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 "rsi_sdio.h" 20 #include "rsi_common.h" 21 22 /** 23 * rsi_sdio_master_access_msword() - This function sets the AHB master access 24 * MS word in the SDIO slave registers. 25 * @adapter: Pointer to the adapter structure. 26 * @ms_word: ms word need to be initialized. 27 * 28 * Return: status: 0 on success, -1 on failure. 29 */ 30 int rsi_sdio_master_access_msword(struct rsi_hw *adapter, u16 ms_word) 31 { 32 u8 byte; 33 u8 function = 0; 34 int status = 0; 35 36 byte = (u8)(ms_word & 0x00FF); 37 38 rsi_dbg(INIT_ZONE, 39 "%s: MASTER_ACCESS_MSBYTE:0x%x\n", __func__, byte); 40 41 status = rsi_sdio_write_register(adapter, 42 function, 43 SDIO_MASTER_ACCESS_MSBYTE, 44 &byte); 45 if (status) { 46 rsi_dbg(ERR_ZONE, 47 "%s: fail to access MASTER_ACCESS_MSBYTE\n", 48 __func__); 49 return -1; 50 } 51 52 byte = (u8)(ms_word >> 8); 53 54 rsi_dbg(INIT_ZONE, "%s:MASTER_ACCESS_LSBYTE:0x%x\n", __func__, byte); 55 status = rsi_sdio_write_register(adapter, 56 function, 57 SDIO_MASTER_ACCESS_LSBYTE, 58 &byte); 59 return status; 60 } 61 62 /** 63 * rsi_process_pkt() - This Function reads rx_blocks register and figures out 64 * the size of the rx pkt. 65 * @common: Pointer to the driver private structure. 66 * 67 * Return: 0 on success, -1 on failure. 68 */ 69 static int rsi_process_pkt(struct rsi_common *common) 70 { 71 struct rsi_hw *adapter = common->priv; 72 u8 num_blks = 0; 73 u32 rcv_pkt_len = 0; 74 int status = 0; 75 76 status = rsi_sdio_read_register(adapter, 77 SDIO_RX_NUM_BLOCKS_REG, 78 &num_blks); 79 80 if (status) { 81 rsi_dbg(ERR_ZONE, 82 "%s: Failed to read pkt length from the card:\n", 83 __func__); 84 return status; 85 } 86 rcv_pkt_len = (num_blks * 256); 87 88 common->rx_data_pkt = kmalloc(rcv_pkt_len, GFP_KERNEL); 89 if (!common->rx_data_pkt) { 90 rsi_dbg(ERR_ZONE, "%s: Failed in memory allocation\n", 91 __func__); 92 return -ENOMEM; 93 } 94 95 status = rsi_sdio_host_intf_read_pkt(adapter, 96 common->rx_data_pkt, 97 rcv_pkt_len); 98 if (status) { 99 rsi_dbg(ERR_ZONE, "%s: Failed to read packet from card\n", 100 __func__); 101 goto fail; 102 } 103 104 status = rsi_read_pkt(common, rcv_pkt_len); 105 106 fail: 107 kfree(common->rx_data_pkt); 108 return status; 109 } 110 111 /** 112 * rsi_init_sdio_slave_regs() - This function does the actual initialization 113 * of SDBUS slave registers. 114 * @adapter: Pointer to the adapter structure. 115 * 116 * Return: status: 0 on success, -1 on failure. 117 */ 118 int rsi_init_sdio_slave_regs(struct rsi_hw *adapter) 119 { 120 struct rsi_91x_sdiodev *dev = 121 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 122 u8 function = 0; 123 u8 byte; 124 int status = 0; 125 126 if (dev->next_read_delay) { 127 byte = dev->next_read_delay; 128 status = rsi_sdio_write_register(adapter, 129 function, 130 SDIO_NXT_RD_DELAY2, 131 &byte); 132 if (status) { 133 rsi_dbg(ERR_ZONE, 134 "%s: Failed to write SDIO_NXT_RD_DELAY2\n", 135 __func__); 136 return -1; 137 } 138 } 139 140 if (dev->sdio_high_speed_enable) { 141 rsi_dbg(INIT_ZONE, "%s: Enabling SDIO High speed\n", __func__); 142 byte = 0x3; 143 144 status = rsi_sdio_write_register(adapter, 145 function, 146 SDIO_REG_HIGH_SPEED, 147 &byte); 148 if (status) { 149 rsi_dbg(ERR_ZONE, 150 "%s: Failed to enable SDIO high speed\n", 151 __func__); 152 return -1; 153 } 154 } 155 156 /* This tells SDIO FIFO when to start read to host */ 157 rsi_dbg(INIT_ZONE, "%s: Initialzing SDIO read start level\n", __func__); 158 byte = 0x24; 159 160 status = rsi_sdio_write_register(adapter, 161 function, 162 SDIO_READ_START_LVL, 163 &byte); 164 if (status) { 165 rsi_dbg(ERR_ZONE, 166 "%s: Failed to write SDIO_READ_START_LVL\n", __func__); 167 return -1; 168 } 169 170 rsi_dbg(INIT_ZONE, "%s: Initialzing FIFO ctrl registers\n", __func__); 171 byte = (128 - 32); 172 173 status = rsi_sdio_write_register(adapter, 174 function, 175 SDIO_READ_FIFO_CTL, 176 &byte); 177 if (status) { 178 rsi_dbg(ERR_ZONE, 179 "%s: Failed to write SDIO_READ_FIFO_CTL\n", __func__); 180 return -1; 181 } 182 183 byte = 32; 184 status = rsi_sdio_write_register(adapter, 185 function, 186 SDIO_WRITE_FIFO_CTL, 187 &byte); 188 if (status) { 189 rsi_dbg(ERR_ZONE, 190 "%s: Failed to write SDIO_WRITE_FIFO_CTL\n", __func__); 191 return -1; 192 } 193 194 return 0; 195 } 196 197 /** 198 * rsi_interrupt_handler() - This function read and process SDIO interrupts. 199 * @adapter: Pointer to the adapter structure. 200 * 201 * Return: None. 202 */ 203 void rsi_interrupt_handler(struct rsi_hw *adapter) 204 { 205 struct rsi_common *common = adapter->priv; 206 struct rsi_91x_sdiodev *dev = 207 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 208 int status; 209 enum sdio_interrupt_type isr_type; 210 u8 isr_status = 0; 211 u8 fw_status = 0; 212 213 dev->rx_info.sdio_int_counter++; 214 215 do { 216 mutex_lock(&common->tx_rxlock); 217 status = rsi_sdio_read_register(common->priv, 218 RSI_FN1_INT_REGISTER, 219 &isr_status); 220 if (status) { 221 rsi_dbg(ERR_ZONE, 222 "%s: Failed to Read Intr Status Register\n", 223 __func__); 224 mutex_unlock(&common->tx_rxlock); 225 return; 226 } 227 228 if (isr_status == 0) { 229 rsi_set_event(&common->tx_thread.event); 230 dev->rx_info.sdio_intr_status_zero++; 231 mutex_unlock(&common->tx_rxlock); 232 return; 233 } 234 235 rsi_dbg(ISR_ZONE, "%s: Intr_status = %x %d %d\n", 236 __func__, isr_status, (1 << MSDU_PKT_PENDING), 237 (1 << FW_ASSERT_IND)); 238 239 do { 240 RSI_GET_SDIO_INTERRUPT_TYPE(isr_status, isr_type); 241 242 switch (isr_type) { 243 case BUFFER_AVAILABLE: 244 dev->rx_info.watch_bufferfull_count = 0; 245 dev->rx_info.buffer_full = false; 246 dev->rx_info.semi_buffer_full = false; 247 dev->rx_info.mgmt_buffer_full = false; 248 rsi_sdio_ack_intr(common->priv, 249 (1 << PKT_BUFF_AVAILABLE)); 250 rsi_set_event(&common->tx_thread.event); 251 252 rsi_dbg(ISR_ZONE, 253 "%s: ==> BUFFER_AVAILABLE <==\n", 254 __func__); 255 dev->rx_info.buf_available_counter++; 256 break; 257 258 case FIRMWARE_ASSERT_IND: 259 rsi_dbg(ERR_ZONE, 260 "%s: ==> FIRMWARE Assert <==\n", 261 __func__); 262 status = rsi_sdio_read_register(common->priv, 263 SDIO_FW_STATUS_REG, 264 &fw_status); 265 if (status) { 266 rsi_dbg(ERR_ZONE, 267 "%s: Failed to read f/w reg\n", 268 __func__); 269 } else { 270 rsi_dbg(ERR_ZONE, 271 "%s: Firmware Status is 0x%x\n", 272 __func__ , fw_status); 273 rsi_sdio_ack_intr(common->priv, 274 (1 << FW_ASSERT_IND)); 275 } 276 277 common->fsm_state = FSM_CARD_NOT_READY; 278 break; 279 280 case MSDU_PACKET_PENDING: 281 rsi_dbg(ISR_ZONE, "Pkt pending interrupt\n"); 282 dev->rx_info.total_sdio_msdu_pending_intr++; 283 284 status = rsi_process_pkt(common); 285 if (status) { 286 rsi_dbg(ERR_ZONE, 287 "%s: Failed to read pkt\n", 288 __func__); 289 mutex_unlock(&common->tx_rxlock); 290 return; 291 } 292 break; 293 default: 294 rsi_sdio_ack_intr(common->priv, isr_status); 295 dev->rx_info.total_sdio_unknown_intr++; 296 isr_status = 0; 297 rsi_dbg(ISR_ZONE, 298 "Unknown Interrupt %x\n", 299 isr_status); 300 break; 301 } 302 isr_status ^= BIT(isr_type - 1); 303 } while (isr_status); 304 mutex_unlock(&common->tx_rxlock); 305 } while (1); 306 } 307 308 /** 309 * rsi_sdio_read_buffer_status_register() - This function is used to the read 310 * buffer status register and set 311 * relevant fields in 312 * rsi_91x_sdiodev struct. 313 * @adapter: Pointer to the driver hw structure. 314 * @q_num: The Q number whose status is to be found. 315 * 316 * Return: status: -1 on failure or else queue full/stop is indicated. 317 */ 318 int rsi_sdio_read_buffer_status_register(struct rsi_hw *adapter, u8 q_num) 319 { 320 struct rsi_common *common = adapter->priv; 321 struct rsi_91x_sdiodev *dev = 322 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 323 u8 buf_status = 0; 324 int status = 0; 325 326 status = rsi_sdio_read_register(common->priv, 327 RSI_DEVICE_BUFFER_STATUS_REGISTER, 328 &buf_status); 329 330 if (status) { 331 rsi_dbg(ERR_ZONE, 332 "%s: Failed to read status register\n", __func__); 333 return -1; 334 } 335 336 if (buf_status & (BIT(PKT_MGMT_BUFF_FULL))) { 337 if (!dev->rx_info.mgmt_buffer_full) 338 dev->rx_info.mgmt_buf_full_counter++; 339 dev->rx_info.mgmt_buffer_full = true; 340 } else { 341 dev->rx_info.mgmt_buffer_full = false; 342 } 343 344 if (buf_status & (BIT(PKT_BUFF_FULL))) { 345 if (!dev->rx_info.buffer_full) 346 dev->rx_info.buf_full_counter++; 347 dev->rx_info.buffer_full = true; 348 } else { 349 dev->rx_info.buffer_full = false; 350 } 351 352 if (buf_status & (BIT(PKT_BUFF_SEMI_FULL))) { 353 if (!dev->rx_info.semi_buffer_full) 354 dev->rx_info.buf_semi_full_counter++; 355 dev->rx_info.semi_buffer_full = true; 356 } else { 357 dev->rx_info.semi_buffer_full = false; 358 } 359 360 if ((q_num == MGMT_SOFT_Q) && (dev->rx_info.mgmt_buffer_full)) 361 return QUEUE_FULL; 362 363 if (dev->rx_info.buffer_full) 364 return QUEUE_FULL; 365 366 return QUEUE_NOT_FULL; 367 } 368 369 /** 370 * rsi_sdio_determine_event_timeout() - This Function determines the event 371 * timeout duration. 372 * @adapter: Pointer to the adapter structure. 373 * 374 * Return: timeout duration is returned. 375 */ 376 int rsi_sdio_determine_event_timeout(struct rsi_hw *adapter) 377 { 378 struct rsi_91x_sdiodev *dev = 379 (struct rsi_91x_sdiodev *)adapter->rsi_dev; 380 381 /* Once buffer full is seen, event timeout to occur every 2 msecs */ 382 if (dev->rx_info.buffer_full) 383 return 2; 384 385 return EVENT_WAIT_FOREVER; 386 } 387