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>
44 #include <linux/screen_info.h>
46 #include <linux/uaccess.h>
48 #include <linux/vgaarb.h>
50 static void vga_arbiter_notify_clients(void);
52 * We keep a list of all vga devices in the system to speed
53 * up the various operations of the arbiter
56 struct list_head list;
58 unsigned int decodes; /* what does it decodes */
59 unsigned int owns; /* what does it owns */
60 unsigned int locks; /* what does it locks */
61 unsigned int io_lock_cnt; /* legacy IO lock count */
62 unsigned int mem_lock_cnt; /* legacy MEM lock count */
63 unsigned int io_norm_cnt; /* normal IO count */
64 unsigned int mem_norm_cnt; /* normal MEM count */
65 bool bridge_has_one_vga;
66 /* allow IRQ enable/disable hook */
68 void (*irq_set_state)(void *cookie, bool enable);
69 unsigned int (*set_vga_decode)(void *cookie, bool decode);
72 static LIST_HEAD(vga_list);
73 static int vga_count, vga_decode_count;
74 static bool vga_arbiter_used;
75 static DEFINE_SPINLOCK(vga_lock);
76 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
79 static const char *vga_iostate_to_str(unsigned int iostate)
81 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
82 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
84 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
86 case VGA_RSRC_LEGACY_IO:
88 case VGA_RSRC_LEGACY_MEM:
94 static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
96 /* we could in theory hand out locks on IO and mem
97 * separately to userspace but it can cause deadlocks */
98 if (strncmp(buf, "none", 4) == 0) {
99 *io_state = VGA_RSRC_NONE;
103 /* XXX We're not chekcing the str_size! */
104 if (strncmp(buf, "io+mem", 6) == 0)
106 else if (strncmp(buf, "io", 2) == 0)
108 else if (strncmp(buf, "mem", 3) == 0)
112 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
116 /* this is only used a cookie - it should not be dereferenced */
117 static struct pci_dev *vga_default;
119 static void vga_arb_device_card_gone(struct pci_dev *pdev);
121 /* Find somebody in our list */
122 static struct vga_device *vgadev_find(struct pci_dev *pdev)
124 struct vga_device *vgadev;
126 list_for_each_entry(vgadev, &vga_list, list)
127 if (pdev == vgadev->pdev)
132 /* Returns the default VGA device (vgacon's babe) */
133 struct pci_dev *vga_default_device(void)
138 EXPORT_SYMBOL_GPL(vga_default_device);
140 void vga_set_default_device(struct pci_dev *pdev)
142 if (vga_default == pdev)
145 pci_dev_put(vga_default);
146 vga_default = pci_dev_get(pdev);
149 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
151 if (vgadev->irq_set_state)
152 vgadev->irq_set_state(vgadev->cookie, state);
156 /* If we don't ever use VGA arb we should avoid
157 turning off anything anywhere due to old X servers getting
158 confused about the boot device not being VGA */
159 static void vga_check_first_use(void)
161 /* we should inform all GPUs in the system that
162 * VGA arb has occurred and to try and disable resources
164 if (!vga_arbiter_used) {
165 vga_arbiter_used = true;
166 vga_arbiter_notify_clients();
170 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
173 unsigned int wants, legacy_wants, match;
174 struct vga_device *conflict;
175 unsigned int pci_bits;
178 /* Account for "normal" resources to lock. If we decode the legacy,
179 * counterpart, we need to request it as well
181 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
182 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
183 rsrc |= VGA_RSRC_LEGACY_IO;
184 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
185 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
186 rsrc |= VGA_RSRC_LEGACY_MEM;
188 pr_debug("%s: %d\n", __func__, rsrc);
189 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
191 /* Check what resources we need to acquire */
192 wants = rsrc & ~vgadev->owns;
194 /* We already own everything, just mark locked & bye bye */
198 /* We don't need to request a legacy resource, we just enable
199 * appropriate decoding and go
201 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
202 if (legacy_wants == 0)
205 /* Ok, we don't, let's find out how we need to kick off */
206 list_for_each_entry(conflict, &vga_list, list) {
207 unsigned int lwants = legacy_wants;
208 unsigned int change_bridge = 0;
210 /* Don't conflict with myself */
211 if (vgadev == conflict)
214 /* Check if the architecture allows a conflict between those
215 * 2 devices or if they are on separate domains
217 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
220 /* We have a possible conflict. before we go further, we must
221 * check if we sit on the same bus as the conflicting device.
222 * if we don't, then we must tie both IO and MEM resources
223 * together since there is only a single bit controlling
224 * VGA forwarding on P2P bridges
226 if (vgadev->pdev->bus != conflict->pdev->bus) {
228 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
231 /* Check if the guy has a lock on the resource. If he does,
232 * return the conflicting entry
234 if (conflict->locks & lwants)
237 /* Ok, now check if it owns the resource we want. We can
238 * lock resources that are not decoded, therefore a device
239 * can own resources it doesn't decode.
241 match = lwants & conflict->owns;
245 /* looks like he doesn't have a lock, we can steal
252 /* If we can't control legacy resources via the bridge, we
253 * also need to disable normal decoding.
255 if (!conflict->bridge_has_one_vga) {
256 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)
257 pci_bits |= PCI_COMMAND_MEMORY;
258 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)
259 pci_bits |= PCI_COMMAND_IO;
262 vga_irq_set_state(conflict, false);
263 flags |= PCI_VGA_STATE_CHANGE_DECODES;
268 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
270 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
271 conflict->owns &= ~match;
273 /* If we disabled normal decoding, reflect it in owns */
274 if (pci_bits & PCI_COMMAND_MEMORY)
275 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
276 if (pci_bits & PCI_COMMAND_IO)
277 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
281 /* ok dude, we got it, everybody conflicting has been disabled, let's
282 * enable us. Mark any bits in "owns" regardless of whether we
283 * decoded them. We can lock resources we don't decode, therefore
284 * we must track them via "owns".
289 if (!vgadev->bridge_has_one_vga) {
290 flags |= PCI_VGA_STATE_CHANGE_DECODES;
291 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
292 pci_bits |= PCI_COMMAND_MEMORY;
293 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
294 pci_bits |= PCI_COMMAND_IO;
296 if (wants & VGA_RSRC_LEGACY_MASK)
297 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
299 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
301 if (!vgadev->bridge_has_one_vga) {
302 vga_irq_set_state(vgadev, true);
304 vgadev->owns |= wants;
306 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
307 if (rsrc & VGA_RSRC_LEGACY_IO)
308 vgadev->io_lock_cnt++;
309 if (rsrc & VGA_RSRC_LEGACY_MEM)
310 vgadev->mem_lock_cnt++;
311 if (rsrc & VGA_RSRC_NORMAL_IO)
312 vgadev->io_norm_cnt++;
313 if (rsrc & VGA_RSRC_NORMAL_MEM)
314 vgadev->mem_norm_cnt++;
319 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
321 unsigned int old_locks = vgadev->locks;
323 pr_debug("%s\n", __func__);
325 /* Update our counters, and account for equivalent legacy resources
328 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
329 vgadev->io_norm_cnt--;
330 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
331 rsrc |= VGA_RSRC_LEGACY_IO;
333 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
334 vgadev->mem_norm_cnt--;
335 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
336 rsrc |= VGA_RSRC_LEGACY_MEM;
338 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
339 vgadev->io_lock_cnt--;
340 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
341 vgadev->mem_lock_cnt--;
343 /* Just clear lock bits, we do lazy operations so we don't really
344 * have to bother about anything else at this point
346 if (vgadev->io_lock_cnt == 0)
347 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
348 if (vgadev->mem_lock_cnt == 0)
349 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
351 /* Kick the wait queue in case somebody was waiting if we actually
354 if (old_locks != vgadev->locks)
355 wake_up_all(&vga_wait_queue);
358 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
360 struct vga_device *vgadev, *conflict;
365 vga_check_first_use();
366 /* The one who calls us should check for this, but lets be sure... */
368 pdev = vga_default_device();
373 spin_lock_irqsave(&vga_lock, flags);
374 vgadev = vgadev_find(pdev);
375 if (vgadev == NULL) {
376 spin_unlock_irqrestore(&vga_lock, flags);
380 conflict = __vga_tryget(vgadev, rsrc);
381 spin_unlock_irqrestore(&vga_lock, flags);
382 if (conflict == NULL)
386 /* We have a conflict, we wait until somebody kicks the
387 * work queue. Currently we have one work queue that we
388 * kick each time some resources are released, but it would
389 * be fairly easy to have a per device one so that we only
390 * need to attach to the conflicting device
392 init_waitqueue_entry(&wait, current);
393 add_wait_queue(&vga_wait_queue, &wait);
394 set_current_state(interruptible ?
396 TASK_UNINTERRUPTIBLE);
397 if (signal_pending(current)) {
402 remove_wait_queue(&vga_wait_queue, &wait);
403 set_current_state(TASK_RUNNING);
407 EXPORT_SYMBOL(vga_get);
409 int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
411 struct vga_device *vgadev;
415 vga_check_first_use();
417 /* The one who calls us should check for this, but lets be sure... */
419 pdev = vga_default_device();
422 spin_lock_irqsave(&vga_lock, flags);
423 vgadev = vgadev_find(pdev);
424 if (vgadev == NULL) {
428 if (__vga_tryget(vgadev, rsrc))
431 spin_unlock_irqrestore(&vga_lock, flags);
434 EXPORT_SYMBOL(vga_tryget);
436 void vga_put(struct pci_dev *pdev, unsigned int rsrc)
438 struct vga_device *vgadev;
441 /* The one who calls us should check for this, but lets be sure... */
443 pdev = vga_default_device();
446 spin_lock_irqsave(&vga_lock, flags);
447 vgadev = vgadev_find(pdev);
450 __vga_put(vgadev, rsrc);
452 spin_unlock_irqrestore(&vga_lock, flags);
454 EXPORT_SYMBOL(vga_put);
456 /* Rules for using a bridge to control a VGA descendant decoding:
457 if a bridge has only one VGA descendant then it can be used
458 to control the VGA routing for that device.
459 It should always use the bridge closest to the device to control it.
460 If a bridge has a direct VGA descendant, but also have a sub-bridge
461 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
462 So for every device we register, we need to iterate all its parent bridges
463 so we can invalidate any devices using them properly.
465 static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
467 struct vga_device *same_bridge_vgadev;
468 struct pci_bus *new_bus, *bus;
469 struct pci_dev *new_bridge, *bridge;
471 vgadev->bridge_has_one_vga = true;
473 if (list_empty(&vga_list))
476 /* okay iterate the new devices bridge hierarachy */
477 new_bus = vgadev->pdev->bus;
479 new_bridge = new_bus->self;
481 /* go through list of devices already registered */
482 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
483 bus = same_bridge_vgadev->pdev->bus;
486 /* see if the share a bridge with this device */
487 if (new_bridge == bridge) {
488 /* if their direct parent bridge is the same
489 as any bridge of this device then it can't be used
491 same_bridge_vgadev->bridge_has_one_vga = false;
494 /* now iterate the previous devices bridge hierarchy */
495 /* if the new devices parent bridge is in the other devices
496 hierarchy then we can't use it to control this device */
500 if (bridge == vgadev->pdev->bus->self)
501 vgadev->bridge_has_one_vga = false;
506 new_bus = new_bus->parent;
511 * Currently, we assume that the "initial" setup of the system is
512 * not sane, that is we come up with conflicting devices and let
513 * the arbiter's client decides if devices decodes or not legacy
516 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
518 struct vga_device *vgadev;
521 struct pci_dev *bridge;
524 /* Only deal with VGA class devices */
525 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
528 /* Allocate structure */
529 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
530 if (vgadev == NULL) {
531 pr_err("vgaarb: failed to allocate pci device\n");
532 /* What to do on allocation failure ? For now, let's
533 * just do nothing, I'm not sure there is anything saner
539 memset(vgadev, 0, sizeof(*vgadev));
541 /* Take lock & check for duplicates */
542 spin_lock_irqsave(&vga_lock, flags);
543 if (vgadev_find(pdev) != NULL) {
549 /* By default, assume we decode everything */
550 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
551 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
553 /* by default mark it as decoding */
555 /* Mark that we "own" resources based on our enables, we will
556 * clear that below if the bridge isn't forwarding
558 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
559 if (cmd & PCI_COMMAND_IO)
560 vgadev->owns |= VGA_RSRC_LEGACY_IO;
561 if (cmd & PCI_COMMAND_MEMORY)
562 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
564 /* Check if VGA cycles can get down to us */
570 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
572 if (!(l & PCI_BRIDGE_CTL_VGA)) {
580 /* Deal with VGA default device. Use first enabled one
581 * by default if arch doesn't have it's own hook
583 if (vga_default == NULL &&
584 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) {
585 pr_info("vgaarb: setting as boot device: PCI:%s\n",
587 vga_set_default_device(pdev);
590 vga_arbiter_check_bridge_sharing(vgadev);
592 /* Add to the list */
593 list_add(&vgadev->list, &vga_list);
595 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
597 vga_iostate_to_str(vgadev->decodes),
598 vga_iostate_to_str(vgadev->owns),
599 vga_iostate_to_str(vgadev->locks));
601 spin_unlock_irqrestore(&vga_lock, flags);
604 spin_unlock_irqrestore(&vga_lock, flags);
609 static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
611 struct vga_device *vgadev;
615 spin_lock_irqsave(&vga_lock, flags);
616 vgadev = vgadev_find(pdev);
617 if (vgadev == NULL) {
622 if (vga_default == pdev)
623 vga_set_default_device(NULL);
625 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
628 /* Remove entry from list */
629 list_del(&vgadev->list);
631 /* Notify userland driver that the device is gone so it discards
632 * it's copies of the pci_dev pointer
634 vga_arb_device_card_gone(pdev);
636 /* Wake up all possible waiters */
637 wake_up_all(&vga_wait_queue);
639 spin_unlock_irqrestore(&vga_lock, flags);
644 /* this is called with the lock */
645 static inline void vga_update_device_decodes(struct vga_device *vgadev,
648 int old_decodes, decodes_removed, decodes_unlocked;
650 old_decodes = vgadev->decodes;
651 decodes_removed = ~new_decodes & old_decodes;
652 decodes_unlocked = vgadev->locks & decodes_removed;
653 vgadev->decodes = new_decodes;
655 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
656 pci_name(vgadev->pdev),
657 vga_iostate_to_str(old_decodes),
658 vga_iostate_to_str(vgadev->decodes),
659 vga_iostate_to_str(vgadev->owns));
661 /* if we removed locked decodes, lock count goes to zero, and release */
662 if (decodes_unlocked) {
663 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
664 vgadev->io_lock_cnt = 0;
665 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
666 vgadev->mem_lock_cnt = 0;
667 __vga_put(vgadev, decodes_unlocked);
670 /* change decodes counter */
671 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
672 !(new_decodes & VGA_RSRC_LEGACY_MASK))
674 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
675 new_decodes & VGA_RSRC_LEGACY_MASK)
677 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
680 static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
682 struct vga_device *vgadev;
685 decodes &= VGA_RSRC_LEGACY_MASK;
687 spin_lock_irqsave(&vga_lock, flags);
688 vgadev = vgadev_find(pdev);
692 /* don't let userspace futz with kernel driver decodes */
693 if (userspace && vgadev->set_vga_decode)
696 /* update the device decodes + counter */
697 vga_update_device_decodes(vgadev, decodes);
699 /* XXX if somebody is going from "doesn't decode" to "decodes" state
700 * here, additional care must be taken as we may have pending owner
701 * ship of non-legacy region ...
704 spin_unlock_irqrestore(&vga_lock, flags);
707 void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
709 __vga_set_legacy_decoding(pdev, decodes, false);
711 EXPORT_SYMBOL(vga_set_legacy_decoding);
713 /* call with NULL to unregister */
714 int vga_client_register(struct pci_dev *pdev, void *cookie,
715 void (*irq_set_state)(void *cookie, bool state),
716 unsigned int (*set_vga_decode)(void *cookie, bool decode))
719 struct vga_device *vgadev;
722 spin_lock_irqsave(&vga_lock, flags);
723 vgadev = vgadev_find(pdev);
727 vgadev->irq_set_state = irq_set_state;
728 vgadev->set_vga_decode = set_vga_decode;
729 vgadev->cookie = cookie;
733 spin_unlock_irqrestore(&vga_lock, flags);
737 EXPORT_SYMBOL(vga_client_register);
740 * Char driver implementation
744 * open : open user instance of the arbitrer. by default, it's
745 * attached to the default VGA device of the system.
747 * close : close user instance, release locks
749 * read : return a string indicating the status of the target.
750 * an IO state string is of the form {io,mem,io+mem,none},
751 * mc and ic are respectively mem and io lock counts (for
752 * debugging/diagnostic only). "decodes" indicate what the
753 * card currently decodes, "owns" indicates what is currently
754 * enabled on it, and "locks" indicates what is locked by this
755 * card. If the card is unplugged, we get "invalid" then for
756 * card_ID and an -ENODEV error is returned for any command
757 * until a new card is targeted
759 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
761 * write : write a command to the arbiter. List of commands is:
763 * target <card_ID> : switch target to card <card_ID> (see below)
764 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
765 * trylock <io_state> : non-blocking acquire locks on target
766 * unlock <io_state> : release locks on target
767 * unlock all : release all locks on target held by this user
768 * decodes <io_state> : set the legacy decoding attributes for the card
770 * poll : event if something change on any card (not just the target)
772 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
773 * to go back to the system default card (TODO: not implemented yet).
774 * Currently, only PCI is supported as a prefix, but the userland API may
775 * support other bus types in the future, even if the current kernel
776 * implementation doesn't.
780 * The driver keeps track of which user has what locks on which card. It
781 * supports stacking, like the kernel one. This complexifies the implementation
782 * a bit, but makes the arbiter more tolerant to userspace problems and able
783 * to properly cleanup in all cases when a process dies.
784 * Currently, a max of 16 cards simultaneously can have locks issued from
785 * userspace for a given user (file descriptor instance) of the arbiter.
787 * If the device is hot-unplugged, there is a hook inside the module to notify
788 * they being added/removed in the system and automatically added/removed in
792 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
793 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
796 * Each user has an array of these, tracking which cards have locks
798 struct vga_arb_user_card {
799 struct pci_dev *pdev;
800 unsigned int mem_cnt;
804 struct vga_arb_private {
805 struct list_head list;
806 struct pci_dev *target;
807 struct vga_arb_user_card cards[MAX_USER_CARDS];
811 static LIST_HEAD(vga_user_list);
812 static DEFINE_SPINLOCK(vga_user_lock);
816 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
817 * returns the respective values. If the string is not in this format,
820 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
821 unsigned int *bus, unsigned int *devfn)
824 unsigned int slot, func;
827 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
831 *devfn = PCI_DEVFN(slot, func);
836 static ssize_t vga_arb_read(struct file *file, char __user * buf,
837 size_t count, loff_t *ppos)
839 struct vga_arb_private *priv = file->private_data;
840 struct vga_device *vgadev;
841 struct pci_dev *pdev;
847 lbuf = kmalloc(1024, GFP_KERNEL);
851 /* Shields against vga_arb_device_card_gone (pci_dev going
852 * away), and allows access to vga list
854 spin_lock_irqsave(&vga_lock, flags);
856 /* If we are targeting the default, use it */
858 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
859 spin_unlock_irqrestore(&vga_lock, flags);
860 len = sprintf(lbuf, "invalid");
864 /* Find card vgadev structure */
865 vgadev = vgadev_find(pdev);
866 if (vgadev == NULL) {
867 /* Wow, it's not in the list, that shouldn't happen,
868 * let's fix us up and return invalid card
870 if (pdev == priv->target)
871 vga_arb_device_card_gone(pdev);
872 spin_unlock_irqrestore(&vga_lock, flags);
873 len = sprintf(lbuf, "invalid");
877 /* Fill the buffer with infos */
878 len = snprintf(lbuf, 1024,
879 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
880 vga_decode_count, pci_name(pdev),
881 vga_iostate_to_str(vgadev->decodes),
882 vga_iostate_to_str(vgadev->owns),
883 vga_iostate_to_str(vgadev->locks),
884 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
886 spin_unlock_irqrestore(&vga_lock, flags);
889 /* Copy that to user */
892 rc = copy_to_user(buf, lbuf, len);
900 * TODO: To avoid parsing inside kernel and to improve the speed we may
901 * consider use ioctl here
903 static ssize_t vga_arb_write(struct file *file, const char __user * buf,
904 size_t count, loff_t *ppos)
906 struct vga_arb_private *priv = file->private_data;
907 struct vga_arb_user_card *uc = NULL;
908 struct pci_dev *pdev;
910 unsigned int io_state;
912 char *kbuf, *curr_pos;
913 size_t remaining = count;
919 kbuf = kmalloc(count + 1, GFP_KERNEL);
923 if (copy_from_user(kbuf, buf, count)) {
928 kbuf[count] = '\0'; /* Just to make sure... */
930 if (strncmp(curr_pos, "lock ", 5) == 0) {
934 pr_debug("client 0x%p called 'lock'\n", priv);
936 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
940 if (io_state == VGA_RSRC_NONE) {
946 if (priv->target == NULL) {
951 vga_get_uninterruptible(pdev, io_state);
953 /* Update the client's locks lists... */
954 for (i = 0; i < MAX_USER_CARDS; i++) {
955 if (priv->cards[i].pdev == pdev) {
956 if (io_state & VGA_RSRC_LEGACY_IO)
957 priv->cards[i].io_cnt++;
958 if (io_state & VGA_RSRC_LEGACY_MEM)
959 priv->cards[i].mem_cnt++;
966 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
970 pr_debug("client 0x%p called 'unlock'\n", priv);
972 if (strncmp(curr_pos, "all", 3) == 0)
973 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
975 if (!vga_str_to_iostate
976 (curr_pos, remaining, &io_state)) {
981 if (io_state == VGA_RSRC_NONE) {
989 if (priv->target == NULL) {
993 for (i = 0; i < MAX_USER_CARDS; i++) {
994 if (priv->cards[i].pdev == pdev)
995 uc = &priv->cards[i];
1003 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1008 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1013 vga_put(pdev, io_state);
1015 if (io_state & VGA_RSRC_LEGACY_IO)
1017 if (io_state & VGA_RSRC_LEGACY_MEM)
1022 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1026 pr_debug("client 0x%p called 'trylock'\n", priv);
1028 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1033 if (io_state == VGA_RSRC_NONE) {
1039 pdev = priv->target;
1040 if (priv->target == NULL) {
1045 if (vga_tryget(pdev, io_state)) {
1046 /* Update the client's locks lists... */
1047 for (i = 0; i < MAX_USER_CARDS; i++) {
1048 if (priv->cards[i].pdev == pdev) {
1049 if (io_state & VGA_RSRC_LEGACY_IO)
1050 priv->cards[i].io_cnt++;
1051 if (io_state & VGA_RSRC_LEGACY_MEM)
1052 priv->cards[i].mem_cnt++;
1063 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1064 unsigned int domain, bus, devfn;
1065 struct vga_device *vgadev;
1069 pr_debug("client 0x%p called 'target'\n", priv);
1070 /* if target is default */
1071 if (!strncmp(curr_pos, "default", 7))
1072 pdev = pci_dev_get(vga_default_device());
1074 if (!vga_pci_str_to_vars(curr_pos, remaining,
1075 &domain, &bus, &devfn)) {
1079 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
1080 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1082 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1083 pr_debug("vgaarb: pdev %p\n", pdev);
1085 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1086 domain, bus, devfn);
1092 vgadev = vgadev_find(pdev);
1093 pr_debug("vgaarb: vgadev %p\n", vgadev);
1094 if (vgadev == NULL) {
1095 pr_err("vgaarb: this pci device is not a vga device\n");
1101 priv->target = pdev;
1102 for (i = 0; i < MAX_USER_CARDS; i++) {
1103 if (priv->cards[i].pdev == pdev)
1105 if (priv->cards[i].pdev == NULL) {
1106 priv->cards[i].pdev = pdev;
1107 priv->cards[i].io_cnt = 0;
1108 priv->cards[i].mem_cnt = 0;
1112 if (i == MAX_USER_CARDS) {
1113 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1116 /* XXX: which value to return? */
1126 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1129 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1131 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1135 pdev = priv->target;
1136 if (priv->target == NULL) {
1141 __vga_set_legacy_decoding(pdev, io_state, true);
1145 /* If we got here, the message written is not part of the protocol! */
1154 static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1156 struct vga_arb_private *priv = file->private_data;
1158 pr_debug("%s\n", __func__);
1162 poll_wait(file, &vga_wait_queue, wait);
1166 static int vga_arb_open(struct inode *inode, struct file *file)
1168 struct vga_arb_private *priv;
1169 unsigned long flags;
1171 pr_debug("%s\n", __func__);
1173 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1176 spin_lock_init(&priv->lock);
1177 file->private_data = priv;
1179 spin_lock_irqsave(&vga_user_lock, flags);
1180 list_add(&priv->list, &vga_user_list);
1181 spin_unlock_irqrestore(&vga_user_lock, flags);
1183 /* Set the client' lists of locks */
1184 priv->target = vga_default_device(); /* Maybe this is still null! */
1185 priv->cards[0].pdev = priv->target;
1186 priv->cards[0].io_cnt = 0;
1187 priv->cards[0].mem_cnt = 0;
1193 static int vga_arb_release(struct inode *inode, struct file *file)
1195 struct vga_arb_private *priv = file->private_data;
1196 struct vga_arb_user_card *uc;
1197 unsigned long flags;
1200 pr_debug("%s\n", __func__);
1205 spin_lock_irqsave(&vga_user_lock, flags);
1206 list_del(&priv->list);
1207 for (i = 0; i < MAX_USER_CARDS; i++) {
1208 uc = &priv->cards[i];
1209 if (uc->pdev == NULL)
1211 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1212 uc->io_cnt, uc->mem_cnt);
1213 while (uc->io_cnt--)
1214 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1215 while (uc->mem_cnt--)
1216 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1218 spin_unlock_irqrestore(&vga_user_lock, flags);
1225 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1230 * callback any registered clients to let them know we have a
1231 * change in VGA cards
1233 static void vga_arbiter_notify_clients(void)
1235 struct vga_device *vgadev;
1236 unsigned long flags;
1237 uint32_t new_decodes;
1240 if (!vga_arbiter_used)
1243 spin_lock_irqsave(&vga_lock, flags);
1244 list_for_each_entry(vgadev, &vga_list, list) {
1249 if (vgadev->set_vga_decode) {
1250 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1251 vga_update_device_decodes(vgadev, new_decodes);
1254 spin_unlock_irqrestore(&vga_lock, flags);
1257 static int pci_notify(struct notifier_block *nb, unsigned long action,
1260 struct device *dev = data;
1261 struct pci_dev *pdev = to_pci_dev(dev);
1262 bool notify = false;
1264 pr_debug("%s\n", __func__);
1266 /* For now we're only intereted in devices added and removed. I didn't
1267 * test this thing here, so someone needs to double check for the
1268 * cases of hotplugable vga cards. */
1269 if (action == BUS_NOTIFY_ADD_DEVICE)
1270 notify = vga_arbiter_add_pci_device(pdev);
1271 else if (action == BUS_NOTIFY_DEL_DEVICE)
1272 notify = vga_arbiter_del_pci_device(pdev);
1275 vga_arbiter_notify_clients();
1279 static struct notifier_block pci_notifier = {
1280 .notifier_call = pci_notify,
1283 static const struct file_operations vga_arb_device_fops = {
1284 .read = vga_arb_read,
1285 .write = vga_arb_write,
1286 .poll = vga_arb_fpoll,
1287 .open = vga_arb_open,
1288 .release = vga_arb_release,
1289 .llseek = noop_llseek,
1292 static struct miscdevice vga_arb_device = {
1293 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1296 static int __init vga_arb_device_init(void)
1299 struct pci_dev *pdev;
1300 struct vga_device *vgadev;
1302 rc = misc_register(&vga_arb_device);
1304 pr_err("vgaarb: error %d registering device\n", rc);
1306 bus_register_notifier(&pci_bus_type, &pci_notifier);
1308 /* We add all pci devices satisfying vga class in the arbiter by
1312 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1313 PCI_ANY_ID, pdev)) != NULL)
1314 vga_arbiter_add_pci_device(pdev);
1316 pr_info("vgaarb: loaded\n");
1318 list_for_each_entry(vgadev, &vga_list, list) {
1319 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
1320 /* Override I/O based detection done by vga_arbiter_add_pci_device()
1321 * as it may take the wrong device (e.g. on Apple system under EFI).
1323 * Select the device owning the boot framebuffer if there is one.
1325 resource_size_t start, end;
1328 /* Does firmware framebuffer belong to us? */
1329 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
1330 if (!(pci_resource_flags(vgadev->pdev, i) & IORESOURCE_MEM))
1333 start = pci_resource_start(vgadev->pdev, i);
1334 end = pci_resource_end(vgadev->pdev, i);
1339 if (screen_info.lfb_base < start ||
1340 (screen_info.lfb_base + screen_info.lfb_size) >= end)
1342 if (!vga_default_device())
1343 pr_info("vgaarb: setting as boot device: PCI:%s\n",
1344 pci_name(vgadev->pdev));
1345 else if (vgadev->pdev != vga_default_device())
1346 pr_info("vgaarb: overriding boot device: PCI:%s\n",
1347 pci_name(vgadev->pdev));
1348 vga_set_default_device(vgadev->pdev);
1351 if (vgadev->bridge_has_one_vga)
1352 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1354 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1358 subsys_initcall(vga_arb_device_init);