2 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/vgaarbiter.txt
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>
10 * Permission is hereby granted, free of charge, to any person obtaining a
11 * copy of this software and associated documentation files (the "Software"),
12 * to deal in the Software without restriction, including without limitation
13 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 * and/or sell copies of the Software, and to permit persons to whom the
15 * Software is furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice (including the next
18 * paragraph) shall be included in all copies or substantial portions of the
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/pci.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/list.h>
38 #include <linux/sched.h>
39 #include <linux/wait.h>
40 #include <linux/spinlock.h>
41 #include <linux/poll.h>
42 #include <linux/miscdevice.h>
43 #include <linux/slab.h>
45 #include <linux/uaccess.h>
47 #include <linux/vgaarb.h>
49 static void vga_arbiter_notify_clients(void);
51 * We keep a list of all vga devices in the system to speed
52 * up the various operations of the arbiter
55 struct list_head list;
57 unsigned int decodes; /* what does it decodes */
58 unsigned int owns; /* what does it owns */
59 unsigned int locks; /* what does it locks */
60 unsigned int io_lock_cnt; /* legacy IO lock count */
61 unsigned int mem_lock_cnt; /* legacy MEM lock count */
62 unsigned int io_norm_cnt; /* normal IO count */
63 unsigned int mem_norm_cnt; /* normal MEM count */
64 bool bridge_has_one_vga;
65 /* allow IRQ enable/disable hook */
67 void (*irq_set_state)(void *cookie, bool enable);
68 unsigned int (*set_vga_decode)(void *cookie, bool decode);
71 static LIST_HEAD(vga_list);
72 static int vga_count, vga_decode_count;
73 static bool vga_arbiter_used;
74 static DEFINE_SPINLOCK(vga_lock);
75 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
78 static const char *vga_iostate_to_str(unsigned int iostate)
80 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
81 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
83 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
85 case VGA_RSRC_LEGACY_IO:
87 case VGA_RSRC_LEGACY_MEM:
93 static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
95 /* we could in theory hand out locks on IO and mem
96 * separately to userspace but it can cause deadlocks */
97 if (strncmp(buf, "none", 4) == 0) {
98 *io_state = VGA_RSRC_NONE;
102 /* XXX We're not chekcing the str_size! */
103 if (strncmp(buf, "io+mem", 6) == 0)
105 else if (strncmp(buf, "io", 2) == 0)
107 else if (strncmp(buf, "mem", 3) == 0)
111 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
115 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
116 /* this is only used a cookie - it should not be dereferenced */
117 static struct pci_dev *vga_default;
120 static void vga_arb_device_card_gone(struct pci_dev *pdev);
122 /* Find somebody in our list */
123 static struct vga_device *vgadev_find(struct pci_dev *pdev)
125 struct vga_device *vgadev;
127 list_for_each_entry(vgadev, &vga_list, list)
128 if (pdev == vgadev->pdev)
133 /* Returns the default VGA device (vgacon's babe) */
134 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
135 struct pci_dev *vga_default_device(void)
140 EXPORT_SYMBOL_GPL(vga_default_device);
142 void vga_set_default_device(struct pci_dev *pdev)
144 if (vga_default == pdev)
147 pci_dev_put(vga_default);
148 vga_default = pci_dev_get(pdev);
152 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
154 if (vgadev->irq_set_state)
155 vgadev->irq_set_state(vgadev->cookie, state);
159 /* If we don't ever use VGA arb we should avoid
160 turning off anything anywhere due to old X servers getting
161 confused about the boot device not being VGA */
162 static void vga_check_first_use(void)
164 /* we should inform all GPUs in the system that
165 * VGA arb has occurred and to try and disable resources
167 if (!vga_arbiter_used) {
168 vga_arbiter_used = true;
169 vga_arbiter_notify_clients();
173 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
176 unsigned int wants, legacy_wants, match;
177 struct vga_device *conflict;
178 unsigned int pci_bits;
181 /* Account for "normal" resources to lock. If we decode the legacy,
182 * counterpart, we need to request it as well
184 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
185 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
186 rsrc |= VGA_RSRC_LEGACY_IO;
187 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
188 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
189 rsrc |= VGA_RSRC_LEGACY_MEM;
191 pr_debug("%s: %d\n", __func__, rsrc);
192 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
194 /* Check what resources we need to acquire */
195 wants = rsrc & ~vgadev->owns;
197 /* We already own everything, just mark locked & bye bye */
201 /* We don't need to request a legacy resource, we just enable
202 * appropriate decoding and go
204 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
205 if (legacy_wants == 0)
208 /* Ok, we don't, let's find out how we need to kick off */
209 list_for_each_entry(conflict, &vga_list, list) {
210 unsigned int lwants = legacy_wants;
211 unsigned int change_bridge = 0;
213 /* Don't conflict with myself */
214 if (vgadev == conflict)
217 /* Check if the architecture allows a conflict between those
218 * 2 devices or if they are on separate domains
220 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
223 /* We have a possible conflict. before we go further, we must
224 * check if we sit on the same bus as the conflicting device.
225 * if we don't, then we must tie both IO and MEM resources
226 * together since there is only a single bit controlling
227 * VGA forwarding on P2P bridges
229 if (vgadev->pdev->bus != conflict->pdev->bus) {
231 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
234 /* Check if the guy has a lock on the resource. If he does,
235 * return the conflicting entry
237 if (conflict->locks & lwants)
240 /* Ok, now check if it owns the resource we want. We can
241 * lock resources that are not decoded, therefore a device
242 * can own resources it doesn't decode.
244 match = lwants & conflict->owns;
248 /* looks like he doesn't have a lock, we can steal
255 /* If we can't control legacy resources via the bridge, we
256 * also need to disable normal decoding.
258 if (!conflict->bridge_has_one_vga) {
259 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)
260 pci_bits |= PCI_COMMAND_MEMORY;
261 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)
262 pci_bits |= PCI_COMMAND_IO;
265 vga_irq_set_state(conflict, false);
266 flags |= PCI_VGA_STATE_CHANGE_DECODES;
271 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
273 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
274 conflict->owns &= ~match;
276 /* If we disabled normal decoding, reflect it in owns */
277 if (pci_bits & PCI_COMMAND_MEMORY)
278 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
279 if (pci_bits & PCI_COMMAND_IO)
280 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
284 /* ok dude, we got it, everybody conflicting has been disabled, let's
285 * enable us. Mark any bits in "owns" regardless of whether we
286 * decoded them. We can lock resources we don't decode, therefore
287 * we must track them via "owns".
292 if (!vgadev->bridge_has_one_vga) {
293 flags |= PCI_VGA_STATE_CHANGE_DECODES;
294 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
295 pci_bits |= PCI_COMMAND_MEMORY;
296 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
297 pci_bits |= PCI_COMMAND_IO;
299 if (wants & VGA_RSRC_LEGACY_MASK)
300 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
302 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
304 if (!vgadev->bridge_has_one_vga) {
305 vga_irq_set_state(vgadev, true);
307 vgadev->owns |= wants;
309 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
310 if (rsrc & VGA_RSRC_LEGACY_IO)
311 vgadev->io_lock_cnt++;
312 if (rsrc & VGA_RSRC_LEGACY_MEM)
313 vgadev->mem_lock_cnt++;
314 if (rsrc & VGA_RSRC_NORMAL_IO)
315 vgadev->io_norm_cnt++;
316 if (rsrc & VGA_RSRC_NORMAL_MEM)
317 vgadev->mem_norm_cnt++;
322 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
324 unsigned int old_locks = vgadev->locks;
326 pr_debug("%s\n", __func__);
328 /* Update our counters, and account for equivalent legacy resources
331 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
332 vgadev->io_norm_cnt--;
333 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
334 rsrc |= VGA_RSRC_LEGACY_IO;
336 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
337 vgadev->mem_norm_cnt--;
338 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
339 rsrc |= VGA_RSRC_LEGACY_MEM;
341 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
342 vgadev->io_lock_cnt--;
343 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
344 vgadev->mem_lock_cnt--;
346 /* Just clear lock bits, we do lazy operations so we don't really
347 * have to bother about anything else at this point
349 if (vgadev->io_lock_cnt == 0)
350 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
351 if (vgadev->mem_lock_cnt == 0)
352 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
354 /* Kick the wait queue in case somebody was waiting if we actually
357 if (old_locks != vgadev->locks)
358 wake_up_all(&vga_wait_queue);
361 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
363 struct vga_device *vgadev, *conflict;
368 vga_check_first_use();
369 /* The one who calls us should check for this, but lets be sure... */
371 pdev = vga_default_device();
376 spin_lock_irqsave(&vga_lock, flags);
377 vgadev = vgadev_find(pdev);
378 if (vgadev == NULL) {
379 spin_unlock_irqrestore(&vga_lock, flags);
383 conflict = __vga_tryget(vgadev, rsrc);
384 spin_unlock_irqrestore(&vga_lock, flags);
385 if (conflict == NULL)
389 /* We have a conflict, we wait until somebody kicks the
390 * work queue. Currently we have one work queue that we
391 * kick each time some resources are released, but it would
392 * be fairly easy to have a per device one so that we only
393 * need to attach to the conflicting device
395 init_waitqueue_entry(&wait, current);
396 add_wait_queue(&vga_wait_queue, &wait);
397 set_current_state(interruptible ?
399 TASK_UNINTERRUPTIBLE);
400 if (signal_pending(current)) {
405 remove_wait_queue(&vga_wait_queue, &wait);
406 set_current_state(TASK_RUNNING);
410 EXPORT_SYMBOL(vga_get);
412 int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
414 struct vga_device *vgadev;
418 vga_check_first_use();
420 /* The one who calls us should check for this, but lets be sure... */
422 pdev = vga_default_device();
425 spin_lock_irqsave(&vga_lock, flags);
426 vgadev = vgadev_find(pdev);
427 if (vgadev == NULL) {
431 if (__vga_tryget(vgadev, rsrc))
434 spin_unlock_irqrestore(&vga_lock, flags);
437 EXPORT_SYMBOL(vga_tryget);
439 void vga_put(struct pci_dev *pdev, unsigned int rsrc)
441 struct vga_device *vgadev;
444 /* The one who calls us should check for this, but lets be sure... */
446 pdev = vga_default_device();
449 spin_lock_irqsave(&vga_lock, flags);
450 vgadev = vgadev_find(pdev);
453 __vga_put(vgadev, rsrc);
455 spin_unlock_irqrestore(&vga_lock, flags);
457 EXPORT_SYMBOL(vga_put);
459 /* Rules for using a bridge to control a VGA descendant decoding:
460 if a bridge has only one VGA descendant then it can be used
461 to control the VGA routing for that device.
462 It should always use the bridge closest to the device to control it.
463 If a bridge has a direct VGA descendant, but also have a sub-bridge
464 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
465 So for every device we register, we need to iterate all its parent bridges
466 so we can invalidate any devices using them properly.
468 static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
470 struct vga_device *same_bridge_vgadev;
471 struct pci_bus *new_bus, *bus;
472 struct pci_dev *new_bridge, *bridge;
474 vgadev->bridge_has_one_vga = true;
476 if (list_empty(&vga_list))
479 /* okay iterate the new devices bridge hierarachy */
480 new_bus = vgadev->pdev->bus;
482 new_bridge = new_bus->self;
484 /* go through list of devices already registered */
485 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
486 bus = same_bridge_vgadev->pdev->bus;
489 /* see if the share a bridge with this device */
490 if (new_bridge == bridge) {
491 /* if their direct parent bridge is the same
492 as any bridge of this device then it can't be used
494 same_bridge_vgadev->bridge_has_one_vga = false;
497 /* now iterate the previous devices bridge hierarchy */
498 /* if the new devices parent bridge is in the other devices
499 hierarchy then we can't use it to control this device */
503 if (bridge == vgadev->pdev->bus->self)
504 vgadev->bridge_has_one_vga = false;
509 new_bus = new_bus->parent;
514 * Currently, we assume that the "initial" setup of the system is
515 * not sane, that is we come up with conflicting devices and let
516 * the arbiter's client decides if devices decodes or not legacy
519 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
521 struct vga_device *vgadev;
524 struct pci_dev *bridge;
527 /* Only deal with VGA class devices */
528 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
531 /* Allocate structure */
532 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
533 if (vgadev == NULL) {
534 pr_err("vgaarb: failed to allocate pci device\n");
535 /* What to do on allocation failure ? For now, let's
536 * just do nothing, I'm not sure there is anything saner
542 memset(vgadev, 0, sizeof(*vgadev));
544 /* Take lock & check for duplicates */
545 spin_lock_irqsave(&vga_lock, flags);
546 if (vgadev_find(pdev) != NULL) {
552 /* By default, assume we decode everything */
553 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
554 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
556 /* by default mark it as decoding */
558 /* Mark that we "own" resources based on our enables, we will
559 * clear that below if the bridge isn't forwarding
561 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
562 if (cmd & PCI_COMMAND_IO)
563 vgadev->owns |= VGA_RSRC_LEGACY_IO;
564 if (cmd & PCI_COMMAND_MEMORY)
565 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
567 /* Check if VGA cycles can get down to us */
573 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
575 if (!(l & PCI_BRIDGE_CTL_VGA)) {
583 /* Deal with VGA default device. Use first enabled one
584 * by default if arch doesn't have it's own hook
586 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
587 if (vga_default == NULL &&
588 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
589 vga_set_default_device(pdev);
592 vga_arbiter_check_bridge_sharing(vgadev);
594 /* Add to the list */
595 list_add(&vgadev->list, &vga_list);
597 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
599 vga_iostate_to_str(vgadev->decodes),
600 vga_iostate_to_str(vgadev->owns),
601 vga_iostate_to_str(vgadev->locks));
603 spin_unlock_irqrestore(&vga_lock, flags);
606 spin_unlock_irqrestore(&vga_lock, flags);
611 static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
613 struct vga_device *vgadev;
617 spin_lock_irqsave(&vga_lock, flags);
618 vgadev = vgadev_find(pdev);
619 if (vgadev == NULL) {
624 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
625 if (vga_default == pdev)
626 vga_set_default_device(NULL);
629 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
632 /* Remove entry from list */
633 list_del(&vgadev->list);
635 /* Notify userland driver that the device is gone so it discards
636 * it's copies of the pci_dev pointer
638 vga_arb_device_card_gone(pdev);
640 /* Wake up all possible waiters */
641 wake_up_all(&vga_wait_queue);
643 spin_unlock_irqrestore(&vga_lock, flags);
648 /* this is called with the lock */
649 static inline void vga_update_device_decodes(struct vga_device *vgadev,
652 int old_decodes, decodes_removed, decodes_unlocked;
654 old_decodes = vgadev->decodes;
655 decodes_removed = ~new_decodes & old_decodes;
656 decodes_unlocked = vgadev->locks & decodes_removed;
657 vgadev->decodes = new_decodes;
659 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
660 pci_name(vgadev->pdev),
661 vga_iostate_to_str(old_decodes),
662 vga_iostate_to_str(vgadev->decodes),
663 vga_iostate_to_str(vgadev->owns));
665 /* if we removed locked decodes, lock count goes to zero, and release */
666 if (decodes_unlocked) {
667 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
668 vgadev->io_lock_cnt = 0;
669 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
670 vgadev->mem_lock_cnt = 0;
671 __vga_put(vgadev, decodes_unlocked);
674 /* change decodes counter */
675 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
676 !(new_decodes & VGA_RSRC_LEGACY_MASK))
678 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
679 new_decodes & VGA_RSRC_LEGACY_MASK)
681 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
684 static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
686 struct vga_device *vgadev;
689 decodes &= VGA_RSRC_LEGACY_MASK;
691 spin_lock_irqsave(&vga_lock, flags);
692 vgadev = vgadev_find(pdev);
696 /* don't let userspace futz with kernel driver decodes */
697 if (userspace && vgadev->set_vga_decode)
700 /* update the device decodes + counter */
701 vga_update_device_decodes(vgadev, decodes);
703 /* XXX if somebody is going from "doesn't decode" to "decodes" state
704 * here, additional care must be taken as we may have pending owner
705 * ship of non-legacy region ...
708 spin_unlock_irqrestore(&vga_lock, flags);
711 void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
713 __vga_set_legacy_decoding(pdev, decodes, false);
715 EXPORT_SYMBOL(vga_set_legacy_decoding);
717 /* call with NULL to unregister */
718 int vga_client_register(struct pci_dev *pdev, void *cookie,
719 void (*irq_set_state)(void *cookie, bool state),
720 unsigned int (*set_vga_decode)(void *cookie, bool decode))
723 struct vga_device *vgadev;
726 spin_lock_irqsave(&vga_lock, flags);
727 vgadev = vgadev_find(pdev);
731 vgadev->irq_set_state = irq_set_state;
732 vgadev->set_vga_decode = set_vga_decode;
733 vgadev->cookie = cookie;
737 spin_unlock_irqrestore(&vga_lock, flags);
741 EXPORT_SYMBOL(vga_client_register);
744 * Char driver implementation
748 * open : open user instance of the arbitrer. by default, it's
749 * attached to the default VGA device of the system.
751 * close : close user instance, release locks
753 * read : return a string indicating the status of the target.
754 * an IO state string is of the form {io,mem,io+mem,none},
755 * mc and ic are respectively mem and io lock counts (for
756 * debugging/diagnostic only). "decodes" indicate what the
757 * card currently decodes, "owns" indicates what is currently
758 * enabled on it, and "locks" indicates what is locked by this
759 * card. If the card is unplugged, we get "invalid" then for
760 * card_ID and an -ENODEV error is returned for any command
761 * until a new card is targeted
763 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
765 * write : write a command to the arbiter. List of commands is:
767 * target <card_ID> : switch target to card <card_ID> (see below)
768 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
769 * trylock <io_state> : non-blocking acquire locks on target
770 * unlock <io_state> : release locks on target
771 * unlock all : release all locks on target held by this user
772 * decodes <io_state> : set the legacy decoding attributes for the card
774 * poll : event if something change on any card (not just the target)
776 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
777 * to go back to the system default card (TODO: not implemented yet).
778 * Currently, only PCI is supported as a prefix, but the userland API may
779 * support other bus types in the future, even if the current kernel
780 * implementation doesn't.
784 * The driver keeps track of which user has what locks on which card. It
785 * supports stacking, like the kernel one. This complexifies the implementation
786 * a bit, but makes the arbiter more tolerant to userspace problems and able
787 * to properly cleanup in all cases when a process dies.
788 * Currently, a max of 16 cards simultaneously can have locks issued from
789 * userspace for a given user (file descriptor instance) of the arbiter.
791 * If the device is hot-unplugged, there is a hook inside the module to notify
792 * they being added/removed in the system and automatically added/removed in
796 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
797 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
800 * Each user has an array of these, tracking which cards have locks
802 struct vga_arb_user_card {
803 struct pci_dev *pdev;
804 unsigned int mem_cnt;
808 struct vga_arb_private {
809 struct list_head list;
810 struct pci_dev *target;
811 struct vga_arb_user_card cards[MAX_USER_CARDS];
815 static LIST_HEAD(vga_user_list);
816 static DEFINE_SPINLOCK(vga_user_lock);
820 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
821 * returns the respective values. If the string is not in this format,
824 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
825 unsigned int *bus, unsigned int *devfn)
828 unsigned int slot, func;
831 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
835 *devfn = PCI_DEVFN(slot, func);
840 static ssize_t vga_arb_read(struct file *file, char __user * buf,
841 size_t count, loff_t *ppos)
843 struct vga_arb_private *priv = file->private_data;
844 struct vga_device *vgadev;
845 struct pci_dev *pdev;
851 lbuf = kmalloc(1024, GFP_KERNEL);
855 /* Shields against vga_arb_device_card_gone (pci_dev going
856 * away), and allows access to vga list
858 spin_lock_irqsave(&vga_lock, flags);
860 /* If we are targeting the default, use it */
862 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
863 spin_unlock_irqrestore(&vga_lock, flags);
864 len = sprintf(lbuf, "invalid");
868 /* Find card vgadev structure */
869 vgadev = vgadev_find(pdev);
870 if (vgadev == NULL) {
871 /* Wow, it's not in the list, that shouldn't happen,
872 * let's fix us up and return invalid card
874 if (pdev == priv->target)
875 vga_arb_device_card_gone(pdev);
876 spin_unlock_irqrestore(&vga_lock, flags);
877 len = sprintf(lbuf, "invalid");
881 /* Fill the buffer with infos */
882 len = snprintf(lbuf, 1024,
883 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
884 vga_decode_count, pci_name(pdev),
885 vga_iostate_to_str(vgadev->decodes),
886 vga_iostate_to_str(vgadev->owns),
887 vga_iostate_to_str(vgadev->locks),
888 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
890 spin_unlock_irqrestore(&vga_lock, flags);
893 /* Copy that to user */
896 rc = copy_to_user(buf, lbuf, len);
904 * TODO: To avoid parsing inside kernel and to improve the speed we may
905 * consider use ioctl here
907 static ssize_t vga_arb_write(struct file *file, const char __user * buf,
908 size_t count, loff_t *ppos)
910 struct vga_arb_private *priv = file->private_data;
911 struct vga_arb_user_card *uc = NULL;
912 struct pci_dev *pdev;
914 unsigned int io_state;
916 char *kbuf, *curr_pos;
917 size_t remaining = count;
923 kbuf = kmalloc(count + 1, GFP_KERNEL);
927 if (copy_from_user(kbuf, buf, count)) {
932 kbuf[count] = '\0'; /* Just to make sure... */
934 if (strncmp(curr_pos, "lock ", 5) == 0) {
938 pr_debug("client 0x%p called 'lock'\n", priv);
940 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
944 if (io_state == VGA_RSRC_NONE) {
950 if (priv->target == NULL) {
955 vga_get_uninterruptible(pdev, io_state);
957 /* Update the client's locks lists... */
958 for (i = 0; i < MAX_USER_CARDS; i++) {
959 if (priv->cards[i].pdev == pdev) {
960 if (io_state & VGA_RSRC_LEGACY_IO)
961 priv->cards[i].io_cnt++;
962 if (io_state & VGA_RSRC_LEGACY_MEM)
963 priv->cards[i].mem_cnt++;
970 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
974 pr_debug("client 0x%p called 'unlock'\n", priv);
976 if (strncmp(curr_pos, "all", 3) == 0)
977 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
979 if (!vga_str_to_iostate
980 (curr_pos, remaining, &io_state)) {
985 if (io_state == VGA_RSRC_NONE) {
993 if (priv->target == NULL) {
997 for (i = 0; i < MAX_USER_CARDS; i++) {
998 if (priv->cards[i].pdev == pdev)
999 uc = &priv->cards[i];
1007 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1012 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1017 vga_put(pdev, io_state);
1019 if (io_state & VGA_RSRC_LEGACY_IO)
1021 if (io_state & VGA_RSRC_LEGACY_MEM)
1026 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1030 pr_debug("client 0x%p called 'trylock'\n", priv);
1032 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1037 if (io_state == VGA_RSRC_NONE) {
1043 pdev = priv->target;
1044 if (priv->target == NULL) {
1049 if (vga_tryget(pdev, io_state)) {
1050 /* Update the client's locks lists... */
1051 for (i = 0; i < MAX_USER_CARDS; i++) {
1052 if (priv->cards[i].pdev == pdev) {
1053 if (io_state & VGA_RSRC_LEGACY_IO)
1054 priv->cards[i].io_cnt++;
1055 if (io_state & VGA_RSRC_LEGACY_MEM)
1056 priv->cards[i].mem_cnt++;
1067 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1068 unsigned int domain, bus, devfn;
1069 struct vga_device *vgadev;
1073 pr_debug("client 0x%p called 'target'\n", priv);
1074 /* if target is default */
1075 if (!strncmp(curr_pos, "default", 7))
1076 pdev = pci_dev_get(vga_default_device());
1078 if (!vga_pci_str_to_vars(curr_pos, remaining,
1079 &domain, &bus, &devfn)) {
1083 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
1084 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1086 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1087 pr_debug("vgaarb: pdev %p\n", pdev);
1089 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1090 domain, bus, devfn);
1096 vgadev = vgadev_find(pdev);
1097 pr_debug("vgaarb: vgadev %p\n", vgadev);
1098 if (vgadev == NULL) {
1099 pr_err("vgaarb: this pci device is not a vga device\n");
1105 priv->target = pdev;
1106 for (i = 0; i < MAX_USER_CARDS; i++) {
1107 if (priv->cards[i].pdev == pdev)
1109 if (priv->cards[i].pdev == NULL) {
1110 priv->cards[i].pdev = pdev;
1111 priv->cards[i].io_cnt = 0;
1112 priv->cards[i].mem_cnt = 0;
1116 if (i == MAX_USER_CARDS) {
1117 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1120 /* XXX: which value to return? */
1130 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1133 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1135 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1139 pdev = priv->target;
1140 if (priv->target == NULL) {
1145 __vga_set_legacy_decoding(pdev, io_state, true);
1149 /* If we got here, the message written is not part of the protocol! */
1158 static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1160 struct vga_arb_private *priv = file->private_data;
1162 pr_debug("%s\n", __func__);
1166 poll_wait(file, &vga_wait_queue, wait);
1170 static int vga_arb_open(struct inode *inode, struct file *file)
1172 struct vga_arb_private *priv;
1173 unsigned long flags;
1175 pr_debug("%s\n", __func__);
1177 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1180 spin_lock_init(&priv->lock);
1181 file->private_data = priv;
1183 spin_lock_irqsave(&vga_user_lock, flags);
1184 list_add(&priv->list, &vga_user_list);
1185 spin_unlock_irqrestore(&vga_user_lock, flags);
1187 /* Set the client' lists of locks */
1188 priv->target = vga_default_device(); /* Maybe this is still null! */
1189 priv->cards[0].pdev = priv->target;
1190 priv->cards[0].io_cnt = 0;
1191 priv->cards[0].mem_cnt = 0;
1197 static int vga_arb_release(struct inode *inode, struct file *file)
1199 struct vga_arb_private *priv = file->private_data;
1200 struct vga_arb_user_card *uc;
1201 unsigned long flags;
1204 pr_debug("%s\n", __func__);
1209 spin_lock_irqsave(&vga_user_lock, flags);
1210 list_del(&priv->list);
1211 for (i = 0; i < MAX_USER_CARDS; i++) {
1212 uc = &priv->cards[i];
1213 if (uc->pdev == NULL)
1215 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1216 uc->io_cnt, uc->mem_cnt);
1217 while (uc->io_cnt--)
1218 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1219 while (uc->mem_cnt--)
1220 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1222 spin_unlock_irqrestore(&vga_user_lock, flags);
1229 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1234 * callback any registered clients to let them know we have a
1235 * change in VGA cards
1237 static void vga_arbiter_notify_clients(void)
1239 struct vga_device *vgadev;
1240 unsigned long flags;
1241 uint32_t new_decodes;
1244 if (!vga_arbiter_used)
1247 spin_lock_irqsave(&vga_lock, flags);
1248 list_for_each_entry(vgadev, &vga_list, list) {
1253 if (vgadev->set_vga_decode) {
1254 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1255 vga_update_device_decodes(vgadev, new_decodes);
1258 spin_unlock_irqrestore(&vga_lock, flags);
1261 static int pci_notify(struct notifier_block *nb, unsigned long action,
1264 struct device *dev = data;
1265 struct pci_dev *pdev = to_pci_dev(dev);
1266 bool notify = false;
1268 pr_debug("%s\n", __func__);
1270 /* For now we're only intereted in devices added and removed. I didn't
1271 * test this thing here, so someone needs to double check for the
1272 * cases of hotplugable vga cards. */
1273 if (action == BUS_NOTIFY_ADD_DEVICE)
1274 notify = vga_arbiter_add_pci_device(pdev);
1275 else if (action == BUS_NOTIFY_DEL_DEVICE)
1276 notify = vga_arbiter_del_pci_device(pdev);
1279 vga_arbiter_notify_clients();
1283 static struct notifier_block pci_notifier = {
1284 .notifier_call = pci_notify,
1287 static const struct file_operations vga_arb_device_fops = {
1288 .read = vga_arb_read,
1289 .write = vga_arb_write,
1290 .poll = vga_arb_fpoll,
1291 .open = vga_arb_open,
1292 .release = vga_arb_release,
1293 .llseek = noop_llseek,
1296 static struct miscdevice vga_arb_device = {
1297 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1300 static int __init vga_arb_device_init(void)
1303 struct pci_dev *pdev;
1304 struct vga_device *vgadev;
1306 rc = misc_register(&vga_arb_device);
1308 pr_err("vgaarb: error %d registering device\n", rc);
1310 bus_register_notifier(&pci_bus_type, &pci_notifier);
1312 /* We add all pci devices satisfying vga class in the arbiter by
1316 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1317 PCI_ANY_ID, pdev)) != NULL)
1318 vga_arbiter_add_pci_device(pdev);
1320 pr_info("vgaarb: loaded\n");
1322 list_for_each_entry(vgadev, &vga_list, list) {
1323 if (vgadev->bridge_has_one_vga)
1324 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1326 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1330 subsys_initcall(vga_arb_device_init);