1 /* 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) 619