silicom: bury bp_proc.c · tjh.dev/kernel@685e55e

-3

drivers/staging/silicom/Makefile

··· 4 4 5 5 obj-$(CONFIG_BPCTL) += bpctl_mod.o 6 6 obj-$(CONFIG_SBYPASS) += bypasslib/ 7 - 8 - 9 - bpctl_mod-objs := bp_mod.o bp_proc.o

drivers/staging/silicom/bp_mod.c drivers/staging/silicom/bpctl_mod.c

-1327

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