| #ifndef __NVKM_GSP_H__ | |
| #define __NVKM_GSP_H__ | |
| #define nvkm_gsp(p) container_of((p), struct nvkm_gsp, subdev) | |
| #include <core/subdev.h> | |
| #include <core/falcon.h> | |
| #include <core/firmware.h> | |
| #include <linux/debugfs.h> | |
| #define GSP_PAGE_SHIFT 12 | |
| #define GSP_PAGE_SIZE BIT(GSP_PAGE_SHIFT) | |
| struct nvkm_gsp_mem { | |
| struct device *dev; | |
| size_t size; | |
| void *data; | |
| dma_addr_t addr; | |
| }; | |
| int nvkm_gsp_mem_ctor(struct nvkm_gsp *, size_t size, struct nvkm_gsp_mem *); | |
| void nvkm_gsp_mem_dtor(struct nvkm_gsp_mem *); | |
| struct nvkm_gsp_radix3 { | |
| struct nvkm_gsp_mem lvl0; | |
| struct nvkm_gsp_mem lvl1; | |
| struct sg_table lvl2; | |
| }; | |
| int nvkm_gsp_sg(struct nvkm_device *, u64 size, struct sg_table *); | |
| void nvkm_gsp_sg_free(struct nvkm_device *, struct sg_table *); | |
| typedef int (*nvkm_gsp_msg_ntfy_func)(void *priv, u32 fn, void *repv, u32 repc); | |
| struct nvkm_gsp_event; | |
| typedef void (*nvkm_gsp_event_func)(struct nvkm_gsp_event *, void *repv, u32 repc); | |
| /** | |
| * DOC: GSP message handling policy | |
| * | |
| * When sending a GSP RPC command, there can be multiple cases of handling | |
| * the GSP RPC messages, which are the reply of GSP RPC commands, according | |
| * to the requirement of the callers and the nature of the GSP RPC commands. | |
| * | |
| * NVKM_GSP_RPC_REPLY_NOWAIT - If specified, immediately return to the | |
| * caller after the GSP RPC command is issued. | |
| * | |
| * NVKM_GSP_RPC_REPLY_NOSEQ - If specified, exactly like NOWAIT | |
| * but don't emit RPC sequence number. | |
| * | |
| * NVKM_GSP_RPC_REPLY_RECV - If specified, wait and receive the entire GSP | |
| * RPC message after the GSP RPC command is issued. | |
| * | |
| * NVKM_GSP_RPC_REPLY_POLL - If specified, wait for the specific reply and | |
| * discard the reply before returning to the caller. | |
| * | |
| */ | |
| enum nvkm_gsp_rpc_reply_policy { | |
| NVKM_GSP_RPC_REPLY_NOWAIT = 0, | |
| NVKM_GSP_RPC_REPLY_NOSEQ, | |
| NVKM_GSP_RPC_REPLY_RECV, | |
| NVKM_GSP_RPC_REPLY_POLL, | |
| }; | |
| struct nvkm_gsp { | |
| const struct nvkm_gsp_func *func; | |
| struct nvkm_subdev subdev; | |
| struct nvkm_falcon falcon; | |
| struct { | |
| struct { | |
| const struct firmware *load; | |
| const struct firmware *unload; | |
| } booter; | |
| const struct firmware *fmc; | |
| const struct firmware *bl; | |
| const struct firmware *rm; | |
| struct { | |
| struct nvkm_falcon_fw sb; | |
| } falcon; | |
| } fws; | |
| struct nvkm_firmware fw; | |
| struct nvkm_gsp_mem sig; | |
| struct nvkm_gsp_radix3 radix3; | |
| struct { | |
| struct { | |
| struct { | |
| u64 addr; | |
| u64 size; | |
| } vga_workspace; | |
| u64 addr; | |
| u64 size; | |
| } bios; | |
| struct { | |
| struct { | |
| u64 addr; | |
| u64 size; | |
| } frts, boot, elf, heap; | |
| u64 addr; | |
| u64 size; | |
| } wpr2; | |
| struct { | |
| u64 addr; | |
| u64 size; | |
| } heap; | |
| u64 addr; | |
| u64 size; | |
| struct { | |
| u64 addr; | |
| u64 size; | |
| } region[16]; | |
| int region_nr; | |
| u32 rsvd_size; | |
| } fb; | |
| struct { | |
| struct nvkm_falcon_fw load; | |
| struct nvkm_falcon_fw unload; | |
| } booter; | |
| struct { | |
| struct nvkm_gsp_mem fw; | |
| u8 *hash; | |
| u8 *pkey; | |
| u8 *sig; | |
| struct nvkm_gsp_mem args; | |
| } fmc; | |
| struct { | |
| struct nvkm_gsp_mem fw; | |
| u32 code_offset; | |
| u32 data_offset; | |
| u32 manifest_offset; | |
| u32 app_version; | |
| } boot; | |
| struct nvkm_gsp_mem libos; | |
| struct nvkm_gsp_mem loginit; | |
| struct nvkm_gsp_mem logintr; | |
| struct nvkm_gsp_mem logrm; | |
| struct nvkm_gsp_mem rmargs; | |
| struct nvkm_gsp_mem wpr_meta; | |
| struct { | |
| struct sg_table sgt; | |
| struct nvkm_gsp_radix3 radix3; | |
| struct nvkm_gsp_mem meta; | |
| struct sg_table fbsr; | |
| } sr; | |
| struct { | |
| bool use_raw_mode_comptagline_alloc; | |
| } memsys; | |
| struct { | |
| struct nvkm_gsp_mem mem; | |
| struct { | |
| int nr; | |
| u32 size; | |
| u64 *ptr; | |
| } ptes; | |
| struct { | |
| u32 size; | |
| void *ptr; | |
| } cmdq, msgq; | |
| } shm; | |
| struct nvkm_gsp_cmdq { | |
| struct mutex mutex; | |
| u32 cnt; | |
| u32 seq; | |
| u32 *wptr; | |
| u32 *rptr; | |
| } cmdq; | |
| struct nvkm_gsp_msgq { | |
| struct mutex mutex; | |
| u32 cnt; | |
| u32 *wptr; | |
| u32 *rptr; | |
| struct nvkm_gsp_msgq_ntfy { | |
| u32 fn; | |
| nvkm_gsp_msg_ntfy_func func; | |
| void *priv; | |
| } ntfy[16]; | |
| int ntfy_nr; | |
| struct work_struct work; | |
| } msgq; | |
| bool running; | |
| /* Internal GSP-RM control handles. */ | |
| struct { | |
| struct nvkm_gsp_client { | |
| struct nvkm_gsp_object { | |
| struct nvkm_gsp_client *client; | |
| struct nvkm_gsp_object *parent; | |
| u32 handle; | |
| } object; | |
| struct nvkm_gsp *gsp; | |
| struct list_head events; | |
| } client; | |
| struct nvkm_gsp_device { | |
| struct nvkm_gsp_object object; | |
| struct nvkm_gsp_object subdevice; | |
| } device; | |
| } internal; | |
| struct { | |
| enum nvkm_subdev_type type; | |
| int inst; | |
| u32 stall; | |
| u32 nonstall; | |
| } intr[32]; | |
| int intr_nr; | |
| struct { | |
| u64 rm_bar1_pdb; | |
| u64 rm_bar2_pdb; | |
| } bar; | |
| struct { | |
| u8 gpcs; | |
| u8 tpcs; | |
| } gr; | |
| struct nvkm_rm *rm; | |
| struct { | |
| struct mutex mutex; | |
| struct idr idr; | |
| } client_id; | |
| /* A linked list of registry items. The registry RPC will be built from it. */ | |
| struct list_head registry_list; | |
| /* The size of the registry RPC */ | |
| size_t registry_rpc_size; | |
| u32 rpc_seq; | |
| #ifdef CONFIG_DEBUG_FS | |
| /* | |
| * Logging buffers in debugfs. The wrapper objects need to remain | |
| * in memory until the dentry is deleted. | |
| */ | |
| struct { | |
| struct dentry *parent; | |
| struct dentry *init; | |
| struct dentry *rm; | |
| struct dentry *intr; | |
| struct dentry *pmu; | |
| } debugfs; | |
| struct debugfs_blob_wrapper blob_init; | |
| struct debugfs_blob_wrapper blob_intr; | |
| struct debugfs_blob_wrapper blob_rm; | |
| struct debugfs_blob_wrapper blob_pmu; | |
| #endif | |
| }; | |
| static inline bool | |
| nvkm_gsp_rm(struct nvkm_gsp *gsp) | |
| { | |
| return gsp && (gsp->fws.rm || gsp->fw.img); | |
| } | |
| #include <rm/rm.h> | |
| static inline void * | |
| nvkm_gsp_rpc_get(struct nvkm_gsp *gsp, u32 fn, u32 argc) | |
| { | |
| return gsp->rm->api->rpc->get(gsp, fn, argc); | |
| } | |
| static inline void * | |
| nvkm_gsp_rpc_push(struct nvkm_gsp *gsp, void *argv, | |
| enum nvkm_gsp_rpc_reply_policy policy, u32 repc) | |
| { | |
| return gsp->rm->api->rpc->push(gsp, argv, policy, repc); | |
| } | |
| static inline void * | |
| nvkm_gsp_rpc_rd(struct nvkm_gsp *gsp, u32 fn, u32 argc) | |
| { | |
| void *argv = nvkm_gsp_rpc_get(gsp, fn, argc); | |
| if (IS_ERR_OR_NULL(argv)) | |
| return argv; | |
| return nvkm_gsp_rpc_push(gsp, argv, NVKM_GSP_RPC_REPLY_RECV, argc); | |
| } | |
| static inline int | |
| nvkm_gsp_rpc_wr(struct nvkm_gsp *gsp, void *argv, | |
| enum nvkm_gsp_rpc_reply_policy policy) | |
| { | |
| void *repv = nvkm_gsp_rpc_push(gsp, argv, policy, 0); | |
| if (IS_ERR(repv)) | |
| return PTR_ERR(repv); | |
| return 0; | |
| } | |
| static inline void | |
| nvkm_gsp_rpc_done(struct nvkm_gsp *gsp, void *repv) | |
| { | |
| gsp->rm->api->rpc->done(gsp, repv); | |
| } | |
| static inline void * | |
| nvkm_gsp_rm_ctrl_get(struct nvkm_gsp_object *object, u32 cmd, u32 argc) | |
| { | |
| return object->client->gsp->rm->api->ctrl->get(object, cmd, argc); | |
| } | |
| static inline int | |
| nvkm_gsp_rm_ctrl_push(struct nvkm_gsp_object *object, void *argv, u32 repc) | |
| { | |
| return object->client->gsp->rm->api->ctrl->push(object, argv, repc); | |
| } | |
| static inline void * | |
| nvkm_gsp_rm_ctrl_rd(struct nvkm_gsp_object *object, u32 cmd, u32 repc) | |
| { | |
| void *argv = nvkm_gsp_rm_ctrl_get(object, cmd, repc); | |
| int ret; | |
| if (IS_ERR(argv)) | |
| return argv; | |
| ret = nvkm_gsp_rm_ctrl_push(object, &argv, repc); | |
| if (ret) | |
| return ERR_PTR(ret); | |
| return argv; | |
| } | |
| static inline int | |
| nvkm_gsp_rm_ctrl_wr(struct nvkm_gsp_object *object, void *argv) | |
| { | |
| int ret = nvkm_gsp_rm_ctrl_push(object, &argv, 0); | |
| if (ret) | |
| return ret; | |
| return 0; | |
| } | |
| static inline void | |
| nvkm_gsp_rm_ctrl_done(struct nvkm_gsp_object *object, void *repv) | |
| { | |
| object->client->gsp->rm->api->ctrl->done(object, repv); | |
| } | |
| static inline void * | |
| nvkm_gsp_rm_alloc_get(struct nvkm_gsp_object *parent, u32 handle, u32 oclass, u32 argc, | |
| struct nvkm_gsp_object *object) | |
| { | |
| struct nvkm_gsp_client *client = parent->client; | |
| struct nvkm_gsp *gsp = client->gsp; | |
| void *argv; | |
| object->client = parent->client; | |
| object->parent = parent; | |
| object->handle = handle; | |
| argv = gsp->rm->api->alloc->get(object, oclass, argc); | |
| if (IS_ERR_OR_NULL(argv)) { | |
| object->client = NULL; | |
| return argv; | |
| } | |
| return argv; | |
| } | |
| static inline void * | |
| nvkm_gsp_rm_alloc_push(struct nvkm_gsp_object *object, void *argv) | |
| { | |
| void *repv = object->client->gsp->rm->api->alloc->push(object, argv); | |
| if (IS_ERR(repv)) | |
| object->client = NULL; | |
| return repv; | |
| } | |
| static inline int | |
| nvkm_gsp_rm_alloc_wr(struct nvkm_gsp_object *object, void *argv) | |
| { | |
| void *repv = nvkm_gsp_rm_alloc_push(object, argv); | |
| if (IS_ERR(repv)) | |
| return PTR_ERR(repv); | |
| return 0; | |
| } | |
| static inline void | |
| nvkm_gsp_rm_alloc_done(struct nvkm_gsp_object *object, void *repv) | |
| { | |
| object->client->gsp->rm->api->alloc->done(object, repv); | |
| } | |
| static inline int | |
| nvkm_gsp_rm_alloc(struct nvkm_gsp_object *parent, u32 handle, u32 oclass, u32 argc, | |
| struct nvkm_gsp_object *object) | |
| { | |
| void *argv = nvkm_gsp_rm_alloc_get(parent, handle, oclass, argc, object); | |
| if (IS_ERR_OR_NULL(argv)) | |
| return argv ? PTR_ERR(argv) : -EIO; | |
| return nvkm_gsp_rm_alloc_wr(object, argv); | |
| } | |
| static inline int | |
| nvkm_gsp_rm_free(struct nvkm_gsp_object *object) | |
| { | |
| if (object->client) { | |
| int ret = object->client->gsp->rm->api->alloc->free(object); | |
| object->client = NULL; | |
| return ret; | |
| } | |
| return 0; | |
| } | |
| int nvkm_gsp_client_ctor(struct nvkm_gsp *, struct nvkm_gsp_client *); | |
| void nvkm_gsp_client_dtor(struct nvkm_gsp_client *); | |
| static inline int | |
| nvkm_gsp_device_ctor(struct nvkm_gsp_client *client, struct nvkm_gsp_device *device) | |
| { | |
| return client->gsp->rm->api->device->ctor(client, device); | |
| } | |
| static inline void | |
| nvkm_gsp_device_dtor(struct nvkm_gsp_device *device) | |
| { | |
| if (device->object.client) | |
| device->object.client->gsp->rm->api->device->dtor(device); | |
| } | |
| static inline int | |
| nvkm_gsp_client_device_ctor(struct nvkm_gsp *gsp, | |
| struct nvkm_gsp_client *client, struct nvkm_gsp_device *device) | |
| { | |
| int ret = nvkm_gsp_client_ctor(gsp, client); | |
| if (ret == 0) { | |
| ret = nvkm_gsp_device_ctor(client, device); | |
| if (ret) | |
| nvkm_gsp_client_dtor(client); | |
| } | |
| return ret; | |
| } | |
| struct nvkm_gsp_event { | |
| struct nvkm_gsp_device *device; | |
| u32 id; | |
| nvkm_gsp_event_func func; | |
| struct nvkm_gsp_object object; | |
| struct list_head head; | |
| }; | |
| static inline int | |
| nvkm_gsp_device_event_ctor(struct nvkm_gsp_device *device, u32 handle, u32 id, | |
| nvkm_gsp_event_func func, struct nvkm_gsp_event *event) | |
| { | |
| struct nvkm_rm *rm = device->object.client->gsp->rm; | |
| return rm->api->device->event.ctor(device, handle, id, func, event); | |
| } | |
| static inline void | |
| nvkm_gsp_event_dtor(struct nvkm_gsp_event *event) | |
| { | |
| struct nvkm_gsp_device *device = event->device; | |
| if (device) | |
| device->object.client->gsp->rm->api->device->event.dtor(event); | |
| } | |
| int nvkm_gsp_intr_stall(struct nvkm_gsp *, enum nvkm_subdev_type, int); | |
| int nvkm_gsp_intr_nonstall(struct nvkm_gsp *, enum nvkm_subdev_type, int); | |
| int nvkm_gsp_gcx_ready(struct nvkm_gsp *gsp); | |
| int gv100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int tu102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int tu116_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int ga100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int ga102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int gh100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int ad102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int gb100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| int gb202_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **); | |
| #endif |