dm thin metadata: fix __udivdi3 undefined on 32-bit
[linux/fpc-iii.git] / drivers / gpu / vga / vgaarb.c
blob9abcaa53bd25a4149e850562628bdc17e81161ed
1 /*
2 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/vgaarbiter.txt
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>
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:
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.
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.
32 #define pr_fmt(fmt) "vgaarb: " fmt
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>
48 #include <linux/uaccess.h>
50 #include <linux/vgaarb.h>
52 static void vga_arbiter_notify_clients(void);
54 * We keep a list of all vga devices in the system to speed
55 * up the various operations of the arbiter
57 struct 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);
74 static LIST_HEAD(vga_list);
75 static int vga_count, vga_decode_count;
76 static bool vga_arbiter_used;
77 static DEFINE_SPINLOCK(vga_lock);
78 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
81 static const char *vga_iostate_to_str(unsigned int iostate)
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";
93 return "none";
96 static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
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;
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;
113 both:
114 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
115 return 1;
118 /* this is only used a cookie - it should not be dereferenced */
119 static struct pci_dev *vga_default;
121 static void vga_arb_device_card_gone(struct pci_dev *pdev);
123 /* Find somebody in our list */
124 static struct vga_device *vgadev_find(struct pci_dev *pdev)
126 struct vga_device *vgadev;
128 list_for_each_entry(vgadev, &vga_list, list)
129 if (pdev == vgadev->pdev)
130 return vgadev;
131 return NULL;
134 /* Returns the default VGA device (vgacon's babe) */
135 struct pci_dev *vga_default_device(void)
137 return vga_default;
139 EXPORT_SYMBOL_GPL(vga_default_device);
141 void vga_set_default_device(struct pci_dev *pdev)
143 if (vga_default == pdev)
144 return;
146 pci_dev_put(vga_default);
147 vga_default = pci_dev_get(pdev);
150 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
152 if (vgadev->irq_set_state)
153 vgadev->irq_set_state(vgadev->cookie, state);
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 */
160 static void vga_check_first_use(void)
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();
171 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
172 unsigned int rsrc)
174 unsigned int wants, legacy_wants, match;
175 struct vga_device *conflict;
176 unsigned int pci_bits;
177 u32 flags = 0;
179 /* Account for "normal" resources to lock. If we decode the legacy,
180 * counterpart, we need to request it as well
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;
189 pr_debug("%s: %d\n", __func__, rsrc);
190 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
192 /* Check what resources we need to acquire */
193 wants = rsrc & ~vgadev->owns;
195 /* We already own everything, just mark locked & bye bye */
196 if (wants == 0)
197 goto lock_them;
199 /* We don't need to request a legacy resource, we just enable
200 * appropriate decoding and go
202 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
203 if (legacy_wants == 0)
204 goto enable_them;
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;
211 /* Don't conflict with myself */
212 if (vgadev == conflict)
213 continue;
215 /* Check if the architecture allows a conflict between those
216 * 2 devices or if they are on separate domains
218 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
219 continue;
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
227 if (vgadev->pdev->bus != conflict->pdev->bus) {
228 change_bridge = 1;
229 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
232 /* Check if the guy has a lock on the resource. If he does,
233 * return the conflicting entry
235 if (conflict->locks & lwants)
236 return conflict;
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.
242 match = lwants & conflict->owns;
243 if (!match)
244 continue;
246 /* looks like he doesn't have a lock, we can steal
247 * them from him
250 flags = 0;
251 pci_bits = 0;
253 /* If we can't control legacy resources via the bridge, we
254 * also need to disable normal decoding.
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;
262 if (pci_bits) {
263 vga_irq_set_state(conflict, false);
264 flags |= PCI_VGA_STATE_CHANGE_DECODES;
268 if (change_bridge)
269 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
271 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
272 conflict->owns &= ~match;
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;
281 enable_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".
287 flags = 0;
288 pci_bits = 0;
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;
297 if (wants & VGA_RSRC_LEGACY_MASK)
298 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
300 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
302 if (!vgadev->bridge_has_one_vga)
303 vga_irq_set_state(vgadev, true);
305 vgadev->owns |= wants;
306 lock_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++;
317 return NULL;
320 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
322 unsigned int old_locks = vgadev->locks;
324 pr_debug("%s\n", __func__);
326 /* Update our counters, and account for equivalent legacy resources
327 * if we decode them
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;
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;
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--;
344 /* Just clear lock bits, we do lazy operations so we don't really
345 * have to bother about anything else at this point
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;
352 /* Kick the wait queue in case somebody was waiting if we actually
353 * released something
355 if (old_locks != vgadev->locks)
356 wake_up_all(&vga_wait_queue);
359 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
361 struct vga_device *vgadev, *conflict;
362 unsigned long flags;
363 wait_queue_t wait;
364 int rc = 0;
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;
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;
381 conflict = __vga_tryget(vgadev, rsrc);
382 spin_unlock_irqrestore(&vga_lock, flags);
383 if (conflict == NULL)
384 break;
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
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;
404 schedule();
405 remove_wait_queue(&vga_wait_queue, &wait);
407 return rc;
409 EXPORT_SYMBOL(vga_get);
411 int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
413 struct vga_device *vgadev;
414 unsigned long flags;
415 int rc = 0;
417 vga_check_first_use();
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;
430 if (__vga_tryget(vgadev, rsrc))
431 rc = -EBUSY;
432 bail:
433 spin_unlock_irqrestore(&vga_lock, flags);
434 return rc;
436 EXPORT_SYMBOL(vga_tryget);
438 void vga_put(struct pci_dev *pdev, unsigned int rsrc)
440 struct vga_device *vgadev;
441 unsigned long flags;
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);
453 bail:
454 spin_unlock_irqrestore(&vga_lock, flags);
456 EXPORT_SYMBOL(vga_put);
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.
467 static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
469 struct vga_device *same_bridge_vgadev;
470 struct pci_bus *new_bus, *bus;
471 struct pci_dev *new_bridge, *bridge;
473 vgadev->bridge_has_one_vga = true;
475 if (list_empty(&vga_list))
476 return;
478 /* okay iterate the new devices bridge hierarachy */
479 new_bus = vgadev->pdev->bus;
480 while (new_bus) {
481 new_bridge = new_bus->self;
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;
488 /* see if the share a bridge with this device */
489 if (new_bridge == bridge) {
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.
495 same_bridge_vgadev->bridge_has_one_vga = false;
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
504 while (bus) {
505 bridge = bus->self;
507 if (bridge && bridge == vgadev->pdev->bus->self)
508 vgadev->bridge_has_one_vga = false;
510 bus = bus->parent;
513 new_bus = new_bus->parent;
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.
523 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
525 struct vga_device *vgadev;
526 unsigned long flags;
527 struct pci_bus *bus;
528 struct pci_dev *bridge;
529 u16 cmd;
531 /* Only deal with VGA class devices */
532 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
533 return false;
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");
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.
543 return false;
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;
552 vgadev->pdev = pdev;
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;
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
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;
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;
576 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &l);
577 if (!(l & PCI_BRIDGE_CTL_VGA)) {
578 vgadev->owns = 0;
579 break;
582 bus = bus->parent;
585 /* Deal with VGA default device. Use first enabled one
586 * by default if arch doesn't have it's own hook
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);
594 vga_arbiter_check_bridge_sharing(vgadev);
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));
605 spin_unlock_irqrestore(&vga_lock, flags);
606 return true;
607 fail:
608 spin_unlock_irqrestore(&vga_lock, flags);
609 kfree(vgadev);
610 return false;
613 static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
615 struct vga_device *vgadev;
616 unsigned long flags;
617 bool ret = true;
619 spin_lock_irqsave(&vga_lock, flags);
620 vgadev = vgadev_find(pdev);
621 if (vgadev == NULL) {
622 ret = false;
623 goto bail;
626 if (vga_default == pdev)
627 vga_set_default_device(NULL);
629 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
630 vga_decode_count--;
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
638 vga_arb_device_card_gone(pdev);
640 /* Wake up all possible waiters */
641 wake_up_all(&vga_wait_queue);
642 bail:
643 spin_unlock_irqrestore(&vga_lock, flags);
644 kfree(vgadev);
645 return ret;
648 /* this is called with the lock */
649 static inline void vga_update_device_decodes(struct vga_device *vgadev,
650 int new_decodes)
652 int old_decodes, decodes_removed, decodes_unlocked;
654 old_decodes = vgadev->decodes;
655 decodes_removed = ~new_decodes & old_decodes;
656 decodes_unlocked = vgadev->locks & decodes_removed;
657 vgadev->decodes = new_decodes;
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));
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);
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);
684 static void __vga_set_legacy_decoding(struct pci_dev *pdev,
685 unsigned int decodes,
686 bool userspace)
688 struct vga_device *vgadev;
689 unsigned long flags;
691 decodes &= VGA_RSRC_LEGACY_MASK;
693 spin_lock_irqsave(&vga_lock, flags);
694 vgadev = vgadev_find(pdev);
695 if (vgadev == NULL)
696 goto bail;
698 /* don't let userspace futz with kernel driver decodes */
699 if (userspace && vgadev->set_vga_decode)
700 goto bail;
702 /* update the device decodes + counter */
703 vga_update_device_decodes(vgadev, decodes);
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 ...
709 bail:
710 spin_unlock_irqrestore(&vga_lock, flags);
713 void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
715 __vga_set_legacy_decoding(pdev, decodes, false);
717 EXPORT_SYMBOL(vga_set_legacy_decoding);
719 /* call with NULL to unregister */
720 int 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))
725 int ret = -ENODEV;
726 struct vga_device *vgadev;
727 unsigned long flags;
729 spin_lock_irqsave(&vga_lock, flags);
730 vgadev = vgadev_find(pdev);
731 if (!vgadev)
732 goto bail;
734 vgadev->irq_set_state = irq_set_state;
735 vgadev->set_vga_decode = set_vga_decode;
736 vgadev->cookie = cookie;
737 ret = 0;
739 bail:
740 spin_unlock_irqrestore(&vga_lock, flags);
741 return ret;
744 EXPORT_SYMBOL(vga_client_register);
747 * Char driver implementation
749 * Semantics is:
751 * open : open user instance of the arbitrer. by default, it's
752 * attached to the default VGA device of the system.
754 * close : close user instance, release locks
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
766 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
768 * write : write a command to the arbiter. List of commands is:
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
777 * poll : event if something change on any card (not just the target)
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.
785 * Note about locks:
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.
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.
799 #define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
800 #define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
803 * Each user has an array of these, tracking which cards have locks
805 struct vga_arb_user_card {
806 struct pci_dev *pdev;
807 unsigned int mem_cnt;
808 unsigned int io_cnt;
811 struct 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;
818 static LIST_HEAD(vga_user_list);
819 static DEFINE_SPINLOCK(vga_user_lock);
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.
827 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
828 unsigned int *bus, unsigned int *devfn)
830 int n;
831 unsigned int slot, func;
834 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
835 if (n != 4)
836 return 0;
838 *devfn = PCI_DEVFN(slot, func);
840 return 1;
843 static ssize_t vga_arb_read(struct file *file, char __user *buf,
844 size_t count, loff_t *ppos)
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;
854 lbuf = kmalloc(1024, GFP_KERNEL);
855 if (lbuf == NULL)
856 return -ENOMEM;
858 /* Shields against vga_arb_device_card_gone (pci_dev going
859 * away), and allows access to vga list
861 spin_lock_irqsave(&vga_lock, flags);
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;
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
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;
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);
893 spin_unlock_irqrestore(&vga_lock, flags);
894 done:
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;
907 * TODO: To avoid parsing inside kernel and to improve the speed we may
908 * consider use ioctl here
910 static ssize_t vga_arb_write(struct file *file, const char __user *buf,
911 size_t count, loff_t *ppos)
913 struct vga_arb_private *priv = file->private_data;
914 struct vga_arb_user_card *uc = NULL;
915 struct pci_dev *pdev;
917 unsigned int io_state;
919 char *kbuf, *curr_pos;
920 size_t remaining = count;
922 int ret_val;
923 int i;
926 kbuf = kmalloc(count + 1, GFP_KERNEL);
927 if (!kbuf)
928 return -ENOMEM;
930 if (copy_from_user(kbuf, buf, count)) {
931 kfree(kbuf);
932 return -EFAULT;
934 curr_pos = kbuf;
935 kbuf[count] = '\0'; /* Just to make sure... */
937 if (strncmp(curr_pos, "lock ", 5) == 0) {
938 curr_pos += 5;
939 remaining -= 5;
941 pr_debug("client 0x%p called 'lock'\n", priv);
943 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
944 ret_val = -EPROTO;
945 goto done;
947 if (io_state == VGA_RSRC_NONE) {
948 ret_val = -EPROTO;
949 goto done;
952 pdev = priv->target;
953 if (priv->target == NULL) {
954 ret_val = -ENODEV;
955 goto done;
958 vga_get_uninterruptible(pdev, io_state);
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;
971 ret_val = count;
972 goto done;
973 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
974 curr_pos += 7;
975 remaining -= 7;
977 pr_debug("client 0x%p called 'unlock'\n", priv);
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;
987 /* TODO: Add this?
988 if (io_state == VGA_RSRC_NONE) {
989 ret_val = -EPROTO;
990 goto done;
995 pdev = priv->target;
996 if (priv->target == NULL) {
997 ret_val = -ENODEV;
998 goto done;
1000 for (i = 0; i < MAX_USER_CARDS; i++) {
1001 if (priv->cards[i].pdev == pdev)
1002 uc = &priv->cards[i];
1005 if (!uc) {
1006 ret_val = -EINVAL;
1007 goto done;
1010 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1011 ret_val = -EINVAL;
1012 goto done;
1015 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1016 ret_val = -EINVAL;
1017 goto done;
1020 vga_put(pdev, io_state);
1022 if (io_state & VGA_RSRC_LEGACY_IO)
1023 uc->io_cnt--;
1024 if (io_state & VGA_RSRC_LEGACY_MEM)
1025 uc->mem_cnt--;
1027 ret_val = count;
1028 goto done;
1029 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1030 curr_pos += 8;
1031 remaining -= 8;
1033 pr_debug("client 0x%p called 'trylock'\n", priv);
1035 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1036 ret_val = -EPROTO;
1037 goto done;
1039 /* TODO: Add this?
1040 if (io_state == VGA_RSRC_NONE) {
1041 ret_val = -EPROTO;
1042 goto done;
1046 pdev = priv->target;
1047 if (priv->target == NULL) {
1048 ret_val = -ENODEV;
1049 goto done;
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;
1063 ret_val = count;
1064 goto done;
1065 } else {
1066 ret_val = -EBUSY;
1067 goto done;
1070 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1071 unsigned int domain, bus, devfn;
1072 struct vga_device *vgadev;
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;
1086 pr_debug("%s ==> %x:%x:%x.%x\n", curr_pos,
1087 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
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;
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);
1107 ret_val = -ENODEV;
1108 goto done;
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;
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;
1131 ret_val = count;
1132 pci_dev_put(pdev);
1133 goto done;
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);
1141 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1142 ret_val = -EPROTO;
1143 goto done;
1145 pdev = priv->target;
1146 if (priv->target == NULL) {
1147 ret_val = -ENODEV;
1148 goto done;
1151 __vga_set_legacy_decoding(pdev, io_state, true);
1152 ret_val = count;
1153 goto done;
1155 /* If we got here, the message written is not part of the protocol! */
1156 kfree(kbuf);
1157 return -EPROTO;
1159 done:
1160 kfree(kbuf);
1161 return ret_val;
1164 static unsigned int vga_arb_fpoll(struct file *file, poll_table *wait)
1166 struct vga_arb_private *priv = file->private_data;
1168 pr_debug("%s\n", __func__);
1170 if (priv == NULL)
1171 return -ENODEV;
1172 poll_wait(file, &vga_wait_queue, wait);
1173 return POLLIN;
1176 static int vga_arb_open(struct inode *inode, struct file *file)
1178 struct vga_arb_private *priv;
1179 unsigned long flags;
1181 pr_debug("%s\n", __func__);
1183 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1184 if (priv == NULL)
1185 return -ENOMEM;
1186 spin_lock_init(&priv->lock);
1187 file->private_data = priv;
1189 spin_lock_irqsave(&vga_user_lock, flags);
1190 list_add(&priv->list, &vga_user_list);
1191 spin_unlock_irqrestore(&vga_user_lock, flags);
1193 /* Set the client' lists of locks */
1194 priv->target = vga_default_device(); /* Maybe this is still null! */
1195 priv->cards[0].pdev = priv->target;
1196 priv->cards[0].io_cnt = 0;
1197 priv->cards[0].mem_cnt = 0;
1200 return 0;
1203 static int vga_arb_release(struct inode *inode, struct file *file)
1205 struct vga_arb_private *priv = file->private_data;
1206 struct vga_arb_user_card *uc;
1207 unsigned long flags;
1208 int i;
1210 pr_debug("%s\n", __func__);
1212 if (priv == NULL)
1213 return -ENODEV;
1215 spin_lock_irqsave(&vga_user_lock, flags);
1216 list_del(&priv->list);
1217 for (i = 0; i < MAX_USER_CARDS; i++) {
1218 uc = &priv->cards[i];
1219 if (uc->pdev == NULL)
1220 continue;
1221 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1222 uc->io_cnt, uc->mem_cnt);
1223 while (uc->io_cnt--)
1224 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1225 while (uc->mem_cnt--)
1226 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1228 spin_unlock_irqrestore(&vga_user_lock, flags);
1230 kfree(priv);
1232 return 0;
1235 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1240 * callback any registered clients to let them know we have a
1241 * change in VGA cards
1243 static void vga_arbiter_notify_clients(void)
1245 struct vga_device *vgadev;
1246 unsigned long flags;
1247 uint32_t new_decodes;
1248 bool new_state;
1250 if (!vga_arbiter_used)
1251 return;
1253 spin_lock_irqsave(&vga_lock, flags);
1254 list_for_each_entry(vgadev, &vga_list, list) {
1255 if (vga_count > 1)
1256 new_state = false;
1257 else
1258 new_state = true;
1259 if (vgadev->set_vga_decode) {
1260 new_decodes = vgadev->set_vga_decode(vgadev->cookie,
1261 new_state);
1262 vga_update_device_decodes(vgadev, new_decodes);
1265 spin_unlock_irqrestore(&vga_lock, flags);
1268 static int pci_notify(struct notifier_block *nb, unsigned long action,
1269 void *data)
1271 struct device *dev = data;
1272 struct pci_dev *pdev = to_pci_dev(dev);
1273 bool notify = false;
1275 pr_debug("%s\n", __func__);
1277 /* For now we're only intereted in devices added and removed. I didn't
1278 * test this thing here, so someone needs to double check for the
1279 * cases of hotplugable vga cards. */
1280 if (action == BUS_NOTIFY_ADD_DEVICE)
1281 notify = vga_arbiter_add_pci_device(pdev);
1282 else if (action == BUS_NOTIFY_DEL_DEVICE)
1283 notify = vga_arbiter_del_pci_device(pdev);
1285 if (notify)
1286 vga_arbiter_notify_clients();
1287 return 0;
1290 static struct notifier_block pci_notifier = {
1291 .notifier_call = pci_notify,
1294 static const struct file_operations vga_arb_device_fops = {
1295 .read = vga_arb_read,
1296 .write = vga_arb_write,
1297 .poll = vga_arb_fpoll,
1298 .open = vga_arb_open,
1299 .release = vga_arb_release,
1300 .llseek = noop_llseek,
1303 static struct miscdevice vga_arb_device = {
1304 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1307 static int __init vga_arb_device_init(void)
1309 int rc;
1310 struct pci_dev *pdev;
1311 struct vga_device *vgadev;
1313 rc = misc_register(&vga_arb_device);
1314 if (rc < 0)
1315 pr_err("error %d registering device\n", rc);
1317 bus_register_notifier(&pci_bus_type, &pci_notifier);
1319 /* We add all pci devices satisfying vga class in the arbiter by
1320 * default */
1321 pdev = NULL;
1322 while ((pdev =
1323 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1324 PCI_ANY_ID, pdev)) != NULL)
1325 vga_arbiter_add_pci_device(pdev);
1327 pr_info("loaded\n");
1329 list_for_each_entry(vgadev, &vga_list, list) {
1330 #if defined(CONFIG_X86) || defined(CONFIG_IA64)
1332 * Override vga_arbiter_add_pci_device()'s I/O based detection
1333 * as it may take the wrong device (e.g. on Apple system under
1334 * EFI).
1336 * Select the device owning the boot framebuffer if there is
1337 * one.
1339 resource_size_t start, end, limit;
1340 unsigned long flags;
1341 int i;
1343 limit = screen_info.lfb_base + screen_info.lfb_size;
1345 /* Does firmware framebuffer belong to us? */
1346 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
1347 flags = pci_resource_flags(vgadev->pdev, i);
1349 if ((flags & IORESOURCE_MEM) == 0)
1350 continue;
1352 start = pci_resource_start(vgadev->pdev, i);
1353 end = pci_resource_end(vgadev->pdev, i);
1355 if (!start || !end)
1356 continue;
1358 if (screen_info.lfb_base < start || limit >= end)
1359 continue;
1361 if (!vga_default_device())
1362 pr_info("setting as boot device: PCI:%s\n",
1363 pci_name(vgadev->pdev));
1364 else if (vgadev->pdev != vga_default_device())
1365 pr_info("overriding boot device: PCI:%s\n",
1366 pci_name(vgadev->pdev));
1367 vga_set_default_device(vgadev->pdev);
1369 #endif
1370 if (vgadev->bridge_has_one_vga)
1371 pr_info("bridge control possible %s\n",
1372 pci_name(vgadev->pdev));
1373 else
1374 pr_info("no bridge control possible %s\n",
1375 pci_name(vgadev->pdev));
1377 return rc;
1379 subsys_initcall(vga_arb_device_init);