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