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