git.gag.com Git - fw/openocd/blob - src/jtag/gw16012.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2006 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 #if 1\r
  29 #define _DEBUG_GW16012_IO_\r
  30 #endif\r
  31 \r
  32 /* system includes */\r
  33 // -ino: 060521-1036\r
  34 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
  35 \r
  36 #include <sys/types.h>\r
  37 #include <machine/sysarch.h>\r
  38 #include <machine/cpufunc.h>\r
  39 #define ioperm(startport,length,enable)\\r
  40   i386_set_ioperm((startport), (length), (enable))\r
  41 \r
  42 #else\r
  43 \r
  44 #ifdef _WIN32\r
  45 #include "errno.h"\r
  46 #endif /* _WIN32 */\r
  47 \r
  48 #endif /* __FreeBSD__, __FreeBSD_kernel__ */\r
  49 \r
  50 #include <string.h>\r
  51 #include <stdlib.h>\r
  52 \r
  53 #include <sys/time.h>\r
  54 #include <time.h>\r
  55 \r
  56 #if PARPORT_USE_PPDEV == 1\r
  57 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
  58 #include <dev/ppbus/ppi.h>\r
  59 #include <dev/ppbus/ppbconf.h>\r
  60 #define PPRSTATUS       PPIGSTATUS\r
  61 #define PPWDATA         PPISDATA\r
  62 #else\r
  63 #include <linux/parport.h>\r
  64 #include <linux/ppdev.h>\r
  65 #endif\r
  66 #include <fcntl.h>\r
  67 #include <sys/ioctl.h>\r
  68 #else /* not PARPORT_USE_PPDEV */\r
  69 #ifndef _WIN32\r
  70 #include <sys/io.h>\r
  71 #endif\r
  72 #endif\r
  73 \r
  74 #if PARPORT_USE_GIVEIO == 1\r
  75 #if IS_CYGWIN == 1\r
  76 #include <windows.h>\r
  77 #include <errno.h>\r
  78 #undef ERROR\r
  79 #endif\r
  80 #endif\r
  81 \r
  82 #include "log.h"\r
  83 \r
  84 /* configuration */\r
  85 u16 gw16012_port;\r
  86 \r
  87 /* interface variables\r
  88  */\r
  89 static u8 gw16012_msb = 0x0;\r
  90 static u8 gw16012_control_value = 0x0;\r
  91 \r
  92 #if PARPORT_USE_PPDEV == 1\r
  93 static int device_handle;\r
  94 #endif\r
  95 \r
  96 int gw16012_execute_queue(void);\r
  97 int gw16012_register_commands(struct command_context_s *cmd_ctx);\r
  98 int gw16012_speed(int speed);\r
  99 int gw16012_init(void);\r
 100 int gw16012_quit(void);\r
 101 \r
 102 int gw16012_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);\r
 103 \r
 104 jtag_interface_t gw16012_interface = \r
 105 {\r
 106         .name = "gw16012",\r
 107         \r
 108         .execute_queue = gw16012_execute_queue,\r
 109 \r
 110         .speed = gw16012_speed, \r
 111         .register_commands = gw16012_register_commands,\r
 112         .init = gw16012_init,\r
 113         .quit = gw16012_quit,\r
 114 };\r
 115 \r
 116 int gw16012_register_commands(struct command_context_s *cmd_ctx)\r
 117 {\r
 118         register_command(cmd_ctx, NULL, "parport_port", gw16012_handle_parport_port_command,\r
 119                                          COMMAND_CONFIG, NULL);\r
 120         \r
 121         return ERROR_OK;\r
 122 }\r
 123 \r
 124 void gw16012_data(u8 value)\r
 125 {\r
 126         value = (value & 0x7f) | gw16012_msb;\r
 127         gw16012_msb ^= 0x80; /* toggle MSB */\r
 128 \r
 129 #ifdef _DEBUG_GW16012_IO_\r
 130         DEBUG("%2.2x", value);\r
 131 #endif\r
 132         \r
 133         #if PARPORT_USE_PPDEV == 1\r
 134                 ioctl(device_handle, PPWDATA, &value);\r
 135         #else\r
 136                 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
 137                         outb(gw16012_port, value);\r
 138                 #else\r
 139                         outb(value, gw16012_port);\r
 140                 #endif\r
 141         #endif  \r
 142 }\r
 143 \r
 144 void gw16012_control(u8 value)\r
 145 {\r
 146         if (value != gw16012_control_value)\r
 147         {\r
 148                 gw16012_control_value = value;\r
 149 \r
 150 #ifdef _DEBUG_GW16012_IO_\r
 151                 DEBUG("%2.2x", gw16012_control_value);\r
 152 #endif\r
 153 \r
 154                 #if PARPORT_USE_PPDEV == 1\r
 155                         ioctl(device_handle, PPWCONTROL, &gw16012_control_value);\r
 156                 #else\r
 157                         #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
 158                                 outb(gw16012_port + 2, gw16012_control_value);\r
 159                         #else\r
 160                                 outb(gw16012_control_value, gw16012_port + 2);\r
 161                         #endif\r
 162                 #endif\r
 163         }\r
 164 }\r
 165 \r
 166 void gw16012_input(u8 *value)\r
 167 {\r
 168         #if PARPORT_USE_PPDEV == 1\r
 169                 ioctl(device_handle, PPRSTATUS, value);\r
 170         #else\r
 171                 *value = inb(gw16012_port + 1);\r
 172         #endif\r
 173 \r
 174 #ifdef _DEBUG_GW16012_IO_\r
 175         DEBUG("%2.2x", *value);\r
 176 #endif\r
 177 }\r
 178 \r
 179 /* (1) assert or (0) deassert reset lines */\r
 180 void gw16012_reset(int trst, int srst)\r
 181 {\r
 182         DEBUG("trst: %i, srst: %i", trst, srst);\r
 183 \r
 184         if (trst == 0)\r
 185                 gw16012_control(0x0d);\r
 186         else if (trst == 1)\r
 187                 gw16012_control(0x0c);\r
 188 \r
 189         if (srst == 0)\r
 190                 gw16012_control(0x0a);\r
 191         else if (srst == 1)\r
 192                 gw16012_control(0x0b);\r
 193 }\r
 194 \r
 195 int gw16012_speed(int speed)\r
 196 {\r
 197 \r
 198         return ERROR_OK;\r
 199 }\r
 200 \r
 201 void gw16012_end_state(state)\r
 202 {\r
 203         if (tap_move_map[state] != -1)\r
 204                 end_state = state;\r
 205         else\r
 206         {\r
 207                 ERROR("BUG: %i is not a valid end state", state);\r
 208                 exit(-1);\r
 209         }\r
 210 }\r
 211 \r
 212 void gw16012_state_move(void)\r
 213 {\r
 214         int i=0, tms=0;\r
 215         u8 tms_scan = TAP_MOVE(cur_state, end_state);\r
 216         \r
 217         gw16012_control(0x0); /* single-bit mode */\r
 218         \r
 219         for (i = 0; i < 7; i++)\r
 220         {\r
 221                 tms = (tms_scan >> i) & 1;\r
 222                 gw16012_data(tms << 1); /* output next TMS bit */\r
 223         }\r
 224         \r
 225         cur_state = end_state;\r
 226 }\r
 227 \r
 228 void gw16012_path_move(pathmove_command_t *cmd)\r
 229 {\r
 230         int num_states = cmd->num_states;\r
 231         int state_count;\r
 232 \r
 233         state_count = 0;\r
 234         while (num_states)\r
 235         {\r
 236                 gw16012_control(0x0); /* single-bit mode */\r
 237                 if (tap_transitions[cur_state].low == cmd->path[state_count])\r
 238                 {\r
 239                         gw16012_data(0x0); /* TCK cycle with TMS low */\r
 240                 }\r
 241                 else if (tap_transitions[cur_state].high == cmd->path[state_count])\r
 242                 {\r
 243                         gw16012_data(0x2); /* TCK cycle with TMS high */\r
 244                 }\r
 245                 else\r
 246                 {\r
 247                         ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);\r
 248                         exit(-1);\r
 249                 }\r
 250                 \r
 251                 cur_state = cmd->path[state_count];\r
 252                 state_count++;\r
 253                 num_states--;\r
 254         }\r
 255         \r
 256         end_state = cur_state;\r
 257 }\r
 258 \r
 259 void gw16012_runtest(int num_cycles)\r
 260 {\r
 261         enum tap_state saved_end_state = end_state;\r
 262         int i;\r
 263         \r
 264         /* only do a state_move when we're not already in RTI */\r
 265         if (cur_state != TAP_RTI)\r
 266         {\r
 267                 gw16012_end_state(TAP_RTI);\r
 268                 gw16012_state_move();\r
 269         }\r
 270         \r
 271         for (i = 0; i < num_cycles; i++)\r
 272         {\r
 273                 gw16012_control(0x0); /* single-bit mode */\r
 274                 gw16012_data(0x0); /* TMS cycle with TMS low */\r
 275         }\r
 276         \r
 277         gw16012_end_state(saved_end_state);\r
 278         if (cur_state != end_state)\r
 279                 gw16012_state_move();\r
 280 }\r
 281 \r
 282 void gw16012_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)\r
 283 {\r
 284         int bits_left = scan_size;\r
 285         int bit_count = 0;\r
 286         enum tap_state saved_end_state = end_state;\r
 287         u8 scan_out, scan_in;\r
 288 \r
 289         /* only if we're not already in the correct Shift state */\r
 290         if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))\r
 291         {\r
 292                 if (ir_scan)\r
 293                         gw16012_end_state(TAP_SI);\r
 294                 else\r
 295                         gw16012_end_state(TAP_SD);\r
 296 \r
 297                 gw16012_state_move();\r
 298                 gw16012_end_state(saved_end_state);\r
 299         }\r
 300 \r
 301         while (type == SCAN_OUT && ((bits_left - 1) > 7))\r
 302         {\r
 303                 gw16012_control(0x2); /* seven-bit mode */\r
 304                 scan_out = buf_get_u32(buffer, bit_count, 7);\r
 305                 gw16012_data(scan_out);\r
 306                 bit_count += 7;\r
 307                 bits_left -= 7;\r
 308         }\r
 309         \r
 310         gw16012_control(0x0); /* single-bit mode */\r
 311         while (bits_left-- > 0)\r
 312         {\r
 313                 u8 tms = 0;\r
 314                 \r
 315                 scan_out = buf_get_u32(buffer, bit_count, 1);\r
 316                 \r
 317                 if (bits_left == 0) /* last bit */\r
 318                 {\r
 319                         if ((ir_scan && (end_state == TAP_SI))\r
 320                                 || (!ir_scan && (end_state == TAP_SD)))\r
 321                         {\r
 322                                 tms = 0; \r
 323                         }\r
 324                         else\r
 325                         {\r
 326                                 tms = 2;\r
 327                         }\r
 328                 }\r
 329 \r
 330                 gw16012_data(scan_out | tms);\r
 331 \r
 332                 if (type != SCAN_OUT)\r
 333                 {\r
 334                         gw16012_input(&scan_in);\r
 335                         buf_set_u32(buffer, bit_count, 1, ((scan_in & 0x08) >> 3));\r
 336                 }               \r
 337 \r
 338                 bit_count++;\r
 339         }\r
 340 \r
 341         if (!((ir_scan && (end_state == TAP_SI)) ||\r
 342                 (!ir_scan && (end_state == TAP_SD))))\r
 343         {\r
 344                 gw16012_data(0x0);\r
 345                 if (ir_scan)\r
 346                         cur_state = TAP_PI;\r
 347                 else\r
 348                         cur_state = TAP_PD;\r
 349                         \r
 350                 if (cur_state != end_state)\r
 351                         gw16012_state_move();\r
 352         }\r
 353 }\r
 354 \r
 355 int gw16012_execute_queue(void)\r
 356 {\r
 357         jtag_command_t *cmd = jtag_command_queue; /* currently processed command */\r
 358         int scan_size;\r
 359         enum scan_type type;\r
 360         u8 *buffer;\r
 361         int retval;\r
 362         \r
 363         /* return ERROR_OK, unless a jtag_read_buffer returns a failed check\r
 364          * that wasn't handled by a caller-provided error handler\r
 365          */ \r
 366         retval = ERROR_OK;\r
 367                 \r
 368         while (cmd)\r
 369         {\r
 370                 switch (cmd->type)\r
 371                 {\r
 372                         case JTAG_END_STATE:\r
 373 #ifdef _DEBUG_JTAG_IO_\r
 374                                 DEBUG("end_state: %i", cmd->cmd.end_state->end_state);\r
 375 #endif\r
 376                                 if (cmd->cmd.end_state->end_state != -1)\r
 377                                         gw16012_end_state(cmd->cmd.end_state->end_state);\r
 378                                 break;\r
 379                         case JTAG_RESET:\r
 380 #ifdef _DEBUG_JTAG_IO_\r
 381                                 DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);\r
 382 #endif\r
 383                                 if (cmd->cmd.reset->trst == 1)\r
 384                                 {\r
 385                                         cur_state = TAP_TLR;\r
 386                                 }\r
 387                                 gw16012_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);\r
 388                                 break;\r
 389                         case JTAG_RUNTEST:\r
 390 #ifdef _DEBUG_JTAG_IO_\r
 391                                 DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);\r
 392 #endif\r
 393                                 if (cmd->cmd.runtest->end_state != -1)\r
 394                                         gw16012_end_state(cmd->cmd.runtest->end_state);\r
 395                                 gw16012_runtest(cmd->cmd.runtest->num_cycles);\r
 396                                 break;\r
 397                         case JTAG_STATEMOVE:\r
 398 #ifdef _DEBUG_JTAG_IO_\r
 399                                 DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);\r
 400 #endif\r
 401                                 if (cmd->cmd.statemove->end_state != -1)\r
 402                                         gw16012_end_state(cmd->cmd.statemove->end_state);\r
 403                                 gw16012_state_move();\r
 404                                 break;\r
 405                         case JTAG_PATHMOVE:\r
 406 #ifdef _DEBUG_JTAG_IO_\r
 407                                 DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);\r
 408 #endif\r
 409                                 gw16012_path_move(cmd->cmd.pathmove);\r
 410                                 break;\r
 411                         case JTAG_SCAN:\r
 412                                 if (cmd->cmd.scan->end_state != -1)\r
 413                                         gw16012_end_state(cmd->cmd.scan->end_state);\r
 414                                 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);\r
 415                                 type = jtag_scan_type(cmd->cmd.scan);\r
 416 #ifdef _DEBUG_JTAG_IO_\r
 417                                 DEBUG("%s scan (%i) %i bit end in %i", (cmd->cmd.scan->ir_scan) ? "ir" : "dr", \r
 418                                         type, scan_size, cmd->cmd.scan->end_state);\r
 419 #endif\r
 420                                 gw16012_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);\r
 421                                 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)\r
 422                                         retval = ERROR_JTAG_QUEUE_FAILED;\r
 423                                 if (buffer)\r
 424                                         free(buffer);\r
 425                                 break;\r
 426                         case JTAG_SLEEP:\r
 427 #ifdef _DEBUG_JTAG_IO_\r
 428                                 DEBUG("sleep %i", cmd->cmd.sleep->us);\r
 429 #endif\r
 430                                 jtag_sleep(cmd->cmd.sleep->us);\r
 431                                 break;\r
 432                         default:\r
 433                                 ERROR("BUG: unknown JTAG command type encountered");\r
 434                                 exit(-1);\r
 435                 }\r
 436                 cmd = cmd->next;\r
 437         }\r
 438         \r
 439         return retval;\r
 440 }\r
 441 \r
 442 #if PARPORT_USE_GIVEIO == 1\r
 443 int gw16012_get_giveio_access()\r
 444 {\r
 445     HANDLE h;\r
 446     OSVERSIONINFO version;\r
 447 \r
 448     version.dwOSVersionInfoSize = sizeof version;\r
 449     if (!GetVersionEx( &version )) {\r
 450         errno = EINVAL;\r
 451         return -1;\r
 452     }\r
 453     if (version.dwPlatformId != VER_PLATFORM_WIN32_NT)\r
 454         return 0;\r
 455 \r
 456     h = CreateFile( "\\\\.\\giveio", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );\r
 457     if (h == INVALID_HANDLE_VALUE) {\r
 458         errno = ENODEV;\r
 459         return -1;\r
 460     }\r
 461 \r
 462     CloseHandle( h );\r
 463 \r
 464     return 0;\r
 465 }\r
 466 #endif\r
 467 \r
 468 int gw16012_init(void)\r
 469 {\r
 470 #if PARPORT_USE_PPDEV == 1\r
 471         char buffer[256];\r
 472         int i = 0;\r
 473 #endif\r
 474         u8 status_port;\r
 475         \r
 476 #if PARPORT_USE_PPDEV == 1\r
 477         if (device_handle>0)\r
 478         {\r
 479                 ERROR("device is already opened");\r
 480                 return ERROR_JTAG_INIT_FAILED;\r
 481         }\r
 482 \r
 483 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
 484         DEBUG("opening /dev/ppi%d...", gw16012_port);\r
 485 \r
 486         snprintf(buffer, 256, "/dev/ppi%d", gw16012_port);\r
 487         device_handle = open(buffer, O_WRONLY);\r
 488 #else\r
 489         DEBUG("opening /dev/parport%d...", gw16012_port);\r
 490 \r
 491         snprintf(buffer, 256, "/dev/parport%d", gw16012_port);\r
 492         device_handle = open(buffer, O_WRONLY);\r
 493 #endif  \r
 494         if (device_handle<0)\r
 495         {\r
 496                 ERROR("cannot open device. check it exists and that user read and write rights are set");\r
 497                 return ERROR_JTAG_INIT_FAILED;\r
 498         }\r
 499 \r
 500         DEBUG("...open");\r
 501 \r
 502 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
 503         i=ioctl(device_handle, PPCLAIM);\r
 504         if (i<0)\r
 505         {\r
 506                 ERROR("cannot claim device");\r
 507                 return ERROR_JTAG_INIT_FAILED;\r
 508         }\r
 509 \r
 510         i = PARPORT_MODE_COMPAT;\r
 511         i= ioctl(device_handle, PPSETMODE, & i);\r
 512         if (i<0)\r
 513         {\r
 514                 ERROR(" cannot set compatible mode to device");\r
 515                 return ERROR_JTAG_INIT_FAILED;\r
 516         }\r
 517 \r
 518         i = IEEE1284_MODE_COMPAT;\r
 519         i = ioctl(device_handle, PPNEGOT, & i);\r
 520         if (i<0)\r
 521         {\r
 522                 ERROR("cannot set compatible 1284 mode to device");\r
 523                 return ERROR_JTAG_INIT_FAILED;\r
 524         }\r
 525 #endif\r
 526 #else\r
 527         if (gw16012_port == 0)\r
 528         {\r
 529                 gw16012_port = 0x378;\r
 530                 WARNING("No gw16012 port specified, using default '0x378' (LPT1)");\r
 531         }\r
 532         \r
 533         DEBUG("requesting privileges for parallel port 0x%lx...", gw16012_port);\r
 534 #if PARPORT_USE_GIVEIO == 1\r
 535         if (gw16012_get_giveio_access() != 0)\r
 536 #else /* PARPORT_USE_GIVEIO */\r
 537         if (ioperm(gw16012_port, 3, 1) != 0)\r
 538 #endif /* PARPORT_USE_GIVEIO */\r
 539         {\r
 540                 ERROR("missing privileges for direct i/o");\r
 541                 return ERROR_JTAG_INIT_FAILED;\r
 542         }\r
 543         DEBUG("...privileges granted");\r
 544 \r
 545         /* make sure parallel port is in right mode (clear tristate and interrupt */\r
 546 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\r
 547         outb(gw16012_port + 2, 0x0);\r
 548 #else\r
 549         outb(0x0, gw16012_port + 2);\r
 550 #endif\r
 551 #endif /* PARPORT_USE_PPDEV */\r
 552         \r
 553         gw16012_input(&status_port);\r
 554         gw16012_msb = (status_port & 0x80) ^ 0x80;\r
 555         \r
 556         gw16012_speed(jtag_speed);\r
 557         gw16012_reset(0, 0);\r
 558         \r
 559         return ERROR_OK;\r
 560 }\r
 561 \r
 562 int gw16012_quit(void)\r
 563 {\r
 564         \r
 565         return ERROR_OK;\r
 566 }\r
 567 \r
 568 int gw16012_handle_parport_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)\r
 569 {\r
 570         if (argc == 0)\r
 571                 return ERROR_OK;\r
 572 \r
 573         /* only if the port wasn't overwritten by cmdline */\r
 574         if (gw16012_port == 0)\r
 575                 gw16012_port = strtoul(args[0], NULL, 0);\r
 576 \r
 577         return ERROR_OK;\r
 578 }\r