src/hardware/ftdi-la/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2015 Sergey Alirzaev <zl29ah@gmail.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <config.h>
  21 #include <ftdi.h>
  22 #include <libusb.h>
  23 #include <libsigrok/libsigrok.h>
  24 #include "libsigrok-internal.h"
  25 #include "protocol.h"
  26
  27 static const uint32_t scanopts[] = {
  28         SR_CONF_CONN,
  29 };
  30
  31 static const uint32_t drvopts[] = {
  32         SR_CONF_LOGIC_ANALYZER,
  33 };
  34
  35 static const uint32_t devopts[] = {
  36         SR_CONF_CONTINUOUS,
  37         SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
  38         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  39         SR_CONF_CONN | SR_CONF_GET,
  40 };
  41
  42 static const uint64_t samplerates[] = {
  43         SR_HZ(3600),
  44         SR_MHZ(10),
  45         SR_HZ(1),
  46 };
  47
  48 static const struct ftdi_chip_desc ft2232h_desc = {
  49         .vendor = 0x0403,
  50         .product = 0x6010,
  51         .samplerate_div = 20,
  52         .channel_names = {
  53                 "ADBUS0", "ADBUS1", "ADBUS2", "ADBUS3",
  54                 "ADBUS4", "ADBUS5", "ADBUS6", "ADBUS7",
  55                 /* TODO: BDBUS[0..7] channels. */
  56                 NULL
  57         }
  58 };
  59
  60 static const struct ftdi_chip_desc ft2232h_tumpa_desc = {
  61         .vendor = 0x0403,
  62         .product = 0x8a98,
  63         .samplerate_div = 20,
  64         /* 20 pin JTAG header */
  65         .channel_names = {
  66                 "TCK", "TDI", "TDO", "TMS", "RST", "nTRST", "DBGRQ", "RTCK",
  67                 NULL
  68         }
  69 };
  70
  71 static const struct ftdi_chip_desc ft4232h_desc = {
  72         .vendor = 0x0403,
  73         .product = 0x6011,
  74         .samplerate_div = 20,
  75         .channel_names = {
  76                 "ADBUS0", "ADBUS1", "ADBUS2", "ADBUS3", "ADBUS4", "ADBUS5", "ADBUS6", "ADBUS7",
  77                 /* TODO: BDBUS[0..7], CDBUS[0..7], DDBUS[0..7] channels. */
  78                 NULL
  79         }
  80 };
  81
  82 static const struct ftdi_chip_desc ft232r_desc = {
  83         .vendor = 0x0403,
  84         .product = 0x6001,
  85         .samplerate_div = 30,
  86         .channel_names = {
  87                 "TXD", "RXD", "RTS#", "CTS#", "DTR#", "DSR#", "DCD#", "RI#",
  88                 NULL
  89         }
  90 };
  91
  92 static const struct ftdi_chip_desc ft232h_desc = {
  93         .vendor = 0x0403,
  94         .product = 0x6014,
  95         .samplerate_div = 30,
  96         .channel_names = {
  97                 "ADBUS0", "ADBUS1", "ADBUS2", "ADBUS3", "ADBUS4", "ADBUS5", "ADBUS6", "ADBUS7",
  98                 NULL
  99         }
 100 };
 101
 102 static const struct ftdi_chip_desc *chip_descs[] = {
 103         &ft2232h_desc,
 104         &ft2232h_tumpa_desc,
 105         &ft4232h_desc,
 106         &ft232r_desc,
 107         &ft232h_desc,
 108         NULL,
 109 };
 110
 111 static void scan_device(struct ftdi_context *ftdic,
 112         struct libusb_device *dev, GSList **devices)
 113 {
 114         struct libusb_device_descriptor usb_desc;
 115         const struct ftdi_chip_desc *desc;
 116         struct dev_context *devc;
 117         char *vendor, *model, *serial_num;
 118         struct sr_dev_inst *sdi;
 119         int rv;
 120
 121         libusb_get_device_descriptor(dev, &usb_desc);
 122
 123         desc = NULL;
 124         for (unsigned long i = 0; i < ARRAY_SIZE(chip_descs); i++) {
 125                 desc = chip_descs[i];
 126                 if (!desc)
 127                         break;
 128                 if (desc->vendor == usb_desc.idVendor &&
 129                         desc->product == usb_desc.idProduct)
 130                         break;
 131         }
 132
 133         if (!desc) {
 134                 sr_spew("Unsupported FTDI device 0x%04x:0x%04x.",
 135                         usb_desc.idVendor, usb_desc.idProduct);
 136                 return;
 137         }
 138
 139         devc = g_malloc0(sizeof(struct dev_context));
 140
 141         /* Allocate memory for the incoming data. */
 142         devc->data_buf = g_malloc0(DATA_BUF_SIZE);
 143
 144         devc->desc = desc;
 145
 146         vendor = g_malloc(32);
 147         model = g_malloc(32);
 148         serial_num = g_malloc(32);
 149         rv = ftdi_usb_get_strings(ftdic, dev, vendor, 32,
 150                         model, 32, serial_num, 32);
 151         switch (rv) {
 152         case 0:
 153                 break;
 154         case -9:
 155                 sr_dbg("The device lacks a serial number.");
 156                 g_free(serial_num);
 157                 serial_num = NULL;
 158                 break;
 159         default:
 160                 sr_err("Failed to get the FTDI strings: %d", rv);
 161                 goto err_free_strings;
 162         }
 163         sr_dbg("Found an FTDI device: %s.", model);
 164
 165         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 166         sdi->status = SR_ST_INACTIVE;
 167         sdi->vendor = vendor;
 168         sdi->model = model;
 169         sdi->serial_num = serial_num;
 170         sdi->priv = devc;
 171         sdi->connection_id = g_strdup_printf("d:%u/%u",
 172                 libusb_get_bus_number(dev), libusb_get_device_address(dev));
 173
 174         for (char *const *chan = &(desc->channel_names[0]); *chan; chan++)
 175                 sr_channel_new(sdi, chan - &(desc->channel_names[0]),
 176                                 SR_CHANNEL_LOGIC, TRUE, *chan);
 177
 178         *devices = g_slist_append(*devices, sdi);
 179         return;
 180
 181 err_free_strings:
 182         g_free(vendor);
 183         g_free(model);
 184         g_free(serial_num);
 185         g_free(devc->data_buf);
 186         g_free(devc);
 187 }
 188
 189 static GSList *scan_all(struct ftdi_context *ftdic, GSList *options)
 190 {
 191         GSList *devices;
 192         struct ftdi_device_list *devlist = 0;
 193         struct ftdi_device_list *curdev;
 194         int ret;
 195
 196         (void)options;
 197
 198         devices = NULL;
 199
 200         ret = ftdi_usb_find_all(ftdic, &devlist, 0, 0);
 201         if (ret < 0) {
 202                 sr_err("Failed to list devices (%d): %s", ret,
 203                        ftdi_get_error_string(ftdic));
 204                 return NULL;
 205         }
 206
 207         curdev = devlist;
 208         while (curdev) {
 209                 scan_device(ftdic, curdev->dev, &devices);
 210                 curdev = curdev->next;
 211         }
 212
 213         ftdi_list_free(&devlist);
 214
 215         return devices;
 216 }
 217
 218 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 219 {
 220         struct ftdi_context *ftdic;
 221         struct sr_config *src;
 222         struct sr_usb_dev_inst *usb;
 223         const char *conn;
 224         GSList *l, *conn_devices;
 225         GSList *devices;
 226         struct drv_context *drvc;
 227         libusb_device **devlist;
 228         int i;
 229
 230         drvc = di->context;
 231         conn = NULL;
 232         for (l = options; l; l = l->next) {
 233                 src = l->data;
 234                 if (src->key == SR_CONF_CONN) {
 235                         conn = g_variant_get_string(src->data, NULL);
 236                         break;
 237                 }
 238         }
 239
 240         ftdic = ftdi_new();
 241         if (!ftdic) {
 242                 sr_err("Failed to initialize libftdi.");
 243                 return NULL;
 244         }
 245
 246         if (conn) {
 247                 devices = NULL;
 248                 libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
 249                 for (i = 0; devlist[i]; i++) {
 250                         conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
 251                         for (l = conn_devices; l; l = l->next) {
 252                                 usb = l->data;
 253                                 if (usb->bus == libusb_get_bus_number(devlist[i])
 254                                         && usb->address == libusb_get_device_address(devlist[i])) {
 255                                         scan_device(ftdic, devlist[i], &devices);
 256                                 }
 257                         }
 258                 }
 259                 libusb_free_device_list(devlist, 1);
 260         } else
 261                 devices = scan_all(ftdic, options);
 262
 263         ftdi_free(ftdic);
 264
 265         return std_scan_complete(di, devices);
 266 }
 267
 268 static void clear_helper(struct dev_context *devc)
 269 {
 270         g_free(devc->data_buf);
 271 }
 272
 273 static int dev_clear(const struct sr_dev_driver *di)
 274 {
 275         return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
 276 }
 277
 278 static int dev_open(struct sr_dev_inst *sdi)
 279 {
 280         struct dev_context *devc;
 281         int ret = SR_OK;
 282
 283         devc = sdi->priv;
 284
 285         devc->ftdic = ftdi_new();
 286         if (!devc->ftdic)
 287                 return SR_ERR;
 288
 289         ret = ftdi_usb_open_string(devc->ftdic, sdi->connection_id);
 290         if (ret < 0) {
 291                 /* Log errors, except for -3 ("device not found"). */
 292                 if (ret != -3)
 293                         sr_err("Failed to open device (%d): %s", ret,
 294                                ftdi_get_error_string(devc->ftdic));
 295                 goto err_ftdi_free;
 296         }
 297
 298         ret = ftdi_usb_purge_buffers(devc->ftdic);
 299         if (ret < 0) {
 300                 sr_err("Failed to purge FTDI RX/TX buffers (%d): %s.",
 301                        ret, ftdi_get_error_string(devc->ftdic));
 302                 goto err_dev_open_close_ftdic;
 303         }
 304
 305         ret = ftdi_set_bitmode(devc->ftdic, 0x00, BITMODE_RESET);
 306         if (ret < 0) {
 307                 sr_err("Failed to reset the FTDI chip bitmode (%d): %s.",
 308                        ret, ftdi_get_error_string(devc->ftdic));
 309                 goto err_dev_open_close_ftdic;
 310         }
 311
 312         ret = ftdi_set_bitmode(devc->ftdic, 0x00, BITMODE_BITBANG);
 313         if (ret < 0) {
 314                 sr_err("Failed to put FTDI chip into bitbang mode (%d): %s.",
 315                        ret, ftdi_get_error_string(devc->ftdic));
 316                 goto err_dev_open_close_ftdic;
 317         }
 318
 319         return SR_OK;
 320
 321 err_dev_open_close_ftdic:
 322         ftdi_usb_close(devc->ftdic);
 323
 324 err_ftdi_free:
 325         ftdi_free(devc->ftdic);
 326
 327         return SR_ERR;
 328 }
 329
 330 static int dev_close(struct sr_dev_inst *sdi)
 331 {
 332         struct dev_context *devc;
 333
 334         devc = sdi->priv;
 335
 336         if (!devc->ftdic)
 337                 return SR_ERR_BUG;
 338
 339         ftdi_usb_close(devc->ftdic);
 340         ftdi_free(devc->ftdic);
 341         devc->ftdic = NULL;
 342
 343         return SR_OK;
 344 }
 345
 346 static int config_get(uint32_t key, GVariant **data,
 347         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 348 {
 349         struct dev_context *devc;
 350         struct sr_usb_dev_inst *usb;
 351
 352         (void)cg;
 353
 354         devc = sdi->priv;
 355
 356         switch (key) {
 357         case SR_CONF_SAMPLERATE:
 358                 *data = g_variant_new_uint64(devc->cur_samplerate);
 359                 break;
 360         case SR_CONF_CONN:
 361                 if (!sdi || !sdi->conn)
 362                         return SR_ERR_ARG;
 363                 usb = sdi->conn;
 364                 *data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
 365                 break;
 366         default:
 367                 return SR_ERR_NA;
 368         }
 369
 370         return SR_OK;
 371 }
 372
 373 static int config_set(uint32_t key, GVariant *data,
 374         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 375 {
 376         struct dev_context *devc;
 377         uint64_t value;
 378
 379         (void)cg;
 380
 381         devc = sdi->priv;
 382
 383         switch (key) {
 384         case SR_CONF_LIMIT_MSEC:
 385                 value = g_variant_get_uint64(data);
 386                 /* TODO: Implement. */
 387                 (void)value;
 388                 return SR_ERR_NA;
 389         case SR_CONF_LIMIT_SAMPLES:
 390                 devc->limit_samples = g_variant_get_uint64(data);
 391                 break;
 392         case SR_CONF_SAMPLERATE:
 393                 value = g_variant_get_uint64(data);
 394                 if (value < 3600)
 395                         return SR_ERR_SAMPLERATE;
 396                 devc->cur_samplerate = value;
 397                 return ftdi_la_set_samplerate(devc);
 398         default:
 399                 return SR_ERR_NA;
 400         }
 401
 402         return SR_OK;
 403 }
 404
 405 static int config_list(uint32_t key, GVariant **data,
 406         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 407 {
 408         switch (key) {
 409         case SR_CONF_SCAN_OPTIONS:
 410         case SR_CONF_DEVICE_OPTIONS:
 411                 return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
 412         case SR_CONF_SAMPLERATE:
 413                 *data = std_gvar_samplerates_steps(ARRAY_AND_SIZE(samplerates));
 414                 break;
 415         default:
 416                 return SR_ERR_NA;
 417         }
 418
 419         return SR_OK;
 420 }
 421
 422 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 423 {
 424         struct dev_context *devc;
 425
 426         devc = sdi->priv;
 427
 428         if (!devc->ftdic)
 429                 return SR_ERR_BUG;
 430
 431         ftdi_set_bitmode(devc->ftdic, 0, BITMODE_BITBANG);
 432
 433         /* Properly reset internal variables before every new acquisition. */
 434         devc->samples_sent = 0;
 435         devc->bytes_received = 0;
 436
 437         std_session_send_df_header(sdi);
 438
 439         /* Hook up a dummy handler to receive data from the device. */
 440         sr_session_source_add(sdi->session, -1, G_IO_IN, 0,
 441                               ftdi_la_receive_data, (void *)sdi);
 442
 443         return SR_OK;
 444 }
 445
 446 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 447 {
 448         sr_session_source_remove(sdi->session, -1);
 449
 450         std_session_send_df_end(sdi);
 451
 452         return SR_OK;
 453 }
 454
 455 static struct sr_dev_driver ftdi_la_driver_info = {
 456         .name = "ftdi-la",
 457         .longname = "FTDI LA",
 458         .api_version = 1,
 459         .init = std_init,
 460         .cleanup = std_cleanup,
 461         .scan = scan,
 462         .dev_list = std_dev_list,
 463         .dev_clear = dev_clear,
 464         .config_get = config_get,
 465         .config_set = config_set,
 466         .config_list = config_list,
 467         .dev_open = dev_open,
 468         .dev_close = dev_close,
 469         .dev_acquisition_start = dev_acquisition_start,
 470         .dev_acquisition_stop = dev_acquisition_stop,
 471         .context = NULL,
 472 };
 473 SR_REGISTER_DEV_DRIVER(ftdi_la_driver_info);