leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[PATCH] pcmcia: merge struct pcmcia_bus_socket into struct pcmcia_socket

Browse Source 
Merge struct pcmcia_bus_socket into struct pcmcia_socket.

Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
This commit is contained in:
Dominik Brodowski 2005-06-27 16:28:50 -07:00 committed by Linus Torvalds
parent b5e43913cf
commit dc109497bd
4 changed files with 118 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
drivers/pcmcia/ds.c
View File

@ -75,7 +75,7 @@ module_param_named(pc_debug, ds_pc_debug, int, 0644);
spinlock_t pcmcia_dev_list_lock; spinlock_t pcmcia_dev_list_lock;
static int unbind_request(struct pcmcia_bus_socket *s); static int unbind_request(struct pcmcia_socket *s);
/*====================================================================*/ /*====================================================================*/
@ -313,24 +313,6 @@ static inline int pcmcia_load_firmware(struct pcmcia_device *dev, char * filenam
/*======================================================================*/ /*======================================================================*/
void pcmcia_release_bus_socket(struct kref *refcount)
{
struct pcmcia_bus_socket *s = container_of(refcount, struct pcmcia_bus_socket, refcount);
pcmcia_put_socket(s->parent);
kfree(s);
}
void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s)
{
kref_put(&s->refcount, pcmcia_release_bus_socket);
}
struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s)
{
kref_get(&s->refcount);
return (s);
}
/** /**
* pcmcia_register_driver - register a PCMCIA driver with the bus core * pcmcia_register_driver - register a PCMCIA driver with the bus core
* *
@ -387,7 +369,7 @@ static void pcmcia_release_dev(struct device *dev)
{ {
struct pcmcia_device *p_dev = to_pcmcia_dev(dev); struct pcmcia_device *p_dev = to_pcmcia_dev(dev);
ds_dbg(1, "releasing dev %p\n", p_dev); ds_dbg(1, "releasing dev %p\n", p_dev);
pcmcia_put_bus_socket(p_dev->socket->pcmcia); pcmcia_put_socket(p_dev->socket);
kfree(p_dev); kfree(p_dev);
} }
@ -522,12 +504,12 @@ static int pcmcia_device_query(struct pcmcia_device *p_dev)
*/ */
static DECLARE_MUTEX(device_add_lock); static DECLARE_MUTEX(device_add_lock);
struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function) struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int function)
{ {
struct pcmcia_device *p_dev; struct pcmcia_device *p_dev;
unsigned long flags; unsigned long flags;
s = pcmcia_get_bus_socket(s); s = pcmcia_get_socket(s);
if (!s) if (!s)
return NULL; return NULL;
@ -542,18 +524,18 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned i
goto err_put; goto err_put;
memset(p_dev, 0, sizeof(struct pcmcia_device)); memset(p_dev, 0, sizeof(struct pcmcia_device));
p_dev->socket = s->parent; p_dev->socket = s;
p_dev->device_no = (s->device_count++); p_dev->device_no = (s->device_count++);
p_dev->func = function; p_dev->func = function;
p_dev->dev.bus = &pcmcia_bus_type; p_dev->dev.bus = &pcmcia_bus_type;
p_dev->dev.parent = s->parent->dev.dev; p_dev->dev.parent = s->dev.dev;
p_dev->dev.release = pcmcia_release_dev; p_dev->dev.release = pcmcia_release_dev;
sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no); sprintf (p_dev->dev.bus_id, "%d.%d", p_dev->socket->sock, p_dev->device_no);
/* compat */ /* compat */
p_dev->client.client_magic = CLIENT_MAGIC; p_dev->client.client_magic = CLIENT_MAGIC;
p_dev->client.Socket = s->parent; p_dev->client.Socket = s;
p_dev->client.Function = function; p_dev->client.Function = function;
p_dev->client.state = CLIENT_UNBOUND; p_dev->client.state = CLIENT_UNBOUND;
@ -581,7 +563,7 @@ struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned i
s->device_count--; s->device_count--;
err_put: err_put:
up(&device_add_lock); up(&device_add_lock);
pcmcia_put_bus_socket(s); pcmcia_put_socket(s);
return NULL; return NULL;
} }
@ -612,7 +594,7 @@ static int pcmcia_card_add(struct pcmcia_socket *s)
/* this doesn't handle multifunction devices on one pcmcia function /* this doesn't handle multifunction devices on one pcmcia function
* yet. */ * yet. */
for (i=0; i < no_funcs; i++) for (i=0; i < no_funcs; i++)
pcmcia_device_add(s->pcmcia, i); pcmcia_device_add(s, i);
return (ret); return (ret);
} }
@ -620,12 +602,12 @@ static int pcmcia_card_add(struct pcmcia_socket *s)
static void pcmcia_delayed_add_pseudo_device(void *data) static void pcmcia_delayed_add_pseudo_device(void *data)
{ {
struct pcmcia_bus_socket *s = data; struct pcmcia_socket *s = data;
pcmcia_device_add(s, 0); pcmcia_device_add(s, 0);
s->pcmcia_state.device_add_pending = 0; s->pcmcia_state.device_add_pending = 0;
} }
static inline void pcmcia_add_pseudo_device(struct pcmcia_bus_socket *s) static inline void pcmcia_add_pseudo_device(struct pcmcia_socket *s)
{ {
if (!s->pcmcia_state.device_add_pending) { if (!s->pcmcia_state.device_add_pending) {
schedule_work(&s->device_add); schedule_work(&s->device_add);
@ -650,7 +632,7 @@ static void pcmcia_bus_rescan(struct pcmcia_socket *skt)
/* must be called with skt_sem held */ /* must be called with skt_sem held */
spin_lock_irqsave(&pcmcia_dev_list_lock, flags); spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
if (list_empty(&skt->pcmcia->devices_list)) if (list_empty(&skt->devices_list))
no_devices=1; no_devices=1;
spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
@ -727,7 +709,7 @@ static inline int pcmcia_devmatch(struct pcmcia_device *dev,
* pseudo devices, and if not, add the second one. * pseudo devices, and if not, add the second one.
*/ */
if (dev->device_no == 0) if (dev->device_no == 0)
pcmcia_add_pseudo_device(dev->socket->pcmcia); pcmcia_add_pseudo_device(dev->socket);
if (dev->device_no != did->device_no) if (dev->device_no != did->device_no)
return 0; return 0;
@ -947,21 +929,13 @@ static int send_event_callback(struct device *dev, void * _data)
static int send_event(struct pcmcia_socket *s, event_t event, int priority) static int send_event(struct pcmcia_socket *s, event_t event, int priority)
{ {
int ret = 0;
struct send_event_data private; struct send_event_data private;
struct pcmcia_bus_socket *skt = pcmcia_get_bus_socket(s->pcmcia);
if (!skt)
return 0;
private.skt = s; private.skt = s;
private.event = event; private.event = event;
private.priority = priority; private.priority = priority;
ret = bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback); return bus_for_each_dev(&pcmcia_bus_type, NULL, &private, send_event_callback);
pcmcia_put_bus_socket(skt);
return ret;
} /* send_event */ } /* send_event */
@ -972,25 +946,25 @@ static int send_event(struct pcmcia_socket *s, event_t event, int priority)
static int ds_event(struct pcmcia_socket *skt, event_t event, int priority) static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
{ {
struct pcmcia_bus_socket *s = skt->pcmcia; struct pcmcia_socket *s = pcmcia_get_socket(skt);
int ret = 0; int ret = 0;
ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n", ds_dbg(1, "ds_event(0x%06x, %d, 0x%p)\n",
event, priority, s); event, priority, skt);
switch (event) { switch (event) {
case CS_EVENT_CARD_REMOVAL: case CS_EVENT_CARD_REMOVAL:
s->pcmcia_state.present = 0; s->pcmcia_state.present = 0;
send_event(skt, event, priority); send_event(skt, event, priority);
unbind_request(s); unbind_request(skt);
handle_event(s, event); handle_event(skt, event);
break; break;
case CS_EVENT_CARD_INSERTION: case CS_EVENT_CARD_INSERTION:
s->pcmcia_state.present = 1; s->pcmcia_state.present = 1;
pcmcia_card_add(skt); pcmcia_card_add(skt);
handle_event(s, event); handle_event(skt, event);
break; break;
case CS_EVENT_EJECTION_REQUEST: case CS_EVENT_EJECTION_REQUEST:
@ -998,11 +972,13 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
break; break;
default: default:
handle_event(s, event); handle_event(skt, event);
send_event(skt, event, priority); send_event(skt, event, priority);
break; break;
} }
pcmcia_put_socket(s);
return 0; return 0;
} /* ds_event */ } /* ds_event */
@ -1011,8 +987,7 @@ static int ds_event(struct pcmcia_socket *skt, event_t event, int priority)
int pcmcia_register_client(client_handle_t *handle, client_reg_t *req) int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
{ {
client_t *client = NULL; client_t *client = NULL;
struct pcmcia_socket *s; struct pcmcia_socket *s = NULL;
struct pcmcia_bus_socket *skt = NULL;
struct pcmcia_device *p_dev = NULL; struct pcmcia_device *p_dev = NULL;
/* Look for unbound client with matching dev_info */ /* Look for unbound client with matching dev_info */
@ -1023,14 +998,11 @@ int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
if (s->state & SOCKET_CARDBUS) if (s->state & SOCKET_CARDBUS)
continue; continue;
skt = s->pcmcia; s = pcmcia_get_socket(s);
if (!skt) if (!s)
continue;
skt = pcmcia_get_bus_socket(skt);
if (!skt)
continue; continue;
spin_lock_irqsave(&pcmcia_dev_list_lock, flags); spin_lock_irqsave(&pcmcia_dev_list_lock, flags);
list_for_each_entry(p_dev, &skt->devices_list, socket_device_list) { list_for_each_entry(p_dev, &s->devices_list, socket_device_list) {
struct pcmcia_driver *p_drv; struct pcmcia_driver *p_drv;
p_dev = pcmcia_get_dev(p_dev); p_dev = pcmcia_get_dev(p_dev);
if (!p_dev) if (!p_dev)
@ -1049,14 +1021,14 @@ int pcmcia_register_client(client_handle_t *handle, client_reg_t *req)
pcmcia_put_dev(p_dev); pcmcia_put_dev(p_dev);
} }
spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags); spin_unlock_irqrestore(&pcmcia_dev_list_lock, flags);
pcmcia_put_bus_socket(skt); pcmcia_put_socket(s);
} }
found: found:
up_read(&pcmcia_socket_list_rwsem); up_read(&pcmcia_socket_list_rwsem);
if (!p_dev || !client) if (!p_dev || !client)
return -ENODEV; return -ENODEV;
pcmcia_put_bus_socket(skt); /* safe, as we already hold a reference from bind_device */ pcmcia_put_socket(s); /* safe, as we already hold a reference from bind_device */
*handle = client; *handle = client;
client->state &= ~CLIENT_UNBOUND; client->state &= ~CLIENT_UNBOUND;
@ -1106,12 +1078,12 @@ EXPORT_SYMBOL(pcmcia_register_client);
/* unbind _all_ devices attached to a given pcmcia_bus_socket. The /* unbind _all_ devices attached to a given pcmcia_bus_socket. The
* drivers have been called with EVENT_CARD_REMOVAL before. * drivers have been called with EVENT_CARD_REMOVAL before.
*/ */
static int unbind_request(struct pcmcia_bus_socket *s) static int unbind_request(struct pcmcia_socket *s)
{ {
struct pcmcia_device *p_dev; struct pcmcia_device *p_dev;
unsigned long flags; unsigned long flags;
ds_dbg(2, "unbind_request(%d)\n", s->parent->sock); ds_dbg(2, "unbind_request(%d)\n", s->sock);
s->device_count = 0; s->device_count = 0;
@ -1176,24 +1148,14 @@ static struct pcmcia_callback pcmcia_bus_callback = {
static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev) static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
{ {
struct pcmcia_socket *socket = class_get_devdata(class_dev); struct pcmcia_socket *socket = class_get_devdata(class_dev);
struct pcmcia_bus_socket *s;
int ret; int ret;
s = kmalloc(sizeof(struct pcmcia_bus_socket), GFP_KERNEL); socket = pcmcia_get_socket(socket);
if(!s) if (!socket) {
return -ENOMEM;
memset(s, 0, sizeof(struct pcmcia_bus_socket));
/* get reference to parent socket */
s->parent = pcmcia_get_socket(socket);
if (!s->parent) {
printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket); printk(KERN_ERR "PCMCIA obtaining reference to socket %p failed\n", socket);
kfree (s);
return -ENODEV; return -ENODEV;
} }
kref_init(&s->refcount);
/* /*
* Ugly. But we want to wait for the socket threads to have started up. * 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.. * We really should let the drivers themselves drive some of this..
@ -1201,19 +1163,17 @@ static int __devinit pcmcia_bus_add_socket(struct class_device *class_dev)
msleep(250); msleep(250);
#ifdef CONFIG_PCMCIA_IOCTL #ifdef CONFIG_PCMCIA_IOCTL
init_waitqueue_head(&s->queue); init_waitqueue_head(&socket->queue);
#endif #endif
INIT_LIST_HEAD(&s->devices_list); INIT_LIST_HEAD(&socket->devices_list);
INIT_WORK(&s->device_add, pcmcia_delayed_add_pseudo_device, s); INIT_WORK(&socket->device_add, pcmcia_delayed_add_pseudo_device, socket);
memset(&socket->pcmcia_state, 0, sizeof(u8));
/* Set up hotline to Card Services */ socket->device_count = 0;
socket->pcmcia = s;
ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback); ret = pccard_register_pcmcia(socket, &pcmcia_bus_callback);
if (ret) { if (ret) {
printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket); printk(KERN_ERR "PCMCIA registration PCCard core failed for socket %p\n", socket);
pcmcia_put_bus_socket(s); pcmcia_put_socket(socket);
socket->pcmcia = NULL;
return (ret); return (ret);
} }
@ -1224,14 +1184,13 @@ static void pcmcia_bus_remove_socket(struct class_device *class_dev)
{ {
struct pcmcia_socket *socket = class_get_devdata(class_dev); struct pcmcia_socket *socket = class_get_devdata(class_dev);
if (!socket || !socket->pcmcia) if (!socket)
return; return;
socket->pcmcia_state.dead = 1;
pccard_register_pcmcia(socket, NULL); pccard_register_pcmcia(socket, NULL);
socket->pcmcia->pcmcia_state.dead = 1; pcmcia_put_socket(socket);
pcmcia_put_bus_socket(socket->pcmcia);
socket->pcmcia = NULL;
return; return;
} }

45
drivers/pcmcia/ds_internal.h
View File

@ -1,56 +1,21 @@
/* ds_internal.h - internal header for 16-bit PCMCIA devices management */ /* ds_internal.h - internal header for 16-bit PCMCIA devices management */
struct user_info_t;
/* Socket state information */
struct pcmcia_bus_socket {
struct kref refcount;
struct pcmcia_socket *parent;
/* the PCMCIA devices connected to this socket (normally one, more
* for multifunction devices: */
struct list_head devices_list;
u8 device_count; /* the number of devices, used
* only internally and subject
* to incorrectness and change */
struct {
u8 present:1,
busy:1,
dead:1,
device_add_pending:1,
reserved:4;
} pcmcia_state;
struct work_struct device_add;
#ifdef CONFIG_PCMCIA_IOCTL
struct user_info_t *user;
wait_queue_head_t queue;
#endif
};
extern spinlock_t pcmcia_dev_list_lock; extern spinlock_t pcmcia_dev_list_lock;
extern struct bus_type pcmcia_bus_type; extern struct bus_type pcmcia_bus_type;
extern struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev); extern struct pcmcia_device * pcmcia_get_dev(struct pcmcia_device *p_dev);
extern void pcmcia_put_dev(struct pcmcia_device *p_dev); extern void pcmcia_put_dev(struct pcmcia_device *p_dev);
struct pcmcia_bus_socket *pcmcia_get_bus_socket(struct pcmcia_bus_socket *s); struct pcmcia_device * pcmcia_device_add(struct pcmcia_socket *s, unsigned int function);
void pcmcia_put_bus_socket(struct pcmcia_bus_socket *s);
struct pcmcia_device * pcmcia_device_add(struct pcmcia_bus_socket *s, unsigned int function);
#ifdef CONFIG_PCMCIA_IOCTL #ifdef CONFIG_PCMCIA_IOCTL
extern void __init pcmcia_setup_ioctl(void); extern void __init pcmcia_setup_ioctl(void);
extern void __exit pcmcia_cleanup_ioctl(void); extern void __exit pcmcia_cleanup_ioctl(void);
extern void handle_event(struct pcmcia_bus_socket *s, event_t event); extern void handle_event(struct pcmcia_socket *s, event_t event);
extern int handle_request(struct pcmcia_bus_socket *s, event_t event); extern int handle_request(struct pcmcia_socket *s, event_t event);
#else #else
static inline void __init pcmcia_setup_ioctl(void) { return; } static inline void __init pcmcia_setup_ioctl(void) { return; }
static inline void __init pcmcia_cleanup_ioctl(void) { return; } static inline void __init pcmcia_cleanup_ioctl(void) { return; }
static inline void handle_event(struct pcmcia_bus_socket *s, event_t event) { return; } static inline void handle_event(struct pcmcia_socket *s, event_t event) { return; }
static inline int handle_request(struct pcmcia_bus_socket *s, event_t event) { return CS_SUCCESS; } static inline int handle_request(struct pcmcia_socket *s, event_t event) { return CS_SUCCESS; }
#endif #endif

97
drivers/pcmcia/pcmcia_ioctl.c
View File

@ -70,7 +70,7 @@ typedef struct user_info_t {
int event_head, event_tail; int event_head, event_tail;
event_t event[MAX_EVENTS]; event_t event[MAX_EVENTS];
struct user_info_t *next; struct user_info_t *next;
struct pcmcia_bus_socket *socket; struct pcmcia_socket *socket;
} user_info_t; } user_info_t;
@ -87,15 +87,6 @@ extern int ds_pc_debug;
#endif #endif
static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
{
struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
if (s && s->pcmcia)
return s->pcmcia;
else
return NULL;
}
/* backwards-compatible accessing of driver --- by name! */ /* backwards-compatible accessing of driver --- by name! */
static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info) static struct pcmcia_driver * get_pcmcia_driver (dev_info_t *dev_info)
@ -172,7 +163,7 @@ static void queue_event(user_info_t *user, event_t event)
user->event[user->event_head] = event; user->event[user->event_head] = event;
} }
void handle_event(struct pcmcia_bus_socket *s, event_t event) void handle_event(struct pcmcia_socket *s, event_t event)
{ {
user_info_t *user; user_info_t *user;
for (user = s->user; user; user = user->next) for (user = s->user; user; user = user->next)
@ -204,18 +195,18 @@ void handle_event(struct pcmcia_bus_socket *s, event_t event)
======================================================================*/ ======================================================================*/
static int bind_request(struct pcmcia_bus_socket *s, bind_info_t *bind_info) static int bind_request(struct pcmcia_socket *s, bind_info_t *bind_info)
{ {
struct pcmcia_driver *p_drv; struct pcmcia_driver *p_drv;
struct pcmcia_device *p_dev; struct pcmcia_device *p_dev;
int ret = 0; int ret = 0;
unsigned long flags; unsigned long flags;
s = pcmcia_get_bus_socket(s); s = pcmcia_get_socket(s);
if (!s) if (!s)
return -EINVAL; return -EINVAL;
ds_dbg(2, "bind_request(%d, '%s')\n", s->parent->sock, ds_dbg(2, "bind_request(%d, '%s')\n", s->sock,
(char *)bind_info->dev_info); (char *)bind_info->dev_info);
p_drv = get_pcmcia_driver(&bind_info->dev_info); p_drv = get_pcmcia_driver(&bind_info->dev_info);
@ -278,9 +269,9 @@ rescan:
/* /*
* Prevent this racing with a card insertion. * Prevent this racing with a card insertion.
*/ */
down(&s->parent->skt_sem); down(&s->skt_sem);
bus_rescan_devices(&pcmcia_bus_type); bus_rescan_devices(&pcmcia_bus_type);
up(&s->parent->skt_sem); up(&s->skt_sem);
/* check whether the driver indeed matched. I don't care if this /* check whether the driver indeed matched. I don't care if this
* is racy or not, because it can only happen on cardmgr access * is racy or not, because it can only happen on cardmgr access
@ -294,7 +285,7 @@ rescan:
err_put_driver: err_put_driver:
put_driver(&p_drv->drv); put_driver(&p_drv->drv);
err_put: err_put:
pcmcia_put_bus_socket(s); pcmcia_put_socket(s);
return (ret); return (ret);
} /* bind_request */ } /* bind_request */
@ -302,7 +293,7 @@ rescan:
extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s); extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info, int first) static int get_device_info(struct pcmcia_socket *s, bind_info_t *bind_info, int first)
{ {
dev_node_t *node; dev_node_t *node;
struct pcmcia_device *p_dev; struct pcmcia_device *p_dev;
@ -317,7 +308,7 @@ static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info,
{ {
struct pci_bus *bus; struct pci_bus *bus;
bus = pcmcia_lookup_bus(s->parent); bus = pcmcia_lookup_bus(s);
if (bus) { if (bus) {
struct list_head *list; struct list_head *list;
struct pci_dev *dev = NULL; struct pci_dev *dev = NULL;
@ -391,21 +382,21 @@ static int get_device_info(struct pcmcia_bus_socket *s, bind_info_t *bind_info,
static int ds_open(struct inode *inode, struct file *file) static int ds_open(struct inode *inode, struct file *file)
{ {
socket_t i = iminor(inode); socket_t i = iminor(inode);
struct pcmcia_bus_socket *s; struct pcmcia_socket *s;
user_info_t *user; user_info_t *user;
ds_dbg(0, "ds_open(socket %d)\n", i); ds_dbg(0, "ds_open(socket %d)\n", i);
s = get_socket_info_by_nr(i); s = pcmcia_get_socket_by_nr(i);
if (!s) if (!s)
return -ENODEV; return -ENODEV;
s = pcmcia_get_bus_socket(s); s = pcmcia_get_socket(s);
if (!s) if (!s)
return -ENODEV; return -ENODEV;
if ((file->f_flags & O_ACCMODE) != O_RDONLY) { if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
if (s->pcmcia_state.busy) { if (s->pcmcia_state.busy) {
pcmcia_put_bus_socket(s); pcmcia_put_socket(s);
return -EBUSY; return -EBUSY;
} }
else else
@ -414,7 +405,7 @@ static int ds_open(struct inode *inode, struct file *file)
user = kmalloc(sizeof(user_info_t), GFP_KERNEL); user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
if (!user) { if (!user) {
pcmcia_put_bus_socket(s); pcmcia_put_socket(s);
return -ENOMEM; return -ENOMEM;
} }
user->event_tail = user->event_head = 0; user->event_tail = user->event_head = 0;
@ -433,7 +424,7 @@ static int ds_open(struct inode *inode, struct file *file)
static int ds_release(struct inode *inode, struct file *file) static int ds_release(struct inode *inode, struct file *file)
{ {
struct pcmcia_bus_socket *s; struct pcmcia_socket *s;
user_info_t *user, **link; user_info_t *user, **link;
ds_dbg(0, "ds_release(socket %d)\n", iminor(inode)); ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
@ -456,7 +447,7 @@ static int ds_release(struct inode *inode, struct file *file)
*link = user->next; *link = user->next;
user->user_magic = 0; user->user_magic = 0;
kfree(user); kfree(user);
pcmcia_put_bus_socket(s); pcmcia_put_socket(s);
out: out:
return 0; return 0;
} /* ds_release */ } /* ds_release */
@ -466,7 +457,7 @@ out:
static ssize_t ds_read(struct file *file, char __user *buf, static ssize_t ds_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos) size_t count, loff_t *ppos)
{ {
struct pcmcia_bus_socket *s; struct pcmcia_socket *s;
user_info_t *user; user_info_t *user;
int ret; int ret;
@ -510,7 +501,7 @@ static ssize_t ds_write(struct file *file, const char __user *buf,
/* No kernel lock - fine */ /* No kernel lock - fine */
static u_int ds_poll(struct file *file, poll_table *wait) static u_int ds_poll(struct file *file, poll_table *wait)
{ {
struct pcmcia_bus_socket *s; struct pcmcia_socket *s;
user_info_t *user; user_info_t *user;
ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode)); ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
@ -536,7 +527,7 @@ extern int pcmcia_adjust_resource_info(adjust_t *adj);
static int ds_ioctl(struct inode * inode, struct file * file, static int ds_ioctl(struct inode * inode, struct file * file,
u_int cmd, u_long arg) u_int cmd, u_long arg)
{ {
struct pcmcia_bus_socket *s; struct pcmcia_socket *s;
void __user *uarg = (char __user *)arg; void __user *uarg = (char __user *)arg;
u_int size; u_int size;
int ret, err; int ret, err;
@ -589,57 +580,57 @@ static int ds_ioctl(struct inode * inode, struct file * file,
break; break;
case DS_GET_CONFIGURATION_INFO: case DS_GET_CONFIGURATION_INFO:
if (buf->config.Function && if (buf->config.Function &&
(buf->config.Function >= s->parent->functions)) (buf->config.Function >= s->functions))
ret = CS_BAD_ARGS; ret = CS_BAD_ARGS;
else else
ret = pccard_get_configuration_info(s->parent, ret = pccard_get_configuration_info(s,
buf->config.Function, &buf->config); buf->config.Function, &buf->config);
break; break;
case DS_GET_FIRST_TUPLE: case DS_GET_FIRST_TUPLE:
down(&s->parent->skt_sem); down(&s->skt_sem);
pcmcia_validate_mem(s->parent); pcmcia_validate_mem(s);
up(&s->parent->skt_sem); up(&s->skt_sem);
ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple); ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
break; break;
case DS_GET_NEXT_TUPLE: case DS_GET_NEXT_TUPLE:
ret = pccard_get_next_tuple(s->parent, BIND_FN_ALL, &buf->tuple); ret = pccard_get_next_tuple(s, BIND_FN_ALL, &buf->tuple);
break; break;
case DS_GET_TUPLE_DATA: case DS_GET_TUPLE_DATA:
buf->tuple.TupleData = buf->tuple_parse.data; buf->tuple.TupleData = buf->tuple_parse.data;
buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data); buf->tuple.TupleDataMax = sizeof(buf->tuple_parse.data);
ret = pccard_get_tuple_data(s->parent, &buf->tuple); ret = pccard_get_tuple_data(s, &buf->tuple);
break; break;
case DS_PARSE_TUPLE: case DS_PARSE_TUPLE:
buf->tuple.TupleData = buf->tuple_parse.data; buf->tuple.TupleData = buf->tuple_parse.data;
ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse); ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
break; break;
case DS_RESET_CARD: case DS_RESET_CARD:
ret = pccard_reset_card(s->parent); ret = pccard_reset_card(s);
break; break;
case DS_GET_STATUS: case DS_GET_STATUS:
if (buf->status.Function && if (buf->status.Function &&
(buf->status.Function >= s->parent->functions)) (buf->status.Function >= s->functions))
ret = CS_BAD_ARGS; ret = CS_BAD_ARGS;
else else
ret = pccard_get_status(s->parent, buf->status.Function, &buf->status); ret = pccard_get_status(s, buf->status.Function, &buf->status);
break; break;
case DS_VALIDATE_CIS: case DS_VALIDATE_CIS:
down(&s->parent->skt_sem); down(&s->skt_sem);
pcmcia_validate_mem(s->parent); pcmcia_validate_mem(s);
up(&s->parent->skt_sem); up(&s->skt_sem);
ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo); ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
break; break;
case DS_SUSPEND_CARD: case DS_SUSPEND_CARD:
ret = pcmcia_suspend_card(s->parent); ret = pcmcia_suspend_card(s);
break; break;
case DS_RESUME_CARD: case DS_RESUME_CARD:
ret = pcmcia_resume_card(s->parent); ret = pcmcia_resume_card(s);
break; break;
case DS_EJECT_CARD: case DS_EJECT_CARD:
err = pcmcia_eject_card(s->parent); err = pcmcia_eject_card(s);
break; break;
case DS_INSERT_CARD: case DS_INSERT_CARD:
err = pcmcia_insert_card(s->parent); err = pcmcia_insert_card(s);
break; break;
case DS_ACCESS_CONFIGURATION_REGISTER: case DS_ACCESS_CONFIGURATION_REGISTER:
if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) { if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
@ -647,10 +638,10 @@ static int ds_ioctl(struct inode * inode, struct file * file,
goto free_out; goto free_out;
} }
if (buf->conf_reg.Function && if (buf->conf_reg.Function &&
(buf->conf_reg.Function >= s->parent->functions)) (buf->conf_reg.Function >= s->functions))
ret = CS_BAD_ARGS; ret = CS_BAD_ARGS;
else else
ret = pccard_access_configuration_register(s->parent, ret = pccard_access_configuration_register(s,
buf->conf_reg.Function, &buf->conf_reg); buf->conf_reg.Function, &buf->conf_reg);
break; break;
case DS_GET_FIRST_REGION: case DS_GET_FIRST_REGION:
@ -671,11 +662,11 @@ static int ds_ioctl(struct inode * inode, struct file * file,
goto free_out; goto free_out;
break; break;
case DS_GET_FIRST_WINDOW: case DS_GET_FIRST_WINDOW:
ret = pcmcia_get_window(s->parent, &buf->win_info.handle, 0, ret = pcmcia_get_window(s, &buf->win_info.handle, 0,
&buf->win_info.window); &buf->win_info.window);
break; break;
case DS_GET_NEXT_WINDOW: case DS_GET_NEXT_WINDOW:
ret = pcmcia_get_window(s->parent, &buf->win_info.handle, ret = pcmcia_get_window(s, &buf->win_info.handle,
buf->win_info.handle->index + 1, &buf->win_info.window); buf->win_info.handle->index + 1, &buf->win_info.window);
break; break;
case DS_GET_MEM_PAGE: case DS_GET_MEM_PAGE:
@ -683,7 +674,7 @@ static int ds_ioctl(struct inode * inode, struct file * file,
&buf->win_info.map); &buf->win_info.map);
break; break;
case DS_REPLACE_CIS: case DS_REPLACE_CIS:
ret = pcmcia_replace_cis(s->parent, &buf->cisdump); ret = pcmcia_replace_cis(s, &buf->cisdump);
break; break;
case DS_BIND_REQUEST: case DS_BIND_REQUEST:
if (!capable(CAP_SYS_ADMIN)) { if (!capable(CAP_SYS_ADMIN)) {

31
include/pcmcia/ss.h
View File

@ -15,10 +15,12 @@
#ifndef _LINUX_SS_H #ifndef _LINUX_SS_H
#define _LINUX_SS_H #define _LINUX_SS_H
#include <linux/config.h>
#include <linux/device.h>
#include <pcmcia/cs_types.h> #include <pcmcia/cs_types.h>
#include <pcmcia/cs.h> #include <pcmcia/cs.h>
#include <pcmcia/bulkmem.h> #include <pcmcia/bulkmem.h>
#include <linux/device.h>
/* Definitions for card status flags for GetStatus */ /* Definitions for card status flags for GetStatus */
#define SS_WRPROT 0x0001 #define SS_WRPROT 0x0001
@ -171,7 +173,7 @@ typedef struct window_t {
struct config_t; struct config_t;
struct pcmcia_callback; struct pcmcia_callback;
struct user_info_t;
struct pcmcia_socket { struct pcmcia_socket {
struct module *owner; struct module *owner;
@ -242,9 +244,32 @@ struct pcmcia_socket {
unsigned int thread_events; unsigned int thread_events;
/* pcmcia (16-bit) */ /* pcmcia (16-bit) */
struct pcmcia_bus_socket *pcmcia;
struct pcmcia_callback *callback; struct pcmcia_callback *callback;
#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
struct list_head devices_list; /* PCMCIA devices */
u8 device_count; /* the number of devices, used
* only internally and subject
* to incorrectness and change */
struct {
u8 present:1, /* PCMCIA card is present in socket */
busy:1, /* "master" ioctl is used */
dead:1, /* pcmcia module is being unloaded */
device_add_pending:1, /* a pseudo-multifunction-device
* add event is pending */
reserved:4;
} pcmcia_state;
struct work_struct device_add; /* for adding further pseudo-multifunction
* devices */
#ifdef CONFIG_PCMCIA_IOCTL
struct user_info_t *user;
wait_queue_head_t queue;
#endif
#endif
/* cardbus (32-bit) */ /* cardbus (32-bit) */
#ifdef CONFIG_CARDBUS #ifdef CONFIG_CARDBUS
struct resource * cb_cis_res; struct resource * cb_cis_res;