tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 */
30int 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 */
69static 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
106fail:
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 */
118int 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 */
203void 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 */
318int 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 */
376int 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}