From 933a838aa1aae8388438bb002fbdaf6fca519a5c Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Tue, 29 Dec 2009 18:21:39 +0100 Subject: pcmcia: make use of pcmcia_dev_resume() return value In runtime_resume(), do not throw away the return value of pcmcia_dev_resume(), for we can use it (at least) in pcmcia_store_pm_state(). This also fixes the pointless assignment previosly seen there, as noted by Dan Carpenter. CC: Dan Carpenter Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 1a4a3c49cc15..defa44c27b97 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -970,13 +970,14 @@ static int runtime_suspend(struct device *dev) return rc; } -static void runtime_resume(struct device *dev) +static int runtime_resume(struct device *dev) { int rc; down(&dev->sem); rc = pcmcia_dev_resume(dev); up(&dev->sem); + return rc; } /************************ per-device sysfs output ***************************/ @@ -1027,7 +1028,7 @@ static ssize_t pcmcia_store_pm_state(struct device *dev, struct device_attribute if ((!p_dev->suspended) && !strncmp(buf, "off", 3)) ret = runtime_suspend(dev); else if (p_dev->suspended && !strncmp(buf, "on", 2)) - runtime_resume(dev); + ret = runtime_resume(dev); return ret ? ret : count; } -- cgit v1.2.3 From 88b060d6c03fcb9e4d2018b4349954c4242a5c7f Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 2 Jan 2010 14:14:23 +0100 Subject: pcmcia: improve check for same card in slot after resume During a suspend/resume cycle, an user may change the card in the PCMCIA/CardBus slot. The pcmcia_core can at least look at the socket state to check whether it is the same. For PCMCIA devices, move the detection and handling of such a change to ds.c. For CardBus devices, the PCI hotplug interface doesn't offer a "rescan" facility which also _removes_ devices no longer to be found behind a bridge. Therefore, remove and re-add all devices unconditionally. CC: Jesse Barnes CC: Linus Torvalds Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index defa44c27b97..87e06395c129 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -1252,8 +1252,22 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) case CS_EVENT_EJECTION_REQUEST: break; - case CS_EVENT_PM_SUSPEND: case CS_EVENT_PM_RESUME: + if (verify_cis_cache(skt) != 0) { + dev_dbg(&skt->dev, "cis mismatch - different card\n"); + /* first, remove the card */ + ds_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH); + destroy_cis_cache(skt); + kfree(skt->fake_cis); + skt->fake_cis = NULL; + /* now, add the new card */ + ds_event(skt, CS_EVENT_CARD_INSERTION, + CS_EVENT_PRI_LOW); + } + handle_event(skt, event); + break; + + case CS_EVENT_PM_SUSPEND: case CS_EVENT_RESET_PHYSICAL: case CS_EVENT_CARD_RESET: default: -- cgit v1.2.3 From 180c33ee409eb3ed605d4ad9884e4a526a7655ff Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 2 Jan 2010 17:34:09 +0100 Subject: pcmcia: call CIS cleanup from ds.c As ds.c is the only real user of CIS access functions, call the cleanup functions from ds.c, too. Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 87e06395c129..7bb52b003f0e 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -1241,10 +1241,12 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) s->pcmcia_state.present = 0; pcmcia_card_remove(skt, NULL); handle_event(skt, event); + destroy_cis_cache(s); break; case CS_EVENT_CARD_INSERTION: s->pcmcia_state.present = 1; + destroy_cis_cache(s); /* to be on the safe side... */ pcmcia_card_add(skt); handle_event(skt, event); break; @@ -1366,6 +1368,7 @@ static void pcmcia_bus_remove_socket(struct device *dev, /* unregister any unbound devices */ mutex_lock(&socket->skt_mutex); pcmcia_card_remove(socket, NULL); + release_cis_mem(socket); mutex_unlock(&socket->skt_mutex); pcmcia_put_socket(socket); -- cgit v1.2.3 From 6e7b51a733fde86d3be748543215a69da04d5bb7 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Wed, 6 Jan 2010 13:57:43 +0100 Subject: pcmcia: move cistpl.c into pcmcia module As PCMCIA is the only real user of CIS access functions, include cistpl.c in the PCMCIA module, not in the PCMCIA & CardBus core module. Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 7bb52b003f0e..0ab4fe045920 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -1313,6 +1313,7 @@ static struct pcmcia_callback pcmcia_bus_callback = { .owner = THIS_MODULE, .event = ds_event, .requery = pcmcia_bus_rescan, + .validate = pccard_validate_cis, .suspend = pcmcia_bus_suspend, .resume = pcmcia_bus_resume, }; @@ -1336,6 +1337,13 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev, */ msleep(250); + ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); + if (ret) { + dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); + pcmcia_put_socket(socket); + return ret; + } + #ifdef CONFIG_PCMCIA_IOCTL init_waitqueue_head(&socket->queue); #endif @@ -1371,6 +1379,8 @@ static void pcmcia_bus_remove_socket(struct device *dev, release_cis_mem(socket); mutex_unlock(&socket->skt_mutex); + sysfs_remove_bin_file(&dev->kobj, &pccard_cis_attr); + pcmcia_put_socket(socket); return; -- cgit v1.2.3 From 8680c4b3faa298dc768c2a78a94a84d89854eca9 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Tue, 12 Jan 2010 22:05:36 +0100 Subject: pcmcia: also lock fake and cache CIS by ops_mutex Specifically, struct list_head cis_cache; size_t fake_cis_len; u8 *fake_cis; are protected. Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 0ab4fe045920..4f7308df22c8 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -1241,12 +1241,16 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) s->pcmcia_state.present = 0; pcmcia_card_remove(skt, NULL); handle_event(skt, event); + mutex_lock(&s->ops_mutex); destroy_cis_cache(s); + mutex_unlock(&s->ops_mutex); break; case CS_EVENT_CARD_INSERTION: s->pcmcia_state.present = 1; + mutex_lock(&s->ops_mutex); destroy_cis_cache(s); /* to be on the safe side... */ + mutex_unlock(&s->ops_mutex); pcmcia_card_add(skt); handle_event(skt, event); break; @@ -1259,9 +1263,11 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) dev_dbg(&skt->dev, "cis mismatch - different card\n"); /* first, remove the card */ ds_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH); + mutex_lock(&s->ops_mutex); destroy_cis_cache(skt); kfree(skt->fake_cis); skt->fake_cis = NULL; + mutex_unlock(&s->ops_mutex); /* now, add the new card */ ds_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW); -- cgit v1.2.3 From e6e4f397e5d0970ee1bb7a5591ac93b37cfa524a Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 16 Jan 2010 01:34:06 +0100 Subject: pcmcia: protect s->device_count Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 4f7308df22c8..bcb9ef103427 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -265,6 +265,7 @@ static int pcmcia_device_probe(struct device *dev) struct pcmcia_device_id *did; struct pcmcia_socket *s; cistpl_config_t cis_config; + unsigned long flags; int ret = 0; dev = get_device(dev); @@ -315,9 +316,11 @@ static int pcmcia_device_probe(struct device *dev) goto put_module; } + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && (p_dev->socket->device_count == 1) && (p_dev->device_no == 0)) pcmcia_add_device_later(p_dev->socket, 0); + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); put_module: if (ret) @@ -342,10 +345,12 @@ static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *le "pcmcia_card_remove(%d) %s\n", s->sock, leftover ? leftover->devname : ""); + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); if (!leftover) s->device_count = 0; else s->device_count = 1; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); /* unregister all pcmcia_devices registered with this socket, except leftover */ list_for_each_entry_safe(p_dev, tmp, &s->devices_list, socket_device_list) { @@ -382,7 +387,7 @@ static int pcmcia_device_remove(struct device *dev) */ did = dev_get_drvdata(&p_dev->dev); if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && - (p_dev->socket->device_count != 0) && + (p_dev->socket->device_count > 0) && (p_dev->device_no == 0)) pcmcia_card_remove(p_dev->socket, p_dev); @@ -512,16 +517,19 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu pr_debug("adding device to %d, function %d\n", s->sock, function); - /* max of 4 devices per card */ - if (s->device_count == 4) - goto err_put; - p_dev = kzalloc(sizeof(struct pcmcia_device), GFP_KERNEL); if (!p_dev) goto err_put; - p_dev->socket = s; + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); p_dev->device_no = (s->device_count++); + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + + /* max of 4 devices per card */ + if (p_dev->device_no >= 4) + goto err_free; + + p_dev->socket = s; p_dev->func = function; p_dev->dev.bus = &pcmcia_bus_type; @@ -586,9 +594,12 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); err_free: + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + s->device_count--; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + kfree(p_dev->devname); kfree(p_dev); - s->device_count--; err_put: mutex_unlock(&device_add_lock); pcmcia_put_socket(s); -- cgit v1.2.3 From 3d3de32fad19e37695e6649136e4cb17f9d46329 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 16 Jan 2010 08:32:56 +0100 Subject: pcmcia: add locking to struct pcmcia_socket->pcmcia_state() Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 33 ++++++++++++++++++++++++++++++--- 1 file changed, 30 insertions(+), 3 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index bcb9ef103427..0eb242cbed17 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -649,10 +649,17 @@ static void pcmcia_delayed_add_device(struct work_struct *work) { struct pcmcia_socket *s = container_of(work, struct pcmcia_socket, device_add); - dev_dbg(&s->dev, "adding additional device to %d\n", s->sock); - pcmcia_device_add(s, s->pcmcia_state.mfc_pfc); + u8 mfc_pfc; + unsigned long flags; + + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mfc_pfc = s->pcmcia_state.mfc_pfc; s->pcmcia_state.device_add_pending = 0; s->pcmcia_state.mfc_pfc = 0; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + + dev_dbg(&s->dev, "adding additional device to %d\n", s->sock); + pcmcia_device_add(s, mfc_pfc); } static int pcmcia_requery(struct device *dev, void * _data) @@ -761,8 +768,13 @@ static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) if (old_funcs > no_funcs) pcmcia_card_remove(s, dev); - else if (no_funcs > old_funcs) + else if (no_funcs > old_funcs) { + unsigned long flags; + + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); pcmcia_add_device_later(s, 1); + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + } } release: release_firmware(fw); @@ -1236,6 +1248,7 @@ static int pcmcia_bus_suspend(struct pcmcia_socket *skt) static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) { struct pcmcia_socket *s = pcmcia_get_socket(skt); + unsigned long flags; if (!s) { dev_printk(KERN_ERR, &skt->dev, @@ -1249,7 +1262,9 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) switch (event) { case CS_EVENT_CARD_REMOVAL: + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); s->pcmcia_state.present = 0; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); pcmcia_card_remove(skt, NULL); handle_event(skt, event); mutex_lock(&s->ops_mutex); @@ -1258,7 +1273,9 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) break; case CS_EVENT_CARD_INSERTION: + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); s->pcmcia_state.present = 1; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); mutex_lock(&s->ops_mutex); destroy_cis_cache(s); /* to be on the safe side... */ mutex_unlock(&s->ops_mutex); @@ -1304,14 +1321,19 @@ struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) { struct pcmcia_device *p_dev; struct pcmcia_device *ret = NULL; + unsigned long flags; p_dev = pcmcia_get_dev(_p_dev); if (!p_dev) return NULL; + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); if (!p_dev->socket->pcmcia_state.present) goto out; + if (p_dev->socket->pcmcia_state.dead) + goto out; + if (p_dev->_removed) goto out; @@ -1320,6 +1342,7 @@ struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) ret = p_dev; out: + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); pcmcia_put_dev(p_dev); return ret; } @@ -1383,11 +1406,15 @@ static void pcmcia_bus_remove_socket(struct device *dev, struct class_interface *class_intf) { struct pcmcia_socket *socket = dev_get_drvdata(dev); + unsigned long flags; if (!socket) return; + spin_lock_irqsave(&pcmcia_dev_list_lock, flags); socket->pcmcia_state.dead = 1; + spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + pccard_register_pcmcia(socket, NULL); /* unregister any unbound devices */ -- cgit v1.2.3 From 00ce99ff506a17882747a7d6874e3f5206a99043 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 16 Jan 2010 09:14:11 +0100 Subject: pcmcia: simplify locking replace pcmcia_socket->lock and pcmcia_dev_list_lock by using the per-socket "ops_mutex", as we do neither need different locks nor a spinlock here. Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 70 +++++++++++++++++++++-------------------------------- 1 file changed, 27 insertions(+), 43 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 0eb242cbed17..4c40db8889d9 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -42,8 +42,6 @@ MODULE_DESCRIPTION("PCMCIA Driver Services"); MODULE_LICENSE("GPL"); -spinlock_t pcmcia_dev_list_lock; - /*====================================================================*/ static void pcmcia_check_driver(struct pcmcia_driver *p_drv) @@ -265,7 +263,6 @@ static int pcmcia_device_probe(struct device *dev) struct pcmcia_device_id *did; struct pcmcia_socket *s; cistpl_config_t cis_config; - unsigned long flags; int ret = 0; dev = get_device(dev); @@ -316,11 +313,11 @@ static int pcmcia_device_probe(struct device *dev) goto put_module; } - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && (p_dev->socket->device_count == 1) && (p_dev->device_no == 0)) pcmcia_add_device_later(p_dev->socket, 0); - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); put_module: if (ret) @@ -339,28 +336,27 @@ static void pcmcia_card_remove(struct pcmcia_socket *s, struct pcmcia_device *le { struct pcmcia_device *p_dev; struct pcmcia_device *tmp; - unsigned long flags; dev_dbg(leftover ? &leftover->dev : &s->dev, "pcmcia_card_remove(%d) %s\n", s->sock, leftover ? leftover->devname : ""); - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); if (!leftover) s->device_count = 0; else s->device_count = 1; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); /* 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); + mutex_lock(&s->ops_mutex); list_del(&p_dev->socket_device_list); p_dev->_removed = 1; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); dev_dbg(&p_dev->dev, "unregistering device\n"); device_unregister(&p_dev->dev); @@ -507,7 +503,6 @@ static DEFINE_MUTEX(device_add_lock); struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int function) { struct pcmcia_device *p_dev, *tmp_dev; - unsigned long flags; s = pcmcia_get_socket(s); if (!s) @@ -521,9 +516,9 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu if (!p_dev) goto err_put; - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); p_dev->device_no = (s->device_count++); - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); /* max of 4 devices per card */ if (p_dev->device_no >= 4) @@ -546,7 +541,7 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu goto err_free; dev_dbg(&p_dev->dev, "devname is %s\n", p_dev->devname); - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); /* * p_dev->function_config must be the same for all card functions. @@ -564,7 +559,7 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu /* Add to the list in pcmcia_bus_socket */ list_add(&p_dev->socket_device_list, &s->devices_list); - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); if (!p_dev->function_config) { dev_dbg(&p_dev->dev, "creating config_t\n"); @@ -589,14 +584,14 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu return p_dev; err_unreg: - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); list_del(&p_dev->socket_device_list); - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); err_free: - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); s->device_count--; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); kfree(p_dev->devname); kfree(p_dev); @@ -650,13 +645,12 @@ static void pcmcia_delayed_add_device(struct work_struct *work) struct pcmcia_socket *s = container_of(work, struct pcmcia_socket, device_add); u8 mfc_pfc; - unsigned long flags; - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); mfc_pfc = s->pcmcia_state.mfc_pfc; s->pcmcia_state.device_add_pending = 0; s->pcmcia_state.mfc_pfc = 0; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); dev_dbg(&s->dev, "adding additional device to %d\n", s->sock); pcmcia_device_add(s, mfc_pfc); @@ -677,15 +671,14 @@ static void pcmcia_bus_rescan(struct pcmcia_socket *skt, int new_cis) { int no_devices = 0; int ret = 0; - unsigned long flags; /* must be called with skt_mutex held */ dev_dbg(&skt->dev, "re-scanning socket %d\n", skt->sock); - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&skt->ops_mutex); if (list_empty(&skt->devices_list)) no_devices = 1; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&skt->ops_mutex); /* If this is because of a CIS override, start over */ if (new_cis && !no_devices) @@ -769,11 +762,9 @@ static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) if (old_funcs > no_funcs) pcmcia_card_remove(s, dev); else if (no_funcs > old_funcs) { - unsigned long flags; - - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); pcmcia_add_device_later(s, 1); - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); } } release: @@ -1248,7 +1239,6 @@ static int pcmcia_bus_suspend(struct pcmcia_socket *skt) static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) { struct pcmcia_socket *s = pcmcia_get_socket(skt); - unsigned long flags; if (!s) { dev_printk(KERN_ERR, &skt->dev, @@ -1262,9 +1252,9 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) switch (event) { case CS_EVENT_CARD_REMOVAL: - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&s->ops_mutex); s->pcmcia_state.present = 0; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&s->ops_mutex); pcmcia_card_remove(skt, NULL); handle_event(skt, event); mutex_lock(&s->ops_mutex); @@ -1273,10 +1263,8 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) break; case CS_EVENT_CARD_INSERTION: - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); - s->pcmcia_state.present = 1; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); mutex_lock(&s->ops_mutex); + s->pcmcia_state.present = 1; destroy_cis_cache(s); /* to be on the safe side... */ mutex_unlock(&s->ops_mutex); pcmcia_card_add(skt); @@ -1321,13 +1309,12 @@ struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) { struct pcmcia_device *p_dev; struct pcmcia_device *ret = NULL; - unsigned long flags; p_dev = pcmcia_get_dev(_p_dev); if (!p_dev) return NULL; - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&p_dev->socket->ops_mutex); if (!p_dev->socket->pcmcia_state.present) goto out; @@ -1342,7 +1329,7 @@ struct pcmcia_device *pcmcia_dev_present(struct pcmcia_device *_p_dev) ret = p_dev; out: - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&p_dev->socket->ops_mutex); pcmcia_put_dev(p_dev); return ret; } @@ -1406,14 +1393,13 @@ static void pcmcia_bus_remove_socket(struct device *dev, struct class_interface *class_intf) { struct pcmcia_socket *socket = dev_get_drvdata(dev); - unsigned long flags; if (!socket) return; - spin_lock_irqsave(&pcmcia_dev_list_lock, flags); + mutex_lock(&socket->ops_mutex); socket->pcmcia_state.dead = 1; - spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); + mutex_unlock(&socket->ops_mutex); pccard_register_pcmcia(socket, NULL); @@ -1455,8 +1441,6 @@ static int __init init_pcmcia_bus(void) { int ret; - spin_lock_init(&pcmcia_dev_list_lock); - ret = bus_register(&pcmcia_bus_type); if (ret < 0) { printk(KERN_WARNING "pcmcia: bus_register error: %d\n", ret); -- cgit v1.2.3 From 94a819f80297e1f635a7cde4ed5317612e512ba7 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 17 Jan 2010 18:31:34 +0100 Subject: pcmcia: assert locking to struct pcmcia_device Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 4c40db8889d9..83b51ddd3da3 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -835,6 +835,8 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev, } if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) { + int ret; + if ((!dev->has_func_id) || (dev->func_id != did->func_id)) return 0; @@ -849,10 +851,15 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev, * after it has re-checked that there is no possible module * with a prod_id/manf_id/card_id match. */ - dev_dbg(&dev->dev, - "skipping FUNC_ID match until userspace interaction\n"); - if (!dev->allow_func_id_match) + mutex_lock(&dev->socket->ops_mutex); + ret = dev->allow_func_id_match; + mutex_unlock(&dev->socket->ops_mutex); + + if (!ret) { + dev_dbg(&dev->dev, + "skipping FUNC_ID match until userspace ACK\n"); return 0; + } } if (did->match_flags & PCMCIA_DEV_ID_MATCH_FAKE_CIS) { @@ -1079,9 +1086,9 @@ static ssize_t pcmcia_store_allow_func_id_match(struct device *dev, if (!count) return -EINVAL; - mutex_lock(&p_dev->socket->skt_mutex); + mutex_lock(&p_dev->socket->ops_mutex); p_dev->allow_func_id_match = 1; - mutex_unlock(&p_dev->socket->skt_mutex); + mutex_unlock(&p_dev->socket->ops_mutex); ret = bus_rescan_devices(&pcmcia_bus_type); if (ret) @@ -1114,8 +1121,13 @@ static int pcmcia_dev_suspend(struct device *dev, pm_message_t state) struct pcmcia_driver *p_drv = NULL; int ret = 0; - if (p_dev->suspended) + mutex_lock(&p_dev->socket->ops_mutex); + if (p_dev->suspended) { + mutex_unlock(&p_dev->socket->ops_mutex); return 0; + } + p_dev->suspended = 1; + mutex_unlock(&p_dev->socket->ops_mutex); dev_dbg(dev, "suspending\n"); @@ -1132,6 +1144,9 @@ static int pcmcia_dev_suspend(struct device *dev, pm_message_t state) "pcmcia: device %s (driver %s) did " "not want to go to sleep (%d)\n", p_dev->devname, p_drv->drv.name, ret); + mutex_lock(&p_dev->socket->ops_mutex); + p_dev->suspended = 0; + mutex_unlock(&p_dev->socket->ops_mutex); goto out; } } @@ -1142,8 +1157,6 @@ static int pcmcia_dev_suspend(struct device *dev, pm_message_t state) } out: - if (!ret) - p_dev->suspended = 1; return ret; } @@ -1154,8 +1167,13 @@ static int pcmcia_dev_resume(struct device *dev) struct pcmcia_driver *p_drv = NULL; int ret = 0; - if (!p_dev->suspended) + mutex_lock(&p_dev->socket->ops_mutex); + if (!p_dev->suspended) { + mutex_unlock(&p_dev->socket->ops_mutex); return 0; + } + p_dev->suspended = 0; + mutex_unlock(&p_dev->socket->ops_mutex); dev_dbg(dev, "resuming\n"); @@ -1176,8 +1194,6 @@ static int pcmcia_dev_resume(struct device *dev) ret = p_drv->resume(p_dev); out: - if (!ret) - p_dev->suspended = 0; return ret; } -- cgit v1.2.3 From 3f565232c561fbd9d5e03354aac29b90cb2bc78a Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sat, 16 Jan 2010 13:06:40 +0100 Subject: pcmcia: use mutex for dynid lock Even though we weren't calling a blocking function within the dynid spinlock, we do not need a spinlock here but can and should be using a mutex. Reported-by: Jiri Slaby Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 83b51ddd3da3..253d9aca5f77 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -124,9 +124,9 @@ pcmcia_store_new_id(struct device_driver *driver, const char *buf, size_t count) dynid->id.device_no = device_no; memcpy(dynid->id.prod_id_hash, prod_id_hash, sizeof(__u32) * 4); - spin_lock(&pdrv->dynids.lock); + mutex_lock(&pdrv->dynids.lock); list_add_tail(&dynid->node, &pdrv->dynids.list); - spin_unlock(&pdrv->dynids.lock); + mutex_unlock(&pdrv->dynids.lock); if (get_driver(&pdrv->drv)) { retval = driver_attach(&pdrv->drv); @@ -144,12 +144,12 @@ pcmcia_free_dynids(struct pcmcia_driver *drv) { struct pcmcia_dynid *dynid, *n; - spin_lock(&drv->dynids.lock); + mutex_lock(&drv->dynids.lock); list_for_each_entry_safe(dynid, n, &drv->dynids.list, node) { list_del(&dynid->node); kfree(dynid); } - spin_unlock(&drv->dynids.lock); + mutex_unlock(&drv->dynids.lock); } static int @@ -180,7 +180,7 @@ int pcmcia_register_driver(struct pcmcia_driver *driver) /* initialize common fields */ driver->drv.bus = &pcmcia_bus_type; driver->drv.owner = driver->owner; - spin_lock_init(&driver->dynids.lock); + mutex_init(&driver->dynids.lock); INIT_LIST_HEAD(&driver->dynids.list); pr_debug("registering driver %s\n", driver->drv.name); @@ -894,16 +894,16 @@ static int pcmcia_bus_match(struct device *dev, struct device_driver *drv) struct pcmcia_dynid *dynid; /* match dynamic devices first */ - spin_lock(&p_drv->dynids.lock); + mutex_lock(&p_drv->dynids.lock); list_for_each_entry(dynid, &p_drv->dynids.list, node) { dev_dbg(dev, "trying to match to %s\n", drv->name); if (pcmcia_devmatch(p_dev, &dynid->id)) { dev_dbg(dev, "matched to %s\n", drv->name); - spin_unlock(&p_drv->dynids.lock); + mutex_unlock(&p_drv->dynids.lock); return 1; } } - spin_unlock(&p_drv->dynids.lock); + mutex_unlock(&p_drv->dynids.lock); #ifdef CONFIG_PCMCIA_IOCTL /* matching by cardmgr */ -- cgit v1.2.3 From cfe5d809518eda3d5e2da87c5ccbe8647143573a Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 17 Jan 2010 19:31:45 +0100 Subject: pcmcia: use ops_mutex for rsrc_{mgr,nonstatic} locking Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 253d9aca5f77..76a21638291b 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -607,19 +607,23 @@ static int pcmcia_card_add(struct pcmcia_socket *s) { cistpl_longlink_mfc_t mfc; unsigned int no_funcs, i, no_chains; - int ret = 0; + int ret = -EAGAIN; + mutex_lock(&s->ops_mutex); if (!(s->resource_setup_done)) { dev_dbg(&s->dev, "no resources available, delaying card_add\n"); + mutex_unlock(&s->ops_mutex); return -EAGAIN; /* try again, but later... */ } if (pcmcia_validate_mem(s)) { dev_dbg(&s->dev, "validating mem resources failed, " "delaying card_add\n"); + mutex_unlock(&s->ops_mutex); return -EAGAIN; /* try again, but later... */ } + mutex_unlock(&s->ops_mutex); ret = pccard_validate_cis(s, &no_chains); if (ret || !no_chains) { -- cgit v1.2.3 From af461fc1875b6ec18e23b5f670af36c4ed35c84e Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 17 Jan 2010 19:30:53 +0100 Subject: pcmcia: delay re-scanning and re-querying of PCMCIA bus After a CIS update -- or the finalization of the resource database --, proceed with the re-scanning or re-querying of PCMCIA cards only in a separate thread to avoid deadlocks. Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 80 ++++++++++++++++++++++++++++++++--------------------- 1 file changed, 48 insertions(+), 32 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 76a21638291b..5400e20c664e 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -432,16 +432,20 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev) if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_MANFID, &manf_id)) { + mutex_lock(&p_dev->socket->ops_mutex); p_dev->manf_id = manf_id.manf; p_dev->card_id = manf_id.card; p_dev->has_manf_id = 1; p_dev->has_card_id = 1; + mutex_unlock(&p_dev->socket->ops_mutex); } if (!pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_FUNCID, &func_id)) { + mutex_lock(&p_dev->socket->ops_mutex); p_dev->func_id = func_id.func; p_dev->has_func_id = 1; + mutex_unlock(&p_dev->socket->ops_mutex); } else { /* rule of thumb: cards with no FUNCID, but with * common memory device geometry information, are @@ -458,14 +462,17 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev) dev_dbg(&p_dev->dev, "mem device geometry probably means " "FUNCID_MEMORY\n"); + mutex_lock(&p_dev->socket->ops_mutex); p_dev->func_id = CISTPL_FUNCID_MEMORY; p_dev->has_func_id = 1; + mutex_unlock(&p_dev->socket->ops_mutex); } kfree(devgeo); } if (!pccard_read_tuple(p_dev->socket, BIND_FN_ALL, CISTPL_VERS_1, vers1)) { + mutex_lock(&p_dev->socket->ops_mutex); for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) { char *tmp; unsigned int length; @@ -484,6 +491,7 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev) p_dev->prod_id[i] = strncpy(p_dev->prod_id[i], tmp, length); } + mutex_unlock(&p_dev->socket->ops_mutex); } kfree(vers1); @@ -660,7 +668,7 @@ static void pcmcia_delayed_add_device(struct work_struct *work) pcmcia_device_add(s, mfc_pfc); } -static int pcmcia_requery(struct device *dev, void * _data) +static int pcmcia_requery_callback(struct device *dev, void * _data) { struct pcmcia_device *p_dev = to_pcmcia_dev(dev); if (!p_dev->dev.driver) { @@ -671,44 +679,57 @@ static int pcmcia_requery(struct device *dev, void * _data) return 0; } -static void pcmcia_bus_rescan(struct pcmcia_socket *skt, int new_cis) +static void pcmcia_requery(struct pcmcia_socket *s) { - int no_devices = 0; - int ret = 0; - - /* must be called with skt_mutex held */ - dev_dbg(&skt->dev, "re-scanning socket %d\n", skt->sock); + int present; - mutex_lock(&skt->ops_mutex); - if (list_empty(&skt->devices_list)) - no_devices = 1; - mutex_unlock(&skt->ops_mutex); + mutex_lock(&s->ops_mutex); + present = s->pcmcia_state.present; + mutex_unlock(&s->ops_mutex); - /* If this is because of a CIS override, start over */ - if (new_cis && !no_devices) - pcmcia_card_remove(skt, NULL); + if (!present) + return; - /* if no devices were added for this socket yet because of - * missing resource information or other trouble, we need to - * do this now. */ - if (no_devices || new_cis) { - ret = pcmcia_card_add(skt); - if (ret) - return; + if (s->functions == 0) { + pcmcia_card_add(s); + return; } /* some device information might have changed because of a CIS * update or because we can finally read it correctly... so * determine it again, overwriting old values if necessary. */ - bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery); + bus_for_each_dev(&pcmcia_bus_type, NULL, NULL, pcmcia_requery_callback); + + /* if the CIS changed, we need to check whether the number of + * functions changed. */ + if (s->fake_cis) { + int old_funcs, new_funcs; + cistpl_longlink_mfc_t mfc; + + /* does this cis override add or remove functions? */ + old_funcs = s->functions; + + if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, + &mfc)) + new_funcs = mfc.nfn; + else + new_funcs = 1; + if (old_funcs > new_funcs) { + pcmcia_card_remove(s, NULL); + pcmcia_card_add(s); + } else if (new_funcs > old_funcs) { + s->functions = new_funcs; + pcmcia_device_add(s, 1); + } + } /* we re-scan all devices, not just the ones connected to this * socket. This does not matter, though. */ - ret = bus_rescan_devices(&pcmcia_bus_type); - if (ret) - printk(KERN_INFO "pcmcia: bus_rescan_devices failed\n"); + if (bus_rescan_devices(&pcmcia_bus_type)) + dev_warn(&s->dev, "rescanning the bus failed\n"); } + #ifdef CONFIG_PCMCIA_LOAD_CIS /** @@ -1085,7 +1106,6 @@ static ssize_t pcmcia_store_allow_func_id_match(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct pcmcia_device *p_dev = to_pcmcia_dev(dev); - int ret; if (!count) return -EINVAL; @@ -1093,11 +1113,7 @@ static ssize_t pcmcia_store_allow_func_id_match(struct device *dev, mutex_lock(&p_dev->socket->ops_mutex); p_dev->allow_func_id_match = 1; mutex_unlock(&p_dev->socket->ops_mutex); - - ret = bus_rescan_devices(&pcmcia_bus_type); - if (ret) - printk(KERN_INFO "pcmcia: bus_rescan_devices failed after " - "allowing func_id matches\n"); + pcmcia_parse_uevents(p_dev->socket, PCMCIA_UEVENT_REQUERY); return count; } @@ -1359,7 +1375,7 @@ EXPORT_SYMBOL(pcmcia_dev_present); static struct pcmcia_callback pcmcia_bus_callback = { .owner = THIS_MODULE, .event = ds_event, - .requery = pcmcia_bus_rescan, + .requery = pcmcia_requery, .validate = pccard_validate_cis, .suspend = pcmcia_bus_suspend, .resume = pcmcia_bus_resume, -- cgit v1.2.3 From aa584ca4cdd8db370a524c61fd3ca408303281e9 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 24 Jan 2010 14:36:59 +0100 Subject: pcmcia: use state machine for extended requery The requery callback now also handles the addition of a second pseudo multifunction device. Avoids messing with dev_{g,s}et_drvdata(), and fixes any workqueue <-> skt_mutex deadlock. Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 92 +++++++++++++---------------------------------------- 1 file changed, 22 insertions(+), 70 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 5400e20c664e..9968c0d3a5fb 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -244,23 +244,11 @@ static void pcmcia_release_dev(struct device *dev) kfree(p_dev); } -static void pcmcia_add_device_later(struct pcmcia_socket *s, int mfc) -{ - if (!s->pcmcia_state.device_add_pending) { - dev_dbg(&s->dev, "scheduling to add %s secondary" - " device to %d\n", mfc ? "mfc" : "pfc", s->sock); - s->pcmcia_state.device_add_pending = 1; - s->pcmcia_state.mfc_pfc = mfc; - schedule_work(&s->device_add); - } - return; -} static int pcmcia_device_probe(struct device *dev) { struct pcmcia_device *p_dev; struct pcmcia_driver *p_drv; - struct pcmcia_device_id *did; struct pcmcia_socket *s; cistpl_config_t cis_config; int ret = 0; @@ -273,18 +261,6 @@ static int pcmcia_device_probe(struct device *dev) p_drv = to_pcmcia_drv(dev->driver); s = p_dev->socket; - /* The PCMCIA code passes the match data in via dev_set_drvdata(dev) - * which is an ugly hack. Once the driver probe is called it may - * and often will overwrite the match data so we must save it first - * - * handle pseudo multifunction devices: - * there are at most two pseudo multifunction devices. - * if we're matching against the first, schedule a - * call which will then check whether there are two - * pseudo devices, and if not, add the second one. - */ - did = dev_get_drvdata(&p_dev->dev); - dev_dbg(dev, "trying to bind to %s\n", p_drv->drv.name); if ((!p_drv->probe) || (!p_dev->function_config) || @@ -314,9 +290,9 @@ static int pcmcia_device_probe(struct device *dev) } mutex_lock(&s->ops_mutex); - if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && + if ((s->pcmcia_state.has_pfc) && (p_dev->socket->device_count == 1) && (p_dev->device_no == 0)) - pcmcia_add_device_later(p_dev->socket, 0); + pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY); mutex_unlock(&s->ops_mutex); put_module: @@ -369,7 +345,6 @@ 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; p_dev = to_pcmcia_dev(dev); @@ -381,8 +356,7 @@ static int pcmcia_device_remove(struct device *dev) * pseudo multi-function card, we need to unbind * all devices */ - did = dev_get_drvdata(&p_dev->dev); - if (did && (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) && + if ((p_dev->socket->pcmcia_state.has_pfc) && (p_dev->socket->device_count > 0) && (p_dev->device_no == 0)) pcmcia_card_remove(p_dev->socket, p_dev); @@ -528,8 +502,8 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu p_dev->device_no = (s->device_count++); mutex_unlock(&s->ops_mutex); - /* max of 4 devices per card */ - if (p_dev->device_no >= 4) + /* max of 2 devices per card */ + if (p_dev->device_no >= 2) goto err_free; p_dev->socket = s; @@ -652,22 +626,6 @@ static int pcmcia_card_add(struct pcmcia_socket *s) } -static void pcmcia_delayed_add_device(struct work_struct *work) -{ - struct pcmcia_socket *s = - container_of(work, struct pcmcia_socket, device_add); - u8 mfc_pfc; - - mutex_lock(&s->ops_mutex); - mfc_pfc = s->pcmcia_state.mfc_pfc; - s->pcmcia_state.device_add_pending = 0; - s->pcmcia_state.mfc_pfc = 0; - mutex_unlock(&s->ops_mutex); - - dev_dbg(&s->dev, "adding additional device to %d\n", s->sock); - pcmcia_device_add(s, mfc_pfc); -} - static int pcmcia_requery_callback(struct device *dev, void * _data) { struct pcmcia_device *p_dev = to_pcmcia_dev(dev); @@ -679,9 +637,10 @@ static int pcmcia_requery_callback(struct device *dev, void * _data) return 0; } + static void pcmcia_requery(struct pcmcia_socket *s) { - int present; + int present, has_pfc; mutex_lock(&s->ops_mutex); present = s->pcmcia_state.present; @@ -723,6 +682,15 @@ static void pcmcia_requery(struct pcmcia_socket *s) } } + /* If the PCMCIA device consists of two pseudo devices, + * call pcmcia_device_add() -- which will fail if both + * devices are already registered. */ + mutex_lock(&s->ops_mutex); + has_pfc = s->pcmcia_state.has_pfc; + mutex_unlock(&s->ops_mutex); + if (has_pfc) + pcmcia_device_add(s, 0); + /* we re-scan all devices, not just the ones connected to this * socket. This does not matter, though. */ if (bus_rescan_devices(&pcmcia_bus_type)) @@ -746,9 +714,6 @@ static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) struct pcmcia_socket *s = dev->socket; const struct firmware *fw; int ret = -ENOMEM; - int no_funcs; - int old_funcs; - cistpl_longlink_mfc_t mfc; if (!filename) return -EINVAL; @@ -775,22 +740,8 @@ static int pcmcia_load_firmware(struct pcmcia_device *dev, char * filename) /* update information */ pcmcia_device_query(dev); - /* does this cis override add or remove functions? */ - old_funcs = s->functions; - - if (!pccard_read_tuple(s, BIND_FN_ALL, CISTPL_LONGLINK_MFC, &mfc)) - no_funcs = mfc.nfn; - else - no_funcs = 1; - s->functions = no_funcs; - - if (old_funcs > no_funcs) - pcmcia_card_remove(s, dev); - else if (no_funcs > old_funcs) { - mutex_lock(&s->ops_mutex); - pcmcia_add_device_later(s, 1); - mutex_unlock(&s->ops_mutex); - } + /* requery (as number of functions might have changed) */ + pcmcia_parse_uevents(s, PCMCIA_UEVENT_REQUERY); } release: release_firmware(fw); @@ -857,6 +808,9 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev, if (did->match_flags & PCMCIA_DEV_ID_MATCH_DEVICE_NO) { if (dev->device_no != did->device_no) return 0; + mutex_lock(&dev->socket->ops_mutex); + dev->socket->pcmcia_state.has_pfc = 1; + mutex_unlock(&dev->socket->ops_mutex); } if (did->match_flags & PCMCIA_DEV_ID_MATCH_FUNC_ID) { @@ -905,8 +859,6 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev, return 0; } - dev_set_drvdata(&dev->dev, did); - return 1; } @@ -1300,6 +1252,7 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) case CS_EVENT_CARD_INSERTION: mutex_lock(&s->ops_mutex); + s->pcmcia_state.has_pfc = 0; s->pcmcia_state.present = 1; destroy_cis_cache(s); /* to be on the safe side... */ mutex_unlock(&s->ops_mutex); @@ -1411,7 +1364,6 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev, init_waitqueue_head(&socket->queue); #endif INIT_LIST_HEAD(&socket->devices_list); - INIT_WORK(&socket->device_add, pcmcia_delayed_add_device); memset(&socket->pcmcia_state, 0, sizeof(u8)); socket->device_count = 0; -- cgit v1.2.3 From 44961a03adbf16d872f0b83ec848d0759516d33f Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 24 Jan 2010 12:11:02 +0100 Subject: pcmcia: avoid prod_id memleak Reported-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 9968c0d3a5fb..93925f5908b8 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -237,8 +237,11 @@ static void pcmcia_release_function(struct kref *ref) static void pcmcia_release_dev(struct device *dev) { struct pcmcia_device *p_dev = to_pcmcia_dev(dev); + int i; dev_dbg(dev, "releasing device\n"); pcmcia_put_socket(p_dev->socket); + for (i = 0; i < 4; i++) + kfree(p_dev->prod_id[i]); kfree(p_dev->devname); kref_put(&p_dev->function_config->ref, pcmcia_release_function); kfree(p_dev); @@ -450,6 +453,7 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev) for (i = 0; i < min_t(unsigned int, 4, vers1->ns); i++) { char *tmp; unsigned int length; + char *new; tmp = vers1->str + vers1->ofs[i]; @@ -457,13 +461,15 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev) if ((length < 2) || (length > 255)) continue; - p_dev->prod_id[i] = kmalloc(sizeof(char) * length, - GFP_KERNEL); - if (!p_dev->prod_id[i]) + new = kmalloc(sizeof(char) * length, GFP_KERNEL); + if (!new) continue; - p_dev->prod_id[i] = strncpy(p_dev->prod_id[i], - tmp, length); + new = strncpy(new, tmp, length); + + tmp = p_dev->prod_id[i]; + p_dev->prod_id[i] = new; + kfree(tmp); } mutex_unlock(&p_dev->socket->ops_mutex); } @@ -485,6 +491,7 @@ static DEFINE_MUTEX(device_add_lock); struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int function) { struct pcmcia_device *p_dev, *tmp_dev; + int i; s = pcmcia_get_socket(s); if (!s) @@ -575,6 +582,8 @@ struct pcmcia_device *pcmcia_device_add(struct pcmcia_socket *s, unsigned int fu s->device_count--; mutex_unlock(&s->ops_mutex); + for (i = 0; i < 4; i++) + kfree(p_dev->prod_id[i]); kfree(p_dev->devname); kfree(p_dev); err_put: -- cgit v1.2.3 From d801c1409ef7d45339cbe8ac9de28ade6ed4699a Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Wed, 17 Feb 2010 11:02:22 +0100 Subject: pcmcia: remove useless msleep in ds.c As this is the socket thread (pccardd) starting up, we do not have anything to wait for in ds.c. Instead, wait the same amount of time in pccardd to allow userspace to catch up and - possibly - execute pcmcia-socket-startup. Signed-off-by: Dominik Brodowski --- drivers/pcmcia/ds.c | 6 ------ 1 file changed, 6 deletions(-) (limited to 'drivers/pcmcia/ds.c') diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c index 93925f5908b8..0f98be4450b7 100644 --- a/drivers/pcmcia/ds.c +++ b/drivers/pcmcia/ds.c @@ -1356,12 +1356,6 @@ static int __devinit pcmcia_bus_add_socket(struct device *dev, return -ENODEV; } - /* - * Ugly. But we want to wait for the socket threads to have started up. - * We really should let the drivers themselves drive some of this.. - */ - msleep(250); - ret = sysfs_create_bin_file(&dev->kobj, &pccard_cis_attr); if (ret) { dev_printk(KERN_ERR, dev, "PCMCIA registration failed\n"); -- cgit v1.2.3