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                         ret_val = -EINVAL;
 996                         goto done;
 997                 }
 998
 999                 if (io_state & VGA_RSRC_LEGACY_IO && uc->io_cnt == 0) {
1000                         ret_val = -EINVAL;
1001                         goto done;
1002                 }
1003
1004                 if (io_state & VGA_RSRC_LEGACY_MEM && uc->mem_cnt == 0) {
1005                         ret_val = -EINVAL;
1006                         goto done;
1007                 }
1008
1009                 vga_put(pdev, io_state);
1010
1011                 if (io_state & VGA_RSRC_LEGACY_IO)
1012                         uc->io_cnt--;
1013                 if (io_state & VGA_RSRC_LEGACY_MEM)
1014                         uc->mem_cnt--;
1015
1016                 ret_val = count;
1017                 goto done;
1018         } else if (strncmp(curr_pos, "trylock ", 8) == 0) {
1019                 curr_pos += 8;
1020                 remaining -= 8;
1021
1022                 pr_debug("client 0x%p called 'trylock'\n", priv);
1023
1024                 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1025                         ret_val = -EPROTO;
1026                         goto done;
1027                 }
1028                 /* TODO: Add this?
1029                    if (io_state == VGA_RSRC_NONE) {
1030                    ret_val = -EPROTO;
1031                    goto done;
1032                    }
1033                  */
1034
1035                 pdev = priv->target;
1036                 if (priv->target == NULL) {
1037                         ret_val = -ENODEV;
1038                         goto done;
1039                 }
1040
1041                 if (vga_tryget(pdev, io_state)) {
1042                         /* Update the client's locks lists... */
1043                         for (i = 0; i < MAX_USER_CARDS; i++) {
1044                                 if (priv->cards[i].pdev == pdev) {
1045                                         if (io_state & VGA_RSRC_LEGACY_IO)
1046                                                 priv->cards[i].io_cnt++;
1047                                         if (io_state & VGA_RSRC_LEGACY_MEM)
1048                                                 priv->cards[i].mem_cnt++;
1049                                         break;
1050                                 }
1051                         }
1052                         ret_val = count;
1053                         goto done;
1054                 } else {
1055                         ret_val = -EBUSY;
1056                         goto done;
1057                 }
1058
1059         } else if (strncmp(curr_pos, "target ", 7) == 0) {
1060                 struct pci_bus *pbus;
1061                 unsigned int domain, bus, devfn;
1062                 struct vga_device *vgadev;
1063
1064                 curr_pos += 7;
1065                 remaining -= 7;
1066                 pr_debug("client 0x%p called 'target'\n", priv);
1067                 /* if target is default */
1068                 if (!strncmp(curr_pos, "default", 7))
1069                         pdev = pci_dev_get(vga_default_device());
1070                 else {
1071                         if (!vga_pci_str_to_vars(curr_pos, remaining,
1072                                                  &domain, &bus, &devfn)) {
1073                                 ret_val = -EPROTO;
1074                                 goto done;
1075                         }
1076                         pr_debug("vgaarb: %s ==> %x:%x:%x.%x\n", curr_pos,
1077                                 domain, bus, PCI_SLOT(devfn), PCI_FUNC(devfn));
1078
1079                         pbus = pci_find_bus(domain, bus);
1080                         pr_debug("vgaarb: pbus %p\n", pbus);
1081                         if (pbus == NULL) {
1082                                 pr_err("vgaarb: invalid PCI domain and/or bus address %x:%x\n",
1083                                         domain, bus);
1084                                 ret_val = -ENODEV;
1085                                 goto done;
1086                         }
1087                         pdev = pci_get_slot(pbus, devfn);
1088                         pr_debug("vgaarb: pdev %p\n", pdev);
1089                         if (!pdev) {
1090                                 pr_err("vgaarb: invalid PCI address %x:%x\n",
1091                                         bus, devfn);
1092                                 ret_val = -ENODEV;
1093                                 goto done;
1094                         }
1095                 }
1096
1097                 vgadev = vgadev_find(pdev);
1098                 pr_debug("vgaarb: vgadev %p\n", vgadev);
1099                 if (vgadev == NULL) {
1100                         pr_err("vgaarb: this pci device is not a vga device\n");
1101                         pci_dev_put(pdev);
1102                         ret_val = -ENODEV;
1103                         goto done;
1104                 }
1105
1106                 priv->target = pdev;
1107                 for (i = 0; i < MAX_USER_CARDS; i++) {
1108                         if (priv->cards[i].pdev == pdev)
1109                                 break;
1110                         if (priv->cards[i].pdev == NULL) {
1111                                 priv->cards[i].pdev = pdev;
1112                                 priv->cards[i].io_cnt = 0;
1113                                 priv->cards[i].mem_cnt = 0;
1114                                 break;
1115                         }
1116                 }
1117                 if (i == MAX_USER_CARDS) {
1118                         pr_err("vgaarb: maximum user cards (%d) number reached!\n",
1119                                 MAX_USER_CARDS);
1120                         pci_dev_put(pdev);
1121                         /* XXX: which value to return? */
1122                         ret_val =  -ENOMEM;
1123                         goto done;
1124                 }
1125
1126                 ret_val = count;
1127                 pci_dev_put(pdev);
1128                 goto done;
1129
1130
1131         } else if (strncmp(curr_pos, "decodes ", 8) == 0) {
1132                 curr_pos += 8;
1133                 remaining -= 8;
1134                 pr_debug("vgaarb: client 0x%p called 'decodes'\n", priv);
1135
1136                 if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {
1137                         ret_val = -EPROTO;
1138                         goto done;
1139                 }
1140                 pdev = priv->target;
1141                 if (priv->target == NULL) {
1142                         ret_val = -ENODEV;
1143                         goto done;
1144                 }
1145
1146                 __vga_set_legacy_decoding(pdev, io_state, true);
1147                 ret_val = count;
1148                 goto done;
1149         }
1150         /* If we got here, the message written is not part of the protocol! */
1151         kfree(kbuf);
1152         return -EPROTO;
1153
1154 done:
1155         kfree(kbuf);
1156         return ret_val;
1157 }
1158
1159 static unsigned int vga_arb_fpoll(struct file *file, poll_table * wait)
1160 {
1161         struct vga_arb_private *priv = file->private_data;
1162
1163         pr_debug("%s\n", __func__);
1164
1165         if (priv == NULL)
1166                 return -ENODEV;
1167         poll_wait(file, &vga_wait_queue, wait);
1168         return POLLIN;
1169 }
1170
1171 static int vga_arb_open(struct inode *inode, struct file *file)
1172 {
1173         struct vga_arb_private *priv;
1174         unsigned long flags;
1175
1176         pr_debug("%s\n", __func__);
1177
1178         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1179         if (priv == NULL)
1180                 return -ENOMEM;
1181         spin_lock_init(&priv->lock);
1182         file->private_data = priv;
1183
1184         spin_lock_irqsave(&vga_user_lock, flags);
1185         list_add(&priv->list, &vga_user_list);
1186         spin_unlock_irqrestore(&vga_user_lock, flags);
1187
1188         /* Set the client' lists of locks */
1189         priv->target = vga_default_device(); /* Maybe this is still null! */
1190         priv->cards[0].pdev = priv->target;
1191         priv->cards[0].io_cnt = 0;
1192         priv->cards[0].mem_cnt = 0;
1193
1194
1195         return 0;
1196 }
1197
1198 static int vga_arb_release(struct inode *inode, struct file *file)
1199 {
1200         struct vga_arb_private *priv = file->private_data;
1201         struct vga_arb_user_card *uc;
1202         unsigned long flags;
1203         int i;
1204
1205         pr_debug("%s\n", __func__);
1206
1207         if (priv == NULL)
1208                 return -ENODEV;
1209
1210         spin_lock_irqsave(&vga_user_lock, flags);
1211         list_del(&priv->list);
1212         for (i = 0; i < MAX_USER_CARDS; i++) {
1213                 uc = &priv->cards[i];
1214                 if (uc->pdev == NULL)
1215                         continue;
1216                 pr_debug("uc->io_cnt == %d, uc->mem_cnt == %d\n",
1217                          uc->io_cnt, uc->mem_cnt);
1218                 while (uc->io_cnt--)
1219                         vga_put(uc->pdev, VGA_RSRC_LEGACY_IO);
1220                 while (uc->mem_cnt--)
1221                         vga_put(uc->pdev, VGA_RSRC_LEGACY_MEM);
1222         }
1223         spin_unlock_irqrestore(&vga_user_lock, flags);
1224
1225         kfree(priv);
1226
1227         return 0;
1228 }
1229
1230 static void vga_arb_device_card_gone(struct pci_dev *pdev)
1231 {
1232 }
1233
1234 /*
1235  * callback any registered clients to let them know we have a
1236  * change in VGA cards
1237  */
1238 static void vga_arbiter_notify_clients(void)
1239 {
1240         struct vga_device *vgadev;
1241         unsigned long flags;
1242         uint32_t new_decodes;
1243         bool new_state;
1244
1245         if (!vga_arbiter_used)
1246                 return;
1247
1248         spin_lock_irqsave(&vga_lock, flags);
1249         list_for_each_entry(vgadev, &vga_list, list) {
1250                 if (vga_count > 1)
1251                         new_state = false;
1252                 else
1253                         new_state = true;
1254                 if (vgadev->set_vga_decode) {
1255                         new_decodes = vgadev->set_vga_decode(vgadev->cookie, new_state);
1256                         vga_update_device_decodes(vgadev, new_decodes);
1257                 }
1258         }
1259         spin_unlock_irqrestore(&vga_lock, flags);
1260 }
1261
1262 static int pci_notify(struct notifier_block *nb, unsigned long action,
1263                       void *data)
1264 {
1265         struct device *dev = data;
1266         struct pci_dev *pdev = to_pci_dev(dev);
1267         bool notify = false;
1268
1269         pr_debug("%s\n", __func__);
1270
1271         /* For now we're only intereted in devices added and removed. I didn't
1272          * test this thing here, so someone needs to double check for the
1273          * cases of hotplugable vga cards. */
1274         if (action == BUS_NOTIFY_ADD_DEVICE)
1275                 notify = vga_arbiter_add_pci_device(pdev);
1276         else if (action == BUS_NOTIFY_DEL_DEVICE)
1277                 notify = vga_arbiter_del_pci_device(pdev);
1278
1279         if (notify)
1280                 vga_arbiter_notify_clients();
1281         return 0;
1282 }
1283
1284 static struct notifier_block pci_notifier = {
1285         .notifier_call = pci_notify,
1286 };
1287
1288 static const struct file_operations vga_arb_device_fops = {
1289         .read = vga_arb_read,
1290         .write = vga_arb_write,
1291         .poll = vga_arb_fpoll,
1292         .open = vga_arb_open,
1293         .release = vga_arb_release,
1294         .llseek = noop_llseek,
1295 };
1296
1297 static struct miscdevice vga_arb_device = {
1298         MISC_DYNAMIC_MINOR, "vga_arbiter", &vga_arb_device_fops
1299 };
1300
1301 static int __init vga_arb_device_init(void)
1302 {
1303         int rc;
1304         struct pci_dev *pdev;
1305         struct vga_device *vgadev;
1306
1307         rc = misc_register(&vga_arb_device);
1308         if (rc < 0)
1309                 pr_err("vgaarb: error %d registering device\n", rc);
1310
1311         bus_register_notifier(&pci_bus_type, &pci_notifier);
1312
1313         /* We add all pci devices satisfying vga class in the arbiter by
1314          * default */
1315         pdev = NULL;
1316         while ((pdev =
1317                 pci_get_subsys(PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
1318                                PCI_ANY_ID, pdev)) != NULL)
1319                 vga_arbiter_add_pci_device(pdev);
1320
1321         pr_info("vgaarb: loaded\n");
1322
1323         list_for_each_entry(vgadev, &vga_list, list) {
1324                 if (vgadev->bridge_has_one_vga)
1325                         pr_info("vgaarb: bridge control possible %s\n", pci_name(vgadev->pdev));
1326                 else
1327                         pr_info("vgaarb: no bridge control possible %s\n", pci_name(vgadev->pdev));
1328         }
1329         return rc;
1330 }
1331 subsys_initcall(vga_arb_device_init);