URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [parport/] [procfs.c] - Blame information for rev 65

Go to most recent revision | Details | Compare with Previous | View Log


/* Sysctl interface for parport devices.
 *
 * Authors: David Campbell
 *          Tim Waugh <tim@cyberelk.demon.co.uk>
 *          Philip Blundell <philb@gnu.org>
 *          Andrea Arcangeli
 *          Riccardo Facchetti <fizban@tin.it>
 *
 * based on work by Grant Guenther <grant@torque.net>
 *              and Philip Blundell
 *
 * Cleaned up include files - Russell King <linux@arm.uk.linux.org>
 */
 
#include <linux/string.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/parport.h>
#include <linux/ctype.h>
#include <linux/sysctl.h>
 
#include <asm/uaccess.h>
 
#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)
 
#define PARPORT_MIN_TIMESLICE_VALUE 1ul 
#define PARPORT_MAX_TIMESLICE_VALUE ((unsigned long) HZ)
#define PARPORT_MIN_SPINTIME_VALUE 1
#define PARPORT_MAX_SPINTIME_VALUE 1000
 
static int do_active_device(ctl_table *table, int write, struct file *filp,
                      void __user *result, size_t *lenp, loff_t *ppos)
{
        struct parport *port = (struct parport *)table->extra1;
        char buffer[256];
        struct pardevice *dev;
        int len = 0;
 
        if (write)              /* can't happen anyway */
                return -EACCES;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        for (dev = port->devices; dev ; dev = dev->next) {
                if(dev == port->cad) {
                        len += sprintf(buffer, "%s\n", dev->name);
                }
        }
 
        if(!len) {
                len += sprintf(buffer, "%s\n", "none");
        }
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}
 
#ifdef CONFIG_PARPORT_1284
static int do_autoprobe(ctl_table *table, int write, struct file *filp,
                        void __user *result, size_t *lenp, loff_t *ppos)
{
        struct parport_device_info *info = table->extra2;
        const char *str;
        char buffer[256];
        int len = 0;
 
        if (write) /* permissions stop this */
                return -EACCES;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        if ((str = info->class_name) != NULL)
                len += sprintf (buffer + len, "CLASS:%s;\n", str);
 
        if ((str = info->model) != NULL)
                len += sprintf (buffer + len, "MODEL:%s;\n", str);
 
        if ((str = info->mfr) != NULL)
                len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);
 
        if ((str = info->description) != NULL)
                len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);
 
        if ((str = info->cmdset) != NULL)
                len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user (result, buffer, len) ? -EFAULT : 0;
}
#endif /* IEEE1284.3 support. */
 
static int do_hardware_base_addr (ctl_table *table, int write,
                                  struct file *filp, void __user *result,
                                  size_t *lenp, loff_t *ppos)
{
        struct parport *port = (struct parport *)table->extra1;
        char buffer[20];
        int len = 0;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        if (write) /* permissions prevent this anyway */
                return -EACCES;
 
        len += sprintf (buffer, "%lu\t%lu\n", port->base, port->base_hi);
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}
 
static int do_hardware_irq (ctl_table *table, int write,
                            struct file *filp, void __user *result,
                            size_t *lenp, loff_t *ppos)
{
        struct parport *port = (struct parport *)table->extra1;
        char buffer[20];
        int len = 0;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        if (write) /* permissions prevent this anyway */
                return -EACCES;
 
        len += sprintf (buffer, "%d\n", port->irq);
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}
 
static int do_hardware_dma (ctl_table *table, int write,
                            struct file *filp, void __user *result,
                            size_t *lenp, loff_t *ppos)
{
        struct parport *port = (struct parport *)table->extra1;
        char buffer[20];
        int len = 0;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        if (write) /* permissions prevent this anyway */
                return -EACCES;
 
        len += sprintf (buffer, "%d\n", port->dma);
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}
 
static int do_hardware_modes (ctl_table *table, int write,
                              struct file *filp, void __user *result,
                              size_t *lenp, loff_t *ppos)
{
        struct parport *port = (struct parport *)table->extra1;
        char buffer[40];
        int len = 0;
 
        if (*ppos) {
                *lenp = 0;
                return 0;
        }
 
        if (write) /* permissions prevent this anyway */
                return -EACCES;
 
        {
#define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}}
                int f = 0;
                printmode(PCSPP);
                printmode(TRISTATE);
                printmode(COMPAT);
                printmode(EPP);
                printmode(ECP);
                printmode(DMA);
#undef printmode
        }
        buffer[len++] = '\n';
 
        if (len > *lenp)
                len = *lenp;
        else
                *lenp = len;
 
        *ppos += len;
 
        return copy_to_user(result, buffer, len) ? -EFAULT : 0;
}
 
