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