xref: /openbmc/linux/drivers/mmc/core/sdio_io.c (revision b6dcefde)
1 /*
2  *  linux/drivers/mmc/core/sdio_io.c
3  *
4  *  Copyright 2007-2008 Pierre Ossman
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or (at
9  * your option) any later version.
10  */
11 
12 #include <linux/mmc/host.h>
13 #include <linux/mmc/card.h>
14 #include <linux/mmc/sdio.h>
15 #include <linux/mmc/sdio_func.h>
16 
17 #include "sdio_ops.h"
18 
19 /**
20  *	sdio_claim_host - exclusively claim a bus for a certain SDIO function
21  *	@func: SDIO function that will be accessed
22  *
23  *	Claim a bus for a set of operations. The SDIO function given
24  *	is used to figure out which bus is relevant.
25  */
26 void sdio_claim_host(struct sdio_func *func)
27 {
28 	BUG_ON(!func);
29 	BUG_ON(!func->card);
30 
31 	mmc_claim_host(func->card->host);
32 }
33 EXPORT_SYMBOL_GPL(sdio_claim_host);
34 
35 /**
36  *	sdio_release_host - release a bus for a certain SDIO function
37  *	@func: SDIO function that was accessed
38  *
39  *	Release a bus, allowing others to claim the bus for their
40  *	operations.
41  */
42 void sdio_release_host(struct sdio_func *func)
43 {
44 	BUG_ON(!func);
45 	BUG_ON(!func->card);
46 
47 	mmc_release_host(func->card->host);
48 }
49 EXPORT_SYMBOL_GPL(sdio_release_host);
50 
51 /**
52  *	sdio_enable_func - enables a SDIO function for usage
53  *	@func: SDIO function to enable
54  *
55  *	Powers up and activates a SDIO function so that register
56  *	access is possible.
57  */
58 int sdio_enable_func(struct sdio_func *func)
59 {
60 	int ret;
61 	unsigned char reg;
62 	unsigned long timeout;
63 
64 	BUG_ON(!func);
65 	BUG_ON(!func->card);
66 
67 	pr_debug("SDIO: Enabling device %s...\n", sdio_func_id(func));
68 
69 	ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, &reg);
70 	if (ret)
71 		goto err;
72 
73 	reg |= 1 << func->num;
74 
75 	ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
76 	if (ret)
77 		goto err;
78 
79 	timeout = jiffies + msecs_to_jiffies(func->enable_timeout);
80 
81 	while (1) {
82 		ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IORx, 0, &reg);
83 		if (ret)
84 			goto err;
85 		if (reg & (1 << func->num))
86 			break;
87 		ret = -ETIME;
88 		if (time_after(jiffies, timeout))
89 			goto err;
90 	}
91 
92 	pr_debug("SDIO: Enabled device %s\n", sdio_func_id(func));
93 
94 	return 0;
95 
96 err:
97 	pr_debug("SDIO: Failed to enable device %s\n", sdio_func_id(func));
98 	return ret;
99 }
100 EXPORT_SYMBOL_GPL(sdio_enable_func);
101 
102 /**
103  *	sdio_disable_func - disable a SDIO function
104  *	@func: SDIO function to disable
105  *
106  *	Powers down and deactivates a SDIO function. Register access
107  *	to this function will fail until the function is reenabled.
108  */
109 int sdio_disable_func(struct sdio_func *func)
110 {
111 	int ret;
112 	unsigned char reg;
113 
114 	BUG_ON(!func);
115 	BUG_ON(!func->card);
116 
117 	pr_debug("SDIO: Disabling device %s...\n", sdio_func_id(func));
118 
119 	ret = mmc_io_rw_direct(func->card, 0, 0, SDIO_CCCR_IOEx, 0, &reg);
120 	if (ret)
121 		goto err;
122 
123 	reg &= ~(1 << func->num);
124 
125 	ret = mmc_io_rw_direct(func->card, 1, 0, SDIO_CCCR_IOEx, reg, NULL);
126 	if (ret)
127 		goto err;
128 
129 	pr_debug("SDIO: Disabled device %s\n", sdio_func_id(func));
130 
131 	return 0;
132 
133 err:
134 	pr_debug("SDIO: Failed to disable device %s\n", sdio_func_id(func));
135 	return -EIO;
136 }
137 EXPORT_SYMBOL_GPL(sdio_disable_func);
138 
139 /**
140  *	sdio_set_block_size - set the block size of an SDIO function
141  *	@func: SDIO function to change
142  *	@blksz: new block size or 0 to use the default.
143  *
144  *	The default block size is the largest supported by both the function
145  *	and the host, with a maximum of 512 to ensure that arbitrarily sized
146  *	data transfer use the optimal (least) number of commands.
147  *
148  *	A driver may call this to override the default block size set by the
149  *	core. This can be used to set a block size greater than the maximum
150  *	that reported by the card; it is the driver's responsibility to ensure
151  *	it uses a value that the card supports.
152  *
153  *	Returns 0 on success, -EINVAL if the host does not support the
154  *	requested block size, or -EIO (etc.) if one of the resultant FBR block
155  *	size register writes failed.
156  *
157  */
158 int sdio_set_block_size(struct sdio_func *func, unsigned blksz)
159 {
160 	int ret;
161 
162 	if (blksz > func->card->host->max_blk_size)
163 		return -EINVAL;
164 
165 	if (blksz == 0) {
166 		blksz = min(func->max_blksize, func->card->host->max_blk_size);
167 		blksz = min(blksz, 512u);
168 	}
169 
170 	ret = mmc_io_rw_direct(func->card, 1, 0,
171 		SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE,
172 		blksz & 0xff, NULL);
173 	if (ret)
174 		return ret;
175 	ret = mmc_io_rw_direct(func->card, 1, 0,
176 		SDIO_FBR_BASE(func->num) + SDIO_FBR_BLKSIZE + 1,
177 		(blksz >> 8) & 0xff, NULL);
178 	if (ret)
179 		return ret;
180 	func->cur_blksize = blksz;
181 	return 0;
182 }
183 EXPORT_SYMBOL_GPL(sdio_set_block_size);
184 
185 /*
186  * Calculate the maximum byte mode transfer size
187  */
188 static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
189 {
190 	unsigned mval =	min(func->card->host->max_seg_size,
191 			    func->card->host->max_blk_size);
192 	mval = min(mval, func->max_blksize);
193 	return min(mval, 512u); /* maximum size for byte mode */
194 }
195 
196 /**
197  *	sdio_align_size - pads a transfer size to a more optimal value
198  *	@func: SDIO function
199  *	@sz: original transfer size
200  *
201  *	Pads the original data size with a number of extra bytes in
202  *	order to avoid controller bugs and/or performance hits
203  *	(e.g. some controllers revert to PIO for certain sizes).
204  *
205  *	If possible, it will also adjust the size so that it can be
206  *	handled in just a single request.
207  *
208  *	Returns the improved size, which might be unmodified.
209  */
210 unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz)
211 {
212 	unsigned int orig_sz;
213 	unsigned int blk_sz, byte_sz;
214 	unsigned chunk_sz;
215 
216 	orig_sz = sz;
217 
218 	/*
219 	 * Do a first check with the controller, in case it
220 	 * wants to increase the size up to a point where it
221 	 * might need more than one block.
222 	 */
223 	sz = mmc_align_data_size(func->card, sz);
224 
225 	/*
226 	 * If we can still do this with just a byte transfer, then
227 	 * we're done.
228 	 */
229 	if (sz <= sdio_max_byte_size(func))
230 		return sz;
231 
232 	if (func->card->cccr.multi_block) {
233 		/*
234 		 * Check if the transfer is already block aligned
235 		 */
236 		if ((sz % func->cur_blksize) == 0)
237 			return sz;
238 
239 		/*
240 		 * Realign it so that it can be done with one request,
241 		 * and recheck if the controller still likes it.
242 		 */
243 		blk_sz = ((sz + func->cur_blksize - 1) /
244 			func->cur_blksize) * func->cur_blksize;
245 		blk_sz = mmc_align_data_size(func->card, blk_sz);
246 
247 		/*
248 		 * This value is only good if it is still just
249 		 * one request.
250 		 */
251 		if ((blk_sz % func->cur_blksize) == 0)
252 			return blk_sz;
253 
254 		/*
255 		 * We failed to do one request, but at least try to
256 		 * pad the remainder properly.
257 		 */
258 		byte_sz = mmc_align_data_size(func->card,
259 				sz % func->cur_blksize);
260 		if (byte_sz <= sdio_max_byte_size(func)) {
261 			blk_sz = sz / func->cur_blksize;
262 			return blk_sz * func->cur_blksize + byte_sz;
263 		}
264 	} else {
265 		/*
266 		 * We need multiple requests, so first check that the
267 		 * controller can handle the chunk size;
268 		 */
269 		chunk_sz = mmc_align_data_size(func->card,
270 				sdio_max_byte_size(func));
271 		if (chunk_sz == sdio_max_byte_size(func)) {
272 			/*
273 			 * Fix up the size of the remainder (if any)
274 			 */
275 			byte_sz = orig_sz % chunk_sz;
276 			if (byte_sz) {
277 				byte_sz = mmc_align_data_size(func->card,
278 						byte_sz);
279 			}
280 
281 			return (orig_sz / chunk_sz) * chunk_sz + byte_sz;
282 		}
283 	}
284 
285 	/*
286 	 * The controller is simply incapable of transferring the size
287 	 * we want in decent manner, so just return the original size.
288 	 */
289 	return orig_sz;
290 }
291 EXPORT_SYMBOL_GPL(sdio_align_size);
292 
293 /* Split an arbitrarily sized data transfer into several
294  * IO_RW_EXTENDED commands. */
295 static int sdio_io_rw_ext_helper(struct sdio_func *func, int write,
296 	unsigned addr, int incr_addr, u8 *buf, unsigned size)
297 {
298 	unsigned remainder = size;
299 	unsigned max_blocks;
300 	int ret;
301 
302 	/* Do the bulk of the transfer using block mode (if supported). */
303 	if (func->card->cccr.multi_block && (size > sdio_max_byte_size(func))) {
304 		/* Blocks per command is limited by host count, host transfer
305 		 * size (we only use a single sg entry) and the maximum for
306 		 * IO_RW_EXTENDED of 511 blocks. */
307 		max_blocks = min(func->card->host->max_blk_count,
308 			func->card->host->max_seg_size / func->cur_blksize);
309 		max_blocks = min(max_blocks, 511u);
310 
311 		while (remainder > func->cur_blksize) {
312 			unsigned blocks;
313 
314 			blocks = remainder / func->cur_blksize;
315 			if (blocks > max_blocks)
316 				blocks = max_blocks;
317 			size = blocks * func->cur_blksize;
318 
319 			ret = mmc_io_rw_extended(func->card, write,
320 				func->num, addr, incr_addr, buf,
321 				blocks, func->cur_blksize);
322 			if (ret)
323 				return ret;
324 
325 			remainder -= size;
326 			buf += size;
327 			if (incr_addr)
328 				addr += size;
329 		}
330 	}
331 
332 	/* Write the remainder using byte mode. */
333 	while (remainder > 0) {
334 		size = min(remainder, sdio_max_byte_size(func));
335 
336 		ret = mmc_io_rw_extended(func->card, write, func->num, addr,
337 			 incr_addr, buf, 1, size);
338 		if (ret)
339 			return ret;
340 
341 		remainder -= size;
342 		buf += size;
343 		if (incr_addr)
344 			addr += size;
345 	}
346 	return 0;
347 }
348 
349 /**
350  *	sdio_readb - read a single byte from a SDIO function
351  *	@func: SDIO function to access
352  *	@addr: address to read
353  *	@err_ret: optional status value from transfer
354  *
355  *	Reads a single byte from the address space of a given SDIO
356  *	function. If there is a problem reading the address, 0xff
357  *	is returned and @err_ret will contain the error code.
358  */
359 u8 sdio_readb(struct sdio_func *func, unsigned int addr, int *err_ret)
360 {
361 	int ret;
362 	u8 val;
363 
364 	BUG_ON(!func);
365 
366 	if (err_ret)
367 		*err_ret = 0;
368 
369 	ret = mmc_io_rw_direct(func->card, 0, func->num, addr, 0, &val);
370 	if (ret) {
371 		if (err_ret)
372 			*err_ret = ret;
373 		return 0xFF;
374 	}
375 
376 	return val;
377 }
378 EXPORT_SYMBOL_GPL(sdio_readb);
379 
380 /**
381  *	sdio_writeb - write a single byte to a SDIO function
382  *	@func: SDIO function to access
383  *	@b: byte to write
384  *	@addr: address to write to
385  *	@err_ret: optional status value from transfer
386  *
387  *	Writes a single byte to the address space of a given SDIO
388  *	function. @err_ret will contain the status of the actual
389  *	transfer.
390  */
391 void sdio_writeb(struct sdio_func *func, u8 b, unsigned int addr, int *err_ret)
392 {
393 	int ret;
394 
395 	BUG_ON(!func);
396 
397 	ret = mmc_io_rw_direct(func->card, 1, func->num, addr, b, NULL);
398 	if (err_ret)
399 		*err_ret = ret;
400 }
401 EXPORT_SYMBOL_GPL(sdio_writeb);
402 
403 /**
404  *	sdio_memcpy_fromio - read a chunk of memory from a SDIO function
405  *	@func: SDIO function to access
406  *	@dst: buffer to store the data
407  *	@addr: address to begin reading from
408  *	@count: number of bytes to read
409  *
410  *	Reads from the address space of a given SDIO function. Return
411  *	value indicates if the transfer succeeded or not.
412  */
413 int sdio_memcpy_fromio(struct sdio_func *func, void *dst,
414 	unsigned int addr, int count)
415 {
416 	return sdio_io_rw_ext_helper(func, 0, addr, 1, dst, count);
417 }
418 EXPORT_SYMBOL_GPL(sdio_memcpy_fromio);
419 
420 /**
421  *	sdio_memcpy_toio - write a chunk of memory to a SDIO function
422  *	@func: SDIO function to access
423  *	@addr: address to start writing to
424  *	@src: buffer that contains the data to write
425  *	@count: number of bytes to write
426  *
427  *	Writes to the address space of a given SDIO function. Return
428  *	value indicates if the transfer succeeded or not.
429  */
430 int sdio_memcpy_toio(struct sdio_func *func, unsigned int addr,
431 	void *src, int count)
432 {
433 	return sdio_io_rw_ext_helper(func, 1, addr, 1, src, count);
434 }
435 EXPORT_SYMBOL_GPL(sdio_memcpy_toio);
436 
437 /**
438  *	sdio_readsb - read from a FIFO on a SDIO function
439  *	@func: SDIO function to access
440  *	@dst: buffer to store the data
441  *	@addr: address of (single byte) FIFO
442  *	@count: number of bytes to read
443  *
444  *	Reads from the specified FIFO of a given SDIO function. Return
445  *	value indicates if the transfer succeeded or not.
446  */
447 int sdio_readsb(struct sdio_func *func, void *dst, unsigned int addr,
448 	int count)
449 {
450 	return sdio_io_rw_ext_helper(func, 0, addr, 0, dst, count);
451 }
452 EXPORT_SYMBOL_GPL(sdio_readsb);
453 
454 /**
455  *	sdio_writesb - write to a FIFO of a SDIO function
456  *	@func: SDIO function to access
457  *	@addr: address of (single byte) FIFO
458  *	@src: buffer that contains the data to write
459  *	@count: number of bytes to write
460  *
461  *	Writes to the specified FIFO of a given SDIO function. Return
462  *	value indicates if the transfer succeeded or not.
463  */
464 int sdio_writesb(struct sdio_func *func, unsigned int addr, void *src,
465 	int count)
466 {
467 	return sdio_io_rw_ext_helper(func, 1, addr, 0, src, count);
468 }
469 EXPORT_SYMBOL_GPL(sdio_writesb);
470 
471 /**
472  *	sdio_readw - read a 16 bit integer from a SDIO function
473  *	@func: SDIO function to access
474  *	@addr: address to read
475  *	@err_ret: optional status value from transfer
476  *
477  *	Reads a 16 bit integer from the address space of a given SDIO
478  *	function. If there is a problem reading the address, 0xffff
479  *	is returned and @err_ret will contain the error code.
480  */
481 u16 sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret)
482 {
483 	int ret;
484 
485 	if (err_ret)
486 		*err_ret = 0;
487 
488 	ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 2);
489 	if (ret) {
490 		if (err_ret)
491 			*err_ret = ret;
492 		return 0xFFFF;
493 	}
494 
495 	return le16_to_cpup((__le16 *)func->tmpbuf);
496 }
497 EXPORT_SYMBOL_GPL(sdio_readw);
498 
499 /**
500  *	sdio_writew - write a 16 bit integer to a SDIO function
501  *	@func: SDIO function to access
502  *	@b: integer to write
503  *	@addr: address to write to
504  *	@err_ret: optional status value from transfer
505  *
506  *	Writes a 16 bit integer to the address space of a given SDIO
507  *	function. @err_ret will contain the status of the actual
508  *	transfer.
509  */
510 void sdio_writew(struct sdio_func *func, u16 b, unsigned int addr, int *err_ret)
511 {
512 	int ret;
513 
514 	*(__le16 *)func->tmpbuf = cpu_to_le16(b);
515 
516 	ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 2);
517 	if (err_ret)
518 		*err_ret = ret;
519 }
520 EXPORT_SYMBOL_GPL(sdio_writew);
521 
522 /**
523  *	sdio_readl - read a 32 bit integer from a SDIO function
524  *	@func: SDIO function to access
525  *	@addr: address to read
526  *	@err_ret: optional status value from transfer
527  *
528  *	Reads a 32 bit integer from the address space of a given SDIO
529  *	function. If there is a problem reading the address,
530  *	0xffffffff is returned and @err_ret will contain the error
531  *	code.
532  */
533 u32 sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret)
534 {
535 	int ret;
536 
537 	if (err_ret)
538 		*err_ret = 0;
539 
540 	ret = sdio_memcpy_fromio(func, func->tmpbuf, addr, 4);
541 	if (ret) {
542 		if (err_ret)
543 			*err_ret = ret;
544 		return 0xFFFFFFFF;
545 	}
546 
547 	return le32_to_cpup((__le32 *)func->tmpbuf);
548 }
549 EXPORT_SYMBOL_GPL(sdio_readl);
550 
551 /**
552  *	sdio_writel - write a 32 bit integer to a SDIO function
553  *	@func: SDIO function to access
554  *	@b: integer to write
555  *	@addr: address to write to
556  *	@err_ret: optional status value from transfer
557  *
558  *	Writes a 32 bit integer to the address space of a given SDIO
559  *	function. @err_ret will contain the status of the actual
560  *	transfer.
561  */
562 void sdio_writel(struct sdio_func *func, u32 b, unsigned int addr, int *err_ret)
563 {
564 	int ret;
565 
566 	*(__le32 *)func->tmpbuf = cpu_to_le32(b);
567 
568 	ret = sdio_memcpy_toio(func, addr, func->tmpbuf, 4);
569 	if (err_ret)
570 		*err_ret = ret;
571 }
572 EXPORT_SYMBOL_GPL(sdio_writel);
573 
574 /**
575  *	sdio_f0_readb - read a single byte from SDIO function 0
576  *	@func: an SDIO function of the card
577  *	@addr: address to read
578  *	@err_ret: optional status value from transfer
579  *
580  *	Reads a single byte from the address space of SDIO function 0.
581  *	If there is a problem reading the address, 0xff is returned
582  *	and @err_ret will contain the error code.
583  */
584 unsigned char sdio_f0_readb(struct sdio_func *func, unsigned int addr,
585 	int *err_ret)
586 {
587 	int ret;
588 	unsigned char val;
589 
590 	BUG_ON(!func);
591 
592 	if (err_ret)
593 		*err_ret = 0;
594 
595 	ret = mmc_io_rw_direct(func->card, 0, 0, addr, 0, &val);
596 	if (ret) {
597 		if (err_ret)
598 			*err_ret = ret;
599 		return 0xFF;
600 	}
601 
602 	return val;
603 }
604 EXPORT_SYMBOL_GPL(sdio_f0_readb);
605 
606 /**
607  *	sdio_f0_writeb - write a single byte to SDIO function 0
608  *	@func: an SDIO function of the card
609  *	@b: byte to write
610  *	@addr: address to write to
611  *	@err_ret: optional status value from transfer
612  *
613  *	Writes a single byte to the address space of SDIO function 0.
614  *	@err_ret will contain the status of the actual transfer.
615  *
616  *	Only writes to the vendor specific CCCR registers (0xF0 -
617  *	0xFF) are permiited; @err_ret will be set to -EINVAL for *
618  *	writes outside this range.
619  */
620 void sdio_f0_writeb(struct sdio_func *func, unsigned char b, unsigned int addr,
621 	int *err_ret)
622 {
623 	int ret;
624 
625 	BUG_ON(!func);
626 
627 	if ((addr < 0xF0 || addr > 0xFF) && (!mmc_card_lenient_fn0(func->card))) {
628 		if (err_ret)
629 			*err_ret = -EINVAL;
630 		return;
631 	}
632 
633 	ret = mmc_io_rw_direct(func->card, 1, 0, addr, b, NULL);
634 	if (err_ret)
635 		*err_ret = ret;
636 }
637 EXPORT_SYMBOL_GPL(sdio_f0_writeb);
638