WebSVN – freemyipod – Diff – /emcore/trunk/usb/usb.c



void usb_start_tx(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size)
{
    data->driver->start_tx(data, ep, buf, size);
}
 
void usb_set_stall(const struct usb_instance* data, union usb_endpoint_number ep, bool stall)
{
    data->driver->set_stall(data, ep, stall);
}
 
void usb_ep0_start_rx(const struct usb_instance* data, bool non_setup, int len, bool (*callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft))
{
    data->state->ep0_rx_callback = callback;
    data->driver->ep0_start_rx(data, non_setup, len);
}
 
bool usb_ep0_ack_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    // This function is intended to eat zero-byte ACK packets,
    // which are always the last packet of a transaction.
    // At this point we can STALL all further packets.
    union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };
    usb_set_stall(data, ep, true);
    ep.direction = USB_ENDPOINT_DIRECTION_IN;
    usb_set_stall(data, ep, true);
    // If this is an IN endpoint, something else must already be
    // waiting for a SETUP packet anyway, or there could be deadlocks.
    if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT) usb_ep0_start_rx(data, false, 0, NULL);
    return true;
}
 
void usb_ep0_start_tx(const struct usb_instance* data, const void* buf, int len, bool (*callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft))
{
 
 
 
    if (((uint32_t)buf) & (CACHEALIGN_SIZE - 1))
    {
        memcpy(data->buffer->raw, buf, len);
        buf = data->buffer->raw;
    }
 
    data->state->ep0_tx_callback = callback;
    data->driver->ep0_start_tx(data, buf, len);
}
 
bool usb_ep0_short_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    // No more data to be sent after a short packet. STALL IN.
    union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };
    usb_set_stall(data, ep, true);
    // If this was the last regular packet, but a short one, expect zero-length ACK.
    // Otherwise usb_ep0_tx_callback will have taken care of that already.
    if (data->state->ep0_tx_ptr) usb_ep0_start_rx(data, true, 0, usb_ep0_ack_callback);
    return false;
}
 
bool usb_ep0_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    if (bytesleft || !data->state->ep0_tx_len)
    {
        // This was the last packet. Expect zero-length ACK.
        usb_ep0_start_rx(data, true, 0, usb_ep0_ack_callback);
        // If someone might expect to receive more data, send a zero-byte packet.
        if (!data->state->ep0_tx_len) usb_ep0_start_tx(data, NULL, 0, usb_ep0_short_tx_callback);
        // Abuse this as a marker for usb_ep0_short_tx_callback...
        data->state->ep0_tx_ptr = NULL;
        return false;
    }
    
    int len = MIN(64, data->state->ep0_tx_len);
 
    data->state->ep0_tx_len -= len;
    usb_ep0_start_tx(data, data->state->ep0_tx_ptr, len,
                     len < 64 ? usb_ep0_short_tx_callback : usb_ep0_tx_callback);
    data->state->ep0_tx_ptr += 64;
    return true;
}
 
void usb_unconfigure_ep(const struct usb_instance* data, union usb_endpoint_number ep)
{

}
 
