linux/drivers/parport/procfs.c
<<
>>
Prefs
   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
  34static int do_active_device(ctl_table *table, int write,
  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
  71static int do_autoprobe(ctl_table *table, int write,
  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
 113static int do_hardware_base_addr (ctl_table *table, int write,
 114                                  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
 141static int do_hardware_irq (ctl_table *table, int write,
 142                            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
 169static int do_hardware_dma (ctl_table *table, int write,
 170                            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
 197static int do_hardware_modes (ctl_table *table, int write,
 198                              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) { .procname = NULL, .mode = 0555, .child = CHILD }
 237#define PARPORT_PARPORT_DIR(CHILD) { .procname = "parport", \
 238                                     .mode = 0555, .child = CHILD }
 239#define PARPORT_DEV_DIR(CHILD) { .procname = "dev", .mode = 0555, .child = CHILD }
 240#define PARPORT_DEVICES_ROOT_DIR  {  .procname = "devices", \
 241                                    .mode = 0555, .child = NULL }
 242
 243static const unsigned long parport_min_timeslice_value =
 244PARPORT_MIN_TIMESLICE_VALUE;
 245
 246static const unsigned long parport_max_timeslice_value =
 247PARPORT_MAX_TIMESLICE_VALUE;
 248
 249static const  int parport_min_spintime_value =
 250PARPORT_MIN_SPINTIME_VALUE;
 251
 252static const int parport_max_spintime_value =
 253PARPORT_MAX_SPINTIME_VALUE;
 254
 255
 256struct 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
 265static 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
 369struct 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
 380static const struct parport_device_sysctl_table
 381parport_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                        .procname       = NULL,
 397                        .data           = NULL,
 398                        .maxlen         = 0,
 399                        .mode           = 0555,
 400                        .child          = NULL
 401                },
 402                {}
 403        },
 404        {
 405                PARPORT_DEVICES_ROOT_DIR,
 406                {}
 407        },
 408        {
 409                PARPORT_PORT_DIR(NULL),
 410                {}
 411        },
 412        {
 413                PARPORT_PARPORT_DIR(NULL),
 414                {}
 415        },
 416        {
 417                PARPORT_DEV_DIR(NULL),
 418                {}
 419        }
 420};
 421
 422struct parport_default_sysctl_table
 423{
 424        struct ctl_table_header *sysctl_header;
 425        ctl_table vars[3];
 426        ctl_table default_dir[2];
 427        ctl_table parport_dir[2];
 428        ctl_table dev_dir[2];
 429};
 430
 431static struct parport_default_sysctl_table
 432parport_default_sysctl_table = {
 433        .sysctl_header  = NULL,
 434        {
 435                {
 436                        .procname       = "timeslice",
 437                        .data           = &parport_default_timeslice,
 438                        .maxlen         = sizeof(parport_default_timeslice),
 439                        .mode           = 0644,
 440                        .proc_handler   = proc_doulongvec_ms_jiffies_minmax,
 441                        .extra1         = (void*) &parport_min_timeslice_value,
 442                        .extra2         = (void*) &parport_max_timeslice_value
 443                },
 444                {
 445                        .procname       = "spintime",
 446                        .data           = &parport_default_spintime,
 447                        .maxlen         = sizeof(parport_default_spintime),
 448                        .mode           = 0644,
 449                        .proc_handler   = proc_dointvec_minmax,
 450                        .extra1         = (void*) &parport_min_spintime_value,
 451                        .extra2         = (void*) &parport_max_spintime_value
 452                },
 453                {}
 454        },
 455        {
 456                {
 457                        .procname       = "default",
 458                        .mode           = 0555,
 459                        .child          = parport_default_sysctl_table.vars
 460                },
 461                {}
 462        },
 463        {
 464                PARPORT_PARPORT_DIR(parport_default_sysctl_table.default_dir),
 465                {}
 466        },
 467        {
 468                PARPORT_DEV_DIR(parport_default_sysctl_table.parport_dir),
 469                {}
 470        }
 471};
 472
 473
 474int parport_proc_register(struct parport *port)
 475{
 476        struct parport_sysctl_table *t;
 477        int i;
 478
 479        t = kmalloc(sizeof(*t), GFP_KERNEL);
 480        if (t == NULL)
 481                return -ENOMEM;
 482        memcpy(t, &parport_sysctl_template, sizeof(*t));
 483
 484        t->device_dir[0].extra1 = port;
 485
 486        for (i = 0; i < 5; i++)
 487                t->vars[i].extra1 = port;
 488
 489        t->vars[0].data = &port->spintime;
 490        t->vars[5].child = t->device_dir;
 491        
 492        for (i = 0; i < 5; i++)
 493                t->vars[6 + i].extra2 = &port->probe_info[i];
 494
 495        t->port_dir[0].procname = port->name;
 496
 497        t->port_dir[0].child = t->vars;
 498        t->parport_dir[0].child = t->port_dir;
 499        t->dev_dir[0].child = t->parport_dir;
 500
 501        t->sysctl_header = register_sysctl_table(t->dev_dir);
 502        if (t->sysctl_header == NULL) {
 503                kfree(t);
 504                t = NULL;
 505        }
 506        port->sysctl_table = t;
 507        return 0;
 508}
 509
 510int parport_proc_unregister(struct parport *port)
 511{
 512        if (port->sysctl_table) {
 513                struct parport_sysctl_table *t = port->sysctl_table;
 514                port->sysctl_table = NULL;
 515                unregister_sysctl_table(t->sysctl_header);
 516                kfree(t);
 517        }
 518        return 0;
 519}
 520
 521int parport_device_proc_register(struct pardevice *device)
 522{
 523        struct parport_device_sysctl_table *t;
 524        struct parport * port = device->port;
 525        
 526        t = kmalloc(sizeof(*t), GFP_KERNEL);
 527        if (t == NULL)
 528                return -ENOMEM;
 529        memcpy(t, &parport_device_sysctl_template, sizeof(*t));
 530
 531        t->dev_dir[0].child = t->parport_dir;
 532        t->parport_dir[0].child = t->port_dir;
 533        t->port_dir[0].procname = port->name;
 534        t->port_dir[0].child = t->devices_root_dir;
 535        t->devices_root_dir[0].child = t->device_dir;
 536
 537        t->device_dir[0].procname = device->name;
 538        t->device_dir[0].child = t->vars;
 539        t->vars[0].data = &device->timeslice;
 540
 541        t->sysctl_header = register_sysctl_table(t->dev_dir);
 542        if (t->sysctl_header == NULL) {
 543                kfree(t);
 544                t = NULL;
 545        }
 546        device->sysctl_table = t;
 547        return 0;
 548}
 549
 550int parport_device_proc_unregister(struct pardevice *device)
 551{
 552        if (device->sysctl_table) {
 553                struct parport_device_sysctl_table *t = device->sysctl_table;
 554                device->sysctl_table = NULL;
 555                unregister_sysctl_table(t->sysctl_header);
 556                kfree(t);
 557        }
 558        return 0;
 559}
 560
 561static int __init parport_default_proc_register(void)
 562{
 563        parport_default_sysctl_table.sysctl_header =
 564                register_sysctl_table(parport_default_sysctl_table.dev_dir);
 565        return 0;
 566}
 567
 568static void __exit parport_default_proc_unregister(void)
 569{
 570        if (parport_default_sysctl_table.sysctl_header) {
 571                unregister_sysctl_table(parport_default_sysctl_table.
 572                                        sysctl_header);
 573                parport_default_sysctl_table.sysctl_header = NULL;
 574        }
 575}
 576
 577#else /* no sysctl or no procfs*/
 578
 579int parport_proc_register(struct parport *pp)
 580{
 581        return 0;
 582}
 583
 584int parport_proc_unregister(struct parport *pp)
 585{
 586        return 0;
 587}
 588
 589int parport_device_proc_register(struct pardevice *device)
 590{
 591        return 0;
 592}
 593
 594int parport_device_proc_unregister(struct pardevice *device)
 595{
 596        return 0;
 597}
 598
 599static int __init parport_default_proc_register (void)
 600{
 601        return 0;
 602}
 603
 604static void __exit parport_default_proc_unregister (void)
 605{
 606}
 607#endif
 608
 609module_init(parport_default_proc_register)
 610module_exit(parport_default_proc_unregister)
 611
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.