1 /* CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
4 * This file is part of Express Card USB Driver
7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/netdevice.h>
12 #include <linux/etherdevice.h>
13 #include <linux/usb.h>
14 #include "ft1000_usb.h"
15 #include <linux/types.h>
17 #define HARLEY_READ_REGISTER 0x0
18 #define HARLEY_WRITE_REGISTER 0x01
19 #define HARLEY_READ_DPRAM_32 0x02
20 #define HARLEY_READ_DPRAM_LOW 0x03
21 #define HARLEY_READ_DPRAM_HIGH 0x04
22 #define HARLEY_WRITE_DPRAM_32 0x05
23 #define HARLEY_WRITE_DPRAM_LOW 0x06
24 #define HARLEY_WRITE_DPRAM_HIGH 0x07
26 #define HARLEY_READ_OPERATION 0xc1
27 #define HARLEY_WRITE_OPERATION 0x41
33 static int ft1000_submit_rx_urb(struct ft1000_info *info);
35 static u8 tempbuffer[1600];
37 #define MAX_RCV_LOOP 100
39 /* send a control message via USB interface synchronously
40 * Parameters: ft1000_usb - device structure
41 * pipe - usb control message pipe
42 * request - control request
43 * requesttype - control message request type
44 * value - value to be written or 0
45 * index - register index
46 * data - data buffer to hold the read/write values
48 * timeout - control message time out value
50 static int ft1000_control(struct ft1000_usb *ft1000dev, unsigned int pipe,
51 u8 request, u8 requesttype, u16 value, u16 index,
52 void *data, u16 size, int timeout)
56 if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
57 pr_debug("ft1000dev or ft1000dev->dev == NULL, failure\n");
61 ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
62 value, index, data, size, timeout);
70 /* returns the value in a register */
71 int ft1000_read_register(struct ft1000_usb *ft1000dev, u16 *Data,
76 ret = ft1000_control(ft1000dev,
77 usb_rcvctrlpipe(ft1000dev->dev, 0),
79 HARLEY_READ_OPERATION,
84 USB_CTRL_GET_TIMEOUT);
89 /* writes the value in a register */
90 int ft1000_write_register(struct ft1000_usb *ft1000dev, u16 value,
95 ret = ft1000_control(ft1000dev,
96 usb_sndctrlpipe(ft1000dev->dev, 0),
97 HARLEY_WRITE_REGISTER,
98 HARLEY_WRITE_OPERATION,
103 USB_CTRL_SET_TIMEOUT);
108 /* read a number of bytes from DPRAM */
109 int ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
114 ret = ft1000_control(ft1000dev,
115 usb_rcvctrlpipe(ft1000dev->dev, 0),
116 HARLEY_READ_DPRAM_32,
117 HARLEY_READ_OPERATION,
122 USB_CTRL_GET_TIMEOUT);
127 /* writes into DPRAM a number of bytes */
128 int ft1000_write_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
134 cnt += cnt - (cnt % 4);
136 ret = ft1000_control(ft1000dev,
137 usb_sndctrlpipe(ft1000dev->dev, 0),
138 HARLEY_WRITE_DPRAM_32,
139 HARLEY_WRITE_OPERATION,
144 USB_CTRL_SET_TIMEOUT);
149 /* read 16 bits from DPRAM */
150 int ft1000_read_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
157 request = HARLEY_READ_DPRAM_LOW;
159 request = HARLEY_READ_DPRAM_HIGH;
161 ret = ft1000_control(ft1000dev,
162 usb_rcvctrlpipe(ft1000dev->dev, 0),
164 HARLEY_READ_OPERATION,
169 USB_CTRL_GET_TIMEOUT);
174 /* write into DPRAM a number of bytes */
175 int ft1000_write_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u16 value,
182 request = HARLEY_WRITE_DPRAM_LOW;
184 request = HARLEY_WRITE_DPRAM_HIGH;
186 ret = ft1000_control(ft1000dev,
187 usb_sndctrlpipe(ft1000dev->dev, 0),
189 HARLEY_WRITE_OPERATION,
194 USB_CTRL_SET_TIMEOUT);
199 /* read DPRAM 4 words at a time */
200 int fix_ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx,
207 pos = (indx / 4) * 4;
208 ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
211 pos = (indx % 4) * 4;
212 *buffer++ = buf[pos++];
213 *buffer++ = buf[pos++];
214 *buffer++ = buf[pos++];
215 *buffer++ = buf[pos++];
217 pr_debug("DPRAM32 Read failed\n");
228 /* Description: This function write to DPRAM 4 words at a time */
229 int fix_ft1000_write_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer)
239 pos1 = (indx / 4) * 4;
241 ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
245 buf[pos2++] = *buffer++;
246 buf[pos2++] = *buffer++;
247 buf[pos2++] = *buffer++;
248 buf[pos2++] = *buffer++;
249 ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
251 pr_debug("DPRAM32 Read failed\n");
255 ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
259 for (i = 0; i < 16; i++) {
260 if (buf[i] != resultbuffer[i])
266 ret = ft1000_write_dpram32(ft1000dev, pos1,
267 (u8 *)&tempbuffer[0], 16);
268 ret = ft1000_read_dpram32(ft1000dev, pos1,
269 (u8 *)&resultbuffer[0], 16);
272 for (i = 0; i < 16; i++) {
273 if (tempbuffer[i] != resultbuffer[i]) {
275 pr_debug("Failed to write\n");
284 /* reset or activate the DSP */
285 static void card_reset_dsp(struct ft1000_usb *ft1000dev, bool value)
290 status = ft1000_write_register(ft1000dev, HOST_INTF_BE,
291 FT1000_REG_SUP_CTRL);
292 status = ft1000_read_register(ft1000dev, &tempword,
293 FT1000_REG_SUP_CTRL);
296 pr_debug("Reset DSP\n");
297 status = ft1000_read_register(ft1000dev, &tempword,
299 tempword |= DSP_RESET_BIT;
300 status = ft1000_write_register(ft1000dev, tempword,
303 pr_debug("Activate DSP\n");
304 status = ft1000_read_register(ft1000dev, &tempword,
306 tempword |= DSP_ENCRYPTED;
307 tempword &= ~DSP_UNENCRYPTED;
308 status = ft1000_write_register(ft1000dev, tempword,
310 status = ft1000_read_register(ft1000dev, &tempword,
312 tempword &= ~EFUSE_MEM_DISABLE;
313 tempword &= ~DSP_RESET_BIT;
314 status = ft1000_write_register(ft1000dev, tempword,
316 status = ft1000_read_register(ft1000dev, &tempword,
321 /* send a command to ASIC
322 * Parameters: ft1000_usb - device structure
323 * ptempbuffer - command buffer
324 * size - command buffer size
326 int card_send_command(struct ft1000_usb *ft1000dev, void *ptempbuffer,
331 unsigned char *commandbuf;
333 pr_debug("enter card_send_command... size=%d\n", size);
335 ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
339 commandbuf = kmalloc(size + 2, GFP_KERNEL);
342 memcpy((void *)commandbuf + 2, ptempbuffer, size);
345 usleep_range(900, 1100);
347 /* check for odd word */
350 /* Must force to be 32 bit aligned */
352 size += 4 - (size % 4);
354 ret = ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
357 usleep_range(900, 1100);
358 ret = ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
359 FT1000_REG_DOORBELL);
362 usleep_range(900, 1100);
364 ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
367 if ((temp & 0x0100) == 0)
368 pr_debug("Message sent\n");
373 /* load or reload the DSP */
374 int dsp_reload(struct ft1000_usb *ft1000dev)
380 struct ft1000_info *pft1000info;
382 pft1000info = netdev_priv(ft1000dev->net);
384 pft1000info->CardReady = 0;
386 /* Program Interrupt Mask register */
387 status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
389 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
390 tempword |= ASIC_RESET_BIT;
391 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
393 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
394 pr_debug("Reset Register = 0x%x\n", tempword);
396 /* Toggle DSP reset */
397 card_reset_dsp(ft1000dev, 1);
399 card_reset_dsp(ft1000dev, 0);
403 ft1000_write_register(ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
405 /* Let's check for FEFE */
407 ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
409 pr_debug("templong (fefe) = 0x%8x\n", templong);
411 /* call codeloader */
412 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
422 /* call the Card Service function to reset the ASIC. */
423 static void ft1000_reset_asic(struct net_device *dev)
425 struct ft1000_info *info = netdev_priv(dev);
426 struct ft1000_usb *ft1000dev = info->priv;
429 /* Let's use the register provided by the Magnemite ASIC to reset the
432 ft1000_write_register(ft1000dev, DSP_RESET_BIT | ASIC_RESET_BIT,
437 /* set watermark to -1 in order to not generate an interrupt */
438 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
440 /* clear interrupts */
441 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
442 pr_debug("interrupt status register = 0x%x\n", tempword);
443 ft1000_write_register(ft1000dev, tempword, FT1000_REG_SUP_ISR);
444 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
445 pr_debug("interrupt status register = 0x%x\n", tempword);
448 static int ft1000_reset_card(struct net_device *dev)
450 struct ft1000_info *info = netdev_priv(dev);
451 struct ft1000_usb *ft1000dev = info->priv;
453 struct prov_record *ptr;
454 struct prov_record *tmp;
456 ft1000dev->fCondResetPend = true;
458 ft1000dev->fProvComplete = false;
460 /* Make sure we free any memory reserve for provisioning */
461 list_for_each_entry_safe(ptr, tmp, &info->prov_list, list) {
462 pr_debug("deleting provisioning record\n");
463 list_del(&ptr->list);
464 kfree(ptr->pprov_data);
468 pr_debug("reset asic\n");
469 ft1000_reset_asic(dev);
471 pr_debug("call dsp_reload\n");
472 dsp_reload(ft1000dev);
474 pr_debug("dsp reload successful\n");
478 /* Initialize DSP heartbeat area */
479 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
480 FT1000_MAG_HI_HO_INDX);
481 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *)&tempword,
482 FT1000_MAG_HI_HO_INDX);
483 pr_debug("hi_ho value = 0x%x\n", tempword);
487 ft1000dev->fCondResetPend = false;
492 /* callback function when a urb is transmitted */
493 static void ft1000_usb_transmit_complete(struct urb *urb)
496 struct ft1000_usb *ft1000dev = urb->context;
499 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
501 netif_wake_queue(ft1000dev->net);
504 /* take an ethernet packet and convert it to a Flarion
505 * packet prior to sending it to the ASIC Downlink FIFO.
507 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 *packet, u16 len)
509 struct ft1000_info *pInfo = netdev_priv(netdev);
510 struct ft1000_usb *pFt1000Dev = pInfo->priv;
514 struct pseudo_hdr hdr;
516 if (!pInfo->CardReady) {
517 pr_debug("Card Not Ready\n");
521 count = sizeof(struct pseudo_hdr) + len;
522 if (count > MAX_BUF_SIZE) {
523 pr_debug("Message Size Overflow! size = %d\n", count);
528 count = count + (4 - (count % 4));
530 memset(&hdr, 0, sizeof(struct pseudo_hdr));
532 hdr.length = ntohs(count);
534 hdr.destination = 0x20;
537 hdr.sh_str_id = 0x91;
540 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
541 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
543 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
544 memcpy(&pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)], packet, len);
546 netif_stop_queue(netdev);
548 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
550 usb_sndbulkpipe(pFt1000Dev->dev,
551 pFt1000Dev->bulk_out_endpointAddr),
552 pFt1000Dev->tx_buf, count,
553 ft1000_usb_transmit_complete, pFt1000Dev);
555 t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
557 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
560 pr_debug("failed tx_urb %d\n", ret);
563 pInfo->stats.tx_packets++;
564 pInfo->stats.tx_bytes += (len + 14);
569 /* transmit an ethernet packet
570 * Parameters: skb - socket buffer to be sent
571 * dev - network device
573 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
575 struct ft1000_info *pInfo = netdev_priv(dev);
576 struct ft1000_usb *pFt1000Dev = pInfo->priv;
581 pr_debug("skb == NULL!!!\n");
585 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
586 pr_debug("network driver is closed, return\n");
591 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
592 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
594 pdata = (u8 *)skb->data;
596 if (pInfo->mediastate == 0) {
597 /* Drop packet is mediastate is down */
598 pr_debug("mediastate is down\n");
602 if ((skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE)) {
603 /* Drop packet which has invalid size */
604 pr_debug("invalid ethernet length\n");
608 ft1000_copy_down_pkt(dev, pdata + ENET_HEADER_SIZE - 2,
609 skb->len - ENET_HEADER_SIZE + 2);
617 /* open the network driver */
618 static int ft1000_open(struct net_device *dev)
620 struct ft1000_info *pInfo = netdev_priv(dev);
621 struct ft1000_usb *pFt1000Dev = pInfo->priv;
624 pr_debug("ft1000_open is called for card %d\n", pFt1000Dev->CardNumber);
626 pInfo->stats.rx_bytes = 0;
627 pInfo->stats.tx_bytes = 0;
628 pInfo->stats.rx_packets = 0;
629 pInfo->stats.tx_packets = 0;
630 do_gettimeofday(&tv);
631 pInfo->ConTm = tv.tv_sec;
632 pInfo->ProgConStat = 0;
634 netif_start_queue(dev);
636 netif_carrier_on(dev);
638 return ft1000_submit_rx_urb(pInfo);
641 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
643 struct ft1000_info *info = netdev_priv(dev);
645 return &(info->stats);
648 static const struct net_device_ops ftnet_ops = {
649 .ndo_open = &ft1000_open,
650 .ndo_stop = &ft1000_close,
651 .ndo_start_xmit = &ft1000_start_xmit,
652 .ndo_get_stats = &ft1000_netdev_stats,
655 /* initialize the network device */
656 static int ft1000_reset(void *dev)
658 ft1000_reset_card(dev);
662 int init_ft1000_netdev(struct ft1000_usb *ft1000dev)
664 struct net_device *netdev;
665 struct ft1000_info *pInfo = NULL;
666 struct dpram_blk *pdpram_blk;
668 struct list_head *cur, *tmp;
672 netdev = alloc_etherdev(sizeof(struct ft1000_info));
674 pr_debug("can not allocate network device\n");
678 pInfo = netdev_priv(netdev);
680 memset(pInfo, 0, sizeof(struct ft1000_info));
682 dev_alloc_name(netdev, netdev->name);
684 pr_debug("network device name is %s\n", netdev->name);
686 if (strncmp(netdev->name, "eth", 3) == 0) {
687 card_nr[0] = netdev->name[3];
689 ret_val = kstrtou8(card_nr, 10, &gCardIndex);
691 netdev_err(ft1000dev->net, "Can't parse netdev\n");
695 ft1000dev->CardNumber = gCardIndex;
696 pr_debug("card number = %d\n", ft1000dev->CardNumber);
698 netdev_err(ft1000dev->net, "ft1000: Invalid device name\n");
703 memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
705 spin_lock_init(&pInfo->dpram_lock);
706 pInfo->priv = ft1000dev;
707 pInfo->DrvErrNum = 0;
708 pInfo->registered = 1;
709 pInfo->ft1000_reset = ft1000_reset;
710 pInfo->mediastate = 0;
712 ft1000dev->DeviceCreated = FALSE;
713 pInfo->CardReady = 0;
714 pInfo->DSP_TIME[0] = 0;
715 pInfo->DSP_TIME[1] = 0;
716 pInfo->DSP_TIME[2] = 0;
717 pInfo->DSP_TIME[3] = 0;
718 ft1000dev->fAppMsgPend = false;
719 ft1000dev->fCondResetPend = false;
720 ft1000dev->usbboot = 0;
721 ft1000dev->dspalive = 0;
722 memset(&ft1000dev->tempbuf[0], 0, sizeof(ft1000dev->tempbuf));
724 INIT_LIST_HEAD(&pInfo->prov_list);
726 INIT_LIST_HEAD(&ft1000dev->nodes.list);
728 netdev->netdev_ops = &ftnet_ops;
730 ft1000dev->net = netdev;
732 pr_debug("Initialize free_buff_lock and freercvpool\n");
733 spin_lock_init(&free_buff_lock);
735 /* initialize a list of buffers to be use for queuing
736 * up receive command data
738 INIT_LIST_HEAD(&freercvpool);
740 /* create list of free buffers */
741 for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
742 /* Get memory for DPRAM_DATA link list */
743 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
744 if (pdpram_blk == NULL) {
748 /* Get a block of memory to store command data */
749 pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
750 if (pdpram_blk->pbuffer == NULL) {
755 /* link provisioning data */
756 list_add_tail(&pdpram_blk->list, &freercvpool);
758 numofmsgbuf = NUM_OF_FREE_BUFFERS;
763 list_for_each_safe(cur, tmp, &freercvpool) {
764 pdpram_blk = list_entry(cur, struct dpram_blk, list);
765 list_del(&pdpram_blk->list);
766 kfree(pdpram_blk->pbuffer);
774 /* register the network driver */
775 int reg_ft1000_netdev(struct ft1000_usb *ft1000dev,
776 struct usb_interface *intf)
778 struct net_device *netdev;
779 struct ft1000_info *pInfo;
782 netdev = ft1000dev->net;
783 pInfo = netdev_priv(ft1000dev->net);
785 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
787 usb_set_intfdata(intf, pInfo);
788 SET_NETDEV_DEV(netdev, &intf->dev);
790 rc = register_netdev(netdev);
792 pr_debug("could not register network device\n");
797 ft1000_create_dev(ft1000dev);
799 pInfo->CardReady = 1;
804 /* take a packet from the FIFO up link and
805 * convert it into an ethernet packet and deliver it to the IP stack
807 static int ft1000_copy_up_pkt(struct urb *urb)
809 struct ft1000_info *info = urb->context;
810 struct ft1000_usb *ft1000dev = info->priv;
811 struct net_device *net = ft1000dev->net;
822 if (ft1000dev->status & FT1000_STATUS_CLOSING) {
823 pr_debug("network driver is closed, return\n");
827 len = urb->transfer_buffer_length;
828 lena = urb->actual_length;
830 chksum = (u16 *)ft1000dev->rx_buf;
832 tempword = *chksum++;
833 for (i = 1; i < 7; i++)
834 tempword ^= *chksum++;
836 if (tempword != *chksum) {
837 info->stats.rx_errors++;
838 ft1000_submit_rx_urb(info);
842 skb = dev_alloc_skb(len + 12 + 2);
845 pr_debug("No Network buffers available\n");
846 info->stats.rx_errors++;
847 ft1000_submit_rx_urb(info);
851 pbuffer = (u8 *)skb_put(skb, len + 12);
853 /* subtract the number of bytes read already */
856 /* fake MAC address */
857 *pbuffer++ = net->dev_addr[0];
858 *pbuffer++ = net->dev_addr[1];
859 *pbuffer++ = net->dev_addr[2];
860 *pbuffer++ = net->dev_addr[3];
861 *pbuffer++ = net->dev_addr[4];
862 *pbuffer++ = net->dev_addr[5];
870 memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
871 len - sizeof(struct pseudo_hdr));
875 skb->protocol = eth_type_trans(skb, net);
876 skb->ip_summed = CHECKSUM_UNNECESSARY;
879 info->stats.rx_packets++;
880 /* Add on 12 bytes for MAC address which was removed */
881 info->stats.rx_bytes += (lena + 12);
883 ft1000_submit_rx_urb(info);
889 /* the receiving function of the network driver */
890 static int ft1000_submit_rx_urb(struct ft1000_info *info)
893 struct ft1000_usb *pFt1000Dev = info->priv;
895 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
896 pr_debug("network driver is closed, return\n");
900 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
902 usb_rcvbulkpipe(pFt1000Dev->dev,
903 pFt1000Dev->bulk_in_endpointAddr),
904 pFt1000Dev->rx_buf, MAX_BUF_SIZE,
905 (usb_complete_t)ft1000_copy_up_pkt, info);
907 result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
910 pr_err("submitting rx_urb %d failed\n", result);
917 /* close the network driver */
918 int ft1000_close(struct net_device *net)
920 struct ft1000_info *pInfo = netdev_priv(net);
921 struct ft1000_usb *ft1000dev = pInfo->priv;
923 ft1000dev->status |= FT1000_STATUS_CLOSING;
925 pr_debug("pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
926 netif_carrier_off(net);
927 netif_stop_queue(net);
928 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
930 pInfo->ProgConStat = 0xff;
935 /* check if the device is presently available on the system. */
936 static int ft1000_chkcard(struct ft1000_usb *dev)
941 if (dev->fCondResetPend) {
942 pr_debug("Card is being reset, return FALSE\n");
945 /* Mask register is used to check for device presence since it is never
948 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
950 pr_debug("IMASK = 0 Card not detected\n");
953 /* The system will return the value of 0xffff for the version register
954 * if the device is not present.
956 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
957 if (tempword != 0x1b01) {
958 dev->status |= FT1000_STATUS_CLOSING;
959 pr_debug("Version = 0xffff Card not detected\n");
965 /* read a message from the dpram area.
967 * dev - network device structure
968 * pbuffer - caller supply address to buffer
970 static bool ft1000_receive_cmd(struct ft1000_usb *dev, u16 *pbuffer,
980 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size,
981 FT1000_MAG_PH_LEN_INDX);
982 size = ntohs(size) + PSEUDOSZ;
984 pr_debug("Invalid command length = %d\n", size);
987 ppseudohdr = (u16 *)pbuffer;
988 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
989 FT1000_REG_DPRAM_ADDR);
991 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
993 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
994 FT1000_REG_DPRAM_ADDR);
995 for (i = 0; i <= (size >> 2); i++) {
997 ft1000_read_register(dev, pbuffer,
998 FT1000_REG_MAG_DPDATAL);
1001 ft1000_read_register(dev, pbuffer,
1002 FT1000_REG_MAG_DPDATAH);
1005 /* copy odd aligned word */
1007 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1011 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1014 if (size & 0x0001) {
1015 /* copy odd byte from fifo */
1017 ft1000_read_register(dev, &tempword,
1018 FT1000_REG_DPRAM_DATA);
1019 *pbuffer = ntohs(tempword);
1021 /* Check if pseudo header checksum is good
1022 * Calculate pseudo header checksum
1024 tempword = *ppseudohdr++;
1025 for (i = 1; i < 7; i++)
1026 tempword ^= *ppseudohdr++;
1028 if (tempword != *ppseudohdr)
1034 static int ft1000_dsp_prov(void *arg)
1036 struct ft1000_usb *dev = (struct ft1000_usb *)arg;
1037 struct ft1000_info *info = netdev_priv(dev->net);
1041 struct prov_record *ptr;
1042 struct pseudo_hdr *ppseudo_hdr;
1045 u16 TempShortBuf[256];
1047 while (list_empty(&info->prov_list) == 0) {
1048 pr_debug("DSP Provisioning List Entry\n");
1050 /* Check if doorbell is available */
1051 pr_debug("check if doorbell is cleared\n");
1053 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1055 pr_debug("ft1000_read_register error\n");
1059 while (tempword & FT1000_DB_DPRAM_TX) {
1063 pr_debug("message drop\n");
1066 ft1000_read_register(dev, &tempword,
1067 FT1000_REG_DOORBELL);
1070 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1071 pr_debug("*** Provision Data Sent to DSP\n");
1073 /* Send provisioning data */
1075 list_entry(info->prov_list.next, struct prov_record,
1077 len = *(u16 *)ptr->pprov_data;
1081 pmsg = (u16 *)ptr->pprov_data;
1082 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1083 /* Insert slow queue sequence number */
1084 ppseudo_hdr->seq_num = info->squeseqnum++;
1085 ppseudo_hdr->portsrc = 0;
1086 /* Calculate new checksum */
1087 ppseudo_hdr->checksum = *pmsg++;
1088 for (i = 1; i < 7; i++)
1089 ppseudo_hdr->checksum ^= *pmsg++;
1091 TempShortBuf[0] = 0;
1092 TempShortBuf[1] = htons(len);
1093 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1096 ft1000_write_dpram32(dev, 0,
1097 (u8 *)&TempShortBuf[0],
1098 (unsigned short)(len + 2));
1100 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1101 FT1000_REG_DOORBELL);
1103 list_del(&ptr->list);
1104 kfree(ptr->pprov_data);
1107 usleep_range(9000, 11000);
1110 pr_debug("DSP Provisioning List Entry finished\n");
1114 dev->fProvComplete = true;
1115 info->CardReady = 1;
1120 static int ft1000_proc_drvmsg(struct ft1000_usb *dev, u16 size)
1122 struct ft1000_info *info = netdev_priv(dev->net);
1125 struct media_msg *pmediamsg;
1126 struct dsp_init_msg *pdspinitmsg;
1127 struct drv_msg *pdrvmsg;
1129 struct pseudo_hdr *ppseudo_hdr;
1137 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1142 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1145 print_hex_dump_debug("cmdbuffer: ", HEX_DUMP_OFFSET, 16, 1,
1146 cmdbuffer, size, true);
1148 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1149 msgtype = ntohs(pdrvmsg->type);
1150 pr_debug("Command message type = 0x%x\n", msgtype);
1153 pr_debug("Command message type = MEDIA_STATE\n");
1154 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1155 if (info->ProgConStat != 0xFF) {
1156 if (pmediamsg->state) {
1157 pr_debug("Media is up\n");
1158 if (info->mediastate == 0) {
1159 if (dev->NetDevRegDone)
1160 netif_wake_queue(dev->net);
1161 info->mediastate = 1;
1164 pr_debug("Media is down\n");
1165 if (info->mediastate == 1) {
1166 info->mediastate = 0;
1167 if (dev->NetDevRegDone)
1172 pr_debug("Media is down\n");
1173 if (info->mediastate == 1) {
1174 info->mediastate = 0;
1181 pr_debug("Command message type = DSP_INIT_MSG\n");
1182 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1183 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1184 pr_debug("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1185 info->DspVer[0], info->DspVer[1], info->DspVer[2],
1187 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1189 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1190 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1191 pr_debug("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1192 info->eui64[0], info->eui64[1], info->eui64[2],
1193 info->eui64[3], info->eui64[4], info->eui64[5],
1194 info->eui64[6], info->eui64[7]);
1195 dev->net->dev_addr[0] = info->eui64[0];
1196 dev->net->dev_addr[1] = info->eui64[1];
1197 dev->net->dev_addr[2] = info->eui64[2];
1198 dev->net->dev_addr[3] = info->eui64[5];
1199 dev->net->dev_addr[4] = info->eui64[6];
1200 dev->net->dev_addr[5] = info->eui64[7];
1202 if (ntohs(pdspinitmsg->length) ==
1203 (sizeof(struct dsp_init_msg) - 20)) {
1204 memcpy(info->ProductMode, pdspinitmsg->ProductMode,
1206 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1207 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1209 pr_debug("RFCalVer = 0x%2x 0x%2x\n",
1210 info->RfCalVer[0], info->RfCalVer[1]);
1214 case DSP_PROVISION:{
1215 pr_debug("Command message type = DSP_PROVISION\n");
1217 /* kick off dspprov routine to start provisioning
1218 * Send provisioning data to DSP
1220 if (list_empty(&info->prov_list) == 0) {
1221 dev->fProvComplete = false;
1222 status = ft1000_dsp_prov(dev);
1226 dev->fProvComplete = true;
1227 status = ft1000_write_register(dev, FT1000_DB_HB,
1228 FT1000_REG_DOORBELL);
1229 pr_debug("No more DSP provisioning data in dsp image\n");
1231 pr_debug("DSP PROVISION is done\n");
1234 case DSP_STORE_INFO:{
1235 pr_debug("Command message type = DSP_STORE_INFO");
1236 tempword = ntohs(pdrvmsg->length);
1237 info->DSPInfoBlklen = tempword;
1238 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1239 pmsg = (u16 *)&pdrvmsg->data[0];
1240 for (i = 0; i < ((tempword + 1) / 2); i++) {
1241 pr_debug("dsp info data = 0x%x\n", *pmsg);
1242 info->DSPInfoBlk[i + 10] = *pmsg++;
1245 info->DSPInfoBlklen = 0;
1250 pr_debug("Got DSP_GET_INFO\n");
1251 /* copy dsp info block to dsp */
1252 dev->DrvMsgPend = 1;
1253 /* allow any outstanding ioctl to finish */
1255 status = ft1000_read_register(dev, &tempword,
1256 FT1000_REG_DOORBELL);
1257 if (tempword & FT1000_DB_DPRAM_TX) {
1259 status = ft1000_read_register(dev, &tempword,
1260 FT1000_REG_DOORBELL);
1261 if (tempword & FT1000_DB_DPRAM_TX) {
1263 status = ft1000_read_register(dev, &tempword,
1264 FT1000_REG_DOORBELL);
1265 if (tempword & FT1000_DB_DPRAM_TX)
1269 /* Put message into Slow Queue Form Pseudo header */
1270 pmsg = (u16 *)info->DSPInfoBlk;
1272 *pmsg++ = htons(info->DSPInfoBlklen + 20 + info->DSPInfoBlklen);
1274 (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1275 ppseudo_hdr->length = htons(info->DSPInfoBlklen + 4
1276 + info->DSPInfoBlklen);
1277 ppseudo_hdr->source = 0x10;
1278 ppseudo_hdr->destination = 0x20;
1279 ppseudo_hdr->portdest = 0;
1280 ppseudo_hdr->portsrc = 0;
1281 ppseudo_hdr->sh_str_id = 0;
1282 ppseudo_hdr->control = 0;
1283 ppseudo_hdr->rsvd1 = 0;
1284 ppseudo_hdr->rsvd2 = 0;
1285 ppseudo_hdr->qos_class = 0;
1286 /* Insert slow queue sequence number */
1287 ppseudo_hdr->seq_num = info->squeseqnum++;
1288 /* Insert application id */
1289 ppseudo_hdr->portsrc = 0;
1290 /* Calculate new checksum */
1291 ppseudo_hdr->checksum = *pmsg++;
1292 for (i = 1; i < 7; i++)
1293 ppseudo_hdr->checksum ^= *pmsg++;
1295 info->DSPInfoBlk[10] = 0x7200;
1296 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1297 status = ft1000_write_dpram32(dev, 0,
1298 (u8 *)&info->DSPInfoBlk[0],
1299 (unsigned short)(info->DSPInfoBlklen + 22));
1300 status = ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1301 FT1000_REG_DOORBELL);
1302 dev->DrvMsgPend = 0;
1305 case GET_DRV_ERR_RPT_MSG:{
1306 pr_debug("Got GET_DRV_ERR_RPT_MSG\n");
1307 /* copy driver error message to dsp */
1308 dev->DrvMsgPend = 1;
1309 /* allow any outstanding ioctl to finish */
1311 status = ft1000_read_register(dev, &tempword,
1312 FT1000_REG_DOORBELL);
1313 if (tempword & FT1000_DB_DPRAM_TX) {
1315 status = ft1000_read_register(dev, &tempword,
1316 FT1000_REG_DOORBELL);
1317 if (tempword & FT1000_DB_DPRAM_TX)
1320 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1321 /* Put message into Slow Queue Form Pseudo header */
1322 pmsg = (u16 *)&tempbuffer[0];
1323 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1324 ppseudo_hdr->length = htons(0x0012);
1325 ppseudo_hdr->source = 0x10;
1326 ppseudo_hdr->destination = 0x20;
1327 ppseudo_hdr->portdest = 0;
1328 ppseudo_hdr->portsrc = 0;
1329 ppseudo_hdr->sh_str_id = 0;
1330 ppseudo_hdr->control = 0;
1331 ppseudo_hdr->rsvd1 = 0;
1332 ppseudo_hdr->rsvd2 = 0;
1333 ppseudo_hdr->qos_class = 0;
1334 /* Insert slow queue sequence number */
1335 ppseudo_hdr->seq_num = info->squeseqnum++;
1336 /* Insert application id */
1337 ppseudo_hdr->portsrc = 0;
1338 /* Calculate new checksum */
1339 ppseudo_hdr->checksum = *pmsg++;
1340 for (i = 1; i < 7; i++)
1341 ppseudo_hdr->checksum ^= *pmsg++;
1343 pmsg = (u16 *)&tempbuffer[16];
1344 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1345 *pmsg++ = htons(0x000e);
1346 *pmsg++ = htons(info->DSP_TIME[0]);
1347 *pmsg++ = htons(info->DSP_TIME[1]);
1348 *pmsg++ = htons(info->DSP_TIME[2]);
1349 *pmsg++ = htons(info->DSP_TIME[3]);
1350 convert.byte[0] = info->DspVer[0];
1351 convert.byte[1] = info->DspVer[1];
1352 *pmsg++ = convert.wrd;
1353 convert.byte[0] = info->DspVer[2];
1354 convert.byte[1] = info->DspVer[3];
1355 *pmsg++ = convert.wrd;
1356 *pmsg++ = htons(info->DrvErrNum);
1358 status = card_send_command(dev, (unsigned char *)&tempbuffer[0],
1359 (u16)(0x0012 + PSEUDOSZ));
1362 info->DrvErrNum = 0;
1364 dev->DrvMsgPend = 0;
1377 /* Check which application has registered for dsp broadcast messages */
1378 static int dsp_broadcast_msg_id(struct ft1000_usb *dev)
1380 struct dpram_blk *pdpram_blk;
1381 unsigned long flags;
1384 for (i = 0; i < MAX_NUM_APP; i++) {
1385 if ((dev->app_info[i].DspBCMsgFlag)
1386 && (dev->app_info[i].fileobject)
1387 && (dev->app_info[i].NumOfMsg
1389 pdpram_blk = ft1000_get_buffer(&freercvpool);
1390 if (pdpram_blk == NULL) {
1391 pr_debug("Out of memory in free receive command pool\n");
1392 dev->app_info[i].nRxMsgMiss++;
1395 if (ft1000_receive_cmd(dev, pdpram_blk->pbuffer,
1397 /* Put message into the
1398 * appropriate application block
1400 dev->app_info[i].nRxMsg++;
1401 spin_lock_irqsave(&free_buff_lock, flags);
1402 list_add_tail(&pdpram_blk->list,
1403 &dev->app_info[i] .app_sqlist);
1404 dev->app_info[i].NumOfMsg++;
1405 spin_unlock_irqrestore(&free_buff_lock, flags);
1406 wake_up_interruptible(&dev->app_info[i]
1409 dev->app_info[i].nRxMsgMiss++;
1410 ft1000_free_buffer(pdpram_blk, &freercvpool);
1411 pr_debug("ft1000_get_buffer NULL\n");
1419 static int handle_misc_portid(struct ft1000_usb *dev)
1421 struct dpram_blk *pdpram_blk;
1424 pdpram_blk = ft1000_get_buffer(&freercvpool);
1425 if (pdpram_blk == NULL) {
1426 pr_debug("Out of memory in free receive command pool\n");
1429 if (!ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE))
1432 /* Search for correct application block */
1433 for (i = 0; i < MAX_NUM_APP; i++) {
1434 if (dev->app_info[i].app_id == ((struct pseudo_hdr *)
1435 pdpram_blk->pbuffer)->portdest)
1438 if (i == MAX_NUM_APP) {
1439 pr_debug("No application matching id = %d\n",
1440 ((struct pseudo_hdr *)pdpram_blk->pbuffer)->portdest);
1442 } else if (dev->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1445 dev->app_info[i].nRxMsg++;
1446 /* Put message into the appropriate application block */
1447 list_add_tail(&pdpram_blk->list, &dev->app_info[i].app_sqlist);
1448 dev->app_info[i].NumOfMsg++;
1453 ft1000_free_buffer(pdpram_blk, &freercvpool);
1457 int ft1000_poll(void *dev_id)
1459 struct ft1000_usb *dev = (struct ft1000_usb *)dev_id;
1460 struct ft1000_info *info = netdev_priv(dev->net);
1469 if (ft1000_chkcard(dev) == FALSE) {
1470 pr_debug("failed\n");
1473 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1475 if (tempword & FT1000_DB_DPRAM_RX) {
1476 status = ft1000_read_dpram16(dev,
1477 0x200, (u8 *)&data, 0);
1478 size = ntohs(data) + 16 + 2;
1480 modulo = 4 - (size % 4);
1481 size = size + modulo;
1483 status = ft1000_read_dpram16(dev, 0x201,
1486 if (size < MAX_CMD_SQSIZE) {
1489 pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1490 status = ft1000_proc_drvmsg(dev, size);
1495 status = dsp_broadcast_msg_id(dev);
1498 status = handle_misc_portid(dev);
1502 pr_debug("Invalid total length for SlowQ = %d\n",
1504 status = ft1000_write_register(dev,
1506 FT1000_REG_DOORBELL);
1507 } else if (tempword & FT1000_DSP_ASIC_RESET) {
1508 /* Let's reset the ASIC from the Host side as well */
1509 status = ft1000_write_register(dev, ASIC_RESET_BIT,
1511 status = ft1000_read_register(dev, &tempword,
1514 while (tempword & ASIC_RESET_BIT) {
1515 status = ft1000_read_register(dev, &tempword,
1517 usleep_range(9000, 11000);
1523 pr_debug("Unable to reset ASIC\n");
1526 usleep_range(9000, 11000);
1527 /* Program WMARK register */
1528 status = ft1000_write_register(dev, 0x600,
1529 FT1000_REG_MAG_WATERMARK);
1530 /* clear ASIC reset doorbell */
1531 status = ft1000_write_register(dev,
1532 FT1000_DSP_ASIC_RESET,
1533 FT1000_REG_DOORBELL);
1534 usleep_range(9000, 11000);
1535 } else if (tempword & FT1000_ASIC_RESET_REQ) {
1536 pr_debug("FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1537 /* clear ASIC reset request from DSP */
1538 status = ft1000_write_register(dev,
1539 FT1000_ASIC_RESET_REQ,
1540 FT1000_REG_DOORBELL);
1541 status = ft1000_write_register(dev, HOST_INTF_BE,
1542 FT1000_REG_SUP_CTRL);
1543 /* copy dsp session record from Adapter block */
1544 status = ft1000_write_dpram32(dev, 0,
1545 (u8 *)&info->DSPSess.Rec[0], 1024);
1546 status = ft1000_write_register(dev, 0x600,
1547 FT1000_REG_MAG_WATERMARK);
1548 /* ring doorbell to tell DSP that
1549 * ASIC is out of reset
1551 status = ft1000_write_register(dev,
1552 FT1000_ASIC_RESET_DSP,
1553 FT1000_REG_DOORBELL);
1554 } else if (tempword & FT1000_DB_COND_RESET) {
1555 pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1556 if (!dev->fAppMsgPend) {
1557 /* Reset ASIC and DSP */
1558 status = ft1000_read_dpram16(dev,
1559 FT1000_MAG_DSP_TIMER0,
1560 (u8 *)&info->DSP_TIME[0],
1561 FT1000_MAG_DSP_TIMER0_INDX);
1562 status = ft1000_read_dpram16(dev,
1563 FT1000_MAG_DSP_TIMER1,
1564 (u8 *)&info->DSP_TIME[1],
1565 FT1000_MAG_DSP_TIMER1_INDX);
1566 status = ft1000_read_dpram16(dev,
1567 FT1000_MAG_DSP_TIMER2,
1568 (u8 *)&info->DSP_TIME[2],
1569 FT1000_MAG_DSP_TIMER2_INDX);
1570 status = ft1000_read_dpram16(dev,
1571 FT1000_MAG_DSP_TIMER3,
1572 (u8 *)&info->DSP_TIME[3],
1573 FT1000_MAG_DSP_TIMER3_INDX);
1574 info->CardReady = 0;
1575 info->DrvErrNum = DSP_CONDRESET_INFO;
1576 pr_debug("DSP conditional reset requested\n");
1577 info->ft1000_reset(dev->net);
1579 dev->fProvComplete = false;
1580 dev->fCondResetPend = true;
1582 ft1000_write_register(dev, FT1000_DB_COND_RESET,
1583 FT1000_REG_DOORBELL);