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) { 0, NULL, NULL, 0, 0555, child } 237 #define PARPORT_PARPORT_DIR(child) { DEV_PARPORT, "parport", \ 238 NULL, 0, 0555, child } 239 #define PARPORT_DEV_DIR(child) { CTL_DEV, "dev", NULL, 0, 0555, child } 240 #define PARPORT_DEVICES_ROOT_DIR { DEV_PARPORT_DEVICES, "devices", \ 241 NULL, 0, 0555, 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 NULL, 267 { 268 { DEV_PARPORT_SPINTIME, "spintime", 269 NULL, sizeof(int), 0644, NULL, 270 &proc_dointvec_minmax, NULL, NULL, 271 (void*) &parport_min_spintime_value, 272 (void*) &parport_max_spintime_value }, 273 { DEV_PARPORT_BASE_ADDR, "base-addr", 274 NULL, 0, 0444, NULL, 275 &do_hardware_base_addr }, 276 { DEV_PARPORT_IRQ, "irq", 277 NULL, 0, 0444, NULL, 278 &do_hardware_irq }, 279 { DEV_PARPORT_DMA, "dma", 280 NULL, 0, 0444, NULL, 281 &do_hardware_dma }, 282 { DEV_PARPORT_MODES, "modes", 283 NULL, 0, 0444, NULL, 284 &do_hardware_modes }, 285 PARPORT_DEVICES_ROOT_DIR, 286 #ifdef CONFIG_PARPORT_1284 287 { DEV_PARPORT_AUTOPROBE, "autoprobe", 288 NULL, 0, 0444, NULL, 289 &do_autoprobe }, 290 { DEV_PARPORT_AUTOPROBE + 1, "autoprobe0", 291 NULL, 0, 0444, NULL, 292 &do_autoprobe }, 293 { DEV_PARPORT_AUTOPROBE + 2, "autoprobe1", 294 NULL, 0, 0444, NULL, 295 &do_autoprobe }, 296 { DEV_PARPORT_AUTOPROBE + 3, "autoprobe2", 297 NULL, 0, 0444, NULL, 298 &do_autoprobe }, 299 { DEV_PARPORT_AUTOPROBE + 4, "autoprobe3", 300 NULL, 0, 0444, NULL, 301 &do_autoprobe }, 302 #endif /* IEEE 1284 support */ 303 {0} 304 }, 305 { {DEV_PARPORT_DEVICES_ACTIVE, "active", NULL, 0, 0444, NULL, 306 &do_active_device }, {0}}, 307 { PARPORT_PORT_DIR(NULL), {0}}, 308 { PARPORT_PARPORT_DIR(NULL), {0}}, 309 { PARPORT_DEV_DIR(NULL), {0}} 310 }; 311 312 struct parport_device_sysctl_table 313 { 314 struct ctl_table_header *sysctl_header; 315 ctl_table vars[2]; 316 ctl_table device_dir[2]; 317 ctl_table devices_root_dir[2]; 318 ctl_table port_dir[2]; 319 ctl_table parport_dir[2]; 320 ctl_table dev_dir[2]; 321 }; 322 323 static const struct parport_device_sysctl_table 324 parport_device_sysctl_template = { 325 NULL, 326 { 327 { DEV_PARPORT_DEVICE_TIMESLICE, "timeslice", 328 NULL, sizeof(int), 0644, NULL, 329 &proc_doulongvec_ms_jiffies_minmax, NULL, NULL, 330 (void*) &parport_min_timeslice_value, 331 (void*) &parport_max_timeslice_value }, 332 }, 333 { {0, NULL, NULL, 0, 0555, NULL}, {0}}, 334 { PARPORT_DEVICES_ROOT_DIR, {0}}, 335 { PARPORT_PORT_DIR(NULL), {0}}, 336 { PARPORT_PARPORT_DIR(NULL), {0}}, 337 { PARPORT_DEV_DIR(NULL), {0}} 338 }; 339 340 struct parport_default_sysctl_table 341 { 342 struct ctl_table_header *sysctl_header; 343 ctl_table vars[3]; 344 ctl_table default_dir[2]; 345 ctl_table parport_dir[2]; 346 ctl_table dev_dir[2]; 347 }; 348 349 extern unsigned long parport_default_timeslice; 350 extern int parport_default_spintime; 351 352 static struct parport_default_sysctl_table 353 parport_default_sysctl_table = { 354 NULL, 355 { 356 { DEV_PARPORT_DEFAULT_TIMESLICE, "timeslice", 357 &parport_default_timeslice, 358 sizeof(parport_default_timeslice), 0644, NULL, 359 &proc_doulongvec_ms_jiffies_minmax, NULL, NULL, 360 (void*) &parport_min_timeslice_value, 361 (void*) &parport_max_timeslice_value }, 362 { DEV_PARPORT_DEFAULT_SPINTIME, "spintime", 363 &parport_default_spintime, 364 sizeof(parport_default_spintime), 0644, NULL, 365 &proc_dointvec_minmax, NULL, NULL, 366 (void*) &parport_min_spintime_value, 367 (void*) &parport_max_spintime_value }, 368 {0} 369 }, 370 { { DEV_PARPORT_DEFAULT, "default", NULL, 0, 0555, 371 parport_default_sysctl_table.vars },{0}}, 372 { 373 PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir), 374 {0}}, 375 { PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir), {0}} 376 }; 377 378 379 int parport_proc_register(struct parport *port) 380 { 381 struct parport_sysctl_table *t; 382 int i; 383 384 t = kmalloc(sizeof(*t), GFP_KERNEL); 385 if (t == NULL) 386 return -ENOMEM; 387 memcpy(t, &parport_sysctl_template, sizeof(*t)); 388 389 t->device_dir[0].extra1 = port; 390 391 for (i = 0; i < 8; i++) 392 t->vars[i].extra1 = port; 393 394 t->vars[0].data = &port->spintime; 395 t->vars[5].child = t->device_dir; 396 397 for (i = 0; i < 5; i++) 398 t->vars[6 + i].extra2 = &port->probe_info[i]; 399 400 t->port_dir[0].procname = port->name; 401 t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */ 402 403 t->port_dir[0].child = t->vars; 404 t->parport_dir[0].child = t->port_dir; 405 t->dev_dir[0].child = t->parport_dir; 406 407 t->sysctl_header = register_sysctl_table(t->dev_dir, 0); 408 if (t->sysctl_header == NULL) { 409 kfree(t); 410 t = NULL; 411 } 412 port->sysctl_table = t; 413 return 0; 414 } 415 416 int parport_proc_unregister(struct parport *port) 417 { 418 if (port->sysctl_table) { 419 struct parport_sysctl_table *t = port->sysctl_table; 420 port->sysctl_table = NULL; 421 unregister_sysctl_table(t->sysctl_header); 422 kfree(t); 423 } 424 return 0; 425 } 426 427 int parport_device_proc_register(struct pardevice *device) 428 { 429 struct parport_device_sysctl_table *t; 430 struct parport * port = device->port; 431 432 t = kmalloc(sizeof(*t), GFP_KERNEL); 433 if (t == NULL) 434 return -ENOMEM; 435 memcpy(t, &parport_device_sysctl_template, sizeof(*t)); 436 437 t->dev_dir[0].child = t->parport_dir; 438 t->parport_dir[0].child = t->port_dir; 439 t->port_dir[0].procname = port->name; 440 t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */ 441 t->port_dir[0].child = t->devices_root_dir; 442 t->devices_root_dir[0].child = t->device_dir; 443 444 #ifdef CONFIG_PARPORT_1284 445 446 t->device_dir[0].ctl_name = 447 parport_device_num(port->number, port->muxport, 448 device->daisy) 449 + 1; /* nb 0 isn't legal here */ 450 451 #else /* No IEEE 1284 support */ 452 453 /* parport_device_num isn't available. */ 454 t->device_dir[0].ctl_name = 1; 455 456 #endif /* IEEE 1284 support or not */ 457 458 t->device_dir[0].procname = device->name; 459 t->device_dir[0].extra1 = device; 460 t->device_dir[0].child = t->vars; 461 t->vars[0].data = &device->timeslice; 462 463 t->sysctl_header = register_sysctl_table(t->dev_dir, 0); 464 if (t->sysctl_header == NULL) { 465 kfree(t); 466 t = NULL; 467 } 468 device->sysctl_table = t; 469 return 0; 470 } 471 472 int parport_device_proc_unregister(struct pardevice *device) 473 { 474 if (device->sysctl_table) { 475 struct parport_device_sysctl_table *t = device->sysctl_table; 476 device->sysctl_table = NULL; 477 unregister_sysctl_table(t->sysctl_header); 478 kfree(t); 479 } 480 return 0; 481 } 482 483 static int __init parport_default_proc_register(void) 484 { 485 parport_default_sysctl_table.sysctl_header = 486 register_sysctl_table(parport_default_sysctl_table.dev_dir, 0); 487 return 0; 488 } 489 490 static void __exit parport_default_proc_unregister(void) 491 { 492 if (parport_default_sysctl_table.sysctl_header) { 493 unregister_sysctl_table(parport_default_sysctl_table. 494 sysctl_header); 495 parport_default_sysctl_table.sysctl_header = NULL; 496 } 497 } 498 499 #else /* no sysctl or no procfs*/ 500 501 int parport_proc_register(struct parport *pp) 502 { 503 return 0; 504 } 505 506 int parport_proc_unregister(struct parport *pp) 507 { 508 return 0; 509 } 510 511 int parport_device_proc_register(struct pardevice *device) 512 { 513 return 0; 514 } 515 516 int parport_device_proc_unregister(struct pardevice *device) 517 { 518 return 0; 519 } 520 521 static int __init parport_default_proc_register (void) 522 { 523 return 0; 524 } 525 526 static void __exit parport_default_proc_unregister (void) 527 { 528 } 529 #endif 530 531 module_init(parport_default_proc_register) 532 module_exit(parport_default_proc_unregister) 533