w83l518d_sdmmc.c revision 1.2
1 /* $NetBSD: w83l518d_sdmmc.c,v 1.2 2010/08/19 14:58:22 jmcneill Exp $ */ 2 3 /* 4 * Copyright (c) 2009 Jared D. McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __KERNEL_RCSID(0, "$NetBSD: w83l518d_sdmmc.c,v 1.2 2010/08/19 14:58:22 jmcneill Exp $"); 30 31 #include <sys/param.h> 32 #include <sys/kernel.h> 33 #include <sys/systm.h> 34 #include <sys/errno.h> 35 #include <sys/ioctl.h> 36 #include <sys/syslog.h> 37 #include <sys/device.h> 38 #include <sys/proc.h> 39 40 #include <sys/bus.h> 41 42 #include <dev/sdmmc/sdmmcvar.h> 43 #include <dev/sdmmc/sdmmcchip.h> 44 #include <dev/sdmmc/sdmmc_ioreg.h> 45 46 #include <dev/isa/isavar.h> 47 #include <dev/isa/isadmavar.h> 48 49 #include <dev/ic/w83l518dreg.h> 50 #include <dev/ic/w83l518dvar.h> 51 #include <dev/ic/w83l518d_sdmmc.h> 52 53 /* #define WB_SDMMC_DEBUG */ 54 55 #ifdef WB_SDMMC_DEBUG 56 static int wb_sdmmc_debug = 1; 57 #else 58 static int wb_sdmmc_debug = 0; 59 #endif 60 61 #if defined(__NetBSD__) && __NetBSD_Version__ < 599000600 62 #define snprintb(b, l, f, v) bitmask_snprintf((v), (f), (b), (l)) 63 #endif 64 65 #define REPORT(_wb, ...) \ 66 if (wb_sdmmc_debug > 0) \ 67 aprint_normal_dev(((struct wb_softc *)(_wb))->wb_dev, \ 68 __VA_ARGS__) 69 70 static int wb_sdmmc_host_reset(sdmmc_chipset_handle_t); 71 static uint32_t wb_sdmmc_host_ocr(sdmmc_chipset_handle_t); 72 static int wb_sdmmc_host_maxblklen(sdmmc_chipset_handle_t); 73 static int wb_sdmmc_card_detect(sdmmc_chipset_handle_t); 74 static int wb_sdmmc_write_protect(sdmmc_chipset_handle_t); 75 static int wb_sdmmc_bus_power(sdmmc_chipset_handle_t, uint32_t); 76 static int wb_sdmmc_bus_clock(sdmmc_chipset_handle_t, int); 77 static int wb_sdmmc_bus_width(sdmmc_chipset_handle_t, int); 78 static void wb_sdmmc_exec_command(sdmmc_chipset_handle_t, 79 struct sdmmc_command *); 80 static void wb_sdmmc_card_enable_intr(sdmmc_chipset_handle_t, int); 81 static void wb_sdmmc_card_intr_ack(sdmmc_chipset_handle_t); 82 83 static struct sdmmc_chip_functions wb_sdmmc_chip_functions = { 84 .host_reset = wb_sdmmc_host_reset, 85 .host_ocr = wb_sdmmc_host_ocr, 86 .host_maxblklen = wb_sdmmc_host_maxblklen, 87 .card_detect = wb_sdmmc_card_detect, 88 .write_protect = wb_sdmmc_write_protect, 89 .bus_power = wb_sdmmc_bus_power, 90 .bus_clock = wb_sdmmc_bus_clock, 91 .bus_width = wb_sdmmc_bus_width, 92 .exec_command = wb_sdmmc_exec_command, 93 .card_enable_intr = wb_sdmmc_card_enable_intr, 94 .card_intr_ack = wb_sdmmc_card_intr_ack, 95 }; 96 97 static void 98 wb_sdmmc_read_data(struct wb_softc *wb, uint8_t *data, int len) 99 { 100 bus_space_read_multi_1(wb->wb_iot, wb->wb_ioh, WB_SD_FIFO, data, len); 101 } 102 103 static void 104 wb_sdmmc_write_data(struct wb_softc *wb, uint8_t *data, int len) 105 { 106 bus_space_write_multi_1(wb->wb_iot, wb->wb_ioh, WB_SD_FIFO, data, len); 107 } 108 109 static void 110 wb_sdmmc_discover(void *opaque) 111 { 112 struct wb_softc *wb = opaque; 113 114 REPORT(wb, "TRACE: discover(wb)\n"); 115 116 sdmmc_needs_discover(wb->wb_sdmmc_dev); 117 } 118 119 static bool 120 wb_sdmmc_enable(struct wb_softc *wb) 121 { 122 int i = 5000; 123 124 REPORT(wb, "TRACE: enable(wb)\n"); 125 126 /* put the device in a known state */ 127 wb_idx_write(wb, WB_INDEX_SETUP, WB_SETUP_SOFT_RST); 128 while (--i > 0 && wb_idx_read(wb, WB_INDEX_SETUP) & WB_SETUP_SOFT_RST) 129 delay(100); 130 if (i == 0) { 131 aprint_error_dev(wb->wb_dev, "timeout resetting device\n"); 132 return false; 133 } 134 wb_idx_write(wb, WB_INDEX_CLK, wb->wb_sdmmc_clk); 135 wb_idx_write(wb, WB_INDEX_FIFOEN, 0); 136 wb_idx_write(wb, WB_INDEX_DMA, 0); 137 wb_idx_write(wb, WB_INDEX_PBSMSB, 0); 138 wb_idx_write(wb, WB_INDEX_PBSLSB, 0); 139 /* drain FIFO */ 140 while ((wb_read(wb, WB_SD_FIFOSTS) & WB_FIFO_EMPTY) == 0) 141 wb_read(wb, WB_SD_FIFO); 142 143 wb_write(wb, WB_SD_CSR, 0); 144 145 wb_write(wb, WB_SD_INTCTL, WB_INT_DEFAULT); 146 147 wb_sdmmc_card_detect(wb); 148 149 return true; 150 } 151 152 static bool 153 wb_sdmmc_disable(struct wb_softc *wb) 154 { 155 uint8_t val; 156 157 REPORT(wb, "TRACE: disable(wb)\n"); 158 159 val = wb_read(wb, WB_SD_CSR); 160 val |= WB_CSR_POWER_N; 161 wb_write(wb, WB_SD_CSR, val); 162 163 return true; 164 } 165 166 void 167 wb_sdmmc_attach(struct wb_softc *wb) 168 { 169 struct sdmmcbus_attach_args saa; 170 171 callout_init(&wb->wb_sdmmc_callout, 0); 172 callout_setfunc(&wb->wb_sdmmc_callout, wb_sdmmc_discover, wb); 173 174 wb->wb_sdmmc_width = 1; 175 wb->wb_sdmmc_clk = WB_CLK_375K; 176 177 if (wb_sdmmc_enable(wb) == false) 178 return; 179 180 memset(&saa, 0, sizeof(saa)); 181 saa.saa_busname = "sdmmc"; 182 saa.saa_sct = &wb_sdmmc_chip_functions; 183 saa.saa_sch = wb; 184 saa.saa_clkmin = 375; 185 saa.saa_clkmax = 24000; 186 saa.saa_caps = SMC_CAPS_4BIT_MODE; 187 188 wb->wb_sdmmc_dev = config_found(wb->wb_dev, &saa, NULL); 189 } 190 191 int 192 wb_sdmmc_detach(struct wb_softc *wb, int flags) 193 { 194 int rv; 195 196 if (wb->wb_sdmmc_dev) { 197 rv = config_detach(wb->wb_sdmmc_dev, flags); 198 if (rv) 199 return rv; 200 } 201 wb_sdmmc_disable(wb); 202 203 callout_halt(&wb->wb_sdmmc_callout, NULL); 204 callout_destroy(&wb->wb_sdmmc_callout); 205 206 return 0; 207 } 208 209 /* 210 * SD/MMC interface 211 */ 212 static int 213 wb_sdmmc_host_reset(sdmmc_chipset_handle_t sch) 214 { 215 REPORT(sch, "TRACE: sdmmc/host_reset(wb)\n"); 216 217 return 0; 218 } 219 220 static uint32_t 221 wb_sdmmc_host_ocr(sdmmc_chipset_handle_t sch) 222 { 223 REPORT(sch, "TRACE: sdmmc/host_ocr(wb)\n"); 224 225 return MMC_OCR_3_2V_3_3V | MMC_OCR_3_3V_3_4V; 226 } 227 228 static int 229 wb_sdmmc_host_maxblklen(sdmmc_chipset_handle_t sch) 230 { 231 REPORT(sch, "TRACE: sdmmc/host_maxblklen(wb)\n"); 232 233 return 512; /* XXX */ 234 } 235 236 static int 237 wb_sdmmc_card_detect(sdmmc_chipset_handle_t sch) 238 { 239 struct wb_softc *wb = sch; 240 int rv; 241 242 wb_led(wb, true); 243 rv = (wb_read(wb, WB_SD_CSR) & WB_CSR_CARD_PRESENT) ? 1 : 0; 244 wb_led(wb, false); 245 246 REPORT(wb, "TRACE: sdmmc/card_detect(wb) -> %d\n", rv); 247 248 return rv; 249 } 250 251 static int 252 wb_sdmmc_write_protect(sdmmc_chipset_handle_t sch) 253 { 254 struct wb_softc *wb = sch; 255 int rv; 256 257 wb_led(wb, true); 258 rv = (wb_read(wb, WB_SD_CSR) & WB_CSR_WRITE_PROTECT) ? 1 : 0; 259 wb_led(wb, false); 260 261 REPORT(wb, "TRACE: sdmmc/write_protect(wb) -> %d\n", rv); 262 263 return rv; 264 } 265 266 static int 267 wb_sdmmc_bus_power(sdmmc_chipset_handle_t sch, uint32_t ocr) 268 { 269 REPORT(sch, "TRACE: sdmmc/bus_power(wb, ocr=%d)\n", ocr); 270 271 return 0; 272 } 273 274 static int 275 wb_sdmmc_bus_clock(sdmmc_chipset_handle_t sch, int freq) 276 { 277 struct wb_softc *wb = sch; 278 uint8_t clk; 279 280 REPORT(wb, "TRACE: sdmmc/bus_clock(wb, freq=%d)\n", freq); 281 282 if (freq >= 24000) 283 clk = WB_CLK_24M; 284 else if (freq >= 16000) 285 clk = WB_CLK_16M; 286 else if (freq >= 12000) 287 clk = WB_CLK_12M; 288 else 289 clk = WB_CLK_375K; 290 291 wb->wb_sdmmc_clk = clk; 292 293 if (wb_idx_read(wb, WB_INDEX_CLK) != clk) 294 wb_idx_write(wb, WB_INDEX_CLK, clk); 295 296 return 0; 297 } 298 299 static int 300 wb_sdmmc_bus_width(sdmmc_chipset_handle_t sch, int width) 301 { 302 struct wb_softc *wb = sch; 303 304 REPORT(wb, "TRACE: sdmmc/bus_width(wb, width=%d)\n", width); 305 306 if (width != 1 && width != 4) 307 return 1; 308 309 wb->wb_sdmmc_width = width; 310 311 return 0; 312 } 313 314 315 static void 316 wb_sdmmc_rsp_read_long(struct wb_softc *wb, struct sdmmc_command *cmd) 317 { 318 uint8_t *p = (uint8_t *)cmd->c_resp; 319 int i; 320 321 if (wb_idx_read(wb, WB_INDEX_RESPLEN) != 1) { 322 cmd->c_error = ENXIO; 323 return; 324 } 325 326 for (i = 12; i >= 0; i -= 4) { 327 p[3] = wb_idx_read(wb, WB_INDEX_RESP(i + 0)); 328 p[2] = wb_idx_read(wb, WB_INDEX_RESP(i + 1)); 329 p[1] = wb_idx_read(wb, WB_INDEX_RESP(i + 2)); 330 p[0] = wb_idx_read(wb, WB_INDEX_RESP(i + 3)); 331 p += 4; 332 } 333 } 334 335 static void 336 wb_sdmmc_rsp_read_short(struct wb_softc *wb, struct sdmmc_command *cmd) 337 { 338 uint8_t *p = (uint8_t *)cmd->c_resp; 339 340 if (wb_idx_read(wb, WB_INDEX_RESPLEN) != 0) { 341 cmd->c_error = ENXIO; 342 return; 343 } 344 345 p[3] = wb_idx_read(wb, WB_INDEX_RESP(12)); 346 p[2] = wb_idx_read(wb, WB_INDEX_RESP(13)); 347 p[1] = wb_idx_read(wb, WB_INDEX_RESP(14)); 348 p[0] = wb_idx_read(wb, WB_INDEX_RESP(15)); 349 } 350 351 static int 352 wb_sdmmc_transfer_data(struct wb_softc *wb, struct sdmmc_command *cmd) 353 { 354 uint8_t fifosts; 355 int datalen, retry = 5000; 356 357 if (wb->wb_sdmmc_intsts & WB_INT_CARD) 358 return EIO; 359 360 fifosts = wb_read(wb, WB_SD_FIFOSTS); 361 if (ISSET(cmd->c_flags, SCF_CMD_READ)) { 362 if (fifosts & WB_FIFO_EMPTY) { 363 while (--retry > 0) { 364 fifosts = wb_read(wb, WB_SD_FIFOSTS); 365 if ((fifosts & WB_FIFO_EMPTY) == 0) 366 break; 367 delay(100); 368 } 369 if (retry == 0) 370 return EBUSY; 371 } 372 373 if (fifosts & WB_FIFO_FULL) 374 datalen = 16; 375 else 376 datalen = fifosts & WB_FIFO_DEPTH_MASK; 377 } else { 378 if (fifosts & WB_FIFO_FULL) { 379 while (--retry > 0) { 380 fifosts = wb_read(wb, WB_SD_FIFOSTS); 381 if ((fifosts & WB_FIFO_FULL) == 0) 382 break; 383 delay(100); 384 } 385 if (retry == 0) 386 return EBUSY; 387 } 388 389 if (fifosts & WB_FIFO_EMPTY) 390 datalen = 16; 391 else 392 datalen = 16 - (fifosts & WB_FIFO_DEPTH_MASK); 393 } 394 395 datalen = MIN(datalen, cmd->c_resid); 396 if (datalen > 0) { 397 if (ISSET(cmd->c_flags, SCF_CMD_READ)) 398 wb_sdmmc_read_data(wb, cmd->c_buf, datalen); 399 else 400 wb_sdmmc_write_data(wb, cmd->c_buf, datalen); 401 402 cmd->c_buf += datalen; 403 cmd->c_resid -= datalen; 404 } 405 406 return 0; 407 } 408 409 static void 410 wb_sdmmc_exec_command(sdmmc_chipset_handle_t sch, struct sdmmc_command *cmd) 411 { 412 static const int opcodes[] = { 413 11, 17, 18, 20, 24, 25, 26, 27, 30, 42, 51, 56 414 }; 415 struct wb_softc *wb = sch; 416 uint8_t val; 417 int blklen; 418 int error; 419 int i, retry; 420 int s; 421 422 REPORT(wb, "TRACE: sdmmc/exec_command(wb, cmd) " 423 "opcode %d flags 0x%x data %p datalen %d\n", 424 cmd->c_opcode, cmd->c_flags, cmd->c_data, cmd->c_datalen); 425 426 if (cmd->c_datalen > 0) { 427 /* controller only supports a select number of data opcodes */ 428 for (i = 0; i < __arraycount(opcodes); i++) 429 if (opcodes[i] == cmd->c_opcode) 430 break; 431 if (i == __arraycount(opcodes)) { 432 cmd->c_error = EINVAL; 433 goto done; 434 } 435 436 /* Fragment the data into proper blocks */ 437 blklen = MIN(cmd->c_datalen, cmd->c_blklen); 438 439 if (cmd->c_datalen % blklen > 0) { 440 aprint_error_dev(wb->wb_dev, 441 "data is not a multiple of %u bytes\n", blklen); 442 cmd->c_error = EINVAL; 443 goto done; 444 } 445 446 /* setup block size registers */ 447 blklen = blklen + 2 * wb->wb_sdmmc_width; 448 wb_idx_write(wb, WB_INDEX_PBSMSB, 449 ((blklen >> 4) & 0xf0) | (wb->wb_sdmmc_width / 4)); 450 wb_idx_write(wb, WB_INDEX_PBSLSB, blklen & 0xff); 451 452 /* clear FIFO */ 453 val = wb_idx_read(wb, WB_INDEX_SETUP); 454 val |= WB_SETUP_FIFO_RST; 455 wb_idx_write(wb, WB_INDEX_SETUP, val); 456 while (wb_idx_read(wb, WB_INDEX_SETUP) & WB_SETUP_FIFO_RST) 457 ; 458 459 cmd->c_resid = cmd->c_datalen; 460 cmd->c_buf = cmd->c_data; 461 462 /* setup FIFO thresholds */ 463 if (ISSET(cmd->c_flags, SCF_CMD_READ)) 464 wb_idx_write(wb, WB_INDEX_FIFOEN, WB_FIFOEN_FULL | 8); 465 else { 466 wb_idx_write(wb, WB_INDEX_FIFOEN, WB_FIFOEN_EMPTY | 8); 467 468 /* pre-fill the FIFO on write */ 469 error = wb_sdmmc_transfer_data(wb, cmd); 470 if (error) { 471 cmd->c_error = error; 472 goto done; 473 } 474 } 475 } 476 477 s = splsdmmc(); 478 wb->wb_sdmmc_intsts = 0; 479 wb_write(wb, WB_SD_COMMAND, cmd->c_opcode); 480 wb_write(wb, WB_SD_COMMAND, (cmd->c_arg >> 24) & 0xff); 481 wb_write(wb, WB_SD_COMMAND, (cmd->c_arg >> 16) & 0xff); 482 wb_write(wb, WB_SD_COMMAND, (cmd->c_arg >> 8) & 0xff); 483 wb_write(wb, WB_SD_COMMAND, (cmd->c_arg >> 0) & 0xff); 484 splx(s); 485 486 retry = 100000; 487 while (wb_idx_read(wb, WB_INDEX_STATUS) & WB_STATUS_CARD_TRAFFIC) { 488 if (--retry == 0) 489 break; 490 delay(1); 491 } 492 if (wb_idx_read(wb, WB_INDEX_STATUS) & WB_STATUS_CARD_TRAFFIC) { 493 REPORT(wb, 494 "command timed out, WB_INDEX_STATUS = 0x%02x\n", 495 wb_idx_read(wb, WB_INDEX_STATUS)); 496 cmd->c_error = ETIMEDOUT; 497 goto done; 498 } 499 500 if (ISSET(cmd->c_flags, SCF_RSP_PRESENT)) { 501 if (wb->wb_sdmmc_intsts & WB_INT_TIMEOUT) { 502 cmd->c_error = ETIMEDOUT; 503 goto done; 504 } 505 506 if (ISSET(cmd->c_flags, SCF_RSP_136)) 507 wb_sdmmc_rsp_read_long(wb, cmd); 508 else 509 wb_sdmmc_rsp_read_short(wb, cmd); 510 } 511 512 if (cmd->c_error == 0 && cmd->c_datalen > 0) { 513 wb_led(wb, true); 514 while (cmd->c_resid > 0) { 515 error = wb_sdmmc_transfer_data(wb, cmd); 516 if (error) { 517 cmd->c_error = error; 518 break; 519 } 520 } 521 wb_led(wb, false); 522 } 523 524 done: 525 SET(cmd->c_flags, SCF_ITSDONE); 526 527 if (cmd->c_error) { 528 REPORT(wb, 529 "cmd error = %d, op = %d [%s] " 530 "blklen %d datalen %d resid %d\n", 531 cmd->c_error, cmd->c_opcode, 532 ISSET(cmd->c_flags, SCF_CMD_READ) ? "rd" : "wr", 533 cmd->c_blklen, cmd->c_datalen, cmd->c_resid); 534 } 535 } 536 537 static void 538 wb_sdmmc_card_enable_intr(sdmmc_chipset_handle_t sch, int enable) 539 { 540 REPORT(sch, "TRACE: sdmmc/card_enable_intr(wb, enable=%d)\n", enable); 541 } 542 543 static void 544 wb_sdmmc_card_intr_ack(sdmmc_chipset_handle_t sch) 545 { 546 REPORT(sch, "TRACE: sdmmc/card_intr_ack(wb)\n"); 547 } 548 549 /* 550 * intr handler 551 */ 552 int 553 wb_sdmmc_intr(struct wb_softc *wb) 554 { 555 uint8_t val; 556 557 val = wb_read(wb, WB_SD_INTSTS); 558 if (val == 0xff || val == 0x00) 559 return 0; 560 561 if (wb->wb_sdmmc_dev == NULL) 562 return 1; 563 564 wb->wb_sdmmc_intsts |= val; 565 566 if (wb_sdmmc_debug) { 567 char buf[64]; 568 snprintb(buf, sizeof(buf), 569 "\20\1TC\2BUSYEND\3PROGEND\4TIMEOUT" 570 "\5CRC\6FIFO\7CARD\010PENDING", 571 val); 572 REPORT(wb, "WB_SD_INTSTS = %s\n", buf); 573 } 574 575 if (val & WB_INT_CARD) 576 callout_schedule(&wb->wb_sdmmc_callout, hz / 4); 577 578 return 1; 579 } 580 581 /* 582 * pmf 583 */ 584 bool 585 wb_sdmmc_suspend(struct wb_softc *wb) 586 { 587 return wb_sdmmc_disable(wb); 588 } 589 590 bool 591 wb_sdmmc_resume(struct wb_softc *wb) 592 { 593 uint8_t val; 594 595 val = wb_read(wb, WB_SD_CSR); 596 val &= ~WB_CSR_POWER_N; 597 wb_write(wb, WB_SD_CSR, val); 598 599 if (wb_sdmmc_enable(wb) == false) 600 return false; 601 602 if (wb_idx_read(wb, WB_INDEX_CLK) != wb->wb_sdmmc_clk) 603 wb_idx_write(wb, WB_INDEX_CLK, wb->wb_sdmmc_clk); 604 605 return true; 606 } 607
Indexes created Tue Sep 30 11:09:46 GMT 2025