static void usb_handle_ep0_setup(const struct usb_instance* data, union usb_ep0_buffer* buffer)
{
    // size < -2: do nothing at all (dangerous, you need to take care of priming EP0 yourself!)
    //            (this case is required for requests that have an OUT data stage)
    // size == -2: send STALL
    // size == -1: try to run default handler, or send STALL if none exists
    // size == 0: send ACK
    // size > 0: send <size> bytes at <addr>, then expect ACK
    const void* addr = data->buffer;

                    addr = data->buffer;
                    size = 2;
                    break;
                case USB_SETUP_BREQUEST_CLEAR_FEATURE:
                    if (buffer->setup.wLength || buffer->setup.wValue) break;
                    usb_set_stall(data, ep, false);
                    size = 0;
                    break;
                case USB_SETUP_BREQUEST_SET_FEATURE:
                    if (buffer->setup.wLength || buffer->setup.wValue) break;
                    usb_set_stall(data, ep, true);
                    size = 0;
                    break;
                default: break;
                }
                break;

            break;
        }
        default: break;
    }
    }
    union usb_endpoint_number ep0in = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };
    union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };
    // See comment at the top of this function for meanings of size.
    if (size == 0)
    {
        // Send ACK. Stall OUT pipe. Accept SETUP packets though.
        usb_set_stall(data, ep0out, true);
        usb_ep0_start_rx(data, false, 0, NULL);
        usb_ep0_start_tx(data, NULL, 0, usb_ep0_ack_callback);
    }
    else if (size > 0)
    {
        // Send a data stage. Expect to receive only SETUP until we're done. NAK everything else.
        usb_ep0_start_rx(data, false, 0, NULL);
 
        data->state->ep0_tx_ptr = addr;
        data->state->ep0_tx_len = size;
        usb_ep0_tx_callback(data, ep0in, 0);  // A convenient way to start a transfer.
    }
    else if (size >= -2)
    {
        // We have no handler, or the handler failed. STALL everything, accept only SETUP packets.
        usb_set_stall(data, ep0in, true);
        usb_set_stall(data, ep0out, true);
        usb_ep0_start_rx(data, false, 0, NULL);
    }
}
 
void usb_handle_bus_reset(const struct usb_instance* data, int highspeed)
{

            if (interface->bus_reset) interface->bus_reset(data, c, i, highspeed);
        }
    }
 
    // Prime EP0 for the first setup packet.
    usb_ep0_start_rx(data, false, 0, NULL);
}
 
