1 /******************************************************************************/
3 /* Copyright (c) 2004-2006 Silicom, Ltd */
4 /* All rights reserved. */
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. */
11 /******************************************************************************/
13 #if defined(CONFIG_SMP) && !defined(__SMP__)
17 #include <linux/proc_fs.h>
18 #include <linux/netdevice.h>
19 #include <asm/uaccess.h>
20 /* #include <linux/smp_lock.h> */
23 #define BP_PROC_DIR "bypass"
24 /* #define BYPASS_SUPPORT "bypass" */
28 #define GPIO6_SET_ENTRY_SD "gpio6_set"
29 #define GPIO6_CLEAR_ENTRY_SD "gpio6_clear"
31 #define GPIO7_SET_ENTRY_SD "gpio7_set"
32 #define GPIO7_CLEAR_ENTRY_SD "gpio7_clear"
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"
39 #define CMND_ON_ENTRY_SD "cmnd_on"
40 #define CMND_OFF_ENTRY_SD "cmnd_off"
41 #define RESET_CONT_ENTRY_SD "reset_cont"
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"
73 static struct proc_dir_entry *bp_procfs_dir;
75 static struct proc_dir_entry *proc_getdir(char *name,
76 struct proc_dir_entry *proc_dir)
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 */
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)
95 bypass_proc_create_entry_sd(struct pfs_unit *pfs_unit_curr,
97 write_proc_t *write_proc,
98 read_proc_t *read_proc,
99 struct proc_dir_entry *parent_pfs, void *data)
101 strcpy(pfs_unit_curr->proc_name, proc_name);
102 pfs_unit_curr->proc_entry = create_proc_entry(pfs_unit_curr->proc_name,
105 S_IROTH, parent_pfs);
106 if (pfs_unit_curr->proc_entry == 0)
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;
118 get_bypass_info_pfs(char *page, char **start, off_t off, int count,
119 int *eof, void *data)
121 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
124 len += sprintf(page, "Name\t\t\t%s\n", pbp_device_block->bp_name);
126 sprintf(page + len, "Firmware version\t0x%x\n",
127 pbp_device_block->bp_fw_ver);
134 get_bypass_slave_pfs(char *page, char **start, off_t off, int count,
135 int *eof, void *data)
137 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
139 struct pci_dev *pci_slave_dev = pbp_device_block->bp_slave;
140 struct net_device *net_slave_dev;
143 if (is_bypass_fn(pbp_device_block)) {
144 net_slave_dev = pci_get_drvdata(pci_slave_dev);
146 len = sprintf(page, "%s\n", net_slave_dev->name);
148 len = sprintf(page, "fail\n");
150 len = sprintf(page, "fail\n");
157 get_bypass_caps_pfs(char *page, char **start, off_t off, int count,
158 int *eof, void *data)
160 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
162 int len = 0, ret = 0;
164 ret = get_bypass_caps_fn(pbp_device_block);
165 if (ret == BP_NOT_CAP)
166 len = sprintf(page, "-1\n");
168 len = sprintf(page, "0x%x\n", ret);
175 get_wd_set_caps_pfs(char *page, char **start, off_t off, int count,
176 int *eof, void *data)
178 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
180 int len = 0, ret = 0;
182 ret = get_wd_set_caps_fn(pbp_device_block);
183 if (ret == BP_NOT_CAP)
184 len = sprintf(page, "-1\n");
186 len = sprintf(page, "0x%x\n", ret);
192 set_bypass_pfs(struct file *file, const char *buffer,
193 unsigned long count, void *data)
197 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
199 int bypass_param = 0, length = 0;
201 if (count > (sizeof(kbuf) - 1))
204 if (copy_from_user(&kbuf, buffer, count))
208 length = strlen(kbuf);
209 if (kbuf[length - 1] == '\n')
210 kbuf[--length] = '\0';
212 if (strcmp(kbuf, "on") == 0)
214 else if (strcmp(kbuf, "off") == 0)
217 set_bypass_fn(pbp_device_block, bypass_param);
223 set_tap_pfs(struct file *file, const char *buffer,
224 unsigned long count, void *data)
228 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
230 int tap_param = 0, length = 0;
232 if (count > (sizeof(kbuf) - 1))
235 if (copy_from_user(&kbuf, buffer, count))
239 length = strlen(kbuf);
240 if (kbuf[length - 1] == '\n')
241 kbuf[--length] = '\0';
243 if (strcmp(kbuf, "on") == 0)
245 else if (strcmp(kbuf, "off") == 0)
248 set_tap_fn(pbp_device_block, tap_param);
254 set_disc_pfs(struct file *file, const char *buffer,
255 unsigned long count, void *data)
259 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
261 int tap_param = 0, length = 0;
263 if (count > (sizeof(kbuf) - 1))
266 if (copy_from_user(&kbuf, buffer, count))
270 length = strlen(kbuf);
271 if (kbuf[length - 1] == '\n')
272 kbuf[--length] = '\0';
274 if (strcmp(kbuf, "on") == 0)
276 else if (strcmp(kbuf, "off") == 0)
279 set_disc_fn(pbp_device_block, tap_param);
285 get_bypass_pfs(char *page, char **start, off_t off, int count,
286 int *eof, void *data)
288 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
290 int len = 0, ret = 0;
292 ret = get_bypass_fn(pbp_device_block);
293 if (ret == BP_NOT_CAP)
294 len = sprintf(page, "fail\n");
296 len = sprintf(page, "on\n");
298 len = sprintf(page, "off\n");
305 get_tap_pfs(char *page, char **start, off_t off, int count,
306 int *eof, void *data)
308 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
310 int len = 0, ret = 0;
312 ret = get_tap_fn(pbp_device_block);
313 if (ret == BP_NOT_CAP)
314 len = sprintf(page, "fail\n");
316 len = sprintf(page, "on\n");
318 len = sprintf(page, "off\n");
325 get_disc_pfs(char *page, char **start, off_t off, int count,
326 int *eof, void *data)
328 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
330 int len = 0, ret = 0;
332 ret = get_disc_fn(pbp_device_block);
333 if (ret == BP_NOT_CAP)
334 len = sprintf(page, "fail\n");
336 len = sprintf(page, "on\n");
338 len = sprintf(page, "off\n");
345 get_bypass_change_pfs(char *page, char **start, off_t off, int count,
346 int *eof, void *data)
348 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
350 int len = 0, ret = 0;
352 ret = get_bypass_change_fn(pbp_device_block);
354 len = sprintf(page, "on\n");
356 len = sprintf(page, "off\n");
358 len = sprintf(page, "fail\n");
365 get_tap_change_pfs(char *page, char **start, off_t off, int count,
366 int *eof, void *data)
368 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
370 int len = 0, ret = 0;
372 ret = get_tap_change_fn(pbp_device_block);
374 len = sprintf(page, "on\n");
376 len = sprintf(page, "off\n");
378 len = sprintf(page, "fail\n");
385 get_disc_change_pfs(char *page, char **start, off_t off, int count,
386 int *eof, void *data)
388 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
390 int len = 0, ret = 0;
392 ret = get_disc_change_fn(pbp_device_block);
394 len = sprintf(page, "on\n");
396 len = sprintf(page, "off\n");
398 len = sprintf(page, "fail\n");
405 set_bypass_wd_pfs(struct file *file, const char *buffer,
406 unsigned long count, void *data)
410 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
412 unsigned int timeout = 0;
413 char *timeout_ptr = kbuf;
415 if (copy_from_user(&kbuf, buffer, count))
419 timeout = atoi(&timeout_ptr);
421 set_bypass_wd_fn(pbp_device_block, timeout);
427 get_bypass_wd_pfs(char *page, char **start, off_t off, int count,
428 int *eof, void *data)
430 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
432 int len = 0, ret = 0, timeout = 0;
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");
442 len = sprintf(page, "%d\n", timeout);
449 get_wd_expire_time_pfs(char *page, char **start, off_t off, int count,
450 int *eof, void *data)
452 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
454 int len = 0, ret = 0, timeout = 0;
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");
465 len = sprintf(page, "%d\n", timeout);
471 get_tpl_pfs(char *page, char **start, off_t off, int count,
472 int *eof, void *data)
474 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
476 int len = 0, ret = 0;
478 ret = get_tpl_fn(pbp_device_block);
479 if (ret == BP_NOT_CAP)
480 len = sprintf(page, "fail\n");
482 len = sprintf(page, "on\n");
484 len = sprintf(page, "off\n");
492 get_wait_at_pwup_pfs(char *page, char **start, off_t off, int count,
493 int *eof, void *data)
495 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
497 int len = 0, ret = 0;
499 ret = get_bp_wait_at_pwup_fn(pbp_device_block);
500 if (ret == BP_NOT_CAP)
501 len = sprintf(page, "fail\n");
503 len = sprintf(page, "on\n");
505 len = sprintf(page, "off\n");
512 get_hw_reset_pfs(char *page, char **start, off_t off, int count,
513 int *eof, void *data)
515 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
517 int len = 0, ret = 0;
519 ret = get_bp_hw_reset_fn(pbp_device_block);
520 if (ret == BP_NOT_CAP)
521 len = sprintf(page, "fail\n");
523 len = sprintf(page, "on\n");
525 len = sprintf(page, "off\n");
531 #endif /*PMC_WAIT_FLAG */
534 reset_bypass_wd_pfs(char *page, char **start, off_t off, int count,
535 int *eof, void *data)
537 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
539 int len = 0, ret = 0;
541 ret = reset_bypass_wd_timer_fn(pbp_device_block);
542 if (ret == BP_NOT_CAP)
543 len = sprintf(page, "fail\n");
545 len = sprintf(page, "disable\n");
547 len = sprintf(page, "success\n");
554 set_dis_bypass_pfs(struct file *file, const char *buffer,
555 unsigned long count, void *data)
559 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
561 int bypass_param = 0, length = 0;
563 if (copy_from_user(&kbuf, buffer, count))
567 length = strlen(kbuf);
568 if (kbuf[length - 1] == '\n')
569 kbuf[--length] = '\0';
571 if (strcmp(kbuf, "on") == 0)
573 else if (strcmp(kbuf, "off") == 0)
576 set_dis_bypass_fn(pbp_device_block, bypass_param);
582 set_dis_tap_pfs(struct file *file, const char *buffer,
583 unsigned long count, void *data)
587 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
589 int tap_param = 0, length = 0;
591 if (copy_from_user(&kbuf, buffer, count))
595 length = strlen(kbuf);
596 if (kbuf[length - 1] == '\n')
597 kbuf[--length] = '\0';
599 if (strcmp(kbuf, "on") == 0)
601 else if (strcmp(kbuf, "off") == 0)
604 set_dis_tap_fn(pbp_device_block, tap_param);
610 set_dis_disc_pfs(struct file *file, const char *buffer,
611 unsigned long count, void *data)
615 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
617 int tap_param = 0, length = 0;
619 if (copy_from_user(&kbuf, buffer, count))
623 length = strlen(kbuf);
624 if (kbuf[length - 1] == '\n')
625 kbuf[--length] = '\0';
627 if (strcmp(kbuf, "on") == 0)
629 else if (strcmp(kbuf, "off") == 0)
632 set_dis_disc_fn(pbp_device_block, tap_param);
638 get_dis_bypass_pfs(char *page, char **start, off_t off, int count,
639 int *eof, void *data)
641 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
643 int len = 0, ret = 0;
645 ret = get_dis_bypass_fn(pbp_device_block);
646 if (ret == BP_NOT_CAP)
647 len = sprintf(page, "fail\n");
649 len = sprintf(page, "off\n");
651 len = sprintf(page, "on\n");
658 get_dis_tap_pfs(char *page, char **start, off_t off, int count,
659 int *eof, void *data)
661 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
663 int len = 0, ret = 0;
665 ret = get_dis_tap_fn(pbp_device_block);
666 if (ret == BP_NOT_CAP)
667 len = sprintf(page, "fail\n");
669 len = sprintf(page, "off\n");
671 len = sprintf(page, "on\n");
678 get_dis_disc_pfs(char *page, char **start, off_t off, int count,
679 int *eof, void *data)
681 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
683 int len = 0, ret = 0;
685 ret = get_dis_disc_fn(pbp_device_block);
686 if (ret == BP_NOT_CAP)
687 len = sprintf(page, "fail\n");
689 len = sprintf(page, "off\n");
691 len = sprintf(page, "on\n");
698 set_bypass_pwup_pfs(struct file *file, const char *buffer,
699 unsigned long count, void *data)
703 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
705 int bypass_param = 0, length = 0;
707 if (copy_from_user(&kbuf, buffer, count))
711 length = strlen(kbuf);
712 if (kbuf[length - 1] == '\n')
713 kbuf[--length] = '\0';
715 if (strcmp(kbuf, "on") == 0)
717 else if (strcmp(kbuf, "off") == 0)
720 set_bypass_pwup_fn(pbp_device_block, bypass_param);
726 set_bypass_pwoff_pfs(struct file *file, const char *buffer,
727 unsigned long count, void *data)
731 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
733 int bypass_param = 0, length = 0;
735 if (copy_from_user(&kbuf, buffer, count))
739 length = strlen(kbuf);
740 if (kbuf[length - 1] == '\n')
741 kbuf[--length] = '\0';
743 if (strcmp(kbuf, "on") == 0)
745 else if (strcmp(kbuf, "off") == 0)
748 set_bypass_pwoff_fn(pbp_device_block, bypass_param);
754 set_tap_pwup_pfs(struct file *file, const char *buffer,
755 unsigned long count, void *data)
759 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
761 int tap_param = 0, length = 0;
763 if (copy_from_user(&kbuf, buffer, count))
767 length = strlen(kbuf);
768 if (kbuf[length - 1] == '\n')
769 kbuf[--length] = '\0';
771 if (strcmp(kbuf, "on") == 0)
773 else if (strcmp(kbuf, "off") == 0)
776 set_tap_pwup_fn(pbp_device_block, tap_param);
782 set_disc_pwup_pfs(struct file *file, const char *buffer,
783 unsigned long count, void *data)
787 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
789 int tap_param = 0, length = 0;
791 if (copy_from_user(&kbuf, buffer, count))
795 length = strlen(kbuf);
796 if (kbuf[length - 1] == '\n')
797 kbuf[--length] = '\0';
799 if (strcmp(kbuf, "on") == 0)
801 else if (strcmp(kbuf, "off") == 0)
804 set_disc_pwup_fn(pbp_device_block, tap_param);
810 get_bypass_pwup_pfs(char *page, char **start, off_t off, int count,
811 int *eof, void *data)
813 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
815 int len = 0, ret = 0;
817 ret = get_bypass_pwup_fn(pbp_device_block);
818 if (ret == BP_NOT_CAP)
819 len = sprintf(page, "fail\n");
821 len = sprintf(page, "off\n");
823 len = sprintf(page, "on\n");
830 get_bypass_pwoff_pfs(char *page, char **start, off_t off, int count,
831 int *eof, void *data)
833 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
835 int len = 0, ret = 0;
837 ret = get_bypass_pwoff_fn(pbp_device_block);
838 if (ret == BP_NOT_CAP)
839 len = sprintf(page, "fail\n");
841 len = sprintf(page, "off\n");
843 len = sprintf(page, "on\n");
850 get_tap_pwup_pfs(char *page, char **start, off_t off, int count,
851 int *eof, void *data)
853 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
855 int len = 0, ret = 0;
857 ret = get_tap_pwup_fn(pbp_device_block);
858 if (ret == BP_NOT_CAP)
859 len = sprintf(page, "fail\n");
861 len = sprintf(page, "off\n");
863 len = sprintf(page, "on\n");
870 get_disc_pwup_pfs(char *page, char **start, off_t off, int count,
871 int *eof, void *data)
873 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
875 int len = 0, ret = 0;
877 ret = get_disc_pwup_fn(pbp_device_block);
878 if (ret == BP_NOT_CAP)
879 len = sprintf(page, "fail\n");
881 len = sprintf(page, "off\n");
883 len = sprintf(page, "on\n");
890 set_std_nic_pfs(struct file *file, const char *buffer,
891 unsigned long count, void *data)
895 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
897 int bypass_param = 0, length = 0;
899 if (copy_from_user(&kbuf, buffer, count))
903 length = strlen(kbuf);
904 if (kbuf[length - 1] == '\n')
905 kbuf[--length] = '\0';
907 if (strcmp(kbuf, "on") == 0)
909 else if (strcmp(kbuf, "off") == 0)
912 set_std_nic_fn(pbp_device_block, bypass_param);
918 get_std_nic_pfs(char *page, char **start, off_t off, int count,
919 int *eof, void *data)
921 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
923 int len = 0, ret = 0;
925 ret = get_std_nic_fn(pbp_device_block);
926 if (ret == BP_NOT_CAP)
927 len = sprintf(page, "fail\n");
929 len = sprintf(page, "off\n");
931 len = sprintf(page, "on\n");
938 get_wd_exp_mode_pfs(char *page, char **start, off_t off, int count,
939 int *eof, void *data)
941 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
943 int len = 0, ret = 0;
945 ret = get_wd_exp_mode_fn(pbp_device_block);
947 len = sprintf(page, "tap\n");
949 len = sprintf(page, "bypass\n");
951 len = sprintf(page, "disc\n");
954 len = sprintf(page, "fail\n");
961 set_wd_exp_mode_pfs(struct file *file, const char *buffer,
962 unsigned long count, void *data)
966 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
968 int bypass_param = 0, length = 0;
970 if (count > (sizeof(kbuf) - 1))
973 if (copy_from_user(&kbuf, buffer, count))
977 length = strlen(kbuf);
978 if (kbuf[length - 1] == '\n')
979 kbuf[--length] = '\0';
981 if (strcmp(kbuf, "tap") == 0)
983 else if (strcmp(kbuf, "bypass") == 0)
985 else if (strcmp(kbuf, "disc") == 0)
988 set_wd_exp_mode_fn(pbp_device_block, bypass_param);
994 get_wd_autoreset_pfs(char *page, char **start, off_t off, int count,
995 int *eof, void *data)
997 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
999 int len = 0, ret = 0;
1001 ret = get_wd_autoreset_fn(pbp_device_block);
1003 len = sprintf(page, "%d\n", ret);
1005 len = sprintf(page, "fail\n");
1012 set_wd_autoreset_pfs(struct file *file, const char *buffer,
1013 unsigned long count, void *data)
1016 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1018 char *timeout_ptr = kbuf;
1020 if (copy_from_user(&kbuf, buffer, count))
1024 timeout = atoi(&timeout_ptr);
1026 set_wd_autoreset_fn(pbp_device_block, timeout);
1032 set_tpl_pfs(struct file *file, const char *buffer,
1033 unsigned long count, void *data)
1037 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1039 int tpl_param = 0, length = 0;
1041 if (count > (sizeof(kbuf) - 1))
1044 if (copy_from_user(&kbuf, buffer, count))
1048 length = strlen(kbuf);
1049 if (kbuf[length - 1] == '\n')
1050 kbuf[--length] = '\0';
1052 if (strcmp(kbuf, "on") == 0)
1054 else if (strcmp(kbuf, "off") == 0)
1057 set_tpl_fn(pbp_device_block, tpl_param);
1064 set_wait_at_pwup_pfs(struct file *file, const char *buffer,
1065 unsigned long count, void *data)
1069 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1071 int tpl_param = 0, length = 0;
1073 if (count > (sizeof(kbuf) - 1))
1076 if (copy_from_user(&kbuf, buffer, count))
1080 length = strlen(kbuf);
1081 if (kbuf[length - 1] == '\n')
1082 kbuf[--length] = '\0';
1084 if (strcmp(kbuf, "on") == 0)
1086 else if (strcmp(kbuf, "off") == 0)
1089 set_bp_wait_at_pwup_fn(pbp_device_block, tpl_param);
1095 set_hw_reset_pfs(struct file *file, const char *buffer,
1096 unsigned long count, void *data)
1100 bpctl_dev_t *pbp_device_block = (bpctl_dev_t *) data;
1102 int tpl_param = 0, length = 0;
1104 if (count > (sizeof(kbuf) - 1))
1107 if (copy_from_user(&kbuf, buffer, count))
1111 length = strlen(kbuf);
1112 if (kbuf[length - 1] == '\n')
1113 kbuf[--length] = '\0';
1115 if (strcmp(kbuf, "on") == 0)
1117 else if (strcmp(kbuf, "off") == 0)
1120 set_bp_hw_reset_fn(pbp_device_block, tpl_param);
1125 #endif /*PMC_FIX_FLAG */
1127 int bypass_proc_create_dev_sd(bpctl_dev_t *pbp_device_block)
1129 struct bypass_pfs_sd *current_pfs = &(pbp_device_block->bypass_pfs_set);
1130 static struct proc_dir_entry *procfs_dir;
1133 sprintf(current_pfs->dir_name, "bypass_%s", dev->name);
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);
1145 current_pfs->bypass_entry = procfs_dir;
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))
1152 if (pbp_device_block->bp_caps & SW_CTL_CAP) {
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))
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))
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))
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))
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))
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))
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))
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 */
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 */
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 */
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 */
1213 if (bypass_proc_create_entry_sd(&(current_pfs->bypass_change), BYPASS_CHANGE_ENTRY_SD, NULL, /* write */
1214 get_bypass_change_pfs, /* read */
1220 if (pbp_device_block->bp_caps & TAP_CAP) {
1222 if (bypass_proc_create_entry_sd(&(current_pfs->tap), TAP_ENTRY_SD, set_tap_pfs, /* write */
1223 get_tap_pfs, /* read */
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 */
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 */
1240 if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), TAP_CHANGE_ENTRY_SD, NULL, /* write */
1241 get_tap_change_pfs, /* read */
1246 if (pbp_device_block->bp_caps & DISC_CAP) {
1248 if (bypass_proc_create_entry_sd(&(current_pfs->tap), DISC_ENTRY_SD, set_disc_pfs, /* write */
1249 get_disc_pfs, /* read */
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 */
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 */
1268 if (bypass_proc_create_entry_sd(&(current_pfs->tap_change), DISC_CHANGE_ENTRY_SD, NULL, /* write */
1269 get_disc_change_pfs, /* read */
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))
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))
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))
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))
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))
1302 printk(KERN_DEBUG "Create proc entry failed\n");
1307 int bypass_proc_remove_dev_sd(bpctl_dev_t *pbp_device_block)
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 =
1315 for (pde = pde->subdir; pde;) {
1316 strcpy(name, pde->name);
1319 remove_proc_entry(name, current_pfs->bypass_entry);
1322 remove_proc_entry(current_pfs->dir_name, bp_procfs_dir);
1327 #endif /* BYPASS_SUPPORT */