drivers/staging/csr/csr_wifi_hip_card_sdio_mem.c

   1 /*****************************************************************************
   2
   3             (c) Cambridge Silicon Radio Limited 2012
   4             All rights reserved and confidential information of CSR
   5
   6             Refer to LICENSE.txt included with this source for details
   7             on the license terms.
   8
   9 *****************************************************************************/
  10
  11 /*
  12  * ---------------------------------------------------------------------------
  13  * FILE: csr_wifi_hip_card_sdio_mem.c
  14  *
  15  * PURPOSE: Implementation of the Card API for SDIO.
  16  *
  17  * ---------------------------------------------------------------------------
  18  */
  19 #include "csr_wifi_hip_unifi.h"
  20 #include "csr_wifi_hip_card.h"
  21
  22 #define SDIO_RETRIES    3
  23 #define CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH 16
  24
  25
  26 #define retryable_sdio_error(_csrResult) (((_csrResult) == CSR_SDIO_RESULT_CRC_ERROR) || ((_csrResult) == CSR_SDIO_RESULT_TIMEOUT))
  27
  28
  29 /*
  30  * ---------------------------------------------------------------------------
  31  *  retrying_read8
  32  *  retrying_write8
  33  *
  34  *      These functions provide the first level of retry for SDIO operations.
  35  *      If an SDIO command fails for reason of a response timeout or CRC
  36  *      error, it is retried immediately. If three attempts fail we report a
  37  *      failure.
  38  *      If the command failed for any other reason, the failure is reported
  39  *      immediately.
  40  *
  41  *  Arguments:
  42  *      card            Pointer to card structure.
  43  *      funcnum         The SDIO function to access.
  44  *                      Function 0 is the Card Configuration Register space,
  45  *                      function 1/2 is the UniFi register space.
  46  *      addr            Address to access
  47  *      pdata           Pointer in which to return the value read.
  48  *      data            Value to write.
  49  *
  50  *  Returns:
  51  *      CSR_RESULT_SUCCESS  on success, non-zero error code on error:
  52  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
  53  *      CSR_RESULT_FAILURE     an SDIO error occurred
  54  * ---------------------------------------------------------------------------
  55  */
  56 static CsrResult retrying_read8(card_t *card, s16 funcnum, u32 addr, u8 *pdata)
  57 {
  58     CsrSdioFunction *sdio = card->sdio_if;
  59     CsrResult r = CSR_RESULT_SUCCESS;
  60     s16 retries;
  61     CsrResult csrResult = CSR_RESULT_SUCCESS;
  62
  63     retries = 0;
  64     while (retries++ < SDIO_RETRIES)
  65     {
  66         if (funcnum == 0)
  67         {
  68 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
  69             unifi_debug_log_to_buf("r0@%02X", addr);
  70 #endif
  71             csrResult = CsrSdioF0Read8(sdio, addr, pdata);
  72         }
  73         else
  74         {
  75 #ifdef CSR_WIFI_TRANSPORT_CSPI
  76             unifi_error(card->ospriv,
  77                         "retrying_read_f0_8: F1 8-bit reads are not allowed.\n");
  78             return CSR_RESULT_FAILURE;
  79 #else
  80 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
  81             unifi_debug_log_to_buf("r@%02X", addr);
  82 #endif
  83             csrResult = CsrSdioRead8(sdio, addr, pdata);
  84 #endif
  85         }
  86 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
  87         if (csrResult != CSR_RESULT_SUCCESS)
  88         {
  89             unifi_debug_log_to_buf("error=%X\n", csrResult);
  90         }
  91         else
  92         {
  93             unifi_debug_log_to_buf("=%X\n", *pdata);
  94         }
  95 #endif
  96         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
  97         {
  98             return CSR_WIFI_HIP_RESULT_NO_DEVICE;
  99         }
 100         /*
 101          * Try again for retryable (CRC or TIMEOUT) errors,
 102          * break on success or fatal error
 103          */
 104         if (!retryable_sdio_error(csrResult))
 105         {
 106 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
 107             card->cmd_prof.cmd52_count++;
 108 #endif
 109             break;
 110         }
 111         unifi_trace(card->ospriv, UDBG2, "retryable SDIO error reading F%d 0x%lX\n", funcnum, addr);
 112     }
 113
 114     if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
 115     {
 116         unifi_warning(card->ospriv, "Read succeeded after %d attempts\n", retries);
 117     }
 118
 119     if (csrResult != CSR_RESULT_SUCCESS)
 120     {
 121         unifi_error(card->ospriv, "Failed to read from UniFi (addr 0x%lX) after %d tries\n",
 122                     addr, retries - 1);
 123         /* Report any SDIO error as a general i/o error */
 124         r = CSR_RESULT_FAILURE;
 125     }
 126
 127     return r;
 128 } /* retrying_read8() */
 129
 130
 131 static CsrResult retrying_write8(card_t *card, s16 funcnum, u32 addr, u8 data)
 132 {
 133     CsrSdioFunction *sdio = card->sdio_if;
 134     CsrResult r = CSR_RESULT_SUCCESS;
 135     s16 retries;
 136     CsrResult csrResult = CSR_RESULT_SUCCESS;
 137
 138     retries = 0;
 139     while (retries++ < SDIO_RETRIES)
 140     {
 141         if (funcnum == 0)
 142         {
 143 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 144             unifi_debug_log_to_buf("w0@%02X=%X", addr, data);
 145 #endif
 146             csrResult = CsrSdioF0Write8(sdio, addr, data);
 147         }
 148         else
 149         {
 150 #ifdef CSR_WIFI_TRANSPORT_CSPI
 151             unifi_error(card->ospriv,
 152                         "retrying_write_f0_8: F1 8-bit writes are not allowed.\n");
 153             return CSR_RESULT_FAILURE;
 154 #else
 155 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 156             unifi_debug_log_to_buf("w@%02X=%X", addr, data);
 157 #endif
 158             csrResult = CsrSdioWrite8(sdio, addr, data);
 159 #endif
 160         }
 161 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 162         if (csrResult != CSR_RESULT_SUCCESS)
 163         {
 164             unifi_debug_log_to_buf(",error=%X", csrResult);
 165         }
 166         unifi_debug_string_to_buf("\n");
 167 #endif
 168         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
 169         {
 170             return CSR_WIFI_HIP_RESULT_NO_DEVICE;
 171         }
 172         /*
 173          * Try again for retryable (CRC or TIMEOUT) errors,
 174          * break on success or fatal error
 175          */
 176         if (!retryable_sdio_error(csrResult))
 177         {
 178 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
 179             card->cmd_prof.cmd52_count++;
 180 #endif
 181             break;
 182         }
 183         unifi_trace(card->ospriv, UDBG2, "retryable SDIO error writing %02X to F%d 0x%lX\n",
 184                     data, funcnum, addr);
 185     }
 186
 187     if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
 188     {
 189         unifi_warning(card->ospriv, "Write succeeded after %d attempts\n", retries);
 190     }
 191
 192     if (csrResult != CSR_RESULT_SUCCESS)
 193     {
 194         unifi_error(card->ospriv, "Failed to write to UniFi (addr 0x%lX) after %d tries\n",
 195                     addr, retries - 1);
 196         /* Report any SDIO error as a general i/o error */
 197         r = CSR_RESULT_FAILURE;
 198     }
 199
 200     return r;
 201 } /* retrying_write8() */
 202
 203
 204 static CsrResult retrying_read16(card_t *card, s16 funcnum,
 205                                  u32 addr, u16 *pdata)
 206 {
 207     CsrSdioFunction *sdio = card->sdio_if;
 208     CsrResult r = CSR_RESULT_SUCCESS;
 209     s16 retries;
 210     CsrResult csrResult = CSR_RESULT_SUCCESS;
 211
 212     retries = 0;
 213     while (retries++ < SDIO_RETRIES)
 214     {
 215 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 216         unifi_debug_log_to_buf("r@%02X", addr);
 217 #endif
 218         csrResult = CsrSdioRead16(sdio, addr, pdata);
 219 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 220         if (csrResult != CSR_RESULT_SUCCESS)
 221         {
 222             unifi_debug_log_to_buf("error=%X\n", csrResult);
 223         }
 224         else
 225         {
 226             unifi_debug_log_to_buf("=%X\n", *pdata);
 227         }
 228 #endif
 229         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
 230         {
 231             return CSR_WIFI_HIP_RESULT_NO_DEVICE;
 232         }
 233
 234         /*
 235          * Try again for retryable (CRC or TIMEOUT) errors,
 236          * break on success or fatal error
 237          */
 238         if (!retryable_sdio_error(csrResult))
 239         {
 240 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
 241             card->cmd_prof.cmd52_count++;
 242 #endif
 243             break;
 244         }
 245         unifi_trace(card->ospriv, UDBG2, "retryable SDIO error reading F%d 0x%lX\n", funcnum, addr);
 246     }
 247
 248     if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
 249     {
 250         unifi_warning(card->ospriv, "Read succeeded after %d attempts\n", retries);
 251     }
 252
 253     if (csrResult != CSR_RESULT_SUCCESS)
 254     {
 255         unifi_error(card->ospriv, "Failed to read from UniFi (addr 0x%lX) after %d tries\n",
 256                     addr, retries - 1);
 257         /* Report any SDIO error as a general i/o error */
 258         r = CSR_RESULT_FAILURE;
 259     }
 260
 261     return r;
 262 } /* retrying_read16() */
 263
 264
 265 static CsrResult retrying_write16(card_t *card, s16 funcnum,
 266                                   u32 addr, u16 data)
 267 {
 268     CsrSdioFunction *sdio = card->sdio_if;
 269     CsrResult r = CSR_RESULT_SUCCESS;
 270     s16 retries;
 271     CsrResult csrResult = CSR_RESULT_SUCCESS;
 272
 273     retries = 0;
 274     while (retries++ < SDIO_RETRIES)
 275     {
 276 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 277         unifi_debug_log_to_buf("w@%02X=%X", addr, data);
 278 #endif
 279         csrResult = CsrSdioWrite16(sdio, addr, data);
 280 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
 281         if (csrResult != CSR_RESULT_SUCCESS)
 282         {
 283             unifi_debug_log_to_buf(",error=%X", csrResult);
 284         }
 285         unifi_debug_string_to_buf("\n");
 286 #endif
 287         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
 288         {
 289             return CSR_WIFI_HIP_RESULT_NO_DEVICE;
 290         }
 291
 292         /*
 293          * Try again for retryable (CRC or TIMEOUT) errors,
 294          * break on success or fatal error
 295          */
 296         if (!retryable_sdio_error(csrResult))
 297         {
 298 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
 299             card->cmd_prof.cmd52_count++;
 300 #endif
 301             break;
 302         }
 303         unifi_trace(card->ospriv, UDBG2, "retryable SDIO error writing %02X to F%d 0x%lX\n",
 304                     data, funcnum, addr);
 305     }
 306
 307     if ((csrResult == CSR_RESULT_SUCCESS) && (retries > 1))
 308     {
 309         unifi_warning(card->ospriv, "Write succeeded after %d attempts\n", retries);
 310     }
 311
 312     if (csrResult != CSR_RESULT_SUCCESS)
 313     {
 314         unifi_error(card->ospriv, "Failed to write to UniFi (addr 0x%lX) after %d tries\n",
 315                     addr, retries - 1);
 316         /* Report any SDIO error as a general i/o error */
 317         r = CSR_RESULT_FAILURE;
 318     }
 319
 320     return r;
 321 } /* retrying_write16() */
 322
 323
 324 /*
 325  * ---------------------------------------------------------------------------
 326  *  sdio_read_f0
 327  *
 328  *      Reads a byte value from the CCCR (func 0) area of UniFi.
 329  *
 330  *  Arguments:
 331  *      card    Pointer to card structure.
 332  *      addr    Address to read from
 333  *      pdata   Pointer in which to store the read value.
 334  *
 335  *  Returns:
 336  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 337  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 338  *      CSR_RESULT_FAILURE     an SDIO error occurred
 339  * ---------------------------------------------------------------------------
 340  */
 341 CsrResult sdio_read_f0(card_t *card, u32 addr, u8 *pdata)
 342 {
 343 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
 344     card->cmd_prof.cmd52_f0_r_count++;
 345 #endif
 346     return retrying_read8(card, 0, addr, pdata);
 347 } /* sdio_read_f0() */
 348
 349
 350 /*
 351  * ---------------------------------------------------------------------------
 352  *  sdio_write_f0
 353  *
 354  *      Writes a byte value to the CCCR (func 0) area of UniFi.
 355  *
 356  *  Arguments:
 357  *      card    Pointer to card structure.
 358  *      addr    Address to read from
 359  *      data    Data value to write.
 360  *
 361  *  Returns:
 362  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 363  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 364  *      CSR_RESULT_FAILURE     an SDIO error occurred
 365  * ---------------------------------------------------------------------------
 366  */
 367 CsrResult sdio_write_f0(card_t *card, u32 addr, u8 data)
 368 {
 369 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
 370     card->cmd_prof.cmd52_f0_w_count++;
 371 #endif
 372     return retrying_write8(card, 0, addr, data);
 373 } /* sdio_write_f0() */
 374
 375
 376 /*
 377  * ---------------------------------------------------------------------------
 378  * unifi_read_direct_8_or_16
 379  *
 380  *      Read a 8-bit value from the UniFi SDIO interface.
 381  *
 382  *  Arguments:
 383  *      card    Pointer to card structure.
 384  *      addr    Address to read from
 385  *      pdata   Pointer in which to return data.
 386  *
 387  *  Returns:
 388  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 389  * ---------------------------------------------------------------------------
 390  */
 391 CsrResult unifi_read_direct_8_or_16(card_t *card, u32 addr, u8 *pdata)
 392 {
 393 #ifdef CSR_WIFI_TRANSPORT_CSPI
 394     u16 w;
 395     CsrResult r;
 396
 397     r = retrying_read16(card, card->function, addr, &w);
 398     *pdata = (u8)(w & 0xFF);
 399     return r;
 400 #else
 401     return retrying_read8(card, card->function, addr, pdata);
 402 #endif
 403 } /* unifi_read_direct_8_or_16() */
 404
 405
 406 /*
 407  * ---------------------------------------------------------------------------
 408  *  unifi_write_direct_8_or_16
 409  *
 410  *      Write a byte value to the UniFi SDIO interface.
 411  *
 412  *  Arguments:
 413  *      card    Pointer to card structure.
 414  *      addr    Address to write to
 415  *      data    Value to write.
 416  *
 417  *  Returns:
 418  *      CSR_RESULT_SUCCESS on success, non-zero error code on error
 419  *
 420  *  Notes:
 421  *      If 8-bit write is used, the even address *must* be written second.
 422  *      This is because writes to odd bytes are cached and not committed
 423  *      to memory until the preceding even address is written.
 424  * ---------------------------------------------------------------------------
 425  */
 426 CsrResult unifi_write_direct_8_or_16(card_t *card, u32 addr, u8 data)
 427 {
 428     if (addr & 1)
 429     {
 430         unifi_warning(card->ospriv,
 431                       "Warning: Byte write to an odd address (0x%lX) is dangerous\n",
 432                       addr);
 433     }
 434
 435 #ifdef CSR_WIFI_TRANSPORT_CSPI
 436     return retrying_write16(card, card->function, addr, (u16)data);
 437 #else
 438     return retrying_write8(card, card->function, addr, data);
 439 #endif
 440 } /* unifi_write_direct_8_or_16() */
 441
 442
 443 /*
 444  * ---------------------------------------------------------------------------
 445  *  unifi_read_direct16
 446  *
 447  *      Read a 16-bit value from the UniFi SDIO interface.
 448  *
 449  *  Arguments:
 450  *      card    Pointer to card structure.
 451  *      addr    Address to read from
 452  *      pdata   Pointer in which to return data.
 453  *
 454  *  Returns:
 455  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 456  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 457  *      CSR_RESULT_FAILURE     an SDIO error occurred
 458  *
 459  *  Notes:
 460  *      The even address *must* be read first. This is because reads from
 461  *      odd bytes are cached and read from memory when the preceding
 462  *      even address is read.
 463  * ---------------------------------------------------------------------------
 464  */
 465 CsrResult unifi_read_direct16(card_t *card, u32 addr, u16 *pdata)
 466 {
 467     return retrying_read16(card, card->function, addr, pdata);
 468 } /* unifi_read_direct16() */
 469
 470
 471 /*
 472  * ---------------------------------------------------------------------------
 473  *  unifi_write_direct16
 474  *
 475  *      Write a 16-bit value to the UniFi SDIO interface.
 476  *
 477  *  Arguments:
 478  *      card    Pointer to card structure.
 479  *      addr    Address to write to
 480  *      data    Value to write.
 481  *
 482  *  Returns:
 483  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 484  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 485  *      CSR_RESULT_FAILURE     an SDIO error occurred
 486  *
 487  *  Notes:
 488  *      The even address *must* be written second. This is because writes to
 489  *      odd bytes are cached and not committed to memory until the preceding
 490  *      even address is written.
 491  * ---------------------------------------------------------------------------
 492  */
 493 CsrResult unifi_write_direct16(card_t *card, u32 addr, u16 data)
 494 {
 495     return retrying_write16(card, card->function, addr, data);
 496 } /* unifi_write_direct16() */
 497
 498
 499 /*
 500  * ---------------------------------------------------------------------------
 501  *  unifi_read_direct32
 502  *
 503  *      Read a 32-bit value from the UniFi SDIO interface.
 504  *
 505  *  Arguments:
 506  *      card    Pointer to card structure.
 507  *      addr    Address to read from
 508  *      pdata   Pointer in which to return data.
 509  *
 510  *  Returns:
 511  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
 512  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 513  *      CSR_RESULT_FAILURE     an SDIO error occurred
 514  * ---------------------------------------------------------------------------
 515  */
 516 CsrResult unifi_read_direct32(card_t *card, u32 addr, u32 *pdata)
 517 {
 518     CsrResult r;
 519     u16 w0, w1;
 520
 521     r = retrying_read16(card, card->function, addr, &w0);
 522     if (r != CSR_RESULT_SUCCESS)
 523     {
 524         return r;
 525     }
 526
 527     r = retrying_read16(card, card->function, addr + 2, &w1);
 528     if (r != CSR_RESULT_SUCCESS)
 529     {
 530         return r;
 531     }
 532
 533     *pdata = ((u32)w1 << 16) | (u32)w0;
 534
 535     return CSR_RESULT_SUCCESS;
 536 } /* unifi_read_direct32() */
 537
 538
 539 /*
 540  * ---------------------------------------------------------------------------
 541  *  unifi_read_directn_match
 542  *
 543  *      Read multiple 8-bit values from the UniFi SDIO interface,
 544  *      stopping when either we have read 'len' bytes or we have read
 545  *      a octet equal to 'match'.  If 'match' is not a valid octet
 546  *      then this function is the same as 'unifi_read_directn'.
 547  *
 548  *  Arguments:
 549  *      card            Pointer to card structure.
 550  *      addr            Start address to read from.
 551  *      pdata           Pointer to which to write data.
 552  *      len             Maximum umber of bytes to read
 553  *      match           The value to stop reading at.
 554  *      num             Pointer to buffer to write number of bytes read
 555  *
 556  *  Returns:
 557  *      number of octets read on success, negative error code on error:
 558  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 559  *      CSR_RESULT_FAILURE     an SDIO error occurred
 560  *
 561  *  Notes:
 562  *      The even address *must* be read first. This is because reads from
 563  *      odd bytes are cached and read from memory when the preceding
 564  *      even address is read.
 565  * ---------------------------------------------------------------------------
 566  */
 567 static CsrResult unifi_read_directn_match(card_t *card, u32 addr, void *pdata, u16 len, s8 m, u32 *num)
 568 {
 569     CsrResult r;
 570     u32 i;
 571     u8 *cptr;
 572     u16 w;
 573
 574     *num = 0;
 575
 576     cptr = (u8 *)pdata;
 577     for (i = 0; i < len; i += 2)
 578     {
 579         r = retrying_read16(card, card->function, addr, &w);
 580         if (r != CSR_RESULT_SUCCESS)
 581         {
 582             return r;
 583         }
 584
 585         *cptr++ = ((u8)w & 0xFF);
 586         if ((m >= 0) && (((s8)w & 0xFF) == m))
 587         {
 588             break;
 589         }
 590
 591         if (i + 1 == len)
 592         {
 593             /* The len is odd. Ignore the last high byte */
 594             break;
 595         }
 596
 597         *cptr++ = ((u8)(w >> 8) & 0xFF);
 598         if ((m >= 0) && (((s8)(w >> 8) & 0xFF) == m))
 599         {
 600             break;
 601         }
 602
 603         addr += 2;
 604     }
 605
 606     *num = (s32)(cptr - (u8 *)pdata);
 607     return CSR_RESULT_SUCCESS;
 608 }
 609
 610
 611 /*
 612  * ---------------------------------------------------------------------------
 613  *  unifi_read_directn
 614  *
 615  *      Read multiple 8-bit values from the UniFi SDIO interface.
 616  *
 617  *  Arguments:
 618  *      card            Pointer to card structure.
 619  *      addr            Start address to read from.
 620  *      pdata           Pointer to which to write data.
 621  *      len             Number of bytes to read
 622  *
 623  *  Returns:
 624  *      0 on success, non-zero error code on error:
 625  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 626  *      CSR_RESULT_FAILURE     an SDIO error occurred
 627  *
 628  *  Notes:
 629  *      The even address *must* be read first. This is because reads from
 630  *      odd bytes are cached and read from memory when the preceding
 631  *      even address is read.
 632  * ---------------------------------------------------------------------------
 633  */
 634 CsrResult unifi_read_directn(card_t *card, u32 addr, void *pdata, u16 len)
 635 {
 636     u32 num;
 637
 638     return unifi_read_directn_match(card, addr, pdata, len, -1, &num);
 639 } /* unifi_read_directn() */
 640
 641
 642 /*
 643  * ---------------------------------------------------------------------------
 644  *  unifi_write_directn
 645  *
 646  *      Write multiple 8-bit values to the UniFi SDIO interface.
 647  *
 648  *  Arguments:
 649  *      card            Pointer to card structure.
 650  *      addr            Start address to write to.
 651  *      pdata           Source data pointer.
 652  *      len             Number of bytes to write, must be even.
 653  *
 654  *  Returns:
 655  *      0 on success, non-zero error code on error:
 656  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 657  *      CSR_RESULT_FAILURE     an SDIO error occurred
 658  *
 659  *  Notes:
 660  *      The UniFi has a peculiar 16-bit bus architecture. Writes are only
 661  *      committed to memory when an even address is accessed. Writes to
 662  *      odd addresses are cached and only committed if the next write is
 663  *      to the preceding address.
 664  *      This means we must write data as pairs of bytes in reverse order.
 665  * ---------------------------------------------------------------------------
 666  */
 667 CsrResult unifi_write_directn(card_t *card, u32 addr, void *pdata, u16 len)
 668 {
 669     CsrResult r;
 670     u8 *cptr;
 671     s16 signed_len;
 672
 673     cptr = (u8 *)pdata;
 674     signed_len = (s16)len;
 675     while (signed_len > 0)
 676     {
 677         /* This is UniFi-1 specific code. CSPI not supported so 8-bit write allowed */
 678         r = retrying_write16(card, card->function, addr, *cptr);
 679         if (r != CSR_RESULT_SUCCESS)
 680         {
 681             return r;
 682         }
 683
 684         cptr += 2;
 685         addr += 2;
 686         signed_len -= 2;
 687     }
 688
 689     return CSR_RESULT_SUCCESS;
 690 } /* unifi_write_directn() */
 691
 692
 693 /*
 694  * ---------------------------------------------------------------------------
 695  *  set_dmem_page
 696  *  set_pmem_page
 697  *
 698  *      Set up the page register for the shared data memory window or program
 699  *      memory window.
 700  *
 701  *  Arguments:
 702  *      card            Pointer to card structure.
 703  *      dmem_addr       UniFi shared-data-memory address to access.
 704  *      pmem_addr       UniFi program memory address to access. This includes
 705  *                        External FLASH memory at    0x000000
 706  *                        Processor program memory at 0x200000
 707  *                        External SRAM at memory     0x400000
 708  *      paddr           Location to write an SDIO address (24-bit) for
 709  *                       use in a unifi_read_direct or unifi_write_direct call.
 710  *
 711  *  Returns:
 712  *      CSR_RESULT_SUCCESS on success
 713  *      CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
 714  *      CSR_RESULT_FAILURE an SDIO error occurred
 715  * ---------------------------------------------------------------------------
 716  */
 717 static CsrResult set_dmem_page(card_t *card, u32 dmem_addr, u32 *paddr)
 718 {
 719     u16 page, addr;
 720     u32 len;
 721     CsrResult r;
 722
 723     *paddr = 0;
 724
 725     if (!ChipHelper_DecodeWindow(card->helper,
 726                                  CHIP_HELPER_WINDOW_3,
 727                                  CHIP_HELPER_WT_SHARED,
 728                                  dmem_addr / 2,
 729                                  &page, &addr, &len))
 730     {
 731         unifi_error(card->ospriv, "Failed to decode SHARED_DMEM_PAGE %08lx\n", dmem_addr);
 732         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 733     }
 734
 735     if (page != card->dmem_page)
 736     {
 737         unifi_trace(card->ospriv, UDBG6, "setting dmem page=0x%X, addr=0x%lX\n", page, addr);
 738
 739         /* change page register */
 740         r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW3_PAGE(card->helper) * 2, page);
 741         if (r != CSR_RESULT_SUCCESS)
 742         {
 743             unifi_error(card->ospriv, "Failed to write SHARED_DMEM_PAGE\n");
 744             return r;
 745         }
 746
 747         card->dmem_page = page;
 748     }
 749
 750     *paddr = ((s32)addr * 2) + (dmem_addr & 1);
 751
 752     return CSR_RESULT_SUCCESS;
 753 } /* set_dmem_page() */
 754
 755
 756 static CsrResult set_pmem_page(card_t *card, u32 pmem_addr,
 757                                enum chip_helper_window_type mem_type, u32 *paddr)
 758 {
 759     u16 page, addr;
 760     u32 len;
 761     CsrResult r;
 762
 763     *paddr = 0;
 764
 765     if (!ChipHelper_DecodeWindow(card->helper,
 766                                  CHIP_HELPER_WINDOW_2,
 767                                  mem_type,
 768                                  pmem_addr / 2,
 769                                  &page, &addr, &len))
 770     {
 771         unifi_error(card->ospriv, "Failed to decode PROG MEM PAGE %08lx %d\n", pmem_addr, mem_type);
 772         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 773     }
 774
 775     if (page != card->pmem_page)
 776     {
 777         unifi_trace(card->ospriv, UDBG6, "setting pmem page=0x%X, addr=0x%lX\n", page, addr);
 778
 779         /* change page register */
 780         r = unifi_write_direct16(card, ChipHelper_HOST_WINDOW2_PAGE(card->helper) * 2, page);
 781         if (r != CSR_RESULT_SUCCESS)
 782         {
 783             unifi_error(card->ospriv, "Failed to write PROG MEM PAGE\n");
 784             return r;
 785         }
 786
 787         card->pmem_page = page;
 788     }
 789
 790     *paddr = ((s32)addr * 2) + (pmem_addr & 1);
 791
 792     return CSR_RESULT_SUCCESS;
 793 } /* set_pmem_page() */
 794
 795
 796 /*
 797  * ---------------------------------------------------------------------------
 798  *  set_page
 799  *
 800  *      Sets up the appropriate page register to access the given address.
 801  *      Returns the sdio address at which the unifi address can be accessed.
 802  *
 803  *  Arguments:
 804  *      card            Pointer to card structure.
 805  *      generic_addr    UniFi internal address to access, in Generic Pointer
 806  *                      format, i.e. top byte is space indicator.
 807  *      paddr           Location to write page address
 808  *                          SDIO address (24-bit) for use in a unifi_read_direct or
 809  *                          unifi_write_direct call
 810  *
 811  *  Returns:
 812  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
 813  *      CSR_RESULT_FAILURE     an SDIO error occurred
 814  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  the address is invalid
 815  * ---------------------------------------------------------------------------
 816  */
 817 static CsrResult set_page(card_t *card, u32 generic_addr, u32 *paddr)
 818 {
 819     s32 space;
 820     u32 addr;
 821     CsrResult r = CSR_RESULT_SUCCESS;
 822
 823     if (!paddr)
 824     {
 825         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 826     }
 827     *paddr = 0;
 828     space = UNIFI_GP_SPACE(generic_addr);
 829     addr = UNIFI_GP_OFFSET(generic_addr);
 830     switch (space)
 831     {
 832         case UNIFI_SH_DMEM:
 833             /* Shared Data Memory is accessed via the Shared Data Memory window */
 834             r = set_dmem_page(card, addr, paddr);
 835             if (r != CSR_RESULT_SUCCESS)
 836             {
 837                 return r;
 838             }
 839             break;
 840
 841         case UNIFI_EXT_FLASH:
 842             if (!ChipHelper_HasFlash(card->helper))
 843             {
 844                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 845                             generic_addr, card->helper);
 846                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 847             }
 848             /* External FLASH is accessed via the Program Memory window */
 849             r = set_pmem_page(card, addr, CHIP_HELPER_WT_FLASH, paddr);
 850             break;
 851
 852         case UNIFI_EXT_SRAM:
 853             if (!ChipHelper_HasExtSram(card->helper))
 854             {
 855                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08l (helper=0x%x)\n",
 856                             generic_addr, card->helper);
 857                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 858             }
 859             /* External SRAM is accessed via the Program Memory window */
 860             r = set_pmem_page(card, addr, CHIP_HELPER_WT_EXT_SRAM, paddr);
 861             break;
 862
 863         case UNIFI_REGISTERS:
 864             /* Registers are accessed directly */
 865             *paddr = addr;
 866             break;
 867
 868         case UNIFI_PHY_DMEM:
 869             r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
 870             if (r != CSR_RESULT_SUCCESS)
 871             {
 872                 return r;
 873             }
 874             *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
 875             break;
 876
 877         case UNIFI_MAC_DMEM:
 878             r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
 879             if (r != CSR_RESULT_SUCCESS)
 880             {
 881                 return r;
 882             }
 883             *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
 884             break;
 885
 886         case UNIFI_BT_DMEM:
 887             if (!ChipHelper_HasBt(card->helper))
 888             {
 889                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 890                             generic_addr, card->helper);
 891                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 892             }
 893             r = unifi_set_proc_select(card, UNIFI_PROC_BT);
 894             if (r != CSR_RESULT_SUCCESS)
 895             {
 896                 return r;
 897             }
 898             *paddr = ChipHelper_DATA_MEMORY_RAM_OFFSET(card->helper) * 2 + addr;
 899             break;
 900
 901         case UNIFI_PHY_PMEM:
 902             r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
 903             if (r != CSR_RESULT_SUCCESS)
 904             {
 905                 return r;
 906             }
 907             r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
 908             break;
 909
 910         case UNIFI_MAC_PMEM:
 911             r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
 912             if (r != CSR_RESULT_SUCCESS)
 913             {
 914                 return r;
 915             }
 916             r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
 917             break;
 918
 919         case UNIFI_BT_PMEM:
 920             if (!ChipHelper_HasBt(card->helper))
 921             {
 922                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 923                             generic_addr, card->helper);
 924                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 925             }
 926             r = unifi_set_proc_select(card, UNIFI_PROC_BT);
 927             if (r != CSR_RESULT_SUCCESS)
 928             {
 929                 return r;
 930             }
 931             r = set_pmem_page(card, addr, CHIP_HELPER_WT_CODE_RAM, paddr);
 932             break;
 933
 934         case UNIFI_PHY_ROM:
 935             if (!ChipHelper_HasRom(card->helper))
 936             {
 937                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 938                             generic_addr, card->helper);
 939                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 940             }
 941             r = unifi_set_proc_select(card, UNIFI_PROC_PHY);
 942             if (r != CSR_RESULT_SUCCESS)
 943             {
 944                 return r;
 945             }
 946             r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
 947             break;
 948
 949         case UNIFI_MAC_ROM:
 950             if (!ChipHelper_HasRom(card->helper))
 951             {
 952                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 953                             generic_addr, card->helper);
 954                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 955             }
 956             r = unifi_set_proc_select(card, UNIFI_PROC_MAC);
 957             if (r != CSR_RESULT_SUCCESS)
 958             {
 959                 return r;
 960             }
 961             r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
 962             break;
 963
 964         case UNIFI_BT_ROM:
 965             if (!ChipHelper_HasRom(card->helper) || !ChipHelper_HasBt(card->helper))
 966             {
 967                 unifi_error(card->ospriv, "Bad address space for chip in generic pointer 0x%08lX (helper=0x%x)\n",
 968                             generic_addr, card->helper);
 969                 return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 970             }
 971             r = unifi_set_proc_select(card, UNIFI_PROC_BT);
 972             if (r != CSR_RESULT_SUCCESS)
 973             {
 974                 return r;
 975             }
 976             r = set_pmem_page(card, addr, CHIP_HELPER_WT_ROM, paddr);
 977             break;
 978
 979         default:
 980             unifi_error(card->ospriv, "Bad address space %d in generic pointer 0x%08lX (helper=0x%x)\n",
 981                         space, generic_addr, card->helper);
 982             return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
 983     }
 984
 985     return r;
 986 } /* set_page() */
 987
 988
 989 /*
 990  * ---------------------------------------------------------------------------
 991  *  unifi_set_proc_select
 992  *
 993  *
 994  *  Arguments:
 995  *      card            Pointer to card structure.
 996  *      select          Which XAP core to select
 997  *
 998  *  Returns:
 999  *      0 on success, non-zero error code on error:
1000  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1001  *      CSR_RESULT_FAILURE     an SDIO error occurred
1002  * ---------------------------------------------------------------------------
1003  */
1004 CsrResult unifi_set_proc_select(card_t *card, enum unifi_dbg_processors_select select)
1005 {
1006     CsrResult r;
1007
1008     /* Verify the the select value is allowed. */
1009     switch (select)
1010     {
1011         case UNIFI_PROC_MAC:
1012         case UNIFI_PROC_PHY:
1013         case UNIFI_PROC_BOTH:
1014             break;
1015
1016
1017         default:
1018             return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
1019     }
1020
1021     if (card->proc_select != (u32)select)
1022     {
1023         r = unifi_write_direct16(card,
1024                                  ChipHelper_DBG_HOST_PROC_SELECT(card->helper) * 2,
1025                                  (u8)select);
1026         if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
1027         {
1028             return r;
1029         }
1030         if (r != CSR_RESULT_SUCCESS)
1031         {
1032             unifi_error(card->ospriv, "Failed to write to Proc Select register\n");
1033             return r;
1034         }
1035
1036         card->proc_select = (u32)select;
1037     }
1038
1039     return CSR_RESULT_SUCCESS;
1040 }
1041
1042
1043 /*
1044  * ---------------------------------------------------------------------------
1045  * unifi_read_8_or_16
1046  *
1047  * Performs a byte read of the given address in shared data memory.
1048  * Set up the shared data memory page register as required.
1049  *
1050  * Arguments:
1051  * card Pointer to card structure.
1052  * unifi_addr UniFi shared-data-memory address to access.
1053  * pdata Pointer to a byte variable for the value read.
1054  *
1055  * Returns:
1056  * CSR_RESULT_SUCCESS on success, non-zero error code on error:
1057  * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
1058  * CSR_RESULT_FAILURE an SDIO error occurred
1059  * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
1060  * ---------------------------------------------------------------------------
1061  */
1062 CsrResult unifi_read_8_or_16(card_t *card, u32 unifi_addr, u8 *pdata)
1063 {
1064     u32 sdio_addr;
1065     CsrResult r;
1066 #ifdef CSR_WIFI_TRANSPORT_CSPI
1067     u16 w;
1068 #endif
1069
1070     r = set_page(card, unifi_addr, &sdio_addr);
1071     if (r != CSR_RESULT_SUCCESS)
1072     {
1073         return r;
1074     }
1075
1076 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1077     card->cmd_prof.cmd52_r8or16_count++;
1078 #endif
1079 #ifdef CSR_WIFI_TRANSPORT_CSPI
1080     r = retrying_read16(card, card->function, sdio_addr, &w);
1081     *pdata = (u8)(w & 0xFF);
1082     return r;
1083 #else
1084     return retrying_read8(card, card->function, sdio_addr, pdata);
1085 #endif
1086 } /* unifi_read_8_or_16() */
1087
1088
1089 /*
1090  * ---------------------------------------------------------------------------
1091  * unifi_write_8_or_16
1092  *
1093  * Performs a byte write of the given address in shared data memory.
1094  * Set up the shared data memory page register as required.
1095  *
1096  * Arguments:
1097  * card Pointer to card context struct.
1098  * unifi_addr UniFi shared-data-memory address to access.
1099  * data Value to write.
1100  *
1101  * Returns:
1102  * CSR_RESULT_SUCCESS on success, non-zero error code on error:
1103  * CSR_WIFI_HIP_RESULT_NO_DEVICE card was ejected
1104  * CSR_RESULT_FAILURE an SDIO error occurred
1105  * CSR_WIFI_HIP_RESULT_INVALID_VALUE a bad generic pointer was specified
1106  *
1107  * Notes:
1108  * Beware using unifi_write8() because byte writes are not safe on UniFi.
1109  * Writes to odd bytes are cached, writes to even bytes perform a 16-bit
1110  * write with the previously cached odd byte.
1111  * ---------------------------------------------------------------------------
1112  */
1113 CsrResult unifi_write_8_or_16(card_t *card, u32 unifi_addr, u8 data)
1114 {
1115     u32 sdio_addr;
1116     CsrResult r;
1117 #ifdef CSR_WIFI_TRANSPORT_CSPI
1118     u16 w;
1119 #endif
1120
1121     r = set_page(card, unifi_addr, &sdio_addr);
1122     if (r != CSR_RESULT_SUCCESS)
1123     {
1124         return r;
1125     }
1126
1127     if (sdio_addr & 1)
1128     {
1129         unifi_warning(card->ospriv,
1130                       "Warning: Byte write to an odd address (0x%lX) is dangerous\n",
1131                       sdio_addr);
1132     }
1133
1134 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1135     card->cmd_prof.cmd52_w8or16_count++;
1136 #endif
1137 #ifdef CSR_WIFI_TRANSPORT_CSPI
1138     w = data;
1139     return retrying_write16(card, card->function, sdio_addr, w);
1140 #else
1141     return retrying_write8(card, card->function, sdio_addr, data);
1142 #endif
1143 } /* unifi_write_8_or_16() */
1144
1145
1146 /*
1147  * ---------------------------------------------------------------------------
1148  *  unifi_card_read16
1149  *
1150  *      Performs a 16-bit read of the given address in shared data memory.
1151  *      Set up the shared data memory page register as required.
1152  *
1153  *  Arguments:
1154  *      card            Pointer to card structure.
1155  *      unifi_addr      UniFi shared-data-memory address to access.
1156  *      pdata           Pointer to a 16-bit int variable for the value read.
1157  *
1158  *  Returns:
1159  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
1160  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1161  *      CSR_RESULT_FAILURE     an SDIO error occurred
1162  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
1163  * ---------------------------------------------------------------------------
1164  */
1165 CsrResult unifi_card_read16(card_t *card, u32 unifi_addr, u16 *pdata)
1166 {
1167     u32 sdio_addr;
1168     CsrResult r;
1169
1170     r = set_page(card, unifi_addr, &sdio_addr);
1171     if (r != CSR_RESULT_SUCCESS)
1172     {
1173         return r;
1174     }
1175
1176 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1177     card->cmd_prof.cmd52_r16_count++;
1178 #endif
1179     return unifi_read_direct16(card, sdio_addr, pdata);
1180 } /* unifi_card_read16() */
1181
1182
1183 /*
1184  * ---------------------------------------------------------------------------
1185  *  unifi_card_write16
1186  *
1187  *      Performs a 16-bit write of the given address in shared data memory.
1188  *      Set up the shared data memory page register as required.
1189  *
1190  *  Arguments:
1191  *      card            Pointer to card structure.
1192  *      unifi_addr      UniFi shared-data-memory address to access.
1193  *      pdata           Pointer to a byte variable for the value write.
1194  *
1195  *  Returns:
1196  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
1197  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1198  *      CSR_RESULT_FAILURE     an SDIO error occurred
1199  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
1200  * ---------------------------------------------------------------------------
1201  */
1202 CsrResult unifi_card_write16(card_t *card, u32 unifi_addr, u16 data)
1203 {
1204     u32 sdio_addr;
1205     CsrResult r;
1206
1207     r = set_page(card, unifi_addr, &sdio_addr);
1208     if (r != CSR_RESULT_SUCCESS)
1209     {
1210         return r;
1211     }
1212
1213 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1214     card->cmd_prof.cmd52_w16_count++;
1215 #endif
1216     return unifi_write_direct16(card, sdio_addr, data);
1217 } /* unifi_card_write16() */
1218
1219
1220 /*
1221  * ---------------------------------------------------------------------------
1222  *  unifi_read32
1223  *
1224  *      Performs a 32-bit read of the given address in shared data memory.
1225  *      Set up the shared data memory page register as required.
1226  *
1227  *  Arguments:
1228  *      card            Pointer to card structure.
1229  *      unifi_addr      UniFi shared-data-memory address to access.
1230  *      pdata           Pointer to a int variable for the value read.
1231  *
1232  *  Returns:
1233  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
1234  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1235  *      CSR_RESULT_FAILURE     an SDIO error occurred
1236  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
1237  * ---------------------------------------------------------------------------
1238  */
1239 CsrResult unifi_read32(card_t *card, u32 unifi_addr, u32 *pdata)
1240 {
1241     u32 sdio_addr;
1242     CsrResult r;
1243
1244     r = set_page(card, unifi_addr, &sdio_addr);
1245     if (r != CSR_RESULT_SUCCESS)
1246     {
1247         return r;
1248     }
1249
1250 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1251     card->cmd_prof.cmd52_r32_count++;
1252 #endif
1253     return unifi_read_direct32(card, sdio_addr, pdata);
1254 } /* unifi_read32() */
1255
1256
1257 /*
1258  * ---------------------------------------------------------------------------
1259  *  unifi_card_readn
1260  *  unifi_readnz
1261  *
1262  *      Read multiple 8-bit values from the UniFi SDIO interface.
1263  *      This function interprets the address as a GenericPointer as
1264  *      defined in the UniFi Host Interface Protocol Specification.
1265  *      The readnz version of this function will stop when it reads a
1266  *      zero octet.
1267  *
1268  *  Arguments:
1269  *      card            Pointer to card structure.
1270  *      unifi_addr      UniFi shared-data-memory address to access.
1271  *      pdata           Pointer to which to write data.
1272  *      len             Number of bytes to read
1273  *
1274  *  Returns:
1275  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
1276  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1277  *      CSR_RESULT_FAILURE     an SDIO error occurred
1278  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE  a bad generic pointer was specified
1279  * ---------------------------------------------------------------------------
1280  */
1281 CsrResult unifi_readn_match(card_t *card, u32 unifi_addr, void *pdata, u16 len, s8 match)
1282 {
1283     u32 sdio_addr;
1284     CsrResult r;
1285     u32 num;
1286
1287     r = set_page(card, unifi_addr, &sdio_addr);
1288     if (r != CSR_RESULT_SUCCESS)
1289     {
1290         return r;
1291     }
1292
1293     r = unifi_read_directn_match(card, sdio_addr, pdata, len, match, &num);
1294     return r;
1295 } /* unifi_readn_match() */
1296
1297
1298 CsrResult unifi_card_readn(card_t *card, u32 unifi_addr, void *pdata, u16 len)
1299 {
1300     return unifi_readn_match(card, unifi_addr, pdata, len, -1);
1301 } /* unifi_card_readn() */
1302
1303
1304 CsrResult unifi_readnz(card_t *card, u32 unifi_addr, void *pdata, u16 len)
1305 {
1306     return unifi_readn_match(card, unifi_addr, pdata, len, 0);
1307 } /* unifi_readnz() */
1308
1309
1310 /*
1311  * ---------------------------------------------------------------------------
1312  *  unifi_read_shared_count
1313  *
1314  *      Read signal count locations, checking for an SDIO error.  The
1315  *      signal count locations only contain a valid number if the
1316  *      highest bit isn't set.
1317  *
1318  *  Arguments:
1319  *      card            Pointer to card context structure.
1320  *      addr            Shared-memory address to read.
1321  *
1322  *  Returns:
1323  *      Value read from memory (0-127) or -1 on error
1324  * ---------------------------------------------------------------------------
1325  */
1326 s32 unifi_read_shared_count(card_t *card, u32 addr)
1327 {
1328     u8 b;
1329     /* I've increased this count, because I have seen cases where
1330      * there were three reads in a row with the top bit set.  I'm not
1331      * sure why this might have happened, but I can't see a problem
1332      * with increasing this limit.  It's better to take a while to
1333      * recover than to fail. */
1334 #define SHARED_READ_RETRY_LIMIT 10
1335     s32 i;
1336
1337     /*
1338      * Get the to-host-signals-written count.
1339      * The top-bit will be set if the firmware was in the process of
1340      * changing the value, in which case we read again.
1341      */
1342     /* Limit the number of repeats so we don't freeze */
1343     for (i = 0; i < SHARED_READ_RETRY_LIMIT; i++)
1344     {
1345         CsrResult r;
1346         r = unifi_read_8_or_16(card, addr, &b);
1347         if (r != CSR_RESULT_SUCCESS)
1348         {
1349             return -1;
1350         }
1351         if (!(b & 0x80))
1352         {
1353             /* There is a chance that the MSB may have contained invalid data
1354              * (overflow) at the time it was read. Therefore mask off the MSB.
1355              * This avoids a race between driver read and firmware write of the
1356              * word, the value we need is in the lower 8 bits anway.
1357              */
1358             return (s32)(b & 0xff);
1359         }
1360     }
1361
1362     return -1;                  /* this function has changed in WMM mods */
1363 } /* unifi_read_shared_count() */
1364
1365
1366 /*
1367  * ---------------------------------------------------------------------------
1368  *  unifi_writen
1369  *
1370  *      Write multiple 8-bit values to the UniFi SDIO interface using CMD52
1371  *      This function interprets the address as a GenericPointer as
1372  *      defined in the UniFi Host Interface Protocol Specification.
1373  *
1374  *  Arguments:
1375  *      card            Pointer to card structure.
1376  *      unifi_addr      UniFi shared-data-memory address to access.
1377  *      pdata           Pointer to which to write data.
1378  *      len             Number of bytes to write
1379  *
1380  *  Returns:
1381  *      0 on success, non-zero error code on error:
1382  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1383  *      CSR_RESULT_FAILURE     an SDIO error occurred
1384  *      CSR_WIFI_HIP_RESULT_INVALID_VALUE    an odd length or length too big.
1385  * ---------------------------------------------------------------------------
1386  */
1387 CsrResult unifi_writen(card_t *card, u32 unifi_addr, void *pdata, u16 len)
1388 {
1389     u32 sdio_addr;
1390     CsrResult r;
1391
1392     r = set_page(card, unifi_addr, &sdio_addr);
1393     if (r != CSR_RESULT_SUCCESS)
1394     {
1395         return r;
1396     }
1397
1398     return unifi_write_directn(card, sdio_addr, pdata, len);
1399 } /* unifi_writen() */
1400
1401
1402 static CsrResult csr_sdio_block_rw(card_t *card, s16 funcnum,
1403                                    u32 addr, u8 *pdata,
1404                                    u16 count, s16 dir_is_write)
1405 {
1406     CsrResult csrResult;
1407
1408     if (dir_is_write == UNIFI_SDIO_READ)
1409     {
1410 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
1411         unifi_debug_log_to_buf("r@%02X#%X=", addr, count);
1412 #endif
1413 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1414         unifi_debug_log_to_buf("R");
1415 #endif
1416         csrResult = CsrSdioRead(card->sdio_if, addr, pdata, count);
1417 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1418         unifi_debug_log_to_buf("<");
1419 #endif
1420     }
1421     else
1422     {
1423 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
1424         unifi_debug_log_to_buf("w@%02X#%X=", addr, count);
1425         unifi_debug_hex_to_buf(pdata, count > CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH?CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH : count);
1426 #endif
1427 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1428         unifi_debug_log_to_buf("W");
1429 #endif
1430         csrResult = CsrSdioWrite(card->sdio_if, addr, pdata, count);
1431 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_DATA_PLANE_PROFILE)
1432         unifi_debug_log_to_buf(">");
1433 #endif
1434     }
1435 #ifdef CSR_WIFI_HIP_DATA_PLANE_PROFILE
1436     card->cmd_prof.cmd53_count++;
1437 #endif
1438 #if defined (CSR_WIFI_HIP_DEBUG_OFFLINE) && defined (CSR_WIFI_HIP_SDIO_TRACE)
1439     if (csrResult != CSR_RESULT_SUCCESS)
1440     {
1441         unifi_debug_log_to_buf("error=%X", csrResult);
1442     }
1443     else if (dir_is_write == UNIFI_SDIO_READ)
1444     {
1445         unifi_debug_hex_to_buf(pdata, count > CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH?CSR_WIFI_HIP_SDIO_TRACE_DATA_LENGTH : count);
1446     }
1447     unifi_debug_string_to_buf("\n");
1448 #endif
1449     return csrResult;  /* CSR SDIO (not HIP) error code */
1450 }
1451
1452
1453 /*
1454  * ---------------------------------------------------------------------------
1455  *  unifi_bulk_rw
1456  *
1457  *      Transfer bulk data to or from the UniFi SDIO interface.
1458  *      This function is used to read or write signals and bulk data.
1459  *
1460  *  Arguments:
1461  *      card            Pointer to card structure.
1462  *      handle          Value to put in the Register Address field of the CMD53 req.
1463  *      data            Pointer to data to write.
1464  *      direction       One of UNIFI_SDIO_READ or UNIFI_SDIO_WRITE
1465  *
1466  *  Returns:
1467  *      CSR_RESULT_SUCCESS on success, non-zero error code on error:
1468  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1469  *      CSR_RESULT_FAILURE     an SDIO error occurred
1470  *
1471  *  Notes:
1472  *      This function uses SDIO CMD53, which is the block transfer mode.
1473  * ---------------------------------------------------------------------------
1474  */
1475 CsrResult unifi_bulk_rw(card_t *card, u32 handle, void *pdata,
1476                         u32 len, s16 direction)
1477 {
1478 #define CMD53_RETRIES 3
1479     /*
1480      * Ideally instead of sleeping, we want to busy wait.
1481      * Currently there is no framework API to do this. When it becomes available,
1482      * we can use it to busy wait using usecs
1483      */
1484 #define REWIND_RETRIES          15    /* when REWIND_DELAY==1msec, or 250 when REWIND_DELAY==50usecs */
1485 #define REWIND_POLLING_RETRIES  5
1486 #define REWIND_DELAY            1     /* msec or 50usecs */
1487     CsrResult csrResult;              /* SDIO error code */
1488     CsrResult r = CSR_RESULT_SUCCESS; /* HIP error code */
1489     s16 retries = CMD53_RETRIES;
1490     s16 stat_retries;
1491     u8 stat;
1492     s16 dump_read;
1493 #ifdef UNIFI_DEBUG
1494     u8 *pdata_lsb = ((u8 *)&pdata) + card->lsb;
1495 #endif
1496 #ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
1497     static s16 fake_error;
1498 #endif
1499
1500     dump_read = 0;
1501 #ifdef UNIFI_DEBUG
1502     if (*pdata_lsb & 1)
1503     {
1504         unifi_notice(card->ospriv, "CD53 request on a unaligned buffer (addr: 0x%X) dir %s-Host\n",
1505                      pdata, (direction == UNIFI_SDIO_READ)?"To" : "From");
1506         if (direction == UNIFI_SDIO_WRITE)
1507         {
1508             dump(pdata, (u16)len);
1509         }
1510         else
1511         {
1512             dump_read = 1;
1513         }
1514     }
1515 #endif
1516
1517     /* Defensive checks */
1518     if (!pdata)
1519     {
1520         unifi_error(card->ospriv, "Null pdata for unifi_bulk_rw() len: %d\n", len);
1521         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
1522     }
1523     if ((len & 1) || (len > 0xffff))
1524     {
1525         unifi_error(card->ospriv, "Impossible CMD53 length requested: %d\n", len);
1526         return CSR_WIFI_HIP_RESULT_INVALID_VALUE;
1527     }
1528
1529     while (1)
1530     {
1531         csrResult = csr_sdio_block_rw(card, card->function, handle,
1532                                       (u8 *)pdata, (u16)len,
1533                                       direction);
1534         if (csrResult == CSR_SDIO_RESULT_NO_DEVICE)
1535         {
1536             return CSR_WIFI_HIP_RESULT_NO_DEVICE;
1537         }
1538 #ifdef CSR_WIFI_MAKE_FAKE_CMD53_ERRORS
1539         if (++fake_error > 100)
1540         {
1541             fake_error = 90;
1542             unifi_warning(card->ospriv, "Faking a CMD53 error,\n");
1543             if (csrResult == CSR_RESULT_SUCCESS)
1544             {
1545                 csrResult = CSR_RESULT_FAILURE;
1546             }
1547         }
1548 #endif
1549         if (csrResult == CSR_RESULT_SUCCESS)
1550         {
1551             if (dump_read)
1552             {
1553                 dump(pdata, (u16)len);
1554             }
1555             break;
1556         }
1557
1558         /*
1559          * At this point the SDIO driver should have written the I/O Abort
1560          * register to notify UniFi that the command has failed.
1561          * UniFi-1 and UniFi-2 (not UF6xxx) use the same register to store the
1562          * Deep Sleep State. This means we have to restore the Deep Sleep
1563          * State (AWAKE in any case since we can not perform a CD53 in any other
1564          * state) by rewriting the I/O Abort register to its previous value.
1565          */
1566         if (card->chip_id <= SDIO_CARD_ID_UNIFI_2)
1567         {
1568             (void)unifi_set_host_state(card, UNIFI_HOST_STATE_AWAKE);
1569         }
1570
1571         /* If csr_sdio_block_rw() failed in a non-retryable way, or retries exhausted
1572          * then stop retrying
1573          */
1574         if (!retryable_sdio_error(csrResult))
1575         {
1576             unifi_error(card->ospriv, "Fatal error in a CMD53 transfer\n");
1577             break;
1578         }
1579
1580         /*
1581          * These happen from time to time, try again
1582          */
1583         if (--retries == 0)
1584         {
1585             break;
1586         }
1587
1588         unifi_trace(card->ospriv, UDBG4,
1589                     "Error in a CMD53 transfer, retrying (h:%d,l:%u)...\n",
1590                     (s16)handle & 0xff, len);
1591
1592         /* The transfer failed, rewind and try again */
1593         r = unifi_write_8_or_16(card, card->sdio_ctrl_addr + 8,
1594                                 (u8)(handle & 0xff));
1595         if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
1596         {
1597             return r;
1598         }
1599         if (r != CSR_RESULT_SUCCESS)
1600         {
1601             /*
1602              * If we can't even do CMD52 (register read/write) then
1603              * stop here.
1604              */
1605             unifi_error(card->ospriv, "Failed to write REWIND cmd\n");
1606             return r;
1607         }
1608
1609         /* Signal the UniFi to look for the rewind request. */
1610         r = CardGenInt(card);
1611         if (r != CSR_RESULT_SUCCESS)
1612         {
1613             return r;
1614         }
1615
1616         /* Wait for UniFi to acknowledge the rewind */
1617         stat_retries = REWIND_RETRIES;
1618         while (1)
1619         {
1620             r = unifi_read_8_or_16(card, card->sdio_ctrl_addr + 8, &stat);
1621             if (r == CSR_WIFI_HIP_RESULT_NO_DEVICE)
1622             {
1623                 return r;
1624             }
1625             if (r != CSR_RESULT_SUCCESS)
1626             {
1627                 unifi_error(card->ospriv, "Failed to read REWIND status\n");
1628                 return CSR_RESULT_FAILURE;
1629             }
1630
1631             if (stat == 0)
1632             {
1633                 break;
1634             }
1635             if (--stat_retries == 0)
1636             {
1637                 unifi_error(card->ospriv, "Timeout waiting for REWIND ready\n");
1638                 return CSR_RESULT_FAILURE;
1639             }
1640
1641             /* Poll for the ack a few times */
1642             if (stat_retries < REWIND_RETRIES - REWIND_POLLING_RETRIES)
1643             {
1644                 CsrThreadSleep(REWIND_DELAY);
1645             }
1646         }
1647     }
1648
1649     /* The call to csr_sdio_block_rw() still failed after retrying */
1650     if (csrResult != CSR_RESULT_SUCCESS)
1651     {
1652         unifi_error(card->ospriv, "Block %s failed after %d retries\n",
1653                     (direction == UNIFI_SDIO_READ)?"read" : "write",
1654                     CMD53_RETRIES - retries);
1655         /* Report any SDIO error as a general i/o error */
1656         return CSR_RESULT_FAILURE;
1657     }
1658
1659     /* Collect some stats */
1660     if (direction == UNIFI_SDIO_READ)
1661     {
1662         card->sdio_bytes_read += len;
1663     }
1664     else
1665     {
1666         card->sdio_bytes_written += len;
1667     }
1668
1669     return CSR_RESULT_SUCCESS;
1670 } /* unifi_bulk_rw() */
1671
1672
1673 /*
1674  * ---------------------------------------------------------------------------
1675  *  unifi_bulk_rw_noretry
1676  *
1677  *      Transfer bulk data to or from the UniFi SDIO interface.
1678  *      This function is used to read or write signals and bulk data.
1679  *
1680  *  Arguments:
1681  *      card            Pointer to card structure.
1682  *      handle          Value to put in the Register Address field of
1683  *                      the CMD53 req.
1684  *      data            Pointer to data to write.
1685  *      direction       One of UNIFI_SDIO_READ or UNIFI_SDIO_WRITE
1686  *
1687  *  Returns:
1688  *      0 on success, non-zero error code on error:
1689  *      CSR_WIFI_HIP_RESULT_NO_DEVICE  card was ejected
1690  *      CSR_RESULT_FAILURE     an SDIO error occurred
1691  *
1692  *  Notes:
1693  *      This function uses SDIO CMD53, which is the block transfer mode.
1694  * ---------------------------------------------------------------------------
1695  */
1696 CsrResult unifi_bulk_rw_noretry(card_t *card, u32 handle, void *pdata,
1697                                 u32 len, s16 direction)
1698 {
1699     CsrResult csrResult;
1700
1701     csrResult = csr_sdio_block_rw(card, card->function, handle,
1702                                   (u8 *)pdata, (u16)len, direction);
1703     if (csrResult != CSR_RESULT_SUCCESS)
1704     {
1705         unifi_error(card->ospriv, "Block %s failed\n",
1706                     (direction == UNIFI_SDIO_READ)?"read" : "write");
1707         return csrResult;
1708     }
1709
1710     return CSR_RESULT_SUCCESS;
1711 } /* unifi_bulk_rw_noretry() */
1712
1713