Skip to content

Commit

Permalink
[IRDA]: nsc-ircc: ISAPnP support
Browse files Browse the repository at this point in the history 
This enables PnP support for the nsc-ircc chipset.
Since we can't fetch the chipset cfg_base from the PnP layer, we just use
the PnP information as one more hint when probing the chip.

Signed-off-by: Jean Tourrilhes <jt@hpl.hp.com>
Signed-off-by: Samuel Ortiz <samuel.ortiz@nokia.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
  • Loading branch information
Jean Tourrilhes authored and David S. Miller committed Mar 21, 2006
1 parent 4277a08 commit ec4f32d
Showing 1 changed file with 151 additions and 34 deletions.
185 changes: 151 additions & 34 deletions drivers/net/irda/nsc-ircc.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,7 @@
* Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>
* Copyright (c) 1998 Lichen Wang, <lwang@actisys.com>
* Copyright (c) 1998 Actisys Corp., www.actisys.com
* Copyright (c) 2000-2004 Jean Tourrilhes <jt@hpl.hp.com>
* All Rights Reserved
*
* This program is free software; you can redistribute it and/or
Expand Down Expand Up @@ -53,6 +54,7 @@
#include <linux/init.h>
#include <linux/rtnetlink.h>
#include <linux/dma-mapping.h>
#include <linux/pnp.h>

#include <asm/io.h>
#include <asm/dma.h>
Expand All @@ -78,15 +80,16 @@ static int dongle_id;

/* Use BIOS settions by default, but user may supply module parameters */
static unsigned int io[] = { ~0, ~0, ~0, ~0 };
static unsigned int irq[] = { 0, 0, 0, 0, 0 };
static unsigned int dma[] = { 0, 0, 0, 0, 0 };
static unsigned int irq[] = { 0, 0, 0, 0 };
static unsigned int dma[] = { 0, 0, 0, 0 };

