1 /* CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
4 * This file is part of Express Card USB Driver
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/netdevice.h>
10 #include <linux/etherdevice.h>
11 #include <linux/usb.h>
12 #include "ft1000_usb.h"
13 #include <linux/types.h>
15 #define HARLEY_READ_REGISTER 0x0
16 #define HARLEY_WRITE_REGISTER 0x01
17 #define HARLEY_READ_DPRAM_32 0x02
18 #define HARLEY_READ_DPRAM_LOW 0x03
19 #define HARLEY_READ_DPRAM_HIGH 0x04
20 #define HARLEY_WRITE_DPRAM_32 0x05
21 #define HARLEY_WRITE_DPRAM_LOW 0x06
22 #define HARLEY_WRITE_DPRAM_HIGH 0x07
24 #define HARLEY_READ_OPERATION 0xc1
25 #define HARLEY_WRITE_OPERATION 0x41
31 static int ft1000_submit_rx_urb(struct ft1000_info *info);
33 static u8 tempbuffer[1600];
35 #define MAX_RCV_LOOP 100
37 /* send a control message via USB interface synchronously
38 * Parameters: ft1000_usb - device structure
39 * pipe - usb control message pipe
40 * request - control request
41 * requesttype - control message request type
42 * value - value to be written or 0
43 * index - register index
44 * data - data buffer to hold the read/write values
46 * timeout - control message time out value
48 static int ft1000_control(struct ft1000_usb *ft1000dev, unsigned int pipe,
49 u8 request, u8 requesttype, u16 value, u16 index,
50 void *data, u16 size, int timeout)
54 if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
55 DEBUG("ft1000dev or ft1000dev->dev == NULL, failure\n");
59 ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
60 value, index, data, size, timeout);
68 /* returns the value in a register */
69 int ft1000_read_register(struct ft1000_usb *ft1000dev, u16 *Data,
74 ret = ft1000_control(ft1000dev,
75 usb_rcvctrlpipe(ft1000dev->dev, 0),
77 HARLEY_READ_OPERATION,
82 USB_CTRL_GET_TIMEOUT);
87 /* writes the value in a register */
88 int ft1000_write_register(struct ft1000_usb *ft1000dev, u16 value,
93 ret = ft1000_control(ft1000dev,
94 usb_sndctrlpipe(ft1000dev->dev, 0),
95 HARLEY_WRITE_REGISTER,
96 HARLEY_WRITE_OPERATION,
101 USB_CTRL_SET_TIMEOUT);
106 /* read a number of bytes from DPRAM */
107 int ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
112 ret = ft1000_control(ft1000dev,
113 usb_rcvctrlpipe(ft1000dev->dev, 0),
114 HARLEY_READ_DPRAM_32,
115 HARLEY_READ_OPERATION,
120 USB_CTRL_GET_TIMEOUT);
125 /* writes into DPRAM a number of bytes */
126 int ft1000_write_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
132 cnt += cnt - (cnt % 4);
134 ret = ft1000_control(ft1000dev,
135 usb_sndctrlpipe(ft1000dev->dev, 0),
136 HARLEY_WRITE_DPRAM_32,
137 HARLEY_WRITE_OPERATION,
142 USB_CTRL_SET_TIMEOUT);
147 /* read 16 bits from DPRAM */
148 int ft1000_read_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
155 request = HARLEY_READ_DPRAM_LOW;
157 request = HARLEY_READ_DPRAM_HIGH;
159 ret = ft1000_control(ft1000dev,
160 usb_rcvctrlpipe(ft1000dev->dev, 0),
162 HARLEY_READ_OPERATION,
167 USB_CTRL_GET_TIMEOUT);
172 /* write into DPRAM a number of bytes */
173 int ft1000_write_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u16 value,
180 request = HARLEY_WRITE_DPRAM_LOW;
182 request = HARLEY_WRITE_DPRAM_HIGH;
184 ret = ft1000_control(ft1000dev,
185 usb_sndctrlpipe(ft1000dev->dev, 0),
187 HARLEY_WRITE_OPERATION,
192 USB_CTRL_SET_TIMEOUT);
197 /* read DPRAM 4 words at a time */
198 int fix_ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx,
205 pos = (indx / 4) * 4;
206 ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
209 pos = (indx % 4) * 4;
210 *buffer++ = buf[pos++];
211 *buffer++ = buf[pos++];
212 *buffer++ = buf[pos++];
213 *buffer++ = buf[pos++];
215 DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
226 /* Description: This function write to DPRAM 4 words at a time */
227 int fix_ft1000_write_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer)
237 pos1 = (indx / 4) * 4;
239 ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
243 buf[pos2++] = *buffer++;
244 buf[pos2++] = *buffer++;
245 buf[pos2++] = *buffer++;
246 buf[pos2++] = *buffer++;
247 ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
249 DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
253 ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
257 for (i = 0; i < 16; i++) {
258 if (buf[i] != resultbuffer[i])
264 ret = ft1000_write_dpram32(ft1000dev, pos1,
265 (u8 *)&tempbuffer[0], 16);
266 ret = ft1000_read_dpram32(ft1000dev, pos1,
267 (u8 *)&resultbuffer[0], 16);
270 for (i = 0; i < 16; i++) {
271 if (tempbuffer[i] != resultbuffer[i]) {
273 DEBUG("%s Failed to write\n",
283 /* reset or activate the DSP */
284 static void card_reset_dsp(struct ft1000_usb *ft1000dev, bool value)
289 status = ft1000_write_register(ft1000dev, HOST_INTF_BE,
290 FT1000_REG_SUP_CTRL);
291 status = ft1000_read_register(ft1000dev, &tempword,
292 FT1000_REG_SUP_CTRL);
295 DEBUG("Reset DSP\n");
296 status = ft1000_read_register(ft1000dev, &tempword,
298 tempword |= DSP_RESET_BIT;
299 status = ft1000_write_register(ft1000dev, tempword,
302 DEBUG("Activate DSP\n");
303 status = ft1000_read_register(ft1000dev, &tempword,
305 tempword |= DSP_ENCRYPTED;
306 tempword &= ~DSP_UNENCRYPTED;
307 status = ft1000_write_register(ft1000dev, tempword,
309 status = ft1000_read_register(ft1000dev, &tempword,
311 tempword &= ~EFUSE_MEM_DISABLE;
312 tempword &= ~DSP_RESET_BIT;
313 status = ft1000_write_register(ft1000dev, tempword,
315 status = ft1000_read_register(ft1000dev, &tempword,
320 /* send a command to ASIC
321 * Parameters: ft1000_usb - device structure
322 * ptempbuffer - command buffer
323 * size - command buffer size
325 int card_send_command(struct ft1000_usb *ft1000dev, void *ptempbuffer,
330 unsigned char *commandbuf;
332 DEBUG("card_send_command: enter card_send_command... size=%d\n", size);
334 commandbuf = kmalloc(size + 2, GFP_KERNEL);
337 memcpy((void *)commandbuf + 2, (void *)ptempbuffer, size);
339 ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
344 usleep_range(900, 1100);
346 /* check for odd word */
349 /* Must force to be 32 bit aligned */
351 size += 4 - (size % 4);
353 ret = ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
356 usleep_range(900, 1100);
357 ret = ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
358 FT1000_REG_DOORBELL);
361 usleep_range(900, 1100);
363 ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
366 if ((temp & 0x0100) == 0)
367 DEBUG("card_send_command: Message sent\n");
372 /* load or reload the DSP */
373 int dsp_reload(struct ft1000_usb *ft1000dev)
379 struct ft1000_info *pft1000info;
381 pft1000info = netdev_priv(ft1000dev->net);
383 pft1000info->CardReady = 0;
385 /* Program Interrupt Mask register */
386 status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
388 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
389 tempword |= ASIC_RESET_BIT;
390 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
392 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
393 DEBUG("Reset Register = 0x%x\n", tempword);
395 /* Toggle DSP reset */
396 card_reset_dsp(ft1000dev, 1);
398 card_reset_dsp(ft1000dev, 0);
402 ft1000_write_register(ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
404 /* Let's check for FEFE */
406 ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
407 (u8 *) &templong, 4);
408 DEBUG("templong (fefe) = 0x%8x\n", templong);
410 /* call codeloader */
411 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
418 DEBUG("dsp_reload returned\n");
423 /* call the Card Service function to reset the ASIC. */
424 static void ft1000_reset_asic(struct net_device *dev)
426 struct ft1000_info *info = netdev_priv(dev);
427 struct ft1000_usb *ft1000dev = info->priv;
430 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
432 /* Let's use the register provided by the Magnemite ASIC to reset the
435 ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT),
440 /* set watermark to -1 in order to not generate an interrupt */
441 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
443 /* clear interrupts */
444 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
445 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
446 ft1000_write_register(ft1000dev, tempword, FT1000_REG_SUP_ISR);
447 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
448 DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
451 static int ft1000_reset_card(struct net_device *dev)
453 struct ft1000_info *info = netdev_priv(dev);
454 struct ft1000_usb *ft1000dev = info->priv;
456 struct prov_record *ptr;
458 DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
460 ft1000dev->fCondResetPend = true;
462 ft1000dev->fProvComplete = false;
464 /* Make sure we free any memory reserve for provisioning */
465 while (list_empty(&info->prov_list) == 0) {
466 DEBUG("ft1000_reset_card:deleting provisioning record\n");
468 list_entry(info->prov_list.next, struct prov_record, list);
469 list_del(&ptr->list);
470 kfree(ptr->pprov_data);
474 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
475 ft1000_reset_asic(dev);
477 DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
478 dsp_reload(ft1000dev);
480 DEBUG("dsp reload successful\n");
484 /* Initialize DSP heartbeat area */
485 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
486 FT1000_MAG_HI_HO_INDX);
487 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *) &tempword,
488 FT1000_MAG_HI_HO_INDX);
489 DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
493 ft1000dev->fCondResetPend = false;
498 /* callback function when a urb is transmitted */
499 static void ft1000_usb_transmit_complete(struct urb *urb)
502 struct ft1000_usb *ft1000dev = urb->context;
505 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
507 netif_wake_queue(ft1000dev->net);
510 /* take an ethernet packet and convert it to a Flarion
511 * packet prior to sending it to the ASIC Downlink FIFO.
513 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 *packet, u16 len)
515 struct ft1000_info *pInfo = netdev_priv(netdev);
516 struct ft1000_usb *pFt1000Dev = pInfo->priv;
520 struct pseudo_hdr hdr;
522 if (!pInfo->CardReady) {
523 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
527 count = sizeof(struct pseudo_hdr) + len;
528 if (count > MAX_BUF_SIZE) {
529 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
530 DEBUG("size = %d\n", count);
535 count = count + (4 - (count % 4));
537 memset(&hdr, 0, sizeof(struct pseudo_hdr));
539 hdr.length = ntohs(count);
541 hdr.destination = 0x20;
544 hdr.sh_str_id = 0x91;
547 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
548 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
550 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
551 memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
553 netif_stop_queue(netdev);
555 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
557 usb_sndbulkpipe(pFt1000Dev->dev,
558 pFt1000Dev->bulk_out_endpointAddr),
559 pFt1000Dev->tx_buf, count,
560 ft1000_usb_transmit_complete, (void *)pFt1000Dev);
562 t = (u8 *) pFt1000Dev->tx_urb->transfer_buffer;
564 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
567 DEBUG("ft1000 failed tx_urb %d\n", ret);
570 pInfo->stats.tx_packets++;
571 pInfo->stats.tx_bytes += (len + 14);
577 /* transmit an ethernet packet
578 * Parameters: skb - socket buffer to be sent
579 * dev - network device
581 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
583 struct ft1000_info *pInfo = netdev_priv(dev);
584 struct ft1000_usb *pFt1000Dev = pInfo->priv;
589 DEBUG("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n");
593 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
594 DEBUG("network driver is closed, return\n");
599 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
600 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
602 pdata = (u8 *) skb->data;
604 if (pInfo->mediastate == 0) {
605 /* Drop packet is mediastate is down */
606 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
610 if ((skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE)) {
611 /* Drop packet which has invalid size */
612 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
616 ft1000_copy_down_pkt(dev, (pdata + ENET_HEADER_SIZE - 2),
617 skb->len - ENET_HEADER_SIZE + 2);
625 /* open the network driver */
626 static int ft1000_open(struct net_device *dev)
628 struct ft1000_info *pInfo = netdev_priv(dev);
629 struct ft1000_usb *pFt1000Dev = pInfo->priv;
632 DEBUG("ft1000_open is called for card %d\n", pFt1000Dev->CardNumber);
634 pInfo->stats.rx_bytes = 0;
635 pInfo->stats.tx_bytes = 0;
636 pInfo->stats.rx_packets = 0;
637 pInfo->stats.tx_packets = 0;
638 do_gettimeofday(&tv);
639 pInfo->ConTm = tv.tv_sec;
640 pInfo->ProgConStat = 0;
642 netif_start_queue(dev);
644 netif_carrier_on(dev);
646 return ft1000_submit_rx_urb(pInfo);
649 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
651 struct ft1000_info *info = netdev_priv(dev);
653 return &(info->stats);
656 static const struct net_device_ops ftnet_ops = {
657 .ndo_open = &ft1000_open,
658 .ndo_stop = &ft1000_close,
659 .ndo_start_xmit = &ft1000_start_xmit,
660 .ndo_get_stats = &ft1000_netdev_stats,
663 /* initialize the network device */
664 static int ft1000_reset(void *dev)
666 ft1000_reset_card(dev);
670 int init_ft1000_netdev(struct ft1000_usb *ft1000dev)
672 struct net_device *netdev;
673 struct ft1000_info *pInfo = NULL;
674 struct dpram_blk *pdpram_blk;
676 struct list_head *cur, *tmp;
680 DEBUG("Enter init_ft1000_netdev...\n");
682 netdev = alloc_etherdev(sizeof(struct ft1000_info));
684 DEBUG("init_ft1000_netdev: can not allocate network device\n");
688 pInfo = netdev_priv(netdev);
690 memset(pInfo, 0, sizeof(struct ft1000_info));
692 dev_alloc_name(netdev, netdev->name);
694 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
696 if (strncmp(netdev->name, "eth", 3) == 0) {
697 card_nr[0] = netdev->name[3];
699 ret_val = kstrtou8(card_nr, 10, &gCardIndex);
701 netdev_err(ft1000dev->net, "Can't parse netdev\n");
705 ft1000dev->CardNumber = gCardIndex;
706 DEBUG("card number = %d\n", ft1000dev->CardNumber);
708 netdev_err(ft1000dev->net, "ft1000: Invalid device name\n");
713 memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
715 spin_lock_init(&pInfo->dpram_lock);
716 pInfo->priv = ft1000dev;
717 pInfo->DrvErrNum = 0;
718 pInfo->registered = 1;
719 pInfo->ft1000_reset = ft1000_reset;
720 pInfo->mediastate = 0;
722 ft1000dev->DeviceCreated = FALSE;
723 pInfo->CardReady = 0;
724 pInfo->DSP_TIME[0] = 0;
725 pInfo->DSP_TIME[1] = 0;
726 pInfo->DSP_TIME[2] = 0;
727 pInfo->DSP_TIME[3] = 0;
728 ft1000dev->fAppMsgPend = false;
729 ft1000dev->fCondResetPend = false;
730 ft1000dev->usbboot = 0;
731 ft1000dev->dspalive = 0;
732 memset(&ft1000dev->tempbuf[0], 0, sizeof(ft1000dev->tempbuf));
734 INIT_LIST_HEAD(&pInfo->prov_list);
736 INIT_LIST_HEAD(&ft1000dev->nodes.list);
738 netdev->netdev_ops = &ftnet_ops;
740 ft1000dev->net = netdev;
742 DEBUG("Initialize free_buff_lock and freercvpool\n");
743 spin_lock_init(&free_buff_lock);
745 /* initialize a list of buffers to be use for queuing
746 * up receive command data
748 INIT_LIST_HEAD(&freercvpool);
750 /* create list of free buffers */
751 for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
752 /* Get memory for DPRAM_DATA link list */
753 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
754 if (pdpram_blk == NULL) {
758 /* Get a block of memory to store command data */
759 pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
760 if (pdpram_blk->pbuffer == NULL) {
765 /* link provisioning data */
766 list_add_tail(&pdpram_blk->list, &freercvpool);
768 numofmsgbuf = NUM_OF_FREE_BUFFERS;
773 list_for_each_safe(cur, tmp, &freercvpool) {
774 pdpram_blk = list_entry(cur, struct dpram_blk, list);
775 list_del(&pdpram_blk->list);
776 kfree(pdpram_blk->pbuffer);
784 /* register the network driver */
785 int reg_ft1000_netdev(struct ft1000_usb *ft1000dev,
786 struct usb_interface *intf)
788 struct net_device *netdev;
789 struct ft1000_info *pInfo;
792 netdev = ft1000dev->net;
793 pInfo = netdev_priv(ft1000dev->net);
794 DEBUG("Enter reg_ft1000_netdev...\n");
796 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
798 usb_set_intfdata(intf, pInfo);
799 SET_NETDEV_DEV(netdev, &intf->dev);
801 rc = register_netdev(netdev);
803 DEBUG("reg_ft1000_netdev: could not register network device\n");
808 ft1000_create_dev(ft1000dev);
810 DEBUG("reg_ft1000_netdev returned\n");
812 pInfo->CardReady = 1;
817 /* take a packet from the FIFO up link and
818 * convert it into an ethernet packet and deliver it to the IP stack
820 static int ft1000_copy_up_pkt(struct urb *urb)
822 struct ft1000_info *info = urb->context;
823 struct ft1000_usb *ft1000dev = info->priv;
824 struct net_device *net = ft1000dev->net;
835 if (ft1000dev->status & FT1000_STATUS_CLOSING) {
836 DEBUG("network driver is closed, return\n");
840 len = urb->transfer_buffer_length;
841 lena = urb->actual_length;
843 chksum = (u16 *) ft1000dev->rx_buf;
845 tempword = *chksum++;
846 for (i = 1; i < 7; i++)
847 tempword ^= *chksum++;
849 if (tempword != *chksum) {
850 info->stats.rx_errors++;
851 ft1000_submit_rx_urb(info);
855 skb = dev_alloc_skb(len + 12 + 2);
858 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
859 info->stats.rx_errors++;
860 ft1000_submit_rx_urb(info);
864 pbuffer = (u8 *) skb_put(skb, len + 12);
866 /* subtract the number of bytes read already */
869 /* fake MAC address */
870 *pbuffer++ = net->dev_addr[0];
871 *pbuffer++ = net->dev_addr[1];
872 *pbuffer++ = net->dev_addr[2];
873 *pbuffer++ = net->dev_addr[3];
874 *pbuffer++ = net->dev_addr[4];
875 *pbuffer++ = net->dev_addr[5];
883 memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
884 len - sizeof(struct pseudo_hdr));
888 skb->protocol = eth_type_trans(skb, net);
889 skb->ip_summed = CHECKSUM_UNNECESSARY;
892 info->stats.rx_packets++;
893 /* Add on 12 bytes for MAC address which was removed */
894 info->stats.rx_bytes += (lena + 12);
896 ft1000_submit_rx_urb(info);
902 /* the receiving function of the network driver */
903 static int ft1000_submit_rx_urb(struct ft1000_info *info)
906 struct ft1000_usb *pFt1000Dev = info->priv;
908 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
909 DEBUG("network driver is closed, return\n");
913 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
915 usb_rcvbulkpipe(pFt1000Dev->dev,
916 pFt1000Dev->bulk_in_endpointAddr),
917 pFt1000Dev->rx_buf, MAX_BUF_SIZE,
918 (usb_complete_t) ft1000_copy_up_pkt, info);
920 result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
923 pr_err("ft1000_submit_rx_urb: submitting rx_urb %d failed\n",
931 /* close the network driver */
932 int ft1000_close(struct net_device *net)
934 struct ft1000_info *pInfo = netdev_priv(net);
935 struct ft1000_usb *ft1000dev = pInfo->priv;
937 ft1000dev->status |= FT1000_STATUS_CLOSING;
939 DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
940 netif_carrier_off(net);
941 netif_stop_queue(net);
942 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
944 pInfo->ProgConStat = 0xff;
949 /* check if the device is presently available on the system. */
950 static int ft1000_chkcard(struct ft1000_usb *dev)
955 if (dev->fCondResetPend) {
956 DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
959 /* Mask register is used to check for device presence since it is never
962 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
964 DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
967 /* The system will return the value of 0xffff for the version register
968 * if the device is not present.
970 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
971 if (tempword != 0x1b01) {
972 dev->status |= FT1000_STATUS_CLOSING;
973 DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
979 /* read a message from the dpram area.
981 * dev - network device structure
982 * pbuffer - caller supply address to buffer
984 static bool ft1000_receive_cmd(struct ft1000_usb *dev, u16 *pbuffer,
994 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *) &size,
995 FT1000_MAG_PH_LEN_INDX);
996 size = ntohs(size) + PSEUDOSZ;
998 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n",
1002 ppseudohdr = (u16 *) pbuffer;
1003 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
1004 FT1000_REG_DPRAM_ADDR);
1006 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1008 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
1009 FT1000_REG_DPRAM_ADDR);
1010 for (i = 0; i <= (size >> 2); i++) {
1012 ft1000_read_register(dev, pbuffer,
1013 FT1000_REG_MAG_DPDATAL);
1016 ft1000_read_register(dev, pbuffer,
1017 FT1000_REG_MAG_DPDATAH);
1020 /* copy odd aligned word */
1022 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1026 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1029 if (size & 0x0001) {
1030 /* copy odd byte from fifo */
1032 ft1000_read_register(dev, &tempword,
1033 FT1000_REG_DPRAM_DATA);
1034 *pbuffer = ntohs(tempword);
1036 /* Check if pseudo header checksum is good
1037 * Calculate pseudo header checksum
1039 tempword = *ppseudohdr++;
1040 for (i = 1; i < 7; i++)
1041 tempword ^= *ppseudohdr++;
1043 if ((tempword != *ppseudohdr))
1050 static int ft1000_dsp_prov(void *arg)
1052 struct ft1000_usb *dev = (struct ft1000_usb *)arg;
1053 struct ft1000_info *info = netdev_priv(dev->net);
1057 struct prov_record *ptr;
1058 struct pseudo_hdr *ppseudo_hdr;
1061 u16 TempShortBuf[256];
1063 DEBUG("*** DspProv Entered\n");
1065 while (list_empty(&info->prov_list) == 0) {
1066 DEBUG("DSP Provisioning List Entry\n");
1068 /* Check if doorbell is available */
1069 DEBUG("check if doorbell is cleared\n");
1071 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1073 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1077 while (tempword & FT1000_DB_DPRAM_TX) {
1081 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1084 ft1000_read_register(dev, &tempword,
1085 FT1000_REG_DOORBELL);
1088 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1089 DEBUG("*** Provision Data Sent to DSP\n");
1091 /* Send provisioning data */
1093 list_entry(info->prov_list.next, struct prov_record,
1095 len = *(u16 *) ptr->pprov_data;
1099 pmsg = (u16 *) ptr->pprov_data;
1100 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1101 /* Insert slow queue sequence number */
1102 ppseudo_hdr->seq_num = info->squeseqnum++;
1103 ppseudo_hdr->portsrc = 0;
1104 /* Calculate new checksum */
1105 ppseudo_hdr->checksum = *pmsg++;
1106 for (i = 1; i < 7; i++)
1107 ppseudo_hdr->checksum ^= *pmsg++;
1109 TempShortBuf[0] = 0;
1110 TempShortBuf[1] = htons(len);
1111 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1114 ft1000_write_dpram32(dev, 0,
1115 (u8 *) &TempShortBuf[0],
1116 (unsigned short)(len + 2));
1118 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1119 FT1000_REG_DOORBELL);
1121 list_del(&ptr->list);
1122 kfree(ptr->pprov_data);
1125 usleep_range(9000, 11000);
1128 DEBUG("DSP Provisioning List Entry finished\n");
1132 dev->fProvComplete = true;
1133 info->CardReady = 1;
1138 static int ft1000_proc_drvmsg(struct ft1000_usb *dev, u16 size)
1140 struct ft1000_info *info = netdev_priv(dev->net);
1143 struct media_msg *pmediamsg;
1144 struct dsp_init_msg *pdspinitmsg;
1145 struct drv_msg *pdrvmsg;
1147 struct pseudo_hdr *ppseudo_hdr;
1155 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1159 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1162 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1163 for (i = 0; i < size; i += 5) {
1165 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i],
1166 cmdbuffer[i + 1], cmdbuffer[i + 2],
1167 cmdbuffer[i + 3], cmdbuffer[i + 4]);
1169 for (j = i; j < size; j++)
1170 DEBUG("0x%x ", cmdbuffer[j]);
1176 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1177 msgtype = ntohs(pdrvmsg->type);
1178 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1181 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1182 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1183 if (info->ProgConStat != 0xFF) {
1184 if (pmediamsg->state) {
1185 DEBUG("Media is up\n");
1186 if (info->mediastate == 0) {
1187 if (dev->NetDevRegDone)
1188 netif_wake_queue(dev->net);
1189 info->mediastate = 1;
1192 DEBUG("Media is down\n");
1193 if (info->mediastate == 1) {
1194 info->mediastate = 0;
1195 if (dev->NetDevRegDone)
1200 DEBUG("Media is down\n");
1201 if (info->mediastate == 1) {
1202 info->mediastate = 0;
1209 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1210 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1211 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1212 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1213 info->DspVer[0], info->DspVer[1], info->DspVer[2],
1215 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1217 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1218 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1219 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1220 info->eui64[0], info->eui64[1], info->eui64[2],
1221 info->eui64[3], info->eui64[4], info->eui64[5],
1222 info->eui64[6], info->eui64[7]);
1223 dev->net->dev_addr[0] = info->eui64[0];
1224 dev->net->dev_addr[1] = info->eui64[1];
1225 dev->net->dev_addr[2] = info->eui64[2];
1226 dev->net->dev_addr[3] = info->eui64[5];
1227 dev->net->dev_addr[4] = info->eui64[6];
1228 dev->net->dev_addr[5] = info->eui64[7];
1230 if (ntohs(pdspinitmsg->length) ==
1231 (sizeof(struct dsp_init_msg) - 20)) {
1232 memcpy(info->ProductMode, pdspinitmsg->ProductMode,
1234 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1235 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1237 DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0],
1242 case DSP_PROVISION:{
1243 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1245 /* kick off dspprov routine to start provisioning
1246 * Send provisioning data to DSP
1248 if (list_empty(&info->prov_list) == 0) {
1249 dev->fProvComplete = false;
1250 status = ft1000_dsp_prov(dev);
1254 dev->fProvComplete = true;
1255 status = ft1000_write_register(dev, FT1000_DB_HB,
1256 FT1000_REG_DOORBELL);
1257 DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1259 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1262 case DSP_STORE_INFO:{
1263 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1264 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1265 tempword = ntohs(pdrvmsg->length);
1266 info->DSPInfoBlklen = tempword;
1267 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1268 pmsg = (u16 *) &pdrvmsg->data[0];
1269 for (i = 0; i < ((tempword + 1) / 2); i++) {
1270 DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
1271 info->DSPInfoBlk[i + 10] = *pmsg++;
1274 info->DSPInfoBlklen = 0;
1279 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1280 /* copy dsp info block to dsp */
1281 dev->DrvMsgPend = 1;
1282 /* allow any outstanding ioctl to finish */
1284 status = ft1000_read_register(dev, &tempword,
1285 FT1000_REG_DOORBELL);
1286 if (tempword & FT1000_DB_DPRAM_TX) {
1288 status = ft1000_read_register(dev, &tempword,
1289 FT1000_REG_DOORBELL);
1290 if (tempword & FT1000_DB_DPRAM_TX) {
1292 status = ft1000_read_register(dev, &tempword,
1293 FT1000_REG_DOORBELL);
1294 if (tempword & FT1000_DB_DPRAM_TX)
1298 /* Put message into Slow Queue Form Pseudo header */
1299 pmsg = (u16 *) info->DSPInfoBlk;
1301 *pmsg++ = htons(info->DSPInfoBlklen + 20 + info->DSPInfoBlklen);
1303 (struct pseudo_hdr *)(u16 *) &info->DSPInfoBlk[2];
1304 ppseudo_hdr->length = htons(info->DSPInfoBlklen + 4
1305 + info->DSPInfoBlklen);
1306 ppseudo_hdr->source = 0x10;
1307 ppseudo_hdr->destination = 0x20;
1308 ppseudo_hdr->portdest = 0;
1309 ppseudo_hdr->portsrc = 0;
1310 ppseudo_hdr->sh_str_id = 0;
1311 ppseudo_hdr->control = 0;
1312 ppseudo_hdr->rsvd1 = 0;
1313 ppseudo_hdr->rsvd2 = 0;
1314 ppseudo_hdr->qos_class = 0;
1315 /* Insert slow queue sequence number */
1316 ppseudo_hdr->seq_num = info->squeseqnum++;
1317 /* Insert application id */
1318 ppseudo_hdr->portsrc = 0;
1319 /* Calculate new checksum */
1320 ppseudo_hdr->checksum = *pmsg++;
1321 for (i = 1; i < 7; i++)
1322 ppseudo_hdr->checksum ^= *pmsg++;
1324 info->DSPInfoBlk[10] = 0x7200;
1325 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1326 status = ft1000_write_dpram32(dev, 0,
1327 (u8 *)&info->DSPInfoBlk[0],
1328 (unsigned short)(info->DSPInfoBlklen + 22));
1329 status = ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1330 FT1000_REG_DOORBELL);
1331 dev->DrvMsgPend = 0;
1334 case GET_DRV_ERR_RPT_MSG:{
1335 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1336 /* copy driver error message to dsp */
1337 dev->DrvMsgPend = 1;
1338 /* allow any outstanding ioctl to finish */
1340 status = ft1000_read_register(dev, &tempword,
1341 FT1000_REG_DOORBELL);
1342 if (tempword & FT1000_DB_DPRAM_TX) {
1344 status = ft1000_read_register(dev, &tempword,
1345 FT1000_REG_DOORBELL);
1346 if (tempword & FT1000_DB_DPRAM_TX)
1349 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1350 /* Put message into Slow Queue Form Pseudo header */
1351 pmsg = (u16 *) &tempbuffer[0];
1352 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1353 ppseudo_hdr->length = htons(0x0012);
1354 ppseudo_hdr->source = 0x10;
1355 ppseudo_hdr->destination = 0x20;
1356 ppseudo_hdr->portdest = 0;
1357 ppseudo_hdr->portsrc = 0;
1358 ppseudo_hdr->sh_str_id = 0;
1359 ppseudo_hdr->control = 0;
1360 ppseudo_hdr->rsvd1 = 0;
1361 ppseudo_hdr->rsvd2 = 0;
1362 ppseudo_hdr->qos_class = 0;
1363 /* Insert slow queue sequence number */
1364 ppseudo_hdr->seq_num = info->squeseqnum++;
1365 /* Insert application id */
1366 ppseudo_hdr->portsrc = 0;
1367 /* Calculate new checksum */
1368 ppseudo_hdr->checksum = *pmsg++;
1369 for (i = 1; i < 7; i++)
1370 ppseudo_hdr->checksum ^= *pmsg++;
1372 pmsg = (u16 *) &tempbuffer[16];
1373 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1374 *pmsg++ = htons(0x000e);
1375 *pmsg++ = htons(info->DSP_TIME[0]);
1376 *pmsg++ = htons(info->DSP_TIME[1]);
1377 *pmsg++ = htons(info->DSP_TIME[2]);
1378 *pmsg++ = htons(info->DSP_TIME[3]);
1379 convert.byte[0] = info->DspVer[0];
1380 convert.byte[1] = info->DspVer[1];
1381 *pmsg++ = convert.wrd;
1382 convert.byte[0] = info->DspVer[2];
1383 convert.byte[1] = info->DspVer[3];
1384 *pmsg++ = convert.wrd;
1385 *pmsg++ = htons(info->DrvErrNum);
1387 status = card_send_command(dev, (unsigned char *)&tempbuffer[0],
1388 (u16)(0x0012 + PSEUDOSZ));
1391 info->DrvErrNum = 0;
1393 dev->DrvMsgPend = 0;
1403 DEBUG("return from ft1000_proc_drvmsg\n");
1407 /* Check which application has registered for dsp broadcast messages */
1408 static int dsp_broadcast_msg_id(struct ft1000_usb *dev)
1410 struct dpram_blk *pdpram_blk;
1411 unsigned long flags;
1414 for (i = 0; i < MAX_NUM_APP; i++) {
1415 if ((dev->app_info[i].DspBCMsgFlag)
1416 && (dev->app_info[i].fileobject)
1417 && (dev->app_info[i].NumOfMsg
1419 pdpram_blk = ft1000_get_buffer(&freercvpool);
1420 if (pdpram_blk == NULL) {
1421 DEBUG("Out of memory in free receive command pool\n");
1422 dev->app_info[i].nRxMsgMiss++;
1425 if (ft1000_receive_cmd(dev, pdpram_blk->pbuffer,
1427 /* Put message into the
1428 * appropriate application block
1430 dev->app_info[i].nRxMsg++;
1431 spin_lock_irqsave(&free_buff_lock, flags);
1432 list_add_tail(&pdpram_blk->list,
1433 &dev->app_info[i] .app_sqlist);
1434 dev->app_info[i].NumOfMsg++;
1435 spin_unlock_irqrestore(&free_buff_lock, flags);
1436 wake_up_interruptible(&dev->app_info[i]
1439 dev->app_info[i].nRxMsgMiss++;
1440 ft1000_free_buffer(pdpram_blk, &freercvpool);
1441 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1449 static int handle_misc_portid(struct ft1000_usb *dev)
1451 struct dpram_blk *pdpram_blk;
1454 pdpram_blk = ft1000_get_buffer(&freercvpool);
1455 if (pdpram_blk == NULL) {
1456 DEBUG("Out of memory in free receive command pool\n");
1459 if (!ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE))
1462 /* Search for correct application block */
1463 for (i = 0; i < MAX_NUM_APP; i++) {
1464 if (dev->app_info[i].app_id == ((struct pseudo_hdr *)
1465 pdpram_blk->pbuffer)->portdest)
1468 if (i == MAX_NUM_APP) {
1469 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ((struct pseudo_hdr *)pdpram_blk->pbuffer)->portdest);
1471 } else if (dev->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1474 dev->app_info[i].nRxMsg++;
1475 /* Put message into the appropriate application block */
1476 list_add_tail(&pdpram_blk->list, &dev->app_info[i].app_sqlist);
1477 dev->app_info[i].NumOfMsg++;
1482 ft1000_free_buffer(pdpram_blk, &freercvpool);
1486 int ft1000_poll(void *dev_id)
1488 struct ft1000_usb *dev = (struct ft1000_usb *)dev_id;
1489 struct ft1000_info *info = netdev_priv(dev->net);
1498 if (ft1000_chkcard(dev) == FALSE) {
1499 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1502 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1504 if (tempword & FT1000_DB_DPRAM_RX) {
1505 status = ft1000_read_dpram16(dev,
1506 0x200, (u8 *)&data, 0);
1507 size = ntohs(data) + 16 + 2;
1509 modulo = 4 - (size % 4);
1510 size = size + modulo;
1512 status = ft1000_read_dpram16(dev, 0x201,
1515 if (size < MAX_CMD_SQSIZE) {
1518 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1519 status = ft1000_proc_drvmsg(dev, size);
1524 status = dsp_broadcast_msg_id(dev);
1527 status = handle_misc_portid(dev);
1531 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
1532 status = ft1000_write_register(dev,
1534 FT1000_REG_DOORBELL);
1535 } else if (tempword & FT1000_DSP_ASIC_RESET) {
1536 /* Let's reset the ASIC from the Host side as well */
1537 status = ft1000_write_register(dev, ASIC_RESET_BIT,
1539 status = ft1000_read_register(dev, &tempword,
1542 while (tempword & ASIC_RESET_BIT) {
1543 status = ft1000_read_register(dev, &tempword,
1545 usleep_range(9000, 11000);
1551 DEBUG("Unable to reset ASIC\n");
1554 usleep_range(9000, 11000);
1555 /* Program WMARK register */
1556 status = ft1000_write_register(dev, 0x600,
1557 FT1000_REG_MAG_WATERMARK);
1558 /* clear ASIC reset doorbell */
1559 status = ft1000_write_register(dev,
1560 FT1000_DSP_ASIC_RESET,
1561 FT1000_REG_DOORBELL);
1562 usleep_range(9000, 11000);
1563 } else if (tempword & FT1000_ASIC_RESET_REQ) {
1564 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1565 /* clear ASIC reset request from DSP */
1566 status = ft1000_write_register(dev,
1567 FT1000_ASIC_RESET_REQ,
1568 FT1000_REG_DOORBELL);
1569 status = ft1000_write_register(dev, HOST_INTF_BE,
1570 FT1000_REG_SUP_CTRL);
1571 /* copy dsp session record from Adapter block */
1572 status = ft1000_write_dpram32(dev, 0,
1573 (u8 *)&info->DSPSess.Rec[0], 1024);
1574 status = ft1000_write_register(dev, 0x600,
1575 FT1000_REG_MAG_WATERMARK);
1576 /* ring doorbell to tell DSP that
1577 * ASIC is out of reset
1579 status = ft1000_write_register(dev,
1580 FT1000_ASIC_RESET_DSP,
1581 FT1000_REG_DOORBELL);
1582 } else if (tempword & FT1000_DB_COND_RESET) {
1583 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1584 if (!dev->fAppMsgPend) {
1585 /* Reset ASIC and DSP */
1586 status = ft1000_read_dpram16(dev,
1587 FT1000_MAG_DSP_TIMER0,
1588 (u8 *)&(info->DSP_TIME[0]),
1589 FT1000_MAG_DSP_TIMER0_INDX);
1590 status = ft1000_read_dpram16(dev,
1591 FT1000_MAG_DSP_TIMER1,
1592 (u8 *)&(info->DSP_TIME[1]),
1593 FT1000_MAG_DSP_TIMER1_INDX);
1594 status = ft1000_read_dpram16(dev,
1595 FT1000_MAG_DSP_TIMER2,
1596 (u8 *)&(info->DSP_TIME[2]),
1597 FT1000_MAG_DSP_TIMER2_INDX);
1598 status = ft1000_read_dpram16(dev,
1599 FT1000_MAG_DSP_TIMER3,
1600 (u8 *)&(info->DSP_TIME[3]),
1601 FT1000_MAG_DSP_TIMER3_INDX);
1602 info->CardReady = 0;
1603 info->DrvErrNum = DSP_CONDRESET_INFO;
1604 DEBUG("ft1000_hw:DSP conditional reset requested\n");
1605 info->ft1000_reset(dev->net);
1607 dev->fProvComplete = false;
1608 dev->fCondResetPend = true;
1610 ft1000_write_register(dev, FT1000_DB_COND_RESET,
1611 FT1000_REG_DOORBELL);