llseek: automatically add .llseek fop
[linux-2.6.git] / drivers / gpu / vga / vgaarb.c
1 /*
2  * vgaarb.c: Implements the VGA arbitration. For details refer to
3  * Documentation/vgaarbiter.txt
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 #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>
43 #include <linux/slab.h>
44
45 #include <linux/uaccess.h>
46
47 #include <linux/vgaarb.h>
48
49 static 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  */
54 struct 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 */
64
65         /* 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
71 static LIST_HEAD(vga_list);
72 static int vga_count, vga_decode_count;
73 static bool vga_arbiter_used;
74 static DEFINE_SPINLOCK(vga_lock);
75 static DECLARE_WAIT_QUEUE_HEAD(vga_wait_queue);
76
77
78 static 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
93 static 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;
110 both:
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 */
117 static struct pci_dev *vga_default;
118 #endif
119
120 static void vga_arb_device_card_gone(struct pci_dev *pdev);
121
122 /* Find somebody in our list */
123 static 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
135 struct pci_dev *vga_default_device(void)
136 {
137         return vga_default;
138 }
139 #endif
140
141 static inline void vga_irq_set_state(struct vga_device *vgadev, bool state)
142 {
143         if (vgadev->irq_set_state)
144                 vgadev->irq_set_state(vgadev->cookie, state);
145 }
146
147
148 /* If we don't ever use VGA arb we should avoid
149    turning off anything anywhere due to old X servers getting
150    confused about the boot device not being VGA */
151 static void vga_check_first_use(void)
152 {
153         /* we should inform all GPUs in the system that
154          * VGA arb has occured and to try and disable resources
155          * if they can */
156         if (!vga_arbiter_used) {
157                 vga_arbiter_used = true;
158                 vga_arbiter_notify_clients();
159         }
160 }
161
162 static struct vga_device *__vga_tryget(struct vga_device *vgadev,
163                                        unsigned int rsrc)
164 {
165         unsigned int wants, legacy_wants, match;
166         struct vga_device *conflict;
167         unsigned int pci_bits;
168         /* Account for "normal" resources to lock. If we decode the legacy,
169          * counterpart, we need to request it as well
170          */
171         if ((rsrc & VGA_RSRC_NORMAL_IO) &&
172             (vgadev->decodes & VGA_RSRC_LEGACY_IO))
173                 rsrc |= VGA_RSRC_LEGACY_IO;
174         if ((rsrc & VGA_RSRC_NORMAL_MEM) &&
175             (vgadev->decodes & VGA_RSRC_LEGACY_MEM))
176                 rsrc |= VGA_RSRC_LEGACY_MEM;
177
178         pr_debug("%s: %d\n", __func__, rsrc);
179         pr_debug("%s: owns: %d\n", __func__, vgadev->owns);
180
181         /* Check what resources we need to acquire */
182         wants = rsrc & ~vgadev->owns;
183
184         /* We already own everything, just mark locked & bye bye */
185         if (wants == 0)
186                 goto lock_them;
187
188         /* We don't need to request a legacy resource, we just enable
189          * appropriate decoding and go
190          */
191         legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
192         if (legacy_wants == 0)
193                 goto enable_them;
194
195         /* Ok, we don't, let's find out how we need to kick off */
196         list_for_each_entry(conflict, &vga_list, list) {
197                 unsigned int lwants = legacy_wants;
198                 unsigned int change_bridge = 0;
199
200                 /* Don't conflict with myself */
201                 if (vgadev == conflict)
202                         continue;
203
204                 /* Check if the architecture allows a conflict between those
205                  * 2 devices or if they are on separate domains
206                  */
207                 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
208                         continue;
209
210                 /* We have a possible conflict. before we go further, we must
211                  * check if we sit on the same bus as the conflicting device.
212                  * if we don't, then we must tie both IO and MEM resources
213                  * together since there is only a single bit controlling
214                  * VGA forwarding on P2P bridges
215                  */
216                 if (vgadev->pdev->bus != conflict->pdev->bus) {
217                         change_bridge = 1;
218                         lwants = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
219                 }
220
221                 /* Check if the guy has a lock on the resource. If he does,
222                  * return the conflicting entry
223                  */
224                 if (conflict->locks & lwants)
225                         return conflict;
226
227                 /* Ok, now check if he owns the resource we want. We don't need
228                  * to check "decodes" since it should be impossible to own
229                  * own legacy resources you don't decode unless I have a bug
230                  * in this code...
231                  */
232                 WARN_ON(conflict->owns & ~conflict->decodes);
233                 match = lwants & conflict->owns;
234                 if (!match)
235                         continue;
236
237                 /* looks like he doesn't have a lock, we can steal
238                  * them from him
239                  */
240                 vga_irq_set_state(conflict, false);
241
242                 pci_bits = 0;
243                 if (lwants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
244                         pci_bits |= PCI_COMMAND_MEMORY;
245                 if (lwants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
246                         pci_bits |= PCI_COMMAND_IO;
247
248                 pci_set_vga_state(conflict->pdev, false, pci_bits,
249                                   change_bridge);
250                 conflict->owns &= ~lwants;
251                 /* If he also owned non-legacy, that is no longer the case */
252                 if (lwants & VGA_RSRC_LEGACY_MEM)
253                         conflict->owns &= ~VGA_RSRC_NORMAL_MEM;
254                 if (lwants & VGA_RSRC_LEGACY_IO)
255                         conflict->owns &= ~VGA_RSRC_NORMAL_IO;
256         }
257
258 enable_them:
259         /* ok dude, we got it, everybody conflicting has been disabled, let's
260          * enable us. Make sure we don't mark a bit in "owns" that we don't
261          * also have in "decodes". We can lock resources we don't decode but
262          * not own them.
263          */
264         pci_bits = 0;
265         if (wants & (VGA_RSRC_LEGACY_MEM|VGA_RSRC_NORMAL_MEM))
266                 pci_bits |= PCI_COMMAND_MEMORY;
267         if (wants & (VGA_RSRC_LEGACY_IO|VGA_RSRC_NORMAL_IO))
268                 pci_bits |= PCI_COMMAND_IO;
269         pci_set_vga_state(vgadev->pdev, true, pci_bits, !!(wants & VGA_RSRC_LEGACY_MASK));
270
271         vga_irq_set_state(vgadev, true);
272         vgadev->owns |= (wants & vgadev->decodes);
273 lock_them:
274         vgadev->locks |= (rsrc & VGA_RSRC_LEGACY_MASK);
275         if (rsrc & VGA_RSRC_LEGACY_IO)
276                 vgadev->io_lock_cnt++;
277         if (rsrc & VGA_RSRC_LEGACY_MEM)
278                 vgadev->mem_lock_cnt++;
279         if (rsrc & VGA_RSRC_NORMAL_IO)
280                 vgadev->io_norm_cnt++;
281         if (rsrc & VGA_RSRC_NORMAL_MEM)
282                 vgadev->mem_norm_cnt++;
283
284         return NULL;
285 }
286
287 static void __vga_put(struct vga_device *vgadev, unsigned int rsrc)
288 {
289         unsigned int old_locks = vgadev->locks;
290
291         pr_debug("%s\n", __func__);
292
293         /* Update our counters, and account for equivalent legacy resources
294          * if we decode them
295          */
296         if ((rsrc & VGA_RSRC_NORMAL_IO) && vgadev->io_norm_cnt > 0) {
297                 vgadev->io_norm_cnt--;
298                 if (vgadev->decodes & VGA_RSRC_LEGACY_IO)
299                         rsrc |= VGA_RSRC_LEGACY_IO;
300         }
301         if ((rsrc & VGA_RSRC_NORMAL_MEM) && vgadev->mem_norm_cnt > 0) {
302                 vgadev->mem_norm_cnt--;
303                 if (vgadev->decodes & VGA_RSRC_LEGACY_MEM)
304                         rsrc |= VGA_RSRC_LEGACY_MEM;
305         }
306         if ((rsrc & VGA_RSRC_LEGACY_IO) && vgadev->io_lock_cnt > 0)
307                 vgadev->io_lock_cnt--;
308         if ((rsrc & VGA_RSRC_LEGACY_MEM) && vgadev->mem_lock_cnt > 0)
309                 vgadev->mem_lock_cnt--;
310
311         /* Just clear lock bits, we do lazy operations so we don't really
312          * have to bother about anything else at this point
313          */
314         if (vgadev->io_lock_cnt == 0)
315                 vgadev->locks &= ~VGA_RSRC_LEGACY_IO;
316         if (vgadev->mem_lock_cnt == 0)
317                 vgadev->locks &= ~VGA_RSRC_LEGACY_MEM;
318
319         /* Kick the wait queue in case somebody was waiting if we actually
320          * released something
321          */
322         if (old_locks != vgadev->locks)
323                 wake_up_all(&vga_wait_queue);
324 }
325
326 int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible)
327 {
328         struct vga_device *vgadev, *conflict;
329         unsigned long flags;
330         wait_queue_t wait;
331         int rc = 0;
332
333         vga_check_first_use();
334         /* The one who calls us should check for this, but lets be sure... */
335         if (pdev == NULL)
336                 pdev = vga_default_device();
337         if (pdev == NULL)
338                 return 0;
339
340         for (;;) {
341                 spin_lock_irqsave(&vga_lock, flags);
342                 vgadev = vgadev_find(pdev);
343                 if (vgadev == NULL) {
344                         spin_unlock_irqrestore(&vga_lock, flags);
345                         rc = -ENODEV;
346                         break;
347                 }
348                 conflict = __vga_tryget(vgadev, rsrc);
349                 spin_unlock_irqrestore(&vga_lock, flags);
350                 if (conflict == NULL)
351                         break;
352
353
354                 /* We have a conflict, we wait until somebody kicks the
355                  * work queue. Currently we have one work queue that we
356                  * kick each time some resources are released, but it would
357                  * be fairly easy to have a per device one so that we only
358                  * need to attach to the conflicting device
359                  */
360                 init_waitqueue_entry(&wait, current);
361                 add_wait_queue(&vga_wait_queue, &wait);
362                 set_current_state(interruptible ?
363                                   TASK_INTERRUPTIBLE :
364                                   TASK_UNINTERRUPTIBLE);
365                 if (signal_pending(current)) {
366                         rc = -EINTR;
367                         break;
368                 }
369                 schedule();
370                 remove_wait_queue(&vga_wait_queue, &wait);
371                 set_current_state(TASK_RUNNING);
372         }
373         return rc;
374 }
375 EXPORT_SYMBOL(vga_get);
376
377 int vga_tryget(struct pci_dev *pdev, unsigned int rsrc)
378 {
379         struct vga_device *vgadev;
380         unsigned long flags;
381         int rc = 0;
382
383         vga_check_first_use();
384
385         /* The one who calls us should check for this, but lets be sure... */
386         if (pdev == NULL)
387                 pdev = vga_default_device();
388         if (pdev == NULL)
389                 return 0;
390         spin_lock_irqsave(&vga_lock, flags);
391         vgadev = vgadev_find(pdev);
392         if (vgadev == NULL) {
393                 rc = -ENODEV;
394                 goto bail;
395         }
396         if (__vga_tryget(vgadev, rsrc))
397                 rc = -EBUSY;
398 bail:
399         spin_unlock_irqrestore(&vga_lock, flags);
400         return rc;
401 }
402 EXPORT_SYMBOL(vga_tryget);
403
404 void vga_put(struct pci_dev *pdev, unsigned int rsrc)
405 {
406         struct vga_device *vgadev;
407         unsigned long flags;
408
409         /* The one who calls us should check for this, but lets be sure... */
410         if (pdev == NULL)
411                 pdev = vga_default_device();
412         if (pdev == NULL)
413                 return;
414         spin_lock_irqsave(&vga_lock, flags);
415         vgadev = vgadev_find(pdev);
416         if (vgadev == NULL)
417                 goto bail;
418         __vga_put(vgadev, rsrc);
419 bail:
420         spin_unlock_irqrestore(&vga_lock, flags);
421 }
422 EXPORT_SYMBOL(vga_put);
423
424 /*
425  * Currently, we assume that the "initial" setup of the system is
426  * not sane, that is we come up with conflicting devices and let
427  * the arbiter's client decides if devices decodes or not legacy
428  * things.
429  */
430 static bool vga_arbiter_add_pci_device(struct pci_dev *pdev)
431 {
432         struct vga_device *vgadev;
433         unsigned long flags;
434         struct pci_bus *bus;
435         struct pci_dev *bridge;
436         u16 cmd;
437
438         /* Only deal with VGA class devices */
439         if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
440                 return false;
441
442         /* Allocate structure */
443         vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
444         if (vgadev == NULL) {
445                 pr_err("vgaarb: failed to allocate pci device\n");
446                 /* What to do on allocation failure ? For now, let's
447                  * just do nothing, I'm not sure there is anything saner
448                  * to be done
449                  */
450                 return false;
451         }
452
453         memset(vgadev, 0, sizeof(*vgadev));
454
455         /* Take lock & check for duplicates */
456         spin_lock_irqsave(&vga_lock, flags);
457         if (vgadev_find(pdev) != NULL) {
458                 BUG_ON(1);
459                 goto fail;
460         }
461         vgadev->pdev = pdev;
462
463         /* By default, assume we decode everything */
464         vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
465                           VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
466
467         /* by default mark it as decoding */
468         vga_decode_count++;
469         /* Mark that we "own" resources based on our enables, we will
470          * clear that below if the bridge isn't forwarding
471          */
472         pci_read_config_word(pdev, PCI_COMMAND, &cmd);
473         if (cmd & PCI_COMMAND_IO)
474                 vgadev->owns |= VGA_RSRC_LEGACY_IO;
475         if (cmd & PCI_COMMAND_MEMORY)
476                 vgadev->owns |= VGA_RSRC_LEGACY_MEM;
477
478         /* Check if VGA cycles can get down to us */
479         bus = pdev->bus;
480         while (bus) {
481                 bridge = bus->self;
482                 if (bridge) {
483                         u16 l;
484                         pci_read_config_word(bridge, PCI_BRIDGE_CONTROL,
485                                              &l);
486                         if (!(l & PCI_BRIDGE_CTL_VGA)) {
487                                 vgadev->owns = 0;
488                                 break;
489                         }
490                 }
491                 bus = bus->parent;
492         }
493
494         /* Deal with VGA default device. Use first enabled one
495          * by default if arch doesn't have it's own hook
496          */
497 #ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
498         if (vga_default == NULL &&
499             ((vgadev->owns & VGA_RSRC_LEGACY_MASK) == VGA_RSRC_LEGACY_MASK))
500                 vga_default = pci_dev_get(pdev);
501 #endif
502
503         /* Add to the list */
504         list_add(&vgadev->list, &vga_list);
505         vga_count++;
506         pr_info("vgaarb: device added: PCI:%s,decodes=%s,owns=%s,locks=%s\n",
507                 pci_name(pdev),
508                 vga_iostate_to_str(vgadev->decodes),
509                 vga_iostate_to_str(vgadev->owns),
510                 vga_iostate_to_str(vgadev->locks));
511
512         spin_unlock_irqrestore(&vga_lock, flags);
513         return true;
514 fail:
515         spin_unlock_irqrestore(&vga_lock, flags);
516         kfree(vgadev);
517         return false;
518 }
519
520 static bool vga_arbiter_del_pci_device(struct pci_dev *pdev)
521 {
522         struct vga_device *vgadev;
523         unsigned long flags;
524         bool ret = true;
525
526         spin_lock_irqsave(&vga_lock, flags);
527         vgadev = vgadev_find(pdev);
528         if (vgadev == NULL) {
529                 ret = false;
530                 goto bail;
531         }
532
533         if (vga_default == pdev) {
534                 pci_dev_put(vga_default);
535                 vga_default = NULL;
536         }
537
538         if (vgadev->decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
539                 vga_decode_count--;
540
541         /* Remove entry from list */
542         list_del(&vgadev->list);
543         vga_count--;
544         /* Notify userland driver that the device is gone so it discards
545          * it's copies of the pci_dev pointer
546          */
547         vga_arb_device_card_gone(pdev);
548
549         /* Wake up all possible waiters */
550         wake_up_all(&vga_wait_queue);
551 bail:
552         spin_unlock_irqrestore(&vga_lock, flags);
553         kfree(vgadev);
554         return ret;
555 }
556
557 /* this is called with the lock */
558 static inline void vga_update_device_decodes(struct vga_device *vgadev,
559                                              int new_decodes)
560 {
561         int old_decodes;
562         struct vga_device *new_vgadev, *conflict;
563
564         old_decodes = vgadev->decodes;
565         vgadev->decodes = new_decodes;
566
567         pr_info("vgaarb: device changed decodes: PCI:%s,olddecodes=%s,decodes=%s:owns=%s\n",
568                 pci_name(vgadev->pdev),
569                 vga_iostate_to_str(old_decodes),
570                 vga_iostate_to_str(vgadev->decodes),
571                 vga_iostate_to_str(vgadev->owns));
572
573
574         /* if we own the decodes we should move them along to
575            another card */
576         if ((vgadev->owns & old_decodes) && (vga_count > 1)) {
577                 /* set us to own nothing */
578                 vgadev->owns &= ~old_decodes;
579                 list_for_each_entry(new_vgadev, &vga_list, list) {
580                         if ((new_vgadev != vgadev) &&
581                             (new_vgadev->decodes & VGA_RSRC_LEGACY_MASK)) {
582                                 pr_info("vgaarb: transferring owner from PCI:%s to PCI:%s\n", pci_name(vgadev->pdev), pci_name(new_vgadev->pdev));
583                                 conflict = __vga_tryget(new_vgadev, VGA_RSRC_LEGACY_MASK);
584                                 if (!conflict)
585                                         __vga_put(new_vgadev, VGA_RSRC_LEGACY_MASK);
586                                 break;
587                         }
588                 }
589         }
590
591         /* change decodes counter */
592         if (old_decodes != new_decodes) {
593                 if (new_decodes & (VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM))
594                         vga_decode_count++;
595                 else
596                         vga_decode_count--;
597         }
598         pr_debug("vgaarb: decoding count now is: %d\n", vga_decode_count);
599 }
600
601 void __vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes, bool userspace)
602 {
603         struct vga_device *vgadev;
604         unsigned long flags;
605
606         decodes &= VGA_RSRC_LEGACY_MASK;
607
608         spin_lock_irqsave(&vga_lock, flags);
609         vgadev = vgadev_find(pdev);
610         if (vgadev == NULL)
611                 goto bail;
612
613         /* don't let userspace futz with kernel driver decodes */
614         if (userspace && vgadev->set_vga_decode)
615                 goto bail;
616
617         /* update the device decodes + counter */
618         vga_update_device_decodes(vgadev, decodes);
619
620         /* XXX if somebody is going from "doesn't decode" to "decodes" state
621          * here, additional care must be taken as we may have pending owner
622          * ship of non-legacy region ...
623          */
624 bail:
625         spin_unlock_irqrestore(&vga_lock, flags);
626 }
627
628 void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
629 {
630         __vga_set_legacy_decoding(pdev, decodes, false);
631 }
632 EXPORT_SYMBOL(vga_set_legacy_decoding);
633
634 /* call with NULL to unregister */
635 int vga_client_register(struct pci_dev *pdev, void *cookie,
636                         void (*irq_set_state)(void *cookie, bool state),
637                         unsigned int (*set_vga_decode)(void *cookie, bool decode))
638 {
639         int ret = -1;
640         struct vga_device *vgadev;
641         unsigned long flags;
642
643         spin_lock_irqsave(&vga_lock, flags);
644         vgadev = vgadev_find(pdev);
645         if (!vgadev)
646                 goto bail;
647
648         vgadev->irq_set_state = irq_set_state;
649         vgadev->set_vga_decode = set_vga_decode;
650         vgadev->cookie = cookie;
651         ret = 0;
652
653 bail:
654         spin_unlock_irqrestore(&vga_lock, flags);
655         return ret;
656
657 }
658 EXPORT_SYMBOL(vga_client_register);
659
660 /*
661  * Char driver implementation
662  *
663  * Semantics is:
664  *
665  *  open       : open user instance of the arbitrer. by default, it's
666  *                attached to the default VGA device of the system.
667  *
668  *  close      : close user instance, release locks
669  *
670  *  read       : return a string indicating the status of the target.
671  *                an IO state string is of the form {io,mem,io+mem,none},
672  *                mc and ic are respectively mem and io lock counts (for
673  *                debugging/diagnostic only). "decodes" indicate what the
674  *                card currently decodes, "owns" indicates what is currently
675  *                enabled on it, and "locks" indicates what is locked by this
676  *                card. If the card is unplugged, we get "invalid" then for
677  *                card_ID and an -ENODEV error is returned for any command
678  *                until a new card is targeted
679  *
680  *   "<card_ID>,decodes=<io_state>,owns=<io_state>,locks=<io_state> (ic,mc)"
681  *
682  * write       : write a command to the arbiter. List of commands is:
683  *
684  *   target <card_ID>   : switch target to card <card_ID> (see below)
685  *   lock <io_state>    : acquires locks on target ("none" is invalid io_state)
686  *   trylock <io_state> : non-blocking acquire locks on target
687  *   unlock <io_state>  : release locks on target
688  *   unlock all         : release all locks on target held by this user
689  *   decodes <io_state> : set the legacy decoding attributes for the card
690  *
691  * poll         : event if something change on any card (not just the target)
692  *
693  * card_ID is of the form "PCI:domain:bus:dev.fn". It can be set to "default"
694  * to go back to the system default card (TODO: not implemented yet).
695  * Currently, only PCI is supported as a prefix, but the userland API may
696  * support other bus types in the future, even if the current kernel
697  * implementation doesn't.
698  *
699  * Note about locks:
700  *
701  * The driver keeps track of which user has what locks on which card. It
702  * supports stacking, like the kernel one. This complexifies the implementation
703  * a bit, but makes the arbiter more tolerant to userspace problems and able
704  * to properly cleanup in all cases when a process dies.
705  * Currently, a max of 16 cards simultaneously can have locks issued from
706  * userspace for a given user (file descriptor instance) of the arbiter.
707  *
708  * If the device is hot-unplugged, there is a hook inside the module to notify
709  * they being added/removed in the system and automatically added/removed in
710  * the arbiter.
711  */
712
713 #define MAX_USER_CARDS         CONFIG_VGA_ARB_MAX_GPUS
714 #define PCI_INVALID_CARD       ((struct pci_dev *)-1UL)
715
716 /*
717  * Each user has an array of these, tracking which cards have locks
718  */
719 struct vga_arb_user_card {
720         struct pci_dev *pdev;
721         unsigned int mem_cnt;
722         unsigned int io_cnt;
723 };
724
725 struct vga_arb_private {
726         struct list_head list;
727         struct pci_dev *target;
728         struct vga_arb_user_card cards[MAX_USER_CARDS];
729         spinlock_t lock;
730 };
731
732 static LIST_HEAD(vga_user_list);
733 static DEFINE_SPINLOCK(vga_user_lock);
734
735
736 /*
737  * This function gets a string in the format: "PCI:domain:bus:dev.fn" and
738  * returns the respective values. If the string is not in this format,
739  * it returns 0.
740  */
741 static int vga_pci_str_to_vars(char *buf, int count, unsigned int *domain,
742                                unsigned int *bus, unsigned int *devfn)
743 {
744         int n;
745         unsigned int slot, func;
746
747
748         n = sscanf(buf, "PCI:%x:%x:%x.%x", domain, bus, &slot, &func);
749         if (n != 4)
750                 return 0;
751
752         *devfn = PCI_DEVFN(slot, func);
753
754         return 1;
755 }
756
757 static ssize_t vga_arb_read(struct file *file, char __user * buf,
758                             size_t count, loff_t *ppos)
759 {
760         struct vga_arb_private *priv = file->private_data;
761         struct vga_device *vgadev;
762         struct pci_dev *pdev;
763         unsigned long flags;
764         size_t len;
765         int rc;
766         char *lbuf;
767
768         lbuf = kmalloc(1024, GFP_KERNEL);
769         if (lbuf == NULL)
770                 return -ENOMEM;
771
772         /* Shields against vga_arb_device_card_gone (pci_dev going
773          * away), and allows access to vga list
774          */
775         spin_lock_irqsave(&vga_lock, flags);
776
777         /* If we are targetting the default, use it */
778         pdev = priv->target;
779         if (pdev == NULL || pdev == PCI_INVALID_CARD) {
780                 spin_unlock_irqrestore(&vga_lock, flags);
781                 len = sprintf(lbuf, "invalid");
782                 goto done;
783         }
784
785         /* Find card vgadev structure */
786         vgadev = vgadev_find(pdev);
787         if (vgadev == NULL) {
788                 /* Wow, it's not in the list, that shouldn't happen,
789                  * let's fix us up and return invalid card
790                  */
791                 if (pdev == priv->target)
792                         vga_arb_device_card_gone(pdev);
793                 spin_unlock_irqrestore(&vga_lock, flags);
794                 len = sprintf(lbuf, "invalid");
795                 goto done;
796         }
797
798         /* Fill the buffer with infos */
799         len = snprintf(lbuf, 1024,
800                        "count:%d,PCI:%s,decodes=%s,owns=%s,locks=%s(%d:%d)\n",
801                        vga_decode_count, pci_name(pdev),
802                        vga_iostate_to_str(vgadev->decodes),
803                        vga_iostate_to_str(vgadev->owns),
804                        vga_iostate_to_str(vgadev->locks),
805                        vgadev->io_lock_cnt, vgadev->mem_lock_cnt);
806
807         spin_unlock_irqrestore(&vga_lock, flags);
808 done:
809
810         /* Copy that to user */
811         if (len > count)
812                 len = count;
813         rc = copy_to_user(buf, lbuf, len);
814         kfree(lbuf);
815         if (rc)
816                 return -EFAULT;
817         return len;
818 }
819
820 /*
821  * TODO: To avoid parsing inside kernel and to improve the speed we may
822  * consider use ioctl here
823  */
824 static ssize_t vga_arb_write(struct file *file, const char __user * buf,
825                              size_t count, loff_t *ppos)
826 {
827         struct vga_arb_private *priv = file->private_data;
828         struct vga_arb_user_card *uc = NULL;
829         struct pci_dev *pdev;
830
831         unsigned int io_state;
832
833         char *kbuf, *curr_pos;
834         size_t remaining = count;
835
836         int ret_val;
837         int i;
838
839
840         kbuf = kmalloc(count + 1, GFP_KERNEL);
841         if (!kbuf)
842                 return -ENOMEM;
843
844         if (copy_from_user(kbuf, buf, count)) {
845                 kfree(kbuf);
846                 return -EFAULT;
847         }
848         curr_pos = kbuf;
849         kbuf[count] = '\0';     /* Just to make sure... */
850
851         if (strncmp(curr_pos, "lock ", 5) == 0) {
852                 curr_pos += 5;
853                 remaining -= 5;
854
855                 pr_debug("client 0x%p called 'lock'\n", priv);
856
857                 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
858                         ret_val = -EPROTO;
859                         goto done;
860                 }
861                 if (io_state == VGA_RSRC_NONE) {
862                         ret_val = -EPROTO;
863                         goto done;
864                 }
865
866                 pdev = priv->target;
867                 if (priv->target == NULL) {
868                         ret_val = -ENODEV;
869                         goto done;
870                 }
871
872                 vga_get_uninterruptible(pdev, io_state);
873
874                 /* Update the client's locks lists... */
875                 for (i = 0; i < MAX_USER_CARDS; i++) {
876                         if (priv->cards[i].pdev == pdev) {
877                                 if (io_state & VGA_RSRC_LEGACY_IO)
878                                         priv->cards[i].io_cnt++;
879                                 if (io_state & VGA_RSRC_LEGACY_MEM)
880                                         priv->cards[i].mem_cnt++;
881                                 break;
882                         }
883                 }
884
885                 ret_val = count;
886                 goto done;
887         } else if (strncmp(curr_pos, "unlock ", 7) == 0) {
888                 curr_pos += 7;
889                 remaining -= 7;
890
891                 pr_debug("client 0x%p called 'unlock'\n", priv);
892
893                 if (strncmp(curr_pos, "all", 3) == 0)
894                         io_state = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM;
895                 else {
896                         if (!vga_str_to_iostate
897                             (curr_pos, remaining, &io_state)) {
898                                 ret_val = -EPROTO;
899                                 goto done;
900                         }
901                         /* TODO: Add this?
902                            if (io_state == VGA_RSRC_NONE) {
903                            ret_val = -EPROTO;
904                            goto done;
905                            }
906                           */
907                 }
908
909                 pdev = priv->target;
910                 if (priv->target == NULL) {
911                         ret_val = -ENODEV;
912                         goto done;
913                 }
914                 for (i = 0; i < MAX_USER_CARDS; i++) {
915                         if (priv->cards[i].pdev == pdev)
916                                 uc = &priv->cards[i];
917                 }
918
919                 if (!uc)
920                         return -EINVAL;
921
922                 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0)
923                         return -EINVAL;
924
925                 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0)
926                         return -EINVAL;
927
928                 vga_put(pdev, io_state);
929
930                 if (io_state & VGA_RSRC_LEGACY_IO)
931                         uc->io_cnt--;
932                 if (io_state & VGA_RSRC_LEGACY_MEM)
933                         uc->mem_cnt--;
934
935                 ret_val = count;
936                 goto done;
937         } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
938                 curr_pos += 8;
939                 remaining -= 8;
940
941                 pr_debug("client 0x%p called 'trylock'\n", priv);
942
943                 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
944                         ret_val = -EPROTO;
945                         goto done;
946                 }
947                 /* TODO: Add this?
948                    if (io_state == VGA_RSRC_NONE) {
949                    ret_val = -EPROTO;
950                    goto done;
951                    }
952                  */
953
954                 pdev = priv->target;
955                 if (priv->target == NULL) {
956                         ret_val = -ENODEV;
957                         goto done;
958                 }
959
960                 if (vga_tryget(pdev, io_state)) {
961                         /* Update the client's locks lists... */
962                         for (i = 0; i < MAX_USER_CARDS; i++) {
963                                 if (priv->cards[i].pdev == pdev) {
964                                         if (io_state & VGA_RSRC_LEGACY_IO)
965                                                 priv->cards[i].io_cnt++;
966                                         if (io_state & VGA_RSRC_LEGACY_MEM)
967                                                 priv->cards[i].mem_cnt++;
968                                         break;
969                                 }
970                         }
971                         ret_val = count;
972                         goto done;
973                 } else {
974                         ret_val = -EBUSY;
975                         goto done;
976                 }
977
978         } else if (strncmp(curr_pos, "target ", 7) == 0) {
979                 struct pci_bus *pbus;
980                 unsigned int domain, bus, devfn;
981                 struct vga_device *vgadev;
982
983                 curr_pos += 7;
984                 remaining -= 7;
985                 pr_debug("client 0x%p called 'target'\n", priv);
986                 /* if target is default */
987                 if (!strncmp(curr_pos, "default", 7))
988                         pdev = pci_dev_get(vga_default_device());
989                 else {
990                         if (!vga_pci_str_to_vars(curr_pos, remaining,
991                                                  &domain, &bus, &devfn)) {
992                                 ret_val = -EPROTO;
993                                 goto done;
994                         }
995                         pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
996                                 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
997
998                         pbus = pci_find_bus(domain, bus);
999                         pr_debug("vgaarb: pbus %p\n", pbus);
1000                         if (pbus == NULL) {
1001                                 pr_err("vgaarb: invalid PCI domain and/or bus address %x:%x\n",
1002                                         domain, bus);
1003                                 ret_val = -ENODEV;
1004                                 goto done;
1005                         }
1006                         pdev = pci_get_slot(pbus, devfn);
1007                         pr_debug("vgaarb: pdev %p\n", pdev);
1008                         if (!pdev) {
1009                                 pr_err("vgaarb: invalid PCI address %x:%x\n",
1010                                         bus, devfn);
1011                                 ret_val = -ENODEV;
1012                                 goto done;
1013                         }
1014                 }
1015
1016                 vgadev = vgadev_find(pdev);
1017                 pr_debug("vgaarb: vgadev %p\n", vgadev);
1018                 if (vgadev == NULL) {
1019                         pr_err("vgaarb: this pci device is not a vga device\n");
1020                         pci_dev_put(pdev);
1021                         ret_val = -ENODEV;
1022                         goto done;
1023                 }
1024
1025                 priv->target = pdev;
1026                 for (i = 0; i < MAX_USER_CARDS; i++) {
1027                         if (priv->cards[i].pdev == pdev)
1028                                 break;
1029                         if (priv->cards[i].pdev == NULL) {
1030                                 priv->cards[i].pdev = pdev;
1031                                 priv->cards[i].io_cnt = 0;
1032                                 priv->cards[i].mem_cnt = 0;
1033                                 break;
1034                         }
1035                 }
1036                 if (i == MAX_USER_CARDS) {
1037                         pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1038                                 MAX_USER_CARDS);
1039                         pci_dev_put(pdev);
1040                         /* XXX: which value to return? */
1041                         ret_val =  -ENOMEM;
1042                         goto done;
1043                 }
1044
1045                 ret_val = count;
1046                 pci_dev_put(pdev);
1047                 goto done;
1048
1049
1050         } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1051                 curr_pos += 8;
1052                 remaining -= 8;
1053                 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1054
1055                 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1056                         ret_val = -EPROTO;
1057                         goto done;
1058                 }
1059                 pdev = priv->target;
1060                 if (priv->target == NULL) {
1061                         ret_val = -ENODEV;
1062                         goto done;
1063                 }
1064
1065                 __vga_set_legacy_decoding(pdev, io_state, true);
1066                 ret_val = count;
1067                 goto done;
1068         }
1069         /* If we got here, the message written is not part of the protocol! */
1070         kfree(kbuf);
1071         return -EPROTO;
1072
1073 done:
1074         kfree(kbuf);
1075         return ret_val;
1076 }
1077
1078 static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1079 {
1080         struct vga_arb_private *priv = file->private_data;
1081
1082         pr_debug("%s\n", __func__);
1083
1084         if (priv == NULL)
1085                 return -ENODEV;
1086         poll_wait(file, &vga_wait_queue, wait);
1087         return POLLIN;
1088 }
1089
1090 static int vga_arb_open(struct inode *inode, struct file *file)
1091 {
1092         struct vga_arb_private *priv;
1093         unsigned long flags;
1094
1095         pr_debug("%s\n", __func__);
1096
1097         priv = kmalloc(sizeof(struct vga_arb_private), GFP_KERNEL);
1098         if (priv == NULL)
1099                 return -ENOMEM;
1100         memset(priv, 0, sizeof(*priv));
1101         spin_lock_init(&priv->lock);
1102         file->private_data = priv;
1103
1104         spin_lock_irqsave(&vga_user_lock, flags);
1105         list_add(&priv->list, &vga_user_list);
1106         spin_unlock_irqrestore(&vga_user_lock, flags);
1107
1108         /* Set the client' lists of locks */
1109         priv->target = vga_default_device(); /* Maybe this is still null! */
1110         priv->cards[0].pdev = priv->target;
1111         priv->cards[0].io_cnt = 0;
1112         priv->cards[0].mem_cnt = 0;
1113
1114
1115         return 0;
1116 }
1117
1118 static int vga_arb_release(struct inode *inode, struct file *file)
1119 {
1120         struct vga_arb_private *priv = file->private_data;
1121         struct vga_arb_user_card *uc;
1122         unsigned long flags;
1123         int i;
1124
1125         pr_debug("%s\n", __func__);
1126
1127         if (priv == NULL)
1128                 return -ENODEV;
1129
1130         spin_lock_irqsave(&vga_user_lock, flags);
1131         list_del(&priv->list);
1132         for (i = 0; i < MAX_USER_CARDS; i++) {
1133                 uc = &priv->cards[i];
1134                 if (uc->pdev == NULL)
1135                         continue;
1136                 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1137                          uc->io_cnt, uc->mem_cnt);
1138                 while (uc->io_cnt--)
1139                         vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1140                 while (uc->mem_cnt--)
1141                         vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1142         }
1143         spin_unlock_irqrestore(&vga_user_lock, flags);
1144
1145         kfree(priv);
1146
1147         return 0;
1148 }
1149
1150 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1151 {
1152 }
1153
1154 /*
1155  * callback any registered clients to let them know we have a
1156  * change in VGA cards
1157  */
1158 static void vga_arbiter_notify_clients(void)
1159 {
1160         struct vga_device *vgadev;
1161         unsigned long flags;
1162         uint32_t new_decodes;
1163         bool new_state;
1164
1165         if (!vga_arbiter_used)
1166                 return;
1167
1168         spin_lock_irqsave(&vga_lock, flags);
1169         list_for_each_entry(vgadev, &vga_list, list) {
1170                 if (vga_count > 1)
1171                         new_state = false;
1172                 else
1173                         new_state = true;
1174                 if (vgadev->set_vga_decode) {
1175                         new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1176                         vga_update_device_decodes(vgadev, new_decodes);
1177                 }
1178         }
1179         spin_unlock_irqrestore(&vga_lock, flags);
1180 }
1181
1182 static int pci_notify(struct notifier_block *nb, unsigned long action,
1183                       void *data)
1184 {
1185         struct device *dev = data;
1186         struct pci_dev *pdev = to_pci_dev(dev);
1187         bool notify = false;
1188
1189         pr_debug("%s\n", __func__);
1190
1191         /* For now we're only intereted in devices added and removed. I didn't
1192          * test this thing here, so someone needs to double check for the
1193          * cases of hotplugable vga cards. */
1194         if (action == BUS_NOTIFY_ADD_DEVICE)
1195                 notify = vga_arbiter_add_pci_device(pdev);
1196         else if (action == BUS_NOTIFY_DEL_DEVICE)
1197                 notify = vga_arbiter_del_pci_device(pdev);
1198
1199         if (notify)
1200                 vga_arbiter_notify_clients();
1201         return 0;
1202 }
1203
1204 static struct notifier_block pci_notifier = {
1205         .notifier_call = pci_notify,
1206 };
1207
1208 static const struct file_operations vga_arb_device_fops = {
1209         .read = vga_arb_read,
1210         .write = vga_arb_write,
1211         .poll = vga_arb_fpoll,
1212         .open = vga_arb_open,
1213         .release = vga_arb_release,
1214         .llseek = noop_llseek,
1215 };
1216
1217 static struct miscdevice vga_arb_device = {
1218         MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1219 };
1220
1221 static int __init vga_arb_device_init(void)
1222 {
1223         int rc;
1224         struct pci_dev *pdev;
1225
1226         rc = misc_register(&vga_arb_device);
1227         if (rc < 0)
1228                 pr_err("vgaarb: error %d registering device\n", rc);
1229
1230         bus_register_notifier(&pci_bus_type, &pci_notifier);
1231
1232         /* We add all pci devices satisfying vga class in the arbiter by
1233          * default */
1234         pdev = NULL;
1235         while ((pdev =
1236                 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1237                                PCI_ANY_ID, pdev)) != NULL)
1238                 vga_arbiter_add_pci_device(pdev);
1239
1240         pr_info("vgaarb: loaded\n");
1241         return rc;
1242 }
1243 subsys_initcall(vga_arb_device_init);