blob: e893f6e1937d7c79e2de772e00d1ed0b9a936e33 [file] [log] [blame]
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001/*
Tiago Vignattic0db9cb2010-05-24 18:24:31 +03002 * vgaarb.c: Implements the VGA arbitration. For details refer to
3 * Documentation/vgaarbiter.txt
4 *
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10005 *
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 *
Tiago Vignattic0db9cb2010-05-24 18:24:31 +030010 * 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 *
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +100030 */
31
32#include <linux/module.h>
33#include <linux/kernel.h>
34#include <linux/pci.h>
35#include <linux/errno.h>
36#include <linux/init.h>
37#include <linux/list.h>
38#include <linux/sched.h>
39#include <linux/wait.h>
40#include <linux/spinlock.h>
41#include <linux/poll.h>
42#include <linux/miscdevice.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090043#include <linux/slab.h>
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +100044
45#include <linux/uaccess.h>
46
47#include <linux/vgaarb.h>
48
49static void vga_arbiter_notify_clients(void);
50/*
51 * We keep a list of all vga devices in the system to speed
52 * up the various operations of the arbiter
53 */
54struct vga_device {
55 struct list_head list;
56 struct pci_dev *pdev;
57 unsigned int decodes; /* what does it decodes */
58 unsigned int owns; /* what does it owns */
59 unsigned int locks; /* what does it locks */
60 unsigned int io_lock_cnt; /* legacy IO lock count */
61 unsigned int mem_lock_cnt; /* legacy MEM lock count */
62 unsigned int io_norm_cnt; /* normal IO count */
63 unsigned int mem_norm_cnt; /* normal MEM count */
Dave Airlie3448a192010-06-01 15:32:24 +100064 bool bridge_has_one_vga;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +100065 /* allow IRQ enable/disable hook */
66 void *cookie;
67 void (*irq_set_state)(void *cookie, bool enable);
68 unsigned int (*set_vga_decode)(void *cookie, bool decode);
69};
70
71static LIST_HEAD(vga_list);
72static int vga_count, vga_decode_count;
73static bool vga_arbiter_used;
74static DEFINE_SPINLOCK(vga_lock);
75static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
76
77
78static const char *vga_iostate_to_str(unsigned int iostate)
79{
80 /* Ignore VGA_RSRC_IO and VGA_RSRC_MEM */
81 iostate &= VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
82 switch (iostate) {
83 case VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM:
84 return "io+mem";
85 case VGA_RSRC_LEGACY_IO:
86 return "io";
87 case VGA_RSRC_LEGACY_MEM:
88 return "mem";
89 }
90 return "none";
91}
92
93static int vga_str_to_iostate(char *buf, int str_size, int *io_state)
94{
95 /* we could in theory hand out locks on IO and mem
96 * separately to userspace but it can cause deadlocks */
97 if (strncmp(buf, "none", 4) == 0) {
98 *io_state = VGA_RSRC_NONE;
99 return 1;
100 }
101
102 /* XXX We're not chekcing the str_size! */
103 if (strncmp(buf, "io+mem", 6) == 0)
104 goto both;
105 else if (strncmp(buf, "io", 2) == 0)
106 goto both;
107 else if (strncmp(buf, "mem", 3) == 0)
108 goto both;
109 return 0;
110both:
111 *io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
112 return 1;
113}
114
115#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
116/* this is only used a cookie - it should not be dereferenced */
117static struct pci_dev *vga_default;
118#endif
119
120static void vga_arb_device_card_gone(struct pci_dev *pdev);
121
122/* Find somebody in our list */
123static struct vga_device *vgadev_find(struct pci_dev *pdev)
124{
125 struct vga_device *vgadev;
126
127 list_for_each_entry(vgadev, &vga_list, list)
128 if (pdev == vgadev->pdev)
129 return vgadev;
130 return NULL;
131}
132
133/* Returns the default VGA device (vgacon's babe) */
134#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
135struct pci_dev *vga_default_device(void)
136{
137 return vga_default;
138}
Matthew Garrett1a39b312012-04-16 16:26:02 -0400139
Matthew Garrett1b231702012-04-24 09:31:28 +0100140EXPORT_SYMBOL_GPL(vga_default_device);
141
Matthew Garrett1a39b312012-04-16 16:26:02 -0400142void vga_set_default_device(struct pci_dev *pdev)
143{
Yinghai Lu84544a12012-09-19 11:54:15 -0700144 if (vga_default == pdev)
145 return;
146
147 pci_dev_put(vga_default);
148 vga_default = pci_dev_get(pdev);
Matthew Garrett1a39b312012-04-16 16:26:02 -0400149}
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000150#endif
151
152static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
153{
154 if (vgadev->irq_set_state)
155 vgadev->irq_set_state(vgadev->cookie, state);
156}
157
158
159/* If we don't ever use VGA arb we should avoid
160 turning off anything anywhere due to old X servers getting
161 confused about the boot device not being VGA */
162static void vga_check_first_use(void)
163{
164 /* we should inform all GPUs in the system that
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300165 * VGA arb has occurred and to try and disable resources
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000166 * if they can */
167 if (!vga_arbiter_used) {
168 vga_arbiter_used = true;
169 vga_arbiter_notify_clients();
170 }
171}
172
173static struct vga_device *__vga_tryget(struct vga_device *vgadev,
174 unsigned int rsrc)
175{
176 unsigned int wants, legacy_wants, match;
177 struct vga_device *conflict;
178 unsigned int pci_bits;
Dave Airlie3448a192010-06-01 15:32:24 +1000179 u32 flags = 0;
180
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000181 /* Account for "normal" resources to lock. If we decode the legacy,
182 * counterpart, we need to request it as well
183 */
184 if ((rsrc & VGA_RSRC_NORMAL_IO) &&
185 (vgadev->decodes & VGA_RSRC_LEGACY_IO))
186 rsrc |= VGA_RSRC_LEGACY_IO;
187 if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
188 (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
189 rsrc |= VGA_RSRC_LEGACY_MEM;
190
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300191 pr_debug("%s: %d\n", __func__, rsrc);
192 pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000193
194 /* Check what resources we need to acquire */
195 wants = rsrc & ~vgadev->owns;
196
197 /* We already own everything, just mark locked & bye bye */
198 if (wants == 0)
199 goto lock_them;
200
201 /* We don't need to request a legacy resource, we just enable
202 * appropriate decoding and go
203 */
204 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
205 if (legacy_wants == 0)
206 goto enable_them;
207
208 /* Ok, we don't, let's find out how we need to kick off */
209 list_for_each_entry(conflict, &vga_list, list) {
210 unsigned int lwants = legacy_wants;
211 unsigned int change_bridge = 0;
212
213 /* Don't conflict with myself */
214 if (vgadev == conflict)
215 continue;
216
217 /* Check if the architecture allows a conflict between those
218 * 2 devices or if they are on separate domains
219 */
220 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
221 continue;
222
223 /* We have a possible conflict. before we go further, we must
224 * check if we sit on the same bus as the conflicting device.
225 * if we don't, then we must tie both IO and MEM resources
226 * together since there is only a single bit controlling
227 * VGA forwarding on P2P bridges
228 */
229 if (vgadev->pdev->bus != conflict->pdev->bus) {
230 change_bridge = 1;
231 lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
232 }
233
234 /* Check if the guy has a lock on the resource. If he does,
235 * return the conflicting entry
236 */
237 if (conflict->locks & lwants)
238 return conflict;
239
240 /* Ok, now check if he owns the resource we want. We don't need
241 * to check "decodes" since it should be impossible to own
242 * own legacy resources you don't decode unless I have a bug
243 * in this code...
244 */
245 WARN_ON(conflict->owns & ~conflict->decodes);
246 match = lwants & conflict->owns;
247 if (!match)
248 continue;
249
250 /* looks like he doesn't have a lock, we can steal
251 * them from him
252 */
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000253
Dave Airlie3448a192010-06-01 15:32:24 +1000254 flags = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000255 pci_bits = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000256
Dave Airlie3448a192010-06-01 15:32:24 +1000257 if (!conflict->bridge_has_one_vga) {
258 vga_irq_set_state(conflict, false);
259 flags |= PCI_VGA_STATE_CHANGE_DECODES;
260 if (lwants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
261 pci_bits |= PCI_COMMAND_MEMORY;
262 if (lwants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
263 pci_bits |= PCI_COMMAND_IO;
264 }
265
266 if (change_bridge)
267 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
268
269 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000270 conflict->owns &= ~lwants;
271 /* If he also owned non-legacy, that is no longer the case */
272 if (lwants & VGA_RSRC_LEGACY_MEM)
273 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
274 if (lwants & VGA_RSRC_LEGACY_IO)
275 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
276 }
277
278enable_them:
279 /* ok dude, we got it, everybody conflicting has been disabled, let's
280 * enable us. Make sure we don't mark a bit in "owns" that we don't
281 * also have in "decodes". We can lock resources we don't decode but
282 * not own them.
283 */
Dave Airlie3448a192010-06-01 15:32:24 +1000284 flags = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000285 pci_bits = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000286
Dave Airlie3448a192010-06-01 15:32:24 +1000287 if (!vgadev->bridge_has_one_vga) {
288 flags |= PCI_VGA_STATE_CHANGE_DECODES;
289 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
290 pci_bits |= PCI_COMMAND_MEMORY;
291 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
292 pci_bits |= PCI_COMMAND_IO;
293 }
294 if (!!(wants & VGA_RSRC_LEGACY_MASK))
295 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
296
297 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
298
299 if (!vgadev->bridge_has_one_vga) {
300 vga_irq_set_state(vgadev, true);
301 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000302 vgadev->owns |= (wants & vgadev->decodes);
303lock_them:
304 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
305 if (rsrc & VGA_RSRC_LEGACY_IO)
306 vgadev->io_lock_cnt++;
307 if (rsrc & VGA_RSRC_LEGACY_MEM)
308 vgadev->mem_lock_cnt++;
309 if (rsrc & VGA_RSRC_NORMAL_IO)
310 vgadev->io_norm_cnt++;
311 if (rsrc & VGA_RSRC_NORMAL_MEM)
312 vgadev->mem_norm_cnt++;
313
314 return NULL;
315}
316
317static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
318{
319 unsigned int old_locks = vgadev->locks;
320
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300321 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000322
323 /* Update our counters, and account for equivalent legacy resources
324 * if we decode them
325 */
326 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
327 vgadev->io_norm_cnt--;
328 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
329 rsrc |= VGA_RSRC_LEGACY_IO;
330 }
331 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
332 vgadev->mem_norm_cnt--;
333 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
334 rsrc |= VGA_RSRC_LEGACY_MEM;
335 }
336 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
337 vgadev->io_lock_cnt--;
338 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
339 vgadev->mem_lock_cnt--;
340
341 /* Just clear lock bits, we do lazy operations so we don't really
342 * have to bother about anything else at this point
343 */
344 if (vgadev->io_lock_cnt == 0)
345 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
346 if (vgadev->mem_lock_cnt == 0)
347 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
348
349 /* Kick the wait queue in case somebody was waiting if we actually
350 * released something
351 */
352 if (old_locks != vgadev->locks)
353 wake_up_all(&vga_wait_queue);
354}
355
356int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
357{
358 struct vga_device *vgadev, *conflict;
359 unsigned long flags;
360 wait_queue_t wait;
361 int rc = 0;
362
363 vga_check_first_use();
364 /* The one who calls us should check for this, but lets be sure... */
365 if (pdev == NULL)
366 pdev = vga_default_device();
367 if (pdev == NULL)
368 return 0;
369
370 for (;;) {
371 spin_lock_irqsave(&vga_lock, flags);
372 vgadev = vgadev_find(pdev);
373 if (vgadev == NULL) {
374 spin_unlock_irqrestore(&vga_lock, flags);
375 rc = -ENODEV;
376 break;
377 }
378 conflict = __vga_tryget(vgadev, rsrc);
379 spin_unlock_irqrestore(&vga_lock, flags);
380 if (conflict == NULL)
381 break;
382
383
384 /* We have a conflict, we wait until somebody kicks the
385 * work queue. Currently we have one work queue that we
386 * kick each time some resources are released, but it would
387 * be fairly easy to have a per device one so that we only
388 * need to attach to the conflicting device
389 */
390 init_waitqueue_entry(&wait, current);
391 add_wait_queue(&vga_wait_queue, &wait);
392 set_current_state(interruptible ?
393 TASK_INTERRUPTIBLE :
394 TASK_UNINTERRUPTIBLE);
395 if (signal_pending(current)) {
396 rc = -EINTR;
397 break;
398 }
399 schedule();
400 remove_wait_queue(&vga_wait_queue, &wait);
401 set_current_state(TASK_RUNNING);
402 }
403 return rc;
404}
405EXPORT_SYMBOL(vga_get);
406
407int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
408{
409 struct vga_device *vgadev;
410 unsigned long flags;
411 int rc = 0;
412
413 vga_check_first_use();
414
415 /* The one who calls us should check for this, but lets be sure... */
416 if (pdev == NULL)
417 pdev = vga_default_device();
418 if (pdev == NULL)
419 return 0;
420 spin_lock_irqsave(&vga_lock, flags);
421 vgadev = vgadev_find(pdev);
422 if (vgadev == NULL) {
423 rc = -ENODEV;
424 goto bail;
425 }
426 if (__vga_tryget(vgadev, rsrc))
427 rc = -EBUSY;
428bail:
429 spin_unlock_irqrestore(&vga_lock, flags);
430 return rc;
431}
432EXPORT_SYMBOL(vga_tryget);
433
434void vga_put(struct pci_dev *pdev, unsigned int rsrc)
435{
436 struct vga_device *vgadev;
437 unsigned long flags;
438
439 /* The one who calls us should check for this, but lets be sure... */
440 if (pdev == NULL)
441 pdev = vga_default_device();
442 if (pdev == NULL)
443 return;
444 spin_lock_irqsave(&vga_lock, flags);
445 vgadev = vgadev_find(pdev);
446 if (vgadev == NULL)
447 goto bail;
448 __vga_put(vgadev, rsrc);
449bail:
450 spin_unlock_irqrestore(&vga_lock, flags);
451}
452EXPORT_SYMBOL(vga_put);
453
Dave Airlie3448a192010-06-01 15:32:24 +1000454/* Rules for using a bridge to control a VGA descendant decoding:
455 if a bridge has only one VGA descendant then it can be used
456 to control the VGA routing for that device.
457 It should always use the bridge closest to the device to control it.
458 If a bridge has a direct VGA descendant, but also have a sub-bridge
459 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
460 So for every device we register, we need to iterate all its parent bridges
461 so we can invalidate any devices using them properly.
462*/
463static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
464{
465 struct vga_device *same_bridge_vgadev;
466 struct pci_bus *new_bus, *bus;
467 struct pci_dev *new_bridge, *bridge;
468
469 vgadev->bridge_has_one_vga = true;
470
471 if (list_empty(&vga_list))
472 return;
473
474 /* okay iterate the new devices bridge hierarachy */
475 new_bus = vgadev->pdev->bus;
476 while (new_bus) {
477 new_bridge = new_bus->self;
478
Dave Airlief6252112011-10-10 09:29:18 +0100479 /* go through list of devices already registered */
480 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
481 bus = same_bridge_vgadev->pdev->bus;
482 bridge = bus->self;
483
484 /* see if the share a bridge with this device */
485 if (new_bridge == bridge) {
486 /* if their direct parent bridge is the same
487 as any bridge of this device then it can't be used
488 for that device */
489 same_bridge_vgadev->bridge_has_one_vga = false;
490 }
491
492 /* now iterate the previous devices bridge hierarchy */
493 /* if the new devices parent bridge is in the other devices
494 hierarchy then we can't use it to control this device */
495 while (bus) {
Dave Airlie3448a192010-06-01 15:32:24 +1000496 bridge = bus->self;
Dave Airlief6252112011-10-10 09:29:18 +0100497 if (bridge) {
498 if (bridge == vgadev->pdev->bus->self)
499 vgadev->bridge_has_one_vga = false;
Dave Airlie3448a192010-06-01 15:32:24 +1000500 }
Dave Airlief6252112011-10-10 09:29:18 +0100501 bus = bus->parent;
Dave Airlie3448a192010-06-01 15:32:24 +1000502 }
503 }
504 new_bus = new_bus->parent;
505 }
506}
507
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000508/*
509 * Currently, we assume that the "initial" setup of the system is
510 * not sane, that is we come up with conflicting devices and let
511 * the arbiter's client decides if devices decodes or not legacy
512 * things.
513 */
514static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
515{
516 struct vga_device *vgadev;
517 unsigned long flags;
518 struct pci_bus *bus;
519 struct pci_dev *bridge;
520 u16 cmd;
521
522 /* Only deal with VGA class devices */
523 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
524 return false;
525
526 /* Allocate structure */
527 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
528 if (vgadev == NULL) {
529 pr_err("vgaarb: failed to allocate pci device\n");
530 /* What to do on allocation failure ? For now, let's
531 * just do nothing, I'm not sure there is anything saner
532 * to be done
533 */
534 return false;
535 }
536
537 memset(vgadev, 0, sizeof(*vgadev));
538
539 /* Take lock & check for duplicates */
540 spin_lock_irqsave(&vga_lock, flags);
541 if (vgadev_find(pdev) != NULL) {
542 BUG_ON(1);
543 goto fail;
544 }
545 vgadev->pdev = pdev;
546
547 /* By default, assume we decode everything */
548 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
549 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
550
551 /* by default mark it as decoding */
552 vga_decode_count++;
553 /* Mark that we "own" resources based on our enables, we will
554 * clear that below if the bridge isn't forwarding
555 */
556 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
557 if (cmd & PCI_COMMAND_IO)
558 vgadev->owns |= VGA_RSRC_LEGACY_IO;
559 if (cmd & PCI_COMMAND_MEMORY)
560 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
561
562 /* Check if VGA cycles can get down to us */
563 bus = pdev->bus;
564 while (bus) {
565 bridge = bus->self;
566 if (bridge) {
567 u16 l;
568 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
569 &l);
570 if (!(l & PCI_BRIDGE_CTL_VGA)) {
571 vgadev->owns = 0;
572 break;
573 }
574 }
575 bus = bus->parent;
576 }
577
578 /* Deal with VGA default device. Use first enabled one
579 * by default if arch doesn't have it's own hook
580 */
581#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
582 if (vga_default == NULL &&
583 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
Yinghai Lu84544a12012-09-19 11:54:15 -0700584 vga_set_default_device(pdev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000585#endif
586
Dave Airlie3448a192010-06-01 15:32:24 +1000587 vga_arbiter_check_bridge_sharing(vgadev);
588
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000589 /* Add to the list */
590 list_add(&vgadev->list, &vga_list);
591 vga_count++;
592 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
593 pci_name(pdev),
594 vga_iostate_to_str(vgadev->decodes),
595 vga_iostate_to_str(vgadev->owns),
596 vga_iostate_to_str(vgadev->locks));
597
598 spin_unlock_irqrestore(&vga_lock, flags);
599 return true;
600fail:
601 spin_unlock_irqrestore(&vga_lock, flags);
602 kfree(vgadev);
603 return false;
604}
605
606static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
607{
608 struct vga_device *vgadev;
609 unsigned long flags;
610 bool ret = true;
611
612 spin_lock_irqsave(&vga_lock, flags);
613 vgadev = vgadev_find(pdev);
614 if (vgadev == NULL) {
615 ret = false;
616 goto bail;
617 }
618
Matthew Garrett1a39b312012-04-16 16:26:02 -0400619#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
Yinghai Lu84544a12012-09-19 11:54:15 -0700620 if (vga_default == pdev)
621 vga_set_default_device(NULL);
Matthew Garrett1a39b312012-04-16 16:26:02 -0400622#endif
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000623
624 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
625 vga_decode_count--;
626
627 /* Remove entry from list */
628 list_del(&vgadev->list);
629 vga_count--;
630 /* Notify userland driver that the device is gone so it discards
631 * it's copies of the pci_dev pointer
632 */
633 vga_arb_device_card_gone(pdev);
634
635 /* Wake up all possible waiters */
636 wake_up_all(&vga_wait_queue);
637bail:
638 spin_unlock_irqrestore(&vga_lock, flags);
639 kfree(vgadev);
640 return ret;
641}
642
643/* this is called with the lock */
644static inline void vga_update_device_decodes(struct vga_device *vgadev,
645 int new_decodes)
646{
647 int old_decodes;
648 struct vga_device *new_vgadev, *conflict;
649
650 old_decodes = vgadev->decodes;
651 vgadev->decodes = new_decodes;
652
653 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
654 pci_name(vgadev->pdev),
655 vga_iostate_to_str(old_decodes),
656 vga_iostate_to_str(vgadev->decodes),
657 vga_iostate_to_str(vgadev->owns));
658
659
660 /* if we own the decodes we should move them along to
661 another card */
662 if ((vgadev->owns & old_decodes) && (vga_count > 1)) {
663 /* set us to own nothing */
664 vgadev->owns &= ~old_decodes;
665 list_for_each_entry(new_vgadev, &vga_list, list) {
666 if ((new_vgadev != vgadev) &&
667 (new_vgadev->decodes & VGA_RSRC_LEGACY_MASK)) {
668 pr_info("vgaarb: transferring owner from PCI:%s to PCI:%s\n", pci_name(vgadev->pdev), pci_name(new_vgadev->pdev));
669 conflict = __vga_tryget(new_vgadev, VGA_RSRC_LEGACY_MASK);
670 if (!conflict)
671 __vga_put(new_vgadev, VGA_RSRC_LEGACY_MASK);
672 break;
673 }
674 }
675 }
676
677 /* change decodes counter */
678 if (old_decodes != new_decodes) {
679 if (new_decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
680 vga_decode_count++;
681 else
682 vga_decode_count--;
683 }
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300684 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000685}
686
Daniel J Blueman201ba4c2010-09-22 18:05:35 +0100687static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000688{
689 struct vga_device *vgadev;
690 unsigned long flags;
691
692 decodes &= VGA_RSRC_LEGACY_MASK;
693
694 spin_lock_irqsave(&vga_lock, flags);
695 vgadev = vgadev_find(pdev);
696 if (vgadev == NULL)
697 goto bail;
698
699 /* don't let userspace futz with kernel driver decodes */
700 if (userspace && vgadev->set_vga_decode)
701 goto bail;
702
703 /* update the device decodes + counter */
704 vga_update_device_decodes(vgadev, decodes);
705
706 /* XXX if somebody is going from "doesn't decode" to "decodes" state
707 * here, additional care must be taken as we may have pending owner
708 * ship of non-legacy region ...
709 */
710bail:
711 spin_unlock_irqrestore(&vga_lock, flags);
712}
713
714void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
715{
716 __vga_set_legacy_decoding(pdev, decodes, false);
717}
718EXPORT_SYMBOL(vga_set_legacy_decoding);
719
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000720/* call with NULL to unregister */
721int vga_client_register(struct pci_dev *pdev, void *cookie,
722 void (*irq_set_state)(void *cookie, bool state),
723 unsigned int (*set_vga_decode)(void *cookie, bool decode))
724{
Chris Wilson934f9922011-01-20 13:09:12 +0000725 int ret = -ENODEV;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000726 struct vga_device *vgadev;
727 unsigned long flags;
728
729 spin_lock_irqsave(&vga_lock, flags);
730 vgadev = vgadev_find(pdev);
731 if (!vgadev)
732 goto bail;
733
734 vgadev->irq_set_state = irq_set_state;
735 vgadev->set_vga_decode = set_vga_decode;
736 vgadev->cookie = cookie;
737 ret = 0;
738
739bail:
740 spin_unlock_irqrestore(&vga_lock, flags);
741 return ret;
742
743}
744EXPORT_SYMBOL(vga_client_register);
745
746/*
747 * Char driver implementation
748 *
749 * Semantics is:
750 *
751 * open : open user instance of the arbitrer. by default, it's
752 * attached to the default VGA device of the system.
753 *
754 * close : close user instance, release locks
755 *
756 * read : return a string indicating the status of the target.
757 * an IO state string is of the form {io,mem,io+mem,none},
758 * mc and ic are respectively mem and io lock counts (for
759 * debugging/diagnostic only). "decodes" indicate what the
760 * card currently decodes, "owns" indicates what is currently
761 * enabled on it, and "locks" indicates what is locked by this
762 * card. If the card is unplugged, we get "invalid" then for
763 * card_ID and an -ENODEV error is returned for any command
764 * until a new card is targeted
765 *
766 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
767 *
768 * write : write a command to the arbiter. List of commands is:
769 *
770 * target <card_ID> : switch target to card <card_ID> (see below)
771 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
772 * trylock <io_state> : non-blocking acquire locks on target
773 * unlock <io_state> : release locks on target
774 * unlock all : release all locks on target held by this user
775 * decodes <io_state> : set the legacy decoding attributes for the card
776 *
777 * poll : event if something change on any card (not just the target)
778 *
779 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
780 * to go back to the system default card (TODO: not implemented yet).
781 * Currently, only PCI is supported as a prefix, but the userland API may
782 * support other bus types in the future, even if the current kernel
783 * implementation doesn't.
784 *
785 * Note about locks:
786 *
787 * The driver keeps track of which user has what locks on which card. It
788 * supports stacking, like the kernel one. This complexifies the implementation
789 * a bit, but makes the arbiter more tolerant to userspace problems and able
790 * to properly cleanup in all cases when a process dies.
791 * Currently, a max of 16 cards simultaneously can have locks issued from
792 * userspace for a given user (file descriptor instance) of the arbiter.
793 *
794 * If the device is hot-unplugged, there is a hook inside the module to notify
795 * they being added/removed in the system and automatically added/removed in
796 * the arbiter.
797 */
798
Mike Travis36028f32010-02-02 17:45:01 -0800799#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000800#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
801
802/*
803 * Each user has an array of these, tracking which cards have locks
804 */
805struct vga_arb_user_card {
806 struct pci_dev *pdev;
807 unsigned int mem_cnt;
808 unsigned int io_cnt;
809};
810
811struct vga_arb_private {
812 struct list_head list;
813 struct pci_dev *target;
814 struct vga_arb_user_card cards[MAX_USER_CARDS];
815 spinlock_t lock;
816};
817
818static LIST_HEAD(vga_user_list);
819static DEFINE_SPINLOCK(vga_user_lock);
820
821
822/*
823 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
824 * returns the respective values. If the string is not in this format,
825 * it returns 0.
826 */
827static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
828 unsigned int *bus, unsigned int *devfn)
829{
830 int n;
831 unsigned int slot, func;
832
833
834 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
835 if (n != 4)
836 return 0;
837
838 *devfn = PCI_DEVFN(slot, func);
839
840 return 1;
841}
842
843static ssize_t vga_arb_read(struct file *file, char __user * buf,
844 size_t count, loff_t *ppos)
845{
846 struct vga_arb_private *priv = file->private_data;
847 struct vga_device *vgadev;
848 struct pci_dev *pdev;
849 unsigned long flags;
850 size_t len;
851 int rc;
852 char *lbuf;
853
854 lbuf = kmalloc(1024, GFP_KERNEL);
855 if (lbuf == NULL)
856 return -ENOMEM;
857
858 /* Shields against vga_arb_device_card_gone (pci_dev going
859 * away), and allows access to vga list
860 */
861 spin_lock_irqsave(&vga_lock, flags);
862
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300863 /* If we are targeting the default, use it */
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000864 pdev = priv->target;
865 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
866 spin_unlock_irqrestore(&vga_lock, flags);
867 len = sprintf(lbuf, "invalid");
868 goto done;
869 }
870
871 /* Find card vgadev structure */
872 vgadev = vgadev_find(pdev);
873 if (vgadev == NULL) {
874 /* Wow, it's not in the list, that shouldn't happen,
875 * let's fix us up and return invalid card
876 */
877 if (pdev == priv->target)
878 vga_arb_device_card_gone(pdev);
879 spin_unlock_irqrestore(&vga_lock, flags);
880 len = sprintf(lbuf, "invalid");
881 goto done;
882 }
883
884 /* Fill the buffer with infos */
885 len = snprintf(lbuf, 1024,
886 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
887 vga_decode_count, pci_name(pdev),
888 vga_iostate_to_str(vgadev->decodes),
889 vga_iostate_to_str(vgadev->owns),
890 vga_iostate_to_str(vgadev->locks),
891 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
892
893 spin_unlock_irqrestore(&vga_lock, flags);
894done:
895
896 /* Copy that to user */
897 if (len > count)
898 len = count;
899 rc = copy_to_user(buf, lbuf, len);
900 kfree(lbuf);
901 if (rc)
902 return -EFAULT;
903 return len;
904}
905
906/*
907 * TODO: To avoid parsing inside kernel and to improve the speed we may
908 * consider use ioctl here
909 */
910static ssize_t vga_arb_write(struct file *file, const char __user * buf,
911 size_t count, loff_t *ppos)
912{
913 struct vga_arb_private *priv = file->private_data;
914 struct vga_arb_user_card *uc = NULL;
915 struct pci_dev *pdev;
916
917 unsigned int io_state;
918
919 char *kbuf, *curr_pos;
920 size_t remaining = count;
921
922 int ret_val;
923 int i;
924
925
926 kbuf = kmalloc(count + 1, GFP_KERNEL);
927 if (!kbuf)
928 return -ENOMEM;
929
930 if (copy_from_user(kbuf, buf, count)) {
931 kfree(kbuf);
932 return -EFAULT;
933 }
934 curr_pos = kbuf;
935 kbuf[count] = '\0'; /* Just to make sure... */
936
937 if (strncmp(curr_pos, "lock ", 5) == 0) {
938 curr_pos += 5;
939 remaining -= 5;
940
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300941 pr_debug("client 0x%p called 'lock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000942
943 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
944 ret_val = -EPROTO;
945 goto done;
946 }
947 if (io_state == VGA_RSRC_NONE) {
948 ret_val = -EPROTO;
949 goto done;
950 }
951
952 pdev = priv->target;
953 if (priv->target == NULL) {
954 ret_val = -ENODEV;
955 goto done;
956 }
957
958 vga_get_uninterruptible(pdev, io_state);
959
960 /* Update the client's locks lists... */
961 for (i = 0; i < MAX_USER_CARDS; i++) {
962 if (priv->cards[i].pdev == pdev) {
963 if (io_state & VGA_RSRC_LEGACY_IO)
964 priv->cards[i].io_cnt++;
965 if (io_state & VGA_RSRC_LEGACY_MEM)
966 priv->cards[i].mem_cnt++;
967 break;
968 }
969 }
970
971 ret_val = count;
972 goto done;
973 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
974 curr_pos += 7;
975 remaining -= 7;
976
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300977 pr_debug("client 0x%p called 'unlock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000978
979 if (strncmp(curr_pos, "all", 3) == 0)
980 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
981 else {
982 if (!vga_str_to_iostate
983 (curr_pos, remaining, &io_state)) {
984 ret_val = -EPROTO;
985 goto done;
986 }
987 /* TODO: Add this?
988 if (io_state == VGA_RSRC_NONE) {
989 ret_val = -EPROTO;
990 goto done;
991 }
992 */
993 }
994
995 pdev = priv->target;
996 if (priv->target == NULL) {
997 ret_val = -ENODEV;
998 goto done;
999 }
1000 for (i = 0; i < MAX_USER_CARDS; i++) {
1001 if (priv->cards[i].pdev == pdev)
1002 uc = &priv->cards[i];
1003 }
1004
Julia Lawallc9168742011-11-15 14:53:11 -08001005 if (!uc) {
1006 ret_val = -EINVAL;
1007 goto done;
1008 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001009
Julia Lawallc9168742011-11-15 14:53:11 -08001010 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1011 ret_val = -EINVAL;
1012 goto done;
1013 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001014
Julia Lawallc9168742011-11-15 14:53:11 -08001015 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1016 ret_val = -EINVAL;
1017 goto done;
1018 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001019
1020 vga_put(pdev, io_state);
1021
1022 if (io_state & VGA_RSRC_LEGACY_IO)
1023 uc->io_cnt--;
1024 if (io_state & VGA_RSRC_LEGACY_MEM)
1025 uc->mem_cnt--;
1026
1027 ret_val = count;
1028 goto done;
1029 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1030 curr_pos += 8;
1031 remaining -= 8;
1032
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001033 pr_debug("client 0x%p called 'trylock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001034
1035 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1036 ret_val = -EPROTO;
1037 goto done;
1038 }
1039 /* TODO: Add this?
1040 if (io_state == VGA_RSRC_NONE) {
1041 ret_val = -EPROTO;
1042 goto done;
1043 }
1044 */
1045
1046 pdev = priv->target;
1047 if (priv->target == NULL) {
1048 ret_val = -ENODEV;
1049 goto done;
1050 }
1051
1052 if (vga_tryget(pdev, io_state)) {
1053 /* Update the client's locks lists... */
1054 for (i = 0; i < MAX_USER_CARDS; i++) {
1055 if (priv->cards[i].pdev == pdev) {
1056 if (io_state & VGA_RSRC_LEGACY_IO)
1057 priv->cards[i].io_cnt++;
1058 if (io_state & VGA_RSRC_LEGACY_MEM)
1059 priv->cards[i].mem_cnt++;
1060 break;
1061 }
1062 }
1063 ret_val = count;
1064 goto done;
1065 } else {
1066 ret_val = -EBUSY;
1067 goto done;
1068 }
1069
1070 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1071 unsigned int domain, bus, devfn;
1072 struct vga_device *vgadev;
1073
1074 curr_pos += 7;
1075 remaining -= 7;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001076 pr_debug("client 0x%p called 'target'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001077 /* if target is default */
Kyle McMartin2cc91162010-02-16 16:18:37 -05001078 if (!strncmp(curr_pos, "default", 7))
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001079 pdev = pci_dev_get(vga_default_device());
1080 else {
1081 if (!vga_pci_str_to_vars(curr_pos, remaining,
1082 &domain, &bus, &devfn)) {
1083 ret_val = -EPROTO;
1084 goto done;
1085 }
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001086 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
Mike Travis773a38db2010-02-02 14:38:15 -08001087 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001088
Jiang Liuf85567c2012-08-28 23:43:55 +08001089 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001090 pr_debug("vgaarb: pdev %p\n", pdev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001091 if (!pdev) {
Jiang Liuf85567c2012-08-28 23:43:55 +08001092 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1093 domain, bus, devfn);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001094 ret_val = -ENODEV;
1095 goto done;
1096 }
1097 }
1098
1099 vgadev = vgadev_find(pdev);
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001100 pr_debug("vgaarb: vgadev %p\n", vgadev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001101 if (vgadev == NULL) {
Mike Travis773a38db2010-02-02 14:38:15 -08001102 pr_err("vgaarb: this pci device is not a vga device\n");
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001103 pci_dev_put(pdev);
1104 ret_val = -ENODEV;
1105 goto done;
1106 }
1107
1108 priv->target = pdev;
1109 for (i = 0; i < MAX_USER_CARDS; i++) {
1110 if (priv->cards[i].pdev == pdev)
1111 break;
1112 if (priv->cards[i].pdev == NULL) {
1113 priv->cards[i].pdev = pdev;
1114 priv->cards[i].io_cnt = 0;
1115 priv->cards[i].mem_cnt = 0;
1116 break;
1117 }
1118 }
1119 if (i == MAX_USER_CARDS) {
Mike Travis773a38db2010-02-02 14:38:15 -08001120 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1121 MAX_USER_CARDS);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001122 pci_dev_put(pdev);
1123 /* XXX: which value to return? */
1124 ret_val = -ENOMEM;
1125 goto done;
1126 }
1127
1128 ret_val = count;
1129 pci_dev_put(pdev);
1130 goto done;
1131
1132
1133 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1134 curr_pos += 8;
1135 remaining -= 8;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001136 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001137
1138 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1139 ret_val = -EPROTO;
1140 goto done;
1141 }
1142 pdev = priv->target;
1143 if (priv->target == NULL) {
1144 ret_val = -ENODEV;
1145 goto done;
1146 }
1147
1148 __vga_set_legacy_decoding(pdev, io_state, true);
1149 ret_val = count;
1150 goto done;
1151 }
1152 /* If we got here, the message written is not part of the protocol! */
1153 kfree(kbuf);
1154 return -EPROTO;
1155
1156done:
1157 kfree(kbuf);
1158 return ret_val;
1159}
1160
1161static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1162{
1163 struct vga_arb_private *priv = file->private_data;
1164
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001165 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001166
1167 if (priv == NULL)
1168 return -ENODEV;
1169 poll_wait(file, &vga_wait_queue, wait);
1170 return POLLIN;
1171}
1172
1173static int vga_arb_open(struct inode *inode, struct file *file)
1174{
1175 struct vga_arb_private *priv;
1176 unsigned long flags;
1177
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001178 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001179
Rakib Mullickf35119d2011-07-25 17:12:56 -07001180 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001181 if (priv == NULL)
1182 return -ENOMEM;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001183 spin_lock_init(&priv->lock);
1184 file->private_data = priv;
1185
1186 spin_lock_irqsave(&vga_user_lock, flags);
1187 list_add(&priv->list, &vga_user_list);
1188 spin_unlock_irqrestore(&vga_user_lock, flags);
1189
1190 /* Set the client' lists of locks */
1191 priv->target = vga_default_device(); /* Maybe this is still null! */
1192 priv->cards[0].pdev = priv->target;
1193 priv->cards[0].io_cnt = 0;
1194 priv->cards[0].mem_cnt = 0;
1195
1196
1197 return 0;
1198}
1199
1200static int vga_arb_release(struct inode *inode, struct file *file)
1201{
1202 struct vga_arb_private *priv = file->private_data;
1203 struct vga_arb_user_card *uc;
1204 unsigned long flags;
1205 int i;
1206
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001207 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001208
1209 if (priv == NULL)
1210 return -ENODEV;
1211
1212 spin_lock_irqsave(&vga_user_lock, flags);
1213 list_del(&priv->list);
1214 for (i = 0; i < MAX_USER_CARDS; i++) {
1215 uc = &priv->cards[i];
1216 if (uc->pdev == NULL)
1217 continue;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001218 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001219 uc->io_cnt, uc->mem_cnt);
1220 while (uc->io_cnt--)
1221 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1222 while (uc->mem_cnt--)
1223 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1224 }
1225 spin_unlock_irqrestore(&vga_user_lock, flags);
1226
1227 kfree(priv);
1228
1229 return 0;
1230}
1231
1232static void vga_arb_device_card_gone(struct pci_dev *pdev)
1233{
1234}
1235
1236/*
1237 * callback any registered clients to let them know we have a
1238 * change in VGA cards
1239 */
1240static void vga_arbiter_notify_clients(void)
1241{
1242 struct vga_device *vgadev;
1243 unsigned long flags;
1244 uint32_t new_decodes;
1245 bool new_state;
1246
1247 if (!vga_arbiter_used)
1248 return;
1249
1250 spin_lock_irqsave(&vga_lock, flags);
1251 list_for_each_entry(vgadev, &vga_list, list) {
1252 if (vga_count > 1)
1253 new_state = false;
1254 else
1255 new_state = true;
1256 if (vgadev->set_vga_decode) {
1257 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1258 vga_update_device_decodes(vgadev, new_decodes);
1259 }
1260 }
1261 spin_unlock_irqrestore(&vga_lock, flags);
1262}
1263
1264static int pci_notify(struct notifier_block *nb, unsigned long action,
1265 void *data)
1266{
1267 struct device *dev = data;
1268 struct pci_dev *pdev = to_pci_dev(dev);
1269 bool notify = false;
1270
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001271 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001272
1273 /* For now we're only intereted in devices added and removed. I didn't
1274 * test this thing here, so someone needs to double check for the
1275 * cases of hotplugable vga cards. */
1276 if (action == BUS_NOTIFY_ADD_DEVICE)
1277 notify = vga_arbiter_add_pci_device(pdev);
1278 else if (action == BUS_NOTIFY_DEL_DEVICE)
1279 notify = vga_arbiter_del_pci_device(pdev);
1280
1281 if (notify)
1282 vga_arbiter_notify_clients();
1283 return 0;
1284}
1285
1286static struct notifier_block pci_notifier = {
1287 .notifier_call = pci_notify,
1288};
1289
1290static const struct file_operations vga_arb_device_fops = {
1291 .read = vga_arb_read,
1292 .write = vga_arb_write,
1293 .poll = vga_arb_fpoll,
1294 .open = vga_arb_open,
1295 .release = vga_arb_release,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001296 .llseek = noop_llseek,
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001297};
1298
1299static struct miscdevice vga_arb_device = {
1300 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1301};
1302
1303static int __init vga_arb_device_init(void)
1304{
1305 int rc;
1306 struct pci_dev *pdev;
Dave Airlie3448a192010-06-01 15:32:24 +10001307 struct vga_device *vgadev;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001308
1309 rc = misc_register(&vga_arb_device);
1310 if (rc < 0)
1311 pr_err("vgaarb: error %d registering device\n", rc);
1312
1313 bus_register_notifier(&pci_bus_type, &pci_notifier);
1314
1315 /* We add all pci devices satisfying vga class in the arbiter by
1316 * default */
1317 pdev = NULL;
1318 while ((pdev =
1319 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1320 PCI_ANY_ID, pdev)) != NULL)
1321 vga_arbiter_add_pci_device(pdev);
1322
1323 pr_info("vgaarb: loaded\n");
Dave Airlie3448a192010-06-01 15:32:24 +10001324
1325 list_for_each_entry(vgadev, &vga_list, list) {
1326 if (vgadev->bridge_has_one_vga)
1327 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1328 else
1329 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1330 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001331 return rc;
1332}
1333subsys_initcall(vga_arb_device_init);