[sigrok-firmware-fx2lafw.git] / hantek_6022be.c

/**
 * Copyright (C) 2009 Ubixum, Inc. 
 * Copyright (C) 2015 Jochen Hoenicke
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 **/

#include <fx2macros.h>
#include <fx2ints.h>
#include <autovector.h>
#include <delay.h>
#include <setupdat.h>

#ifdef DEBUG_FIRMWARE 
#include <serial.h>
#include <stdio.h>
#else
#define printf(...)
#endif

volatile WORD ledcounter = 0;


volatile __bit dosud=FALSE;
volatile __bit dosuspend=FALSE;

// custom functions
extern void main_loop();
extern void main_init();

void main() {

 SETCPUFREQ(CLK_12M); // save energy

 main_init();

 // set up interrupts.
 USE_USB_INTS();
 
 ENABLE_SUDAV();
 ENABLE_USBRESET();
 ENABLE_HISPEED(); 
 ENABLE_SUSPEND();
 ENABLE_RESUME();

 EA=1;

 // init timer2
    RCAP2L = -500 & 0xff;
    RCAP2H = (-500 >> 8) & 0xff;
    T2CON = 0;
    ET2 = 1;
    TR2 = 1;

// iic files (c2 load) don't need to renumerate/delay
// trm 3.6
#ifndef NORENUM
 RENUMERATE();
#else
 USBCS &= ~bmDISCON;
#endif
 
    PORTCCFG = 0;
    PORTACFG = 0;
    OEC = 0xff;
    OEA = 0x80;

 while(TRUE) {

     main_loop();

     if (dosud) {
       dosud=FALSE;
       handle_setupdata();
     }

     if (dosuspend) {
        dosuspend=FALSE;
        do {
           printf ( "I'm going to Suspend.\n" );
           WAKEUPCS |= bmWU|bmWU2; // make sure ext wakeups are cleared
           SUSPEND=1;
           PCON |= 1;
           __asm
           nop
           nop
           nop
           nop
           nop
           nop
           nop
           __endasm;
        } while ( !remote_wakeup_allowed && REMOTE_WAKEUP()); 
        printf ( "I'm going to wake up.\n");

        // resume
        // trm 6.4
        if ( REMOTE_WAKEUP() ) {
            delay(5);
            USBCS |= bmSIGRESUME;
            delay(15);
            USBCS &= ~bmSIGRESUME;
        }

     }

 } // end while

} // end main

void resume_isr() __interrupt RESUME_ISR {
 CLEAR_RESUME();
}
  
void sudav_isr() __interrupt SUDAV_ISR {
 dosud=TRUE;
 CLEAR_SUDAV();
}
void usbreset_isr() __interrupt USBRESET_ISR {
 handle_hispeed(FALSE);
 CLEAR_USBRESET();
}
void hispeed_isr() __interrupt HISPEED_ISR {
 handle_hispeed(TRUE);
 CLEAR_HISPEED();
}

void suspend_isr() __interrupt SUSPEND_ISR {
 dosuspend=TRUE;
 CLEAR_SUSPEND();
}

void timer2_isr() __interrupt TF2_ISR {
  PA7 = !PA7;
  if (ledcounter) {
    if (--ledcounter == 0) {
      // clear LED
      PC0 = 1;
      PC1 = 1;
    }
  }
  TF2 = 0;
}
/**
 * Copyright (C) 2009 Ubixum, Inc. 
 * Copyright (C) 2015 Jochen Hoenicke
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 **/

#include <fx2macros.h>
#include <delay.h>

#ifdef DEBUG_FIRMWARE
#include <stdio.h>
#else
#define printf(...)
#endif

// change to support as many interfaces as you need
BYTE altiface = 0; // alt interface
extern volatile WORD ledcounter;


/* This sets three bits for each channel, one channel at a time.
 * For channel 0 we want to set bits 5, 6 & 7
 * For channel 1 we want to set bits 2, 3 & 4
 *
 * We convert the input values that are strange due to original firmware code into the value of the three bits as follows:
 * val -> bits
 * 1  -> 010b
 * 2  -> 001b
 * 5  -> 000b
 * 10 -> 011b
 *
 * The third bit is always zero since there are only four outputs connected in the serial selector chip.
 *
 * The multiplication of the converted value by 0x24 sets the relevant bits in
 * both channels and then we mask it out to only affect the channel currently
 * requested.
 */
