1562 lines · c
1// SPDX-License-Identifier: MIT2/*3 * vgaarb.c: Implements VGA arbitration. For details refer to4 * Documentation/gpu/vgaarbiter.rst5 *6 * (C) Copyright 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>7 * (C) Copyright 2007 Paulo R. Zanoni <przanoni@gmail.com>8 * (C) Copyright 2007, 2009 Tiago Vignatti <vignatti@freedesktop.org>9 */10 11#define pr_fmt(fmt) "vgaarb: " fmt12 13#define vgaarb_dbg(dev, fmt, arg...) dev_dbg(dev, "vgaarb: " fmt, ##arg)14#define vgaarb_info(dev, fmt, arg...) dev_info(dev, "vgaarb: " fmt, ##arg)15#define vgaarb_err(dev, fmt, arg...) dev_err(dev, "vgaarb: " fmt, ##arg)16 17#include <linux/module.h>18#include <linux/kernel.h>19#include <linux/pci.h>20#include <linux/errno.h>21#include <linux/init.h>22#include <linux/list.h>23#include <linux/sched/signal.h>24#include <linux/wait.h>25#include <linux/spinlock.h>26#include <linux/poll.h>27#include <linux/miscdevice.h>28#include <linux/slab.h>29#include <linux/screen_info.h>30#include <linux/vt.h>31#include <linux/console.h>32#include <linux/acpi.h>33#include <linux/uaccess.h>34#include <linux/vgaarb.h>35 36static void vga_arbiter_notify_clients(void);37 38/*39 * We keep a list of all VGA devices in the system to speed40 * up the various operations of the arbiter41 */42struct vga_device {43 struct list_head list;44 struct pci_dev *pdev;45 unsigned int decodes; /* what it decodes */46 unsigned int owns; /* what it owns */47 unsigned int locks; /* what it locks */48 unsigned int io_lock_cnt; /* legacy IO lock count */49 unsigned int mem_lock_cnt; /* legacy MEM lock count */50 unsigned int io_norm_cnt; /* normal IO count */51 unsigned int mem_norm_cnt; /* normal MEM count */52 bool bridge_has_one_vga;53 bool is_firmware_default; /* device selected by firmware */54 unsigned int (*set_decode)(struct pci_dev *pdev, bool decode);55};56 57static LIST_HEAD(vga_list);58static int vga_count, vga_decode_count;59static bool vga_arbiter_used;60static DEFINE_SPINLOCK(vga_lock);61static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);62 63static const char *vga_iostate_to_str(unsigned int iostate)64{65 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */66 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;67 switch (iostate) {68 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:69 return "io+mem";70 case VGA_RSRC_LEGACY_IO:71 return "io";72 case VGA_RSRC_LEGACY_MEM:73 return "mem";74 }75 return "none";76}77 78static int vga_str_to_iostate(char *buf, int str_size, unsigned int *io_state)79{80 /*81 * In theory, we could hand out locks on IO and MEM separately to82 * userspace, but this can cause deadlocks.83 */84 if (strncmp(buf, "none", 4) == 0) {85 *io_state = VGA_RSRC_NONE;86 return 1;87 }88 89 /* XXX We're not checking the str_size! */90 if (strncmp(buf, "io+mem", 6) == 0)91 goto both;92 else if (strncmp(buf, "io", 2) == 0)93 goto both;94 else if (strncmp(buf, "mem", 3) == 0)95 goto both;96 return 0;97both:98 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;99 return 1;100}101 102/* This is only used as a cookie, it should not be dereferenced */103static struct pci_dev *vga_default;104 105/* Find somebody in our list */106static struct vga_device *vgadev_find(struct pci_dev *pdev)107{108 struct vga_device *vgadev;109 110 list_for_each_entry(vgadev, &vga_list, list)111 if (pdev == vgadev->pdev)112 return vgadev;113 return NULL;114}115 116/**117 * vga_default_device - return the default VGA device, for vgacon118 *119 * This can be defined by the platform. The default implementation is120 * rather dumb and will probably only work properly on single VGA card121 * setups and/or x86 platforms.122 *123 * If your VGA default device is not PCI, you'll have to return NULL here.124 * In this case, I assume it will not conflict with any PCI card. If this125 * is not true, I'll have to define two arch hooks for enabling/disabling126 * the VGA default device if that is possible. This may be a problem with127 * real _ISA_ VGA cards, in addition to a PCI one. I don't know at this128 * point how to deal with that card. Can their IOs be disabled at all? If129 * not, then I suppose it's a matter of having the proper arch hook telling130 * us about it, so we basically never allow anybody to succeed a vga_get().131 */132struct pci_dev *vga_default_device(void)133{134 return vga_default;135}136EXPORT_SYMBOL_GPL(vga_default_device);137 138void vga_set_default_device(struct pci_dev *pdev)139{140 if (vga_default == pdev)141 return;142 143 pci_dev_put(vga_default);144 vga_default = pci_dev_get(pdev);145}146 147/**148 * vga_remove_vgacon - deactivate VGA console149 *150 * Unbind and unregister vgacon in case pdev is the default VGA device.151 * Can be called by GPU drivers on initialization to make sure VGA register152 * access done by vgacon will not disturb the device.153 *154 * @pdev: PCI device.155 */156#if !defined(CONFIG_VGA_CONSOLE)157int vga_remove_vgacon(struct pci_dev *pdev)158{159 return 0;160}161#elif !defined(CONFIG_DUMMY_CONSOLE)162int vga_remove_vgacon(struct pci_dev *pdev)163{164 return -ENODEV;165}166#else167int vga_remove_vgacon(struct pci_dev *pdev)168{169 int ret = 0;170 171 if (pdev != vga_default)172 return 0;173 vgaarb_info(&pdev->dev, "deactivate vga console\n");174 175 console_lock();176 if (con_is_bound(&vga_con))177 ret = do_take_over_console(&dummy_con, 0,178 MAX_NR_CONSOLES - 1, 1);179 if (ret == 0) {180 ret = do_unregister_con_driver(&vga_con);181 182 /* Ignore "already unregistered". */183 if (ret == -ENODEV)184 ret = 0;185 }186 console_unlock();187 188 return ret;189}190#endif191EXPORT_SYMBOL(vga_remove_vgacon);192 193/*194 * If we don't ever use VGA arbitration, we should avoid turning off195 * anything anywhere due to old X servers getting confused about the boot196 * device not being VGA.197 */198static void vga_check_first_use(void)199{200 /*201 * Inform all GPUs in the system that VGA arbitration has occurred202 * so they can disable resources if possible.203 */204 if (!vga_arbiter_used) {205 vga_arbiter_used = true;206 vga_arbiter_notify_clients();207 }208}209 210static struct vga_device *__vga_tryget(struct vga_device *vgadev,211 unsigned int rsrc)212{213 struct device *dev = &vgadev->pdev->dev;214 unsigned int wants, legacy_wants, match;215 struct vga_device *conflict;216 unsigned int pci_bits;217 u32 flags = 0;218 219 /*220 * Account for "normal" resources to lock. If we decode the legacy,221 * counterpart, we need to request it as well222 */223 if ((rsrc & VGA_RSRC_NORMAL_IO) &&224 (vgadev->decodes & VGA_RSRC_LEGACY_IO))225 rsrc |= VGA_RSRC_LEGACY_IO;226 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&227 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))228 rsrc |= VGA_RSRC_LEGACY_MEM;229 230 vgaarb_dbg(dev, "%s: %d\n", __func__, rsrc);231 vgaarb_dbg(dev, "%s: owns: %d\n", __func__, vgadev->owns);232 233 /* Check what resources we need to acquire */234 wants = rsrc & ~vgadev->owns;235 236 /* We already own everything, just mark locked & bye bye */237 if (wants == 0)238 goto lock_them;239 240 /*241 * We don't need to request a legacy resource, we just enable242 * appropriate decoding and go.243 */244 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;245 if (legacy_wants == 0)246 goto enable_them;247 248 /* Ok, we don't, let's find out who we need to kick off */249 list_for_each_entry(conflict, &vga_list, list) {250 unsigned int lwants = legacy_wants;251 unsigned int change_bridge = 0;252 253 /* Don't conflict with myself */254 if (vgadev == conflict)255 continue;256 257 /*258 * We have a possible conflict. Before we go further, we must259 * check if we sit on the same bus as the conflicting device.260 * If we don't, then we must tie both IO and MEM resources261 * together since there is only a single bit controlling262 * VGA forwarding on P2P bridges.263 */264 if (vgadev->pdev->bus != conflict->pdev->bus) {265 change_bridge = 1;266 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;267 }268 269 /*270 * Check if the guy has a lock on the resource. If he does,271 * return the conflicting entry.272 */273 if (conflict->locks & lwants)274 return conflict;275 276 /*277 * Ok, now check if it owns the resource we want. We can278 * lock resources that are not decoded; therefore a device279 * can own resources it doesn't decode.280 */281 match = lwants & conflict->owns;282 if (!match)283 continue;284 285 /*286 * Looks like he doesn't have a lock, we can steal them287 * from him.288 */289 290 flags = 0;291 pci_bits = 0;292 293 /*294 * If we can't control legacy resources via the bridge, we295 * also need to disable normal decoding.296 */297 if (!conflict->bridge_has_one_vga) {298 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)299 pci_bits |= PCI_COMMAND_MEMORY;300 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)301 pci_bits |= PCI_COMMAND_IO;302 303 if (pci_bits)304 flags |= PCI_VGA_STATE_CHANGE_DECODES;305 }306 307 if (change_bridge)308 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;309 310 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);311 conflict->owns &= ~match;312 313 /* If we disabled normal decoding, reflect it in owns */314 if (pci_bits & PCI_COMMAND_MEMORY)315 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;316 if (pci_bits & PCI_COMMAND_IO)317 conflict->owns &= ~VGA_RSRC_NORMAL_IO;318 }319 320enable_them:321 /*322 * Ok, we got it, everybody conflicting has been disabled, let's323 * enable us. Mark any bits in "owns" regardless of whether we324 * decoded them. We can lock resources we don't decode, therefore325 * we must track them via "owns".326 */327 flags = 0;328 pci_bits = 0;329 330 if (!vgadev->bridge_has_one_vga) {331 flags |= PCI_VGA_STATE_CHANGE_DECODES;332 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))333 pci_bits |= PCI_COMMAND_MEMORY;334 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))335 pci_bits |= PCI_COMMAND_IO;336 }337 if (wants & VGA_RSRC_LEGACY_MASK)338 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;339 340 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);341 342 vgadev->owns |= wants;343lock_them:344 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);345 if (rsrc & VGA_RSRC_LEGACY_IO)346 vgadev->io_lock_cnt++;347 if (rsrc & VGA_RSRC_LEGACY_MEM)348 vgadev->mem_lock_cnt++;349 if (rsrc & VGA_RSRC_NORMAL_IO)350 vgadev->io_norm_cnt++;351 if (rsrc & VGA_RSRC_NORMAL_MEM)352 vgadev->mem_norm_cnt++;353 354 return NULL;355}356 357static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)358{359 struct device *dev = &vgadev->pdev->dev;360 unsigned int old_locks = vgadev->locks;361 362 vgaarb_dbg(dev, "%s\n", __func__);363 364 /*365 * Update our counters and account for equivalent legacy resources366 * if we decode them.367 */368 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {369 vgadev->io_norm_cnt--;370 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)371 rsrc |= VGA_RSRC_LEGACY_IO;372 }373 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {374 vgadev->mem_norm_cnt--;375 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)376 rsrc |= VGA_RSRC_LEGACY_MEM;377 }378 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)379 vgadev->io_lock_cnt--;380 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)381 vgadev->mem_lock_cnt--;382 383 /*384 * Just clear lock bits, we do lazy operations so we don't really385 * have to bother about anything else at this point.386 */387 if (vgadev->io_lock_cnt == 0)388 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;389 if (vgadev->mem_lock_cnt == 0)390 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;391 392 /*393 * Kick the wait queue in case somebody was waiting if we actually394 * released something.395 */396 if (old_locks != vgadev->locks)397 wake_up_all(&vga_wait_queue);398}399 400/**401 * vga_get - acquire & lock VGA resources402 * @pdev: PCI device of the VGA card or NULL for the system default403 * @rsrc: bit mask of resources to acquire and lock404 * @interruptible: blocking should be interruptible by signals ?405 *406 * Acquire VGA resources for the given card and mark those resources407 * locked. If the resources requested are "normal" (and not legacy)408 * resources, the arbiter will first check whether the card is doing legacy409 * decoding for that type of resource. If yes, the lock is "converted" into410 * a legacy resource lock.411 *412 * The arbiter will first look for all VGA cards that might conflict and disable413 * their IOs and/or Memory access, including VGA forwarding on P2P bridges if414 * necessary, so that the requested resources can be used. Then, the card is415 * marked as locking these resources and the IO and/or Memory accesses are416 * enabled on the card (including VGA forwarding on parent P2P bridges if any).417 *418 * This function will block if some conflicting card is already locking one of419 * the required resources (or any resource on a different bus segment, since P2P420 * bridges don't differentiate VGA memory and IO afaik). You can indicate421 * whether this blocking should be interruptible by a signal (for userland422 * interface) or not.423 *424 * Must not be called at interrupt time or in atomic context. If the card425 * already owns the resources, the function succeeds. Nested calls are426 * supported (a per-resource counter is maintained)427 *428 * On success, release the VGA resource again with vga_put().429 *430 * Returns:431 *432 * 0 on success, negative error code on failure.433 */434int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)435{436 struct vga_device *vgadev, *conflict;437 unsigned long flags;438 wait_queue_entry_t wait;439 int rc = 0;440 441 vga_check_first_use();442 /* The caller should check for this, but let's be sure */443 if (pdev == NULL)444 pdev = vga_default_device();445 if (pdev == NULL)446 return 0;447 448 for (;;) {449 spin_lock_irqsave(&vga_lock, flags);450 vgadev = vgadev_find(pdev);451 if (vgadev == NULL) {452 spin_unlock_irqrestore(&vga_lock, flags);453 rc = -ENODEV;454 break;455 }456 conflict = __vga_tryget(vgadev, rsrc);457 spin_unlock_irqrestore(&vga_lock, flags);458 if (conflict == NULL)459 break;460 461 /*462 * We have a conflict; we wait until somebody kicks the463 * work queue. Currently we have one work queue that we464 * kick each time some resources are released, but it would465 * be fairly easy to have a per-device one so that we only466 * need to attach to the conflicting device.467 */468 init_waitqueue_entry(&wait, current);469 add_wait_queue(&vga_wait_queue, &wait);470 set_current_state(interruptible ?471 TASK_INTERRUPTIBLE :472 TASK_UNINTERRUPTIBLE);473 if (interruptible && signal_pending(current)) {474 __set_current_state(TASK_RUNNING);475 remove_wait_queue(&vga_wait_queue, &wait);476 rc = -ERESTARTSYS;477 break;478 }479 schedule();480 remove_wait_queue(&vga_wait_queue, &wait);481 }482 return rc;483}484EXPORT_SYMBOL(vga_get);485 486/**487 * vga_tryget - try to acquire & lock legacy VGA resources488 * @pdev: PCI device of VGA card or NULL for system default489 * @rsrc: bit mask of resources to acquire and lock490 *491 * Perform the same operation as vga_get(), but return an error (-EBUSY)492 * instead of blocking if the resources are already locked by another card.493 * Can be called in any context.494 *495 * On success, release the VGA resource again with vga_put().496 *497 * Returns:498 *499 * 0 on success, negative error code on failure.500 */501static int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)502{503 struct vga_device *vgadev;504 unsigned long flags;505 int rc = 0;506 507 vga_check_first_use();508 509 /* The caller should check for this, but let's be sure */510 if (pdev == NULL)511 pdev = vga_default_device();512 if (pdev == NULL)513 return 0;514 spin_lock_irqsave(&vga_lock, flags);515 vgadev = vgadev_find(pdev);516 if (vgadev == NULL) {517 rc = -ENODEV;518 goto bail;519 }520 if (__vga_tryget(vgadev, rsrc))521 rc = -EBUSY;522bail:523 spin_unlock_irqrestore(&vga_lock, flags);524 return rc;525}526 527/**528 * vga_put - release lock on legacy VGA resources529 * @pdev: PCI device of VGA card or NULL for system default530 * @rsrc: bit mask of resource to release531 *532 * Release resources previously locked by vga_get() or vga_tryget(). The533 * resources aren't disabled right away, so that a subsequent vga_get() on534 * the same card will succeed immediately. Resources have a counter, so535 * locks are only released if the counter reaches 0.536 */537void vga_put(struct pci_dev *pdev, unsigned int rsrc)538{539 struct vga_device *vgadev;540 unsigned long flags;541 542 /* The caller should check for this, but let's be sure */543 if (pdev == NULL)544 pdev = vga_default_device();545 if (pdev == NULL)546 return;547 spin_lock_irqsave(&vga_lock, flags);548 vgadev = vgadev_find(pdev);549 if (vgadev == NULL)550 goto bail;551 __vga_put(vgadev, rsrc);552bail:553 spin_unlock_irqrestore(&vga_lock, flags);554}555EXPORT_SYMBOL(vga_put);556 557static bool vga_is_firmware_default(struct pci_dev *pdev)558{559#if defined(CONFIG_X86)560 u64 base = screen_info.lfb_base;561 u64 size = screen_info.lfb_size;562 struct resource *r;563 u64 limit;564 565 /* Select the device owning the boot framebuffer if there is one */566 567 if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)568 base |= (u64)screen_info.ext_lfb_base << 32;569 570 limit = base + size;571 572 /* Does firmware framebuffer belong to us? */573 pci_dev_for_each_resource(pdev, r) {574 if (resource_type(r) != IORESOURCE_MEM)575 continue;576 577 if (!r->start || !r->end)578 continue;579 580 if (base < r->start || limit >= r->end)581 continue;582 583 return true;584 }585#endif586 return false;587}588 589static bool vga_arb_integrated_gpu(struct device *dev)590{591#if defined(CONFIG_ACPI)592 struct acpi_device *adev = ACPI_COMPANION(dev);593 594 return adev && !strcmp(acpi_device_hid(adev), ACPI_VIDEO_HID);595#else596 return false;597#endif598}599 600/*601 * Return true if vgadev is a better default VGA device than the best one602 * we've seen so far.603 */604static bool vga_is_boot_device(struct vga_device *vgadev)605{606 struct vga_device *boot_vga = vgadev_find(vga_default_device());607 struct pci_dev *pdev = vgadev->pdev;608 u16 cmd, boot_cmd;609 610 /*611 * We select the default VGA device in this order:612 * Firmware framebuffer (see vga_arb_select_default_device())613 * Legacy VGA device (owns VGA_RSRC_LEGACY_MASK)614 * Non-legacy integrated device (see vga_arb_select_default_device())615 * Non-legacy discrete device (see vga_arb_select_default_device())616 * Other device (see vga_arb_select_default_device())617 */618 619 /*620 * We always prefer a firmware default device, so if we've already621 * found one, there's no need to consider vgadev.622 */623 if (boot_vga && boot_vga->is_firmware_default)624 return false;625 626 if (vga_is_firmware_default(pdev)) {627 vgadev->is_firmware_default = true;628 return true;629 }630 631 /*632 * A legacy VGA device has MEM and IO enabled and any bridges633 * leading to it have PCI_BRIDGE_CTL_VGA enabled so the legacy634 * resources ([mem 0xa0000-0xbffff], [io 0x3b0-0x3bb], etc) are635 * routed to it.636 *637 * We use the first one we find, so if we've already found one,638 * vgadev is no better.639 */640 if (boot_vga &&641 (boot_vga->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)642 return false;643 644 if ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)645 return true;646 647 /*648 * If we haven't found a legacy VGA device, accept a non-legacy649 * device. It may have either IO or MEM enabled, and bridges may650 * not have PCI_BRIDGE_CTL_VGA enabled, so it may not be able to651 * use legacy VGA resources. Prefer an integrated GPU over others.652 */653 pci_read_config_word(pdev, PCI_COMMAND, &cmd);654 if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {655 656 /*657 * An integrated GPU overrides a previous non-legacy658 * device. We expect only a single integrated GPU, but if659 * there are more, we use the *last* because that was the660 * previous behavior.661 */662 if (vga_arb_integrated_gpu(&pdev->dev))663 return true;664 665 /*666 * We prefer the first non-legacy discrete device we find.667 * If we already found one, vgadev is no better.668 */669 if (boot_vga) {670 pci_read_config_word(boot_vga->pdev, PCI_COMMAND,671 &boot_cmd);672 if (boot_cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))673 return false;674 }675 return true;676 }677 678 /*679 * Vgadev has neither IO nor MEM enabled. If we haven't found any680 * other VGA devices, it is the best candidate so far.681 */682 if (!boot_vga)683 return true;684 685 return false;686}687 688/*689 * Rules for using a bridge to control a VGA descendant decoding: if a bridge690 * has only one VGA descendant then it can be used to control the VGA routing691 * for that device. It should always use the bridge closest to the device to692 * control it. If a bridge has a direct VGA descendant, but also have a sub-693 * bridge VGA descendant then we cannot use that bridge to control the direct694 * VGA descendant. So for every device we register, we need to iterate all695 * its parent bridges so we can invalidate any devices using them properly.696 */697static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)698{699 struct vga_device *same_bridge_vgadev;700 struct pci_bus *new_bus, *bus;701 struct pci_dev *new_bridge, *bridge;702 703 vgadev->bridge_has_one_vga = true;704 705 if (list_empty(&vga_list)) {706 vgaarb_info(&vgadev->pdev->dev, "bridge control possible\n");707 return;708 }709 710 /* Iterate the new device's bridge hierarchy */711 new_bus = vgadev->pdev->bus;712 while (new_bus) {713 new_bridge = new_bus->self;714 715 /* Go through list of devices already registered */716 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {717 bus = same_bridge_vgadev->pdev->bus;718 bridge = bus->self;719 720 /* See if it shares a bridge with this device */721 if (new_bridge == bridge) {722 /*723 * If its direct parent bridge is the same724 * as any bridge of this device then it can't725 * be used for that device.726 */727 same_bridge_vgadev->bridge_has_one_vga = false;728 }729 730 /*731 * Now iterate the previous device's bridge hierarchy.732 * If the new device's parent bridge is in the other733 * device's hierarchy, we can't use it to control this734 * device.735 */736 while (bus) {737 bridge = bus->self;738 739 if (bridge && bridge == vgadev->pdev->bus->self)740 vgadev->bridge_has_one_vga = false;741 742 bus = bus->parent;743 }744 }745 new_bus = new_bus->parent;746 }747 748 if (vgadev->bridge_has_one_vga)749 vgaarb_info(&vgadev->pdev->dev, "bridge control possible\n");750 else751 vgaarb_info(&vgadev->pdev->dev, "no bridge control possible\n");752}753 754/*755 * Currently, we assume that the "initial" setup of the system is not sane,756 * that is, we come up with conflicting devices and let the arbiter's757 * client decide if devices decodes legacy things or not.758 */759static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)760{761 struct vga_device *vgadev;762 unsigned long flags;763 struct pci_bus *bus;764 struct pci_dev *bridge;765 u16 cmd;766 767 /* Allocate structure */768 vgadev = kzalloc(sizeof(struct vga_device), GFP_KERNEL);769 if (vgadev == NULL) {770 vgaarb_err(&pdev->dev, "failed to allocate VGA arbiter data\n");771 /*772 * What to do on allocation failure? For now, let's just do773 * nothing, I'm not sure there is anything saner to be done.774 */775 return false;776 }777 778 /* Take lock & check for duplicates */779 spin_lock_irqsave(&vga_lock, flags);780 if (vgadev_find(pdev) != NULL) {781 BUG_ON(1);782 goto fail;783 }784 vgadev->pdev = pdev;785 786 /* By default, assume we decode everything */787 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |788 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;789 790 /* By default, mark it as decoding */791 vga_decode_count++;792 793 /*794 * Mark that we "own" resources based on our enables, we will795 * clear that below if the bridge isn't forwarding.796 */797 pci_read_config_word(pdev, PCI_COMMAND, &cmd);798 if (cmd & PCI_COMMAND_IO)799 vgadev->owns |= VGA_RSRC_LEGACY_IO;800 if (cmd & PCI_COMMAND_MEMORY)801 vgadev->owns |= VGA_RSRC_LEGACY_MEM;802 803 /* Check if VGA cycles can get down to us */804 bus = pdev->bus;805 while (bus) {806 bridge = bus->self;807 if (bridge) {808 u16 l;809 810 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &l);811 if (!(l & PCI_BRIDGE_CTL_VGA)) {812 vgadev->owns = 0;813 break;814 }815 }816 bus = bus->parent;817 }818 819 if (vga_is_boot_device(vgadev)) {820 vgaarb_info(&pdev->dev, "setting as boot VGA device%s\n",821 vga_default_device() ?822 " (overriding previous)" : "");823 vga_set_default_device(pdev);824 }825 826 vga_arbiter_check_bridge_sharing(vgadev);827 828 /* Add to the list */829 list_add_tail(&vgadev->list, &vga_list);830 vga_count++;831 vgaarb_info(&pdev->dev, "VGA device added: decodes=%s,owns=%s,locks=%s\n",832 vga_iostate_to_str(vgadev->decodes),833 vga_iostate_to_str(vgadev->owns),834 vga_iostate_to_str(vgadev->locks));835 836 spin_unlock_irqrestore(&vga_lock, flags);837 return true;838fail:839 spin_unlock_irqrestore(&vga_lock, flags);840 kfree(vgadev);841 return false;842}843 844static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)845{846 struct vga_device *vgadev;847 unsigned long flags;848 bool ret = true;849 850 spin_lock_irqsave(&vga_lock, flags);851 vgadev = vgadev_find(pdev);852 if (vgadev == NULL) {853 ret = false;854 goto bail;855 }856 857 if (vga_default == pdev)858 vga_set_default_device(NULL);859 860 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))861 vga_decode_count--;862 863 /* Remove entry from list */864 list_del(&vgadev->list);865 vga_count--;866 867 /* Wake up all possible waiters */868 wake_up_all(&vga_wait_queue);869bail:870 spin_unlock_irqrestore(&vga_lock, flags);871 kfree(vgadev);872 return ret;873}874 875/* Called with the lock */876static void vga_update_device_decodes(struct vga_device *vgadev,877 unsigned int new_decodes)878{879 struct device *dev = &vgadev->pdev->dev;880 unsigned int old_decodes = vgadev->decodes;881 unsigned int decodes_removed = ~new_decodes & old_decodes;882 unsigned int decodes_unlocked = vgadev->locks & decodes_removed;883 884 vgadev->decodes = new_decodes;885 886 vgaarb_info(dev, "VGA decodes changed: olddecodes=%s,decodes=%s:owns=%s\n",887 vga_iostate_to_str(old_decodes),888 vga_iostate_to_str(vgadev->decodes),889 vga_iostate_to_str(vgadev->owns));890 891 /* If we removed locked decodes, lock count goes to zero, and release */892 if (decodes_unlocked) {893 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)894 vgadev->io_lock_cnt = 0;895 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)896 vgadev->mem_lock_cnt = 0;897 __vga_put(vgadev, decodes_unlocked);898 }899 900 /* Change decodes counter */901 if (old_decodes & VGA_RSRC_LEGACY_MASK &&902 !(new_decodes & VGA_RSRC_LEGACY_MASK))903 vga_decode_count--;904 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&905 new_decodes & VGA_RSRC_LEGACY_MASK)906 vga_decode_count++;907 vgaarb_dbg(dev, "decoding count now is: %d\n", vga_decode_count);908}909 910static void __vga_set_legacy_decoding(struct pci_dev *pdev,911 unsigned int decodes,912 bool userspace)913{914 struct vga_device *vgadev;915 unsigned long flags;916 917 decodes &= VGA_RSRC_LEGACY_MASK;918 919 spin_lock_irqsave(&vga_lock, flags);920 vgadev = vgadev_find(pdev);921 if (vgadev == NULL)922 goto bail;923 924 /* Don't let userspace futz with kernel driver decodes */925 if (userspace && vgadev->set_decode)926 goto bail;927 928 /* Update the device decodes + counter */929 vga_update_device_decodes(vgadev, decodes);930 931 /*932 * XXX If somebody is going from "doesn't decode" to "decodes"933 * state here, additional care must be taken as we may have pending934 * ownership of non-legacy region.935 */936bail:937 spin_unlock_irqrestore(&vga_lock, flags);938}939 940/**941 * vga_set_legacy_decoding942 * @pdev: PCI device of the VGA card943 * @decodes: bit mask of what legacy regions the card decodes944 *945 * Indicate to the arbiter if the card decodes legacy VGA IOs, legacy VGA946 * Memory, both, or none. All cards default to both, the card driver (fbdev for947 * example) should tell the arbiter if it has disabled legacy decoding, so the948 * card can be left out of the arbitration process (and can be safe to take949 * interrupts at any time.950 */951void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)952{953 __vga_set_legacy_decoding(pdev, decodes, false);954}955EXPORT_SYMBOL(vga_set_legacy_decoding);956 957/**958 * vga_client_register - register or unregister a VGA arbitration client959 * @pdev: PCI device of the VGA client960 * @set_decode: VGA decode change callback961 *962 * Clients have two callback mechanisms they can use.963 *964 * @set_decode callback: If a client can disable its GPU VGA resource, it965 * will get a callback from this to set the encode/decode state.966 *967 * Rationale: we cannot disable VGA decode resources unconditionally968 * because some single GPU laptops seem to require ACPI or BIOS access to969 * the VGA registers to control things like backlights etc. Hopefully newer970 * multi-GPU laptops do something saner, and desktops won't have any971 * special ACPI for this. The driver will get a callback when VGA972 * arbitration is first used by userspace since some older X servers have973 * issues.974 *975 * Does not check whether a client for @pdev has been registered already.976 *977 * To unregister, call vga_client_unregister().978 *979 * Returns: 0 on success, -ENODEV on failure980 */981int vga_client_register(struct pci_dev *pdev,982 unsigned int (*set_decode)(struct pci_dev *pdev, bool decode))983{984 unsigned long flags;985 struct vga_device *vgadev;986 987 spin_lock_irqsave(&vga_lock, flags);988 vgadev = vgadev_find(pdev);989 if (vgadev)990 vgadev->set_decode = set_decode;991 spin_unlock_irqrestore(&vga_lock, flags);992 if (!vgadev)993 return -ENODEV;994 return 0;995}996EXPORT_SYMBOL(vga_client_register);997 998/*999 * Char driver implementation1000 *1001 * Semantics is:1002 *1003 * open : Open user instance of the arbiter. By default, it's1004 * attached to the default VGA device of the system.1005 *1006 * close : Close user instance, release locks1007 *1008 * read : Return a string indicating the status of the target.1009 * An IO state string is of the form {io,mem,io+mem,none},1010 * mc and ic are respectively mem and io lock counts (for1011 * debugging/diagnostic only). "decodes" indicate what the1012 * card currently decodes, "owns" indicates what is currently1013 * enabled on it, and "locks" indicates what is locked by this1014 * card. If the card is unplugged, we get "invalid" then for1015 * card_ID and an -ENODEV error is returned for any command1016 * until a new card is targeted1017 *1018 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"1019 *1020 * write : write a command to the arbiter. List of commands is:1021 *1022 * target <card_ID> : switch target to card <card_ID> (see below)1023 * lock <io_state> : acquire locks on target ("none" is invalid io_state)1024 * trylock <io_state> : non-blocking acquire locks on target1025 * unlock <io_state> : release locks on target1026 * unlock all : release all locks on target held by this user1027 * decodes <io_state> : set the legacy decoding attributes for the card1028 *1029 * poll : event if something change on any card (not just the target)1030 *1031 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"1032 * to go back to the system default card (TODO: not implemented yet).1033 * Currently, only PCI is supported as a prefix, but the userland API may1034 * support other bus types in the future, even if the current kernel1035 * implementation doesn't.1036 *1037 * Note about locks:1038 *1039 * The driver keeps track of which user has what locks on which card. It1040 * supports stacking, like the kernel one. This complicates the implementation1041 * a bit, but makes the arbiter more tolerant to userspace problems and able1042 * to properly cleanup in all cases when a process dies.1043 * Currently, a max of 16 cards simultaneously can have locks issued from1044 * userspace for a given user (file descriptor instance) of the arbiter.1045 *1046 * If the device is hot-unplugged, there is a hook inside the module to notify1047 * it being added/removed in the system and automatically added/removed in1048 * the arbiter.1049 */1050 1051#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS1052#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)1053 1054/* Each user has an array of these, tracking which cards have locks */1055struct vga_arb_user_card {1056 struct pci_dev *pdev;1057 unsigned int mem_cnt;1058 unsigned int io_cnt;1059};1060 1061struct vga_arb_private {1062 struct list_head list;1063 struct pci_dev *target;1064 struct vga_arb_user_card cards[MAX_USER_CARDS];1065 spinlock_t lock;1066};1067 1068static LIST_HEAD(vga_user_list);1069static DEFINE_SPINLOCK(vga_user_lock);1070 1071 1072/*1073 * Take a string in the format: "PCI:domain:bus:dev.fn" and return the1074 * respective values. If the string is not in this format, return 0.1075 */1076static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,1077 unsigned int *bus, unsigned int *devfn)1078{1079 int n;1080 unsigned int slot, func;1081 1082 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);1083 if (n != 4)1084 return 0;1085 1086 *devfn = PCI_DEVFN(slot, func);1087 1088 return 1;1089}1090 1091static ssize_t vga_arb_read(struct file *file, char __user *buf,1092 size_t count, loff_t *ppos)1093{1094 struct vga_arb_private *priv = file->private_data;1095 struct vga_device *vgadev;1096 struct pci_dev *pdev;1097 unsigned long flags;1098 size_t len;1099 int rc;1100 char *lbuf;1101 1102 lbuf = kmalloc(1024, GFP_KERNEL);1103 if (lbuf == NULL)1104 return -ENOMEM;1105 1106 /* Protect vga_list */1107 spin_lock_irqsave(&vga_lock, flags);1108 1109 /* If we are targeting the default, use it */1110 pdev = priv->target;1111 if (pdev == NULL || pdev == PCI_INVALID_CARD) {1112 spin_unlock_irqrestore(&vga_lock, flags);1113 len = sprintf(lbuf, "invalid");1114 goto done;1115 }1116 1117 /* Find card vgadev structure */1118 vgadev = vgadev_find(pdev);1119 if (vgadev == NULL) {1120 /*1121 * Wow, it's not in the list, that shouldn't happen, let's1122 * fix us up and return invalid card.1123 */1124 spin_unlock_irqrestore(&vga_lock, flags);1125 len = sprintf(lbuf, "invalid");1126 goto done;1127 }1128 1129 /* Fill the buffer with info */1130 len = snprintf(lbuf, 1024,1131 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%u:%u)\n",1132 vga_decode_count, pci_name(pdev),1133 vga_iostate_to_str(vgadev->decodes),1134 vga_iostate_to_str(vgadev->owns),1135 vga_iostate_to_str(vgadev->locks),1136 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);1137 1138 spin_unlock_irqrestore(&vga_lock, flags);1139done:1140 1141 /* Copy that to user */1142 if (len > count)1143 len = count;1144 rc = copy_to_user(buf, lbuf, len);1145 kfree(lbuf);1146 if (rc)1147 return -EFAULT;1148 return len;1149}1150 1151/*1152 * TODO: To avoid parsing inside kernel and to improve the speed we may1153 * consider use ioctl here1154 */1155static ssize_t vga_arb_write(struct file *file, const char __user *buf,1156 size_t count, loff_t *ppos)1157{1158 struct vga_arb_private *priv = file->private_data;1159 struct vga_arb_user_card *uc = NULL;1160 struct pci_dev *pdev;1161 1162 unsigned int io_state;1163 1164 char kbuf[64], *curr_pos;1165 size_t remaining = count;1166 1167 int ret_val;1168 int i;1169 1170 if (count >= sizeof(kbuf))1171 return -EINVAL;1172 if (copy_from_user(kbuf, buf, count))1173 return -EFAULT;1174 curr_pos = kbuf;1175 kbuf[count] = '\0';1176 1177 if (strncmp(curr_pos, "lock ", 5) == 0) {1178 curr_pos += 5;1179 remaining -= 5;1180 1181 pr_debug("client 0x%p called 'lock'\n", priv);1182 1183 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {1184 ret_val = -EPROTO;1185 goto done;1186 }1187 if (io_state == VGA_RSRC_NONE) {1188 ret_val = -EPROTO;1189 goto done;1190 }1191 1192 pdev = priv->target;1193 if (priv->target == NULL) {1194 ret_val = -ENODEV;1195 goto done;1196 }1197 1198 vga_get_uninterruptible(pdev, io_state);1199 1200 /* Update the client's locks lists */1201 for (i = 0; i < MAX_USER_CARDS; i++) {1202 if (priv->cards[i].pdev == pdev) {1203 if (io_state & VGA_RSRC_LEGACY_IO)1204 priv->cards[i].io_cnt++;1205 if (io_state & VGA_RSRC_LEGACY_MEM)1206 priv->cards[i].mem_cnt++;1207 break;1208 }1209 }1210 1211 ret_val = count;1212 goto done;1213 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {1214 curr_pos += 7;1215 remaining -= 7;1216 1217 pr_debug("client 0x%p called 'unlock'\n", priv);1218 1219 if (strncmp(curr_pos, "all", 3) == 0)1220 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;1221 else {1222 if (!vga_str_to_iostate1223 (curr_pos, remaining, &io_state)) {1224 ret_val = -EPROTO;1225 goto done;1226 }1227 /* TODO: Add this?1228 if (io_state == VGA_RSRC_NONE) {1229 ret_val = -EPROTO;1230 goto done;1231 }1232 */1233 }1234 1235 pdev = priv->target;1236 if (priv->target == NULL) {1237 ret_val = -ENODEV;1238 goto done;1239 }1240 for (i = 0; i < MAX_USER_CARDS; i++) {1241 if (priv->cards[i].pdev == pdev)1242 uc = &priv->cards[i];1243 }1244 1245 if (!uc) {1246 ret_val = -EINVAL;1247 goto done;1248 }1249 1250 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {1251 ret_val = -EINVAL;1252 goto done;1253 }1254 1255 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {1256 ret_val = -EINVAL;1257 goto done;1258 }1259 1260 vga_put(pdev, io_state);1261 1262 if (io_state & VGA_RSRC_LEGACY_IO)1263 uc->io_cnt--;1264 if (io_state & VGA_RSRC_LEGACY_MEM)1265 uc->mem_cnt--;1266 1267 ret_val = count;1268 goto done;1269 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {1270 curr_pos += 8;1271 remaining -= 8;1272 1273 pr_debug("client 0x%p called 'trylock'\n", priv);1274 1275 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {1276 ret_val = -EPROTO;1277 goto done;1278 }1279 /* TODO: Add this?1280 if (io_state == VGA_RSRC_NONE) {1281 ret_val = -EPROTO;1282 goto done;1283 }1284 */1285 1286 pdev = priv->target;1287 if (priv->target == NULL) {1288 ret_val = -ENODEV;1289 goto done;1290 }1291 1292 if (vga_tryget(pdev, io_state)) {1293 /* Update the client's locks lists... */1294 for (i = 0; i < MAX_USER_CARDS; i++) {1295 if (priv->cards[i].pdev == pdev) {1296 if (io_state & VGA_RSRC_LEGACY_IO)1297 priv->cards[i].io_cnt++;1298 if (io_state & VGA_RSRC_LEGACY_MEM)1299 priv->cards[i].mem_cnt++;1300 break;1301 }1302 }1303 ret_val = count;1304 goto done;1305 } else {1306 ret_val = -EBUSY;1307 goto done;1308 }1309 1310 } else if (strncmp(curr_pos, "target ", 7) == 0) {1311 unsigned int domain, bus, devfn;1312 struct vga_device *vgadev;1313 1314 curr_pos += 7;1315 remaining -= 7;1316 pr_debug("client 0x%p called 'target'\n", priv);1317 /* If target is default */1318 if (!strncmp(curr_pos, "default", 7))1319 pdev = pci_dev_get(vga_default_device());1320 else {1321 if (!vga_pci_str_to_vars(curr_pos, remaining,1322 &domain, &bus, &devfn)) {1323 ret_val = -EPROTO;1324 goto done;1325 }1326 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);1327 if (!pdev) {1328 pr_debug("invalid PCI address %04x:%02x:%02x.%x\n",1329 domain, bus, PCI_SLOT(devfn),1330 PCI_FUNC(devfn));1331 ret_val = -ENODEV;1332 goto done;1333 }1334 1335 pr_debug("%s ==> %04x:%02x:%02x.%x pdev %p\n", curr_pos,1336 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn),1337 pdev);1338 }1339 1340 vgadev = vgadev_find(pdev);1341 pr_debug("vgadev %p\n", vgadev);1342 if (vgadev == NULL) {1343 if (pdev) {1344 vgaarb_dbg(&pdev->dev, "not a VGA device\n");1345 pci_dev_put(pdev);1346 }1347 1348 ret_val = -ENODEV;1349 goto done;1350 }1351 1352 priv->target = pdev;1353 for (i = 0; i < MAX_USER_CARDS; i++) {1354 if (priv->cards[i].pdev == pdev)1355 break;1356 if (priv->cards[i].pdev == NULL) {1357 priv->cards[i].pdev = pdev;1358 priv->cards[i].io_cnt = 0;1359 priv->cards[i].mem_cnt = 0;1360 break;1361 }1362 }1363 if (i == MAX_USER_CARDS) {1364 vgaarb_dbg(&pdev->dev, "maximum user cards (%d) number reached, ignoring this one!\n",1365 MAX_USER_CARDS);1366 pci_dev_put(pdev);1367 /* XXX: Which value to return? */1368 ret_val = -ENOMEM;1369 goto done;1370 }1371 1372 ret_val = count;1373 pci_dev_put(pdev);1374 goto done;1375 1376 1377 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {1378 curr_pos += 8;1379 remaining -= 8;1380 pr_debug("client 0x%p called 'decodes'\n", priv);1381 1382 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {1383 ret_val = -EPROTO;1384 goto done;1385 }1386 pdev = priv->target;1387 if (priv->target == NULL) {1388 ret_val = -ENODEV;1389 goto done;1390 }1391 1392 __vga_set_legacy_decoding(pdev, io_state, true);1393 ret_val = count;1394 goto done;1395 }1396 /* If we got here, the message written is not part of the protocol! */1397 return -EPROTO;1398 1399done:1400 return ret_val;1401}1402 1403static __poll_t vga_arb_fpoll(struct file *file, poll_table *wait)1404{1405 pr_debug("%s\n", __func__);1406 1407 poll_wait(file, &vga_wait_queue, wait);1408 return EPOLLIN;1409}1410 1411static int vga_arb_open(struct inode *inode, struct file *file)1412{1413 struct vga_arb_private *priv;1414 unsigned long flags;1415 1416 pr_debug("%s\n", __func__);1417 1418 priv = kzalloc(sizeof(*priv), GFP_KERNEL);1419 if (priv == NULL)1420 return -ENOMEM;1421 spin_lock_init(&priv->lock);1422 file->private_data = priv;1423 1424 spin_lock_irqsave(&vga_user_lock, flags);1425 list_add(&priv->list, &vga_user_list);1426 spin_unlock_irqrestore(&vga_user_lock, flags);1427 1428 /* Set the client's lists of locks */1429 priv->target = vga_default_device(); /* Maybe this is still null! */1430 priv->cards[0].pdev = priv->target;1431 priv->cards[0].io_cnt = 0;1432 priv->cards[0].mem_cnt = 0;1433 1434 return 0;1435}1436 1437static int vga_arb_release(struct inode *inode, struct file *file)1438{1439 struct vga_arb_private *priv = file->private_data;1440 struct vga_arb_user_card *uc;1441 unsigned long flags;1442 int i;1443 1444 pr_debug("%s\n", __func__);1445 1446 spin_lock_irqsave(&vga_user_lock, flags);1447 list_del(&priv->list);1448 for (i = 0; i < MAX_USER_CARDS; i++) {1449 uc = &priv->cards[i];1450 if (uc->pdev == NULL)1451 continue;1452 vgaarb_dbg(&uc->pdev->dev, "uc->io_cnt == %d, uc->mem_cnt == %d\n",1453 uc->io_cnt, uc->mem_cnt);1454 while (uc->io_cnt--)1455 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);1456 while (uc->mem_cnt--)1457 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);1458 }1459 spin_unlock_irqrestore(&vga_user_lock, flags);1460 1461 kfree(priv);1462 1463 return 0;1464}1465 1466/*1467 * Callback any registered clients to let them know we have a change in VGA1468 * cards.1469 */1470static void vga_arbiter_notify_clients(void)1471{1472 struct vga_device *vgadev;1473 unsigned long flags;1474 unsigned int new_decodes;1475 bool new_state;1476 1477 if (!vga_arbiter_used)1478 return;1479 1480 new_state = (vga_count > 1) ? false : true;1481 1482 spin_lock_irqsave(&vga_lock, flags);1483 list_for_each_entry(vgadev, &vga_list, list) {1484 if (vgadev->set_decode) {1485 new_decodes = vgadev->set_decode(vgadev->pdev,1486 new_state);1487 vga_update_device_decodes(vgadev, new_decodes);1488 }1489 }1490 spin_unlock_irqrestore(&vga_lock, flags);1491}1492 1493static int pci_notify(struct notifier_block *nb, unsigned long action,1494 void *data)1495{1496 struct device *dev = data;1497 struct pci_dev *pdev = to_pci_dev(dev);1498 bool notify = false;1499 1500 vgaarb_dbg(dev, "%s\n", __func__);1501 1502 /* Only deal with VGA class devices */1503 if (!pci_is_vga(pdev))1504 return 0;1505 1506 /*1507 * For now, we're only interested in devices added and removed.1508 * I didn't test this thing here, so someone needs to double check1509 * for the cases of hot-pluggable VGA cards.1510 */1511 if (action == BUS_NOTIFY_ADD_DEVICE)1512 notify = vga_arbiter_add_pci_device(pdev);1513 else if (action == BUS_NOTIFY_DEL_DEVICE)1514 notify = vga_arbiter_del_pci_device(pdev);1515 1516 if (notify)1517 vga_arbiter_notify_clients();1518 return 0;1519}1520 1521static struct notifier_block pci_notifier = {1522 .notifier_call = pci_notify,1523};1524 1525static const struct file_operations vga_arb_device_fops = {1526 .read = vga_arb_read,1527 .write = vga_arb_write,1528 .poll = vga_arb_fpoll,1529 .open = vga_arb_open,1530 .release = vga_arb_release,1531 .llseek = noop_llseek,1532};1533 1534static struct miscdevice vga_arb_device = {1535 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops1536};1537 1538static int __init vga_arb_device_init(void)1539{1540 int rc;1541 struct pci_dev *pdev;1542 1543 rc = misc_register(&vga_arb_device);1544 if (rc < 0)1545 pr_err("error %d registering device\n", rc);1546 1547 bus_register_notifier(&pci_bus_type, &pci_notifier);1548 1549 /* Add all VGA class PCI devices by default */1550 pdev = NULL;1551 while ((pdev =1552 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,1553 PCI_ANY_ID, pdev)) != NULL) {1554 if (pci_is_vga(pdev))1555 vga_arbiter_add_pci_device(pdev);1556 }1557 1558 pr_info("loaded\n");1559 return rc;1560}1561subsys_initcall_sync(vga_arb_device_init);1562