1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/module.h>
21#include <linux/kernel.h>
22#include <linux/stddef.h>
23#include <linux/errno.h>
24#include <linux/string.h>
25#include <linux/slab.h>
26#include <linux/wanrouter.h>
27#include <linux/wanpipe.h>
28#include <linux/if_arp.h>
29
30#include <linux/in.h>
31#include <linux/inet.h>
32#include <linux/if.h>
33#include <asm/byteorder.h>
34#include <linux/sdlapci.h>
35#include <asm/io.h>
36
37#include <linux/sdla_chdlc.h>
38#include <linux/sdla_asy.h>
39
40#include <linux/if_wanpipe_common.h>
41#include <linux/if_wanpipe.h>
42
43
44#include <linux/inetdevice.h>
45#include <asm/uaccess.h>
46
47#include <net/syncppp.h>
48
49
50
51
52#ifdef _DEBUG_
53#define STATIC
54#else
55#define STATIC static
56#endif
57
58
59#define TMR_INT_ENABLED_UDP 0x01
60#define TMR_INT_ENABLED_UPDATE 0x02
61#define TMR_INT_ENABLED_CONFIG 0x04
62
63#define CHDLC_DFLT_DATA_LEN 1500
64#define CHDLC_HDR_LEN 1
65
66#define IFF_POINTTOPOINT 0x10
67
68#define CHDLC_API 0x01
69
70#define PORT(x) (x == 0 ? "PRIMARY" : "SECONDARY" )
71#define MAX_BH_BUFF 10
72
73#define CRC_LENGTH 2
74#define PPP_HEADER_LEN 4
75
76
77
78
79
80
81
82
83typedef struct chdlc_private_area
84{
85 void *if_ptr;
86 wanpipe_common_t common;
87 sdla_t *card;
88 int TracingEnabled;
89 unsigned long curr_trace_addr;
90 unsigned long start_trace_addr;
91 unsigned long end_trace_addr;
92 unsigned long base_addr_trace_buffer;
93 unsigned long end_addr_trace_buffer;
94 unsigned short number_trace_elements;
95 unsigned available_buffer_space;
96 unsigned long router_start_time;
97 unsigned char route_status;
98 unsigned char route_removed;
99 unsigned long tick_counter;
100 unsigned long router_up_time;
101 u32 IP_address;
102 u32 IP_netmask;
103 unsigned char mc;
104 unsigned short udp_pkt_lgth;
105 char udp_pkt_src;
106 char udp_pkt_data[MAX_LGTH_UDP_MGNT_PKT];
107 unsigned short timer_int_enabled;
108 char update_comms_stats;
109
110
111
112} chdlc_private_area_t;
113
114
115#define NO_ROUTE 0x00
116#define ADD_ROUTE 0x01
117#define ROUTE_ADDED 0x02
118#define REMOVE_ROUTE 0x03
119
120
121
122static int rCount = 0;
123
124
125
126
127extern void disable_irq(unsigned int);
128extern void enable_irq(unsigned int);
129
130
131
132static int update(struct wan_device* wandev);
133static int new_if(struct wan_device* wandev, struct net_device* dev,
134 wanif_conf_t* conf);
135static int del_if(struct wan_device* wandev, struct net_device* dev);
136
137
138static int if_init(struct net_device* dev);
139static int if_open(struct net_device* dev);
140static int if_close(struct net_device* dev);
141static int if_send(struct sk_buff* skb, struct net_device* dev);
142static struct net_device_stats* if_stats(struct net_device* dev);
143
144static void if_tx_timeout(struct net_device *dev);
145
146
147static int chdlc_configure (sdla_t* card, void* data);
148static int chdlc_comm_enable (sdla_t* card);
149static int chdlc_comm_disable (sdla_t* card);
150static int chdlc_read_version (sdla_t* card, char* str);
151static int chdlc_set_intr_mode (sdla_t* card, unsigned mode);
152static int chdlc_send (sdla_t* card, void* data, unsigned len);
153static int chdlc_read_comm_err_stats (sdla_t* card);
154static int chdlc_read_op_stats (sdla_t* card);
155static int config_chdlc (sdla_t *card);
156
157
158
159static int set_chdlc_config (sdla_t* card);
160static void init_chdlc_tx_rx_buff(sdla_t* card, struct net_device *dev);
161static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb);
162static int process_chdlc_exception(sdla_t *card);
163static int process_global_exception(sdla_t *card);
164static int update_comms_stats(sdla_t* card,
165 chdlc_private_area_t* chdlc_priv_area);
166static void port_set_state (sdla_t *card, int);
167
168
169static void wsppp_isr (sdla_t* card);
170static void rx_intr (sdla_t* card);
171static void timer_intr(sdla_t *);
172
173
174static int reply_udp( unsigned char *data, unsigned int mbox_len );
175static int intr_test( sdla_t* card);
176static int udp_pkt_type( struct sk_buff *skb , sdla_t* card);
177static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
178 struct sk_buff *skb, struct net_device* dev,
179 chdlc_private_area_t* chdlc_priv_area);
180static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
181 chdlc_private_area_t* chdlc_priv_area);
182static unsigned short calc_checksum (char *, int);
183static void s508_lock (sdla_t *card, unsigned long *smp_flags);
184static void s508_unlock (sdla_t *card, unsigned long *smp_flags);
185static void send_ppp_term_request(struct net_device *dev);
186
187
188static int Intr_test_counter;
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203int wsppp_init (sdla_t* card, wandev_conf_t* conf)
204{
205 unsigned char port_num;
206 int err;
207 unsigned long max_permitted_baud = 0;
208 SHARED_MEMORY_INFO_STRUCT *flags;
209
210 union
211 {
212 char str[80];
213 } u;
214 volatile CHDLC_MAILBOX_STRUCT* mb;
215 CHDLC_MAILBOX_STRUCT* mb1;
216 unsigned long timeout;
217
218
219 if (conf->config_id != WANCONFIG_MPPP) {
220 printk(KERN_INFO "%s: invalid configuration ID %u!\n",
221 card->devname, conf->config_id);
222 return -EINVAL;
223 }
224
225
226 if ((conf->comm_port == WANOPT_PRI) || (conf->comm_port == WANOPT_SEC)){
227 if (card->next){
228
229 if (conf->comm_port != card->next->u.c.comm_port){
230 card->u.c.comm_port = conf->comm_port;
231 }else{
232 printk(KERN_ERR "%s: ERROR - %s port used!\n",
233 card->wandev.name, PORT(conf->comm_port));
234 return -EINVAL;
235 }
236 }else{
237 card->u.c.comm_port = conf->comm_port;
238 }
239 }else{
240 printk(KERN_ERR "%s: ERROR - Invalid Port Selected!\n",
241 card->wandev.name);
242 return -EINVAL;
243 }
244
245
246
247 if(card->hw.type != SDLA_S514){
248
249 if (card->u.c.comm_port == WANOPT_PRI){
250 card->mbox = (void *) card->hw.dpmbase;
251 }else{
252 card->mbox = (void *) card->hw.dpmbase +
253 SEC_BASE_ADDR_MB_STRUCT - PRI_BASE_ADDR_MB_STRUCT;
254 }
255 }else{
256
257
258 if (card->u.c.comm_port == WANOPT_PRI){
259 card->mbox = (void *) card->hw.dpmbase + PRI_BASE_ADDR_MB_STRUCT;
260 }else{
261 card->mbox = (void *) card->hw.dpmbase + SEC_BASE_ADDR_MB_STRUCT;
262 }
263 }
264
265 mb = mb1 = card->mbox;
266
267 if (!card->configured){
268
269
270
271
272
273 timeout = jiffies;
274 while (mb->return_code != 'I')
275 if ((jiffies - timeout) > 1*HZ) break;
276
277 if (mb->return_code != 'I') {
278 printk(KERN_INFO
279 "%s: Initialization not completed by adapter\n",
280 card->devname);
281 printk(KERN_INFO "Please contact Sangoma representative.\n");
282 return -EIO;
283 }
284 }
285
286
287
288
289
290
291
292 if (chdlc_read_version(card, u.str))
293 return -EIO;
294
295 printk(KERN_INFO "%s: Running Raw CHDLC firmware v%s\n"
296 "%s: for Multi-Port PPP protocol.\n",
297 card->devname,u.str,card->devname);
298
299 card->isr = &wsppp_isr;
300 card->poll = NULL;
301 card->exec = NULL;
302 card->wandev.update = &update;
303 card->wandev.new_if = &new_if;
304 card->wandev.del_if = &del_if;
305 card->wandev.udp_port = conf->udp_port;
306
307 card->wandev.new_if_cnt = 0;
308
309
310 card->u.c.update_call_count = 0;
311
312 card->wandev.ttl = conf->ttl;
313 card->wandev.interface = conf->interface;
314
315 if ((card->u.c.comm_port == WANOPT_SEC && conf->interface == WANOPT_V35)&&
316 card->hw.type != SDLA_S514){
317 printk(KERN_INFO "%s: ERROR - V35 Interface not supported on S508 %s port \n",
318 card->devname, PORT(card->u.c.comm_port));
319 return -EIO;
320 }
321
322
323 card->wandev.clocking = conf->clocking;
324
325 port_num = card->u.c.comm_port;
326
327
328
329 if(card->wandev.clocking) {
330 if((port_num == WANOPT_PRI) || card->u.c.receive_only) {
331
332 max_permitted_baud =
333 (card->hw.type == SDLA_S514) ?
334 PRI_MAX_BAUD_RATE_S514 :
335 PRI_MAX_BAUD_RATE_S508;
336 }
337 else if(port_num == WANOPT_SEC) {
338
339 max_permitted_baud =
340 (card->hw.type == SDLA_S514) ?
341 SEC_MAX_BAUD_RATE_S514 :
342 SEC_MAX_BAUD_RATE_S508;
343 }
344
345 if(conf->bps > max_permitted_baud) {
346 conf->bps = max_permitted_baud;
347 printk(KERN_INFO "%s: Baud too high!\n",
348 card->wandev.name);
349 printk(KERN_INFO "%s: Baud rate set to %lu bps\n",
350 card->wandev.name, max_permitted_baud);
351 }
352
353 card->wandev.bps = conf->bps;
354 }else{
355 card->wandev.bps = 0;
356 }
357
358
359 if((port_num == WANOPT_PRI) || card->u.c.receive_only) {
360
361
362 card->wandev.mtu =
363 (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
364 min_t(unsigned int, conf->mtu, PRI_MAX_NO_DATA_BYTES_IN_FRAME) :
365 CHDLC_DFLT_DATA_LEN;
366 } else if(port_num == WANOPT_SEC) {
367
368 card->wandev.mtu =
369 (conf->mtu >= MIN_LGTH_CHDLC_DATA_CFG) ?
370 min_t(unsigned int, conf->mtu, SEC_MAX_NO_DATA_BYTES_IN_FRAME) :
371 CHDLC_DFLT_DATA_LEN;
372 }
373
374
375 card->wandev.mtu += PPP_HEADER_LEN;
376
377
378
379
380
381
382 mb1->buffer_length = 0;
383 mb1->command = READ_CHDLC_CONFIGURATION;
384 err = sdla_exec(mb1) ? mb1->return_code : CMD_TIMEOUT;
385 if(err != COMMAND_OK) {
386 clear_bit(1, (void*)&card->wandev.critical);
387
388 if(card->hw.type != SDLA_S514)
389 enable_irq(card->hw.irq);
390
391 chdlc_error(card, err, mb1);
392 return -EIO;
393 }
394
395 if(card->hw.type == SDLA_S514){
396 card->u.c.flags = (void *)(card->hw.dpmbase +
397 (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
398 ptr_shared_mem_info_struct));
399 }else{
400 card->u.c.flags = (void *)(card->hw.dpmbase +
401 (((CHDLC_CONFIGURATION_STRUCT *)mb1->data)->
402 ptr_shared_mem_info_struct % SDLA_WINDOWSIZE));
403 }
404
405 flags = card->u.c.flags;
406
407
408 card->wandev.state = WAN_DUALPORT;
409 card->u.c.state = WAN_DISCONNECTED;
410
411
412 if (!card->wandev.piggyback){
413 err = intr_test(card);
414
415 if(err || (Intr_test_counter < MAX_INTR_TEST_COUNTER)) {
416 printk(KERN_ERR "%s: Interrupt test failed (%i)\n",
417 card->devname, Intr_test_counter);
418 printk(KERN_ERR "%s: Please choose another interrupt\n",
419 card->devname);
420 return -EIO;
421 }
422
423 printk(KERN_INFO "%s: Interrupt test passed (%i)\n",
424 card->devname, Intr_test_counter);
425 }
426
427
428 if (chdlc_set_intr_mode(card, APP_INT_ON_TIMER)){
429 printk (KERN_INFO "%s: Failed to set interrupt triggers!\n",
430 card->devname);
431 return -EIO;
432 }
433
434
435 flags->interrupt_info_struct.interrupt_permission &=
436 ~APP_INT_ON_TIMER;
437
438 printk(KERN_INFO "\n");
439
440 return 0;
441}
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458static int update(struct wan_device* wandev)
459{
460 sdla_t* card = wandev->private;
461 struct net_device* dev;
462 volatile chdlc_private_area_t* chdlc_priv_area;
463 SHARED_MEMORY_INFO_STRUCT *flags;
464 unsigned long timeout;
465
466
467 if((wandev == NULL) || (wandev->private == NULL))
468 return -EFAULT;
469
470 if(wandev->state == WAN_UNCONFIGURED)
471 return -ENODEV;
472
473
474 if(!card->u.c.flags)
475 return -ENODEV;
476
477 if((dev=card->wandev.dev) == NULL)
478 return -ENODEV;
479
480 if((chdlc_priv_area=dev->priv) == NULL)
481 return -ENODEV;
482
483 flags = card->u.c.flags;
484
485 if(chdlc_priv_area->update_comms_stats){
486 return -EAGAIN;
487 }
488
489
490
491 chdlc_priv_area->update_comms_stats = 2;
492 flags->interrupt_info_struct.interrupt_permission |= APP_INT_ON_TIMER;
493 chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UPDATE;
494
495
496 timeout = jiffies;
497 for(;;) {
498 if(chdlc_priv_area->update_comms_stats == 0)
499 break;
500 if ((jiffies - timeout) > (1 * HZ)){
501 chdlc_priv_area->update_comms_stats = 0;
502 chdlc_priv_area->timer_int_enabled &=
503 ~TMR_INT_ENABLED_UPDATE;
504 return -EAGAIN;
505 }
506 }
507
508 return 0;
509}
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524static int new_if(struct wan_device* wandev, struct net_device* pdev,
525 wanif_conf_t* conf)
526{
527
528 struct ppp_device *pppdev = (struct ppp_device *)pdev;
529 struct net_device *dev = NULL;
530 struct sppp *sp;
531 sdla_t* card = wandev->private;
532 chdlc_private_area_t* chdlc_priv_area;
533
534 if ((conf->name[0] == '\0') || (strlen(conf->name) > WAN_IFNAME_SZ)) {
535 printk(KERN_INFO "%s: invalid interface name!\n",
536 card->devname);
537 return -EINVAL;
538 }
539
540
541 chdlc_priv_area = kmalloc(sizeof(chdlc_private_area_t), GFP_KERNEL);
542
543 if(chdlc_priv_area == NULL)
544 return -ENOMEM;
545
546 memset(chdlc_priv_area, 0, sizeof(chdlc_private_area_t));
547
548 chdlc_priv_area->card = card;
549
550
551 strcpy(card->u.c.if_name, conf->name);
552
553 if(card->wandev.new_if_cnt > 0) {
554 kfree(chdlc_priv_area);
555 return -EEXIST;
556 }
557
558 card->wandev.new_if_cnt++;
559
560 chdlc_priv_area->TracingEnabled = 0;
561
562
563 chdlc_priv_area->route_status = NO_ROUTE;
564 chdlc_priv_area->route_removed = 0;
565
566 printk(KERN_INFO "%s: Firmware running in HDLC STREAMING Mode\n",
567 wandev->name);
568
569
570 if( strcmp(conf->usedby, "WANPIPE") == 0) {
571 printk(KERN_INFO "%s: Driver running in WANPIPE mode!\n",
572 wandev->name);
573 card->u.c.usedby = WANPIPE;
574 } else {
575 printk(KERN_INFO
576 "%s: API Mode is not supported for SyncPPP!\n",
577 wandev->name);
578 kfree(chdlc_priv_area);
579 return -EINVAL;
580 }
581
582
583 chdlc_priv_area->mc = conf->mc;
584
585
586 chdlc_priv_area->if_ptr = pppdev;
587
588
589
590 strcpy(dev->name,card->u.c.if_name);
591
592
593
594
595
596
597
598 sppp_attach(pppdev);
599 dev = pppdev->dev;
600 sp = &pppdev->sppp;
601
602
603
604
605 sp->pp_flags &= ~PP_CISCO;
606
607 dev->init = &if_init;
608 dev->priv = chdlc_priv_area;
609
610 return 0;
611}
612
613
614
615
616
617
618
619static int del_if(struct wan_device* wandev, struct net_device* dev)
620{
621 chdlc_private_area_t *chdlc_priv_area = dev->priv;
622 sdla_t *card = chdlc_priv_area->card;
623 unsigned long smp_lock;
624
625
626 printk(KERN_INFO "%s: Detaching SyncPPP Module from %s\n",
627 wandev->name,dev->name);
628
629 lock_adapter_irq(&wandev->lock,&smp_lock);
630
631 sppp_detach(dev);
632 chdlc_priv_area->if_ptr=NULL;
633
634 chdlc_set_intr_mode(card, 0);
635 if (card->u.c.comm_enabled)
636 chdlc_comm_disable(card);
637 unlock_adapter_irq(&wandev->lock,&smp_lock);
638
639 port_set_state(card, WAN_DISCONNECTED);
640
641 return 0;
642}
643
644
645
646
647
648
649
650
651
652
653
654static int if_init(struct net_device* dev)
655{
656 chdlc_private_area_t* chdlc_priv_area = dev->priv;
657 sdla_t* card = chdlc_priv_area->card;
658 struct wan_device* wandev = &card->wandev;
659
660
661
662
663
664
665
666
667 dev->open = &if_open;
668 dev->stop = &if_close;
669 dev->hard_start_xmit = &if_send;
670 dev->get_stats = &if_stats;
671 dev->tx_timeout = &if_tx_timeout;
672 dev->watchdog_timeo = TX_TIMEOUT;
673
674
675
676 dev->irq = wandev->irq;
677 dev->dma = wandev->dma;
678 dev->base_addr = wandev->ioport;
679 dev->mem_start = wandev->maddr;
680 dev->mem_end = wandev->maddr + wandev->msize - 1;
681
682
683
684
685
686
687
688 dev->tx_queue_len = 100;
689
690 return 0;
691}
692
693
694
695
696
697static void if_tx_timeout(struct net_device *dev)
698{
699 chdlc_private_area_t* chan = dev->priv;
700 sdla_t *card = chan->card;
701
702
703
704
705
706
707
708 ++card->wandev.stats.collisions;
709
710 printk (KERN_INFO "%s: Transmit timed out on %s\n", card->devname,dev->name);
711 netif_wake_queue (dev);
712}
713
714
715
716
717
718
719
720
721
722static int if_open(struct net_device* dev)
723{
724 chdlc_private_area_t* chdlc_priv_area = dev->priv;
725 sdla_t* card = chdlc_priv_area->card;
726 struct timeval tv;
727 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
728
729
730 if (netif_running(dev))
731 return -EBUSY;
732
733
734 if (sppp_open(dev)){
735 return -EIO;
736 }
737
738 do_gettimeofday(&tv);
739 chdlc_priv_area->router_start_time = tv.tv_sec;
740
741 netif_start_queue(dev);
742
743 wanpipe_open(card);
744
745 chdlc_priv_area->timer_int_enabled |= TMR_INT_ENABLED_CONFIG;
746 flags->interrupt_info_struct.interrupt_permission |= APP_INT_ON_TIMER;
747 return 0;
748}
749
750
751
752
753
754
755static int if_close(struct net_device* dev)
756{
757 chdlc_private_area_t* chdlc_priv_area = dev->priv;
758 sdla_t* card = chdlc_priv_area->card;
759
760
761 sppp_close(dev);
762 netif_stop_queue(dev);
763
764 wanpipe_close(card);
765
766 return 0;
767}
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786static int if_send(struct sk_buff* skb, struct net_device* dev)
787{
788 chdlc_private_area_t *chdlc_priv_area = dev->priv;
789 sdla_t *card = chdlc_priv_area->card;
790 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
791 INTERRUPT_INFORMATION_STRUCT *chdlc_int = &flags->interrupt_info_struct;
792 int udp_type = 0;
793 unsigned long smp_flags;
794 int err=0;
795
796 netif_stop_queue(dev);
797
798
799 if (skb == NULL){
800
801
802
803 printk(KERN_INFO "%s: Received NULL skb buffer! interface %s got kicked!\n",
804 card->devname, dev->name);
805
806 netif_wake_queue(dev);
807 return 0;
808 }
809
810 if (ntohs(skb->protocol) != htons(PVC_PROT)){
811
812
813 udp_type = udp_pkt_type(skb, card);
814 if (udp_type == UDP_CPIPE_TYPE){
815 if(store_udp_mgmt_pkt(UDP_PKT_FRM_STACK, card, skb, dev,
816 chdlc_priv_area)){
817 chdlc_int->interrupt_permission |=
818 APP_INT_ON_TIMER;
819 }
820 netif_start_queue(dev);
821 return 0;
822 }
823 }
824
825
826 if(card->hw.type != SDLA_S514){
827 s508_lock(card,&smp_flags);
828 }
829
830 if (test_and_set_bit(SEND_CRIT, (void*)&card->wandev.critical)){
831
832 printk(KERN_INFO "%s: Critical in if_send: %lx\n",
833 card->wandev.name,card->wandev.critical);
834 ++card->wandev.stats.tx_dropped;
835 netif_start_queue(dev);
836 goto if_send_crit_exit;
837 }
838
839 if (card->wandev.state != WAN_CONNECTED){
840 ++card->wandev.stats.tx_dropped;
841 netif_start_queue(dev);
842 goto if_send_crit_exit;
843 }
844
845 if (chdlc_send(card, skb->data, skb->len)){
846 netif_stop_queue(dev);
847
848 }else{
849 ++card->wandev.stats.tx_packets;
850 card->wandev.stats.tx_bytes += skb->len;
851 dev->trans_start = jiffies;
852 netif_start_queue(dev);
853 }
854
855if_send_crit_exit:
856 if (!(err=netif_queue_stopped(dev))){
857 dev_kfree_skb_any(skb);
858 }else{
859 chdlc_priv_area->tick_counter = jiffies;
860 chdlc_int->interrupt_permission |= APP_INT_ON_TX_FRAME;
861 }
862
863 clear_bit(SEND_CRIT, (void*)&card->wandev.critical);
864 if(card->hw.type != SDLA_S514){
865 s508_unlock(card,&smp_flags);
866 }
867
868 return err;
869}
870
871
872
873
874
875
876static int reply_udp( unsigned char *data, unsigned int mbox_len )
877{
878
879 unsigned short len, udp_length, temp, ip_length;
880 unsigned long ip_temp;
881 int even_bound = 0;
882 chdlc_udp_pkt_t *c_udp_pkt = (chdlc_udp_pkt_t *)data;
883
884
885 len = sizeof(ip_pkt_t)+
886 sizeof(udp_pkt_t)+
887 sizeof(wp_mgmt_t)+
888 sizeof(cblock_t)+
889 sizeof(trace_info_t)+
890 mbox_len;
891
892
893 c_udp_pkt->wp_mgmt.request_reply = UDPMGMT_REPLY;
894
895
896 udp_length = sizeof(udp_pkt_t)+
897 sizeof(wp_mgmt_t)+
898 sizeof(cblock_t)+
899 sizeof(trace_info_t)+
900 mbox_len;
901
902
903 if ( udp_length & 0x0001 ) {
904 udp_length += 1;
905 len += 1;
906 even_bound = 1;
907 }
908
909 temp = (udp_length<<8)|(udp_length>>8);
910 c_udp_pkt->udp_pkt.udp_length = temp;
911
912
913 temp = c_udp_pkt->udp_pkt.udp_src_port;
914 c_udp_pkt->udp_pkt.udp_src_port =
915 c_udp_pkt->udp_pkt.udp_dst_port;
916 c_udp_pkt->udp_pkt.udp_dst_port = temp;
917
918
919 temp = 0x1100;
920 *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound)) = temp;
921 temp = (udp_length<<8)|(udp_length>>8);
922 *((unsigned short *)(c_udp_pkt->data+mbox_len+even_bound+2)) = temp;
923
924
925
926 c_udp_pkt->udp_pkt.udp_checksum = 0;
927 c_udp_pkt->udp_pkt.udp_checksum = calc_checksum(&data[UDP_OFFSET],udp_length+UDP_OFFSET);
928
929
930 ip_length = len;
931 temp = (ip_length<<8)|(ip_length>>8);
932 c_udp_pkt->ip_pkt.total_length = temp;
933
934
935 ip_temp = c_udp_pkt->ip_pkt.ip_src_address;
936 c_udp_pkt->ip_pkt.ip_src_address = c_udp_pkt->ip_pkt.ip_dst_address;
937 c_udp_pkt->ip_pkt.ip_dst_address = ip_temp;
938
939
940 c_udp_pkt->ip_pkt.hdr_checksum = 0;
941 c_udp_pkt->ip_pkt.hdr_checksum = calc_checksum(data,sizeof(ip_pkt_t));
942
943 return len;
944
945}
946
947unsigned short calc_checksum (char *data, int len)
948{
949 unsigned short temp;
950 unsigned long sum=0;
951 int i;
952
953 for( i = 0; i <len; i+=2 ) {
954 memcpy(&temp,&data[i],2);
955 sum += (unsigned long)temp;
956 }
957
958 while (sum >> 16 ) {
959 sum = (sum & 0xffffUL) + (sum >> 16);
960 }
961
962 temp = (unsigned short)sum;
963 temp = ~temp;
964
965 if( temp == 0 )
966 temp = 0xffff;
967
968 return temp;
969}
970
971
972
973
974
975
976static struct net_device_stats* if_stats(struct net_device* dev)
977{
978 sdla_t *my_card;
979 chdlc_private_area_t* chdlc_priv_area;
980
981
982
983
984
985 if ((chdlc_priv_area=dev->priv) == NULL)
986 return NULL;
987
988 my_card = chdlc_priv_area->card;
989 return &my_card->wandev.stats;
990}
991
992
993
994
995
996
997
998
999static int chdlc_read_version (sdla_t* card, char* str)
1000{
1001 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1002 int len;
1003 char err;
1004 mb->buffer_length = 0;
1005 mb->command = READ_CHDLC_CODE_VERSION;
1006 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1007
1008 if(err != COMMAND_OK) {
1009 chdlc_error(card,err,mb);
1010 }
1011 else if (str) {
1012 len = mb->buffer_length;
1013 memcpy(str, mb->data, len);
1014 str[len] = '\0';
1015 }
1016 return (err);
1017}
1018
1019
1020
1021
1022static int chdlc_configure (sdla_t* card, void* data)
1023{
1024 int err;
1025 CHDLC_MAILBOX_STRUCT *mailbox = card->mbox;
1026 int data_length = sizeof(CHDLC_CONFIGURATION_STRUCT);
1027
1028 mailbox->buffer_length = data_length;
1029 memcpy(mailbox->data, data, data_length);
1030 mailbox->command = SET_CHDLC_CONFIGURATION;
1031 err = sdla_exec(mailbox) ? mailbox->return_code : CMD_TIMEOUT;
1032
1033 if (err != COMMAND_OK) chdlc_error (card, err, mailbox);
1034
1035 return err;
1036}
1037
1038
1039
1040
1041
1042
1043static int chdlc_set_intr_mode (sdla_t* card, unsigned mode)
1044{
1045 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1046 CHDLC_INT_TRIGGERS_STRUCT* int_data =
1047 (CHDLC_INT_TRIGGERS_STRUCT *)mb->data;
1048 int err;
1049
1050 int_data->CHDLC_interrupt_triggers = mode;
1051 int_data->IRQ = card->hw.irq;
1052 int_data->interrupt_timer = 1;
1053
1054 mb->buffer_length = sizeof(CHDLC_INT_TRIGGERS_STRUCT);
1055 mb->command = SET_CHDLC_INTERRUPT_TRIGGERS;
1056 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1057 if (err != COMMAND_OK)
1058 chdlc_error (card, err, mb);
1059 return err;
1060}
1061
1062
1063
1064
1065
1066
1067static int chdlc_comm_enable (sdla_t* card)
1068{
1069 int err;
1070 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1071
1072 mb->buffer_length = 0;
1073 mb->command = ENABLE_CHDLC_COMMUNICATIONS;
1074 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1075 if (err != COMMAND_OK)
1076 chdlc_error(card, err, mb);
1077 else
1078 card->u.c.comm_enabled=1;
1079
1080 return err;
1081}
1082
1083
1084
1085
1086static int chdlc_comm_disable (sdla_t* card)
1087{
1088 int err;
1089 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1090
1091 mb->buffer_length = 0;
1092 mb->command = DISABLE_CHDLC_COMMUNICATIONS;
1093 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1094 if (err != COMMAND_OK)
1095 chdlc_error(card,err,mb);
1096
1097 return err;
1098}
1099
1100
1101
1102
1103static int chdlc_read_comm_err_stats (sdla_t* card)
1104{
1105 int err;
1106 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1107
1108 mb->buffer_length = 0;
1109 mb->command = READ_COMMS_ERROR_STATS;
1110 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1111 if (err != COMMAND_OK)
1112 chdlc_error(card,err,mb);
1113 return err;
1114}
1115
1116
1117
1118
1119
1120static int chdlc_read_op_stats (sdla_t* card)
1121{
1122 int err;
1123 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1124
1125 mb->buffer_length = 0;
1126 mb->command = READ_CHDLC_OPERATIONAL_STATS;
1127 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1128 if (err != COMMAND_OK)
1129 chdlc_error(card,err,mb);
1130 return err;
1131}
1132
1133
1134
1135
1136
1137static int update_comms_stats(sdla_t* card,
1138 chdlc_private_area_t* chdlc_priv_area)
1139{
1140 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1141 COMMS_ERROR_STATS_STRUCT* err_stats;
1142 CHDLC_OPERATIONAL_STATS_STRUCT *op_stats;
1143
1144
1145 if(chdlc_priv_area->update_comms_stats == 2) {
1146 if(chdlc_read_comm_err_stats(card))
1147 return 1;
1148 err_stats = (COMMS_ERROR_STATS_STRUCT *)mb->data;
1149 card->wandev.stats.rx_over_errors =
1150 err_stats->Rx_overrun_err_count;
1151 card->wandev.stats.rx_crc_errors =
1152 err_stats->CRC_err_count;
1153 card->wandev.stats.rx_frame_errors =
1154 err_stats->Rx_abort_count;
1155 card->wandev.stats.rx_fifo_errors =
1156 err_stats->Rx_dis_pri_bfrs_full_count;
1157 card->wandev.stats.rx_missed_errors =
1158 card->wandev.stats.rx_fifo_errors;
1159 card->wandev.stats.tx_aborted_errors =
1160 err_stats->sec_Tx_abort_count;
1161 }
1162
1163
1164 else {
1165 if(chdlc_read_op_stats(card))
1166 return 1;
1167 op_stats = (CHDLC_OPERATIONAL_STATS_STRUCT *)mb->data;
1168 card->wandev.stats.rx_length_errors =
1169 (op_stats->Rx_Data_discard_short_count +
1170 op_stats->Rx_Data_discard_long_count);
1171 }
1172
1173 return 0;
1174}
1175
1176
1177
1178
1179
1180
1181static int chdlc_send (sdla_t* card, void* data, unsigned len)
1182{
1183 CHDLC_DATA_TX_STATUS_EL_STRUCT *txbuf = card->u.c.txbuf;
1184
1185 if (txbuf->opp_flag)
1186 return 1;
1187
1188 sdla_poke(&card->hw, txbuf->ptr_data_bfr, data, len);
1189
1190 txbuf->frame_length = len;
1191 txbuf->opp_flag = 1;
1192
1193
1194 card->u.c.txbuf = ++txbuf;
1195
1196 if ((void*)txbuf > card->u.c.txbuf_last)
1197 card->u.c.txbuf = card->u.c.txbuf_base;
1198
1199 return 0;
1200}
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211static int chdlc_error (sdla_t *card, int err, CHDLC_MAILBOX_STRUCT *mb)
1212{
1213 unsigned cmd = mb->command;
1214
1215 switch (err) {
1216
1217 case CMD_TIMEOUT:
1218 printk(KERN_ERR "%s: command 0x%02X timed out!\n",
1219 card->devname, cmd);
1220 break;
1221
1222 case S514_BOTH_PORTS_SAME_CLK_MODE:
1223 if(cmd == SET_CHDLC_CONFIGURATION) {
1224 printk(KERN_INFO
1225 "%s: Configure both ports for the same clock source\n",
1226 card->devname);
1227 break;
1228 }
1229
1230 default:
1231 printk(KERN_INFO "%s: command 0x%02X returned 0x%02X!\n",
1232 card->devname, cmd, err);
1233 }
1234
1235 return 0;
1236}
1237
1238
1239
1240
1241
1242
1243STATIC void wsppp_isr (sdla_t* card)
1244{
1245 struct net_device* dev;
1246 SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1247 int i;
1248 sdla_t *my_card;
1249
1250
1251
1252
1253
1254
1255
1256 flags = card->u.c.flags;
1257 if (!flags->interrupt_info_struct.interrupt_type){
1258
1259 if((my_card = card->next)){
1260 flags = my_card->u.c.flags;
1261 if (flags->interrupt_info_struct.interrupt_type){
1262 card = my_card;
1263 card->isr(card);
1264 return;
1265 }
1266 }
1267 }
1268
1269 dev = card->wandev.dev;
1270 card->in_isr = 1;
1271 flags = card->u.c.flags;
1272
1273
1274
1275 if ((!dev || !dev->priv) && flags->interrupt_info_struct.interrupt_type !=
1276 COMMAND_COMPLETE_APP_INT_PEND){
1277 goto isr_done;
1278 }
1279
1280
1281
1282
1283
1284
1285 if(test_bit(PERI_CRIT, (void*)&card->wandev.critical)) {
1286 flags->interrupt_info_struct.
1287 interrupt_type = 0;
1288 goto isr_done;
1289 }
1290
1291
1292
1293
1294
1295 if(card->hw.type != SDLA_S514) {
1296 if(test_bit(0, (void*)&card->wandev.critical)) {
1297 printk(KERN_INFO "%s: Critical while in ISR: %lx\n",
1298 card->devname, card->wandev.critical);
1299 goto isr_done;
1300 }
1301 }
1302
1303 switch(flags->interrupt_info_struct.interrupt_type) {
1304
1305 case RX_APP_INT_PEND:
1306 rx_intr(card);
1307 break;
1308
1309 case TX_APP_INT_PEND:
1310 flags->interrupt_info_struct.interrupt_permission &=
1311 ~APP_INT_ON_TX_FRAME;
1312
1313 netif_wake_queue(dev);
1314 break;
1315
1316 case COMMAND_COMPLETE_APP_INT_PEND:
1317 ++ Intr_test_counter;
1318 break;
1319
1320 case CHDLC_EXCEP_COND_APP_INT_PEND:
1321 process_chdlc_exception(card);
1322 break;
1323
1324 case GLOBAL_EXCEP_COND_APP_INT_PEND:
1325 process_global_exception(card);
1326 break;
1327
1328 case TIMER_APP_INT_PEND:
1329 timer_intr(card);
1330 break;
1331
1332 default:
1333 printk(KERN_INFO "%s: spurious interrupt 0x%02X!\n",
1334 card->devname,
1335 flags->interrupt_info_struct.interrupt_type);
1336 printk(KERN_INFO "Code name: ");
1337 for(i = 0; i < 4; i ++)
1338 printk(KERN_INFO "%c",
1339 flags->global_info_struct.codename[i]);
1340 printk(KERN_INFO "\nCode version: ");
1341 for(i = 0; i < 4; i ++)
1342 printk(KERN_INFO "%c",
1343 flags->global_info_struct.codeversion[i]);
1344 printk(KERN_INFO "\n");
1345 break;
1346 }
1347
1348isr_done:
1349 card->in_isr = 0;
1350 flags->interrupt_info_struct.interrupt_type = 0;
1351}
1352
1353
1354
1355
1356static void rx_intr (sdla_t* card)
1357{
1358 struct net_device *dev;
1359 chdlc_private_area_t *chdlc_priv_area;
1360 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
1361 CHDLC_DATA_RX_STATUS_EL_STRUCT *rxbuf = card->u.c.rxmb;
1362 struct sk_buff *skb;
1363 unsigned len;
1364 unsigned addr = rxbuf->ptr_data_bfr;
1365 void *buf;
1366 int i,udp_type;
1367
1368 if (rxbuf->opp_flag != 0x01) {
1369 printk(KERN_INFO
1370 "%s: corrupted Rx buffer @ 0x%X, flag = 0x%02X!\n",
1371 card->devname, (unsigned)rxbuf, rxbuf->opp_flag);
1372 printk(KERN_INFO "Code name: ");
1373 for(i = 0; i < 4; i ++)
1374 printk(KERN_INFO "%c",
1375 flags->global_info_struct.codename[i]);
1376 printk(KERN_INFO "\nCode version: ");
1377 for(i = 0; i < 4; i ++)
1378 printk(KERN_INFO "%c",
1379 flags->global_info_struct.codeversion[i]);
1380 printk(KERN_INFO "\n");
1381
1382
1383
1384
1385
1386
1387
1388
1389 printk(KERN_INFO "%s: Critical router failure ...!!!\n", card->devname);
1390 printk(KERN_INFO "Please contact Sangoma Technologies !\n");
1391 chdlc_set_intr_mode(card,0);
1392 return;
1393 }
1394
1395 dev = card->wandev.dev;
1396
1397 if (!dev){
1398 goto rx_exit;
1399 }
1400
1401 if (!netif_running(dev)){
1402 goto rx_exit;
1403 }
1404
1405 chdlc_priv_area = dev->priv;
1406
1407 if (rxbuf->error_flag){
1408 goto rx_exit;
1409 }
1410
1411
1412 if (rxbuf->frame_length < 7 || rxbuf->frame_length > 1506 ){
1413 goto rx_exit;
1414 }
1415
1416 len = rxbuf->frame_length - CRC_LENGTH;
1417
1418
1419 skb = dev_alloc_skb(len);
1420
1421 if (skb == NULL) {
1422 if (net_ratelimit()){
1423 printk(KERN_INFO "%s: no socket buffers available!\n",
1424 card->devname);
1425 }
1426 ++card->wandev.stats.rx_dropped;
1427 goto rx_exit;
1428 }
1429
1430
1431 if((addr + len) > card->u.c.rx_top + 1) {
1432 unsigned tmp = card->u.c.rx_top - addr + 1;
1433 buf = skb_put(skb, tmp);
1434 sdla_peek(&card->hw, addr, buf, tmp);
1435 addr = card->u.c.rx_base;
1436 len -= tmp;
1437 }
1438
1439 buf = skb_put(skb, len);
1440 sdla_peek(&card->hw, addr, buf, len);
1441
1442 skb->protocol = htons(ETH_P_WAN_PPP);
1443
1444 card->wandev.stats.rx_packets ++;
1445 card->wandev.stats.rx_bytes += skb->len;
1446 udp_type = udp_pkt_type( skb, card );
1447
1448 if(udp_type == UDP_CPIPE_TYPE) {
1449 if(store_udp_mgmt_pkt(UDP_PKT_FRM_NETWORK,
1450 card, skb, dev, chdlc_priv_area)) {
1451 flags->interrupt_info_struct.
1452 interrupt_permission |=
1453 APP_INT_ON_TIMER;
1454 }
1455 }else{
1456
1457 skb->dev = dev;
1458 skb->mac.raw = skb->data;
1459 netif_rx(skb);
1460 dev->last_rx = jiffies;
1461 }
1462
1463rx_exit:
1464
1465 rxbuf->opp_flag = 0x00;
1466 card->u.c.rxmb = ++ rxbuf;
1467 if((void*)rxbuf > card->u.c.rxbuf_last){
1468 card->u.c.rxmb = card->u.c.rxbuf_base;
1469 }
1470}
1471
1472
1473
1474
1475
1476
1477
1478void timer_intr(sdla_t *card)
1479{
1480 struct net_device* dev;
1481 chdlc_private_area_t* chdlc_priv_area = NULL;
1482 SHARED_MEMORY_INFO_STRUCT* flags = NULL;
1483
1484 dev = card->wandev.dev;
1485 chdlc_priv_area = dev->priv;
1486
1487 if (chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_CONFIG) {
1488 if (!config_chdlc(card)){
1489 chdlc_priv_area->timer_int_enabled &= ~TMR_INT_ENABLED_CONFIG;
1490 }
1491 }
1492
1493
1494 if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UDP) {
1495 process_udp_mgmt_pkt(card, dev,
1496 chdlc_priv_area);
1497 chdlc_priv_area->timer_int_enabled &= ~TMR_INT_ENABLED_UDP;
1498 }
1499
1500
1501
1502 if(chdlc_priv_area->timer_int_enabled & TMR_INT_ENABLED_UPDATE) {
1503 update_comms_stats(card, chdlc_priv_area);
1504 if(!(-- chdlc_priv_area->update_comms_stats)) {
1505 chdlc_priv_area->timer_int_enabled &=
1506 ~TMR_INT_ENABLED_UPDATE;
1507 }
1508 }
1509
1510
1511
1512 if(!chdlc_priv_area->timer_int_enabled) {
1513 flags = card->u.c.flags;
1514 flags->interrupt_info_struct.interrupt_permission &=
1515 ~APP_INT_ON_TIMER;
1516 }
1517}
1518
1519
1520
1521
1522
1523
1524static int set_chdlc_config(sdla_t* card)
1525{
1526
1527 CHDLC_CONFIGURATION_STRUCT cfg;
1528
1529 memset(&cfg, 0, sizeof(CHDLC_CONFIGURATION_STRUCT));
1530
1531 if(card->wandev.clocking)
1532 cfg.baud_rate = card->wandev.bps;
1533
1534 cfg.line_config_options = (card->wandev.interface == WANOPT_RS232) ?
1535 INTERFACE_LEVEL_RS232 : INTERFACE_LEVEL_V35;
1536
1537 cfg.modem_config_options = 0;
1538
1539 cfg.CHDLC_API_options = DISCARD_RX_ERROR_FRAMES;
1540 cfg.modem_status_timer = 100;
1541 cfg.CHDLC_protocol_options = HDLC_STREAMING_MODE;
1542 cfg.percent_data_buffer_for_Tx = 50;
1543 cfg.CHDLC_statistics_options = (CHDLC_TX_DATA_BYTE_COUNT_STAT |
1544 CHDLC_RX_DATA_BYTE_COUNT_STAT);
1545 cfg.max_CHDLC_data_field_length = card->wandev.mtu;
1546
1547 cfg.transmit_keepalive_timer = 0;
1548 cfg.receive_keepalive_timer = 0;
1549 cfg.keepalive_error_tolerance = 0;
1550 cfg.SLARP_request_timer = 0;
1551
1552 cfg.IP_address = 0;
1553 cfg.IP_netmask = 0;
1554
1555 return chdlc_configure(card, &cfg);
1556}
1557
1558
1559
1560
1561static int process_global_exception(sdla_t *card)
1562{
1563 CHDLC_MAILBOX_STRUCT* mbox = card->mbox;
1564 int err;
1565
1566 mbox->buffer_length = 0;
1567 mbox->command = READ_GLOBAL_EXCEPTION_CONDITION;
1568 err = sdla_exec(mbox) ? mbox->return_code : CMD_TIMEOUT;
1569
1570 if(err != CMD_TIMEOUT ){
1571
1572 switch(mbox->return_code) {
1573
1574 case EXCEP_MODEM_STATUS_CHANGE:
1575
1576 printk(KERN_INFO "%s: Modem status change\n",
1577 card->devname);
1578
1579 switch(mbox->data[0] & (DCD_HIGH | CTS_HIGH)) {
1580 case (DCD_HIGH):
1581 printk(KERN_INFO "%s: DCD high, CTS low\n",card->devname);
1582 break;
1583 case (CTS_HIGH):
1584 printk(KERN_INFO "%s: DCD low, CTS high\n",card->devname);
1585 break;
1586 case ((DCD_HIGH | CTS_HIGH)):
1587 printk(KERN_INFO "%s: DCD high, CTS high\n",card->devname);
1588 break;
1589 default:
1590 printk(KERN_INFO "%s: DCD low, CTS low\n",card->devname);
1591 break;
1592 }
1593
1594 if (!(mbox->data[0] & DCD_HIGH) || !(mbox->data[0] & DCD_HIGH)){
1595
1596 send_ppp_term_request(card->wandev.dev);
1597 }
1598 break;
1599
1600 case EXCEP_TRC_DISABLED:
1601 printk(KERN_INFO "%s: Line trace disabled\n",
1602 card->devname);
1603 break;
1604
1605 case EXCEP_IRQ_TIMEOUT:
1606 printk(KERN_INFO "%s: IRQ timeout occurred\n",
1607 card->devname);
1608 break;
1609
1610 default:
1611 printk(KERN_INFO "%s: Global exception %x\n",
1612 card->devname, mbox->return_code);
1613 break;
1614 }
1615 }
1616 return 0;
1617}
1618
1619
1620
1621
1622
1623static int process_chdlc_exception(sdla_t *card)
1624{
1625 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
1626 int err;
1627
1628 mb->buffer_length = 0;
1629 mb->command = READ_CHDLC_EXCEPTION_CONDITION;
1630 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1631 if(err != CMD_TIMEOUT) {
1632
1633 switch (err) {
1634
1635 case EXCEP_LINK_ACTIVE:
1636 port_set_state(card, WAN_CONNECTED);
1637 break;
1638
1639 case EXCEP_LINK_INACTIVE_MODEM:
1640 port_set_state(card, WAN_DISCONNECTED);
1641 break;
1642
1643 case EXCEP_LOOPBACK_CONDITION:
1644 printk(KERN_INFO "%s: Loopback Condition Detected.\n",
1645 card->devname);
1646 break;
1647
1648 case NO_CHDLC_EXCEP_COND_TO_REPORT:
1649 printk(KERN_INFO "%s: No exceptions reported.\n",
1650 card->devname);
1651 break;
1652 default:
1653 printk(KERN_INFO "%s: Exception Condition %x!\n",
1654 card->devname,err);
1655 break;
1656 }
1657
1658 }
1659 return 0;
1660}
1661
1662
1663
1664
1665
1666
1667static int store_udp_mgmt_pkt(char udp_pkt_src, sdla_t* card,
1668 struct sk_buff *skb, struct net_device* dev,
1669 chdlc_private_area_t* chdlc_priv_area )
1670{
1671 int udp_pkt_stored = 0;
1672
1673 if(!chdlc_priv_area->udp_pkt_lgth &&
1674 (skb->len <= MAX_LGTH_UDP_MGNT_PKT)) {
1675 chdlc_priv_area->udp_pkt_lgth = skb->len;
1676 chdlc_priv_area->udp_pkt_src = udp_pkt_src;
1677 memcpy(chdlc_priv_area->udp_pkt_data, skb->data, skb->len);
1678 chdlc_priv_area->timer_int_enabled = TMR_INT_ENABLED_UDP;
1679 udp_pkt_stored = 1;
1680 }
1681
1682 if(udp_pkt_src == UDP_PKT_FRM_STACK)
1683 dev_kfree_skb_any(skb);
1684 else
1685 dev_kfree_skb_any(skb);
1686
1687 return(udp_pkt_stored);
1688}
1689
1690
1691
1692
1693
1694
1695static int process_udp_mgmt_pkt(sdla_t* card, struct net_device* dev,
1696 chdlc_private_area_t* chdlc_priv_area )
1697{
1698 unsigned char *buf;
1699 unsigned int frames, len;
1700 struct sk_buff *new_skb;
1701 unsigned short buffer_length, real_len;
1702 unsigned long data_ptr;
1703 unsigned data_length;
1704 int udp_mgmt_req_valid = 1;
1705 CHDLC_MAILBOX_STRUCT *mb = card->mbox;
1706 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
1707 chdlc_udp_pkt_t *chdlc_udp_pkt;
1708 struct timeval tv;
1709 int err;
1710 char ut_char;
1711
1712 chdlc_udp_pkt = (chdlc_udp_pkt_t *) chdlc_priv_area->udp_pkt_data;
1713
1714 if(chdlc_priv_area->udp_pkt_src == UDP_PKT_FRM_NETWORK) {
1715
1716 switch(chdlc_udp_pkt->cblock.command) {
1717 case READ_GLOBAL_STATISTICS:
1718 case READ_MODEM_STATUS:
1719 case READ_CHDLC_LINK_STATUS:
1720 case CPIPE_ROUTER_UP_TIME:
1721 case READ_COMMS_ERROR_STATS:
1722 case READ_CHDLC_OPERATIONAL_STATS:
1723
1724
1725
1726 case READ_CHDLC_CONFIGURATION:
1727 case READ_CHDLC_CODE_VERSION:
1728 udp_mgmt_req_valid = 1;
1729 break;
1730 default:
1731 udp_mgmt_req_valid = 0;
1732 break;
1733 }
1734 }
1735
1736 if(!udp_mgmt_req_valid) {
1737
1738
1739 chdlc_udp_pkt->cblock.buffer_length = 0;
1740
1741
1742 chdlc_udp_pkt->cblock.return_code = 0xCD;
1743
1744 if (net_ratelimit()){
1745 printk(KERN_INFO
1746 "%s: Warning, Illegal UDP command attempted from network: %x\n",
1747 card->devname,chdlc_udp_pkt->cblock.command);
1748 }
1749
1750 } else {
1751 unsigned long trace_status_cfg_addr = 0;
1752 TRACE_STATUS_EL_CFG_STRUCT trace_cfg_struct;
1753 TRACE_STATUS_ELEMENT_STRUCT trace_element_struct;
1754
1755 switch(chdlc_udp_pkt->cblock.command) {
1756
1757 case CPIPE_ENABLE_TRACING:
1758 if (!chdlc_priv_area->TracingEnabled) {
1759
1760
1761
1762 mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
1763 mb->command = SET_TRACE_CONFIGURATION;
1764
1765 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1766 trace_config = TRACE_ACTIVE;
1767
1768
1769
1770
1771
1772 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->trace_config |=
1773 chdlc_udp_pkt->data[0];
1774
1775 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1776 trace_deactivation_timer = 4000;
1777
1778
1779 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1780 if (err != COMMAND_OK) {
1781 chdlc_error(card,err,mb);
1782 card->TracingEnabled = 0;
1783 chdlc_udp_pkt->cblock.return_code = err;
1784 mb->buffer_length = 0;
1785 break;
1786 }
1787
1788
1789 mb->buffer_length = 0;
1790 mb->command = READ_TRACE_CONFIGURATION;
1791 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1792
1793 if (err != COMMAND_OK) {
1794 chdlc_error(card,err,mb);
1795 chdlc_priv_area->TracingEnabled = 0;
1796 chdlc_udp_pkt->cblock.return_code = err;
1797 mb->buffer_length = 0;
1798 break;
1799 }
1800
1801 trace_status_cfg_addr =((LINE_TRACE_CONFIG_STRUCT *)
1802 mb->data) -> ptr_trace_stat_el_cfg_struct;
1803
1804 sdla_peek(&card->hw, trace_status_cfg_addr,
1805 &trace_cfg_struct, sizeof(trace_cfg_struct));
1806
1807 chdlc_priv_area->start_trace_addr = trace_cfg_struct.
1808 base_addr_trace_status_elements;
1809
1810 chdlc_priv_area->number_trace_elements =
1811 trace_cfg_struct.number_trace_status_elements;
1812
1813 chdlc_priv_area->end_trace_addr = (unsigned long)
1814 ((TRACE_STATUS_ELEMENT_STRUCT *)
1815 chdlc_priv_area->start_trace_addr +
1816 (chdlc_priv_area->number_trace_elements - 1));
1817
1818 chdlc_priv_area->base_addr_trace_buffer =
1819 trace_cfg_struct.base_addr_trace_buffer;
1820
1821 chdlc_priv_area->end_addr_trace_buffer =
1822 trace_cfg_struct.end_addr_trace_buffer;
1823
1824 chdlc_priv_area->curr_trace_addr =
1825 trace_cfg_struct.next_trace_element_to_use;
1826
1827 chdlc_priv_area->available_buffer_space = 2000 -
1828 sizeof(ip_pkt_t) -
1829 sizeof(udp_pkt_t) -
1830 sizeof(wp_mgmt_t) -
1831 sizeof(cblock_t) -
1832 sizeof(trace_info_t);
1833 }
1834 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1835 mb->buffer_length = 0;
1836 chdlc_priv_area->TracingEnabled = 1;
1837 break;
1838
1839
1840 case CPIPE_DISABLE_TRACING:
1841 if (chdlc_priv_area->TracingEnabled) {
1842
1843
1844 mb->buffer_length = sizeof(LINE_TRACE_CONFIG_STRUCT);
1845 mb->command = SET_TRACE_CONFIGURATION;
1846 ((LINE_TRACE_CONFIG_STRUCT *)mb->data)->
1847 trace_config = TRACE_INACTIVE;
1848 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
1849 }
1850
1851 chdlc_priv_area->TracingEnabled = 0;
1852 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1853 mb->buffer_length = 0;
1854 break;
1855
1856
1857 case CPIPE_GET_TRACE_INFO:
1858
1859 if (!chdlc_priv_area->TracingEnabled) {
1860 chdlc_udp_pkt->cblock.return_code = 1;
1861 mb->buffer_length = 0;
1862 break;
1863 }
1864
1865 chdlc_udp_pkt->trace_info.ismoredata = 0x00;
1866 buffer_length = 0;
1867
1868 for (frames=0; frames < chdlc_priv_area->number_trace_elements; frames++){
1869
1870 trace_pkt_t *trace_pkt = (trace_pkt_t *)
1871 &chdlc_udp_pkt->data[buffer_length];
1872
1873 sdla_peek(&card->hw, chdlc_priv_area->curr_trace_addr,
1874 (unsigned char *)&trace_element_struct,
1875 sizeof(TRACE_STATUS_ELEMENT_STRUCT));
1876
1877 if (trace_element_struct.opp_flag == 0x00) {
1878 break;
1879 }
1880
1881
1882 data_ptr = trace_element_struct.ptr_data_bfr;
1883
1884
1885 if (data_ptr){
1886 data_length = trace_element_struct.trace_length;
1887 }else{
1888 data_length = 0;
1889 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1890 }
1891
1892 if( (chdlc_priv_area->available_buffer_space - buffer_length)
1893 < ( sizeof(trace_pkt_t) + data_length) ) {
1894
1895
1896 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1897 break;
1898 }
1899
1900 trace_pkt->status = trace_element_struct.trace_type;
1901
1902 trace_pkt->time_stamp =
1903 trace_element_struct.trace_time_stamp;
1904
1905 trace_pkt->real_length =
1906 trace_element_struct.trace_length;
1907
1908
1909 real_len = trace_pkt->real_length;
1910
1911 if (data_ptr == 0) {
1912 trace_pkt->data_avail = 0x00;
1913 } else {
1914 unsigned tmp = 0;
1915
1916
1917
1918 trace_pkt->data_avail = 0x01;
1919
1920 if ((data_ptr + real_len) >
1921 chdlc_priv_area->end_addr_trace_buffer + 1){
1922
1923 tmp = chdlc_priv_area->end_addr_trace_buffer - data_ptr + 1;
1924 sdla_peek(&card->hw, data_ptr,
1925 trace_pkt->data,tmp);
1926 data_ptr = chdlc_priv_area->base_addr_trace_buffer;
1927 }
1928
1929 sdla_peek(&card->hw, data_ptr,
1930 &trace_pkt->data[tmp], real_len - tmp);
1931 }
1932
1933
1934 ut_char = 0x00;
1935 sdla_poke(&card->hw, chdlc_priv_area->curr_trace_addr, &ut_char, 1);
1936
1937
1938 chdlc_priv_area->curr_trace_addr += sizeof(TRACE_STATUS_ELEMENT_STRUCT);
1939
1940
1941 if ( chdlc_priv_area->curr_trace_addr > chdlc_priv_area->end_trace_addr ) {
1942 chdlc_priv_area->curr_trace_addr = chdlc_priv_area->start_trace_addr;
1943 }
1944
1945 if(trace_pkt->data_avail == 0x01) {
1946 buffer_length += real_len - 1;
1947 }
1948
1949
1950 buffer_length += sizeof(trace_pkt_t);
1951
1952 }
1953
1954 if (frames == chdlc_priv_area->number_trace_elements){
1955 chdlc_udp_pkt->trace_info.ismoredata = 0x01;
1956 }
1957 chdlc_udp_pkt->trace_info.num_frames = frames;
1958
1959 mb->buffer_length = buffer_length;
1960 chdlc_udp_pkt->cblock.buffer_length = buffer_length;
1961
1962 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1963
1964 break;
1965
1966
1967 case CPIPE_FT1_READ_STATUS:
1968 ((unsigned char *)chdlc_udp_pkt->data )[0] =
1969 flags->FT1_info_struct.parallel_port_A_input;
1970
1971 ((unsigned char *)chdlc_udp_pkt->data )[1] =
1972 flags->FT1_info_struct.parallel_port_B_input;
1973
1974 chdlc_udp_pkt->cblock.return_code = COMMAND_OK;
1975 mb->buffer_length = 2;
1976 break;
1977
1978 case CPIPE_ROUTER_UP_TIME:
1979 do_gettimeofday( &tv );
1980 chdlc_priv_area->router_up_time = tv.tv_sec -
1981 chdlc_priv_area->router_start_time;
1982 *(unsigned long *)&chdlc_udp_pkt->data =
1983 chdlc_priv_area->router_up_time;
1984 mb->buffer_length = sizeof(unsigned long);
1985 break;
1986
1987 case FT1_MONITOR_STATUS_CTRL:
1988
1989 if ((chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_STATUS) ||
1990 (chdlc_udp_pkt->data[0] & ENABLE_READ_FT1_OP_STATS)) {
1991
1992 if( rCount++ != 0 ) {
1993 chdlc_udp_pkt->cblock.
1994 return_code = COMMAND_OK;
1995 mb->buffer_length = 1;
1996 break;
1997 }
1998 }
1999
2000
2001 if( chdlc_udp_pkt->data[0] == 0) {
2002
2003 if( --rCount != 0) {
2004 chdlc_udp_pkt->cblock.
2005 return_code = COMMAND_OK;
2006 mb->buffer_length = 1;
2007 break;
2008 }
2009 }
2010
2011 default:
2012
2013 mb->command = chdlc_udp_pkt->cblock.command;
2014 mb->buffer_length = chdlc_udp_pkt->cblock.buffer_length;
2015 if (mb->buffer_length) {
2016 memcpy(&mb->data, (unsigned char *) chdlc_udp_pkt->
2017 data, mb->buffer_length);
2018 }
2019
2020 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2021 if (err != COMMAND_OK) {
2022 break;
2023 }
2024
2025
2026 memcpy(&chdlc_udp_pkt->cblock, mb, sizeof(cblock_t));
2027
2028 if (mb->buffer_length) {
2029 memcpy(&chdlc_udp_pkt->data, &mb->data,
2030 mb->buffer_length);
2031 }
2032
2033 }
2034 }
2035
2036
2037 chdlc_udp_pkt->ip_pkt.ttl = card->wandev.ttl;
2038
2039 len = reply_udp(chdlc_priv_area->udp_pkt_data, mb->buffer_length);
2040
2041 if(chdlc_priv_area->udp_pkt_src == UDP_PKT_FRM_NETWORK) {
2042 if(!chdlc_send(card, chdlc_priv_area->udp_pkt_data, len)) {
2043 ++ card->wandev.stats.tx_packets;
2044 card->wandev.stats.tx_bytes += len;
2045 }
2046 } else {
2047
2048
2049
2050 if ((new_skb = dev_alloc_skb(len)) != NULL) {
2051
2052
2053 buf = skb_put(new_skb, len);
2054 memcpy(buf, chdlc_priv_area->udp_pkt_data, len);
2055
2056
2057 new_skb->protocol = htons(ETH_P_IP);
2058 new_skb->dev = dev;
2059 new_skb->mac.raw = new_skb->data;
2060
2061 netif_rx(new_skb);
2062 dev->last_rx = jiffies;
2063 } else {
2064
2065 printk(KERN_INFO "%s: no socket buffers available!\n",
2066 card->devname);
2067 }
2068 }
2069
2070 chdlc_priv_area->udp_pkt_lgth = 0;
2071
2072 return 0;
2073}
2074
2075
2076
2077
2078
2079static void init_chdlc_tx_rx_buff(sdla_t* card, struct net_device *dev)
2080{
2081 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2082 CHDLC_TX_STATUS_EL_CFG_STRUCT *tx_config;
2083 CHDLC_RX_STATUS_EL_CFG_STRUCT *rx_config;
2084 char err;
2085
2086 mb->buffer_length = 0;
2087 mb->command = READ_CHDLC_CONFIGURATION;
2088 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2089
2090 if(err != COMMAND_OK) {
2091 chdlc_error(card,err,mb);
2092 return;
2093 }
2094
2095 if(card->hw.type == SDLA_S514) {
2096 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2097 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2098 ptr_CHDLC_Tx_stat_el_cfg_struct));
2099 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2100 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2101 ptr_CHDLC_Rx_stat_el_cfg_struct));
2102
2103
2104 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2105 tx_config->base_addr_Tx_status_elements);
2106 card->u.c.txbuf_last =
2107 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)
2108 card->u.c.txbuf_base +
2109 (tx_config->number_Tx_status_elements - 1);
2110
2111 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2112 rx_config->base_addr_Rx_status_elements);
2113 card->u.c.rxbuf_last =
2114 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)
2115 card->u.c.rxbuf_base +
2116 (rx_config->number_Rx_status_elements - 1);
2117
2118
2119 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2120 tx_config->next_Tx_status_element_to_use);
2121 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2122 rx_config->next_Rx_status_element_to_use);
2123 }
2124 else {
2125 tx_config = (CHDLC_TX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2126 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2127 ptr_CHDLC_Tx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2128
2129 rx_config = (CHDLC_RX_STATUS_EL_CFG_STRUCT *)(card->hw.dpmbase +
2130 (((CHDLC_CONFIGURATION_STRUCT *)mb->data)->
2131 ptr_CHDLC_Rx_stat_el_cfg_struct % SDLA_WINDOWSIZE));
2132
2133
2134 card->u.c.txbuf_base = (void *)(card->hw.dpmbase +
2135 (tx_config->base_addr_Tx_status_elements % SDLA_WINDOWSIZE));
2136 card->u.c.txbuf_last =
2137 (CHDLC_DATA_TX_STATUS_EL_STRUCT *)card->u.c.txbuf_base
2138 + (tx_config->number_Tx_status_elements - 1);
2139 card->u.c.rxbuf_base = (void *)(card->hw.dpmbase +
2140 (rx_config->base_addr_Rx_status_elements % SDLA_WINDOWSIZE));
2141 card->u.c.rxbuf_last =
2142 (CHDLC_DATA_RX_STATUS_EL_STRUCT *)card->u.c.rxbuf_base
2143 + (rx_config->number_Rx_status_elements - 1);
2144
2145
2146 card->u.c.txbuf = (void *)(card->hw.dpmbase +
2147 (tx_config->next_Tx_status_element_to_use % SDLA_WINDOWSIZE));
2148 card->u.c.rxmb = (void *)(card->hw.dpmbase +
2149 (rx_config->next_Rx_status_element_to_use % SDLA_WINDOWSIZE));
2150 }
2151
2152
2153 card->u.c.rx_base = rx_config->base_addr_Rx_buffer;
2154 card->u.c.rx_top = rx_config->end_addr_Rx_buffer;
2155
2156}
2157
2158
2159
2160
2161
2162static int intr_test( sdla_t* card)
2163{
2164 CHDLC_MAILBOX_STRUCT* mb = card->mbox;
2165 int err,i;
2166
2167 Intr_test_counter = 0;
2168
2169
2170
2171
2172
2173
2174 err = chdlc_set_intr_mode(card, APP_INT_ON_COMMAND_COMPLETE);
2175
2176 if (err == CMD_OK) {
2177 for (i = 0; i < MAX_INTR_TEST_COUNTER; i ++) {
2178 mb->buffer_length = 0;
2179 mb->command = READ_CHDLC_CODE_VERSION;
2180 err = sdla_exec(mb) ? mb->return_code : CMD_TIMEOUT;
2181 }
2182 }
2183 else {
2184 return err;
2185 }
2186
2187 err = chdlc_set_intr_mode(card, 0);
2188
2189 if (err != CMD_OK)
2190 return err;
2191
2192 return 0;
2193}
2194
2195
2196
2197
2198static int udp_pkt_type(struct sk_buff *skb, sdla_t* card)
2199{
2200 chdlc_udp_pkt_t *chdlc_udp_pkt = (chdlc_udp_pkt_t *)skb->data;
2201
2202 if (!strncmp(chdlc_udp_pkt->wp_mgmt.signature,UDPMGMT_SIGNATURE,8) &&
2203 (chdlc_udp_pkt->udp_pkt.udp_dst_port == ntohs(card->wandev.udp_port)) &&
2204 (chdlc_udp_pkt->ip_pkt.protocol == UDPMGMT_UDP_PROTOCOL) &&
2205 (chdlc_udp_pkt->wp_mgmt.request_reply == UDPMGMT_REQUEST)) {
2206 return UDP_CPIPE_TYPE;
2207 }
2208 else return UDP_INVALID_TYPE;
2209}
2210
2211
2212
2213
2214static void port_set_state (sdla_t *card, int state)
2215{
2216 struct net_device *dev = card->wandev.dev;
2217 chdlc_private_area_t *chdlc_priv_area = dev->priv;
2218
2219 if (card->u.c.state != state)
2220 {
2221 switch (state)
2222 {
2223 case WAN_CONNECTED:
2224 printk (KERN_INFO "%s: HDLC link connected!\n",
2225 card->devname);
2226 break;
2227
2228 case WAN_CONNECTING:
2229 printk (KERN_INFO "%s: HDLC link connecting...\n",
2230 card->devname);
2231 break;
2232
2233 case WAN_DISCONNECTED:
2234 printk (KERN_INFO "%s: HDLC link disconnected!\n",
2235 card->devname);
2236 break;
2237 }
2238
2239 card->wandev.state = card->u.c.state = state;
2240 chdlc_priv_area->common.state = state;
2241 }
2242}
2243
2244void s508_lock (sdla_t *card, unsigned long *smp_flags)
2245{
2246 spin_lock_irqsave(&card->wandev.lock, *smp_flags);
2247 if (card->next){
2248
2249
2250 spin_lock(&card->next->wandev.lock);
2251 }
2252}
2253
2254void s508_unlock (sdla_t *card, unsigned long *smp_flags)
2255{
2256 if (card->next){
2257 spin_unlock(&card->next->wandev.lock);
2258 }
2259 spin_unlock_irqrestore(&card->wandev.lock, *smp_flags);
2260}
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285static int config_chdlc (sdla_t *card)
2286{
2287 struct net_device *dev = card->wandev.dev;
2288 SHARED_MEMORY_INFO_STRUCT *flags = card->u.c.flags;
2289
2290 if (card->u.c.comm_enabled){
2291 chdlc_comm_disable(card);
2292 port_set_state(card, WAN_DISCONNECTED);
2293 }
2294
2295 if (set_chdlc_config(card)) {
2296 printk(KERN_INFO "%s: CHDLC Configuration Failed!\n",
2297 card->devname);
2298 return 0;
2299 }
2300 init_chdlc_tx_rx_buff(card, dev);
2301
2302
2303 if (chdlc_set_intr_mode(card, APP_INT_ON_RX_FRAME |
2304 APP_INT_ON_GLOBAL_EXCEP_COND |
2305 APP_INT_ON_TX_FRAME |
2306 APP_INT_ON_CHDLC_EXCEP_COND | APP_INT_ON_TIMER)){
2307 printk (KERN_INFO "%s: Failed to set interrupt triggers!\n",
2308 card->devname);
2309 return 0;
2310 }
2311
2312
2313
2314 flags->interrupt_info_struct.interrupt_permission &=
2315 ~(APP_INT_ON_TX_FRAME | APP_INT_ON_TIMER);
2316
2317
2318 if (chdlc_comm_enable(card) != 0) {
2319 printk(KERN_INFO "%s: Failed to enable chdlc communications!\n",
2320 card->devname);
2321 flags->interrupt_info_struct.interrupt_permission = 0;
2322 card->u.c.comm_enabled=0;
2323 chdlc_set_intr_mode(card,0);
2324 return 0;
2325 }
2326
2327
2328 port_set_state(card, WAN_CONNECTING);
2329 return 0;
2330}
2331
2332
2333static void send_ppp_term_request(struct net_device *dev)
2334{
2335 struct sk_buff *new_skb;
2336 unsigned char *buf;
2337
2338 if ((new_skb = dev_alloc_skb(8)) != NULL) {
2339
2340
2341 buf = skb_put(new_skb, 8);
2342 sprintf(buf,"%c%c%c%c%c%c%c%c", 0xFF,0x03,0xC0,0x21,0x05,0x98,0x00,0x07);
2343
2344
2345 new_skb->protocol = htons(ETH_P_WAN_PPP);
2346 new_skb->dev = dev;
2347 new_skb->mac.raw = new_skb->data;
2348
2349 netif_rx(new_skb);
2350 dev->last_rx = jiffies;
2351 }
2352}
2353
2354
2355MODULE_LICENSE("GPL");
2356
2357
2358
