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/stat.h>
19 #include <linux/device.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/console.h>
23 #include <linux/export.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/kobject.h>
28 #include <asm/iommu.h>
32 #include <asm/firmware.h>
34 #include <asm/abs_addr.h>
36 #include <asm/hvcall.h>
37 #include <asm/iseries/vio.h>
38 #include <asm/iseries/hv_types.h>
39 #include <asm/iseries/hv_lp_config.h>
40 #include <asm/iseries/hv_call_xm.h>
41 #include <asm/iseries/iommu.h>
43 static struct bus_type vio_bus_type;
45 static struct vio_dev vio_bus_device = { /* fake "parent" device */
48 .dev.init_name = "vio",
49 .dev.bus = &vio_bus_type,
52 #ifdef CONFIG_PPC_SMLPAR
54 * vio_cmo_pool - A pool of IO memory for CMO use
56 * @size: The size of the pool in bytes
57 * @free: The amount of free memory in the pool
64 /* How many ms to delay queued balance work */
65 #define VIO_CMO_BALANCE_DELAY 100
67 /* Portion out IO memory to CMO devices by this chunk size */
68 #define VIO_CMO_BALANCE_CHUNK 131072
71 * vio_cmo_dev_entry - A device that is CMO-enabled and requires entitlement
73 * @vio_dev: struct vio_dev pointer
74 * @list: pointer to other devices on bus that are being tracked
76 struct vio_cmo_dev_entry {
77 struct vio_dev *viodev;
78 struct list_head list;
82 * vio_cmo - VIO bus accounting structure for CMO entitlement
84 * @lock: spinlock for entire structure
85 * @balance_q: work queue for balancing system entitlement
86 * @device_list: list of CMO-enabled devices requiring entitlement
87 * @entitled: total system entitlement in bytes
88 * @reserve: pool of memory from which devices reserve entitlement, incl. spare
89 * @excess: pool of excess entitlement not needed for device reserves or spare
90 * @spare: IO memory for device hotplug functionality
91 * @min: minimum necessary for system operation
92 * @desired: desired memory for system operation
93 * @curr: bytes currently allocated
94 * @high: high water mark for IO data usage
98 struct delayed_work balance_q;
99 struct list_head device_list;
101 struct vio_cmo_pool reserve;
102 struct vio_cmo_pool excess;
111 * vio_cmo_OF_devices - Count the number of OF devices that have DMA windows
113 static int vio_cmo_num_OF_devs(void)
115 struct device_node *node_vroot;
119 * Count the number of vdevice entries with an
120 * ibm,my-dma-window OF property
122 node_vroot = of_find_node_by_name(NULL, "vdevice");
124 struct device_node *of_node;
125 struct property *prop;
127 for_each_child_of_node(node_vroot, of_node) {
128 prop = of_find_property(of_node, "ibm,my-dma-window",
134 of_node_put(node_vroot);
139 * vio_cmo_alloc - allocate IO memory for CMO-enable devices
141 * @viodev: VIO device requesting IO memory
142 * @size: size of allocation requested
144 * Allocations come from memory reserved for the devices and any excess
145 * IO memory available to all devices. The spare pool used to service
146 * hotplug must be equal to %VIO_CMO_MIN_ENT for the excess pool to be
150 * 0 for successful allocation and -ENOMEM for a failure
152 static inline int vio_cmo_alloc(struct vio_dev *viodev, size_t size)
155 size_t reserve_free = 0;
156 size_t excess_free = 0;
159 spin_lock_irqsave(&vio_cmo.lock, flags);
161 /* Determine the amount of free entitlement available in reserve */
162 if (viodev->cmo.entitled > viodev->cmo.allocated)
163 reserve_free = viodev->cmo.entitled - viodev->cmo.allocated;
165 /* If spare is not fulfilled, the excess pool can not be used. */
166 if (vio_cmo.spare >= VIO_CMO_MIN_ENT)
167 excess_free = vio_cmo.excess.free;
169 /* The request can be satisfied */
170 if ((reserve_free + excess_free) >= size) {
171 vio_cmo.curr += size;
172 if (vio_cmo.curr > vio_cmo.high)
173 vio_cmo.high = vio_cmo.curr;
174 viodev->cmo.allocated += size;
175 size -= min(reserve_free, size);
176 vio_cmo.excess.free -= size;
180 spin_unlock_irqrestore(&vio_cmo.lock, flags);
185 * vio_cmo_dealloc - deallocate IO memory from CMO-enable devices
186 * @viodev: VIO device freeing IO memory
187 * @size: size of deallocation
189 * IO memory is freed by the device back to the correct memory pools.
190 * The spare pool is replenished first from either memory pool, then
191 * the reserve pool is used to reduce device entitlement, the excess
192 * pool is used to increase the reserve pool toward the desired entitlement
193 * target, and then the remaining memory is returned to the pools.
196 static inline void vio_cmo_dealloc(struct vio_dev *viodev, size_t size)
199 size_t spare_needed = 0;
200 size_t excess_freed = 0;
201 size_t reserve_freed = size;
205 spin_lock_irqsave(&vio_cmo.lock, flags);
206 vio_cmo.curr -= size;
208 /* Amount of memory freed from the excess pool */
209 if (viodev->cmo.allocated > viodev->cmo.entitled) {
210 excess_freed = min(reserve_freed, (viodev->cmo.allocated -
211 viodev->cmo.entitled));
212 reserve_freed -= excess_freed;
215 /* Remove allocation from device */
216 viodev->cmo.allocated -= (reserve_freed + excess_freed);
218 /* Spare is a subset of the reserve pool, replenish it first. */
219 spare_needed = VIO_CMO_MIN_ENT - vio_cmo.spare;
222 * Replenish the spare in the reserve pool from the excess pool.
223 * This moves entitlement into the reserve pool.
225 if (spare_needed && excess_freed) {
226 tmp = min(excess_freed, spare_needed);
227 vio_cmo.excess.size -= tmp;
228 vio_cmo.reserve.size += tmp;
229 vio_cmo.spare += tmp;
236 * Replenish the spare in the reserve pool from the reserve pool.
237 * This removes entitlement from the device down to VIO_CMO_MIN_ENT,
238 * if needed, and gives it to the spare pool. The amount of used
239 * memory in this pool does not change.
241 if (spare_needed && reserve_freed) {
242 tmp = min3(spare_needed, reserve_freed, (viodev->cmo.entitled - VIO_CMO_MIN_ENT));
244 vio_cmo.spare += tmp;
245 viodev->cmo.entitled -= tmp;
246 reserve_freed -= tmp;
252 * Increase the reserve pool until the desired allocation is met.
253 * Move an allocation freed from the excess pool into the reserve
254 * pool and schedule a balance operation.
256 if (excess_freed && (vio_cmo.desired > vio_cmo.reserve.size)) {
257 tmp = min(excess_freed, (vio_cmo.desired - vio_cmo.reserve.size));
259 vio_cmo.excess.size -= tmp;
260 vio_cmo.reserve.size += tmp;
265 /* Return memory from the excess pool to that pool */
267 vio_cmo.excess.free += excess_freed;
270 schedule_delayed_work(&vio_cmo.balance_q, VIO_CMO_BALANCE_DELAY);
271 spin_unlock_irqrestore(&vio_cmo.lock, flags);
275 * vio_cmo_entitlement_update - Manage system entitlement changes
277 * @new_entitlement: new system entitlement to attempt to accommodate
279 * Increases in entitlement will be used to fulfill the spare entitlement
280 * and the rest is given to the excess pool. Decreases, if they are
281 * possible, come from the excess pool and from unused device entitlement
283 * Returns: 0 on success, -ENOMEM when change can not be made
285 int vio_cmo_entitlement_update(size_t new_entitlement)
287 struct vio_dev *viodev;
288 struct vio_cmo_dev_entry *dev_ent;
290 size_t avail, delta, tmp;
292 spin_lock_irqsave(&vio_cmo.lock, flags);
294 /* Entitlement increases */
295 if (new_entitlement > vio_cmo.entitled) {
296 delta = new_entitlement - vio_cmo.entitled;
298 /* Fulfill spare allocation */
299 if (vio_cmo.spare < VIO_CMO_MIN_ENT) {
300 tmp = min(delta, (VIO_CMO_MIN_ENT - vio_cmo.spare));
301 vio_cmo.spare += tmp;
302 vio_cmo.reserve.size += tmp;
306 /* Remaining new allocation goes to the excess pool */
307 vio_cmo.entitled += delta;
308 vio_cmo.excess.size += delta;
309 vio_cmo.excess.free += delta;
314 /* Entitlement decreases */
315 delta = vio_cmo.entitled - new_entitlement;
316 avail = vio_cmo.excess.free;
319 * Need to check how much unused entitlement each device can
320 * sacrifice to fulfill entitlement change.
322 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
326 viodev = dev_ent->viodev;
327 if ((viodev->cmo.entitled > viodev->cmo.allocated) &&
328 (viodev->cmo.entitled > VIO_CMO_MIN_ENT))
329 avail += viodev->cmo.entitled -
330 max_t(size_t, viodev->cmo.allocated,
334 if (delta <= avail) {
335 vio_cmo.entitled -= delta;
337 /* Take entitlement from the excess pool first */
338 tmp = min(vio_cmo.excess.free, delta);
339 vio_cmo.excess.size -= tmp;
340 vio_cmo.excess.free -= tmp;
344 * Remove all but VIO_CMO_MIN_ENT bytes from devices
345 * until entitlement change is served
347 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
351 viodev = dev_ent->viodev;
353 if ((viodev->cmo.entitled > viodev->cmo.allocated) &&
354 (viodev->cmo.entitled > VIO_CMO_MIN_ENT))
355 tmp = viodev->cmo.entitled -
356 max_t(size_t, viodev->cmo.allocated,
358 viodev->cmo.entitled -= min(tmp, delta);
359 delta -= min(tmp, delta);
362 spin_unlock_irqrestore(&vio_cmo.lock, flags);
367 schedule_delayed_work(&vio_cmo.balance_q, 0);
368 spin_unlock_irqrestore(&vio_cmo.lock, flags);
373 * vio_cmo_balance - Balance entitlement among devices
375 * @work: work queue structure for this operation
377 * Any system entitlement above the minimum needed for devices, or
378 * already allocated to devices, can be distributed to the devices.
379 * The list of devices is iterated through to recalculate the desired
380 * entitlement level and to determine how much entitlement above the
381 * minimum entitlement is allocated to devices.
383 * Small chunks of the available entitlement are given to devices until
384 * their requirements are fulfilled or there is no entitlement left to give.
385 * Upon completion sizes of the reserve and excess pools are calculated.
387 * The system minimum entitlement level is also recalculated here.
388 * Entitlement will be reserved for devices even after vio_bus_remove to
389 * accommodate reloading the driver. The OF tree is walked to count the
390 * number of devices present and this will remove entitlement for devices
391 * that have actually left the system after having vio_bus_remove called.
393 static void vio_cmo_balance(struct work_struct *work)
396 struct vio_dev *viodev;
397 struct vio_cmo_dev_entry *dev_ent;
399 size_t avail = 0, level, chunk, need;
400 int devcount = 0, fulfilled;
402 cmo = container_of(work, struct vio_cmo, balance_q.work);
404 spin_lock_irqsave(&vio_cmo.lock, flags);
406 /* Calculate minimum entitlement and fulfill spare */
407 cmo->min = vio_cmo_num_OF_devs() * VIO_CMO_MIN_ENT;
408 BUG_ON(cmo->min > cmo->entitled);
409 cmo->spare = min_t(size_t, VIO_CMO_MIN_ENT, (cmo->entitled - cmo->min));
410 cmo->min += cmo->spare;
411 cmo->desired = cmo->min;
414 * Determine how much entitlement is available and reset device
417 avail = cmo->entitled - cmo->spare;
418 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
419 viodev = dev_ent->viodev;
421 viodev->cmo.entitled = VIO_CMO_MIN_ENT;
422 cmo->desired += (viodev->cmo.desired - VIO_CMO_MIN_ENT);
423 avail -= max_t(size_t, viodev->cmo.allocated, VIO_CMO_MIN_ENT);
427 * Having provided each device with the minimum entitlement, loop
428 * over the devices portioning out the remaining entitlement
429 * until there is nothing left.
431 level = VIO_CMO_MIN_ENT;
434 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
435 viodev = dev_ent->viodev;
437 if (viodev->cmo.desired <= level) {
443 * Give the device up to VIO_CMO_BALANCE_CHUNK
444 * bytes of entitlement, but do not exceed the
445 * desired level of entitlement for the device.
447 chunk = min_t(size_t, avail, VIO_CMO_BALANCE_CHUNK);
448 chunk = min(chunk, (viodev->cmo.desired -
449 viodev->cmo.entitled));
450 viodev->cmo.entitled += chunk;
453 * If the memory for this entitlement increase was
454 * already allocated to the device it does not come
455 * from the available pool being portioned out.
457 need = max(viodev->cmo.allocated, viodev->cmo.entitled)-
458 max(viodev->cmo.allocated, level);
462 if (fulfilled == devcount)
464 level += VIO_CMO_BALANCE_CHUNK;
467 /* Calculate new reserve and excess pool sizes */
468 cmo->reserve.size = cmo->min;
469 cmo->excess.free = 0;
470 cmo->excess.size = 0;
472 list_for_each_entry(dev_ent, &vio_cmo.device_list, list) {
473 viodev = dev_ent->viodev;
474 /* Calculated reserve size above the minimum entitlement */
475 if (viodev->cmo.entitled)
476 cmo->reserve.size += (viodev->cmo.entitled -
478 /* Calculated used excess entitlement */
479 if (viodev->cmo.allocated > viodev->cmo.entitled)
480 need += viodev->cmo.allocated - viodev->cmo.entitled;
482 cmo->excess.size = cmo->entitled - cmo->reserve.size;
483 cmo->excess.free = cmo->excess.size - need;
485 cancel_delayed_work(to_delayed_work(work));
486 spin_unlock_irqrestore(&vio_cmo.lock, flags);
489 static void *vio_dma_iommu_alloc_coherent(struct device *dev, size_t size,
490 dma_addr_t *dma_handle, gfp_t flag)
492 struct vio_dev *viodev = to_vio_dev(dev);
495 if (vio_cmo_alloc(viodev, roundup(size, PAGE_SIZE))) {
496 atomic_inc(&viodev->cmo.allocs_failed);
500 ret = dma_iommu_ops.alloc_coherent(dev, size, dma_handle, flag);
501 if (unlikely(ret == NULL)) {
502 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
503 atomic_inc(&viodev->cmo.allocs_failed);
509 static void vio_dma_iommu_free_coherent(struct device *dev, size_t size,
510 void *vaddr, dma_addr_t dma_handle)
512 struct vio_dev *viodev = to_vio_dev(dev);
514 dma_iommu_ops.free_coherent(dev, size, vaddr, dma_handle);
516 vio_cmo_dealloc(viodev, roundup(size, PAGE_SIZE));
519 static dma_addr_t vio_dma_iommu_map_page(struct device *dev, struct page *page,
520 unsigned long offset, size_t size,
521 enum dma_data_direction direction,
522 struct dma_attrs *attrs)
524 struct vio_dev *viodev = to_vio_dev(dev);
525 dma_addr_t ret = DMA_ERROR_CODE;
527 if (vio_cmo_alloc(viodev, roundup(size, IOMMU_PAGE_SIZE))) {
528 atomic_inc(&viodev->cmo.allocs_failed);
532 ret = dma_iommu_ops.map_page(dev, page, offset, size, direction, attrs);
533 if (unlikely(dma_mapping_error(dev, ret))) {
534 vio_cmo_dealloc(viodev, roundup(size, IOMMU_PAGE_SIZE));
535 atomic_inc(&viodev->cmo.allocs_failed);
541 static void vio_dma_iommu_unmap_page(struct device *dev, dma_addr_t dma_handle,
543 enum dma_data_direction direction,
544 struct dma_attrs *attrs)
546 struct vio_dev *viodev = to_vio_dev(dev);
548 dma_iommu_ops.unmap_page(dev, dma_handle, size, direction, attrs);
550 vio_cmo_dealloc(viodev, roundup(size, IOMMU_PAGE_SIZE));
553 static int vio_dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
554 int nelems, enum dma_data_direction direction,
555 struct dma_attrs *attrs)
557 struct vio_dev *viodev = to_vio_dev(dev);
558 struct scatterlist *sgl;
560 size_t alloc_size = 0;
562 for (sgl = sglist; count < nelems; count++, sgl++)
563 alloc_size += roundup(sgl->length, IOMMU_PAGE_SIZE);
565 if (vio_cmo_alloc(viodev, alloc_size)) {
566 atomic_inc(&viodev->cmo.allocs_failed);
570 ret = dma_iommu_ops.map_sg(dev, sglist, nelems, direction, attrs);
572 if (unlikely(!ret)) {
573 vio_cmo_dealloc(viodev, alloc_size);
574 atomic_inc(&viodev->cmo.allocs_failed);
578 for (sgl = sglist, count = 0; count < ret; count++, sgl++)
579 alloc_size -= roundup(sgl->dma_length, IOMMU_PAGE_SIZE);
581 vio_cmo_dealloc(viodev, alloc_size);
586 static void vio_dma_iommu_unmap_sg(struct device *dev,
587 struct scatterlist *sglist, int nelems,
588 enum dma_data_direction direction,
589 struct dma_attrs *attrs)
591 struct vio_dev *viodev = to_vio_dev(dev);
592 struct scatterlist *sgl;
593 size_t alloc_size = 0;
596 for (sgl = sglist; count < nelems; count++, sgl++)
597 alloc_size += roundup(sgl->dma_length, IOMMU_PAGE_SIZE);
599 dma_iommu_ops.unmap_sg(dev, sglist, nelems, direction, attrs);
601 vio_cmo_dealloc(viodev, alloc_size);
604 static int vio_dma_iommu_dma_supported(struct device *dev, u64 mask)
606 return dma_iommu_ops.dma_supported(dev, mask);
609 static u64 vio_dma_get_required_mask(struct device *dev)
611 return dma_iommu_ops.get_required_mask(dev);
614 struct dma_map_ops vio_dma_mapping_ops = {
615 .alloc_coherent = vio_dma_iommu_alloc_coherent,
616 .free_coherent = vio_dma_iommu_free_coherent,
617 .map_sg = vio_dma_iommu_map_sg,
618 .unmap_sg = vio_dma_iommu_unmap_sg,
619 .map_page = vio_dma_iommu_map_page,
620 .unmap_page = vio_dma_iommu_unmap_page,
621 .dma_supported = vio_dma_iommu_dma_supported,
622 .get_required_mask = vio_dma_get_required_mask,
626 * vio_cmo_set_dev_desired - Set desired entitlement for a device
628 * @viodev: struct vio_dev for device to alter
629 * @new_desired: new desired entitlement level in bytes
631 * For use by devices to request a change to their entitlement at runtime or
632 * through sysfs. The desired entitlement level is changed and a balancing
633 * of system resources is scheduled to run in the future.
635 void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired)
638 struct vio_cmo_dev_entry *dev_ent;
641 if (!firmware_has_feature(FW_FEATURE_CMO))
644 spin_lock_irqsave(&vio_cmo.lock, flags);
645 if (desired < VIO_CMO_MIN_ENT)
646 desired = VIO_CMO_MIN_ENT;
649 * Changes will not be made for devices not in the device list.
650 * If it is not in the device list, then no driver is loaded
651 * for the device and it can not receive entitlement.
653 list_for_each_entry(dev_ent, &vio_cmo.device_list, list)
654 if (viodev == dev_ent->viodev) {
659 spin_unlock_irqrestore(&vio_cmo.lock, flags);
663 /* Increase/decrease in desired device entitlement */
664 if (desired >= viodev->cmo.desired) {
665 /* Just bump the bus and device values prior to a balance*/
666 vio_cmo.desired += desired - viodev->cmo.desired;
667 viodev->cmo.desired = desired;
669 /* Decrease bus and device values for desired entitlement */
670 vio_cmo.desired -= viodev->cmo.desired - desired;
671 viodev->cmo.desired = desired;
673 * If less entitlement is desired than current entitlement, move
674 * any reserve memory in the change region to the excess pool.
676 if (viodev->cmo.entitled > desired) {
677 vio_cmo.reserve.size -= viodev->cmo.entitled - desired;
678 vio_cmo.excess.size += viodev->cmo.entitled - desired;
680 * If entitlement moving from the reserve pool to the
681 * excess pool is currently unused, add to the excess
684 if (viodev->cmo.allocated < viodev->cmo.entitled)
685 vio_cmo.excess.free += viodev->cmo.entitled -
686 max(viodev->cmo.allocated, desired);
687 viodev->cmo.entitled = desired;
690 schedule_delayed_work(&vio_cmo.balance_q, 0);
691 spin_unlock_irqrestore(&vio_cmo.lock, flags);
695 * vio_cmo_bus_probe - Handle CMO specific bus probe activities
697 * @viodev - Pointer to struct vio_dev for device
699 * Determine the devices IO memory entitlement needs, attempting
700 * to satisfy the system minimum entitlement at first and scheduling
701 * a balance operation to take care of the rest at a later time.
703 * Returns: 0 on success, -EINVAL when device doesn't support CMO, and
704 * -ENOMEM when entitlement is not available for device or
708 static int vio_cmo_bus_probe(struct vio_dev *viodev)
710 struct vio_cmo_dev_entry *dev_ent;
711 struct device *dev = &viodev->dev;
712 struct vio_driver *viodrv = to_vio_driver(dev->driver);
717 * Check to see that device has a DMA window and configure
718 * entitlement for the device.
720 if (of_get_property(viodev->dev.of_node,
721 "ibm,my-dma-window", NULL)) {
722 /* Check that the driver is CMO enabled and get desired DMA */
723 if (!viodrv->get_desired_dma) {
724 dev_err(dev, "%s: device driver does not support CMO\n",
729 viodev->cmo.desired = IOMMU_PAGE_ALIGN(viodrv->get_desired_dma(viodev));
730 if (viodev->cmo.desired < VIO_CMO_MIN_ENT)
731 viodev->cmo.desired = VIO_CMO_MIN_ENT;
732 size = VIO_CMO_MIN_ENT;
734 dev_ent = kmalloc(sizeof(struct vio_cmo_dev_entry),
739 dev_ent->viodev = viodev;
740 spin_lock_irqsave(&vio_cmo.lock, flags);
741 list_add(&dev_ent->list, &vio_cmo.device_list);
743 viodev->cmo.desired = 0;
745 spin_lock_irqsave(&vio_cmo.lock, flags);
749 * If the needs for vio_cmo.min have not changed since they
750 * were last set, the number of devices in the OF tree has
751 * been constant and the IO memory for this is already in
754 if (vio_cmo.min == ((vio_cmo_num_OF_devs() + 1) *
756 /* Updated desired entitlement if device requires it */
758 vio_cmo.desired += (viodev->cmo.desired -
763 tmp = vio_cmo.spare + vio_cmo.excess.free;
765 dev_err(dev, "%s: insufficient free "
766 "entitlement to add device. "
767 "Need %lu, have %lu\n", __func__,
768 size, (vio_cmo.spare + tmp));
769 spin_unlock_irqrestore(&vio_cmo.lock, flags);
773 /* Use excess pool first to fulfill request */
774 tmp = min(size, vio_cmo.excess.free);
775 vio_cmo.excess.free -= tmp;
776 vio_cmo.excess.size -= tmp;
777 vio_cmo.reserve.size += tmp;
779 /* Use spare if excess pool was insufficient */
780 vio_cmo.spare -= size - tmp;
782 /* Update bus accounting */
784 vio_cmo.desired += viodev->cmo.desired;
786 spin_unlock_irqrestore(&vio_cmo.lock, flags);
791 * vio_cmo_bus_remove - Handle CMO specific bus removal activities
793 * @viodev - Pointer to struct vio_dev for device
795 * Remove the device from the cmo device list. The minimum entitlement
796 * will be reserved for the device as long as it is in the system. The
797 * rest of the entitlement the device had been allocated will be returned
800 static void vio_cmo_bus_remove(struct vio_dev *viodev)
802 struct vio_cmo_dev_entry *dev_ent;
806 spin_lock_irqsave(&vio_cmo.lock, flags);
807 if (viodev->cmo.allocated) {
808 dev_err(&viodev->dev, "%s: device had %lu bytes of IO "
809 "allocated after remove operation.\n",
810 __func__, viodev->cmo.allocated);
815 * Remove the device from the device list being maintained for
816 * CMO enabled devices.
818 list_for_each_entry(dev_ent, &vio_cmo.device_list, list)
819 if (viodev == dev_ent->viodev) {
820 list_del(&dev_ent->list);
826 * Devices may not require any entitlement and they do not need
827 * to be processed. Otherwise, return the device's entitlement
830 if (viodev->cmo.entitled) {
832 * This device has not yet left the OF tree, it's
833 * minimum entitlement remains in vio_cmo.min and
836 vio_cmo.desired -= (viodev->cmo.desired - VIO_CMO_MIN_ENT);
839 * Save min allocation for device in reserve as long
840 * as it exists in OF tree as determined by later
843 viodev->cmo.entitled -= VIO_CMO_MIN_ENT;
845 /* Replenish spare from freed reserve pool */
846 if (viodev->cmo.entitled && (vio_cmo.spare < VIO_CMO_MIN_ENT)) {
847 tmp = min(viodev->cmo.entitled, (VIO_CMO_MIN_ENT -
849 vio_cmo.spare += tmp;
850 viodev->cmo.entitled -= tmp;
853 /* Remaining reserve goes to excess pool */
854 vio_cmo.excess.size += viodev->cmo.entitled;
855 vio_cmo.excess.free += viodev->cmo.entitled;
856 vio_cmo.reserve.size -= viodev->cmo.entitled;
859 * Until the device is removed it will keep a
860 * minimum entitlement; this will guarantee that
861 * a module unload/load will result in a success.
863 viodev->cmo.entitled = VIO_CMO_MIN_ENT;
864 viodev->cmo.desired = VIO_CMO_MIN_ENT;
865 atomic_set(&viodev->cmo.allocs_failed, 0);
868 spin_unlock_irqrestore(&vio_cmo.lock, flags);
871 static void vio_cmo_set_dma_ops(struct vio_dev *viodev)
873 set_dma_ops(&viodev->dev, &vio_dma_mapping_ops);
877 * vio_cmo_bus_init - CMO entitlement initialization at bus init time
879 * Set up the reserve and excess entitlement pools based on available
880 * system entitlement and the number of devices in the OF tree that
881 * require entitlement in the reserve pool.
883 static void vio_cmo_bus_init(void)
885 struct hvcall_mpp_data mpp_data;
888 memset(&vio_cmo, 0, sizeof(struct vio_cmo));
889 spin_lock_init(&vio_cmo.lock);
890 INIT_LIST_HEAD(&vio_cmo.device_list);
891 INIT_DELAYED_WORK(&vio_cmo.balance_q, vio_cmo_balance);
893 /* Get current system entitlement */
894 err = h_get_mpp(&mpp_data);
897 * On failure, continue with entitlement set to 0, will panic()
898 * later when spare is reserved.
900 if (err != H_SUCCESS) {
901 printk(KERN_ERR "%s: unable to determine system IO "\
902 "entitlement. (%d)\n", __func__, err);
903 vio_cmo.entitled = 0;
905 vio_cmo.entitled = mpp_data.entitled_mem;
908 /* Set reservation and check against entitlement */
909 vio_cmo.spare = VIO_CMO_MIN_ENT;
910 vio_cmo.reserve.size = vio_cmo.spare;
911 vio_cmo.reserve.size += (vio_cmo_num_OF_devs() *
913 if (vio_cmo.reserve.size > vio_cmo.entitled) {
914 printk(KERN_ERR "%s: insufficient system entitlement\n",
916 panic("%s: Insufficient system entitlement", __func__);
919 /* Set the remaining accounting variables */
920 vio_cmo.excess.size = vio_cmo.entitled - vio_cmo.reserve.size;
921 vio_cmo.excess.free = vio_cmo.excess.size;
922 vio_cmo.min = vio_cmo.reserve.size;
923 vio_cmo.desired = vio_cmo.reserve.size;
926 /* sysfs device functions and data structures for CMO */
928 #define viodev_cmo_rd_attr(name) \
929 static ssize_t viodev_cmo_##name##_show(struct device *dev, \
930 struct device_attribute *attr, \
933 return sprintf(buf, "%lu\n", to_vio_dev(dev)->cmo.name); \
936 static ssize_t viodev_cmo_allocs_failed_show(struct device *dev,
937 struct device_attribute *attr, char *buf)
939 struct vio_dev *viodev = to_vio_dev(dev);
940 return sprintf(buf, "%d\n", atomic_read(&viodev->cmo.allocs_failed));
943 static ssize_t viodev_cmo_allocs_failed_reset(struct device *dev,
944 struct device_attribute *attr, const char *buf, size_t count)
946 struct vio_dev *viodev = to_vio_dev(dev);
947 atomic_set(&viodev->cmo.allocs_failed, 0);
951 static ssize_t viodev_cmo_desired_set(struct device *dev,
952 struct device_attribute *attr, const char *buf, size_t count)
954 struct vio_dev *viodev = to_vio_dev(dev);
958 ret = strict_strtoul(buf, 10, &new_desired);
962 vio_cmo_set_dev_desired(viodev, new_desired);
966 viodev_cmo_rd_attr(desired);
967 viodev_cmo_rd_attr(entitled);
968 viodev_cmo_rd_attr(allocated);
970 static ssize_t name_show(struct device *, struct device_attribute *, char *);
971 static ssize_t devspec_show(struct device *, struct device_attribute *, char *);
972 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
974 static struct device_attribute vio_cmo_dev_attrs[] = {
978 __ATTR(cmo_desired, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
979 viodev_cmo_desired_show, viodev_cmo_desired_set),
980 __ATTR(cmo_entitled, S_IRUGO, viodev_cmo_entitled_show, NULL),
981 __ATTR(cmo_allocated, S_IRUGO, viodev_cmo_allocated_show, NULL),
982 __ATTR(cmo_allocs_failed, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
983 viodev_cmo_allocs_failed_show, viodev_cmo_allocs_failed_reset),
987 /* sysfs bus functions and data structures for CMO */
989 #define viobus_cmo_rd_attr(name) \
991 viobus_cmo_##name##_show(struct bus_type *bt, char *buf) \
993 return sprintf(buf, "%lu\n", vio_cmo.name); \
996 #define viobus_cmo_pool_rd_attr(name, var) \
998 viobus_cmo_##name##_pool_show_##var(struct bus_type *bt, char *buf) \
1000 return sprintf(buf, "%lu\n", vio_cmo.name.var); \
1003 static ssize_t viobus_cmo_high_reset(struct bus_type *bt, const char *buf,
1006 unsigned long flags;
1008 spin_lock_irqsave(&vio_cmo.lock, flags);
1009 vio_cmo.high = vio_cmo.curr;
1010 spin_unlock_irqrestore(&vio_cmo.lock, flags);
1015 viobus_cmo_rd_attr(entitled);
1016 viobus_cmo_pool_rd_attr(reserve, size);
1017 viobus_cmo_pool_rd_attr(excess, size);
1018 viobus_cmo_pool_rd_attr(excess, free);
1019 viobus_cmo_rd_attr(spare);
1020 viobus_cmo_rd_attr(min);
1021 viobus_cmo_rd_attr(desired);
1022 viobus_cmo_rd_attr(curr);
1023 viobus_cmo_rd_attr(high);
1025 static struct bus_attribute vio_cmo_bus_attrs[] = {
1026 __ATTR(cmo_entitled, S_IRUGO, viobus_cmo_entitled_show, NULL),
1027 __ATTR(cmo_reserve_size, S_IRUGO, viobus_cmo_reserve_pool_show_size, NULL),
1028 __ATTR(cmo_excess_size, S_IRUGO, viobus_cmo_excess_pool_show_size, NULL),
1029 __ATTR(cmo_excess_free, S_IRUGO, viobus_cmo_excess_pool_show_free, NULL),
1030 __ATTR(cmo_spare, S_IRUGO, viobus_cmo_spare_show, NULL),
1031 __ATTR(cmo_min, S_IRUGO, viobus_cmo_min_show, NULL),
1032 __ATTR(cmo_desired, S_IRUGO, viobus_cmo_desired_show, NULL),
1033 __ATTR(cmo_curr, S_IRUGO, viobus_cmo_curr_show, NULL),
1034 __ATTR(cmo_high, S_IWUSR|S_IRUSR|S_IWGRP|S_IRGRP|S_IROTH,
1035 viobus_cmo_high_show, viobus_cmo_high_reset),
1039 static void vio_cmo_sysfs_init(void)
1041 vio_bus_type.dev_attrs = vio_cmo_dev_attrs;
1042 vio_bus_type.bus_attrs = vio_cmo_bus_attrs;
1044 #else /* CONFIG_PPC_SMLPAR */
1045 /* Dummy functions for iSeries platform */
1046 int vio_cmo_entitlement_update(size_t new_entitlement) { return 0; }
1047 void vio_cmo_set_dev_desired(struct vio_dev *viodev, size_t desired) {}
1048 static int vio_cmo_bus_probe(struct vio_dev *viodev) { return 0; }
1049 static void vio_cmo_bus_remove(struct vio_dev *viodev) {}
1050 static void vio_cmo_set_dma_ops(struct vio_dev *viodev) {}
1051 static void vio_cmo_bus_init(void) {}
1052 static void vio_cmo_sysfs_init(void) { }
1053 #endif /* CONFIG_PPC_SMLPAR */
1054 EXPORT_SYMBOL(vio_cmo_entitlement_update);
1055 EXPORT_SYMBOL(vio_cmo_set_dev_desired);
1057 static struct iommu_table *vio_build_iommu_table(struct vio_dev *dev)
1059 const unsigned char *dma_window;
1060 struct iommu_table *tbl;
1061 unsigned long offset, size;
1063 if (firmware_has_feature(FW_FEATURE_ISERIES))
1064 return vio_build_iommu_table_iseries(dev);
1066 dma_window = of_get_property(dev->dev.of_node,
1067 "ibm,my-dma-window", NULL);
1071 tbl = kzalloc(sizeof(*tbl), GFP_KERNEL);
1075 of_parse_dma_window(dev->dev.of_node, dma_window,
1076 &tbl->it_index, &offset, &size);
1078 /* TCE table size - measured in tce entries */
1079 tbl->it_size = size >> IOMMU_PAGE_SHIFT;
1080 /* offset for VIO should always be 0 */
1081 tbl->it_offset = offset >> IOMMU_PAGE_SHIFT;
1083 tbl->it_type = TCE_VB;
1084 tbl->it_blocksize = 16;
1086 return iommu_init_table(tbl, -1);
1090 * vio_match_device: - Tell if a VIO device has a matching
1091 * VIO device id structure.
1092 * @ids: array of VIO device id structures to search in
1093 * @dev: the VIO device structure to match against
1095 * Used by a driver to check whether a VIO device present in the
1096 * system is in its list of supported devices. Returns the matching
1097 * vio_device_id structure or NULL if there is no match.
1099 static const struct vio_device_id *vio_match_device(
1100 const struct vio_device_id *ids, const struct vio_dev *dev)
1102 while (ids->type[0] != '\0') {
1103 if ((strncmp(dev->type, ids->type, strlen(ids->type)) == 0) &&
1104 of_device_is_compatible(dev->dev.of_node,
1113 * Convert from struct device to struct vio_dev and pass to driver.
1114 * dev->driver has already been set by generic code because vio_bus_match
1117 static int vio_bus_probe(struct device *dev)
1119 struct vio_dev *viodev = to_vio_dev(dev);
1120 struct vio_driver *viodrv = to_vio_driver(dev->driver);
1121 const struct vio_device_id *id;
1122 int error = -ENODEV;
1127 id = vio_match_device(viodrv->id_table, viodev);
1129 memset(&viodev->cmo, 0, sizeof(viodev->cmo));
1130 if (firmware_has_feature(FW_FEATURE_CMO)) {
1131 error = vio_cmo_bus_probe(viodev);
1135 error = viodrv->probe(viodev, id);
1136 if (error && firmware_has_feature(FW_FEATURE_CMO))
1137 vio_cmo_bus_remove(viodev);
1143 /* convert from struct device to struct vio_dev and pass to driver. */
1144 static int vio_bus_remove(struct device *dev)
1146 struct vio_dev *viodev = to_vio_dev(dev);
1147 struct vio_driver *viodrv = to_vio_driver(dev->driver);
1148 struct device *devptr;
1152 * Hold a reference to the device after the remove function is called
1153 * to allow for CMO accounting cleanup for the device.
1155 devptr = get_device(dev);
1158 ret = viodrv->remove(viodev);
1160 if (!ret && firmware_has_feature(FW_FEATURE_CMO))
1161 vio_cmo_bus_remove(viodev);
1168 * vio_register_driver: - Register a new vio driver
1169 * @drv: The vio_driver structure to be registered.
1171 int vio_register_driver(struct vio_driver *viodrv)
1173 printk(KERN_DEBUG "%s: driver %s registering\n", __func__,
1174 viodrv->driver.name);
1176 /* fill in 'struct driver' fields */
1177 viodrv->driver.bus = &vio_bus_type;
1179 return driver_register(&viodrv->driver);
1181 EXPORT_SYMBOL(vio_register_driver);
1184 * vio_unregister_driver - Remove registration of vio driver.
1185 * @driver: The vio_driver struct to be removed form registration
1187 void vio_unregister_driver(struct vio_driver *viodrv)
1189 driver_unregister(&viodrv->driver);
1191 EXPORT_SYMBOL(vio_unregister_driver);
1193 /* vio_dev refcount hit 0 */
1194 static void __devinit vio_dev_release(struct device *dev)
1196 struct iommu_table *tbl = get_iommu_table_base(dev);
1198 /* iSeries uses a common table for all vio devices */
1199 if (!firmware_has_feature(FW_FEATURE_ISERIES) && tbl)
1200 iommu_free_table(tbl, dev->of_node ?
1201 dev->of_node->full_name : dev_name(dev));
1202 of_node_put(dev->of_node);
1203 kfree(to_vio_dev(dev));
1207 * vio_register_device_node: - Register a new vio device.
1208 * @of_node: The OF node for this device.
1210 * Creates and initializes a vio_dev structure from the data in
1211 * of_node and adds it to the list of virtual devices.
1212 * Returns a pointer to the created vio_dev or NULL if node has
1213 * NULL device_type or compatible fields.
1215 struct vio_dev *vio_register_device_node(struct device_node *of_node)
1217 struct vio_dev *viodev;
1218 const unsigned int *unit_address;
1220 /* we need the 'device_type' property, in order to match with drivers */
1221 if (of_node->type == NULL) {
1222 printk(KERN_WARNING "%s: node %s missing 'device_type'\n",
1224 of_node->name ? of_node->name : "<unknown>");
1228 unit_address = of_get_property(of_node, "reg", NULL);
1229 if (unit_address == NULL) {
1230 printk(KERN_WARNING "%s: node %s missing 'reg'\n",
1232 of_node->name ? of_node->name : "<unknown>");
1236 /* allocate a vio_dev for this node */
1237 viodev = kzalloc(sizeof(struct vio_dev), GFP_KERNEL);
1241 viodev->irq = irq_of_parse_and_map(of_node, 0);
1243 dev_set_name(&viodev->dev, "%x", *unit_address);
1244 viodev->name = of_node->name;
1245 viodev->type = of_node->type;
1246 viodev->unit_address = *unit_address;
1247 if (firmware_has_feature(FW_FEATURE_ISERIES)) {
1248 unit_address = of_get_property(of_node,
1249 "linux,unit_address", NULL);
1250 if (unit_address != NULL)
1251 viodev->unit_address = *unit_address;
1253 viodev->dev.of_node = of_node_get(of_node);
1255 if (firmware_has_feature(FW_FEATURE_CMO))
1256 vio_cmo_set_dma_ops(viodev);
1258 set_dma_ops(&viodev->dev, &dma_iommu_ops);
1259 set_iommu_table_base(&viodev->dev, vio_build_iommu_table(viodev));
1260 set_dev_node(&viodev->dev, of_node_to_nid(of_node));
1262 /* init generic 'struct device' fields: */
1263 viodev->dev.parent = &vio_bus_device.dev;
1264 viodev->dev.bus = &vio_bus_type;
1265 viodev->dev.release = vio_dev_release;
1266 /* needed to ensure proper operation of coherent allocations
1267 * later, in case driver doesn't set it explicitly */
1268 dma_set_mask(&viodev->dev, DMA_BIT_MASK(64));
1269 dma_set_coherent_mask(&viodev->dev, DMA_BIT_MASK(64));
1271 /* register with generic device framework */
1272 if (device_register(&viodev->dev)) {
1273 printk(KERN_ERR "%s: failed to register device %s\n",
1274 __func__, dev_name(&viodev->dev));
1275 put_device(&viodev->dev);
1281 EXPORT_SYMBOL(vio_register_device_node);
1284 * vio_bus_init: - Initialize the virtual IO bus
1286 static int __init vio_bus_init(void)
1289 struct device_node *node_vroot;
1291 if (firmware_has_feature(FW_FEATURE_CMO))
1292 vio_cmo_sysfs_init();
1294 err = bus_register(&vio_bus_type);
1296 printk(KERN_ERR "failed to register VIO bus\n");
1301 * The fake parent of all vio devices, just to give us
1304 err = device_register(&vio_bus_device.dev);
1306 printk(KERN_WARNING "%s: device_register returned %i\n",
1311 if (firmware_has_feature(FW_FEATURE_CMO))
1314 node_vroot = of_find_node_by_name(NULL, "vdevice");
1316 struct device_node *of_node;
1319 * Create struct vio_devices for each virtual device in
1320 * the device tree. Drivers will associate with them later.
1322 for (of_node = node_vroot->child; of_node != NULL;
1323 of_node = of_node->sibling)
1324 vio_register_device_node(of_node);
1325 of_node_put(node_vroot);
1330 __initcall(vio_bus_init);
1332 static ssize_t name_show(struct device *dev,
1333 struct device_attribute *attr, char *buf)
1335 return sprintf(buf, "%s\n", to_vio_dev(dev)->name);
1338 static ssize_t devspec_show(struct device *dev,
1339 struct device_attribute *attr, char *buf)
1341 struct device_node *of_node = dev->of_node;
1343 return sprintf(buf, "%s\n", of_node ? of_node->full_name : "none");
1346 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
1349 const struct vio_dev *vio_dev = to_vio_dev(dev);
1350 struct device_node *dn;
1356 cp = of_get_property(dn, "compatible", NULL);
1360 return sprintf(buf, "vio:T%sS%s\n", vio_dev->type, cp);
1363 static struct device_attribute vio_dev_attrs[] = {
1366 __ATTR_RO(modalias),
1370 void __devinit vio_unregister_device(struct vio_dev *viodev)
1372 device_unregister(&viodev->dev);
1374 EXPORT_SYMBOL(vio_unregister_device);
1376 static int vio_bus_match(struct device *dev, struct device_driver *drv)
1378 const struct vio_dev *vio_dev = to_vio_dev(dev);
1379 struct vio_driver *vio_drv = to_vio_driver(drv);
1380 const struct vio_device_id *ids = vio_drv->id_table;
1382 return (ids != NULL) && (vio_match_device(ids, vio_dev) != NULL);
1385 static int vio_hotplug(struct device *dev, struct kobj_uevent_env *env)
1387 const struct vio_dev *vio_dev = to_vio_dev(dev);
1388 struct device_node *dn;
1394 cp = of_get_property(dn, "compatible", NULL);
1398 add_uevent_var(env, "MODALIAS=vio:T%sS%s", vio_dev->type, cp);
1402 static struct bus_type vio_bus_type = {
1404 .dev_attrs = vio_dev_attrs,
1405 .uevent = vio_hotplug,
1406 .match = vio_bus_match,
1407 .probe = vio_bus_probe,
1408 .remove = vio_bus_remove,
1412 * vio_get_attribute: - get attribute for virtual device
1413 * @vdev: The vio device to get property.
1414 * @which: The property/attribute to be extracted.
1415 * @length: Pointer to length of returned data size (unused if NULL).
1417 * Calls prom.c's of_get_property() to return the value of the
1418 * attribute specified by @which
1420 const void *vio_get_attribute(struct vio_dev *vdev, char *which, int *length)
1422 return of_get_property(vdev->dev.of_node, which, length);
1424 EXPORT_SYMBOL(vio_get_attribute);
1426 #ifdef CONFIG_PPC_PSERIES
1427 /* vio_find_name() - internal because only vio.c knows how we formatted the
1430 static struct vio_dev *vio_find_name(const char *name)
1432 struct device *found;
1434 found = bus_find_device_by_name(&vio_bus_type, NULL, name);
1438 return to_vio_dev(found);
1442 * vio_find_node - find an already-registered vio_dev
1443 * @vnode: device_node of the virtual device we're looking for
1445 struct vio_dev *vio_find_node(struct device_node *vnode)
1447 const uint32_t *unit_address;
1450 /* construct the kobject name from the device node */
1451 unit_address = of_get_property(vnode, "reg", NULL);
1454 snprintf(kobj_name, sizeof(kobj_name), "%x", *unit_address);
1456 return vio_find_name(kobj_name);
1458 EXPORT_SYMBOL(vio_find_node);
1460 int vio_enable_interrupts(struct vio_dev *dev)
1462 int rc = h_vio_signal(dev->unit_address, VIO_IRQ_ENABLE);
1463 if (rc != H_SUCCESS)
1464 printk(KERN_ERR "vio: Error 0x%x enabling interrupts\n", rc);
1467 EXPORT_SYMBOL(vio_enable_interrupts);
1469 int vio_disable_interrupts(struct vio_dev *dev)
1471 int rc = h_vio_signal(dev->unit_address, VIO_IRQ_DISABLE);
1472 if (rc != H_SUCCESS)
1473 printk(KERN_ERR "vio: Error 0x%x disabling interrupts\n", rc);
1476 EXPORT_SYMBOL(vio_disable_interrupts);
1477 #endif /* CONFIG_PPC_PSERIES */