Subversion Repositories freemyipod

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
15 theseven 1 
//
2 
//
3 
//    Copyright 2010 TheSeven
4 
//
5 
//
6 
//    This file is part of emBIOS.
7 
//
8 
//    emBIOS is free software: you can redistribute it and/or
9 
//    modify it under the terms of the GNU General Public License as
10 
//    published by the Free Software Foundation, either version 2 of the
11 
//    License, or (at your option) any later version.
12 
//
13 
//    emBIOS is distributed in the hope that it will be useful,
14 
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
15 
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16 
//    See the GNU General Public License for more details.
17 
//
18 
//    You should have received a copy of the GNU General Public License along
19 
//    with emBIOS.  If not, see <http://www.gnu.org/licenses/>.
20 
//
21 
//
22 
 
23 
 
24 
#include "global.h"
25 
#include "mmu.h"
26 
#include "panic.h"
27 
#include "usbdrv.h"
28 
#include "thread.h"
29 
#include "timer.h"
30 
#include "usb.h"
31 
#include "usb_ch9.h"
32 
#include "synopsysotg.h"
58 theseven 33 
#include "util.h"
85 theseven 34 
#include "interrupt.h"
87 theseven 35 
#include "clockgates.h"
221 theseven 36 
#include "power.h"
15 theseven 37 
 
38 
 
39 
struct ep_type
40 
{
41 
    bool active;
42 
    bool busy;
43 
    bool done;
44 
    int rc;
45 
    int size;
46 
    struct wakeup complete;
47 
} ;
48 
 
49 
static struct ep_type endpoints[5];
50 
static struct usb_ctrlrequest ctrlreq CACHEALIGN_ATTR;
221 theseven 51 
static uint32_t synopsysotg_stack[0x40] STACK_ATTR;
15 theseven 52 
 
53 
int usb_drv_port_speed(void)
54 
{
55 
    return (DSTS & 2) == 0 ? 1 : 0;
56 
}
57 
 
66 theseven 58 
static void reset_endpoints(int reinit)
15 theseven 59 
{
60 
    unsigned int i;
61 
    for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++)
62 
    {
63 
        if (reinit) endpoints[i].active = false;
64 
        endpoints[i].busy = false;
65 
        endpoints[i].rc = -1;
66 
        endpoints[i].done = true;
67 
        wakeup_signal(&endpoints[i].complete);
68 
    }
69 
    DIEPCTL0 = 0x8800;  /* EP0 IN ACTIVE NEXT=1 */
70 
    DOEPCTL0 = 0x8000;  /* EP0 OUT ACTIVE */
71 
    DOEPTSIZ0 = 0x20080040;  /* EP0 OUT Transfer Size:
72 
                                64 Bytes, 1 Packet, 1 Setup Packet */
265 theseven 73 
    DOEPDMA0 = &ctrlreq;
15 theseven 74 
    DOEPCTL0 |= 0x84000000;  /* EP0 OUT ENABLE CLEARNAK */
75 
    if (reinit)
76 
    {
77 
        /* The size is getting set to zero, because we don't know
78 
           whether we are Full Speed or High Speed at this stage */
79 
        /* EP1 IN INACTIVE DATA0 SIZE=0 NEXT=3 */
80 
        DIEPCTL1 = 0x10001800;
81 
        /* EP2 OUT INACTIVE DATA0 SIZE=0 */
82 
        DOEPCTL2 = 0x10000000;
83 
        /* EP3 IN INACTIVE DATA0 SIZE=0 NEXT=0 */
84 
        DIEPCTL3 = 0x10000000;
85 
        /* EP4 OUT INACTIVE DATA0 SIZE=0 */
86 
        DOEPCTL4 = 0x10000000;
87 
    }
88 
    else
89 
    {
90 
        /* INACTIVE DATA0 */
91 
        DIEPCTL1 = (DIEPCTL1 & ~0x00008000) | 0x10000000;
92 
        DOEPCTL2 = (DOEPCTL2 & ~0x00008000) | 0x10000000;
93 
        DIEPCTL3 = (DIEPCTL3 & ~0x00008000) | 0x10000000;
94 
        DOEPCTL4 = (DOEPCTL4 & ~0x00008000) | 0x10000000;
95 
    }
96 
    DAINTMSK = 0xFFFFFFFF;  /* Enable interrupts on all EPs */
97 
}
98 
 
