2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* ISA Plug & Play support
|
2007-10-15 14:50:19 +07:00
|
|
|
* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*
|
|
|
|
* Changelog:
|
|
|
|
* 2000-01-01 Added quirks handling for buggy hardware
|
|
|
|
* Peter Denison <peterd@pnd-pc.demon.co.uk>
|
|
|
|
* 2000-06-14 Added isapnp_probe_devs() and isapnp_activate_dev()
|
|
|
|
* Christoph Hellwig <hch@infradead.org>
|
|
|
|
* 2001-06-03 Added release_region calls to correspond with
|
|
|
|
* request_region calls when a failure occurs. Also
|
|
|
|
* added KERN_* constants to printk() calls.
|
|
|
|
* 2001-11-07 Added isapnp_{,un}register_driver calls along the lines
|
|
|
|
* of the pci driver interface
|
|
|
|
* Kai Germaschewski <kai.germaschewski@gmx.de>
|
|
|
|
* 2002-06-06 Made the use of dma channel 0 configurable
|
|
|
|
* Gerald Teschl <gerald.teschl@univie.ac.at>
|
|
|
|
* 2002-10-06 Ported to PnP Layer - Adam Belay <ambx1@neo.rr.com>
|
|
|
|
* 2003-08-11 Resource Management Updates - Adam Belay <ambx1@neo.rr.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/isapnp.h>
|
2006-03-26 16:37:14 +07:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/io.h>
|
|
|
|
|
2008-04-29 05:33:52 +07:00
|
|
|
#include "../base.h"
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
#if 0
|
|
|
|
#define ISAPNP_REGION_OK
|
|
|
|
#endif
|
|
|
|
|
2007-07-27 00:41:20 +07:00
|
|
|
int isapnp_disable; /* Disable ISA PnP */
|
|
|
|
static int isapnp_rdp; /* Read Data Port */
|
|
|
|
static int isapnp_reset = 1; /* reset all PnP cards (deactivate) */
|
|
|
|
static int isapnp_verbose = 1; /* verbose mode */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-10-15 14:50:19 +07:00
|
|
|
MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
|
2005-04-17 05:20:36 +07:00
|
|
|
MODULE_DESCRIPTION("Generic ISA Plug & Play support");
|
|
|
|
module_param(isapnp_disable, int, 0);
|
|
|
|
MODULE_PARM_DESC(isapnp_disable, "ISA Plug & Play disable");
|
|
|
|
module_param(isapnp_rdp, int, 0);
|
|
|
|
MODULE_PARM_DESC(isapnp_rdp, "ISA Plug & Play read data port");
|
|
|
|
module_param(isapnp_reset, int, 0);
|
|
|
|
MODULE_PARM_DESC(isapnp_reset, "ISA Plug & Play reset all cards");
|
|
|
|
module_param(isapnp_verbose, int, 0);
|
|
|
|
MODULE_PARM_DESC(isapnp_verbose, "ISA Plug & Play verbose mode");
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
#define _PIDXR 0x279
|
|
|
|
#define _PNPWRP 0xa79
|
|
|
|
|
|
|
|
/* short tags */
|
|
|
|
#define _STAG_PNPVERNO 0x01
|
|
|
|
#define _STAG_LOGDEVID 0x02
|
|
|
|
#define _STAG_COMPATDEVID 0x03
|
|
|
|
#define _STAG_IRQ 0x04
|
|
|
|
#define _STAG_DMA 0x05
|
|
|
|
#define _STAG_STARTDEP 0x06
|
|
|
|
#define _STAG_ENDDEP 0x07
|
|
|
|
#define _STAG_IOPORT 0x08
|
|
|
|
#define _STAG_FIXEDIO 0x09
|
|
|
|
#define _STAG_VENDOR 0x0e
|
|
|
|
#define _STAG_END 0x0f
|
|
|
|
/* long tags */
|
|
|
|
#define _LTAG_MEMRANGE 0x81
|
|
|
|
#define _LTAG_ANSISTR 0x82
|
|
|
|
#define _LTAG_UNICODESTR 0x83
|
|
|
|
#define _LTAG_VENDOR 0x84
|
|
|
|
#define _LTAG_MEM32RANGE 0x85
|
|
|
|
#define _LTAG_FIXEDMEM32RANGE 0x86
|
|
|
|
|
2008-04-29 05:33:49 +07:00
|
|
|
/* Logical device control and configuration registers */
|
|
|
|
|
|
|
|
#define ISAPNP_CFG_ACTIVATE 0x30 /* byte */
|
|
|
|
#define ISAPNP_CFG_MEM 0x40 /* 4 * dword */
|
|
|
|
#define ISAPNP_CFG_PORT 0x60 /* 8 * word */
|
|
|
|
#define ISAPNP_CFG_IRQ 0x70 /* 2 * word */
|
|
|
|
#define ISAPNP_CFG_DMA 0x74 /* 2 * byte */
|
|
|
|
|
2008-03-22 01:08:37 +07:00
|
|
|
/*
|
|
|
|
* Sizes of ISAPNP logical device configuration register sets.
|
|
|
|
* See PNP-ISA-v1.0a.pdf, Appendix A.
|
|
|
|
*/
|
|
|
|
#define ISAPNP_MAX_MEM 4
|
|
|
|
#define ISAPNP_MAX_PORT 8
|
|
|
|
#define ISAPNP_MAX_IRQ 2
|
|
|
|
#define ISAPNP_MAX_DMA 2
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static unsigned char isapnp_checksum_value;
|
2006-03-26 16:37:14 +07:00
|
|
|
static DEFINE_MUTEX(isapnp_cfg_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
static int isapnp_csn_count;
|
|
|
|
|
|
|
|
/* some prototypes */
|
|
|
|
|
|
|
|
static inline void write_data(unsigned char x)
|
|
|
|
{
|
|
|
|
outb(x, _PNPWRP);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void write_address(unsigned char x)
|
|
|
|
{
|
|
|
|
outb(x, _PIDXR);
|
|
|
|
udelay(20);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned char read_data(void)
|
|
|
|
{
|
|
|
|
unsigned char val = inb(isapnp_rdp);
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned char isapnp_read_byte(unsigned char idx)
|
|
|
|
{
|
|
|
|
write_address(idx);
|
|
|
|
return read_data();
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned short isapnp_read_word(unsigned char idx)
|
|
|
|
{
|
|
|
|
unsigned short val;
|
|
|
|
|
|
|
|
val = isapnp_read_byte(idx);
|
2007-07-27 00:41:20 +07:00
|
|
|
val = (val << 8) + isapnp_read_byte(idx + 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
void isapnp_write_byte(unsigned char idx, unsigned char val)
|
|
|
|
{
|
|
|
|
write_address(idx);
|
|
|
|
write_data(val);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_write_word(unsigned char idx, unsigned short val)
|
|
|
|
{
|
|
|
|
isapnp_write_byte(idx, val >> 8);
|
2007-07-27 00:41:20 +07:00
|
|
|
isapnp_write_byte(idx + 1, val);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_key(void)
|
|
|
|
{
|
|
|
|
unsigned char code = 0x6a, msb;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
mdelay(1);
|
|
|
|
write_address(0x00);
|
|
|
|
write_address(0x00);
|
|
|
|
|
|
|
|
write_address(code);
|
|
|
|
|
|
|
|
for (i = 1; i < 32; i++) {
|
|
|
|
msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
|
|
|
|
code = (code >> 1) | msb;
|
|
|
|
write_address(code);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* place all pnp cards in wait-for-key state */
|
|
|
|
static void isapnp_wait(void)
|
|
|
|
{
|
|
|
|
isapnp_write_byte(0x02, 0x02);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_wake(unsigned char csn)
|
|
|
|
{
|
|
|
|
isapnp_write_byte(0x03, csn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_device(unsigned char logdev)
|
|
|
|
{
|
|
|
|
isapnp_write_byte(0x07, logdev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_activate(unsigned char logdev)
|
|
|
|
{
|
|
|
|
isapnp_device(logdev);
|
|
|
|
isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 1);
|
|
|
|
udelay(250);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void isapnp_deactivate(unsigned char logdev)
|
|
|
|
{
|
|
|
|
isapnp_device(logdev);
|
|
|
|
isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 0);
|
|
|
|
udelay(500);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __init isapnp_peek(unsigned char *data, int bytes)
|
|
|
|
{
|
|
|
|
int i, j;
|
2007-07-27 00:41:20 +07:00
|
|
|
unsigned char d = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
for (i = 1; i <= bytes; i++) {
|
|
|
|
for (j = 0; j < 20; j++) {
|
|
|
|
d = isapnp_read_byte(0x05);
|
|
|
|
if (d & 1)
|
|
|
|
break;
|
|
|
|
udelay(100);
|
|
|
|
}
|
|
|
|
if (!(d & 1)) {
|
|
|
|
if (data != NULL)
|
|
|
|
*data++ = 0xff;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
d = isapnp_read_byte(0x04); /* PRESDI */
|
|
|
|
isapnp_checksum_value += d;
|
|
|
|
if (data != NULL)
|
|
|
|
*data++ = d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RDP_STEP 32 /* minimum is 4 */
|
|
|
|
|
|
|
|
static int isapnp_next_rdp(void)
|
|
|
|
{
|
|
|
|
int rdp = isapnp_rdp;
|
|
|
|
static int old_rdp = 0;
|
2007-07-27 00:41:20 +07:00
|
|
|
|
|
|
|
if (old_rdp) {
|
2005-04-17 05:20:36 +07:00
|
|
|
release_region(old_rdp, 1);
|
|
|
|
old_rdp = 0;
|
|
|
|
}
|
|
|
|
while (rdp <= 0x3ff) {
|
|
|
|
/*
|
2007-07-27 00:41:20 +07:00
|
|
|
* We cannot use NE2000 probe spaces for ISAPnP or we
|
|
|
|
* will lock up machines.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-27 00:41:20 +07:00
|
|
|
if ((rdp < 0x280 || rdp > 0x380)
|
|
|
|
&& request_region(rdp, 1, "ISAPnP")) {
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_rdp = rdp;
|
|
|
|
old_rdp = rdp;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
rdp += RDP_STEP;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set read port address */
|
|
|
|
static inline void isapnp_set_rdp(void)
|
|
|
|
{
|
|
|
|
isapnp_write_byte(0x00, isapnp_rdp >> 2);
|
|
|
|
udelay(100);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform an isolation. The port selection code now tries to avoid
|
|
|
|
* "dangerous to read" ports.
|
|
|
|
*/
|
|
|
|
static int __init isapnp_isolate_rdp_select(void)
|
|
|
|
{
|
|
|
|
isapnp_wait();
|
|
|
|
isapnp_key();
|
|
|
|
|
|
|
|
/* Control: reset CSN and conditionally everything else too */
|
|
|
|
isapnp_write_byte(0x02, isapnp_reset ? 0x05 : 0x04);
|
|
|
|
mdelay(2);
|
|
|
|
|
|
|
|
isapnp_wait();
|
|
|
|
isapnp_key();
|
|
|
|
isapnp_wake(0x00);
|
|
|
|
|
|
|
|
if (isapnp_next_rdp() < 0) {
|
|
|
|
isapnp_wait();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
isapnp_set_rdp();
|
|
|
|
udelay(1000);
|
|
|
|
write_address(0x01);
|
|
|
|
udelay(1000);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Isolate (assign uniqued CSN) to all ISA PnP devices.
|
|
|
|
*/
|
|
|
|
static int __init isapnp_isolate(void)
|
|
|
|
{
|
|
|
|
unsigned char checksum = 0x6a;
|
|
|
|
unsigned char chksum = 0x00;
|
|
|
|
unsigned char bit = 0x00;
|
|
|
|
int data;
|
|
|
|
int csn = 0;
|
|
|
|
int i;
|
|
|
|
int iteration = 1;
|
|
|
|
|
|
|
|
isapnp_rdp = 0x213;
|
|
|
|
if (isapnp_isolate_rdp_select() < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
for (i = 1; i <= 64; i++) {
|
|
|
|
data = read_data() << 8;
|
|
|
|
udelay(250);
|
|
|
|
data = data | read_data();
|
|
|
|
udelay(250);
|
|
|
|
if (data == 0x55aa)
|
|
|
|
bit = 0x01;
|
2007-07-27 00:41:20 +07:00
|
|
|
checksum =
|
|
|
|
((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
|
|
|
|
| (checksum >> 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
bit = 0x00;
|
|
|
|
}
|
|
|
|
for (i = 65; i <= 72; i++) {
|
|
|
|
data = read_data() << 8;
|
|
|
|
udelay(250);
|
|
|
|
data = data | read_data();
|
|
|
|
udelay(250);
|
|
|
|
if (data == 0x55aa)
|
|
|
|
chksum |= (1 << (i - 65));
|
|
|
|
}
|
|
|
|
if (checksum != 0x00 && checksum == chksum) {
|
|
|
|
csn++;
|
|
|
|
|
|
|
|
isapnp_write_byte(0x06, csn);
|
|
|
|
udelay(250);
|
|
|
|
iteration++;
|
|
|
|
isapnp_wake(0x00);
|
|
|
|
isapnp_set_rdp();
|
|
|
|
udelay(1000);
|
|
|
|
write_address(0x01);
|
|
|
|
udelay(1000);
|
|
|
|
goto __next;
|
|
|
|
}
|
|
|
|
if (iteration == 1) {
|
|
|
|
isapnp_rdp += RDP_STEP;
|
|
|
|
if (isapnp_isolate_rdp_select() < 0)
|
|
|
|
return -1;
|
|
|
|
} else if (iteration > 1) {
|
|
|
|
break;
|
|
|
|
}
|
2007-08-15 23:32:08 +07:00
|
|
|
__next:
|
2005-04-17 05:20:36 +07:00
|
|
|
if (csn == 255)
|
|
|
|
break;
|
|
|
|
checksum = 0x6a;
|
|
|
|
chksum = 0x00;
|
|
|
|
bit = 0x00;
|
|
|
|
}
|
|
|
|
isapnp_wait();
|
|
|
|
isapnp_csn_count = csn;
|
|
|
|
return csn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read one tag from stream.
|
|
|
|
*/
|
|
|
|
static int __init isapnp_read_tag(unsigned char *type, unsigned short *size)
|
|
|
|
{
|
|
|
|
unsigned char tag, tmp[2];
|
|
|
|
|
|
|
|
isapnp_peek(&tag, 1);
|
2007-07-27 00:41:20 +07:00
|
|
|
if (tag == 0) /* invalid tag */
|
2005-04-17 05:20:36 +07:00
|
|
|
return -1;
|
|
|
|
if (tag & 0x80) { /* large item */
|
|
|
|
*type = tag;
|
|
|
|
isapnp_peek(tmp, 2);
|
|
|
|
*size = (tmp[1] << 8) | tmp[0];
|
|
|
|
} else {
|
|
|
|
*type = (tag >> 3) & 0x0f;
|
|
|
|
*size = tag & 0x07;
|
|
|
|
}
|
|
|
|
#if 0
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type,
|
|
|
|
*size);
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
if (*type == 0xff && *size == 0xffff) /* probably invalid data */
|
|
|
|
return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Skip specified number of bytes from stream.
|
|
|
|
*/
|
|
|
|
static void __init isapnp_skip_bytes(int count)
|
|
|
|
{
|
|
|
|
isapnp_peek(NULL, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse logical device tag.
|
|
|
|
*/
|
2007-07-27 00:41:20 +07:00
|
|
|
static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
|
|
|
|
int size, int number)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[6];
|
|
|
|
struct pnp_dev *dev;
|
2008-04-29 05:33:53 +07:00
|
|
|
u32 eisa_id;
|
|
|
|
char id[8];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-04-29 05:33:53 +07:00
|
|
|
eisa_id = tmp[0] | tmp[1] << 8 | tmp[2] << 16 | tmp[3] << 24;
|
|
|
|
pnp_eisa_id_to_string(eisa_id, id);
|
2008-04-29 05:33:54 +07:00
|
|
|
|
|
|
|
dev = pnp_alloc_dev(&isapnp_protocol, number, id);
|
|
|
|
if (!dev)
|
|
|
|
return NULL;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
dev->card = card;
|
|
|
|
dev->capabilities |= PNP_CONFIGURABLE;
|
|
|
|
dev->capabilities |= PNP_READ;
|
|
|
|
dev->capabilities |= PNP_WRITE;
|
|
|
|
dev->capabilities |= PNP_DISABLE;
|
2008-04-29 05:34:09 +07:00
|
|
|
pnp_init_resources(dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
return dev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add IRQ resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_irq_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[3];
|
|
|
|
unsigned long bits;
|
2008-06-28 05:57:11 +07:00
|
|
|
pnp_irq_mask_t map;
|
|
|
|
unsigned char flags = IORESOURCE_IRQ_HIGHEDGE;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
|
|
|
bits = (tmp[1] << 8) | tmp[0];
|
2008-06-28 05:57:11 +07:00
|
|
|
|
|
|
|
bitmap_zero(map.bits, PNP_IRQ_NR);
|
|
|
|
bitmap_copy(map.bits, &bits, 16);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (size > 2)
|
2008-06-28 05:57:11 +07:00
|
|
|
flags = tmp[2];
|
|
|
|
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_irq_resource(dev, option_flags, &map, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add DMA resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_dma_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[2];
|
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_dma_resource(dev, option_flags, tmp[0], tmp[1]);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add port resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_port_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[7];
|
2008-06-28 05:57:11 +07:00
|
|
|
resource_size_t min, max, align, len;
|
|
|
|
unsigned char flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:11 +07:00
|
|
|
min = (tmp[2] << 8) | tmp[1];
|
|
|
|
max = (tmp[4] << 8) | tmp[3];
|
|
|
|
align = tmp[5];
|
|
|
|
len = tmp[6];
|
|
|
|
flags = tmp[0] ? IORESOURCE_IO_16BIT_ADDR : 0;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_port_resource(dev, option_flags,
|
|
|
|
min, max, align, len, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add fixed port resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_fixed_port_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[3];
|
2008-06-28 05:57:11 +07:00
|
|
|
resource_size_t base, len;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:11 +07:00
|
|
|
base = (tmp[1] << 8) | tmp[0];
|
|
|
|
len = tmp[2];
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_port_resource(dev, option_flags, base, base, 0, len,
|
2008-06-28 05:57:11 +07:00
|
|
|
IORESOURCE_IO_FIXED);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add memory resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_mem_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[9];
|
2008-06-28 05:57:11 +07:00
|
|
|
resource_size_t min, max, align, len;
|
|
|
|
unsigned char flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:11 +07:00
|
|
|
min = ((tmp[2] << 8) | tmp[1]) << 8;
|
|
|
|
max = ((tmp[4] << 8) | tmp[3]) << 8;
|
|
|
|
align = (tmp[6] << 8) | tmp[5];
|
|
|
|
len = ((tmp[8] << 8) | tmp[7]) << 8;
|
|
|
|
flags = tmp[0];
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_mem_resource(dev, option_flags,
|
|
|
|
min, max, align, len, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add 32-bit memory resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_mem32_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[17];
|
2008-06-28 05:57:11 +07:00
|
|
|
resource_size_t min, max, align, len;
|
|
|
|
unsigned char flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:11 +07:00
|
|
|
min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
|
|
|
|
max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
|
|
|
|
align = (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
|
|
|
|
len = (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
|
|
|
|
flags = tmp[0];
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_mem_resource(dev, option_flags,
|
|
|
|
min, max, align, len, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add 32-bit fixed memory resource to resources list.
|
|
|
|
*/
|
2008-04-29 05:34:04 +07:00
|
|
|
static void __init isapnp_parse_fixed_mem32_resource(struct pnp_dev *dev,
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags,
|
2007-07-27 00:41:20 +07:00
|
|
|
int size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
unsigned char tmp[9];
|
2008-06-28 05:57:11 +07:00
|
|
|
resource_size_t base, len;
|
|
|
|
unsigned char flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:11 +07:00
|
|
|
base = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
|
|
|
|
len = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
|
|
|
|
flags = tmp[0];
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
pnp_register_mem_resource(dev, option_flags, base, base, 0, len, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse card name for ISA PnP device.
|
2007-07-27 00:41:20 +07:00
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
static void __init
|
|
|
|
isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size)
|
|
|
|
{
|
|
|
|
if (name[0] == '\0') {
|
2007-07-27 00:41:20 +07:00
|
|
|
unsigned short size1 =
|
|
|
|
*size >= name_max ? (name_max - 1) : *size;
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_peek(name, size1);
|
|
|
|
name[size1] = '\0';
|
|
|
|
*size -= size1;
|
|
|
|
|
|
|
|
/* clean whitespace from end of string */
|
2007-07-27 00:41:20 +07:00
|
|
|
while (size1 > 0 && name[--size1] == ' ')
|
2005-04-17 05:20:36 +07:00
|
|
|
name[size1] = '\0';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse resource map for logical device.
|
|
|
|
*/
|
|
|
|
static int __init isapnp_create_device(struct pnp_card *card,
|
|
|
|
unsigned short size)
|
|
|
|
{
|
2008-06-28 05:57:15 +07:00
|
|
|
int number = 0, skip = 0, priority, compat = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned char type, tmp[17];
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
unsigned int option_flags;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct pnp_dev *dev;
|
2008-04-29 05:33:53 +07:00
|
|
|
u32 eisa_id;
|
|
|
|
char id[8];
|
2007-07-27 00:41:21 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
|
|
|
|
return 1;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
option_flags = 0;
|
2007-07-27 00:41:20 +07:00
|
|
|
pnp_add_card_device(card, dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
while (1) {
|
2007-07-27 00:41:20 +07:00
|
|
|
if (isapnp_read_tag(&type, &size) < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
if (skip && type != _STAG_LOGDEVID && type != _STAG_END)
|
|
|
|
goto __skip;
|
|
|
|
switch (type) {
|
|
|
|
case _STAG_LOGDEVID:
|
|
|
|
if (size >= 5 && size <= 6) {
|
2007-07-27 00:41:20 +07:00
|
|
|
if ((dev =
|
|
|
|
isapnp_parse_device(card, size,
|
|
|
|
number++)) == NULL)
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
size = 0;
|
|
|
|
skip = 0;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
option_flags = 0;
|
2007-07-27 00:41:20 +07:00
|
|
|
pnp_add_card_device(card, dev);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else {
|
|
|
|
skip = 1;
|
|
|
|
}
|
|
|
|
compat = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_COMPATDEVID:
|
|
|
|
if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
|
|
|
|
isapnp_peek(tmp, 4);
|
2008-04-29 05:33:53 +07:00
|
|
|
eisa_id = tmp[0] | tmp[1] << 8 |
|
|
|
|
tmp[2] << 16 | tmp[3] << 24;
|
|
|
|
pnp_eisa_id_to_string(eisa_id, id);
|
|
|
|
pnp_add_id(dev, id);
|
2005-04-17 05:20:36 +07:00
|
|
|
compat++;
|
|
|
|
size = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case _STAG_IRQ:
|
|
|
|
if (size < 2 || size > 3)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_irq_resource(dev, option_flags, size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_DMA:
|
|
|
|
if (size != 2)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_dma_resource(dev, option_flags, size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_STARTDEP:
|
|
|
|
if (size > 1)
|
|
|
|
goto __skip;
|
2008-06-28 05:57:15 +07:00
|
|
|
priority = PNP_RES_PRIORITY_ACCEPTABLE;
|
2005-04-17 05:20:36 +07:00
|
|
|
if (size > 0) {
|
|
|
|
isapnp_peek(tmp, size);
|
2008-06-28 05:57:15 +07:00
|
|
|
priority = tmp[0];
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
}
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
option_flags = pnp_new_dependent_set(dev, priority);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case _STAG_ENDDEP:
|
|
|
|
if (size != 0)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
option_flags = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case _STAG_IOPORT:
|
|
|
|
if (size != 7)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_port_resource(dev, option_flags, size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_FIXEDIO:
|
|
|
|
if (size != 3)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_fixed_port_resource(dev, option_flags,
|
|
|
|
size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_VENDOR:
|
|
|
|
break;
|
|
|
|
case _LTAG_MEMRANGE:
|
|
|
|
if (size != 9)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_mem_resource(dev, option_flags, size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _LTAG_ANSISTR:
|
|
|
|
isapnp_parse_name(dev->name, sizeof(dev->name), &size);
|
|
|
|
break;
|
|
|
|
case _LTAG_UNICODESTR:
|
|
|
|
/* silently ignore */
|
|
|
|
/* who use unicode for hardware identification? */
|
|
|
|
break;
|
|
|
|
case _LTAG_VENDOR:
|
|
|
|
break;
|
|
|
|
case _LTAG_MEM32RANGE:
|
|
|
|
if (size != 17)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_mem32_resource(dev, option_flags, size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _LTAG_FIXEDMEM32RANGE:
|
|
|
|
if (size != 9)
|
|
|
|
goto __skip;
|
PNP: convert resource options to single linked list
ISAPNP, PNPBIOS, and ACPI describe the "possible resource settings" of
a device, i.e., the possibilities an OS bus driver has when it assigns
I/O port, MMIO, and other resources to the device.
PNP used to maintain this "possible resource setting" information in
one independent option structure and a list of dependent option
structures for each device. Each of these option structures had lists
of I/O, memory, IRQ, and DMA resources, for example:
dev
independent options
ind-io0 -> ind-io1 ...
ind-mem0 -> ind-mem1 ...
...
dependent option set 0
dep0-io0 -> dep0-io1 ...
dep0-mem0 -> dep0-mem1 ...
...
dependent option set 1
dep1-io0 -> dep1-io1 ...
dep1-mem0 -> dep1-mem1 ...
...
...
This data structure was designed for ISAPNP, where the OS configures
device resource settings by writing directly to configuration
registers. The OS can write the registers in arbitrary order much
like it writes PCI BARs.
However, for PNPBIOS and ACPI devices, the OS uses firmware interfaces
that perform device configuration, and it is important to pass the
desired settings to those interfaces in the correct order. The OS
learns the correct order by using firmware interfaces that return the
"current resource settings" and "possible resource settings," but the
option structures above doesn't store the ordering information.
This patch replaces the independent and dependent lists with a single
list of options. For example, a device might have possible resource
settings like this:
dev
options
ind-io0 -> dep0-io0 -> dep1->io0 -> ind-io1 ...
All the possible settings are in the same list, in the order they
come from the firmware "possible resource settings" list. Each entry
is tagged with an independent/dependent flag. Dependent entries also
have a "set number" and an optional priority value. All dependent
entries must be assigned from the same set. For example, the OS can
use all the entries from dependent set 0, or all the entries from
dependent set 1, but it cannot mix entries from set 0 with entries
from set 1.
Prior to this patch PNP didn't keep track of the order of this list,
and it assigned all independent options first, then all dependent
ones. Using the example above, that resulted in a "desired
configuration" list like this:
ind->io0 -> ind->io1 -> depN-io0 ...
instead of the list the firmware expects, which looks like this:
ind->io0 -> depN-io0 -> ind-io1 ...
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Rene Herman <rene.herman@gmail.com>
Signed-off-by: Len Brown <len.brown@intel.com>
2008-06-28 05:57:17 +07:00
|
|
|
isapnp_parse_fixed_mem32_resource(dev, option_flags,
|
|
|
|
size);
|
2005-04-17 05:20:36 +07:00
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_END:
|
|
|
|
if (size > 0)
|
|
|
|
isapnp_skip_bytes(size);
|
|
|
|
return 1;
|
|
|
|
default:
|
2008-04-29 05:34:12 +07:00
|
|
|
dev_err(&dev->dev, "unknown tag %#x (card %i), "
|
|
|
|
"ignored\n", type, card->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-08-15 23:32:08 +07:00
|
|
|
__skip:
|
2007-07-27 00:41:20 +07:00
|
|
|
if (size > 0)
|
|
|
|
isapnp_skip_bytes(size);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Parse resource map for ISA PnP card.
|
|
|
|
*/
|
|
|
|
static void __init isapnp_parse_resource_map(struct pnp_card *card)
|
|
|
|
{
|
|
|
|
unsigned char type, tmp[17];
|
|
|
|
unsigned short size;
|
|
|
|
|
|
|
|
while (1) {
|
2007-07-27 00:41:20 +07:00
|
|
|
if (isapnp_read_tag(&type, &size) < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
switch (type) {
|
|
|
|
case _STAG_PNPVERNO:
|
|
|
|
if (size != 2)
|
|
|
|
goto __skip;
|
|
|
|
isapnp_peek(tmp, 2);
|
|
|
|
card->pnpver = tmp[0];
|
|
|
|
card->productver = tmp[1];
|
|
|
|
size = 0;
|
|
|
|
break;
|
|
|
|
case _STAG_LOGDEVID:
|
|
|
|
if (size >= 5 && size <= 6) {
|
2007-07-27 00:41:20 +07:00
|
|
|
if (isapnp_create_device(card, size) == 1)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
size = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case _STAG_VENDOR:
|
|
|
|
break;
|
|
|
|
case _LTAG_ANSISTR:
|
2007-07-27 00:41:20 +07:00
|
|
|
isapnp_parse_name(card->name, sizeof(card->name),
|
|
|
|
&size);
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
|
|
|
case _LTAG_UNICODESTR:
|
|
|
|
/* silently ignore */
|
|
|
|
/* who use unicode for hardware identification? */
|
|
|
|
break;
|
|
|
|
case _LTAG_VENDOR:
|
|
|
|
break;
|
|
|
|
case _STAG_END:
|
|
|
|
if (size > 0)
|
|
|
|
isapnp_skip_bytes(size);
|
|
|
|
return;
|
|
|
|
default:
|
2008-04-29 05:34:12 +07:00
|
|
|
dev_err(&card->dev, "unknown tag %#x, ignored\n",
|
|
|
|
type);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-08-15 23:32:08 +07:00
|
|
|
__skip:
|
2007-07-27 00:41:20 +07:00
|
|
|
if (size > 0)
|
|
|
|
isapnp_skip_bytes(size);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Compute ISA PnP checksum for first eight bytes.
|
|
|
|
*/
|
|
|
|
static unsigned char __init isapnp_checksum(unsigned char *data)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
unsigned char checksum = 0x6a, bit, b;
|
|
|
|
|
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
b = data[i];
|
|
|
|
for (j = 0; j < 8; j++) {
|
|
|
|
bit = 0;
|
|
|
|
if (b & (1 << j))
|
|
|
|
bit = 1;
|
2007-07-27 00:41:20 +07:00
|
|
|
checksum =
|
|
|
|
((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
|
|
|
|
| (checksum >> 1);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return checksum;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Build device list for all present ISA PnP devices.
|
|
|
|
*/
|
|
|
|
static int __init isapnp_build_device_list(void)
|
|
|
|
{
|
|
|
|
int csn;
|
|
|
|
unsigned char header[9], checksum;
|
|
|
|
struct pnp_card *card;
|
2008-04-29 05:33:57 +07:00
|
|
|
u32 eisa_id;
|
|
|
|
char id[8];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
isapnp_wait();
|
|
|
|
isapnp_key();
|
|
|
|
for (csn = 1; csn <= isapnp_csn_count; csn++) {
|
|
|
|
isapnp_wake(csn);
|
|
|
|
isapnp_peek(header, 9);
|
|
|
|
checksum = isapnp_checksum(header);
|
2008-04-29 05:33:57 +07:00
|
|
|
eisa_id = header[0] | header[1] << 8 |
|
|
|
|
header[2] << 16 | header[3] << 24;
|
|
|
|
pnp_eisa_id_to_string(eisa_id, id);
|
2008-04-29 05:33:58 +07:00
|
|
|
card = pnp_alloc_card(&isapnp_protocol, csn, id);
|
|
|
|
if (!card)
|
|
|
|
continue;
|
|
|
|
|
2008-04-29 05:34:12 +07:00
|
|
|
#if 0
|
|
|
|
dev_info(&card->dev,
|
|
|
|
"vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
|
|
header[0], header[1], header[2], header[3], header[4],
|
|
|
|
header[5], header[6], header[7], header[8]);
|
|
|
|
dev_info(&card->dev, "checksum = %#x\n", checksum);
|
|
|
|
#endif
|
2008-04-29 05:33:58 +07:00
|
|
|
INIT_LIST_HEAD(&card->devices);
|
2007-07-27 00:41:20 +07:00
|
|
|
card->serial =
|
|
|
|
(header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
|
|
|
|
header[4];
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_checksum_value = 0x00;
|
|
|
|
isapnp_parse_resource_map(card);
|
|
|
|
if (isapnp_checksum_value != 0x00)
|
2008-04-29 05:34:12 +07:00
|
|
|
dev_err(&card->dev, "invalid checksum %#x\n",
|
|
|
|
isapnp_checksum_value);
|
2005-04-17 05:20:36 +07:00
|
|
|
card->checksum = isapnp_checksum_value;
|
|
|
|
|
|
|
|
pnp_add_card(card);
|
|
|
|
}
|
|
|
|
isapnp_wait();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Basic configuration routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int isapnp_present(void)
|
|
|
|
{
|
|
|
|
struct pnp_card *card;
|
2007-07-27 00:41:21 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
pnp_for_each_card(card) {
|
|
|
|
if (card->protocol == &isapnp_protocol)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int isapnp_cfg_begin(int csn, int logdev)
|
|
|
|
{
|
|
|
|
if (csn < 1 || csn > isapnp_csn_count || logdev > 10)
|
|
|
|
return -EINVAL;
|
2006-03-26 16:37:14 +07:00
|
|
|
mutex_lock(&isapnp_cfg_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_wait();
|
|
|
|
isapnp_key();
|
|
|
|
isapnp_wake(csn);
|
|
|
|
#if 0
|
|
|
|
/* to avoid malfunction when the isapnptools package is used */
|
|
|
|
/* we must set RDP to our value again */
|
|
|
|
/* it is possible to set RDP only in the isolation phase */
|
|
|
|
/* Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
|
|
|
|
isapnp_write_byte(0x02, 0x04); /* clear CSN of card */
|
2007-07-27 00:41:20 +07:00
|
|
|
mdelay(2); /* is this necessary? */
|
|
|
|
isapnp_wake(csn); /* bring card into sleep state */
|
|
|
|
isapnp_wake(0); /* bring card into isolation state */
|
|
|
|
isapnp_set_rdp(); /* reset the RDP port */
|
|
|
|
udelay(1000); /* delay 1000us */
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_write_byte(0x06, csn); /* reset CSN to previous value */
|
2007-07-27 00:41:20 +07:00
|
|
|
udelay(250); /* is this necessary? */
|
2005-04-17 05:20:36 +07:00
|
|
|
#endif
|
|
|
|
if (logdev >= 0)
|
|
|
|
isapnp_device(logdev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int isapnp_cfg_end(void)
|
|
|
|
{
|
|
|
|
isapnp_wait();
|
2006-03-26 16:37:14 +07:00
|
|
|
mutex_unlock(&isapnp_cfg_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2007-07-27 00:41:21 +07:00
|
|
|
* Initialization.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(isapnp_protocol);
|
|
|
|
EXPORT_SYMBOL(isapnp_present);
|
|
|
|
EXPORT_SYMBOL(isapnp_cfg_begin);
|
|
|
|
EXPORT_SYMBOL(isapnp_cfg_end);
|
|
|
|
EXPORT_SYMBOL(isapnp_write_byte);
|
|
|
|
|
2008-04-29 05:34:38 +07:00
|
|
|
static int isapnp_get_resources(struct pnp_dev *dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-29 05:34:38 +07:00
|
|
|
int i, ret;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, "get resources\n");
|
2008-04-29 05:34:38 +07:00
|
|
|
pnp_init_resources(dev);
|
|
|
|
isapnp_cfg_begin(dev->card->number, dev->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
|
2008-04-29 05:34:38 +07:00
|
|
|
if (!dev->active)
|
|
|
|
goto __end;
|
|
|
|
|
|
|
|
for (i = 0; i < ISAPNP_MAX_PORT; i++) {
|
|
|
|
ret = isapnp_read_word(ISAPNP_CFG_PORT + (i << 1));
|
2008-06-28 05:56:53 +07:00
|
|
|
pnp_add_io_resource(dev, ret, ret,
|
|
|
|
ret == 0 ? IORESOURCE_DISABLED : 0);
|
2008-04-29 05:34:38 +07:00
|
|
|
}
|
|
|
|
for (i = 0; i < ISAPNP_MAX_MEM; i++) {
|
|
|
|
ret = isapnp_read_word(ISAPNP_CFG_MEM + (i << 3)) << 8;
|
2008-06-28 05:56:53 +07:00
|
|
|
pnp_add_mem_resource(dev, ret, ret,
|
|
|
|
ret == 0 ? IORESOURCE_DISABLED : 0);
|
2008-04-29 05:34:38 +07:00
|
|
|
}
|
|
|
|
for (i = 0; i < ISAPNP_MAX_IRQ; i++) {
|
|
|
|
ret = isapnp_read_word(ISAPNP_CFG_IRQ + (i << 1)) >> 8;
|
2008-06-28 05:56:53 +07:00
|
|
|
pnp_add_irq_resource(dev, ret,
|
|
|
|
ret == 0 ? IORESOURCE_DISABLED : 0);
|
2008-04-29 05:34:38 +07:00
|
|
|
}
|
|
|
|
for (i = 0; i < ISAPNP_MAX_DMA; i++) {
|
|
|
|
ret = isapnp_read_byte(ISAPNP_CFG_DMA + i);
|
2008-06-28 05:56:53 +07:00
|
|
|
pnp_add_dma_resource(dev, ret,
|
|
|
|
ret == 4 ? IORESOURCE_DISABLED : 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2007-08-15 23:32:08 +07:00
|
|
|
|
2008-04-29 05:34:38 +07:00
|
|
|
__end:
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_cfg_end();
|
2008-04-29 05:34:38 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-04-29 05:34:05 +07:00
|
|
|
static int isapnp_set_resources(struct pnp_dev *dev)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-29 05:34:29 +07:00
|
|
|
struct resource *res;
|
2008-06-28 05:56:53 +07:00
|
|
|
int tmp;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, "set resources\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
isapnp_cfg_begin(dev->card->number, dev->number);
|
|
|
|
dev->active = 1;
|
2008-04-29 05:34:29 +07:00
|
|
|
for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
|
2008-06-28 05:56:53 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_IO, tmp);
|
PNP: replace pnp_resource_table with dynamically allocated resources
PNP used to have a fixed-size pnp_resource_table for tracking the
resources used by a device. This table often overflowed, so we've
had to increase the table size, which wastes memory because most
devices have very few resources.
This patch replaces the table with a linked list of resources where
the entries are allocated on demand.
This removes messages like these:
pnpacpi: exceeded the max number of IO resources
00:01: too many I/O port resources
References:
http://bugzilla.kernel.org/show_bug.cgi?id=9535
http://bugzilla.kernel.org/show_bug.cgi?id=9740
http://lkml.org/lkml/2007/11/30/110
This patch also changes the way PNP uses the IORESOURCE_UNSET,
IORESOURCE_AUTO, and IORESOURCE_DISABLED flags.
Prior to this patch, the pnp_resource_table entries used the flags
like this:
IORESOURCE_UNSET
This table entry is unused and available for use. When this flag
is set, we shouldn't look at anything else in the resource structure.
This flag is set when a resource table entry is initialized.
IORESOURCE_AUTO
This resource was assigned automatically by pnp_assign_{io,mem,etc}().
This flag is set when a resource table entry is initialized and
cleared whenever we discover a resource setting by reading an ISAPNP
config register, parsing a PNPBIOS resource data stream, parsing an
ACPI _CRS list, or interpreting a sysfs "set" command.
Resources marked IORESOURCE_AUTO are reinitialized and marked as
IORESOURCE_UNSET by pnp_clean_resource_table() in these cases:
- before we attempt to assign resources automatically,
- if we fail to assign resources automatically,
- after disabling a device
IORESOURCE_DISABLED
Set by pnp_assign_{io,mem,etc}() when automatic assignment fails.
Also set by PNPBIOS and PNPACPI for:
- invalid IRQs or GSI registration failures
- invalid DMA channels
- I/O ports above 0x10000
- mem ranges with negative length
After this patch, there is no pnp_resource_table, and the resource list
entries use the flags like this:
IORESOURCE_UNSET
This flag is no longer used in PNP. Instead of keeping
IORESOURCE_UNSET entries in the resource list, we remove
entries from the list and free them.
IORESOURCE_AUTO
No change in meaning: it still means the resource was assigned
automatically by pnp_assign_{port,mem,etc}(), but these functions
now set the bit explicitly.
We still "clean" a device's resource list in the same places,
but rather than reinitializing IORESOURCE_AUTO entries, we
just remove them from the list.
Note that IORESOURCE_AUTO entries are always at the end of the
list, so removing them doesn't reorder other list entries.
This is because non-IORESOURCE_AUTO entries are added by the
ISAPNP, PNPBIOS, or PNPACPI "get resources" methods and by the
sysfs "set" command. In each of these cases, we completely free
the resource list first.
IORESOURCE_DISABLED
In addition to the cases where we used to set this flag, ISAPNP now
adds an IORESOURCE_DISABLED resource when it reads a configuration
register with a "disabled" value.
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
2008-06-28 05:56:57 +07:00
|
|
|
if (pnp_resource_enabled(res)) {
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, " set io %d to %#llx\n",
|
2008-06-28 05:56:53 +07:00
|
|
|
tmp, (unsigned long long) res->start);
|
|
|
|
isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1),
|
2008-04-29 05:34:29 +07:00
|
|
|
res->start);
|
|
|
|
}
|
2008-04-29 05:34:07 +07:00
|
|
|
}
|
2008-04-29 05:34:29 +07:00
|
|
|
for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
|
2008-06-28 05:56:53 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_IRQ, tmp);
|
PNP: replace pnp_resource_table with dynamically allocated resources
PNP used to have a fixed-size pnp_resource_table for tracking the
resources used by a device. This table often overflowed, so we've
had to increase the table size, which wastes memory because most
devices have very few resources.
This patch replaces the table with a linked list of resources where
the entries are allocated on demand.
This removes messages like these:
pnpacpi: exceeded the max number of IO resources
00:01: too many I/O port resources
References:
http://bugzilla.kernel.org/show_bug.cgi?id=9535
http://bugzilla.kernel.org/show_bug.cgi?id=9740
http://lkml.org/lkml/2007/11/30/110
This patch also changes the way PNP uses the IORESOURCE_UNSET,
IORESOURCE_AUTO, and IORESOURCE_DISABLED flags.
Prior to this patch, the pnp_resource_table entries used the flags
like this:
IORESOURCE_UNSET
This table entry is unused and available for use. When this flag
is set, we shouldn't look at anything else in the resource structure.
This flag is set when a resource table entry is initialized.
IORESOURCE_AUTO
This resource was assigned automatically by pnp_assign_{io,mem,etc}().
This flag is set when a resource table entry is initialized and
cleared whenever we discover a resource setting by reading an ISAPNP
config register, parsing a PNPBIOS resource data stream, parsing an
ACPI _CRS list, or interpreting a sysfs "set" command.
Resources marked IORESOURCE_AUTO are reinitialized and marked as
IORESOURCE_UNSET by pnp_clean_resource_table() in these cases:
- before we attempt to assign resources automatically,
- if we fail to assign resources automatically,
- after disabling a device
IORESOURCE_DISABLED
Set by pnp_assign_{io,mem,etc}() when automatic assignment fails.
Also set by PNPBIOS and PNPACPI for:
- invalid IRQs or GSI registration failures
- invalid DMA channels
- I/O ports above 0x10000
- mem ranges with negative length
After this patch, there is no pnp_resource_table, and the resource list
entries use the flags like this:
IORESOURCE_UNSET
This flag is no longer used in PNP. Instead of keeping
IORESOURCE_UNSET entries in the resource list, we remove
entries from the list and free them.
IORESOURCE_AUTO
No change in meaning: it still means the resource was assigned
automatically by pnp_assign_{port,mem,etc}(), but these functions
now set the bit explicitly.
We still "clean" a device's resource list in the same places,
but rather than reinitializing IORESOURCE_AUTO entries, we
just remove them from the list.
Note that IORESOURCE_AUTO entries are always at the end of the
list, so removing them doesn't reorder other list entries.
This is because non-IORESOURCE_AUTO entries are added by the
ISAPNP, PNPBIOS, or PNPACPI "get resources" methods and by the
sysfs "set" command. In each of these cases, we completely free
the resource list first.
IORESOURCE_DISABLED
In addition to the cases where we used to set this flag, ISAPNP now
adds an IORESOURCE_DISABLED resource when it reads a configuration
register with a "disabled" value.
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
2008-06-28 05:56:57 +07:00
|
|
|
if (pnp_resource_enabled(res)) {
|
2008-04-29 05:34:29 +07:00
|
|
|
int irq = res->start;
|
|
|
|
if (irq == 2)
|
|
|
|
irq = 9;
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, " set irq %d to %d\n", tmp, irq);
|
2008-06-28 05:56:53 +07:00
|
|
|
isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq);
|
2008-04-29 05:34:29 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-04-29 05:34:29 +07:00
|
|
|
for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
|
2008-06-28 05:56:53 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_DMA, tmp);
|
PNP: replace pnp_resource_table with dynamically allocated resources
PNP used to have a fixed-size pnp_resource_table for tracking the
resources used by a device. This table often overflowed, so we've
had to increase the table size, which wastes memory because most
devices have very few resources.
This patch replaces the table with a linked list of resources where
the entries are allocated on demand.
This removes messages like these:
pnpacpi: exceeded the max number of IO resources
00:01: too many I/O port resources
References:
http://bugzilla.kernel.org/show_bug.cgi?id=9535
http://bugzilla.kernel.org/show_bug.cgi?id=9740
http://lkml.org/lkml/2007/11/30/110
This patch also changes the way PNP uses the IORESOURCE_UNSET,
IORESOURCE_AUTO, and IORESOURCE_DISABLED flags.
Prior to this patch, the pnp_resource_table entries used the flags
like this:
IORESOURCE_UNSET
This table entry is unused and available for use. When this flag
is set, we shouldn't look at anything else in the resource structure.
This flag is set when a resource table entry is initialized.
IORESOURCE_AUTO
This resource was assigned automatically by pnp_assign_{io,mem,etc}().
This flag is set when a resource table entry is initialized and
cleared whenever we discover a resource setting by reading an ISAPNP
config register, parsing a PNPBIOS resource data stream, parsing an
ACPI _CRS list, or interpreting a sysfs "set" command.
Resources marked IORESOURCE_AUTO are reinitialized and marked as
IORESOURCE_UNSET by pnp_clean_resource_table() in these cases:
- before we attempt to assign resources automatically,
- if we fail to assign resources automatically,
- after disabling a device
IORESOURCE_DISABLED
Set by pnp_assign_{io,mem,etc}() when automatic assignment fails.
Also set by PNPBIOS and PNPACPI for:
- invalid IRQs or GSI registration failures
- invalid DMA channels
- I/O ports above 0x10000
- mem ranges with negative length
After this patch, there is no pnp_resource_table, and the resource list
entries use the flags like this:
IORESOURCE_UNSET
This flag is no longer used in PNP. Instead of keeping
IORESOURCE_UNSET entries in the resource list, we remove
entries from the list and free them.
IORESOURCE_AUTO
No change in meaning: it still means the resource was assigned
automatically by pnp_assign_{port,mem,etc}(), but these functions
now set the bit explicitly.
We still "clean" a device's resource list in the same places,
but rather than reinitializing IORESOURCE_AUTO entries, we
just remove them from the list.
Note that IORESOURCE_AUTO entries are always at the end of the
list, so removing them doesn't reorder other list entries.
This is because non-IORESOURCE_AUTO entries are added by the
ISAPNP, PNPBIOS, or PNPACPI "get resources" methods and by the
sysfs "set" command. In each of these cases, we completely free
the resource list first.
IORESOURCE_DISABLED
In addition to the cases where we used to set this flag, ISAPNP now
adds an IORESOURCE_DISABLED resource when it reads a configuration
register with a "disabled" value.
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
2008-06-28 05:56:57 +07:00
|
|
|
if (pnp_resource_enabled(res)) {
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, " set dma %d to %lld\n",
|
2008-06-28 05:56:53 +07:00
|
|
|
tmp, (unsigned long long) res->start);
|
|
|
|
isapnp_write_byte(ISAPNP_CFG_DMA + tmp, res->start);
|
2008-04-29 05:34:29 +07:00
|
|
|
}
|
2008-04-29 05:34:07 +07:00
|
|
|
}
|
2008-04-29 05:34:29 +07:00
|
|
|
for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
|
2008-06-28 05:56:53 +07:00
|
|
|
res = pnp_get_resource(dev, IORESOURCE_MEM, tmp);
|
PNP: replace pnp_resource_table with dynamically allocated resources
PNP used to have a fixed-size pnp_resource_table for tracking the
resources used by a device. This table often overflowed, so we've
had to increase the table size, which wastes memory because most
devices have very few resources.
This patch replaces the table with a linked list of resources where
the entries are allocated on demand.
This removes messages like these:
pnpacpi: exceeded the max number of IO resources
00:01: too many I/O port resources
References:
http://bugzilla.kernel.org/show_bug.cgi?id=9535
http://bugzilla.kernel.org/show_bug.cgi?id=9740
http://lkml.org/lkml/2007/11/30/110
This patch also changes the way PNP uses the IORESOURCE_UNSET,
IORESOURCE_AUTO, and IORESOURCE_DISABLED flags.
Prior to this patch, the pnp_resource_table entries used the flags
like this:
IORESOURCE_UNSET
This table entry is unused and available for use. When this flag
is set, we shouldn't look at anything else in the resource structure.
This flag is set when a resource table entry is initialized.
IORESOURCE_AUTO
This resource was assigned automatically by pnp_assign_{io,mem,etc}().
This flag is set when a resource table entry is initialized and
cleared whenever we discover a resource setting by reading an ISAPNP
config register, parsing a PNPBIOS resource data stream, parsing an
ACPI _CRS list, or interpreting a sysfs "set" command.
Resources marked IORESOURCE_AUTO are reinitialized and marked as
IORESOURCE_UNSET by pnp_clean_resource_table() in these cases:
- before we attempt to assign resources automatically,
- if we fail to assign resources automatically,
- after disabling a device
IORESOURCE_DISABLED
Set by pnp_assign_{io,mem,etc}() when automatic assignment fails.
Also set by PNPBIOS and PNPACPI for:
- invalid IRQs or GSI registration failures
- invalid DMA channels
- I/O ports above 0x10000
- mem ranges with negative length
After this patch, there is no pnp_resource_table, and the resource list
entries use the flags like this:
IORESOURCE_UNSET
This flag is no longer used in PNP. Instead of keeping
IORESOURCE_UNSET entries in the resource list, we remove
entries from the list and free them.
IORESOURCE_AUTO
No change in meaning: it still means the resource was assigned
automatically by pnp_assign_{port,mem,etc}(), but these functions
now set the bit explicitly.
We still "clean" a device's resource list in the same places,
but rather than reinitializing IORESOURCE_AUTO entries, we
just remove them from the list.
Note that IORESOURCE_AUTO entries are always at the end of the
list, so removing them doesn't reorder other list entries.
This is because non-IORESOURCE_AUTO entries are added by the
ISAPNP, PNPBIOS, or PNPACPI "get resources" methods and by the
sysfs "set" command. In each of these cases, we completely free
the resource list first.
IORESOURCE_DISABLED
In addition to the cases where we used to set this flag, ISAPNP now
adds an IORESOURCE_DISABLED resource when it reads a configuration
register with a "disabled" value.
Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com>
Signed-off-by: Len Brown <len.brown@intel.com>
Signed-off-by: Andi Kleen <ak@linux.intel.com>
2008-06-28 05:56:57 +07:00
|
|
|
if (pnp_resource_enabled(res)) {
|
2008-08-20 05:53:47 +07:00
|
|
|
pnp_dbg(&dev->dev, " set mem %d to %#llx\n",
|
2008-06-28 05:56:53 +07:00
|
|
|
tmp, (unsigned long long) res->start);
|
|
|
|
isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3),
|
2008-04-29 05:34:29 +07:00
|
|
|
(res->start >> 8) & 0xffff);
|
|
|
|
}
|
2008-04-29 05:34:07 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
/* FIXME: We aren't handling 32bit mems properly here */
|
|
|
|
isapnp_activate(dev->number);
|
|
|
|
isapnp_cfg_end();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int isapnp_disable_resources(struct pnp_dev *dev)
|
|
|
|
{
|
2007-08-15 23:32:13 +07:00
|
|
|
if (!dev->active)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EINVAL;
|
|
|
|
isapnp_cfg_begin(dev->card->number, dev->number);
|
|
|
|
isapnp_deactivate(dev->number);
|
|
|
|
dev->active = 0;
|
|
|
|
isapnp_cfg_end();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct pnp_protocol isapnp_protocol = {
|
2007-07-27 00:41:20 +07:00
|
|
|
.name = "ISA Plug and Play",
|
|
|
|
.get = isapnp_get_resources,
|
|
|
|
.set = isapnp_set_resources,
|
2005-04-17 05:20:36 +07:00
|
|
|
.disable = isapnp_disable_resources,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init isapnp_init(void)
|
|
|
|
{
|
|
|
|
int cards;
|
|
|
|
struct pnp_card *card;
|
|
|
|
struct pnp_dev *dev;
|
|
|
|
|
|
|
|
if (isapnp_disable) {
|
|
|
|
printk(KERN_INFO "isapnp: ISA Plug & Play support disabled\n");
|
|
|
|
return 0;
|
|
|
|
}
|
2008-09-23 04:41:31 +07:00
|
|
|
#ifdef CONFIG_PPC
|
2006-09-27 14:18:55 +07:00
|
|
|
if (check_legacy_ioport(_PIDXR) || check_legacy_ioport(_PNPWRP))
|
|
|
|
return -EINVAL;
|
|
|
|
#endif
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef ISAPNP_REGION_OK
|
|
|
|
if (!request_region(_PIDXR, 1, "isapnp index")) {
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_ERR "isapnp: Index Register 0x%x already used\n",
|
|
|
|
_PIDXR);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
if (!request_region(_PNPWRP, 1, "isapnp write")) {
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_ERR
|
|
|
|
"isapnp: Write Data Register 0x%x already used\n",
|
|
|
|
_PNPWRP);
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef ISAPNP_REGION_OK
|
|
|
|
release_region(_PIDXR, 1);
|
|
|
|
#endif
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2007-07-27 00:41:20 +07:00
|
|
|
if (pnp_register_protocol(&isapnp_protocol) < 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/*
|
2007-07-27 00:41:20 +07:00
|
|
|
* Print a message. The existing ISAPnP code is hanging machines
|
|
|
|
* so let the user know where.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2007-07-27 00:41:20 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
printk(KERN_INFO "isapnp: Scanning for PnP cards...\n");
|
|
|
|
if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
|
|
|
|
isapnp_rdp |= 3;
|
|
|
|
if (!request_region(isapnp_rdp, 1, "isapnp read")) {
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_ERR
|
|
|
|
"isapnp: Read Data Register 0x%x already used\n",
|
|
|
|
isapnp_rdp);
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef ISAPNP_REGION_OK
|
|
|
|
release_region(_PIDXR, 1);
|
|
|
|
#endif
|
|
|
|
release_region(_PNPWRP, 1);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
isapnp_set_rdp();
|
|
|
|
}
|
|
|
|
if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
|
|
|
|
cards = isapnp_isolate();
|
2007-07-27 00:41:20 +07:00
|
|
|
if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
|
2005-04-17 05:20:36 +07:00
|
|
|
#ifdef ISAPNP_REGION_OK
|
|
|
|
release_region(_PIDXR, 1);
|
|
|
|
#endif
|
|
|
|
release_region(_PNPWRP, 1);
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_INFO
|
|
|
|
"isapnp: No Plug & Play device found\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
request_region(isapnp_rdp, 1, "isapnp read");
|
|
|
|
}
|
|
|
|
isapnp_build_device_list();
|
|
|
|
cards = 0;
|
|
|
|
|
2007-07-27 00:41:20 +07:00
|
|
|
protocol_for_each_card(&isapnp_protocol, card) {
|
2005-04-17 05:20:36 +07:00
|
|
|
cards++;
|
|
|
|
if (isapnp_verbose) {
|
2008-04-29 05:34:12 +07:00
|
|
|
dev_info(&card->dev, "card '%s'\n",
|
|
|
|
card->name[0] ? card->name : "unknown");
|
2005-04-17 05:20:36 +07:00
|
|
|
if (isapnp_verbose < 2)
|
|
|
|
continue;
|
2007-07-27 00:41:20 +07:00
|
|
|
card_for_each_dev(card, dev) {
|
2008-04-29 05:34:12 +07:00
|
|
|
dev_info(&card->dev, "device '%s'\n",
|
|
|
|
dev->name[0] ? dev->name : "unknown");
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-08-15 23:32:08 +07:00
|
|
|
if (cards)
|
2007-07-27 00:41:20 +07:00
|
|
|
printk(KERN_INFO
|
|
|
|
"isapnp: %i Plug & Play card%s detected total\n", cards,
|
|
|
|
cards > 1 ? "s" : "");
|
2007-08-15 23:32:08 +07:00
|
|
|
else
|
2005-04-17 05:20:36 +07:00
|
|
|
printk(KERN_INFO "isapnp: No Plug & Play card found\n");
|
|
|
|
|
|
|
|
isapnp_proc_init();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
device_initcall(isapnp_init);
|
|
|
|
|
|
|
|
/* format is: noisapnp */
|
|
|
|
|
|
|
|
static int __init isapnp_setup_disable(char *str)
|
|
|
|
{
|
|
|
|
isapnp_disable = 1;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("noisapnp", isapnp_setup_disable);
|
|
|
|
|
|
|
|
/* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
|
|
|
|
|
|
|
|
static int __init isapnp_setup_isapnp(char *str)
|
|
|
|
{
|
2007-07-27 00:41:20 +07:00
|
|
|
(void)((get_option(&str, &isapnp_rdp) == 2) &&
|
|
|
|
(get_option(&str, &isapnp_reset) == 2) &&
|
|
|
|
(get_option(&str, &isapnp_verbose) == 2));
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__setup("isapnp=", isapnp_setup_isapnp);
|