#include <linux/config.h>
+#include <linux/kernel.h>
#include <linux/module.h>
-#include <linux/moduleparam.h>
#include <linux/init.h>
-#include <linux/kernel.h>
#include <linux/major.h>
-#include <linux/string.h>
#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/mm.h>
-#include <linux/fcntl.h>
-#include <linux/sched.h>
-#include <linux/smp_lock.h>
-#include <linux/timer.h>
#include <linux/ioctl.h>
#include <linux/proc_fs.h>
#include <linux/poll.h>
#include <linux/pci.h>
-#include <linux/list.h>
-#include <linux/delay.h>
-#include <linux/kref.h>
#include <linux/workqueue.h>
-#include <linux/crc32.h>
-
-#include <asm/atomic.h>
#define IN_CARD_SERVICES
#include <pcmcia/version.h>
#include <pcmcia/cs_types.h>
#include <pcmcia/cs.h>
-#include <pcmcia/bulkmem.h>
#include <pcmcia/cistpl.h>
#include <pcmcia/ds.h>
#include <pcmcia/ss.h>
int event_head, event_tail;
event_t event[MAX_EVENTS];
struct user_info_t *next;
- struct pcmcia_bus_socket *socket;
+ struct pcmcia_socket *socket;
} user_info_t;
#define ds_dbg(lvl, fmt, arg...) do { } while (0)
#endif
+static const char *release = "Linux Kernel Card Services";
-static struct pcmcia_bus_socket * get_socket_info_by_nr(unsigned int nr)
+/** pcmcia_get_card_services_info
+ *
+ * Return information about this version of Card Services
+ */
+static int pcmcia_get_card_services_info(servinfo_t *info)
{
- struct pcmcia_socket * s = pcmcia_get_socket_by_nr(nr);
- if (s && s->pcmcia)
- return s->pcmcia;
- else
- return NULL;
-}
+ unsigned int socket_count = 0;
+ struct list_head *tmp;
+ info->Signature[0] = 'C';
+ info->Signature[1] = 'S';
+ down_read(&pcmcia_socket_list_rwsem);
+ list_for_each(tmp, &pcmcia_socket_list)
+ socket_count++;
+ up_read(&pcmcia_socket_list_rwsem);
+ info->Count = socket_count;
+ info->Revision = CS_RELEASE_CODE;
+ info->CSLevel = 0x0210;
+ info->VendorString = (char *)release;
+ return CS_SUCCESS;
+} /* get_card_services_info */
+
/* backwards-compatible accessing of driver --- by name! */
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;
for (user = s->user; user; user = user->next)
======================================================================*/
-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_device *p_dev;
int ret = 0;
unsigned long flags;
- s = pcmcia_get_bus_socket(s);
+ s = pcmcia_get_socket(s);
if (!s)
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);
p_drv = get_pcmcia_driver(&bind_info->dev_info);
/*
* Prevent this racing with a card insertion.
*/
- down(&s->parent->skt_sem);
+ down(&s->skt_sem);
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
* is racy or not, because it can only happen on cardmgr access
err_put_driver:
put_driver(&p_drv->drv);
err_put:
- pcmcia_put_bus_socket(s);
+ pcmcia_put_socket(s);
return (ret);
} /* bind_request */
+#ifdef CONFIG_CARDBUS
-extern struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s);
+static struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
+{
+ if (!s || !(s->state & SOCKET_CARDBUS))
+ return NULL;
+
+ return s->cb_dev->subordinate;
+}
+#endif
-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;
struct pcmcia_device *p_dev;
{
struct pci_bus *bus;
- bus = pcmcia_lookup_bus(s->parent);
+ bus = pcmcia_lookup_bus(s);
if (bus) {
struct list_head *list;
struct pci_dev *dev = NULL;
static int ds_open(struct inode *inode, struct file *file)
{
socket_t i = iminor(inode);
- struct pcmcia_bus_socket *s;
+ struct pcmcia_socket *s;
user_info_t *user;
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)
return -ENODEV;
- s = pcmcia_get_bus_socket(s);
+ s = pcmcia_get_socket(s);
if (!s)
return -ENODEV;
if ((file->f_flags & O_ACCMODE) != O_RDONLY) {
if (s->pcmcia_state.busy) {
- pcmcia_put_bus_socket(s);
+ pcmcia_put_socket(s);
return -EBUSY;
}
else
user = kmalloc(sizeof(user_info_t), GFP_KERNEL);
if (!user) {
- pcmcia_put_bus_socket(s);
+ pcmcia_put_socket(s);
return -ENOMEM;
}
user->event_tail = user->event_head = 0;
static int ds_release(struct inode *inode, struct file *file)
{
- struct pcmcia_bus_socket *s;
+ struct pcmcia_socket *s;
user_info_t *user, **link;
ds_dbg(0, "ds_release(socket %d)\n", iminor(inode));
*link = user->next;
user->user_magic = 0;
kfree(user);
- pcmcia_put_bus_socket(s);
+ pcmcia_put_socket(s);
out:
return 0;
} /* ds_release */
static ssize_t ds_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
- struct pcmcia_bus_socket *s;
+ struct pcmcia_socket *s;
user_info_t *user;
int ret;
/* No kernel lock - fine */
static u_int ds_poll(struct file *file, poll_table *wait)
{
- struct pcmcia_bus_socket *s;
+ struct pcmcia_socket *s;
user_info_t *user;
ds_dbg(2, "ds_poll(socket %d)\n", iminor(file->f_dentry->d_inode));
static int ds_ioctl(struct inode * inode, struct file * file,
u_int cmd, u_long arg)
{
- struct pcmcia_bus_socket *s;
+ struct pcmcia_socket *s;
void __user *uarg = (char __user *)arg;
u_int size;
int ret, err;
break;
case DS_GET_CONFIGURATION_INFO:
if (buf->config.Function &&
- (buf->config.Function >= s->parent->functions))
+ (buf->config.Function >= s->functions))
ret = CS_BAD_ARGS;
else
- ret = pccard_get_configuration_info(s->parent,
+ ret = pccard_get_configuration_info(s,
buf->config.Function, &buf->config);
break;
case DS_GET_FIRST_TUPLE:
- down(&s->parent->skt_sem);
- pcmcia_validate_mem(s->parent);
- up(&s->parent->skt_sem);
- ret = pccard_get_first_tuple(s->parent, BIND_FN_ALL, &buf->tuple);
+ down(&s->skt_sem);
+ pcmcia_validate_mem(s);
+ up(&s->skt_sem);
+ ret = pccard_get_first_tuple(s, BIND_FN_ALL, &buf->tuple);
break;
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;
case DS_GET_TUPLE_DATA:
buf->tuple.TupleData = 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;
case DS_PARSE_TUPLE:
buf->tuple.TupleData = buf->tuple_parse.data;
ret = pccard_parse_tuple(&buf->tuple, &buf->tuple_parse.parse);
break;
case DS_RESET_CARD:
- ret = pccard_reset_card(s->parent);
+ ret = pccard_reset_card(s);
break;
case DS_GET_STATUS:
if (buf->status.Function &&
- (buf->status.Function >= s->parent->functions))
+ (buf->status.Function >= s->functions))
ret = CS_BAD_ARGS;
else
- ret = pccard_get_status(s->parent, buf->status.Function, &buf->status);
+ ret = pccard_get_status(s, buf->status.Function, &buf->status);
break;
case DS_VALIDATE_CIS:
- down(&s->parent->skt_sem);
- pcmcia_validate_mem(s->parent);
- up(&s->parent->skt_sem);
- ret = pccard_validate_cis(s->parent, BIND_FN_ALL, &buf->cisinfo);
+ down(&s->skt_sem);
+ pcmcia_validate_mem(s);
+ up(&s->skt_sem);
+ ret = pccard_validate_cis(s, BIND_FN_ALL, &buf->cisinfo);
break;
case DS_SUSPEND_CARD:
- ret = pcmcia_suspend_card(s->parent);
+ ret = pcmcia_suspend_card(s);
break;
case DS_RESUME_CARD:
- ret = pcmcia_resume_card(s->parent);
+ ret = pcmcia_resume_card(s);
break;
case DS_EJECT_CARD:
- err = pcmcia_eject_card(s->parent);
+ err = pcmcia_eject_card(s);
break;
case DS_INSERT_CARD:
- err = pcmcia_insert_card(s->parent);
+ err = pcmcia_insert_card(s);
break;
case DS_ACCESS_CONFIGURATION_REGISTER:
if ((buf->conf_reg.Action == CS_WRITE) && !capable(CAP_SYS_ADMIN)) {
goto free_out;
}
if (buf->conf_reg.Function &&
- (buf->conf_reg.Function >= s->parent->functions))
+ (buf->conf_reg.Function >= s->functions))
ret = CS_BAD_ARGS;
else
- ret = pccard_access_configuration_register(s->parent,
+ ret = pccard_access_configuration_register(s,
buf->conf_reg.Function, &buf->conf_reg);
break;
case DS_GET_FIRST_REGION:
goto free_out;
break;
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);
break;
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);
break;
case DS_GET_MEM_PAGE:
&buf->win_info.map);
break;
case DS_REPLACE_CIS:
- ret = pcmcia_replace_cis(s->parent, &buf->cisdump);
+ ret = pcmcia_replace_cis(s, &buf->cisdump);
break;
case DS_BIND_REQUEST:
if (!capable(CAP_SYS_ADMIN)) {
/* Set up character device for user mode clients */
i = register_chrdev(0, "pcmcia", &ds_fops);
- if (i == -EBUSY)
+ if (i < 0)
printk(KERN_NOTICE "unable to find a free device # for "
- "Driver Services\n");
+ "Driver Services (error=%d)\n", i);
else
major_dev = i;