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