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>
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>
24 #include <linux/dma-mapping.h>
25 #include <linux/kobject.h>
27 #include <asm/iommu.h>
31 #include <asm/firmware.h>
33 #include <asm/abs_addr.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 */
47 .dev
.init_name
= "vio",
48 .dev
.bus
= &vio_bus_type
,
51 #ifdef CONFIG_PPC_SMLPAR
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
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
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
;
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
97 struct delayed_work balance_q
;
98 struct list_head device_list
;
100 struct vio_cmo_pool reserve
;
101 struct vio_cmo_pool excess
;
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
;
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");
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",
133 of_node_put(node_vroot
);
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
149 * 0 for successful allocation and -ENOMEM for a failure
151 static inline int vio_cmo_alloc(struct vio_dev
*viodev
, size_t size
)
154 size_t reserve_free
= 0;
155 size_t excess_free
= 0;
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
;
179 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
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
)
198 size_t spare_needed
= 0;
199 size_t excess_freed
= 0;
200 size_t reserve_freed
= size
;
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
;
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
= min(spare_needed
, min(reserve_freed
,
242 (viodev
->cmo
.entitled
-
245 vio_cmo
.spare
+= tmp
;
246 viodev
->cmo
.entitled
-= tmp
;
247 reserve_freed
-= tmp
;
253 * Increase the reserve pool until the desired allocation is met.
254 * Move an allocation freed from the excess pool into the reserve
255 * pool and schedule a balance operation.
257 if (excess_freed
&& (vio_cmo
.desired
> vio_cmo
.reserve
.size
)) {
258 tmp
= min(excess_freed
, (vio_cmo
.desired
- vio_cmo
.reserve
.size
));
260 vio_cmo
.excess
.size
-= tmp
;
261 vio_cmo
.reserve
.size
+= tmp
;
266 /* Return memory from the excess pool to that pool */
268 vio_cmo
.excess
.free
+= excess_freed
;
271 schedule_delayed_work(&vio_cmo
.balance_q
, VIO_CMO_BALANCE_DELAY
);
272 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
276 * vio_cmo_entitlement_update - Manage system entitlement changes
278 * @new_entitlement: new system entitlement to attempt to accommodate
280 * Increases in entitlement will be used to fulfill the spare entitlement
281 * and the rest is given to the excess pool. Decreases, if they are
282 * possible, come from the excess pool and from unused device entitlement
284 * Returns: 0 on success, -ENOMEM when change can not be made
286 int vio_cmo_entitlement_update(size_t new_entitlement
)
288 struct vio_dev
*viodev
;
289 struct vio_cmo_dev_entry
*dev_ent
;
291 size_t avail
, delta
, tmp
;
293 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
295 /* Entitlement increases */
296 if (new_entitlement
> vio_cmo
.entitled
) {
297 delta
= new_entitlement
- vio_cmo
.entitled
;
299 /* Fulfill spare allocation */
300 if (vio_cmo
.spare
< VIO_CMO_MIN_ENT
) {
301 tmp
= min(delta
, (VIO_CMO_MIN_ENT
- vio_cmo
.spare
));
302 vio_cmo
.spare
+= tmp
;
303 vio_cmo
.reserve
.size
+= tmp
;
307 /* Remaining new allocation goes to the excess pool */
308 vio_cmo
.entitled
+= delta
;
309 vio_cmo
.excess
.size
+= delta
;
310 vio_cmo
.excess
.free
+= delta
;
315 /* Entitlement decreases */
316 delta
= vio_cmo
.entitled
- new_entitlement
;
317 avail
= vio_cmo
.excess
.free
;
320 * Need to check how much unused entitlement each device can
321 * sacrifice to fulfill entitlement change.
323 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
327 viodev
= dev_ent
->viodev
;
328 if ((viodev
->cmo
.entitled
> viodev
->cmo
.allocated
) &&
329 (viodev
->cmo
.entitled
> VIO_CMO_MIN_ENT
))
330 avail
+= viodev
->cmo
.entitled
-
331 max_t(size_t, viodev
->cmo
.allocated
,
335 if (delta
<= avail
) {
336 vio_cmo
.entitled
-= delta
;
338 /* Take entitlement from the excess pool first */
339 tmp
= min(vio_cmo
.excess
.free
, delta
);
340 vio_cmo
.excess
.size
-= tmp
;
341 vio_cmo
.excess
.free
-= tmp
;
345 * Remove all but VIO_CMO_MIN_ENT bytes from devices
346 * until entitlement change is served
348 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
352 viodev
= dev_ent
->viodev
;
354 if ((viodev
->cmo
.entitled
> viodev
->cmo
.allocated
) &&
355 (viodev
->cmo
.entitled
> VIO_CMO_MIN_ENT
))
356 tmp
= viodev
->cmo
.entitled
-
357 max_t(size_t, viodev
->cmo
.allocated
,
359 viodev
->cmo
.entitled
-= min(tmp
, delta
);
360 delta
-= min(tmp
, delta
);
363 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
368 schedule_delayed_work(&vio_cmo
.balance_q
, 0);
369 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
374 * vio_cmo_balance - Balance entitlement among devices
376 * @work: work queue structure for this operation
378 * Any system entitlement above the minimum needed for devices, or
379 * already allocated to devices, can be distributed to the devices.
380 * The list of devices is iterated through to recalculate the desired
381 * entitlement level and to determine how much entitlement above the
382 * minimum entitlement is allocated to devices.
384 * Small chunks of the available entitlement are given to devices until
385 * their requirements are fulfilled or there is no entitlement left to give.
386 * Upon completion sizes of the reserve and excess pools are calculated.
388 * The system minimum entitlement level is also recalculated here.
389 * Entitlement will be reserved for devices even after vio_bus_remove to
390 * accommodate reloading the driver. The OF tree is walked to count the
391 * number of devices present and this will remove entitlement for devices
392 * that have actually left the system after having vio_bus_remove called.
394 static void vio_cmo_balance(struct work_struct
*work
)
397 struct vio_dev
*viodev
;
398 struct vio_cmo_dev_entry
*dev_ent
;
400 size_t avail
= 0, level
, chunk
, need
;
401 int devcount
= 0, fulfilled
;
403 cmo
= container_of(work
, struct vio_cmo
, balance_q
.work
);
405 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
407 /* Calculate minimum entitlement and fulfill spare */
408 cmo
->min
= vio_cmo_num_OF_devs() * VIO_CMO_MIN_ENT
;
409 BUG_ON(cmo
->min
> cmo
->entitled
);
410 cmo
->spare
= min_t(size_t, VIO_CMO_MIN_ENT
, (cmo
->entitled
- cmo
->min
));
411 cmo
->min
+= cmo
->spare
;
412 cmo
->desired
= cmo
->min
;
415 * Determine how much entitlement is available and reset device
418 avail
= cmo
->entitled
- cmo
->spare
;
419 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
420 viodev
= dev_ent
->viodev
;
422 viodev
->cmo
.entitled
= VIO_CMO_MIN_ENT
;
423 cmo
->desired
+= (viodev
->cmo
.desired
- VIO_CMO_MIN_ENT
);
424 avail
-= max_t(size_t, viodev
->cmo
.allocated
, VIO_CMO_MIN_ENT
);
428 * Having provided each device with the minimum entitlement, loop
429 * over the devices portioning out the remaining entitlement
430 * until there is nothing left.
432 level
= VIO_CMO_MIN_ENT
;
435 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
436 viodev
= dev_ent
->viodev
;
438 if (viodev
->cmo
.desired
<= level
) {
444 * Give the device up to VIO_CMO_BALANCE_CHUNK
445 * bytes of entitlement, but do not exceed the
446 * desired level of entitlement for the device.
448 chunk
= min_t(size_t, avail
, VIO_CMO_BALANCE_CHUNK
);
449 chunk
= min(chunk
, (viodev
->cmo
.desired
-
450 viodev
->cmo
.entitled
));
451 viodev
->cmo
.entitled
+= chunk
;
454 * If the memory for this entitlement increase was
455 * already allocated to the device it does not come
456 * from the available pool being portioned out.
458 need
= max(viodev
->cmo
.allocated
, viodev
->cmo
.entitled
)-
459 max(viodev
->cmo
.allocated
, level
);
463 if (fulfilled
== devcount
)
465 level
+= VIO_CMO_BALANCE_CHUNK
;
468 /* Calculate new reserve and excess pool sizes */
469 cmo
->reserve
.size
= cmo
->min
;
470 cmo
->excess
.free
= 0;
471 cmo
->excess
.size
= 0;
473 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
474 viodev
= dev_ent
->viodev
;
475 /* Calculated reserve size above the minimum entitlement */
476 if (viodev
->cmo
.entitled
)
477 cmo
->reserve
.size
+= (viodev
->cmo
.entitled
-
479 /* Calculated used excess entitlement */
480 if (viodev
->cmo
.allocated
> viodev
->cmo
.entitled
)
481 need
+= viodev
->cmo
.allocated
- viodev
->cmo
.entitled
;
483 cmo
->excess
.size
= cmo
->entitled
- cmo
->reserve
.size
;
484 cmo
->excess
.free
= cmo
->excess
.size
- need
;
486 cancel_delayed_work(to_delayed_work(work
));
487 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
490 static void *vio_dma_iommu_alloc_coherent(struct device
*dev
, size_t size
,
491 dma_addr_t
*dma_handle
, gfp_t flag
)
493 struct vio_dev
*viodev
= to_vio_dev(dev
);
496 if (vio_cmo_alloc(viodev
, roundup(size
, PAGE_SIZE
))) {
497 atomic_inc(&viodev
->cmo
.allocs_failed
);
501 ret
= dma_iommu_ops
.alloc_coherent(dev
, size
, dma_handle
, flag
);
502 if (unlikely(ret
== NULL
)) {
503 vio_cmo_dealloc(viodev
, roundup(size
, PAGE_SIZE
));
504 atomic_inc(&viodev
->cmo
.allocs_failed
);
510 static void vio_dma_iommu_free_coherent(struct device
*dev
, size_t size
,
511 void *vaddr
, dma_addr_t dma_handle
)
513 struct vio_dev
*viodev
= to_vio_dev(dev
);
515 dma_iommu_ops
.free_coherent(dev
, size
, vaddr
, dma_handle
);
517 vio_cmo_dealloc(viodev
, roundup(size
, PAGE_SIZE
));
520 static dma_addr_t
vio_dma_iommu_map_page(struct device
*dev
, struct page
*page
,
521 unsigned long offset
, size_t size
,
522 enum dma_data_direction direction
,
523 struct dma_attrs
*attrs
)
525 struct vio_dev
*viodev
= to_vio_dev(dev
);
526 dma_addr_t ret
= DMA_ERROR_CODE
;
528 if (vio_cmo_alloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
))) {
529 atomic_inc(&viodev
->cmo
.allocs_failed
);
533 ret
= dma_iommu_ops
.map_page(dev
, page
, offset
, size
, direction
, attrs
);
534 if (unlikely(dma_mapping_error(dev
, ret
))) {
535 vio_cmo_dealloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
));
536 atomic_inc(&viodev
->cmo
.allocs_failed
);
542 static void vio_dma_iommu_unmap_page(struct device
*dev
, dma_addr_t dma_handle
,
544 enum dma_data_direction direction
,
545 struct dma_attrs
*attrs
)
547 struct vio_dev
*viodev
= to_vio_dev(dev
);
549 dma_iommu_ops
.unmap_page(dev
, dma_handle
, size
, direction
, attrs
);
551 vio_cmo_dealloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
));
554 static int vio_dma_iommu_map_sg(struct device
*dev
, struct scatterlist
*sglist
,
555 int nelems
, enum dma_data_direction direction
,
556 struct dma_attrs
*attrs
)
558 struct vio_dev
*viodev
= to_vio_dev(dev
);
559 struct scatterlist
*sgl
;
561 size_t alloc_size
= 0;
563 for (sgl
= sglist
; count
< nelems
; count
++, sgl
++)
564 alloc_size
+= roundup(sgl
->length
, IOMMU_PAGE_SIZE
);
566 if (vio_cmo_alloc(viodev
, alloc_size
)) {
567 atomic_inc(&viodev
->cmo
.allocs_failed
);
571 ret
= dma_iommu_ops
.map_sg(dev
, sglist
, nelems
, direction
, attrs
);
573 if (unlikely(!ret
)) {
574 vio_cmo_dealloc(viodev
, alloc_size
);
575 atomic_inc(&viodev
->cmo
.allocs_failed
);
579 for (sgl
= sglist
, count
= 0; count
< ret
; count
++, sgl
++)
580 alloc_size
-= roundup(sgl
->dma_length
, IOMMU_PAGE_SIZE
);
582 vio_cmo_dealloc(viodev
, alloc_size
);
587 static void vio_dma_iommu_unmap_sg(struct device
*dev
,
588 struct scatterlist
*sglist
, int nelems
,
589 enum dma_data_direction direction
,
590 struct dma_attrs
*attrs
)
592 struct vio_dev
*viodev
= to_vio_dev(dev
);
593 struct scatterlist
*sgl
;
594 size_t alloc_size
= 0;
597 for (sgl
= sglist
; count
< nelems
; count
++, sgl
++)
598 alloc_size
+= roundup(sgl
->dma_length
, IOMMU_PAGE_SIZE
);
600 dma_iommu_ops
.unmap_sg(dev
, sglist
, nelems
, direction
, attrs
);
602 vio_cmo_dealloc(viodev
, alloc_size
);
605 struct dma_map_ops vio_dma_mapping_ops
= {
606 .alloc_coherent
= vio_dma_iommu_alloc_coherent
,
607 .free_coherent
= vio_dma_iommu_free_coherent
,
608 .map_sg
= vio_dma_iommu_map_sg
,
609 .unmap_sg
= vio_dma_iommu_unmap_sg
,
610 .map_page
= vio_dma_iommu_map_page
,
611 .unmap_page
= vio_dma_iommu_unmap_page
,
616 * vio_cmo_set_dev_desired - Set desired entitlement for a device
618 * @viodev: struct vio_dev for device to alter
619 * @new_desired: new desired entitlement level in bytes
621 * For use by devices to request a change to their entitlement at runtime or
622 * through sysfs. The desired entitlement level is changed and a balancing
623 * of system resources is scheduled to run in the future.
625 void vio_cmo_set_dev_desired(struct vio_dev
*viodev
, size_t desired
)
628 struct vio_cmo_dev_entry
*dev_ent
;
631 if (!firmware_has_feature(FW_FEATURE_CMO
))
634 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
635 if (desired
< VIO_CMO_MIN_ENT
)
636 desired
= VIO_CMO_MIN_ENT
;
639 * Changes will not be made for devices not in the device list.
640 * If it is not in the device list, then no driver is loaded
641 * for the device and it can not receive entitlement.
643 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
)
644 if (viodev
== dev_ent
->viodev
) {
649 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
653 /* Increase/decrease in desired device entitlement */
654 if (desired
>= viodev
->cmo
.desired
) {
655 /* Just bump the bus and device values prior to a balance*/
656 vio_cmo
.desired
+= desired
- viodev
->cmo
.desired
;
657 viodev
->cmo
.desired
= desired
;
659 /* Decrease bus and device values for desired entitlement */
660 vio_cmo
.desired
-= viodev
->cmo
.desired
- desired
;
661 viodev
->cmo
.desired
= desired
;
663 * If less entitlement is desired than current entitlement, move
664 * any reserve memory in the change region to the excess pool.
666 if (viodev
->cmo
.entitled
> desired
) {
667 vio_cmo
.reserve
.size
-= viodev
->cmo
.entitled
- desired
;
668 vio_cmo
.excess
.size
+= viodev
->cmo
.entitled
- desired
;
670 * If entitlement moving from the reserve pool to the
671 * excess pool is currently unused, add to the excess
674 if (viodev
->cmo
.allocated
< viodev
->cmo
.entitled
)
675 vio_cmo
.excess
.free
+= viodev
->cmo
.entitled
-
676 max(viodev
->cmo
.allocated
, desired
);
677 viodev
->cmo
.entitled
= desired
;
680 schedule_delayed_work(&vio_cmo
.balance_q
, 0);
681 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
685 * vio_cmo_bus_probe - Handle CMO specific bus probe activities
687 * @viodev - Pointer to struct vio_dev for device
689 * Determine the devices IO memory entitlement needs, attempting
690 * to satisfy the system minimum entitlement at first and scheduling
691 * a balance operation to take care of the rest at a later time.
693 * Returns: 0 on success, -EINVAL when device doesn't support CMO, and
694 * -ENOMEM when entitlement is not available for device or
698 static int vio_cmo_bus_probe(struct vio_dev
*viodev
)
700 struct vio_cmo_dev_entry
*dev_ent
;
701 struct device
*dev
= &viodev
->dev
;
702 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
707 * Check to see that device has a DMA window and configure
708 * entitlement for the device.
710 if (of_get_property(viodev
->dev
.of_node
,
711 "ibm,my-dma-window", NULL
)) {
712 /* Check that the driver is CMO enabled and get desired DMA */
713 if (!viodrv
->get_desired_dma
) {
714 dev_err(dev
, "%s: device driver does not support CMO\n",
719 viodev
->cmo
.desired
= IOMMU_PAGE_ALIGN(viodrv
->get_desired_dma(viodev
));
720 if (viodev
->cmo
.desired
< VIO_CMO_MIN_ENT
)
721 viodev
->cmo
.desired
= VIO_CMO_MIN_ENT
;
722 size
= VIO_CMO_MIN_ENT
;
724 dev_ent
= kmalloc(sizeof(struct vio_cmo_dev_entry
),
729 dev_ent
->viodev
= viodev
;
730 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
731 list_add(&dev_ent
->list
, &vio_cmo
.device_list
);
733 viodev
->cmo
.desired
= 0;
735 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
739 * If the needs for vio_cmo.min have not changed since they
740 * were last set, the number of devices in the OF tree has
741 * been constant and the IO memory for this is already in
744 if (vio_cmo
.min
== ((vio_cmo_num_OF_devs() + 1) *
746 /* Updated desired entitlement if device requires it */
748 vio_cmo
.desired
+= (viodev
->cmo
.desired
-
753 tmp
= vio_cmo
.spare
+ vio_cmo
.excess
.free
;
755 dev_err(dev
, "%s: insufficient free "
756 "entitlement to add device. "
757 "Need %lu, have %lu\n", __func__
,
758 size
, (vio_cmo
.spare
+ tmp
));
759 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
763 /* Use excess pool first to fulfill request */
764 tmp
= min(size
, vio_cmo
.excess
.free
);
765 vio_cmo
.excess
.free
-= tmp
;
766 vio_cmo
.excess
.size
-= tmp
;
767 vio_cmo
.reserve
.size
+= tmp
;
769 /* Use spare if excess pool was insufficient */
770 vio_cmo
.spare
-= size
- tmp
;
772 /* Update bus accounting */
774 vio_cmo
.desired
+= viodev
->cmo
.desired
;
776 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
781 * vio_cmo_bus_remove - Handle CMO specific bus removal activities
783 * @viodev - Pointer to struct vio_dev for device
785 * Remove the device from the cmo device list. The minimum entitlement
786 * will be reserved for the device as long as it is in the system. The
787 * rest of the entitlement the device had been allocated will be returned
790 static void vio_cmo_bus_remove(struct vio_dev
*viodev
)
792 struct vio_cmo_dev_entry
*dev_ent
;
796 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
797 if (viodev
->cmo
.allocated
) {
798 dev_err(&viodev
->dev
, "%s: device had %lu bytes of IO "
799 "allocated after remove operation.\n",
800 __func__
, viodev
->cmo
.allocated
);
805 * Remove the device from the device list being maintained for
806 * CMO enabled devices.
808 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
)
809 if (viodev
== dev_ent
->viodev
) {
810 list_del(&dev_ent
->list
);
816 * Devices may not require any entitlement and they do not need
817 * to be processed. Otherwise, return the device's entitlement
820 if (viodev
->cmo
.entitled
) {
822 * This device has not yet left the OF tree, it's
823 * minimum entitlement remains in vio_cmo.min and
826 vio_cmo
.desired
-= (viodev
->cmo
.desired
- VIO_CMO_MIN_ENT
);
829 * Save min allocation for device in reserve as long
830 * as it exists in OF tree as determined by later
833 viodev
->cmo
.entitled
-= VIO_CMO_MIN_ENT
;
835 /* Replenish spare from freed reserve pool */
836 if (viodev
->cmo
.entitled
&& (vio_cmo
.spare
< VIO_CMO_MIN_ENT
)) {
837 tmp
= min(viodev
->cmo
.entitled
, (VIO_CMO_MIN_ENT
-
839 vio_cmo
.spare
+= tmp
;
840 viodev
->cmo
.entitled
-= tmp
;
843 /* Remaining reserve goes to excess pool */
844 vio_cmo
.excess
.size
+= viodev
->cmo
.entitled
;
845 vio_cmo
.excess
.free
+= viodev
->cmo
.entitled
;
846 vio_cmo
.reserve
.size
-= viodev
->cmo
.entitled
;
849 * Until the device is removed it will keep a
850 * minimum entitlement; this will guarantee that
851 * a module unload/load will result in a success.
853 viodev
->cmo
.entitled
= VIO_CMO_MIN_ENT
;
854 viodev
->cmo
.desired
= VIO_CMO_MIN_ENT
;
855 atomic_set(&viodev
->cmo
.allocs_failed
, 0);
858 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
861 static void vio_cmo_set_dma_ops(struct vio_dev
*viodev
)
863 vio_dma_mapping_ops
.dma_supported
= dma_iommu_ops
.dma_supported
;
864 viodev
->dev
.archdata
.dma_ops
= &vio_dma_mapping_ops
;
868 * vio_cmo_bus_init - CMO entitlement initialization at bus init time
870 * Set up the reserve and excess entitlement pools based on available
871 * system entitlement and the number of devices in the OF tree that
872 * require entitlement in the reserve pool.
874 static void vio_cmo_bus_init(void)
876 struct hvcall_mpp_data mpp_data
;
879 memset(&vio_cmo
, 0, sizeof(struct vio_cmo
));
880 spin_lock_init(&vio_cmo
.lock
);
881 INIT_LIST_HEAD(&vio_cmo
.device_list
);
882 INIT_DELAYED_WORK(&vio_cmo
.balance_q
, vio_cmo_balance
);
884 /* Get current system entitlement */
885 err
= h_get_mpp(&mpp_data
);
888 * On failure, continue with entitlement set to 0, will panic()
889 * later when spare is reserved.
891 if (err
!= H_SUCCESS
) {
892 printk(KERN_ERR
"%s: unable to determine system IO "\
893 "entitlement. (%d)\n", __func__
, err
);
894 vio_cmo
.entitled
= 0;
896 vio_cmo
.entitled
= mpp_data
.entitled_mem
;
899 /* Set reservation and check against entitlement */
900 vio_cmo
.spare
= VIO_CMO_MIN_ENT
;
901 vio_cmo
.reserve
.size
= vio_cmo
.spare
;
902 vio_cmo
.reserve
.size
+= (vio_cmo_num_OF_devs() *
904 if (vio_cmo
.reserve
.size
> vio_cmo
.entitled
) {
905 printk(KERN_ERR
"%s: insufficient system entitlement\n",
907 panic("%s: Insufficient system entitlement", __func__
);
910 /* Set the remaining accounting variables */
911 vio_cmo
.excess
.size
= vio_cmo
.entitled
- vio_cmo
.reserve
.size
;
912 vio_cmo
.excess
.free
= vio_cmo
.excess
.size
;
913 vio_cmo
.min
= vio_cmo
.reserve
.size
;
914 vio_cmo
.desired
= vio_cmo
.reserve
.size
;
917 /* sysfs device functions and data structures for CMO */
919 #define viodev_cmo_rd_attr(name) \
920 static ssize_t viodev_cmo_##name##_show(struct device *dev, \
921 struct device_attribute *attr, \
924 return sprintf(buf, "%lu\n", to_vio_dev(dev)->cmo.name); \
927 static ssize_t
viodev_cmo_allocs_failed_show(struct device
*dev
,
928 struct device_attribute
*attr
, char *buf
)
930 struct vio_dev
*viodev
= to_vio_dev(dev
);
931 return sprintf(buf
, "%d\n", atomic_read(&viodev
->cmo
.allocs_failed
));
934 static ssize_t
viodev_cmo_allocs_failed_reset(struct device
*dev
,
935 struct device_attribute
*attr
, const char *buf
, size_t count
)
937 struct vio_dev
*viodev
= to_vio_dev(dev
);
938 atomic_set(&viodev
->cmo
.allocs_failed
, 0);
942 static ssize_t
viodev_cmo_desired_set(struct device
*dev
,
943 struct device_attribute
*attr
, const char *buf
, size_t count
)
945 struct vio_dev
*viodev
= to_vio_dev(dev
);
949 ret
= strict_strtoul(buf
, 10, &new_desired
);
953 vio_cmo_set_dev_desired(viodev
, new_desired
);
957 viodev_cmo_rd_attr(desired
);
958 viodev_cmo_rd_attr(entitled
);
959 viodev_cmo_rd_attr(allocated
);
961 static ssize_t
name_show(struct device
*, struct device_attribute
*, char *);
962 static ssize_t
devspec_show(struct device
*, struct device_attribute
*, char *);
963 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
,
965 static struct device_attribute vio_cmo_dev_attrs
[] = {
969 __ATTR(cmo_desired
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
970 viodev_cmo_desired_show
, viodev_cmo_desired_set
),
971 __ATTR(cmo_entitled
, S_IRUGO
, viodev_cmo_entitled_show
, NULL
),
972 __ATTR(cmo_allocated
, S_IRUGO
, viodev_cmo_allocated_show
, NULL
),
973 __ATTR(cmo_allocs_failed
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
974 viodev_cmo_allocs_failed_show
, viodev_cmo_allocs_failed_reset
),
978 /* sysfs bus functions and data structures for CMO */
980 #define viobus_cmo_rd_attr(name) \
982 viobus_cmo_##name##_show(struct bus_type *bt, char *buf) \
984 return sprintf(buf, "%lu\n", vio_cmo.name); \
987 #define viobus_cmo_pool_rd_attr(name, var) \
989 viobus_cmo_##name##_pool_show_##var(struct bus_type *bt, char *buf) \
991 return sprintf(buf, "%lu\n", vio_cmo.name.var); \
994 static ssize_t
viobus_cmo_high_reset(struct bus_type
*bt
, const char *buf
,
999 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
1000 vio_cmo
.high
= vio_cmo
.curr
;
1001 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
1006 viobus_cmo_rd_attr(entitled
);
1007 viobus_cmo_pool_rd_attr(reserve
, size
);
1008 viobus_cmo_pool_rd_attr(excess
, size
);
1009 viobus_cmo_pool_rd_attr(excess
, free
);
1010 viobus_cmo_rd_attr(spare
);
1011 viobus_cmo_rd_attr(min
);
1012 viobus_cmo_rd_attr(desired
);
1013 viobus_cmo_rd_attr(curr
);
1014 viobus_cmo_rd_attr(high
);
1016 static struct bus_attribute vio_cmo_bus_attrs
[] = {
1017 __ATTR(cmo_entitled
, S_IRUGO
, viobus_cmo_entitled_show
, NULL
),
1018 __ATTR(cmo_reserve_size
, S_IRUGO
, viobus_cmo_reserve_pool_show_size
, NULL
),
1019 __ATTR(cmo_excess_size
, S_IRUGO
, viobus_cmo_excess_pool_show_size
, NULL
),
1020 __ATTR(cmo_excess_free
, S_IRUGO
, viobus_cmo_excess_pool_show_free
, NULL
),
1021 __ATTR(cmo_spare
, S_IRUGO
, viobus_cmo_spare_show
, NULL
),
1022 __ATTR(cmo_min
, S_IRUGO
, viobus_cmo_min_show
, NULL
),
1023 __ATTR(cmo_desired
, S_IRUGO
, viobus_cmo_desired_show
, NULL
),
1024 __ATTR(cmo_curr
, S_IRUGO
, viobus_cmo_curr_show
, NULL
),
1025 __ATTR(cmo_high
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
1026 viobus_cmo_high_show
, viobus_cmo_high_reset
),
1030 static void vio_cmo_sysfs_init(void)
1032 vio_bus_type
.dev_attrs
= vio_cmo_dev_attrs
;
1033 vio_bus_type
.bus_attrs
= vio_cmo_bus_attrs
;
1035 #else /* CONFIG_PPC_SMLPAR */
1036 /* Dummy functions for iSeries platform */
1037 int vio_cmo_entitlement_update(size_t new_entitlement
) { return 0; }
1038 void vio_cmo_set_dev_desired(struct vio_dev
*viodev
, size_t desired
) {}
1039 static int vio_cmo_bus_probe(struct vio_dev
*viodev
) { return 0; }
1040 static void vio_cmo_bus_remove(struct vio_dev
*viodev
) {}
1041 static void vio_cmo_set_dma_ops(struct vio_dev
*viodev
) {}
1042 static void vio_cmo_bus_init(void) {}
1043 static void vio_cmo_sysfs_init(void) { }
1044 #endif /* CONFIG_PPC_SMLPAR */
1045 EXPORT_SYMBOL(vio_cmo_entitlement_update
);
1046 EXPORT_SYMBOL(vio_cmo_set_dev_desired
);
1048 static struct iommu_table
*vio_build_iommu_table(struct vio_dev
*dev
)
1050 const unsigned char *dma_window
;
1051 struct iommu_table
*tbl
;
1052 unsigned long offset
, size
;
1054 if (firmware_has_feature(FW_FEATURE_ISERIES
))
1055 return vio_build_iommu_table_iseries(dev
);
1057 dma_window
= of_get_property(dev
->dev
.of_node
,
1058 "ibm,my-dma-window", NULL
);
1062 tbl
= kmalloc(sizeof(*tbl
), GFP_KERNEL
);
1066 of_parse_dma_window(dev
->dev
.of_node
, dma_window
,
1067 &tbl
->it_index
, &offset
, &size
);
1069 /* TCE table size - measured in tce entries */
1070 tbl
->it_size
= size
>> IOMMU_PAGE_SHIFT
;
1071 /* offset for VIO should always be 0 */
1072 tbl
->it_offset
= offset
>> IOMMU_PAGE_SHIFT
;
1074 tbl
->it_type
= TCE_VB
;
1076 return iommu_init_table(tbl
, -1);
1080 * vio_match_device: - Tell if a VIO device has a matching
1081 * VIO device id structure.
1082 * @ids: array of VIO device id structures to search in
1083 * @dev: the VIO device structure to match against
1085 * Used by a driver to check whether a VIO device present in the
1086 * system is in its list of supported devices. Returns the matching
1087 * vio_device_id structure or NULL if there is no match.
1089 static const struct vio_device_id
*vio_match_device(
1090 const struct vio_device_id
*ids
, const struct vio_dev
*dev
)
1092 while (ids
->type
[0] != '\0') {
1093 if ((strncmp(dev
->type
, ids
->type
, strlen(ids
->type
)) == 0) &&
1094 of_device_is_compatible(dev
->dev
.of_node
,
1103 * Convert from struct device to struct vio_dev and pass to driver.
1104 * dev->driver has already been set by generic code because vio_bus_match
1107 static int vio_bus_probe(struct device
*dev
)
1109 struct vio_dev
*viodev
= to_vio_dev(dev
);
1110 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
1111 const struct vio_device_id
*id
;
1112 int error
= -ENODEV
;
1117 id
= vio_match_device(viodrv
->id_table
, viodev
);
1119 memset(&viodev
->cmo
, 0, sizeof(viodev
->cmo
));
1120 if (firmware_has_feature(FW_FEATURE_CMO
)) {
1121 error
= vio_cmo_bus_probe(viodev
);
1125 error
= viodrv
->probe(viodev
, id
);
1126 if (error
&& firmware_has_feature(FW_FEATURE_CMO
))
1127 vio_cmo_bus_remove(viodev
);
1133 /* convert from struct device to struct vio_dev and pass to driver. */
1134 static int vio_bus_remove(struct device
*dev
)
1136 struct vio_dev
*viodev
= to_vio_dev(dev
);
1137 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
1138 struct device
*devptr
;
1142 * Hold a reference to the device after the remove function is called
1143 * to allow for CMO accounting cleanup for the device.
1145 devptr
= get_device(dev
);
1148 ret
= viodrv
->remove(viodev
);
1150 if (!ret
&& firmware_has_feature(FW_FEATURE_CMO
))
1151 vio_cmo_bus_remove(viodev
);
1158 * vio_register_driver: - Register a new vio driver
1159 * @drv: The vio_driver structure to be registered.
1161 int vio_register_driver(struct vio_driver
*viodrv
)
1163 printk(KERN_DEBUG
"%s: driver %s registering\n", __func__
,
1164 viodrv
->driver
.name
);
1166 /* fill in 'struct driver' fields */
1167 viodrv
->driver
.bus
= &vio_bus_type
;
1169 return driver_register(&viodrv
->driver
);
1171 EXPORT_SYMBOL(vio_register_driver
);
1174 * vio_unregister_driver - Remove registration of vio driver.
1175 * @driver: The vio_driver struct to be removed form registration
1177 void vio_unregister_driver(struct vio_driver
*viodrv
)
1179 driver_unregister(&viodrv
->driver
);
1181 EXPORT_SYMBOL(vio_unregister_driver
);
1183 /* vio_dev refcount hit 0 */
1184 static void __devinit
vio_dev_release(struct device
*dev
)
1186 /* XXX should free TCE table */
1187 of_node_put(dev
->of_node
);
1188 kfree(to_vio_dev(dev
));
1192 * vio_register_device_node: - Register a new vio device.
1193 * @of_node: The OF node for this device.
1195 * Creates and initializes a vio_dev structure from the data in
1196 * of_node and adds it to the list of virtual devices.
1197 * Returns a pointer to the created vio_dev or NULL if node has
1198 * NULL device_type or compatible fields.
1200 struct vio_dev
*vio_register_device_node(struct device_node
*of_node
)
1202 struct vio_dev
*viodev
;
1203 const unsigned int *unit_address
;
1205 /* we need the 'device_type' property, in order to match with drivers */
1206 if (of_node
->type
== NULL
) {
1207 printk(KERN_WARNING
"%s: node %s missing 'device_type'\n",
1209 of_node
->name
? of_node
->name
: "<unknown>");
1213 unit_address
= of_get_property(of_node
, "reg", NULL
);
1214 if (unit_address
== NULL
) {
1215 printk(KERN_WARNING
"%s: node %s missing 'reg'\n",
1217 of_node
->name
? of_node
->name
: "<unknown>");
1221 /* allocate a vio_dev for this node */
1222 viodev
= kzalloc(sizeof(struct vio_dev
), GFP_KERNEL
);
1226 viodev
->irq
= irq_of_parse_and_map(of_node
, 0);
1228 dev_set_name(&viodev
->dev
, "%x", *unit_address
);
1229 viodev
->name
= of_node
->name
;
1230 viodev
->type
= of_node
->type
;
1231 viodev
->unit_address
= *unit_address
;
1232 if (firmware_has_feature(FW_FEATURE_ISERIES
)) {
1233 unit_address
= of_get_property(of_node
,
1234 "linux,unit_address", NULL
);
1235 if (unit_address
!= NULL
)
1236 viodev
->unit_address
= *unit_address
;
1238 viodev
->dev
.of_node
= of_node_get(of_node
);
1240 if (firmware_has_feature(FW_FEATURE_CMO
))
1241 vio_cmo_set_dma_ops(viodev
);
1243 viodev
->dev
.archdata
.dma_ops
= &dma_iommu_ops
;
1244 set_iommu_table_base(&viodev
->dev
, vio_build_iommu_table(viodev
));
1245 set_dev_node(&viodev
->dev
, of_node_to_nid(of_node
));
1247 /* init generic 'struct device' fields: */
1248 viodev
->dev
.parent
= &vio_bus_device
.dev
;
1249 viodev
->dev
.bus
= &vio_bus_type
;
1250 viodev
->dev
.release
= vio_dev_release
;
1252 /* register with generic device framework */
1253 if (device_register(&viodev
->dev
)) {
1254 printk(KERN_ERR
"%s: failed to register device %s\n",
1255 __func__
, dev_name(&viodev
->dev
));
1256 /* XXX free TCE table */
1263 EXPORT_SYMBOL(vio_register_device_node
);
1266 * vio_bus_init: - Initialize the virtual IO bus
1268 static int __init
vio_bus_init(void)
1271 struct device_node
*node_vroot
;
1273 if (firmware_has_feature(FW_FEATURE_CMO
))
1274 vio_cmo_sysfs_init();
1276 err
= bus_register(&vio_bus_type
);
1278 printk(KERN_ERR
"failed to register VIO bus\n");
1283 * The fake parent of all vio devices, just to give us
1286 err
= device_register(&vio_bus_device
.dev
);
1288 printk(KERN_WARNING
"%s: device_register returned %i\n",
1293 if (firmware_has_feature(FW_FEATURE_CMO
))
1296 node_vroot
= of_find_node_by_name(NULL
, "vdevice");
1298 struct device_node
*of_node
;
1301 * Create struct vio_devices for each virtual device in
1302 * the device tree. Drivers will associate with them later.
1304 for (of_node
= node_vroot
->child
; of_node
!= NULL
;
1305 of_node
= of_node
->sibling
)
1306 vio_register_device_node(of_node
);
1307 of_node_put(node_vroot
);
1312 __initcall(vio_bus_init
);
1314 static ssize_t
name_show(struct device
*dev
,
1315 struct device_attribute
*attr
, char *buf
)
1317 return sprintf(buf
, "%s\n", to_vio_dev(dev
)->name
);
1320 static ssize_t
devspec_show(struct device
*dev
,
1321 struct device_attribute
*attr
, char *buf
)
1323 struct device_node
*of_node
= dev
->of_node
;
1325 return sprintf(buf
, "%s\n", of_node
? of_node
->full_name
: "none");
1328 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
,
1331 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1332 struct device_node
*dn
;
1338 cp
= of_get_property(dn
, "compatible", NULL
);
1342 return sprintf(buf
, "vio:T%sS%s\n", vio_dev
->type
, cp
);
1345 static struct device_attribute vio_dev_attrs
[] = {
1348 __ATTR_RO(modalias
),
1352 void __devinit
vio_unregister_device(struct vio_dev
*viodev
)
1354 device_unregister(&viodev
->dev
);
1356 EXPORT_SYMBOL(vio_unregister_device
);
1358 static int vio_bus_match(struct device
*dev
, struct device_driver
*drv
)
1360 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1361 struct vio_driver
*vio_drv
= to_vio_driver(drv
);
1362 const struct vio_device_id
*ids
= vio_drv
->id_table
;
1364 return (ids
!= NULL
) && (vio_match_device(ids
, vio_dev
) != NULL
);
1367 static int vio_hotplug(struct device
*dev
, struct kobj_uevent_env
*env
)
1369 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1370 struct device_node
*dn
;
1376 cp
= of_get_property(dn
, "compatible", NULL
);
1380 add_uevent_var(env
, "MODALIAS=vio:T%sS%s", vio_dev
->type
, cp
);
1384 static struct bus_type vio_bus_type
= {
1386 .dev_attrs
= vio_dev_attrs
,
1387 .uevent
= vio_hotplug
,
1388 .match
= vio_bus_match
,
1389 .probe
= vio_bus_probe
,
1390 .remove
= vio_bus_remove
,
1391 .pm
= GENERIC_SUBSYS_PM_OPS
,
1395 * vio_get_attribute: - get attribute for virtual device
1396 * @vdev: The vio device to get property.
1397 * @which: The property/attribute to be extracted.
1398 * @length: Pointer to length of returned data size (unused if NULL).
1400 * Calls prom.c's of_get_property() to return the value of the
1401 * attribute specified by @which
1403 const void *vio_get_attribute(struct vio_dev
*vdev
, char *which
, int *length
)
1405 return of_get_property(vdev
->dev
.of_node
, which
, length
);
1407 EXPORT_SYMBOL(vio_get_attribute
);
1409 #ifdef CONFIG_PPC_PSERIES
1410 /* vio_find_name() - internal because only vio.c knows how we formatted the
1413 static struct vio_dev
*vio_find_name(const char *name
)
1415 struct device
*found
;
1417 found
= bus_find_device_by_name(&vio_bus_type
, NULL
, name
);
1421 return to_vio_dev(found
);
1425 * vio_find_node - find an already-registered vio_dev
1426 * @vnode: device_node of the virtual device we're looking for
1428 struct vio_dev
*vio_find_node(struct device_node
*vnode
)
1430 const uint32_t *unit_address
;
1433 /* construct the kobject name from the device node */
1434 unit_address
= of_get_property(vnode
, "reg", NULL
);
1437 snprintf(kobj_name
, sizeof(kobj_name
), "%x", *unit_address
);
1439 return vio_find_name(kobj_name
);
1441 EXPORT_SYMBOL(vio_find_node
);
1443 int vio_enable_interrupts(struct vio_dev
*dev
)
1445 int rc
= h_vio_signal(dev
->unit_address
, VIO_IRQ_ENABLE
);
1446 if (rc
!= H_SUCCESS
)
1447 printk(KERN_ERR
"vio: Error 0x%x enabling interrupts\n", rc
);
1450 EXPORT_SYMBOL(vio_enable_interrupts
);
1452 int vio_disable_interrupts(struct vio_dev
*dev
)
1454 int rc
= h_vio_signal(dev
->unit_address
, VIO_IRQ_DISABLE
);
1455 if (rc
!= H_SUCCESS
)
1456 printk(KERN_ERR
"vio: Error 0x%x disabling interrupts\n", rc
);
1459 EXPORT_SYMBOL(vio_disable_interrupts
);
1460 #endif /* CONFIG_PPC_PSERIES */