PNP: Lindent all source files
Run Lindent on all PNP source files. Produced by: $ quilt new pnp-lindent $ find drivers/pnp -name \*.[ch] | xargs quilt add $ quilt add include/linux/{pnp.h,pnpbios.h} $ scripts/Lindent drivers/pnp/*.c drivers/pnp/*/*.c include/linux/pnp*.h $ quilt refresh --sort Signed-off-by: Bjorn Helgaas <bjorn.helgaas@hp.com> Cc: Len Brown <lenb@kernel.org> Cc: Adam Belay <ambx1@neo.rr.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
parent
8ec3cf7d29
commit
9dd78466c9
|
@ -13,8 +13,8 @@
|
|||
LIST_HEAD(pnp_cards);
|
||||
static LIST_HEAD(pnp_card_drivers);
|
||||
|
||||
|
||||
static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv, struct pnp_card * card)
|
||||
static const struct pnp_card_device_id *match_card(struct pnp_card_driver *drv,
|
||||
struct pnp_card *card)
|
||||
{
|
||||
const struct pnp_card_device_id *drv_id = drv->id_table;
|
||||
while (*drv_id->id) {
|
||||
|
@ -23,11 +23,13 @@ static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv
|
|||
for (;;) {
|
||||
int found;
|
||||
struct pnp_dev *dev;
|
||||
if (i == PNP_MAX_DEVICES || ! *drv_id->devs[i].id)
|
||||
if (i == PNP_MAX_DEVICES
|
||||
|| !*drv_id->devs[i].id)
|
||||
return drv_id;
|
||||
found = 0;
|
||||
card_for_each_dev(card, dev) {
|
||||
if (compare_pnp_id(dev->id, drv_id->devs[i].id)) {
|
||||
if (compare_pnp_id
|
||||
(dev->id, drv_id->devs[i].id)) {
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
|
@ -136,8 +138,8 @@ static void pnp_release_card(struct device *dmdev)
|
|||
kfree(card);
|
||||
}
|
||||
|
||||
|
||||
static ssize_t pnp_show_card_name(struct device *dmdev, struct device_attribute *attr, char *buf)
|
||||
static ssize_t pnp_show_card_name(struct device *dmdev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
char *str = buf;
|
||||
struct pnp_card *card = to_pnp_card(dmdev);
|
||||
|
@ -147,7 +149,8 @@ static ssize_t pnp_show_card_name(struct device *dmdev, struct device_attribute
|
|||
|
||||
static DEVICE_ATTR(name, S_IRUGO, pnp_show_card_name, NULL);
|
||||
|
||||
static ssize_t pnp_show_card_ids(struct device *dmdev, struct device_attribute *attr, char *buf)
|
||||
static ssize_t pnp_show_card_ids(struct device *dmdev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
char *str = buf;
|
||||
struct pnp_card *card = to_pnp_card(dmdev);
|
||||
|
@ -165,10 +168,12 @@ static DEVICE_ATTR(card_id,S_IRUGO,pnp_show_card_ids,NULL);
|
|||
static int pnp_interface_attach_card(struct pnp_card *card)
|
||||
{
|
||||
int rc = device_create_file(&card->dev, &dev_attr_name);
|
||||
if (rc) return rc;
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
rc = device_create_file(&card->dev, &dev_attr_card_id);
|
||||
if (rc) goto err_name;
|
||||
if (rc)
|
||||
goto err_name;
|
||||
|
||||
return 0;
|
||||
|
||||
|
@ -189,7 +194,8 @@ int pnp_add_card(struct pnp_card * card)
|
|||
if (!card || !card->protocol)
|
||||
return -EINVAL;
|
||||
|
||||
sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number, card->number);
|
||||
sprintf(card->dev.bus_id, "%02x:%02x", card->protocol->number,
|
||||
card->number);
|
||||
card->dev.parent = &card->protocol->dev;
|
||||
card->dev.bus = NULL;
|
||||
card->dev.release = &pnp_release_card;
|
||||
|
@ -212,11 +218,14 @@ int pnp_add_card(struct pnp_card * card)
|
|||
|
||||
/* match with card drivers */
|
||||
list_for_each_safe(pos, temp, &pnp_card_drivers) {
|
||||
struct pnp_card_driver * drv = list_entry(pos, struct pnp_card_driver, global_list);
|
||||
struct pnp_card_driver *drv =
|
||||
list_entry(pos, struct pnp_card_driver,
|
||||
global_list);
|
||||
card_probe(card, drv);
|
||||
}
|
||||
} else
|
||||
pnp_err("sysfs failure, card '%s' will be unavailable", card->dev.bus_id);
|
||||
pnp_err("sysfs failure, card '%s' will be unavailable",
|
||||
card->dev.bus_id);
|
||||
return error;
|
||||
}
|
||||
|
||||
|
@ -253,8 +262,8 @@ int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev)
|
|||
return -EINVAL;
|
||||
dev->dev.parent = &card->dev;
|
||||
dev->card_link = NULL;
|
||||
snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x", dev->protocol->number,
|
||||
card->number,dev->number);
|
||||
snprintf(dev->dev.bus_id, BUS_ID_SIZE, "%02x:%02x.%02x",
|
||||
dev->protocol->number, card->number, dev->number);
|
||||
spin_lock(&pnp_lock);
|
||||
dev->card = card;
|
||||
list_add_tail(&dev->card_list, &card->devices);
|
||||
|
@ -283,7 +292,8 @@ void pnp_remove_card_device(struct pnp_dev * dev)
|
|||
* @from: Starting place to search from. If NULL it will start from the begining.
|
||||
*/
|
||||
|
||||
struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from)
|
||||
struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink,
|
||||
const char *id, struct pnp_dev *from)
|
||||
{
|
||||
struct list_head *pos;
|
||||
struct pnp_dev *dev;
|
||||
|
@ -390,7 +400,8 @@ int pnp_register_card_driver(struct pnp_card_driver * drv)
|
|||
spin_unlock(&pnp_lock);
|
||||
|
||||
list_for_each_safe(pos, temp, &pnp_cards) {
|
||||
struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
|
||||
struct pnp_card *card =
|
||||
list_entry(pos, struct pnp_card, global_list);
|
||||
card_probe(card, drv);
|
||||
}
|
||||
return 0;
|
||||
|
|
|
@ -18,7 +18,6 @@
|
|||
|
||||
#include "base.h"
|
||||
|
||||
|
||||
static LIST_HEAD(pnp_protocols);
|
||||
LIST_HEAD(pnp_global);
|
||||
DEFINE_SPINLOCK(pnp_lock);
|
||||
|
@ -93,7 +92,6 @@ void pnp_unregister_protocol(struct pnp_protocol *protocol)
|
|||
device_unregister(&protocol->dev);
|
||||
}
|
||||
|
||||
|
||||
static void pnp_free_ids(struct pnp_dev *dev)
|
||||
{
|
||||
struct pnp_id *id;
|
||||
|
@ -149,7 +147,8 @@ int pnp_add_device(struct pnp_dev *dev)
|
|||
if (!dev || !dev->protocol || dev->card)
|
||||
return -EINVAL;
|
||||
dev->dev.parent = &dev->protocol->dev;
|
||||
sprintf(dev->dev.bus_id, "%02x:%02x", dev->protocol->number, dev->number);
|
||||
sprintf(dev->dev.bus_id, "%02x:%02x", dev->protocol->number,
|
||||
dev->number);
|
||||
return __pnp_add_device(dev);
|
||||
}
|
||||
|
||||
|
|
|
@ -17,11 +17,9 @@ static int compare_func(const char *ida, const char *idb)
|
|||
{
|
||||
int i;
|
||||
/* we only need to compare the last 4 chars */
|
||||
for (i=3; i<7; i++)
|
||||
{
|
||||
for (i = 3; i < 7; i++) {
|
||||
if (ida[i] != 'X' &&
|
||||
idb[i] != 'X' &&
|
||||
toupper(ida[i]) != toupper(idb[i]))
|
||||
idb[i] != 'X' && toupper(ida[i]) != toupper(idb[i]))
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
|
@ -42,7 +40,8 @@ int compare_pnp_id(struct pnp_id *pos, const char *id)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static const struct pnp_device_id * match_device(struct pnp_driver *drv, struct pnp_dev *dev)
|
||||
static const struct pnp_device_id *match_device(struct pnp_driver *drv,
|
||||
struct pnp_dev *dev)
|
||||
{
|
||||
const struct pnp_device_id *drv_id = drv->id_table;
|
||||
if (!drv_id)
|
||||
|
@ -86,7 +85,8 @@ static int pnp_device_probe(struct device *dev)
|
|||
pnp_dev = to_pnp_dev(dev);
|
||||
pnp_drv = to_pnp_driver(dev->driver);
|
||||
|
||||
pnp_dbg("match found with the PnP device '%s' and the driver '%s'", dev->bus_id,pnp_drv->name);
|
||||
pnp_dbg("match found with the PnP device '%s' and the driver '%s'",
|
||||
dev->bus_id, pnp_drv->name);
|
||||
|
||||
error = pnp_device_attach(pnp_dev);
|
||||
if (error < 0)
|
||||
|
|
|
@ -48,14 +48,18 @@ static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt,...)
|
|||
return res;
|
||||
}
|
||||
|
||||
static void pnp_print_port(pnp_info_buffer_t *buffer, char *space, struct pnp_port *port)
|
||||
static void pnp_print_port(pnp_info_buffer_t * buffer, char *space,
|
||||
struct pnp_port *port)
|
||||
{
|
||||
pnp_printf(buffer, "%sport 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decoding\n",
|
||||
space, port->min, port->max, port->align ? (port->align-1) : 0, port->size,
|
||||
pnp_printf(buffer,
|
||||
"%sport 0x%x-0x%x, align 0x%x, size 0x%x, %i-bit address decoding\n",
|
||||
space, port->min, port->max,
|
||||
port->align ? (port->align - 1) : 0, port->size,
|
||||
port->flags & PNP_PORT_FLAG_16BITADDR ? 16 : 10);
|
||||
}
|
||||
|
||||
static void pnp_print_irq(pnp_info_buffer_t *buffer, char *space, struct pnp_irq *irq)
|
||||
static void pnp_print_irq(pnp_info_buffer_t * buffer, char *space,
|
||||
struct pnp_irq *irq)
|
||||
{
|
||||
int first = 1, i;
|
||||
|
||||
|
@ -85,7 +89,8 @@ static void pnp_print_irq(pnp_info_buffer_t *buffer, char *space, struct pnp_irq
|
|||
pnp_printf(buffer, "\n");
|
||||
}
|
||||
|
||||
static void pnp_print_dma(pnp_info_buffer_t *buffer, char *space, struct pnp_dma *dma)
|
||||
static void pnp_print_dma(pnp_info_buffer_t * buffer, char *space,
|
||||
struct pnp_dma *dma)
|
||||
{
|
||||
int first = 1, i;
|
||||
char *s;
|
||||
|
@ -136,7 +141,8 @@ static void pnp_print_dma(pnp_info_buffer_t *buffer, char *space, struct pnp_dma
|
|||
pnp_printf(buffer, " %s\n", s);
|
||||
}
|
||||
|
||||
static void pnp_print_mem(pnp_info_buffer_t *buffer, char *space, struct pnp_mem *mem)
|
||||
static void pnp_print_mem(pnp_info_buffer_t * buffer, char *space,
|
||||
struct pnp_mem *mem)
|
||||
{
|
||||
char *s;
|
||||
|
||||
|
@ -204,8 +210,8 @@ static void pnp_print_option(pnp_info_buffer_t *buffer, char *space,
|
|||
pnp_print_mem(buffer, space, mem);
|
||||
}
|
||||
|
||||
|
||||
static ssize_t pnp_show_options(struct device *dmdev, struct device_attribute *attr, char *buf)
|
||||
static ssize_t pnp_show_options(struct device *dmdev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
||||
struct pnp_option *independent = dev->independent;
|
||||
|
@ -235,8 +241,9 @@ static ssize_t pnp_show_options(struct device *dmdev, struct device_attribute *a
|
|||
|
||||
static DEVICE_ATTR(options, S_IRUGO, pnp_show_options, NULL);
|
||||
|
||||
|
||||
static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_attribute *attr, char *buf)
|
||||
static ssize_t pnp_show_current_resources(struct device *dmdev,
|
||||
struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
||||
int i, ret;
|
||||
|
@ -265,8 +272,10 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
|
|||
pnp_printf(buffer, " disabled\n");
|
||||
else
|
||||
pnp_printf(buffer, " 0x%llx-0x%llx\n",
|
||||
(unsigned long long)pnp_port_start(dev, i),
|
||||
(unsigned long long)pnp_port_end(dev, i));
|
||||
(unsigned long long)
|
||||
pnp_port_start(dev, i),
|
||||
(unsigned long long)pnp_port_end(dev,
|
||||
i));
|
||||
}
|
||||
}
|
||||
for (i = 0; i < PNP_MAX_MEM; i++) {
|
||||
|
@ -276,8 +285,10 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
|
|||
pnp_printf(buffer, " disabled\n");
|
||||
else
|
||||
pnp_printf(buffer, " 0x%llx-0x%llx\n",
|
||||
(unsigned long long)pnp_mem_start(dev, i),
|
||||
(unsigned long long)pnp_mem_end(dev, i));
|
||||
(unsigned long long)
|
||||
pnp_mem_start(dev, i),
|
||||
(unsigned long long)pnp_mem_end(dev,
|
||||
i));
|
||||
}
|
||||
}
|
||||
for (i = 0; i < PNP_MAX_IRQ; i++) {
|
||||
|
@ -308,7 +319,8 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
|
|||
extern struct semaphore pnp_res_mutex;
|
||||
|
||||
static ssize_t
|
||||
pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr, const char * ubuf, size_t count)
|
||||
pnp_set_current_resources(struct device *dmdev, struct device_attribute *attr,
|
||||
const char *ubuf, size_t count)
|
||||
{
|
||||
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
||||
char *buf = (void *)ubuf;
|
||||
|
@ -316,7 +328,8 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
|
||||
if (dev->status & PNP_ATTACHED) {
|
||||
retval = -EBUSY;
|
||||
pnp_info("Device %s cannot be configured because it is in use.", dev->dev.bus_id);
|
||||
pnp_info("Device %s cannot be configured because it is in use.",
|
||||
dev->dev.bus_id);
|
||||
goto done;
|
||||
}
|
||||
|
||||
|
@ -370,17 +383,21 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
buf += 2;
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.port_resource[nport].start = simple_strtoul(buf,&buf,0);
|
||||
dev->res.port_resource[nport].start =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
if (*buf == '-') {
|
||||
buf += 1;
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.port_resource[nport].end = simple_strtoul(buf,&buf,0);
|
||||
dev->res.port_resource[nport].end =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
} else
|
||||
dev->res.port_resource[nport].end = dev->res.port_resource[nport].start;
|
||||
dev->res.port_resource[nport].flags = IORESOURCE_IO;
|
||||
dev->res.port_resource[nport].end =
|
||||
dev->res.port_resource[nport].start;
|
||||
dev->res.port_resource[nport].flags =
|
||||
IORESOURCE_IO;
|
||||
nport++;
|
||||
if (nport >= PNP_MAX_PORT)
|
||||
break;
|
||||
|
@ -390,17 +407,21 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
buf += 3;
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.mem_resource[nmem].start = simple_strtoul(buf,&buf,0);
|
||||
dev->res.mem_resource[nmem].start =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
if (*buf == '-') {
|
||||
buf += 1;
|
||||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.mem_resource[nmem].end = simple_strtoul(buf,&buf,0);
|
||||
dev->res.mem_resource[nmem].end =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
} else
|
||||
dev->res.mem_resource[nmem].end = dev->res.mem_resource[nmem].start;
|
||||
dev->res.mem_resource[nmem].flags = IORESOURCE_MEM;
|
||||
dev->res.mem_resource[nmem].end =
|
||||
dev->res.mem_resource[nmem].start;
|
||||
dev->res.mem_resource[nmem].flags =
|
||||
IORESOURCE_MEM;
|
||||
nmem++;
|
||||
if (nmem >= PNP_MAX_MEM)
|
||||
break;
|
||||
|
@ -411,8 +432,10 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.irq_resource[nirq].start =
|
||||
dev->res.irq_resource[nirq].end = simple_strtoul(buf,&buf,0);
|
||||
dev->res.irq_resource[nirq].flags = IORESOURCE_IRQ;
|
||||
dev->res.irq_resource[nirq].end =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
dev->res.irq_resource[nirq].flags =
|
||||
IORESOURCE_IRQ;
|
||||
nirq++;
|
||||
if (nirq >= PNP_MAX_IRQ)
|
||||
break;
|
||||
|
@ -423,8 +446,10 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
while (isspace(*buf))
|
||||
++buf;
|
||||
dev->res.dma_resource[ndma].start =
|
||||
dev->res.dma_resource[ndma].end = simple_strtoul(buf,&buf,0);
|
||||
dev->res.dma_resource[ndma].flags = IORESOURCE_DMA;
|
||||
dev->res.dma_resource[ndma].end =
|
||||
simple_strtoul(buf, &buf, 0);
|
||||
dev->res.dma_resource[ndma].flags =
|
||||
IORESOURCE_DMA;
|
||||
ndma++;
|
||||
if (ndma >= PNP_MAX_DMA)
|
||||
break;
|
||||
|
@ -444,7 +469,8 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
|
|||
static DEVICE_ATTR(resources, S_IRUGO | S_IWUSR,
|
||||
pnp_show_current_resources, pnp_set_current_resources);
|
||||
|
||||
static ssize_t pnp_show_current_ids(struct device *dmdev, struct device_attribute *attr, char *buf)
|
||||
static ssize_t pnp_show_current_ids(struct device *dmdev,
|
||||
struct device_attribute *attr, char *buf)
|
||||
{
|
||||
char *str = buf;
|
||||
struct pnp_dev *dev = to_pnp_dev(dmdev);
|
||||
|
@ -462,11 +488,14 @@ static DEVICE_ATTR(id,S_IRUGO,pnp_show_current_ids,NULL);
|
|||
int pnp_interface_attach_device(struct pnp_dev *dev)
|
||||
{
|
||||
int rc = device_create_file(&dev->dev, &dev_attr_options);
|
||||
if (rc) goto err;
|
||||
if (rc)
|
||||
goto err;
|
||||
rc = device_create_file(&dev->dev, &dev_attr_resources);
|
||||
if (rc) goto err_opt;
|
||||
if (rc)
|
||||
goto err_opt;
|
||||
rc = device_create_file(&dev->dev, &dev_attr_id);
|
||||
if (rc) goto err_res;
|
||||
if (rc)
|
||||
goto err_res;
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
@ -12,21 +12,19 @@
|
|||
#include <linux/isapnp.h>
|
||||
#include <linux/string.h>
|
||||
|
||||
static void pnp_convert_id(char *buf, unsigned short vendor, unsigned short device)
|
||||
static void pnp_convert_id(char *buf, unsigned short vendor,
|
||||
unsigned short device)
|
||||
{
|
||||
sprintf(buf, "%c%c%c%x%x%x%x",
|
||||
'A' + ((vendor >> 2) & 0x3f) - 1,
|
||||
'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
|
||||
'A' + ((vendor >> 8) & 0x1f) - 1,
|
||||
(device >> 4) & 0x0f,
|
||||
device & 0x0f,
|
||||
(device >> 12) & 0x0f,
|
||||
(device >> 8) & 0x0f);
|
||||
device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
|
||||
}
|
||||
|
||||
struct pnp_card *pnp_find_card(unsigned short vendor,
|
||||
unsigned short device,
|
||||
struct pnp_card *from)
|
||||
unsigned short device, struct pnp_card *from)
|
||||
{
|
||||
char id[8];
|
||||
char any[8];
|
||||
|
@ -47,8 +45,7 @@ struct pnp_card *pnp_find_card(unsigned short vendor,
|
|||
|
||||
struct pnp_dev *pnp_find_dev(struct pnp_card *card,
|
||||
unsigned short vendor,
|
||||
unsigned short function,
|
||||
struct pnp_dev *from)
|
||||
unsigned short function, struct pnp_dev *from)
|
||||
{
|
||||
char id[8];
|
||||
char any[8];
|
||||
|
@ -63,7 +60,8 @@ struct pnp_dev *pnp_find_dev(struct pnp_card *card,
|
|||
|
||||
while (list != &pnp_global) {
|
||||
struct pnp_dev *dev = global_to_pnp_dev(list);
|
||||
if (compare_pnp_id(dev->id,id) || (memcmp(id,any,7)==0))
|
||||
if (compare_pnp_id(dev->id, id)
|
||||
|| (memcmp(id, any, 7) == 0))
|
||||
return dev;
|
||||
list = list->next;
|
||||
}
|
||||
|
|
|
@ -221,8 +221,7 @@ static int isapnp_next_rdp(void)
|
|||
int rdp = isapnp_rdp;
|
||||
static int old_rdp = 0;
|
||||
|
||||
if(old_rdp)
|
||||
{
|
||||
if (old_rdp) {
|
||||
release_region(old_rdp, 1);
|
||||
old_rdp = 0;
|
||||
}
|
||||
|
@ -231,8 +230,8 @@ static int isapnp_next_rdp(void)
|
|||
* We cannot use NE2000 probe spaces for ISAPnP or we
|
||||
* will lock up machines.
|
||||
*/
|
||||
if ((rdp < 0x280 || rdp > 0x380) && request_region(rdp, 1, "ISAPnP"))
|
||||
{
|
||||
if ((rdp < 0x280 || rdp > 0x380)
|
||||
&& request_region(rdp, 1, "ISAPnP")) {
|
||||
isapnp_rdp = rdp;
|
||||
old_rdp = rdp;
|
||||
return 0;
|
||||
|
@ -305,7 +304,9 @@ static int __init isapnp_isolate(void)
|
|||
udelay(250);
|
||||
if (data == 0x55aa)
|
||||
bit = 0x01;
|
||||
checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1);
|
||||
checksum =
|
||||
((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
|
||||
| (checksum >> 1);
|
||||
bit = 0x00;
|
||||
}
|
||||
for (i = 65; i <= 72; i++) {
|
||||
|
@ -368,7 +369,8 @@ static int __init isapnp_read_tag(unsigned char *type, unsigned short *size)
|
|||
*size = tag & 0x07;
|
||||
}
|
||||
#if 0
|
||||
printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type, *size);
|
||||
printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type,
|
||||
*size);
|
||||
#endif
|
||||
if (*type == 0xff && *size == 0xffff) /* probably invalid data */
|
||||
return -1;
|
||||
|
@ -388,7 +390,8 @@ static void __init isapnp_skip_bytes(int count)
|
|||
* Parse EISA id.
|
||||
*/
|
||||
|
||||
static void isapnp_parse_id(struct pnp_dev * dev, unsigned short vendor, unsigned short device)
|
||||
static void isapnp_parse_id(struct pnp_dev *dev, unsigned short vendor,
|
||||
unsigned short device)
|
||||
{
|
||||
struct pnp_id *id;
|
||||
if (!dev)
|
||||
|
@ -401,9 +404,7 @@ static void isapnp_parse_id(struct pnp_dev * dev, unsigned short vendor, unsigne
|
|||
'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
|
||||
'A' + ((vendor >> 8) & 0x1f) - 1,
|
||||
(device >> 4) & 0x0f,
|
||||
device & 0x0f,
|
||||
(device >> 12) & 0x0f,
|
||||
(device >> 8) & 0x0f);
|
||||
device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
|
||||
pnp_add_id(id, dev);
|
||||
}
|
||||
|
||||
|
@ -411,7 +412,8 @@ static void isapnp_parse_id(struct pnp_dev * dev, unsigned short vendor, unsigne
|
|||
* Parse logical device tag.
|
||||
*/
|
||||
|
||||
static struct pnp_dev * __init isapnp_parse_device(struct pnp_card *card, int size, int number)
|
||||
static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
|
||||
int size, int number)
|
||||
{
|
||||
unsigned char tmp[6];
|
||||
struct pnp_dev *dev;
|
||||
|
@ -435,7 +437,6 @@ static struct pnp_dev * __init isapnp_parse_device(struct pnp_card *card, int si
|
|||
return dev;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Add IRQ resource to resources list.
|
||||
*/
|
||||
|
@ -565,8 +566,10 @@ static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
|
|||
return;
|
||||
mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
|
||||
mem->max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
|
||||
mem->align = (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
|
||||
mem->size = (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
|
||||
mem->align =
|
||||
(tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
|
||||
mem->size =
|
||||
(tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
|
||||
mem->flags = tmp[0];
|
||||
pnp_register_mem_resource(option, mem);
|
||||
}
|
||||
|
@ -585,7 +588,8 @@ static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
|
|||
mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
|
||||
if (!mem)
|
||||
return;
|
||||
mem->min = mem->max = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
|
||||
mem->min = mem->max =
|
||||
(tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
|
||||
mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
|
||||
mem->align = 0;
|
||||
mem->flags = tmp[0];
|
||||
|
@ -600,7 +604,8 @@ static void __init
|
|||
isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size)
|
||||
{
|
||||
if (name[0] == '\0') {
|
||||
unsigned short size1 = *size >= name_max ? (name_max - 1) : *size;
|
||||
unsigned short size1 =
|
||||
*size >= name_max ? (name_max - 1) : *size;
|
||||
isapnp_peek(name, size1);
|
||||
name[size1] = '\0';
|
||||
*size -= size1;
|
||||
|
@ -639,7 +644,9 @@ static int __init isapnp_create_device(struct pnp_card *card,
|
|||
switch (type) {
|
||||
case _STAG_LOGDEVID:
|
||||
if (size >= 5 && size <= 6) {
|
||||
if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
|
||||
if ((dev =
|
||||
isapnp_parse_device(card, size,
|
||||
number++)) == NULL)
|
||||
return 1;
|
||||
size = 0;
|
||||
skip = 0;
|
||||
|
@ -658,7 +665,8 @@ static int __init isapnp_create_device(struct pnp_card *card,
|
|||
case _STAG_COMPATDEVID:
|
||||
if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
|
||||
isapnp_peek(tmp, 4);
|
||||
isapnp_parse_id(dev,(tmp[1] << 8) | tmp[0], (tmp[3] << 8) | tmp[2]);
|
||||
isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0],
|
||||
(tmp[3] << 8) | tmp[2]);
|
||||
compat++;
|
||||
size = 0;
|
||||
}
|
||||
|
@ -739,7 +747,9 @@ static int __init isapnp_create_device(struct pnp_card *card,
|
|||
isapnp_skip_bytes(size);
|
||||
return 1;
|
||||
default:
|
||||
printk(KERN_ERR "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n", type, dev->number, card->number);
|
||||
printk(KERN_ERR
|
||||
"isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n",
|
||||
type, dev->number, card->number);
|
||||
}
|
||||
__skip:
|
||||
if (size > 0)
|
||||
|
@ -779,7 +789,8 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card)
|
|||
case _STAG_VENDOR:
|
||||
break;
|
||||
case _LTAG_ANSISTR:
|
||||
isapnp_parse_name(card->name, sizeof(card->name), &size);
|
||||
isapnp_parse_name(card->name, sizeof(card->name),
|
||||
&size);
|
||||
break;
|
||||
case _LTAG_UNICODESTR:
|
||||
/* silently ignore */
|
||||
|
@ -792,7 +803,9 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card)
|
|||
isapnp_skip_bytes(size);
|
||||
return;
|
||||
default:
|
||||
printk(KERN_ERR "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n", type, card->number);
|
||||
printk(KERN_ERR
|
||||
"isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n",
|
||||
type, card->number);
|
||||
}
|
||||
__skip:
|
||||
if (size > 0)
|
||||
|
@ -815,7 +828,9 @@ static unsigned char __init isapnp_checksum(unsigned char *data)
|
|||
bit = 0;
|
||||
if (b & (1 << j))
|
||||
bit = 1;
|
||||
checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1);
|
||||
checksum =
|
||||
((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
|
||||
| (checksum >> 1);
|
||||
}
|
||||
}
|
||||
return checksum;
|
||||
|
@ -825,7 +840,8 @@ static unsigned char __init isapnp_checksum(unsigned char *data)
|
|||
* Parse EISA id for ISA PnP card.
|
||||
*/
|
||||
|
||||
static void isapnp_parse_card_id(struct pnp_card * card, unsigned short vendor, unsigned short device)
|
||||
static void isapnp_parse_card_id(struct pnp_card *card, unsigned short vendor,
|
||||
unsigned short device)
|
||||
{
|
||||
struct pnp_id *id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
|
||||
if (!id)
|
||||
|
@ -835,9 +851,7 @@ static void isapnp_parse_card_id(struct pnp_card * card, unsigned short vendor,
|
|||
'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
|
||||
'A' + ((vendor >> 8) & 0x1f) - 1,
|
||||
(device >> 4) & 0x0f,
|
||||
device & 0x0f,
|
||||
(device >> 12) & 0x0f,
|
||||
(device >> 8) & 0x0f);
|
||||
device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
|
||||
pnp_add_card_id(id, card);
|
||||
}
|
||||
|
||||
|
@ -858,22 +872,29 @@ static int __init isapnp_build_device_list(void)
|
|||
isapnp_peek(header, 9);
|
||||
checksum = isapnp_checksum(header);
|
||||
#if 0
|
||||
printk(KERN_DEBUG "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]);
|
||||
printk(KERN_DEBUG
|
||||
"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]);
|
||||
printk(KERN_DEBUG "checksum = 0x%x\n", checksum);
|
||||
#endif
|
||||
if ((card = kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
|
||||
if ((card =
|
||||
kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
|
||||
continue;
|
||||
|
||||
card->number = csn;
|
||||
INIT_LIST_HEAD(&card->devices);
|
||||
isapnp_parse_card_id(card, (header[1] << 8) | header[0], (header[3] << 8) | header[2]);
|
||||
card->serial = (header[7] << 24) | (header[6] << 16) | (header[5] << 8) | header[4];
|
||||
isapnp_parse_card_id(card, (header[1] << 8) | header[0],
|
||||
(header[3] << 8) | header[2]);
|
||||
card->serial =
|
||||
(header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
|
||||
header[4];
|
||||
isapnp_checksum_value = 0x00;
|
||||
isapnp_parse_resource_map(card);
|
||||
if (isapnp_checksum_value != 0x00)
|
||||
printk(KERN_ERR "isapnp: checksum for device %i is not valid (0x%x)\n", csn, isapnp_checksum_value);
|
||||
printk(KERN_ERR
|
||||
"isapnp: checksum for device %i is not valid (0x%x)\n",
|
||||
csn, isapnp_checksum_value);
|
||||
card->checksum = isapnp_checksum_value;
|
||||
card->protocol = &isapnp_protocol;
|
||||
|
||||
|
@ -931,12 +952,10 @@ int isapnp_cfg_end(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Inititialization.
|
||||
*/
|
||||
|
||||
|
||||
EXPORT_SYMBOL(isapnp_protocol);
|
||||
EXPORT_SYMBOL(isapnp_present);
|
||||
EXPORT_SYMBOL(isapnp_cfg_begin);
|
||||
|
@ -946,7 +965,8 @@ EXPORT_SYMBOL(isapnp_read_byte);
|
|||
#endif
|
||||
EXPORT_SYMBOL(isapnp_write_byte);
|
||||
|
||||
static int isapnp_read_resources(struct pnp_dev *dev, struct pnp_resource_table *res)
|
||||
static int isapnp_read_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
int tmp, ret;
|
||||
|
||||
|
@ -960,31 +980,37 @@ static int isapnp_read_resources(struct pnp_dev *dev, struct pnp_resource_table
|
|||
res->port_resource[tmp].flags = IORESOURCE_IO;
|
||||
}
|
||||
for (tmp = 0; tmp < PNP_MAX_MEM; tmp++) {
|
||||
ret = isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
|
||||
ret =
|
||||
isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
|
||||
if (!ret)
|
||||
continue;
|
||||
res->mem_resource[tmp].start = ret;
|
||||
res->mem_resource[tmp].flags = IORESOURCE_MEM;
|
||||
}
|
||||
for (tmp = 0; tmp < PNP_MAX_IRQ; tmp++) {
|
||||
ret = (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >> 8);
|
||||
ret =
|
||||
(isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >>
|
||||
8);
|
||||
if (!ret)
|
||||
continue;
|
||||
res->irq_resource[tmp].start = res->irq_resource[tmp].end = ret;
|
||||
res->irq_resource[tmp].start =
|
||||
res->irq_resource[tmp].end = ret;
|
||||
res->irq_resource[tmp].flags = IORESOURCE_IRQ;
|
||||
}
|
||||
for (tmp = 0; tmp < PNP_MAX_DMA; tmp++) {
|
||||
ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp);
|
||||
if (ret == 4)
|
||||
continue;
|
||||
res->dma_resource[tmp].start = res->dma_resource[tmp].end = ret;
|
||||
res->dma_resource[tmp].start =
|
||||
res->dma_resource[tmp].end = ret;
|
||||
res->dma_resource[tmp].flags = IORESOURCE_DMA;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int isapnp_get_resources(struct pnp_dev *dev, struct pnp_resource_table * res)
|
||||
static int isapnp_get_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
int ret;
|
||||
pnp_init_resource_table(res);
|
||||
|
@ -994,24 +1020,44 @@ static int isapnp_get_resources(struct pnp_dev *dev, struct pnp_resource_table *
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int isapnp_set_resources(struct pnp_dev *dev, struct pnp_resource_table * res)
|
||||
static int isapnp_set_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
int tmp;
|
||||
|
||||
isapnp_cfg_begin(dev->card->number, dev->number);
|
||||
dev->active = 1;
|
||||
for (tmp = 0; tmp < PNP_MAX_PORT && (res->port_resource[tmp].flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO; tmp++)
|
||||
isapnp_write_word(ISAPNP_CFG_PORT+(tmp<<1), res->port_resource[tmp].start);
|
||||
for (tmp = 0; tmp < PNP_MAX_IRQ && (res->irq_resource[tmp].flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ; tmp++) {
|
||||
for (tmp = 0;
|
||||
tmp < PNP_MAX_PORT
|
||||
&& (res->port_resource[tmp].
|
||||
flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO;
|
||||
tmp++)
|
||||
isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1),
|
||||
res->port_resource[tmp].start);
|
||||
for (tmp = 0;
|
||||
tmp < PNP_MAX_IRQ
|
||||
&& (res->irq_resource[tmp].
|
||||
flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ;
|
||||
tmp++) {
|
||||
int irq = res->irq_resource[tmp].start;
|
||||
if (irq == 2)
|
||||
irq = 9;
|
||||
isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq);
|
||||
}
|
||||
for (tmp = 0; tmp < PNP_MAX_DMA && (res->dma_resource[tmp].flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA; tmp++)
|
||||
isapnp_write_byte(ISAPNP_CFG_DMA+tmp, res->dma_resource[tmp].start);
|
||||
for (tmp = 0; tmp < PNP_MAX_MEM && (res->mem_resource[tmp].flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM; tmp++)
|
||||
isapnp_write_word(ISAPNP_CFG_MEM+(tmp<<3), (res->mem_resource[tmp].start >> 8) & 0xffff);
|
||||
for (tmp = 0;
|
||||
tmp < PNP_MAX_DMA
|
||||
&& (res->dma_resource[tmp].
|
||||
flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA;
|
||||
tmp++)
|
||||
isapnp_write_byte(ISAPNP_CFG_DMA + tmp,
|
||||
res->dma_resource[tmp].start);
|
||||
for (tmp = 0;
|
||||
tmp < PNP_MAX_MEM
|
||||
&& (res->mem_resource[tmp].
|
||||
flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM;
|
||||
tmp++)
|
||||
isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3),
|
||||
(res->mem_resource[tmp].start >> 8) & 0xffff);
|
||||
/* FIXME: We aren't handling 32bit mems properly here */
|
||||
isapnp_activate(dev->number);
|
||||
isapnp_cfg_end();
|
||||
|
@ -1053,12 +1099,15 @@ static int __init isapnp_init(void)
|
|||
#endif
|
||||
#ifdef ISAPNP_REGION_OK
|
||||
if (!request_region(_PIDXR, 1, "isapnp index")) {
|
||||
printk(KERN_ERR "isapnp: Index Register 0x%x already used\n", _PIDXR);
|
||||
printk(KERN_ERR "isapnp: Index Register 0x%x already used\n",
|
||||
_PIDXR);
|
||||
return -EBUSY;
|
||||
}
|
||||
#endif
|
||||
if (!request_region(_PNPWRP, 1, "isapnp write")) {
|
||||
printk(KERN_ERR "isapnp: Write Data Register 0x%x already used\n", _PNPWRP);
|
||||
printk(KERN_ERR
|
||||
"isapnp: Write Data Register 0x%x already used\n",
|
||||
_PNPWRP);
|
||||
#ifdef ISAPNP_REGION_OK
|
||||
release_region(_PIDXR, 1);
|
||||
#endif
|
||||
|
@ -1077,7 +1126,9 @@ static int __init isapnp_init(void)
|
|||
if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
|
||||
isapnp_rdp |= 3;
|
||||
if (!request_region(isapnp_rdp, 1, "isapnp read")) {
|
||||
printk(KERN_ERR "isapnp: Read Data Register 0x%x already used\n", isapnp_rdp);
|
||||
printk(KERN_ERR
|
||||
"isapnp: Read Data Register 0x%x already used\n",
|
||||
isapnp_rdp);
|
||||
#ifdef ISAPNP_REGION_OK
|
||||
release_region(_PIDXR, 1);
|
||||
#endif
|
||||
|
@ -1089,14 +1140,14 @@ static int __init isapnp_init(void)
|
|||
isapnp_detected = 1;
|
||||
if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
|
||||
cards = isapnp_isolate();
|
||||
if (cards < 0 ||
|
||||
(isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
|
||||
if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
|
||||
#ifdef ISAPNP_REGION_OK
|
||||
release_region(_PIDXR, 1);
|
||||
#endif
|
||||
release_region(_PNPWRP, 1);
|
||||
isapnp_detected = 0;
|
||||
printk(KERN_INFO "isapnp: No Plug & Play device found\n");
|
||||
printk(KERN_INFO
|
||||
"isapnp: No Plug & Play device found\n");
|
||||
return 0;
|
||||
}
|
||||
request_region(isapnp_rdp, 1, "isapnp read");
|
||||
|
@ -1107,16 +1158,20 @@ static int __init isapnp_init(void)
|
|||
protocol_for_each_card(&isapnp_protocol, card) {
|
||||
cards++;
|
||||
if (isapnp_verbose) {
|
||||
printk(KERN_INFO "isapnp: Card '%s'\n", card->name[0]?card->name:"Unknown");
|
||||
printk(KERN_INFO "isapnp: Card '%s'\n",
|
||||
card->name[0] ? card->name : "Unknown");
|
||||
if (isapnp_verbose < 2)
|
||||
continue;
|
||||
card_for_each_dev(card, dev) {
|
||||
printk(KERN_INFO "isapnp: Device '%s'\n", dev->name[0]?dev->name:"Unknown");
|
||||
printk(KERN_INFO "isapnp: Device '%s'\n",
|
||||
dev->name[0] ? dev->name : "Unknown");
|
||||
}
|
||||
}
|
||||
}
|
||||
if (cards) {
|
||||
printk(KERN_INFO "isapnp: %i Plug & Play card%s detected total\n", cards, cards>1?"s":"");
|
||||
printk(KERN_INFO
|
||||
"isapnp: %i Plug & Play card%s detected total\n", cards,
|
||||
cards > 1 ? "s" : "");
|
||||
} else {
|
||||
printk(KERN_INFO "isapnp: No Plug & Play card found\n");
|
||||
}
|
||||
|
@ -1148,4 +1203,3 @@ static int __init isapnp_setup_isapnp(char *str)
|
|||
}
|
||||
|
||||
__setup("isapnp=", isapnp_setup_isapnp);
|
||||
|
||||
|
|
|
@ -54,7 +54,8 @@ static loff_t isapnp_proc_bus_lseek(struct file *file, loff_t off, int whence)
|
|||
return (file->f_pos = new);
|
||||
}
|
||||
|
||||
static ssize_t isapnp_proc_bus_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
|
||||
static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf,
|
||||
size_t nbytes, loff_t * ppos)
|
||||
{
|
||||
struct inode *ino = file->f_path.dentry->d_inode;
|
||||
struct proc_dir_entry *dp = PDE(ino);
|
||||
|
@ -85,8 +86,7 @@ static ssize_t isapnp_proc_bus_read(struct file *file, char __user *buf, size_t
|
|||
return nbytes;
|
||||
}
|
||||
|
||||
static const struct file_operations isapnp_proc_bus_file_operations =
|
||||
{
|
||||
static const struct file_operations isapnp_proc_bus_file_operations = {
|
||||
.llseek = isapnp_proc_bus_lseek,
|
||||
.read = isapnp_proc_bus_read,
|
||||
};
|
||||
|
|
|
@ -26,7 +26,8 @@ static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
|
|||
return -EINVAL;
|
||||
|
||||
if (idx >= PNP_MAX_PORT) {
|
||||
pnp_err("More than 4 ports is incompatible with pnp specifications.");
|
||||
pnp_err
|
||||
("More than 4 ports is incompatible with pnp specifications.");
|
||||
/* pretend we were successful so at least the manager won't try again */
|
||||
return 1;
|
||||
}
|
||||
|
@ -70,7 +71,8 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
|
|||
return -EINVAL;
|
||||
|
||||
if (idx >= PNP_MAX_MEM) {
|
||||
pnp_err("More than 8 mems is incompatible with pnp specifications.");
|
||||
pnp_err
|
||||
("More than 8 mems is incompatible with pnp specifications.");
|
||||
/* pretend we were successful so at least the manager won't try again */
|
||||
return 1;
|
||||
}
|
||||
|
@ -130,7 +132,8 @@ static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
|
|||
return -EINVAL;
|
||||
|
||||
if (idx >= PNP_MAX_IRQ) {
|
||||
pnp_err("More than 2 irqs is incompatible with pnp specifications.");
|
||||
pnp_err
|
||||
("More than 2 irqs is incompatible with pnp specifications.");
|
||||
/* pretend we were successful so at least the manager won't try again */
|
||||
return 1;
|
||||
}
|
||||
|
@ -183,7 +186,8 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
|
|||
return -EINVAL;
|
||||
|
||||
if (idx >= PNP_MAX_DMA) {
|
||||
pnp_err("More than 2 dmas is incompatible with pnp specifications.");
|
||||
pnp_err
|
||||
("More than 2 dmas is incompatible with pnp specifications.");
|
||||
/* pretend we were successful so at least the manager won't try again */
|
||||
return 1;
|
||||
}
|
||||
|
@ -227,25 +231,29 @@ void pnp_init_resource_table(struct pnp_resource_table *table)
|
|||
table->irq_resource[idx].name = NULL;
|
||||
table->irq_resource[idx].start = -1;
|
||||
table->irq_resource[idx].end = -1;
|
||||
table->irq_resource[idx].flags = IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
table->irq_resource[idx].flags =
|
||||
IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_DMA; idx++) {
|
||||
table->dma_resource[idx].name = NULL;
|
||||
table->dma_resource[idx].start = -1;
|
||||
table->dma_resource[idx].end = -1;
|
||||
table->dma_resource[idx].flags = IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
table->dma_resource[idx].flags =
|
||||
IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_PORT; idx++) {
|
||||
table->port_resource[idx].name = NULL;
|
||||
table->port_resource[idx].start = 0;
|
||||
table->port_resource[idx].end = 0;
|
||||
table->port_resource[idx].flags = IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
table->port_resource[idx].flags =
|
||||
IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_MEM; idx++) {
|
||||
table->mem_resource[idx].name = NULL;
|
||||
table->mem_resource[idx].start = 0;
|
||||
table->mem_resource[idx].end = 0;
|
||||
table->mem_resource[idx].flags = IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
table->mem_resource[idx].flags =
|
||||
IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -262,28 +270,32 @@ static void pnp_clean_resource_table(struct pnp_resource_table * res)
|
|||
continue;
|
||||
res->irq_resource[idx].start = -1;
|
||||
res->irq_resource[idx].end = -1;
|
||||
res->irq_resource[idx].flags = IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
res->irq_resource[idx].flags =
|
||||
IORESOURCE_IRQ | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_DMA; idx++) {
|
||||
if (!(res->dma_resource[idx].flags & IORESOURCE_AUTO))
|
||||
continue;
|
||||
res->dma_resource[idx].start = -1;
|
||||
res->dma_resource[idx].end = -1;
|
||||
res->dma_resource[idx].flags = IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
res->dma_resource[idx].flags =
|
||||
IORESOURCE_DMA | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_PORT; idx++) {
|
||||
if (!(res->port_resource[idx].flags & IORESOURCE_AUTO))
|
||||
continue;
|
||||
res->port_resource[idx].start = 0;
|
||||
res->port_resource[idx].end = 0;
|
||||
res->port_resource[idx].flags = IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
res->port_resource[idx].flags =
|
||||
IORESOURCE_IO | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
for (idx = 0; idx < PNP_MAX_MEM; idx++) {
|
||||
if (!(res->mem_resource[idx].flags & IORESOURCE_AUTO))
|
||||
continue;
|
||||
res->mem_resource[idx].start = 0;
|
||||
res->mem_resource[idx].end = 0;
|
||||
res->mem_resource[idx].flags = IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
res->mem_resource[idx].flags =
|
||||
IORESOURCE_MEM | IORESOURCE_AUTO | IORESOURCE_UNSET;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -341,7 +353,8 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
|
|||
if (depnum) {
|
||||
struct pnp_option *dep;
|
||||
int i;
|
||||
for (i=1,dep=dev->dependent; i<depnum; i++, dep=dep->next)
|
||||
for (i = 1, dep = dev->dependent; i < depnum;
|
||||
i++, dep = dep->next)
|
||||
if (!dep)
|
||||
goto fail;
|
||||
port = dep->port;
|
||||
|
@ -392,7 +405,8 @@ fail:
|
|||
*
|
||||
* This function can be used by drivers that want to manually set thier resources.
|
||||
*/
|
||||
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table * res, int mode)
|
||||
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
|
||||
int mode)
|
||||
{
|
||||
int i;
|
||||
struct pnp_resource_table *bak;
|
||||
|
@ -451,7 +465,8 @@ int pnp_auto_config_dev(struct pnp_dev *dev)
|
|||
return -EINVAL;
|
||||
|
||||
if (!pnp_can_configure(dev)) {
|
||||
pnp_dbg("Device %s does not support resource configuration.", dev->dev.bus_id);
|
||||
pnp_dbg("Device %s does not support resource configuration.",
|
||||
dev->dev.bus_id);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
|
@ -482,7 +497,8 @@ int pnp_auto_config_dev(struct pnp_dev *dev)
|
|||
int pnp_start_dev(struct pnp_dev *dev)
|
||||
{
|
||||
if (!pnp_can_write(dev)) {
|
||||
pnp_dbg("Device %s does not support activation.", dev->dev.bus_id);
|
||||
pnp_dbg("Device %s does not support activation.",
|
||||
dev->dev.bus_id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
|
@ -506,7 +522,8 @@ int pnp_start_dev(struct pnp_dev *dev)
|
|||
int pnp_stop_dev(struct pnp_dev *dev)
|
||||
{
|
||||
if (!pnp_can_disable(dev)) {
|
||||
pnp_dbg("Device %s does not support disabling.", dev->dev.bus_id);
|
||||
pnp_dbg("Device %s does not support disabling.",
|
||||
dev->dev.bus_id);
|
||||
return -EINVAL;
|
||||
}
|
||||
if (dev->protocol->disable(dev) < 0) {
|
||||
|
@ -595,7 +612,6 @@ void pnp_resource_change(struct resource *resource, resource_size_t start,
|
|||
resource->end = start + size - 1;
|
||||
}
|
||||
|
||||
|
||||
EXPORT_SYMBOL(pnp_manual_config_dev);
|
||||
#if 0
|
||||
EXPORT_SYMBOL(pnp_auto_config_dev);
|
||||
|
|
|
@ -84,7 +84,8 @@ static void __init pnpidacpi_to_pnpid(char *id, char *str)
|
|||
str[7] = '\0';
|
||||
}
|
||||
|
||||
static int pnpacpi_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res)
|
||||
static int pnpacpi_get_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
acpi_status status;
|
||||
status = pnpacpi_parse_allocated_resource((acpi_handle) dev->data,
|
||||
|
@ -92,7 +93,8 @@ static int pnpacpi_get_resources(struct pnp_dev * dev, struct pnp_resource_table
|
|||
return ACPI_FAILURE(status) ? -ENODEV : 0;
|
||||
}
|
||||
|
||||
static int pnpacpi_set_resources(struct pnp_dev * dev, struct pnp_resource_table * res)
|
||||
static int pnpacpi_set_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
acpi_handle handle = dev->data;
|
||||
struct acpi_buffer buffer;
|
||||
|
@ -128,7 +130,9 @@ static int pnpacpi_suspend(struct pnp_dev *dev, pm_message_t state)
|
|||
{
|
||||
return acpi_bus_set_power((acpi_handle) dev->data,
|
||||
acpi_pm_device_sleep_state(&dev->dev,
|
||||
device_may_wakeup(&dev->dev), NULL));
|
||||
device_may_wakeup
|
||||
(&dev->dev),
|
||||
NULL));
|
||||
}
|
||||
|
||||
static int pnpacpi_resume(struct pnp_dev *dev)
|
||||
|
@ -196,9 +200,11 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
|
|||
|
||||
if (dev->active) {
|
||||
/* parse allocated resource */
|
||||
status = pnpacpi_parse_allocated_resource(device->handle, &dev->res);
|
||||
status =
|
||||
pnpacpi_parse_allocated_resource(device->handle, &dev->res);
|
||||
if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
|
||||
pnp_err("PnPACPI: METHOD_NAME__CRS failure for %s", dev_id->id);
|
||||
pnp_err("PnPACPI: METHOD_NAME__CRS failure for %s",
|
||||
dev_id->id);
|
||||
goto err1;
|
||||
}
|
||||
}
|
||||
|
@ -207,7 +213,8 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
|
|||
status = pnpacpi_parse_resource_option_data(device->handle,
|
||||
dev);
|
||||
if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
|
||||
pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s", dev_id->id);
|
||||
pnp_err("PnPACPI: METHOD_NAME__PRS failure for %s",
|
||||
dev_id->id);
|
||||
goto err1;
|
||||
}
|
||||
}
|
||||
|
@ -244,7 +251,8 @@ err:
|
|||
}
|
||||
|
||||
static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
|
||||
u32 lvl, void *context, void **rv)
|
||||
u32 lvl, void *context,
|
||||
void **rv)
|
||||
{
|
||||
struct acpi_device *device;
|
||||
|
||||
|
@ -272,8 +280,7 @@ static int __init acpi_pnp_find_device(struct device *dev, acpi_handle *handle)
|
|||
struct acpi_device *acpi;
|
||||
|
||||
adev = bus_find_device(&acpi_bus_type, NULL,
|
||||
to_pnp_dev(dev),
|
||||
acpi_pnp_match);
|
||||
to_pnp_dev(dev), acpi_pnp_match);
|
||||
if (!adev)
|
||||
return -ENODEV;
|
||||
|
||||
|
@ -307,6 +314,7 @@ static int __init pnpacpi_init(void)
|
|||
pnp_platform_devices = 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
subsys_initcall(pnpacpi_init);
|
||||
|
||||
static int __init pnpacpi_setup(char *str)
|
||||
|
@ -317,6 +325,7 @@ static int __init pnpacpi_setup(char *str)
|
|||
pnpacpi_disabled = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
__setup("pnpacpi=", pnpacpi_setup);
|
||||
|
||||
#if 0
|
||||
|
|
|
@ -40,8 +40,7 @@ static int irq_flags(int triggering, int polarity)
|
|||
flag = IORESOURCE_IRQ_LOWLEVEL;
|
||||
else
|
||||
flag = IORESOURCE_IRQ_HIGHLEVEL;
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
if (polarity == ACPI_ACTIVE_LOW)
|
||||
flag = IORESOURCE_IRQ_LOWEDGE;
|
||||
else
|
||||
|
@ -157,7 +156,8 @@ pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res, u32 dma,
|
|||
i++;
|
||||
if (i < PNP_MAX_DMA) {
|
||||
res->dma_resource[i].flags = IORESOURCE_DMA; // Also clears _UNSET flag
|
||||
res->dma_resource[i].flags |= dma_flags(type, bus_master, transfer);
|
||||
res->dma_resource[i].flags |=
|
||||
dma_flags(type, bus_master, transfer);
|
||||
if (dma == -1) {
|
||||
res->dma_resource[i].flags |= IORESOURCE_DISABLED;
|
||||
return;
|
||||
|
@ -229,17 +229,23 @@ pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
|
|||
|
||||
if (p->resource_type == ACPI_MEMORY_RANGE)
|
||||
pnpacpi_parse_allocated_memresource(res_table,
|
||||
p->minimum, p->address_length, p->info.mem.write_protect);
|
||||
p->minimum,
|
||||
p->address_length,
|
||||
p->info.mem.write_protect);
|
||||
else if (p->resource_type == ACPI_IO_RANGE)
|
||||
pnpacpi_parse_allocated_ioresource(res_table,
|
||||
p->minimum, p->address_length,
|
||||
p->granularity == 0xfff ? ACPI_DECODE_10 : ACPI_DECODE_16);
|
||||
p->minimum,
|
||||
p->address_length,
|
||||
p->granularity ==
|
||||
0xfff ? ACPI_DECODE_10 :
|
||||
ACPI_DECODE_16);
|
||||
}
|
||||
|
||||
static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
||||
void *data)
|
||||
{
|
||||
struct pnp_resource_table *res_table = (struct pnp_resource_table *)data;
|
||||
struct pnp_resource_table *res_table =
|
||||
(struct pnp_resource_table *)data;
|
||||
int i;
|
||||
|
||||
switch (res->type) {
|
||||
|
@ -250,20 +256,27 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
|||
*/
|
||||
for (i = 0; i < res->data.irq.interrupt_count; i++) {
|
||||
pnpacpi_parse_allocated_irqresource(res_table,
|
||||
res->data.irq.interrupts[i],
|
||||
res->data.irq.triggering,
|
||||
res->data.irq.polarity,
|
||||
res->data.irq.sharable);
|
||||
res->data.irq.
|
||||
interrupts[i],
|
||||
res->data.irq.
|
||||
triggering,
|
||||
res->data.irq.
|
||||
polarity,
|
||||
res->data.irq.
|
||||
sharable);
|
||||
}
|
||||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_DMA:
|
||||
if (res->data.dma.channel_count > 0)
|
||||
pnpacpi_parse_allocated_dmaresource(res_table,
|
||||
res->data.dma.channels[0],
|
||||
res->data.dma.
|
||||
channels[0],
|
||||
res->data.dma.type,
|
||||
res->data.dma.bus_master,
|
||||
res->data.dma.transfer);
|
||||
res->data.dma.
|
||||
bus_master,
|
||||
res->data.dma.
|
||||
transfer);
|
||||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_IO:
|
||||
|
@ -280,7 +293,8 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
|||
case ACPI_RESOURCE_TYPE_FIXED_IO:
|
||||
pnpacpi_parse_allocated_ioresource(res_table,
|
||||
res->data.fixed_io.address,
|
||||
res->data.fixed_io.address_length,
|
||||
res->data.fixed_io.
|
||||
address_length,
|
||||
ACPI_DECODE_10);
|
||||
break;
|
||||
|
||||
|
@ -293,20 +307,27 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
|||
case ACPI_RESOURCE_TYPE_MEMORY24:
|
||||
pnpacpi_parse_allocated_memresource(res_table,
|
||||
res->data.memory24.minimum,
|
||||
res->data.memory24.address_length,
|
||||
res->data.memory24.write_protect);
|
||||
res->data.memory24.
|
||||
address_length,
|
||||
res->data.memory24.
|
||||
write_protect);
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_MEMORY32:
|
||||
pnpacpi_parse_allocated_memresource(res_table,
|
||||
res->data.memory32.minimum,
|
||||
res->data.memory32.address_length,
|
||||
res->data.memory32.write_protect);
|
||||
res->data.memory32.
|
||||
address_length,
|
||||
res->data.memory32.
|
||||
write_protect);
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
|
||||
pnpacpi_parse_allocated_memresource(res_table,
|
||||
res->data.fixed_memory32.address,
|
||||
res->data.fixed_memory32.address_length,
|
||||
res->data.fixed_memory32.write_protect);
|
||||
res->data.fixed_memory32.
|
||||
address,
|
||||
res->data.fixed_memory32.
|
||||
address_length,
|
||||
res->data.fixed_memory32.
|
||||
write_protect);
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_ADDRESS16:
|
||||
case ACPI_RESOURCE_TYPE_ADDRESS32:
|
||||
|
@ -325,10 +346,18 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
|||
|
||||
for (i = 0; i < res->data.extended_irq.interrupt_count; i++) {
|
||||
pnpacpi_parse_allocated_irqresource(res_table,
|
||||
res->data.extended_irq.interrupts[i],
|
||||
res->data.extended_irq.triggering,
|
||||
res->data.extended_irq.polarity,
|
||||
res->data.extended_irq.sharable);
|
||||
res->data.
|
||||
extended_irq.
|
||||
interrupts[i],
|
||||
res->data.
|
||||
extended_irq.
|
||||
triggering,
|
||||
res->data.
|
||||
extended_irq.
|
||||
polarity,
|
||||
res->data.
|
||||
extended_irq.
|
||||
sharable);
|
||||
}
|
||||
break;
|
||||
|
||||
|
@ -343,15 +372,18 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
|
|||
return AE_OK;
|
||||
}
|
||||
|
||||
acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle, struct pnp_resource_table *res)
|
||||
acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle,
|
||||
struct pnp_resource_table * res)
|
||||
{
|
||||
/* Blank the resource table values */
|
||||
pnp_init_resource_table(res);
|
||||
|
||||
return acpi_walk_resources(handle, METHOD_NAME__CRS, pnpacpi_allocated_resource, res);
|
||||
return acpi_walk_resources(handle, METHOD_NAME__CRS,
|
||||
pnpacpi_allocated_resource, res);
|
||||
}
|
||||
|
||||
static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_resource_dma *p)
|
||||
static void pnpacpi_parse_dma_option(struct pnp_option *option,
|
||||
struct acpi_resource_dma *p)
|
||||
{
|
||||
int i;
|
||||
struct pnp_dma *dma;
|
||||
|
@ -371,7 +403,6 @@ static void pnpacpi_parse_dma_option(struct pnp_option *option, struct acpi_reso
|
|||
return;
|
||||
}
|
||||
|
||||
|
||||
static void pnpacpi_parse_irq_option(struct pnp_option *option,
|
||||
struct acpi_resource_irq *p)
|
||||
{
|
||||
|
@ -532,7 +563,8 @@ pnpacpi_parse_address_option(struct pnp_option *option, struct acpi_resource *r)
|
|||
|
||||
status = acpi_resource_to_address64(r, p);
|
||||
if (!ACPI_SUCCESS(status)) {
|
||||
pnp_warn("PnPACPI: failed to convert resource type %d", r->type);
|
||||
pnp_warn("PnPACPI: failed to convert resource type %d",
|
||||
r->type);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -547,7 +579,8 @@ pnpacpi_parse_address_option(struct pnp_option *option, struct acpi_resource *r)
|
|||
mem->size = p->address_length;
|
||||
mem->align = 0;
|
||||
mem->flags = (p->info.mem.write_protect ==
|
||||
ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE : 0;
|
||||
ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE
|
||||
: 0;
|
||||
pnp_register_mem_resource(option, mem);
|
||||
} else if (p->resource_type == ACPI_IO_RANGE) {
|
||||
port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
|
||||
|
@ -571,7 +604,8 @@ static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
|
|||
void *data)
|
||||
{
|
||||
int priority = 0;
|
||||
struct acpipnp_parse_option_s *parse_data = (struct acpipnp_parse_option_s *)data;
|
||||
struct acpipnp_parse_option_s *parse_data =
|
||||
(struct acpipnp_parse_option_s *)data;
|
||||
struct pnp_dev *dev = parse_data->dev;
|
||||
struct pnp_option *option = parse_data->option;
|
||||
|
||||
|
@ -623,8 +657,7 @@ static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
|
|||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_FIXED_IO:
|
||||
pnpacpi_parse_fixed_port_option(option,
|
||||
&res->data.fixed_io);
|
||||
pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io);
|
||||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_VENDOR:
|
||||
|
@ -654,8 +687,7 @@ static acpi_status pnpacpi_option_resource(struct acpi_resource *res,
|
|||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
|
||||
pnpacpi_parse_ext_irq_option(option,
|
||||
&res->data.extended_irq);
|
||||
pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq);
|
||||
break;
|
||||
|
||||
case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
|
||||
|
@ -892,7 +924,8 @@ int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
|
|||
int i = 0;
|
||||
/* pnpacpi_build_resource_template allocates extra mem */
|
||||
int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
|
||||
struct acpi_resource *resource = (struct acpi_resource*)buffer->pointer;
|
||||
struct acpi_resource *resource =
|
||||
(struct acpi_resource *)buffer->pointer;
|
||||
int port = 0, irq = 0, dma = 0, mem = 0;
|
||||
|
||||
pnp_dbg("res cnt %d", res_cnt);
|
||||
|
@ -920,7 +953,8 @@ int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
|
|||
case ACPI_RESOURCE_TYPE_FIXED_IO:
|
||||
pnp_dbg("Encode fixed io");
|
||||
pnpacpi_encode_fixed_io(resource,
|
||||
&res_table->port_resource[port]);
|
||||
&res_table->
|
||||
port_resource[port]);
|
||||
port++;
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_MEMORY24:
|
||||
|
@ -938,7 +972,8 @@ int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
|
|||
case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
|
||||
pnp_dbg("Encode fixed mem32");
|
||||
pnpacpi_encode_fixed_mem32(resource,
|
||||
&res_table->mem_resource[mem]);
|
||||
&res_table->
|
||||
mem_resource[mem]);
|
||||
mem++;
|
||||
break;
|
||||
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
|
||||
|
|
|
@ -30,7 +30,6 @@ static struct {
|
|||
u16 segment;
|
||||
} pnp_bios_callpoint;
|
||||
|
||||
|
||||
/*
|
||||
* These are some opcodes for a "static asmlinkage"
|
||||
* As this code is *not* executed inside the linux kernel segment, but in a
|
||||
|
@ -44,8 +43,7 @@ static struct {
|
|||
|
||||
asmlinkage void pnp_bios_callfunc(void);
|
||||
|
||||
__asm__(
|
||||
".text \n"
|
||||
__asm__(".text \n"
|
||||
__ALIGN_STR "\n"
|
||||
"pnp_bios_callfunc:\n"
|
||||
" pushl %edx \n"
|
||||
|
@ -54,9 +52,7 @@ __asm__(
|
|||
" pushl %eax \n"
|
||||
" lcallw *pnp_bios_callpoint\n"
|
||||
" addl $16, %esp \n"
|
||||
" lret \n"
|
||||
".previous \n"
|
||||
);
|
||||
" lret \n" ".previous \n");
|
||||
|
||||
#define Q2_SET_SEL(cpu, selname, address, size) \
|
||||
do { \
|
||||
|
@ -78,7 +74,6 @@ u32 pnp_bios_is_utter_crap = 0;
|
|||
|
||||
static spinlock_t pnp_bios_lock;
|
||||
|
||||
|
||||
/*
|
||||
* Support Functions
|
||||
*/
|
||||
|
@ -113,8 +108,7 @@ static inline u16 call_pnp_bios(u16 func, u16 arg1, u16 arg2, u16 arg3,
|
|||
if (ts2_size)
|
||||
Q2_SET_SEL(smp_processor_id(), PNP_TS2, ts2_base, ts2_size);
|
||||
|
||||
__asm__ __volatile__(
|
||||
"pushl %%ebp\n\t"
|
||||
__asm__ __volatile__("pushl %%ebp\n\t"
|
||||
"pushl %%edi\n\t"
|
||||
"pushl %%esi\n\t"
|
||||
"pushl %%ds\n\t"
|
||||
|
@ -131,28 +125,26 @@ static inline u16 call_pnp_bios(u16 func, u16 arg1, u16 arg2, u16 arg3,
|
|||
"popl %%es\n\t"
|
||||
"popl %%ds\n\t"
|
||||
"popl %%esi\n\t"
|
||||
"popl %%edi\n\t"
|
||||
"popl %%ebp\n\t"
|
||||
: "=a" (status)
|
||||
"popl %%edi\n\t" "popl %%ebp\n\t":"=a"(status)
|
||||
:"0"((func) | (((u32) arg1) << 16)),
|
||||
"b"((arg2) | (((u32) arg3) << 16)),
|
||||
"c"((arg4) | (((u32) arg5) << 16)),
|
||||
"d"((arg6) | (((u32) arg7) << 16)),
|
||||
"i" (PNP_CS32),
|
||||
"i" (0)
|
||||
: "memory"
|
||||
);
|
||||
"i"(PNP_CS32), "i"(0)
|
||||
:"memory");
|
||||
spin_unlock_irqrestore(&pnp_bios_lock, flags);
|
||||
|
||||
get_cpu_gdt_table(cpu)[0x40 / 8] = save_desc_40;
|
||||
put_cpu();
|
||||
|
||||
/* If we get here and this is set then the PnP BIOS faulted on us. */
|
||||
if(pnp_bios_is_utter_crap)
|
||||
{
|
||||
printk(KERN_ERR "PnPBIOS: Warning! Your PnP BIOS caused a fatal error. Attempting to continue\n");
|
||||
printk(KERN_ERR "PnPBIOS: You may need to reboot with the \"pnpbios=off\" option to operate stably\n");
|
||||
printk(KERN_ERR "PnPBIOS: Check with your vendor for an updated BIOS\n");
|
||||
if (pnp_bios_is_utter_crap) {
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Warning! Your PnP BIOS caused a fatal error. Attempting to continue\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: You may need to reboot with the \"pnpbios=off\" option to operate stably\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Check with your vendor for an updated BIOS\n");
|
||||
}
|
||||
|
||||
return status;
|
||||
|
@ -165,60 +157,78 @@ void pnpbios_print_status(const char * module, u16 status)
|
|||
printk(KERN_ERR "PnPBIOS: %s: function successful\n", module);
|
||||
break;
|
||||
case PNP_NOT_SET_STATICALLY:
|
||||
printk(KERN_ERR "PnPBIOS: %s: unable to set static resources\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: unable to set static resources\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_UNKNOWN_FUNCTION:
|
||||
printk(KERN_ERR "PnPBIOS: %s: invalid function number passed\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: invalid function number passed\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_FUNCTION_NOT_SUPPORTED:
|
||||
printk(KERN_ERR "PnPBIOS: %s: function not supported on this system\n", module);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: %s: function not supported on this system\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_INVALID_HANDLE:
|
||||
printk(KERN_ERR "PnPBIOS: %s: invalid handle\n", module);
|
||||
break;
|
||||
case PNP_BAD_PARAMETER:
|
||||
printk(KERN_ERR "PnPBIOS: %s: invalid parameters were passed\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: invalid parameters were passed\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_SET_FAILED:
|
||||
printk(KERN_ERR "PnPBIOS: %s: unable to set resources\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: unable to set resources\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_EVENTS_NOT_PENDING:
|
||||
printk(KERN_ERR "PnPBIOS: %s: no events are pending\n", module);
|
||||
break;
|
||||
case PNP_SYSTEM_NOT_DOCKED:
|
||||
printk(KERN_ERR "PnPBIOS: %s: the system is not docked\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: the system is not docked\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_NO_ISA_PNP_CARDS:
|
||||
printk(KERN_ERR "PnPBIOS: %s: no isapnp cards are installed on this system\n", module);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: %s: no isapnp cards are installed on this system\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_UNABLE_TO_DETERMINE_DOCK_CAPABILITIES:
|
||||
printk(KERN_ERR "PnPBIOS: %s: cannot determine the capabilities of the docking station\n", module);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: %s: cannot determine the capabilities of the docking station\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_CONFIG_CHANGE_FAILED_NO_BATTERY:
|
||||
printk(KERN_ERR "PnPBIOS: %s: unable to undock, the system does not have a battery\n", module);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: %s: unable to undock, the system does not have a battery\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_CONFIG_CHANGE_FAILED_RESOURCE_CONFLICT:
|
||||
printk(KERN_ERR "PnPBIOS: %s: could not dock due to resource conflicts\n", module);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: %s: could not dock due to resource conflicts\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_BUFFER_TOO_SMALL:
|
||||
printk(KERN_ERR "PnPBIOS: %s: the buffer passed is too small\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: the buffer passed is too small\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_USE_ESCD_SUPPORT:
|
||||
printk(KERN_ERR "PnPBIOS: %s: use ESCD instead\n", module);
|
||||
break;
|
||||
case PNP_MESSAGE_NOT_SUPPORTED:
|
||||
printk(KERN_ERR "PnPBIOS: %s: the message is unsupported\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: the message is unsupported\n",
|
||||
module);
|
||||
break;
|
||||
case PNP_HARDWARE_ERROR:
|
||||
printk(KERN_ERR "PnPBIOS: %s: a hardware failure has occured\n", module);
|
||||
printk(KERN_ERR "PnPBIOS: %s: a hardware failure has occured\n",
|
||||
module);
|
||||
break;
|
||||
default:
|
||||
printk(KERN_ERR "PnPBIOS: %s: unexpected status 0x%x\n", module, status);
|
||||
printk(KERN_ERR "PnPBIOS: %s: unexpected status 0x%x\n", module,
|
||||
status);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* PnP BIOS Low Level Calls
|
||||
*/
|
||||
|
@ -245,8 +255,10 @@ static int __pnp_bios_dev_node_info(struct pnp_dev_node_info *data)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_NUM_SYS_DEV_NODES, 0, PNP_TS1, 2, PNP_TS1, PNP_DS, 0, 0,
|
||||
data, sizeof(struct pnp_dev_node_info), NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_NUM_SYS_DEV_NODES, 0, PNP_TS1, 2, PNP_TS1,
|
||||
PNP_DS, 0, 0, data, sizeof(struct pnp_dev_node_info),
|
||||
NULL, 0);
|
||||
data->no_nodes &= 0xff;
|
||||
return status;
|
||||
}
|
||||
|
@ -273,7 +285,8 @@ int pnp_bios_dev_node_info(struct pnp_dev_node_info *data)
|
|||
* or volatile current (0) config
|
||||
* Output: *nodenum=next node or 0xff if no more nodes
|
||||
*/
|
||||
static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data)
|
||||
static int __pnp_bios_get_dev_node(u8 * nodenum, char boot,
|
||||
struct pnp_bios_node *data)
|
||||
{
|
||||
u16 status;
|
||||
u16 tmp_nodenum;
|
||||
|
@ -282,8 +295,10 @@ static int __pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node
|
|||
if (!boot && pnpbios_dont_use_current_config)
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
tmp_nodenum = *nodenum;
|
||||
status = call_pnp_bios(PNP_GET_SYS_DEV_NODE, 0, PNP_TS1, 0, PNP_TS2, boot ? 2 : 1, PNP_DS, 0,
|
||||
&tmp_nodenum, sizeof(tmp_nodenum), data, 65536);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_SYS_DEV_NODE, 0, PNP_TS1, 0, PNP_TS2,
|
||||
boot ? 2 : 1, PNP_DS, 0, &tmp_nodenum,
|
||||
sizeof(tmp_nodenum), data, 65536);
|
||||
*nodenum = tmp_nodenum;
|
||||
return status;
|
||||
}
|
||||
|
@ -297,22 +312,23 @@ int pnp_bios_get_dev_node(u8 *nodenum, char boot, struct pnp_bios_node *data)
|
|||
return status;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Call PnP BIOS with function 0x02, "set system device node"
|
||||
* Input: *nodenum = desired node,
|
||||
* boot = whether to set nonvolatile boot (!=0)
|
||||
* or volatile current (0) config
|
||||
*/
|
||||
static int __pnp_bios_set_dev_node(u8 nodenum, char boot, struct pnp_bios_node *data)
|
||||
static int __pnp_bios_set_dev_node(u8 nodenum, char boot,
|
||||
struct pnp_bios_node *data)
|
||||
{
|
||||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
if (!boot && pnpbios_dont_use_current_config)
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_SET_SYS_DEV_NODE, nodenum, 0, PNP_TS1, boot ? 2 : 1, PNP_DS, 0, 0,
|
||||
data, 65536, NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_SET_SYS_DEV_NODE, nodenum, 0, PNP_TS1,
|
||||
boot ? 2 : 1, PNP_DS, 0, 0, data, 65536, NULL, 0);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
@ -356,7 +372,9 @@ static int pnp_bios_send_message(u16 message)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_SEND_MESSAGE, message, PNP_DS, 0, 0, 0, 0, 0, 0, 0, 0, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_SEND_MESSAGE, message, PNP_DS, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0);
|
||||
return status;
|
||||
}
|
||||
#endif
|
||||
|
@ -369,8 +387,10 @@ int pnp_bios_dock_station_info(struct pnp_docking_station_info *data)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_DOCKING_STATION_INFORMATION, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0,
|
||||
data, sizeof(struct pnp_docking_station_info), NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_DOCKING_STATION_INFORMATION, 0, PNP_TS1,
|
||||
PNP_DS, 0, 0, 0, 0, data,
|
||||
sizeof(struct pnp_docking_station_info), NULL, 0);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
@ -384,8 +404,9 @@ static int pnp_bios_set_stat_res(char *info)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_SET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0,
|
||||
info, *((u16 *) info), 0, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_SET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS,
|
||||
0, 0, 0, 0, info, *((u16 *) info), 0, 0);
|
||||
return status;
|
||||
}
|
||||
#endif
|
||||
|
@ -399,8 +420,9 @@ static int __pnp_bios_get_stat_res(char *info)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0,
|
||||
info, 65536, NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_STATIC_ALLOCED_RES_INFO, 0, PNP_TS1, PNP_DS,
|
||||
0, 0, 0, 0, info, 65536, NULL, 0);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
@ -422,8 +444,9 @@ static int pnp_bios_apm_id_table(char *table, u16 *size)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_APM_ID_TABLE, 0, PNP_TS2, 0, PNP_TS1, PNP_DS, 0, 0,
|
||||
table, *size, size, sizeof(u16));
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_APM_ID_TABLE, 0, PNP_TS2, 0, PNP_TS1, PNP_DS,
|
||||
0, 0, table, *size, size, sizeof(u16));
|
||||
return status;
|
||||
}
|
||||
#endif
|
||||
|
@ -436,8 +459,10 @@ static int __pnp_bios_isapnp_config(struct pnp_isa_config_struc *data)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return PNP_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_PNP_ISA_CONFIG_STRUC, 0, PNP_TS1, PNP_DS, 0, 0, 0, 0,
|
||||
data, sizeof(struct pnp_isa_config_struc), NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_PNP_ISA_CONFIG_STRUC, 0, PNP_TS1, PNP_DS, 0,
|
||||
0, 0, 0, data, sizeof(struct pnp_isa_config_struc),
|
||||
NULL, 0);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
@ -458,8 +483,10 @@ static int __pnp_bios_escd_info(struct escd_info_struc *data)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return ESCD_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_GET_ESCD_INFO, 0, PNP_TS1, 2, PNP_TS1, 4, PNP_TS1, PNP_DS,
|
||||
data, sizeof(struct escd_info_struc), NULL, 0);
|
||||
status =
|
||||
call_pnp_bios(PNP_GET_ESCD_INFO, 0, PNP_TS1, 2, PNP_TS1, 4, PNP_TS1,
|
||||
PNP_DS, data, sizeof(struct escd_info_struc), NULL,
|
||||
0);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
@ -481,7 +508,8 @@ static int __pnp_bios_read_escd(char *data, u32 nvram_base)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return ESCD_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_READ_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0,
|
||||
status =
|
||||
call_pnp_bios(PNP_READ_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0,
|
||||
data, 65536, __va(nvram_base), 65536);
|
||||
return status;
|
||||
}
|
||||
|
@ -504,13 +532,13 @@ static int pnp_bios_write_escd(char *data, u32 nvram_base)
|
|||
u16 status;
|
||||
if (!pnp_bios_present())
|
||||
return ESCD_FUNCTION_NOT_SUPPORTED;
|
||||
status = call_pnp_bios(PNP_WRITE_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0,
|
||||
status =
|
||||
call_pnp_bios(PNP_WRITE_ESCD, 0, PNP_TS1, PNP_TS2, PNP_DS, 0, 0, 0,
|
||||
data, 65536, __va(nvram_base), 65536);
|
||||
return status;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* Initialization
|
||||
*/
|
||||
|
@ -529,7 +557,9 @@ void pnpbios_calls_init(union pnp_bios_install_struct *header)
|
|||
if (!gdt)
|
||||
continue;
|
||||
set_base(gdt[GDT_ENTRY_PNPBIOS_CS32], &pnp_bios_callfunc);
|
||||
set_base(gdt[GDT_ENTRY_PNPBIOS_CS16], __va(header->fields.pm16cseg));
|
||||
set_base(gdt[GDT_ENTRY_PNPBIOS_DS], __va(header->fields.pm16dseg));
|
||||
set_base(gdt[GDT_ENTRY_PNPBIOS_CS16],
|
||||
__va(header->fields.pm16cseg));
|
||||
set_base(gdt[GDT_ENTRY_PNPBIOS_DS],
|
||||
__va(header->fields.pm16dseg));
|
||||
}
|
||||
}
|
||||
|
|
|
@ -71,7 +71,6 @@
|
|||
|
||||
#include "pnpbios.h"
|
||||
|
||||
|
||||
/*
|
||||
*
|
||||
* PnP BIOS INTERFACE
|
||||
|
@ -161,8 +160,7 @@ static int pnp_dock_thread(void * unused)
|
|||
static struct pnp_docking_station_info now;
|
||||
int docked = -1, d = 0;
|
||||
set_freezable();
|
||||
while (!unloading)
|
||||
{
|
||||
while (!unloading) {
|
||||
int status;
|
||||
|
||||
/*
|
||||
|
@ -175,8 +173,7 @@ static int pnp_dock_thread(void * unused)
|
|||
|
||||
status = pnp_bios_dock_station_info(&now);
|
||||
|
||||
switch(status)
|
||||
{
|
||||
switch (status) {
|
||||
/*
|
||||
* No dock to manage
|
||||
*/
|
||||
|
@ -192,13 +189,13 @@ static int pnp_dock_thread(void * unused)
|
|||
pnpbios_print_status("pnp_dock_thread", status);
|
||||
continue;
|
||||
}
|
||||
if(d != docked)
|
||||
{
|
||||
if(pnp_dock_event(d, &now)==0)
|
||||
{
|
||||
if (d != docked) {
|
||||
if (pnp_dock_event(d, &now) == 0) {
|
||||
docked = d;
|
||||
#if 0
|
||||
printk(KERN_INFO "PnPBIOS: Docking station %stached\n", docked?"at":"de");
|
||||
printk(KERN_INFO
|
||||
"PnPBIOS: Docking station %stached\n",
|
||||
docked ? "at" : "de");
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
@ -208,7 +205,8 @@ static int pnp_dock_thread(void * unused)
|
|||
|
||||
#endif /* CONFIG_HOTPLUG */
|
||||
|
||||
static int pnpbios_get_resources(struct pnp_dev * dev, struct pnp_resource_table * res)
|
||||
static int pnpbios_get_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
u8 nodenum = dev->number;
|
||||
struct pnp_bios_node *node;
|
||||
|
@ -230,7 +228,8 @@ static int pnpbios_get_resources(struct pnp_dev * dev, struct pnp_resource_table
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table * res)
|
||||
static int pnpbios_set_resources(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res)
|
||||
{
|
||||
u8 nodenum = dev->number;
|
||||
struct pnp_bios_node *node;
|
||||
|
@ -278,7 +277,8 @@ static void pnpbios_zero_data_stream(struct pnp_bios_node * node)
|
|||
p[i] = 0;
|
||||
p += len;
|
||||
}
|
||||
printk(KERN_ERR "PnPBIOS: Resource structure did not contain an end tag.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Resource structure did not contain an end tag.\n");
|
||||
}
|
||||
|
||||
static int pnpbios_disable_resources(struct pnp_dev *dev)
|
||||
|
@ -381,10 +381,12 @@ static void __init build_devlist(void)
|
|||
* dynamic will help us catch buggy bioses to add to the blacklist.
|
||||
*/
|
||||
if (!pnpbios_dont_use_current_config) {
|
||||
if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node))
|
||||
if (pnp_bios_get_dev_node
|
||||
(&nodenum, (char)PNPMODE_DYNAMIC, node))
|
||||
break;
|
||||
} else {
|
||||
if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_STATIC, node))
|
||||
if (pnp_bios_get_dev_node
|
||||
(&nodenum, (char)PNPMODE_STATIC, node))
|
||||
break;
|
||||
}
|
||||
nodes_got++;
|
||||
|
@ -396,13 +398,17 @@ static void __init build_devlist(void)
|
|||
else
|
||||
devs++;
|
||||
if (nodenum <= thisnodenum) {
|
||||
printk(KERN_ERR "PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", (unsigned int)nodenum, (unsigned int)thisnodenum);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: build_devlist: Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
|
||||
(unsigned int)nodenum,
|
||||
(unsigned int)thisnodenum);
|
||||
break;
|
||||
}
|
||||
}
|
||||
kfree(node);
|
||||
|
||||
printk(KERN_INFO "PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n",
|
||||
printk(KERN_INFO
|
||||
"PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n",
|
||||
nodes_got, nodes_got != 1 ? "s" : "", devs);
|
||||
}
|
||||
|
||||
|
@ -462,25 +468,31 @@ static int __init pnpbios_probe_system(void)
|
|||
check = (void *)check + 16) {
|
||||
if (check->fields.signature != PNP_SIGNATURE)
|
||||
continue;
|
||||
printk(KERN_INFO "PnPBIOS: Found PnP BIOS installation structure at 0x%p\n", check);
|
||||
printk(KERN_INFO
|
||||
"PnPBIOS: Found PnP BIOS installation structure at 0x%p\n",
|
||||
check);
|
||||
length = check->fields.length;
|
||||
if (!length) {
|
||||
printk(KERN_ERR "PnPBIOS: installation structure is invalid, skipping\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: installation structure is invalid, skipping\n");
|
||||
continue;
|
||||
}
|
||||
for (sum = 0, i = 0; i < length; i++)
|
||||
sum += check->chars[i];
|
||||
if (sum) {
|
||||
printk(KERN_ERR "PnPBIOS: installation structure is corrupted, skipping\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: installation structure is corrupted, skipping\n");
|
||||
continue;
|
||||
}
|
||||
if (check->fields.version < 0x10) {
|
||||
printk(KERN_WARNING "PnPBIOS: PnP BIOS version %d.%d is not supported\n",
|
||||
printk(KERN_WARNING
|
||||
"PnPBIOS: PnP BIOS version %d.%d is not supported\n",
|
||||
check->fields.version >> 4,
|
||||
check->fields.version & 15);
|
||||
continue;
|
||||
}
|
||||
printk(KERN_INFO "PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n",
|
||||
printk(KERN_INFO
|
||||
"PnPBIOS: PnP BIOS version %d.%d, entry 0x%x:0x%x, dseg 0x%x\n",
|
||||
check->fields.version >> 4, check->fields.version & 15,
|
||||
check->fields.pm16cseg, check->fields.pm16offset,
|
||||
check->fields.pm16dseg);
|
||||
|
@ -533,7 +545,6 @@ static int __init pnpbios_init(void)
|
|||
printk(KERN_INFO "PnPBIOS: Disabled\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_PNPACPI
|
||||
if (!acpi_disabled && !pnpacpi_disabled) {
|
||||
pnpbios_disabled = 1;
|
||||
|
@ -552,14 +563,16 @@ static int __init pnpbios_init(void)
|
|||
/* read the node info */
|
||||
ret = pnp_bios_dev_node_info(&node_info);
|
||||
if (ret) {
|
||||
printk(KERN_ERR "PnPBIOS: Unable to get node info. Aborting.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unable to get node info. Aborting.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* register with the pnp layer */
|
||||
ret = pnp_register_protocol(&pnpbios_protocol);
|
||||
if (ret) {
|
||||
printk(KERN_ERR "PnPBIOS: Unable to register driver. Aborting.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unable to register driver. Aborting.\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -47,10 +47,7 @@ static int proc_read_pnpconfig(char *buf, char **start, off_t pos,
|
|||
"structure_revision %d\n"
|
||||
"number_of_CSNs %d\n"
|
||||
"ISA_read_data_port 0x%x\n",
|
||||
pnps.revision,
|
||||
pnps.no_csns,
|
||||
pnps.isa_rd_data_port
|
||||
);
|
||||
pnps.revision, pnps.no_csns, pnps.isa_rd_data_port);
|
||||
}
|
||||
|
||||
static int proc_read_escdinfo(char *buf, char **start, off_t pos,
|
||||
|
@ -65,9 +62,7 @@ static int proc_read_escdinfo(char *buf, char **start, off_t pos,
|
|||
"ESCD_size %d\n"
|
||||
"NVRAM_base 0x%x\n",
|
||||
escd.min_escd_write_size,
|
||||
escd.escd_size,
|
||||
escd.nv_storage_base
|
||||
);
|
||||
escd.escd_size, escd.nv_storage_base);
|
||||
}
|
||||
|
||||
#define MAX_SANE_ESCD_SIZE (32*1024)
|
||||
|
@ -83,29 +78,35 @@ static int proc_read_escd(char *buf, char **start, off_t pos,
|
|||
|
||||
/* sanity check */
|
||||
if (escd.escd_size > MAX_SANE_ESCD_SIZE) {
|
||||
printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: proc_read_escd: ESCD size reported by BIOS escd_info call is too great\n");
|
||||
return -EFBIG;
|
||||
}
|
||||
|
||||
tmpbuf = kzalloc(escd.escd_size, GFP_KERNEL);
|
||||
if (!tmpbuf) return -ENOMEM;
|
||||
if (!tmpbuf)
|
||||
return -ENOMEM;
|
||||
|
||||
if (pnp_bios_read_escd(tmpbuf, escd.nv_storage_base)) {
|
||||
kfree(tmpbuf);
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
escd_size = (unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1])*256;
|
||||
escd_size =
|
||||
(unsigned char)(tmpbuf[0]) + (unsigned char)(tmpbuf[1]) * 256;
|
||||
|
||||
/* sanity check */
|
||||
if (escd_size > MAX_SANE_ESCD_SIZE) {
|
||||
printk(KERN_ERR "PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: proc_read_escd: ESCD size reported by BIOS read_escd call is too great\n");
|
||||
return -EFBIG;
|
||||
}
|
||||
|
||||
escd_left_to_read = escd_size - pos;
|
||||
if (escd_left_to_read < 0) escd_left_to_read = 0;
|
||||
if (escd_left_to_read == 0) *eof = 1;
|
||||
if (escd_left_to_read < 0)
|
||||
escd_left_to_read = 0;
|
||||
if (escd_left_to_read == 0)
|
||||
*eof = 1;
|
||||
n = min(count, escd_left_to_read);
|
||||
memcpy(buf, tmpbuf + pos, n);
|
||||
kfree(tmpbuf);
|
||||
|
@ -134,7 +135,8 @@ static int proc_read_devices(char *buf, char **start, off_t pos,
|
|||
return 0;
|
||||
|
||||
node = kzalloc(node_info.max_node_size, GFP_KERNEL);
|
||||
if (!node) return -ENOMEM;
|
||||
if (!node)
|
||||
return -ENOMEM;
|
||||
|
||||
for (nodenum = pos; nodenum < 0xff;) {
|
||||
u8 thisnodenum = nodenum;
|
||||
|
@ -148,7 +150,11 @@ static int proc_read_devices(char *buf, char **start, off_t pos,
|
|||
node->type_code[0], node->type_code[1],
|
||||
node->type_code[2], node->flags);
|
||||
if (nodenum <= thisnodenum) {
|
||||
printk(KERN_ERR "%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n", "PnPBIOS: proc_read_devices:", (unsigned int)nodenum, (unsigned int)thisnodenum);
|
||||
printk(KERN_ERR
|
||||
"%s Node number 0x%x is out of sequence following node 0x%x. Aborting.\n",
|
||||
"PnPBIOS: proc_read_devices:",
|
||||
(unsigned int)nodenum,
|
||||
(unsigned int)thisnodenum);
|
||||
*eof = 1;
|
||||
break;
|
||||
}
|
||||
|
@ -169,7 +175,8 @@ static int proc_read_node(char *buf, char **start, off_t pos,
|
|||
int len;
|
||||
|
||||
node = kzalloc(node_info.max_node_size, GFP_KERNEL);
|
||||
if (!node) return -ENOMEM;
|
||||
if (!node)
|
||||
return -ENOMEM;
|
||||
if (pnp_bios_get_dev_node(&nodenum, boot, node)) {
|
||||
kfree(node);
|
||||
return -EIO;
|
||||
|
@ -258,10 +265,13 @@ int __init pnpbios_proc_init( void )
|
|||
if (!proc_pnp_boot)
|
||||
return -EIO;
|
||||
create_proc_read_entry("devices", 0, proc_pnp, proc_read_devices, NULL);
|
||||
create_proc_read_entry("configuration_info", 0, proc_pnp, proc_read_pnpconfig, NULL);
|
||||
create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo, NULL);
|
||||
create_proc_read_entry("configuration_info", 0, proc_pnp,
|
||||
proc_read_pnpconfig, NULL);
|
||||
create_proc_read_entry("escd_info", 0, proc_pnp, proc_read_escdinfo,
|
||||
NULL);
|
||||
create_proc_read_entry("escd", S_IRUSR, proc_pnp, proc_read_escd, NULL);
|
||||
create_proc_read_entry("legacy_device_resources", 0, proc_pnp, proc_read_legacyres, NULL);
|
||||
create_proc_read_entry("legacy_device_resources", 0, proc_pnp,
|
||||
proc_read_legacyres, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -12,7 +12,9 @@
|
|||
#ifdef CONFIG_PCI
|
||||
#include <linux/pci.h>
|
||||
#else
|
||||
inline void pcibios_penalize_isa_irq(int irq, int active) {}
|
||||
inline void pcibios_penalize_isa_irq(int irq, int active)
|
||||
{
|
||||
}
|
||||
#endif /* CONFIG_PCI */
|
||||
|
||||
#include "pnpbios.h"
|
||||
|
@ -56,7 +58,9 @@ static void
|
|||
pnpbios_parse_allocated_irqresource(struct pnp_resource_table *res, int irq)
|
||||
{
|
||||
int i = 0;
|
||||
while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_IRQ) i++;
|
||||
while (!(res->irq_resource[i].flags & IORESOURCE_UNSET)
|
||||
&& i < PNP_MAX_IRQ)
|
||||
i++;
|
||||
if (i < PNP_MAX_IRQ) {
|
||||
res->irq_resource[i].flags = IORESOURCE_IRQ; // Also clears _UNSET flag
|
||||
if (irq == -1) {
|
||||
|
@ -88,10 +92,13 @@ pnpbios_parse_allocated_dmaresource(struct pnp_resource_table * res, int dma)
|
|||
}
|
||||
|
||||
static void
|
||||
pnpbios_parse_allocated_ioresource(struct pnp_resource_table * res, int io, int len)
|
||||
pnpbios_parse_allocated_ioresource(struct pnp_resource_table *res, int io,
|
||||
int len)
|
||||
{
|
||||
int i = 0;
|
||||
while (!(res->port_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_PORT) i++;
|
||||
while (!(res->port_resource[i].flags & IORESOURCE_UNSET)
|
||||
&& i < PNP_MAX_PORT)
|
||||
i++;
|
||||
if (i < PNP_MAX_PORT) {
|
||||
res->port_resource[i].flags = IORESOURCE_IO; // Also clears _UNSET flag
|
||||
if (len <= 0 || (io + len - 1) >= 0x10003) {
|
||||
|
@ -104,10 +111,13 @@ pnpbios_parse_allocated_ioresource(struct pnp_resource_table * res, int io, int
|
|||
}
|
||||
|
||||
static void
|
||||
pnpbios_parse_allocated_memresource(struct pnp_resource_table * res, int mem, int len)
|
||||
pnpbios_parse_allocated_memresource(struct pnp_resource_table *res, int mem,
|
||||
int len)
|
||||
{
|
||||
int i = 0;
|
||||
while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) && i < PNP_MAX_MEM) i++;
|
||||
while (!(res->mem_resource[i].flags & IORESOURCE_UNSET)
|
||||
&& i < PNP_MAX_MEM)
|
||||
i++;
|
||||
if (i < PNP_MAX_MEM) {
|
||||
res->mem_resource[i].flags = IORESOURCE_MEM; // Also clears _UNSET flag
|
||||
if (len <= 0) {
|
||||
|
@ -119,8 +129,11 @@ pnpbios_parse_allocated_memresource(struct pnp_resource_table * res, int mem, in
|
|||
}
|
||||
}
|
||||
|
||||
static unsigned char *
|
||||
pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res)
|
||||
static unsigned char *pnpbios_parse_allocated_resource_data(unsigned char *p,
|
||||
unsigned char *end,
|
||||
struct
|
||||
pnp_resource_table
|
||||
*res)
|
||||
{
|
||||
unsigned int len, tag;
|
||||
int io, size, mask, i;
|
||||
|
@ -182,7 +195,8 @@ pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, st
|
|||
io = -1;
|
||||
mask = p[1] + p[2] * 256;
|
||||
for (i = 0; i < 16; i++, mask = mask >> 1)
|
||||
if(mask & 0x01) io=i;
|
||||
if (mask & 0x01)
|
||||
io = i;
|
||||
pnpbios_parse_allocated_irqresource(res, io);
|
||||
break;
|
||||
|
||||
|
@ -192,7 +206,8 @@ pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, st
|
|||
io = -1;
|
||||
mask = p[1];
|
||||
for (i = 0; i < 8; i++, mask = mask >> 1)
|
||||
if(mask & 0x01) io=i;
|
||||
if (mask & 0x01)
|
||||
io = i;
|
||||
pnpbios_parse_allocated_dmaresource(res, io);
|
||||
break;
|
||||
|
||||
|
@ -223,7 +238,9 @@ pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, st
|
|||
|
||||
default: /* an unkown tag */
|
||||
len_err:
|
||||
printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
|
||||
tag, len);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -234,12 +251,12 @@ pnpbios_parse_allocated_resource_data(unsigned char * p, unsigned char * end, st
|
|||
p += len + 1;
|
||||
}
|
||||
|
||||
printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Resource Configuration Options
|
||||
*/
|
||||
|
@ -261,7 +278,8 @@ pnpbios_parse_mem_option(unsigned char *p, int size, struct pnp_option *option)
|
|||
}
|
||||
|
||||
static void
|
||||
pnpbios_parse_mem32_option(unsigned char *p, int size, struct pnp_option *option)
|
||||
pnpbios_parse_mem32_option(unsigned char *p, int size,
|
||||
struct pnp_option *option)
|
||||
{
|
||||
struct pnp_mem *mem;
|
||||
mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
|
||||
|
@ -277,7 +295,8 @@ pnpbios_parse_mem32_option(unsigned char *p, int size, struct pnp_option *option
|
|||
}
|
||||
|
||||
static void
|
||||
pnpbios_parse_fixed_mem32_option(unsigned char *p, int size, struct pnp_option *option)
|
||||
pnpbios_parse_fixed_mem32_option(unsigned char *p, int size,
|
||||
struct pnp_option *option)
|
||||
{
|
||||
struct pnp_mem *mem;
|
||||
mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
|
||||
|
@ -340,7 +359,8 @@ pnpbios_parse_port_option(unsigned char *p, int size, struct pnp_option *option)
|
|||
}
|
||||
|
||||
static void
|
||||
pnpbios_parse_fixed_port_option(unsigned char *p, int size, struct pnp_option *option)
|
||||
pnpbios_parse_fixed_port_option(unsigned char *p, int size,
|
||||
struct pnp_option *option)
|
||||
{
|
||||
struct pnp_port *port;
|
||||
port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
|
||||
|
@ -354,8 +374,9 @@ pnpbios_parse_fixed_port_option(unsigned char *p, int size, struct pnp_option *o
|
|||
return;
|
||||
}
|
||||
|
||||
static unsigned char *
|
||||
pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struct pnp_dev *dev)
|
||||
static unsigned char *pnpbios_parse_resource_option_data(unsigned char *p,
|
||||
unsigned char *end,
|
||||
struct pnp_dev *dev)
|
||||
{
|
||||
unsigned int len, tag;
|
||||
int priority = 0;
|
||||
|
@ -442,7 +463,8 @@ pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struc
|
|||
if (len != 0)
|
||||
goto len_err;
|
||||
if (option_independent == option)
|
||||
printk(KERN_WARNING "PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n");
|
||||
printk(KERN_WARNING
|
||||
"PnPBIOS: Missing SMALL_TAG_STARTDEP tag\n");
|
||||
option = option_independent;
|
||||
break;
|
||||
|
||||
|
@ -451,7 +473,9 @@ pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struc
|
|||
|
||||
default: /* an unkown tag */
|
||||
len_err:
|
||||
printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
|
||||
tag, len);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -462,12 +486,12 @@ pnpbios_parse_resource_option_data(unsigned char * p, unsigned char * end, struc
|
|||
p += len + 1;
|
||||
}
|
||||
|
||||
printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Compatible Device IDs
|
||||
*/
|
||||
|
@ -492,12 +516,14 @@ void pnpid32_to_pnpid(u32 id, char *str)
|
|||
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
#undef CHAR
|
||||
#undef HEX
|
||||
|
||||
static unsigned char *
|
||||
pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_dev *dev)
|
||||
static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p,
|
||||
unsigned char *end,
|
||||
struct pnp_dev *dev)
|
||||
{
|
||||
int len, tag;
|
||||
char id[8];
|
||||
|
@ -520,8 +546,10 @@ pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_de
|
|||
switch (tag) {
|
||||
|
||||
case LARGE_TAG_ANSISTR:
|
||||
strncpy(dev->name, p + 3, len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len);
|
||||
dev->name[len >= PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0';
|
||||
strncpy(dev->name, p + 3,
|
||||
len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len);
|
||||
dev->name[len >=
|
||||
PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0';
|
||||
break;
|
||||
|
||||
case SMALL_TAG_COMPATDEVID: /* compatible ID */
|
||||
|
@ -530,7 +558,8 @@ pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_de
|
|||
dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
|
||||
if (!dev_id)
|
||||
return NULL;
|
||||
pnpid32_to_pnpid(p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24,id);
|
||||
pnpid32_to_pnpid(p[1] | p[2] << 8 | p[3] << 16 | p[4] <<
|
||||
24, id);
|
||||
memcpy(&dev_id->id, id, 7);
|
||||
pnp_add_id(dev_id, dev);
|
||||
break;
|
||||
|
@ -542,7 +571,9 @@ pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_de
|
|||
|
||||
default: /* an unkown tag */
|
||||
len_err:
|
||||
printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
|
||||
tag, len);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -553,12 +584,12 @@ pnpbios_parse_compatible_ids(unsigned char *p, unsigned char *end, struct pnp_de
|
|||
p += len + 1;
|
||||
}
|
||||
|
||||
printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Allocated Resource Encoding
|
||||
*/
|
||||
|
@ -596,7 +627,8 @@ static void pnpbios_encode_mem32(unsigned char *p, struct resource * res)
|
|||
}
|
||||
|
||||
static void pnpbios_encode_fixed_mem32(unsigned char *p, struct resource *res)
|
||||
{ unsigned long base = res->start;
|
||||
{
|
||||
unsigned long base = res->start;
|
||||
unsigned long len = res->end - res->start + 1;
|
||||
p[4] = base & 0xff;
|
||||
p[5] = (base >> 8) & 0xff;
|
||||
|
@ -648,8 +680,11 @@ static void pnpbios_encode_fixed_port(unsigned char *p, struct resource * res)
|
|||
return;
|
||||
}
|
||||
|
||||
static unsigned char *
|
||||
pnpbios_encode_allocated_resource_data(unsigned char * p, unsigned char * end, struct pnp_resource_table * res)
|
||||
static unsigned char *pnpbios_encode_allocated_resource_data(unsigned char *p,
|
||||
unsigned char *end,
|
||||
struct
|
||||
pnp_resource_table
|
||||
*res)
|
||||
{
|
||||
unsigned int len, tag;
|
||||
int port = 0, irq = 0, dma = 0, mem = 0;
|
||||
|
@ -730,7 +765,9 @@ pnpbios_encode_allocated_resource_data(unsigned char * p, unsigned char * end, s
|
|||
|
||||
default: /* an unkown tag */
|
||||
len_err:
|
||||
printk(KERN_ERR "PnPBIOS: Unknown tag '0x%x', length '%d'.\n", tag, len);
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Unknown tag '0x%x', length '%d'.\n",
|
||||
tag, len);
|
||||
break;
|
||||
}
|
||||
|
||||
|
@ -741,18 +778,17 @@ pnpbios_encode_allocated_resource_data(unsigned char * p, unsigned char * end, s
|
|||
p += len + 1;
|
||||
}
|
||||
|
||||
printk(KERN_ERR "PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
printk(KERN_ERR
|
||||
"PnPBIOS: Resource structure does not contain an end tag.\n");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Core Parsing Functions
|
||||
*/
|
||||
|
||||
int
|
||||
pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node * node)
|
||||
int pnpbios_parse_data_stream(struct pnp_dev *dev, struct pnp_bios_node *node)
|
||||
{
|
||||
unsigned char *p = (char *)node->data;
|
||||
unsigned char *end = (char *)(node->data + node->size);
|
||||
|
|
|
@ -19,7 +19,6 @@
|
|||
#include <linux/io.h>
|
||||
#include "base.h"
|
||||
|
||||
|
||||
static void quirk_awe32_resources(struct pnp_dev *dev)
|
||||
{
|
||||
struct pnp_port *port, *port2, *port3;
|
||||
|
@ -69,7 +68,8 @@ static void quirk_cmi8330_resources(struct pnp_dev *dev)
|
|||
}
|
||||
|
||||
for (dma = res->dma; dma; dma = dma->next) // Valid 8bit dma channels are 1,3
|
||||
if( ( dma->flags & IORESOURCE_DMA_TYPE_MASK ) == IORESOURCE_DMA_8BIT )
|
||||
if ((dma->flags & IORESOURCE_DMA_TYPE_MASK) ==
|
||||
IORESOURCE_DMA_8BIT)
|
||||
dma->map = 0x000A;
|
||||
}
|
||||
printk(KERN_INFO "pnp: CMI8330 quirk - fixing interrupts and dma\n");
|
||||
|
@ -103,7 +103,8 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev)
|
|||
changed = 1;
|
||||
}
|
||||
if (changed)
|
||||
printk(KERN_INFO "pnp: SB audio device quirk - increasing port range\n");
|
||||
printk(KERN_INFO
|
||||
"pnp: SB audio device quirk - increasing port range\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -209,7 +210,6 @@ static void quirk_smc_enable(struct pnp_dev *dev)
|
|||
"email bjorn.helgaas@hp.com\n");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* PnP Quirks
|
||||
* Cards or devices that need some tweaking due to incomplete resource info
|
||||
|
@ -240,8 +240,7 @@ void pnp_fixup_device(struct pnp_dev *dev)
|
|||
|
||||
while (*pnp_fixups[i].id) {
|
||||
if (compare_pnp_id(dev->id, pnp_fixups[i].id)) {
|
||||
pnp_dbg("Calling quirk for %s",
|
||||
dev->dev.bus_id);
|
||||
pnp_dbg("Calling quirk for %s", dev->dev.bus_id);
|
||||
pnp_fixups[i].quirk_function(dev);
|
||||
}
|
||||
i++;
|
||||
|
|
|
@ -25,7 +25,6 @@ static int pnp_reserve_dma[8] = { [0 ... 7] = -1 }; /* reserve (don't use) some
|
|||
static int pnp_reserve_io[16] = {[0...15] = -1 }; /* reserve (don't use) some I/O region */
|
||||
static int pnp_reserve_mem[16] = {[0...15] = -1 }; /* reserve (don't use) some memory region */
|
||||
|
||||
|
||||
/*
|
||||
* option registration
|
||||
*/
|
||||
|
@ -61,7 +60,8 @@ struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev)
|
|||
return option;
|
||||
}
|
||||
|
||||
struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority)
|
||||
struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev,
|
||||
int priority)
|
||||
{
|
||||
struct pnp_option *option;
|
||||
if (!dev)
|
||||
|
@ -222,7 +222,6 @@ void pnp_free_option(struct pnp_option *option)
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* resource validity checking
|
||||
*/
|
||||
|
@ -279,7 +278,8 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
|
|||
continue;
|
||||
for (tmp = 0; tmp < PNP_MAX_PORT; tmp++) {
|
||||
if (tdev->res.port_resource[tmp].flags & IORESOURCE_IO) {
|
||||
if (cannot_compare(tdev->res.port_resource[tmp].flags))
|
||||
if (cannot_compare
|
||||
(tdev->res.port_resource[tmp].flags))
|
||||
continue;
|
||||
tport = &tdev->res.port_resource[tmp].start;
|
||||
tend = &tdev->res.port_resource[tmp].end;
|
||||
|
@ -335,7 +335,8 @@ int pnp_check_mem(struct pnp_dev * dev, int idx)
|
|||
continue;
|
||||
for (tmp = 0; tmp < PNP_MAX_MEM; tmp++) {
|
||||
if (tdev->res.mem_resource[tmp].flags & IORESOURCE_MEM) {
|
||||
if (cannot_compare(tdev->res.mem_resource[tmp].flags))
|
||||
if (cannot_compare
|
||||
(tdev->res.mem_resource[tmp].flags))
|
||||
continue;
|
||||
taddr = &tdev->res.mem_resource[tmp].start;
|
||||
tend = &tdev->res.mem_resource[tmp].end;
|
||||
|
@ -407,7 +408,8 @@ int pnp_check_irq(struct pnp_dev * dev, int idx)
|
|||
continue;
|
||||
for (tmp = 0; tmp < PNP_MAX_IRQ; tmp++) {
|
||||
if (tdev->res.irq_resource[tmp].flags & IORESOURCE_IRQ) {
|
||||
if (cannot_compare(tdev->res.irq_resource[tmp].flags))
|
||||
if (cannot_compare
|
||||
(tdev->res.irq_resource[tmp].flags))
|
||||
continue;
|
||||
if ((tdev->res.irq_resource[tmp].start == *irq))
|
||||
return 0;
|
||||
|
@ -461,7 +463,8 @@ int pnp_check_dma(struct pnp_dev * dev, int idx)
|
|||
continue;
|
||||
for (tmp = 0; tmp < PNP_MAX_DMA; tmp++) {
|
||||
if (tdev->res.dma_resource[tmp].flags & IORESOURCE_DMA) {
|
||||
if (cannot_compare(tdev->res.dma_resource[tmp].flags))
|
||||
if (cannot_compare
|
||||
(tdev->res.dma_resource[tmp].flags))
|
||||
continue;
|
||||
if ((tdev->res.dma_resource[tmp].start == *dma))
|
||||
return 0;
|
||||
|
@ -476,7 +479,6 @@ int pnp_check_dma(struct pnp_dev * dev, int idx)
|
|||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
EXPORT_SYMBOL(pnp_register_dependent_option);
|
||||
EXPORT_SYMBOL(pnp_register_independent_option);
|
||||
|
@ -486,7 +488,6 @@ EXPORT_SYMBOL(pnp_register_port_resource);
|
|||
EXPORT_SYMBOL(pnp_register_mem_resource);
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
/* format is: pnp_reserve_irq=irq1[,irq2] .... */
|
||||
|
||||
static int __init pnp_setup_reserve_irq(char *str)
|
||||
|
|
|
@ -20,13 +20,10 @@ int pnp_is_active(struct pnp_dev * dev)
|
|||
{
|
||||
if (!pnp_port_start(dev, 0) && pnp_port_len(dev, 0) <= 1 &&
|
||||
!pnp_mem_start(dev, 0) && pnp_mem_len(dev, 0) <= 1 &&
|
||||
pnp_irq(dev, 0) == -1 &&
|
||||
pnp_dma(dev, 0) == -1)
|
||||
pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EXPORT_SYMBOL(pnp_is_active);
|
||||
|
|
|
@ -22,7 +22,8 @@ static const struct pnp_device_id pnp_dev_table[] = {
|
|||
{"", 0}
|
||||
};
|
||||
|
||||
static void reserve_range(const char *pnpid, resource_size_t start, resource_size_t end, int port)
|
||||
static void reserve_range(const char *pnpid, resource_size_t start,
|
||||
resource_size_t end, int port)
|
||||
{
|
||||
struct resource *res;
|
||||
char *regionid;
|
||||
|
@ -88,7 +89,8 @@ static void reserve_resources_of_dev(const struct pnp_dev *dev)
|
|||
return;
|
||||
}
|
||||
|
||||
static int system_pnp_probe(struct pnp_dev * dev, const struct pnp_device_id *dev_id)
|
||||
static int system_pnp_probe(struct pnp_dev *dev,
|
||||
const struct pnp_device_id *dev_id)
|
||||
{
|
||||
reserve_resources_of_dev(dev);
|
||||
return 0;
|
||||
|
|
|
@ -23,7 +23,6 @@
|
|||
struct pnp_protocol;
|
||||
struct pnp_dev;
|
||||
|
||||
|
||||
/*
|
||||
* Resource Management
|
||||
*/
|
||||
|
@ -127,7 +126,6 @@ struct pnp_resource_table {
|
|||
struct resource irq_resource[PNP_MAX_IRQ];
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Device Managemnt
|
||||
*/
|
||||
|
@ -269,7 +267,6 @@ extern struct pnp_protocol pnpbios_protocol;
|
|||
#define pnp_device_is_pnpbios(dev) 0
|
||||
#endif
|
||||
|
||||
|
||||
/* status */
|
||||
#define PNP_READY 0x0000
|
||||
#define PNP_ATTACHED 0x0001
|
||||
|
@ -294,7 +291,8 @@ struct pnp_driver {
|
|||
char *name;
|
||||
const struct pnp_device_id *id_table;
|
||||
unsigned int flags;
|
||||
int (*probe) (struct pnp_dev *dev, const struct pnp_device_id *dev_id);
|
||||
int (*probe) (struct pnp_dev * dev,
|
||||
const struct pnp_device_id * dev_id);
|
||||
void (*remove) (struct pnp_dev * dev);
|
||||
int (*suspend) (struct pnp_dev * dev, pm_message_t state);
|
||||
int (*resume) (struct pnp_dev * dev);
|
||||
|
@ -308,7 +306,8 @@ struct pnp_card_driver {
|
|||
char *name;
|
||||
const struct pnp_card_device_id *id_table;
|
||||
unsigned int flags;
|
||||
int (*probe) (struct pnp_card_link *card, const struct pnp_card_device_id *card_id);
|
||||
int (*probe) (struct pnp_card_link * card,
|
||||
const struct pnp_card_device_id * card_id);
|
||||
void (*remove) (struct pnp_card_link * card);
|
||||
int (*suspend) (struct pnp_card_link * card, pm_message_t state);
|
||||
int (*resume) (struct pnp_card_link * card);
|
||||
|
@ -321,7 +320,6 @@ struct pnp_card_driver {
|
|||
#define PNP_DRIVER_RES_DO_NOT_CHANGE 0x0001 /* do not change the state of the device */
|
||||
#define PNP_DRIVER_RES_DISABLE 0x0003 /* ensure the device is disabled */
|
||||
|
||||
|
||||
/*
|
||||
* Protocol Management
|
||||
*/
|
||||
|
@ -356,7 +354,6 @@ struct pnp_protocol {
|
|||
(dev) != protocol_to_pnp_dev(&(protocol)->devices); \
|
||||
(dev) = protocol_to_pnp_dev((dev)->protocol_list.next))
|
||||
|
||||
|
||||
extern struct bus_type pnp_bus_type;
|
||||
|
||||
#if defined(CONFIG_PNP)
|
||||
|
@ -376,7 +373,8 @@ void pnp_remove_card(struct pnp_card *card);
|
|||
int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev);
|
||||
void pnp_remove_card_device(struct pnp_dev *dev);
|
||||
int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card);
|
||||
struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from);
|
||||
struct pnp_dev *pnp_request_card_device(struct pnp_card_link *clink,
|
||||
const char *id, struct pnp_dev *from);
|
||||
void pnp_release_card_device(struct pnp_dev *dev);
|
||||
int pnp_register_card_driver(struct pnp_card_driver *drv);
|
||||
void pnp_unregister_card_driver(struct pnp_card_driver *drv);
|
||||
|
@ -384,13 +382,16 @@ extern struct list_head pnp_cards;
|
|||
|
||||
/* resource management */
|
||||
struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev);
|
||||
struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority);
|
||||
struct pnp_option *pnp_register_dependent_option(struct pnp_dev *dev,
|
||||
int priority);
|
||||
int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data);
|
||||
int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data);
|
||||
int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data);
|
||||
int pnp_register_port_resource(struct pnp_option *option,
|
||||
struct pnp_port *data);
|
||||
int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data);
|
||||
void pnp_init_resource_table(struct pnp_resource_table *table);
|
||||
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode);
|
||||
int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res,
|
||||
int mode);
|
||||
int pnp_auto_config_dev(struct pnp_dev *dev);
|
||||
int pnp_validate_config(struct pnp_dev *dev);
|
||||
int pnp_start_dev(struct pnp_dev *dev);
|
||||
|
@ -410,54 +411,162 @@ void pnp_unregister_driver(struct pnp_driver *drv);
|
|||
#else
|
||||
|
||||
/* device management */
|
||||
static inline int pnp_register_protocol(struct pnp_protocol *protocol) { return -ENODEV; }
|
||||
static inline void pnp_unregister_protocol(struct pnp_protocol *protocol) { }
|
||||
static inline int pnp_init_device(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_add_device(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_device_attach(struct pnp_dev *pnp_dev) { return -ENODEV; }
|
||||
static inline void pnp_device_detach(struct pnp_dev *pnp_dev) { ; }
|
||||
static inline int pnp_register_protocol(struct pnp_protocol *protocol)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_unregister_protocol(struct pnp_protocol *protocol)
|
||||
{
|
||||
}
|
||||
static inline int pnp_init_device(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_add_device(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_device_attach(struct pnp_dev *pnp_dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_device_detach(struct pnp_dev *pnp_dev)
|
||||
{;
|
||||
}
|
||||
|
||||
#define pnp_platform_devices 0
|
||||
|
||||
/* multidevice card support */
|
||||
static inline int pnp_add_card(struct pnp_card *card) { return -ENODEV; }
|
||||
static inline void pnp_remove_card(struct pnp_card *card) { ; }
|
||||
static inline int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline void pnp_remove_card_device(struct pnp_dev *dev) { ; }
|
||||
static inline int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card) { return -ENODEV; }
|
||||
static inline struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char * id, struct pnp_dev * from) { return NULL; }
|
||||
static inline void pnp_release_card_device(struct pnp_dev * dev) { ; }
|
||||
static inline int pnp_register_card_driver(struct pnp_card_driver * drv) { return -ENODEV; }
|
||||
static inline void pnp_unregister_card_driver(struct pnp_card_driver * drv) { ; }
|
||||
static inline int pnp_add_card(struct pnp_card *card)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_remove_card(struct pnp_card *card)
|
||||
{;
|
||||
}
|
||||
static inline int pnp_add_card_device(struct pnp_card *card,
|
||||
struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_remove_card_device(struct pnp_dev *dev)
|
||||
{;
|
||||
}
|
||||
static inline int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline struct pnp_dev *pnp_request_card_device(struct pnp_card_link
|
||||
*clink, const char *id,
|
||||
struct pnp_dev *from)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
static inline void pnp_release_card_device(struct pnp_dev *dev)
|
||||
{;
|
||||
}
|
||||
static inline int pnp_register_card_driver(struct pnp_card_driver *drv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_unregister_card_driver(struct pnp_card_driver *drv)
|
||||
{;
|
||||
}
|
||||
|
||||
/* resource management */
|
||||
static inline struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev) { return NULL; }
|
||||
static inline struct pnp_option * pnp_register_dependent_option(struct pnp_dev *dev, int priority) { return NULL; }
|
||||
static inline int pnp_register_irq_resource(struct pnp_option *option, struct pnp_irq *data) { return -ENODEV; }
|
||||
static inline int pnp_register_dma_resource(struct pnp_option *option, struct pnp_dma *data) { return -ENODEV; }
|
||||
static inline int pnp_register_port_resource(struct pnp_option *option, struct pnp_port *data) { return -ENODEV; }
|
||||
static inline int pnp_register_mem_resource(struct pnp_option *option, struct pnp_mem *data) { return -ENODEV; }
|
||||
static inline void pnp_init_resource_table(struct pnp_resource_table *table) { }
|
||||
static inline int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table *res, int mode) { return -ENODEV; }
|
||||
static inline int pnp_auto_config_dev(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_validate_config(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_start_dev(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_stop_dev(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_activate_dev(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_disable_dev(struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline struct pnp_option *pnp_register_independent_option(struct pnp_dev
|
||||
*dev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
static inline struct pnp_option *pnp_register_dependent_option(struct pnp_dev
|
||||
*dev,
|
||||
int priority)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
static inline int pnp_register_irq_resource(struct pnp_option *option,
|
||||
struct pnp_irq *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_register_dma_resource(struct pnp_option *option,
|
||||
struct pnp_dma *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_register_port_resource(struct pnp_option *option,
|
||||
struct pnp_port *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_register_mem_resource(struct pnp_option *option,
|
||||
struct pnp_mem *data)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_init_resource_table(struct pnp_resource_table *table)
|
||||
{
|
||||
}
|
||||
static inline int pnp_manual_config_dev(struct pnp_dev *dev,
|
||||
struct pnp_resource_table *res,
|
||||
int mode)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_auto_config_dev(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_validate_config(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_start_dev(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_stop_dev(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_activate_dev(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_disable_dev(struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_resource_change(struct resource *resource,
|
||||
resource_size_t start,
|
||||
resource_size_t size) { }
|
||||
resource_size_t size)
|
||||
{
|
||||
}
|
||||
|
||||
/* protocol helpers */
|
||||
static inline int pnp_is_active(struct pnp_dev * dev) { return 0; }
|
||||
static inline int compare_pnp_id(struct pnp_id * pos, const char * id) { return -ENODEV; }
|
||||
static inline int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev) { return -ENODEV; }
|
||||
static inline int pnp_register_driver(struct pnp_driver *drv) { return -ENODEV; }
|
||||
static inline void pnp_unregister_driver(struct pnp_driver *drv) { ; }
|
||||
static inline int pnp_is_active(struct pnp_dev *dev)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
static inline int compare_pnp_id(struct pnp_id *pos, const char *id)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_add_id(struct pnp_id *id, struct pnp_dev *dev)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline int pnp_register_driver(struct pnp_driver *drv)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
static inline void pnp_unregister_driver(struct pnp_driver *drv)
|
||||
{;
|
||||
}
|
||||
|
||||
#endif /* CONFIG_PNP */
|
||||
|
||||
|
||||
#define pnp_err(format, arg...) printk(KERN_ERR "pnp: " format "\n" , ## arg)
|
||||
#define pnp_info(format, arg...) printk(KERN_INFO "pnp: " format "\n" , ## arg)
|
||||
#define pnp_warn(format, arg...) printk(KERN_WARNING "pnp: " format "\n" , ## arg)
|
||||
|
|
|
@ -134,8 +134,10 @@ struct pnp_bios_node {
|
|||
extern struct pnp_dev_node_info node_info;
|
||||
|
||||
extern int pnp_bios_dev_node_info(struct pnp_dev_node_info *data);
|
||||
extern int pnp_bios_get_dev_node (u8 *nodenum, char config, struct pnp_bios_node *data);
|
||||
extern int pnp_bios_set_dev_node (u8 nodenum, char config, struct pnp_bios_node *data);
|
||||
extern int pnp_bios_get_dev_node(u8 * nodenum, char config,
|
||||
struct pnp_bios_node *data);
|
||||
extern int pnp_bios_set_dev_node(u8 nodenum, char config,
|
||||
struct pnp_bios_node *data);
|
||||
extern int pnp_bios_get_stat_res(char *info);
|
||||
extern int pnp_bios_isapnp_config(struct pnp_isa_config_struc *data);
|
||||
extern int pnp_bios_escd_info(struct escd_info_struc *data);
|
||||
|
|
Loading…
Reference in New Issue