1144513Simp// SPDX-License-Identifier: GPL-2.0+
2144513Simp/*
3144513Simp * Freescale QUICC Engine USB Host Controller Driver
4144513Simp *
5144513Simp * Copyright (c) Freescale Semicondutor, Inc. 2006.
6144513Simp *               Shlomi Gridish <gridish@freescale.com>
7 *               Jerry Huang <Chang-Ming.Huang@freescale.com>
8 * Copyright (c) Logic Product Development, Inc. 2007
9 *               Peter Barada <peterb@logicpd.com>
10 * Copyright (c) MontaVista Software, Inc. 2008.
11 *               Anton Vorontsov <avorontsov@ru.mvista.com>
12 */
13
14#include <linux/kernel.h>
15#include <linux/types.h>
16#include <linux/spinlock.h>
17#include <linux/errno.h>
18#include <linux/slab.h>
19#include <linux/list.h>
20#include <linux/usb.h>
21#include <linux/usb/hcd.h>
22#include "fhci.h"
23
24/* maps the hardware error code to the USB error code */
25static int status_to_error(u32 status)
26{
27	if (status == USB_TD_OK)
28		return 0;
29	else if (status & USB_TD_RX_ER_CRC)
30		return -EILSEQ;
31	else if (status & USB_TD_RX_ER_NONOCT)
32		return -EPROTO;
33	else if (status & USB_TD_RX_ER_OVERUN)
34		return -ECOMM;
35	else if (status & USB_TD_RX_ER_BITSTUFF)
36		return -EPROTO;
37	else if (status & USB_TD_RX_ER_PID)
38		return -EILSEQ;
39	else if (status & (USB_TD_TX_ER_NAK | USB_TD_TX_ER_TIMEOUT))
40		return -ETIMEDOUT;
41	else if (status & USB_TD_TX_ER_STALL)
42		return -EPIPE;
43	else if (status & USB_TD_TX_ER_UNDERUN)
44		return -ENOSR;
45	else if (status & USB_TD_RX_DATA_UNDERUN)
46		return -EREMOTEIO;
47	else if (status & USB_TD_RX_DATA_OVERUN)
48		return -EOVERFLOW;
49	else
50		return -EINVAL;
51}
52
53void fhci_add_td_to_frame(struct fhci_time_frame *frame, struct td *td)
54{
55	list_add_tail(&td->frame_lh, &frame->tds_list);
56}
57
58void fhci_add_tds_to_ed(struct ed *ed, struct td **td_list, int number)
59{
60	int i;
61
62	for (i = 0; i < number; i++) {
63		struct td *td = td_list[i];
64		list_add_tail(&td->node, &ed->td_list);
65	}
66	if (ed->td_head == NULL)
67		ed->td_head = td_list[0];
68}
69
70static struct td *peek_td_from_ed(struct ed *ed)
71{
72	struct td *td;
73
74	if (!list_empty(&ed->td_list))
75		td = list_entry(ed->td_list.next, struct td, node);
76	else
77		td = NULL;
78
79	return td;
80}
81
82struct td *fhci_remove_td_from_frame(struct fhci_time_frame *frame)
83{
84	struct td *td;
85
86	if (!list_empty(&frame->tds_list)) {
87		td = list_entry(frame->tds_list.next, struct td, frame_lh);
88		list_del_init(frame->tds_list.next);
89	} else
90		td = NULL;
91
92	return td;
93}
94
95struct td *fhci_peek_td_from_frame(struct fhci_time_frame *frame)
96{
97	struct td *td;
98
99	if (!list_empty(&frame->tds_list))
100		td = list_entry(frame->tds_list.next, struct td, frame_lh);
101	else
102		td = NULL;
103
104	return td;
105}
106
107struct td *fhci_remove_td_from_ed(struct ed *ed)
108{
109	struct td *td;
110
111	if (!list_empty(&ed->td_list)) {
112		td = list_entry(ed->td_list.next, struct td, node);
113		list_del_init(ed->td_list.next);
114
115		/* if this TD was the ED's head, find next TD */
116		if (!list_empty(&ed->td_list))
117			ed->td_head = list_entry(ed->td_list.next, struct td,
118						 node);
119		else
120			ed->td_head = NULL;
121	} else
122		td = NULL;
123
124	return td;
125}
126
127struct td *fhci_remove_td_from_done_list(struct fhci_controller_list *p_list)
128{
129	struct td *td;
130
131	if (!list_empty(&p_list->done_list)) {
132		td = list_entry(p_list->done_list.next, struct td, node);
133		list_del_init(p_list->done_list.next);
134	} else
135		td = NULL;
136
137	return td;
138}
139
140void fhci_move_td_from_ed_to_done_list(struct fhci_usb *usb, struct ed *ed)
141{
142	struct td *td;
143
144	td = ed->td_head;
145	list_del_init(&td->node);
146
147	/* If this TD was the ED's head,find next TD */
148	if (!list_empty(&ed->td_list))
149		ed->td_head = list_entry(ed->td_list.next, struct td, node);
150	else {
151		ed->td_head = NULL;
152		ed->state = FHCI_ED_SKIP;
153	}
154	ed->toggle_carry = td->toggle;
155	list_add_tail(&td->node, &usb->hc_list->done_list);
156	if (td->ioc)
157		usb->transfer_confirm(usb->fhci);
158}
159
160/* free done FHCI URB resource such as ED and TD */
161static void free_urb_priv(struct fhci_hcd *fhci, struct urb *urb)
162{
163	int i;
164	struct urb_priv *urb_priv = urb->hcpriv;
165	struct ed *ed = urb_priv->ed;
166
167	for (i = 0; i < urb_priv->num_of_tds; i++) {
168		list_del_init(&urb_priv->tds[i]->node);
169		fhci_recycle_empty_td(fhci, urb_priv->tds[i]);
170	}
171
172	/* if this TD was the ED's head,find the next TD */
173	if (!list_empty(&ed->td_list))
174		ed->td_head = list_entry(ed->td_list.next, struct td, node);
175	else
176		ed->td_head = NULL;
177
178	kfree(urb_priv->tds);
179	kfree(urb_priv);
180	urb->hcpriv = NULL;
181
182	/* if this TD was the ED's head,find next TD */
183	if (ed->td_head == NULL)
184		list_del_init(&ed->node);
185	fhci->active_urbs--;
186}
187
188/* this routine called to complete and free done URB */
189void fhci_urb_complete_free(struct fhci_hcd *fhci, struct urb *urb)
190{
191	free_urb_priv(fhci, urb);
192
193	if (urb->status == -EINPROGRESS) {
194		if (urb->actual_length != urb->transfer_buffer_length &&
195				urb->transfer_flags & URB_SHORT_NOT_OK)
196			urb->status = -EREMOTEIO;
197		else
198			urb->status = 0;
199	}
200
201	usb_hcd_unlink_urb_from_ep(fhci_to_hcd(fhci), urb);
202
203	spin_unlock(&fhci->lock);
204
205	usb_hcd_giveback_urb(fhci_to_hcd(fhci), urb, urb->status);
206
207	spin_lock(&fhci->lock);
208}
209
210/*
211 * caculate transfer length/stats and update the urb
212 * Precondition: irqsafe(only for urb-?status locking)
213 */
214void fhci_done_td(struct urb *urb, struct td *td)
215{
216	struct ed *ed = td->ed;
217	u32 cc = td->status;
218
219	/* ISO...drivers see per-TD length/status */
220	if (ed->mode == FHCI_TF_ISO) {
221		u32 len;
222		if (!(urb->transfer_flags & URB_SHORT_NOT_OK &&
223				cc == USB_TD_RX_DATA_UNDERUN))
224			cc = USB_TD_OK;
225
226		if (usb_pipeout(urb->pipe))
227			len = urb->iso_frame_desc[td->iso_index].length;
228		else
229			len = td->actual_len;
230
231		urb->actual_length += len;
232		urb->iso_frame_desc[td->iso_index].actual_length = len;
233		urb->iso_frame_desc[td->iso_index].status =
234			status_to_error(cc);
235	}
236
237	/* BULK,INT,CONTROL... drivers see aggregate length/status,
238	 * except that "setup" bytes aren't counted and "short" transfers
239	 * might not be reported as errors.
240	 */
241	else {
242		if (td->error_cnt >= 3)
243			urb->error_count = 3;
244
245		/* control endpoint only have soft stalls */
246
247		/* update packet status if needed(short may be ok) */
248		if (!(urb->transfer_flags & URB_SHORT_NOT_OK) &&
249				cc == USB_TD_RX_DATA_UNDERUN) {
250			ed->state = FHCI_ED_OPER;
251			cc = USB_TD_OK;
252		}
253		if (cc != USB_TD_OK) {
254			if (urb->status == -EINPROGRESS)
255				urb->status = status_to_error(cc);
256		}
257
258		/* count all non-empty packets except control SETUP packet */
259		if (td->type != FHCI_TA_SETUP || td->iso_index != 0)
260			urb->actual_length += td->actual_len;
261	}
262}
263
264/* there are some pedning request to unlink */
265void fhci_del_ed_list(struct fhci_hcd *fhci, struct ed *ed)
266{
267	struct td *td = peek_td_from_ed(ed);
268	struct urb *urb = td->urb;
269	struct urb_priv *urb_priv = urb->hcpriv;
270
271	if (urb_priv->state == URB_DEL) {
272		td = fhci_remove_td_from_ed(ed);
273		/* HC may have partly processed this TD */
274		if (td->status != USB_TD_INPROGRESS)
275			fhci_done_td(urb, td);
276
277		/* URB is done;clean up */
278		if (++(urb_priv->tds_cnt) == urb_priv->num_of_tds)
279			fhci_urb_complete_free(fhci, urb);
280	}
281}
282