access.c 10.6 KB
Newer Older
1
#include <linux/delay.h>
Linus Torvalds's avatar
Linus Torvalds committed
2 3
#include <linux/pci.h>
#include <linux/module.h>
4
#include <linux/sched.h>
5
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
6
#include <linux/ioport.h>
7
#include <linux/wait.h>
Linus Torvalds's avatar
Linus Torvalds committed
8

9 10
#include "pci.h"

Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15
/*
 * This interrupt-safe spinlock protects all accesses to PCI
 * configuration space.
 */

16
static DEFINE_RAW_SPINLOCK(pci_lock);
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

/*
 *  Wrappers for all PCI configuration access functions.  They just check
 *  alignment, do locking and call the low-level functions pointed to
 *  by pci_dev->ops.
 */

#define PCI_byte_BAD 0
#define PCI_word_BAD (pos & 1)
#define PCI_dword_BAD (pos & 3)

#define PCI_OP_READ(size,type,len) \
int pci_bus_read_config_##size \
	(struct pci_bus *bus, unsigned int devfn, int pos, type *value)	\
{									\
	int res;							\
	unsigned long flags;						\
	u32 data = 0;							\
	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\
36
	raw_spin_lock_irqsave(&pci_lock, flags);			\
Linus Torvalds's avatar
Linus Torvalds committed
37 38
	res = bus->ops->read(bus, devfn, pos, len, &data);		\
	*value = (type)data;						\
39
	raw_spin_unlock_irqrestore(&pci_lock, flags);		\
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46 47 48 49
	return res;							\
}

#define PCI_OP_WRITE(size,type,len) \
int pci_bus_write_config_##size \
	(struct pci_bus *bus, unsigned int devfn, int pos, type value)	\
{									\
	int res;							\
	unsigned long flags;						\
	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\
50
	raw_spin_lock_irqsave(&pci_lock, flags);			\
Linus Torvalds's avatar
Linus Torvalds committed
51
	res = bus->ops->write(bus, devfn, pos, len, value);		\
52
	raw_spin_unlock_irqrestore(&pci_lock, flags);		\
Linus Torvalds's avatar
Linus Torvalds committed
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
	return res;							\
}

PCI_OP_READ(byte, u8, 1)
PCI_OP_READ(word, u16, 2)
PCI_OP_READ(dword, u32, 4)
PCI_OP_WRITE(byte, u8, 1)
PCI_OP_WRITE(word, u16, 2)
PCI_OP_WRITE(dword, u32, 4)

EXPORT_SYMBOL(pci_bus_read_config_byte);
EXPORT_SYMBOL(pci_bus_read_config_word);
EXPORT_SYMBOL(pci_bus_read_config_dword);
EXPORT_SYMBOL(pci_bus_write_config_byte);
EXPORT_SYMBOL(pci_bus_write_config_word);
EXPORT_SYMBOL(pci_bus_write_config_dword);
69

Huang Ying's avatar
Huang Ying committed
70 71 72 73 74 75 76 77 78 79 80 81
/**
 * pci_bus_set_ops - Set raw operations of pci bus
 * @bus:	pci bus struct
 * @ops:	new raw operations
 *
 * Return previous raw operations
 */
struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops)
{
	struct pci_ops *old_ops;
	unsigned long flags;

82
	raw_spin_lock_irqsave(&pci_lock, flags);
Huang Ying's avatar
Huang Ying committed
83 84
	old_ops = bus->ops;
	bus->ops = ops;
85
	raw_spin_unlock_irqrestore(&pci_lock, flags);
Huang Ying's avatar
Huang Ying committed
86 87 88
	return old_ops;
}
EXPORT_SYMBOL(pci_bus_set_ops);
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

/**
 * pci_read_vpd - Read one entry from Vital Product Data
 * @dev:	pci device struct
 * @pos:	offset in vpd space
 * @count:	number of bytes to read
 * @buf:	pointer to where to store result
 *
 */
ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf)
{
	if (!dev->vpd || !dev->vpd->ops)
		return -ENODEV;
	return dev->vpd->ops->read(dev, pos, count, buf);
}
EXPORT_SYMBOL(pci_read_vpd);

