drivers/staging/silicom/bp_proc.c

   1 /******************************************************************************/
   2 /*                                                                            */
   3 /* Copyright (c) 2004-2006 Silicom, Ltd                                       */
   4 /* All rights reserved.                                                       */
   5 /*                                                                            */
   6 /* This program is free software; you can redistribute it and/or modify       */
   7 /* it under the terms of the GNU General Public License as published by       */
   8 /* the Free Software Foundation, located in the file LICENSE.                 */
   9 /*                                                                            */
  10 /*                                                                            */
  11 /******************************************************************************/
  12
  13 #include <linux/version.h>
  14 #if defined(CONFIG_SMP) && !defined(__SMP__)
  15 #define __SMP__
  16 #endif
  17
  18 #include <linux/proc_fs.h>
  19 #include <linux/netdevice.h>
  20 #include <asm/uaccess.h>
  21 /* #include <linux/smp_lock.h> */
  22 #include "bp_mod.h"
  23
  24 #define BP_PROC_DIR "bypass"
  25 /* #define BYPASS_SUPPORT "bypass" */
  26
  27 #ifdef BYPASS_SUPPORT
  28
  29 #define GPIO6_SET_ENTRY_SD           "gpio6_set"
  30 #define GPIO6_CLEAR_ENTRY_SD         "gpio6_clear"
  31
  32 #define GPIO7_SET_ENTRY_SD           "gpio7_set"
  33 #define GPIO7_CLEAR_ENTRY_SD         "gpio7_clear"
  34
  35 #define PULSE_SET_ENTRY_SD            "pulse_set"
  36 #define ZERO_SET_ENTRY_SD            "zero_set"
  37 #define PULSE_GET1_ENTRY_SD            "pulse_get1"
  38 #define PULSE_GET2_ENTRY_SD            "pulse_get2"
  39
  40 #define CMND_ON_ENTRY_SD              "cmnd_on"
  41 #define CMND_OFF_ENTRY_SD             "cmnd_off"
  42 #define RESET_CONT_ENTRY_SD           "reset_cont"
  43
  44  /*COMMANDS*/
  45 #define BYPASS_INFO_ENTRY_SD     "bypass_info"
  46 #define BYPASS_SLAVE_ENTRY_SD    "bypass_slave"
  47 #define BYPASS_CAPS_ENTRY_SD     "bypass_caps"
  48 #define WD_SET_CAPS_ENTRY_SD     "wd_set_caps"
  49 #define BYPASS_ENTRY_SD          "bypass"
  50 #define BYPASS_CHANGE_ENTRY_SD   "bypass_change"
  51 #define BYPASS_WD_ENTRY_SD       "bypass_wd"
  52 #define WD_EXPIRE_TIME_ENTRY_SD  "wd_expire_time"
  53 #define RESET_BYPASS_WD_ENTRY_SD "reset_bypass_wd"
  54 #define DIS_BYPASS_ENTRY_SD      "dis_bypass"
  55 #define BYPASS_PWUP_ENTRY_SD     "bypass_pwup"
  56 #define BYPASS_PWOFF_ENTRY_SD     "bypass_pwoff"
  57 #define STD_NIC_ENTRY_SD         "std_nic"
  58 #define STD_NIC_ENTRY_SD         "std_nic"
  59 #define TAP_ENTRY_SD             "tap"
  60 #define TAP_CHANGE_ENTRY_SD      "tap_change"
  61 #define DIS_TAP_ENTRY_SD         "dis_tap"
  62 #define TAP_PWUP_ENTRY_SD        "tap_pwup"
  63 #define TWO_PORT_LINK_ENTRY_SD   "two_port_link"
  64 #define WD_EXP_MODE_ENTRY_SD     "wd_exp_mode"
  65 #define WD_AUTORESET_ENTRY_SD    "wd_autoreset"
  66 #define TPL_ENTRY_SD             "tpl"
  67 #define WAIT_AT_PWUP_ENTRY_SD    "wait_at_pwup"
  68 #define HW_RESET_ENTRY_SD        "hw_reset"
  69 #define DISC_ENTRY_SD             "disc"
  70 #define DISC_CHANGE_ENTRY_SD      "disc_change"
  71 #define DIS_DISC_ENTRY_SD         "dis_disc"
  72 #define DISC_PWUP_ENTRY_SD        "disc_pwup"
  73 #endif  /* bypass_support */
  74 static struct proc_dir_entry *bp_procfs_dir;
  75
  76 static struct proc_dir_entry *proc_getdir(char *name,
  77                                           struct proc_dir_entry *proc_dir)
  78 {
  79         struct proc_dir_entry *pde = proc_dir;
  80         for (pde = pde->subdir; pde; pde = pde->next) {
  81                 if (pde->namelen && (strcmp(name, pde->name) == 0)) {
  82                         /* directory exists */
  83                         break;
  84                 }
  85         }
  86         if (pde == (struct proc_dir_entry *)0) {
  87                 /* create the directory */
  88                 pde = create_proc_entry(name, S_IFDIR, proc_dir);
  89                 if (pde == (struct proc_dir_entry *)0)
  90                         return pde;
  91         }
  92         return pde;
  93 }
  94
  95 #ifdef BYPASS_SUPPORT
  96
  97 int
  98 bypass_proc_create_entry_sd(struct pfs_unit *pfs_unit_curr,
  99                             char *proc_name,
 100                             write_proc_t *write_proc,
 101                             read_proc_t *read_proc,
 102                             struct proc_dir_entry *parent_pfs, void *data)
 103 {
 104         strcpy(pfs_unit_curr->proc_name, proc_name);
 105         pfs_unit_curr->proc_entry = create_proc_entry(pfs_unit_curr->proc_name,
 106                                                       S_IFREG | S_IRUSR |
 107                                                       S_IWUSR | S_IRGRP |
 108                                                       S_IROTH, parent_pfs);
 109         if (pfs_unit_curr->proc_entry == 0)
 110                 return -1;
 111
 112         pfs_unit_curr->proc_entry->read_proc = read_proc;
 113         pfs_unit_curr->proc_entry->write_proc = write_proc;
 114         pfs_unit_curr->proc_entry->data = data;
 115
 116         return 0;
 117
 118 }
 119
 120 int
 121 get_bypass_info_pfs(char *page, char **start, off_t off, int count,
 122                     int *eof, void *data)
 123 {
 124         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 125         int len = 0;
 126
 127         len += sprintf(page, "Name\t\t\t%s\n", pbp_device_block->bp_name);
 128         len +=
 129             sprintf(page + len, "Firmware version\t0x%x\n",
 130                     pbp_device_block->bp_fw_ver);
 131
 132         *eof = 1;
 133         return len;
 134 }
 135
 136 int
 137 get_bypass_slave_pfs(char *page, char **start, off_t off, int count,
 138                      int *eof, void *data)
 139 {
 140         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 141
 142         struct pci_dev *pci_slave_dev = pbp_device_block->bp_slave;
 143         struct net_device *net_slave_dev;
 144         int len = 0;
 145
 146         if (is_bypass_fn(pbp_device_block)) {
 147                 net_slave_dev = pci_get_drvdata(pci_slave_dev);
 148                 if (net_slave_dev)
 149                         len = sprintf(page, "%s\n", net_slave_dev->name);
 150                 else
 151                         len = sprintf(page, "fail\n");
 152         } else
 153                 len = sprintf(page, "fail\n");
 154
 155         *eof = 1;
 156         return len;
 157 }
 158
 159 int
 160 get_bypass_caps_pfs(char *page, char **start, off_t off, int count,
 161                     int *eof, void *data)
 162 {
 163         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 164
 165         int len = 0, ret = 0;
 166
 167         ret = get_bypass_caps_fn(pbp_device_block);
 168         if (ret == BP_NOT_CAP)
 169                 len = sprintf(page, "-1\n");
 170         else
 171                 len = sprintf(page, "0x%x\n", ret);
 172         *eof = 1;
 173         return len;
 174
 175 }
 176
 177 int
 178 get_wd_set_caps_pfs(char *page, char **start, off_t off, int count,
 179                     int *eof, void *data)
 180 {
 181         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 182
 183         int len = 0, ret = 0;
 184
 185         ret = get_wd_set_caps_fn(pbp_device_block);
 186         if (ret == BP_NOT_CAP)
 187                 len = sprintf(page, "-1\n");
 188         else
 189                 len = sprintf(page, "0x%x\n", ret);
 190         *eof = 1;
 191         return len;
 192 }
 193
 194 int
 195 set_bypass_pfs(struct file *file, const char *buffer,
 196                unsigned long count, void *data)
 197 {
 198
 199         char kbuf[256];
 200         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 201
 202         int bypass_param = 0, length = 0;
 203
 204         if (count > (sizeof(kbuf) - 1))
 205                 return -1;
 206
 207         if (copy_from_user(&kbuf, buffer, count))
 208                 return -1;
 209
 210         kbuf[count] = '\0';
 211         length = strlen(kbuf);
 212         if (kbuf[length - 1] == '\n')
 213                 kbuf[--length] = '\0';
 214
 215         if (strcmp(kbuf, "on") == 0)
 216                 bypass_param = 1;
 217         else if (strcmp(kbuf, "off") == 0)
 218                 bypass_param = 0;
 219
 220         set_bypass_fn(pbp_device_block, bypass_param);
 221
 222         return count;
 223 }
 224
 225 int
 226 set_tap_pfs(struct file *file, const char *buffer,
 227             unsigned long count, void *data)
 228 {
 229
 230         char kbuf[256];
 231         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 232
 233         int tap_param = 0, length = 0;
 234
 235         if (count > (sizeof(kbuf) - 1))
 236                 return -1;
 237
 238         if (copy_from_user(&kbuf, buffer, count))
 239                 return -1;
 240
 241         kbuf[count] = '\0';
 242         length = strlen(kbuf);
 243         if (kbuf[length - 1] == '\n')
 244                 kbuf[--length] = '\0';
 245
 246         if (strcmp(kbuf, "on") == 0)
 247                 tap_param = 1;
 248         else if (strcmp(kbuf, "off") == 0)
 249                 tap_param = 0;
 250
 251         set_tap_fn(pbp_device_block, tap_param);
 252
 253         return count;
 254 }
 255
 256 int
 257 set_disc_pfs(struct file *file, const char *buffer,
 258              unsigned long count, void *data)
 259 {
 260
 261         char kbuf[256];
 262         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 263
 264         int tap_param = 0, length = 0;
 265
 266         if (count > (sizeof(kbuf) - 1))
 267                 return -1;
 268
 269         if (copy_from_user(&kbuf, buffer, count))
 270                 return -1;
 271
 272         kbuf[count] = '\0';
 273         length = strlen(kbuf);
 274         if (kbuf[length - 1] == '\n')
 275                 kbuf[--length] = '\0';
 276
 277         if (strcmp(kbuf, "on") == 0)
 278                 tap_param = 1;
 279         else if (strcmp(kbuf, "off") == 0)
 280                 tap_param = 0;
 281
 282         set_disc_fn(pbp_device_block, tap_param);
 283
 284         return count;
 285 }
 286
 287 int
 288 get_bypass_pfs(char *page, char **start, off_t off, int count,
 289                int *eof, void *data)
 290 {
 291         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 292
 293         int len = 0, ret = 0;
 294
 295         ret = get_bypass_fn(pbp_device_block);
 296         if (ret == BP_NOT_CAP)
 297                 len = sprintf(page, "fail\n");
 298         else if (ret == 1)
 299                 len = sprintf(page, "on\n");
 300         else if (ret == 0)
 301                 len = sprintf(page, "off\n");
 302
 303         *eof = 1;
 304         return len;
 305 }
 306
 307 int
 308 get_tap_pfs(char *page, char **start, off_t off, int count,
 309             int *eof, void *data)
 310 {
 311         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 312
 313         int len = 0, ret = 0;
 314
 315         ret = get_tap_fn(pbp_device_block);
 316         if (ret == BP_NOT_CAP)
 317                 len = sprintf(page, "fail\n");
 318         else if (ret == 1)
 319                 len = sprintf(page, "on\n");
 320         else if (ret == 0)
 321                 len = sprintf(page, "off\n");
 322
 323         *eof = 1;
 324         return len;
 325 }
 326
 327 int
 328 get_disc_pfs(char *page, char **start, off_t off, int count,
 329              int *eof, void *data)
 330 {
 331         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 332
 333         int len = 0, ret = 0;
 334
 335         ret = get_disc_fn(pbp_device_block);
 336         if (ret == BP_NOT_CAP)
 337                 len = sprintf(page, "fail\n");
 338         else if (ret == 1)
 339                 len = sprintf(page, "on\n");
 340         else if (ret == 0)
 341                 len = sprintf(page, "off\n");
 342
 343         *eof = 1;
 344         return len;
 345 }
 346
 347 int
 348 get_bypass_change_pfs(char *page, char **start, off_t off, int count,
 349                       int *eof, void *data)
 350 {
 351         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 352
 353         int len = 0, ret = 0;
 354
 355         ret = get_bypass_change_fn(pbp_device_block);
 356         if (ret == 1)
 357                 len = sprintf(page, "on\n");
 358         else if (ret == 0)
 359                 len = sprintf(page, "off\n");
 360         else
 361                 len = sprintf(page, "fail\n");
 362
 363         *eof = 1;
 364         return len;
 365 }
 366
 367 int
 368 get_tap_change_pfs(char *page, char **start, off_t off, int count,
 369                    int *eof, void *data)
 370 {
 371         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 372
 373         int len = 0, ret = 0;
 374
 375         ret = get_tap_change_fn(pbp_device_block);
 376         if (ret == 1)
 377                 len = sprintf(page, "on\n");
 378         else if (ret == 0)
 379                 len = sprintf(page, "off\n");
 380         else
 381                 len = sprintf(page, "fail\n");
 382
 383         *eof = 1;
 384         return len;
 385 }
 386
 387 int
 388 get_disc_change_pfs(char *page, char **start, off_t off, int count,
 389                     int *eof, void *data)
 390 {
 391         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 392
 393         int len = 0, ret = 0;
 394
 395         ret = get_disc_change_fn(pbp_device_block);
 396         if (ret == 1)
 397                 len = sprintf(page, "on\n");
 398         else if (ret == 0)
 399                 len = sprintf(page, "off\n");
 400         else
 401                 len = sprintf(page, "fail\n");
 402
 403         *eof = 1;
 404         return len;
 405 }
 406
 407 int
 408 set_bypass_wd_pfs(struct file *file, const char *buffer,
 409                   unsigned long count, void *data)
 410 {
 411
 412         char kbuf[256];
 413         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 414
 415         unsigned int timeout = 0;
 416         char *timeout_ptr = kbuf;
 417
 418         if (copy_from_user(&kbuf, buffer, count))
 419                 return -1;
 420
 421         timeout_ptr = kbuf;
 422         timeout = atoi(&timeout_ptr);
 423
 424         set_bypass_wd_fn(pbp_device_block, timeout);
 425
 426         return count;
 427 }
 428
 429 int
 430 get_bypass_wd_pfs(char *page, char **start, off_t off, int count,
 431                   int *eof, void *data)
 432 {
 433         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 434
 435         int len = 0, ret = 0, timeout = 0;
 436
 437         ret = get_bypass_wd_fn(pbp_device_block, &timeout);
 438         if (ret == BP_NOT_CAP)
 439                 len = sprintf(page, "fail\n");
 440         else if (timeout == -1)
 441                 len = sprintf(page, "unknown\n");
 442         else if (timeout == 0)
 443                 len = sprintf(page, "disable\n");
 444         else
 445                 len = sprintf(page, "%d\n", timeout);
 446
 447         *eof = 1;
 448         return len;
 449 }
 450
 451 int
 452 get_wd_expire_time_pfs(char *page, char **start, off_t off, int count,
 453                        int *eof, void *data)
 454 {
 455         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 456
 457         int len = 0, ret = 0, timeout = 0;
 458
 459         ret = get_wd_expire_time_fn(pbp_device_block, &timeout);
 460         if (ret == BP_NOT_CAP)
 461                 len = sprintf(page, "fail\n");
 462         else if (timeout == -1)
 463                 len = sprintf(page, "expire\n");
 464         else if (timeout == 0)
 465                 len = sprintf(page, "disable\n");
 466
 467         else
 468                 len = sprintf(page, "%d\n", timeout);
 469         *eof = 1;
 470         return len;
 471 }
 472
 473 int
 474 get_tpl_pfs(char *page, char **start, off_t off, int count,
 475             int *eof, void *data)
 476 {
 477         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 478
 479         int len = 0, ret = 0;
 480
 481         ret = get_tpl_fn(pbp_device_block);
 482         if (ret == BP_NOT_CAP)
 483                 len = sprintf(page, "fail\n");
 484         else if (ret == 1)
 485                 len = sprintf(page, "on\n");
 486         else if (ret == 0)
 487                 len = sprintf(page, "off\n");
 488
 489         *eof = 1;
 490         return len;
 491 }
 492
 493 #ifdef PMC_FIX_FLAG
 494 int
 495 get_wait_at_pwup_pfs(char *page, char **start, off_t off, int count,
 496                      int *eof, void *data)
 497 {
 498         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 499
 500         int len = 0, ret = 0;
 501
 502         ret = get_bp_wait_at_pwup_fn(pbp_device_block);
 503         if (ret == BP_NOT_CAP)
 504                 len = sprintf(page, "fail\n");
 505         else if (ret == 1)
 506                 len = sprintf(page, "on\n");
 507         else if (ret == 0)
 508                 len = sprintf(page, "off\n");
 509
 510         *eof = 1;
 511         return len;
 512 }
 513
 514 int
 515 get_hw_reset_pfs(char *page, char **start, off_t off, int count,
 516                  int *eof, void *data)
 517 {
 518         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 519
 520         int len = 0, ret = 0;
 521
 522         ret = get_bp_hw_reset_fn(pbp_device_block);
 523         if (ret == BP_NOT_CAP)
 524                 len = sprintf(page, "fail\n");
 525         else if (ret == 1)
 526                 len = sprintf(page, "on\n");
 527         else if (ret == 0)
 528                 len = sprintf(page, "off\n");
 529
 530         *eof = 1;
 531         return len;
 532 }
 533
 534 #endif                          /*PMC_WAIT_FLAG */
 535
 536 int
 537 reset_bypass_wd_pfs(char *page, char **start, off_t off, int count,
 538                     int *eof, void *data)
 539 {
 540         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 541
 542         int len = 0, ret = 0;
 543
 544         ret = reset_bypass_wd_timer_fn(pbp_device_block);
 545         if (ret == BP_NOT_CAP)
 546                 len = sprintf(page, "fail\n");
 547         else if (ret == 0)
 548                 len = sprintf(page, "disable\n");
 549         else if (ret == 1)
 550                 len = sprintf(page, "success\n");
 551
 552         *eof = 1;
 553         return len;
 554 }
 555
 556 int
 557 set_dis_bypass_pfs(struct file *file, const char *buffer,
 558                    unsigned long count, void *data)
 559 {
 560
 561         char kbuf[256];
 562         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 563
 564         int bypass_param = 0, length = 0;
 565
 566         if (copy_from_user(&kbuf, buffer, count))
 567                 return -1;
 568
 569         kbuf[count] = '\0';
 570         length = strlen(kbuf);
 571         if (kbuf[length - 1] == '\n')
 572                 kbuf[--length] = '\0';
 573
 574         if (strcmp(kbuf, "on") == 0)
 575                 bypass_param = 1;
 576         else if (strcmp(kbuf, "off") == 0)
 577                 bypass_param = 0;
 578
 579         set_dis_bypass_fn(pbp_device_block, bypass_param);
 580
 581         return count;
 582 }
 583
 584 int
 585 set_dis_tap_pfs(struct file *file, const char *buffer,
 586                 unsigned long count, void *data)
 587 {
 588
 589         char kbuf[256];
 590         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 591
 592         int tap_param = 0, length = 0;
 593
 594         if (copy_from_user(&kbuf, buffer, count))
 595                 return -1;
 596
 597         kbuf[count] = '\0';
 598         length = strlen(kbuf);
 599         if (kbuf[length - 1] == '\n')
 600                 kbuf[--length] = '\0';
 601
 602         if (strcmp(kbuf, "on") == 0)
 603                 tap_param = 1;
 604         else if (strcmp(kbuf, "off") == 0)
 605                 tap_param = 0;
 606
 607         set_dis_tap_fn(pbp_device_block, tap_param);
 608
 609         return count;
 610 }
 611
 612 int
 613 set_dis_disc_pfs(struct file *file, const char *buffer,
 614                  unsigned long count, void *data)
 615 {
 616
 617         char kbuf[256];
 618         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 619
 620         int tap_param = 0, length = 0;
 621
 622         if (copy_from_user(&kbuf, buffer, count))
 623                 return -1;
 624
 625         kbuf[count] = '\0';
 626         length = strlen(kbuf);
 627         if (kbuf[length - 1] == '\n')
 628                 kbuf[--length] = '\0';
 629
 630         if (strcmp(kbuf, "on") == 0)
 631                 tap_param = 1;
 632         else if (strcmp(kbuf, "off") == 0)
 633                 tap_param = 0;
 634
 635         set_dis_disc_fn(pbp_device_block, tap_param);
 636
 637         return count;
 638 }
 639
 640 int
 641 get_dis_bypass_pfs(char *page, char **start, off_t off, int count,
 642                    int *eof, void *data)
 643 {
 644         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 645
 646         int len = 0, ret = 0;
 647
 648         ret = get_dis_bypass_fn(pbp_device_block);
 649         if (ret == BP_NOT_CAP)
 650                 len = sprintf(page, "fail\n");
 651         else if (ret == 0)
 652                 len = sprintf(page, "off\n");
 653         else
 654                 len = sprintf(page, "on\n");
 655
 656         *eof = 1;
 657         return len;
 658 }
 659
 660 int
 661 get_dis_tap_pfs(char *page, char **start, off_t off, int count,
 662                 int *eof, void *data)
 663 {
 664         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 665
 666         int len = 0, ret = 0;
 667
 668         ret = get_dis_tap_fn(pbp_device_block);
 669         if (ret == BP_NOT_CAP)
 670                 len = sprintf(page, "fail\n");
 671         else if (ret == 0)
 672                 len = sprintf(page, "off\n");
 673         else
 674                 len = sprintf(page, "on\n");
 675
 676         *eof = 1;
 677         return len;
 678 }
 679
 680 int
 681 get_dis_disc_pfs(char *page, char **start, off_t off, int count,
 682                  int *eof, void *data)
 683 {
 684         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 685
 686         int len = 0, ret = 0;
 687
 688         ret = get_dis_disc_fn(pbp_device_block);
 689         if (ret == BP_NOT_CAP)
 690                 len = sprintf(page, "fail\n");
 691         else if (ret == 0)
 692                 len = sprintf(page, "off\n");
 693         else
 694                 len = sprintf(page, "on\n");
 695
 696         *eof = 1;
 697         return len;
 698 }
 699
 700 int
 701 set_bypass_pwup_pfs(struct file *file, const char *buffer,
 702                     unsigned long count, void *data)
 703 {
 704
 705         char kbuf[256];
 706         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 707
 708         int bypass_param = 0, length = 0;
 709
 710         if (copy_from_user(&kbuf, buffer, count))
 711                 return -1;
 712
 713         kbuf[count] = '\0';
 714         length = strlen(kbuf);
 715         if (kbuf[length - 1] == '\n')
 716                 kbuf[--length] = '\0';
 717
 718         if (strcmp(kbuf, "on") == 0)
 719                 bypass_param = 1;
 720         else if (strcmp(kbuf, "off") == 0)
 721                 bypass_param = 0;
 722
 723         set_bypass_pwup_fn(pbp_device_block, bypass_param);
 724
 725         return count;
 726 }
 727
 728 int
 729 set_bypass_pwoff_pfs(struct file *file, const char *buffer,
 730                      unsigned long count, void *data)
 731 {
 732
 733         char kbuf[256];
 734         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 735
 736         int bypass_param = 0, length = 0;
 737
 738         if (copy_from_user(&kbuf, buffer, count))
 739                 return -1;
 740
 741         kbuf[count] = '\0';
 742         length = strlen(kbuf);
 743         if (kbuf[length - 1] == '\n')
 744                 kbuf[--length] = '\0';
 745
 746         if (strcmp(kbuf, "on") == 0)
 747                 bypass_param = 1;
 748         else if (strcmp(kbuf, "off") == 0)
 749                 bypass_param = 0;
 750
 751         set_bypass_pwoff_fn(pbp_device_block, bypass_param);
 752
 753         return count;
 754 }
 755
 756 int
 757 set_tap_pwup_pfs(struct file *file, const char *buffer,
 758                  unsigned long count, void *data)
 759 {
 760
 761         char kbuf[256];
 762         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 763
 764         int tap_param = 0, length = 0;
 765
 766         if (copy_from_user(&kbuf, buffer, count))
 767                 return -1;
 768
 769         kbuf[count] = '\0';
 770         length = strlen(kbuf);
 771         if (kbuf[length - 1] == '\n')
 772                 kbuf[--length] = '\0';
 773
 774         if (strcmp(kbuf, "on") == 0)
 775                 tap_param = 1;
 776         else if (strcmp(kbuf, "off") == 0)
 777                 tap_param = 0;
 778
 779         set_tap_pwup_fn(pbp_device_block, tap_param);
 780
 781         return count;
 782 }
 783
 784 int
 785 set_disc_pwup_pfs(struct file *file, const char *buffer,
 786                   unsigned long count, void *data)
 787 {
 788
 789         char kbuf[256];
 790         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 791
 792         int tap_param = 0, length = 0;
 793
 794         if (copy_from_user(&kbuf, buffer, count))
 795                 return -1;
 796
 797         kbuf[count] = '\0';
 798         length = strlen(kbuf);
 799         if (kbuf[length - 1] == '\n')
 800                 kbuf[--length] = '\0';
 801
 802         if (strcmp(kbuf, "on") == 0)
 803                 tap_param = 1;
 804         else if (strcmp(kbuf, "off") == 0)
 805                 tap_param = 0;
 806
 807         set_disc_pwup_fn(pbp_device_block, tap_param);
 808
 809         return count;
 810 }
 811
 812 int
 813 get_bypass_pwup_pfs(char *page, char **start, off_t off, int count,
 814                     int *eof, void *data)
 815 {
 816         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 817
 818         int len = 0, ret = 0;
 819
 820         ret = get_bypass_pwup_fn(pbp_device_block);
 821         if (ret == BP_NOT_CAP)
 822                 len = sprintf(page, "fail\n");
 823         else if (ret == 0)
 824                 len = sprintf(page, "off\n");
 825         else
 826                 len = sprintf(page, "on\n");
 827
 828         *eof = 1;
 829         return len;
 830 }
 831
 832 int
 833 get_bypass_pwoff_pfs(char *page, char **start, off_t off, int count,
 834                      int *eof, void *data)
 835 {
 836         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 837
 838         int len = 0, ret = 0;
 839
 840         ret = get_bypass_pwoff_fn(pbp_device_block);
 841         if (ret == BP_NOT_CAP)
 842                 len = sprintf(page, "fail\n");
 843         else if (ret == 0)
 844                 len = sprintf(page, "off\n");
 845         else
 846                 len = sprintf(page, "on\n");
 847
 848         *eof = 1;
 849         return len;
 850 }
 851
 852 int
 853 get_tap_pwup_pfs(char *page, char **start, off_t off, int count,
 854                  int *eof, void *data)
 855 {
 856         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 857
 858         int len = 0, ret = 0;
 859
 860         ret = get_tap_pwup_fn(pbp_device_block);
 861         if (ret == BP_NOT_CAP)
 862                 len = sprintf(page, "fail\n");
 863         else if (ret == 0)
 864                 len = sprintf(page, "off\n");
 865         else
 866                 len = sprintf(page, "on\n");
 867
 868         *eof = 1;
 869         return len;
 870 }
 871
 872 int
 873 get_disc_pwup_pfs(char *page, char **start, off_t off, int count,
 874                   int *eof, void *data)
 875 {
 876         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 877
 878         int len = 0, ret = 0;
 879
 880         ret = get_disc_pwup_fn(pbp_device_block);
 881         if (ret == BP_NOT_CAP)
 882                 len = sprintf(page, "fail\n");
 883         else if (ret == 0)
 884                 len = sprintf(page, "off\n");
 885         else
 886                 len = sprintf(page, "on\n");
 887
 888         *eof = 1;
 889         return len;
 890 }
 891
 892 int
 893 set_std_nic_pfs(struct file *file, const char *buffer,
 894                 unsigned long count, void *data)
 895 {
 896
 897         char kbuf[256];
 898         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 899
 900         int bypass_param = 0, length = 0;
 901
 902         if (copy_from_user(&kbuf, buffer, count))
 903                 return -1;
 904
 905         kbuf[count] = '\0';
 906         length = strlen(kbuf);
 907         if (kbuf[length - 1] == '\n')
 908                 kbuf[--length] = '\0';
 909
 910         if (strcmp(kbuf, "on") == 0)
 911                 bypass_param = 1;
 912         else if (strcmp(kbuf, "off") == 0)
 913                 bypass_param = 0;
 914
 915         set_std_nic_fn(pbp_device_block, bypass_param);
 916
 917         return count;
 918 }
 919
 920 int
 921 get_std_nic_pfs(char *page, char **start, off_t off, int count,
 922                 int *eof, void *data)
 923 {
 924         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 925
 926         int len = 0, ret = 0;
 927
 928         ret = get_std_nic_fn(pbp_device_block);
 929         if (ret == BP_NOT_CAP)
 930                 len = sprintf(page, "fail\n");
 931         else if (ret == 0)
 932                 len = sprintf(page, "off\n");
 933         else
 934                 len = sprintf(page, "on\n");
 935
 936         *eof = 1;
 937         return len;
 938 }
 939
 940 int
 941 get_wd_exp_mode_pfs(char *page, char **start, off_t off, int count,
 942                     int *eof, void *data)
 943 {
 944         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 945
 946         int len = 0, ret = 0;
 947
 948         ret = get_wd_exp_mode_fn(pbp_device_block);
 949         if (ret == 1)
 950                 len = sprintf(page, "tap\n");
 951         else if (ret == 0)
 952                 len = sprintf(page, "bypass\n");
 953         else if (ret == 2)
 954                 len = sprintf(page, "disc\n");
 955
 956         else
 957                 len = sprintf(page, "fail\n");
 958
 959         *eof = 1;
 960         return len;
 961 }
 962
 963 int
 964 set_wd_exp_mode_pfs(struct file *file, const char *buffer,
 965                     unsigned long count, void *data)
 966 {
 967
 968         char kbuf[256];
 969         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
 970
 971         int bypass_param = 0, length = 0;
 972
 973         if (count > (sizeof(kbuf) - 1))
 974                 return -1;
 975
 976         if (copy_from_user(&kbuf, buffer, count))
 977                 return -1;
 978
 979         kbuf[count] = '\0';
 980         length = strlen(kbuf);
 981         if (kbuf[length - 1] == '\n')
 982                 kbuf[--length] = '\0';
 983
 984         if (strcmp(kbuf, "tap") == 0)
 985                 bypass_param = 1;
 986         else if (strcmp(kbuf, "bypass") == 0)
 987                 bypass_param = 0;
 988         else if (strcmp(kbuf, "disc") == 0)
 989                 bypass_param = 2;
 990
 991         set_wd_exp_mode_fn(pbp_device_block, bypass_param);
 992
 993         return count;
 994 }
 995
 996 int
 997 get_wd_autoreset_pfs(char *page, char **start, off_t off, int count,
 998                      int *eof, void *data)
 999 {
1000         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1001
1002         int len = 0, ret = 0;
1003
1004         ret = get_wd_autoreset_fn(pbp_device_block);
1005         if (ret >= 0)
1006                 len = sprintf(page, "%d\n", ret);
1007         else
1008                 len = sprintf(page, "fail\n");
1009
1010         *eof = 1;
1011         return len;
1012 }
1013
1014 int
1015 set_wd_autoreset_pfs(struct file *file, const char *buffer,
1016                      unsigned long count, void *data)
1017 {
1018         char kbuf[256];
1019         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1020         u32 timeout = 0;
1021         char *timeout_ptr = kbuf;
1022
1023         if (copy_from_user(&kbuf, buffer, count))
1024                 return -1;
1025
1026         timeout_ptr = kbuf;
1027         timeout = atoi(&timeout_ptr);
1028
1029         set_wd_autoreset_fn(pbp_device_block, timeout);
1030
1031         return count;
1032 }
1033
1034 int
1035 set_tpl_pfs(struct file *file, const char *buffer,
1036             unsigned long count, void *data)
1037 {
1038
1039         char kbuf[256];
1040         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1041
1042         int tpl_param = 0, length = 0;
1043
1044         if (count > (sizeof(kbuf) - 1))
1045                 return -1;
1046
1047         if (copy_from_user(&kbuf, buffer, count))
1048                 return -1;
1049
1050         kbuf[count] = '\0';
1051         length = strlen(kbuf);
1052         if (kbuf[length - 1] == '\n')
1053                 kbuf[--length] = '\0';
1054
1055         if (strcmp(kbuf, "on") == 0)
1056                 tpl_param = 1;
1057         else if (strcmp(kbuf, "off") == 0)
1058                 tpl_param = 0;
1059
1060         set_tpl_fn(pbp_device_block, tpl_param);
1061
1062         return count;
1063 }
1064
1065 #ifdef PMC_FIX_FLAG
1066 int
1067 set_wait_at_pwup_pfs(struct file *file, const char *buffer,
1068                      unsigned long count, void *data)
1069 {
1070
1071         char kbuf[256];
1072         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1073
1074         int tpl_param = 0, length = 0;
1075
1076         if (count > (sizeof(kbuf) - 1))
1077                 return -1;
1078
1079         if (copy_from_user(&kbuf, buffer, count))
1080                 return -1;
1081
1082         kbuf[count] = '\0';
1083         length = strlen(kbuf);
1084         if (kbuf[length - 1] == '\n')
1085                 kbuf[--length] = '\0';
1086
1087         if (strcmp(kbuf, "on") == 0)
1088                 tpl_param = 1;
1089         else if (strcmp(kbuf, "off") == 0)
1090                 tpl_param = 0;
1091
1092         set_bp_wait_at_pwup_fn(pbp_device_block, tpl_param);
1093
1094         return count;
1095 }
1096
1097 int
1098 set_hw_reset_pfs(struct file *file, const char *buffer,
1099                  unsigned long count, void *data)
1100 {
1101
1102         char kbuf[256];
1103         bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1104
1105         int tpl_param = 0, length = 0;
1106
1107         if (count > (sizeof(kbuf) - 1))
1108                 return -1;
1109
1110         if (copy_from_user(&kbuf, buffer, count))
1111                 return -1;
1112
1113         kbuf[count] = '\0';
1114         length = strlen(kbuf);
1115         if (kbuf[length - 1] == '\n')
1116                 kbuf[--length] = '\0';
1117
1118         if (strcmp(kbuf, "on") == 0)
1119                 tpl_param = 1;
1120         else if (strcmp(kbuf, "off") == 0)
1121                 tpl_param = 0;
1122
1123         set_bp_hw_reset_fn(pbp_device_block, tpl_param);
1124
1125         return count;
1126 }
1127
1128 #endif                          /*PMC_FIX_FLAG */
1129
1130 int bypass_proc_create_dev_sd(bpctl_dev_t *pbp_device_block)
1131 {
1132         struct bypass_pfs_sd *current_pfs = &(pbp_device_block->bypass_pfs_set);
1133         static struct proc_dir_entry *procfs_dir;
1134         int ret = 0;
1135
1136         sprintf(current_pfs->dir_name, "bypass_%s", dev->name);
1137
1138         if (!bp_procfs_dir)
1139                 return -1;
1140
1141         /* create device proc dir */
1142         procfs_dir = proc_getdir(current_pfs->dir_name, bp_procfs_dir);
1143         if (procfs_dir == 0) {
1144                 printk(KERN_DEBUG "Could not create procfs directory %s\n",
1145                        current_pfs->dir_name);
1146                 return -1;
1147         }
1148         current_pfs->bypass_entry = procfs_dir;
1149
1150         if (bypass_proc_create_entry(&(current_pfs->bypass_info), BYPASS_INFO_ENTRY_SD, NULL,   /* write */
1151                                      get_bypass_info_pfs,       /* read  */
1152                                      procfs_dir, pbp_device_block))
1153                 ret = -1;
1154
1155         if (pbp_device_block->bp_caps & SW_CTL_CAP) {
1156
1157                 /* Create set param proc's */
1158                 if (bypass_proc_create_entry_sd(&(current_pfs->bypass_slave), BYPASS_SLAVE_ENTRY_SD, NULL,      /* write */
1159                                                 get_bypass_slave_pfs,   /* read  */
1160                                                 procfs_dir, pbp_device_block))
1161                         ret = -1;
1162
1163                 if (bypass_proc_create_entry_sd(&(current_pfs->bypass_caps), BYPASS_CAPS_ENTRY_SD, NULL,        /* write */
1164                                                 get_bypass_caps_pfs,    /* read  */
1165                                                 procfs_dir, pbp_device_block))
1166                         ret = -1;
1167
1168                 if (bypass_proc_create_entry_sd(&(current_pfs->wd_set_caps), WD_SET_CAPS_ENTRY_SD, NULL,        /* write */
1169                                                 get_wd_set_caps_pfs,    /* read  */
1170                                                 procfs_dir, pbp_device_block))
1171                         ret = -1;
1172                 if (bypass_proc_create_entry_sd(&(current_pfs->bypass_wd), BYPASS_WD_ENTRY_SD, set_bypass_wd_pfs,       /* write */
1173                                                 get_bypass_wd_pfs,      /* read  */
1174                                                 procfs_dir, pbp_device_block))
1175                         ret = -1;
1176
1177                 if (bypass_proc_create_entry_sd(&(current_pfs->wd_expire_time), WD_EXPIRE_TIME_ENTRY_SD, NULL,  /* write */
1178                                                 get_wd_expire_time_pfs, /* read  */
1179                                                 procfs_dir, pbp_device_block))
1180                         ret = -1;
1181
1182                 if (bypass_proc_create_entry_sd(&(current_pfs->reset_bypass_wd), RESET_BYPASS_WD_ENTRY_SD, NULL,        /* write */
1183                                                 reset_bypass_wd_pfs,    /* read  */
1184                                                 procfs_dir, pbp_device_block))
1185                         ret = -1;
1186
1187                 if (bypass_proc_create_entry_sd(&(current_pfs->std_nic), STD_NIC_ENTRY_SD, set_std_nic_pfs,     /* write */
1188                                                 get_std_nic_pfs,        /* read  */
1189                                                 procfs_dir, pbp_device_block))
1190                         ret = -1;
1191
1192                 if (pbp_device_block->bp_caps & BP_CAP) {
1193                         if (bypass_proc_create_entry_sd(&(current_pfs->bypass), BYPASS_ENTRY_SD, set_bypass_pfs,        /* write */
1194                                                         get_bypass_pfs, /* read  */
1195                                                         procfs_dir,
1196                                                         pbp_device_block))
1197                                 ret = -1;
1198
1199                         if (bypass_proc_create_entry_sd(&(current_pfs->dis_bypass), DIS_BYPASS_ENTRY_SD, set_dis_bypass_pfs,    /* write */
1200                                                         get_dis_bypass_pfs,     /* read  */
1201                                                         procfs_dir,
1202                                                         pbp_device_block))
1203                                 ret = -1;
1204
1205                         if (bypass_proc_create_entry_sd(&(current_pfs->bypass_pwup), BYPASS_PWUP_ENTRY_SD, set_bypass_pwup_pfs, /* write */
1206                                                         get_bypass_pwup_pfs,    /* read  */
1207                                                         procfs_dir,
1208                                                         pbp_device_block))
1209                                 ret = -1;
1210                         if (bypass_proc_create_entry_sd(&(current_pfs->bypass_pwoff), BYPASS_PWOFF_ENTRY_SD, set_bypass_pwoff_pfs,      /* write */
1211                                                         get_bypass_pwoff_pfs,   /* read  */
1212                                                         procfs_dir,
1213                                                         pbp_device_block))
1214                                 ret = -1;
1215
1216                         if (bypass_proc_create_entry_sd(&(current_pfs->bypass_change), BYPASS_CHANGE_ENTRY_SD, NULL,    /* write */
1217                                                         get_bypass_change_pfs,  /* read  */
1218                                                         procfs_dir,
1219                                                         pbp_device_block))
1220                                 ret = -1;
1221                 }
1222
1223                 if (pbp_device_block->bp_caps & TAP_CAP) {
1224
1225                         if (bypass_proc_create_entry_sd(&(current_pfs->tap), TAP_ENTRY_SD, set_tap_pfs, /* write */
1226                                                         get_tap_pfs,    /* read  */
1227                                                         procfs_dir,
1228                                                         pbp_device_block))
1229                                 ret = -1;
1230
1231                         if (bypass_proc_create_entry_sd(&(current_pfs->dis_tap), DIS_TAP_ENTRY_SD, set_dis_tap_pfs,     /* write */
1232                                                         get_dis_tap_pfs,        /* read  */
1233                                                         procfs_dir,
1234                                                         pbp_device_block))
1235                                 ret = -1;
1236
1237                         if (bypass_proc_create_entry_sd(&(current_pfs->tap_pwup), TAP_PWUP_ENTRY_SD, set_tap_pwup_pfs,  /* write */
1238                                                         get_tap_pwup_pfs,       /* read  */
1239                                                         procfs_dir,
1240                                                         pbp_device_block))
1241                                 ret = -1;
1242
1243                         if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), TAP_CHANGE_ENTRY_SD, NULL,  /* write */
1244                                                         get_tap_change_pfs,     /* read  */
1245                                                         procfs_dir,
1246                                                         pbp_device_block))
1247                                 ret = -1;
1248                 }
1249                 if (pbp_device_block->bp_caps & DISC_CAP) {
1250
1251                         if (bypass_proc_create_entry_sd(&(current_pfs->tap), DISC_ENTRY_SD, set_disc_pfs,       /* write */
1252                                                         get_disc_pfs,   /* read  */
1253                                                         procfs_dir,
1254                                                         pbp_device_block))
1255                                 ret = -1;
1256 #if 1
1257
1258                         if (bypass_proc_create_entry_sd(&(current_pfs->dis_tap), DIS_DISC_ENTRY_SD, set_dis_disc_pfs,   /* write */
1259                                                         get_dis_disc_pfs,       /* read  */
1260                                                         procfs_dir,
1261                                                         pbp_device_block))
1262                                 ret = -1;
1263 #endif
1264
1265                         if (bypass_proc_create_entry_sd(&(current_pfs->tap_pwup), DISC_PWUP_ENTRY_SD, set_disc_pwup_pfs,        /* write */
1266                                                         get_disc_pwup_pfs,      /* read  */
1267                                                         procfs_dir,
1268                                                         pbp_device_block))
1269                                 ret = -1;
1270
1271                         if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), DISC_CHANGE_ENTRY_SD, NULL, /* write */
1272                                                         get_disc_change_pfs,    /* read  */
1273                                                         procfs_dir,
1274                                                         pbp_device_block))
1275                                 ret = -1;
1276                 }
1277
1278                 if (bypass_proc_create_entry_sd(&(current_pfs->wd_exp_mode), WD_EXP_MODE_ENTRY_SD, set_wd_exp_mode_pfs, /* write */
1279                                                 get_wd_exp_mode_pfs,    /* read  */
1280                                                 procfs_dir, pbp_device_block))
1281                         ret = -1;
1282
1283                 if (bypass_proc_create_entry_sd(&(current_pfs->wd_autoreset), WD_AUTORESET_ENTRY_SD, set_wd_autoreset_pfs,      /* write */
1284                                                 get_wd_autoreset_pfs,   /* read  */
1285                                                 procfs_dir, pbp_device_block))
1286                         ret = -1;
1287                 if (bypass_proc_create_entry_sd(&(current_pfs->tpl), TPL_ENTRY_SD, set_tpl_pfs, /* write */
1288                                                 get_tpl_pfs,    /* read  */
1289                                                 procfs_dir, pbp_device_block))
1290                         ret = -1;
1291 #ifdef PMC_FIX_FLAG
1292                 if (bypass_proc_create_entry_sd(&(current_pfs->tpl), WAIT_AT_PWUP_ENTRY_SD, set_wait_at_pwup_pfs,       /* write */
1293                                                 get_wait_at_pwup_pfs,   /* read  */
1294                                                 procfs_dir, pbp_device_block))
1295                         ret = -1;
1296                 if (bypass_proc_create_entry_sd(&(current_pfs->tpl), HW_RESET_ENTRY_SD, set_hw_reset_pfs,       /* write */
1297                                                 get_hw_reset_pfs,       /* read  */
1298                                                 procfs_dir, pbp_device_block))
1299                         ret = -1;
1300
1301 #endif
1302
1303         }
1304         if (ret < 0)
1305                 printk(KERN_DEBUG "Create proc entry failed\n");
1306
1307         return ret;
1308 }
1309
1310 int bypass_proc_remove_dev_sd(bpctl_dev_t *pbp_device_block)
1311 {
1312
1313         struct bypass_pfs_sd *current_pfs = &pbp_device_block->bypass_pfs_set;
1314         struct proc_dir_entry *pde = current_pfs->bypass_entry, *pde_curr =
1315             NULL;
1316         char name[256];
1317
1318         for (pde = pde->subdir; pde;) {
1319                 strcpy(name, pde->name);
1320                 pde_curr = pde;
1321                 pde = pde->next;
1322                 remove_proc_entry(name, current_pfs->bypass_entry);
1323         }
1324         if (!pde)
1325                 remove_proc_entry(current_pfs->dir_name, bp_procfs_dir);
1326
1327         return 0;
1328 }
1329
1330 #endif                          /* BYPASS_SUPPORT */