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