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



{
    dbgenabled = false;
    dbgstate = DBGSTATE_IDLE;
}
 
bool usbdebug_handle_data(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    union usb_endpoint_number ep0in = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };
    union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };
    uint32_t* buf = (uint32_t*)data->buffer->raw;
    usb_ep0_start_rx(dbgusb, false, 0, NULL);
    switch (dbgstate)
    {
    case DBGSTATE_SETUP:
        switch (buf[0])
        {

            memcpy(dbgmemaddr, &buf[4], len);
            if (dbgmemlen)
            {
                dbgmemaddr += len;
                dbgstate = DBGSTATE_WRITE_MEM;
                usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);
                return true;
            }
            dbgbuf[0] = 1;
            break;
        }
        case 10:  // READ CONSOLE
            dbgmemaddr = (void*)buf[1];
            dbgstate = DBGSTATE_READ_CONSOLE;
            usb_set_stall(dbgusb, ep0out, true);
            usb_ep0_start_tx(dbgusb, NULL, 0, NULL);
            return true;
            break;
        case 11:  // WRITE CONSOLE
        {
            int total = 0;

            dbgbuf[2] = sizeof(dbgconrecvbuf);
            if (total > 48)
            {
                dbgmemlen = total - 48;
                dbgstate = DBGSTATE_WRITE_CONSOLE;
                usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);
                return true;
            }
            dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;
            break;
        }

        dbgmemlen -= len;
        memcpy(dbgmemaddr, buf, len);
        if (dbgmemlen && !bytesleft)
        {
            dbgmemaddr += len;
            usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);
            return true;
        }
        dbgbuf[0] = 1;
        break;
    }

            if (writebytes) memcpy(&dbgconrecvbuf[dbgconrecvwriteidx], readptr, writebytes);
            dbgconrecvwriteidx += writebytes;
            wakeup_signal(&dbgconrecvwakeup);
            if (dbgmemlen && !bytesleft)
            {
                usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);
                return true;
            }
        }
        dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;
        if (dbgbuf[3] < 0) dbgbuf[3] += sizeof(dbgconrecvbuf);
    }
    default: break;
    }
    dbgstate = DBGSTATE_RESPOND;
    usb_set_stall(dbgusb, ep0out, true);
    usb_ep0_start_tx(dbgusb, NULL, 0, NULL);
    return true;
}
 
bool read_console_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)
{
    if (bytesleft || !dbgmemaddr)
    {
        usb_ep0_start_rx(dbgusb, true, 0, usb_ep0_ack_callback);
        if (!dbgmemaddr) usb_ep0_start_tx(dbgusb, NULL, 0, usb_ep0_short_tx_callback);
        dbgusb->state->ep0_tx_ptr = NULL;
        return false;
    }
    dbgconsoleattached = true;
    int bytes = MIN(64, dbgmemlen);
    if (bytes)
    {
        int readbytes = bytes;

    }
    bytes = MIN(64, (int)dbgmemaddr);
    dbgmemaddr -= bytes;
    if (dbgmemaddr)
    {
        usb_ep0_start_tx(dbgusb, dbgbuf, bytes,
                         bytes < 64 ? usb_ep0_short_tx_callback : read_console_callback);
    }
    else usb_ep0_start_tx(dbgusb, dbgbuf, bytes, NULL);
    return true;
}
 
