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 ft232r_desc = {
  61         .vendor = 0x0403,
  62         .product = 0x6001,
  63         .samplerate_div = 30,
  64         .channel_names = {
  65                 "TXD", "RXD", "RTS#", "CTS#", "DTR#", "DSR#", "DCD#", "RI#",
  66                 NULL
  67         }
  68 };
  69
  70 static const struct ftdi_chip_desc *chip_descs[] = {
  71         &ft2232h_desc,
  72         &ft232r_desc,
  73 };
  74
  75 static void scan_device(struct ftdi_context *ftdic,
  76         struct libusb_device *dev, GSList **devices)
  77 {
  78         struct libusb_device_descriptor usb_desc;
  79         const struct ftdi_chip_desc *desc;
  80         struct dev_context *devc;
  81         char *vendor, *model, *serial_num;
  82         struct sr_dev_inst *sdi;
  83         int rv;
  84
  85         libusb_get_device_descriptor(dev, &usb_desc);
  86
  87         desc = NULL;
  88         for (unsigned long i = 0; i < ARRAY_SIZE(chip_descs); i++) {
  89                 desc = chip_descs[i];
  90                 if (desc->vendor == usb_desc.idVendor &&
  91                         desc->product == usb_desc.idProduct)
  92                         break;
  93         }
  94
  95         if (!desc) {
  96                 sr_spew("Unsupported FTDI device 0x%4x:0x%4x.",
  97                         usb_desc.idVendor, usb_desc.idProduct);
  98                 return;
  99         }
 100
 101         devc = g_malloc0(sizeof(struct dev_context));
 102
 103         /* Allocate memory for the incoming data. */
 104         devc->data_buf = g_malloc0(DATA_BUF_SIZE);
 105
 106         devc->desc = desc;
 107
 108         vendor = g_malloc(32);
 109         model = g_malloc(32);
 110         serial_num = g_malloc(32);
 111         rv = ftdi_usb_get_strings(ftdic, dev, vendor, 32,
 112                         model, 32, serial_num, 32);
 113         switch (rv) {
 114         case 0:
 115                 break;
 116         case -9:
 117                 sr_dbg("The device lacks a serial number.");
 118                 g_free(serial_num);
 119                 serial_num = NULL;
 120                 break;
 121         default:
 122                 sr_err("Failed to get the FTDI strings: %d", rv);
 123                 goto err_free_strings;
 124         }
 125         sr_dbg("Found an FTDI device: %s.", model);
 126
 127         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 128         sdi->status = SR_ST_INACTIVE;
 129         sdi->vendor = vendor;
 130         sdi->model = model;
 131         sdi->serial_num = serial_num;
 132         sdi->priv = devc;
 133         sdi->connection_id = g_strdup_printf("d:%u/%u",
 134                 libusb_get_bus_number(dev), libusb_get_device_address(dev));
 135
 136         for (char *const *chan = &(desc->channel_names[0]); *chan; chan++)
 137                 sr_channel_new(sdi, chan - &(desc->channel_names[0]),
 138                                 SR_CHANNEL_LOGIC, TRUE, *chan);
 139
 140         *devices = g_slist_append(*devices, sdi);
 141         return;
 142
 143 err_free_strings:
 144         g_free(vendor);
 145         g_free(model);
 146         g_free(serial_num);
 147         g_free(devc->data_buf);
 148         g_free(devc);
 149 }
 150
 151 static GSList *scan_all(struct ftdi_context *ftdic, GSList *options)
 152 {
 153         GSList *devices;
 154         struct ftdi_device_list *devlist = 0;
 155         struct ftdi_device_list *curdev;
 156         int ret;
 157
 158         (void)options;
 159
 160         devices = NULL;
 161
 162         ret = ftdi_usb_find_all(ftdic, &devlist, 0, 0);
 163         if (ret < 0) {
 164                 sr_err("Failed to list devices (%d): %s", ret,
 165                        ftdi_get_error_string(ftdic));
 166                 return NULL;
 167         }
 168
 169         curdev = devlist;
 170         while (curdev) {
 171                 scan_device(ftdic, curdev->dev, &devices);
 172                 curdev = curdev->next;
 173         }
 174
 175         ftdi_list_free(&devlist);
 176
 177         return devices;
 178 }
 179
 180 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 181 {
 182         struct ftdi_context *ftdic;
 183         struct sr_config *src;
 184         struct sr_usb_dev_inst *usb;
 185         const char *conn;
 186         GSList *l, *conn_devices;
 187         GSList *devices;
 188         struct drv_context *drvc;
 189         libusb_device **devlist;
 190         int i;
 191
 192         drvc = di->context;
 193         conn = NULL;
 194         for (l = options; l; l = l->next) {
 195                 src = l->data;
 196                 if (src->key == SR_CONF_CONN) {
 197                         conn = g_variant_get_string(src->data, NULL);
 198                         break;
 199                 }
 200         }
 201
 202         ftdic = ftdi_new();
 203         if (!ftdic) {
 204                 sr_err("Failed to initialize libftdi.");
 205                 return NULL;
 206         }
 207
 208         if (conn) {
 209                 devices = NULL;
 210                 libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
 211                 for (i = 0; devlist[i]; i++) {
 212                         conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
 213                         for (l = conn_devices; l; l = l->next) {
 214                                 usb = l->data;
 215                                 if (usb->bus == libusb_get_bus_number(devlist[i])
 216                                         && usb->address == libusb_get_device_address(devlist[i])) {
 217                                         scan_device(ftdic, devlist[i], &devices);
 218                                 }
 219                         }
 220                 }
 221                 libusb_free_device_list(devlist, 1);
 222         } else
 223                 devices = scan_all(ftdic, options);
 224
 225         ftdi_free(ftdic);
 226
 227         return std_scan_complete(di, devices);
 228 }
 229
 230 static void clear_helper(struct dev_context *devc)
 231 {
 232         g_free(devc->data_buf);
 233 }
 234
 235 static int dev_clear(const struct sr_dev_driver *di)
 236 {
 237         return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
 238 }
 239
 240 static int dev_open(struct sr_dev_inst *sdi)
 241 {
 242         struct dev_context *devc;
 243         int ret = SR_OK;
 244
 245         devc = sdi->priv;
 246
 247         devc->ftdic = ftdi_new();
 248         if (!devc->ftdic)
 249                 return SR_ERR;
 250
 251         ret = ftdi_usb_open_string(devc->ftdic, sdi->connection_id);
 252         if (ret < 0) {
 253                 /* Log errors, except for -3 ("device not found"). */
 254                 if (ret != -3)
 255                         sr_err("Failed to open device (%d): %s", ret,
 256                                ftdi_get_error_string(devc->ftdic));
 257                 goto err_ftdi_free;
 258         }
 259
 260         ret = ftdi_usb_purge_buffers(devc->ftdic);
 261         if (ret < 0) {
 262                 sr_err("Failed to purge FTDI RX/TX buffers (%d): %s.",
 263                        ret, ftdi_get_error_string(devc->ftdic));
 264                 goto err_dev_open_close_ftdic;
 265         }
 266
 267         ret = ftdi_set_bitmode(devc->ftdic, 0x00, BITMODE_RESET);
 268         if (ret < 0) {
 269                 sr_err("Failed to reset the FTDI chip bitmode (%d): %s.",
 270                        ret, ftdi_get_error_string(devc->ftdic));
 271                 goto err_dev_open_close_ftdic;
 272         }
 273
 274         ret = ftdi_set_bitmode(devc->ftdic, 0x00, BITMODE_BITBANG);
 275         if (ret < 0) {
 276                 sr_err("Failed to put FTDI chip into bitbang mode (%d): %s.",
 277                        ret, ftdi_get_error_string(devc->ftdic));
 278                 goto err_dev_open_close_ftdic;
 279         }
 280
 281         return SR_OK;
 282
 283 err_dev_open_close_ftdic:
 284         ftdi_usb_close(devc->ftdic);
 285
 286 err_ftdi_free:
 287         ftdi_free(devc->ftdic);
 288
 289         return SR_ERR;
 290 }
 291
 292 static int dev_close(struct sr_dev_inst *sdi)
 293 {
 294         struct dev_context *devc;
 295
 296         devc = sdi->priv;
 297
 298         if (!devc->ftdic)
 299                 return SR_ERR_BUG;
 300
 301         ftdi_usb_close(devc->ftdic);
 302         ftdi_free(devc->ftdic);
 303         devc->ftdic = NULL;
 304
 305         return SR_OK;
 306 }
 307
 308 static int config_get(uint32_t key, GVariant **data,
 309         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 310 {
 311         struct dev_context *devc;
 312         struct sr_usb_dev_inst *usb;
 313
 314         (void)cg;
 315
 316         devc = sdi->priv;
 317
 318         switch (key) {
 319         case SR_CONF_SAMPLERATE:
 320                 *data = g_variant_new_uint64(devc->cur_samplerate);
 321                 break;
 322         case SR_CONF_CONN:
 323                 if (!sdi || !sdi->conn)
 324                         return SR_ERR_ARG;
 325                 usb = sdi->conn;
 326                 *data = g_variant_new_printf("%d.%d", usb->bus, usb->address);
 327                 break;
 328         default:
 329                 return SR_ERR_NA;
 330         }
 331
 332         return SR_OK;
 333 }
 334
 335 static int config_set(uint32_t key, GVariant *data,
 336         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 337 {
 338         struct dev_context *devc;
 339         uint64_t value;
 340
 341         (void)cg;
 342
 343         devc = sdi->priv;
 344
 345         switch (key) {
 346         case SR_CONF_LIMIT_MSEC:
 347                 value = g_variant_get_uint64(data);
 348                 /* TODO: Implement. */
 349                 (void)value;
 350                 return SR_ERR_NA;
 351         case SR_CONF_LIMIT_SAMPLES:
 352                 devc->limit_samples = g_variant_get_uint64(data);
 353                 break;
 354         case SR_CONF_SAMPLERATE:
 355                 value = g_variant_get_uint64(data);
 356                 if (value < 3600)
 357                         return SR_ERR_SAMPLERATE;
 358                 devc->cur_samplerate = value;
 359                 return ftdi_la_set_samplerate(devc);
 360         default:
 361                 return SR_ERR_NA;
 362         }
 363
 364         return SR_OK;
 365 }
 366
 367 static int config_list(uint32_t key, GVariant **data,
 368         const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 369 {
 370         switch (key) {
 371         case SR_CONF_SCAN_OPTIONS:
 372         case SR_CONF_DEVICE_OPTIONS:
 373                 return STD_CONFIG_LIST(key, data, sdi, cg, scanopts, drvopts, devopts);
 374         case SR_CONF_SAMPLERATE:
 375                 *data = std_gvar_samplerates_steps(ARRAY_AND_SIZE(samplerates));
 376                 break;
 377         default:
 378                 return SR_ERR_NA;
 379         }
 380
 381         return SR_OK;
 382 }
 383
 384 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 385 {
 386         struct dev_context *devc;
 387
 388         devc = sdi->priv;
 389
 390         if (!devc->ftdic)
 391                 return SR_ERR_BUG;
 392
 393         ftdi_set_bitmode(devc->ftdic, 0, BITMODE_BITBANG);
 394
 395         /* Properly reset internal variables before every new acquisition. */
 396         devc->samples_sent = 0;
 397         devc->bytes_received = 0;
 398
 399         std_session_send_df_header(sdi);
 400
 401         /* Hook up a dummy handler to receive data from the device. */
 402         sr_session_source_add(sdi->session, -1, G_IO_IN, 0,
 403                               ftdi_la_receive_data, (void *)sdi);
 404
 405         return SR_OK;
 406 }
 407
 408 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 409 {
 410         sr_session_source_remove(sdi->session, -1);
 411
 412         std_session_send_df_end(sdi);
 413
 414         return SR_OK;
 415 }
 416
 417 static struct sr_dev_driver ftdi_la_driver_info = {
 418         .name = "ftdi-la",
 419         .longname = "FTDI LA",
 420         .api_version = 1,
 421         .init = std_init,
 422         .cleanup = std_cleanup,
 423         .scan = scan,
 424         .dev_list = std_dev_list,
 425         .dev_clear = dev_clear,
 426         .config_get = config_get,
 427         .config_set = config_set,
 428         .config_list = config_list,
 429         .dev_open = dev_open,
 430         .dev_close = dev_close,
 431         .dev_acquisition_start = dev_acquisition_start,
 432         .dev_acquisition_stop = dev_acquisition_stop,
 433         .context = NULL,
 434 };
 435 SR_REGISTER_DEV_DRIVER(ftdi_la_driver_info);