include/linux/host1x.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * Copyright (c) 2009-2013, NVIDIA Corporation. All rights reserved.
   4  */
   5
   6 #ifndef __LINUX_HOST1X_H
   7 #define __LINUX_HOST1X_H
   8
   9 #include <linux/device.h>
  10 #include <linux/types.h>
  11
  12 enum host1x_class {
  13         HOST1X_CLASS_HOST1X = 0x1,
  14         HOST1X_CLASS_GR2D = 0x51,
  15         HOST1X_CLASS_GR2D_SB = 0x52,
  16         HOST1X_CLASS_VIC = 0x5D,
  17         HOST1X_CLASS_GR3D = 0x60,
  18 };
  19
  20 struct host1x;
  21 struct host1x_client;
  22 struct iommu_group;
  23
  24 u64 host1x_get_dma_mask(struct host1x *host1x);
  25
  26 /**
  27  * struct host1x_client_ops - host1x client operations
  28  * @init: host1x client initialization code
  29  * @exit: host1x client tear down code
  30  * @suspend: host1x client suspend code
  31  * @resume: host1x client resume code
  32  */
  33 struct host1x_client_ops {
  34         int (*init)(struct host1x_client *client);
  35         int (*exit)(struct host1x_client *client);
  36         int (*suspend)(struct host1x_client *client);
  37         int (*resume)(struct host1x_client *client);
  38 };
  39
  40 /**
  41  * struct host1x_client - host1x client structure
  42  * @list: list node for the host1x client
  43  * @host: pointer to struct device representing the host1x controller
  44  * @dev: pointer to struct device backing this host1x client
  45  * @group: IOMMU group that this client is a member of
  46  * @ops: host1x client operations
  47  * @class: host1x class represented by this client
  48  * @channel: host1x channel associated with this client
  49  * @syncpts: array of syncpoints requested for this client
  50  * @num_syncpts: number of syncpoints requested for this client
  51  * @parent: pointer to parent structure
  52  * @usecount: reference count for this structure
  53  * @lock: mutex for mutually exclusive concurrency
  54  */
  55 struct host1x_client {
  56         struct list_head list;
  57         struct device *host;
  58         struct device *dev;
  59         struct iommu_group *group;
  60
  61         const struct host1x_client_ops *ops;
  62
  63         enum host1x_class class;
  64         struct host1x_channel *channel;
  65
  66         struct host1x_syncpt **syncpts;
  67         unsigned int num_syncpts;
  68
  69         struct host1x_client *parent;
  70         unsigned int usecount;
  71         struct mutex lock;
  72 };
  73
  74 /*
  75  * host1x buffer objects
  76  */
  77
  78 struct host1x_bo;
  79 struct sg_table;
  80
  81 struct host1x_bo_ops {
  82         struct host1x_bo *(*get)(struct host1x_bo *bo);
  83         void (*put)(struct host1x_bo *bo);
  84         struct sg_table *(*pin)(struct device *dev, struct host1x_bo *bo,
  85                                 dma_addr_t *phys);
  86         void (*unpin)(struct device *dev, struct sg_table *sgt);
  87         void *(*mmap)(struct host1x_bo *bo);
  88         void (*munmap)(struct host1x_bo *bo, void *addr);
  89 };
  90
  91 struct host1x_bo {
  92         const struct host1x_bo_ops *ops;
  93 };
  94
  95 static inline void host1x_bo_init(struct host1x_bo *bo,
  96                                   const struct host1x_bo_ops *ops)
  97 {
  98         bo->ops = ops;
  99 }
 100
 101 static inline struct host1x_bo *host1x_bo_get(struct host1x_bo *bo)
 102 {
 103         return bo->ops->get(bo);
 104 }
 105
 106 static inline void host1x_bo_put(struct host1x_bo *bo)
 107 {
 108         bo->ops->put(bo);
 109 }
 110
 111 static inline struct sg_table *host1x_bo_pin(struct device *dev,
 112                                              struct host1x_bo *bo,
 113                                              dma_addr_t *phys)
 114 {
 115         return bo->ops->pin(dev, bo, phys);
 116 }
 117
 118 static inline void host1x_bo_unpin(struct device *dev, struct host1x_bo *bo,
 119                                    struct sg_table *sgt)
 120 {
 121         bo->ops->unpin(dev, sgt);
 122 }
 123
 124 static inline void *host1x_bo_mmap(struct host1x_bo *bo)
 125 {
 126         return bo->ops->mmap(bo);
 127 }
 128
 129 static inline void host1x_bo_munmap(struct host1x_bo *bo, void *addr)
 130 {
 131         bo->ops->munmap(bo, addr);
 132 }
 133
 134 /*
 135  * host1x syncpoints
 136  */
 137
 138 #define HOST1X_SYNCPT_CLIENT_MANAGED    (1 << 0)
 139 #define HOST1X_SYNCPT_HAS_BASE          (1 << 1)
 140
 141 struct host1x_syncpt_base;
 142 struct host1x_syncpt;
 143 struct host1x;
 144
 145 struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, u32 id);
 146 u32 host1x_syncpt_id(struct host1x_syncpt *sp);
 147 u32 host1x_syncpt_read_min(struct host1x_syncpt *sp);
 148 u32 host1x_syncpt_read_max(struct host1x_syncpt *sp);
 149 u32 host1x_syncpt_read(struct host1x_syncpt *sp);
 150 int host1x_syncpt_incr(struct host1x_syncpt *sp);
 151 u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs);
 152 int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
 153                        u32 *value);
 154 struct host1x_syncpt *host1x_syncpt_request(struct host1x_client *client,
 155                                             unsigned long flags);
 156 void host1x_syncpt_free(struct host1x_syncpt *sp);
 157
 158 struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp);
 159 u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base);
 160
 161 /*
 162  * host1x channel
 163  */
 164
 165 struct host1x_channel;
 166 struct host1x_job;
 167
 168 struct host1x_channel *host1x_channel_request(struct host1x_client *client);
 169 struct host1x_channel *host1x_channel_get(struct host1x_channel *channel);
 170 void host1x_channel_put(struct host1x_channel *channel);
 171 int host1x_job_submit(struct host1x_job *job);
 172
 173 /*
 174  * host1x job
 175  */
 176
 177 #define HOST1X_RELOC_READ       (1 << 0)
 178 #define HOST1X_RELOC_WRITE      (1 << 1)
 179
 180 struct host1x_reloc {
 181         struct {
 182                 struct host1x_bo *bo;
 183                 unsigned long offset;
 184         } cmdbuf;
 185         struct {
 186                 struct host1x_bo *bo;
 187                 unsigned long offset;
 188         } target;
 189         unsigned long shift;
 190         unsigned long flags;
 191 };
 192
 193 struct host1x_job {
 194         /* When refcount goes to zero, job can be freed */
 195         struct kref ref;
 196
 197         /* List entry */
 198         struct list_head list;
 199
 200         /* Channel where job is submitted to */
 201         struct host1x_channel *channel;
 202
 203         /* client where the job originated */
 204         struct host1x_client *client;
 205
 206         /* Gathers and their memory */
 207         struct host1x_job_gather *gathers;
 208         unsigned int num_gathers;
 209
 210         /* Array of handles to be pinned & unpinned */
 211         struct host1x_reloc *relocs;
 212         unsigned int num_relocs;
 213         struct host1x_job_unpin_data *unpins;
 214         unsigned int num_unpins;
 215
 216         dma_addr_t *addr_phys;
 217         dma_addr_t *gather_addr_phys;
 218         dma_addr_t *reloc_addr_phys;
 219
 220         /* Sync point id, number of increments and end related to the submit */
 221         u32 syncpt_id;
 222         u32 syncpt_incrs;
 223         u32 syncpt_end;
 224
 225         /* Maximum time to wait for this job */
 226         unsigned int timeout;
 227
 228         /* Index and number of slots used in the push buffer */
 229         unsigned int first_get;
 230         unsigned int num_slots;
 231
 232         /* Copy of gathers */
 233         size_t gather_copy_size;
 234         dma_addr_t gather_copy;
 235         u8 *gather_copy_mapped;
 236
 237         /* Check if register is marked as an address reg */
 238         int (*is_addr_reg)(struct device *dev, u32 class, u32 reg);
 239
 240         /* Check if class belongs to the unit */
 241         int (*is_valid_class)(u32 class);
 242
 243         /* Request a SETCLASS to this class */
 244         u32 class;
 245
 246         /* Add a channel wait for previous ops to complete */
 247         bool serialize;
 248 };
 249
 250 struct host1x_job *host1x_job_alloc(struct host1x_channel *ch,
 251                                     u32 num_cmdbufs, u32 num_relocs);
 252 void host1x_job_add_gather(struct host1x_job *job, struct host1x_bo *bo,
 253                            unsigned int words, unsigned int offset);
 254 struct host1x_job *host1x_job_get(struct host1x_job *job);
 255 void host1x_job_put(struct host1x_job *job);
 256 int host1x_job_pin(struct host1x_job *job, struct device *dev);
 257 void host1x_job_unpin(struct host1x_job *job);
 258
 259 /*
 260  * subdevice probe infrastructure
 261  */
 262
 263 struct host1x_device;
 264
 265 /**
 266  * struct host1x_driver - host1x logical device driver
 267  * @driver: core driver
 268  * @subdevs: table of OF device IDs matching subdevices for this driver
 269  * @list: list node for the driver
 270  * @probe: called when the host1x logical device is probed
 271  * @remove: called when the host1x logical device is removed
 272  * @shutdown: called when the host1x logical device is shut down
 273  */
 274 struct host1x_driver {
 275         struct device_driver driver;
 276
 277         const struct of_device_id *subdevs;
 278         struct list_head list;
 279
 280         int (*probe)(struct host1x_device *device);
 281         int (*remove)(struct host1x_device *device);
 282         void (*shutdown)(struct host1x_device *device);
 283 };
 284
 285 static inline struct host1x_driver *
 286 to_host1x_driver(struct device_driver *driver)
 287 {
 288         return container_of(driver, struct host1x_driver, driver);
 289 }
 290
 291 int host1x_driver_register_full(struct host1x_driver *driver,
 292                                 struct module *owner);
 293 void host1x_driver_unregister(struct host1x_driver *driver);
 294
 295 #define host1x_driver_register(driver) \
 296         host1x_driver_register_full(driver, THIS_MODULE)
 297
 298 struct host1x_device {
 299         struct host1x_driver *driver;
 300         struct list_head list;
 301         struct device dev;
 302
 303         struct mutex subdevs_lock;
 304         struct list_head subdevs;
 305         struct list_head active;
 306
 307         struct mutex clients_lock;
 308         struct list_head clients;
 309
 310         bool registered;
 311
 312         struct device_dma_parameters dma_parms;
 313 };
 314
 315 static inline struct host1x_device *to_host1x_device(struct device *dev)
 316 {
 317         return container_of(dev, struct host1x_device, dev);
 318 }
 319
 320 int host1x_device_init(struct host1x_device *device);
 321 int host1x_device_exit(struct host1x_device *device);
 322
 323 int host1x_client_register(struct host1x_client *client);
 324 int host1x_client_unregister(struct host1x_client *client);
 325
 326 int host1x_client_suspend(struct host1x_client *client);
 327 int host1x_client_resume(struct host1x_client *client);
 328
 329 struct tegra_mipi_device;
 330
 331 struct tegra_mipi_device *tegra_mipi_request(struct device *device,
 332                                              struct device_node *np);
 333 void tegra_mipi_free(struct tegra_mipi_device *device);
 334 int tegra_mipi_enable(struct tegra_mipi_device *device);
 335 int tegra_mipi_disable(struct tegra_mipi_device *device);
 336 int tegra_mipi_start_calibration(struct tegra_mipi_device *device);
 337 int tegra_mipi_finish_calibration(struct tegra_mipi_device *device);
 338
 339 #endif