1 //=====================================================
2 // CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
5 // This file is part of Express Card USB Driver
8 //====================================================
9 // 20090926; aelias; removed compiler warnings & errors; ubuntu 9.04; 2.6.28-15-generic
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h>
16 #include <linux/usb.h>
17 #include "ft1000_usb.h"
18 #include <linux/types.h>
20 #define HARLEY_READ_REGISTER 0x0
21 #define HARLEY_WRITE_REGISTER 0x01
22 #define HARLEY_READ_DPRAM_32 0x02
23 #define HARLEY_READ_DPRAM_LOW 0x03
24 #define HARLEY_READ_DPRAM_HIGH 0x04
25 #define HARLEY_WRITE_DPRAM_32 0x05
26 #define HARLEY_WRITE_DPRAM_LOW 0x06
27 #define HARLEY_WRITE_DPRAM_HIGH 0x07
29 #define HARLEY_READ_OPERATION 0xc1
30 #define HARLEY_WRITE_OPERATION 0x41
34 static int ft1000_reset(struct net_device *ft1000dev);
35 static int ft1000_submit_rx_urb(struct ft1000_info *info);
36 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
37 static int ft1000_open (struct net_device *dev);
38 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
39 static int ft1000_chkcard (struct ft1000_device *dev);
43 static u8 tempbuffer[1600];
45 #define MAX_RCV_LOOP 100
47 //---------------------------------------------------------------------------
48 // Function: ft1000_control
50 // Parameters: ft1000_device - device structure
51 // pipe - usb control message pipe
52 // request - control request
53 // requesttype - control message request type
54 // value - value to be written or 0
55 // index - register index
56 // data - data buffer to hold the read/write values
58 // timeout - control message time out value
60 // Returns: STATUS_SUCCESS - success
61 // STATUS_FAILURE - failure
63 // Description: This function sends a control message via USB interface synchronously
67 //---------------------------------------------------------------------------
68 static int ft1000_control(struct ft1000_device *ft1000dev, unsigned int pipe,
69 u8 request, u8 requesttype, u16 value, u16 index,
70 void *data, u16 size, int timeout)
74 if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
75 DEBUG("ft1000dev or ft1000dev->dev == NULL, failure\n");
79 ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
80 value, index, data, size, LARGE_TIMEOUT);
88 //---------------------------------------------------------------------------
89 // Function: ft1000_read_register
91 // Parameters: ft1000_device - device structure
92 // Data - data buffer to hold the value read
93 // nRegIndex - register index
95 // Returns: STATUS_SUCCESS - success
96 // STATUS_FAILURE - failure
98 // Description: This function returns the value in a register
102 //---------------------------------------------------------------------------
104 int ft1000_read_register(struct ft1000_device *ft1000dev, u16* Data,
107 int ret = STATUS_SUCCESS;
109 ret = ft1000_control(ft1000dev,
110 usb_rcvctrlpipe(ft1000dev->dev, 0),
111 HARLEY_READ_REGISTER,
112 HARLEY_READ_OPERATION,
122 //---------------------------------------------------------------------------
123 // Function: ft1000_write_register
125 // Parameters: ft1000_device - device structure
126 // value - value to write into a register
127 // nRegIndex - register index
129 // Returns: STATUS_SUCCESS - success
130 // STATUS_FAILURE - failure
132 // Description: This function writes the value in a register
136 //---------------------------------------------------------------------------
137 int ft1000_write_register(struct ft1000_device *ft1000dev, u16 value,
140 int ret = STATUS_SUCCESS;
142 ret = ft1000_control(ft1000dev,
143 usb_sndctrlpipe(ft1000dev->dev, 0),
144 HARLEY_WRITE_REGISTER,
145 HARLEY_WRITE_OPERATION,
155 //---------------------------------------------------------------------------
156 // Function: ft1000_read_dpram32
158 // Parameters: ft1000_device - device structure
159 // indx - starting address to read
160 // buffer - data buffer to hold the data read
161 // cnt - number of byte read from DPRAM
163 // Returns: STATUS_SUCCESS - success
164 // STATUS_FAILURE - failure
166 // Description: This function read a number of bytes from DPRAM
170 //---------------------------------------------------------------------------
172 int ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
175 int ret = STATUS_SUCCESS;
177 ret = ft1000_control(ft1000dev,
178 usb_rcvctrlpipe(ft1000dev->dev, 0),
179 HARLEY_READ_DPRAM_32,
180 HARLEY_READ_OPERATION,
190 //---------------------------------------------------------------------------
191 // Function: ft1000_write_dpram32
193 // Parameters: ft1000_device - device structure
194 // indx - starting address to write the data
195 // buffer - data buffer to write into DPRAM
196 // cnt - number of bytes to write
198 // Returns: STATUS_SUCCESS - success
199 // STATUS_FAILURE - failure
201 // Description: This function writes into DPRAM a number of bytes
205 //---------------------------------------------------------------------------
206 int ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
209 int ret = STATUS_SUCCESS;
212 cnt += cnt - (cnt % 4);
214 ret = ft1000_control(ft1000dev,
215 usb_sndctrlpipe(ft1000dev->dev, 0),
216 HARLEY_WRITE_DPRAM_32,
217 HARLEY_WRITE_OPERATION,
227 //---------------------------------------------------------------------------
228 // Function: ft1000_read_dpram16
230 // Parameters: ft1000_device - device structure
231 // indx - starting address to read
232 // buffer - data buffer to hold the data read
233 // hightlow - high or low 16 bit word
235 // Returns: STATUS_SUCCESS - success
236 // STATUS_FAILURE - failure
238 // Description: This function read 16 bits from DPRAM
242 //---------------------------------------------------------------------------
243 int ft1000_read_dpram16(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
246 int ret = STATUS_SUCCESS;
250 request = HARLEY_READ_DPRAM_LOW;
252 request = HARLEY_READ_DPRAM_HIGH;
254 ret = ft1000_control(ft1000dev,
255 usb_rcvctrlpipe(ft1000dev->dev, 0),
257 HARLEY_READ_OPERATION,
267 //---------------------------------------------------------------------------
268 // Function: ft1000_write_dpram16
270 // Parameters: ft1000_device - device structure
271 // indx - starting address to write the data
272 // value - 16bits value to write
273 // hightlow - high or low 16 bit word
275 // Returns: STATUS_SUCCESS - success
276 // STATUS_FAILURE - failure
278 // Description: This function writes into DPRAM a number of bytes
282 //---------------------------------------------------------------------------
283 int ft1000_write_dpram16(struct ft1000_device *ft1000dev, u16 indx, u16 value, u8 highlow)
285 int ret = STATUS_SUCCESS;
289 request = HARLEY_WRITE_DPRAM_LOW;
291 request = HARLEY_WRITE_DPRAM_HIGH;
293 ret = ft1000_control(ft1000dev,
294 usb_sndctrlpipe(ft1000dev->dev, 0),
296 HARLEY_WRITE_OPERATION,
306 //---------------------------------------------------------------------------
307 // Function: fix_ft1000_read_dpram32
309 // Parameters: ft1000_device - device structure
310 // indx - starting address to read
311 // buffer - data buffer to hold the data read
314 // Returns: STATUS_SUCCESS - success
315 // STATUS_FAILURE - failure
317 // Description: This function read DPRAM 4 words at a time
321 //---------------------------------------------------------------------------
322 int fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx,
327 int ret = STATUS_SUCCESS;
329 pos = (indx / 4) * 4;
330 ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
332 if (ret == STATUS_SUCCESS) {
333 pos = (indx % 4) * 4;
334 *buffer++ = buf[pos++];
335 *buffer++ = buf[pos++];
336 *buffer++ = buf[pos++];
337 *buffer++ = buf[pos++];
339 DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
350 //---------------------------------------------------------------------------
351 // Function: fix_ft1000_write_dpram32
353 // Parameters: ft1000_device - device structure
354 // indx - starting address to write
355 // buffer - data buffer to write
358 // Returns: STATUS_SUCCESS - success
359 // STATUS_FAILURE - failure
361 // Description: This function write to DPRAM 4 words at a time
365 //---------------------------------------------------------------------------
366 int fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
374 int ret = STATUS_SUCCESS;
376 pos1 = (indx / 4) * 4;
378 ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
380 if (ret == STATUS_SUCCESS) {
382 buf[pos2++] = *buffer++;
383 buf[pos2++] = *buffer++;
384 buf[pos2++] = *buffer++;
385 buf[pos2++] = *buffer++;
386 ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
388 DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
392 ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
394 if (ret == STATUS_SUCCESS) {
396 for (i = 0; i < 16; i++) {
397 if (buf[i] != resultbuffer[i])
398 ret = STATUS_FAILURE;
402 if (ret == STATUS_FAILURE) {
403 ret = ft1000_write_dpram32(ft1000dev, pos1,
404 (u8 *)&tempbuffer[0], 16);
405 ret = ft1000_read_dpram32(ft1000dev, pos1,
406 (u8 *)&resultbuffer[0], 16);
407 if (ret == STATUS_SUCCESS) {
409 for (i = 0; i < 16; i++) {
410 if (tempbuffer[i] != resultbuffer[i]) {
411 ret = STATUS_FAILURE;
412 DEBUG("%s Failed to write\n",
423 //------------------------------------------------------------------------
425 // Function: card_reset_dsp
427 // Synopsis: This function is called to reset or activate the DSP
429 // Arguments: value - reset or activate
432 //-----------------------------------------------------------------------
433 static void card_reset_dsp(struct ft1000_device *ft1000dev, bool value)
435 u16 status = STATUS_SUCCESS;
438 status = ft1000_write_register(ft1000dev, HOST_INTF_BE,
439 FT1000_REG_SUP_CTRL);
440 status = ft1000_read_register(ft1000dev, &tempword,
441 FT1000_REG_SUP_CTRL);
444 DEBUG("Reset DSP\n");
445 status = ft1000_read_register(ft1000dev, &tempword,
447 tempword |= DSP_RESET_BIT;
448 status = ft1000_write_register(ft1000dev, tempword,
451 DEBUG("Activate DSP\n");
452 status = ft1000_read_register(ft1000dev, &tempword,
454 tempword |= DSP_ENCRYPTED;
455 tempword &= ~DSP_UNENCRYPTED;
456 status = ft1000_write_register(ft1000dev, tempword,
458 status = ft1000_read_register(ft1000dev, &tempword,
460 tempword &= ~EFUSE_MEM_DISABLE;
461 tempword &= ~DSP_RESET_BIT;
462 status = ft1000_write_register(ft1000dev, tempword,
464 status = ft1000_read_register(ft1000dev, &tempword,
469 //---------------------------------------------------------------------------
470 // Function: card_send_command
472 // Parameters: ft1000_device - device structure
473 // ptempbuffer - command buffer
474 // size - command buffer size
476 // Returns: STATUS_SUCCESS - success
477 // STATUS_FAILURE - failure
479 // Description: This function sends a command to ASIC
483 //---------------------------------------------------------------------------
484 void card_send_command(struct ft1000_device *ft1000dev, void *ptempbuffer,
488 unsigned char *commandbuf;
490 DEBUG("card_send_command: enter card_send_command... size=%d\n", size);
492 commandbuf = (unsigned char *)kmalloc(size + 2, GFP_KERNEL);
493 memcpy((void *)commandbuf + 2, (void *)ptempbuffer, size);
495 //DEBUG("card_send_command: Command Send\n");
497 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
502 /* check for odd word */
505 /* Must force to be 32 bit aligned */
507 size += 4 - (size % 4);
509 //DEBUG("card_send_command: write dpram ... size=%d\n", size);
510 ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
512 //DEBUG("card_send_command: write into doorbell ...\n");
513 ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
514 FT1000_REG_DOORBELL);
517 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
518 //DEBUG("card_send_command: read doorbell ...temp=%x\n", temp);
519 if ((temp & 0x0100) == 0) {
520 //DEBUG("card_send_command: Message sent\n");
525 //--------------------------------------------------------------------------
527 // Function: dsp_reload
529 // Synopsis: This function is called to load or reload the DSP
531 // Arguments: ft1000dev - device structure
534 //-----------------------------------------------------------------------
535 int dsp_reload(struct ft1000_device *ft1000dev)
541 struct ft1000_info *pft1000info;
543 pft1000info = netdev_priv(ft1000dev->net);
545 pft1000info->CardReady = 0;
547 /* Program Interrupt Mask register */
548 status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
550 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
551 tempword |= ASIC_RESET_BIT;
552 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
554 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
555 DEBUG("Reset Register = 0x%x\n", tempword);
557 /* Toggle DSP reset */
558 card_reset_dsp(ft1000dev, 1);
560 card_reset_dsp(ft1000dev, 0);
564 ft1000_write_register(ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
566 /* Let's check for FEFE */
568 ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
569 (u8 *) &templong, 4);
570 DEBUG("templong (fefe) = 0x%8x\n", templong);
572 /* call codeloader */
573 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
575 if (status != STATUS_SUCCESS)
580 DEBUG("dsp_reload returned\n");
585 //---------------------------------------------------------------------------
587 // Function: ft1000_reset_asic
588 // Description: This function will call the Card Service function to reset the
591 // dev - device structure
595 //---------------------------------------------------------------------------
596 static void ft1000_reset_asic(struct net_device *dev)
598 struct ft1000_info *info = netdev_priv(dev);
599 struct ft1000_device *ft1000dev = info->pFt1000Dev;
602 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
604 info->ASICResetNum++;
606 /* Let's use the register provided by the Magnemite ASIC to reset the
609 ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT),
614 /* set watermark to -1 in order to not generate an interrrupt */
615 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
617 /* clear interrupts */
618 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
619 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
620 ft1000_write_register(ft1000dev, tempword, FT1000_REG_SUP_ISR);
621 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
622 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
626 //---------------------------------------------------------------------------
628 // Function: ft1000_reset_card
629 // Description: This function will reset the card
631 // dev - device structure
633 // status - FALSE (card reset fail)
634 // TRUE (card reset successful)
636 //---------------------------------------------------------------------------
637 static int ft1000_reset_card(struct net_device *dev)
639 struct ft1000_info *info = netdev_priv(dev);
640 struct ft1000_device *ft1000dev = info->pFt1000Dev;
642 struct prov_record *ptr;
644 DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
646 info->fCondResetPend = 1;
648 info->fProvComplete = 0;
650 /* Make sure we free any memory reserve for provisioning */
651 while (list_empty(&info->prov_list) == 0) {
652 DEBUG("ft1000_reset_card:deleting provisioning record\n");
654 list_entry(info->prov_list.next, struct prov_record, list);
655 list_del(&ptr->list);
656 kfree(ptr->pprov_data);
660 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
661 ft1000_reset_asic(dev);
665 DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
666 dsp_reload(ft1000dev);
668 DEBUG("dsp reload successful\n");
672 /* Initialize DSP heartbeat area */
673 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
674 FT1000_MAG_HI_HO_INDX);
675 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *) &tempword,
676 FT1000_MAG_HI_HO_INDX);
677 DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
681 info->fCondResetPend = 0;
688 #ifdef HAVE_NET_DEVICE_OPS
689 static const struct net_device_ops ftnet_ops =
691 .ndo_open = &ft1000_open,
692 .ndo_stop = &ft1000_close,
693 .ndo_start_xmit = &ft1000_start_xmit,
694 .ndo_get_stats = &ft1000_netdev_stats,
699 //---------------------------------------------------------------------------
700 // Function: init_ft1000_netdev
702 // Parameters: ft1000dev - device structure
705 // Returns: STATUS_SUCCESS - success
706 // STATUS_FAILURE - failure
708 // Description: This function initialize the network device
712 //---------------------------------------------------------------------------
713 int init_ft1000_netdev(struct ft1000_device *ft1000dev)
715 struct net_device *netdev;
716 struct ft1000_info *pInfo = NULL;
717 struct dpram_blk *pdpram_blk;
719 struct list_head *cur, *tmp;
721 unsigned long gCardIndex = 0;
723 DEBUG("Enter init_ft1000_netdev...\n");
725 netdev = alloc_etherdev(sizeof(struct ft1000_info));
727 DEBUG("init_ft1000_netdev: can not allocate network device\n");
731 pInfo = netdev_priv(netdev);
733 memset(pInfo, 0, sizeof(struct ft1000_info));
735 dev_alloc_name(netdev, netdev->name);
737 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
739 if (strncmp(netdev->name, "eth", 3) == 0) {
740 card_nr[0] = netdev->name[3];
742 ret_val = strict_strtoul(card_nr, 10, &gCardIndex);
744 printk(KERN_ERR "Can't parse netdev\n");
748 pInfo->CardNumber = gCardIndex;
749 DEBUG("card number = %d\n", pInfo->CardNumber);
751 printk(KERN_ERR "ft1000: Invalid device name\n");
756 memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
758 spin_lock_init(&pInfo->dpram_lock);
759 pInfo->pFt1000Dev = ft1000dev;
760 pInfo->DrvErrNum = 0;
761 pInfo->ASICResetNum = 0;
762 pInfo->registered = 1;
763 pInfo->ft1000_reset = ft1000_reset;
764 pInfo->mediastate = 0;
766 pInfo->DeviceCreated = FALSE;
767 pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
768 pInfo->InterruptsEnabled = FALSE;
769 pInfo->CardReady = 0;
770 pInfo->DSP_TIME[0] = 0;
771 pInfo->DSP_TIME[1] = 0;
772 pInfo->DSP_TIME[2] = 0;
773 pInfo->DSP_TIME[3] = 0;
774 pInfo->fAppMsgPend = 0;
775 pInfo->fCondResetPend = 0;
778 memset(&pInfo->tempbuf[0], 0, sizeof(pInfo->tempbuf));
780 INIT_LIST_HEAD(&pInfo->prov_list);
782 INIT_LIST_HEAD(&pInfo->nodes.list);
784 #ifdef HAVE_NET_DEVICE_OPS
785 netdev->netdev_ops = &ftnet_ops;
787 netdev->hard_start_xmit = &ft1000_start_xmit;
788 netdev->get_stats = &ft1000_netdev_stats;
789 netdev->open = &ft1000_open;
790 netdev->stop = &ft1000_close;
793 ft1000dev->net = netdev;
795 DEBUG("Initialize free_buff_lock and freercvpool\n");
796 spin_lock_init(&free_buff_lock);
798 /* initialize a list of buffers to be use for queuing
799 * up receive command data
801 INIT_LIST_HEAD(&freercvpool);
803 /* create list of free buffers */
804 for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
805 /* Get memory for DPRAM_DATA link list */
806 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
807 if (pdpram_blk == NULL) {
811 /* Get a block of memory to store command data */
812 pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
813 if (pdpram_blk->pbuffer == NULL) {
818 /* link provisioning data */
819 list_add_tail(&pdpram_blk->list, &freercvpool);
821 numofmsgbuf = NUM_OF_FREE_BUFFERS;
826 list_for_each_safe(cur, tmp, &freercvpool) {
827 pdpram_blk = list_entry(cur, struct dpram_blk, list);
828 list_del(&pdpram_blk->list);
829 kfree(pdpram_blk->pbuffer);
837 //---------------------------------------------------------------------------
838 // Function: reg_ft1000_netdev
840 // Parameters: ft1000dev - device structure
843 // Returns: STATUS_SUCCESS - success
844 // STATUS_FAILURE - failure
846 // Description: This function register the network driver
850 //---------------------------------------------------------------------------
851 int reg_ft1000_netdev(struct ft1000_device *ft1000dev,
852 struct usb_interface *intf)
854 struct net_device *netdev;
855 struct ft1000_info *pInfo;
858 netdev = ft1000dev->net;
859 pInfo = netdev_priv(ft1000dev->net);
860 DEBUG("Enter reg_ft1000_netdev...\n");
862 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
864 usb_set_intfdata(intf, pInfo);
865 SET_NETDEV_DEV(netdev, &intf->dev);
867 rc = register_netdev(netdev);
869 DEBUG("reg_ft1000_netdev: could not register network device\n");
874 ft1000_create_dev(ft1000dev);
876 DEBUG("reg_ft1000_netdev returned\n");
878 pInfo->CardReady = 1;
883 static int ft1000_reset(struct net_device *dev)
885 ft1000_reset_card(dev);
889 //---------------------------------------------------------------------------
890 // Function: ft1000_usb_transmit_complete
892 // Parameters: urb - transmitted usb urb
897 // Description: This is the callback function when a urb is transmitted
901 //---------------------------------------------------------------------------
902 static void ft1000_usb_transmit_complete(struct urb *urb)
905 struct ft1000_device *ft1000dev = urb->context;
907 //DEBUG("ft1000_usb_transmit_complete entered\n");
910 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
912 netif_wake_queue(ft1000dev->net);
914 //DEBUG("Return from ft1000_usb_transmit_complete\n");
917 //---------------------------------------------------------------------------
919 // Function: ft1000_copy_down_pkt
920 // Description: This function will take an ethernet packet and convert it to
921 // a Flarion packet prior to sending it to the ASIC Downlink
924 // dev - device structure
925 // packet - address of ethernet packet
926 // len - length of IP packet
931 //---------------------------------------------------------------------------
932 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 * packet, u16 len)
934 struct ft1000_info *pInfo = netdev_priv(netdev);
935 struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
939 struct pseudo_hdr hdr;
941 if (!pInfo->CardReady) {
942 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
946 //DEBUG("ft1000_copy_down_pkt() entered, len = %d\n", len);
948 count = sizeof(struct pseudo_hdr) + len;
949 if (count > MAX_BUF_SIZE) {
950 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
951 DEBUG("size = %d\n", count);
956 count = count + (4 - (count % 4));
958 memset(&hdr, 0, sizeof(struct pseudo_hdr));
960 hdr.length = ntohs(count);
962 hdr.destination = 0x20;
965 hdr.sh_str_id = 0x91;
968 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
969 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
971 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
972 memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
974 netif_stop_queue(netdev);
976 //DEBUG ("ft1000_copy_down_pkt: count = %d\n", count);
978 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
980 usb_sndbulkpipe(pFt1000Dev->dev,
981 pFt1000Dev->bulk_out_endpointAddr),
982 pFt1000Dev->tx_buf, count,
983 ft1000_usb_transmit_complete, (void *)pFt1000Dev);
985 t = (u8 *) pFt1000Dev->tx_urb->transfer_buffer;
986 //DEBUG("transfer_length=%d\n", pFt1000Dev->tx_urb->transfer_buffer_length);
987 /*for (i=0; i<count; i++ )
992 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
995 DEBUG("ft1000 failed tx_urb %d\n", ret);
998 pInfo->stats.tx_packets++;
999 pInfo->stats.tx_bytes += (len + 14);
1002 //DEBUG("ft1000_copy_down_pkt() exit\n");
1008 //---------------------------------------------------------------------------
1009 // Function: ft1000_start_xmit
1011 // Parameters: skb - socket buffer to be sent
1012 // dev - network device
1017 // Description: transmit a ethernet packet
1021 //---------------------------------------------------------------------------
1022 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1024 struct ft1000_info *pInfo = netdev_priv(dev);
1025 struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
1029 //DEBUG(" ft1000_start_xmit() entered\n");
1032 DEBUG("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n");
1033 return NETDEV_TX_OK;
1036 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
1037 DEBUG("network driver is closed, return\n");
1040 //DEBUG("ft1000_start_xmit 1:length of packet = %d\n", skb->len);
1042 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1043 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1044 //DEBUG("ft1000_start_xmit 2: pipe=%d dev->maxpacket = %d\n", pipe, maxlen);
1046 pdata = (u8 *) skb->data;
1047 /*for (i=0; i<skb->len; i++)
1048 DEBUG("skb->data[%d]=%x ", i, *(skb->data+i));
1052 if (pInfo->mediastate == 0) {
1053 /* Drop packet is mediastate is down */
1054 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1058 if ((skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE)) {
1059 /* Drop packet which has invalid size */
1060 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1064 ft1000_copy_down_pkt(dev, (pdata + ENET_HEADER_SIZE - 2),
1065 skb->len - ENET_HEADER_SIZE + 2);
1069 //DEBUG(" ft1000_start_xmit() exit\n");
1071 return NETDEV_TX_OK;
1075 //---------------------------------------------------------------------------
1077 // Function: ft1000_copy_up_pkt
1078 // Description: This function will take a packet from the FIFO up link and
1079 // convert it into an ethernet packet and deliver it to the IP stack
1081 // urb - the receiving usb urb
1087 //---------------------------------------------------------------------------
1088 static int ft1000_copy_up_pkt(struct urb *urb)
1090 struct ft1000_info *info = urb->context;
1091 struct ft1000_device *ft1000dev = info->pFt1000Dev;
1092 struct net_device *net = ft1000dev->net;
1097 struct sk_buff *skb;
1103 //DEBUG("ft1000_copy_up_pkt entered\n");
1105 if (ft1000dev->status & FT1000_STATUS_CLOSING) {
1106 DEBUG("network driver is closed, return\n");
1107 return STATUS_SUCCESS;
1110 len = urb->transfer_buffer_length;
1111 lena = urb->actual_length; //mbelian
1112 //DEBUG("ft1000_copy_up_pkt: transfer_buffer_length=%d, actual_buffer_len=%d\n",
1113 // urb->transfer_buffer_length, urb->actual_length);
1115 chksum = (u16 *) ft1000dev->rx_buf;
1117 tempword = *chksum++;
1118 for (i = 1; i < 7; i++)
1119 tempword ^= *chksum++;
1121 if (tempword != *chksum) {
1122 info->stats.rx_errors++;
1123 ft1000_submit_rx_urb(info);
1124 return STATUS_FAILURE;
1127 //DEBUG("ft1000_copy_up_pkt: checksum is correct %x\n", *chksum);
1129 skb = dev_alloc_skb(len + 12 + 2);
1132 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1133 info->stats.rx_errors++;
1134 ft1000_submit_rx_urb(info);
1135 return STATUS_FAILURE;
1138 pbuffer = (u8 *) skb_put(skb, len + 12);
1140 /* subtract the number of bytes read already */
1143 /* fake MAC address */
1144 *pbuffer++ = net->dev_addr[0];
1145 *pbuffer++ = net->dev_addr[1];
1146 *pbuffer++ = net->dev_addr[2];
1147 *pbuffer++ = net->dev_addr[3];
1148 *pbuffer++ = net->dev_addr[4];
1149 *pbuffer++ = net->dev_addr[5];
1157 memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
1158 len - sizeof(struct pseudo_hdr));
1160 //DEBUG("ft1000_copy_up_pkt: Data passed to Protocol layer\n");
1161 /*for (i=0; i<len+12; i++)
1163 DEBUG("ft1000_copy_up_pkt: Protocol Data: 0x%x\n ", *ptemp++);
1168 skb->protocol = eth_type_trans(skb, net);
1169 skb->ip_summed = CHECKSUM_UNNECESSARY;
1172 info->stats.rx_packets++;
1173 /* Add on 12 bytes for MAC address which was removed */
1174 info->stats.rx_bytes += (lena + 12); //mbelian
1176 ft1000_submit_rx_urb(info);
1177 //DEBUG("ft1000_copy_up_pkt exited\n");
1182 //---------------------------------------------------------------------------
1184 // Function: ft1000_submit_rx_urb
1185 // Description: the receiving function of the network driver
1188 // info - a private structure contains the device information
1194 //---------------------------------------------------------------------------
1195 static int ft1000_submit_rx_urb(struct ft1000_info *info)
1198 struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1200 //DEBUG ("ft1000_submit_rx_urb entered: sizeof rx_urb is %d\n", sizeof(*pFt1000Dev->rx_urb));
1201 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
1202 DEBUG("network driver is closed, return\n");
1203 //usb_kill_urb(pFt1000Dev->rx_urb); //mbelian
1207 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1209 usb_rcvbulkpipe(pFt1000Dev->dev,
1210 pFt1000Dev->bulk_in_endpointAddr),
1211 pFt1000Dev->rx_buf, MAX_BUF_SIZE,
1212 (usb_complete_t) ft1000_copy_up_pkt, info);
1214 result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
1217 pr_err("ft1000_submit_rx_urb: submitting rx_urb %d failed\n",
1221 //DEBUG("ft1000_submit_rx_urb exit: result=%d\n", result);
1227 //---------------------------------------------------------------------------
1228 // Function: ft1000_open
1231 // dev - network device
1236 // Description: open the network driver
1240 //---------------------------------------------------------------------------
1241 static int ft1000_open(struct net_device *dev)
1243 struct ft1000_info *pInfo = netdev_priv(dev);
1244 struct timeval tv; //mbelian
1247 DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1248 //DEBUG("ft1000_open: dev->addr=%x, dev->addr_len=%d\n", dev->addr, dev->addr_len);
1250 pInfo->stats.rx_bytes = 0; //mbelian
1251 pInfo->stats.tx_bytes = 0; //mbelian
1252 pInfo->stats.rx_packets = 0; //mbelian
1253 pInfo->stats.tx_packets = 0; //mbelian
1254 do_gettimeofday(&tv);
1255 pInfo->ConTm = tv.tv_sec;
1256 pInfo->ProgConStat = 0; //mbelian
1258 netif_start_queue(dev);
1260 netif_carrier_on(dev); //mbelian
1262 ret = ft1000_submit_rx_urb(pInfo);
1267 //---------------------------------------------------------------------------
1268 // Function: ft1000_close
1271 // net - network device
1276 // Description: close the network driver
1280 //---------------------------------------------------------------------------
1281 int ft1000_close(struct net_device *net)
1283 struct ft1000_info *pInfo = netdev_priv(net);
1284 struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1286 //DEBUG ("ft1000_close: netdev->refcnt=%d\n", net->refcnt);
1288 ft1000dev->status |= FT1000_STATUS_CLOSING;
1290 //DEBUG("ft1000_close: calling usb_kill_urb \n");
1292 DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1293 netif_carrier_off(net); //mbelian
1294 netif_stop_queue(net);
1295 //DEBUG("ft1000_close: netif_stop_queue called\n");
1296 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1298 pInfo->ProgConStat = 0xff; //mbelian
1303 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1305 struct ft1000_info *info = netdev_priv(dev);
1307 return &(info->stats); //mbelian
1311 /*********************************************************************************
1316 //---------------------------------------------------------------------------
1318 // Function: ft1000_chkcard
1319 // Description: This function will check if the device is presently available on
1322 // dev - device structure
1324 // status - FALSE (device is not present)
1325 // TRUE (device is present)
1327 //---------------------------------------------------------------------------
1328 static int ft1000_chkcard(struct ft1000_device *dev)
1332 struct ft1000_info *info = netdev_priv(dev->net);
1334 if (info->fCondResetPend) {
1336 ("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1339 /* Mask register is used to check for device presence since it is never
1342 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1343 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_SUP_IMASK = %x\n", tempword);
1344 if (tempword == 0) {
1346 ("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1349 /* The system will return the value of 0xffff for the version register
1350 * if the device is not present.
1352 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1353 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_ASIC_ID = %x\n", tempword);
1354 if (tempword != 0x1b01) {
1355 dev->status |= FT1000_STATUS_CLOSING; //mbelian
1357 ("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1363 //---------------------------------------------------------------------------
1365 // Function: ft1000_receive_cmd
1366 // Description: This function will read a message from the dpram area.
1368 // dev - network device structure
1369 // pbuffer - caller supply address to buffer
1370 // pnxtph - pointer to next pseudo header
1372 // Status = 0 (unsuccessful)
1375 //---------------------------------------------------------------------------
1376 static bool ft1000_receive_cmd(struct ft1000_device *dev, u16 *pbuffer,
1377 int maxsz, u16 *pnxtph)
1385 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *) &size,
1386 FT1000_MAG_PH_LEN_INDX);
1387 size = ntohs(size) + PSEUDOSZ;
1389 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n",
1393 ppseudohdr = (u16 *) pbuffer;
1394 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
1395 FT1000_REG_DPRAM_ADDR);
1397 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1398 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1400 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
1401 FT1000_REG_DPRAM_ADDR);
1402 for (i = 0; i <= (size >> 2); i++) {
1404 ft1000_read_register(dev, pbuffer,
1405 FT1000_REG_MAG_DPDATAL);
1408 ft1000_read_register(dev, pbuffer,
1409 FT1000_REG_MAG_DPDATAH);
1412 /* copy odd aligned word */
1414 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1415 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1418 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1419 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1421 if (size & 0x0001) {
1422 /* copy odd byte from fifo */
1424 ft1000_read_register(dev, &tempword,
1425 FT1000_REG_DPRAM_DATA);
1426 *pbuffer = ntohs(tempword);
1428 /* Check if pseudo header checksum is good
1429 * Calculate pseudo header checksum
1431 tempword = *ppseudohdr++;
1432 for (i = 1; i < 7; i++)
1433 tempword ^= *ppseudohdr++;
1435 if ((tempword != *ppseudohdr))
1442 static int ft1000_dsp_prov(void *arg)
1444 struct ft1000_device *dev = (struct ft1000_device *)arg;
1445 struct ft1000_info *info = netdev_priv(dev->net);
1449 struct prov_record *ptr;
1450 struct pseudo_hdr *ppseudo_hdr;
1453 u16 TempShortBuf[256];
1455 DEBUG("*** DspProv Entered\n");
1457 while (list_empty(&info->prov_list) == 0) {
1458 DEBUG("DSP Provisioning List Entry\n");
1460 /* Check if doorbell is available */
1461 DEBUG("check if doorbell is cleared\n");
1463 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1465 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1469 while (tempword & FT1000_DB_DPRAM_TX) {
1473 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1474 return STATUS_FAILURE;
1476 ft1000_read_register(dev, &tempword,
1477 FT1000_REG_DOORBELL);
1480 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1481 DEBUG("*** Provision Data Sent to DSP\n");
1483 /* Send provisioning data */
1485 list_entry(info->prov_list.next, struct prov_record,
1487 len = *(u16 *) ptr->pprov_data;
1491 pmsg = (u16 *) ptr->pprov_data;
1492 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1493 /* Insert slow queue sequence number */
1494 ppseudo_hdr->seq_num = info->squeseqnum++;
1495 ppseudo_hdr->portsrc = 0;
1496 /* Calculate new checksum */
1497 ppseudo_hdr->checksum = *pmsg++;
1498 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1499 for (i = 1; i < 7; i++) {
1500 ppseudo_hdr->checksum ^= *pmsg++;
1501 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1504 TempShortBuf[0] = 0;
1505 TempShortBuf[1] = htons(len);
1506 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1509 ft1000_write_dpram32(dev, 0,
1510 (u8 *) &TempShortBuf[0],
1511 (unsigned short)(len + 2));
1513 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1514 FT1000_REG_DOORBELL);
1516 list_del(&ptr->list);
1517 kfree(ptr->pprov_data);
1523 DEBUG("DSP Provisioning List Entry finished\n");
1527 info->fProvComplete = 1;
1528 info->CardReady = 1;
1530 return STATUS_SUCCESS;
1533 static int ft1000_proc_drvmsg(struct ft1000_device *dev, u16 size)
1535 struct ft1000_info *info = netdev_priv(dev->net);
1538 struct media_msg *pmediamsg;
1539 struct dsp_init_msg *pdspinitmsg;
1540 struct drv_msg *pdrvmsg;
1542 struct pseudo_hdr *ppseudo_hdr;
1550 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1552 return STATUS_FAILURE;
1554 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1557 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1558 for (i = 0; i < size; i += 5) {
1560 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i],
1561 cmdbuffer[i + 1], cmdbuffer[i + 2],
1562 cmdbuffer[i + 3], cmdbuffer[i + 4]);
1564 for (j = i; j < size; j++)
1565 DEBUG("0x%x ", cmdbuffer[j]);
1571 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1572 msgtype = ntohs(pdrvmsg->type);
1573 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1577 ("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1579 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1580 if (info->ProgConStat != 0xFF) {
1581 if (pmediamsg->state) {
1582 DEBUG("Media is up\n");
1583 if (info->mediastate == 0) {
1584 if (info->NetDevRegDone) {
1585 //netif_carrier_on(dev->net);//mbelian
1586 netif_wake_queue(dev->
1589 info->mediastate = 1;
1590 /*do_gettimeofday(&tv);
1591 info->ConTm = tv.tv_sec; *///mbelian
1594 DEBUG("Media is down\n");
1595 if (info->mediastate == 1) {
1596 info->mediastate = 0;
1597 if (info->NetDevRegDone) {
1598 //netif_carrier_off(dev->net); mbelian
1599 //netif_stop_queue(dev->net);
1605 DEBUG("Media is down\n");
1606 if (info->mediastate == 1) {
1607 info->mediastate = 0;
1608 if (info->NetDevRegDone) {
1609 //netif_carrier_off(dev->net); //mbelian
1610 //netif_stop_queue(dev->net);
1619 ("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1621 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1622 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1623 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1624 info->DspVer[0], info->DspVer[1], info->DspVer[2],
1626 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1628 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1629 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1630 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1631 info->eui64[0], info->eui64[1], info->eui64[2],
1632 info->eui64[3], info->eui64[4], info->eui64[5],
1633 info->eui64[6], info->eui64[7]);
1634 dev->net->dev_addr[0] = info->eui64[0];
1635 dev->net->dev_addr[1] = info->eui64[1];
1636 dev->net->dev_addr[2] = info->eui64[2];
1637 dev->net->dev_addr[3] = info->eui64[5];
1638 dev->net->dev_addr[4] = info->eui64[6];
1639 dev->net->dev_addr[5] = info->eui64[7];
1641 if (ntohs(pdspinitmsg->length) ==
1642 (sizeof(struct dsp_init_msg) - 20)) {
1643 memcpy(info->ProductMode,
1644 pdspinitmsg->ProductMode, MODESZ);
1645 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer,
1647 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1649 DEBUG("RFCalVer = 0x%2x 0x%2x\n",
1650 info->RfCalVer[0], info->RfCalVer[1]);
1654 case DSP_PROVISION:{
1656 ("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1658 /* kick off dspprov routine to start provisioning
1659 * Send provisioning data to DSP
1661 if (list_empty(&info->prov_list) == 0) {
1662 info->fProvComplete = 0;
1663 status = ft1000_dsp_prov(dev);
1664 if (status != STATUS_SUCCESS)
1667 info->fProvComplete = 1;
1669 ft1000_write_register(dev, FT1000_DB_HB,
1670 FT1000_REG_DOORBELL);
1672 ("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1674 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1677 case DSP_STORE_INFO:{
1679 ("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1681 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1682 tempword = ntohs(pdrvmsg->length);
1683 info->DSPInfoBlklen = tempword;
1684 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1685 pmsg = (u16 *) &pdrvmsg->data[0];
1686 for (i = 0; i < ((tempword + 1) / 2); i++) {
1688 ("FT1000:drivermsg:dsp info data = 0x%x\n",
1690 info->DSPInfoBlk[i + 10] = *pmsg++;
1693 info->DSPInfoBlklen = 0;
1698 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1699 /* copy dsp info block to dsp */
1700 info->DrvMsgPend = 1;
1701 /* allow any outstanding ioctl to finish */
1704 ft1000_read_register(dev, &tempword,
1705 FT1000_REG_DOORBELL);
1706 if (tempword & FT1000_DB_DPRAM_TX) {
1709 ft1000_read_register(dev, &tempword,
1710 FT1000_REG_DOORBELL);
1711 if (tempword & FT1000_DB_DPRAM_TX) {
1714 ft1000_read_register(dev, &tempword,
1715 FT1000_REG_DOORBELL);
1716 if (tempword & FT1000_DB_DPRAM_TX)
1720 /* Put message into Slow Queue
1721 * Form Pseudo header
1723 pmsg = (u16 *) info->DSPInfoBlk;
1726 htons(info->DSPInfoBlklen + 20 +
1727 info->DSPInfoBlklen);
1729 (struct pseudo_hdr *)(u16 *) &info->DSPInfoBlk[2];
1730 ppseudo_hdr->length =
1731 htons(info->DSPInfoBlklen + 4 +
1732 info->DSPInfoBlklen);
1733 ppseudo_hdr->source = 0x10;
1734 ppseudo_hdr->destination = 0x20;
1735 ppseudo_hdr->portdest = 0;
1736 ppseudo_hdr->portsrc = 0;
1737 ppseudo_hdr->sh_str_id = 0;
1738 ppseudo_hdr->control = 0;
1739 ppseudo_hdr->rsvd1 = 0;
1740 ppseudo_hdr->rsvd2 = 0;
1741 ppseudo_hdr->qos_class = 0;
1742 /* Insert slow queue sequence number */
1743 ppseudo_hdr->seq_num = info->squeseqnum++;
1744 /* Insert application id */
1745 ppseudo_hdr->portsrc = 0;
1746 /* Calculate new checksum */
1747 ppseudo_hdr->checksum = *pmsg++;
1748 for (i = 1; i < 7; i++)
1749 ppseudo_hdr->checksum ^= *pmsg++;
1751 info->DSPInfoBlk[10] = 0x7200;
1752 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1754 ft1000_write_dpram32(dev, 0,
1755 (u8 *) &info->DSPInfoBlk[0],
1756 (unsigned short)(info->
1760 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1761 FT1000_REG_DOORBELL);
1762 info->DrvMsgPend = 0;
1767 case GET_DRV_ERR_RPT_MSG:{
1768 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1769 /* copy driver error message to dsp */
1770 info->DrvMsgPend = 1;
1771 /* allow any outstanding ioctl to finish */
1774 ft1000_read_register(dev, &tempword,
1775 FT1000_REG_DOORBELL);
1776 if (tempword & FT1000_DB_DPRAM_TX) {
1779 ft1000_read_register(dev, &tempword,
1780 FT1000_REG_DOORBELL);
1781 if (tempword & FT1000_DB_DPRAM_TX)
1785 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1786 /* Put message into Slow Queue
1787 * Form Pseudo header
1789 pmsg = (u16 *) &tempbuffer[0];
1790 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1791 ppseudo_hdr->length = htons(0x0012);
1792 ppseudo_hdr->source = 0x10;
1793 ppseudo_hdr->destination = 0x20;
1794 ppseudo_hdr->portdest = 0;
1795 ppseudo_hdr->portsrc = 0;
1796 ppseudo_hdr->sh_str_id = 0;
1797 ppseudo_hdr->control = 0;
1798 ppseudo_hdr->rsvd1 = 0;
1799 ppseudo_hdr->rsvd2 = 0;
1800 ppseudo_hdr->qos_class = 0;
1801 /* Insert slow queue sequence number */
1802 ppseudo_hdr->seq_num = info->squeseqnum++;
1803 /* Insert application id */
1804 ppseudo_hdr->portsrc = 0;
1805 /* Calculate new checksum */
1806 ppseudo_hdr->checksum = *pmsg++;
1807 for (i = 1; i < 7; i++)
1808 ppseudo_hdr->checksum ^= *pmsg++;
1810 pmsg = (u16 *) &tempbuffer[16];
1811 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1812 *pmsg++ = htons(0x000e);
1813 *pmsg++ = htons(info->DSP_TIME[0]);
1814 *pmsg++ = htons(info->DSP_TIME[1]);
1815 *pmsg++ = htons(info->DSP_TIME[2]);
1816 *pmsg++ = htons(info->DSP_TIME[3]);
1817 convert.byte[0] = info->DspVer[0];
1818 convert.byte[1] = info->DspVer[1];
1819 *pmsg++ = convert.wrd;
1820 convert.byte[0] = info->DspVer[2];
1821 convert.byte[1] = info->DspVer[3];
1822 *pmsg++ = convert.wrd;
1823 *pmsg++ = htons(info->DrvErrNum);
1825 card_send_command(dev,
1826 (unsigned char *)&tempbuffer[0],
1827 (u16) (0x0012 + PSEUDOSZ));
1828 info->DrvErrNum = 0;
1830 info->DrvMsgPend = 0;
1839 status = STATUS_SUCCESS;
1842 DEBUG("return from ft1000_proc_drvmsg\n");
1846 int ft1000_poll(void* dev_id) {
1848 struct ft1000_device *dev = (struct ft1000_device *)dev_id;
1849 struct ft1000_info *info = netdev_priv(dev->net);
1859 struct dpram_blk *pdpram_blk;
1860 struct pseudo_hdr *ppseudo_hdr;
1861 unsigned long flags;
1863 //DEBUG("Enter ft1000_poll...\n");
1864 if (ft1000_chkcard(dev) == FALSE) {
1865 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1866 return STATUS_FAILURE;
1869 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1870 // DEBUG("ft1000_poll: read FT1000_REG_DOORBELL message 0x%x\n", tempword);
1875 if (tempword & FT1000_DB_DPRAM_RX) {
1876 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX\n");
1878 status = ft1000_read_dpram16(dev, 0x200, (u8 *)&data, 0);
1879 //DEBUG("ft1000_poll:FT1000_DB_DPRAM_RX:ft1000_read_dpram16:size = 0x%x\n", data);
1880 size = ntohs(data) + 16 + 2; //wai
1882 modulo = 4 - (size % 4);
1883 size = size + modulo;
1885 status = ft1000_read_dpram16(dev, 0x201, (u8 *)&portid, 1);
1887 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid 0x%x\n", portid);
1889 if (size < MAX_CMD_SQSIZE) {
1893 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1895 status = ft1000_proc_drvmsg (dev, size);
1896 if (status != STATUS_SUCCESS )
1900 // This is a dsp broadcast message
1901 // Check which application has registered for dsp broadcast messages
1902 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DSPBCMSGID\n");
1904 for (i=0; i<MAX_NUM_APP; i++) {
1905 if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
1906 (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT) )
1908 //DEBUG("Dsp broadcast message detected for app id %d\n", i);
1909 nxtph = FT1000_DPRAM_RX_BASE + 2;
1910 pdpram_blk = ft1000_get_buffer (&freercvpool);
1911 if (pdpram_blk != NULL) {
1912 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1913 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1914 // Put message into the appropriate application block
1915 info->app_info[i].nRxMsg++;
1916 spin_lock_irqsave(&free_buff_lock, flags);
1917 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1918 info->app_info[i].NumOfMsg++;
1919 spin_unlock_irqrestore(&free_buff_lock, flags);
1920 wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1923 info->app_info[i].nRxMsgMiss++;
1924 // Put memory back to free pool
1925 ft1000_free_buffer(pdpram_blk, &freercvpool);
1926 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1930 DEBUG("Out of memory in free receive command pool\n");
1931 info->app_info[i].nRxMsgMiss++;
1932 }//endof if (pdpram_blk != NULL)
1935 // DEBUG("app_info mismatch\n");
1939 pdpram_blk = ft1000_get_buffer (&freercvpool);
1940 //DEBUG("Memory allocated = 0x%8x\n", (u32)pdpram_blk);
1941 if (pdpram_blk != NULL) {
1942 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1943 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1944 // Search for correct application block
1945 for (i=0; i<MAX_NUM_APP; i++) {
1946 if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
1951 if (i == MAX_NUM_APP) {
1952 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
1953 // Put memory back to free pool
1954 ft1000_free_buffer(pdpram_blk, &freercvpool);
1957 if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1958 // Put memory back to free pool
1959 ft1000_free_buffer(pdpram_blk, &freercvpool);
1962 info->app_info[i].nRxMsg++;
1963 // Put message into the appropriate application block
1964 //pxu spin_lock_irqsave(&free_buff_lock, flags);
1965 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1966 info->app_info[i].NumOfMsg++;
1967 //pxu spin_unlock_irqrestore(&free_buff_lock, flags);
1968 //pxu wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1973 // Put memory back to free pool
1974 ft1000_free_buffer(pdpram_blk, &freercvpool);
1978 DEBUG("Out of memory in free receive command pool\n");
1982 } //endof if (size < MAX_CMD_SQSIZE)
1984 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
1986 status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
1988 else if (tempword & FT1000_DSP_ASIC_RESET) {
1989 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DSP_ASIC_RESET\n");
1991 // Let's reset the ASIC from the Host side as well
1992 status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
1993 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
1995 while (tempword & ASIC_RESET_BIT) {
1996 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2003 DEBUG("Unable to reset ASIC\n");
2004 return STATUS_SUCCESS;
2007 // Program WMARK register
2008 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2009 // clear ASIC reset doorbell
2010 status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
2013 else if (tempword & FT1000_ASIC_RESET_REQ) {
2014 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
2016 // clear ASIC reset request from DSP
2017 status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
2018 status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
2019 // copy dsp session record from Adapter block
2020 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPSess.Rec[0], 1024);
2021 // Program WMARK register
2022 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2023 // ring doorbell to tell DSP that ASIC is out of reset
2024 status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
2026 else if (tempword & FT1000_DB_COND_RESET) {
2027 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
2029 // Reset ASIC and DSP
2031 if (info->fAppMsgPend == 0) {
2032 // Reset ASIC and DSP
2034 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (u8 *)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2035 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (u8 *)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2036 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (u8 *)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2037 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (u8 *)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2038 info->CardReady = 0;
2039 info->DrvErrNum = DSP_CONDRESET_INFO;
2040 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2041 info->ft1000_reset(dev->net);
2044 info->fProvComplete = 0;
2045 info->fCondResetPend = 1;
2048 ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2051 }//endof if ( !status )
2053 //DEBUG("return from ft1000_poll.\n");
2054 return STATUS_SUCCESS;