2 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/vgaarbiter.txt
6 * (C) Copyright 2005 Benjamin Herrenschmidt <benh@kernel.crashing.org>
7 * (C) Copyright 2007 Paulo R. Zanoni <przanoni@gmail.com>
8 * (C) Copyright 2007, 2009 Tiago Vignatti <vignatti@freedesktop.org>
10 * Permission is hereby granted, free of charge, to any person obtaining a
11 * copy of this software and associated documentation files (the "Software"),
12 * to deal in the Software without restriction, including without limitation
13 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14 * and/or sell copies of the Software, and to permit persons to whom the
15 * Software is furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice (including the next
18 * paragraph) shall be included in all copies or substantial portions of the
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
26 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/pci.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/list.h>
38 #include <linux/sched.h>
39 #include <linux/wait.h>
40 #include <linux/spinlock.h>
41 #include <linux/poll.h>
42 #include <linux/miscdevice.h>
43 #include <linux/slab.h>
45 #include <linux/uaccess.h>
47 #include <linux/vgaarb.h>
49 static void vga_arbiter_notify_clients(void);
51 * We keep a list of all vga devices in the system to speed
52 * up the various operations of the arbiter
55 struct list_head list
;
57 unsigned int decodes
; /* what does it decodes */
58 unsigned int owns
; /* what does it owns */
59 unsigned int locks
; /* what does it locks */
60 unsigned int io_lock_cnt
; /* legacy IO lock count */
61 unsigned int mem_lock_cnt
; /* legacy MEM lock count */
62 unsigned int io_norm_cnt
; /* normal IO count */
63 unsigned int mem_norm_cnt
; /* normal MEM count */
64 bool bridge_has_one_vga
;
65 /* allow IRQ enable/disable hook */
67 void (*irq_set_state
)(void *cookie
, bool enable
);
68 unsigned int (*set_vga_decode
)(void *cookie
, bool decode
);
71 static LIST_HEAD(vga_list
);
72 static int vga_count
, vga_decode_count
;
73 static bool vga_arbiter_used
;
74 static DEFINE_SPINLOCK(vga_lock
);
75 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue
);
78 static const char *vga_iostate_to_str(unsigned int iostate
)
80 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
81 iostate
&= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
;
83 case VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
:
85 case VGA_RSRC_LEGACY_IO
:
87 case VGA_RSRC_LEGACY_MEM
:
93 static int vga_str_to_iostate(char *buf
, int str_size
, int *io_state
)
95 /* we could in theory hand out locks on IO and mem
96 * separately to userspace but it can cause deadlocks */
97 if (strncmp(buf
, "none", 4) == 0) {
98 *io_state
= VGA_RSRC_NONE
;
102 /* XXX We're not chekcing the str_size! */
103 if (strncmp(buf
, "io+mem", 6) == 0)
105 else if (strncmp(buf
, "io", 2) == 0)
107 else if (strncmp(buf
, "mem", 3) == 0)
111 *io_state
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
;
115 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
116 /* this is only used a cookie - it should not be dereferenced */
117 static struct pci_dev
*vga_default
;
120 static void vga_arb_device_card_gone(struct pci_dev
*pdev
);
122 /* Find somebody in our list */
123 static struct vga_device
*vgadev_find(struct pci_dev
*pdev
)
125 struct vga_device
*vgadev
;
127 list_for_each_entry(vgadev
, &vga_list
, list
)
128 if (pdev
== vgadev
->pdev
)
133 /* Returns the default VGA device (vgacon's babe) */
134 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
135 struct pci_dev
*vga_default_device(void)
140 EXPORT_SYMBOL_GPL(vga_default_device
);
142 void vga_set_default_device(struct pci_dev
*pdev
)
144 if (vga_default
== pdev
)
147 pci_dev_put(vga_default
);
148 vga_default
= pci_dev_get(pdev
);
152 static inline void vga_irq_set_state(struct vga_device
*vgadev
, bool state
)
154 if (vgadev
->irq_set_state
)
155 vgadev
->irq_set_state(vgadev
->cookie
, state
);
159 /* If we don't ever use VGA arb we should avoid
160 turning off anything anywhere due to old X servers getting
161 confused about the boot device not being VGA */
162 static void vga_check_first_use(void)
164 /* we should inform all GPUs in the system that
165 * VGA arb has occurred and to try and disable resources
167 if (!vga_arbiter_used
) {
168 vga_arbiter_used
= true;
169 vga_arbiter_notify_clients();
173 static struct vga_device
*__vga_tryget(struct vga_device
*vgadev
,
176 unsigned int wants
, legacy_wants
, match
;
177 struct vga_device
*conflict
;
178 unsigned int pci_bits
;
181 /* Account for "normal" resources to lock. If we decode the legacy,
182 * counterpart, we need to request it as well
184 if ((rsrc
& VGA_RSRC_NORMAL_IO
) &&
185 (vgadev
->decodes
& VGA_RSRC_LEGACY_IO
))
186 rsrc
|= VGA_RSRC_LEGACY_IO
;
187 if ((rsrc
& VGA_RSRC_NORMAL_MEM
) &&
188 (vgadev
->decodes
& VGA_RSRC_LEGACY_MEM
))
189 rsrc
|= VGA_RSRC_LEGACY_MEM
;
191 pr_debug("%s: %d\n", __func__
, rsrc
);
192 pr_debug("%s: owns: %d\n", __func__
, vgadev
->owns
);
194 /* Check what resources we need to acquire */
195 wants
= rsrc
& ~vgadev
->owns
;
197 /* We already own everything, just mark locked & bye bye */
201 /* We don't need to request a legacy resource, we just enable
202 * appropriate decoding and go
204 legacy_wants
= wants
& VGA_RSRC_LEGACY_MASK
;
205 if (legacy_wants
== 0)
208 /* Ok, we don't, let's find out how we need to kick off */
209 list_for_each_entry(conflict
, &vga_list
, list
) {
210 unsigned int lwants
= legacy_wants
;
211 unsigned int change_bridge
= 0;
213 /* Don't conflict with myself */
214 if (vgadev
== conflict
)
217 /* Check if the architecture allows a conflict between those
218 * 2 devices or if they are on separate domains
220 if (!vga_conflicts(vgadev
->pdev
, conflict
->pdev
))
223 /* We have a possible conflict. before we go further, we must
224 * check if we sit on the same bus as the conflicting device.
225 * if we don't, then we must tie both IO and MEM resources
226 * together since there is only a single bit controlling
227 * VGA forwarding on P2P bridges
229 if (vgadev
->pdev
->bus
!= conflict
->pdev
->bus
) {
231 lwants
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
;
234 /* Check if the guy has a lock on the resource. If he does,
235 * return the conflicting entry
237 if (conflict
->locks
& lwants
)
240 /* Ok, now check if he owns the resource we want. We don't need
241 * to check "decodes" since it should be impossible to own
242 * own legacy resources you don't decode unless I have a bug
245 WARN_ON(conflict
->owns
& ~conflict
->decodes
);
246 match
= lwants
& conflict
->owns
;
250 /* looks like he doesn't have a lock, we can steal
257 if (!conflict
->bridge_has_one_vga
) {
258 vga_irq_set_state(conflict
, false);
259 flags
|= PCI_VGA_STATE_CHANGE_DECODES
;
260 if (lwants
& (VGA_RSRC_LEGACY_MEM
|VGA_RSRC_NORMAL_MEM
))
261 pci_bits
|= PCI_COMMAND_MEMORY
;
262 if (lwants
& (VGA_RSRC_LEGACY_IO
|VGA_RSRC_NORMAL_IO
))
263 pci_bits
|= PCI_COMMAND_IO
;
267 flags
|= PCI_VGA_STATE_CHANGE_BRIDGE
;
269 pci_set_vga_state(conflict
->pdev
, false, pci_bits
, flags
);
270 conflict
->owns
&= ~lwants
;
271 /* If he also owned non-legacy, that is no longer the case */
272 if (lwants
& VGA_RSRC_LEGACY_MEM
)
273 conflict
->owns
&= ~VGA_RSRC_NORMAL_MEM
;
274 if (lwants
& VGA_RSRC_LEGACY_IO
)
275 conflict
->owns
&= ~VGA_RSRC_NORMAL_IO
;
279 /* ok dude, we got it, everybody conflicting has been disabled, let's
280 * enable us. Make sure we don't mark a bit in "owns" that we don't
281 * also have in "decodes". We can lock resources we don't decode but
287 if (!vgadev
->bridge_has_one_vga
) {
288 flags
|= PCI_VGA_STATE_CHANGE_DECODES
;
289 if (wants
& (VGA_RSRC_LEGACY_MEM
|VGA_RSRC_NORMAL_MEM
))
290 pci_bits
|= PCI_COMMAND_MEMORY
;
291 if (wants
& (VGA_RSRC_LEGACY_IO
|VGA_RSRC_NORMAL_IO
))
292 pci_bits
|= PCI_COMMAND_IO
;
294 if (!!(wants
& VGA_RSRC_LEGACY_MASK
))
295 flags
|= PCI_VGA_STATE_CHANGE_BRIDGE
;
297 pci_set_vga_state(vgadev
->pdev
, true, pci_bits
, flags
);
299 if (!vgadev
->bridge_has_one_vga
) {
300 vga_irq_set_state(vgadev
, true);
302 vgadev
->owns
|= (wants
& vgadev
->decodes
);
304 vgadev
->locks
|= (rsrc
& VGA_RSRC_LEGACY_MASK
);
305 if (rsrc
& VGA_RSRC_LEGACY_IO
)
306 vgadev
->io_lock_cnt
++;
307 if (rsrc
& VGA_RSRC_LEGACY_MEM
)
308 vgadev
->mem_lock_cnt
++;
309 if (rsrc
& VGA_RSRC_NORMAL_IO
)
310 vgadev
->io_norm_cnt
++;
311 if (rsrc
& VGA_RSRC_NORMAL_MEM
)
312 vgadev
->mem_norm_cnt
++;
317 static void __vga_put(struct vga_device
*vgadev
, unsigned int rsrc
)
319 unsigned int old_locks
= vgadev
->locks
;
321 pr_debug("%s\n", __func__
);
323 /* Update our counters, and account for equivalent legacy resources
326 if ((rsrc
& VGA_RSRC_NORMAL_IO
) && vgadev
->io_norm_cnt
> 0) {
327 vgadev
->io_norm_cnt
--;
328 if (vgadev
->decodes
& VGA_RSRC_LEGACY_IO
)
329 rsrc
|= VGA_RSRC_LEGACY_IO
;
331 if ((rsrc
& VGA_RSRC_NORMAL_MEM
) && vgadev
->mem_norm_cnt
> 0) {
332 vgadev
->mem_norm_cnt
--;
333 if (vgadev
->decodes
& VGA_RSRC_LEGACY_MEM
)
334 rsrc
|= VGA_RSRC_LEGACY_MEM
;
336 if ((rsrc
& VGA_RSRC_LEGACY_IO
) && vgadev
->io_lock_cnt
> 0)
337 vgadev
->io_lock_cnt
--;
338 if ((rsrc
& VGA_RSRC_LEGACY_MEM
) && vgadev
->mem_lock_cnt
> 0)
339 vgadev
->mem_lock_cnt
--;
341 /* Just clear lock bits, we do lazy operations so we don't really
342 * have to bother about anything else at this point
344 if (vgadev
->io_lock_cnt
== 0)
345 vgadev
->locks
&= ~VGA_RSRC_LEGACY_IO
;
346 if (vgadev
->mem_lock_cnt
== 0)
347 vgadev
->locks
&= ~VGA_RSRC_LEGACY_MEM
;
349 /* Kick the wait queue in case somebody was waiting if we actually
352 if (old_locks
!= vgadev
->locks
)
353 wake_up_all(&vga_wait_queue
);
356 int vga_get(struct pci_dev
*pdev
, unsigned int rsrc
, int interruptible
)
358 struct vga_device
*vgadev
, *conflict
;
363 vga_check_first_use();
364 /* The one who calls us should check for this, but lets be sure... */
366 pdev
= vga_default_device();
371 spin_lock_irqsave(&vga_lock
, flags
);
372 vgadev
= vgadev_find(pdev
);
373 if (vgadev
== NULL
) {
374 spin_unlock_irqrestore(&vga_lock
, flags
);
378 conflict
= __vga_tryget(vgadev
, rsrc
);
379 spin_unlock_irqrestore(&vga_lock
, flags
);
380 if (conflict
== NULL
)
384 /* We have a conflict, we wait until somebody kicks the
385 * work queue. Currently we have one work queue that we
386 * kick each time some resources are released, but it would
387 * be fairly easy to have a per device one so that we only
388 * need to attach to the conflicting device
390 init_waitqueue_entry(&wait
, current
);
391 add_wait_queue(&vga_wait_queue
, &wait
);
392 set_current_state(interruptible
?
394 TASK_UNINTERRUPTIBLE
);
395 if (interruptible
&& signal_pending(current
)) {
396 __set_current_state(TASK_RUNNING
);
397 remove_wait_queue(&vga_wait_queue
, &wait
);
402 remove_wait_queue(&vga_wait_queue
, &wait
);
403 set_current_state(TASK_RUNNING
);
407 EXPORT_SYMBOL(vga_get
);
409 int vga_tryget(struct pci_dev
*pdev
, unsigned int rsrc
)
411 struct vga_device
*vgadev
;
415 vga_check_first_use();
417 /* The one who calls us should check for this, but lets be sure... */
419 pdev
= vga_default_device();
422 spin_lock_irqsave(&vga_lock
, flags
);
423 vgadev
= vgadev_find(pdev
);
424 if (vgadev
== NULL
) {
428 if (__vga_tryget(vgadev
, rsrc
))
431 spin_unlock_irqrestore(&vga_lock
, flags
);
434 EXPORT_SYMBOL(vga_tryget
);
436 void vga_put(struct pci_dev
*pdev
, unsigned int rsrc
)
438 struct vga_device
*vgadev
;
441 /* The one who calls us should check for this, but lets be sure... */
443 pdev
= vga_default_device();
446 spin_lock_irqsave(&vga_lock
, flags
);
447 vgadev
= vgadev_find(pdev
);
450 __vga_put(vgadev
, rsrc
);
452 spin_unlock_irqrestore(&vga_lock
, flags
);
454 EXPORT_SYMBOL(vga_put
);
456 /* Rules for using a bridge to control a VGA descendant decoding:
457 if a bridge has only one VGA descendant then it can be used
458 to control the VGA routing for that device.
459 It should always use the bridge closest to the device to control it.
460 If a bridge has a direct VGA descendant, but also have a sub-bridge
461 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
462 So for every device we register, we need to iterate all its parent bridges
463 so we can invalidate any devices using them properly.
465 static void vga_arbiter_check_bridge_sharing(struct vga_device
*vgadev
)
467 struct vga_device
*same_bridge_vgadev
;
468 struct pci_bus
*new_bus
, *bus
;
469 struct pci_dev
*new_bridge
, *bridge
;
471 vgadev
->bridge_has_one_vga
= true;
473 if (list_empty(&vga_list
))
476 /* okay iterate the new devices bridge hierarachy */
477 new_bus
= vgadev
->pdev
->bus
;
479 new_bridge
= new_bus
->self
;
481 /* go through list of devices already registered */
482 list_for_each_entry(same_bridge_vgadev
, &vga_list
, list
) {
483 bus
= same_bridge_vgadev
->pdev
->bus
;
486 /* see if the share a bridge with this device */
487 if (new_bridge
== bridge
) {
488 /* if their direct parent bridge is the same
489 as any bridge of this device then it can't be used
491 same_bridge_vgadev
->bridge_has_one_vga
= false;
494 /* now iterate the previous devices bridge hierarchy */
495 /* if the new devices parent bridge is in the other devices
496 hierarchy then we can't use it to control this device */
500 if (bridge
== vgadev
->pdev
->bus
->self
)
501 vgadev
->bridge_has_one_vga
= false;
506 new_bus
= new_bus
->parent
;
511 * Currently, we assume that the "initial" setup of the system is
512 * not sane, that is we come up with conflicting devices and let
513 * the arbiter's client decides if devices decodes or not legacy
516 static bool vga_arbiter_add_pci_device(struct pci_dev
*pdev
)
518 struct vga_device
*vgadev
;
521 struct pci_dev
*bridge
;
524 /* Only deal with VGA class devices */
525 if ((pdev
->class >> 8) != PCI_CLASS_DISPLAY_VGA
)
528 /* Allocate structure */
529 vgadev
= kmalloc(sizeof(struct vga_device
), GFP_KERNEL
);
530 if (vgadev
== NULL
) {
531 pr_err("vgaarb: failed to allocate pci device\n");
532 /* What to do on allocation failure ? For now, let's
533 * just do nothing, I'm not sure there is anything saner
539 memset(vgadev
, 0, sizeof(*vgadev
));
541 /* Take lock & check for duplicates */
542 spin_lock_irqsave(&vga_lock
, flags
);
543 if (vgadev_find(pdev
) != NULL
) {
549 /* By default, assume we decode everything */
550 vgadev
->decodes
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
|
551 VGA_RSRC_NORMAL_IO
| VGA_RSRC_NORMAL_MEM
;
553 /* by default mark it as decoding */
555 /* Mark that we "own" resources based on our enables, we will
556 * clear that below if the bridge isn't forwarding
558 pci_read_config_word(pdev
, PCI_COMMAND
, &cmd
);
559 if (cmd
& PCI_COMMAND_IO
)
560 vgadev
->owns
|= VGA_RSRC_LEGACY_IO
;
561 if (cmd
& PCI_COMMAND_MEMORY
)
562 vgadev
->owns
|= VGA_RSRC_LEGACY_MEM
;
564 /* Check if VGA cycles can get down to us */
570 pci_read_config_word(bridge
, PCI_BRIDGE_CONTROL
,
572 if (!(l
& PCI_BRIDGE_CTL_VGA
)) {
580 /* Deal with VGA default device. Use first enabled one
581 * by default if arch doesn't have it's own hook
583 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
584 if (vga_default
== NULL
&&
585 ((vgadev
->owns
& VGA_RSRC_LEGACY_MASK
) == VGA_RSRC_LEGACY_MASK
))
586 vga_set_default_device(pdev
);
589 vga_arbiter_check_bridge_sharing(vgadev
);
591 /* Add to the list */
592 list_add(&vgadev
->list
, &vga_list
);
594 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
596 vga_iostate_to_str(vgadev
->decodes
),
597 vga_iostate_to_str(vgadev
->owns
),
598 vga_iostate_to_str(vgadev
->locks
));
600 spin_unlock_irqrestore(&vga_lock
, flags
);
603 spin_unlock_irqrestore(&vga_lock
, flags
);
608 static bool vga_arbiter_del_pci_device(struct pci_dev
*pdev
)
610 struct vga_device
*vgadev
;
614 spin_lock_irqsave(&vga_lock
, flags
);
615 vgadev
= vgadev_find(pdev
);
616 if (vgadev
== NULL
) {
621 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
622 if (vga_default
== pdev
)
623 vga_set_default_device(NULL
);
626 if (vgadev
->decodes
& (VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
))
629 /* Remove entry from list */
630 list_del(&vgadev
->list
);
632 /* Notify userland driver that the device is gone so it discards
633 * it's copies of the pci_dev pointer
635 vga_arb_device_card_gone(pdev
);
637 /* Wake up all possible waiters */
638 wake_up_all(&vga_wait_queue
);
640 spin_unlock_irqrestore(&vga_lock
, flags
);
645 /* this is called with the lock */
646 static inline void vga_update_device_decodes(struct vga_device
*vgadev
,
650 struct vga_device
*new_vgadev
, *conflict
;
652 old_decodes
= vgadev
->decodes
;
653 vgadev
->decodes
= new_decodes
;
655 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
656 pci_name(vgadev
->pdev
),
657 vga_iostate_to_str(old_decodes
),
658 vga_iostate_to_str(vgadev
->decodes
),
659 vga_iostate_to_str(vgadev
->owns
));
662 /* if we own the decodes we should move them along to
664 if ((vgadev
->owns
& old_decodes
) && (vga_count
> 1)) {
665 /* set us to own nothing */
666 vgadev
->owns
&= ~old_decodes
;
667 list_for_each_entry(new_vgadev
, &vga_list
, list
) {
668 if ((new_vgadev
!= vgadev
) &&
669 (new_vgadev
->decodes
& VGA_RSRC_LEGACY_MASK
)) {
670 pr_info("vgaarb: transferring owner from PCI:%s to PCI:%s\n", pci_name(vgadev
->pdev
), pci_name(new_vgadev
->pdev
));
671 conflict
= __vga_tryget(new_vgadev
, VGA_RSRC_LEGACY_MASK
);
673 __vga_put(new_vgadev
, VGA_RSRC_LEGACY_MASK
);
679 /* change decodes counter */
680 if (old_decodes
!= new_decodes
) {
681 if (new_decodes
& (VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
))
686 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count
);
689 static void __vga_set_legacy_decoding(struct pci_dev
*pdev
, unsigned int decodes
, bool userspace
)
691 struct vga_device
*vgadev
;
694 decodes
&= VGA_RSRC_LEGACY_MASK
;
696 spin_lock_irqsave(&vga_lock
, flags
);
697 vgadev
= vgadev_find(pdev
);
701 /* don't let userspace futz with kernel driver decodes */
702 if (userspace
&& vgadev
->set_vga_decode
)
705 /* update the device decodes + counter */
706 vga_update_device_decodes(vgadev
, decodes
);
708 /* XXX if somebody is going from "doesn't decode" to "decodes" state
709 * here, additional care must be taken as we may have pending owner
710 * ship of non-legacy region ...
713 spin_unlock_irqrestore(&vga_lock
, flags
);
716 void vga_set_legacy_decoding(struct pci_dev
*pdev
, unsigned int decodes
)
718 __vga_set_legacy_decoding(pdev
, decodes
, false);
720 EXPORT_SYMBOL(vga_set_legacy_decoding
);
722 /* call with NULL to unregister */
723 int vga_client_register(struct pci_dev
*pdev
, void *cookie
,
724 void (*irq_set_state
)(void *cookie
, bool state
),
725 unsigned int (*set_vga_decode
)(void *cookie
, bool decode
))
728 struct vga_device
*vgadev
;
731 spin_lock_irqsave(&vga_lock
, flags
);
732 vgadev
= vgadev_find(pdev
);
736 vgadev
->irq_set_state
= irq_set_state
;
737 vgadev
->set_vga_decode
= set_vga_decode
;
738 vgadev
->cookie
= cookie
;
742 spin_unlock_irqrestore(&vga_lock
, flags
);
746 EXPORT_SYMBOL(vga_client_register
);
749 * Char driver implementation
753 * open : open user instance of the arbitrer. by default, it's
754 * attached to the default VGA device of the system.
756 * close : close user instance, release locks
758 * read : return a string indicating the status of the target.
759 * an IO state string is of the form {io,mem,io+mem,none},
760 * mc and ic are respectively mem and io lock counts (for
761 * debugging/diagnostic only). "decodes" indicate what the
762 * card currently decodes, "owns" indicates what is currently
763 * enabled on it, and "locks" indicates what is locked by this
764 * card. If the card is unplugged, we get "invalid" then for
765 * card_ID and an -ENODEV error is returned for any command
766 * until a new card is targeted
768 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
770 * write : write a command to the arbiter. List of commands is:
772 * target <card_ID> : switch target to card <card_ID> (see below)
773 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
774 * trylock <io_state> : non-blocking acquire locks on target
775 * unlock <io_state> : release locks on target
776 * unlock all : release all locks on target held by this user
777 * decodes <io_state> : set the legacy decoding attributes for the card
779 * poll : event if something change on any card (not just the target)
781 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
782 * to go back to the system default card (TODO: not implemented yet).
783 * Currently, only PCI is supported as a prefix, but the userland API may
784 * support other bus types in the future, even if the current kernel
785 * implementation doesn't.
789 * The driver keeps track of which user has what locks on which card. It
790 * supports stacking, like the kernel one. This complexifies the implementation
791 * a bit, but makes the arbiter more tolerant to userspace problems and able
792 * to properly cleanup in all cases when a process dies.
793 * Currently, a max of 16 cards simultaneously can have locks issued from
794 * userspace for a given user (file descriptor instance) of the arbiter.
796 * If the device is hot-unplugged, there is a hook inside the module to notify
797 * they being added/removed in the system and automatically added/removed in
801 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
802 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
805 * Each user has an array of these, tracking which cards have locks
807 struct vga_arb_user_card
{
808 struct pci_dev
*pdev
;
809 unsigned int mem_cnt
;
813 struct vga_arb_private
{
814 struct list_head list
;
815 struct pci_dev
*target
;
816 struct vga_arb_user_card cards
[MAX_USER_CARDS
];
820 static LIST_HEAD(vga_user_list
);
821 static DEFINE_SPINLOCK(vga_user_lock
);
825 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
826 * returns the respective values. If the string is not in this format,
829 static int vga_pci_str_to_vars(char *buf
, int count
, unsigned int *domain
,
830 unsigned int *bus
, unsigned int *devfn
)
833 unsigned int slot
, func
;
836 n
= sscanf(buf
, "PCI:%x:%x:%x.%x", domain
, bus
, &slot
, &func
);
840 *devfn
= PCI_DEVFN(slot
, func
);
845 static ssize_t
vga_arb_read(struct file
*file
, char __user
* buf
,
846 size_t count
, loff_t
*ppos
)
848 struct vga_arb_private
*priv
= file
->private_data
;
849 struct vga_device
*vgadev
;
850 struct pci_dev
*pdev
;
856 lbuf
= kmalloc(1024, GFP_KERNEL
);
860 /* Shields against vga_arb_device_card_gone (pci_dev going
861 * away), and allows access to vga list
863 spin_lock_irqsave(&vga_lock
, flags
);
865 /* If we are targeting the default, use it */
867 if (pdev
== NULL
|| pdev
== PCI_INVALID_CARD
) {
868 spin_unlock_irqrestore(&vga_lock
, flags
);
869 len
= sprintf(lbuf
, "invalid");
873 /* Find card vgadev structure */
874 vgadev
= vgadev_find(pdev
);
875 if (vgadev
== NULL
) {
876 /* Wow, it's not in the list, that shouldn't happen,
877 * let's fix us up and return invalid card
879 if (pdev
== priv
->target
)
880 vga_arb_device_card_gone(pdev
);
881 spin_unlock_irqrestore(&vga_lock
, flags
);
882 len
= sprintf(lbuf
, "invalid");
886 /* Fill the buffer with infos */
887 len
= snprintf(lbuf
, 1024,
888 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
889 vga_decode_count
, pci_name(pdev
),
890 vga_iostate_to_str(vgadev
->decodes
),
891 vga_iostate_to_str(vgadev
->owns
),
892 vga_iostate_to_str(vgadev
->locks
),
893 vgadev
->io_lock_cnt
, vgadev
->mem_lock_cnt
);
895 spin_unlock_irqrestore(&vga_lock
, flags
);
898 /* Copy that to user */
901 rc
= copy_to_user(buf
, lbuf
, len
);
909 * TODO: To avoid parsing inside kernel and to improve the speed we may
910 * consider use ioctl here
912 static ssize_t
vga_arb_write(struct file
*file
, const char __user
* buf
,
913 size_t count
, loff_t
*ppos
)
915 struct vga_arb_private
*priv
= file
->private_data
;
916 struct vga_arb_user_card
*uc
= NULL
;
917 struct pci_dev
*pdev
;
919 unsigned int io_state
;
921 char *kbuf
, *curr_pos
;
922 size_t remaining
= count
;
928 kbuf
= kmalloc(count
+ 1, GFP_KERNEL
);
932 if (copy_from_user(kbuf
, buf
, count
)) {
937 kbuf
[count
] = '\0'; /* Just to make sure... */
939 if (strncmp(curr_pos
, "lock ", 5) == 0) {
943 pr_debug("client 0x%p called 'lock'\n", priv
);
945 if (!vga_str_to_iostate(curr_pos
, remaining
, &io_state
)) {
949 if (io_state
== VGA_RSRC_NONE
) {
955 if (priv
->target
== NULL
) {
960 vga_get_uninterruptible(pdev
, io_state
);
962 /* Update the client's locks lists... */
963 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
964 if (priv
->cards
[i
].pdev
== pdev
) {
965 if (io_state
& VGA_RSRC_LEGACY_IO
)
966 priv
->cards
[i
].io_cnt
++;
967 if (io_state
& VGA_RSRC_LEGACY_MEM
)
968 priv
->cards
[i
].mem_cnt
++;
975 } else if (strncmp(curr_pos
, "unlock ", 7) == 0) {
979 pr_debug("client 0x%p called 'unlock'\n", priv
);
981 if (strncmp(curr_pos
, "all", 3) == 0)
982 io_state
= VGA_RSRC_LEGACY_IO
| VGA_RSRC_LEGACY_MEM
;
984 if (!vga_str_to_iostate
985 (curr_pos
, remaining
, &io_state
)) {
990 if (io_state == VGA_RSRC_NONE) {
998 if (priv
->target
== NULL
) {
1002 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1003 if (priv
->cards
[i
].pdev
== pdev
)
1004 uc
= &priv
->cards
[i
];
1012 if (io_state
& VGA_RSRC_LEGACY_IO
&& uc
->io_cnt
== 0) {
1017 if (io_state
& VGA_RSRC_LEGACY_MEM
&& uc
->mem_cnt
== 0) {
1022 vga_put(pdev
, io_state
);
1024 if (io_state
& VGA_RSRC_LEGACY_IO
)
1026 if (io_state
& VGA_RSRC_LEGACY_MEM
)
1031 } else if (strncmp(curr_pos
, "trylock ", 8) == 0) {
1035 pr_debug("client 0x%p called 'trylock'\n", priv
);
1037 if (!vga_str_to_iostate(curr_pos
, remaining
, &io_state
)) {
1042 if (io_state == VGA_RSRC_NONE) {
1048 pdev
= priv
->target
;
1049 if (priv
->target
== NULL
) {
1054 if (vga_tryget(pdev
, io_state
)) {
1055 /* Update the client's locks lists... */
1056 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1057 if (priv
->cards
[i
].pdev
== pdev
) {
1058 if (io_state
& VGA_RSRC_LEGACY_IO
)
1059 priv
->cards
[i
].io_cnt
++;
1060 if (io_state
& VGA_RSRC_LEGACY_MEM
)
1061 priv
->cards
[i
].mem_cnt
++;
1072 } else if (strncmp(curr_pos
, "target ", 7) == 0) {
1073 unsigned int domain
, bus
, devfn
;
1074 struct vga_device
*vgadev
;
1078 pr_debug("client 0x%p called 'target'\n", priv
);
1079 /* if target is default */
1080 if (!strncmp(curr_pos
, "default", 7))
1081 pdev
= pci_dev_get(vga_default_device());
1083 if (!vga_pci_str_to_vars(curr_pos
, remaining
,
1084 &domain
, &bus
, &devfn
)) {
1088 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos
,
1089 domain
, bus
, PCI_SLOT(devfn
), PCI_FUNC(devfn
));
1091 pdev
= pci_get_domain_bus_and_slot(domain
, bus
, devfn
);
1092 pr_debug("vgaarb: pdev %p\n", pdev
);
1094 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1095 domain
, bus
, devfn
);
1101 vgadev
= vgadev_find(pdev
);
1102 pr_debug("vgaarb: vgadev %p\n", vgadev
);
1103 if (vgadev
== NULL
) {
1104 pr_err("vgaarb: this pci device is not a vga device\n");
1110 priv
->target
= pdev
;
1111 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1112 if (priv
->cards
[i
].pdev
== pdev
)
1114 if (priv
->cards
[i
].pdev
== NULL
) {
1115 priv
->cards
[i
].pdev
= pdev
;
1116 priv
->cards
[i
].io_cnt
= 0;
1117 priv
->cards
[i
].mem_cnt
= 0;
1121 if (i
== MAX_USER_CARDS
) {
1122 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1125 /* XXX: which value to return? */
1135 } else if (strncmp(curr_pos
, "decodes ", 8) == 0) {
1138 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv
);
1140 if (!vga_str_to_iostate(curr_pos
, remaining
, &io_state
)) {
1144 pdev
= priv
->target
;
1145 if (priv
->target
== NULL
) {
1150 __vga_set_legacy_decoding(pdev
, io_state
, true);
1154 /* If we got here, the message written is not part of the protocol! */
1163 static unsigned int vga_arb_fpoll(struct file
*file
, poll_table
* wait
)
1165 struct vga_arb_private
*priv
= file
->private_data
;
1167 pr_debug("%s\n", __func__
);
1171 poll_wait(file
, &vga_wait_queue
, wait
);
1175 static int vga_arb_open(struct inode
*inode
, struct file
*file
)
1177 struct vga_arb_private
*priv
;
1178 unsigned long flags
;
1180 pr_debug("%s\n", __func__
);
1182 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
1185 spin_lock_init(&priv
->lock
);
1186 file
->private_data
= priv
;
1188 spin_lock_irqsave(&vga_user_lock
, flags
);
1189 list_add(&priv
->list
, &vga_user_list
);
1190 spin_unlock_irqrestore(&vga_user_lock
, flags
);
1192 /* Set the client' lists of locks */
1193 priv
->target
= vga_default_device(); /* Maybe this is still null! */
1194 priv
->cards
[0].pdev
= priv
->target
;
1195 priv
->cards
[0].io_cnt
= 0;
1196 priv
->cards
[0].mem_cnt
= 0;
1202 static int vga_arb_release(struct inode
*inode
, struct file
*file
)
1204 struct vga_arb_private
*priv
= file
->private_data
;
1205 struct vga_arb_user_card
*uc
;
1206 unsigned long flags
;
1209 pr_debug("%s\n", __func__
);
1214 spin_lock_irqsave(&vga_user_lock
, flags
);
1215 list_del(&priv
->list
);
1216 for (i
= 0; i
< MAX_USER_CARDS
; i
++) {
1217 uc
= &priv
->cards
[i
];
1218 if (uc
->pdev
== NULL
)
1220 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1221 uc
->io_cnt
, uc
->mem_cnt
);
1222 while (uc
->io_cnt
--)
1223 vga_put(uc
->pdev
, VGA_RSRC_LEGACY_IO
);
1224 while (uc
->mem_cnt
--)
1225 vga_put(uc
->pdev
, VGA_RSRC_LEGACY_MEM
);
1227 spin_unlock_irqrestore(&vga_user_lock
, flags
);
1234 static void vga_arb_device_card_gone(struct pci_dev
*pdev
)
1239 * callback any registered clients to let them know we have a
1240 * change in VGA cards
1242 static void vga_arbiter_notify_clients(void)
1244 struct vga_device
*vgadev
;
1245 unsigned long flags
;
1246 uint32_t new_decodes
;
1249 if (!vga_arbiter_used
)
1252 spin_lock_irqsave(&vga_lock
, flags
);
1253 list_for_each_entry(vgadev
, &vga_list
, list
) {
1258 if (vgadev
->set_vga_decode
) {
1259 new_decodes
= vgadev
->set_vga_decode(vgadev
->cookie
, new_state
);
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("vgaarb: 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("vgaarb: loaded\n");
1327 list_for_each_entry(vgadev
, &vga_list
, list
) {
1328 if (vgadev
->bridge_has_one_vga
)
1329 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev
->pdev
));
1331 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev
->pdev
));
1335 subsys_initcall(vga_arb_device_init
);