?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 6.14-rc1
[linux.git] / drivers / misc / cardreader / rtsx_usb.c
blobe0174da5e9fc39ae96b70ce70d57a87dfaa2ebdb
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Driver for Realtek USB card reader
3 *
4 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
5 *
6 * Author:
7 * Roger Tseng <rogerable@realtek.com>
8 */
9 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/mutex.h>
12 #include <linux/usb.h>
13 #include <linux/platform_device.h>
14 #include <linux/mfd/core.h>
15 #include <linux/rtsx_usb.h>
16
17 static int polling_pipe = 1;
18 module_param(polling_pipe, int, S_IRUGO | S_IWUSR);
19 MODULE_PARM_DESC(polling_pipe, "polling pipe (0: ctl, 1: bulk)");
20
21 static const struct mfd_cell rtsx_usb_cells[] = {
22 [RTSX_USB_SD_CARD] = {
23 .name = DRV_NAME_RTSX_USB_SDMMC,
24 .pdata_size = 0,
25 },
26 [RTSX_USB_MS_CARD] = {
27 .name = DRV_NAME_RTSX_USB_MS,
28 .pdata_size = 0,
29 },
30 };
31
32 static void rtsx_usb_sg_timed_out(struct timer_list *t)
33 {
34 struct rtsx_ucr *ucr = from_timer(ucr, t, sg_timer);
35
36 dev_dbg(&ucr->pusb_intf->dev, "%s: sg transfer timed out", __func__);
37 usb_sg_cancel(&ucr->current_sg);
38 }
39
40 static int rtsx_usb_bulk_transfer_sglist(struct rtsx_ucr *ucr,
41 unsigned int pipe, struct scatterlist *sg, int num_sg,
42 unsigned int length, unsigned int *act_len, int timeout)
43 {
44 int ret;
45
46 dev_dbg(&ucr->pusb_intf->dev, "%s: xfer %u bytes, %d entries\n",
47 __func__, length, num_sg);
48 ret = usb_sg_init(&ucr->current_sg, ucr->pusb_dev, pipe, 0,
49 sg, num_sg, length, GFP_NOIO);
50 if (ret)
51 return ret;
52
53 ucr->sg_timer.expires = jiffies + msecs_to_jiffies(timeout);
54 add_timer(&ucr->sg_timer);
55 usb_sg_wait(&ucr->current_sg);
56 if (!del_timer_sync(&ucr->sg_timer))
57 ret = -ETIMEDOUT;
58 else
59 ret = ucr->current_sg.status;
60
61 if (act_len)
62 *act_len = ucr->current_sg.bytes;
63
64 return ret;
65 }
66
67 int rtsx_usb_transfer_data(struct rtsx_ucr *ucr, unsigned int pipe,
68 void *buf, unsigned int len, int num_sg,
69 unsigned int *act_len, int timeout)
70 {
71 if (timeout < 600)
72 timeout = 600;
73
74 if (num_sg)
75 return rtsx_usb_bulk_transfer_sglist(ucr, pipe,
76 (struct scatterlist *)buf, num_sg, len, act_len,
77 timeout);
78 else
79 return usb_bulk_msg(ucr->pusb_dev, pipe, buf, len, act_len,
80 timeout);
81 }
82 EXPORT_SYMBOL_GPL(rtsx_usb_transfer_data);
83
84 static inline void rtsx_usb_seq_cmd_hdr(struct rtsx_ucr *ucr,
85 u16 addr, u16 len, u8 seq_type)
86 {
87 rtsx_usb_cmd_hdr_tag(ucr);
88
89 ucr->cmd_buf[PACKET_TYPE] = seq_type;
90 ucr->cmd_buf[5] = (u8)(len >> 8);
91 ucr->cmd_buf[6] = (u8)len;
92 ucr->cmd_buf[8] = (u8)(addr >> 8);
93 ucr->cmd_buf[9] = (u8)addr;
94
95 if (seq_type == SEQ_WRITE)
96 ucr->cmd_buf[STAGE_FLAG] = 0;
97 else
98 ucr->cmd_buf[STAGE_FLAG] = STAGE_R;
99 }
100
101 static int rtsx_usb_seq_write_register(struct rtsx_ucr *ucr,
102 u16 addr, u16 len, u8 *data)
103 {
104 u16 cmd_len = ALIGN(SEQ_WRITE_DATA_OFFSET + len, 4);
105
106 if (!data)
107 return -EINVAL;
108
109 if (cmd_len > IOBUF_SIZE)
110 return -EINVAL;
111
112 rtsx_usb_seq_cmd_hdr(ucr, addr, len, SEQ_WRITE);
113 memcpy(ucr->cmd_buf + SEQ_WRITE_DATA_OFFSET, data, len);
114
115 return rtsx_usb_transfer_data(ucr,
116 usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
117 ucr->cmd_buf, cmd_len, 0, NULL, 100);
118 }
119
120 static int rtsx_usb_seq_read_register(struct rtsx_ucr *ucr,
121 u16 addr, u16 len, u8 *data)
122 {
123 int i, ret;
124 u16 rsp_len = round_down(len, 4);
125 u16 res_len = len - rsp_len;
126
127 if (!data)
128 return -EINVAL;
129
130 /* 4-byte aligned part */
131 if (rsp_len) {
132 rtsx_usb_seq_cmd_hdr(ucr, addr, len, SEQ_READ);
133 ret = rtsx_usb_transfer_data(ucr,
134 usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
135 ucr->cmd_buf, 12, 0, NULL, 100);
136 if (ret)
137 return ret;
138
139 ret = rtsx_usb_transfer_data(ucr,
140 usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN),
141 data, rsp_len, 0, NULL, 100);
142 if (ret)
143 return ret;
144 }
145
146 /* unaligned part */
147 for (i = 0; i < res_len; i++) {
148 ret = rtsx_usb_read_register(ucr, addr + rsp_len + i,
149 data + rsp_len + i);
150 if (ret)
151 return ret;
152 }
153
154 return 0;
155 }
156
157 int rtsx_usb_read_ppbuf(struct rtsx_ucr *ucr, u8 *buf, int buf_len)
158 {
159 return rtsx_usb_seq_read_register(ucr, PPBUF_BASE2, (u16)buf_len, buf);
160 }
161 EXPORT_SYMBOL_GPL(rtsx_usb_read_ppbuf);
162
163 int rtsx_usb_write_ppbuf(struct rtsx_ucr *ucr, u8 *buf, int buf_len)
164 {
165 return rtsx_usb_seq_write_register(ucr, PPBUF_BASE2, (u16)buf_len, buf);
166 }
167 EXPORT_SYMBOL_GPL(rtsx_usb_write_ppbuf);
168
169 int rtsx_usb_ep0_write_register(struct rtsx_ucr *ucr, u16 addr,
170 u8 mask, u8 data)
171 {
172 u16 value, index;
173
174 addr |= EP0_WRITE_REG_CMD << EP0_OP_SHIFT;
175 value = swab16(addr);
176 index = mask | data << 8;
177
178 return usb_control_msg(ucr->pusb_dev,
179 usb_sndctrlpipe(ucr->pusb_dev, 0), RTSX_USB_REQ_REG_OP,
180 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
181 value, index, NULL, 0, 100);
182 }
183 EXPORT_SYMBOL_GPL(rtsx_usb_ep0_write_register);
184
185 int rtsx_usb_ep0_read_register(struct rtsx_ucr *ucr, u16 addr, u8 *data)
186 {
187 u16 value;
188 u8 *buf;
189 int ret;
190
191 if (!data)
192 return -EINVAL;
193
194 buf = kzalloc(sizeof(u8), GFP_KERNEL);
195 if (!buf)
196 return -ENOMEM;
197
198 addr |= EP0_READ_REG_CMD << EP0_OP_SHIFT;
199 value = swab16(addr);
200
201 ret = usb_control_msg(ucr->pusb_dev,
202 usb_rcvctrlpipe(ucr->pusb_dev, 0), RTSX_USB_REQ_REG_OP,
203 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
204 value, 0, buf, 1, 100);
205 *data = *buf;
206
207 kfree(buf);
208 return ret;
209 }
210 EXPORT_SYMBOL_GPL(rtsx_usb_ep0_read_register);
211
212 void rtsx_usb_add_cmd(struct rtsx_ucr *ucr, u8 cmd_type, u16 reg_addr,
213 u8 mask, u8 data)
214 {
215 int i;
216
217 if (ucr->cmd_idx < (IOBUF_SIZE - CMD_OFFSET) / 4) {
218 i = CMD_OFFSET + ucr->cmd_idx * 4;
219
220 ucr->cmd_buf[i++] = ((cmd_type & 0x03) << 6) |
221 (u8)((reg_addr >> 8) & 0x3F);
222 ucr->cmd_buf[i++] = (u8)reg_addr;
223 ucr->cmd_buf[i++] = mask;
224 ucr->cmd_buf[i++] = data;
225
226 ucr->cmd_idx++;
227 }
228 }
229 EXPORT_SYMBOL_GPL(rtsx_usb_add_cmd);
230
231 int rtsx_usb_send_cmd(struct rtsx_ucr *ucr, u8 flag, int timeout)
232 {
233 int ret;
234
235 ucr->cmd_buf[CNT_H] = (u8)(ucr->cmd_idx >> 8);
236 ucr->cmd_buf[CNT_L] = (u8)(ucr->cmd_idx);
237 ucr->cmd_buf[STAGE_FLAG] = flag;
238
239 ret = rtsx_usb_transfer_data(ucr,
240 usb_sndbulkpipe(ucr->pusb_dev, EP_BULK_OUT),
241 ucr->cmd_buf, ucr->cmd_idx * 4 + CMD_OFFSET,
242 0, NULL, timeout);
243 if (ret) {
244 rtsx_usb_clear_fsm_err(ucr);
245 return ret;
246 }
247
248 return 0;
249 }
250 EXPORT_SYMBOL_GPL(rtsx_usb_send_cmd);
251
252 int rtsx_usb_get_rsp(struct rtsx_ucr *ucr, int rsp_len, int timeout)
253 {
254 if (rsp_len <= 0)
255 return -EINVAL;
256
257 rsp_len = ALIGN(rsp_len, 4);
258
259 return rtsx_usb_transfer_data(ucr,
260 usb_rcvbulkpipe(ucr->pusb_dev, EP_BULK_IN),
261 ucr->rsp_buf, rsp_len, 0, NULL, timeout);
262 }
263 EXPORT_SYMBOL_GPL(rtsx_usb_get_rsp);
264
265 static int rtsx_usb_get_status_with_bulk(struct rtsx_ucr *ucr, u16 *status)
266 {
267 int ret;
268
269 rtsx_usb_init_cmd(ucr);
270 rtsx_usb_add_cmd(ucr, READ_REG_CMD, CARD_EXIST, 0x00, 0x00);
271 rtsx_usb_add_cmd(ucr, READ_REG_CMD, OCPSTAT, 0x00, 0x00);
272 ret = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
273 if (ret)
274 return ret;
275
276 ret = rtsx_usb_get_rsp(ucr, 2, 100);
277 if (ret)
278 return ret;
279
280 *status = ((ucr->rsp_buf[0] >> 2) & 0x0f) |
281 ((ucr->rsp_buf[1] & 0x03) << 4);
282
283 return 0;
284 }
285
286 int rtsx_usb_get_card_status(struct rtsx_ucr *ucr, u16 *status)
287 {
288 int ret;
289 u8 interrupt_val = 0;
290 u16 *buf;
291
292 if (!status)
293 return -EINVAL;
294
295 if (polling_pipe == 0) {
296 buf = kzalloc(sizeof(u16), GFP_KERNEL);
297 if (!buf)
298 return -ENOMEM;
299
300 ret = usb_control_msg(ucr->pusb_dev,
301 usb_rcvctrlpipe(ucr->pusb_dev, 0),
302 RTSX_USB_REQ_POLL,
303 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
304 0, 0, buf, 2, 100);
305 *status = *buf;
306
307 kfree(buf);
308 } else {
309 ret = rtsx_usb_get_status_with_bulk(ucr, status);
310 }
311
312 rtsx_usb_read_register(ucr, CARD_INT_PEND, &interrupt_val);
313 /* Cross check presence with interrupts */
314 if (*status & XD_CD)
315 if (!(interrupt_val & XD_INT))
316 *status &= ~XD_CD;
317
318 if (*status & SD_CD)
319 if (!(interrupt_val & SD_INT))
320 *status &= ~SD_CD;
321
322 if (*status & MS_CD)
323 if (!(interrupt_val & MS_INT))
324 *status &= ~MS_CD;
325
326 /* usb_control_msg may return positive when success */
327 if (ret < 0)
328 return ret;
329
330 return 0;
331 }
332 EXPORT_SYMBOL_GPL(rtsx_usb_get_card_status);
333
334 static int rtsx_usb_write_phy_register(struct rtsx_ucr *ucr, u8 addr, u8 val)
335 {
336 dev_dbg(&ucr->pusb_intf->dev, "Write 0x%x to phy register 0x%x\n",
337 val, addr);
338
339 rtsx_usb_init_cmd(ucr);
340
341 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VSTAIN, 0xFF, val);
342 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL, 0xFF, addr & 0x0F);
343 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
344 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
345 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
346 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL,
347 0xFF, (addr >> 4) & 0x0F);
348 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
349 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
350 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
351
352 return rtsx_usb_send_cmd(ucr, MODE_C, 100);
353 }
354
355 int rtsx_usb_write_register(struct rtsx_ucr *ucr, u16 addr, u8 mask, u8 data)
356 {
357 rtsx_usb_init_cmd(ucr);
358 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, addr, mask, data);
359 return rtsx_usb_send_cmd(ucr, MODE_C, 100);
360 }
361 EXPORT_SYMBOL_GPL(rtsx_usb_write_register);
362
363 int rtsx_usb_read_register(struct rtsx_ucr *ucr, u16 addr, u8 *data)
364 {
365 int ret;
366
367 if (data != NULL)
368 *data = 0;
369
370 rtsx_usb_init_cmd(ucr);
371 rtsx_usb_add_cmd(ucr, READ_REG_CMD, addr, 0, 0);
372 ret = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
373 if (ret)
374 return ret;
375
376 ret = rtsx_usb_get_rsp(ucr, 1, 100);
377 if (ret)
378 return ret;
379
380 if (data != NULL)
381 *data = ucr->rsp_buf[0];
382
383 return 0;
384 }
385 EXPORT_SYMBOL_GPL(rtsx_usb_read_register);
386
387 static inline u8 double_ssc_depth(u8 depth)
388 {
389 return (depth > 1) ? (depth - 1) : depth;
390 }
391
392 static u8 revise_ssc_depth(u8 ssc_depth, u8 div)
393 {
394 if (div > CLK_DIV_1) {
395 if (ssc_depth > div - 1)
396 ssc_depth -= (div - 1);
397 else
398 ssc_depth = SSC_DEPTH_2M;
399 }
400
401 return ssc_depth;
402 }
403
404 int rtsx_usb_switch_clock(struct rtsx_ucr *ucr, unsigned int card_clock,
405 u8 ssc_depth, bool initial_mode, bool double_clk, bool vpclk)
406 {
407 int ret;
408 u8 n, clk_divider, mcu_cnt, div;
409
410 if (!card_clock) {
411 ucr->cur_clk = 0;
412 return 0;
413 }
414
415 if (initial_mode) {
416 /* We use 250k(around) here, in initial stage */
417 clk_divider = SD_CLK_DIVIDE_128;
418 card_clock = 30000000;
419 } else {
420 clk_divider = SD_CLK_DIVIDE_0;
421 }
422
423 ret = rtsx_usb_write_register(ucr, SD_CFG1,
424 SD_CLK_DIVIDE_MASK, clk_divider);
425 if (ret < 0)
426 return ret;
427
428 card_clock /= 1000000;
429 dev_dbg(&ucr->pusb_intf->dev,
430 "Switch card clock to %dMHz\n", card_clock);
431
432 if (!initial_mode && double_clk)
433 card_clock *= 2;
434 dev_dbg(&ucr->pusb_intf->dev,
435 "Internal SSC clock: %dMHz (cur_clk = %d)\n",
436 card_clock, ucr->cur_clk);
437
438 if (card_clock == ucr->cur_clk)
439 return 0;
440
441 /* Converting clock value into internal settings: n and div */
442 n = card_clock - 2;
443 if ((card_clock <= 2) || (n > MAX_DIV_N))
444 return -EINVAL;
445
446 mcu_cnt = 60/card_clock + 3;
447 if (mcu_cnt > 15)
448 mcu_cnt = 15;
449
450 /* Make sure that the SSC clock div_n is not less than MIN_DIV_N */
451
452 div = CLK_DIV_1;
453 while (n < MIN_DIV_N && div < CLK_DIV_4) {
454 n = (n + 2) * 2 - 2;
455 div++;
456 }
457 dev_dbg(&ucr->pusb_intf->dev, "n = %d, div = %d\n", n, div);
458
459 if (double_clk)
460 ssc_depth = double_ssc_depth(ssc_depth);
461
462 ssc_depth = revise_ssc_depth(ssc_depth, div);
463 dev_dbg(&ucr->pusb_intf->dev, "ssc_depth = %d\n", ssc_depth);
464
465 rtsx_usb_init_cmd(ucr);
466 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV, CLK_CHANGE, CLK_CHANGE);
467 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV,
468 0x3F, (div << 4) | mcu_cnt);
469 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, 0);
470 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL2,
471 SSC_DEPTH_MASK, ssc_depth);
472 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_DIV_N_0, 0xFF, n);
473 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, SSC_RSTB);
474 if (vpclk) {
475 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
476 PHASE_NOT_RESET, 0);
477 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
478 PHASE_NOT_RESET, PHASE_NOT_RESET);
479 }
480
481 ret = rtsx_usb_send_cmd(ucr, MODE_C, 2000);
482 if (ret < 0)
483 return ret;
484
485 ret = rtsx_usb_write_register(ucr, SSC_CTL1, 0xff,
486 SSC_RSTB | SSC_8X_EN | SSC_SEL_4M);
487 if (ret < 0)
488 return ret;
489
490 /* Wait SSC clock stable */
491 usleep_range(100, 1000);
492
493 ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0);
494 if (ret < 0)
495 return ret;
496
497 ucr->cur_clk = card_clock;
498
499 return 0;
500 }
501 EXPORT_SYMBOL_GPL(rtsx_usb_switch_clock);
502
503 int rtsx_usb_card_exclusive_check(struct rtsx_ucr *ucr, int card)
504 {
505 int ret;
506 u16 val;
507 u16 cd_mask[] = {
508 [RTSX_USB_SD_CARD] = (CD_MASK & ~SD_CD),
509 [RTSX_USB_MS_CARD] = (CD_MASK & ~MS_CD)
510 };
511
512 ret = rtsx_usb_get_card_status(ucr, &val);
513 /*
514 * If get status fails, return 0 (ok) for the exclusive check
515 * and let the flow fail at somewhere else.
516 */
517 if (ret)
518 return 0;
519
520 if (val & cd_mask[card])
521 return -EIO;
522
523 return 0;
524 }
525 EXPORT_SYMBOL_GPL(rtsx_usb_card_exclusive_check);
526
527 static int rtsx_usb_reset_chip(struct rtsx_ucr *ucr)
528 {
529 int ret;
530 u8 val;
531
532 rtsx_usb_init_cmd(ucr);
533
534 if (CHECK_PKG(ucr, LQFP48)) {
535 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
536 LDO3318_PWR_MASK, LDO_SUSPEND);
537 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
538 FORCE_LDO_POWERB, FORCE_LDO_POWERB);
539 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1,
540 0x30, 0x10);
541 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5,
542 0x03, 0x01);
543 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6,
544 0x0C, 0x04);
545 }
546
547 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SYS_DUMMY0, NYET_MSAK, NYET_EN);
548 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CD_DEGLITCH_WIDTH, 0xFF, 0x08);
549 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
550 CD_DEGLITCH_EN, XD_CD_DEGLITCH_EN, 0x0);
551 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD30_DRIVE_SEL,
552 SD30_DRIVE_MASK, DRIVER_TYPE_D);
553 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
554 CARD_DRIVE_SEL, SD20_DRIVE_MASK, 0x0);
555 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, LDO_POWER_CFG, 0xE0, 0x0);
556
557 if (ucr->is_rts5179)
558 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
559 CARD_PULL_CTL5, 0x03, 0x01);
560
561 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DMA1_CTL,
562 EXTEND_DMA1_ASYNC_SIGNAL, EXTEND_DMA1_ASYNC_SIGNAL);
563 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_INT_PEND,
564 XD_INT | MS_INT | SD_INT,
565 XD_INT | MS_INT | SD_INT);
566
567 ret = rtsx_usb_send_cmd(ucr, MODE_C, 100);
568 if (ret)
569 return ret;
570
571 /* config non-crystal mode */
572 rtsx_usb_read_register(ucr, CFG_MODE, &val);
573 if ((val & XTAL_FREE) || ((val & CLK_MODE_MASK) == CLK_MODE_NON_XTAL)) {
574 ret = rtsx_usb_write_phy_register(ucr, 0xC2, 0x7C);
575 if (ret)
576 return ret;
577 }
578
579 return 0;
580 }
581
582 static int rtsx_usb_init_chip(struct rtsx_ucr *ucr)
583 {
584 int ret;
585 u8 val;
586
587 rtsx_usb_clear_fsm_err(ucr);
588
589 /* power on SSC */
590 ret = rtsx_usb_write_register(ucr,
591 FPDCTL, SSC_POWER_MASK, SSC_POWER_ON);
592 if (ret)
593 return ret;
594
595 usleep_range(100, 1000);
596 ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0x00);
597 if (ret)
598 return ret;
599
600 /* determine IC version */
601 ret = rtsx_usb_read_register(ucr, HW_VERSION, &val);
602 if (ret)
603 return ret;
604
605 ucr->ic_version = val & HW_VER_MASK;
606
607 /* determine package */
608 ret = rtsx_usb_read_register(ucr, CARD_SHARE_MODE, &val);
609 if (ret)
610 return ret;
611
612 if (val & CARD_SHARE_LQFP_SEL) {
613 ucr->package = LQFP48;
614 dev_dbg(&ucr->pusb_intf->dev, "Package: LQFP48\n");
615 } else {
616 ucr->package = QFN24;
617 dev_dbg(&ucr->pusb_intf->dev, "Package: QFN24\n");
618 }
619
620 /* determine IC variations */
621 rtsx_usb_read_register(ucr, CFG_MODE_1, &val);
622 if (val & RTS5179) {
623 ucr->is_rts5179 = true;
624 dev_dbg(&ucr->pusb_intf->dev, "Device is rts5179\n");
625 } else {
626 ucr->is_rts5179 = false;
627 }
628
629 return rtsx_usb_reset_chip(ucr);
630 }
631
632 static int rtsx_usb_probe(struct usb_interface *intf,
633 const struct usb_device_id *id)
634 {
635 struct usb_device *usb_dev = interface_to_usbdev(intf);
636 struct rtsx_ucr *ucr;
637 int ret;
638
639 dev_dbg(&intf->dev,
640 ": Realtek USB Card Reader found at bus %03d address %03d\n",
641 usb_dev->bus->busnum, usb_dev->devnum);
642
643 ucr = devm_kzalloc(&intf->dev, sizeof(*ucr), GFP_KERNEL);
644 if (!ucr)
645 return -ENOMEM;
646
647 ucr->pusb_dev = usb_dev;
648
649 ucr->cmd_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
650 if (!ucr->cmd_buf)
651 return -ENOMEM;
652
653 ucr->rsp_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
654 if (!ucr->rsp_buf) {
655 ret = -ENOMEM;
656 goto out_free_cmd_buf;
657 }
658
659 usb_set_intfdata(intf, ucr);
660
661 ucr->vendor_id = id->idVendor;
662 ucr->product_id = id->idProduct;
663
664 mutex_init(&ucr->dev_mutex);
665
666 ucr->pusb_intf = intf;
667
668 /* initialize */
669 ret = rtsx_usb_init_chip(ucr);
670 if (ret)
671 goto out_init_fail;
672
673 /* initialize USB SG transfer timer */
674 timer_setup(&ucr->sg_timer, rtsx_usb_sg_timed_out, 0);
675
676 ret = mfd_add_hotplug_devices(&intf->dev, rtsx_usb_cells,
677 ARRAY_SIZE(rtsx_usb_cells));
678 if (ret)
679 goto out_init_fail;
680
681 #ifdef CONFIG_PM
682 intf->needs_remote_wakeup = 1;
683 usb_enable_autosuspend(usb_dev);
684 #endif
685
686 return 0;
687
688 out_init_fail:
689 usb_set_intfdata(ucr->pusb_intf, NULL);
690 kfree(ucr->rsp_buf);
691 ucr->rsp_buf = NULL;
692 out_free_cmd_buf:
693 kfree(ucr->cmd_buf);
694 ucr->cmd_buf = NULL;
695 return ret;
696 }
697
698 static void rtsx_usb_disconnect(struct usb_interface *intf)
699 {
700 struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
701
702 dev_dbg(&intf->dev, "%s called\n", __func__);
703
704 mfd_remove_devices(&intf->dev);
705
706 usb_set_intfdata(ucr->pusb_intf, NULL);
707
708 kfree(ucr->cmd_buf);
709 ucr->cmd_buf = NULL;
710
711 kfree(ucr->rsp_buf);
712 ucr->rsp_buf = NULL;
713 }
714
715 #ifdef CONFIG_PM
716 static int rtsx_usb_suspend(struct usb_interface *intf, pm_message_t message)
717 {
718 struct rtsx_ucr *ucr =
719 (struct rtsx_ucr *)usb_get_intfdata(intf);
720 u16 val = 0;
721
722 dev_dbg(&intf->dev, "%s called with pm message 0x%04x\n",
723 __func__, message.event);
724
725 if (PMSG_IS_AUTO(message)) {
726 if (mutex_trylock(&ucr->dev_mutex)) {
727 rtsx_usb_get_card_status(ucr, &val);
728 mutex_unlock(&ucr->dev_mutex);
729
730 /* Defer the autosuspend if card exists */
731 if (val & (SD_CD | MS_CD))
732 return -EAGAIN;
733 } else {
734 /* There is an ongoing operation*/
735 return -EAGAIN;
736 }
737 }
738
739 return 0;
740 }
741
742 static int rtsx_usb_resume_child(struct device *dev, void *data)
743 {
744 pm_request_resume(dev);
745 return 0;
746 }
747
748 static int rtsx_usb_resume(struct usb_interface *intf)
749 {
750 device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
751 return 0;
752 }
753
754 static int rtsx_usb_reset_resume(struct usb_interface *intf)
755 {
756 struct rtsx_ucr *ucr =
757 (struct rtsx_ucr *)usb_get_intfdata(intf);
758
759 rtsx_usb_reset_chip(ucr);
760 device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
761 return 0;
762 }
763
764 #else /* CONFIG_PM */
765
766 #define rtsx_usb_suspend NULL
767 #define rtsx_usb_resume NULL
768 #define rtsx_usb_reset_resume NULL
769
770 #endif /* CONFIG_PM */
771
772
773 static int rtsx_usb_pre_reset(struct usb_interface *intf)
774 {
775 struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
776
777 mutex_lock(&ucr->dev_mutex);
778 return 0;
779 }
780
781 static int rtsx_usb_post_reset(struct usb_interface *intf)
782 {
783 struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
784
785 mutex_unlock(&ucr->dev_mutex);
786 return 0;
787 }
788
789 static const struct usb_device_id rtsx_usb_usb_ids[] = {
790 { USB_DEVICE(0x0BDA, 0x0129) },
791 { USB_DEVICE(0x0BDA, 0x0139) },
792 { USB_DEVICE(0x0BDA, 0x0140) },
793 { }
794 };
795 MODULE_DEVICE_TABLE(usb, rtsx_usb_usb_ids);
796
797 static struct usb_driver rtsx_usb_driver = {
798 .name = DRV_NAME_RTSX_USB,
799 .probe = rtsx_usb_probe,
800 .disconnect = rtsx_usb_disconnect,
801 .suspend = rtsx_usb_suspend,
802 .resume = rtsx_usb_resume,
803 .reset_resume = rtsx_usb_reset_resume,
804 .pre_reset = rtsx_usb_pre_reset,
805 .post_reset = rtsx_usb_post_reset,
806 .id_table = rtsx_usb_usb_ids,
807 .supports_autosuspend = 1,
808 .soft_unbind = 1,
809 };
810
811 module_usb_driver(rtsx_usb_driver);
812
813 MODULE_LICENSE("GPL v2");
814 MODULE_AUTHOR("Roger Tseng <rogerable@realtek.com>");
815 MODULE_DESCRIPTION("Realtek USB Card Reader Driver");
Linux Kernel