projects / deliverable / linux.git / blob
? search:


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