99 
int usb_drv_request_endpoint(int type, int dir)
100 
{
101 
    size_t ep;
102 
    int ret = -1;
103 
 
104 
    if (dir == USB_DIR_IN) ep = 1;
105 
    else ep = 2;
106 
 
107 
    while (ep < 5)
108 
    {
109 
        if (!endpoints[ep].active)
110 
        {
111 
            endpoints[ep].active = true;
112 
            ret = ep | dir;
113 
            uint32_t newbits = (type << 18) | 0x10000000;
114 
            if (dir) DIEPCTL(ep) = (DIEPCTL(ep) & ~0x000C0000) | newbits;
115 
            else DOEPCTL(ep) = (DOEPCTL(ep) & ~0x000C0000) | newbits;
116 
            break;
117 
        }
118 
        ep += 2;
119 
    }
120 
 
121 
    return ret;
122 
}
123 
 
124 
void usb_drv_release_endpoint(int ep)
125 
{
126 
    ep = ep & 0x7f;
127 
 
128 
    if (ep < 1 || ep > USB_NUM_ENDPOINTS) return;
129 
 
130 
    endpoints[ep].active = false;
131 
}
132 
 
133 
static void usb_reset(void)
134 
{
135 
    volatile int i;
136 
 
137 
    DCTL = 0x802;  /* Soft Disconnect */
138 
 
139 
    OPHYPWR = 0;  /* PHY: Power up */
85 theseven 140 
    OPHYUNK1 = 1;
15 theseven 141 
    OPHYUNK2 = 0xE3F;
85 theseven 142 
    OPHYCLK = SYNOPSYSOTG_CLOCK;
15 theseven 143 
    ORSTCON = 1;  /* PHY: Assert Software Reset */
144 
    udelay(10);
145 
    ORSTCON = 0;  /* PHY: Deassert Software Reset */
274 theseven 146 
    OPHYUNK3 = 0x600;
15 theseven 147 
 
148 
    GRSTCTL = 1;  /* OTG: Assert Software Reset */
149 
    while (GRSTCTL & 1);  /* Wait for OTG to ack reset */
150 
    while (!(GRSTCTL & 0x80000000));  /* Wait for OTG AHB master idle */
151 
 
152 
    GRXFSIZ = 0x00000200;  /* RX FIFO: 512 bytes */
153 
    GNPTXFSIZ = 0x02000200;  /* Non-periodic TX FIFO: 512 bytes */
85 theseven 154 
    GAHBCFG = SYNOPSYSOTG_AHBCFG;
15 theseven 155 
    GUSBCFG = 0x1408;  /* OTG: 16bit PHY and some reserved bits */
156 
 
157 
    DCFG = 4;  /* Address 0 */
158 
    DCTL = 0x800;  /* Soft Reconnect */
159 
    DIEPMSK = 0x0D;  /* IN EP interrupt mask */
160 
    DOEPMSK = 0x0D;  /* IN EP interrupt mask */
161 
    DAINTMSK = 0xFFFFFFFF;  /* Enable interrupts on all endpoints */
162 
    GINTMSK = 0xC3000;  /* Interrupt mask: IN event, OUT event, bus reset */
163 
 
164 
    reset_endpoints(1);
165 
}
166 
 
