rtsx_usb.c 18 KB

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