#define PARPORT_PORT_DIR(CHILD) { .ctl_name = 0, .procname = NULL, .mode = 0555, .child = CHILD }
#define PARPORT_PARPORT_DIR(CHILD) { .ctl_name = DEV_PARPORT, .procname = "parport", \
                                     .mode = 0555, .child = CHILD }
#define PARPORT_DEV_DIR(CHILD) { .ctl_name = CTL_DEV, .procname = "dev", .mode = 0555, .child = CHILD }
#define PARPORT_DEVICES_ROOT_DIR  {  .procname = "devices", \
                                    .mode = 0555, .child = NULL }
 
static const unsigned long parport_min_timeslice_value =
PARPORT_MIN_TIMESLICE_VALUE;
 
static const unsigned long parport_max_timeslice_value =
PARPORT_MAX_TIMESLICE_VALUE;
 
static const  int parport_min_spintime_value =
PARPORT_MIN_SPINTIME_VALUE;
 
static const int parport_max_spintime_value =
PARPORT_MAX_SPINTIME_VALUE;
 
 
struct parport_sysctl_table {
        struct ctl_table_header *sysctl_header;
        ctl_table vars[12];
        ctl_table device_dir[2];
        ctl_table port_dir[2];
        ctl_table parport_dir[2];
        ctl_table dev_dir[2];
};
 
static const struct parport_sysctl_table parport_sysctl_template = {
        .sysctl_header = NULL,
        {
                {
                        .procname       = "spintime",
                        .data           = NULL,
                        .maxlen         = sizeof(int),
                        .mode           = 0644,
                        .proc_handler   = &proc_dointvec_minmax,
                        .extra1         = (void*) &parport_min_spintime_value,
                        .extra2         = (void*) &parport_max_spintime_value
                },
                {
                        .procname       = "base-addr",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_hardware_base_addr
                },
                {
                        .procname       = "irq",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_hardware_irq
                },
                {
                        .procname       = "dma",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_hardware_dma
                },
                {
                        .procname       = "modes",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_hardware_modes
                },
                PARPORT_DEVICES_ROOT_DIR,
#ifdef CONFIG_PARPORT_1284
                {
                        .procname       = "autoprobe",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_autoprobe
                },
                {
                        .procname       = "autoprobe0",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   =  &do_autoprobe
                },
                {
                        .procname       = "autoprobe1",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_autoprobe
                },
                {
                        .procname       = "autoprobe2",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_autoprobe
                },
                {
                        .procname       = "autoprobe3",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_autoprobe
                },
#endif /* IEEE 1284 support */
                {}
        },
        {
                {
                        .procname       = "active",
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0444,
                        .proc_handler   = &do_active_device
                },
                {}
        },
        {
                PARPORT_PORT_DIR(NULL),
                {}
        },
        {
                PARPORT_PARPORT_DIR(NULL),
                {}
        },
        {
                PARPORT_DEV_DIR(NULL),
                {}
        }
};
 
struct parport_device_sysctl_table
{
        struct ctl_table_header *sysctl_header;
        ctl_table vars[2];
        ctl_table device_dir[2];
        ctl_table devices_root_dir[2];
        ctl_table port_dir[2];
        ctl_table parport_dir[2];
        ctl_table dev_dir[2];
};
 
static const struct parport_device_sysctl_table
parport_device_sysctl_template = {
        .sysctl_header = NULL,
        {
                {
                        .procname       = "timeslice",
                        .data           = NULL,
                        .maxlen         = sizeof(unsigned long),
                        .mode           = 0644,
                        .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
                        .extra1         = (void*) &parport_min_timeslice_value,
                        .extra2         = (void*) &parport_max_timeslice_value
                },
        },
        {
                {
                        .ctl_name       = 0,
                        .procname       = NULL,
                        .data           = NULL,
                        .maxlen         = 0,
                        .mode           = 0555,
                        .child          = NULL
                },
                {}
        },
        {
                PARPORT_DEVICES_ROOT_DIR,
                {}
        },
        {
                PARPORT_PORT_DIR(NULL),
                {}
        },
        {
                PARPORT_PARPORT_DIR(NULL),
                {}
        },
        {
                PARPORT_DEV_DIR(NULL),
                {}
        }
};
 