167 
/* IRQ handler */
168 
void INT_USB_FUNC(void)
169 
{
170 
    int i;
171 
    uint32_t ints = GINTSTS;
172 
    uint32_t epints;
173 
    if (ints & 0x1000)  /* bus reset */
174 
    {
175 
        DCFG = 4;  /* Address 0 */
176 
        reset_endpoints(1);
177 
        usb_handle_bus_reset();
178 
    }
179 
 
180 
    if (ints & 0x2000)  /* enumeration done, we now know the speed */
181 
    {
182 
        /* Set up the maximum packet sizes accordingly */
183 
        uint32_t maxpacket = usb_drv_port_speed() ? 512 : 64;
184 
        DIEPCTL1 = (DIEPCTL1 & ~0x000003FF) | maxpacket;
185 
        DOEPCTL2 = (DOEPCTL2 & ~0x000003FF) | maxpacket;
186 
        DIEPCTL3 = (DIEPCTL3 & ~0x000003FF) | maxpacket;
187 
        DOEPCTL4 = (DOEPCTL4 & ~0x000003FF) | maxpacket;
188 
    }
189 
 
190 
    if (ints & 0x40000)  /* IN EP event */
191 
        for (i = 0; i < 4; i += i + 1)  // 0, 1, 3
192 
            if (epints = DIEPINT(i))
193 
            {
194 
                if (epints & 1)  /* Transfer completed */
195 
                {
196 
                    invalidate_dcache();
197 
                    int bytes = endpoints[i].size - (DIEPTSIZ(i) & 0x3FFFF);
198 
                    if (endpoints[i].busy)
199 
                    {
200 
                        endpoints[i].busy = false;
201 
                        endpoints[i].rc = 0;
202 
                        endpoints[i].done = true;
203 
                        usb_handle_transfer_complete(i, USB_DIR_IN, 0, bytes);
204 
                        wakeup_signal(&endpoints[i].complete);
205 
                    }
206 
                }
207 
                if (epints & 4)  /* AHB error */
208 
                    panicf(PANIC_FATAL, "USB: AHB error on IN EP%d", i);
209 
                if (epints & 8)  /* Timeout */
210 
                {
211 
                    if (endpoints[i].busy)
212 
                    {
213 
                        endpoints[i].busy = false;
214 
                        endpoints[i].rc = 1;
215 
                        endpoints[i].done = true;
216 
                        wakeup_signal(&endpoints[i].complete);
217 
                    }
218 
                }
219 
                DIEPINT(i) = epints;
220 
            }
221 
 
222 
    if (ints & 0x80000)  /* OUT EP event */
223 
        for (i = 0; i < 5; i += 2)  // 0, 2, 4
224 
            if (epints = DOEPINT(i))
225 
            {
226 
                if (epints & 1)  /* Transfer completed */
227 
                {
228 
                    invalidate_dcache();
229 
                    int bytes = endpoints[i].size - (DOEPTSIZ(i) & 0x3FFFF);
230 
                    if (endpoints[i].busy)
231 
                    {
232 
                        endpoints[i].busy = false;
233 
                        endpoints[i].rc = 0;
234 
                        endpoints[i].done = true;
235 
                        usb_handle_transfer_complete(i, USB_DIR_OUT, 0, bytes);
236 
                        wakeup_signal(&endpoints[i].complete);
237 
                    }
238 
                }
239 
                if (epints & 4)  /* AHB error */
240 
                    panicf(PANIC_FATAL, "USB: AHB error on OUT EP%d", i);
241 
                if (epints & 8)  /* SETUP phase done */
242 
                {
243 
                    invalidate_dcache();
244 
                    if (i == 0) usb_handle_control_request(&ctrlreq);
245 
                    else panicf(PANIC_FATAL, "USB: SETUP done on OUT EP%d!?", i);
246 
                }
247 
                /* Make sure EP0 OUT is set up to accept the next request */
248 
                if (!i)
249 
                {
250 
                    DOEPTSIZ0 = 0x20080040;
265 theseven 251 
                    DOEPDMA0 = &ctrlreq;
15 theseven 252 
                    DOEPCTL0 |= 0x84000000;
253 
                }
254 
                DOEPINT(i) = epints;
255 
            }
256 
 
257 
    GINTSTS = ints;
258 
}
259 
 
260 
void usb_drv_set_address(int address)
261 
{
262 
    DCFG = (DCFG & ~0x7F0) | (address << 4);
263 
}
264 
 
66 theseven 265 
static void ep_send(int ep, const void *ptr, int length)
15 theseven 266 
{
267 
    endpoints[ep].busy = true;
268 
    endpoints[ep].size = length;
269 
    DIEPCTL(ep) |= 0x8000;  /* EPx OUT ACTIVE */
270 
    int blocksize = usb_drv_port_speed() ? 512 : 64;
271 
    int packets = (length + blocksize - 1) / blocksize;
272 
    if (!length)
273 
    {
274 
        DIEPTSIZ(ep) = 1 << 19;  /* one empty packet */
265 theseven 275 
        DIEPDMA(ep) = NULL;  /* dummy address */
15 theseven 276 
    }
277 
    else
278 
    {
279 
        DIEPTSIZ(ep) = length | (packets << 19);
265 theseven 280 
        DIEPDMA(ep) = ptr;
15 theseven 281 
    }
282 
    clean_dcache();
283 
    DIEPCTL(ep) |= 0x84000000;  /* EPx OUT ENABLE CLEARNAK */
284 
}
285 
 
66 theseven 286 
static void ep_recv(int ep, void *ptr, int length)
15 theseven 287 
{
288 
    endpoints[ep].busy = true;
289 
    endpoints[ep].size = length;
290 
    DOEPCTL(ep) &= ~0x20000;  /* EPx UNSTALL */
291 
    DOEPCTL(ep) |= 0x8000;  /* EPx OUT ACTIVE */
292 
    int blocksize = usb_drv_port_speed() ? 512 : 64;
293 
    int packets = (length + blocksize - 1) / blocksize;
294 
    if (!length)
295 
    {
296 
        DOEPTSIZ(ep) = 1 << 19;  /* one empty packet */
265 theseven 297 
        DOEPDMA(ep) = NULL;  /* dummy address */
15 theseven 298 
    }
299 
    else
300 
    {
301 
        DOEPTSIZ(ep) = length | (packets << 19);
265 theseven 302 
        DOEPDMA(ep) = ptr;
15 theseven 303 
    }
304 
    clean_dcache();
305 
    DOEPCTL(ep) |= 0x84000000;  /* EPx OUT ENABLE CLEARNAK */
306 
}
307 
 
