apfs/linux-apfs
0
0
Fork 0
mirror of https://github.com/linux-apfs/linux-apfs.git synced 2026-05-01 15:00:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

PNP: Lindent all source files

Browse Source 
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:
Bjorn Helgaas
2007-07-26 10:41:20 -07:00
committed by Linus Torvalds
parent 8ec3cf7d29
commit 9dd78466c9
20 changed files with 1662 additions and 1312 deletions
Download Patch File Download Diff File Expand all files Collapse all files
drivers/pnp/card.c
+73 -62
View File
@@ -13,26 +13,28 @@
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){
if (compare_pnp_id(card->id,drv_id->id)) {
const struct pnp_card_device_id *drv_id = drv->id_table;
while (*drv_id->id) {
if (compare_pnp_id(card->id, drv_id->id)) {
int i = 0;
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;
}
}
if (! found)
if (!found)
break;
i++;
}
@@ -42,14 +44,14 @@ static const struct pnp_card_device_id * match_card(struct pnp_card_driver * drv
return NULL;
}
static void card_remove(struct pnp_dev * dev)
static void card_remove(struct pnp_dev *dev)
{
dev->card_link = NULL;
}
static void card_remove_first(struct pnp_dev * dev)
static void card_remove_first(struct pnp_dev *dev)
{
struct pnp_card_driver * drv = to_pnp_card_driver(dev->driver);
struct pnp_card_driver *drv = to_pnp_card_driver(dev->driver);
if (!dev->card || !drv)
return;
if (drv->remove)
@@ -67,7 +69,7 @@ static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
if (!drv->probe)
return 0;
id = match_card(drv,card);
id = match_card(drv, card);
if (!id)
return 0;
@@ -97,9 +99,9 @@ static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
*
*/
int pnp_add_card_id(struct pnp_id *id, struct pnp_card * card)
int pnp_add_card_id(struct pnp_id *id, struct pnp_card *card)
{
struct pnp_id * ptr;
struct pnp_id *ptr;
if (!id)
return -EINVAL;
if (!card)
@@ -115,9 +117,9 @@ int pnp_add_card_id(struct pnp_id *id, struct pnp_card * card)
return 0;
}
static void pnp_free_card_ids(struct pnp_card * card)
static void pnp_free_card_ids(struct pnp_card *card)
{
struct pnp_id * id;
struct pnp_id *id;
struct pnp_id *next;
if (!card)
return;
@@ -131,49 +133,52 @@ static void pnp_free_card_ids(struct pnp_card * card)
static void pnp_release_card(struct device *dmdev)
{
struct pnp_card * card = to_pnp_card(dmdev);
struct pnp_card *card = to_pnp_card(dmdev);
pnp_free_card_ids(card);
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);
str += sprintf(str,"%s\n", card->name);
str += sprintf(str, "%s\n", card->name);
return (str - buf);
}
static DEVICE_ATTR(name,S_IRUGO,pnp_show_card_name,NULL);
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);
struct pnp_id * pos = card->id;
struct pnp_id *pos = card->id;
while (pos) {
str += sprintf(str,"%s\n", pos->id);
str += sprintf(str, "%s\n", pos->id);
pos = pos->next;
}
return (str - buf);
}
static DEVICE_ATTR(card_id,S_IRUGO,pnp_show_card_ids,NULL);
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;
int rc = device_create_file(&card->dev, &dev_attr_name);
if (rc)
return rc;
rc = device_create_file(&card->dev,&dev_attr_card_id);
if (rc) goto err_name;
rc = device_create_file(&card->dev, &dev_attr_card_id);
if (rc)
goto err_name;
return 0;
err_name:
device_remove_file(&card->dev,&dev_attr_name);
err_name:
device_remove_file(&card->dev, &dev_attr_name);
return rc;
}
@@ -182,14 +187,15 @@ err_name:
* @card: pointer to the card to add
*/
int pnp_add_card(struct pnp_card * card)
int pnp_add_card(struct pnp_card *card)
{
int error;
struct list_head * pos, * temp;
struct list_head *pos, *temp;
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;
@@ -205,18 +211,21 @@ int pnp_add_card(struct pnp_card * card)
/* we wait until now to add devices in order to ensure the drivers
* will be able to use all of the related devices on the card
* without waiting any unresonable length of time */
list_for_each(pos,&card->devices){
list_for_each(pos, &card->devices) {
struct pnp_dev *dev = card_to_pnp_dev(pos);
__pnp_add_device(dev);
}
/* 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);
card_probe(card,drv);
list_for_each_safe(pos, temp, &pnp_card_drivers) {
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;
}
@@ -225,7 +234,7 @@ int pnp_add_card(struct pnp_card * card)
* @card: pointer to the card to remove
*/
void pnp_remove_card(struct pnp_card * card)
void pnp_remove_card(struct pnp_card *card)
{
struct list_head *pos, *temp;
if (!card)
@@ -235,7 +244,7 @@ void pnp_remove_card(struct pnp_card * card)
list_del(&card->global_list);
list_del(&card->protocol_list);
spin_unlock(&pnp_lock);
list_for_each_safe(pos,temp,&card->devices){
list_for_each_safe(pos, temp, &card->devices) {
struct pnp_dev *dev = card_to_pnp_dev(pos);
pnp_remove_card_device(dev);
}
@@ -247,14 +256,14 @@ void pnp_remove_card(struct pnp_card * card)
* @dev: pointer to the device to add
*/
int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev)
int pnp_add_card_device(struct pnp_card *card, struct pnp_dev *dev)
{
if (!card || !dev || !dev->protocol)
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);
@@ -267,7 +276,7 @@ int pnp_add_card_device(struct pnp_card * card, struct pnp_dev * dev)
* @dev: pointer to the device to remove
*/
void pnp_remove_card_device(struct pnp_dev * dev)
void pnp_remove_card_device(struct pnp_dev *dev)
{
spin_lock(&pnp_lock);
dev->card = NULL;
@@ -283,12 +292,13 @@ 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;
struct pnp_card_driver * drv;
struct pnp_card * card;
struct list_head *pos;
struct pnp_dev *dev;
struct pnp_card_driver *drv;
struct pnp_card *card;
if (!clink || !id)
goto done;
card = clink->card;
@@ -302,15 +312,15 @@ struct pnp_dev * pnp_request_card_device(struct pnp_card_link *clink, const char
}
while (pos != &card->devices) {
dev = card_to_pnp_dev(pos);
if ((!dev->card_link) && compare_pnp_id(dev->id,id))
if ((!dev->card_link) && compare_pnp_id(dev->id, id))
goto found;
pos = pos->next;
}
done:
done:
return NULL;
found:
found:
dev->card_link = clink;
dev->dev.driver = &drv->link.driver;
if (pnp_bus_type.probe(&dev->dev))
@@ -320,7 +330,7 @@ found:
return dev;
err_out:
err_out:
dev->dev.driver = NULL;
dev->card_link = NULL;
return NULL;
@@ -331,9 +341,9 @@ err_out:
* @dev: pointer to the PnP device stucture
*/
void pnp_release_card_device(struct pnp_dev * dev)
void pnp_release_card_device(struct pnp_dev *dev)
{
struct pnp_card_driver * drv = dev->card_link->driver;
struct pnp_card_driver *drv = dev->card_link->driver;
if (!drv)
return;
drv->link.remove = &card_remove;
@@ -368,7 +378,7 @@ static int card_resume(struct pnp_dev *dev)
* @drv: pointer to the driver to register
*/
int pnp_register_card_driver(struct pnp_card_driver * drv)
int pnp_register_card_driver(struct pnp_card_driver *drv)
{
int error;
struct list_head *pos, *temp;
@@ -389,9 +399,10 @@ int pnp_register_card_driver(struct pnp_card_driver * drv)
list_add_tail(&drv->global_list, &pnp_card_drivers);
spin_unlock(&pnp_lock);
list_for_each_safe(pos,temp,&pnp_cards){
struct pnp_card *card = list_entry(pos, struct pnp_card, global_list);
card_probe(card,drv);
list_for_each_safe(pos, temp, &pnp_cards) {
struct pnp_card *card =
list_entry(pos, struct pnp_card, global_list);
card_probe(card, drv);
}
return 0;
}
@@ -401,7 +412,7 @@ int pnp_register_card_driver(struct pnp_card_driver * drv)
* @drv: pointer to the driver to unregister
*/
void pnp_unregister_card_driver(struct pnp_card_driver * drv)
void pnp_unregister_card_driver(struct pnp_card_driver *drv)
{
spin_lock(&pnp_lock);
list_del(&drv->global_list);
@@ -415,7 +426,7 @@ EXPORT_SYMBOL(pnp_remove_card);
EXPORT_SYMBOL(pnp_add_card_device);
EXPORT_SYMBOL(pnp_remove_card_device);
EXPORT_SYMBOL(pnp_add_card_id);
#endif /* 0 */
#endif /* 0 */
EXPORT_SYMBOL(pnp_request_card_device);
EXPORT_SYMBOL(pnp_release_card_device);
EXPORT_SYMBOL(pnp_register_card_driver);
drivers/pnp/core.c
+12 -13
View File
@@ -18,7 +18,6 @@
#include "base.h"
static LIST_HEAD(pnp_protocols);
LIST_HEAD(pnp_global);
DEFINE_SPINLOCK(pnp_lock);
@@ -36,7 +35,7 @@ void *pnp_alloc(long size)
void *result;
result = kzalloc(size, GFP_KERNEL);
if (!result){
if (!result) {
printk(KERN_ERR "pnp: Out of Memory\n");
return NULL;
}
@@ -53,7 +52,7 @@ void *pnp_alloc(long size)
int pnp_register_protocol(struct pnp_protocol *protocol)
{
int nodenum;
struct list_head * pos;
struct list_head *pos;
if (!protocol)
return -EINVAL;
@@ -64,9 +63,9 @@ int pnp_register_protocol(struct pnp_protocol *protocol)
spin_lock(&pnp_lock);
/* assign the lowest unused number */
list_for_each(pos,&pnp_protocols) {
struct pnp_protocol * cur = to_pnp_protocol(pos);
if (cur->number == nodenum){
list_for_each(pos, &pnp_protocols) {
struct pnp_protocol *cur = to_pnp_protocol(pos);
if (cur->number == nodenum) {
pos = &pnp_protocols;
nodenum++;
}
@@ -93,11 +92,10 @@ 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;
struct pnp_id * next;
struct pnp_id *id;
struct pnp_id *next;
if (!dev)
return;
id = dev->id;
@@ -110,7 +108,7 @@ static void pnp_free_ids(struct pnp_dev *dev)
static void pnp_release_device(struct device *dmdev)
{
struct pnp_dev * dev = to_pnp_dev(dmdev);
struct pnp_dev *dev = to_pnp_dev(dmdev);
pnp_free_option(dev->independent);
pnp_free_option(dev->dependent);
pnp_free_ids(dev);
@@ -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);
}
@@ -175,7 +174,7 @@ void pnp_remove_device(struct pnp_dev *dev)
return;
__pnp_remove_device(dev);
}
#endif /* 0 */
#endif /* 0 */
static int __init pnp_init(void)
{
@@ -190,4 +189,4 @@ EXPORT_SYMBOL(pnp_register_protocol);
EXPORT_SYMBOL(pnp_unregister_protocol);
EXPORT_SYMBOL(pnp_add_device);
EXPORT_SYMBOL(pnp_remove_device);
#endif /* 0 */
#endif /* 0 */
drivers/pnp/driver.c
+29 -29
View File
@@ -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;
@@ -31,18 +29,19 @@ int compare_pnp_id(struct pnp_id *pos, const char *id)
{
if (!pos || !id || (strlen(id) != 7))
return 0;
if (memcmp(id,"ANYDEVS",7)==0)
if (memcmp(id, "ANYDEVS", 7) == 0)
return 1;
while (pos){
if (memcmp(pos->id,id,3)==0)
if (compare_func(pos->id,id)==1)
while (pos) {
if (memcmp(pos->id, id, 3) == 0)
if (compare_func(pos->id, id) == 1)
return 1;
pos = pos->next;
}
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)
@@ -59,7 +58,7 @@ static const struct pnp_device_id * match_device(struct pnp_driver *drv, struct
int pnp_device_attach(struct pnp_dev *pnp_dev)
{
spin_lock(&pnp_lock);
if(pnp_dev->status != PNP_READY){
if (pnp_dev->status != PNP_READY) {
spin_unlock(&pnp_lock);
return -EBUSY;
}
@@ -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)
@@ -99,7 +99,7 @@ static int pnp_device_probe(struct device *dev)
return error;
}
} else if ((pnp_drv->flags & PNP_DRIVER_RES_DISABLE)
== PNP_DRIVER_RES_DISABLE) {
== PNP_DRIVER_RES_DISABLE) {
error = pnp_disable_dev(pnp_dev);
if (error < 0)
return error;
@@ -110,22 +110,22 @@ static int pnp_device_probe(struct device *dev)
if (dev_id != NULL)
error = pnp_drv->probe(pnp_dev, dev_id);
}
if (error >= 0){
if (error >= 0) {
pnp_dev->driver = pnp_drv;
error = 0;
} else
goto fail;
return error;
fail:
fail:
pnp_device_detach(pnp_dev);
return error;
}
static int pnp_device_remove(struct device *dev)
{
struct pnp_dev * pnp_dev = to_pnp_dev(dev);
struct pnp_driver * drv = pnp_dev->driver;
struct pnp_dev *pnp_dev = to_pnp_dev(dev);
struct pnp_driver *drv = pnp_dev->driver;
if (drv) {
if (drv->remove)
@@ -138,8 +138,8 @@ static int pnp_device_remove(struct device *dev)
static int pnp_bus_match(struct device *dev, struct device_driver *drv)
{
struct pnp_dev * pnp_dev = to_pnp_dev(dev);
struct pnp_driver * pnp_drv = to_pnp_driver(drv);
struct pnp_dev *pnp_dev = to_pnp_dev(dev);
struct pnp_driver *pnp_drv = to_pnp_driver(drv);
if (match_device(pnp_drv, pnp_dev) == NULL)
return 0;
return 1;
@@ -147,8 +147,8 @@ static int pnp_bus_match(struct device *dev, struct device_driver *drv)
static int pnp_bus_suspend(struct device *dev, pm_message_t state)
{
struct pnp_dev * pnp_dev = to_pnp_dev(dev);
struct pnp_driver * pnp_drv = pnp_dev->driver;
struct pnp_dev *pnp_dev = to_pnp_dev(dev);
struct pnp_driver *pnp_drv = pnp_dev->driver;
int error;
if (!pnp_drv)
@@ -162,9 +162,9 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state)
if (!(pnp_drv->flags & PNP_DRIVER_RES_DO_NOT_CHANGE) &&
pnp_can_disable(pnp_dev)) {
error = pnp_stop_dev(pnp_dev);
if (error)
return error;
error = pnp_stop_dev(pnp_dev);
if (error)
return error;
}
if (pnp_dev->protocol && pnp_dev->protocol->suspend)
@@ -174,8 +174,8 @@ static int pnp_bus_suspend(struct device *dev, pm_message_t state)
static int pnp_bus_resume(struct device *dev)
{
struct pnp_dev * pnp_dev = to_pnp_dev(dev);
struct pnp_driver * pnp_drv = pnp_dev->driver;
struct pnp_dev *pnp_dev = to_pnp_dev(dev);
struct pnp_driver *pnp_drv = pnp_dev->driver;
int error;
if (!pnp_drv)
@@ -197,10 +197,10 @@ static int pnp_bus_resume(struct device *dev)
}
struct bus_type pnp_bus_type = {
.name = "pnp",
.match = pnp_bus_match,
.probe = pnp_device_probe,
.remove = pnp_device_remove,
.name = "pnp",
.match = pnp_bus_match,
.probe = pnp_device_probe,
.remove = pnp_device_remove,
.suspend = pnp_bus_suspend,
.resume = pnp_bus_resume,
};
drivers/pnp/interface.c
+122 -93
View File
@@ -29,7 +29,7 @@ struct pnp_info_buffer {
typedef struct pnp_info_buffer pnp_info_buffer_t;
static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt,...)
static int pnp_printf(pnp_info_buffer_t * buffer, char *fmt, ...)
{
va_list args;
int res;
@@ -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,
port->flags & PNP_PORT_FLAG_16BITADDR ? 16 : 10);
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,14 +89,15 @@ 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;
pnp_printf(buffer, "%sdma ", space);
for (i = 0; i < 8; i++)
if (dma->map & (1<<i)) {
if (dma->map & (1 << i)) {
if (!first) {
pnp_printf(buffer, ",");
} else {
@@ -136,12 +141,13 @@ 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;
pnp_printf(buffer, "%sMemory 0x%x-0x%x, align 0x%x, size 0x%x",
space, mem->min, mem->max, mem->align, mem->size);
space, mem->min, mem->max, mem->align, mem->size);
if (mem->flags & IORESOURCE_MEM_WRITEABLE)
pnp_printf(buffer, ", writeable");
if (mem->flags & IORESOURCE_MEM_CACHEABLE)
@@ -168,7 +174,7 @@ static void pnp_print_mem(pnp_info_buffer_t *buffer, char *space, struct pnp_mem
pnp_printf(buffer, ", %s\n", s);
}
static void pnp_print_option(pnp_info_buffer_t *buffer, char *space,
static void pnp_print_option(pnp_info_buffer_t * buffer, char *space,
struct pnp_option *option, int dep)
{
char *s;
@@ -179,19 +185,19 @@ static void pnp_print_option(pnp_info_buffer_t *buffer, char *space,
if (dep) {
switch (option->priority) {
case PNP_RES_PRIORITY_PREFERRED:
case PNP_RES_PRIORITY_PREFERRED:
s = "preferred";
break;
case PNP_RES_PRIORITY_ACCEPTABLE:
case PNP_RES_PRIORITY_ACCEPTABLE:
s = "acceptable";
break;
case PNP_RES_PRIORITY_FUNCTIONAL:
case PNP_RES_PRIORITY_FUNCTIONAL:
s = "functional";
break;
default:
default:
s = "invalid";
}
pnp_printf(buffer, "Dependent: %02i - Priority %s\n",dep, s);
pnp_printf(buffer, "Dependent: %02i - Priority %s\n", dep, s);
}
for (port = option->port; port; port = port->next)
@@ -204,16 +210,16 @@ 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;
struct pnp_option * dependent = dev->dependent;
struct pnp_option *independent = dev->independent;
struct pnp_option *dependent = dev->dependent;
int ret, dep = 1;
pnp_info_buffer_t *buffer = (pnp_info_buffer_t *)
pnp_alloc(sizeof(pnp_info_buffer_t));
pnp_alloc(sizeof(pnp_info_buffer_t));
if (!buffer)
return -ENOMEM;
@@ -223,7 +229,7 @@ static ssize_t pnp_show_options(struct device *dmdev, struct device_attribute *a
if (independent)
pnp_print_option(buffer, "", independent, 0);
while (dependent){
while (dependent) {
pnp_print_option(buffer, " ", dependent, dep);
dependent = dependent->next;
dep++;
@@ -233,10 +239,11 @@ static ssize_t pnp_show_options(struct device *dmdev, struct device_attribute *a
return ret;
}
static DEVICE_ATTR(options,S_IRUGO,pnp_show_options,NULL);
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;
@@ -252,52 +259,56 @@ static ssize_t pnp_show_current_resources(struct device *dmdev, struct device_at
buffer->buffer = buf;
buffer->curr = buffer->buffer;
pnp_printf(buffer,"state = ");
pnp_printf(buffer, "state = ");
if (dev->active)
pnp_printf(buffer,"active\n");
pnp_printf(buffer, "active\n");
else
pnp_printf(buffer,"disabled\n");
pnp_printf(buffer, "disabled\n");
for (i = 0; i < PNP_MAX_PORT; i++) {
if (pnp_port_valid(dev, i)) {
pnp_printf(buffer,"io");
pnp_printf(buffer, "io");
if (pnp_port_flags(dev, i) & IORESOURCE_DISABLED)
pnp_printf(buffer," disabled\n");
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));
pnp_printf(buffer, " 0x%llx-0x%llx\n",
(unsigned long long)
pnp_port_start(dev, i),
(unsigned long long)pnp_port_end(dev,
i));
}
}
for (i = 0; i < PNP_MAX_MEM; i++) {
if (pnp_mem_valid(dev, i)) {
pnp_printf(buffer,"mem");
pnp_printf(buffer, "mem");
if (pnp_mem_flags(dev, i) & IORESOURCE_DISABLED)
pnp_printf(buffer," disabled\n");
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));
pnp_printf(buffer, " 0x%llx-0x%llx\n",
(unsigned long long)
pnp_mem_start(dev, i),
(unsigned long long)pnp_mem_end(dev,
i));
}
}
for (i = 0; i < PNP_MAX_IRQ; i++) {
if (pnp_irq_valid(dev, i)) {
pnp_printf(buffer,"irq");
pnp_printf(buffer, "irq");
if (pnp_irq_flags(dev, i) & IORESOURCE_DISABLED)
pnp_printf(buffer," disabled\n");
pnp_printf(buffer, " disabled\n");
else
pnp_printf(buffer," %lld\n",
(unsigned long long)pnp_irq(dev, i));
pnp_printf(buffer, " %lld\n",
(unsigned long long)pnp_irq(dev, i));
}
}
for (i = 0; i < PNP_MAX_DMA; i++) {
if (pnp_dma_valid(dev, i)) {
pnp_printf(buffer,"dma");
pnp_printf(buffer, "dma");
if (pnp_dma_flags(dev, i) & IORESOURCE_DISABLED)
pnp_printf(buffer," disabled\n");
pnp_printf(buffer, " disabled\n");
else
pnp_printf(buffer," %lld\n",
(unsigned long long)pnp_dma(dev, i));
pnp_printf(buffer, " %lld\n",
(unsigned long long)pnp_dma(dev, i));
}
}
ret = (buffer->curr - buf);
@@ -308,55 +319,57 @@ 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;
int retval = 0;
char *buf = (void *)ubuf;
int retval = 0;
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;
}
while (isspace(*buf))
++buf;
if (!strnicmp(buf,"disable",7)) {
if (!strnicmp(buf, "disable", 7)) {
retval = pnp_disable_dev(dev);
goto done;
}
if (!strnicmp(buf,"activate",8)) {
if (!strnicmp(buf, "activate", 8)) {
retval = pnp_activate_dev(dev);
goto done;
}
if (!strnicmp(buf,"fill",4)) {
if (!strnicmp(buf, "fill", 4)) {
if (dev->active)
goto done;
retval = pnp_auto_config_dev(dev);
goto done;
}
if (!strnicmp(buf,"auto",4)) {
if (!strnicmp(buf, "auto", 4)) {
if (dev->active)
goto done;
pnp_init_resource_table(&dev->res);
retval = pnp_auto_config_dev(dev);
goto done;
}
if (!strnicmp(buf,"clear",5)) {
if (!strnicmp(buf, "clear", 5)) {
if (dev->active)
goto done;
pnp_init_resource_table(&dev->res);
goto done;
}
if (!strnicmp(buf,"get",3)) {
if (!strnicmp(buf, "get", 3)) {
down(&pnp_res_mutex);
if (pnp_can_read(dev))
dev->protocol->get(dev, &dev->res);
up(&pnp_res_mutex);
goto done;
}
if (!strnicmp(buf,"set",3)) {
if (!strnicmp(buf, "set", 3)) {
int nport = 0, nmem = 0, nirq = 0, ndma = 0;
if (dev->active)
goto done;
@@ -366,65 +379,77 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
while (1) {
while (isspace(*buf))
++buf;
if (!strnicmp(buf,"io",2)) {
if (!strnicmp(buf, "io", 2)) {
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 == '-') {
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;
continue;
}
if (!strnicmp(buf,"mem",3)) {
if (!strnicmp(buf, "mem", 3)) {
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 == '-') {
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;
continue;
}
if (!strnicmp(buf,"irq",3)) {
if (!strnicmp(buf, "irq", 3)) {
buf += 3;
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;
continue;
}
if (!strnicmp(buf,"dma",3)) {
if (!strnicmp(buf, "dma", 3)) {
buf += 3;
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;
@@ -435,45 +460,49 @@ pnp_set_current_resources(struct device * dmdev, struct device_attribute *attr,
up(&pnp_res_mutex);
goto done;
}
done:
done:
if (retval < 0)
return retval;
return count;
}
static DEVICE_ATTR(resources,S_IRUGO | S_IWUSR,
pnp_show_current_resources,pnp_set_current_resources);
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);
struct pnp_id * pos = dev->id;
struct pnp_id *pos = dev->id;
while (pos) {
str += sprintf(str,"%s\n", pos->id);
str += sprintf(str, "%s\n", pos->id);
pos = pos->next;
}
return (str - buf);
}
static DEVICE_ATTR(id,S_IRUGO,pnp_show_current_ids,NULL);
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;
rc = device_create_file(&dev->dev,&dev_attr_resources);
if (rc) goto err_opt;
rc = device_create_file(&dev->dev,&dev_attr_id);
if (rc) goto err_res;
int rc = device_create_file(&dev->dev, &dev_attr_options);
if (rc)
goto err;
rc = device_create_file(&dev->dev, &dev_attr_resources);
if (rc)
goto err_opt;
rc = device_create_file(&dev->dev, &dev_attr_id);
if (rc)
goto err_res;
return 0;
err_res:
device_remove_file(&dev->dev,&dev_attr_resources);
err_opt:
device_remove_file(&dev->dev,&dev_attr_options);
err:
err_res:
device_remove_file(&dev->dev, &dev_attr_resources);
err_opt:
device_remove_file(&dev->dev, &dev_attr_options);
err:
return rc;
}
drivers/pnp/isapnp/compat.c
+14 -16
View File
@@ -5,28 +5,26 @@
* Copyright 2002 Adam Belay <ambx1@neo.rr.com>
*
*/
/* TODO: see if more isapnp functions are needed here */
#include <linux/module.h>
#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);
'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);
}
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];
@@ -38,7 +36,7 @@ struct pnp_card *pnp_find_card(unsigned short vendor,
while (list != &pnp_cards) {
struct pnp_card *card = global_to_pnp_card(list);
if (compare_pnp_id(card->id,id) || (memcmp(id,any,7)==0))
if (compare_pnp_id(card->id, id) || (memcmp(id, any, 7) == 0))
return card;
list = list->next;
}
@@ -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;
}
@@ -78,7 +76,7 @@ struct pnp_dev *pnp_find_dev(struct pnp_card *card,
}
while (list != &card->devices) {
struct pnp_dev *dev = card_to_pnp_dev(list);
if (compare_pnp_id(dev->id,id))
if (compare_pnp_id(dev->id, id))
return dev;
list = list->next;
}
drivers/pnp/isapnp/core.c
+178 -124
View File
File diff suppressed because it is too large Load Diff
drivers/pnp/isapnp/proc.c
+7 -7
View File
@@ -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);
@@ -74,7 +75,7 @@ static ssize_t isapnp_proc_bus_read(struct file *file, char __user *buf, size_t
return -EINVAL;
isapnp_cfg_begin(dev->card->number, dev->number);
for ( ; pos < 256 && cnt > 0; pos++, buf++, cnt--) {
for (; pos < 256 && cnt > 0; pos++, buf++, cnt--) {
unsigned char val;
val = isapnp_read_byte(pos);
__put_user(val, buf);
@@ -85,10 +86,9 @@ 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 =
{
.llseek = isapnp_proc_bus_lseek,
.read = isapnp_proc_bus_read,
static const struct file_operations isapnp_proc_bus_file_operations = {
.llseek = isapnp_proc_bus_lseek,
.read = isapnp_proc_bus_read,
};
static int isapnp_proc_attach_device(struct pnp_dev *dev)
@@ -145,7 +145,7 @@ int __init isapnp_proc_init(void)
{
struct pnp_dev *dev;
isapnp_proc_bus_dir = proc_mkdir("isapnp", proc_bus);
protocol_for_each_dev(&isapnp_protocol,dev) {
protocol_for_each_dev(&isapnp_protocol, dev) {
isapnp_proc_attach_device(dev);
}
return 0;
drivers/pnp/manager.c
+68 -52
View File
@@ -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;
}
@@ -41,11 +42,11 @@ static int pnp_assign_port(struct pnp_dev *dev, struct pnp_port *rule, int idx)
/* set the initial values */
*flags |= rule->flags | IORESOURCE_IO;
*flags &= ~IORESOURCE_UNSET;
*flags &= ~IORESOURCE_UNSET;
if (!rule->size) {
*flags |= IORESOURCE_DISABLED;
return 1; /* skip disabled resource requests */
return 1; /* skip disabled resource requests */
}
*start = rule->min;
@@ -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;
}
@@ -85,7 +87,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
/* set the initial values */
*flags |= rule->flags | IORESOURCE_MEM;
*flags &= ~IORESOURCE_UNSET;
*flags &= ~IORESOURCE_UNSET;
/* convert pnp flags to standard Linux flags */
if (!(rule->flags & IORESOURCE_MEM_WRITEABLE))
@@ -99,11 +101,11 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
if (!rule->size) {
*flags |= IORESOURCE_DISABLED;
return 1; /* skip disabled resource requests */
return 1; /* skip disabled resource requests */
}
*start = rule->min;
*end = *start + rule->size -1;
*end = *start + rule->size - 1;
/* run through until pnp_check_mem is happy */
while (!pnp_check_mem(dev, idx)) {
@@ -115,7 +117,7 @@ static int pnp_assign_mem(struct pnp_dev *dev, struct pnp_mem *rule, int idx)
return 1;
}
static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
static int pnp_assign_irq(struct pnp_dev *dev, struct pnp_irq *rule, int idx)
{
resource_size_t *start, *end;
unsigned long *flags;
@@ -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;
}
@@ -145,11 +148,11 @@ static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
/* set the initial values */
*flags |= rule->flags | IORESOURCE_IRQ;
*flags &= ~IORESOURCE_UNSET;
*flags &= ~IORESOURCE_UNSET;
if (bitmap_empty(rule->map, PNP_IRQ_NR)) {
*flags |= IORESOURCE_DISABLED;
return 1; /* skip disabled resource requests */
return 1; /* skip disabled resource requests */
}
/* TBD: need check for >16 IRQ */
@@ -159,9 +162,9 @@ static int pnp_assign_irq(struct pnp_dev * dev, struct pnp_irq *rule, int idx)
return 1;
}
for (i = 0; i < 16; i++) {
if(test_bit(xtab[i], rule->map)) {
if (test_bit(xtab[i], rule->map)) {
*start = *end = xtab[i];
if(pnp_check_irq(dev, idx))
if (pnp_check_irq(dev, idx))
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;
}
@@ -198,17 +202,17 @@ static int pnp_assign_dma(struct pnp_dev *dev, struct pnp_dma *rule, int idx)
/* set the initial values */
*flags |= rule->flags | IORESOURCE_DMA;
*flags &= ~IORESOURCE_UNSET;
*flags &= ~IORESOURCE_UNSET;
if (!rule->map) {
*flags |= IORESOURCE_DISABLED;
return 1; /* skip disabled resource requests */
return 1; /* skip disabled resource requests */
}
for (i = 0; i < 8; i++) {
if(rule->map & (1<<xtab[i])) {
if (rule->map & (1 << xtab[i])) {
*start = *end = xtab[i];
if(pnp_check_dma(dev, idx))
if (pnp_check_dma(dev, idx))
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;
}
}
@@ -254,7 +262,7 @@ void pnp_init_resource_table(struct pnp_resource_table *table)
* @res: the resources to clean
*
*/
static void pnp_clean_resource_table(struct pnp_resource_table * res)
static void pnp_clean_resource_table(struct pnp_resource_table *res)
{
int idx;
for (idx = 0; idx < PNP_MAX_IRQ; idx++) {
@@ -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;
}
}
@@ -306,7 +318,7 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
return -ENODEV;
down(&pnp_res_mutex);
pnp_clean_resource_table(&dev->res); /* start with a fresh slate */
pnp_clean_resource_table(&dev->res); /* start with a fresh slate */
if (dev->independent) {
port = dev->independent->port;
mem = dev->independent->mem;
@@ -341,10 +353,11 @@ 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)
if(!dep)
for (i = 1, dep = dev->dependent; i < depnum;
i++, dep = dep->next)
if (!dep)
goto fail;
port =dep->port;
port = dep->port;
mem = dep->mem;
irq = dep->irq;
dma = dep->dma;
@@ -378,7 +391,7 @@ static int pnp_assign_resources(struct pnp_dev *dev, int depnum)
up(&pnp_res_mutex);
return 1;
fail:
fail:
pnp_clean_resource_table(&dev->res);
up(&pnp_res_mutex);
return 0;
@@ -392,10 +405,11 @@ 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;
struct pnp_resource_table *bak;
if (!dev || !res)
return -EINVAL;
if (!pnp_can_configure(dev))
@@ -409,19 +423,19 @@ int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table * res,
dev->res = *res;
if (!(mode & PNP_CONFIG_FORCE)) {
for (i = 0; i < PNP_MAX_PORT; i++) {
if(!pnp_check_port(dev,i))
if (!pnp_check_port(dev, i))
goto fail;
}
for (i = 0; i < PNP_MAX_MEM; i++) {
if(!pnp_check_mem(dev,i))
if (!pnp_check_mem(dev, i))
goto fail;
}
for (i = 0; i < PNP_MAX_IRQ; i++) {
if(!pnp_check_irq(dev,i))
if (!pnp_check_irq(dev, i))
goto fail;
}
for (i = 0; i < PNP_MAX_DMA; i++) {
if(!pnp_check_dma(dev,i))
if (!pnp_check_dma(dev, i))
goto fail;
}
}
@@ -430,7 +444,7 @@ int pnp_manual_config_dev(struct pnp_dev *dev, struct pnp_resource_table * res,
kfree(bak);
return 0;
fail:
fail:
dev->res = *bak;
up(&pnp_res_mutex);
kfree(bak);
@@ -447,11 +461,12 @@ int pnp_auto_config_dev(struct pnp_dev *dev)
struct pnp_option *dep;
int i = 1;
if(!dev)
if (!dev)
return -EINVAL;
if(!pnp_can_configure(dev)) {
pnp_dbg("Device %s does not support resource configuration.", dev->dev.bus_id);
if (!pnp_can_configure(dev)) {
pnp_dbg("Device %s does not support resource configuration.",
dev->dev.bus_id);
return -ENODEV;
}
@@ -482,11 +497,12 @@ 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;
}
if (dev->protocol->set(dev, &dev->res)<0) {
if (dev->protocol->set(dev, &dev->res) < 0) {
pnp_err("Failed to activate device %s.", dev->dev.bus_id);
return -EIO;
}
@@ -506,10 +522,11 @@ 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) {
if (dev->protocol->disable(dev) < 0) {
pnp_err("Failed to disable device %s.", dev->dev.bus_id);
return -EIO;
}
@@ -532,7 +549,7 @@ int pnp_activate_dev(struct pnp_dev *dev)
if (!dev)
return -EINVAL;
if (dev->active) {
return 0; /* the device is already active */
return 0; /* the device is already active */
}
/* ensure resources are allocated */
@@ -558,10 +575,10 @@ int pnp_disable_dev(struct pnp_dev *dev)
{
int error;
if (!dev)
return -EINVAL;
if (!dev)
return -EINVAL;
if (!dev->active) {
return 0; /* the device is already disabled */
return 0; /* the device is already disabled */
}
error = pnp_stop_dev(dev);
@@ -586,7 +603,7 @@ int pnp_disable_dev(struct pnp_dev *dev)
*
*/
void pnp_resource_change(struct resource *resource, resource_size_t start,
resource_size_t size)
resource_size_t size)
{
if (resource == NULL)
return;
@@ -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);
drivers/pnp/pnpacpi/core.c
+48 -39
View File
@@ -36,11 +36,11 @@ static int num = 0;
* have irqs (PIC, Timer) because we call acpi_register_gsi.
* Finaly only devices that have a CRS method need to be in this list.
*/
static __initdata struct acpi_device_id excluded_id_list[] ={
{"PNP0C09", 0}, /* EC */
{"PNP0C0F", 0}, /* Link device */
{"PNP0000", 0}, /* PIC */
{"PNP0100", 0}, /* Timer */
static __initdata struct acpi_device_id excluded_id_list[] = {
{"PNP0C09", 0}, /* EC */
{"PNP0C0F", 0}, /* Link device */
{"PNP0000", 0}, /* PIC */
{"PNP0100", 0}, /* Timer */
{"", 0},
};
@@ -84,15 +84,17 @@ 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,
&dev->res);
status = pnpacpi_parse_allocated_resource((acpi_handle) dev->data,
&dev->res);
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;
@@ -119,27 +121,29 @@ static int pnpacpi_disable_resources(struct pnp_dev *dev)
acpi_status status;
/* acpi_unregister_gsi(pnp_irq(dev, 0)); */
status = acpi_evaluate_object((acpi_handle)dev->data,
"_DIS", NULL, NULL);
status = acpi_evaluate_object((acpi_handle) dev->data,
"_DIS", NULL, NULL);
return ACPI_FAILURE(status) ? -ENODEV : 0;
}
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));
return acpi_bus_set_power((acpi_handle) dev->data,
acpi_pm_device_sleep_state(&dev->dev,
device_may_wakeup
(&dev->dev),
NULL));
}
static int pnpacpi_resume(struct pnp_dev *dev)
{
return acpi_bus_set_power((acpi_handle)dev->data, ACPI_STATE_D0);
return acpi_bus_set_power((acpi_handle) dev->data, ACPI_STATE_D0);
}
static struct pnp_protocol pnpacpi_protocol = {
.name = "Plug and Play ACPI",
.get = pnpacpi_get_resources,
.set = pnpacpi_set_resources,
.name = "Plug and Play ACPI",
.get = pnpacpi_get_resources,
.set = pnpacpi_set_resources,
.disable = pnpacpi_disable_resources,
.suspend = pnpacpi_suspend,
.resume = pnpacpi_resume,
@@ -154,11 +158,11 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
status = acpi_get_handle(device->handle, "_CRS", &temp);
if (ACPI_FAILURE(status) || !ispnpidacpi(acpi_device_hid(device)) ||
is_exclusive_device(device))
is_exclusive_device(device))
return 0;
pnp_dbg("ACPI device : hid %s", acpi_device_hid(device));
dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
if (!dev) {
pnp_err("Out of memory");
return -ENOMEM;
@@ -194,20 +198,23 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
pnpidacpi_to_pnpid(acpi_device_hid(device), dev_id->id);
pnp_add_id(dev_id, dev);
if(dev->active) {
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;
}
}
if(dev->capabilities & PNP_CONFIGURABLE) {
if (dev->capabilities & PNP_CONFIGURABLE) {
status = pnpacpi_parse_resource_option_data(device->handle,
dev);
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;
}
}
@@ -233,18 +240,19 @@ static int __init pnpacpi_add_device(struct acpi_device *device)
if (!dev->active)
pnp_init_resource_table(&dev->res);
pnp_add_device(dev);
num ++;
num++;
return AE_OK;
err1:
err1:
kfree(dev_id);
err:
err:
kfree(dev);
return -EINVAL;
}
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;
@@ -257,23 +265,22 @@ static acpi_status __init pnpacpi_add_device_handler(acpi_handle handle,
static int __init acpi_pnp_match(struct device *dev, void *_pnp)
{
struct acpi_device *acpi = to_acpi_device(dev);
struct pnp_dev *pnp = _pnp;
struct acpi_device *acpi = to_acpi_device(dev);
struct pnp_dev *pnp = _pnp;
/* true means it matched */
return acpi->flags.hardware_id
&& !acpi_get_physical_device(acpi->handle)
&& compare_pnp_id(pnp->id, acpi->pnp.hardware_id);
&& !acpi_get_physical_device(acpi->handle)
&& compare_pnp_id(pnp->id, acpi->pnp.hardware_id);
}
static int __init acpi_pnp_find_device(struct device *dev, acpi_handle *handle)
static int __init acpi_pnp_find_device(struct device *dev, acpi_handle * handle)
{
struct device *adev;
struct acpi_device *acpi;
struct device *adev;
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
drivers/pnp/pnpacpi/rsparser.c
+245 -210
View File
File diff suppressed because it is too large Load Diff
drivers/pnp/pnpbios/bioscalls.c
+156 -126
View File
File diff suppressed because it is too large Load Diff
drivers/pnp/pnpbios/core.c
+127 -114
View File
@@ -32,7 +32,7 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Change Log
*
* Adam Belay - <ambx1@neo.rr.com> - March 16, 2003
@@ -71,14 +71,13 @@
#include "pnpbios.h"
/*
*
* PnP BIOS INTERFACE
*
*/
static union pnp_bios_install_struct * pnp_bios_install = NULL;
static union pnp_bios_install_struct *pnp_bios_install = NULL;
int pnp_bios_present(void)
{
@@ -101,36 +100,36 @@ static struct completion unload_sem;
/*
* (Much of this belongs in a shared routine somewhere)
*/
static int pnp_dock_event(int dock, struct pnp_docking_station_info *info)
{
char *argv [3], **envp, *buf, *scratch;
char *argv[3], **envp, *buf, *scratch;
int i = 0, value;
if (!current->fs->root) {
return -EAGAIN;
}
if (!(envp = kcalloc(20, sizeof (char *), GFP_KERNEL))) {
if (!(envp = kcalloc(20, sizeof(char *), GFP_KERNEL))) {
return -ENOMEM;
}
if (!(buf = kzalloc(256, GFP_KERNEL))) {
kfree (envp);
kfree(envp);
return -ENOMEM;
}
/* FIXME: if there are actual users of this, it should be integrated into
* the driver core and use the usual infrastructure like sysfs and uevents */
argv [0] = "/sbin/pnpbios";
argv [1] = "dock";
argv [2] = NULL;
argv[0] = "/sbin/pnpbios";
argv[1] = "dock";
argv[2] = NULL;
/* minimal command environment */
envp [i++] = "HOME=/";
envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
envp[i++] = "HOME=/";
envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
#ifdef DEBUG
/* hint that policy agent should enter no-stdout debug mode */
envp [i++] = "DEBUG=kernel";
envp[i++] = "DEBUG=kernel";
#endif
/* extensible set of named bus-specific parameters,
* supporting multiple driver selection algorithms.
@@ -138,33 +137,32 @@ static int pnp_dock_event(int dock, struct pnp_docking_station_info *info)
scratch = buf;
/* action: add, remove */
envp [i++] = scratch;
scratch += sprintf (scratch, "ACTION=%s", dock?"add":"remove") + 1;
envp[i++] = scratch;
scratch += sprintf(scratch, "ACTION=%s", dock ? "add" : "remove") + 1;
/* Report the ident for the dock */
envp [i++] = scratch;
scratch += sprintf (scratch, "DOCK=%x/%x/%x",
info->location_id, info->serial, info->capabilities);
envp[i++] = scratch;
scratch += sprintf(scratch, "DOCK=%x/%x/%x",
info->location_id, info->serial, info->capabilities);
envp[i] = NULL;
value = call_usermodehelper (argv [0], argv, envp, UMH_WAIT_EXEC);
kfree (buf);
kfree (envp);
value = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
kfree(buf);
kfree(envp);
return 0;
}
/*
* Poll the PnP docking at regular intervals
*/
static int pnp_dock_thread(void * unused)
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;
/*
* Poll every 2 seconds
*/
@@ -175,30 +173,29 @@ static int pnp_dock_thread(void * unused)
status = pnp_bios_dock_station_info(&now);
switch(status)
{
switch (status) {
/*
* No dock to manage
*/
case PNP_FUNCTION_NOT_SUPPORTED:
complete_and_exit(&unload_sem, 0);
case PNP_SYSTEM_NOT_DOCKED:
d = 0;
break;
case PNP_SUCCESS:
d = 1;
break;
default:
pnpbios_print_status( "pnp_dock_thread", status );
continue;
case PNP_FUNCTION_NOT_SUPPORTED:
complete_and_exit(&unload_sem, 0);
case PNP_SYSTEM_NOT_DOCKED:
d = 0;
break;
case PNP_SUCCESS:
d = 1;
break;
default:
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
}
}
@@ -206,21 +203,22 @@ static int pnp_dock_thread(void * unused)
complete_and_exit(&unload_sem, 0);
}
#endif /* CONFIG_HOTPLUG */
#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;
struct pnp_bios_node *node;
/* just in case */
if(!pnpbios_is_dynamic(dev))
if (!pnpbios_is_dynamic(dev))
return -EPERM;
node = kzalloc(node_info.max_node_size, GFP_KERNEL);
if (!node)
return -1;
if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) {
if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
kfree(node);
return -ENODEV;
}
@@ -230,10 +228,11 @@ 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;
struct pnp_bios_node *node;
int ret;
/* just in case */
@@ -243,11 +242,11 @@ static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table
node = kzalloc(node_info.max_node_size, GFP_KERNEL);
if (!node)
return -1;
if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) {
if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
kfree(node);
return -ENODEV;
}
if(pnpbios_write_resources_to_node(res, node)<0) {
if (pnpbios_write_resources_to_node(res, node) < 0) {
kfree(node);
return -1;
}
@@ -258,18 +257,18 @@ static int pnpbios_set_resources(struct pnp_dev * dev, struct pnp_resource_table
return ret;
}
static void pnpbios_zero_data_stream(struct pnp_bios_node * node)
static void pnpbios_zero_data_stream(struct pnp_bios_node *node)
{
unsigned char * p = (char *)node->data;
unsigned char * end = (char *)(node->data + node->size);
unsigned char *p = (char *)node->data;
unsigned char *end = (char *)(node->data + node->size);
unsigned int len;
int i;
while ((char *)p < (char *)end) {
if(p[0] & 0x80) { /* large tag */
if (p[0] & 0x80) { /* large tag */
len = (p[2] << 8) | p[1];
p += 3;
} else {
if (((p[0]>>3) & 0x0f) == 0x0f)
if (((p[0] >> 3) & 0x0f) == 0x0f)
return;
len = p[0] & 0x07;
p += 1;
@@ -278,24 +277,25 @@ 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)
{
struct pnp_bios_node * node;
struct pnp_bios_node *node;
u8 nodenum = dev->number;
int ret;
/* just in case */
if(dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev))
if (dev->flags & PNPBIOS_NO_DISABLE || !pnpbios_is_dynamic(dev))
return -EPERM;
node = kzalloc(node_info.max_node_size, GFP_KERNEL);
if (!node)
return -ENOMEM;
if (pnp_bios_get_dev_node(&nodenum, (char )PNPMODE_DYNAMIC, node)) {
if (pnp_bios_get_dev_node(&nodenum, (char)PNPMODE_DYNAMIC, node)) {
kfree(node);
return -ENODEV;
}
@@ -311,22 +311,22 @@ static int pnpbios_disable_resources(struct pnp_dev *dev)
/* PnP Layer support */
struct pnp_protocol pnpbios_protocol = {
.name = "Plug and Play BIOS",
.get = pnpbios_get_resources,
.set = pnpbios_set_resources,
.name = "Plug and Play BIOS",
.get = pnpbios_get_resources,
.set = pnpbios_set_resources,
.disable = pnpbios_disable_resources,
};
static int insert_device(struct pnp_dev *dev, struct pnp_bios_node * node)
static int insert_device(struct pnp_dev *dev, struct pnp_bios_node *node)
{
struct list_head * pos;
struct pnp_dev * pnp_dev;
struct list_head *pos;
struct pnp_dev *pnp_dev;
struct pnp_id *dev_id;
char id[8];
/* check if the device is already added */
dev->number = node->handle;
list_for_each (pos, &pnpbios_protocol.devices){
list_for_each(pos, &pnpbios_protocol.devices) {
pnp_dev = list_entry(pos, struct pnp_dev, protocol_list);
if (dev->number == pnp_dev->number)
return -1;
@@ -336,8 +336,8 @@ static int insert_device(struct pnp_dev *dev, struct pnp_bios_node * node)
dev_id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
if (!dev_id)
return -1;
pnpid32_to_pnpid(node->eisa_id,id);
memcpy(dev_id->id,id,7);
pnpid32_to_pnpid(node->eisa_id, id);
memcpy(dev_id->id, id, 7);
pnp_add_id(dev_id, dev);
pnpbios_parse_data_stream(dev, node);
dev->active = pnp_is_active(dev);
@@ -375,35 +375,41 @@ static void __init build_devlist(void)
if (!node)
return;
for(nodenum=0; nodenum<0xff; ) {
for (nodenum = 0; nodenum < 0xff;) {
u8 thisnodenum = nodenum;
/* eventually we will want to use PNPMODE_STATIC here but for now
* 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++;
dev = kzalloc(sizeof (struct pnp_dev), GFP_KERNEL);
dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
if (!dev)
break;
if(insert_device(dev,node)<0)
if (insert_device(dev, node) < 0)
kfree(dev);
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",
nodes_got, nodes_got != 1 ? "s" : "", devs);
printk(KERN_INFO
"PnPBIOS: %i node%s reported by PnP BIOS; %i recorded by driver\n",
nodes_got, nodes_got != 1 ? "s" : "", devs);
}
/*
@@ -412,8 +418,8 @@ static void __init build_devlist(void)
*
*/
static int pnpbios_disabled; /* = 0 */
int pnpbios_dont_use_current_config; /* = 0 */
static int pnpbios_disabled; /* = 0 */
int pnpbios_dont_use_current_config; /* = 0 */
#ifndef MODULE
static int __init pnpbios_setup(char *str)
@@ -422,9 +428,9 @@ static int __init pnpbios_setup(char *str)
while ((str != NULL) && (*str != '\0')) {
if (strncmp(str, "off", 3) == 0)
pnpbios_disabled=1;
pnpbios_disabled = 1;
if (strncmp(str, "on", 2) == 0)
pnpbios_disabled=0;
pnpbios_disabled = 0;
invert = (strncmp(str, "no-", 3) == 0);
if (invert)
str += 3;
@@ -453,35 +459,41 @@ static int __init pnpbios_probe_system(void)
printk(KERN_INFO "PnPBIOS: Scanning system for PnP BIOS support...\n");
/*
* Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS
* Search the defined area (0xf0000-0xffff0) for a valid PnP BIOS
* structure and, if one is found, sets up the selectors and
* entry points
*/
for (check = (union pnp_bios_install_struct *) __va(0xf0000);
check < (union pnp_bios_install_struct *) __va(0xffff0);
for (check = (union pnp_bios_install_struct *)__va(0xf0000);
check < (union pnp_bios_install_struct *)__va(0xffff0);
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",
check->fields.version >> 4, check->fields.version & 15,
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);
pnp_bios_install = check;
@@ -499,25 +511,25 @@ static int __init exploding_pnp_bios(struct dmi_system_id *d)
}
static struct dmi_system_id pnpbios_dmi_table[] __initdata = {
{ /* PnPBIOS GPF on boot */
.callback = exploding_pnp_bios,
.ident = "Higraded P14H",
.matches = {
DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
DMI_MATCH(DMI_BIOS_VERSION, "07.00T"),
DMI_MATCH(DMI_SYS_VENDOR, "Higraded"),
DMI_MATCH(DMI_PRODUCT_NAME, "P14H"),
},
},
{ /* PnPBIOS GPF on boot */
.callback = exploding_pnp_bios,
.ident = "ASUS P4P800",
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
DMI_MATCH(DMI_BOARD_NAME, "P4P800"),
},
},
{ }
{ /* PnPBIOS GPF on boot */
.callback = exploding_pnp_bios,
.ident = "Higraded P14H",
.matches = {
DMI_MATCH(DMI_BIOS_VENDOR, "American Megatrends Inc."),
DMI_MATCH(DMI_BIOS_VERSION, "07.00T"),
DMI_MATCH(DMI_SYS_VENDOR, "Higraded"),
DMI_MATCH(DMI_PRODUCT_NAME, "P14H"),
},
},
{ /* PnPBIOS GPF on boot */
.callback = exploding_pnp_bios,
.ident = "ASUS P4P800",
.matches = {
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc."),
DMI_MATCH(DMI_BOARD_NAME, "P4P800"),
},
},
{}
};
static int __init pnpbios_init(void)
@@ -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;
}
drivers/pnp/pnpbios/proc.c
+56 -46
View File
@@ -37,42 +37,37 @@ static struct proc_dir_entry *proc_pnp = NULL;
static struct proc_dir_entry *proc_pnp_boot = NULL;
static int proc_read_pnpconfig(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
struct pnp_isa_config_struc pnps;
if (pnp_bios_isapnp_config(&pnps))
return -EIO;
return snprintf(buf, count,
"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
);
"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);
}
static int proc_read_escdinfo(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
struct escd_info_struc escd;
if (pnp_bios_escd_info(&escd))
return -EIO;
return snprintf(buf, count,
"min_ESCD_write_size %d\n"
"ESCD_size %d\n"
"NVRAM_base 0x%x\n",
escd.min_escd_write_size,
escd.escd_size,
escd.nv_storage_base
);
"min_ESCD_write_size %d\n"
"ESCD_size %d\n"
"NVRAM_base 0x%x\n",
escd.min_escd_write_size,
escd.escd_size, escd.nv_storage_base);
}
#define MAX_SANE_ESCD_SIZE (32*1024)
static int proc_read_escd(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
struct escd_info_struc escd;
char *tmpbuf;
@@ -83,30 +78,36 @@ 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;
n = min(count,escd_left_to_read);
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);
*start = buf;
@@ -114,17 +115,17 @@ static int proc_read_escd(char *buf, char **start, off_t pos,
}
static int proc_read_legacyres(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
/* Assume that the following won't overflow the buffer */
if (pnp_bios_get_stat_res(buf))
if (pnp_bios_get_stat_res(buf))
return -EIO;
return count; // FIXME: Return actual length
return count; // FIXME: Return actual length
}
static int proc_read_devices(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
struct pnp_bios_node *node;
u8 nodenum;
@@ -134,9 +135,10 @@ 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; ) {
for (nodenum = pos; nodenum < 0xff;) {
u8 thisnodenum = nodenum;
/* 26 = the number of characters per line sprintf'ed */
if ((p - buf + 26) > count)
@@ -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;
}
@@ -156,12 +162,12 @@ static int proc_read_devices(char *buf, char **start, off_t pos,
kfree(node);
if (nodenum == 0xff)
*eof = 1;
*start = (char *)((off_t)nodenum - pos);
*start = (char *)((off_t) nodenum - pos);
return p - buf;
}
static int proc_read_node(char *buf, char **start, off_t pos,
int count, int *eof, void *data)
int count, int *eof, void *data)
{
struct pnp_bios_node *node;
int boot = (long)data >> 8;
@@ -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;
@@ -180,8 +187,8 @@ static int proc_read_node(char *buf, char **start, off_t pos,
return len;
}
static int proc_write_node(struct file *file, const char __user *buf,
unsigned long count, void *data)
static int proc_write_node(struct file *file, const char __user * buf,
unsigned long count, void *data)
{
struct pnp_bios_node *node;
int boot = (long)data >> 8;
@@ -208,12 +215,12 @@ static int proc_write_node(struct file *file, const char __user *buf,
goto out;
}
ret = count;
out:
out:
kfree(node);
return ret;
}
int pnpbios_interface_attach_device(struct pnp_bios_node * node)
int pnpbios_interface_attach_device(struct pnp_bios_node *node)
{
char name[3];
struct proc_dir_entry *ent;
@@ -222,7 +229,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node * node)
if (!proc_pnp)
return -EIO;
if ( !pnpbios_dont_use_current_config ) {
if (!pnpbios_dont_use_current_config) {
ent = create_proc_entry(name, 0, proc_pnp);
if (ent) {
ent->read_proc = proc_read_node;
@@ -237,7 +244,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node * node)
if (ent) {
ent->read_proc = proc_read_node;
ent->write_proc = proc_write_node;
ent->data = (void *)(long)(node->handle+0x100);
ent->data = (void *)(long)(node->handle + 0x100);
return 0;
}
@@ -249,7 +256,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node * node)
* work and the pnpbios_dont_use_current_config flag
* should already have been set to the appropriate value
*/
int __init pnpbios_proc_init( void )
int __init pnpbios_proc_init(void)
{
proc_pnp = proc_mkdir("pnp", proc_bus);
if (!proc_pnp)
@@ -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;
}
@@ -274,9 +284,9 @@ void __exit pnpbios_proc_exit(void)
if (!proc_pnp)
return;
for (i=0; i<0xff; i++) {
for (i = 0; i < 0xff; i++) {
sprintf(name, "%02x", i);
if ( !pnpbios_dont_use_current_config )
if (!pnpbios_dont_use_current_config)
remove_proc_entry(name, proc_pnp);
remove_proc_entry(name, proc_pnp_boot);
}
drivers/pnp/pnpbios/rsparser.c
+157 -121
View File
File diff suppressed because it is too large Load Diff
drivers/pnp/quirks.c
+39 -40
View File
@@ -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;
@@ -31,7 +30,7 @@ static void quirk_awe32_resources(struct pnp_dev *dev)
* two extra ports (at offset 0x400 and 0x800 from the one given) by
* hand.
*/
for ( ; res ; res = res->next ) {
for (; res; res = res->next) {
port2 = pnp_alloc(sizeof(struct pnp_port));
if (!port2)
return;
@@ -58,18 +57,19 @@ static void quirk_cmi8330_resources(struct pnp_dev *dev)
struct pnp_option *res = dev->dependent;
unsigned long tmp;
for ( ; res ; res = res->next ) {
for (; res; res = res->next) {
struct pnp_irq *irq;
struct pnp_dma *dma;
for( irq = res->irq; irq; irq = irq->next ) { // Valid irqs are 5, 7, 10
for (irq = res->irq; irq; irq = irq->next) { // Valid irqs are 5, 7, 10
tmp = 0x04A0;
bitmap_copy(irq->map, &tmp, 16); // 0000 0100 1010 0000
}
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 )
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)
dma->map = 0x000A;
}
printk(KERN_INFO "pnp: CMI8330 quirk - fixing interrupts and dma\n");
@@ -79,7 +79,7 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev)
{
struct pnp_port *port;
struct pnp_option *res = dev->dependent;
int changed = 0;
int changed = 0;
/*
* The default range on the mpu port for these devices is 0x388-0x388.
@@ -87,23 +87,24 @@ static void quirk_sb16audio_resources(struct pnp_dev *dev)
* auto-configured.
*/
for( ; res ; res = res->next ) {
for (; res; res = res->next) {
port = res->port;
if(!port)
if (!port)
continue;
port = port->next;
if(!port)
if (!port)
continue;
port = port->next;
if(!port)
if (!port)
continue;
if(port->min != port->max)
if (port->min != port->max)
continue;
port->max += 0x70;
changed = 1;
}
if(changed)
printk(KERN_INFO "pnp: SB audio device quirk - increasing port range\n");
if (changed)
printk(KERN_INFO
"pnp: SB audio device quirk - increasing port range\n");
return;
}
@@ -124,7 +125,7 @@ static int quirk_smc_fir_enabled(struct pnp_dev *dev)
outb(bank, firbase + 7);
high = inb(firbase + 0);
low = inb(firbase + 1);
low = inb(firbase + 1);
chip = inb(firbase + 2);
/* This corresponds to the check in smsc_ircc_present() */
@@ -153,8 +154,8 @@ static void quirk_smc_enable(struct pnp_dev *dev)
*/
dev_err(&dev->dev, "%s not responding at SIR 0x%lx, FIR 0x%lx; "
"auto-configuring\n", dev->id->id,
(unsigned long) pnp_port_start(dev, 0),
(unsigned long) pnp_port_start(dev, 1));
(unsigned long)pnp_port_start(dev, 0),
(unsigned long)pnp_port_start(dev, 1));
pnp_disable_dev(dev);
pnp_init_resource_table(&dev->res);
@@ -162,8 +163,8 @@ static void quirk_smc_enable(struct pnp_dev *dev)
pnp_activate_dev(dev);
if (quirk_smc_fir_enabled(dev)) {
dev_err(&dev->dev, "responds at SIR 0x%lx, FIR 0x%lx\n",
(unsigned long) pnp_port_start(dev, 0),
(unsigned long) pnp_port_start(dev, 1));
(unsigned long)pnp_port_start(dev, 0),
(unsigned long)pnp_port_start(dev, 1));
return;
}
@@ -175,8 +176,8 @@ static void quirk_smc_enable(struct pnp_dev *dev)
*/
dev_err(&dev->dev, "not responding at SIR 0x%lx, FIR 0x%lx; "
"swapping SIR/FIR and reconfiguring\n",
(unsigned long) pnp_port_start(dev, 0),
(unsigned long) pnp_port_start(dev, 1));
(unsigned long)pnp_port_start(dev, 0),
(unsigned long)pnp_port_start(dev, 1));
/*
* Clear IORESOURCE_AUTO so pnp_activate_dev() doesn't reassign
@@ -200,8 +201,8 @@ static void quirk_smc_enable(struct pnp_dev *dev)
if (quirk_smc_fir_enabled(dev)) {
dev_err(&dev->dev, "responds at SIR 0x%lx, FIR 0x%lx\n",
(unsigned long) pnp_port_start(dev, 0),
(unsigned long) pnp_port_start(dev, 1));
(unsigned long)pnp_port_start(dev, 0),
(unsigned long)pnp_port_start(dev, 1));
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
@@ -217,21 +217,21 @@ static void quirk_smc_enable(struct pnp_dev *dev)
static struct pnp_fixup pnp_fixups[] = {
/* Soundblaster awe io port quirk */
{ "CTL0021", quirk_awe32_resources },
{ "CTL0022", quirk_awe32_resources },
{ "CTL0023", quirk_awe32_resources },
{"CTL0021", quirk_awe32_resources},
{"CTL0022", quirk_awe32_resources},
{"CTL0023", quirk_awe32_resources},
/* CMI 8330 interrupt and dma fix */
{ "@X@0001", quirk_cmi8330_resources },
{"@X@0001", quirk_cmi8330_resources},
/* Soundblaster audio device io port range quirk */
{ "CTL0001", quirk_sb16audio_resources },
{ "CTL0031", quirk_sb16audio_resources },
{ "CTL0041", quirk_sb16audio_resources },
{ "CTL0042", quirk_sb16audio_resources },
{ "CTL0043", quirk_sb16audio_resources },
{ "CTL0044", quirk_sb16audio_resources },
{ "CTL0045", quirk_sb16audio_resources },
{ "SMCf010", quirk_smc_enable },
{ "" }
{"CTL0001", quirk_sb16audio_resources},
{"CTL0031", quirk_sb16audio_resources},
{"CTL0041", quirk_sb16audio_resources},
{"CTL0042", quirk_sb16audio_resources},
{"CTL0043", quirk_sb16audio_resources},
{"CTL0044", quirk_sb16audio_resources},
{"CTL0045", quirk_sb16audio_resources},
{"SMCf010", quirk_smc_enable},
{""}
};
void pnp_fixup_device(struct pnp_dev *dev)
@@ -239,9 +239,8 @@ void pnp_fixup_device(struct pnp_dev *dev)
int i = 0;
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);
if (compare_pnp_id(dev->id, pnp_fixups[i].id)) {
pnp_dbg("Calling quirk for %s", dev->dev.bus_id);
pnp_fixups[i].quirk_function(dev);
}
i++;
drivers/pnp/resource.c
+40 -39
View File
@@ -20,17 +20,16 @@
#include <linux/pnp.h>
#include "base.h"
static int pnp_reserve_irq[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some IRQ */
static int pnp_reserve_dma[8] = { [0 ... 7] = -1 }; /* reserve (don't use) some DMA */
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 */
static int pnp_reserve_irq[16] = {[0...15] = -1 }; /* reserve (don't use) some IRQ */
static int pnp_reserve_dma[8] = {[0...7] = -1 }; /* reserve (don't use) some DMA */
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
*/
static struct pnp_option * pnp_build_option(int priority)
static struct pnp_option *pnp_build_option(int priority)
{
struct pnp_option *option = pnp_alloc(sizeof(struct pnp_option));
@@ -46,7 +45,7 @@ static struct pnp_option * pnp_build_option(int priority)
return option;
}
struct pnp_option * pnp_register_independent_option(struct pnp_dev *dev)
struct pnp_option *pnp_register_independent_option(struct pnp_dev *dev)
{
struct pnp_option *option;
if (!dev)
@@ -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
*/
@@ -236,7 +235,7 @@ void pnp_free_option(struct pnp_option *option)
#define cannot_compare(flags) \
((flags) & (IORESOURCE_UNSET | IORESOURCE_DISABLED))
int pnp_check_port(struct pnp_dev * dev, int idx)
int pnp_check_port(struct pnp_dev *dev, int idx)
{
int tmp;
struct pnp_dev *tdev;
@@ -250,8 +249,8 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
/* check if the resource is already in use, skip if the
* device is active because it itself may be in use */
if(!dev->active) {
if (__check_region(&ioport_resource, *port, length(port,end)))
if (!dev->active) {
if (__check_region(&ioport_resource, *port, length(port, end)))
return 0;
}
@@ -259,7 +258,7 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
for (tmp = 0; tmp < 8; tmp++) {
int rport = pnp_reserve_io[tmp << 1];
int rend = pnp_reserve_io[(tmp << 1) + 1] + rport - 1;
if (ranged_conflict(port,end,&rport,&rend))
if (ranged_conflict(port, end, &rport, &rend))
return 0;
}
@@ -268,7 +267,7 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
if (dev->res.port_resource[tmp].flags & IORESOURCE_IO) {
tport = &dev->res.port_resource[tmp].start;
tend = &dev->res.port_resource[tmp].end;
if (ranged_conflict(port,end,tport,tend))
if (ranged_conflict(port, end, tport, tend))
return 0;
}
}
@@ -279,11 +278,12 @@ 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;
if (ranged_conflict(port,end,tport,tend))
if (ranged_conflict(port, end, tport, tend))
return 0;
}
}
@@ -292,7 +292,7 @@ int pnp_check_port(struct pnp_dev * dev, int idx)
return 1;
}
int pnp_check_mem(struct pnp_dev * dev, int idx)
int pnp_check_mem(struct pnp_dev *dev, int idx)
{
int tmp;
struct pnp_dev *tdev;
@@ -306,8 +306,8 @@ int pnp_check_mem(struct pnp_dev * dev, int idx)
/* check if the resource is already in use, skip if the
* device is active because it itself may be in use */
if(!dev->active) {
if (check_mem_region(*addr, length(addr,end)))
if (!dev->active) {
if (check_mem_region(*addr, length(addr, end)))
return 0;
}
@@ -315,7 +315,7 @@ int pnp_check_mem(struct pnp_dev * dev, int idx)
for (tmp = 0; tmp < 8; tmp++) {
int raddr = pnp_reserve_mem[tmp << 1];
int rend = pnp_reserve_mem[(tmp << 1) + 1] + raddr - 1;
if (ranged_conflict(addr,end,&raddr,&rend))
if (ranged_conflict(addr, end, &raddr, &rend))
return 0;
}
@@ -324,7 +324,7 @@ int pnp_check_mem(struct pnp_dev * dev, int idx)
if (dev->res.mem_resource[tmp].flags & IORESOURCE_MEM) {
taddr = &dev->res.mem_resource[tmp].start;
tend = &dev->res.mem_resource[tmp].end;
if (ranged_conflict(addr,end,taddr,tend))
if (ranged_conflict(addr, end, taddr, tend))
return 0;
}
}
@@ -335,11 +335,12 @@ 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;
if (ranged_conflict(addr,end,taddr,tend))
if (ranged_conflict(addr, end, taddr, tend))
return 0;
}
}
@@ -353,11 +354,11 @@ static irqreturn_t pnp_test_handler(int irq, void *dev_id)
return IRQ_HANDLED;
}
int pnp_check_irq(struct pnp_dev * dev, int idx)
int pnp_check_irq(struct pnp_dev *dev, int idx)
{
int tmp;
struct pnp_dev *tdev;
resource_size_t * irq = &dev->res.irq_resource[idx].start;
resource_size_t *irq = &dev->res.irq_resource[idx].start;
/* if the resource doesn't exist, don't complain about it */
if (cannot_compare(dev->res.irq_resource[idx].flags))
@@ -394,9 +395,9 @@ int pnp_check_irq(struct pnp_dev * dev, int idx)
/* check if the resource is already in use, skip if the
* device is active because it itself may be in use */
if(!dev->active) {
if (!dev->active) {
if (request_irq(*irq, pnp_test_handler,
IRQF_DISABLED|IRQF_PROBE_SHARED, "pnp", NULL))
IRQF_DISABLED | IRQF_PROBE_SHARED, "pnp", NULL))
return 0;
free_irq(*irq, NULL);
}
@@ -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;
@@ -418,12 +420,12 @@ int pnp_check_irq(struct pnp_dev * dev, int idx)
return 1;
}
int pnp_check_dma(struct pnp_dev * dev, int idx)
int pnp_check_dma(struct pnp_dev *dev, int idx)
{
#ifndef CONFIG_IA64
int tmp;
struct pnp_dev *tdev;
resource_size_t * dma = &dev->res.dma_resource[idx].start;
resource_size_t *dma = &dev->res.dma_resource[idx].start;
/* if the resource doesn't exist, don't complain about it */
if (cannot_compare(dev->res.dma_resource[idx].flags))
@@ -449,7 +451,7 @@ int pnp_check_dma(struct pnp_dev * dev, int idx)
/* check if the resource is already in use, skip if the
* device is active because it itself may be in use */
if(!dev->active) {
if (!dev->active) {
if (request_dma(*dma, "pnp"))
return 0;
free_dma(*dma);
@@ -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);
@@ -484,8 +486,7 @@ EXPORT_SYMBOL(pnp_register_irq_resource);
EXPORT_SYMBOL(pnp_register_dma_resource);
EXPORT_SYMBOL(pnp_register_port_resource);
EXPORT_SYMBOL(pnp_register_mem_resource);
#endif /* 0 */
#endif /* 0 */
/* format is: pnp_reserve_irq=irq1[,irq2] .... */
@@ -494,7 +495,7 @@ static int __init pnp_setup_reserve_irq(char *str)
int i;
for (i = 0; i < 16; i++)
if (get_option(&str,&pnp_reserve_irq[i]) != 2)
if (get_option(&str, &pnp_reserve_irq[i]) != 2)
break;
return 1;
}
@@ -508,7 +509,7 @@ static int __init pnp_setup_reserve_dma(char *str)
int i;
for (i = 0; i < 8; i++)
if (get_option(&str,&pnp_reserve_dma[i]) != 2)
if (get_option(&str, &pnp_reserve_dma[i]) != 2)
break;
return 1;
}
@@ -522,7 +523,7 @@ static int __init pnp_setup_reserve_io(char *str)
int i;
for (i = 0; i < 16; i++)
if (get_option(&str,&pnp_reserve_io[i]) != 2)
if (get_option(&str, &pnp_reserve_io[i]) != 2)
break;
return 1;
}
@@ -536,7 +537,7 @@ static int __init pnp_setup_reserve_mem(char *str)
int i;
for (i = 0; i < 16; i++)
if (get_option(&str,&pnp_reserve_mem[i]) != 2)
if (get_option(&str, &pnp_reserve_mem[i]) != 2)
break;
return 1;
}
drivers/pnp/support.c
+3 -6
View File
@@ -16,17 +16,14 @@
*
*/
int pnp_is_active(struct pnp_dev * dev)
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)
return 0;
pnp_irq(dev, 0) == -1 && pnp_dma(dev, 0) == -1)
return 0;
else
return 1;
}
EXPORT_SYMBOL(pnp_is_active);
drivers/pnp/system.c
+20 -18
View File
@@ -16,13 +16,14 @@
static const struct pnp_device_id pnp_dev_table[] = {
/* General ID for reserving resources */
{ "PNP0c02", 0 },
{"PNP0c02", 0},
/* memory controller */
{ "PNP0c01", 0 },
{ "", 0 }
{"PNP0c01", 0},
{"", 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;
@@ -32,9 +33,9 @@ static void reserve_range(const char *pnpid, resource_size_t start, resource_siz
return;
snprintf(regionid, 16, "pnp %s", pnpid);
if (port)
res = request_region(start, end-start+1, regionid);
res = request_region(start, end - start + 1, regionid);
else
res = request_mem_region(start, end-start+1, regionid);
res = request_mem_region(start, end - start + 1, regionid);
if (res == NULL)
kfree(regionid);
else
@@ -45,10 +46,10 @@ static void reserve_range(const char *pnpid, resource_size_t start, resource_siz
* have double reservations.
*/
printk(KERN_INFO
"pnp: %s: %s range 0x%llx-0x%llx %s reserved\n",
pnpid, port ? "ioport" : "iomem",
(unsigned long long)start, (unsigned long long)end,
NULL != res ? "has been" : "could not be");
"pnp: %s: %s range 0x%llx-0x%llx %s reserved\n",
pnpid, port ? "ioport" : "iomem",
(unsigned long long)start, (unsigned long long)end,
NULL != res ? "has been" : "could not be");
}
static void reserve_resources_of_dev(const struct pnp_dev *dev)
@@ -74,7 +75,7 @@ static void reserve_resources_of_dev(const struct pnp_dev *dev)
continue; /* invalid */
reserve_range(dev->dev.bus_id, pnp_port_start(dev, i),
pnp_port_end(dev, i), 1);
pnp_port_end(dev, i), 1);
}
for (i = 0; i < PNP_MAX_MEM; i++) {
@@ -82,24 +83,25 @@ static void reserve_resources_of_dev(const struct pnp_dev *dev)
continue;
reserve_range(dev->dev.bus_id, pnp_mem_start(dev, i),
pnp_mem_end(dev, i), 0);
pnp_mem_end(dev, i), 0);
}
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;
}
static struct pnp_driver system_pnp_driver = {
.name = "system",
.id_table = pnp_dev_table,
.flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
.probe = system_pnp_probe,
.remove = NULL,
.name = "system",
.id_table = pnp_dev_table,
.flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
.probe = system_pnp_probe,
.remove = NULL,
};
static int __init pnp_system_init(void)
include/linux/pnp.h
+236 -127
View File
File diff suppressed because it is too large Load Diff
include/linux/pnpbios.h
+32 -30
View File
@@ -99,32 +99,32 @@
#pragma pack(1)
struct pnp_dev_node_info {
__u16 no_nodes;
__u16 max_node_size;
__u16 no_nodes;
__u16 max_node_size;
};
struct pnp_docking_station_info {
__u32 location_id;
__u32 serial;
__u16 capabilities;
__u32 location_id;
__u32 serial;
__u16 capabilities;
};
struct pnp_isa_config_struc {
__u8 revision;
__u8 no_csns;
__u16 isa_rd_data_port;
__u16 reserved;
__u8 revision;
__u8 no_csns;
__u16 isa_rd_data_port;
__u16 reserved;
};
struct escd_info_struc {
__u16 min_escd_write_size;
__u16 escd_size;
__u32 nv_storage_base;
__u16 min_escd_write_size;
__u16 escd_size;
__u32 nv_storage_base;
};
struct pnp_bios_node {
__u16 size;
__u8 handle;
__u32 eisa_id;
__u8 type_code[3];
__u16 flags;
__u8 data[0];
__u16 size;
__u8 handle;
__u32 eisa_id;
__u8 type_code[3];
__u16 flags;
__u8 data[0];
};
#pragma pack()
@@ -133,21 +133,23 @@ struct pnp_bios_node {
/* non-exported */
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_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);
extern int pnp_bios_read_escd (char *data, u32 nvram_base);
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_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);
extern int pnp_bios_read_escd(char *data, u32 nvram_base);
extern int pnp_bios_dock_station_info(struct pnp_docking_station_info *data);
#define needed 0
#if needed
extern int pnp_bios_get_event (u16 *message);
extern int pnp_bios_send_message (u16 message);
extern int pnp_bios_set_stat_res (char *info);
extern int pnp_bios_apm_id_table (char *table, u16 *size);
extern int pnp_bios_write_escd (char *data, u32 nvram_base);
extern int pnp_bios_get_event(u16 * message);
extern int pnp_bios_send_message(u16 message);
extern int pnp_bios_set_stat_res(char *info);
extern int pnp_bios_apm_id_table(char *table, u16 * size);
extern int pnp_bios_write_escd(char *data, u32 nvram_base);
#endif
#endif /* CONFIG_PNPBIOS */