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