1 // SPDX-License-Identifier: GPL-2.0
2 /******************************************************************************
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
6 *******************************************************************************/
7 #define _SDIO_OPS_LINUX_C_
10 #include <rtw_debug.h>
12 static bool rtw_sdio_claim_host_needed(struct sdio_func *func)
14 struct dvobj_priv *dvobj = sdio_get_drvdata(func);
15 struct sdio_data *sdio_data = &dvobj->intf_data;
17 if (sdio_data->sys_sdio_irq_thd && sdio_data->sys_sdio_irq_thd == current)
22 inline void rtw_sdio_set_irq_thd(struct dvobj_priv *dvobj, void *thd_hdl)
24 struct sdio_data *sdio_data = &dvobj->intf_data;
26 sdio_data->sys_sdio_irq_thd = thd_hdl;
29 u8 sd_f0_read8(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
31 struct adapter *padapter;
32 struct dvobj_priv *psdiodev;
33 struct sdio_data *psdio;
36 struct sdio_func *func;
39 padapter = pintfhdl->padapter;
40 psdiodev = pintfhdl->pintf_dev;
41 psdio = &psdiodev->intf_data;
43 if (padapter->bSurpriseRemoved)
47 claim_needed = rtw_sdio_claim_host_needed(func);
50 sdio_claim_host(func);
51 v = sdio_f0_readb(func, addr, err);
53 sdio_release_host(func);
62 s32 _sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
64 struct adapter *padapter;
65 struct dvobj_priv *psdiodev;
66 struct sdio_data *psdio;
69 struct sdio_func *func;
71 padapter = pintfhdl->padapter;
72 psdiodev = pintfhdl->pintf_dev;
73 psdio = &psdiodev->intf_data;
75 if (padapter->bSurpriseRemoved)
80 for (i = 0; i < cnt; i++) {
81 pdata[i] = sdio_readb(func, addr + i, &err);
93 s32 sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
95 struct adapter *padapter;
96 struct dvobj_priv *psdiodev;
97 struct sdio_data *psdio;
100 struct sdio_func *func;
103 padapter = pintfhdl->padapter;
104 psdiodev = pintfhdl->pintf_dev;
105 psdio = &psdiodev->intf_data;
107 if (padapter->bSurpriseRemoved)
111 claim_needed = rtw_sdio_claim_host_needed(func);
114 sdio_claim_host(func);
115 err = _sd_cmd52_read(pintfhdl, addr, cnt, pdata);
117 sdio_release_host(func);
126 s32 _sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
128 struct adapter *padapter;
129 struct dvobj_priv *psdiodev;
130 struct sdio_data *psdio;
133 struct sdio_func *func;
135 padapter = pintfhdl->padapter;
136 psdiodev = pintfhdl->pintf_dev;
137 psdio = &psdiodev->intf_data;
139 if (padapter->bSurpriseRemoved)
144 for (i = 0; i < cnt; i++) {
145 sdio_writeb(func, pdata[i], addr + i, &err);
157 s32 sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
159 struct adapter *padapter;
160 struct dvobj_priv *psdiodev;
161 struct sdio_data *psdio;
164 struct sdio_func *func;
167 padapter = pintfhdl->padapter;
168 psdiodev = pintfhdl->pintf_dev;
169 psdio = &psdiodev->intf_data;
171 if (padapter->bSurpriseRemoved)
175 claim_needed = rtw_sdio_claim_host_needed(func);
178 sdio_claim_host(func);
179 err = _sd_cmd52_write(pintfhdl, addr, cnt, pdata);
181 sdio_release_host(func);
185 u8 sd_read8(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
187 struct adapter *padapter;
188 struct dvobj_priv *psdiodev;
189 struct sdio_data *psdio;
192 struct sdio_func *func;
195 padapter = pintfhdl->padapter;
196 psdiodev = pintfhdl->pintf_dev;
197 psdio = &psdiodev->intf_data;
199 if (padapter->bSurpriseRemoved)
203 claim_needed = rtw_sdio_claim_host_needed(func);
206 sdio_claim_host(func);
207 v = sdio_readb(func, addr, err);
209 sdio_release_host(func);
213 u32 sd_read32(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
215 struct adapter *padapter;
216 struct dvobj_priv *psdiodev;
217 struct sdio_data *psdio;
219 struct sdio_func *func;
222 padapter = pintfhdl->padapter;
223 psdiodev = pintfhdl->pintf_dev;
224 psdio = &psdiodev->intf_data;
226 if (padapter->bSurpriseRemoved)
230 claim_needed = rtw_sdio_claim_host_needed(func);
233 sdio_claim_host(func);
234 v = sdio_readl(func, addr, err);
236 sdio_release_host(func);
242 for (i = 0; i < SD_IO_TRY_CNT; i++) {
244 sdio_claim_host(func);
245 v = sdio_readl(func, addr, err);
247 sdio_release_host(func);
250 rtw_reset_continual_io_error(psdiodev);
253 if ((-ESHUTDOWN == *err) || (-ENODEV == *err))
254 padapter->bSurpriseRemoved = true;
256 if (rtw_inc_and_chk_continual_io_error(psdiodev) == true) {
257 padapter->bSurpriseRemoved = true;
266 void sd_write8(struct intf_hdl *pintfhdl, u32 addr, u8 v, s32 *err)
268 struct adapter *padapter;
269 struct dvobj_priv *psdiodev;
270 struct sdio_data *psdio;
271 struct sdio_func *func;
274 padapter = pintfhdl->padapter;
275 psdiodev = pintfhdl->pintf_dev;
276 psdio = &psdiodev->intf_data;
278 if (padapter->bSurpriseRemoved)
282 claim_needed = rtw_sdio_claim_host_needed(func);
285 sdio_claim_host(func);
286 sdio_writeb(func, v, addr, err);
288 sdio_release_host(func);
291 void sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
293 struct adapter *padapter;
294 struct dvobj_priv *psdiodev;
295 struct sdio_data *psdio;
296 struct sdio_func *func;
299 padapter = pintfhdl->padapter;
300 psdiodev = pintfhdl->pintf_dev;
301 psdio = &psdiodev->intf_data;
303 if (padapter->bSurpriseRemoved)
307 claim_needed = rtw_sdio_claim_host_needed(func);
310 sdio_claim_host(func);
311 sdio_writel(func, v, addr, err);
313 sdio_release_host(func);
319 for (i = 0; i < SD_IO_TRY_CNT; i++) {
321 sdio_claim_host(func);
322 sdio_writel(func, v, addr, err);
324 sdio_release_host(func);
326 rtw_reset_continual_io_error(psdiodev);
329 if ((-ESHUTDOWN == *err) || (-ENODEV == *err))
330 padapter->bSurpriseRemoved = true;
332 if (rtw_inc_and_chk_continual_io_error(psdiodev) == true) {
333 padapter->bSurpriseRemoved = true;
343 * Use CMD53 to read data from SDIO device.
344 * This function MUST be called after sdio_claim_host() or
345 * in SDIO ISR(host had been claimed).
348 *psdio pointer of SDIO_DATA
349 *addr address to read
351 *pdata pointer to put data, this should be a "DMA:able scratch buffer"!
357 s32 _sd_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
359 struct adapter *padapter;
360 struct dvobj_priv *psdiodev;
361 struct sdio_data *psdio;
364 struct sdio_func *func;
366 padapter = pintfhdl->padapter;
367 psdiodev = pintfhdl->pintf_dev;
368 psdio = &psdiodev->intf_data;
370 if (padapter->bSurpriseRemoved)
375 if (unlikely((cnt == 1) || (cnt == 2))) {
379 for (i = 0; i < cnt; i++) {
380 *(pbuf + i) = sdio_readb(func, addr + i, &err);
388 err = sdio_memcpy_fromio(func, pdata, addr, cnt);
394 * Use CMD53 to read data from SDIO device.
397 *psdio pointer of SDIO_DATA
398 *addr address to read
400 *pdata pointer to put data, this should be a "DMA:able scratch buffer"!
406 s32 sd_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
408 struct adapter *padapter;
409 struct dvobj_priv *psdiodev;
410 struct sdio_data *psdio;
412 struct sdio_func *func;
416 padapter = pintfhdl->padapter;
417 psdiodev = pintfhdl->pintf_dev;
418 psdio = &psdiodev->intf_data;
420 if (padapter->bSurpriseRemoved)
424 claim_needed = rtw_sdio_claim_host_needed(func);
427 sdio_claim_host(func);
428 err = _sd_read(pintfhdl, addr, cnt, pdata);
430 sdio_release_host(func);
435 * Use CMD53 to write data to SDIO device.
436 * This function MUST be called after sdio_claim_host() or
437 * in SDIO ISR(host had been claimed).
440 *psdio pointer of SDIO_DATA
441 *addr address to write
443 *pdata data pointer, this should be a "DMA:able scratch buffer"!
449 s32 _sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
451 struct adapter *padapter;
452 struct dvobj_priv *psdiodev;
453 struct sdio_data *psdio;
455 struct sdio_func *func;
459 padapter = pintfhdl->padapter;
460 psdiodev = pintfhdl->pintf_dev;
461 psdio = &psdiodev->intf_data;
463 if (padapter->bSurpriseRemoved)
467 /* size = sdio_align_size(func, cnt); */
469 if (unlikely((cnt == 1) || (cnt == 2))) {
473 for (i = 0; i < cnt; i++) {
474 sdio_writeb(func, *(pbuf + i), addr + i, &err);
483 err = sdio_memcpy_toio(func, addr, pdata, size);
489 * Use CMD53 to write data to SDIO device.
492 * psdio pointer of SDIO_DATA
493 * addr address to write
494 * cnt amount to write
495 * pdata data pointer, this should be a "DMA:able scratch buffer"!
501 s32 sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
503 struct adapter *padapter;
504 struct dvobj_priv *psdiodev;
505 struct sdio_data *psdio;
506 struct sdio_func *func;
510 padapter = pintfhdl->padapter;
511 psdiodev = pintfhdl->pintf_dev;
512 psdio = &psdiodev->intf_data;
514 if (padapter->bSurpriseRemoved)
518 claim_needed = rtw_sdio_claim_host_needed(func);
521 sdio_claim_host(func);
522 err = _sd_write(pintfhdl, addr, cnt, pdata);
524 sdio_release_host(func);