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)
140 EXPORT_SYMBOL_GPL(vga_default_device
);
142 void vga_set_default_device(struct pci_dev
*pdev
)
144 if (vga_default
== pdev
)
147 pci_dev_put(vga_default
);
148 vga_default
= pci_dev_get(pdev
);
151 static inline void vga_irq_set_state(struct vga_device
*vgadev
, bool state
)
153 if (vgadev
->irq_set_state
)
154 vgadev
->irq_set_state(vgadev
->cookie
, state
);
158 /* If we don't ever use VGA arb we should avoid
159 turning off anything anywhere due to old X servers getting
160 confused about the boot device not being VGA */
161 static void vga_check_first_use(void)
163 /* we should inform all GPUs in the system that
164 * VGA arb has occurred and to try and disable resources
166 if (!vga_arbiter_used
) {
167 vga_arbiter_used
= true;
168 vga_arbiter_notify_clients();
172 static struct vga_device
*__vga_tryget(struct vga_device
*vgadev
,
175 unsigned int wants
, legacy_wants
, match
;
176 struct vga_device
*conflict
;
177 unsigned int pci_bits
;
180 /* Account for "normal" resources to lock. If we decode the legacy,
181 * counterpart, we need to request it as well
183 if ((rsrc
& VGA_RSRC_NORMAL_IO
) &&
184 (vgadev
->decodes
& VGA_RSRC_LEGACY_IO
))
185 rsrc
|= VGA_RSRC_LEGACY_IO
;
186 if ((rsrc
& VGA_RSRC_NORMAL_MEM
) &&
187 (vgadev
->decodes
& VGA_RSRC_LEGACY_MEM
))
188 rsrc
|= VGA_RSRC_LEGACY_MEM
;
190 pr_debug("%s: %d\n", __func__
, rsrc
);
191 pr_debug("%s: owns: %d\n", __func__
, vgadev
->owns
);
193 /* Check what resources we need to acquire */
194 wants
= rsrc
& ~vgadev
->owns
;
196 /* We already own everything, just mark locked & bye bye */
200 /* We don't need to request a legacy resource, we just enable
201 * appropriate decoding and go
203 legacy_wants
= wants
& VGA_RSRC_LEGACY_MASK
;
204 if (legacy_wants
== 0)
207 /* Ok, we don't, let's find out how we need to kick off */
208 list_for_each_entry(conflict
, &vga_list
, list
) {
209 unsigned int lwants
= legacy_wants
;
210 unsigned int change_bridge
= 0;
212 /* Don't conflict with myself */
213 if (vgadev
== conflict
)
216 /* Check if the architecture allows a conflict between those
217 * 2 devices or if they are on separate domains
219 if (!vga_conflicts(vgadev
->pdev
, conflict
->pdev
))
222 /* We have a possible conflict. before we go further, we must
223 * check if we sit on the same bus as the conflicting device.
224 * if we don't, then we must tie both IO and MEM resources
225 * together since there is only a single bit controlling
226 * VGA forwarding on P2P bridges
228 if (vgadev
->pdev
->bus
!= conflict
->pdev
->bus
) {
230 lwants
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
;
233 /* Check if the guy has a lock on the resource. If he does,
234 * return the conflicting entry
236 if (conflict
->locks
& lwants
)
239 /* Ok, now check if it owns the resource we want. We can
240 * lock resources that are not decoded, therefore a device
241 * can own resources it doesn't decode.
243 match
= lwants
& conflict
->owns
;
247 /* looks like he doesn't have a lock, we can steal
254 /* If we can't control legacy resources via the bridge, we
255 * also need to disable normal decoding.
257 if (!conflict
->bridge_has_one_vga
) {
258 if ((match
& conflict
->decodes
) & VGA_RSRC_LEGACY_MEM
)
259 pci_bits
|= PCI_COMMAND_MEMORY
;
260 if ((match
& conflict
->decodes
) & VGA_RSRC_LEGACY_IO
)
261 pci_bits
|= PCI_COMMAND_IO
;
264 vga_irq_set_state(conflict
, false);
265 flags
|= PCI_VGA_STATE_CHANGE_DECODES
;
270 flags
|= PCI_VGA_STATE_CHANGE_BRIDGE
;
272 pci_set_vga_state(conflict
->pdev
, false, pci_bits
, flags
);
273 conflict
->owns
&= ~match
;
275 /* If we disabled normal decoding, reflect it in owns */
276 if (pci_bits
& PCI_COMMAND_MEMORY
)
277 conflict
->owns
&= ~VGA_RSRC_NORMAL_MEM
;
278 if (pci_bits
& PCI_COMMAND_IO
)
279 conflict
->owns
&= ~VGA_RSRC_NORMAL_IO
;
283 /* ok dude, we got it, everybody conflicting has been disabled, let's
284 * enable us. Mark any bits in "owns" regardless of whether we
285 * decoded them. We can lock resources we don't decode, therefore
286 * we must track them via "owns".
291 if (!vgadev
->bridge_has_one_vga
) {
292 flags
|= PCI_VGA_STATE_CHANGE_DECODES
;
293 if (wants
& (VGA_RSRC_LEGACY_MEM
|VGA_RSRC_NORMAL_MEM
))
294 pci_bits
|= PCI_COMMAND_MEMORY
;
295 if (wants
& (VGA_RSRC_LEGACY_IO
|VGA_RSRC_NORMAL_IO
))
296 pci_bits
|= PCI_COMMAND_IO
;
298 if (wants
& VGA_RSRC_LEGACY_MASK
)
299 flags
|= PCI_VGA_STATE_CHANGE_BRIDGE
;
301 pci_set_vga_state(vgadev
->pdev
, true, pci_bits
, flags
);
303 if (!vgadev
->bridge_has_one_vga
) {
304 vga_irq_set_state(vgadev
, true);
306 vgadev
->owns
|= wants
;
308 vgadev
->locks
|= (rsrc
& VGA_RSRC_LEGACY_MASK
);
309 if (rsrc
& VGA_RSRC_LEGACY_IO
)
310 vgadev
->io_lock_cnt
++;
311 if (rsrc
& VGA_RSRC_LEGACY_MEM
)
312 vgadev
->mem_lock_cnt
++;
313 if (rsrc
& VGA_RSRC_NORMAL_IO
)
314 vgadev
->io_norm_cnt
++;
315 if (rsrc
& VGA_RSRC_NORMAL_MEM
)
316 vgadev
->mem_norm_cnt
++;
321 static void __vga_put(struct vga_device
*vgadev
, unsigned int rsrc
)
323 unsigned int old_locks
= vgadev
->locks
;
325 pr_debug("%s\n", __func__
);
327 /* Update our counters, and account for equivalent legacy resources
330 if ((rsrc
& VGA_RSRC_NORMAL_IO
) && vgadev
->io_norm_cnt
> 0) {
331 vgadev
->io_norm_cnt
--;
332 if (vgadev
->decodes
& VGA_RSRC_LEGACY_IO
)
333 rsrc
|= VGA_RSRC_LEGACY_IO
;
335 if ((rsrc
& VGA_RSRC_NORMAL_MEM
) && vgadev
->mem_norm_cnt
> 0) {
336 vgadev
->mem_norm_cnt
--;
337 if (vgadev
->decodes
& VGA_RSRC_LEGACY_MEM
)
338 rsrc
|= VGA_RSRC_LEGACY_MEM
;
340 if ((rsrc
& VGA_RSRC_LEGACY_IO
) && vgadev
->io_lock_cnt
> 0)
341 vgadev
->io_lock_cnt
--;
342 if ((rsrc
& VGA_RSRC_LEGACY_MEM
) && vgadev
->mem_lock_cnt
> 0)
343 vgadev
->mem_lock_cnt
--;
345 /* Just clear lock bits, we do lazy operations so we don't really
346 * have to bother about anything else at this point
348 if (vgadev
->io_lock_cnt
== 0)
349 vgadev
->locks
&= ~VGA_RSRC_LEGACY_IO
;
350 if (vgadev
->mem_lock_cnt
== 0)
351 vgadev
->locks
&= ~VGA_RSRC_LEGACY_MEM
;
353 /* Kick the wait queue in case somebody was waiting if we actually
356 if (old_locks
!= vgadev
->locks
)
357 wake_up_all(&vga_wait_queue
);
360 int vga_get(struct pci_dev
*pdev
, unsigned int rsrc
, int interruptible
)
362 struct vga_device
*vgadev
, *conflict
;
367 vga_check_first_use();
368 /* The one who calls us should check for this, but lets be sure... */
370 pdev
= vga_default_device();
375 spin_lock_irqsave(&vga_lock
, flags
);
376 vgadev
= vgadev_find(pdev
);
377 if (vgadev
== NULL
) {
378 spin_unlock_irqrestore(&vga_lock
, flags
);
382 conflict
= __vga_tryget(vgadev
, rsrc
);
383 spin_unlock_irqrestore(&vga_lock
, flags
);
384 if (conflict
== NULL
)
388 /* We have a conflict, we wait until somebody kicks the
389 * work queue. Currently we have one work queue that we
390 * kick each time some resources are released, but it would
391 * be fairly easy to have a per device one so that we only
392 * need to attach to the conflicting device
394 init_waitqueue_entry(&wait
, current
);
395 add_wait_queue(&vga_wait_queue
, &wait
);
396 set_current_state(interruptible
?
398 TASK_UNINTERRUPTIBLE
);
399 if (signal_pending(current
)) {
404 remove_wait_queue(&vga_wait_queue
, &wait
);
408 EXPORT_SYMBOL(vga_get
);
410 int vga_tryget(struct pci_dev
*pdev
, unsigned int rsrc
)
412 struct vga_device
*vgadev
;
416 vga_check_first_use();
418 /* The one who calls us should check for this, but lets be sure... */
420 pdev
= vga_default_device();
423 spin_lock_irqsave(&vga_lock
, flags
);
424 vgadev
= vgadev_find(pdev
);
425 if (vgadev
== NULL
) {
429 if (__vga_tryget(vgadev
, rsrc
))
432 spin_unlock_irqrestore(&vga_lock
, flags
);
435 EXPORT_SYMBOL(vga_tryget
);
437 void vga_put(struct pci_dev
*pdev
, unsigned int rsrc
)
439 struct vga_device
*vgadev
;
442 /* The one who calls us should check for this, but lets be sure... */
444 pdev
= vga_default_device();
447 spin_lock_irqsave(&vga_lock
, flags
);
448 vgadev
= vgadev_find(pdev
);
451 __vga_put(vgadev
, rsrc
);
453 spin_unlock_irqrestore(&vga_lock
, flags
);
455 EXPORT_SYMBOL(vga_put
);
457 /* Rules for using a bridge to control a VGA descendant decoding:
458 if a bridge has only one VGA descendant then it can be used
459 to control the VGA routing for that device.
460 It should always use the bridge closest to the device to control it.
461 If a bridge has a direct VGA descendant, but also have a sub-bridge
462 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
463 So for every device we register, we need to iterate all its parent bridges
464 so we can invalidate any devices using them properly.
466 static void vga_arbiter_check_bridge_sharing(struct vga_device
*vgadev
)
468 struct vga_device
*same_bridge_vgadev
;
469 struct pci_bus
*new_bus
, *bus
;
470 struct pci_dev
*new_bridge
, *bridge
;
472 vgadev
->bridge_has_one_vga
= true;
474 if (list_empty(&vga_list
))
477 /* okay iterate the new devices bridge hierarachy */
478 new_bus
= vgadev
->pdev
->bus
;
480 new_bridge
= new_bus
->self
;
482 /* go through list of devices already registered */
483 list_for_each_entry(same_bridge_vgadev
, &vga_list
, list
) {
484 bus
= same_bridge_vgadev
->pdev
->bus
;
487 /* see if the share a bridge with this device */
488 if (new_bridge
== bridge
) {
489 /* if their direct parent bridge is the same
490 as any bridge of this device then it can't be used
492 same_bridge_vgadev
->bridge_has_one_vga
= false;
495 /* now iterate the previous devices bridge hierarchy */
496 /* if the new devices parent bridge is in the other devices
497 hierarchy then we can't use it to control this device */
501 if (bridge
== vgadev
->pdev
->bus
->self
)
502 vgadev
->bridge_has_one_vga
= false;
507 new_bus
= new_bus
->parent
;
512 * Currently, we assume that the "initial" setup of the system is
513 * not sane, that is we come up with conflicting devices and let
514 * the arbiter's client decides if devices decodes or not legacy
517 static bool vga_arbiter_add_pci_device(struct pci_dev
*pdev
)
519 struct vga_device
*vgadev
;
522 struct pci_dev
*bridge
;
525 /* Only deal with VGA class devices */
526 if ((pdev
->class >> 8) != PCI_CLASS_DISPLAY_VGA
)
529 /* Allocate structure */
530 vgadev
= kmalloc(sizeof(struct vga_device
), GFP_KERNEL
);
531 if (vgadev
== NULL
) {
532 pr_err("failed to allocate pci device\n");
533 /* What to do on allocation failure ? For now, let's
534 * just do nothing, I'm not sure there is anything saner
540 memset(vgadev
, 0, sizeof(*vgadev
));
542 /* Take lock & check for duplicates */
543 spin_lock_irqsave(&vga_lock
, flags
);
544 if (vgadev_find(pdev
) != NULL
) {
550 /* By default, assume we decode everything */
551 vgadev
->decodes
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
|
552 VGA_RSRC_NORMAL_IO
| VGA_RSRC_NORMAL_MEM
;
554 /* by default mark it as decoding */
556 /* Mark that we "own" resources based on our enables, we will
557 * clear that below if the bridge isn't forwarding
559 pci_read_config_word(pdev
, PCI_COMMAND
, &cmd
);
560 if (cmd
& PCI_COMMAND_IO
)
561 vgadev
->owns
|= VGA_RSRC_LEGACY_IO
;
562 if (cmd
& PCI_COMMAND_MEMORY
)
563 vgadev
->owns
|= VGA_RSRC_LEGACY_MEM
;
565 /* Check if VGA cycles can get down to us */
571 pci_read_config_word(bridge
, PCI_BRIDGE_CONTROL
,
573 if (!(l
& PCI_BRIDGE_CTL_VGA
)) {
581 /* Deal with VGA default device. Use first enabled one
582 * by default if arch doesn't have it's own hook
584 if (vga_default
== NULL
&&
585 ((vgadev
->owns
& VGA_RSRC_LEGACY_MASK
) == VGA_RSRC_LEGACY_MASK
)) {
586 pr_info("setting as boot device: PCI:%s\n", pci_name(pdev
));
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("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("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("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("%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("pdev %p\n", pdev
);
1085 pr_err("invalid PCI address %x:%x:%x\n",
1086 domain
, bus
, devfn
);
1092 vgadev
= vgadev_find(pdev
);
1093 pr_debug("vgadev %p\n", vgadev
);
1094 if (vgadev
== NULL
) {
1096 pr_err("this pci device is not a vga device\n");
1104 priv
->target
= pdev
;
1105 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1106 if (priv
->cards
[i
].pdev
== pdev
)
1108 if (priv
->cards
[i
].pdev
== NULL
) {
1109 priv
->cards
[i
].pdev
= pdev
;
1110 priv
->cards
[i
].io_cnt
= 0;
1111 priv
->cards
[i
].mem_cnt
= 0;
1115 if (i
== MAX_USER_CARDS
) {
1116 pr_err("maximum user cards (%d) number reached!\n",
1119 /* XXX: which value to return? */
1129 } else if (strncmp(curr_pos
, "decodes ", 8) == 0) {
1132 pr_debug("client 0x%p called 'decodes'\n", priv
);
1134 if (!vga_str_to_iostate(curr_pos
, remaining
, &io_state
)) {
1138 pdev
= priv
->target
;
1139 if (priv
->target
== NULL
) {
1144 __vga_set_legacy_decoding(pdev
, io_state
, true);
1148 /* If we got here, the message written is not part of the protocol! */
1157 static unsigned int vga_arb_fpoll(struct file
*file
, poll_table
* wait
)
1159 struct vga_arb_private
*priv
= file
->private_data
;
1161 pr_debug("%s\n", __func__
);
1165 poll_wait(file
, &vga_wait_queue
, wait
);
1169 static int vga_arb_open(struct inode
*inode
, struct file
*file
)
1171 struct vga_arb_private
*priv
;
1172 unsigned long flags
;
1174 pr_debug("%s\n", __func__
);
1176 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1179 spin_lock_init(&priv
->lock
);
1180 file
->private_data
= priv
;
1182 spin_lock_irqsave(&vga_user_lock
, flags
);
1183 list_add(&priv
->list
, &vga_user_list
);
1184 spin_unlock_irqrestore(&vga_user_lock
, flags
);
1186 /* Set the client' lists of locks */
1187 priv
->target
= vga_default_device(); /* Maybe this is still null! */
1188 priv
->cards
[0].pdev
= priv
->target
;
1189 priv
->cards
[0].io_cnt
= 0;
1190 priv
->cards
[0].mem_cnt
= 0;
1196 static int vga_arb_release(struct inode
*inode
, struct file
*file
)
1198 struct vga_arb_private
*priv
= file
->private_data
;
1199 struct vga_arb_user_card
*uc
;
1200 unsigned long flags
;
1203 pr_debug("%s\n", __func__
);
1208 spin_lock_irqsave(&vga_user_lock
, flags
);
1209 list_del(&priv
->list
);
1210 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1211 uc
= &priv
->cards
[i
];
1212 if (uc
->pdev
== NULL
)
1214 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1215 uc
->io_cnt
, uc
->mem_cnt
);
1216 while (uc
->io_cnt
--)
1217 vga_put(uc
->pdev
, VGA_RSRC_LEGACY_IO
);
1218 while (uc
->mem_cnt
--)
1219 vga_put(uc
->pdev
, VGA_RSRC_LEGACY_MEM
);
1221 spin_unlock_irqrestore(&vga_user_lock
, flags
);
1228 static void vga_arb_device_card_gone(struct pci_dev
*pdev
)
1233 * callback any registered clients to let them know we have a
1234 * change in VGA cards
1236 static void vga_arbiter_notify_clients(void)
1238 struct vga_device
*vgadev
;
1239 unsigned long flags
;
1240 uint32_t new_decodes
;
1243 if (!vga_arbiter_used
)
1246 spin_lock_irqsave(&vga_lock
, flags
);
1247 list_for_each_entry(vgadev
, &vga_list
, list
) {
1252 if (vgadev
->set_vga_decode
) {
1253 new_decodes
= vgadev
->set_vga_decode(vgadev
->cookie
, new_state
);
1254 vga_update_device_decodes(vgadev
, new_decodes
);
1257 spin_unlock_irqrestore(&vga_lock
, flags
);
1260 static int pci_notify(struct notifier_block
*nb
, unsigned long action
,
1263 struct device
*dev
= data
;
1264 struct pci_dev
*pdev
= to_pci_dev(dev
);
1265 bool notify
= false;
1267 pr_debug("%s\n", __func__
);
1269 /* For now we're only intereted in devices added and removed. I didn't
1270 * test this thing here, so someone needs to double check for the
1271 * cases of hotplugable vga cards. */
1272 if (action
== BUS_NOTIFY_ADD_DEVICE
)
1273 notify
= vga_arbiter_add_pci_device(pdev
);
1274 else if (action
== BUS_NOTIFY_DEL_DEVICE
)
1275 notify
= vga_arbiter_del_pci_device(pdev
);
1278 vga_arbiter_notify_clients();
1282 static struct notifier_block pci_notifier
= {
1283 .notifier_call
= pci_notify
,
1286 static const struct file_operations vga_arb_device_fops
= {
1287 .read
= vga_arb_read
,
1288 .write
= vga_arb_write
,
1289 .poll
= vga_arb_fpoll
,
1290 .open
= vga_arb_open
,
1291 .release
= vga_arb_release
,
1292 .llseek
= noop_llseek
,
1295 static struct miscdevice vga_arb_device
= {
1296 MISC_DYNAMIC_MINOR
, "vga_arbiter", &vga_arb_device_fops
1299 static int __init
vga_arb_device_init(void)
1302 struct pci_dev
*pdev
;
1303 struct vga_device
*vgadev
;
1305 rc
= misc_register(&vga_arb_device
);
1307 pr_err("error %d registering device\n", rc
);
1309 bus_register_notifier(&pci_bus_type
, &pci_notifier
);
1311 /* We add all pci devices satisfying vga class in the arbiter by
1315 pci_get_subsys(PCI_ANY_ID
, PCI_ANY_ID
, PCI_ANY_ID
,
1316 PCI_ANY_ID
, pdev
)) != NULL
)
1317 vga_arbiter_add_pci_device(pdev
);
1319 pr_info("loaded\n");
1321 list_for_each_entry(vgadev
, &vga_list
, list
) {
1322 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
1323 /* Override I/O based detection done by vga_arbiter_add_pci_device()
1324 * as it may take the wrong device (e.g. on Apple system under EFI).
1326 * Select the device owning the boot framebuffer if there is one.
1328 resource_size_t start
, end
;
1331 /* Does firmware framebuffer belong to us? */
1332 for (i
= 0; i
< DEVICE_COUNT_RESOURCE
; i
++) {
1333 if (!(pci_resource_flags(vgadev
->pdev
, i
) & IORESOURCE_MEM
))
1336 start
= pci_resource_start(vgadev
->pdev
, i
);
1337 end
= pci_resource_end(vgadev
->pdev
, i
);
1342 if (screen_info
.lfb_base
< start
||
1343 (screen_info
.lfb_base
+ screen_info
.lfb_size
) >= end
)
1345 if (!vga_default_device())
1346 pr_info("setting as boot device: PCI:%s\n",
1347 pci_name(vgadev
->pdev
));
1348 else if (vgadev
->pdev
!= vga_default_device())
1349 pr_info("overriding boot device: PCI:%s\n",
1350 pci_name(vgadev
->pdev
));
1351 vga_set_default_device(vgadev
->pdev
);
1354 if (vgadev
->bridge_has_one_vga
)
1355 pr_info("bridge control possible %s\n", pci_name(vgadev
->pdev
));
1357 pr_info("no bridge control possible %s\n", pci_name(vgadev
->pdev
));
1361 subsys_initcall(vga_arb_device_init
);