source: rtems-libbsd/freebsd/sys/dev/usb/controller/saf1761_otg.c @ c37f9fb

5-freebsd-12
Last change on this file since c37f9fb was c37f9fb, checked in by Sebastian Huber <sebastian.huber@…>, on Aug 7, 2018 at 12:56:50 PM

Update to FreeBSD head 2017-08-01

Git mirror commit f5002f5e5f78cae9f0269d812dc0aedb0339312c.

Update #3472.

  • Property mode set to 100644
File size: 91.3 KB
Line 
1#include <machine/rtems-bsd-kernel-space.h>
2
3/* $FreeBSD$ */
4/*-
5 * Copyright (c) 2014 Hans Petter Selasky <hselasky@FreeBSD.org>
6 * All rights reserved.
7 *
8 * This software was developed by SRI International and the University of
9 * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237)
10 * ("CTSRD"), as part of the DARPA CRASH research programme.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34/*
35 * This file contains the driver for the SAF1761 series USB OTG
36 * controller.
37 *
38 * Datasheet is available from:
39 * http://www.nxp.com/products/automotive/multimedia/usb/SAF1761BE.html
40 */
41
42#ifdef USB_GLOBAL_INCLUDE_FILE
43#include USB_GLOBAL_INCLUDE_FILE
44#else
45#include <sys/stdint.h>
46#include <sys/stddef.h>
47#include <sys/param.h>
48#include <sys/queue.h>
49#include <sys/types.h>
50#include <sys/systm.h>
51#include <sys/kernel.h>
52#include <sys/bus.h>
53#include <sys/module.h>
54#include <sys/lock.h>
55#include <sys/mutex.h>
56#include <sys/condvar.h>
57#include <sys/sysctl.h>
58#include <sys/sx.h>
59#include <rtems/bsd/sys/unistd.h>
60#include <sys/callout.h>
61#include <sys/malloc.h>
62#include <sys/priv.h>
63#include <sys/libkern.h>
64
65#include <dev/usb/usb.h>
66#include <dev/usb/usbdi.h>
67
68#define USB_DEBUG_VAR saf1761_otg_debug
69
70#include <dev/usb/usb_core.h>
71#include <dev/usb/usb_debug.h>
72#include <dev/usb/usb_busdma.h>
73#include <dev/usb/usb_process.h>
74#include <dev/usb/usb_transfer.h>
75#include <dev/usb/usb_device.h>
76#include <dev/usb/usb_hub.h>
77#include <dev/usb/usb_util.h>
78
79#include <dev/usb/usb_controller.h>
80#include <dev/usb/usb_bus.h>
81#endif                                  /* USB_GLOBAL_INCLUDE_FILE */
82
83#include <dev/usb/controller/saf1761_otg.h>
84#include <dev/usb/controller/saf1761_otg_reg.h>
85#ifdef __rtems__
86#include <rtems.h>
87#include <bsp.h>
88#ifdef LIBBSP_ARM_ATSAM_BSP_H
89#include <bsp/pin-config.h>
90#endif /* LIBBSP_ARM_ATSAM_BSP_H */
91#endif /* __rtems__ */
92
93#define SAF1761_OTG_BUS2SC(bus) \
94   ((struct saf1761_otg_softc *)(((uint8_t *)(bus)) - \
95    ((uint8_t *)&(((struct saf1761_otg_softc *)0)->sc_bus))))
96
97#define SAF1761_OTG_PC2UDEV(pc) \
98   (USB_DMATAG_TO_XROOT((pc)->tag_parent)->udev)
99
100#define SAF1761_DCINTERRUPT_THREAD_IRQ                  \
101  (SOTG_DCINTERRUPT_IEVBUS | SOTG_DCINTERRUPT_IEBRST |  \
102  SOTG_DCINTERRUPT_IERESM | SOTG_DCINTERRUPT_IESUSP)
103
104#ifdef USB_DEBUG
105static int saf1761_otg_debug = 0;
106static int saf1761_otg_forcefs = 0;
107
108static 
109SYSCTL_NODE(_hw_usb, OID_AUTO, saf1761_otg, CTLFLAG_RW, 0,
110    "USB SAF1761 DCI");
111
112SYSCTL_INT(_hw_usb_saf1761_otg, OID_AUTO, debug, CTLFLAG_RWTUN,
113    &saf1761_otg_debug, 0, "SAF1761 DCI debug level");
114SYSCTL_INT(_hw_usb_saf1761_otg, OID_AUTO, forcefs, CTLFLAG_RWTUN,
115    &saf1761_otg_forcefs, 0, "SAF1761 DCI force FULL speed");
116#endif
117
118#define SAF1761_OTG_INTR_ENDPT 1
119
120/* prototypes */
121
122static const struct usb_bus_methods saf1761_otg_bus_methods;
123static const struct usb_pipe_methods saf1761_otg_non_isoc_methods;
124static const struct usb_pipe_methods saf1761_otg_device_isoc_methods;
125static const struct usb_pipe_methods saf1761_otg_host_isoc_methods;
126
127static saf1761_otg_cmd_t saf1761_host_setup_tx;
128static saf1761_otg_cmd_t saf1761_host_bulk_data_rx;
129static saf1761_otg_cmd_t saf1761_host_bulk_data_tx;
130static saf1761_otg_cmd_t saf1761_host_intr_data_rx;
131static saf1761_otg_cmd_t saf1761_host_intr_data_tx;
132static saf1761_otg_cmd_t saf1761_host_isoc_data_rx;
133static saf1761_otg_cmd_t saf1761_host_isoc_data_tx;
134static saf1761_otg_cmd_t saf1761_device_setup_rx;
135static saf1761_otg_cmd_t saf1761_device_data_rx;
136static saf1761_otg_cmd_t saf1761_device_data_tx;
137static saf1761_otg_cmd_t saf1761_device_data_tx_sync;
138static void saf1761_otg_device_done(struct usb_xfer *, usb_error_t);
139static void saf1761_otg_do_poll(struct usb_bus *);
140static void saf1761_otg_standard_done(struct usb_xfer *);
141static void saf1761_otg_intr_set(struct usb_xfer *, uint8_t);
142static void saf1761_otg_root_intr(struct saf1761_otg_softc *);
143static void saf1761_otg_enable_psof(struct saf1761_otg_softc *, uint8_t);
144
145/*
146 * Here is a list of what the SAF1761 chip can support. The main
147 * limitation is that the sum of the buffer sizes must be less than
148 * 8192 bytes.
149 */
150static const struct usb_hw_ep_profile saf1761_otg_ep_profile[] = {
151
152        [0] = {
153                .max_in_frame_size = 64,
154                .max_out_frame_size = 64,
155                .is_simplex = 0,
156                .support_control = 1,
157        },
158        [1] = {
159                .max_in_frame_size = SOTG_HS_MAX_PACKET_SIZE,
160                .max_out_frame_size = SOTG_HS_MAX_PACKET_SIZE,
161                .is_simplex = 0,
162                .support_interrupt = 1,
163                .support_bulk = 1,
164                .support_isochronous = 1,
165                .support_in = 1,
166                .support_out = 1,
167        },
168};
169
170static void
171saf1761_otg_get_hw_ep_profile(struct usb_device *udev,
172    const struct usb_hw_ep_profile **ppf, uint8_t ep_addr)
173{
174        if (ep_addr == 0) {
175                *ppf = saf1761_otg_ep_profile + 0;
176        } else if (ep_addr < 8) {
177                *ppf = saf1761_otg_ep_profile + 1;
178        } else {
179                *ppf = NULL;
180        }
181}
182
183static void
184saf1761_otg_pull_up(struct saf1761_otg_softc *sc)
185{
186        /* activate pullup on D+, if possible */
187
188        if (!sc->sc_flags.d_pulled_up && sc->sc_flags.port_powered) {
189                DPRINTF("\n");
190
191                sc->sc_flags.d_pulled_up = 1;
192        }
193}
194
195static void
196saf1761_otg_pull_down(struct saf1761_otg_softc *sc)
197{
198        /* release pullup on D+, if possible */
199
200        if (sc->sc_flags.d_pulled_up) {
201                DPRINTF("\n");
202
203                sc->sc_flags.d_pulled_up = 0;
204        }
205}
206
207static void
208saf1761_otg_wakeup_peer(struct saf1761_otg_softc *sc)
209{
210        uint16_t temp;
211
212        if (!(sc->sc_flags.status_suspend))
213                return;
214
215        DPRINTFN(5, "\n");
216
217        temp = SAF1761_READ_LE_4(sc, SOTG_MODE);
218        SAF1761_WRITE_LE_4(sc, SOTG_MODE, temp | SOTG_MODE_SNDRSU);
219        SAF1761_WRITE_LE_4(sc, SOTG_MODE, temp & ~SOTG_MODE_SNDRSU);
220
221        /* Wait 8ms for remote wakeup to complete. */
222        usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 125);
223}
224
225static uint8_t
226saf1761_host_channel_alloc(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
227{
228        uint32_t map;
229        int x;
230
231        if (td->channel < SOTG_HOST_CHANNEL_MAX)
232                return (0);
233
234        /* check if device is suspended */
235        if (SAF1761_OTG_PC2UDEV(td->pc)->flags.self_suspended != 0)
236                return (1);             /* busy - cannot transfer data */
237
238        switch (td->ep_type) {
239        case UE_INTERRUPT:
240                map = ~(sc->sc_host_intr_map |
241                    sc->sc_host_intr_busy_map[0] |
242                    sc->sc_host_intr_busy_map[1]);
243                /* find first set bit */
244                x = ffs(map) - 1;
245                if (x < 0 || x > 31)
246                        break;
247                sc->sc_host_intr_map |= (1U << x);
248                td->channel = 32 + x;
249                return (0);
250        case UE_ISOCHRONOUS:
251                map = ~(sc->sc_host_isoc_map |
252                    sc->sc_host_isoc_busy_map[0] |
253                    sc->sc_host_isoc_busy_map[1]);
254                /* find first set bit */
255                x = ffs(map) - 1;
256                if (x < 0 || x > 31)
257                        break;
258                sc->sc_host_isoc_map |= (1U << x);
259                td->channel = x;
260                return (0);
261        default:
262                map = ~(sc->sc_host_async_map |
263                    sc->sc_host_async_busy_map[0] |
264                    sc->sc_host_async_busy_map[1]);
265                /* find first set bit */
266                x = ffs(map) - 1;
267                if (x < 0 || x > 31)
268                        break;
269                sc->sc_host_async_map |= (1U << x);
270                td->channel = 64 + x;
271                return (0);
272        }
273        return (1);
274}
275
276static void
277saf1761_host_channel_free(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
278{
279        uint32_t x;
280
281        if (td->channel >= SOTG_HOST_CHANNEL_MAX)
282                return;
283
284        switch (td->ep_type) {
285        case UE_INTERRUPT:
286                x = td->channel - 32;
287                td->channel = SOTG_HOST_CHANNEL_MAX;
288                sc->sc_host_intr_map &= ~(1U << x);
289                sc->sc_host_intr_suspend_map &= ~(1U << x);
290                sc->sc_host_intr_busy_map[0] |= (1U << x);
291                SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD,
292                    (~sc->sc_host_intr_map) | sc->sc_host_intr_suspend_map);
293                break;
294        case UE_ISOCHRONOUS:
295                x = td->channel;
296                td->channel = SOTG_HOST_CHANNEL_MAX;
297                sc->sc_host_isoc_map &= ~(1U << x);
298                sc->sc_host_isoc_suspend_map &= ~(1U << x);
299                sc->sc_host_isoc_busy_map[0] |= (1U << x);
300                SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD,
301                    (~sc->sc_host_isoc_map) | sc->sc_host_isoc_suspend_map);
302                break;
303        default:
304                x = td->channel - 64;
305                td->channel = SOTG_HOST_CHANNEL_MAX;
306                sc->sc_host_async_map &= ~(1U << x);
307                sc->sc_host_async_suspend_map &= ~(1U << x);
308                sc->sc_host_async_busy_map[0] |= (1U << x);
309                SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
310                    (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
311                break;
312        }
313        saf1761_otg_enable_psof(sc, 1);
314}
315
316static uint32_t
317saf1761_peek_host_status_le_4(struct saf1761_otg_softc *sc, uint32_t offset)
318{
319        uint32_t x = 0;
320        while (1) {
321                uint32_t retval;
322
323                SAF1761_WRITE_LE_4(sc, SOTG_MEMORY_REG, offset);
324                SAF1761_90NS_DELAY(sc); /* read prefetch time is 90ns */
325                retval = SAF1761_READ_LE_4(sc, offset);
326                if (retval != 0)
327                        return (retval);
328                if (++x == 8) {
329                        DPRINTF("STAUS is zero at offset 0x%x\n", offset);
330                        break;
331                }
332        }
333        return (0);
334}
335
336static void
337saf1761_read_host_memory(struct saf1761_otg_softc *sc,
338    struct saf1761_otg_td *td, uint32_t len)
339{
340        struct usb_page_search buf_res;
341        uint32_t offset;
342        uint32_t count;
343
344        if (len == 0)
345                return;
346
347        offset = SOTG_DATA_ADDR(td->channel);
348        SAF1761_WRITE_LE_4(sc, SOTG_MEMORY_REG, offset);
349        SAF1761_90NS_DELAY(sc); /* read prefetch time is 90ns */
350
351        /* optimised read first */
352        while (len > 0) {
353                usbd_get_page(td->pc, td->offset, &buf_res);
354
355                /* get correct length */
356                if (buf_res.length > len)
357                        buf_res.length = len;
358
359                /* check buffer alignment */
360                if (((uintptr_t)buf_res.buffer) & 3)
361                        break;
362
363                count = buf_res.length & ~3;
364                if (count == 0)
365                        break;
366
367                bus_space_read_region_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
368                    offset, buf_res.buffer, count / 4);
369
370                len -= count;
371                offset += count;
372
373                /* update remainder and offset */
374                td->remainder -= count;
375                td->offset += count;
376        }
377
378        if (len > 0) {
379                /* use bounce buffer */
380                bus_space_read_region_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
381                    offset, sc->sc_bounce_buffer, (len + 3) / 4);
382                usbd_copy_in(td->pc, td->offset,
383                    sc->sc_bounce_buffer, len);
384
385                /* update remainder and offset */
386                td->remainder -= len;
387                td->offset += len;
388        }
389}
390
391static void
392saf1761_write_host_memory(struct saf1761_otg_softc *sc,
393    struct saf1761_otg_td *td, uint32_t len)
394{
395        struct usb_page_search buf_res;
396        uint32_t offset;
397        uint32_t count;
398
399        if (len == 0)
400                return;
401
402        offset = SOTG_DATA_ADDR(td->channel);
403
404        /* optimised write first */
405        while (len > 0) {
406                usbd_get_page(td->pc, td->offset, &buf_res);
407
408                /* get correct length */
409                if (buf_res.length > len)
410                        buf_res.length = len;
411
412                /* check buffer alignment */
413                if (((uintptr_t)buf_res.buffer) & 3)
414                        break;
415
416                count = buf_res.length & ~3;
417                if (count == 0)
418                        break;
419
420                bus_space_write_region_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
421                    offset, buf_res.buffer, count / 4);
422
423                len -= count;
424                offset += count;
425
426                /* update remainder and offset */
427                td->remainder -= count;
428                td->offset += count;
429        }
430        if (len > 0) {
431                /* use bounce buffer */
432                usbd_copy_out(td->pc, td->offset, sc->sc_bounce_buffer, len);
433                bus_space_write_region_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
434                    offset, sc->sc_bounce_buffer, (len + 3) / 4);
435
436                /* update remainder and offset */
437                td->remainder -= len;
438                td->offset += len;
439        }
440}
441
442static uint8_t
443saf1761_host_setup_tx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
444{
445        uint32_t pdt_addr;
446        uint32_t status;
447        uint32_t count;
448        uint32_t temp;
449
450        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
451                pdt_addr = SOTG_PTD(td->channel);
452
453                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
454
455                DPRINTFN(5, "STATUS=0x%08x\n", status);
456
457                if (status & SOTG_PTD_DW3_ACTIVE) {
458                        goto busy;
459                } else if (status & SOTG_PTD_DW3_HALTED) {
460                        td->error_any = 1;
461                }
462                goto complete;
463        }
464        if (saf1761_host_channel_alloc(sc, td))
465                goto busy;
466
467        count = 8;
468
469        if (count != td->remainder) {
470                td->error_any = 1;
471                goto complete;
472        }
473
474        saf1761_write_host_memory(sc, td, count);
475
476        pdt_addr = SOTG_PTD(td->channel);
477
478        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
479        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
480        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, 0);
481        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, 0);
482
483        temp = SOTG_PTD_DW3_ACTIVE | (td->toggle << 25) | SOTG_PTD_DW3_CERR_3;
484        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
485           
486        temp = SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8;
487        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
488
489        temp = td->dw1_value | (2 << 10) /* SETUP PID */ | (td->ep_index >> 1);
490        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
491
492        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
493            (td->max_packet_size << 18) /* wMaxPacketSize */ |
494            (count << 3) /* transfer count */ |
495            SOTG_PTD_DW0_VALID;
496        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
497
498        /* activate PTD */
499        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
500            (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
501
502        td->toggle = 1;
503busy:
504        return (1);     /* busy */
505complete:
506        saf1761_host_channel_free(sc, td);
507        return (0);     /* complete */
508}
509
510static uint8_t
511saf1761_host_bulk_data_rx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
512{
513        uint32_t pdt_addr;
514        uint32_t temp;
515
516        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
517                uint32_t status;
518                uint32_t count;
519                uint8_t got_short;
520
521                pdt_addr = SOTG_PTD(td->channel);
522
523                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
524
525                DPRINTFN(5, "STATUS=0x%08x\n", status);
526
527                if (status & SOTG_PTD_DW3_ACTIVE) {
528                        temp = saf1761_peek_host_status_le_4(sc,
529                            pdt_addr + SOTG_PTD_DW0);
530                        if (temp & SOTG_PTD_DW0_VALID) {
531                                goto busy;
532                        } else {
533                                status = saf1761_peek_host_status_le_4(sc,
534                                    pdt_addr + SOTG_PTD_DW3);
535
536                                /* check if still active */
537                                if (status & SOTG_PTD_DW3_ACTIVE) {
538                                        saf1761_host_channel_free(sc, td);
539                                        goto retry;
540                                } else if (status & SOTG_PTD_DW3_HALTED) {
541                                        if (!(status & SOTG_PTD_DW3_ERRORS))
542                                                td->error_stall = 1;
543                                        td->error_any = 1;
544                                        goto complete;
545                                }
546                        }
547                } else if (status & SOTG_PTD_DW3_HALTED) {
548                        if (!(status & SOTG_PTD_DW3_ERRORS))
549                                td->error_stall = 1;
550                        td->error_any = 1;
551                        goto complete;
552                }
553                if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT)
554                        count = (status & SOTG_PTD_DW3_XFER_COUNT_SPLIT);
555                else
556                        count = (status & SOTG_PTD_DW3_XFER_COUNT_HS);
557                got_short = 0;
558
559                /* verify the packet byte count */
560                if (count != td->max_packet_size) {
561                        if (count < td->max_packet_size) {
562                                /* we have a short packet */
563                                td->short_pkt = 1;
564                                got_short = 1;
565                        } else {
566                                /* invalid USB packet */
567                                td->error_any = 1;
568                                goto complete;
569                        }
570                }
571                td->toggle ^= 1;
572
573                /* verify the packet byte count */
574                if (count > td->remainder) {
575                        /* invalid USB packet */
576                        td->error_any = 1;
577                        goto complete;
578                }
579
580                saf1761_read_host_memory(sc, td, count);
581
582                /* check if we are complete */
583                if ((td->remainder == 0) || got_short) {
584                        if (td->short_pkt)
585                                goto complete;
586                        /* else need to receive a zero length packet */
587                }
588                saf1761_host_channel_free(sc, td);
589        }
590retry:
591        if (saf1761_host_channel_alloc(sc, td))
592                goto busy;
593
594        /* set toggle, if any */
595        if (td->set_toggle) {
596                td->set_toggle = 0;
597                td->toggle = 1;
598        }
599
600        /* receive one more packet */
601
602        pdt_addr = SOTG_PTD(td->channel);
603
604        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
605        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
606        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, 0);
607        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, 0);
608
609        temp = SOTG_PTD_DW3_ACTIVE | (td->toggle << 25) |
610            SOTG_PTD_DW3_CERR_2;
611        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
612
613        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8);
614        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
615
616        temp = td->dw1_value | (1 << 10) /* IN-PID */ | (td->ep_index >> 1);
617        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
618
619        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
620            (td->max_packet_size << 18) /* wMaxPacketSize */ |
621            (td->max_packet_size << 3) /* transfer count */ |
622            SOTG_PTD_DW0_VALID;
623        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
624
625        /* activate PTD */
626        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
627            (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
628busy:
629        return (1);     /* busy */
630complete:
631        saf1761_host_channel_free(sc, td);
632        return (0);     /* complete */
633}
634
635static uint8_t
636saf1761_host_bulk_data_tx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
637{
638        uint32_t pdt_addr;
639        uint32_t temp;
640        uint32_t count;
641
642        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
643                uint32_t status;
644
645                pdt_addr = SOTG_PTD(td->channel);
646
647                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
648
649                DPRINTFN(5, "STATUS=0x%08x\n", status);
650
651                if (status & SOTG_PTD_DW3_ACTIVE) {
652                        goto busy;
653                } else if (status & SOTG_PTD_DW3_HALTED) {
654                        if (!(status & SOTG_PTD_DW3_ERRORS))
655                                td->error_stall = 1;
656                        td->error_any = 1;
657                        goto complete;
658                }
659                /* check remainder */
660                if (td->remainder == 0) {
661                        if (td->short_pkt)
662                                goto complete;
663                        /* else we need to transmit a short packet */
664                }
665                saf1761_host_channel_free(sc, td);
666        }
667        if (saf1761_host_channel_alloc(sc, td))
668                goto busy;
669
670        count = td->max_packet_size;
671        if (td->remainder < count) {
672                /* we have a short packet */
673                td->short_pkt = 1;
674                count = td->remainder;
675        }
676
677        saf1761_write_host_memory(sc, td, count);
678
679        /* set toggle, if any */
680        if (td->set_toggle) {
681                td->set_toggle = 0;
682                td->toggle = 1;
683        }
684
685        /* send one more packet */
686
687        pdt_addr = SOTG_PTD(td->channel);
688
689        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
690        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
691        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, 0);
692        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, 0);
693
694        temp = SOTG_PTD_DW3_ACTIVE | (td->toggle << 25) |
695            SOTG_PTD_DW3_CERR_2;
696        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
697
698        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8);
699        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
700
701        temp = td->dw1_value | (0 << 10) /* OUT-PID */ | (td->ep_index >> 1);
702        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
703
704        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
705            (td->max_packet_size << 18) /* wMaxPacketSize */ |
706            (count << 3) /* transfer count */ |
707            SOTG_PTD_DW0_VALID;
708        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
709
710        /* activate PTD */
711        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
712            (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
713
714        td->toggle ^= 1;
715busy:
716        return (1);     /* busy */
717complete:
718        saf1761_host_channel_free(sc, td);
719        return (0);     /* complete */
720}
721
722static uint8_t
723saf1761_host_intr_data_rx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
724{
725        uint32_t pdt_addr;
726        uint32_t temp;
727
728        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
729                uint32_t status;
730                uint32_t count;
731                uint8_t got_short;
732
733                pdt_addr = SOTG_PTD(td->channel);
734
735                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
736
737                DPRINTFN(5, "STATUS=0x%08x\n", status);
738
739                if (status & SOTG_PTD_DW3_ACTIVE) {
740                        goto busy;
741                } else if (status & SOTG_PTD_DW3_HALTED) {
742                        if (!(status & SOTG_PTD_DW3_ERRORS))
743                                td->error_stall = 1;
744                        td->error_any = 1;
745                        goto complete;
746                }
747                if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT)
748                        count = (status & SOTG_PTD_DW3_XFER_COUNT_SPLIT);
749                else
750                        count = (status & SOTG_PTD_DW3_XFER_COUNT_HS);
751                got_short = 0;
752
753                /* verify the packet byte count */
754                if (count != td->max_packet_size) {
755                        if (count < td->max_packet_size) {
756                                /* we have a short packet */
757                                td->short_pkt = 1;
758                                got_short = 1;
759                        } else {
760                                /* invalid USB packet */
761                                td->error_any = 1;
762                                goto complete;
763                        }
764                }
765                td->toggle ^= 1;
766
767                /* verify the packet byte count */
768                if (count > td->remainder) {
769                        /* invalid USB packet */
770                        td->error_any = 1;
771                        goto complete;
772                }
773
774                saf1761_read_host_memory(sc, td, count);
775
776                /* check if we are complete */
777                if ((td->remainder == 0) || got_short) {
778                        if (td->short_pkt)
779                                goto complete;
780                        /* else need to receive a zero length packet */
781                }
782                saf1761_host_channel_free(sc, td);
783        }
784        if (saf1761_host_channel_alloc(sc, td))
785                goto busy;
786
787        /* set toggle, if any */
788        if (td->set_toggle) {
789                td->set_toggle = 0;
790                td->toggle = 1;
791        }
792
793        /* receive one more packet */
794
795        pdt_addr = SOTG_PTD(td->channel);
796
797        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
798        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
799
800        if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT) {
801                temp = (0xFC << td->uframe) & 0xFF;     /* complete split */
802        } else {
803                temp = 0;
804        }
805        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, temp);
806
807        temp = (1U << td->uframe);              /* start mask or start split */
808        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, temp);
809
810        temp = SOTG_PTD_DW3_ACTIVE | (td->toggle << 25) | SOTG_PTD_DW3_CERR_3;
811        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
812
813        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8) |
814            (td->interval & 0xF8);
815        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
816
817        temp = td->dw1_value | (1 << 10) /* IN-PID */ | (td->ep_index >> 1);
818        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
819
820        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
821            (td->max_packet_size << 18) /* wMaxPacketSize */ |
822            (td->max_packet_size << 3) /* transfer count */ |
823            SOTG_PTD_DW0_VALID;
824        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
825
826        /* activate PTD */
827        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD,
828            (~sc->sc_host_intr_map) | sc->sc_host_intr_suspend_map);
829busy:
830        return (1);     /* busy */
831complete:
832        saf1761_host_channel_free(sc, td);
833        return (0);     /* complete */
834}
835
836static uint8_t
837saf1761_host_intr_data_tx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
838{
839        uint32_t pdt_addr;
840        uint32_t temp;
841        uint32_t count;
842
843        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
844                uint32_t status;
845
846                pdt_addr = SOTG_PTD(td->channel);
847
848                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
849
850                DPRINTFN(5, "STATUS=0x%08x\n", status);
851
852                if (status & SOTG_PTD_DW3_ACTIVE) {
853                        goto busy;
854                } else if (status & SOTG_PTD_DW3_HALTED) {
855                        if (!(status & SOTG_PTD_DW3_ERRORS))
856                                td->error_stall = 1;
857                        td->error_any = 1;
858                        goto complete;
859                }
860
861                /* check remainder */
862                if (td->remainder == 0) {
863                        if (td->short_pkt)
864                                goto complete;
865                        /* else we need to transmit a short packet */
866                }
867                saf1761_host_channel_free(sc, td);
868        }
869        if (saf1761_host_channel_alloc(sc, td))
870                goto busy;
871
872        count = td->max_packet_size;
873        if (td->remainder < count) {
874                /* we have a short packet */
875                td->short_pkt = 1;
876                count = td->remainder;
877        }
878
879        saf1761_write_host_memory(sc, td, count);
880
881        /* set toggle, if any */
882        if (td->set_toggle) {
883                td->set_toggle = 0;
884                td->toggle = 1;
885        }
886
887        /* send one more packet */
888
889        pdt_addr = SOTG_PTD(td->channel);
890
891        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
892        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
893
894        if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT) {
895                temp = (0xFC << td->uframe) & 0xFF;     /* complete split */
896        } else {
897                temp = 0;
898        }
899        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, temp);
900
901        temp = (1U << td->uframe);              /* start mask or start split */
902        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, temp);
903
904        temp = SOTG_PTD_DW3_ACTIVE | (td->toggle << 25) | SOTG_PTD_DW3_CERR_3;
905        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
906
907        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8) |
908            (td->interval & 0xF8);
909        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
910
911        temp = td->dw1_value | (0 << 10) /* OUT-PID */ | (td->ep_index >> 1);
912        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
913
914        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
915            (td->max_packet_size << 18) /* wMaxPacketSize */ |
916            (count << 3) /* transfer count */ |
917            SOTG_PTD_DW0_VALID;
918        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
919
920        /* activate PTD */
921        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD,
922            (~sc->sc_host_intr_map) | sc->sc_host_intr_suspend_map);
923
924        td->toggle ^= 1;
925busy:
926        return (1);     /* busy */
927complete:
928        saf1761_host_channel_free(sc, td);
929        return (0);     /* complete */
930}
931
932static uint8_t
933saf1761_host_isoc_data_rx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
934{
935        uint32_t pdt_addr;
936        uint32_t temp;
937
938        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
939                uint32_t status;
940                uint32_t count;
941
942                pdt_addr = SOTG_PTD(td->channel);
943
944                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
945
946                DPRINTFN(5, "STATUS=0x%08x\n", status);
947
948                if (status & SOTG_PTD_DW3_ACTIVE) {
949                        goto busy;
950                } else if (status & SOTG_PTD_DW3_HALTED) {
951                        goto complete;
952                }
953                if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT)
954                        count = (status & SOTG_PTD_DW3_XFER_COUNT_SPLIT);
955                else
956                        count = (status & SOTG_PTD_DW3_XFER_COUNT_HS);
957
958                /* verify the packet byte count */
959                if (count != td->max_packet_size) {
960                        if (count < td->max_packet_size) {
961                                /* we have a short packet */
962                                td->short_pkt = 1;
963                        } else {
964                                /* invalid USB packet */
965                                td->error_any = 1;
966                                goto complete;
967                        }
968                }
969
970                /* verify the packet byte count */
971                if (count > td->remainder) {
972                        /* invalid USB packet */
973                        td->error_any = 1;
974                        goto complete;
975                }
976
977                saf1761_read_host_memory(sc, td, count);
978                goto complete;
979        }
980
981        if (saf1761_host_channel_alloc(sc, td))
982                goto busy;
983
984        /* receive one more packet */
985
986        pdt_addr = SOTG_PTD(td->channel);
987
988        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
989        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
990
991        if (td->dw1_value & SOTG_PTD_DW1_ENABLE_SPLIT) {
992                temp = (0xFC << (td->uframe & 7)) & 0xFF;       /* complete split */
993        } else {
994                temp = 0;
995        }
996        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, temp);
997
998        temp = (1U << (td->uframe & 7));        /* start mask or start split */
999        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, temp);
1000
1001        temp = SOTG_PTD_DW3_ACTIVE | SOTG_PTD_DW3_CERR_3;
1002        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
1003
1004        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8) |
1005            (td->uframe & 0xF8);
1006        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
1007
1008        temp = td->dw1_value | (1 << 10) /* IN-PID */ | (td->ep_index >> 1);
1009        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
1010
1011        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
1012            (td->max_packet_size << 18) /* wMaxPacketSize */ |
1013            (td->max_packet_size << 3) /* transfer count */ |
1014            SOTG_PTD_DW0_VALID;
1015        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
1016
1017        /* activate PTD */
1018        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD,
1019            (~sc->sc_host_isoc_map) | sc->sc_host_isoc_suspend_map);
1020busy:
1021        return (1);     /* busy */
1022complete:
1023        saf1761_host_channel_free(sc, td);
1024        return (0);     /* complete */
1025}
1026
1027static uint8_t
1028saf1761_host_isoc_data_tx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
1029{
1030        uint32_t pdt_addr;
1031        uint32_t temp;
1032        uint32_t count;
1033
1034        if (td->channel < SOTG_HOST_CHANNEL_MAX) {
1035                uint32_t status;
1036
1037                pdt_addr = SOTG_PTD(td->channel);
1038
1039                status = saf1761_peek_host_status_le_4(sc, pdt_addr + SOTG_PTD_DW3);
1040
1041                DPRINTFN(5, "STATUS=0x%08x\n", status);
1042
1043                if (status & SOTG_PTD_DW3_ACTIVE) {
1044                        goto busy;
1045                } else if (status & SOTG_PTD_DW3_HALTED) {
1046                        goto complete;
1047                }
1048                goto complete;
1049        }
1050        if (saf1761_host_channel_alloc(sc, td))
1051                goto busy;
1052
1053        count = td->max_packet_size;
1054        if (td->remainder < count) {
1055                /* we have a short packet */
1056                td->short_pkt = 1;
1057                count = td->remainder;
1058        }
1059
1060        saf1761_write_host_memory(sc, td, count);
1061
1062        /* send one more packet */
1063
1064        pdt_addr = SOTG_PTD(td->channel);
1065
1066        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW7, 0);
1067        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW6, 0);
1068        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW5, 0);
1069
1070        temp = (1U << (td->uframe & 7));        /* start mask or start split */
1071        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW4, temp);
1072
1073        temp = SOTG_PTD_DW3_ACTIVE | SOTG_PTD_DW3_CERR_3;
1074        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW3, temp);
1075
1076        temp = (SOTG_HC_MEMORY_ADDR(SOTG_DATA_ADDR(td->channel)) << 8) |
1077            (td->uframe & 0xF8);
1078        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW2, temp);
1079
1080        temp = td->dw1_value | (0 << 10) /* OUT-PID */ | (td->ep_index >> 1);
1081        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW1, temp);
1082
1083        temp = (td->ep_index << 31) | (1 << 29) /* pkt-multiplier */ |
1084            (count << 18) /* wMaxPacketSize */ |
1085            (count << 3) /* transfer count */ |
1086            SOTG_PTD_DW0_VALID;
1087        SAF1761_WRITE_LE_4(sc, pdt_addr + SOTG_PTD_DW0, temp);
1088
1089        /* activate PTD */
1090        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD,
1091            (~sc->sc_host_isoc_map) | sc->sc_host_isoc_suspend_map);
1092busy:
1093        return (1);     /* busy */
1094complete:
1095        saf1761_host_channel_free(sc, td);
1096        return (0);     /* complete */
1097}
1098
1099static void
1100saf1761_otg_set_address(struct saf1761_otg_softc *sc, uint8_t addr)
1101{
1102        DPRINTFN(5, "addr=%d\n", addr);
1103
1104        SAF1761_WRITE_LE_4(sc, SOTG_ADDRESS, addr | SOTG_ADDRESS_ENABLE);
1105}
1106
1107
1108static void
1109saf1761_read_device_fifo(struct saf1761_otg_softc *sc,
1110    struct saf1761_otg_td *td, uint32_t len)
1111{
1112        struct usb_page_search buf_res;
1113        uint32_t count;
1114
1115        /* optimised read first */
1116        while (len > 0) {
1117                usbd_get_page(td->pc, td->offset, &buf_res);
1118
1119                /* get correct length */
1120                if (buf_res.length > len)
1121                        buf_res.length = len;
1122
1123                /* check buffer alignment */
1124                if (((uintptr_t)buf_res.buffer) & 3)
1125                        break;
1126
1127                count = buf_res.length & ~3;
1128                if (count == 0)
1129                        break;
1130
1131                bus_space_read_multi_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
1132                    SOTG_DATA_PORT, buf_res.buffer, count / 4);
1133
1134                len -= count;
1135
1136                /* update remainder and offset */
1137                td->remainder -= count;
1138                td->offset += count;
1139        }
1140
1141        if (len > 0) {
1142                /* use bounce buffer */
1143                bus_space_read_multi_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
1144                    SOTG_DATA_PORT, sc->sc_bounce_buffer, (len + 3) / 4);
1145                usbd_copy_in(td->pc, td->offset,
1146                    sc->sc_bounce_buffer, len);
1147
1148                /* update remainder and offset */
1149                td->remainder -= len;
1150                td->offset += len;
1151        }
1152}
1153
1154static void
1155saf1761_write_device_fifo(struct saf1761_otg_softc *sc,
1156    struct saf1761_otg_td *td, uint32_t len)
1157{
1158        struct usb_page_search buf_res;
1159        uint32_t count;
1160
1161        /* optimised write first */
1162        while (len > 0) {
1163                usbd_get_page(td->pc, td->offset, &buf_res);
1164
1165                /* get correct length */
1166                if (buf_res.length > len)
1167                        buf_res.length = len;
1168
1169                /* check buffer alignment */
1170                if (((uintptr_t)buf_res.buffer) & 3)
1171                        break;
1172
1173                count = buf_res.length & ~3;
1174                if (count == 0)
1175                        break;
1176
1177                bus_space_write_multi_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
1178                    SOTG_DATA_PORT, buf_res.buffer, count / 4);
1179
1180                len -= count;
1181
1182                /* update remainder and offset */
1183                td->remainder -= count;
1184                td->offset += count;
1185        }
1186        if (len > 0) {
1187                /* use bounce buffer */
1188                usbd_copy_out(td->pc, td->offset, sc->sc_bounce_buffer, len);
1189                bus_space_write_multi_4((sc)->sc_io_tag, (sc)->sc_io_hdl,
1190                    SOTG_DATA_PORT, sc->sc_bounce_buffer, (len + 3) / 4);
1191
1192                /* update remainder and offset */
1193                td->remainder -= len;
1194                td->offset += len;
1195        }
1196}
1197
1198static uint8_t
1199saf1761_device_setup_rx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
1200{
1201        struct usb_device_request req;
1202        uint32_t count;
1203
1204        /* select the correct endpoint */
1205        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX, SOTG_EP_INDEX_EP0SETUP);
1206
1207        count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1208
1209        /* check buffer status */
1210        if ((count & SOTG_BUF_LENGTH_FILLED_MASK) == 0)
1211                goto busy;
1212
1213        /* get buffer length */
1214        count &= SOTG_BUF_LENGTH_BUFLEN_MASK;
1215
1216        DPRINTFN(5, "count=%u rem=%u\n", count, td->remainder);
1217
1218        /* clear did stall */
1219        td->did_stall = 0;
1220
1221        /* clear stall */
1222        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, 0);
1223
1224        /* verify data length */
1225        if (count != td->remainder) {
1226                DPRINTFN(0, "Invalid SETUP packet "
1227                    "length, %d bytes\n", count);
1228                goto busy;
1229        }
1230        if (count != sizeof(req)) {
1231                DPRINTFN(0, "Unsupported SETUP packet "
1232                    "length, %d bytes\n", count);
1233                goto busy;
1234        }
1235        /* receive data */
1236        saf1761_read_device_fifo(sc, td, sizeof(req));
1237
1238        /* extract SETUP packet again */
1239        usbd_copy_out(td->pc, 0, &req, sizeof(req));
1240
1241        /* sneak peek the set address request */
1242        if ((req.bmRequestType == UT_WRITE_DEVICE) &&
1243            (req.bRequest == UR_SET_ADDRESS)) {
1244                sc->sc_dv_addr = req.wValue[0] & 0x7F;
1245                DPRINTF("Set address %d\n", sc->sc_dv_addr);
1246        } else {
1247                sc->sc_dv_addr = 0xFF;
1248        }
1249        return (0);                     /* complete */
1250
1251busy:
1252        /* abort any ongoing transfer */
1253        if (!td->did_stall) {
1254                DPRINTFN(5, "stalling\n");
1255
1256                /* set stall */
1257                SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_STALL);
1258
1259                td->did_stall = 1;
1260        }
1261        return (1);                     /* not complete */
1262}
1263
1264static uint8_t
1265saf1761_device_data_rx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
1266{
1267        uint32_t count;
1268        uint8_t got_short = 0;
1269
1270        if (td->ep_index == 0) {
1271                /* select the correct endpoint */
1272                SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX, SOTG_EP_INDEX_EP0SETUP);
1273
1274                count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1275
1276                /* check buffer status */
1277                if ((count & SOTG_BUF_LENGTH_FILLED_MASK) != 0) {
1278
1279                        if (td->remainder == 0) {
1280                                /*
1281                                 * We are actually complete and have
1282                                 * received the next SETUP:
1283                                 */
1284                                DPRINTFN(5, "faking complete\n");
1285                                return (0);     /* complete */
1286                        }
1287                        DPRINTFN(5, "SETUP packet while receiving data\n");
1288                        /*
1289                         * USB Host Aborted the transfer.
1290                         */
1291                        td->error_any = 1;
1292                        return (0);     /* complete */
1293                }
1294        }
1295        /* select the correct endpoint */
1296        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
1297            (td->ep_index << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
1298            SOTG_EP_INDEX_DIR_OUT);
1299
1300        /* enable data stage */
1301        if (td->set_toggle) {
1302                td->set_toggle = 0;
1303                SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_DSEN);
1304        }
1305
1306        count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1307
1308        /* check buffer status */
1309        if ((count & SOTG_BUF_LENGTH_FILLED_MASK) == 0)
1310                return (1);             /* not complete */
1311
1312        /* get buffer length */
1313        count &= SOTG_BUF_LENGTH_BUFLEN_MASK;
1314
1315        DPRINTFN(5, "rem=%u count=0x%04x\n", td->remainder, count);
1316
1317        /* verify the packet byte count */
1318        if (count != td->max_packet_size) {
1319                if (count < td->max_packet_size) {
1320                        /* we have a short packet */
1321                        td->short_pkt = 1;
1322                        got_short = 1;
1323                } else {
1324                        /* invalid USB packet */
1325                        td->error_any = 1;
1326                        return (0);     /* we are complete */
1327                }
1328        }
1329        /* verify the packet byte count */
1330        if (count > td->remainder) {
1331                /* invalid USB packet */
1332                td->error_any = 1;
1333                return (0);             /* we are complete */
1334        }
1335        /* receive data */
1336        saf1761_read_device_fifo(sc, td, count);
1337
1338        /* check if we are complete */
1339        if ((td->remainder == 0) || got_short) {
1340                if (td->short_pkt) {
1341                        /* we are complete */
1342                        return (0);
1343                }
1344                /* else need to receive a zero length packet */
1345        }
1346        return (1);                     /* not complete */
1347}
1348
1349static uint8_t
1350saf1761_device_data_tx(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
1351{
1352        uint32_t count;
1353
1354        if (td->ep_index == 0) {
1355                /* select the correct endpoint */
1356                SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX, SOTG_EP_INDEX_EP0SETUP);
1357
1358                count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1359
1360                /* check buffer status */
1361                if ((count & SOTG_BUF_LENGTH_FILLED_MASK) != 0) {
1362                        DPRINTFN(5, "SETUP abort\n");
1363                        /*
1364                         * USB Host Aborted the transfer.
1365                         */
1366                        td->error_any = 1;
1367                        return (0);     /* complete */
1368                }
1369        }
1370        /* select the correct endpoint */
1371        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
1372            (td->ep_index << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
1373            SOTG_EP_INDEX_DIR_IN);
1374
1375        count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1376
1377        /* check buffer status */
1378        if ((count & SOTG_BUF_LENGTH_FILLED_MASK) != 0)
1379                return (1);             /* not complete */
1380
1381        /* enable data stage */
1382        if (td->set_toggle) {
1383                td->set_toggle = 0;
1384                SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_DSEN);
1385        }
1386
1387        DPRINTFN(5, "rem=%u\n", td->remainder);
1388
1389        count = td->max_packet_size;
1390        if (td->remainder < count) {
1391                /* we have a short packet */
1392                td->short_pkt = 1;
1393                count = td->remainder;
1394        }
1395        /* transmit data */
1396        saf1761_write_device_fifo(sc, td, count);
1397
1398        if (td->ep_index == 0) {
1399                if (count < SOTG_FS_MAX_PACKET_SIZE) {
1400                        /* set end of packet */
1401                        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_VENDP);
1402                }
1403        } else {
1404                if (count < SOTG_HS_MAX_PACKET_SIZE) {
1405                        /* set end of packet */
1406                        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_VENDP);
1407                }
1408        }
1409
1410        /* check remainder */
1411        if (td->remainder == 0) {
1412                if (td->short_pkt) {
1413                        return (0);     /* complete */
1414                }
1415                /* else we need to transmit a short packet */
1416        }
1417        return (1);                     /* not complete */
1418}
1419
1420static uint8_t
1421saf1761_device_data_tx_sync(struct saf1761_otg_softc *sc, struct saf1761_otg_td *td)
1422{
1423        uint32_t count;
1424
1425        if (td->ep_index == 0) {
1426                /* select the correct endpoint */
1427                SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX, SOTG_EP_INDEX_EP0SETUP);
1428
1429                count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1430
1431                /* check buffer status */
1432                if ((count & SOTG_BUF_LENGTH_FILLED_MASK) != 0) {
1433                        DPRINTFN(5, "Faking complete\n");
1434                        return (0);     /* complete */
1435                }
1436        }
1437        /* select the correct endpoint */
1438        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
1439            (td->ep_index << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
1440            SOTG_EP_INDEX_DIR_IN);
1441
1442        count = SAF1761_READ_LE_4(sc, SOTG_BUF_LENGTH);
1443
1444        /* check buffer status */
1445        if ((count & SOTG_BUF_LENGTH_FILLED_MASK) != 0)
1446                return (1);             /* busy */
1447
1448        if (sc->sc_dv_addr != 0xFF) {
1449                /* write function address */
1450                saf1761_otg_set_address(sc, sc->sc_dv_addr);
1451        }
1452        return (0);                     /* complete */
1453}
1454
1455static void
1456saf1761_otg_xfer_do_fifo(struct saf1761_otg_softc *sc, struct usb_xfer *xfer)
1457{
1458        struct saf1761_otg_td *td;
1459        uint8_t toggle;
1460
1461        DPRINTFN(9, "\n");
1462
1463        td = xfer->td_transfer_cache;
1464        if (td == NULL)
1465                return;
1466
1467        while (1) {
1468                if ((td->func) (sc, td)) {
1469                        /* operation in progress */
1470                        break;
1471                }
1472                if (((void *)td) == xfer->td_transfer_last) {
1473                        goto done;
1474                }
1475                if (td->error_any) {
1476                        goto done;
1477                } else if (td->remainder > 0) {
1478                        /*
1479                         * We had a short transfer. If there is no alternate
1480                         * next, stop processing !
1481                         */
1482                        if (!td->alt_next) {
1483                                goto done;
1484                        }
1485                }
1486                /*
1487                 * Fetch the next transfer descriptor.
1488                 */
1489                toggle = td->toggle;
1490                td = td->obj_next;
1491                td->toggle = toggle;
1492                xfer->td_transfer_cache = td;
1493        }
1494        return;
1495
1496done:
1497        /* compute all actual lengths */
1498        xfer->td_transfer_cache = NULL;
1499        sc->sc_xfer_complete = 1;
1500}
1501
1502static uint8_t
1503saf1761_otg_xfer_do_complete(struct saf1761_otg_softc *sc, struct usb_xfer *xfer)
1504{
1505        struct saf1761_otg_td *td;
1506
1507        DPRINTFN(9, "\n");
1508
1509        td = xfer->td_transfer_cache;
1510        if (td == NULL) {
1511                /* compute all actual lengths */
1512                saf1761_otg_standard_done(xfer);
1513                return (1);
1514        }
1515        return (0);
1516}
1517
1518static void
1519saf1761_otg_interrupt_poll_locked(struct saf1761_otg_softc *sc)
1520{
1521        struct usb_xfer *xfer;
1522
1523        TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry)
1524                saf1761_otg_xfer_do_fifo(sc, xfer);
1525}
1526
1527static void
1528saf1761_otg_enable_psof(struct saf1761_otg_softc *sc, uint8_t on)
1529{
1530        if (on) {
1531                sc->sc_intr_enable |= SOTG_DCINTERRUPT_IEPSOF;
1532        } else {
1533                sc->sc_intr_enable &= ~SOTG_DCINTERRUPT_IEPSOF;
1534        }
1535        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT_EN, sc->sc_intr_enable);
1536}
1537
1538static void
1539saf1761_otg_wait_suspend(struct saf1761_otg_softc *sc, uint8_t on)
1540{
1541        if (on) {
1542                sc->sc_intr_enable |= SOTG_DCINTERRUPT_IESUSP;
1543                sc->sc_intr_enable &= ~SOTG_DCINTERRUPT_IERESM;
1544        } else {
1545                sc->sc_intr_enable &= ~SOTG_DCINTERRUPT_IESUSP;
1546                sc->sc_intr_enable |= SOTG_DCINTERRUPT_IERESM;
1547        }
1548        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT_EN, sc->sc_intr_enable);
1549}
1550
1551static void
1552saf1761_otg_update_vbus(struct saf1761_otg_softc *sc)
1553{
1554        uint16_t status;
1555
1556        /* read fresh status */
1557        status = SAF1761_READ_LE_4(sc, SOTG_STATUS);
1558
1559        DPRINTFN(4, "STATUS=0x%04x\n", status);
1560
1561        if ((status & SOTG_STATUS_VBUS_VLD) &&
1562            (status & SOTG_STATUS_ID)) {
1563                /* VBUS present and device mode */
1564                if (!sc->sc_flags.status_vbus) {
1565                        sc->sc_flags.status_vbus = 1;
1566
1567                        /* complete root HUB interrupt endpoint */
1568                        saf1761_otg_root_intr(sc);
1569                }
1570        } else {
1571                /* VBUS not-present or host mode */
1572                if (sc->sc_flags.status_vbus) {
1573                        sc->sc_flags.status_vbus = 0;
1574                        sc->sc_flags.status_bus_reset = 0;
1575                        sc->sc_flags.status_suspend = 0;
1576                        sc->sc_flags.change_suspend = 0;
1577                        sc->sc_flags.change_connect = 1;
1578
1579                        /* complete root HUB interrupt endpoint */
1580                        saf1761_otg_root_intr(sc);
1581                }
1582        }
1583}
1584
1585static void
1586saf1761_otg_interrupt_complete_locked(struct saf1761_otg_softc *sc)
1587{
1588        struct usb_xfer *xfer;
1589repeat:
1590        /* scan for completion events */
1591        TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
1592                if (saf1761_otg_xfer_do_complete(sc, xfer))
1593                        goto repeat;
1594        }
1595}
1596
1597int
1598saf1761_otg_filter_interrupt(void *arg)
1599{
1600        struct saf1761_otg_softc *sc = arg;
1601        int retval = FILTER_HANDLED;
1602        uint32_t hcstat;
1603        uint32_t status;
1604
1605        USB_BUS_SPIN_LOCK(&sc->sc_bus);
1606
1607        hcstat = SAF1761_READ_LE_4(sc, SOTG_HCINTERRUPT);
1608        /* acknowledge all host controller interrupts */
1609        SAF1761_WRITE_LE_4(sc, SOTG_HCINTERRUPT, hcstat);
1610
1611        status = SAF1761_READ_LE_4(sc, SOTG_DCINTERRUPT);
1612        /* acknowledge all device controller interrupts */
1613        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT,
1614            status & ~SAF1761_DCINTERRUPT_THREAD_IRQ);
1615
1616        (void) SAF1761_READ_LE_4(sc, SOTG_ATL_PTD_DONE_PTD);
1617        (void) SAF1761_READ_LE_4(sc, SOTG_INT_PTD_DONE_PTD);
1618        (void) SAF1761_READ_LE_4(sc, SOTG_ISO_PTD_DONE_PTD);
1619
1620        DPRINTFN(9, "HCINTERRUPT=0x%08x DCINTERRUPT=0x%08x\n", hcstat, status);
1621
1622        if (status & SOTG_DCINTERRUPT_IEPSOF) {
1623                if ((sc->sc_host_async_busy_map[1] | sc->sc_host_async_busy_map[0] |
1624                     sc->sc_host_intr_busy_map[1] | sc->sc_host_intr_busy_map[0] |
1625                     sc->sc_host_isoc_busy_map[1] | sc->sc_host_isoc_busy_map[0]) != 0) {
1626                        /* busy waiting is active */
1627                        retval = FILTER_SCHEDULE_THREAD;
1628
1629                        sc->sc_host_async_busy_map[1] = sc->sc_host_async_busy_map[0];
1630                        sc->sc_host_async_busy_map[0] = 0;
1631
1632                        sc->sc_host_intr_busy_map[1] = sc->sc_host_intr_busy_map[0];
1633                        sc->sc_host_intr_busy_map[0] = 0;
1634
1635                        sc->sc_host_isoc_busy_map[1] = sc->sc_host_isoc_busy_map[0];
1636                        sc->sc_host_isoc_busy_map[0] = 0;
1637                } else {
1638                        /* busy waiting is not active */
1639                        saf1761_otg_enable_psof(sc, 0);
1640                }
1641        }
1642
1643        if (status & SAF1761_DCINTERRUPT_THREAD_IRQ)
1644                retval = FILTER_SCHEDULE_THREAD;
1645
1646        /* poll FIFOs, if any */
1647        saf1761_otg_interrupt_poll_locked(sc);
1648
1649        if (sc->sc_xfer_complete != 0)
1650                retval = FILTER_SCHEDULE_THREAD;
1651
1652        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
1653
1654#ifdef __rtems__
1655#ifdef LIBBSP_ARM_ATSAM_BSP_H
1656        const Pio *saf_irq_pio = PIOC;
1657        /* The PIOC is used only by the SAF1761. So we can just reset the status
1658         * without any further handling. */
1659        (void) saf_irq_pio->PIO_ISR;
1660#endif /* LIBBSP_ARM_ATSAM_BSP_H */
1661
1662#endif /* __rtems__ */
1663        return (retval);
1664}
1665
1666void
1667saf1761_otg_interrupt(void *arg)
1668{
1669        struct saf1761_otg_softc *sc = arg;
1670        uint32_t status;
1671
1672        USB_BUS_LOCK(&sc->sc_bus);
1673        USB_BUS_SPIN_LOCK(&sc->sc_bus);
1674
1675        status = SAF1761_READ_LE_4(sc, SOTG_DCINTERRUPT) & 
1676            SAF1761_DCINTERRUPT_THREAD_IRQ;
1677
1678        /* acknowledge all device controller interrupts */
1679        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT, status);
1680
1681        DPRINTF("DCINTERRUPT=0x%08x SOF=0x%08x "
1682            "FRINDEX=0x%08x\n", status,
1683            SAF1761_READ_LE_4(sc, SOTG_FRAME_NUM),
1684            SAF1761_READ_LE_4(sc, SOTG_FRINDEX));
1685
1686        /* update VBUS and ID bits, if any */
1687        if (status & SOTG_DCINTERRUPT_IEVBUS)
1688                saf1761_otg_update_vbus(sc);
1689
1690        if (status & SOTG_DCINTERRUPT_IEBRST) {
1691                /* unlock device */
1692                SAF1761_WRITE_LE_4(sc, SOTG_UNLOCK_DEVICE,
1693                    SOTG_UNLOCK_DEVICE_CODE);
1694
1695                /* Enable device address */
1696                SAF1761_WRITE_LE_4(sc, SOTG_ADDRESS,
1697                    SOTG_ADDRESS_ENABLE);
1698
1699                sc->sc_flags.status_bus_reset = 1;
1700                sc->sc_flags.status_suspend = 0;
1701                sc->sc_flags.change_suspend = 0;
1702                sc->sc_flags.change_connect = 1;
1703
1704                /* disable resume interrupt */
1705                saf1761_otg_wait_suspend(sc, 1);
1706                /* complete root HUB interrupt endpoint */
1707                saf1761_otg_root_intr(sc);
1708        }
1709        /*
1710         * If "RESUME" and "SUSPEND" is set at the same time we
1711         * interpret that like "RESUME". Resume is set when there is
1712         * at least 3 milliseconds of inactivity on the USB BUS:
1713         */
1714        if (status & SOTG_DCINTERRUPT_IERESM) {
1715                /* unlock device */
1716                SAF1761_WRITE_LE_4(sc, SOTG_UNLOCK_DEVICE,
1717                    SOTG_UNLOCK_DEVICE_CODE);
1718
1719                if (sc->sc_flags.status_suspend) {
1720                        sc->sc_flags.status_suspend = 0;
1721                        sc->sc_flags.change_suspend = 1;
1722                        /* disable resume interrupt */
1723                        saf1761_otg_wait_suspend(sc, 1);
1724                        /* complete root HUB interrupt endpoint */
1725                        saf1761_otg_root_intr(sc);
1726                }
1727        } else if (status & SOTG_DCINTERRUPT_IESUSP) {
1728                if (!sc->sc_flags.status_suspend) {
1729                        sc->sc_flags.status_suspend = 1;
1730                        sc->sc_flags.change_suspend = 1;
1731                        /* enable resume interrupt */
1732                        saf1761_otg_wait_suspend(sc, 0);
1733                        /* complete root HUB interrupt endpoint */
1734                        saf1761_otg_root_intr(sc);
1735                }
1736        }
1737
1738        if (sc->sc_xfer_complete != 0) {
1739                sc->sc_xfer_complete = 0;
1740
1741                /* complete FIFOs, if any */
1742                saf1761_otg_interrupt_complete_locked(sc);
1743        }
1744        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
1745        USB_BUS_UNLOCK(&sc->sc_bus);
1746}
1747
1748static void
1749saf1761_otg_setup_standard_chain_sub(struct saf1761_otg_std_temp *temp)
1750{
1751        struct saf1761_otg_td *td;
1752
1753        /* get current Transfer Descriptor */
1754        td = temp->td_next;
1755        temp->td = td;
1756
1757        /* prepare for next TD */
1758        temp->td_next = td->obj_next;
1759
1760        /* fill out the Transfer Descriptor */
1761        td->func = temp->func;
1762        td->pc = temp->pc;
1763        td->offset = temp->offset;
1764        td->remainder = temp->len;
1765        td->error_any = 0;
1766        td->error_stall = 0;
1767        td->set_toggle = 0;
1768        td->did_stall = temp->did_stall;
1769        td->short_pkt = temp->short_pkt;
1770        td->alt_next = temp->setup_alt_next;
1771        td->channel = SOTG_HOST_CHANNEL_MAX;
1772}
1773
1774static void
1775saf1761_otg_setup_standard_chain(struct usb_xfer *xfer)
1776{
1777        struct saf1761_otg_std_temp temp;
1778        struct saf1761_otg_softc *sc;
1779        struct saf1761_otg_td *td;
1780        uint32_t x;
1781        uint8_t ep_no;
1782        uint8_t ep_type;
1783        uint8_t need_sync;
1784        uint8_t is_host;
1785        uint8_t uframe_start;
1786        uint8_t uframe_interval;
1787
1788        DPRINTFN(9, "addr=%d endpt=%d sumlen=%d speed=%d\n",
1789            xfer->address, UE_GET_ADDR(xfer->endpointno),
1790            xfer->sumlen, usbd_get_speed(xfer->xroot->udev));
1791
1792        temp.max_frame_size = xfer->max_frame_size;
1793
1794        td = xfer->td_start[0];
1795        xfer->td_transfer_first = td;
1796        xfer->td_transfer_cache = td;
1797
1798        /* setup temp */
1799
1800        temp.pc = NULL;
1801        temp.td = NULL;
1802        temp.td_next = xfer->td_start[0];
1803        temp.offset = 0;
1804        temp.setup_alt_next = xfer->flags_int.short_frames_ok ||
1805            xfer->flags_int.isochronous_xfr;
1806        temp.did_stall = !xfer->flags_int.control_stall;
1807
1808        is_host = (xfer->xroot->udev->flags.usb_mode == USB_MODE_HOST);
1809
1810        sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
1811        ep_no = (xfer->endpointno & UE_ADDR);
1812        ep_type = (xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE);
1813
1814        /* check if we should prepend a setup message */
1815
1816        if (xfer->flags_int.control_xfr) {
1817                if (xfer->flags_int.control_hdr) {
1818
1819                        if (is_host)
1820                                temp.func = &saf1761_host_setup_tx;
1821                        else
1822                                temp.func = &saf1761_device_setup_rx;
1823
1824                        temp.len = xfer->frlengths[0];
1825                        temp.pc = xfer->frbuffers + 0;
1826                        temp.short_pkt = temp.len ? 1 : 0;
1827                        /* check for last frame */
1828                        if (xfer->nframes == 1) {
1829                                /* no STATUS stage yet, SETUP is last */
1830                                if (xfer->flags_int.control_act)
1831                                        temp.setup_alt_next = 0;
1832                        }
1833                        saf1761_otg_setup_standard_chain_sub(&temp);
1834                }
1835                x = 1;
1836        } else {
1837                x = 0;
1838        }
1839
1840        uframe_start = 0;
1841        uframe_interval = 0;
1842
1843        if (x != xfer->nframes) {
1844                if (xfer->endpointno & UE_DIR_IN) {
1845                        if (is_host) {
1846                                if (ep_type == UE_INTERRUPT) {
1847                                        temp.func = &saf1761_host_intr_data_rx;
1848                                } else if (ep_type == UE_ISOCHRONOUS) {
1849                                        temp.func = &saf1761_host_isoc_data_rx;
1850                                        uframe_start = (SAF1761_READ_LE_4(sc, SOTG_FRINDEX) + 8) &
1851                                            (SOTG_FRINDEX_MASK & ~7);
1852                                        if (xfer->xroot->udev->speed == USB_SPEED_HIGH)
1853                                                uframe_interval = 1U << xfer->fps_shift;
1854                                        else
1855                                                uframe_interval = 8U;
1856                                } else {
1857                                        temp.func = &saf1761_host_bulk_data_rx;
1858                                }
1859                                need_sync = 0;
1860                        } else {
1861                                temp.func = &saf1761_device_data_tx;
1862                                need_sync = 1;
1863                        }
1864                } else {
1865                        if (is_host) {
1866                                if (ep_type == UE_INTERRUPT) {
1867                                        temp.func = &saf1761_host_intr_data_tx;
1868                                } else if (ep_type == UE_ISOCHRONOUS) {
1869                                        temp.func = &saf1761_host_isoc_data_tx;
1870                                        uframe_start = (SAF1761_READ_LE_4(sc, SOTG_FRINDEX) + 8) &
1871                                            (SOTG_FRINDEX_MASK & ~7);
1872                                        if (xfer->xroot->udev->speed == USB_SPEED_HIGH)
1873                                                uframe_interval = 1U << xfer->fps_shift;
1874                                        else
1875                                                uframe_interval = 8U;
1876                                } else {
1877                                        temp.func = &saf1761_host_bulk_data_tx;
1878                                }
1879                                need_sync = 0;
1880                        } else {
1881                                temp.func = &saf1761_device_data_rx;
1882                                need_sync = 0;
1883                        }
1884                }
1885
1886                /* setup "pc" pointer */
1887                temp.pc = xfer->frbuffers + x;
1888        } else {
1889                need_sync = 0;
1890        }
1891
1892        while (x != xfer->nframes) {
1893
1894                /* DATA0 / DATA1 message */
1895
1896                temp.len = xfer->frlengths[x];
1897
1898                x++;
1899
1900                if (x == xfer->nframes) {
1901                        if (xfer->flags_int.control_xfr) {
1902                                if (xfer->flags_int.control_act) {
1903                                        temp.setup_alt_next = 0;
1904                                }
1905                        } else {
1906                                temp.setup_alt_next = 0;
1907                        }
1908                }
1909                if (temp.len == 0) {
1910
1911                        /* make sure that we send an USB packet */
1912
1913                        temp.short_pkt = 0;
1914
1915                } else {
1916
1917                        /* regular data transfer */
1918
1919                        temp.short_pkt = (xfer->flags.force_short_xfer) ? 0 : 1;
1920                }
1921
1922                saf1761_otg_setup_standard_chain_sub(&temp);
1923
1924                if (xfer->flags_int.isochronous_xfr) {
1925                        temp.offset += temp.len;
1926
1927                        /* stamp the starting point for this transaction */
1928                        temp.td->uframe = uframe_start;
1929
1930                        /* advance to next */
1931                        uframe_start += uframe_interval;
1932                } else {
1933                        /* get next Page Cache pointer */
1934                        temp.pc = xfer->frbuffers + x;
1935                }
1936        }
1937
1938        /* check for control transfer */
1939        if (xfer->flags_int.control_xfr) {
1940                /* always setup a valid "pc" pointer for status and sync */
1941                temp.pc = xfer->frbuffers + 0;
1942                temp.len = 0;
1943                temp.short_pkt = 0;
1944                temp.setup_alt_next = 0;
1945
1946                /* check if we should append a status stage */
1947                if (!xfer->flags_int.control_act) {
1948
1949                        /*
1950                         * Send a DATA1 message and invert the current
1951                         * endpoint direction.
1952                         */
1953                        if (xfer->endpointno & UE_DIR_IN) {
1954                                if (is_host) {
1955                                        temp.func = &saf1761_host_bulk_data_tx;
1956                                        need_sync = 0;
1957                                } else {
1958                                        temp.func = &saf1761_device_data_rx;
1959                                        need_sync = 0;
1960                                }
1961                        } else {
1962                                if (is_host) {
1963                                        temp.func = &saf1761_host_bulk_data_rx;
1964                                        need_sync = 0;
1965                                } else {
1966                                        temp.func = &saf1761_device_data_tx;
1967                                        need_sync = 1;
1968                                }
1969                        }
1970                        temp.len = 0;
1971                        temp.short_pkt = 0;
1972
1973                        saf1761_otg_setup_standard_chain_sub(&temp);
1974
1975                        /* data toggle should be DATA1 */
1976                        td = temp.td;
1977                        td->set_toggle = 1;
1978
1979                        if (need_sync) {
1980                                /* we need a SYNC point after TX */
1981                                temp.func = &saf1761_device_data_tx_sync;
1982                                saf1761_otg_setup_standard_chain_sub(&temp);
1983                        }
1984                }
1985        } else {
1986                if (need_sync) {
1987                        temp.pc = xfer->frbuffers + 0;
1988                        temp.len = 0;
1989                        temp.short_pkt = 0;
1990                        temp.setup_alt_next = 0;
1991
1992                        /* we need a SYNC point after TX */
1993                        temp.func = &saf1761_device_data_tx_sync;
1994                        saf1761_otg_setup_standard_chain_sub(&temp);
1995                }
1996        }
1997
1998        /* must have at least one frame! */
1999        td = temp.td;
2000        xfer->td_transfer_last = td;
2001
2002        if (is_host) {
2003                /* get first again */
2004                td = xfer->td_transfer_first;
2005                td->toggle = (xfer->endpoint->toggle_next ? 1 : 0);
2006        }
2007}
2008
2009static void
2010saf1761_otg_timeout(void *arg)
2011{
2012        struct usb_xfer *xfer = arg;
2013
2014        DPRINTF("xfer=%p\n", xfer);
2015
2016        USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2017
2018        /* transfer is transferred */
2019        saf1761_otg_device_done(xfer, USB_ERR_TIMEOUT);
2020}
2021
2022static void
2023saf1761_otg_intr_set(struct usb_xfer *xfer, uint8_t set)
2024{
2025        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
2026        uint8_t ep_no = (xfer->endpointno & UE_ADDR);
2027        uint32_t mask;
2028
2029        DPRINTFN(15, "endpoint=%d set=%d\n", xfer->endpointno, set);
2030
2031        if (ep_no == 0) {
2032                mask = SOTG_DCINTERRUPT_IEPRX(0) |
2033                    SOTG_DCINTERRUPT_IEPTX(0) |
2034                    SOTG_DCINTERRUPT_IEP0SETUP;
2035        } else if (xfer->endpointno & UE_DIR_IN) {
2036                mask = SOTG_DCINTERRUPT_IEPTX(ep_no);
2037        } else {
2038                mask = SOTG_DCINTERRUPT_IEPRX(ep_no);
2039        }
2040
2041        if (set)
2042                sc->sc_intr_enable |= mask;
2043        else
2044                sc->sc_intr_enable &= ~mask;
2045
2046        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT_EN, sc->sc_intr_enable);
2047}
2048
2049static void
2050saf1761_otg_start_standard_chain(struct usb_xfer *xfer)
2051{
2052        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
2053
2054        DPRINTFN(9, "\n");
2055
2056        USB_BUS_SPIN_LOCK(&sc->sc_bus);
2057
2058        /* poll one time */
2059        saf1761_otg_xfer_do_fifo(sc, xfer);
2060
2061        if (saf1761_otg_xfer_do_complete(sc, xfer) == 0) {
2062                /*
2063                 * Only enable the endpoint interrupt when we are
2064                 * actually waiting for data, hence we are dealing
2065                 * with level triggered interrupts !
2066                 */
2067                saf1761_otg_intr_set(xfer, 1);
2068
2069                /* put transfer on interrupt queue */
2070                usbd_transfer_enqueue(&xfer->xroot->bus->intr_q, xfer);
2071
2072                /* start timeout, if any */
2073                if (xfer->timeout != 0) {
2074                        usbd_transfer_timeout_ms(xfer,
2075                            &saf1761_otg_timeout, xfer->timeout);
2076                }
2077        }
2078        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
2079}
2080
2081static void
2082saf1761_otg_root_intr(struct saf1761_otg_softc *sc)
2083{
2084        DPRINTFN(9, "\n");
2085
2086        USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);
2087
2088        /* set port bit - we only have one port */
2089        sc->sc_hub_idata[0] = 0x02;
2090
2091        uhub_root_intr(&sc->sc_bus, sc->sc_hub_idata,
2092            sizeof(sc->sc_hub_idata));
2093}
2094
2095static usb_error_t
2096saf1761_otg_standard_done_sub(struct usb_xfer *xfer)
2097{
2098        struct saf1761_otg_td *td;
2099        uint32_t len;
2100        usb_error_t error;
2101
2102        DPRINTFN(9, "\n");
2103
2104        td = xfer->td_transfer_cache;
2105
2106        do {
2107                len = td->remainder;
2108
2109                /* store last data toggle */
2110                xfer->endpoint->toggle_next = td->toggle;
2111
2112                if (xfer->aframes != xfer->nframes) {
2113                        /*
2114                         * Verify the length and subtract
2115                         * the remainder from "frlengths[]":
2116                         */
2117                        if (len > xfer->frlengths[xfer->aframes]) {
2118                                td->error_any = 1;
2119                        } else {
2120                                xfer->frlengths[xfer->aframes] -= len;
2121                        }
2122                }
2123                /* Check for transfer error */
2124                if (td->error_any) {
2125                        /* the transfer is finished */
2126                        error = (td->error_stall ?
2127                            USB_ERR_STALLED : USB_ERR_IOERROR);
2128                        td = NULL;
2129                        break;
2130                }
2131                /* Check for short transfer */
2132                if (len > 0) {
2133                        if (xfer->flags_int.short_frames_ok ||
2134                            xfer->flags_int.isochronous_xfr) {
2135                                /* follow alt next */
2136                                if (td->alt_next) {
2137                                        td = td->obj_next;
2138                                } else {
2139                                        td = NULL;
2140                                }
2141                        } else {
2142                                /* the transfer is finished */
2143                                td = NULL;
2144                        }
2145                        error = 0;
2146                        break;
2147                }
2148                td = td->obj_next;
2149
2150                /* this USB frame is complete */
2151                error = 0;
2152                break;
2153
2154        } while (0);
2155
2156        /* update transfer cache */
2157
2158        xfer->td_transfer_cache = td;
2159
2160        return (error);
2161}
2162
2163static void
2164saf1761_otg_standard_done(struct usb_xfer *xfer)
2165{
2166        usb_error_t err = 0;
2167
2168        DPRINTFN(13, "xfer=%p endpoint=%p transfer done\n",
2169            xfer, xfer->endpoint);
2170
2171        /* reset scanner */
2172
2173        xfer->td_transfer_cache = xfer->td_transfer_first;
2174
2175        if (xfer->flags_int.control_xfr) {
2176
2177                if (xfer->flags_int.control_hdr) {
2178
2179                        err = saf1761_otg_standard_done_sub(xfer);
2180                }
2181                xfer->aframes = 1;
2182
2183                if (xfer->td_transfer_cache == NULL) {
2184                        goto done;
2185                }
2186        }
2187        while (xfer->aframes != xfer->nframes) {
2188
2189                err = saf1761_otg_standard_done_sub(xfer);
2190                xfer->aframes++;
2191
2192                if (xfer->td_transfer_cache == NULL) {
2193                        goto done;
2194                }
2195        }
2196
2197        if (xfer->flags_int.control_xfr &&
2198            !xfer->flags_int.control_act) {
2199
2200                err = saf1761_otg_standard_done_sub(xfer);
2201        }
2202done:
2203        saf1761_otg_device_done(xfer, err);
2204}
2205
2206/*------------------------------------------------------------------------*
2207 *      saf1761_otg_device_done
2208 *
2209 * NOTE: this function can be called more than one time on the
2210 * same USB transfer!
2211 *------------------------------------------------------------------------*/
2212static void
2213saf1761_otg_device_done(struct usb_xfer *xfer, usb_error_t error)
2214{
2215        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
2216
2217        USB_BUS_LOCK_ASSERT(xfer->xroot->bus, MA_OWNED);
2218
2219        DPRINTFN(2, "xfer=%p, endpoint=%p, error=%d\n",
2220            xfer, xfer->endpoint, error);
2221
2222        USB_BUS_SPIN_LOCK(&sc->sc_bus);
2223
2224        if (xfer->flags_int.usb_mode == USB_MODE_DEVICE) {
2225                saf1761_otg_intr_set(xfer, 0);
2226        } else {
2227                struct saf1761_otg_td *td;
2228
2229                td = xfer->td_transfer_cache;
2230
2231                if (td != NULL)
2232                        saf1761_host_channel_free(sc, td);
2233        }
2234
2235        /* dequeue transfer and start next transfer */
2236        usbd_transfer_done(xfer, error);
2237
2238        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
2239}
2240
2241static void
2242saf1761_otg_xfer_stall(struct usb_xfer *xfer)
2243{
2244        saf1761_otg_device_done(xfer, USB_ERR_STALLED);
2245}
2246
2247static void
2248saf1761_otg_set_stall(struct usb_device *udev,
2249    struct usb_endpoint *ep, uint8_t *did_stall)
2250{
2251        struct saf1761_otg_softc *sc;
2252        uint8_t ep_no;
2253        uint8_t ep_type;
2254        uint8_t ep_dir;
2255
2256        USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
2257
2258        /* check mode */
2259        if (udev->flags.usb_mode != USB_MODE_DEVICE) {
2260                /* not supported */
2261                return;
2262        }
2263
2264        DPRINTFN(5, "endpoint=%p\n", ep);
2265
2266        /* set STALL bit */
2267        sc = SAF1761_OTG_BUS2SC(udev->bus);
2268
2269        ep_no = (ep->edesc->bEndpointAddress & UE_ADDR);
2270        ep_dir = (ep->edesc->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT));
2271        ep_type = (ep->edesc->bmAttributes & UE_XFERTYPE);
2272
2273        if (ep_type == UE_CONTROL) {
2274                /* should not happen */
2275                return;
2276        }
2277        USB_BUS_SPIN_LOCK(&sc->sc_bus);
2278
2279        /* select the correct endpoint */
2280        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
2281            (ep_no << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
2282            ((ep_dir == UE_DIR_IN) ? SOTG_EP_INDEX_DIR_IN :
2283            SOTG_EP_INDEX_DIR_OUT));
2284
2285        /* set stall */
2286        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_STALL);
2287
2288        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
2289}
2290
2291static void
2292saf1761_otg_clear_stall_sub_locked(struct saf1761_otg_softc *sc,
2293    uint8_t ep_no, uint8_t ep_type, uint8_t ep_dir)
2294{
2295        if (ep_type == UE_CONTROL) {
2296                /* clearing stall is not needed */
2297                return;
2298        }
2299        /* select the correct endpoint */
2300        SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
2301            (ep_no << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
2302            ((ep_dir == UE_DIR_IN) ? SOTG_EP_INDEX_DIR_IN :
2303            SOTG_EP_INDEX_DIR_OUT));
2304
2305        /* disable endpoint */
2306        SAF1761_WRITE_LE_4(sc, SOTG_EP_TYPE, 0);
2307        /* enable endpoint again - will clear data toggle */
2308        SAF1761_WRITE_LE_4(sc, SOTG_EP_TYPE, ep_type | SOTG_EP_TYPE_ENABLE);
2309
2310        /* clear buffer */
2311        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, SOTG_CTRL_FUNC_CLBUF);
2312        /* clear stall */
2313        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_FUNC, 0);
2314}
2315
2316static void
2317saf1761_otg_clear_stall(struct usb_device *udev, struct usb_endpoint *ep)
2318{
2319        struct saf1761_otg_softc *sc;
2320        struct usb_endpoint_descriptor *ed;
2321
2322        USB_BUS_LOCK_ASSERT(udev->bus, MA_OWNED);
2323
2324        DPRINTFN(5, "endpoint=%p\n", ep);
2325
2326        /* check mode */
2327        if (udev->flags.usb_mode != USB_MODE_DEVICE) {
2328                /* not supported */
2329                return;
2330        }
2331        /* get softc */
2332        sc = SAF1761_OTG_BUS2SC(udev->bus);
2333
2334        USB_BUS_SPIN_LOCK(&sc->sc_bus);
2335
2336        /* get endpoint descriptor */
2337        ed = ep->edesc;
2338
2339        /* reset endpoint */
2340        saf1761_otg_clear_stall_sub_locked(sc,
2341            (ed->bEndpointAddress & UE_ADDR),
2342            (ed->bmAttributes & UE_XFERTYPE),
2343            (ed->bEndpointAddress & (UE_DIR_IN | UE_DIR_OUT)));
2344
2345        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
2346}
2347
2348usb_error_t
2349saf1761_otg_init(struct saf1761_otg_softc *sc)
2350{
2351        const struct usb_hw_ep_profile *pf;
2352        uint32_t x;
2353
2354        DPRINTF("\n");
2355
2356        /* set up the bus structure */
2357        sc->sc_bus.usbrev = USB_REV_2_0;
2358        sc->sc_bus.methods = &saf1761_otg_bus_methods;
2359
2360        USB_BUS_LOCK(&sc->sc_bus);
2361
2362        /* Reset Host controller, including HW mode */
2363        SAF1761_WRITE_LE_4(sc, SOTG_SW_RESET, SOTG_SW_RESET_ALL);
2364
2365        DELAY(1000);
2366
2367        /* Reset Host controller, including HW mode */
2368        SAF1761_WRITE_LE_4(sc, SOTG_SW_RESET, SOTG_SW_RESET_HC);
2369
2370        /* wait a bit */
2371        DELAY(1000);
2372
2373        SAF1761_WRITE_LE_4(sc, SOTG_SW_RESET, 0);
2374
2375        /* wait a bit */
2376        DELAY(1000);
2377
2378        /* Enable interrupts */
2379        sc->sc_hw_mode |= SOTG_HW_MODE_CTRL_GLOBAL_INTR_EN |
2380            SOTG_HW_MODE_CTRL_COMN_INT;
2381
2382        /* unlock device */
2383        SAF1761_WRITE_LE_4(sc, SOTG_UNLOCK_DEVICE, SOTG_UNLOCK_DEVICE_CODE);
2384
2385        /*
2386         * Set correct hardware mode, must be written twice if bus
2387         * width is changed:
2388         */
2389        SAF1761_WRITE_LE_4(sc, SOTG_HW_MODE_CTRL, sc->sc_hw_mode);
2390        SAF1761_WRITE_LE_4(sc, SOTG_HW_MODE_CTRL, sc->sc_hw_mode);
2391
2392        SAF1761_WRITE_LE_4(sc, SOTG_DCSCRATCH, 0xdeadbeef);
2393        SAF1761_WRITE_LE_4(sc, SOTG_HCSCRATCH, 0xdeadbeef);
2394
2395        DPRINTF("DCID=0x%08x VEND_PROD=0x%08x HWMODE=0x%08x SCRATCH=0x%08x,0x%08x\n",
2396            SAF1761_READ_LE_4(sc, SOTG_DCCHIP_ID),
2397            SAF1761_READ_LE_4(sc, SOTG_VEND_PROD_ID),
2398            SAF1761_READ_LE_4(sc, SOTG_HW_MODE_CTRL),
2399            SAF1761_READ_LE_4(sc, SOTG_DCSCRATCH),
2400            SAF1761_READ_LE_4(sc, SOTG_HCSCRATCH));
2401
2402        /* reset device controller */
2403        SAF1761_WRITE_LE_4(sc, SOTG_MODE, SOTG_MODE_SFRESET);
2404        SAF1761_WRITE_LE_4(sc, SOTG_MODE, 0);
2405
2406        /* wait a bit */
2407        DELAY(1000);
2408
2409        /* reset host controller */
2410        SAF1761_WRITE_LE_4(sc, SOTG_USBCMD, SOTG_USBCMD_HCRESET);
2411
2412        /* wait for reset to clear */
2413        for (x = 0; x != 10; x++) {
2414                if ((SAF1761_READ_LE_4(sc, SOTG_USBCMD) & SOTG_USBCMD_HCRESET) == 0)
2415                        break;
2416                usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 10);
2417        }
2418
2419        SAF1761_WRITE_LE_4(sc, SOTG_HW_MODE_CTRL, sc->sc_hw_mode |
2420            SOTG_HW_MODE_CTRL_ALL_ATX_RESET);
2421
2422        /* wait a bit */
2423        DELAY(1000);
2424
2425        SAF1761_WRITE_LE_4(sc, SOTG_HW_MODE_CTRL, sc->sc_hw_mode);
2426
2427        /* wait a bit */
2428        DELAY(1000);
2429
2430        /* do a pulldown */
2431        saf1761_otg_pull_down(sc);
2432
2433        /* wait 10ms for pulldown to stabilise */
2434        usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
2435
2436        for (x = 1;; x++) {
2437
2438                saf1761_otg_get_hw_ep_profile(NULL, &pf, x);
2439                if (pf == NULL)
2440                        break;
2441
2442                /* select the correct endpoint */
2443                SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
2444                    (x << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
2445                    SOTG_EP_INDEX_DIR_IN);
2446
2447                /* select the maximum packet size */
2448                SAF1761_WRITE_LE_4(sc, SOTG_EP_MAXPACKET, pf->max_in_frame_size);
2449
2450                /* select the correct endpoint */
2451                SAF1761_WRITE_LE_4(sc, SOTG_EP_INDEX,
2452                    (x << SOTG_EP_INDEX_ENDP_INDEX_SHIFT) |
2453                    SOTG_EP_INDEX_DIR_OUT);
2454
2455                /* select the maximum packet size */
2456                SAF1761_WRITE_LE_4(sc, SOTG_EP_MAXPACKET, pf->max_out_frame_size);
2457        }
2458
2459        /* enable interrupts */
2460        SAF1761_WRITE_LE_4(sc, SOTG_MODE, SOTG_MODE_GLINTENA |
2461            SOTG_MODE_CLKAON | SOTG_MODE_WKUPCS);
2462
2463        sc->sc_interrupt_cfg |=
2464            SOTG_INTERRUPT_CFG_CDBGMOD |
2465            SOTG_INTERRUPT_CFG_DDBGMODIN |
2466            SOTG_INTERRUPT_CFG_DDBGMODOUT;
2467
2468        /* set default values */
2469        SAF1761_WRITE_LE_4(sc, SOTG_INTERRUPT_CFG, sc->sc_interrupt_cfg);
2470
2471        /* enable VBUS and ID interrupt */
2472        SAF1761_WRITE_LE_4(sc, SOTG_IRQ_ENABLE_SET_CLR,
2473            SOTG_IRQ_ENABLE_CLR(0xFFFF));
2474        SAF1761_WRITE_LE_4(sc, SOTG_IRQ_ENABLE_SET_CLR,
2475            SOTG_IRQ_ENABLE_SET(SOTG_IRQ_ID | SOTG_IRQ_VBUS_VLD));
2476
2477        /* enable interrupts */
2478        sc->sc_intr_enable = SOTG_DCINTERRUPT_IEVBUS |
2479            SOTG_DCINTERRUPT_IEBRST | SOTG_DCINTERRUPT_IESUSP;
2480        SAF1761_WRITE_LE_4(sc, SOTG_DCINTERRUPT_EN, sc->sc_intr_enable);
2481
2482        /*
2483         * Connect ATX port 1 to device controller, select external
2484         * charge pump and driver VBUS to +5V:
2485         */
2486        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_SET_CLR,
2487            SOTG_CTRL_CLR(0xFFFF));
2488#ifdef __rtems__
2489        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_SET_CLR,
2490            SOTG_CTRL_SET(SOTG_CTRL_SEL_CP_EXT | SOTG_CTRL_VBUS_DRV));
2491#else
2492        SAF1761_WRITE_LE_4(sc, SOTG_CTRL_SET_CLR,
2493            SOTG_CTRL_SET(SOTG_CTRL_SW_SEL_HC_DC |
2494            SOTG_CTRL_BDIS_ACON_EN | SOTG_CTRL_SEL_CP_EXT |
2495            SOTG_CTRL_VBUS_DRV));
2496#endif
2497        /* disable device address */
2498        SAF1761_WRITE_LE_4(sc, SOTG_ADDRESS, 0);
2499
2500        /* enable host controller clock and preserve reserved bits */
2501        x = SAF1761_READ_LE_4(sc, SOTG_POWER_DOWN);
2502        SAF1761_WRITE_LE_4(sc, SOTG_POWER_DOWN, x | SOTG_POWER_DOWN_HC_CLK_EN);
2503
2504        /* wait 10ms for clock */
2505        usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 100);
2506
2507        /* enable configuration flag */
2508        SAF1761_WRITE_LE_4(sc, SOTG_CONFIGFLAG, SOTG_CONFIGFLAG_ENABLE);
2509
2510        /* clear RAM block */
2511        for (x = 0x400; x != 0x10000; x += 4)
2512                SAF1761_WRITE_LE_4(sc, x, 0);
2513
2514        /* start the HC */
2515        SAF1761_WRITE_LE_4(sc, SOTG_USBCMD, SOTG_USBCMD_RS);
2516
2517        DPRINTF("USBCMD=0x%08x\n", SAF1761_READ_LE_4(sc, SOTG_USBCMD));
2518
2519        /* make HC scan all PTDs */
2520        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_LAST_PTD, (1 << 31));
2521        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_LAST_PTD, (1 << 31));
2522        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_LAST_PTD, (1 << 31));
2523
2524        /* skip all PTDs by default */
2525        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD, -1U);
2526        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD, -1U);
2527        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD, -1U);
2528
2529        /* activate all PTD types */
2530        SAF1761_WRITE_LE_4(sc, SOTG_HCBUFFERSTATUS,
2531            SOTG_HCBUFFERSTATUS_ISO_BUF_FILL |
2532            SOTG_HCBUFFERSTATUS_INT_BUF_FILL |
2533            SOTG_HCBUFFERSTATUS_ATL_BUF_FILL);
2534
2535        /* we don't use the AND mask */
2536        SAF1761_WRITE_LE_4(sc, SOTG_ISO_IRQ_MASK_AND, 0);
2537        SAF1761_WRITE_LE_4(sc, SOTG_INT_IRQ_MASK_AND, 0);
2538        SAF1761_WRITE_LE_4(sc, SOTG_ATL_IRQ_MASK_AND, 0);
2539
2540        /* enable all PTD OR interrupts by default */
2541        SAF1761_WRITE_LE_4(sc, SOTG_ISO_IRQ_MASK_OR, -1U);
2542        SAF1761_WRITE_LE_4(sc, SOTG_INT_IRQ_MASK_OR, -1U);
2543        SAF1761_WRITE_LE_4(sc, SOTG_ATL_IRQ_MASK_OR, -1U);
2544
2545        /* enable HC interrupts */
2546        SAF1761_WRITE_LE_4(sc, SOTG_HCINTERRUPT_ENABLE,
2547            SOTG_HCINTERRUPT_OTG_IRQ |
2548            SOTG_HCINTERRUPT_ISO_IRQ |
2549            SOTG_HCINTERRUPT_ALT_IRQ |
2550            SOTG_HCINTERRUPT_INT_IRQ);
2551
2552        /* poll initial VBUS status */
2553        saf1761_otg_update_vbus(sc);
2554
2555        USB_BUS_UNLOCK(&sc->sc_bus);
2556
2557        /* catch any lost interrupts */
2558
2559        saf1761_otg_do_poll(&sc->sc_bus);
2560
2561        return (0);                     /* success */
2562}
2563
2564void
2565saf1761_otg_uninit(struct saf1761_otg_softc *sc)
2566{
2567        USB_BUS_LOCK(&sc->sc_bus);
2568
2569        /* disable all interrupts */
2570        SAF1761_WRITE_LE_4(sc, SOTG_MODE, 0);
2571
2572        sc->sc_flags.port_powered = 0;
2573        sc->sc_flags.status_vbus = 0;
2574        sc->sc_flags.status_bus_reset = 0;
2575        sc->sc_flags.status_suspend = 0;
2576        sc->sc_flags.change_suspend = 0;
2577        sc->sc_flags.change_connect = 1;
2578
2579        saf1761_otg_pull_down(sc);
2580        USB_BUS_UNLOCK(&sc->sc_bus);
2581}
2582
2583static void
2584saf1761_otg_suspend(struct saf1761_otg_softc *sc)
2585{
2586        /* TODO */
2587}
2588
2589static void
2590saf1761_otg_resume(struct saf1761_otg_softc *sc)
2591{
2592        /* TODO */
2593}
2594
2595static void
2596saf1761_otg_do_poll(struct usb_bus *bus)
2597{
2598        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(bus);
2599
2600        USB_BUS_LOCK(&sc->sc_bus);
2601        USB_BUS_SPIN_LOCK(&sc->sc_bus);
2602        saf1761_otg_interrupt_poll_locked(sc);
2603        saf1761_otg_interrupt_complete_locked(sc);
2604        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
2605        USB_BUS_UNLOCK(&sc->sc_bus);
2606}
2607
2608/*------------------------------------------------------------------------*
2609 * saf1761_otg control support
2610 * saf1761_otg interrupt support
2611 * saf1761_otg bulk support
2612 *------------------------------------------------------------------------*/
2613static void
2614saf1761_otg_device_non_isoc_open(struct usb_xfer *xfer)
2615{
2616        return;
2617}
2618
2619static void
2620saf1761_otg_device_non_isoc_close(struct usb_xfer *xfer)
2621{
2622        saf1761_otg_device_done(xfer, USB_ERR_CANCELLED);
2623}
2624
2625static void
2626saf1761_otg_device_non_isoc_enter(struct usb_xfer *xfer)
2627{
2628        return;
2629}
2630
2631static void
2632saf1761_otg_device_non_isoc_start(struct usb_xfer *xfer)
2633{
2634        /* setup TDs */
2635        saf1761_otg_setup_standard_chain(xfer);
2636        saf1761_otg_start_standard_chain(xfer);
2637}
2638
2639static const struct usb_pipe_methods saf1761_otg_non_isoc_methods =
2640{
2641        .open = saf1761_otg_device_non_isoc_open,
2642        .close = saf1761_otg_device_non_isoc_close,
2643        .enter = saf1761_otg_device_non_isoc_enter,
2644        .start = saf1761_otg_device_non_isoc_start,
2645};
2646
2647/*------------------------------------------------------------------------*
2648 * saf1761_otg device side isochronous support
2649 *------------------------------------------------------------------------*/
2650static void
2651saf1761_otg_device_isoc_open(struct usb_xfer *xfer)
2652{
2653        return;
2654}
2655
2656static void
2657saf1761_otg_device_isoc_close(struct usb_xfer *xfer)
2658{
2659        saf1761_otg_device_done(xfer, USB_ERR_CANCELLED);
2660}
2661
2662static void
2663saf1761_otg_device_isoc_enter(struct usb_xfer *xfer)
2664{
2665        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
2666        uint32_t temp;
2667        uint32_t nframes;
2668
2669        DPRINTFN(6, "xfer=%p next=%d nframes=%d\n",
2670            xfer, xfer->endpoint->isoc_next, xfer->nframes);
2671
2672        /* get the current frame index - we don't need the high bits */
2673
2674        nframes = SAF1761_READ_LE_4(sc, SOTG_FRAME_NUM);
2675
2676        /*
2677         * check if the frame index is within the window where the
2678         * frames will be inserted
2679         */
2680        temp = (nframes - xfer->endpoint->isoc_next) & SOTG_FRAME_NUM_SOFR_MASK;
2681
2682        if ((xfer->endpoint->is_synced == 0) ||
2683            (temp < xfer->nframes)) {
2684                /*
2685                 * If there is data underflow or the pipe queue is
2686                 * empty we schedule the transfer a few frames ahead
2687                 * of the current frame position. Else two isochronous
2688                 * transfers might overlap.
2689                 */
2690                xfer->endpoint->isoc_next = (nframes + 3) & SOTG_FRAME_NUM_SOFR_MASK;
2691                xfer->endpoint->is_synced = 1;
2692                DPRINTFN(3, "start next=%d\n", xfer->endpoint->isoc_next);
2693        }
2694        /*
2695         * compute how many milliseconds the insertion is ahead of the
2696         * current frame position:
2697         */
2698        temp = (xfer->endpoint->isoc_next - nframes) & SOTG_FRAME_NUM_SOFR_MASK;
2699
2700        /*
2701         * pre-compute when the isochronous transfer will be finished:
2702         */
2703        xfer->isoc_time_complete =
2704            usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
2705            xfer->nframes;
2706
2707        /* compute frame number for next insertion */
2708        xfer->endpoint->isoc_next += xfer->nframes;
2709
2710        /* setup TDs */
2711        saf1761_otg_setup_standard_chain(xfer);
2712}
2713
2714static void
2715saf1761_otg_device_isoc_start(struct usb_xfer *xfer)
2716{
2717        /* start TD chain */
2718        saf1761_otg_start_standard_chain(xfer);
2719}
2720
2721static const struct usb_pipe_methods saf1761_otg_device_isoc_methods =
2722{
2723        .open = saf1761_otg_device_isoc_open,
2724        .close = saf1761_otg_device_isoc_close,
2725        .enter = saf1761_otg_device_isoc_enter,
2726        .start = saf1761_otg_device_isoc_start,
2727};
2728
2729/*------------------------------------------------------------------------*
2730 * saf1761_otg host side isochronous support
2731 *------------------------------------------------------------------------*/
2732static void
2733saf1761_otg_host_isoc_open(struct usb_xfer *xfer)
2734{
2735        return;
2736}
2737
2738static void
2739saf1761_otg_host_isoc_close(struct usb_xfer *xfer)
2740{
2741        saf1761_otg_device_done(xfer, USB_ERR_CANCELLED);
2742}
2743
2744static void
2745saf1761_otg_host_isoc_enter(struct usb_xfer *xfer)
2746{
2747        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(xfer->xroot->bus);
2748        uint32_t temp;
2749        uint32_t nframes;
2750
2751        DPRINTFN(6, "xfer=%p next=%d nframes=%d\n",
2752            xfer, xfer->endpoint->isoc_next, xfer->nframes);
2753
2754        /* get the current frame index - we don't need the high bits */
2755
2756        nframes = (SAF1761_READ_LE_4(sc, SOTG_FRINDEX) & SOTG_FRINDEX_MASK) >> 3;
2757
2758        /*
2759         * check if the frame index is within the window where the
2760         * frames will be inserted
2761         */
2762        temp = (nframes - xfer->endpoint->isoc_next) & (SOTG_FRINDEX_MASK >> 3);
2763
2764        if ((xfer->endpoint->is_synced == 0) ||
2765            (temp < xfer->nframes)) {
2766                /*
2767                 * If there is data underflow or the pipe queue is
2768                 * empty we schedule the transfer a few frames ahead
2769                 * of the current frame position. Else two isochronous
2770                 * transfers might overlap.
2771                 */
2772                xfer->endpoint->isoc_next = (nframes + 3) & (SOTG_FRINDEX_MASK >> 3);
2773                xfer->endpoint->is_synced = 1;
2774                DPRINTFN(3, "start next=%d\n", xfer->endpoint->isoc_next);
2775        }
2776        /*
2777         * compute how many milliseconds the insertion is ahead of the
2778         * current frame position:
2779         */
2780        temp = (xfer->endpoint->isoc_next - nframes) & (SOTG_FRINDEX_MASK >> 3);
2781
2782        /*
2783         * pre-compute when the isochronous transfer will be finished:
2784         */
2785        xfer->isoc_time_complete =
2786            usb_isoc_time_expand(&sc->sc_bus, nframes) + temp +
2787            xfer->nframes;
2788
2789        /* compute frame number for next insertion */
2790        xfer->endpoint->isoc_next += xfer->nframes;
2791
2792        /* setup TDs */
2793        saf1761_otg_setup_standard_chain(xfer);
2794}
2795
2796static void
2797saf1761_otg_host_isoc_start(struct usb_xfer *xfer)
2798{
2799        /* start TD chain */
2800        saf1761_otg_start_standard_chain(xfer);
2801}
2802
2803static const struct usb_pipe_methods saf1761_otg_host_isoc_methods =
2804{
2805        .open = saf1761_otg_host_isoc_open,
2806        .close = saf1761_otg_host_isoc_close,
2807        .enter = saf1761_otg_host_isoc_enter,
2808        .start = saf1761_otg_host_isoc_start,
2809};
2810
2811/*------------------------------------------------------------------------*
2812 * saf1761_otg root control support
2813 *------------------------------------------------------------------------*
2814 * Simulate a hardware HUB by handling all the necessary requests.
2815 *------------------------------------------------------------------------*/
2816
2817#define HSETW(ptr, val) ptr = { (uint8_t)(val), (uint8_t)((val) >> 8) }
2818
2819static const struct usb_device_descriptor saf1761_otg_devd = {
2820        .bLength = sizeof(struct usb_device_descriptor),
2821        .bDescriptorType = UDESC_DEVICE,
2822        HSETW(.idVendor, 0x04cc),
2823        HSETW(.idProduct, 0x1761),
2824        .bcdUSB = {0x00, 0x02},
2825        .bDeviceClass = UDCLASS_HUB,
2826        .bDeviceSubClass = UDSUBCLASS_HUB,
2827        .bDeviceProtocol = UDPROTO_FSHUB,
2828        .bMaxPacketSize = 64,
2829        .bcdDevice = {0x00, 0x01},
2830        .iManufacturer = 1,
2831        .iProduct = 2,
2832        .bNumConfigurations = 1,
2833};
2834
2835static const struct usb_device_qualifier saf1761_otg_odevd = {
2836        .bLength = sizeof(struct usb_device_qualifier),
2837        .bDescriptorType = UDESC_DEVICE_QUALIFIER,
2838        .bcdUSB = {0x00, 0x02},
2839        .bDeviceClass = UDCLASS_HUB,
2840        .bDeviceSubClass = UDSUBCLASS_HUB,
2841        .bDeviceProtocol = UDPROTO_FSHUB,
2842        .bMaxPacketSize0 = 0,
2843        .bNumConfigurations = 0,
2844};
2845
2846static const struct saf1761_otg_config_desc saf1761_otg_confd = {
2847        .confd = {
2848                .bLength = sizeof(struct usb_config_descriptor),
2849                .bDescriptorType = UDESC_CONFIG,
2850                .wTotalLength[0] = sizeof(saf1761_otg_confd),
2851                .bNumInterface = 1,
2852                .bConfigurationValue = 1,
2853                .iConfiguration = 0,
2854                .bmAttributes = UC_SELF_POWERED,
2855                .bMaxPower = 0,
2856        },
2857        .ifcd = {
2858                .bLength = sizeof(struct usb_interface_descriptor),
2859                .bDescriptorType = UDESC_INTERFACE,
2860                .bNumEndpoints = 1,
2861                .bInterfaceClass = UICLASS_HUB,
2862                .bInterfaceSubClass = UISUBCLASS_HUB,
2863                .bInterfaceProtocol = 0,
2864        },
2865
2866        .endpd = {
2867                .bLength = sizeof(struct usb_endpoint_descriptor),
2868                .bDescriptorType = UDESC_ENDPOINT,
2869                .bEndpointAddress = (UE_DIR_IN | SAF1761_OTG_INTR_ENDPT),
2870                .bmAttributes = UE_INTERRUPT,
2871                .wMaxPacketSize[0] = 8,
2872                .bInterval = 255,
2873        },
2874};
2875
2876static const struct usb_hub_descriptor_min saf1761_otg_hubd = {
2877        .bDescLength = sizeof(saf1761_otg_hubd),
2878        .bDescriptorType = UDESC_HUB,
2879        .bNbrPorts = SOTG_NUM_PORTS,
2880        HSETW(.wHubCharacteristics, (UHD_PWR_NO_SWITCH | UHD_OC_INDIVIDUAL)),
2881        .bPwrOn2PwrGood = 50,
2882        .bHubContrCurrent = 0,
2883        .DeviceRemovable = {0},         /* port is removable */
2884};
2885
2886#define STRING_VENDOR \
2887  "N\0X\0P"
2888
2889#define STRING_PRODUCT \
2890  "D\0C\0I\0 \0R\0o\0o\0t\0 \0H\0U\0B"
2891
2892USB_MAKE_STRING_DESC(STRING_VENDOR, saf1761_otg_vendor);
2893USB_MAKE_STRING_DESC(STRING_PRODUCT, saf1761_otg_product);
2894
2895static usb_error_t
2896saf1761_otg_roothub_exec(struct usb_device *udev,
2897    struct usb_device_request *req, const void **pptr, uint16_t *plength)
2898{
2899        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(udev->bus);
2900        const void *ptr;
2901        uint16_t len;
2902        uint16_t value;
2903        uint16_t index;
2904        uint32_t temp;
2905        uint32_t i;
2906        usb_error_t err;
2907
2908        USB_BUS_LOCK_ASSERT(&sc->sc_bus, MA_OWNED);
2909
2910        /* buffer reset */
2911        ptr = (const void *)&sc->sc_hub_temp;
2912        len = 0;
2913        err = 0;
2914
2915        value = UGETW(req->wValue);
2916        index = UGETW(req->wIndex);
2917
2918        /* demultiplex the control request */
2919
2920        switch (req->bmRequestType) {
2921        case UT_READ_DEVICE:
2922                switch (req->bRequest) {
2923                case UR_GET_DESCRIPTOR:
2924                        goto tr_handle_get_descriptor;
2925                case UR_GET_CONFIG:
2926                        goto tr_handle_get_config;
2927                case UR_GET_STATUS:
2928                        goto tr_handle_get_status;
2929                default:
2930                        goto tr_stalled;
2931                }
2932                break;
2933
2934        case UT_WRITE_DEVICE:
2935                switch (req->bRequest) {
2936                case UR_SET_ADDRESS:
2937                        goto tr_handle_set_address;
2938                case UR_SET_CONFIG:
2939                        goto tr_handle_set_config;
2940                case UR_CLEAR_FEATURE:
2941                        goto tr_valid;  /* nop */
2942                case UR_SET_DESCRIPTOR:
2943                        goto tr_valid;  /* nop */
2944                case UR_SET_FEATURE:
2945                default:
2946                        goto tr_stalled;
2947                }
2948                break;
2949
2950        case UT_WRITE_ENDPOINT:
2951                switch (req->bRequest) {
2952                case UR_CLEAR_FEATURE:
2953                        switch (UGETW(req->wValue)) {
2954                        case UF_ENDPOINT_HALT:
2955                                goto tr_handle_clear_halt;
2956                        case UF_DEVICE_REMOTE_WAKEUP:
2957                                goto tr_handle_clear_wakeup;
2958                        default:
2959                                goto tr_stalled;
2960                        }
2961                        break;
2962                case UR_SET_FEATURE:
2963                        switch (UGETW(req->wValue)) {
2964                        case UF_ENDPOINT_HALT:
2965                                goto tr_handle_set_halt;
2966                        case UF_DEVICE_REMOTE_WAKEUP:
2967                                goto tr_handle_set_wakeup;
2968                        default:
2969                                goto tr_stalled;
2970                        }
2971                        break;
2972                case UR_SYNCH_FRAME:
2973                        goto tr_valid;  /* nop */
2974                default:
2975                        goto tr_stalled;
2976                }
2977                break;
2978
2979        case UT_READ_ENDPOINT:
2980                switch (req->bRequest) {
2981                case UR_GET_STATUS:
2982                        goto tr_handle_get_ep_status;
2983                default:
2984                        goto tr_stalled;
2985                }
2986                break;
2987
2988        case UT_WRITE_INTERFACE:
2989                switch (req->bRequest) {
2990                case UR_SET_INTERFACE:
2991                        goto tr_handle_set_interface;
2992                case UR_CLEAR_FEATURE:
2993                        goto tr_valid;  /* nop */
2994                case UR_SET_FEATURE:
2995                default:
2996                        goto tr_stalled;
2997                }
2998                break;
2999
3000        case UT_READ_INTERFACE:
3001                switch (req->bRequest) {
3002                case UR_GET_INTERFACE:
3003                        goto tr_handle_get_interface;
3004                case UR_GET_STATUS:
3005                        goto tr_handle_get_iface_status;
3006                default:
3007                        goto tr_stalled;
3008                }
3009                break;
3010
3011        case UT_WRITE_CLASS_INTERFACE:
3012        case UT_WRITE_VENDOR_INTERFACE:
3013                /* XXX forward */
3014                break;
3015
3016        case UT_READ_CLASS_INTERFACE:
3017        case UT_READ_VENDOR_INTERFACE:
3018                /* XXX forward */
3019                break;
3020
3021        case UT_WRITE_CLASS_DEVICE:
3022                switch (req->bRequest) {
3023                case UR_CLEAR_FEATURE:
3024                        goto tr_valid;
3025                case UR_SET_DESCRIPTOR:
3026                case UR_SET_FEATURE:
3027                        break;
3028                default:
3029                        goto tr_stalled;
3030                }
3031                break;
3032
3033        case UT_WRITE_CLASS_OTHER:
3034                switch (req->bRequest) {
3035                case UR_CLEAR_FEATURE:
3036                        if (index == SOTG_HOST_PORT_NUM)
3037                                goto tr_handle_clear_port_feature_host;
3038                        else if (index == SOTG_DEVICE_PORT_NUM)
3039                                goto tr_handle_clear_port_feature_device;
3040                        else
3041                                goto tr_stalled;
3042                case UR_SET_FEATURE:
3043                        if (index == SOTG_HOST_PORT_NUM)
3044                                goto tr_handle_set_port_feature_host;
3045                        else if (index == SOTG_DEVICE_PORT_NUM)
3046                                goto tr_handle_set_port_feature_device;
3047                        else
3048                                goto tr_stalled;
3049                case UR_CLEAR_TT_BUFFER:
3050                case UR_RESET_TT:
3051                case UR_STOP_TT:
3052                        goto tr_valid;
3053
3054                default:
3055                        goto tr_stalled;
3056                }
3057                break;
3058
3059        case UT_READ_CLASS_OTHER:
3060                switch (req->bRequest) {
3061                case UR_GET_TT_STATE:
3062                        goto tr_handle_get_tt_state;
3063                case UR_GET_STATUS:
3064                        if (index == SOTG_HOST_PORT_NUM)
3065                                goto tr_handle_get_port_status_host;
3066                        else if (index == SOTG_DEVICE_PORT_NUM)
3067                                goto tr_handle_get_port_status_device;
3068                        else
3069                                goto tr_stalled;
3070                default:
3071                        goto tr_stalled;
3072                }
3073                break;
3074
3075        case UT_READ_CLASS_DEVICE:
3076                switch (req->bRequest) {
3077                case UR_GET_DESCRIPTOR:
3078                        goto tr_handle_get_class_descriptor;
3079                case UR_GET_STATUS:
3080                        goto tr_handle_get_class_status;
3081
3082                default:
3083                        goto tr_stalled;
3084                }
3085                break;
3086        default:
3087                goto tr_stalled;
3088        }
3089        goto tr_valid;
3090
3091tr_handle_get_descriptor:
3092        switch (value >> 8) {
3093        case UDESC_DEVICE:
3094                if (value & 0xff)
3095                        goto tr_stalled;
3096                len = sizeof(saf1761_otg_devd);
3097                ptr = (const void *)&saf1761_otg_devd;
3098                goto tr_valid;
3099        case UDESC_DEVICE_QUALIFIER:
3100                if (value & 0xff)
3101                        goto tr_stalled;
3102                len = sizeof(saf1761_otg_odevd);
3103                ptr = (const void *)&saf1761_otg_odevd;
3104                goto tr_valid;
3105        case UDESC_CONFIG:
3106                if (value & 0xff)
3107                        goto tr_stalled;
3108                len = sizeof(saf1761_otg_confd);
3109                ptr = (const void *)&saf1761_otg_confd;
3110                goto tr_valid;
3111        case UDESC_STRING:
3112                switch (value & 0xff) {
3113                case 0:         /* Language table */
3114                        len = sizeof(usb_string_lang_en);
3115                        ptr = (const void *)&usb_string_lang_en;
3116                        goto tr_valid;
3117
3118                case 1:         /* Vendor */
3119                        len = sizeof(saf1761_otg_vendor);
3120                        ptr = (const void *)&saf1761_otg_vendor;
3121                        goto tr_valid;
3122
3123                case 2:         /* Product */
3124                        len = sizeof(saf1761_otg_product);
3125                        ptr = (const void *)&saf1761_otg_product;
3126                        goto tr_valid;
3127                default:
3128                        break;
3129                }
3130                break;
3131        default:
3132                goto tr_stalled;
3133        }
3134        goto tr_stalled;
3135
3136tr_handle_get_config:
3137        len = 1;
3138        sc->sc_hub_temp.wValue[0] = sc->sc_conf;
3139        goto tr_valid;
3140
3141tr_handle_get_status:
3142        len = 2;
3143        USETW(sc->sc_hub_temp.wValue, UDS_SELF_POWERED);
3144        goto tr_valid;
3145
3146tr_handle_set_address:
3147        if (value & 0xFF00)
3148                goto tr_stalled;
3149
3150        sc->sc_rt_addr = value;
3151        goto tr_valid;
3152
3153tr_handle_set_config:
3154        if (value >= 2)
3155                goto tr_stalled;
3156        sc->sc_conf = value;
3157        goto tr_valid;
3158
3159tr_handle_get_interface:
3160        len = 1;
3161        sc->sc_hub_temp.wValue[0] = 0;
3162        goto tr_valid;
3163
3164tr_handle_get_tt_state:
3165tr_handle_get_class_status:
3166tr_handle_get_iface_status:
3167tr_handle_get_ep_status:
3168        len = 2;
3169        USETW(sc->sc_hub_temp.wValue, 0);
3170        goto tr_valid;
3171
3172tr_handle_set_halt:
3173tr_handle_set_interface:
3174tr_handle_set_wakeup:
3175tr_handle_clear_wakeup:
3176tr_handle_clear_halt:
3177        goto tr_valid;
3178
3179tr_handle_clear_port_feature_device:
3180        DPRINTFN(9, "UR_CLEAR_FEATURE on port %d\n", index);
3181
3182        switch (value) {
3183        case UHF_PORT_SUSPEND:
3184                saf1761_otg_wakeup_peer(sc);
3185                break;
3186
3187        case UHF_PORT_ENABLE:
3188                sc->sc_flags.port_enabled = 0;
3189                break;
3190
3191        case UHF_PORT_TEST:
3192        case UHF_PORT_INDICATOR:
3193        case UHF_C_PORT_ENABLE:
3194        case UHF_C_PORT_OVER_CURRENT:
3195        case UHF_C_PORT_RESET:
3196                /* nops */
3197                break;
3198        case UHF_PORT_POWER:
3199                sc->sc_flags.port_powered = 0;
3200                saf1761_otg_pull_down(sc);
3201                break;
3202        case UHF_C_PORT_CONNECTION:
3203                sc->sc_flags.change_connect = 0;
3204                break;
3205        case UHF_C_PORT_SUSPEND:
3206                sc->sc_flags.change_suspend = 0;
3207                break;
3208        default:
3209                err = USB_ERR_IOERROR;
3210                goto tr_valid;
3211        }
3212        goto tr_valid;
3213
3214tr_handle_clear_port_feature_host:
3215        DPRINTFN(9, "UR_CLEAR_FEATURE on port %d\n", index);
3216
3217        temp = SAF1761_READ_LE_4(sc, SOTG_PORTSC1);
3218
3219        switch (value) {
3220        case UHF_PORT_ENABLE:
3221                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp & ~SOTG_PORTSC1_PED);
3222                break;
3223        case UHF_PORT_SUSPEND:
3224                if ((temp & SOTG_PORTSC1_SUSP) && (!(temp & SOTG_PORTSC1_FPR)))
3225                        SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_FPR);
3226
3227                /* wait 20ms for resume sequence to complete */
3228                usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 50);
3229
3230                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp & ~(SOTG_PORTSC1_SUSP |
3231                    SOTG_PORTSC1_FPR | SOTG_PORTSC1_LS /* High Speed */ ));
3232
3233                /* 4ms settle time */
3234                usb_pause_mtx(&sc->sc_bus.bus_mtx, hz / 250);
3235                break;
3236        case UHF_PORT_INDICATOR:
3237                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp & ~SOTG_PORTSC1_PIC);
3238                break;
3239        case UHF_PORT_TEST:
3240        case UHF_C_PORT_ENABLE:
3241        case UHF_C_PORT_OVER_CURRENT:
3242        case UHF_C_PORT_RESET:
3243        case UHF_C_PORT_SUSPEND:
3244                /* NOPs */
3245                break;
3246        case UHF_PORT_POWER:
3247                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp & ~SOTG_PORTSC1_PP);
3248                break;
3249        case UHF_C_PORT_CONNECTION:
3250                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp & ~SOTG_PORTSC1_ECSC);
3251                break;
3252        default:
3253                err = USB_ERR_IOERROR;
3254                goto tr_valid;
3255        }
3256        goto tr_valid;
3257
3258tr_handle_set_port_feature_device:
3259        DPRINTFN(9, "UR_SET_FEATURE on port %d\n", index);
3260
3261        switch (value) {
3262        case UHF_PORT_ENABLE:
3263                sc->sc_flags.port_enabled = 1;
3264                break;
3265        case UHF_PORT_SUSPEND:
3266        case UHF_PORT_RESET:
3267        case UHF_PORT_TEST:
3268        case UHF_PORT_INDICATOR:
3269                /* nops */
3270                break;
3271        case UHF_PORT_POWER:
3272                sc->sc_flags.port_powered = 1;
3273                break;
3274        default:
3275                err = USB_ERR_IOERROR;
3276                goto tr_valid;
3277        }
3278        goto tr_valid;
3279
3280tr_handle_set_port_feature_host:
3281        DPRINTFN(9, "UR_SET_FEATURE on port %d\n", index);
3282
3283        temp = SAF1761_READ_LE_4(sc, SOTG_PORTSC1);
3284
3285        switch (value) {
3286        case UHF_PORT_ENABLE:
3287                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_PED);
3288                break;
3289        case UHF_PORT_SUSPEND:
3290                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_SUSP);
3291                break;
3292        case UHF_PORT_RESET:
3293                DPRINTFN(6, "reset port %d\n", index);
3294
3295                /* Start reset sequence. */
3296                temp &= ~(SOTG_PORTSC1_PED | SOTG_PORTSC1_PR);
3297
3298                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_PR);
3299
3300                /* Wait for reset to complete. */
3301                usb_pause_mtx(&sc->sc_bus.bus_mtx,
3302                    USB_MS_TO_TICKS(usb_port_root_reset_delay));
3303
3304                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp);
3305
3306                /* Wait for HC to complete reset. */
3307                usb_pause_mtx(&sc->sc_bus.bus_mtx, USB_MS_TO_TICKS(2));
3308
3309                temp = SAF1761_READ_LE_4(sc, SOTG_PORTSC1);
3310
3311                DPRINTF("After reset, status=0x%08x\n", temp);
3312                if (temp & SOTG_PORTSC1_PR) {
3313                        device_printf(sc->sc_bus.bdev, "port reset timeout\n");
3314                        err = USB_ERR_TIMEOUT;
3315                        goto tr_valid;
3316                }
3317                if (!(temp & SOTG_PORTSC1_PED)) {
3318                        /* Not a high speed device, give up ownership.*/
3319                        SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_PO);
3320                        break;
3321                }
3322                sc->sc_isreset = 1;
3323                DPRINTF("port %d reset, status = 0x%08x\n", index, temp);
3324                break;
3325        case UHF_PORT_POWER:
3326                DPRINTFN(3, "set port power %d\n", index);
3327                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_PP);
3328                break;
3329
3330        case UHF_PORT_TEST:
3331                DPRINTFN(3, "set port test %d\n", index);
3332                break;
3333
3334        case UHF_PORT_INDICATOR:
3335                DPRINTFN(3, "set port ind %d\n", index);
3336                SAF1761_WRITE_LE_4(sc, SOTG_PORTSC1, temp | SOTG_PORTSC1_PIC);
3337                break;
3338        default:
3339                err = USB_ERR_IOERROR;
3340                goto tr_valid;
3341        }
3342        goto tr_valid;
3343
3344tr_handle_get_port_status_device:
3345
3346        DPRINTFN(9, "UR_GET_PORT_STATUS on port %d\n", index);
3347
3348        if (sc->sc_flags.status_vbus) {
3349                saf1761_otg_pull_up(sc);
3350        } else {
3351                saf1761_otg_pull_down(sc);
3352        }
3353
3354        /* Select FULL-speed and Device Side Mode */
3355
3356        value = UPS_PORT_MODE_DEVICE;
3357
3358        if (sc->sc_flags.port_powered)
3359                value |= UPS_PORT_POWER;
3360
3361        if (sc->sc_flags.port_enabled)
3362                value |= UPS_PORT_ENABLED;
3363
3364        if (sc->sc_flags.status_vbus &&
3365            sc->sc_flags.status_bus_reset)
3366                value |= UPS_CURRENT_CONNECT_STATUS;
3367
3368        if (sc->sc_flags.status_suspend)
3369                value |= UPS_SUSPEND;
3370
3371        USETW(sc->sc_hub_temp.ps.wPortStatus, value);
3372
3373        value = 0;
3374
3375        if (sc->sc_flags.change_connect)
3376                value |= UPS_C_CONNECT_STATUS;
3377
3378        if (sc->sc_flags.change_suspend)
3379                value |= UPS_C_SUSPEND;
3380
3381        USETW(sc->sc_hub_temp.ps.wPortChange, value);
3382        len = sizeof(sc->sc_hub_temp.ps);
3383        goto tr_valid;
3384
3385tr_handle_get_port_status_host:
3386
3387        temp = SAF1761_READ_LE_4(sc, SOTG_PORTSC1);
3388
3389        DPRINTFN(9, "UR_GET_PORT_STATUS on port %d = 0x%08x\n", index, temp);
3390
3391        i = UPS_HIGH_SPEED;
3392
3393        if (temp & SOTG_PORTSC1_ECCS)
3394                i |= UPS_CURRENT_CONNECT_STATUS;
3395        if (temp & SOTG_PORTSC1_PED)
3396                i |= UPS_PORT_ENABLED;
3397        if ((temp & SOTG_PORTSC1_SUSP) && !(temp & SOTG_PORTSC1_FPR))
3398                i |= UPS_SUSPEND;
3399        if (temp & SOTG_PORTSC1_PR)
3400                i |= UPS_RESET;
3401        if (temp & SOTG_PORTSC1_PP)
3402                i |= UPS_PORT_POWER;
3403
3404        USETW(sc->sc_hub_temp.ps.wPortStatus, i);
3405        i = 0;
3406
3407        if (temp & SOTG_PORTSC1_ECSC)
3408                i |= UPS_C_CONNECT_STATUS;
3409        if (temp & SOTG_PORTSC1_FPR)
3410                i |= UPS_C_SUSPEND;
3411        if (sc->sc_isreset)
3412                i |= UPS_C_PORT_RESET;
3413        USETW(sc->sc_hub_temp.ps.wPortChange, i);
3414        len = sizeof(sc->sc_hub_temp.ps);
3415        goto tr_valid;
3416
3417tr_handle_get_class_descriptor:
3418        if (value & 0xFF)
3419                goto tr_stalled;
3420        ptr = (const void *)&saf1761_otg_hubd;
3421        len = sizeof(saf1761_otg_hubd);
3422        goto tr_valid;
3423
3424tr_stalled:
3425        err = USB_ERR_STALLED;
3426tr_valid:
3427        *plength = len;
3428        *pptr = ptr;
3429        return (err);
3430}
3431
3432static void
3433saf1761_otg_xfer_setup(struct usb_setup_params *parm)
3434{
3435        struct saf1761_otg_softc *sc;
3436        struct usb_xfer *xfer;
3437        void *last_obj;
3438        uint32_t dw1;
3439        uint32_t ntd;
3440        uint32_t n;
3441        uint8_t ep_no;
3442        uint8_t ep_type;
3443
3444        sc = SAF1761_OTG_BUS2SC(parm->udev->bus);
3445        xfer = parm->curr_xfer;
3446
3447        /*
3448         * NOTE: This driver does not use any of the parameters that
3449         * are computed from the following values. Just set some
3450         * reasonable dummies:
3451         */
3452        parm->hc_max_packet_size = 0x500;
3453        parm->hc_max_packet_count = 1;
3454        parm->hc_max_frame_size = 0x500;
3455
3456        usbd_transfer_setup_sub(parm);
3457
3458        /*
3459         * Compute maximum number of TDs:
3460         */
3461        ep_type = (xfer->endpoint->edesc->bmAttributes & UE_XFERTYPE);
3462
3463        if (ep_type == UE_CONTROL) {
3464
3465                ntd = xfer->nframes + 1 /* STATUS */ + 1 /* SYNC */ ;
3466
3467        } else {
3468                ntd = xfer->nframes + 1 /* SYNC */ ;
3469        }
3470
3471        /*
3472         * check if "usbd_transfer_setup_sub" set an error
3473         */
3474        if (parm->err)
3475                return;
3476
3477        /*
3478         * allocate transfer descriptors
3479         */
3480        last_obj = NULL;
3481
3482        ep_no = xfer->endpointno & UE_ADDR;
3483
3484        /*
3485         * Check profile stuff
3486         */
3487        if (parm->udev->flags.usb_mode == USB_MODE_DEVICE) {
3488                const struct usb_hw_ep_profile *pf;
3489
3490                saf1761_otg_get_hw_ep_profile(parm->udev, &pf, ep_no);
3491
3492                if (pf == NULL) {
3493                        /* should not happen */
3494                        parm->err = USB_ERR_INVAL;
3495                        return;
3496                }
3497        }
3498
3499        dw1 = (xfer->address << 3) | (ep_type << 12);
3500
3501        switch (parm->udev->speed) {
3502        case USB_SPEED_FULL:
3503        case USB_SPEED_LOW:
3504                /* check if root HUB port is running High Speed */
3505                if (parm->udev->parent_hs_hub != NULL) {
3506                        dw1 |= SOTG_PTD_DW1_ENABLE_SPLIT;
3507                        dw1 |= (parm->udev->hs_port_no << 18);
3508                        dw1 |= (parm->udev->hs_hub_addr << 25);
3509                        if (parm->udev->speed == USB_SPEED_LOW)
3510                                dw1 |= (1 << 17);
3511                }
3512                break;
3513        default:
3514                break;
3515        }
3516
3517        /* align data */
3518        parm->size[0] += ((-parm->size[0]) & (USB_HOST_ALIGN - 1));
3519
3520        for (n = 0; n != ntd; n++) {
3521
3522                struct saf1761_otg_td *td;
3523
3524                if (parm->buf) {
3525
3526                        td = USB_ADD_BYTES(parm->buf, parm->size[0]);
3527
3528                        /* init TD */
3529                        td->max_packet_size = xfer->max_packet_size;
3530                        td->ep_index = ep_no;
3531                        td->ep_type = ep_type;
3532                        td->dw1_value = dw1;
3533                        td->uframe = 0;
3534
3535                        if (ep_type == UE_INTERRUPT) {
3536                                if (xfer->interval > 32)
3537                                        td->interval = (32 / 2) << 3;
3538                                else
3539                                        td->interval = (xfer->interval / 2) << 3;
3540                        } else {
3541                                td->interval = 0;
3542                        }
3543                        td->obj_next = last_obj;
3544
3545                        last_obj = td;
3546                }
3547                parm->size[0] += sizeof(*td);
3548        }
3549
3550        xfer->td_start[0] = last_obj;
3551}
3552
3553static void
3554saf1761_otg_xfer_unsetup(struct usb_xfer *xfer)
3555{
3556}
3557
3558static void
3559saf1761_otg_ep_init(struct usb_device *udev, struct usb_endpoint_descriptor *edesc,
3560    struct usb_endpoint *ep)
3561{
3562        uint16_t mps;
3563
3564        DPRINTFN(2, "endpoint=%p, addr=%d, endpt=%d, mode=%d\n",
3565            ep, udev->address,
3566            edesc->bEndpointAddress, udev->flags.usb_mode);
3567
3568        if (udev->parent_hub == NULL) {
3569                /* root HUB has special endpoint handling */
3570                return;
3571        }
3572
3573        /* Verify wMaxPacketSize */
3574        mps = UGETW(edesc->wMaxPacketSize);
3575        if (udev->speed == USB_SPEED_HIGH) {
3576                if ((mps >> 11) & 3) {
3577                        DPRINTF("A packet multiplier different from "
3578                            "1 is not supported\n");
3579                        return;
3580                }
3581        }
3582        if (mps > SOTG_HS_MAX_PACKET_SIZE) {
3583                DPRINTF("Packet size %d bigger than %d\n",
3584                    (int)mps, SOTG_HS_MAX_PACKET_SIZE);
3585                return;
3586        }
3587        if (udev->flags.usb_mode == USB_MODE_DEVICE) {
3588                if (udev->speed != USB_SPEED_FULL &&
3589                    udev->speed != USB_SPEED_HIGH) {
3590                        /* not supported */
3591                        return;
3592                }
3593                switch (edesc->bmAttributes & UE_XFERTYPE) {
3594                case UE_ISOCHRONOUS:
3595                        ep->methods = &saf1761_otg_device_isoc_methods;
3596                        break;
3597                default:
3598                        ep->methods = &saf1761_otg_non_isoc_methods;
3599                        break;
3600                }
3601        } else {
3602                switch (edesc->bmAttributes & UE_XFERTYPE) {
3603                case UE_ISOCHRONOUS:
3604                        ep->methods = &saf1761_otg_host_isoc_methods;
3605                        break;
3606                default:
3607                        ep->methods = &saf1761_otg_non_isoc_methods;
3608                        break;
3609                }
3610        }
3611}
3612
3613static void
3614saf1761_otg_set_hw_power_sleep(struct usb_bus *bus, uint32_t state)
3615{
3616        struct saf1761_otg_softc *sc = SAF1761_OTG_BUS2SC(bus);
3617
3618        switch (state) {
3619        case USB_HW_POWER_SUSPEND:
3620                saf1761_otg_suspend(sc);
3621                break;
3622        case USB_HW_POWER_SHUTDOWN:
3623                saf1761_otg_uninit(sc);
3624                break;
3625        case USB_HW_POWER_RESUME:
3626                saf1761_otg_resume(sc);
3627                break;
3628        default:
3629                break;
3630        }
3631}
3632
3633static void
3634saf1761_otg_device_resume(struct usb_device *udev)
3635{
3636        struct saf1761_otg_softc *sc;
3637        struct saf1761_otg_td *td;
3638        struct usb_xfer *xfer;
3639        uint8_t x;
3640
3641        DPRINTF("\n");
3642
3643        if (udev->flags.usb_mode != USB_MODE_HOST)
3644                return;
3645
3646        sc = SAF1761_OTG_BUS2SC(udev->bus);
3647
3648        USB_BUS_LOCK(&sc->sc_bus);
3649        USB_BUS_SPIN_LOCK(&sc->sc_bus);
3650
3651        TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
3652
3653                if (xfer->xroot->udev != udev)
3654                        continue;
3655
3656                td = xfer->td_transfer_cache;
3657                if (td == NULL || td->channel >= SOTG_HOST_CHANNEL_MAX)
3658                        continue;
3659
3660                switch (td->ep_type) {
3661                case UE_INTERRUPT:
3662                        x = td->channel - 32;
3663                        sc->sc_host_intr_suspend_map &= ~(1U << x);
3664                        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD,
3665                            (~sc->sc_host_intr_map) | sc->sc_host_intr_suspend_map);
3666                        break;
3667                case UE_ISOCHRONOUS:
3668                        x = td->channel;
3669                        sc->sc_host_isoc_suspend_map &= ~(1U << x);
3670                        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD,
3671                            (~sc->sc_host_isoc_map) | sc->sc_host_isoc_suspend_map);
3672                        break;
3673                default:
3674                        x = td->channel - 64;
3675                        sc->sc_host_async_suspend_map &= ~(1U << x);
3676                        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
3677                            (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
3678                        break;
3679                }
3680        }
3681
3682        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
3683        USB_BUS_UNLOCK(&sc->sc_bus);
3684
3685        /* poll all transfers again to restart resumed ones */
3686        saf1761_otg_do_poll(&sc->sc_bus);
3687}
3688
3689static void
3690saf1761_otg_device_suspend(struct usb_device *udev)
3691{
3692        struct saf1761_otg_softc *sc;
3693        struct saf1761_otg_td *td;
3694        struct usb_xfer *xfer;
3695        uint8_t x;
3696
3697        DPRINTF("\n");
3698
3699        if (udev->flags.usb_mode != USB_MODE_HOST)
3700                return;
3701
3702        sc = SAF1761_OTG_BUS2SC(udev->bus);
3703
3704        USB_BUS_LOCK(&sc->sc_bus);
3705        USB_BUS_SPIN_LOCK(&sc->sc_bus);
3706
3707        TAILQ_FOREACH(xfer, &sc->sc_bus.intr_q.head, wait_entry) {
3708
3709                if (xfer->xroot->udev != udev)
3710                        continue;
3711
3712                td = xfer->td_transfer_cache;
3713                if (td == NULL || td->channel >= SOTG_HOST_CHANNEL_MAX)
3714                        continue;
3715
3716                switch (td->ep_type) {
3717                case UE_INTERRUPT:
3718                        x = td->channel - 32;
3719                        sc->sc_host_intr_suspend_map |= (1U << x);
3720                        SAF1761_WRITE_LE_4(sc, SOTG_INT_PTD_SKIP_PTD,
3721                            (~sc->sc_host_intr_map) | sc->sc_host_intr_suspend_map);
3722                        break;
3723                case UE_ISOCHRONOUS:
3724                        x = td->channel;
3725                        sc->sc_host_isoc_suspend_map |= (1U << x);
3726                        SAF1761_WRITE_LE_4(sc, SOTG_ISO_PTD_SKIP_PTD,
3727                            (~sc->sc_host_isoc_map) | sc->sc_host_isoc_suspend_map);
3728                        break;
3729                default:
3730                        x = td->channel - 64;
3731                        sc->sc_host_async_suspend_map |= (1U << x);
3732                        SAF1761_WRITE_LE_4(sc, SOTG_ATL_PTD_SKIP_PTD,
3733                            (~sc->sc_host_async_map) | sc->sc_host_async_suspend_map);
3734                        break;
3735                }
3736        }
3737
3738        USB_BUS_SPIN_UNLOCK(&sc->sc_bus);
3739        USB_BUS_UNLOCK(&sc->sc_bus);
3740}
3741
3742static const struct usb_bus_methods saf1761_otg_bus_methods =
3743{
3744        .endpoint_init = &saf1761_otg_ep_init,
3745        .xfer_setup = &saf1761_otg_xfer_setup,
3746        .xfer_unsetup = &saf1761_otg_xfer_unsetup,
3747        .get_hw_ep_profile = &saf1761_otg_get_hw_ep_profile,
3748        .xfer_stall = &saf1761_otg_xfer_stall,
3749        .set_stall = &saf1761_otg_set_stall,
3750        .clear_stall = &saf1761_otg_clear_stall,
3751        .roothub_exec = &saf1761_otg_roothub_exec,
3752        .xfer_poll = &saf1761_otg_do_poll,
3753        .set_hw_power_sleep = saf1761_otg_set_hw_power_sleep,
3754        .device_resume = &saf1761_otg_device_resume,
3755        .device_suspend = &saf1761_otg_device_suspend,
3756};
Note: See TracBrowser for help on using the repository browser.