int usbdebug_handle_setup(const struct usb_instance* data, int interface, union usb_ep0_buffer* request, const void** response)
{
    int size = -1;
    union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };
    switch (request->setup.bmRequestType.type)
    {
    case USB_SETUP_BMREQUESTTYPE_TYPE_VENDOR:
        switch (request->setup.bRequest.raw)
        {

            switch (data->buffer->setup.bmRequestType.direction)
            {
            case USB_SETUP_BMREQUESTTYPE_DIRECTION_OUT:
                dbgstate = DBGSTATE_SETUP;
                dbgmemlen = 0;
                usb_ep0_start_rx(dbgusb, true, 64, usbdebug_handle_data);
                return -3;
            case USB_SETUP_BMREQUESTTYPE_DIRECTION_IN:
                switch (dbgstate)
                {
                case DBGSTATE_RESPOND:
                {
                    dbgmemlen = MIN(dbgmemlen, data->buffer->setup.wLength - 16);
                    int len = MIN(48, dbgmemlen);
                    if (len) memcpy(&dbgbuf[4], dbgmemaddr, len);
                    dbgmemlen -= len;
                    if (dbgmemlen)
                    {
                        usb_ep0_start_rx(dbgusb, false, 0, NULL);
                        dbgusb->state->ep0_tx_ptr = dbgmemaddr + 48;
                        dbgusb->state->ep0_tx_len = dbgmemlen;
                        usb_ep0_start_tx(dbgusb, dbgbuf, len + 16,
                                         len < 48 ? usb_ep0_short_tx_callback : usb_ep0_tx_callback);
                        return -3;
                    }
                    dbgstate = DBGSTATE_IDLE;
                    *response = dbgbuf;
                    return len + 16;
                }
                case DBGSTATE_READ_CONSOLE:
                {
                    dbgmemaddr = (void*)MIN((int)dbgmemaddr, data->buffer->setup.wLength - 16);
                    dbgconsoleattached = true;
                    dbgmemlen = dbgconsendwriteidx - dbgconsendreadidx;
                    if (dbgmemlen < 0) dbgmemlen += sizeof(dbgconsendbuf);
                    int used = dbgmemlen;
                    if (dbgmemlen > (int)dbgmemaddr) dbgmemlen = (int)dbgmemaddr;

                    dbgmemlen -= bytes;
                    bytes = MIN(48, (int)dbgmemaddr);
                    dbgmemaddr -= bytes;
                    if (dbgmemaddr)
                    {
                        dbgusb->state->ep0_tx_ptr = (void*)true;
                        usb_ep0_start_rx(dbgusb, false, 0, NULL);
                        usb_ep0_start_tx(dbgusb, dbgbuf, bytes + 16,
                                         bytes < 48 ? usb_ep0_short_tx_callback : read_console_callback);
                        return -3;
                    }
                    dbgstate = DBGSTATE_IDLE;
                    *response = dbgbuf;
                    return bytes + 16;

                    break;
            }
            mode = enter_critical_section();
            if (dbgstate == DBGSTATE_ASYNC)
            {
                usb_ep0_start_tx(dbgusb, NULL, 0, NULL);
                dbgstate = DBGSTATE_RESPOND;
                dbgmemaddr = addr;
                dbgmemlen = len;
                memcpy(dbgbuf, buf, 16);
            }

Rev 933	Rev 944
Line 108...	Line 108...
108	`{`	108	`{`
109	`dbgenabled = false;`	109	`dbgenabled = false;`
110	`dbgstate = DBGSTATE_IDLE;`	110	`dbgstate = DBGSTATE_IDLE;`
111	`}`	111	`}`
112		112
113	`bool usbdebug_handle_data(const struct usb_instance* data, int bytesleft)`	113	`bool usbdebug_handle_data(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
114	`{`	114	`{`
-		115	`union usb_endpoint_number ep0in = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_IN };`
-		116	`union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };`
115	`uint32_t* buf = (uint32_t*)data->buffer->raw;`	117	`uint32_t* buf = (uint32_t*)data->buffer->raw;`
116	`usb_ep0_start_rx(dbgusb, 0, NULL);`	118	`usb_ep0_start_rx(dbgusb, false, 0, NULL);`
117	`switch (dbgstate)`	119	`switch (dbgstate)`
118	`{`	120	`{`
119	`case DBGSTATE_SETUP:`	121	`case DBGSTATE_SETUP:`
120	`switch (buf[0])`	122	`switch (buf[0])`
121	`{`	123	`{`
Line 150...	Line 152...
150	`memcpy(dbgmemaddr, &buf[4], len);`	152	`memcpy(dbgmemaddr, &buf[4], len);`
151	`if (dbgmemlen)`	153	`if (dbgmemlen)`
152	`{`	154	`{`
153	`dbgmemaddr += len;`	155	`dbgmemaddr += len;`
154	`dbgstate = DBGSTATE_WRITE_MEM;`	156	`dbgstate = DBGSTATE_WRITE_MEM;`
155	`usb_ep0_start_rx(dbgusb, 1, usbdebug_handle_data);`	157	`usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);`
156	`return true;`	158	`return true;`
157	`}`	159	`}`
158	`dbgbuf[0] = 1;`	160	`dbgbuf[0] = 1;`
159	`break;`	161	`break;`
160	`}`	162	`}`
161	`case 10: // READ CONSOLE`	163	`case 10: // READ CONSOLE`
162	`dbgmemaddr = (void*)buf[1];`	164	`dbgmemaddr = (void*)buf[1];`
163	`dbgstate = DBGSTATE_READ_CONSOLE;`	165	`dbgstate = DBGSTATE_READ_CONSOLE;`
-		166	`usb_set_stall(dbgusb, ep0out, true);`
164	`usb_ep0_start_tx(dbgusb, NULL, 0, true, NULL);`	167	`usb_ep0_start_tx(dbgusb, NULL, 0, NULL);`
165	`return true;`	168	`return true;`
166	`break;`	169	`break;`
167	`case 11: // WRITE CONSOLE`	170	`case 11: // WRITE CONSOLE`
168	`{`	171	`{`
169	`int total = 0;`	172	`int total = 0;`
Line 193...	Line 196...
193	`dbgbuf[2] = sizeof(dbgconrecvbuf);`	196	`dbgbuf[2] = sizeof(dbgconrecvbuf);`
194	`if (total > 48)`	197	`if (total > 48)`
195	`{`	198	`{`
196	`dbgmemlen = total - 48;`	199	`dbgmemlen = total - 48;`
197	`dbgstate = DBGSTATE_WRITE_CONSOLE;`	200	`dbgstate = DBGSTATE_WRITE_CONSOLE;`
198	`usb_ep0_start_rx(dbgusb, 1, usbdebug_handle_data);`	201	`usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);`
199	`return true;`	202	`return true;`
200	`}`	203	`}`
201	`dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;`	204	`dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;`
202	`break;`	205	`break;`
203	`}`	206	`}`
Line 263...	Line 266...
263	`dbgmemlen -= len;`	266	`dbgmemlen -= len;`
264	`memcpy(dbgmemaddr, buf, len);`	267	`memcpy(dbgmemaddr, buf, len);`
265	`if (dbgmemlen && !bytesleft)`	268	`if (dbgmemlen && !bytesleft)`
266	`{`	269	`{`
267	`dbgmemaddr += len;`	270	`dbgmemaddr += len;`
268	`usb_ep0_start_rx(dbgusb, 1, usbdebug_handle_data);`	271	`usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);`
269	`return true;`	272	`return true;`
270	`}`	273	`}`
271	`dbgbuf[0] = 1;`	274	`dbgbuf[0] = 1;`
272	`break;`	275	`break;`
273	`}`	276	`}`
Line 290...	Line 293...
290	`if (writebytes) memcpy(&dbgconrecvbuf[dbgconrecvwriteidx], readptr, writebytes);`	293	`if (writebytes) memcpy(&dbgconrecvbuf[dbgconrecvwriteidx], readptr, writebytes);`
291	`dbgconrecvwriteidx += writebytes;`	294	`dbgconrecvwriteidx += writebytes;`
292	`wakeup_signal(&dbgconrecvwakeup);`	295	`wakeup_signal(&dbgconrecvwakeup);`
293	`if (dbgmemlen && !bytesleft)`	296	`if (dbgmemlen && !bytesleft)`
294	`{`	297	`{`
295	`usb_ep0_start_rx(dbgusb, 1, usbdebug_handle_data);`	298	`usb_ep0_start_rx(dbgusb, true, MIN(64, dbgmemlen), usbdebug_handle_data);`
296	`return true;`	299	`return true;`
297	`}`	300	`}`
298	`}`	301	`}`
299	`dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;`	302	`dbgbuf[3] = dbgconrecvreadidx - dbgconrecvwriteidx - 1;`
300	`if (dbgbuf[3] < 0) dbgbuf[3] += sizeof(dbgconrecvbuf);`	303	`if (dbgbuf[3] < 0) dbgbuf[3] += sizeof(dbgconrecvbuf);`
301	`}`	304	`}`
302	`default: break;`	305	`default: break;`
303	`}`	306	`}`
304	`dbgstate = DBGSTATE_RESPOND;`	307	`dbgstate = DBGSTATE_RESPOND;`
-		308	`usb_set_stall(dbgusb, ep0out, true);`
305	`usb_ep0_start_tx(dbgusb, NULL, 0, true, NULL);`	309	`usb_ep0_start_tx(dbgusb, NULL, 0, NULL);`
306	`return true;`	310	`return true;`
307	`}`	311	`}`
308		312
309	`bool read_console_callback(const struct usb_instance* data, int bytesleft)`	313	`bool read_console_callback(const struct usb_instance* data, union usb_endpoint_number epnum, int bytesleft)`
310	`{`	314	`{`
311	`if (bytesleft \|\| !dbgmemaddr) return false;`	315	`if (bytesleft \|\| !dbgmemaddr)`
-		316	`{`
-		317	`usb_ep0_start_rx(dbgusb, true, 0, usb_ep0_ack_callback);`
-		318	`if (!dbgmemaddr) usb_ep0_start_tx(dbgusb, NULL, 0, usb_ep0_short_tx_callback);`
-		319	`dbgusb->state->ep0_tx_ptr = NULL;`
-		320	`return false;`
-		321	`}`
312	`dbgconsoleattached = true;`	322	`dbgconsoleattached = true;`
313	`int bytes = MIN(64, dbgmemlen);`	323	`int bytes = MIN(64, dbgmemlen);`
314	`if (bytes)`	324	`if (bytes)`
315	`{`	325	`{`
316	`int readbytes = bytes;`	326	`int readbytes = bytes;`
Line 330...	Line 340...
330	`}`	340	`}`
331	`bytes = MIN(64, (int)dbgmemaddr);`	341	`bytes = MIN(64, (int)dbgmemaddr);`
332	`dbgmemaddr -= bytes;`	342	`dbgmemaddr -= bytes;`
333	`if (dbgmemaddr)`	343	`if (dbgmemaddr)`
334	`{`	344	`{`
335	`usb_ep0_start_rx(dbgusb, 0, NULL);`	345	`usb_ep0_start_tx(dbgusb, dbgbuf, bytes,`
336	`usb_ep0_start_tx(dbgusb, dbgbuf, bytes, false, read_console_callback);`	346	`bytes < 64 ? usb_ep0_short_tx_callback : read_console_callback);`
337	`}`	347	`}`
338	`else usb_ep0_start_tx(dbgusb, dbgbuf, bytes, true, NULL);`	348	`else usb_ep0_start_tx(dbgusb, dbgbuf, bytes, NULL);`
339	`return true;`	349	`return true;`
340	`}`	350	`}`
341		351
342	`int usbdebug_handle_setup(const struct usb_instance* data, int interface, union usb_ep0_buffer* request, const void** response)`	352	`int usbdebug_handle_setup(const struct usb_instance* data, int interface, union usb_ep0_buffer* request, const void** response)`
343	`{`	353	`{`
344	`int size = -1;`	354	`int size = -1;`
-		355	`union usb_endpoint_number ep0out = { .number = 0, .direction = USB_ENDPOINT_DIRECTION_OUT };`
345	`switch (request->setup.bmRequestType.type)`	356	`switch (request->setup.bmRequestType.type)`
346	`{`	357	`{`
347	`case USB_SETUP_BMREQUESTTYPE_TYPE_VENDOR:`	358	`case USB_SETUP_BMREQUESTTYPE_TYPE_VENDOR:`
348	`switch (request->setup.bRequest.raw)`	359	`switch (request->setup.bRequest.raw)`
349	`{`	360	`{`
Line 351...	Line 362...
351	`switch (data->buffer->setup.bmRequestType.direction)`	362	`switch (data->buffer->setup.bmRequestType.direction)`
352	`{`	363	`{`
353	`case USB_SETUP_BMREQUESTTYPE_DIRECTION_OUT:`	364	`case USB_SETUP_BMREQUESTTYPE_DIRECTION_OUT:`
354	`dbgstate = DBGSTATE_SETUP;`	365	`dbgstate = DBGSTATE_SETUP;`
355	`dbgmemlen = 0;`	366	`dbgmemlen = 0;`
356	`usb_ep0_start_rx(dbgusb, 1, usbdebug_handle_data);`	367	`usb_ep0_start_rx(dbgusb, true, 64, usbdebug_handle_data);`
357	`return -3;`	368	`return -3;`
358	`case USB_SETUP_BMREQUESTTYPE_DIRECTION_IN:`	369	`case USB_SETUP_BMREQUESTTYPE_DIRECTION_IN:`
359	`switch (dbgstate)`	370	`switch (dbgstate)`
360	`{`	371	`{`
361	`case DBGSTATE_RESPOND:`	372	`case DBGSTATE_RESPOND:`
362	`{`	373	`{`
-		374	`dbgmemlen = MIN(dbgmemlen, data->buffer->setup.wLength - 16);`
363	`int len = MIN(48, dbgmemlen);`	375	`int len = MIN(48, dbgmemlen);`
364	`if (len) memcpy(&dbgbuf[4], dbgmemaddr, len);`	376	`if (len) memcpy(&dbgbuf[4], dbgmemaddr, len);`
365	`dbgmemlen -= len;`	377	`dbgmemlen -= len;`
366	`if (dbgmemlen)`	378	`if (dbgmemlen)`
367	`{`	379	`{`
368	`usb_ep0_start_rx(dbgusb, 0, NULL);`	380	`usb_ep0_start_rx(dbgusb, false, 0, NULL);`
369	`data->state->ep0_tx_ptr = dbgmemaddr - 16;`	381	`dbgusb->state->ep0_tx_ptr = dbgmemaddr + 48;`
370	`data->state->ep0_tx_len = dbgmemlen;`	382	`dbgusb->state->ep0_tx_len = dbgmemlen;`
371	`usb_ep0_start_tx(dbgusb, dbgbuf, len + 16, false, usb_ep0_tx_callback);`	383	`usb_ep0_start_tx(dbgusb, dbgbuf, len + 16,`
-		384	`len < 48 ? usb_ep0_short_tx_callback : usb_ep0_tx_callback);`
372	`return -3;`	385	`return -3;`
373	`}`	386	`}`
374	`dbgstate = DBGSTATE_IDLE;`	387	`dbgstate = DBGSTATE_IDLE;`
375	`*response = dbgbuf;`	388	`*response = dbgbuf;`
376	`return len + 16;`	389	`return len + 16;`
377	`}`	390	`}`
378	`case DBGSTATE_READ_CONSOLE:`	391	`case DBGSTATE_READ_CONSOLE:`
379	`{`	392	`{`
-		393	`dbgmemaddr = (void*)MIN((int)dbgmemaddr, data->buffer->setup.wLength - 16);`
380	`dbgconsoleattached = true;`	394	`dbgconsoleattached = true;`
381	`dbgmemlen = dbgconsendwriteidx - dbgconsendreadidx;`	395	`dbgmemlen = dbgconsendwriteidx - dbgconsendreadidx;`
382	`if (dbgmemlen < 0) dbgmemlen += sizeof(dbgconsendbuf);`	396	`if (dbgmemlen < 0) dbgmemlen += sizeof(dbgconsendbuf);`
383	`int used = dbgmemlen;`	397	`int used = dbgmemlen;`
384	`if (dbgmemlen > (int)dbgmemaddr) dbgmemlen = (int)dbgmemaddr;`	398	`if (dbgmemlen > (int)dbgmemaddr) dbgmemlen = (int)dbgmemaddr;`
Line 406...	Line 420...
406	`dbgmemlen -= bytes;`	420	`dbgmemlen -= bytes;`
407	`bytes = MIN(48, (int)dbgmemaddr);`	421	`bytes = MIN(48, (int)dbgmemaddr);`
408	`dbgmemaddr -= bytes;`	422	`dbgmemaddr -= bytes;`
409	`if (dbgmemaddr)`	423	`if (dbgmemaddr)`
410	`{`	424	`{`
-		425	`dbgusb->state->ep0_tx_ptr = (void*)true;`
411	`usb_ep0_start_rx(dbgusb, 0, NULL);`	426	`usb_ep0_start_rx(dbgusb, false, 0, NULL);`
412	`usb_ep0_start_tx(dbgusb, dbgbuf, bytes + 16, false, read_console_callback);`	427	`usb_ep0_start_tx(dbgusb, dbgbuf, bytes + 16,`
-		428	`bytes < 48 ? usb_ep0_short_tx_callback : read_console_callback);`
413	`return -3;`	429	`return -3;`
414	`}`	430	`}`
415	`dbgstate = DBGSTATE_IDLE;`	431	`dbgstate = DBGSTATE_IDLE;`
416	`*response = dbgbuf;`	432	`*response = dbgbuf;`
417	`return bytes + 16;`	433	`return bytes + 16;`
Line 706...	Line 722...
706	`break;`	722	`break;`
707	`}`	723	`}`
708	`mode = enter_critical_section();`	724	`mode = enter_critical_section();`
709	`if (dbgstate == DBGSTATE_ASYNC)`	725	`if (dbgstate == DBGSTATE_ASYNC)`
710	`{`	726	`{`
711	`usb_ep0_start_tx(dbgusb, NULL, 0, true, NULL);`	727	`usb_ep0_start_tx(dbgusb, NULL, 0, NULL);`
712	`dbgstate = DBGSTATE_RESPOND;`	728	`dbgstate = DBGSTATE_RESPOND;`
713	`dbgmemaddr = addr;`	729	`dbgmemaddr = addr;`
714	`dbgmemlen = len;`	730	`dbgmemlen = len;`
715	`memcpy(dbgbuf, buf, 16);`	731	`memcpy(dbgbuf, buf, 16);`
716	`}`	732	`}`

Subversion Repositories freemyipod

(root)/emcore/trunk/usb/usbdebug.c @ 944 – Rev 933 → 944