git.zerfleddert.de Git - usb-driver/blob - jtagkey.c

   1 #include <stdio.h>
   2 #include <ftdi.h>
   3 #include <unistd.h>
   4 #include "usb-driver.h"
   5 #include "jtagkey.h"
   6
   7 #define USBBUFSIZE 4096
   8
   9 static struct ftdi_context ftdic;
  10 static unsigned int usb_maxlen = 0;
  11 static unsigned char bitbang_mode;
  12
  13 int jtagkey_init(unsigned short vid, unsigned short pid) {
  14         int ret = 0;
  15         unsigned char c;
  16
  17         if ((ret = ftdi_init(&ftdic)) != 0) {
  18                 fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  19                 return ret;
  20         }
  21
  22         if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) {
  23                 fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  24                 return ret;
  25         }
  26
  27         if ((ret = ftdi_usb_reset(&ftdic)) != 0) {
  28                 fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  29                 return ret;
  30         }
  31
  32         if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) {
  33                 fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  34                 return ret;
  35         }
  36
  37
  38         if ((ret = ftdi_write_data_get_chunksize(&ftdic, &usb_maxlen))  != 0) {
  39                 fprintf(stderr, "unable to get write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  40                 return ret;
  41         }
  42
  43         if ((ret = ftdi_set_latency_timer(&ftdic, 1))  != 0) {
  44                 fprintf(stderr, "unable to set latency timer: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  45                 return ret;
  46         }
  47
  48         if ((ret = ftdi_set_baudrate(&ftdic, 500000))  != 0) {
  49                 fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  50                 return ret;
  51         }
  52
  53         c = 0x00;
  54         ftdi_write_data(&ftdic, &c, 1);
  55
  56         if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, BITMODE_BITBANG))  != 0) {
  57                 fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  58                 return ret;
  59         }
  60
  61         bitbang_mode = BITMODE_BITBANG;
  62
  63         if ((ret = ftdi_usb_purge_buffers(&ftdic))  != 0) {
  64                 fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  65                 return ret;
  66         }
  67
  68         return ret;
  69 }
  70
  71 void jtagkey_close() {
  72         ftdi_disable_bitbang(&ftdic);
  73         ftdi_usb_close(&ftdic);
  74         ftdi_deinit(&ftdic);
  75 }
  76
  77 static int jtagkey_set_bbmode(unsigned char mode) {
  78         int ret = 0;
  79
  80         if (bitbang_mode != mode) {
  81                 DPRINTF("switching bitbang-mode!\n");
  82
  83                 /* Wait for the latency-timer to kick in */
  84                 usleep(2);
  85                 if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, mode))  != 0) {
  86                         fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  87                         return ret;
  88                 }
  89                 if ((ret = ftdi_usb_purge_buffers(&ftdic))  != 0) {
  90                         fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
  91                         return ret;
  92                 }
  93                 /* Wait for the FTDI2232 to settle */
  94                 usleep(2);
  95
  96                 bitbang_mode = mode;
  97         }
  98
  99         return ret;
 100 }
 101
 102 void jtagkey_state(unsigned char data) {
 103         fprintf(stderr,"Pins high: ");
 104
 105         if (data & JTAGKEY_TCK)
 106                 fprintf(stderr,"TCK ");
 107
 108         if (data & JTAGKEY_TDI)
 109                 fprintf(stderr,"TDI ");
 110
 111         if (data & JTAGKEY_TDO)
 112                 fprintf(stderr,"TDO ");
 113
 114         if (data & JTAGKEY_TMS)
 115                 fprintf(stderr,"TMS ");
 116
 117         if (data & JTAGKEY_VREF)
 118                 fprintf(stderr,"VREF ");
 119
 120         fprintf(stderr,"\n");
 121 }
 122
 123 int jtagkey_transfer(WD_TRANSFER *tr, int fd, unsigned int request, int ppbase, int ecpbase, int num) {
 124         int ret = 0;
 125         int i;
 126         int nread = 0;
 127         unsigned long port;
 128         unsigned char val;
 129         static unsigned char last_data = 0;
 130         static unsigned char last_write = 0x00;
 131         static unsigned char writebuf[USBBUFSIZE], *writepos = writebuf;
 132         static unsigned char readbuf[USBBUFSIZE], *readpos;
 133         unsigned char data, prev_data;
 134
 135         /* Count reads */
 136         for (i = 0; i < num; i++)
 137                 if (tr[i].cmdTrans == PP_READ)
 138                         nread++;
 139
 140         /* Write combining */
 141         if ((writepos-writebuf > sizeof(writebuf)-num) || (nread && writepos-writebuf)) {
 142                 unsigned char *pos = writebuf;
 143                 int len;
 144                 DPRINTF("writing %d bytes due to %d following reads in %d chunks or full buffer\n", writepos-writebuf, nread, num);
 145
 146                 jtagkey_set_bbmode(BITMODE_BITBANG);
 147                 while (pos < writepos) {
 148                         len = writepos-pos;
 149
 150                         if (len > usb_maxlen)
 151                                 len = usb_maxlen;
 152
 153                         DPRINTF("combined write of %d/%d\n",len,writepos-pos);
 154                         ftdi_write_data(&ftdic, pos, len);
 155                         pos += len;
 156                 }
 157
 158                 DPRINTF("read %d/%d bytes\n", i, writepos-writebuf);
 159                 writepos = writebuf;
 160         }
 161
 162         for (i = 0; i < num; i++) {
 163                 DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
 164                                 (unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
 165                                 tr[i].fAutoinc, tr[i].dwOptions);
 166
 167                 port = (unsigned long)tr[i].dwPort;
 168                 val = tr[i].Data.Byte;
 169
 170 #ifdef DEBUG
 171                 if (tr[i].cmdTrans == 13)
 172                         DPRINTF("write byte: %d\n", val);
 173 #endif
 174
 175                 /* Pad writebuf for read-commands in stream */
 176                 *writepos = last_data;
 177                 prev_data = last_data;
 178
 179                 if (port == ppbase + PP_DATA) {
 180                         DPRINTF("data port\n");
 181
 182                         data = 0x00;
 183                         switch(tr[i].cmdTrans) {
 184                                 case PP_READ:
 185                                         ret = 0; /* We don't support reading of the data port */
 186                                         break;
 187
 188                                 case PP_WRITE:
 189                                         if (val & PP_TDI) {
 190                                                 data |= JTAGKEY_TDI;
 191                                                 DPRINTF("TDI\n");
 192                                         } else {
 193                                                 DPRINTF("!TDI\n");
 194                                         }
 195                                         if (val & PP_TCK) {
 196                                                 data |= JTAGKEY_TCK;
 197                                                 DPRINTF("TCK\n");
 198                                         } else {
 199                                                 DPRINTF("!TCK\n");
 200                                         }
 201                                         if (val & PP_TMS) {
 202                                                 data |= JTAGKEY_TMS;
 203                                                 DPRINTF("TMS\n");
 204                                         } else {
 205                                                 DPRINTF("!TMS\n");
 206                                         }
 207                                         if (val & PP_CTRL) {
 208                                                 data = JTAGKEY_OEn;
 209                                                 DPRINTF("CTRL\n");
 210                                         } else {
 211                                                 DPRINTF("!CTRL\n");
 212                                         }
 213
 214                                         if (val & PP_PROG) {
 215                                                 DPRINTF("PROG\n");
 216                                         } else {
 217                                                 DPRINTF("!PROG\n");
 218                                         }
 219
 220                                         *writepos = data;
 221
 222                                         last_data = data;
 223                                         last_write = val;
 224                                         break;
 225
 226                                 default:
 227                                         fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
 228                                         ret = -1;
 229                                         break;
 230                         }
 231                 }
 232
 233                 if (nread || (*writepos != prev_data))
 234                         writepos++;
 235         }
 236
 237         if (nread)
 238         {
 239                 DPRINTF("writing %d bytes\n", writepos-writebuf);
 240
 241                 *writepos = last_data;
 242                 writepos++;
 243
 244                 jtagkey_set_bbmode(BITMODE_SYNCBB);
 245                 ftdi_write_data(&ftdic, writebuf, writepos-writebuf);
 246
 247                 i = 0;
 248                 while (i < writepos-writebuf) {
 249                         i += ftdi_read_data(&ftdic, readbuf, sizeof(readbuf));
 250                 }
 251
 252 #ifdef DEBUG
 253                 DPRINTF("write: ");
 254                 hexdump(writebuf, writepos-writebuf);
 255                 DPRINTF("read: ");
 256                 hexdump(readbuf, i);
 257 #endif
 258
 259                 writepos = writebuf;
 260         } else {
 261                 return ret;
 262         }
 263
 264         readpos = readbuf;
 265
 266         for (i = 0; i < num; i++) {
 267                 DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
 268                                 (unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
 269                                 tr[i].fAutoinc, tr[i].dwOptions);
 270
 271                 port = (unsigned long)tr[i].dwPort;
 272                 val = tr[i].Data.Byte;
 273                 readpos++;
 274
 275                 if (port == ppbase + PP_DATA) {
 276                         if (tr[i].cmdTrans == PP_WRITE) {
 277                                 last_write = val;
 278                         }
 279                 } else if (port == ppbase + PP_STATUS) {
 280                         DPRINTF("status port (last write: 0x%x)\n", last_write);
 281                         switch(tr[i].cmdTrans) {
 282                                 case PP_READ:
 283                                         data = *readpos;
 284
 285 #ifdef DEBUG
 286                                         DPRINTF("READ: 0x%x\n", data);
 287                                         jtagkey_state(data);
 288 #endif
 289
 290                                         val = 0x00;
 291                                         if ((data & JTAGKEY_TDO) && (last_write & PP_PROG))
 292                                                 val |= PP_TDO;
 293
 294                                         if (!(last_write & PP_PROG))
 295                                                 val |= 0x08;
 296
 297                                         if (last_write & 0x40)
 298                                                 val |= 0x20;
 299                                         else
 300                                                 val |= 0x80;
 301                                         break;
 302
 303                                 case PP_WRITE:
 304                                         ret = 0; /* Status Port is readonly */
 305                                         break;
 306
 307                                 default:
 308                                         fprintf(stderr,"!!!Unsupported TRANSFER command: %lu!!!\n", tr[i].cmdTrans);
 309                                         ret = -1;
 310                                         break;
 311                         }
 312                 } else {
 313                         ret = 0;
 314                 }
 315
 316                 tr[i].Data.Byte = val;
 317
 318                 DPRINTF("dwPortReturn: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
 319                                 (unsigned long)tr[i].dwPort, tr[i].cmdTrans, tr[i].dwBytes,
 320                                 tr[i].fAutoinc, tr[i].dwOptions);
 321 #ifdef DEBUG
 322                 if (tr[i].cmdTrans == 10)
 323                         DPRINTF("read byte: %d\n", tr[i].Data.Byte);
 324 #endif
 325         }
 326
 327         return ret;
 328 }