struct parport_default_sysctl_table
{
        struct ctl_table_header *sysctl_header;
        ctl_table vars[3];
        ctl_table default_dir[2];
        ctl_table parport_dir[2];
        ctl_table dev_dir[2];
};
 
extern unsigned long parport_default_timeslice;
extern int parport_default_spintime;
 
static struct parport_default_sysctl_table
parport_default_sysctl_table = {
        .sysctl_header  = NULL,
        {
                {
                        .procname       = "timeslice",
                        .data           = &parport_default_timeslice,
                        .maxlen         = sizeof(parport_default_timeslice),
                        .mode           = 0644,
                        .proc_handler   = &proc_doulongvec_ms_jiffies_minmax,
                        .extra1         = (void*) &parport_min_timeslice_value,
                        .extra2         = (void*) &parport_max_timeslice_value
                },
                {
                        .procname       = "spintime",
                        .data           = &parport_default_spintime,
                        .maxlen         = sizeof(parport_default_spintime),
                        .mode           = 0644,
                        .proc_handler   = &proc_dointvec_minmax,
                        .extra1         = (void*) &parport_min_spintime_value,
                        .extra2         = (void*) &parport_max_spintime_value
                },
                {}
        },
        {
                {
                        .ctl_name       = DEV_PARPORT_DEFAULT,
                        .procname       = "default",
                        .mode           = 0555,
                        .child          = parport_default_sysctl_table.vars
                },
                {}
        },
        {
                PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),
                {}
        },
        {
                PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir),
                {}
        }
};
 
 
int parport_proc_register(struct parport *port)
{
        struct parport_sysctl_table *t;
        int i;
 
        t = kmalloc(sizeof(*t), GFP_KERNEL);
        if (t == NULL)
                return -ENOMEM;
        memcpy(t, &parport_sysctl_template, sizeof(*t));
 
        t->device_dir[0].extra1 = port;
 
        for (i = 0; i < 5; i++)
                t->vars[i].extra1 = port;
 
        t->vars[0].data = &port->spintime;
        t->vars[5].child = t->device_dir;
 
        for (i = 0; i < 5; i++)
                t->vars[6 + i].extra2 = &port->probe_info[i];
 
        t->port_dir[0].procname = port->name;
        t->port_dir[0].ctl_name = 0;
 
        t->port_dir[0].child = t->vars;
        t->parport_dir[0].child = t->port_dir;
        t->dev_dir[0].child = t->parport_dir;
 
        t->sysctl_header = register_sysctl_table(t->dev_dir);
        if (t->sysctl_header == NULL) {
                kfree(t);
                t = NULL;
        }
        port->sysctl_table = t;
        return 0;
}
 
int parport_proc_unregister(struct parport *port)
{
        if (port->sysctl_table) {
                struct parport_sysctl_table *t = port->sysctl_table;
                port->sysctl_table = NULL;
                unregister_sysctl_table(t->sysctl_header);
                kfree(t);
        }
        return 0;
}
 
int parport_device_proc_register(struct pardevice *device)
{
        struct parport_device_sysctl_table *t;
        struct parport * port = device->port;
 
        t = kmalloc(sizeof(*t), GFP_KERNEL);
        if (t == NULL)
                return -ENOMEM;
        memcpy(t, &parport_device_sysctl_template, sizeof(*t));
 
        t->dev_dir[0].child = t->parport_dir;
        t->parport_dir[0].child = t->port_dir;
        t->port_dir[0].procname = port->name;
        t->port_dir[0].ctl_name = 0;
        t->port_dir[0].child = t->devices_root_dir;
        t->devices_root_dir[0].child = t->device_dir;
 
        t->device_dir[0].ctl_name = 0;
        t->device_dir[0].procname = device->name;
        t->device_dir[0].child = t->vars;
        t->vars[0].data = &device->timeslice;
 
        t->sysctl_header = register_sysctl_table(t->dev_dir);
        if (t->sysctl_header == NULL) {
                kfree(t);
                t = NULL;
        }
        device->sysctl_table = t;
        return 0;
}
 
int parport_device_proc_unregister(struct pardevice *device)
{
        if (device->sysctl_table) {
                struct parport_device_sysctl_table *t = device->sysctl_table;
                device->sysctl_table = NULL;
                unregister_sysctl_table(t->sysctl_header);
                kfree(t);
        }
        return 0;
}
 
