drivers/staging/ft1000/ft1000-usb/ft1000_hw.c

   1 /* CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
   2  *
   3  *
   4  * This file is part of Express Card USB Driver
   5  */
   6
   7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   8
   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>
  16
  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
  25
  26 #define HARLEY_READ_OPERATION    0xc1
  27 #define HARLEY_WRITE_OPERATION   0x41
  28
  29 #if 0
  30 #define JDEBUG
  31 #endif
  32
  33 static int ft1000_submit_rx_urb(struct ft1000_info *info);
  34
  35 static u8 tempbuffer[1600];
  36
  37 #define MAX_RCV_LOOP   100
  38
  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
  47  *               size - data size
  48  *               timeout - control message time out value
  49  */
  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)
  53 {
  54         int ret;
  55
  56         if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
  57                 pr_debug("ft1000dev or ft1000dev->dev == NULL, failure\n");
  58                 return -ENODEV;
  59         }
  60
  61         ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
  62                               value, index, data, size, timeout);
  63
  64         if (ret > 0)
  65                 ret = 0;
  66
  67         return ret;
  68 }
  69
  70 /* returns the value in a register */
  71 int ft1000_read_register(struct ft1000_usb *ft1000dev, u16 *Data,
  72                          u16 nRegIndx)
  73 {
  74         int ret = 0;
  75
  76         ret = ft1000_control(ft1000dev,
  77                              usb_rcvctrlpipe(ft1000dev->dev, 0),
  78                              HARLEY_READ_REGISTER,
  79                              HARLEY_READ_OPERATION,
  80                              0,
  81                              nRegIndx,
  82                              Data,
  83                              2,
  84                              USB_CTRL_GET_TIMEOUT);
  85
  86         return ret;
  87 }
  88
  89 /* writes the value in a register */
  90 int ft1000_write_register(struct ft1000_usb *ft1000dev, u16 value,
  91                           u16 nRegIndx)
  92 {
  93         int ret = 0;
  94
  95         ret = ft1000_control(ft1000dev,
  96                              usb_sndctrlpipe(ft1000dev->dev, 0),
  97                              HARLEY_WRITE_REGISTER,
  98                              HARLEY_WRITE_OPERATION,
  99                              value,
 100                              nRegIndx,
 101                              NULL,
 102                              0,
 103                              USB_CTRL_SET_TIMEOUT);
 104
 105         return ret;
 106 }
 107
 108 /* read a number of bytes from DPRAM */
 109 int ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
 110                         u16 cnt)
 111 {
 112         int ret = 0;
 113
 114         ret = ft1000_control(ft1000dev,
 115                              usb_rcvctrlpipe(ft1000dev->dev, 0),
 116                              HARLEY_READ_DPRAM_32,
 117                              HARLEY_READ_OPERATION,
 118                              0,
 119                              indx,
 120                              buffer,
 121                              cnt,
 122                              USB_CTRL_GET_TIMEOUT);
 123
 124         return ret;
 125 }
 126
 127 /* writes into DPRAM a number of bytes */
 128 int ft1000_write_dpram32(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
 129                          u16 cnt)
 130 {
 131         int ret = 0;
 132
 133         if (cnt % 4)
 134                 cnt += cnt - (cnt % 4);
 135
 136         ret = ft1000_control(ft1000dev,
 137                              usb_sndctrlpipe(ft1000dev->dev, 0),
 138                              HARLEY_WRITE_DPRAM_32,
 139                              HARLEY_WRITE_OPERATION,
 140                              0,
 141                              indx,
 142                              buffer,
 143                              cnt,
 144                              USB_CTRL_SET_TIMEOUT);
 145
 146         return ret;
 147 }
 148
 149 /* read 16 bits from DPRAM */
 150 int ft1000_read_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u8 *buffer,
 151                         u8 highlow)
 152 {
 153         int ret = 0;
 154         u8 request;
 155
 156         if (highlow == 0)
 157                 request = HARLEY_READ_DPRAM_LOW;
 158         else
 159                 request = HARLEY_READ_DPRAM_HIGH;
 160
 161         ret = ft1000_control(ft1000dev,
 162                              usb_rcvctrlpipe(ft1000dev->dev, 0),
 163                              request,
 164                              HARLEY_READ_OPERATION,
 165                              0,
 166                              indx,
 167                              buffer,
 168                              2,
 169                              USB_CTRL_GET_TIMEOUT);
 170
 171         return ret;
 172 }
 173
 174 /* write into DPRAM a number of bytes */
 175 int ft1000_write_dpram16(struct ft1000_usb *ft1000dev, u16 indx, u16 value,
 176                          u8 highlow)
 177 {
 178         int ret = 0;
 179         u8 request;
 180
 181         if (highlow == 0)
 182                 request = HARLEY_WRITE_DPRAM_LOW;
 183         else
 184                 request = HARLEY_WRITE_DPRAM_HIGH;
 185
 186         ret = ft1000_control(ft1000dev,
 187                              usb_sndctrlpipe(ft1000dev->dev, 0),
 188                              request,
 189                              HARLEY_WRITE_OPERATION,
 190                              value,
 191                              indx,
 192                              NULL,
 193                              0,
 194                              USB_CTRL_SET_TIMEOUT);
 195
 196         return ret;
 197 }
 198
 199 /* read DPRAM 4 words at a time */
 200 int fix_ft1000_read_dpram32(struct ft1000_usb *ft1000dev, u16 indx,
 201                             u8 *buffer)
 202 {
 203         u8 buf[16];
 204         u16 pos;
 205         int ret = 0;
 206
 207         pos = (indx / 4) * 4;
 208         ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
 209
 210         if (ret == 0) {
 211                 pos = (indx % 4) * 4;
 212                 *buffer++ = buf[pos++];
 213                 *buffer++ = buf[pos++];
 214                 *buffer++ = buf[pos++];
 215                 *buffer++ = buf[pos++];
 216         } else {
 217                 pr_debug("DPRAM32 Read failed\n");
 218                 *buffer++ = 0;
 219                 *buffer++ = 0;
 220                 *buffer++ = 0;
 221                 *buffer++ = 0;
 222         }
 223
 224         return ret;
 225 }
 226
 227
 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)
 230 {
 231         u16 pos1;
 232         u16 pos2;
 233         u16 i;
 234         u8 buf[32];
 235         u8 resultbuffer[32];
 236         u8 *pdata;
 237         int ret  = 0;
 238
 239         pos1 = (indx / 4) * 4;
 240         pdata = buffer;
 241         ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
 242
 243         if (ret == 0) {
 244                 pos2 = (indx % 4)*4;
 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);
 250         } else {
 251                 pr_debug("DPRAM32 Read failed\n");
 252                 return ret;
 253         }
 254
 255         ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
 256
 257         if (ret == 0) {
 258                 buffer = pdata;
 259                 for (i = 0; i < 16; i++) {
 260                         if (buf[i] != resultbuffer[i])
 261                                 ret = -1;
 262                 }
 263         }
 264
 265         if (ret == -1) {
 266                 ret = ft1000_write_dpram32(ft1000dev, pos1,
 267                                            (u8 *)&tempbuffer[0], 16);
 268                 ret = ft1000_read_dpram32(ft1000dev, pos1,
 269                                           (u8 *)&resultbuffer[0], 16);
 270                 if (ret == 0) {
 271                         buffer = pdata;
 272                         for (i = 0; i < 16; i++) {
 273                                 if (tempbuffer[i] != resultbuffer[i]) {
 274                                         ret = -1;
 275                                         pr_debug("Failed to write\n");
 276                                 }
 277                         }
 278                 }
 279         }
 280
 281         return ret;
 282 }
 283
 284 /* reset or activate the DSP */
 285 static void card_reset_dsp(struct ft1000_usb *ft1000dev, bool value)
 286 {
 287         int status = 0;
 288         u16 tempword;
 289
 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);
 294
 295         if (value) {
 296                 pr_debug("Reset DSP\n");
 297                 status = ft1000_read_register(ft1000dev, &tempword,
 298                                               FT1000_REG_RESET);
 299                 tempword |= DSP_RESET_BIT;
 300                 status = ft1000_write_register(ft1000dev, tempword,
 301                                                FT1000_REG_RESET);
 302         } else {
 303                 pr_debug("Activate DSP\n");
 304                 status = ft1000_read_register(ft1000dev, &tempword,
 305                                               FT1000_REG_RESET);
 306                 tempword |= DSP_ENCRYPTED;
 307                 tempword &= ~DSP_UNENCRYPTED;
 308                 status = ft1000_write_register(ft1000dev, tempword,
 309                                                FT1000_REG_RESET);
 310                 status = ft1000_read_register(ft1000dev, &tempword,
 311                                               FT1000_REG_RESET);
 312                 tempword &= ~EFUSE_MEM_DISABLE;
 313                 tempword &= ~DSP_RESET_BIT;
 314                 status = ft1000_write_register(ft1000dev, tempword,
 315                                                FT1000_REG_RESET);
 316                 status = ft1000_read_register(ft1000dev, &tempword,
 317                                               FT1000_REG_RESET);
 318         }
 319 }
 320
 321 /* send a command to ASIC
 322  *  Parameters:  ft1000_usb  - device structure
 323  *               ptempbuffer - command buffer
 324  *               size - command buffer size
 325  */
 326 int card_send_command(struct ft1000_usb *ft1000dev, void *ptempbuffer,
 327                       int size)
 328 {
 329         int ret;
 330         unsigned short temp;
 331         unsigned char *commandbuf;
 332
 333         pr_debug("enter card_send_command... size=%d\n", size);
 334
 335         ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 336         if (ret)
 337                 return ret;
 338
 339         commandbuf = kmalloc(size + 2, GFP_KERNEL);
 340         if (!commandbuf)
 341                 return -ENOMEM;
 342         memcpy((void *)commandbuf + 2, ptempbuffer, size);
 343
 344         if (temp & 0x0100)
 345                 usleep_range(900, 1100);
 346
 347         /* check for odd word */
 348         size = size + 2;
 349
 350         /* Must force to be 32 bit aligned */
 351         if (size % 4)
 352                 size += 4 - (size % 4);
 353
 354         ret = ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
 355         if (ret)
 356                 return ret;
 357         usleep_range(900, 1100);
 358         ret = ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
 359                                     FT1000_REG_DOORBELL);
 360         if (ret)
 361                 return ret;
 362         usleep_range(900, 1100);
 363
 364         ret = ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 365
 366 #if 0
 367         if ((temp & 0x0100) == 0)
 368                 pr_debug("Message sent\n");
 369 #endif
 370         return ret;
 371 }
 372
 373 /* load or reload the DSP */
 374 int dsp_reload(struct ft1000_usb *ft1000dev)
 375 {
 376         int status;
 377         u16 tempword;
 378         u32 templong;
 379
 380         struct ft1000_info *pft1000info;
 381
 382         pft1000info = netdev_priv(ft1000dev->net);
 383
 384         pft1000info->CardReady = 0;
 385
 386         /* Program Interrupt Mask register */
 387         status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
 388
 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);
 392         msleep(1000);
 393         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 394         pr_debug("Reset Register = 0x%x\n", tempword);
 395
 396         /* Toggle DSP reset */
 397         card_reset_dsp(ft1000dev, 1);
 398         msleep(1000);
 399         card_reset_dsp(ft1000dev, 0);
 400         msleep(1000);
 401
 402         status = ft1000_write_register(ft1000dev, HOST_INTF_BE,
 403                                        FT1000_REG_SUP_CTRL);
 404
 405         /* Let's check for FEFE */
 406         status =
 407                 ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
 408                                     (u8 *)&templong, 4);
 409         pr_debug("templong (fefe) = 0x%8x\n", templong);
 410
 411         /* call codeloader */
 412         status = scram_dnldr(ft1000dev, pFileStart, FileLength);
 413
 414         if (status != 0)
 415                 return -EIO;
 416
 417         msleep(1000);
 418
 419         return 0;
 420 }
 421
 422 /* call the Card Service function to reset the ASIC. */
 423 static void ft1000_reset_asic(struct net_device *dev)
 424 {
 425         struct ft1000_info *info = netdev_priv(dev);
 426         struct ft1000_usb *ft1000dev = info->priv;
 427         u16 tempword;
 428
 429         /* Let's use the register provided by the Magnemite ASIC to reset the
 430          * ASIC and DSP.
 431          */
 432         ft1000_write_register(ft1000dev, DSP_RESET_BIT | ASIC_RESET_BIT,
 433                               FT1000_REG_RESET);
 434
 435         mdelay(1);
 436
 437         /* set watermark to -1 in order to not generate an interrupt */
 438         ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
 439
 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);
 446 }
 447
 448 static int ft1000_reset_card(struct net_device *dev)
 449 {
 450         struct ft1000_info *info = netdev_priv(dev);
 451         struct ft1000_usb *ft1000dev = info->priv;
 452         u16 tempword;
 453         struct prov_record *ptr;
 454         struct prov_record *tmp;
 455
 456         ft1000dev->fCondResetPend = true;
 457         info->CardReady = 0;
 458         ft1000dev->fProvComplete = false;
 459
 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);
 465                 kfree(ptr);
 466         }
 467
 468         pr_debug("reset asic\n");
 469         ft1000_reset_asic(dev);
 470
 471         pr_debug("call dsp_reload\n");
 472         dsp_reload(ft1000dev);
 473
 474         pr_debug("dsp reload successful\n");
 475
 476         mdelay(10);
 477
 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);
 484
 485         info->CardReady = 1;
 486
 487         ft1000dev->fCondResetPend = false;
 488
 489         return TRUE;
 490 }
 491
 492 /* callback function when a urb is transmitted */
 493 static void ft1000_usb_transmit_complete(struct urb *urb)
 494 {
 495
 496         struct ft1000_usb *ft1000dev = urb->context;
 497
 498         if (urb->status)
 499                 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
 500
 501         netif_wake_queue(ft1000dev->net);
 502 }
 503
 504 /* take an ethernet packet and convert it to a Flarion
 505  *  packet prior to sending it to the ASIC Downlink FIFO.
 506  */
 507 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 *packet, u16 len)
 508 {
 509         struct ft1000_info *pInfo = netdev_priv(netdev);
 510         struct ft1000_usb *pFt1000Dev = pInfo->priv;
 511
 512         int count, ret;
 513         u8 *t;
 514         struct pseudo_hdr hdr;
 515
 516         if (!pInfo->CardReady) {
 517                 pr_debug("Card Not Ready\n");
 518                 return -ENODEV;
 519         }
 520
 521         count = sizeof(struct pseudo_hdr) + len;
 522         if (count > MAX_BUF_SIZE) {
 523                 pr_debug("Message Size Overflow! size = %d\n", count);
 524                 return -EINVAL;
 525         }
 526
 527         if (count % 4)
 528                 count = count + (4 - (count % 4));
 529
 530         memset(&hdr, 0, sizeof(struct pseudo_hdr));
 531
 532         hdr.length = ntohs(count);
 533         hdr.source = 0x10;
 534         hdr.destination = 0x20;
 535         hdr.portdest = 0x20;
 536         hdr.portsrc = 0x10;
 537         hdr.sh_str_id = 0x91;
 538         hdr.control = 0x00;
 539
 540         hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
 541                 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
 542
 543         memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
 544         memcpy(&pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)], packet, len);
 545
 546         netif_stop_queue(netdev);
 547
 548         usb_fill_bulk_urb(pFt1000Dev->tx_urb,
 549                           pFt1000Dev->dev,
 550                           usb_sndbulkpipe(pFt1000Dev->dev,
 551                                           pFt1000Dev->bulk_out_endpointAddr),
 552                           pFt1000Dev->tx_buf, count,
 553                           ft1000_usb_transmit_complete, pFt1000Dev);
 554
 555         t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
 556
 557         ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
 558
 559         if (ret) {
 560                 pr_debug("failed tx_urb %d\n", ret);
 561                 return ret;
 562         }
 563         pInfo->stats.tx_packets++;
 564         pInfo->stats.tx_bytes += (len + 14);
 565
 566         return 0;
 567 }
 568
 569 /* transmit an ethernet packet
 570  *  Parameters:  skb - socket buffer to be sent
 571  *               dev - network device
 572  */
 573 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
 574 {
 575         struct ft1000_info *pInfo = netdev_priv(dev);
 576         struct ft1000_usb *pFt1000Dev = pInfo->priv;
 577         u8 *pdata;
 578         int maxlen, pipe;
 579
 580         if (skb == NULL) {
 581                 pr_debug("skb == NULL!!!\n");
 582                 return NETDEV_TX_OK;
 583         }
 584
 585         if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
 586                 pr_debug("network driver is closed, return\n");
 587                 goto err;
 588         }
 589
 590         pipe = usb_sndbulkpipe(pFt1000Dev->dev,
 591                                pFt1000Dev->bulk_out_endpointAddr);
 592         maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
 593
 594         pdata = (u8 *)skb->data;
 595
 596         if (pInfo->mediastate == 0) {
 597                 /* Drop packet is mediastate is down */
 598                 pr_debug("mediastate is down\n");
 599                 goto err;
 600         }
 601
 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");
 605                 goto err;
 606         }
 607
 608         ft1000_copy_down_pkt(dev, pdata + ENET_HEADER_SIZE - 2,
 609                              skb->len - ENET_HEADER_SIZE + 2);
 610
 611 err:
 612         dev_kfree_skb(skb);
 613
 614         return NETDEV_TX_OK;
 615 }
 616
 617 /* open the network driver */
 618 static int ft1000_open(struct net_device *dev)
 619 {
 620         struct ft1000_info *pInfo = netdev_priv(dev);
 621         struct ft1000_usb *pFt1000Dev = pInfo->priv;
 622         struct timeval tv;
 623
 624         pr_debug("ft1000_open is called for card %d\n", pFt1000Dev->CardNumber);
 625
 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;
 633
 634         netif_start_queue(dev);
 635
 636         netif_carrier_on(dev);
 637
 638         return ft1000_submit_rx_urb(pInfo);
 639 }
 640
 641 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
 642 {
 643         struct ft1000_info *info = netdev_priv(dev);
 644
 645         return &(info->stats);
 646 }
 647
 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,
 653 };
 654
 655 /* initialize the network device */
 656 static int ft1000_reset(void *dev)
 657 {
 658         ft1000_reset_card(dev);
 659         return 0;
 660 }
 661
 662 int init_ft1000_netdev(struct ft1000_usb *ft1000dev)
 663 {
 664         struct net_device *netdev;
 665         struct ft1000_info *pInfo = NULL;
 666         struct dpram_blk *pdpram_blk;
 667         int i, ret_val;
 668         struct list_head *cur, *tmp;
 669         char card_nr[2];
 670         u8 gCardIndex = 0;
 671
 672         netdev = alloc_etherdev(sizeof(struct ft1000_info));
 673         if (!netdev) {
 674                 pr_debug("can not allocate network device\n");
 675                 return -ENOMEM;
 676         }
 677
 678         pInfo = netdev_priv(netdev);
 679
 680         memset(pInfo, 0, sizeof(struct ft1000_info));
 681
 682         dev_alloc_name(netdev, netdev->name);
 683
 684         pr_debug("network device name is %s\n", netdev->name);
 685
 686         if (strncmp(netdev->name, "eth", 3) == 0) {
 687                 card_nr[0] = netdev->name[3];
 688                 card_nr[1] = '\0';
 689                 ret_val = kstrtou8(card_nr, 10, &gCardIndex);
 690                 if (ret_val) {
 691                         netdev_err(ft1000dev->net, "Can't parse netdev\n");
 692                         goto err_net;
 693                 }
 694
 695                 ft1000dev->CardNumber = gCardIndex;
 696                 pr_debug("card number = %d\n", ft1000dev->CardNumber);
 697         } else {
 698                 netdev_err(ft1000dev->net, "ft1000: Invalid device name\n");
 699                 ret_val = -ENXIO;
 700                 goto err_net;
 701         }
 702
 703         memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
 704
 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;
 711         pInfo->fifo_cnt = 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));
 723
 724         INIT_LIST_HEAD(&pInfo->prov_list);
 725
 726         INIT_LIST_HEAD(&ft1000dev->nodes.list);
 727
 728         netdev->netdev_ops = &ftnet_ops;
 729
 730         ft1000dev->net = netdev;
 731
 732         pr_debug("Initialize free_buff_lock and freercvpool\n");
 733         spin_lock_init(&free_buff_lock);
 734
 735         /* initialize a list of buffers to be use for queuing
 736          * up receive command data
 737          */
 738         INIT_LIST_HEAD(&freercvpool);
 739
 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) {
 745                         ret_val = -ENOMEM;
 746                         goto err_free;
 747                 }
 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) {
 751                         ret_val = -ENOMEM;
 752                         kfree(pdpram_blk);
 753                         goto err_free;
 754                 }
 755                 /* link provisioning data */
 756                 list_add_tail(&pdpram_blk->list, &freercvpool);
 757         }
 758         numofmsgbuf = NUM_OF_FREE_BUFFERS;
 759
 760         return 0;
 761
 762 err_free:
 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);
 767                 kfree(pdpram_blk);
 768         }
 769 err_net:
 770         free_netdev(netdev);
 771         return ret_val;
 772 }
 773
 774 /* register the network driver */
 775 int reg_ft1000_netdev(struct ft1000_usb *ft1000dev,
 776                       struct usb_interface *intf)
 777 {
 778         struct net_device *netdev;
 779         struct ft1000_info *pInfo;
 780         int rc;
 781
 782         netdev = ft1000dev->net;
 783         pInfo = netdev_priv(ft1000dev->net);
 784
 785         ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
 786
 787         usb_set_intfdata(intf, pInfo);
 788         SET_NETDEV_DEV(netdev, &intf->dev);
 789
 790         rc = register_netdev(netdev);
 791         if (rc) {
 792                 pr_debug("could not register network device\n");
 793                 free_netdev(netdev);
 794                 return rc;
 795         }
 796
 797         ft1000_create_dev(ft1000dev);
 798
 799         pInfo->CardReady = 1;
 800
 801         return 0;
 802 }
 803
 804 /* take a packet from the FIFO up link and
 805  *  convert it into an ethernet packet and deliver it to the IP stack
 806  */
 807 static int ft1000_copy_up_pkt(struct urb *urb)
 808 {
 809         struct ft1000_info *info = urb->context;
 810         struct ft1000_usb *ft1000dev = info->priv;
 811         struct net_device *net = ft1000dev->net;
 812
 813         u16 tempword;
 814         u16 len;
 815         u16 lena;
 816         struct sk_buff *skb;
 817         u16 i;
 818         u8 *pbuffer = NULL;
 819         u8 *ptemp = NULL;
 820         u16 *chksum;
 821
 822         if (ft1000dev->status & FT1000_STATUS_CLOSING) {
 823                 pr_debug("network driver is closed, return\n");
 824                 return 0;
 825         }
 826         /* Read length */
 827         len = urb->transfer_buffer_length;
 828         lena = urb->actual_length;
 829
 830         chksum = (u16 *)ft1000dev->rx_buf;
 831
 832         tempword = *chksum++;
 833         for (i = 1; i < 7; i++)
 834                 tempword ^= *chksum++;
 835
 836         if (tempword != *chksum) {
 837                 info->stats.rx_errors++;
 838                 ft1000_submit_rx_urb(info);
 839                 return -1;
 840         }
 841
 842         skb = dev_alloc_skb(len + 12 + 2);
 843
 844         if (skb == NULL) {
 845                 info->stats.rx_errors++;
 846                 ft1000_submit_rx_urb(info);
 847                 return -1;
 848         }
 849
 850         pbuffer = (u8 *)skb_put(skb, len + 12);
 851
 852         /* subtract the number of bytes read already */
 853         ptemp = pbuffer;
 854
 855         /* fake MAC address */
 856         *pbuffer++ = net->dev_addr[0];
 857         *pbuffer++ = net->dev_addr[1];
 858         *pbuffer++ = net->dev_addr[2];
 859         *pbuffer++ = net->dev_addr[3];
 860         *pbuffer++ = net->dev_addr[4];
 861         *pbuffer++ = net->dev_addr[5];
 862         *pbuffer++ = 0x00;
 863         *pbuffer++ = 0x07;
 864         *pbuffer++ = 0x35;
 865         *pbuffer++ = 0xff;
 866         *pbuffer++ = 0xff;
 867         *pbuffer++ = 0xfe;
 868
 869         memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
 870                len - sizeof(struct pseudo_hdr));
 871
 872         skb->dev = net;
 873
 874         skb->protocol = eth_type_trans(skb, net);
 875         skb->ip_summed = CHECKSUM_UNNECESSARY;
 876         netif_rx(skb);
 877
 878         info->stats.rx_packets++;
 879         /* Add on 12 bytes for MAC address which was removed */
 880         info->stats.rx_bytes += (lena + 12);
 881
 882         ft1000_submit_rx_urb(info);
 883
 884         return 0;
 885 }
 886
 887
 888 /* the receiving function of the network driver */
 889 static int ft1000_submit_rx_urb(struct ft1000_info *info)
 890 {
 891         int result;
 892         struct ft1000_usb *pFt1000Dev = info->priv;
 893
 894         if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
 895                 pr_debug("network driver is closed, return\n");
 896                 return -ENODEV;
 897         }
 898
 899         usb_fill_bulk_urb(pFt1000Dev->rx_urb,
 900                           pFt1000Dev->dev,
 901                           usb_rcvbulkpipe(pFt1000Dev->dev,
 902                                           pFt1000Dev->bulk_in_endpointAddr),
 903                           pFt1000Dev->rx_buf, MAX_BUF_SIZE,
 904                           (usb_complete_t)ft1000_copy_up_pkt, info);
 905
 906         result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
 907
 908         if (result) {
 909                 pr_err("submitting rx_urb %d failed\n", result);
 910                 return result;
 911         }
 912
 913         return 0;
 914 }
 915
 916 /* close the network driver */
 917 int ft1000_close(struct net_device *net)
 918 {
 919         struct ft1000_info *pInfo = netdev_priv(net);
 920         struct ft1000_usb *ft1000dev = pInfo->priv;
 921
 922         ft1000dev->status |= FT1000_STATUS_CLOSING;
 923
 924         pr_debug("pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
 925         netif_carrier_off(net);
 926         netif_stop_queue(net);
 927         ft1000dev->status &= ~FT1000_STATUS_CLOSING;
 928
 929         pInfo->ProgConStat = 0xff;
 930
 931         return 0;
 932 }
 933
 934 /* check if the device is presently available on the system. */
 935 static int ft1000_chkcard(struct ft1000_usb *dev)
 936 {
 937         u16 tempword;
 938         int status;
 939
 940         if (dev->fCondResetPend) {
 941                 pr_debug("Card is being reset, return FALSE\n");
 942                 return TRUE;
 943         }
 944         /* Mask register is used to check for device presence since it is never
 945          * set to zero.
 946          */
 947         status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
 948         if (tempword == 0) {
 949                 pr_debug("IMASK = 0 Card not detected\n");
 950                 return FALSE;
 951         }
 952         /* The system will return the value of 0xffff for the version register
 953          * if the device is not present.
 954          */
 955         status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
 956         if (tempword != 0x1b01) {
 957                 dev->status |= FT1000_STATUS_CLOSING;
 958                 pr_debug("Version = 0xffff Card not detected\n");
 959                 return FALSE;
 960         }
 961         return TRUE;
 962 }
 963
 964 /* read a message from the dpram area.
 965  *  Input:
 966  *    dev - network device structure
 967  *    pbuffer - caller supply address to buffer
 968  */
 969 static bool ft1000_receive_cmd(struct ft1000_usb *dev, u16 *pbuffer,
 970                                int maxsz)
 971 {
 972         u16 size;
 973         int ret;
 974         u16 *ppseudohdr;
 975         int i;
 976         u16 tempword;
 977
 978         ret =
 979                 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size,
 980                                     FT1000_MAG_PH_LEN_INDX);
 981         size = ntohs(size) + PSEUDOSZ;
 982         if (size > maxsz) {
 983                 pr_debug("Invalid command length = %d\n", size);
 984                 return FALSE;
 985         }
 986         ppseudohdr = (u16 *)pbuffer;
 987         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
 988                               FT1000_REG_DPRAM_ADDR);
 989         ret =
 990                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
 991         pbuffer++;
 992         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
 993                               FT1000_REG_DPRAM_ADDR);
 994         for (i = 0; i <= (size >> 2); i++) {
 995                 ret =
 996                         ft1000_read_register(dev, pbuffer,
 997                                              FT1000_REG_MAG_DPDATAL);
 998                 pbuffer++;
 999                 ret =
1000                         ft1000_read_register(dev, pbuffer,
1001                                              FT1000_REG_MAG_DPDATAH);
1002                 pbuffer++;
1003         }
1004         /* copy odd aligned word */
1005         ret =
1006                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1007
1008         pbuffer++;
1009         ret =
1010                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1011
1012         pbuffer++;
1013         if (size & 0x0001) {
1014                 /* copy odd byte from fifo */
1015                 ret =
1016                         ft1000_read_register(dev, &tempword,
1017                                              FT1000_REG_DPRAM_DATA);
1018                 *pbuffer = ntohs(tempword);
1019         }
1020         /* Check if pseudo header checksum is good
1021          * Calculate pseudo header checksum
1022          */
1023         tempword = *ppseudohdr++;
1024         for (i = 1; i < 7; i++)
1025                 tempword ^= *ppseudohdr++;
1026
1027         if (tempword != *ppseudohdr)
1028                 return FALSE;
1029
1030         return TRUE;
1031 }
1032
1033 static int ft1000_dsp_prov(void *arg)
1034 {
1035         struct ft1000_usb *dev = (struct ft1000_usb *)arg;
1036         struct ft1000_info *info = netdev_priv(dev->net);
1037         u16 tempword;
1038         u16 len;
1039         u16 i = 0;
1040         struct prov_record *ptr;
1041         struct pseudo_hdr *ppseudo_hdr;
1042         u16 *pmsg;
1043         int status;
1044         u16 TempShortBuf[256];
1045
1046         while (list_empty(&info->prov_list) == 0) {
1047                 pr_debug("DSP Provisioning List Entry\n");
1048
1049                 /* Check if doorbell is available */
1050                 pr_debug("check if doorbell is cleared\n");
1051                 status = ft1000_read_register(dev, &tempword,
1052                                               FT1000_REG_DOORBELL);
1053                 if (status) {
1054                         pr_debug("ft1000_read_register error\n");
1055                         break;
1056                 }
1057
1058                 while (tempword & FT1000_DB_DPRAM_TX) {
1059                         mdelay(10);
1060                         i++;
1061                         if (i == 10) {
1062                                 pr_debug("message drop\n");
1063                                 return -1;
1064                         }
1065                         ft1000_read_register(dev, &tempword,
1066                                              FT1000_REG_DOORBELL);
1067                 }
1068
1069                 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1070                         pr_debug("*** Provision Data Sent to DSP\n");
1071
1072                         /* Send provisioning data */
1073                         ptr = list_entry(info->prov_list.next,
1074                                          struct prov_record, list);
1075                         len = *(u16 *)ptr->pprov_data;
1076                         len = htons(len);
1077                         len += PSEUDOSZ;
1078
1079                         pmsg = (u16 *)ptr->pprov_data;
1080                         ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1081                         /* Insert slow queue sequence number */
1082                         ppseudo_hdr->seq_num = info->squeseqnum++;
1083                         ppseudo_hdr->portsrc = 0;
1084                         /* Calculate new checksum */
1085                         ppseudo_hdr->checksum = *pmsg++;
1086                         for (i = 1; i < 7; i++)
1087                                 ppseudo_hdr->checksum ^= *pmsg++;
1088
1089                         TempShortBuf[0] = 0;
1090                         TempShortBuf[1] = htons(len);
1091                         memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1092
1093                         status =
1094                                 ft1000_write_dpram32(dev, 0,
1095                                                      (u8 *)&TempShortBuf[0],
1096                                                      (unsigned short)(len + 2));
1097                         status =
1098                                 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1099                                                       FT1000_REG_DOORBELL);
1100
1101                         list_del(&ptr->list);
1102                         kfree(ptr->pprov_data);
1103                         kfree(ptr);
1104                 }
1105                 usleep_range(9000, 11000);
1106         }
1107
1108         pr_debug("DSP Provisioning List Entry finished\n");
1109
1110         msleep(100);
1111
1112         dev->fProvComplete = true;
1113         info->CardReady = 1;
1114
1115         return 0;
1116 }
1117
1118 static int ft1000_proc_drvmsg(struct ft1000_usb *dev, u16 size)
1119 {
1120         struct ft1000_info *info = netdev_priv(dev->net);
1121         u16 msgtype;
1122         u16 tempword;
1123         struct media_msg *pmediamsg;
1124         struct dsp_init_msg *pdspinitmsg;
1125         struct drv_msg *pdrvmsg;
1126         u16 i;
1127         struct pseudo_hdr *ppseudo_hdr;
1128         u16 *pmsg;
1129         int status;
1130         union {
1131                 u8 byte[2];
1132                 u16 wrd;
1133         } convert;
1134
1135         char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1136
1137         if (!cmdbuffer)
1138                 return -ENOMEM;
1139
1140         status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1141
1142 #ifdef JDEBUG
1143         print_hex_dump_debug("cmdbuffer: ", HEX_DUMP_OFFSET, 16, 1,
1144                              cmdbuffer, size, true);
1145 #endif
1146         pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1147         msgtype = ntohs(pdrvmsg->type);
1148         pr_debug("Command message type = 0x%x\n", msgtype);
1149         switch (msgtype) {
1150         case MEDIA_STATE:{
1151                 pr_debug("Command message type = MEDIA_STATE\n");
1152                 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1153                 if (info->ProgConStat != 0xFF) {
1154                         if (pmediamsg->state) {
1155                                 pr_debug("Media is up\n");
1156                                 if (info->mediastate == 0) {
1157                                         if (dev->NetDevRegDone)
1158                                                 netif_wake_queue(dev->net);
1159                                         info->mediastate = 1;
1160                                 }
1161                         } else {
1162                                 pr_debug("Media is down\n");
1163                                 if (info->mediastate == 1) {
1164                                         info->mediastate = 0;
1165                                         if (dev->NetDevRegDone)
1166                                                 info->ConTm = 0;
1167                                 }
1168                         }
1169                 } else {
1170                         pr_debug("Media is down\n");
1171                         if (info->mediastate == 1) {
1172                                 info->mediastate = 0;
1173                                 info->ConTm = 0;
1174                         }
1175                 }
1176                 break;
1177         }
1178         case DSP_INIT_MSG:{
1179                 pr_debug("Command message type = DSP_INIT_MSG\n");
1180                 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1181                 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1182                 pr_debug("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1183                          info->DspVer[0], info->DspVer[1], info->DspVer[2],
1184                          info->DspVer[3]);
1185                 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1186                        HWSERNUMSZ);
1187                 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1188                 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1189                 pr_debug("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1190                          info->eui64[0], info->eui64[1], info->eui64[2],
1191                          info->eui64[3], info->eui64[4], info->eui64[5],
1192                          info->eui64[6], info->eui64[7]);
1193                 dev->net->dev_addr[0] = info->eui64[0];
1194                 dev->net->dev_addr[1] = info->eui64[1];
1195                 dev->net->dev_addr[2] = info->eui64[2];
1196                 dev->net->dev_addr[3] = info->eui64[5];
1197                 dev->net->dev_addr[4] = info->eui64[6];
1198                 dev->net->dev_addr[5] = info->eui64[7];
1199
1200                 if (ntohs(pdspinitmsg->length) ==
1201                     (sizeof(struct dsp_init_msg) - 20)) {
1202                         memcpy(info->ProductMode, pdspinitmsg->ProductMode,
1203                                MODESZ);
1204                         memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1205                         memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1206                                CALDATESZ);
1207                         pr_debug("RFCalVer = 0x%2x 0x%2x\n",
1208                                  info->RfCalVer[0], info->RfCalVer[1]);
1209                 }
1210                 break;
1211         }
1212         case DSP_PROVISION:{
1213                 pr_debug("Command message type = DSP_PROVISION\n");
1214
1215                 /* kick off dspprov routine to start provisioning
1216                  * Send provisioning data to DSP
1217                  */
1218                 if (list_empty(&info->prov_list) == 0) {
1219                         dev->fProvComplete = false;
1220                         status = ft1000_dsp_prov(dev);
1221                         if (status != 0)
1222                                 goto out;
1223                 } else {
1224                         dev->fProvComplete = true;
1225                         status = ft1000_write_register(dev, FT1000_DB_HB,
1226                                                        FT1000_REG_DOORBELL);
1227                         pr_debug("No more DSP provisioning data in dsp image\n");
1228                 }
1229                 pr_debug("DSP PROVISION is done\n");
1230                 break;
1231         }
1232         case DSP_STORE_INFO:{
1233                 pr_debug("Command message type = DSP_STORE_INFO");
1234                 tempword = ntohs(pdrvmsg->length);
1235                 info->DSPInfoBlklen = tempword;
1236                 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1237                         pmsg = (u16 *)&pdrvmsg->data[0];
1238                         for (i = 0; i < ((tempword + 1) / 2); i++) {
1239                                 pr_debug("dsp info data = 0x%x\n", *pmsg);
1240                                 info->DSPInfoBlk[i + 10] = *pmsg++;
1241                         }
1242                 } else {
1243                         info->DSPInfoBlklen = 0;
1244                 }
1245                 break;
1246         }
1247         case DSP_GET_INFO:{
1248                 pr_debug("Got DSP_GET_INFO\n");
1249                 /* copy dsp info block to dsp */
1250                 dev->DrvMsgPend = 1;
1251                 /* allow any outstanding ioctl to finish */
1252                 mdelay(10);
1253                 status = ft1000_read_register(dev, &tempword,
1254                                               FT1000_REG_DOORBELL);
1255                 if (tempword & FT1000_DB_DPRAM_TX) {
1256                         mdelay(10);
1257                         status = ft1000_read_register(dev, &tempword,
1258                                                       FT1000_REG_DOORBELL);
1259                         if (tempword & FT1000_DB_DPRAM_TX) {
1260                                 mdelay(10);
1261                                 status = ft1000_read_register(dev, &tempword,
1262                                                         FT1000_REG_DOORBELL);
1263                                 if (tempword & FT1000_DB_DPRAM_TX)
1264                                         break;
1265                         }
1266                 }
1267                 /* Put message into Slow Queue Form Pseudo header */
1268                 pmsg = (u16 *)info->DSPInfoBlk;
1269                 *pmsg++ = 0;
1270                 *pmsg++ = htons(info->DSPInfoBlklen + 20 + info->DSPInfoBlklen);
1271                 ppseudo_hdr =
1272                         (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1273                 ppseudo_hdr->length = htons(info->DSPInfoBlklen + 4
1274                                             + info->DSPInfoBlklen);
1275                 ppseudo_hdr->source = 0x10;
1276                 ppseudo_hdr->destination = 0x20;
1277                 ppseudo_hdr->portdest = 0;
1278                 ppseudo_hdr->portsrc = 0;
1279                 ppseudo_hdr->sh_str_id = 0;
1280                 ppseudo_hdr->control = 0;
1281                 ppseudo_hdr->rsvd1 = 0;
1282                 ppseudo_hdr->rsvd2 = 0;
1283                 ppseudo_hdr->qos_class = 0;
1284                 /* Insert slow queue sequence number */
1285                 ppseudo_hdr->seq_num = info->squeseqnum++;
1286                 /* Insert application id */
1287                 ppseudo_hdr->portsrc = 0;
1288                 /* Calculate new checksum */
1289                 ppseudo_hdr->checksum = *pmsg++;
1290                 for (i = 1; i < 7; i++)
1291                         ppseudo_hdr->checksum ^= *pmsg++;
1292
1293                 info->DSPInfoBlk[10] = 0x7200;
1294                 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1295                 status = ft1000_write_dpram32(dev, 0,
1296                                 (u8 *)&info->DSPInfoBlk[0],
1297                                 (unsigned short)(info->DSPInfoBlklen + 22));
1298                 status = ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1299                                                FT1000_REG_DOORBELL);
1300                 dev->DrvMsgPend = 0;
1301                 break;
1302         }
1303         case GET_DRV_ERR_RPT_MSG:{
1304                 pr_debug("Got GET_DRV_ERR_RPT_MSG\n");
1305                 /* copy driver error message to dsp */
1306                 dev->DrvMsgPend = 1;
1307                 /* allow any outstanding ioctl to finish */
1308                 mdelay(10);
1309                 status = ft1000_read_register(dev, &tempword,
1310                                               FT1000_REG_DOORBELL);
1311                 if (tempword & FT1000_DB_DPRAM_TX) {
1312                         mdelay(10);
1313                         status = ft1000_read_register(dev, &tempword,
1314                                                       FT1000_REG_DOORBELL);
1315                         if (tempword & FT1000_DB_DPRAM_TX)
1316                                 mdelay(10);
1317                 }
1318                 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1319                         /* Put message into Slow Queue Form Pseudo header */
1320                         pmsg = (u16 *)&tempbuffer[0];
1321                         ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1322                         ppseudo_hdr->length = htons(0x0012);
1323                         ppseudo_hdr->source = 0x10;
1324                         ppseudo_hdr->destination = 0x20;
1325                         ppseudo_hdr->portdest = 0;
1326                         ppseudo_hdr->portsrc = 0;
1327                         ppseudo_hdr->sh_str_id = 0;
1328                         ppseudo_hdr->control = 0;
1329                         ppseudo_hdr->rsvd1 = 0;
1330                         ppseudo_hdr->rsvd2 = 0;
1331                         ppseudo_hdr->qos_class = 0;
1332                         /* Insert slow queue sequence number */
1333                         ppseudo_hdr->seq_num = info->squeseqnum++;
1334                         /* Insert application id */
1335                         ppseudo_hdr->portsrc = 0;
1336                         /* Calculate new checksum */
1337                         ppseudo_hdr->checksum = *pmsg++;
1338                         for (i = 1; i < 7; i++)
1339                                 ppseudo_hdr->checksum ^= *pmsg++;
1340
1341                         pmsg = (u16 *)&tempbuffer[16];
1342                         *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1343                         *pmsg++ = htons(0x000e);
1344                         *pmsg++ = htons(info->DSP_TIME[0]);
1345                         *pmsg++ = htons(info->DSP_TIME[1]);
1346                         *pmsg++ = htons(info->DSP_TIME[2]);
1347                         *pmsg++ = htons(info->DSP_TIME[3]);
1348                         convert.byte[0] = info->DspVer[0];
1349                         convert.byte[1] = info->DspVer[1];
1350                         *pmsg++ = convert.wrd;
1351                         convert.byte[0] = info->DspVer[2];
1352                         convert.byte[1] = info->DspVer[3];
1353                         *pmsg++ = convert.wrd;
1354                         *pmsg++ = htons(info->DrvErrNum);
1355
1356                         status = card_send_command(dev,
1357                                         (unsigned char *)&tempbuffer[0],
1358                                         (u16)(0x0012 + PSEUDOSZ));
1359                         if (status)
1360                                 goto out;
1361                         info->DrvErrNum = 0;
1362                 }
1363                 dev->DrvMsgPend = 0;
1364                 break;
1365         }
1366         default:
1367                 break;
1368         }
1369
1370         status = 0;
1371 out:
1372         kfree(cmdbuffer);
1373         return status;
1374 }
1375
1376 /* Check which application has registered for dsp broadcast messages */
1377 static int dsp_broadcast_msg_id(struct ft1000_usb *dev)
1378 {
1379         struct dpram_blk *pdpram_blk;
1380         unsigned long flags;
1381         int i;
1382
1383         for (i = 0; i < MAX_NUM_APP; i++) {
1384                 if ((dev->app_info[i].DspBCMsgFlag)
1385                     && (dev->app_info[i].fileobject)
1386                     && (dev->app_info[i].NumOfMsg
1387                         < MAX_MSG_LIMIT)) {
1388                         pdpram_blk = ft1000_get_buffer(&freercvpool);
1389                         if (pdpram_blk == NULL) {
1390                                 pr_debug("Out of memory in free receive command pool\n");
1391                                 dev->app_info[i].nRxMsgMiss++;
1392                                 return -1;
1393                         }
1394                         if (ft1000_receive_cmd(dev, pdpram_blk->pbuffer,
1395                                                MAX_CMD_SQSIZE)) {
1396                                 /* Put message into the
1397                                  * appropriate application block
1398                                  */
1399                                 dev->app_info[i].nRxMsg++;
1400                                 spin_lock_irqsave(&free_buff_lock, flags);
1401                                 list_add_tail(&pdpram_blk->list,
1402                                               &dev->app_info[i] .app_sqlist);
1403                                 dev->app_info[i].NumOfMsg++;
1404                                 spin_unlock_irqrestore(&free_buff_lock, flags);
1405                                 wake_up_interruptible(&dev->app_info[i]
1406                                                       .wait_dpram_msg);
1407                         } else {
1408                                 dev->app_info[i].nRxMsgMiss++;
1409                                 ft1000_free_buffer(pdpram_blk, &freercvpool);
1410                                 pr_debug("ft1000_get_buffer NULL\n");
1411                                 return -1;
1412                         }
1413                 }
1414         }
1415         return 0;
1416 }
1417
1418 static int handle_misc_portid(struct ft1000_usb *dev)
1419 {
1420         struct dpram_blk *pdpram_blk;
1421         int i;
1422
1423         pdpram_blk = ft1000_get_buffer(&freercvpool);
1424         if (pdpram_blk == NULL) {
1425                 pr_debug("Out of memory in free receive command pool\n");
1426                 return -1;
1427         }
1428         if (!ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE))
1429                 goto exit_failure;
1430
1431         /* Search for correct application block */
1432         for (i = 0; i < MAX_NUM_APP; i++) {
1433                 if (dev->app_info[i].app_id == ((struct pseudo_hdr *)
1434                                                 pdpram_blk->pbuffer)->portdest)
1435                         break;
1436         }
1437         if (i == MAX_NUM_APP) {
1438                 pr_debug("No application matching id = %d\n",
1439                          ((struct pseudo_hdr *)pdpram_blk->pbuffer)->portdest);
1440                 goto exit_failure;
1441         } else if (dev->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1442                 goto exit_failure;
1443         } else {
1444                 dev->app_info[i].nRxMsg++;
1445                 /* Put message into the appropriate application block */
1446                 list_add_tail(&pdpram_blk->list, &dev->app_info[i].app_sqlist);
1447                 dev->app_info[i].NumOfMsg++;
1448         }
1449         return 0;
1450
1451 exit_failure:
1452         ft1000_free_buffer(pdpram_blk, &freercvpool);
1453         return -1;
1454 }
1455
1456 int ft1000_poll(void *dev_id)
1457 {
1458         struct ft1000_usb *dev = (struct ft1000_usb *)dev_id;
1459         struct ft1000_info *info = netdev_priv(dev->net);
1460         u16 tempword;
1461         int status;
1462         u16 size;
1463         int i;
1464         u16 data;
1465         u16 modulo;
1466         u16 portid;
1467
1468         if (ft1000_chkcard(dev) == FALSE) {
1469                 pr_debug("failed\n");
1470                 return -1;
1471         }
1472         status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1473         if (!status) {
1474                 if (tempword & FT1000_DB_DPRAM_RX) {
1475                         status = ft1000_read_dpram16(dev,
1476                                                      0x200, (u8 *)&data, 0);
1477                         size = ntohs(data) + 16 + 2;
1478                         if (size % 4) {
1479                                 modulo = 4 - (size % 4);
1480                                 size = size + modulo;
1481                         }
1482                         status = ft1000_read_dpram16(dev, 0x201,
1483                                                      (u8 *)&portid, 1);
1484                         portid &= 0xff;
1485                         if (size < MAX_CMD_SQSIZE) {
1486                                 switch (portid) {
1487                                 case DRIVERID:
1488                                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1489                                         status = ft1000_proc_drvmsg(dev, size);
1490                                         if (status != 0)
1491                                                 return status;
1492                                         break;
1493                                 case DSPBCMSGID:
1494                                         status = dsp_broadcast_msg_id(dev);
1495                                         break;
1496                                 default:
1497                                         status = handle_misc_portid(dev);
1498                                         break;
1499                                 }
1500                         } else
1501                                 pr_debug("Invalid total length for SlowQ = %d\n",
1502                                          size);
1503                         status = ft1000_write_register(dev,
1504                                                        FT1000_DB_DPRAM_RX,
1505                                                        FT1000_REG_DOORBELL);
1506                 } else if (tempword & FT1000_DSP_ASIC_RESET) {
1507                         /* Let's reset the ASIC from the Host side as well */
1508                         status = ft1000_write_register(dev, ASIC_RESET_BIT,
1509                                                        FT1000_REG_RESET);
1510                         status = ft1000_read_register(dev, &tempword,
1511                                                       FT1000_REG_RESET);
1512                         i = 0;
1513                         while (tempword & ASIC_RESET_BIT) {
1514                                 status = ft1000_read_register(dev, &tempword,
1515                                                               FT1000_REG_RESET);
1516                                 usleep_range(9000, 11000);
1517                                 i++;
1518                                 if (i == 100)
1519                                         break;
1520                         }
1521                         if (i == 100) {
1522                                 pr_debug("Unable to reset ASIC\n");
1523                                 return 0;
1524                         }
1525                         usleep_range(9000, 11000);
1526                         /* Program WMARK register */
1527                         status = ft1000_write_register(dev, 0x600,
1528                                                FT1000_REG_MAG_WATERMARK);
1529                         /* clear ASIC reset doorbell */
1530                         status = ft1000_write_register(dev,
1531                                                        FT1000_DSP_ASIC_RESET,
1532                                                        FT1000_REG_DOORBELL);
1533                         usleep_range(9000, 11000);
1534                 } else if (tempword & FT1000_ASIC_RESET_REQ) {
1535                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1536                         /* clear ASIC reset request from DSP */
1537                         status = ft1000_write_register(dev,
1538                                                        FT1000_ASIC_RESET_REQ,
1539                                                        FT1000_REG_DOORBELL);
1540                         status = ft1000_write_register(dev, HOST_INTF_BE,
1541                                                        FT1000_REG_SUP_CTRL);
1542                         /* copy dsp session record from Adapter block */
1543                         status = ft1000_write_dpram32(dev, 0,
1544                                       (u8 *)&info->DSPSess.Rec[0], 1024);
1545                         status = ft1000_write_register(dev, 0x600,
1546                                                FT1000_REG_MAG_WATERMARK);
1547                         /* ring doorbell to tell DSP that
1548                          * ASIC is out of reset
1549                          * */
1550                         status = ft1000_write_register(dev,
1551                                                        FT1000_ASIC_RESET_DSP,
1552                                                        FT1000_REG_DOORBELL);
1553                 } else if (tempword & FT1000_DB_COND_RESET) {
1554                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1555                         if (!dev->fAppMsgPend) {
1556                                 /* Reset ASIC and DSP */
1557                                 status = ft1000_read_dpram16(dev,
1558                                                 FT1000_MAG_DSP_TIMER0,
1559                                                 (u8 *)&info->DSP_TIME[0],
1560                                                 FT1000_MAG_DSP_TIMER0_INDX);
1561                                 status = ft1000_read_dpram16(dev,
1562                                                 FT1000_MAG_DSP_TIMER1,
1563                                                 (u8 *)&info->DSP_TIME[1],
1564                                                 FT1000_MAG_DSP_TIMER1_INDX);
1565                                 status = ft1000_read_dpram16(dev,
1566                                                 FT1000_MAG_DSP_TIMER2,
1567                                                 (u8 *)&info->DSP_TIME[2],
1568                                                 FT1000_MAG_DSP_TIMER2_INDX);
1569                                 status = ft1000_read_dpram16(dev,
1570                                                 FT1000_MAG_DSP_TIMER3,
1571                                                 (u8 *)&info->DSP_TIME[3],
1572                                                 FT1000_MAG_DSP_TIMER3_INDX);
1573                                 info->CardReady = 0;
1574                                 info->DrvErrNum = DSP_CONDRESET_INFO;
1575                                 pr_debug("DSP conditional reset requested\n");
1576                                 info->ft1000_reset(dev->net);
1577                         } else {
1578                                 dev->fProvComplete = false;
1579                                 dev->fCondResetPend = true;
1580                         }
1581                         ft1000_write_register(dev, FT1000_DB_COND_RESET,
1582                                               FT1000_REG_DOORBELL);
1583                 }
1584         }
1585         return 0;
1586 }