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