993c2ca4f0cae1f2b88f3c01d474778a39ce8b5c
[linux-2.6.git] / drivers / usb / renesas_usbhs / mod.c
1 /*
2  * Renesas USB driver
3  *
4  * Copyright (C) 2011 Renesas Solutions Corp.
5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
15  *
16  */
17 #include <linux/interrupt.h>
18
19 #include "./common.h"
20 #include "./mod.h"
21
22 #define usbhs_priv_to_modinfo(priv) (&priv->mod_info)
23 #define usbhs_mod_info_call(priv, func, param...)       \
24 ({                                              \
25         struct usbhs_mod_info *info;            \
26         info = usbhs_priv_to_modinfo(priv);     \
27         !info->func ? 0 :                       \
28          info->func(param);                     \
29 })
30
31 /*
32  *              autonomy
33  *
34  * these functions are used if platform doesn't have external phy.
35  *  -> there is no "notify_hotplug" callback from platform
36  *  -> call "notify_hotplug" by itself
37  *  -> use own interrupt to connect/disconnect
38  *  -> it mean module clock is always ON
39  *             ~~~~~~~~~~~~~~~~~~~~~~~~~
40  */
41 static int usbhsm_autonomy_get_vbus(struct platform_device *pdev)
42 {
43         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
44
45         return  VBSTS & usbhs_read(priv, INTSTS0);
46 }
47
48 static int usbhsm_autonomy_irq_vbus(struct usbhs_priv *priv,
49                                     struct usbhs_irq_state *irq_state)
50 {
51         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
52
53         return usbhsc_drvcllbck_notify_hotplug(pdev);
54 }
55
56 void usbhs_mod_autonomy_mode(struct usbhs_priv *priv)
57 {
58         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
59
60         info->irq_vbus          = usbhsm_autonomy_irq_vbus;
61         priv->pfunc->get_vbus   = usbhsm_autonomy_get_vbus;
62
63         usbhs_irq_callback_update(priv, NULL);
64 }
65
66 /*
67  *              host / gadget functions
68  *
69  * renesas_usbhs host/gadget can register itself by below functions.
70  * these functions are called when probe
71  *
72  */
73 void usbhs_mod_register(struct usbhs_priv *priv, struct usbhs_mod *mod, int id)
74 {
75         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
76
77         info->mod[id]   = mod;
78         mod->priv       = priv;
79 }
80
81 struct usbhs_mod *usbhs_mod_get(struct usbhs_priv *priv, int id)
82 {
83         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
84         struct usbhs_mod *ret = NULL;
85
86         switch (id) {
87         case USBHS_HOST:
88         case USBHS_GADGET:
89                 ret = info->mod[id];
90                 break;
91         }
92
93         return ret;
94 }
95
96 int usbhs_mod_is_host(struct usbhs_priv *priv)
97 {
98         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
99         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
100
101         if (!mod)
102                 return -EINVAL;
103
104         return info->mod[USBHS_HOST] == mod;
105 }
106
107 struct usbhs_mod *usbhs_mod_get_current(struct usbhs_priv *priv)
108 {
109         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
110
111         return info->curt;
112 }
113
114 int usbhs_mod_change(struct usbhs_priv *priv, int id)
115 {
116         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
117         struct usbhs_mod *mod = NULL;
118         int ret = 0;
119
120         /* id < 0 mean no current */
121         switch (id) {
122         case USBHS_HOST:
123         case USBHS_GADGET:
124                 mod = info->mod[id];
125                 break;
126         default:
127                 ret = -EINVAL;
128         }
129         info->curt = mod;
130
131         return ret;
132 }
133
134 static irqreturn_t usbhs_interrupt(int irq, void *data);
135 int usbhs_mod_probe(struct usbhs_priv *priv)
136 {
137         struct device *dev = usbhs_priv_to_dev(priv);
138         int ret;
139
140         /*
141          * install host/gadget driver
142          */
143         ret = usbhs_mod_gadget_probe(priv);
144         if (ret < 0)
145                 return ret;
146
147         /* irq settings */
148         ret = request_irq(priv->irq, usbhs_interrupt,
149                           0, dev_name(dev), priv);
150         if (ret) {
151                 dev_err(dev, "irq request err\n");
152                 goto mod_init_gadget_err;
153         }
154
155         return ret;
156
157 mod_init_gadget_err:
158         usbhs_mod_gadget_remove(priv);
159
160         return ret;
161 }
162
163 void usbhs_mod_remove(struct usbhs_priv *priv)
164 {
165         usbhs_mod_gadget_remove(priv);
166         free_irq(priv->irq, priv);
167 }
168
169 /*
170  *              status functions
171  */
172 int usbhs_status_get_device_state(struct usbhs_irq_state *irq_state)
173 {
174         int state = irq_state->intsts0 & DVSQ_MASK;
175
176         switch (state) {
177         case POWER_STATE:
178         case DEFAULT_STATE:
179         case ADDRESS_STATE:
180         case CONFIGURATION_STATE:
181                 return state;
182         }
183
184         return -EIO;
185 }
186
187 int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
188 {
189         /*
190          * return value
191          *
192          * IDLE_SETUP_STAGE
193          * READ_DATA_STAGE
194          * READ_STATUS_STAGE
195          * WRITE_DATA_STAGE
196          * WRITE_STATUS_STAGE
197          * NODATA_STATUS_STAGE
198          * SEQUENCE_ERROR
199          */
200         return (int)irq_state->intsts0 & CTSQ_MASK;
201 }
202
203 static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
204                                       struct usbhs_irq_state *state)
205 {
206         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
207
208         state->intsts0 = usbhs_read(priv, INTSTS0);
209         state->intsts1 = usbhs_read(priv, INTSTS1);
210
211         /* mask */
212         if (mod) {
213                 state->brdysts = usbhs_read(priv, BRDYSTS);
214                 state->nrdysts = usbhs_read(priv, NRDYSTS);
215                 state->bempsts = usbhs_read(priv, BEMPSTS);
216
217                 state->bempsts &= mod->irq_bempsts;
218                 state->brdysts &= mod->irq_brdysts;
219         }
220 }
221
222 /*
223  *              interrupt
224  */
225 #define INTSTS0_MAGIC 0xF800 /* acknowledge magical interrupt sources */
226 #define INTSTS1_MAGIC 0xA870 /* acknowledge magical interrupt sources */
227 static irqreturn_t usbhs_interrupt(int irq, void *data)
228 {
229         struct usbhs_priv *priv = data;
230         struct usbhs_irq_state irq_state;
231
232         usbhs_status_get_each_irq(priv, &irq_state);
233
234         /*
235          * clear interrupt
236          *
237          * The hardware is _very_ picky to clear interrupt bit.
238          * Especially INTSTS0_MAGIC, INTSTS1_MAGIC value.
239          *
240          * see
241          *      "Operation"
242          *       - "Control Transfer (DCP)"
243          *         - Function :: VALID bit should 0
244          */
245         usbhs_write(priv, INTSTS0, ~irq_state.intsts0 & INTSTS0_MAGIC);
246         usbhs_write(priv, INTSTS1, ~irq_state.intsts1 & INTSTS1_MAGIC);
247
248         usbhs_write(priv, BRDYSTS, 0);
249         usbhs_write(priv, NRDYSTS, 0);
250         usbhs_write(priv, BEMPSTS, 0);
251
252         /*
253          * call irq callback functions
254          * see also
255          *      usbhs_irq_setting_update
256          */
257
258         /* INTSTS0 */
259         if (irq_state.intsts0 & VBINT)
260                 usbhs_mod_info_call(priv, irq_vbus, priv, &irq_state);
261
262         if (irq_state.intsts0 & DVST)
263                 usbhs_mod_call(priv, irq_dev_state, priv, &irq_state);
264
265         if (irq_state.intsts0 & CTRT)
266                 usbhs_mod_call(priv, irq_ctrl_stage, priv, &irq_state);
267
268         if (irq_state.intsts0 & BEMP)
269                 usbhs_mod_call(priv, irq_empty, priv, &irq_state);
270
271         if (irq_state.intsts0 & BRDY)
272                 usbhs_mod_call(priv, irq_ready, priv, &irq_state);
273
274         /* INTSTS1 */
275         if (irq_state.intsts1 & ATTCH)
276                 usbhs_mod_call(priv, irq_attch, priv, &irq_state);
277
278         if (irq_state.intsts1 & DTCH)
279                 usbhs_mod_call(priv, irq_dtch, priv, &irq_state);
280
281         if (irq_state.intsts1 & SIGN)
282                 usbhs_mod_call(priv, irq_sign, priv, &irq_state);
283
284         if (irq_state.intsts1 & SACK)
285                 usbhs_mod_call(priv, irq_sack, priv, &irq_state);
286
287         return IRQ_HANDLED;
288 }
289
290 void usbhs_irq_callback_update(struct usbhs_priv *priv, struct usbhs_mod *mod)
291 {
292         u16 intenb0 = 0;
293         u16 intenb1 = 0;
294         struct usbhs_mod_info *info = usbhs_priv_to_modinfo(priv);
295
296         /*
297          * BEMPENB/BRDYENB are picky.
298          * below method is required
299          *
300          *  - clear  INTSTS0
301          *  - update BEMPENB/BRDYENB
302          *  - update INTSTS0
303          */
304         usbhs_write(priv, INTENB0, 0);
305         usbhs_write(priv, INTENB1, 0);
306
307         usbhs_write(priv, BEMPENB, 0);
308         usbhs_write(priv, BRDYENB, 0);
309
310         /*
311          * see also
312          *      usbhs_interrupt
313          */
314
315         /*
316          * it don't enable DVSE (intenb0) here
317          * but "mod->irq_dev_state" will be called.
318          */
319         if (info->irq_vbus)
320                 intenb0 |= VBSE;
321
322         if (mod) {
323                 /*
324                  * INTSTS0
325                  */
326                 if (mod->irq_ctrl_stage)
327                         intenb0 |= CTRE;
328
329                 if (mod->irq_empty && mod->irq_bempsts) {
330                         usbhs_write(priv, BEMPENB, mod->irq_bempsts);
331                         intenb0 |= BEMPE;
332                 }
333
334                 if (mod->irq_ready && mod->irq_brdysts) {
335                         usbhs_write(priv, BRDYENB, mod->irq_brdysts);
336                         intenb0 |= BRDYE;
337                 }
338
339                 /*
340                  * INTSTS1
341                  */
342                 if (mod->irq_attch)
343                         intenb1 |= ATTCHE;
344
345                 if (mod->irq_attch)
346                         intenb1 |= DTCHE;
347
348                 if (mod->irq_sign)
349                         intenb1 |= SIGNE;
350
351                 if (mod->irq_sack)
352                         intenb1 |= SACKE;
353         }
354
355         if (intenb0)
356                 usbhs_write(priv, INTENB0, intenb0);
357
358         if (intenb1)
359                 usbhs_write(priv, INTENB1, intenb1);
360 }