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