|
@@ -23,6 +23,8 @@
|
|
#include <linux/netdevice.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/slab.h>
|
|
|
|
|
|
|
|
+#include <asm/irq.h>
|
|
|
|
+
|
|
#include <pcmcia/cs_types.h>
|
|
#include <pcmcia/cs_types.h>
|
|
#include <pcmcia/ss.h>
|
|
#include <pcmcia/ss.h>
|
|
#include <pcmcia/cs.h>
|
|
#include <pcmcia/cs.h>
|
|
@@ -38,29 +40,6 @@ static int io_speed;
|
|
module_param(io_speed, int, 0444);
|
|
module_param(io_speed, int, 0444);
|
|
|
|
|
|
|
|
|
|
-#ifdef CONFIG_PCMCIA_PROBE
|
|
|
|
-#include <asm/irq.h>
|
|
|
|
-/* mask of IRQs already reserved by other cards, we should avoid using them */
|
|
|
|
-static u8 pcmcia_used_irq[NR_IRQS];
|
|
|
|
-#endif
|
|
|
|
-
|
|
|
|
-static int pcmcia_adjust_io_region(struct resource *res, unsigned long start,
|
|
|
|
- unsigned long end, struct pcmcia_socket *s)
|
|
|
|
-{
|
|
|
|
- if (s->resource_ops->adjust_io_region)
|
|
|
|
- return s->resource_ops->adjust_io_region(res, start, end, s);
|
|
|
|
- return -ENOMEM;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static struct resource *pcmcia_find_io_region(unsigned long base, int num,
|
|
|
|
- unsigned long align,
|
|
|
|
- struct pcmcia_socket *s)
|
|
|
|
-{
|
|
|
|
- if (s->resource_ops->find_io)
|
|
|
|
- return s->resource_ops->find_io(base, num, align, s);
|
|
|
|
- return NULL;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
int pcmcia_validate_mem(struct pcmcia_socket *s)
|
|
int pcmcia_validate_mem(struct pcmcia_socket *s)
|
|
{
|
|
{
|
|
if (s->resource_ops->validate_mem)
|
|
if (s->resource_ops->validate_mem)
|
|
@@ -86,8 +65,7 @@ struct resource *pcmcia_find_mem_region(u_long base, u_long num, u_long align,
|
|
static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
|
|
static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
|
|
unsigned int *base, unsigned int num, u_int lines)
|
|
unsigned int *base, unsigned int num, u_int lines)
|
|
{
|
|
{
|
|
- int i;
|
|
|
|
- unsigned int try, align;
|
|
|
|
|
|
+ unsigned int align;
|
|
|
|
|
|
align = (*base) ? (lines ? 1<<lines : 0) : 1;
|
|
align = (*base) ? (lines ? 1<<lines : 0) : 1;
|
|
if (align && (align < num)) {
|
|
if (align && (align < num)) {
|
|
@@ -104,50 +82,8 @@ static int alloc_io_space(struct pcmcia_socket *s, u_int attr,
|
|
*base, align);
|
|
*base, align);
|
|
align = 0;
|
|
align = 0;
|
|
}
|
|
}
|
|
- if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
|
|
|
|
- *base = s->io_offset | (*base & 0x0fff);
|
|
|
|
- return 0;
|
|
|
|
- }
|
|
|
|
- /* Check for an already-allocated window that must conflict with
|
|
|
|
- * what was asked for. It is a hack because it does not catch all
|
|
|
|
- * potential conflicts, just the most obvious ones.
|
|
|
|
- */
|
|
|
|
- for (i = 0; i < MAX_IO_WIN; i++)
|
|
|
|
- if ((s->io[i].res) && *base &&
|
|
|
|
- ((s->io[i].res->start & (align-1)) == *base))
|
|
|
|
- return 1;
|
|
|
|
- for (i = 0; i < MAX_IO_WIN; i++) {
|
|
|
|
- if (!s->io[i].res) {
|
|
|
|
- s->io[i].res = pcmcia_find_io_region(*base, num, align, s);
|
|
|
|
- if (s->io[i].res) {
|
|
|
|
- *base = s->io[i].res->start;
|
|
|
|
- s->io[i].res->flags = (s->io[i].res->flags & ~IORESOURCE_BITS) | (attr & IORESOURCE_BITS);
|
|
|
|
- s->io[i].InUse = num;
|
|
|
|
- break;
|
|
|
|
- } else
|
|
|
|
- return 1;
|
|
|
|
- } else if ((s->io[i].res->flags & IORESOURCE_BITS) != (attr & IORESOURCE_BITS))
|
|
|
|
- continue;
|
|
|
|
- /* Try to extend top of window */
|
|
|
|
- try = s->io[i].res->end + 1;
|
|
|
|
- if ((*base == 0) || (*base == try))
|
|
|
|
- if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start,
|
|
|
|
- s->io[i].res->end + num, s) == 0) {
|
|
|
|
- *base = try;
|
|
|
|
- s->io[i].InUse += num;
|
|
|
|
- break;
|
|
|
|
- }
|
|
|
|
- /* Try to extend bottom of window */
|
|
|
|
- try = s->io[i].res->start - num;
|
|
|
|
- if ((*base == 0) || (*base == try))
|
|
|
|
- if (pcmcia_adjust_io_region(s->io[i].res, s->io[i].res->start - num,
|
|
|
|
- s->io[i].res->end, s) == 0) {
|
|
|
|
- *base = try;
|
|
|
|
- s->io[i].InUse += num;
|
|
|
|
- break;
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
- return (i == MAX_IO_WIN);
|
|
|
|
|
|
+
|
|
|
|
+ return s->resource_ops->find_io(s, attr, base, num, align);
|
|
} /* alloc_io_space */
|
|
} /* alloc_io_space */
|
|
|
|
|
|
|
|
|
|
@@ -187,6 +123,7 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
|
|
config_t *c;
|
|
config_t *c;
|
|
int addr;
|
|
int addr;
|
|
u_char val;
|
|
u_char val;
|
|
|
|
+ int ret = 0;
|
|
|
|
|
|
if (!p_dev || !p_dev->function_config)
|
|
if (!p_dev || !p_dev->function_config)
|
|
return -EINVAL;
|
|
return -EINVAL;
|
|
@@ -203,11 +140,10 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
|
|
}
|
|
}
|
|
|
|
|
|
addr = (c->ConfigBase + reg->Offset) >> 1;
|
|
addr = (c->ConfigBase + reg->Offset) >> 1;
|
|
- mutex_unlock(&s->ops_mutex);
|
|
|
|
|
|
|
|
switch (reg->Action) {
|
|
switch (reg->Action) {
|
|
case CS_READ:
|
|
case CS_READ:
|
|
- pcmcia_read_cis_mem(s, 1, addr, 1, &val);
|
|
|
|
|
|
+ ret = pcmcia_read_cis_mem(s, 1, addr, 1, &val);
|
|
reg->Value = val;
|
|
reg->Value = val;
|
|
break;
|
|
break;
|
|
case CS_WRITE:
|
|
case CS_WRITE:
|
|
@@ -216,10 +152,11 @@ int pcmcia_access_configuration_register(struct pcmcia_device *p_dev,
|
|
break;
|
|
break;
|
|
default:
|
|
default:
|
|
dev_dbg(&s->dev, "Invalid conf register request\n");
|
|
dev_dbg(&s->dev, "Invalid conf register request\n");
|
|
- return -EINVAL;
|
|
|
|
|
|
+ ret = -EINVAL;
|
|
break;
|
|
break;
|
|
}
|
|
}
|
|
- return 0;
|
|
|
|
|
|
+ mutex_unlock(&s->ops_mutex);
|
|
|
|
+ return ret;
|
|
} /* pcmcia_access_configuration_register */
|
|
} /* pcmcia_access_configuration_register */
|
|
EXPORT_SYMBOL(pcmcia_access_configuration_register);
|
|
EXPORT_SYMBOL(pcmcia_access_configuration_register);
|
|
|
|
|
|
@@ -275,19 +212,9 @@ int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
|
|
goto unlock;
|
|
goto unlock;
|
|
}
|
|
}
|
|
|
|
|
|
- if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
|
|
|
|
- if (mod->Attributes & CONF_ENABLE_IRQ) {
|
|
|
|
- c->Attributes |= CONF_ENABLE_IRQ;
|
|
|
|
- s->socket.io_irq = s->irq.AssignedIRQ;
|
|
|
|
- } else {
|
|
|
|
- c->Attributes &= ~CONF_ENABLE_IRQ;
|
|
|
|
- s->socket.io_irq = 0;
|
|
|
|
- }
|
|
|
|
- s->ops->set_socket(s, &s->socket);
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if (mod->Attributes & CONF_VCC_CHANGE_VALID) {
|
|
|
|
- dev_dbg(&s->dev, "changing Vcc is not allowed at this time\n");
|
|
|
|
|
|
+ if (mod->Attributes & (CONF_IRQ_CHANGE_VALID | CONF_VCC_CHANGE_VALID)) {
|
|
|
|
+ dev_dbg(&s->dev,
|
|
|
|
+ "changing Vcc or IRQ is not allowed at this time\n");
|
|
ret = -EINVAL;
|
|
ret = -EINVAL;
|
|
goto unlock;
|
|
goto unlock;
|
|
}
|
|
}
|
|
@@ -422,52 +349,6 @@ out:
|
|
} /* pcmcia_release_io */
|
|
} /* pcmcia_release_io */
|
|
|
|
|
|
|
|
|
|
-static int pcmcia_release_irq(struct pcmcia_device *p_dev, irq_req_t *req)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_socket *s = p_dev->socket;
|
|
|
|
- config_t *c;
|
|
|
|
- int ret = -EINVAL;
|
|
|
|
-
|
|
|
|
- mutex_lock(&s->ops_mutex);
|
|
|
|
-
|
|
|
|
- c = p_dev->function_config;
|
|
|
|
-
|
|
|
|
- if (!p_dev->_irq)
|
|
|
|
- goto out;
|
|
|
|
-
|
|
|
|
- p_dev->_irq = 0;
|
|
|
|
-
|
|
|
|
- if (c->state & CONFIG_LOCKED)
|
|
|
|
- goto out;
|
|
|
|
-
|
|
|
|
- if (c->irq.Attributes != req->Attributes) {
|
|
|
|
- dev_dbg(&s->dev, "IRQ attributes must match assigned ones\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- if (s->irq.AssignedIRQ != req->AssignedIRQ) {
|
|
|
|
- dev_dbg(&s->dev, "IRQ must match assigned one\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- if (--s->irq.Config == 0) {
|
|
|
|
- c->state &= ~CONFIG_IRQ_REQ;
|
|
|
|
- s->irq.AssignedIRQ = 0;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if (req->Handler)
|
|
|
|
- free_irq(req->AssignedIRQ, p_dev->priv);
|
|
|
|
-
|
|
|
|
-#ifdef CONFIG_PCMCIA_PROBE
|
|
|
|
- pcmcia_used_irq[req->AssignedIRQ]--;
|
|
|
|
-#endif
|
|
|
|
- ret = 0;
|
|
|
|
-
|
|
|
|
-out:
|
|
|
|
- mutex_unlock(&s->ops_mutex);
|
|
|
|
-
|
|
|
|
- return ret;
|
|
|
|
-} /* pcmcia_release_irq */
|
|
|
|
-
|
|
|
|
-
|
|
|
|
int pcmcia_release_window(struct pcmcia_device *p_dev, window_handle_t wh)
|
|
int pcmcia_release_window(struct pcmcia_device *p_dev, window_handle_t wh)
|
|
{
|
|
{
|
|
struct pcmcia_socket *s = p_dev->socket;
|
|
struct pcmcia_socket *s = p_dev->socket;
|
|
@@ -551,12 +432,11 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
|
|
if (req->Attributes & CONF_ENABLE_SPKR)
|
|
if (req->Attributes & CONF_ENABLE_SPKR)
|
|
s->socket.flags |= SS_SPKR_ENA;
|
|
s->socket.flags |= SS_SPKR_ENA;
|
|
if (req->Attributes & CONF_ENABLE_IRQ)
|
|
if (req->Attributes & CONF_ENABLE_IRQ)
|
|
- s->socket.io_irq = s->irq.AssignedIRQ;
|
|
|
|
|
|
+ s->socket.io_irq = s->pcmcia_irq;
|
|
else
|
|
else
|
|
s->socket.io_irq = 0;
|
|
s->socket.io_irq = 0;
|
|
s->ops->set_socket(s, &s->socket);
|
|
s->ops->set_socket(s, &s->socket);
|
|
s->lock_count++;
|
|
s->lock_count++;
|
|
- mutex_unlock(&s->ops_mutex);
|
|
|
|
|
|
|
|
/* Set up CIS configuration registers */
|
|
/* Set up CIS configuration registers */
|
|
base = c->ConfigBase = req->ConfigBase;
|
|
base = c->ConfigBase = req->ConfigBase;
|
|
@@ -574,9 +454,9 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
|
|
if (req->Present & PRESENT_IOBASE_0)
|
|
if (req->Present & PRESENT_IOBASE_0)
|
|
c->Option |= COR_ADDR_DECODE;
|
|
c->Option |= COR_ADDR_DECODE;
|
|
}
|
|
}
|
|
- if (c->state & CONFIG_IRQ_REQ)
|
|
|
|
- if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
|
|
|
|
- c->Option |= COR_LEVEL_REQ;
|
|
|
|
|
|
+ if ((req->Attributes & CONF_ENABLE_IRQ) &&
|
|
|
|
+ !(req->Attributes & CONF_ENABLE_PULSE_IRQ))
|
|
|
|
+ c->Option |= COR_LEVEL_REQ;
|
|
pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
|
|
pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
|
|
mdelay(40);
|
|
mdelay(40);
|
|
}
|
|
}
|
|
@@ -605,7 +485,6 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
|
|
|
|
|
|
/* Configure I/O windows */
|
|
/* Configure I/O windows */
|
|
if (c->state & CONFIG_IO_REQ) {
|
|
if (c->state & CONFIG_IO_REQ) {
|
|
- mutex_lock(&s->ops_mutex);
|
|
|
|
iomap.speed = io_speed;
|
|
iomap.speed = io_speed;
|
|
for (i = 0; i < MAX_IO_WIN; i++)
|
|
for (i = 0; i < MAX_IO_WIN; i++)
|
|
if (s->io[i].res) {
|
|
if (s->io[i].res) {
|
|
@@ -624,11 +503,11 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
|
|
s->ops->set_io_map(s, &iomap);
|
|
s->ops->set_io_map(s, &iomap);
|
|
s->io[i].Config++;
|
|
s->io[i].Config++;
|
|
}
|
|
}
|
|
- mutex_unlock(&s->ops_mutex);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
c->state |= CONFIG_LOCKED;
|
|
c->state |= CONFIG_LOCKED;
|
|
p_dev->_locked = 1;
|
|
p_dev->_locked = 1;
|
|
|
|
+ mutex_unlock(&s->ops_mutex);
|
|
return 0;
|
|
return 0;
|
|
} /* pcmcia_request_configuration */
|
|
} /* pcmcia_request_configuration */
|
|
EXPORT_SYMBOL(pcmcia_request_configuration);
|
|
EXPORT_SYMBOL(pcmcia_request_configuration);
|
|
@@ -706,137 +585,176 @@ out:
|
|
EXPORT_SYMBOL(pcmcia_request_io);
|
|
EXPORT_SYMBOL(pcmcia_request_io);
|
|
|
|
|
|
|
|
|
|
-/** pcmcia_request_irq
|
|
|
|
|
|
+/**
|
|
|
|
+ * pcmcia_request_irq() - attempt to request a IRQ for a PCMCIA device
|
|
*
|
|
*
|
|
- * Request_irq() reserves an irq for this client.
|
|
|
|
|
|
+ * pcmcia_request_irq() is a wrapper around request_irq which will allow
|
|
|
|
+ * the PCMCIA core to clean up the registration in pcmcia_disable_device().
|
|
|
|
+ * Drivers are free to use request_irq() directly, but then they need to
|
|
|
|
+ * call free_irq themselfves, too. Also, only IRQF_SHARED capable IRQ
|
|
|
|
+ * handlers are allowed.
|
|
|
|
+ */
|
|
|
|
+int __must_check pcmcia_request_irq(struct pcmcia_device *p_dev,
|
|
|
|
+ irq_handler_t handler)
|
|
|
|
+{
|
|
|
|
+ int ret;
|
|
|
|
+
|
|
|
|
+ if (!p_dev->irq)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ ret = request_irq(p_dev->irq, handler, IRQF_SHARED,
|
|
|
|
+ p_dev->devname, p_dev->priv);
|
|
|
|
+ if (!ret)
|
|
|
|
+ p_dev->_irq = 1;
|
|
|
|
+
|
|
|
|
+ return ret;
|
|
|
|
+}
|
|
|
|
+EXPORT_SYMBOL(pcmcia_request_irq);
|
|
|
|
+
|
|
|
|
+
|
|
|
|
+/**
|
|
|
|
+ * pcmcia_request_exclusive_irq() - attempt to request an exclusive IRQ first
|
|
*
|
|
*
|
|
- * Also, since Linux only reserves irq's when they are actually
|
|
|
|
- * hooked, we don't guarantee that an irq will still be available
|
|
|
|
- * when the configuration is locked. Now that I think about it,
|
|
|
|
- * there might be a way to fix this using a dummy handler.
|
|
|
|
|
|
+ * pcmcia_request_exclusive_irq() is a wrapper around request_irq which
|
|
|
|
+ * attempts first to request an exclusive IRQ. If it fails, it also accepts
|
|
|
|
+ * a shared IRQ, but prints out a warning. PCMCIA drivers should allow for
|
|
|
|
+ * IRQ sharing and either use request_irq directly (then they need to call
|
|
|
|
+ * free_irq themselves, too), or the pcmcia_request_irq() function.
|
|
*/
|
|
*/
|
|
|
|
+int __must_check
|
|
|
|
+__pcmcia_request_exclusive_irq(struct pcmcia_device *p_dev,
|
|
|
|
+ irq_handler_t handler)
|
|
|
|
+{
|
|
|
|
+ int ret;
|
|
|
|
+
|
|
|
|
+ if (!p_dev->irq)
|
|
|
|
+ return -EINVAL;
|
|
|
|
+
|
|
|
|
+ ret = request_irq(p_dev->irq, handler, 0, p_dev->devname, p_dev->priv);
|
|
|
|
+ if (ret) {
|
|
|
|
+ ret = pcmcia_request_irq(p_dev, handler);
|
|
|
|
+ dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: "
|
|
|
|
+ "request for exclusive IRQ could not be fulfilled.\n");
|
|
|
|
+ dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver "
|
|
|
|
+ "needs updating to supported shared IRQ lines.\n");
|
|
|
|
+ }
|
|
|
|
+ if (ret)
|
|
|
|
+ dev_printk(KERN_INFO, &p_dev->dev, "request_irq() failed\n");
|
|
|
|
+ else
|
|
|
|
+ p_dev->_irq = 1;
|
|
|
|
+
|
|
|
|
+ return ret;
|
|
|
|
+} /* pcmcia_request_exclusive_irq */
|
|
|
|
+EXPORT_SYMBOL(__pcmcia_request_exclusive_irq);
|
|
|
|
+
|
|
|
|
|
|
#ifdef CONFIG_PCMCIA_PROBE
|
|
#ifdef CONFIG_PCMCIA_PROBE
|
|
|
|
+
|
|
|
|
+/* mask of IRQs already reserved by other cards, we should avoid using them */
|
|
|
|
+static u8 pcmcia_used_irq[NR_IRQS];
|
|
|
|
+
|
|
static irqreturn_t test_action(int cpl, void *dev_id)
|
|
static irqreturn_t test_action(int cpl, void *dev_id)
|
|
{
|
|
{
|
|
return IRQ_NONE;
|
|
return IRQ_NONE;
|
|
}
|
|
}
|
|
-#endif
|
|
|
|
|
|
|
|
-int pcmcia_request_irq(struct pcmcia_device *p_dev, irq_req_t *req)
|
|
|
|
|
|
+/**
|
|
|
|
+ * pcmcia_setup_isa_irq() - determine whether an ISA IRQ can be used
|
|
|
|
+ * @p_dev - the associated PCMCIA device
|
|
|
|
+ *
|
|
|
|
+ * locking note: must be called with ops_mutex locked.
|
|
|
|
+ */
|
|
|
|
+static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
|
|
{
|
|
{
|
|
struct pcmcia_socket *s = p_dev->socket;
|
|
struct pcmcia_socket *s = p_dev->socket;
|
|
- config_t *c;
|
|
|
|
- int ret = -EINVAL, irq = 0;
|
|
|
|
- int type;
|
|
|
|
|
|
+ unsigned int try, irq;
|
|
|
|
+ u32 mask = s->irq_mask;
|
|
|
|
+ int ret = -ENODEV;
|
|
|
|
|
|
- mutex_lock(&s->ops_mutex);
|
|
|
|
|
|
+ for (try = 0; try < 64; try++) {
|
|
|
|
+ irq = try % 32;
|
|
|
|
|
|
- if (!(s->state & SOCKET_PRESENT)) {
|
|
|
|
- dev_dbg(&s->dev, "No card present\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- c = p_dev->function_config;
|
|
|
|
- if (c->state & CONFIG_LOCKED) {
|
|
|
|
- dev_dbg(&s->dev, "Configuration is locked\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- if (c->state & CONFIG_IRQ_REQ) {
|
|
|
|
- dev_dbg(&s->dev, "IRQ already configured\n");
|
|
|
|
- goto out;
|
|
|
|
|
|
+ /* marked as available by driver, not blocked by userspace? */
|
|
|
|
+ if (!((mask >> irq) & 1))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ /* avoid an IRQ which is already used by another PCMCIA card */
|
|
|
|
+ if ((try < 32) && pcmcia_used_irq[irq])
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ /* register the correct driver, if possible, to check whether
|
|
|
|
+ * registering a dummy handle works, i.e. if the IRQ isn't
|
|
|
|
+ * marked as used by the kernel resource management core */
|
|
|
|
+ ret = request_irq(irq, test_action, type, p_dev->devname,
|
|
|
|
+ p_dev);
|
|
|
|
+ if (!ret) {
|
|
|
|
+ free_irq(irq, p_dev);
|
|
|
|
+ p_dev->irq = s->pcmcia_irq = irq;
|
|
|
|
+ pcmcia_used_irq[irq]++;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
}
|
|
}
|
|
|
|
|
|
- /* Decide what type of interrupt we are registering */
|
|
|
|
- type = 0;
|
|
|
|
- if (s->functions > 1) /* All of this ought to be handled higher up */
|
|
|
|
- type = IRQF_SHARED;
|
|
|
|
- else if (req->Attributes & IRQ_TYPE_DYNAMIC_SHARING)
|
|
|
|
- type = IRQF_SHARED;
|
|
|
|
- else
|
|
|
|
- printk(KERN_WARNING "pcmcia: Driver needs updating to support IRQ sharing.\n");
|
|
|
|
|
|
+ return ret;
|
|
|
|
+}
|
|
|
|
|
|
- /* If the interrupt is already assigned, it must be the same */
|
|
|
|
- if (s->irq.AssignedIRQ != 0)
|
|
|
|
- irq = s->irq.AssignedIRQ;
|
|
|
|
|
|
+void pcmcia_cleanup_irq(struct pcmcia_socket *s)
|
|
|
|
+{
|
|
|
|
+ pcmcia_used_irq[s->pcmcia_irq]--;
|
|
|
|
+ s->pcmcia_irq = 0;
|
|
|
|
+}
|
|
|
|
|
|
-#ifdef CONFIG_PCMCIA_PROBE
|
|
|
|
- if (!irq) {
|
|
|
|
- int try;
|
|
|
|
- u32 mask = s->irq_mask;
|
|
|
|
- void *data = p_dev; /* something unique to this device */
|
|
|
|
|
|
+#else /* CONFIG_PCMCIA_PROBE */
|
|
|
|
|
|
- for (try = 0; try < 64; try++) {
|
|
|
|
- irq = try % 32;
|
|
|
|
|
|
+static int pcmcia_setup_isa_irq(struct pcmcia_device *p_dev, int type)
|
|
|
|
+{
|
|
|
|
+ return -EINVAL;
|
|
|
|
+}
|
|
|
|
|
|
- /* marked as available by driver, and not blocked by userspace? */
|
|
|
|
- if (!((mask >> irq) & 1))
|
|
|
|
- continue;
|
|
|
|
|
|
+void pcmcia_cleanup_irq(struct pcmcia_socket *s)
|
|
|
|
+{
|
|
|
|
+ s->pcmcia_irq = 0;
|
|
|
|
+ return;
|
|
|
|
+}
|
|
|
|
|
|
- /* avoid an IRQ which is already used by a PCMCIA card */
|
|
|
|
- if ((try < 32) && pcmcia_used_irq[irq])
|
|
|
|
- continue;
|
|
|
|
|
|
+#endif /* CONFIG_PCMCIA_PROBE */
|
|
|
|
|
|
- /* register the correct driver, if possible, of check whether
|
|
|
|
- * registering a dummy handle works, i.e. if the IRQ isn't
|
|
|
|
- * marked as used by the kernel resource management core */
|
|
|
|
- ret = request_irq(irq,
|
|
|
|
- (req->Handler) ? req->Handler : test_action,
|
|
|
|
- type,
|
|
|
|
- p_dev->devname,
|
|
|
|
- (req->Handler) ? p_dev->priv : data);
|
|
|
|
- if (!ret) {
|
|
|
|
- if (!req->Handler)
|
|
|
|
- free_irq(irq, data);
|
|
|
|
- break;
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
-#endif
|
|
|
|
- /* only assign PCI irq if no IRQ already assigned */
|
|
|
|
- if (ret && !s->irq.AssignedIRQ) {
|
|
|
|
- if (!s->pci_irq) {
|
|
|
|
- dev_printk(KERN_INFO, &s->dev, "no IRQ found\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- type = IRQF_SHARED;
|
|
|
|
- irq = s->pci_irq;
|
|
|
|
- }
|
|
|
|
|
|
|
|
- if (ret && req->Handler) {
|
|
|
|
- ret = request_irq(irq, req->Handler, type,
|
|
|
|
- p_dev->devname, p_dev->priv);
|
|
|
|
- if (ret) {
|
|
|
|
- dev_printk(KERN_INFO, &s->dev,
|
|
|
|
- "request_irq() failed\n");
|
|
|
|
- goto out;
|
|
|
|
- }
|
|
|
|
- }
|
|
|
|
|
|
+/**
|
|
|
|
+ * pcmcia_setup_irq() - determine IRQ to be used for device
|
|
|
|
+ * @p_dev - the associated PCMCIA device
|
|
|
|
+ *
|
|
|
|
+ * locking note: must be called with ops_mutex locked.
|
|
|
|
+ */
|
|
|
|
+int pcmcia_setup_irq(struct pcmcia_device *p_dev)
|
|
|
|
+{
|
|
|
|
+ struct pcmcia_socket *s = p_dev->socket;
|
|
|
|
|
|
- /* Make sure the fact the request type was overridden is passed back */
|
|
|
|
- if (type == IRQF_SHARED && !(req->Attributes & IRQ_TYPE_DYNAMIC_SHARING)) {
|
|
|
|
- req->Attributes |= IRQ_TYPE_DYNAMIC_SHARING;
|
|
|
|
- dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: "
|
|
|
|
- "request for exclusive IRQ could not be fulfilled.\n");
|
|
|
|
- dev_printk(KERN_WARNING, &p_dev->dev, "pcmcia: the driver "
|
|
|
|
- "needs updating to supported shared IRQ lines.\n");
|
|
|
|
|
|
+ if (p_dev->irq)
|
|
|
|
+ return 0;
|
|
|
|
+
|
|
|
|
+ /* already assigned? */
|
|
|
|
+ if (s->pcmcia_irq) {
|
|
|
|
+ p_dev->irq = s->pcmcia_irq;
|
|
|
|
+ return 0;
|
|
}
|
|
}
|
|
- c->irq.Attributes = req->Attributes;
|
|
|
|
- s->irq.AssignedIRQ = req->AssignedIRQ = irq;
|
|
|
|
- s->irq.Config++;
|
|
|
|
|
|
|
|
- c->state |= CONFIG_IRQ_REQ;
|
|
|
|
- p_dev->_irq = 1;
|
|
|
|
|
|
+ /* prefer an exclusive ISA irq */
|
|
|
|
+ if (!pcmcia_setup_isa_irq(p_dev, 0))
|
|
|
|
+ return 0;
|
|
|
|
|
|
-#ifdef CONFIG_PCMCIA_PROBE
|
|
|
|
- pcmcia_used_irq[irq]++;
|
|
|
|
-#endif
|
|
|
|
|
|
+ /* but accept a shared ISA irq */
|
|
|
|
+ if (!pcmcia_setup_isa_irq(p_dev, IRQF_SHARED))
|
|
|
|
+ return 0;
|
|
|
|
|
|
- ret = 0;
|
|
|
|
-out:
|
|
|
|
- mutex_unlock(&s->ops_mutex);
|
|
|
|
- return ret;
|
|
|
|
-} /* pcmcia_request_irq */
|
|
|
|
-EXPORT_SYMBOL(pcmcia_request_irq);
|
|
|
|
|
|
+ /* but use the PCI irq otherwise */
|
|
|
|
+ if (s->pci_irq) {
|
|
|
|
+ p_dev->irq = s->pcmcia_irq = s->pci_irq;
|
|
|
|
+ return 0;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return -EINVAL;
|
|
|
|
+}
|
|
|
|
|
|
|
|
|
|
/** pcmcia_request_window
|
|
/** pcmcia_request_window
|
|
@@ -939,237 +857,9 @@ void pcmcia_disable_device(struct pcmcia_device *p_dev)
|
|
{
|
|
{
|
|
pcmcia_release_configuration(p_dev);
|
|
pcmcia_release_configuration(p_dev);
|
|
pcmcia_release_io(p_dev, &p_dev->io);
|
|
pcmcia_release_io(p_dev, &p_dev->io);
|
|
- pcmcia_release_irq(p_dev, &p_dev->irq);
|
|
|
|
|
|
+ if (p_dev->_irq)
|
|
|
|
+ free_irq(p_dev->irq, p_dev->priv);
|
|
if (p_dev->win)
|
|
if (p_dev->win)
|
|
pcmcia_release_window(p_dev, p_dev->win);
|
|
pcmcia_release_window(p_dev, p_dev->win);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(pcmcia_disable_device);
|
|
EXPORT_SYMBOL(pcmcia_disable_device);
|
|
-
|
|
|
|
-
|
|
|
|
-struct pcmcia_cfg_mem {
|
|
|
|
- struct pcmcia_device *p_dev;
|
|
|
|
- void *priv_data;
|
|
|
|
- int (*conf_check) (struct pcmcia_device *p_dev,
|
|
|
|
- cistpl_cftable_entry_t *cfg,
|
|
|
|
- cistpl_cftable_entry_t *dflt,
|
|
|
|
- unsigned int vcc,
|
|
|
|
- void *priv_data);
|
|
|
|
- cisparse_t parse;
|
|
|
|
- cistpl_cftable_entry_t dflt;
|
|
|
|
-};
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_do_loop_config() - internal helper for pcmcia_loop_config()
|
|
|
|
- *
|
|
|
|
- * pcmcia_do_loop_config() is the internal callback for the call from
|
|
|
|
- * pcmcia_loop_config() to pccard_loop_tuple(). Data is transferred
|
|
|
|
- * by a struct pcmcia_cfg_mem.
|
|
|
|
- */
|
|
|
|
-static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv)
|
|
|
|
-{
|
|
|
|
- cistpl_cftable_entry_t *cfg = &parse->cftable_entry;
|
|
|
|
- struct pcmcia_cfg_mem *cfg_mem = priv;
|
|
|
|
-
|
|
|
|
- /* default values */
|
|
|
|
- cfg_mem->p_dev->conf.ConfigIndex = cfg->index;
|
|
|
|
- if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
|
|
|
|
- cfg_mem->dflt = *cfg;
|
|
|
|
-
|
|
|
|
- return cfg_mem->conf_check(cfg_mem->p_dev, cfg, &cfg_mem->dflt,
|
|
|
|
- cfg_mem->p_dev->socket->socket.Vcc,
|
|
|
|
- cfg_mem->priv_data);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_loop_config() - loop over configuration options
|
|
|
|
- * @p_dev: the struct pcmcia_device which we need to loop for.
|
|
|
|
- * @conf_check: function to call for each configuration option.
|
|
|
|
- * It gets passed the struct pcmcia_device, the CIS data
|
|
|
|
- * describing the configuration option, and private data
|
|
|
|
- * being passed to pcmcia_loop_config()
|
|
|
|
- * @priv_data: private data to be passed to the conf_check function.
|
|
|
|
- *
|
|
|
|
- * pcmcia_loop_config() loops over all configuration options, and calls
|
|
|
|
- * the driver-specific conf_check() for each one, checking whether
|
|
|
|
- * it is a valid one. Returns 0 on success or errorcode otherwise.
|
|
|
|
- */
|
|
|
|
-int pcmcia_loop_config(struct pcmcia_device *p_dev,
|
|
|
|
- int (*conf_check) (struct pcmcia_device *p_dev,
|
|
|
|
- cistpl_cftable_entry_t *cfg,
|
|
|
|
- cistpl_cftable_entry_t *dflt,
|
|
|
|
- unsigned int vcc,
|
|
|
|
- void *priv_data),
|
|
|
|
- void *priv_data)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_cfg_mem *cfg_mem;
|
|
|
|
- int ret;
|
|
|
|
-
|
|
|
|
- cfg_mem = kzalloc(sizeof(struct pcmcia_cfg_mem), GFP_KERNEL);
|
|
|
|
- if (cfg_mem == NULL)
|
|
|
|
- return -ENOMEM;
|
|
|
|
-
|
|
|
|
- cfg_mem->p_dev = p_dev;
|
|
|
|
- cfg_mem->conf_check = conf_check;
|
|
|
|
- cfg_mem->priv_data = priv_data;
|
|
|
|
-
|
|
|
|
- ret = pccard_loop_tuple(p_dev->socket, p_dev->func,
|
|
|
|
- CISTPL_CFTABLE_ENTRY, &cfg_mem->parse,
|
|
|
|
- cfg_mem, pcmcia_do_loop_config);
|
|
|
|
-
|
|
|
|
- kfree(cfg_mem);
|
|
|
|
- return ret;
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(pcmcia_loop_config);
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-struct pcmcia_loop_mem {
|
|
|
|
- struct pcmcia_device *p_dev;
|
|
|
|
- void *priv_data;
|
|
|
|
- int (*loop_tuple) (struct pcmcia_device *p_dev,
|
|
|
|
- tuple_t *tuple,
|
|
|
|
- void *priv_data);
|
|
|
|
-};
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_do_loop_tuple() - internal helper for pcmcia_loop_config()
|
|
|
|
- *
|
|
|
|
- * pcmcia_do_loop_tuple() is the internal callback for the call from
|
|
|
|
- * pcmcia_loop_tuple() to pccard_loop_tuple(). Data is transferred
|
|
|
|
- * by a struct pcmcia_cfg_mem.
|
|
|
|
- */
|
|
|
|
-static int pcmcia_do_loop_tuple(tuple_t *tuple, cisparse_t *parse, void *priv)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_loop_mem *loop = priv;
|
|
|
|
-
|
|
|
|
- return loop->loop_tuple(loop->p_dev, tuple, loop->priv_data);
|
|
|
|
-};
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_loop_tuple() - loop over tuples in the CIS
|
|
|
|
- * @p_dev: the struct pcmcia_device which we need to loop for.
|
|
|
|
- * @code: which CIS code shall we look for?
|
|
|
|
- * @priv_data: private data to be passed to the loop_tuple function.
|
|
|
|
- * @loop_tuple: function to call for each CIS entry of type @function. IT
|
|
|
|
- * gets passed the raw tuple and @priv_data.
|
|
|
|
- *
|
|
|
|
- * pcmcia_loop_tuple() loops over all CIS entries of type @function, and
|
|
|
|
- * calls the @loop_tuple function for each entry. If the call to @loop_tuple
|
|
|
|
- * returns 0, the loop exits. Returns 0 on success or errorcode otherwise.
|
|
|
|
- */
|
|
|
|
-int pcmcia_loop_tuple(struct pcmcia_device *p_dev, cisdata_t code,
|
|
|
|
- int (*loop_tuple) (struct pcmcia_device *p_dev,
|
|
|
|
- tuple_t *tuple,
|
|
|
|
- void *priv_data),
|
|
|
|
- void *priv_data)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_loop_mem loop = {
|
|
|
|
- .p_dev = p_dev,
|
|
|
|
- .loop_tuple = loop_tuple,
|
|
|
|
- .priv_data = priv_data};
|
|
|
|
-
|
|
|
|
- return pccard_loop_tuple(p_dev->socket, p_dev->func, code, NULL,
|
|
|
|
- &loop, pcmcia_do_loop_tuple);
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(pcmcia_loop_tuple);
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-struct pcmcia_loop_get {
|
|
|
|
- size_t len;
|
|
|
|
- cisdata_t **buf;
|
|
|
|
-};
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_do_get_tuple() - internal helper for pcmcia_get_tuple()
|
|
|
|
- *
|
|
|
|
- * pcmcia_do_get_tuple() is the internal callback for the call from
|
|
|
|
- * pcmcia_get_tuple() to pcmcia_loop_tuple(). As we're only interested in
|
|
|
|
- * the first tuple, return 0 unconditionally. Create a memory buffer large
|
|
|
|
- * enough to hold the content of the tuple, and fill it with the tuple data.
|
|
|
|
- * The caller is responsible to free the buffer.
|
|
|
|
- */
|
|
|
|
-static int pcmcia_do_get_tuple(struct pcmcia_device *p_dev, tuple_t *tuple,
|
|
|
|
- void *priv)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_loop_get *get = priv;
|
|
|
|
-
|
|
|
|
- *get->buf = kzalloc(tuple->TupleDataLen, GFP_KERNEL);
|
|
|
|
- if (*get->buf) {
|
|
|
|
- get->len = tuple->TupleDataLen;
|
|
|
|
- memcpy(*get->buf, tuple->TupleData, tuple->TupleDataLen);
|
|
|
|
- } else
|
|
|
|
- dev_dbg(&p_dev->dev, "do_get_tuple: out of memory\n");
|
|
|
|
- return 0;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_get_tuple() - get first tuple from CIS
|
|
|
|
- * @p_dev: the struct pcmcia_device which we need to loop for.
|
|
|
|
- * @code: which CIS code shall we look for?
|
|
|
|
- * @buf: pointer to store the buffer to.
|
|
|
|
- *
|
|
|
|
- * pcmcia_get_tuple() gets the content of the first CIS entry of type @code.
|
|
|
|
- * It returns the buffer length (or zero). The caller is responsible to free
|
|
|
|
- * the buffer passed in @buf.
|
|
|
|
- */
|
|
|
|
-size_t pcmcia_get_tuple(struct pcmcia_device *p_dev, cisdata_t code,
|
|
|
|
- unsigned char **buf)
|
|
|
|
-{
|
|
|
|
- struct pcmcia_loop_get get = {
|
|
|
|
- .len = 0,
|
|
|
|
- .buf = buf,
|
|
|
|
- };
|
|
|
|
-
|
|
|
|
- *get.buf = NULL;
|
|
|
|
- pcmcia_loop_tuple(p_dev, code, pcmcia_do_get_tuple, &get);
|
|
|
|
-
|
|
|
|
- return get.len;
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(pcmcia_get_tuple);
|
|
|
|
-
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_do_get_mac() - internal helper for pcmcia_get_mac_from_cis()
|
|
|
|
- *
|
|
|
|
- * pcmcia_do_get_mac() is the internal callback for the call from
|
|
|
|
- * pcmcia_get_mac_from_cis() to pcmcia_loop_tuple(). We check whether the
|
|
|
|
- * tuple contains a proper LAN_NODE_ID of length 6, and copy the data
|
|
|
|
- * to struct net_device->dev_addr[i].
|
|
|
|
- */
|
|
|
|
-static int pcmcia_do_get_mac(struct pcmcia_device *p_dev, tuple_t *tuple,
|
|
|
|
- void *priv)
|
|
|
|
-{
|
|
|
|
- struct net_device *dev = priv;
|
|
|
|
- int i;
|
|
|
|
-
|
|
|
|
- if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
|
|
|
|
- return -EINVAL;
|
|
|
|
- if (tuple->TupleDataLen < ETH_ALEN + 2) {
|
|
|
|
- dev_warn(&p_dev->dev, "Invalid CIS tuple length for "
|
|
|
|
- "LAN_NODE_ID\n");
|
|
|
|
- return -EINVAL;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- if (tuple->TupleData[1] != ETH_ALEN) {
|
|
|
|
- dev_warn(&p_dev->dev, "Invalid header for LAN_NODE_ID\n");
|
|
|
|
- return -EINVAL;
|
|
|
|
- }
|
|
|
|
- for (i = 0; i < 6; i++)
|
|
|
|
- dev->dev_addr[i] = tuple->TupleData[i+2];
|
|
|
|
- return 0;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-/**
|
|
|
|
- * pcmcia_get_mac_from_cis() - read out MAC address from CISTPL_FUNCE
|
|
|
|
- * @p_dev: the struct pcmcia_device for which we want the address.
|
|
|
|
- * @dev: a properly prepared struct net_device to store the info to.
|
|
|
|
- *
|
|
|
|
- * pcmcia_get_mac_from_cis() reads out the hardware MAC address from
|
|
|
|
- * CISTPL_FUNCE and stores it into struct net_device *dev->dev_addr which
|
|
|
|
- * must be set up properly by the driver (see examples!).
|
|
|
|
- */
|
|
|
|
-int pcmcia_get_mac_from_cis(struct pcmcia_device *p_dev, struct net_device *dev)
|
|
|
|
-{
|
|
|
|
- return pcmcia_loop_tuple(p_dev, CISTPL_FUNCE, pcmcia_do_get_mac, dev);
|
|
|
|
-}
|
|
|
|
-EXPORT_SYMBOL(pcmcia_get_mac_from_cis);
|
|
|
|
-
|
|
|