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