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

   1 //=====================================================
   2 // CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
   3 //
   4 //
   5 // This file is part of Express Card USB Driver
   6 //
   7 // $Id:
   8 //====================================================
   9 // 20090926; aelias; removed compiler warnings & errors; ubuntu 9.04; 2.6.28-15-generic
  10
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/usb.h>
  17 #include "ft1000_usb.h"
  18 #include <linux/types.h>
  19
  20 #define HARLEY_READ_REGISTER     0x0
  21 #define HARLEY_WRITE_REGISTER    0x01
  22 #define HARLEY_READ_DPRAM_32     0x02
  23 #define HARLEY_READ_DPRAM_LOW    0x03
  24 #define HARLEY_READ_DPRAM_HIGH   0x04
  25 #define HARLEY_WRITE_DPRAM_32    0x05
  26 #define HARLEY_WRITE_DPRAM_LOW   0x06
  27 #define HARLEY_WRITE_DPRAM_HIGH  0x07
  28
  29 #define HARLEY_READ_OPERATION    0xc1
  30 #define HARLEY_WRITE_OPERATION   0x41
  31
  32 //#define JDEBUG
  33
  34 static int ft1000_reset(struct net_device *ft1000dev);
  35 static int ft1000_submit_rx_urb(struct ft1000_info *info);
  36 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
  37 static int ft1000_open (struct net_device *dev);
  38 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
  39 static int ft1000_chkcard (struct ft1000_device *dev);
  40
  41 //Jim
  42
  43 static u8 tempbuffer[1600];
  44
  45 #define MAX_RCV_LOOP   100
  46
  47 //---------------------------------------------------------------------------
  48 // Function:    ft1000_control
  49 //
  50 // Parameters:  ft1000_device  - device structure
  51 //              pipe - usb control message pipe
  52 //              request - control request
  53 //              requesttype - control message request type
  54 //              value - value to be written or 0
  55 //              index - register index
  56 //              data - data buffer to hold the read/write values
  57 //              size - data size
  58 //              timeout - control message time out value
  59 //
  60 // Returns:     STATUS_SUCCESS - success
  61 //              STATUS_FAILURE - failure
  62 //
  63 // Description: This function sends a control message via USB interface synchronously
  64 //
  65 // Notes:
  66 //
  67 //---------------------------------------------------------------------------
  68 static int ft1000_control(struct ft1000_device *ft1000dev, unsigned int pipe,
  69                           u8 request, u8 requesttype, u16 value, u16 index,
  70                           void *data, u16 size, int timeout)
  71 {
  72         u16 ret;
  73
  74         if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
  75                 DEBUG("ft1000dev or ft1000dev->dev == NULL, failure\n");
  76                 return -ENODEV;
  77         }
  78
  79         ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
  80                               value, index, data, size, LARGE_TIMEOUT);
  81
  82         if (ret > 0)
  83                 ret = 0;
  84
  85         return ret;
  86 }
  87
  88 //---------------------------------------------------------------------------
  89 // Function:    ft1000_read_register
  90 //
  91 // Parameters:  ft1000_device  - device structure
  92 //              Data - data buffer to hold the value read
  93 //              nRegIndex - register index
  94 //
  95 // Returns:     STATUS_SUCCESS - success
  96 //              STATUS_FAILURE - failure
  97 //
  98 // Description: This function returns the value in a register
  99 //
 100 // Notes:
 101 //
 102 //---------------------------------------------------------------------------
 103
 104 int ft1000_read_register(struct ft1000_device *ft1000dev, u16* Data,
 105                          u16 nRegIndx)
 106 {
 107         int ret = STATUS_SUCCESS;
 108
 109         ret = ft1000_control(ft1000dev,
 110                              usb_rcvctrlpipe(ft1000dev->dev, 0),
 111                              HARLEY_READ_REGISTER,
 112                              HARLEY_READ_OPERATION,
 113                              0,
 114                              nRegIndx,
 115                              Data,
 116                              2,
 117                              LARGE_TIMEOUT);
 118
 119         return ret;
 120 }
 121
 122 //---------------------------------------------------------------------------
 123 // Function:    ft1000_write_register
 124 //
 125 // Parameters:  ft1000_device  - device structure
 126 //              value - value to write into a register
 127 //              nRegIndex - register index
 128 //
 129 // Returns:     STATUS_SUCCESS - success
 130 //              STATUS_FAILURE - failure
 131 //
 132 // Description: This function writes the value in a register
 133 //
 134 // Notes:
 135 //
 136 //---------------------------------------------------------------------------
 137 int ft1000_write_register(struct ft1000_device *ft1000dev, u16 value,
 138                           u16 nRegIndx)
 139 {
 140         int ret = STATUS_SUCCESS;
 141
 142         ret = ft1000_control(ft1000dev,
 143                              usb_sndctrlpipe(ft1000dev->dev, 0),
 144                              HARLEY_WRITE_REGISTER,
 145                              HARLEY_WRITE_OPERATION,
 146                              value,
 147                              nRegIndx,
 148                              NULL,
 149                              0,
 150                              LARGE_TIMEOUT);
 151
 152         return ret;
 153 }
 154
 155 //---------------------------------------------------------------------------
 156 // Function:    ft1000_read_dpram32
 157 //
 158 // Parameters:  ft1000_device  - device structure
 159 //              indx - starting address to read
 160 //              buffer - data buffer to hold the data read
 161 //              cnt - number of byte read from DPRAM
 162 //
 163 // Returns:     STATUS_SUCCESS - success
 164 //              STATUS_FAILURE - failure
 165 //
 166 // Description: This function read a number of bytes from DPRAM
 167 //
 168 // Notes:
 169 //
 170 //---------------------------------------------------------------------------
 171
 172 int ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u16 cnt)
 173 {
 174     int ret = STATUS_SUCCESS;
 175
 176     //DEBUG("ft1000_read_dpram32: indx: %d  cnt: %d\n", indx, cnt);
 177     ret =ft1000_control(ft1000dev,
 178                          usb_rcvctrlpipe(ft1000dev->dev,0),
 179                          HARLEY_READ_DPRAM_32,                //request --READ_DPRAM_32
 180                          HARLEY_READ_OPERATION,               //requestType
 181                          0,                                   //value
 182                          indx,                                //index
 183                          buffer,                              //data
 184                          cnt,                                 //data size
 185                          LARGE_TIMEOUT );                     //timeout
 186
 187    //DEBUG("ft1000_read_dpram32: ret is  %d \n", ret);
 188
 189    //DEBUG("ft1000_read_dpram32: ret=%d \n", ret);
 190
 191    return ret;
 192
 193 }
 194
 195 //---------------------------------------------------------------------------
 196 // Function:    ft1000_write_dpram32
 197 //
 198 // Parameters:  ft1000_device  - device structure
 199 //              indx - starting address to write the data
 200 //              buffer - data buffer to write into DPRAM
 201 //              cnt - number of bytes to write
 202 //
 203 // Returns:     STATUS_SUCCESS - success
 204 //              STATUS_FAILURE - failure
 205 //
 206 // Description: This function writes into DPRAM a number of bytes
 207 //
 208 // Notes:
 209 //
 210 //---------------------------------------------------------------------------
 211 int ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u16 cnt)
 212 {
 213      int ret = STATUS_SUCCESS;
 214
 215      //DEBUG("ft1000_write_dpram32: indx: %d   buffer: %x cnt: %d\n", indx, buffer, cnt);
 216      if ( cnt % 4)
 217          cnt += cnt - (cnt % 4);
 218
 219      ret = ft1000_control(ft1000dev,
 220                            usb_sndctrlpipe(ft1000dev->dev, 0),
 221                            HARLEY_WRITE_DPRAM_32,              //request -- WRITE_DPRAM_32
 222                            HARLEY_WRITE_OPERATION,             //requestType
 223                            0,                                  //value
 224                            indx,                               //index
 225                            buffer,                             //buffer
 226                            cnt,                                //buffer size
 227                            LARGE_TIMEOUT );
 228
 229     return ret;
 230 }
 231
 232 //---------------------------------------------------------------------------
 233 // Function:    ft1000_read_dpram16
 234 //
 235 // Parameters:  ft1000_device  - device structure
 236 //              indx - starting address to read
 237 //              buffer - data buffer to hold the data read
 238 //              hightlow - high or low 16 bit word
 239 //
 240 // Returns:     STATUS_SUCCESS - success
 241 //              STATUS_FAILURE - failure
 242 //
 243 // Description: This function read 16 bits from DPRAM
 244 //
 245 // Notes:
 246 //
 247 //---------------------------------------------------------------------------
 248 int ft1000_read_dpram16(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer, u8 highlow)
 249 {
 250     int ret = STATUS_SUCCESS;
 251
 252     //DEBUG("ft1000_read_dpram16: indx: %d  hightlow: %d\n", indx, highlow);
 253
 254     u8 request;
 255
 256     if (highlow == 0 )
 257         request = HARLEY_READ_DPRAM_LOW;
 258     else
 259         request = HARLEY_READ_DPRAM_HIGH;
 260
 261     ret = ft1000_control(ft1000dev,
 262                          usb_rcvctrlpipe(ft1000dev->dev,0),
 263                          request,                     //request --READ_DPRAM_H/L
 264                          HARLEY_READ_OPERATION,       //requestType
 265                          0,                           //value
 266                          indx,                        //index
 267                          buffer,                      //data
 268                          2,                           //data size
 269                          LARGE_TIMEOUT );             //timeout
 270
 271    //DEBUG("ft1000_read_dpram16: ret is  %d \n", ret);
 272
 273
 274    //DEBUG("ft1000_read_dpram16: data is  %x \n", *buffer);
 275
 276    return ret;
 277
 278 }
 279
 280 //---------------------------------------------------------------------------
 281 // Function:    ft1000_write_dpram16
 282 //
 283 // Parameters:  ft1000_device  - device structure
 284 //              indx - starting address to write the data
 285 //              value - 16bits value to write
 286 //              hightlow - high or low 16 bit word
 287 //
 288 // Returns:     STATUS_SUCCESS - success
 289 //              STATUS_FAILURE - failure
 290 //
 291 // Description: This function writes into DPRAM a number of bytes
 292 //
 293 // Notes:
 294 //
 295 //---------------------------------------------------------------------------
 296 int ft1000_write_dpram16(struct ft1000_device *ft1000dev, u16 indx, u16 value, u8 highlow)
 297 {
 298      int ret = STATUS_SUCCESS;
 299
 300
 301
 302      //DEBUG("ft1000_write_dpram16: indx: %d  value: %d  highlow: %d\n", indx, value, highlow);
 303
 304      u8 request;
 305
 306
 307      if ( highlow == 0 )
 308          request = HARLEY_WRITE_DPRAM_LOW;
 309      else
 310          request = HARLEY_WRITE_DPRAM_HIGH;
 311
 312      ret = ft1000_control(ft1000dev,
 313                            usb_sndctrlpipe(ft1000dev->dev, 0),
 314                            request,                             //request -- WRITE_DPRAM_H/L
 315                            HARLEY_WRITE_OPERATION,              //requestType
 316                            value,                                   //value
 317                            indx,                                //index
 318                            NULL,                               //buffer
 319                            0,                                   //buffer size
 320                            LARGE_TIMEOUT );
 321
 322     return ret;
 323 }
 324
 325 //---------------------------------------------------------------------------
 326 // Function:    fix_ft1000_read_dpram32
 327 //
 328 // Parameters:  ft1000_device  - device structure
 329 //              indx - starting address to read
 330 //              buffer - data buffer to hold the data read
 331 //
 332 //
 333 // Returns:     STATUS_SUCCESS - success
 334 //              STATUS_FAILURE - failure
 335 //
 336 // Description: This function read DPRAM 4 words at a time
 337 //
 338 // Notes:
 339 //
 340 //---------------------------------------------------------------------------
 341 int fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
 342 {
 343     u8 buf[16];
 344     u16 pos;
 345     int ret = STATUS_SUCCESS;
 346
 347     //DEBUG("fix_ft1000_read_dpram32: indx: %d  \n", indx);
 348     pos = (indx / 4)*4;
 349     ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
 350     if (ret == STATUS_SUCCESS)
 351     {
 352         pos = (indx % 4)*4;
 353         *buffer++ = buf[pos++];
 354         *buffer++ = buf[pos++];
 355         *buffer++ = buf[pos++];
 356         *buffer++ = buf[pos++];
 357     }
 358     else
 359     {
 360         DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
 361         *buffer++ = 0;
 362         *buffer++ = 0;
 363         *buffer++ = 0;
 364         *buffer++ = 0;
 365
 366     }
 367
 368    //DEBUG("fix_ft1000_read_dpram32: data is  %x \n", *buffer);
 369    return ret;
 370
 371 }
 372
 373
 374 //---------------------------------------------------------------------------
 375 // Function:    fix_ft1000_write_dpram32
 376 //
 377 // Parameters:  ft1000_device  - device structure
 378 //              indx - starting address to write
 379 //              buffer - data buffer to write
 380 //
 381 //
 382 // Returns:     STATUS_SUCCESS - success
 383 //              STATUS_FAILURE - failure
 384 //
 385 // Description: This function write to DPRAM 4 words at a time
 386 //
 387 // Notes:
 388 //
 389 //---------------------------------------------------------------------------
 390 int fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
 391 {
 392     u16 pos1;
 393     u16 pos2;
 394     u16 i;
 395     u8 buf[32];
 396     u8 resultbuffer[32];
 397     u8 *pdata;
 398     int ret  = STATUS_SUCCESS;
 399
 400     //DEBUG("fix_ft1000_write_dpram32: Entered:\n");
 401
 402     pos1 = (indx / 4)*4;
 403     pdata = buffer;
 404     ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
 405     if (ret == STATUS_SUCCESS)
 406     {
 407         pos2 = (indx % 4)*4;
 408         buf[pos2++] = *buffer++;
 409         buf[pos2++] = *buffer++;
 410         buf[pos2++] = *buffer++;
 411         buf[pos2++] = *buffer++;
 412         ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
 413     }
 414     else
 415     {
 416         DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
 417
 418         return ret;
 419     }
 420
 421     ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
 422     if (ret == STATUS_SUCCESS)
 423     {
 424         buffer = pdata;
 425         for (i=0; i<16; i++)
 426         {
 427             if (buf[i] != resultbuffer[i]){
 428
 429                 ret = STATUS_FAILURE;
 430             }
 431         }
 432     }
 433
 434     if (ret == STATUS_FAILURE)
 435     {
 436         ret = ft1000_write_dpram32(ft1000dev, pos1, (u8 *)&tempbuffer[0], 16);
 437         ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
 438         if (ret == STATUS_SUCCESS)
 439         {
 440             buffer = pdata;
 441             for (i=0; i<16; i++)
 442             {
 443                 if (tempbuffer[i] != resultbuffer[i])
 444                 {
 445                     ret = STATUS_FAILURE;
 446                     DEBUG("fix_ft1000_write_dpram32 Failed to write\n");
 447                 }
 448             }
 449          }
 450     }
 451
 452     return ret;
 453
 454 }
 455
 456
 457 //------------------------------------------------------------------------
 458 //
 459 //  Function:   card_reset_dsp
 460 //
 461 //  Synopsis:   This function is called to reset or activate the DSP
 462 //
 463 //  Arguments:  value                  - reset or activate
 464 //
 465 //  Returns:    None
 466 //-----------------------------------------------------------------------
 467 static void card_reset_dsp (struct ft1000_device *ft1000dev, bool value)
 468 {
 469     u16 status = STATUS_SUCCESS;
 470     u16 tempword;
 471
 472     status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
 473     status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_CTRL);
 474     if (value)
 475     {
 476         DEBUG("Reset DSP\n");
 477         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 478         tempword |= DSP_RESET_BIT;
 479         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 480     }
 481     else
 482     {
 483         DEBUG("Activate DSP\n");
 484         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 485         tempword |= DSP_ENCRYPTED;
 486         tempword &= ~DSP_UNENCRYPTED;
 487         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 488         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 489         tempword &= ~EFUSE_MEM_DISABLE;
 490         tempword &= ~DSP_RESET_BIT;
 491         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 492         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 493     }
 494 }
 495
 496 //---------------------------------------------------------------------------
 497 // Function:    CardSendCommand
 498 //
 499 // Parameters:  ft1000_device  - device structure
 500 //              ptempbuffer - command buffer
 501 //              size - command buffer size
 502 //
 503 // Returns:     STATUS_SUCCESS - success
 504 //              STATUS_FAILURE - failure
 505 //
 506 // Description: This function sends a command to ASIC
 507 //
 508 // Notes:
 509 //
 510 //---------------------------------------------------------------------------
 511 void CardSendCommand(struct ft1000_device *ft1000dev, void *ptempbuffer, int size)
 512 {
 513     unsigned short temp;
 514     unsigned char *commandbuf;
 515
 516     DEBUG("CardSendCommand: enter CardSendCommand... size=%d\n", size);
 517
 518     commandbuf =(unsigned char*) kmalloc(size+2, GFP_KERNEL);
 519     memcpy((void*)commandbuf+2, (void*)ptempbuffer, size);
 520
 521     //DEBUG("CardSendCommand: Command Send\n");
 522
 523     ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 524
 525     if (temp & 0x0100)
 526     {
 527        msleep(10);
 528     }
 529
 530     // check for odd word
 531     size = size + 2;
 532     if (size % 4)
 533     {
 534        // Must force to be 32 bit aligned
 535        size += 4 - (size % 4);
 536     }
 537
 538
 539     //DEBUG("CardSendCommand: write dpram ... size=%d\n", size);
 540     ft1000_write_dpram32(ft1000dev, 0,commandbuf, size);
 541     msleep(1);
 542     //DEBUG("CardSendCommand: write into doorbell ...\n");
 543     ft1000_write_register(ft1000dev,  FT1000_DB_DPRAM_TX ,FT1000_REG_DOORBELL) ;
 544     msleep(1);
 545
 546     ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 547     //DEBUG("CardSendCommand: read doorbell ...temp=%x\n", temp);
 548     if ( (temp & 0x0100) == 0)
 549     {
 550        //DEBUG("CardSendCommand: Message sent\n");
 551     }
 552
 553 }
 554
 555
 556 //--------------------------------------------------------------------------
 557 //
 558 //  Function:   dsp_reload
 559 //
 560 //  Synopsis:   This function is called to load or reload the DSP
 561 //
 562 //  Arguments:  ft1000dev - device structure
 563 //
 564 //  Returns:    None
 565 //-----------------------------------------------------------------------
 566 int dsp_reload(struct ft1000_device *ft1000dev)
 567 {
 568     u16 status;
 569     u16 tempword;
 570     u32 templong;
 571
 572         struct ft1000_info *pft1000info;
 573
 574     pft1000info = netdev_priv(ft1000dev->net);
 575
 576     pft1000info->CardReady = 0;
 577
 578     // Program Interrupt Mask register
 579     status = ft1000_write_register (ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
 580
 581     status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
 582     tempword |= ASIC_RESET_BIT;
 583     status = ft1000_write_register (ft1000dev, tempword, FT1000_REG_RESET);
 584     msleep(1000);
 585     status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
 586     DEBUG("Reset Register = 0x%x\n", tempword);
 587
 588     // Toggle DSP reset
 589     card_reset_dsp (ft1000dev, 1);
 590     msleep(1000);
 591     card_reset_dsp (ft1000dev, 0);
 592     msleep(1000);
 593
 594     status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
 595
 596     // Let's check for FEFE
 597     status = ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (u8 *)&templong, 4);
 598     DEBUG("templong (fefe) = 0x%8x\n", templong);
 599
 600     // call codeloader
 601     status = scram_dnldr(ft1000dev, pFileStart, FileLength);
 602
 603         if (status != STATUS_SUCCESS)
 604                 return -EIO;
 605
 606     msleep(1000);
 607
 608     DEBUG("dsp_reload returned\n");
 609         return 0;
 610
 611 }
 612
 613 //---------------------------------------------------------------------------
 614 //
 615 // Function:   ft1000_reset_asic
 616 // Descripton: This function will call the Card Service function to reset the
 617 //             ASIC.
 618 // Input:
 619 //     dev    - device structure
 620 // Output:
 621 //     none
 622 //
 623 //---------------------------------------------------------------------------
 624 static void ft1000_reset_asic (struct net_device *dev)
 625 {
 626         struct ft1000_info *info = netdev_priv(dev);
 627     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 628     u16 tempword;
 629
 630     DEBUG("ft1000_hw:ft1000_reset_asic called\n");
 631
 632     info->ASICResetNum++;
 633
 634     // Let's use the register provided by the Magnemite ASIC to reset the
 635     // ASIC and DSP.
 636     ft1000_write_register(ft1000dev,  (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
 637
 638     mdelay(1);
 639
 640     // set watermark to -1 in order to not generate an interrrupt
 641     ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
 642
 643     // clear interrupts
 644     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
 645     DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
 646     ft1000_write_register (ft1000dev,  tempword, FT1000_REG_SUP_ISR);
 647     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
 648     DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
 649
 650 }
 651
 652
 653 //---------------------------------------------------------------------------
 654 //
 655 // Function:   ft1000_reset_card
 656 // Descripton: This function will reset the card
 657 // Input:
 658 //     dev    - device structure
 659 // Output:
 660 //     status - FALSE (card reset fail)
 661 //              TRUE  (card reset successful)
 662 //
 663 //---------------------------------------------------------------------------
 664 static int ft1000_reset_card (struct net_device *dev)
 665 {
 666         struct ft1000_info *info = netdev_priv(dev);
 667     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 668     u16 tempword;
 669         struct prov_record *ptr;
 670
 671     DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
 672
 673     info->fCondResetPend = 1;
 674     info->CardReady = 0;
 675     info->fProvComplete = 0;
 676
 677     // Make sure we free any memory reserve for provisioning
 678     while (list_empty(&info->prov_list) == 0) {
 679         DEBUG("ft1000_hw:ft1000_reset_card:deleting provisioning record\n");
 680         ptr = list_entry(info->prov_list.next, struct prov_record, list);
 681         list_del(&ptr->list);
 682         kfree(ptr->pprov_data);
 683         kfree(ptr);
 684     }
 685
 686     DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
 687     //reset ASIC
 688     ft1000_reset_asic(dev);
 689
 690     info->DSPResetNum++;
 691
 692     DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
 693     dsp_reload(ft1000dev);
 694
 695     DEBUG("dsp reload successful\n");
 696
 697
 698     mdelay(10);
 699
 700     // Initialize DSP heartbeat area to ho
 701     ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag, FT1000_MAG_HI_HO_INDX);
 702     ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *)&tempword, FT1000_MAG_HI_HO_INDX);
 703     DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
 704
 705
 706
 707     info->CardReady = 1;
 708
 709     info->fCondResetPend = 0;
 710     return TRUE;
 711
 712 }
 713
 714
 715 //mbelian
 716 #ifdef HAVE_NET_DEVICE_OPS
 717 static const struct net_device_ops ftnet_ops =
 718 {
 719 .ndo_open = &ft1000_open,
 720 .ndo_stop = &ft1000_close,
 721 .ndo_start_xmit = &ft1000_start_xmit,
 722 .ndo_get_stats = &ft1000_netdev_stats,
 723 };
 724 #endif
 725
 726
 727 //---------------------------------------------------------------------------
 728 // Function:    init_ft1000_netdev
 729 //
 730 // Parameters:  ft1000dev  - device structure
 731 //
 732 //
 733 // Returns:     STATUS_SUCCESS - success
 734 //              STATUS_FAILURE - failure
 735 //
 736 // Description: This function initialize the network device
 737 //
 738 // Notes:
 739 //
 740 //---------------------------------------------------------------------------
 741 u16 init_ft1000_netdev(struct ft1000_device *ft1000dev)
 742 {
 743     struct net_device *netdev;
 744         struct ft1000_info *pInfo = NULL;
 745         struct dpram_blk *pdpram_blk;
 746         int i, ret_val;
 747         struct list_head *cur, *tmp;
 748         char card_nr[2];
 749         unsigned long gCardIndex = 0;
 750
 751     DEBUG("Enter init_ft1000_netdev...\n");
 752
 753
 754         netdev = alloc_etherdev(sizeof(struct ft1000_info));
 755     if (!netdev )
 756     {
 757         DEBUG("init_ft1000_netdev: can not allocate network device\n");
 758         return -ENOMEM;
 759     }
 760
 761         pInfo = netdev_priv(netdev);
 762
 763     //DEBUG("init_ft1000_netdev: gFt1000Info=%x, netdev=%x, ft1000dev=%x\n", gFt1000Info, netdev, ft1000dev);
 764
 765         memset(pInfo, 0, sizeof(struct ft1000_info));
 766
 767     dev_alloc_name(netdev, netdev->name);
 768
 769         DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
 770
 771         if ( strncmp(netdev->name,"eth", 3) == 0) {
 772                 card_nr[0] = netdev->name[3];
 773                 card_nr[1] = '\0';
 774                 ret_val = strict_strtoul(card_nr, 10, &gCardIndex);
 775                 if (ret_val) {
 776                         printk(KERN_ERR "Can't parse netdev\n");
 777                         goto err_net;
 778                 }
 779
 780             pInfo->CardNumber = gCardIndex;
 781             DEBUG("card number = %d\n", pInfo->CardNumber);
 782         }
 783         else {
 784             printk(KERN_ERR "ft1000: Invalid device name\n");
 785                 ret_val = -ENXIO;
 786                 goto err_net;
 787         }
 788
 789     memset(&pInfo->stats, 0, sizeof(struct net_device_stats) );
 790
 791    spin_lock_init(&pInfo->dpram_lock);
 792     pInfo->pFt1000Dev = ft1000dev;
 793     pInfo->DrvErrNum = 0;
 794     pInfo->ASICResetNum = 0;
 795     pInfo->registered = 1;
 796     pInfo->ft1000_reset = ft1000_reset;
 797     pInfo->mediastate = 0;
 798     pInfo->fifo_cnt = 0;
 799     pInfo->DeviceCreated = FALSE;
 800     pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
 801     pInfo->InterruptsEnabled = FALSE;
 802     pInfo->CardReady = 0;
 803     pInfo->DSP_TIME[0] = 0;
 804     pInfo->DSP_TIME[1] = 0;
 805     pInfo->DSP_TIME[2] = 0;
 806     pInfo->DSP_TIME[3] = 0;
 807     pInfo->fAppMsgPend = 0;
 808     pInfo->fCondResetPend = 0;
 809         pInfo->usbboot = 0;
 810         pInfo->dspalive = 0;
 811         memset(&pInfo->tempbuf[0], 0, sizeof(pInfo->tempbuf));
 812
 813     INIT_LIST_HEAD(&pInfo->prov_list);
 814
 815         INIT_LIST_HEAD(&pInfo->nodes.list);
 816 //mbelian
 817 #ifdef HAVE_NET_DEVICE_OPS
 818         netdev->netdev_ops = &ftnet_ops;
 819 #else
 820     netdev->hard_start_xmit = &ft1000_start_xmit;
 821     netdev->get_stats = &ft1000_netdev_stats;
 822     netdev->open = &ft1000_open;
 823     netdev->stop = &ft1000_close;
 824 #endif
 825
 826     ft1000dev->net = netdev;
 827
 828
 829
 830 //init free_buff_lock, freercvpool, numofmsgbuf, pdpram_blk
 831 //only init once per card
 832 //Jim
 833           DEBUG("Initialize free_buff_lock and freercvpool\n");
 834         spin_lock_init(&free_buff_lock);
 835
 836         // initialize a list of buffers to be use for queuing up receive command data
 837         INIT_LIST_HEAD (&freercvpool);
 838
 839         // create list of free buffers
 840         for (i=0; i<NUM_OF_FREE_BUFFERS; i++) {
 841             // Get memory for DPRAM_DATA link list
 842                 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
 843                 if (pdpram_blk == NULL) {
 844                         ret_val = -ENOMEM;
 845                         goto err_free;
 846                 }
 847             // Get a block of memory to store command data
 848             pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );
 849                 if (pdpram_blk->pbuffer == NULL) {
 850                         ret_val = -ENOMEM;
 851                         kfree(pdpram_blk);
 852                         goto err_free;
 853                 }
 854             // link provisioning data
 855             list_add_tail (&pdpram_blk->list, &freercvpool);
 856         }
 857         numofmsgbuf = NUM_OF_FREE_BUFFERS;
 858
 859
 860         return 0;
 861
 862
 863 err_free:
 864         list_for_each_safe(cur, tmp, &freercvpool) {
 865                 pdpram_blk = list_entry(cur, struct dpram_blk, list);
 866                 list_del(&pdpram_blk->list);
 867                 kfree(pdpram_blk->pbuffer);
 868                 kfree(pdpram_blk);
 869         }
 870 err_net:
 871         free_netdev(netdev);
 872         return ret_val;
 873 }
 874
 875
 876
 877 //---------------------------------------------------------------------------
 878 // Function:    reg_ft1000_netdev
 879 //
 880 // Parameters:  ft1000dev  - device structure
 881 //
 882 //
 883 // Returns:     STATUS_SUCCESS - success
 884 //              STATUS_FAILURE - failure
 885 //
 886 // Description: This function register the network driver
 887 //
 888 // Notes:
 889 //
 890 //---------------------------------------------------------------------------
 891 int reg_ft1000_netdev(struct ft1000_device *ft1000dev, struct usb_interface *intf)
 892 {
 893     struct net_device *netdev;
 894         struct ft1000_info *pInfo;
 895         int rc;
 896
 897     netdev = ft1000dev->net;
 898     pInfo = netdev_priv(ft1000dev->net);
 899     DEBUG("Enter reg_ft1000_netdev...\n");
 900
 901
 902     ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
 903
 904     usb_set_intfdata(intf, pInfo);
 905     SET_NETDEV_DEV(netdev, &intf->dev);
 906
 907     rc = register_netdev(netdev);
 908     if (rc)
 909     {
 910         DEBUG("reg_ft1000_netdev: could not register network device\n");
 911         free_netdev(netdev);
 912         return rc;
 913     }
 914
 915
 916     //Create character device, implemented by Jim
 917     ft1000_create_dev(ft1000dev);
 918
 919     DEBUG ("reg_ft1000_netdev returned\n");
 920
 921     pInfo->CardReady = 1;
 922
 923
 924         return 0;
 925 }
 926
 927 static int ft1000_reset(struct net_device *dev)
 928 {
 929     ft1000_reset_card(dev);
 930     return 0;
 931 }
 932
 933 //---------------------------------------------------------------------------
 934 // Function:    ft1000_usb_transmit_complete
 935 //
 936 // Parameters:  urb  - transmitted usb urb
 937 //
 938 //
 939 // Returns:     none
 940 //
 941 // Description: This is the callback function when a urb is transmitted
 942 //
 943 // Notes:
 944 //
 945 //---------------------------------------------------------------------------
 946 static void ft1000_usb_transmit_complete(struct urb *urb)
 947 {
 948
 949     struct ft1000_device *ft1000dev = urb->context;
 950
 951     //DEBUG("ft1000_usb_transmit_complete entered\n");
 952
 953     if (urb->status)
 954         printk("%s: TX status %d\n", ft1000dev->net->name, urb->status);
 955
 956     netif_wake_queue(ft1000dev->net);
 957
 958     //DEBUG("Return from ft1000_usb_transmit_complete\n");
 959 }
 960
 961 //---------------------------------------------------------------------------
 962 //
 963 // Function:   ft1000_copy_down_pkt
 964 // Descripton: This function will take an ethernet packet and convert it to
 965 //             a Flarion packet prior to sending it to the ASIC Downlink
 966 //             FIFO.
 967 // Input:
 968 //     dev    - device structure
 969 //     packet - address of ethernet packet
 970 //     len    - length of IP packet
 971 // Output:
 972 //     status - FAILURE
 973 //              SUCCESS
 974 //
 975 //---------------------------------------------------------------------------
 976 static int ft1000_copy_down_pkt (struct net_device *netdev, u8 *packet, u16 len)
 977 {
 978         struct ft1000_info *pInfo = netdev_priv(netdev);
 979     struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
 980
 981
 982         int count, ret;
 983     u8 *t;
 984         struct pseudo_hdr hdr;
 985
 986     if (!pInfo->CardReady)
 987     {
 988
 989         DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
 990         return -ENODEV;
 991
 992     }
 993
 994
 995     //DEBUG("ft1000_copy_down_pkt() entered, len = %d\n", len);
 996
 997         count = sizeof(struct pseudo_hdr) + len;
 998     if(count > MAX_BUF_SIZE)
 999     {
1000         DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
1001         DEBUG("size = %d\n", count);
1002         return -EINVAL;
1003     }
1004
1005     if ( count % 4)
1006         count = count + (4- (count %4) );
1007
1008         memset(&hdr, 0, sizeof(struct pseudo_hdr));
1009
1010         hdr.length = ntohs(count);
1011         hdr.source = 0x10;
1012         hdr.destination = 0x20;
1013         hdr.portdest = 0x20;
1014         hdr.portsrc = 0x10;
1015         hdr.sh_str_id = 0x91;
1016         hdr.control = 0x00;
1017
1018         hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
1019                         hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^
1020                         hdr.control;
1021
1022         memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
1023         memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
1024
1025     netif_stop_queue(netdev);
1026
1027     //DEBUG ("ft1000_copy_down_pkt: count = %d\n", count);
1028
1029     usb_fill_bulk_urb(pFt1000Dev->tx_urb,
1030                       pFt1000Dev->dev,
1031                       usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr),
1032                       pFt1000Dev->tx_buf,
1033                       count,
1034                       ft1000_usb_transmit_complete,
1035                       (void*)pFt1000Dev);
1036
1037     t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
1038     //DEBUG("transfer_length=%d\n", pFt1000Dev->tx_urb->transfer_buffer_length);
1039     /*for (i=0; i<count; i++ )
1040     {
1041        DEBUG("%x    ", *t++ );
1042     }*/
1043
1044
1045         ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
1046         if (ret) {
1047                 DEBUG("ft1000 failed tx_urb %d\n", ret);
1048                 return ret;
1049         } else {
1050                 pInfo->stats.tx_packets++;
1051                 pInfo->stats.tx_bytes += (len+14);
1052         }
1053
1054     //DEBUG("ft1000_copy_down_pkt() exit\n");
1055
1056         return 0;
1057 }
1058
1059 //---------------------------------------------------------------------------
1060 // Function:    ft1000_start_xmit
1061 //
1062 // Parameters:  skb - socket buffer to be sent
1063 //              dev - network device
1064 //
1065 //
1066 // Returns:     none
1067 //
1068 // Description: transmit a ethernet packet
1069 //
1070 // Notes:
1071 //
1072 //---------------------------------------------------------------------------
1073 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1074 {
1075         struct ft1000_info *pInfo = netdev_priv(dev);
1076     struct ft1000_device *pFt1000Dev= pInfo->pFt1000Dev;
1077     u8 *pdata;
1078     int maxlen, pipe;
1079
1080
1081     //DEBUG(" ft1000_start_xmit() entered\n");
1082
1083     if ( skb == NULL )
1084     {
1085         DEBUG ("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n" );
1086         return NETDEV_TX_OK;
1087     }
1088
1089     if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1090     {
1091         DEBUG("network driver is closed, return\n");
1092         goto err;
1093     }
1094
1095     //DEBUG("ft1000_start_xmit 1:length of packet = %d\n", skb->len);
1096     pipe = usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1097     maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1098     //DEBUG("ft1000_start_xmit 2: pipe=%d dev->maxpacket  = %d\n", pipe, maxlen);
1099
1100     pdata = (u8 *)skb->data;
1101     /*for (i=0; i<skb->len; i++)
1102         DEBUG("skb->data[%d]=%x    ", i, *(skb->data+i));
1103
1104     DEBUG("\n");*/
1105
1106
1107     if (pInfo->mediastate == 0)
1108     {
1109         /* Drop packet is mediastate is down */
1110         DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1111         goto err;
1112     }
1113
1114     if ( (skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE) )
1115     {
1116         /* Drop packet which has invalid size */
1117         DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1118         goto err;
1119     }
1120 //mbelian
1121         ft1000_copy_down_pkt(dev, (pdata+ENET_HEADER_SIZE-2),
1122                                 skb->len - ENET_HEADER_SIZE + 2);
1123
1124 err:
1125         dev_kfree_skb(skb);
1126     //DEBUG(" ft1000_start_xmit() exit\n");
1127
1128         return NETDEV_TX_OK;
1129 }
1130
1131 //---------------------------------------------------------------------------
1132 //
1133 // Function:   ft1000_copy_up_pkt
1134 // Descripton: This function will take a packet from the FIFO up link and
1135 //             convert it into an ethernet packet and deliver it to the IP stack
1136 // Input:
1137 //     urb - the receving usb urb
1138 //
1139 // Output:
1140 //     status - FAILURE
1141 //              SUCCESS
1142 //
1143 //---------------------------------------------------------------------------
1144 static int ft1000_copy_up_pkt (struct urb *urb)
1145 {
1146         struct ft1000_info *info = urb->context;
1147     struct ft1000_device *ft1000dev = info->pFt1000Dev;
1148     struct net_device *net = ft1000dev->net;
1149
1150     u16 tempword;
1151     u16 len;
1152     u16 lena; //mbelian
1153     struct sk_buff *skb;
1154     u16 i;
1155     u8 *pbuffer=NULL;
1156     u8 *ptemp=NULL;
1157     u16 *chksum;
1158
1159
1160     //DEBUG("ft1000_copy_up_pkt entered\n");
1161
1162     if ( ft1000dev->status & FT1000_STATUS_CLOSING)
1163     {
1164         DEBUG("network driver is closed, return\n");
1165         return STATUS_SUCCESS;
1166     }
1167
1168     // Read length
1169     len = urb->transfer_buffer_length;
1170     lena = urb->actual_length; //mbelian
1171     //DEBUG("ft1000_copy_up_pkt: transfer_buffer_length=%d, actual_buffer_len=%d\n",
1172       //       urb->transfer_buffer_length, urb->actual_length);
1173
1174     chksum = (u16 *)ft1000dev->rx_buf;
1175
1176     tempword = *chksum++;
1177     for (i=1; i<7; i++)
1178     {
1179         tempword ^= *chksum++;
1180     }
1181
1182     if  (tempword != *chksum)
1183     {
1184         info->stats.rx_errors ++;
1185         ft1000_submit_rx_urb(info);
1186         return STATUS_FAILURE;
1187     }
1188
1189
1190     //DEBUG("ft1000_copy_up_pkt: checksum is correct %x\n", *chksum);
1191
1192     skb = dev_alloc_skb(len+12+2);
1193
1194     if (skb == NULL)
1195     {
1196         DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1197         info->stats.rx_errors++;
1198         ft1000_submit_rx_urb(info);
1199         return STATUS_FAILURE;
1200     }
1201
1202     pbuffer = (u8 *)skb_put(skb, len+12);
1203
1204     //subtract the number of bytes read already
1205     ptemp = pbuffer;
1206
1207     // fake MAC address
1208     *pbuffer++ = net->dev_addr[0];
1209     *pbuffer++ = net->dev_addr[1];
1210     *pbuffer++ = net->dev_addr[2];
1211     *pbuffer++ = net->dev_addr[3];
1212     *pbuffer++ = net->dev_addr[4];
1213     *pbuffer++ = net->dev_addr[5];
1214     *pbuffer++ = 0x00;
1215     *pbuffer++ = 0x07;
1216     *pbuffer++ = 0x35;
1217     *pbuffer++ = 0xff;
1218     *pbuffer++ = 0xff;
1219     *pbuffer++ = 0xfe;
1220
1221
1222
1223
1224         memcpy(pbuffer, ft1000dev->rx_buf+sizeof(struct pseudo_hdr), len-sizeof(struct pseudo_hdr));
1225
1226     //DEBUG("ft1000_copy_up_pkt: Data passed to Protocol layer\n");
1227     /*for (i=0; i<len+12; i++)
1228     {
1229         DEBUG("ft1000_copy_up_pkt: Protocol Data: 0x%x\n ", *ptemp++);
1230     }*/
1231
1232     skb->dev = net;
1233
1234     skb->protocol = eth_type_trans(skb, net);
1235     skb->ip_summed = CHECKSUM_UNNECESSARY;
1236     netif_rx(skb);
1237
1238     info->stats.rx_packets++;
1239     // Add on 12 bytes for MAC address which was removed
1240     info->stats.rx_bytes += (lena+12); //mbelian
1241
1242     ft1000_submit_rx_urb(info);
1243     //DEBUG("ft1000_copy_up_pkt exited\n");
1244     return SUCCESS;
1245 }
1246
1247 //---------------------------------------------------------------------------
1248 //
1249 // Function:   ft1000_submit_rx_urb
1250 // Descripton: the receiving function of the network driver
1251 //
1252 // Input:
1253 //     info - a private structure contains the device information
1254 //
1255 // Output:
1256 //     status - FAILURE
1257 //              SUCCESS
1258 //
1259 //---------------------------------------------------------------------------
1260 static int ft1000_submit_rx_urb(struct ft1000_info *info)
1261 {
1262     int result;
1263     struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1264
1265
1266     //DEBUG ("ft1000_submit_rx_urb entered: sizeof rx_urb is %d\n", sizeof(*pFt1000Dev->rx_urb));
1267     if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1268     {
1269         DEBUG("network driver is closed, return\n");
1270         //usb_kill_urb(pFt1000Dev->rx_urb); //mbelian
1271         return -ENODEV;
1272     }
1273
1274     usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1275             pFt1000Dev->dev,
1276             usb_rcvbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_in_endpointAddr),
1277             pFt1000Dev->rx_buf,
1278             MAX_BUF_SIZE,
1279             (usb_complete_t)ft1000_copy_up_pkt,
1280             info);
1281
1282
1283     if((result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC)))
1284     {
1285         printk("ft1000_submit_rx_urb: submitting rx_urb %d failed\n", result);
1286         return result;
1287     }
1288
1289     //DEBUG("ft1000_submit_rx_urb exit: result=%d\n", result);
1290
1291         return 0;
1292 }
1293
1294 //---------------------------------------------------------------------------
1295 // Function:    ft1000_open
1296 //
1297 // Parameters:
1298 //              dev - network device
1299 //
1300 //
1301 // Returns:     none
1302 //
1303 // Description: open the network driver
1304 //
1305 // Notes:
1306 //
1307 //---------------------------------------------------------------------------
1308 static int ft1000_open (struct net_device *dev)
1309 {
1310         struct ft1000_info *pInfo = netdev_priv(dev);
1311     struct timeval tv; //mbelian
1312         int ret;
1313
1314     DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1315     //DEBUG("ft1000_open: dev->addr=%x, dev->addr_len=%d\n", dev->addr, dev->addr_len);
1316
1317         pInfo->stats.rx_bytes = 0; //mbelian
1318         pInfo->stats.tx_bytes = 0; //mbelian
1319         pInfo->stats.rx_packets = 0; //mbelian
1320         pInfo->stats.tx_packets = 0; //mbelian
1321         do_gettimeofday(&tv);
1322     pInfo->ConTm = tv.tv_sec;
1323         pInfo->ProgConStat = 0; //mbelian
1324
1325
1326     netif_start_queue(dev);
1327
1328     netif_carrier_on(dev); //mbelian
1329
1330         ret = ft1000_submit_rx_urb(pInfo);
1331
1332         return ret;
1333 }
1334
1335 //---------------------------------------------------------------------------
1336 // Function:    ft1000_close
1337 //
1338 // Parameters:
1339 //              net - network device
1340 //
1341 //
1342 // Returns:     none
1343 //
1344 // Description: close the network driver
1345 //
1346 // Notes:
1347 //
1348 //---------------------------------------------------------------------------
1349 int ft1000_close(struct net_device *net)
1350 {
1351         struct ft1000_info *pInfo = netdev_priv(net);
1352     struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1353
1354     //DEBUG ("ft1000_close: netdev->refcnt=%d\n", net->refcnt);
1355
1356     ft1000dev->status |= FT1000_STATUS_CLOSING;
1357
1358     //DEBUG("ft1000_close: calling usb_kill_urb \n");
1359
1360     DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1361     netif_carrier_off(net);//mbelian
1362     netif_stop_queue(net);
1363     //DEBUG("ft1000_close: netif_stop_queue called\n");
1364     ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1365
1366    pInfo->ProgConStat = 0xff; //mbelian
1367
1368
1369     return 0;
1370 }
1371
1372 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1373 {
1374         struct ft1000_info *info = netdev_priv(dev);
1375
1376         return &(info->stats); //mbelian
1377 }
1378
1379
1380 /*********************************************************************************
1381 Jim
1382 */
1383
1384
1385 //---------------------------------------------------------------------------
1386 //
1387 // Function:   ft1000_chkcard
1388 // Descripton: This function will check if the device is presently available on
1389 //             the system.
1390 // Input:
1391 //     dev    - device structure
1392 // Output:
1393 //     status - FALSE (device is not present)
1394 //              TRUE  (device is present)
1395 //
1396 //---------------------------------------------------------------------------
1397 static int ft1000_chkcard (struct ft1000_device *dev) {
1398     u16 tempword;
1399     u16 status;
1400         struct ft1000_info *info = netdev_priv(dev->net);
1401
1402     if (info->fCondResetPend)
1403     {
1404         DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1405         return TRUE;
1406     }
1407
1408     // Mask register is used to check for device presence since it is never
1409     // set to zero.
1410     status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1411     //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_SUP_IMASK = %x\n", tempword);
1412     if (tempword == 0) {
1413         DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1414         return FALSE;
1415     }
1416
1417     // The system will return the value of 0xffff for the version register
1418     // if the device is not present.
1419     status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1420     //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_ASIC_ID = %x\n", tempword);
1421     if (tempword != 0x1b01 ){
1422         dev->status |= FT1000_STATUS_CLOSING; //mbelian
1423         DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1424         return FALSE;
1425     }
1426     return TRUE;
1427 }
1428
1429
1430
1431 //---------------------------------------------------------------------------
1432 //
1433 // Function:   ft1000_receive_cmd
1434 // Descripton: This function will read a message from the dpram area.
1435 // Input:
1436 //    dev - network device structure
1437 //    pbuffer - caller supply address to buffer
1438 //    pnxtph - pointer to next pseudo header
1439 // Output:
1440 //   Status = 0 (unsuccessful)
1441 //          = 1 (successful)
1442 //
1443 //---------------------------------------------------------------------------
1444 static bool ft1000_receive_cmd (struct ft1000_device *dev, u16 *pbuffer, int maxsz, u16 *pnxtph) {
1445     u16 size, ret;
1446     u16 *ppseudohdr;
1447     int i;
1448     u16 tempword;
1449
1450     ret = ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size, FT1000_MAG_PH_LEN_INDX);
1451     size = ntohs(size) + PSEUDOSZ;
1452     if (size > maxsz) {
1453         DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n", size);
1454         return FALSE;
1455     }
1456     else {
1457         ppseudohdr = (u16 *)pbuffer;
1458         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
1459         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1460         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1461         pbuffer++;
1462         ft1000_write_register(dev,  FT1000_DPRAM_MAG_RX_BASE+1, FT1000_REG_DPRAM_ADDR);
1463         for (i=0; i<=(size>>2); i++) {
1464             ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1465             pbuffer++;
1466             ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1467             pbuffer++;
1468         }
1469         //copy odd aligned word
1470         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1471         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1472         pbuffer++;
1473         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1474         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
1475         pbuffer++;
1476         if (size & 0x0001) {
1477             //copy odd byte from fifo
1478             ret = ft1000_read_register(dev, &tempword, FT1000_REG_DPRAM_DATA);
1479             *pbuffer = ntohs(tempword);
1480         }
1481
1482         // Check if pseudo header checksum is good
1483         // Calculate pseudo header checksum
1484         tempword = *ppseudohdr++;
1485         for (i=1; i<7; i++) {
1486             tempword ^= *ppseudohdr++;
1487         }
1488         if ( (tempword != *ppseudohdr) ) {
1489             return FALSE;
1490         }
1491
1492         return TRUE;
1493     }
1494 }
1495
1496
1497 static int ft1000_dsp_prov(void *arg)
1498 {
1499     struct ft1000_device *dev = (struct ft1000_device *)arg;
1500         struct ft1000_info *info = netdev_priv(dev->net);
1501     u16 tempword;
1502     u16 len;
1503     u16 i=0;
1504         struct prov_record *ptr;
1505         struct pseudo_hdr *ppseudo_hdr;
1506     u16 *pmsg;
1507     u16 status;
1508     u16 TempShortBuf [256];
1509
1510     DEBUG("*** DspProv Entered\n");
1511
1512     while (list_empty(&info->prov_list) == 0)
1513     {
1514         DEBUG("DSP Provisioning List Entry\n");
1515
1516         // Check if doorbell is available
1517         DEBUG("check if doorbell is cleared\n");
1518         status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1519         if (status)
1520         {
1521                 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1522             break;
1523         }
1524
1525         while (tempword & FT1000_DB_DPRAM_TX) {
1526             mdelay(10);
1527             i++;
1528             if (i==10) {
1529                DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1530                return STATUS_FAILURE;
1531             }
1532             ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1533         }
1534
1535         if ( !(tempword & FT1000_DB_DPRAM_TX) ) {
1536             DEBUG("*** Provision Data Sent to DSP\n");
1537
1538             // Send provisioning data
1539                 ptr = list_entry(info->prov_list.next, struct prov_record, list);
1540             len = *(u16 *)ptr->pprov_data;
1541             len = htons(len);
1542             len += PSEUDOSZ;
1543
1544             pmsg = (u16 *)ptr->pprov_data;
1545                 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1546             // Insert slow queue sequence number
1547             ppseudo_hdr->seq_num = info->squeseqnum++;
1548             ppseudo_hdr->portsrc = 0;
1549             // Calculate new checksum
1550             ppseudo_hdr->checksum = *pmsg++;
1551             //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1552             for (i=1; i<7; i++) {
1553                 ppseudo_hdr->checksum ^= *pmsg++;
1554                 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
1555             }
1556
1557             TempShortBuf[0] = 0;
1558             TempShortBuf[1] = htons (len);
1559             memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1560
1561             status = ft1000_write_dpram32 (dev, 0, (u8 *)&TempShortBuf[0], (unsigned short)(len+2));
1562             status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1563
1564             list_del(&ptr->list);
1565             kfree(ptr->pprov_data);
1566             kfree(ptr);
1567         }
1568         msleep(10);
1569     }
1570
1571     DEBUG("DSP Provisioning List Entry finished\n");
1572
1573     msleep(100);
1574
1575     info->fProvComplete = 1;
1576     info->CardReady = 1;
1577     return STATUS_SUCCESS;
1578
1579 }
1580
1581
1582 static int ft1000_proc_drvmsg (struct ft1000_device *dev, u16 size) {
1583         struct ft1000_info *info = netdev_priv(dev->net);
1584     u16 msgtype;
1585     u16 tempword;
1586         struct media_msg *pmediamsg;
1587         struct dsp_init_msg *pdspinitmsg;
1588         struct drv_msg *pdrvmsg;
1589     u16 i;
1590         struct pseudo_hdr *ppseudo_hdr;
1591     u16 *pmsg;
1592     u16 status;
1593     union {
1594         u8  byte[2];
1595         u16 wrd;
1596     } convert;
1597
1598
1599     char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1600     if (!cmdbuffer)
1601         return STATUS_FAILURE;
1602
1603     status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1604
1605
1606
1607 #ifdef JDEBUG
1608         DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1609         for(i = 0; i < size; i+=5)
1610         {
1611             if( (i + 5) < size )
1612                 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i], cmdbuffer[i+1], cmdbuffer[i+2], cmdbuffer[i+3], cmdbuffer[i+4]);
1613             else
1614             {
1615                 for (j = i; j < size; j++)
1616                 DEBUG("0x%x ", cmdbuffer[j]);
1617                 DEBUG("\n");
1618                 break;
1619             }
1620         }
1621 #endif
1622         pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1623         msgtype = ntohs(pdrvmsg->type);
1624         DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1625         switch (msgtype) {
1626             case MEDIA_STATE: {
1627                 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1628
1629                 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1630                 if (info->ProgConStat != 0xFF) {
1631                     if (pmediamsg->state) {
1632                         DEBUG("Media is up\n");
1633                         if (info->mediastate == 0) {
1634                             if ( info->NetDevRegDone )
1635                             {
1636                                 //netif_carrier_on(dev->net);//mbelian
1637                                 netif_wake_queue(dev->net);
1638                             }
1639                             info->mediastate = 1;
1640                             /*do_gettimeofday(&tv);
1641                             info->ConTm = tv.tv_sec;*/ //mbelian
1642                         }
1643                     }
1644                     else {
1645                         DEBUG("Media is down\n");
1646                         if (info->mediastate == 1) {
1647                             info->mediastate = 0;
1648                             if ( info->NetDevRegDone )
1649                             {
1650                                 //netif_carrier_off(dev->net); mbelian
1651                                 //netif_stop_queue(dev->net);
1652                             }
1653                             info->ConTm = 0;
1654                         }
1655                     }
1656                 }
1657                 else {
1658                     DEBUG("Media is down\n");
1659                     if (info->mediastate == 1) {
1660                         info->mediastate = 0;
1661                         if ( info->NetDevRegDone)
1662                         {
1663                             //netif_carrier_off(dev->net); //mbelian
1664                             //netif_stop_queue(dev->net);
1665                         }
1666                         info->ConTm = 0;
1667                     }
1668                 }
1669                 break;
1670             }
1671             case DSP_INIT_MSG: {
1672                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1673
1674                 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1675                 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1676                 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n", info->DspVer[0], info->DspVer[1], info->DspVer[2], info->DspVer[3]);
1677                 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum, HWSERNUMSZ);
1678                 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1679                 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1680                 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n", info->eui64[0],info->eui64[1], info->eui64[2], info->eui64[3], info->eui64[4], info->eui64[5],info->eui64[6], info->eui64[7]);
1681                 dev->net->dev_addr[0] = info->eui64[0];
1682                 dev->net->dev_addr[1] = info->eui64[1];
1683                 dev->net->dev_addr[2] = info->eui64[2];
1684                 dev->net->dev_addr[3] = info->eui64[5];
1685                 dev->net->dev_addr[4] = info->eui64[6];
1686                 dev->net->dev_addr[5] = info->eui64[7];
1687
1688                 if (ntohs(pdspinitmsg->length) == (sizeof(struct dsp_init_msg) - 20)) {
1689                     memcpy(info->ProductMode, pdspinitmsg->ProductMode, MODESZ);
1690                     memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1691                     memcpy(info->RfCalDate, pdspinitmsg->RfCalDate, CALDATESZ);
1692                     DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0], info->RfCalVer[1]);
1693                 }
1694                 break;
1695             }
1696             case DSP_PROVISION: {
1697                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1698
1699                 // kick off dspprov routine to start provisioning
1700                 // Send provisioning data to DSP
1701                 if (list_empty(&info->prov_list) == 0)
1702                 {
1703                     info->fProvComplete = 0;
1704                     status = ft1000_dsp_prov(dev);
1705                     if (status != STATUS_SUCCESS)
1706                         goto out;
1707                 }
1708                 else {
1709                     info->fProvComplete = 1;
1710                     status = ft1000_write_register (dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
1711                     DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1712                 }
1713                 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1714                 break;
1715             }
1716             case DSP_STORE_INFO: {
1717                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1718
1719                 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1720                 tempword = ntohs(pdrvmsg->length);
1721                 info->DSPInfoBlklen = tempword;
1722                 if (tempword < (MAX_DSP_SESS_REC-4) ) {
1723                     pmsg = (u16 *)&pdrvmsg->data[0];
1724                     for (i=0; i<((tempword+1)/2); i++) {
1725                         DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
1726                         info->DSPInfoBlk[i+10] = *pmsg++;
1727                     }
1728                 }
1729                 else {
1730                     info->DSPInfoBlklen = 0;
1731                 }
1732                 break;
1733             }
1734             case DSP_GET_INFO: {
1735                 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1736                 // copy dsp info block to dsp
1737                 info->DrvMsgPend = 1;
1738                 // allow any outstanding ioctl to finish
1739                 mdelay(10);
1740                 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1741                 if (tempword & FT1000_DB_DPRAM_TX) {
1742                     mdelay(10);
1743                     status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1744                     if (tempword & FT1000_DB_DPRAM_TX) {
1745                         mdelay(10);
1746                             status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1747                             if (tempword & FT1000_DB_DPRAM_TX) {
1748                                 break;
1749                             }
1750                     }
1751                 }
1752
1753                 // Put message into Slow Queue
1754                 // Form Pseudo header
1755                 pmsg = (u16 *)info->DSPInfoBlk;
1756                 *pmsg++ = 0;
1757                 *pmsg++ = htons(info->DSPInfoBlklen+20+info->DSPInfoBlklen);
1758                 ppseudo_hdr = (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1759                 ppseudo_hdr->length = htons(info->DSPInfoBlklen+4+info->DSPInfoBlklen);
1760                 ppseudo_hdr->source = 0x10;
1761                 ppseudo_hdr->destination = 0x20;
1762                 ppseudo_hdr->portdest = 0;
1763                 ppseudo_hdr->portsrc = 0;
1764                 ppseudo_hdr->sh_str_id = 0;
1765                 ppseudo_hdr->control = 0;
1766                 ppseudo_hdr->rsvd1 = 0;
1767                 ppseudo_hdr->rsvd2 = 0;
1768                 ppseudo_hdr->qos_class = 0;
1769                 // Insert slow queue sequence number
1770                 ppseudo_hdr->seq_num = info->squeseqnum++;
1771                 // Insert application id
1772                 ppseudo_hdr->portsrc = 0;
1773                 // Calculate new checksum
1774                 ppseudo_hdr->checksum = *pmsg++;
1775                 for (i=1; i<7; i++) {
1776                     ppseudo_hdr->checksum ^= *pmsg++;
1777                 }
1778                 info->DSPInfoBlk[10] = 0x7200;
1779                 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1780                 status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPInfoBlk[0], (unsigned short)(info->DSPInfoBlklen+22));
1781                 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
1782                 info->DrvMsgPend = 0;
1783
1784                 break;
1785             }
1786
1787           case GET_DRV_ERR_RPT_MSG: {
1788               DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1789               // copy driver error message to dsp
1790               info->DrvMsgPend = 1;
1791               // allow any outstanding ioctl to finish
1792               mdelay(10);
1793               status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1794               if (tempword & FT1000_DB_DPRAM_TX) {
1795                   mdelay(10);
1796                   status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1797                   if (tempword & FT1000_DB_DPRAM_TX) {
1798                       mdelay(10);
1799                   }
1800               }
1801
1802               if ( (tempword & FT1000_DB_DPRAM_TX) == 0) {
1803                   // Put message into Slow Queue
1804                   // Form Pseudo header
1805                   pmsg = (u16 *)&tempbuffer[0];
1806                         ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1807                   ppseudo_hdr->length = htons(0x0012);
1808                   ppseudo_hdr->source = 0x10;
1809                   ppseudo_hdr->destination = 0x20;
1810                   ppseudo_hdr->portdest = 0;
1811                   ppseudo_hdr->portsrc = 0;
1812                   ppseudo_hdr->sh_str_id = 0;
1813                   ppseudo_hdr->control = 0;
1814                   ppseudo_hdr->rsvd1 = 0;
1815                   ppseudo_hdr->rsvd2 = 0;
1816                   ppseudo_hdr->qos_class = 0;
1817                   // Insert slow queue sequence number
1818                   ppseudo_hdr->seq_num = info->squeseqnum++;
1819                   // Insert application id
1820                   ppseudo_hdr->portsrc = 0;
1821                   // Calculate new checksum
1822                   ppseudo_hdr->checksum = *pmsg++;
1823                   for (i=1; i<7; i++) {
1824                       ppseudo_hdr->checksum ^= *pmsg++;
1825                   }
1826                   pmsg = (u16 *)&tempbuffer[16];
1827                   *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1828                   *pmsg++ = htons(0x000e);
1829                   *pmsg++ = htons(info->DSP_TIME[0]);
1830                   *pmsg++ = htons(info->DSP_TIME[1]);
1831                   *pmsg++ = htons(info->DSP_TIME[2]);
1832                   *pmsg++ = htons(info->DSP_TIME[3]);
1833                   convert.byte[0] = info->DspVer[0];
1834                   convert.byte[1] = info->DspVer[1];
1835                   *pmsg++ = convert.wrd;
1836                   convert.byte[0] = info->DspVer[2];
1837                   convert.byte[1] = info->DspVer[3];
1838                   *pmsg++ = convert.wrd;
1839                   *pmsg++ = htons(info->DrvErrNum);
1840
1841                   CardSendCommand (dev, (unsigned char*)&tempbuffer[0], (u16)(0x0012 + PSEUDOSZ));
1842                   info->DrvErrNum = 0;
1843               }
1844               info->DrvMsgPend = 0;
1845
1846           break;
1847       }
1848
1849       default:
1850           break;
1851         }
1852
1853
1854     status = STATUS_SUCCESS;
1855 out:
1856     kfree(cmdbuffer);
1857     DEBUG("return from ft1000_proc_drvmsg\n");
1858     return status;
1859 }
1860
1861
1862
1863 int ft1000_poll(void* dev_id) {
1864
1865     struct ft1000_device *dev = (struct ft1000_device *)dev_id;
1866         struct ft1000_info *info = netdev_priv(dev->net);
1867
1868     u16 tempword;
1869     u16 status;
1870     u16 size;
1871     int i;
1872     u16 data;
1873     u16 modulo;
1874     u16 portid;
1875     u16 nxtph;
1876         struct dpram_blk *pdpram_blk;
1877         struct pseudo_hdr *ppseudo_hdr;
1878     unsigned long flags;
1879
1880     //DEBUG("Enter ft1000_poll...\n");
1881     if (ft1000_chkcard(dev) == FALSE) {
1882         DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1883         return STATUS_FAILURE;
1884     }
1885
1886     status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1887    // DEBUG("ft1000_poll: read FT1000_REG_DOORBELL message 0x%x\n", tempword);
1888
1889     if ( !status )
1890     {
1891
1892         if (tempword & FT1000_DB_DPRAM_RX) {
1893             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DB_DPRAM_RX\n");
1894
1895             status = ft1000_read_dpram16(dev, 0x200, (u8 *)&data, 0);
1896             //DEBUG("ft1000_poll:FT1000_DB_DPRAM_RX:ft1000_read_dpram16:size = 0x%x\n", data);
1897             size = ntohs(data) + 16 + 2; //wai
1898             if (size % 4) {
1899                 modulo = 4 - (size % 4);
1900                 size = size + modulo;
1901             }
1902             status = ft1000_read_dpram16(dev, 0x201, (u8 *)&portid, 1);
1903             portid &= 0xff;
1904             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid 0x%x\n", portid);
1905
1906             if (size < MAX_CMD_SQSIZE) {
1907                 switch (portid)
1908                 {
1909                     case DRIVERID:
1910                         DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1911
1912                         status = ft1000_proc_drvmsg (dev, size);
1913                         if (status != STATUS_SUCCESS )
1914                             return status;
1915                         break;
1916                     case DSPBCMSGID:
1917                         // This is a dsp broadcast message
1918                         // Check which application has registered for dsp broadcast messages
1919                         //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DSPBCMSGID\n");
1920
1921                         for (i=0; i<MAX_NUM_APP; i++) {
1922                            if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
1923                                          (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT)  )
1924                            {
1925                                //DEBUG("Dsp broadcast message detected for app id %d\n", i);
1926                                nxtph = FT1000_DPRAM_RX_BASE + 2;
1927                                pdpram_blk = ft1000_get_buffer (&freercvpool);
1928                                if (pdpram_blk != NULL) {
1929                                    if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1930                                         ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1931                                        // Put message into the appropriate application block
1932                                        info->app_info[i].nRxMsg++;
1933                                        spin_lock_irqsave(&free_buff_lock, flags);
1934                                        list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1935                                        info->app_info[i].NumOfMsg++;
1936                                        spin_unlock_irqrestore(&free_buff_lock, flags);
1937                                        wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1938                                    }
1939                                    else {
1940                                        info->app_info[i].nRxMsgMiss++;
1941                                        // Put memory back to free pool
1942                                        ft1000_free_buffer(pdpram_blk, &freercvpool);
1943                                        DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1944                                    }
1945                                }
1946                                else {
1947                                    DEBUG("Out of memory in free receive command pool\n");
1948                                    info->app_info[i].nRxMsgMiss++;
1949                                }//endof if (pdpram_blk != NULL)
1950                            }//endof if
1951                            //else
1952                            //    DEBUG("app_info mismatch\n");
1953                         }// endof for
1954                         break;
1955                     default:
1956                         pdpram_blk = ft1000_get_buffer (&freercvpool);
1957                         //DEBUG("Memory allocated = 0x%8x\n", (u32)pdpram_blk);
1958                         if (pdpram_blk != NULL) {
1959                            if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1960                                 ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1961                                // Search for correct application block
1962                                for (i=0; i<MAX_NUM_APP; i++) {
1963                                    if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
1964                                        break;
1965                                    }
1966                                }
1967
1968                                if (i == MAX_NUM_APP) {
1969                                    DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
1970                                    // Put memory back to free pool
1971                                    ft1000_free_buffer(pdpram_blk, &freercvpool);
1972                                }
1973                                else {
1974                                    if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1975                                        // Put memory back to free pool
1976                                        ft1000_free_buffer(pdpram_blk, &freercvpool);
1977                                    }
1978                                    else {
1979                                        info->app_info[i].nRxMsg++;
1980                                        // Put message into the appropriate application block
1981                                        //pxu spin_lock_irqsave(&free_buff_lock, flags);
1982                                        list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1983                                        info->app_info[i].NumOfMsg++;
1984                                        //pxu spin_unlock_irqrestore(&free_buff_lock, flags);
1985                                        //pxu wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1986                                    }
1987                                }
1988                            }
1989                            else {
1990                                // Put memory back to free pool
1991                                ft1000_free_buffer(pdpram_blk, &freercvpool);
1992                            }
1993                         }
1994                         else {
1995                             DEBUG("Out of memory in free receive command pool\n");
1996                         }
1997                         break;
1998                 } //end of switch
1999             } //endof if (size < MAX_CMD_SQSIZE)
2000             else {
2001                 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
2002             }
2003             status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
2004         }
2005         else if (tempword & FT1000_DSP_ASIC_RESET) {
2006             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DSP_ASIC_RESET\n");
2007
2008             // Let's reset the ASIC from the Host side as well
2009             status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
2010             status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2011             i = 0;
2012             while (tempword & ASIC_RESET_BIT) {
2013                 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2014                 msleep(10);
2015                 i++;
2016                 if (i==100)
2017                     break;
2018             }
2019             if (i==100) {
2020                 DEBUG("Unable to reset ASIC\n");
2021                 return STATUS_SUCCESS;
2022             }
2023             msleep(10);
2024             // Program WMARK register
2025             status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2026             // clear ASIC reset doorbell
2027             status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
2028             msleep(10);
2029         }
2030         else if (tempword & FT1000_ASIC_RESET_REQ) {
2031             DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_ASIC_RESET_REQ\n");
2032
2033             // clear ASIC reset request from DSP
2034             status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
2035             status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
2036             // copy dsp session record from Adapter block
2037             status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPSess.Rec[0], 1024);
2038             // Program WMARK register
2039             status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2040             // ring doorbell to tell DSP that ASIC is out of reset
2041             status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
2042         }
2043         else if (tempword & FT1000_DB_COND_RESET) {
2044             DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DB_COND_RESET\n");
2045 //By Jim
2046 // Reset ASIC and DSP
2047 //MAG
2048             if (info->fAppMsgPend == 0) {
2049                // Reset ASIC and DSP
2050
2051                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (u8 *)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2052                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (u8 *)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2053                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (u8 *)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2054                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (u8 *)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2055                 info->CardReady = 0;
2056                 info->DrvErrNum = DSP_CONDRESET_INFO;
2057                 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2058                 info->ft1000_reset(dev->net);
2059             }
2060             else {
2061                 info->fProvComplete = 0;
2062                 info->fCondResetPend = 1;
2063             }
2064
2065             ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2066         }
2067
2068     }//endof if ( !status )
2069
2070     //DEBUG("return from ft1000_poll.\n");
2071     return STATUS_SUCCESS;
2072
2073 }
2074
2075 /*end of Jim*/