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 #define pr_fmt(fmt) "vgaarb: " fmt
34 #include <linux/module.h>
35 #include <linux/kernel.h>
36 #include <linux/pci.h>
37 #include <linux/errno.h>
38 #include <linux/init.h>
39 #include <linux/list.h>
40 #include <linux/sched.h>
41 #include <linux/wait.h>
42 #include <linux/spinlock.h>
43 #include <linux/poll.h>
44 #include <linux/miscdevice.h>
45 #include <linux/slab.h>
46 #include <linux/screen_info.h>
48 #include <linux/uaccess.h>
50 #include <linux/vgaarb.h>
52 static void vga_arbiter_notify_clients(void);
54 * We keep a list of all vga devices in the system to speed
55 * up the various operations of the arbiter
58 struct list_head list;
60 unsigned int decodes; /* what does it decodes */
61 unsigned int owns; /* what does it owns */
62 unsigned int locks; /* what does it locks */
63 unsigned int io_lock_cnt; /* legacy IO lock count */
64 unsigned int mem_lock_cnt; /* legacy MEM lock count */
65 unsigned int io_norm_cnt; /* normal IO count */
66 unsigned int mem_norm_cnt; /* normal MEM count */
67 bool bridge_has_one_vga;
68 /* allow IRQ enable/disable hook */
70 void (*irq_set_state)(void *cookie, bool enable);
71 unsigned int (*set_vga_decode)(void *cookie, bool decode);
74 static LIST_HEAD(vga_list);
75 static int vga_count, vga_decode_count;
76 static bool vga_arbiter_used;
77 static DEFINE_SPINLOCK(vga_lock);
78 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
81 static const char *vga_iostate_to_str(unsigned int iostate)
83 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
84 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
86 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
88 case VGA_RSRC_LEGACY_IO:
90 case VGA_RSRC_LEGACY_MEM:
96 static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
98 /* we could in theory hand out locks on IO and mem
99 * separately to userspace but it can cause deadlocks */
100 if (strncmp(buf, "none", 4) == 0) {
101 *io_state = VGA_RSRC_NONE;
105 /* XXX We're not chekcing the str_size! */
106 if (strncmp(buf, "io+mem", 6) == 0)
108 else if (strncmp(buf, "io", 2) == 0)
110 else if (strncmp(buf, "mem", 3) == 0)
114 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
118 /* this is only used a cookie - it should not be dereferenced */
119 static struct pci_dev *vga_default;
121 static void vga_arb_device_card_gone(struct pci_dev *pdev);
123 /* Find somebody in our list */
124 static struct vga_device *vgadev_find(struct pci_dev *pdev)
126 struct vga_device *vgadev;
128 list_for_each_entry(vgadev, &vga_list, list)
129 if (pdev == vgadev->pdev)
134 /* Returns the default VGA device (vgacon's babe) */
135 struct pci_dev *vga_default_device(void)
139 EXPORT_SYMBOL_GPL(vga_default_device);
141 void vga_set_default_device(struct pci_dev *pdev)
143 if (vga_default == pdev)
146 pci_dev_put(vga_default);
147 vga_default = pci_dev_get(pdev);
150 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
152 if (vgadev->irq_set_state)
153 vgadev->irq_set_state(vgadev->cookie, state);
157 /* If we don't ever use VGA arb we should avoid
158 turning off anything anywhere due to old X servers getting
159 confused about the boot device not being VGA */
160 static void vga_check_first_use(void)
162 /* we should inform all GPUs in the system that
163 * VGA arb has occurred and to try and disable resources
165 if (!vga_arbiter_used) {
166 vga_arbiter_used = true;
167 vga_arbiter_notify_clients();
171 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
174 unsigned int wants, legacy_wants, match;
175 struct vga_device *conflict;
176 unsigned int pci_bits;
179 /* Account for "normal" resources to lock. If we decode the legacy,
180 * counterpart, we need to request it as well
182 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
183 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
184 rsrc |= VGA_RSRC_LEGACY_IO;
185 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
186 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
187 rsrc |= VGA_RSRC_LEGACY_MEM;
189 pr_debug("%s: %d\n", __func__, rsrc);
190 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
192 /* Check what resources we need to acquire */
193 wants = rsrc & ~vgadev->owns;
195 /* We already own everything, just mark locked & bye bye */
199 /* We don't need to request a legacy resource, we just enable
200 * appropriate decoding and go
202 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
203 if (legacy_wants == 0)
206 /* Ok, we don't, let's find out how we need to kick off */
207 list_for_each_entry(conflict, &vga_list, list) {
208 unsigned int lwants = legacy_wants;
209 unsigned int change_bridge = 0;
211 /* Don't conflict with myself */
212 if (vgadev == conflict)
215 /* Check if the architecture allows a conflict between those
216 * 2 devices or if they are on separate domains
218 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
221 /* We have a possible conflict. before we go further, we must
222 * check if we sit on the same bus as the conflicting device.
223 * if we don't, then we must tie both IO and MEM resources
224 * together since there is only a single bit controlling
225 * VGA forwarding on P2P bridges
227 if (vgadev->pdev->bus != conflict->pdev->bus) {
229 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
232 /* Check if the guy has a lock on the resource. If he does,
233 * return the conflicting entry
235 if (conflict->locks & lwants)
238 /* Ok, now check if it owns the resource we want. We can
239 * lock resources that are not decoded, therefore a device
240 * can own resources it doesn't decode.
242 match = lwants & conflict->owns;
246 /* looks like he doesn't have a lock, we can steal
253 /* If we can't control legacy resources via the bridge, we
254 * also need to disable normal decoding.
256 if (!conflict->bridge_has_one_vga) {
257 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)
258 pci_bits |= PCI_COMMAND_MEMORY;
259 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)
260 pci_bits |= PCI_COMMAND_IO;
263 vga_irq_set_state(conflict, false);
264 flags |= PCI_VGA_STATE_CHANGE_DECODES;
269 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
271 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
272 conflict->owns &= ~match;
274 /* If we disabled normal decoding, reflect it in owns */
275 if (pci_bits & PCI_COMMAND_MEMORY)
276 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
277 if (pci_bits & PCI_COMMAND_IO)
278 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
282 /* ok dude, we got it, everybody conflicting has been disabled, let's
283 * enable us. Mark any bits in "owns" regardless of whether we
284 * decoded them. We can lock resources we don't decode, therefore
285 * we must track them via "owns".
290 if (!vgadev->bridge_has_one_vga) {
291 flags |= PCI_VGA_STATE_CHANGE_DECODES;
292 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
293 pci_bits |= PCI_COMMAND_MEMORY;
294 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
295 pci_bits |= PCI_COMMAND_IO;
297 if (wants & VGA_RSRC_LEGACY_MASK)
298 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
300 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
302 if (!vgadev->bridge_has_one_vga)
303 vga_irq_set_state(vgadev, true);
305 vgadev->owns |= wants;
307 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
308 if (rsrc & VGA_RSRC_LEGACY_IO)
309 vgadev->io_lock_cnt++;
310 if (rsrc & VGA_RSRC_LEGACY_MEM)
311 vgadev->mem_lock_cnt++;
312 if (rsrc & VGA_RSRC_NORMAL_IO)
313 vgadev->io_norm_cnt++;
314 if (rsrc & VGA_RSRC_NORMAL_MEM)
315 vgadev->mem_norm_cnt++;
320 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
322 unsigned int old_locks = vgadev->locks;
324 pr_debug("%s\n", __func__);
326 /* Update our counters, and account for equivalent legacy resources
329 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
330 vgadev->io_norm_cnt--;
331 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
332 rsrc |= VGA_RSRC_LEGACY_IO;
334 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
335 vgadev->mem_norm_cnt--;
336 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
337 rsrc |= VGA_RSRC_LEGACY_MEM;
339 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
340 vgadev->io_lock_cnt--;
341 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
342 vgadev->mem_lock_cnt--;
344 /* Just clear lock bits, we do lazy operations so we don't really
345 * have to bother about anything else at this point
347 if (vgadev->io_lock_cnt == 0)
348 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
349 if (vgadev->mem_lock_cnt == 0)
350 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
352 /* Kick the wait queue in case somebody was waiting if we actually
355 if (old_locks != vgadev->locks)
356 wake_up_all(&vga_wait_queue);
359 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
361 struct vga_device *vgadev, *conflict;
366 vga_check_first_use();
367 /* The one who calls us should check for this, but lets be sure... */
369 pdev = vga_default_device();
374 spin_lock_irqsave(&vga_lock, flags);
375 vgadev = vgadev_find(pdev);
376 if (vgadev == NULL) {
377 spin_unlock_irqrestore(&vga_lock, flags);
381 conflict = __vga_tryget(vgadev, rsrc);
382 spin_unlock_irqrestore(&vga_lock, flags);
383 if (conflict == NULL)
387 /* We have a conflict, we wait until somebody kicks the
388 * work queue. Currently we have one work queue that we
389 * kick each time some resources are released, but it would
390 * be fairly easy to have a per device one so that we only
391 * need to attach to the conflicting device
393 init_waitqueue_entry(&wait, current);
394 add_wait_queue(&vga_wait_queue, &wait);
395 set_current_state(interruptible ?
397 TASK_UNINTERRUPTIBLE);
398 if (signal_pending(current)) {
403 remove_wait_queue(&vga_wait_queue, &wait);
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);
457 * Rules for using a bridge to control a VGA descendant decoding: if a bridge
458 * has only one VGA descendant then it can be used to control the VGA routing
459 * for that device. It should always use the bridge closest to the device to
460 * control it. If a bridge has a direct VGA descendant, but also have a sub-
461 * bridge VGA descendant then we cannot use that bridge to control the direct
462 * VGA descendant. So for every device we register, we need to iterate all
463 * its parent bridges 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) {
489 * If their direct parent bridge is the same
490 * as any bridge of this device then it can't
491 * be used for that device.
493 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
499 * devices hierarchy then we can't use it to control
505 if (bridge && bridge == vgadev->pdev->bus->self)
506 vgadev->bridge_has_one_vga = false;
511 new_bus = new_bus->parent;
516 * Currently, we assume that the "initial" setup of the system is
517 * not sane, that is we come up with conflicting devices and let
518 * the arbiter's client decides if devices decodes or not legacy
521 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
523 struct vga_device *vgadev;
526 struct pci_dev *bridge;
529 /* Only deal with VGA class devices */
530 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
533 /* Allocate structure */
534 vgadev = kzalloc(sizeof(struct vga_device), GFP_KERNEL);
535 if (vgadev == NULL) {
536 pr_err("failed to allocate pci device\n");
538 * What to do on allocation failure ? For now, let's just do
539 * nothing, I'm not sure there is anything saner to be done.
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 */
574 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &l);
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 if (vga_default == NULL &&
587 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) {
588 pr_info("setting as boot device: PCI:%s\n", pci_name(pdev));
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("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 if (vga_default == pdev)
625 vga_set_default_device(NULL);
627 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
630 /* Remove entry from list */
631 list_del(&vgadev->list);
633 /* Notify userland driver that the device is gone so it discards
634 * it's copies of the pci_dev pointer
636 vga_arb_device_card_gone(pdev);
638 /* Wake up all possible waiters */
639 wake_up_all(&vga_wait_queue);
641 spin_unlock_irqrestore(&vga_lock, flags);
646 /* this is called with the lock */
647 static inline void vga_update_device_decodes(struct vga_device *vgadev,
650 int old_decodes, decodes_removed, decodes_unlocked;
652 old_decodes = vgadev->decodes;
653 decodes_removed = ~new_decodes & old_decodes;
654 decodes_unlocked = vgadev->locks & decodes_removed;
655 vgadev->decodes = new_decodes;
657 pr_info("device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
658 pci_name(vgadev->pdev),
659 vga_iostate_to_str(old_decodes),
660 vga_iostate_to_str(vgadev->decodes),
661 vga_iostate_to_str(vgadev->owns));
663 /* if we removed locked decodes, lock count goes to zero, and release */
664 if (decodes_unlocked) {
665 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
666 vgadev->io_lock_cnt = 0;
667 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
668 vgadev->mem_lock_cnt = 0;
669 __vga_put(vgadev, decodes_unlocked);
672 /* change decodes counter */
673 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
674 !(new_decodes & VGA_RSRC_LEGACY_MASK))
676 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
677 new_decodes & VGA_RSRC_LEGACY_MASK)
679 pr_debug("decoding count now is: %d\n", vga_decode_count);
682 static void __vga_set_legacy_decoding(struct pci_dev *pdev,
683 unsigned int decodes,
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,
724 struct vga_device *vgadev;
727 spin_lock_irqsave(&vga_lock, flags);
728 vgadev = vgadev_find(pdev);
732 vgadev->irq_set_state = irq_set_state;
733 vgadev->set_vga_decode = set_vga_decode;
734 vgadev->cookie = cookie;
738 spin_unlock_irqrestore(&vga_lock, flags);
742 EXPORT_SYMBOL(vga_client_register);
745 * Char driver implementation
749 * open : open user instance of the arbitrer. by default, it's
750 * attached to the default VGA device of the system.
752 * close : close user instance, release locks
754 * read : return a string indicating the status of the target.
755 * an IO state string is of the form {io,mem,io+mem,none},
756 * mc and ic are respectively mem and io lock counts (for
757 * debugging/diagnostic only). "decodes" indicate what the
758 * card currently decodes, "owns" indicates what is currently
759 * enabled on it, and "locks" indicates what is locked by this
760 * card. If the card is unplugged, we get "invalid" then for
761 * card_ID and an -ENODEV error is returned for any command
762 * until a new card is targeted
764 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
766 * write : write a command to the arbiter. List of commands is:
768 * target <card_ID> : switch target to card <card_ID> (see below)
769 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
770 * trylock <io_state> : non-blocking acquire locks on target
771 * unlock <io_state> : release locks on target
772 * unlock all : release all locks on target held by this user
773 * decodes <io_state> : set the legacy decoding attributes for the card
775 * poll : event if something change on any card (not just the target)
777 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
778 * to go back to the system default card (TODO: not implemented yet).
779 * Currently, only PCI is supported as a prefix, but the userland API may
780 * support other bus types in the future, even if the current kernel
781 * implementation doesn't.
785 * The driver keeps track of which user has what locks on which card. It
786 * supports stacking, like the kernel one. This complexifies the implementation
787 * a bit, but makes the arbiter more tolerant to userspace problems and able
788 * to properly cleanup in all cases when a process dies.
789 * Currently, a max of 16 cards simultaneously can have locks issued from
790 * userspace for a given user (file descriptor instance) of the arbiter.
792 * If the device is hot-unplugged, there is a hook inside the module to notify
793 * they being added/removed in the system and automatically added/removed in
797 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
798 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
801 * Each user has an array of these, tracking which cards have locks
803 struct vga_arb_user_card {
804 struct pci_dev *pdev;
805 unsigned int mem_cnt;
809 struct vga_arb_private {
810 struct list_head list;
811 struct pci_dev *target;
812 struct vga_arb_user_card cards[MAX_USER_CARDS];
816 static LIST_HEAD(vga_user_list);
817 static DEFINE_SPINLOCK(vga_user_lock);
821 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
822 * returns the respective values. If the string is not in this format,
825 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
826 unsigned int *bus, unsigned int *devfn)
829 unsigned int slot, func;
832 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
836 *devfn = PCI_DEVFN(slot, func);
841 static ssize_t vga_arb_read(struct file *file, char __user *buf,
842 size_t count, loff_t *ppos)
844 struct vga_arb_private *priv = file->private_data;
845 struct vga_device *vgadev;
846 struct pci_dev *pdev;
852 lbuf = kmalloc(1024, GFP_KERNEL);
856 /* Shields against vga_arb_device_card_gone (pci_dev going
857 * away), and allows access to vga list
859 spin_lock_irqsave(&vga_lock, flags);
861 /* If we are targeting the default, use it */
863 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
864 spin_unlock_irqrestore(&vga_lock, flags);
865 len = sprintf(lbuf, "invalid");
869 /* Find card vgadev structure */
870 vgadev = vgadev_find(pdev);
871 if (vgadev == NULL) {
872 /* Wow, it's not in the list, that shouldn't happen,
873 * let's fix us up and return invalid card
875 if (pdev == priv->target)
876 vga_arb_device_card_gone(pdev);
877 spin_unlock_irqrestore(&vga_lock, flags);
878 len = sprintf(lbuf, "invalid");
882 /* Fill the buffer with infos */
883 len = snprintf(lbuf, 1024,
884 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
885 vga_decode_count, pci_name(pdev),
886 vga_iostate_to_str(vgadev->decodes),
887 vga_iostate_to_str(vgadev->owns),
888 vga_iostate_to_str(vgadev->locks),
889 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
891 spin_unlock_irqrestore(&vga_lock, flags);
894 /* Copy that to user */
897 rc = copy_to_user(buf, lbuf, len);
905 * TODO: To avoid parsing inside kernel and to improve the speed we may
906 * consider use ioctl here
908 static ssize_t vga_arb_write(struct file *file, const char __user *buf,
909 size_t count, loff_t *ppos)
911 struct vga_arb_private *priv = file->private_data;
912 struct vga_arb_user_card *uc = NULL;
913 struct pci_dev *pdev;
915 unsigned int io_state;
917 char *kbuf, *curr_pos;
918 size_t remaining = count;
924 kbuf = kmalloc(count + 1, GFP_KERNEL);
928 if (copy_from_user(kbuf, buf, count)) {
933 kbuf[count] = '\0'; /* Just to make sure... */
935 if (strncmp(curr_pos, "lock ", 5) == 0) {
939 pr_debug("client 0x%p called 'lock'\n", priv);
941 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
945 if (io_state == VGA_RSRC_NONE) {
951 if (priv->target == NULL) {
956 vga_get_uninterruptible(pdev, io_state);
958 /* Update the client's locks lists... */
959 for (i = 0; i < MAX_USER_CARDS; i++) {
960 if (priv->cards[i].pdev == pdev) {
961 if (io_state & VGA_RSRC_LEGACY_IO)
962 priv->cards[i].io_cnt++;
963 if (io_state & VGA_RSRC_LEGACY_MEM)
964 priv->cards[i].mem_cnt++;
971 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
975 pr_debug("client 0x%p called 'unlock'\n", priv);
977 if (strncmp(curr_pos, "all", 3) == 0)
978 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
980 if (!vga_str_to_iostate
981 (curr_pos, remaining, &io_state)) {
986 if (io_state == VGA_RSRC_NONE) {
994 if (priv->target == NULL) {
998 for (i = 0; i < MAX_USER_CARDS; i++) {
999 if (priv->cards[i].pdev == pdev)
1000 uc = &priv->cards[i];
1008 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1013 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1018 vga_put(pdev, io_state);
1020 if (io_state & VGA_RSRC_LEGACY_IO)
1022 if (io_state & VGA_RSRC_LEGACY_MEM)
1027 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1031 pr_debug("client 0x%p called 'trylock'\n", priv);
1033 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1038 if (io_state == VGA_RSRC_NONE) {
1044 pdev = priv->target;
1045 if (priv->target == NULL) {
1050 if (vga_tryget(pdev, io_state)) {
1051 /* Update the client's locks lists... */
1052 for (i = 0; i < MAX_USER_CARDS; i++) {
1053 if (priv->cards[i].pdev == pdev) {
1054 if (io_state & VGA_RSRC_LEGACY_IO)
1055 priv->cards[i].io_cnt++;
1056 if (io_state & VGA_RSRC_LEGACY_MEM)
1057 priv->cards[i].mem_cnt++;
1068 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1069 unsigned int domain, bus, devfn;
1070 struct vga_device *vgadev;
1074 pr_debug("client 0x%p called 'target'\n", priv);
1075 /* if target is default */
1076 if (!strncmp(curr_pos, "default", 7))
1077 pdev = pci_dev_get(vga_default_device());
1079 if (!vga_pci_str_to_vars(curr_pos, remaining,
1080 &domain, &bus, &devfn)) {
1084 pr_debug("%s ==> %x:%x:%x.%x\n", curr_pos,
1085 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1087 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1088 pr_debug("pdev %p\n", pdev);
1090 pr_err("invalid PCI address %x:%x:%x\n",
1091 domain, bus, devfn);
1097 vgadev = vgadev_find(pdev);
1098 pr_debug("vgadev %p\n", vgadev);
1099 if (vgadev == NULL) {
1101 pr_err("this pci device is not a vga device\n");
1109 priv->target = pdev;
1110 for (i = 0; i < MAX_USER_CARDS; i++) {
1111 if (priv->cards[i].pdev == pdev)
1113 if (priv->cards[i].pdev == NULL) {
1114 priv->cards[i].pdev = pdev;
1115 priv->cards[i].io_cnt = 0;
1116 priv->cards[i].mem_cnt = 0;
1120 if (i == MAX_USER_CARDS) {
1121 pr_err("maximum user cards (%d) number reached!\n",
1124 /* XXX: which value to return? */
1134 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1137 pr_debug("client 0x%p called 'decodes'\n", priv);
1139 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1143 pdev = priv->target;
1144 if (priv->target == NULL) {
1149 __vga_set_legacy_decoding(pdev, io_state, true);
1153 /* If we got here, the message written is not part of the protocol! */
1162 static unsigned int vga_arb_fpoll(struct file *file, poll_table *wait)
1164 struct vga_arb_private *priv = file->private_data;
1166 pr_debug("%s\n", __func__);
1170 poll_wait(file, &vga_wait_queue, wait);
1174 static int vga_arb_open(struct inode *inode, struct file *file)
1176 struct vga_arb_private *priv;
1177 unsigned long flags;
1179 pr_debug("%s\n", __func__);
1181 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1184 spin_lock_init(&priv->lock);
1185 file->private_data = priv;
1187 spin_lock_irqsave(&vga_user_lock, flags);
1188 list_add(&priv->list, &vga_user_list);
1189 spin_unlock_irqrestore(&vga_user_lock, flags);
1191 /* Set the client' lists of locks */
1192 priv->target = vga_default_device(); /* Maybe this is still null! */
1193 priv->cards[0].pdev = priv->target;
1194 priv->cards[0].io_cnt = 0;
1195 priv->cards[0].mem_cnt = 0;
1201 static int vga_arb_release(struct inode *inode, struct file *file)
1203 struct vga_arb_private *priv = file->private_data;
1204 struct vga_arb_user_card *uc;
1205 unsigned long flags;
1208 pr_debug("%s\n", __func__);
1213 spin_lock_irqsave(&vga_user_lock, flags);
1214 list_del(&priv->list);
1215 for (i = 0; i < MAX_USER_CARDS; i++) {
1216 uc = &priv->cards[i];
1217 if (uc->pdev == NULL)
1219 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1220 uc->io_cnt, uc->mem_cnt);
1221 while (uc->io_cnt--)
1222 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1223 while (uc->mem_cnt--)
1224 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1226 spin_unlock_irqrestore(&vga_user_lock, flags);
1233 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1238 * callback any registered clients to let them know we have a
1239 * change in VGA cards
1241 static void vga_arbiter_notify_clients(void)
1243 struct vga_device *vgadev;
1244 unsigned long flags;
1245 uint32_t new_decodes;
1248 if (!vga_arbiter_used)
1251 spin_lock_irqsave(&vga_lock, flags);
1252 list_for_each_entry(vgadev, &vga_list, list) {
1257 if (vgadev->set_vga_decode) {
1258 new_decodes = vgadev->set_vga_decode(vgadev->cookie,
1260 vga_update_device_decodes(vgadev, new_decodes);
1263 spin_unlock_irqrestore(&vga_lock, flags);
1266 static int pci_notify(struct notifier_block *nb, unsigned long action,
1269 struct device *dev = data;
1270 struct pci_dev *pdev = to_pci_dev(dev);
1271 bool notify = false;
1273 pr_debug("%s\n", __func__);
1275 /* For now we're only intereted in devices added and removed. I didn't
1276 * test this thing here, so someone needs to double check for the
1277 * cases of hotplugable vga cards. */
1278 if (action == BUS_NOTIFY_ADD_DEVICE)
1279 notify = vga_arbiter_add_pci_device(pdev);
1280 else if (action == BUS_NOTIFY_DEL_DEVICE)
1281 notify = vga_arbiter_del_pci_device(pdev);
1284 vga_arbiter_notify_clients();
1288 static struct notifier_block pci_notifier = {
1289 .notifier_call = pci_notify,
1292 static const struct file_operations vga_arb_device_fops = {
1293 .read = vga_arb_read,
1294 .write = vga_arb_write,
1295 .poll = vga_arb_fpoll,
1296 .open = vga_arb_open,
1297 .release = vga_arb_release,
1298 .llseek = noop_llseek,
1301 static struct miscdevice vga_arb_device = {
1302 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1305 static int __init vga_arb_device_init(void)
1308 struct pci_dev *pdev;
1309 struct vga_device *vgadev;
1311 rc = misc_register(&vga_arb_device);
1313 pr_err("error %d registering device\n", rc);
1315 bus_register_notifier(&pci_bus_type, &pci_notifier);
1317 /* We add all pci devices satisfying vga class in the arbiter by
1321 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1322 PCI_ANY_ID, pdev)) != NULL)
1323 vga_arbiter_add_pci_device(pdev);
1325 pr_info("loaded\n");
1327 list_for_each_entry(vgadev, &vga_list, list) {
1328 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
1330 * Override vga_arbiter_add_pci_device()'s I/O based detection
1331 * as it may take the wrong device (e.g. on Apple system under
1334 * Select the device owning the boot framebuffer if there is
1337 resource_size_t start, end, limit;
1338 unsigned long flags;
1341 limit = screen_info.lfb_base + screen_info.lfb_size;
1343 /* Does firmware framebuffer belong to us? */
1344 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
1345 flags = pci_resource_flags(vgadev->pdev, i);
1347 if ((flags & IORESOURCE_MEM) == 0)
1350 start = pci_resource_start(vgadev->pdev, i);
1351 end = pci_resource_end(vgadev->pdev, i);
1356 if (screen_info.lfb_base < start || limit >= end)
1359 if (!vga_default_device())
1360 pr_info("setting as boot device: PCI:%s\n",
1361 pci_name(vgadev->pdev));
1362 else if (vgadev->pdev != vga_default_device())
1363 pr_info("overriding boot device: PCI:%s\n",
1364 pci_name(vgadev->pdev));
1365 vga_set_default_device(vgadev->pdev);
1368 if (vgadev->bridge_has_one_vga)
1369 pr_info("bridge control possible %s\n",
1370 pci_name(vgadev->pdev));
1372 pr_info("no bridge control possible %s\n",
1373 pci_name(vgadev->pdev));
1377 subsys_initcall(vga_arb_device_init);