| /* SPDX-License-Identifier: GPL-2.0-or-later */ |
| /* |
| * Copyright (c) 2009-2013, NVIDIA Corporation. All rights reserved. |
| */ |
| |
| #ifndef __LINUX_HOST1X_H |
| #define __LINUX_HOST1X_H |
| |
| #include <linux/device.h> |
| #include <linux/types.h> |
| |
| enum host1x_class { |
| HOST1X_CLASS_HOST1X = 0x1, |
| HOST1X_CLASS_GR2D = 0x51, |
| HOST1X_CLASS_GR2D_SB = 0x52, |
| HOST1X_CLASS_VIC = 0x5D, |
| HOST1X_CLASS_GR3D = 0x60, |
| }; |
| |
| struct host1x; |
| struct host1x_client; |
| struct iommu_group; |
| |
| u64 host1x_get_dma_mask(struct host1x *host1x); |
| |
| /** |
| * struct host1x_client_ops - host1x client operations |
| * @init: host1x client initialization code |
| * @exit: host1x client tear down code |
| * @suspend: host1x client suspend code |
| * @resume: host1x client resume code |
| */ |
| struct host1x_client_ops { |
| int (*init)(struct host1x_client *client); |
| int (*exit)(struct host1x_client *client); |
| int (*suspend)(struct host1x_client *client); |
| int (*resume)(struct host1x_client *client); |
| }; |
| |
| /** |
| * struct host1x_client - host1x client structure |
| * @list: list node for the host1x client |
| * @host: pointer to struct device representing the host1x controller |
| * @dev: pointer to struct device backing this host1x client |
| * @group: IOMMU group that this client is a member of |
| * @ops: host1x client operations |
| * @class: host1x class represented by this client |
| * @channel: host1x channel associated with this client |
| * @syncpts: array of syncpoints requested for this client |
| * @num_syncpts: number of syncpoints requested for this client |
| * @parent: pointer to parent structure |
| * @usecount: reference count for this structure |
| * @lock: mutex for mutually exclusive concurrency |
| */ |
| struct host1x_client { |
| struct list_head list; |
| struct device *host; |
| struct device *dev; |
| struct iommu_group *group; |
| |
| const struct host1x_client_ops *ops; |
| |
| enum host1x_class class; |
| struct host1x_channel *channel; |
| |
| struct host1x_syncpt **syncpts; |
| unsigned int num_syncpts; |
| |
| struct host1x_client *parent; |
| unsigned int usecount; |
| struct mutex lock; |
| }; |
| |
| /* |
| * host1x buffer objects |
| */ |
| |
| struct host1x_bo; |
| struct sg_table; |
| |
| struct host1x_bo_ops { |
| struct host1x_bo *(*get)(struct host1x_bo *bo); |
| void (*put)(struct host1x_bo *bo); |
| struct sg_table *(*pin)(struct device *dev, struct host1x_bo *bo, |
| dma_addr_t *phys); |
| void (*unpin)(struct device *dev, struct sg_table *sgt); |
| void *(*mmap)(struct host1x_bo *bo); |
| void (*munmap)(struct host1x_bo *bo, void *addr); |
| }; |
| |
| struct host1x_bo { |
| const struct host1x_bo_ops *ops; |
| }; |
| |
| static inline void host1x_bo_init(struct host1x_bo *bo, |
| const struct host1x_bo_ops *ops) |
| { |
| bo->ops = ops; |
| } |
| |
| static inline struct host1x_bo *host1x_bo_get(struct host1x_bo *bo) |
| { |
| return bo->ops->get(bo); |
| } |
| |
| static inline void host1x_bo_put(struct host1x_bo *bo) |
| { |
| bo->ops->put(bo); |
| } |
| |
| static inline struct sg_table *host1x_bo_pin(struct device *dev, |
| struct host1x_bo *bo, |
| dma_addr_t *phys) |
| { |
| return bo->ops->pin(dev, bo, phys); |
| } |
| |
| static inline void host1x_bo_unpin(struct device *dev, struct host1x_bo *bo, |
| struct sg_table *sgt) |
| { |
| bo->ops->unpin(dev, sgt); |
| } |
| |
| static inline void *host1x_bo_mmap(struct host1x_bo *bo) |
| { |
| return bo->ops->mmap(bo); |
| } |
| |
| static inline void host1x_bo_munmap(struct host1x_bo *bo, void *addr) |
| { |
| bo->ops->munmap(bo, addr); |
| } |
| |
| /* |
| * host1x syncpoints |
| */ |
| |
| #define HOST1X_SYNCPT_CLIENT_MANAGED (1 << 0) |
| #define HOST1X_SYNCPT_HAS_BASE (1 << 1) |
| |
| struct host1x_syncpt_base; |
| struct host1x_syncpt; |
| struct host1x; |
| |
| struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, u32 id); |
| u32 host1x_syncpt_id(struct host1x_syncpt *sp); |
| u32 host1x_syncpt_read_min(struct host1x_syncpt *sp); |
| u32 host1x_syncpt_read_max(struct host1x_syncpt *sp); |
| u32 host1x_syncpt_read(struct host1x_syncpt *sp); |
| int host1x_syncpt_incr(struct host1x_syncpt *sp); |
| u32 host1x_syncpt_incr_max(struct host1x_syncpt *sp, u32 incrs); |
| int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout, |
| u32 *value); |
| struct host1x_syncpt *host1x_syncpt_request(struct host1x_client *client, |
| unsigned long flags); |
| void host1x_syncpt_free(struct host1x_syncpt *sp); |
| |
| struct host1x_syncpt_base *host1x_syncpt_get_base(struct host1x_syncpt *sp); |
| u32 host1x_syncpt_base_id(struct host1x_syncpt_base *base); |
| |
| /* |
| * host1x channel |
| */ |
| |
| struct host1x_channel; |
| struct host1x_job; |
| |
| struct host1x_channel *host1x_channel_request(struct host1x_client *client); |
| struct host1x_channel *host1x_channel_get(struct host1x_channel *channel); |
| void host1x_channel_put(struct host1x_channel *channel); |
| int host1x_job_submit(struct host1x_job *job); |
| |
| /* |
| * host1x job |
| */ |
| |
| #define HOST1X_RELOC_READ (1 << 0) |
| #define HOST1X_RELOC_WRITE (1 << 1) |
| |
| struct host1x_reloc { |
| struct { |
| struct host1x_bo *bo; |
| unsigned long offset; |
| } cmdbuf; |
| struct { |
| struct host1x_bo *bo; |
| unsigned long offset; |
| } target; |
| unsigned long shift; |
| unsigned long flags; |
| }; |
| |
| struct host1x_job { |
| /* When refcount goes to zero, job can be freed */ |
| struct kref ref; |
| |
| /* List entry */ |
| struct list_head list; |
| |
| /* Channel where job is submitted to */ |
| struct host1x_channel *channel; |
| |
| /* client where the job originated */ |
| struct host1x_client *client; |
| |
| /* Gathers and their memory */ |
| struct host1x_job_gather *gathers; |
| unsigned int num_gathers; |
| |
| /* Array of handles to be pinned & unpinned */ |
| struct host1x_reloc *relocs; |
| unsigned int num_relocs; |
| struct host1x_job_unpin_data *unpins; |
| unsigned int num_unpins; |
| |
| dma_addr_t *addr_phys; |
| dma_addr_t *gather_addr_phys; |
| dma_addr_t *reloc_addr_phys; |
| |
| /* Sync point id, number of increments and end related to the submit */ |
| u32 syncpt_id; |
| u32 syncpt_incrs; |
| u32 syncpt_end; |
| |
| /* Maximum time to wait for this job */ |
| unsigned int timeout; |
| |
| /* Index and number of slots used in the push buffer */ |
| unsigned int first_get; |
| unsigned int num_slots; |
| |
| /* Copy of gathers */ |
| size_t gather_copy_size; |
| dma_addr_t gather_copy; |
| u8 *gather_copy_mapped; |
| |
| /* Check if register is marked as an address reg */ |
| int (*is_addr_reg)(struct device *dev, u32 class, u32 reg); |
| |
| /* Check if class belongs to the unit */ |
| int (*is_valid_class)(u32 class); |
| |
| /* Request a SETCLASS to this class */ |
| u32 class; |
| |
| /* Add a channel wait for previous ops to complete */ |
| bool serialize; |
| }; |
| |
| struct host1x_job *host1x_job_alloc(struct host1x_channel *ch, |
| u32 num_cmdbufs, u32 num_relocs); |
| void host1x_job_add_gather(struct host1x_job *job, struct host1x_bo *bo, |
| unsigned int words, unsigned int offset); |
| struct host1x_job *host1x_job_get(struct host1x_job *job); |
| void host1x_job_put(struct host1x_job *job); |
| int host1x_job_pin(struct host1x_job *job, struct device *dev); |
| void host1x_job_unpin(struct host1x_job *job); |
| |
| /* |
| * subdevice probe infrastructure |
| */ |
| |
| struct host1x_device; |
| |
| /** |
| * struct host1x_driver - host1x logical device driver |
| * @driver: core driver |
| * @subdevs: table of OF device IDs matching subdevices for this driver |
| * @list: list node for the driver |
| * @probe: called when the host1x logical device is probed |
| * @remove: called when the host1x logical device is removed |
| * @shutdown: called when the host1x logical device is shut down |
| */ |
| struct host1x_driver { |
| struct device_driver driver; |
| |
| const struct of_device_id *subdevs; |
| struct list_head list; |
| |
| int (*probe)(struct host1x_device *device); |
| int (*remove)(struct host1x_device *device); |
| void (*shutdown)(struct host1x_device *device); |
| }; |
| |
| static inline struct host1x_driver * |
| to_host1x_driver(struct device_driver *driver) |
| { |
| return container_of(driver, struct host1x_driver, driver); |
| } |
| |
| int host1x_driver_register_full(struct host1x_driver *driver, |
| struct module *owner); |
| void host1x_driver_unregister(struct host1x_driver *driver); |
| |
| #define host1x_driver_register(driver) \ |
| host1x_driver_register_full(driver, THIS_MODULE) |
| |
| struct host1x_device { |
| struct host1x_driver *driver; |
| struct list_head list; |
| struct device dev; |
| |
| struct mutex subdevs_lock; |
| struct list_head subdevs; |
| struct list_head active; |
| |
| struct mutex clients_lock; |
| struct list_head clients; |
| |
| bool registered; |
| |
| struct device_dma_parameters dma_parms; |
| }; |
| |
| static inline struct host1x_device *to_host1x_device(struct device *dev) |
| { |
| return container_of(dev, struct host1x_device, dev); |
| } |
| |
| int host1x_device_init(struct host1x_device *device); |
| int host1x_device_exit(struct host1x_device *device); |
| |
| int host1x_client_register(struct host1x_client *client); |
| int host1x_client_unregister(struct host1x_client *client); |
| |
| int host1x_client_suspend(struct host1x_client *client); |
| int host1x_client_resume(struct host1x_client *client); |
| |
| struct tegra_mipi_device; |
| |
| struct tegra_mipi_device *tegra_mipi_request(struct device *device, |
| struct device_node *np); |
| void tegra_mipi_free(struct tegra_mipi_device *device); |
| int tegra_mipi_enable(struct tegra_mipi_device *device); |
| int tegra_mipi_disable(struct tegra_mipi_device *device); |
| int tegra_mipi_start_calibration(struct tegra_mipi_device *device); |
| int tegra_mipi_finish_calibration(struct tegra_mipi_device *device); |
| |
| #endif |