kernel/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 =
 403                 ft1000_write_register(ft1000dev, HOST_INTF_BE, 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 =
 591                 usb_sndbulkpipe(pFt1000Dev->dev, 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                 pr_debug("No Network buffers available\n");
 846                 info->stats.rx_errors++;
 847                 ft1000_submit_rx_urb(info);
 848                 return -1;
 849         }
 850
 851         pbuffer = (u8 *)skb_put(skb, len + 12);
 852
 853         /* subtract the number of bytes read already */
 854         ptemp = pbuffer;
 855
 856         /* fake MAC address */
 857         *pbuffer++ = net->dev_addr[0];
 858         *pbuffer++ = net->dev_addr[1];
 859         *pbuffer++ = net->dev_addr[2];
 860         *pbuffer++ = net->dev_addr[3];
 861         *pbuffer++ = net->dev_addr[4];
 862         *pbuffer++ = net->dev_addr[5];
 863         *pbuffer++ = 0x00;
 864         *pbuffer++ = 0x07;
 865         *pbuffer++ = 0x35;
 866         *pbuffer++ = 0xff;
 867         *pbuffer++ = 0xff;
 868         *pbuffer++ = 0xfe;
 869
 870         memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
 871                len - sizeof(struct pseudo_hdr));
 872
 873         skb->dev = net;
 874
 875         skb->protocol = eth_type_trans(skb, net);
 876         skb->ip_summed = CHECKSUM_UNNECESSARY;
 877         netif_rx(skb);
 878
 879         info->stats.rx_packets++;
 880         /* Add on 12 bytes for MAC address which was removed */
 881         info->stats.rx_bytes += (lena + 12);
 882
 883         ft1000_submit_rx_urb(info);
 884
 885         return 0;
 886 }
 887
 888
 889 /* the receiving function of the network driver */
 890 static int ft1000_submit_rx_urb(struct ft1000_info *info)
 891 {
 892         int result;
 893         struct ft1000_usb *pFt1000Dev = info->priv;
 894
 895         if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
 896                 pr_debug("network driver is closed, return\n");
 897                 return -ENODEV;
 898         }
 899
 900         usb_fill_bulk_urb(pFt1000Dev->rx_urb,
 901                           pFt1000Dev->dev,
 902                           usb_rcvbulkpipe(pFt1000Dev->dev,
 903                                           pFt1000Dev->bulk_in_endpointAddr),
 904                           pFt1000Dev->rx_buf, MAX_BUF_SIZE,
 905                           (usb_complete_t)ft1000_copy_up_pkt, info);
 906
 907         result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
 908
 909         if (result) {
 910                 pr_err("submitting rx_urb %d failed\n", result);
 911                 return result;
 912         }
 913
 914         return 0;
 915 }
 916
 917 /* close the network driver */
 918 int ft1000_close(struct net_device *net)
 919 {
 920         struct ft1000_info *pInfo = netdev_priv(net);
 921         struct ft1000_usb *ft1000dev = pInfo->priv;
 922
 923         ft1000dev->status |= FT1000_STATUS_CLOSING;
 924
 925         pr_debug("pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
 926         netif_carrier_off(net);
 927         netif_stop_queue(net);
 928         ft1000dev->status &= ~FT1000_STATUS_CLOSING;
 929
 930         pInfo->ProgConStat = 0xff;
 931
 932         return 0;
 933 }
 934
 935 /* check if the device is presently available on the system. */
 936 static int ft1000_chkcard(struct ft1000_usb *dev)
 937 {
 938         u16 tempword;
 939         int status;
 940
 941         if (dev->fCondResetPend) {
 942                 pr_debug("Card is being reset, return FALSE\n");
 943                 return TRUE;
 944         }
 945         /* Mask register is used to check for device presence since it is never
 946          * set to zero.
 947          */
 948         status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
 949         if (tempword == 0) {
 950                 pr_debug("IMASK = 0 Card not detected\n");
 951                 return FALSE;
 952         }
 953         /* The system will return the value of 0xffff for the version register
 954          * if the device is not present.
 955          */
 956         status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
 957         if (tempword != 0x1b01) {
 958                 dev->status |= FT1000_STATUS_CLOSING;
 959                 pr_debug("Version = 0xffff Card not detected\n");
 960                 return FALSE;
 961         }
 962         return TRUE;
 963 }
 964
 965 /* read a message from the dpram area.
 966  *  Input:
 967  *    dev - network device structure
 968  *    pbuffer - caller supply address to buffer
 969  */
 970 static bool ft1000_receive_cmd(struct ft1000_usb *dev, u16 *pbuffer,
 971                                int maxsz)
 972 {
 973         u16 size;
 974         int ret;
 975         u16 *ppseudohdr;
 976         int i;
 977         u16 tempword;
 978
 979         ret =
 980                 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size,
 981                                     FT1000_MAG_PH_LEN_INDX);
 982         size = ntohs(size) + PSEUDOSZ;
 983         if (size > maxsz) {
 984                 pr_debug("Invalid command length = %d\n", size);
 985                 return FALSE;
 986         }
 987         ppseudohdr = (u16 *)pbuffer;
 988         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
 989                               FT1000_REG_DPRAM_ADDR);
 990         ret =
 991                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
 992         pbuffer++;
 993         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
 994                               FT1000_REG_DPRAM_ADDR);
 995         for (i = 0; i <= (size >> 2); i++) {
 996                 ret =
 997                         ft1000_read_register(dev, pbuffer,
 998                                              FT1000_REG_MAG_DPDATAL);
 999                 pbuffer++;
1000                 ret =
1001                         ft1000_read_register(dev, pbuffer,
1002                                              FT1000_REG_MAG_DPDATAH);
1003                 pbuffer++;
1004         }
1005         /* copy odd aligned word */
1006         ret =
1007                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1008
1009         pbuffer++;
1010         ret =
1011                 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1012
1013         pbuffer++;
1014         if (size & 0x0001) {
1015                 /* copy odd byte from fifo */
1016                 ret =
1017                         ft1000_read_register(dev, &tempword,
1018                                              FT1000_REG_DPRAM_DATA);
1019                 *pbuffer = ntohs(tempword);
1020         }
1021         /* Check if pseudo header checksum is good
1022          * Calculate pseudo header checksum
1023          */
1024         tempword = *ppseudohdr++;
1025         for (i = 1; i < 7; i++)
1026                 tempword ^= *ppseudohdr++;
1027
1028         if (tempword != *ppseudohdr)
1029                 return FALSE;
1030
1031         return TRUE;
1032 }
1033
1034 static int ft1000_dsp_prov(void *arg)
1035 {
1036         struct ft1000_usb *dev = (struct ft1000_usb *)arg;
1037         struct ft1000_info *info = netdev_priv(dev->net);
1038         u16 tempword;
1039         u16 len;
1040         u16 i = 0;
1041         struct prov_record *ptr;
1042         struct pseudo_hdr *ppseudo_hdr;
1043         u16 *pmsg;
1044         int status;
1045         u16 TempShortBuf[256];
1046
1047         while (list_empty(&info->prov_list) == 0) {
1048                 pr_debug("DSP Provisioning List Entry\n");
1049
1050                 /* Check if doorbell is available */
1051                 pr_debug("check if doorbell is cleared\n");
1052                 status =
1053                         ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1054                 if (status) {
1055                         pr_debug("ft1000_read_register error\n");
1056                         break;
1057                 }
1058
1059                 while (tempword & FT1000_DB_DPRAM_TX) {
1060                         mdelay(10);
1061                         i++;
1062                         if (i == 10) {
1063                                 pr_debug("message drop\n");
1064                                 return -1;
1065                         }
1066                         ft1000_read_register(dev, &tempword,
1067                                              FT1000_REG_DOORBELL);
1068                 }
1069
1070                 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1071                         pr_debug("*** Provision Data Sent to DSP\n");
1072
1073                         /* Send provisioning data */
1074                         ptr =
1075                                 list_entry(info->prov_list.next, struct prov_record,
1076                                            list);
1077                         len = *(u16 *)ptr->pprov_data;
1078                         len = htons(len);
1079                         len += PSEUDOSZ;
1080
1081                         pmsg = (u16 *)ptr->pprov_data;
1082                         ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1083                         /* Insert slow queue sequence number */
1084                         ppseudo_hdr->seq_num = info->squeseqnum++;
1085                         ppseudo_hdr->portsrc = 0;
1086                         /* Calculate new checksum */
1087                         ppseudo_hdr->checksum = *pmsg++;
1088                         for (i = 1; i < 7; i++)
1089                                 ppseudo_hdr->checksum ^= *pmsg++;
1090
1091                         TempShortBuf[0] = 0;
1092                         TempShortBuf[1] = htons(len);
1093                         memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1094
1095                         status =
1096                                 ft1000_write_dpram32(dev, 0,
1097                                                      (u8 *)&TempShortBuf[0],
1098                                                      (unsigned short)(len + 2));
1099                         status =
1100                                 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1101                                                       FT1000_REG_DOORBELL);
1102
1103                         list_del(&ptr->list);
1104                         kfree(ptr->pprov_data);
1105                         kfree(ptr);
1106                 }
1107                 usleep_range(9000, 11000);
1108         }
1109
1110         pr_debug("DSP Provisioning List Entry finished\n");
1111
1112         msleep(100);
1113
1114         dev->fProvComplete = true;
1115         info->CardReady = 1;
1116
1117         return 0;
1118 }
1119
1120 static int ft1000_proc_drvmsg(struct ft1000_usb *dev, u16 size)
1121 {
1122         struct ft1000_info *info = netdev_priv(dev->net);
1123         u16 msgtype;
1124         u16 tempword;
1125         struct media_msg *pmediamsg;
1126         struct dsp_init_msg *pdspinitmsg;
1127         struct drv_msg *pdrvmsg;
1128         u16 i;
1129         struct pseudo_hdr *ppseudo_hdr;
1130         u16 *pmsg;
1131         int status;
1132         union {
1133                 u8 byte[2];
1134                 u16 wrd;
1135         } convert;
1136
1137         char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1138
1139         if (!cmdbuffer)
1140                 return -ENOMEM;
1141
1142         status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1143
1144 #ifdef JDEBUG
1145         print_hex_dump_debug("cmdbuffer: ", HEX_DUMP_OFFSET, 16, 1,
1146                              cmdbuffer, size, true);
1147 #endif
1148         pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1149         msgtype = ntohs(pdrvmsg->type);
1150         pr_debug("Command message type = 0x%x\n", msgtype);
1151         switch (msgtype) {
1152         case MEDIA_STATE:{
1153                 pr_debug("Command message type = MEDIA_STATE\n");
1154                 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1155                 if (info->ProgConStat != 0xFF) {
1156                         if (pmediamsg->state) {
1157                                 pr_debug("Media is up\n");
1158                                 if (info->mediastate == 0) {
1159                                         if (dev->NetDevRegDone)
1160                                                 netif_wake_queue(dev->net);
1161                                         info->mediastate = 1;
1162                                 }
1163                         } else {
1164                                 pr_debug("Media is down\n");
1165                                 if (info->mediastate == 1) {
1166                                         info->mediastate = 0;
1167                                         if (dev->NetDevRegDone)
1168                                                 info->ConTm = 0;
1169                                 }
1170                         }
1171                 } else {
1172                         pr_debug("Media is down\n");
1173                         if (info->mediastate == 1) {
1174                                 info->mediastate = 0;
1175                                 info->ConTm = 0;
1176                         }
1177                 }
1178                 break;
1179         }
1180         case DSP_INIT_MSG:{
1181                 pr_debug("Command message type = DSP_INIT_MSG\n");
1182                 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1183                 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1184                 pr_debug("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1185                          info->DspVer[0], info->DspVer[1], info->DspVer[2],
1186                          info->DspVer[3]);
1187                 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1188                        HWSERNUMSZ);
1189                 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1190                 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1191                 pr_debug("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1192                          info->eui64[0], info->eui64[1], info->eui64[2],
1193                          info->eui64[3], info->eui64[4], info->eui64[5],
1194                          info->eui64[6], info->eui64[7]);
1195                 dev->net->dev_addr[0] = info->eui64[0];
1196                 dev->net->dev_addr[1] = info->eui64[1];
1197                 dev->net->dev_addr[2] = info->eui64[2];
1198                 dev->net->dev_addr[3] = info->eui64[5];
1199                 dev->net->dev_addr[4] = info->eui64[6];
1200                 dev->net->dev_addr[5] = info->eui64[7];
1201
1202                 if (ntohs(pdspinitmsg->length) ==
1203                     (sizeof(struct dsp_init_msg) - 20)) {
1204                         memcpy(info->ProductMode, pdspinitmsg->ProductMode,
1205                                MODESZ);
1206                         memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1207                         memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1208                                CALDATESZ);
1209                         pr_debug("RFCalVer = 0x%2x 0x%2x\n",
1210                                  info->RfCalVer[0], info->RfCalVer[1]);
1211                 }
1212                 break;
1213         }
1214         case DSP_PROVISION:{
1215                 pr_debug("Command message type = DSP_PROVISION\n");
1216
1217                 /* kick off dspprov routine to start provisioning
1218                  * Send provisioning data to DSP
1219                  */
1220                 if (list_empty(&info->prov_list) == 0) {
1221                         dev->fProvComplete = false;
1222                         status = ft1000_dsp_prov(dev);
1223                         if (status != 0)
1224                                 goto out;
1225                 } else {
1226                         dev->fProvComplete = true;
1227                         status = ft1000_write_register(dev, FT1000_DB_HB,
1228                                                        FT1000_REG_DOORBELL);
1229                         pr_debug("No more DSP provisioning data in dsp image\n");
1230                 }
1231                 pr_debug("DSP PROVISION is done\n");
1232                 break;
1233         }
1234         case DSP_STORE_INFO:{
1235                 pr_debug("Command message type = DSP_STORE_INFO");
1236                 tempword = ntohs(pdrvmsg->length);
1237                 info->DSPInfoBlklen = tempword;
1238                 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1239                         pmsg = (u16 *)&pdrvmsg->data[0];
1240                         for (i = 0; i < ((tempword + 1) / 2); i++) {
1241                                 pr_debug("dsp info data = 0x%x\n", *pmsg);
1242                                 info->DSPInfoBlk[i + 10] = *pmsg++;
1243                         }
1244                 } else {
1245                         info->DSPInfoBlklen = 0;
1246                 }
1247                 break;
1248         }
1249         case DSP_GET_INFO:{
1250                 pr_debug("Got DSP_GET_INFO\n");
1251                 /* copy dsp info block to dsp */
1252                 dev->DrvMsgPend = 1;
1253                 /* allow any outstanding ioctl to finish */
1254                 mdelay(10);
1255                 status = ft1000_read_register(dev, &tempword,
1256                                               FT1000_REG_DOORBELL);
1257                 if (tempword & FT1000_DB_DPRAM_TX) {
1258                         mdelay(10);
1259                         status = ft1000_read_register(dev, &tempword,
1260                                                       FT1000_REG_DOORBELL);
1261                         if (tempword & FT1000_DB_DPRAM_TX) {
1262                                 mdelay(10);
1263                                 status = ft1000_read_register(dev, &tempword,
1264                                                               FT1000_REG_DOORBELL);
1265                                 if (tempword & FT1000_DB_DPRAM_TX)
1266                                         break;
1267                         }
1268                 }
1269                 /* Put message into Slow Queue Form Pseudo header */
1270                 pmsg = (u16 *)info->DSPInfoBlk;
1271                 *pmsg++ = 0;
1272                 *pmsg++ = htons(info->DSPInfoBlklen + 20 + info->DSPInfoBlklen);
1273                 ppseudo_hdr =
1274                         (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1275                 ppseudo_hdr->length = htons(info->DSPInfoBlklen + 4
1276                                             + info->DSPInfoBlklen);
1277                 ppseudo_hdr->source = 0x10;
1278                 ppseudo_hdr->destination = 0x20;
1279                 ppseudo_hdr->portdest = 0;
1280                 ppseudo_hdr->portsrc = 0;
1281                 ppseudo_hdr->sh_str_id = 0;
1282                 ppseudo_hdr->control = 0;
1283                 ppseudo_hdr->rsvd1 = 0;
1284                 ppseudo_hdr->rsvd2 = 0;
1285                 ppseudo_hdr->qos_class = 0;
1286                 /* Insert slow queue sequence number */
1287                 ppseudo_hdr->seq_num = info->squeseqnum++;
1288                 /* Insert application id */
1289                 ppseudo_hdr->portsrc = 0;
1290                 /* Calculate new checksum */
1291                 ppseudo_hdr->checksum = *pmsg++;
1292                 for (i = 1; i < 7; i++)
1293                         ppseudo_hdr->checksum ^= *pmsg++;
1294
1295                 info->DSPInfoBlk[10] = 0x7200;
1296                 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1297                 status = ft1000_write_dpram32(dev, 0,
1298                                               (u8 *)&info->DSPInfoBlk[0],
1299                                               (unsigned short)(info->DSPInfoBlklen + 22));
1300                 status = ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1301                                                FT1000_REG_DOORBELL);
1302                 dev->DrvMsgPend = 0;
1303                 break;
1304         }
1305         case GET_DRV_ERR_RPT_MSG:{
1306                 pr_debug("Got GET_DRV_ERR_RPT_MSG\n");
1307                 /* copy driver error message to dsp */
1308                 dev->DrvMsgPend = 1;
1309                 /* allow any outstanding ioctl to finish */
1310                 mdelay(10);
1311                 status = ft1000_read_register(dev, &tempword,
1312                                               FT1000_REG_DOORBELL);
1313                 if (tempword & FT1000_DB_DPRAM_TX) {
1314                         mdelay(10);
1315                         status = ft1000_read_register(dev, &tempword,
1316                                                       FT1000_REG_DOORBELL);
1317                         if (tempword & FT1000_DB_DPRAM_TX)
1318                                 mdelay(10);
1319                 }
1320                 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1321                         /* Put message into Slow Queue Form Pseudo header */
1322                         pmsg = (u16 *)&tempbuffer[0];
1323                         ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1324                         ppseudo_hdr->length = htons(0x0012);
1325                         ppseudo_hdr->source = 0x10;
1326                         ppseudo_hdr->destination = 0x20;
1327                         ppseudo_hdr->portdest = 0;
1328                         ppseudo_hdr->portsrc = 0;
1329                         ppseudo_hdr->sh_str_id = 0;
1330                         ppseudo_hdr->control = 0;
1331                         ppseudo_hdr->rsvd1 = 0;
1332                         ppseudo_hdr->rsvd2 = 0;
1333                         ppseudo_hdr->qos_class = 0;
1334                         /* Insert slow queue sequence number */
1335                         ppseudo_hdr->seq_num = info->squeseqnum++;
1336                         /* Insert application id */
1337                         ppseudo_hdr->portsrc = 0;
1338                         /* Calculate new checksum */
1339                         ppseudo_hdr->checksum = *pmsg++;
1340                         for (i = 1; i < 7; i++)
1341                                 ppseudo_hdr->checksum ^= *pmsg++;
1342
1343                         pmsg = (u16 *)&tempbuffer[16];
1344                         *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1345                         *pmsg++ = htons(0x000e);
1346                         *pmsg++ = htons(info->DSP_TIME[0]);
1347                         *pmsg++ = htons(info->DSP_TIME[1]);
1348                         *pmsg++ = htons(info->DSP_TIME[2]);
1349                         *pmsg++ = htons(info->DSP_TIME[3]);
1350                         convert.byte[0] = info->DspVer[0];
1351                         convert.byte[1] = info->DspVer[1];
1352                         *pmsg++ = convert.wrd;
1353                         convert.byte[0] = info->DspVer[2];
1354                         convert.byte[1] = info->DspVer[3];
1355                         *pmsg++ = convert.wrd;
1356                         *pmsg++ = htons(info->DrvErrNum);
1357
1358                         status = card_send_command(dev, (unsigned char *)&tempbuffer[0],
1359                                                    (u16)(0x0012 + PSEUDOSZ));
1360                         if (status)
1361                                 goto out;
1362                         info->DrvErrNum = 0;
1363                 }
1364                 dev->DrvMsgPend = 0;
1365                 break;
1366         }
1367         default:
1368                 break;
1369         }
1370
1371         status = 0;
1372 out:
1373         kfree(cmdbuffer);
1374         return status;
1375 }
1376
1377 /* Check which application has registered for dsp broadcast messages */
1378 static int dsp_broadcast_msg_id(struct ft1000_usb *dev)
1379 {
1380         struct dpram_blk *pdpram_blk;
1381         unsigned long flags;
1382         int i;
1383
1384         for (i = 0; i < MAX_NUM_APP; i++) {
1385                 if ((dev->app_info[i].DspBCMsgFlag)
1386                     && (dev->app_info[i].fileobject)
1387                     && (dev->app_info[i].NumOfMsg
1388                         < MAX_MSG_LIMIT)) {
1389                         pdpram_blk = ft1000_get_buffer(&freercvpool);
1390                         if (pdpram_blk == NULL) {
1391                                 pr_debug("Out of memory in free receive command pool\n");
1392                                 dev->app_info[i].nRxMsgMiss++;
1393                                 return -1;
1394                         }
1395                         if (ft1000_receive_cmd(dev, pdpram_blk->pbuffer,
1396                                                MAX_CMD_SQSIZE)) {
1397                                 /* Put message into the
1398                                  * appropriate application block
1399                                  */
1400                                 dev->app_info[i].nRxMsg++;
1401                                 spin_lock_irqsave(&free_buff_lock, flags);
1402                                 list_add_tail(&pdpram_blk->list,
1403                                               &dev->app_info[i] .app_sqlist);
1404                                 dev->app_info[i].NumOfMsg++;
1405                                 spin_unlock_irqrestore(&free_buff_lock, flags);
1406                                 wake_up_interruptible(&dev->app_info[i]
1407                                                       .wait_dpram_msg);
1408                         } else {
1409                                 dev->app_info[i].nRxMsgMiss++;
1410                                 ft1000_free_buffer(pdpram_blk, &freercvpool);
1411                                 pr_debug("ft1000_get_buffer NULL\n");
1412                                 return -1;
1413                         }
1414                 }
1415         }
1416         return 0;
1417 }
1418
1419 static int handle_misc_portid(struct ft1000_usb *dev)
1420 {
1421         struct dpram_blk *pdpram_blk;
1422         int i;
1423
1424         pdpram_blk = ft1000_get_buffer(&freercvpool);
1425         if (pdpram_blk == NULL) {
1426                 pr_debug("Out of memory in free receive command pool\n");
1427                 return -1;
1428         }
1429         if (!ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE))
1430                 goto exit_failure;
1431
1432         /* Search for correct application block */
1433         for (i = 0; i < MAX_NUM_APP; i++) {
1434                 if (dev->app_info[i].app_id == ((struct pseudo_hdr *)
1435                                                 pdpram_blk->pbuffer)->portdest)
1436                         break;
1437         }
1438         if (i == MAX_NUM_APP) {
1439                 pr_debug("No application matching id = %d\n",
1440                          ((struct pseudo_hdr *)pdpram_blk->pbuffer)->portdest);
1441                 goto exit_failure;
1442         } else if (dev->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1443                 goto exit_failure;
1444         } else {
1445                 dev->app_info[i].nRxMsg++;
1446                 /* Put message into the appropriate application block */
1447                 list_add_tail(&pdpram_blk->list, &dev->app_info[i].app_sqlist);
1448                 dev->app_info[i].NumOfMsg++;
1449         }
1450         return 0;
1451
1452 exit_failure:
1453         ft1000_free_buffer(pdpram_blk, &freercvpool);
1454         return -1;
1455 }
1456
1457 int ft1000_poll(void *dev_id)
1458 {
1459         struct ft1000_usb *dev = (struct ft1000_usb *)dev_id;
1460         struct ft1000_info *info = netdev_priv(dev->net);
1461         u16 tempword;
1462         int status;
1463         u16 size;
1464         int i;
1465         u16 data;
1466         u16 modulo;
1467         u16 portid;
1468
1469         if (ft1000_chkcard(dev) == FALSE) {
1470                 pr_debug("failed\n");
1471                 return -1;
1472         }
1473         status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1474         if (!status) {
1475                 if (tempword & FT1000_DB_DPRAM_RX) {
1476                         status = ft1000_read_dpram16(dev,
1477                                                      0x200, (u8 *)&data, 0);
1478                         size = ntohs(data) + 16 + 2;
1479                         if (size % 4) {
1480                                 modulo = 4 - (size % 4);
1481                                 size = size + modulo;
1482                         }
1483                         status = ft1000_read_dpram16(dev, 0x201,
1484                                                      (u8 *)&portid, 1);
1485                         portid &= 0xff;
1486                         if (size < MAX_CMD_SQSIZE) {
1487                                 switch (portid) {
1488                                 case DRIVERID:
1489                                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1490                                         status = ft1000_proc_drvmsg(dev, size);
1491                                         if (status != 0)
1492                                                 return status;
1493                                         break;
1494                                 case DSPBCMSGID:
1495                                         status = dsp_broadcast_msg_id(dev);
1496                                         break;
1497                                 default:
1498                                         status = handle_misc_portid(dev);
1499                                         break;
1500                                 }
1501                         } else
1502                                 pr_debug("Invalid total length for SlowQ = %d\n",
1503                                          size);
1504                         status = ft1000_write_register(dev,
1505                                                        FT1000_DB_DPRAM_RX,
1506                                                        FT1000_REG_DOORBELL);
1507                 } else if (tempword & FT1000_DSP_ASIC_RESET) {
1508                         /* Let's reset the ASIC from the Host side as well */
1509                         status = ft1000_write_register(dev, ASIC_RESET_BIT,
1510                                                        FT1000_REG_RESET);
1511                         status = ft1000_read_register(dev, &tempword,
1512                                                       FT1000_REG_RESET);
1513                         i = 0;
1514                         while (tempword & ASIC_RESET_BIT) {
1515                                 status = ft1000_read_register(dev, &tempword,
1516                                                               FT1000_REG_RESET);
1517                                 usleep_range(9000, 11000);
1518                                 i++;
1519                                 if (i == 100)
1520                                         break;
1521                         }
1522                         if (i == 100) {
1523                                 pr_debug("Unable to reset ASIC\n");
1524                                 return 0;
1525                         }
1526                         usleep_range(9000, 11000);
1527                         /* Program WMARK register */
1528                         status = ft1000_write_register(dev, 0x600,
1529                                                        FT1000_REG_MAG_WATERMARK);
1530                         /* clear ASIC reset doorbell */
1531                         status = ft1000_write_register(dev,
1532                                                        FT1000_DSP_ASIC_RESET,
1533                                                        FT1000_REG_DOORBELL);
1534                         usleep_range(9000, 11000);
1535                 } else if (tempword & FT1000_ASIC_RESET_REQ) {
1536                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1537                         /* clear ASIC reset request from DSP */
1538                         status = ft1000_write_register(dev,
1539                                                        FT1000_ASIC_RESET_REQ,
1540                                                        FT1000_REG_DOORBELL);
1541                         status = ft1000_write_register(dev, HOST_INTF_BE,
1542                                                        FT1000_REG_SUP_CTRL);
1543                         /* copy dsp session record from Adapter block */
1544                         status = ft1000_write_dpram32(dev, 0,
1545                                                       (u8 *)&info->DSPSess.Rec[0], 1024);
1546                         status = ft1000_write_register(dev, 0x600,
1547                                                        FT1000_REG_MAG_WATERMARK);
1548                         /* ring doorbell to tell DSP that
1549                          * ASIC is out of reset
1550                          * */
1551                         status = ft1000_write_register(dev,
1552                                                        FT1000_ASIC_RESET_DSP,
1553                                                        FT1000_REG_DOORBELL);
1554                 } else if (tempword & FT1000_DB_COND_RESET) {
1555                         pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1556                         if (!dev->fAppMsgPend) {
1557                                 /* Reset ASIC and DSP */
1558                                 status = ft1000_read_dpram16(dev,
1559                                                              FT1000_MAG_DSP_TIMER0,
1560                                                              (u8 *)&info->DSP_TIME[0],
1561                                                              FT1000_MAG_DSP_TIMER0_INDX);
1562                                 status = ft1000_read_dpram16(dev,
1563                                                              FT1000_MAG_DSP_TIMER1,
1564                                                              (u8 *)&info->DSP_TIME[1],
1565                                                              FT1000_MAG_DSP_TIMER1_INDX);
1566                                 status = ft1000_read_dpram16(dev,
1567                                                              FT1000_MAG_DSP_TIMER2,
1568                                                              (u8 *)&info->DSP_TIME[2],
1569                                                              FT1000_MAG_DSP_TIMER2_INDX);
1570                                 status = ft1000_read_dpram16(dev,
1571                                                              FT1000_MAG_DSP_TIMER3,
1572                                                              (u8 *)&info->DSP_TIME[3],
1573                                                              FT1000_MAG_DSP_TIMER3_INDX);
1574                                 info->CardReady = 0;
1575                                 info->DrvErrNum = DSP_CONDRESET_INFO;
1576                                 pr_debug("DSP conditional reset requested\n");
1577                                 info->ft1000_reset(dev->net);
1578                         } else {
1579                                 dev->fProvComplete = false;
1580                                 dev->fCondResetPend = true;
1581                         }
1582                         ft1000_write_register(dev, FT1000_DB_COND_RESET,
1583                                               FT1000_REG_DOORBELL);
1584                 }
1585         }
1586         return 0;
1587 }