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