drivers/gpu/vga/vgaarb.c

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