Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / arch / powerpc / kernel / vio.c
blob1b695fdc362b8b10f0551072e74b949dd04d4761
1 /*
2 * IBM PowerPC Virtual I/O Infrastructure Support.
4 * Copyright (c) 2003,2008 IBM Corp.
5 * Dave Engebretsen engebret@us.ibm.com
6 * Santiago Leon santil@us.ibm.com
7 * Hollis Blanchard <hollisb@us.ibm.com>
8 * Stephen Rothwell
9 * Robert Jennings <rcjenn@us.ibm.com>
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version
14 * 2 of the License, or (at your option) any later version.
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>
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>
42 static struct bus_type vio_bus_type;
44 static struct vio_dev vio_bus_device = { /* fake "parent" device */
45 .name = "vio",
46 .type = "",
47 .dev.init_name = "vio",
48 .dev.bus = &vio_bus_type,
51 #ifdef CONFIG_PPC_SMLPAR
52 /**
53 * vio_cmo_pool - A pool of IO memory for CMO use
55 * @size: The size of the pool in bytes
56 * @free: The amount of free memory in the pool
58 struct vio_cmo_pool {
59 size_t size;
60 size_t free;
63 /* How many ms to delay queued balance work */
64 #define VIO_CMO_BALANCE_DELAY 100
66 /* Portion out IO memory to CMO devices by this chunk size */
67 #define VIO_CMO_BALANCE_CHUNK 131072
69 /**
70 * vio_cmo_dev_entry - A device that is CMO-enabled and requires entitlement
72 * @vio_dev: struct vio_dev pointer
73 * @list: pointer to other devices on bus that are being tracked
75 struct vio_cmo_dev_entry {
76 struct vio_dev *viodev;
77 struct list_head list;
80 /**
81 * vio_cmo - VIO bus accounting structure for CMO entitlement
83 * @lock: spinlock for entire structure
84 * @balance_q: work queue for balancing system entitlement
85 * @device_list: list of CMO-enabled devices requiring entitlement
86 * @entitled: total system entitlement in bytes
87 * @reserve: pool of memory from which devices reserve entitlement, incl. spare
88 * @excess: pool of excess entitlement not needed for device reserves or spare
89 * @spare: IO memory for device hotplug functionality
90 * @min: minimum necessary for system operation
91 * @desired: desired memory for system operation
92 * @curr: bytes currently allocated
93 * @high: high water mark for IO data usage
95 struct 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;
110 * vio_cmo_OF_devices - Count the number of OF devices that have DMA windows
112 static int vio_cmo_num_OF_devs(void)
114 struct device_node *node_vroot;
115 int count = 0;
118 * Count the number of vdevice entries with an
119 * ibm,my-dma-window OF property
121 node_vroot = of_find_node_by_name(NULL, "vdevice");
122 if (node_vroot) {
123 struct device_node *of_node;
124 struct property *prop;
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++;
133 of_node_put(node_vroot);
134 return count;
138 * vio_cmo_alloc - allocate IO memory for CMO-enable devices
140 * @viodev: VIO device requesting IO memory
141 * @size: size of allocation requested
143 * Allocations come from memory reserved for the devices and any excess
144 * IO memory available to all devices. The spare pool used to service
145 * hotplug must be equal to %VIO_CMO_MIN_ENT for the excess pool to be
146 * made available.
148 * Return codes:
149 * 0 for successful allocation and -ENOMEM for a failure
151 static inline int vio_cmo_alloc(struct vio_dev *viodev, size_t size)
153 unsigned long flags;
154 size_t reserve_free = 0;
155 size_t excess_free = 0;
156 int ret = -ENOMEM;
158 spin_lock_irqsave(&vio_cmo.lock, flags);
160 /* Determine the amount of free entitlement available in reserve */
161 if (viodev->cmo.entitled > viodev->cmo.allocated)
162 reserve_free = viodev->cmo.entitled - viodev->cmo.allocated;
164 /* If spare is not fulfilled, the excess pool can not be used. */
165 if (vio_cmo.spare >= VIO_CMO_MIN_ENT)
166 excess_free = vio_cmo.excess.free;
168 /* The request can be satisfied */
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;
179 spin_unlock_irqrestore(&vio_cmo.lock, flags);
180 return ret;
184 * vio_cmo_dealloc - deallocate IO memory from CMO-enable devices
185 * @viodev: VIO device freeing IO memory
186 * @size: size of deallocation
188 * IO memory is freed by the device back to the correct memory pools.
189 * The spare pool is replenished first from either memory pool, then
190 * the reserve pool is used to reduce device entitlement, the excess
191 * pool is used to increase the reserve pool toward the desired entitlement
192 * target, and then the remaining memory is returned to the pools.
195 static inline void vio_cmo_dealloc(struct vio_dev *viodev, size_t size)
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;
204 spin_lock_irqsave(&vio_cmo.lock, flags);
205 vio_cmo.curr -= size;
207 /* Amount of memory freed from the excess pool */
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;
214 /* Remove allocation from device */
215 viodev->cmo.allocated -= (reserve_freed + excess_freed);
217 /* Spare is a subset of the reserve pool, replenish it first. */
218 spare_needed = VIO_CMO_MIN_ENT - vio_cmo.spare;
221 * Replenish the spare in the reserve pool from the excess pool.
222 * This moves entitlement into the reserve pool.
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;
235 * Replenish the spare in the reserve pool from the reserve pool.
236 * This removes entitlement from the device down to VIO_CMO_MIN_ENT,
237 * if needed, and gives it to the spare pool. The amount of used
238 * memory in this pool does not change.
240 if (spare_needed && reserve_freed) {
241 tmp = min3(spare_needed, reserve_freed, (viodev->cmo.entitled - VIO_CMO_MIN_ENT));
243 vio_cmo.spare += tmp;
244 viodev->cmo.entitled -= tmp;
245 reserve_freed -= tmp;
246 spare_needed -= tmp;
247 balance = 1;
251 * Increase the reserve pool until the desired allocation is met.
252 * Move an allocation freed from the excess pool into the reserve
253 * pool and schedule a balance operation.
255 if (excess_freed && (vio_cmo.desired > vio_cmo.reserve.size)) {
256 tmp = min(excess_freed, (vio_cmo.desired - vio_cmo.reserve.size));
258 vio_cmo.excess.size -= tmp;
259 vio_cmo.reserve.size += tmp;
260 excess_freed -= tmp;
261 balance = 1;
264 /* Return memory from the excess pool to that pool */
265 if (excess_freed)
266 vio_cmo.excess.free += excess_freed;
268 if (balance)
269 schedule_delayed_work(&vio_cmo.balance_q, VIO_CMO_BALANCE_DELAY);
270 spin_unlock_irqrestore(&vio_cmo.lock, flags);
274 * vio_cmo_entitlement_update - Manage system entitlement changes
276 * @new_entitlement: new system entitlement to attempt to accommodate
278 * Increases in entitlement will be used to fulfill the spare entitlement
279 * and the rest is given to the excess pool. Decreases, if they are
280 * possible, come from the excess pool and from unused device entitlement
282 * Returns: 0 on success, -ENOMEM when change can not be made
284 int vio_cmo_entitlement_update(size_t new_entitlement)
286 struct vio_dev *viodev;
287 struct vio_cmo_dev_entry *dev_ent;
288 unsigned long flags;
289 size_t avail, delta, tmp;
291 spin_lock_irqsave(&vio_cmo.lock, flags);
293 /* Entitlement increases */
294 if (new_entitlement > vio_cmo.entitled) {
295 delta = new_entitlement - vio_cmo.entitled;
297 /* Fulfill spare allocation */
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;
305 /* Remaining new allocation goes to the excess pool */
306 vio_cmo.entitled += delta;
307 vio_cmo.excess.size += delta;
308 vio_cmo.excess.free += delta;
310 goto out;
313 /* Entitlement decreases */
314 delta = vio_cmo.entitled - new_entitlement;
315 avail = vio_cmo.excess.free;
318 * Need to check how much unused entitlement each device can
319 * sacrifice to fulfill entitlement change.
321 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
322 if (avail >= delta)
323 break;
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);
333 if (delta <= avail) {
334 vio_cmo.entitled -= delta;
336 /* Take entitlement from the excess pool first */
337 tmp = min(vio_cmo.excess.free, delta);
338 vio_cmo.excess.size -= tmp;
339 vio_cmo.excess.free -= tmp;
340 delta -= tmp;
343 * Remove all but VIO_CMO_MIN_ENT bytes from devices
344 * until entitlement change is served
346 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
347 if (!delta)
348 break;
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);
360 } else {
361 spin_unlock_irqrestore(&vio_cmo.lock, flags);
362 return -ENOMEM;
365 out:
366 schedule_delayed_work(&vio_cmo.balance_q, 0);
367 spin_unlock_irqrestore(&vio_cmo.lock, flags);
368 return 0;
372 * vio_cmo_balance - Balance entitlement among devices
374 * @work: work queue structure for this operation
376 * Any system entitlement above the minimum needed for devices, or
377 * already allocated to devices, can be distributed to the devices.
378 * The list of devices is iterated through to recalculate the desired
379 * entitlement level and to determine how much entitlement above the
380 * minimum entitlement is allocated to devices.
382 * Small chunks of the available entitlement are given to devices until
383 * their requirements are fulfilled or there is no entitlement left to give.
384 * Upon completion sizes of the reserve and excess pools are calculated.
386 * The system minimum entitlement level is also recalculated here.
387 * Entitlement will be reserved for devices even after vio_bus_remove to
388 * accommodate reloading the driver. The OF tree is walked to count the
389 * number of devices present and this will remove entitlement for devices
390 * that have actually left the system after having vio_bus_remove called.
392 static void vio_cmo_balance(struct work_struct *work)
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;
401 cmo = container_of(work, struct vio_cmo, balance_q.work);
403 spin_lock_irqsave(&vio_cmo.lock, flags);
405 /* Calculate minimum entitlement and fulfill spare */
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;
413 * Determine how much entitlement is available and reset device
414 * entitlements
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);
426 * Having provided each device with the minimum entitlement, loop
427 * over the devices portioning out the remaining entitlement
428 * until there is nothing left.
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;
436 if (viodev->cmo.desired <= level) {
437 fulfilled++;
438 continue;
442 * Give the device up to VIO_CMO_BALANCE_CHUNK
443 * bytes of entitlement, but do not exceed the
444 * desired level of entitlement for the device.
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;
452 * If the memory for this entitlement increase was
453 * already allocated to the device it does not come
454 * from the available pool being portioned out.
456 need = max(viodev->cmo.allocated, viodev->cmo.entitled)-
457 max(viodev->cmo.allocated, level);
458 avail -= need;
461 if (fulfilled == devcount)
462 break;
463 level += VIO_CMO_BALANCE_CHUNK;
466 /* Calculate new reserve and excess pool sizes */
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 /* Calculated reserve size above the minimum entitlement */
474 if (viodev->cmo.entitled)
475 cmo->reserve.size += (viodev->cmo.entitled -
476 VIO_CMO_MIN_ENT);
477 /* Calculated used excess entitlement */
478 if (viodev->cmo.allocated > viodev->cmo.entitled)
479 need += viodev->cmo.allocated - viodev->cmo.entitled;
481 cmo->excess.size = cmo->entitled - cmo->reserve.size;
482 cmo->excess.free = cmo->excess.size - need;
484 cancel_delayed_work(to_delayed_work(work));
485 spin_unlock_irqrestore(&vio_cmo.lock, flags);
488 static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
489 dma_addr_t *dma_handle, gfp_t flag)
491 struct vio_dev *viodev = to_vio_dev(dev);
492 void *ret;
494 if (vio_cmo_alloc(viodev, roundup(size, PAGE_SIZE))) {
495 atomic_inc(&viodev->cmo.allocs_failed);
496 return NULL;
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);
505 return ret;
508 static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
509 void *vaddr, dma_addr_t dma_handle)
511 struct vio_dev *viodev = to_vio_dev(dev);
513 dma_iommu_ops.free_coherent(dev, size, vaddr, dma_handle);
515 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
518 static 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)
523 struct vio_dev *viodev = to_vio_dev(dev);
524 dma_addr_t ret = DMA_ERROR_CODE;
526 if (vio_cmo_alloc(viodev, roundup(size, IOMMU_PAGE_SIZE))) {
527 atomic_inc(&viodev->cmo.allocs_failed);
528 return ret;
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);
537 return ret;
540 static 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)
545 struct vio_dev *viodev = to_vio_dev(dev);
547 dma_iommu_ops.unmap_page(dev, dma_handle, size, direction, attrs);
549 vio_cmo_dealloc(viodev, roundup(size, IOMMU_PAGE_SIZE));
552 static 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)
556 struct vio_dev *viodev = to_vio_dev(dev);
557 struct scatterlist *sgl;
558 int ret, count = 0;
559 size_t alloc_size = 0;
561 for (sgl = sglist; count < nelems; count++, sgl++)
562 alloc_size += roundup(sgl->length, IOMMU_PAGE_SIZE);
564 if (vio_cmo_alloc(viodev, alloc_size)) {
565 atomic_inc(&viodev->cmo.allocs_failed);
566 return 0;
569 ret = dma_iommu_ops.map_sg(dev, sglist, nelems, direction, attrs);
571 if (unlikely(!ret)) {
572 vio_cmo_dealloc(viodev, alloc_size);
573 atomic_inc(&viodev->cmo.allocs_failed);
574 return ret;
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);
582 return ret;
585 static 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)
590 struct vio_dev *viodev = to_vio_dev(dev);
591 struct scatterlist *sgl;
592 size_t alloc_size = 0;
593 int count = 0;
595 for (sgl = sglist; count < nelems; count++, sgl++)
596 alloc_size += roundup(sgl->dma_length, IOMMU_PAGE_SIZE);
598 dma_iommu_ops.unmap_sg(dev, sglist, nelems, direction, attrs);
600 vio_cmo_dealloc(viodev, alloc_size);
603 static int vio_dma_iommu_dma_supported(struct device *dev, u64 mask)
605 return dma_iommu_ops.dma_supported(dev, mask);
608 struct 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,
620 * vio_cmo_set_dev_desired - Set desired entitlement for a device
622 * @viodev: struct vio_dev for device to alter
623 * @new_desired: new desired entitlement level in bytes
625 * For use by devices to request a change to their entitlement at runtime or
626 * through sysfs. The desired entitlement level is changed and a balancing
627 * of system resources is scheduled to run in the future.
629 void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired)
631 unsigned long flags;
632 struct vio_cmo_dev_entry *dev_ent;
633 int found = 0;
635 if (!firmware_has_feature(FW_FEATURE_CMO))
636 return;
638 spin_lock_irqsave(&vio_cmo.lock, flags);
639 if (desired < VIO_CMO_MIN_ENT)
640 desired = VIO_CMO_MIN_ENT;
643 * Changes will not be made for devices not in the device list.
644 * If it is not in the device list, then no driver is loaded
645 * for the device and it can not receive entitlement.
647 list_for_each_entry(dev_ent, &vio_cmo.device_list, list)
648 if (viodev == dev_ent->viodev) {
649 found = 1;
650 break;
652 if (!found) {
653 spin_unlock_irqrestore(&vio_cmo.lock, flags);
654 return;
657 /* Increase/decrease in desired device entitlement */
658 if (desired >= viodev->cmo.desired) {
659 /* Just bump the bus and device values prior to a balance*/
660 vio_cmo.desired += desired - viodev->cmo.desired;
661 viodev->cmo.desired = desired;
662 } else {
663 /* Decrease bus and device values for desired entitlement */
664 vio_cmo.desired -= viodev->cmo.desired - desired;
665 viodev->cmo.desired = desired;
667 * If less entitlement is desired than current entitlement, move
668 * any reserve memory in the change region to the excess pool.
670 if (viodev->cmo.entitled > desired) {
671 vio_cmo.reserve.size -= viodev->cmo.entitled - desired;
672 vio_cmo.excess.size += viodev->cmo.entitled - desired;
674 * If entitlement moving from the reserve pool to the
675 * excess pool is currently unused, add to the excess
676 * free counter.
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;
684 schedule_delayed_work(&vio_cmo.balance_q, 0);
685 spin_unlock_irqrestore(&vio_cmo.lock, flags);
689 * vio_cmo_bus_probe - Handle CMO specific bus probe activities
691 * @viodev - Pointer to struct vio_dev for device
693 * Determine the devices IO memory entitlement needs, attempting
694 * to satisfy the system minimum entitlement at first and scheduling
695 * a balance operation to take care of the rest at a later time.
697 * Returns: 0 on success, -EINVAL when device doesn't support CMO, and
698 * -ENOMEM when entitlement is not available for device or
699 * device entry.
702 static int vio_cmo_bus_probe(struct vio_dev *viodev)
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;
711 * Check to see that device has a DMA window and configure
712 * entitlement for the device.
714 if (of_get_property(viodev->dev.of_node,
715 "ibm,my-dma-window", NULL)) {
716 /* Check that the driver is CMO enabled and get desired DMA */
717 if (!viodrv->get_desired_dma) {
718 dev_err(dev, "%s: device driver does not support CMO\n",
719 __func__);
720 return -EINVAL;
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;
728 dev_ent = kmalloc(sizeof(struct vio_cmo_dev_entry),
729 GFP_KERNEL);
730 if (!dev_ent)
731 return -ENOMEM;
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);
743 * If the needs for vio_cmo.min have not changed since they
744 * were last set, the number of devices in the OF tree has
745 * been constant and the IO memory for this is already in
746 * the reserve pool.
748 if (vio_cmo.min == ((vio_cmo_num_OF_devs() + 1) *
749 VIO_CMO_MIN_ENT)) {
750 /* Updated desired entitlement if device requires it */
751 if (size)
752 vio_cmo.desired += (viodev->cmo.desired -
753 VIO_CMO_MIN_ENT);
754 } else {
755 size_t tmp;
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;
767 /* Use excess pool first to fulfill request */
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;
773 /* Use spare if excess pool was insufficient */
774 vio_cmo.spare -= size - tmp;
776 /* Update bus accounting */
777 vio_cmo.min += size;
778 vio_cmo.desired += viodev->cmo.desired;
780 spin_unlock_irqrestore(&vio_cmo.lock, flags);
781 return 0;
785 * vio_cmo_bus_remove - Handle CMO specific bus removal activities
787 * @viodev - Pointer to struct vio_dev for device
789 * Remove the device from the cmo device list. The minimum entitlement
790 * will be reserved for the device as long as it is in the system. The
791 * rest of the entitlement the device had been allocated will be returned
792 * to the system.
794 static void vio_cmo_bus_remove(struct vio_dev *viodev)
796 struct vio_cmo_dev_entry *dev_ent;
797 unsigned long flags;
798 size_t tmp;
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();
809 * Remove the device from the device list being maintained for
810 * CMO enabled devices.
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;
820 * Devices may not require any entitlement and they do not need
821 * to be processed. Otherwise, return the device's entitlement
822 * back to the pools.
824 if (viodev->cmo.entitled) {
826 * This device has not yet left the OF tree, it's
827 * minimum entitlement remains in vio_cmo.min and
828 * vio_cmo.desired
830 vio_cmo.desired -= (viodev->cmo.desired - VIO_CMO_MIN_ENT);
833 * Save min allocation for device in reserve as long
834 * as it exists in OF tree as determined by later
835 * balance operation
837 viodev->cmo.entitled -= VIO_CMO_MIN_ENT;
839 /* Replenish spare from freed reserve pool */
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;
847 /* Remaining reserve goes to excess pool */
848 vio_cmo.excess.size += viodev->cmo.entitled;
849 vio_cmo.excess.free += viodev->cmo.entitled;
850 vio_cmo.reserve.size -= viodev->cmo.entitled;
853 * Until the device is removed it will keep a
854 * minimum entitlement; this will guarantee that
855 * a module unload/load will result in a success.
857 viodev->cmo.entitled = VIO_CMO_MIN_ENT;
858 viodev->cmo.desired = VIO_CMO_MIN_ENT;
859 atomic_set(&viodev->cmo.allocs_failed, 0);
862 spin_unlock_irqrestore(&vio_cmo.lock, flags);
865 static void vio_cmo_set_dma_ops(struct vio_dev *viodev)
867 set_dma_ops(&viodev->dev, &vio_dma_mapping_ops);
871 * vio_cmo_bus_init - CMO entitlement initialization at bus init time
873 * Set up the reserve and excess entitlement pools based on available
874 * system entitlement and the number of devices in the OF tree that
875 * require entitlement in the reserve pool.
877 static void vio_cmo_bus_init(void)
879 struct hvcall_mpp_data mpp_data;
880 int err;
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);
887 /* Get current system entitlement */
888 err = h_get_mpp(&mpp_data);
891 * On failure, continue with entitlement set to 0, will panic()
892 * later when spare is reserved.
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;
902 /* Set reservation and check against entitlement */
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__);
913 /* Set the remaining accounting variables */
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;
920 /* sysfs device functions and data structures for CMO */
922 #define viodev_cmo_rd_attr(name) \
923 static ssize_t viodev_cmo_##name##_show(struct device *dev, \
924 struct device_attribute *attr, \
925 char *buf) \
927 return sprintf(buf, "%lu\n", to_vio_dev(dev)->cmo.name); \
930 static ssize_t viodev_cmo_allocs_failed_show(struct device *dev,
931 struct device_attribute *attr, char *buf)
933 struct vio_dev *viodev = to_vio_dev(dev);
934 return sprintf(buf, "%d\n", atomic_read(&viodev->cmo.allocs_failed));
937 static ssize_t viodev_cmo_allocs_failed_reset(struct device *dev,
938 struct device_attribute *attr, const char *buf, size_t count)
940 struct vio_dev *viodev = to_vio_dev(dev);
941 atomic_set(&viodev->cmo.allocs_failed, 0);
942 return count;
945 static ssize_t viodev_cmo_desired_set(struct device *dev,
946 struct device_attribute *attr, const char *buf, size_t count)
948 struct vio_dev *viodev = to_vio_dev(dev);
949 size_t new_desired;
950 int ret;
952 ret = strict_strtoul(buf, 10, &new_desired);
953 if (ret)
954 return ret;
956 vio_cmo_set_dev_desired(viodev, new_desired);
957 return count;
960 viodev_cmo_rd_attr(desired);
961 viodev_cmo_rd_attr(entitled);
962 viodev_cmo_rd_attr(allocated);
964 static ssize_t name_show(struct device *, struct device_attribute *, char *);
965 static ssize_t devspec_show(struct device *, struct device_attribute *, char *);
966 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
967 char *buf);
968 static 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
981 /* sysfs bus functions and data structures for CMO */
983 #define viobus_cmo_rd_attr(name) \
984 static ssize_t \
985 viobus_cmo_##name##_show(struct bus_type *bt, char *buf) \
987 return sprintf(buf, "%lu\n", vio_cmo.name); \
990 #define viobus_cmo_pool_rd_attr(name, var) \
991 static ssize_t \
992 viobus_cmo_##name##_pool_show_##var(struct bus_type *bt, char *buf) \
994 return sprintf(buf, "%lu\n", vio_cmo.name.var); \
997 static ssize_t viobus_cmo_high_reset(struct bus_type *bt, const char *buf,
998 size_t count)
1000 unsigned long flags;
1002 spin_lock_irqsave(&vio_cmo.lock, flags);
1003 vio_cmo.high = vio_cmo.curr;
1004 spin_unlock_irqrestore(&vio_cmo.lock, flags);
1006 return count;
1009 viobus_cmo_rd_attr(entitled);
1010 viobus_cmo_pool_rd_attr(reserve, size);
1011 viobus_cmo_pool_rd_attr(excess, size);
1012 viobus_cmo_pool_rd_attr(excess, free);
1013 viobus_cmo_rd_attr(spare);
1014 viobus_cmo_rd_attr(min);
1015 viobus_cmo_rd_attr(desired);
1016 viobus_cmo_rd_attr(curr);
1017 viobus_cmo_rd_attr(high);
1019 static 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
1033 static void vio_cmo_sysfs_init(void)
1035 vio_bus_type.dev_attrs = vio_cmo_dev_attrs;
1036 vio_bus_type.bus_attrs = vio_cmo_bus_attrs;
1038 #else /* CONFIG_PPC_SMLPAR */
1039 /* Dummy functions for iSeries platform */
1040 int vio_cmo_entitlement_update(size_t new_entitlement) { return 0; }
1041 void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired) {}
1042 static int vio_cmo_bus_probe(struct vio_dev *viodev) { return 0; }
1043 static void vio_cmo_bus_remove(struct vio_dev *viodev) {}
1044 static void vio_cmo_set_dma_ops(struct vio_dev *viodev) {}
1045 static void vio_cmo_bus_init(void) {}
1046 static void vio_cmo_sysfs_init(void) { }
1047 #endif /* CONFIG_PPC_SMLPAR */
1048 EXPORT_SYMBOL(vio_cmo_entitlement_update);
1049 EXPORT_SYMBOL(vio_cmo_set_dev_desired);
1051 static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
1053 const unsigned char *dma_window;
1054 struct iommu_table *tbl;
1055 unsigned long offset, size;
1057 if (firmware_has_feature(FW_FEATURE_ISERIES))
1058 return vio_build_iommu_table_iseries(dev);
1060 dma_window = of_get_property(dev->dev.of_node,
1061 "ibm,my-dma-window", NULL);
1062 if (!dma_window)
1063 return NULL;
1065 tbl = kzalloc(sizeof(*tbl), GFP_KERNEL);
1066 if (tbl == NULL)
1067 return NULL;
1069 of_parse_dma_window(dev->dev.of_node, dma_window,
1070 &tbl->it_index, &offset, &size);
1072 /* TCE table size - measured in tce entries */
1073 tbl->it_size = size >> IOMMU_PAGE_SHIFT;
1074 /* offset for VIO should always be 0 */
1075 tbl->it_offset = offset >> IOMMU_PAGE_SHIFT;
1076 tbl->it_busno = 0;
1077 tbl->it_type = TCE_VB;
1078 tbl->it_blocksize = 16;
1080 return iommu_init_table(tbl, -1);
1084 * vio_match_device: - Tell if a VIO device has a matching
1085 * VIO device id structure.
1086 * @ids: array of VIO device id structures to search in
1087 * @dev: the VIO device structure to match against
1089 * Used by a driver to check whether a VIO device present in the
1090 * system is in its list of supported devices. Returns the matching
1091 * vio_device_id structure or NULL if there is no match.
1093 static const struct vio_device_id *vio_match_device(
1094 const struct vio_device_id *ids, const struct vio_dev *dev)
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++;
1103 return NULL;
1107 * Convert from struct device to struct vio_dev and pass to driver.
1108 * dev->driver has already been set by generic code because vio_bus_match
1109 * succeeded.
1111 static int vio_bus_probe(struct device *dev)
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;
1118 if (!viodrv->probe)
1119 return error;
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;
1129 error = viodrv->probe(viodev, id);
1130 if (error && firmware_has_feature(FW_FEATURE_CMO))
1131 vio_cmo_bus_remove(viodev);
1134 return error;
1137 /* convert from struct device to struct vio_dev and pass to driver. */
1138 static int vio_bus_remove(struct device *dev)
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;
1146 * Hold a reference to the device after the remove function is called
1147 * to allow for CMO accounting cleanup for the device.
1149 devptr = get_device(dev);
1151 if (viodrv->remove)
1152 ret = viodrv->remove(viodev);
1154 if (!ret && firmware_has_feature(FW_FEATURE_CMO))
1155 vio_cmo_bus_remove(viodev);
1157 put_device(devptr);
1158 return ret;
1162 * vio_register_driver: - Register a new vio driver
1163 * @drv: The vio_driver structure to be registered.
1165 int vio_register_driver(struct vio_driver *viodrv)
1167 printk(KERN_DEBUG "%s: driver %s registering\n", __func__,
1168 viodrv->driver.name);
1170 /* fill in 'struct driver' fields */
1171 viodrv->driver.bus = &vio_bus_type;
1173 return driver_register(&viodrv->driver);
1175 EXPORT_SYMBOL(vio_register_driver);
1178 * vio_unregister_driver - Remove registration of vio driver.
1179 * @driver: The vio_driver struct to be removed form registration
1181 void vio_unregister_driver(struct vio_driver *viodrv)
1183 driver_unregister(&viodrv->driver);
1185 EXPORT_SYMBOL(vio_unregister_driver);
1187 /* vio_dev refcount hit 0 */
1188 static void __devinit vio_dev_release(struct device *dev)
1190 struct iommu_table *tbl = get_iommu_table_base(dev);
1192 /* iSeries uses a common table for all vio devices */
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));
1201 * vio_register_device_node: - Register a new vio device.
1202 * @of_node: The OF node for this device.
1204 * Creates and initializes a vio_dev structure from the data in
1205 * of_node and adds it to the list of virtual devices.
1206 * Returns a pointer to the created vio_dev or NULL if node has
1207 * NULL device_type or compatible fields.
1209 struct vio_dev *vio_register_device_node(struct device_node *of_node)
1211 struct vio_dev *viodev;
1212 const unsigned int *unit_address;
1214 /* we need the 'device_type' property, in order to match with drivers */
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;
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;
1230 /* allocate a vio_dev for this node */
1231 viodev = kzalloc(sizeof(struct vio_dev), GFP_KERNEL);
1232 if (viodev == NULL)
1233 return NULL;
1235 viodev->irq = irq_of_parse_and_map(of_node, 0);
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;
1247 viodev->dev.of_node = of_node_get(of_node);
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));
1256 /* init generic 'struct device' fields: */
1257 viodev->dev.parent = &vio_bus_device.dev;
1258 viodev->dev.bus = &vio_bus_type;
1259 viodev->dev.release = vio_dev_release;
1260 /* needed to ensure proper operation of coherent allocations
1261 * later, in case driver doesn't set it explicitly */
1262 dma_set_mask(&viodev->dev, DMA_BIT_MASK(64));
1263 dma_set_coherent_mask(&viodev->dev, DMA_BIT_MASK(64));
1265 /* register with generic device framework */
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;
1273 return viodev;
1275 EXPORT_SYMBOL(vio_register_device_node);
1278 * vio_bus_init: - Initialize the virtual IO bus
1280 static int __init vio_bus_init(void)
1282 int err;
1283 struct device_node *node_vroot;
1285 if (firmware_has_feature(FW_FEATURE_CMO))
1286 vio_cmo_sysfs_init();
1288 err = bus_register(&vio_bus_type);
1289 if (err) {
1290 printk(KERN_ERR "failed to register VIO bus\n");
1291 return err;
1295 * The fake parent of all vio devices, just to give us
1296 * a nice directory
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;
1305 if (firmware_has_feature(FW_FEATURE_CMO))
1306 vio_cmo_bus_init();
1308 node_vroot = of_find_node_by_name(NULL, "vdevice");
1309 if (node_vroot) {
1310 struct device_node *of_node;
1313 * Create struct vio_devices for each virtual device in
1314 * the device tree. Drivers will associate with them later.
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);
1322 return 0;
1324 __initcall(vio_bus_init);
1326 static ssize_t name_show(struct device *dev,
1327 struct device_attribute *attr, char *buf)
1329 return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
1332 static ssize_t devspec_show(struct device *dev,
1333 struct device_attribute *attr, char *buf)
1335 struct device_node *of_node = dev->of_node;
1337 return sprintf(buf, "%s\n", of_node ? of_node->full_name : "none");
1340 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
1341 char *buf)
1343 const struct vio_dev *vio_dev = to_vio_dev(dev);
1344 struct device_node *dn;
1345 const char *cp;
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;
1354 return sprintf(buf, "vio:T%sS%s\n", vio_dev->type, cp);
1357 static struct device_attribute vio_dev_attrs[] = {
1358 __ATTR_RO(name),
1359 __ATTR_RO(devspec),
1360 __ATTR_RO(modalias),
1361 __ATTR_NULL
1364 void __devinit vio_unregister_device(struct vio_dev *viodev)
1366 device_unregister(&viodev->dev);
1368 EXPORT_SYMBOL(vio_unregister_device);
1370 static int vio_bus_match(struct device *dev, struct device_driver *drv)
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;
1376 return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL);
1379 static int vio_hotplug(struct device *dev, struct kobj_uevent_env *env)
1381 const struct vio_dev *vio_dev = to_vio_dev(dev);
1382 struct device_node *dn;
1383 const char *cp;
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;
1392 add_uevent_var(env, "MODALIAS=vio:T%sS%s", vio_dev->type, cp);
1393 return 0;
1396 static 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,
1407 * vio_get_attribute: - get attribute for virtual device
1408 * @vdev: The vio device to get property.
1409 * @which: The property/attribute to be extracted.
1410 * @length: Pointer to length of returned data size (unused if NULL).
1412 * Calls prom.c's of_get_property() to return the value of the
1413 * attribute specified by @which
1415 const void *vio_get_attribute(struct vio_dev *vdev, char *which, int *length)
1417 return of_get_property(vdev->dev.of_node, which, length);
1419 EXPORT_SYMBOL(vio_get_attribute);
1421 #ifdef CONFIG_PPC_PSERIES
1422 /* vio_find_name() - internal because only vio.c knows how we formatted the
1423 * kobject name
1425 static struct vio_dev *vio_find_name(const char *name)
1427 struct device *found;
1429 found = bus_find_device_by_name(&vio_bus_type, NULL, name);
1430 if (!found)
1431 return NULL;
1433 return to_vio_dev(found);
1437 * vio_find_node - find an already-registered vio_dev
1438 * @vnode: device_node of the virtual device we're looking for
1440 struct vio_dev *vio_find_node(struct device_node *vnode)
1442 const uint32_t *unit_address;
1443 char kobj_name[20];
1445 /* construct the kobject name from the device node */
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);
1451 return vio_find_name(kobj_name);
1453 EXPORT_SYMBOL(vio_find_node);
1455 int vio_enable_interrupts(struct vio_dev *dev)
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;
1462 EXPORT_SYMBOL(vio_enable_interrupts);
1464 int vio_disable_interrupts(struct vio_dev *dev)
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;
1471 EXPORT_SYMBOL(vio_disable_interrupts);
1472 #endif /* CONFIG_PPC_PSERIES */