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 //#include <asm/semaphore.h>            //aelias [-] reason : file moved
  20 //#include <linux/semaphore.h>          //aelias [+] reason : file moved
  21 //#include <asm/io.h>
  22 //#include <linux/kthread.h>
  23
  24 #define HARLEY_READ_REGISTER     0x0
  25 #define HARLEY_WRITE_REGISTER    0x01
  26 #define HARLEY_READ_DPRAM_32     0x02
  27 #define HARLEY_READ_DPRAM_LOW    0x03
  28 #define HARLEY_READ_DPRAM_HIGH   0x04
  29 #define HARLEY_WRITE_DPRAM_32    0x05
  30 #define HARLEY_WRITE_DPRAM_LOW   0x06
  31 #define HARLEY_WRITE_DPRAM_HIGH  0x07
  32
  33 #define HARLEY_READ_OPERATION    0xc1
  34 #define HARLEY_WRITE_OPERATION   0x41
  35
  36 //#define JDEBUG
  37
  38 static int ft1000_reset(struct net_device *ft1000dev);
  39 static int ft1000_submit_rx_urb(PFT1000_INFO info);
  40 static void ft1000_hbchk(u_long data);
  41 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
  42 static int ft1000_open (struct net_device *dev);
  43 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
  44 static struct timer_list poll_timer[MAX_NUM_CARDS];
  45 static int ft1000_chkcard (struct ft1000_device *dev);
  46 /*
  47 static const struct net_device_ops ft1000net_ops = {
  48     .ndo_start_xmit = ft1000_start_xmit,
  49     .ndo_get_stats = ft1000_netdev_stats,
  50     .ndo_open = ft1000_open,
  51     .ndo_stop = ft1000_close,
  52 };
  53 */
  54
  55 //Jim
  56
  57 static u8 tempbuffer[1600];
  58 static int gCardIndex;
  59
  60 #define MAX_RCV_LOOP   100
  61
  62
  63 static int atoi(const char *s)
  64 {
  65         int k = 0;
  66     int cnt;
  67
  68         k = 0;
  69     cnt = 0;
  70         while (*s != '\0' && *s >= '0' && *s <= '9') {
  71                 k = 10 * k + (*s - '0');
  72                 s++;
  73         // Let's put a limit on this while loop to avoid deadlock scenario
  74         if (cnt > 100)
  75            break;
  76         cnt++;
  77         }
  78         return k;
  79 }
  80 /****************************************************************
  81  *     ft1000_control_complete
  82  ****************************************************************/
  83 static void ft1000_control_complete(struct urb *urb)
  84 {
  85     struct ft1000_device *ft1000dev = (struct ft1000_device *)urb->context;
  86
  87     //DEBUG("FT1000_CONTROL_COMPLETE ENTERED\n");
  88     if (ft1000dev == NULL )
  89     {
  90         DEBUG("NULL ft1000dev, failure\n");
  91         return ;
  92     }
  93     else if ( ft1000dev->dev == NULL )
  94     {
  95         DEBUG("NULL ft1000dev->dev, failure\n");
  96         return ;
  97     }
  98     //spin_lock(&ft1000dev->device_lock);
  99
 100     if(waitqueue_active(&ft1000dev->control_wait))
 101     {
 102         wake_up(&ft1000dev->control_wait);
 103     }
 104
 105     //DEBUG("FT1000_CONTROL_COMPLETE RETURNED\n");
 106     //spin_unlock(&ft1000dev->device_lock);
 107 }
 108
 109 //---------------------------------------------------------------------------
 110 // Function:    ft1000_control
 111 //
 112 // Parameters:  ft1000_device  - device structure
 113 //              pipe - usb control message pipe
 114 //              request - control request
 115 //              requesttype - control message request type
 116 //              value - value to be written or 0
 117 //              index - register index
 118 //              data - data buffer to hold the read/write values
 119 //              size - data size
 120 //              timeout - control message time out value
 121 //
 122 // Returns:     STATUS_SUCCESS - success
 123 //              STATUS_FAILURE - failure
 124 //
 125 // Description: This function sends a control message via USB interface synchronously
 126 //
 127 // Notes:
 128 //
 129 //---------------------------------------------------------------------------
 130 static int ft1000_control(struct ft1000_device *ft1000dev,unsigned int pipe,
 131                           u8 request,
 132                           u8 requesttype,
 133                           u16 value,
 134                           u16 index,
 135                           void *data,
 136                           u16 size,
 137                           int timeout)
 138 {
 139         u16 ret;
 140
 141     if (ft1000dev == NULL )
 142     {
 143         DEBUG("NULL ft1000dev, failure\n");
 144         return STATUS_FAILURE;
 145     }
 146     else if ( ft1000dev->dev == NULL )
 147     {
 148         DEBUG("NULL ft1000dev->dev, failure\n");
 149         return STATUS_FAILURE;
 150     }
 151
 152     ret = usb_control_msg(ft1000dev->dev,
 153                           pipe,
 154                           request,
 155                           requesttype,
 156                           value,
 157                           index,
 158                           data,
 159                           size,
 160                           LARGE_TIMEOUT);
 161
 162     if (ret>0)
 163         ret = STATUS_SUCCESS;
 164     else
 165         ret = STATUS_FAILURE;
 166
 167
 168     return ret;
 169
 170
 171 }
 172 //---------------------------------------------------------------------------
 173 // Function:    ft1000_read_register
 174 //
 175 // Parameters:  ft1000_device  - device structure
 176 //              Data - data buffer to hold the value read
 177 //              nRegIndex - register index
 178 //
 179 // Returns:     STATUS_SUCCESS - success
 180 //              STATUS_FAILURE - failure
 181 //
 182 // Description: This function returns the value in a register
 183 //
 184 // Notes:
 185 //
 186 //---------------------------------------------------------------------------
 187
 188 u16 ft1000_read_register(struct ft1000_device *ft1000dev, u16* Data, u16 nRegIndx)
 189 {
 190     u16 ret = STATUS_SUCCESS;
 191
 192     //DEBUG("ft1000_read_register: reg index is %d\n", nRegIndx);
 193     //DEBUG("ft1000_read_register: spin_lock locked\n");
 194     ret = ft1000_control(ft1000dev,
 195                          usb_rcvctrlpipe(ft1000dev->dev,0),
 196                          HARLEY_READ_REGISTER,   //request --READ_REGISTER
 197                          HARLEY_READ_OPERATION,  //requestType
 198                          0,                      //value
 199                          nRegIndx,               //index
 200                          Data,                   //data
 201                          2,                      //data size
 202                          LARGE_TIMEOUT );        //timeout
 203
 204    //DEBUG("ft1000_read_register: ret is  %d \n", ret);
 205
 206    //DEBUG("ft1000_read_register: data is  %x \n", *Data);
 207    if ( ret != STATUS_SUCCESS )
 208        return STATUS_FAILURE;
 209
 210    return ret;
 211
 212 }
 213
 214 //---------------------------------------------------------------------------
 215 // Function:    ft1000_write_register
 216 //
 217 // Parameters:  ft1000_device  - device structure
 218 //              value - value to write into a register
 219 //              nRegIndex - register index
 220 //
 221 // Returns:     STATUS_SUCCESS - success
 222 //              STATUS_FAILURE - failure
 223 //
 224 // Description: This function writes the value in a register
 225 //
 226 // Notes:
 227 //
 228 //---------------------------------------------------------------------------
 229 u16 ft1000_write_register(struct ft1000_device *ft1000dev, USHORT value, u16 nRegIndx)
 230 {
 231      u16 ret = STATUS_SUCCESS;
 232
 233      //DEBUG("ft1000_write_register: value is: %d, reg index is: %d\n", value, nRegIndx);
 234
 235      ret = ft1000_control(ft1000dev,
 236                            usb_sndctrlpipe(ft1000dev->dev, 0),
 237                            HARLEY_WRITE_REGISTER,       //request -- WRITE_REGISTER
 238                            HARLEY_WRITE_OPERATION,      //requestType
 239                            value,
 240                            nRegIndx,
 241                            NULL,
 242                            0,
 243                            LARGE_TIMEOUT );
 244
 245    if ( ret != STATUS_SUCCESS )
 246        return STATUS_FAILURE;
 247
 248     return ret;
 249 }
 250
 251 //---------------------------------------------------------------------------
 252 // Function:    ft1000_read_dpram32
 253 //
 254 // Parameters:  ft1000_device  - device structure
 255 //              indx - starting address to read
 256 //              buffer - data buffer to hold the data read
 257 //              cnt - number of byte read from DPRAM
 258 //
 259 // Returns:     STATUS_SUCCESS - success
 260 //              STATUS_FAILURE - failure
 261 //
 262 // Description: This function read a number of bytes from DPRAM
 263 //
 264 // Notes:
 265 //
 266 //---------------------------------------------------------------------------
 267
 268 u16 ft1000_read_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, USHORT cnt)
 269 {
 270     u16 ret = STATUS_SUCCESS;
 271
 272     //DEBUG("ft1000_read_dpram32: indx: %d  cnt: %d\n", indx, cnt);
 273     ret =ft1000_control(ft1000dev,
 274                          usb_rcvctrlpipe(ft1000dev->dev,0),
 275                          HARLEY_READ_DPRAM_32,                //request --READ_DPRAM_32
 276                          HARLEY_READ_OPERATION,               //requestType
 277                          0,                                   //value
 278                          indx,                                //index
 279                          buffer,                              //data
 280                          cnt,                                 //data size
 281                          LARGE_TIMEOUT );                     //timeout
 282
 283    //DEBUG("ft1000_read_dpram32: ret is  %d \n", ret);
 284
 285    //DEBUG("ft1000_read_dpram32: ret=%d \n", ret);
 286    if ( ret != STATUS_SUCCESS )
 287        return STATUS_FAILURE;
 288
 289    return ret;
 290
 291 }
 292
 293 //---------------------------------------------------------------------------
 294 // Function:    ft1000_write_dpram32
 295 //
 296 // Parameters:  ft1000_device  - device structure
 297 //              indx - starting address to write the data
 298 //              buffer - data buffer to write into DPRAM
 299 //              cnt - number of bytes to write
 300 //
 301 // Returns:     STATUS_SUCCESS - success
 302 //              STATUS_FAILURE - failure
 303 //
 304 // Description: This function writes into DPRAM a number of bytes
 305 //
 306 // Notes:
 307 //
 308 //---------------------------------------------------------------------------
 309 u16 ft1000_write_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, USHORT cnt)
 310 {
 311      u16 ret = STATUS_SUCCESS;
 312
 313      //DEBUG("ft1000_write_dpram32: indx: %d   buffer: %x cnt: %d\n", indx, buffer, cnt);
 314      if ( cnt % 4)
 315          cnt += cnt - (cnt % 4);
 316
 317      ret = ft1000_control(ft1000dev,
 318                            usb_sndctrlpipe(ft1000dev->dev, 0),
 319                            HARLEY_WRITE_DPRAM_32,              //request -- WRITE_DPRAM_32
 320                            HARLEY_WRITE_OPERATION,             //requestType
 321                            0,                                  //value
 322                            indx,                               //index
 323                            buffer,                             //buffer
 324                            cnt,                                //buffer size
 325                            LARGE_TIMEOUT );
 326
 327
 328    if ( ret != STATUS_SUCCESS )
 329        return STATUS_FAILURE;
 330
 331
 332     return ret;
 333 }
 334
 335 //---------------------------------------------------------------------------
 336 // Function:    ft1000_read_dpram16
 337 //
 338 // Parameters:  ft1000_device  - device structure
 339 //              indx - starting address to read
 340 //              buffer - data buffer to hold the data read
 341 //              hightlow - high or low 16 bit word
 342 //
 343 // Returns:     STATUS_SUCCESS - success
 344 //              STATUS_FAILURE - failure
 345 //
 346 // Description: This function read 16 bits from DPRAM
 347 //
 348 // Notes:
 349 //
 350 //---------------------------------------------------------------------------
 351 u16 ft1000_read_dpram16(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, u8 highlow)
 352 {
 353     u16 ret = STATUS_SUCCESS;
 354
 355     //DEBUG("ft1000_read_dpram16: indx: %d  hightlow: %d\n", indx, highlow);
 356
 357     u8 request;
 358
 359     if (highlow == 0 )
 360         request = HARLEY_READ_DPRAM_LOW;
 361     else
 362         request = HARLEY_READ_DPRAM_HIGH;
 363
 364     ret = ft1000_control(ft1000dev,
 365                          usb_rcvctrlpipe(ft1000dev->dev,0),
 366                          request,                     //request --READ_DPRAM_H/L
 367                          HARLEY_READ_OPERATION,       //requestType
 368                          0,                           //value
 369                          indx,                        //index
 370                          buffer,                      //data
 371                          2,                           //data size
 372                          LARGE_TIMEOUT );             //timeout
 373
 374    //DEBUG("ft1000_read_dpram16: ret is  %d \n", ret);
 375
 376
 377    //DEBUG("ft1000_read_dpram16: data is  %x \n", *buffer);
 378    if ( ret != STATUS_SUCCESS )
 379        return STATUS_FAILURE;
 380
 381    return ret;
 382
 383 }
 384
 385 //---------------------------------------------------------------------------
 386 // Function:    ft1000_write_dpram16
 387 //
 388 // Parameters:  ft1000_device  - device structure
 389 //              indx - starting address to write the data
 390 //              value - 16bits value to write
 391 //              hightlow - high or low 16 bit word
 392 //
 393 // Returns:     STATUS_SUCCESS - success
 394 //              STATUS_FAILURE - failure
 395 //
 396 // Description: This function writes into DPRAM a number of bytes
 397 //
 398 // Notes:
 399 //
 400 //---------------------------------------------------------------------------
 401 u16 ft1000_write_dpram16(struct ft1000_device *ft1000dev, USHORT indx, USHORT value, u8 highlow)
 402 {
 403      u16 ret = STATUS_SUCCESS;
 404
 405
 406
 407      //DEBUG("ft1000_write_dpram16: indx: %d  value: %d  highlow: %d\n", indx, value, highlow);
 408
 409      u8 request;
 410
 411
 412      if ( highlow == 0 )
 413          request = HARLEY_WRITE_DPRAM_LOW;
 414      else
 415          request = HARLEY_WRITE_DPRAM_HIGH;
 416
 417      ret = ft1000_control(ft1000dev,
 418                            usb_sndctrlpipe(ft1000dev->dev, 0),
 419                            request,                             //request -- WRITE_DPRAM_H/L
 420                            HARLEY_WRITE_OPERATION,              //requestType
 421                            value,                                   //value
 422                            indx,                                //index
 423                            NULL,                               //buffer
 424                            0,                                   //buffer size
 425                            LARGE_TIMEOUT );
 426
 427
 428    if ( ret != STATUS_SUCCESS )
 429        return STATUS_FAILURE;
 430
 431
 432     return ret;
 433 }
 434
 435 //---------------------------------------------------------------------------
 436 // Function:    fix_ft1000_read_dpram32
 437 //
 438 // Parameters:  ft1000_device  - device structure
 439 //              indx - starting address to read
 440 //              buffer - data buffer to hold the data read
 441 //
 442 //
 443 // Returns:     STATUS_SUCCESS - success
 444 //              STATUS_FAILURE - failure
 445 //
 446 // Description: This function read DPRAM 4 words at a time
 447 //
 448 // Notes:
 449 //
 450 //---------------------------------------------------------------------------
 451 u16 fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer)
 452 {
 453     UCHAR buf[16];
 454     USHORT pos;
 455     u16 ret = STATUS_SUCCESS;
 456
 457     //DEBUG("fix_ft1000_read_dpram32: indx: %d  \n", indx);
 458     pos = (indx / 4)*4;
 459     ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
 460     if (ret == STATUS_SUCCESS)
 461     {
 462         pos = (indx % 4)*4;
 463         *buffer++ = buf[pos++];
 464         *buffer++ = buf[pos++];
 465         *buffer++ = buf[pos++];
 466         *buffer++ = buf[pos++];
 467     }
 468     else
 469     {
 470         DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
 471         *buffer++ = 0;
 472         *buffer++ = 0;
 473         *buffer++ = 0;
 474         *buffer++ = 0;
 475
 476     }
 477
 478    //DEBUG("fix_ft1000_read_dpram32: data is  %x \n", *buffer);
 479    return ret;
 480
 481 }
 482
 483
 484 //---------------------------------------------------------------------------
 485 // Function:    fix_ft1000_write_dpram32
 486 //
 487 // Parameters:  ft1000_device  - device structure
 488 //              indx - starting address to write
 489 //              buffer - data buffer to write
 490 //
 491 //
 492 // Returns:     STATUS_SUCCESS - success
 493 //              STATUS_FAILURE - failure
 494 //
 495 // Description: This function write to DPRAM 4 words at a time
 496 //
 497 // Notes:
 498 //
 499 //---------------------------------------------------------------------------
 500 u16 fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer)
 501 {
 502     USHORT pos1;
 503     USHORT pos2;
 504     USHORT i;
 505     UCHAR buf[32];
 506     UCHAR resultbuffer[32];
 507     PUCHAR pdata;
 508     u16 ret  = STATUS_SUCCESS;
 509
 510     //DEBUG("fix_ft1000_write_dpram32: Entered:\n");
 511
 512     pos1 = (indx / 4)*4;
 513     pdata = buffer;
 514     ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
 515     if (ret == STATUS_SUCCESS)
 516     {
 517         pos2 = (indx % 4)*4;
 518         buf[pos2++] = *buffer++;
 519         buf[pos2++] = *buffer++;
 520         buf[pos2++] = *buffer++;
 521         buf[pos2++] = *buffer++;
 522         ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
 523     }
 524     else
 525     {
 526         DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
 527
 528         return ret;
 529     }
 530
 531     ret = ft1000_read_dpram32(ft1000dev, pos1, (PUCHAR)&resultbuffer[0], 16);
 532     if (ret == STATUS_SUCCESS)
 533     {
 534         buffer = pdata;
 535         for (i=0; i<16; i++)
 536         {
 537             if (buf[i] != resultbuffer[i]){
 538
 539                 ret = STATUS_FAILURE;
 540             }
 541         }
 542     }
 543
 544     if (ret == STATUS_FAILURE)
 545     {
 546         ret = ft1000_write_dpram32(ft1000dev, pos1, (PUCHAR)&tempbuffer[0], 16);
 547         ret = ft1000_read_dpram32(ft1000dev, pos1, (PUCHAR)&resultbuffer[0], 16);
 548         if (ret == STATUS_SUCCESS)
 549         {
 550             buffer = pdata;
 551             for (i=0; i<16; i++)
 552             {
 553                 if (tempbuffer[i] != resultbuffer[i])
 554                 {
 555                     ret = STATUS_FAILURE;
 556                     DEBUG("fix_ft1000_write_dpram32 Failed to write\n");
 557                 }
 558             }
 559          }
 560     }
 561
 562     return ret;
 563
 564 }
 565
 566
 567 //------------------------------------------------------------------------
 568 //
 569 //  Function:   card_reset_dsp
 570 //
 571 //  Synopsis:   This function is called to reset or activate the DSP
 572 //
 573 //  Arguments:  value                  - reset or activate
 574 //
 575 //  Returns:    None
 576 //-----------------------------------------------------------------------
 577 static void card_reset_dsp (struct ft1000_device *ft1000dev, BOOLEAN value)
 578 {
 579     u16 status = STATUS_SUCCESS;
 580     USHORT tempword;
 581
 582     status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
 583     status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_CTRL);
 584     if (value)
 585     {
 586         DEBUG("Reset DSP\n");
 587         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 588         tempword |= DSP_RESET_BIT;
 589         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 590     }
 591     else
 592     {
 593         DEBUG("Activate DSP\n");
 594         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 595 #if 1
 596         tempword |= DSP_ENCRYPTED;
 597         tempword &= ~DSP_UNENCRYPTED;
 598 #else
 599         tempword |= DSP_UNENCRYPTED;
 600         tempword &= ~DSP_ENCRYPTED;
 601 #endif
 602         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 603         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 604         tempword &= ~EFUSE_MEM_DISABLE;
 605         tempword &= ~DSP_RESET_BIT;
 606         status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 607         status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 608     }
 609 }
 610
 611 //---------------------------------------------------------------------------
 612 // Function:    CardSendCommand
 613 //
 614 // Parameters:  ft1000_device  - device structure
 615 //              ptempbuffer - command buffer
 616 //              size - command buffer size
 617 //
 618 // Returns:     STATUS_SUCCESS - success
 619 //              STATUS_FAILURE - failure
 620 //
 621 // Description: This function sends a command to ASIC
 622 //
 623 // Notes:
 624 //
 625 //---------------------------------------------------------------------------
 626 void CardSendCommand(struct ft1000_device *ft1000dev, void *ptempbuffer, int size)
 627 {
 628     unsigned short temp;
 629     unsigned char *commandbuf;
 630
 631     DEBUG("CardSendCommand: enter CardSendCommand... size=%d\n", size);
 632
 633     commandbuf =(unsigned char*) kmalloc(size+2, GFP_KERNEL);
 634     //memset((void*)commandbuf, 0, size+2);
 635     memcpy((void*)commandbuf+2, (void*)ptempbuffer, size);
 636
 637     //DEBUG("CardSendCommand: Command Send\n");
 638     /***
 639     for (i=0; i<size+2; i++)
 640     {
 641         DEBUG("FT1000:ft1000_ChIoctl: data %d = 0x%x\n", i, *ptr++);
 642     }
 643     ***/
 644
 645     ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 646
 647     if (temp & 0x0100)
 648     {
 649        msleep(10);
 650     }
 651
 652     // check for odd word
 653     size = size + 2;
 654     if (size % 4)
 655     {
 656        // Must force to be 32 bit aligned
 657        size += 4 - (size % 4);
 658     }
 659
 660
 661     //DEBUG("CardSendCommand: write dpram ... size=%d\n", size);
 662     ft1000_write_dpram32(ft1000dev, 0,commandbuf, size);
 663     msleep(1);
 664     //DEBUG("CardSendCommand: write into doorbell ...\n");
 665     ft1000_write_register(ft1000dev,  FT1000_DB_DPRAM_TX ,FT1000_REG_DOORBELL) ;
 666     msleep(1);
 667
 668     ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
 669     //DEBUG("CardSendCommand: read doorbell ...temp=%x\n", temp);
 670     if ( (temp & 0x0100) == 0)
 671     {
 672        //DEBUG("CardSendCommand: Message sent\n");
 673     }
 674
 675 }
 676
 677
 678 //--------------------------------------------------------------------------
 679 //
 680 //  Function:   dsp_reload
 681 //
 682 //  Synopsis:   This function is called to load or reload the DSP
 683 //
 684 //  Arguments:  ft1000dev - device structure
 685 //
 686 //  Returns:    None
 687 //-----------------------------------------------------------------------
 688 void dsp_reload (struct ft1000_device *ft1000dev)
 689 {
 690     u16 status;
 691     USHORT tempword;
 692     ULONG templong;
 693
 694     PFT1000_INFO pft1000info;
 695
 696     pft1000info = netdev_priv(ft1000dev->net);
 697
 698     pft1000info->CardReady = 0;
 699     pft1000info->DSP_loading= 1;
 700
 701     // Program Interrupt Mask register
 702     status = ft1000_write_register (ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
 703
 704     status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
 705     tempword |= ASIC_RESET_BIT;
 706     status = ft1000_write_register (ft1000dev, tempword, FT1000_REG_RESET);
 707     msleep(1000);
 708     status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
 709     DEBUG("Reset Register = 0x%x\n", tempword);
 710
 711     // Toggle DSP reset
 712     card_reset_dsp (ft1000dev, 1);
 713     msleep(1000);
 714     card_reset_dsp (ft1000dev, 0);
 715     msleep(1000);
 716
 717     status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
 718
 719     // Let's check for FEFE
 720     status = ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (PUCHAR)&templong, 4);
 721     DEBUG("templong (fefe) = 0x%8x\n", templong);
 722
 723     // call codeloader
 724     status = scram_dnldr(ft1000dev, pFileStart, FileLength);
 725
 726     if ( status != STATUS_SUCCESS)
 727        return;
 728
 729     msleep(1000);
 730     pft1000info->DSP_loading= 0;
 731
 732     DEBUG("dsp_reload returned\n");
 733
 734
 735 }
 736
 737 //---------------------------------------------------------------------------
 738 //
 739 // Function:   ft1000_reset_asic
 740 // Descripton: This function will call the Card Service function to reset the
 741 //             ASIC.
 742 // Input:
 743 //     dev    - device structure
 744 // Output:
 745 //     none
 746 //
 747 //---------------------------------------------------------------------------
 748 static void ft1000_reset_asic (struct net_device *dev)
 749 {
 750     FT1000_INFO *info = netdev_priv(dev);
 751     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 752     u16 tempword;
 753
 754     DEBUG("ft1000_hw:ft1000_reset_asic called\n");
 755
 756     info->ASICResetNum++;
 757
 758     // Let's use the register provided by the Magnemite ASIC to reset the
 759     // ASIC and DSP.
 760     ft1000_write_register(ft1000dev,  (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
 761
 762     mdelay(1);
 763
 764     // set watermark to -1 in order to not generate an interrrupt
 765     ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
 766
 767     // clear interrupts
 768     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
 769     DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
 770     ft1000_write_register (ft1000dev,  tempword, FT1000_REG_SUP_ISR);
 771     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
 772     DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
 773
 774 }
 775 /*
 776 //---------------------------------------------------------------------------
 777 //
 778 // Function:   ft1000_disable_interrupts
 779 // Descripton: This function will disable all interrupts.
 780 // Input:
 781 //     dev    - device structure
 782 // Output:
 783 //     None.
 784 //
 785 //---------------------------------------------------------------------------
 786 static void ft1000_disable_interrupts(struct net_device *dev) {
 787     FT1000_INFO *info = netdev_priv(dev);
 788     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 789     u16 tempword;
 790
 791     DEBUG("ft1000_hw: ft1000_disable_interrupts()\n");
 792     ft1000_write_register (ft1000dev, ISR_MASK_ALL, FT1000_REG_SUP_IMASK);
 793     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_IMASK);
 794     DEBUG("ft1000_hw:ft1000_disable_interrupts:current interrupt enable mask = 0x%x\n", tempword);
 795     info->InterruptsEnabled = FALSE;
 796 }
 797
 798 //---------------------------------------------------------------------------
 799 //
 800 // Function:   ft1000_enable_interrupts
 801 // Descripton: This function will enable interrupts base on the current interrupt mask.
 802 // Input:
 803 //     dev    - device structure
 804 // Output:
 805 //     None.
 806 //
 807 //---------------------------------------------------------------------------
 808 static void ft1000_enable_interrupts(struct net_device *dev) {
 809     FT1000_INFO *info = netdev_priv(dev);
 810     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 811     u16 tempword;
 812
 813     DEBUG("ft1000_hw:ft1000_enable_interrupts()\n");
 814     ft1000_write_register (ft1000dev, info->CurrentInterruptEnableMask, FT1000_REG_SUP_IMASK);
 815     ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_IMASK);
 816     DEBUG("ft1000_hw:ft1000_enable_interrupts:current interrupt enable mask = 0x%x\n", tempword);
 817     info->InterruptsEnabled = TRUE;
 818 }
 819 */
 820
 821 //---------------------------------------------------------------------------
 822 //
 823 // Function:   ft1000_reset_card
 824 // Descripton: This function will reset the card
 825 // Input:
 826 //     dev    - device structure
 827 // Output:
 828 //     status - FALSE (card reset fail)
 829 //              TRUE  (card reset successful)
 830 //
 831 //---------------------------------------------------------------------------
 832 static int ft1000_reset_card (struct net_device *dev)
 833 {
 834     FT1000_INFO *info = netdev_priv(dev);
 835     struct ft1000_device *ft1000dev = info->pFt1000Dev;
 836     u16 tempword;
 837     PPROV_RECORD ptr;
 838
 839     DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
 840
 841     info->fCondResetPend = 1;
 842     info->CardReady = 0;
 843     info->fProvComplete = 0;
 844     //ft1000_disable_interrupts(dev);
 845
 846     // Cancel heartbeat task since we are reloading the dsp
 847     //del_timer(&poll_timer[info->CardNumber]);
 848
 849     // Make sure we free any memory reserve for provisioning
 850     while (list_empty(&info->prov_list) == 0) {
 851         DEBUG("ft1000_hw:ft1000_reset_card:deleting provisioning record\n");
 852         ptr = list_entry(info->prov_list.next, PROV_RECORD, list);
 853         list_del(&ptr->list);
 854         kfree(ptr->pprov_data);
 855         kfree(ptr);
 856     }
 857
 858     DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
 859     //reset ASIC
 860     ft1000_reset_asic(dev);
 861
 862     info->DSPResetNum++;
 863
 864 #if 0
 865     DEBUG("ft1000_hw:ft1000_reset_card:resetting ASIC and DSP\n");
 866     ft1000_write_register (ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
 867
 868
 869     // Copy DSP session record into info block if this is not a coldstart
 870     //if (ft1000_card_present == 1) {
 871         spin_lock_irqsave(&info->dpram_lock, flags);
 872
 873             ft1000_write_register(ft1000dev,  FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
 874             for (i=0;i<MAX_DSP_SESS_REC/2; i++) {
 875                 //info->DSPSess.MagRec[i] = inl(dev->base_addr+FT1000_REG_MAG_DPDATA);
 876                 ft1000_read_dpram32(ft1000dev, FT1000_REG_MAG_DPDATA, (PCHAR)&(info->DSPSess.MagRec[i]), 4);
 877             }
 878
 879         spin_unlock_irqrestore(&info->dpram_lock, flags);
 880     //}
 881     info->squeseqnum = 0;
 882
 883     DEBUG("ft1000_hw:ft1000_reset_card:resetting ASIC\n");
 884     mdelay(10);
 885     //reset ASIC
 886     ft1000_reset_asic(dev);
 887
 888     info->DSPResetNum++;
 889
 890     DEBUG("ft1000_hw:ft1000_reset_card:downloading dsp image\n");
 891
 892
 893         // Put dsp in reset and take ASIC out of reset
 894         DEBUG("ft1000_hw:ft1000_reset_card:Put DSP in reset and take ASIC out of reset\n");
 895         ft1000_write_register (ft1000dev, DSP_RESET_BIT, FT1000_REG_RESET);
 896
 897         // Setting MAGNEMITE ASIC to big endian mode
 898         ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
 899
 900         // Take DSP out of reset
 901
 902            ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
 903            tempword |= DSP_ENCRYPTED;
 904            tempword &= ~DSP_UNENCRYPTED;
 905            ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 906            tempword &= ~EFUSE_MEM_DISABLE;
 907            ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 908            tempword &= ~DSP_RESET_BIT;
 909            ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
 910
 911
 912         // FLARION_DSP_ACTIVE;
 913         mdelay(10);
 914         DEBUG("ft1000_hw:ft1000_reset_card:Take DSP out of reset\n");
 915
 916         // Wait for 0xfefe indicating dsp ready before starting download
 917         for (i=0; i<50; i++) {
 918             //tempword = ft1000_read_dpram_mag_16(dev, FT1000_MAG_DPRAM_FEFE, FT1000_MAG_DPRAM_FEFE_INDX);
 919             ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (PUCHAR)&templong, 4);
 920             if (tempword == 0xfefe) {
 921                 break;
 922             }
 923             mdelay(20);
 924         }
 925
 926         if (i==50) {
 927             DEBUG("ft1000_hw:ft1000_reset_card:No FEFE detected from DSP\n");
 928             return FALSE;
 929         }
 930
 931
 932 #endif
 933
 934     DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
 935     dsp_reload(ft1000dev);
 936
 937     DEBUG("dsp reload successful\n");
 938
 939
 940     mdelay(10);
 941
 942     // Initialize DSP heartbeat area to ho
 943     ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag, FT1000_MAG_HI_HO_INDX);
 944     ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (PCHAR)&tempword, FT1000_MAG_HI_HO_INDX);
 945     DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
 946
 947
 948
 949     info->CardReady = 1;
 950     //ft1000_enable_interrupts(dev);
 951     /* Schedule heartbeat process to run every 2 seconds */
 952     //poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
 953     //poll_timer[info->CardNumber].data = (u_long)dev;
 954     //add_timer(&poll_timer[info->CardNumber]);
 955
 956     info->fCondResetPend = 0;
 957     return TRUE;
 958
 959 }
 960
 961
 962 //mbelian
 963 #ifdef HAVE_NET_DEVICE_OPS
 964 static const struct net_device_ops ftnet_ops =
 965 {
 966 .ndo_open = &ft1000_open,
 967 .ndo_stop = &ft1000_close,
 968 .ndo_start_xmit = &ft1000_start_xmit,
 969 .ndo_get_stats = &ft1000_netdev_stats,
 970 };
 971 #endif
 972
 973
 974 //---------------------------------------------------------------------------
 975 // Function:    init_ft1000_netdev
 976 //
 977 // Parameters:  ft1000dev  - device structure
 978 //
 979 //
 980 // Returns:     STATUS_SUCCESS - success
 981 //              STATUS_FAILURE - failure
 982 //
 983 // Description: This function initialize the network device
 984 //
 985 // Notes:
 986 //
 987 //---------------------------------------------------------------------------
 988 u16 init_ft1000_netdev(struct ft1000_device *ft1000dev)
 989 {
 990     struct net_device *netdev;
 991     FT1000_INFO *pInfo = NULL;
 992     PDPRAM_BLK pdpram_blk;
 993     int i;
 994         struct list_head *cur, *tmp;
 995
 996         gCardIndex=0; //mbelian
 997
 998     DEBUG("Enter init_ft1000_netdev...\n");
 999
1000
1001     netdev = alloc_etherdev( sizeof(FT1000_INFO));
1002     if (!netdev )
1003     {
1004         DEBUG("init_ft1000_netdev: can not allocate network device\n");
1005         return STATUS_FAILURE;
1006     }
1007
1008     //pInfo = (PFT1000_INFO)netdev->priv;
1009         pInfo = (FT1000_INFO *) netdev_priv (netdev);
1010
1011     //DEBUG("init_ft1000_netdev: gFt1000Info=%x, netdev=%x, ft1000dev=%x\n", gFt1000Info, netdev, ft1000dev);
1012
1013     memset (pInfo, 0, sizeof(FT1000_INFO));
1014
1015     dev_alloc_name(netdev, netdev->name);
1016
1017     //for the first inserted card, decide the card index beginning number, in case there are existing network interfaces
1018     if ( gCardIndex == 0 )
1019     {
1020         DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
1021
1022         if ( strncmp(netdev->name,"eth", 3) == 0) {
1023             //pInfo->CardNumber = atoi(&netdev->name[3]);
1024             gCardIndex = atoi(&netdev->name[3]);
1025             pInfo->CardNumber = gCardIndex;
1026             DEBUG("card number = %d\n", pInfo->CardNumber);
1027         }
1028         else {
1029             printk(KERN_ERR "ft1000: Invalid device name\n");
1030             free_netdev(netdev);
1031             return STATUS_FAILURE;
1032         }
1033     }
1034     else
1035     {
1036         //not the first inserted card, increase card number by 1
1037         /*gCardIndex ++;*/
1038         pInfo->CardNumber = gCardIndex;
1039         /*DEBUG("card number = %d\n", pInfo->CardNumber);*/ //mbelian
1040     }
1041
1042     memset(&pInfo->stats, 0, sizeof(struct net_device_stats) );
1043
1044    spin_lock_init(&pInfo->dpram_lock);
1045     pInfo->pFt1000Dev = ft1000dev;
1046     pInfo->DrvErrNum = 0;
1047     pInfo->ASICResetNum = 0;
1048     pInfo->registered = 1;
1049     pInfo->ft1000_reset = ft1000_reset;
1050     pInfo->mediastate = 0;
1051     pInfo->fifo_cnt = 0;
1052     pInfo->DeviceCreated = FALSE;
1053     pInfo->DeviceMajor = 0;
1054     pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
1055     pInfo->InterruptsEnabled = FALSE;
1056     pInfo->CardReady = 0;
1057     pInfo->DSP_loading = 0;
1058     pInfo->DSP_TIME[0] = 0;
1059     pInfo->DSP_TIME[1] = 0;
1060     pInfo->DSP_TIME[2] = 0;
1061     pInfo->DSP_TIME[3] = 0;
1062     pInfo->fAppMsgPend = 0;
1063     pInfo->fCondResetPend = 0;
1064         pInfo->usbboot = 0;
1065         pInfo->dspalive = 0;
1066         for (i=0;i<32 ;i++ )
1067         {
1068                 pInfo->tempbuf[i] = 0;
1069         }
1070
1071     INIT_LIST_HEAD(&pInfo->prov_list);
1072
1073 //mbelian
1074 #ifdef HAVE_NET_DEVICE_OPS
1075         netdev->netdev_ops = &ftnet_ops;
1076 #else
1077     netdev->hard_start_xmit = &ft1000_start_xmit;
1078     netdev->get_stats = &ft1000_netdev_stats;
1079     netdev->open = &ft1000_open;
1080     netdev->stop = &ft1000_close;
1081 #endif
1082
1083     //netif_stop_queue(netdev); //mbelian
1084
1085
1086     ft1000dev->net = netdev;
1087
1088
1089
1090 //init free_buff_lock, freercvpool, numofmsgbuf, pdpram_blk
1091 //only init once per card
1092 //Jim
1093           DEBUG("Initialize free_buff_lock and freercvpool\n");
1094         spin_lock_init(&free_buff_lock);
1095
1096         // initialize a list of buffers to be use for queuing up receive command data
1097         INIT_LIST_HEAD (&freercvpool);
1098
1099         // create list of free buffers
1100         for (i=0; i<NUM_OF_FREE_BUFFERS; i++) {
1101             // Get memory for DPRAM_DATA link list
1102             pdpram_blk = kmalloc ( sizeof(DPRAM_BLK), GFP_KERNEL );
1103             if (pdpram_blk == NULL)
1104                 goto err_free;
1105             // Get a block of memory to store command data
1106             pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );
1107             if (pdpram_blk->pbuffer == NULL) {
1108                 kfree(pdpram_blk);
1109                 goto err_free;
1110             }
1111             // link provisioning data
1112             list_add_tail (&pdpram_blk->list, &freercvpool);
1113         }
1114         numofmsgbuf = NUM_OF_FREE_BUFFERS;
1115
1116
1117     return STATUS_SUCCESS;
1118
1119
1120 err_free:
1121         list_for_each_safe(cur, tmp, &pdpram_blk->list) {
1122                 pdpram_blk = list_entry(cur, DPRAM_BLK, list);
1123                 list_del(&pdpram_blk->list);
1124                 kfree(pdpram_blk->pbuffer);
1125                 kfree(pdpram_blk);
1126         }
1127         return STATUS_FAILURE;
1128 }
1129
1130
1131
1132 //---------------------------------------------------------------------------
1133 // Function:    reg_ft1000_netdev
1134 //
1135 // Parameters:  ft1000dev  - device structure
1136 //
1137 //
1138 // Returns:     STATUS_SUCCESS - success
1139 //              STATUS_FAILURE - failure
1140 //
1141 // Description: This function register the network driver
1142 //
1143 // Notes:
1144 //
1145 //---------------------------------------------------------------------------
1146 u16 reg_ft1000_netdev(struct ft1000_device *ft1000dev, struct usb_interface *intf)
1147 {
1148     struct net_device *netdev;
1149     FT1000_INFO *pInfo;
1150     int i, rc;
1151
1152     netdev = ft1000dev->net;
1153     pInfo = netdev_priv(ft1000dev->net);
1154     DEBUG("Enter reg_ft1000_netdev...\n");
1155
1156
1157     ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
1158
1159     usb_set_intfdata(intf, pInfo);
1160     SET_NETDEV_DEV(netdev, &intf->dev);
1161
1162     rc = register_netdev(netdev);
1163     if (rc)
1164     {
1165         DEBUG("reg_ft1000_netdev: could not register network device\n");
1166         free_netdev(netdev);
1167         return STATUS_FAILURE;
1168     }
1169
1170
1171     //Create character device, implemented by Jim
1172     ft1000_CreateDevice(ft1000dev);
1173
1174     //INIT_LIST_HEAD(&pInfo->prov_list);
1175
1176     for (i=0; i<MAX_NUM_CARDS; i++) {
1177         poll_timer[i].function = ft1000_hbchk;
1178     }
1179
1180
1181     //hard code MAC address for now
1182 /**
1183     netdev->dev_addr[0] = 0;
1184     netdev->dev_addr[1] = 7;
1185     netdev->dev_addr[2] = 0x35;
1186     netdev->dev_addr[3] = 0x84;
1187     netdev->dev_addr[4] = 0;
1188     netdev->dev_addr[5] = 0x20 + pInfo->CardNumber;
1189 **/
1190
1191     DEBUG ("reg_ft1000_netdev returned\n");
1192
1193     pInfo->CardReady = 1;
1194
1195
1196    return STATUS_SUCCESS;
1197 }
1198
1199 static int ft1000_reset(struct net_device *dev)
1200 {
1201     ft1000_reset_card(dev);
1202     return 0;
1203 }
1204
1205 //---------------------------------------------------------------------------
1206 // Function:    ft1000_usb_transmit_complete
1207 //
1208 // Parameters:  urb  - transmitted usb urb
1209 //
1210 //
1211 // Returns:     none
1212 //
1213 // Description: This is the callback function when a urb is transmitted
1214 //
1215 // Notes:
1216 //
1217 //---------------------------------------------------------------------------
1218 static void ft1000_usb_transmit_complete(struct urb *urb)
1219 {
1220
1221     struct ft1000_device *ft1000dev = urb->context;
1222
1223     //DEBUG("ft1000_usb_transmit_complete entered\n");
1224 // Jim   spin_lock(&ft1000dev->device_lock);
1225
1226     if (urb->status)
1227         printk("%s: TX status %d\n", ft1000dev->net->name, urb->status);
1228
1229     netif_wake_queue(ft1000dev->net);
1230
1231 //Jim    spin_unlock(&ft1000dev->device_lock);
1232     //DEBUG("Return from ft1000_usb_transmit_complete\n");
1233 }
1234
1235
1236 /****************************************************************
1237  *     ft1000_control
1238  ****************************************************************/
1239 static int ft1000_read_fifo_reg(struct ft1000_device *ft1000dev,unsigned int pipe,
1240                           u8 request,
1241                           u8 requesttype,
1242                           u16 value,
1243                           u16 index,
1244                           void *data,
1245                           u16 size,
1246                           int timeout)
1247 {
1248     u16 ret;
1249
1250     DECLARE_WAITQUEUE(wait, current);
1251     struct urb *urb;
1252     struct usb_ctrlrequest *dr;
1253     int status;
1254
1255     if (ft1000dev == NULL )
1256     {
1257         DEBUG("NULL ft1000dev, failure\n");
1258         return STATUS_FAILURE;
1259     }
1260     else if ( ft1000dev->dev == NULL )
1261     {
1262         DEBUG("NULL ft1000dev->dev, failure\n");
1263         return STATUS_FAILURE;
1264     }
1265
1266     spin_lock(&ft1000dev->device_lock);
1267
1268     /*DECLARE_WAITQUEUE(wait, current);
1269     struct urb *urb;
1270     struct usb_ctrlrequest *dr;
1271     int status;*/
1272
1273     if(in_interrupt())
1274     {
1275         spin_unlock(&ft1000dev->device_lock);
1276         return -EBUSY;
1277     }
1278
1279     urb = usb_alloc_urb(0, GFP_KERNEL);
1280     dr = kmalloc(sizeof(struct usb_ctrlrequest), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
1281
1282     if(!urb || !dr)
1283     {
1284         kfree(dr);
1285         usb_free_urb(urb);
1286         spin_unlock(&ft1000dev->device_lock);
1287         return -ENOMEM;
1288     }
1289
1290
1291
1292     dr->bRequestType = requesttype;
1293     dr->bRequest = request;
1294     dr->wValue = value;
1295     dr->wIndex = index;
1296     dr->wLength = size;
1297
1298     usb_fill_control_urb(urb, ft1000dev->dev, pipe, (char*)dr, (void*)data, size, (void *)ft1000_control_complete, (void*)ft1000dev);
1299
1300
1301     init_waitqueue_head(&ft1000dev->control_wait);
1302
1303     //current->state = TASK_INTERRUPTIBLE; //mbelian
1304         set_current_state(TASK_INTERRUPTIBLE);
1305
1306     add_wait_queue(&ft1000dev->control_wait, &wait);
1307
1308
1309
1310
1311     status = usb_submit_urb(urb, GFP_KERNEL);
1312
1313     if(status)
1314     {
1315         usb_free_urb(urb);
1316         kfree(dr);
1317         remove_wait_queue(&ft1000dev->control_wait, &wait);
1318         spin_unlock(&ft1000dev->device_lock);
1319         return status;
1320     }
1321
1322     if(urb->status == -EINPROGRESS)
1323     {
1324         while(timeout && urb->status == -EINPROGRESS)
1325         {
1326             status = timeout = schedule_timeout(timeout);
1327         }
1328     }
1329     else
1330     {
1331         status = 1;
1332     }
1333
1334     remove_wait_queue(&ft1000dev->control_wait, &wait);
1335
1336     if(!status)
1337     {
1338         usb_unlink_urb(urb);
1339         printk("ft1000 timeout\n");
1340         status = -ETIMEDOUT;
1341     }
1342     else
1343     {
1344         status = urb->status;
1345
1346         if(urb->status)
1347         {
1348             printk("ft1000 control message failed (urb addr: %p) with error number: %i\n", urb, (int)status);
1349
1350             usb_clear_halt(ft1000dev->dev, usb_rcvctrlpipe(ft1000dev->dev, 0));
1351             usb_clear_halt(ft1000dev->dev, usb_sndctrlpipe(ft1000dev->dev, 0));
1352             usb_unlink_urb(urb);
1353         }
1354     }
1355
1356
1357
1358     usb_free_urb(urb);
1359     kfree(dr);
1360     spin_unlock(&ft1000dev->device_lock);
1361     return ret;
1362
1363
1364 }
1365
1366 //---------------------------------------------------------------------------
1367 // Function:    ft1000_read_fifo_len
1368 //
1369 // Parameters:  ft1000dev - device structure
1370 //
1371 //
1372 // Returns:     none
1373 //
1374 // Description: read the fifo length register content
1375 //
1376 // Notes:
1377 //
1378 //---------------------------------------------------------------------------
1379 static inline u16 ft1000_read_fifo_len (struct net_device *dev)
1380 {
1381     u16 temp;
1382     u16 ret;
1383
1384     //FT1000_INFO *info = (PFT1000_INFO)dev->priv;
1385         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev);
1386     struct ft1000_device *ft1000dev = info->pFt1000Dev;
1387 //    DEBUG("ft1000_read_fifo_len: enter ft1000dev %x\n", ft1000dev);                   //aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct ft1000_device *???
1388     DEBUG("ft1000_read_fifo_len: enter ft1000dev %p\n", ft1000dev);     //aelias [+] reason: up
1389     //ft1000_read_register(ft1000dev, &temp, FT1000_REG_MAG_UFSR);
1390
1391     ret = STATUS_SUCCESS;
1392
1393     ret = ft1000_read_fifo_reg(ft1000dev,
1394                           usb_rcvctrlpipe(ft1000dev->dev,0),
1395                           HARLEY_READ_REGISTER,
1396                           HARLEY_READ_OPERATION,
1397                           0,
1398                           FT1000_REG_MAG_UFSR,
1399                           &temp,
1400                           2,
1401                           LARGE_TIMEOUT);
1402
1403     if (ret>0)
1404         ret = STATUS_SUCCESS;
1405     else
1406         ret = STATUS_FAILURE;
1407
1408     DEBUG("ft1000_read_fifo_len: returned %d\n", temp);
1409
1410     return (temp- 16);
1411
1412 }
1413
1414
1415 //---------------------------------------------------------------------------
1416 //
1417 // Function:   ft1000_copy_down_pkt
1418 // Descripton: This function will take an ethernet packet and convert it to
1419 //             a Flarion packet prior to sending it to the ASIC Downlink
1420 //             FIFO.
1421 // Input:
1422 //     dev    - device structure
1423 //     packet - address of ethernet packet
1424 //     len    - length of IP packet
1425 // Output:
1426 //     status - FAILURE
1427 //              SUCCESS
1428 //
1429 //---------------------------------------------------------------------------
1430 static int ft1000_copy_down_pkt (struct net_device *netdev, u8 *packet, u16 len)
1431 {
1432     FT1000_INFO *pInfo = netdev_priv(netdev);
1433     struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
1434
1435
1436     int i, count, ret;
1437     USHORT *pTemp;
1438     USHORT checksum;
1439     u8 *t;
1440
1441     if (!pInfo->CardReady)
1442     {
1443
1444         DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
1445         return STATUS_FAILURE;
1446
1447     }
1448
1449
1450     //DEBUG("ft1000_copy_down_pkt() entered, len = %d\n", len);
1451
1452 #if 0
1453     // Check if there is room on the FIFO
1454     if ( len > ft1000_read_fifo_len (netdev) )
1455     {
1456          udelay(10);
1457          if ( len > ft1000_read_fifo_len (netdev) )
1458          {
1459              udelay(20);
1460          }
1461
1462          if ( len > ft1000_read_fifo_len (netdev) )
1463          {
1464              udelay(20);
1465          }
1466
1467          if ( len > ft1000_read_fifo_len (netdev) )
1468          {
1469              udelay(20);
1470          }
1471
1472          if ( len > ft1000_read_fifo_len (netdev) )
1473          {
1474              udelay(20);
1475          }
1476
1477          if ( len > ft1000_read_fifo_len (netdev) )
1478          {
1479              udelay(20);
1480          }
1481
1482          if ( len > ft1000_read_fifo_len (netdev) )
1483          {
1484             DEBUG("ft1000_hw:ft1000_copy_down_pkt:Transmit FIFO is fulli - pkt drop\n");
1485             pInfo->stats.tx_errors++;
1486             return STATUS_SUCCESS;
1487          }
1488     }
1489 #endif
1490
1491     count = sizeof (PSEUDO_HDR) + len;
1492     if(count > MAX_BUF_SIZE)
1493     {
1494         DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
1495         DEBUG("size = %d\n", count);
1496         return STATUS_FAILURE;
1497     }
1498
1499     if ( count % 4)
1500         count = count + (4- (count %4) );
1501
1502     pTemp = (PUSHORT)&(pFt1000Dev->tx_buf[0]);
1503     *pTemp ++ = ntohs(count);
1504     *pTemp ++ = 0x1020;
1505     *pTemp ++ = 0x2010;
1506     *pTemp ++ = 0x9100;
1507     *pTemp ++ = 0;
1508     *pTemp ++ = 0;
1509     *pTemp ++ = 0;
1510     pTemp = (PUSHORT)&(pFt1000Dev->tx_buf[0]);
1511     checksum = *pTemp ++;
1512     for (i=1; i<7; i++)
1513     {
1514         checksum ^= *pTemp ++;
1515     }
1516     *pTemp++ = checksum;
1517     memcpy (&(pFt1000Dev->tx_buf[sizeof(PSEUDO_HDR)]), packet, len);
1518
1519     //usb_init_urb(pFt1000Dev->tx_urb); //mbelian
1520
1521     netif_stop_queue(netdev);
1522
1523     //DEBUG ("ft1000_copy_down_pkt: count = %d\n", count);
1524
1525     usb_fill_bulk_urb(pFt1000Dev->tx_urb,
1526                       pFt1000Dev->dev,
1527                       usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr),
1528                       pFt1000Dev->tx_buf,
1529                       count,
1530                       ft1000_usb_transmit_complete,
1531                       (void*)pFt1000Dev);
1532
1533     t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
1534     //DEBUG("transfer_length=%d\n", pFt1000Dev->tx_urb->transfer_buffer_length);
1535     /*for (i=0; i<count; i++ )
1536     {
1537        DEBUG("%x    ", *t++ );
1538     }*/
1539
1540
1541     ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
1542     if(ret)
1543     {
1544                 DEBUG("ft1000 failed tx_urb %d\n", ret);
1545
1546    /*     pInfo->stats.tx_errors++;
1547
1548         netif_start_queue(netdev);  */  //mbelian
1549                 return STATUS_FAILURE;
1550
1551     }
1552     else
1553     {
1554         //DEBUG("ft1000 sucess tx_urb %d\n", ret);
1555
1556         pInfo->stats.tx_packets++;
1557         pInfo->stats.tx_bytes += (len+14);
1558     }
1559
1560     //DEBUG("ft1000_copy_down_pkt() exit\n");
1561
1562     return STATUS_SUCCESS;
1563 }
1564
1565 //---------------------------------------------------------------------------
1566 // Function:    ft1000_start_xmit
1567 //
1568 // Parameters:  skb - socket buffer to be sent
1569 //              dev - network device
1570 //
1571 //
1572 // Returns:     none
1573 //
1574 // Description: transmit a ethernet packet
1575 //
1576 // Notes:
1577 //
1578 //---------------------------------------------------------------------------
1579 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1580 {
1581     FT1000_INFO *pInfo = netdev_priv(dev);
1582     struct ft1000_device *pFt1000Dev= pInfo->pFt1000Dev;
1583     u8 *pdata;
1584     int maxlen, pipe;
1585
1586
1587     //DEBUG(" ft1000_start_xmit() entered\n");
1588
1589     if ( skb == NULL )
1590     {
1591         DEBUG ("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n" );
1592         return STATUS_FAILURE;
1593     }
1594
1595     if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1596     {
1597         DEBUG("network driver is closed, return\n");
1598         dev_kfree_skb(skb);
1599         //usb_kill_urb(pFt1000Dev->tx_urb); //mbelian
1600         return STATUS_SUCCESS;
1601     }
1602
1603     //DEBUG("ft1000_start_xmit 1:length of packet = %d\n", skb->len);
1604     pipe = usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1605     maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1606     //DEBUG("ft1000_start_xmit 2: pipe=%d dev->maxpacket  = %d\n", pipe, maxlen);
1607
1608     pdata = (u8 *)skb->data;
1609     /*for (i=0; i<skb->len; i++)
1610         DEBUG("skb->data[%d]=%x    ", i, *(skb->data+i));
1611
1612     DEBUG("\n");*/
1613
1614
1615     if (pInfo->mediastate == 0)
1616     {
1617         /* Drop packet is mediastate is down */
1618         DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1619         dev_kfree_skb(skb);
1620         return STATUS_SUCCESS;
1621     }
1622
1623     if ( (skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE) )
1624     {
1625         /* Drop packet which has invalid size */
1626         DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1627         dev_kfree_skb(skb);
1628         return STATUS_SUCCESS;
1629     }
1630 //mbelian
1631     if(ft1000_copy_down_pkt (dev, (pdata+ENET_HEADER_SIZE-2), skb->len - ENET_HEADER_SIZE + 2) == STATUS_FAILURE)
1632         {
1633         dev_kfree_skb(skb);
1634                 return STATUS_SUCCESS;
1635         }
1636
1637     dev_kfree_skb(skb);
1638     //DEBUG(" ft1000_start_xmit() exit\n");
1639
1640     return 0;
1641 }
1642
1643 //---------------------------------------------------------------------------
1644 //
1645 // Function:   ft1000_copy_up_pkt
1646 // Descripton: This function will take a packet from the FIFO up link and
1647 //             convert it into an ethernet packet and deliver it to the IP stack
1648 // Input:
1649 //     urb - the receving usb urb
1650 //
1651 // Output:
1652 //     status - FAILURE
1653 //              SUCCESS
1654 //
1655 //---------------------------------------------------------------------------
1656 static int ft1000_copy_up_pkt (struct urb *urb)
1657 {
1658     PFT1000_INFO info = urb->context;
1659     struct ft1000_device *ft1000dev = info->pFt1000Dev;
1660     struct net_device *net = ft1000dev->net;
1661
1662     u16 tempword;
1663     u16 len;
1664     u16 lena; //mbelian
1665     struct sk_buff *skb;
1666     u16 i;
1667     u8 *pbuffer=NULL;
1668     u8 *ptemp=NULL;
1669     u16 *chksum;
1670
1671
1672     //DEBUG("ft1000_copy_up_pkt entered\n");
1673
1674     if ( ft1000dev->status & FT1000_STATUS_CLOSING)
1675     {
1676         DEBUG("network driver is closed, return\n");
1677         return STATUS_SUCCESS;
1678     }
1679
1680     // Read length
1681     len = urb->transfer_buffer_length;
1682     lena = urb->actual_length; //mbelian
1683     //DEBUG("ft1000_copy_up_pkt: transfer_buffer_length=%d, actual_buffer_len=%d\n",
1684       //       urb->transfer_buffer_length, urb->actual_length);
1685
1686     chksum = (PUSHORT)ft1000dev->rx_buf;
1687
1688     tempword = *chksum++;
1689     for (i=1; i<7; i++)
1690     {
1691         tempword ^= *chksum++;
1692     }
1693
1694     if  (tempword != *chksum)
1695     {
1696         info->stats.rx_errors ++;
1697         ft1000_submit_rx_urb(info);
1698         return STATUS_FAILURE;
1699     }
1700
1701
1702     //DEBUG("ft1000_copy_up_pkt: checksum is correct %x\n", *chksum);
1703
1704     skb = dev_alloc_skb(len+12+2);
1705
1706     if (skb == NULL)
1707     {
1708         DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1709         info->stats.rx_errors++;
1710         ft1000_submit_rx_urb(info);
1711         return STATUS_FAILURE;
1712     }
1713
1714     pbuffer = (u8 *)skb_put(skb, len+12);
1715
1716     //subtract the number of bytes read already
1717     ptemp = pbuffer;
1718
1719     // fake MAC address
1720     *pbuffer++ = net->dev_addr[0];
1721     *pbuffer++ = net->dev_addr[1];
1722     *pbuffer++ = net->dev_addr[2];
1723     *pbuffer++ = net->dev_addr[3];
1724     *pbuffer++ = net->dev_addr[4];
1725     *pbuffer++ = net->dev_addr[5];
1726     *pbuffer++ = 0x00;
1727     *pbuffer++ = 0x07;
1728     *pbuffer++ = 0x35;
1729     *pbuffer++ = 0xff;
1730     *pbuffer++ = 0xff;
1731     *pbuffer++ = 0xfe;
1732
1733
1734
1735
1736     memcpy(pbuffer, ft1000dev->rx_buf+sizeof(PSEUDO_HDR), len-sizeof(PSEUDO_HDR));
1737
1738     //DEBUG("ft1000_copy_up_pkt: Data passed to Protocol layer\n");
1739     /*for (i=0; i<len+12; i++)
1740     {
1741         DEBUG("ft1000_copy_up_pkt: Protocol Data: 0x%x\n ", *ptemp++);
1742     }*/
1743
1744     skb->dev = net;
1745
1746     skb->protocol = eth_type_trans(skb, net);
1747     skb->ip_summed = CHECKSUM_UNNECESSARY;
1748     netif_rx(skb);
1749
1750     info->stats.rx_packets++;
1751     // Add on 12 bytes for MAC address which was removed
1752     info->stats.rx_bytes += (lena+12); //mbelian
1753
1754     ft1000_submit_rx_urb(info);
1755     //DEBUG("ft1000_copy_up_pkt exited\n");
1756     return SUCCESS;
1757 }
1758
1759 //---------------------------------------------------------------------------
1760 //
1761 // Function:   ft1000_submit_rx_urb
1762 // Descripton: the receiving function of the network driver
1763 //
1764 // Input:
1765 //     info - a private structure contains the device information
1766 //
1767 // Output:
1768 //     status - FAILURE
1769 //              SUCCESS
1770 //
1771 //---------------------------------------------------------------------------
1772 static int ft1000_submit_rx_urb(PFT1000_INFO info)
1773 {
1774     int result;
1775     struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1776
1777     //netif_carrier_on(pFt1000Dev->net);
1778
1779     //DEBUG ("ft1000_submit_rx_urb entered: sizeof rx_urb is %d\n", sizeof(*pFt1000Dev->rx_urb));
1780     if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1781     {
1782         DEBUG("network driver is closed, return\n");
1783         //usb_kill_urb(pFt1000Dev->rx_urb); //mbelian
1784         return STATUS_SUCCESS;
1785     }
1786     //memset(pFt1000Dev->rx_urb, 0, sizeof(*pFt1000Dev->rx_urb));
1787     //usb_init_urb(pFt1000Dev->rx_urb);//mbelian
1788
1789     //spin_lock_init(&pFt1000Dev->rx_urb->lock);
1790
1791     usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1792             pFt1000Dev->dev,
1793             usb_rcvbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_in_endpointAddr),
1794             pFt1000Dev->rx_buf,
1795             MAX_BUF_SIZE,
1796             (usb_complete_t)ft1000_copy_up_pkt,
1797             info);
1798
1799
1800     if((result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC)))
1801     {
1802         printk("ft1000_submit_rx_urb: submitting rx_urb %d failed\n", result);
1803         return STATUS_FAILURE;
1804     }
1805
1806     //DEBUG("ft1000_submit_rx_urb exit: result=%d\n", result);
1807
1808     return STATUS_SUCCESS;
1809 }
1810
1811 //---------------------------------------------------------------------------
1812 // Function:    ft1000_open
1813 //
1814 // Parameters:
1815 //              dev - network device
1816 //
1817 //
1818 // Returns:     none
1819 //
1820 // Description: open the network driver
1821 //
1822 // Notes:
1823 //
1824 //---------------------------------------------------------------------------
1825 static int ft1000_open (struct net_device *dev)
1826 {
1827         FT1000_INFO *pInfo = (FT1000_INFO *)netdev_priv(dev);
1828     struct timeval tv; //mbelian
1829
1830     DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1831     //DEBUG("ft1000_open: dev->addr=%x, dev->addr_len=%d\n", dev->addr, dev->addr_len);
1832
1833         pInfo->stats.rx_bytes = 0; //mbelian
1834         pInfo->stats.tx_bytes = 0; //mbelian
1835         pInfo->stats.rx_packets = 0; //mbelian
1836         pInfo->stats.tx_packets = 0; //mbelian
1837         do_gettimeofday(&tv);
1838     pInfo->ConTm = tv.tv_sec;
1839         pInfo->ProgConStat = 0; //mbelian
1840
1841
1842     netif_start_queue(dev);
1843
1844     //netif_device_attach(dev);
1845
1846     netif_carrier_on(dev); //mbelian
1847
1848     ft1000_submit_rx_urb(pInfo);
1849     return 0;
1850 }
1851
1852 //---------------------------------------------------------------------------
1853 // Function:    ft1000_close
1854 //
1855 // Parameters:
1856 //              net - network device
1857 //
1858 //
1859 // Returns:     none
1860 //
1861 // Description: close the network driver
1862 //
1863 // Notes:
1864 //
1865 //---------------------------------------------------------------------------
1866 int ft1000_close(struct net_device *net)
1867 {
1868         FT1000_INFO *pInfo = (FT1000_INFO *) netdev_priv (net);
1869     struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1870
1871     //DEBUG ("ft1000_close: netdev->refcnt=%d\n", net->refcnt);
1872
1873     ft1000dev->status |= FT1000_STATUS_CLOSING;
1874
1875     //DEBUG("ft1000_close: calling usb_kill_urb \n");
1876     //usb_kill_urb(ft1000dev->rx_urb);
1877     //usb_kill_urb(ft1000dev->tx_urb);
1878
1879
1880     DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1881     netif_carrier_off(net);//mbelian
1882     netif_stop_queue(net);
1883     //DEBUG("ft1000_close: netif_stop_queue called\n");
1884     ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1885
1886    pInfo->ProgConStat = 0xff; //mbelian
1887
1888
1889     return 0;
1890 }
1891
1892 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1893 {
1894         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev);
1895     //struct ft1000_device *ft1000dev = info->pFt1000Dev;
1896
1897     //return &(ft1000dev->stats);//mbelian
1898         return &(info->stats); //mbelian
1899 }
1900
1901
1902 /*********************************************************************************
1903 Jim
1904 */
1905
1906
1907 //---------------------------------------------------------------------------
1908 //
1909 // Function:   ft1000_chkcard
1910 // Descripton: This function will check if the device is presently available on
1911 //             the system.
1912 // Input:
1913 //     dev    - device structure
1914 // Output:
1915 //     status - FALSE (device is not present)
1916 //              TRUE  (device is present)
1917 //
1918 //---------------------------------------------------------------------------
1919 static int ft1000_chkcard (struct ft1000_device *dev) {
1920     u16 tempword;
1921     u16 status;
1922         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
1923
1924     if (info->fCondResetPend)
1925     {
1926         DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1927         return TRUE;
1928     }
1929
1930     // Mask register is used to check for device presence since it is never
1931     // set to zero.
1932     status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1933     //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_SUP_IMASK = %x\n", tempword);
1934     if (tempword == 0) {
1935         DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1936         return FALSE;
1937     }
1938
1939     // The system will return the value of 0xffff for the version register
1940     // if the device is not present.
1941     status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1942     //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_ASIC_ID = %x\n", tempword);
1943     //pxu if (tempword == 0xffff) {
1944     if (tempword != 0x1b01 ){
1945         dev->status |= FT1000_STATUS_CLOSING; //mbelian
1946         DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1947         return FALSE;
1948     }
1949     return TRUE;
1950 }
1951
1952 //---------------------------------------------------------------------------
1953 //
1954 // Function:   ft1000_hbchk
1955 // Descripton: This function will perform the heart beat check of the DSP as
1956 //             well as the ASIC.
1957 // Input:
1958 //     dev    - device structure
1959 // Output:
1960 //     none
1961 //
1962 //---------------------------------------------------------------------------
1963 static void ft1000_hbchk(u_long data)
1964 {
1965     struct ft1000_device *dev = (struct ft1000_device *)data;
1966
1967     FT1000_INFO *info;
1968     USHORT tempword;
1969         u16 status;
1970         info = (FT1000_INFO *) netdev_priv (dev->net);
1971
1972     DEBUG("ft1000_hbchk called for CardNumber = %d CardReady = %d\n", info->CardNumber, info->CardReady);
1973
1974     if (info->fCondResetPend == 1) {
1975         // Reset ASIC and DSP
1976         status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
1977         status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
1978         status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
1979         status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
1980
1981         info->DrvErrNum = DSP_CONDRESET_INFO;
1982         DEBUG("ft1000_hw:DSP conditional reset requested\n");
1983         ft1000_reset_card(dev->net);
1984         info->fCondResetPend = 0;
1985         /* Schedule this module to run every 2 seconds */
1986
1987         poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
1988         poll_timer[info->CardNumber].data = (u_long)dev;
1989         add_timer(&poll_timer[info->CardNumber]);
1990
1991
1992
1993         return;
1994     }
1995
1996     if (info->CardReady == 1) {
1997         // Perform dsp heartbeat check
1998             status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
1999         DEBUG("ft1000_hw:ft1000_hbchk:hi_ho value = 0x%x\n", tempword);
2000         // Let's perform another check if ho is not detected
2001         if (tempword != ho) {
2002               status  = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword,FT1000_MAG_HI_HO_INDX));
2003         }
2004         if (tempword != ho) {
2005             printk(KERN_INFO "ft1000: heartbeat failed - no ho detected\n");
2006                 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2007                 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2008                 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2009                 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2010             info->DrvErrNum = DSP_HB_INFO;
2011             if (ft1000_reset_card(dev->net) == 0) {
2012                printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2013                info->ProgConStat = 0xff;
2014                return;
2015             }
2016             /* Schedule this module to run every 2 seconds */
2017             poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2018             poll_timer[info->CardNumber].data = (u_long)dev;
2019             add_timer(&poll_timer[info->CardNumber]);
2020             return;
2021         }
2022
2023         status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2024         // Let's check doorbell again if fail
2025         if (tempword & FT1000_DB_HB) {
2026                 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2027         }
2028         if (tempword & FT1000_DB_HB) {
2029             printk(KERN_INFO "ft1000: heartbeat doorbell not clear by firmware\n");
2030             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2031             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2032             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2033             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2034             info->DrvErrNum = DSP_HB_INFO;
2035             if (ft1000_reset_card(dev->net) == 0) {
2036                printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2037                info->ProgConStat = 0xff;
2038                return;
2039             }
2040             /* Schedule this module to run every 2 seconds */
2041             poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2042             poll_timer[info->CardNumber].data = (u_long)dev;
2043             add_timer(&poll_timer[info->CardNumber]);
2044             return;
2045         }
2046
2047         // Set dedicated area to hi and ring appropriate doorbell according
2048         // to hi/ho heartbeat protocol
2049         ft1000_write_dpram16(dev, FT1000_MAG_HI_HO, hi_mag, FT1000_MAG_HI_HO_INDX);
2050
2051         status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
2052         // Let's write hi again if fail
2053         if (tempword != hi) {
2054                ft1000_write_dpram16(dev, FT1000_MAG_HI_HO, hi_mag, FT1000_MAG_HI_HO_INDX);
2055                    status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
2056
2057         }
2058         if (tempword != hi) {
2059             printk(KERN_INFO "ft1000: heartbeat failed - cannot write hi into DPRAM\n");
2060             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2061             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2062             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2063             status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2064
2065             info->DrvErrNum = DSP_HB_INFO;
2066             if (ft1000_reset_card(dev->net) == 0) {
2067                printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2068                info->ProgConStat = 0xff;
2069                return;
2070             }
2071             /* Schedule this module to run every 2 seconds */
2072             poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2073             poll_timer[info->CardNumber].data = (u_long)dev;
2074             add_timer(&poll_timer[info->CardNumber]);
2075             return;
2076         }
2077         ft1000_write_register(dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
2078
2079     }
2080
2081     /* Schedule this module to run every 2 seconds */
2082     poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2083     poll_timer[info->CardNumber].data = (u_long)dev;
2084     add_timer(&poll_timer[info->CardNumber]);
2085 }
2086
2087 //---------------------------------------------------------------------------
2088 //
2089 // Function:   ft1000_receive_cmd
2090 // Descripton: This function will read a message from the dpram area.
2091 // Input:
2092 //    dev - network device structure
2093 //    pbuffer - caller supply address to buffer
2094 //    pnxtph - pointer to next pseudo header
2095 // Output:
2096 //   Status = 0 (unsuccessful)
2097 //          = 1 (successful)
2098 //
2099 //---------------------------------------------------------------------------
2100 static BOOLEAN ft1000_receive_cmd (struct ft1000_device *dev, u16 *pbuffer, int maxsz, u16 *pnxtph) {
2101     u16 size, ret;
2102     u16 *ppseudohdr;
2103     int i;
2104     u16 tempword;
2105
2106     ret = ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (PUCHAR)&size, FT1000_MAG_PH_LEN_INDX);
2107     size = ntohs(size) + PSEUDOSZ;
2108     if (size > maxsz) {
2109         DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n", size);
2110         return FALSE;
2111     }
2112     else {
2113         ppseudohdr = (u16 *)pbuffer;
2114         //spin_lock_irqsave (&info->dpram_lock, flags);
2115         ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
2116         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2117         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2118         pbuffer++;
2119         ft1000_write_register(dev,  FT1000_DPRAM_MAG_RX_BASE+1, FT1000_REG_DPRAM_ADDR);
2120         for (i=0; i<=(size>>2); i++) {
2121             ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
2122             pbuffer++;
2123             ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2124             pbuffer++;
2125         }
2126         //copy odd aligned word
2127         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
2128         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2129         pbuffer++;
2130         ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2131         //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2132         pbuffer++;
2133         if (size & 0x0001) {
2134             //copy odd byte from fifo
2135             ret = ft1000_read_register(dev, &tempword, FT1000_REG_DPRAM_DATA);
2136             *pbuffer = ntohs(tempword);
2137         }
2138         //spin_unlock_irqrestore(&info->dpram_lock, flags);
2139
2140         // Check if pseudo header checksum is good
2141         // Calculate pseudo header checksum
2142         tempword = *ppseudohdr++;
2143         for (i=1; i<7; i++) {
2144             tempword ^= *ppseudohdr++;
2145         }
2146         if ( (tempword != *ppseudohdr) ) {
2147             return FALSE;
2148         }
2149
2150
2151 #if 0
2152         DEBUG("ft1000_receive_cmd:pbuffer\n");
2153         for(i = 0; i < size; i+=5)
2154         {
2155             if( (i + 5) < size )
2156                 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", tempbuffer[i], tempbuffer[i+1], tempbuffer[i+2], tempbuffer[i+3], tempbuffer[i+4]);
2157             else
2158             {
2159                 for (j = i; j < size; j++)
2160                 DEBUG("0x%x ", tempbuffer[j]);
2161                 DEBUG("\n");
2162                 break;
2163             }
2164         }
2165
2166 #endif
2167
2168         return TRUE;
2169     }
2170 }
2171
2172
2173 static int ft1000_dsp_prov(void *arg)
2174 {
2175     struct ft1000_device *dev = (struct ft1000_device *)arg;
2176         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2177     u16 tempword;
2178     u16 len;
2179     u16 i=0;
2180     PPROV_RECORD ptr;
2181     PPSEUDO_HDR ppseudo_hdr;
2182     PUSHORT pmsg;
2183     u16 status;
2184     USHORT TempShortBuf [256];
2185
2186     DEBUG("*** DspProv Entered\n");
2187
2188     while (         list_empty(&info->prov_list) == 0
2189                    /*&&  !kthread_should_stop()  */)
2190     {
2191         DEBUG("DSP Provisioning List Entry\n");
2192
2193         // Check if doorbell is available
2194         DEBUG("check if doorbell is cleared\n");
2195         status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
2196         if (status)
2197         {
2198                 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
2199             break;
2200         }
2201
2202         while (tempword & FT1000_DB_DPRAM_TX) {
2203             mdelay(10);
2204             i++;
2205             if (i==10) {
2206                DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
2207                return STATUS_FAILURE;
2208             }
2209             ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2210         }
2211
2212         if ( !(tempword & FT1000_DB_DPRAM_TX) ) {
2213             DEBUG("*** Provision Data Sent to DSP\n");
2214
2215             // Send provisioning data
2216             ptr = list_entry(info->prov_list.next, PROV_RECORD, list);
2217             len = *(u16 *)ptr->pprov_data;
2218             len = htons(len);
2219             len += PSEUDOSZ;
2220             //len = htons(len);
2221
2222             pmsg = (PUSHORT)ptr->pprov_data;
2223             ppseudo_hdr = (PPSEUDO_HDR)pmsg;
2224             // Insert slow queue sequence number
2225             ppseudo_hdr->seq_num = info->squeseqnum++;
2226             ppseudo_hdr->portsrc = 0;
2227             // Calculate new checksum
2228             ppseudo_hdr->checksum = *pmsg++;
2229             //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
2230             for (i=1; i<7; i++) {
2231                 ppseudo_hdr->checksum ^= *pmsg++;
2232                 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
2233             }
2234
2235             TempShortBuf[0] = 0;
2236             TempShortBuf[1] = htons (len);
2237             memcpy(&TempShortBuf[2], ppseudo_hdr, len);
2238
2239             status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&TempShortBuf[0], (unsigned short)(len+2));
2240             status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
2241
2242             list_del(&ptr->list);
2243             kfree(ptr->pprov_data);
2244             kfree(ptr);
2245         }
2246         msleep(10);
2247     }
2248
2249     DEBUG("DSP Provisioning List Entry finished\n");
2250
2251     msleep(100);
2252
2253     info->fProvComplete = 1;
2254     info->CardReady = 1;
2255     info->DSP_loading= 0;
2256     return STATUS_SUCCESS;
2257
2258 }
2259
2260
2261 static int ft1000_proc_drvmsg (struct ft1000_device *dev, u16 size) {
2262         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2263     u16 msgtype;
2264     u16 tempword;
2265     PMEDIAMSG pmediamsg;
2266     PDSPINITMSG pdspinitmsg;
2267     PDRVMSG pdrvmsg;
2268     u16 i;
2269     PPSEUDO_HDR ppseudo_hdr;
2270     PUSHORT pmsg;
2271     u16 status;
2272     //struct timeval tv; //mbelian
2273     union {
2274         u8  byte[2];
2275         u16 wrd;
2276     } convert;
2277
2278
2279     char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
2280     if (!cmdbuffer)
2281         return STATUS_FAILURE;
2282
2283     status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
2284
2285
2286     //if (ft1000_receive_cmd(dev, &cmdbuffer[0], MAX_CMD_SQSIZE, &tempword))
2287     {
2288
2289 #ifdef JDEBUG
2290         DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
2291         for(i = 0; i < size; i+=5)
2292         {
2293             if( (i + 5) < size )
2294                 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]);
2295             else
2296             {
2297                 for (j = i; j < size; j++)
2298                 DEBUG("0x%x ", cmdbuffer[j]);
2299                 DEBUG("\n");
2300                 break;
2301             }
2302         }
2303 #endif
2304         pdrvmsg = (PDRVMSG)&cmdbuffer[2];
2305         msgtype = ntohs(pdrvmsg->type);
2306         DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
2307         switch (msgtype) {
2308             case MEDIA_STATE: {
2309                 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
2310
2311                 pmediamsg = (PMEDIAMSG)&cmdbuffer[0];
2312                 if (info->ProgConStat != 0xFF) {
2313                     if (pmediamsg->state) {
2314                         DEBUG("Media is up\n");
2315                         if (info->mediastate == 0) {
2316                             if ( info->NetDevRegDone )
2317                             {
2318                                 //netif_carrier_on(dev->net);//mbelian
2319                                 netif_wake_queue(dev->net);
2320                             }
2321                             info->mediastate = 1;
2322                             /*do_gettimeofday(&tv);
2323                             info->ConTm = tv.tv_sec;*/ //mbelian
2324                         }
2325                     }
2326                     else {
2327                         DEBUG("Media is down\n");
2328                         if (info->mediastate == 1) {
2329                             info->mediastate = 0;
2330                             if ( info->NetDevRegDone )
2331                             {
2332                                 //netif_carrier_off(dev->net); mbelian
2333                                 //netif_stop_queue(dev->net);
2334                             }
2335                             info->ConTm = 0;
2336                         }
2337                     }
2338                 }
2339                 else {
2340                     DEBUG("Media is down\n");
2341                     if (info->mediastate == 1) {
2342                         info->mediastate = 0;
2343                         if ( info->NetDevRegDone)
2344                         {
2345                             //netif_carrier_off(dev->net); //mbelian
2346                             //netif_stop_queue(dev->net);
2347                         }
2348                         info->ConTm = 0;
2349                     }
2350                 }
2351                 break;
2352             }
2353             case DSP_INIT_MSG: {
2354                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
2355
2356                 pdspinitmsg = (PDSPINITMSG)&cmdbuffer[2];
2357                 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
2358                 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n", info->DspVer[0], info->DspVer[1], info->DspVer[2], info->DspVer[3]);
2359                 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum, HWSERNUMSZ);
2360                 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
2361                 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
2362                 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]);
2363                 dev->net->dev_addr[0] = info->eui64[0];
2364                 dev->net->dev_addr[1] = info->eui64[1];
2365                 dev->net->dev_addr[2] = info->eui64[2];
2366                 dev->net->dev_addr[3] = info->eui64[5];
2367                 dev->net->dev_addr[4] = info->eui64[6];
2368                 dev->net->dev_addr[5] = info->eui64[7];
2369
2370                 if (ntohs(pdspinitmsg->length) == (sizeof(DSPINITMSG) - 20) ) {
2371                     memcpy(info->ProductMode, pdspinitmsg->ProductMode, MODESZ);
2372                     memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
2373                     memcpy(info->RfCalDate, pdspinitmsg->RfCalDate, CALDATESZ);
2374                     DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0], info->RfCalVer[1]);
2375                 }
2376                 break;
2377             }
2378             case DSP_PROVISION: {
2379                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
2380
2381                 // kick off dspprov routine to start provisioning
2382                 // Send provisioning data to DSP
2383                 if (list_empty(&info->prov_list) == 0)
2384                 {
2385                     info->fProvComplete = 0;
2386                     status = ft1000_dsp_prov(dev);
2387                     if (status != STATUS_SUCCESS)
2388                         goto out;
2389                 }
2390                 else {
2391                     info->fProvComplete = 1;
2392                     status = ft1000_write_register (dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
2393                     DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
2394                 }
2395                 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
2396                 break;
2397             }
2398             case DSP_STORE_INFO: {
2399                 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
2400
2401                 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
2402                 tempword = ntohs(pdrvmsg->length);
2403                 info->DSPInfoBlklen = tempword;
2404                 if (tempword < (MAX_DSP_SESS_REC-4) ) {
2405                     pmsg = (PUSHORT)&pdrvmsg->data[0];
2406                     for (i=0; i<((tempword+1)/2); i++) {
2407                         DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
2408                         info->DSPInfoBlk[i+10] = *pmsg++;
2409                     }
2410                 }
2411                 else {
2412                     info->DSPInfoBlklen = 0;
2413                 }
2414                 break;
2415             }
2416             case DSP_GET_INFO: {
2417                 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
2418                 // copy dsp info block to dsp
2419                 info->DrvMsgPend = 1;
2420                 // allow any outstanding ioctl to finish
2421                 mdelay(10);
2422                 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2423                 if (tempword & FT1000_DB_DPRAM_TX) {
2424                     mdelay(10);
2425                     status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2426                     if (tempword & FT1000_DB_DPRAM_TX) {
2427                         mdelay(10);
2428                             status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2429                             if (tempword & FT1000_DB_DPRAM_TX) {
2430                                 break;
2431                             }
2432                     }
2433                 }
2434
2435                 // Put message into Slow Queue
2436                 // Form Pseudo header
2437                 pmsg = (PUSHORT)info->DSPInfoBlk;
2438                 *pmsg++ = 0;
2439                 *pmsg++ = htons(info->DSPInfoBlklen+20+info->DSPInfoBlklen);
2440                 ppseudo_hdr = (PPSEUDO_HDR)(PUSHORT)&info->DSPInfoBlk[2];
2441                 ppseudo_hdr->length = htons(info->DSPInfoBlklen+4+info->DSPInfoBlklen);
2442                 ppseudo_hdr->source = 0x10;
2443                 ppseudo_hdr->destination = 0x20;
2444                 ppseudo_hdr->portdest = 0;
2445                 ppseudo_hdr->portsrc = 0;
2446                 ppseudo_hdr->sh_str_id = 0;
2447                 ppseudo_hdr->control = 0;
2448                 ppseudo_hdr->rsvd1 = 0;
2449                 ppseudo_hdr->rsvd2 = 0;
2450                 ppseudo_hdr->qos_class = 0;
2451                 // Insert slow queue sequence number
2452                 ppseudo_hdr->seq_num = info->squeseqnum++;
2453                 // Insert application id
2454                 ppseudo_hdr->portsrc = 0;
2455                 // Calculate new checksum
2456                 ppseudo_hdr->checksum = *pmsg++;
2457                 for (i=1; i<7; i++) {
2458                     ppseudo_hdr->checksum ^= *pmsg++;
2459                 }
2460                 info->DSPInfoBlk[10] = 0x7200;
2461                 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
2462                 status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&info->DSPInfoBlk[0], (unsigned short)(info->DSPInfoBlklen+22));
2463                 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
2464                 info->DrvMsgPend = 0;
2465
2466                 break;
2467             }
2468
2469           case GET_DRV_ERR_RPT_MSG: {
2470               DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
2471               // copy driver error message to dsp
2472               info->DrvMsgPend = 1;
2473               // allow any outstanding ioctl to finish
2474               mdelay(10);
2475               status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2476               if (tempword & FT1000_DB_DPRAM_TX) {
2477                   mdelay(10);
2478                   status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2479                   if (tempword & FT1000_DB_DPRAM_TX) {
2480                       mdelay(10);
2481                   }
2482               }
2483
2484               if ( (tempword & FT1000_DB_DPRAM_TX) == 0) {
2485                   // Put message into Slow Queue
2486                   // Form Pseudo header
2487                   pmsg = (PUSHORT)&tempbuffer[0];
2488                   ppseudo_hdr = (PPSEUDO_HDR)pmsg;
2489                   ppseudo_hdr->length = htons(0x0012);
2490                   ppseudo_hdr->source = 0x10;
2491                   ppseudo_hdr->destination = 0x20;
2492                   ppseudo_hdr->portdest = 0;
2493                   ppseudo_hdr->portsrc = 0;
2494                   ppseudo_hdr->sh_str_id = 0;
2495                   ppseudo_hdr->control = 0;
2496                   ppseudo_hdr->rsvd1 = 0;
2497                   ppseudo_hdr->rsvd2 = 0;
2498                   ppseudo_hdr->qos_class = 0;
2499                   // Insert slow queue sequence number
2500                   ppseudo_hdr->seq_num = info->squeseqnum++;
2501                   // Insert application id
2502                   ppseudo_hdr->portsrc = 0;
2503                   // Calculate new checksum
2504                   ppseudo_hdr->checksum = *pmsg++;
2505                   for (i=1; i<7; i++) {
2506                       ppseudo_hdr->checksum ^= *pmsg++;
2507                   }
2508                   pmsg = (PUSHORT)&tempbuffer[16];
2509                   *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
2510                   *pmsg++ = htons(0x000e);
2511                   *pmsg++ = htons(info->DSP_TIME[0]);
2512                   *pmsg++ = htons(info->DSP_TIME[1]);
2513                   *pmsg++ = htons(info->DSP_TIME[2]);
2514                   *pmsg++ = htons(info->DSP_TIME[3]);
2515                   convert.byte[0] = info->DspVer[0];
2516                   convert.byte[1] = info->DspVer[1];
2517                   *pmsg++ = convert.wrd;
2518                   convert.byte[0] = info->DspVer[2];
2519                   convert.byte[1] = info->DspVer[3];
2520                   *pmsg++ = convert.wrd;
2521                   *pmsg++ = htons(info->DrvErrNum);
2522
2523                   CardSendCommand (dev, (unsigned char*)&tempbuffer[0], (USHORT)(0x0012 + PSEUDOSZ));
2524                   info->DrvErrNum = 0;
2525               }
2526               info->DrvMsgPend = 0;
2527
2528           break;
2529       }
2530
2531       default:
2532           break;
2533         }
2534
2535     }
2536
2537     status = STATUS_SUCCESS;
2538 out:
2539     kfree(cmdbuffer);
2540     DEBUG("return from ft1000_proc_drvmsg\n");
2541     return status;
2542 }
2543
2544
2545
2546 int ft1000_poll(void* dev_id) {
2547
2548     //FT1000_INFO *info = (PFT1000_INFO)((struct net_device *)dev_id)->priv;
2549     //struct ft1000_device *dev = (struct ft1000_device *)info->pFt1000Dev;
2550     struct ft1000_device *dev = (struct ft1000_device *)dev_id;
2551         FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2552
2553     u16 tempword;
2554     u16 status;
2555     u16 size;
2556     int i;
2557     USHORT data;
2558     USHORT modulo;
2559     USHORT portid;
2560     u16 nxtph;
2561     PDPRAM_BLK pdpram_blk;
2562     PPSEUDO_HDR ppseudo_hdr;
2563     unsigned long flags;
2564
2565     //DEBUG("Enter ft1000_poll...\n");
2566     if (ft1000_chkcard(dev) == FALSE) {
2567         DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
2568         return STATUS_FAILURE;
2569     }
2570
2571     status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
2572    // DEBUG("ft1000_poll: read FT1000_REG_DOORBELL message 0x%x\n", tempword);
2573
2574     //while ( (tempword) && (!status) ) {
2575     if ( !status )
2576     {
2577
2578         if (tempword & FT1000_DB_DPRAM_RX) {
2579             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DB_DPRAM_RX\n");
2580
2581             status = ft1000_read_dpram16(dev, 0x200, (PUCHAR)&data, 0);
2582             //DEBUG("ft1000_poll:FT1000_DB_DPRAM_RX:ft1000_read_dpram16:size = 0x%x\n", data);
2583             size = ntohs(data) + 16 + 2; //wai
2584             if (size % 4) {
2585                 modulo = 4 - (size % 4);
2586                 size = size + modulo;
2587             }
2588             status = ft1000_read_dpram16(dev, 0x201, (PUCHAR)&portid, 1);
2589             portid &= 0xff;
2590             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid 0x%x\n", portid);
2591
2592             if (size < MAX_CMD_SQSIZE) {
2593                 switch (portid)
2594                 {
2595                     case DRIVERID:
2596                         DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
2597
2598                         status = ft1000_proc_drvmsg (dev, size);
2599                         if (status != STATUS_SUCCESS )
2600                             return status;
2601                         break;
2602                     case DSPBCMSGID:
2603                         // This is a dsp broadcast message
2604                         // Check which application has registered for dsp broadcast messages
2605                         //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DSPBCMSGID\n");
2606
2607                         for (i=0; i<MAX_NUM_APP; i++) {
2608                            if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
2609                                          (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT)  )
2610                            {
2611                                //DEBUG("Dsp broadcast message detected for app id %d\n", i);
2612                                nxtph = FT1000_DPRAM_RX_BASE + 2;
2613                                pdpram_blk = ft1000_get_buffer (&freercvpool);
2614                                if (pdpram_blk != NULL) {
2615                                    if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
2616                                        ppseudo_hdr = (PPSEUDO_HDR)pdpram_blk->pbuffer;
2617                                        // Put message into the appropriate application block
2618                                        info->app_info[i].nRxMsg++;
2619                                        spin_lock_irqsave(&free_buff_lock, flags);
2620                                        list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
2621                                        info->app_info[i].NumOfMsg++;
2622                                        spin_unlock_irqrestore(&free_buff_lock, flags);
2623                                        wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
2624                                    }
2625                                    else {
2626                                        info->app_info[i].nRxMsgMiss++;
2627                                        // Put memory back to free pool
2628                                        ft1000_free_buffer(pdpram_blk, &freercvpool);
2629                                        DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
2630                                    }
2631                                }
2632                                else {
2633                                    DEBUG("Out of memory in free receive command pool\n");
2634                                    info->app_info[i].nRxMsgMiss++;
2635                                }//endof if (pdpram_blk != NULL)
2636                            }//endof if
2637                            //else
2638                            //    DEBUG("app_info mismatch\n");
2639                         }// endof for
2640                         break;
2641                     default:
2642                         pdpram_blk = ft1000_get_buffer (&freercvpool);
2643                         //DEBUG("Memory allocated = 0x%8x\n", (u32)pdpram_blk);
2644                         if (pdpram_blk != NULL) {
2645                            if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
2646                                ppseudo_hdr = (PPSEUDO_HDR)pdpram_blk->pbuffer;
2647                                // Search for correct application block
2648                                for (i=0; i<MAX_NUM_APP; i++) {
2649                                    if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
2650                                        break;
2651                                    }
2652                                }
2653
2654                                if (i==(MAX_NUM_APP-1)) {                // aelias [+] reason: was out of array boundary
2655                                    info->app_info[i].nRxMsgMiss++;
2656                                    DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
2657                                    // Put memory back to free pool
2658                                    ft1000_free_buffer(pdpram_blk, &freercvpool);
2659                                }
2660                                else {
2661                                    if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
2662                                        // Put memory back to free pool
2663                                        ft1000_free_buffer(pdpram_blk, &freercvpool);
2664                                    }
2665                                    else {
2666                                        info->app_info[i].nRxMsg++;
2667                                        // Put message into the appropriate application block
2668                                        //pxu spin_lock_irqsave(&free_buff_lock, flags);
2669                                        list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
2670                                        info->app_info[i].NumOfMsg++;
2671                                        //pxu spin_unlock_irqrestore(&free_buff_lock, flags);
2672                                        //pxu wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
2673                                    }
2674                                }
2675                            }
2676                            else {
2677                                // Put memory back to free pool
2678                                ft1000_free_buffer(pdpram_blk, &freercvpool);
2679                            }
2680                         }
2681                         else {
2682                             DEBUG("Out of memory in free receive command pool\n");
2683                         }
2684                         break;
2685                 } //end of switch
2686             } //endof if (size < MAX_CMD_SQSIZE)
2687             else {
2688                 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
2689             }
2690             status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
2691         }
2692         else if (tempword & FT1000_DSP_ASIC_RESET) {
2693             //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DSP_ASIC_RESET\n");
2694
2695             // Let's reset the ASIC from the Host side as well
2696             status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
2697             status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2698             i = 0;
2699             while (tempword & ASIC_RESET_BIT) {
2700                 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2701                 msleep(10);
2702                 i++;
2703                 if (i==100)
2704                     break;
2705             }
2706             if (i==100) {
2707                 DEBUG("Unable to reset ASIC\n");
2708                 return STATUS_SUCCESS;
2709             }
2710             msleep(10);
2711             // Program WMARK register
2712             status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2713             // clear ASIC reset doorbell
2714             status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
2715             msleep(10);
2716         }
2717         else if (tempword & FT1000_ASIC_RESET_REQ) {
2718             DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_ASIC_RESET_REQ\n");
2719
2720             // clear ASIC reset request from DSP
2721             status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
2722             status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
2723             // copy dsp session record from Adapter block
2724             status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&info->DSPSess.Rec[0], 1024);
2725             // Program WMARK register
2726             status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2727             // ring doorbell to tell DSP that ASIC is out of reset
2728             status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
2729         }
2730         else if (tempword & FT1000_DB_COND_RESET) {
2731             DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type:  FT1000_DB_COND_RESET\n");
2732 //By Jim
2733 // Reset ASIC and DSP
2734 //MAG
2735             if (info->fAppMsgPend == 0) {
2736                // Reset ASIC and DSP
2737
2738                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2739                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2740                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2741                 status    = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2742                 info->CardReady = 0;
2743                 info->DrvErrNum = DSP_CONDRESET_INFO;
2744                 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2745                 info->ft1000_reset(dev->net);
2746             }
2747             else {
2748                 info->fProvComplete = 0;
2749                 info->fCondResetPend = 1;
2750             }
2751
2752             ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2753         }
2754
2755     }//endof if ( !status )
2756
2757     //DEBUG("return from ft1000_poll.\n");
2758     return STATUS_SUCCESS;
2759
2760 }
2761
2762 /*end of Jim*/