| /*************************************************************************** |
| * __________ __ ___. |
| * Open \______ \ ____ ____ | | _\_ |__ _______ ___ |
| * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / |
| * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
| * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
| * \/ \/ \/ \/ \/ |
| * $Id$ |
| * |
| * Copyright (C) 2006 by Tomasz Malesinski |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| * KIND, either express or implied. |
| * |
| ****************************************************************************/ |
| |
| /* |
| #define LCD_DEBUG |
| #define BUTTONS |
| */ |
| |
| /* #include "config.h" */ |
| #include <stdlib.h> |
| #include "pnx0101.h" |
| #include "ifp_usb_serial.h" |
| |
| #ifdef BUTTONS |
| #include "kernel.h" |
| #include "button.h" |
| #include "system.h" |
| #endif |
| |
| #ifdef LCD_DEBUG |
| #include "lcd.h" |
| #endif |
| |
| |
| #define ISP1582_BASE (0x24100000) |
| #define ISP1582_ADDRESS (*(volatile unsigned char *)ISP1582_BASE) |
| #define ISP1582_MODE (*(volatile unsigned short *)(ISP1582_BASE + 0xc)) |
| #define ISP1582_INTCONF (*(volatile unsigned char *)(ISP1582_BASE + 0x10)) |
| #define ISP1582_OTG (*(volatile unsigned char *)(ISP1582_BASE + 0x12)) |
| #define ISP1582_INTEN (*(volatile unsigned long *)(ISP1582_BASE + 0x14)) |
| |
| #define ISP1582_EPINDEX (*(volatile unsigned char *)(ISP1582_BASE + 0x2c)) |
| #define ISP1582_CTRLFUN (*(volatile unsigned char *)(ISP1582_BASE + 0x28)) |
| #define ISP1582_DATA (*(volatile unsigned short *)(ISP1582_BASE + 0x20)) |
| #define ISP1582_BUFLEN (*(volatile unsigned short *)(ISP1582_BASE + 0x1c)) |
| #define ISP1582_BUFSTAT (*(volatile unsigned char *)(ISP1582_BASE + 0x1e)) |
| #define ISP1582_MAXPKSZ (*(volatile unsigned short *)(ISP1582_BASE + 0x04)) |
| #define ISP1582_EPTYPE (*(volatile unsigned short *)(ISP1582_BASE + 0x08)) |
| |
| #define ISP1582_INT (*(volatile unsigned long *)(ISP1582_BASE + 0x18)) |
| #define ISP1582_CHIPID (*(volatile unsigned long *)(ISP1582_BASE + 0x70)) |
| #define ISP1582_FRAMENO (*(volatile unsigned short *)(ISP1582_BASE + 0x74)) |
| #define ISP1582_UNLOCK (*(volatile unsigned short *)(ISP1582_BASE + 0x7c)) |
| |
| #define ISP1582_UNLOCK_CODE 0xaa37 |
| |
| #define TYPE_BULK 2 |
| |
| #define STATE_DEFAULT 0 |
| #define STATE_ADDRESS 1 |
| #define STATE_CONFIGURED 2 |
| |
| #define N_ENDPOINTS 2 |
| |
| struct usb_endpoint |
| { |
| unsigned char *out_buf; |
| short out_len; |
| short out_ptr; |
| void (*out_done)(int, unsigned char *, int); |
| unsigned char out_in_progress; |
| |
| unsigned char *in_buf; |
| short in_min_len; |
| short in_max_len; |
| short in_ptr; |
| void (*in_done)(int, unsigned char *, int); |
| unsigned char in_ack; |
| |
| unsigned char halt[2]; |
| unsigned char enabled[2]; |
| short max_pkt_size[2]; |
| }; |
| |
| static char usb_connect_state; |
| |
| static struct usb_endpoint endpoints[N_ENDPOINTS]; |
| |
| static unsigned char setup_pkt_buf[8]; |
| static unsigned char setup_out_buf[8]; |
| static unsigned char usb_state; |
| static unsigned char usb_remote_wakeup; |
| |
| #ifdef LCD_DEBUG |
| static unsigned char int_count[32]; |
| |
| static int log_pos_x = 0; |
| static int log_pos_y = 3; |
| #endif |
| |
| static void nop_f(void) |
| { |
| } |
| |
| #ifdef LCD_DEBUG |
| static void log_char(char c) |
| { |
| char s[2]; |
| |
| s[0] = c; |
| s[1] = 0; |
| |
| lcd_puts(log_pos_x, log_pos_y, s); |
| lcd_update(); |
| log_pos_x++; |
| if (log_pos_x >= 16) |
| { |
| log_pos_x = 0; |
| log_pos_y++; |
| if (log_pos_y > 5) |
| log_pos_y = 3; |
| } |
| } |
| #else |
| #define log_char(c) |
| #endif |
| |
| #define SERIAL_BUF_SIZE 1024 |
| |
| struct serial_fifo |
| { |
| unsigned char buf[SERIAL_BUF_SIZE]; |
| short head, tail; |
| }; |
| |
| static struct serial_fifo serial_in_fifo; |
| static struct serial_fifo serial_out_fifo; |
| static unsigned char serial_in_pkt[64]; |
| |
| static unsigned char device_descriptor[18] = { |
| 0x12, /* length */ |
| 0x01, /* descriptor type */ |
| 0x10, 0x01, /* USB version (1.1) */ |
| 0xff, 0xff, /* class and subclass */ |
| 0xff, /* protocol */ |
| 0x40, /* max packet size 0 */ |
| 0x02, 0x41, /* vendor (iRiver) */ |
| 0x07, 0xee, /* product (0xee07) */ |
| 0x01, 0x00, /* device version */ |
| 0x01, /* manufacturer string */ |
| 0x02, /* product string */ |
| 0x00, /* serial number string */ |
| 0x01 /* number of configurations */ |
| }; |
| |
| static unsigned char cfg_descriptor[32] = { |
| 0x09, /* length */ |
| 0x02, /* descriptor type */ |
| 0x20, 0x00, /* total length */ |
| 0x01, /* number of interfaces */ |
| 0x01, /* configuration value */ |
| 0x00, /* configuration string */ |
| 0x80, /* attributes (none) */ |
| 0x32, /* max power (100 mA) */ |
| /* interface descriptor */ |
| 0x09, /* length */ |
| 0x04, /* descriptor type */ |
| 0x00, /* interface number */ |
| 0x00, /* alternate setting */ |
| 0x02, /* number of endpoints */ |
| 0xff, /* interface class */ |
| 0xff, /* interface subclass */ |
| 0xff, /* interface protocol */ |
| 0x00, /* interface string */ |
| /* endpoint IN */ |
| 0x07, /* length */ |
| 0x05, /* descriptor type */ |
| 0x81, /* endpoint 1 IN */ |
| 0x02, /* attributes (bulk) */ |
| 0x40, 0x00, /* max packet size */ |
| 0x00, /* interval */ |
| /* endpoint OUT */ |
| 0x07, /* length */ |
| 0x05, /* descriptor type */ |
| 0x01, /* endpoint 1 IN */ |
| 0x02, /* attributes (bulk) */ |
| 0x40, 0x00, /* max packet size */ |
| 0x00 /* interval */ |
| }; |
| |
| static unsigned char lang_descriptor[4] = { |
| 0x04, /* length */ |
| 0x03, /* descriptor type */ |
| 0x09, 0x04 /* English (US) */ |
| }; |
| |
| #define N_STRING_DESCRIPTORS 2 |
| |
| static unsigned char string_descriptor_vendor[] = { |
| 0x2e, 0x03, |
| 'i', 0, 'R', 0, 'i', 0, 'v', 0, 'e', 0, 'r', 0, ' ', 0, 'L', 0, |
| 't', 0, 'd', 0, ' ', 0, 'a', 0, 'n', 0, 'd', 0, ' ', 0, 'R', 0, |
| 'o', 0, 'c', 0, 'k', 0, 'b', 0, 'o', 0, 'x', 0}; |
| |
| static unsigned char string_descriptor_product[] = { |
| 0x1c, 0x03, |
| 'i', 0, 'R', 0, 'i', 0, 'v', 0, 'e', 0, 'r', 0, ' ', 0, 'i', 0, |
| 'F', 0, 'P', 0, '7', 0, '0', 0, '0', 0}; |
| |
| static unsigned char *string_descriptor[N_STRING_DESCRIPTORS] = { |
| string_descriptor_vendor, |
| string_descriptor_product |
| }; |
| |
| static inline int ep_index(int n, int dir) |
| { |
| return (n << 1) | dir; |
| } |
| |
| static inline int epidx_dir(int idx) |
| { |
| return idx & 1; |
| } |
| |
| static inline int epidx_n(int idx) |
| { |
| return idx >> 1; |
| } |
| |
| int usb_connected(void) |
| { |
| return GPIO7_READ & 1; |
| } |
| |
| static inline void usb_select_endpoint(int idx) |
| { |
| ISP1582_EPINDEX = idx; |
| } |
| |
| static inline void usb_select_setup_endpoint(void) |
| { |
| ISP1582_EPINDEX = 0x20; |
| } |
| |
| static void usb_setup_endpoint(int idx, int max_pkt_size, int type) |
| { |
| struct usb_endpoint *ep; |
| |
| usb_select_endpoint(idx); |
| ISP1582_MAXPKSZ = max_pkt_size; |
| /* |= is in the original firmware */ |
| ISP1582_EPTYPE |= 0x1c | type; |
| /* clear buffer */ |
| ISP1582_CTRLFUN |= 0x10; |
| ISP1582_INTEN |= (1 << (10 + idx)); |
| |
| ep = &(endpoints[epidx_n(idx)]); |
| ep->halt[epidx_dir(idx)] = 0; |
| ep->enabled[epidx_dir(idx)] = 1; |
| ep->out_in_progress = 0; |
| ep->in_min_len = -1; |
| ep->in_ack = 0; |
| ep->max_pkt_size[epidx_dir(idx)] = max_pkt_size; |
| } |
| |
| static void usb_disable_endpoint(int idx) |
| { |
| usb_select_endpoint(idx); |
| ISP1582_EPTYPE &= 8; |
| ISP1582_INTEN &= ~(1 << (10 + idx)); |
| endpoints[epidx_n(idx)].enabled[epidx_dir(idx)] = 1; |
| } |
| |
| void usb_reconnect(void) |
| { |
| int i; |
| ISP1582_MODE &= ~1; /* SOFTCT off */ |
| for (i = 0; i < 10000; i++) |
| nop_f(); |
| ISP1582_MODE |= 1; /* SOFTCT on */ |
| } |
| |
| static void usb_cleanup(void) |
| { |
| ISP1582_MODE &= ~1; /* SOFTCT off */ |
| } |
| |
| static void usb_setup(int reset) |
| { |
| int i; |
| |
| for (i = 0; i < N_ENDPOINTS; i++) |
| endpoints[i].enabled[0] = endpoints[i].enabled[1] = 0; |
| |
| ISP1582_UNLOCK = ISP1582_UNLOCK_CODE; |
| if (!reset) |
| ISP1582_MODE = 0x88; /* CLKAON | GLINTENA */ |
| ISP1582_INTCONF = 0x57; |
| ISP1582_INTEN = 0xd39; |
| |
| ISP1582_ADDRESS = reset ? 0x80: 0; |
| |
| usb_setup_endpoint(ep_index(0, DIR_RX), 64, 0); |
| usb_setup_endpoint(ep_index(0, DIR_TX), 64, 0); |
| |
| ISP1582_MODE |= 1; /* SOFTCT on */ |
| |
| usb_state = STATE_DEFAULT; |
| usb_remote_wakeup = 0; |
| } |
| |
| static int usb_get_packet(unsigned char *buf, int max_len) |
| { |
| int len, i; |
| len = ISP1582_BUFLEN; |
| |
| if (max_len < 0 || max_len > len) |
| max_len = len; |
| |
| i = 0; |
| while (i < len) |
| { |
| unsigned short d = ISP1582_DATA; |
| if (i < max_len) |
| buf[i] = d & 0xff; |
| i++; |
| if (i < max_len) |
| buf[i] = (d >> 8) & 0xff; |
| i++; |
| } |
| return max_len; |
| } |
| |
| static void usb_receive(int n) |
| { |
| int len; |
| |
| if (endpoints[n].halt[DIR_RX] |
| || !endpoints[n].enabled[DIR_RX] |
| || endpoints[n].in_min_len < 0 |
| || !endpoints[n].in_ack) |
| return; |
| |
| endpoints[n].in_ack = 0; |
| |
| usb_select_endpoint(ep_index(n, DIR_RX)); |
| |
| len = usb_get_packet(endpoints[n].in_buf + endpoints[n].in_ptr, |
| endpoints[n].in_max_len - endpoints[n].in_ptr); |
| endpoints[n].in_ptr += len; |
| if (endpoints[n].in_ptr >= endpoints[n].in_min_len) { |
| endpoints[n].in_min_len = -1; |
| if (endpoints[n].in_done) |
| (*(endpoints[n].in_done))(n, endpoints[n].in_buf, |
| endpoints[n].in_ptr); |
| } |
| } |
| |
| static int usb_out_buffer_full(int ep) |
| { |
| usb_select_endpoint(ep_index(ep, DIR_TX)); |
| if (ISP1582_EPTYPE & 4) |
| return (ISP1582_BUFSTAT & 3) == 3; |
| else |
| return (ISP1582_BUFSTAT & 3) != 0; |
| } |
| |
| static void usb_send(int n) |
| { |
| int max_pkt_size, len; |
| int i; |
| unsigned char *p; |
| |
| #ifdef LCD_DEBUG |
| if (endpoints[n].halt[DIR_TX]) |
| log_char('H'); |
| if (!endpoints[n].out_in_progress) |
| log_char('$'); |
| #endif |
| |
| if (endpoints[n].halt[DIR_TX] |
| || !endpoints[n].enabled[DIR_TX] |
| || !endpoints[n].out_in_progress) |
| return; |
| |
| if (endpoints[n].out_ptr < 0) |
| { |
| endpoints[n].out_in_progress = 0; |
| if (endpoints[n].out_done) |
| (*(endpoints[n].out_done))(n, endpoints[n].out_buf, |
| endpoints[n].out_len); |
| return; |
| } |
| |
| if (usb_out_buffer_full(n)) |
| { |
| log_char('F'); |
| return; |
| } |
| |
| usb_select_endpoint(ep_index(n, DIR_TX)); |
| max_pkt_size = endpoints[n].max_pkt_size[DIR_TX]; |
| len = endpoints[n].out_len - endpoints[n].out_ptr; |
| if (len > max_pkt_size) |
| len = max_pkt_size; |
| |
| log_char('0' + (len % 10)); |
| ISP1582_BUFLEN = len; |
| p = endpoints[n].out_buf + endpoints[n].out_ptr; |
| i = 0; |
| while (len - i >= 2) { |
| ISP1582_DATA = p[i] | (p[i + 1] << 8); |
| i += 2; |
| } |
| if (i < len) |
| ISP1582_DATA = p[i]; |
| |
| endpoints[n].out_ptr += len; |
| |
| /* |
| if (endpoints[n].out_ptr == endpoints[n].out_len |
| && len < max_pkt_size) |
| */ |
| if (endpoints[n].out_ptr == endpoints[n].out_len) |
| endpoints[n].out_ptr = -1; |
| } |
| |
| static void usb_stall_endpoint(int idx) |
| { |
| usb_select_endpoint(idx); |
| ISP1582_CTRLFUN |= 1; |
| endpoints[epidx_n(idx)].halt[epidx_dir(idx)] = 1; |
| } |
| |
| static void usb_unstall_endpoint(int idx) |
| { |
| usb_select_endpoint(idx); |
| ISP1582_CTRLFUN &= ~1; |
| ISP1582_EPTYPE &= ~8; |
| ISP1582_EPTYPE |= 8; |
| ISP1582_CTRLFUN |= 0x10; |
| if (epidx_dir(idx) == DIR_TX) |
| endpoints[epidx_n(idx)].out_in_progress = 0; |
| else |
| { |
| endpoints[epidx_n(idx)].in_min_len = -1; |
| endpoints[epidx_n(idx)].in_ack = 0; |
| } |
| endpoints[epidx_n(idx)].halt[epidx_dir(idx)] = 0; |
| } |
| |
| static void usb_status_ack(int dir) |
| { |
| log_char(dir ? '@' : '#'); |
| usb_select_endpoint(ep_index(0, dir)); |
| ISP1582_CTRLFUN |= 2; |
| } |
| |
| static void usb_set_address(int adr) |
| { |
| ISP1582_ADDRESS = adr | 0x80; |
| } |
| |
| static void usb_data_stage_enable(int dir) |
| { |
| usb_select_endpoint(ep_index(0, dir)); |
| ISP1582_CTRLFUN |= 4; |
| } |
| |
| static void usb_request_error(void) |
| { |
| usb_stall_endpoint(ep_index(0, DIR_TX)); |
| usb_stall_endpoint(ep_index(0, DIR_RX)); |
| } |
| |
| static void usb_receive_block(unsigned char *buf, int min_len, |
| int max_len, |
| void (*in_done)(int, unsigned char *, int), |
| int ep) |
| { |
| endpoints[ep].in_done = in_done; |
| endpoints[ep].in_buf = buf; |
| endpoints[ep].in_max_len = max_len; |
| endpoints[ep].in_min_len = min_len; |
| endpoints[ep].in_ptr = 0; |
| usb_receive(ep); |
| } |
| |
| static void usb_send_block(unsigned char *buf, int len, |
| void (*done)(int, unsigned char *, int), |
| int ep) |
| { |
| endpoints[ep].out_done = done; |
| endpoints[ep].out_buf = buf; |
| endpoints[ep].out_len = len; |
| endpoints[ep].out_ptr = 0; |
| endpoints[ep].out_in_progress = 1; |
| usb_send(ep); |
| } |
| |
| static void out_send_status(int n, unsigned char *buf, int len) |
| { |
| (void)n; |
| (void)buf; |
| (void)len; |
| usb_status_ack(DIR_RX); |
| } |
| |
| static void usb_send_block_and_status(unsigned char *buf, int len, int ep) |
| { |
| usb_send_block(buf, len, out_send_status, ep); |
| } |
| |
| static void usb_setup_set_address(int adr) |
| { |
| usb_set_address(adr); |
| usb_state = adr ? STATE_ADDRESS : STATE_DEFAULT; |
| usb_status_ack(DIR_TX); |
| } |
| |
| static void usb_send_descriptor(unsigned char *device_descriptor, |
| int descriptor_len, int buffer_len) |
| { |
| int len = descriptor_len < buffer_len ? descriptor_len : buffer_len; |
| usb_send_block_and_status(device_descriptor, len, 0); |
| } |
| |
| static void usb_setup_get_descriptor(int type, int index, int lang, int len) |
| { |
| (void)lang; |
| usb_data_stage_enable(DIR_TX); |
| switch (type) |
| { |
| case 1: |
| if (index == 0) |
| usb_send_descriptor(device_descriptor, |
| sizeof(device_descriptor), len); |
| else |
| usb_request_error(); |
| break; |
| case 2: |
| if (index == 0) |
| usb_send_descriptor(cfg_descriptor, |
| sizeof(cfg_descriptor), len); |
| else |
| usb_request_error(); |
| break; |
| case 3: |
| if (index == 0) |
| usb_send_descriptor(lang_descriptor, |
| sizeof(lang_descriptor), len); |
| else if (index <= N_STRING_DESCRIPTORS) |
| usb_send_descriptor(string_descriptor[index - 1], |
| string_descriptor[index - 1][0], |
| len); |
| else |
| usb_request_error(); |
| break; |
| default: |
| usb_request_error(); |
| } |
| } |
| |
| static void usb_setup_get_configuration(void) |
| { |
| setup_out_buf[0] = (usb_state == STATE_CONFIGURED) ? 1 : 0; |
| usb_data_stage_enable(DIR_TX); |
| usb_send_block_and_status(setup_out_buf, 1, 0); |
| } |
| |
| static void usb_setup_interface(void) |
| { |
| usb_setup_endpoint(ep_index(1, DIR_RX), 64, TYPE_BULK); |
| usb_setup_endpoint(ep_index(1, DIR_TX), 64, TYPE_BULK); |
| } |
| |
| static void usb_setup_set_configuration(int value) |
| { |
| switch (value) |
| { |
| case 0: |
| usb_disable_endpoint(ep_index(1, DIR_RX)); |
| usb_disable_endpoint(ep_index(1, DIR_TX)); |
| usb_state = STATE_ADDRESS; |
| usb_status_ack(DIR_TX); |
| break; |
| case 1: |
| usb_setup_interface(); |
| usb_state = STATE_CONFIGURED; |
| usb_status_ack(DIR_TX); |
| break; |
| default: |
| usb_request_error(); |
| } |
| } |
| |
| static void usb_send_status(void) |
| { |
| usb_data_stage_enable(DIR_TX); |
| usb_send_block_and_status(setup_out_buf, 2, 0); |
| } |
| |
| static void usb_setup_get_device_status(void) |
| { |
| setup_out_buf[0] = (usb_remote_wakeup != 0) ? 2 : 0; |
| setup_out_buf[1] = 0; |
| usb_send_status(); |
| } |
| |
| static void usb_setup_clear_device_feature(int feature) |
| { |
| if (feature == 1) { |
| usb_remote_wakeup = 0; |
| usb_status_ack(DIR_TX); |
| } else |
| usb_request_error(); |
| } |
| |
| static void usb_setup_set_device_feature(int feature) |
| { |
| if (feature == 1) { |
| usb_remote_wakeup = 1; |
| usb_status_ack(DIR_TX); |
| } else |
| usb_request_error(); |
| } |
| |
| static void usb_setup_clear_endpoint_feature(int endpoint, int feature) |
| { |
| if (usb_state != STATE_CONFIGURED || feature != 0) |
| usb_request_error(); |
| else if ((endpoint & 0xf) == 1) |
| { |
| usb_unstall_endpoint(ep_index(endpoint & 0xf, endpoint >> 7)); |
| usb_status_ack(DIR_TX); |
| } |
| else |
| usb_request_error(); |
| } |
| |
| static void usb_setup_set_endpoint_feature(int endpoint, int feature) |
| { |
| if (usb_state != STATE_CONFIGURED || feature != 0) |
| usb_request_error(); |
| else if ((endpoint & 0xf) == 1) |
| { |
| usb_stall_endpoint(ep_index(endpoint & 0xf, endpoint >> 7)); |
| usb_status_ack(DIR_TX); |
| } |
| else |
| usb_request_error(); |
| } |
| |
| static void usb_setup_get_interface_status(int interface) |
| { |
| if (usb_state != STATE_CONFIGURED || interface != 0) |
| usb_request_error(); |
| else |
| { |
| setup_out_buf[0] = setup_out_buf[1] = 0; |
| usb_send_status(); |
| } |
| } |
| |
| static void usb_setup_get_endpoint_status(int endpoint) |
| { |
| if ((usb_state == STATE_CONFIGURED && (endpoint & 0xf) <= 1) |
| || (usb_state == STATE_ADDRESS && (endpoint & 0xf) == 0)) |
| { |
| setup_out_buf[0] = endpoints[endpoint & 0xf].halt[endpoint >> 7]; |
| setup_out_buf[1] = 0; |
| usb_send_status(); |
| } |
| else |
| usb_request_error(); |
| } |
| |
| static void usb_setup_get_interface(int interface) |
| { |
| if (usb_state != STATE_CONFIGURED || interface != 0) |
| usb_request_error(); |
| else |
| { |
| setup_out_buf[0] = 0; |
| usb_data_stage_enable(DIR_TX); |
| usb_send_block_and_status(setup_out_buf, 1, 0); |
| } |
| } |
| |
| static void usb_setup_set_interface(int interface, int setting) |
| { |
| if (usb_state != STATE_CONFIGURED || interface != 0 || setting != 0) |
| usb_request_error(); |
| else |
| { |
| usb_setup_interface(); |
| usb_status_ack(DIR_TX); |
| } |
| } |
| |
| static void usb_handle_setup_pkt(unsigned char *pkt) |
| { |
| switch ((pkt[0] << 8) | pkt[1]) |
| { |
| case 0x0005: |
| log_char('A'); |
| usb_setup_set_address(pkt[2]); |
| break; |
| case 0x8006: |
| log_char('D'); |
| usb_setup_get_descriptor(pkt[3], pkt[2], (pkt[5] << 8) | pkt[4], |
| (pkt[7] << 8) | pkt[6]); |
| break; |
| case 0x8008: |
| usb_setup_get_configuration(); |
| break; |
| case 0x0009: |
| usb_setup_set_configuration(pkt[2]); |
| break; |
| case 0x8000: |
| usb_setup_get_device_status(); |
| break; |
| case 0x8100: |
| usb_setup_get_interface_status(pkt[4]); |
| break; |
| case 0x8200: |
| usb_setup_get_endpoint_status(pkt[4]); |
| break; |
| case 0x0001: |
| usb_setup_clear_device_feature(pkt[2]); |
| break; |
| case 0x0201: |
| usb_setup_clear_endpoint_feature(pkt[4], pkt[2]); |
| break; |
| case 0x0003: |
| usb_setup_set_device_feature(pkt[2]); |
| break; |
| case 0x0203: |
| usb_setup_set_endpoint_feature(pkt[4], pkt[2]); |
| break; |
| case 0x810a: |
| usb_setup_get_interface(pkt[4]); |
| break; |
| case 0x010b: |
| usb_setup_set_interface(pkt[4], pkt[2]); |
| break; |
| case 0x0103: |
| /* set interface feature */ |
| case 0x0101: |
| /* clear interface feature */ |
| case 0x0007: |
| /* set descriptor */ |
| case 0x820c: |
| /* synch frame */ |
| default: |
| usb_request_error(); |
| } |
| } |
| |
| static void usb_handle_setup_rx(void) |
| { |
| int len; |
| #ifdef LCD_DEBUG |
| char s[20]; |
| int i; |
| #endif |
| usb_select_setup_endpoint(); |
| len = usb_get_packet(setup_pkt_buf, 8); |
| |
| if (len == 8) |
| usb_handle_setup_pkt(setup_pkt_buf); |
| |
| #ifdef LCD_DEBUG |
| /* |
| snprintf(s, 10, "l%02x", len); |
| lcd_puts(0, 5, s); |
| */ |
| for (i = 0; i < 8; i++) |
| snprintf(s + i * 2, 3, "%02x", setup_pkt_buf[i]); |
| lcd_puts(0, 0, s); |
| lcd_update(); |
| #endif |
| } |
| |
| static void usb_handle_data_int(int ep, int dir) |
| { |
| if (dir == DIR_TX) |
| usb_send(ep); |
| else |
| { |
| endpoints[ep].in_ack = 1; |
| usb_receive(ep); |
| } |
| } |
| |
| static void usb_handle_int(int i) |
| { |
| #ifdef LCD_DEBUG |
| /* |
| char s[10]; |
| snprintf(s, sizeof(s), "%02d", i); |
| lcd_puts(0, 2, s); |
| lcd_update(); |
| */ |
| int_count[i]++; |
| if (i == 10) |
| log_char('o'); |
| if (i == 11) |
| log_char('i'); |
| if (i == 12) |
| log_char('O'); |
| if (i == 13) |
| log_char('I'); |
| #endif |
| |
| if (i >= 10) |
| usb_handle_data_int((i - 10) / 2, i % 2); |
| else |
| { |
| switch (i) |
| { |
| case 0: |
| log_char('r'); |
| usb_setup(1); |
| break; |
| case 8: |
| log_char('s'); |
| usb_handle_setup_rx(); |
| break; |
| } |
| } |
| |
| } |
| |
| static void usb_handle_interrupts(void) |
| { |
| #ifdef LCD_DEBUG |
| char s[20]; |
| #endif |
| |
| while (1) |
| { |
| unsigned long ints; |
| int i; |
| |
| #ifdef LCD_DEBUG |
| /* |
| snprintf(s, sizeof(s), "i%08lx", ISP1582_INT); |
| lcd_puts(0, 2, s); |
| */ |
| #endif |
| |
| ints = ISP1582_INT & ISP1582_INTEN; |
| if (!ints) break; |
| |
| i = 0; |
| while (!(ints & (1 << i))) |
| i++; |
| ISP1582_INT = 1 << i; |
| usb_handle_int(i); |
| |
| #ifdef LCD_DEBUG |
| for (i = 0; i < 8; i++) |
| snprintf(s + i * 2, 3, "%02x", int_count[i]); |
| lcd_puts(0, 6, s); |
| for (i = 0; i < 8; i++) |
| snprintf(s + i * 2, 3, "%02x", int_count[i + 8]); |
| lcd_puts(0, 7, s); |
| #endif |
| } |
| #ifdef LCD_DEBUG |
| /* |
| lcd_puts(0, 3, usb_connected() ? "C" : "N"); |
| lcd_update(); |
| */ |
| #endif |
| } |
| |
| static inline int fifo_mod(int n) |
| { |
| return (n >= SERIAL_BUF_SIZE) ? n - SERIAL_BUF_SIZE : n; |
| } |
| |
| static void fifo_init(struct serial_fifo *fifo) |
| { |
| fifo->head = fifo->tail = 0; |
| } |
| |
| static int fifo_empty(struct serial_fifo *fifo) |
| { |
| return fifo->head == fifo->tail; |
| } |
| |
| static int fifo_full(struct serial_fifo *fifo) |
| { |
| return fifo_mod(fifo->head + 1) == fifo->tail; |
| } |
| |
| static void fifo_remove(struct serial_fifo *fifo, int n) |
| { |
| fifo->tail = fifo_mod(fifo->tail + n); |
| } |
| |
| /* |
| Not used: |
| static void fifo_add(struct serial_fifo *fifo, int n) |
| { |
| fifo->head = fifo_mod(fifo->head + n); |
| } |
| |
| static void fifo_free_block(struct serial_fifo *fifo, |
| unsigned char **ptr, int *len) |
| { |
| *ptr = fifo->buf + fifo->head; |
| if (fifo->head >= fifo->tail) |
| { |
| int l = SERIAL_BUF_SIZE - fifo->head; |
| if (fifo->tail == 0) |
| l--; |
| *len = l; |
| } |
| else |
| *len = fifo->tail - fifo->head - 1; |
| } |
| */ |
| |
| static int fifo_free_space(struct serial_fifo *fifo) |
| { |
| if (fifo->head >= fifo->tail) |
| return SERIAL_BUF_SIZE - (fifo->head - fifo->tail) - 1; |
| else |
| return fifo->tail - fifo->head - 1; |
| } |
| |
| static int fifo_get_byte(struct serial_fifo *fifo) |
| { |
| int r = fifo->buf[fifo->tail]; |
| fifo->tail = fifo_mod(fifo->tail + 1); |
| return r; |
| } |
| |
| static void fifo_put_byte(struct serial_fifo *fifo, int b) |
| { |
| fifo->buf[fifo->head] = b; |
| fifo->head = fifo_mod(fifo->head + 1); |
| } |
| |
| static void fifo_full_block(struct serial_fifo *fifo, |
| unsigned char **ptr, int *len) |
| { |
| *ptr = fifo->buf + fifo->tail; |
| if (fifo->head >= fifo->tail) |
| *len = fifo->head - fifo->tail; |
| else |
| *len = SERIAL_BUF_SIZE - fifo->tail; |
| } |
| |
| static void serial_fill_in_fifo(int ep, unsigned char *buf, int len); |
| static void serial_free_out_fifo(int ep, unsigned char *buf, int len); |
| |
| static void serial_restart_input(int ep) |
| { |
| if (fifo_free_space(&serial_in_fifo) >= 64) |
| usb_receive_block(serial_in_pkt, 1, 64, serial_fill_in_fifo, ep); |
| } |
| |
| static void serial_fill_in_fifo(int ep, unsigned char *buf, int len) |
| { |
| int i; |
| for (i = 0; i < len; i++) |
| fifo_put_byte(&serial_in_fifo, buf[i]); |
| serial_restart_input(ep); |
| } |
| |
| static void serial_restart_output(int ep) |
| { |
| unsigned char *block; |
| int blen; |
| fifo_full_block(&serial_out_fifo, &block, &blen); |
| if (blen) |
| { |
| #ifdef LCD_DEBUG |
| lcd_putsf(0, 2, "o%03lx/%03x", block - serial_out_fifo.buf, blen); |
| lcd_update(); |
| #endif |
| usb_send_block(block, blen, serial_free_out_fifo, ep); |
| } |
| } |
| |
| static void serial_free_out_fifo(int ep, unsigned char *buf, int len) |
| { |
| (void)buf; |
| fifo_remove(&serial_out_fifo, len); |
| serial_restart_output(ep); |
| } |
| |
| static void usb_serial_handle(void) |
| { |
| #ifdef BUTTONS |
| static int t = 0; |
| |
| t++; |
| if (t >= 1000) |
| { |
| int b; |
| t = 0; |
| yield(); |
| b = button_get(false); |
| if (b == BUTTON_PLAY) |
| system_reboot(); |
| else if (b & BUTTON_REL) |
| usb_reconnect(); |
| } |
| #endif |
| |
| |
| if (!usb_connect_state) |
| { |
| if (usb_connected()) |
| { |
| int i; |
| GPIO3_SET = 4; |
| (*(volatile unsigned long *)0x80005004) = 2; |
| (*(volatile unsigned long *)0x80005008) = 0; |
| for (i = 0; i < 100000; i++) |
| nop_f(); |
| usb_setup(0); |
| usb_connect_state = 1; |
| } |
| } |
| else |
| { |
| if (!usb_connected()) |
| { |
| usb_connect_state = 0; |
| usb_cleanup(); |
| } |
| else |
| { |
| usb_handle_interrupts(); |
| |
| if (usb_state == STATE_CONFIGURED) |
| { |
| if (endpoints[1].in_min_len < 0) |
| serial_restart_input(1); |
| if (!endpoints[1].out_in_progress) |
| serial_restart_output(1); |
| } |
| } |
| } |
| } |
| |
| |
| /* |
| Not used: |
| static int usb_serial_in_empty(void) |
| { |
| return fifo_empty(&serial_in_fifo); |
| } |
| */ |
| |
| int usb_serial_get_byte(void) |
| { |
| while (fifo_empty(&serial_in_fifo)) |
| usb_serial_handle(); |
| return fifo_get_byte(&serial_in_fifo); |
| } |
| |
| int usb_serial_try_get_byte(void) |
| { |
| int r; |
| if (fifo_empty(&serial_in_fifo)) |
| r = -1; |
| else |
| r = fifo_get_byte(&serial_in_fifo); |
| usb_serial_handle(); |
| return r; |
| } |
| |
| /* |
| Not used: |
| static int usb_serial_out_full(void) |
| { |
| return fifo_full(&serial_out_fifo); |
| } |
| */ |
| |
| void usb_serial_put_byte(int b) |
| { |
| while (fifo_full(&serial_out_fifo)) |
| usb_serial_handle(); |
| fifo_put_byte(&serial_out_fifo, b); |
| usb_serial_handle(); |
| } |
| |
| int usb_serial_try_put_byte(int b) |
| { |
| int r = -1; |
| if (!fifo_full(&serial_out_fifo)) |
| { |
| fifo_put_byte(&serial_out_fifo, b); |
| r = 0; |
| } |
| usb_serial_handle(); |
| return r; |
| } |
| |
| void usb_serial_init(void) |
| { |
| fifo_init(&serial_in_fifo); |
| fifo_init(&serial_out_fifo); |
| usb_connect_state = 0; |
| } |