1 files changed, 168 insertions, 172 deletions

diff --git a/drivers/pnp/isapnp/core.c b/drivers/pnp/isapnp/core.c
index 257f5d827d83..f1bccdbdeb08 100644
--- a/drivers/pnp/isapnp/core.c
+++ b/drivers/pnp/isapnp/core.c
@@ -44,6 +44,8 @@
 #include <linux/mutex.h>
 #include <asm/io.h>
 
+#include "../base.h"
+
 #if 0
 #define ISAPNP_REGION_OK
 #endif
@@ -88,6 +90,14 @@ MODULE_LICENSE("GPL");
 #define _LTAG_MEM32RANGE        0x85
 #define _LTAG_FIXEDMEM32RANGE   0x86
 
+/* Logical device control and configuration registers */
+
+#define ISAPNP_CFG_ACTIVATE     0x30    /* byte */
+#define ISAPNP_CFG_MEM          0x40    /* 4 * dword */
+#define ISAPNP_CFG_PORT         0x60    /* 8 * word */
+#define ISAPNP_CFG_IRQ          0x70    /* 2 * word */
+#define ISAPNP_CFG_DMA          0x74    /* 2 * byte */
+
 /*
  * Sizes of ISAPNP logical device configuration register sets.
  * See PNP-ISA-v1.0a.pdf, Appendix A.
@@ -388,28 +398,6 @@ static void __init isapnp_skip_bytes(int count)
 }
 
 /*
- *  Parse EISA id.
- */
-static void isapnp_parse_id(struct pnp_dev *dev, unsigned short vendor,
-                            unsigned short device)
-{
-        struct pnp_id *id;
-
-        if (!dev)
-                return;
-        id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
-        if (!id)
-                return;
-        sprintf(id->id, "%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);
-        pnp_add_id(id, dev);
-}
-
-/*
  *  Parse logical device tag.
  */
 static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
@@ -417,30 +405,31 @@ static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
 {
         unsigned char tmp[6];
         struct pnp_dev *dev;
+        u32 eisa_id;
+        char id[8];
 
         isapnp_peek(tmp, size);
-        dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
+        eisa_id = tmp[0] | tmp[1] << 8 | tmp[2] << 16 | tmp[3] << 24;
+        pnp_eisa_id_to_string(eisa_id, id);
+
+        dev = pnp_alloc_dev(&isapnp_protocol, number, id);
         if (!dev)
                 return NULL;
-        dev->number = number;
-        isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0], (tmp[3] << 8) | tmp[2]);
-        dev->regs = tmp[4];
+
         dev->card = card;
-        if (size > 5)
-                dev->regs |= tmp[5] << 8;
-        dev->protocol = &isapnp_protocol;
         dev->capabilities |= PNP_CONFIGURABLE;
         dev->capabilities |= PNP_READ;
         dev->capabilities |= PNP_WRITE;
         dev->capabilities |= PNP_DISABLE;
-        pnp_init_resource_table(&dev->res);
+        pnp_init_resources(dev);
         return dev;
 }
 
 /*
  *  Add IRQ resource to resources list.
  */