308 
int usb_drv_send(int endpoint, const void *ptr, int length)
309 
{
310 
    endpoint &= 0x7f;
311 
    endpoints[endpoint].done = false;
312 
    ep_send(endpoint, ptr, length);
313 
    while (!endpoints[endpoint].done && endpoints[endpoint].busy)
314 
        wakeup_wait(&endpoints[endpoint].complete, TIMEOUT_BLOCK);
315 
    return endpoints[endpoint].rc;
316 
}
317 
 
318 
int usb_drv_send_nonblocking(int endpoint, const void *ptr, int length)
319 
{
320 
    ep_send(endpoint & 0x7f, ptr, length);
321 
    return 0;
322 
}
323 
 
324 
int usb_drv_recv(int endpoint, void* ptr, int length)
325 
{
326 
    ep_recv(endpoint & 0x7f, ptr, length);
327 
    return 0;
328 
}
329 
 
330 
void usb_drv_cancel_all_transfers(void)
331 
{
332 
    uint32_t mode = enter_critical_section();
333 
    reset_endpoints(0);
334 
    leave_critical_section(mode);
335 
}
336 
 
337 
bool usb_drv_stalled(int endpoint, bool in)
338 
{
339 
    if (in) return DIEPCTL(endpoint) & 0x00200000 ? true : false;
340 
    else return DOEPCTL(endpoint) & 0x00200000 ? true : false;
341 
}
342 
 
343 
void usb_drv_stall(int endpoint, bool stall, bool in)
344 
{
345 
    if (in)
346 
    {
347 
        if (stall) DIEPCTL(endpoint) |= 0x00200000;
348 
        else DIEPCTL(endpoint) &= ~0x00200000;
349 
    }
350 
    else
351 
    {
352 
        if (stall) DOEPCTL(endpoint) |= 0x00200000;
353 
        else DOEPCTL(endpoint) &= ~0x00200000;
354 
    }
355 
}
356 
 
225 theseven 357 
void usb_drv_power_up(void)
358 
{
359 
    /* Enable USB clock */
221 theseven 360 
    clockgate_enable(CLOCKGATE_USB_1, true);
361 
    clockgate_enable(CLOCKGATE_USB_2, true);
225 theseven 362 
    PCGCCTL = 0;
363 
 
364 
    /* reset the beast */
365 
    usb_reset();
366 
}
367 
 
368 
void usb_drv_power_down(void)
369 
{
370 
    DCTL = 0x802;  /* Soft Disconnect */
371 
 
372 
    ORSTCON = 1;  /* Put the PHY into reset (needed to get current down) */
373 
    PCGCCTL = 1;  /* Shut down PHY clock */
374 
    OPHYPWR = 0xF;  /* PHY: Power down */
375 
 
221 theseven 376 
    clockgate_enable(CLOCKGATE_USB_1, false);
377 
    clockgate_enable(CLOCKGATE_USB_2, false);
225 theseven 378 
}
379 
 
221 theseven 380 
void usb_check_vbus()
381 
{
382 
    bool oldstate = false;
383 
    while (true)
384 
    {
385 
        sleep(200000);
386 
        bool newstate = vbus_state();
387 
        if (oldstate != newstate)
388 
        {
389 
            if (newstate) usb_drv_power_up();
390 
            else usb_drv_power_down();
391 
            oldstate = newstate;
392 
        }
393 
    }
394 
}
395 
 
15 theseven 396 
void usb_drv_init(void)
397 
{
398 
    unsigned int i;
399 
    for (i = 0; i < sizeof(endpoints)/sizeof(struct ep_type); i++)
400 
        wakeup_init(&endpoints[i].complete);
401 
 
402 
    /* Enable USB clock */
87 theseven 403 
    clockgate_enable(CLOCKGATE_USB_1, true);
404 
    clockgate_enable(CLOCKGATE_USB_2, true);
15 theseven 405 
    PCGCCTL = 0;
406 
 
407 
    /* unmask irq */
85 theseven 408 
    interrupt_enable(IRQ_USB_FUNC, true);
15 theseven 409 
 
221 theseven 410 
    thread_create("synopsysotg", usb_check_vbus, synopsysotg_stack,
411 
                  sizeof(synopsysotg_stack), OS_THREAD, 63, true);
412 
 
413 
    usb_drv_power_down();
15 theseven 414 
}
28 theseven 415 
 
240 theseven 416 
void usb_drv_exit(void)
417 
{
418 
    usb_drv_power_down();
419 
}
420 
 
28 theseven 421 
int usb_drv_get_max_out_size()
422 
{
423 
    return usb_drv_port_speed() ? 262144 : 32768;
424 
}
425 
 
426 
int usb_drv_get_max_in_size()
427 
{
428 
    return usb_drv_port_speed() ? 262144 : 32768;
429 
}