Loading...
Note: File does not exist in v6.9.4.
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 */
532static int 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}
557
558/**
559 * vga_put - release lock on legacy VGA resources
560 * @pdev: pci device of VGA card or NULL for system default
561 * @rsrc: but mask of resource to release
562 *
563 * This fuction releases resources previously locked by vga_get() or
564 * vga_tryget(). The resources aren't disabled right away, so that a subsequence
565 * vga_get() on the same card will succeed immediately. Resources have a
566 * counter, so locks are only released if the counter reaches 0.
567 */
568void vga_put(struct pci_dev *pdev, unsigned int rsrc)
569{
570 struct vga_device *vgadev;
571 unsigned long flags;
572
573 /* The one who calls us should check for this, but lets be sure... */
574 if (pdev == NULL)
575 pdev = vga_default_device();
576 if (pdev == NULL)
577 return;
578 spin_lock_irqsave(&vga_lock, flags);
579 vgadev = vgadev_find(pdev);
580 if (vgadev == NULL)
581 goto bail;
582 __vga_put(vgadev, rsrc);
583bail:
584 spin_unlock_irqrestore(&vga_lock, flags);
585}
586EXPORT_SYMBOL(vga_put);
587
588/*
589 * Rules for using a bridge to control a VGA descendant decoding: if a bridge
590 * has only one VGA descendant then it can be used to control the VGA routing
591 * for that device. It should always use the bridge closest to the device to
592 * control it. If a bridge has a direct VGA descendant, but also have a sub-
593 * bridge VGA descendant then we cannot use that bridge to control the direct
594 * VGA descendant. So for every device we register, we need to iterate all
595 * its parent bridges so we can invalidate any devices using them properly.
596 */
597static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
598{
599 struct vga_device *same_bridge_vgadev;
600 struct pci_bus *new_bus, *bus;
601 struct pci_dev *new_bridge, *bridge;
602
603 vgadev->bridge_has_one_vga = true;
604
605 if (list_empty(&vga_list))
606 return;
607
608 /* okay iterate the new devices bridge hierarachy */
609 new_bus = vgadev->pdev->bus;
610 while (new_bus) {
611 new_bridge = new_bus->self;
612
613 /* go through list of devices already registered */
614 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
615 bus = same_bridge_vgadev->pdev->bus;
616 bridge = bus->self;
617
618 /* see if the share a bridge with this device */
619 if (new_bridge == bridge) {
620 /*
621 * If their direct parent bridge is the same
622 * as any bridge of this device then it can't
623 * be used for that device.
624 */
625 same_bridge_vgadev->bridge_has_one_vga = false;
626 }
627
628 /*
629 * Now iterate the previous devices bridge hierarchy.
630 * If the new devices parent bridge is in the other
631 * devices hierarchy then we can't use it to control
632 * this device
633 */
634 while (bus) {
635 bridge = bus->self;
636
637 if (bridge && bridge == vgadev->pdev->bus->self)
638 vgadev->bridge_has_one_vga = false;
639
640 bus = bus->parent;
641 }
642 }
643 new_bus = new_bus->parent;
644 }
645}
646
647/*
648 * Currently, we assume that the "initial" setup of the system is
649 * not sane, that is we come up with conflicting devices and let
650 * the arbiter's client decides if devices decodes or not legacy
651 * things.
652 */
653static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
654{
655 struct vga_device *vgadev;
656 unsigned long flags;
657 struct pci_bus *bus;
658 struct pci_dev *bridge;
659 u16 cmd;
660
661 /* Only deal with VGA class devices */
662 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
663 return false;
664
665 /* Allocate structure */
666 vgadev = kzalloc(sizeof(struct vga_device), GFP_KERNEL);
667 if (vgadev == NULL) {
668 vgaarb_err(&pdev->dev, "failed to allocate VGA arbiter data\n");
669 /*
670 * What to do on allocation failure ? For now, let's just do
671 * nothing, I'm not sure there is anything saner to be done.
672 */
673 return false;
674 }
675
676 /* Take lock & check for duplicates */
677 spin_lock_irqsave(&vga_lock, flags);
678 if (vgadev_find(pdev) != NULL) {
679 BUG_ON(1);
680 goto fail;
681 }
682 vgadev->pdev = pdev;
683
684 /* By default, assume we decode everything */
685 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
686 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
687
688 /* by default mark it as decoding */
689 vga_decode_count++;
690 /* Mark that we "own" resources based on our enables, we will
691 * clear that below if the bridge isn't forwarding
692 */
693 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
694 if (cmd & PCI_COMMAND_IO)
695 vgadev->owns |= VGA_RSRC_LEGACY_IO;
696 if (cmd & PCI_COMMAND_MEMORY)
697 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
698
699 /* Check if VGA cycles can get down to us */
700 bus = pdev->bus;
701 while (bus) {
702 bridge = bus->self;
703 if (bridge) {
704 u16 l;
705
706 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL, &l);
707 if (!(l & PCI_BRIDGE_CTL_VGA)) {
708 vgadev->owns = 0;
709 break;
710 }
711 }
712 bus = bus->parent;
713 }
714
715 /* Deal with VGA default device. Use first enabled one
716 * by default if arch doesn't have it's own hook
717 */
718 if (vga_default == NULL &&
719 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK)) {
720 vgaarb_info(&pdev->dev, "setting as boot VGA device\n");
721 vga_set_default_device(pdev);
722 }
723
724 vga_arbiter_check_bridge_sharing(vgadev);
725
726 /* Add to the list */
727 list_add_tail(&vgadev->list, &vga_list);
728 vga_count++;
729 vgaarb_info(&pdev->dev, "VGA device added: decodes=%s,owns=%s,locks=%s\n",
730 vga_iostate_to_str(vgadev->decodes),
731 vga_iostate_to_str(vgadev->owns),
732 vga_iostate_to_str(vgadev->locks));
733
734 spin_unlock_irqrestore(&vga_lock, flags);
735 return true;
736fail:
737 spin_unlock_irqrestore(&vga_lock, flags);
738 kfree(vgadev);
739 return false;
740}
741
742static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
743{
744 struct vga_device *vgadev;
745 unsigned long flags;
746 bool ret = true;
747
748 spin_lock_irqsave(&vga_lock, flags);
749 vgadev = vgadev_find(pdev);
750 if (vgadev == NULL) {
751 ret = false;
752 goto bail;
753 }
754
755 if (vga_default == pdev)
756 vga_set_default_device(NULL);
757
758 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
759 vga_decode_count--;
760
761 /* Remove entry from list */
762 list_del(&vgadev->list);
763 vga_count--;
764 /* Notify userland driver that the device is gone so it discards
765 * it's copies of the pci_dev pointer
766 */
767 vga_arb_device_card_gone(pdev);
768
769 /* Wake up all possible waiters */
770 wake_up_all(&vga_wait_queue);
771bail:
772 spin_unlock_irqrestore(&vga_lock, flags);
773 kfree(vgadev);
774 return ret;
775}
776
777/* this is called with the lock */
778static inline void vga_update_device_decodes(struct vga_device *vgadev,
779 int new_decodes)
780{
781 struct device *dev = &vgadev->pdev->dev;
782 int old_decodes, decodes_removed, decodes_unlocked;
783
784 old_decodes = vgadev->decodes;
785 decodes_removed = ~new_decodes & old_decodes;
786 decodes_unlocked = vgadev->locks & decodes_removed;
787 vgadev->decodes = new_decodes;
788
789 vgaarb_info(dev, "changed VGA decodes: olddecodes=%s,decodes=%s:owns=%s\n",
790 vga_iostate_to_str(old_decodes),
791 vga_iostate_to_str(vgadev->decodes),
792 vga_iostate_to_str(vgadev->owns));
793
794 /* if we removed locked decodes, lock count goes to zero, and release */
795 if (decodes_unlocked) {
796 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
797 vgadev->io_lock_cnt = 0;
798 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
799 vgadev->mem_lock_cnt = 0;
800 __vga_put(vgadev, decodes_unlocked);
801 }
802
803 /* change decodes counter */
804 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
805 !(new_decodes & VGA_RSRC_LEGACY_MASK))
806 vga_decode_count--;
807 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
808 new_decodes & VGA_RSRC_LEGACY_MASK)
809 vga_decode_count++;
810 vgaarb_dbg(dev, "decoding count now is: %d\n", vga_decode_count);
811}
812
813static void __vga_set_legacy_decoding(struct pci_dev *pdev,
814 unsigned int decodes,
815 bool userspace)
816{
817 struct vga_device *vgadev;
818 unsigned long flags;
819
820 decodes &= VGA_RSRC_LEGACY_MASK;
821
822 spin_lock_irqsave(&vga_lock, flags);
823 vgadev = vgadev_find(pdev);
824 if (vgadev == NULL)
825 goto bail;
826
827 /* don't let userspace futz with kernel driver decodes */
828 if (userspace && vgadev->set_vga_decode)
829 goto bail;
830
831 /* update the device decodes + counter */
832 vga_update_device_decodes(vgadev, decodes);
833
834 /* XXX if somebody is going from "doesn't decode" to "decodes" state
835 * here, additional care must be taken as we may have pending owner
836 * ship of non-legacy region ...
837 */
838bail:
839 spin_unlock_irqrestore(&vga_lock, flags);
840}
841
842void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
843{
844 __vga_set_legacy_decoding(pdev, decodes, false);
845}
846EXPORT_SYMBOL(vga_set_legacy_decoding);
847
848/**
849 * vga_client_register - register or unregister a VGA arbitration client
850 * @pdev: pci device of the VGA client
851 * @cookie: client cookie to be used in callbacks
852 * @irq_set_state: irq state change callback
853 * @set_vga_decode: vga decode change callback
854 *
855 * Clients have two callback mechanisms they can use.
856 *
857 * @irq_set_state callback: If a client can't disable its GPUs VGA
858 * resources, then we need to be able to ask it to turn off its irqs when we
859 * turn off its mem and io decoding.
860 *
861 * @set_vga_decode callback: If a client can disable its GPU VGA resource, it
862 * will get a callback from this to set the encode/decode state.
863 *
864 * Rationale: we cannot disable VGA decode resources unconditionally some single
865 * GPU laptops seem to require ACPI or BIOS access to the VGA registers to
866 * control things like backlights etc. Hopefully newer multi-GPU laptops do
867 * something saner, and desktops won't have any special ACPI for this. The
868 * driver will get a callback when VGA arbitration is first used by userspace
869 * since some older X servers have issues.
870 *
871 * This function does not check whether a client for @pdev has been registered
872 * already.
873 *
874 * To unregister just call this function with @irq_set_state and @set_vga_decode
875 * both set to NULL for the same @pdev as originally used to register them.
876 *
877 * Returns: 0 on success, -1 on failure
878 */
879int vga_client_register(struct pci_dev *pdev, void *cookie,
880 void (*irq_set_state)(void *cookie, bool state),
881 unsigned int (*set_vga_decode)(void *cookie,
882 bool decode))
883{
884 int ret = -ENODEV;
885 struct vga_device *vgadev;
886 unsigned long flags;
887
888 spin_lock_irqsave(&vga_lock, flags);
889 vgadev = vgadev_find(pdev);
890 if (!vgadev)
891 goto bail;
892
893 vgadev->irq_set_state = irq_set_state;
894 vgadev->set_vga_decode = set_vga_decode;
895 vgadev->cookie = cookie;
896 ret = 0;
897
898bail:
899 spin_unlock_irqrestore(&vga_lock, flags);
900 return ret;
901
902}
903EXPORT_SYMBOL(vga_client_register);
904
905/*
906 * Char driver implementation
907 *
908 * Semantics is:
909 *
910 * open : open user instance of the arbitrer. by default, it's
911 * attached to the default VGA device of the system.
912 *
913 * close : close user instance, release locks
914 *
915 * read : return a string indicating the status of the target.
916 * an IO state string is of the form {io,mem,io+mem,none},
917 * mc and ic are respectively mem and io lock counts (for
918 * debugging/diagnostic only). "decodes" indicate what the
919 * card currently decodes, "owns" indicates what is currently
920 * enabled on it, and "locks" indicates what is locked by this
921 * card. If the card is unplugged, we get "invalid" then for
922 * card_ID and an -ENODEV error is returned for any command
923 * until a new card is targeted
924 *
925 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
926 *
927 * write : write a command to the arbiter. List of commands is:
928 *
929 * target <card_ID> : switch target to card <card_ID> (see below)
930 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
931 * trylock <io_state> : non-blocking acquire locks on target
932 * unlock <io_state> : release locks on target
933 * unlock all : release all locks on target held by this user
934 * decodes <io_state> : set the legacy decoding attributes for the card
935 *
936 * poll : event if something change on any card (not just the target)
937 *
938 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
939 * to go back to the system default card (TODO: not implemented yet).
940 * Currently, only PCI is supported as a prefix, but the userland API may
941 * support other bus types in the future, even if the current kernel
942 * implementation doesn't.
943 *
944 * Note about locks:
945 *
946 * The driver keeps track of which user has what locks on which card. It
947 * supports stacking, like the kernel one. This complexifies the implementation
948 * a bit, but makes the arbiter more tolerant to userspace problems and able
949 * to properly cleanup in all cases when a process dies.
950 * Currently, a max of 16 cards simultaneously can have locks issued from
951 * userspace for a given user (file descriptor instance) of the arbiter.
952 *
953 * If the device is hot-unplugged, there is a hook inside the module to notify
954 * they being added/removed in the system and automatically added/removed in
955 * the arbiter.
956 */
957
958#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
959#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
960
961/*
962 * Each user has an array of these, tracking which cards have locks
963 */
964struct vga_arb_user_card {
965 struct pci_dev *pdev;
966 unsigned int mem_cnt;
967 unsigned int io_cnt;
968};
969
970struct vga_arb_private {
971 struct list_head list;
972 struct pci_dev *target;
973 struct vga_arb_user_card cards[MAX_USER_CARDS];
974 spinlock_t lock;
975};
976
977static LIST_HEAD(vga_user_list);
978static DEFINE_SPINLOCK(vga_user_lock);
979
980
981/*
982 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
983 * returns the respective values. If the string is not in this format,
984 * it returns 0.
985 */
986static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
987 unsigned int *bus, unsigned int *devfn)
988{
989 int n;
990 unsigned int slot, func;
991
992
993 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
994 if (n != 4)
995 return 0;
996
997 *devfn = PCI_DEVFN(slot, func);
998
999 return 1;
1000}
1001
1002static ssize_t vga_arb_read(struct file *file, char __user *buf,
1003 size_t count, loff_t *ppos)
1004{
1005 struct vga_arb_private *priv = file->private_data;
1006 struct vga_device *vgadev;
1007 struct pci_dev *pdev;
1008 unsigned long flags;
1009 size_t len;
1010 int rc;
1011 char *lbuf;
1012
1013 lbuf = kmalloc(1024, GFP_KERNEL);
1014 if (lbuf == NULL)
1015 return -ENOMEM;
1016
1017 /* Shields against vga_arb_device_card_gone (pci_dev going
1018 * away), and allows access to vga list
1019 */
1020 spin_lock_irqsave(&vga_lock, flags);
1021
1022 /* If we are targeting the default, use it */
1023 pdev = priv->target;
1024 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
1025 spin_unlock_irqrestore(&vga_lock, flags);
1026 len = sprintf(lbuf, "invalid");
1027 goto done;
1028 }
1029
1030 /* Find card vgadev structure */
1031 vgadev = vgadev_find(pdev);
1032 if (vgadev == NULL) {
1033 /* Wow, it's not in the list, that shouldn't happen,
1034 * let's fix us up and return invalid card
1035 */
1036 if (pdev == priv->target)
1037 vga_arb_device_card_gone(pdev);
1038 spin_unlock_irqrestore(&vga_lock, flags);
1039 len = sprintf(lbuf, "invalid");
1040 goto done;
1041 }
1042
1043 /* Fill the buffer with infos */
1044 len = snprintf(lbuf, 1024,
1045 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
1046 vga_decode_count, pci_name(pdev),
1047 vga_iostate_to_str(vgadev->decodes),
1048 vga_iostate_to_str(vgadev->owns),
1049 vga_iostate_to_str(vgadev->locks),
1050 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
1051
1052 spin_unlock_irqrestore(&vga_lock, flags);
1053done:
1054
1055 /* Copy that to user */
1056 if (len > count)
1057 len = count;
1058 rc = copy_to_user(buf, lbuf, len);
1059 kfree(lbuf);
1060 if (rc)
1061 return -EFAULT;
1062 return len;
1063}
1064
1065/*
1066 * TODO: To avoid parsing inside kernel and to improve the speed we may
1067 * consider use ioctl here
1068 */
1069static ssize_t vga_arb_write(struct file *file, const char __user *buf,
1070 size_t count, loff_t *ppos)
1071{
1072 struct vga_arb_private *priv = file->private_data;
1073 struct vga_arb_user_card *uc = NULL;
1074 struct pci_dev *pdev;
1075
1076 unsigned int io_state;
1077
1078 char kbuf[64], *curr_pos;
1079 size_t remaining = count;
1080
1081 int ret_val;
1082 int i;
1083
1084 if (count >= sizeof(kbuf))
1085 return -EINVAL;
1086 if (copy_from_user(kbuf, buf, count))
1087 return -EFAULT;
1088 curr_pos = kbuf;
1089 kbuf[count] = '\0'; /* Just to make sure... */
1090
1091 if (strncmp(curr_pos, "lock ", 5) == 0) {
1092 curr_pos += 5;
1093 remaining -= 5;
1094
1095 pr_debug("client 0x%p called 'lock'\n", priv);
1096
1097 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1098 ret_val = -EPROTO;
1099 goto done;
1100 }
1101 if (io_state == VGA_RSRC_NONE) {
1102 ret_val = -EPROTO;
1103 goto done;
1104 }
1105
1106 pdev = priv->target;
1107 if (priv->target == NULL) {
1108 ret_val = -ENODEV;
1109 goto done;
1110 }
1111
1112 vga_get_uninterruptible(pdev, io_state);
1113
1114 /* Update the client's locks lists... */
1115 for (i = 0; i < MAX_USER_CARDS; i++) {
1116 if (priv->cards[i].pdev == pdev) {
1117 if (io_state & VGA_RSRC_LEGACY_IO)
1118 priv->cards[i].io_cnt++;
1119 if (io_state & VGA_RSRC_LEGACY_MEM)
1120 priv->cards[i].mem_cnt++;
1121 break;
1122 }
1123 }
1124
1125 ret_val = count;
1126 goto done;
1127 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
1128 curr_pos += 7;
1129 remaining -= 7;
1130
1131 pr_debug("client 0x%p called 'unlock'\n", priv);
1132
1133 if (strncmp(curr_pos, "all", 3) == 0)
1134 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
1135 else {
1136 if (!vga_str_to_iostate
1137 (curr_pos, remaining, &io_state)) {
1138 ret_val = -EPROTO;
1139 goto done;
1140 }
1141 /* TODO: Add this?
1142 if (io_state == VGA_RSRC_NONE) {
1143 ret_val = -EPROTO;
1144 goto done;
1145 }
1146 */
1147 }
1148
1149 pdev = priv->target;
1150 if (priv->target == NULL) {
1151 ret_val = -ENODEV;
1152 goto done;
1153 }
1154 for (i = 0; i < MAX_USER_CARDS; i++) {
1155 if (priv->cards[i].pdev == pdev)
1156 uc = &priv->cards[i];
1157 }
1158
1159 if (!uc) {
1160 ret_val = -EINVAL;
1161 goto done;
1162 }
1163
1164 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1165 ret_val = -EINVAL;
1166 goto done;
1167 }
1168
1169 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1170 ret_val = -EINVAL;
1171 goto done;
1172 }
1173
1174 vga_put(pdev, io_state);
1175
1176 if (io_state & VGA_RSRC_LEGACY_IO)
1177 uc->io_cnt--;
1178 if (io_state & VGA_RSRC_LEGACY_MEM)
1179 uc->mem_cnt--;
1180
1181 ret_val = count;
1182 goto done;
1183 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1184 curr_pos += 8;
1185 remaining -= 8;
1186
1187 pr_debug("client 0x%p called 'trylock'\n", priv);
1188
1189 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1190 ret_val = -EPROTO;
1191 goto done;
1192 }
1193 /* TODO: Add this?
1194 if (io_state == VGA_RSRC_NONE) {
1195 ret_val = -EPROTO;
1196 goto done;
1197 }
1198 */
1199
1200 pdev = priv->target;
1201 if (priv->target == NULL) {
1202 ret_val = -ENODEV;
1203 goto done;
1204 }
1205
1206 if (vga_tryget(pdev, io_state)) {
1207 /* Update the client's locks lists... */
1208 for (i = 0; i < MAX_USER_CARDS; i++) {
1209 if (priv->cards[i].pdev == pdev) {
1210 if (io_state & VGA_RSRC_LEGACY_IO)
1211 priv->cards[i].io_cnt++;
1212 if (io_state & VGA_RSRC_LEGACY_MEM)
1213 priv->cards[i].mem_cnt++;
1214 break;
1215 }
1216 }
1217 ret_val = count;
1218 goto done;
1219 } else {
1220 ret_val = -EBUSY;
1221 goto done;
1222 }
1223
1224 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1225 unsigned int domain, bus, devfn;
1226 struct vga_device *vgadev;
1227
1228 curr_pos += 7;
1229 remaining -= 7;
1230 pr_debug("client 0x%p called 'target'\n", priv);
1231 /* if target is default */
1232 if (!strncmp(curr_pos, "default", 7))
1233 pdev = pci_dev_get(vga_default_device());
1234 else {
1235 if (!vga_pci_str_to_vars(curr_pos, remaining,
1236 &domain, &bus, &devfn)) {
1237 ret_val = -EPROTO;
1238 goto done;
1239 }
1240 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
1241 if (!pdev) {
1242 pr_debug("invalid PCI address %04x:%02x:%02x.%x\n",
1243 domain, bus, PCI_SLOT(devfn),
1244 PCI_FUNC(devfn));
1245 ret_val = -ENODEV;
1246 goto done;
1247 }
1248
1249 pr_debug("%s ==> %04x:%02x:%02x.%x pdev %p\n", curr_pos,
1250 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn),
1251 pdev);
1252 }
1253
1254 vgadev = vgadev_find(pdev);
1255 pr_debug("vgadev %p\n", vgadev);
1256 if (vgadev == NULL) {
1257 if (pdev) {
1258 vgaarb_dbg(&pdev->dev, "not a VGA device\n");
1259 pci_dev_put(pdev);
1260 }
1261
1262 ret_val = -ENODEV;
1263 goto done;
1264 }
1265
1266 priv->target = pdev;
1267 for (i = 0; i < MAX_USER_CARDS; i++) {
1268 if (priv->cards[i].pdev == pdev)
1269 break;
1270 if (priv->cards[i].pdev == NULL) {
1271 priv->cards[i].pdev = pdev;
1272 priv->cards[i].io_cnt = 0;
1273 priv->cards[i].mem_cnt = 0;
1274 break;
1275 }
1276 }
1277 if (i == MAX_USER_CARDS) {
1278 vgaarb_dbg(&pdev->dev, "maximum user cards (%d) number reached, ignoring this one!\n",
1279 MAX_USER_CARDS);
1280 pci_dev_put(pdev);
1281 /* XXX: which value to return? */
1282 ret_val = -ENOMEM;
1283 goto done;
1284 }
1285
1286 ret_val = count;
1287 pci_dev_put(pdev);
1288 goto done;
1289
1290
1291 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1292 curr_pos += 8;
1293 remaining -= 8;
1294 pr_debug("client 0x%p called 'decodes'\n", priv);
1295
1296 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1297 ret_val = -EPROTO;
1298 goto done;
1299 }
1300 pdev = priv->target;
1301 if (priv->target == NULL) {
1302 ret_val = -ENODEV;
1303 goto done;
1304 }
1305
1306 __vga_set_legacy_decoding(pdev, io_state, true);
1307 ret_val = count;
1308 goto done;
1309 }
1310 /* If we got here, the message written is not part of the protocol! */
1311 return -EPROTO;
1312
1313done:
1314 return ret_val;
1315}
1316
1317static __poll_t vga_arb_fpoll(struct file *file, poll_table *wait)
1318{
1319 pr_debug("%s\n", __func__);
1320
1321 poll_wait(file, &vga_wait_queue, wait);
1322 return EPOLLIN;
1323}
1324
1325static int vga_arb_open(struct inode *inode, struct file *file)
1326{
1327 struct vga_arb_private *priv;
1328 unsigned long flags;
1329
1330 pr_debug("%s\n", __func__);
1331
1332 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1333 if (priv == NULL)
1334 return -ENOMEM;
1335 spin_lock_init(&priv->lock);
1336 file->private_data = priv;
1337
1338 spin_lock_irqsave(&vga_user_lock, flags);
1339 list_add(&priv->list, &vga_user_list);
1340 spin_unlock_irqrestore(&vga_user_lock, flags);
1341
1342 /* Set the client' lists of locks */
1343 priv->target = vga_default_device(); /* Maybe this is still null! */
1344 priv->cards[0].pdev = priv->target;
1345 priv->cards[0].io_cnt = 0;
1346 priv->cards[0].mem_cnt = 0;
1347
1348
1349 return 0;
1350}
1351
1352static int vga_arb_release(struct inode *inode, struct file *file)
1353{
1354 struct vga_arb_private *priv = file->private_data;
1355 struct vga_arb_user_card *uc;
1356 unsigned long flags;
1357 int i;
1358
1359 pr_debug("%s\n", __func__);
1360
1361 spin_lock_irqsave(&vga_user_lock, flags);
1362 list_del(&priv->list);
1363 for (i = 0; i < MAX_USER_CARDS; i++) {
1364 uc = &priv->cards[i];
1365 if (uc->pdev == NULL)
1366 continue;
1367 vgaarb_dbg(&uc->pdev->dev, "uc->io_cnt == %d, uc->mem_cnt == %d\n",
1368 uc->io_cnt, uc->mem_cnt);
1369 while (uc->io_cnt--)
1370 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1371 while (uc->mem_cnt--)
1372 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1373 }
1374 spin_unlock_irqrestore(&vga_user_lock, flags);
1375
1376 kfree(priv);
1377
1378 return 0;
1379}
1380
1381static void vga_arb_device_card_gone(struct pci_dev *pdev)
1382{
1383}
1384
1385/*
1386 * callback any registered clients to let them know we have a
1387 * change in VGA cards
1388 */
1389static void vga_arbiter_notify_clients(void)
1390{
1391 struct vga_device *vgadev;
1392 unsigned long flags;
1393 uint32_t new_decodes;
1394 bool new_state;
1395
1396 if (!vga_arbiter_used)
1397 return;
1398
1399 spin_lock_irqsave(&vga_lock, flags);
1400 list_for_each_entry(vgadev, &vga_list, list) {
1401 if (vga_count > 1)
1402 new_state = false;
1403 else
1404 new_state = true;
1405 if (vgadev->set_vga_decode) {
1406 new_decodes = vgadev->set_vga_decode(vgadev->cookie,
1407 new_state);
1408 vga_update_device_decodes(vgadev, new_decodes);
1409 }
1410 }
1411 spin_unlock_irqrestore(&vga_lock, flags);
1412}
1413
1414static int pci_notify(struct notifier_block *nb, unsigned long action,
1415 void *data)
1416{
1417 struct device *dev = data;
1418 struct pci_dev *pdev = to_pci_dev(dev);
1419 bool notify = false;
1420
1421 vgaarb_dbg(dev, "%s\n", __func__);
1422
1423 /* For now we're only intereted in devices added and removed. I didn't
1424 * test this thing here, so someone needs to double check for the
1425 * cases of hotplugable vga cards. */
1426 if (action == BUS_NOTIFY_ADD_DEVICE)
1427 notify = vga_arbiter_add_pci_device(pdev);
1428 else if (action == BUS_NOTIFY_DEL_DEVICE)
1429 notify = vga_arbiter_del_pci_device(pdev);
1430
1431 if (notify)
1432 vga_arbiter_notify_clients();
1433 return 0;
1434}
1435
1436static struct notifier_block pci_notifier = {
1437 .notifier_call = pci_notify,
1438};
1439
1440static const struct file_operations vga_arb_device_fops = {
1441 .read = vga_arb_read,
1442 .write = vga_arb_write,
1443 .poll = vga_arb_fpoll,
1444 .open = vga_arb_open,
1445 .release = vga_arb_release,
1446 .llseek = noop_llseek,
1447};
1448
1449static struct miscdevice vga_arb_device = {
1450 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1451};
1452
1453static void __init vga_arb_select_default_device(void)
1454{
1455 struct pci_dev *pdev;
1456 struct vga_device *vgadev;
1457
1458#if defined(CONFIG_X86) || defined(CONFIG_IA64)
1459 u64 base = screen_info.lfb_base;
1460 u64 size = screen_info.lfb_size;
1461 u64 limit;
1462 resource_size_t start, end;
1463 unsigned long flags;
1464 int i;
1465
1466 if (screen_info.capabilities & VIDEO_CAPABILITY_64BIT_BASE)
1467 base |= (u64)screen_info.ext_lfb_base << 32;
1468
1469 limit = base + size;
1470
1471 list_for_each_entry(vgadev, &vga_list, list) {
1472 struct device *dev = &vgadev->pdev->dev;
1473 /*
1474 * Override vga_arbiter_add_pci_device()'s I/O based detection
1475 * as it may take the wrong device (e.g. on Apple system under
1476 * EFI).
1477 *
1478 * Select the device owning the boot framebuffer if there is
1479 * one.
1480 */
1481
1482 /* Does firmware framebuffer belong to us? */
1483 for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
1484 flags = pci_resource_flags(vgadev->pdev, i);
1485
1486 if ((flags & IORESOURCE_MEM) == 0)
1487 continue;
1488
1489 start = pci_resource_start(vgadev->pdev, i);
1490 end = pci_resource_end(vgadev->pdev, i);
1491
1492 if (!start || !end)
1493 continue;
1494
1495 if (base < start || limit >= end)
1496 continue;
1497
1498 if (!vga_default_device())
1499 vgaarb_info(dev, "setting as boot device\n");
1500 else if (vgadev->pdev != vga_default_device())
1501 vgaarb_info(dev, "overriding boot device\n");
1502 vga_set_default_device(vgadev->pdev);
1503 }
1504 }
1505#endif
1506
1507 if (!vga_default_device()) {
1508 list_for_each_entry(vgadev, &vga_list, list) {
1509 struct device *dev = &vgadev->pdev->dev;
1510 u16 cmd;
1511
1512 pdev = vgadev->pdev;
1513 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
1514 if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
1515 vgaarb_info(dev, "setting as boot device (VGA legacy resources not available)\n");
1516 vga_set_default_device(pdev);
1517 break;
1518 }
1519 }
1520 }
1521
1522 if (!vga_default_device()) {
1523 vgadev = list_first_entry_or_null(&vga_list,
1524 struct vga_device, list);
1525 if (vgadev) {
1526 struct device *dev = &vgadev->pdev->dev;
1527 vgaarb_info(dev, "setting as boot device (VGA legacy resources not available)\n");
1528 vga_set_default_device(vgadev->pdev);
1529 }
1530 }
1531}
1532
1533static int __init vga_arb_device_init(void)
1534{
1535 int rc;
1536 struct pci_dev *pdev;
1537 struct vga_device *vgadev;
1538
1539 rc = misc_register(&vga_arb_device);
1540 if (rc < 0)
1541 pr_err("error %d registering device\n", rc);
1542
1543 bus_register_notifier(&pci_bus_type, &pci_notifier);
1544
1545 /* We add all PCI devices satisfying VGA class in the arbiter by
1546 * default */
1547 pdev = NULL;
1548 while ((pdev =
1549 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1550 PCI_ANY_ID, pdev)) != NULL)
1551 vga_arbiter_add_pci_device(pdev);
1552
1553 list_for_each_entry(vgadev, &vga_list, list) {
1554 struct device *dev = &vgadev->pdev->dev;
1555
1556 if (vgadev->bridge_has_one_vga)
1557 vgaarb_info(dev, "bridge control possible\n");
1558 else
1559 vgaarb_info(dev, "no bridge control possible\n");
1560 }
1561
1562 vga_arb_select_default_device();
1563
1564 pr_info("loaded\n");
1565 return rc;
1566}
1567subsys_initcall(vga_arb_device_init);