drivers/misc/cardreader/rtsx_usb.c

   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 <[email protected]>
   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 = "rtsx_usb_sdmmc",
  24                 .pdata_size = 0,
  25         },
  26         [RTSX_USB_MS_CARD] = {
  27                 .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         u16 *buf;
 290
 291         if (!status)
 292                 return -EINVAL;
 293
 294         if (polling_pipe == 0) {
 295                 buf = kzalloc(sizeof(u16), GFP_KERNEL);
 296                 if (!buf)
 297                         return -ENOMEM;
 298
 299                 ret = usb_control_msg(ucr->pusb_dev,
 300                                 usb_rcvctrlpipe(ucr->pusb_dev, 0),
 301                                 RTSX_USB_REQ_POLL,
 302                                 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 303                                 0, 0, buf, 2, 100);
 304                 *status = *buf;
 305
 306                 kfree(buf);
 307         } else {
 308                 ret = rtsx_usb_get_status_with_bulk(ucr, status);
 309         }
 310
 311         /* usb_control_msg may return positive when success */
 312         if (ret < 0)
 313                 return ret;
 314
 315         return 0;
 316 }
 317 EXPORT_SYMBOL_GPL(rtsx_usb_get_card_status);
 318
 319 static int rtsx_usb_write_phy_register(struct rtsx_ucr *ucr, u8 addr, u8 val)
 320 {
 321         dev_dbg(&ucr->pusb_intf->dev, "Write 0x%x to phy register 0x%x\n",
 322                         val, addr);
 323
 324         rtsx_usb_init_cmd(ucr);
 325
 326         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VSTAIN, 0xFF, val);
 327         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL, 0xFF, addr & 0x0F);
 328         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
 329         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
 330         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
 331         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VCONTROL,
 332                         0xFF, (addr >> 4) & 0x0F);
 333         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
 334         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x00);
 335         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, HS_VLOADM, 0xFF, 0x01);
 336
 337         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 338 }
 339
 340 int rtsx_usb_write_register(struct rtsx_ucr *ucr, u16 addr, u8 mask, u8 data)
 341 {
 342         rtsx_usb_init_cmd(ucr);
 343         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, addr, mask, data);
 344         return rtsx_usb_send_cmd(ucr, MODE_C, 100);
 345 }
 346 EXPORT_SYMBOL_GPL(rtsx_usb_write_register);
 347
 348 int rtsx_usb_read_register(struct rtsx_ucr *ucr, u16 addr, u8 *data)
 349 {
 350         int ret;
 351
 352         if (data != NULL)
 353                 *data = 0;
 354
 355         rtsx_usb_init_cmd(ucr);
 356         rtsx_usb_add_cmd(ucr, READ_REG_CMD, addr, 0, 0);
 357         ret = rtsx_usb_send_cmd(ucr, MODE_CR, 100);
 358         if (ret)
 359                 return ret;
 360
 361         ret = rtsx_usb_get_rsp(ucr, 1, 100);
 362         if (ret)
 363                 return ret;
 364
 365         if (data != NULL)
 366                 *data = ucr->rsp_buf[0];
 367
 368         return 0;
 369 }
 370 EXPORT_SYMBOL_GPL(rtsx_usb_read_register);
 371
 372 static inline u8 double_ssc_depth(u8 depth)
 373 {
 374         return (depth > 1) ? (depth - 1) : depth;
 375 }
 376
 377 static u8 revise_ssc_depth(u8 ssc_depth, u8 div)
 378 {
 379         if (div > CLK_DIV_1) {
 380                 if (ssc_depth > div - 1)
 381                         ssc_depth -= (div - 1);
 382                 else
 383                         ssc_depth = SSC_DEPTH_2M;
 384         }
 385
 386         return ssc_depth;
 387 }
 388
 389 int rtsx_usb_switch_clock(struct rtsx_ucr *ucr, unsigned int card_clock,
 390                 u8 ssc_depth, bool initial_mode, bool double_clk, bool vpclk)
 391 {
 392         int ret;
 393         u8 n, clk_divider, mcu_cnt, div;
 394
 395         if (!card_clock) {
 396                 ucr->cur_clk = 0;
 397                 return 0;
 398         }
 399
 400         if (initial_mode) {
 401                 /* We use 250k(around) here, in initial stage */
 402                 clk_divider = SD_CLK_DIVIDE_128;
 403                 card_clock = 30000000;
 404         } else {
 405                 clk_divider = SD_CLK_DIVIDE_0;
 406         }
 407
 408         ret = rtsx_usb_write_register(ucr, SD_CFG1,
 409                         SD_CLK_DIVIDE_MASK, clk_divider);
 410         if (ret < 0)
 411                 return ret;
 412
 413         card_clock /= 1000000;
 414         dev_dbg(&ucr->pusb_intf->dev,
 415                         "Switch card clock to %dMHz\n", card_clock);
 416
 417         if (!initial_mode && double_clk)
 418                 card_clock *= 2;
 419         dev_dbg(&ucr->pusb_intf->dev,
 420                         "Internal SSC clock: %dMHz (cur_clk = %d)\n",
 421                         card_clock, ucr->cur_clk);
 422
 423         if (card_clock == ucr->cur_clk)
 424                 return 0;
 425
 426         /* Converting clock value into internal settings: n and div */
 427         n = card_clock - 2;
 428         if ((card_clock <= 2) || (n > MAX_DIV_N))
 429                 return -EINVAL;
 430
 431         mcu_cnt = 60/card_clock + 3;
 432         if (mcu_cnt > 15)
 433                 mcu_cnt = 15;
 434
 435         /* Make sure that the SSC clock div_n is not less than MIN_DIV_N */
 436
 437         div = CLK_DIV_1;
 438         while (n < MIN_DIV_N && div < CLK_DIV_4) {
 439                 n = (n + 2) * 2 - 2;
 440                 div++;
 441         }
 442         dev_dbg(&ucr->pusb_intf->dev, "n = %d, div = %d\n", n, div);
 443
 444         if (double_clk)
 445                 ssc_depth = double_ssc_depth(ssc_depth);
 446
 447         ssc_depth = revise_ssc_depth(ssc_depth, div);
 448         dev_dbg(&ucr->pusb_intf->dev, "ssc_depth = %d\n", ssc_depth);
 449
 450         rtsx_usb_init_cmd(ucr);
 451         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV, CLK_CHANGE, CLK_CHANGE);
 452         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CLK_DIV,
 453                         0x3F, (div << 4) | mcu_cnt);
 454         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, 0);
 455         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL2,
 456                         SSC_DEPTH_MASK, ssc_depth);
 457         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_DIV_N_0, 0xFF, n);
 458         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SSC_CTL1, SSC_RSTB, SSC_RSTB);
 459         if (vpclk) {
 460                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
 461                                 PHASE_NOT_RESET, 0);
 462                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD_VPCLK0_CTL,
 463                                 PHASE_NOT_RESET, PHASE_NOT_RESET);
 464         }
 465
 466         ret = rtsx_usb_send_cmd(ucr, MODE_C, 2000);
 467         if (ret < 0)
 468                 return ret;
 469
 470         ret = rtsx_usb_write_register(ucr, SSC_CTL1, 0xff,
 471                         SSC_RSTB | SSC_8X_EN | SSC_SEL_4M);
 472         if (ret < 0)
 473                 return ret;
 474
 475         /* Wait SSC clock stable */
 476         usleep_range(100, 1000);
 477
 478         ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0);
 479         if (ret < 0)
 480                 return ret;
 481
 482         ucr->cur_clk = card_clock;
 483
 484         return 0;
 485 }
 486 EXPORT_SYMBOL_GPL(rtsx_usb_switch_clock);
 487
 488 int rtsx_usb_card_exclusive_check(struct rtsx_ucr *ucr, int card)
 489 {
 490         int ret;
 491         u16 val;
 492         u16 cd_mask[] = {
 493                 [RTSX_USB_SD_CARD] = (CD_MASK & ~SD_CD),
 494                 [RTSX_USB_MS_CARD] = (CD_MASK & ~MS_CD)
 495         };
 496
 497         ret = rtsx_usb_get_card_status(ucr, &val);
 498         /*
 499          * If get status fails, return 0 (ok) for the exclusive check
 500          * and let the flow fail at somewhere else.
 501          */
 502         if (ret)
 503                 return 0;
 504
 505         if (val & cd_mask[card])
 506                 return -EIO;
 507
 508         return 0;
 509 }
 510 EXPORT_SYMBOL_GPL(rtsx_usb_card_exclusive_check);
 511
 512 static int rtsx_usb_reset_chip(struct rtsx_ucr *ucr)
 513 {
 514         int ret;
 515         u8 val;
 516
 517         rtsx_usb_init_cmd(ucr);
 518
 519         if (CHECK_PKG(ucr, LQFP48)) {
 520                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
 521                                 LDO3318_PWR_MASK, LDO_SUSPEND);
 522                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PWR_CTL,
 523                                 FORCE_LDO_POWERB, FORCE_LDO_POWERB);
 524                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL1,
 525                                 0x30, 0x10);
 526                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL5,
 527                                 0x03, 0x01);
 528                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_PULL_CTL6,
 529                                 0x0C, 0x04);
 530         }
 531
 532         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SYS_DUMMY0, NYET_MSAK, NYET_EN);
 533         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CD_DEGLITCH_WIDTH, 0xFF, 0x08);
 534         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
 535                         CD_DEGLITCH_EN, XD_CD_DEGLITCH_EN, 0x0);
 536         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, SD30_DRIVE_SEL,
 537                         SD30_DRIVE_MASK, DRIVER_TYPE_D);
 538         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
 539                         CARD_DRIVE_SEL, SD20_DRIVE_MASK, 0x0);
 540         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, LDO_POWER_CFG, 0xE0, 0x0);
 541
 542         if (ucr->is_rts5179)
 543                 rtsx_usb_add_cmd(ucr, WRITE_REG_CMD,
 544                                 CARD_PULL_CTL5, 0x03, 0x01);
 545
 546         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_DMA1_CTL,
 547                        EXTEND_DMA1_ASYNC_SIGNAL, EXTEND_DMA1_ASYNC_SIGNAL);
 548         rtsx_usb_add_cmd(ucr, WRITE_REG_CMD, CARD_INT_PEND,
 549                         XD_INT | MS_INT | SD_INT,
 550                         XD_INT | MS_INT | SD_INT);
 551
 552         ret = rtsx_usb_send_cmd(ucr, MODE_C, 100);
 553         if (ret)
 554                 return ret;
 555
 556         /* config non-crystal mode */
 557         rtsx_usb_read_register(ucr, CFG_MODE, &val);
 558         if ((val & XTAL_FREE) || ((val & CLK_MODE_MASK) == CLK_MODE_NON_XTAL)) {
 559                 ret = rtsx_usb_write_phy_register(ucr, 0xC2, 0x7C);
 560                 if (ret)
 561                         return ret;
 562         }
 563
 564         return 0;
 565 }
 566
 567 static int rtsx_usb_init_chip(struct rtsx_ucr *ucr)
 568 {
 569         int ret;
 570         u8 val;
 571
 572         rtsx_usb_clear_fsm_err(ucr);
 573
 574         /* power on SSC */
 575         ret = rtsx_usb_write_register(ucr,
 576                         FPDCTL, SSC_POWER_MASK, SSC_POWER_ON);
 577         if (ret)
 578                 return ret;
 579
 580         usleep_range(100, 1000);
 581         ret = rtsx_usb_write_register(ucr, CLK_DIV, CLK_CHANGE, 0x00);
 582         if (ret)
 583                 return ret;
 584
 585         /* determine IC version */
 586         ret = rtsx_usb_read_register(ucr, HW_VERSION, &val);
 587         if (ret)
 588                 return ret;
 589
 590         ucr->ic_version = val & HW_VER_MASK;
 591
 592         /* determine package */
 593         ret = rtsx_usb_read_register(ucr, CARD_SHARE_MODE, &val);
 594         if (ret)
 595                 return ret;
 596
 597         if (val & CARD_SHARE_LQFP_SEL) {
 598                 ucr->package = LQFP48;
 599                 dev_dbg(&ucr->pusb_intf->dev, "Package: LQFP48\n");
 600         } else {
 601                 ucr->package = QFN24;
 602                 dev_dbg(&ucr->pusb_intf->dev, "Package: QFN24\n");
 603         }
 604
 605         /* determine IC variations */
 606         rtsx_usb_read_register(ucr, CFG_MODE_1, &val);
 607         if (val & RTS5179) {
 608                 ucr->is_rts5179 = true;
 609                 dev_dbg(&ucr->pusb_intf->dev, "Device is rts5179\n");
 610         } else {
 611                 ucr->is_rts5179 = false;
 612         }
 613
 614         return rtsx_usb_reset_chip(ucr);
 615 }
 616
 617 static int rtsx_usb_probe(struct usb_interface *intf,
 618                          const struct usb_device_id *id)
 619 {
 620         struct usb_device *usb_dev = interface_to_usbdev(intf);
 621         struct rtsx_ucr *ucr;
 622         int ret;
 623
 624         dev_dbg(&intf->dev,
 625                 ": Realtek USB Card Reader found at bus %03d address %03d\n",
 626                  usb_dev->bus->busnum, usb_dev->devnum);
 627
 628         ucr = devm_kzalloc(&intf->dev, sizeof(*ucr), GFP_KERNEL);
 629         if (!ucr)
 630                 return -ENOMEM;
 631
 632         ucr->pusb_dev = usb_dev;
 633
 634         ucr->cmd_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
 635         if (!ucr->cmd_buf)
 636                 return -ENOMEM;
 637
 638         ucr->rsp_buf = kmalloc(IOBUF_SIZE, GFP_KERNEL);
 639         if (!ucr->rsp_buf) {
 640                 ret = -ENOMEM;
 641                 goto out_free_cmd_buf;
 642         }
 643
 644         usb_set_intfdata(intf, ucr);
 645
 646         ucr->vendor_id = id->idVendor;
 647         ucr->product_id = id->idProduct;
 648
 649         mutex_init(&ucr->dev_mutex);
 650
 651         ucr->pusb_intf = intf;
 652
 653         /* initialize */
 654         ret = rtsx_usb_init_chip(ucr);
 655         if (ret)
 656                 goto out_init_fail;
 657
 658         /* initialize USB SG transfer timer */
 659         timer_setup(&ucr->sg_timer, rtsx_usb_sg_timed_out, 0);
 660
 661         ret = mfd_add_hotplug_devices(&intf->dev, rtsx_usb_cells,
 662                                       ARRAY_SIZE(rtsx_usb_cells));
 663         if (ret)
 664                 goto out_init_fail;
 665
 666 #ifdef CONFIG_PM
 667         intf->needs_remote_wakeup = 1;
 668         usb_enable_autosuspend(usb_dev);
 669 #endif
 670
 671         return 0;
 672
 673 out_init_fail:
 674         usb_set_intfdata(ucr->pusb_intf, NULL);
 675         kfree(ucr->rsp_buf);
 676         ucr->rsp_buf = NULL;
 677 out_free_cmd_buf:
 678         kfree(ucr->cmd_buf);
 679         ucr->cmd_buf = NULL;
 680         return ret;
 681 }
 682
 683 static void rtsx_usb_disconnect(struct usb_interface *intf)
 684 {
 685         struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
 686
 687         dev_dbg(&intf->dev, "%s called\n", __func__);
 688
 689         mfd_remove_devices(&intf->dev);
 690
 691         usb_set_intfdata(ucr->pusb_intf, NULL);
 692
 693         kfree(ucr->cmd_buf);
 694         ucr->cmd_buf = NULL;
 695
 696         kfree(ucr->rsp_buf);
 697         ucr->rsp_buf = NULL;
 698 }
 699
 700 #ifdef CONFIG_PM
 701 static int rtsx_usb_suspend(struct usb_interface *intf, pm_message_t message)
 702 {
 703         struct rtsx_ucr *ucr =
 704                 (struct rtsx_ucr *)usb_get_intfdata(intf);
 705         u16 val = 0;
 706
 707         dev_dbg(&intf->dev, "%s called with pm message 0x%04x\n",
 708                         __func__, message.event);
 709
 710         if (PMSG_IS_AUTO(message)) {
 711                 if (mutex_trylock(&ucr->dev_mutex)) {
 712                         rtsx_usb_get_card_status(ucr, &val);
 713                         mutex_unlock(&ucr->dev_mutex);
 714
 715                         /* Defer the autosuspend if card exists */
 716                         if (val & (SD_CD | MS_CD))
 717                                 return -EAGAIN;
 718                 } else {
 719                         /* There is an ongoing operation*/
 720                         return -EAGAIN;
 721                 }
 722         }
 723
 724         return 0;
 725 }
 726
 727 static int rtsx_usb_resume_child(struct device *dev, void *data)
 728 {
 729         pm_request_resume(dev);
 730         return 0;
 731 }
 732
 733 static int rtsx_usb_resume(struct usb_interface *intf)
 734 {
 735         device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
 736         return 0;
 737 }
 738
 739 static int rtsx_usb_reset_resume(struct usb_interface *intf)
 740 {
 741         struct rtsx_ucr *ucr =
 742                 (struct rtsx_ucr *)usb_get_intfdata(intf);
 743
 744         rtsx_usb_reset_chip(ucr);
 745         device_for_each_child(&intf->dev, NULL, rtsx_usb_resume_child);
 746         return 0;
 747 }
 748
 749 #else /* CONFIG_PM */
 750
 751 #define rtsx_usb_suspend NULL
 752 #define rtsx_usb_resume NULL
 753 #define rtsx_usb_reset_resume NULL
 754
 755 #endif /* CONFIG_PM */
 756
 757
 758 static int rtsx_usb_pre_reset(struct usb_interface *intf)
 759 {
 760         struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
 761
 762         mutex_lock(&ucr->dev_mutex);
 763         return 0;
 764 }
 765
 766 static int rtsx_usb_post_reset(struct usb_interface *intf)
 767 {
 768         struct rtsx_ucr *ucr = (struct rtsx_ucr *)usb_get_intfdata(intf);
 769
 770         mutex_unlock(&ucr->dev_mutex);
 771         return 0;
 772 }
 773
 774 static const struct usb_device_id rtsx_usb_usb_ids[] = {
 775         { USB_DEVICE(0x0BDA, 0x0129) },
 776         { USB_DEVICE(0x0BDA, 0x0139) },
 777         { USB_DEVICE(0x0BDA, 0x0140) },
 778         { }
 779 };
 780 MODULE_DEVICE_TABLE(usb, rtsx_usb_usb_ids);
 781
 782 static struct usb_driver rtsx_usb_driver = {
 783         .name                   = "rtsx_usb",
 784         .probe                  = rtsx_usb_probe,
 785         .disconnect             = rtsx_usb_disconnect,
 786         .suspend                = rtsx_usb_suspend,
 787         .resume                 = rtsx_usb_resume,
 788         .reset_resume           = rtsx_usb_reset_resume,
 789         .pre_reset              = rtsx_usb_pre_reset,
 790         .post_reset             = rtsx_usb_post_reset,
 791         .id_table               = rtsx_usb_usb_ids,
 792         .supports_autosuspend   = 1,
 793         .soft_unbind            = 1,
 794 };
 795
 796 module_usb_driver(rtsx_usb_driver);
 797
 798 MODULE_LICENSE("GPL v2");
 799 MODULE_AUTHOR("Roger Tseng <[email protected]>");
 800 MODULE_DESCRIPTION("Realtek USB Card Reader Driver");