void usb_handle_timeout(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    // If the host doesn't fetch an EP0 IN packet, we can't do much about it.

 
void usb_handle_xfer_complete(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    if (!epnum.number)
    {
        bool (*callback)(const struct usb_instance* data, union usb_endpoint_number epnum, int size);
        if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT)
        {
            callback = data->state->ep0_rx_callback;
            data->state->ep0_rx_callback = NULL;
        }
        else
        {
            callback = data->state->ep0_tx_callback;
            data->state->ep0_tx_callback = NULL;
        }
        if (callback) callback(data, epnum, bytesleft);
    }
    else
    {
        int epidx;
        int ifidx;

Rev 891	Rev 944
Line 10...	Line 10...
10	`void usb_start_tx(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size)`	10	`void usb_start_tx(const struct usb_instance* data, union usb_endpoint_number ep, const void* buf, int size)`
11	`{`	11	`{`
12	`data->driver->start_tx(data, ep, buf, size);`	12	`data->driver->start_tx(data, ep, buf, size);`
13	`}`	13	`}`
14		14
15	`void usb_set_stall(const struct usb_instance* data, union usb_endpoint_number ep, int stall)`	15	`void usb_set_stall(const struct usb_instance* data, union usb_endpoint_number ep, bool stall)`
16	`{`	16	`{`
17	`data->driver->set_stall(data, ep, stall);`	17	`data->driver->set_stall(data, ep, stall);`
18	`}`	18	`}`
19		19
20	`void usb_ep0_start_rx(const struct usb_instance* data, int non_setup, bool (callback)(const struct usb_instance data, int bytesleft))`	20	`void usb_ep0_start_rx(const struct usb_instance* data, bool non_setup, int len, bool (callback)(const struct usb_instance data, union usb_endpoint_number epnum, int bytesleft))`
21	`{`	21	`{`
22	`data->state->ep0_rx_callback = callback;`	22	`data->state->ep0_rx_callback = callback;`
23	`data->driver->ep0_start_rx(data, non_setup);`	23	`data->driver->ep0_start_rx(data, non_setup, len);`
24	`}`	24	`}`
25		25
26	`bool usb_ep0_rx_callback(const struct usb_instance* data, int bytesleft)`	26	`bool usb_ep0_ack_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
27	`{`	27	`{`
-		28	`// This function is intended to eat zero-byte ACK packets,`
-		29	`// which are always the last packet of a transaction.`
-		30	`// At this point we can STALL all further packets.`
-		31	`union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };`
28	`usb_ep0_start_rx(data, 0, NULL);`	32	`usb_set_stall(data, ep, true);`
-		33	`ep.direction = USB_ENDPOINT_DIRECTION_IN;`
-		34	`usb_set_stall(data, ep, true);`
-		35	`// If this is an IN endpoint, something else must already be`
-		36	`// waiting for a SETUP packet anyway, or there could be deadlocks.`
-		37	`if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT) usb_ep0_start_rx(data, false, 0, NULL);`
29	`return true;`	38	`return true;`
30	`}`	39	`}`
31		40
32	`void usb_ep0_start_tx(const struct usb_instance* data, const void* buf, int len, bool last, bool (callback)(const struct usb_instance data, int bytesleft))`	41	`void usb_ep0_start_tx(const struct usb_instance* data, const void* buf, int len, bool (callback)(const struct usb_instance data, union usb_endpoint_number epnum, int bytesleft))`
33	`{`	42	`{`
34	`// Expect zero-length ACK if we are about to actually send data, otherwise expect SETUP.`	-
35	`if (last) usb_ep0_start_rx(data, !!len, usb_ep0_rx_callback);`	-
36		-
37	`if (((uint32_t)buf) & (CACHEALIGN_SIZE - 1))`	43	`if (((uint32_t)buf) & (CACHEALIGN_SIZE - 1))`
38	`{`	44	`{`
39	`memcpy(data->buffer->raw, buf, len);`	45	`memcpy(data->buffer->raw, buf, len);`
40	`buf = data->buffer->raw;`	46	`buf = data->buffer->raw;`
41	`}`	47	`}`
42		48
43	`data->state->ep0_tx_callback = callback;`	49	`data->state->ep0_tx_callback = callback;`
44	`data->driver->ep0_start_tx(data, buf, len);`	50	`data->driver->ep0_start_tx(data, buf, len);`
45	`}`	51	`}`
46		52
47	`bool usb_ep0_tx_callback(const struct usb_instance* data, int bytesleft)`	53	`bool usb_ep0_short_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
48	`{`	54	`{`
-		55	`// No more data to be sent after a short packet. STALL IN.`
-		56	`union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };`
-		57	`usb_set_stall(data, ep, true);`
-		58	`// If this was the last regular packet, but a short one, expect zero-length ACK.`
-		59	`// Otherwise usb_ep0_tx_callback will have taken care of that already.`
-		60	`if (data->state->ep0_tx_ptr) usb_ep0_start_rx(data, true, 0, usb_ep0_ack_callback);`
-		61	`return false;`
-		62	`}`
-		63
-		64	`bool usb_ep0_tx_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
-		65	`{`
49	`if (bytesleft \|\| !data->state->ep0_tx_len) return false;`	66	`if (bytesleft \|\| !data->state->ep0_tx_len)`
-		67	`{`
-		68	`// This was the last packet. Expect zero-length ACK.`
-		69	`usb_ep0_start_rx(data, true, 0, usb_ep0_ack_callback);`
-		70	`// If someone might expect to receive more data, send a zero-byte packet.`
-		71	`if (!data->state->ep0_tx_len) usb_ep0_start_tx(data, NULL, 0, usb_ep0_short_tx_callback);`
-		72	`// Abuse this as a marker for usb_ep0_short_tx_callback...`
-		73	`data->state->ep0_tx_ptr = NULL;`
-		74	`return false;`
-		75	`}`
-		76
50	`int len = MIN(64, data->state->ep0_tx_len);`	77	`int len = MIN(64, data->state->ep0_tx_len);`
51	`data->state->ep0_tx_ptr += 64;`	-
52	`data->state->ep0_tx_len -= len;`	78	`data->state->ep0_tx_len -= len;`
53	`usb_ep0_start_tx(data, data->state->ep0_tx_ptr, len, !data->state->ep0_tx_len, usb_ep0_tx_callback);`	79	`usb_ep0_start_tx(data, data->state->ep0_tx_ptr, len,`
-		80	`len < 64 ? usb_ep0_short_tx_callback : usb_ep0_tx_callback);`
-		81	`data->state->ep0_tx_ptr += 64;`
54	`return true;`	82	`return true;`
55	`}`	83	`}`
56		84
57	`void usb_unconfigure_ep(const struct usb_instance* data, union usb_endpoint_number ep)`	85	`void usb_unconfigure_ep(const struct usb_instance* data, union usb_endpoint_number ep)`
58	`{`	86	`{`
Line 117...	Line 145...
117	`}`	145	`}`
118		146
119	`static void usb_handle_ep0_setup(const struct usb_instance* data, union usb_ep0_buffer* buffer)`	147	`static void usb_handle_ep0_setup(const struct usb_instance* data, union usb_ep0_buffer* buffer)`
120	`{`	148	`{`
121	`// size < -2: do nothing at all (dangerous, you need to take care of priming EP0 yourself!)`	149	`// size < -2: do nothing at all (dangerous, you need to take care of priming EP0 yourself!)`
-		150	`// (this case is required for requests that have an OUT data stage)`
122	`// size == -2: send STALL`	151	`// size == -2: send STALL`
123	`// size == -1: try to run default handler, or send STALL if none exists`	152	`// size == -1: try to run default handler, or send STALL if none exists`
124	`// size == 0: send ACK`	153	`// size == 0: send ACK`
125	`// size > 0: send <size> bytes at <addr>, then expect ACK`	154	`// size > 0: send <size> bytes at <addr>, then expect ACK`
126	`const void* addr = data->buffer;`	155	`const void* addr = data->buffer;`
Line 273...	Line 302...
273	`addr = data->buffer;`	302	`addr = data->buffer;`
274	`size = 2;`	303	`size = 2;`
275	`break;`	304	`break;`
276	`case USB_SETUP_BREQUEST_CLEAR_FEATURE:`	305	`case USB_SETUP_BREQUEST_CLEAR_FEATURE:`
277	`if (buffer->setup.wLength \|\| buffer->setup.wValue) break;`	306	`if (buffer->setup.wLength \|\| buffer->setup.wValue) break;`
278	`data->driver->set_stall(data, ep, false);`	307	`usb_set_stall(data, ep, false);`
279	`size = 0;`	308	`size = 0;`
280	`break;`	309	`break;`
281	`case USB_SETUP_BREQUEST_SET_FEATURE:`	310	`case USB_SETUP_BREQUEST_SET_FEATURE:`
282	`if (buffer->setup.wLength \|\| buffer->setup.wValue) break;`	311	`if (buffer->setup.wLength \|\| buffer->setup.wValue) break;`
283	`data->driver->set_stall(data, ep, true);`	312	`usb_set_stall(data, ep, true);`
284	`size = 0;`	313	`size = 0;`
285	`break;`	314	`break;`
286	`default: break;`	315	`default: break;`
287	`}`	316	`}`
288	`break;`	317	`break;`
Line 291...	Line 320...
291	`break;`	320	`break;`
292	`}`	321	`}`
293	`default: break;`	322	`default: break;`
294	`}`	323	`}`
295	`}`	324	`}`
-		325	`union usb_endpoint_number ep0in = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };`
-		326	`union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };`
296	`// See comment at the top of this function`	327	`// See comment at the top of this function for meanings of size.`
-		328	`if (size == 0)`
-		329	`{`
-		330	`// Send ACK. Stall OUT pipe. Accept SETUP packets though.`
-		331	`usb_set_stall(data, ep0out, true);`
297	`if (size == 0) usb_ep0_start_tx(data, NULL, 0, true, NULL);`	332	`usb_ep0_start_rx(data, false, 0, NULL);`
-		333	`usb_ep0_start_tx(data, NULL, 0, usb_ep0_ack_callback);`
-		334	`}`
298	`else if (size > 0)`	335	`else if (size > 0)`
299	`{`	336	`{`
-		337	`// Send a data stage. Expect to receive only SETUP until we're done. NAK everything else.`
300	`usb_ep0_start_rx(data, 0, NULL);`	338	`usb_ep0_start_rx(data, false, 0, NULL);`
301	`int len = MIN(64, size);`	-
302	`data->state->ep0_tx_ptr = addr;`	339	`data->state->ep0_tx_ptr = addr;`
303	`data->state->ep0_tx_len = size - len;`	340	`data->state->ep0_tx_len = size;`
304	`usb_ep0_start_tx(data, addr, len, !data->state->ep0_tx_len, usb_ep0_tx_callback);`	341	`usb_ep0_tx_callback(data, ep0in, 0); // A convenient way to start a transfer.`
305	`}`	342	`}`
306	`else if (size >= -2)`	343	`else if (size >= -2)`
307	`{`	344	`{`
308	`union usb_endpoint_number ep = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };`	345	`// We have no handler, or the handler failed. STALL everything, accept only SETUP packets.`
309	`usb_set_stall(data, ep, 1);`	346	`usb_set_stall(data, ep0in, true);`
310	`ep.direction = USB_ENDPOINT_DIRECTION_OUT;`	347	`usb_set_stall(data, ep0out, true);`
311	`usb_set_stall(data, ep, 1);`	348	`usb_ep0_start_rx(data, false, 0, NULL);`
312	`}`	349	`}`
313	`}`	350	`}`
314		351
315	`void usb_handle_bus_reset(const struct usb_instance* data, int highspeed)`	352	`void usb_handle_bus_reset(const struct usb_instance* data, int highspeed)`
316	`{`	353	`{`
Line 327...	Line 364...
327	`if (interface->bus_reset) interface->bus_reset(data, c, i, highspeed);`	364	`if (interface->bus_reset) interface->bus_reset(data, c, i, highspeed);`
328	`}`	365	`}`
329	`}`	366	`}`
330		367
331	`// Prime EP0 for the first setup packet.`	368	`// Prime EP0 for the first setup packet.`
332	`usb_ep0_start_rx(data, 0, NULL);`	369	`usb_ep0_start_rx(data, false, 0, NULL);`
333	`}`	370	`}`
334		371
335	`void usb_handle_timeout(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`	372	`void usb_handle_timeout(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
336	`{`	373	`{`
337	`// If the host doesn't fetch an EP0 IN packet, we can't do much about it.`	374	`// If the host doesn't fetch an EP0 IN packet, we can't do much about it.`
Line 348...	Line 385...
348		385
349	`void usb_handle_xfer_complete(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`	386	`void usb_handle_xfer_complete(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
350	`{`	387	`{`
351	`if (!epnum.number)`	388	`if (!epnum.number)`
352	`{`	389	`{`
353	`bool (callback)(const struct usb_instance data, int size);`	390	`bool (callback)(const struct usb_instance data, union usb_endpoint_number epnum, int size);`
354	`if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT)`	391	`if (epnum.direction == USB_ENDPOINT_DIRECTION_OUT)`
355	`{`	392	`{`
356	`callback = data->state->ep0_rx_callback;`	393	`callback = data->state->ep0_rx_callback;`
357	`data->state->ep0_rx_callback = NULL;`	394	`data->state->ep0_rx_callback = NULL;`
358	`}`	395	`}`
359	`else`	396	`else`
360	`{`	397	`{`
361	`callback = data->state->ep0_tx_callback;`	398	`callback = data->state->ep0_tx_callback;`
362	`data->state->ep0_tx_callback = NULL;`	399	`data->state->ep0_tx_callback = NULL;`
363	`}`	400	`}`
364	`if (callback) callback(data, bytesleft);`	401	`if (callback) callback(data, epnum, bytesleft);`
365	`}`	402	`}`
366	`else`	403	`else`
367	`{`	404	`{`
368	`int epidx;`	405	`int epidx;`
369	`int ifidx;`	406	`int ifidx;`

Subversion Repositories freemyipod

(root)/emcore/trunk/usb/usb.c @ 947 – Rev 891 → 944