vmwgfx_shader.c 27 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054
  1. // SPDX-License-Identifier: GPL-2.0 OR MIT
  2. /**************************************************************************
  3. *
  4. * Copyright 2009-2015 VMware, Inc., Palo Alto, CA., USA
  5. *
  6. * Permission is hereby granted, free of charge, to any person obtaining a
  7. * copy of this software and associated documentation files (the
  8. * "Software"), to deal in the Software without restriction, including
  9. * without limitation the rights to use, copy, modify, merge, publish,
  10. * distribute, sub license, and/or sell copies of the Software, and to
  11. * permit persons to whom the Software is furnished to do so, subject to
  12. * the following conditions:
  13. *
  14. * The above copyright notice and this permission notice (including the
  15. * next paragraph) shall be included in all copies or substantial portions
  16. * of the Software.
  17. *
  18. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20. * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21. * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22. * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23. * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24. * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25. *
  26. **************************************************************************/
  27. #include <drm/ttm/ttm_placement.h>
  28. #include "vmwgfx_drv.h"
  29. #include "vmwgfx_resource_priv.h"
  30. #include "vmwgfx_binding.h"
  31. struct vmw_shader {
  32. struct vmw_resource res;
  33. SVGA3dShaderType type;
  34. uint32_t size;
  35. uint8_t num_input_sig;
  36. uint8_t num_output_sig;
  37. };
  38. struct vmw_user_shader {
  39. struct ttm_base_object base;
  40. struct vmw_shader shader;
  41. };
  42. struct vmw_dx_shader {
  43. struct vmw_resource res;
  44. struct vmw_resource *ctx;
  45. struct vmw_resource *cotable;
  46. u32 id;
  47. bool committed;
  48. struct list_head cotable_head;
  49. };
  50. static uint64_t vmw_user_shader_size;
  51. static uint64_t vmw_shader_size;
  52. static size_t vmw_shader_dx_size;
  53. static void vmw_user_shader_free(struct vmw_resource *res);
  54. static struct vmw_resource *
  55. vmw_user_shader_base_to_res(struct ttm_base_object *base);
  56. static int vmw_gb_shader_create(struct vmw_resource *res);
  57. static int vmw_gb_shader_bind(struct vmw_resource *res,
  58. struct ttm_validate_buffer *val_buf);
  59. static int vmw_gb_shader_unbind(struct vmw_resource *res,
  60. bool readback,
  61. struct ttm_validate_buffer *val_buf);
  62. static int vmw_gb_shader_destroy(struct vmw_resource *res);
  63. static int vmw_dx_shader_create(struct vmw_resource *res);
  64. static int vmw_dx_shader_bind(struct vmw_resource *res,
  65. struct ttm_validate_buffer *val_buf);
  66. static int vmw_dx_shader_unbind(struct vmw_resource *res,
  67. bool readback,
  68. struct ttm_validate_buffer *val_buf);
  69. static void vmw_dx_shader_commit_notify(struct vmw_resource *res,
  70. enum vmw_cmdbuf_res_state state);
  71. static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type);
  72. static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type);
  73. static uint64_t vmw_user_shader_size;
  74. static const struct vmw_user_resource_conv user_shader_conv = {
  75. .object_type = VMW_RES_SHADER,
  76. .base_obj_to_res = vmw_user_shader_base_to_res,
  77. .res_free = vmw_user_shader_free
  78. };
  79. const struct vmw_user_resource_conv *user_shader_converter =
  80. &user_shader_conv;
  81. static const struct vmw_res_func vmw_gb_shader_func = {
  82. .res_type = vmw_res_shader,
  83. .needs_backup = true,
  84. .may_evict = true,
  85. .prio = 3,
  86. .dirty_prio = 3,
  87. .type_name = "guest backed shaders",
  88. .backup_placement = &vmw_mob_placement,
  89. .create = vmw_gb_shader_create,
  90. .destroy = vmw_gb_shader_destroy,
  91. .bind = vmw_gb_shader_bind,
  92. .unbind = vmw_gb_shader_unbind
  93. };
  94. static const struct vmw_res_func vmw_dx_shader_func = {
  95. .res_type = vmw_res_shader,
  96. .needs_backup = true,
  97. .may_evict = true,
  98. .prio = 3,
  99. .dirty_prio = 3,
  100. .type_name = "dx shaders",
  101. .backup_placement = &vmw_mob_placement,
  102. .create = vmw_dx_shader_create,
  103. /*
  104. * The destroy callback is only called with a committed resource on
  105. * context destroy, in which case we destroy the cotable anyway,
  106. * so there's no need to destroy DX shaders separately.
  107. */
  108. .destroy = NULL,
  109. .bind = vmw_dx_shader_bind,
  110. .unbind = vmw_dx_shader_unbind,
  111. .commit_notify = vmw_dx_shader_commit_notify,
  112. };
  113. /**
  114. * Shader management:
  115. */
  116. static inline struct vmw_shader *
  117. vmw_res_to_shader(struct vmw_resource *res)
  118. {
  119. return container_of(res, struct vmw_shader, res);
  120. }
  121. /**
  122. * vmw_res_to_dx_shader - typecast a struct vmw_resource to a
  123. * struct vmw_dx_shader
  124. *
  125. * @res: Pointer to the struct vmw_resource.
  126. */
  127. static inline struct vmw_dx_shader *
  128. vmw_res_to_dx_shader(struct vmw_resource *res)
  129. {
  130. return container_of(res, struct vmw_dx_shader, res);
  131. }
  132. static void vmw_hw_shader_destroy(struct vmw_resource *res)
  133. {
  134. if (likely(res->func->destroy))
  135. (void) res->func->destroy(res);
  136. else
  137. res->id = -1;
  138. }
  139. static int vmw_gb_shader_init(struct vmw_private *dev_priv,
  140. struct vmw_resource *res,
  141. uint32_t size,
  142. uint64_t offset,
  143. SVGA3dShaderType type,
  144. uint8_t num_input_sig,
  145. uint8_t num_output_sig,
  146. struct vmw_buffer_object *byte_code,
  147. void (*res_free) (struct vmw_resource *res))
  148. {
  149. struct vmw_shader *shader = vmw_res_to_shader(res);
  150. int ret;
  151. ret = vmw_resource_init(dev_priv, res, true, res_free,
  152. &vmw_gb_shader_func);
  153. if (unlikely(ret != 0)) {
  154. if (res_free)
  155. res_free(res);
  156. else
  157. kfree(res);
  158. return ret;
  159. }
  160. res->backup_size = size;
  161. if (byte_code) {
  162. res->backup = vmw_bo_reference(byte_code);
  163. res->backup_offset = offset;
  164. }
  165. shader->size = size;
  166. shader->type = type;
  167. shader->num_input_sig = num_input_sig;
  168. shader->num_output_sig = num_output_sig;
  169. res->hw_destroy = vmw_hw_shader_destroy;
  170. return 0;
  171. }
  172. /*
  173. * GB shader code:
  174. */
  175. static int vmw_gb_shader_create(struct vmw_resource *res)
  176. {
  177. struct vmw_private *dev_priv = res->dev_priv;
  178. struct vmw_shader *shader = vmw_res_to_shader(res);
  179. int ret;
  180. struct {
  181. SVGA3dCmdHeader header;
  182. SVGA3dCmdDefineGBShader body;
  183. } *cmd;
  184. if (likely(res->id != -1))
  185. return 0;
  186. ret = vmw_resource_alloc_id(res);
  187. if (unlikely(ret != 0)) {
  188. DRM_ERROR("Failed to allocate a shader id.\n");
  189. goto out_no_id;
  190. }
  191. if (unlikely(res->id >= VMWGFX_NUM_GB_SHADER)) {
  192. ret = -EBUSY;
  193. goto out_no_fifo;
  194. }
  195. cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
  196. if (unlikely(cmd == NULL)) {
  197. ret = -ENOMEM;
  198. goto out_no_fifo;
  199. }
  200. cmd->header.id = SVGA_3D_CMD_DEFINE_GB_SHADER;
  201. cmd->header.size = sizeof(cmd->body);
  202. cmd->body.shid = res->id;
  203. cmd->body.type = shader->type;
  204. cmd->body.sizeInBytes = shader->size;
  205. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  206. vmw_fifo_resource_inc(dev_priv);
  207. return 0;
  208. out_no_fifo:
  209. vmw_resource_release_id(res);
  210. out_no_id:
  211. return ret;
  212. }
  213. static int vmw_gb_shader_bind(struct vmw_resource *res,
  214. struct ttm_validate_buffer *val_buf)
  215. {
  216. struct vmw_private *dev_priv = res->dev_priv;
  217. struct {
  218. SVGA3dCmdHeader header;
  219. SVGA3dCmdBindGBShader body;
  220. } *cmd;
  221. struct ttm_buffer_object *bo = val_buf->bo;
  222. BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
  223. cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
  224. if (unlikely(cmd == NULL))
  225. return -ENOMEM;
  226. cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
  227. cmd->header.size = sizeof(cmd->body);
  228. cmd->body.shid = res->id;
  229. cmd->body.mobid = bo->mem.start;
  230. cmd->body.offsetInBytes = res->backup_offset;
  231. res->backup_dirty = false;
  232. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  233. return 0;
  234. }
  235. static int vmw_gb_shader_unbind(struct vmw_resource *res,
  236. bool readback,
  237. struct ttm_validate_buffer *val_buf)
  238. {
  239. struct vmw_private *dev_priv = res->dev_priv;
  240. struct {
  241. SVGA3dCmdHeader header;
  242. SVGA3dCmdBindGBShader body;
  243. } *cmd;
  244. struct vmw_fence_obj *fence;
  245. BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB);
  246. cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
  247. if (unlikely(cmd == NULL))
  248. return -ENOMEM;
  249. cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
  250. cmd->header.size = sizeof(cmd->body);
  251. cmd->body.shid = res->id;
  252. cmd->body.mobid = SVGA3D_INVALID_ID;
  253. cmd->body.offsetInBytes = 0;
  254. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  255. /*
  256. * Create a fence object and fence the backup buffer.
  257. */
  258. (void) vmw_execbuf_fence_commands(NULL, dev_priv,
  259. &fence, NULL);
  260. vmw_bo_fence_single(val_buf->bo, fence);
  261. if (likely(fence != NULL))
  262. vmw_fence_obj_unreference(&fence);
  263. return 0;
  264. }
  265. static int vmw_gb_shader_destroy(struct vmw_resource *res)
  266. {
  267. struct vmw_private *dev_priv = res->dev_priv;
  268. struct {
  269. SVGA3dCmdHeader header;
  270. SVGA3dCmdDestroyGBShader body;
  271. } *cmd;
  272. if (likely(res->id == -1))
  273. return 0;
  274. mutex_lock(&dev_priv->binding_mutex);
  275. vmw_binding_res_list_scrub(&res->binding_head);
  276. cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
  277. if (unlikely(cmd == NULL)) {
  278. mutex_unlock(&dev_priv->binding_mutex);
  279. return -ENOMEM;
  280. }
  281. cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SHADER;
  282. cmd->header.size = sizeof(cmd->body);
  283. cmd->body.shid = res->id;
  284. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  285. mutex_unlock(&dev_priv->binding_mutex);
  286. vmw_resource_release_id(res);
  287. vmw_fifo_resource_dec(dev_priv);
  288. return 0;
  289. }
  290. /*
  291. * DX shader code:
  292. */
  293. /**
  294. * vmw_dx_shader_commit_notify - Notify that a shader operation has been
  295. * committed to hardware from a user-supplied command stream.
  296. *
  297. * @res: Pointer to the shader resource.
  298. * @state: Indicating whether a creation or removal has been committed.
  299. *
  300. */
  301. static void vmw_dx_shader_commit_notify(struct vmw_resource *res,
  302. enum vmw_cmdbuf_res_state state)
  303. {
  304. struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
  305. struct vmw_private *dev_priv = res->dev_priv;
  306. if (state == VMW_CMDBUF_RES_ADD) {
  307. mutex_lock(&dev_priv->binding_mutex);
  308. vmw_cotable_add_resource(shader->cotable,
  309. &shader->cotable_head);
  310. shader->committed = true;
  311. res->id = shader->id;
  312. mutex_unlock(&dev_priv->binding_mutex);
  313. } else {
  314. mutex_lock(&dev_priv->binding_mutex);
  315. list_del_init(&shader->cotable_head);
  316. shader->committed = false;
  317. res->id = -1;
  318. mutex_unlock(&dev_priv->binding_mutex);
  319. }
  320. }
  321. /**
  322. * vmw_dx_shader_unscrub - Have the device reattach a MOB to a DX shader.
  323. *
  324. * @res: The shader resource
  325. *
  326. * This function reverts a scrub operation.
  327. */
  328. static int vmw_dx_shader_unscrub(struct vmw_resource *res)
  329. {
  330. struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
  331. struct vmw_private *dev_priv = res->dev_priv;
  332. struct {
  333. SVGA3dCmdHeader header;
  334. SVGA3dCmdDXBindShader body;
  335. } *cmd;
  336. if (!list_empty(&shader->cotable_head) || !shader->committed)
  337. return 0;
  338. cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), shader->ctx->id);
  339. if (unlikely(cmd == NULL))
  340. return -ENOMEM;
  341. cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
  342. cmd->header.size = sizeof(cmd->body);
  343. cmd->body.cid = shader->ctx->id;
  344. cmd->body.shid = shader->id;
  345. cmd->body.mobid = res->backup->base.mem.start;
  346. cmd->body.offsetInBytes = res->backup_offset;
  347. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  348. vmw_cotable_add_resource(shader->cotable, &shader->cotable_head);
  349. return 0;
  350. }
  351. /**
  352. * vmw_dx_shader_create - The DX shader create callback
  353. *
  354. * @res: The DX shader resource
  355. *
  356. * The create callback is called as part of resource validation and
  357. * makes sure that we unscrub the shader if it's previously been scrubbed.
  358. */
  359. static int vmw_dx_shader_create(struct vmw_resource *res)
  360. {
  361. struct vmw_private *dev_priv = res->dev_priv;
  362. struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
  363. int ret = 0;
  364. WARN_ON_ONCE(!shader->committed);
  365. if (vmw_resource_mob_attached(res)) {
  366. mutex_lock(&dev_priv->binding_mutex);
  367. ret = vmw_dx_shader_unscrub(res);
  368. mutex_unlock(&dev_priv->binding_mutex);
  369. }
  370. res->id = shader->id;
  371. return ret;
  372. }
  373. /**
  374. * vmw_dx_shader_bind - The DX shader bind callback
  375. *
  376. * @res: The DX shader resource
  377. * @val_buf: Pointer to the validate buffer.
  378. *
  379. */
  380. static int vmw_dx_shader_bind(struct vmw_resource *res,
  381. struct ttm_validate_buffer *val_buf)
  382. {
  383. struct vmw_private *dev_priv = res->dev_priv;
  384. struct ttm_buffer_object *bo = val_buf->bo;
  385. BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
  386. mutex_lock(&dev_priv->binding_mutex);
  387. vmw_dx_shader_unscrub(res);
  388. mutex_unlock(&dev_priv->binding_mutex);
  389. return 0;
  390. }
  391. /**
  392. * vmw_dx_shader_scrub - Have the device unbind a MOB from a DX shader.
  393. *
  394. * @res: The shader resource
  395. *
  396. * This function unbinds a MOB from the DX shader without requiring the
  397. * MOB dma_buffer to be reserved. The driver still considers the MOB bound.
  398. * However, once the driver eventually decides to unbind the MOB, it doesn't
  399. * need to access the context.
  400. */
  401. static int vmw_dx_shader_scrub(struct vmw_resource *res)
  402. {
  403. struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
  404. struct vmw_private *dev_priv = res->dev_priv;
  405. struct {
  406. SVGA3dCmdHeader header;
  407. SVGA3dCmdDXBindShader body;
  408. } *cmd;
  409. if (list_empty(&shader->cotable_head))
  410. return 0;
  411. WARN_ON_ONCE(!shader->committed);
  412. cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));
  413. if (unlikely(cmd == NULL))
  414. return -ENOMEM;
  415. cmd->header.id = SVGA_3D_CMD_DX_BIND_SHADER;
  416. cmd->header.size = sizeof(cmd->body);
  417. cmd->body.cid = shader->ctx->id;
  418. cmd->body.shid = res->id;
  419. cmd->body.mobid = SVGA3D_INVALID_ID;
  420. cmd->body.offsetInBytes = 0;
  421. vmw_fifo_commit(dev_priv, sizeof(*cmd));
  422. res->id = -1;
  423. list_del_init(&shader->cotable_head);
  424. return 0;
  425. }
  426. /**
  427. * vmw_dx_shader_unbind - The dx shader unbind callback.
  428. *
  429. * @res: The shader resource
  430. * @readback: Whether this is a readback unbind. Currently unused.
  431. * @val_buf: MOB buffer information.
  432. */
  433. static int vmw_dx_shader_unbind(struct vmw_resource *res,
  434. bool readback,
  435. struct ttm_validate_buffer *val_buf)
  436. {
  437. struct vmw_private *dev_priv = res->dev_priv;
  438. struct vmw_fence_obj *fence;
  439. int ret;
  440. BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB);
  441. mutex_lock(&dev_priv->binding_mutex);
  442. ret = vmw_dx_shader_scrub(res);
  443. mutex_unlock(&dev_priv->binding_mutex);
  444. if (ret)
  445. return ret;
  446. (void) vmw_execbuf_fence_commands(NULL, dev_priv,
  447. &fence, NULL);
  448. vmw_bo_fence_single(val_buf->bo, fence);
  449. if (likely(fence != NULL))
  450. vmw_fence_obj_unreference(&fence);
  451. return 0;
  452. }
  453. /**
  454. * vmw_dx_shader_cotable_list_scrub - The cotable unbind_func callback for
  455. * DX shaders.
  456. *
  457. * @dev_priv: Pointer to device private structure.
  458. * @list: The list of cotable resources.
  459. * @readback: Whether the call was part of a readback unbind.
  460. *
  461. * Scrubs all shader MOBs so that any subsequent shader unbind or shader
  462. * destroy operation won't need to swap in the context.
  463. */
  464. void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv,
  465. struct list_head *list,
  466. bool readback)
  467. {
  468. struct vmw_dx_shader *entry, *next;
  469. lockdep_assert_held_once(&dev_priv->binding_mutex);
  470. list_for_each_entry_safe(entry, next, list, cotable_head) {
  471. WARN_ON(vmw_dx_shader_scrub(&entry->res));
  472. if (!readback)
  473. entry->committed = false;
  474. }
  475. }
  476. /**
  477. * vmw_dx_shader_res_free - The DX shader free callback
  478. *
  479. * @res: The shader resource
  480. *
  481. * Frees the DX shader resource and updates memory accounting.
  482. */
  483. static void vmw_dx_shader_res_free(struct vmw_resource *res)
  484. {
  485. struct vmw_private *dev_priv = res->dev_priv;
  486. struct vmw_dx_shader *shader = vmw_res_to_dx_shader(res);
  487. vmw_resource_unreference(&shader->cotable);
  488. kfree(shader);
  489. ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_shader_dx_size);
  490. }
  491. /**
  492. * vmw_dx_shader_add - Add a shader resource as a command buffer managed
  493. * resource.
  494. *
  495. * @man: The command buffer resource manager.
  496. * @ctx: Pointer to the context resource.
  497. * @user_key: The id used for this shader.
  498. * @shader_type: The shader type.
  499. * @list: The list of staged command buffer managed resources.
  500. */
  501. int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man,
  502. struct vmw_resource *ctx,
  503. u32 user_key,
  504. SVGA3dShaderType shader_type,
  505. struct list_head *list)
  506. {
  507. struct vmw_dx_shader *shader;
  508. struct vmw_resource *res;
  509. struct vmw_private *dev_priv = ctx->dev_priv;
  510. struct ttm_operation_ctx ttm_opt_ctx = {
  511. .interruptible = true,
  512. .no_wait_gpu = false
  513. };
  514. int ret;
  515. if (!vmw_shader_dx_size)
  516. vmw_shader_dx_size = ttm_round_pot(sizeof(*shader));
  517. if (!vmw_shader_id_ok(user_key, shader_type))
  518. return -EINVAL;
  519. ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), vmw_shader_dx_size,
  520. &ttm_opt_ctx);
  521. if (ret) {
  522. if (ret != -ERESTARTSYS)
  523. DRM_ERROR("Out of graphics memory for shader "
  524. "creation.\n");
  525. return ret;
  526. }
  527. shader = kmalloc(sizeof(*shader), GFP_KERNEL);
  528. if (!shader) {
  529. ttm_mem_global_free(vmw_mem_glob(dev_priv), vmw_shader_dx_size);
  530. return -ENOMEM;
  531. }
  532. res = &shader->res;
  533. shader->ctx = ctx;
  534. shader->cotable = vmw_resource_reference
  535. (vmw_context_cotable(ctx, SVGA_COTABLE_DXSHADER));
  536. shader->id = user_key;
  537. shader->committed = false;
  538. INIT_LIST_HEAD(&shader->cotable_head);
  539. ret = vmw_resource_init(dev_priv, res, true,
  540. vmw_dx_shader_res_free, &vmw_dx_shader_func);
  541. if (ret)
  542. goto out_resource_init;
  543. /*
  544. * The user_key name-space is not per shader type for DX shaders,
  545. * so when hashing, use a single zero shader type.
  546. */
  547. ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader,
  548. vmw_shader_key(user_key, 0),
  549. res, list);
  550. if (ret)
  551. goto out_resource_init;
  552. res->id = shader->id;
  553. res->hw_destroy = vmw_hw_shader_destroy;
  554. out_resource_init:
  555. vmw_resource_unreference(&res);
  556. return ret;
  557. }
  558. /**
  559. * User-space shader management:
  560. */
  561. static struct vmw_resource *
  562. vmw_user_shader_base_to_res(struct ttm_base_object *base)
  563. {
  564. return &(container_of(base, struct vmw_user_shader, base)->
  565. shader.res);
  566. }
  567. static void vmw_user_shader_free(struct vmw_resource *res)
  568. {
  569. struct vmw_user_shader *ushader =
  570. container_of(res, struct vmw_user_shader, shader.res);
  571. struct vmw_private *dev_priv = res->dev_priv;
  572. ttm_base_object_kfree(ushader, base);
  573. ttm_mem_global_free(vmw_mem_glob(dev_priv),
  574. vmw_user_shader_size);
  575. }
  576. static void vmw_shader_free(struct vmw_resource *res)
  577. {
  578. struct vmw_shader *shader = vmw_res_to_shader(res);
  579. struct vmw_private *dev_priv = res->dev_priv;
  580. kfree(shader);
  581. ttm_mem_global_free(vmw_mem_glob(dev_priv),
  582. vmw_shader_size);
  583. }
  584. /**
  585. * This function is called when user space has no more references on the
  586. * base object. It releases the base-object's reference on the resource object.
  587. */
  588. static void vmw_user_shader_base_release(struct ttm_base_object **p_base)
  589. {
  590. struct ttm_base_object *base = *p_base;
  591. struct vmw_resource *res = vmw_user_shader_base_to_res(base);
  592. *p_base = NULL;
  593. vmw_resource_unreference(&res);
  594. }
  595. int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
  596. struct drm_file *file_priv)
  597. {
  598. struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data;
  599. struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
  600. return ttm_ref_object_base_unref(tfile, arg->handle,
  601. TTM_REF_USAGE);
  602. }
  603. static int vmw_user_shader_alloc(struct vmw_private *dev_priv,
  604. struct vmw_buffer_object *buffer,
  605. size_t shader_size,
  606. size_t offset,
  607. SVGA3dShaderType shader_type,
  608. uint8_t num_input_sig,
  609. uint8_t num_output_sig,
  610. struct ttm_object_file *tfile,
  611. u32 *handle)
  612. {
  613. struct vmw_user_shader *ushader;
  614. struct vmw_resource *res, *tmp;
  615. struct ttm_operation_ctx ctx = {
  616. .interruptible = true,
  617. .no_wait_gpu = false
  618. };
  619. int ret;
  620. if (unlikely(vmw_user_shader_size == 0))
  621. vmw_user_shader_size =
  622. ttm_round_pot(sizeof(struct vmw_user_shader)) +
  623. VMW_IDA_ACC_SIZE + TTM_OBJ_EXTRA_SIZE;
  624. ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
  625. vmw_user_shader_size,
  626. &ctx);
  627. if (unlikely(ret != 0)) {
  628. if (ret != -ERESTARTSYS)
  629. DRM_ERROR("Out of graphics memory for shader "
  630. "creation.\n");
  631. goto out;
  632. }
  633. ushader = kzalloc(sizeof(*ushader), GFP_KERNEL);
  634. if (unlikely(!ushader)) {
  635. ttm_mem_global_free(vmw_mem_glob(dev_priv),
  636. vmw_user_shader_size);
  637. ret = -ENOMEM;
  638. goto out;
  639. }
  640. res = &ushader->shader.res;
  641. ushader->base.shareable = false;
  642. ushader->base.tfile = NULL;
  643. /*
  644. * From here on, the destructor takes over resource freeing.
  645. */
  646. ret = vmw_gb_shader_init(dev_priv, res, shader_size,
  647. offset, shader_type, num_input_sig,
  648. num_output_sig, buffer,
  649. vmw_user_shader_free);
  650. if (unlikely(ret != 0))
  651. goto out;
  652. tmp = vmw_resource_reference(res);
  653. ret = ttm_base_object_init(tfile, &ushader->base, false,
  654. VMW_RES_SHADER,
  655. &vmw_user_shader_base_release, NULL);
  656. if (unlikely(ret != 0)) {
  657. vmw_resource_unreference(&tmp);
  658. goto out_err;
  659. }
  660. if (handle)
  661. *handle = ushader->base.handle;
  662. out_err:
  663. vmw_resource_unreference(&res);
  664. out:
  665. return ret;
  666. }
  667. static struct vmw_resource *vmw_shader_alloc(struct vmw_private *dev_priv,
  668. struct vmw_buffer_object *buffer,
  669. size_t shader_size,
  670. size_t offset,
  671. SVGA3dShaderType shader_type)
  672. {
  673. struct vmw_shader *shader;
  674. struct vmw_resource *res;
  675. struct ttm_operation_ctx ctx = {
  676. .interruptible = true,
  677. .no_wait_gpu = false
  678. };
  679. int ret;
  680. if (unlikely(vmw_shader_size == 0))
  681. vmw_shader_size =
  682. ttm_round_pot(sizeof(struct vmw_shader)) +
  683. VMW_IDA_ACC_SIZE;
  684. ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
  685. vmw_shader_size,
  686. &ctx);
  687. if (unlikely(ret != 0)) {
  688. if (ret != -ERESTARTSYS)
  689. DRM_ERROR("Out of graphics memory for shader "
  690. "creation.\n");
  691. goto out_err;
  692. }
  693. shader = kzalloc(sizeof(*shader), GFP_KERNEL);
  694. if (unlikely(!shader)) {
  695. ttm_mem_global_free(vmw_mem_glob(dev_priv),
  696. vmw_shader_size);
  697. ret = -ENOMEM;
  698. goto out_err;
  699. }
  700. res = &shader->res;
  701. /*
  702. * From here on, the destructor takes over resource freeing.
  703. */
  704. ret = vmw_gb_shader_init(dev_priv, res, shader_size,
  705. offset, shader_type, 0, 0, buffer,
  706. vmw_shader_free);
  707. out_err:
  708. return ret ? ERR_PTR(ret) : res;
  709. }
  710. static int vmw_shader_define(struct drm_device *dev, struct drm_file *file_priv,
  711. enum drm_vmw_shader_type shader_type_drm,
  712. u32 buffer_handle, size_t size, size_t offset,
  713. uint8_t num_input_sig, uint8_t num_output_sig,
  714. uint32_t *shader_handle)
  715. {
  716. struct vmw_private *dev_priv = vmw_priv(dev);
  717. struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
  718. struct vmw_buffer_object *buffer = NULL;
  719. SVGA3dShaderType shader_type;
  720. int ret;
  721. if (buffer_handle != SVGA3D_INVALID_ID) {
  722. ret = vmw_user_bo_lookup(tfile, buffer_handle,
  723. &buffer, NULL);
  724. if (unlikely(ret != 0)) {
  725. VMW_DEBUG_USER("Couldn't find buffer for shader creation.\n");
  726. return ret;
  727. }
  728. if ((u64)buffer->base.num_pages * PAGE_SIZE <
  729. (u64)size + (u64)offset) {
  730. VMW_DEBUG_USER("Illegal buffer- or shader size.\n");
  731. ret = -EINVAL;
  732. goto out_bad_arg;
  733. }
  734. }
  735. switch (shader_type_drm) {
  736. case drm_vmw_shader_type_vs:
  737. shader_type = SVGA3D_SHADERTYPE_VS;
  738. break;
  739. case drm_vmw_shader_type_ps:
  740. shader_type = SVGA3D_SHADERTYPE_PS;
  741. break;
  742. default:
  743. VMW_DEBUG_USER("Illegal shader type.\n");
  744. ret = -EINVAL;
  745. goto out_bad_arg;
  746. }
  747. ret = ttm_read_lock(&dev_priv->reservation_sem, true);
  748. if (unlikely(ret != 0))
  749. goto out_bad_arg;
  750. ret = vmw_user_shader_alloc(dev_priv, buffer, size, offset,
  751. shader_type, num_input_sig,
  752. num_output_sig, tfile, shader_handle);
  753. ttm_read_unlock(&dev_priv->reservation_sem);
  754. out_bad_arg:
  755. vmw_bo_unreference(&buffer);
  756. return ret;
  757. }
  758. /**
  759. * vmw_shader_id_ok - Check whether a compat shader user key and
  760. * shader type are within valid bounds.
  761. *
  762. * @user_key: User space id of the shader.
  763. * @shader_type: Shader type.
  764. *
  765. * Returns true if valid false if not.
  766. */
  767. static bool vmw_shader_id_ok(u32 user_key, SVGA3dShaderType shader_type)
  768. {
  769. return user_key <= ((1 << 20) - 1) && (unsigned) shader_type < 16;
  770. }
  771. /**
  772. * vmw_shader_key - Compute a hash key suitable for a compat shader.
  773. *
  774. * @user_key: User space id of the shader.
  775. * @shader_type: Shader type.
  776. *
  777. * Returns a hash key suitable for a command buffer managed resource
  778. * manager hash table.
  779. */
  780. static u32 vmw_shader_key(u32 user_key, SVGA3dShaderType shader_type)
  781. {
  782. return user_key | (shader_type << 20);
  783. }
  784. /**
  785. * vmw_shader_remove - Stage a compat shader for removal.
  786. *
  787. * @man: Pointer to the compat shader manager identifying the shader namespace.
  788. * @user_key: The key that is used to identify the shader. The key is
  789. * unique to the shader type.
  790. * @shader_type: Shader type.
  791. * @list: Caller's list of staged command buffer resource actions.
  792. */
  793. int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man,
  794. u32 user_key, SVGA3dShaderType shader_type,
  795. struct list_head *list)
  796. {
  797. struct vmw_resource *dummy;
  798. if (!vmw_shader_id_ok(user_key, shader_type))
  799. return -EINVAL;
  800. return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_shader,
  801. vmw_shader_key(user_key, shader_type),
  802. list, &dummy);
  803. }
  804. /**
  805. * vmw_compat_shader_add - Create a compat shader and stage it for addition
  806. * as a command buffer managed resource.
  807. *
  808. * @man: Pointer to the compat shader manager identifying the shader namespace.
  809. * @user_key: The key that is used to identify the shader. The key is
  810. * unique to the shader type.
  811. * @bytecode: Pointer to the bytecode of the shader.
  812. * @shader_type: Shader type.
  813. * @tfile: Pointer to a struct ttm_object_file that the guest-backed shader is
  814. * to be created with.
  815. * @list: Caller's list of staged command buffer resource actions.
  816. *
  817. */
  818. int vmw_compat_shader_add(struct vmw_private *dev_priv,
  819. struct vmw_cmdbuf_res_manager *man,
  820. u32 user_key, const void *bytecode,
  821. SVGA3dShaderType shader_type,
  822. size_t size,
  823. struct list_head *list)
  824. {
  825. struct ttm_operation_ctx ctx = { false, true };
  826. struct vmw_buffer_object *buf;
  827. struct ttm_bo_kmap_obj map;
  828. bool is_iomem;
  829. int ret;
  830. struct vmw_resource *res;
  831. if (!vmw_shader_id_ok(user_key, shader_type))
  832. return -EINVAL;
  833. /* Allocate and pin a DMA buffer */
  834. buf = kzalloc(sizeof(*buf), GFP_KERNEL);
  835. if (unlikely(!buf))
  836. return -ENOMEM;
  837. ret = vmw_bo_init(dev_priv, buf, size, &vmw_sys_ne_placement,
  838. true, vmw_bo_bo_free);
  839. if (unlikely(ret != 0))
  840. goto out;
  841. ret = ttm_bo_reserve(&buf->base, false, true, NULL);
  842. if (unlikely(ret != 0))
  843. goto no_reserve;
  844. /* Map and copy shader bytecode. */
  845. ret = ttm_bo_kmap(&buf->base, 0, PAGE_ALIGN(size) >> PAGE_SHIFT,
  846. &map);
  847. if (unlikely(ret != 0)) {
  848. ttm_bo_unreserve(&buf->base);
  849. goto no_reserve;
  850. }
  851. memcpy(ttm_kmap_obj_virtual(&map, &is_iomem), bytecode, size);
  852. WARN_ON(is_iomem);
  853. ttm_bo_kunmap(&map);
  854. ret = ttm_bo_validate(&buf->base, &vmw_sys_placement, &ctx);
  855. WARN_ON(ret != 0);
  856. ttm_bo_unreserve(&buf->base);
  857. res = vmw_shader_alloc(dev_priv, buf, size, 0, shader_type);
  858. if (unlikely(ret != 0))
  859. goto no_reserve;
  860. ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_shader,
  861. vmw_shader_key(user_key, shader_type),
  862. res, list);
  863. vmw_resource_unreference(&res);
  864. no_reserve:
  865. vmw_bo_unreference(&buf);
  866. out:
  867. return ret;
  868. }
  869. /**
  870. * vmw_shader_lookup - Look up a compat shader
  871. *
  872. * @man: Pointer to the command buffer managed resource manager identifying
  873. * the shader namespace.
  874. * @user_key: The user space id of the shader.
  875. * @shader_type: The shader type.
  876. *
  877. * Returns a refcounted pointer to a struct vmw_resource if the shader was
  878. * found. An error pointer otherwise.
  879. */
  880. struct vmw_resource *
  881. vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man,
  882. u32 user_key,
  883. SVGA3dShaderType shader_type)
  884. {
  885. if (!vmw_shader_id_ok(user_key, shader_type))
  886. return ERR_PTR(-EINVAL);
  887. return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_shader,
  888. vmw_shader_key(user_key, shader_type));
  889. }
  890. int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
  891. struct drm_file *file_priv)
  892. {
  893. struct drm_vmw_shader_create_arg *arg =
  894. (struct drm_vmw_shader_create_arg *)data;
  895. return vmw_shader_define(dev, file_priv, arg->shader_type,
  896. arg->buffer_handle,
  897. arg->size, arg->offset,
  898. 0, 0,
  899. &arg->shader_handle);
  900. }