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