static int __init parport_default_proc_register(void)
{
        parport_default_sysctl_table.sysctl_header =
                register_sysctl_table(parport_default_sysctl_table.dev_dir);
        return 0;
}
 
static void __exit parport_default_proc_unregister(void)
{
        if (parport_default_sysctl_table.sysctl_header) {
                unregister_sysctl_table(parport_default_sysctl_table.
                                        sysctl_header);
                parport_default_sysctl_table.sysctl_header = NULL;
        }
}
 
#else /* no sysctl or no procfs*/
 
int parport_proc_register(struct parport *pp)
{
        return 0;
}
 
int parport_proc_unregister(struct parport *pp)
{
        return 0;
}
 
int parport_device_proc_register(struct pardevice *device)
{
        return 0;
}
 
int parport_device_proc_unregister(struct pardevice *device)
{
        return 0;
}
 
static int __init parport_default_proc_register (void)
{
        return 0;
}
 
static void __exit parport_default_proc_unregister (void)
{
}
#endif
 
module_init(parport_default_proc_register)
module_exit(parport_default_proc_unregister)

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [parport/] [procfs.c] - Blame information for rev 65

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* Sysctl interface for parport devices.`
2			`*`
3			`* Authors: David Campbell`
4			`* Tim Waugh <tim@cyberelk.demon.co.uk>`
5			`* Philip Blundell <philb@gnu.org>`
6			`* Andrea Arcangeli`
7			`* Riccardo Facchetti <fizban@tin.it>`
8			`*`
9			`* based on work by Grant Guenther <grant@torque.net>`
10			`* and Philip Blundell`
11			`*`
12			`* Cleaned up include files - Russell King <linux@arm.uk.linux.org>`
13			`*/`
14
15			`#include <linux/string.h>`
16			`#include <linux/init.h>`
17			`#include <linux/module.h>`
18			`#include <linux/errno.h>`
19			`#include <linux/kernel.h>`
20			`#include <linux/slab.h>`
21			`#include <linux/parport.h>`
22			`#include <linux/ctype.h>`
23			`#include <linux/sysctl.h>`
24
25			`#include <asm/uaccess.h>`
26
27			`#if defined(CONFIG_SYSCTL) && defined(CONFIG_PROC_FS)`
28
29			`#define PARPORT_MIN_TIMESLICE_VALUE 1ul`
30			`#define PARPORT_MAX_TIMESLICE_VALUE ((unsigned long) HZ)`
31			`#define PARPORT_MIN_SPINTIME_VALUE 1`
32			`#define PARPORT_MAX_SPINTIME_VALUE 1000`
33
34			`static int do_active_device(ctl_table table, int write, struct file filp,`
35			`void __user result, size_t lenp, loff_t *ppos)`
36			`{`
37			`struct parport port = (struct parport )table->extra1;`
38			`char buffer[256];`
39			`struct pardevice *dev;`
40			`int len = 0;`
41
42			`if (write) /* can't happen anyway */`
43			`return -EACCES;`
44
45			`if (*ppos) {`
46			`*lenp = 0;`
47			`return 0;`
48			`}`
49
50			`for (dev = port->devices; dev ; dev = dev->next) {`
51			`if(dev == port->cad) {`
52			`len += sprintf(buffer, "%s\n", dev->name);`
53			`}`
54			`}`
55
56			`if(!len) {`
57			`len += sprintf(buffer, "%s\n", "none");`
58			`}`
59
60			`if (len > *lenp)`
61			`len = *lenp;`
62			`else`
63			`*lenp = len;`
64
65			`*ppos += len;`
66
67			`return copy_to_user(result, buffer, len) ? -EFAULT : 0;`
68			`}`
69
70			`#ifdef CONFIG_PARPORT_1284`
71			`static int do_autoprobe(ctl_table table, int write, struct file filp,`
72			`void __user result, size_t lenp, loff_t *ppos)`
73			`{`
74			`struct parport_device_info *info = table->extra2;`
75			`const char *str;`
76			`char buffer[256];`
77			`int len = 0;`
78
79			`if (write) /* permissions stop this */`
80			`return -EACCES;`
81
82			`if (*ppos) {`
83			`*lenp = 0;`
84			`return 0;`
85			`}`
86
87			`if ((str = info->class_name) != NULL)`
88			`len += sprintf (buffer + len, "CLASS:%s;\n", str);`
89
90			`if ((str = info->model) != NULL)`
91			`len += sprintf (buffer + len, "MODEL:%s;\n", str);`
92
93			`if ((str = info->mfr) != NULL)`
94			`len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);`
95
96			`if ((str = info->description) != NULL)`
97			`len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);`
98
99			`if ((str = info->cmdset) != NULL)`
100			`len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);`
101
102			`if (len > *lenp)`
103			`len = *lenp;`
104			`else`
105			`*lenp = len;`
106
107			`*ppos += len;`
108
109			`return copy_to_user (result, buffer, len) ? -EFAULT : 0;`
110			`}`
111			`#endif /* IEEE1284.3 support. */`
112
113			`static int do_hardware_base_addr (ctl_table *table, int write,`
114			`struct file filp, void __user result,`
115			`size_t lenp, loff_t ppos)`
116			`{`
117			`struct parport port = (struct parport )table->extra1;`
118			`char buffer[20];`
119			`int len = 0;`
120
121			`if (*ppos) {`
122			`*lenp = 0;`
123			`return 0;`
124			`}`
125
126			`if (write) /* permissions prevent this anyway */`
127			`return -EACCES;`
128
129			`len += sprintf (buffer, "%lu\t%lu\n", port->base, port->base_hi);`
130
131			`if (len > *lenp)`
132			`len = *lenp;`
133			`else`
134			`*lenp = len;`
135
136			`*ppos += len;`
137
138			`return copy_to_user(result, buffer, len) ? -EFAULT : 0;`
139			`}`
140
141			`static int do_hardware_irq (ctl_table *table, int write,`
142			`struct file filp, void __user result,`
143			`size_t lenp, loff_t ppos)`
144			`{`
145			`struct parport port = (struct parport )table->extra1;`
146			`char buffer[20];`
147			`int len = 0;`
148
149			`if (*ppos) {`
150			`*lenp = 0;`
151			`return 0;`
152			`}`
153
154			`if (write) /* permissions prevent this anyway */`
155			`return -EACCES;`
156
157			`len += sprintf (buffer, "%d\n", port->irq);`
158
159			`if (len > *lenp)`
160			`len = *lenp;`
161			`else`
162			`*lenp = len;`
163
164			`*ppos += len;`
165
166			`return copy_to_user(result, buffer, len) ? -EFAULT : 0;`
167			`}`
168
169			`static int do_hardware_dma (ctl_table *table, int write,`
170			`struct file filp, void __user result,`
171			`size_t lenp, loff_t ppos)`
172			`{`
173			`struct parport port = (struct parport )table->extra1;`
174			`char buffer[20];`
175			`int len = 0;`
176
177			`if (*ppos) {`
178			`*lenp = 0;`
179			`return 0;`
180			`}`
181
182			`if (write) /* permissions prevent this anyway */`
183			`return -EACCES;`
184
185			`len += sprintf (buffer, "%d\n", port->dma);`
186
187			`if (len > *lenp)`
188			`len = *lenp;`
189			`else`
190			`*lenp = len;`
191
192			`*ppos += len;`
193
194			`return copy_to_user(result, buffer, len) ? -EFAULT : 0;`
195			`}`
196
197			`static int do_hardware_modes (ctl_table *table, int write,`
198			`struct file filp, void __user result,`
199			`size_t lenp, loff_t ppos)`
200			`{`
201			`struct parport port = (struct parport )table->extra1;`
202			`char buffer[40];`
203			`int len = 0;`
204
205			`if (*ppos) {`
206			`*lenp = 0;`
207			`return 0;`
208			`}`
209
210			`if (write) /* permissions prevent this anyway */`
211			`return -EACCES;`
212
213			`{`
214			`#define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}}`
215			`int f = 0;`
216			`printmode(PCSPP);`
217			`printmode(TRISTATE);`
218			`printmode(COMPAT);`
219			`printmode(EPP);`
220			`printmode(ECP);`
221			`printmode(DMA);`
222			`#undef printmode`
223			`}`
224			`buffer[len++] = '\n';`
225
226			`if (len > *lenp)`
227			`len = *lenp;`
228			`else`
229			`*lenp = len;`
230
231			`*ppos += len;`
232
233			`return copy_to_user(result, buffer, len) ? -EFAULT : 0;`
234			`}`
235
236			`#define PARPORT_PORT_DIR(CHILD) { .ctl_name = 0, .procname = NULL, .mode = 0555, .child = CHILD }`
237			`#define PARPORT_PARPORT_DIR(CHILD) { .ctl_name = DEV_PARPORT, .procname = "parport", \`
238			`.mode = 0555, .child = CHILD }`
239			`#define PARPORT_DEV_DIR(CHILD) { .ctl_name = CTL_DEV, .procname = "dev", .mode = 0555, .child = CHILD }`
240			`#define PARPORT_DEVICES_ROOT_DIR { .procname = "devices", \`
241			`.mode = 0555, .child = NULL }`
242
243			`static const unsigned long parport_min_timeslice_value =`
244			`PARPORT_MIN_TIMESLICE_VALUE;`
245
246			`static const unsigned long parport_max_timeslice_value =`
247			`PARPORT_MAX_TIMESLICE_VALUE;`
248
249			`static const int parport_min_spintime_value =`
250			`PARPORT_MIN_SPINTIME_VALUE;`
251
252			`static const int parport_max_spintime_value =`
253			`PARPORT_MAX_SPINTIME_VALUE;`
254
255
256			`struct parport_sysctl_table {`
257			`struct ctl_table_header *sysctl_header;`
258			`ctl_table vars[12];`
259			`ctl_table device_dir[2];`
260			`ctl_table port_dir[2];`
261			`ctl_table parport_dir[2];`
262			`ctl_table dev_dir[2];`
263			`};`
264
265			`static const struct parport_sysctl_table parport_sysctl_template = {`
266			`.sysctl_header = NULL,`
267			`{`
268			`{`
269			`.procname = "spintime",`
270			`.data = NULL,`
271			`.maxlen = sizeof(int),`
272			`.mode = 0644,`
273			`.proc_handler = &proc_dointvec_minmax,`
274			`.extra1 = (void*) &parport_min_spintime_value,`
275			`.extra2 = (void*) &parport_max_spintime_value`
276			`},`
277			`{`
278			`.procname = "base-addr",`
279			`.data = NULL,`
280			`.maxlen = 0,`
281			`.mode = 0444,`
282			`.proc_handler = &do_hardware_base_addr`
283			`},`
284			`{`
285			`.procname = "irq",`
286			`.data = NULL,`
287			`.maxlen = 0,`
288			`.mode = 0444,`
289			`.proc_handler = &do_hardware_irq`
290			`},`
291			`{`
292			`.procname = "dma",`
293			`.data = NULL,`
294			`.maxlen = 0,`
295			`.mode = 0444,`
296			`.proc_handler = &do_hardware_dma`
297			`},`
298			`{`
299			`.procname = "modes",`
300			`.data = NULL,`
301			`.maxlen = 0,`
302			`.mode = 0444,`
303			`.proc_handler = &do_hardware_modes`
304			`},`
305			`PARPORT_DEVICES_ROOT_DIR,`
306			`#ifdef CONFIG_PARPORT_1284`
307			`{`
308			`.procname = "autoprobe",`
309			`.data = NULL,`
310			`.maxlen = 0,`
311			`.mode = 0444,`
312			`.proc_handler = &do_autoprobe`
313			`},`
314			`{`
315			`.procname = "autoprobe0",`
316			`.data = NULL,`
317			`.maxlen = 0,`
318			`.mode = 0444,`
319			`.proc_handler = &do_autoprobe`
320			`},`
321			`{`
322			`.procname = "autoprobe1",`
323			`.data = NULL,`
324			`.maxlen = 0,`
325			`.mode = 0444,`
326			`.proc_handler = &do_autoprobe`
327			`},`
328			`{`
329			`.procname = "autoprobe2",`
330			`.data = NULL,`
331			`.maxlen = 0,`
332			`.mode = 0444,`
333			`.proc_handler = &do_autoprobe`
334			`},`
335			`{`
336			`.procname = "autoprobe3",`
337			`.data = NULL,`
338			`.maxlen = 0,`
339			`.mode = 0444,`
340			`.proc_handler = &do_autoprobe`
341			`},`
342			`#endif /* IEEE 1284 support */`
343			`{}`
344			`},`
345			`{`
346			`{`
347			`.procname = "active",`
348			`.data = NULL,`
349			`.maxlen = 0,`
350			`.mode = 0444,`
351			`.proc_handler = &do_active_device`
352			`},`
353			`{}`
354			`},`
355			`{`
356			`PARPORT_PORT_DIR(NULL),`
357			`{}`
358			`},`
359			`{`
360			`PARPORT_PARPORT_DIR(NULL),`
361			`{}`
362			`},`
363			`{`
364			`PARPORT_DEV_DIR(NULL),`
365			`{}`
366			`}`
367			`};`
368
369			`struct parport_device_sysctl_table`
370			`{`
371			`struct ctl_table_header *sysctl_header;`
372			`ctl_table vars[2];`
373			`ctl_table device_dir[2];`
374			`ctl_table devices_root_dir[2];`
375			`ctl_table port_dir[2];`
376			`ctl_table parport_dir[2];`
377			`ctl_table dev_dir[2];`
378			`};`
379
380			`static const struct parport_device_sysctl_table`
381			`parport_device_sysctl_template = {`
382			`.sysctl_header = NULL,`
383			`{`
384			`{`
385			`.procname = "timeslice",`
386			`.data = NULL,`
387			`.maxlen = sizeof(unsigned long),`
388			`.mode = 0644,`
389			`.proc_handler = &proc_doulongvec_ms_jiffies_minmax,`
390			`.extra1 = (void*) &parport_min_timeslice_value,`
391			`.extra2 = (void*) &parport_max_timeslice_value`
392			`},`
393			`},`
394			`{`
395			`{`
396			`.ctl_name = 0,`
397			`.procname = NULL,`
398			`.data = NULL,`
399			`.maxlen = 0,`
400			`.mode = 0555,`
401			`.child = NULL`
402			`},`
403			`{}`
404			`},`
405			`{`
406			`PARPORT_DEVICES_ROOT_DIR,`
407			`{}`
408			`},`
409			`{`
410			`PARPORT_PORT_DIR(NULL),`
411			`{}`
412			`},`
413			`{`
414			`PARPORT_PARPORT_DIR(NULL),`
415			`{}`
416			`},`
417			`{`
418			`PARPORT_DEV_DIR(NULL),`
419			`{}`
420			`}`
421			`};`
422
423			`struct parport_default_sysctl_table`
424			`{`
425			`struct ctl_table_header *sysctl_header;`
426			`ctl_table vars[3];`
427			`ctl_table default_dir[2];`
428			`ctl_table parport_dir[2];`
429			`ctl_table dev_dir[2];`
430			`};`
431
432			`extern unsigned long parport_default_timeslice;`
433			`extern int parport_default_spintime;`
434
435			`static struct parport_default_sysctl_table`
436			`parport_default_sysctl_table = {`
437			`.sysctl_header = NULL,`
438			`{`
439			`{`
440			`.procname = "timeslice",`
441			`.data = &parport_default_timeslice,`
442			`.maxlen = sizeof(parport_default_timeslice),`
443			`.mode = 0644,`
444			`.proc_handler = &proc_doulongvec_ms_jiffies_minmax,`
445			`.extra1 = (void*) &parport_min_timeslice_value,`
446			`.extra2 = (void*) &parport_max_timeslice_value`
447			`},`
448			`{`
449			`.procname = "spintime",`
450			`.data = &parport_default_spintime,`
451			`.maxlen = sizeof(parport_default_spintime),`
452			`.mode = 0644,`
453			`.proc_handler = &proc_dointvec_minmax,`
454			`.extra1 = (void*) &parport_min_spintime_value,`
455			`.extra2 = (void*) &parport_max_spintime_value`
456			`},`
457			`{}`
458			`},`
459			`{`
460			`{`
461			`.ctl_name = DEV_PARPORT_DEFAULT,`
462			`.procname = "default",`
463			`.mode = 0555,`
464			`.child = parport_default_sysctl_table.vars`
465			`},`
466			`{}`
467			`},`
468			`{`
469			`PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),`
470			`{}`
471			`},`
472			`{`
473			`PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir),`
474			`{}`
475			`}`
476			`};`
477
478
479			`int parport_proc_register(struct parport *port)`
480			`{`
481			`struct parport_sysctl_table *t;`
482			`int i;`
483
484			`t = kmalloc(sizeof(*t), GFP_KERNEL);`
485			`if (t == NULL)`
486			`return -ENOMEM;`
487			`memcpy(t, &parport_sysctl_template, sizeof(*t));`
488
489			`t->device_dir[0].extra1 = port;`
490
491			`for (i = 0; i < 5; i++)`
492			`t->vars[i].extra1 = port;`
493
494			`t->vars[0].data = &port->spintime;`
495			`t->vars[5].child = t->device_dir;`
496
497			`for (i = 0; i < 5; i++)`
498			`t->vars[6 + i].extra2 = &port->probe_info[i];`
499
500			`t->port_dir[0].procname = port->name;`
501			`t->port_dir[0].ctl_name = 0;`
502
503			`t->port_dir[0].child = t->vars;`
504			`t->parport_dir[0].child = t->port_dir;`
505			`t->dev_dir[0].child = t->parport_dir;`
506
507			`t->sysctl_header = register_sysctl_table(t->dev_dir);`
508			`if (t->sysctl_header == NULL) {`
509			`kfree(t);`
510			`t = NULL;`
511			`}`
512			`port->sysctl_table = t;`
513			`return 0;`
514			`}`
515
516			`int parport_proc_unregister(struct parport *port)`
517			`{`
518			`if (port->sysctl_table) {`
519			`struct parport_sysctl_table *t = port->sysctl_table;`
520			`port->sysctl_table = NULL;`
521			`unregister_sysctl_table(t->sysctl_header);`
522			`kfree(t);`
523			`}`
524			`return 0;`
525			`}`
526
527			`int parport_device_proc_register(struct pardevice *device)`
528			`{`
529			`struct parport_device_sysctl_table *t;`
530			`struct parport * port = device->port;`
531
532			`t = kmalloc(sizeof(*t), GFP_KERNEL);`
533			`if (t == NULL)`
534			`return -ENOMEM;`
535			`memcpy(t, &parport_device_sysctl_template, sizeof(*t));`
536
537			`t->dev_dir[0].child = t->parport_dir;`
538			`t->parport_dir[0].child = t->port_dir;`
539			`t->port_dir[0].procname = port->name;`
540			`t->port_dir[0].ctl_name = 0;`
541			`t->port_dir[0].child = t->devices_root_dir;`
542			`t->devices_root_dir[0].child = t->device_dir;`
543
544			`t->device_dir[0].ctl_name = 0;`
545			`t->device_dir[0].procname = device->name;`
546			`t->device_dir[0].child = t->vars;`
547			`t->vars[0].data = &device->timeslice;`
548
549			`t->sysctl_header = register_sysctl_table(t->dev_dir);`
550			`if (t->sysctl_header == NULL) {`
551			`kfree(t);`
552			`t = NULL;`
553			`}`
554			`device->sysctl_table = t;`
555			`return 0;`
556			`}`
557
558			`int parport_device_proc_unregister(struct pardevice *device)`
559			`{`
560			`if (device->sysctl_table) {`
561			`struct parport_device_sysctl_table *t = device->sysctl_table;`
562			`device->sysctl_table = NULL;`
563			`unregister_sysctl_table(t->sysctl_header);`
564			`kfree(t);`
565			`}`
566			`return 0;`
567			`}`
568
569			`static int __init parport_default_proc_register(void)`
570			`{`
571			`parport_default_sysctl_table.sysctl_header =`
572			`register_sysctl_table(parport_default_sysctl_table.dev_dir);`
573			`return 0;`
574			`}`
575
576			`static void __exit parport_default_proc_unregister(void)`
577			`{`
578			`if (parport_default_sysctl_table.sysctl_header) {`
579			`unregister_sysctl_table(parport_default_sysctl_table.`
580			`sysctl_header);`
581			`parport_default_sysctl_table.sysctl_header = NULL;`
582			`}`
583			`}`
584
585			`#else /* no sysctl or no procfs*/`
586
587			`int parport_proc_register(struct parport *pp)`
588			`{`
589			`return 0;`
590			`}`
591
592			`int parport_proc_unregister(struct parport *pp)`
593			`{`
594			`return 0;`
595			`}`
596
597			`int parport_device_proc_register(struct pardevice *device)`
598			`{`
599			`return 0;`
600			`}`
601
602			`int parport_device_proc_unregister(struct pardevice *device)`
603			`{`
604			`return 0;`
605			`}`
606
607			`static int __init parport_default_proc_register (void)`
608			`{`
609			`return 0;`
610			`}`
611
612			`static void __exit parport_default_proc_unregister (void)`
613			`{`
614			`}`
615			`#endif`
616
617			`module_init(parport_default_proc_register)`
618			`module_exit(parport_default_proc_unregister)`