1 //=====================================================
2 // CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
5 // This file is part of Express Card USB Driver
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>
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
27 #define HARLEY_READ_OPERATION 0xc1
28 #define HARLEY_WRITE_OPERATION 0x41
32 static int ft1000_reset(struct net_device
*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_device
*dev
);
39 static u8 tempbuffer
[1600];
41 #define MAX_RCV_LOOP 100
43 //---------------------------------------------------------------------------
44 // Function: ft1000_control
46 // Parameters: ft1000_device - 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
54 // timeout - control message time out value
56 // Returns: STATUS_SUCCESS - success
57 // STATUS_FAILURE - failure
59 // Description: This function sends a control message via USB interface synchronously
63 //---------------------------------------------------------------------------
64 static int ft1000_control(struct ft1000_device
*ft1000dev
, unsigned int pipe
,
65 u8 request
, u8 requesttype
, u16 value
, u16 index
,
66 void *data
, u16 size
, int timeout
)
70 if ((ft1000dev
== NULL
) || (ft1000dev
->dev
== NULL
)) {
71 DEBUG("ft1000dev or ft1000dev->dev == NULL, failure\n");
75 ret
= usb_control_msg(ft1000dev
->dev
, pipe
, request
, requesttype
,
76 value
, index
, data
, size
, LARGE_TIMEOUT
);
84 //---------------------------------------------------------------------------
85 // Function: ft1000_read_register
87 // Parameters: ft1000_device - device structure
88 // Data - data buffer to hold the value read
89 // nRegIndex - register index
91 // Returns: STATUS_SUCCESS - success
92 // STATUS_FAILURE - failure
94 // Description: This function returns the value in a register
98 //---------------------------------------------------------------------------
100 int ft1000_read_register(struct ft1000_device
*ft1000dev
, u16
* Data
,
103 int ret
= STATUS_SUCCESS
;
105 ret
= ft1000_control(ft1000dev
,
106 usb_rcvctrlpipe(ft1000dev
->dev
, 0),
107 HARLEY_READ_REGISTER
,
108 HARLEY_READ_OPERATION
,
118 //---------------------------------------------------------------------------
119 // Function: ft1000_write_register
121 // Parameters: ft1000_device - device structure
122 // value - value to write into a register
123 // nRegIndex - register index
125 // Returns: STATUS_SUCCESS - success
126 // STATUS_FAILURE - failure
128 // Description: This function writes the value in a register
132 //---------------------------------------------------------------------------
133 int ft1000_write_register(struct ft1000_device
*ft1000dev
, u16 value
,
136 int ret
= STATUS_SUCCESS
;
138 ret
= ft1000_control(ft1000dev
,
139 usb_sndctrlpipe(ft1000dev
->dev
, 0),
140 HARLEY_WRITE_REGISTER
,
141 HARLEY_WRITE_OPERATION
,
151 //---------------------------------------------------------------------------
152 // Function: ft1000_read_dpram32
154 // Parameters: ft1000_device - 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
159 // Returns: STATUS_SUCCESS - success
160 // STATUS_FAILURE - failure
162 // Description: This function read a number of bytes from DPRAM
166 //---------------------------------------------------------------------------
168 int ft1000_read_dpram32(struct ft1000_device
*ft1000dev
, u16 indx
, u8
*buffer
,
171 int ret
= STATUS_SUCCESS
;
173 ret
= ft1000_control(ft1000dev
,
174 usb_rcvctrlpipe(ft1000dev
->dev
, 0),
175 HARLEY_READ_DPRAM_32
,
176 HARLEY_READ_OPERATION
,
186 //---------------------------------------------------------------------------
187 // Function: ft1000_write_dpram32
189 // Parameters: ft1000_device - 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
194 // Returns: STATUS_SUCCESS - success
195 // STATUS_FAILURE - failure
197 // Description: This function writes into DPRAM a number of bytes
201 //---------------------------------------------------------------------------
202 int ft1000_write_dpram32(struct ft1000_device
*ft1000dev
, u16 indx
, u8
*buffer
,
205 int ret
= STATUS_SUCCESS
;
208 cnt
+= cnt
- (cnt
% 4);
210 ret
= ft1000_control(ft1000dev
,
211 usb_sndctrlpipe(ft1000dev
->dev
, 0),
212 HARLEY_WRITE_DPRAM_32
,
213 HARLEY_WRITE_OPERATION
,
223 //---------------------------------------------------------------------------
224 // Function: ft1000_read_dpram16
226 // Parameters: ft1000_device - 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
231 // Returns: STATUS_SUCCESS - success
232 // STATUS_FAILURE - failure
234 // Description: This function read 16 bits from DPRAM
238 //---------------------------------------------------------------------------
239 int ft1000_read_dpram16(struct ft1000_device
*ft1000dev
, u16 indx
, u8
*buffer
,
242 int ret
= STATUS_SUCCESS
;
246 request
= HARLEY_READ_DPRAM_LOW
;
248 request
= HARLEY_READ_DPRAM_HIGH
;
250 ret
= ft1000_control(ft1000dev
,
251 usb_rcvctrlpipe(ft1000dev
->dev
, 0),
253 HARLEY_READ_OPERATION
,
263 //---------------------------------------------------------------------------
264 // Function: ft1000_write_dpram16
266 // Parameters: ft1000_device - device structure
267 // indx - starting address to write the data
268 // value - 16bits value to write
269 // hightlow - high or low 16 bit word
271 // Returns: STATUS_SUCCESS - success
272 // STATUS_FAILURE - failure
274 // Description: This function writes into DPRAM a number of bytes
278 //---------------------------------------------------------------------------
279 int ft1000_write_dpram16(struct ft1000_device
*ft1000dev
, u16 indx
, u16 value
, u8 highlow
)
281 int ret
= STATUS_SUCCESS
;
285 request
= HARLEY_WRITE_DPRAM_LOW
;
287 request
= HARLEY_WRITE_DPRAM_HIGH
;
289 ret
= ft1000_control(ft1000dev
,
290 usb_sndctrlpipe(ft1000dev
->dev
, 0),
292 HARLEY_WRITE_OPERATION
,
302 //---------------------------------------------------------------------------
303 // Function: fix_ft1000_read_dpram32
305 // Parameters: ft1000_device - device structure
306 // indx - starting address to read
307 // buffer - data buffer to hold the data read
310 // Returns: STATUS_SUCCESS - success
311 // STATUS_FAILURE - failure
313 // Description: This function read DPRAM 4 words at a time
317 //---------------------------------------------------------------------------
318 int fix_ft1000_read_dpram32(struct ft1000_device
*ft1000dev
, u16 indx
,
323 int ret
= STATUS_SUCCESS
;
325 pos
= (indx
/ 4) * 4;
326 ret
= ft1000_read_dpram32(ft1000dev
, pos
, buf
, 16);
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
++];
335 DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
346 //---------------------------------------------------------------------------
347 // Function: fix_ft1000_write_dpram32
349 // Parameters: ft1000_device - device structure
350 // indx - starting address to write
351 // buffer - data buffer to write
354 // Returns: STATUS_SUCCESS - success
355 // STATUS_FAILURE - failure
357 // Description: This function write to DPRAM 4 words at a time
361 //---------------------------------------------------------------------------
362 int fix_ft1000_write_dpram32(struct ft1000_device
*ft1000dev
, u16 indx
, u8
*buffer
)
370 int ret
= STATUS_SUCCESS
;
372 pos1
= (indx
/ 4) * 4;
374 ret
= ft1000_read_dpram32(ft1000dev
, pos1
, buf
, 16);
376 if (ret
== STATUS_SUCCESS
) {
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);
384 DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
388 ret
= ft1000_read_dpram32(ft1000dev
, pos1
, (u8
*)&resultbuffer
[0], 16);
390 if (ret
== STATUS_SUCCESS
) {
392 for (i
= 0; i
< 16; i
++) {
393 if (buf
[i
] != resultbuffer
[i
])
394 ret
= STATUS_FAILURE
;
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
) {
405 for (i
= 0; i
< 16; i
++) {
406 if (tempbuffer
[i
] != resultbuffer
[i
]) {
407 ret
= STATUS_FAILURE
;
408 DEBUG("%s Failed to write\n",
419 //------------------------------------------------------------------------
421 // Function: card_reset_dsp
423 // Synopsis: This function is called to reset or activate the DSP
425 // Arguments: value - reset or activate
428 //-----------------------------------------------------------------------
429 static void card_reset_dsp(struct ft1000_device
*ft1000dev
, bool value
)
431 u16 status
= STATUS_SUCCESS
;
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
);
440 DEBUG("Reset DSP\n");
441 status
= ft1000_read_register(ft1000dev
, &tempword
,
443 tempword
|= DSP_RESET_BIT
;
444 status
= ft1000_write_register(ft1000dev
, tempword
,
447 DEBUG("Activate DSP\n");
448 status
= ft1000_read_register(ft1000dev
, &tempword
,
450 tempword
|= DSP_ENCRYPTED
;
451 tempword
&= ~DSP_UNENCRYPTED
;
452 status
= ft1000_write_register(ft1000dev
, tempword
,
454 status
= ft1000_read_register(ft1000dev
, &tempword
,
456 tempword
&= ~EFUSE_MEM_DISABLE
;
457 tempword
&= ~DSP_RESET_BIT
;
458 status
= ft1000_write_register(ft1000dev
, tempword
,
460 status
= ft1000_read_register(ft1000dev
, &tempword
,
465 //---------------------------------------------------------------------------
466 // Function: card_send_command
468 // Parameters: ft1000_device - device structure
469 // ptempbuffer - command buffer
470 // size - command buffer size
472 // Returns: STATUS_SUCCESS - success
473 // STATUS_FAILURE - failure
475 // Description: This function sends a command to ASIC
479 //---------------------------------------------------------------------------
480 void card_send_command(struct ft1000_device
*ft1000dev
, void *ptempbuffer
,
484 unsigned char *commandbuf
;
486 DEBUG("card_send_command: enter card_send_command... size=%d\n", size
);
488 commandbuf
= (unsigned char *)kmalloc(size
+ 2, GFP_KERNEL
);
489 memcpy((void *)commandbuf
+ 2, (void *)ptempbuffer
, size
);
491 ft1000_read_register(ft1000dev
, &temp
, FT1000_REG_DOORBELL
);
496 /* check for odd word */
499 /* Must force to be 32 bit aligned */
501 size
+= 4 - (size
% 4);
503 ft1000_write_dpram32(ft1000dev
, 0, commandbuf
, size
);
505 ft1000_write_register(ft1000dev
, FT1000_DB_DPRAM_TX
,
506 FT1000_REG_DOORBELL
);
509 ft1000_read_register(ft1000dev
, &temp
, FT1000_REG_DOORBELL
);
511 if ((temp
& 0x0100) == 0) {
512 //DEBUG("card_send_command: Message sent\n");
517 //--------------------------------------------------------------------------
519 // Function: dsp_reload
521 // Synopsis: This function is called to load or reload the DSP
523 // Arguments: ft1000dev - device structure
526 //-----------------------------------------------------------------------
527 int dsp_reload(struct ft1000_device
*ft1000dev
)
533 struct ft1000_info
*pft1000info
;
535 pft1000info
= netdev_priv(ft1000dev
->net
);
537 pft1000info
->CardReady
= 0;
539 /* Program Interrupt Mask register */
540 status
= ft1000_write_register(ft1000dev
, 0xffff, FT1000_REG_SUP_IMASK
);
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
);
546 status
= ft1000_read_register(ft1000dev
, &tempword
, FT1000_REG_RESET
);
547 DEBUG("Reset Register = 0x%x\n", tempword
);
549 /* Toggle DSP reset */
550 card_reset_dsp(ft1000dev
, 1);
552 card_reset_dsp(ft1000dev
, 0);
556 ft1000_write_register(ft1000dev
, HOST_INTF_BE
, FT1000_REG_SUP_CTRL
);
558 /* Let's check for FEFE */
560 ft1000_read_dpram32(ft1000dev
, FT1000_MAG_DPRAM_FEFE_INDX
,
561 (u8
*) &templong
, 4);
562 DEBUG("templong (fefe) = 0x%8x\n", templong
);
564 /* call codeloader */
565 status
= scram_dnldr(ft1000dev
, pFileStart
, FileLength
);
567 if (status
!= STATUS_SUCCESS
)
572 DEBUG("dsp_reload returned\n");
577 //---------------------------------------------------------------------------
579 // Function: ft1000_reset_asic
580 // Description: This function will call the Card Service function to reset the
583 // dev - device structure
587 //---------------------------------------------------------------------------
588 static void ft1000_reset_asic(struct net_device
*dev
)
590 struct ft1000_info
*info
= netdev_priv(dev
);
591 struct ft1000_device
*ft1000dev
= info
->pFt1000Dev
;
594 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
596 /* Let's use the register provided by the Magnemite ASIC to reset the
599 ft1000_write_register(ft1000dev
, (DSP_RESET_BIT
| ASIC_RESET_BIT
),
604 /* set watermark to -1 in order to not generate an interrrupt */
605 ft1000_write_register(ft1000dev
, 0xffff, FT1000_REG_MAG_WATERMARK
);
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
);
616 //---------------------------------------------------------------------------
618 // Function: ft1000_reset_card
619 // Description: This function will reset the card
621 // dev - device structure
623 // status - FALSE (card reset fail)
624 // TRUE (card reset successful)
626 //---------------------------------------------------------------------------
627 static int ft1000_reset_card(struct net_device
*dev
)
629 struct ft1000_info
*info
= netdev_priv(dev
);
630 struct ft1000_device
*ft1000dev
= info
->pFt1000Dev
;
632 struct prov_record
*ptr
;
634 DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
636 info
->fCondResetPend
= 1;
638 info
->fProvComplete
= 0;
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");
644 list_entry(info
->prov_list
.next
, struct prov_record
, list
);
645 list_del(&ptr
->list
);
646 kfree(ptr
->pprov_data
);
650 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
651 ft1000_reset_asic(dev
);
653 DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
654 dsp_reload(ft1000dev
);
656 DEBUG("dsp reload successful\n");
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
);
669 info
->fCondResetPend
= 0;
674 #ifdef HAVE_NET_DEVICE_OPS
675 static const struct net_device_ops ftnet_ops
=
677 .ndo_open
= &ft1000_open
,
678 .ndo_stop
= &ft1000_close
,
679 .ndo_start_xmit
= &ft1000_start_xmit
,
680 .ndo_get_stats
= &ft1000_netdev_stats
,
685 //---------------------------------------------------------------------------
686 // Function: init_ft1000_netdev
688 // Parameters: ft1000dev - device structure
691 // Returns: STATUS_SUCCESS - success
692 // STATUS_FAILURE - failure
694 // Description: This function initialize the network device
698 //---------------------------------------------------------------------------
699 int init_ft1000_netdev(struct ft1000_device
*ft1000dev
)
701 struct net_device
*netdev
;
702 struct ft1000_info
*pInfo
= NULL
;
703 struct dpram_blk
*pdpram_blk
;
705 struct list_head
*cur
, *tmp
;
707 unsigned long gCardIndex
= 0;
709 DEBUG("Enter init_ft1000_netdev...\n");
711 netdev
= alloc_etherdev(sizeof(struct ft1000_info
));
713 DEBUG("init_ft1000_netdev: can not allocate network device\n");
717 pInfo
= netdev_priv(netdev
);
719 memset(pInfo
, 0, sizeof(struct ft1000_info
));
721 dev_alloc_name(netdev
, netdev
->name
);
723 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev
->name
);
725 if (strncmp(netdev
->name
, "eth", 3) == 0) {
726 card_nr
[0] = netdev
->name
[3];
728 ret_val
= strict_strtoul(card_nr
, 10, &gCardIndex
);
730 printk(KERN_ERR
"Can't parse netdev\n");
734 pInfo
->CardNumber
= gCardIndex
;
735 DEBUG("card number = %d\n", pInfo
->CardNumber
);
737 printk(KERN_ERR
"ft1000: Invalid device name\n");
742 memset(&pInfo
->stats
, 0, sizeof(struct net_device_stats
));
744 spin_lock_init(&pInfo
->dpram_lock
);
745 pInfo
->pFt1000Dev
= ft1000dev
;
746 pInfo
->DrvErrNum
= 0;
747 pInfo
->registered
= 1;
748 pInfo
->ft1000_reset
= ft1000_reset
;
749 pInfo
->mediastate
= 0;
751 pInfo
->DeviceCreated
= FALSE
;
752 pInfo
->InterruptsEnabled
= FALSE
;
753 pInfo
->CardReady
= 0;
754 pInfo
->DSP_TIME
[0] = 0;
755 pInfo
->DSP_TIME
[1] = 0;
756 pInfo
->DSP_TIME
[2] = 0;
757 pInfo
->DSP_TIME
[3] = 0;
758 pInfo
->fAppMsgPend
= 0;
759 pInfo
->fCondResetPend
= 0;
762 memset(&pInfo
->tempbuf
[0], 0, sizeof(pInfo
->tempbuf
));
764 INIT_LIST_HEAD(&pInfo
->prov_list
);
766 INIT_LIST_HEAD(&pInfo
->nodes
.list
);
768 #ifdef HAVE_NET_DEVICE_OPS
769 netdev
->netdev_ops
= &ftnet_ops
;
771 netdev
->hard_start_xmit
= &ft1000_start_xmit
;
772 netdev
->get_stats
= &ft1000_netdev_stats
;
773 netdev
->open
= &ft1000_open
;
774 netdev
->stop
= &ft1000_close
;
777 ft1000dev
->net
= netdev
;
779 DEBUG("Initialize free_buff_lock and freercvpool\n");
780 spin_lock_init(&free_buff_lock
);
782 /* initialize a list of buffers to be use for queuing
783 * up receive command data
785 INIT_LIST_HEAD(&freercvpool
);
787 /* create list of free buffers */
788 for (i
= 0; i
< NUM_OF_FREE_BUFFERS
; i
++) {
789 /* Get memory for DPRAM_DATA link list */
790 pdpram_blk
= kmalloc(sizeof(struct dpram_blk
), GFP_KERNEL
);
791 if (pdpram_blk
== NULL
) {
795 /* Get a block of memory to store command data */
796 pdpram_blk
->pbuffer
= kmalloc(MAX_CMD_SQSIZE
, GFP_KERNEL
);
797 if (pdpram_blk
->pbuffer
== NULL
) {
802 /* link provisioning data */
803 list_add_tail(&pdpram_blk
->list
, &freercvpool
);
805 numofmsgbuf
= NUM_OF_FREE_BUFFERS
;
810 list_for_each_safe(cur
, tmp
, &freercvpool
) {
811 pdpram_blk
= list_entry(cur
, struct dpram_blk
, list
);
812 list_del(&pdpram_blk
->list
);
813 kfree(pdpram_blk
->pbuffer
);
821 //---------------------------------------------------------------------------
822 // Function: reg_ft1000_netdev
824 // Parameters: ft1000dev - device structure
827 // Returns: STATUS_SUCCESS - success
828 // STATUS_FAILURE - failure
830 // Description: This function register the network driver
834 //---------------------------------------------------------------------------
835 int reg_ft1000_netdev(struct ft1000_device
*ft1000dev
,
836 struct usb_interface
*intf
)
838 struct net_device
*netdev
;
839 struct ft1000_info
*pInfo
;
842 netdev
= ft1000dev
->net
;
843 pInfo
= netdev_priv(ft1000dev
->net
);
844 DEBUG("Enter reg_ft1000_netdev...\n");
846 ft1000_read_register(ft1000dev
, &pInfo
->AsicID
, FT1000_REG_ASIC_ID
);
848 usb_set_intfdata(intf
, pInfo
);
849 SET_NETDEV_DEV(netdev
, &intf
->dev
);
851 rc
= register_netdev(netdev
);
853 DEBUG("reg_ft1000_netdev: could not register network device\n");
858 ft1000_create_dev(ft1000dev
);
860 DEBUG("reg_ft1000_netdev returned\n");
862 pInfo
->CardReady
= 1;
867 static int ft1000_reset(struct net_device
*dev
)
869 ft1000_reset_card(dev
);
873 //---------------------------------------------------------------------------
874 // Function: ft1000_usb_transmit_complete
876 // Parameters: urb - transmitted usb urb
881 // Description: This is the callback function when a urb is transmitted
885 //---------------------------------------------------------------------------
886 static void ft1000_usb_transmit_complete(struct urb
*urb
)
889 struct ft1000_device
*ft1000dev
= urb
->context
;
892 pr_err("%s: TX status %d\n", ft1000dev
->net
->name
, urb
->status
);
894 netif_wake_queue(ft1000dev
->net
);
897 //---------------------------------------------------------------------------
899 // Function: ft1000_copy_down_pkt
900 // Description: This function will take an ethernet packet and convert it to
901 // a Flarion packet prior to sending it to the ASIC Downlink
904 // dev - device structure
905 // packet - address of ethernet packet
906 // len - length of IP packet
911 //---------------------------------------------------------------------------
912 static int ft1000_copy_down_pkt(struct net_device
*netdev
, u8
* packet
, u16 len
)
914 struct ft1000_info
*pInfo
= netdev_priv(netdev
);
915 struct ft1000_device
*pFt1000Dev
= pInfo
->pFt1000Dev
;
919 struct pseudo_hdr hdr
;
921 if (!pInfo
->CardReady
) {
922 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
926 count
= sizeof(struct pseudo_hdr
) + len
;
927 if (count
> MAX_BUF_SIZE
) {
928 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
929 DEBUG("size = %d\n", count
);
934 count
= count
+ (4 - (count
% 4));
936 memset(&hdr
, 0, sizeof(struct pseudo_hdr
));
938 hdr
.length
= ntohs(count
);
940 hdr
.destination
= 0x20;
943 hdr
.sh_str_id
= 0x91;
946 hdr
.checksum
= hdr
.length
^ hdr
.source
^ hdr
.destination
^
947 hdr
.portdest
^ hdr
.portsrc
^ hdr
.sh_str_id
^ hdr
.control
;
949 memcpy(&pFt1000Dev
->tx_buf
[0], &hdr
, sizeof(hdr
));
950 memcpy(&(pFt1000Dev
->tx_buf
[sizeof(struct pseudo_hdr
)]), packet
, len
);
952 netif_stop_queue(netdev
);
954 usb_fill_bulk_urb(pFt1000Dev
->tx_urb
,
956 usb_sndbulkpipe(pFt1000Dev
->dev
,
957 pFt1000Dev
->bulk_out_endpointAddr
),
958 pFt1000Dev
->tx_buf
, count
,
959 ft1000_usb_transmit_complete
, (void *)pFt1000Dev
);
961 t
= (u8
*) pFt1000Dev
->tx_urb
->transfer_buffer
;
963 ret
= usb_submit_urb(pFt1000Dev
->tx_urb
, GFP_ATOMIC
);
966 DEBUG("ft1000 failed tx_urb %d\n", ret
);
969 pInfo
->stats
.tx_packets
++;
970 pInfo
->stats
.tx_bytes
+= (len
+ 14);
977 //---------------------------------------------------------------------------
978 // Function: ft1000_start_xmit
980 // Parameters: skb - socket buffer to be sent
981 // dev - network device
986 // Description: transmit a ethernet packet
990 //---------------------------------------------------------------------------
991 static int ft1000_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
993 struct ft1000_info
*pInfo
= netdev_priv(dev
);
994 struct ft1000_device
*pFt1000Dev
= pInfo
->pFt1000Dev
;
999 DEBUG("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n");
1000 return NETDEV_TX_OK
;
1003 if (pFt1000Dev
->status
& FT1000_STATUS_CLOSING
) {
1004 DEBUG("network driver is closed, return\n");
1009 usb_sndbulkpipe(pFt1000Dev
->dev
, pFt1000Dev
->bulk_out_endpointAddr
);
1010 maxlen
= usb_maxpacket(pFt1000Dev
->dev
, pipe
, usb_pipeout(pipe
));
1012 pdata
= (u8
*) skb
->data
;
1014 if (pInfo
->mediastate
== 0) {
1015 /* Drop packet is mediastate is down */
1016 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1020 if ((skb
->len
< ENET_HEADER_SIZE
) || (skb
->len
> ENET_MAX_SIZE
)) {
1021 /* Drop packet which has invalid size */
1022 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1026 ft1000_copy_down_pkt(dev
, (pdata
+ ENET_HEADER_SIZE
- 2),
1027 skb
->len
- ENET_HEADER_SIZE
+ 2);
1032 return NETDEV_TX_OK
;
1036 //---------------------------------------------------------------------------
1038 // Function: ft1000_copy_up_pkt
1039 // Description: This function will take a packet from the FIFO up link and
1040 // convert it into an ethernet packet and deliver it to the IP stack
1042 // urb - the receiving usb urb
1048 //---------------------------------------------------------------------------
1049 static int ft1000_copy_up_pkt(struct urb
*urb
)
1051 struct ft1000_info
*info
= urb
->context
;
1052 struct ft1000_device
*ft1000dev
= info
->pFt1000Dev
;
1053 struct net_device
*net
= ft1000dev
->net
;
1058 struct sk_buff
*skb
;
1064 if (ft1000dev
->status
& FT1000_STATUS_CLOSING
) {
1065 DEBUG("network driver is closed, return\n");
1066 return STATUS_SUCCESS
;
1069 len
= urb
->transfer_buffer_length
;
1070 lena
= urb
->actual_length
;
1072 chksum
= (u16
*) ft1000dev
->rx_buf
;
1074 tempword
= *chksum
++;
1075 for (i
= 1; i
< 7; i
++)
1076 tempword
^= *chksum
++;
1078 if (tempword
!= *chksum
) {
1079 info
->stats
.rx_errors
++;
1080 ft1000_submit_rx_urb(info
);
1081 return STATUS_FAILURE
;
1084 skb
= dev_alloc_skb(len
+ 12 + 2);
1087 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1088 info
->stats
.rx_errors
++;
1089 ft1000_submit_rx_urb(info
);
1090 return STATUS_FAILURE
;
1093 pbuffer
= (u8
*) skb_put(skb
, len
+ 12);
1095 /* subtract the number of bytes read already */
1098 /* fake MAC address */
1099 *pbuffer
++ = net
->dev_addr
[0];
1100 *pbuffer
++ = net
->dev_addr
[1];
1101 *pbuffer
++ = net
->dev_addr
[2];
1102 *pbuffer
++ = net
->dev_addr
[3];
1103 *pbuffer
++ = net
->dev_addr
[4];
1104 *pbuffer
++ = net
->dev_addr
[5];
1112 memcpy(pbuffer
, ft1000dev
->rx_buf
+ sizeof(struct pseudo_hdr
),
1113 len
- sizeof(struct pseudo_hdr
));
1117 skb
->protocol
= eth_type_trans(skb
, net
);
1118 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1121 info
->stats
.rx_packets
++;
1122 /* Add on 12 bytes for MAC address which was removed */
1123 info
->stats
.rx_bytes
+= (lena
+ 12);
1125 ft1000_submit_rx_urb(info
);
1131 //---------------------------------------------------------------------------
1133 // Function: ft1000_submit_rx_urb
1134 // Description: the receiving function of the network driver
1137 // info - a private structure contains the device information
1143 //---------------------------------------------------------------------------
1144 static int ft1000_submit_rx_urb(struct ft1000_info
*info
)
1147 struct ft1000_device
*pFt1000Dev
= info
->pFt1000Dev
;
1149 if (pFt1000Dev
->status
& FT1000_STATUS_CLOSING
) {
1150 DEBUG("network driver is closed, return\n");
1154 usb_fill_bulk_urb(pFt1000Dev
->rx_urb
,
1156 usb_rcvbulkpipe(pFt1000Dev
->dev
,
1157 pFt1000Dev
->bulk_in_endpointAddr
),
1158 pFt1000Dev
->rx_buf
, MAX_BUF_SIZE
,
1159 (usb_complete_t
) ft1000_copy_up_pkt
, info
);
1161 result
= usb_submit_urb(pFt1000Dev
->rx_urb
, GFP_ATOMIC
);
1164 pr_err("ft1000_submit_rx_urb: submitting rx_urb %d failed\n",
1173 //---------------------------------------------------------------------------
1174 // Function: ft1000_open
1177 // dev - network device
1182 // Description: open the network driver
1186 //---------------------------------------------------------------------------
1187 static int ft1000_open(struct net_device
*dev
)
1189 struct ft1000_info
*pInfo
= netdev_priv(dev
);
1193 DEBUG("ft1000_open is called for card %d\n", pInfo
->CardNumber
);
1195 pInfo
->stats
.rx_bytes
= 0;
1196 pInfo
->stats
.tx_bytes
= 0;
1197 pInfo
->stats
.rx_packets
= 0;
1198 pInfo
->stats
.tx_packets
= 0;
1199 do_gettimeofday(&tv
);
1200 pInfo
->ConTm
= tv
.tv_sec
;
1201 pInfo
->ProgConStat
= 0;
1203 netif_start_queue(dev
);
1205 netif_carrier_on(dev
);
1207 ret
= ft1000_submit_rx_urb(pInfo
);
1212 //---------------------------------------------------------------------------
1213 // Function: ft1000_close
1216 // net - network device
1221 // Description: close the network driver
1225 //---------------------------------------------------------------------------
1226 int ft1000_close(struct net_device
*net
)
1228 struct ft1000_info
*pInfo
= netdev_priv(net
);
1229 struct ft1000_device
*ft1000dev
= pInfo
->pFt1000Dev
;
1231 ft1000dev
->status
|= FT1000_STATUS_CLOSING
;
1233 DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo
, ft1000dev
);
1234 netif_carrier_off(net
);
1235 netif_stop_queue(net
);
1236 ft1000dev
->status
&= ~FT1000_STATUS_CLOSING
;
1238 pInfo
->ProgConStat
= 0xff;
1243 static struct net_device_stats
*ft1000_netdev_stats(struct net_device
*dev
)
1245 struct ft1000_info
*info
= netdev_priv(dev
);
1247 return &(info
->stats
);
1251 //---------------------------------------------------------------------------
1253 // Function: ft1000_chkcard
1254 // Description: This function will check if the device is presently available on
1257 // dev - device structure
1259 // status - FALSE (device is not present)
1260 // TRUE (device is present)
1262 //---------------------------------------------------------------------------
1263 static int ft1000_chkcard(struct ft1000_device
*dev
)
1267 struct ft1000_info
*info
= netdev_priv(dev
->net
);
1269 if (info
->fCondResetPend
) {
1271 ("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1274 /* Mask register is used to check for device presence since it is never
1277 status
= ft1000_read_register(dev
, &tempword
, FT1000_REG_SUP_IMASK
);
1278 if (tempword
== 0) {
1280 ("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1283 /* The system will return the value of 0xffff for the version register
1284 * if the device is not present.
1286 status
= ft1000_read_register(dev
, &tempword
, FT1000_REG_ASIC_ID
);
1287 if (tempword
!= 0x1b01) {
1288 dev
->status
|= FT1000_STATUS_CLOSING
;
1290 ("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1296 //---------------------------------------------------------------------------
1298 // Function: ft1000_receive_cmd
1299 // Description: This function will read a message from the dpram area.
1301 // dev - network device structure
1302 // pbuffer - caller supply address to buffer
1303 // pnxtph - pointer to next pseudo header
1305 // Status = 0 (unsuccessful)
1308 //---------------------------------------------------------------------------
1309 static bool ft1000_receive_cmd(struct ft1000_device
*dev
, u16
*pbuffer
,
1310 int maxsz
, u16
*pnxtph
)
1318 ft1000_read_dpram16(dev
, FT1000_MAG_PH_LEN
, (u8
*) &size
,
1319 FT1000_MAG_PH_LEN_INDX
);
1320 size
= ntohs(size
) + PSEUDOSZ
;
1322 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n",
1326 ppseudohdr
= (u16
*) pbuffer
;
1327 ft1000_write_register(dev
, FT1000_DPRAM_MAG_RX_BASE
,
1328 FT1000_REG_DPRAM_ADDR
);
1330 ft1000_read_register(dev
, pbuffer
, FT1000_REG_MAG_DPDATAH
);
1332 ft1000_write_register(dev
, FT1000_DPRAM_MAG_RX_BASE
+ 1,
1333 FT1000_REG_DPRAM_ADDR
);
1334 for (i
= 0; i
<= (size
>> 2); i
++) {
1336 ft1000_read_register(dev
, pbuffer
,
1337 FT1000_REG_MAG_DPDATAL
);
1340 ft1000_read_register(dev
, pbuffer
,
1341 FT1000_REG_MAG_DPDATAH
);
1344 /* copy odd aligned word */
1346 ft1000_read_register(dev
, pbuffer
, FT1000_REG_MAG_DPDATAL
);
1350 ft1000_read_register(dev
, pbuffer
, FT1000_REG_MAG_DPDATAH
);
1353 if (size
& 0x0001) {
1354 /* copy odd byte from fifo */
1356 ft1000_read_register(dev
, &tempword
,
1357 FT1000_REG_DPRAM_DATA
);
1358 *pbuffer
= ntohs(tempword
);
1360 /* Check if pseudo header checksum is good
1361 * Calculate pseudo header checksum
1363 tempword
= *ppseudohdr
++;
1364 for (i
= 1; i
< 7; i
++)
1365 tempword
^= *ppseudohdr
++;
1367 if ((tempword
!= *ppseudohdr
))
1374 static int ft1000_dsp_prov(void *arg
)
1376 struct ft1000_device
*dev
= (struct ft1000_device
*)arg
;
1377 struct ft1000_info
*info
= netdev_priv(dev
->net
);
1381 struct prov_record
*ptr
;
1382 struct pseudo_hdr
*ppseudo_hdr
;
1385 u16 TempShortBuf
[256];
1387 DEBUG("*** DspProv Entered\n");
1389 while (list_empty(&info
->prov_list
) == 0) {
1390 DEBUG("DSP Provisioning List Entry\n");
1392 /* Check if doorbell is available */
1393 DEBUG("check if doorbell is cleared\n");
1395 ft1000_read_register(dev
, &tempword
, FT1000_REG_DOORBELL
);
1397 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1401 while (tempword
& FT1000_DB_DPRAM_TX
) {
1405 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1406 return STATUS_FAILURE
;
1408 ft1000_read_register(dev
, &tempword
,
1409 FT1000_REG_DOORBELL
);
1412 if (!(tempword
& FT1000_DB_DPRAM_TX
)) {
1413 DEBUG("*** Provision Data Sent to DSP\n");
1415 /* Send provisioning data */
1417 list_entry(info
->prov_list
.next
, struct prov_record
,
1419 len
= *(u16
*) ptr
->pprov_data
;
1423 pmsg
= (u16
*) ptr
->pprov_data
;
1424 ppseudo_hdr
= (struct pseudo_hdr
*)pmsg
;
1425 /* Insert slow queue sequence number */
1426 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
1427 ppseudo_hdr
->portsrc
= 0;
1428 /* Calculate new checksum */
1429 ppseudo_hdr
->checksum
= *pmsg
++;
1430 for (i
= 1; i
< 7; i
++) {
1431 ppseudo_hdr
->checksum
^= *pmsg
++;
1434 TempShortBuf
[0] = 0;
1435 TempShortBuf
[1] = htons(len
);
1436 memcpy(&TempShortBuf
[2], ppseudo_hdr
, len
);
1439 ft1000_write_dpram32(dev
, 0,
1440 (u8
*) &TempShortBuf
[0],
1441 (unsigned short)(len
+ 2));
1443 ft1000_write_register(dev
, FT1000_DB_DPRAM_TX
,
1444 FT1000_REG_DOORBELL
);
1446 list_del(&ptr
->list
);
1447 kfree(ptr
->pprov_data
);
1453 DEBUG("DSP Provisioning List Entry finished\n");
1457 info
->fProvComplete
= 1;
1458 info
->CardReady
= 1;
1460 return STATUS_SUCCESS
;
1463 static int ft1000_proc_drvmsg(struct ft1000_device
*dev
, u16 size
)
1465 struct ft1000_info
*info
= netdev_priv(dev
->net
);
1468 struct media_msg
*pmediamsg
;
1469 struct dsp_init_msg
*pdspinitmsg
;
1470 struct drv_msg
*pdrvmsg
;
1472 struct pseudo_hdr
*ppseudo_hdr
;
1480 char *cmdbuffer
= kmalloc(1600, GFP_KERNEL
);
1482 return STATUS_FAILURE
;
1484 status
= ft1000_read_dpram32(dev
, 0x200, cmdbuffer
, size
);
1487 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1488 for (i
= 0; i
< size
; i
+= 5) {
1490 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer
[i
],
1491 cmdbuffer
[i
+ 1], cmdbuffer
[i
+ 2],
1492 cmdbuffer
[i
+ 3], cmdbuffer
[i
+ 4]);
1494 for (j
= i
; j
< size
; j
++)
1495 DEBUG("0x%x ", cmdbuffer
[j
]);
1501 pdrvmsg
= (struct drv_msg
*)&cmdbuffer
[2];
1502 msgtype
= ntohs(pdrvmsg
->type
);
1503 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype
);
1507 ("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1509 pmediamsg
= (struct media_msg
*)&cmdbuffer
[0];
1510 if (info
->ProgConStat
!= 0xFF) {
1511 if (pmediamsg
->state
) {
1512 DEBUG("Media is up\n");
1513 if (info
->mediastate
== 0) {
1514 if (info
->NetDevRegDone
) {
1515 netif_wake_queue(dev
->
1518 info
->mediastate
= 1;
1521 DEBUG("Media is down\n");
1522 if (info
->mediastate
== 1) {
1523 info
->mediastate
= 0;
1524 if (info
->NetDevRegDone
) {
1530 DEBUG("Media is down\n");
1531 if (info
->mediastate
== 1) {
1532 info
->mediastate
= 0;
1540 ("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1542 pdspinitmsg
= (struct dsp_init_msg
*)&cmdbuffer
[2];
1543 memcpy(info
->DspVer
, pdspinitmsg
->DspVer
, DSPVERSZ
);
1544 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1545 info
->DspVer
[0], info
->DspVer
[1], info
->DspVer
[2],
1547 memcpy(info
->HwSerNum
, pdspinitmsg
->HwSerNum
,
1549 memcpy(info
->Sku
, pdspinitmsg
->Sku
, SKUSZ
);
1550 memcpy(info
->eui64
, pdspinitmsg
->eui64
, EUISZ
);
1551 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1552 info
->eui64
[0], info
->eui64
[1], info
->eui64
[2],
1553 info
->eui64
[3], info
->eui64
[4], info
->eui64
[5],
1554 info
->eui64
[6], info
->eui64
[7]);
1555 dev
->net
->dev_addr
[0] = info
->eui64
[0];
1556 dev
->net
->dev_addr
[1] = info
->eui64
[1];
1557 dev
->net
->dev_addr
[2] = info
->eui64
[2];
1558 dev
->net
->dev_addr
[3] = info
->eui64
[5];
1559 dev
->net
->dev_addr
[4] = info
->eui64
[6];
1560 dev
->net
->dev_addr
[5] = info
->eui64
[7];
1562 if (ntohs(pdspinitmsg
->length
) ==
1563 (sizeof(struct dsp_init_msg
) - 20)) {
1564 memcpy(info
->ProductMode
,
1565 pdspinitmsg
->ProductMode
, MODESZ
);
1566 memcpy(info
->RfCalVer
, pdspinitmsg
->RfCalVer
,
1568 memcpy(info
->RfCalDate
, pdspinitmsg
->RfCalDate
,
1570 DEBUG("RFCalVer = 0x%2x 0x%2x\n",
1571 info
->RfCalVer
[0], info
->RfCalVer
[1]);
1575 case DSP_PROVISION
:{
1577 ("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1579 /* kick off dspprov routine to start provisioning
1580 * Send provisioning data to DSP
1582 if (list_empty(&info
->prov_list
) == 0) {
1583 info
->fProvComplete
= 0;
1584 status
= ft1000_dsp_prov(dev
);
1585 if (status
!= STATUS_SUCCESS
)
1588 info
->fProvComplete
= 1;
1590 ft1000_write_register(dev
, FT1000_DB_HB
,
1591 FT1000_REG_DOORBELL
);
1593 ("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1595 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1598 case DSP_STORE_INFO
:{
1600 ("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1602 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1603 tempword
= ntohs(pdrvmsg
->length
);
1604 info
->DSPInfoBlklen
= tempword
;
1605 if (tempword
< (MAX_DSP_SESS_REC
- 4)) {
1606 pmsg
= (u16
*) &pdrvmsg
->data
[0];
1607 for (i
= 0; i
< ((tempword
+ 1) / 2); i
++) {
1609 ("FT1000:drivermsg:dsp info data = 0x%x\n",
1611 info
->DSPInfoBlk
[i
+ 10] = *pmsg
++;
1614 info
->DSPInfoBlklen
= 0;
1619 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1620 /* copy dsp info block to dsp */
1621 info
->DrvMsgPend
= 1;
1622 /* allow any outstanding ioctl to finish */
1625 ft1000_read_register(dev
, &tempword
,
1626 FT1000_REG_DOORBELL
);
1627 if (tempword
& FT1000_DB_DPRAM_TX
) {
1630 ft1000_read_register(dev
, &tempword
,
1631 FT1000_REG_DOORBELL
);
1632 if (tempword
& FT1000_DB_DPRAM_TX
) {
1635 ft1000_read_register(dev
, &tempword
,
1636 FT1000_REG_DOORBELL
);
1637 if (tempword
& FT1000_DB_DPRAM_TX
)
1641 /* Put message into Slow Queue
1642 * Form Pseudo header
1644 pmsg
= (u16
*) info
->DSPInfoBlk
;
1647 htons(info
->DSPInfoBlklen
+ 20 +
1648 info
->DSPInfoBlklen
);
1650 (struct pseudo_hdr
*)(u16
*) &info
->DSPInfoBlk
[2];
1651 ppseudo_hdr
->length
=
1652 htons(info
->DSPInfoBlklen
+ 4 +
1653 info
->DSPInfoBlklen
);
1654 ppseudo_hdr
->source
= 0x10;
1655 ppseudo_hdr
->destination
= 0x20;
1656 ppseudo_hdr
->portdest
= 0;
1657 ppseudo_hdr
->portsrc
= 0;
1658 ppseudo_hdr
->sh_str_id
= 0;
1659 ppseudo_hdr
->control
= 0;
1660 ppseudo_hdr
->rsvd1
= 0;
1661 ppseudo_hdr
->rsvd2
= 0;
1662 ppseudo_hdr
->qos_class
= 0;
1663 /* Insert slow queue sequence number */
1664 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
1665 /* Insert application id */
1666 ppseudo_hdr
->portsrc
= 0;
1667 /* Calculate new checksum */
1668 ppseudo_hdr
->checksum
= *pmsg
++;
1669 for (i
= 1; i
< 7; i
++)
1670 ppseudo_hdr
->checksum
^= *pmsg
++;
1672 info
->DSPInfoBlk
[10] = 0x7200;
1673 info
->DSPInfoBlk
[11] = htons(info
->DSPInfoBlklen
);
1675 ft1000_write_dpram32(dev
, 0,
1676 (u8
*) &info
->DSPInfoBlk
[0],
1677 (unsigned short)(info
->
1681 ft1000_write_register(dev
, FT1000_DB_DPRAM_TX
,
1682 FT1000_REG_DOORBELL
);
1683 info
->DrvMsgPend
= 0;
1688 case GET_DRV_ERR_RPT_MSG
:{
1689 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1690 /* copy driver error message to dsp */
1691 info
->DrvMsgPend
= 1;
1692 /* allow any outstanding ioctl to finish */
1695 ft1000_read_register(dev
, &tempword
,
1696 FT1000_REG_DOORBELL
);
1697 if (tempword
& FT1000_DB_DPRAM_TX
) {
1700 ft1000_read_register(dev
, &tempword
,
1701 FT1000_REG_DOORBELL
);
1702 if (tempword
& FT1000_DB_DPRAM_TX
)
1706 if ((tempword
& FT1000_DB_DPRAM_TX
) == 0) {
1707 /* Put message into Slow Queue
1708 * Form Pseudo header
1710 pmsg
= (u16
*) &tempbuffer
[0];
1711 ppseudo_hdr
= (struct pseudo_hdr
*)pmsg
;
1712 ppseudo_hdr
->length
= htons(0x0012);
1713 ppseudo_hdr
->source
= 0x10;
1714 ppseudo_hdr
->destination
= 0x20;
1715 ppseudo_hdr
->portdest
= 0;
1716 ppseudo_hdr
->portsrc
= 0;
1717 ppseudo_hdr
->sh_str_id
= 0;
1718 ppseudo_hdr
->control
= 0;
1719 ppseudo_hdr
->rsvd1
= 0;
1720 ppseudo_hdr
->rsvd2
= 0;
1721 ppseudo_hdr
->qos_class
= 0;
1722 /* Insert slow queue sequence number */
1723 ppseudo_hdr
->seq_num
= info
->squeseqnum
++;
1724 /* Insert application id */
1725 ppseudo_hdr
->portsrc
= 0;
1726 /* Calculate new checksum */
1727 ppseudo_hdr
->checksum
= *pmsg
++;
1728 for (i
= 1; i
< 7; i
++)
1729 ppseudo_hdr
->checksum
^= *pmsg
++;
1731 pmsg
= (u16
*) &tempbuffer
[16];
1732 *pmsg
++ = htons(RSP_DRV_ERR_RPT_MSG
);
1733 *pmsg
++ = htons(0x000e);
1734 *pmsg
++ = htons(info
->DSP_TIME
[0]);
1735 *pmsg
++ = htons(info
->DSP_TIME
[1]);
1736 *pmsg
++ = htons(info
->DSP_TIME
[2]);
1737 *pmsg
++ = htons(info
->DSP_TIME
[3]);
1738 convert
.byte
[0] = info
->DspVer
[0];
1739 convert
.byte
[1] = info
->DspVer
[1];
1740 *pmsg
++ = convert
.wrd
;
1741 convert
.byte
[0] = info
->DspVer
[2];
1742 convert
.byte
[1] = info
->DspVer
[3];
1743 *pmsg
++ = convert
.wrd
;
1744 *pmsg
++ = htons(info
->DrvErrNum
);
1746 card_send_command(dev
,
1747 (unsigned char *)&tempbuffer
[0],
1748 (u16
) (0x0012 + PSEUDOSZ
));
1749 info
->DrvErrNum
= 0;
1751 info
->DrvMsgPend
= 0;
1760 status
= STATUS_SUCCESS
;
1763 DEBUG("return from ft1000_proc_drvmsg\n");
1767 int ft1000_poll(void* dev_id
) {
1769 struct ft1000_device
*dev
= (struct ft1000_device
*)dev_id
;
1770 struct ft1000_info
*info
= netdev_priv(dev
->net
);
1780 struct dpram_blk
*pdpram_blk
;
1781 struct pseudo_hdr
*ppseudo_hdr
;
1782 unsigned long flags
;
1784 if (ft1000_chkcard(dev
) == FALSE
) {
1785 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1786 return STATUS_FAILURE
;
1789 status
= ft1000_read_register (dev
, &tempword
, FT1000_REG_DOORBELL
);
1794 if (tempword
& FT1000_DB_DPRAM_RX
) {
1796 status
= ft1000_read_dpram16(dev
, 0x200, (u8
*)&data
, 0);
1797 size
= ntohs(data
) + 16 + 2;
1799 modulo
= 4 - (size
% 4);
1800 size
= size
+ modulo
;
1802 status
= ft1000_read_dpram16(dev
, 0x201, (u8
*)&portid
, 1);
1805 if (size
< MAX_CMD_SQSIZE
) {
1809 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1811 status
= ft1000_proc_drvmsg (dev
, size
);
1812 if (status
!= STATUS_SUCCESS
)
1816 // This is a dsp broadcast message
1817 // Check which application has registered for dsp broadcast messages
1819 for (i
=0; i
<MAX_NUM_APP
; i
++) {
1820 if ( (info
->app_info
[i
].DspBCMsgFlag
) && (info
->app_info
[i
].fileobject
) &&
1821 (info
->app_info
[i
].NumOfMsg
< MAX_MSG_LIMIT
) )
1823 nxtph
= FT1000_DPRAM_RX_BASE
+ 2;
1824 pdpram_blk
= ft1000_get_buffer (&freercvpool
);
1825 if (pdpram_blk
!= NULL
) {
1826 if ( ft1000_receive_cmd(dev
, pdpram_blk
->pbuffer
, MAX_CMD_SQSIZE
, &nxtph
) ) {
1827 ppseudo_hdr
= (struct pseudo_hdr
*)pdpram_blk
->pbuffer
;
1828 // Put message into the appropriate application block
1829 info
->app_info
[i
].nRxMsg
++;
1830 spin_lock_irqsave(&free_buff_lock
, flags
);
1831 list_add_tail(&pdpram_blk
->list
, &info
->app_info
[i
].app_sqlist
);
1832 info
->app_info
[i
].NumOfMsg
++;
1833 spin_unlock_irqrestore(&free_buff_lock
, flags
);
1834 wake_up_interruptible(&info
->app_info
[i
].wait_dpram_msg
);
1837 info
->app_info
[i
].nRxMsgMiss
++;
1838 // Put memory back to free pool
1839 ft1000_free_buffer(pdpram_blk
, &freercvpool
);
1840 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1844 DEBUG("Out of memory in free receive command pool\n");
1845 info
->app_info
[i
].nRxMsgMiss
++;
1851 pdpram_blk
= ft1000_get_buffer (&freercvpool
);
1853 if (pdpram_blk
!= NULL
) {
1854 if ( ft1000_receive_cmd(dev
, pdpram_blk
->pbuffer
, MAX_CMD_SQSIZE
, &nxtph
) ) {
1855 ppseudo_hdr
= (struct pseudo_hdr
*)pdpram_blk
->pbuffer
;
1856 // Search for correct application block
1857 for (i
=0; i
<MAX_NUM_APP
; i
++) {
1858 if (info
->app_info
[i
].app_id
== ppseudo_hdr
->portdest
) {
1863 if (i
== MAX_NUM_APP
) {
1864 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr
->portdest
);
1865 // Put memory back to free pool
1866 ft1000_free_buffer(pdpram_blk
, &freercvpool
);
1869 if (info
->app_info
[i
].NumOfMsg
> MAX_MSG_LIMIT
) {
1870 // Put memory back to free pool
1871 ft1000_free_buffer(pdpram_blk
, &freercvpool
);
1874 info
->app_info
[i
].nRxMsg
++;
1875 // Put message into the appropriate application block
1876 list_add_tail(&pdpram_blk
->list
, &info
->app_info
[i
].app_sqlist
);
1877 info
->app_info
[i
].NumOfMsg
++;
1882 // Put memory back to free pool
1883 ft1000_free_buffer(pdpram_blk
, &freercvpool
);
1887 DEBUG("Out of memory in free receive command pool\n");
1893 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size
);
1895 status
= ft1000_write_register (dev
, FT1000_DB_DPRAM_RX
, FT1000_REG_DOORBELL
);
1897 else if (tempword
& FT1000_DSP_ASIC_RESET
) {
1899 // Let's reset the ASIC from the Host side as well
1900 status
= ft1000_write_register (dev
, ASIC_RESET_BIT
, FT1000_REG_RESET
);
1901 status
= ft1000_read_register (dev
, &tempword
, FT1000_REG_RESET
);
1903 while (tempword
& ASIC_RESET_BIT
) {
1904 status
= ft1000_read_register (dev
, &tempword
, FT1000_REG_RESET
);
1911 DEBUG("Unable to reset ASIC\n");
1912 return STATUS_SUCCESS
;
1915 // Program WMARK register
1916 status
= ft1000_write_register (dev
, 0x600, FT1000_REG_MAG_WATERMARK
);
1917 // clear ASIC reset doorbell
1918 status
= ft1000_write_register (dev
, FT1000_DSP_ASIC_RESET
, FT1000_REG_DOORBELL
);
1921 else if (tempword
& FT1000_ASIC_RESET_REQ
) {
1922 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1924 // clear ASIC reset request from DSP
1925 status
= ft1000_write_register (dev
, FT1000_ASIC_RESET_REQ
, FT1000_REG_DOORBELL
);
1926 status
= ft1000_write_register (dev
, HOST_INTF_BE
, FT1000_REG_SUP_CTRL
);
1927 // copy dsp session record from Adapter block
1928 status
= ft1000_write_dpram32 (dev
, 0, (u8
*)&info
->DSPSess
.Rec
[0], 1024);
1929 // Program WMARK register
1930 status
= ft1000_write_register (dev
, 0x600, FT1000_REG_MAG_WATERMARK
);
1931 // ring doorbell to tell DSP that ASIC is out of reset
1932 status
= ft1000_write_register (dev
, FT1000_ASIC_RESET_DSP
, FT1000_REG_DOORBELL
);
1934 else if (tempword
& FT1000_DB_COND_RESET
) {
1935 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1937 if (info
->fAppMsgPend
== 0) {
1938 // Reset ASIC and DSP
1940 status
= ft1000_read_dpram16(dev
, FT1000_MAG_DSP_TIMER0
, (u8
*)&(info
->DSP_TIME
[0]), FT1000_MAG_DSP_TIMER0_INDX
);
1941 status
= ft1000_read_dpram16(dev
, FT1000_MAG_DSP_TIMER1
, (u8
*)&(info
->DSP_TIME
[1]), FT1000_MAG_DSP_TIMER1_INDX
);
1942 status
= ft1000_read_dpram16(dev
, FT1000_MAG_DSP_TIMER2
, (u8
*)&(info
->DSP_TIME
[2]), FT1000_MAG_DSP_TIMER2_INDX
);
1943 status
= ft1000_read_dpram16(dev
, FT1000_MAG_DSP_TIMER3
, (u8
*)&(info
->DSP_TIME
[3]), FT1000_MAG_DSP_TIMER3_INDX
);
1944 info
->CardReady
= 0;
1945 info
->DrvErrNum
= DSP_CONDRESET_INFO
;
1946 DEBUG("ft1000_hw:DSP conditional reset requested\n");
1947 info
->ft1000_reset(dev
->net
);
1950 info
->fProvComplete
= 0;
1951 info
->fCondResetPend
= 1;
1954 ft1000_write_register(dev
, FT1000_DB_COND_RESET
, FT1000_REG_DOORBELL
);
1959 return STATUS_SUCCESS
;