drivers/gpu/drm/arm/display/komeda/komeda_dev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * (C) COPYRIGHT 2018 ARM Limited. All rights reserved.
   4  * Author: James.Qian.Wang <james.qian.wang@arm.com>
   5  *
   6  */
   7 #include <linux/io.h>
   8 #include <linux/iommu.h>
   9 #include <linux/of_device.h>
  10 #include <linux/of_graph.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/dma-mapping.h>
  13 #ifdef CONFIG_DEBUG_FS
  14 #include <linux/debugfs.h>
  15 #include <linux/seq_file.h>
  16 #endif
  17
  18 #include <drm/drm_print.h>
  19
  20 #include "komeda_dev.h"
  21
  22 static int komeda_register_show(struct seq_file *sf, void *x)
  23 {
  24         struct komeda_dev *mdev = sf->private;
  25         int i;
  26
  27         if (mdev->funcs->dump_register)
  28                 mdev->funcs->dump_register(mdev, sf);
  29
  30         for (i = 0; i < mdev->n_pipelines; i++)
  31                 komeda_pipeline_dump_register(mdev->pipelines[i], sf);
  32
  33         return 0;
  34 }
  35
  36 static int komeda_register_open(struct inode *inode, struct file *filp)
  37 {
  38         return single_open(filp, komeda_register_show, inode->i_private);
  39 }
  40
  41 static const struct file_operations komeda_register_fops = {
  42         .owner          = THIS_MODULE,
  43         .open           = komeda_register_open,
  44         .read           = seq_read,
  45         .llseek         = seq_lseek,
  46         .release        = single_release,
  47 };
  48
  49 #ifdef CONFIG_DEBUG_FS
  50 static void komeda_debugfs_init(struct komeda_dev *mdev)
  51 {
  52         if (!debugfs_initialized())
  53                 return;
  54
  55         mdev->debugfs_root = debugfs_create_dir("komeda", NULL);
  56         if (IS_ERR_OR_NULL(mdev->debugfs_root))
  57                 return;
  58
  59         debugfs_create_file("register", 0444, mdev->debugfs_root,
  60                             mdev, &komeda_register_fops);
  61 }
  62 #endif
  63
  64 static ssize_t
  65 core_id_show(struct device *dev, struct device_attribute *attr, char *buf)
  66 {
  67         struct komeda_dev *mdev = dev_to_mdev(dev);
  68
  69         return snprintf(buf, PAGE_SIZE, "0x%08x\n", mdev->chip.core_id);
  70 }
  71 static DEVICE_ATTR_RO(core_id);
  72
  73 static ssize_t
  74 config_id_show(struct device *dev, struct device_attribute *attr, char *buf)
  75 {
  76         struct komeda_dev *mdev = dev_to_mdev(dev);
  77         struct komeda_pipeline *pipe = mdev->pipelines[0];
  78         union komeda_config_id config_id;
  79         int i;
  80
  81         memset(&config_id, 0, sizeof(config_id));
  82
  83         config_id.max_line_sz = pipe->layers[0]->hsize_in.end;
  84         config_id.n_pipelines = mdev->n_pipelines;
  85         config_id.n_scalers = pipe->n_scalers;
  86         config_id.n_layers = pipe->n_layers;
  87         config_id.n_richs = 0;
  88         for (i = 0; i < pipe->n_layers; i++) {
  89                 if (pipe->layers[i]->layer_type == KOMEDA_FMT_RICH_LAYER)
  90                         config_id.n_richs++;
  91         }
  92         return snprintf(buf, PAGE_SIZE, "0x%08x\n", config_id.value);
  93 }
  94 static DEVICE_ATTR_RO(config_id);
  95
  96 static struct attribute *komeda_sysfs_entries[] = {
  97         &dev_attr_core_id.attr,
  98         &dev_attr_config_id.attr,
  99         NULL,
 100 };
 101
 102 static struct attribute_group komeda_sysfs_attr_group = {
 103         .attrs = komeda_sysfs_entries,
 104 };
 105
 106 static int komeda_parse_pipe_dt(struct komeda_dev *mdev, struct device_node *np)
 107 {
 108         struct komeda_pipeline *pipe;
 109         struct clk *clk;
 110         u32 pipe_id;
 111         int ret = 0;
 112
 113         ret = of_property_read_u32(np, "reg", &pipe_id);
 114         if (ret != 0 || pipe_id >= mdev->n_pipelines)
 115                 return -EINVAL;
 116
 117         pipe = mdev->pipelines[pipe_id];
 118
 119         clk = of_clk_get_by_name(np, "pxclk");
 120         if (IS_ERR(clk)) {
 121                 DRM_ERROR("get pxclk for pipeline %d failed!\n", pipe_id);
 122                 return PTR_ERR(clk);
 123         }
 124         pipe->pxlclk = clk;
 125
 126         /* enum ports */
 127         pipe->of_output_dev =
 128                 of_graph_get_remote_node(np, KOMEDA_OF_PORT_OUTPUT, 0);
 129         pipe->of_output_port =
 130                 of_graph_get_port_by_id(np, KOMEDA_OF_PORT_OUTPUT);
 131
 132         pipe->of_node = np;
 133
 134         return 0;
 135 }
 136
 137 static int komeda_parse_dt(struct device *dev, struct komeda_dev *mdev)
 138 {
 139         struct platform_device *pdev = to_platform_device(dev);
 140         struct device_node *child, *np = dev->of_node;
 141         int ret;
 142
 143         mdev->irq  = platform_get_irq(pdev, 0);
 144         if (mdev->irq < 0) {
 145                 DRM_ERROR("could not get IRQ number.\n");
 146                 return mdev->irq;
 147         }
 148
 149         for_each_available_child_of_node(np, child) {
 150                 if (of_node_cmp(child->name, "pipeline") == 0) {
 151                         ret = komeda_parse_pipe_dt(mdev, child);
 152                         if (ret) {
 153                                 DRM_ERROR("parse pipeline dt error!\n");
 154                                 of_node_put(child);
 155                                 break;
 156                         }
 157                 }
 158         }
 159
 160         return ret;
 161 }
 162
 163 struct komeda_dev *komeda_dev_create(struct device *dev)
 164 {
 165         struct platform_device *pdev = to_platform_device(dev);
 166         const struct komeda_product_data *product;
 167         struct komeda_dev *mdev;
 168         struct resource *io_res;
 169         int err = 0;
 170
 171         product = of_device_get_match_data(dev);
 172         if (!product)
 173                 return ERR_PTR(-ENODEV);
 174
 175         io_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 176         if (!io_res) {
 177                 DRM_ERROR("No registers defined.\n");
 178                 return ERR_PTR(-ENODEV);
 179         }
 180
 181         mdev = devm_kzalloc(dev, sizeof(*mdev), GFP_KERNEL);
 182         if (!mdev)
 183                 return ERR_PTR(-ENOMEM);
 184
 185         mutex_init(&mdev->lock);
 186
 187         mdev->dev = dev;
 188         mdev->reg_base = devm_ioremap_resource(dev, io_res);
 189         if (IS_ERR(mdev->reg_base)) {
 190                 DRM_ERROR("Map register space failed.\n");
 191                 err = PTR_ERR(mdev->reg_base);
 192                 mdev->reg_base = NULL;
 193                 goto err_cleanup;
 194         }
 195
 196         mdev->aclk = devm_clk_get(dev, "aclk");
 197         if (IS_ERR(mdev->aclk)) {
 198                 DRM_ERROR("Get engine clk failed.\n");
 199                 err = PTR_ERR(mdev->aclk);
 200                 mdev->aclk = NULL;
 201                 goto err_cleanup;
 202         }
 203
 204         clk_prepare_enable(mdev->aclk);
 205
 206         mdev->funcs = product->identify(mdev->reg_base, &mdev->chip);
 207         if (!komeda_product_match(mdev, product->product_id)) {
 208                 DRM_ERROR("DT configured %x mismatch with real HW %x.\n",
 209                           product->product_id,
 210                           MALIDP_CORE_ID_PRODUCT_ID(mdev->chip.core_id));
 211                 err = -ENODEV;
 212                 goto err_cleanup;
 213         }
 214
 215         DRM_INFO("Found ARM Mali-D%x version r%dp%d\n",
 216                  MALIDP_CORE_ID_PRODUCT_ID(mdev->chip.core_id),
 217                  MALIDP_CORE_ID_MAJOR(mdev->chip.core_id),
 218                  MALIDP_CORE_ID_MINOR(mdev->chip.core_id));
 219
 220         mdev->funcs->init_format_table(mdev);
 221
 222         err = mdev->funcs->enum_resources(mdev);
 223         if (err) {
 224                 DRM_ERROR("enumerate display resource failed.\n");
 225                 goto err_cleanup;
 226         }
 227
 228         err = komeda_parse_dt(dev, mdev);
 229         if (err) {
 230                 DRM_ERROR("parse device tree failed.\n");
 231                 goto err_cleanup;
 232         }
 233
 234         err = komeda_assemble_pipelines(mdev);
 235         if (err) {
 236                 DRM_ERROR("assemble display pipelines failed.\n");
 237                 goto err_cleanup;
 238         }
 239
 240         dev->dma_parms = &mdev->dma_parms;
 241         dma_set_max_seg_size(dev, DMA_BIT_MASK(32));
 242
 243         mdev->iommu = iommu_get_domain_for_dev(mdev->dev);
 244         if (!mdev->iommu)
 245                 DRM_INFO("continue without IOMMU support!\n");
 246
 247         if (mdev->iommu && mdev->funcs->connect_iommu) {
 248                 err = mdev->funcs->connect_iommu(mdev);
 249                 if (err) {
 250                         mdev->iommu = NULL;
 251                         goto err_cleanup;
 252                 }
 253         }
 254
 255         err = sysfs_create_group(&dev->kobj, &komeda_sysfs_attr_group);
 256         if (err) {
 257                 DRM_ERROR("create sysfs group failed.\n");
 258                 goto err_cleanup;
 259         }
 260
 261 #ifdef CONFIG_DEBUG_FS
 262         komeda_debugfs_init(mdev);
 263 #endif
 264
 265         return mdev;
 266
 267 err_cleanup:
 268         komeda_dev_destroy(mdev);
 269         return ERR_PTR(err);
 270 }
 271
 272 void komeda_dev_destroy(struct komeda_dev *mdev)
 273 {
 274         struct device *dev = mdev->dev;
 275         const struct komeda_dev_funcs *funcs = mdev->funcs;
 276         int i;
 277
 278         sysfs_remove_group(&dev->kobj, &komeda_sysfs_attr_group);
 279
 280 #ifdef CONFIG_DEBUG_FS
 281         debugfs_remove_recursive(mdev->debugfs_root);
 282 #endif
 283
 284         if (mdev->iommu && mdev->funcs->disconnect_iommu)
 285                 mdev->funcs->disconnect_iommu(mdev);
 286         mdev->iommu = NULL;
 287
 288         for (i = 0; i < mdev->n_pipelines; i++) {
 289                 komeda_pipeline_destroy(mdev, mdev->pipelines[i]);
 290                 mdev->pipelines[i] = NULL;
 291         }
 292
 293         mdev->n_pipelines = 0;
 294
 295         if (funcs && funcs->cleanup)
 296                 funcs->cleanup(mdev);
 297
 298         if (mdev->reg_base) {
 299                 devm_iounmap(dev, mdev->reg_base);
 300                 mdev->reg_base = NULL;
 301         }
 302
 303         if (mdev->aclk) {
 304                 clk_disable_unprepare(mdev->aclk);
 305                 devm_clk_put(dev, mdev->aclk);
 306                 mdev->aclk = NULL;
 307         }
 308
 309         devm_kfree(dev, mdev);
 310 }