git.sur5r.net Git - openocd/blob - src/jtag/amt_jtagaccel.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2005 by Dominic Rath                                    *\r
   3  *   Dominic.Rath@gmx.de                                                   *\r
   4  *                                                                         *\r
   5  *   This program is free software; you can redistribute it and/or modify  *\r
   6  *   it under the terms of the GNU General Public License as published by  *\r
   7  *   the Free Software Foundation; either version 2 of the License, or     *\r
   8  *   (at your option) any later version.                                   *\r
   9  *                                                                         *\r
  10  *   This program is distributed in the hope that it will be useful,       *\r
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  13  *   GNU General Public License for more details.                          *\r
  14  *                                                                         *\r
  15  *   You should have received a copy of the GNU General Public License     *\r
  16  *   along with this program; if not, write to the                         *\r
  17  *   Free Software Foundation, Inc.,                                       *\r
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  19  ***************************************************************************/\r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "replacements.h"\r
  25 \r
  26 #include "jtag.h"\r
  27 \r
  28 /* system includes */\r
  29 \r
  30 #ifdef _WIN32\r
  31 #include "errno.h"\r
  32 #endif /* _WIN32 */\r
  33 \r
  34 #include <string.h>\r
  35 #include <stdlib.h>\r
  36 \r
  37 #include <sys/time.h>\r
  38 #include <time.h>\r
  39 \r
  40 #if PARPORT_USE_PPDEV == 1\r
  41 #include <linux/parport.h>\r
  42 #include <linux/ppdev.h>\r
  43 #include <fcntl.h>\r
  44 #include <sys/ioctl.h>\r
  45 #include <unistd.h>\r
  46 #else /* not PARPORT_USE_PPDEV */\r
  47 #ifndef _WIN32\r
  48 #include <sys/io.h>\r
  49 #endif\r
  50 #endif\r
  51 \r
  52 #if PARPORT_USE_GIVEIO == 1\r
  53 #if IS_CYGWIN == 1\r
  54 #include <windows.h>\r
  55 #include <errno.h>\r
  56 #undef ERROR\r
  57 #endif\r
  58 #endif\r
  59 \r
  60 #include "log.h"\r
  61 \r
  62 /* configuration */\r
  63 u16 amt_jtagaccel_port;\r
  64 \r
  65 /* interface variables\r
  66  */\r
  67 static u8 aw_control_rst = 0x00;\r
  68 static u8 aw_control_fsm = 0x10;\r
  69 static u8 aw_control_baudrate = 0x20;\r
  70 \r
  71 static int rtck_enabled = 0;\r
  72 \r
  73 #if PARPORT_USE_PPDEV == 1\r
  74 static int device_handle;\r
  75 int addr_mode = IEEE1284_MODE_EPP | IEEE1284_ADDR ;\r
  76 int data_mode = IEEE1284_MODE_EPP | IEEE1284_DATA ;\r
  77 #define AMT_AW(val)     do { ioctl(device_handle, PPSETMODE, &addr_mode); write(device_handle, &val, 1); } while (0)\r
  78 #define AMT_AR(val)     do { ioctl(device_handle, PPSETMODE, &addr_mode); read(device_handle, &val, 1); } while (0)\r
  79 #define AMT_DW(val)     do { ioctl(device_handle, PPSETMODE, &data_mode); write(device_handle, &val, 1); } while (0)\r
  80 #define AMT_DR(val)     do { ioctl(device_handle, PPSETMODE, &data_mode); read(device_handle, &val, 1); } while (0)\r
  81 #else\r
  82 #define AMT_AW(val)     do { outb(val, amt_jtagaccel_port + 3); } while (0)\r
  83 #define AMT_AR(val)     do { val = inb(amt_jtagaccel_port + 3); } while (0)\r
  84 #define AMT_DW(val)     do { outb(val, amt_jtagaccel_port + 4); } while (0)\r
  85 #define AMT_DR(val)     do { val = inb(amt_jtagaccel_port + 4); } while (0)\r
  86 #endif\r
  87 \r
  88 int amt_jtagaccel_execute_queue(void);\r
  89 int amt_jtagaccel_register_commands(struct command_context_s *cmd_ctx);\r
  90 int amt_jtagaccel_speed(int speed);\r
  91 int amt_jtagaccel_init(void);\r
  92 int amt_jtagaccel_quit(void);\r
  93 \r
  94 int amt_jtagaccel_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);\r
  95 int amt_jtagaccel_handle_rtck_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);\r
  96 \r
  97 /* tap_move[i][j]: tap movement command to go from state i to state j\r
  98  * 0: Test-Logic-Reset\r
  99  * 1: Run-Test/Idle\r
 100  * 2: Shift-DR\r
 101  * 3: Pause-DR\r
 102  * 4: Shift-IR\r
 103  * 5: Pause-IR\r
 104  */\r
 105 u8 amt_jtagaccel_tap_move[6][6][2] =\r
 106 {\r
 107         /*         TLR           RTI              SD            PD            SI            PI             */\r
 108         {{0x1f, 0x00}, {0x0f, 0x00}, {0x8a, 0x04}, {0x0a, 0x00}, {0x06, 0x00}, {0x96, 0x00}},   /* TLR */\r
 109         {{0x1f, 0x00}, {0x00, 0x00}, {0x85, 0x08}, {0x05, 0x00}, {0x8b, 0x08}, {0x0b, 0x00}},   /* RTI */\r
 110         {{0x1f, 0x00}, {0x0d, 0x00}, {0x00, 0x00}, {0x01, 0x00}, {0x8f, 0x09}, {0x8f, 0x01}},   /* SD  */\r
 111         {{0x1f, 0x00}, {0x0c, 0x00}, {0x08, 0x00}, {0x00, 0x00}, {0x8f, 0x09}, {0x8f, 0x01}},   /* PD  */\r
 112         {{0x1f, 0x00}, {0x0d, 0x00}, {0x07, 0x00}, {0x97, 0x00}, {0x00, 0x00}, {0x01, 0x00}},   /* SI  */\r
 113         {{0x1f, 0x00}, {0x0c, 0x00}, {0x07, 0x00}, {0x97, 0x00}, {0x08, 0x00}, {0x00, 0x00}},   /* PI  */\r
 114 };\r
 115 \r
 116 jtag_interface_t amt_jtagaccel_interface = \r
 117 {\r
 118         .name = "amt_jtagaccel",\r
 119         \r
 120         .execute_queue = amt_jtagaccel_execute_queue,\r
 121 \r
 122         .speed = amt_jtagaccel_speed,   \r
 123         .register_commands = amt_jtagaccel_register_commands,\r
 124         .init = amt_jtagaccel_init,\r
 125         .quit = amt_jtagaccel_quit,\r
 126 };\r
 127 \r
 128 int amt_jtagaccel_register_commands(struct command_context_s *cmd_ctx)\r
 129 {\r
 130         register_command(cmd_ctx, NULL, "parport_port", amt_jtagaccel_handle_parport_port_command,\r
 131                                          COMMAND_CONFIG, NULL);\r
 132         register_command(cmd_ctx, NULL, "rtck", amt_jtagaccel_handle_rtck_command,\r
 133                                          COMMAND_CONFIG, NULL);\r
 134         \r
 135         return ERROR_OK;\r
 136 }\r
 137 \r
 138 void amt_jtagaccel_reset(int trst, int srst)\r
 139 {\r
 140         if (trst == 1)\r
 141                 aw_control_rst |= 0x4;\r
 142         else if (trst == 0)\r
 143                 aw_control_rst &= ~0x4;\r
 144 \r
 145         if (srst == 1)\r
 146                 aw_control_rst |= 0x1;\r
 147         else if (srst == 0)\r
 148                 aw_control_rst &= ~0x1;\r
 149         \r
 150         AMT_AW(aw_control_rst);\r
 151 }\r
 152 \r
 153 int amt_jtagaccel_speed(int speed)\r
 154 {\r
 155         aw_control_baudrate &= 0xf0;\r
 156         aw_control_baudrate |= speed & 0x0f;\r
 157         AMT_AW(aw_control_baudrate);\r
 158         \r
 159         return ERROR_OK;\r
 160 }\r
 161 \r
 162 void amt_jtagaccel_end_state(state)\r
 163 {\r
 164         if (tap_move_map[state] != -1)\r
 165                 end_state = state;\r
 166         else\r
 167         {\r
 168                 ERROR("BUG: %i is not a valid end state", state);\r
 169                 exit(-1);\r
 170         }\r
 171 }\r
 172 \r
 173 void amt_wait_scan_busy()\r
 174 {\r
 175         int timeout = 4096;\r
 176         u8 ar_status;\r
 177         \r
 178         AMT_AR(ar_status);\r
 179         while (((ar_status) & 0x80) && (timeout-- > 0))\r
 180                 AMT_AR(ar_status);\r
 181         \r
 182         if (ar_status & 0x80)\r
 183         {\r
 184                 ERROR("amt_jtagaccel timed out while waiting for end of scan, rtck was %s, last AR_STATUS: 0x%2.2x", (rtck_enabled) ? "enabled" : "disabled", ar_status);\r
 185                 exit(-1);\r
 186         }\r
 187 }\r
 188 \r
 189 void amt_jtagaccel_state_move(void)\r
 190 {\r
 191         u8 aw_scan_tms_5;\r
 192         u8 tms_scan[2];\r
 193          \r
 194         tms_scan[0] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][0];\r
 195         tms_scan[1] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][1];\r
 196         \r
 197         aw_scan_tms_5 = 0x40 | (tms_scan[0] & 0x1f);\r
 198         AMT_AW(aw_scan_tms_5);\r
 199         if (jtag_speed > 3 || rtck_enabled)\r
 200                 amt_wait_scan_busy();\r
 201                 \r
 202         if (tms_scan[0] & 0x80)\r
 203         {\r
 204                 aw_scan_tms_5 = 0x40 | (tms_scan[1] & 0x1f);\r
 205                 AMT_AW(aw_scan_tms_5);\r
 206                 if (jtag_speed > 3 || rtck_enabled)\r
 207                         amt_wait_scan_busy();\r
 208         }\r
 209         \r
 210         cur_state = end_state;\r
 211 }\r
 212 \r
 213 void amt_jtagaccel_runtest(int num_cycles)\r
 214 {\r
 215         int i = 0;\r
 216         u8 aw_scan_tms_5;\r
 217         u8 aw_scan_tms_1to4;\r
 218 \r
 219         enum tap_state saved_end_state = end_state;\r
 220         \r
 221         /* only do a state_move when we're not already in RTI */\r
 222         if (cur_state != TAP_RTI)\r
 223         {\r
 224                 amt_jtagaccel_end_state(TAP_RTI);\r
 225                 amt_jtagaccel_state_move();\r
 226         }\r
 227         \r
 228         while (num_cycles - i >= 5)\r
 229         {\r
 230                 aw_scan_tms_5 = 0x40;\r
 231                 AMT_AW(aw_scan_tms_5);\r
 232                 i += 5;\r
 233         }\r
 234         \r
 235         if (num_cycles - i > 0)\r
 236         {\r
 237                 aw_scan_tms_1to4 = 0x80 | ((num_cycles - i - 1) & 0x3) << 4;\r
 238                 AMT_AW(aw_scan_tms_1to4);\r
 239         }\r
 240         \r
 241         amt_jtagaccel_end_state(saved_end_state);\r
 242         if (cur_state != end_state)\r
 243                 amt_jtagaccel_state_move();\r
 244 }\r
 245 \r
 246 void amt_jtagaccel_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)\r
 247 {\r
 248         int bits_left = scan_size;\r
 249         int bit_count = 0;\r
 250         enum tap_state saved_end_state = end_state;\r
 251         u8 aw_tdi_option;\r
 252         u8 dw_tdi_scan;\r
 253         u8 dr_tdo;\r
 254         u8 aw_tms_scan;\r
 255         u8 tms_scan[2];\r
 256 \r
 257         if (ir_scan)\r
 258                 amt_jtagaccel_end_state(TAP_SI);\r
 259         else\r
 260                 amt_jtagaccel_end_state(TAP_SD);\r
 261 \r
 262         amt_jtagaccel_state_move();\r
 263         amt_jtagaccel_end_state(saved_end_state);\r
 264 \r
 265         /* handle unaligned bits at the beginning */\r
 266         if ((scan_size - 1) % 8)\r
 267         {\r
 268                 aw_tdi_option = 0x30 | (((scan_size - 1) % 8) - 1);\r
 269                 AMT_AW(aw_tdi_option);\r
 270                 \r
 271                 dw_tdi_scan = buf_get_u32(buffer, bit_count, (scan_size - 1) % 8) & 0xff;\r
 272                 AMT_DW(dw_tdi_scan);\r
 273                 if (jtag_speed > 3 || rtck_enabled)\r
 274                         amt_wait_scan_busy();\r
 275 \r
 276                 if ((type == SCAN_IN) || (type == SCAN_IO))\r
 277                 {\r
 278                         AMT_DR(dr_tdo);\r
 279                         dr_tdo = dr_tdo >> (8 - ((scan_size - 1) % 8));\r
 280                         buf_set_u32(buffer, bit_count, (scan_size - 1) % 8, dr_tdo);\r
 281                 }\r
 282                 \r
 283                 bit_count += (scan_size - 1) % 8;\r
 284                 bits_left -= (scan_size - 1) % 8;\r
 285         }\r
 286         \r
 287         while (bits_left - 1 >= 8)\r
 288         {\r
 289                 dw_tdi_scan = buf_get_u32(buffer, bit_count, 8) & 0xff;\r
 290                 AMT_DW(dw_tdi_scan);\r
 291                 if (jtag_speed > 3 || rtck_enabled)\r
 292                         amt_wait_scan_busy();\r
 293 \r
 294                 if ((type == SCAN_IN) || (type == SCAN_IO))\r
 295                 {\r
 296                         AMT_DR(dr_tdo);\r
 297                         buf_set_u32(buffer, bit_count, 8, dr_tdo);\r
 298                 }\r
 299                                 \r
 300                 bit_count += 8;\r
 301                 bits_left -= 8;\r
 302         }\r
 303                 \r
 304         tms_scan[0] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][0];\r
 305         tms_scan[1] = amt_jtagaccel_tap_move[tap_move_map[cur_state]][tap_move_map[end_state]][1];\r
 306         aw_tms_scan = 0x40 | (tms_scan[0] & 0x1f) | (buf_get_u32(buffer, bit_count, 1) << 5);\r
 307         AMT_AW(aw_tms_scan);\r
 308         if (jtag_speed > 3 || rtck_enabled)\r
 309                 amt_wait_scan_busy();\r
 310 \r
 311         if ((type == SCAN_IN) || (type == SCAN_IO))\r
 312         {\r
 313                 AMT_DR(dr_tdo);\r
 314                 dr_tdo = dr_tdo >> 7;\r
 315                 buf_set_u32(buffer, bit_count, 1, dr_tdo);\r
 316         }\r
 317         \r
 318         if (tms_scan[0] & 0x80)\r
 319         {\r
 320                 aw_tms_scan = 0x40 | (tms_scan[1] & 0x1f);\r
 321                 AMT_AW(aw_tms_scan);\r
 322                 if (jtag_speed > 3 || rtck_enabled)\r
 323                         amt_wait_scan_busy();\r
 324         }\r
 325         cur_state = end_state;\r
 326 }\r
 327 \r
 328 int amt_jtagaccel_execute_queue(void)\r
 329 {\r
 330         jtag_command_t *cmd = jtag_command_queue; /* currently processed command */\r
 331         int scan_size;\r
 332         enum scan_type type;\r
 333         u8 *buffer;\r
 334         int retval;\r
 335         \r
 336         /* return ERROR_OK, unless a jtag_read_buffer returns a failed check\r
 337          * that wasn't handled by a caller-provided error handler\r
 338          */ \r
 339         retval = ERROR_OK;\r
 340                 \r
 341         while (cmd)\r
 342         {\r
 343                 switch (cmd->type)\r
 344                 {\r
 345                         case JTAG_END_STATE:\r
 346 #ifdef _DEBUG_JTAG_IO_\r
 347                                 DEBUG("end_state: %i", cmd->cmd.end_state->end_state);\r
 348 #endif\r
 349                                 if (cmd->cmd.end_state->end_state != -1)\r
 350                                         amt_jtagaccel_end_state(cmd->cmd.end_state->end_state);\r
 351                                 break;\r
 352                         case JTAG_RESET:\r
 353 #ifdef _DEBUG_JTAG_IO_\r
 354                                 DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);\r
 355 #endif\r
 356                                 if (cmd->cmd.reset->trst == 1)\r
 357                                 {\r
 358                                         cur_state = TAP_TLR;\r
 359                                 }\r
 360                                 amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);\r
 361                                 break;\r
 362                         case JTAG_RUNTEST:\r
 363 #ifdef _DEBUG_JTAG_IO_\r
 364                                 DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);\r
 365 #endif\r
 366                                 if (cmd->cmd.runtest->end_state != -1)\r
 367                                         amt_jtagaccel_end_state(cmd->cmd.runtest->end_state);\r
 368                                 amt_jtagaccel_runtest(cmd->cmd.runtest->num_cycles);\r
 369                                 break;\r
 370                         case JTAG_STATEMOVE:\r
 371 #ifdef _DEBUG_JTAG_IO_\r
 372                                 DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);\r
 373 #endif\r
 374                                 if (cmd->cmd.statemove->end_state != -1)\r
 375                                         amt_jtagaccel_end_state(cmd->cmd.statemove->end_state);\r
 376                                 amt_jtagaccel_state_move();\r
 377                                 break;\r
 378                         case JTAG_SCAN:\r
 379 #ifdef _DEBUG_JTAG_IO_\r
 380                                 DEBUG("scan end in %i", cmd->cmd.scan->end_state);\r
 381 #endif\r
 382                                 if (cmd->cmd.scan->end_state != -1)\r
 383                                         amt_jtagaccel_end_state(cmd->cmd.scan->end_state);\r
 384                                 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);\r
 385                                 type = jtag_scan_type(cmd->cmd.scan);\r
 386                                 amt_jtagaccel_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);\r
 387                                 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)\r
 388                                         retval = ERROR_JTAG_QUEUE_FAILED;\r
 389                                 if (buffer)\r
 390                                         free(buffer);\r
 391                                 break;\r
 392                         case JTAG_SLEEP:\r
 393 #ifdef _DEBUG_JTAG_IO_\r
 394                                 DEBUG("sleep %i", cmd->cmd.sleep->us);\r
 395 #endif\r
 396                                 jtag_sleep(cmd->cmd.sleep->us);\r
 397                                 break;\r
 398                         default:\r
 399                                 ERROR("BUG: unknown JTAG command type encountered");\r
 400                                 exit(-1);\r
 401                 }\r
 402                 cmd = cmd->next;\r
 403         }\r
 404         \r
 405         return retval;\r
 406 }\r
 407 \r
 408 #if PARPORT_USE_GIVEIO == 1\r
 409 int amt_jtagaccel_get_giveio_access()\r
 410 {\r
 411     HANDLE h;\r
 412     OSVERSIONINFO version;\r
 413 \r
 414     version.dwOSVersionInfoSize = sizeof version;\r
 415     if (!GetVersionEx( &version )) {\r
 416         errno = EINVAL;\r
 417         return -1;\r
 418     }\r
 419     if (version.dwPlatformId != VER_PLATFORM_WIN32_NT)\r
 420         return 0;\r
 421 \r
 422     h = CreateFile( "\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );\r
 423     if (h == INVALID_HANDLE_VALUE) {\r
 424         errno = ENODEV;\r
 425         return -1;\r
 426     }\r
 427 \r
 428     CloseHandle( h );\r
 429 \r
 430     return 0;\r
 431 }\r
 432 #endif\r
 433 \r
 434 int amt_jtagaccel_init(void)\r
 435 {\r
 436 #if PARPORT_USE_PPDEV == 1\r
 437         char buffer[256];\r
 438         int i = 0;\r
 439         u8 control_port;\r
 440 #else\r
 441         u8 status_port;\r
 442 #endif\r
 443         u8 ar_status;\r
 444         \r
 445 #if PARPORT_USE_PPDEV == 1\r
 446         if (device_handle > 0)\r
 447         {\r
 448                 ERROR("device is already opened");\r
 449                 return ERROR_JTAG_INIT_FAILED;\r
 450         }\r
 451 \r
 452         snprintf(buffer, 256, "/dev/parport%d", amt_jtagaccel_port);\r
 453         device_handle = open(buffer, O_RDWR);\r
 454         \r
 455         if (device_handle < 0)\r
 456         {\r
 457                 ERROR("cannot open device. check it exists and that user read and write rights are set");\r
 458                 return ERROR_JTAG_INIT_FAILED;\r
 459         }\r
 460 \r
 461         i = ioctl(device_handle, PPCLAIM);\r
 462         if (i < 0)\r
 463         {\r
 464                 ERROR("cannot claim device");\r
 465                 return ERROR_JTAG_INIT_FAILED;\r
 466         }\r
 467 \r
 468         i = IEEE1284_MODE_EPP;\r
 469         i = ioctl(device_handle, PPSETMODE, & i);\r
 470         if (i < 0)\r
 471         {\r
 472                 ERROR(" cannot set compatible mode to device");\r
 473                 return ERROR_JTAG_INIT_FAILED;\r
 474         }\r
 475         \r
 476         control_port = 0x00;\r
 477         i = ioctl(device_handle, PPWCONTROL, &control_port);\r
 478 \r
 479         control_port = 0x04;\r
 480         i = ioctl(device_handle, PPWCONTROL, &control_port);\r
 481 \r
 482 #else\r
 483         if (amt_jtagaccel_port == 0)\r
 484         {\r
 485                 amt_jtagaccel_port = 0x378;\r
 486                 WARNING("No parport port specified, using default '0x378' (LPT1)");\r
 487         }\r
 488 \r
 489 #if PARPORT_USE_GIVEIO == 1\r
 490         if (amt_jtagaccel_get_giveio_access() != 0) {\r
 491 #else /* PARPORT_USE_GIVEIO */  \r
 492         if (ioperm(amt_jtagaccel_port, 5, 1) != 0) {\r
 493 #endif /* PARPORT_USE_GIVEIO */\r
 494                 ERROR("missing privileges for direct i/o");\r
 495                 return ERROR_JTAG_INIT_FAILED;\r
 496         }\r
 497         \r
 498         /* prepare epp port */\r
 499         /* clear timeout */\r
 500         status_port = inb(amt_jtagaccel_port + 1);\r
 501         outb(status_port | 0x1, amt_jtagaccel_port + 1);\r
 502         \r
 503         /* reset epp port */\r
 504         outb(0x00, amt_jtagaccel_port + 2);\r
 505         outb(0x04, amt_jtagaccel_port + 2);\r
 506 #endif\r
 507         \r
 508         if (rtck_enabled)\r
 509         {       \r
 510                 /* set RTCK enable bit */\r
 511                 aw_control_fsm |= 0x02;\r
 512         }\r
 513         \r
 514         /* enable JTAG port */\r
 515         aw_control_fsm |= 0x04;\r
 516         AMT_AW(aw_control_fsm);\r
 517         \r
 518         amt_jtagaccel_speed(jtag_speed);\r
 519         \r
 520         if (jtag_reset_config & RESET_TRST_OPEN_DRAIN)\r
 521                 aw_control_rst &= ~0x8;\r
 522         else\r
 523                 aw_control_rst |= 0x8;\r
 524         \r
 525         if (jtag_reset_config & RESET_SRST_PUSH_PULL)\r
 526                 aw_control_rst &= ~0x2;\r
 527         else\r
 528                 aw_control_rst |= 0x2;\r
 529         \r
 530         amt_jtagaccel_reset(0, 0);\r
 531         \r
 532         /* read status register */\r
 533         AMT_AR(ar_status);\r
 534         DEBUG("AR_STATUS: 0x%2.2x", ar_status);\r
 535         \r
 536         return ERROR_OK;\r
 537 }\r
 538 \r
 539 int amt_jtagaccel_quit(void)\r
 540 {\r
 541         \r
 542         return ERROR_OK;\r
 543 }\r
 544 \r
 545 int amt_jtagaccel_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
 546 {\r
 547         if (argc == 0)\r
 548                 return ERROR_OK;\r
 549 \r
 550         /* only if the port wasn't overwritten by cmdline */\r
 551         if (amt_jtagaccel_port == 0)\r
 552                 amt_jtagaccel_port = strtoul(args[0], NULL, 0);\r
 553 \r
 554         return ERROR_OK;\r
 555 }\r
 556 \r
 557 int amt_jtagaccel_handle_rtck_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
 558 {\r
 559         if (argc == 0)\r
 560         {\r
 561                 command_print(cmd_ctx, "amt_jtagaccel RTCK feature %s", (rtck_enabled) ? "enabled" : "disabled");\r
 562                 return ERROR_OK;\r
 563         }\r
 564         else\r
 565         {\r
 566                 if (strcmp(args[0], "enabled") == 0)\r
 567                 {\r
 568                         rtck_enabled = 1;\r
 569                 }\r
 570                 else\r
 571                 {\r
 572                         rtck_enabled = 0;\r
 573                 }\r
 574         }\r
 575         \r
 576         return ERROR_OK;\r
 577 }\r