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