1
2
3
4
5
6
7
8
9
10
11#include <linux/init.h>
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/netdevice.h>
15#include <linux/etherdevice.h>
16#include <linux/usb.h>
17#include "ft1000_usb.h"
18#include <linux/types.h>
19
20#define HARLEY_READ_REGISTER 0x0
21#define HARLEY_WRITE_REGISTER 0x01
22#define HARLEY_READ_DPRAM_32 0x02
23#define HARLEY_READ_DPRAM_LOW 0x03
24#define HARLEY_READ_DPRAM_HIGH 0x04
25#define HARLEY_WRITE_DPRAM_32 0x05
26#define HARLEY_WRITE_DPRAM_LOW 0x06
27#define HARLEY_WRITE_DPRAM_HIGH 0x07
28
29#define HARLEY_READ_OPERATION 0xc1
30#define HARLEY_WRITE_OPERATION 0x41
31
32
33
34static int ft1000_reset(struct net_device *ft1000dev);
35static int ft1000_submit_rx_urb(struct ft1000_info *info);
36static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
37static int ft1000_open (struct net_device *dev);
38static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
39static int ft1000_chkcard (struct ft1000_device *dev);
40
41
42
43static u8 tempbuffer[1600];
44
45#define MAX_RCV_LOOP 100
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68static int ft1000_control(struct ft1000_device *ft1000dev,unsigned int pipe,
69 u8 request,
70 u8 requesttype,
71 u16 value,
72 u16 index,
73 void *data,
74 u16 size,
75 int timeout)
76{
77 u16 ret;
78
79 if (ft1000dev == NULL )
80 {
81 DEBUG("NULL ft1000dev, failure\n");
82 return -ENODEV;
83 }
84 else if ( ft1000dev->dev == NULL )
85 {
86 DEBUG("NULL ft1000dev->dev, failure\n");
87 return -ENODEV;
88 }
89
90 ret = usb_control_msg(ft1000dev->dev,
91 pipe,
92 request,
93 requesttype,
94 value,
95 index,
96 data,
97 size,
98 LARGE_TIMEOUT);
99
100 if (ret > 0)
101 ret = 0;
102
103 return ret;
104
105
106}
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123u16 ft1000_read_register(struct ft1000_device *ft1000dev, u16* Data, u16 nRegIndx)
124{
125 u16 ret = STATUS_SUCCESS;
126
127
128
129 ret = ft1000_control(ft1000dev,
130 usb_rcvctrlpipe(ft1000dev->dev,0),
131 HARLEY_READ_REGISTER,
132 HARLEY_READ_OPERATION,
133 0,
134 nRegIndx,
135 Data,
136 2,
137 LARGE_TIMEOUT );
138
139
140
141
142
143 return ret;
144
145}
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162u16 ft1000_write_register(struct ft1000_device *ft1000dev, u16 value, u16 nRegIndx)
163{
164 u16 ret = STATUS_SUCCESS;
165
166
167
168 ret = ft1000_control(ft1000dev,
169 usb_sndctrlpipe(ft1000dev->dev, 0),
170 HARLEY_WRITE_REGISTER,
171 HARLEY_WRITE_OPERATION,
172 value,
173 nRegIndx,
174 NULL,
175 0,
176 LARGE_TIMEOUT );
177
178 return ret;
179}
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198u16 ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u16 cnt)
199{
200 u16 ret = STATUS_SUCCESS;
201
202
203 ret =ft1000_control(ft1000dev,
204 usb_rcvctrlpipe(ft1000dev->dev,0),
205 HARLEY_READ_DPRAM_32,
206 HARLEY_READ_OPERATION,
207 0,
208 indx,
209 buffer,
210 cnt,
211 LARGE_TIMEOUT );
212
213
214
215
216
217 return ret;
218
219}
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237u16 ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u16 cnt)
238{
239 u16 ret = STATUS_SUCCESS;
240
241
242 if ( cnt % 4)
243 cnt += cnt - (cnt % 4);
244
245 ret = ft1000_control(ft1000dev,
246 usb_sndctrlpipe(ft1000dev->dev, 0),
247 HARLEY_WRITE_DPRAM_32,
248 HARLEY_WRITE_OPERATION,
249 0,
250 indx,
251 buffer,
252 cnt,
253 LARGE_TIMEOUT );
254
255 return ret;
256}
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274u16 ft1000_read_dpram16(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u8 highlow)
275{
276 u16 ret = STATUS_SUCCESS;
277
278
279
280 u8 request;
281
282 if (highlow == 0 )
283 request = HARLEY_READ_DPRAM_LOW;
284 else
285 request = HARLEY_READ_DPRAM_HIGH;
286
287 ret = ft1000_control(ft1000dev,
288 usb_rcvctrlpipe(ft1000dev->dev,0),
289 request,
290 HARLEY_READ_OPERATION,
291 0,
292 indx,
293 buffer,
294 2,
295 LARGE_TIMEOUT );
296
297
298
299
300
301
302 return ret;
303
304}
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322u16 ft1000_write_dpram16(struct ft1000_device *ft1000dev, u16 indx, u16 value, u8 highlow)
323{
324 u16 ret = STATUS_SUCCESS;
325
326
327
328
329
330 u8 request;
331
332
333 if ( highlow == 0 )
334 request = HARLEY_WRITE_DPRAM_LOW;
335 else
336 request = HARLEY_WRITE_DPRAM_HIGH;
337
338 ret = ft1000_control(ft1000dev,
339 usb_sndctrlpipe(ft1000dev->dev, 0),
340 request,
341 HARLEY_WRITE_OPERATION,
342 value,
343 indx,
344 NULL,
345 0,
346 LARGE_TIMEOUT );
347
348 return ret;
349}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367u16 fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
368{
369 u8 buf[16];
370 u16 pos;
371 u16 ret = STATUS_SUCCESS;
372
373
374 pos = (indx / 4)*4;
375 ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
376 if (ret == STATUS_SUCCESS)
377 {
378 pos = (indx % 4)*4;
379 *buffer++ = buf[pos++];
380 *buffer++ = buf[pos++];
381 *buffer++ = buf[pos++];
382 *buffer++ = buf[pos++];
383 }
384 else
385 {
386 DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
387 *buffer++ = 0;
388 *buffer++ = 0;
389 *buffer++ = 0;
390 *buffer++ = 0;
391
392 }
393
394
395 return ret;
396
397}
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416u16 fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
417{
418 u16 pos1;
419 u16 pos2;
420 u16 i;
421 u8 buf[32];
422 u8 resultbuffer[32];
423 u8 *pdata;
424 u16 ret = STATUS_SUCCESS;
425
426
427
428 pos1 = (indx / 4)*4;
429 pdata = buffer;
430 ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
431 if (ret == STATUS_SUCCESS)
432 {
433 pos2 = (indx % 4)*4;
434 buf[pos2++] = *buffer++;
435 buf[pos2++] = *buffer++;
436 buf[pos2++] = *buffer++;
437 buf[pos2++] = *buffer++;
438 ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
439 }
440 else
441 {
442 DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
443
444 return ret;
445 }
446
447 ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
448 if (ret == STATUS_SUCCESS)
449 {
450 buffer = pdata;
451 for (i=0; i<16; i++)
452 {
453 if (buf[i] != resultbuffer[i]){
454
455 ret = STATUS_FAILURE;
456 }
457 }
458 }
459
460 if (ret == STATUS_FAILURE)
461 {
462 ret = ft1000_write_dpram32(ft1000dev, pos1, (u8 *)&tempbuffer[0], 16);
463 ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
464 if (ret == STATUS_SUCCESS)
465 {
466 buffer = pdata;
467 for (i=0; i<16; i++)
468 {
469 if (tempbuffer[i] != resultbuffer[i])
470 {
471 ret = STATUS_FAILURE;
472 DEBUG("fix_ft1000_write_dpram32 Failed to write\n");
473 }
474 }
475 }
476 }
477
478 return ret;
479
480}
481
482
483
484
485
486
487
488
489
490
491
492
493static void card_reset_dsp (struct ft1000_device *ft1000dev, bool value)
494{
495 u16 status = STATUS_SUCCESS;
496 u16 tempword;
497
498 status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
499 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_CTRL);
500 if (value)
501 {
502 DEBUG("Reset DSP\n");
503 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
504 tempword |= DSP_RESET_BIT;
505 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
506 }
507 else
508 {
509 DEBUG("Activate DSP\n");
510 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
511 tempword |= DSP_ENCRYPTED;
512 tempword &= ~DSP_UNENCRYPTED;
513 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
514 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
515 tempword &= ~EFUSE_MEM_DISABLE;
516 tempword &= ~DSP_RESET_BIT;
517 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
518 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
519 }
520}
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537void CardSendCommand(struct ft1000_device *ft1000dev, void *ptempbuffer, int size)
538{
539 unsigned short temp;
540 unsigned char *commandbuf;
541
542 DEBUG("CardSendCommand: enter CardSendCommand... size=%d\n", size);
543
544 commandbuf =(unsigned char*) kmalloc(size+2, GFP_KERNEL);
545 memcpy((void*)commandbuf+2, (void*)ptempbuffer, size);
546
547
548
549 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
550
551 if (temp & 0x0100)
552 {
553 msleep(10);
554 }
555
556
557 size = size + 2;
558 if (size % 4)
559 {
560
561 size += 4 - (size % 4);
562 }
563
564
565
566 ft1000_write_dpram32(ft1000dev, 0,commandbuf, size);
567 msleep(1);
568
569 ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX ,FT1000_REG_DOORBELL) ;
570 msleep(1);
571
572 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
573
574 if ( (temp & 0x0100) == 0)
575 {
576
577 }
578
579}
580
581
582
583
584
585
586
587
588
589
590
591
592int dsp_reload(struct ft1000_device *ft1000dev)
593{
594 u16 status;
595 u16 tempword;
596 u32 templong;
597
598 struct ft1000_info *pft1000info;
599
600 pft1000info = netdev_priv(ft1000dev->net);
601
602 pft1000info->CardReady = 0;
603
604
605 status = ft1000_write_register (ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
606
607 status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
608 tempword |= ASIC_RESET_BIT;
609 status = ft1000_write_register (ft1000dev, tempword, FT1000_REG_RESET);
610 msleep(1000);
611 status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
612 DEBUG("Reset Register = 0x%x\n", tempword);
613
614
615 card_reset_dsp (ft1000dev, 1);
616 msleep(1000);
617 card_reset_dsp (ft1000dev, 0);
618 msleep(1000);
619
620 status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
621
622
623 status = ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (u8 *)&templong, 4);
624 DEBUG("templong (fefe) = 0x%8x\n", templong);
625
626
627 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
628
629 if (status != STATUS_SUCCESS)
630 return -EIO;
631
632 msleep(1000);
633
634 DEBUG("dsp_reload returned\n");
635 return 0;
636
637}
638
639
640
641
642
643
644
645
646
647
648
649
650static void ft1000_reset_asic (struct net_device *dev)
651{
652 struct ft1000_info *info = netdev_priv(dev);
653 struct ft1000_device *ft1000dev = info->pFt1000Dev;
654 u16 tempword;
655
656 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
657
658 info->ASICResetNum++;
659
660
661
662 ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
663
664 mdelay(1);
665
666
667 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
668
669
670 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
671 DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
672 ft1000_write_register (ft1000dev, tempword, FT1000_REG_SUP_ISR);
673 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
674 DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
675
676}
677
678
679
680
681
682
683
684
685
686
687
688
689
690static int ft1000_reset_card (struct net_device *dev)
691{
692 struct ft1000_info *info = netdev_priv(dev);
693 struct ft1000_device *ft1000dev = info->pFt1000Dev;
694 u16 tempword;
695 struct prov_record *ptr;
696
697 DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
698
699 info->fCondResetPend = 1;
700 info->CardReady = 0;
701 info->fProvComplete = 0;
702
703
704 while (list_empty(&info->prov_list) == 0) {
705 DEBUG("ft1000_hw:ft1000_reset_card:deleting provisioning record\n");
706 ptr = list_entry(info->prov_list.next, struct prov_record, list);
707 list_del(&ptr->list);
708 kfree(ptr->pprov_data);
709 kfree(ptr);
710 }
711
712 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
713
714 ft1000_reset_asic(dev);
715
716 info->DSPResetNum++;
717
718 DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
719 dsp_reload(ft1000dev);
720
721 DEBUG("dsp reload successful\n");
722
723
724 mdelay(10);
725
726
727 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag, FT1000_MAG_HI_HO_INDX);
728 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *)&tempword, FT1000_MAG_HI_HO_INDX);
729 DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
730
731
732
733 info->CardReady = 1;
734
735 info->fCondResetPend = 0;
736 return TRUE;
737
738}
739
740
741
742#ifdef HAVE_NET_DEVICE_OPS
743static const struct net_device_ops ftnet_ops =
744{
745.ndo_open = &ft1000_open,
746.ndo_stop = &ft1000_close,
747.ndo_start_xmit = &ft1000_start_xmit,
748.ndo_get_stats = &ft1000_netdev_stats,
749};
750#endif
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767u16 init_ft1000_netdev(struct ft1000_device *ft1000dev)
768{
769 struct net_device *netdev;
770 struct ft1000_info *pInfo = NULL;
771 struct dpram_blk *pdpram_blk;
772 int i, ret_val;
773 struct list_head *cur, *tmp;
774 char card_nr[2];
775 unsigned long gCardIndex = 0;
776
777 DEBUG("Enter init_ft1000_netdev...\n");
778
779
780 netdev = alloc_etherdev(sizeof(struct ft1000_info));
781 if (!netdev )
782 {
783 DEBUG("init_ft1000_netdev: can not allocate network device\n");
784 return -ENOMEM;
785 }
786
787 pInfo = netdev_priv(netdev);
788
789
790
791 memset(pInfo, 0, sizeof(struct ft1000_info));
792
793 dev_alloc_name(netdev, netdev->name);
794
795 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
796
797 if ( strncmp(netdev->name,"eth", 3) == 0) {
798 card_nr[0] = netdev->name[3];
799 card_nr[1] = '\0';
800 ret_val = strict_strtoul(card_nr, 10, &gCardIndex);
801 if (ret_val) {
802 printk(KERN_ERR "Can't parse netdev\n");
803 goto err_net;
804 }
805
806 pInfo->CardNumber = gCardIndex;
807 DEBUG("card number = %d\n", pInfo->CardNumber);
808 }
809 else {
810 printk(KERN_ERR "ft1000: Invalid device name\n");
811 ret_val = -ENXIO;
812 goto err_net;
813 }
814
815 memset(&pInfo->stats, 0, sizeof(struct net_device_stats) );
816
817 spin_lock_init(&pInfo->dpram_lock);
818 pInfo->pFt1000Dev = ft1000dev;
819 pInfo->DrvErrNum = 0;
820 pInfo->ASICResetNum = 0;
821 pInfo->registered = 1;
822 pInfo->ft1000_reset = ft1000_reset;
823 pInfo->mediastate = 0;
824 pInfo->fifo_cnt = 0;
825 pInfo->DeviceCreated = FALSE;
826 pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
827 pInfo->InterruptsEnabled = FALSE;
828 pInfo->CardReady = 0;
829 pInfo->DSP_TIME[0] = 0;
830 pInfo->DSP_TIME[1] = 0;
831 pInfo->DSP_TIME[2] = 0;
832 pInfo->DSP_TIME[3] = 0;
833 pInfo->fAppMsgPend = 0;
834 pInfo->fCondResetPend = 0;
835 pInfo->usbboot = 0;
836 pInfo->dspalive = 0;
837 memset(&pInfo->tempbuf[0], 0, sizeof(pInfo->tempbuf));
838
839 INIT_LIST_HEAD(&pInfo->prov_list);
840
841 INIT_LIST_HEAD(&pInfo->nodes.list);
842
843#ifdef HAVE_NET_DEVICE_OPS
844 netdev->netdev_ops = &ftnet_ops;
845#else
846 netdev->hard_start_xmit = &ft1000_start_xmit;
847 netdev->get_stats = &ft1000_netdev_stats;
848 netdev->open = &ft1000_open;
849 netdev->stop = &ft1000_close;
850#endif
851
852 ft1000dev->net = netdev;
853
854
855
856
857
858
859 DEBUG("Initialize free_buff_lock and freercvpool\n");
860 spin_lock_init(&free_buff_lock);
861
862
863 INIT_LIST_HEAD (&freercvpool);
864
865
866 for (i=0; i<NUM_OF_FREE_BUFFERS; i++) {
867
868 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
869 if (pdpram_blk == NULL) {
870 ret_val = -ENOMEM;
871 goto err_free;
872 }
873
874 pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );
875 if (pdpram_blk->pbuffer == NULL) {
876 ret_val = -ENOMEM;
877 kfree(pdpram_blk);
878 goto err_free;
879 }
880
881 list_add_tail (&pdpram_blk->list, &freercvpool);
882 }
883 numofmsgbuf = NUM_OF_FREE_BUFFERS;
884
885
886 return 0;
887
888
889err_free:
890 list_for_each_safe(cur, tmp, &freercvpool) {
891 pdpram_blk = list_entry(cur, struct dpram_blk, list);
892 list_del(&pdpram_blk->list);
893 kfree(pdpram_blk->pbuffer);
894 kfree(pdpram_blk);
895 }
896err_net:
897 free_netdev(netdev);
898 return ret_val;
899}
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917int reg_ft1000_netdev(struct ft1000_device *ft1000dev, struct usb_interface *intf)
918{
919 struct net_device *netdev;
920 struct ft1000_info *pInfo;
921 int rc;
922
923 netdev = ft1000dev->net;
924 pInfo = netdev_priv(ft1000dev->net);
925 DEBUG("Enter reg_ft1000_netdev...\n");
926
927
928 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
929
930 usb_set_intfdata(intf, pInfo);
931 SET_NETDEV_DEV(netdev, &intf->dev);
932
933 rc = register_netdev(netdev);
934 if (rc)
935 {
936 DEBUG("reg_ft1000_netdev: could not register network device\n");
937 free_netdev(netdev);
938 return rc;
939 }
940
941
942
943 ft1000_create_dev(ft1000dev);
944
945 DEBUG ("reg_ft1000_netdev returned\n");
946
947 pInfo->CardReady = 1;
948
949
950 return 0;
951}
952
953static int ft1000_reset(struct net_device *dev)
954{
955 ft1000_reset_card(dev);
956 return 0;
957}
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972static void ft1000_usb_transmit_complete(struct urb *urb)
973{
974
975 struct ft1000_device *ft1000dev = urb->context;
976
977
978
979 if (urb->status)
980 printk("%s: TX status %d\n", ft1000dev->net->name, urb->status);
981
982 netif_wake_queue(ft1000dev->net);
983
984
985}
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002static int ft1000_copy_down_pkt (struct net_device *netdev, u8 *packet, u16 len)
1003{
1004 struct ft1000_info *pInfo = netdev_priv(netdev);
1005 struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
1006
1007
1008 int count, ret;
1009 u8 *t;
1010 struct pseudo_hdr hdr;
1011
1012 if (!pInfo->CardReady)
1013 {
1014
1015 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
1016 return -ENODEV;
1017
1018 }
1019
1020
1021
1022
1023 count = sizeof(struct pseudo_hdr) + len;
1024 if(count > MAX_BUF_SIZE)
1025 {
1026 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
1027 DEBUG("size = %d\n", count);
1028 return -EINVAL;
1029 }
1030
1031 if ( count % 4)
1032 count = count + (4- (count %4) );
1033
1034 memset(&hdr, 0, sizeof(struct pseudo_hdr));
1035
1036 hdr.length = ntohs(count);
1037 hdr.source = 0x10;
1038 hdr.destination = 0x20;
1039 hdr.portdest = 0x20;
1040 hdr.portsrc = 0x10;
1041 hdr.sh_str_id = 0x91;
1042 hdr.control = 0x00;
1043
1044 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
1045 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^
1046 hdr.control;
1047
1048 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
1049 memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
1050
1051 netif_stop_queue(netdev);
1052
1053
1054
1055 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
1056 pFt1000Dev->dev,
1057 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr),
1058 pFt1000Dev->tx_buf,
1059 count,
1060 ft1000_usb_transmit_complete,
1061 (void*)pFt1000Dev);
1062
1063 t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
1064
1065
1066
1067
1068
1069
1070
1071 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
1072 if (ret) {
1073 DEBUG("ft1000 failed tx_urb %d\n", ret);
1074 return ret;
1075 } else {
1076 pInfo->stats.tx_packets++;
1077 pInfo->stats.tx_bytes += (len+14);
1078 }
1079
1080
1081
1082 return 0;
1083}
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1100{
1101 struct ft1000_info *pInfo = netdev_priv(dev);
1102 struct ft1000_device *pFt1000Dev= pInfo->pFt1000Dev;
1103 u8 *pdata;
1104 int maxlen, pipe;
1105
1106
1107
1108
1109 if ( skb == NULL )
1110 {
1111 DEBUG ("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n" );
1112 return NETDEV_TX_OK;
1113 }
1114
1115 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1116 {
1117 DEBUG("network driver is closed, return\n");
1118 goto err;
1119 }
1120
1121
1122 pipe = usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1123 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1124
1125
1126 pdata = (u8 *)skb->data;
1127
1128
1129
1130
1131
1132
1133 if (pInfo->mediastate == 0)
1134 {
1135
1136 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1137 goto err;
1138 }
1139
1140 if ( (skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE) )
1141 {
1142
1143 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1144 goto err;
1145 }
1146
1147 ft1000_copy_down_pkt(dev, (pdata+ENET_HEADER_SIZE-2),
1148 skb->len - ENET_HEADER_SIZE + 2);
1149
1150err:
1151 dev_kfree_skb(skb);
1152
1153
1154 return NETDEV_TX_OK;
1155}
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170static int ft1000_copy_up_pkt (struct urb *urb)
1171{
1172 struct ft1000_info *info = urb->context;
1173 struct ft1000_device *ft1000dev = info->pFt1000Dev;
1174 struct net_device *net = ft1000dev->net;
1175
1176 u16 tempword;
1177 u16 len;
1178 u16 lena;
1179 struct sk_buff *skb;
1180 u16 i;
1181 u8 *pbuffer=NULL;
1182 u8 *ptemp=NULL;
1183 u16 *chksum;
1184
1185
1186
1187
1188 if ( ft1000dev->status & FT1000_STATUS_CLOSING)
1189 {
1190 DEBUG("network driver is closed, return\n");
1191 return STATUS_SUCCESS;
1192 }
1193
1194
1195 len = urb->transfer_buffer_length;
1196 lena = urb->actual_length;
1197
1198
1199
1200 chksum = (u16 *)ft1000dev->rx_buf;
1201
1202 tempword = *chksum++;
1203 for (i=1; i<7; i++)
1204 {
1205 tempword ^= *chksum++;
1206 }
1207
1208 if (tempword != *chksum)
1209 {
1210 info->stats.rx_errors ++;
1211 ft1000_submit_rx_urb(info);
1212 return STATUS_FAILURE;
1213 }
1214
1215
1216
1217
1218 skb = dev_alloc_skb(len+12+2);
1219
1220 if (skb == NULL)
1221 {
1222 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1223 info->stats.rx_errors++;
1224 ft1000_submit_rx_urb(info);
1225 return STATUS_FAILURE;
1226 }
1227
1228 pbuffer = (u8 *)skb_put(skb, len+12);
1229
1230
1231 ptemp = pbuffer;
1232
1233
1234 *pbuffer++ = net->dev_addr[0];
1235 *pbuffer++ = net->dev_addr[1];
1236 *pbuffer++ = net->dev_addr[2];
1237 *pbuffer++ = net->dev_addr[3];
1238 *pbuffer++ = net->dev_addr[4];
1239 *pbuffer++ = net->dev_addr[5];
1240 *pbuffer++ = 0x00;
1241 *pbuffer++ = 0x07;
1242 *pbuffer++ = 0x35;
1243 *pbuffer++ = 0xff;
1244 *pbuffer++ = 0xff;
1245 *pbuffer++ = 0xfe;
1246
1247
1248
1249
1250 memcpy(pbuffer, ft1000dev->rx_buf+sizeof(struct pseudo_hdr), len-sizeof(struct pseudo_hdr));
1251
1252
1253
1254
1255
1256
1257
1258 skb->dev = net;
1259
1260 skb->protocol = eth_type_trans(skb, net);
1261 skb->ip_summed = CHECKSUM_UNNECESSARY;
1262 netif_rx(skb);
1263
1264 info->stats.rx_packets++;
1265
1266 info->stats.rx_bytes += (lena+12);
1267
1268 ft1000_submit_rx_urb(info);
1269
1270 return SUCCESS;
1271}
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286static int ft1000_submit_rx_urb(struct ft1000_info *info)
1287{
1288 int result;
1289 struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1290
1291
1292
1293 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1294 {
1295 DEBUG("network driver is closed, return\n");
1296
1297 return -ENODEV;
1298 }
1299
1300 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1301 pFt1000Dev->dev,
1302 usb_rcvbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_in_endpointAddr),
1303 pFt1000Dev->rx_buf,
1304 MAX_BUF_SIZE,
1305 (usb_complete_t)ft1000_copy_up_pkt,
1306 info);
1307
1308
1309 if((result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC)))
1310 {
1311 printk("ft1000_submit_rx_urb: submitting rx_urb %d failed\n", result);
1312 return result;
1313 }
1314
1315
1316
1317 return 0;
1318}
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334static int ft1000_open (struct net_device *dev)
1335{
1336 struct ft1000_info *pInfo = netdev_priv(dev);
1337 struct timeval tv;
1338 int ret;
1339
1340 DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1341
1342
1343 pInfo->stats.rx_bytes = 0;
1344 pInfo->stats.tx_bytes = 0;
1345 pInfo->stats.rx_packets = 0;
1346 pInfo->stats.tx_packets = 0;
1347 do_gettimeofday(&tv);
1348 pInfo->ConTm = tv.tv_sec;
1349 pInfo->ProgConStat = 0;
1350
1351
1352 netif_start_queue(dev);
1353
1354 netif_carrier_on(dev);
1355
1356 ret = ft1000_submit_rx_urb(pInfo);
1357
1358 return ret;
1359}
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375int ft1000_close(struct net_device *net)
1376{
1377 struct ft1000_info *pInfo = netdev_priv(net);
1378 struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1379
1380
1381
1382 ft1000dev->status |= FT1000_STATUS_CLOSING;
1383
1384
1385
1386 DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1387 netif_carrier_off(net);
1388 netif_stop_queue(net);
1389
1390 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1391
1392 pInfo->ProgConStat = 0xff;
1393
1394
1395 return 0;
1396}
1397
1398static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1399{
1400 struct ft1000_info *info = netdev_priv(dev);
1401
1402 return &(info->stats);
1403}
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423static int ft1000_chkcard (struct ft1000_device *dev) {
1424 u16 tempword;
1425 u16 status;
1426 struct ft1000_info *info = netdev_priv(dev->net);
1427
1428 if (info->fCondResetPend)
1429 {
1430 DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1431 return TRUE;
1432 }
1433
1434
1435
1436 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1437
1438 if (tempword == 0) {
1439 DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1440 return FALSE;
1441 }
1442
1443
1444
1445 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1446
1447 if (tempword != 0x1b01 ){
1448 dev->status |= FT1000_STATUS_CLOSING;
1449 DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1450 return FALSE;
1451 }
1452 return TRUE;
1453}
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470static bool ft1000_receive_cmd (struct ft1000_device *dev, u16 *pbuffer, int maxsz, u16 *pnxtph) {
1471 u16 size, ret;
1472 u16 *ppseudohdr;
1473 int i;
1474 u16 tempword;
1475
1476 ret = ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size, FT1000_MAG_PH_LEN_INDX);
1477 size = ntohs(size) + PSEUDOSZ;
1478 if (size > maxsz) {
1479 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n", size);
1480 return FALSE;
1481 }
1482 else {
1483 ppseudohdr = (u16 *)pbuffer;
1484 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
1485 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1486
1487 pbuffer++;
1488 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE+1, FT1000_REG_DPRAM_ADDR);
1489 for (i=0; i<=(size>>2); i++) {
1490 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1491 pbuffer++;
1492 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1493 pbuffer++;
1494 }
1495
1496 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1497
1498 pbuffer++;
1499 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1500
1501 pbuffer++;
1502 if (size & 0x0001) {
1503
1504 ret = ft1000_read_register(dev, &tempword, FT1000_REG_DPRAM_DATA);
1505 *pbuffer = ntohs(tempword);
1506 }
1507
1508
1509
1510 tempword = *ppseudohdr++;
1511 for (i=1; i<7; i++) {
1512 tempword ^= *ppseudohdr++;
1513 }
1514 if ( (tempword != *ppseudohdr) ) {
1515 return FALSE;
1516 }
1517
1518 return TRUE;
1519 }
1520}
1521
1522
1523static int ft1000_dsp_prov(void *arg)
1524{
1525 struct ft1000_device *dev = (struct ft1000_device *)arg;
1526 struct ft1000_info *info = netdev_priv(dev->net);
1527 u16 tempword;
1528 u16 len;
1529 u16 i=0;
1530 struct prov_record *ptr;
1531 struct pseudo_hdr *ppseudo_hdr;
1532 u16 *pmsg;
1533 u16 status;
1534 u16 TempShortBuf [256];
1535
1536 DEBUG("*** DspProv Entered\n");
1537
1538 while (list_empty(&info->prov_list) == 0)
1539 {
1540 DEBUG("DSP Provisioning List Entry\n");
1541
1542
1543 DEBUG("check if doorbell is cleared\n");
1544 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1545 if (status)
1546 {
1547 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1548 break;
1549 }
1550
1551 while (tempword & FT1000_DB_DPRAM_TX) {
1552 mdelay(10);
1553 i++;
1554 if (i==10) {
1555 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1556 return STATUS_FAILURE;
1557 }
1558 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1559 }
1560
1561 if ( !(tempword & FT1000_DB_DPRAM_TX) ) {
1562 DEBUG("*** Provision Data Sent to DSP\n");
1563
1564
1565 ptr = list_entry(info->prov_list.next, struct prov_record, list);
1566 len = *(u16 *)ptr->pprov_data;
1567 len = htons(len);
1568 len += PSEUDOSZ;
1569
1570 pmsg = (u16 *)ptr->pprov_data;
1571 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1572
1573 ppseudo_hdr->seq_num = info->squeseqnum++;
1574 ppseudo_hdr->portsrc = 0;
1575
1576 ppseudo_hdr->checksum = *pmsg++;
1577
1578 for (i=1; i<7; i++) {
1579 ppseudo_hdr->checksum ^= *pmsg++;
1580
1581 }
1582
1583 TempShortBuf[0] = 0;
1584 TempShortBuf[1] = htons (len);
1585 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1586
1587 status = ft1000_write_dpram32 (dev, 0, (u8 *)&TempShortBuf[0], (unsigned short)(len+2));
1588 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1589
1590 list_del(&ptr->list);
1591 kfree(ptr->pprov_data);
1592 kfree(ptr);
1593 }
1594 msleep(10);
1595 }
1596
1597 DEBUG("DSP Provisioning List Entry finished\n");
1598
1599 msleep(100);
1600
1601 info->fProvComplete = 1;
1602 info->CardReady = 1;
1603 return STATUS_SUCCESS;
1604
1605}
1606
1607
1608static int ft1000_proc_drvmsg (struct ft1000_device *dev, u16 size) {
1609 struct ft1000_info *info = netdev_priv(dev->net);
1610 u16 msgtype;
1611 u16 tempword;
1612 struct media_msg *pmediamsg;
1613 struct dsp_init_msg *pdspinitmsg;
1614 struct drv_msg *pdrvmsg;
1615 u16 i;
1616 struct pseudo_hdr *ppseudo_hdr;
1617 u16 *pmsg;
1618 u16 status;
1619 union {
1620 u8 byte[2];
1621 u16 wrd;
1622 } convert;
1623
1624
1625 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1626 if (!cmdbuffer)
1627 return STATUS_FAILURE;
1628
1629 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1630
1631
1632
1633#ifdef JDEBUG
1634 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1635 for(i = 0; i < size; i+=5)
1636 {
1637 if( (i + 5) < size )
1638 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i], cmdbuffer[i+1], cmdbuffer[i+2], cmdbuffer[i+3], cmdbuffer[i+4]);
1639 else
1640 {
1641 for (j = i; j < size; j++)
1642 DEBUG("0x%x ", cmdbuffer[j]);
1643 DEBUG("\n");
1644 break;
1645 }
1646 }
1647#endif
1648 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1649 msgtype = ntohs(pdrvmsg->type);
1650 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1651 switch (msgtype) {
1652 case MEDIA_STATE: {
1653 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1654
1655 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1656 if (info->ProgConStat != 0xFF) {
1657 if (pmediamsg->state) {
1658 DEBUG("Media is up\n");
1659 if (info->mediastate == 0) {
1660 if ( info->NetDevRegDone )
1661 {
1662
1663 netif_wake_queue(dev->net);
1664 }
1665 info->mediastate = 1;
1666
1667
1668 }
1669 }
1670 else {
1671 DEBUG("Media is down\n");
1672 if (info->mediastate == 1) {
1673 info->mediastate = 0;
1674 if ( info->NetDevRegDone )
1675 {
1676
1677
1678 }
1679 info->ConTm = 0;
1680 }
1681 }
1682 }
1683 else {
1684 DEBUG("Media is down\n");
1685 if (info->mediastate == 1) {
1686 info->mediastate = 0;
1687 if ( info->NetDevRegDone)
1688 {
1689
1690
1691 }
1692 info->ConTm = 0;
1693 }
1694 }
1695 break;
1696 }
1697 case DSP_INIT_MSG: {
1698 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1699
1700 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1701 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1702 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n", info->DspVer[0], info->DspVer[1], info->DspVer[2], info->DspVer[3]);
1703 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum, HWSERNUMSZ);
1704 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1705 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1706 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n", info->eui64[0],info->eui64[1], info->eui64[2], info->eui64[3], info->eui64[4], info->eui64[5],info->eui64[6], info->eui64[7]);
1707 dev->net->dev_addr[0] = info->eui64[0];
1708 dev->net->dev_addr[1] = info->eui64[1];
1709 dev->net->dev_addr[2] = info->eui64[2];
1710 dev->net->dev_addr[3] = info->eui64[5];
1711 dev->net->dev_addr[4] = info->eui64[6];
1712 dev->net->dev_addr[5] = info->eui64[7];
1713
1714 if (ntohs(pdspinitmsg->length) == (sizeof(struct dsp_init_msg) - 20)) {
1715 memcpy(info->ProductMode, pdspinitmsg->ProductMode, MODESZ);
1716 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1717 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate, CALDATESZ);
1718 DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0], info->RfCalVer[1]);
1719 }
1720 break;
1721 }
1722 case DSP_PROVISION: {
1723 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1724
1725
1726
1727 if (list_empty(&info->prov_list) == 0)
1728 {
1729 info->fProvComplete = 0;
1730 status = ft1000_dsp_prov(dev);
1731 if (status != STATUS_SUCCESS)
1732 goto out;
1733 }
1734 else {
1735 info->fProvComplete = 1;
1736 status = ft1000_write_register (dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
1737 DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1738 }
1739 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1740 break;
1741 }
1742 case DSP_STORE_INFO: {
1743 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1744
1745 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1746 tempword = ntohs(pdrvmsg->length);
1747 info->DSPInfoBlklen = tempword;
1748 if (tempword < (MAX_DSP_SESS_REC-4) ) {
1749 pmsg = (u16 *)&pdrvmsg->data[0];
1750 for (i=0; i<((tempword+1)/2); i++) {
1751 DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
1752 info->DSPInfoBlk[i+10] = *pmsg++;
1753 }
1754 }
1755 else {
1756 info->DSPInfoBlklen = 0;
1757 }
1758 break;
1759 }
1760 case DSP_GET_INFO: {
1761 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1762
1763 info->DrvMsgPend = 1;
1764
1765 mdelay(10);
1766 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1767 if (tempword & FT1000_DB_DPRAM_TX) {
1768 mdelay(10);
1769 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1770 if (tempword & FT1000_DB_DPRAM_TX) {
1771 mdelay(10);
1772 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1773 if (tempword & FT1000_DB_DPRAM_TX) {
1774 break;
1775 }
1776 }
1777 }
1778
1779
1780
1781 pmsg = (u16 *)info->DSPInfoBlk;
1782 *pmsg++ = 0;
1783 *pmsg++ = htons(info->DSPInfoBlklen+20+info->DSPInfoBlklen);
1784 ppseudo_hdr = (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1785 ppseudo_hdr->length = htons(info->DSPInfoBlklen+4+info->DSPInfoBlklen);
1786 ppseudo_hdr->source = 0x10;
1787 ppseudo_hdr->destination = 0x20;
1788 ppseudo_hdr->portdest = 0;
1789 ppseudo_hdr->portsrc = 0;
1790 ppseudo_hdr->sh_str_id = 0;
1791 ppseudo_hdr->control = 0;
1792 ppseudo_hdr->rsvd1 = 0;
1793 ppseudo_hdr->rsvd2 = 0;
1794 ppseudo_hdr->qos_class = 0;
1795
1796 ppseudo_hdr->seq_num = info->squeseqnum++;
1797
1798 ppseudo_hdr->portsrc = 0;
1799
1800 ppseudo_hdr->checksum = *pmsg++;
1801 for (i=1; i<7; i++) {
1802 ppseudo_hdr->checksum ^= *pmsg++;
1803 }
1804 info->DSPInfoBlk[10] = 0x7200;
1805 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1806 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPInfoBlk[0], (unsigned short)(info->DSPInfoBlklen+22));
1807 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1808 info->DrvMsgPend = 0;
1809
1810 break;
1811 }
1812
1813 case GET_DRV_ERR_RPT_MSG: {
1814 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1815
1816 info->DrvMsgPend = 1;
1817
1818 mdelay(10);
1819 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1820 if (tempword & FT1000_DB_DPRAM_TX) {
1821 mdelay(10);
1822 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1823 if (tempword & FT1000_DB_DPRAM_TX) {
1824 mdelay(10);
1825 }
1826 }
1827
1828 if ( (tempword & FT1000_DB_DPRAM_TX) == 0) {
1829
1830
1831 pmsg = (u16 *)&tempbuffer[0];
1832 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1833 ppseudo_hdr->length = htons(0x0012);
1834 ppseudo_hdr->source = 0x10;
1835 ppseudo_hdr->destination = 0x20;
1836 ppseudo_hdr->portdest = 0;
1837 ppseudo_hdr->portsrc = 0;
1838 ppseudo_hdr->sh_str_id = 0;
1839 ppseudo_hdr->control = 0;
1840 ppseudo_hdr->rsvd1 = 0;
1841 ppseudo_hdr->rsvd2 = 0;
1842 ppseudo_hdr->qos_class = 0;
1843
1844 ppseudo_hdr->seq_num = info->squeseqnum++;
1845
1846 ppseudo_hdr->portsrc = 0;
1847
1848 ppseudo_hdr->checksum = *pmsg++;
1849 for (i=1; i<7; i++) {
1850 ppseudo_hdr->checksum ^= *pmsg++;
1851 }
1852 pmsg = (u16 *)&tempbuffer[16];
1853 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1854 *pmsg++ = htons(0x000e);
1855 *pmsg++ = htons(info->DSP_TIME[0]);
1856 *pmsg++ = htons(info->DSP_TIME[1]);
1857 *pmsg++ = htons(info->DSP_TIME[2]);
1858 *pmsg++ = htons(info->DSP_TIME[3]);
1859 convert.byte[0] = info->DspVer[0];
1860 convert.byte[1] = info->DspVer[1];
1861 *pmsg++ = convert.wrd;
1862 convert.byte[0] = info->DspVer[2];
1863 convert.byte[1] = info->DspVer[3];
1864 *pmsg++ = convert.wrd;
1865 *pmsg++ = htons(info->DrvErrNum);
1866
1867 CardSendCommand (dev, (unsigned char*)&tempbuffer[0], (u16)(0x0012 + PSEUDOSZ));
1868 info->DrvErrNum = 0;
1869 }
1870 info->DrvMsgPend = 0;
1871
1872 break;
1873 }
1874
1875 default:
1876 break;
1877 }
1878
1879
1880 status = STATUS_SUCCESS;
1881out:
1882 kfree(cmdbuffer);
1883 DEBUG("return from ft1000_proc_drvmsg\n");
1884 return status;
1885}
1886
1887
1888
1889int ft1000_poll(void* dev_id) {
1890
1891 struct ft1000_device *dev = (struct ft1000_device *)dev_id;
1892 struct ft1000_info *info = netdev_priv(dev->net);
1893
1894 u16 tempword;
1895 u16 status;
1896 u16 size;
1897 int i;
1898 u16 data;
1899 u16 modulo;
1900 u16 portid;
1901 u16 nxtph;
1902 struct dpram_blk *pdpram_blk;
1903 struct pseudo_hdr *ppseudo_hdr;
1904 unsigned long flags;
1905
1906
1907 if (ft1000_chkcard(dev) == FALSE) {
1908 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1909 return STATUS_FAILURE;
1910 }
1911
1912 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1913
1914
1915 if ( !status )
1916 {
1917
1918 if (tempword & FT1000_DB_DPRAM_RX) {
1919
1920
1921 status = ft1000_read_dpram16(dev, 0x200, (u8 *)&data, 0);
1922
1923 size = ntohs(data) + 16 + 2;
1924 if (size % 4) {
1925 modulo = 4 - (size % 4);
1926 size = size + modulo;
1927 }
1928 status = ft1000_read_dpram16(dev, 0x201, (u8 *)&portid, 1);
1929 portid &= 0xff;
1930
1931
1932 if (size < MAX_CMD_SQSIZE) {
1933 switch (portid)
1934 {
1935 case DRIVERID:
1936 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1937
1938 status = ft1000_proc_drvmsg (dev, size);
1939 if (status != STATUS_SUCCESS )
1940 return status;
1941 break;
1942 case DSPBCMSGID:
1943
1944
1945
1946
1947 for (i=0; i<MAX_NUM_APP; i++) {
1948 if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
1949 (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT) )
1950 {
1951
1952 nxtph = FT1000_DPRAM_RX_BASE + 2;
1953 pdpram_blk = ft1000_get_buffer (&freercvpool);
1954 if (pdpram_blk != NULL) {
1955 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1956 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1957
1958 info->app_info[i].nRxMsg++;
1959 spin_lock_irqsave(&free_buff_lock, flags);
1960 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1961 info->app_info[i].NumOfMsg++;
1962 spin_unlock_irqrestore(&free_buff_lock, flags);
1963 wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1964 }
1965 else {
1966 info->app_info[i].nRxMsgMiss++;
1967
1968 ft1000_free_buffer(pdpram_blk, &freercvpool);
1969 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1970 }
1971 }
1972 else {
1973 DEBUG("Out of memory in free receive command pool\n");
1974 info->app_info[i].nRxMsgMiss++;
1975 }
1976 }
1977
1978
1979 }
1980 break;
1981 default:
1982 pdpram_blk = ft1000_get_buffer (&freercvpool);
1983
1984 if (pdpram_blk != NULL) {
1985 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1986 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1987
1988 for (i=0; i<MAX_NUM_APP; i++) {
1989 if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
1990 break;
1991 }
1992 }
1993
1994 if (i == MAX_NUM_APP) {
1995 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
1996
1997 ft1000_free_buffer(pdpram_blk, &freercvpool);
1998 }
1999 else {
2000 if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
2001
2002 ft1000_free_buffer(pdpram_blk, &freercvpool);
2003 }
2004 else {
2005 info->app_info[i].nRxMsg++;
2006
2007
2008 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
2009 info->app_info[i].NumOfMsg++;
2010
2011
2012 }
2013 }
2014 }
2015 else {
2016
2017 ft1000_free_buffer(pdpram_blk, &freercvpool);
2018 }
2019 }
2020 else {
2021 DEBUG("Out of memory in free receive command pool\n");
2022 }
2023 break;
2024 }
2025 }
2026 else {
2027 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
2028 }
2029 status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
2030 }
2031 else if (tempword & FT1000_DSP_ASIC_RESET) {
2032
2033
2034
2035 status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
2036 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2037 i = 0;
2038 while (tempword & ASIC_RESET_BIT) {
2039 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2040 msleep(10);
2041 i++;
2042 if (i==100)
2043 break;
2044 }
2045 if (i==100) {
2046 DEBUG("Unable to reset ASIC\n");
2047 return STATUS_SUCCESS;
2048 }
2049 msleep(10);
2050
2051 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2052
2053 status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
2054 msleep(10);
2055 }
2056 else if (tempword & FT1000_ASIC_RESET_REQ) {
2057 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
2058
2059
2060 status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
2061 status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
2062
2063 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPSess.Rec[0], 1024);
2064
2065 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2066
2067 status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
2068 }
2069 else if (tempword & FT1000_DB_COND_RESET) {
2070 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
2071
2072
2073
2074 if (info->fAppMsgPend == 0) {
2075
2076
2077 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (u8 *)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2078 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (u8 *)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2079 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (u8 *)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2080 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (u8 *)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2081 info->CardReady = 0;
2082 info->DrvErrNum = DSP_CONDRESET_INFO;
2083 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2084 info->ft1000_reset(dev->net);
2085 }
2086 else {
2087 info->fProvComplete = 0;
2088 info->fCondResetPend = 1;
2089 }
2090
2091 ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2092 }
2093
2094 }
2095
2096
2097 return STATUS_SUCCESS;
2098
2099}
2100
2101
2102