-static void __init isapnp_parse_irq_resource(struct pnp_option *option,
+static void __init isapnp_parse_irq_resource(struct pnp_dev *dev,
+                                             struct pnp_option *option,
                                              int size)
 {
         unsigned char tmp[3];
@@ -457,13 +446,14 @@ static void __init isapnp_parse_irq_resource(struct pnp_option *option,
                 irq->flags = tmp[2];
         else
                 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
-        pnp_register_irq_resource(option, irq);
+        pnp_register_irq_resource(dev, option, irq);
 }
 
 /*
  *  Add DMA resource to resources list.
  */
-static void __init isapnp_parse_dma_resource(struct pnp_option *option,
+static void __init isapnp_parse_dma_resource(struct pnp_dev *dev,
+                                             struct pnp_option *option,
                                              int size)
 {
         unsigned char tmp[2];
@@ -475,13 +465,14 @@ static void __init isapnp_parse_dma_resource(struct pnp_option *option,
                 return;
         dma->map = tmp[0];
         dma->flags = tmp[1];
-        pnp_register_dma_resource(option, dma);
+        pnp_register_dma_resource(dev, option, dma);
 }
 
 /*
  *  Add port resource to resources list.
  */
-static void __init isapnp_parse_port_resource(struct pnp_option *option,
+static void __init isapnp_parse_port_resource(struct pnp_dev *dev,
+                                              struct pnp_option *option,
                                               int size)
 {
         unsigned char tmp[7];
@@ -496,13 +487,14 @@ static void __init isapnp_parse_port_resource(struct pnp_option *option,
         port->align = tmp[5];
         port->size = tmp[6];
         port->flags = tmp[0] ? PNP_PORT_FLAG_16BITADDR : 0;
-        pnp_register_port_resource(option, port);
+        pnp_register_port_resource(dev, option, port);
 }
 
 /*
  *  Add fixed port resource to resources list.
  */
-static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option,
+static void __init isapnp_parse_fixed_port_resource(struct pnp_dev *dev,
+                                                    struct pnp_option *option,
                                                     int size)
 {
         unsigned char tmp[3];
@@ -516,13 +508,14 @@ static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option,
         port->size = tmp[2];
         port->align = 0;
         port->flags = PNP_PORT_FLAG_FIXED;
-        pnp_register_port_resource(option, port);
+        pnp_register_port_resource(dev, option, port);
 }
 
 /*
  *  Add memory resource to resources list.
  */
-static void __init isapnp_parse_mem_resource(struct pnp_option *option,
+static void __init isapnp_parse_mem_resource(struct pnp_dev *dev,
+                                             struct pnp_option *option,
                                              int size)
 {
         unsigned char tmp[9];
@@ -537,13 +530,14 @@ static void __init isapnp_parse_mem_resource(struct pnp_option *option,
         mem->align = (tmp[6] << 8) | tmp[5];
         mem->size = ((tmp[8] << 8) | tmp[7]) << 8;
         mem->flags = tmp[0];
-        pnp_register_mem_resource(option, mem);
+        pnp_register_mem_resource(dev, option, mem);
 }
 
 /*
  *  Add 32-bit memory resource to resources list.
  */
-static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
+static void __init isapnp_parse_mem32_resource(struct pnp_dev *dev,
+                                               struct pnp_option *option,
                                                int size)
 {
         unsigned char tmp[17];
@@ -560,13 +554,14 @@ static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
         mem->size =
             (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
         mem->flags = tmp[0];
-        pnp_register_mem_resource(option, mem);
+        pnp_register_mem_resource(dev, option, mem);
 }
 
 /*
  *  Add 32-bit fixed memory resource to resources list.
  */
-static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
+static void __init isapnp_parse_fixed_mem32_resource(struct pnp_dev *dev,
+                                                     struct pnp_option *option,
                                                      int size)
 {
         unsigned char tmp[9];
@@ -581,7 +576,7 @@ static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
         mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
         mem->align = 0;
         mem->flags = tmp[0];
-        pnp_register_mem_resource(option, mem);
+        pnp_register_mem_resource(dev, option, mem);
 }
 
 /*
@@ -613,6 +608,8 @@ static int __init isapnp_create_device(struct pnp_card *card,
         unsigned char type, tmp[17];
         struct pnp_option *option;
         struct pnp_dev *dev;
+        u32 eisa_id;
+        char id[8];
 
         if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
                 return 1;
@@ -652,8 +649,10 @@ static int __init isapnp_create_device(struct pnp_card *card,
                 case _STAG_COMPATDEVID:
                         if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
                                 isapnp_peek(tmp, 4);
-                                isapnp_parse_id(dev, (tmp[1] << 8) | tmp[0],
-                                                (tmp[3] << 8) | tmp[2]);
+                                eisa_id = tmp[0] | tmp[1] << 8 |
+                                          tmp[2] << 16 | tmp[3] << 24;
+                                pnp_eisa_id_to_string(eisa_id, id);
+                                pnp_add_id(dev, id);
                                 compat++;
                                 size = 0;
                         }
@@ -661,13 +660,13 @@ static int __init isapnp_create_device(struct pnp_card *card,
                 case _STAG_IRQ:
                         if (size < 2 || size > 3)
                                 goto __skip;
-                        isapnp_parse_irq_resource(option, size);
+                        isapnp_parse_irq_resource(dev, option, size);
                         size = 0;
                         break;
                 case _STAG_DMA:
                         if (size != 2)
                                 goto __skip;
-                        isapnp_parse_dma_resource(option, size);
+                        isapnp_parse_dma_resource(dev, option, size);
                         size = 0;
                         break;
                 case _STAG_STARTDEP:
@@ -687,17 +686,18 @@ static int __init isapnp_create_device(struct pnp_card *card,
                         if (size != 0)
                                 goto __skip;
                         priority = 0;
+                        dev_dbg(&dev->dev, "end dependent options\n");
                         break;
                 case _STAG_IOPORT:
                         if (size != 7)
                                 goto __skip;
-                        isapnp_parse_port_resource(option, size);
+                        isapnp_parse_port_resource(dev, option, size);
                         size = 0;
                         break;
                 case _STAG_FIXEDIO:
                         if (size != 3)
                                 goto __skip;
-                        isapnp_parse_fixed_port_resource(option, size);
+                        isapnp_parse_fixed_port_resource(dev, option, size);
                         size = 0;
                         break;
                 case _STAG_VENDOR:
@@ -705,7 +705,7 @@ static int __init isapnp_create_device(struct pnp_card *card,
                 case _LTAG_MEMRANGE:
                         if (size != 9)
                                 goto __skip;
-                        isapnp_parse_mem_resource(option, size);
+                        isapnp_parse_mem_resource(dev, option, size);
                         size = 0;
                         break;
                 case _LTAG_ANSISTR:
@@ -720,13 +720,13 @@ static int __init isapnp_create_device(struct pnp_card *card,
                 case _LTAG_MEM32RANGE:
                         if (size != 17)
                                 goto __skip;
-                        isapnp_parse_mem32_resource(option, size);
+                        isapnp_parse_mem32_resource(dev, option, size);
                         size = 0;
                         break;
                 case _LTAG_FIXEDMEM32RANGE:
                         if (size != 9)
                                 goto __skip;
-                        isapnp_parse_fixed_mem32_resource(option, size);
+                        isapnp_parse_fixed_mem32_resource(dev, option, size);
                         size = 0;
                         break;
                 case _STAG_END:
@@ -734,9 +734,8 @@ static int __init isapnp_create_device(struct pnp_card *card,
                                 isapnp_skip_bytes(size);
                         return 1;
                 default:
-                        printk(KERN_ERR
-                               "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n",
-                               type, dev->number, card->number);
+                        dev_err(&dev->dev, "unknown tag %#x (card %i), "
+                                "ignored\n", type, card->number);
                 }
 __skip:
                 if (size > 0)
@@ -789,9 +788,8 @@ static void __init isapnp_parse_resource_map(struct pnp_card *card)
                                 isapnp_skip_bytes(size);
                         return;
                 default:
-                        printk(KERN_ERR
-                               "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n",
-                               type, card->number);
+                        dev_err(&card->dev, "unknown tag %#x, ignored\n",
+                               type);
                 }
 __skip:
                 if (size > 0)
@@ -822,25 +820,6 @@ static unsigned char __init isapnp_checksum(unsigned char *data)
 }
 
 /*
- *  Parse EISA id for ISA PnP card.
- */
-static void isapnp_parse_card_id(struct pnp_card *card, unsigned short vendor,
-                                 unsigned short device)
-{
-        struct pnp_id *id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
-
-        if (!id)
-                return;
-        sprintf(id->id, "%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);
-        pnp_add_card_id(id, card);
-}
-
-/*
  *  Build device list for all present ISA PnP devices.
  */
 static int __init isapnp_build_device_list(void)
@@ -848,6 +827,8 @@ static int __init isapnp_build_device_list(void)
         int csn;
         unsigned char header[9], checksum;
         struct pnp_card *card;
+        u32 eisa_id;
+        char id[8];
 
         isapnp_wait();
         isapnp_key();
@@ -855,32 +836,30 @@ static int __init isapnp_build_device_list(void)
                 isapnp_wake(csn);
                 isapnp_peek(header, 9);
                 checksum = isapnp_checksum(header);
+                eisa_id = header[0] | header[1] << 8 |
+                          header[2] << 16 | header[3] << 24;
+                pnp_eisa_id_to_string(eisa_id, id);
+                card = pnp_alloc_card(&isapnp_protocol, csn, id);
+                if (!card)
+                        continue;
+
 #if 0
-                printk(KERN_DEBUG
+                dev_info(&card->dev,
                        "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
                        header[0], header[1], header[2], header[3], header[4],
                        header[5], header[6], header[7], header[8]);
-                printk(KERN_DEBUG "checksum = 0x%x\n", checksum);
+                dev_info(&card->dev, "checksum = %#x\n", checksum);
 #endif
-                if ((card =
-                     kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
-                        continue;
-
-                card->number = csn;
                 INIT_LIST_HEAD(&card->devices);
-                isapnp_parse_card_id(card, (header[1] << 8) | header[0],
-                                     (header[3] << 8) | header[2]);
                 card->serial =
                     (header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
                     header[4];
                 isapnp_checksum_value = 0x00;
                 isapnp_parse_resource_map(card);
                 if (isapnp_checksum_value != 0x00)
-                        printk(KERN_ERR
-                               "isapnp: checksum for device %i is not valid (0x%x)\n",
-                               csn, isapnp_checksum_value);
+                        dev_err(&card->dev, "invalid checksum %#x\n",
+                                isapnp_checksum_value);
                 card->checksum = isapnp_checksum_value;
-                card->protocol = &isapnp_protocol;
 
                 pnp_add_card(card);
         }
@@ -947,100 +926,117 @@ EXPORT_SYMBOL(isapnp_cfg_begin);
 EXPORT_SYMBOL(isapnp_cfg_end);
 EXPORT_SYMBOL(isapnp_write_byte);
 
-static int isapnp_read_resources(struct pnp_dev *dev,
-                                 struct pnp_resource_table *res)
+static int isapnp_get_resources(struct pnp_dev *dev)
 {
-        int tmp, ret;
+        struct pnp_resource *pnp_res;
+        int i, ret;
 
+        dev_dbg(&dev->dev, "get resources\n");
+        pnp_init_resources(dev);
+        isapnp_cfg_begin(dev->card->number, dev->number);
         dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
-        if (dev->active) {
-                for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
-                        ret = isapnp_read_word(ISAPNP_CFG_PORT + (tmp << 1));
-                        if (!ret)
-                                continue;
-                        res->port_resource[tmp].start = ret;
-                        res->port_resource[tmp].flags = IORESOURCE_IO;
+        if (!dev->active)
+                goto __end;
+
+        for (i = 0; i < ISAPNP_MAX_PORT; i++) {
+                ret = isapnp_read_word(ISAPNP_CFG_PORT + (i << 1));
+                if (ret) {
+                        pnp_res = pnp_add_io_resource(dev, ret, ret, 0);
+                        if (pnp_res)
+                                pnp_res->index = i;
                 }
-                for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
-                        ret =
-                            isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
-                        if (!ret)
-                                continue;
-                        res->mem_resource[tmp].start = ret;
-                        res->mem_resource[tmp].flags = IORESOURCE_MEM;
+        }
+        for (i = 0; i < ISAPNP_MAX_MEM; i++) {
+                ret = isapnp_read_word(ISAPNP_CFG_MEM + (i << 3)) << 8;
+                if (ret) {
+                        pnp_res = pnp_add_mem_resource(dev, ret, ret, 0);
+                        if (pnp_res)
+                                pnp_res->index = i;
                 }
-                for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
-                        ret =
-                            (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >>
-                             8);
-                        if (!ret)
-                                continue;
-                        res->irq_resource[tmp].start =
-                            res->irq_resource[tmp].end = ret;
-                        res->irq_resource[tmp].flags = IORESOURCE_IRQ;
+        }
+        for (i = 0; i < ISAPNP_MAX_IRQ; i++) {
+                ret = isapnp_read_word(ISAPNP_CFG_IRQ + (i << 1)) >> 8;
+                if (ret) {
+                        pnp_res = pnp_add_irq_resource(dev, ret, 0);
+                        if (pnp_res)
+                                pnp_res->index = i;
                 }
-                for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
-                        ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp);
-                        if (ret == 4)
-                                continue;
-                        res->dma_resource[tmp].start =
-                            res->dma_resource[tmp].end = ret;
-                        res->dma_resource[tmp].flags = IORESOURCE_DMA;
+        }
+        for (i = 0; i < ISAPNP_MAX_DMA; i++) {
+                ret = isapnp_read_byte(ISAPNP_CFG_DMA + i);
+                if (ret != 4) {
+                        pnp_res = pnp_add_dma_resource(dev, ret, 0);
+                        if  (pnp_res)
+                                pnp_res->index = i;
                 }
         }
-        return 0;
-}
-
-static int isapnp_get_resources(struct pnp_dev *dev,
-                                struct pnp_resource_table *res)
-{
-        int ret;
 
-        pnp_init_resource_table(res);
-        isapnp_cfg_begin(dev->card->number, dev->number);
-        ret = isapnp_read_resources(dev, res);
+__end:
         isapnp_cfg_end();
-        return ret;
+        return 0;
 }
 
-static int isapnp_set_resources(struct pnp_dev *dev,
-                                struct pnp_resource_table *res)
+static int isapnp_set_resources(struct pnp_dev *dev)
 {
-        int tmp;
+        struct pnp_resource *pnp_res;
+        struct resource *res;
+        int tmp, index;
 
+        dev_dbg(&dev->dev, "set resources\n");
         isapnp_cfg_begin(dev->card->number, dev->number);
         dev->active = 1;
-        for (tmp = 0;
-             tmp < ISAPNP_MAX_PORT
-             && (res->port_resource[tmp].
-                 flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO;
-             tmp++)
-                isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1),
-                                  res->port_resource[tmp].start);
-        for (tmp = 0;
-             tmp < ISAPNP_MAX_IRQ
-             && (res->irq_resource[tmp].
-                 flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ;
-             tmp++) {
-                int irq = res->irq_resource[tmp].start;
-                if (irq == 2)
-                        irq = 9;
-                isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq);
+        for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
+                pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_IO, tmp);
+                if (!pnp_res)
+                        continue;
+                res = &pnp_res->res;
+                if (pnp_resource_valid(res)) {
+                        index = pnp_res->index;
+                        dev_dbg(&dev->dev, "  set io  %d to %#llx\n",
+                                index, (unsigned long long) res->start);
+                        isapnp_write_word(ISAPNP_CFG_PORT + (index << 1),
+                                          res->start);
+                }
+        }
+        for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
+                pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_IRQ, tmp);
+                if (!pnp_res)
+                        continue;
+                res = &pnp_res->res;
+                if (pnp_resource_valid(res)) {
+                        int irq = res->start;
+                        if (irq == 2)
+                                irq = 9;
+                        index = pnp_res->index;
+                        dev_dbg(&dev->dev, "  set irq %d to %d\n", index, irq);
+                        isapnp_write_byte(ISAPNP_CFG_IRQ + (index << 1), irq);
+                }
+        }
+        for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
+                pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_DMA, tmp);
+                if (!pnp_res)
+                        continue;
+                res = &pnp_res->res;
+                if (pnp_resource_valid(res)) {
+                        index = pnp_res->index;
+                        dev_dbg(&dev->dev, "  set dma %d to %lld\n",
+                                index, (unsigned long long) res->start);
+                        isapnp_write_byte(ISAPNP_CFG_DMA + index, res->start);
+                }
+        }
+        for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
+                pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_MEM, tmp);
+                if (!pnp_res)
+                        continue;
+                res = &pnp_res->res;
+                if (pnp_resource_valid(res)) {
+                        index = pnp_res->index;
+                        dev_dbg(&dev->dev, "  set mem %d to %#llx\n",
+                                index, (unsigned long long) res->start);
+                        isapnp_write_word(ISAPNP_CFG_MEM + (index << 3),
+                                          (res->start >> 8) & 0xffff);
+                }
         }
-        for (tmp = 0;
-             tmp < ISAPNP_MAX_DMA
-             && (res->dma_resource[tmp].
-                 flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA;
-             tmp++)
-                isapnp_write_byte(ISAPNP_CFG_DMA + tmp,
-                                  res->dma_resource[tmp].start);
-        for (tmp = 0;
-             tmp < ISAPNP_MAX_MEM
-             && (res->mem_resource[tmp].
-                 flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM;
-             tmp++)
-                isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3),
-                                  (res->mem_resource[tmp].start >> 8) & 0xffff);
         /* FIXME: We aren't handling 32bit mems properly here */
         isapnp_activate(dev->number);
         isapnp_cfg_end();
@@ -1138,13 +1134,13 @@ static int __init isapnp_init(void)
         protocol_for_each_card(&isapnp_protocol, card) {
                 cards++;
                 if (isapnp_verbose) {
-                        printk(KERN_INFO "isapnp: Card '%s'\n",
-                               card->name[0] ? card->name : "Unknown");
+                        dev_info(&card->dev, "card '%s'\n",
+                               card->name[0] ? card->name : "unknown");
                         if (isapnp_verbose < 2)
                                 continue;
                         card_for_each_dev(card, dev) {
-                                printk(KERN_INFO "isapnp:   Device '%s'\n",
-                                       dev->name[0] ? dev->name : "Unknown");
+                                dev_info(&card->dev, "device '%s'\n",
+                                       dev->name[0] ? dev->name : "unknown");
                         }
                 }
         }