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