1 /* 2 * linux/drivers/mmc/host/omap.c 3 * 4 * Copyright (C) 2004 Nokia Corporation 5 * Written by Tuukka Tikkanen and Juha Yrjölä<juha.yrjola@nokia.com> 6 * Misc hacks here and there by Tony Lindgren <tony@atomide.com> 7 * Other hacks (DMA, SD, etc) by David Brownell 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 */ 13 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/init.h> 17 #include <linux/ioport.h> 18 #include <linux/platform_device.h> 19 #include <linux/interrupt.h> 20 #include <linux/dmaengine.h> 21 #include <linux/dma-mapping.h> 22 #include <linux/delay.h> 23 #include <linux/spinlock.h> 24 #include <linux/timer.h> 25 #include <linux/of.h> 26 #include <linux/mmc/host.h> 27 #include <linux/mmc/card.h> 28 #include <linux/mmc/mmc.h> 29 #include <linux/clk.h> 30 #include <linux/scatterlist.h> 31 #include <linux/slab.h> 32 #include <linux/platform_data/mmc-omap.h> 33 34 35 #define OMAP_MMC_REG_CMD 0x00 36 #define OMAP_MMC_REG_ARGL 0x01 37 #define OMAP_MMC_REG_ARGH 0x02 38 #define OMAP_MMC_REG_CON 0x03 39 #define OMAP_MMC_REG_STAT 0x04 40 #define OMAP_MMC_REG_IE 0x05 41 #define OMAP_MMC_REG_CTO 0x06 42 #define OMAP_MMC_REG_DTO 0x07 43 #define OMAP_MMC_REG_DATA 0x08 44 #define OMAP_MMC_REG_BLEN 0x09 45 #define OMAP_MMC_REG_NBLK 0x0a 46 #define OMAP_MMC_REG_BUF 0x0b 47 #define OMAP_MMC_REG_SDIO 0x0d 48 #define OMAP_MMC_REG_REV 0x0f 49 #define OMAP_MMC_REG_RSP0 0x10 50 #define OMAP_MMC_REG_RSP1 0x11 51 #define OMAP_MMC_REG_RSP2 0x12 52 #define OMAP_MMC_REG_RSP3 0x13 53 #define OMAP_MMC_REG_RSP4 0x14 54 #define OMAP_MMC_REG_RSP5 0x15 55 #define OMAP_MMC_REG_RSP6 0x16 56 #define OMAP_MMC_REG_RSP7 0x17 57 #define OMAP_MMC_REG_IOSR 0x18 58 #define OMAP_MMC_REG_SYSC 0x19 59 #define OMAP_MMC_REG_SYSS 0x1a 60 61 #define OMAP_MMC_STAT_CARD_ERR (1 << 14) 62 #define OMAP_MMC_STAT_CARD_IRQ (1 << 13) 63 #define OMAP_MMC_STAT_OCR_BUSY (1 << 12) 64 #define OMAP_MMC_STAT_A_EMPTY (1 << 11) 65 #define OMAP_MMC_STAT_A_FULL (1 << 10) 66 #define OMAP_MMC_STAT_CMD_CRC (1 << 8) 67 #define OMAP_MMC_STAT_CMD_TOUT (1 << 7) 68 #define OMAP_MMC_STAT_DATA_CRC (1 << 6) 69 #define OMAP_MMC_STAT_DATA_TOUT (1 << 5) 70 #define OMAP_MMC_STAT_END_BUSY (1 << 4) 71 #define OMAP_MMC_STAT_END_OF_DATA (1 << 3) 72 #define OMAP_MMC_STAT_CARD_BUSY (1 << 2) 73 #define OMAP_MMC_STAT_END_OF_CMD (1 << 0) 74 75 #define mmc_omap7xx() (host->features & MMC_OMAP7XX) 76 #define mmc_omap15xx() (host->features & MMC_OMAP15XX) 77 #define mmc_omap16xx() (host->features & MMC_OMAP16XX) 78 #define MMC_OMAP1_MASK (MMC_OMAP7XX | MMC_OMAP15XX | MMC_OMAP16XX) 79 #define mmc_omap1() (host->features & MMC_OMAP1_MASK) 80 #define mmc_omap2() (!mmc_omap1()) 81 82 #define OMAP_MMC_REG(host, reg) (OMAP_MMC_REG_##reg << (host)->reg_shift) 83 #define OMAP_MMC_READ(host, reg) __raw_readw((host)->virt_base + OMAP_MMC_REG(host, reg)) 84 #define OMAP_MMC_WRITE(host, reg, val) __raw_writew((val), (host)->virt_base + OMAP_MMC_REG(host, reg)) 85 86 /* 87 * Command types 88 */ 89 #define OMAP_MMC_CMDTYPE_BC 0 90 #define OMAP_MMC_CMDTYPE_BCR 1 91 #define OMAP_MMC_CMDTYPE_AC 2 92 #define OMAP_MMC_CMDTYPE_ADTC 3 93 94 #define DRIVER_NAME "mmci-omap" 95 96 /* Specifies how often in millisecs to poll for card status changes 97 * when the cover switch is open */ 98 #define OMAP_MMC_COVER_POLL_DELAY 500 99 100 struct mmc_omap_host; 101 102 struct mmc_omap_slot { 103 int id; 104 unsigned int vdd; 105 u16 saved_con; 106 u16 bus_mode; 107 u16 power_mode; 108 unsigned int fclk_freq; 109 110 struct tasklet_struct cover_tasklet; 111 struct timer_list cover_timer; 112 unsigned cover_open; 113 114 struct mmc_request *mrq; 115 struct mmc_omap_host *host; 116 struct mmc_host *mmc; 117 struct omap_mmc_slot_data *pdata; 118 }; 119 120 struct mmc_omap_host { 121 int initialized; 122 struct mmc_request * mrq; 123 struct mmc_command * cmd; 124 struct mmc_data * data; 125 struct mmc_host * mmc; 126 struct device * dev; 127 unsigned char id; /* 16xx chips have 2 MMC blocks */ 128 struct clk * iclk; 129 struct clk * fclk; 130 struct dma_chan *dma_rx; 131 u32 dma_rx_burst; 132 struct dma_chan *dma_tx; 133 u32 dma_tx_burst; 134 void __iomem *virt_base; 135 unsigned int phys_base; 136 int irq; 137 unsigned char bus_mode; 138 unsigned int reg_shift; 139 140 struct work_struct cmd_abort_work; 141 unsigned abort:1; 142 struct timer_list cmd_abort_timer; 143 144 struct work_struct slot_release_work; 145 struct mmc_omap_slot *next_slot; 146 struct work_struct send_stop_work; 147 struct mmc_data *stop_data; 148 149 unsigned int sg_len; 150 int sg_idx; 151 u16 * buffer; 152 u32 buffer_bytes_left; 153 u32 total_bytes_left; 154 155 unsigned features; 156 unsigned brs_received:1, dma_done:1; 157 unsigned dma_in_use:1; 158 spinlock_t dma_lock; 159 160 struct mmc_omap_slot *slots[OMAP_MMC_MAX_SLOTS]; 161 struct mmc_omap_slot *current_slot; 162 spinlock_t slot_lock; 163 wait_queue_head_t slot_wq; 164 int nr_slots; 165 166 struct timer_list clk_timer; 167 spinlock_t clk_lock; /* for changing enabled state */ 168 unsigned int fclk_enabled:1; 169 struct workqueue_struct *mmc_omap_wq; 170 171 struct omap_mmc_platform_data *pdata; 172 }; 173 174 175 static void mmc_omap_fclk_offdelay(struct mmc_omap_slot *slot) 176 { 177 unsigned long tick_ns; 178 179 if (slot != NULL && slot->host->fclk_enabled && slot->fclk_freq > 0) { 180 tick_ns = DIV_ROUND_UP(NSEC_PER_SEC, slot->fclk_freq); 181 ndelay(8 * tick_ns); 182 } 183 } 184 185 static void mmc_omap_fclk_enable(struct mmc_omap_host *host, unsigned int enable) 186 { 187 unsigned long flags; 188 189 spin_lock_irqsave(&host->clk_lock, flags); 190 if (host->fclk_enabled != enable) { 191 host->fclk_enabled = enable; 192 if (enable) 193 clk_enable(host->fclk); 194 else 195 clk_disable(host->fclk); 196 } 197 spin_unlock_irqrestore(&host->clk_lock, flags); 198 } 199 200 static void mmc_omap_select_slot(struct mmc_omap_slot *slot, int claimed) 201 { 202 struct mmc_omap_host *host = slot->host; 203 unsigned long flags; 204 205 if (claimed) 206 goto no_claim; 207 spin_lock_irqsave(&host->slot_lock, flags); 208 while (host->mmc != NULL) { 209 spin_unlock_irqrestore(&host->slot_lock, flags); 210 wait_event(host->slot_wq, host->mmc == NULL); 211 spin_lock_irqsave(&host->slot_lock, flags); 212 } 213 host->mmc = slot->mmc; 214 spin_unlock_irqrestore(&host->slot_lock, flags); 215 no_claim: 216 del_timer(&host->clk_timer); 217 if (host->current_slot != slot || !claimed) 218 mmc_omap_fclk_offdelay(host->current_slot); 219 220 if (host->current_slot != slot) { 221 OMAP_MMC_WRITE(host, CON, slot->saved_con & 0xFC00); 222 if (host->pdata->switch_slot != NULL) 223 host->pdata->switch_slot(mmc_dev(slot->mmc), slot->id); 224 host->current_slot = slot; 225 } 226 227 if (claimed) { 228 mmc_omap_fclk_enable(host, 1); 229 230 /* Doing the dummy read here seems to work around some bug 231 * at least in OMAP24xx silicon where the command would not 232 * start after writing the CMD register. Sigh. */ 233 OMAP_MMC_READ(host, CON); 234 235 OMAP_MMC_WRITE(host, CON, slot->saved_con); 236 } else 237 mmc_omap_fclk_enable(host, 0); 238 } 239 240 static void mmc_omap_start_request(struct mmc_omap_host *host, 241 struct mmc_request *req); 242 243 static void mmc_omap_slot_release_work(struct work_struct *work) 244 { 245 struct mmc_omap_host *host = container_of(work, struct mmc_omap_host, 246 slot_release_work); 247 struct mmc_omap_slot *next_slot = host->next_slot; 248 struct mmc_request *rq; 249 250 host->next_slot = NULL; 251 mmc_omap_select_slot(next_slot, 1); 252 253 rq = next_slot->mrq; 254 next_slot->mrq = NULL; 255 mmc_omap_start_request(host, rq); 256 } 257 258 static void mmc_omap_release_slot(struct mmc_omap_slot *slot, int clk_enabled) 259 { 260 struct mmc_omap_host *host = slot->host; 261 unsigned long flags; 262 int i; 263 264 BUG_ON(slot == NULL || host->mmc == NULL); 265 266 if (clk_enabled) 267 /* Keeps clock running for at least 8 cycles on valid freq */ 268 mod_timer(&host->clk_timer, jiffies + HZ/10); 269 else { 270 del_timer(&host->clk_timer); 271 mmc_omap_fclk_offdelay(slot); 272 mmc_omap_fclk_enable(host, 0); 273 } 274 275 spin_lock_irqsave(&host->slot_lock, flags); 276 /* Check for any pending requests */ 277 for (i = 0; i < host->nr_slots; i++) { 278 struct mmc_omap_slot *new_slot; 279 280 if (host->slots[i] == NULL || host->slots[i]->mrq == NULL) 281 continue; 282 283 BUG_ON(host->next_slot != NULL); 284 new_slot = host->slots[i]; 285 /* The current slot should not have a request in queue */ 286 BUG_ON(new_slot == host->current_slot); 287 288 host->next_slot = new_slot; 289 host->mmc = new_slot->mmc; 290 spin_unlock_irqrestore(&host->slot_lock, flags); 291 queue_work(host->mmc_omap_wq, &host->slot_release_work); 292 return; 293 } 294 295 host->mmc = NULL; 296 wake_up(&host->slot_wq); 297 spin_unlock_irqrestore(&host->slot_lock, flags); 298 } 299 300 static inline 301 int mmc_omap_cover_is_open(struct mmc_omap_slot *slot) 302 { 303 if (slot->pdata->get_cover_state) 304 return slot->pdata->get_cover_state(mmc_dev(slot->mmc), 305 slot->id); 306 return 0; 307 } 308 309 static ssize_t 310 mmc_omap_show_cover_switch(struct device *dev, struct device_attribute *attr, 311 char *buf) 312 { 313 struct mmc_host *mmc = container_of(dev, struct mmc_host, class_dev); 314 struct mmc_omap_slot *slot = mmc_priv(mmc); 315 316 return sprintf(buf, "%s\n", mmc_omap_cover_is_open(slot) ? "open" : 317 "closed"); 318 } 319 320 static DEVICE_ATTR(cover_switch, S_IRUGO, mmc_omap_show_cover_switch, NULL); 321 322 static ssize_t 323 mmc_omap_show_slot_name(struct device *dev, struct device_attribute *attr, 324 char *buf) 325 { 326 struct mmc_host *mmc = container_of(dev, struct mmc_host, class_dev); 327 struct mmc_omap_slot *slot = mmc_priv(mmc); 328 329 return sprintf(buf, "%s\n", slot->pdata->name); 330 } 331 332 static DEVICE_ATTR(slot_name, S_IRUGO, mmc_omap_show_slot_name, NULL); 333 334 static void 335 mmc_omap_start_command(struct mmc_omap_host *host, struct mmc_command *cmd) 336 { 337 u32 cmdreg; 338 u32 resptype; 339 u32 cmdtype; 340 u16 irq_mask; 341 342 host->cmd = cmd; 343 344 resptype = 0; 345 cmdtype = 0; 346 347 /* Our hardware needs to know exact type */ 348 switch (mmc_resp_type(cmd)) { 349 case MMC_RSP_NONE: 350 break; 351 case MMC_RSP_R1: 352 case MMC_RSP_R1B: 353 /* resp 1, 1b, 6, 7 */ 354 resptype = 1; 355 break; 356 case MMC_RSP_R2: 357 resptype = 2; 358 break; 359 case MMC_RSP_R3: 360 resptype = 3; 361 break; 362 default: 363 dev_err(mmc_dev(host->mmc), "Invalid response type: %04x\n", mmc_resp_type(cmd)); 364 break; 365 } 366 367 if (mmc_cmd_type(cmd) == MMC_CMD_ADTC) { 368 cmdtype = OMAP_MMC_CMDTYPE_ADTC; 369 } else if (mmc_cmd_type(cmd) == MMC_CMD_BC) { 370 cmdtype = OMAP_MMC_CMDTYPE_BC; 371 } else if (mmc_cmd_type(cmd) == MMC_CMD_BCR) { 372 cmdtype = OMAP_MMC_CMDTYPE_BCR; 373 } else { 374 cmdtype = OMAP_MMC_CMDTYPE_AC; 375 } 376 377 cmdreg = cmd->opcode | (resptype << 8) | (cmdtype << 12); 378 379 if (host->current_slot->bus_mode == MMC_BUSMODE_OPENDRAIN) 380 cmdreg |= 1 << 6; 381 382 if (cmd->flags & MMC_RSP_BUSY) 383 cmdreg |= 1 << 11; 384 385 if (host->data && !(host->data->flags & MMC_DATA_WRITE)) 386 cmdreg |= 1 << 15; 387 388 mod_timer(&host->cmd_abort_timer, jiffies + HZ/2); 389 390 OMAP_MMC_WRITE(host, CTO, 200); 391 OMAP_MMC_WRITE(host, ARGL, cmd->arg & 0xffff); 392 OMAP_MMC_WRITE(host, ARGH, cmd->arg >> 16); 393 irq_mask = OMAP_MMC_STAT_A_EMPTY | OMAP_MMC_STAT_A_FULL | 394 OMAP_MMC_STAT_CMD_CRC | OMAP_MMC_STAT_CMD_TOUT | 395 OMAP_MMC_STAT_DATA_CRC | OMAP_MMC_STAT_DATA_TOUT | 396 OMAP_MMC_STAT_END_OF_CMD | OMAP_MMC_STAT_CARD_ERR | 397 OMAP_MMC_STAT_END_OF_DATA; 398 if (cmd->opcode == MMC_ERASE) 399 irq_mask &= ~OMAP_MMC_STAT_DATA_TOUT; 400 OMAP_MMC_WRITE(host, IE, irq_mask); 401 OMAP_MMC_WRITE(host, CMD, cmdreg); 402 } 403 404 static void 405 mmc_omap_release_dma(struct mmc_omap_host *host, struct mmc_data *data, 406 int abort) 407 { 408 enum dma_data_direction dma_data_dir; 409 struct device *dev = mmc_dev(host->mmc); 410 struct dma_chan *c; 411 412 if (data->flags & MMC_DATA_WRITE) { 413 dma_data_dir = DMA_TO_DEVICE; 414 c = host->dma_tx; 415 } else { 416 dma_data_dir = DMA_FROM_DEVICE; 417 c = host->dma_rx; 418 } 419 if (c) { 420 if (data->error) { 421 dmaengine_terminate_all(c); 422 /* Claim nothing transferred on error... */ 423 data->bytes_xfered = 0; 424 } 425 dev = c->device->dev; 426 } 427 dma_unmap_sg(dev, data->sg, host->sg_len, dma_data_dir); 428 } 429 430 static void mmc_omap_send_stop_work(struct work_struct *work) 431 { 432 struct mmc_omap_host *host = container_of(work, struct mmc_omap_host, 433 send_stop_work); 434 struct mmc_omap_slot *slot = host->current_slot; 435 struct mmc_data *data = host->stop_data; 436 unsigned long tick_ns; 437 438 tick_ns = DIV_ROUND_UP(NSEC_PER_SEC, slot->fclk_freq); 439 ndelay(8*tick_ns); 440 441 mmc_omap_start_command(host, data->stop); 442 } 443 444 static void 445 mmc_omap_xfer_done(struct mmc_omap_host *host, struct mmc_data *data) 446 { 447 if (host->dma_in_use) 448 mmc_omap_release_dma(host, data, data->error); 449 450 host->data = NULL; 451 host->sg_len = 0; 452 453 /* NOTE: MMC layer will sometimes poll-wait CMD13 next, issuing 454 * dozens of requests until the card finishes writing data. 455 * It'd be cheaper to just wait till an EOFB interrupt arrives... 456 */ 457 458 if (!data->stop) { 459 struct mmc_host *mmc; 460 461 host->mrq = NULL; 462 mmc = host->mmc; 463 mmc_omap_release_slot(host->current_slot, 1); 464 mmc_request_done(mmc, data->mrq); 465 return; 466 } 467 468 host->stop_data = data; 469 queue_work(host->mmc_omap_wq, &host->send_stop_work); 470 } 471 472 static void 473 mmc_omap_send_abort(struct mmc_omap_host *host, int maxloops) 474 { 475 struct mmc_omap_slot *slot = host->current_slot; 476 unsigned int restarts, passes, timeout; 477 u16 stat = 0; 478 479 /* Sending abort takes 80 clocks. Have some extra and round up */ 480 timeout = DIV_ROUND_UP(120 * USEC_PER_SEC, slot->fclk_freq); 481 restarts = 0; 482 while (restarts < maxloops) { 483 OMAP_MMC_WRITE(host, STAT, 0xFFFF); 484 OMAP_MMC_WRITE(host, CMD, (3 << 12) | (1 << 7)); 485 486 passes = 0; 487 while (passes < timeout) { 488 stat = OMAP_MMC_READ(host, STAT); 489 if (stat & OMAP_MMC_STAT_END_OF_CMD) 490 goto out; 491 udelay(1); 492 passes++; 493 } 494 495 restarts++; 496 } 497 out: 498 OMAP_MMC_WRITE(host, STAT, stat); 499 } 500 501 static void 502 mmc_omap_abort_xfer(struct mmc_omap_host *host, struct mmc_data *data) 503 { 504 if (host->dma_in_use) 505 mmc_omap_release_dma(host, data, 1); 506 507 host->data = NULL; 508 host->sg_len = 0; 509 510 mmc_omap_send_abort(host, 10000); 511 } 512 513 static void 514 mmc_omap_end_of_data(struct mmc_omap_host *host, struct mmc_data *data) 515 { 516 unsigned long flags; 517 int done; 518 519 if (!host->dma_in_use) { 520 mmc_omap_xfer_done(host, data); 521 return; 522 } 523 done = 0; 524 spin_lock_irqsave(&host->dma_lock, flags); 525 if (host->dma_done) 526 done = 1; 527 else 528 host->brs_received = 1; 529 spin_unlock_irqrestore(&host->dma_lock, flags); 530 if (done) 531 mmc_omap_xfer_done(host, data); 532 } 533 534 static void 535 mmc_omap_dma_done(struct mmc_omap_host *host, struct mmc_data *data) 536 { 537 unsigned long flags; 538 int done; 539 540 done = 0; 541 spin_lock_irqsave(&host->dma_lock, flags); 542 if (host->brs_received) 543 done = 1; 544 else 545 host->dma_done = 1; 546 spin_unlock_irqrestore(&host->dma_lock, flags); 547 if (done) 548 mmc_omap_xfer_done(host, data); 549 } 550 551 static void 552 mmc_omap_cmd_done(struct mmc_omap_host *host, struct mmc_command *cmd) 553 { 554 host->cmd = NULL; 555 556 del_timer(&host->cmd_abort_timer); 557 558 if (cmd->flags & MMC_RSP_PRESENT) { 559 if (cmd->flags & MMC_RSP_136) { 560 /* response type 2 */ 561 cmd->resp[3] = 562 OMAP_MMC_READ(host, RSP0) | 563 (OMAP_MMC_READ(host, RSP1) << 16); 564 cmd->resp[2] = 565 OMAP_MMC_READ(host, RSP2) | 566 (OMAP_MMC_READ(host, RSP3) << 16); 567 cmd->resp[1] = 568 OMAP_MMC_READ(host, RSP4) | 569 (OMAP_MMC_READ(host, RSP5) << 16); 570 cmd->resp[0] = 571 OMAP_MMC_READ(host, RSP6) | 572 (OMAP_MMC_READ(host, RSP7) << 16); 573 } else { 574 /* response types 1, 1b, 3, 4, 5, 6 */ 575 cmd->resp[0] = 576 OMAP_MMC_READ(host, RSP6) | 577 (OMAP_MMC_READ(host, RSP7) << 16); 578 } 579 } 580 581 if (host->data == NULL || cmd->error) { 582 struct mmc_host *mmc; 583 584 if (host->data != NULL) 585 mmc_omap_abort_xfer(host, host->data); 586 host->mrq = NULL; 587 mmc = host->mmc; 588 mmc_omap_release_slot(host->current_slot, 1); 589 mmc_request_done(mmc, cmd->mrq); 590 } 591 } 592 593 /* 594 * Abort stuck command. Can occur when card is removed while it is being 595 * read. 596 */ 597 static void mmc_omap_abort_command(struct work_struct *work) 598 { 599 struct mmc_omap_host *host = container_of(work, struct mmc_omap_host, 600 cmd_abort_work); 601 BUG_ON(!host->cmd); 602 603 dev_dbg(mmc_dev(host->mmc), "Aborting stuck command CMD%d\n", 604 host->cmd->opcode); 605 606 if (host->cmd->error == 0) 607 host->cmd->error = -ETIMEDOUT; 608 609 if (host->data == NULL) { 610 struct mmc_command *cmd; 611 struct mmc_host *mmc; 612 613 cmd = host->cmd; 614 host->cmd = NULL; 615 mmc_omap_send_abort(host, 10000); 616 617 host->mrq = NULL; 618 mmc = host->mmc; 619 mmc_omap_release_slot(host->current_slot, 1); 620 mmc_request_done(mmc, cmd->mrq); 621 } else 622 mmc_omap_cmd_done(host, host->cmd); 623 624 host->abort = 0; 625 enable_irq(host->irq); 626 } 627 628 static void 629 mmc_omap_cmd_timer(struct timer_list *t) 630 { 631 struct mmc_omap_host *host = from_timer(host, t, cmd_abort_timer); 632 unsigned long flags; 633 634 spin_lock_irqsave(&host->slot_lock, flags); 635 if (host->cmd != NULL && !host->abort) { 636 OMAP_MMC_WRITE(host, IE, 0); 637 disable_irq(host->irq); 638 host->abort = 1; 639 queue_work(host->mmc_omap_wq, &host->cmd_abort_work); 640 } 641 spin_unlock_irqrestore(&host->slot_lock, flags); 642 } 643 644 /* PIO only */ 645 static void 646 mmc_omap_sg_to_buf(struct mmc_omap_host *host) 647 { 648 struct scatterlist *sg; 649 650 sg = host->data->sg + host->sg_idx; 651 host->buffer_bytes_left = sg->length; 652 host->buffer = sg_virt(sg); 653 if (host->buffer_bytes_left > host->total_bytes_left) 654 host->buffer_bytes_left = host->total_bytes_left; 655 } 656 657 static void 658 mmc_omap_clk_timer(struct timer_list *t) 659 { 660 struct mmc_omap_host *host = from_timer(host, t, clk_timer); 661 662 mmc_omap_fclk_enable(host, 0); 663 } 664 665 /* PIO only */ 666 static void 667 mmc_omap_xfer_data(struct mmc_omap_host *host, int write) 668 { 669 int n, nwords; 670 671 if (host->buffer_bytes_left == 0) { 672 host->sg_idx++; 673 BUG_ON(host->sg_idx == host->sg_len); 674 mmc_omap_sg_to_buf(host); 675 } 676 n = 64; 677 if (n > host->buffer_bytes_left) 678 n = host->buffer_bytes_left; 679 680 /* Round up to handle odd number of bytes to transfer */ 681 nwords = DIV_ROUND_UP(n, 2); 682 683 host->buffer_bytes_left -= n; 684 host->total_bytes_left -= n; 685 host->data->bytes_xfered += n; 686 687 if (write) { 688 __raw_writesw(host->virt_base + OMAP_MMC_REG(host, DATA), 689 host->buffer, nwords); 690 } else { 691 __raw_readsw(host->virt_base + OMAP_MMC_REG(host, DATA), 692 host->buffer, nwords); 693 } 694 695 host->buffer += nwords; 696 } 697 698 #ifdef CONFIG_MMC_DEBUG 699 static void mmc_omap_report_irq(struct mmc_omap_host *host, u16 status) 700 { 701 static const char *mmc_omap_status_bits[] = { 702 "EOC", "CD", "CB", "BRS", "EOFB", "DTO", "DCRC", "CTO", 703 "CCRC", "CRW", "AF", "AE", "OCRB", "CIRQ", "CERR" 704 }; 705 int i; 706 char res[64], *buf = res; 707 708 buf += sprintf(buf, "MMC IRQ 0x%x:", status); 709 710 for (i = 0; i < ARRAY_SIZE(mmc_omap_status_bits); i++) 711 if (status & (1 << i)) 712 buf += sprintf(buf, " %s", mmc_omap_status_bits[i]); 713 dev_vdbg(mmc_dev(host->mmc), "%s\n", res); 714 } 715 #else 716 static void mmc_omap_report_irq(struct mmc_omap_host *host, u16 status) 717 { 718 } 719 #endif 720 721 722 static irqreturn_t mmc_omap_irq(int irq, void *dev_id) 723 { 724 struct mmc_omap_host * host = (struct mmc_omap_host *)dev_id; 725 u16 status; 726 int end_command; 727 int end_transfer; 728 int transfer_error, cmd_error; 729 730 if (host->cmd == NULL && host->data == NULL) { 731 status = OMAP_MMC_READ(host, STAT); 732 dev_info(mmc_dev(host->slots[0]->mmc), 733 "Spurious IRQ 0x%04x\n", status); 734 if (status != 0) { 735 OMAP_MMC_WRITE(host, STAT, status); 736 OMAP_MMC_WRITE(host, IE, 0); 737 } 738 return IRQ_HANDLED; 739 } 740 741 end_command = 0; 742 end_transfer = 0; 743 transfer_error = 0; 744 cmd_error = 0; 745 746 while ((status = OMAP_MMC_READ(host, STAT)) != 0) { 747 int cmd; 748 749 OMAP_MMC_WRITE(host, STAT, status); 750 if (host->cmd != NULL) 751 cmd = host->cmd->opcode; 752 else 753 cmd = -1; 754 dev_dbg(mmc_dev(host->mmc), "MMC IRQ %04x (CMD %d): ", 755 status, cmd); 756 mmc_omap_report_irq(host, status); 757 758 if (host->total_bytes_left) { 759 if ((status & OMAP_MMC_STAT_A_FULL) || 760 (status & OMAP_MMC_STAT_END_OF_DATA)) 761 mmc_omap_xfer_data(host, 0); 762 if (status & OMAP_MMC_STAT_A_EMPTY) 763 mmc_omap_xfer_data(host, 1); 764 } 765 766 if (status & OMAP_MMC_STAT_END_OF_DATA) 767 end_transfer = 1; 768 769 if (status & OMAP_MMC_STAT_DATA_TOUT) { 770 dev_dbg(mmc_dev(host->mmc), "data timeout (CMD%d)\n", 771 cmd); 772 if (host->data) { 773 host->data->error = -ETIMEDOUT; 774 transfer_error = 1; 775 } 776 } 777 778 if (status & OMAP_MMC_STAT_DATA_CRC) { 779 if (host->data) { 780 host->data->error = -EILSEQ; 781 dev_dbg(mmc_dev(host->mmc), 782 "data CRC error, bytes left %d\n", 783 host->total_bytes_left); 784 transfer_error = 1; 785 } else { 786 dev_dbg(mmc_dev(host->mmc), "data CRC error\n"); 787 } 788 } 789 790 if (status & OMAP_MMC_STAT_CMD_TOUT) { 791 /* Timeouts are routine with some commands */ 792 if (host->cmd) { 793 struct mmc_omap_slot *slot = 794 host->current_slot; 795 if (slot == NULL || 796 !mmc_omap_cover_is_open(slot)) 797 dev_err(mmc_dev(host->mmc), 798 "command timeout (CMD%d)\n", 799 cmd); 800 host->cmd->error = -ETIMEDOUT; 801 end_command = 1; 802 cmd_error = 1; 803 } 804 } 805 806 if (status & OMAP_MMC_STAT_CMD_CRC) { 807 if (host->cmd) { 808 dev_err(mmc_dev(host->mmc), 809 "command CRC error (CMD%d, arg 0x%08x)\n", 810 cmd, host->cmd->arg); 811 host->cmd->error = -EILSEQ; 812 end_command = 1; 813 cmd_error = 1; 814 } else 815 dev_err(mmc_dev(host->mmc), 816 "command CRC error without cmd?\n"); 817 } 818 819 if (status & OMAP_MMC_STAT_CARD_ERR) { 820 dev_dbg(mmc_dev(host->mmc), 821 "ignoring card status error (CMD%d)\n", 822 cmd); 823 end_command = 1; 824 } 825 826 /* 827 * NOTE: On 1610 the END_OF_CMD may come too early when 828 * starting a write 829 */ 830 if ((status & OMAP_MMC_STAT_END_OF_CMD) && 831 (!(status & OMAP_MMC_STAT_A_EMPTY))) { 832 end_command = 1; 833 } 834 } 835 836 if (cmd_error && host->data) { 837 del_timer(&host->cmd_abort_timer); 838 host->abort = 1; 839 OMAP_MMC_WRITE(host, IE, 0); 840 disable_irq_nosync(host->irq); 841 queue_work(host->mmc_omap_wq, &host->cmd_abort_work); 842 return IRQ_HANDLED; 843 } 844 845 if (end_command && host->cmd) 846 mmc_omap_cmd_done(host, host->cmd); 847 if (host->data != NULL) { 848 if (transfer_error) 849 mmc_omap_xfer_done(host, host->data); 850 else if (end_transfer) 851 mmc_omap_end_of_data(host, host->data); 852 } 853 854 return IRQ_HANDLED; 855 } 856 857 void omap_mmc_notify_cover_event(struct device *dev, int num, int is_closed) 858 { 859 int cover_open; 860 struct mmc_omap_host *host = dev_get_drvdata(dev); 861 struct mmc_omap_slot *slot = host->slots[num]; 862 863 BUG_ON(num >= host->nr_slots); 864 865 /* Other subsystems can call in here before we're initialised. */ 866 if (host->nr_slots == 0 || !host->slots[num]) 867 return; 868 869 cover_open = mmc_omap_cover_is_open(slot); 870 if (cover_open != slot->cover_open) { 871 slot->cover_open = cover_open; 872 sysfs_notify(&slot->mmc->class_dev.kobj, NULL, "cover_switch"); 873 } 874 875 tasklet_hi_schedule(&slot->cover_tasklet); 876 } 877 878 static void mmc_omap_cover_timer(struct timer_list *t) 879 { 880 struct mmc_omap_slot *slot = from_timer(slot, t, cover_timer); 881 tasklet_schedule(&slot->cover_tasklet); 882 } 883 884 static void mmc_omap_cover_handler(unsigned long param) 885 { 886 struct mmc_omap_slot *slot = (struct mmc_omap_slot *)param; 887 int cover_open = mmc_omap_cover_is_open(slot); 888 889 mmc_detect_change(slot->mmc, 0); 890 if (!cover_open) 891 return; 892 893 /* 894 * If no card is inserted, we postpone polling until 895 * the cover has been closed. 896 */ 897 if (slot->mmc->card == NULL) 898 return; 899 900 mod_timer(&slot->cover_timer, 901 jiffies + msecs_to_jiffies(OMAP_MMC_COVER_POLL_DELAY)); 902 } 903 904 static void mmc_omap_dma_callback(void *priv) 905 { 906 struct mmc_omap_host *host = priv; 907 struct mmc_data *data = host->data; 908 909 /* If we got to the end of DMA, assume everything went well */ 910 data->bytes_xfered += data->blocks * data->blksz; 911 912 mmc_omap_dma_done(host, data); 913 } 914 915 static inline void set_cmd_timeout(struct mmc_omap_host *host, struct mmc_request *req) 916 { 917 u16 reg; 918 919 reg = OMAP_MMC_READ(host, SDIO); 920 reg &= ~(1 << 5); 921 OMAP_MMC_WRITE(host, SDIO, reg); 922 /* Set maximum timeout */ 923 OMAP_MMC_WRITE(host, CTO, 0xfd); 924 } 925 926 static inline void set_data_timeout(struct mmc_omap_host *host, struct mmc_request *req) 927 { 928 unsigned int timeout, cycle_ns; 929 u16 reg; 930 931 cycle_ns = 1000000000 / host->current_slot->fclk_freq; 932 timeout = req->data->timeout_ns / cycle_ns; 933 timeout += req->data->timeout_clks; 934 935 /* Check if we need to use timeout multiplier register */ 936 reg = OMAP_MMC_READ(host, SDIO); 937 if (timeout > 0xffff) { 938 reg |= (1 << 5); 939 timeout /= 1024; 940 } else 941 reg &= ~(1 << 5); 942 OMAP_MMC_WRITE(host, SDIO, reg); 943 OMAP_MMC_WRITE(host, DTO, timeout); 944 } 945 946 static void 947 mmc_omap_prepare_data(struct mmc_omap_host *host, struct mmc_request *req) 948 { 949 struct mmc_data *data = req->data; 950 int i, use_dma = 1, block_size; 951 struct scatterlist *sg; 952 unsigned sg_len; 953 954 host->data = data; 955 if (data == NULL) { 956 OMAP_MMC_WRITE(host, BLEN, 0); 957 OMAP_MMC_WRITE(host, NBLK, 0); 958 OMAP_MMC_WRITE(host, BUF, 0); 959 host->dma_in_use = 0; 960 set_cmd_timeout(host, req); 961 return; 962 } 963 964 block_size = data->blksz; 965 966 OMAP_MMC_WRITE(host, NBLK, data->blocks - 1); 967 OMAP_MMC_WRITE(host, BLEN, block_size - 1); 968 set_data_timeout(host, req); 969 970 /* cope with calling layer confusion; it issues "single 971 * block" writes using multi-block scatterlists. 972 */ 973 sg_len = (data->blocks == 1) ? 1 : data->sg_len; 974 975 /* Only do DMA for entire blocks */ 976 for_each_sg(data->sg, sg, sg_len, i) { 977 if ((sg->length % block_size) != 0) { 978 use_dma = 0; 979 break; 980 } 981 } 982 983 host->sg_idx = 0; 984 if (use_dma) { 985 enum dma_data_direction dma_data_dir; 986 struct dma_async_tx_descriptor *tx; 987 struct dma_chan *c; 988 u32 burst, *bp; 989 u16 buf; 990 991 /* 992 * FIFO is 16x2 bytes on 15xx, and 32x2 bytes on 16xx 993 * and 24xx. Use 16 or 32 word frames when the 994 * blocksize is at least that large. Blocksize is 995 * usually 512 bytes; but not for some SD reads. 996 */ 997 burst = mmc_omap15xx() ? 32 : 64; 998 if (burst > data->blksz) 999 burst = data->blksz; 1000 1001 burst >>= 1; 1002 1003 if (data->flags & MMC_DATA_WRITE) { 1004 c = host->dma_tx; 1005 bp = &host->dma_tx_burst; 1006 buf = 0x0f80 | (burst - 1) << 0; 1007 dma_data_dir = DMA_TO_DEVICE; 1008 } else { 1009 c = host->dma_rx; 1010 bp = &host->dma_rx_burst; 1011 buf = 0x800f | (burst - 1) << 8; 1012 dma_data_dir = DMA_FROM_DEVICE; 1013 } 1014 1015 if (!c) 1016 goto use_pio; 1017 1018 /* Only reconfigure if we have a different burst size */ 1019 if (*bp != burst) { 1020 struct dma_slave_config cfg = { 1021 .src_addr = host->phys_base + 1022 OMAP_MMC_REG(host, DATA), 1023 .dst_addr = host->phys_base + 1024 OMAP_MMC_REG(host, DATA), 1025 .src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES, 1026 .dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES, 1027 .src_maxburst = burst, 1028 .dst_maxburst = burst, 1029 }; 1030 1031 if (dmaengine_slave_config(c, &cfg)) 1032 goto use_pio; 1033 1034 *bp = burst; 1035 } 1036 1037 host->sg_len = dma_map_sg(c->device->dev, data->sg, sg_len, 1038 dma_data_dir); 1039 if (host->sg_len == 0) 1040 goto use_pio; 1041 1042 tx = dmaengine_prep_slave_sg(c, data->sg, host->sg_len, 1043 data->flags & MMC_DATA_WRITE ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM, 1044 DMA_PREP_INTERRUPT | DMA_CTRL_ACK); 1045 if (!tx) 1046 goto use_pio; 1047 1048 OMAP_MMC_WRITE(host, BUF, buf); 1049 1050 tx->callback = mmc_omap_dma_callback; 1051 tx->callback_param = host; 1052 dmaengine_submit(tx); 1053 host->brs_received = 0; 1054 host->dma_done = 0; 1055 host->dma_in_use = 1; 1056 return; 1057 } 1058 use_pio: 1059 1060 /* Revert to PIO? */ 1061 OMAP_MMC_WRITE(host, BUF, 0x1f1f); 1062 host->total_bytes_left = data->blocks * block_size; 1063 host->sg_len = sg_len; 1064 mmc_omap_sg_to_buf(host); 1065 host->dma_in_use = 0; 1066 } 1067 1068 static void mmc_omap_start_request(struct mmc_omap_host *host, 1069 struct mmc_request *req) 1070 { 1071 BUG_ON(host->mrq != NULL); 1072 1073 host->mrq = req; 1074 1075 /* only touch fifo AFTER the controller readies it */ 1076 mmc_omap_prepare_data(host, req); 1077 mmc_omap_start_command(host, req->cmd); 1078 if (host->dma_in_use) { 1079 struct dma_chan *c = host->data->flags & MMC_DATA_WRITE ? 1080 host->dma_tx : host->dma_rx; 1081 1082 dma_async_issue_pending(c); 1083 } 1084 } 1085 1086 static void mmc_omap_request(struct mmc_host *mmc, struct mmc_request *req) 1087 { 1088 struct mmc_omap_slot *slot = mmc_priv(mmc); 1089 struct mmc_omap_host *host = slot->host; 1090 unsigned long flags; 1091 1092 spin_lock_irqsave(&host->slot_lock, flags); 1093 if (host->mmc != NULL) { 1094 BUG_ON(slot->mrq != NULL); 1095 slot->mrq = req; 1096 spin_unlock_irqrestore(&host->slot_lock, flags); 1097 return; 1098 } else 1099 host->mmc = mmc; 1100 spin_unlock_irqrestore(&host->slot_lock, flags); 1101 mmc_omap_select_slot(slot, 1); 1102 mmc_omap_start_request(host, req); 1103 } 1104 1105 static void mmc_omap_set_power(struct mmc_omap_slot *slot, int power_on, 1106 int vdd) 1107 { 1108 struct mmc_omap_host *host; 1109 1110 host = slot->host; 1111 1112 if (slot->pdata->set_power != NULL) 1113 slot->pdata->set_power(mmc_dev(slot->mmc), slot->id, power_on, 1114 vdd); 1115 if (mmc_omap2()) { 1116 u16 w; 1117 1118 if (power_on) { 1119 w = OMAP_MMC_READ(host, CON); 1120 OMAP_MMC_WRITE(host, CON, w | (1 << 11)); 1121 } else { 1122 w = OMAP_MMC_READ(host, CON); 1123 OMAP_MMC_WRITE(host, CON, w & ~(1 << 11)); 1124 } 1125 } 1126 } 1127 1128 static int mmc_omap_calc_divisor(struct mmc_host *mmc, struct mmc_ios *ios) 1129 { 1130 struct mmc_omap_slot *slot = mmc_priv(mmc); 1131 struct mmc_omap_host *host = slot->host; 1132 int func_clk_rate = clk_get_rate(host->fclk); 1133 int dsor; 1134 1135 if (ios->clock == 0) 1136 return 0; 1137 1138 dsor = func_clk_rate / ios->clock; 1139 if (dsor < 1) 1140 dsor = 1; 1141 1142 if (func_clk_rate / dsor > ios->clock) 1143 dsor++; 1144 1145 if (dsor > 250) 1146 dsor = 250; 1147 1148 slot->fclk_freq = func_clk_rate / dsor; 1149 1150 if (ios->bus_width == MMC_BUS_WIDTH_4) 1151 dsor |= 1 << 15; 1152 1153 return dsor; 1154 } 1155 1156 static void mmc_omap_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) 1157 { 1158 struct mmc_omap_slot *slot = mmc_priv(mmc); 1159 struct mmc_omap_host *host = slot->host; 1160 int i, dsor; 1161 int clk_enabled, init_stream; 1162 1163 mmc_omap_select_slot(slot, 0); 1164 1165 dsor = mmc_omap_calc_divisor(mmc, ios); 1166 1167 if (ios->vdd != slot->vdd) 1168 slot->vdd = ios->vdd; 1169 1170 clk_enabled = 0; 1171 init_stream = 0; 1172 switch (ios->power_mode) { 1173 case MMC_POWER_OFF: 1174 mmc_omap_set_power(slot, 0, ios->vdd); 1175 break; 1176 case MMC_POWER_UP: 1177 /* Cannot touch dsor yet, just power up MMC */ 1178 mmc_omap_set_power(slot, 1, ios->vdd); 1179 slot->power_mode = ios->power_mode; 1180 goto exit; 1181 case MMC_POWER_ON: 1182 mmc_omap_fclk_enable(host, 1); 1183 clk_enabled = 1; 1184 dsor |= 1 << 11; 1185 if (slot->power_mode != MMC_POWER_ON) 1186 init_stream = 1; 1187 break; 1188 } 1189 slot->power_mode = ios->power_mode; 1190 1191 if (slot->bus_mode != ios->bus_mode) { 1192 if (slot->pdata->set_bus_mode != NULL) 1193 slot->pdata->set_bus_mode(mmc_dev(mmc), slot->id, 1194 ios->bus_mode); 1195 slot->bus_mode = ios->bus_mode; 1196 } 1197 1198 /* On insanely high arm_per frequencies something sometimes 1199 * goes somehow out of sync, and the POW bit is not being set, 1200 * which results in the while loop below getting stuck. 1201 * Writing to the CON register twice seems to do the trick. */ 1202 for (i = 0; i < 2; i++) 1203 OMAP_MMC_WRITE(host, CON, dsor); 1204 slot->saved_con = dsor; 1205 if (init_stream) { 1206 /* worst case at 400kHz, 80 cycles makes 200 microsecs */ 1207 int usecs = 250; 1208 1209 /* Send clock cycles, poll completion */ 1210 OMAP_MMC_WRITE(host, IE, 0); 1211 OMAP_MMC_WRITE(host, STAT, 0xffff); 1212 OMAP_MMC_WRITE(host, CMD, 1 << 7); 1213 while (usecs > 0 && (OMAP_MMC_READ(host, STAT) & 1) == 0) { 1214 udelay(1); 1215 usecs--; 1216 } 1217 OMAP_MMC_WRITE(host, STAT, 1); 1218 } 1219 1220 exit: 1221 mmc_omap_release_slot(slot, clk_enabled); 1222 } 1223 1224 static const struct mmc_host_ops mmc_omap_ops = { 1225 .request = mmc_omap_request, 1226 .set_ios = mmc_omap_set_ios, 1227 }; 1228 1229 static int mmc_omap_new_slot(struct mmc_omap_host *host, int id) 1230 { 1231 struct mmc_omap_slot *slot = NULL; 1232 struct mmc_host *mmc; 1233 int r; 1234 1235 mmc = mmc_alloc_host(sizeof(struct mmc_omap_slot), host->dev); 1236 if (mmc == NULL) 1237 return -ENOMEM; 1238 1239 slot = mmc_priv(mmc); 1240 slot->host = host; 1241 slot->mmc = mmc; 1242 slot->id = id; 1243 slot->power_mode = MMC_POWER_UNDEFINED; 1244 slot->pdata = &host->pdata->slots[id]; 1245 1246 host->slots[id] = slot; 1247 1248 mmc->caps = 0; 1249 if (host->pdata->slots[id].wires >= 4) 1250 mmc->caps |= MMC_CAP_4_BIT_DATA | MMC_CAP_ERASE; 1251 1252 mmc->ops = &mmc_omap_ops; 1253 mmc->f_min = 400000; 1254 1255 if (mmc_omap2()) 1256 mmc->f_max = 48000000; 1257 else 1258 mmc->f_max = 24000000; 1259 if (host->pdata->max_freq) 1260 mmc->f_max = min(host->pdata->max_freq, mmc->f_max); 1261 mmc->ocr_avail = slot->pdata->ocr_mask; 1262 1263 /* Use scatterlist DMA to reduce per-transfer costs. 1264 * NOTE max_seg_size assumption that small blocks aren't 1265 * normally used (except e.g. for reading SD registers). 1266 */ 1267 mmc->max_segs = 32; 1268 mmc->max_blk_size = 2048; /* BLEN is 11 bits (+1) */ 1269 mmc->max_blk_count = 2048; /* NBLK is 11 bits (+1) */ 1270 mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count; 1271 mmc->max_seg_size = mmc->max_req_size; 1272 1273 if (slot->pdata->get_cover_state != NULL) { 1274 timer_setup(&slot->cover_timer, mmc_omap_cover_timer, 0); 1275 tasklet_init(&slot->cover_tasklet, mmc_omap_cover_handler, 1276 (unsigned long)slot); 1277 } 1278 1279 r = mmc_add_host(mmc); 1280 if (r < 0) 1281 goto err_remove_host; 1282 1283 if (slot->pdata->name != NULL) { 1284 r = device_create_file(&mmc->class_dev, 1285 &dev_attr_slot_name); 1286 if (r < 0) 1287 goto err_remove_host; 1288 } 1289 1290 if (slot->pdata->get_cover_state != NULL) { 1291 r = device_create_file(&mmc->class_dev, 1292 &dev_attr_cover_switch); 1293 if (r < 0) 1294 goto err_remove_slot_name; 1295 tasklet_schedule(&slot->cover_tasklet); 1296 } 1297 1298 return 0; 1299 1300 err_remove_slot_name: 1301 if (slot->pdata->name != NULL) 1302 device_remove_file(&mmc->class_dev, &dev_attr_slot_name); 1303 err_remove_host: 1304 mmc_remove_host(mmc); 1305 mmc_free_host(mmc); 1306 return r; 1307 } 1308 1309 static void mmc_omap_remove_slot(struct mmc_omap_slot *slot) 1310 { 1311 struct mmc_host *mmc = slot->mmc; 1312 1313 if (slot->pdata->name != NULL) 1314 device_remove_file(&mmc->class_dev, &dev_attr_slot_name); 1315 if (slot->pdata->get_cover_state != NULL) 1316 device_remove_file(&mmc->class_dev, &dev_attr_cover_switch); 1317 1318 tasklet_kill(&slot->cover_tasklet); 1319 del_timer_sync(&slot->cover_timer); 1320 flush_workqueue(slot->host->mmc_omap_wq); 1321 1322 mmc_remove_host(mmc); 1323 mmc_free_host(mmc); 1324 } 1325 1326 static int mmc_omap_probe(struct platform_device *pdev) 1327 { 1328 struct omap_mmc_platform_data *pdata = pdev->dev.platform_data; 1329 struct mmc_omap_host *host = NULL; 1330 struct resource *res; 1331 int i, ret = 0; 1332 int irq; 1333 1334 if (pdata == NULL) { 1335 dev_err(&pdev->dev, "platform data missing\n"); 1336 return -ENXIO; 1337 } 1338 if (pdata->nr_slots == 0) { 1339 dev_err(&pdev->dev, "no slots\n"); 1340 return -EPROBE_DEFER; 1341 } 1342 1343 host = devm_kzalloc(&pdev->dev, sizeof(struct mmc_omap_host), 1344 GFP_KERNEL); 1345 if (host == NULL) 1346 return -ENOMEM; 1347 1348 irq = platform_get_irq(pdev, 0); 1349 if (irq < 0) 1350 return -ENXIO; 1351 1352 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1353 host->virt_base = devm_ioremap_resource(&pdev->dev, res); 1354 if (IS_ERR(host->virt_base)) 1355 return PTR_ERR(host->virt_base); 1356 1357 INIT_WORK(&host->slot_release_work, mmc_omap_slot_release_work); 1358 INIT_WORK(&host->send_stop_work, mmc_omap_send_stop_work); 1359 1360 INIT_WORK(&host->cmd_abort_work, mmc_omap_abort_command); 1361 timer_setup(&host->cmd_abort_timer, mmc_omap_cmd_timer, 0); 1362 1363 spin_lock_init(&host->clk_lock); 1364 timer_setup(&host->clk_timer, mmc_omap_clk_timer, 0); 1365 1366 spin_lock_init(&host->dma_lock); 1367 spin_lock_init(&host->slot_lock); 1368 init_waitqueue_head(&host->slot_wq); 1369 1370 host->pdata = pdata; 1371 host->features = host->pdata->slots[0].features; 1372 host->dev = &pdev->dev; 1373 platform_set_drvdata(pdev, host); 1374 1375 host->id = pdev->id; 1376 host->irq = irq; 1377 host->phys_base = res->start; 1378 host->iclk = clk_get(&pdev->dev, "ick"); 1379 if (IS_ERR(host->iclk)) 1380 return PTR_ERR(host->iclk); 1381 clk_enable(host->iclk); 1382 1383 host->fclk = clk_get(&pdev->dev, "fck"); 1384 if (IS_ERR(host->fclk)) { 1385 ret = PTR_ERR(host->fclk); 1386 goto err_free_iclk; 1387 } 1388 1389 host->dma_tx_burst = -1; 1390 host->dma_rx_burst = -1; 1391 1392 host->dma_tx = dma_request_chan(&pdev->dev, "tx"); 1393 if (IS_ERR(host->dma_tx)) { 1394 ret = PTR_ERR(host->dma_tx); 1395 if (ret == -EPROBE_DEFER) { 1396 clk_put(host->fclk); 1397 goto err_free_iclk; 1398 } 1399 1400 host->dma_tx = NULL; 1401 dev_warn(host->dev, "TX DMA channel request failed\n"); 1402 } 1403 1404 host->dma_rx = dma_request_chan(&pdev->dev, "rx"); 1405 if (IS_ERR(host->dma_rx)) { 1406 ret = PTR_ERR(host->dma_rx); 1407 if (ret == -EPROBE_DEFER) { 1408 if (host->dma_tx) 1409 dma_release_channel(host->dma_tx); 1410 clk_put(host->fclk); 1411 goto err_free_iclk; 1412 } 1413 1414 host->dma_rx = NULL; 1415 dev_warn(host->dev, "RX DMA channel request failed\n"); 1416 } 1417 1418 ret = request_irq(host->irq, mmc_omap_irq, 0, DRIVER_NAME, host); 1419 if (ret) 1420 goto err_free_dma; 1421 1422 if (pdata->init != NULL) { 1423 ret = pdata->init(&pdev->dev); 1424 if (ret < 0) 1425 goto err_free_irq; 1426 } 1427 1428 host->nr_slots = pdata->nr_slots; 1429 host->reg_shift = (mmc_omap7xx() ? 1 : 2); 1430 1431 host->mmc_omap_wq = alloc_workqueue("mmc_omap", 0, 0); 1432 if (!host->mmc_omap_wq) { 1433 ret = -ENOMEM; 1434 goto err_plat_cleanup; 1435 } 1436 1437 for (i = 0; i < pdata->nr_slots; i++) { 1438 ret = mmc_omap_new_slot(host, i); 1439 if (ret < 0) { 1440 while (--i >= 0) 1441 mmc_omap_remove_slot(host->slots[i]); 1442 1443 goto err_destroy_wq; 1444 } 1445 } 1446 1447 return 0; 1448 1449 err_destroy_wq: 1450 destroy_workqueue(host->mmc_omap_wq); 1451 err_plat_cleanup: 1452 if (pdata->cleanup) 1453 pdata->cleanup(&pdev->dev); 1454 err_free_irq: 1455 free_irq(host->irq, host); 1456 err_free_dma: 1457 if (host->dma_tx) 1458 dma_release_channel(host->dma_tx); 1459 if (host->dma_rx) 1460 dma_release_channel(host->dma_rx); 1461 clk_put(host->fclk); 1462 err_free_iclk: 1463 clk_disable(host->iclk); 1464 clk_put(host->iclk); 1465 return ret; 1466 } 1467 1468 static int mmc_omap_remove(struct platform_device *pdev) 1469 { 1470 struct mmc_omap_host *host = platform_get_drvdata(pdev); 1471 int i; 1472 1473 BUG_ON(host == NULL); 1474 1475 for (i = 0; i < host->nr_slots; i++) 1476 mmc_omap_remove_slot(host->slots[i]); 1477 1478 if (host->pdata->cleanup) 1479 host->pdata->cleanup(&pdev->dev); 1480 1481 mmc_omap_fclk_enable(host, 0); 1482 free_irq(host->irq, host); 1483 clk_put(host->fclk); 1484 clk_disable(host->iclk); 1485 clk_put(host->iclk); 1486 1487 if (host->dma_tx) 1488 dma_release_channel(host->dma_tx); 1489 if (host->dma_rx) 1490 dma_release_channel(host->dma_rx); 1491 1492 destroy_workqueue(host->mmc_omap_wq); 1493 1494 return 0; 1495 } 1496 1497 #if IS_BUILTIN(CONFIG_OF) 1498 static const struct of_device_id mmc_omap_match[] = { 1499 { .compatible = "ti,omap2420-mmc", }, 1500 { }, 1501 }; 1502 MODULE_DEVICE_TABLE(of, mmc_omap_match); 1503 #endif 1504 1505 static struct platform_driver mmc_omap_driver = { 1506 .probe = mmc_omap_probe, 1507 .remove = mmc_omap_remove, 1508 .driver = { 1509 .name = DRIVER_NAME, 1510 .of_match_table = of_match_ptr(mmc_omap_match), 1511 }, 1512 }; 1513 1514 module_platform_driver(mmc_omap_driver); 1515 MODULE_DESCRIPTION("OMAP Multimedia Card driver"); 1516 MODULE_LICENSE("GPL"); 1517 MODULE_ALIAS("platform:" DRIVER_NAME); 1518 MODULE_AUTHOR("Juha Yrjölä"); 1519