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