Loading...
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
49static 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 */
54struct 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
71static LIST_HEAD(vga_list);
72static int vga_count, vga_decode_count;
73static bool vga_arbiter_used;
74static DEFINE_SPINLOCK(vga_lock);
75static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
76
77
78static 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
93static 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;
110both:
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 */
117static struct pci_dev *vga_default;
118#endif
119
120static void vga_arb_device_card_gone(struct pci_dev *pdev);
121
122/* Find somebody in our list */
123static 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
135struct pci_dev *vga_default_device(void)
136{
137 return vga_default;
138}
139
140EXPORT_SYMBOL_GPL(vga_default_device);
141
142void vga_set_default_device(struct pci_dev *pdev)
143{
144 if (vga_default == pdev)
145 return;
146
147 pci_dev_put(vga_default);
148 vga_default = pci_dev_get(pdev);
149}
150#endif
151
152static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
153{
154 if (vgadev->irq_set_state)
155 vgadev->irq_set_state(vgadev->cookie, state);
156}
157
158
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 */
162static void vga_check_first_use(void)
163{
164 /* we should inform all GPUs in the system that
165 * VGA arb has occurred and to try and disable resources
166 * if they can */
167 if (!vga_arbiter_used) {
168 vga_arbiter_used = true;
169 vga_arbiter_notify_clients();
170 }
171}
172
173static struct vga_device *__vga_tryget(struct vga_device *vgadev,
174 unsigned int rsrc)
175{
176 unsigned int wants, legacy_wants, match;
177 struct vga_device *conflict;
178 unsigned int pci_bits;
179 u32 flags = 0;
180
181 /* Account for "normal" resources to lock. If we decode the legacy,
182 * counterpart, we need to request it as well
183 */
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;
190
191 pr_debug("%s: %d\n", __func__, rsrc);
192 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
193
194 /* Check what resources we need to acquire */
195 wants = rsrc & ~vgadev->owns;
196
197 /* We already own everything, just mark locked & bye bye */
198 if (wants == 0)
199 goto lock_them;
200
201 /* We don't need to request a legacy resource, we just enable
202 * appropriate decoding and go
203 */
204 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
205 if (legacy_wants == 0)
206 goto enable_them;
207
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;
212
213 /* Don't conflict with myself */
214 if (vgadev == conflict)
215 continue;
216
217 /* Check if the architecture allows a conflict between those
218 * 2 devices or if they are on separate domains
219 */
220 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
221 continue;
222
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
228 */
229 if (vgadev->pdev->bus != conflict->pdev->bus) {
230 change_bridge = 1;
231 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
232 }
233
234 /* Check if the guy has a lock on the resource. If he does,
235 * return the conflicting entry
236 */
237 if (conflict->locks & lwants)
238 return conflict;
239
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
243 * in this code...
244 */
245 WARN_ON(conflict->owns & ~conflict->decodes);
246 match = lwants & conflict->owns;
247 if (!match)
248 continue;
249
250 /* looks like he doesn't have a lock, we can steal
251 * them from him
252 */
253
254 flags = 0;
255 pci_bits = 0;
256
257 if (!conflict->bridge_has_one_vga) {
258 vga_irq_set_state(conflict, false);
259 flags |= PCI_VGA_STATE_CHANGE_DECODES;
260 if (match & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
261 pci_bits |= PCI_COMMAND_MEMORY;
262 if (match & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
263 pci_bits |= PCI_COMMAND_IO;
264 }
265
266 if (change_bridge)
267 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
268
269 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
270 conflict->owns &= ~match;
271 /* If he also owned non-legacy, that is no longer the case */
272 if (match & VGA_RSRC_LEGACY_MEM)
273 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
274 if (match & VGA_RSRC_LEGACY_IO)
275 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
276 }
277
278enable_them:
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
282 * not own them.
283 */
284 flags = 0;
285 pci_bits = 0;
286
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;
293 }
294 if (!!(wants & VGA_RSRC_LEGACY_MASK))
295 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
296
297 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
298
299 if (!vgadev->bridge_has_one_vga) {
300 vga_irq_set_state(vgadev, true);
301 }
302 vgadev->owns |= (wants & vgadev->decodes);
303lock_them:
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++;
313
314 return NULL;
315}
316
317static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
318{
319 unsigned int old_locks = vgadev->locks;
320
321 pr_debug("%s\n", __func__);
322
323 /* Update our counters, and account for equivalent legacy resources
324 * if we decode them
325 */
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;
330 }
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;
335 }
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--;
340
341 /* Just clear lock bits, we do lazy operations so we don't really
342 * have to bother about anything else at this point
343 */
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;
348
349 /* Kick the wait queue in case somebody was waiting if we actually
350 * released something
351 */
352 if (old_locks != vgadev->locks)
353 wake_up_all(&vga_wait_queue);
354}
355
356int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
357{
358 struct vga_device *vgadev, *conflict;
359 unsigned long flags;
360 wait_queue_t wait;
361 int rc = 0;
362
363 vga_check_first_use();
364 /* The one who calls us should check for this, but lets be sure... */
365 if (pdev == NULL)
366 pdev = vga_default_device();
367 if (pdev == NULL)
368 return 0;
369
370 for (;;) {
371 spin_lock_irqsave(&vga_lock, flags);
372 vgadev = vgadev_find(pdev);
373 if (vgadev == NULL) {
374 spin_unlock_irqrestore(&vga_lock, flags);
375 rc = -ENODEV;
376 break;
377 }
378 conflict = __vga_tryget(vgadev, rsrc);
379 spin_unlock_irqrestore(&vga_lock, flags);
380 if (conflict == NULL)
381 break;
382
383
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
389 */
390 init_waitqueue_entry(&wait, current);
391 add_wait_queue(&vga_wait_queue, &wait);
392 set_current_state(interruptible ?
393 TASK_INTERRUPTIBLE :
394 TASK_UNINTERRUPTIBLE);
395 if (signal_pending(current)) {
396 rc = -EINTR;
397 break;
398 }
399 schedule();
400 remove_wait_queue(&vga_wait_queue, &wait);
401 set_current_state(TASK_RUNNING);
402 }
403 return rc;
404}
405EXPORT_SYMBOL(vga_get);
406
407int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
408{
409 struct vga_device *vgadev;
410 unsigned long flags;
411 int rc = 0;
412
413 vga_check_first_use();
414
415 /* The one who calls us should check for this, but lets be sure... */
416 if (pdev == NULL)
417 pdev = vga_default_device();
418 if (pdev == NULL)
419 return 0;
420 spin_lock_irqsave(&vga_lock, flags);
421 vgadev = vgadev_find(pdev);
422 if (vgadev == NULL) {
423 rc = -ENODEV;
424 goto bail;
425 }
426 if (__vga_tryget(vgadev, rsrc))
427 rc = -EBUSY;
428bail:
429 spin_unlock_irqrestore(&vga_lock, flags);
430 return rc;
431}
432EXPORT_SYMBOL(vga_tryget);
433
434void vga_put(struct pci_dev *pdev, unsigned int rsrc)
435{
436 struct vga_device *vgadev;
437 unsigned long flags;
438
439 /* The one who calls us should check for this, but lets be sure... */
440 if (pdev == NULL)
441 pdev = vga_default_device();
442 if (pdev == NULL)
443 return;
444 spin_lock_irqsave(&vga_lock, flags);
445 vgadev = vgadev_find(pdev);
446 if (vgadev == NULL)
447 goto bail;
448 __vga_put(vgadev, rsrc);
449bail:
450 spin_unlock_irqrestore(&vga_lock, flags);
451}
452EXPORT_SYMBOL(vga_put);
453
454/* Rules for using a bridge to control a VGA descendant decoding:
455 if a bridge has only one VGA descendant then it can be used
456 to control the VGA routing for that device.
457 It should always use the bridge closest to the device to control it.
458 If a bridge has a direct VGA descendant, but also have a sub-bridge
459 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
460 So for every device we register, we need to iterate all its parent bridges
461 so we can invalidate any devices using them properly.
462*/
463static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
464{
465 struct vga_device *same_bridge_vgadev;
466 struct pci_bus *new_bus, *bus;
467 struct pci_dev *new_bridge, *bridge;
468
469 vgadev->bridge_has_one_vga = true;
470
471 if (list_empty(&vga_list))
472 return;
473
474 /* okay iterate the new devices bridge hierarachy */
475 new_bus = vgadev->pdev->bus;
476 while (new_bus) {
477 new_bridge = new_bus->self;
478
479 /* go through list of devices already registered */
480 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
481 bus = same_bridge_vgadev->pdev->bus;
482 bridge = bus->self;
483
484 /* see if the share a bridge with this device */
485 if (new_bridge == bridge) {
486 /* if their direct parent bridge is the same
487 as any bridge of this device then it can't be used
488 for that device */
489 same_bridge_vgadev->bridge_has_one_vga = false;
490 }
491
492 /* now iterate the previous devices bridge hierarchy */
493 /* if the new devices parent bridge is in the other devices
494 hierarchy then we can't use it to control this device */
495 while (bus) {
496 bridge = bus->self;
497 if (bridge) {
498 if (bridge == vgadev->pdev->bus->self)
499 vgadev->bridge_has_one_vga = false;
500 }
501 bus = bus->parent;
502 }
503 }
504 new_bus = new_bus->parent;
505 }
506}
507
508/*
509 * Currently, we assume that the "initial" setup of the system is
510 * not sane, that is we come up with conflicting devices and let
511 * the arbiter's client decides if devices decodes or not legacy
512 * things.
513 */
514static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
515{
516 struct vga_device *vgadev;
517 unsigned long flags;
518 struct pci_bus *bus;
519 struct pci_dev *bridge;
520 u16 cmd;
521
522 /* Only deal with VGA class devices */
523 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
524 return false;
525
526 /* Allocate structure */
527 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
528 if (vgadev == NULL) {
529 pr_err("vgaarb: failed to allocate pci device\n");
530 /* What to do on allocation failure ? For now, let's
531 * just do nothing, I'm not sure there is anything saner
532 * to be done
533 */
534 return false;
535 }
536
537 memset(vgadev, 0, sizeof(*vgadev));
538
539 /* Take lock & check for duplicates */
540 spin_lock_irqsave(&vga_lock, flags);
541 if (vgadev_find(pdev) != NULL) {
542 BUG_ON(1);
543 goto fail;
544 }
545 vgadev->pdev = pdev;
546
547 /* By default, assume we decode everything */
548 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
549 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
550
551 /* by default mark it as decoding */
552 vga_decode_count++;
553 /* Mark that we "own" resources based on our enables, we will
554 * clear that below if the bridge isn't forwarding
555 */
556 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
557 if (cmd & PCI_COMMAND_IO)
558 vgadev->owns |= VGA_RSRC_LEGACY_IO;
559 if (cmd & PCI_COMMAND_MEMORY)
560 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
561
562 /* Check if VGA cycles can get down to us */
563 bus = pdev->bus;
564 while (bus) {
565 bridge = bus->self;
566 if (bridge) {
567 u16 l;
568 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
569 &l);
570 if (!(l & PCI_BRIDGE_CTL_VGA)) {
571 vgadev->owns = 0;
572 break;
573 }
574 }
575 bus = bus->parent;
576 }
577
578 /* Deal with VGA default device. Use first enabled one
579 * by default if arch doesn't have it's own hook
580 */
581#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
582 if (vga_default == NULL &&
583 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
584 vga_set_default_device(pdev);
585#endif
586
587 vga_arbiter_check_bridge_sharing(vgadev);
588
589 /* Add to the list */
590 list_add(&vgadev->list, &vga_list);
591 vga_count++;
592 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
593 pci_name(pdev),
594 vga_iostate_to_str(vgadev->decodes),
595 vga_iostate_to_str(vgadev->owns),
596 vga_iostate_to_str(vgadev->locks));
597
598 spin_unlock_irqrestore(&vga_lock, flags);
599 return true;
600fail:
601 spin_unlock_irqrestore(&vga_lock, flags);
602 kfree(vgadev);
603 return false;
604}
605
606static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
607{
608 struct vga_device *vgadev;
609 unsigned long flags;
610 bool ret = true;
611
612 spin_lock_irqsave(&vga_lock, flags);
613 vgadev = vgadev_find(pdev);
614 if (vgadev == NULL) {
615 ret = false;
616 goto bail;
617 }
618
619#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
620 if (vga_default == pdev)
621 vga_set_default_device(NULL);
622#endif
623
624 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
625 vga_decode_count--;
626
627 /* Remove entry from list */
628 list_del(&vgadev->list);
629 vga_count--;
630 /* Notify userland driver that the device is gone so it discards
631 * it's copies of the pci_dev pointer
632 */
633 vga_arb_device_card_gone(pdev);
634
635 /* Wake up all possible waiters */
636 wake_up_all(&vga_wait_queue);
637bail:
638 spin_unlock_irqrestore(&vga_lock, flags);
639 kfree(vgadev);
640 return ret;
641}
642
643/* this is called with the lock */
644static inline void vga_update_device_decodes(struct vga_device *vgadev,
645 int new_decodes)
646{
647 int old_decodes, decodes_removed, decodes_unlocked;
648
649 old_decodes = vgadev->decodes;
650 decodes_removed = ~new_decodes & old_decodes;
651 decodes_unlocked = vgadev->locks & decodes_removed;
652 vgadev->owns &= ~decodes_removed;
653 vgadev->decodes = new_decodes;
654
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));
660
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);
668 }
669
670 /* change decodes counter */
671 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
672 !(new_decodes & VGA_RSRC_LEGACY_MASK))
673 vga_decode_count--;
674 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
675 new_decodes & VGA_RSRC_LEGACY_MASK)
676 vga_decode_count++;
677 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
678}
679
680static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
681{
682 struct vga_device *vgadev;
683 unsigned long flags;
684
685 decodes &= VGA_RSRC_LEGACY_MASK;
686
687 spin_lock_irqsave(&vga_lock, flags);
688 vgadev = vgadev_find(pdev);
689 if (vgadev == NULL)
690 goto bail;
691
692 /* don't let userspace futz with kernel driver decodes */
693 if (userspace && vgadev->set_vga_decode)
694 goto bail;
695
696 /* update the device decodes + counter */
697 vga_update_device_decodes(vgadev, decodes);
698
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 ...
702 */
703bail:
704 spin_unlock_irqrestore(&vga_lock, flags);
705}
706
707void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
708{
709 __vga_set_legacy_decoding(pdev, decodes, false);
710}
711EXPORT_SYMBOL(vga_set_legacy_decoding);
712
713/* call with NULL to unregister */
714int 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))
717{
718 int ret = -ENODEV;
719 struct vga_device *vgadev;
720 unsigned long flags;
721
722 spin_lock_irqsave(&vga_lock, flags);
723 vgadev = vgadev_find(pdev);
724 if (!vgadev)
725 goto bail;
726
727 vgadev->irq_set_state = irq_set_state;
728 vgadev->set_vga_decode = set_vga_decode;
729 vgadev->cookie = cookie;
730 ret = 0;
731
732bail:
733 spin_unlock_irqrestore(&vga_lock, flags);
734 return ret;
735
736}
737EXPORT_SYMBOL(vga_client_register);
738
739/*
740 * Char driver implementation
741 *
742 * Semantics is:
743 *
744 * open : open user instance of the arbitrer. by default, it's
745 * attached to the default VGA device of the system.
746 *
747 * close : close user instance, release locks
748 *
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
758 *
759 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
760 *
761 * write : write a command to the arbiter. List of commands is:
762 *
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
769 *
770 * poll : event if something change on any card (not just the target)
771 *
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.
777 *
778 * Note about locks:
779 *
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.
786 *
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
789 * the arbiter.
790 */
791
792#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
793#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
794
795/*
796 * Each user has an array of these, tracking which cards have locks
797 */
798struct vga_arb_user_card {
799 struct pci_dev *pdev;
800 unsigned int mem_cnt;
801 unsigned int io_cnt;
802};
803
804struct vga_arb_private {
805 struct list_head list;
806 struct pci_dev *target;
807 struct vga_arb_user_card cards[MAX_USER_CARDS];
808 spinlock_t lock;
809};
810
811static LIST_HEAD(vga_user_list);
812static DEFINE_SPINLOCK(vga_user_lock);
813
814
815/*
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,
818 * it returns 0.
819 */
820static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
821 unsigned int *bus, unsigned int *devfn)
822{
823 int n;
824 unsigned int slot, func;
825
826
827 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
828 if (n != 4)
829 return 0;
830
831 *devfn = PCI_DEVFN(slot, func);
832
833 return 1;
834}
835
836static ssize_t vga_arb_read(struct file *file, char __user * buf,
837 size_t count, loff_t *ppos)
838{
839 struct vga_arb_private *priv = file->private_data;
840 struct vga_device *vgadev;
841 struct pci_dev *pdev;
842 unsigned long flags;
843 size_t len;
844 int rc;
845 char *lbuf;
846
847 lbuf = kmalloc(1024, GFP_KERNEL);
848 if (lbuf == NULL)
849 return -ENOMEM;
850
851 /* Shields against vga_arb_device_card_gone (pci_dev going
852 * away), and allows access to vga list
853 */
854 spin_lock_irqsave(&vga_lock, flags);
855
856 /* If we are targeting the default, use it */
857 pdev = priv->target;
858 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
859 spin_unlock_irqrestore(&vga_lock, flags);
860 len = sprintf(lbuf, "invalid");
861 goto done;
862 }
863
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
869 */
870 if (pdev == priv->target)
871 vga_arb_device_card_gone(pdev);
872 spin_unlock_irqrestore(&vga_lock, flags);
873 len = sprintf(lbuf, "invalid");
874 goto done;
875 }
876
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);
885
886 spin_unlock_irqrestore(&vga_lock, flags);
887done:
888
889 /* Copy that to user */
890 if (len > count)
891 len = count;
892 rc = copy_to_user(buf, lbuf, len);
893 kfree(lbuf);
894 if (rc)
895 return -EFAULT;
896 return len;
897}
898
899/*
900 * TODO: To avoid parsing inside kernel and to improve the speed we may
901 * consider use ioctl here
902 */
903static ssize_t vga_arb_write(struct file *file, const char __user * buf,
904 size_t count, loff_t *ppos)
905{
906 struct vga_arb_private *priv = file->private_data;
907 struct vga_arb_user_card *uc = NULL;
908 struct pci_dev *pdev;
909
910 unsigned int io_state;
911
912 char *kbuf, *curr_pos;
913 size_t remaining = count;
914
915 int ret_val;
916 int i;
917
918
919 kbuf = kmalloc(count + 1, GFP_KERNEL);
920 if (!kbuf)
921 return -ENOMEM;
922
923 if (copy_from_user(kbuf, buf, count)) {
924 kfree(kbuf);
925 return -EFAULT;
926 }
927 curr_pos = kbuf;
928 kbuf[count] = '\0'; /* Just to make sure... */
929
930 if (strncmp(curr_pos, "lock ", 5) == 0) {
931 curr_pos += 5;
932 remaining -= 5;
933
934 pr_debug("client 0x%p called 'lock'\n", priv);
935
936 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
937 ret_val = -EPROTO;
938 goto done;
939 }
940 if (io_state == VGA_RSRC_NONE) {
941 ret_val = -EPROTO;
942 goto done;
943 }
944
945 pdev = priv->target;
946 if (priv->target == NULL) {
947 ret_val = -ENODEV;
948 goto done;
949 }
950
951 vga_get_uninterruptible(pdev, io_state);
952
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++;
960 break;
961 }
962 }
963
964 ret_val = count;
965 goto done;
966 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
967 curr_pos += 7;
968 remaining -= 7;
969
970 pr_debug("client 0x%p called 'unlock'\n", priv);
971
972 if (strncmp(curr_pos, "all", 3) == 0)
973 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
974 else {
975 if (!vga_str_to_iostate
976 (curr_pos, remaining, &io_state)) {
977 ret_val = -EPROTO;
978 goto done;
979 }
980 /* TODO: Add this?
981 if (io_state == VGA_RSRC_NONE) {
982 ret_val = -EPROTO;
983 goto done;
984 }
985 */
986 }
987
988 pdev = priv->target;
989 if (priv->target == NULL) {
990 ret_val = -ENODEV;
991 goto done;
992 }
993 for (i = 0; i < MAX_USER_CARDS; i++) {
994 if (priv->cards[i].pdev == pdev)
995 uc = &priv->cards[i];
996 }
997
998 if (!uc) {
999 ret_val = -EINVAL;
1000 goto done;
1001 }
1002
1003 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1004 ret_val = -EINVAL;
1005 goto done;
1006 }
1007
1008 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1009 ret_val = -EINVAL;
1010 goto done;
1011 }
1012
1013 vga_put(pdev, io_state);
1014
1015 if (io_state & VGA_RSRC_LEGACY_IO)
1016 uc->io_cnt--;
1017 if (io_state & VGA_RSRC_LEGACY_MEM)
1018 uc->mem_cnt--;
1019
1020 ret_val = count;
1021 goto done;
1022 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1023 curr_pos += 8;
1024 remaining -= 8;
1025
1026 pr_debug("client 0x%p called 'trylock'\n", priv);
1027
1028 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1029 ret_val = -EPROTO;
1030 goto done;
1031 }
1032 /* TODO: Add this?
1033 if (io_state == VGA_RSRC_NONE) {
1034 ret_val = -EPROTO;
1035 goto done;
1036 }
1037 */
1038
1039 pdev = priv->target;
1040 if (priv->target == NULL) {
1041 ret_val = -ENODEV;
1042 goto done;
1043 }
1044
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++;
1053 break;
1054 }
1055 }
1056 ret_val = count;
1057 goto done;
1058 } else {
1059 ret_val = -EBUSY;
1060 goto done;
1061 }
1062
1063 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1064 unsigned int domain, bus, devfn;
1065 struct vga_device *vgadev;
1066
1067 curr_pos += 7;
1068 remaining -= 7;
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());
1073 else {
1074 if (!vga_pci_str_to_vars(curr_pos, remaining,
1075 &domain, &bus, &devfn)) {
1076 ret_val = -EPROTO;
1077 goto done;
1078 }
1079 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
1080 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1081
1082 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1083 pr_debug("vgaarb: pdev %p\n", pdev);
1084 if (!pdev) {
1085 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1086 domain, bus, devfn);
1087 ret_val = -ENODEV;
1088 goto done;
1089 }
1090 }
1091
1092 vgadev = vgadev_find(pdev);
1093 pr_debug("vgaarb: vgadev %p\n", vgadev);
1094 if (vgadev == NULL) {
1095 pr_err("vgaarb: this pci device is not a vga device\n");
1096 pci_dev_put(pdev);
1097 ret_val = -ENODEV;
1098 goto done;
1099 }
1100
1101 priv->target = pdev;
1102 for (i = 0; i < MAX_USER_CARDS; i++) {
1103 if (priv->cards[i].pdev == pdev)
1104 break;
1105 if (priv->cards[i].pdev == NULL) {
1106 priv->cards[i].pdev = pdev;
1107 priv->cards[i].io_cnt = 0;
1108 priv->cards[i].mem_cnt = 0;
1109 break;
1110 }
1111 }
1112 if (i == MAX_USER_CARDS) {
1113 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1114 MAX_USER_CARDS);
1115 pci_dev_put(pdev);
1116 /* XXX: which value to return? */
1117 ret_val = -ENOMEM;
1118 goto done;
1119 }
1120
1121 ret_val = count;
1122 pci_dev_put(pdev);
1123 goto done;
1124
1125
1126 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1127 curr_pos += 8;
1128 remaining -= 8;
1129 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1130
1131 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1132 ret_val = -EPROTO;
1133 goto done;
1134 }
1135 pdev = priv->target;
1136 if (priv->target == NULL) {
1137 ret_val = -ENODEV;
1138 goto done;
1139 }
1140
1141 __vga_set_legacy_decoding(pdev, io_state, true);
1142 ret_val = count;
1143 goto done;
1144 }
1145 /* If we got here, the message written is not part of the protocol! */
1146 kfree(kbuf);
1147 return -EPROTO;
1148
1149done:
1150 kfree(kbuf);
1151 return ret_val;
1152}
1153
1154static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1155{
1156 struct vga_arb_private *priv = file->private_data;
1157
1158 pr_debug("%s\n", __func__);
1159
1160 if (priv == NULL)
1161 return -ENODEV;
1162 poll_wait(file, &vga_wait_queue, wait);
1163 return POLLIN;
1164}
1165
1166static int vga_arb_open(struct inode *inode, struct file *file)
1167{
1168 struct vga_arb_private *priv;
1169 unsigned long flags;
1170
1171 pr_debug("%s\n", __func__);
1172
1173 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1174 if (priv == NULL)
1175 return -ENOMEM;
1176 spin_lock_init(&priv->lock);
1177 file->private_data = priv;
1178
1179 spin_lock_irqsave(&vga_user_lock, flags);
1180 list_add(&priv->list, &vga_user_list);
1181 spin_unlock_irqrestore(&vga_user_lock, flags);
1182
1183 /* Set the client' lists of locks */
1184 priv->target = vga_default_device(); /* Maybe this is still null! */
1185 priv->cards[0].pdev = priv->target;
1186 priv->cards[0].io_cnt = 0;
1187 priv->cards[0].mem_cnt = 0;
1188
1189
1190 return 0;
1191}
1192
1193static int vga_arb_release(struct inode *inode, struct file *file)
1194{
1195 struct vga_arb_private *priv = file->private_data;
1196 struct vga_arb_user_card *uc;
1197 unsigned long flags;
1198 int i;
1199
1200 pr_debug("%s\n", __func__);
1201
1202 if (priv == NULL)
1203 return -ENODEV;
1204
1205 spin_lock_irqsave(&vga_user_lock, flags);
1206 list_del(&priv->list);
1207 for (i = 0; i < MAX_USER_CARDS; i++) {
1208 uc = &priv->cards[i];
1209 if (uc->pdev == NULL)
1210 continue;
1211 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1212 uc->io_cnt, uc->mem_cnt);
1213 while (uc->io_cnt--)
1214 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1215 while (uc->mem_cnt--)
1216 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1217 }
1218 spin_unlock_irqrestore(&vga_user_lock, flags);
1219
1220 kfree(priv);
1221
1222 return 0;
1223}
1224
1225static void vga_arb_device_card_gone(struct pci_dev *pdev)
1226{
1227}
1228
1229/*
1230 * callback any registered clients to let them know we have a
1231 * change in VGA cards
1232 */
1233static void vga_arbiter_notify_clients(void)
1234{
1235 struct vga_device *vgadev;
1236 unsigned long flags;
1237 uint32_t new_decodes;
1238 bool new_state;
1239
1240 if (!vga_arbiter_used)
1241 return;
1242
1243 spin_lock_irqsave(&vga_lock, flags);
1244 list_for_each_entry(vgadev, &vga_list, list) {
1245 if (vga_count > 1)
1246 new_state = false;
1247 else
1248 new_state = true;
1249 if (vgadev->set_vga_decode) {
1250 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1251 vga_update_device_decodes(vgadev, new_decodes);
1252 }
1253 }
1254 spin_unlock_irqrestore(&vga_lock, flags);
1255}
1256
1257static int pci_notify(struct notifier_block *nb, unsigned long action,
1258 void *data)
1259{
1260 struct device *dev = data;
1261 struct pci_dev *pdev = to_pci_dev(dev);
1262 bool notify = false;
1263
1264 pr_debug("%s\n", __func__);
1265
1266 /* For now we're only intereted in devices added and removed. I didn't
1267 * test this thing here, so someone needs to double check for the
1268 * cases of hotplugable vga cards. */
1269 if (action == BUS_NOTIFY_ADD_DEVICE)
1270 notify = vga_arbiter_add_pci_device(pdev);
1271 else if (action == BUS_NOTIFY_DEL_DEVICE)
1272 notify = vga_arbiter_del_pci_device(pdev);
1273
1274 if (notify)
1275 vga_arbiter_notify_clients();
1276 return 0;
1277}
1278
1279static struct notifier_block pci_notifier = {
1280 .notifier_call = pci_notify,
1281};
1282
1283static const struct file_operations vga_arb_device_fops = {
1284 .read = vga_arb_read,
1285 .write = vga_arb_write,
1286 .poll = vga_arb_fpoll,
1287 .open = vga_arb_open,
1288 .release = vga_arb_release,
1289 .llseek = noop_llseek,
1290};
1291
1292static struct miscdevice vga_arb_device = {
1293 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1294};
1295
1296static int __init vga_arb_device_init(void)
1297{
1298 int rc;
1299 struct pci_dev *pdev;
1300 struct vga_device *vgadev;
1301
1302 rc = misc_register(&vga_arb_device);
1303 if (rc < 0)
1304 pr_err("vgaarb: error %d registering device\n", rc);
1305
1306 bus_register_notifier(&pci_bus_type, &pci_notifier);
1307
1308 /* We add all pci devices satisfying vga class in the arbiter by
1309 * default */
1310 pdev = NULL;
1311 while ((pdev =
1312 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1313 PCI_ANY_ID, pdev)) != NULL)
1314 vga_arbiter_add_pci_device(pdev);
1315
1316 pr_info("vgaarb: loaded\n");
1317
1318 list_for_each_entry(vgadev, &vga_list, list) {
1319 if (vgadev->bridge_has_one_vga)
1320 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1321 else
1322 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1323 }
1324 return rc;
1325}
1326subsys_initcall(vga_arb_device_init);
1/*
2 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/gpu/vgaarbiter.rst
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#define pr_fmt(fmt) "vgaarb: " fmt
33
34#define vgaarb_dbg(dev, fmt, arg...) dev_dbg(dev, "vgaarb: " fmt, ##arg)
35#define vgaarb_info(dev, fmt, arg...) dev_info(dev, "vgaarb: " fmt, ##arg)
36#define vgaarb_err(dev, fmt, arg...) dev_err(dev, "vgaarb: " fmt, ##arg)
37
38#include <linux/module.h>
39#include <linux/kernel.h>
40#include <linux/pci.h>
41#include <linux/errno.h>
42#include <linux/init.h>
43#include <linux/list.h>
44#include <linux/sched/signal.h>
45#include <linux/wait.h>
46#include <linux/spinlock.h>
47#include <linux/poll.h>
48#include <linux/miscdevice.h>
49#include <linux/slab.h>
50#include <linux/screen_info.h>
51#include <linux/vt.h>
52#include <linux/console.h>
53#include <linux/acpi.h>
54
55#include <linux/uaccess.h>
56
57#include <linux/vgaarb.h>
58
59static void vga_arbiter_notify_clients(void);
60/*
61 * We keep a list of all vga devices in the system to speed
62 * up the various operations of the arbiter
63 */
64struct vga_device {
65 struct list_head list;
66 struct pci_dev *pdev;
67 unsigned int decodes; /* what does it decodes */
68 unsigned int owns; /* what does it owns */
69 unsigned int locks; /* what does it locks */
70 unsigned int io_lock_cnt; /* legacy IO lock count */
71 unsigned int mem_lock_cnt; /* legacy MEM lock count */
72 unsigned int io_norm_cnt; /* normal IO count */
73 unsigned int mem_norm_cnt; /* normal MEM count */
74 bool bridge_has_one_vga;
75 /* allow IRQ enable/disable hook */
76 void *cookie;
77 void (*irq_set_state)(void *cookie, bool enable);
78 unsigned int (*set_vga_decode)(void *cookie, bool decode);
79};
80
81static LIST_HEAD(vga_list);
82static int vga_count, vga_decode_count;
83static bool vga_arbiter_used;
84static DEFINE_SPINLOCK(vga_lock);
85static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
86
87
88static const char *vga_iostate_to_str(unsigned int iostate)
89{
90 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
91 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
92 switch (iostate) {
93 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
94 return "io+mem";
95 case VGA_RSRC_LEGACY_IO:
96 return "io";
97 case VGA_RSRC_LEGACY_MEM:
98 return "mem";
99 }
100 return "none";
101}
102
103static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
104{
105 /* we could in theory hand out locks on IO and mem
106 * separately to userspace but it can cause deadlocks */
107 if (strncmp(buf, "none", 4) == 0) {
108 *io_state = VGA_RSRC_NONE;
109 return 1;
110 }
111
112 /* XXX We're not chekcing the str_size! */
113 if (strncmp(buf, "io+mem", 6) == 0)
114 goto both;
115 else if (strncmp(buf, "io", 2) == 0)
116 goto both;
117 else if (strncmp(buf, "mem", 3) == 0)
118 goto both;
119 return 0;
120both:
121 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
122 return 1;
123}
124
125/* this is only used a cookie - it should not be dereferenced */
126static struct pci_dev *vga_default;
127
128static void vga_arb_device_card_gone(struct pci_dev *pdev);
129
130/* Find somebody in our list */
131static struct vga_device *vgadev_find(struct pci_dev *pdev)
132{
133 struct vga_device *vgadev;
134
135 list_for_each_entry(vgadev, &vga_list, list)
136 if (pdev == vgadev->pdev)
137 return vgadev;
138 return NULL;
139}
140
141/**
142 * vga_default_device - return the default VGA device, for vgacon
143 *
144 * This can be defined by the platform. The default implementation
145 * is rather dumb and will probably only work properly on single
146 * vga card setups and/or x86 platforms.
147 *
148 * If your VGA default device is not PCI, you'll have to return
149 * NULL here. In this case, I assume it will not conflict with
150 * any PCI card. If this is not true, I'll have to define two archs
151 * hooks for enabling/disabling the VGA default device if that is
152 * possible. This may be a problem with real _ISA_ VGA cards, in
153 * addition to a PCI one. I don't know at this point how to deal
154 * with that card. Can theirs IOs be disabled at all ? If not, then
155 * I suppose it's a matter of having the proper arch hook telling
156 * us about it, so we basically never allow anybody to succeed a
157 * vga_get()...
158 */
159struct pci_dev *vga_default_device(void)
160{
161 return vga_default;
162}
163EXPORT_SYMBOL_GPL(vga_default_device);
164
165void vga_set_default_device(struct pci_dev *pdev)
166{
167 if (vga_default == pdev)
168 return;
169
170 pci_dev_put(vga_default);
171 vga_default = pci_dev_get(pdev);
172}
173
174/**
175 * vga_remove_vgacon - deactivete vga console
176 *
177 * Unbind and unregister vgacon in case pdev is the default vga
178 * device. Can be called by gpu drivers on initialization to make
179 * sure vga register access done by vgacon will not disturb the
180 * device.
181 *
182 * @pdev: pci device.
183 */
184#if !defined(CONFIG_VGA_CONSOLE)
185int vga_remove_vgacon(struct pci_dev *pdev)
186{
187 return 0;
188}
189#elif !defined(CONFIG_DUMMY_CONSOLE)
190int vga_remove_vgacon(struct pci_dev *pdev)
191{
192 return -ENODEV;
193}
194#else
195int vga_remove_vgacon(struct pci_dev *pdev)
196{
197 int ret = 0;
198
199 if (pdev != vga_default)
200 return 0;
201 vgaarb_info(&pdev->dev, "deactivate vga console\n");
202
203 console_lock();
204 if (con_is_bound(&vga_con))
205 ret = do_take_over_console(&dummy_con, 0,
206 MAX_NR_CONSOLES - 1, 1);
207 if (ret == 0) {
208 ret = do_unregister_con_driver(&vga_con);
209
210 /* Ignore "already unregistered". */
211 if (ret == -ENODEV)
212 ret = 0;
213 }
214 console_unlock();
215
216 return ret;
217}
218#endif
219EXPORT_SYMBOL(vga_remove_vgacon);
220
221static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
222{
223 if (vgadev->irq_set_state)
224 vgadev->irq_set_state(vgadev->cookie, state);
225}
226
227
228/* If we don't ever use VGA arb we should avoid
229 turning off anything anywhere due to old X servers getting
230 confused about the boot device not being VGA */
231static void vga_check_first_use(void)
232{
233 /* we should inform all GPUs in the system that
234 * VGA arb has occurred and to try and disable resources
235 * if they can */
236 if (!vga_arbiter_used) {
237 vga_arbiter_used = true;
238 vga_arbiter_notify_clients();
239 }
240}
241
242static struct vga_device *__vga_tryget(struct vga_device *vgadev,
243 unsigned int rsrc)
244{
245 struct device *dev = &vgadev->pdev->dev;
246 unsigned int wants, legacy_wants, match;
247 struct vga_device *conflict;
248 unsigned int pci_bits;
249 u32 flags = 0;
250
251 /* Account for "normal" resources to lock. If we decode the legacy,
252 * counterpart, we need to request it as well
253 */
254 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
255 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
256 rsrc |= VGA_RSRC_LEGACY_IO;
257 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
258 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
259 rsrc |= VGA_RSRC_LEGACY_MEM;
260
261 vgaarb_dbg(dev, "%s: %d\n", __func__, rsrc);
262 vgaarb_dbg(dev, "%s: owns: %d\n", __func__, vgadev->owns);
263
264 /* Check what resources we need to acquire */
265 wants = rsrc & ~vgadev->owns;
266
267 /* We already own everything, just mark locked & bye bye */
268 if (wants == 0)
269 goto lock_them;
270
271 /* We don't need to request a legacy resource, we just enable
272 * appropriate decoding and go
273 */
274 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
275 if (legacy_wants == 0)
276 goto enable_them;
277
278 /* Ok, we don't, let's find out how we need to kick off */
279 list_for_each_entry(conflict, &vga_list, list) {
280 unsigned int lwants = legacy_wants;
281 unsigned int change_bridge = 0;
282
283 /* Don't conflict with myself */
284 if (vgadev == conflict)
285 continue;
286
287 /* Check if the architecture allows a conflict between those
288 * 2 devices or if they are on separate domains
289 */
290 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
291 continue;
292
293 /* We have a possible conflict. before we go further, we must
294 * check if we sit on the same bus as the conflicting device.
295 * if we don't, then we must tie both IO and MEM resources
296 * together since there is only a single bit controlling
297 * VGA forwarding on P2P bridges
298 */
299 if (vgadev->pdev->bus != conflict->pdev->bus) {
300 change_bridge = 1;
301 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
302 }
303
304 /* Check if the guy has a lock on the resource. If he does,
305 * return the conflicting entry
306 */
307 if (conflict->locks & lwants)
308 return conflict;
309
310 /* Ok, now check if it owns the resource we want. We can
311 * lock resources that are not decoded, therefore a device
312 * can own resources it doesn't decode.
313 */
314 match = lwants & conflict->owns;
315 if (!match)
316 continue;
317
318 /* looks like he doesn't have a lock, we can steal
319 * them from him
320 */
321
322 flags = 0;
323 pci_bits = 0;
324
325 /* If we can't control legacy resources via the bridge, we
326 * also need to disable normal decoding.
327 */
328 if (!conflict->bridge_has_one_vga) {
329 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)
330 pci_bits |= PCI_COMMAND_MEMORY;
331 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)
332 pci_bits |= PCI_COMMAND_IO;
333
334 if (pci_bits) {
335 vga_irq_set_state(conflict, false);
336 flags |= PCI_VGA_STATE_CHANGE_DECODES;
337 }
338 }
339
340 if (change_bridge)
341 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
342
343 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
344 conflict->owns &= ~match;
345
346 /* If we disabled normal decoding, reflect it in owns */
347 if (pci_bits & PCI_COMMAND_MEMORY)
348 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
349 if (pci_bits & PCI_COMMAND_IO)
350 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
351 }
352
353enable_them:
354 /* ok dude, we got it, everybody conflicting has been disabled, let's
355 * enable us. Mark any bits in "owns" regardless of whether we
356 * decoded them. We can lock resources we don't decode, therefore
357 * we must track them via "owns".
358 */
359 flags = 0;
360 pci_bits = 0;
361
362 if (!vgadev->bridge_has_one_vga) {
363 flags |= PCI_VGA_STATE_CHANGE_DECODES;
364 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
365 pci_bits |= PCI_COMMAND_MEMORY;
366 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
367 pci_bits |= PCI_COMMAND_IO;
368 }
369 if (wants & VGA_RSRC_LEGACY_MASK)
370 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
371
372 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
373
374 if (!vgadev->bridge_has_one_vga)
375 vga_irq_set_state(vgadev, true);
376
377 vgadev->owns |= wants;
378lock_them:
379 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
380 if (rsrc & VGA_RSRC_LEGACY_IO)
381 vgadev->io_lock_cnt++;
382 if (rsrc & VGA_RSRC_LEGACY_MEM)
383 vgadev->mem_lock_cnt++;
384 if (rsrc & VGA_RSRC_NORMAL_IO)
385 vgadev->io_norm_cnt++;
386 if (rsrc & VGA_RSRC_NORMAL_MEM)
387 vgadev->mem_norm_cnt++;
388
389 return NULL;
390}
391
392static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
393{
394 struct device *dev = &vgadev->pdev->dev;
395 unsigned int old_locks = vgadev->locks;
396
397 vgaarb_dbg(dev, "%s\n", __func__);
398
399 /* Update our counters, and account for equivalent legacy resources
400 * if we decode them
401 */
402 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
403 vgadev->io_norm_cnt--;
404 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
405 rsrc |= VGA_RSRC_LEGACY_IO;
406 }
407 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
408 vgadev->mem_norm_cnt--;
409 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
410 rsrc |= VGA_RSRC_LEGACY_MEM;
411 }
412 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
413 vgadev->io_lock_cnt--;
414 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
415 vgadev->mem_lock_cnt--;
416
417 /* Just clear lock bits, we do lazy operations so we don't really
418 * have to bother about anything else at this point
419 */
420 if (vgadev->io_lock_cnt == 0)
421 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
422 if (vgadev->mem_lock_cnt == 0)
423 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
424
425 /* Kick the wait queue in case somebody was waiting if we actually
426 * released something
427 */
428 if (old_locks != vgadev->locks)
429 wake_up_all(&vga_wait_queue);
430}
431
432/**
433 * vga_get - acquire & locks VGA resources
434 * @pdev: pci device of the VGA card or NULL for the system default
435 * @rsrc: bit mask of resources to acquire and lock
436 * @interruptible: blocking should be interruptible by signals ?
437 *
438 * This function acquires VGA resources for the given card and mark those
439 * resources locked. If the resource requested are "normal" (and not legacy)
440 * resources, the arbiter will first check whether the card is doing legacy
441 * decoding for that type of resource. If yes, the lock is "converted" into a
442 * legacy resource lock.
443 *
444 * The arbiter will first look for all VGA cards that might conflict and disable
445 * their IOs and/or Memory access, including VGA forwarding on P2P bridges if
446 * necessary, so that the requested resources can be used. Then, the card is
447 * marked as locking these resources and the IO and/or Memory accesses are
448 * enabled on the card (including VGA forwarding on parent P2P bridges if any).
449 *
450 * This function will block if some conflicting card is already locking one of
451 * the required resources (or any resource on a different bus segment, since P2P
452 * bridges don't differentiate VGA memory and IO afaik). You can indicate
453 * whether this blocking should be interruptible by a signal (for userland
454 * interface) or not.
455 *
456 * Must not be called at interrupt time or in atomic context. If the card
457 * already owns the resources, the function succeeds. Nested calls are
458 * supported (a per-resource counter is maintained)
459 *
460 * On success, release the VGA resource again with vga_put().
461 *
462 * Returns:
463 *
464 * 0 on success, negative error code on failure.
465 */
466int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
467{
468 struct vga_device *vgadev, *conflict;
469 unsigned long flags;
470 wait_queue_entry_t wait;
471 int rc = 0;
472
473 vga_check_first_use();
474 /* The one who calls us should check for this, but lets be sure... */
475 if (pdev == NULL)
476 pdev = vga_default_device();
477 if (pdev == NULL)
478 return 0;
479
480 for (;;) {
481 spin_lock_irqsave(&vga_lock, flags);
482 vgadev = vgadev_find(pdev);
483 if (vgadev == NULL) {
484 spin_unlock_irqrestore(&vga_lock, flags);
485 rc = -ENODEV;
486 break;
487 }
488 conflict = __vga_tryget(vgadev, rsrc);
489 spin_unlock_irqrestore(&vga_lock, flags);
490 if (conflict == NULL)
491 break;
492
493
494 /* We have a conflict, we wait until somebody kicks the
495 * work queue. Currently we have one work queue that we
496 * kick each time some resources are released, but it would
497 * be fairly easy to have a per device one so that we only
498 * need to attach to the conflicting device
499 */
500 init_waitqueue_entry(&wait, current);
501 add_wait_queue(&vga_wait_queue, &wait);
502 set_current_state(interruptible ?
503 TASK_INTERRUPTIBLE :
504 TASK_UNINTERRUPTIBLE);
505 if (interruptible && signal_pending(current)) {
506 __set_current_state(TASK_RUNNING);
507 remove_wait_queue(&vga_wait_queue, &wait);
508 rc = -ERESTARTSYS;
509 break;
510 }
511 schedule();
512 remove_wait_queue(&vga_wait_queue, &wait);
513 }
514 return rc;
515}
516EXPORT_SYMBOL(vga_get);
517
518/**
519 * vga_tryget - try to acquire & lock legacy VGA resources
520 * @pdev: pci devivce of VGA card or NULL for system default
521 * @rsrc: bit mask of resources to acquire and lock
522 *
523 * This function performs the same operation as vga_get(), but will return an
524 * error (-EBUSY) instead of blocking if the resources are already locked by
525 * another card. It can be called in any context
526 *
527 * On success, release the VGA resource again with vga_put().
528 *
529 * Returns:
530 *
531 * 0 on success, negative error code on failure.
532 */
533static int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
534{
535 struct vga_device *vgadev;
536 unsigned long flags;
537 int rc = 0;
538
539 vga_check_first_use();
540
541 /* The one who calls us should check for this, but lets be sure... */
542 if (pdev == NULL)
543 pdev = vga_default_device();
544 if (pdev == NULL)
545 return 0;
546 spin_lock_irqsave(&vga_lock, flags);
547 vgadev = vgadev_find(pdev);
548 if (vgadev == NULL) {
549 rc = -ENODEV;
550 goto bail;
551 }
552 if (__vga_tryget(vgadev, rsrc))
553 rc = -EBUSY;
554bail:
555 spin_unlock_irqrestore(&vga_lock, flags);
556 return rc;
557}
558
559/**
560 * vga_put - release lock on legacy VGA resources
561 * @pdev: pci device of VGA card or NULL for system default
562 * @rsrc: but mask of resource to release
563 *
564 * This fuction releases resources previously locked by vga_get() or
565 * vga_tryget(). The resources aren't disabled right away, so that a subsequence
566 * vga_get() on the same card will succeed immediately. Resources have a
567 * counter, so locks are only released if the counter reaches 0.
568 */
569void vga_put(struct pci_dev *pdev, unsigned int rsrc)
570{
571 struct vga_device *vgadev;
572 unsigned long flags;
573
574 /* The one who calls us should check for this, but lets be sure... */
575 if (pdev == NULL)
576 pdev = vga_default_device();
577 if (pdev == NULL)
578 return;
579 spin_lock_irqsave(&vga_lock, flags);
580 vgadev = vgadev_find(pdev);
581 if (vgadev == NULL)
582 goto bail;
583 __vga_put(vgadev, rsrc);
584bail:
585 spin_unlock_irqrestore(&vga_lock, flags);
586}
587EXPORT_SYMBOL(vga_put);
588
589/*
590 * Rules for using a bridge to control a VGA descendant decoding: if a bridge
591 * has only one VGA descendant then it can be used to control the VGA routing
592 * for that device. It should always use the bridge closest to the device to
593 * control it. If a bridge has a direct VGA descendant, but also have a sub-
594 * bridge VGA descendant then we cannot use that bridge to control the direct
595 * VGA descendant. So for every device we register, we need to iterate all
596 * its parent bridges so we can invalidate any devices using them properly.
597 */
598static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
599{
600 struct vga_device *same_bridge_vgadev;
601 struct pci_bus *new_bus, *bus;
602 struct pci_dev *new_bridge, *bridge;
603
604 vgadev->bridge_has_one_vga = true;
605
606 if (list_empty(&vga_list))
607 return;
608
609 /* okay iterate the new devices bridge hierarachy */
610 new_bus = vgadev->pdev->bus;
611 while (new_bus) {
612 new_bridge = new_bus->self;
613
614 /* go through list of devices already registered */
615 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
616 bus = same_bridge_vgadev->pdev->bus;
617 bridge = bus->self;
618
619 /* see if the share a bridge with this device */
620 if (new_bridge == bridge) {
621 /*
622 * If their direct parent bridge is the same
623 * as any bridge of this device then it can't
624 * be used for that device.
625 */
626 same_bridge_vgadev->bridge_has_one_vga = false;
627 }
628
629 /*
630 * Now iterate the previous devices bridge hierarchy.
631 * If the new devices parent bridge is in the other
632 * devices hierarchy then we can't use it to control
633 * this device
634 */
635 while (bus) {
636 bridge = bus->self;
637
638 if (bridge && bridge == vgadev->pdev->bus->self)
639 vgadev->bridge_has_one_vga = false;
640
641 bus = bus->parent;
642 }
643 }
644 new_bus = new_bus->parent;
645 }
646}
647
648/*
649 * Currently, we assume that the "initial" setup of the system is
650 * not sane, that is we come up with conflicting devices and let
651 * the arbiter's client decides if devices decodes or not legacy
652 * things.
653 */
654static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
655{
656 struct vga_device *vgadev;
657 unsigned long flags;
658 struct pci_bus *bus;
659 struct pci_dev *bridge;
660 u16 cmd;
661
662 /* Only deal with VGA class devices */
663 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
664 return false;
665
666 /* Allocate structure */
667 vgadev = kzalloc(sizeof(struct vga_device), GFP_KERNEL);
668 if (vgadev == NULL) {
669 vgaarb_err(&pdev->dev, "failed to allocate VGA arbiter data\n");
670 /*
671 * What to do on allocation failure ? For now, let's just do
672 * nothing, I'm not sure there is anything saner to be done.
673 */
674 return false;
675 }
676
677 /* Take lock & check for duplicates */
678 spin_lock_irqsave(&vga_lock, flags);
679 if (vgadev_find(pdev) != NULL) {
680 BUG_ON(1);
681 goto fail;
682 }
683 vgadev->pdev = pdev;
684
685 /* By default, assume we decode everything */
686 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
687 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
688
689 /* by default mark it as decoding */
690 vga_decode_count++;
691 /* Mark that we "own" resources based on our enables, we will
692 * clear that below if the bridge isn't forwarding
693 */
694 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
695 if (cmd & PCI_COMMAND_IO)
696 vgadev->owns |= VGA_RSRC_LEGACY_IO;
697 if (cmd & PCI_COMMAND_MEMORY)
698 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
699
700 /* Check if VGA cycles can get down to us */
701 bus = pdev->bus;
702 while (bus) {
703 bridge = bus->self;
704 if (bridge) {
705 u16 l;
706
707 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &l);
708 if (!(l & PCI_BRIDGE_CTL_VGA)) {
709 vgadev->owns = 0;
710 break;
711 }
712 }
713 bus = bus->parent;
714 }
715
716 /* Deal with VGA default device. Use first enabled one
717 * by default if arch doesn't have it's own hook
718 */
719 if (vga_default == NULL &&
720 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) {
721 vgaarb_info(&pdev->dev, "setting as boot VGA device\n");
722 vga_set_default_device(pdev);
723 }
724
725 vga_arbiter_check_bridge_sharing(vgadev);
726
727 /* Add to the list */
728 list_add_tail(&vgadev->list, &vga_list);
729 vga_count++;
730 vgaarb_info(&pdev->dev, "VGA device added: decodes=%s,owns=%s,locks=%s\n",
731 vga_iostate_to_str(vgadev->decodes),
732 vga_iostate_to_str(vgadev->owns),
733 vga_iostate_to_str(vgadev->locks));
734
735 spin_unlock_irqrestore(&vga_lock, flags);
736 return true;
737fail:
738 spin_unlock_irqrestore(&vga_lock, flags);
739 kfree(vgadev);
740 return false;
741}
742
743static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
744{
745 struct vga_device *vgadev;
746 unsigned long flags;
747 bool ret = true;
748
749 spin_lock_irqsave(&vga_lock, flags);
750 vgadev = vgadev_find(pdev);
751 if (vgadev == NULL) {
752 ret = false;
753 goto bail;
754 }
755
756 if (vga_default == pdev)
757 vga_set_default_device(NULL);
758
759 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
760 vga_decode_count--;
761
762 /* Remove entry from list */
763 list_del(&vgadev->list);
764 vga_count--;
765 /* Notify userland driver that the device is gone so it discards
766 * it's copies of the pci_dev pointer
767 */
768 vga_arb_device_card_gone(pdev);
769
770 /* Wake up all possible waiters */
771 wake_up_all(&vga_wait_queue);
772bail:
773 spin_unlock_irqrestore(&vga_lock, flags);
774 kfree(vgadev);
775 return ret;
776}
777
778/* this is called with the lock */
779static inline void vga_update_device_decodes(struct vga_device *vgadev,
780 int new_decodes)
781{
782 struct device *dev = &vgadev->pdev->dev;
783 int old_decodes, decodes_removed, decodes_unlocked;
784
785 old_decodes = vgadev->decodes;
786 decodes_removed = ~new_decodes & old_decodes;
787 decodes_unlocked = vgadev->locks & decodes_removed;
788 vgadev->decodes = new_decodes;
789
790 vgaarb_info(dev, "changed VGA decodes: olddecodes=%s,decodes=%s:owns=%s\n",
791 vga_iostate_to_str(old_decodes),
792 vga_iostate_to_str(vgadev->decodes),
793 vga_iostate_to_str(vgadev->owns));
794
795 /* if we removed locked decodes, lock count goes to zero, and release */
796 if (decodes_unlocked) {
797 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
798 vgadev->io_lock_cnt = 0;
799 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
800 vgadev->mem_lock_cnt = 0;
801 __vga_put(vgadev, decodes_unlocked);
802 }
803
804 /* change decodes counter */
805 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
806 !(new_decodes & VGA_RSRC_LEGACY_MASK))
807 vga_decode_count--;
808 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
809 new_decodes & VGA_RSRC_LEGACY_MASK)
810 vga_decode_count++;
811 vgaarb_dbg(dev, "decoding count now is: %d\n", vga_decode_count);
812}
813
814static void __vga_set_legacy_decoding(struct pci_dev *pdev,
815 unsigned int decodes,
816 bool userspace)
817{
818 struct vga_device *vgadev;
819 unsigned long flags;
820
821 decodes &= VGA_RSRC_LEGACY_MASK;
822
823 spin_lock_irqsave(&vga_lock, flags);
824 vgadev = vgadev_find(pdev);
825 if (vgadev == NULL)
826 goto bail;
827
828 /* don't let userspace futz with kernel driver decodes */
829 if (userspace && vgadev->set_vga_decode)
830 goto bail;
831
832 /* update the device decodes + counter */
833 vga_update_device_decodes(vgadev, decodes);
834
835 /* XXX if somebody is going from "doesn't decode" to "decodes" state
836 * here, additional care must be taken as we may have pending owner
837 * ship of non-legacy region ...
838 */
839bail:
840 spin_unlock_irqrestore(&vga_lock, flags);
841}
842
843void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
844{
845 __vga_set_legacy_decoding(pdev, decodes, false);
846}
847EXPORT_SYMBOL(vga_set_legacy_decoding);
848
849/**
850 * vga_client_register - register or unregister a VGA arbitration client
851 * @pdev: pci device of the VGA client
852 * @cookie: client cookie to be used in callbacks
853 * @irq_set_state: irq state change callback
854 * @set_vga_decode: vga decode change callback
855 *
856 * Clients have two callback mechanisms they can use.
857 *
858 * @irq_set_state callback: If a client can't disable its GPUs VGA
859 * resources, then we need to be able to ask it to turn off its irqs when we
860 * turn off its mem and io decoding.
861 *
862 * @set_vga_decode callback: If a client can disable its GPU VGA resource, it
863 * will get a callback from this to set the encode/decode state.
864 *
865 * Rationale: we cannot disable VGA decode resources unconditionally some single
866 * GPU laptops seem to require ACPI or BIOS access to the VGA registers to
867 * control things like backlights etc. Hopefully newer multi-GPU laptops do
868 * something saner, and desktops won't have any special ACPI for this. The
869 * driver will get a callback when VGA arbitration is first used by userspace
870 * since some older X servers have issues.
871 *
872 * This function does not check whether a client for @pdev has been registered
873 * already.
874 *
875 * To unregister just call this function with @irq_set_state and @set_vga_decode
876 * both set to NULL for the same @pdev as originally used to register them.
877 *
878 * Returns: 0 on success, -1 on failure
879 */
880int vga_client_register(struct pci_dev *pdev, void *cookie,
881 void (*irq_set_state)(void *cookie, bool state),
882 unsigned int (*set_vga_decode)(void *cookie,
883 bool decode))
884{
885 int ret = -ENODEV;
886 struct vga_device *vgadev;
887 unsigned long flags;
888
889 spin_lock_irqsave(&vga_lock, flags);
890 vgadev = vgadev_find(pdev);
891 if (!vgadev)
892 goto bail;
893
894 vgadev->irq_set_state = irq_set_state;
895 vgadev->set_vga_decode = set_vga_decode;
896 vgadev->cookie = cookie;
897 ret = 0;
898
899bail:
900 spin_unlock_irqrestore(&vga_lock, flags);
901 return ret;
902
903}
904EXPORT_SYMBOL(vga_client_register);
905
906/*
907 * Char driver implementation
908 *
909 * Semantics is:
910 *
911 * open : open user instance of the arbitrer. by default, it's
912 * attached to the default VGA device of the system.
913 *
914 * close : close user instance, release locks
915 *
916 * read : return a string indicating the status of the target.
917 * an IO state string is of the form {io,mem,io+mem,none},
918 * mc and ic are respectively mem and io lock counts (for
919 * debugging/diagnostic only). "decodes" indicate what the
920 * card currently decodes, "owns" indicates what is currently
921 * enabled on it, and "locks" indicates what is locked by this
922 * card. If the card is unplugged, we get "invalid" then for
923 * card_ID and an -ENODEV error is returned for any command
924 * until a new card is targeted
925 *
926 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
927 *
928 * write : write a command to the arbiter. List of commands is:
929 *
930 * target <card_ID> : switch target to card <card_ID> (see below)
931 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
932 * trylock <io_state> : non-blocking acquire locks on target
933 * unlock <io_state> : release locks on target
934 * unlock all : release all locks on target held by this user
935 * decodes <io_state> : set the legacy decoding attributes for the card
936 *
937 * poll : event if something change on any card (not just the target)
938 *
939 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
940 * to go back to the system default card (TODO: not implemented yet).
941 * Currently, only PCI is supported as a prefix, but the userland API may
942 * support other bus types in the future, even if the current kernel
943 * implementation doesn't.
944 *
945 * Note about locks:
946 *
947 * The driver keeps track of which user has what locks on which card. It
948 * supports stacking, like the kernel one. This complexifies the implementation
949 * a bit, but makes the arbiter more tolerant to userspace problems and able
950 * to properly cleanup in all cases when a process dies.
951 * Currently, a max of 16 cards simultaneously can have locks issued from
952 * userspace for a given user (file descriptor instance) of the arbiter.
953 *
954 * If the device is hot-unplugged, there is a hook inside the module to notify
955 * they being added/removed in the system and automatically added/removed in
956 * the arbiter.
957 */
958
959#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
960#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
961
962/*
963 * Each user has an array of these, tracking which cards have locks
964 */
965struct vga_arb_user_card {
966 struct pci_dev *pdev;
967 unsigned int mem_cnt;
968 unsigned int io_cnt;
969};
970
971struct vga_arb_private {
972 struct list_head list;
973 struct pci_dev *target;
974 struct vga_arb_user_card cards[MAX_USER_CARDS];
975 spinlock_t lock;
976};
977
978static LIST_HEAD(vga_user_list);
979static DEFINE_SPINLOCK(vga_user_lock);
980
981
982/*
983 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
984 * returns the respective values. If the string is not in this format,
985 * it returns 0.
986 */
987static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
988 unsigned int *bus, unsigned int *devfn)
989{
990 int n;
991 unsigned int slot, func;
992
993
994 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
995 if (n != 4)
996 return 0;
997
998 *devfn = PCI_DEVFN(slot, func);
999
1000 return 1;
1001}
1002
1003static ssize_t vga_arb_read(struct file *file, char __user *buf,
1004 size_t count, loff_t *ppos)
1005{
1006 struct vga_arb_private *priv = file->private_data;
1007 struct vga_device *vgadev;
1008 struct pci_dev *pdev;
1009 unsigned long flags;
1010 size_t len;
1011 int rc;
1012 char *lbuf;
1013
1014 lbuf = kmalloc(1024, GFP_KERNEL);
1015 if (lbuf == NULL)
1016 return -ENOMEM;
1017
1018 /* Shields against vga_arb_device_card_gone (pci_dev going
1019 * away), and allows access to vga list
1020 */
1021 spin_lock_irqsave(&vga_lock, flags);
1022
1023 /* If we are targeting the default, use it */
1024 pdev = priv->target;
1025 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
1026 spin_unlock_irqrestore(&vga_lock, flags);
1027 len = sprintf(lbuf, "invalid");
1028 goto done;
1029 }
1030
1031 /* Find card vgadev structure */
1032 vgadev = vgadev_find(pdev);
1033 if (vgadev == NULL) {
1034 /* Wow, it's not in the list, that shouldn't happen,
1035 * let's fix us up and return invalid card
1036 */
1037 if (pdev == priv->target)
1038 vga_arb_device_card_gone(pdev);
1039 spin_unlock_irqrestore(&vga_lock, flags);
1040 len = sprintf(lbuf, "invalid");
1041 goto done;
1042 }
1043
1044 /* Fill the buffer with infos */
1045 len = snprintf(lbuf, 1024,
1046 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
1047 vga_decode_count, pci_name(pdev),
1048 vga_iostate_to_str(vgadev->decodes),
1049 vga_iostate_to_str(vgadev->owns),
1050 vga_iostate_to_str(vgadev->locks),
1051 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
1052
1053 spin_unlock_irqrestore(&vga_lock, flags);
1054done:
1055
1056 /* Copy that to user */
1057 if (len > count)
1058 len = count;
1059 rc = copy_to_user(buf, lbuf, len);
1060 kfree(lbuf);
1061 if (rc)
1062 return -EFAULT;
1063 return len;
1064}
1065
1066/*
1067 * TODO: To avoid parsing inside kernel and to improve the speed we may
1068 * consider use ioctl here
1069 */
1070static ssize_t vga_arb_write(struct file *file, const char __user *buf,
1071 size_t count, loff_t *ppos)
1072{
1073 struct vga_arb_private *priv = file->private_data;
1074 struct vga_arb_user_card *uc = NULL;
1075 struct pci_dev *pdev;
1076
1077 unsigned int io_state;
1078
1079 char kbuf[64], *curr_pos;
1080 size_t remaining = count;
1081
1082 int ret_val;
1083 int i;
1084
1085 if (count >= sizeof(kbuf))
1086 return -EINVAL;
1087 if (copy_from_user(kbuf, buf, count))
1088 return -EFAULT;
1089 curr_pos = kbuf;
1090 kbuf[count] = '\0'; /* Just to make sure... */
1091
1092 if (strncmp(curr_pos, "lock ", 5) == 0) {
1093 curr_pos += 5;
1094 remaining -= 5;
1095
1096 pr_debug("client 0x%p called 'lock'\n", priv);
1097
1098 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1099 ret_val = -EPROTO;
1100 goto done;
1101 }
1102 if (io_state == VGA_RSRC_NONE) {
1103 ret_val = -EPROTO;
1104 goto done;
1105 }
1106
1107 pdev = priv->target;
1108 if (priv->target == NULL) {
1109 ret_val = -ENODEV;
1110 goto done;
1111 }
1112
1113 vga_get_uninterruptible(pdev, io_state);
1114
1115 /* Update the client's locks lists... */
1116 for (i = 0; i < MAX_USER_CARDS; i++) {
1117 if (priv->cards[i].pdev == pdev) {
1118 if (io_state & VGA_RSRC_LEGACY_IO)
1119 priv->cards[i].io_cnt++;
1120 if (io_state & VGA_RSRC_LEGACY_MEM)
1121 priv->cards[i].mem_cnt++;
1122 break;
1123 }
1124 }
1125
1126 ret_val = count;
1127 goto done;
1128 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
1129 curr_pos += 7;
1130 remaining -= 7;
1131
1132 pr_debug("client 0x%p called 'unlock'\n", priv);
1133
1134 if (strncmp(curr_pos, "all", 3) == 0)
1135 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
1136 else {
1137 if (!vga_str_to_iostate
1138 (curr_pos, remaining, &io_state)) {
1139 ret_val = -EPROTO;
1140 goto done;
1141 }
1142 /* TODO: Add this?
1143 if (io_state == VGA_RSRC_NONE) {
1144 ret_val = -EPROTO;
1145 goto done;
1146 }
1147 */
1148 }
1149
1150 pdev = priv->target;
1151 if (priv->target == NULL) {
1152 ret_val = -ENODEV;
1153 goto done;
1154 }
1155 for (i = 0; i < MAX_USER_CARDS; i++) {
1156 if (priv->cards[i].pdev == pdev)
1157 uc = &priv->cards[i];
1158 }
1159
1160 if (!uc) {
1161 ret_val = -EINVAL;
1162 goto done;
1163 }
1164
1165 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1166 ret_val = -EINVAL;
1167 goto done;
1168 }
1169
1170 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1171 ret_val = -EINVAL;
1172 goto done;
1173 }
1174
1175 vga_put(pdev, io_state);
1176
1177 if (io_state & VGA_RSRC_LEGACY_IO)
1178 uc->io_cnt--;
1179 if (io_state & VGA_RSRC_LEGACY_MEM)
1180 uc->mem_cnt--;
1181
1182 ret_val = count;
1183 goto done;
1184 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1185 curr_pos += 8;
1186 remaining -= 8;
1187
1188 pr_debug("client 0x%p called 'trylock'\n", priv);
1189
1190 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1191 ret_val = -EPROTO;
1192 goto done;
1193 }
1194 /* TODO: Add this?
1195 if (io_state == VGA_RSRC_NONE) {
1196 ret_val = -EPROTO;
1197 goto done;
1198 }
1199 */
1200
1201 pdev = priv->target;
1202 if (priv->target == NULL) {
1203 ret_val = -ENODEV;
1204 goto done;
1205 }
1206
1207 if (vga_tryget(pdev, io_state)) {
1208 /* Update the client's locks lists... */
1209 for (i = 0; i < MAX_USER_CARDS; i++) {
1210 if (priv->cards[i].pdev == pdev) {
1211 if (io_state & VGA_RSRC_LEGACY_IO)
1212 priv->cards[i].io_cnt++;
1213 if (io_state & VGA_RSRC_LEGACY_MEM)
1214 priv->cards[i].mem_cnt++;
1215 break;
1216 }
1217 }
1218 ret_val = count;
1219 goto done;
1220 } else {
1221 ret_val = -EBUSY;
1222 goto done;
1223 }
1224
1225 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1226 unsigned int domain, bus, devfn;
1227 struct vga_device *vgadev;
1228
1229 curr_pos += 7;
1230 remaining -= 7;
1231 pr_debug("client 0x%p called 'target'\n", priv);
1232 /* if target is default */
1233 if (!strncmp(curr_pos, "default", 7))
1234 pdev = pci_dev_get(vga_default_device());
1235 else {
1236 if (!vga_pci_str_to_vars(curr_pos, remaining,
1237 &domain, &bus, &devfn)) {
1238 ret_val = -EPROTO;
1239 goto done;
1240 }
1241 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1242 if (!pdev) {
1243 pr_debug("invalid PCI address %04x:%02x:%02x.%x\n",
1244 domain, bus, PCI_SLOT(devfn),
1245 PCI_FUNC(devfn));
1246 ret_val = -ENODEV;
1247 goto done;
1248 }
1249
1250 pr_debug("%s ==> %04x:%02x:%02x.%x pdev %p\n", curr_pos,
1251 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn),
1252 pdev);
1253 }
1254
1255 vgadev = vgadev_find(pdev);
1256 pr_debug("vgadev %p\n", vgadev);
1257 if (vgadev == NULL) {
1258 if (pdev) {
1259 vgaarb_dbg(&pdev->dev, "not a VGA device\n");
1260 pci_dev_put(pdev);
1261 }
1262
1263 ret_val = -ENODEV;
1264 goto done;
1265 }
1266
1267 priv->target = pdev;
1268 for (i = 0; i < MAX_USER_CARDS; i++) {
1269 if (priv->cards[i].pdev == pdev)
1270 break;
1271 if (priv->cards[i].pdev == NULL) {
1272 priv->cards[i].pdev = pdev;
1273 priv->cards[i].io_cnt = 0;
1274 priv->cards[i].mem_cnt = 0;
1275 break;
1276 }
1277 }
1278 if (i == MAX_USER_CARDS) {
1279 vgaarb_dbg(&pdev->dev, "maximum user cards (%d) number reached, ignoring this one!\n",
1280 MAX_USER_CARDS);
1281 pci_dev_put(pdev);
1282 /* XXX: which value to return? */
1283 ret_val = -ENOMEM;
1284 goto done;
1285 }
1286
1287 ret_val = count;
1288 pci_dev_put(pdev);
1289 goto done;
1290
1291
1292 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1293 curr_pos += 8;
1294 remaining -= 8;
1295 pr_debug("client 0x%p called 'decodes'\n", priv);
1296
1297 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1298 ret_val = -EPROTO;
1299 goto done;
1300 }
1301 pdev = priv->target;
1302 if (priv->target == NULL) {
1303 ret_val = -ENODEV;
1304 goto done;
1305 }
1306
1307 __vga_set_legacy_decoding(pdev, io_state, true);
1308 ret_val = count;
1309 goto done;
1310 }
1311 /* If we got here, the message written is not part of the protocol! */
1312 return -EPROTO;
1313
1314done:
1315 return ret_val;
1316}
1317
1318static __poll_t vga_arb_fpoll(struct file *file, poll_table *wait)
1319{
1320 pr_debug("%s\n", __func__);
1321
1322 poll_wait(file, &vga_wait_queue, wait);
1323 return EPOLLIN;
1324}
1325
1326static int vga_arb_open(struct inode *inode, struct file *file)
1327{
1328 struct vga_arb_private *priv;
1329 unsigned long flags;
1330
1331 pr_debug("%s\n", __func__);
1332
1333 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1334 if (priv == NULL)
1335 return -ENOMEM;
1336 spin_lock_init(&priv->lock);
1337 file->private_data = priv;
1338
1339 spin_lock_irqsave(&vga_user_lock, flags);
1340 list_add(&priv->list, &vga_user_list);
1341 spin_unlock_irqrestore(&vga_user_lock, flags);
1342
1343 /* Set the client' lists of locks */
1344 priv->target = vga_default_device(); /* Maybe this is still null! */
1345 priv->cards[0].pdev = priv->target;
1346 priv->cards[0].io_cnt = 0;
1347 priv->cards[0].mem_cnt = 0;
1348
1349
1350 return 0;
1351}
1352
1353static int vga_arb_release(struct inode *inode, struct file *file)
1354{
1355 struct vga_arb_private *priv = file->private_data;
1356 struct vga_arb_user_card *uc;
1357 unsigned long flags;
1358 int i;
1359
1360 pr_debug("%s\n", __func__);
1361
1362 spin_lock_irqsave(&vga_user_lock, flags);
1363 list_del(&priv->list);
1364 for (i = 0; i < MAX_USER_CARDS; i++) {
1365 uc = &priv->cards[i];
1366 if (uc->pdev == NULL)
1367 continue;
1368 vgaarb_dbg(&uc->pdev->dev, "uc->io_cnt == %d, uc->mem_cnt == %d\n",
1369 uc->io_cnt, uc->mem_cnt);
1370 while (uc->io_cnt--)
1371 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1372 while (uc->mem_cnt--)
1373 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1374 }
1375 spin_unlock_irqrestore(&vga_user_lock, flags);
1376
1377 kfree(priv);
1378
1379 return 0;
1380}
1381
1382static void vga_arb_device_card_gone(struct pci_dev *pdev)
1383{
1384}
1385
1386/*
1387 * callback any registered clients to let them know we have a
1388 * change in VGA cards
1389 */
1390static void vga_arbiter_notify_clients(void)
1391{
1392 struct vga_device *vgadev;
1393 unsigned long flags;
1394 uint32_t new_decodes;
1395 bool new_state;
1396
1397 if (!vga_arbiter_used)
1398 return;
1399
1400 spin_lock_irqsave(&vga_lock, flags);
1401 list_for_each_entry(vgadev, &vga_list, list) {
1402 if (vga_count > 1)
1403 new_state = false;
1404 else
1405 new_state = true;
1406 if (vgadev->set_vga_decode) {
1407 new_decodes = vgadev->set_vga_decode(vgadev->cookie,
1408 new_state);
1409 vga_update_device_decodes(vgadev, new_decodes);
1410 }
1411 }
1412 spin_unlock_irqrestore(&vga_lock, flags);
1413}
1414
1415static int pci_notify(struct notifier_block *nb, unsigned long action,
1416 void *data)
1417{
1418 struct device *dev = data;
1419 struct pci_dev *pdev = to_pci_dev(dev);
1420 bool notify = false;
1421
1422 vgaarb_dbg(dev, "%s\n", __func__);
1423
1424 /* For now we're only intereted in devices added and removed. I didn't
1425 * test this thing here, so someone needs to double check for the
1426 * cases of hotplugable vga cards. */
1427 if (action == BUS_NOTIFY_ADD_DEVICE)
1428 notify = vga_arbiter_add_pci_device(pdev);
1429 else if (action == BUS_NOTIFY_DEL_DEVICE)
1430 notify = vga_arbiter_del_pci_device(pdev);
1431
1432 if (notify)
1433 vga_arbiter_notify_clients();
1434 return 0;
1435}
1436
1437static struct notifier_block pci_notifier = {
1438 .notifier_call = pci_notify,
1439};
1440
1441static const struct file_operations vga_arb_device_fops = {
1442 .read = vga_arb_read,
1443 .write = vga_arb_write,
1444 .poll = vga_arb_fpoll,
1445 .open = vga_arb_open,
1446 .release = vga_arb_release,
1447 .llseek = noop_llseek,
1448};
1449
1450static struct miscdevice vga_arb_device = {
1451 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1452};
1453
1454#if defined(CONFIG_ACPI)
1455static bool vga_arb_integrated_gpu(struct device *dev)
1456{
1457 struct acpi_device *adev = ACPI_COMPANION(dev);
1458
1459 return adev && !strcmp(acpi_device_hid(adev), ACPI_VIDEO_HID);
1460}
1461#else
1462static bool vga_arb_integrated_gpu(struct device *dev)
1463{
1464 return false;
1465}
1466#endif
1467
1468static void __init vga_arb_select_default_device(void)
1469{
1470 struct pci_dev *pdev, *found = NULL;
1471 struct vga_device *vgadev;
1472
1473#if defined(CONFIG_X86) || defined(CONFIG_IA64)
1474 u64 base = screen_info.lfb_base;
1475 u64 size = screen_info.lfb_size;
1476 u64 limit;
1477 resource_size_t start, end;
1478 unsigned long flags;
1479 int i;
1480
1481 if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
1482 base |= (u64)screen_info.ext_lfb_base << 32;
1483
1484 limit = base + size;
1485
1486 list_for_each_entry(vgadev, &vga_list, list) {
1487 struct device *dev = &vgadev->pdev->dev;
1488 /*
1489 * Override vga_arbiter_add_pci_device()'s I/O based detection
1490 * as it may take the wrong device (e.g. on Apple system under
1491 * EFI).
1492 *
1493 * Select the device owning the boot framebuffer if there is
1494 * one.
1495 */
1496
1497 /* Does firmware framebuffer belong to us? */
1498 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
1499 flags = pci_resource_flags(vgadev->pdev, i);
1500
1501 if ((flags & IORESOURCE_MEM) == 0)
1502 continue;
1503
1504 start = pci_resource_start(vgadev->pdev, i);
1505 end = pci_resource_end(vgadev->pdev, i);
1506
1507 if (!start || !end)
1508 continue;
1509
1510 if (base < start || limit >= end)
1511 continue;
1512
1513 if (!vga_default_device())
1514 vgaarb_info(dev, "setting as boot device\n");
1515 else if (vgadev->pdev != vga_default_device())
1516 vgaarb_info(dev, "overriding boot device\n");
1517 vga_set_default_device(vgadev->pdev);
1518 }
1519 }
1520#endif
1521
1522 if (!vga_default_device()) {
1523 list_for_each_entry_reverse(vgadev, &vga_list, list) {
1524 struct device *dev = &vgadev->pdev->dev;
1525 u16 cmd;
1526
1527 pdev = vgadev->pdev;
1528 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
1529 if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
1530 found = pdev;
1531 if (vga_arb_integrated_gpu(dev))
1532 break;
1533 }
1534 }
1535 }
1536
1537 if (found) {
1538 vgaarb_info(&found->dev, "setting as boot device (VGA legacy resources not available)\n");
1539 vga_set_default_device(found);
1540 return;
1541 }
1542
1543 if (!vga_default_device()) {
1544 vgadev = list_first_entry_or_null(&vga_list,
1545 struct vga_device, list);
1546 if (vgadev) {
1547 struct device *dev = &vgadev->pdev->dev;
1548 vgaarb_info(dev, "setting as boot device (VGA legacy resources not available)\n");
1549 vga_set_default_device(vgadev->pdev);
1550 }
1551 }
1552}
1553
1554static int __init vga_arb_device_init(void)
1555{
1556 int rc;
1557 struct pci_dev *pdev;
1558 struct vga_device *vgadev;
1559
1560 rc = misc_register(&vga_arb_device);
1561 if (rc < 0)
1562 pr_err("error %d registering device\n", rc);
1563
1564 bus_register_notifier(&pci_bus_type, &pci_notifier);
1565
1566 /* We add all PCI devices satisfying VGA class in the arbiter by
1567 * default */
1568 pdev = NULL;
1569 while ((pdev =
1570 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1571 PCI_ANY_ID, pdev)) != NULL)
1572 vga_arbiter_add_pci_device(pdev);
1573
1574 list_for_each_entry(vgadev, &vga_list, list) {
1575 struct device *dev = &vgadev->pdev->dev;
1576
1577 if (vgadev->bridge_has_one_vga)
1578 vgaarb_info(dev, "bridge control possible\n");
1579 else
1580 vgaarb_info(dev, "no bridge control possible\n");
1581 }
1582
1583 vga_arb_select_default_device();
1584
1585 pr_info("loaded\n");
1586 return rc;
1587}
1588subsys_initcall(vga_arb_device_init);