1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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
49static void vga_arbiter_notify_clients(void);
50
51
52
53
54struct vga_device {
55 struct list_head list;
56 struct pci_dev *pdev;
57 unsigned int decodes;
58 unsigned int owns;
59 unsigned int locks;
60 unsigned int io_lock_cnt;
61 unsigned int mem_lock_cnt;
62 unsigned int io_norm_cnt;
63 unsigned int mem_norm_cnt;
64
65
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
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
96
97 if (strncmp(buf, "none", 4) == 0) {
98 *io_state = VGA_RSRC_NONE;
99 return 1;
100 }
101
102
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
117static struct pci_dev *vga_default;
118#endif
119
120static void vga_arb_device_card_gone(struct pci_dev *pdev);
121
122
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
134#ifndef __ARCH_HAS_VGA_DEFAULT_DEVICE
135struct pci_dev *vga_default_device(void)
136{
137 return vga_default;
138}
139#endif
140
141static 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
149
150
151static void vga_check_first_use(void)
152{
153
154
155
156 if (!vga_arbiter_used) {
157 vga_arbiter_used = true;
158 vga_arbiter_notify_clients();
159 }
160}
161
162static 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
169
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
182 wants = rsrc & ~vgadev->owns;
183
184
185 if (wants == 0)
186 goto lock_them;
187
188
189
190
191 legacy_wants = wants & VGA_RSRC_LEGACY_MASK;
192 if (legacy_wants == 0)
193 goto enable_them;
194
195
196 list_for_each_entry(conflict, &vga_list, list) {
197 unsigned int lwants = legacy_wants;
198 unsigned int change_bridge = 0;
199
200
201 if (vgadev == conflict)
202 continue;
203
204
205
206
207 if (!vga_conflicts(vgadev->pdev, conflict->pdev))
208 continue;
209
210
211
212
213
214
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
222
223
224 if (conflict->locks & lwants)
225 return conflict;
226
227
228
229
230
231
232 WARN_ON(conflict->owns & ~conflict->decodes);
233 match = lwants & conflict->owns;
234 if (!match)
235 continue;
236
237
238
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
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
258enable_them:
259
260
261
262
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);
273lock_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
287static 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
294
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
312
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
320
321
322 if (old_locks != vgadev->locks)
323 wake_up_all(&vga_wait_queue);
324}
325
326int 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
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
355
356
357
358
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}
375EXPORT_SYMBOL(vga_get);
376
377int 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
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;
398bail:
399 spin_unlock_irqrestore(&vga_lock, flags);
400 return rc;
401}
402EXPORT_SYMBOL(vga_tryget);
403
404void vga_put(struct pci_dev *pdev, unsigned int rsrc)
405{
406 struct vga_device *vgadev;
407 unsigned long flags;
408
409
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);
419bail:
420 spin_unlock_irqrestore(&vga_lock, flags);
421}
422EXPORT_SYMBOL(vga_put);
423
424
425
426
427
428
429
430static 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
439 if ((pdev->class >> 8) != PCI_CLASS_DISPLAY_VGA)
440 return false;
441
442
443 vgadev = kmalloc(sizeof(struct vga_device), GFP_KERNEL);
444 if (vgadev == NULL) {
445 pr_err("vgaarb: failed to allocate pci device\n");
446
447
448
449
450 return false;
451 }
452
453 memset(vgadev, 0, sizeof(*vgadev));
454
455
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
464 vgadev->decodes = VGA_RSRC_LEGACY_IO | VGA_RSRC_LEGACY_MEM |
465 VGA_RSRC_NORMAL_IO | VGA_RSRC_NORMAL_MEM;
466
467
468 vga_decode_count++;
469
470
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
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
495
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
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;
514fail:
515 spin_unlock_irqrestore(&vga_lock, flags);
516 kfree(vgadev);
517 return false;
518}
519
520static 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
542 list_del(&vgadev->list);
543 vga_count--;
544
545
546
547 vga_arb_device_card_gone(pdev);
548
549
550 wake_up_all(&vga_wait_queue);
551bail:
552 spin_unlock_irqrestore(&vga_lock, flags);
553 kfree(vgadev);
554 return ret;
555}
556
557
558static 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
575
576 if ((vgadev->owns & old_decodes) && (vga_count > 1)) {
577
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
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
601static 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
614 if (userspace && vgadev->set_vga_decode)
615 goto bail;
616
617
618 vga_update_device_decodes(vgadev, decodes);
619
620
621
622
623
624bail:
625 spin_unlock_irqrestore(&vga_lock, flags);
626}
627
628void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes)
629{
630 __vga_set_legacy_decoding(pdev, decodes, false);
631}
632EXPORT_SYMBOL(vga_set_legacy_decoding);
633
634
635int 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 = -ENODEV;
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
653bail:
654 spin_unlock_irqrestore(&vga_lock, flags);
655 return ret;
656
657}
658EXPORT_SYMBOL(vga_client_register);
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713#define MAX_USER_CARDS CONFIG_VGA_ARB_MAX_GPUS
714#define PCI_INVALID_CARD ((struct pci_dev *)-1UL)
715
716
717
718
719struct vga_arb_user_card {
720 struct pci_dev *pdev;
721 unsigned int mem_cnt;
722 unsigned int io_cnt;
723};
724
725struct 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
732static LIST_HEAD(vga_user_list);
733static DEFINE_SPINLOCK(vga_user_lock);
734
735
736
737
738
739
740
741static 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
757static 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
773
774
775 spin_lock_irqsave(&vga_lock, flags);
776
777
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
786 vgadev = vgadev_find(pdev);
787 if (vgadev == NULL) {
788
789
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
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);
808done:
809
810
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
822
823
824static 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';
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
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
902
903
904
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
948
949
950
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
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
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
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
1070 kfree(kbuf);
1071 return -EPROTO;
1072
1073done:
1074 kfree(kbuf);
1075 return ret_val;
1076}
1077
1078static 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
1090static 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
1109 priv->target = vga_default_device();
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
1118static 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
1150static void vga_arb_device_card_gone(struct pci_dev *pdev)
1151{
1152}
1153
1154
1155
1156
1157
1158static 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
1182static 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
1192
1193
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
1204static struct notifier_block pci_notifier = {
1205 .notifier_call = pci_notify,
1206};
1207
1208static 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
1217static struct miscdevice vga_arb_device = {
1218 MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1219};
1220
1221static 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
1233
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}
1243subsys_initcall(vga_arb_device_init);
1244