* are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
*
* (C) 1999 David A. Hinds
- * (C) 2003 - 2006 Dominik Brodowski
+ * (C) 2003 - 2005 Dominik Brodowski
*/
+#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/workqueue.h>
#include <linux/crc32.h>
#include <linux/firmware.h>
-#include <linux/kref.h>
#define IN_CARD_SERVICES
#include <pcmcia/cs_types.h>
/**
* pcmcia_load_firmware - load CIS from userspace if device-provided is broken
* @dev - the pcmcia device which needs a CIS override
- * @filename - requested filename in /lib/firmware/
+ * @filename - requested filename in /lib/firmware/cis/
*
* This uses the in-kernel firmware loading mechanism to use a "fake CIS" if
* the one provided by the card is broken. The firmware files reside in
- * /lib/firmware/ in userspace.
+ * /lib/firmware/cis/ in userspace.
*/
static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename)
{
*
* Registers a PCMCIA driver with the PCMCIA bus core.
*/
+static int pcmcia_device_probe(struct device *dev);
+static int pcmcia_device_remove(struct device * dev);
+
int pcmcia_register_driver(struct pcmcia_driver *driver)
{
if (!driver)
put_device(&p_dev->dev);
}
-static void pcmcia_release_function(struct kref *ref)
-{
- struct config_t *c = container_of(ref, struct config_t, ref);
- kfree(c);
-}
-
static void pcmcia_release_dev(struct device *dev)
{
struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
ds_dbg(1, "releasing dev %p\n", p_dev);
pcmcia_put_socket(p_dev->socket);
kfree(p_dev->devname);
- kref_put(&p_dev->function_config->ref, pcmcia_release_function);
kfree(p_dev);
}
p_drv = to_pcmcia_drv(dev->driver);
s = p_dev->socket;
- if ((!p_drv->probe) || (!p_dev->function_config) ||
- (!try_module_get(p_drv->owner))) {
+ if ((!p_drv->probe) || (!try_module_get(p_drv->owner))) {
ret = -EINVAL;
goto put_dev;
}
+ p_dev->state &= ~CLIENT_UNBOUND;
+
+ /* set up the device configuration, if it hasn't been done before */
+ if (!s->functions) {
+ cistpl_longlink_mfc_t mfc;
+ if (pccard_read_tuple(s, p_dev->func, CISTPL_LONGLINK_MFC,
+ &mfc) == CS_SUCCESS)
+ s->functions = mfc.nfn;
+ else
+ s->functions = 1;
+ s->config = kzalloc(sizeof(config_t) * s->functions,
+ GFP_KERNEL);
+ if (!s->config) {
+ ret = -ENOMEM;
+ goto put_module;
+ }
+ }
+
ret = p_drv->probe(p_dev);
if (ret)
goto put_module;
* call which will then check whether there are two
* pseudo devices, and if not, add the second one.
*/
- did = p_dev->dev.driver_data;
+ did = (struct pcmcia_device_id *) p_dev->dev.driver_data;
if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) &&
(p_dev->socket->device_count == 1) && (p_dev->device_no == 0))
pcmcia_add_pseudo_device(p_dev->socket);
}
-/*
- * Removes a PCMCIA card from the device tree and socket list.
- */
-static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *leftover)
-{
- struct pcmcia_device *p_dev;
- struct pcmcia_device *tmp;
- unsigned long flags;
-
- ds_dbg(2, "unbind_request(%d)\n", s->sock);
-
-
- if (!leftover)
- s->device_count = 0;
- else
- s->device_count = 1;
-
- /* unregister all pcmcia_devices registered with this socket, except leftover */
- list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) {
- if (p_dev == leftover)
- continue;
-
- spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
- list_del(&p_dev->socket_device_list);
- p_dev->_removed=1;
- spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
-
- device_unregister(&p_dev->dev);
- }
-
- return;
-}
-
static int pcmcia_device_remove(struct device * dev)
{
struct pcmcia_device *p_dev;
struct pcmcia_driver *p_drv;
- struct pcmcia_device_id *did;
int i;
+ /* detach the "instance" */
p_dev = to_pcmcia_dev(dev);
p_drv = to_pcmcia_drv(dev->driver);
-
- /* If we're removing the primary module driving a
- * pseudo multi-function card, we need to unbind
- * all devices
- */
- did = p_dev->dev.driver_data;
- if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) &&
- (p_dev->socket->device_count != 0) &&
- (p_dev->device_no == 0))
- pcmcia_card_remove(p_dev->socket, p_dev);
-
- /* detach the "instance" */
if (!p_drv)
return 0;
if (p_drv->remove)
p_drv->remove(p_dev);
- p_dev->dev_node = NULL;
-
/* check for proper unloading */
- if (p_dev->_irq || p_dev->_io || p_dev->_locked)
+ if (p_dev->state & (CLIENT_IRQ_REQ|CLIENT_IO_REQ|CLIENT_CONFIG_LOCKED))
printk(KERN_INFO "pcmcia: driver %s did not release config properly\n",
p_drv->drv.name);
for (i = 0; i < MAX_WIN; i++)
- if (p_dev->_win & CLIENT_WIN_REQ(i))
+ if (p_dev->state & CLIENT_WIN_REQ(i))
printk(KERN_INFO "pcmcia: driver %s did not release windows properly\n",
p_drv->drv.name);
/* references from pcmcia_probe_device */
+ p_dev->state = CLIENT_UNBOUND;
pcmcia_put_dev(p_dev);
module_put(p_drv->owner);
}
+/*
+ * Removes a PCMCIA card from the device tree and socket list.
+ */
+static void pcmcia_card_remove(struct pcmcia_socket *s)
+{
+ struct pcmcia_device *p_dev;
+ unsigned long flags;
+
+ ds_dbg(2, "unbind_request(%d)\n", s->sock);
+
+ s->device_count = 0;
+
+ for (;;) {
+ /* unregister all pcmcia_devices registered with this socket*/
+ spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
+ if (list_empty(&s->devices_list)) {
+ spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
+ return;
+ }
+ p_dev = list_entry((&s->devices_list)->next, struct pcmcia_device, socket_device_list);
+ list_del(&p_dev->socket_device_list);
+ p_dev->state |= CLIENT_STALE;
+ spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
+
+ device_unregister(&p_dev->dev);
+ }
+
+ return;
+} /* unbind_request */
+
+
/*
* pcmcia_device_query -- determine information about a pcmcia device
*/
* won't work, this doesn't matter much at the moment: the driver core doesn't
* support it either.
*/
-static DEFINE_MUTEX(device_add_lock);
+static DECLARE_MUTEX(device_add_lock);
struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int function)
{
- struct pcmcia_device *p_dev, *tmp_dev;
+ struct pcmcia_device *p_dev;
unsigned long flags;
int bus_id_len;
if (!s)
return NULL;
- mutex_lock(&device_add_lock);
+ down(&device_add_lock);
/* max of 2 devices per card */
if (s->device_count == 2)
p_dev->socket = s;
p_dev->device_no = (s->device_count++);
p_dev->func = function;
- if (s->functions <= function)
- s->functions = function + 1;
p_dev->dev.bus = &pcmcia_bus_type;
p_dev->dev.parent = s->dev.dev;
sprintf (p_dev->devname, "pcmcia%s", p_dev->dev.bus_id);
/* compat */
- spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
-
- /*
- * p_dev->function_config must be the same for all card functions.
- * Note that this is serialized by the device_add_lock, so that
- * only one such struct will be created.
- */
- list_for_each_entry(tmp_dev, &s->devices_list, socket_device_list)
- if (p_dev->func == tmp_dev->func) {
- p_dev->function_config = tmp_dev->function_config;
- kref_get(&p_dev->function_config->ref);
- }
+ p_dev->state = CLIENT_UNBOUND;
/* Add to the list in pcmcia_bus_socket */
- list_add(&p_dev->socket_device_list, &s->devices_list);
-
+ spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
+ list_add_tail(&p_dev->socket_device_list, &s->devices_list);
spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
- if (!p_dev->function_config) {
- p_dev->function_config = kzalloc(sizeof(struct config_t),
- GFP_KERNEL);
- if (!p_dev->function_config)
- goto err_unreg;
- kref_init(&p_dev->function_config->ref);
- }
-
printk(KERN_NOTICE "pcmcia: registering new device %s\n",
p_dev->devname);
pcmcia_device_query(p_dev);
- if (device_register(&p_dev->dev))
- goto err_unreg;
+ if (device_register(&p_dev->dev)) {
+ spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
+ list_del(&p_dev->socket_device_list);
+ spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
- mutex_unlock(&device_add_lock);
+ goto err_free;
+ }
- return p_dev;
+ up(&device_add_lock);
- err_unreg:
- spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
- list_del(&p_dev->socket_device_list);
- spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
+ return p_dev;
err_free:
kfree(p_dev->devname);
kfree(p_dev);
s->device_count--;
err_put:
- mutex_unlock(&device_add_lock);
+ up(&device_add_lock);
pcmcia_put_socket(s);
return NULL;
int no_devices=0;
unsigned long flags;
- /* must be called with skt_mutex held */
+ /* must be called with skt_sem held */
spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
if (list_empty(&skt->devices_list))
no_devices=1;
struct pcmcia_driver * p_drv = to_pcmcia_drv(drv);
struct pcmcia_device_id *did = p_drv->id_table;
-#ifdef CONFIG_PCMCIA_IOCTL
/* matching by cardmgr */
if (p_dev->cardmgr == p_drv)
return 1;
-#endif
while (did && did->match_flags) {
if (pcmcia_devmatch(p_dev, did))
{
struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
- if (p_dev->suspended)
+ if (p_dev->dev.power.power_state.event != PM_EVENT_ON)
return sprintf(buf, "off\n");
else
return sprintf(buf, "on\n");
if (!count)
return -EINVAL;
- if ((!p_dev->suspended) && !strncmp(buf, "off", 3))
+ if ((p_dev->dev.power.power_state.event == PM_EVENT_ON) &&
+ (!strncmp(buf, "off", 3)))
ret = dpm_runtime_suspend(dev, PMSG_SUSPEND);
- else if (p_dev->suspended && !strncmp(buf, "on", 2))
+ else if ((p_dev->dev.power.power_state.event != PM_EVENT_ON) &&
+ (!strncmp(buf, "on", 2)))
dpm_runtime_resume(dev);
return ret ? ret : count;
if (!count)
return -EINVAL;
- mutex_lock(&p_dev->socket->skt_mutex);
+ down(&p_dev->socket->skt_sem);
p_dev->allow_func_id_match = 1;
- mutex_unlock(&p_dev->socket->skt_mutex);
+ up(&p_dev->socket->skt_sem);
bus_rescan_devices(&pcmcia_bus_type);
{
struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
struct pcmcia_driver *p_drv = NULL;
- int ret = 0;
if (dev->driver)
p_drv = to_pcmcia_drv(dev->driver);
- if (!p_drv)
- goto out;
+ if (p_drv && p_drv->suspend)
+ return p_drv->suspend(p_dev);
- if (p_drv->suspend) {
- ret = p_drv->suspend(p_dev);
- if (ret)
- goto out;
- }
-
- if (p_dev->device_no == p_dev->func)
- pcmcia_release_configuration(p_dev);
-
- out:
- if (!ret)
- p_dev->suspended = 1;
- return ret;
+ return 0;
}
{
struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
struct pcmcia_driver *p_drv = NULL;
- int ret = 0;
if (dev->driver)
p_drv = to_pcmcia_drv(dev->driver);
- if (!p_drv)
- goto out;
-
- if (p_dev->device_no == p_dev->func) {
- ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
- if (ret)
- goto out;
- }
-
- if (p_drv->resume)
- ret = p_drv->resume(p_dev);
+ if (p_drv && p_drv->resume)
+ return p_drv->resume(p_dev);
- out:
- if (!ret)
- p_dev->suspended = 0;
- return ret;
+ return 0;
}
{
struct pcmcia_socket *s = pcmcia_get_socket(skt);
- if (!s) {
- printk(KERN_ERR "PCMCIA obtaining reference to socket %p " \
- "failed, event 0x%x lost!\n", skt, event);
- return -ENODEV;
- }
-
ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
event, priority, skt);
switch (event) {
case CS_EVENT_CARD_REMOVAL:
s->pcmcia_state.present = 0;
- pcmcia_card_remove(skt, NULL);
+ pcmcia_card_remove(skt);
handle_event(skt, event);
break;
} /* ds_event */
-struct pcmcia_device * pcmcia_dev_present(struct pcmcia_device *_p_dev)
-{
- struct pcmcia_device *p_dev;
- struct pcmcia_device *ret = NULL;
-
- p_dev = pcmcia_get_dev(_p_dev);
- if (!p_dev)
- return NULL;
-
- if (!p_dev->socket->pcmcia_state.present)
- goto out;
-
- if (p_dev->_removed)
- goto out;
-
- if (p_dev->suspended)
- goto out;
-
- ret = p_dev;
- out:
- pcmcia_put_dev(p_dev);
- return ret;
-}
-EXPORT_SYMBOL(pcmcia_dev_present);
-
-
static struct pcmcia_callback pcmcia_bus_callback = {
.owner = THIS_MODULE,
.event = ds_event,
socket->pcmcia_state.dead = 1;
pccard_register_pcmcia(socket, NULL);
- /* unregister any unbound devices */
- mutex_lock(&socket->skt_mutex);
- pcmcia_card_remove(socket, NULL);
- mutex_unlock(&socket->skt_mutex);
-
pcmcia_put_socket(socket);
return;
git://git.onelab.eu / linux-2.6.git / blobdiff