projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'for-3.9-rc' of git://git.kernel.org/pub/scm/linux/kernel/git/rwlove/fcoe
[deliverable/linux.git] / drivers / staging / silicom / bp_proc.c
CommitLineData
7040e556
D		 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
19c1fb13 13#if defined(CONFIG_SMP) && !defined(__SMP__)
7040e556
D		 14#define __SMP__
15#endif
16
17#include <linux/proc_fs.h>
18#include <linux/netdevice.h>
19#include <asm/uaccess.h>
1713eaf7 20/* #include <linux/smp_lock.h> */
7040e556
D		 21#include "bp_mod.h"
22
23#define BP_PROC_DIR "bypass"
1713eaf7 24/* #define BYPASS_SUPPORT "bypass" */
7040e556 25
19c1fb13 26#ifdef BYPASS_SUPPORT
7040e556
D		 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"
41c66e06 72
7040e556
D		 73static struct proc_dir_entry *bp_procfs_dir;
74
75static 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);
c460c7d9 88 if (pde == (struct proc_dir_entry *)0)
ed5054b6 89 return pde;
7040e556 90 }
ed5054b6 91 return pde;
7040e556
D		 92}
93
7040e556
D		 94int
95bypass_proc_create_entry_sd(struct pfs_unit *pfs_unit_curr,
96 char *proc_name,
19c1fb13
CW		 97 write_proc_t *write_proc,
98 read_proc_t *read_proc,
7040e556
D		 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 |
f325129a 105 S_IROTH, parent_pfs);
c460c7d9 106 if (pfs_unit_curr->proc_entry == 0)
7040e556 107 return -1;
7040e556
D		 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
117int
118get_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
133int
134get_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
156int
157get_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
174int
175get_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
191int
192set_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
c460c7d9 204 if (copy_from_user(&kbuf, buffer, count))
7040e556 205 return -1;
7040e556
D		 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
222int
223set_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
c460c7d9 235 if (copy_from_user(&kbuf, buffer, count))
7040e556 236 return -1;
7040e556
D		 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
253int
254set_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
c460c7d9 266 if (copy_from_user(&kbuf, buffer, count))
7040e556 267 return -1;
7040e556
D		 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
284int
285get_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
304int
305get_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
324int
325get_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
344int
345get_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
364int
365get_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
384int
385get_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
404int
405set_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
c460c7d9 415 if (copy_from_user(&kbuf, buffer, count))
7040e556 416 return -1;
7040e556
D		 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
426int
427get_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
448int
449get_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
470int
471get_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
491int
492get_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
511int
512get_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
533int
534reset_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
553int
554set_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
c460c7d9 563 if (copy_from_user(&kbuf, buffer, count))
7040e556 564 return -1;
7040e556
D		 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
581int
582set_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
c460c7d9 591 if (copy_from_user(&kbuf, buffer, count))
7040e556 592 return -1;
7040e556
D		 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
609int
610set_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
c460c7d9 619 if (copy_from_user(&kbuf, buffer, count))
7040e556 620 return -1;
7040e556
D		 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
637int
638get_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
657int
658get_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
677int
678get_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
697int
698set_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
c460c7d9 707 if (copy_from_user(&kbuf, buffer, count))
7040e556 708 return -1;
7040e556
D		 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
725int
726set_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
c460c7d9 735 if (copy_from_user(&kbuf, buffer, count))
7040e556 736 return -1;
7040e556
D		 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
753int
754set_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
c460c7d9 763 if (copy_from_user(&kbuf, buffer, count))
7040e556 764 return -1;
7040e556
D		 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
781int
782set_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
c460c7d9 791 if (copy_from_user(&kbuf, buffer, count))
7040e556 792 return -1;
7040e556
D		 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
809int
810get_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
829int
830get_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
849int
850get_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
869int
870get_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
889int
890set_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
c460c7d9 899 if (copy_from_user(&kbuf, buffer, count))
7040e556 900 return -1;
7040e556
D		 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
917int
918get_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
937int
938get_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
960int
961set_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
c460c7d9 973 if (copy_from_user(&kbuf, buffer, count))
7040e556 974 return -1;
7040e556
D		 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
993int
994get_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
1011int
1012set_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
c460c7d9 1020 if (copy_from_user(&kbuf, buffer, count))
7040e556 1021 return -1;
7040e556
D		 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
1031int
1032set_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
c460c7d9 1044 if (copy_from_user(&kbuf, buffer, count))
7040e556 1045 return -1;
7040e556
D		 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
1063int
1064set_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
c460c7d9 1076 if (copy_from_user(&kbuf, buffer, count))
7040e556 1077 return -1;
7040e556
D		 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
1094int
1095set_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
c460c7d9 1107 if (copy_from_user(&kbuf, buffer, count))
7040e556 1108 return -1;
7040e556
D		 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
19c1fb13 1127int bypass_proc_create_dev_sd(bpctl_dev_t *pbp_device_block)
7040e556
D		 1128{
1129 struct bypass_pfs_sd *current_pfs = &(pbp_device_block->bypass_pfs_set);
6b8c8773 1130 static struct proc_dir_entry *procfs_dir;
7040e556
D		 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
19c1fb13 1307int bypass_proc_remove_dev_sd(bpctl_dev_t *pbp_device_block)
7040e556
D		 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 */
Linux kernel - Deliverables
This page took 0.133477 seconds and 5 git commands to generate.