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/cpu.h>
18 #include <linux/types.h>
19 #include <linux/delay.h>
20 #include <linux/stat.h>
21 #include <linux/device.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/console.h>
25 #include <linux/export.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/kobject.h>
30 #include <asm/iommu.h>
34 #include <asm/firmware.h>
37 #include <asm/hvcall.h>
39 static struct vio_dev vio_bus_device
= { /* fake "parent" device */
42 .dev
.init_name
= "vio",
43 .dev
.bus
= &vio_bus_type
,
46 #ifdef CONFIG_PPC_SMLPAR
48 * vio_cmo_pool - A pool of IO memory for CMO use
50 * @size: The size of the pool in bytes
51 * @free: The amount of free memory in the pool
58 /* How many ms to delay queued balance work */
59 #define VIO_CMO_BALANCE_DELAY 100
61 /* Portion out IO memory to CMO devices by this chunk size */
62 #define VIO_CMO_BALANCE_CHUNK 131072
65 * vio_cmo_dev_entry - A device that is CMO-enabled and requires entitlement
67 * @vio_dev: struct vio_dev pointer
68 * @list: pointer to other devices on bus that are being tracked
70 struct vio_cmo_dev_entry
{
71 struct vio_dev
*viodev
;
72 struct list_head list
;
76 * vio_cmo - VIO bus accounting structure for CMO entitlement
78 * @lock: spinlock for entire structure
79 * @balance_q: work queue for balancing system entitlement
80 * @device_list: list of CMO-enabled devices requiring entitlement
81 * @entitled: total system entitlement in bytes
82 * @reserve: pool of memory from which devices reserve entitlement, incl. spare
83 * @excess: pool of excess entitlement not needed for device reserves or spare
84 * @spare: IO memory for device hotplug functionality
85 * @min: minimum necessary for system operation
86 * @desired: desired memory for system operation
87 * @curr: bytes currently allocated
88 * @high: high water mark for IO data usage
92 struct delayed_work balance_q
;
93 struct list_head device_list
;
95 struct vio_cmo_pool reserve
;
96 struct vio_cmo_pool excess
;
105 * vio_cmo_OF_devices - Count the number of OF devices that have DMA windows
107 static int vio_cmo_num_OF_devs(void)
109 struct device_node
*node_vroot
;
113 * Count the number of vdevice entries with an
114 * ibm,my-dma-window OF property
116 node_vroot
= of_find_node_by_name(NULL
, "vdevice");
118 struct device_node
*of_node
;
119 struct property
*prop
;
121 for_each_child_of_node(node_vroot
, of_node
) {
122 prop
= of_find_property(of_node
, "ibm,my-dma-window",
128 of_node_put(node_vroot
);
133 * vio_cmo_alloc - allocate IO memory for CMO-enable devices
135 * @viodev: VIO device requesting IO memory
136 * @size: size of allocation requested
138 * Allocations come from memory reserved for the devices and any excess
139 * IO memory available to all devices. The spare pool used to service
140 * hotplug must be equal to %VIO_CMO_MIN_ENT for the excess pool to be
144 * 0 for successful allocation and -ENOMEM for a failure
146 static inline int vio_cmo_alloc(struct vio_dev
*viodev
, size_t size
)
149 size_t reserve_free
= 0;
150 size_t excess_free
= 0;
153 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
155 /* Determine the amount of free entitlement available in reserve */
156 if (viodev
->cmo
.entitled
> viodev
->cmo
.allocated
)
157 reserve_free
= viodev
->cmo
.entitled
- viodev
->cmo
.allocated
;
159 /* If spare is not fulfilled, the excess pool can not be used. */
160 if (vio_cmo
.spare
>= VIO_CMO_MIN_ENT
)
161 excess_free
= vio_cmo
.excess
.free
;
163 /* The request can be satisfied */
164 if ((reserve_free
+ excess_free
) >= size
) {
165 vio_cmo
.curr
+= size
;
166 if (vio_cmo
.curr
> vio_cmo
.high
)
167 vio_cmo
.high
= vio_cmo
.curr
;
168 viodev
->cmo
.allocated
+= size
;
169 size
-= min(reserve_free
, size
);
170 vio_cmo
.excess
.free
-= size
;
174 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
179 * vio_cmo_dealloc - deallocate IO memory from CMO-enable devices
180 * @viodev: VIO device freeing IO memory
181 * @size: size of deallocation
183 * IO memory is freed by the device back to the correct memory pools.
184 * The spare pool is replenished first from either memory pool, then
185 * the reserve pool is used to reduce device entitlement, the excess
186 * pool is used to increase the reserve pool toward the desired entitlement
187 * target, and then the remaining memory is returned to the pools.
190 static inline void vio_cmo_dealloc(struct vio_dev
*viodev
, size_t size
)
193 size_t spare_needed
= 0;
194 size_t excess_freed
= 0;
195 size_t reserve_freed
= size
;
199 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
200 vio_cmo
.curr
-= size
;
202 /* Amount of memory freed from the excess pool */
203 if (viodev
->cmo
.allocated
> viodev
->cmo
.entitled
) {
204 excess_freed
= min(reserve_freed
, (viodev
->cmo
.allocated
-
205 viodev
->cmo
.entitled
));
206 reserve_freed
-= excess_freed
;
209 /* Remove allocation from device */
210 viodev
->cmo
.allocated
-= (reserve_freed
+ excess_freed
);
212 /* Spare is a subset of the reserve pool, replenish it first. */
213 spare_needed
= VIO_CMO_MIN_ENT
- vio_cmo
.spare
;
216 * Replenish the spare in the reserve pool from the excess pool.
217 * This moves entitlement into the reserve pool.
219 if (spare_needed
&& excess_freed
) {
220 tmp
= min(excess_freed
, spare_needed
);
221 vio_cmo
.excess
.size
-= tmp
;
222 vio_cmo
.reserve
.size
+= tmp
;
223 vio_cmo
.spare
+= tmp
;
230 * Replenish the spare in the reserve pool from the reserve pool.
231 * This removes entitlement from the device down to VIO_CMO_MIN_ENT,
232 * if needed, and gives it to the spare pool. The amount of used
233 * memory in this pool does not change.
235 if (spare_needed
&& reserve_freed
) {
236 tmp
= min3(spare_needed
, reserve_freed
, (viodev
->cmo
.entitled
- VIO_CMO_MIN_ENT
));
238 vio_cmo
.spare
+= tmp
;
239 viodev
->cmo
.entitled
-= tmp
;
240 reserve_freed
-= tmp
;
246 * Increase the reserve pool until the desired allocation is met.
247 * Move an allocation freed from the excess pool into the reserve
248 * pool and schedule a balance operation.
250 if (excess_freed
&& (vio_cmo
.desired
> vio_cmo
.reserve
.size
)) {
251 tmp
= min(excess_freed
, (vio_cmo
.desired
- vio_cmo
.reserve
.size
));
253 vio_cmo
.excess
.size
-= tmp
;
254 vio_cmo
.reserve
.size
+= tmp
;
259 /* Return memory from the excess pool to that pool */
261 vio_cmo
.excess
.free
+= excess_freed
;
264 schedule_delayed_work(&vio_cmo
.balance_q
, VIO_CMO_BALANCE_DELAY
);
265 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
269 * vio_cmo_entitlement_update - Manage system entitlement changes
271 * @new_entitlement: new system entitlement to attempt to accommodate
273 * Increases in entitlement will be used to fulfill the spare entitlement
274 * and the rest is given to the excess pool. Decreases, if they are
275 * possible, come from the excess pool and from unused device entitlement
277 * Returns: 0 on success, -ENOMEM when change can not be made
279 int vio_cmo_entitlement_update(size_t new_entitlement
)
281 struct vio_dev
*viodev
;
282 struct vio_cmo_dev_entry
*dev_ent
;
284 size_t avail
, delta
, tmp
;
286 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
288 /* Entitlement increases */
289 if (new_entitlement
> vio_cmo
.entitled
) {
290 delta
= new_entitlement
- vio_cmo
.entitled
;
292 /* Fulfill spare allocation */
293 if (vio_cmo
.spare
< VIO_CMO_MIN_ENT
) {
294 tmp
= min(delta
, (VIO_CMO_MIN_ENT
- vio_cmo
.spare
));
295 vio_cmo
.spare
+= tmp
;
296 vio_cmo
.reserve
.size
+= tmp
;
300 /* Remaining new allocation goes to the excess pool */
301 vio_cmo
.entitled
+= delta
;
302 vio_cmo
.excess
.size
+= delta
;
303 vio_cmo
.excess
.free
+= delta
;
308 /* Entitlement decreases */
309 delta
= vio_cmo
.entitled
- new_entitlement
;
310 avail
= vio_cmo
.excess
.free
;
313 * Need to check how much unused entitlement each device can
314 * sacrifice to fulfill entitlement change.
316 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
320 viodev
= dev_ent
->viodev
;
321 if ((viodev
->cmo
.entitled
> viodev
->cmo
.allocated
) &&
322 (viodev
->cmo
.entitled
> VIO_CMO_MIN_ENT
))
323 avail
+= viodev
->cmo
.entitled
-
324 max_t(size_t, viodev
->cmo
.allocated
,
328 if (delta
<= avail
) {
329 vio_cmo
.entitled
-= delta
;
331 /* Take entitlement from the excess pool first */
332 tmp
= min(vio_cmo
.excess
.free
, delta
);
333 vio_cmo
.excess
.size
-= tmp
;
334 vio_cmo
.excess
.free
-= tmp
;
338 * Remove all but VIO_CMO_MIN_ENT bytes from devices
339 * until entitlement change is served
341 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
345 viodev
= dev_ent
->viodev
;
347 if ((viodev
->cmo
.entitled
> viodev
->cmo
.allocated
) &&
348 (viodev
->cmo
.entitled
> VIO_CMO_MIN_ENT
))
349 tmp
= viodev
->cmo
.entitled
-
350 max_t(size_t, viodev
->cmo
.allocated
,
352 viodev
->cmo
.entitled
-= min(tmp
, delta
);
353 delta
-= min(tmp
, delta
);
356 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
361 schedule_delayed_work(&vio_cmo
.balance_q
, 0);
362 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
367 * vio_cmo_balance - Balance entitlement among devices
369 * @work: work queue structure for this operation
371 * Any system entitlement above the minimum needed for devices, or
372 * already allocated to devices, can be distributed to the devices.
373 * The list of devices is iterated through to recalculate the desired
374 * entitlement level and to determine how much entitlement above the
375 * minimum entitlement is allocated to devices.
377 * Small chunks of the available entitlement are given to devices until
378 * their requirements are fulfilled or there is no entitlement left to give.
379 * Upon completion sizes of the reserve and excess pools are calculated.
381 * The system minimum entitlement level is also recalculated here.
382 * Entitlement will be reserved for devices even after vio_bus_remove to
383 * accommodate reloading the driver. The OF tree is walked to count the
384 * number of devices present and this will remove entitlement for devices
385 * that have actually left the system after having vio_bus_remove called.
387 static void vio_cmo_balance(struct work_struct
*work
)
390 struct vio_dev
*viodev
;
391 struct vio_cmo_dev_entry
*dev_ent
;
393 size_t avail
= 0, level
, chunk
, need
;
394 int devcount
= 0, fulfilled
;
396 cmo
= container_of(work
, struct vio_cmo
, balance_q
.work
);
398 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
400 /* Calculate minimum entitlement and fulfill spare */
401 cmo
->min
= vio_cmo_num_OF_devs() * VIO_CMO_MIN_ENT
;
402 BUG_ON(cmo
->min
> cmo
->entitled
);
403 cmo
->spare
= min_t(size_t, VIO_CMO_MIN_ENT
, (cmo
->entitled
- cmo
->min
));
404 cmo
->min
+= cmo
->spare
;
405 cmo
->desired
= cmo
->min
;
408 * Determine how much entitlement is available and reset device
411 avail
= cmo
->entitled
- cmo
->spare
;
412 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
413 viodev
= dev_ent
->viodev
;
415 viodev
->cmo
.entitled
= VIO_CMO_MIN_ENT
;
416 cmo
->desired
+= (viodev
->cmo
.desired
- VIO_CMO_MIN_ENT
);
417 avail
-= max_t(size_t, viodev
->cmo
.allocated
, VIO_CMO_MIN_ENT
);
421 * Having provided each device with the minimum entitlement, loop
422 * over the devices portioning out the remaining entitlement
423 * until there is nothing left.
425 level
= VIO_CMO_MIN_ENT
;
428 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
429 viodev
= dev_ent
->viodev
;
431 if (viodev
->cmo
.desired
<= level
) {
437 * Give the device up to VIO_CMO_BALANCE_CHUNK
438 * bytes of entitlement, but do not exceed the
439 * desired level of entitlement for the device.
441 chunk
= min_t(size_t, avail
, VIO_CMO_BALANCE_CHUNK
);
442 chunk
= min(chunk
, (viodev
->cmo
.desired
-
443 viodev
->cmo
.entitled
));
444 viodev
->cmo
.entitled
+= chunk
;
447 * If the memory for this entitlement increase was
448 * already allocated to the device it does not come
449 * from the available pool being portioned out.
451 need
= max(viodev
->cmo
.allocated
, viodev
->cmo
.entitled
)-
452 max(viodev
->cmo
.allocated
, level
);
456 if (fulfilled
== devcount
)
458 level
+= VIO_CMO_BALANCE_CHUNK
;
461 /* Calculate new reserve and excess pool sizes */
462 cmo
->reserve
.size
= cmo
->min
;
463 cmo
->excess
.free
= 0;
464 cmo
->excess
.size
= 0;
466 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
) {
467 viodev
= dev_ent
->viodev
;
468 /* Calculated reserve size above the minimum entitlement */
469 if (viodev
->cmo
.entitled
)
470 cmo
->reserve
.size
+= (viodev
->cmo
.entitled
-
472 /* Calculated used excess entitlement */
473 if (viodev
->cmo
.allocated
> viodev
->cmo
.entitled
)
474 need
+= viodev
->cmo
.allocated
- viodev
->cmo
.entitled
;
476 cmo
->excess
.size
= cmo
->entitled
- cmo
->reserve
.size
;
477 cmo
->excess
.free
= cmo
->excess
.size
- need
;
479 cancel_delayed_work(to_delayed_work(work
));
480 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
483 static void *vio_dma_iommu_alloc_coherent(struct device
*dev
, size_t size
,
484 dma_addr_t
*dma_handle
, gfp_t flag
,
485 struct dma_attrs
*attrs
)
487 struct vio_dev
*viodev
= to_vio_dev(dev
);
490 if (vio_cmo_alloc(viodev
, roundup(size
, PAGE_SIZE
))) {
491 atomic_inc(&viodev
->cmo
.allocs_failed
);
495 ret
= dma_iommu_ops
.alloc(dev
, size
, dma_handle
, flag
, attrs
);
496 if (unlikely(ret
== NULL
)) {
497 vio_cmo_dealloc(viodev
, roundup(size
, PAGE_SIZE
));
498 atomic_inc(&viodev
->cmo
.allocs_failed
);
504 static void vio_dma_iommu_free_coherent(struct device
*dev
, size_t size
,
505 void *vaddr
, dma_addr_t dma_handle
,
506 struct dma_attrs
*attrs
)
508 struct vio_dev
*viodev
= to_vio_dev(dev
);
510 dma_iommu_ops
.free(dev
, size
, vaddr
, dma_handle
, attrs
);
512 vio_cmo_dealloc(viodev
, roundup(size
, PAGE_SIZE
));
515 static dma_addr_t
vio_dma_iommu_map_page(struct device
*dev
, struct page
*page
,
516 unsigned long offset
, size_t size
,
517 enum dma_data_direction direction
,
518 struct dma_attrs
*attrs
)
520 struct vio_dev
*viodev
= to_vio_dev(dev
);
521 dma_addr_t ret
= DMA_ERROR_CODE
;
523 if (vio_cmo_alloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
))) {
524 atomic_inc(&viodev
->cmo
.allocs_failed
);
528 ret
= dma_iommu_ops
.map_page(dev
, page
, offset
, size
, direction
, attrs
);
529 if (unlikely(dma_mapping_error(dev
, ret
))) {
530 vio_cmo_dealloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
));
531 atomic_inc(&viodev
->cmo
.allocs_failed
);
537 static void vio_dma_iommu_unmap_page(struct device
*dev
, dma_addr_t dma_handle
,
539 enum dma_data_direction direction
,
540 struct dma_attrs
*attrs
)
542 struct vio_dev
*viodev
= to_vio_dev(dev
);
544 dma_iommu_ops
.unmap_page(dev
, dma_handle
, size
, direction
, attrs
);
546 vio_cmo_dealloc(viodev
, roundup(size
, IOMMU_PAGE_SIZE
));
549 static int vio_dma_iommu_map_sg(struct device
*dev
, struct scatterlist
*sglist
,
550 int nelems
, enum dma_data_direction direction
,
551 struct dma_attrs
*attrs
)
553 struct vio_dev
*viodev
= to_vio_dev(dev
);
554 struct scatterlist
*sgl
;
556 size_t alloc_size
= 0;
558 for (sgl
= sglist
; count
< nelems
; count
++, sgl
++)
559 alloc_size
+= roundup(sgl
->length
, IOMMU_PAGE_SIZE
);
561 if (vio_cmo_alloc(viodev
, alloc_size
)) {
562 atomic_inc(&viodev
->cmo
.allocs_failed
);
566 ret
= dma_iommu_ops
.map_sg(dev
, sglist
, nelems
, direction
, attrs
);
568 if (unlikely(!ret
)) {
569 vio_cmo_dealloc(viodev
, alloc_size
);
570 atomic_inc(&viodev
->cmo
.allocs_failed
);
574 for (sgl
= sglist
, count
= 0; count
< ret
; count
++, sgl
++)
575 alloc_size
-= roundup(sgl
->dma_length
, IOMMU_PAGE_SIZE
);
577 vio_cmo_dealloc(viodev
, alloc_size
);
582 static void vio_dma_iommu_unmap_sg(struct device
*dev
,
583 struct scatterlist
*sglist
, int nelems
,
584 enum dma_data_direction direction
,
585 struct dma_attrs
*attrs
)
587 struct vio_dev
*viodev
= to_vio_dev(dev
);
588 struct scatterlist
*sgl
;
589 size_t alloc_size
= 0;
592 for (sgl
= sglist
; count
< nelems
; count
++, sgl
++)
593 alloc_size
+= roundup(sgl
->dma_length
, IOMMU_PAGE_SIZE
);
595 dma_iommu_ops
.unmap_sg(dev
, sglist
, nelems
, direction
, attrs
);
597 vio_cmo_dealloc(viodev
, alloc_size
);
600 static int vio_dma_iommu_dma_supported(struct device
*dev
, u64 mask
)
602 return dma_iommu_ops
.dma_supported(dev
, mask
);
605 static u64
vio_dma_get_required_mask(struct device
*dev
)
607 return dma_iommu_ops
.get_required_mask(dev
);
610 struct dma_map_ops vio_dma_mapping_ops
= {
611 .alloc
= vio_dma_iommu_alloc_coherent
,
612 .free
= vio_dma_iommu_free_coherent
,
613 .mmap
= dma_direct_mmap_coherent
,
614 .map_sg
= vio_dma_iommu_map_sg
,
615 .unmap_sg
= vio_dma_iommu_unmap_sg
,
616 .map_page
= vio_dma_iommu_map_page
,
617 .unmap_page
= vio_dma_iommu_unmap_page
,
618 .dma_supported
= vio_dma_iommu_dma_supported
,
619 .get_required_mask
= vio_dma_get_required_mask
,
623 * vio_cmo_set_dev_desired - Set desired entitlement for a device
625 * @viodev: struct vio_dev for device to alter
626 * @desired: new desired entitlement level in bytes
628 * For use by devices to request a change to their entitlement at runtime or
629 * through sysfs. The desired entitlement level is changed and a balancing
630 * of system resources is scheduled to run in the future.
632 void vio_cmo_set_dev_desired(struct vio_dev
*viodev
, size_t desired
)
635 struct vio_cmo_dev_entry
*dev_ent
;
638 if (!firmware_has_feature(FW_FEATURE_CMO
))
641 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
642 if (desired
< VIO_CMO_MIN_ENT
)
643 desired
= VIO_CMO_MIN_ENT
;
646 * Changes will not be made for devices not in the device list.
647 * If it is not in the device list, then no driver is loaded
648 * for the device and it can not receive entitlement.
650 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
)
651 if (viodev
== dev_ent
->viodev
) {
656 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
660 /* Increase/decrease in desired device entitlement */
661 if (desired
>= viodev
->cmo
.desired
) {
662 /* Just bump the bus and device values prior to a balance*/
663 vio_cmo
.desired
+= desired
- viodev
->cmo
.desired
;
664 viodev
->cmo
.desired
= desired
;
666 /* Decrease bus and device values for desired entitlement */
667 vio_cmo
.desired
-= viodev
->cmo
.desired
- desired
;
668 viodev
->cmo
.desired
= desired
;
670 * If less entitlement is desired than current entitlement, move
671 * any reserve memory in the change region to the excess pool.
673 if (viodev
->cmo
.entitled
> desired
) {
674 vio_cmo
.reserve
.size
-= viodev
->cmo
.entitled
- desired
;
675 vio_cmo
.excess
.size
+= viodev
->cmo
.entitled
- desired
;
677 * If entitlement moving from the reserve pool to the
678 * excess pool is currently unused, add to the excess
681 if (viodev
->cmo
.allocated
< viodev
->cmo
.entitled
)
682 vio_cmo
.excess
.free
+= viodev
->cmo
.entitled
-
683 max(viodev
->cmo
.allocated
, desired
);
684 viodev
->cmo
.entitled
= desired
;
687 schedule_delayed_work(&vio_cmo
.balance_q
, 0);
688 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
692 * vio_cmo_bus_probe - Handle CMO specific bus probe activities
694 * @viodev - Pointer to struct vio_dev for device
696 * Determine the devices IO memory entitlement needs, attempting
697 * to satisfy the system minimum entitlement at first and scheduling
698 * a balance operation to take care of the rest at a later time.
700 * Returns: 0 on success, -EINVAL when device doesn't support CMO, and
701 * -ENOMEM when entitlement is not available for device or
705 static int vio_cmo_bus_probe(struct vio_dev
*viodev
)
707 struct vio_cmo_dev_entry
*dev_ent
;
708 struct device
*dev
= &viodev
->dev
;
709 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
712 bool dma_capable
= false;
714 /* A device requires entitlement if it has a DMA window property */
715 switch (viodev
->family
) {
717 if (of_get_property(viodev
->dev
.of_node
,
718 "ibm,my-dma-window", NULL
))
725 dev_warn(dev
, "unknown device family: %d\n", viodev
->family
);
730 /* Configure entitlement for the device. */
732 /* Check that the driver is CMO enabled and get desired DMA */
733 if (!viodrv
->get_desired_dma
) {
734 dev_err(dev
, "%s: device driver does not support CMO\n",
739 viodev
->cmo
.desired
= IOMMU_PAGE_ALIGN(viodrv
->get_desired_dma(viodev
));
740 if (viodev
->cmo
.desired
< VIO_CMO_MIN_ENT
)
741 viodev
->cmo
.desired
= VIO_CMO_MIN_ENT
;
742 size
= VIO_CMO_MIN_ENT
;
744 dev_ent
= kmalloc(sizeof(struct vio_cmo_dev_entry
),
749 dev_ent
->viodev
= viodev
;
750 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
751 list_add(&dev_ent
->list
, &vio_cmo
.device_list
);
753 viodev
->cmo
.desired
= 0;
755 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
759 * If the needs for vio_cmo.min have not changed since they
760 * were last set, the number of devices in the OF tree has
761 * been constant and the IO memory for this is already in
764 if (vio_cmo
.min
== ((vio_cmo_num_OF_devs() + 1) *
766 /* Updated desired entitlement if device requires it */
768 vio_cmo
.desired
+= (viodev
->cmo
.desired
-
773 tmp
= vio_cmo
.spare
+ vio_cmo
.excess
.free
;
775 dev_err(dev
, "%s: insufficient free "
776 "entitlement to add device. "
777 "Need %lu, have %lu\n", __func__
,
778 size
, (vio_cmo
.spare
+ tmp
));
779 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
783 /* Use excess pool first to fulfill request */
784 tmp
= min(size
, vio_cmo
.excess
.free
);
785 vio_cmo
.excess
.free
-= tmp
;
786 vio_cmo
.excess
.size
-= tmp
;
787 vio_cmo
.reserve
.size
+= tmp
;
789 /* Use spare if excess pool was insufficient */
790 vio_cmo
.spare
-= size
- tmp
;
792 /* Update bus accounting */
794 vio_cmo
.desired
+= viodev
->cmo
.desired
;
796 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
801 * vio_cmo_bus_remove - Handle CMO specific bus removal activities
803 * @viodev - Pointer to struct vio_dev for device
805 * Remove the device from the cmo device list. The minimum entitlement
806 * will be reserved for the device as long as it is in the system. The
807 * rest of the entitlement the device had been allocated will be returned
810 static void vio_cmo_bus_remove(struct vio_dev
*viodev
)
812 struct vio_cmo_dev_entry
*dev_ent
;
816 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
817 if (viodev
->cmo
.allocated
) {
818 dev_err(&viodev
->dev
, "%s: device had %lu bytes of IO "
819 "allocated after remove operation.\n",
820 __func__
, viodev
->cmo
.allocated
);
825 * Remove the device from the device list being maintained for
826 * CMO enabled devices.
828 list_for_each_entry(dev_ent
, &vio_cmo
.device_list
, list
)
829 if (viodev
== dev_ent
->viodev
) {
830 list_del(&dev_ent
->list
);
836 * Devices may not require any entitlement and they do not need
837 * to be processed. Otherwise, return the device's entitlement
840 if (viodev
->cmo
.entitled
) {
842 * This device has not yet left the OF tree, it's
843 * minimum entitlement remains in vio_cmo.min and
846 vio_cmo
.desired
-= (viodev
->cmo
.desired
- VIO_CMO_MIN_ENT
);
849 * Save min allocation for device in reserve as long
850 * as it exists in OF tree as determined by later
853 viodev
->cmo
.entitled
-= VIO_CMO_MIN_ENT
;
855 /* Replenish spare from freed reserve pool */
856 if (viodev
->cmo
.entitled
&& (vio_cmo
.spare
< VIO_CMO_MIN_ENT
)) {
857 tmp
= min(viodev
->cmo
.entitled
, (VIO_CMO_MIN_ENT
-
859 vio_cmo
.spare
+= tmp
;
860 viodev
->cmo
.entitled
-= tmp
;
863 /* Remaining reserve goes to excess pool */
864 vio_cmo
.excess
.size
+= viodev
->cmo
.entitled
;
865 vio_cmo
.excess
.free
+= viodev
->cmo
.entitled
;
866 vio_cmo
.reserve
.size
-= viodev
->cmo
.entitled
;
869 * Until the device is removed it will keep a
870 * minimum entitlement; this will guarantee that
871 * a module unload/load will result in a success.
873 viodev
->cmo
.entitled
= VIO_CMO_MIN_ENT
;
874 viodev
->cmo
.desired
= VIO_CMO_MIN_ENT
;
875 atomic_set(&viodev
->cmo
.allocs_failed
, 0);
878 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
881 static void vio_cmo_set_dma_ops(struct vio_dev
*viodev
)
883 set_dma_ops(&viodev
->dev
, &vio_dma_mapping_ops
);
887 * vio_cmo_bus_init - CMO entitlement initialization at bus init time
889 * Set up the reserve and excess entitlement pools based on available
890 * system entitlement and the number of devices in the OF tree that
891 * require entitlement in the reserve pool.
893 static void vio_cmo_bus_init(void)
895 struct hvcall_mpp_data mpp_data
;
898 memset(&vio_cmo
, 0, sizeof(struct vio_cmo
));
899 spin_lock_init(&vio_cmo
.lock
);
900 INIT_LIST_HEAD(&vio_cmo
.device_list
);
901 INIT_DELAYED_WORK(&vio_cmo
.balance_q
, vio_cmo_balance
);
903 /* Get current system entitlement */
904 err
= h_get_mpp(&mpp_data
);
907 * On failure, continue with entitlement set to 0, will panic()
908 * later when spare is reserved.
910 if (err
!= H_SUCCESS
) {
911 printk(KERN_ERR
"%s: unable to determine system IO "\
912 "entitlement. (%d)\n", __func__
, err
);
913 vio_cmo
.entitled
= 0;
915 vio_cmo
.entitled
= mpp_data
.entitled_mem
;
918 /* Set reservation and check against entitlement */
919 vio_cmo
.spare
= VIO_CMO_MIN_ENT
;
920 vio_cmo
.reserve
.size
= vio_cmo
.spare
;
921 vio_cmo
.reserve
.size
+= (vio_cmo_num_OF_devs() *
923 if (vio_cmo
.reserve
.size
> vio_cmo
.entitled
) {
924 printk(KERN_ERR
"%s: insufficient system entitlement\n",
926 panic("%s: Insufficient system entitlement", __func__
);
929 /* Set the remaining accounting variables */
930 vio_cmo
.excess
.size
= vio_cmo
.entitled
- vio_cmo
.reserve
.size
;
931 vio_cmo
.excess
.free
= vio_cmo
.excess
.size
;
932 vio_cmo
.min
= vio_cmo
.reserve
.size
;
933 vio_cmo
.desired
= vio_cmo
.reserve
.size
;
936 /* sysfs device functions and data structures for CMO */
938 #define viodev_cmo_rd_attr(name) \
939 static ssize_t viodev_cmo_##name##_show(struct device *dev, \
940 struct device_attribute *attr, \
943 return sprintf(buf, "%lu\n", to_vio_dev(dev)->cmo.name); \
946 static ssize_t
viodev_cmo_allocs_failed_show(struct device
*dev
,
947 struct device_attribute
*attr
, char *buf
)
949 struct vio_dev
*viodev
= to_vio_dev(dev
);
950 return sprintf(buf
, "%d\n", atomic_read(&viodev
->cmo
.allocs_failed
));
953 static ssize_t
viodev_cmo_allocs_failed_reset(struct device
*dev
,
954 struct device_attribute
*attr
, const char *buf
, size_t count
)
956 struct vio_dev
*viodev
= to_vio_dev(dev
);
957 atomic_set(&viodev
->cmo
.allocs_failed
, 0);
961 static ssize_t
viodev_cmo_desired_set(struct device
*dev
,
962 struct device_attribute
*attr
, const char *buf
, size_t count
)
964 struct vio_dev
*viodev
= to_vio_dev(dev
);
968 ret
= strict_strtoul(buf
, 10, &new_desired
);
972 vio_cmo_set_dev_desired(viodev
, new_desired
);
976 viodev_cmo_rd_attr(desired
);
977 viodev_cmo_rd_attr(entitled
);
978 viodev_cmo_rd_attr(allocated
);
980 static ssize_t
name_show(struct device
*, struct device_attribute
*, char *);
981 static ssize_t
devspec_show(struct device
*, struct device_attribute
*, char *);
982 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
,
984 static struct device_attribute vio_cmo_dev_attrs
[] = {
988 __ATTR(cmo_desired
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
989 viodev_cmo_desired_show
, viodev_cmo_desired_set
),
990 __ATTR(cmo_entitled
, S_IRUGO
, viodev_cmo_entitled_show
, NULL
),
991 __ATTR(cmo_allocated
, S_IRUGO
, viodev_cmo_allocated_show
, NULL
),
992 __ATTR(cmo_allocs_failed
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
993 viodev_cmo_allocs_failed_show
, viodev_cmo_allocs_failed_reset
),
997 /* sysfs bus functions and data structures for CMO */
999 #define viobus_cmo_rd_attr(name) \
1001 viobus_cmo_##name##_show(struct bus_type *bt, char *buf) \
1003 return sprintf(buf, "%lu\n", vio_cmo.name); \
1006 #define viobus_cmo_pool_rd_attr(name, var) \
1008 viobus_cmo_##name##_pool_show_##var(struct bus_type *bt, char *buf) \
1010 return sprintf(buf, "%lu\n", vio_cmo.name.var); \
1013 static ssize_t
viobus_cmo_high_reset(struct bus_type
*bt
, const char *buf
,
1016 unsigned long flags
;
1018 spin_lock_irqsave(&vio_cmo
.lock
, flags
);
1019 vio_cmo
.high
= vio_cmo
.curr
;
1020 spin_unlock_irqrestore(&vio_cmo
.lock
, flags
);
1025 viobus_cmo_rd_attr(entitled
);
1026 viobus_cmo_pool_rd_attr(reserve
, size
);
1027 viobus_cmo_pool_rd_attr(excess
, size
);
1028 viobus_cmo_pool_rd_attr(excess
, free
);
1029 viobus_cmo_rd_attr(spare
);
1030 viobus_cmo_rd_attr(min
);
1031 viobus_cmo_rd_attr(desired
);
1032 viobus_cmo_rd_attr(curr
);
1033 viobus_cmo_rd_attr(high
);
1035 static struct bus_attribute vio_cmo_bus_attrs
[] = {
1036 __ATTR(cmo_entitled
, S_IRUGO
, viobus_cmo_entitled_show
, NULL
),
1037 __ATTR(cmo_reserve_size
, S_IRUGO
, viobus_cmo_reserve_pool_show_size
, NULL
),
1038 __ATTR(cmo_excess_size
, S_IRUGO
, viobus_cmo_excess_pool_show_size
, NULL
),
1039 __ATTR(cmo_excess_free
, S_IRUGO
, viobus_cmo_excess_pool_show_free
, NULL
),
1040 __ATTR(cmo_spare
, S_IRUGO
, viobus_cmo_spare_show
, NULL
),
1041 __ATTR(cmo_min
, S_IRUGO
, viobus_cmo_min_show
, NULL
),
1042 __ATTR(cmo_desired
, S_IRUGO
, viobus_cmo_desired_show
, NULL
),
1043 __ATTR(cmo_curr
, S_IRUGO
, viobus_cmo_curr_show
, NULL
),
1044 __ATTR(cmo_high
, S_IWUSR
|S_IRUSR
|S_IWGRP
|S_IRGRP
|S_IROTH
,
1045 viobus_cmo_high_show
, viobus_cmo_high_reset
),
1049 static void vio_cmo_sysfs_init(void)
1051 vio_bus_type
.dev_attrs
= vio_cmo_dev_attrs
;
1052 vio_bus_type
.bus_attrs
= vio_cmo_bus_attrs
;
1054 #else /* CONFIG_PPC_SMLPAR */
1055 int vio_cmo_entitlement_update(size_t new_entitlement
) { return 0; }
1056 void vio_cmo_set_dev_desired(struct vio_dev
*viodev
, size_t desired
) {}
1057 static int vio_cmo_bus_probe(struct vio_dev
*viodev
) { return 0; }
1058 static void vio_cmo_bus_remove(struct vio_dev
*viodev
) {}
1059 static void vio_cmo_set_dma_ops(struct vio_dev
*viodev
) {}
1060 static void vio_cmo_bus_init(void) {}
1061 static void vio_cmo_sysfs_init(void) { }
1062 #endif /* CONFIG_PPC_SMLPAR */
1063 EXPORT_SYMBOL(vio_cmo_entitlement_update
);
1064 EXPORT_SYMBOL(vio_cmo_set_dev_desired
);
1068 * Platform Facilities Option (PFO) support
1072 * vio_h_cop_sync - Perform a synchronous PFO co-processor operation
1074 * @vdev - Pointer to a struct vio_dev for device
1075 * @op - Pointer to a struct vio_pfo_op for the operation parameters
1077 * Calls the hypervisor to synchronously perform the PFO operation
1078 * described in @op. In the case of a busy response from the hypervisor,
1079 * the operation will be re-submitted indefinitely unless a non-zero timeout
1080 * is specified or an error occurs. The timeout places a limit on when to
1081 * stop re-submitting a operation, the total time can be exceeded if an
1082 * operation is in progress.
1084 * If op->hcall_ret is not NULL, this will be set to the return from the
1085 * last h_cop_op call or it will be 0 if an error not involving the h_call
1090 * -EINVAL if the h_call fails due to an invalid parameter,
1091 * -E2BIG if the h_call can not be performed synchronously,
1092 * -EBUSY if a timeout is specified and has elapsed,
1093 * -EACCES if the memory area for data/status has been rescinded, or
1094 * -EPERM if a hardware fault has been indicated
1096 int vio_h_cop_sync(struct vio_dev
*vdev
, struct vio_pfo_op
*op
)
1098 struct device
*dev
= &vdev
->dev
;
1099 unsigned long deadline
= 0;
1104 deadline
= jiffies
+ msecs_to_jiffies(op
->timeout
);
1107 hret
= plpar_hcall_norets(H_COP
, op
->flags
,
1109 op
->in
, op
->inlen
, op
->out
,
1110 op
->outlen
, op
->csbcpb
);
1112 if (hret
== H_SUCCESS
||
1113 (hret
!= H_NOT_ENOUGH_RESOURCES
&&
1114 hret
!= H_BUSY
&& hret
!= H_RESOURCE
) ||
1115 (op
->timeout
&& time_after(deadline
, jiffies
)))
1118 dev_dbg(dev
, "%s: hcall ret(%ld), retrying.\n", __func__
, hret
);
1135 case H_NOT_ENOUGH_RESOURCES
:
1146 dev_dbg(dev
, "%s: Sync h_cop_op failure (ret:%d) (hret:%ld)\n",
1147 __func__
, ret
, hret
);
1149 op
->hcall_err
= hret
;
1152 EXPORT_SYMBOL(vio_h_cop_sync
);
1154 static struct iommu_table
*vio_build_iommu_table(struct vio_dev
*dev
)
1156 const __be32
*dma_window
;
1157 struct iommu_table
*tbl
;
1158 unsigned long offset
, size
;
1160 dma_window
= of_get_property(dev
->dev
.of_node
,
1161 "ibm,my-dma-window", NULL
);
1165 tbl
= kzalloc(sizeof(*tbl
), GFP_KERNEL
);
1169 of_parse_dma_window(dev
->dev
.of_node
, dma_window
,
1170 &tbl
->it_index
, &offset
, &size
);
1172 /* TCE table size - measured in tce entries */
1173 tbl
->it_size
= size
>> IOMMU_PAGE_SHIFT
;
1174 /* offset for VIO should always be 0 */
1175 tbl
->it_offset
= offset
>> IOMMU_PAGE_SHIFT
;
1177 tbl
->it_type
= TCE_VB
;
1178 tbl
->it_blocksize
= 16;
1180 return iommu_init_table(tbl
, -1);
1184 * vio_match_device: - Tell if a VIO device has a matching
1185 * VIO device id structure.
1186 * @ids: array of VIO device id structures to search in
1187 * @dev: the VIO device structure to match against
1189 * Used by a driver to check whether a VIO device present in the
1190 * system is in its list of supported devices. Returns the matching
1191 * vio_device_id structure or NULL if there is no match.
1193 static const struct vio_device_id
*vio_match_device(
1194 const struct vio_device_id
*ids
, const struct vio_dev
*dev
)
1196 while (ids
->type
[0] != '\0') {
1197 if ((strncmp(dev
->type
, ids
->type
, strlen(ids
->type
)) == 0) &&
1198 of_device_is_compatible(dev
->dev
.of_node
,
1207 * Convert from struct device to struct vio_dev and pass to driver.
1208 * dev->driver has already been set by generic code because vio_bus_match
1211 static int vio_bus_probe(struct device
*dev
)
1213 struct vio_dev
*viodev
= to_vio_dev(dev
);
1214 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
1215 const struct vio_device_id
*id
;
1216 int error
= -ENODEV
;
1221 id
= vio_match_device(viodrv
->id_table
, viodev
);
1223 memset(&viodev
->cmo
, 0, sizeof(viodev
->cmo
));
1224 if (firmware_has_feature(FW_FEATURE_CMO
)) {
1225 error
= vio_cmo_bus_probe(viodev
);
1229 error
= viodrv
->probe(viodev
, id
);
1230 if (error
&& firmware_has_feature(FW_FEATURE_CMO
))
1231 vio_cmo_bus_remove(viodev
);
1237 /* convert from struct device to struct vio_dev and pass to driver. */
1238 static int vio_bus_remove(struct device
*dev
)
1240 struct vio_dev
*viodev
= to_vio_dev(dev
);
1241 struct vio_driver
*viodrv
= to_vio_driver(dev
->driver
);
1242 struct device
*devptr
;
1246 * Hold a reference to the device after the remove function is called
1247 * to allow for CMO accounting cleanup for the device.
1249 devptr
= get_device(dev
);
1252 ret
= viodrv
->remove(viodev
);
1254 if (!ret
&& firmware_has_feature(FW_FEATURE_CMO
))
1255 vio_cmo_bus_remove(viodev
);
1262 * vio_register_driver: - Register a new vio driver
1263 * @viodrv: The vio_driver structure to be registered.
1265 int __vio_register_driver(struct vio_driver
*viodrv
, struct module
*owner
,
1266 const char *mod_name
)
1268 pr_debug("%s: driver %s registering\n", __func__
, viodrv
->name
);
1270 /* fill in 'struct driver' fields */
1271 viodrv
->driver
.name
= viodrv
->name
;
1272 viodrv
->driver
.pm
= viodrv
->pm
;
1273 viodrv
->driver
.bus
= &vio_bus_type
;
1274 viodrv
->driver
.owner
= owner
;
1275 viodrv
->driver
.mod_name
= mod_name
;
1277 return driver_register(&viodrv
->driver
);
1279 EXPORT_SYMBOL(__vio_register_driver
);
1282 * vio_unregister_driver - Remove registration of vio driver.
1283 * @viodrv: The vio_driver struct to be removed form registration
1285 void vio_unregister_driver(struct vio_driver
*viodrv
)
1287 driver_unregister(&viodrv
->driver
);
1289 EXPORT_SYMBOL(vio_unregister_driver
);
1291 /* vio_dev refcount hit 0 */
1292 static void vio_dev_release(struct device
*dev
)
1294 struct iommu_table
*tbl
= get_iommu_table_base(dev
);
1297 iommu_free_table(tbl
, of_node_full_name(dev
->of_node
));
1298 of_node_put(dev
->of_node
);
1299 kfree(to_vio_dev(dev
));
1303 * vio_register_device_node: - Register a new vio device.
1304 * @of_node: The OF node for this device.
1306 * Creates and initializes a vio_dev structure from the data in
1307 * of_node and adds it to the list of virtual devices.
1308 * Returns a pointer to the created vio_dev or NULL if node has
1309 * NULL device_type or compatible fields.
1311 struct vio_dev
*vio_register_device_node(struct device_node
*of_node
)
1313 struct vio_dev
*viodev
;
1314 struct device_node
*parent_node
;
1316 enum vio_dev_family family
;
1317 const char *of_node_name
= of_node
->name
? of_node
->name
: "<unknown>";
1320 * Determine if this node is a under the /vdevice node or under the
1321 * /ibm,platform-facilities node. This decides the device's family.
1323 parent_node
= of_get_parent(of_node
);
1325 if (!strcmp(parent_node
->full_name
, "/ibm,platform-facilities"))
1327 else if (!strcmp(parent_node
->full_name
, "/vdevice"))
1330 pr_warn("%s: parent(%s) of %s not recognized.\n",
1332 parent_node
->full_name
,
1334 of_node_put(parent_node
);
1337 of_node_put(parent_node
);
1339 pr_warn("%s: could not determine the parent of node %s.\n",
1340 __func__
, of_node_name
);
1344 if (family
== PFO
) {
1345 if (of_get_property(of_node
, "interrupt-controller", NULL
)) {
1346 pr_debug("%s: Skipping the interrupt controller %s.\n",
1347 __func__
, of_node_name
);
1352 /* allocate a vio_dev for this node */
1353 viodev
= kzalloc(sizeof(struct vio_dev
), GFP_KERNEL
);
1354 if (viodev
== NULL
) {
1355 pr_warn("%s: allocation failure for VIO device.\n", __func__
);
1359 /* we need the 'device_type' property, in order to match with drivers */
1360 viodev
->family
= family
;
1361 if (viodev
->family
== VDEVICE
) {
1362 unsigned int unit_address
;
1364 if (of_node
->type
!= NULL
)
1365 viodev
->type
= of_node
->type
;
1367 pr_warn("%s: node %s is missing the 'device_type' "
1368 "property.\n", __func__
, of_node_name
);
1372 prop
= of_get_property(of_node
, "reg", NULL
);
1374 pr_warn("%s: node %s missing 'reg'\n",
1375 __func__
, of_node_name
);
1378 unit_address
= of_read_number(prop
, 1);
1379 dev_set_name(&viodev
->dev
, "%x", unit_address
);
1380 viodev
->irq
= irq_of_parse_and_map(of_node
, 0);
1381 viodev
->unit_address
= unit_address
;
1383 /* PFO devices need their resource_id for submitting COP_OPs
1384 * This is an optional field for devices, but is required when
1385 * performing synchronous ops */
1386 prop
= of_get_property(of_node
, "ibm,resource-id", NULL
);
1388 viodev
->resource_id
= of_read_number(prop
, 1);
1390 dev_set_name(&viodev
->dev
, "%s", of_node_name
);
1391 viodev
->type
= of_node_name
;
1395 viodev
->name
= of_node
->name
;
1396 viodev
->dev
.of_node
= of_node_get(of_node
);
1398 set_dev_node(&viodev
->dev
, of_node_to_nid(of_node
));
1400 /* init generic 'struct device' fields: */
1401 viodev
->dev
.parent
= &vio_bus_device
.dev
;
1402 viodev
->dev
.bus
= &vio_bus_type
;
1403 viodev
->dev
.release
= vio_dev_release
;
1405 if (of_get_property(viodev
->dev
.of_node
, "ibm,my-dma-window", NULL
)) {
1406 if (firmware_has_feature(FW_FEATURE_CMO
))
1407 vio_cmo_set_dma_ops(viodev
);
1409 set_dma_ops(&viodev
->dev
, &dma_iommu_ops
);
1411 set_iommu_table_base(&viodev
->dev
,
1412 vio_build_iommu_table(viodev
));
1414 /* needed to ensure proper operation of coherent allocations
1415 * later, in case driver doesn't set it explicitly */
1416 dma_set_mask(&viodev
->dev
, DMA_BIT_MASK(64));
1417 dma_set_coherent_mask(&viodev
->dev
, DMA_BIT_MASK(64));
1420 /* register with generic device framework */
1421 if (device_register(&viodev
->dev
)) {
1422 printk(KERN_ERR
"%s: failed to register device %s\n",
1423 __func__
, dev_name(&viodev
->dev
));
1424 put_device(&viodev
->dev
);
1430 out
: /* Use this exit point for any return prior to device_register */
1435 EXPORT_SYMBOL(vio_register_device_node
);
1438 * vio_bus_scan_for_devices - Scan OF and register each child device
1439 * @root_name - OF node name for the root of the subtree to search.
1440 * This must be non-NULL
1442 * Starting from the root node provide, register the device node for
1443 * each child beneath the root.
1445 static void vio_bus_scan_register_devices(char *root_name
)
1447 struct device_node
*node_root
, *node_child
;
1452 node_root
= of_find_node_by_name(NULL
, root_name
);
1456 * Create struct vio_devices for each virtual device in
1457 * the device tree. Drivers will associate with them later.
1459 node_child
= of_get_next_child(node_root
, NULL
);
1460 while (node_child
) {
1461 vio_register_device_node(node_child
);
1462 node_child
= of_get_next_child(node_root
, node_child
);
1464 of_node_put(node_root
);
1469 * vio_bus_init: - Initialize the virtual IO bus
1471 static int __init
vio_bus_init(void)
1475 if (firmware_has_feature(FW_FEATURE_CMO
))
1476 vio_cmo_sysfs_init();
1478 err
= bus_register(&vio_bus_type
);
1480 printk(KERN_ERR
"failed to register VIO bus\n");
1485 * The fake parent of all vio devices, just to give us
1488 err
= device_register(&vio_bus_device
.dev
);
1490 printk(KERN_WARNING
"%s: device_register returned %i\n",
1495 if (firmware_has_feature(FW_FEATURE_CMO
))
1500 postcore_initcall(vio_bus_init
);
1502 static int __init
vio_device_init(void)
1504 vio_bus_scan_register_devices("vdevice");
1505 vio_bus_scan_register_devices("ibm,platform-facilities");
1509 device_initcall(vio_device_init
);
1511 static ssize_t
name_show(struct device
*dev
,
1512 struct device_attribute
*attr
, char *buf
)
1514 return sprintf(buf
, "%s\n", to_vio_dev(dev
)->name
);
1517 static ssize_t
devspec_show(struct device
*dev
,
1518 struct device_attribute
*attr
, char *buf
)
1520 struct device_node
*of_node
= dev
->of_node
;
1522 return sprintf(buf
, "%s\n", of_node_full_name(of_node
));
1525 static ssize_t
modalias_show(struct device
*dev
, struct device_attribute
*attr
,
1528 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1529 struct device_node
*dn
;
1537 cp
= of_get_property(dn
, "compatible", NULL
);
1543 return sprintf(buf
, "vio:T%sS%s\n", vio_dev
->type
, cp
);
1546 static struct device_attribute vio_dev_attrs
[] = {
1549 __ATTR_RO(modalias
),
1553 void vio_unregister_device(struct vio_dev
*viodev
)
1555 device_unregister(&viodev
->dev
);
1557 EXPORT_SYMBOL(vio_unregister_device
);
1559 static int vio_bus_match(struct device
*dev
, struct device_driver
*drv
)
1561 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1562 struct vio_driver
*vio_drv
= to_vio_driver(drv
);
1563 const struct vio_device_id
*ids
= vio_drv
->id_table
;
1565 return (ids
!= NULL
) && (vio_match_device(ids
, vio_dev
) != NULL
);
1568 static int vio_hotplug(struct device
*dev
, struct kobj_uevent_env
*env
)
1570 const struct vio_dev
*vio_dev
= to_vio_dev(dev
);
1571 struct device_node
*dn
;
1577 cp
= of_get_property(dn
, "compatible", NULL
);
1581 add_uevent_var(env
, "MODALIAS=vio:T%sS%s", vio_dev
->type
, cp
);
1585 struct bus_type vio_bus_type
= {
1587 .dev_attrs
= vio_dev_attrs
,
1588 .uevent
= vio_hotplug
,
1589 .match
= vio_bus_match
,
1590 .probe
= vio_bus_probe
,
1591 .remove
= vio_bus_remove
,
1595 * vio_get_attribute: - get attribute for virtual device
1596 * @vdev: The vio device to get property.
1597 * @which: The property/attribute to be extracted.
1598 * @length: Pointer to length of returned data size (unused if NULL).
1600 * Calls prom.c's of_get_property() to return the value of the
1601 * attribute specified by @which
1603 const void *vio_get_attribute(struct vio_dev
*vdev
, char *which
, int *length
)
1605 return of_get_property(vdev
->dev
.of_node
, which
, length
);
1607 EXPORT_SYMBOL(vio_get_attribute
);
1609 #ifdef CONFIG_PPC_PSERIES
1610 /* vio_find_name() - internal because only vio.c knows how we formatted the
1613 static struct vio_dev
*vio_find_name(const char *name
)
1615 struct device
*found
;
1617 found
= bus_find_device_by_name(&vio_bus_type
, NULL
, name
);
1621 return to_vio_dev(found
);
1625 * vio_find_node - find an already-registered vio_dev
1626 * @vnode: device_node of the virtual device we're looking for
1628 struct vio_dev
*vio_find_node(struct device_node
*vnode
)
1631 struct device_node
*vnode_parent
;
1632 const char *dev_type
;
1634 vnode_parent
= of_get_parent(vnode
);
1638 dev_type
= of_get_property(vnode_parent
, "device_type", NULL
);
1639 of_node_put(vnode_parent
);
1643 /* construct the kobject name from the device node */
1644 if (!strcmp(dev_type
, "vdevice")) {
1647 prop
= of_get_property(vnode
, "reg", NULL
);
1650 snprintf(kobj_name
, sizeof(kobj_name
), "%x",
1651 (uint32_t)of_read_number(prop
, 1));
1652 } else if (!strcmp(dev_type
, "ibm,platform-facilities"))
1653 snprintf(kobj_name
, sizeof(kobj_name
), "%s", vnode
->name
);
1657 return vio_find_name(kobj_name
);
1659 EXPORT_SYMBOL(vio_find_node
);
1661 int vio_enable_interrupts(struct vio_dev
*dev
)
1663 int rc
= h_vio_signal(dev
->unit_address
, VIO_IRQ_ENABLE
);
1664 if (rc
!= H_SUCCESS
)
1665 printk(KERN_ERR
"vio: Error 0x%x enabling interrupts\n", rc
);
1668 EXPORT_SYMBOL(vio_enable_interrupts
);
1670 int vio_disable_interrupts(struct vio_dev
*dev
)
1672 int rc
= h_vio_signal(dev
->unit_address
, VIO_IRQ_DISABLE
);
1673 if (rc
!= H_SUCCESS
)
1674 printk(KERN_ERR
"vio: Error 0x%x disabling interrupts\n", rc
);
1677 EXPORT_SYMBOL(vio_disable_interrupts
);
1678 #endif /* CONFIG_PPC_PSERIES */