1 /*
2  * Copyright (c) 2020-2023 Huawei Device Co., Ltd.
3  *
4  * HDF is dual licensed: you can use it either under the terms of
5  * the GPL, or the BSD license, at your option.
6  * See the LICENSE file in the root of this repository for complete details.
7  */
8 
9 #include "mmc_sdio.h"
10 
11 #define HDF_LOG_TAG mmc_sdio_c
12 #define SDIO_READ_IO_READY_RETRY_TIMES 10000
13 
SdioDeviceDefaultIncrAddrReadBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size)14 static int32_t SdioDeviceDefaultIncrAddrReadBytes(struct SdioDevice *dev,
15     uint8_t *data, uint32_t addr, uint32_t size)
16 {
17     struct SdioFunction *func = dev->curFunction;
18     struct MmcCntlr *cntlr = NULL;
19     struct SdioRwBlockInfo info = {0};
20 
21     if (func == NULL) {
22         HDF_LOGE("SdioDeviceDefaultIncrAddrReadBytes: fail, func is null!");
23         return HDF_ERR_INVALID_OBJECT;
24     }
25     if (data == NULL) {
26         HDF_LOGE("SdioDeviceDefaultIncrAddrReadBytes: fail, data is null!");
27         return HDF_ERR_INVALID_PARAM;
28     }
29 
30     cntlr = dev->sd.mmc.cntlr;
31     if (cntlr == NULL) {
32         HDF_LOGE("SdioDeviceDefaultIncrAddrReadBytes: fail, cntlr is null!");
33         return HDF_ERR_INVALID_OBJECT;
34     }
35 
36     if (size == 1) {
37         return SdioReadWriteByte(cntlr, false, func->funcNum, addr, data);
38     } else if (size > 1) {
39         info.addr = addr;
40         info.buf = data;
41         info.incrAddrFlag = true;
42         info.size = size;
43         info.writeFlag = false;
44         return SdioReadWriteBlock(cntlr, &info);
45     }
46     HDF_LOGE("SdioDeviceDefaultIncrAddrReadBytes: fail, data size is 0!");
47     return HDF_ERR_INVALID_PARAM;
48 }
49 
SdioDeviceDefaultIncrAddrWriteBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size)50 static int32_t SdioDeviceDefaultIncrAddrWriteBytes(struct SdioDevice *dev,
51     uint8_t *data, uint32_t addr, uint32_t size)
52 {
53     struct SdioFunction *func = dev->curFunction;
54     struct MmcCntlr *cntlr = NULL;
55     struct SdioRwBlockInfo info = {0};
56 
57     if (func == NULL) {
58         HDF_LOGE("SdioDeviceDefaultIncrAddrWriteBytes: fail, func is null!");
59         return HDF_ERR_INVALID_OBJECT;
60     }
61     if (data == NULL) {
62         HDF_LOGE("SdioDeviceDefaultIncrAddrWriteBytes: fail, data is null!");
63         return HDF_ERR_INVALID_PARAM;
64     }
65 
66     cntlr = dev->sd.mmc.cntlr;
67     if (cntlr == NULL) {
68         HDF_LOGE("SdioDeviceDefaultIncrAddrWriteBytes: fail, cntlr is null!");
69         return HDF_ERR_INVALID_OBJECT;
70     }
71 
72     if (size == 1) {
73         return SdioReadWriteByte(cntlr, true, func->funcNum, addr, data);
74     } else if (size > 1) {
75         info.addr = addr;
76         info.buf = data;
77         info.incrAddrFlag = true;
78         info.size = size;
79         info.writeFlag = true;
80         return SdioReadWriteBlock(cntlr, &info);
81     }
82     HDF_LOGE("SdioDeviceDefaultIncrAddrWriteBytes: fail, data size is 0!");
83     return HDF_ERR_INVALID_PARAM;
84 }
85 
SdioDeviceDefaultFixedAddrReadBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size,uint32_t scatterLen)86 static int32_t SdioDeviceDefaultFixedAddrReadBytes(struct SdioDevice *dev,
87     uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen)
88 {
89     struct SdioFunction *func = dev->curFunction;
90     struct MmcCntlr *cntlr = NULL;
91     struct SdioRwBlockInfo info = {0};
92 
93     if (func == NULL) {
94         HDF_LOGE("SdioDeviceDefaultFixedAddrReadBytes: fail, func is null!");
95         return HDF_ERR_INVALID_OBJECT;
96     }
97     if (data == NULL || size == 0) {
98         HDF_LOGE("SdioDeviceDefaultFixedAddrReadBytes: fail, param is invalid!");
99         return HDF_ERR_INVALID_PARAM;
100     }
101 
102     cntlr = dev->sd.mmc.cntlr;
103     if (cntlr == NULL) {
104         HDF_LOGE("SdioDeviceDefaultFixedAddrReadBytes: fail, cntlr is null!");
105         return HDF_ERR_INVALID_OBJECT;
106     }
107 
108     info.addr = addr;
109     info.buf = data;
110     info.incrAddrFlag = false;
111     info.size = size;
112     info.writeFlag = false;
113     if (scatterLen > 0) {
114         info.scatterFlag = true;
115         info.scatterLen = scatterLen;
116     }
117     return SdioReadWriteBlock(cntlr, &info);
118 }
119 
SdioDeviceDefaultFixedAddrWriteBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size,uint32_t scatterLen)120 static int32_t SdioDeviceDefaultFixedAddrWriteBytes(struct SdioDevice *dev,
121     uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen)
122 {
123     struct SdioFunction *func = dev->curFunction;
124     struct MmcCntlr *cntlr = NULL;
125     struct SdioRwBlockInfo info = {0};
126 
127     if (func == NULL) {
128         HDF_LOGE("SdioDeviceDefaultFixedAddrWriteBytes: fail, func is null!");
129         return HDF_ERR_INVALID_OBJECT;
130     }
131     if (data == NULL || size == 0) {
132         HDF_LOGE("SdioDeviceDefaultFixedAddrWriteBytes: fail, param is invalid!");
133         return HDF_ERR_INVALID_PARAM;
134     }
135 
136     cntlr = dev->sd.mmc.cntlr;
137     if (cntlr == NULL) {
138         HDF_LOGE("SdioDeviceDefaultFixedAddrWriteBytes: fail, cntlr is null!");
139         return HDF_ERR_INVALID_OBJECT;
140     }
141 
142     info.addr = addr;
143     info.buf = data;
144     info.incrAddrFlag = false;
145     info.size = size;
146     info.writeFlag = true;
147     if (scatterLen > 0) {
148         info.scatterFlag = true;
149         info.scatterLen = scatterLen;
150     }
151     return SdioReadWriteBlock(cntlr, &info);
152 }
153 
SdioDeviceDefaultFunc0ReadBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size)154 static int32_t SdioDeviceDefaultFunc0ReadBytes(struct SdioDevice *dev,
155     uint8_t *data, uint32_t addr, uint32_t size)
156 {
157     struct SdioFunction *func = dev->curFunction;
158     struct MmcCntlr *cntlr = NULL;
159     uint32_t i;
160     int32_t ret;
161 
162     if (func == NULL) {
163         HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, func is null!");
164         return HDF_ERR_INVALID_OBJECT;
165     }
166     if (data == NULL) {
167         HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, data is null!");
168         return HDF_ERR_INVALID_PARAM;
169     }
170     cntlr = dev->sd.mmc.cntlr;
171     if (cntlr == NULL) {
172         HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, cntlr is null!");
173         return HDF_ERR_INVALID_OBJECT;
174     }
175 
176     for (i = 0; i < size; i++) {
177         ret = SdioReadWriteByte(cntlr, false, 0, (addr + i), &data[i]);
178         if (ret != HDF_SUCCESS) {
179             HDF_LOGE("SdioDeviceDefaultFunc0ReadBytes: fail, i = %u!", i);
180             return ret;
181         }
182     }
183     return HDF_SUCCESS;
184 }
185 
SdioDeviceDefaultFunc0WriteBytes(struct SdioDevice * dev,uint8_t * data,uint32_t addr,uint32_t size)186 static int32_t SdioDeviceDefaultFunc0WriteBytes(struct SdioDevice *dev,
187     uint8_t *data, uint32_t addr, uint32_t size)
188 {
189     struct SdioFunction *func = dev->curFunction;
190     struct MmcCntlr *cntlr = NULL;
191     int32_t ret;
192     uint32_t i;
193 
194     if (func == NULL) {
195         HDF_LOGE("SdioDeviceDefaultFunc0WriteBytes: fail, func is null!");
196         return HDF_ERR_INVALID_OBJECT;
197     }
198     if (data == NULL) {
199         HDF_LOGE("SdioDeviceDefaultFunc0WriteBytes: fail, data is null!");
200         return HDF_ERR_INVALID_PARAM;
201     }
202     cntlr = dev->sd.mmc.cntlr;
203     if (cntlr == NULL) {
204         HDF_LOGE("SdioDeviceDefaultFunc0WriteBytes: fail, cntlr is null!");
205         return HDF_ERR_INVALID_OBJECT;
206     }
207 
208     for (i = 0; i < size; i++) {
209         ret = SdioReadWriteByte(cntlr, true, 0, (addr + i), &data[i]);
210         if (ret != HDF_SUCCESS) {
211             HDF_LOGE("SdioDeviceDefaultFunc0WriteBytes: fail, i = %u!", i);
212             return ret;
213         }
214     }
215     return HDF_SUCCESS;
216 }
217 
SdioDeviceDefaultSetBlockSize(struct SdioDevice * dev,uint32_t blkSize)218 static int32_t SdioDeviceDefaultSetBlockSize(struct SdioDevice *dev, uint32_t blkSize)
219 {
220     struct SdioFunction *func = dev->curFunction;
221     struct MmcCntlr *cntlr = NULL;
222     uint32_t blockSize = blkSize;
223     int32_t ret;
224 
225     if (func == NULL) {
226         HDF_LOGE("SdioDeviceDefaultSetBlockSize: func is null!");
227         return HDF_ERR_INVALID_OBJECT;
228     }
229 
230     cntlr = dev->sd.mmc.cntlr;
231     if (blockSize == 0) {
232         blockSize = ((func->maxBlkSize < cntlr->maxBlkSize) ? func->maxBlkSize : cntlr->maxBlkSize);
233     }
234     blockSize = MMC_MIN(blockSize, MMC_SEC_SIZE);
235 
236     ret = SdioSetFbrIoBlockSize(cntlr, blockSize);
237     if (ret == HDF_SUCCESS) {
238         func->curBlkSize = blockSize;
239     }
240     return ret;
241 }
242 
SdioDeviceDefaultGetCommonInfo(struct SdioDevice * dev,SdioCommonInfo * info,SdioCommonInfoType infoType)243 static int32_t SdioDeviceDefaultGetCommonInfo(struct SdioDevice *dev,
244     SdioCommonInfo *info, SdioCommonInfoType infoType)
245 {
246     struct MmcCntlr *cntlr = NULL;
247     struct SdioFunction *func = dev->curFunction;
248 
249     if (func == NULL) {
250         HDF_LOGE("SdioDeviceDefaultGetCommonInfo: func is null!");
251         return HDF_ERR_INVALID_OBJECT;
252     }
253     if (info == NULL) {
254         HDF_LOGE("SdioDeviceDefaultGetCommonInfo: info is null!");
255         return HDF_ERR_INVALID_PARAM;
256     }
257     if (infoType != SDIO_FUNC_INFO) {
258         HDF_LOGE("SdioDeviceDefaultGetCommonInfo: cur type %d is not support!", infoType);
259         return HDF_ERR_NOT_SUPPORT;
260     }
261 
262     cntlr = dev->sd.mmc.cntlr;
263     if (cntlr == NULL) {
264         HDF_LOGE("SdioDeviceDefaultGetCommonInfo fail, cntlr is null!");
265         return HDF_ERR_INVALID_PARAM;
266     }
267     info->funcInfo.enTimeout = func->timeOut;
268     info->funcInfo.maxBlockNum = cntlr->maxBlkNum;
269     info->funcInfo.maxBlockSize = cntlr->maxBlkSize;
270     info->funcInfo.maxRequestSize = cntlr->maxReqSize;
271     info->funcInfo.funcNum = func->funcNum;
272     info->funcInfo.irqCap = cntlr->caps.bits.sdioIrq;
273     info->funcInfo.data = (void *)func;
274     return HDF_SUCCESS;
275 }
276 
SdioDeviceDefaultSetCommonInfo(struct SdioDevice * dev,SdioCommonInfo * info,SdioCommonInfoType infoType)277 static int32_t SdioDeviceDefaultSetCommonInfo(struct SdioDevice *dev,
278     SdioCommonInfo *info, SdioCommonInfoType infoType)
279 {
280     struct MmcCntlr *cntlr = NULL;
281     struct SdioFunction *func = dev->curFunction;
282 
283     if (func == NULL) {
284         HDF_LOGE("SdioDeviceDefaultSetCommonInfo: func is null!");
285         return HDF_ERR_INVALID_OBJECT;
286     }
287     if (info == NULL) {
288         HDF_LOGE("SdioDeviceDefaultSetCommonInfo: info is null!");
289         return HDF_ERR_INVALID_PARAM;
290     }
291     if (infoType != SDIO_FUNC_INFO) {
292         HDF_LOGE("SdioDeviceDefaultSetCommonInfo: cur type %d is not support!", infoType);
293         return HDF_ERR_NOT_SUPPORT;
294     }
295 
296     cntlr = dev->sd.mmc.cntlr;
297     if (cntlr == NULL) {
298         HDF_LOGE("SdioDeviceDefaultSetCommonInfo fail, cntlr is null!");
299         return HDF_ERR_INVALID_PARAM;
300     }
301 
302     func->timeOut = info->funcInfo.enTimeout;
303     cntlr->maxBlkNum = info->funcInfo.maxBlockNum;
304     cntlr->maxBlkSize = info->funcInfo.maxBlockSize;
305     cntlr->maxReqSize = info->funcInfo.maxRequestSize;
306     func->funcNum = info->funcInfo.funcNum;
307     return HDF_SUCCESS;
308 }
309 
SdioDeviceDefaultFlushData(struct SdioDevice * dev)310 static int32_t SdioDeviceDefaultFlushData(struct SdioDevice *dev)
311 {
312     struct MmcCntlr *cntlr = NULL;
313 
314     cntlr = dev->sd.mmc.cntlr;
315     if (cntlr == NULL) {
316         HDF_LOGE("SdioDeviceDefaultFlushData fail, cntlr is null!");
317         return HDF_ERR_INVALID_OBJECT;
318     }
319     return SdioReinit(cntlr);
320 }
321 
SdioDeviceDefaultEnableFunc(struct SdioDevice * dev)322 static int32_t SdioDeviceDefaultEnableFunc(struct SdioDevice *dev)
323 {
324     struct SdioFunction *func = dev->curFunction;
325     int32_t ret;
326     uint32_t i;
327     uint8_t val;
328 
329     if (func == NULL) {
330         HDF_LOGE("SdioDeviceDefaultEnableFunc: func is null!");
331         return HDF_ERR_INVALID_OBJECT;
332     }
333 
334     ret = SdioCccrIoEnable(dev->sd.mmc.cntlr);
335     if (ret != HDF_SUCCESS) {
336         HDF_LOGE("SdioDeviceDefaultEnableFunc: Io Enable fail, ret: %d!", ret);
337         return ret;
338     }
339 
340     for (i = 0; i < SDIO_READ_IO_READY_RETRY_TIMES; i++) {
341         ret = SdioReadCccrIoReady(dev->sd.mmc.cntlr, &val);
342         if (ret != HDF_SUCCESS) {
343             HDF_LOGE("SdioDeviceDefaultEnableFunc: read Io Ready fail, ret: %d", ret);
344             return ret;
345         }
346         if ((val & (1 << func->funcNum)) > 0) {
347             return HDF_SUCCESS;
348         }
349     }
350 
351     HDF_LOGE("SdioDeviceDefaultEnableFunc: Io not Ready!");
352     return HDF_ERR_TIMEOUT;
353 }
354 
SdioDeviceDefaultDisableFunc(struct SdioDevice * dev)355 static int32_t SdioDeviceDefaultDisableFunc(struct SdioDevice *dev)
356 {
357     struct SdioFunction *func = dev->curFunction;
358 
359     if (func == NULL) {
360         HDF_LOGE("SdioDeviceDefaultDisableFunc: func is null!");
361         return HDF_ERR_INVALID_OBJECT;
362     }
363     return SdioCccrIoDisable(dev->sd.mmc.cntlr);
364 }
365 
SdioDeviceDefaultClaimIrq(struct SdioDevice * dev,SdioIrqHandler * irqHandler)366 static int32_t SdioDeviceDefaultClaimIrq(struct SdioDevice *dev, SdioIrqHandler *irqHandler)
367 {
368     struct SdioFunction *func = dev->curFunction;
369     struct MmcCntlr *cntlr = NULL;
370     int32_t ret;
371 
372     if (func == NULL) {
373         HDF_LOGE("SdioDeviceDefaultClaimIrq: func is null!");
374         return HDF_ERR_INVALID_OBJECT;
375     }
376     if (func->irqHandler != NULL) {
377         HDF_LOGE("SdioDeviceDefaultClaimIrq: irq has been registered!");
378         return HDF_ERR_DEVICE_BUSY;
379     }
380     if (irqHandler == NULL) {
381         HDF_LOGE("SdioDeviceDefaultClaimIrq: irqHandler is null!");
382         return HDF_ERR_INVALID_PARAM;
383     }
384 
385     cntlr = dev->sd.mmc.cntlr;
386     if (cntlr == NULL) {
387         HDF_LOGE("SdioDeviceDefaultClaimIrq: cntlr is null!");
388         return HDF_ERR_INVALID_OBJECT;
389     }
390 
391     ret = SdioCccrIntEnable(cntlr);
392     if (ret != HDF_SUCCESS) {
393         return ret;
394     }
395 
396     func->irqHandler = irqHandler;
397     if (cntlr->caps.bits.sdioIrq > 0) {
398         ret = MmcCntlrCreatSdioIrqThread(cntlr);
399     }
400     return ret;
401 }
402 
SdioDeviceDefaultReleaseIrq(struct SdioDevice * dev)403 static int32_t SdioDeviceDefaultReleaseIrq(struct SdioDevice *dev)
404 {
405     struct SdioFunction *func = dev->curFunction;
406     struct MmcCntlr *cntlr = NULL;
407 
408     if (func == NULL) {
409         HDF_LOGE("SdioDeviceDefaultReleaseIrq: func is null!");
410         return HDF_ERR_INVALID_OBJECT;
411     }
412 
413     cntlr = dev->sd.mmc.cntlr;
414     if (cntlr == NULL) {
415         HDF_LOGE("SdioDeviceDefaultReleaseIrq: cntlr is null!");
416         return HDF_ERR_INVALID_OBJECT;
417     }
418 
419     if (func->irqHandler != NULL) {
420         func->irqHandler = NULL;
421         MmcCntlrDestroySdioIrqThread(cntlr);
422     }
423     if (cntlr->caps.bits.sdioIrq > 0 && cntlr->ops != NULL && cntlr->ops->setSdioIrq != NULL) {
424         (void)cntlr->ops->setSdioIrq(cntlr, false);
425     }
426     return SdioCccrIntDisable(cntlr);
427 }
428 
SdioDeviceDefaultFindFunc(struct SdioDevice * dev,struct SdioFunctionConfig * cfg)429 static int32_t SdioDeviceDefaultFindFunc(struct SdioDevice *dev, struct SdioFunctionConfig *cfg)
430 {
431     uint32_t i;
432     struct SdioFunction *func = NULL;
433 
434     if (dev->functions > SDIO_MAX_FUNCTION_NUMBER) {
435         HDF_LOGE("SdioDeviceDefaultFindFunc: functions = %d, error!", dev->functions);
436         return HDF_ERR_INVALID_PARAM;
437     }
438 
439     for (i = 0; i < dev->functions; i++) {
440         func = dev->sdioFunc[i];
441         if (func == NULL) {
442             continue;
443         }
444         if (cfg->deviceId == func->deviceId &&
445             cfg->vendorId == func->vendorId &&
446             cfg->funcNr == func->funcNum) {
447             dev->curFunction = func;
448             return HDF_SUCCESS;
449         }
450     }
451 
452     HDF_LOGE("SdioDeviceDefaultFindFunc: find func fail!");
453     return HDF_FAILURE;
454 }
455 
SdioDeviceDefaultClaimHost(struct SdioDevice * dev)456 static int32_t SdioDeviceDefaultClaimHost(struct SdioDevice *dev)
457 {
458     struct SdioFunction *func = dev->curFunction;
459     struct MmcCntlr *cntlr = NULL;
460 
461     if (func == NULL) {
462         HDF_LOGE("SdioDeviceDefaultClaimHost: func is null!");
463         return HDF_ERR_INVALID_OBJECT;
464     }
465 
466     cntlr = dev->sd.mmc.cntlr;
467     if (cntlr == NULL) {
468         HDF_LOGE("SdioDeviceDefaultClaimHost: cntlr is null!");
469         return HDF_ERR_INVALID_OBJECT;
470     }
471 
472     MmcCntlrLock(cntlr);
473     return HDF_SUCCESS;
474 }
475 
SdioDeviceDefaultReleaseHost(struct SdioDevice * dev)476 static int32_t SdioDeviceDefaultReleaseHost(struct SdioDevice *dev)
477 {
478     struct SdioFunction *func = dev->curFunction;
479     struct MmcCntlr *cntlr = NULL;
480 
481     if (func == NULL) {
482         HDF_LOGE("SdioDeviceDefaultReleaseHost: func is null!");
483         return HDF_ERR_INVALID_OBJECT;
484     }
485 
486     cntlr = dev->sd.mmc.cntlr;
487     if (cntlr == NULL) {
488         HDF_LOGE("SdioDeviceDefaultReleaseHost: cntlr is null!");
489         return HDF_ERR_INVALID_OBJECT;
490     }
491 
492     MmcCntlrUnlock(cntlr);
493     return HDF_SUCCESS;
494 }
495 
496 static struct SdioDeviceOps g_sdioDefaultOps = {
497     .incrAddrReadBytes = SdioDeviceDefaultIncrAddrReadBytes,
498     .incrAddrWriteBytes = SdioDeviceDefaultIncrAddrWriteBytes,
499     .fixedAddrReadBytes = SdioDeviceDefaultFixedAddrReadBytes,
500     .fixedAddrWriteBytes = SdioDeviceDefaultFixedAddrWriteBytes,
501     .func0ReadBytes = SdioDeviceDefaultFunc0ReadBytes,
502     .func0WriteBytes = SdioDeviceDefaultFunc0WriteBytes,
503     .setBlockSize = SdioDeviceDefaultSetBlockSize,
504     .getCommonInfo = SdioDeviceDefaultGetCommonInfo,
505     .setCommonInfo = SdioDeviceDefaultSetCommonInfo,
506     .flushData = SdioDeviceDefaultFlushData,
507     .enableFunc = SdioDeviceDefaultEnableFunc,
508     .disableFunc = SdioDeviceDefaultDisableFunc,
509     .claimIrq = SdioDeviceDefaultClaimIrq,
510     .releaseIrq = SdioDeviceDefaultReleaseIrq,
511     .findFunc = SdioDeviceDefaultFindFunc,
512     .claimHost = SdioDeviceDefaultClaimHost,
513     .releaseHost = SdioDeviceDefaultReleaseHost,
514 };
515 
SdioDeviceFindFunction(struct SdioDevice * sdio,struct SdioFunctionConfig * config)516 int32_t SdioDeviceFindFunction(struct SdioDevice *sdio, struct SdioFunctionConfig *config)
517 {
518     if (sdio->sdioOps == NULL) {
519         HDF_LOGE("SdioDeviceFindFunction: ops is null!");
520         return HDF_ERR_INVALID_OBJECT;
521     }
522     if (sdio->sdioOps->findFunc == NULL) {
523         HDF_LOGE("SdioDeviceFindFunction: func is null!");
524         return HDF_FAILURE;
525     }
526     return sdio->sdioOps->findFunc(sdio, config);
527 }
528 
SdioDeviceIncrAddrReadBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size)529 int32_t SdioDeviceIncrAddrReadBytes(struct SdioDevice *sdio,
530     uint8_t *data, uint32_t addr, uint32_t size)
531 {
532     if (sdio->sdioOps == NULL) {
533         HDF_LOGE("SdioDeviceIncrAddrReadBytes: ops is null!");
534         return HDF_ERR_INVALID_OBJECT;
535     }
536     if (sdio->sdioOps->incrAddrReadBytes == NULL) {
537         HDF_LOGE("SdioDeviceIncrAddrReadBytes: incrAddrReadBytes is null!");
538         return HDF_FAILURE;
539     }
540     return sdio->sdioOps->incrAddrReadBytes(sdio, data, addr, size);
541 }
542 
SdioDeviceIncrAddrWriteBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size)543 int32_t SdioDeviceIncrAddrWriteBytes(struct SdioDevice *sdio,
544     uint8_t *data, uint32_t addr, uint32_t size)
545 {
546     if (sdio->sdioOps == NULL) {
547         HDF_LOGE("SdioDeviceIncrAddrWriteBytes: ops is null!");
548         return HDF_ERR_INVALID_OBJECT;
549     }
550     if (sdio->sdioOps->incrAddrWriteBytes == NULL) {
551         HDF_LOGE("SdioDeviceIncrAddrWriteBytes: incrAddrWriteBytes is null!");
552         return HDF_FAILURE;
553     }
554     return sdio->sdioOps->incrAddrWriteBytes(sdio, data, addr, size);
555 }
556 
SdioDeviceFixedAddrReadBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size,uint32_t scatterLen)557 int32_t SdioDeviceFixedAddrReadBytes(struct SdioDevice *sdio,
558     uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen)
559 {
560     if (sdio->sdioOps == NULL) {
561         HDF_LOGE("SdioDeviceFixedAddrReadBytes: ops is null!");
562         return HDF_ERR_INVALID_OBJECT;
563     }
564     if (sdio->sdioOps->fixedAddrReadBytes == NULL) {
565         HDF_LOGE("SdioDeviceFixedAddrReadBytes: fixedAddrReadBytes is null!");
566         return HDF_FAILURE;
567     }
568     return sdio->sdioOps->fixedAddrReadBytes(sdio, data, addr, size, scatterLen);
569 }
570 
SdioDeviceFixedAddrWriteBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size,uint32_t scatterLen)571 int32_t SdioDeviceFixedAddrWriteBytes(struct SdioDevice *sdio,
572     uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen)
573 {
574     if (sdio->sdioOps == NULL) {
575         HDF_LOGE("SdioDeviceFixedAddrWriteBytes: ops is null!");
576         return HDF_ERR_INVALID_OBJECT;
577     }
578     if (sdio->sdioOps->fixedAddrWriteBytes == NULL) {
579         HDF_LOGE("SdioDeviceFixedAddrWriteBytes: fixedAddrWriteBytes is null!");
580         return HDF_FAILURE;
581     }
582     return sdio->sdioOps->fixedAddrWriteBytes(sdio, data, addr, size, scatterLen);
583 }
584 
SdioDeviceFunc0ReadBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size)585 int32_t SdioDeviceFunc0ReadBytes(struct SdioDevice *sdio,
586     uint8_t *data, uint32_t addr, uint32_t size)
587 {
588     if (sdio->sdioOps == NULL) {
589         HDF_LOGE("SdioDeviceFunc0ReadBytes: ops is null!");
590         return HDF_ERR_INVALID_OBJECT;
591     }
592     if (sdio->sdioOps->func0ReadBytes == NULL) {
593         HDF_LOGE("SdioDeviceFunc0ReadBytes: func0ReadBytes is null!");
594         return HDF_FAILURE;
595     }
596     return sdio->sdioOps->func0ReadBytes(sdio, data, addr, size);
597 }
598 
SdioDeviceFunc0WriteBytes(struct SdioDevice * sdio,uint8_t * data,uint32_t addr,uint32_t size)599 int32_t SdioDeviceFunc0WriteBytes(struct SdioDevice *sdio,
600     uint8_t *data, uint32_t addr, uint32_t size)
601 {
602     if (sdio->sdioOps == NULL) {
603         HDF_LOGE("SdioDeviceFunc0WriteBytes: ops is null!");
604         return HDF_ERR_INVALID_OBJECT;
605     }
606     if (sdio->sdioOps->func0WriteBytes == NULL) {
607         HDF_LOGE("SdioDeviceFunc0WriteBytes: func0WriteBytes is null!");
608         return HDF_FAILURE;
609     }
610     return sdio->sdioOps->func0WriteBytes(sdio, data, addr, size);
611 }
612 
SdioDeviceSetBlockSize(struct SdioDevice * sdio,uint32_t blockSize)613 int32_t SdioDeviceSetBlockSize(struct SdioDevice *sdio, uint32_t blockSize)
614 {
615     if (sdio->sdioOps == NULL) {
616         HDF_LOGE("SdioDeviceSetBlockSize: ops is null!");
617         return HDF_ERR_INVALID_OBJECT;
618     }
619     if (sdio->sdioOps->setBlockSize == NULL) {
620         HDF_LOGE("SdioDeviceSetBlockSize: setBlockSize is null!");
621         return HDF_FAILURE;
622     }
623     return sdio->sdioOps->setBlockSize(sdio, blockSize);
624 }
625 
SdioDeviceGetCommonInfo(struct SdioDevice * sdio,SdioCommonInfo * info,SdioCommonInfoType infoType)626 int32_t SdioDeviceGetCommonInfo(struct SdioDevice *sdio,
627     SdioCommonInfo *info, SdioCommonInfoType infoType)
628 {
629     if (sdio->sdioOps == NULL) {
630         HDF_LOGE("SdioDeviceGetCommonInfo: ops is null!");
631         return HDF_ERR_INVALID_OBJECT;
632     }
633     if (sdio->sdioOps->getCommonInfo == NULL) {
634         HDF_LOGE("SdioDeviceGetCommonInfo: getCommonInfo is null!");
635         return HDF_FAILURE;
636     }
637     return sdio->sdioOps->getCommonInfo(sdio, info, infoType);
638 }
639 
SdioDeviceSetCommonInfo(struct SdioDevice * sdio,SdioCommonInfo * info,SdioCommonInfoType infoType)640 int32_t SdioDeviceSetCommonInfo(struct SdioDevice *sdio,
641     SdioCommonInfo *info, SdioCommonInfoType infoType)
642 {
643     if (sdio->sdioOps == NULL) {
644         HDF_LOGE("SdioDeviceSetCommonInfo: ops is null!");
645         return HDF_ERR_INVALID_OBJECT;
646     }
647     if (sdio->sdioOps->setCommonInfo == NULL) {
648         HDF_LOGE("SdioDeviceSetCommonInfo: setCommonInfo is null!");
649         return HDF_FAILURE;
650     }
651     return sdio->sdioOps->setCommonInfo(sdio, info, infoType);
652 }
653 
SdioDeviceFlushData(struct SdioDevice * sdio)654 int32_t SdioDeviceFlushData(struct SdioDevice *sdio)
655 {
656     if (sdio->sdioOps == NULL) {
657         HDF_LOGE("SdioDeviceFlushData: ops is null!");
658         return HDF_ERR_INVALID_OBJECT;
659     }
660     if (sdio->sdioOps->flushData == NULL) {
661         HDF_LOGE("SdioDeviceFlushData: flushData is null!");
662         return HDF_FAILURE;
663     }
664     return sdio->sdioOps->flushData(sdio);
665 }
666 
SdioDeviceClaimHost(struct SdioDevice * sdio)667 int32_t SdioDeviceClaimHost(struct SdioDevice *sdio)
668 {
669     if (sdio->sdioOps == NULL) {
670         HDF_LOGE("SdioDeviceClaimHost: cntlr is null!");
671         return HDF_ERR_INVALID_OBJECT;
672     }
673 
674     if (sdio->sdioOps->claimHost != NULL) {
675         return sdio->sdioOps->claimHost(sdio);
676     }
677     return HDF_SUCCESS;
678 }
679 
SdioDeviceReleaseHost(struct SdioDevice * sdio)680 int32_t SdioDeviceReleaseHost(struct SdioDevice *sdio)
681 {
682     if (sdio->sdioOps == NULL) {
683         HDF_LOGE("SdioDeviceReleaseHost: cntlr is null!");
684         return HDF_ERR_INVALID_OBJECT;
685     }
686 
687     if (sdio->sdioOps->releaseHost != NULL) {
688         return sdio->sdioOps->releaseHost(sdio);
689     }
690     return HDF_SUCCESS;
691 }
692 
SdioDeviceEnableFunc(struct SdioDevice * sdio)693 int32_t SdioDeviceEnableFunc(struct SdioDevice *sdio)
694 {
695     if (sdio->sdioOps == NULL) {
696         HDF_LOGE("SdioDeviceEnableFunc: ops is null!");
697         return HDF_ERR_INVALID_OBJECT;
698     }
699     if (sdio->sdioOps->enableFunc == NULL) {
700         HDF_LOGE("SdioDeviceEnableFunc: enableFunc is null!");
701         return HDF_FAILURE;
702     }
703     return sdio->sdioOps->enableFunc(sdio);
704 }
705 
SdioDeviceDisableFunc(struct SdioDevice * sdio)706 int32_t SdioDeviceDisableFunc(struct SdioDevice *sdio)
707 {
708     if (sdio->sdioOps == NULL) {
709         HDF_LOGE("SdioDeviceDisableFunc: ops is null!");
710         return HDF_ERR_INVALID_OBJECT;
711     }
712     if (sdio->sdioOps->disableFunc == NULL) {
713         HDF_LOGE("SdioDeviceDisableFunc: disableFunc is null!");
714         return HDF_FAILURE;
715     }
716     return sdio->sdioOps->disableFunc(sdio);
717 }
718 
SdioDeviceClaimIrq(struct SdioDevice * sdio,SdioIrqHandler * irqHandler)719 int32_t SdioDeviceClaimIrq(struct SdioDevice *sdio, SdioIrqHandler *irqHandler)
720 {
721     if (sdio->sdioOps == NULL) {
722         HDF_LOGE("SdioDeviceClaimIrq: ops is null!");
723         return HDF_ERR_INVALID_OBJECT;
724     }
725     if (sdio->sdioOps->claimIrq == NULL) {
726         HDF_LOGE("SdioDeviceClaimIrq: claimIrq is null!");
727         return HDF_FAILURE;
728     }
729     return sdio->sdioOps->claimIrq(sdio, irqHandler);
730 }
731 
SdioDeviceReleaseIrq(struct SdioDevice * sdio)732 int32_t SdioDeviceReleaseIrq(struct SdioDevice *sdio)
733 {
734     if (sdio->sdioOps == NULL) {
735         HDF_LOGE("SdioDeviceReleaseIrq: ops is null!");
736         return HDF_ERR_INVALID_OBJECT;
737     }
738     if (sdio->sdioOps->releaseIrq == NULL) {
739         HDF_LOGE("SdioDeviceReleaseIrq: releaseIrq is null!");
740         return HDF_FAILURE;
741     }
742     return sdio->sdioOps->releaseIrq(sdio);
743 }
744 
SdioDeviceAddOps(struct SdioDevice * sdio,void * ops)745 void SdioDeviceAddOps(struct SdioDevice *sdio, void *ops)
746 {
747     if (sdio == NULL) {
748         HDF_LOGE("SdioDeviceAddOps: sdio is null!");
749         return;
750     }
751     if (ops == NULL) {
752         sdio->sdioOps = &g_sdioDefaultOps;
753         HDF_LOGD("SdioDeviceAddOps: use default ops!");
754     } else {
755         sdio->sdioOps = (struct SdioDeviceOps *)ops;
756     }
757 }
758