drivers/misc/parport_procfs.c

   1 /* Sysctl interface for parport devices.
   2  *
   3  * Authors: David Campbell <campbell@torque.net>
   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/config.h>
  17 #include <linux/errno.h>
  18 #include <linux/kernel.h>
  19 #include <linux/malloc.h>
  20 #include <linux/parport.h>
  21 #include <linux/ctype.h>
  22 #include <linux/sysctl.h>
  23
  24 #include <asm/uaccess.h>
  25
  26 #ifdef CONFIG_SYSCTL
  27
  28
  29 static int do_active_device(ctl_table *table, int write, struct file *filp,
  30                       void *result, size_t *lenp)
  31 {
  32         struct parport *port = (struct parport *)table->extra1;
  33         char buffer[256];
  34         struct pardevice *dev;
  35         int len = 0;
  36
  37         if (write)              /* can't happen anyway */
  38                 return -EACCES;
  39
  40         if (filp->f_pos) {
  41                 *lenp = 0;
  42                 return 0;
  43         }
  44
  45         for (dev = port->devices; dev ; dev = dev->next) {
  46                 if(dev == port->cad) {
  47                         len += sprintf(buffer, "%s\n", dev->name);
  48                 }
  49         }
  50
  51         if(!len) {
  52                 len += sprintf(buffer, "%s\n", "none");
  53         }
  54
  55         if (len > *lenp)
  56                 len = *lenp;
  57         else
  58                 *lenp = len;
  59
  60         filp->f_pos += len;
  61
  62         return copy_to_user(result, buffer, len) ? -EFAULT : 0;
  63 }
  64
  65 #ifdef CONFIG_PARPORT_1284
  66 static int do_autoprobe(ctl_table *table, int write, struct file *filp,
  67                         void *result, size_t *lenp)
  68 {
  69         struct parport_device_info *info = table->extra2;
  70         const char *str;
  71         char buffer[256];
  72         int len = 0;
  73
  74         if (write) /* permissions stop this */
  75                 return -EACCES;
  76
  77         if (filp->f_pos) {
  78                 *lenp = 0;
  79                 return 0;
  80         }
  81
  82         if ((str = info->class_name) != NULL)
  83                 len += sprintf (buffer + len, "CLASS:%s;\n", str);
  84
  85         if ((str = info->model) != NULL)
  86                 len += sprintf (buffer + len, "MODEL:%s;\n", str);
  87
  88         if ((str = info->mfr) != NULL)
  89                 len += sprintf (buffer + len, "MANUFACTURER:%s;\n", str);
  90
  91         if ((str = info->description) != NULL)
  92                 len += sprintf (buffer + len, "DESCRIPTION:%s;\n", str);
  93
  94         if ((str = info->cmdset) != NULL)
  95                 len += sprintf (buffer + len, "COMMAND SET:%s;\n", str);
  96
  97         if (len > *lenp)
  98                 len = *lenp;
  99         else
 100                 *lenp = len;
 101
 102         filp->f_pos += len;
 103
 104         return copy_to_user (result, buffer, len) ? -EFAULT : 0;
 105 }
 106 #endif /* IEEE1284.3 support. */
 107
 108 static int do_hardware(ctl_table *table, int write, struct file *filp,
 109                        void *result, size_t *lenp)
 110 {
 111         struct parport *port = (struct parport *)table->extra1;
 112         char buffer[256];
 113         int len = 0;
 114
 115         if (filp->f_pos) {
 116                 *lenp = 0;
 117                 return 0;
 118         }
 119
 120         if (write)              /* can't happen anyway */
 121                 return -EACCES;
 122
 123         len += sprintf(buffer+len, "base:\t0x%lx", port->base);
 124         if (port->base_hi)
 125                 len += sprintf(buffer+len, " (0x%lx)", port->base_hi);
 126         buffer[len++] = '\n';
 127
 128         if (port->irq == PARPORT_IRQ_NONE) {
 129                 len += sprintf(buffer+len, "irq:\tnone\n");
 130         } else {
 131 #ifdef __sparc__
 132                 len += sprintf(buffer+len, "irq:\t%s\n",
 133                                __irq_itoa(port->irq));
 134 #else
 135                 len += sprintf(buffer+len, "irq:\t%d\n", port->irq);
 136 #endif
 137         }
 138
 139         if (port->dma == PARPORT_DMA_NONE)
 140                 len += sprintf(buffer+len, "dma:\tnone\n");
 141         else
 142                 len += sprintf(buffer+len, "dma:\t%d\n", port->dma);
 143
 144         len += sprintf(buffer+len, "modes:\t");
 145         {
 146 #define printmode(x) {if(port->modes&PARPORT_MODE_##x){len+=sprintf(buffer+len,"%s%s",f?",":"",#x);f++;}}
 147                 int f = 0;
 148                 printmode(PCSPP);
 149                 printmode(TRISTATE);
 150                 printmode(COMPAT);
 151                 printmode(EPP);
 152                 printmode(ECP);
 153                 printmode(DMA);
 154 #undef printmode
 155         }
 156         buffer[len++] = '\n';
 157
 158         if (len > *lenp)
 159                 len = *lenp;
 160         else
 161                 *lenp = len;
 162
 163         filp->f_pos += len;
 164
 165         return copy_to_user(result, buffer, len) ? -EFAULT : 0;
 166 }
 167
 168 #define PARPORT_PORT_DIR(child) { 0, NULL, NULL, 0, 0555, child }
 169 #define PARPORT_PARPORT_DIR(child) { DEV_PARPORT, "parport", \
 170                                      NULL, 0, 0555, child }
 171 #define PARPORT_DEV_DIR(child) { CTL_DEV, "dev", NULL, 0, 0555, child }
 172 #define PARPORT_DEVICES_ROOT_DIR  { DEV_PARPORT_DEVICES, "devices", \
 173                                     NULL, 0, 0555, NULL }
 174
 175
 176 struct parport_sysctl_table {
 177         struct ctl_table_header *sysctl_header;
 178         ctl_table vars[9];
 179         ctl_table device_dir[2];
 180         ctl_table port_dir[2];
 181         ctl_table parport_dir[2];
 182         ctl_table dev_dir[2];
 183 };
 184
 185 static const struct parport_sysctl_table parport_sysctl_template = {
 186         NULL,
 187         {
 188                 { DEV_PARPORT_SPINTIME, "spintime",
 189                   NULL, sizeof(int), 0644, NULL,
 190                   &proc_dointvec },
 191                 { DEV_PARPORT_HARDWARE, "hardware",
 192                   NULL, 0, 0444, NULL,
 193                   &do_hardware },
 194                 PARPORT_DEVICES_ROOT_DIR,
 195 #ifdef CONFIG_PARPORT_1284
 196                 { DEV_PARPORT_AUTOPROBE, "autoprobe",
 197                   NULL, 0, 0444, NULL,
 198                   &do_autoprobe },
 199                 { DEV_PARPORT_AUTOPROBE + 1, "autoprobe0",
 200                  NULL, 0, 0444, NULL,
 201                  &do_autoprobe },
 202                 { DEV_PARPORT_AUTOPROBE + 2, "autoprobe1",
 203                   NULL, 0, 0444, NULL,
 204                   &do_autoprobe },
 205                 { DEV_PARPORT_AUTOPROBE + 3, "autoprobe2",
 206                   NULL, 0, 0444, NULL,
 207                   &do_autoprobe },
 208                 { DEV_PARPORT_AUTOPROBE + 4, "autoprobe3",
 209                   NULL, 0, 0444, NULL,
 210                   &do_autoprobe },
 211 #endif /* IEEE 1284 support */
 212                 {0}
 213         },
 214         { {DEV_PARPORT_DEVICES_ACTIVE, "active", NULL, 0, 444, NULL,
 215           &do_active_device }, {0}},
 216         { PARPORT_PORT_DIR(NULL), {0}},
 217         { PARPORT_PARPORT_DIR(NULL), {0}},
 218         { PARPORT_DEV_DIR(NULL), {0}}
 219 };
 220
 221 struct parport_device_sysctl_table
 222 {
 223         struct ctl_table_header *sysctl_header;
 224         ctl_table vars[2];
 225         ctl_table device_dir[2];
 226         ctl_table devices_root_dir[2];
 227         ctl_table port_dir[2];
 228         ctl_table parport_dir[2];
 229         ctl_table dev_dir[2];
 230 };
 231
 232 static const struct parport_device_sysctl_table
 233 parport_device_sysctl_template = {
 234         NULL,
 235         {
 236                 { DEV_PARPORT_DEVICE_TIMESLICE, "timeslice",
 237                   NULL, sizeof(int), 0644, NULL,
 238                   &proc_dointvec },
 239         },
 240         { {0, NULL, NULL, 0, 0555, NULL}, {0}},
 241         { PARPORT_DEVICES_ROOT_DIR, {0}},
 242         { PARPORT_PORT_DIR(NULL), {0}},
 243         { PARPORT_PARPORT_DIR(NULL), {0}},
 244         { PARPORT_DEV_DIR(NULL), {0}}
 245 };
 246
 247 struct parport_default_sysctl_table
 248 {
 249         struct ctl_table_header *sysctl_header;
 250         ctl_table vars[3];
 251         ctl_table default_dir[2];
 252         ctl_table parport_dir[2];
 253         ctl_table dev_dir[2];
 254 };
 255
 256 extern unsigned long parport_default_timeslice;
 257 extern int parport_default_spintime;
 258
 259 static struct parport_default_sysctl_table
 260 parport_default_sysctl_table = {
 261         NULL,
 262         {
 263                 { DEV_PARPORT_DEFAULT_TIMESLICE, "timeslice",
 264                   &parport_default_timeslice,
 265                   sizeof(parport_default_timeslice), 0644, NULL,
 266                   &proc_dointvec },
 267                 { DEV_PARPORT_DEFAULT_SPINTIME, "spintime",
 268                   &parport_default_spintime,
 269                   sizeof(parport_default_timeslice), 0644, NULL,
 270                   &proc_dointvec },
 271                 {0}
 272         },
 273         { { DEV_PARPORT_DEFAULT, "default", NULL, 0, 0555,
 274             parport_default_sysctl_table.vars },{0}},
 275         {
 276         PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),
 277         {0}},
 278         { PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir), {0}}
 279 };
 280
 281
 282 int parport_proc_register(struct parport *port)
 283 {
 284         struct parport_sysctl_table *t;
 285         int i;
 286
 287         t = kmalloc(sizeof(*t), GFP_KERNEL);
 288         if (t == NULL)
 289                 return -ENOMEM;
 290         memcpy(t, &parport_sysctl_template, sizeof(*t));
 291
 292         t->device_dir[0].extra1 = port;
 293
 294         for (i = 0; i < 8; i++)
 295                 t->vars[i].extra1 = port;
 296
 297         t->vars[0].data = &port->spintime;
 298         t->vars[2].child = t->device_dir;
 299
 300         for (i = 0; i < 5; i++)
 301                 t->vars[3 + i].extra2 = &port->probe_info[i];
 302
 303         t->port_dir[0].procname = port->name;
 304         t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */
 305
 306         t->port_dir[0].child = t->vars;
 307         t->parport_dir[0].child = t->port_dir;
 308         t->dev_dir[0].child = t->parport_dir;
 309
 310         t->sysctl_header = register_sysctl_table(t->dev_dir, 0);
 311         if (t->sysctl_header == NULL) {
 312                 kfree(t);
 313                 t = NULL;
 314         }
 315         port->sysctl_table = t;
 316         return 0;
 317 }
 318
 319 int parport_proc_unregister(struct parport *port)
 320 {
 321         if (port->sysctl_table) {
 322                 struct parport_sysctl_table *t = port->sysctl_table;
 323                 port->sysctl_table = NULL;
 324                 unregister_sysctl_table(t->sysctl_header);
 325                 kfree(t);
 326         }
 327         return 0;
 328 }
 329
 330 int parport_device_proc_register(struct pardevice *device)
 331 {
 332         struct parport_device_sysctl_table *t;
 333         struct parport * port = device->port;
 334
 335         t = kmalloc(sizeof(*t), GFP_KERNEL);
 336         if (t == NULL)
 337                 return -ENOMEM;
 338         memcpy(t, &parport_device_sysctl_template, sizeof(*t));
 339
 340         t->dev_dir[0].child = t->parport_dir;
 341         t->parport_dir[0].child = t->port_dir;
 342         t->port_dir[0].procname = port->name;
 343         t->port_dir[0].ctl_name = port->number + 1; /* nb 0 isn't legal here */
 344         t->port_dir[0].child = t->devices_root_dir;
 345         t->devices_root_dir[0].child = t->device_dir;
 346
 347 #ifdef CONFIG_PARPORT_1284
 348
 349         t->device_dir[0].ctl_name =
 350                 parport_device_num(port->number, port->muxport,
 351                                    device->daisy)
 352                 + 1;  /* nb 0 isn't legal here */
 353
 354 #else /* No IEEE 1284 support */
 355
 356         /* parport_device_num isn't available. */
 357         t->device_dir[0].ctl_name = 1;
 358
 359 #endif /* IEEE 1284 support or not */
 360
 361         t->device_dir[0].procname = device->name;
 362         t->device_dir[0].extra1 = device;
 363         t->device_dir[0].child = t->vars;
 364         t->vars[0].data = &device->timeslice;
 365
 366         t->sysctl_header = register_sysctl_table(t->dev_dir, 0);
 367         if (t->sysctl_header == NULL) {
 368                 kfree(t);
 369                 t = NULL;
 370         }
 371         device->sysctl_table = t;
 372         return 0;
 373 }
 374
 375 int parport_device_proc_unregister(struct pardevice *device)
 376 {
 377         if (device->sysctl_table) {
 378                 struct parport_device_sysctl_table *t = device->sysctl_table;
 379                 device->sysctl_table = NULL;
 380                 unregister_sysctl_table(t->sysctl_header);
 381                 kfree(t);
 382         }
 383         return 0;
 384 }
 385
 386 int parport_default_proc_register(void)
 387 {
 388         parport_default_sysctl_table.sysctl_header =
 389                 register_sysctl_table(parport_default_sysctl_table.dev_dir, 0);
 390         return 0;
 391 }
 392
 393 int parport_default_proc_unregister(void)
 394 {
 395         if (parport_default_sysctl_table.sysctl_header) {
 396                 unregister_sysctl_table(parport_default_sysctl_table.
 397                                         sysctl_header);
 398                 parport_default_sysctl_table.sysctl_header = NULL;
 399         }
 400         return 0;
 401 }
 402
 403 #else /* no sysctl */
 404
 405 int parport_proc_register(struct parport *pp)
 406 {
 407         return 0;
 408 }
 409
 410 int parport_proc_unregister(struct parport *pp)
 411 {
 412         return 0;
 413 }
 414
 415 int parport_device_proc_register(struct pardevice *device)
 416 {
 417         return 0;
 418 }
 419
 420 int parport_device_proc_unregister(struct pardevice *device)
 421 {
 422         return 0;
 423 }
 424
 425 int parport_default_proc_register (void)
 426 {
 427         return 0;
 428 }
 429
 430 int parport_default_proc_unregister (void)
 431 {
 432         return 0;
 433 }
 434 #endif