BOOL set_voltage(BYTE channel, BYTE val)
{
    BYTE bits, mask;
    switch (val) {
    case 1:
	bits = 0x24 * 2;
	break;
    case 2:
	bits = 0x24 * 1;
	break;
    case 5:
	bits = 0x24 * 0;
	break;
    case 10:
	bits = 0x24 * 3;
	break;
    default:
	return FALSE;
    }

    mask = channel ? 0xe0 : 0x1c;
    IOC = (IOC & ~mask) | (bits & mask);
    return TRUE;
}

BOOL set_numchannels(BYTE numchannels)
{
    if (numchannels == 1 || numchannels == 2) {
	BYTE fifocfg = 7 + numchannels;
	EP2FIFOCFG = fifocfg;
	EP6FIFOCFG = fifocfg;
	return TRUE;
    }
    return FALSE;
}

void clear_fifo()
{
    GPIFABORT = 0xff;
    SYNCDELAY3;
    FIFORESET = 0x80;
    SYNCDELAY3;
    FIFORESET = 0x82;
    SYNCDELAY3;
    FIFORESET = 0x86;
    SYNCDELAY3;
    FIFORESET = 0;
}

void stop_sampling()
{
    GPIFABORT = 0xff;
    SYNCDELAY3;
    if (altiface == 0) {
	INPKTEND = 6;
    } else {
	INPKTEND = 2;
    }
}

void start_sampling()
{
    int i;
    clear_fifo();

    for (i = 0; i < 1000; i++);
    while (!(GPIFTRIG & 0x80)) {
	;
    }
    SYNCDELAY3;
    GPIFTCB1 = 0x28;
    SYNCDELAY3;
    GPIFTCB0 = 0;
    if (altiface == 0)
	GPIFTRIG = 6;
    else
	GPIFTRIG = 4;

    // set green led
    // don't clear led
    ledcounter = 0;
    PC0 = 1;
    PC1 = 0;
}

extern __code BYTE highspd_dscr;
extern __code BYTE fullspd_dscr;
void select_interface(BYTE alt)
{
    const BYTE *pPacketSize = (USBCS & bmHSM ? &highspd_dscr : &fullspd_dscr)
	+ (9 + 16*alt + 9 + 4);
    altiface = alt;
    if (alt == 0) {
	// bulk on port 6
	EP2CFG = 0x00;
	EP6CFG = 0xe0;
	EP6GPIFFLGSEL = 1;

	EP6AUTOINLENL = pPacketSize[0];
	EP6AUTOINLENH = pPacketSize[1];
    } else {
	// iso on port 2
	EP2CFG = 0xd8;
	EP6CFG = 0x00;
	EP2GPIFFLGSEL = 1;

	EP2AUTOINLENL = pPacketSize[0];
	EP2AUTOINLENH = pPacketSize[1] & 0x7;
	EP2ISOINPKTS = (pPacketSize[1] >> 3) + 1;
    }
}

const struct samplerate_info {
    BYTE rate;
    BYTE wait0;
    BYTE wait1;
    BYTE opc0;
    BYTE opc1;
    BYTE out0;
    BYTE ifcfg;
} samplerates[] = {
    { 48,0x80,   0, 3, 0, 0x00, 0xea },
    { 30,0x80,   0, 3, 0, 0x00, 0xaa },
    { 24,   1,   0, 2, 1, 0x40, 0xca },
    { 16,   1,   1, 2, 0, 0x40, 0xca },
    { 12,   2,   1, 2, 0, 0x40, 0xca },
    {  8,   3,   2, 2, 0, 0x40, 0xca },
    {  4,   6,   5, 2, 0, 0x40, 0xca },
    {  2,  12,  11, 2, 0, 0x40, 0xca },
    {  1,  24,  23, 2, 0, 0x40, 0xca },
    { 50,  48,  47, 2, 0, 0x40, 0xca },
    { 20, 120, 119, 2, 0, 0x40, 0xca },
    { 10, 240, 239, 2, 0, 0x40, 0xca }
};

