Commit | Line | Data |
---|---|---|
985b1aa0 MR |
1 | /* |
2 | * sdhci-dove.c Support for SDHCI on Marvell's Dove SoC | |
3 | * | |
4 | * Author: Saeed Bishara <saeed@marvell.com> | |
5 | * Mike Rapoport <mike@compulab.co.il> | |
6 | * Based on sdhci-cns3xxx.c | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with this program; if not, write to the Free Software | |
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
20 | */ | |
21 | ||
30b87c60 SH |
22 | #include <linux/clk.h> |
23 | #include <linux/err.h> | |
f8ec589b RK |
24 | #include <linux/gpio.h> |
25 | #include <linux/io.h> | |
985b1aa0 | 26 | #include <linux/mmc/host.h> |
f8ec589b | 27 | #include <linux/module.h> |
4ee7ed0d | 28 | #include <linux/of.h> |
f8ec589b | 29 | #include <linux/of_gpio.h> |
985b1aa0 | 30 | |
985b1aa0 MR |
31 | #include "sdhci-pltfm.h" |
32 | ||
30b87c60 SH |
33 | struct sdhci_dove_priv { |
34 | struct clk *clk; | |
f8ec589b | 35 | int gpio_cd; |
30b87c60 SH |
36 | }; |
37 | ||
f8ec589b RK |
38 | static irqreturn_t sdhci_dove_carddetect_irq(int irq, void *data) |
39 | { | |
40 | struct sdhci_host *host = data; | |
41 | ||
42 | tasklet_schedule(&host->card_tasklet); | |
43 | return IRQ_HANDLED; | |
44 | } | |
45 | ||
985b1aa0 MR |
46 | static u16 sdhci_dove_readw(struct sdhci_host *host, int reg) |
47 | { | |
48 | u16 ret; | |
49 | ||
50 | switch (reg) { | |
51 | case SDHCI_HOST_VERSION: | |
52 | case SDHCI_SLOT_INT_STATUS: | |
53 | /* those registers don't exist */ | |
54 | return 0; | |
55 | default: | |
56 | ret = readw(host->ioaddr + reg); | |
57 | } | |
58 | return ret; | |
59 | } | |
60 | ||
61 | static u32 sdhci_dove_readl(struct sdhci_host *host, int reg) | |
62 | { | |
f8ec589b RK |
63 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); |
64 | struct sdhci_dove_priv *priv = pltfm_host->priv; | |
985b1aa0 MR |
65 | u32 ret; |
66 | ||
f8ec589b RK |
67 | ret = readl(host->ioaddr + reg); |
68 | ||
985b1aa0 MR |
69 | switch (reg) { |
70 | case SDHCI_CAPABILITIES: | |
985b1aa0 MR |
71 | /* Mask the support for 3.0V */ |
72 | ret &= ~SDHCI_CAN_VDD_300; | |
73 | break; | |
f8ec589b RK |
74 | case SDHCI_PRESENT_STATE: |
75 | if (gpio_is_valid(priv->gpio_cd)) { | |
76 | if (gpio_get_value(priv->gpio_cd) == 0) | |
77 | ret |= SDHCI_CARD_PRESENT; | |
78 | else | |
79 | ret &= ~SDHCI_CARD_PRESENT; | |
80 | } | |
81 | break; | |
985b1aa0 MR |
82 | } |
83 | return ret; | |
84 | } | |
85 | ||
86 | static struct sdhci_ops sdhci_dove_ops = { | |
87 | .read_w = sdhci_dove_readw, | |
88 | .read_l = sdhci_dove_readl, | |
89 | }; | |
90 | ||
85d6509d | 91 | static struct sdhci_pltfm_data sdhci_dove_pdata = { |
985b1aa0 MR |
92 | .ops = &sdhci_dove_ops, |
93 | .quirks = SDHCI_QUIRK_NO_SIMULT_VDD_AND_POWER | | |
94 | SDHCI_QUIRK_NO_BUSY_IRQ | | |
95 | SDHCI_QUIRK_BROKEN_TIMEOUT_VAL | | |
a9ca1d54 SH |
96 | SDHCI_QUIRK_FORCE_DMA | |
97 | SDHCI_QUIRK_NO_HISPD_BIT, | |
985b1aa0 | 98 | }; |
85d6509d | 99 | |
c3be1efd | 100 | static int sdhci_dove_probe(struct platform_device *pdev) |
85d6509d | 101 | { |
30b87c60 SH |
102 | struct sdhci_host *host; |
103 | struct sdhci_pltfm_host *pltfm_host; | |
104 | struct sdhci_dove_priv *priv; | |
105 | int ret; | |
106 | ||
30b87c60 SH |
107 | priv = devm_kzalloc(&pdev->dev, sizeof(struct sdhci_dove_priv), |
108 | GFP_KERNEL); | |
109 | if (!priv) { | |
110 | dev_err(&pdev->dev, "unable to allocate private data"); | |
ee3298a2 | 111 | return -ENOMEM; |
30b87c60 SH |
112 | } |
113 | ||
7430e77e | 114 | priv->clk = devm_clk_get(&pdev->dev, NULL); |
ee3298a2 | 115 | |
f8ec589b RK |
116 | if (pdev->dev.of_node) { |
117 | priv->gpio_cd = of_get_named_gpio(pdev->dev.of_node, | |
118 | "cd-gpios", 0); | |
119 | } else { | |
120 | priv->gpio_cd = -EINVAL; | |
121 | } | |
122 | ||
123 | if (gpio_is_valid(priv->gpio_cd)) { | |
124 | ret = gpio_request(priv->gpio_cd, "sdhci-cd"); | |
125 | if (ret) { | |
126 | dev_err(&pdev->dev, "card detect gpio request failed: %d\n", | |
127 | ret); | |
128 | return ret; | |
129 | } | |
130 | gpio_direction_input(priv->gpio_cd); | |
131 | } | |
132 | ||
c430689f RK |
133 | host = sdhci_pltfm_init(pdev, &sdhci_dove_pdata); |
134 | if (IS_ERR(host)) { | |
135 | ret = PTR_ERR(host); | |
136 | goto err_sdhci_pltfm_init; | |
137 | } | |
ee3298a2 | 138 | |
30b87c60 SH |
139 | pltfm_host = sdhci_priv(host); |
140 | pltfm_host->priv = priv; | |
141 | ||
c430689f RK |
142 | if (!IS_ERR(priv->clk)) |
143 | clk_prepare_enable(priv->clk); | |
144 | ||
145 | sdhci_get_of_property(pdev); | |
146 | ||
147 | ret = sdhci_add_host(host); | |
148 | if (ret) | |
149 | goto err_sdhci_add; | |
150 | ||
f8ec589b RK |
151 | /* |
152 | * We must request the IRQ after sdhci_add_host(), as the tasklet only | |
153 | * gets setup in sdhci_add_host() and we oops. | |
154 | */ | |
155 | if (gpio_is_valid(priv->gpio_cd)) { | |
156 | ret = request_irq(gpio_to_irq(priv->gpio_cd), | |
157 | sdhci_dove_carddetect_irq, | |
158 | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, | |
159 | mmc_hostname(host->mmc), host); | |
160 | if (ret) { | |
161 | dev_err(&pdev->dev, "card detect irq request failed: %d\n", | |
162 | ret); | |
163 | goto err_request_irq; | |
164 | } | |
165 | } | |
166 | ||
30b87c60 SH |
167 | return 0; |
168 | ||
f8ec589b RK |
169 | err_request_irq: |
170 | sdhci_remove_host(host, 0); | |
c430689f | 171 | err_sdhci_add: |
7430e77e | 172 | if (!IS_ERR(priv->clk)) |
ee3298a2 | 173 | clk_disable_unprepare(priv->clk); |
c430689f RK |
174 | sdhci_pltfm_free(pdev); |
175 | err_sdhci_pltfm_init: | |
f8ec589b RK |
176 | if (gpio_is_valid(priv->gpio_cd)) |
177 | gpio_free(priv->gpio_cd); | |
30b87c60 | 178 | return ret; |
85d6509d SG |
179 | } |
180 | ||
6e0ee714 | 181 | static int sdhci_dove_remove(struct platform_device *pdev) |
85d6509d | 182 | { |
30b87c60 SH |
183 | struct sdhci_host *host = platform_get_drvdata(pdev); |
184 | struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host); | |
185 | struct sdhci_dove_priv *priv = pltfm_host->priv; | |
186 | ||
ee3298a2 RKAL |
187 | sdhci_pltfm_unregister(pdev); |
188 | ||
f8ec589b RK |
189 | if (gpio_is_valid(priv->gpio_cd)) { |
190 | free_irq(gpio_to_irq(priv->gpio_cd), host); | |
191 | gpio_free(priv->gpio_cd); | |
192 | } | |
193 | ||
7430e77e | 194 | if (!IS_ERR(priv->clk)) |
ee3298a2 | 195 | clk_disable_unprepare(priv->clk); |
7430e77e | 196 | |
ee3298a2 | 197 | return 0; |
85d6509d SG |
198 | } |
199 | ||
498d83e7 | 200 | static const struct of_device_id sdhci_dove_of_match_table[] = { |
4ee7ed0d SH |
201 | { .compatible = "marvell,dove-sdhci", }, |
202 | {} | |
203 | }; | |
204 | MODULE_DEVICE_TABLE(of, sdhci_dove_of_match_table); | |
205 | ||
85d6509d SG |
206 | static struct platform_driver sdhci_dove_driver = { |
207 | .driver = { | |
208 | .name = "sdhci-dove", | |
209 | .owner = THIS_MODULE, | |
29495aa0 | 210 | .pm = SDHCI_PLTFM_PMOPS, |
4ee7ed0d | 211 | .of_match_table = of_match_ptr(sdhci_dove_of_match_table), |
85d6509d SG |
212 | }, |
213 | .probe = sdhci_dove_probe, | |
0433c143 | 214 | .remove = sdhci_dove_remove, |
85d6509d SG |
215 | }; |
216 | ||
d1f81a64 | 217 | module_platform_driver(sdhci_dove_driver); |
85d6509d SG |
218 | |
219 | MODULE_DESCRIPTION("SDHCI driver for Dove"); | |
220 | MODULE_AUTHOR("Saeed Bishara <saeed@marvell.com>, " | |
221 | "Mike Rapoport <mike@compulab.co.il>"); | |
222 | MODULE_LICENSE("GPL v2"); |