From 95167e01773dcfe8e5c1b356cfa1ea4b3a55441b Mon Sep 17 00:00:00 2001 From: Maurus Cuelenaere Date: Thu, 24 Apr 2008 20:08:28 +0000 Subject: Commit whole Creative Zen Vision:M target tree + all related firmware/ changes. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@17241 a1c6a512-1295-4272-9138-f99709370657 --- firmware/drivers/isp1583.c | 741 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 741 insertions(+) create mode 100644 firmware/drivers/isp1583.c (limited to 'firmware/drivers/isp1583.c') diff --git a/firmware/drivers/isp1583.c b/firmware/drivers/isp1583.c new file mode 100644 index 0000000000..8cc440dc4c --- /dev/null +++ b/firmware/drivers/isp1583.c @@ -0,0 +1,741 @@ +/*************************************************************************** + * __________ __ ___. + * Open \______ \ ____ ____ | | _\_ |__ _______ ___ + * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / + * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < + * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ + * \/ \/ \/ \/ \/ + * $Id$ + * + * Copyright (C) 2006 by Tomasz Malesinski + * Copyright (C) 2008 by Maurus Cuelenaere + * + * All files in this archive are subject to the GNU General Public License. + * See the file COPYING in the source tree root for full license agreement. + * + * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY + * KIND, either express or implied. + * + ****************************************************************************/ + +#include "config.h" +#include "usb-target.h" +#include "usb_ch9.h" +#include "usb_drv.h" +#include "usb_core.h" +#include "isp1583.h" +#include "thread.h" + +#define printf +#define logf printf + +#define DIR_RX 0 +#define DIR_TX 1 + +#define DIR_OUT 0 +#define DIR_IN 1 + +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]; + short type; +}; + +static unsigned char setup_pkt_buf[8]; +static struct usb_endpoint endpoints[NUM_ENDPOINTS]; + +static bool high_speed_mode = false; + +static inline void or_int_value(volatile unsigned short *a, volatile unsigned short *b, unsigned long r, unsigned long value) +{ + set_int_value(*a, *b, (r | value)); +} +static inline void bc_int_value(volatile unsigned short *a, volatile unsigned short *b, unsigned long r, unsigned long value) +{ + set_int_value(*a, *b, (r & ~value)); +} + +static inline void nop_f(void) +{ + yield(); +} + +#define NOP asm volatile("nop\n"); + +static inline int ep_index(int n, bool dir) +{ + return (n << 1) | dir; +} + +static inline bool epidx_dir(int idx) +{ + return idx & 1; +} + +static inline int epidx_n(int idx) +{ + return idx >> 1; +} + +static inline void usb_select_endpoint(int idx) +{ + /* Select the endpoint */ + ISP1583_DFLOW_EPINDEX = idx; + /* The delay time from the Write Endpoint Index register to the Read Data Port register must be at least 190 ns. + * The delay time from the Write Endpoint Index register to the Write Data Port register must be at least 100 ns. + */ + NOP; +} + +static inline void usb_select_setup_endpoint(void) +{ + /* Select the endpoint */ + ISP1583_DFLOW_EPINDEX = DFLOW_EPINDEX_EP0SETUP; + /* The delay time from the Write Endpoint Index register to the Read Data Port register must be at least 190 ns. + * The delay time from the Write Endpoint Index register to the Write Data Port register must be at least 100 ns. + */ + NOP; +} + +static void usb_setup_endpoint(int idx, int max_pkt_size, int type) +{ + if(epidx_n(idx)!=0) + { + usb_select_endpoint(idx); + ISP1583_DFLOW_MAXPKSZ = max_pkt_size & 0x7FF; + ISP1583_DFLOW_EPTYPE = (DFLOW_EPTYPE_NOEMPKT | DFLOW_EPTYPE_DBLBUF | (type & 0x3)); + + /* clear buffer ... */ + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF; + /* ... twice because of double buffering */ + usb_select_endpoint(idx); + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF; + } + + struct usb_endpoint *ep; + ep = &(endpoints[epidx_n(idx)]); + ep->halt[epidx_dir(idx)] = 0; + ep->enabled[epidx_dir(idx)] = 0; + ep->out_in_progress = 0; + ep->in_min_len = -1; + ep->in_ack = 0; + ep->type = type; + ep->max_pkt_size[epidx_dir(idx)] = max_pkt_size; +} + +static void usb_enable_endpoint(int idx) +{ + if(epidx_n(idx)!=0) + { + usb_select_endpoint(idx); + /* Enable interrupt */ + or_int_value(&ISP1583_INIT_INTEN_A, &ISP1583_INIT_INTEN_B, ISP1583_INIT_INTEN_READ, 1 << (10 + idx)); + /* Enable endpoint */ + ISP1583_DFLOW_EPTYPE |= DFLOW_EPTYPE_ENABLE; + } + + endpoints[epidx_n(idx)].enabled[epidx_dir(idx)] = 1; +} + +static void usb_disable_endpoint(int idx, bool set_struct) +{ + usb_select_endpoint(idx); + ISP1583_DFLOW_EPTYPE &= ~DFLOW_EPTYPE_ENABLE; + bc_int_value(&ISP1583_INIT_INTEN_A, &ISP1583_INIT_INTEN_B, ISP1583_INIT_INTEN_READ, 1 << (10 + idx)); + + if(set_struct) + endpoints[epidx_n(idx)].enabled[epidx_dir(idx)] = 0; +} + +static int usb_get_packet(unsigned char *buf, int max_len) +{ + int len, i; + len = ISP1583_DFLOW_BUFLEN; + + if (max_len < 0 || max_len > len) + max_len = len; + + i = 0; + while (i < len) + { + unsigned short d = ISP1583_DFLOW_DATA; + if (i < max_len) + buf[i] = d & 0xff; + i++; + if (i < max_len) + buf[i] = (d >> 8) & 0xff; + i++; + } + return max_len; +} + +static int usb_receive(int n) +{ + logf("usb_receive(%d)", 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 -1; + + 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); + } + logf("receive_end"); + return 0; +} + +static bool usb_out_buffer_full(int ep) +{ + usb_select_endpoint(ep_index(ep, DIR_TX)); + if (ISP1583_DFLOW_EPTYPE & 4) /* Check if type=bulk and double buffering is set */ + return (ISP1583_DFLOW_BUFSTAT & 3) == 3; /* Return true if both buffers are filled */ + else + return (ISP1583_DFLOW_BUFSTAT & 3) != 0; /* Return true if one of the buffers are filled */ +} + +static int usb_send(int n) +{ + logf("usb_send(%d)", n); + int max_pkt_size, len; + int i; + unsigned char *p; + + if (endpoints[n].halt[DIR_TX] + || !endpoints[n].enabled[DIR_TX] + || !endpoints[n].out_in_progress) + { + logf("NOT SEND TO EP!"); + return -1; + } + + 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); + logf("ALREADY SENT TO EP!"); + return -1; + } + + if (usb_out_buffer_full(n)) + { + logf("BUFFER FULL!"); + return -1; + } + + 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; + + if(len < max_pkt_size) + ISP1583_DFLOW_BUFLEN = len; + + p = endpoints[n].out_buf + endpoints[n].out_ptr; + i = 0; + while (len - i >= 2) { + ISP1583_DFLOW_DATA = p[i] | (p[i + 1] << 8); + i += 2; + } + if (i < len) + ISP1583_DFLOW_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; + + logf("send_end"); + return 0; +} + +static void usb_stall_endpoint(int idx) +{ + usb_select_endpoint(idx); + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_STALL; + endpoints[epidx_n(idx)].halt[epidx_dir(idx)] = 1; +} + +static void usb_unstall_endpoint(int idx) +{ + usb_select_endpoint(idx); + ISP1583_DFLOW_CTRLFUN &= ~DFLOW_CTRLFUN_STALL; + ISP1583_DFLOW_EPTYPE &= ~DFLOW_EPTYPE_ENABLE; + ISP1583_DFLOW_EPTYPE |= DFLOW_EPTYPE_ENABLE; + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_CLBUF; + 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 ep, int dir) +{ + logf("usb_status_ack(%d)", dir); + usb_select_endpoint(ep_index(ep, dir)); + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_STATUS; +} + +static void usb_data_stage_enable(int ep, int dir) +{ + logf("usb_data_stage_enable(%d)", dir); + usb_select_endpoint(ep_index(ep, dir)); + ISP1583_DFLOW_CTRLFUN |= DFLOW_CTRLFUN_DSEN; +} + +static void usb_handle_setup_rx(void) +{ + int len; + usb_select_setup_endpoint(); + len = usb_get_packet(setup_pkt_buf, 8); + + if (len == 8) + usb_core_control_request((struct usb_ctrlrequest*)setup_pkt_buf); + else + { + usb_drv_stall(0, true, false); + usb_drv_stall(0, true, true); + logf("usb_handle_setup_rx() failed"); + return; + } + + logf("usb_handle_setup_rx(): %02x %02x %02x %02x %02x %02x %02x %02x", setup_pkt_buf[0], setup_pkt_buf[1], setup_pkt_buf[2], setup_pkt_buf[3], setup_pkt_buf[4], setup_pkt_buf[5], setup_pkt_buf[6], setup_pkt_buf[7]); +} + +static void usb_handle_data_int(int ep, int dir) +{ + int len; + if (dir == DIR_TX) + len = usb_send(ep); + else + { + len = usb_receive(ep); + endpoints[ep].in_ack = 1; + } + logf("usb_handle_data_int(%d, %d) finished", ep, dir); +} + +bool usb_drv_powered(void) +{ +#if 0 + return (ISP1583_INIT_OTG & INIT_OTG_BSESS_VALID) ? true : false; +#else + return (ISP1583_INIT_MODE & INIT_MODE_VBUSSTAT) ? true : false; +#endif +} + +static void setup_endpoints(void) +{ + usb_setup_endpoint(ep_index(0, DIR_RX), 64, 0); + usb_setup_endpoint(ep_index(0, DIR_TX), 64, 0); + + int i; + for(i = 1; i < NUM_ENDPOINTS-1; i++) + { + usb_setup_endpoint(ep_index(i, DIR_RX), (high_speed_mode ? 512 : 64), 2); /* 2 = TYPE_BULK */ + usb_setup_endpoint(ep_index(i, DIR_TX), (high_speed_mode ? 512 : 64), 2); + } + + usb_enable_endpoint(ep_index(0, DIR_RX)); + usb_enable_endpoint(ep_index(0, DIR_TX)); + + for (i = 1; i < NUM_ENDPOINTS-1; i++) + { + usb_enable_endpoint(ep_index(i, DIR_RX)); + usb_enable_endpoint(ep_index(i, DIR_TX)); + } + + ZVM_SPECIFIC; +} + +void usb_helper(void) +{ + if(ISP1583_GEN_INT_READ & ISP1583_INIT_INTEN_READ) + { + #ifdef DEBUG + //logf("Helper detected interrupt... [%d]", current_tick); + #endif + usb_drv_int(); + } + return; +} + +void usb_drv_init(void) +{ + /* Disable interrupt at CPU level */ + DIS_INT_CPU_TARGET; + + /* Unlock the device's registers */ + ISP1583_GEN_UNLCKDEV = ISP1583_UNLOCK_CODE; + + /* Soft reset the device */ + ISP1583_INIT_MODE = INIT_MODE_SFRESET; + sleep(10); + /* Enable CLKAON & GLINTENA */ + ISP1583_INIT_MODE = STANDARD_INIT_MODE; + + /* Disable all OTG functions */ + ISP1583_INIT_OTG = 0; + +#if 0 + #ifdef USE_HIGH_SPEED + /* Force device to high speed */ + ISP1583_GEN_TSTMOD = GEN_TSTMOD_FORCEHS; + high_speed_mode = true; + #endif +#endif + + #ifdef DEBUG + logf("BUS_CONF/DA0:%d MODE0/DA1: %d MODE1: %d", (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST0), (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST1), (bool)(ISP1583_INIT_MODE & INIT_MODE_TEST2)); + logf("Chip ID: 0x%x", ISP1583_GEN_CHIPID); + //logf("INV0: 0x% IRQEDGE: 0x%x IRQPORT: 0x%x", IO_GIO_INV0, IO_GIO_IRQEDGE, IO_GIO_IRQPORT); + #endif + + /*Set interrupt generation to target-specific mode + + * Set the control pipe to ACK only interrupt + + * Set the IN pipe to ACK only interrupt + + * Set OUT pipe to ACK and NYET interrupt + */ + + ISP1583_INIT_INTCONF = 0x54 | INT_CONF_TARGET; + /* Clear all interrupts */ + set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, 0xFFFFFFFF); + /* Enable USB interrupts */ + set_int_value(ISP1583_INIT_INTEN_A, ISP1583_INIT_INTEN_B, STANDARD_INTEN); + + ZVM_SPECIFIC; + + /* Enable interrupt at CPU level */ + EN_INT_CPU_TARGET; + + setup_endpoints(); + + /* Clear device address and disable it */ + ISP1583_INIT_ADDRESS = 0; + + /* Turn SoftConnect on */ + ISP1583_INIT_MODE |= INIT_MODE_SOFTCT; + + ZVM_SPECIFIC; + + tick_add_task(usb_helper); + + logf("usb_init_device() finished"); +} + +int usb_drv_port_speed(void) +{ + return (int)high_speed_mode; +} + +void usb_drv_exit(void) +{ + logf("usb_drv_exit()"); + + /* Disable device */ + ISP1583_INIT_MODE &= ~INIT_MODE_SOFTCT; + ISP1583_INIT_ADDRESS = 0; + + /* Disable interrupts */ + set_int_value(ISP1583_INIT_INTEN_A, ISP1583_INIT_INTEN_B, 0); + /* and the CPU's one... */ + DIS_INT_CPU_TARGET; + + + /* Send usb controller to suspend mode */ + ISP1583_INIT_MODE = INIT_MODE_GOSUSP; + ISP1583_INIT_MODE = 0; + + tick_remove_task(usb_helper); + + ZVM_SPECIFIC; +} + +void usb_drv_stall(int endpoint, bool stall, bool in) +{ + logf("%sstall EP%d %s", (stall ? "" : "un"), endpoint, (in ? "RX" : "TX" )); + if (stall) + usb_stall_endpoint(ep_index(endpoint, (int)in)); + else + usb_unstall_endpoint(ep_index(endpoint, (int)in)); +} + +bool usb_drv_stalled(int endpoint, bool in) +{ + return (endpoints[endpoint].halt[(int)in] == 1); +} + +static void out_callback(int ep, unsigned char *buf, int len) +{ + (void)buf; + logf("out_callback(%d, 0x%x, %d)", ep, &buf, len); + usb_status_ack(ep, DIR_RX); + usb_core_transfer_complete(ep, true, 0, len); /* 0=>status succeeded, haven't worked out status failed yet... */ +} + +static void in_callback(int ep, unsigned char *buf, int len) +{ + (void)buf; + logf("in_callback(%d, 0x%x, %d)", ep, &buf, len); + usb_status_ack(ep, DIR_TX); + usb_core_transfer_complete(ep, false, 0, len); +} + +int usb_drv_recv(int ep, void* ptr, int length) +{ + logf("usb_drv_recv(%d, 0x%x, %d)", ep, &ptr, length); + if(ep == 0 && length == 0 && ptr == NULL) + { + usb_status_ack(ep, DIR_TX); + return 0; + } + endpoints[ep].in_done = in_callback; + endpoints[ep].in_buf = ptr; + endpoints[ep].in_max_len = length; + endpoints[ep].in_min_len = length; + endpoints[ep].in_ptr = 0; + if(ep == 0) + { + usb_data_stage_enable(ep, DIR_RX); + return usb_receive(ep); + } + else + return usb_receive(ep); +} + +int usb_drv_send_nonblocking(int ep, void* ptr, int length) +{ + /* First implement DMA... */ + return usb_drv_send(ep, ptr, length); +} + +int usb_drv_send(int ep, void* ptr, int length) +{ + logf("usb_drv_send_nb(%d, 0x%x, %d)", ep, &ptr, length); + if(ep == 0 && length == 0 && ptr == NULL) + { + usb_status_ack(ep, DIR_RX); + return 0; + } + if(endpoints[ep].out_in_progress == 1) + return -1; + endpoints[ep].out_done = out_callback; + endpoints[ep].out_buf = ptr; + endpoints[ep].out_len = length; + endpoints[ep].out_ptr = 0; + endpoints[ep].out_in_progress = 1; + if(ep == 0) + { + int rc = usb_send(ep); + usb_data_stage_enable(ep, DIR_TX); + usb_drv_wait(ep, DIR_TX); + return rc; + } + else + return usb_send(ep); +} + +void usb_drv_reset_endpoint(int ep, bool send) +{ + logf("reset endpoint(%d, %d)", ep, send); + usb_setup_endpoint(ep_index(ep, (int)send), endpoints[ep].max_pkt_size[(int)send], endpoints[ep].type); + usb_enable_endpoint(ep_index(ep, (int)send)); +} + +void usb_drv_wait(int ep, bool send) +{ + logf("usb_drv_wait(%d, %d)", ep, send); + if(send) + { + while (endpoints[ep].out_in_progress) + nop_f(); + } + else + { + while (endpoints[ep].in_ack) + nop_f(); + } +} + +void usb_drv_cancel_all_transfers(void) +{ + logf("usb_drv_cancel_all_tranfers()"); + int i; + + for(i=0;idone"); +} + +/* Method for handling interrupts, must be called from usb-.c */ +void usb_drv_int(void) +{ + unsigned long ints; + ints = ISP1583_GEN_INT_READ & ISP1583_INIT_INTEN_READ; + + if(!ints) + return; + + /* Unlock the device's registers */ + ISP1583_GEN_UNLCKDEV = ISP1583_UNLOCK_CODE; + + #if 0 + logf(" handling int [0x%x & 0x%x = 0x%x]", ISP1583_GEN_INT_READ, ISP1583_INIT_INTEN_READ, ints); + #endif + + if(ints & INT_IEBRST) /* Bus reset */ + { + logf("BRESET"); + high_speed_mode = false; + bus_reset(); + usb_core_bus_reset(); + /* Mask bus reset interrupt */ + set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, INT_IEBRST); + return; + } + if(ints & INT_IEP0SETUP) /* EP0SETUP interrupt */ + { + logf("EP0SETUP"); + usb_handle_setup_rx(); + } + if(ints & INT_IEHS_STA) /* change from full-speed to high-speed mode -> endpoints need to get reconfigured!! */ + { + logf("HS_STA"); + high_speed_mode = true; + setup_endpoints(); + } + if(ints & INT_EP_MASK) /* Endpoints interrupt */ + { + unsigned long ep_event; + unsigned short i = 10; + ep_event = ints & INT_EP_MASK; + while(ep_event) + { + if(i>25) + break; + + if(ep_event & (1 << i)) + { + logf("EP%d %s interrupt", (i - 10) / 2, i % 2 ? "RX" : "TX"); + usb_handle_data_int((i - 10) / 2, i % 2); + ep_event &= ~(1 << i); + } + i++; + } + } + if(ints & INT_IERESM && !(ints & INT_IESUSP)) /* Resume status: status change from suspend to resume (active) */ + { + logf("RESM"); + } + if(ints & INT_IESUSP && !(ints & INT_IERESM)) /* Suspend status: status change from active to suspend */ + { + logf("SUSP"); + } + if(ints & INT_IEDMA) /* change in the DMA Interrupt Reason register */ + { + logf("DMA"); + } + if(ints & INT_IEVBUS) /* transition from LOW to HIGH on VBUS */ + { + logf("VBUS"); + } + /* Mask all (enabled) interrupts */ + set_int_value(ISP1583_GEN_INT_A, ISP1583_GEN_INT_B, ints); + + ZVM_SPECIFIC; +} + +void usb_drv_set_address(int address) +{ + logf("usb_drv_set_address(0x%x)", address); + ISP1583_INIT_ADDRESS = (address & 0x7F) | INIT_ADDRESS_DEVEN; + + ZVM_SPECIFIC; + + usb_status_ack(0, DIR_TX); +} + +void usb_drv_set_test_mode(int mode) +{ + logf("usb_drv_set_test_mode(%d)", mode); + switch(mode){ + case 0: + ISP1583_GEN_TSTMOD = 0; + /* Power cycle... */ + break; + case 1: + ISP1583_GEN_TSTMOD = GEN_TSTMOD_JSTATE; + break; + case 2: + ISP1583_GEN_TSTMOD = GEN_TSTMOD_KSTATE; + break; + case 3: + ISP1583_GEN_TSTMOD = GEN_TSTMOD_SE0_NAK; + break; + case 4: + //REG_PORTSC1 |= PORTSCX_PTC_PACKET; + break; + case 5: + //REG_PORTSC1 |= PORTSCX_PTC_FORCE_EN; + break; + } +} -- cgit v1.2.3