BOOL set_samplerate(BYTE rate)
{
    BYTE i = 0;
    while (samplerates[i].rate != rate) {
	i++;
	if (i == sizeof(samplerates)/sizeof(samplerates[0]))
	    return FALSE;
    }

    IFCONFIG = samplerates[i].ifcfg;

    AUTOPTRSETUP = 7;
    AUTOPTRH2 = 0xE4;
    AUTOPTRL2 = 0x00;

    /* The program for low-speed, e.g. 1 MHz, is
     * wait 24, CTL2=0, FIFO
     * wait 23, CTL2=1
     * jump 0, CTL2=1
     *
     * The program for 24 MHz is
     * wait 1, CTL2=0, FIFO
     * jump 0, CTL2=1
     *
     * The program for 30/48 MHz is:
     * jump 0, CTL2=Z, FIFO, LOOP
     */

    EXTAUTODAT2 = samplerates[i].wait0;
    EXTAUTODAT2 = samplerates[i].wait1;
    EXTAUTODAT2 = 1;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;

    EXTAUTODAT2 = samplerates[i].opc0;
    EXTAUTODAT2 = samplerates[i].opc1;
    EXTAUTODAT2 = 1;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;

    EXTAUTODAT2 = samplerates[i].out0;
    EXTAUTODAT2 = 0x44;
    EXTAUTODAT2 = 0x44;
    EXTAUTODAT2 = 0x00;
    EXTAUTODAT2 = 0x00;
    EXTAUTODAT2 = 0x00;
    EXTAUTODAT2 = 0x00;
    EXTAUTODAT2 = 0x00;

    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;
    EXTAUTODAT2 = 0;

    for (i = 0; i < 96; i++)
	EXTAUTODAT2 = 0;
    return TRUE;
}

//************************** Configuration Handlers *****************************

// set *alt_ifc to the current alt interface for ifc
BOOL handle_get_interface(BYTE ifc, BYTE* alt_ifc) {
    (void) ifc; // ignore unused parameter
    *alt_ifc=altiface;
    return TRUE;
}
// return TRUE if you set the interface requested
// NOTE this function should reconfigure and reset the endpoints
// according to the interface descriptors you provided.
BOOL handle_set_interface(BYTE ifc,BYTE alt_ifc) {  
    printf ( "Set Interface.\n" );
    if (ifc == 0) {
      select_interface(alt_ifc);
    }
    return TRUE;
}

// handle getting and setting the configuration
// 1 is the default.  We don't support multiple configurations.
BYTE handle_get_configuration() { 
    return 0;
}

BOOL handle_set_configuration(BYTE cfg) { 
    (void) cfg; // ignore unused parameter
    return TRUE;
}


//******************* VENDOR COMMAND HANDLERS **************************

BOOL handle_vendorcommand(BYTE cmd) {
    stop_sampling();
    // Set Red LED
    PC0 = 0;
    PC1 = 1;
    ledcounter = 1000;
    switch (cmd) {
    case 0xe0:
    case 0xe1:
	EP0BCH=0;
	EP0BCL=0;
	while (EP0CS & bmEPBUSY);
	set_voltage(cmd - 0xe0, EP0BUF[0]);
	return TRUE;
    case 0xe2:
	EP0BCH=0;
	EP0BCL=0;
	while (EP0CS & bmEPBUSY);
	set_samplerate(EP0BUF[0]);
	return TRUE;
    case 0xe3:
	EP0BCH=0;
	EP0BCL=0;
	while (EP0CS & bmEPBUSY);
	if (EP0BUF[0] == 1)
	    start_sampling();
	return TRUE;
    case 0xe4:
	EP0BCH=0;
	EP0BCL=0;
	while (EP0CS & bmEPBUSY);
	set_numchannels(EP0BUF[0]);
	return TRUE;
    }
    return FALSE; // not handled by handlers
}

//********************  INIT ***********************

