omap_gem.c 36 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
  4. * Author: Rob Clark <rob.clark@linaro.org>
  5. */
  6. #include <linux/dma-mapping.h>
  7. #include <linux/seq_file.h>
  8. #include <linux/shmem_fs.h>
  9. #include <linux/spinlock.h>
  10. #include <linux/pfn_t.h>
  11. #include <drm/drm_prime.h>
  12. #include <drm/drm_vma_manager.h>
  13. #include "omap_drv.h"
  14. #include "omap_dmm_tiler.h"
  15. /*
  16. * GEM buffer object implementation.
  17. */
  18. /* note: we use upper 8 bits of flags for driver-internal flags: */
  19. #define OMAP_BO_MEM_DMA_API 0x01000000 /* memory allocated with the dma_alloc_* API */
  20. #define OMAP_BO_MEM_SHMEM 0x02000000 /* memory allocated through shmem backing */
  21. #define OMAP_BO_MEM_DMABUF 0x08000000 /* memory imported from a dmabuf */
  22. struct omap_gem_object {
  23. struct drm_gem_object base;
  24. struct list_head mm_list;
  25. u32 flags;
  26. /** width/height for tiled formats (rounded up to slot boundaries) */
  27. u16 width, height;
  28. /** roll applied when mapping to DMM */
  29. u32 roll;
  30. /** protects dma_addr_cnt, block, pages, dma_addrs and vaddr */
  31. struct mutex lock;
  32. /**
  33. * dma_addr contains the buffer DMA address. It is valid for
  34. *
  35. * - buffers allocated through the DMA mapping API (with the
  36. * OMAP_BO_MEM_DMA_API flag set)
  37. *
  38. * - buffers imported from dmabuf (with the OMAP_BO_MEM_DMABUF flag set)
  39. * if they are physically contiguous (when sgt->orig_nents == 1)
  40. *
  41. * - buffers mapped through the TILER when dma_addr_cnt is not zero, in
  42. * which case the DMA address points to the TILER aperture
  43. *
  44. * Physically contiguous buffers have their DMA address equal to the
  45. * physical address as we don't remap those buffers through the TILER.
  46. *
  47. * Buffers mapped to the TILER have their DMA address pointing to the
  48. * TILER aperture. As TILER mappings are refcounted (through
  49. * dma_addr_cnt) the DMA address must be accessed through omap_gem_pin()
  50. * to ensure that the mapping won't disappear unexpectedly. References
  51. * must be released with omap_gem_unpin().
  52. */
  53. dma_addr_t dma_addr;
  54. /**
  55. * # of users of dma_addr
  56. */
  57. refcount_t dma_addr_cnt;
  58. /**
  59. * If the buffer has been imported from a dmabuf the OMAP_DB_DMABUF flag
  60. * is set and the sgt field is valid.
  61. */
  62. struct sg_table *sgt;
  63. /**
  64. * tiler block used when buffer is remapped in DMM/TILER.
  65. */
  66. struct tiler_block *block;
  67. /**
  68. * Array of backing pages, if allocated. Note that pages are never
  69. * allocated for buffers originally allocated from contiguous memory
  70. */
  71. struct page **pages;
  72. /** addresses corresponding to pages in above array */
  73. dma_addr_t *dma_addrs;
  74. /**
  75. * Virtual address, if mapped.
  76. */
  77. void *vaddr;
  78. };
  79. #define to_omap_bo(x) container_of(x, struct omap_gem_object, base)
  80. /* To deal with userspace mmap'ings of 2d tiled buffers, which (a) are
  81. * not necessarily pinned in TILER all the time, and (b) when they are
  82. * they are not necessarily page aligned, we reserve one or more small
  83. * regions in each of the 2d containers to use as a user-GART where we
  84. * can create a second page-aligned mapping of parts of the buffer
  85. * being accessed from userspace.
  86. *
  87. * Note that we could optimize slightly when we know that multiple
  88. * tiler containers are backed by the same PAT.. but I'll leave that
  89. * for later..
  90. */
  91. #define NUM_USERGART_ENTRIES 2
  92. struct omap_drm_usergart_entry {
  93. struct tiler_block *block; /* the reserved tiler block */
  94. dma_addr_t dma_addr;
  95. struct drm_gem_object *obj; /* the current pinned obj */
  96. pgoff_t obj_pgoff; /* page offset of obj currently
  97. mapped in */
  98. };
  99. struct omap_drm_usergart {
  100. struct omap_drm_usergart_entry entry[NUM_USERGART_ENTRIES];
  101. int height; /* height in rows */
  102. int height_shift; /* ilog2(height in rows) */
  103. int slot_shift; /* ilog2(width per slot) */
  104. int stride_pfn; /* stride in pages */
  105. int last; /* index of last used entry */
  106. };
  107. /* -----------------------------------------------------------------------------
  108. * Helpers
  109. */
  110. /** get mmap offset */
  111. u64 omap_gem_mmap_offset(struct drm_gem_object *obj)
  112. {
  113. struct drm_device *dev = obj->dev;
  114. int ret;
  115. size_t size;
  116. /* Make it mmapable */
  117. size = omap_gem_mmap_size(obj);
  118. ret = drm_gem_create_mmap_offset_size(obj, size);
  119. if (ret) {
  120. dev_err(dev->dev, "could not allocate mmap offset\n");
  121. return 0;
  122. }
  123. return drm_vma_node_offset_addr(&obj->vma_node);
  124. }
  125. static bool omap_gem_is_contiguous(struct omap_gem_object *omap_obj)
  126. {
  127. if (omap_obj->flags & OMAP_BO_MEM_DMA_API)
  128. return true;
  129. if ((omap_obj->flags & OMAP_BO_MEM_DMABUF) && omap_obj->sgt->nents == 1)
  130. return true;
  131. return false;
  132. }
  133. /* -----------------------------------------------------------------------------
  134. * Eviction
  135. */
  136. static void omap_gem_evict_entry(struct drm_gem_object *obj,
  137. enum tiler_fmt fmt, struct omap_drm_usergart_entry *entry)
  138. {
  139. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  140. struct omap_drm_private *priv = obj->dev->dev_private;
  141. int n = priv->usergart[fmt].height;
  142. size_t size = PAGE_SIZE * n;
  143. loff_t off = omap_gem_mmap_offset(obj) +
  144. (entry->obj_pgoff << PAGE_SHIFT);
  145. const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);
  146. if (m > 1) {
  147. int i;
  148. /* if stride > than PAGE_SIZE then sparse mapping: */
  149. for (i = n; i > 0; i--) {
  150. unmap_mapping_range(obj->dev->anon_inode->i_mapping,
  151. off, PAGE_SIZE, 1);
  152. off += PAGE_SIZE * m;
  153. }
  154. } else {
  155. unmap_mapping_range(obj->dev->anon_inode->i_mapping,
  156. off, size, 1);
  157. }
  158. entry->obj = NULL;
  159. }
  160. /* Evict a buffer from usergart, if it is mapped there */
  161. static void omap_gem_evict(struct drm_gem_object *obj)
  162. {
  163. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  164. struct omap_drm_private *priv = obj->dev->dev_private;
  165. if (omap_obj->flags & OMAP_BO_TILED_MASK) {
  166. enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
  167. int i;
  168. for (i = 0; i < NUM_USERGART_ENTRIES; i++) {
  169. struct omap_drm_usergart_entry *entry =
  170. &priv->usergart[fmt].entry[i];
  171. if (entry->obj == obj)
  172. omap_gem_evict_entry(obj, fmt, entry);
  173. }
  174. }
  175. }
  176. /* -----------------------------------------------------------------------------
  177. * Page Management
  178. */
  179. /*
  180. * Ensure backing pages are allocated. Must be called with the omap_obj.lock
  181. * held.
  182. */
  183. static int omap_gem_attach_pages(struct drm_gem_object *obj)
  184. {
  185. struct drm_device *dev = obj->dev;
  186. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  187. struct page **pages;
  188. int npages = obj->size >> PAGE_SHIFT;
  189. int i, ret;
  190. dma_addr_t *addrs;
  191. lockdep_assert_held(&omap_obj->lock);
  192. /*
  193. * If not using shmem (in which case backing pages don't need to be
  194. * allocated) or if pages are already allocated we're done.
  195. */
  196. if (!(omap_obj->flags & OMAP_BO_MEM_SHMEM) || omap_obj->pages)
  197. return 0;
  198. pages = drm_gem_get_pages(obj);
  199. if (IS_ERR(pages)) {
  200. dev_err(obj->dev->dev, "could not get pages: %ld\n", PTR_ERR(pages));
  201. return PTR_ERR(pages);
  202. }
  203. /* for non-cached buffers, ensure the new pages are clean because
  204. * DSS, GPU, etc. are not cache coherent:
  205. */
  206. if (omap_obj->flags & (OMAP_BO_WC|OMAP_BO_UNCACHED)) {
  207. addrs = kmalloc_array(npages, sizeof(*addrs), GFP_KERNEL);
  208. if (!addrs) {
  209. ret = -ENOMEM;
  210. goto free_pages;
  211. }
  212. for (i = 0; i < npages; i++) {
  213. addrs[i] = dma_map_page(dev->dev, pages[i],
  214. 0, PAGE_SIZE, DMA_TO_DEVICE);
  215. if (dma_mapping_error(dev->dev, addrs[i])) {
  216. dev_warn(dev->dev,
  217. "%s: failed to map page\n", __func__);
  218. for (i = i - 1; i >= 0; --i) {
  219. dma_unmap_page(dev->dev, addrs[i],
  220. PAGE_SIZE, DMA_TO_DEVICE);
  221. }
  222. ret = -ENOMEM;
  223. goto free_addrs;
  224. }
  225. }
  226. } else {
  227. addrs = kcalloc(npages, sizeof(*addrs), GFP_KERNEL);
  228. if (!addrs) {
  229. ret = -ENOMEM;
  230. goto free_pages;
  231. }
  232. }
  233. omap_obj->dma_addrs = addrs;
  234. omap_obj->pages = pages;
  235. return 0;
  236. free_addrs:
  237. kfree(addrs);
  238. free_pages:
  239. drm_gem_put_pages(obj, pages, true, false);
  240. return ret;
  241. }
  242. /* Release backing pages. Must be called with the omap_obj.lock held. */
  243. static void omap_gem_detach_pages(struct drm_gem_object *obj)
  244. {
  245. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  246. unsigned int npages = obj->size >> PAGE_SHIFT;
  247. unsigned int i;
  248. lockdep_assert_held(&omap_obj->lock);
  249. for (i = 0; i < npages; i++) {
  250. if (omap_obj->dma_addrs[i])
  251. dma_unmap_page(obj->dev->dev, omap_obj->dma_addrs[i],
  252. PAGE_SIZE, DMA_TO_DEVICE);
  253. }
  254. kfree(omap_obj->dma_addrs);
  255. omap_obj->dma_addrs = NULL;
  256. drm_gem_put_pages(obj, omap_obj->pages, true, false);
  257. omap_obj->pages = NULL;
  258. }
  259. /* get buffer flags */
  260. u32 omap_gem_flags(struct drm_gem_object *obj)
  261. {
  262. return to_omap_bo(obj)->flags;
  263. }
  264. /** get mmap size */
  265. size_t omap_gem_mmap_size(struct drm_gem_object *obj)
  266. {
  267. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  268. size_t size = obj->size;
  269. if (omap_obj->flags & OMAP_BO_TILED_MASK) {
  270. /* for tiled buffers, the virtual size has stride rounded up
  271. * to 4kb.. (to hide the fact that row n+1 might start 16kb or
  272. * 32kb later!). But we don't back the entire buffer with
  273. * pages, only the valid picture part.. so need to adjust for
  274. * this in the size used to mmap and generate mmap offset
  275. */
  276. size = tiler_vsize(gem2fmt(omap_obj->flags),
  277. omap_obj->width, omap_obj->height);
  278. }
  279. return size;
  280. }
  281. /* -----------------------------------------------------------------------------
  282. * Fault Handling
  283. */
  284. /* Normal handling for the case of faulting in non-tiled buffers */
  285. static vm_fault_t omap_gem_fault_1d(struct drm_gem_object *obj,
  286. struct vm_area_struct *vma, struct vm_fault *vmf)
  287. {
  288. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  289. unsigned long pfn;
  290. pgoff_t pgoff;
  291. /* We don't use vmf->pgoff since that has the fake offset: */
  292. pgoff = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
  293. if (omap_obj->pages) {
  294. omap_gem_cpu_sync_page(obj, pgoff);
  295. pfn = page_to_pfn(omap_obj->pages[pgoff]);
  296. } else {
  297. BUG_ON(!omap_gem_is_contiguous(omap_obj));
  298. pfn = (omap_obj->dma_addr >> PAGE_SHIFT) + pgoff;
  299. }
  300. VERB("Inserting %p pfn %lx, pa %lx", (void *)vmf->address,
  301. pfn, pfn << PAGE_SHIFT);
  302. return vmf_insert_mixed(vma, vmf->address,
  303. __pfn_to_pfn_t(pfn, PFN_DEV));
  304. }
  305. /* Special handling for the case of faulting in 2d tiled buffers */
  306. static vm_fault_t omap_gem_fault_2d(struct drm_gem_object *obj,
  307. struct vm_area_struct *vma, struct vm_fault *vmf)
  308. {
  309. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  310. struct omap_drm_private *priv = obj->dev->dev_private;
  311. struct omap_drm_usergart_entry *entry;
  312. enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
  313. struct page *pages[64]; /* XXX is this too much to have on stack? */
  314. unsigned long pfn;
  315. pgoff_t pgoff, base_pgoff;
  316. unsigned long vaddr;
  317. int i, err, slots;
  318. vm_fault_t ret = VM_FAULT_NOPAGE;
  319. /*
  320. * Note the height of the slot is also equal to the number of pages
  321. * that need to be mapped in to fill 4kb wide CPU page. If the slot
  322. * height is 64, then 64 pages fill a 4kb wide by 64 row region.
  323. */
  324. const int n = priv->usergart[fmt].height;
  325. const int n_shift = priv->usergart[fmt].height_shift;
  326. /*
  327. * If buffer width in bytes > PAGE_SIZE then the virtual stride is
  328. * rounded up to next multiple of PAGE_SIZE.. this need to be taken
  329. * into account in some of the math, so figure out virtual stride
  330. * in pages
  331. */
  332. const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);
  333. /* We don't use vmf->pgoff since that has the fake offset: */
  334. pgoff = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
  335. /*
  336. * Actual address we start mapping at is rounded down to previous slot
  337. * boundary in the y direction:
  338. */
  339. base_pgoff = round_down(pgoff, m << n_shift);
  340. /* figure out buffer width in slots */
  341. slots = omap_obj->width >> priv->usergart[fmt].slot_shift;
  342. vaddr = vmf->address - ((pgoff - base_pgoff) << PAGE_SHIFT);
  343. entry = &priv->usergart[fmt].entry[priv->usergart[fmt].last];
  344. /* evict previous buffer using this usergart entry, if any: */
  345. if (entry->obj)
  346. omap_gem_evict_entry(entry->obj, fmt, entry);
  347. entry->obj = obj;
  348. entry->obj_pgoff = base_pgoff;
  349. /* now convert base_pgoff to phys offset from virt offset: */
  350. base_pgoff = (base_pgoff >> n_shift) * slots;
  351. /* for wider-than 4k.. figure out which part of the slot-row we want: */
  352. if (m > 1) {
  353. int off = pgoff % m;
  354. entry->obj_pgoff += off;
  355. base_pgoff /= m;
  356. slots = min(slots - (off << n_shift), n);
  357. base_pgoff += off << n_shift;
  358. vaddr += off << PAGE_SHIFT;
  359. }
  360. /*
  361. * Map in pages. Beyond the valid pixel part of the buffer, we set
  362. * pages[i] to NULL to get a dummy page mapped in.. if someone
  363. * reads/writes it they will get random/undefined content, but at
  364. * least it won't be corrupting whatever other random page used to
  365. * be mapped in, or other undefined behavior.
  366. */
  367. memcpy(pages, &omap_obj->pages[base_pgoff],
  368. sizeof(struct page *) * slots);
  369. memset(pages + slots, 0,
  370. sizeof(struct page *) * (n - slots));
  371. err = tiler_pin(entry->block, pages, ARRAY_SIZE(pages), 0, true);
  372. if (err) {
  373. ret = vmf_error(err);
  374. dev_err(obj->dev->dev, "failed to pin: %d\n", err);
  375. return ret;
  376. }
  377. pfn = entry->dma_addr >> PAGE_SHIFT;
  378. VERB("Inserting %p pfn %lx, pa %lx", (void *)vmf->address,
  379. pfn, pfn << PAGE_SHIFT);
  380. for (i = n; i > 0; i--) {
  381. ret = vmf_insert_mixed(vma,
  382. vaddr, __pfn_to_pfn_t(pfn, PFN_DEV));
  383. if (ret & VM_FAULT_ERROR)
  384. break;
  385. pfn += priv->usergart[fmt].stride_pfn;
  386. vaddr += PAGE_SIZE * m;
  387. }
  388. /* simple round-robin: */
  389. priv->usergart[fmt].last = (priv->usergart[fmt].last + 1)
  390. % NUM_USERGART_ENTRIES;
  391. return ret;
  392. }
  393. /**
  394. * omap_gem_fault - pagefault handler for GEM objects
  395. * @vmf: fault detail
  396. *
  397. * Invoked when a fault occurs on an mmap of a GEM managed area. GEM
  398. * does most of the work for us including the actual map/unmap calls
  399. * but we need to do the actual page work.
  400. *
  401. * The VMA was set up by GEM. In doing so it also ensured that the
  402. * vma->vm_private_data points to the GEM object that is backing this
  403. * mapping.
  404. */
  405. vm_fault_t omap_gem_fault(struct vm_fault *vmf)
  406. {
  407. struct vm_area_struct *vma = vmf->vma;
  408. struct drm_gem_object *obj = vma->vm_private_data;
  409. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  410. int err;
  411. vm_fault_t ret;
  412. /* Make sure we don't parallel update on a fault, nor move or remove
  413. * something from beneath our feet
  414. */
  415. mutex_lock(&omap_obj->lock);
  416. /* if a shmem backed object, make sure we have pages attached now */
  417. err = omap_gem_attach_pages(obj);
  418. if (err) {
  419. ret = vmf_error(err);
  420. goto fail;
  421. }
  422. /* where should we do corresponding put_pages().. we are mapping
  423. * the original page, rather than thru a GART, so we can't rely
  424. * on eviction to trigger this. But munmap() or all mappings should
  425. * probably trigger put_pages()?
  426. */
  427. if (omap_obj->flags & OMAP_BO_TILED_MASK)
  428. ret = omap_gem_fault_2d(obj, vma, vmf);
  429. else
  430. ret = omap_gem_fault_1d(obj, vma, vmf);
  431. fail:
  432. mutex_unlock(&omap_obj->lock);
  433. return ret;
  434. }
  435. /** We override mainly to fix up some of the vm mapping flags.. */
  436. int omap_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  437. {
  438. int ret;
  439. ret = drm_gem_mmap(filp, vma);
  440. if (ret) {
  441. DBG("mmap failed: %d", ret);
  442. return ret;
  443. }
  444. return omap_gem_mmap_obj(vma->vm_private_data, vma);
  445. }
  446. int omap_gem_mmap_obj(struct drm_gem_object *obj,
  447. struct vm_area_struct *vma)
  448. {
  449. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  450. vma->vm_flags &= ~VM_PFNMAP;
  451. vma->vm_flags |= VM_MIXEDMAP;
  452. if (omap_obj->flags & OMAP_BO_WC) {
  453. vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
  454. } else if (omap_obj->flags & OMAP_BO_UNCACHED) {
  455. vma->vm_page_prot = pgprot_noncached(vm_get_page_prot(vma->vm_flags));
  456. } else {
  457. /*
  458. * We do have some private objects, at least for scanout buffers
  459. * on hardware without DMM/TILER. But these are allocated write-
  460. * combine
  461. */
  462. if (WARN_ON(!obj->filp))
  463. return -EINVAL;
  464. /*
  465. * Shunt off cached objs to shmem file so they have their own
  466. * address_space (so unmap_mapping_range does what we want,
  467. * in particular in the case of mmap'd dmabufs)
  468. */
  469. fput(vma->vm_file);
  470. vma->vm_pgoff = 0;
  471. vma->vm_file = get_file(obj->filp);
  472. vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
  473. }
  474. return 0;
  475. }
  476. /* -----------------------------------------------------------------------------
  477. * Dumb Buffers
  478. */
  479. /**
  480. * omap_gem_dumb_create - create a dumb buffer
  481. * @drm_file: our client file
  482. * @dev: our device
  483. * @args: the requested arguments copied from userspace
  484. *
  485. * Allocate a buffer suitable for use for a frame buffer of the
  486. * form described by user space. Give userspace a handle by which
  487. * to reference it.
  488. */
  489. int omap_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
  490. struct drm_mode_create_dumb *args)
  491. {
  492. union omap_gem_size gsize;
  493. args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
  494. args->size = PAGE_ALIGN(args->pitch * args->height);
  495. gsize = (union omap_gem_size){
  496. .bytes = args->size,
  497. };
  498. return omap_gem_new_handle(dev, file, gsize,
  499. OMAP_BO_SCANOUT | OMAP_BO_WC, &args->handle);
  500. }
  501. /**
  502. * omap_gem_dumb_map - buffer mapping for dumb interface
  503. * @file: our drm client file
  504. * @dev: drm device
  505. * @handle: GEM handle to the object (from dumb_create)
  506. *
  507. * Do the necessary setup to allow the mapping of the frame buffer
  508. * into user memory. We don't have to do much here at the moment.
  509. */
  510. int omap_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
  511. u32 handle, u64 *offset)
  512. {
  513. struct drm_gem_object *obj;
  514. int ret = 0;
  515. /* GEM does all our handle to object mapping */
  516. obj = drm_gem_object_lookup(file, handle);
  517. if (obj == NULL) {
  518. ret = -ENOENT;
  519. goto fail;
  520. }
  521. *offset = omap_gem_mmap_offset(obj);
  522. drm_gem_object_put(obj);
  523. fail:
  524. return ret;
  525. }
  526. #ifdef CONFIG_DRM_FBDEV_EMULATION
  527. /* Set scrolling position. This allows us to implement fast scrolling
  528. * for console.
  529. *
  530. * Call only from non-atomic contexts.
  531. */
  532. int omap_gem_roll(struct drm_gem_object *obj, u32 roll)
  533. {
  534. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  535. u32 npages = obj->size >> PAGE_SHIFT;
  536. int ret = 0;
  537. if (roll > npages) {
  538. dev_err(obj->dev->dev, "invalid roll: %d\n", roll);
  539. return -EINVAL;
  540. }
  541. omap_obj->roll = roll;
  542. mutex_lock(&omap_obj->lock);
  543. /* if we aren't mapped yet, we don't need to do anything */
  544. if (omap_obj->block) {
  545. ret = omap_gem_attach_pages(obj);
  546. if (ret)
  547. goto fail;
  548. ret = tiler_pin(omap_obj->block, omap_obj->pages, npages,
  549. roll, true);
  550. if (ret)
  551. dev_err(obj->dev->dev, "could not repin: %d\n", ret);
  552. }
  553. fail:
  554. mutex_unlock(&omap_obj->lock);
  555. return ret;
  556. }
  557. #endif
  558. /* -----------------------------------------------------------------------------
  559. * Memory Management & DMA Sync
  560. */
  561. /*
  562. * shmem buffers that are mapped cached are not coherent.
  563. *
  564. * We keep track of dirty pages using page faulting to perform cache management.
  565. * When a page is mapped to the CPU in read/write mode the device can't access
  566. * it and omap_obj->dma_addrs[i] is NULL. When a page is mapped to the device
  567. * the omap_obj->dma_addrs[i] is set to the DMA address, and the page is
  568. * unmapped from the CPU.
  569. */
  570. static inline bool omap_gem_is_cached_coherent(struct drm_gem_object *obj)
  571. {
  572. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  573. return !((omap_obj->flags & OMAP_BO_MEM_SHMEM) &&
  574. ((omap_obj->flags & OMAP_BO_CACHE_MASK) == OMAP_BO_CACHED));
  575. }
  576. /* Sync the buffer for CPU access.. note pages should already be
  577. * attached, ie. omap_gem_get_pages()
  578. */
  579. void omap_gem_cpu_sync_page(struct drm_gem_object *obj, int pgoff)
  580. {
  581. struct drm_device *dev = obj->dev;
  582. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  583. if (omap_gem_is_cached_coherent(obj))
  584. return;
  585. if (omap_obj->dma_addrs[pgoff]) {
  586. dma_unmap_page(dev->dev, omap_obj->dma_addrs[pgoff],
  587. PAGE_SIZE, DMA_TO_DEVICE);
  588. omap_obj->dma_addrs[pgoff] = 0;
  589. }
  590. }
  591. /* sync the buffer for DMA access */
  592. void omap_gem_dma_sync_buffer(struct drm_gem_object *obj,
  593. enum dma_data_direction dir)
  594. {
  595. struct drm_device *dev = obj->dev;
  596. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  597. int i, npages = obj->size >> PAGE_SHIFT;
  598. struct page **pages = omap_obj->pages;
  599. bool dirty = false;
  600. if (omap_gem_is_cached_coherent(obj))
  601. return;
  602. for (i = 0; i < npages; i++) {
  603. if (!omap_obj->dma_addrs[i]) {
  604. dma_addr_t addr;
  605. addr = dma_map_page(dev->dev, pages[i], 0,
  606. PAGE_SIZE, dir);
  607. if (dma_mapping_error(dev->dev, addr)) {
  608. dev_warn(dev->dev, "%s: failed to map page\n",
  609. __func__);
  610. break;
  611. }
  612. dirty = true;
  613. omap_obj->dma_addrs[i] = addr;
  614. }
  615. }
  616. if (dirty) {
  617. unmap_mapping_range(obj->filp->f_mapping, 0,
  618. omap_gem_mmap_size(obj), 1);
  619. }
  620. }
  621. /**
  622. * omap_gem_pin() - Pin a GEM object in memory
  623. * @obj: the GEM object
  624. * @dma_addr: the DMA address
  625. *
  626. * Pin the given GEM object in memory and fill the dma_addr pointer with the
  627. * object's DMA address. If the buffer is not physically contiguous it will be
  628. * remapped through the TILER to provide a contiguous view.
  629. *
  630. * Pins are reference-counted, calling this function multiple times is allowed
  631. * as long the corresponding omap_gem_unpin() calls are balanced.
  632. *
  633. * Return 0 on success or a negative error code otherwise.
  634. */
  635. int omap_gem_pin(struct drm_gem_object *obj, dma_addr_t *dma_addr)
  636. {
  637. struct omap_drm_private *priv = obj->dev->dev_private;
  638. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  639. int ret = 0;
  640. mutex_lock(&omap_obj->lock);
  641. if (!omap_gem_is_contiguous(omap_obj) && priv->has_dmm) {
  642. if (refcount_read(&omap_obj->dma_addr_cnt) == 0) {
  643. u32 npages = obj->size >> PAGE_SHIFT;
  644. enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
  645. struct tiler_block *block;
  646. BUG_ON(omap_obj->block);
  647. refcount_set(&omap_obj->dma_addr_cnt, 1);
  648. ret = omap_gem_attach_pages(obj);
  649. if (ret)
  650. goto fail;
  651. if (omap_obj->flags & OMAP_BO_TILED_MASK) {
  652. block = tiler_reserve_2d(fmt,
  653. omap_obj->width,
  654. omap_obj->height, 0);
  655. } else {
  656. block = tiler_reserve_1d(obj->size);
  657. }
  658. if (IS_ERR(block)) {
  659. ret = PTR_ERR(block);
  660. dev_err(obj->dev->dev,
  661. "could not remap: %d (%d)\n", ret, fmt);
  662. goto fail;
  663. }
  664. /* TODO: enable async refill.. */
  665. ret = tiler_pin(block, omap_obj->pages, npages,
  666. omap_obj->roll, true);
  667. if (ret) {
  668. tiler_release(block);
  669. dev_err(obj->dev->dev,
  670. "could not pin: %d\n", ret);
  671. goto fail;
  672. }
  673. omap_obj->dma_addr = tiler_ssptr(block);
  674. omap_obj->block = block;
  675. DBG("got dma address: %pad", &omap_obj->dma_addr);
  676. } else {
  677. refcount_inc(&omap_obj->dma_addr_cnt);
  678. }
  679. if (dma_addr)
  680. *dma_addr = omap_obj->dma_addr;
  681. } else if (omap_gem_is_contiguous(omap_obj)) {
  682. if (dma_addr)
  683. *dma_addr = omap_obj->dma_addr;
  684. } else {
  685. ret = -EINVAL;
  686. goto fail;
  687. }
  688. fail:
  689. mutex_unlock(&omap_obj->lock);
  690. return ret;
  691. }
  692. /**
  693. * omap_gem_unpin_locked() - Unpin a GEM object from memory
  694. * @obj: the GEM object
  695. *
  696. * omap_gem_unpin() without locking.
  697. */
  698. static void omap_gem_unpin_locked(struct drm_gem_object *obj)
  699. {
  700. struct omap_drm_private *priv = obj->dev->dev_private;
  701. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  702. int ret;
  703. if (omap_gem_is_contiguous(omap_obj) || !priv->has_dmm)
  704. return;
  705. if (refcount_dec_and_test(&omap_obj->dma_addr_cnt)) {
  706. ret = tiler_unpin(omap_obj->block);
  707. if (ret) {
  708. dev_err(obj->dev->dev,
  709. "could not unpin pages: %d\n", ret);
  710. }
  711. ret = tiler_release(omap_obj->block);
  712. if (ret) {
  713. dev_err(obj->dev->dev,
  714. "could not release unmap: %d\n", ret);
  715. }
  716. omap_obj->dma_addr = 0;
  717. omap_obj->block = NULL;
  718. }
  719. }
  720. /**
  721. * omap_gem_unpin() - Unpin a GEM object from memory
  722. * @obj: the GEM object
  723. *
  724. * Unpin the given GEM object previously pinned with omap_gem_pin(). Pins are
  725. * reference-counted, the actual unpin will only be performed when the number
  726. * of calls to this function matches the number of calls to omap_gem_pin().
  727. */
  728. void omap_gem_unpin(struct drm_gem_object *obj)
  729. {
  730. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  731. mutex_lock(&omap_obj->lock);
  732. omap_gem_unpin_locked(obj);
  733. mutex_unlock(&omap_obj->lock);
  734. }
  735. /* Get rotated scanout address (only valid if already pinned), at the
  736. * specified orientation and x,y offset from top-left corner of buffer
  737. * (only valid for tiled 2d buffers)
  738. */
  739. int omap_gem_rotated_dma_addr(struct drm_gem_object *obj, u32 orient,
  740. int x, int y, dma_addr_t *dma_addr)
  741. {
  742. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  743. int ret = -EINVAL;
  744. mutex_lock(&omap_obj->lock);
  745. if ((refcount_read(&omap_obj->dma_addr_cnt) > 0) && omap_obj->block &&
  746. (omap_obj->flags & OMAP_BO_TILED_MASK)) {
  747. *dma_addr = tiler_tsptr(omap_obj->block, orient, x, y);
  748. ret = 0;
  749. }
  750. mutex_unlock(&omap_obj->lock);
  751. return ret;
  752. }
  753. /* Get tiler stride for the buffer (only valid for 2d tiled buffers) */
  754. int omap_gem_tiled_stride(struct drm_gem_object *obj, u32 orient)
  755. {
  756. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  757. int ret = -EINVAL;
  758. if (omap_obj->flags & OMAP_BO_TILED_MASK)
  759. ret = tiler_stride(gem2fmt(omap_obj->flags), orient);
  760. return ret;
  761. }
  762. /* if !remap, and we don't have pages backing, then fail, rather than
  763. * increasing the pin count (which we don't really do yet anyways,
  764. * because we don't support swapping pages back out). And 'remap'
  765. * might not be quite the right name, but I wanted to keep it working
  766. * similarly to omap_gem_pin(). Note though that mutex is not
  767. * aquired if !remap (because this can be called in atomic ctxt),
  768. * but probably omap_gem_unpin() should be changed to work in the
  769. * same way. If !remap, a matching omap_gem_put_pages() call is not
  770. * required (and should not be made).
  771. */
  772. int omap_gem_get_pages(struct drm_gem_object *obj, struct page ***pages,
  773. bool remap)
  774. {
  775. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  776. int ret = 0;
  777. mutex_lock(&omap_obj->lock);
  778. if (remap) {
  779. ret = omap_gem_attach_pages(obj);
  780. if (ret)
  781. goto unlock;
  782. }
  783. if (!omap_obj->pages) {
  784. ret = -ENOMEM;
  785. goto unlock;
  786. }
  787. *pages = omap_obj->pages;
  788. unlock:
  789. mutex_unlock(&omap_obj->lock);
  790. return ret;
  791. }
  792. /* release pages when DMA no longer being performed */
  793. int omap_gem_put_pages(struct drm_gem_object *obj)
  794. {
  795. /* do something here if we dynamically attach/detach pages.. at
  796. * least they would no longer need to be pinned if everyone has
  797. * released the pages..
  798. */
  799. return 0;
  800. }
  801. #ifdef CONFIG_DRM_FBDEV_EMULATION
  802. /*
  803. * Get kernel virtual address for CPU access.. this more or less only
  804. * exists for omap_fbdev.
  805. */
  806. void *omap_gem_vaddr(struct drm_gem_object *obj)
  807. {
  808. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  809. void *vaddr;
  810. int ret;
  811. mutex_lock(&omap_obj->lock);
  812. if (!omap_obj->vaddr) {
  813. ret = omap_gem_attach_pages(obj);
  814. if (ret) {
  815. vaddr = ERR_PTR(ret);
  816. goto unlock;
  817. }
  818. omap_obj->vaddr = vmap(omap_obj->pages, obj->size >> PAGE_SHIFT,
  819. VM_MAP, pgprot_writecombine(PAGE_KERNEL));
  820. }
  821. vaddr = omap_obj->vaddr;
  822. unlock:
  823. mutex_unlock(&omap_obj->lock);
  824. return vaddr;
  825. }
  826. #endif
  827. /* -----------------------------------------------------------------------------
  828. * Power Management
  829. */
  830. #ifdef CONFIG_PM
  831. /* re-pin objects in DMM in resume path: */
  832. int omap_gem_resume(struct drm_device *dev)
  833. {
  834. struct omap_drm_private *priv = dev->dev_private;
  835. struct omap_gem_object *omap_obj;
  836. int ret = 0;
  837. mutex_lock(&priv->list_lock);
  838. list_for_each_entry(omap_obj, &priv->obj_list, mm_list) {
  839. if (omap_obj->block) {
  840. struct drm_gem_object *obj = &omap_obj->base;
  841. u32 npages = obj->size >> PAGE_SHIFT;
  842. WARN_ON(!omap_obj->pages); /* this can't happen */
  843. ret = tiler_pin(omap_obj->block,
  844. omap_obj->pages, npages,
  845. omap_obj->roll, true);
  846. if (ret) {
  847. dev_err(dev->dev, "could not repin: %d\n", ret);
  848. goto done;
  849. }
  850. }
  851. }
  852. done:
  853. mutex_unlock(&priv->list_lock);
  854. return ret;
  855. }
  856. #endif
  857. /* -----------------------------------------------------------------------------
  858. * DebugFS
  859. */
  860. #ifdef CONFIG_DEBUG_FS
  861. void omap_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
  862. {
  863. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  864. u64 off;
  865. off = drm_vma_node_start(&obj->vma_node);
  866. mutex_lock(&omap_obj->lock);
  867. seq_printf(m, "%08x: %2d (%2d) %08llx %pad (%2d) %p %4d",
  868. omap_obj->flags, obj->name, kref_read(&obj->refcount),
  869. off, &omap_obj->dma_addr,
  870. refcount_read(&omap_obj->dma_addr_cnt),
  871. omap_obj->vaddr, omap_obj->roll);
  872. if (omap_obj->flags & OMAP_BO_TILED_MASK) {
  873. seq_printf(m, " %dx%d", omap_obj->width, omap_obj->height);
  874. if (omap_obj->block) {
  875. struct tcm_area *area = &omap_obj->block->area;
  876. seq_printf(m, " (%dx%d, %dx%d)",
  877. area->p0.x, area->p0.y,
  878. area->p1.x, area->p1.y);
  879. }
  880. } else {
  881. seq_printf(m, " %zu", obj->size);
  882. }
  883. mutex_unlock(&omap_obj->lock);
  884. seq_printf(m, "\n");
  885. }
  886. void omap_gem_describe_objects(struct list_head *list, struct seq_file *m)
  887. {
  888. struct omap_gem_object *omap_obj;
  889. int count = 0;
  890. size_t size = 0;
  891. list_for_each_entry(omap_obj, list, mm_list) {
  892. struct drm_gem_object *obj = &omap_obj->base;
  893. seq_printf(m, " ");
  894. omap_gem_describe(obj, m);
  895. count++;
  896. size += obj->size;
  897. }
  898. seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
  899. }
  900. #endif
  901. /* -----------------------------------------------------------------------------
  902. * Constructor & Destructor
  903. */
  904. void omap_gem_free_object(struct drm_gem_object *obj)
  905. {
  906. struct drm_device *dev = obj->dev;
  907. struct omap_drm_private *priv = dev->dev_private;
  908. struct omap_gem_object *omap_obj = to_omap_bo(obj);
  909. omap_gem_evict(obj);
  910. mutex_lock(&priv->list_lock);
  911. list_del(&omap_obj->mm_list);
  912. mutex_unlock(&priv->list_lock);
  913. /*
  914. * We own the sole reference to the object at this point, but to keep
  915. * lockdep happy, we must still take the omap_obj_lock to call
  916. * omap_gem_detach_pages(). This should hardly make any difference as
  917. * there can't be any lock contention.
  918. */
  919. mutex_lock(&omap_obj->lock);
  920. /* The object should not be pinned. */
  921. WARN_ON(refcount_read(&omap_obj->dma_addr_cnt) > 0);
  922. if (omap_obj->pages) {
  923. if (omap_obj->flags & OMAP_BO_MEM_DMABUF)
  924. kfree(omap_obj->pages);
  925. else
  926. omap_gem_detach_pages(obj);
  927. }
  928. if (omap_obj->flags & OMAP_BO_MEM_DMA_API) {
  929. dma_free_wc(dev->dev, obj->size, omap_obj->vaddr,
  930. omap_obj->dma_addr);
  931. } else if (omap_obj->vaddr) {
  932. vunmap(omap_obj->vaddr);
  933. } else if (obj->import_attach) {
  934. drm_prime_gem_destroy(obj, omap_obj->sgt);
  935. }
  936. mutex_unlock(&omap_obj->lock);
  937. drm_gem_object_release(obj);
  938. mutex_destroy(&omap_obj->lock);
  939. kfree(omap_obj);
  940. }
  941. static bool omap_gem_validate_flags(struct drm_device *dev, u32 flags)
  942. {
  943. struct omap_drm_private *priv = dev->dev_private;
  944. switch (flags & OMAP_BO_CACHE_MASK) {
  945. case OMAP_BO_CACHED:
  946. case OMAP_BO_WC:
  947. case OMAP_BO_CACHE_MASK:
  948. break;
  949. default:
  950. return false;
  951. }
  952. if (flags & OMAP_BO_TILED_MASK) {
  953. if (!priv->usergart)
  954. return false;
  955. switch (flags & OMAP_BO_TILED_MASK) {
  956. case OMAP_BO_TILED_8:
  957. case OMAP_BO_TILED_16:
  958. case OMAP_BO_TILED_32:
  959. break;
  960. default:
  961. return false;
  962. }
  963. }
  964. return true;
  965. }
  966. /* GEM buffer object constructor */
  967. struct drm_gem_object *omap_gem_new(struct drm_device *dev,
  968. union omap_gem_size gsize, u32 flags)
  969. {
  970. struct omap_drm_private *priv = dev->dev_private;
  971. struct omap_gem_object *omap_obj;
  972. struct drm_gem_object *obj;
  973. struct address_space *mapping;
  974. size_t size;
  975. int ret;
  976. if (!omap_gem_validate_flags(dev, flags))
  977. return NULL;
  978. /* Validate the flags and compute the memory and cache flags. */
  979. if (flags & OMAP_BO_TILED_MASK) {
  980. /*
  981. * Tiled buffers are always shmem paged backed. When they are
  982. * scanned out, they are remapped into DMM/TILER.
  983. */
  984. flags |= OMAP_BO_MEM_SHMEM;
  985. /*
  986. * Currently don't allow cached buffers. There is some caching
  987. * stuff that needs to be handled better.
  988. */
  989. flags &= ~(OMAP_BO_CACHED|OMAP_BO_WC|OMAP_BO_UNCACHED);
  990. flags |= tiler_get_cpu_cache_flags();
  991. } else if ((flags & OMAP_BO_SCANOUT) && !priv->has_dmm) {
  992. /*
  993. * If we don't have DMM, we must allocate scanout buffers
  994. * from contiguous DMA memory.
  995. */
  996. flags |= OMAP_BO_MEM_DMA_API;
  997. } else if (!(flags & OMAP_BO_MEM_DMABUF)) {
  998. /*
  999. * All other buffers not backed by dma_buf are shmem-backed.
  1000. */
  1001. flags |= OMAP_BO_MEM_SHMEM;
  1002. }
  1003. /* Allocate the initialize the OMAP GEM object. */
  1004. omap_obj = kzalloc(sizeof(*omap_obj), GFP_KERNEL);
  1005. if (!omap_obj)
  1006. return NULL;
  1007. obj = &omap_obj->base;
  1008. omap_obj->flags = flags;
  1009. mutex_init(&omap_obj->lock);
  1010. if (flags & OMAP_BO_TILED_MASK) {
  1011. /*
  1012. * For tiled buffers align dimensions to slot boundaries and
  1013. * calculate size based on aligned dimensions.
  1014. */
  1015. tiler_align(gem2fmt(flags), &gsize.tiled.width,
  1016. &gsize.tiled.height);
  1017. size = tiler_size(gem2fmt(flags), gsize.tiled.width,
  1018. gsize.tiled.height);
  1019. omap_obj->width = gsize.tiled.width;
  1020. omap_obj->height = gsize.tiled.height;
  1021. } else {
  1022. size = PAGE_ALIGN(gsize.bytes);
  1023. }
  1024. /* Initialize the GEM object. */
  1025. if (!(flags & OMAP_BO_MEM_SHMEM)) {
  1026. drm_gem_private_object_init(dev, obj, size);
  1027. } else {
  1028. ret = drm_gem_object_init(dev, obj, size);
  1029. if (ret)
  1030. goto err_free;
  1031. mapping = obj->filp->f_mapping;
  1032. mapping_set_gfp_mask(mapping, GFP_USER | __GFP_DMA32);
  1033. }
  1034. /* Allocate memory if needed. */
  1035. if (flags & OMAP_BO_MEM_DMA_API) {
  1036. omap_obj->vaddr = dma_alloc_wc(dev->dev, size,
  1037. &omap_obj->dma_addr,
  1038. GFP_KERNEL);
  1039. if (!omap_obj->vaddr)
  1040. goto err_release;
  1041. }
  1042. mutex_lock(&priv->list_lock);
  1043. list_add(&omap_obj->mm_list, &priv->obj_list);
  1044. mutex_unlock(&priv->list_lock);
  1045. return obj;
  1046. err_release:
  1047. drm_gem_object_release(obj);
  1048. err_free:
  1049. kfree(omap_obj);
  1050. return NULL;
  1051. }
  1052. struct drm_gem_object *omap_gem_new_dmabuf(struct drm_device *dev, size_t size,
  1053. struct sg_table *sgt)
  1054. {
  1055. struct omap_drm_private *priv = dev->dev_private;
  1056. struct omap_gem_object *omap_obj;
  1057. struct drm_gem_object *obj;
  1058. union omap_gem_size gsize;
  1059. /* Without a DMM only physically contiguous buffers can be supported. */
  1060. if (sgt->orig_nents != 1 && !priv->has_dmm)
  1061. return ERR_PTR(-EINVAL);
  1062. gsize.bytes = PAGE_ALIGN(size);
  1063. obj = omap_gem_new(dev, gsize, OMAP_BO_MEM_DMABUF | OMAP_BO_WC);
  1064. if (!obj)
  1065. return ERR_PTR(-ENOMEM);
  1066. omap_obj = to_omap_bo(obj);
  1067. mutex_lock(&omap_obj->lock);
  1068. omap_obj->sgt = sgt;
  1069. if (sgt->orig_nents == 1) {
  1070. omap_obj->dma_addr = sg_dma_address(sgt->sgl);
  1071. } else {
  1072. /* Create pages list from sgt */
  1073. struct page **pages;
  1074. unsigned int npages;
  1075. unsigned int ret;
  1076. npages = DIV_ROUND_UP(size, PAGE_SIZE);
  1077. pages = kcalloc(npages, sizeof(*pages), GFP_KERNEL);
  1078. if (!pages) {
  1079. omap_gem_free_object(obj);
  1080. obj = ERR_PTR(-ENOMEM);
  1081. goto done;
  1082. }
  1083. omap_obj->pages = pages;
  1084. ret = drm_prime_sg_to_page_addr_arrays(sgt, pages, NULL,
  1085. npages);
  1086. if (ret) {
  1087. omap_gem_free_object(obj);
  1088. obj = ERR_PTR(-ENOMEM);
  1089. goto done;
  1090. }
  1091. }
  1092. done:
  1093. mutex_unlock(&omap_obj->lock);
  1094. return obj;
  1095. }
  1096. /* convenience method to construct a GEM buffer object, and userspace handle */
  1097. int omap_gem_new_handle(struct drm_device *dev, struct drm_file *file,
  1098. union omap_gem_size gsize, u32 flags, u32 *handle)
  1099. {
  1100. struct drm_gem_object *obj;
  1101. int ret;
  1102. obj = omap_gem_new(dev, gsize, flags);
  1103. if (!obj)
  1104. return -ENOMEM;
  1105. ret = drm_gem_handle_create(file, obj, handle);
  1106. if (ret) {
  1107. omap_gem_free_object(obj);
  1108. return ret;
  1109. }
  1110. /* drop reference from allocate - handle holds it now */
  1111. drm_gem_object_put(obj);
  1112. return 0;
  1113. }
  1114. /* -----------------------------------------------------------------------------
  1115. * Init & Cleanup
  1116. */
  1117. /* If DMM is used, we need to set some stuff up.. */
  1118. void omap_gem_init(struct drm_device *dev)
  1119. {
  1120. struct omap_drm_private *priv = dev->dev_private;
  1121. struct omap_drm_usergart *usergart;
  1122. const enum tiler_fmt fmts[] = {
  1123. TILFMT_8BIT, TILFMT_16BIT, TILFMT_32BIT
  1124. };
  1125. int i, j;
  1126. if (!dmm_is_available()) {
  1127. /* DMM only supported on OMAP4 and later, so this isn't fatal */
  1128. dev_warn(dev->dev, "DMM not available, disable DMM support\n");
  1129. return;
  1130. }
  1131. usergart = kcalloc(3, sizeof(*usergart), GFP_KERNEL);
  1132. if (!usergart)
  1133. return;
  1134. /* reserve 4k aligned/wide regions for userspace mappings: */
  1135. for (i = 0; i < ARRAY_SIZE(fmts); i++) {
  1136. u16 h = 1, w = PAGE_SIZE >> i;
  1137. tiler_align(fmts[i], &w, &h);
  1138. /* note: since each region is 1 4kb page wide, and minimum
  1139. * number of rows, the height ends up being the same as the
  1140. * # of pages in the region
  1141. */
  1142. usergart[i].height = h;
  1143. usergart[i].height_shift = ilog2(h);
  1144. usergart[i].stride_pfn = tiler_stride(fmts[i], 0) >> PAGE_SHIFT;
  1145. usergart[i].slot_shift = ilog2((PAGE_SIZE / h) >> i);
  1146. for (j = 0; j < NUM_USERGART_ENTRIES; j++) {
  1147. struct omap_drm_usergart_entry *entry;
  1148. struct tiler_block *block;
  1149. entry = &usergart[i].entry[j];
  1150. block = tiler_reserve_2d(fmts[i], w, h, PAGE_SIZE);
  1151. if (IS_ERR(block)) {
  1152. dev_err(dev->dev,
  1153. "reserve failed: %d, %d, %ld\n",
  1154. i, j, PTR_ERR(block));
  1155. return;
  1156. }
  1157. entry->dma_addr = tiler_ssptr(block);
  1158. entry->block = block;
  1159. DBG("%d:%d: %dx%d: dma_addr=%pad stride=%d", i, j, w, h,
  1160. &entry->dma_addr,
  1161. usergart[i].stride_pfn << PAGE_SHIFT);
  1162. }
  1163. }
  1164. priv->usergart = usergart;
  1165. priv->has_dmm = true;
  1166. }
  1167. void omap_gem_deinit(struct drm_device *dev)
  1168. {
  1169. struct omap_drm_private *priv = dev->dev_private;
  1170. /* I believe we can rely on there being no more outstanding GEM
  1171. * objects which could depend on usergart/dmm at this point.
  1172. */
  1173. kfree(priv->usergart);
  1174. }