Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * linux/drivers/mmc/core/sdio_io.c
4 : : *
5 : : * Copyright 2007-2008 Pierre Ossman
6 : : */
7 : :
8 : : #include <linux/export.h>
9 : : #include <linux/kernel.h>
10 : : #include <linux/mmc/host.h>
11 : : #include <linux/mmc/card.h>
12 : : #include <linux/mmc/sdio.h>
13 : : #include <linux/mmc/sdio_func.h>
14 : :
15 : : #include "sdio_ops.h"
16 : : #include "core.h"
17 : : #include "card.h"
18 : : #include "host.h"
19 : :
20 : : /**
21 : : * sdio_claim_host - exclusively claim a bus for a certain SDIO function
22 : : * @func: SDIO function that will be accessed
23 : : *
24 : : * Claim a bus for a set of operations. The SDIO function given
25 : : * is used to figure out which bus is relevant.
26 : : */
27 : 0 : void sdio_claim_host(struct sdio_func *func)
28 : : {
29 : 0 : if (WARN_ON(!func))
30 : 0 : return;
31 : :
32 : 0 : mmc_claim_host(func->card->host);
33 : : }
34 : : EXPORT_SYMBOL_GPL(sdio_claim_host);
35 : :
36 : : /**
37 : : * sdio_release_host - release a bus for a certain SDIO function
38 : : * @func: SDIO function that was accessed
39 : : *
40 : : * Release a bus, allowing others to claim the bus for their
41 : : * operations.
42 : : */
43 : 0 : void sdio_release_host(struct sdio_func *func)
44 : : {
45 : 0 : if (WARN_ON(!func))
46 : 0 : return;
47 : :
48 : 0 : mmc_release_host(func->card->host);
49 : : }
50 : : EXPORT_SYMBOL_GPL(sdio_release_host);
51 : :
52 : : /**
53 : : * sdio_enable_func - enables a SDIO function for usage
54 : : * @func: SDIO function to enable
55 : : *
56 : : * Powers up and activates a SDIO function so that register
57 : : * access is possible.
58 : : */
59 : 0 : int sdio_enable_func(struct sdio_func *func)
60 : : {
61 : : int ret;
62 : : unsigned char reg;
63 : : unsigned long timeout;
64 : :
65 : 0 : if (!func)
66 : : return -EINVAL;
67 : :
68 : : pr_debug("SDIO: Enabling device %s...\n", sdio_func_id(func));
69 : :
70 : 0 : ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, ®);
71 : 0 : if (ret)
72 : : goto err;
73 : :
74 : 0 : reg |= 1 << func->num;
75 : :
76 : 0 : ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
77 : 0 : if (ret)
78 : : goto err;
79 : :
80 : 0 : timeout = jiffies + msecs_to_jiffies(func->enable_timeout);
81 : :
82 : : while (1) {
83 : 0 : ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IORx, 0, ®);
84 : 0 : if (ret)
85 : : goto err;
86 : 0 : if (reg & (1 << func->num))
87 : : break;
88 : : ret = -ETIME;
89 : 0 : if (time_after(jiffies, timeout))
90 : : goto err;
91 : : }
92 : :
93 : : pr_debug("SDIO: Enabled device %s\n", sdio_func_id(func));
94 : :
95 : : return 0;
96 : :
97 : : err:
98 : : pr_debug("SDIO: Failed to enable device %s\n", sdio_func_id(func));
99 : 0 : return ret;
100 : : }
101 : : EXPORT_SYMBOL_GPL(sdio_enable_func);
102 : :
103 : : /**
104 : : * sdio_disable_func - disable a SDIO function
105 : : * @func: SDIO function to disable
106 : : *
107 : : * Powers down and deactivates a SDIO function. Register access
108 : : * to this function will fail until the function is reenabled.
109 : : */
110 : 0 : int sdio_disable_func(struct sdio_func *func)
111 : : {
112 : : int ret;
113 : : unsigned char reg;
114 : :
115 : 0 : if (!func)
116 : : return -EINVAL;
117 : :
118 : : pr_debug("SDIO: Disabling device %s...\n", sdio_func_id(func));
119 : :
120 : 0 : ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, ®);
121 : 0 : if (ret)
122 : : goto err;
123 : :
124 : 0 : reg &= ~(1 << func->num);
125 : :
126 : 0 : ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
127 : 0 : if (ret)
128 : : goto err;
129 : :
130 : : pr_debug("SDIO: Disabled device %s\n", sdio_func_id(func));
131 : :
132 : : return 0;
133 : :
134 : : err:
135 : : pr_debug("SDIO: Failed to disable device %s\n", sdio_func_id(func));
136 : : return -EIO;
137 : : }
138 : : EXPORT_SYMBOL_GPL(sdio_disable_func);
139 : :
140 : : /**
141 : : * sdio_set_block_size - set the block size of an SDIO function
142 : : * @func: SDIO function to change
143 : : * @blksz: new block size or 0 to use the default.
144 : : *
145 : : * The default block size is the largest supported by both the function
146 : : * and the host, with a maximum of 512 to ensure that arbitrarily sized
147 : : * data transfer use the optimal (least) number of commands.
148 : : *
149 : : * A driver may call this to override the default block size set by the
150 : : * core. This can be used to set a block size greater than the maximum
151 : : * that reported by the card; it is the driver's responsibility to ensure
152 : : * it uses a value that the card supports.
153 : : *
154 : : * Returns 0 on success, -EINVAL if the host does not support the
155 : : * requested block size, or -EIO (etc.) if one of the resultant FBR block
156 : : * size register writes failed.
157 : : *
158 : : */
159 : 0 : int sdio_set_block_size(struct sdio_func *func, unsigned blksz)
160 : : {
161 : : int ret;
162 : :
163 : 0 : if (blksz > func->card->host->max_blk_size)
164 : : return -EINVAL;
165 : :
166 : 0 : if (blksz == 0) {
167 : 0 : blksz = min(func->max_blksize, func->card->host->max_blk_size);
168 : 0 : blksz = min(blksz, 512u);
169 : : }
170 : :
171 : 0 : ret = mmc_io_rw_direct(func->card, 1, 0,
172 : 0 : SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE,
173 : : blksz & 0xff, NULL);
174 : 0 : if (ret)
175 : : return ret;
176 : 0 : ret = mmc_io_rw_direct(func->card, 1, 0,
177 : 0 : SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE + 1,
178 : 0 : (blksz >> 8) & 0xff, NULL);
179 : 0 : if (ret)
180 : : return ret;
181 : 0 : func->cur_blksize = blksz;
182 : 0 : return 0;
183 : : }
184 : : EXPORT_SYMBOL_GPL(sdio_set_block_size);
185 : :
186 : : /*
187 : : * Calculate the maximum byte mode transfer size
188 : : */
189 : 0 : static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
190 : : {
191 : 0 : unsigned mval = func->card->host->max_blk_size;
192 : :
193 : 0 : if (mmc_blksz_for_byte_mode(func->card))
194 : 0 : mval = min(mval, func->cur_blksize);
195 : : else
196 : 0 : mval = min(mval, func->max_blksize);
197 : :
198 : 0 : if (mmc_card_broken_byte_mode_512(func->card))
199 : 0 : return min(mval, 511u);
200 : :
201 : 0 : return min(mval, 512u); /* maximum size for byte mode */
202 : : }
203 : :
204 : : /*
205 : : * This is legacy code, which needs to be re-worked some day. Basically we need
206 : : * to take into account the properties of the host, as to enable the SDIO func
207 : : * driver layer to allocate optimal buffers.
208 : : */
209 : : static inline unsigned int _sdio_align_size(unsigned int sz)
210 : : {
211 : : /*
212 : : * FIXME: We don't have a system for the controller to tell
213 : : * the core about its problems yet, so for now we just 32-bit
214 : : * align the size.
215 : : */
216 : 0 : return ALIGN(sz, 4);
217 : : }
218 : :
219 : : /**
220 : : * sdio_align_size - pads a transfer size to a more optimal value
221 : : * @func: SDIO function
222 : : * @sz: original transfer size
223 : : *
224 : : * Pads the original data size with a number of extra bytes in
225 : : * order to avoid controller bugs and/or performance hits
226 : : * (e.g. some controllers revert to PIO for certain sizes).
227 : : *
228 : : * If possible, it will also adjust the size so that it can be
229 : : * handled in just a single request.
230 : : *
231 : : * Returns the improved size, which might be unmodified.
232 : : */
233 : 0 : unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz)
234 : : {
235 : : unsigned int orig_sz;
236 : : unsigned int blk_sz, byte_sz;
237 : : unsigned chunk_sz;
238 : :
239 : : orig_sz = sz;
240 : :
241 : : /*
242 : : * Do a first check with the controller, in case it
243 : : * wants to increase the size up to a point where it
244 : : * might need more than one block.
245 : : */
246 : : sz = _sdio_align_size(sz);
247 : :
248 : : /*
249 : : * If we can still do this with just a byte transfer, then
250 : : * we're done.
251 : : */
252 : 0 : if (sz <= sdio_max_byte_size(func))
253 : : return sz;
254 : :
255 : 0 : if (func->card->cccr.multi_block) {
256 : : /*
257 : : * Check if the transfer is already block aligned
258 : : */
259 : 0 : if ((sz % func->cur_blksize) == 0)
260 : : return sz;
261 : :
262 : : /*
263 : : * Realign it so that it can be done with one request,
264 : : * and recheck if the controller still likes it.
265 : : */
266 : 0 : blk_sz = ((sz + func->cur_blksize - 1) /
267 : : func->cur_blksize) * func->cur_blksize;
268 : : blk_sz = _sdio_align_size(blk_sz);
269 : :
270 : : /*
271 : : * This value is only good if it is still just
272 : : * one request.
273 : : */
274 : 0 : if ((blk_sz % func->cur_blksize) == 0)
275 : : return blk_sz;
276 : :
277 : : /*
278 : : * We failed to do one request, but at least try to
279 : : * pad the remainder properly.
280 : : */
281 : : byte_sz = _sdio_align_size(sz % func->cur_blksize);
282 : 0 : if (byte_sz <= sdio_max_byte_size(func)) {
283 : 0 : blk_sz = sz / func->cur_blksize;
284 : 0 : return blk_sz * func->cur_blksize + byte_sz;
285 : : }
286 : : } else {
287 : : /*
288 : : * We need multiple requests, so first check that the
289 : : * controller can handle the chunk size;
290 : : */
291 : : chunk_sz = _sdio_align_size(sdio_max_byte_size(func));
292 : 0 : if (chunk_sz == sdio_max_byte_size(func)) {
293 : : /*
294 : : * Fix up the size of the remainder (if any)
295 : : */
296 : 0 : byte_sz = orig_sz % chunk_sz;
297 : 0 : if (byte_sz) {
298 : : byte_sz = _sdio_align_size(byte_sz);
299 : : }
300 : :
301 : 0 : return (orig_sz / chunk_sz) * chunk_sz + byte_sz;
302 : : }
303 : : }
304 : :
305 : : /*
306 : : * The controller is simply incapable of transferring the size
307 : : * we want in decent manner, so just return the original size.
308 : : */
309 : : return orig_sz;
310 : : }
311 : : EXPORT_SYMBOL_GPL(sdio_align_size);
312 : :
313 : : /* Split an arbitrarily sized data transfer into several
314 : : * IO_RW_EXTENDED commands. */
315 : 0 : static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
316 : : unsigned addr, int incr_addr, u8 *buf, unsigned size)
317 : : {
318 : : unsigned remainder = size;
319 : : unsigned max_blocks;
320 : : int ret;
321 : :
322 : 0 : if (!func || (func->num > 7))
323 : : return -EINVAL;
324 : :
325 : : /* Do the bulk of the transfer using block mode (if supported). */
326 : 0 : if (func->card->cccr.multi_block && (size > sdio_max_byte_size(func))) {
327 : : /* Blocks per command is limited by host count, host transfer
328 : : * size and the maximum for IO_RW_EXTENDED of 511 blocks. */
329 : 0 : max_blocks = min(func->card->host->max_blk_count, 511u);
330 : :
331 : 0 : while (remainder >= func->cur_blksize) {
332 : : unsigned blocks;
333 : :
334 : 0 : blocks = remainder / func->cur_blksize;
335 : 0 : if (blocks > max_blocks)
336 : : blocks = max_blocks;
337 : 0 : size = blocks * func->cur_blksize;
338 : :
339 : 0 : ret = mmc_io_rw_extended(func->card, write,
340 : : func->num, addr, incr_addr, buf,
341 : : blocks, func->cur_blksize);
342 : 0 : if (ret)
343 : 0 : return ret;
344 : :
345 : 0 : remainder -= size;
346 : 0 : buf += size;
347 : 0 : if (incr_addr)
348 : 0 : addr += size;
349 : : }
350 : : }
351 : :
352 : : /* Write the remainder using byte mode. */
353 : 0 : while (remainder > 0) {
354 : 0 : size = min(remainder, sdio_max_byte_size(func));
355 : :
356 : : /* Indicate byte mode by setting "blocks" = 0 */
357 : 0 : ret = mmc_io_rw_extended(func->card, write, func->num, addr,
358 : : incr_addr, buf, 0, size);
359 : 0 : if (ret)
360 : 0 : return ret;
361 : :
362 : 0 : remainder -= size;
363 : 0 : buf += size;
364 : 0 : if (incr_addr)
365 : 0 : addr += size;
366 : : }
367 : : return 0;
368 : : }
369 : :
370 : : /**
371 : : * sdio_readb - read a single byte from a SDIO function
372 : : * @func: SDIO function to access
373 : : * @addr: address to read
374 : : * @err_ret: optional status value from transfer
375 : : *
376 : : * Reads a single byte from the address space of a given SDIO
377 : : * function. If there is a problem reading the address, 0xff
378 : : * is returned and @err_ret will contain the error code.
379 : : */
380 : 0 : u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret)
381 : : {
382 : : int ret;
383 : : u8 val;
384 : :
385 : 0 : if (!func) {
386 : 0 : if (err_ret)
387 : 0 : *err_ret = -EINVAL;
388 : : return 0xFF;
389 : : }
390 : :
391 : 0 : ret = mmc_io_rw_direct(func->card, 0, func->num, addr, 0, &val);
392 : 0 : if (err_ret)
393 : 0 : *err_ret = ret;
394 : 0 : if (ret)
395 : : return 0xFF;
396 : :
397 : 0 : return val;
398 : : }
399 : : EXPORT_SYMBOL_GPL(sdio_readb);
400 : :
401 : : /**
402 : : * sdio_writeb - write a single byte to a SDIO function
403 : : * @func: SDIO function to access
404 : : * @b: byte to write
405 : : * @addr: address to write to
406 : : * @err_ret: optional status value from transfer
407 : : *
408 : : * Writes a single byte to the address space of a given SDIO
409 : : * function. @err_ret will contain the status of the actual
410 : : * transfer.
411 : : */
412 : 0 : void sdio_writeb(struct sdio_func *func, u8 b, unsigned int addr, int *err_ret)
413 : : {
414 : : int ret;
415 : :
416 : 0 : if (!func) {
417 : 0 : if (err_ret)
418 : 0 : *err_ret = -EINVAL;
419 : 0 : return;
420 : : }
421 : :
422 : 0 : ret = mmc_io_rw_direct(func->card, 1, func->num, addr, b, NULL);
423 : 0 : if (err_ret)
424 : 0 : *err_ret = ret;
425 : : }
426 : : EXPORT_SYMBOL_GPL(sdio_writeb);
427 : :
428 : : /**
429 : : * sdio_writeb_readb - write and read a byte from SDIO function
430 : : * @func: SDIO function to access
431 : : * @write_byte: byte to write
432 : : * @addr: address to write to
433 : : * @err_ret: optional status value from transfer
434 : : *
435 : : * Performs a RAW (Read after Write) operation as defined by SDIO spec -
436 : : * single byte is written to address space of a given SDIO function and
437 : : * response is read back from the same address, both using single request.
438 : : * If there is a problem with the operation, 0xff is returned and
439 : : * @err_ret will contain the error code.
440 : : */
441 : 0 : u8 sdio_writeb_readb(struct sdio_func *func, u8 write_byte,
442 : : unsigned int addr, int *err_ret)
443 : : {
444 : : int ret;
445 : : u8 val;
446 : :
447 : 0 : ret = mmc_io_rw_direct(func->card, 1, func->num, addr,
448 : : write_byte, &val);
449 : 0 : if (err_ret)
450 : 0 : *err_ret = ret;
451 : 0 : if (ret)
452 : : return 0xff;
453 : :
454 : 0 : return val;
455 : : }
456 : : EXPORT_SYMBOL_GPL(sdio_writeb_readb);
457 : :
458 : : /**
459 : : * sdio_memcpy_fromio - read a chunk of memory from a SDIO function
460 : : * @func: SDIO function to access
461 : : * @dst: buffer to store the data
462 : : * @addr: address to begin reading from
463 : : * @count: number of bytes to read
464 : : *
465 : : * Reads from the address space of a given SDIO function. Return
466 : : * value indicates if the transfer succeeded or not.
467 : : */
468 : 0 : int sdio_memcpy_fromio(struct sdio_func *func, void *dst,
469 : : unsigned int addr, int count)
470 : : {
471 : 0 : return sdio_io_rw_ext_helper(func, 0, addr, 1, dst, count);
472 : : }
473 : : EXPORT_SYMBOL_GPL(sdio_memcpy_fromio);
474 : :
475 : : /**
476 : : * sdio_memcpy_toio - write a chunk of memory to a SDIO function
477 : : * @func: SDIO function to access
478 : : * @addr: address to start writing to
479 : : * @src: buffer that contains the data to write
480 : : * @count: number of bytes to write
481 : : *
482 : : * Writes to the address space of a given SDIO function. Return
483 : : * value indicates if the transfer succeeded or not.
484 : : */
485 : 0 : int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr,
486 : : void *src, int count)
487 : : {
488 : 0 : return sdio_io_rw_ext_helper(func, 1, addr, 1, src, count);
489 : : }
490 : : EXPORT_SYMBOL_GPL(sdio_memcpy_toio);
491 : :
492 : : /**
493 : : * sdio_readsb - read from a FIFO on a SDIO function
494 : : * @func: SDIO function to access
495 : : * @dst: buffer to store the data
496 : : * @addr: address of (single byte) FIFO
497 : : * @count: number of bytes to read
498 : : *
499 : : * Reads from the specified FIFO of a given SDIO function. Return
500 : : * value indicates if the transfer succeeded or not.
501 : : */
502 : 0 : int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr,
503 : : int count)
504 : : {
505 : 0 : return sdio_io_rw_ext_helper(func, 0, addr, 0, dst, count);
506 : : }
507 : : EXPORT_SYMBOL_GPL(sdio_readsb);
508 : :
509 : : /**
510 : : * sdio_writesb - write to a FIFO of a SDIO function
511 : : * @func: SDIO function to access
512 : : * @addr: address of (single byte) FIFO
513 : : * @src: buffer that contains the data to write
514 : : * @count: number of bytes to write
515 : : *
516 : : * Writes to the specified FIFO of a given SDIO function. Return
517 : : * value indicates if the transfer succeeded or not.
518 : : */
519 : 0 : int sdio_writesb(struct sdio_func *func, unsigned int addr, void *src,
520 : : int count)
521 : : {
522 : 0 : return sdio_io_rw_ext_helper(func, 1, addr, 0, src, count);
523 : : }
524 : : EXPORT_SYMBOL_GPL(sdio_writesb);
525 : :
526 : : /**
527 : : * sdio_readw - read a 16 bit integer from a SDIO function
528 : : * @func: SDIO function to access
529 : : * @addr: address to read
530 : : * @err_ret: optional status value from transfer
531 : : *
532 : : * Reads a 16 bit integer from the address space of a given SDIO
533 : : * function. If there is a problem reading the address, 0xffff
534 : : * is returned and @err_ret will contain the error code.
535 : : */
536 : 0 : u16 sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret)
537 : : {
538 : : int ret;
539 : :
540 : 0 : ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 2);
541 : 0 : if (err_ret)
542 : 0 : *err_ret = ret;
543 : 0 : if (ret)
544 : : return 0xFFFF;
545 : :
546 : 0 : return le16_to_cpup((__le16 *)func->tmpbuf);
547 : : }
548 : : EXPORT_SYMBOL_GPL(sdio_readw);
549 : :
550 : : /**
551 : : * sdio_writew - write a 16 bit integer to a SDIO function
552 : : * @func: SDIO function to access
553 : : * @b: integer to write
554 : : * @addr: address to write to
555 : : * @err_ret: optional status value from transfer
556 : : *
557 : : * Writes a 16 bit integer to the address space of a given SDIO
558 : : * function. @err_ret will contain the status of the actual
559 : : * transfer.
560 : : */
561 : 0 : void sdio_writew(struct sdio_func *func, u16 b, unsigned int addr, int *err_ret)
562 : : {
563 : : int ret;
564 : :
565 : 0 : *(__le16 *)func->tmpbuf = cpu_to_le16(b);
566 : :
567 : 0 : ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 2);
568 : 0 : if (err_ret)
569 : 0 : *err_ret = ret;
570 : 0 : }
571 : : EXPORT_SYMBOL_GPL(sdio_writew);
572 : :
573 : : /**
574 : : * sdio_readl - read a 32 bit integer from a SDIO function
575 : : * @func: SDIO function to access
576 : : * @addr: address to read
577 : : * @err_ret: optional status value from transfer
578 : : *
579 : : * Reads a 32 bit integer from the address space of a given SDIO
580 : : * function. If there is a problem reading the address,
581 : : * 0xffffffff is returned and @err_ret will contain the error
582 : : * code.
583 : : */
584 : 0 : u32 sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret)
585 : : {
586 : : int ret;
587 : :
588 : 0 : ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 4);
589 : 0 : if (err_ret)
590 : 0 : *err_ret = ret;
591 : 0 : if (ret)
592 : : return 0xFFFFFFFF;
593 : :
594 : 0 : return le32_to_cpup((__le32 *)func->tmpbuf);
595 : : }
596 : : EXPORT_SYMBOL_GPL(sdio_readl);
597 : :
598 : : /**
599 : : * sdio_writel - write a 32 bit integer to a SDIO function
600 : : * @func: SDIO function to access
601 : : * @b: integer to write
602 : : * @addr: address to write to
603 : : * @err_ret: optional status value from transfer
604 : : *
605 : : * Writes a 32 bit integer to the address space of a given SDIO
606 : : * function. @err_ret will contain the status of the actual
607 : : * transfer.
608 : : */
609 : 0 : void sdio_writel(struct sdio_func *func, u32 b, unsigned int addr, int *err_ret)
610 : : {
611 : : int ret;
612 : :
613 : 0 : *(__le32 *)func->tmpbuf = cpu_to_le32(b);
614 : :
615 : 0 : ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 4);
616 : 0 : if (err_ret)
617 : 0 : *err_ret = ret;
618 : 0 : }
619 : : EXPORT_SYMBOL_GPL(sdio_writel);
620 : :
621 : : /**
622 : : * sdio_f0_readb - read a single byte from SDIO function 0
623 : : * @func: an SDIO function of the card
624 : : * @addr: address to read
625 : : * @err_ret: optional status value from transfer
626 : : *
627 : : * Reads a single byte from the address space of SDIO function 0.
628 : : * If there is a problem reading the address, 0xff is returned
629 : : * and @err_ret will contain the error code.
630 : : */
631 : 0 : unsigned char sdio_f0_readb(struct sdio_func *func, unsigned int addr,
632 : : int *err_ret)
633 : : {
634 : : int ret;
635 : : unsigned char val;
636 : :
637 : 0 : if (!func) {
638 : 0 : if (err_ret)
639 : 0 : *err_ret = -EINVAL;
640 : : return 0xFF;
641 : : }
642 : :
643 : 0 : ret = mmc_io_rw_direct(func->card, 0, 0, addr, 0, &val);
644 : 0 : if (err_ret)
645 : 0 : *err_ret = ret;
646 : 0 : if (ret)
647 : : return 0xFF;
648 : :
649 : 0 : return val;
650 : : }
651 : : EXPORT_SYMBOL_GPL(sdio_f0_readb);
652 : :
653 : : /**
654 : : * sdio_f0_writeb - write a single byte to SDIO function 0
655 : : * @func: an SDIO function of the card
656 : : * @b: byte to write
657 : : * @addr: address to write to
658 : : * @err_ret: optional status value from transfer
659 : : *
660 : : * Writes a single byte to the address space of SDIO function 0.
661 : : * @err_ret will contain the status of the actual transfer.
662 : : *
663 : : * Only writes to the vendor specific CCCR registers (0xF0 -
664 : : * 0xFF) are permiited; @err_ret will be set to -EINVAL for *
665 : : * writes outside this range.
666 : : */
667 : 0 : void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
668 : : int *err_ret)
669 : : {
670 : : int ret;
671 : :
672 : 0 : if (!func) {
673 : 0 : if (err_ret)
674 : 0 : *err_ret = -EINVAL;
675 : : return;
676 : : }
677 : :
678 : 0 : if ((addr < 0xF0 || addr > 0xFF) && (!mmc_card_lenient_fn0(func->card))) {
679 : 0 : if (err_ret)
680 : 0 : *err_ret = -EINVAL;
681 : : return;
682 : : }
683 : :
684 : 0 : ret = mmc_io_rw_direct(func->card, 1, 0, addr, b, NULL);
685 : 0 : if (err_ret)
686 : 0 : *err_ret = ret;
687 : : }
688 : : EXPORT_SYMBOL_GPL(sdio_f0_writeb);
689 : :
690 : : /**
691 : : * sdio_get_host_pm_caps - get host power management capabilities
692 : : * @func: SDIO function attached to host
693 : : *
694 : : * Returns a capability bitmask corresponding to power management
695 : : * features supported by the host controller that the card function
696 : : * might rely upon during a system suspend. The host doesn't need
697 : : * to be claimed, nor the function active, for this information to be
698 : : * obtained.
699 : : */
700 : 0 : mmc_pm_flag_t sdio_get_host_pm_caps(struct sdio_func *func)
701 : : {
702 : 0 : if (!func)
703 : : return 0;
704 : :
705 : 0 : return func->card->host->pm_caps;
706 : : }
707 : : EXPORT_SYMBOL_GPL(sdio_get_host_pm_caps);
708 : :
709 : : /**
710 : : * sdio_set_host_pm_flags - set wanted host power management capabilities
711 : : * @func: SDIO function attached to host
712 : : *
713 : : * Set a capability bitmask corresponding to wanted host controller
714 : : * power management features for the upcoming suspend state.
715 : : * This must be called, if needed, each time the suspend method of
716 : : * the function driver is called, and must contain only bits that
717 : : * were returned by sdio_get_host_pm_caps().
718 : : * The host doesn't need to be claimed, nor the function active,
719 : : * for this information to be set.
720 : : */
721 : 0 : int sdio_set_host_pm_flags(struct sdio_func *func, mmc_pm_flag_t flags)
722 : : {
723 : : struct mmc_host *host;
724 : :
725 : 0 : if (!func)
726 : : return -EINVAL;
727 : :
728 : 0 : host = func->card->host;
729 : :
730 : 0 : if (flags & ~host->pm_caps)
731 : : return -EINVAL;
732 : :
733 : : /* function suspend methods are serialized, hence no lock needed */
734 : 0 : host->pm_flags |= flags;
735 : 0 : return 0;
736 : : }
737 : : EXPORT_SYMBOL_GPL(sdio_set_host_pm_flags);
738 : :
739 : : /**
740 : : * sdio_retune_crc_disable - temporarily disable retuning on CRC errors
741 : : * @func: SDIO function attached to host
742 : : *
743 : : * If the SDIO card is known to be in a state where it might produce
744 : : * CRC errors on the bus in response to commands (like if we know it is
745 : : * transitioning between power states), an SDIO function driver can
746 : : * call this function to temporarily disable the SD/MMC core behavior of
747 : : * triggering an automatic retuning.
748 : : *
749 : : * This function should be called while the host is claimed and the host
750 : : * should remain claimed until sdio_retune_crc_enable() is called.
751 : : * Specifically, the expected sequence of calls is:
752 : : * - sdio_claim_host()
753 : : * - sdio_retune_crc_disable()
754 : : * - some number of calls like sdio_writeb() and sdio_readb()
755 : : * - sdio_retune_crc_enable()
756 : : * - sdio_release_host()
757 : : */
758 : 0 : void sdio_retune_crc_disable(struct sdio_func *func)
759 : : {
760 : 0 : func->card->host->retune_crc_disable = true;
761 : 0 : }
762 : : EXPORT_SYMBOL_GPL(sdio_retune_crc_disable);
763 : :
764 : : /**
765 : : * sdio_retune_crc_enable - re-enable retuning on CRC errors
766 : : * @func: SDIO function attached to host
767 : : *
768 : : * This is the compement to sdio_retune_crc_disable().
769 : : */
770 : 0 : void sdio_retune_crc_enable(struct sdio_func *func)
771 : : {
772 : 0 : func->card->host->retune_crc_disable = false;
773 : 0 : }
774 : : EXPORT_SYMBOL_GPL(sdio_retune_crc_enable);
775 : :
776 : : /**
777 : : * sdio_retune_hold_now - start deferring retuning requests till release
778 : : * @func: SDIO function attached to host
779 : : *
780 : : * This function can be called if it's currently a bad time to do
781 : : * a retune of the SDIO card. Retune requests made during this time
782 : : * will be held and we'll actually do the retune sometime after the
783 : : * release.
784 : : *
785 : : * This function could be useful if an SDIO card is in a power state
786 : : * where it can respond to a small subset of commands that doesn't
787 : : * include the retuning command. Care should be taken when using
788 : : * this function since (presumably) the retuning request we might be
789 : : * deferring was made for a good reason.
790 : : *
791 : : * This function should be called while the host is claimed.
792 : : */
793 : 0 : void sdio_retune_hold_now(struct sdio_func *func)
794 : : {
795 : 0 : mmc_retune_hold_now(func->card->host);
796 : 0 : }
797 : : EXPORT_SYMBOL_GPL(sdio_retune_hold_now);
798 : :
799 : : /**
800 : : * sdio_retune_release - signal that it's OK to retune now
801 : : * @func: SDIO function attached to host
802 : : *
803 : : * This is the complement to sdio_retune_hold_now(). Calling this
804 : : * function won't make a retune happen right away but will allow
805 : : * them to be scheduled normally.
806 : : *
807 : : * This function should be called while the host is claimed.
808 : : */
809 : 0 : void sdio_retune_release(struct sdio_func *func)
810 : : {
811 : 0 : mmc_retune_release(func->card->host);
812 : 0 : }
813 : : EXPORT_SYMBOL_GPL(sdio_retune_release);
|
