1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Realtek USB Memstick Card Interface driver
3  *
4  * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
5  *
6  * Author:
7  *   Roger Tseng <rogerable@realtek.com>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/highmem.h>
12 #include <linux/delay.h>
13 #include <linux/platform_device.h>
14 #include <linux/workqueue.h>
15 #include <linux/memstick.h>
16 #include <linux/kthread.h>
17 #include <linux/rtsx_usb.h>
18 #include <linux/pm_runtime.h>
19 #include <linux/mutex.h>
20 #include <linux/sched.h>
21 #include <linux/completion.h>
22 #include <asm/unaligned.h>
23 
24 struct rtsx_usb_ms {
25 	struct platform_device	*pdev;
26 	struct rtsx_ucr	*ucr;
27 	struct memstick_host	*msh;
28 	struct memstick_request	*req;
29 
30 	struct mutex		host_mutex;
31 	struct work_struct	handle_req;
32 	struct delayed_work	poll_card;
33 
34 	u8			ssc_depth;
35 	unsigned int		clock;
36 	int			power_mode;
37 	unsigned char           ifmode;
38 	bool			eject;
39 	bool			system_suspending;
40 };
41 
42 static inline struct device *ms_dev(struct rtsx_usb_ms *host)
43 {
44 	return &(host->pdev->dev);
45 }
46 
47 static inline void ms_clear_error(struct rtsx_usb_ms *host)
48 {
49 	struct rtsx_ucr *ucr = host->ucr;
50 	rtsx_usb_ep0_write_register(ucr, CARD_STOP,
51 				  MS_STOP | MS_CLR_ERR,
52 				  MS_STOP | MS_CLR_ERR);
53 
54 	rtsx_usb_clear_dma_err(ucr);
55 	rtsx_usb_clear_fsm_err(ucr);
56 }
57 
58 #ifdef DEBUG
59 
60 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
61 {
62 	struct rtsx_ucr *ucr = host->ucr;
63 	u16 i;
64 	u8 *ptr;
65 
66 	/* Print MS host internal registers */
67 	rtsx_usb_init_cmd(ucr);
68 
69 	/* MS_CFG to MS_INT_REG */
70 	for (i = 0xFD40; i <= 0xFD44; i++)
71 		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
72 
73 	/* CARD_SHARE_MODE to CARD_GPIO */
74 	for (i = 0xFD51; i <= 0xFD56; i++)
75 		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
76 
77 	/* CARD_PULL_CTLx */
78 	for (i = 0xFD60; i <= 0xFD65; i++)
79 		rtsx_usb_add_cmd(ucr, READ_REG_CMD, i, 0, 0);
80 
81 	/* CARD_DATA_SOURCE, CARD_SELECT, CARD_CLK_EN, CARD_PWR_CTL */
82 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_DATA_SOURCE, 0, 0);
83 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_SELECT, 0, 0);
84 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_CLK_EN, 0, 0);
85 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_PWR_CTL, 0, 0);
86 
87 	rtsx_usb_send_cmd(ucr, MODE_CR, 100);
88 	rtsx_usb_get_rsp(ucr, 21, 100);
89 
90 	ptr = ucr->rsp_buf;
91 	for (i = 0xFD40; i <= 0xFD44; i++)
92 		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
93 	for (i = 0xFD51; i <= 0xFD56; i++)
94 		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
95 	for (i = 0xFD60; i <= 0xFD65; i++)
96 		dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", i, *(ptr++));
97 
98 	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_DATA_SOURCE, *(ptr++));
99 	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_SELECT, *(ptr++));
100 	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_CLK_EN, *(ptr++));
101 	dev_dbg(ms_dev(host), "0x%04X: 0x%02x\n", CARD_PWR_CTL, *(ptr++));
102 }
103 
104 #else
105 
106 static void ms_print_debug_regs(struct rtsx_usb_ms *host)
107 {
108 }
109 
110 #endif
111 
112 static int ms_pull_ctl_disable_lqfp48(struct rtsx_ucr *ucr)
113 {
114 	rtsx_usb_init_cmd(ucr);
115 
116 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
117 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
118 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
119 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
120 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
121 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
122 
123 	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
124 }
125 
126 static int ms_pull_ctl_disable_qfn24(struct rtsx_ucr *ucr)
127 {
128 	rtsx_usb_init_cmd(ucr);
129 
130 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
131 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
132 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
133 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
134 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x56);
135 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
136 
137 	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
138 }
139 
140 static int ms_pull_ctl_enable_lqfp48(struct rtsx_ucr *ucr)
141 {
142 	rtsx_usb_init_cmd(ucr);
143 
144 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x55);
145 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
146 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
147 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
148 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
149 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0xA5);
150 
151 	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
152 }
153 
154 static int ms_pull_ctl_enable_qfn24(struct rtsx_ucr *ucr)
155 {
156 	rtsx_usb_init_cmd(ucr);
157 
158 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF, 0x65);
159 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF, 0x55);
160 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF, 0x95);
161 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF, 0x55);
162 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF, 0x55);
163 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF, 0x59);
164 
165 	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
166 }
167 
168 static int ms_power_on(struct rtsx_usb_ms *host)
169 {
170 	struct rtsx_ucr *ucr = host->ucr;
171 	int err;
172 
173 	dev_dbg(ms_dev(host), "%s\n", __func__);
174 
175 	rtsx_usb_init_cmd(ucr);
176 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SELECT, 0x07, MS_MOD_SEL);
177 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_SHARE_MODE,
178 			CARD_SHARE_MASK, CARD_SHARE_MS);
179 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN,
180 			MS_CLK_EN, MS_CLK_EN);
181 	err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
182 	if (err < 0)
183 		return err;
184 
185 	if (CHECK_PKG(ucr, LQFP48))
186 		err = ms_pull_ctl_enable_lqfp48(ucr);
187 	else
188 		err = ms_pull_ctl_enable_qfn24(ucr);
189 	if (err < 0)
190 		return err;
191 
192 	err = rtsx_usb_write_register(ucr, CARD_PWR_CTL,
193 			POWER_MASK, PARTIAL_POWER_ON);
194 	if (err)
195 		return err;
196 
197 	usleep_range(800, 1000);
198 
199 	rtsx_usb_init_cmd(ucr);
200 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
201 			POWER_MASK, POWER_ON);
202 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE,
203 			MS_OUTPUT_EN, MS_OUTPUT_EN);
204 
205 	return rtsx_usb_send_cmd(ucr, MODE_C, 100);
206 }
207 
208 static int ms_power_off(struct rtsx_usb_ms *host)
209 {
210 	struct rtsx_ucr *ucr = host->ucr;
211 	int err;
212 
213 	dev_dbg(ms_dev(host), "%s\n", __func__);
214 
215 	rtsx_usb_init_cmd(ucr);
216 
217 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_CLK_EN, MS_CLK_EN, 0);
218 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_OE, MS_OUTPUT_EN, 0);
219 
220 	err = rtsx_usb_send_cmd(ucr, MODE_C, 100);
221 	if (err < 0)
222 		return err;
223 
224 	if (CHECK_PKG(ucr, LQFP48))
225 		return ms_pull_ctl_disable_lqfp48(ucr);
226 
227 	return ms_pull_ctl_disable_qfn24(ucr);
228 }
229 
230 static int ms_transfer_data(struct rtsx_usb_ms *host, unsigned char data_dir,
231 		u8 tpc, u8 cfg, struct scatterlist *sg)
232 {
233 	struct rtsx_ucr *ucr = host->ucr;
234 	int err;
235 	unsigned int length = sg->length;
236 	u16 sec_cnt = (u16)(length / 512);
237 	u8 trans_mode, dma_dir, flag;
238 	unsigned int pipe;
239 	struct memstick_dev *card = host->msh->card;
240 
241 	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x, data_dir = %s, length = %d\n",
242 			__func__, tpc, (data_dir == READ) ? "READ" : "WRITE",
243 			length);
244 
245 	if (data_dir == READ) {
246 		flag = MODE_CDIR;
247 		dma_dir = DMA_DIR_FROM_CARD;
248 		if (card->id.type != MEMSTICK_TYPE_PRO)
249 			trans_mode = MS_TM_NORMAL_READ;
250 		else
251 			trans_mode = MS_TM_AUTO_READ;
252 		pipe = usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN);
253 	} else {
254 		flag = MODE_CDOR;
255 		dma_dir = DMA_DIR_TO_CARD;
256 		if (card->id.type != MEMSTICK_TYPE_PRO)
257 			trans_mode = MS_TM_NORMAL_WRITE;
258 		else
259 			trans_mode = MS_TM_AUTO_WRITE;
260 		pipe = usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT);
261 	}
262 
263 	rtsx_usb_init_cmd(ucr);
264 
265 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
266 	if (card->id.type == MEMSTICK_TYPE_PRO) {
267 		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_H,
268 				0xFF, (u8)(sec_cnt >> 8));
269 		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_SECTOR_CNT_L,
270 				0xFF, (u8)sec_cnt);
271 	}
272 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
273 
274 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC3,
275 			0xFF, (u8)(length >> 24));
276 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC2,
277 			0xFF, (u8)(length >> 16));
278 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC1,
279 			0xFF, (u8)(length >> 8));
280 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_TC0, 0xFF,
281 			(u8)length);
282 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MC_DMA_CTL,
283 			0x03 | DMA_PACK_SIZE_MASK, dma_dir | DMA_EN | DMA_512);
284 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
285 			0x01, RING_BUFFER);
286 
287 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
288 			0xFF, MS_TRANSFER_START | trans_mode);
289 	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
290 			MS_TRANSFER_END, MS_TRANSFER_END);
291 
292 	err = rtsx_usb_send_cmd(ucr, flag | STAGE_MS_STATUS, 100);
293 	if (err)
294 		return err;
295 
296 	err = rtsx_usb_transfer_data(ucr, pipe, sg, length,
297 			1, NULL, 10000);
298 	if (err)
299 		goto err_out;
300 
301 	err = rtsx_usb_get_rsp(ucr, 3, 15000);
302 	if (err)
303 		goto err_out;
304 
305 	if (ucr->rsp_buf[0] & MS_TRANSFER_ERR ||
306 	    ucr->rsp_buf[1] & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
307 		err = -EIO;
308 		goto err_out;
309 	}
310 	return 0;
311 err_out:
312 	ms_clear_error(host);
313 	return err;
314 }
315 
316 static int ms_write_bytes(struct rtsx_usb_ms *host, u8 tpc,
317 		u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
318 {
319 	struct rtsx_ucr *ucr = host->ucr;
320 	int err, i;
321 
322 	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
323 
324 	rtsx_usb_init_cmd(ucr);
325 
326 	for (i = 0; i < cnt; i++)
327 		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
328 				PPBUF_BASE2 + i, 0xFF, data[i]);
329 
330 	if (cnt % 2)
331 		rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
332 				PPBUF_BASE2 + i, 0xFF, 0xFF);
333 
334 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
335 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
336 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
337 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
338 			0x01, PINGPONG_BUFFER);
339 
340 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
341 			0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
342 	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
343 			MS_TRANSFER_END, MS_TRANSFER_END);
344 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
345 
346 	err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
347 	if (err)
348 		return err;
349 
350 	err = rtsx_usb_get_rsp(ucr, 2, 5000);
351 	if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
352 		u8 val;
353 
354 		rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
355 		dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
356 
357 		if (int_reg)
358 			*int_reg = val & 0x0F;
359 
360 		ms_print_debug_regs(host);
361 
362 		ms_clear_error(host);
363 
364 		if (!(tpc & 0x08)) {
365 			if (val & MS_CRC16_ERR)
366 				return -EIO;
367 		} else {
368 			if (!(val & 0x80)) {
369 				if (val & (MS_INT_ERR | MS_INT_CMDNK))
370 					return -EIO;
371 			}
372 		}
373 
374 		return -ETIMEDOUT;
375 	}
376 
377 	if (int_reg)
378 		*int_reg = ucr->rsp_buf[1] & 0x0F;
379 
380 	return 0;
381 }
382 
383 static int ms_read_bytes(struct rtsx_usb_ms *host, u8 tpc,
384 		u8 cfg, u8 cnt, u8 *data, u8 *int_reg)
385 {
386 	struct rtsx_ucr *ucr = host->ucr;
387 	int err, i;
388 	u8 *ptr;
389 
390 	dev_dbg(ms_dev(host), "%s: tpc = 0x%02x\n", __func__, tpc);
391 
392 	rtsx_usb_init_cmd(ucr);
393 
394 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
395 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
396 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
397 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DATA_SOURCE,
398 			0x01, PINGPONG_BUFFER);
399 
400 	rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, MS_TRANSFER,
401 			0xFF, MS_TRANSFER_START | MS_TM_READ_BYTES);
402 	rtsx_usb_add_cmd(ucr, CHECK_REG_CMD, MS_TRANSFER,
403 			MS_TRANSFER_END, MS_TRANSFER_END);
404 	for (i = 0; i < cnt - 1; i++)
405 		rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
406 	if (cnt % 2)
407 		rtsx_usb_add_cmd(ucr, READ_REG_CMD, PPBUF_BASE2 + cnt, 0, 0);
408 	else
409 		rtsx_usb_add_cmd(ucr, READ_REG_CMD,
410 				PPBUF_BASE2 + cnt - 1, 0, 0);
411 
412 	rtsx_usb_add_cmd(ucr, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
413 
414 	err = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
415 	if (err)
416 		return err;
417 
418 	err = rtsx_usb_get_rsp(ucr, cnt + 2, 5000);
419 	if (err || (ucr->rsp_buf[0] & MS_TRANSFER_ERR)) {
420 		u8 val;
421 
422 		rtsx_usb_ep0_read_register(ucr, MS_TRANS_CFG, &val);
423 		dev_dbg(ms_dev(host), "MS_TRANS_CFG: 0x%02x\n", val);
424 
425 		if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
426 			*int_reg = val & 0x0F;
427 
428 		ms_print_debug_regs(host);
429 
430 		ms_clear_error(host);
431 
432 		if (!(tpc & 0x08)) {
433 			if (val & MS_CRC16_ERR)
434 				return -EIO;
435 		} else {
436 			if (!(val & 0x80)) {
437 				if (val & (MS_INT_ERR | MS_INT_CMDNK))
438 					return -EIO;
439 			}
440 		}
441 
442 		return -ETIMEDOUT;
443 	}
444 
445 	ptr = ucr->rsp_buf + 1;
446 	for (i = 0; i < cnt; i++)
447 		data[i] = *ptr++;
448 
449 
450 	if (int_reg && (host->ifmode != MEMSTICK_SERIAL))
451 		*int_reg = *ptr & 0x0F;
452 
453 	return 0;
454 }
455 
456 static int rtsx_usb_ms_issue_cmd(struct rtsx_usb_ms *host)
457 {
458 	struct memstick_request *req = host->req;
459 	int err = 0;
460 	u8 cfg = 0, int_reg;
461 
462 	dev_dbg(ms_dev(host), "%s\n", __func__);
463 
464 	if (req->need_card_int) {
465 		if (host->ifmode != MEMSTICK_SERIAL)
466 			cfg = WAIT_INT;
467 	}
468 
469 	if (req->long_data) {
470 		err = ms_transfer_data(host, req->data_dir,
471 				req->tpc, cfg, &(req->sg));
472 	} else {
473 		if (req->data_dir == READ)
474 			err = ms_read_bytes(host, req->tpc, cfg,
475 					req->data_len, req->data, &int_reg);
476 		else
477 			err = ms_write_bytes(host, req->tpc, cfg,
478 					req->data_len, req->data, &int_reg);
479 	}
480 	if (err < 0)
481 		return err;
482 
483 	if (req->need_card_int) {
484 		if (host->ifmode == MEMSTICK_SERIAL) {
485 			err = ms_read_bytes(host, MS_TPC_GET_INT,
486 					NO_WAIT_INT, 1, &req->int_reg, NULL);
487 			if (err < 0)
488 				return err;
489 		} else {
490 
491 			if (int_reg & MS_INT_CMDNK)
492 				req->int_reg |= MEMSTICK_INT_CMDNAK;
493 			if (int_reg & MS_INT_BREQ)
494 				req->int_reg |= MEMSTICK_INT_BREQ;
495 			if (int_reg & MS_INT_ERR)
496 				req->int_reg |= MEMSTICK_INT_ERR;
497 			if (int_reg & MS_INT_CED)
498 				req->int_reg |= MEMSTICK_INT_CED;
499 		}
500 		dev_dbg(ms_dev(host), "int_reg: 0x%02x\n", req->int_reg);
501 	}
502 
503 	return 0;
504 }
505 
506 static void rtsx_usb_ms_handle_req(struct work_struct *work)
507 {
508 	struct rtsx_usb_ms *host = container_of(work,
509 			struct rtsx_usb_ms, handle_req);
510 	struct rtsx_ucr *ucr = host->ucr;
511 	struct memstick_host *msh = host->msh;
512 	int rc;
513 
514 	if (!host->req) {
515 		pm_runtime_get_sync(ms_dev(host));
516 		do {
517 			rc = memstick_next_req(msh, &host->req);
518 			dev_dbg(ms_dev(host), "next req %d\n", rc);
519 
520 			if (!rc) {
521 				mutex_lock(&ucr->dev_mutex);
522 
523 				if (rtsx_usb_card_exclusive_check(ucr,
524 							RTSX_USB_MS_CARD))
525 					host->req->error = -EIO;
526 				else
527 					host->req->error =
528 						rtsx_usb_ms_issue_cmd(host);
529 
530 				mutex_unlock(&ucr->dev_mutex);
531 
532 				dev_dbg(ms_dev(host), "req result %d\n",
533 						host->req->error);
534 			}
535 		} while (!rc);
536 		pm_runtime_put_sync(ms_dev(host));
537 	}
538 
539 }
540 
541 static void rtsx_usb_ms_request(struct memstick_host *msh)
542 {
543 	struct rtsx_usb_ms *host = memstick_priv(msh);
544 
545 	dev_dbg(ms_dev(host), "--> %s\n", __func__);
546 
547 	if (!host->eject)
548 		schedule_work(&host->handle_req);
549 }
550 
551 static int rtsx_usb_ms_set_param(struct memstick_host *msh,
552 		enum memstick_param param, int value)
553 {
554 	struct rtsx_usb_ms *host = memstick_priv(msh);
555 	struct rtsx_ucr *ucr = host->ucr;
556 	unsigned int clock = 0;
557 	u8 ssc_depth = 0;
558 	int err;
559 
560 	dev_dbg(ms_dev(host), "%s: param = %d, value = %d\n",
561 			__func__, param, value);
562 
563 	pm_runtime_get_sync(ms_dev(host));
564 	mutex_lock(&ucr->dev_mutex);
565 
566 	err = rtsx_usb_card_exclusive_check(ucr, RTSX_USB_MS_CARD);
567 	if (err)
568 		goto out;
569 
570 	switch (param) {
571 	case MEMSTICK_POWER:
572 		if (value == host->power_mode)
573 			break;
574 
575 		if (value == MEMSTICK_POWER_ON) {
576 			pm_runtime_get_noresume(ms_dev(host));
577 			err = ms_power_on(host);
578 			if (err)
579 				pm_runtime_put_noidle(ms_dev(host));
580 		} else if (value == MEMSTICK_POWER_OFF) {
581 			err = ms_power_off(host);
582 			if (!err)
583 				pm_runtime_put_noidle(ms_dev(host));
584 		} else
585 			err = -EINVAL;
586 		if (!err)
587 			host->power_mode = value;
588 		break;
589 
590 	case MEMSTICK_INTERFACE:
591 		if (value == MEMSTICK_SERIAL) {
592 			clock = 19000000;
593 			ssc_depth = SSC_DEPTH_512K;
594 			err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
595 				       MS_BUS_WIDTH_1 | PUSH_TIME_DEFAULT);
596 			if (err < 0)
597 				break;
598 		} else if (value == MEMSTICK_PAR4) {
599 			clock = 39000000;
600 			ssc_depth = SSC_DEPTH_1M;
601 
602 			err = rtsx_usb_write_register(ucr, MS_CFG, 0x5A,
603 					MS_BUS_WIDTH_4 | PUSH_TIME_ODD |
604 					MS_NO_CHECK_INT);
605 			if (err < 0)
606 				break;
607 		} else {
608 			err = -EINVAL;
609 			break;
610 		}
611 
612 		err = rtsx_usb_switch_clock(ucr, clock,
613 				ssc_depth, false, true, false);
614 		if (err < 0) {
615 			dev_dbg(ms_dev(host), "switch clock failed\n");
616 			break;
617 		}
618 
619 		host->ssc_depth = ssc_depth;
620 		host->clock = clock;
621 		host->ifmode = value;
622 		break;
623 	default:
624 		err = -EINVAL;
625 		break;
626 	}
627 out:
628 	mutex_unlock(&ucr->dev_mutex);
629 	pm_runtime_put_sync(ms_dev(host));
630 
631 	/* power-on delay */
632 	if (param == MEMSTICK_POWER && value == MEMSTICK_POWER_ON) {
633 		usleep_range(10000, 12000);
634 
635 		if (!host->eject)
636 			schedule_delayed_work(&host->poll_card, 100);
637 	}
638 
639 	dev_dbg(ms_dev(host), "%s: return = %d\n", __func__, err);
640 	return err;
641 }
642 
643 #ifdef CONFIG_PM_SLEEP
644 static int rtsx_usb_ms_suspend(struct device *dev)
645 {
646 	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
647 	struct memstick_host *msh = host->msh;
648 
649 	/* Since we use rtsx_usb's resume callback to runtime resume its
650 	 * children to implement remote wakeup signaling, this causes
651 	 * rtsx_usb_ms' runtime resume callback runs after its suspend
652 	 * callback:
653 	 * rtsx_usb_ms_suspend()
654 	 * rtsx_usb_resume()
655 	 *   -> rtsx_usb_ms_runtime_resume()
656 	 *     -> memstick_detect_change()
657 	 *
658 	 * rtsx_usb_suspend()
659 	 *
660 	 * To avoid this, skip runtime resume/suspend if system suspend is
661 	 * underway.
662 	 */
663 
664 	host->system_suspending = true;
665 	memstick_suspend_host(msh);
666 
667 	return 0;
668 }
669 
670 static int rtsx_usb_ms_resume(struct device *dev)
671 {
672 	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
673 	struct memstick_host *msh = host->msh;
674 
675 	memstick_resume_host(msh);
676 	host->system_suspending = false;
677 
678 	return 0;
679 }
680 #endif /* CONFIG_PM_SLEEP */
681 
682 #ifdef CONFIG_PM
683 static int rtsx_usb_ms_runtime_suspend(struct device *dev)
684 {
685 	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
686 
687 	if (host->system_suspending)
688 		return 0;
689 
690 	if (host->msh->card || host->power_mode != MEMSTICK_POWER_OFF)
691 		return -EAGAIN;
692 
693 	return 0;
694 }
695 
696 static int rtsx_usb_ms_runtime_resume(struct device *dev)
697 {
698 	struct rtsx_usb_ms *host = dev_get_drvdata(dev);
699 
700 
701 	if (host->system_suspending)
702 		return 0;
703 
704 	memstick_detect_change(host->msh);
705 
706 	return 0;
707 }
708 #endif /* CONFIG_PM */
709 
710 static const struct dev_pm_ops rtsx_usb_ms_pm_ops = {
711 	SET_SYSTEM_SLEEP_PM_OPS(rtsx_usb_ms_suspend, rtsx_usb_ms_resume)
712 	SET_RUNTIME_PM_OPS(rtsx_usb_ms_runtime_suspend, rtsx_usb_ms_runtime_resume, NULL)
713 };
714 
715 
716 static void rtsx_usb_ms_poll_card(struct work_struct *work)
717 {
718 	struct rtsx_usb_ms *host = container_of(work, struct rtsx_usb_ms,
719 			poll_card.work);
720 	struct rtsx_ucr *ucr = host->ucr;
721 	int err;
722 	u8 val;
723 
724 	if (host->eject || host->power_mode != MEMSTICK_POWER_ON)
725 		return;
726 
727 	pm_runtime_get_sync(ms_dev(host));
728 	mutex_lock(&ucr->dev_mutex);
729 
730 	/* Check pending MS card changes */
731 	err = rtsx_usb_read_register(ucr, CARD_INT_PEND, &val);
732 	if (err) {
733 		mutex_unlock(&ucr->dev_mutex);
734 		goto poll_again;
735 	}
736 
737 	/* Clear the pending */
738 	rtsx_usb_write_register(ucr, CARD_INT_PEND,
739 			XD_INT | MS_INT | SD_INT,
740 			XD_INT | MS_INT | SD_INT);
741 
742 	mutex_unlock(&ucr->dev_mutex);
743 
744 	if (val & MS_INT) {
745 		dev_dbg(ms_dev(host), "MS slot change detected\n");
746 		memstick_detect_change(host->msh);
747 	}
748 
749 poll_again:
750 	pm_runtime_put_sync(ms_dev(host));
751 
752 	if (!host->eject && host->power_mode == MEMSTICK_POWER_ON)
753 		schedule_delayed_work(&host->poll_card, 100);
754 }
755 
756 static int rtsx_usb_ms_drv_probe(struct platform_device *pdev)
757 {
758 	struct memstick_host *msh;
759 	struct rtsx_usb_ms *host;
760 	struct rtsx_ucr *ucr;
761 	int err;
762 
763 	ucr = usb_get_intfdata(to_usb_interface(pdev->dev.parent));
764 	if (!ucr)
765 		return -ENXIO;
766 
767 	dev_dbg(&(pdev->dev),
768 			"Realtek USB Memstick controller found\n");
769 
770 	msh = memstick_alloc_host(sizeof(*host), &pdev->dev);
771 	if (!msh)
772 		return -ENOMEM;
773 
774 	host = memstick_priv(msh);
775 	host->ucr = ucr;
776 	host->msh = msh;
777 	host->pdev = pdev;
778 	host->power_mode = MEMSTICK_POWER_OFF;
779 	platform_set_drvdata(pdev, host);
780 
781 	mutex_init(&host->host_mutex);
782 	INIT_WORK(&host->handle_req, rtsx_usb_ms_handle_req);
783 
784 	INIT_DELAYED_WORK(&host->poll_card, rtsx_usb_ms_poll_card);
785 
786 	msh->request = rtsx_usb_ms_request;
787 	msh->set_param = rtsx_usb_ms_set_param;
788 	msh->caps = MEMSTICK_CAP_PAR4;
789 
790 	pm_runtime_get_noresume(ms_dev(host));
791 	pm_runtime_set_active(ms_dev(host));
792 	pm_runtime_enable(ms_dev(host));
793 
794 	err = memstick_add_host(msh);
795 	if (err)
796 		goto err_out;
797 
798 	pm_runtime_put(ms_dev(host));
799 
800 	return 0;
801 err_out:
802 	memstick_free_host(msh);
803 	pm_runtime_disable(ms_dev(host));
804 	pm_runtime_put_noidle(ms_dev(host));
805 	return err;
806 }
807 
808 static int rtsx_usb_ms_drv_remove(struct platform_device *pdev)
809 {
810 	struct rtsx_usb_ms *host = platform_get_drvdata(pdev);
811 	struct memstick_host *msh = host->msh;
812 	int err;
813 
814 	host->eject = true;
815 	cancel_work_sync(&host->handle_req);
816 
817 	mutex_lock(&host->host_mutex);
818 	if (host->req) {
819 		dev_dbg(ms_dev(host),
820 			"%s: Controller removed during transfer\n",
821 			dev_name(&msh->dev));
822 		host->req->error = -ENOMEDIUM;
823 		do {
824 			err = memstick_next_req(msh, &host->req);
825 			if (!err)
826 				host->req->error = -ENOMEDIUM;
827 		} while (!err);
828 	}
829 	mutex_unlock(&host->host_mutex);
830 
831 	memstick_remove_host(msh);
832 	memstick_free_host(msh);
833 
834 	/* Balance possible unbalanced usage count
835 	 * e.g. unconditional module removal
836 	 */
837 	if (pm_runtime_active(ms_dev(host)))
838 		pm_runtime_put(ms_dev(host));
839 
840 	pm_runtime_disable(ms_dev(host));
841 	platform_set_drvdata(pdev, NULL);
842 
843 	dev_dbg(ms_dev(host),
844 		": Realtek USB Memstick controller has been removed\n");
845 
846 	return 0;
847 }
848 
849 static struct platform_device_id rtsx_usb_ms_ids[] = {
850 	{
851 		.name = "rtsx_usb_ms",
852 	}, {
853 		/* sentinel */
854 	}
855 };
856 MODULE_DEVICE_TABLE(platform, rtsx_usb_ms_ids);
857 
858 static struct platform_driver rtsx_usb_ms_driver = {
859 	.probe		= rtsx_usb_ms_drv_probe,
860 	.remove		= rtsx_usb_ms_drv_remove,
861 	.id_table       = rtsx_usb_ms_ids,
862 	.driver		= {
863 		.name	= "rtsx_usb_ms",
864 		.pm	= &rtsx_usb_ms_pm_ops,
865 	},
866 };
867 module_platform_driver(rtsx_usb_ms_driver);
868 
869 MODULE_LICENSE("GPL v2");
870 MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
871 MODULE_DESCRIPTION("Realtek USB Memstick Card Host Driver");
872