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