/**
 * pci_write_vpd - Write entry to Vital Product Data
 * @dev:	pci device struct
 * @pos:	offset in vpd space
110 111
 * @count:	number of bytes to write
 * @buf:	buffer containing write data
112 113 114 115 116 117 118 119 120 121
 *
 */
ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf)
{
	if (!dev->vpd || !dev->vpd->ops)
		return -ENODEV;
	return dev->vpd->ops->write(dev, pos, count, buf);
}
EXPORT_SYMBOL(pci_write_vpd);

122 123 124 125 126 127 128 129 130
/*
 * The following routines are to prevent the user from accessing PCI config
 * space when it's unsafe to do so.  Some devices require this during BIST and
 * we're required to prevent it during D-state transitions.
 *
 * We have a bit per device to indicate it's blocked and a global wait queue
 * for callers to sleep on until devices are unblocked.
 */
static DECLARE_WAIT_QUEUE_HEAD(pci_ucfg_wait);
131

132 133 134 135 136 137 138
static noinline void pci_wait_ucfg(struct pci_dev *dev)
{
	DECLARE_WAITQUEUE(wait, current);

	__add_wait_queue(&pci_ucfg_wait, &wait);
	do {
		set_current_state(TASK_UNINTERRUPTIBLE);
139
		raw_spin_unlock_irq(&pci_lock);
140
		schedule();
141
		raw_spin_lock_irq(&pci_lock);
142 143
	} while (dev->block_ucfg_access);
	__remove_wait_queue(&pci_ucfg_wait, &wait);
144 145 146 147 148 149 150 151 152
}

#define PCI_USER_READ_CONFIG(size,type)					\
int pci_user_read_config_##size						\
	(struct pci_dev *dev, int pos, type *val)			\
{									\
	int ret = 0;							\
	u32 data = -1;							\
	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\
153
	raw_spin_lock_irq(&pci_lock);				\
154 155
	if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);	\
	ret = dev->bus->ops->read(dev->bus, dev->devfn,			\
156
					pos, sizeof(type), &data);	\
157
	raw_spin_unlock_irq(&pci_lock);				\
158 159 160 161 162 163 164 165 166 167
	*val = (type)data;						\
	return ret;							\
}

