blob: d2077f040f3ec87f0922b8eb67db413539851e53 [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
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600240 /* Ok, now check if it owns the resource we want. We can
241 * lock resources that are not decoded, therefore a device
242 * can own resources it doesn't decode.
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000243 */
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000244 match = lwants & conflict->owns;
245 if (!match)
246 continue;
247
248 /* looks like he doesn't have a lock, we can steal
249 * them from him
250 */
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000251
Dave Airlie3448a192010-06-01 15:32:24 +1000252 flags = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000253 pci_bits = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000254
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600255 /* If we can't control legacy resources via the bridge, we
256 * also need to disable normal decoding.
257 */
Dave Airlie3448a192010-06-01 15:32:24 +1000258 if (!conflict->bridge_has_one_vga) {
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600259 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_MEM)
Dave Airlie3448a192010-06-01 15:32:24 +1000260 pci_bits |= PCI_COMMAND_MEMORY;
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600261 if ((match & conflict->decodes) & VGA_RSRC_LEGACY_IO)
Dave Airlie3448a192010-06-01 15:32:24 +1000262 pci_bits |= PCI_COMMAND_IO;
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600263
264 if (pci_bits) {
265 vga_irq_set_state(conflict, false);
266 flags |= PCI_VGA_STATE_CHANGE_DECODES;
267 }
Dave Airlie3448a192010-06-01 15:32:24 +1000268 }
269
270 if (change_bridge)
271 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
272
273 pci_set_vga_state(conflict->pdev, false, pci_bits, flags);
Alex Williamsonf22d7762013-08-15 16:37:53 -0600274 conflict->owns &= ~match;
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600275
276 /* If we disabled normal decoding, reflect it in owns */
277 if (pci_bits & PCI_COMMAND_MEMORY)
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000278 conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600279 if (pci_bits & PCI_COMMAND_IO)
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000280 conflict->owns &= ~VGA_RSRC_NORMAL_IO;
281 }
282
283enable_them:
284 /* ok dude, we got it, everybody conflicting has been disabled, let's
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600285 * enable us. Mark any bits in "owns" regardless of whether we
286 * decoded them. We can lock resources we don't decode, therefore
287 * we must track them via "owns".
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000288 */
Dave Airlie3448a192010-06-01 15:32:24 +1000289 flags = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000290 pci_bits = 0;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000291
Dave Airlie3448a192010-06-01 15:32:24 +1000292 if (!vgadev->bridge_has_one_vga) {
293 flags |= PCI_VGA_STATE_CHANGE_DECODES;
294 if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
295 pci_bits |= PCI_COMMAND_MEMORY;
296 if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
297 pci_bits |= PCI_COMMAND_IO;
298 }
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600299 if (wants & VGA_RSRC_LEGACY_MASK)
Dave Airlie3448a192010-06-01 15:32:24 +1000300 flags |= PCI_VGA_STATE_CHANGE_BRIDGE;
301
302 pci_set_vga_state(vgadev->pdev, true, pci_bits, flags);
303
304 if (!vgadev->bridge_has_one_vga) {
305 vga_irq_set_state(vgadev, true);
306 }
Alex Williamson4e4e7dc2014-07-03 09:59:51 -0600307 vgadev->owns |= wants;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000308lock_them:
309 vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
310 if (rsrc & VGA_RSRC_LEGACY_IO)
311 vgadev->io_lock_cnt++;
312 if (rsrc & VGA_RSRC_LEGACY_MEM)
313 vgadev->mem_lock_cnt++;
314 if (rsrc & VGA_RSRC_NORMAL_IO)
315 vgadev->io_norm_cnt++;
316 if (rsrc & VGA_RSRC_NORMAL_MEM)
317 vgadev->mem_norm_cnt++;
318
319 return NULL;
320}
321
322static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
323{
324 unsigned int old_locks = vgadev->locks;
325
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300326 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000327
328 /* Update our counters, and account for equivalent legacy resources
329 * if we decode them
330 */
331 if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
332 vgadev->io_norm_cnt--;
333 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
334 rsrc |= VGA_RSRC_LEGACY_IO;
335 }
336 if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
337 vgadev->mem_norm_cnt--;
338 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
339 rsrc |= VGA_RSRC_LEGACY_MEM;
340 }
341 if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
342 vgadev->io_lock_cnt--;
343 if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
344 vgadev->mem_lock_cnt--;
345
346 /* Just clear lock bits, we do lazy operations so we don't really
347 * have to bother about anything else at this point
348 */
349 if (vgadev->io_lock_cnt == 0)
350 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
351 if (vgadev->mem_lock_cnt == 0)
352 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
353
354 /* Kick the wait queue in case somebody was waiting if we actually
355 * released something
356 */
357 if (old_locks != vgadev->locks)
358 wake_up_all(&vga_wait_queue);
359}
360
361int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
362{
363 struct vga_device *vgadev, *conflict;
364 unsigned long flags;
365 wait_queue_t wait;
366 int rc = 0;
367
368 vga_check_first_use();
369 /* The one who calls us should check for this, but lets be sure... */
370 if (pdev == NULL)
371 pdev = vga_default_device();
372 if (pdev == NULL)
373 return 0;
374
375 for (;;) {
376 spin_lock_irqsave(&vga_lock, flags);
377 vgadev = vgadev_find(pdev);
378 if (vgadev == NULL) {
379 spin_unlock_irqrestore(&vga_lock, flags);
380 rc = -ENODEV;
381 break;
382 }
383 conflict = __vga_tryget(vgadev, rsrc);
384 spin_unlock_irqrestore(&vga_lock, flags);
385 if (conflict == NULL)
386 break;
387
388
389 /* We have a conflict, we wait until somebody kicks the
390 * work queue. Currently we have one work queue that we
391 * kick each time some resources are released, but it would
392 * be fairly easy to have a per device one so that we only
393 * need to attach to the conflicting device
394 */
395 init_waitqueue_entry(&wait, current);
396 add_wait_queue(&vga_wait_queue, &wait);
397 set_current_state(interruptible ?
398 TASK_INTERRUPTIBLE :
399 TASK_UNINTERRUPTIBLE);
400 if (signal_pending(current)) {
401 rc = -EINTR;
402 break;
403 }
404 schedule();
405 remove_wait_queue(&vga_wait_queue, &wait);
406 set_current_state(TASK_RUNNING);
407 }
408 return rc;
409}
410EXPORT_SYMBOL(vga_get);
411
412int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
413{
414 struct vga_device *vgadev;
415 unsigned long flags;
416 int rc = 0;
417
418 vga_check_first_use();
419
420 /* The one who calls us should check for this, but lets be sure... */
421 if (pdev == NULL)
422 pdev = vga_default_device();
423 if (pdev == NULL)
424 return 0;
425 spin_lock_irqsave(&vga_lock, flags);
426 vgadev = vgadev_find(pdev);
427 if (vgadev == NULL) {
428 rc = -ENODEV;
429 goto bail;
430 }
431 if (__vga_tryget(vgadev, rsrc))
432 rc = -EBUSY;
433bail:
434 spin_unlock_irqrestore(&vga_lock, flags);
435 return rc;
436}
437EXPORT_SYMBOL(vga_tryget);
438
439void vga_put(struct pci_dev *pdev, unsigned int rsrc)
440{
441 struct vga_device *vgadev;
442 unsigned long flags;
443
444 /* The one who calls us should check for this, but lets be sure... */
445 if (pdev == NULL)
446 pdev = vga_default_device();
447 if (pdev == NULL)
448 return;
449 spin_lock_irqsave(&vga_lock, flags);
450 vgadev = vgadev_find(pdev);
451 if (vgadev == NULL)
452 goto bail;
453 __vga_put(vgadev, rsrc);
454bail:
455 spin_unlock_irqrestore(&vga_lock, flags);
456}
457EXPORT_SYMBOL(vga_put);
458
Dave Airlie3448a192010-06-01 15:32:24 +1000459/* Rules for using a bridge to control a VGA descendant decoding:
460 if a bridge has only one VGA descendant then it can be used
461 to control the VGA routing for that device.
462 It should always use the bridge closest to the device to control it.
463 If a bridge has a direct VGA descendant, but also have a sub-bridge
464 VGA descendant then we cannot use that bridge to control the direct VGA descendant.
465 So for every device we register, we need to iterate all its parent bridges
466 so we can invalidate any devices using them properly.
467*/
468static void vga_arbiter_check_bridge_sharing(struct vga_device *vgadev)
469{
470 struct vga_device *same_bridge_vgadev;
471 struct pci_bus *new_bus, *bus;
472 struct pci_dev *new_bridge, *bridge;
473
474 vgadev->bridge_has_one_vga = true;
475
476 if (list_empty(&vga_list))
477 return;
478
479 /* okay iterate the new devices bridge hierarachy */
480 new_bus = vgadev->pdev->bus;
481 while (new_bus) {
482 new_bridge = new_bus->self;
483
Dave Airlief6252112011-10-10 09:29:18 +0100484 /* go through list of devices already registered */
485 list_for_each_entry(same_bridge_vgadev, &vga_list, list) {
486 bus = same_bridge_vgadev->pdev->bus;
487 bridge = bus->self;
488
489 /* see if the share a bridge with this device */
490 if (new_bridge == bridge) {
491 /* if their direct parent bridge is the same
492 as any bridge of this device then it can't be used
493 for that device */
494 same_bridge_vgadev->bridge_has_one_vga = false;
495 }
496
497 /* now iterate the previous devices bridge hierarchy */
498 /* if the new devices parent bridge is in the other devices
499 hierarchy then we can't use it to control this device */
500 while (bus) {
Dave Airlie3448a192010-06-01 15:32:24 +1000501 bridge = bus->self;
Dave Airlief6252112011-10-10 09:29:18 +0100502 if (bridge) {
503 if (bridge == vgadev->pdev->bus->self)
504 vgadev->bridge_has_one_vga = false;
Dave Airlie3448a192010-06-01 15:32:24 +1000505 }
Dave Airlief6252112011-10-10 09:29:18 +0100506 bus = bus->parent;
Dave Airlie3448a192010-06-01 15:32:24 +1000507 }
508 }
509 new_bus = new_bus->parent;
510 }
511}
512
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000513/*
514 * Currently, we assume that the "initial" setup of the system is
515 * not sane, that is we come up with conflicting devices and let
516 * the arbiter's client decides if devices decodes or not legacy
517 * things.
518 */
519static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
520{
521 struct vga_device *vgadev;
522 unsigned long flags;
523 struct pci_bus *bus;
524 struct pci_dev *bridge;
525 u16 cmd;
526
527 /* Only deal with VGA class devices */
528 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
529 return false;
530
531 /* Allocate structure */
532 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
533 if (vgadev == NULL) {
534 pr_err("vgaarb: failed to allocate pci device\n");
535 /* What to do on allocation failure ? For now, let's
536 * just do nothing, I'm not sure there is anything saner
537 * to be done
538 */
539 return false;
540 }
541
542 memset(vgadev, 0, sizeof(*vgadev));
543
544 /* Take lock & check for duplicates */
545 spin_lock_irqsave(&vga_lock, flags);
546 if (vgadev_find(pdev) != NULL) {
547 BUG_ON(1);
548 goto fail;
549 }
550 vgadev->pdev = pdev;
551
552 /* By default, assume we decode everything */
553 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
554 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
555
556 /* by default mark it as decoding */
557 vga_decode_count++;
558 /* Mark that we "own" resources based on our enables, we will
559 * clear that below if the bridge isn't forwarding
560 */
561 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
562 if (cmd & PCI_COMMAND_IO)
563 vgadev->owns |= VGA_RSRC_LEGACY_IO;
564 if (cmd & PCI_COMMAND_MEMORY)
565 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
566
567 /* Check if VGA cycles can get down to us */
568 bus = pdev->bus;
569 while (bus) {
570 bridge = bus->self;
571 if (bridge) {
572 u16 l;
573 pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
574 &l);
575 if (!(l & PCI_BRIDGE_CTL_VGA)) {
576 vgadev->owns = 0;
577 break;
578 }
579 }
580 bus = bus->parent;
581 }
582
583 /* Deal with VGA default device. Use first enabled one
584 * by default if arch doesn't have it's own hook
585 */
586#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
587 if (vga_default == NULL &&
588 ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
Yinghai Lu84544a12012-09-19 11:54:15 -0700589 vga_set_default_device(pdev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000590#endif
591
Dave Airlie3448a192010-06-01 15:32:24 +1000592 vga_arbiter_check_bridge_sharing(vgadev);
593
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000594 /* Add to the list */
595 list_add(&vgadev->list, &vga_list);
596 vga_count++;
597 pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
598 pci_name(pdev),
599 vga_iostate_to_str(vgadev->decodes),
600 vga_iostate_to_str(vgadev->owns),
601 vga_iostate_to_str(vgadev->locks));
602
603 spin_unlock_irqrestore(&vga_lock, flags);
604 return true;
605fail:
606 spin_unlock_irqrestore(&vga_lock, flags);
607 kfree(vgadev);
608 return false;
609}
610
611static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
612{
613 struct vga_device *vgadev;
614 unsigned long flags;
615 bool ret = true;
616
617 spin_lock_irqsave(&vga_lock, flags);
618 vgadev = vgadev_find(pdev);
619 if (vgadev == NULL) {
620 ret = false;
621 goto bail;
622 }
623
Matthew Garrett1a39b312012-04-16 16:26:02 -0400624#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
Yinghai Lu84544a12012-09-19 11:54:15 -0700625 if (vga_default == pdev)
626 vga_set_default_device(NULL);
Matthew Garrett1a39b312012-04-16 16:26:02 -0400627#endif
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000628
629 if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
630 vga_decode_count--;
631
632 /* Remove entry from list */
633 list_del(&vgadev->list);
634 vga_count--;
635 /* Notify userland driver that the device is gone so it discards
636 * it's copies of the pci_dev pointer
637 */
638 vga_arb_device_card_gone(pdev);
639
640 /* Wake up all possible waiters */
641 wake_up_all(&vga_wait_queue);
642bail:
643 spin_unlock_irqrestore(&vga_lock, flags);
644 kfree(vgadev);
645 return ret;
646}
647
648/* this is called with the lock */
649static inline void vga_update_device_decodes(struct vga_device *vgadev,
650 int new_decodes)
651{
Alex Williamson5c0f6ee2013-08-15 16:37:59 -0600652 int old_decodes, decodes_removed, decodes_unlocked;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000653
654 old_decodes = vgadev->decodes;
Alex Williamson5c0f6ee2013-08-15 16:37:59 -0600655 decodes_removed = ~new_decodes & old_decodes;
656 decodes_unlocked = vgadev->locks & decodes_removed;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000657 vgadev->decodes = new_decodes;
658
659 pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
660 pci_name(vgadev->pdev),
661 vga_iostate_to_str(old_decodes),
662 vga_iostate_to_str(vgadev->decodes),
663 vga_iostate_to_str(vgadev->owns));
664
Alex Williamson5c0f6ee2013-08-15 16:37:59 -0600665 /* if we removed locked decodes, lock count goes to zero, and release */
666 if (decodes_unlocked) {
667 if (decodes_unlocked & VGA_RSRC_LEGACY_IO)
668 vgadev->io_lock_cnt = 0;
669 if (decodes_unlocked & VGA_RSRC_LEGACY_MEM)
670 vgadev->mem_lock_cnt = 0;
671 __vga_put(vgadev, decodes_unlocked);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000672 }
673
674 /* change decodes counter */
Alex Williamson5c0f6ee2013-08-15 16:37:59 -0600675 if (old_decodes & VGA_RSRC_LEGACY_MASK &&
676 !(new_decodes & VGA_RSRC_LEGACY_MASK))
677 vga_decode_count--;
678 if (!(old_decodes & VGA_RSRC_LEGACY_MASK) &&
679 new_decodes & VGA_RSRC_LEGACY_MASK)
680 vga_decode_count++;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300681 pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000682}
683
Daniel J Blueman201ba4c2010-09-22 18:05:35 +0100684static void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000685{
686 struct vga_device *vgadev;
687 unsigned long flags;
688
689 decodes &= VGA_RSRC_LEGACY_MASK;
690
691 spin_lock_irqsave(&vga_lock, flags);
692 vgadev = vgadev_find(pdev);
693 if (vgadev == NULL)
694 goto bail;
695
696 /* don't let userspace futz with kernel driver decodes */
697 if (userspace && vgadev->set_vga_decode)
698 goto bail;
699
700 /* update the device decodes + counter */
701 vga_update_device_decodes(vgadev, decodes);
702
703 /* XXX if somebody is going from "doesn't decode" to "decodes" state
704 * here, additional care must be taken as we may have pending owner
705 * ship of non-legacy region ...
706 */
707bail:
708 spin_unlock_irqrestore(&vga_lock, flags);
709}
710
711void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
712{
713 __vga_set_legacy_decoding(pdev, decodes, false);
714}
715EXPORT_SYMBOL(vga_set_legacy_decoding);
716
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000717/* call with NULL to unregister */
718int vga_client_register(struct pci_dev *pdev, void *cookie,
719 void (*irq_set_state)(void *cookie, bool state),
720 unsigned int (*set_vga_decode)(void *cookie, bool decode))
721{
Chris Wilson934f992c2011-01-20 13:09:12 +0000722 int ret = -ENODEV;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000723 struct vga_device *vgadev;
724 unsigned long flags;
725
726 spin_lock_irqsave(&vga_lock, flags);
727 vgadev = vgadev_find(pdev);
728 if (!vgadev)
729 goto bail;
730
731 vgadev->irq_set_state = irq_set_state;
732 vgadev->set_vga_decode = set_vga_decode;
733 vgadev->cookie = cookie;
734 ret = 0;
735
736bail:
737 spin_unlock_irqrestore(&vga_lock, flags);
738 return ret;
739
740}
741EXPORT_SYMBOL(vga_client_register);
742
743/*
744 * Char driver implementation
745 *
746 * Semantics is:
747 *
748 * open : open user instance of the arbitrer. by default, it's
749 * attached to the default VGA device of the system.
750 *
751 * close : close user instance, release locks
752 *
753 * read : return a string indicating the status of the target.
754 * an IO state string is of the form {io,mem,io+mem,none},
755 * mc and ic are respectively mem and io lock counts (for
756 * debugging/diagnostic only). "decodes" indicate what the
757 * card currently decodes, "owns" indicates what is currently
758 * enabled on it, and "locks" indicates what is locked by this
759 * card. If the card is unplugged, we get "invalid" then for
760 * card_ID and an -ENODEV error is returned for any command
761 * until a new card is targeted
762 *
763 * "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
764 *
765 * write : write a command to the arbiter. List of commands is:
766 *
767 * target <card_ID> : switch target to card <card_ID> (see below)
768 * lock <io_state> : acquires locks on target ("none" is invalid io_state)
769 * trylock <io_state> : non-blocking acquire locks on target
770 * unlock <io_state> : release locks on target
771 * unlock all : release all locks on target held by this user
772 * decodes <io_state> : set the legacy decoding attributes for the card
773 *
774 * poll : event if something change on any card (not just the target)
775 *
776 * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
777 * to go back to the system default card (TODO: not implemented yet).
778 * Currently, only PCI is supported as a prefix, but the userland API may
779 * support other bus types in the future, even if the current kernel
780 * implementation doesn't.
781 *
782 * Note about locks:
783 *
784 * The driver keeps track of which user has what locks on which card. It
785 * supports stacking, like the kernel one. This complexifies the implementation
786 * a bit, but makes the arbiter more tolerant to userspace problems and able
787 * to properly cleanup in all cases when a process dies.
788 * Currently, a max of 16 cards simultaneously can have locks issued from
789 * userspace for a given user (file descriptor instance) of the arbiter.
790 *
791 * If the device is hot-unplugged, there is a hook inside the module to notify
792 * they being added/removed in the system and automatically added/removed in
793 * the arbiter.
794 */
795
Mike Travis36028f32010-02-02 17:45:01 -0800796#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000797#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
798
799/*
800 * Each user has an array of these, tracking which cards have locks
801 */
802struct vga_arb_user_card {
803 struct pci_dev *pdev;
804 unsigned int mem_cnt;
805 unsigned int io_cnt;
806};
807
808struct vga_arb_private {
809 struct list_head list;
810 struct pci_dev *target;
811 struct vga_arb_user_card cards[MAX_USER_CARDS];
812 spinlock_t lock;
813};
814
815static LIST_HEAD(vga_user_list);
816static DEFINE_SPINLOCK(vga_user_lock);
817
818
819/*
820 * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
821 * returns the respective values. If the string is not in this format,
822 * it returns 0.
823 */
824static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
825 unsigned int *bus, unsigned int *devfn)
826{
827 int n;
828 unsigned int slot, func;
829
830
831 n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
832 if (n != 4)
833 return 0;
834
835 *devfn = PCI_DEVFN(slot, func);
836
837 return 1;
838}
839
840static ssize_t vga_arb_read(struct file *file, char __user * buf,
841 size_t count, loff_t *ppos)
842{
843 struct vga_arb_private *priv = file->private_data;
844 struct vga_device *vgadev;
845 struct pci_dev *pdev;
846 unsigned long flags;
847 size_t len;
848 int rc;
849 char *lbuf;
850
851 lbuf = kmalloc(1024, GFP_KERNEL);
852 if (lbuf == NULL)
853 return -ENOMEM;
854
855 /* Shields against vga_arb_device_card_gone (pci_dev going
856 * away), and allows access to vga list
857 */
858 spin_lock_irqsave(&vga_lock, flags);
859
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300860 /* If we are targeting the default, use it */
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000861 pdev = priv->target;
862 if (pdev == NULL || pdev == PCI_INVALID_CARD) {
863 spin_unlock_irqrestore(&vga_lock, flags);
864 len = sprintf(lbuf, "invalid");
865 goto done;
866 }
867
868 /* Find card vgadev structure */
869 vgadev = vgadev_find(pdev);
870 if (vgadev == NULL) {
871 /* Wow, it's not in the list, that shouldn't happen,
872 * let's fix us up and return invalid card
873 */
874 if (pdev == priv->target)
875 vga_arb_device_card_gone(pdev);
876 spin_unlock_irqrestore(&vga_lock, flags);
877 len = sprintf(lbuf, "invalid");
878 goto done;
879 }
880
881 /* Fill the buffer with infos */
882 len = snprintf(lbuf, 1024,
883 "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
884 vga_decode_count, pci_name(pdev),
885 vga_iostate_to_str(vgadev->decodes),
886 vga_iostate_to_str(vgadev->owns),
887 vga_iostate_to_str(vgadev->locks),
888 vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
889
890 spin_unlock_irqrestore(&vga_lock, flags);
891done:
892
893 /* Copy that to user */
894 if (len > count)
895 len = count;
896 rc = copy_to_user(buf, lbuf, len);
897 kfree(lbuf);
898 if (rc)
899 return -EFAULT;
900 return len;
901}
902
903/*
904 * TODO: To avoid parsing inside kernel and to improve the speed we may
905 * consider use ioctl here
906 */
907static ssize_t vga_arb_write(struct file *file, const char __user * buf,
908 size_t count, loff_t *ppos)
909{
910 struct vga_arb_private *priv = file->private_data;
911 struct vga_arb_user_card *uc = NULL;
912 struct pci_dev *pdev;
913
914 unsigned int io_state;
915
916 char *kbuf, *curr_pos;
917 size_t remaining = count;
918
919 int ret_val;
920 int i;
921
922
923 kbuf = kmalloc(count + 1, GFP_KERNEL);
924 if (!kbuf)
925 return -ENOMEM;
926
927 if (copy_from_user(kbuf, buf, count)) {
928 kfree(kbuf);
929 return -EFAULT;
930 }
931 curr_pos = kbuf;
932 kbuf[count] = '\0'; /* Just to make sure... */
933
934 if (strncmp(curr_pos, "lock ", 5) == 0) {
935 curr_pos += 5;
936 remaining -= 5;
937
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300938 pr_debug("client 0x%p called 'lock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000939
940 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
941 ret_val = -EPROTO;
942 goto done;
943 }
944 if (io_state == VGA_RSRC_NONE) {
945 ret_val = -EPROTO;
946 goto done;
947 }
948
949 pdev = priv->target;
950 if (priv->target == NULL) {
951 ret_val = -ENODEV;
952 goto done;
953 }
954
955 vga_get_uninterruptible(pdev, io_state);
956
957 /* Update the client's locks lists... */
958 for (i = 0; i < MAX_USER_CARDS; i++) {
959 if (priv->cards[i].pdev == pdev) {
960 if (io_state & VGA_RSRC_LEGACY_IO)
961 priv->cards[i].io_cnt++;
962 if (io_state & VGA_RSRC_LEGACY_MEM)
963 priv->cards[i].mem_cnt++;
964 break;
965 }
966 }
967
968 ret_val = count;
969 goto done;
970 } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
971 curr_pos += 7;
972 remaining -= 7;
973
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +0300974 pr_debug("client 0x%p called 'unlock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +1000975
976 if (strncmp(curr_pos, "all", 3) == 0)
977 io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
978 else {
979 if (!vga_str_to_iostate
980 (curr_pos, remaining, &io_state)) {
981 ret_val = -EPROTO;
982 goto done;
983 }
984 /* TODO: Add this?
985 if (io_state == VGA_RSRC_NONE) {
986 ret_val = -EPROTO;
987 goto done;
988 }
989 */
990 }
991
992 pdev = priv->target;
993 if (priv->target == NULL) {
994 ret_val = -ENODEV;
995 goto done;
996 }
997 for (i = 0; i < MAX_USER_CARDS; i++) {
998 if (priv->cards[i].pdev == pdev)
999 uc = &priv->cards[i];
1000 }
1001
Julia Lawallc9168742011-11-15 14:53:11 -08001002 if (!uc) {
1003 ret_val = -EINVAL;
1004 goto done;
1005 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001006
Julia Lawallc9168742011-11-15 14:53:11 -08001007 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1008 ret_val = -EINVAL;
1009 goto done;
1010 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001011
Julia Lawallc9168742011-11-15 14:53:11 -08001012 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1013 ret_val = -EINVAL;
1014 goto done;
1015 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001016
1017 vga_put(pdev, io_state);
1018
1019 if (io_state & VGA_RSRC_LEGACY_IO)
1020 uc->io_cnt--;
1021 if (io_state & VGA_RSRC_LEGACY_MEM)
1022 uc->mem_cnt--;
1023
1024 ret_val = count;
1025 goto done;
1026 } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1027 curr_pos += 8;
1028 remaining -= 8;
1029
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001030 pr_debug("client 0x%p called 'trylock'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001031
1032 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1033 ret_val = -EPROTO;
1034 goto done;
1035 }
1036 /* TODO: Add this?
1037 if (io_state == VGA_RSRC_NONE) {
1038 ret_val = -EPROTO;
1039 goto done;
1040 }
1041 */
1042
1043 pdev = priv->target;
1044 if (priv->target == NULL) {
1045 ret_val = -ENODEV;
1046 goto done;
1047 }
1048
1049 if (vga_tryget(pdev, io_state)) {
1050 /* Update the client's locks lists... */
1051 for (i = 0; i < MAX_USER_CARDS; i++) {
1052 if (priv->cards[i].pdev == pdev) {
1053 if (io_state & VGA_RSRC_LEGACY_IO)
1054 priv->cards[i].io_cnt++;
1055 if (io_state & VGA_RSRC_LEGACY_MEM)
1056 priv->cards[i].mem_cnt++;
1057 break;
1058 }
1059 }
1060 ret_val = count;
1061 goto done;
1062 } else {
1063 ret_val = -EBUSY;
1064 goto done;
1065 }
1066
1067 } else if (strncmp(curr_pos, "target ", 7) == 0) {
1068 unsigned int domain, bus, devfn;
1069 struct vga_device *vgadev;
1070
1071 curr_pos += 7;
1072 remaining -= 7;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001073 pr_debug("client 0x%p called 'target'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001074 /* if target is default */
Kyle McMartin2cc91162010-02-16 16:18:37 -05001075 if (!strncmp(curr_pos, "default", 7))
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001076 pdev = pci_dev_get(vga_default_device());
1077 else {
1078 if (!vga_pci_str_to_vars(curr_pos, remaining,
1079 &domain, &bus, &devfn)) {
1080 ret_val = -EPROTO;
1081 goto done;
1082 }
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001083 pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
Mike Travis773a38db2010-02-02 14:38:15 -08001084 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001085
Jiang Liuf85567c2012-08-28 23:43:55 +08001086 pdev = pci_get_domain_bus_and_slot(domain, bus, devfn);
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001087 pr_debug("vgaarb: pdev %p\n", pdev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001088 if (!pdev) {
Jiang Liuf85567c2012-08-28 23:43:55 +08001089 pr_err("vgaarb: invalid PCI address %x:%x:%x\n",
1090 domain, bus, devfn);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001091 ret_val = -ENODEV;
1092 goto done;
1093 }
1094 }
1095
1096 vgadev = vgadev_find(pdev);
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001097 pr_debug("vgaarb: vgadev %p\n", vgadev);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001098 if (vgadev == NULL) {
Mike Travis773a38db2010-02-02 14:38:15 -08001099 pr_err("vgaarb: this pci device is not a vga device\n");
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001100 pci_dev_put(pdev);
1101 ret_val = -ENODEV;
1102 goto done;
1103 }
1104
1105 priv->target = pdev;
1106 for (i = 0; i < MAX_USER_CARDS; i++) {
1107 if (priv->cards[i].pdev == pdev)
1108 break;
1109 if (priv->cards[i].pdev == NULL) {
1110 priv->cards[i].pdev = pdev;
1111 priv->cards[i].io_cnt = 0;
1112 priv->cards[i].mem_cnt = 0;
1113 break;
1114 }
1115 }
1116 if (i == MAX_USER_CARDS) {
Mike Travis773a38db2010-02-02 14:38:15 -08001117 pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1118 MAX_USER_CARDS);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001119 pci_dev_put(pdev);
1120 /* XXX: which value to return? */
1121 ret_val = -ENOMEM;
1122 goto done;
1123 }
1124
1125 ret_val = count;
1126 pci_dev_put(pdev);
1127 goto done;
1128
1129
1130 } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1131 curr_pos += 8;
1132 remaining -= 8;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001133 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001134
1135 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1136 ret_val = -EPROTO;
1137 goto done;
1138 }
1139 pdev = priv->target;
1140 if (priv->target == NULL) {
1141 ret_val = -ENODEV;
1142 goto done;
1143 }
1144
1145 __vga_set_legacy_decoding(pdev, io_state, true);
1146 ret_val = count;
1147 goto done;
1148 }
1149 /* If we got here, the message written is not part of the protocol! */
1150 kfree(kbuf);
1151 return -EPROTO;
1152
1153done:
1154 kfree(kbuf);
1155 return ret_val;
1156}
1157
1158static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1159{
1160 struct vga_arb_private *priv = file->private_data;
1161
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001162 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001163
1164 if (priv == NULL)
1165 return -ENODEV;
1166 poll_wait(file, &vga_wait_queue, wait);
1167 return POLLIN;
1168}
1169
1170static int vga_arb_open(struct inode *inode, struct file *file)
1171{
1172 struct vga_arb_private *priv;
1173 unsigned long flags;
1174
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001175 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001176
Rakib Mullickf35119d2011-07-25 17:12:56 -07001177 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001178 if (priv == NULL)
1179 return -ENOMEM;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001180 spin_lock_init(&priv->lock);
1181 file->private_data = priv;
1182
1183 spin_lock_irqsave(&vga_user_lock, flags);
1184 list_add(&priv->list, &vga_user_list);
1185 spin_unlock_irqrestore(&vga_user_lock, flags);
1186
1187 /* Set the client' lists of locks */
1188 priv->target = vga_default_device(); /* Maybe this is still null! */
1189 priv->cards[0].pdev = priv->target;
1190 priv->cards[0].io_cnt = 0;
1191 priv->cards[0].mem_cnt = 0;
1192
1193
1194 return 0;
1195}
1196
1197static int vga_arb_release(struct inode *inode, struct file *file)
1198{
1199 struct vga_arb_private *priv = file->private_data;
1200 struct vga_arb_user_card *uc;
1201 unsigned long flags;
1202 int i;
1203
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001204 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001205
1206 if (priv == NULL)
1207 return -ENODEV;
1208
1209 spin_lock_irqsave(&vga_user_lock, flags);
1210 list_del(&priv->list);
1211 for (i = 0; i < MAX_USER_CARDS; i++) {
1212 uc = &priv->cards[i];
1213 if (uc->pdev == NULL)
1214 continue;
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001215 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001216 uc->io_cnt, uc->mem_cnt);
1217 while (uc->io_cnt--)
1218 vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1219 while (uc->mem_cnt--)
1220 vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1221 }
1222 spin_unlock_irqrestore(&vga_user_lock, flags);
1223
1224 kfree(priv);
1225
1226 return 0;
1227}
1228
1229static void vga_arb_device_card_gone(struct pci_dev *pdev)
1230{
1231}
1232
1233/*
1234 * callback any registered clients to let them know we have a
1235 * change in VGA cards
1236 */
1237static void vga_arbiter_notify_clients(void)
1238{
1239 struct vga_device *vgadev;
1240 unsigned long flags;
1241 uint32_t new_decodes;
1242 bool new_state;
1243
1244 if (!vga_arbiter_used)
1245 return;
1246
1247 spin_lock_irqsave(&vga_lock, flags);
1248 list_for_each_entry(vgadev, &vga_list, list) {
1249 if (vga_count > 1)
1250 new_state = false;
1251 else
1252 new_state = true;
1253 if (vgadev->set_vga_decode) {
1254 new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1255 vga_update_device_decodes(vgadev, new_decodes);
1256 }
1257 }
1258 spin_unlock_irqrestore(&vga_lock, flags);
1259}
1260
1261static int pci_notify(struct notifier_block *nb, unsigned long action,
1262 void *data)
1263{
1264 struct device *dev = data;
1265 struct pci_dev *pdev = to_pci_dev(dev);
1266 bool notify = false;
1267
Tiago Vignatti2d6e9b92010-05-24 18:24:30 +03001268 pr_debug("%s\n", __func__);
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001269
1270 /* For now we're only intereted in devices added and removed. I didn't
1271 * test this thing here, so someone needs to double check for the
1272 * cases of hotplugable vga cards. */
1273 if (action == BUS_NOTIFY_ADD_DEVICE)
1274 notify = vga_arbiter_add_pci_device(pdev);
1275 else if (action == BUS_NOTIFY_DEL_DEVICE)
1276 notify = vga_arbiter_del_pci_device(pdev);
1277
1278 if (notify)
1279 vga_arbiter_notify_clients();
1280 return 0;
1281}
1282
1283static struct notifier_block pci_notifier = {
1284 .notifier_call = pci_notify,
1285};
1286
1287static const struct file_operations vga_arb_device_fops = {
1288 .read = vga_arb_read,
1289 .write = vga_arb_write,
1290 .poll = vga_arb_fpoll,
1291 .open = vga_arb_open,
1292 .release = vga_arb_release,
Arnd Bergmann6038f372010-08-15 18:52:59 +02001293 .llseek = noop_llseek,
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001294};
1295
1296static struct miscdevice vga_arb_device = {
1297 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1298};
1299
1300static int __init vga_arb_device_init(void)
1301{
1302 int rc;
1303 struct pci_dev *pdev;
Dave Airlie3448a192010-06-01 15:32:24 +10001304 struct vga_device *vgadev;
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001305
1306 rc = misc_register(&vga_arb_device);
1307 if (rc < 0)
1308 pr_err("vgaarb: error %d registering device\n", rc);
1309
1310 bus_register_notifier(&pci_bus_type, &pci_notifier);
1311
1312 /* We add all pci devices satisfying vga class in the arbiter by
1313 * default */
1314 pdev = NULL;
1315 while ((pdev =
1316 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1317 PCI_ANY_ID, pdev)) != NULL)
1318 vga_arbiter_add_pci_device(pdev);
1319
1320 pr_info("vgaarb: loaded\n");
Dave Airlie3448a192010-06-01 15:32:24 +10001321
1322 list_for_each_entry(vgadev, &vga_list, list) {
1323 if (vgadev->bridge_has_one_vga)
1324 pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1325 else
1326 pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1327 }
Benjamin Herrenschmidtdeb2d2e2009-08-11 15:52:06 +10001328 return rc;
1329}
1330subsys_initcall(vga_arb_device_init);