1
2
3
4
5
6
7#include <linux/seq_file.h>
8#include <linux/shmem_fs.h>
9#include <linux/spinlock.h>
10#include <linux/pfn_t.h>
11
12#include <drm/drm_vma_manager.h>
13
14#include "omap_drv.h"
15#include "omap_dmm_tiler.h"
16
17
18
19
20
21
22#define OMAP_BO_MEM_DMA_API 0x01000000
23#define OMAP_BO_MEM_SHMEM 0x02000000
24#define OMAP_BO_MEM_DMABUF 0x08000000
25
26struct omap_gem_object {
27 struct drm_gem_object base;
28
29 struct list_head mm_list;
30
31 u32 flags;
32
33
34 u16 width, height;
35
36
37 u32 roll;
38
39
40 struct mutex lock;
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63 dma_addr_t dma_addr;
64
65
66
67
68 u32 dma_addr_cnt;
69
70
71
72
73
74 struct sg_table *sgt;
75
76
77
78
79 struct tiler_block *block;
80
81
82
83
84
85 struct page **pages;
86
87
88 dma_addr_t *dma_addrs;
89
90
91
92
93 void *vaddr;
94};
95
96#define to_omap_bo(x) container_of(x, struct omap_gem_object, base)
97
98
99
100
101
102
103
104
105
106
107
108
109#define NUM_USERGART_ENTRIES 2
110struct omap_drm_usergart_entry {
111 struct tiler_block *block;
112 dma_addr_t dma_addr;
113 struct drm_gem_object *obj;
114 pgoff_t obj_pgoff;
115
116};
117
118struct omap_drm_usergart {
119 struct omap_drm_usergart_entry entry[NUM_USERGART_ENTRIES];
120 int height;
121 int height_shift;
122 int slot_shift;
123 int stride_pfn;
124 int last;
125};
126
127
128
129
130
131
132u64 omap_gem_mmap_offset(struct drm_gem_object *obj)
133{
134 struct drm_device *dev = obj->dev;
135 int ret;
136 size_t size;
137
138
139 size = omap_gem_mmap_size(obj);
140 ret = drm_gem_create_mmap_offset_size(obj, size);
141 if (ret) {
142 dev_err(dev->dev, "could not allocate mmap offset\n");
143 return 0;
144 }
145
146 return drm_vma_node_offset_addr(&obj->vma_node);
147}
148
149static bool omap_gem_is_contiguous(struct omap_gem_object *omap_obj)
150{
151 if (omap_obj->flags & OMAP_BO_MEM_DMA_API)
152 return true;
153
154 if ((omap_obj->flags & OMAP_BO_MEM_DMABUF) && omap_obj->sgt->nents == 1)
155 return true;
156
157 return false;
158}
159
160
161
162
163
164static void omap_gem_evict_entry(struct drm_gem_object *obj,
165 enum tiler_fmt fmt, struct omap_drm_usergart_entry *entry)
166{
167 struct omap_gem_object *omap_obj = to_omap_bo(obj);
168 struct omap_drm_private *priv = obj->dev->dev_private;
169 int n = priv->usergart[fmt].height;
170 size_t size = PAGE_SIZE * n;
171 loff_t off = omap_gem_mmap_offset(obj) +
172 (entry->obj_pgoff << PAGE_SHIFT);
173 const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);
174
175 if (m > 1) {
176 int i;
177
178 for (i = n; i > 0; i--) {
179 unmap_mapping_range(obj->dev->anon_inode->i_mapping,
180 off, PAGE_SIZE, 1);
181 off += PAGE_SIZE * m;
182 }
183 } else {
184 unmap_mapping_range(obj->dev->anon_inode->i_mapping,
185 off, size, 1);
186 }
187
188 entry->obj = NULL;
189}
190
191
192static void omap_gem_evict(struct drm_gem_object *obj)
193{
194 struct omap_gem_object *omap_obj = to_omap_bo(obj);
195 struct omap_drm_private *priv = obj->dev->dev_private;
196
197 if (omap_obj->flags & OMAP_BO_TILED) {
198 enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
199 int i;
200
201 for (i = 0; i < NUM_USERGART_ENTRIES; i++) {
202 struct omap_drm_usergart_entry *entry =
203 &priv->usergart[fmt].entry[i];
204
205 if (entry->obj == obj)
206 omap_gem_evict_entry(obj, fmt, entry);
207 }
208 }
209}
210
211
212
213
214
215
216
217
218
219static int omap_gem_attach_pages(struct drm_gem_object *obj)
220{
221 struct drm_device *dev = obj->dev;
222 struct omap_gem_object *omap_obj = to_omap_bo(obj);
223 struct page **pages;
224 int npages = obj->size >> PAGE_SHIFT;
225 int i, ret;
226 dma_addr_t *addrs;
227
228 lockdep_assert_held(&omap_obj->lock);
229
230
231
232
233
234 if (!(omap_obj->flags & OMAP_BO_MEM_SHMEM) || omap_obj->pages)
235 return 0;
236
237 pages = drm_gem_get_pages(obj);
238 if (IS_ERR(pages)) {
239 dev_err(obj->dev->dev, "could not get pages: %ld\n", PTR_ERR(pages));
240 return PTR_ERR(pages);
241 }
242
243
244
245
246 if (omap_obj->flags & (OMAP_BO_WC|OMAP_BO_UNCACHED)) {
247 addrs = kmalloc_array(npages, sizeof(*addrs), GFP_KERNEL);
248 if (!addrs) {
249 ret = -ENOMEM;
250 goto free_pages;
251 }
252
253 for (i = 0; i < npages; i++) {
254 addrs[i] = dma_map_page(dev->dev, pages[i],
255 0, PAGE_SIZE, DMA_TO_DEVICE);
256
257 if (dma_mapping_error(dev->dev, addrs[i])) {
258 dev_warn(dev->dev,
259 "%s: failed to map page\n", __func__);
260
261 for (i = i - 1; i >= 0; --i) {
262 dma_unmap_page(dev->dev, addrs[i],
263 PAGE_SIZE, DMA_TO_DEVICE);
264 }
265
266 ret = -ENOMEM;
267 goto free_addrs;
268 }
269 }
270 } else {
271 addrs = kcalloc(npages, sizeof(*addrs), GFP_KERNEL);
272 if (!addrs) {
273 ret = -ENOMEM;
274 goto free_pages;
275 }
276 }
277
278 omap_obj->dma_addrs = addrs;
279 omap_obj->pages = pages;
280
281 return 0;
282
283free_addrs:
284 kfree(addrs);
285free_pages:
286 drm_gem_put_pages(obj, pages, true, false);
287
288 return ret;
289}
290
291
292static void omap_gem_detach_pages(struct drm_gem_object *obj)
293{
294 struct omap_gem_object *omap_obj = to_omap_bo(obj);
295 unsigned int npages = obj->size >> PAGE_SHIFT;
296 unsigned int i;
297
298 lockdep_assert_held(&omap_obj->lock);
299
300 for (i = 0; i < npages; i++) {
301 if (omap_obj->dma_addrs[i])
302 dma_unmap_page(obj->dev->dev, omap_obj->dma_addrs[i],
303 PAGE_SIZE, DMA_TO_DEVICE);
304 }
305
306 kfree(omap_obj->dma_addrs);
307 omap_obj->dma_addrs = NULL;
308
309 drm_gem_put_pages(obj, omap_obj->pages, true, false);
310 omap_obj->pages = NULL;
311}
312
313
314u32 omap_gem_flags(struct drm_gem_object *obj)
315{
316 return to_omap_bo(obj)->flags;
317}
318
319
320size_t omap_gem_mmap_size(struct drm_gem_object *obj)
321{
322 struct omap_gem_object *omap_obj = to_omap_bo(obj);
323 size_t size = obj->size;
324
325 if (omap_obj->flags & OMAP_BO_TILED) {
326
327
328
329
330
331
332 size = tiler_vsize(gem2fmt(omap_obj->flags),
333 omap_obj->width, omap_obj->height);
334 }
335
336 return size;
337}
338
339
340
341
342
343
344static vm_fault_t omap_gem_fault_1d(struct drm_gem_object *obj,
345 struct vm_area_struct *vma, struct vm_fault *vmf)
346{
347 struct omap_gem_object *omap_obj = to_omap_bo(obj);
348 unsigned long pfn;
349 pgoff_t pgoff;
350
351
352 pgoff = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
353
354 if (omap_obj->pages) {
355 omap_gem_cpu_sync_page(obj, pgoff);
356 pfn = page_to_pfn(omap_obj->pages[pgoff]);
357 } else {
358 BUG_ON(!omap_gem_is_contiguous(omap_obj));
359 pfn = (omap_obj->dma_addr >> PAGE_SHIFT) + pgoff;
360 }
361
362 VERB("Inserting %p pfn %lx, pa %lx", (void *)vmf->address,
363 pfn, pfn << PAGE_SHIFT);
364
365 return vmf_insert_mixed(vma, vmf->address,
366 __pfn_to_pfn_t(pfn, PFN_DEV));
367}
368
369
370static vm_fault_t omap_gem_fault_2d(struct drm_gem_object *obj,
371 struct vm_area_struct *vma, struct vm_fault *vmf)
372{
373 struct omap_gem_object *omap_obj = to_omap_bo(obj);
374 struct omap_drm_private *priv = obj->dev->dev_private;
375 struct omap_drm_usergart_entry *entry;
376 enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
377 struct page *pages[64];
378 unsigned long pfn;
379 pgoff_t pgoff, base_pgoff;
380 unsigned long vaddr;
381 int i, err, slots;
382 vm_fault_t ret = VM_FAULT_NOPAGE;
383
384
385
386
387
388
389 const int n = priv->usergart[fmt].height;
390 const int n_shift = priv->usergart[fmt].height_shift;
391
392
393
394
395
396
397
398 const int m = DIV_ROUND_UP(omap_obj->width << fmt, PAGE_SIZE);
399
400
401 pgoff = (vmf->address - vma->vm_start) >> PAGE_SHIFT;
402
403
404
405
406
407 base_pgoff = round_down(pgoff, m << n_shift);
408
409
410 slots = omap_obj->width >> priv->usergart[fmt].slot_shift;
411
412 vaddr = vmf->address - ((pgoff - base_pgoff) << PAGE_SHIFT);
413
414 entry = &priv->usergart[fmt].entry[priv->usergart[fmt].last];
415
416
417 if (entry->obj)
418 omap_gem_evict_entry(entry->obj, fmt, entry);
419
420 entry->obj = obj;
421 entry->obj_pgoff = base_pgoff;
422
423
424 base_pgoff = (base_pgoff >> n_shift) * slots;
425
426
427 if (m > 1) {
428 int off = pgoff % m;
429 entry->obj_pgoff += off;
430 base_pgoff /= m;
431 slots = min(slots - (off << n_shift), n);
432 base_pgoff += off << n_shift;
433 vaddr += off << PAGE_SHIFT;
434 }
435
436
437
438
439
440
441
442
443 memcpy(pages, &omap_obj->pages[base_pgoff],
444 sizeof(struct page *) * slots);
445 memset(pages + slots, 0,
446 sizeof(struct page *) * (n - slots));
447
448 err = tiler_pin(entry->block, pages, ARRAY_SIZE(pages), 0, true);
449 if (err) {
450 ret = vmf_error(err);
451 dev_err(obj->dev->dev, "failed to pin: %d\n", err);
452 return ret;
453 }
454
455 pfn = entry->dma_addr >> PAGE_SHIFT;
456
457 VERB("Inserting %p pfn %lx, pa %lx", (void *)vmf->address,
458 pfn, pfn << PAGE_SHIFT);
459
460 for (i = n; i > 0; i--) {
461 ret = vmf_insert_mixed(vma,
462 vaddr, __pfn_to_pfn_t(pfn, PFN_DEV));
463 if (ret & VM_FAULT_ERROR)
464 break;
465 pfn += priv->usergart[fmt].stride_pfn;
466 vaddr += PAGE_SIZE * m;
467 }
468
469
470 priv->usergart[fmt].last = (priv->usergart[fmt].last + 1)
471 % NUM_USERGART_ENTRIES;
472
473 return ret;
474}
475
476
477
478
479
480
481
482
483
484
485
486
487
488vm_fault_t omap_gem_fault(struct vm_fault *vmf)
489{
490 struct vm_area_struct *vma = vmf->vma;
491 struct drm_gem_object *obj = vma->vm_private_data;
492 struct omap_gem_object *omap_obj = to_omap_bo(obj);
493 int err;
494 vm_fault_t ret;
495
496
497
498
499 mutex_lock(&omap_obj->lock);
500
501
502 err = omap_gem_attach_pages(obj);
503 if (err) {
504 ret = vmf_error(err);
505 goto fail;
506 }
507
508
509
510
511
512
513
514 if (omap_obj->flags & OMAP_BO_TILED)
515 ret = omap_gem_fault_2d(obj, vma, vmf);
516 else
517 ret = omap_gem_fault_1d(obj, vma, vmf);
518
519
520fail:
521 mutex_unlock(&omap_obj->lock);
522 return ret;
523}
524
525
526int omap_gem_mmap(struct file *filp, struct vm_area_struct *vma)
527{
528 int ret;
529
530 ret = drm_gem_mmap(filp, vma);
531 if (ret) {
532 DBG("mmap failed: %d", ret);
533 return ret;
534 }
535
536 return omap_gem_mmap_obj(vma->vm_private_data, vma);
537}
538
539int omap_gem_mmap_obj(struct drm_gem_object *obj,
540 struct vm_area_struct *vma)
541{
542 struct omap_gem_object *omap_obj = to_omap_bo(obj);
543
544 vma->vm_flags &= ~VM_PFNMAP;
545 vma->vm_flags |= VM_MIXEDMAP;
546
547 if (omap_obj->flags & OMAP_BO_WC) {
548 vma->vm_page_prot = pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
549 } else if (omap_obj->flags & OMAP_BO_UNCACHED) {
550 vma->vm_page_prot = pgprot_noncached(vm_get_page_prot(vma->vm_flags));
551 } else {
552
553
554
555
556
557 if (WARN_ON(!obj->filp))
558 return -EINVAL;
559
560
561
562
563
564
565 fput(vma->vm_file);
566 vma->vm_pgoff = 0;
567 vma->vm_file = get_file(obj->filp);
568
569 vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
570 }
571
572 return 0;
573}
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589int omap_gem_dumb_create(struct drm_file *file, struct drm_device *dev,
590 struct drm_mode_create_dumb *args)
591{
592 union omap_gem_size gsize;
593
594 args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
595
596 args->size = PAGE_ALIGN(args->pitch * args->height);
597
598 gsize = (union omap_gem_size){
599 .bytes = args->size,
600 };
601
602 return omap_gem_new_handle(dev, file, gsize,
603 OMAP_BO_SCANOUT | OMAP_BO_WC, &args->handle);
604}
605
606
607
608
609
610
611
612
613
614
615int omap_gem_dumb_map_offset(struct drm_file *file, struct drm_device *dev,
616 u32 handle, u64 *offset)
617{
618 struct drm_gem_object *obj;
619 int ret = 0;
620
621
622 obj = drm_gem_object_lookup(file, handle);
623 if (obj == NULL) {
624 ret = -ENOENT;
625 goto fail;
626 }
627
628 *offset = omap_gem_mmap_offset(obj);
629
630 drm_gem_object_put_unlocked(obj);
631
632fail:
633 return ret;
634}
635
636#ifdef CONFIG_DRM_FBDEV_EMULATION
637
638
639
640
641
642int omap_gem_roll(struct drm_gem_object *obj, u32 roll)
643{
644 struct omap_gem_object *omap_obj = to_omap_bo(obj);
645 u32 npages = obj->size >> PAGE_SHIFT;
646 int ret = 0;
647
648 if (roll > npages) {
649 dev_err(obj->dev->dev, "invalid roll: %d\n", roll);
650 return -EINVAL;
651 }
652
653 omap_obj->roll = roll;
654
655 mutex_lock(&omap_obj->lock);
656
657
658 if (omap_obj->block) {
659 ret = omap_gem_attach_pages(obj);
660 if (ret)
661 goto fail;
662
663 ret = tiler_pin(omap_obj->block, omap_obj->pages, npages,
664 roll, true);
665 if (ret)
666 dev_err(obj->dev->dev, "could not repin: %d\n", ret);
667 }
668
669fail:
670 mutex_unlock(&omap_obj->lock);
671
672 return ret;
673}
674#endif
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689static inline bool omap_gem_is_cached_coherent(struct drm_gem_object *obj)
690{
691 struct omap_gem_object *omap_obj = to_omap_bo(obj);
692
693 return !((omap_obj->flags & OMAP_BO_MEM_SHMEM) &&
694 ((omap_obj->flags & OMAP_BO_CACHE_MASK) == OMAP_BO_CACHED));
695}
696
697
698
699
700void omap_gem_cpu_sync_page(struct drm_gem_object *obj, int pgoff)
701{
702 struct drm_device *dev = obj->dev;
703 struct omap_gem_object *omap_obj = to_omap_bo(obj);
704
705 if (omap_gem_is_cached_coherent(obj))
706 return;
707
708 if (omap_obj->dma_addrs[pgoff]) {
709 dma_unmap_page(dev->dev, omap_obj->dma_addrs[pgoff],
710 PAGE_SIZE, DMA_TO_DEVICE);
711 omap_obj->dma_addrs[pgoff] = 0;
712 }
713}
714
715
716void omap_gem_dma_sync_buffer(struct drm_gem_object *obj,
717 enum dma_data_direction dir)
718{
719 struct drm_device *dev = obj->dev;
720 struct omap_gem_object *omap_obj = to_omap_bo(obj);
721 int i, npages = obj->size >> PAGE_SHIFT;
722 struct page **pages = omap_obj->pages;
723 bool dirty = false;
724
725 if (omap_gem_is_cached_coherent(obj))
726 return;
727
728 for (i = 0; i < npages; i++) {
729 if (!omap_obj->dma_addrs[i]) {
730 dma_addr_t addr;
731
732 addr = dma_map_page(dev->dev, pages[i], 0,
733 PAGE_SIZE, dir);
734 if (dma_mapping_error(dev->dev, addr)) {
735 dev_warn(dev->dev, "%s: failed to map page\n",
736 __func__);
737 break;
738 }
739
740 dirty = true;
741 omap_obj->dma_addrs[i] = addr;
742 }
743 }
744
745 if (dirty) {
746 unmap_mapping_range(obj->filp->f_mapping, 0,
747 omap_gem_mmap_size(obj), 1);
748 }
749}
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765int omap_gem_pin(struct drm_gem_object *obj, dma_addr_t *dma_addr)
766{
767 struct omap_drm_private *priv = obj->dev->dev_private;
768 struct omap_gem_object *omap_obj = to_omap_bo(obj);
769 int ret = 0;
770
771 mutex_lock(&omap_obj->lock);
772
773 if (!omap_gem_is_contiguous(omap_obj) && priv->has_dmm) {
774 if (omap_obj->dma_addr_cnt == 0) {
775 u32 npages = obj->size >> PAGE_SHIFT;
776 enum tiler_fmt fmt = gem2fmt(omap_obj->flags);
777 struct tiler_block *block;
778
779 BUG_ON(omap_obj->block);
780
781 ret = omap_gem_attach_pages(obj);
782 if (ret)
783 goto fail;
784
785 if (omap_obj->flags & OMAP_BO_TILED) {
786 block = tiler_reserve_2d(fmt,
787 omap_obj->width,
788 omap_obj->height, 0);
789 } else {
790 block = tiler_reserve_1d(obj->size);
791 }
792
793 if (IS_ERR(block)) {
794 ret = PTR_ERR(block);
795 dev_err(obj->dev->dev,
796 "could not remap: %d (%d)\n", ret, fmt);
797 goto fail;
798 }
799
800
801 ret = tiler_pin(block, omap_obj->pages, npages,
802 omap_obj->roll, true);
803 if (ret) {
804 tiler_release(block);
805 dev_err(obj->dev->dev,
806 "could not pin: %d\n", ret);
807 goto fail;
808 }
809
810 omap_obj->dma_addr = tiler_ssptr(block);
811 omap_obj->block = block;
812
813 DBG("got dma address: %pad", &omap_obj->dma_addr);
814 }
815
816 omap_obj->dma_addr_cnt++;
817
818 *dma_addr = omap_obj->dma_addr;
819 } else if (omap_gem_is_contiguous(omap_obj)) {
820 *dma_addr = omap_obj->dma_addr;
821 } else {
822 ret = -EINVAL;
823 goto fail;
824 }
825
826fail:
827 mutex_unlock(&omap_obj->lock);
828
829 return ret;
830}
831
832
833
834
835
836
837
838
839
840void omap_gem_unpin(struct drm_gem_object *obj)
841{
842 struct omap_gem_object *omap_obj = to_omap_bo(obj);
843 int ret;
844
845 mutex_lock(&omap_obj->lock);
846
847 if (omap_obj->dma_addr_cnt > 0) {
848 omap_obj->dma_addr_cnt--;
849 if (omap_obj->dma_addr_cnt == 0) {
850 ret = tiler_unpin(omap_obj->block);
851 if (ret) {
852 dev_err(obj->dev->dev,
853 "could not unpin pages: %d\n", ret);
854 }
855 ret = tiler_release(omap_obj->block);
856 if (ret) {
857 dev_err(obj->dev->dev,
858 "could not release unmap: %d\n", ret);
859 }
860 omap_obj->dma_addr = 0;
861 omap_obj->block = NULL;
862 }
863 }
864
865 mutex_unlock(&omap_obj->lock);
866}
867
868
869
870
871
872int omap_gem_rotated_dma_addr(struct drm_gem_object *obj, u32 orient,
873 int x, int y, dma_addr_t *dma_addr)
874{
875 struct omap_gem_object *omap_obj = to_omap_bo(obj);
876 int ret = -EINVAL;
877
878 mutex_lock(&omap_obj->lock);
879
880 if ((omap_obj->dma_addr_cnt > 0) && omap_obj->block &&
881 (omap_obj->flags & OMAP_BO_TILED)) {
882 *dma_addr = tiler_tsptr(omap_obj->block, orient, x, y);
883 ret = 0;
884 }
885
886 mutex_unlock(&omap_obj->lock);
887
888 return ret;
889}
890
891
892int omap_gem_tiled_stride(struct drm_gem_object *obj, u32 orient)
893{
894 struct omap_gem_object *omap_obj = to_omap_bo(obj);
895 int ret = -EINVAL;
896 if (omap_obj->flags & OMAP_BO_TILED)
897 ret = tiler_stride(gem2fmt(omap_obj->flags), orient);
898 return ret;
899}
900
901
902
903
904
905
906
907
908
909
910
911int omap_gem_get_pages(struct drm_gem_object *obj, struct page ***pages,
912 bool remap)
913{
914 struct omap_gem_object *omap_obj = to_omap_bo(obj);
915 int ret = 0;
916
917 mutex_lock(&omap_obj->lock);
918
919 if (remap) {
920 ret = omap_gem_attach_pages(obj);
921 if (ret)
922 goto unlock;
923 }
924
925 if (!omap_obj->pages) {
926 ret = -ENOMEM;
927 goto unlock;
928 }
929
930 *pages = omap_obj->pages;
931
932unlock:
933 mutex_unlock(&omap_obj->lock);
934
935 return ret;
936}
937
938
939int omap_gem_put_pages(struct drm_gem_object *obj)
940{
941
942
943
944
945 return 0;
946}
947
948#ifdef CONFIG_DRM_FBDEV_EMULATION
949
950
951
952
953void *omap_gem_vaddr(struct drm_gem_object *obj)
954{
955 struct omap_gem_object *omap_obj = to_omap_bo(obj);
956 void *vaddr;
957 int ret;
958
959 mutex_lock(&omap_obj->lock);
960
961 if (!omap_obj->vaddr) {
962 ret = omap_gem_attach_pages(obj);
963 if (ret) {
964 vaddr = ERR_PTR(ret);
965 goto unlock;
966 }
967
968 omap_obj->vaddr = vmap(omap_obj->pages, obj->size >> PAGE_SHIFT,
969 VM_MAP, pgprot_writecombine(PAGE_KERNEL));
970 }
971
972 vaddr = omap_obj->vaddr;
973
974unlock:
975 mutex_unlock(&omap_obj->lock);
976 return vaddr;
977}
978#endif
979
980
981
982
983
984#ifdef CONFIG_PM
985
986int omap_gem_resume(struct drm_device *dev)
987{
988 struct omap_drm_private *priv = dev->dev_private;
989 struct omap_gem_object *omap_obj;
990 int ret = 0;
991
992 mutex_lock(&priv->list_lock);
993 list_for_each_entry(omap_obj, &priv->obj_list, mm_list) {
994 if (omap_obj->block) {
995 struct drm_gem_object *obj = &omap_obj->base;
996 u32 npages = obj->size >> PAGE_SHIFT;
997
998 WARN_ON(!omap_obj->pages);
999 ret = tiler_pin(omap_obj->block,
1000 omap_obj->pages, npages,
1001 omap_obj->roll, true);
1002 if (ret) {
1003 dev_err(dev->dev, "could not repin: %d\n", ret);
1004 goto done;
1005 }
1006 }
1007 }
1008
1009done:
1010 mutex_unlock(&priv->list_lock);
1011 return ret;
1012}
1013#endif
1014
1015
1016
1017
1018
1019#ifdef CONFIG_DEBUG_FS
1020void omap_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
1021{
1022 struct omap_gem_object *omap_obj = to_omap_bo(obj);
1023 u64 off;
1024
1025 off = drm_vma_node_start(&obj->vma_node);
1026
1027 mutex_lock(&omap_obj->lock);
1028
1029 seq_printf(m, "%08x: %2d (%2d) %08llx %pad (%2d) %p %4d",
1030 omap_obj->flags, obj->name, kref_read(&obj->refcount),
1031 off, &omap_obj->dma_addr, omap_obj->dma_addr_cnt,
1032 omap_obj->vaddr, omap_obj->roll);
1033
1034 if (omap_obj->flags & OMAP_BO_TILED) {
1035 seq_printf(m, " %dx%d", omap_obj->width, omap_obj->height);
1036 if (omap_obj->block) {
1037 struct tcm_area *area = &omap_obj->block->area;
1038 seq_printf(m, " (%dx%d, %dx%d)",
1039 area->p0.x, area->p0.y,
1040 area->p1.x, area->p1.y);
1041 }
1042 } else {
1043 seq_printf(m, " %zu", obj->size);
1044 }
1045
1046 mutex_unlock(&omap_obj->lock);
1047
1048 seq_printf(m, "\n");
1049}
1050
1051void omap_gem_describe_objects(struct list_head *list, struct seq_file *m)
1052{
1053 struct omap_gem_object *omap_obj;
1054 int count = 0;
1055 size_t size = 0;
1056
1057 list_for_each_entry(omap_obj, list, mm_list) {
1058 struct drm_gem_object *obj = &omap_obj->base;
1059 seq_printf(m, " ");
1060 omap_gem_describe(obj, m);
1061 count++;
1062 size += obj->size;
1063 }
1064
1065 seq_printf(m, "Total %d objects, %zu bytes\n", count, size);
1066}
1067#endif
1068
1069
1070
1071
1072
1073void omap_gem_free_object(struct drm_gem_object *obj)
1074{
1075 struct drm_device *dev = obj->dev;
1076 struct omap_drm_private *priv = dev->dev_private;
1077 struct omap_gem_object *omap_obj = to_omap_bo(obj);
1078
1079 omap_gem_evict(obj);
1080
1081 mutex_lock(&priv->list_lock);
1082 list_del(&omap_obj->mm_list);
1083 mutex_unlock(&priv->list_lock);
1084
1085
1086
1087
1088
1089
1090
1091 mutex_lock(&omap_obj->lock);
1092
1093
1094 WARN_ON(omap_obj->dma_addr_cnt > 0);
1095
1096 if (omap_obj->pages) {
1097 if (omap_obj->flags & OMAP_BO_MEM_DMABUF)
1098 kfree(omap_obj->pages);
1099 else
1100 omap_gem_detach_pages(obj);
1101 }
1102
1103 if (omap_obj->flags & OMAP_BO_MEM_DMA_API) {
1104 dma_free_wc(dev->dev, obj->size, omap_obj->vaddr,
1105 omap_obj->dma_addr);
1106 } else if (omap_obj->vaddr) {
1107 vunmap(omap_obj->vaddr);
1108 } else if (obj->import_attach) {
1109 drm_prime_gem_destroy(obj, omap_obj->sgt);
1110 }
1111
1112 mutex_unlock(&omap_obj->lock);
1113
1114 drm_gem_object_release(obj);
1115
1116 mutex_destroy(&omap_obj->lock);
1117
1118 kfree(omap_obj);
1119}
1120
1121
1122struct drm_gem_object *omap_gem_new(struct drm_device *dev,
1123 union omap_gem_size gsize, u32 flags)
1124{
1125 struct omap_drm_private *priv = dev->dev_private;
1126 struct omap_gem_object *omap_obj;
1127 struct drm_gem_object *obj;
1128 struct address_space *mapping;
1129 size_t size;
1130 int ret;
1131
1132
1133 if (flags & OMAP_BO_TILED) {
1134 if (!priv->usergart) {
1135 dev_err(dev->dev, "Tiled buffers require DMM\n");
1136 return NULL;
1137 }
1138
1139
1140
1141
1142
1143 flags &= ~OMAP_BO_SCANOUT;
1144 flags |= OMAP_BO_MEM_SHMEM;
1145
1146
1147
1148
1149
1150 flags &= ~(OMAP_BO_CACHED|OMAP_BO_WC|OMAP_BO_UNCACHED);
1151 flags |= tiler_get_cpu_cache_flags();
1152 } else if ((flags & OMAP_BO_SCANOUT) && !priv->has_dmm) {
1153
1154
1155
1156
1157
1158 flags |= OMAP_BO_MEM_DMA_API;
1159 } else if (!(flags & OMAP_BO_MEM_DMABUF)) {
1160
1161
1162
1163 flags |= OMAP_BO_MEM_SHMEM;
1164 }
1165
1166
1167 omap_obj = kzalloc(sizeof(*omap_obj), GFP_KERNEL);
1168 if (!omap_obj)
1169 return NULL;
1170
1171 obj = &omap_obj->base;
1172 omap_obj->flags = flags;
1173 mutex_init(&omap_obj->lock);
1174
1175 if (flags & OMAP_BO_TILED) {
1176
1177
1178
1179
1180 tiler_align(gem2fmt(flags), &gsize.tiled.width,
1181 &gsize.tiled.height);
1182
1183 size = tiler_size(gem2fmt(flags), gsize.tiled.width,
1184 gsize.tiled.height);
1185
1186 omap_obj->width = gsize.tiled.width;
1187 omap_obj->height = gsize.tiled.height;
1188 } else {
1189 size = PAGE_ALIGN(gsize.bytes);
1190 }
1191
1192
1193 if (!(flags & OMAP_BO_MEM_SHMEM)) {
1194 drm_gem_private_object_init(dev, obj, size);
1195 } else {
1196 ret = drm_gem_object_init(dev, obj, size);
1197 if (ret)
1198 goto err_free;
1199
1200 mapping = obj->filp->f_mapping;
1201 mapping_set_gfp_mask(mapping, GFP_USER | __GFP_DMA32);
1202 }
1203
1204
1205 if (flags & OMAP_BO_MEM_DMA_API) {
1206 omap_obj->vaddr = dma_alloc_wc(dev->dev, size,
1207 &omap_obj->dma_addr,
1208 GFP_KERNEL);
1209 if (!omap_obj->vaddr)
1210 goto err_release;
1211 }
1212
1213 mutex_lock(&priv->list_lock);
1214 list_add(&omap_obj->mm_list, &priv->obj_list);
1215 mutex_unlock(&priv->list_lock);
1216
1217 return obj;
1218
1219err_release:
1220 drm_gem_object_release(obj);
1221err_free:
1222 kfree(omap_obj);
1223 return NULL;
1224}
1225
1226struct drm_gem_object *omap_gem_new_dmabuf(struct drm_device *dev, size_t size,
1227 struct sg_table *sgt)
1228{
1229 struct omap_drm_private *priv = dev->dev_private;
1230 struct omap_gem_object *omap_obj;
1231 struct drm_gem_object *obj;
1232 union omap_gem_size gsize;
1233
1234
1235 if (sgt->orig_nents != 1 && !priv->has_dmm)
1236 return ERR_PTR(-EINVAL);
1237
1238 gsize.bytes = PAGE_ALIGN(size);
1239 obj = omap_gem_new(dev, gsize, OMAP_BO_MEM_DMABUF | OMAP_BO_WC);
1240 if (!obj)
1241 return ERR_PTR(-ENOMEM);
1242
1243 omap_obj = to_omap_bo(obj);
1244
1245 mutex_lock(&omap_obj->lock);
1246
1247 omap_obj->sgt = sgt;
1248
1249 if (sgt->orig_nents == 1) {
1250 omap_obj->dma_addr = sg_dma_address(sgt->sgl);
1251 } else {
1252
1253 struct sg_page_iter iter;
1254 struct page **pages;
1255 unsigned int npages;
1256 unsigned int i = 0;
1257
1258 npages = DIV_ROUND_UP(size, PAGE_SIZE);
1259 pages = kcalloc(npages, sizeof(*pages), GFP_KERNEL);
1260 if (!pages) {
1261 omap_gem_free_object(obj);
1262 obj = ERR_PTR(-ENOMEM);
1263 goto done;
1264 }
1265
1266 omap_obj->pages = pages;
1267
1268 for_each_sg_page(sgt->sgl, &iter, sgt->orig_nents, 0) {
1269 pages[i++] = sg_page_iter_page(&iter);
1270 if (i > npages)
1271 break;
1272 }
1273
1274 if (WARN_ON(i != npages)) {
1275 omap_gem_free_object(obj);
1276 obj = ERR_PTR(-ENOMEM);
1277 goto done;
1278 }
1279 }
1280
1281done:
1282 mutex_unlock(&omap_obj->lock);
1283 return obj;
1284}
1285
1286
1287int omap_gem_new_handle(struct drm_device *dev, struct drm_file *file,
1288 union omap_gem_size gsize, u32 flags, u32 *handle)
1289{
1290 struct drm_gem_object *obj;
1291 int ret;
1292
1293 obj = omap_gem_new(dev, gsize, flags);
1294 if (!obj)
1295 return -ENOMEM;
1296
1297 ret = drm_gem_handle_create(file, obj, handle);
1298 if (ret) {
1299 omap_gem_free_object(obj);
1300 return ret;
1301 }
1302
1303
1304 drm_gem_object_put_unlocked(obj);
1305
1306 return 0;
1307}
1308
1309
1310
1311
1312
1313
1314void omap_gem_init(struct drm_device *dev)
1315{
1316 struct omap_drm_private *priv = dev->dev_private;
1317 struct omap_drm_usergart *usergart;
1318 const enum tiler_fmt fmts[] = {
1319 TILFMT_8BIT, TILFMT_16BIT, TILFMT_32BIT
1320 };
1321 int i, j;
1322
1323 if (!dmm_is_available()) {
1324
1325 dev_warn(dev->dev, "DMM not available, disable DMM support\n");
1326 return;
1327 }
1328
1329 usergart = kcalloc(3, sizeof(*usergart), GFP_KERNEL);
1330 if (!usergart)
1331 return;
1332
1333
1334 for (i = 0; i < ARRAY_SIZE(fmts); i++) {
1335 u16 h = 1, w = PAGE_SIZE >> i;
1336
1337 tiler_align(fmts[i], &w, &h);
1338
1339
1340
1341
1342 usergart[i].height = h;
1343 usergart[i].height_shift = ilog2(h);
1344 usergart[i].stride_pfn = tiler_stride(fmts[i], 0) >> PAGE_SHIFT;
1345 usergart[i].slot_shift = ilog2((PAGE_SIZE / h) >> i);
1346 for (j = 0; j < NUM_USERGART_ENTRIES; j++) {
1347 struct omap_drm_usergart_entry *entry;
1348 struct tiler_block *block;
1349
1350 entry = &usergart[i].entry[j];
1351 block = tiler_reserve_2d(fmts[i], w, h, PAGE_SIZE);
1352 if (IS_ERR(block)) {
1353 dev_err(dev->dev,
1354 "reserve failed: %d, %d, %ld\n",
1355 i, j, PTR_ERR(block));
1356 return;
1357 }
1358 entry->dma_addr = tiler_ssptr(block);
1359 entry->block = block;
1360
1361 DBG("%d:%d: %dx%d: dma_addr=%pad stride=%d", i, j, w, h,
1362 &entry->dma_addr,
1363 usergart[i].stride_pfn << PAGE_SHIFT);
1364 }
1365 }
1366
1367 priv->usergart = usergart;
1368 priv->has_dmm = true;
1369}
1370
1371void omap_gem_deinit(struct drm_device *dev)
1372{
1373 struct omap_drm_private *priv = dev->dev_private;
1374
1375
1376
1377
1378 kfree(priv->usergart);
1379}
1380