1 /*
2 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/vgaarbiter.txt
4 *
5 *
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>
9 *
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:
16 *
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
19 * Software.
20 *
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
27 * DEALINGS
28 * IN THE SOFTWARE.
29 *
30 */
31
32 #include <linux/module.h>
33 #include <linux/kernel.h>
34 #include <linux/pci.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/list.h>
38 #include <linux/sched.h>
39 #include <linux/wait.h>
40 #include <linux/spinlock.h>
41 #include <linux/poll.h>
42 #include <linux/miscdevice.h>
43 #include <linux/slab.h>
44
45 #include <linux/uaccess.h>
46
47 #include <linux/vgaarb.h>
48
49 static void vga_arbiter_notify_clients(void);
50 /*
51 * We keep a list of all vga devices in the system to speed
52 * up the various operations of the arbiter
53 */
54 struct vga_device {
55 struct list_head list;
56 struct pci_dev *pdev;
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 */
66 void *cookie;
67 void (*irq_set_state)(void *cookie, bool enable);
68 unsigned int (*set_vga_decode)(void *cookie, bool decode);
69 };
70
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);
76
77
vga_iostate_to_str(unsigned int iostate)78 static const char *vga_iostate_to_str(unsigned int iostate)
79 {
80 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
81 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
82 switch (iostate) {
83 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
84 return "io+mem";
85 case VGA_RSRC_LEGACY_IO:
86 return "io";
87 case VGA_RSRC_LEGACY_MEM:
88 return "mem";
89 }
90 return "none";
91 }
92
vga_str_to_iostate(char * buf,int str_size,int * io_state)93 static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
94 {
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;
99 return 1;
100 }
101
102 /* XXX We're not chekcing the str_size! */
103 if (strncmp(buf, "io+mem", 6) == 0)
104 goto both;
105 else if (strncmp(buf, "io", 2) == 0)
106 goto both;
107 else if (strncmp(buf, "mem", 3) == 0)
108 goto both;
109 return 0;
110 both:
111 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
112 return 1;
113 }
114
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;
118 #endif
119
120 static void vga_arb_device_card_gone(struct pci_dev *pdev);
121
122 /* Find somebody in our list */
vgadev_find(struct pci_dev * pdev)123 static struct vga_device *vgadev_find(struct pci_dev *pdev)
124 {
125 struct vga_device *vgadev;
126
127 list_for_each_entry(vgadev, &vga_list, list)
128 if (pdev == vgadev->pdev)
129 return vgadev;
130 return NULL;
131 }
132
133 /* Returns the default VGA device (vgacon's babe) */
134 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
vga_default_device(void)135 struct pci_dev *vga_default_device(void)
136 {
137 return vga_default;
138 }
139 #endif
140
vga_irq_set_state(struct vga_device * vgadev,bool state)141 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
142 {
143 if (vgadev->irq_set_state)
144 vgadev->irq_set_state(vgadev->cookie, state);
145 }
146
147
148 /* If we don't ever use VGA arb we should avoid
149 turning off anything anywhere due to old X servers getting
150 confused about the boot device not being VGA */
vga_check_first_use(void)151 static void vga_check_first_use(void)
152 {
153 /* we should inform all GPUs in the system that
154 * VGA arb has occurred and to try and disable resources
155 * if they can */
156 if (!vga_arbiter_used) {
157 vga_arbiter_used = true;
158 vga_arbiter_notify_clients();
159 }
160 }
161
__vga_tryget(struct vga_device * vgadev,unsigned int rsrc)162 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
163 unsigned int rsrc)
164 {
165 unsigned int wants, legacy_wants, match;
166 struct vga_device *conflict;
167 unsigned int pci_bits;
168 u32 flags = 0;
169
170 /* Account for "normal" resources to lock. If we decode the legacy,
171 * counterpart, we need to request it as well
172 */
173 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
174 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
175 rsrc |= VGA_RSRC_LEGACY_IO;
176 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
177 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
178 rsrc |= VGA_RSRC_LEGACY_MEM;
179
180 pr_debug("%s: %d\n", __func__, rsrc);
181 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
182
183 /* Check what resources we need to acquire */
184 wants = rsrc & ~vgadev->owns;
185
186 /* We already own everything, just mark locked & bye bye */
187 if (wants == 0)
188 goto lock_them;
189
190 /* We don't need to request a legacy resource, we just enable
191 * appropriate decoding and go
192 */
193 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
194 if (legacy_wants == 0)
195 goto enable_them;
196
197 /* Ok, we don't, let's find out how we need to kick off */
198 list_for_each_entry(conflict, &vga_list, list) {
199 unsigned int lwants = legacy_wants;
200 unsigned int change_bridge = 0;
201
202 /* Don't conflict with myself */
203 if (vgadev == conflict)
204 continue;
205
206 /* Check if the architecture allows a conflict between those
207 * 2 devices or if they are on separate domains
208 */
209 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
210 continue;
211
212 /* We have a possible conflict. before we go further, we must
213 * check if we sit on the same bus as the conflicting device.
214 * if we don't, then we must tie both IO and MEM resources
215 * together since there is only a single bit controlling
216 * VGA forwarding on P2P bridges
217 */
218 if (vgadev->pdev->bus != conflict->pdev->bus) {
219 change_bridge = 1;
220 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
221 }
222
223 /* Check if the guy has a lock on the resource. If he does,
224 * return the conflicting entry
225 */
226 if (conflict->locks & lwants)
227 return conflict;
228
229 /* Ok, now check if he owns the resource we want. We don't need
230 * to check "decodes" since it should be impossible to own
231 * own legacy resources you don't decode unless I have a bug
232 * in this code...
233 */
234 WARN_ON(conflict->owns & ~conflict->decodes);
235 match = lwants & conflict->owns;
236 if (!match)
237 continue;
238
239 /* looks like he doesn't have a lock, we can steal
240 * them from him
241 */
242
243 flags = 0;
244 pci_bits = 0;
245
246 if (!conflict->bridge_has_one_vga) {
247 vga_irq_set_state(conflict, false);
248 flags |= PCI_VGA_STATE_CHANGE_DECODES;
249 if (lwants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
250 pci_bits |= PCI_COMMAND_MEMORY;
251 if (lwants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
252 pci_bits |= PCI_COMMAND_IO;
253 }
254
255 if (change_bridge)
256 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
257
258 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
259 conflict->owns &= ~lwants;
260 /* If he also owned non-legacy, that is no longer the case */
261 if (lwants & VGA_RSRC_LEGACY_MEM)
262 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
263 if (lwants & VGA_RSRC_LEGACY_IO)
264 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
265 }
266
267 enable_them:
268 /* ok dude, we got it, everybody conflicting has been disabled, let's
269 * enable us. Make sure we don't mark a bit in "owns" that we don't
270 * also have in "decodes". We can lock resources we don't decode but
271 * not own them.
272 */
273 flags = 0;
274 pci_bits = 0;
275
276 if (!vgadev->bridge_has_one_vga) {
277 flags |= PCI_VGA_STATE_CHANGE_DECODES;
278 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
279 pci_bits |= PCI_COMMAND_MEMORY;
280 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
281 pci_bits |= PCI_COMMAND_IO;
282 }
283 if (!!(wants & VGA_RSRC_LEGACY_MASK))
284 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
285
286 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
287
288 if (!vgadev->bridge_has_one_vga) {
289 vga_irq_set_state(vgadev, true);
290 }
291 vgadev->owns |= (wants & vgadev->decodes);
292 lock_them:
293 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
294 if (rsrc & VGA_RSRC_LEGACY_IO)
295 vgadev->io_lock_cnt++;
296 if (rsrc & VGA_RSRC_LEGACY_MEM)
297 vgadev->mem_lock_cnt++;
298 if (rsrc & VGA_RSRC_NORMAL_IO)
299 vgadev->io_norm_cnt++;
300 if (rsrc & VGA_RSRC_NORMAL_MEM)
301 vgadev->mem_norm_cnt++;
302
303 return NULL;
304 }
305
__vga_put(struct vga_device * vgadev,unsigned int rsrc)306 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
307 {
308 unsigned int old_locks = vgadev->locks;
309
310 pr_debug("%s\n", __func__);
311
312 /* Update our counters, and account for equivalent legacy resources
313 * if we decode them
314 */
315 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
316 vgadev->io_norm_cnt--;
317 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
318 rsrc |= VGA_RSRC_LEGACY_IO;
319 }
320 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
321 vgadev->mem_norm_cnt--;
322 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
323 rsrc |= VGA_RSRC_LEGACY_MEM;
324 }
325 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
326 vgadev->io_lock_cnt--;
327 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
328 vgadev->mem_lock_cnt--;
329
330 /* Just clear lock bits, we do lazy operations so we don't really
331 * have to bother about anything else at this point
332 */
333 if (vgadev->io_lock_cnt == 0)
334 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
335 if (vgadev->mem_lock_cnt == 0)
336 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
337
338 /* Kick the wait queue in case somebody was waiting if we actually
339 * released something
340 */
341 if (old_locks != vgadev->locks)
342 wake_up_all(&vga_wait_queue);
343 }
344
vga_get(struct pci_dev * pdev,unsigned int rsrc,int interruptible)345 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
346 {
347 struct vga_device *vgadev, *conflict;
348 unsigned long flags;
349 wait_queue_t wait;
350 int rc = 0;
351
352 vga_check_first_use();
353 /* The one who calls us should check for this, but lets be sure... */
354 if (pdev == NULL)
355 pdev = vga_default_device();
356 if (pdev == NULL)
357 return 0;
358
359 for (;;) {
360 spin_lock_irqsave(&vga_lock, flags);
361 vgadev = vgadev_find(pdev);
362 if (vgadev == NULL) {
363 spin_unlock_irqrestore(&vga_lock, flags);
364 rc = -ENODEV;
365 break;
366 }
367 conflict = __vga_tryget(vgadev, rsrc);
368 spin_unlock_irqrestore(&vga_lock, flags);
369 if (conflict == NULL)
370 break;
371
372
373 /* We have a conflict, we wait until somebody kicks the
374 * work queue. Currently we have one work queue that we
375 * kick each time some resources are released, but it would
376 * be fairly easy to have a per device one so that we only
377 * need to attach to the conflicting device
378 */
379 init_waitqueue_entry(&wait, current);
380 add_wait_queue(&vga_wait_queue, &wait);
381 set_current_state(interruptible ?
382 TASK_INTERRUPTIBLE :
383 TASK_UNINTERRUPTIBLE);
384 if (signal_pending(current)) {
385 rc = -EINTR;
386 break;
387 }
388 schedule();
389 remove_wait_queue(&vga_wait_queue, &wait);
390 set_current_state(TASK_RUNNING);
391 }
392 return rc;
393 }
394 EXPORT_SYMBOL(vga_get);
395
vga_tryget(struct pci_dev * pdev,unsigned int rsrc)396 int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
397 {
398 struct vga_device *vgadev;
399 unsigned long flags;
400 int rc = 0;
401
402 vga_check_first_use();
403
404 /* The one who calls us should check for this, but lets be sure... */
405 if (pdev == NULL)
406 pdev = vga_default_device();
407 if (pdev == NULL)
408 return 0;
409 spin_lock_irqsave(&vga_lock, flags);
410 vgadev = vgadev_find(pdev);
411 if (vgadev == NULL) {
412 rc = -ENODEV;
413 goto bail;
414 }
415 if (__vga_tryget(vgadev, rsrc))
416 rc = -EBUSY;
417 bail:
418 spin_unlock_irqrestore(&vga_lock, flags);
419 return rc;
420 }
421 EXPORT_SYMBOL(vga_tryget);
422
vga_put(struct pci_dev * pdev,unsigned int rsrc)423 void vga_put(struct pci_dev *pdev, unsigned int rsrc)
424 {
425 struct vga_device *vgadev;
426 unsigned long flags;
427
428 /* The one who calls us should check for this, but lets be sure... */
429 if (pdev == NULL)
430 pdev = vga_default_device();
431 if (pdev == NULL)
432 return;
433 spin_lock_irqsave(&vga_lock, flags);
434 vgadev = vgadev_find(pdev);
435 if (vgadev == NULL)
436 goto bail;
437 __vga_put(vgadev, rsrc);
438 bail:
439 spin_unlock_irqrestore(&vga_lock, flags);
440 }
441 EXPORT_SYMBOL(vga_put);
442
443 /* Rules for using a bridge to control a VGA descendant decoding:
444 if a bridge has only one VGA descendant then it can be used
445 to control the VGA routing for that device.
446 It should always use the bridge closest to the device to control it.
447 If a bridge has a direct VGA descendant, but also have a sub-bridge
448 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
449 So for every device we register, we need to iterate all its parent bridges
450 so we can invalidate any devices using them properly.
451 */
vga_arbiter_check_bridge_sharing(struct vga_device * vgadev)452 static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
453 {
454 struct vga_device *same_bridge_vgadev;
455 struct pci_bus *new_bus, *bus;
456 struct pci_dev *new_bridge, *bridge;
457
458 vgadev->bridge_has_one_vga = true;
459
460 if (list_empty(&vga_list))
461 return;
462
463 /* okay iterate the new devices bridge hierarachy */
464 new_bus = vgadev->pdev->bus;
465 while (new_bus) {
466 new_bridge = new_bus->self;
467
468 /* go through list of devices already registered */
469 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
470 bus = same_bridge_vgadev->pdev->bus;
471 bridge = bus->self;
472
473 /* see if the share a bridge with this device */
474 if (new_bridge == bridge) {
475 /* if their direct parent bridge is the same
476 as any bridge of this device then it can't be used
477 for that device */
478 same_bridge_vgadev->bridge_has_one_vga = false;
479 }
480
481 /* now iterate the previous devices bridge hierarchy */
482 /* if the new devices parent bridge is in the other devices
483 hierarchy then we can't use it to control this device */
484 while (bus) {
485 bridge = bus->self;
486 if (bridge) {
487 if (bridge == vgadev->pdev->bus->self)
488 vgadev->bridge_has_one_vga = false;
489 }
490 bus = bus->parent;
491 }
492 }
493 new_bus = new_bus->parent;
494 }
495 }
496
497 /*
498 * Currently, we assume that the "initial" setup of the system is
499 * not sane, that is we come up with conflicting devices and let
500 * the arbiter's client decides if devices decodes or not legacy
501 * things.
502 */
vga_arbiter_add_pci_device(struct pci_dev * pdev)503 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
504 {
505 struct vga_device *vgadev;
506 unsigned long flags;
507 struct pci_bus *bus;
508 struct pci_dev *bridge;
509 u16 cmd;
510
511 /* Only deal with VGA class devices */
512 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
513 return false;
514
515 /* Allocate structure */
516 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
517 if (vgadev == NULL) {
518 pr_err("vgaarb: failed to allocate pci device\n");
519 /* What to do on allocation failure ? For now, let's
520 * just do nothing, I'm not sure there is anything saner
521 * to be done
522 */
523 return false;
524 }
525
526 memset(vgadev, 0, sizeof(*vgadev));
527
528 /* Take lock & check for duplicates */
529 spin_lock_irqsave(&vga_lock, flags);
530 if (vgadev_find(pdev) != NULL) {
531 BUG_ON(1);
532 goto fail;
533 }
534 vgadev->pdev = pdev;
535
536 /* By default, assume we decode everything */
537 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
538 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
539
540 /* by default mark it as decoding */
541 vga_decode_count++;
542 /* Mark that we "own" resources based on our enables, we will
543 * clear that below if the bridge isn't forwarding
544 */
545 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
546 if (cmd & PCI_COMMAND_IO)
547 vgadev->owns |= VGA_RSRC_LEGACY_IO;
548 if (cmd & PCI_COMMAND_MEMORY)
549 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
550
551 /* Check if VGA cycles can get down to us */
552 bus = pdev->bus;
553 while (bus) {
554 bridge = bus->self;
555 if (bridge) {
556 u16 l;
557 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
558 &l);
559 if (!(l & PCI_BRIDGE_CTL_VGA)) {
560 vgadev->owns = 0;
561 break;
562 }
563 }
564 bus = bus->parent;
565 }
566
567 /* Deal with VGA default device. Use first enabled one
568 * by default if arch doesn't have it's own hook
569 */
570 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
571 if (vga_default == NULL &&
572 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
573 vga_default = pci_dev_get(pdev);
574 #endif
575
576 vga_arbiter_check_bridge_sharing(vgadev);
577
578 /* Add to the list */
579 list_add(&vgadev->list, &vga_list);
580 vga_count++;
581 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
582 pci_name(pdev),
583 vga_iostate_to_str(vgadev->decodes),
584 vga_iostate_to_str(vgadev->owns),
585 vga_iostate_to_str(vgadev->locks));
586
587 spin_unlock_irqrestore(&vga_lock, flags);
588 return true;
589 fail:
590 spin_unlock_irqrestore(&vga_lock, flags);
591 kfree(vgadev);
592 return false;
593 }
594
vga_arbiter_del_pci_device(struct pci_dev * pdev)595 static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
596 {
597 struct vga_device *vgadev;
598 unsigned long flags;
599 bool ret = true;
600
601 spin_lock_irqsave(&vga_lock, flags);
602 vgadev = vgadev_find(pdev);
603 if (vgadev == NULL) {
604 ret = false;
605 goto bail;
606 }
607
608 if (vga_default == pdev) {
609 pci_dev_put(vga_default);
610 vga_default = NULL;
611 }
612
613 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
614 vga_decode_count--;
615
616 /* Remove entry from list */
617 list_del(&vgadev->list);
618 vga_count--;
619 /* Notify userland driver that the device is gone so it discards
620 * it's copies of the pci_dev pointer
621 */
622 vga_arb_device_card_gone(pdev);
623
624 /* Wake up all possible waiters */
625 wake_up_all(&vga_wait_queue);
626 bail:
627 spin_unlock_irqrestore(&vga_lock, flags);
628 kfree(vgadev);
629 return ret;
630 }
631
632 /* this is called with the lock */
vga_update_device_decodes(struct vga_device * vgadev,int new_decodes)633 static inline void vga_update_device_decodes(struct vga_device *vgadev,
634 int new_decodes)
635 {
636 int old_decodes;
637 struct vga_device *new_vgadev, *conflict;
638
639 old_decodes = vgadev->decodes;
640 vgadev->decodes = new_decodes;
641
642 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
643 pci_name(vgadev->pdev),
644 vga_iostate_to_str(old_decodes),
645 vga_iostate_to_str(vgadev->decodes),
646 vga_iostate_to_str(vgadev->owns));
647
648
649 /* if we own the decodes we should move them along to
650 another card */
651 if ((vgadev->owns & old_decodes) && (vga_count > 1)) {
652 /* set us to own nothing */
653 vgadev->owns &= ~old_decodes;
654 list_for_each_entry(new_vgadev, &vga_list, list) {
655 if ((new_vgadev != vgadev) &&
656 (new_vgadev->decodes & VGA_RSRC_LEGACY_MASK)) {
657 pr_info("vgaarb: transferring owner from PCI:%s to PCI:%s\n", pci_name(vgadev->pdev), pci_name(new_vgadev->pdev));
658 conflict = __vga_tryget(new_vgadev, VGA_RSRC_LEGACY_MASK);
659 if (!conflict)
660 __vga_put(new_vgadev, VGA_RSRC_LEGACY_MASK);
661 break;
662 }
663 }
664 }
665
666 /* change decodes counter */
667 if (old_decodes != new_decodes) {
668 if (new_decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
669 vga_decode_count++;
670 else
671 vga_decode_count--;
672 }
673 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
674 }
675
__vga_set_legacy_decoding(struct pci_dev * pdev,unsigned int decodes,bool userspace)676 static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
677 {
678 struct vga_device *vgadev;
679 unsigned long flags;
680
681 decodes &= VGA_RSRC_LEGACY_MASK;
682
683 spin_lock_irqsave(&vga_lock, flags);
684 vgadev = vgadev_find(pdev);
685 if (vgadev == NULL)
686 goto bail;
687
688 /* don't let userspace futz with kernel driver decodes */
689 if (userspace && vgadev->set_vga_decode)
690 goto bail;
691
692 /* update the device decodes + counter */
693 vga_update_device_decodes(vgadev, decodes);
694
695 /* XXX if somebody is going from "doesn't decode" to "decodes" state
696 * here, additional care must be taken as we may have pending owner
697 * ship of non-legacy region ...
698 */
699 bail:
700 spin_unlock_irqrestore(&vga_lock, flags);
701 }
702
vga_set_legacy_decoding(struct pci_dev * pdev,unsigned int decodes)703 void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
704 {
705 __vga_set_legacy_decoding(pdev, decodes, false);
706 }
707 EXPORT_SYMBOL(vga_set_legacy_decoding);
708
709 /* call with NULL to unregister */
vga_client_register(struct pci_dev * pdev,void * cookie,void (* irq_set_state)(void * cookie,bool state),unsigned int (* set_vga_decode)(void * cookie,bool decode))710 int vga_client_register(struct pci_dev *pdev, void *cookie,
711 void (*irq_set_state)(void *cookie, bool state),
712 unsigned int (*set_vga_decode)(void *cookie, bool decode))
713 {
714 int ret = -ENODEV;
715 struct vga_device *vgadev;
716 unsigned long flags;
717
718 spin_lock_irqsave(&vga_lock, flags);
719 vgadev = vgadev_find(pdev);
720 if (!vgadev)
721 goto bail;
722
723 vgadev->irq_set_state = irq_set_state;
724 vgadev->set_vga_decode = set_vga_decode;
725 vgadev->cookie = cookie;
726 ret = 0;
727
728 bail:
729 spin_unlock_irqrestore(&vga_lock, flags);
730 return ret;
731
732 }
733 EXPORT_SYMBOL(vga_client_register);
734
735 /*
736 * Char driver implementation
737 *
738 * Semantics is:
739 *
740 * open : open user instance of the arbitrer. by default, it's
741 * attached to the default VGA device of the system.
742 *
743 * close : close user instance, release locks
744 *
745 * read : return a string indicating the status of the target.
746 * an IO state string is of the form {io,mem,io+mem,none},
747 * mc and ic are respectively mem and io lock counts (for
748 * debugging/diagnostic only). "decodes" indicate what the
749 * card currently decodes, "owns" indicates what is currently
750 * enabled on it, and "locks" indicates what is locked by this
751 * card. If the card is unplugged, we get "invalid" then for
752 * card_ID and an -ENODEV error is returned for any command
753 * until a new card is targeted
754 *
755 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
756 *
757 * write : write a command to the arbiter. List of commands is:
758 *
759 * target <card_ID> : switch target to card <card_ID> (see below)
760 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
761 * trylock <io_state> : non-blocking acquire locks on target
762 * unlock <io_state> : release locks on target
763 * unlock all : release all locks on target held by this user
764 * decodes <io_state> : set the legacy decoding attributes for the card
765 *
766 * poll : event if something change on any card (not just the target)
767 *
768 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
769 * to go back to the system default card (TODO: not implemented yet).
770 * Currently, only PCI is supported as a prefix, but the userland API may
771 * support other bus types in the future, even if the current kernel
772 * implementation doesn't.
773 *
774 * Note about locks:
775 *
776 * The driver keeps track of which user has what locks on which card. It
777 * supports stacking, like the kernel one. This complexifies the implementation
778 * a bit, but makes the arbiter more tolerant to userspace problems and able
779 * to properly cleanup in all cases when a process dies.
780 * Currently, a max of 16 cards simultaneously can have locks issued from
781 * userspace for a given user (file descriptor instance) of the arbiter.
782 *
783 * If the device is hot-unplugged, there is a hook inside the module to notify
784 * they being added/removed in the system and automatically added/removed in
785 * the arbiter.
786 */
787
788 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
789 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
790
791 /*
792 * Each user has an array of these, tracking which cards have locks
793 */
794 struct vga_arb_user_card {
795 struct pci_dev *pdev;
796 unsigned int mem_cnt;
797 unsigned int io_cnt;
798 };
799
800 struct vga_arb_private {
801 struct list_head list;
802 struct pci_dev *target;
803 struct vga_arb_user_card cards[MAX_USER_CARDS];
804 spinlock_t lock;
805 };
806
807 static LIST_HEAD(vga_user_list);
808 static DEFINE_SPINLOCK(vga_user_lock);
809
810
811 /*
812 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
813 * returns the respective values. If the string is not in this format,
814 * it returns 0.
815 */
vga_pci_str_to_vars(char * buf,int count,unsigned int * domain,unsigned int * bus,unsigned int * devfn)816 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
817 unsigned int *bus, unsigned int *devfn)
818 {
819 int n;
820 unsigned int slot, func;
821
822
823 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
824 if (n != 4)
825 return 0;
826
827 *devfn = PCI_DEVFN(slot, func);
828
829 return 1;
830 }
831
vga_arb_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)832 static ssize_t vga_arb_read(struct file *file, char __user * buf,
833 size_t count, loff_t *ppos)
834 {
835 struct vga_arb_private *priv = file->private_data;
836 struct vga_device *vgadev;
837 struct pci_dev *pdev;
838 unsigned long flags;
839 size_t len;
840 int rc;
841 char *lbuf;
842
843 lbuf = kmalloc(1024, GFP_KERNEL);
844 if (lbuf == NULL)
845 return -ENOMEM;
846
847 /* Shields against vga_arb_device_card_gone (pci_dev going
848 * away), and allows access to vga list
849 */
850 spin_lock_irqsave(&vga_lock, flags);
851
852 /* If we are targeting the default, use it */
853 pdev = priv->target;
854 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
855 spin_unlock_irqrestore(&vga_lock, flags);
856 len = sprintf(lbuf, "invalid");
857 goto done;
858 }
859
860 /* Find card vgadev structure */
861 vgadev = vgadev_find(pdev);
862 if (vgadev == NULL) {
863 /* Wow, it's not in the list, that shouldn't happen,
864 * let's fix us up and return invalid card
865 */
866 if (pdev == priv->target)
867 vga_arb_device_card_gone(pdev);
868 spin_unlock_irqrestore(&vga_lock, flags);
869 len = sprintf(lbuf, "invalid");
870 goto done;
871 }
872
873 /* Fill the buffer with infos */
874 len = snprintf(lbuf, 1024,
875 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
876 vga_decode_count, pci_name(pdev),
877 vga_iostate_to_str(vgadev->decodes),
878 vga_iostate_to_str(vgadev->owns),
879 vga_iostate_to_str(vgadev->locks),
880 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
881
882 spin_unlock_irqrestore(&vga_lock, flags);
883 done:
884
885 /* Copy that to user */
886 if (len > count)
887 len = count;
888 rc = copy_to_user(buf, lbuf, len);
889 kfree(lbuf);
890 if (rc)
891 return -EFAULT;
892 return len;
893 }
894
895 /*
896 * TODO: To avoid parsing inside kernel and to improve the speed we may
897 * consider use ioctl here
898 */
vga_arb_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)899 static ssize_t vga_arb_write(struct file *file, const char __user * buf,
900 size_t count, loff_t *ppos)
901 {
902 struct vga_arb_private *priv = file->private_data;
903 struct vga_arb_user_card *uc = NULL;
904 struct pci_dev *pdev;
905
906 unsigned int io_state;
907
908 char *kbuf, *curr_pos;
909 size_t remaining = count;
910
911 int ret_val;
912 int i;
913
914
915 kbuf = kmalloc(count + 1, GFP_KERNEL);
916 if (!kbuf)
917 return -ENOMEM;
918
919 if (copy_from_user(kbuf, buf, count)) {
920 kfree(kbuf);
921 return -EFAULT;
922 }
923 curr_pos = kbuf;
924 kbuf[count] = '\0'; /* Just to make sure... */
925
926 if (strncmp(curr_pos, "lock ", 5) == 0) {
927 curr_pos += 5;
928 remaining -= 5;
929
930 pr_debug("client 0x%p called 'lock'\n", priv);
931
932 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
933 ret_val = -EPROTO;
934 goto done;
935 }
936 if (io_state == VGA_RSRC_NONE) {
937 ret_val = -EPROTO;
938 goto done;
939 }
940
941 pdev = priv->target;
942 if (priv->target == NULL) {
943 ret_val = -ENODEV;
944 goto done;
945 }
946
947 vga_get_uninterruptible(pdev, io_state);
948
949 /* Update the client's locks lists... */
950 for (i = 0; i < MAX_USER_CARDS; i++) {
951 if (priv->cards[i].pdev == pdev) {
952 if (io_state & VGA_RSRC_LEGACY_IO)
953 priv->cards[i].io_cnt++;
954 if (io_state & VGA_RSRC_LEGACY_MEM)
955 priv->cards[i].mem_cnt++;
956 break;
957 }
958 }
959
960 ret_val = count;
961 goto done;
962 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
963 curr_pos += 7;
964 remaining -= 7;
965
966 pr_debug("client 0x%p called 'unlock'\n", priv);
967
968 if (strncmp(curr_pos, "all", 3) == 0)
969 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
970 else {
971 if (!vga_str_to_iostate
972 (curr_pos, remaining, &io_state)) {
973 ret_val = -EPROTO;
974 goto done;
975 }
976 /* TODO: Add this?
977 if (io_state == VGA_RSRC_NONE) {
978 ret_val = -EPROTO;
979 goto done;
980 }
981 */
982 }
983
984 pdev = priv->target;
985 if (priv->target == NULL) {
986 ret_val = -ENODEV;
987 goto done;
988 }
989 for (i = 0; i < MAX_USER_CARDS; i++) {
990 if (priv->cards[i].pdev == pdev)
991 uc = &priv->cards[i];
992 }
993
994 if (!uc) {
995 ret_val = -EINVAL;
996 goto done;
997 }
998
999 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1000 ret_val = -EINVAL;
1001 goto done;
1002 }
1003
1004 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1005 ret_val = -EINVAL;
1006 goto done;
1007 }
1008
1009 vga_put(pdev, io_state);
1010
1011 if (io_state & VGA_RSRC_LEGACY_IO)
1012 uc->io_cnt--;
1013 if (io_state & VGA_RSRC_LEGACY_MEM)
1014 uc->mem_cnt--;
1015
1016 ret_val = count;
1017 goto done;
1018 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1019 curr_pos += 8;
1020 remaining -= 8;
1021
1022 pr_debug("client 0x%p called 'trylock'\n", priv);
1023
1024 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1025 ret_val = -EPROTO;
1026 goto done;
1027 }
1028 /* TODO: Add this?
1029 if (io_state == VGA_RSRC_NONE) {
1030 ret_val = -EPROTO;
1031 goto done;
1032 }
1033 */
1034
1035 pdev = priv->target;
1036 if (priv->target == NULL) {
1037 ret_val = -ENODEV;
1038 goto done;
1039 }
1040
1041 if (vga_tryget(pdev, io_state)) {
1042 /* Update the client's locks lists... */
1043 for (i = 0; i < MAX_USER_CARDS; i++) {
1044 if (priv->cards[i].pdev == pdev) {
1045 if (io_state & VGA_RSRC_LEGACY_IO)
1046 priv->cards[i].io_cnt++;
1047 if (io_state & VGA_RSRC_LEGACY_MEM)
1048 priv->cards[i].mem_cnt++;
1049 break;
1050 }
1051 }
1052 ret_val = count;
1053 goto done;
1054 } else {
1055 ret_val = -EBUSY;
1056 goto done;
1057 }
1058
1059 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1060 struct pci_bus *pbus;
1061 unsigned int domain, bus, devfn;
1062 struct vga_device *vgadev;
1063
1064 curr_pos += 7;
1065 remaining -= 7;
1066 pr_debug("client 0x%p called 'target'\n", priv);
1067 /* if target is default */
1068 if (!strncmp(curr_pos, "default", 7))
1069 pdev = pci_dev_get(vga_default_device());
1070 else {
1071 if (!vga_pci_str_to_vars(curr_pos, remaining,
1072 &domain, &bus, &devfn)) {
1073 ret_val = -EPROTO;
1074 goto done;
1075 }
1076 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
1077 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1078
1079 pbus = pci_find_bus(domain, bus);
1080 pr_debug("vgaarb: pbus %p\n", pbus);
1081 if (pbus == NULL) {
1082 pr_err("vgaarb: invalid PCI domain and/or bus address %x:%x\n",
1083 domain, bus);
1084 ret_val = -ENODEV;
1085 goto done;
1086 }
1087 pdev = pci_get_slot(pbus, devfn);
1088 pr_debug("vgaarb: pdev %p\n", pdev);
1089 if (!pdev) {
1090 pr_err("vgaarb: invalid PCI address %x:%x\n",
1091 bus, devfn);
1092 ret_val = -ENODEV;
1093 goto done;
1094 }
1095 }
1096
1097 vgadev = vgadev_find(pdev);
1098 pr_debug("vgaarb: vgadev %p\n", vgadev);
1099 if (vgadev == NULL) {
1100 pr_err("vgaarb: this pci device is not a vga device\n");
1101 pci_dev_put(pdev);
1102 ret_val = -ENODEV;
1103 goto done;
1104 }
1105
1106 priv->target = pdev;
1107 for (i = 0; i < MAX_USER_CARDS; i++) {
1108 if (priv->cards[i].pdev == pdev)
1109 break;
1110 if (priv->cards[i].pdev == NULL) {
1111 priv->cards[i].pdev = pdev;
1112 priv->cards[i].io_cnt = 0;
1113 priv->cards[i].mem_cnt = 0;
1114 break;
1115 }
1116 }
1117 if (i == MAX_USER_CARDS) {
1118 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1119 MAX_USER_CARDS);
1120 pci_dev_put(pdev);
1121 /* XXX: which value to return? */
1122 ret_val = -ENOMEM;
1123 goto done;
1124 }
1125
1126 ret_val = count;
1127 pci_dev_put(pdev);
1128 goto done;
1129
1130
1131 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1132 curr_pos += 8;
1133 remaining -= 8;
1134 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1135
1136 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1137 ret_val = -EPROTO;
1138 goto done;
1139 }
1140 pdev = priv->target;
1141 if (priv->target == NULL) {
1142 ret_val = -ENODEV;
1143 goto done;
1144 }
1145
1146 __vga_set_legacy_decoding(pdev, io_state, true);
1147 ret_val = count;
1148 goto done;
1149 }
1150 /* If we got here, the message written is not part of the protocol! */
1151 kfree(kbuf);
1152 return -EPROTO;
1153
1154 done:
1155 kfree(kbuf);
1156 return ret_val;
1157 }
1158
vga_arb_fpoll(struct file * file,poll_table * wait)1159 static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1160 {
1161 struct vga_arb_private *priv = file->private_data;
1162
1163 pr_debug("%s\n", __func__);
1164
1165 if (priv == NULL)
1166 return -ENODEV;
1167 poll_wait(file, &vga_wait_queue, wait);
1168 return POLLIN;
1169 }
1170
vga_arb_open(struct inode * inode,struct file * file)1171 static int vga_arb_open(struct inode *inode, struct file *file)
1172 {
1173 struct vga_arb_private *priv;
1174 unsigned long flags;
1175
1176 pr_debug("%s\n", __func__);
1177
1178 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1179 if (priv == NULL)
1180 return -ENOMEM;
1181 spin_lock_init(&priv->lock);
1182 file->private_data = priv;
1183
1184 spin_lock_irqsave(&vga_user_lock, flags);
1185 list_add(&priv->list, &vga_user_list);
1186 spin_unlock_irqrestore(&vga_user_lock, flags);
1187
1188 /* Set the client' lists of locks */
1189 priv->target = vga_default_device(); /* Maybe this is still null! */
1190 priv->cards[0].pdev = priv->target;
1191 priv->cards[0].io_cnt = 0;
1192 priv->cards[0].mem_cnt = 0;
1193
1194
1195 return 0;
1196 }
1197
vga_arb_release(struct inode * inode,struct file * file)1198 static int vga_arb_release(struct inode *inode, struct file *file)
1199 {
1200 struct vga_arb_private *priv = file->private_data;
1201 struct vga_arb_user_card *uc;
1202 unsigned long flags;
1203 int i;
1204
1205 pr_debug("%s\n", __func__);
1206
1207 if (priv == NULL)
1208 return -ENODEV;
1209
1210 spin_lock_irqsave(&vga_user_lock, flags);
1211 list_del(&priv->list);
1212 for (i = 0; i < MAX_USER_CARDS; i++) {
1213 uc = &priv->cards[i];
1214 if (uc->pdev == NULL)
1215 continue;
1216 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1217 uc->io_cnt, uc->mem_cnt);
1218 while (uc->io_cnt--)
1219 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1220 while (uc->mem_cnt--)
1221 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1222 }
1223 spin_unlock_irqrestore(&vga_user_lock, flags);
1224
1225 kfree(priv);
1226
1227 return 0;
1228 }
1229
vga_arb_device_card_gone(struct pci_dev * pdev)1230 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1231 {
1232 }
1233
1234 /*
1235 * callback any registered clients to let them know we have a
1236 * change in VGA cards
1237 */
vga_arbiter_notify_clients(void)1238 static void vga_arbiter_notify_clients(void)
1239 {
1240 struct vga_device *vgadev;
1241 unsigned long flags;
1242 uint32_t new_decodes;
1243 bool new_state;
1244
1245 if (!vga_arbiter_used)
1246 return;
1247
1248 spin_lock_irqsave(&vga_lock, flags);
1249 list_for_each_entry(vgadev, &vga_list, list) {
1250 if (vga_count > 1)
1251 new_state = false;
1252 else
1253 new_state = true;
1254 if (vgadev->set_vga_decode) {
1255 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1256 vga_update_device_decodes(vgadev, new_decodes);
1257 }
1258 }
1259 spin_unlock_irqrestore(&vga_lock, flags);
1260 }
1261
pci_notify(struct notifier_block * nb,unsigned long action,void * data)1262 static int pci_notify(struct notifier_block *nb, unsigned long action,
1263 void *data)
1264 {
1265 struct device *dev = data;
1266 struct pci_dev *pdev = to_pci_dev(dev);
1267 bool notify = false;
1268
1269 pr_debug("%s\n", __func__);
1270
1271 /* For now we're only intereted in devices added and removed. I didn't
1272 * test this thing here, so someone needs to double check for the
1273 * cases of hotplugable vga cards. */
1274 if (action == BUS_NOTIFY_ADD_DEVICE)
1275 notify = vga_arbiter_add_pci_device(pdev);
1276 else if (action == BUS_NOTIFY_DEL_DEVICE)
1277 notify = vga_arbiter_del_pci_device(pdev);
1278
1279 if (notify)
1280 vga_arbiter_notify_clients();
1281 return 0;
1282 }
1283
1284 static struct notifier_block pci_notifier = {
1285 .notifier_call = pci_notify,
1286 };
1287
1288 static const struct file_operations vga_arb_device_fops = {
1289 .read = vga_arb_read,
1290 .write = vga_arb_write,
1291 .poll = vga_arb_fpoll,
1292 .open = vga_arb_open,
1293 .release = vga_arb_release,
1294 .llseek = noop_llseek,
1295 };
1296
1297 static struct miscdevice vga_arb_device = {
1298 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1299 };
1300
vga_arb_device_init(void)1301 static int __init vga_arb_device_init(void)
1302 {
1303 int rc;
1304 struct pci_dev *pdev;
1305 struct vga_device *vgadev;
1306
1307 rc = misc_register(&vga_arb_device);
1308 if (rc < 0)
1309 pr_err("vgaarb: error %d registering device\n", rc);
1310
1311 bus_register_notifier(&pci_bus_type, &pci_notifier);
1312
1313 /* We add all pci devices satisfying vga class in the arbiter by
1314 * default */
1315 pdev = NULL;
1316 while ((pdev =
1317 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1318 PCI_ANY_ID, pdev)) != NULL)
1319 vga_arbiter_add_pci_device(pdev);
1320
1321 pr_info("vgaarb: loaded\n");
1322
1323 list_for_each_entry(vgadev, &vga_list, list) {
1324 if (vgadev->bridge_has_one_vga)
1325 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1326 else
1327 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1328 }
1329 return rc;
1330 }
1331 subsys_initcall(vga_arb_device_init);
1332