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