1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/types.h>
18#include <linux/device.h>
19#include <linux/init.h>
20#include <linux/slab.h>
21#include <linux/console.h>
22#include <linux/module.h>
23#include <linux/mm.h>
24#include <linux/dma-mapping.h>
25#include <linux/kobject.h>
26
27#include <asm/iommu.h>
28#include <asm/dma.h>
29#include <asm/vio.h>
30#include <asm/prom.h>
31#include <asm/firmware.h>
32#include <asm/tce.h>
33#include <asm/abs_addr.h>
34#include <asm/page.h>
35#include <asm/hvcall.h>
36#include <asm/iseries/vio.h>
37#include <asm/iseries/hv_types.h>
38#include <asm/iseries/hv_lp_config.h>
39#include <asm/iseries/hv_call_xm.h>
40#include <asm/iseries/iommu.h>
41
42static struct bus_type vio_bus_type;
43
44static struct vio_dev vio_bus_device = {
45 .name = "vio",
46 .type = "",
47 .dev.init_name = "vio",
48 .dev.bus = &vio_bus_type,
49};
50
51#ifdef CONFIG_PPC_SMLPAR
52
53
54
55
56
57
58struct vio_cmo_pool {
59 size_t size;
60 size_t free;
61};
62
63
64#define VIO_CMO_BALANCE_DELAY 100
65
66
67#define VIO_CMO_BALANCE_CHUNK 131072
68
69
70
71
72
73
74
75struct vio_cmo_dev_entry {
76 struct vio_dev *viodev;
77 struct list_head list;
78};
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95struct vio_cmo {
96 spinlock_t lock;
97 struct delayed_work balance_q;
98 struct list_head device_list;
99 size_t entitled;
100 struct vio_cmo_pool reserve;
101 struct vio_cmo_pool excess;
102 size_t spare;
103 size_t min;
104 size_t desired;
105 size_t curr;
106 size_t high;
107} vio_cmo;
108
109
110
111
112static int vio_cmo_num_OF_devs(void)
113{
114 struct device_node *node_vroot;
115 int count = 0;
116
117
118
119
120
121 node_vroot = of_find_node_by_name(NULL, "vdevice");
122 if (node_vroot) {
123 struct device_node *of_node;
124 struct property *prop;
125
126 for_each_child_of_node(node_vroot, of_node) {
127 prop = of_find_property(of_node, "ibm,my-dma-window",
128 NULL);
129 if (prop)
130 count++;
131 }
132 }
133 of_node_put(node_vroot);
134 return count;
135}
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151static inline int vio_cmo_alloc(struct vio_dev *viodev, size_t size)
152{
153 unsigned long flags;
154 size_t reserve_free = 0;
155 size_t excess_free = 0;
156 int ret = -ENOMEM;
157
158 spin_lock_irqsave(&vio_cmo.lock, flags);
159
160
161 if (viodev->cmo.entitled > viodev->cmo.allocated)
162 reserve_free = viodev->cmo.entitled - viodev->cmo.allocated;
163
164
165 if (vio_cmo.spare >= VIO_CMO_MIN_ENT)
166 excess_free = vio_cmo.excess.free;
167
168
169 if ((reserve_free + excess_free) >= size) {
170 vio_cmo.curr += size;
171 if (vio_cmo.curr > vio_cmo.high)
172 vio_cmo.high = vio_cmo.curr;
173 viodev->cmo.allocated += size;
174 size -= min(reserve_free, size);
175 vio_cmo.excess.free -= size;
176 ret = 0;
177 }
178
179 spin_unlock_irqrestore(&vio_cmo.lock, flags);
180 return ret;
181}
182
183
184
185
186
187
188
189
190
191
192
193
194
195static inline void vio_cmo_dealloc(struct vio_dev *viodev, size_t size)
196{
197 unsigned long flags;
198 size_t spare_needed = 0;
199 size_t excess_freed = 0;
200 size_t reserve_freed = size;
201 size_t tmp;
202 int balance = 0;
203
204 spin_lock_irqsave(&vio_cmo.lock, flags);
205 vio_cmo.curr -= size;
206
207
208 if (viodev->cmo.allocated > viodev->cmo.entitled) {
209 excess_freed = min(reserve_freed, (viodev->cmo.allocated -
210 viodev->cmo.entitled));
211 reserve_freed -= excess_freed;
212 }
213
214
215 viodev->cmo.allocated -= (reserve_freed + excess_freed);
216
217
218 spare_needed = VIO_CMO_MIN_ENT - vio_cmo.spare;
219
220
221
222
223
224 if (spare_needed && excess_freed) {
225 tmp = min(excess_freed, spare_needed);
226 vio_cmo.excess.size -= tmp;
227 vio_cmo.reserve.size += tmp;
228 vio_cmo.spare += tmp;
229 excess_freed -= tmp;
230 spare_needed -= tmp;
231 balance = 1;
232 }
233
234
235
236
237
238
239
240 if (spare_needed && reserve_freed) {
241 tmp = min3(spare_needed, reserve_freed, (viodev->cmo.entitled - VIO_CMO_MIN_ENT));
242
243 vio_cmo.spare += tmp;
244 viodev->cmo.entitled -= tmp;
245 reserve_freed -= tmp;
246 spare_needed -= tmp;
247 balance = 1;
248 }
249
250
251
252
253
254
255 if (excess_freed && (vio_cmo.desired > vio_cmo.reserve.size)) {
256 tmp = min(excess_freed, (vio_cmo.desired - vio_cmo.reserve.size));
257
258 vio_cmo.excess.size -= tmp;
259 vio_cmo.reserve.size += tmp;
260 excess_freed -= tmp;
261 balance = 1;
262 }
263
264
265 if (excess_freed)
266 vio_cmo.excess.free += excess_freed;
267
268 if (balance)
269 schedule_delayed_work(&vio_cmo.balance_q, VIO_CMO_BALANCE_DELAY);
270 spin_unlock_irqrestore(&vio_cmo.lock, flags);
271}
272
273
274
275
276
277
278
279
280
281
282
283
284int vio_cmo_entitlement_update(size_t new_entitlement)
285{
286 struct vio_dev *viodev;
287 struct vio_cmo_dev_entry *dev_ent;
288 unsigned long flags;
289 size_t avail, delta, tmp;
290
291 spin_lock_irqsave(&vio_cmo.lock, flags);
292
293
294 if (new_entitlement > vio_cmo.entitled) {
295 delta = new_entitlement - vio_cmo.entitled;
296
297
298 if (vio_cmo.spare < VIO_CMO_MIN_ENT) {
299 tmp = min(delta, (VIO_CMO_MIN_ENT - vio_cmo.spare));
300 vio_cmo.spare += tmp;
301 vio_cmo.reserve.size += tmp;
302 delta -= tmp;
303 }
304
305
306 vio_cmo.entitled += delta;
307 vio_cmo.excess.size += delta;
308 vio_cmo.excess.free += delta;
309
310 goto out;
311 }
312
313
314 delta = vio_cmo.entitled - new_entitlement;
315 avail = vio_cmo.excess.free;
316
317
318
319
320
321 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
322 if (avail >= delta)
323 break;
324
325 viodev = dev_ent->viodev;
326 if ((viodev->cmo.entitled > viodev->cmo.allocated) &&
327 (viodev->cmo.entitled > VIO_CMO_MIN_ENT))
328 avail += viodev->cmo.entitled -
329 max_t(size_t, viodev->cmo.allocated,
330 VIO_CMO_MIN_ENT);
331 }
332
333 if (delta <= avail) {
334 vio_cmo.entitled -= delta;
335
336
337 tmp = min(vio_cmo.excess.free, delta);
338 vio_cmo.excess.size -= tmp;
339 vio_cmo.excess.free -= tmp;
340 delta -= tmp;
341
342
343
344
345
346 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
347 if (!delta)
348 break;
349
350 viodev = dev_ent->viodev;
351 tmp = 0;
352 if ((viodev->cmo.entitled > viodev->cmo.allocated) &&
353 (viodev->cmo.entitled > VIO_CMO_MIN_ENT))
354 tmp = viodev->cmo.entitled -
355 max_t(size_t, viodev->cmo.allocated,
356 VIO_CMO_MIN_ENT);
357 viodev->cmo.entitled -= min(tmp, delta);
358 delta -= min(tmp, delta);
359 }
360 } else {
361 spin_unlock_irqrestore(&vio_cmo.lock, flags);
362 return -ENOMEM;
363 }
364
365out:
366 schedule_delayed_work(&vio_cmo.balance_q, 0);
367 spin_unlock_irqrestore(&vio_cmo.lock, flags);
368 return 0;
369}
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392static void vio_cmo_balance(struct work_struct *work)
393{
394 struct vio_cmo *cmo;
395 struct vio_dev *viodev;
396 struct vio_cmo_dev_entry *dev_ent;
397 unsigned long flags;
398 size_t avail = 0, level, chunk, need;
399 int devcount = 0, fulfilled;
400
401 cmo = container_of(work, struct vio_cmo, balance_q.work);
402
403 spin_lock_irqsave(&vio_cmo.lock, flags);
404
405
406 cmo->min = vio_cmo_num_OF_devs() * VIO_CMO_MIN_ENT;
407 BUG_ON(cmo->min > cmo->entitled);
408 cmo->spare = min_t(size_t, VIO_CMO_MIN_ENT, (cmo->entitled - cmo->min));
409 cmo->min += cmo->spare;
410 cmo->desired = cmo->min;
411
412
413
414
415
416 avail = cmo->entitled - cmo->spare;
417 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
418 viodev = dev_ent->viodev;
419 devcount++;
420 viodev->cmo.entitled = VIO_CMO_MIN_ENT;
421 cmo->desired += (viodev->cmo.desired - VIO_CMO_MIN_ENT);
422 avail -= max_t(size_t, viodev->cmo.allocated, VIO_CMO_MIN_ENT);
423 }
424
425
426
427
428
429
430 level = VIO_CMO_MIN_ENT;
431 while (avail) {
432 fulfilled = 0;
433 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
434 viodev = dev_ent->viodev;
435
436 if (viodev->cmo.desired <= level) {
437 fulfilled++;
438 continue;
439 }
440
441
442
443
444
445
446 chunk = min_t(size_t, avail, VIO_CMO_BALANCE_CHUNK);
447 chunk = min(chunk, (viodev->cmo.desired -
448 viodev->cmo.entitled));
449 viodev->cmo.entitled += chunk;
450
451
452
453
454
455
456 need = max(viodev->cmo.allocated, viodev->cmo.entitled)-
457 max(viodev->cmo.allocated, level);
458 avail -= need;
459
460 }
461 if (fulfilled == devcount)
462 break;
463 level += VIO_CMO_BALANCE_CHUNK;
464 }
465
466
467 cmo->reserve.size = cmo->min;
468 cmo->excess.free = 0;
469 cmo->excess.size = 0;
470 need = 0;
471 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
472 viodev = dev_ent->viodev;
473
474 if (viodev->cmo.entitled)
475 cmo->reserve.size += (viodev->cmo.entitled -
476 VIO_CMO_MIN_ENT);
477
478 if (viodev->cmo.allocated > viodev->cmo.entitled)
479 need += viodev->cmo.allocated - viodev->cmo.entitled;
480 }
481 cmo->excess.size = cmo->entitled - cmo->reserve.size;
482 cmo->excess.free = cmo->excess.size - need;
483
484 cancel_delayed_work(to_delayed_work(work));
485 spin_unlock_irqrestore(&vio_cmo.lock, flags);
486}
487
488static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
489 dma_addr_t *dma_handle, gfp_t flag)
490{
491 struct vio_dev *viodev = to_vio_dev(dev);
492 void *ret;
493
494 if (vio_cmo_alloc(viodev, roundup(size, PAGE_SIZE))) {
495 atomic_inc(&viodev->cmo.allocs_failed);
496 return NULL;
497 }
498
499 ret = dma_iommu_ops.alloc_coherent(dev, size, dma_handle, flag);
500 if (unlikely(ret == NULL)) {
501 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
502 atomic_inc(&viodev->cmo.allocs_failed);
503 }
504
505 return ret;
506}
507
508static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
509 void *vaddr, dma_addr_t dma_handle)
510{
511 struct vio_dev *viodev = to_vio_dev(dev);
512
513 dma_iommu_ops.free_coherent(dev, size, vaddr, dma_handle);
514
515 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
516}
517
518static dma_addr_t vio_dma_iommu_map_page(struct device *dev, struct page *page,
519 unsigned long offset, size_t size,
520 enum dma_data_direction direction,
521 struct dma_attrs *attrs)
522{
523 struct vio_dev *viodev = to_vio_dev(dev);
524 dma_addr_t ret = DMA_ERROR_CODE;
525
526 if (vio_cmo_alloc(viodev, roundup(size, IOMMU_PAGE_SIZE))) {
527 atomic_inc(&viodev->cmo.allocs_failed);
528 return ret;
529 }
530
531 ret = dma_iommu_ops.map_page(dev, page, offset, size, direction, attrs);
532 if (unlikely(dma_mapping_error(dev, ret))) {
533 vio_cmo_dealloc(viodev, roundup(size, IOMMU_PAGE_SIZE));
534 atomic_inc(&viodev->cmo.allocs_failed);
535 }
536
537 return ret;
538}
539
540static void vio_dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
541 size_t size,
542 enum dma_data_direction direction,
543 struct dma_attrs *attrs)
544{
545 struct vio_dev *viodev = to_vio_dev(dev);
546
547 dma_iommu_ops.unmap_page(dev, dma_handle, size, direction, attrs);
548
549 vio_cmo_dealloc(viodev, roundup(size, IOMMU_PAGE_SIZE));
550}
551
552static int vio_dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
553 int nelems, enum dma_data_direction direction,
554 struct dma_attrs *attrs)
555{
556 struct vio_dev *viodev = to_vio_dev(dev);
557 struct scatterlist *sgl;
558 int ret, count = 0;
559 size_t alloc_size = 0;
560
561 for (sgl = sglist; count < nelems; count++, sgl++)
562 alloc_size += roundup(sgl->length, IOMMU_PAGE_SIZE);
563
564 if (vio_cmo_alloc(viodev, alloc_size)) {
565 atomic_inc(&viodev->cmo.allocs_failed);
566 return 0;
567 }
568
569 ret = dma_iommu_ops.map_sg(dev, sglist, nelems, direction, attrs);
570
571 if (unlikely(!ret)) {
572 vio_cmo_dealloc(viodev, alloc_size);
573 atomic_inc(&viodev->cmo.allocs_failed);
574 return ret;
575 }
576
577 for (sgl = sglist, count = 0; count < ret; count++, sgl++)
578 alloc_size -= roundup(sgl->dma_length, IOMMU_PAGE_SIZE);
579 if (alloc_size)
580 vio_cmo_dealloc(viodev, alloc_size);
581
582 return ret;
583}
584
585static void vio_dma_iommu_unmap_sg(struct device *dev,
586 struct scatterlist *sglist, int nelems,
587 enum dma_data_direction direction,
588 struct dma_attrs *attrs)
589{
590 struct vio_dev *viodev = to_vio_dev(dev);
591 struct scatterlist *sgl;
592 size_t alloc_size = 0;
593 int count = 0;
594
595 for (sgl = sglist; count < nelems; count++, sgl++)
596 alloc_size += roundup(sgl->dma_length, IOMMU_PAGE_SIZE);
597
598 dma_iommu_ops.unmap_sg(dev, sglist, nelems, direction, attrs);
599
600 vio_cmo_dealloc(viodev, alloc_size);
601}
602
603static int vio_dma_iommu_dma_supported(struct device *dev, u64 mask)
604{
605 return dma_iommu_ops.dma_supported(dev, mask);
606}
607
608struct dma_map_ops vio_dma_mapping_ops = {
609 .alloc_coherent = vio_dma_iommu_alloc_coherent,
610 .free_coherent = vio_dma_iommu_free_coherent,
611 .map_sg = vio_dma_iommu_map_sg,
612 .unmap_sg = vio_dma_iommu_unmap_sg,
613 .map_page = vio_dma_iommu_map_page,
614 .unmap_page = vio_dma_iommu_unmap_page,
615 .dma_supported = vio_dma_iommu_dma_supported,
616
617};
618
619
620
621
622
623
624
625
626
627
628
629void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired)
630{
631 unsigned long flags;
632 struct vio_cmo_dev_entry *dev_ent;
633 int found = 0;
634
635 if (!firmware_has_feature(FW_FEATURE_CMO))
636 return;
637
638 spin_lock_irqsave(&vio_cmo.lock, flags);
639 if (desired < VIO_CMO_MIN_ENT)
640 desired = VIO_CMO_MIN_ENT;
641
642
643
644
645
646
647 list_for_each_entry(dev_ent, &vio_cmo.device_list, list)
648 if (viodev == dev_ent->viodev) {
649 found = 1;
650 break;
651 }
652 if (!found) {
653 spin_unlock_irqrestore(&vio_cmo.lock, flags);
654 return;
655 }
656
657
658 if (desired >= viodev->cmo.desired) {
659
660 vio_cmo.desired += desired - viodev->cmo.desired;
661 viodev->cmo.desired = desired;
662 } else {
663
664 vio_cmo.desired -= viodev->cmo.desired - desired;
665 viodev->cmo.desired = desired;
666
667
668
669
670 if (viodev->cmo.entitled > desired) {
671 vio_cmo.reserve.size -= viodev->cmo.entitled - desired;
672 vio_cmo.excess.size += viodev->cmo.entitled - desired;
673
674
675
676
677
678 if (viodev->cmo.allocated < viodev->cmo.entitled)
679 vio_cmo.excess.free += viodev->cmo.entitled -
680 max(viodev->cmo.allocated, desired);
681 viodev->cmo.entitled = desired;
682 }
683 }
684 schedule_delayed_work(&vio_cmo.balance_q, 0);
685 spin_unlock_irqrestore(&vio_cmo.lock, flags);
686}
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702static int vio_cmo_bus_probe(struct vio_dev *viodev)
703{
704 struct vio_cmo_dev_entry *dev_ent;
705 struct device *dev = &viodev->dev;
706 struct vio_driver *viodrv = to_vio_driver(dev->driver);
707 unsigned long flags;
708 size_t size;
709
710
711
712
713
714 if (of_get_property(viodev->dev.of_node,
715 "ibm,my-dma-window", NULL)) {
716
717 if (!viodrv->get_desired_dma) {
718 dev_err(dev, "%s: device driver does not support CMO\n",
719 __func__);
720 return -EINVAL;
721 }
722
723 viodev->cmo.desired = IOMMU_PAGE_ALIGN(viodrv->get_desired_dma(viodev));
724 if (viodev->cmo.desired < VIO_CMO_MIN_ENT)
725 viodev->cmo.desired = VIO_CMO_MIN_ENT;
726 size = VIO_CMO_MIN_ENT;
727
728 dev_ent = kmalloc(sizeof(struct vio_cmo_dev_entry),
729 GFP_KERNEL);
730 if (!dev_ent)
731 return -ENOMEM;
732
733 dev_ent->viodev = viodev;
734 spin_lock_irqsave(&vio_cmo.lock, flags);
735 list_add(&dev_ent->list, &vio_cmo.device_list);
736 } else {
737 viodev->cmo.desired = 0;
738 size = 0;
739 spin_lock_irqsave(&vio_cmo.lock, flags);
740 }
741
742
743
744
745
746
747
748 if (vio_cmo.min == ((vio_cmo_num_OF_devs() + 1) *
749 VIO_CMO_MIN_ENT)) {
750
751 if (size)
752 vio_cmo.desired += (viodev->cmo.desired -
753 VIO_CMO_MIN_ENT);
754 } else {
755 size_t tmp;
756
757 tmp = vio_cmo.spare + vio_cmo.excess.free;
758 if (tmp < size) {
759 dev_err(dev, "%s: insufficient free "
760 "entitlement to add device. "
761 "Need %lu, have %lu\n", __func__,
762 size, (vio_cmo.spare + tmp));
763 spin_unlock_irqrestore(&vio_cmo.lock, flags);
764 return -ENOMEM;
765 }
766
767
768 tmp = min(size, vio_cmo.excess.free);
769 vio_cmo.excess.free -= tmp;
770 vio_cmo.excess.size -= tmp;
771 vio_cmo.reserve.size += tmp;
772
773
774 vio_cmo.spare -= size - tmp;
775
776
777 vio_cmo.min += size;
778 vio_cmo.desired += viodev->cmo.desired;
779 }
780 spin_unlock_irqrestore(&vio_cmo.lock, flags);
781 return 0;
782}
783
784
785
786
787
788
789
790
791
792
793
794static void vio_cmo_bus_remove(struct vio_dev *viodev)
795{
796 struct vio_cmo_dev_entry *dev_ent;
797 unsigned long flags;
798 size_t tmp;
799
800 spin_lock_irqsave(&vio_cmo.lock, flags);
801 if (viodev->cmo.allocated) {
802 dev_err(&viodev->dev, "%s: device had %lu bytes of IO "
803 "allocated after remove operation.\n",
804 __func__, viodev->cmo.allocated);
805 BUG();
806 }
807
808
809
810
811
812 list_for_each_entry(dev_ent, &vio_cmo.device_list, list)
813 if (viodev == dev_ent->viodev) {
814 list_del(&dev_ent->list);
815 kfree(dev_ent);
816 break;
817 }
818
819
820
821
822
823
824 if (viodev->cmo.entitled) {
825
826
827
828
829
830 vio_cmo.desired -= (viodev->cmo.desired - VIO_CMO_MIN_ENT);
831
832
833
834
835
836
837 viodev->cmo.entitled -= VIO_CMO_MIN_ENT;
838
839
840 if (viodev->cmo.entitled && (vio_cmo.spare < VIO_CMO_MIN_ENT)) {
841 tmp = min(viodev->cmo.entitled, (VIO_CMO_MIN_ENT -
842 vio_cmo.spare));
843 vio_cmo.spare += tmp;
844 viodev->cmo.entitled -= tmp;
845 }
846
847
848 vio_cmo.excess.size += viodev->cmo.entitled;
849 vio_cmo.excess.free += viodev->cmo.entitled;
850 vio_cmo.reserve.size -= viodev->cmo.entitled;
851
852
853
854
855
856
857 viodev->cmo.entitled = VIO_CMO_MIN_ENT;
858 viodev->cmo.desired = VIO_CMO_MIN_ENT;
859 atomic_set(&viodev->cmo.allocs_failed, 0);
860 }
861
862 spin_unlock_irqrestore(&vio_cmo.lock, flags);
863}
864
865static void vio_cmo_set_dma_ops(struct vio_dev *viodev)
866{
867 set_dma_ops(&viodev->dev, &vio_dma_mapping_ops);
868}
869
870
871
872
873
874
875
876
877static void vio_cmo_bus_init(void)
878{
879 struct hvcall_mpp_data mpp_data;
880 int err;
881
882 memset(&vio_cmo, 0, sizeof(struct vio_cmo));
883 spin_lock_init(&vio_cmo.lock);
884 INIT_LIST_HEAD(&vio_cmo.device_list);
885 INIT_DELAYED_WORK(&vio_cmo.balance_q, vio_cmo_balance);
886
887
888 err = h_get_mpp(&mpp_data);
889
890
891
892
893
894 if (err != H_SUCCESS) {
895 printk(KERN_ERR "%s: unable to determine system IO "\
896 "entitlement. (%d)\n", __func__, err);
897 vio_cmo.entitled = 0;
898 } else {
899 vio_cmo.entitled = mpp_data.entitled_mem;
900 }
901
902
903 vio_cmo.spare = VIO_CMO_MIN_ENT;
904 vio_cmo.reserve.size = vio_cmo.spare;
905 vio_cmo.reserve.size += (vio_cmo_num_OF_devs() *
906 VIO_CMO_MIN_ENT);
907 if (vio_cmo.reserve.size > vio_cmo.entitled) {
908 printk(KERN_ERR "%s: insufficient system entitlement\n",
909 __func__);
910 panic("%s: Insufficient system entitlement", __func__);
911 }
912
913
914 vio_cmo.excess.size = vio_cmo.entitled - vio_cmo.reserve.size;
915 vio_cmo.excess.free = vio_cmo.excess.size;
916 vio_cmo.min = vio_cmo.reserve.size;
917 vio_cmo.desired = vio_cmo.reserve.size;
918}
919
920
921
922#define viodev_cmo_rd_attr(name) \
923static ssize_t viodev_cmo_##name##_show(struct device *dev, \
924 struct device_attribute *attr, \
925 char *buf) \
926{ \
927 return sprintf(buf, "%lu\n", to_vio_dev(dev)->cmo.name); \
928}
929
930static ssize_t viodev_cmo_allocs_failed_show(struct device *dev,
931 struct device_attribute *attr, char *buf)
932{
933 struct vio_dev *viodev = to_vio_dev(dev);
934 return sprintf(buf, "%d\n", atomic_read(&viodev->cmo.allocs_failed));
935}
936
937static ssize_t viodev_cmo_allocs_failed_reset(struct device *dev,
938 struct device_attribute *attr, const char *buf, size_t count)
939{
940 struct vio_dev *viodev = to_vio_dev(dev);
941 atomic_set(&viodev->cmo.allocs_failed, 0);
942 return count;
943}
944
945static ssize_t viodev_cmo_desired_set(struct device *dev,
946 struct device_attribute *attr, const char *buf, size_t count)
947{
948 struct vio_dev *viodev = to_vio_dev(dev);
949 size_t new_desired;
950 int ret;
951
952 ret = strict_strtoul(buf, 10, &new_desired);
953 if (ret)
954 return ret;
955
956 vio_cmo_set_dev_desired(viodev, new_desired);
957 return count;
958}
959
960viodev_cmo_rd_attr(desired);
961viodev_cmo_rd_attr(entitled);
962viodev_cmo_rd_attr(allocated);
963
964static ssize_t name_show(struct device *, struct device_attribute *, char *);
965static ssize_t devspec_show(struct device *, struct device_attribute *, char *);
966static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
967 char *buf);
968static struct device_attribute vio_cmo_dev_attrs[] = {
969 __ATTR_RO(name),
970 __ATTR_RO(devspec),
971 __ATTR_RO(modalias),
972 __ATTR(cmo_desired, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
973 viodev_cmo_desired_show, viodev_cmo_desired_set),
974 __ATTR(cmo_entitled, S_IRUGO, viodev_cmo_entitled_show, NULL),
975 __ATTR(cmo_allocated, S_IRUGO, viodev_cmo_allocated_show, NULL),
976 __ATTR(cmo_allocs_failed, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
977 viodev_cmo_allocs_failed_show, viodev_cmo_allocs_failed_reset),
978 __ATTR_NULL
979};
980
981
982
983#define viobus_cmo_rd_attr(name) \
984static ssize_t \
985viobus_cmo_##name##_show(struct bus_type *bt, char *buf) \
986{ \
987 return sprintf(buf, "%lu\n", vio_cmo.name); \
988}
989
990#define viobus_cmo_pool_rd_attr(name, var) \
991static ssize_t \
992viobus_cmo_##name##_pool_show_##var(struct bus_type *bt, char *buf) \
993{ \
994 return sprintf(buf, "%lu\n", vio_cmo.name.var); \
995}
996
997static ssize_t viobus_cmo_high_reset(struct bus_type *bt, const char *buf,
998 size_t count)
999{
1000 unsigned long flags;
1001
1002 spin_lock_irqsave(&vio_cmo.lock, flags);
1003 vio_cmo.high = vio_cmo.curr;
1004 spin_unlock_irqrestore(&vio_cmo.lock, flags);
1005
1006 return count;
1007}
1008
1009viobus_cmo_rd_attr(entitled);
1010viobus_cmo_pool_rd_attr(reserve, size);
1011viobus_cmo_pool_rd_attr(excess, size);
1012viobus_cmo_pool_rd_attr(excess, free);
1013viobus_cmo_rd_attr(spare);
1014viobus_cmo_rd_attr(min);
1015viobus_cmo_rd_attr(desired);
1016viobus_cmo_rd_attr(curr);
1017viobus_cmo_rd_attr(high);
1018
1019static struct bus_attribute vio_cmo_bus_attrs[] = {
1020 __ATTR(cmo_entitled, S_IRUGO, viobus_cmo_entitled_show, NULL),
1021 __ATTR(cmo_reserve_size, S_IRUGO, viobus_cmo_reserve_pool_show_size, NULL),
1022 __ATTR(cmo_excess_size, S_IRUGO, viobus_cmo_excess_pool_show_size, NULL),
1023 __ATTR(cmo_excess_free, S_IRUGO, viobus_cmo_excess_pool_show_free, NULL),
1024 __ATTR(cmo_spare, S_IRUGO, viobus_cmo_spare_show, NULL),
1025 __ATTR(cmo_min, S_IRUGO, viobus_cmo_min_show, NULL),
1026 __ATTR(cmo_desired, S_IRUGO, viobus_cmo_desired_show, NULL),
1027 __ATTR(cmo_curr, S_IRUGO, viobus_cmo_curr_show, NULL),
1028 __ATTR(cmo_high, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
1029 viobus_cmo_high_show, viobus_cmo_high_reset),
1030 __ATTR_NULL
1031};
1032
1033static void vio_cmo_sysfs_init(void)
1034{
1035 vio_bus_type.dev_attrs = vio_cmo_dev_attrs;
1036 vio_bus_type.bus_attrs = vio_cmo_bus_attrs;
1037}
1038#else
1039
1040int vio_cmo_entitlement_update(size_t new_entitlement) { return 0; }
1041void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired) {}
1042static int vio_cmo_bus_probe(struct vio_dev *viodev) { return 0; }
1043static void vio_cmo_bus_remove(struct vio_dev *viodev) {}
1044static void vio_cmo_set_dma_ops(struct vio_dev *viodev) {}
1045static void vio_cmo_bus_init(void) {}
1046static void vio_cmo_sysfs_init(void) { }
1047#endif
1048EXPORT_SYMBOL(vio_cmo_entitlement_update);
1049EXPORT_SYMBOL(vio_cmo_set_dev_desired);
1050
1051static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
1052{
1053 const unsigned char *dma_window;
1054 struct iommu_table *tbl;
1055 unsigned long offset, size;
1056
1057 if (firmware_has_feature(FW_FEATURE_ISERIES))
1058 return vio_build_iommu_table_iseries(dev);
1059
1060 dma_window = of_get_property(dev->dev.of_node,
1061 "ibm,my-dma-window", NULL);
1062 if (!dma_window)
1063 return NULL;
1064
1065 tbl = kzalloc(sizeof(*tbl), GFP_KERNEL);
1066 if (tbl == NULL)
1067 return NULL;
1068
1069 of_parse_dma_window(dev->dev.of_node, dma_window,
1070 &tbl->it_index, &offset, &size);
1071
1072
1073 tbl->it_size = size >> IOMMU_PAGE_SHIFT;
1074
1075 tbl->it_offset = offset >> IOMMU_PAGE_SHIFT;
1076 tbl->it_busno = 0;
1077 tbl->it_type = TCE_VB;
1078 tbl->it_blocksize = 16;
1079
1080 return iommu_init_table(tbl, -1);
1081}
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093static const struct vio_device_id *vio_match_device(
1094 const struct vio_device_id *ids, const struct vio_dev *dev)
1095{
1096 while (ids->type[0] != '\0') {
1097 if ((strncmp(dev->type, ids->type, strlen(ids->type)) == 0) &&
1098 of_device_is_compatible(dev->dev.of_node,
1099 ids->compat))
1100 return ids;
1101 ids++;
1102 }
1103 return NULL;
1104}
1105
1106
1107
1108
1109
1110
1111static int vio_bus_probe(struct device *dev)
1112{
1113 struct vio_dev *viodev = to_vio_dev(dev);
1114 struct vio_driver *viodrv = to_vio_driver(dev->driver);
1115 const struct vio_device_id *id;
1116 int error = -ENODEV;
1117
1118 if (!viodrv->probe)
1119 return error;
1120
1121 id = vio_match_device(viodrv->id_table, viodev);
1122 if (id) {
1123 memset(&viodev->cmo, 0, sizeof(viodev->cmo));
1124 if (firmware_has_feature(FW_FEATURE_CMO)) {
1125 error = vio_cmo_bus_probe(viodev);
1126 if (error)
1127 return error;
1128 }
1129 error = viodrv->probe(viodev, id);
1130 if (error && firmware_has_feature(FW_FEATURE_CMO))
1131 vio_cmo_bus_remove(viodev);
1132 }
1133
1134 return error;
1135}
1136
1137
1138static int vio_bus_remove(struct device *dev)
1139{
1140 struct vio_dev *viodev = to_vio_dev(dev);
1141 struct vio_driver *viodrv = to_vio_driver(dev->driver);
1142 struct device *devptr;
1143 int ret = 1;
1144
1145
1146
1147
1148
1149 devptr = get_device(dev);
1150
1151 if (viodrv->remove)
1152 ret = viodrv->remove(viodev);
1153
1154 if (!ret && firmware_has_feature(FW_FEATURE_CMO))
1155 vio_cmo_bus_remove(viodev);
1156
1157 put_device(devptr);
1158 return ret;
1159}
1160
1161
1162
1163
1164
1165int vio_register_driver(struct vio_driver *viodrv)
1166{
1167 printk(KERN_DEBUG "%s: driver %s registering\n", __func__,
1168 viodrv->driver.name);
1169
1170
1171 viodrv->driver.bus = &vio_bus_type;
1172
1173 return driver_register(&viodrv->driver);
1174}
1175EXPORT_SYMBOL(vio_register_driver);
1176
1177
1178
1179
1180
1181void vio_unregister_driver(struct vio_driver *viodrv)
1182{
1183 driver_unregister(&viodrv->driver);
1184}
1185EXPORT_SYMBOL(vio_unregister_driver);
1186
1187
1188static void __devinit vio_dev_release(struct device *dev)
1189{
1190 struct iommu_table *tbl = get_iommu_table_base(dev);
1191
1192
1193 if (!firmware_has_feature(FW_FEATURE_ISERIES) && tbl)
1194 iommu_free_table(tbl, dev->of_node ?
1195 dev->of_node->full_name : dev_name(dev));
1196 of_node_put(dev->of_node);
1197 kfree(to_vio_dev(dev));
1198}
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209struct vio_dev *vio_register_device_node(struct device_node *of_node)
1210{
1211 struct vio_dev *viodev;
1212 const unsigned int *unit_address;
1213
1214
1215 if (of_node->type == NULL) {
1216 printk(KERN_WARNING "%s: node %s missing 'device_type'\n",
1217 __func__,
1218 of_node->name ? of_node->name : "<unknown>");
1219 return NULL;
1220 }
1221
1222 unit_address = of_get_property(of_node, "reg", NULL);
1223 if (unit_address == NULL) {
1224 printk(KERN_WARNING "%s: node %s missing 'reg'\n",
1225 __func__,
1226 of_node->name ? of_node->name : "<unknown>");
1227 return NULL;
1228 }
1229
1230
1231 viodev = kzalloc(sizeof(struct vio_dev), GFP_KERNEL);
1232 if (viodev == NULL)
1233 return NULL;
1234
1235 viodev->irq = irq_of_parse_and_map(of_node, 0);
1236
1237 dev_set_name(&viodev->dev, "%x", *unit_address);
1238 viodev->name = of_node->name;
1239 viodev->type = of_node->type;
1240 viodev->unit_address = *unit_address;
1241 if (firmware_has_feature(FW_FEATURE_ISERIES)) {
1242 unit_address = of_get_property(of_node,
1243 "linux,unit_address", NULL);
1244 if (unit_address != NULL)
1245 viodev->unit_address = *unit_address;
1246 }
1247 viodev->dev.of_node = of_node_get(of_node);
1248
1249 if (firmware_has_feature(FW_FEATURE_CMO))
1250 vio_cmo_set_dma_ops(viodev);
1251 else
1252 set_dma_ops(&viodev->dev, &dma_iommu_ops);
1253 set_iommu_table_base(&viodev->dev, vio_build_iommu_table(viodev));
1254 set_dev_node(&viodev->dev, of_node_to_nid(of_node));
1255
1256
1257 viodev->dev.parent = &vio_bus_device.dev;
1258 viodev->dev.bus = &vio_bus_type;
1259 viodev->dev.release = vio_dev_release;
1260
1261
1262 dma_set_mask(&viodev->dev, DMA_BIT_MASK(64));
1263 dma_set_coherent_mask(&viodev->dev, DMA_BIT_MASK(64));
1264
1265
1266 if (device_register(&viodev->dev)) {
1267 printk(KERN_ERR "%s: failed to register device %s\n",
1268 __func__, dev_name(&viodev->dev));
1269 put_device(&viodev->dev);
1270 return NULL;
1271 }
1272
1273 return viodev;
1274}
1275EXPORT_SYMBOL(vio_register_device_node);
1276
1277
1278
1279
1280static int __init vio_bus_init(void)
1281{
1282 int err;
1283 struct device_node *node_vroot;
1284
1285 if (firmware_has_feature(FW_FEATURE_CMO))
1286 vio_cmo_sysfs_init();
1287
1288 err = bus_register(&vio_bus_type);
1289 if (err) {
1290 printk(KERN_ERR "failed to register VIO bus\n");
1291 return err;
1292 }
1293
1294
1295
1296
1297
1298 err = device_register(&vio_bus_device.dev);
1299 if (err) {
1300 printk(KERN_WARNING "%s: device_register returned %i\n",
1301 __func__, err);
1302 return err;
1303 }
1304
1305 if (firmware_has_feature(FW_FEATURE_CMO))
1306 vio_cmo_bus_init();
1307
1308 node_vroot = of_find_node_by_name(NULL, "vdevice");
1309 if (node_vroot) {
1310 struct device_node *of_node;
1311
1312
1313
1314
1315
1316 for (of_node = node_vroot->child; of_node != NULL;
1317 of_node = of_node->sibling)
1318 vio_register_device_node(of_node);
1319 of_node_put(node_vroot);
1320 }
1321
1322 return 0;
1323}
1324__initcall(vio_bus_init);
1325
1326static ssize_t name_show(struct device *dev,
1327 struct device_attribute *attr, char *buf)
1328{
1329 return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
1330}
1331
1332static ssize_t devspec_show(struct device *dev,
1333 struct device_attribute *attr, char *buf)
1334{
1335 struct device_node *of_node = dev->of_node;
1336
1337 return sprintf(buf, "%s\n", of_node ? of_node->full_name : "none");
1338}
1339
1340static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
1341 char *buf)
1342{
1343 const struct vio_dev *vio_dev = to_vio_dev(dev);
1344 struct device_node *dn;
1345 const char *cp;
1346
1347 dn = dev->of_node;
1348 if (!dn)
1349 return -ENODEV;
1350 cp = of_get_property(dn, "compatible", NULL);
1351 if (!cp)
1352 return -ENODEV;
1353
1354 return sprintf(buf, "vio:T%sS%s\n", vio_dev->type, cp);
1355}
1356
1357static struct device_attribute vio_dev_attrs[] = {
1358 __ATTR_RO(name),
1359 __ATTR_RO(devspec),
1360 __ATTR_RO(modalias),
1361 __ATTR_NULL
1362};
1363
1364void __devinit vio_unregister_device(struct vio_dev *viodev)
1365{
1366 device_unregister(&viodev->dev);
1367}
1368EXPORT_SYMBOL(vio_unregister_device);
1369
1370static int vio_bus_match(struct device *dev, struct device_driver *drv)
1371{
1372 const struct vio_dev *vio_dev = to_vio_dev(dev);
1373 struct vio_driver *vio_drv = to_vio_driver(drv);
1374 const struct vio_device_id *ids = vio_drv->id_table;
1375
1376 return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL);
1377}
1378
1379static int vio_hotplug(struct device *dev, struct kobj_uevent_env *env)
1380{
1381 const struct vio_dev *vio_dev = to_vio_dev(dev);
1382 struct device_node *dn;
1383 const char *cp;
1384
1385 dn = dev->of_node;
1386 if (!dn)
1387 return -ENODEV;
1388 cp = of_get_property(dn, "compatible", NULL);
1389 if (!cp)
1390 return -ENODEV;
1391
1392 add_uevent_var(env, "MODALIAS=vio:T%sS%s", vio_dev->type, cp);
1393 return 0;
1394}
1395
1396static struct bus_type vio_bus_type = {
1397 .name = "vio",
1398 .dev_attrs = vio_dev_attrs,
1399 .uevent = vio_hotplug,
1400 .match = vio_bus_match,
1401 .probe = vio_bus_probe,
1402 .remove = vio_bus_remove,
1403 .pm = GENERIC_SUBSYS_PM_OPS,
1404};
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415const void *vio_get_attribute(struct vio_dev *vdev, char *which, int *length)
1416{
1417 return of_get_property(vdev->dev.of_node, which, length);
1418}
1419EXPORT_SYMBOL(vio_get_attribute);
1420
1421#ifdef CONFIG_PPC_PSERIES
1422
1423
1424
1425static struct vio_dev *vio_find_name(const char *name)
1426{
1427 struct device *found;
1428
1429 found = bus_find_device_by_name(&vio_bus_type, NULL, name);
1430 if (!found)
1431 return NULL;
1432
1433 return to_vio_dev(found);
1434}
1435
1436
1437
1438
1439
1440struct vio_dev *vio_find_node(struct device_node *vnode)
1441{
1442 const uint32_t *unit_address;
1443 char kobj_name[20];
1444
1445
1446 unit_address = of_get_property(vnode, "reg", NULL);
1447 if (!unit_address)
1448 return NULL;
1449 snprintf(kobj_name, sizeof(kobj_name), "%x", *unit_address);
1450
1451 return vio_find_name(kobj_name);
1452}
1453EXPORT_SYMBOL(vio_find_node);
1454
1455int vio_enable_interrupts(struct vio_dev *dev)
1456{
1457 int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
1458 if (rc != H_SUCCESS)
1459 printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
1460 return rc;
1461}
1462EXPORT_SYMBOL(vio_enable_interrupts);
1463
1464int vio_disable_interrupts(struct vio_dev *dev)
1465{
1466 int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
1467 if (rc != H_SUCCESS)
1468 printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
1469 return rc;
1470}
1471EXPORT_SYMBOL(vio_disable_interrupts);
1472#endif
1473