void main_init() {
    EP4CFG = 0;
    EP8CFG = 0;

    // in idle mode tristate all outputs
    GPIFIDLECTL = 0x00;
    GPIFCTLCFG = 0x80;
    GPIFWFSELECT = 0x00;
    GPIFREADYSTAT = 0x00;

    stop_sampling();
    set_voltage(0, 1);
    set_voltage(1, 1);
    set_samplerate(1);
    set_numchannels(2);
    select_interface(0);

    printf ( "Initialization Done.\n" );
}


void main_loop() {
}
Commit	Line	Data
189db3d4 UH	1	/**
	2	* Copyright (C) 2009 Ubixum, Inc.
	3	* Copyright (C) 2015 Jochen Hoenicke
	4	*
	5	* This library is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2.1 of the License, or (at your option) any later version.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	18	**/
	19
	20	#include <fx2macros.h>
	21	#include <fx2ints.h>
	22	#include <autovector.h>
	23	#include <delay.h>
	24	#include <setupdat.h>
	25
	26	#ifdef DEBUG_FIRMWARE
	27	#include <serial.h>
	28	#include <stdio.h>
	29	#else
	30	#define printf(...)
	31	#endif
	32
	33	volatile WORD ledcounter = 0;
	34
	35
	36	volatile __bit dosud=FALSE;
	37	volatile __bit dosuspend=FALSE;
	38
	39	// custom functions
	40	extern void main_loop();
	41	extern void main_init();
	42
	43	void main() {
	44
	45	SETCPUFREQ(CLK_12M); // save energy
	46
	47	main_init();
	48
	49	// set up interrupts.
	50	USE_USB_INTS();
	51
	52	ENABLE_SUDAV();
	53	ENABLE_USBRESET();
	54	ENABLE_HISPEED();
	55	ENABLE_SUSPEND();
	56	ENABLE_RESUME();
	57
	58	EA=1;
	59
	60	// init timer2
	61	RCAP2L = -500 & 0xff;
	62	RCAP2H = (-500 >> 8) & 0xff;
	63	T2CON = 0;
	64	ET2 = 1;
65	TR2 = 1;
66
67	// iic files (c2 load) don't need to renumerate/delay
68	// trm 3.6
69	#ifndef NORENUM
70	RENUMERATE();
71	#else
72	USBCS &= ~bmDISCON;
73	#endif
74
75	PORTCCFG = 0;
76	PORTACFG = 0;
77	OEC = 0xff;
78	OEA = 0x80;
79
80	while(TRUE) {
81
82	main_loop();
83
84	if (dosud) {
85	dosud=FALSE;
86	handle_setupdata();
87	}
88
89	if (dosuspend) {
90	dosuspend=FALSE;
91	do {
92	printf ( "I'm going to Suspend.\n" );
93	WAKEUPCS \|= bmWU\|bmWU2; // make sure ext wakeups are cleared
94	SUSPEND=1;
95	PCON \|= 1;
96	__asm
97	nop
98	nop
99	nop
100	nop
101	nop
102	nop
103	nop
104	__endasm;
105	} while ( !remote_wakeup_allowed && REMOTE_WAKEUP());
106	printf ( "I'm going to wake up.\n");
107
108	// resume
109	// trm 6.4
110	if ( REMOTE_WAKEUP() ) {
111	delay(5);
112	USBCS \|= bmSIGRESUME;
113	delay(15);
114	USBCS &= ~bmSIGRESUME;
115	}
116
117	}
118
119	} // end while
120
121	} // end main
122
123	void resume_isr() __interrupt RESUME_ISR {
124	CLEAR_RESUME();
125	}
126
127	void sudav_isr() __interrupt SUDAV_ISR {
128	dosud=TRUE;
129	CLEAR_SUDAV();
130	}
131	void usbreset_isr() __interrupt USBRESET_ISR {
132	handle_hispeed(FALSE);
133	CLEAR_USBRESET();
134	}
135	void hispeed_isr() __interrupt HISPEED_ISR {
136	handle_hispeed(TRUE);
137	CLEAR_HISPEED();
138	}
139
140	void suspend_isr() __interrupt SUSPEND_ISR {
141	dosuspend=TRUE;
142	CLEAR_SUSPEND();
143	}
144
145	void timer2_isr() __interrupt TF2_ISR {
146	PA7 = !PA7;
147	if (ledcounter) {
148	if (--ledcounter == 0) {
149	// clear LED
150	PC0 = 1;
151	PC1 = 1;
152	}
153	}
154	TF2 = 0;
155	}
156	/**
157	* Copyright (C) 2009 Ubixum, Inc.
158	* Copyright (C) 2015 Jochen Hoenicke
159	*
160	* This library is free software; you can redistribute it and/or
161	* modify it under the terms of the GNU Lesser General Public
162	* License as published by the Free Software Foundation; either
163	* version 2.1 of the License, or (at your option) any later version.
164	*
165	* This library is distributed in the hope that it will be useful,
166	* but WITHOUT ANY WARRANTY; without even the implied warranty of
167	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
168	* Lesser General Public License for more details.
169	*
170	* You should have received a copy of the GNU Lesser General Public
171	* License along with this library; if not, write to the Free Software
172	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
173	**/
174
175	#include <fx2macros.h>
176	#include <delay.h>
177
178	#ifdef DEBUG_FIRMWARE
179	#include <stdio.h>
180	#else
181	#define printf(...)
182	#endif
183
184	// change to support as many interfaces as you need
185	BYTE altiface = 0; // alt interface
186	extern volatile WORD ledcounter;
187
188
189
190	/* This sets three bits for each channel, one channel at a time.
191	* For channel 0 we want to set bits 5, 6 & 7
192	* For channel 1 we want to set bits 2, 3 & 4
193	*
194	* We convert the input values that are strange due to original firmware code into the value of the three bits as follows:
195	* val -> bits
196	* 1 -> 010b
197	* 2 -> 001b
198	* 5 -> 000b
199	* 10 -> 011b
200	*
201	* The third bit is always zero since there are only four outputs connected in the serial selector chip.
202	*
203	* The multiplication of the converted value by 0x24 sets the relevant bits in
204	* both channels and then we mask it out to only affect the channel currently
205	* requested.
206	*/
207	BOOL set_voltage(BYTE channel, BYTE val)
208	{
209	BYTE bits, mask;
210	switch (val) {
211	case 1:
212	bits = 0x24 * 2;
213	break;
214	case 2:
215	bits = 0x24 * 1;
216	break;
217	case 5:
218	bits = 0x24 * 0;
219	break;
220	case 10:
221	bits = 0x24 * 3;
222	break;
223	default:
224	return FALSE;
225	}
226
227	mask = channel ? 0xe0 : 0x1c;
228	IOC = (IOC & ~mask) \| (bits & mask);
229	return TRUE;
230	}
231
232	BOOL set_numchannels(BYTE numchannels)
233	{
234	if (numchannels == 1 \|\| numchannels == 2) {
235	BYTE fifocfg = 7 + numchannels;
236	EP2FIFOCFG = fifocfg;
237	EP6FIFOCFG = fifocfg;
238	return TRUE;
239	}
240	return FALSE;
241	}
242
243	void clear_fifo()
244	{
245	GPIFABORT = 0xff;
246	SYNCDELAY3;
247	FIFORESET = 0x80;
248	SYNCDELAY3;
249	FIFORESET = 0x82;
250	SYNCDELAY3;
251	FIFORESET = 0x86;
252	SYNCDELAY3;
253	FIFORESET = 0;
254	}
255
256	void stop_sampling()
257	{
258	GPIFABORT = 0xff;
259	SYNCDELAY3;
260	if (altiface == 0) {
261	INPKTEND = 6;
262	} else {
263	INPKTEND = 2;
264	}
265	}
266
267	void start_sampling()
268	{
269	int i;
270	clear_fifo();
271
272	for (i = 0; i < 1000; i++);
273	while (!(GPIFTRIG & 0x80)) {
274	;
275	}
276	SYNCDELAY3;
277	GPIFTCB1 = 0x28;
278	SYNCDELAY3;
279	GPIFTCB0 = 0;
280	if (altiface == 0)
281	GPIFTRIG = 6;
282	else
283	GPIFTRIG = 4;
284
285	// set green led
286	// don't clear led
287	ledcounter = 0;
288	PC0 = 1;
289	PC1 = 0;
290	}
291
292	extern __code BYTE highspd_dscr;
293	extern __code BYTE fullspd_dscr;
294	void select_interface(BYTE alt)
295	{
296	const BYTE *pPacketSize = (USBCS & bmHSM ? &highspd_dscr : &fullspd_dscr)
297	+ (9 + 16*alt + 9 + 4);
298	altiface = alt;
299	if (alt == 0) {
300	// bulk on port 6
301	EP2CFG = 0x00;
302	EP6CFG = 0xe0;
303	EP6GPIFFLGSEL = 1;
304
305	EP6AUTOINLENL = pPacketSize[0];
306	EP6AUTOINLENH = pPacketSize[1];
307	} else {
308	// iso on port 2
309	EP2CFG = 0xd8;
310	EP6CFG = 0x00;
311	EP2GPIFFLGSEL = 1;
312
313	EP2AUTOINLENL = pPacketSize[0];
314	EP2AUTOINLENH = pPacketSize[1] & 0x7;
315	EP2ISOINPKTS = (pPacketSize[1] >> 3) + 1;
316	}
317	}
318
319	const struct samplerate_info {
320	BYTE rate;
321	BYTE wait0;
322	BYTE wait1;
323	BYTE opc0;
324	BYTE opc1;
325	BYTE out0;
326	BYTE ifcfg;
327	} samplerates[] = {
328	{ 48,0x80, 0, 3, 0, 0x00, 0xea },
329	{ 30,0x80, 0, 3, 0, 0x00, 0xaa },
330	{ 24, 1, 0, 2, 1, 0x40, 0xca },
331	{ 16, 1, 1, 2, 0, 0x40, 0xca },
332	{ 12, 2, 1, 2, 0, 0x40, 0xca },
333	{ 8, 3, 2, 2, 0, 0x40, 0xca },
334	{ 4, 6, 5, 2, 0, 0x40, 0xca },
335	{ 2, 12, 11, 2, 0, 0x40, 0xca },
336	{ 1, 24, 23, 2, 0, 0x40, 0xca },
337	{ 50, 48, 47, 2, 0, 0x40, 0xca },
338	{ 20, 120, 119, 2, 0, 0x40, 0xca },
339	{ 10, 240, 239, 2, 0, 0x40, 0xca }
340	};
341
342	BOOL set_samplerate(BYTE rate)
343	{
344	BYTE i = 0;
345	while (samplerates[i].rate != rate) {
346	i++;
347	if (i == sizeof(samplerates)/sizeof(samplerates[0]))
348	return FALSE;
349	}
350
351	IFCONFIG = samplerates[i].ifcfg;
352
353	AUTOPTRSETUP = 7;
354	AUTOPTRH2 = 0xE4;
355	AUTOPTRL2 = 0x00;
356
357	/* The program for low-speed, e.g. 1 MHz, is
358	* wait 24, CTL2=0, FIFO
359	* wait 23, CTL2=1
360	* jump 0, CTL2=1
361	*
362	* The program for 24 MHz is
363	* wait 1, CTL2=0, FIFO
364	* jump 0, CTL2=1
365	*
366	* The program for 30/48 MHz is:
367	* jump 0, CTL2=Z, FIFO, LOOP
368	*/
369
370	EXTAUTODAT2 = samplerates[i].wait0;
371	EXTAUTODAT2 = samplerates[i].wait1;
372	EXTAUTODAT2 = 1;
373	EXTAUTODAT2 = 0;
374	EXTAUTODAT2 = 0;
375	EXTAUTODAT2 = 0;
376	EXTAUTODAT2 = 0;
377	EXTAUTODAT2 = 0;
378
379	EXTAUTODAT2 = samplerates[i].opc0;
380	EXTAUTODAT2 = samplerates[i].opc1;
381	EXTAUTODAT2 = 1;
382	EXTAUTODAT2 = 0;
383	EXTAUTODAT2 = 0;
384	EXTAUTODAT2 = 0;
385	EXTAUTODAT2 = 0;
386	EXTAUTODAT2 = 0;
387
388	EXTAUTODAT2 = samplerates[i].out0;
389	EXTAUTODAT2 = 0x44;
390	EXTAUTODAT2 = 0x44;
391	EXTAUTODAT2 = 0x00;
392	EXTAUTODAT2 = 0x00;
393	EXTAUTODAT2 = 0x00;
394	EXTAUTODAT2 = 0x00;
395	EXTAUTODAT2 = 0x00;
396
397	EXTAUTODAT2 = 0;
398	EXTAUTODAT2 = 0;
399	EXTAUTODAT2 = 0;
400	EXTAUTODAT2 = 0;
401	EXTAUTODAT2 = 0;
402	EXTAUTODAT2 = 0;
403	EXTAUTODAT2 = 0;
404	EXTAUTODAT2 = 0;
405
406	for (i = 0; i < 96; i++)
407	EXTAUTODAT2 = 0;
408	return TRUE;
409	}
410
189db3d4 UH	411	//************************ Configuration Handlers ***************************
	412
	413	// set *alt_ifc to the current alt interface for ifc
	414	BOOL handle_get_interface(BYTE ifc, BYTE* alt_ifc) {
	415	(void) ifc; // ignore unused parameter
	416	*alt_ifc=altiface;
	417	return TRUE;
	418	}
	419	// return TRUE if you set the interface requested
	420	// NOTE this function should reconfigure and reset the endpoints
	421	// according to the interface descriptors you provided.
	422	BOOL handle_set_interface(BYTE ifc,BYTE alt_ifc) {
	423	printf ( "Set Interface.\n" );
	424	if (ifc == 0) {
	425	select_interface(alt_ifc);
	426	}
	427	return TRUE;
	428	}
	429
	430	// handle getting and setting the configuration
	431	// 1 is the default. We don't support multiple configurations.
	432	BYTE handle_get_configuration() {
	433	return 0;
	434	}
	435
	436	BOOL handle_set_configuration(BYTE cfg) {
	437	(void) cfg; // ignore unused parameter
	438	return TRUE;
	439	}
	440
	441
	442	//***************** VENDOR COMMAND HANDLERS ************************
	443
	444	BOOL handle_vendorcommand(BYTE cmd) {
	445	stop_sampling();
	446	// Set Red LED
	447	PC0 = 0;
	448	PC1 = 1;
	449	ledcounter = 1000;
	450	switch (cmd) {
	451	case 0xe0:
	452	case 0xe1:
	453	EP0BCH=0;
	454	EP0BCL=0;
	455	while (EP0CS & bmEPBUSY);
	456	set_voltage(cmd - 0xe0, EP0BUF[0]);
	457	return TRUE;
	458	case 0xe2:
	459	EP0BCH=0;
	460	EP0BCL=0;
	461	while (EP0CS & bmEPBUSY);
	462	set_samplerate(EP0BUF[0]);
	463	return TRUE;
	464	case 0xe3:
	465	EP0BCH=0;
	466	EP0BCL=0;
	467	while (EP0CS & bmEPBUSY);
	468	if (EP0BUF[0] == 1)
	469	start_sampling();
	470	return TRUE;
	471	case 0xe4:
	472	EP0BCH=0;
	473	EP0BCL=0;
	474	while (EP0CS & bmEPBUSY);
475	set_numchannels(EP0BUF[0]);
476	return TRUE;
477	}
478	return FALSE; // not handled by handlers
479	}
480
481	//****************** INIT *********************
482
483	void main_init() {
484	EP4CFG = 0;
485	EP8CFG = 0;
486
487	// in idle mode tristate all outputs
488	GPIFIDLECTL = 0x00;
489	GPIFCTLCFG = 0x80;
490	GPIFWFSELECT = 0x00;
491	GPIFREADYSTAT = 0x00;
492
493	stop_sampling();
494	set_voltage(0, 1);
495	set_voltage(1, 1);
496	set_samplerate(1);
497	set_numchannels(2);
498	select_interface(0);
499
500	printf ( "Initialization Done.\n" );
501	}
502
503
504	void main_loop() {
505	}
506
507