Loading...
Note: File does not exist in v6.13.7.
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);