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