1 /***************************************************************************
2 * Copyright (C) 2007 by Benedikt Sauter sauter@ixbat.de *
3 * based on Dominic Rath's usbprog.c *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program 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 *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
24 #include "replacements.h"
36 int usbprog_execute_queue(void);
37 int usbprog_speed(int speed);
38 int usbprog_register_commands(struct command_context_s *cmd_ctx);
39 int usbprog_init(void);
40 int usbprog_quit(void);
43 void usbprog_end_state(enum tap_state state);
44 void usbprog_state_move(void);
45 void usbprog_path_move(pathmove_command_t *cmd);
46 void usbprog_runtest(int num_cycles);
47 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size);
49 jtag_interface_t usbprog_interface =
53 .execute_queue = usbprog_execute_queue,
55 .support_pathmove = 0,
57 .speed = usbprog_speed,
58 .register_commands = usbprog_register_commands,
69 #define UNKOWN_COMMAND 0x00
70 #define PORT_DIRECTION 0x01
73 #define PORT_SETBIT 0x04
74 #define PORT_GETBIT 0x05
75 #define WRITE_TDI 0x06
77 #define WRITE_AND_READ 0x08
78 #define WRITE_TMS 0x09
82 struct usb_dev_handle* usb_handle;
85 struct usbprog_jtag * usbprog_jtag_handle;
87 struct usbprog_jtag* usbprog_jtag_open();
88 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
89 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
90 unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
93 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
94 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
95 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
96 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan);
98 void usbprog_write(int tck, int tms, int tdi);
99 void usbprog_reset(int trst, int srst);
101 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction);
102 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value);
103 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
104 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value);
105 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
107 int usbprog_speed(int speed)
112 int usbprog_register_commands(struct command_context_s *cmd_ctx)
118 int usbprog_execute_queue(void)
120 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
130 #ifdef _DEBUG_JTAG_IO_
131 DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
133 if (cmd->cmd.end_state->end_state != -1)
134 usbprog_end_state(cmd->cmd.end_state->end_state);
137 #ifdef _DEBUG_JTAG_IO_
138 DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
140 if (cmd->cmd.reset->trst == 1)
144 usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
147 #ifdef _DEBUG_JTAG_IO_
148 DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
150 if (cmd->cmd.runtest->end_state != -1)
151 usbprog_end_state(cmd->cmd.runtest->end_state);
152 usbprog_runtest(cmd->cmd.runtest->num_cycles);
155 #ifdef _DEBUG_JTAG_IO_
156 DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
158 if (cmd->cmd.statemove->end_state != -1)
159 usbprog_end_state(cmd->cmd.statemove->end_state);
160 usbprog_state_move();
163 #ifdef _DEBUG_JTAG_IO_
164 DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
165 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
167 usbprog_path_move(cmd->cmd.pathmove);
170 #ifdef _DEBUG_JTAG_IO_
171 DEBUG("scan end in %i", cmd->cmd.scan->end_state);
173 if (cmd->cmd.scan->end_state != -1)
174 usbprog_end_state(cmd->cmd.scan->end_state);
175 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
176 type = jtag_scan_type(cmd->cmd.scan);
177 usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
178 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
179 return ERROR_JTAG_QUEUE_FAILED;
184 #ifdef _DEBUG_JTAG_IO_
185 DEBUG("sleep %i", cmd->cmd.sleep->us);
187 jtag_sleep(cmd->cmd.sleep->us);
190 ERROR("BUG: unknown JTAG command type encountered");
200 int usbprog_init(void)
202 usbprog_jtag_handle = usbprog_jtag_open();
204 if(usbprog_jtag_handle==0){
205 ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
206 return ERROR_JTAG_INIT_FAILED;
209 INFO("USB JTAG Interface ready!");
211 usbprog_jtag_init(usbprog_jtag_handle);
213 usbprog_write(0, 0, 0);
218 int usbprog_quit(void)
224 /*************** jtag execute commands **********************/
225 void usbprog_end_state(enum tap_state state)
227 if (tap_move_map[state] != -1)
231 ERROR("BUG: %i is not a valid end state", state);
237 void usbprog_state_move(void) {
240 u8 tms_scan = TAP_MOVE(cur_state, end_state);
242 usbprog_jtag_write_tms(usbprog_jtag_handle,(char)tms_scan);
243 for (i = 0; i < 7; i++)
245 tms = (tms_scan >> i) & 1;
248 // moved into firmware
250 // koennte man in tms verlagern
251 //usbprog_write(0, tms, 0);
253 cur_state = end_state;
257 void usbprog_path_move(pathmove_command_t *cmd)
259 int num_states = cmd->num_states;
265 if (tap_transitions[cur_state].low == cmd->path[state_count])
268 usbprog_write(0, 0, 0);
269 usbprog_write(1, 0, 0);
271 else if (tap_transitions[cur_state].high == cmd->path[state_count])
274 usbprog_write(0, 1, 0);
275 usbprog_write(1, 1, 0);
279 ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
283 cur_state = cmd->path[state_count];
288 end_state = cur_state;
292 void usbprog_runtest(int num_cycles)
296 enum tap_state saved_end_state = end_state;
298 /* only do a state_move when we're not already in RTI */
299 if (cur_state != TAP_RTI)
301 usbprog_end_state(TAP_RTI);
303 usbprog_state_move();
306 /* execute num_cycles */
310 usbprog_write(0, 0, 0);
312 for (i = 0; i < num_cycles; i++)
315 usbprog_write(1, 0, 0);
316 usbprog_write(0, 0, 0);
319 /* finish in end_state */
321 usbprog_end_state(saved_end_state);
322 if (cur_state != end_state)
323 usbprog_state_move();
329 void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
331 enum tap_state saved_end_state = end_state;
335 usbprog_end_state(TAP_SI);
337 usbprog_end_state(TAP_SD);
340 usbprog_state_move();
341 usbprog_end_state(saved_end_state);
343 if (type == SCAN_OUT) {
344 usbprog_jtag_write_tdi(usbprog_jtag_handle,buffer, scan_size);
346 if (type == SCAN_IN) {
347 usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
349 if (type == SCAN_IO) {
350 usbprog_jtag_write_and_read(usbprog_jtag_handle,buffer, scan_size);
358 if (cur_state != end_state)
359 usbprog_state_move();
362 /*************** jtag wrapper functions *********************/
364 void usbprog_write(int tck, int tms, int tdi)
366 //INFO("->USBPROG SLICE");
367 //DEBUG("slice tck %i tms %i tdi %i",tck,tms,tdi);
368 unsigned char output_value=0x00;
371 output_value |= (1<<TMS_BIT);
373 output_value |= (1<<TDI_BIT);
375 output_value |= (1<<TCK_BIT);
377 usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
380 /* (1) assert or (0) deassert reset lines */
381 void usbprog_reset(int trst, int srst)
383 //INFO("->USBPROG RESET");
384 DEBUG("trst: %i, srst: %i", trst, srst);
387 usbprog_jtag_set_bit(usbprog_jtag_handle,5,0);
389 usbprog_jtag_set_bit(usbprog_jtag_handle,5,1);
392 usbprog_jtag_set_bit(usbprog_jtag_handle,4,0);
394 usbprog_jtag_set_bit(usbprog_jtag_handle,4,1);
399 /*************** jtag lowlevel functions ********************/
402 struct usbprog_jtag* usbprog_jtag_open()
404 struct usb_bus *busses;
405 struct usb_dev_handle* usb_handle;
407 struct usb_device *dev;
409 struct usbprog_jtag * tmp;
411 tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
418 busses = usb_get_busses();
420 /* find usbprog_jtag device in usb bus */
422 for (bus = busses; bus; bus = bus->next){
423 for (dev = bus->devices; dev; dev = dev->next){
424 /* condition for sucessfully hit (too bad, I only check the vendor id)*/
425 if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
426 tmp->usb_handle = usb_open(dev);
427 usb_set_configuration (tmp->usb_handle,dev->config[0].bConfigurationValue);
428 usb_claim_interface(tmp->usb_handle, 0);
429 usb_set_altinterface(tmp->usb_handle,0);
438 void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
440 usb_close(usbprog_jtag->usb_handle);
445 unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
447 int res = usb_bulk_write(usbprog_jtag->usb_handle,3,msg,msglen,100);
451 res = usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
453 return (unsigned char)msg[1];
462 void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
464 usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
468 void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
470 char tmp[64]; // fastes packet size for usb controller
471 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
474 // 61 byte can be transfered (488 bit)
487 tmp[0] = WRITE_AND_READ;
488 tmp[1] = (char)(send_bits>>8); // high
489 tmp[2] = (char)(send_bits); // low
492 for(i=0;i < loops ;i++) {
493 tmp[3+i]=buffer[bufindex];
497 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
499 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1);
501 for(i=0;i<loops ;i++) {
503 buffer[fillindex++] = swap;
509 void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
511 char tmp[64]; // fastes packet size for usb controller
512 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
515 // 61 byte can be transfered (488 bit)
528 tmp[0] = WRITE_AND_READ;
529 tmp[1] = (char)(send_bits>>8); // high
530 tmp[2] = (char)(send_bits); // low
532 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
534 while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1);
536 for(i=0;i<loops ;i++) {
538 buffer[fillindex++] = swap;
543 void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
545 char tmp[64]; // fastes packet size for usb controller
546 int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
548 // 61 byte can be transfered (488 bit)
562 tmp[1] = (char)(send_bits>>8); // high
563 tmp[2] = (char)(send_bits); // low
566 for(i=0;i < loops ;i++) {
567 tmp[3+i]=buffer[bufindex];
570 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
575 void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
577 char tmp[2]; // fastes packet size for usb controller
580 usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,2,1000);
584 void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
587 tmp[0] = PORT_DIRECTION;
588 tmp[1] = (char)direction;
589 usbprog_jtag_message(usbprog_jtag,tmp,2);
592 void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
596 tmp[1] = (char)value;
597 usbprog_jtag_message(usbprog_jtag,tmp,2);
600 unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
605 return usbprog_jtag_message(usbprog_jtag,tmp,2);
609 void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
612 tmp[0] = PORT_SETBIT;
618 usbprog_jtag_message(usbprog_jtag,tmp,3);
621 int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
624 tmp[0] = PORT_GETBIT;
627 if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)