diff options
Diffstat (limited to 'drivers/mmc')
-rw-r--r-- | drivers/mmc/card/block.c | 3 | ||||
-rw-r--r-- | drivers/mmc/card/mmc_test.c | 58 | ||||
-rw-r--r-- | drivers/mmc/core/core.c | 37 | ||||
-rw-r--r-- | drivers/mmc/core/host.c | 12 | ||||
-rw-r--r-- | drivers/mmc/core/host.h | 8 | ||||
-rw-r--r-- | drivers/mmc/core/mmc.c | 2 | ||||
-rw-r--r-- | drivers/mmc/core/mmc_ops.c | 2 | ||||
-rw-r--r-- | drivers/mmc/core/sd.c | 81 | ||||
-rw-r--r-- | drivers/mmc/host/dw_mmc.c | 6 | ||||
-rw-r--r-- | drivers/mmc/host/sdhci-esdhc-imx.c | 41 | ||||
-rw-r--r-- | drivers/mmc/host/sdhci-pxav3.c | 3 | ||||
-rw-r--r-- | drivers/mmc/host/sdhci-s3c.c | 6 | ||||
-rw-r--r-- | drivers/mmc/host/sdhci.c | 53 | ||||
-rw-r--r-- | drivers/mmc/host/sh_mobile_sdhi.c | 4 | ||||
-rw-r--r-- | drivers/mmc/host/tmio_mmc.c | 2 |
15 files changed, 200 insertions, 118 deletions
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c index 1ff5486213f..4c1a648d00f 100644 --- a/drivers/mmc/card/block.c +++ b/drivers/mmc/card/block.c | |||
@@ -926,6 +926,9 @@ static void mmc_blk_rw_rq_prep(struct mmc_queue_req *mqrq, | |||
926 | /* | 926 | /* |
927 | * Reliable writes are used to implement Forced Unit Access and | 927 | * Reliable writes are used to implement Forced Unit Access and |
928 | * REQ_META accesses, and are supported only on MMCs. | 928 | * REQ_META accesses, and are supported only on MMCs. |
929 | * | ||
930 | * XXX: this really needs a good explanation of why REQ_META | ||
931 | * is treated special. | ||
929 | */ | 932 | */ |
930 | bool do_rel_wr = ((req->cmd_flags & REQ_FUA) || | 933 | bool do_rel_wr = ((req->cmd_flags & REQ_FUA) || |
931 | (req->cmd_flags & REQ_META)) && | 934 | (req->cmd_flags & REQ_META)) && |
diff --git a/drivers/mmc/card/mmc_test.c b/drivers/mmc/card/mmc_test.c index 006a5e9f8ab..2bf229acd3b 100644 --- a/drivers/mmc/card/mmc_test.c +++ b/drivers/mmc/card/mmc_test.c | |||
@@ -224,7 +224,7 @@ static void mmc_test_prepare_mrq(struct mmc_test_card *test, | |||
224 | static int mmc_test_busy(struct mmc_command *cmd) | 224 | static int mmc_test_busy(struct mmc_command *cmd) |
225 | { | 225 | { |
226 | return !(cmd->resp[0] & R1_READY_FOR_DATA) || | 226 | return !(cmd->resp[0] & R1_READY_FOR_DATA) || |
227 | (R1_CURRENT_STATE(cmd->resp[0]) == 7); | 227 | (R1_CURRENT_STATE(cmd->resp[0]) == R1_STATE_PRG); |
228 | } | 228 | } |
229 | 229 | ||
230 | /* | 230 | /* |
@@ -2900,7 +2900,7 @@ static const struct file_operations mmc_test_fops_testlist = { | |||
2900 | .release = single_release, | 2900 | .release = single_release, |
2901 | }; | 2901 | }; |
2902 | 2902 | ||
2903 | static void mmc_test_free_file_test(struct mmc_card *card) | 2903 | static void mmc_test_free_dbgfs_file(struct mmc_card *card) |
2904 | { | 2904 | { |
2905 | struct mmc_test_dbgfs_file *df, *dfs; | 2905 | struct mmc_test_dbgfs_file *df, *dfs; |
2906 | 2906 | ||
@@ -2917,34 +2917,21 @@ static void mmc_test_free_file_test(struct mmc_card *card) | |||
2917 | mutex_unlock(&mmc_test_lock); | 2917 | mutex_unlock(&mmc_test_lock); |
2918 | } | 2918 | } |
2919 | 2919 | ||
2920 | static int mmc_test_register_file_test(struct mmc_card *card) | 2920 | static int __mmc_test_register_dbgfs_file(struct mmc_card *card, |
2921 | const char *name, mode_t mode, const struct file_operations *fops) | ||
2921 | { | 2922 | { |
2922 | struct dentry *file = NULL; | 2923 | struct dentry *file = NULL; |
2923 | struct mmc_test_dbgfs_file *df; | 2924 | struct mmc_test_dbgfs_file *df; |
2924 | int ret = 0; | ||
2925 | |||
2926 | mutex_lock(&mmc_test_lock); | ||
2927 | |||
2928 | if (card->debugfs_root) | ||
2929 | file = debugfs_create_file("test", S_IWUSR | S_IRUGO, | ||
2930 | card->debugfs_root, card, &mmc_test_fops_test); | ||
2931 | |||
2932 | if (IS_ERR_OR_NULL(file)) { | ||
2933 | dev_err(&card->dev, | ||
2934 | "Can't create test. Perhaps debugfs is disabled.\n"); | ||
2935 | ret = -ENODEV; | ||
2936 | goto err; | ||
2937 | } | ||
2938 | 2925 | ||
2939 | if (card->debugfs_root) | 2926 | if (card->debugfs_root) |
2940 | file = debugfs_create_file("testlist", S_IRUGO, | 2927 | file = debugfs_create_file(name, mode, card->debugfs_root, |
2941 | card->debugfs_root, card, &mmc_test_fops_testlist); | 2928 | card, fops); |
2942 | 2929 | ||
2943 | if (IS_ERR_OR_NULL(file)) { | 2930 | if (IS_ERR_OR_NULL(file)) { |
2944 | dev_err(&card->dev, | 2931 | dev_err(&card->dev, |
2945 | "Can't create testlist. Perhaps debugfs is disabled.\n"); | 2932 | "Can't create %s. Perhaps debugfs is disabled.\n", |
2946 | ret = -ENODEV; | 2933 | name); |
2947 | goto err; | 2934 | return -ENODEV; |
2948 | } | 2935 | } |
2949 | 2936 | ||
2950 | df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL); | 2937 | df = kmalloc(sizeof(struct mmc_test_dbgfs_file), GFP_KERNEL); |
@@ -2952,14 +2939,31 @@ static int mmc_test_register_file_test(struct mmc_card *card) | |||
2952 | debugfs_remove(file); | 2939 | debugfs_remove(file); |
2953 | dev_err(&card->dev, | 2940 | dev_err(&card->dev, |
2954 | "Can't allocate memory for internal usage.\n"); | 2941 | "Can't allocate memory for internal usage.\n"); |
2955 | ret = -ENOMEM; | 2942 | return -ENOMEM; |
2956 | goto err; | ||
2957 | } | 2943 | } |
2958 | 2944 | ||
2959 | df->card = card; | 2945 | df->card = card; |
2960 | df->file = file; | 2946 | df->file = file; |
2961 | 2947 | ||
2962 | list_add(&df->link, &mmc_test_file_test); | 2948 | list_add(&df->link, &mmc_test_file_test); |
2949 | return 0; | ||
2950 | } | ||
2951 | |||
2952 | static int mmc_test_register_dbgfs_file(struct mmc_card *card) | ||
2953 | { | ||
2954 | int ret; | ||
2955 | |||
2956 | mutex_lock(&mmc_test_lock); | ||
2957 | |||
2958 | ret = __mmc_test_register_dbgfs_file(card, "test", S_IWUSR | S_IRUGO, | ||
2959 | &mmc_test_fops_test); | ||
2960 | if (ret) | ||
2961 | goto err; | ||
2962 | |||
2963 | ret = __mmc_test_register_dbgfs_file(card, "testlist", S_IRUGO, | ||
2964 | &mmc_test_fops_testlist); | ||
2965 | if (ret) | ||
2966 | goto err; | ||
2963 | 2967 | ||
2964 | err: | 2968 | err: |
2965 | mutex_unlock(&mmc_test_lock); | 2969 | mutex_unlock(&mmc_test_lock); |
@@ -2974,7 +2978,7 @@ static int mmc_test_probe(struct mmc_card *card) | |||
2974 | if (!mmc_card_mmc(card) && !mmc_card_sd(card)) | 2978 | if (!mmc_card_mmc(card) && !mmc_card_sd(card)) |
2975 | return -ENODEV; | 2979 | return -ENODEV; |
2976 | 2980 | ||
2977 | ret = mmc_test_register_file_test(card); | 2981 | ret = mmc_test_register_dbgfs_file(card); |
2978 | if (ret) | 2982 | if (ret) |
2979 | return ret; | 2983 | return ret; |
2980 | 2984 | ||
@@ -2986,7 +2990,7 @@ static int mmc_test_probe(struct mmc_card *card) | |||
2986 | static void mmc_test_remove(struct mmc_card *card) | 2990 | static void mmc_test_remove(struct mmc_card *card) |
2987 | { | 2991 | { |
2988 | mmc_test_free_result(card); | 2992 | mmc_test_free_result(card); |
2989 | mmc_test_free_file_test(card); | 2993 | mmc_test_free_dbgfs_file(card); |
2990 | } | 2994 | } |
2991 | 2995 | ||
2992 | static struct mmc_driver mmc_driver = { | 2996 | static struct mmc_driver mmc_driver = { |
@@ -3006,7 +3010,7 @@ static void __exit mmc_test_exit(void) | |||
3006 | { | 3010 | { |
3007 | /* Clear stalled data if card is still plugged */ | 3011 | /* Clear stalled data if card is still plugged */ |
3008 | mmc_test_free_result(NULL); | 3012 | mmc_test_free_result(NULL); |
3009 | mmc_test_free_file_test(NULL); | 3013 | mmc_test_free_dbgfs_file(NULL); |
3010 | 3014 | ||
3011 | mmc_unregister_driver(&mmc_driver); | 3015 | mmc_unregister_driver(&mmc_driver); |
3012 | } | 3016 | } |
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c index 89bdeaec718..b27b94078c2 100644 --- a/drivers/mmc/core/core.c +++ b/drivers/mmc/core/core.c | |||
@@ -133,7 +133,7 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) | |||
133 | if (mrq->done) | 133 | if (mrq->done) |
134 | mrq->done(mrq); | 134 | mrq->done(mrq); |
135 | 135 | ||
136 | mmc_host_clk_gate(host); | 136 | mmc_host_clk_release(host); |
137 | } | 137 | } |
138 | } | 138 | } |
139 | 139 | ||
@@ -192,7 +192,7 @@ mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) | |||
192 | mrq->stop->mrq = mrq; | 192 | mrq->stop->mrq = mrq; |
193 | } | 193 | } |
194 | } | 194 | } |
195 | mmc_host_clk_ungate(host); | 195 | mmc_host_clk_hold(host); |
196 | led_trigger_event(host->led, LED_FULL); | 196 | led_trigger_event(host->led, LED_FULL); |
197 | host->ops->request(host, mrq); | 197 | host->ops->request(host, mrq); |
198 | } | 198 | } |
@@ -728,15 +728,17 @@ static inline void mmc_set_ios(struct mmc_host *host) | |||
728 | */ | 728 | */ |
729 | void mmc_set_chip_select(struct mmc_host *host, int mode) | 729 | void mmc_set_chip_select(struct mmc_host *host, int mode) |
730 | { | 730 | { |
731 | mmc_host_clk_hold(host); | ||
731 | host->ios.chip_select = mode; | 732 | host->ios.chip_select = mode; |
732 | mmc_set_ios(host); | 733 | mmc_set_ios(host); |
734 | mmc_host_clk_release(host); | ||
733 | } | 735 | } |
734 | 736 | ||
735 | /* | 737 | /* |
736 | * Sets the host clock to the highest possible frequency that | 738 | * Sets the host clock to the highest possible frequency that |
737 | * is below "hz". | 739 | * is below "hz". |
738 | */ | 740 | */ |
739 | void mmc_set_clock(struct mmc_host *host, unsigned int hz) | 741 | static void __mmc_set_clock(struct mmc_host *host, unsigned int hz) |
740 | { | 742 | { |
741 | WARN_ON(hz < host->f_min); | 743 | WARN_ON(hz < host->f_min); |
742 | 744 | ||
@@ -747,6 +749,13 @@ void mmc_set_clock(struct mmc_host *host, unsigned int hz) | |||
747 | mmc_set_ios(host); | 749 | mmc_set_ios(host); |
748 | } | 750 | } |
749 | 751 | ||
752 | void mmc_set_clock(struct mmc_host *host, unsigned int hz) | ||
753 | { | ||
754 | mmc_host_clk_hold(host); | ||
755 | __mmc_set_clock(host, hz); | ||
756 | mmc_host_clk_release(host); | ||
757 | } | ||
758 | |||
750 | #ifdef CONFIG_MMC_CLKGATE | 759 | #ifdef CONFIG_MMC_CLKGATE |
751 | /* | 760 | /* |
752 | * This gates the clock by setting it to 0 Hz. | 761 | * This gates the clock by setting it to 0 Hz. |
@@ -779,7 +788,7 @@ void mmc_ungate_clock(struct mmc_host *host) | |||
779 | if (host->clk_old) { | 788 | if (host->clk_old) { |
780 | BUG_ON(host->ios.clock); | 789 | BUG_ON(host->ios.clock); |
781 | /* This call will also set host->clk_gated to false */ | 790 | /* This call will also set host->clk_gated to false */ |
782 | mmc_set_clock(host, host->clk_old); | 791 | __mmc_set_clock(host, host->clk_old); |
783 | } | 792 | } |
784 | } | 793 | } |
785 | 794 | ||
@@ -807,8 +816,10 @@ void mmc_set_ungated(struct mmc_host *host) | |||
807 | */ | 816 | */ |
808 | void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) | 817 | void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) |
809 | { | 818 | { |
819 | mmc_host_clk_hold(host); | ||
810 | host->ios.bus_mode = mode; | 820 | host->ios.bus_mode = mode; |
811 | mmc_set_ios(host); | 821 | mmc_set_ios(host); |
822 | mmc_host_clk_release(host); | ||
812 | } | 823 | } |
813 | 824 | ||
814 | /* | 825 | /* |
@@ -816,8 +827,10 @@ void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) | |||
816 | */ | 827 | */ |
817 | void mmc_set_bus_width(struct mmc_host *host, unsigned int width) | 828 | void mmc_set_bus_width(struct mmc_host *host, unsigned int width) |
818 | { | 829 | { |
830 | mmc_host_clk_hold(host); | ||
819 | host->ios.bus_width = width; | 831 | host->ios.bus_width = width; |
820 | mmc_set_ios(host); | 832 | mmc_set_ios(host); |
833 | mmc_host_clk_release(host); | ||
821 | } | 834 | } |
822 | 835 | ||
823 | /** | 836 | /** |
@@ -1015,8 +1028,10 @@ u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) | |||
1015 | 1028 | ||
1016 | ocr &= 3 << bit; | 1029 | ocr &= 3 << bit; |
1017 | 1030 | ||
1031 | mmc_host_clk_hold(host); | ||
1018 | host->ios.vdd = bit; | 1032 | host->ios.vdd = bit; |
1019 | mmc_set_ios(host); | 1033 | mmc_set_ios(host); |
1034 | mmc_host_clk_release(host); | ||
1020 | } else { | 1035 | } else { |
1021 | pr_warning("%s: host doesn't support card's voltages\n", | 1036 | pr_warning("%s: host doesn't support card's voltages\n", |
1022 | mmc_hostname(host)); | 1037 | mmc_hostname(host)); |
@@ -1063,8 +1078,10 @@ int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage, bool cmd11 | |||
1063 | */ | 1078 | */ |
1064 | void mmc_set_timing(struct mmc_host *host, unsigned int timing) | 1079 | void mmc_set_timing(struct mmc_host *host, unsigned int timing) |
1065 | { | 1080 | { |
1081 | mmc_host_clk_hold(host); | ||
1066 | host->ios.timing = timing; | 1082 | host->ios.timing = timing; |
1067 | mmc_set_ios(host); | 1083 | mmc_set_ios(host); |
1084 | mmc_host_clk_release(host); | ||
1068 | } | 1085 | } |
1069 | 1086 | ||
1070 | /* | 1087 | /* |
@@ -1072,8 +1089,10 @@ void mmc_set_timing(struct mmc_host *host, unsigned int timing) | |||
1072 | */ | 1089 | */ |
1073 | void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) | 1090 | void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) |
1074 | { | 1091 | { |
1092 | mmc_host_clk_hold(host); | ||
1075 | host->ios.drv_type = drv_type; | 1093 | host->ios.drv_type = drv_type; |
1076 | mmc_set_ios(host); | 1094 | mmc_set_ios(host); |
1095 | mmc_host_clk_release(host); | ||
1077 | } | 1096 | } |
1078 | 1097 | ||
1079 | /* | 1098 | /* |
@@ -1091,6 +1110,8 @@ static void mmc_power_up(struct mmc_host *host) | |||
1091 | { | 1110 | { |
1092 | int bit; | 1111 | int bit; |
1093 | 1112 | ||
1113 | mmc_host_clk_hold(host); | ||
1114 | |||
1094 | /* If ocr is set, we use it */ | 1115 | /* If ocr is set, we use it */ |
1095 | if (host->ocr) | 1116 | if (host->ocr) |
1096 | bit = ffs(host->ocr) - 1; | 1117 | bit = ffs(host->ocr) - 1; |
@@ -1126,10 +1147,14 @@ static void mmc_power_up(struct mmc_host *host) | |||
1126 | * time required to reach a stable voltage. | 1147 | * time required to reach a stable voltage. |
1127 | */ | 1148 | */ |
1128 | mmc_delay(10); | 1149 | mmc_delay(10); |
1150 | |||
1151 | mmc_host_clk_release(host); | ||
1129 | } | 1152 | } |
1130 | 1153 | ||
1131 | static void mmc_power_off(struct mmc_host *host) | 1154 | static void mmc_power_off(struct mmc_host *host) |
1132 | { | 1155 | { |
1156 | mmc_host_clk_hold(host); | ||
1157 | |||
1133 | host->ios.clock = 0; | 1158 | host->ios.clock = 0; |
1134 | host->ios.vdd = 0; | 1159 | host->ios.vdd = 0; |
1135 | 1160 | ||
@@ -1147,6 +1172,8 @@ static void mmc_power_off(struct mmc_host *host) | |||
1147 | host->ios.bus_width = MMC_BUS_WIDTH_1; | 1172 | host->ios.bus_width = MMC_BUS_WIDTH_1; |
1148 | host->ios.timing = MMC_TIMING_LEGACY; | 1173 | host->ios.timing = MMC_TIMING_LEGACY; |
1149 | mmc_set_ios(host); | 1174 | mmc_set_ios(host); |
1175 | |||
1176 | mmc_host_clk_release(host); | ||
1150 | } | 1177 | } |
1151 | 1178 | ||
1152 | /* | 1179 | /* |
@@ -1502,7 +1529,7 @@ static int mmc_do_erase(struct mmc_card *card, unsigned int from, | |||
1502 | goto out; | 1529 | goto out; |
1503 | } | 1530 | } |
1504 | } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || | 1531 | } while (!(cmd.resp[0] & R1_READY_FOR_DATA) || |
1505 | R1_CURRENT_STATE(cmd.resp[0]) == 7); | 1532 | R1_CURRENT_STATE(cmd.resp[0]) == R1_STATE_PRG); |
1506 | out: | 1533 | out: |
1507 | return err; | 1534 | return err; |
1508 | } | 1535 | } |
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c index b29d3e8fd3a..793d0a0dad8 100644 --- a/drivers/mmc/core/host.c +++ b/drivers/mmc/core/host.c | |||
@@ -119,14 +119,14 @@ static void mmc_host_clk_gate_work(struct work_struct *work) | |||
119 | } | 119 | } |
120 | 120 | ||
121 | /** | 121 | /** |
122 | * mmc_host_clk_ungate - ungate hardware MCI clocks | 122 | * mmc_host_clk_hold - ungate hardware MCI clocks |
123 | * @host: host to ungate. | 123 | * @host: host to ungate. |
124 | * | 124 | * |
125 | * Makes sure the host ios.clock is restored to a non-zero value | 125 | * Makes sure the host ios.clock is restored to a non-zero value |
126 | * past this call. Increase clock reference count and ungate clock | 126 | * past this call. Increase clock reference count and ungate clock |
127 | * if we're the first user. | 127 | * if we're the first user. |
128 | */ | 128 | */ |
129 | void mmc_host_clk_ungate(struct mmc_host *host) | 129 | void mmc_host_clk_hold(struct mmc_host *host) |
130 | { | 130 | { |
131 | unsigned long flags; | 131 | unsigned long flags; |
132 | 132 | ||
@@ -164,14 +164,14 @@ static bool mmc_host_may_gate_card(struct mmc_card *card) | |||
164 | } | 164 | } |
165 | 165 | ||
166 | /** | 166 | /** |
167 | * mmc_host_clk_gate - gate off hardware MCI clocks | 167 | * mmc_host_clk_release - gate off hardware MCI clocks |
168 | * @host: host to gate. | 168 | * @host: host to gate. |
169 | * | 169 | * |
170 | * Calls the host driver with ios.clock set to zero as often as possible | 170 | * Calls the host driver with ios.clock set to zero as often as possible |
171 | * in order to gate off hardware MCI clocks. Decrease clock reference | 171 | * in order to gate off hardware MCI clocks. Decrease clock reference |
172 | * count and schedule disabling of clock. | 172 | * count and schedule disabling of clock. |
173 | */ | 173 | */ |
174 | void mmc_host_clk_gate(struct mmc_host *host) | 174 | void mmc_host_clk_release(struct mmc_host *host) |
175 | { | 175 | { |
176 | unsigned long flags; | 176 | unsigned long flags; |
177 | 177 | ||
@@ -179,7 +179,7 @@ void mmc_host_clk_gate(struct mmc_host *host) | |||
179 | host->clk_requests--; | 179 | host->clk_requests--; |
180 | if (mmc_host_may_gate_card(host->card) && | 180 | if (mmc_host_may_gate_card(host->card) && |
181 | !host->clk_requests) | 181 | !host->clk_requests) |
182 | schedule_work(&host->clk_gate_work); | 182 | queue_work(system_nrt_wq, &host->clk_gate_work); |
183 | spin_unlock_irqrestore(&host->clk_lock, flags); | 183 | spin_unlock_irqrestore(&host->clk_lock, flags); |
184 | } | 184 | } |
185 | 185 | ||
@@ -231,7 +231,7 @@ static inline void mmc_host_clk_exit(struct mmc_host *host) | |||
231 | if (cancel_work_sync(&host->clk_gate_work)) | 231 | if (cancel_work_sync(&host->clk_gate_work)) |
232 | mmc_host_clk_gate_delayed(host); | 232 | mmc_host_clk_gate_delayed(host); |
233 | if (host->clk_gated) | 233 | if (host->clk_gated) |
234 | mmc_host_clk_ungate(host); | 234 | mmc_host_clk_hold(host); |
235 | /* There should be only one user now */ | 235 | /* There should be only one user now */ |
236 | WARN_ON(host->clk_requests > 1); | 236 | WARN_ON(host->clk_requests > 1); |
237 | } | 237 | } |
diff --git a/drivers/mmc/core/host.h b/drivers/mmc/core/host.h index de199f91192..fb8a5cd2e4a 100644 --- a/drivers/mmc/core/host.h +++ b/drivers/mmc/core/host.h | |||
@@ -16,16 +16,16 @@ int mmc_register_host_class(void); | |||
16 | void mmc_unregister_host_class(void); | 16 | void mmc_unregister_host_class(void); |
17 | 17 | ||
18 | #ifdef CONFIG_MMC_CLKGATE | 18 | #ifdef CONFIG_MMC_CLKGATE |
19 | void mmc_host_clk_ungate(struct mmc_host *host); | 19 | void mmc_host_clk_hold(struct mmc_host *host); |
20 | void mmc_host_clk_gate(struct mmc_host *host); | 20 | void mmc_host_clk_release(struct mmc_host *host); |
21 | unsigned int mmc_host_clk_rate(struct mmc_host *host); | 21 | unsigned int mmc_host_clk_rate(struct mmc_host *host); |
22 | 22 | ||
23 | #else | 23 | #else |
24 | static inline void mmc_host_clk_ungate(struct mmc_host *host) | 24 | static inline void mmc_host_clk_hold(struct mmc_host *host) |
25 | { | 25 | { |
26 | } | 26 | } |
27 | 27 | ||
28 | static inline void mmc_host_clk_gate(struct mmc_host *host) | 28 | static inline void mmc_host_clk_release(struct mmc_host *host) |
29 | { | 29 | { |
30 | } | 30 | } |
31 | 31 | ||
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c index aa7d1d79b8c..5700b1cbdfe 100644 --- a/drivers/mmc/core/mmc.c +++ b/drivers/mmc/core/mmc.c | |||
@@ -259,7 +259,7 @@ static int mmc_read_ext_csd(struct mmc_card *card, u8 *ext_csd) | |||
259 | } | 259 | } |
260 | 260 | ||
261 | card->ext_csd.rev = ext_csd[EXT_CSD_REV]; | 261 | card->ext_csd.rev = ext_csd[EXT_CSD_REV]; |
262 | if (card->ext_csd.rev > 5) { | 262 | if (card->ext_csd.rev > 6) { |
263 | printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n", | 263 | printk(KERN_ERR "%s: unrecognised EXT_CSD revision %d\n", |
264 | mmc_hostname(card->host), card->ext_csd.rev); | 264 | mmc_hostname(card->host), card->ext_csd.rev); |
265 | err = -EINVAL; | 265 | err = -EINVAL; |
diff --git a/drivers/mmc/core/mmc_ops.c b/drivers/mmc/core/mmc_ops.c index 845ce7c533b..770c3d06f5d 100644 --- a/drivers/mmc/core/mmc_ops.c +++ b/drivers/mmc/core/mmc_ops.c | |||
@@ -407,7 +407,7 @@ int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, | |||
407 | break; | 407 | break; |
408 | if (mmc_host_is_spi(card->host)) | 408 | if (mmc_host_is_spi(card->host)) |
409 | break; | 409 | break; |
410 | } while (R1_CURRENT_STATE(status) == 7); | 410 | } while (R1_CURRENT_STATE(status) == R1_STATE_PRG); |
411 | 411 | ||
412 | if (mmc_host_is_spi(card->host)) { | 412 | if (mmc_host_is_spi(card->host)) { |
413 | if (status & R1_SPI_ILLEGAL_COMMAND) | 413 | if (status & R1_SPI_ILLEGAL_COMMAND) |
diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c index 633975ff2bb..0370e03e314 100644 --- a/drivers/mmc/core/sd.c +++ b/drivers/mmc/core/sd.c | |||
@@ -469,56 +469,75 @@ static int sd_select_driver_type(struct mmc_card *card, u8 *status) | |||
469 | return 0; | 469 | return 0; |
470 | } | 470 | } |
471 | 471 | ||
472 | static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status) | 472 | static void sd_update_bus_speed_mode(struct mmc_card *card) |
473 | { | 473 | { |
474 | unsigned int bus_speed = 0, timing = 0; | ||
475 | int err; | ||
476 | |||
477 | /* | 474 | /* |
478 | * If the host doesn't support any of the UHS-I modes, fallback on | 475 | * If the host doesn't support any of the UHS-I modes, fallback on |
479 | * default speed. | 476 | * default speed. |
480 | */ | 477 | */ |
481 | if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | | 478 | if (!(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 | |
482 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) | 479 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))) { |
483 | return 0; | 480 | card->sd_bus_speed = 0; |
481 | return; | ||
482 | } | ||
484 | 483 | ||
485 | if ((card->host->caps & MMC_CAP_UHS_SDR104) && | 484 | if ((card->host->caps & MMC_CAP_UHS_SDR104) && |
486 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) { | 485 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) { |
487 | bus_speed = UHS_SDR104_BUS_SPEED; | 486 | card->sd_bus_speed = UHS_SDR104_BUS_SPEED; |
488 | timing = MMC_TIMING_UHS_SDR104; | ||
489 | card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR; | ||
490 | } else if ((card->host->caps & MMC_CAP_UHS_DDR50) && | 487 | } else if ((card->host->caps & MMC_CAP_UHS_DDR50) && |
491 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) { | 488 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) { |
492 | bus_speed = UHS_DDR50_BUS_SPEED; | 489 | card->sd_bus_speed = UHS_DDR50_BUS_SPEED; |
493 | timing = MMC_TIMING_UHS_DDR50; | ||
494 | card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR; | ||
495 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | | 490 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
496 | MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode & | 491 | MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode & |
497 | SD_MODE_UHS_SDR50)) { | 492 | SD_MODE_UHS_SDR50)) { |
498 | bus_speed = UHS_SDR50_BUS_SPEED; | 493 | card->sd_bus_speed = UHS_SDR50_BUS_SPEED; |
499 | timing = MMC_TIMING_UHS_SDR50; | ||
500 | card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR; | ||
501 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | | 494 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
502 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) && | 495 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) && |
503 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) { | 496 | (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) { |
504 | bus_speed = UHS_SDR25_BUS_SPEED; | 497 | card->sd_bus_speed = UHS_SDR25_BUS_SPEED; |
505 | timing = MMC_TIMING_UHS_SDR25; | ||
506 | card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR; | ||
507 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | | 498 | } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | |
508 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 | | 499 | MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 | |
509 | MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode & | 500 | MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode & |
510 | SD_MODE_UHS_SDR12)) { | 501 | SD_MODE_UHS_SDR12)) { |
511 | bus_speed = UHS_SDR12_BUS_SPEED; | 502 | card->sd_bus_speed = UHS_SDR12_BUS_SPEED; |
512 | timing = MMC_TIMING_UHS_SDR12; | 503 | } |
513 | card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR; | 504 | } |
505 | |||
506 | static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status) | ||
507 | { | ||
508 | int err; | ||
509 | unsigned int timing = 0; | ||
510 | |||
511 | switch (card->sd_bus_speed) { | ||
512 | case UHS_SDR104_BUS_SPEED: | ||
513 | timing = MMC_TIMING_UHS_SDR104; | ||
514 | card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR; | ||
515 | break; | ||
516 | case UHS_DDR50_BUS_SPEED: | ||
517 | timing = MMC_TIMING_UHS_DDR50; | ||
518 | card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR; | ||
519 | break; | ||
520 | case UHS_SDR50_BUS_SPEED: | ||
521 | timing = MMC_TIMING_UHS_SDR50; | ||
522 | card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR; | ||
523 | break; | ||
524 | case UHS_SDR25_BUS_SPEED: | ||
525 | timing = MMC_TIMING_UHS_SDR25; | ||
526 | card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR; | ||
527 | break; | ||
528 | case UHS_SDR12_BUS_SPEED: | ||
529 | timing = MMC_TIMING_UHS_SDR12; | ||
530 | card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR; | ||
531 | break; | ||
532 | default: | ||
533 | return 0; | ||
514 | } | 534 | } |
515 | 535 | ||
516 | card->sd_bus_speed = bus_speed; | 536 | err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status); |
517 | err = mmc_sd_switch(card, 1, 0, bus_speed, status); | ||
518 | if (err) | 537 | if (err) |
519 | return err; | 538 | return err; |
520 | 539 | ||
521 | if ((status[16] & 0xF) != bus_speed) | 540 | if ((status[16] & 0xF) != card->sd_bus_speed) |
522 | printk(KERN_WARNING "%s: Problem setting bus speed mode!\n", | 541 | printk(KERN_WARNING "%s: Problem setting bus speed mode!\n", |
523 | mmc_hostname(card->host)); | 542 | mmc_hostname(card->host)); |
524 | else { | 543 | else { |
@@ -618,18 +637,24 @@ static int mmc_sd_init_uhs_card(struct mmc_card *card) | |||
618 | mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); | 637 | mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); |
619 | } | 638 | } |
620 | 639 | ||
640 | /* | ||
641 | * Select the bus speed mode depending on host | ||
642 | * and card capability. | ||
643 | */ | ||
644 | sd_update_bus_speed_mode(card); | ||
645 | |||
621 | /* Set the driver strength for the card */ | 646 | /* Set the driver strength for the card */ |
622 | err = sd_select_driver_type(card, status); | 647 | err = sd_select_driver_type(card, status); |
623 | if (err) | 648 | if (err) |
624 | goto out; | 649 | goto out; |
625 | 650 | ||
626 | /* Set bus speed mode of the card */ | 651 | /* Set current limit for the card */ |
627 | err = sd_set_bus_speed_mode(card, status); | 652 | err = sd_set_current_limit(card, status); |
628 | if (err) | 653 | if (err) |
629 | goto out; | 654 | goto out; |
630 | 655 | ||
631 | /* Set current limit for the card */ | 656 | /* Set bus speed mode of the card */ |
632 | err = sd_set_current_limit(card, status); | 657 | err = sd_set_bus_speed_mode(card, status); |
633 | if (err) | 658 | if (err) |
634 | goto out; | 659 | goto out; |
635 | 660 | ||
diff --git a/drivers/mmc/host/dw_mmc.c b/drivers/mmc/host/dw_mmc.c index 77f0b6b1681..ff0f714b012 100644 --- a/drivers/mmc/host/dw_mmc.c +++ b/drivers/mmc/host/dw_mmc.c | |||
@@ -62,7 +62,7 @@ struct idmac_desc { | |||
62 | 62 | ||
63 | u32 des1; /* Buffer sizes */ | 63 | u32 des1; /* Buffer sizes */ |
64 | #define IDMAC_SET_BUFFER1_SIZE(d, s) \ | 64 | #define IDMAC_SET_BUFFER1_SIZE(d, s) \ |
65 | ((d)->des1 = ((d)->des1 & 0x03ffc000) | ((s) & 0x3fff)) | 65 | ((d)->des1 = ((d)->des1 & 0x03ffe000) | ((s) & 0x1fff)) |
66 | 66 | ||
67 | u32 des2; /* buffer 1 physical address */ | 67 | u32 des2; /* buffer 1 physical address */ |
68 | 68 | ||
@@ -699,7 +699,7 @@ static void dw_mci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) | |||
699 | } | 699 | } |
700 | 700 | ||
701 | /* DDR mode set */ | 701 | /* DDR mode set */ |
702 | if (ios->ddr) { | 702 | if (ios->timing == MMC_TIMING_UHS_DDR50) { |
703 | regs = mci_readl(slot->host, UHS_REG); | 703 | regs = mci_readl(slot->host, UHS_REG); |
704 | regs |= (0x1 << slot->id) << 16; | 704 | regs |= (0x1 << slot->id) << 16; |
705 | mci_writel(slot->host, UHS_REG, regs); | 705 | mci_writel(slot->host, UHS_REG, regs); |
@@ -1646,7 +1646,7 @@ static int __init dw_mci_init_slot(struct dw_mci *host, unsigned int id) | |||
1646 | mmc->caps |= MMC_CAP_4_BIT_DATA; | 1646 | mmc->caps |= MMC_CAP_4_BIT_DATA; |
1647 | 1647 | ||
1648 | if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED) | 1648 | if (host->pdata->quirks & DW_MCI_QUIRK_HIGHSPEED) |
1649 | mmc->caps |= MMC_CAP_SD_HIGHSPEED; | 1649 | mmc->caps |= MMC_CAP_SD_HIGHSPEED | MMC_CAP_MMC_HIGHSPEED; |
1650 | 1650 | ||
1651 | #ifdef CONFIG_MMC_DW_IDMAC | 1651 | #ifdef CONFIG_MMC_DW_IDMAC |
1652 | mmc->max_segs = host->ring_size; | 1652 | mmc->max_segs = host->ring_size; |
diff --git a/drivers/mmc/host/sdhci-esdhc-imx.c b/drivers/mmc/host/sdhci-esdhc-imx.c index 9ebfb4b482f..4dc0028086a 100644 --- a/drivers/mmc/host/sdhci-esdhc-imx.c +++ b/drivers/mmc/host/sdhci-esdhc-imx.c | |||
@@ -16,6 +16,7 @@ | |||
16 | #include <linux/err.h> | 16 | #include <linux/err.h> |
17 | #include <linux/clk.h> | 17 | #include <linux/clk.h> |
18 | #include <linux/gpio.h> | 18 | #include <linux/gpio.h> |
19 | #include <linux/module.h> | ||
19 | #include <linux/slab.h> | 20 | #include <linux/slab.h> |
20 | #include <linux/mmc/host.h> | 21 | #include <linux/mmc/host.h> |
21 | #include <linux/mmc/mmc.h> | 22 | #include <linux/mmc/mmc.h> |
@@ -27,6 +28,7 @@ | |||
27 | #include "sdhci-pltfm.h" | 28 | #include "sdhci-pltfm.h" |
28 | #include "sdhci-esdhc.h" | 29 | #include "sdhci-esdhc.h" |
29 | 30 | ||
31 | #define SDHCI_CTRL_D3CD 0x08 | ||
30 | /* VENDOR SPEC register */ | 32 | /* VENDOR SPEC register */ |
31 | #define SDHCI_VENDOR_SPEC 0xC0 | 33 | #define SDHCI_VENDOR_SPEC 0xC0 |
32 | #define SDHCI_VENDOR_SPEC_SDIO_QUIRK 0x00000002 | 34 | #define SDHCI_VENDOR_SPEC_SDIO_QUIRK 0x00000002 |
@@ -141,13 +143,32 @@ static void esdhc_writel_le(struct sdhci_host *host, u32 val, int reg) | |||
141 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | 143 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
142 | struct pltfm_imx_data *imx_data = pltfm_host->priv; | 144 | struct pltfm_imx_data *imx_data = pltfm_host->priv; |
143 | struct esdhc_platform_data *boarddata = &imx_data->boarddata; | 145 | struct esdhc_platform_data *boarddata = &imx_data->boarddata; |
144 | 146 | u32 data; | |
145 | if (unlikely((reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE) | 147 | |
146 | && (boarddata->cd_type == ESDHC_CD_GPIO))) | 148 | if (unlikely(reg == SDHCI_INT_ENABLE || reg == SDHCI_SIGNAL_ENABLE)) { |
147 | /* | 149 | if (boarddata->cd_type == ESDHC_CD_GPIO) |
148 | * these interrupts won't work with a custom card_detect gpio | 150 | /* |
149 | */ | 151 | * These interrupts won't work with a custom |
150 | val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT); | 152 | * card_detect gpio (only applied to mx25/35) |
153 | */ | ||
154 | val &= ~(SDHCI_INT_CARD_REMOVE | SDHCI_INT_CARD_INSERT); | ||
155 | |||
156 | if (val & SDHCI_INT_CARD_INT) { | ||
157 | /* | ||
158 | * Clear and then set D3CD bit to avoid missing the | ||
159 | * card interrupt. This is a eSDHC controller problem | ||
160 | * so we need to apply the following workaround: clear | ||
161 | * and set D3CD bit will make eSDHC re-sample the card | ||
162 | * interrupt. In case a card interrupt was lost, | ||
163 | * re-sample it by the following steps. | ||
164 | */ | ||
165 | data = readl(host->ioaddr + SDHCI_HOST_CONTROL); | ||
166 | data &= ~SDHCI_CTRL_D3CD; | ||
167 | writel(data, host->ioaddr + SDHCI_HOST_CONTROL); | ||
168 | data |= SDHCI_CTRL_D3CD; | ||
169 | writel(data, host->ioaddr + SDHCI_HOST_CONTROL); | ||
170 | } | ||
171 | } | ||
151 | 172 | ||
152 | if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT) | 173 | if (unlikely((imx_data->flags & ESDHC_FLAG_MULTIBLK_NO_INT) |
153 | && (reg == SDHCI_INT_STATUS) | 174 | && (reg == SDHCI_INT_STATUS) |
@@ -217,8 +238,10 @@ static void esdhc_writeb_le(struct sdhci_host *host, u8 val, int reg) | |||
217 | */ | 238 | */ |
218 | return; | 239 | return; |
219 | case SDHCI_HOST_CONTROL: | 240 | case SDHCI_HOST_CONTROL: |
220 | /* FSL messed up here, so we can just keep those two */ | 241 | /* FSL messed up here, so we can just keep those three */ |
221 | new_val = val & (SDHCI_CTRL_LED | SDHCI_CTRL_4BITBUS); | 242 | new_val = val & (SDHCI_CTRL_LED | \ |
243 | SDHCI_CTRL_4BITBUS | \ | ||
244 | SDHCI_CTRL_D3CD); | ||
222 | /* ensure the endianess */ | 245 | /* ensure the endianess */ |
223 | new_val |= ESDHC_HOST_CONTROL_LE; | 246 | new_val |= ESDHC_HOST_CONTROL_LE; |
224 | /* DMA mode bits are shifted */ | 247 | /* DMA mode bits are shifted */ |
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c index 4198dbbc5c2..fc7e4a51562 100644 --- a/drivers/mmc/host/sdhci-pxav3.c +++ b/drivers/mmc/host/sdhci-pxav3.c | |||
@@ -195,7 +195,8 @@ static int __devinit sdhci_pxav3_probe(struct platform_device *pdev) | |||
195 | clk_enable(clk); | 195 | clk_enable(clk); |
196 | 196 | ||
197 | host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | 197 | host->quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
198 | | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC; | 198 | | SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC |
199 | | SDHCI_QUIRK_32BIT_ADMA_SIZE; | ||
199 | 200 | ||
200 | /* enable 1/8V DDR capable */ | 201 | /* enable 1/8V DDR capable */ |
201 | host->mmc->caps |= MMC_CAP_1_8V_DDR; | 202 | host->mmc->caps |= MMC_CAP_1_8V_DDR; |
diff --git a/drivers/mmc/host/sdhci-s3c.c b/drivers/mmc/host/sdhci-s3c.c index 460ffaf0f6d..fe886d6c474 100644 --- a/drivers/mmc/host/sdhci-s3c.c +++ b/drivers/mmc/host/sdhci-s3c.c | |||
@@ -19,6 +19,7 @@ | |||
19 | #include <linux/clk.h> | 19 | #include <linux/clk.h> |
20 | #include <linux/io.h> | 20 | #include <linux/io.h> |
21 | #include <linux/gpio.h> | 21 | #include <linux/gpio.h> |
22 | #include <linux/module.h> | ||
22 | 23 | ||
23 | #include <linux/mmc/host.h> | 24 | #include <linux/mmc/host.h> |
24 | 25 | ||
@@ -301,6 +302,8 @@ static int sdhci_s3c_platform_8bit_width(struct sdhci_host *host, int width) | |||
301 | ctrl &= ~SDHCI_CTRL_8BITBUS; | 302 | ctrl &= ~SDHCI_CTRL_8BITBUS; |
302 | break; | 303 | break; |
303 | default: | 304 | default: |
305 | ctrl &= ~SDHCI_CTRL_4BITBUS; | ||
306 | ctrl &= ~SDHCI_CTRL_8BITBUS; | ||
304 | break; | 307 | break; |
305 | } | 308 | } |
306 | 309 | ||
@@ -502,6 +505,9 @@ static int __devinit sdhci_s3c_probe(struct platform_device *pdev) | |||
502 | /* This host supports the Auto CMD12 */ | 505 | /* This host supports the Auto CMD12 */ |
503 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; | 506 | host->quirks |= SDHCI_QUIRK_MULTIBLOCK_READ_ACMD12; |
504 | 507 | ||
508 | /* Samsung SoCs need BROKEN_ADMA_ZEROLEN_DESC */ | ||
509 | host->quirks |= SDHCI_QUIRK_BROKEN_ADMA_ZEROLEN_DESC; | ||
510 | |||
505 | if (pdata->cd_type == S3C_SDHCI_CD_NONE || | 511 | if (pdata->cd_type == S3C_SDHCI_CD_NONE || |
506 | pdata->cd_type == S3C_SDHCI_CD_PERMANENT) | 512 | pdata->cd_type == S3C_SDHCI_CD_PERMANENT) |
507 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; | 513 | host->quirks |= SDHCI_QUIRK_BROKEN_CARD_DETECTION; |
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c index c31a3343340..0e02cc1df12 100644 --- a/drivers/mmc/host/sdhci.c +++ b/drivers/mmc/host/sdhci.c | |||
@@ -628,12 +628,11 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd) | |||
628 | /* timeout in us */ | 628 | /* timeout in us */ |
629 | if (!data) | 629 | if (!data) |
630 | target_timeout = cmd->cmd_timeout_ms * 1000; | 630 | target_timeout = cmd->cmd_timeout_ms * 1000; |
631 | else | 631 | else { |
632 | target_timeout = data->timeout_ns / 1000 + | 632 | target_timeout = data->timeout_ns / 1000; |
633 | data->timeout_clks / host->clock; | 633 | if (host->clock) |
634 | 634 | target_timeout += data->timeout_clks / host->clock; | |
635 | if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK) | 635 | } |
636 | host->timeout_clk = host->clock / 1000; | ||
637 | 636 | ||
638 | /* | 637 | /* |
639 | * Figure out needed cycles. | 638 | * Figure out needed cycles. |
@@ -645,7 +644,6 @@ static u8 sdhci_calc_timeout(struct sdhci_host *host, struct mmc_command *cmd) | |||
645 | * => | 644 | * => |
646 | * (1) / (2) > 2^6 | 645 | * (1) / (2) > 2^6 |
647 | */ | 646 | */ |
648 | BUG_ON(!host->timeout_clk); | ||
649 | count = 0; | 647 | count = 0; |
650 | current_timeout = (1 << 13) * 1000 / host->timeout_clk; | 648 | current_timeout = (1 << 13) * 1000 / host->timeout_clk; |
651 | while (current_timeout < target_timeout) { | 649 | while (current_timeout < target_timeout) { |
@@ -1867,9 +1865,6 @@ static void sdhci_tasklet_finish(unsigned long param) | |||
1867 | 1865 | ||
1868 | del_timer(&host->timer); | 1866 | del_timer(&host->timer); |
1869 | 1867 | ||
1870 | if (host->version >= SDHCI_SPEC_300) | ||
1871 | del_timer(&host->tuning_timer); | ||
1872 | |||
1873 | mrq = host->mrq; | 1868 | mrq = host->mrq; |
1874 | 1869 | ||
1875 | /* | 1870 | /* |
@@ -2461,22 +2456,6 @@ int sdhci_add_host(struct sdhci_host *host) | |||
2461 | host->max_clk = host->ops->get_max_clock(host); | 2456 | host->max_clk = host->ops->get_max_clock(host); |
2462 | } | 2457 | } |
2463 | 2458 | ||
2464 | host->timeout_clk = | ||
2465 | (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT; | ||
2466 | if (host->timeout_clk == 0) { | ||
2467 | if (host->ops->get_timeout_clock) { | ||
2468 | host->timeout_clk = host->ops->get_timeout_clock(host); | ||
2469 | } else if (!(host->quirks & | ||
2470 | SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) { | ||
2471 | printk(KERN_ERR | ||
2472 | "%s: Hardware doesn't specify timeout clock " | ||
2473 | "frequency.\n", mmc_hostname(mmc)); | ||
2474 | return -ENODEV; | ||
2475 | } | ||
2476 | } | ||
2477 | if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT) | ||
2478 | host->timeout_clk *= 1000; | ||
2479 | |||
2480 | /* | 2459 | /* |
2481 | * In case of Host Controller v3.00, find out whether clock | 2460 | * In case of Host Controller v3.00, find out whether clock |
2482 | * multiplier is supported. | 2461 | * multiplier is supported. |
@@ -2509,10 +2488,26 @@ int sdhci_add_host(struct sdhci_host *host) | |||
2509 | } else | 2488 | } else |
2510 | mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200; | 2489 | mmc->f_min = host->max_clk / SDHCI_MAX_DIV_SPEC_200; |
2511 | 2490 | ||
2491 | host->timeout_clk = | ||
2492 | (caps[0] & SDHCI_TIMEOUT_CLK_MASK) >> SDHCI_TIMEOUT_CLK_SHIFT; | ||
2493 | if (host->timeout_clk == 0) { | ||
2494 | if (host->ops->get_timeout_clock) { | ||
2495 | host->timeout_clk = host->ops->get_timeout_clock(host); | ||
2496 | } else if (!(host->quirks & | ||
2497 | SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK)) { | ||
2498 | printk(KERN_ERR | ||
2499 | "%s: Hardware doesn't specify timeout clock " | ||
2500 | "frequency.\n", mmc_hostname(mmc)); | ||
2501 | return -ENODEV; | ||
2502 | } | ||
2503 | } | ||
2504 | if (caps[0] & SDHCI_TIMEOUT_CLK_UNIT) | ||
2505 | host->timeout_clk *= 1000; | ||
2506 | |||
2512 | if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK) | 2507 | if (host->quirks & SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK) |
2513 | mmc->max_discard_to = (1 << 27) / (mmc->f_max / 1000); | 2508 | host->timeout_clk = mmc->f_max / 1000; |
2514 | else | 2509 | |
2515 | mmc->max_discard_to = (1 << 27) / host->timeout_clk; | 2510 | mmc->max_discard_to = (1 << 27) / host->timeout_clk; |
2516 | 2511 | ||
2517 | mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23; | 2512 | mmc->caps |= MMC_CAP_SDIO_IRQ | MMC_CAP_ERASE | MMC_CAP_CMD23; |
2518 | 2513 | ||
diff --git a/drivers/mmc/host/sh_mobile_sdhi.c b/drivers/mmc/host/sh_mobile_sdhi.c index 774f6439d7c..0c4a672f5db 100644 --- a/drivers/mmc/host/sh_mobile_sdhi.c +++ b/drivers/mmc/host/sh_mobile_sdhi.c | |||
@@ -120,11 +120,11 @@ static int __devinit sh_mobile_sdhi_probe(struct platform_device *pdev) | |||
120 | mmc_data->hclk = clk_get_rate(priv->clk); | 120 | mmc_data->hclk = clk_get_rate(priv->clk); |
121 | mmc_data->set_pwr = sh_mobile_sdhi_set_pwr; | 121 | mmc_data->set_pwr = sh_mobile_sdhi_set_pwr; |
122 | mmc_data->get_cd = sh_mobile_sdhi_get_cd; | 122 | mmc_data->get_cd = sh_mobile_sdhi_get_cd; |
123 | if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT) | ||
124 | mmc_data->write16_hook = sh_mobile_sdhi_write16_hook; | ||
125 | mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED; | 123 | mmc_data->capabilities = MMC_CAP_MMC_HIGHSPEED; |
126 | if (p) { | 124 | if (p) { |
127 | mmc_data->flags = p->tmio_flags; | 125 | mmc_data->flags = p->tmio_flags; |
126 | if (mmc_data->flags & TMIO_MMC_HAS_IDLE_WAIT) | ||
127 | mmc_data->write16_hook = sh_mobile_sdhi_write16_hook; | ||
128 | mmc_data->ocr_mask = p->tmio_ocr_mask; | 128 | mmc_data->ocr_mask = p->tmio_ocr_mask; |
129 | mmc_data->capabilities |= p->tmio_caps; | 129 | mmc_data->capabilities |= p->tmio_caps; |
130 | 130 | ||
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c index 8d185de90d2..44a9668c4b7 100644 --- a/drivers/mmc/host/tmio_mmc.c +++ b/drivers/mmc/host/tmio_mmc.c | |||
@@ -27,7 +27,6 @@ | |||
27 | static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state) | 27 | static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state) |
28 | { | 28 | { |
29 | const struct mfd_cell *cell = mfd_get_cell(dev); | 29 | const struct mfd_cell *cell = mfd_get_cell(dev); |
30 | struct mmc_host *mmc = platform_get_drvdata(dev); | ||
31 | int ret; | 30 | int ret; |
32 | 31 | ||
33 | ret = tmio_mmc_host_suspend(&dev->dev); | 32 | ret = tmio_mmc_host_suspend(&dev->dev); |
@@ -42,7 +41,6 @@ static int tmio_mmc_suspend(struct platform_device *dev, pm_message_t state) | |||
42 | static int tmio_mmc_resume(struct platform_device *dev) | 41 | static int tmio_mmc_resume(struct platform_device *dev) |
43 | { | 42 | { |
44 | const struct mfd_cell *cell = mfd_get_cell(dev); | 43 | const struct mfd_cell *cell = mfd_get_cell(dev); |
45 | struct mmc_host *mmc = platform_get_drvdata(dev); | ||
46 | int ret = 0; | 44 | int ret = 0; |
47 | 45 | ||
48 | /* Tell the MFD core we are ready to be enabled */ | 46 | /* Tell the MFD core we are ready to be enabled */ |