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