Lines Matching refs:host
37 #include <linux/mmc/host.h>
44 #include "host.h"
96 static void mmc_should_fail_request(struct mmc_host *host,
111 !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
120 static inline void mmc_should_fail_request(struct mmc_host *host,
129 * @host: MMC host which completed request
135 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
140 if (err && cmd->retries && mmc_host_is_spi(host)) {
145 if (err && cmd->retries && !mmc_card_removed(host->card)) {
153 mmc_should_fail_request(host, mrq);
155 led_trigger_event(host->led, LED_OFF);
158 mmc_hostname(host), cmd->opcode, err,
164 mmc_hostname(host),
171 mmc_hostname(host), mrq->stop->opcode,
180 mmc_host_clk_release(host);
187 mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
196 mmc_hostname(host), mrq->sbc->opcode,
201 mmc_hostname(host), mrq->cmd->opcode,
207 mmc_hostname(host), mrq->data->blksz,
215 mmc_hostname(host), mrq->stop->opcode,
219 WARN_ON(!host->claimed);
224 BUG_ON(mrq->data->blksz > host->max_blk_size);
225 BUG_ON(mrq->data->blocks > host->max_blk_count);
227 host->max_req_size);
245 mmc_host_clk_hold(host);
246 led_trigger_event(host->led, LED_FULL);
247 host->ops->request(host, mrq);
274 mmc_hostname(card->host), err);
285 mmc_claim_host(card->host);
299 mmc_hostname(card->host), err);
311 mmc_release_host(card->host);
319 * Wakes up mmc context, passed as a callback to host controller driver
323 mrq->host->context_info.is_done_rcv = true;
324 wake_up_interruptible(&mrq->host->context_info.wait);
334 * @host: MMC host to start the request
340 static int __mmc_start_data_req(struct mmc_host *host, struct mmc_request *mrq)
343 mrq->host = host;
344 if (mmc_card_removed(host->card)) {
349 mmc_start_request(host, mrq);
354 static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq)
358 if (mmc_card_removed(host->card)) {
363 mmc_start_request(host, mrq);
369 * @host: MMC host to prepare the command.
372 * Blocks MMC context till host controller will ack end of data request
378 static int mmc_wait_for_data_req_done(struct mmc_host *host,
383 struct mmc_context_info *context_info = &host->context_info;
400 mmc_card_removed(host->card)) {
401 err = host->areq->err_check(host->card,
402 host->areq);
406 mmc_hostname(host),
410 host->ops->request(host, mrq);
424 static void mmc_wait_for_req_done(struct mmc_host *host,
435 * If host has timed out waiting for the sanitize
441 if (!mmc_interrupt_hpi(host->card)) {
443 mmc_hostname(host), __func__);
448 mmc_hostname(host), __func__);
452 mmc_card_removed(host->card))
456 mmc_hostname(host), cmd->opcode, cmd->error);
459 host->ops->request(host, mrq);
465 * @host: MMC host to prepare command
471 * host prepare for the new request. Preparation of a request may be
472 * performed while another request is running on the host.
474 static void mmc_pre_req(struct mmc_host *host, struct mmc_request *mrq,
477 if (host->ops->pre_req) {
478 mmc_host_clk_hold(host);
479 host->ops->pre_req(host, mrq, is_first_req);
480 mmc_host_clk_release(host);
486 * @host: MMC host to post process command
490 * Let the host post process a completed request. Post processing of
493 static void mmc_post_req(struct mmc_host *host, struct mmc_request *mrq,
496 if (host->ops->post_req) {
497 mmc_host_clk_hold(host);
498 host->ops->post_req(host, mrq, err);
499 mmc_host_clk_release(host);
505 * @host: MMC host to start command
509 * Start a new MMC custom command request for a host.
519 struct mmc_async_req *mmc_start_req(struct mmc_host *host,
524 struct mmc_async_req *data = host->areq;
528 mmc_pre_req(host, areq->mrq, !host->areq);
530 if (host->areq) {
531 err = mmc_wait_for_data_req_done(host, host->areq->mrq, areq);
544 if (host->card && mmc_card_mmc(host->card) &&
545 ((mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1) ||
546 (mmc_resp_type(host->areq->mrq->cmd) == MMC_RSP_R1B)) &&
547 (host->areq->mrq->cmd->resp[0] & R1_EXCEPTION_EVENT))
548 mmc_start_bkops(host->card, true);
555 start_err = __mmc_start_data_req(host, areq->mrq);
558 if (host->areq)
559 mmc_post_req(host, host->areq->mrq, 0);
563 mmc_post_req(host, areq->mrq, -EINVAL);
566 host->areq = NULL;
568 host->areq = areq;
578 * @host: MMC host to start command
581 * Start a new MMC custom command request for a host, and wait
585 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)
587 __mmc_start_req(host, mrq);
588 mmc_wait_for_req_done(host, mrq);
608 pr_info("%s: HPI enable bit unset\n", mmc_hostname(card->host));
612 mmc_claim_host(card->host);
615 pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
634 mmc_hostname(card->host), R1_CURRENT_STATE(status));
654 mmc_release_host(card->host);
661 * @host: MMC host to start command
665 * Start a new MMC command for a host, and wait for the command
669 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)
673 WARN_ON(!host->claimed);
681 mmc_wait_for_req(host, &mrq);
728 mmc_hostname(card->host));
732 mmc_claim_host(card->host);
734 mmc_release_host(card->host);
789 if (mmc_host_clk_rate(card->host))
791 (mmc_host_clk_rate(card->host) / 1000);
836 if (mmc_host_is_spi(card->host)) {
876 * __mmc_claim_host - exclusively claim a host
877 * @host: mmc host to claim
880 * Claim a host for a set of operations. If @abort is non null and
885 int __mmc_claim_host(struct mmc_host *host, atomic_t *abort)
893 add_wait_queue(&host->wq, &wait);
894 spin_lock_irqsave(&host->lock, flags);
898 if (stop || !host->claimed || host->claimer == current)
900 spin_unlock_irqrestore(&host->lock, flags);
902 spin_lock_irqsave(&host->lock, flags);
906 host->claimed = 1;
907 host->claimer = current;
908 host->claim_cnt += 1;
910 wake_up(&host->wq);
911 spin_unlock_irqrestore(&host->lock, flags);
912 remove_wait_queue(&host->wq, &wait);
913 if (host->ops->enable && !stop && host->claim_cnt == 1)
914 host->ops->enable(host);
921 * mmc_release_host - release a host
922 * @host: mmc host to release
924 * Release a MMC host, allowing others to claim the host
927 void mmc_release_host(struct mmc_host *host)
931 WARN_ON(!host->claimed);
933 if (host->ops->disable && host->claim_cnt == 1)
934 host->ops->disable(host);
936 spin_lock_irqsave(&host->lock, flags);
937 if (--host->claim_cnt) {
939 spin_unlock_irqrestore(&host->lock, flags);
941 host->claimed = 0;
942 host->claimer = NULL;
943 spin_unlock_irqrestore(&host->lock, flags);
944 wake_up(&host->wq);
951 * card device and also claims the host.
956 mmc_claim_host(card->host);
961 * This is a helper function, which releases the host and drops the runtime
966 mmc_release_host(card->host);
973 * Internal function that does the actual ios call to the host driver,
976 static inline void mmc_set_ios(struct mmc_host *host)
978 struct mmc_ios *ios = &host->ios;
982 mmc_hostname(host), ios->clock, ios->bus_mode,
987 mmc_set_ungated(host);
988 host->ops->set_ios(host, ios);
992 * Control chip select pin on a host.
994 void mmc_set_chip_select(struct mmc_host *host, int mode)
996 mmc_host_clk_hold(host);
997 host->ios.chip_select = mode;
998 mmc_set_ios(host);
999 mmc_host_clk_release(host);
1003 * Sets the host clock to the highest possible frequency that
1006 static void __mmc_set_clock(struct mmc_host *host, unsigned int hz)
1008 WARN_ON(hz && hz < host->f_min);
1010 if (hz > host->f_max)
1011 hz = host->f_max;
1013 host->ios.clock = hz;
1014 mmc_set_ios(host);
1017 void mmc_set_clock(struct mmc_host *host, unsigned int hz)
1019 mmc_host_clk_hold(host);
1020 __mmc_set_clock(host, hz);
1021 mmc_host_clk_release(host);
1028 void mmc_gate_clock(struct mmc_host *host)
1032 spin_lock_irqsave(&host->clk_lock, flags);
1033 host->clk_old = host->ios.clock;
1034 host->ios.clock = 0;
1035 host->clk_gated = true;
1036 spin_unlock_irqrestore(&host->clk_lock, flags);
1037 mmc_set_ios(host);
1044 void mmc_ungate_clock(struct mmc_host *host)
1053 if (host->clk_old) {
1054 BUG_ON(host->ios.clock);
1055 /* This call will also set host->clk_gated to false */
1056 __mmc_set_clock(host, host->clk_old);
1060 void mmc_set_ungated(struct mmc_host *host)
1068 spin_lock_irqsave(&host->clk_lock, flags);
1069 host->clk_gated = false;
1070 spin_unlock_irqrestore(&host->clk_lock, flags);
1074 void mmc_set_ungated(struct mmc_host *host)
1080 * Change the bus mode (open drain/push-pull) of a host.
1082 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)
1084 mmc_host_clk_hold(host);
1085 host->ios.bus_mode = mode;
1086 mmc_set_ios(host);
1087 mmc_host_clk_release(host);
1091 * Change data bus width of a host.
1093 void mmc_set_bus_width(struct mmc_host *host, unsigned int width)
1095 mmc_host_clk_hold(host);
1096 host->ios.bus_width = width;
1097 mmc_set_ios(host);
1098 mmc_host_clk_release(host);
1227 * MMC host adapter.
1264 * mmc_regulator_set_ocr - set regulator to match host->ios voltage
1265 * @mmc: the host to regulate
1267 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
1271 * MMC host drivers may use this to enable or disable a regulator using
1355 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)
1364 dev_warn(mmc_dev(host),
1369 ocr &= host->ocr_avail;
1371 dev_warn(mmc_dev(host), "no support for card's volts\n");
1375 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) {
1378 mmc_power_cycle(host, ocr);
1382 if (bit != host->ios.vdd)
1383 dev_warn(mmc_dev(host), "exceeding card's volts\n");
1389 int __mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage)
1392 int old_signal_voltage = host->ios.signal_voltage;
1394 host->ios.signal_voltage = signal_voltage;
1395 if (host->ops->start_signal_voltage_switch) {
1396 mmc_host_clk_hold(host);
1397 err = host->ops->start_signal_voltage_switch(host, &host->ios);
1398 mmc_host_clk_release(host);
1402 host->ios.signal_voltage = old_signal_voltage;
1408 int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, u32 ocr)
1414 BUG_ON(!host);
1421 return __mmc_set_signal_voltage(host, signal_voltage);
1427 if (!host->ops->start_signal_voltage_switch)
1429 if (!host->ops->card_busy)
1431 mmc_hostname(host));
1437 err = mmc_wait_for_cmd(host, &cmd, 0);
1441 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR))
1444 mmc_host_clk_hold(host);
1450 if (host->ops->card_busy && !host->ops->card_busy(host)) {
1458 clock = host->ios.clock;
1459 host->ios.clock = 0;
1460 mmc_set_ios(host);
1462 if (__mmc_set_signal_voltage(host, signal_voltage)) {
1473 host->ios.clock = clock;
1474 mmc_set_ios(host);
1483 if (host->ops->card_busy && host->ops->card_busy(host))
1489 "power cycling card\n", mmc_hostname(host));
1490 mmc_power_cycle(host, ocr);
1493 mmc_host_clk_release(host);
1499 * Select timing parameters for host.
1501 void mmc_set_timing(struct mmc_host *host, unsigned int timing)
1503 mmc_host_clk_hold(host);
1504 host->ios.timing = timing;
1505 mmc_set_ios(host);
1506 mmc_host_clk_release(host);
1510 * Select appropriate driver type for host.
1512 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type)
1514 mmc_host_clk_hold(host);
1515 host->ios.drv_type = drv_type;
1516 mmc_set_ios(host);
1517 mmc_host_clk_release(host);
1528 * If a host does all the power sequencing itself, ignore the
1531 void mmc_power_up(struct mmc_host *host, u32 ocr)
1533 if (host->ios.power_mode == MMC_POWER_ON)
1536 mmc_host_clk_hold(host);
1538 host->ios.vdd = fls(ocr) - 1;
1539 if (mmc_host_is_spi(host))
1540 host->ios.chip_select = MMC_CS_HIGH;
1542 host->ios.chip_select = MMC_CS_DONTCARE;
1543 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
1544 host->ios.power_mode = MMC_POWER_UP;
1545 host->ios.bus_width = MMC_BUS_WIDTH_1;
1546 host->ios.timing = MMC_TIMING_LEGACY;
1547 mmc_set_ios(host);
1550 if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330) == 0)
1551 dev_dbg(mmc_dev(host), "Initial signal voltage of 3.3v\n");
1552 else if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180) == 0)
1553 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.8v\n");
1554 else if (__mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120) == 0)
1555 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.2v\n");
1563 host->ios.clock = host->f_init;
1565 host->ios.power_mode = MMC_POWER_ON;
1566 mmc_set_ios(host);
1574 mmc_host_clk_release(host);
1577 void mmc_power_off(struct mmc_host *host)
1579 if (host->ios.power_mode == MMC_POWER_OFF)
1582 mmc_host_clk_hold(host);
1584 host->ios.clock = 0;
1585 host->ios.vdd = 0;
1587 if (!mmc_host_is_spi(host)) {
1588 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
1589 host->ios.chip_select = MMC_CS_DONTCARE;
1591 host->ios.power_mode = MMC_POWER_OFF;
1592 host->ios.bus_width = MMC_BUS_WIDTH_1;
1593 host->ios.timing = MMC_TIMING_LEGACY;
1594 mmc_set_ios(host);
1603 mmc_host_clk_release(host);
1606 void mmc_power_cycle(struct mmc_host *host, u32 ocr)
1608 mmc_power_off(host);
1611 mmc_power_up(host, ocr);
1617 static void __mmc_release_bus(struct mmc_host *host)
1619 BUG_ON(!host);
1620 BUG_ON(host->bus_refs);
1621 BUG_ON(!host->bus_dead);
1623 host->bus_ops = NULL;
1629 static inline void mmc_bus_get(struct mmc_host *host)
1633 spin_lock_irqsave(&host->lock, flags);
1634 host->bus_refs++;
1635 spin_unlock_irqrestore(&host->lock, flags);
1642 static inline void mmc_bus_put(struct mmc_host *host)
1646 spin_lock_irqsave(&host->lock, flags);
1647 host->bus_refs--;
1648 if ((host->bus_refs == 0) && host->bus_ops)
1649 __mmc_release_bus(host);
1650 spin_unlock_irqrestore(&host->lock, flags);
1654 * Assign a mmc bus handler to a host. Only one bus handler may control a
1655 * host at any given time.
1657 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)
1661 BUG_ON(!host);
1664 WARN_ON(!host->claimed);
1666 spin_lock_irqsave(&host->lock, flags);
1668 BUG_ON(host->bus_ops);
1669 BUG_ON(host->bus_refs);
1671 host->bus_ops = ops;
1672 host->bus_refs = 1;
1673 host->bus_dead = 0;
1675 spin_unlock_irqrestore(&host->lock, flags);
1679 * Remove the current bus handler from a host.
1681 void mmc_detach_bus(struct mmc_host *host)
1685 BUG_ON(!host);
1687 WARN_ON(!host->claimed);
1688 WARN_ON(!host->bus_ops);
1690 spin_lock_irqsave(&host->lock, flags);
1692 host->bus_dead = 1;
1694 spin_unlock_irqrestore(&host->lock, flags);
1696 mmc_bus_put(host);
1699 static void _mmc_detect_change(struct mmc_host *host, unsigned long delay,
1704 spin_lock_irqsave(&host->lock, flags);
1705 WARN_ON(host->removed);
1706 spin_unlock_irqrestore(&host->lock, flags);
1713 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL) &&
1714 device_can_wakeup(mmc_dev(host)))
1715 pm_wakeup_event(mmc_dev(host), 5000);
1717 host->detect_change = 1;
1718 mmc_schedule_delayed_work(&host->detect, delay);
1723 * @host: host which changed state.
1731 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
1733 _mmc_detect_change(host, delay, true);
1819 (mmc_host_clk_rate(card->host) / 1000);
1845 if (mmc_host_is_spi(card->host) && erase_timeout < 1000)
1935 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1950 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1963 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1971 if (mmc_host_is_spi(card->host))
1981 err = mmc_wait_for_cmd(card->host, &cmd, 0);
1994 mmc_hostname(card->host), __func__);
2014 * Caller must claim host before calling this function.
2021 if (!(card->host->caps & MMC_CAP_ERASE) ||
2076 if ((card->host->caps & MMC_CAP_ERASE) &&
2136 struct mmc_host *host = card->host;
2152 if (timeout > host->max_busy_timeout)
2181 struct mmc_host *host = card->host;
2184 if (!host->max_busy_timeout)
2204 mmc_hostname(host), max_discard, host->max_busy_timeout);
2219 return mmc_wait_for_cmd(card->host, &cmd, 5);
2233 return mmc_wait_for_cmd(card->host, &cmd, 5);
2237 static void mmc_hw_reset_for_init(struct mmc_host *host)
2239 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
2241 mmc_host_clk_hold(host);
2242 host->ops->hw_reset(host);
2243 mmc_host_clk_release(host);
2259 static int mmc_do_hw_reset(struct mmc_host *host, int check)
2261 struct mmc_card *card = host->card;
2263 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset)
2272 mmc_host_clk_hold(host);
2273 mmc_set_clock(host, host->f_init);
2275 host->ops->hw_reset(host);
2283 if (!mmc_host_is_spi(card->host))
2286 err = mmc_wait_for_cmd(card->host, &cmd, 0);
2288 mmc_host_clk_release(host);
2293 if (mmc_host_is_spi(host)) {
2294 host->ios.chip_select = MMC_CS_HIGH;
2295 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;
2297 host->ios.chip_select = MMC_CS_DONTCARE;
2298 host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN;
2300 host->ios.bus_width = MMC_BUS_WIDTH_1;
2301 host->ios.timing = MMC_TIMING_LEGACY;
2302 mmc_set_ios(host);
2304 mmc_host_clk_release(host);
2306 return host->bus_ops->power_restore(host);
2309 int mmc_hw_reset(struct mmc_host *host)
2311 return mmc_do_hw_reset(host, 0);
2315 int mmc_hw_reset_check(struct mmc_host *host)
2317 return mmc_do_hw_reset(host, 1);
2321 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)
2323 host->f_init = freq;
2327 mmc_hostname(host), __func__, host->f_init);
2329 mmc_power_up(host, host->ocr_avail);
2335 mmc_hw_reset_for_init(host);
2342 sdio_reset(host);
2343 mmc_go_idle(host);
2345 mmc_send_if_cond(host, host->ocr_avail);
2348 if (!mmc_attach_sdio(host))
2350 if (!mmc_attach_sd(host))
2352 if (!mmc_attach_mmc(host))
2355 mmc_power_off(host);
2359 int _mmc_detect_card_removed(struct mmc_host *host)
2363 if (host->caps & MMC_CAP_NONREMOVABLE)
2366 if (!host->card || mmc_card_removed(host->card))
2369 ret = host->bus_ops->alive(host);
2378 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) {
2379 mmc_detect_change(host, msecs_to_jiffies(200));
2380 pr_debug("%s: card removed too slowly\n", mmc_hostname(host));
2384 mmc_card_set_removed(host->card);
2385 pr_debug("%s: card remove detected\n", mmc_hostname(host));
2391 int mmc_detect_card_removed(struct mmc_host *host)
2393 struct mmc_card *card = host->card;
2396 WARN_ON(!host->claimed);
2404 * detect a change or host requires polling to provide card detection.
2406 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))
2409 host->detect_change = 0;
2411 ret = _mmc_detect_card_removed(host);
2412 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) {
2417 cancel_delayed_work(&host->detect);
2418 _mmc_detect_change(host, 0, false);
2428 struct mmc_host *host =
2433 if (host->trigger_card_event && host->ops->card_event) {
2434 host->ops->card_event(host);
2435 host->trigger_card_event = false;
2438 if (host->rescan_disable)
2442 if ((host->caps & MMC_CAP_NONREMOVABLE) && host->rescan_entered)
2444 host->rescan_entered = 1;
2446 mmc_bus_get(host);
2452 if (host->bus_ops && !host->bus_dead
2453 && !(host->caps & MMC_CAP_NONREMOVABLE))
2454 host->bus_ops->detect(host);
2456 host->detect_change = 0;
2461 if (host->bus_dead)
2468 mmc_bus_put(host);
2469 mmc_bus_get(host);
2472 if (host->bus_ops != NULL) {
2473 mmc_bus_put(host);
2481 mmc_bus_put(host);
2483 if (!(host->caps & MMC_CAP_NONREMOVABLE) && host->ops->get_cd &&
2484 host->ops->get_cd(host) == 0) {
2485 mmc_claim_host(host);
2486 mmc_power_off(host);
2487 mmc_release_host(host);
2491 mmc_claim_host(host);
2493 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) {
2497 if (freqs[i] <= host->f_min)
2500 mmc_release_host(host);
2507 if (host->caps & MMC_CAP_NEEDS_POLL)
2508 mmc_schedule_delayed_work(&host->detect, HZ);
2511 void mmc_start_host(struct mmc_host *host)
2513 host->f_init = max(freqs[0], host->f_min);
2514 host->rescan_disable = 0;
2515 host->ios.power_mode = MMC_POWER_UNDEFINED;
2516 if (host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)
2517 mmc_power_off(host);
2519 mmc_power_up(host, host->ocr_avail);
2520 mmc_gpiod_request_cd_irq(host);
2521 _mmc_detect_change(host, 0, false);
2524 void mmc_stop_host(struct mmc_host *host)
2528 spin_lock_irqsave(&host->lock, flags);
2529 host->removed = 1;
2530 spin_unlock_irqrestore(&host->lock, flags);
2532 if (host->slot.cd_irq >= 0)
2533 disable_irq(host->slot.cd_irq);
2535 host->rescan_disable = 1;
2536 cancel_delayed_work_sync(&host->detect);
2540 host->pm_flags = 0;
2542 mmc_bus_get(host);
2543 if (host->bus_ops && !host->bus_dead) {
2544 /* Calling bus_ops->remove() with a claimed host can deadlock */
2545 host->bus_ops->remove(host);
2546 mmc_claim_host(host);
2547 mmc_detach_bus(host);
2548 mmc_power_off(host);
2549 mmc_release_host(host);
2550 mmc_bus_put(host);
2553 mmc_bus_put(host);
2555 BUG_ON(host->card);
2557 mmc_power_off(host);
2560 int mmc_power_save_host(struct mmc_host *host)
2565 pr_info("%s: %s: powering down\n", mmc_hostname(host), __func__);
2568 mmc_bus_get(host);
2570 if (!host->bus_ops || host->bus_dead) {
2571 mmc_bus_put(host);
2575 if (host->bus_ops->power_save)
2576 ret = host->bus_ops->power_save(host);
2578 mmc_bus_put(host);
2580 mmc_power_off(host);
2586 int mmc_power_restore_host(struct mmc_host *host)
2591 pr_info("%s: %s: powering up\n", mmc_hostname(host), __func__);
2594 mmc_bus_get(host);
2596 if (!host->bus_ops || host->bus_dead) {
2597 mmc_bus_put(host);
2601 mmc_power_up(host, host->card->ocr);
2602 ret = host->bus_ops->power_restore(host);
2604 mmc_bus_put(host);
2624 mmc_hostname(card->host), err);
2640 struct mmc_host *host = container_of(
2648 spin_lock_irqsave(&host->lock, flags);
2649 host->rescan_disable = 1;
2650 spin_unlock_irqrestore(&host->lock, flags);
2651 cancel_delayed_work_sync(&host->detect);
2653 if (!host->bus_ops)
2657 if (host->bus_ops->pre_suspend)
2658 err = host->bus_ops->pre_suspend(host);
2662 /* Calling bus_ops->remove() with a claimed host can deadlock */
2663 host->bus_ops->remove(host);
2664 mmc_claim_host(host);
2665 mmc_detach_bus(host);
2666 mmc_power_off(host);
2667 mmc_release_host(host);
2668 host->pm_flags = 0;
2675 spin_lock_irqsave(&host->lock, flags);
2676 host->rescan_disable = 0;
2677 spin_unlock_irqrestore(&host->lock, flags);
2678 _mmc_detect_change(host, 0, false);
2688 * @host: mmc host
2691 * request mechanism, used by mmc core, host driver and mmc requests
2694 void mmc_init_context_info(struct mmc_host *host)
2696 spin_lock_init(&host->context_info.lock);
2697 host->context_info.is_new_req = false;
2698 host->context_info.is_done_rcv = false;
2699 host->context_info.is_waiting_last_req = false;
2700 init_waitqueue_head(&host->context_info.wait);
2704 void mmc_set_embedded_sdio_data(struct mmc_host *host,
2710 host->embedded_sdio_data.cis = cis;
2711 host->embedded_sdio_data.cccr = cccr;
2712 host->embedded_sdio_data.funcs = funcs;
2713 host->embedded_sdio_data.num_funcs = num_funcs;