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