drivers/net/wireless/rsi/rsi_91x_sdio_ops.c

   1 /**
   2  * Copyright (c) 2014 Redpine Signals Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  *
  16  */
  17
  18 #include <linux/firmware.h>
  19 #include <net/rsi_91x.h>
  20 #include "rsi_sdio.h"
  21 #include "rsi_common.h"
  22
  23 /**
  24  * rsi_sdio_master_access_msword() - This function sets the AHB master access
  25  *                                   MS word in the SDIO slave registers.
  26  * @adapter: Pointer to the adapter structure.
  27  * @ms_word: ms word need to be initialized.
  28  *
  29  * Return: status: 0 on success, -1 on failure.
  30  */
  31 int rsi_sdio_master_access_msword(struct rsi_hw *adapter, u16 ms_word)
  32 {
  33         u8 byte;
  34         u8 function = 0;
  35         int status = 0;
  36
  37         byte = (u8)(ms_word & 0x00FF);
  38
  39         rsi_dbg(INIT_ZONE,
  40                 "%s: MASTER_ACCESS_MSBYTE:0x%x\n", __func__, byte);
  41
  42         status = rsi_sdio_write_register(adapter,
  43                                          function,
  44                                          SDIO_MASTER_ACCESS_MSBYTE,
  45                                          &byte);
  46         if (status) {
  47                 rsi_dbg(ERR_ZONE,
  48                         "%s: fail to access MASTER_ACCESS_MSBYTE\n",
  49                         __func__);
  50                 return -1;
  51         }
  52
  53         byte = (u8)(ms_word >> 8);
  54
  55         rsi_dbg(INIT_ZONE, "%s:MASTER_ACCESS_LSBYTE:0x%x\n", __func__, byte);
  56         status = rsi_sdio_write_register(adapter,
  57                                          function,
  58                                          SDIO_MASTER_ACCESS_LSBYTE,
  59                                          &byte);
  60         return status;
  61 }
  62
  63 void rsi_sdio_rx_thread(struct rsi_common *common)
  64 {
  65         struct rsi_hw *adapter = common->priv;
  66         struct rsi_91x_sdiodev *sdev = adapter->rsi_dev;
  67         struct sk_buff *skb;
  68         int status;
  69
  70         do {
  71                 rsi_wait_event(&sdev->rx_thread.event, EVENT_WAIT_FOREVER);
  72                 rsi_reset_event(&sdev->rx_thread.event);
  73
  74                 while (true) {
  75                         if (atomic_read(&sdev->rx_thread.thread_done))
  76                                 goto out;
  77
  78                         skb = skb_dequeue(&sdev->rx_q.head);
  79                         if (!skb)
  80                                 break;
  81                         if (sdev->rx_q.num_rx_pkts > 0)
  82                                 sdev->rx_q.num_rx_pkts--;
  83                         status = rsi_read_pkt(common, skb->data, skb->len);
  84                         if (status) {
  85                                 rsi_dbg(ERR_ZONE, "Failed to read the packet\n");
  86                                 dev_kfree_skb(skb);
  87                                 break;
  88                         }
  89                         dev_kfree_skb(skb);
  90                 }
  91         } while (1);
  92
  93 out:
  94         rsi_dbg(INFO_ZONE, "%s: Terminated SDIO RX thread\n", __func__);
  95         skb_queue_purge(&sdev->rx_q.head);
  96         atomic_inc(&sdev->rx_thread.thread_done);
  97         complete_and_exit(&sdev->rx_thread.completion, 0);
  98 }
  99
 100 /**
 101  * rsi_process_pkt() - This Function reads rx_blocks register and figures out
 102  *                     the size of the rx pkt.
 103  * @common: Pointer to the driver private structure.
 104  *
 105  * Return: 0 on success, -1 on failure.
 106  */
 107 static int rsi_process_pkt(struct rsi_common *common)
 108 {
 109         struct rsi_hw *adapter = common->priv;
 110         struct rsi_91x_sdiodev *dev =
 111                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
 112         u8 num_blks = 0;
 113         u32 rcv_pkt_len = 0;
 114         int status = 0;
 115         u8 value = 0;
 116         struct sk_buff *skb;
 117
 118         if (dev->rx_q.num_rx_pkts >= RSI_MAX_RX_PKTS)
 119                 return 0;
 120
 121         num_blks = ((adapter->interrupt_status & 1) |
 122                         ((adapter->interrupt_status >> RECV_NUM_BLOCKS) << 1));
 123
 124         if (!num_blks) {
 125                 status = rsi_sdio_read_register(adapter,
 126                                                 SDIO_RX_NUM_BLOCKS_REG,
 127                                                 &value);
 128                 if (status) {
 129                         rsi_dbg(ERR_ZONE,
 130                                 "%s: Failed to read pkt length from the card:\n",
 131                                 __func__);
 132                         return status;
 133                 }
 134                 num_blks = value & 0x1f;
 135         }
 136
 137         if (dev->write_fail == 2)
 138                 rsi_sdio_ack_intr(common->priv, (1 << MSDU_PKT_PENDING));
 139
 140         if (unlikely(!num_blks)) {
 141                 dev->write_fail = 2;
 142                 return -1;
 143         }
 144
 145         rcv_pkt_len = (num_blks * 256);
 146
 147         skb = dev_alloc_skb(rcv_pkt_len);
 148         if (!skb)
 149                 return -ENOMEM;
 150
 151         status = rsi_sdio_host_intf_read_pkt(adapter, skb->data, rcv_pkt_len);
 152         if (status) {
 153                 rsi_dbg(ERR_ZONE, "%s: Failed to read packet from card\n",
 154                         __func__);
 155                 dev_kfree_skb(skb);
 156                 return status;
 157         }
 158         skb_put(skb, rcv_pkt_len);
 159         skb_queue_tail(&dev->rx_q.head, skb);
 160         dev->rx_q.num_rx_pkts++;
 161
 162         rsi_set_event(&dev->rx_thread.event);
 163
 164         return 0;
 165 }
 166
 167 /**
 168  * rsi_init_sdio_slave_regs() - This function does the actual initialization
 169  *                              of SDBUS slave registers.
 170  * @adapter: Pointer to the adapter structure.
 171  *
 172  * Return: status: 0 on success, -1 on failure.
 173  */
 174 int rsi_init_sdio_slave_regs(struct rsi_hw *adapter)
 175 {
 176         struct rsi_91x_sdiodev *dev =
 177                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
 178         u8 function = 0;
 179         u8 byte;
 180         int status = 0;
 181
 182         if (dev->next_read_delay) {
 183                 byte = dev->next_read_delay;
 184                 status = rsi_sdio_write_register(adapter,
 185                                                  function,
 186                                                  SDIO_NXT_RD_DELAY2,
 187                                                  &byte);
 188                 if (status) {
 189                         rsi_dbg(ERR_ZONE,
 190                                 "%s: Failed to write SDIO_NXT_RD_DELAY2\n",
 191                                 __func__);
 192                         return -1;
 193                 }
 194         }
 195
 196         if (dev->sdio_high_speed_enable) {
 197                 rsi_dbg(INIT_ZONE, "%s: Enabling SDIO High speed\n", __func__);
 198                 byte = 0x3;
 199
 200                 status = rsi_sdio_write_register(adapter,
 201                                                  function,
 202                                                  SDIO_REG_HIGH_SPEED,
 203                                                  &byte);
 204                 if (status) {
 205                         rsi_dbg(ERR_ZONE,
 206                                 "%s: Failed to enable SDIO high speed\n",
 207                                 __func__);
 208                         return -1;
 209                 }
 210         }
 211
 212         /* This tells SDIO FIFO when to start read to host */
 213         rsi_dbg(INIT_ZONE, "%s: Initialzing SDIO read start level\n", __func__);
 214         byte = 0x24;
 215
 216         status = rsi_sdio_write_register(adapter,
 217                                          function,
 218                                          SDIO_READ_START_LVL,
 219                                          &byte);
 220         if (status) {
 221                 rsi_dbg(ERR_ZONE,
 222                         "%s: Failed to write SDIO_READ_START_LVL\n", __func__);
 223                 return -1;
 224         }
 225
 226         rsi_dbg(INIT_ZONE, "%s: Initialzing FIFO ctrl registers\n", __func__);
 227         byte = (128 - 32);
 228
 229         status = rsi_sdio_write_register(adapter,
 230                                          function,
 231                                          SDIO_READ_FIFO_CTL,
 232                                          &byte);
 233         if (status) {
 234                 rsi_dbg(ERR_ZONE,
 235                         "%s: Failed to write SDIO_READ_FIFO_CTL\n", __func__);
 236                 return -1;
 237         }
 238
 239         byte = 32;
 240         status = rsi_sdio_write_register(adapter,
 241                                          function,
 242                                          SDIO_WRITE_FIFO_CTL,
 243                                          &byte);
 244         if (status) {
 245                 rsi_dbg(ERR_ZONE,
 246                         "%s: Failed to write SDIO_WRITE_FIFO_CTL\n", __func__);
 247                 return -1;
 248         }
 249
 250         return 0;
 251 }
 252
 253 /**
 254  * rsi_interrupt_handler() - This function read and process SDIO interrupts.
 255  * @adapter: Pointer to the adapter structure.
 256  *
 257  * Return: None.
 258  */
 259 void rsi_interrupt_handler(struct rsi_hw *adapter)
 260 {
 261         struct rsi_common *common = adapter->priv;
 262         struct rsi_91x_sdiodev *dev =
 263                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
 264         int status;
 265         enum sdio_interrupt_type isr_type;
 266         u8 isr_status = 0;
 267         u8 fw_status = 0;
 268
 269         dev->rx_info.sdio_int_counter++;
 270
 271         do {
 272                 mutex_lock(&common->rx_lock);
 273                 status = rsi_sdio_read_register(common->priv,
 274                                                 RSI_FN1_INT_REGISTER,
 275                                                 &isr_status);
 276                 if (status) {
 277                         rsi_dbg(ERR_ZONE,
 278                                 "%s: Failed to Read Intr Status Register\n",
 279                                 __func__);
 280                         mutex_unlock(&common->rx_lock);
 281                         return;
 282                 }
 283                 adapter->interrupt_status = isr_status;
 284
 285                 if (isr_status == 0) {
 286                         rsi_set_event(&common->tx_thread.event);
 287                         dev->rx_info.sdio_intr_status_zero++;
 288                         mutex_unlock(&common->rx_lock);
 289                         return;
 290                 }
 291
 292                 rsi_dbg(ISR_ZONE, "%s: Intr_status = %x %d %d\n",
 293                         __func__, isr_status, (1 << MSDU_PKT_PENDING),
 294                         (1 << FW_ASSERT_IND));
 295
 296                 do {
 297                         RSI_GET_SDIO_INTERRUPT_TYPE(isr_status, isr_type);
 298
 299                         switch (isr_type) {
 300                         case BUFFER_AVAILABLE:
 301                                 status = rsi_sdio_check_buffer_status(adapter,
 302                                                                       0);
 303                                 if (status < 0)
 304                                         rsi_dbg(ERR_ZONE,
 305                                                 "%s: Failed to check buffer status\n",
 306                                                 __func__);
 307                                 rsi_sdio_ack_intr(common->priv,
 308                                                   (1 << PKT_BUFF_AVAILABLE));
 309                                 rsi_set_event(&common->tx_thread.event);
 310
 311                                 rsi_dbg(ISR_ZONE,
 312                                         "%s: ==> BUFFER_AVAILABLE <==\n",
 313                                         __func__);
 314                                 dev->buff_status_updated = true;
 315                                 break;
 316
 317                         case FIRMWARE_ASSERT_IND:
 318                                 rsi_dbg(ERR_ZONE,
 319                                         "%s: ==> FIRMWARE Assert <==\n",
 320                                         __func__);
 321                                 status = rsi_sdio_read_register(common->priv,
 322                                                         SDIO_FW_STATUS_REG,
 323                                                         &fw_status);
 324                                 if (status) {
 325                                         rsi_dbg(ERR_ZONE,
 326                                                 "%s: Failed to read f/w reg\n",
 327                                                 __func__);
 328                                 } else {
 329                                         rsi_dbg(ERR_ZONE,
 330                                                 "%s: Firmware Status is 0x%x\n",
 331                                                 __func__ , fw_status);
 332                                         rsi_sdio_ack_intr(common->priv,
 333                                                           (1 << FW_ASSERT_IND));
 334                                 }
 335
 336                                 common->fsm_state = FSM_CARD_NOT_READY;
 337                                 break;
 338
 339                         case MSDU_PACKET_PENDING:
 340                                 rsi_dbg(ISR_ZONE, "Pkt pending interrupt\n");
 341                                 dev->rx_info.total_sdio_msdu_pending_intr++;
 342
 343                                 status = rsi_process_pkt(common);
 344                                 if (status) {
 345                                         rsi_dbg(ERR_ZONE,
 346                                                 "%s: Failed to read pkt\n",
 347                                                 __func__);
 348                                         mutex_unlock(&common->rx_lock);
 349                                         return;
 350                                 }
 351                                 break;
 352                         default:
 353                                 rsi_sdio_ack_intr(common->priv, isr_status);
 354                                 dev->rx_info.total_sdio_unknown_intr++;
 355                                 isr_status = 0;
 356                                 rsi_dbg(ISR_ZONE,
 357                                         "Unknown Interrupt %x\n",
 358                                         isr_status);
 359                                 break;
 360                         }
 361                         isr_status ^= BIT(isr_type - 1);
 362                 } while (isr_status);
 363                 mutex_unlock(&common->rx_lock);
 364         } while (1);
 365 }
 366
 367 /* This function is used to read buffer status register and
 368  * set relevant fields in rsi_91x_sdiodev struct.
 369  */
 370 int rsi_sdio_check_buffer_status(struct rsi_hw *adapter, u8 q_num)
 371 {
 372         struct rsi_common *common = adapter->priv;
 373         struct rsi_91x_sdiodev *dev =
 374                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
 375         u8 buf_status = 0;
 376         int status = 0;
 377         static int counter = 4;
 378
 379         if (!dev->buff_status_updated && counter) {
 380                 counter--;
 381                 goto out;
 382         }
 383
 384         dev->buff_status_updated = false;
 385         status = rsi_sdio_read_register(common->priv,
 386                                         RSI_DEVICE_BUFFER_STATUS_REGISTER,
 387                                         &buf_status);
 388
 389         if (status) {
 390                 rsi_dbg(ERR_ZONE,
 391                         "%s: Failed to read status register\n", __func__);
 392                 return -1;
 393         }
 394
 395         if (buf_status & (BIT(PKT_MGMT_BUFF_FULL))) {
 396                 if (!dev->rx_info.mgmt_buffer_full)
 397                         dev->rx_info.mgmt_buf_full_counter++;
 398                 dev->rx_info.mgmt_buffer_full = true;
 399         } else {
 400                 dev->rx_info.mgmt_buffer_full = false;
 401         }
 402
 403         if (buf_status & (BIT(PKT_BUFF_FULL))) {
 404                 if (!dev->rx_info.buffer_full)
 405                         dev->rx_info.buf_full_counter++;
 406                 dev->rx_info.buffer_full = true;
 407         } else {
 408                 dev->rx_info.buffer_full = false;
 409         }
 410
 411         if (buf_status & (BIT(PKT_BUFF_SEMI_FULL))) {
 412                 if (!dev->rx_info.semi_buffer_full)
 413                         dev->rx_info.buf_semi_full_counter++;
 414                 dev->rx_info.semi_buffer_full = true;
 415         } else {
 416                 dev->rx_info.semi_buffer_full = false;
 417         }
 418
 419         if (dev->rx_info.mgmt_buffer_full || dev->rx_info.buf_full_counter)
 420                 counter = 1;
 421         else
 422                 counter = 4;
 423
 424 out:
 425         if ((q_num == MGMT_SOFT_Q) && (dev->rx_info.mgmt_buffer_full))
 426                 return QUEUE_FULL;
 427
 428         if ((q_num < MGMT_SOFT_Q) && (dev->rx_info.buffer_full))
 429                 return QUEUE_FULL;
 430
 431         return QUEUE_NOT_FULL;
 432 }
 433
 434 /**
 435  * rsi_sdio_determine_event_timeout() - This Function determines the event
 436  *                                      timeout duration.
 437  * @adapter: Pointer to the adapter structure.
 438  *
 439  * Return: timeout duration is returned.
 440  */
 441 int rsi_sdio_determine_event_timeout(struct rsi_hw *adapter)
 442 {
 443         struct rsi_91x_sdiodev *dev =
 444                 (struct rsi_91x_sdiodev *)adapter->rsi_dev;
 445
 446         /* Once buffer full is seen, event timeout to occur every 2 msecs */
 447         if (dev->rx_info.buffer_full)
 448                 return 2;
 449
 450         return EVENT_WAIT_FOREVER;
 451 }