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