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
);