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


958292e8178a5e7b50dfc049965a31e9101aa6f4
[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,
485 int size)
486 {
487 unsigned short temp;
488 unsigned char *commandbuf;
489
490 DEBUG("card_send_command: enter card_send_command... size=%d\n", size);
491
492 commandbuf = (unsigned char *)kmalloc(size + 2, GFP_KERNEL);
493 memcpy((void *)commandbuf + 2, (void *)ptempbuffer, size);
494
495 //DEBUG("card_send_command: Command Send\n");
496
497 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
498
499 if (temp & 0x0100)
500 msleep(10);
501
502 /* check for odd word */
503 size = size + 2;
504
505 /* Must force to be 32 bit aligned */
506 if (size % 4)
507 size += 4 - (size % 4);
508
509 //DEBUG("card_send_command: write dpram ... size=%d\n", size);
510 ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
511 msleep(1);
512 //DEBUG("card_send_command: write into doorbell ...\n");
513 ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
514 FT1000_REG_DOORBELL);
515 msleep(1);
516
517 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
518 //DEBUG("card_send_command: read doorbell ...temp=%x\n", temp);
519 if ((temp & 0x0100) == 0) {
520 //DEBUG("card_send_command: Message sent\n");
521 }
522
523 }
524
525 //--------------------------------------------------------------------------
526 //
527 // Function: dsp_reload
528 //
529 // Synopsis: This function is called to load or reload the DSP
530 //
531 // Arguments: ft1000dev - device structure
532 //
533 // Returns: None
534 //-----------------------------------------------------------------------
535 int dsp_reload(struct ft1000_device *ft1000dev)
536 {
537 u16 status;
538 u16 tempword;
539 u32 templong;
540
541 struct ft1000_info *pft1000info;
542
543 pft1000info = netdev_priv(ft1000dev->net);
544
545 pft1000info->CardReady = 0;
546
547 /* Program Interrupt Mask register */
548 status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
549
550 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
551 tempword |= ASIC_RESET_BIT;
552 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
553 msleep(1000);
554 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
555 DEBUG("Reset Register = 0x%x\n", tempword);
556
557 /* Toggle DSP reset */
558 card_reset_dsp(ft1000dev, 1);
559 msleep(1000);
560 card_reset_dsp(ft1000dev, 0);
561 msleep(1000);
562
563 status =
564 ft1000_write_register(ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
565
566 /* Let's check for FEFE */
567 status =
568 ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
569 (u8 *) &templong, 4);
570 DEBUG("templong (fefe) = 0x%8x\n", templong);
571
572 /* call codeloader */
573 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
574
575 if (status != STATUS_SUCCESS)
576 return -EIO;
577
578 msleep(1000);
579
580 DEBUG("dsp_reload returned\n");
581
582 return 0;
583 }
584
585 //---------------------------------------------------------------------------
586 //
587 // Function: ft1000_reset_asic
588 // Descripton: This function will call the Card Service function to reset the
589 // ASIC.
590 // Input:
591 // dev - device structure
592 // Output:
593 // none
594 //
595 //---------------------------------------------------------------------------
596 static void ft1000_reset_asic(struct net_device *dev)
597 {
598 struct ft1000_info *info = netdev_priv(dev);
599 struct ft1000_device *ft1000dev = info->pFt1000Dev;
600 u16 tempword;
601
602 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
603
604 info->ASICResetNum++;
605
606 /* Let's use the register provided by the Magnemite ASIC to reset the
607 * ASIC and DSP.
608 */
609 ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT),
610 FT1000_REG_RESET);
611
612 mdelay(1);
613
614 /* set watermark to -1 in order to not generate an interrrupt */
615 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
616
617 /* clear interrupts */
618 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
619 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
620 ft1000_write_register(ft1000dev, tempword, FT1000_REG_SUP_ISR);
621 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
622 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
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_reset_card:deleting provisioning record\n");
653 ptr =
654 list_entry(info->prov_list.next, struct prov_record, list);
655 list_del(&ptr->list);
656 kfree(ptr->pprov_data);
657 kfree(ptr);
658 }
659
660 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
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 mdelay(10);
671
672 /* Initialize DSP heartbeat area */
673 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
674 FT1000_MAG_HI_HO_INDX);
675 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *) &tempword,
676 FT1000_MAG_HI_HO_INDX);
677 DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
678
679 info->CardReady = 1;
680
681 info->fCondResetPend = 0;
682
683 return TRUE;
684 }
685
686
687 //mbelian
688 #ifdef HAVE_NET_DEVICE_OPS
689 static const struct net_device_ops ftnet_ops =
690 {
691 .ndo_open = &ft1000_open,
692 .ndo_stop = &ft1000_close,
693 .ndo_start_xmit = &ft1000_start_xmit,
694 .ndo_get_stats = &ft1000_netdev_stats,
695 };
696 #endif
697
698
699 //---------------------------------------------------------------------------
700 // Function: init_ft1000_netdev
701 //
702 // Parameters: ft1000dev - device structure
703 //
704 //
705 // Returns: STATUS_SUCCESS - success
706 // STATUS_FAILURE - failure
707 //
708 // Description: This function initialize the network device
709 //
710 // Notes:
711 //
712 //---------------------------------------------------------------------------
713 int init_ft1000_netdev(struct ft1000_device *ft1000dev)
714 {
715 struct net_device *netdev;
716 struct ft1000_info *pInfo = NULL;
717 struct dpram_blk *pdpram_blk;
718 int i, ret_val;
719 struct list_head *cur, *tmp;
720 char card_nr[2];
721 unsigned long gCardIndex = 0;
722
723 DEBUG("Enter init_ft1000_netdev...\n");
724
725 netdev = alloc_etherdev(sizeof(struct ft1000_info));
726 if (!netdev) {
727 DEBUG("init_ft1000_netdev: can not allocate network device\n");
728 return -ENOMEM;
729 }
730
731 pInfo = netdev_priv(netdev);
732
733 memset(pInfo, 0, sizeof(struct ft1000_info));
734
735 dev_alloc_name(netdev, netdev->name);
736
737 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
738
739 if (strncmp(netdev->name, "eth", 3) == 0) {
740 card_nr[0] = netdev->name[3];
741 card_nr[1] = '\0';
742 ret_val = strict_strtoul(card_nr, 10, &gCardIndex);
743 if (ret_val) {
744 printk(KERN_ERR "Can't parse netdev\n");
745 goto err_net;
746 }
747
748 pInfo->CardNumber = gCardIndex;
749 DEBUG("card number = %d\n", pInfo->CardNumber);
750 } else {
751 printk(KERN_ERR "ft1000: Invalid device name\n");
752 ret_val = -ENXIO;
753 goto err_net;
754 }
755
756 memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
757
758 spin_lock_init(&pInfo->dpram_lock);
759 pInfo->pFt1000Dev = ft1000dev;
760 pInfo->DrvErrNum = 0;
761 pInfo->ASICResetNum = 0;
762 pInfo->registered = 1;
763 pInfo->ft1000_reset = ft1000_reset;
764 pInfo->mediastate = 0;
765 pInfo->fifo_cnt = 0;
766 pInfo->DeviceCreated = FALSE;
767 pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
768 pInfo->InterruptsEnabled = FALSE;
769 pInfo->CardReady = 0;
770 pInfo->DSP_TIME[0] = 0;
771 pInfo->DSP_TIME[1] = 0;
772 pInfo->DSP_TIME[2] = 0;
773 pInfo->DSP_TIME[3] = 0;
774 pInfo->fAppMsgPend = 0;
775 pInfo->fCondResetPend = 0;
776 pInfo->usbboot = 0;
777 pInfo->dspalive = 0;
778 memset(&pInfo->tempbuf[0], 0, sizeof(pInfo->tempbuf));
779
780 INIT_LIST_HEAD(&pInfo->prov_list);
781
782 INIT_LIST_HEAD(&pInfo->nodes.list);
783
784 #ifdef HAVE_NET_DEVICE_OPS
785 netdev->netdev_ops = &ftnet_ops;
786 #else
787 netdev->hard_start_xmit = &ft1000_start_xmit;
788 netdev->get_stats = &ft1000_netdev_stats;
789 netdev->open = &ft1000_open;
790 netdev->stop = &ft1000_close;
791 #endif
792
793 ft1000dev->net = netdev;
794
795 DEBUG("Initialize free_buff_lock and freercvpool\n");
796 spin_lock_init(&free_buff_lock);
797
798 /* initialize a list of buffers to be use for queuing
799 * up receive command data
800 */
801 INIT_LIST_HEAD(&freercvpool);
802
803 /* create list of free buffers */
804 for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
805 /* Get memory for DPRAM_DATA link list */
806 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
807 if (pdpram_blk == NULL) {
808 ret_val = -ENOMEM;
809 goto err_free;
810 }
811 /* Get a block of memory to store command data */
812 pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
813 if (pdpram_blk->pbuffer == NULL) {
814 ret_val = -ENOMEM;
815 kfree(pdpram_blk);
816 goto err_free;
817 }
818 /* link provisioning data */
819 list_add_tail(&pdpram_blk->list, &freercvpool);
820 }
821 numofmsgbuf = NUM_OF_FREE_BUFFERS;
822
823 return 0;
824
825 err_free:
826 list_for_each_safe(cur, tmp, &freercvpool) {
827 pdpram_blk = list_entry(cur, struct dpram_blk, list);
828 list_del(&pdpram_blk->list);
829 kfree(pdpram_blk->pbuffer);
830 kfree(pdpram_blk);
831 }
832 err_net:
833 free_netdev(netdev);
834 return ret_val;
835 }
836
837 //---------------------------------------------------------------------------
838 // Function: reg_ft1000_netdev
839 //
840 // Parameters: ft1000dev - device structure
841 //
842 //
843 // Returns: STATUS_SUCCESS - success
844 // STATUS_FAILURE - failure
845 //
846 // Description: This function register the network driver
847 //
848 // Notes:
849 //
850 //---------------------------------------------------------------------------
851 int reg_ft1000_netdev(struct ft1000_device *ft1000dev,
852 struct usb_interface *intf)
853 {
854 struct net_device *netdev;
855 struct ft1000_info *pInfo;
856 int rc;
857
858 netdev = ft1000dev->net;
859 pInfo = netdev_priv(ft1000dev->net);
860 DEBUG("Enter reg_ft1000_netdev...\n");
861
862 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
863
864 usb_set_intfdata(intf, pInfo);
865 SET_NETDEV_DEV(netdev, &intf->dev);
866
867 rc = register_netdev(netdev);
868 if (rc) {
869 DEBUG("reg_ft1000_netdev: could not register network device\n");
870 free_netdev(netdev);
871 return rc;
872 }
873
874 ft1000_create_dev(ft1000dev);
875
876 DEBUG("reg_ft1000_netdev returned\n");
877
878 pInfo->CardReady = 1;
879
880 return 0;
881 }
882
883 static int ft1000_reset(struct net_device *dev)
884 {
885 ft1000_reset_card(dev);
886 return 0;
887 }
888
889 //---------------------------------------------------------------------------
890 // Function: ft1000_usb_transmit_complete
891 //
892 // Parameters: urb - transmitted usb urb
893 //
894 //
895 // Returns: none
896 //
897 // Description: This is the callback function when a urb is transmitted
898 //
899 // Notes:
900 //
901 //---------------------------------------------------------------------------
902 static void ft1000_usb_transmit_complete(struct urb *urb)
903 {
904
905 struct ft1000_device *ft1000dev = urb->context;
906
907 //DEBUG("ft1000_usb_transmit_complete entered\n");
908
909 if (urb->status)
910 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
911
912 netif_wake_queue(ft1000dev->net);
913
914 //DEBUG("Return from ft1000_usb_transmit_complete\n");
915 }
916
917 //---------------------------------------------------------------------------
918 //
919 // Function: ft1000_copy_down_pkt
920 // Descripton: This function will take an ethernet packet and convert it to
921 // a Flarion packet prior to sending it to the ASIC Downlink
922 // FIFO.
923 // Input:
924 // dev - device structure
925 // packet - address of ethernet packet
926 // len - length of IP packet
927 // Output:
928 // status - FAILURE
929 // SUCCESS
930 //
931 //---------------------------------------------------------------------------
932 static int ft1000_copy_down_pkt (struct net_device *netdev, u8 *packet, u16 len)
933 {
934 struct ft1000_info *pInfo = netdev_priv(netdev);
935 struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
936
937
938 int count, ret;
939 u8 *t;
940 struct pseudo_hdr hdr;
941
942 if (!pInfo->CardReady)
943 {
944
945 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
946 return -ENODEV;
947
948 }
949
950
951 //DEBUG("ft1000_copy_down_pkt() entered, len = %d\n", len);
952
953 count = sizeof(struct pseudo_hdr) + len;
954 if(count > MAX_BUF_SIZE)
955 {
956 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
957 DEBUG("size = %d\n", count);
958 return -EINVAL;
959 }
960
961 if ( count % 4)
962 count = count + (4- (count %4) );
963
964 memset(&hdr, 0, sizeof(struct pseudo_hdr));
965
966 hdr.length = ntohs(count);
967 hdr.source = 0x10;
968 hdr.destination = 0x20;
969 hdr.portdest = 0x20;
970 hdr.portsrc = 0x10;
971 hdr.sh_str_id = 0x91;
972 hdr.control = 0x00;
973
974 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
975 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^
976 hdr.control;
977
978 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
979 memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
980
981 netif_stop_queue(netdev);
982
983 //DEBUG ("ft1000_copy_down_pkt: count = %d\n", count);
984
985 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
986 pFt1000Dev->dev,
987 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr),
988 pFt1000Dev->tx_buf,
989 count,
990 ft1000_usb_transmit_complete,
991 (void*)pFt1000Dev);
992
993 t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
994 //DEBUG("transfer_length=%d\n", pFt1000Dev->tx_urb->transfer_buffer_length);
995 /*for (i=0; i<count; i++ )
996 {
997 DEBUG("%x ", *t++ );
998 }*/
999
1000
1001 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
1002 if (ret) {
1003 DEBUG("ft1000 failed tx_urb %d\n", ret);
1004 return ret;
1005 } else {
1006 pInfo->stats.tx_packets++;
1007 pInfo->stats.tx_bytes += (len+14);
1008 }
1009
1010 //DEBUG("ft1000_copy_down_pkt() exit\n");
1011
1012 return 0;
1013 }
1014
1015 //---------------------------------------------------------------------------
1016 // Function: ft1000_start_xmit
1017 //
1018 // Parameters: skb - socket buffer to be sent
1019 // dev - network device
1020 //
1021 //
1022 // Returns: none
1023 //
1024 // Description: transmit a ethernet packet
1025 //
1026 // Notes:
1027 //
1028 //---------------------------------------------------------------------------
1029 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1030 {
1031 struct ft1000_info *pInfo = netdev_priv(dev);
1032 struct ft1000_device *pFt1000Dev= pInfo->pFt1000Dev;
1033 u8 *pdata;
1034 int maxlen, pipe;
1035
1036
1037 //DEBUG(" ft1000_start_xmit() entered\n");
1038
1039 if ( skb == NULL )
1040 {
1041 DEBUG ("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n" );
1042 return NETDEV_TX_OK;
1043 }
1044
1045 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1046 {
1047 DEBUG("network driver is closed, return\n");
1048 goto err;
1049 }
1050
1051 //DEBUG("ft1000_start_xmit 1:length of packet = %d\n", skb->len);
1052 pipe = usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1053 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1054 //DEBUG("ft1000_start_xmit 2: pipe=%d dev->maxpacket = %d\n", pipe, maxlen);
1055
1056 pdata = (u8 *)skb->data;
1057 /*for (i=0; i<skb->len; i++)
1058 DEBUG("skb->data[%d]=%x ", i, *(skb->data+i));
1059
1060 DEBUG("\n");*/
1061
1062
1063 if (pInfo->mediastate == 0)
1064 {
1065 /* Drop packet is mediastate is down */
1066 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1067 goto err;
1068 }
1069
1070 if ( (skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE) )
1071 {
1072 /* Drop packet which has invalid size */
1073 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1074 goto err;
1075 }
1076 //mbelian
1077 ft1000_copy_down_pkt(dev, (pdata+ENET_HEADER_SIZE-2),
1078 skb->len - ENET_HEADER_SIZE + 2);
1079
1080 err:
1081 dev_kfree_skb(skb);
1082 //DEBUG(" ft1000_start_xmit() exit\n");
1083
1084 return NETDEV_TX_OK;
1085 }
1086
1087 //---------------------------------------------------------------------------
1088 //
1089 // Function: ft1000_copy_up_pkt
1090 // Descripton: This function will take a packet from the FIFO up link and
1091 // convert it into an ethernet packet and deliver it to the IP stack
1092 // Input:
1093 // urb - the receving usb urb
1094 //
1095 // Output:
1096 // status - FAILURE
1097 // SUCCESS
1098 //
1099 //---------------------------------------------------------------------------
1100 static int ft1000_copy_up_pkt (struct urb *urb)
1101 {
1102 struct ft1000_info *info = urb->context;
1103 struct ft1000_device *ft1000dev = info->pFt1000Dev;
1104 struct net_device *net = ft1000dev->net;
1105
1106 u16 tempword;
1107 u16 len;
1108 u16 lena; //mbelian
1109 struct sk_buff *skb;
1110 u16 i;
1111 u8 *pbuffer=NULL;
1112 u8 *ptemp=NULL;
1113 u16 *chksum;
1114
1115
1116 //DEBUG("ft1000_copy_up_pkt entered\n");
1117
1118 if ( ft1000dev->status & FT1000_STATUS_CLOSING)
1119 {
1120 DEBUG("network driver is closed, return\n");
1121 return STATUS_SUCCESS;
1122 }
1123
1124 // Read length
1125 len = urb->transfer_buffer_length;
1126 lena = urb->actual_length; //mbelian
1127 //DEBUG("ft1000_copy_up_pkt: transfer_buffer_length=%d, actual_buffer_len=%d\n",
1128 // urb->transfer_buffer_length, urb->actual_length);
1129
1130 chksum = (u16 *)ft1000dev->rx_buf;
1131
1132 tempword = *chksum++;
1133 for (i=1; i<7; i++)
1134 {
1135 tempword ^= *chksum++;
1136 }
1137
1138 if (tempword != *chksum)
1139 {
1140 info->stats.rx_errors ++;
1141 ft1000_submit_rx_urb(info);
1142 return STATUS_FAILURE;
1143 }
1144
1145
1146 //DEBUG("ft1000_copy_up_pkt: checksum is correct %x\n", *chksum);
1147
1148 skb = dev_alloc_skb(len+12+2);
1149
1150 if (skb == NULL)
1151 {
1152 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1153 info->stats.rx_errors++;
1154 ft1000_submit_rx_urb(info);
1155 return STATUS_FAILURE;
1156 }
1157
1158 pbuffer = (u8 *)skb_put(skb, len+12);
1159
1160 //subtract the number of bytes read already
1161 ptemp = pbuffer;
1162
1163 // fake MAC address
1164 *pbuffer++ = net->dev_addr[0];
1165 *pbuffer++ = net->dev_addr[1];
1166 *pbuffer++ = net->dev_addr[2];
1167 *pbuffer++ = net->dev_addr[3];
1168 *pbuffer++ = net->dev_addr[4];
1169 *pbuffer++ = net->dev_addr[5];
1170 *pbuffer++ = 0x00;
1171 *pbuffer++ = 0x07;
1172 *pbuffer++ = 0x35;
1173 *pbuffer++ = 0xff;
1174 *pbuffer++ = 0xff;
1175 *pbuffer++ = 0xfe;
1176
1177
1178
1179
1180 memcpy(pbuffer, ft1000dev->rx_buf+sizeof(struct pseudo_hdr), len-sizeof(struct pseudo_hdr));
1181
1182 //DEBUG("ft1000_copy_up_pkt: Data passed to Protocol layer\n");
1183 /*for (i=0; i<len+12; i++)
1184 {
1185 DEBUG("ft1000_copy_up_pkt: Protocol Data: 0x%x\n ", *ptemp++);
1186 }*/
1187
1188 skb->dev = net;
1189
1190 skb->protocol = eth_type_trans(skb, net);
1191 skb->ip_summed = CHECKSUM_UNNECESSARY;
1192 netif_rx(skb);
1193
1194 info->stats.rx_packets++;
1195 // Add on 12 bytes for MAC address which was removed
1196 info->stats.rx_bytes += (lena+12); //mbelian
1197
1198 ft1000_submit_rx_urb(info);
1199 //DEBUG("ft1000_copy_up_pkt exited\n");
1200 return SUCCESS;
1201 }
1202
1203 //---------------------------------------------------------------------------
1204 //
1205 // Function: ft1000_submit_rx_urb
1206 // Descripton: the receiving function of the network driver
1207 //
1208 // Input:
1209 // info - a private structure contains the device information
1210 //
1211 // Output:
1212 // status - FAILURE
1213 // SUCCESS
1214 //
1215 //---------------------------------------------------------------------------
1216 static int ft1000_submit_rx_urb(struct ft1000_info *info)
1217 {
1218 int result;
1219 struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1220
1221
1222 //DEBUG ("ft1000_submit_rx_urb entered: sizeof rx_urb is %d\n", sizeof(*pFt1000Dev->rx_urb));
1223 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1224 {
1225 DEBUG("network driver is closed, return\n");
1226 //usb_kill_urb(pFt1000Dev->rx_urb); //mbelian
1227 return -ENODEV;
1228 }
1229
1230 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1231 pFt1000Dev->dev,
1232 usb_rcvbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_in_endpointAddr),
1233 pFt1000Dev->rx_buf,
1234 MAX_BUF_SIZE,
1235 (usb_complete_t)ft1000_copy_up_pkt,
1236 info);
1237
1238
1239 if((result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC)))
1240 {
1241 printk("ft1000_submit_rx_urb: submitting rx_urb %d failed\n", result);
1242 return result;
1243 }
1244
1245 //DEBUG("ft1000_submit_rx_urb exit: result=%d\n", result);
1246
1247 return 0;
1248 }
1249
1250 //---------------------------------------------------------------------------
1251 // Function: ft1000_open
1252 //
1253 // Parameters:
1254 // dev - network device
1255 //
1256 //
1257 // Returns: none
1258 //
1259 // Description: open the network driver
1260 //
1261 // Notes:
1262 //
1263 //---------------------------------------------------------------------------
1264 static int ft1000_open (struct net_device *dev)
1265 {
1266 struct ft1000_info *pInfo = netdev_priv(dev);
1267 struct timeval tv; //mbelian
1268 int ret;
1269
1270 DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1271 //DEBUG("ft1000_open: dev->addr=%x, dev->addr_len=%d\n", dev->addr, dev->addr_len);
1272
1273 pInfo->stats.rx_bytes = 0; //mbelian
1274 pInfo->stats.tx_bytes = 0; //mbelian
1275 pInfo->stats.rx_packets = 0; //mbelian
1276 pInfo->stats.tx_packets = 0; //mbelian
1277 do_gettimeofday(&tv);
1278 pInfo->ConTm = tv.tv_sec;
1279 pInfo->ProgConStat = 0; //mbelian
1280
1281
1282 netif_start_queue(dev);
1283
1284 netif_carrier_on(dev); //mbelian
1285
1286 ret = ft1000_submit_rx_urb(pInfo);
1287
1288 return ret;
1289 }
1290
1291 //---------------------------------------------------------------------------
1292 // Function: ft1000_close
1293 //
1294 // Parameters:
1295 // net - network device
1296 //
1297 //
1298 // Returns: none
1299 //
1300 // Description: close the network driver
1301 //
1302 // Notes:
1303 //
1304 //---------------------------------------------------------------------------
1305 int ft1000_close(struct net_device *net)
1306 {
1307 struct ft1000_info *pInfo = netdev_priv(net);
1308 struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1309
1310 //DEBUG ("ft1000_close: netdev->refcnt=%d\n", net->refcnt);
1311
1312 ft1000dev->status |= FT1000_STATUS_CLOSING;
1313
1314 //DEBUG("ft1000_close: calling usb_kill_urb \n");
1315
1316 DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1317 netif_carrier_off(net);//mbelian
1318 netif_stop_queue(net);
1319 //DEBUG("ft1000_close: netif_stop_queue called\n");
1320 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1321
1322 pInfo->ProgConStat = 0xff; //mbelian
1323
1324
1325 return 0;
1326 }
1327
1328 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1329 {
1330 struct ft1000_info *info = netdev_priv(dev);
1331
1332 return &(info->stats); //mbelian
1333 }
1334
1335
1336 /*********************************************************************************
1337 Jim
1338 */
1339
1340
1341 //---------------------------------------------------------------------------
1342 //
1343 // Function: ft1000_chkcard
1344 // Descripton: This function will check if the device is presently available on
1345 // the system.
1346 // Input:
1347 // dev - device structure
1348 // Output:
1349 // status - FALSE (device is not present)
1350 // TRUE (device is present)
1351 //
1352 //---------------------------------------------------------------------------
1353 static int ft1000_chkcard (struct ft1000_device *dev) {
1354 u16 tempword;
1355 u16 status;
1356 struct ft1000_info *info = netdev_priv(dev->net);
1357
1358 if (info->fCondResetPend)
1359 {
1360 DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1361 return TRUE;
1362 }
1363
1364 // Mask register is used to check for device presence since it is never
1365 // set to zero.
1366 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1367 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_SUP_IMASK = %x\n", tempword);
1368 if (tempword == 0) {
1369 DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1370 return FALSE;
1371 }
1372
1373 // The system will return the value of 0xffff for the version register
1374 // if the device is not present.
1375 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1376 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_ASIC_ID = %x\n", tempword);
1377 if (tempword != 0x1b01 ){
1378 dev->status |= FT1000_STATUS_CLOSING; //mbelian
1379 DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1380 return FALSE;
1381 }
1382 return TRUE;
1383 }
1384
1385
1386
1387 //---------------------------------------------------------------------------
1388 //
1389 // Function: ft1000_receive_cmd
1390 // Descripton: This function will read a message from the dpram area.
1391 // Input:
1392 // dev - network device structure
1393 // pbuffer - caller supply address to buffer
1394 // pnxtph - pointer to next pseudo header
1395 // Output:
1396 // Status = 0 (unsuccessful)
1397 // = 1 (successful)
1398 //
1399 //---------------------------------------------------------------------------
1400 static bool ft1000_receive_cmd (struct ft1000_device *dev, u16 *pbuffer, int maxsz, u16 *pnxtph) {
1401 u16 size, ret;
1402 u16 *ppseudohdr;
1403 int i;
1404 u16 tempword;
1405
1406 ret = ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size, FT1000_MAG_PH_LEN_INDX);
1407 size = ntohs(size) + PSEUDOSZ;
1408 if (size > maxsz) {
1409 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n", size);
1410 return FALSE;
1411 }
1412 else {
1413 ppseudohdr = (u16 *)pbuffer;
1414 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
1415 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1416 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1417 pbuffer++;
1418 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE+1, FT1000_REG_DPRAM_ADDR);
1419 for (i=0; i<=(size>>2); i++) {
1420 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1421 pbuffer++;
1422 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1423 pbuffer++;
1424 }
1425 //copy odd aligned word
1426 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1427 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1428 pbuffer++;
1429 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1430 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1431 pbuffer++;
1432 if (size & 0x0001) {
1433 //copy odd byte from fifo
1434 ret = ft1000_read_register(dev, &tempword, FT1000_REG_DPRAM_DATA);
1435 *pbuffer = ntohs(tempword);
1436 }
1437
1438 // Check if pseudo header checksum is good
1439 // Calculate pseudo header checksum
1440 tempword = *ppseudohdr++;
1441 for (i=1; i<7; i++) {
1442 tempword ^= *ppseudohdr++;
1443 }
1444 if ( (tempword != *ppseudohdr) ) {
1445 return FALSE;
1446 }
1447
1448 return TRUE;
1449 }
1450 }
1451
1452
1453 static int ft1000_dsp_prov(void *arg)
1454 {
1455 struct ft1000_device *dev = (struct ft1000_device *)arg;
1456 struct ft1000_info *info = netdev_priv(dev->net);
1457 u16 tempword;
1458 u16 len;
1459 u16 i=0;
1460 struct prov_record *ptr;
1461 struct pseudo_hdr *ppseudo_hdr;
1462 u16 *pmsg;
1463 u16 status;
1464 u16 TempShortBuf [256];
1465
1466 DEBUG("*** DspProv Entered\n");
1467
1468 while (list_empty(&info->prov_list) == 0)
1469 {
1470 DEBUG("DSP Provisioning List Entry\n");
1471
1472 // Check if doorbell is available
1473 DEBUG("check if doorbell is cleared\n");
1474 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1475 if (status)
1476 {
1477 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1478 break;
1479 }
1480
1481 while (tempword & FT1000_DB_DPRAM_TX) {
1482 mdelay(10);
1483 i++;
1484 if (i==10) {
1485 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1486 return STATUS_FAILURE;
1487 }
1488 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1489 }
1490
1491 if ( !(tempword & FT1000_DB_DPRAM_TX) ) {
1492 DEBUG("*** Provision Data Sent to DSP\n");
1493
1494 // Send provisioning data
1495 ptr = list_entry(info->prov_list.next, struct prov_record, list);
1496 len = *(u16 *)ptr->pprov_data;
1497 len = htons(len);
1498 len += PSEUDOSZ;
1499
1500 pmsg = (u16 *)ptr->pprov_data;
1501 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1502 // Insert slow queue sequence number
1503 ppseudo_hdr->seq_num = info->squeseqnum++;
1504 ppseudo_hdr->portsrc = 0;
1505 // Calculate new checksum
1506 ppseudo_hdr->checksum = *pmsg++;
1507 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1508 for (i=1; i<7; i++) {
1509 ppseudo_hdr->checksum ^= *pmsg++;
1510 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1511 }
1512
1513 TempShortBuf[0] = 0;
1514 TempShortBuf[1] = htons (len);
1515 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1516
1517 status = ft1000_write_dpram32 (dev, 0, (u8 *)&TempShortBuf[0], (unsigned short)(len+2));
1518 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1519
1520 list_del(&ptr->list);
1521 kfree(ptr->pprov_data);
1522 kfree(ptr);
1523 }
1524 msleep(10);
1525 }
1526
1527 DEBUG("DSP Provisioning List Entry finished\n");
1528
1529 msleep(100);
1530
1531 info->fProvComplete = 1;
1532 info->CardReady = 1;
1533 return STATUS_SUCCESS;
1534
1535 }
1536
1537
1538 static int ft1000_proc_drvmsg (struct ft1000_device *dev, u16 size) {
1539 struct ft1000_info *info = netdev_priv(dev->net);
1540 u16 msgtype;
1541 u16 tempword;
1542 struct media_msg *pmediamsg;
1543 struct dsp_init_msg *pdspinitmsg;
1544 struct drv_msg *pdrvmsg;
1545 u16 i;
1546 struct pseudo_hdr *ppseudo_hdr;
1547 u16 *pmsg;
1548 u16 status;
1549 union {
1550 u8 byte[2];
1551 u16 wrd;
1552 } convert;
1553
1554
1555 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1556 if (!cmdbuffer)
1557 return STATUS_FAILURE;
1558
1559 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1560
1561
1562
1563 #ifdef JDEBUG
1564 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1565 for(i = 0; i < size; i+=5)
1566 {
1567 if( (i + 5) < size )
1568 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]);
1569 else
1570 {
1571 for (j = i; j < size; j++)
1572 DEBUG("0x%x ", cmdbuffer[j]);
1573 DEBUG("\n");
1574 break;
1575 }
1576 }
1577 #endif
1578 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1579 msgtype = ntohs(pdrvmsg->type);
1580 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1581 switch (msgtype) {
1582 case MEDIA_STATE: {
1583 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1584
1585 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1586 if (info->ProgConStat != 0xFF) {
1587 if (pmediamsg->state) {
1588 DEBUG("Media is up\n");
1589 if (info->mediastate == 0) {
1590 if ( info->NetDevRegDone )
1591 {
1592 //netif_carrier_on(dev->net);//mbelian
1593 netif_wake_queue(dev->net);
1594 }
1595 info->mediastate = 1;
1596 /*do_gettimeofday(&tv);
1597 info->ConTm = tv.tv_sec;*/ //mbelian
1598 }
1599 }
1600 else {
1601 DEBUG("Media is down\n");
1602 if (info->mediastate == 1) {
1603 info->mediastate = 0;
1604 if ( info->NetDevRegDone )
1605 {
1606 //netif_carrier_off(dev->net); mbelian
1607 //netif_stop_queue(dev->net);
1608 }
1609 info->ConTm = 0;
1610 }
1611 }
1612 }
1613 else {
1614 DEBUG("Media is down\n");
1615 if (info->mediastate == 1) {
1616 info->mediastate = 0;
1617 if ( info->NetDevRegDone)
1618 {
1619 //netif_carrier_off(dev->net); //mbelian
1620 //netif_stop_queue(dev->net);
1621 }
1622 info->ConTm = 0;
1623 }
1624 }
1625 break;
1626 }
1627 case DSP_INIT_MSG: {
1628 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1629
1630 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1631 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1632 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n", info->DspVer[0], info->DspVer[1], info->DspVer[2], info->DspVer[3]);
1633 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum, HWSERNUMSZ);
1634 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1635 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1636 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]);
1637 dev->net->dev_addr[0] = info->eui64[0];
1638 dev->net->dev_addr[1] = info->eui64[1];
1639 dev->net->dev_addr[2] = info->eui64[2];
1640 dev->net->dev_addr[3] = info->eui64[5];
1641 dev->net->dev_addr[4] = info->eui64[6];
1642 dev->net->dev_addr[5] = info->eui64[7];
1643
1644 if (ntohs(pdspinitmsg->length) == (sizeof(struct dsp_init_msg) - 20)) {
1645 memcpy(info->ProductMode, pdspinitmsg->ProductMode, MODESZ);
1646 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1647 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate, CALDATESZ);
1648 DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0], info->RfCalVer[1]);
1649 }
1650 break;
1651 }
1652 case DSP_PROVISION: {
1653 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1654
1655 // kick off dspprov routine to start provisioning
1656 // Send provisioning data to DSP
1657 if (list_empty(&info->prov_list) == 0)
1658 {
1659 info->fProvComplete = 0;
1660 status = ft1000_dsp_prov(dev);
1661 if (status != STATUS_SUCCESS)
1662 goto out;
1663 }
1664 else {
1665 info->fProvComplete = 1;
1666 status = ft1000_write_register (dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
1667 DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1668 }
1669 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1670 break;
1671 }
1672 case DSP_STORE_INFO: {
1673 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1674
1675 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1676 tempword = ntohs(pdrvmsg->length);
1677 info->DSPInfoBlklen = tempword;
1678 if (tempword < (MAX_DSP_SESS_REC-4) ) {
1679 pmsg = (u16 *)&pdrvmsg->data[0];
1680 for (i=0; i<((tempword+1)/2); i++) {
1681 DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
1682 info->DSPInfoBlk[i+10] = *pmsg++;
1683 }
1684 }
1685 else {
1686 info->DSPInfoBlklen = 0;
1687 }
1688 break;
1689 }
1690 case DSP_GET_INFO: {
1691 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1692 // copy dsp info block to dsp
1693 info->DrvMsgPend = 1;
1694 // allow any outstanding ioctl to finish
1695 mdelay(10);
1696 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1697 if (tempword & FT1000_DB_DPRAM_TX) {
1698 mdelay(10);
1699 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1700 if (tempword & FT1000_DB_DPRAM_TX) {
1701 mdelay(10);
1702 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1703 if (tempword & FT1000_DB_DPRAM_TX) {
1704 break;
1705 }
1706 }
1707 }
1708
1709 // Put message into Slow Queue
1710 // Form Pseudo header
1711 pmsg = (u16 *)info->DSPInfoBlk;
1712 *pmsg++ = 0;
1713 *pmsg++ = htons(info->DSPInfoBlklen+20+info->DSPInfoBlklen);
1714 ppseudo_hdr = (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1715 ppseudo_hdr->length = htons(info->DSPInfoBlklen+4+info->DSPInfoBlklen);
1716 ppseudo_hdr->source = 0x10;
1717 ppseudo_hdr->destination = 0x20;
1718 ppseudo_hdr->portdest = 0;
1719 ppseudo_hdr->portsrc = 0;
1720 ppseudo_hdr->sh_str_id = 0;
1721 ppseudo_hdr->control = 0;
1722 ppseudo_hdr->rsvd1 = 0;
1723 ppseudo_hdr->rsvd2 = 0;
1724 ppseudo_hdr->qos_class = 0;
1725 // Insert slow queue sequence number
1726 ppseudo_hdr->seq_num = info->squeseqnum++;
1727 // Insert application id
1728 ppseudo_hdr->portsrc = 0;
1729 // Calculate new checksum
1730 ppseudo_hdr->checksum = *pmsg++;
1731 for (i=1; i<7; i++) {
1732 ppseudo_hdr->checksum ^= *pmsg++;
1733 }
1734 info->DSPInfoBlk[10] = 0x7200;
1735 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1736 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPInfoBlk[0], (unsigned short)(info->DSPInfoBlklen+22));
1737 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1738 info->DrvMsgPend = 0;
1739
1740 break;
1741 }
1742
1743 case GET_DRV_ERR_RPT_MSG: {
1744 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1745 // copy driver error message to dsp
1746 info->DrvMsgPend = 1;
1747 // allow any outstanding ioctl to finish
1748 mdelay(10);
1749 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1750 if (tempword & FT1000_DB_DPRAM_TX) {
1751 mdelay(10);
1752 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1753 if (tempword & FT1000_DB_DPRAM_TX) {
1754 mdelay(10);
1755 }
1756 }
1757
1758 if ( (tempword & FT1000_DB_DPRAM_TX) == 0) {
1759 // Put message into Slow Queue
1760 // Form Pseudo header
1761 pmsg = (u16 *)&tempbuffer[0];
1762 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1763 ppseudo_hdr->length = htons(0x0012);
1764 ppseudo_hdr->source = 0x10;
1765 ppseudo_hdr->destination = 0x20;
1766 ppseudo_hdr->portdest = 0;
1767 ppseudo_hdr->portsrc = 0;
1768 ppseudo_hdr->sh_str_id = 0;
1769 ppseudo_hdr->control = 0;
1770 ppseudo_hdr->rsvd1 = 0;
1771 ppseudo_hdr->rsvd2 = 0;
1772 ppseudo_hdr->qos_class = 0;
1773 // Insert slow queue sequence number
1774 ppseudo_hdr->seq_num = info->squeseqnum++;
1775 // Insert application id
1776 ppseudo_hdr->portsrc = 0;
1777 // Calculate new checksum
1778 ppseudo_hdr->checksum = *pmsg++;
1779 for (i=1; i<7; i++) {
1780 ppseudo_hdr->checksum ^= *pmsg++;
1781 }
1782 pmsg = (u16 *)&tempbuffer[16];
1783 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1784 *pmsg++ = htons(0x000e);
1785 *pmsg++ = htons(info->DSP_TIME[0]);
1786 *pmsg++ = htons(info->DSP_TIME[1]);
1787 *pmsg++ = htons(info->DSP_TIME[2]);
1788 *pmsg++ = htons(info->DSP_TIME[3]);
1789 convert.byte[0] = info->DspVer[0];
1790 convert.byte[1] = info->DspVer[1];
1791 *pmsg++ = convert.wrd;
1792 convert.byte[0] = info->DspVer[2];
1793 convert.byte[1] = info->DspVer[3];
1794 *pmsg++ = convert.wrd;
1795 *pmsg++ = htons(info->DrvErrNum);
1796
1797 card_send_command (dev, (unsigned char*)&tempbuffer[0], (u16)(0x0012 + PSEUDOSZ));
1798 info->DrvErrNum = 0;
1799 }
1800 info->DrvMsgPend = 0;
1801
1802 break;
1803 }
1804
1805 default:
1806 break;
1807 }
1808
1809
1810 status = STATUS_SUCCESS;
1811 out:
1812 kfree(cmdbuffer);
1813 DEBUG("return from ft1000_proc_drvmsg\n");
1814 return status;
1815 }
1816
1817
1818
1819 int ft1000_poll(void* dev_id) {
1820
1821 struct ft1000_device *dev = (struct ft1000_device *)dev_id;
1822 struct ft1000_info *info = netdev_priv(dev->net);
1823
1824 u16 tempword;
1825 u16 status;
1826 u16 size;
1827 int i;
1828 u16 data;
1829 u16 modulo;
1830 u16 portid;
1831 u16 nxtph;
1832 struct dpram_blk *pdpram_blk;
1833 struct pseudo_hdr *ppseudo_hdr;
1834 unsigned long flags;
1835
1836 //DEBUG("Enter ft1000_poll...\n");
1837 if (ft1000_chkcard(dev) == FALSE) {
1838 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1839 return STATUS_FAILURE;
1840 }
1841
1842 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1843 // DEBUG("ft1000_poll: read FT1000_REG_DOORBELL message 0x%x\n", tempword);
1844
1845 if ( !status )
1846 {
1847
1848 if (tempword & FT1000_DB_DPRAM_RX) {
1849 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX\n");
1850
1851 status = ft1000_read_dpram16(dev, 0x200, (u8 *)&data, 0);
1852 //DEBUG("ft1000_poll:FT1000_DB_DPRAM_RX:ft1000_read_dpram16:size = 0x%x\n", data);
1853 size = ntohs(data) + 16 + 2; //wai
1854 if (size % 4) {
1855 modulo = 4 - (size % 4);
1856 size = size + modulo;
1857 }
1858 status = ft1000_read_dpram16(dev, 0x201, (u8 *)&portid, 1);
1859 portid &= 0xff;
1860 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid 0x%x\n", portid);
1861
1862 if (size < MAX_CMD_SQSIZE) {
1863 switch (portid)
1864 {
1865 case DRIVERID:
1866 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1867
1868 status = ft1000_proc_drvmsg (dev, size);
1869 if (status != STATUS_SUCCESS )
1870 return status;
1871 break;
1872 case DSPBCMSGID:
1873 // This is a dsp broadcast message
1874 // Check which application has registered for dsp broadcast messages
1875 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DSPBCMSGID\n");
1876
1877 for (i=0; i<MAX_NUM_APP; i++) {
1878 if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
1879 (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT) )
1880 {
1881 //DEBUG("Dsp broadcast message detected for app id %d\n", i);
1882 nxtph = FT1000_DPRAM_RX_BASE + 2;
1883 pdpram_blk = ft1000_get_buffer (&freercvpool);
1884 if (pdpram_blk != NULL) {
1885 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1886 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1887 // Put message into the appropriate application block
1888 info->app_info[i].nRxMsg++;
1889 spin_lock_irqsave(&free_buff_lock, flags);
1890 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1891 info->app_info[i].NumOfMsg++;
1892 spin_unlock_irqrestore(&free_buff_lock, flags);
1893 wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1894 }
1895 else {
1896 info->app_info[i].nRxMsgMiss++;
1897 // Put memory back to free pool
1898 ft1000_free_buffer(pdpram_blk, &freercvpool);
1899 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1900 }
1901 }
1902 else {
1903 DEBUG("Out of memory in free receive command pool\n");
1904 info->app_info[i].nRxMsgMiss++;
1905 }//endof if (pdpram_blk != NULL)
1906 }//endof if
1907 //else
1908 // DEBUG("app_info mismatch\n");
1909 }// endof for
1910 break;
1911 default:
1912 pdpram_blk = ft1000_get_buffer (&freercvpool);
1913 //DEBUG("Memory allocated = 0x%8x\n", (u32)pdpram_blk);
1914 if (pdpram_blk != NULL) {
1915 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1916 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1917 // Search for correct application block
1918 for (i=0; i<MAX_NUM_APP; i++) {
1919 if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
1920 break;
1921 }
1922 }
1923
1924 if (i == MAX_NUM_APP) {
1925 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
1926 // Put memory back to free pool
1927 ft1000_free_buffer(pdpram_blk, &freercvpool);
1928 }
1929 else {
1930 if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1931 // Put memory back to free pool
1932 ft1000_free_buffer(pdpram_blk, &freercvpool);
1933 }
1934 else {
1935 info->app_info[i].nRxMsg++;
1936 // Put message into the appropriate application block
1937 //pxu spin_lock_irqsave(&free_buff_lock, flags);
1938 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1939 info->app_info[i].NumOfMsg++;
1940 //pxu spin_unlock_irqrestore(&free_buff_lock, flags);
1941 //pxu wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1942 }
1943 }
1944 }
1945 else {
1946 // Put memory back to free pool
1947 ft1000_free_buffer(pdpram_blk, &freercvpool);
1948 }
1949 }
1950 else {
1951 DEBUG("Out of memory in free receive command pool\n");
1952 }
1953 break;
1954 } //end of switch
1955 } //endof if (size < MAX_CMD_SQSIZE)
1956 else {
1957 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
1958 }
1959 status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
1960 }
1961 else if (tempword & FT1000_DSP_ASIC_RESET) {
1962 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DSP_ASIC_RESET\n");
1963
1964 // Let's reset the ASIC from the Host side as well
1965 status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
1966 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
1967 i = 0;
1968 while (tempword & ASIC_RESET_BIT) {
1969 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
1970 msleep(10);
1971 i++;
1972 if (i==100)
1973 break;
1974 }
1975 if (i==100) {
1976 DEBUG("Unable to reset ASIC\n");
1977 return STATUS_SUCCESS;
1978 }
1979 msleep(10);
1980 // Program WMARK register
1981 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
1982 // clear ASIC reset doorbell
1983 status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
1984 msleep(10);
1985 }
1986 else if (tempword & FT1000_ASIC_RESET_REQ) {
1987 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1988
1989 // clear ASIC reset request from DSP
1990 status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
1991 status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
1992 // copy dsp session record from Adapter block
1993 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPSess.Rec[0], 1024);
1994 // Program WMARK register
1995 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
1996 // ring doorbell to tell DSP that ASIC is out of reset
1997 status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
1998 }
1999 else if (tempword & FT1000_DB_COND_RESET) {
2000 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
2001 //By Jim
2002 // Reset ASIC and DSP
2003 //MAG
2004 if (info->fAppMsgPend == 0) {
2005 // Reset ASIC and DSP
2006
2007 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (u8 *)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2008 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (u8 *)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2009 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (u8 *)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2010 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (u8 *)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2011 info->CardReady = 0;
2012 info->DrvErrNum = DSP_CONDRESET_INFO;
2013 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2014 info->ft1000_reset(dev->net);
2015 }
2016 else {
2017 info->fProvComplete = 0;
2018 info->fCondResetPend = 1;
2019 }
2020
2021 ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2022 }
2023
2024 }//endof if ( !status )
2025
2026 //DEBUG("return from ft1000_poll.\n");
2027 return STATUS_SUCCESS;
2028
2029 }
2030
2031 /*end of Jim*/
Linux kernel - Deliverables
This page took 0.074295 seconds and 4 git commands to generate.