#define PCI_USER_WRITE_CONFIG(size,type)				\
int pci_user_write_config_##size					\
	(struct pci_dev *dev, int pos, type val)			\
{									\
	int ret = -EIO;							\
	if (PCI_##size##_BAD) return PCIBIOS_BAD_REGISTER_NUMBER;	\
168
	raw_spin_lock_irq(&pci_lock);				\
169 170
	if (unlikely(dev->block_ucfg_access)) pci_wait_ucfg(dev);	\
	ret = dev->bus->ops->write(dev->bus, dev->devfn,		\
171
					pos, sizeof(type), val);	\
172
	raw_spin_unlock_irq(&pci_lock);				\
173 174 175 176 177 178 179 180 181 182
	return ret;							\
}

PCI_USER_READ_CONFIG(byte, u8)
PCI_USER_READ_CONFIG(word, u16)
PCI_USER_READ_CONFIG(dword, u32)
PCI_USER_WRITE_CONFIG(byte, u8)
PCI_USER_WRITE_CONFIG(word, u16)
PCI_USER_WRITE_CONFIG(dword, u32)

183 184 185 186 187 188
/* VPD access through PCI 2.2+ VPD capability */

#define PCI_VPD_PCI22_SIZE (PCI_VPD_ADDR_MASK + 1)

struct pci_vpd_pci22 {
	struct pci_vpd base;
189 190
	struct mutex lock;
	u16	flag;
191
	bool	busy;
192
	u8	cap;
193 194
};

195 196 197 198 199 200
/*
 * Wait for last operation to complete.
 * This code has to spin since there is no other notification from the PCI
 * hardware. Since the VPD is often implemented by serial attachment to an
 * EEPROM, it may take many milliseconds to complete.
 */
201 202 203 204
static int pci_vpd_pci22_wait(struct pci_dev *dev)
{
	struct pci_vpd_pci22 *vpd =
		container_of(dev->vpd, struct pci_vpd_pci22, base);
205 206
	unsigned long timeout = jiffies + HZ/20 + 2;
	u16 status;
207 208 209 210 211 212
	int ret;

	if (!vpd->busy)
		return 0;

	for (;;) {
213
		ret = pci_user_read_config_word(dev, vpd->cap + PCI_VPD_ADDR,
214
						&status);
215
		if (ret)
216
			return ret;
217 218

		if ((status & PCI_VPD_ADDR_F) == vpd->flag) {
219 220 221
			vpd->busy = false;
			return 0;
		}
222

223 224 225 226 227
		if (time_after(jiffies, timeout)) {
			dev_printk(KERN_DEBUG, &dev->dev,
				   "vpd r/w failed.  This is likely a firmware "
				   "bug on this device.  Contact the card "
				   "vendor for a firmware update.");
228
			return -ETIMEDOUT;
229
		}
230 231 232 233
		if (fatal_signal_pending(current))
			return -EINTR;
		if (!cond_resched())
			udelay(10);
234 235 236
	}
}

237 238
static ssize_t pci_vpd_pci22_read(struct pci_dev *dev, loff_t pos, size_t count,
				  void *arg)
239 240 241
{
	struct pci_vpd_pci22 *vpd =
		container_of(dev->vpd, struct pci_vpd_pci22, base);
242 243 244
	int ret;
	loff_t end = pos + count;
	u8 *buf = arg;
245

246
	if (pos < 0 || pos > vpd->base.len || end > vpd->base.len)
247 248
		return -EINVAL;

249 250 251
	if (mutex_lock_killable(&vpd->lock))
		return -EINTR;

252 253 254
	ret = pci_vpd_pci22_wait(dev);
	if (ret < 0)
		goto out;
255

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
	while (pos < end) {
		u32 val;
		unsigned int i, skip;

		ret = pci_user_write_config_word(dev, vpd->cap + PCI_VPD_ADDR,
						 pos & ~3);
		if (ret < 0)
			break;
		vpd->busy = true;
		vpd->flag = PCI_VPD_ADDR_F;
		ret = pci_vpd_pci22_wait(dev);
		if (ret < 0)
			break;

		ret = pci_user_read_config_dword(dev, vpd->cap + PCI_VPD_DATA, &val);
		if (ret < 0)
			break;

		skip = pos & 3;
		for (i = 0;  i < sizeof(u32); i++) {
			if (i >= skip) {
				*buf++ = val;
				if (++pos == end)
					break;
			}
			val >>= 8;
		}
	}
284
out:
285
	mutex_unlock(&vpd->lock);
286
	return ret ? ret : count;
287 288
}

289 290
static ssize_t pci_vpd_pci22_write(struct pci_dev *dev, loff_t pos, size_t count,
				   const void *arg)
291 292 293
{
	struct pci_vpd_pci22 *vpd =
		container_of(dev->vpd, struct pci_vpd_pci22, base);
294 295
	const u8 *buf = arg;
	loff_t end = pos + count;
296
	int ret = 0;
297

298
	if (pos < 0 || (pos & 3) || (count & 3) || end > vpd->base.len)
299 300
		return -EINVAL;

301 302
	if (mutex_lock_killable(&vpd->lock))
		return -EINTR;
303

304 305 306
	ret = pci_vpd_pci22_wait(dev);
	if (ret < 0)
		goto out;
307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326

	while (pos < end) {
		u32 val;

		val = *buf++;
		val |= *buf++ << 8;
		val |= *buf++ << 16;
		val |= *buf++ << 24;

		ret = pci_user_write_config_dword(dev, vpd->cap + PCI_VPD_DATA, val);
		if (ret < 0)
			break;
		ret = pci_user_write_config_word(dev, vpd->cap + PCI_VPD_ADDR,
						 pos | PCI_VPD_ADDR_F);
		if (ret < 0)
			break;

		vpd->busy = true;
		vpd->flag = 0;
		ret = pci_vpd_pci22_wait(dev);
327 328
		if (ret < 0)
			break;
329 330 331

		pos += sizeof(u32);
	}
332
out:
333
	mutex_unlock(&vpd->lock);
334
	return ret ? ret : count;
335 336 337 338 339 340 341
}

static void pci_vpd_pci22_release(struct pci_dev *dev)
{
	kfree(container_of(dev->vpd, struct pci_vpd_pci22, base));
}

342
static const struct pci_vpd_ops pci_vpd_pci22_ops = {
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
	.read = pci_vpd_pci22_read,
	.write = pci_vpd_pci22_write,
	.release = pci_vpd_pci22_release,
};

int pci_vpd_pci22_init(struct pci_dev *dev)
{
	struct pci_vpd_pci22 *vpd;
	u8 cap;

	cap = pci_find_capability(dev, PCI_CAP_ID_VPD);
	if (!cap)
		return -ENODEV;
	vpd = kzalloc(sizeof(*vpd), GFP_ATOMIC);
	if (!vpd)
		return -ENOMEM;

360
	vpd->base.len = PCI_VPD_PCI22_SIZE;
361
	vpd->base.ops = &pci_vpd_pci22_ops;
362
	mutex_init(&vpd->lock);
363 364 365 366 367 368
	vpd->cap = cap;
	vpd->busy = false;
	dev->vpd = &vpd->base;
	return 0;
}

369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
/**
 * pci_vpd_truncate - Set available Vital Product Data size
 * @dev:	pci device struct
 * @size:	available memory in bytes
 *
 * Adjust size of available VPD area.
 */
int pci_vpd_truncate(struct pci_dev *dev, size_t size)
{
	if (!dev->vpd)
		return -EINVAL;

	/* limited by the access method */
	if (size > dev->vpd->len)
		return -EINVAL;

	dev->vpd->len = size;
386 387
	if (dev->vpd->attr)
		dev->vpd->attr->size = size;
388 389 390 391 392

	return 0;
}
EXPORT_SYMBOL(pci_vpd_truncate);

393 394 395 396
/**
 * pci_block_user_cfg_access - Block userspace PCI config reads/writes
 * @dev:	pci device struct
 *
397 398 399 400
 * When user access is blocked, any reads or writes to config space will
 * sleep until access is unblocked again.  We don't allow nesting of
 * block/unblock calls.
 */
401 402 403
void pci_block_user_cfg_access(struct pci_dev *dev)
{
	unsigned long flags;
404
	int was_blocked;
405

406
	raw_spin_lock_irqsave(&pci_lock, flags);
407
	was_blocked = dev->block_ucfg_access;
408
	dev->block_ucfg_access = 1;
409
	raw_spin_unlock_irqrestore(&pci_lock, flags);
410 411 412 413

	/* If we BUG() inside the pci_lock, we're guaranteed to hose
	 * the machine */
	BUG_ON(was_blocked);
414 415 416 417 418 419 420 421
}
EXPORT_SYMBOL_GPL(pci_block_user_cfg_access);

/**
 * pci_unblock_user_cfg_access - Unblock userspace PCI config reads/writes
 * @dev:	pci device struct
 *
 * This function allows userspace PCI config accesses to resume.
422
 */
423 424 425 426
void pci_unblock_user_cfg_access(struct pci_dev *dev)
{
	unsigned long flags;

427
	raw_spin_lock_irqsave(&pci_lock, flags);
428 429 430 431 432

	/* This indicates a problem in the caller, but we don't need
	 * to kill them, unlike a double-block above. */
	WARN_ON(!dev->block_ucfg_access);

433
	dev->block_ucfg_access = 0;
434
	wake_up_all(&pci_ucfg_wait);
435
	raw_spin_unlock_irqrestore(&pci_lock, flags);
436 437
}
EXPORT_SYMBOL_GPL(pci_unblock_user_cfg_access);