static int nsc_ircc_probe_108(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_probe_338(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_probe_39x(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_init_108(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_init_338(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_init_39x(nsc_chip_t *chip, chipio_t *info);
static int nsc_ircc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *id);

/* These are the known NSC chips */
static nsc_chip_t chips[] = {
Expand All @@ -104,7 +107,6 @@ static nsc_chip_t chips[] = {
{ NULL }
};

/* Max 4 instances for now */
static struct nsc_ircc_cb *dev_self[] = { NULL, NULL, NULL, NULL };

static char *dongle_types[] = {
Expand All @@ -126,8 +128,24 @@ static char *dongle_types[] = {
"No dongle connected",
};

/* PNP probing */
static chipio_t pnp_info;
static const struct pnp_device_id nsc_ircc_pnp_table[] = {
{ .id = "NSC6001", .driver_data = 0 },
{ .id = "IBM0071", .driver_data = 0 },
{ }
};

MODULE_DEVICE_TABLE(pnp, nsc_ircc_pnp_table);

static struct pnp_driver nsc_ircc_pnp_driver = {
.name = "nsc-ircc",
.id_table = nsc_ircc_pnp_table,
.probe = nsc_ircc_pnp_probe,
};

/* Some prototypes */
static int nsc_ircc_open(int i, chipio_t *info);
static int nsc_ircc_open(chipio_t *info);
static int nsc_ircc_close(struct nsc_ircc_cb *self);
static int nsc_ircc_setup(chipio_t *info);
static void nsc_ircc_pio_receive(struct nsc_ircc_cb *self);
Expand All @@ -148,6 +166,10 @@ static int nsc_ircc_net_ioctl(struct net_device *dev, struct ifreq *rq, int cmd
static struct net_device_stats *nsc_ircc_net_get_stats(struct net_device *dev);
static int nsc_ircc_pmproc(struct pm_dev *dev, pm_request_t rqst, void *data);

/* Globals */
static int pnp_registered;
static int pnp_succeeded;

/*
* Function nsc_ircc_init ()
*
Expand All @@ -158,28 +180,30 @@ static int __init nsc_ircc_init(void)
{
chipio_t info;
nsc_chip_t *chip;
int ret = -ENODEV;
int ret;
int cfg_base;
int cfg, id;
int reg;
int i = 0;

/* Register with PnP subsystem to detect disable ports */
ret = pnp_register_driver(&nsc_ircc_pnp_driver);

if (ret >= 0)
pnp_registered = 1;

ret = -ENODEV;

/* Probe for all the NSC chipsets we know about */
for (chip=chips; chip->name ; chip++) {
for (chip = chips; chip->name ; chip++) {
IRDA_DEBUG(2, "%s(), Probing for %s ...\n", __FUNCTION__,
chip->name);

/* Try all config registers for this chip */
for (cfg=0; cfg<3; cfg++) {
for (cfg = 0; cfg < ARRAY_SIZE(chip->cfg); cfg++) {
cfg_base = chip->cfg[cfg];
if (!cfg_base)
continue;

memset(&info, 0, sizeof(chipio_t));
info.cfg_base = cfg_base;
info.fir_base = io[i];
info.dma = dma[i];
info.irq = irq[i];

/* Read index register */
reg = inb(cfg_base);
Expand All @@ -194,24 +218,64 @@ static int __init nsc_ircc_init(void)
if ((id & chip->cid_mask) == chip->cid_value) {
IRDA_DEBUG(2, "%s() Found %s chip, revision=%d\n",
__FUNCTION__, chip->name, id & ~chip->cid_mask);
/*
* If the user supplies the base address, then
* we init the chip, if not we probe the values
* set by the BIOS
*/
if (io[i] < 0x2000) {
chip->init(chip, &info);
} else
chip->probe(chip, &info);

if (nsc_ircc_open(i, &info) == 0)
ret = 0;
/*
* If we found a correct PnP setting,
* we first try it.
*/
if (pnp_succeeded) {
memset(&info, 0, sizeof(chipio_t));
info.cfg_base = cfg_base;
info.fir_base = pnp_info.fir_base;
info.dma = pnp_info.dma;
info.irq = pnp_info.irq;

if (info.fir_base < 0x2000) {
IRDA_MESSAGE("%s, chip->init\n", driver_name);
chip->init(chip, &info);
} else
chip->probe(chip, &info);

if (nsc_ircc_open(&info) >= 0)
ret = 0;
}

/*
* Opening based on PnP values failed.
* Let's fallback to user values, or probe
* the chip.
*/
if (ret) {
IRDA_DEBUG(2, "%s, PnP init failed\n", driver_name);
memset(&info, 0, sizeof(chipio_t));
info.cfg_base = cfg_base;
info.fir_base = io[i];
info.dma = dma[i];
info.irq = irq[i];

/*
* If the user supplies the base address, then
* we init the chip, if not we probe the values
* set by the BIOS
*/
if (io[i] < 0x2000) {
chip->init(chip, &info);
} else
chip->probe(chip, &info);

if (nsc_ircc_open(&info) >= 0)
ret = 0;
}
i++;
} else {
IRDA_DEBUG(2, "%s(), Wrong chip id=0x%02x\n", __FUNCTION__, id);
}
}

}

if (ret) {
pnp_unregister_driver(&nsc_ircc_pnp_driver);
pnp_registered = 0;
}

return ret;
Expand All @@ -229,10 +293,15 @@ static void __exit nsc_ircc_cleanup(void)

pm_unregister_all(nsc_ircc_pmproc);

for (i=0; i < 4; i++) {
for (i = 0; i < ARRAY_SIZE(dev_self); i++) {
if (dev_self[i])
nsc_ircc_close(dev_self[i]);
}

if (pnp_registered)
pnp_unregister_driver(&nsc_ircc_pnp_driver);

pnp_registered = 0;
}

/*
Expand All @@ -241,16 +310,27 @@ static void __exit nsc_ircc_cleanup(void)
* Open driver instance
*
*/
static int __init nsc_ircc_open(int i, chipio_t *info)
static int __init nsc_ircc_open(chipio_t *info)
{
struct net_device *dev;
struct nsc_ircc_cb *self;
struct pm_dev *pmdev;
struct pm_dev *pmdev;
void *ret;
int err;
int err, chip_index;

IRDA_DEBUG(2, "%s()\n", __FUNCTION__);


for (chip_index = 0; chip_index < ARRAY_SIZE(dev_self); chip_index++) {
if (!dev_self[chip_index])
break;
}

if (chip_index == ARRAY_SIZE(dev_self)) {
IRDA_ERROR("%s(), maximum number of supported chips reached!\n", __FUNCTION__);
return -ENOMEM;
}

IRDA_MESSAGE("%s, Found chip at base=0x%03x\n", driver_name,
info->cfg_base);

Expand All @@ -271,8 +351,8 @@ static int __init nsc_ircc_open(int i, chipio_t *info)
spin_lock_init(&self->lock);

/* Need to store self somewhere */
dev_self[i] = self;
self->index = i;
dev_self[chip_index] = self;
self->index = chip_index;

/* Initialize IO */
self->io.cfg_base = info->cfg_base;
Expand Down Expand Up @@ -351,7 +431,7 @@ static int __init nsc_ircc_open(int i, chipio_t *info)

/* Check if user has supplied a valid dongle id or not */
if ((dongle_id <= 0) ||
(dongle_id >= (sizeof(dongle_types) / sizeof(dongle_types[0]))) ) {
(dongle_id >= ARRAY_SIZE(dongle_types))) {
dongle_id = nsc_ircc_read_dongle_id(self->io.fir_base);

IRDA_MESSAGE("%s, Found dongle: %s\n", driver_name,
Expand All @@ -368,7 +448,7 @@ static int __init nsc_ircc_open(int i, chipio_t *info)
if (pmdev)
pmdev->data = self;

return 0;
return chip_index;
out4:
dma_free_coherent(NULL, self->tx_buff.truesize,
self->tx_buff.head, self->tx_buff_dma);
Expand All @@ -379,7 +459,7 @@ static int __init nsc_ircc_open(int i, chipio_t *info)
release_region(self->io.fir_base, self->io.fir_ext);
out1:
free_netdev(dev);
dev_self[i] = NULL;
dev_self[chip_index] = NULL;
return err;
}

Expand Down Expand Up @@ -806,6 +886,43 @@ static int nsc_ircc_probe_39x(nsc_chip_t *chip, chipio_t *info)
return 0;
}

/* PNP probing */
static int nsc_ircc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *id)
{
memset(&pnp_info, 0, sizeof(chipio_t));
pnp_info.irq = -1;
pnp_info.dma = -1;
pnp_succeeded = 1;

/* There don't seem to be any way to get the cfg_base.
* On my box, cfg_base is in the PnP descriptor of the
* motherboard. Oh well... Jean II */

if (pnp_port_valid(dev, 0) &&
!(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED))
pnp_info.fir_base = pnp_port_start(dev, 0);

if (pnp_irq_valid(dev, 0) &&
!(pnp_irq_flags(dev, 0) & IORESOURCE_DISABLED))
pnp_info.irq = pnp_irq(dev, 0);

if (pnp_dma_valid(dev, 0) &&
!(pnp_dma_flags(dev, 0) & IORESOURCE_DISABLED))
pnp_info.dma = pnp_dma(dev, 0);

IRDA_DEBUG(0, "%s() : From PnP, found firbase 0x%03X ; irq %d ; dma %d.\n",
__FUNCTION__, pnp_info.fir_base, pnp_info.irq, pnp_info.dma);

if((pnp_info.fir_base == 0) ||
(pnp_info.irq == -1) || (pnp_info.dma == -1)) {
/* Returning an error will disable the device. Yuck ! */
//return -EINVAL;
pnp_succeeded = 0;
}

return 0;
}

/*
* Function nsc_ircc_setup (info)
*
Expand Down

0 comments on commit ec4f32d

Please sign in to comment.