drivers/gpu/drm/nouveau/include/nvkm/subdev/gsp.h

   1 #ifndef __NVKM_GSP_H__
   2 #define __NVKM_GSP_H__
   3 #define nvkm_gsp(p) container_of((p), struct nvkm_gsp, subdev)
   4 #include <core/subdev.h>
   5 #include <core/falcon.h>
   6 #include <core/firmware.h>
   7
   8 #define GSP_PAGE_SHIFT 12
   9 #define GSP_PAGE_SIZE  BIT(GSP_PAGE_SHIFT)
  10
  11 struct nvkm_gsp_mem {
  12         size_t size;
  13         void *data;
  14         dma_addr_t addr;
  15 };
  16
  17 struct nvkm_gsp_radix3 {
  18         struct nvkm_gsp_mem mem[3];
  19 };
  20
  21 int nvkm_gsp_sg(struct nvkm_device *, u64 size, struct sg_table *);
  22 void nvkm_gsp_sg_free(struct nvkm_device *, struct sg_table *);
  23
  24 typedef int (*nvkm_gsp_msg_ntfy_func)(void *priv, u32 fn, void *repv, u32 repc);
  25
  26 struct nvkm_gsp_event;
  27 typedef void (*nvkm_gsp_event_func)(struct nvkm_gsp_event *, void *repv, u32 repc);
  28
  29 struct nvkm_gsp {
  30         const struct nvkm_gsp_func *func;
  31         struct nvkm_subdev subdev;
  32
  33         struct nvkm_falcon falcon;
  34
  35         struct {
  36                 struct {
  37                         const struct firmware *load;
  38                         const struct firmware *unload;
  39                 } booter;
  40                 const struct firmware *bl;
  41                 const struct firmware *rm;
  42         } fws;
  43
  44         struct nvkm_firmware fw;
  45         struct nvkm_gsp_mem sig;
  46         struct nvkm_gsp_radix3 radix3;
  47
  48         struct {
  49                 struct {
  50                         struct {
  51                                 u64 addr;
  52                                 u64 size;
  53                         } vga_workspace;
  54                         u64 addr;
  55                         u64 size;
  56                 } bios;
  57                 struct {
  58                         struct {
  59                                 u64 addr;
  60                                 u64 size;
  61                         } frts, boot, elf, heap;
  62                         u64 addr;
  63                         u64 size;
  64                 } wpr2;
  65                 struct {
  66                         u64 addr;
  67                         u64 size;
  68                 } heap;
  69                 u64 addr;
  70                 u64 size;
  71
  72                 struct {
  73                         u64 addr;
  74                         u64 size;
  75                 } region[16];
  76                 int region_nr;
  77                 u32 rsvd_size;
  78         } fb;
  79
  80         struct {
  81                 struct nvkm_falcon_fw load;
  82                 struct nvkm_falcon_fw unload;
  83         } booter;
  84
  85         struct {
  86                 struct nvkm_gsp_mem fw;
  87                 u32 code_offset;
  88                 u32 data_offset;
  89                 u32 manifest_offset;
  90                 u32 app_version;
  91         } boot;
  92
  93         struct nvkm_gsp_mem libos;
  94         struct nvkm_gsp_mem loginit;
  95         struct nvkm_gsp_mem logintr;
  96         struct nvkm_gsp_mem logrm;
  97         struct nvkm_gsp_mem rmargs;
  98
  99         struct nvkm_gsp_mem wpr_meta;
 100
 101         struct {
 102                 struct sg_table sgt;
 103                 struct nvkm_gsp_radix3 radix3;
 104                 struct nvkm_gsp_mem meta;
 105         } sr;
 106
 107         struct {
 108                 struct nvkm_gsp_mem mem;
 109
 110                 struct {
 111                         int   nr;
 112                         u32 size;
 113                         u64 *ptr;
 114                 } ptes;
 115
 116                 struct {
 117                         u32  size;
 118                         void *ptr;
 119                 } cmdq, msgq;
 120         } shm;
 121
 122         struct nvkm_gsp_cmdq {
 123                 struct mutex mutex;
 124                 u32 cnt;
 125                 u32 seq;
 126                 u32 *wptr;
 127                 u32 *rptr;
 128         } cmdq;
 129
 130         struct nvkm_gsp_msgq {
 131                 struct mutex mutex;
 132                 u32 cnt;
 133                 u32 *wptr;
 134                 u32 *rptr;
 135                 struct nvkm_gsp_msgq_ntfy {
 136                         u32 fn;
 137                         nvkm_gsp_msg_ntfy_func func;
 138                         void *priv;
 139                 } ntfy[16];
 140                 int ntfy_nr;
 141                 struct work_struct work;
 142         } msgq;
 143
 144         bool running;
 145
 146         /* Internal GSP-RM control handles. */
 147         struct {
 148                 struct nvkm_gsp_client {
 149                         struct nvkm_gsp_object {
 150                                 struct nvkm_gsp_client *client;
 151                                 struct nvkm_gsp_object *parent;
 152                                 u32 handle;
 153                         } object;
 154
 155                         struct nvkm_gsp *gsp;
 156
 157                         struct list_head events;
 158                 } client;
 159
 160                 struct nvkm_gsp_device {
 161                         struct nvkm_gsp_object object;
 162                         struct nvkm_gsp_object subdevice;
 163                 } device;
 164         } internal;
 165
 166         struct {
 167                 enum nvkm_subdev_type type;
 168                 int inst;
 169                 u32 stall;
 170                 u32 nonstall;
 171         } intr[32];
 172         int intr_nr;
 173
 174         struct {
 175                 u64 rm_bar1_pdb;
 176                 u64 rm_bar2_pdb;
 177         } bar;
 178
 179         struct {
 180                 u8 gpcs;
 181                 u8 tpcs;
 182         } gr;
 183
 184         const struct nvkm_gsp_rm {
 185                 void *(*rpc_get)(struct nvkm_gsp *, u32 fn, u32 argc);
 186                 void *(*rpc_push)(struct nvkm_gsp *, void *argv, bool wait, u32 repc);
 187                 void (*rpc_done)(struct nvkm_gsp *gsp, void *repv);
 188
 189                 void *(*rm_ctrl_get)(struct nvkm_gsp_object *, u32 cmd, u32 argc);
 190                 int (*rm_ctrl_push)(struct nvkm_gsp_object *, void **argv, u32 repc);
 191                 void (*rm_ctrl_done)(struct nvkm_gsp_object *, void *repv);
 192
 193                 void *(*rm_alloc_get)(struct nvkm_gsp_object *, u32 oclass, u32 argc);
 194                 void *(*rm_alloc_push)(struct nvkm_gsp_object *, void *argv, u32 repc);
 195                 void (*rm_alloc_done)(struct nvkm_gsp_object *, void *repv);
 196
 197                 int (*rm_free)(struct nvkm_gsp_object *);
 198
 199                 int (*client_ctor)(struct nvkm_gsp *, struct nvkm_gsp_client *);
 200                 void (*client_dtor)(struct nvkm_gsp_client *);
 201
 202                 int (*device_ctor)(struct nvkm_gsp_client *, struct nvkm_gsp_device *);
 203                 void (*device_dtor)(struct nvkm_gsp_device *);
 204
 205                 int (*event_ctor)(struct nvkm_gsp_device *, u32 handle, u32 id,
 206                                   nvkm_gsp_event_func, struct nvkm_gsp_event *);
 207                 void (*event_dtor)(struct nvkm_gsp_event *);
 208         } *rm;
 209
 210         struct {
 211                 struct mutex mutex;;
 212                 struct idr idr;
 213         } client_id;
 214 };
 215
 216 static inline bool
 217 nvkm_gsp_rm(struct nvkm_gsp *gsp)
 218 {
 219         return gsp && (gsp->fws.rm || gsp->fw.img);
 220 }
 221
 222 static inline void *
 223 nvkm_gsp_rpc_get(struct nvkm_gsp *gsp, u32 fn, u32 argc)
 224 {
 225         return gsp->rm->rpc_get(gsp, fn, argc);
 226 }
 227
 228 static inline void *
 229 nvkm_gsp_rpc_push(struct nvkm_gsp *gsp, void *argv, bool wait, u32 repc)
 230 {
 231         return gsp->rm->rpc_push(gsp, argv, wait, repc);
 232 }
 233
 234 static inline void *
 235 nvkm_gsp_rpc_rd(struct nvkm_gsp *gsp, u32 fn, u32 argc)
 236 {
 237         void *argv = nvkm_gsp_rpc_get(gsp, fn, argc);
 238
 239         if (IS_ERR_OR_NULL(argv))
 240                 return argv;
 241
 242         return nvkm_gsp_rpc_push(gsp, argv, true, argc);
 243 }
 244
 245 static inline int
 246 nvkm_gsp_rpc_wr(struct nvkm_gsp *gsp, void *argv, bool wait)
 247 {
 248         void *repv = nvkm_gsp_rpc_push(gsp, argv, wait, 0);
 249
 250         if (IS_ERR(repv))
 251                 return PTR_ERR(repv);
 252
 253         return 0;
 254 }
 255
 256 static inline void
 257 nvkm_gsp_rpc_done(struct nvkm_gsp *gsp, void *repv)
 258 {
 259         gsp->rm->rpc_done(gsp, repv);
 260 }
 261
 262 static inline void *
 263 nvkm_gsp_rm_ctrl_get(struct nvkm_gsp_object *object, u32 cmd, u32 argc)
 264 {
 265         return object->client->gsp->rm->rm_ctrl_get(object, cmd, argc);
 266 }
 267
 268 static inline int
 269 nvkm_gsp_rm_ctrl_push(struct nvkm_gsp_object *object, void *argv, u32 repc)
 270 {
 271         return object->client->gsp->rm->rm_ctrl_push(object, argv, repc);
 272 }
 273
 274 static inline void *
 275 nvkm_gsp_rm_ctrl_rd(struct nvkm_gsp_object *object, u32 cmd, u32 repc)
 276 {
 277         void *argv = nvkm_gsp_rm_ctrl_get(object, cmd, repc);
 278         int ret;
 279
 280         if (IS_ERR(argv))
 281                 return argv;
 282
 283         ret = nvkm_gsp_rm_ctrl_push(object, &argv, repc);
 284         if (ret)
 285                 return ERR_PTR(ret);
 286         return argv;
 287 }
 288
 289 static inline int
 290 nvkm_gsp_rm_ctrl_wr(struct nvkm_gsp_object *object, void *argv)
 291 {
 292         int ret = nvkm_gsp_rm_ctrl_push(object, &argv, 0);
 293
 294         if (ret)
 295                 return ret;
 296         return 0;
 297 }
 298
 299 static inline void
 300 nvkm_gsp_rm_ctrl_done(struct nvkm_gsp_object *object, void *repv)
 301 {
 302         object->client->gsp->rm->rm_ctrl_done(object, repv);
 303 }
 304
 305 static inline void *
 306 nvkm_gsp_rm_alloc_get(struct nvkm_gsp_object *parent, u32 handle, u32 oclass, u32 argc,
 307                       struct nvkm_gsp_object *object)
 308 {
 309         struct nvkm_gsp_client *client = parent->client;
 310         struct nvkm_gsp *gsp = client->gsp;
 311         void *argv;
 312
 313         object->client = parent->client;
 314         object->parent = parent;
 315         object->handle = handle;
 316
 317         argv = gsp->rm->rm_alloc_get(object, oclass, argc);
 318         if (IS_ERR_OR_NULL(argv)) {
 319                 object->client = NULL;
 320                 return argv;
 321         }
 322
 323         return argv;
 324 }
 325
 326 static inline void *
 327 nvkm_gsp_rm_alloc_push(struct nvkm_gsp_object *object, void *argv, u32 repc)
 328 {
 329         void *repv = object->client->gsp->rm->rm_alloc_push(object, argv, repc);
 330
 331         if (IS_ERR(repv))
 332                 object->client = NULL;
 333
 334         return repv;
 335 }
 336
 337 static inline int
 338 nvkm_gsp_rm_alloc_wr(struct nvkm_gsp_object *object, void *argv)
 339 {
 340         void *repv = nvkm_gsp_rm_alloc_push(object, argv, 0);
 341
 342         if (IS_ERR(repv))
 343                 return PTR_ERR(repv);
 344
 345         return 0;
 346 }
 347
 348 static inline void
 349 nvkm_gsp_rm_alloc_done(struct nvkm_gsp_object *object, void *repv)
 350 {
 351         object->client->gsp->rm->rm_alloc_done(object, repv);
 352 }
 353
 354 static inline int
 355 nvkm_gsp_rm_alloc(struct nvkm_gsp_object *parent, u32 handle, u32 oclass, u32 argc,
 356                   struct nvkm_gsp_object *object)
 357 {
 358         void *argv = nvkm_gsp_rm_alloc_get(parent, handle, oclass, argc, object);
 359
 360         if (IS_ERR_OR_NULL(argv))
 361                 return argv ? PTR_ERR(argv) : -EIO;
 362
 363         return nvkm_gsp_rm_alloc_wr(object, argv);
 364 }
 365
 366 static inline int
 367 nvkm_gsp_rm_free(struct nvkm_gsp_object *object)
 368 {
 369         if (object->client)
 370                 return object->client->gsp->rm->rm_free(object);
 371
 372         return 0;
 373 }
 374
 375 static inline int
 376 nvkm_gsp_client_ctor(struct nvkm_gsp *gsp, struct nvkm_gsp_client *client)
 377 {
 378         if (WARN_ON(!gsp->rm))
 379                 return -ENOSYS;
 380
 381         return gsp->rm->client_ctor(gsp, client);
 382 }
 383
 384 static inline void
 385 nvkm_gsp_client_dtor(struct nvkm_gsp_client *client)
 386 {
 387         if (client->gsp)
 388                 client->gsp->rm->client_dtor(client);
 389 }
 390
 391 static inline int
 392 nvkm_gsp_device_ctor(struct nvkm_gsp_client *client, struct nvkm_gsp_device *device)
 393 {
 394         return client->gsp->rm->device_ctor(client, device);
 395 }
 396
 397 static inline void
 398 nvkm_gsp_device_dtor(struct nvkm_gsp_device *device)
 399 {
 400         if (device->object.client)
 401                 device->object.client->gsp->rm->device_dtor(device);
 402 }
 403
 404 static inline int
 405 nvkm_gsp_client_device_ctor(struct nvkm_gsp *gsp,
 406                             struct nvkm_gsp_client *client, struct nvkm_gsp_device *device)
 407 {
 408         int ret = nvkm_gsp_client_ctor(gsp, client);
 409
 410         if (ret == 0) {
 411                 ret = nvkm_gsp_device_ctor(client, device);
 412                 if (ret)
 413                         nvkm_gsp_client_dtor(client);
 414         }
 415
 416         return ret;
 417 }
 418
 419 struct nvkm_gsp_event {
 420         struct nvkm_gsp_device *device;
 421         u32 id;
 422         nvkm_gsp_event_func func;
 423
 424         struct nvkm_gsp_object object;
 425
 426         struct list_head head;
 427 };
 428
 429 static inline int
 430 nvkm_gsp_device_event_ctor(struct nvkm_gsp_device *device, u32 handle, u32 id,
 431                            nvkm_gsp_event_func func, struct nvkm_gsp_event *event)
 432 {
 433         return device->object.client->gsp->rm->event_ctor(device, handle, id, func, event);
 434 }
 435
 436 static inline void
 437 nvkm_gsp_event_dtor(struct nvkm_gsp_event *event)
 438 {
 439         struct nvkm_gsp_device *device = event->device;
 440
 441         if (device)
 442                 device->object.client->gsp->rm->event_dtor(event);
 443 }
 444
 445 int nvkm_gsp_intr_stall(struct nvkm_gsp *, enum nvkm_subdev_type, int);
 446 int nvkm_gsp_intr_nonstall(struct nvkm_gsp *, enum nvkm_subdev_type, int);
 447
 448 int gv100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 449 int tu102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 450 int tu116_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 451 int ga100_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 452 int ga102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 453 int ad102_gsp_new(struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_gsp **);
 454 #endif