2 * This file is part of the libsigrok project.
4 * Copyright (C) 2015 Christer Ekholm <christerekholm@gmail.com>
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.
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.
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/>.
23 SR_PRIV int hantek_6xxx_open(struct sr_dev_inst *sdi)
25 struct dev_context *devc;
26 struct drv_context *drvc = sdi->driver->context;
27 struct sr_usb_dev_inst *usb;
28 struct libusb_device_descriptor des;
29 libusb_device **devlist;
31 char connection_id[64];
36 libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
37 for (i = 0; devlist[i]; i++) {
38 libusb_get_device_descriptor(devlist[i], &des);
40 if (des.idVendor != devc->profile->fw_vid
41 || des.idProduct != devc->profile->fw_pid)
44 if ((sdi->status == SR_ST_INITIALIZING) ||
45 (sdi->status == SR_ST_INACTIVE)) {
47 * Check device by its physical USB bus/port address.
49 usb_get_port_path(devlist[i], connection_id, sizeof(connection_id));
50 if (strcmp(sdi->connection_id, connection_id))
51 /* This is not the one. */
55 if (!(err = libusb_open(devlist[i], &usb->devhdl))) {
56 if (usb->address == 0xff) {
58 * First time we touch this device after firmware upload,
59 * so we don't know the address yet.
61 usb->address = libusb_get_device_address(devlist[i]);
64 sr_info("Opened device on %d.%d (logical) / "
65 "%s (physical) interface %d.",
66 usb->bus, usb->address,
67 sdi->connection_id, USB_INTERFACE);
71 sr_err("Failed to open device: %s.",
72 libusb_error_name(err));
76 /* If we made it here, we handled the device (somehow). */
80 libusb_free_device_list(devlist, 1);
85 SR_PRIV void hantek_6xxx_close(struct sr_dev_inst *sdi)
87 struct sr_usb_dev_inst *usb;
94 sr_info("Closing device on %d.%d (logical) / %s (physical) interface %d.",
95 usb->bus, usb->address, sdi->connection_id, USB_INTERFACE);
96 libusb_release_interface(usb->devhdl, USB_INTERFACE);
97 libusb_close(usb->devhdl);
99 sdi->status = SR_ST_INACTIVE;
102 SR_PRIV int hantek_6xxx_get_channeldata(const struct sr_dev_inst *sdi,
103 libusb_transfer_cb_fn cb, uint32_t data_amount)
105 struct sr_usb_dev_inst *usb;
106 struct libusb_transfer *transfer;
110 sr_dbg("Request channel data.");
114 if (!(buf = g_try_malloc(data_amount))) {
115 sr_err("Failed to malloc USB endpoint buffer.");
116 return SR_ERR_MALLOC;
118 transfer = libusb_alloc_transfer(0);
119 libusb_fill_bulk_transfer(transfer, usb->devhdl, HANTEK_EP_IN, buf,
120 data_amount, cb, (void *)sdi, 4000);
121 if ((ret = libusb_submit_transfer(transfer)) < 0) {
122 sr_err("Failed to submit transfer: %s.",
123 libusb_error_name(ret));
124 /* TODO: Free them all. */
125 libusb_free_transfer(transfer);
133 static uint8_t samplerate_to_reg(uint64_t samplerate)
135 const uint64_t samplerate_values[] = {SAMPLERATE_VALUES};
136 const uint8_t samplerate_regs[] = {SAMPLERATE_REGS};
139 for (i = 0; i < ARRAY_SIZE(samplerate_values); i++) {
140 if (samplerate_values[i] == samplerate)
141 return samplerate_regs[i];
144 sr_err("Failed to convert samplerate: %" PRIu64 ".", samplerate);
146 return samplerate_regs[ARRAY_SIZE(samplerate_values) - 1];
149 static uint8_t voltage_to_reg(uint8_t state)
151 const uint8_t vdiv_reg[] = {VDIV_REG};
153 if (state < ARRAY_SIZE(vdiv_reg)) {
154 return vdiv_reg[state];
156 sr_err("Failed to convert vdiv: %d.", state);
157 return vdiv_reg[ARRAY_SIZE(vdiv_reg) - 1];
161 static int write_control(const struct sr_dev_inst *sdi,
162 enum control_requests reg, uint8_t value)
164 struct sr_usb_dev_inst *usb = sdi->conn;
167 sr_spew("hantek_6xxx_write_control: 0x%x 0x%x", reg, value);
169 if ((ret = libusb_control_transfer(usb->devhdl,
170 LIBUSB_REQUEST_TYPE_VENDOR, (uint8_t)reg,
171 0, 0, &value, 1, 100)) <= 0) {
172 sr_err("Failed to control transfer: 0x%x: %s.", reg,
173 libusb_error_name(ret));
180 SR_PRIV int hantek_6xxx_start_data_collecting(const struct sr_dev_inst *sdi)
183 return write_control(sdi, TRIGGER_REG, 1);
186 SR_PRIV int hantek_6xxx_stop_data_collecting(const struct sr_dev_inst *sdi)
188 return write_control(sdi, TRIGGER_REG, 0);
191 SR_PRIV int hantek_6xxx_update_samplerate(const struct sr_dev_inst *sdi)
193 struct dev_context *devc = sdi->priv;
194 sr_dbg("update samplerate %d", samplerate_to_reg(devc->samplerate));
196 return write_control(sdi, SAMPLERATE_REG, samplerate_to_reg(devc->samplerate));
199 SR_PRIV int hantek_6xxx_update_vdiv(const struct sr_dev_inst *sdi)
201 struct dev_context *devc = sdi->priv;
204 sr_dbg("update vdiv %d %d", voltage_to_reg(devc->voltage[0]),
205 voltage_to_reg(devc->voltage[1]));
207 ret1 = write_control(sdi, VDIV_CH1_REG, voltage_to_reg(devc->voltage[0]));
208 ret2 = write_control(sdi, VDIV_CH2_REG, voltage_to_reg(devc->voltage[1]));
210 return MIN(ret1, ret2);
213 SR_PRIV int hantek_6xxx_update_coupling(const struct sr_dev_inst *sdi)
215 struct dev_context *devc = sdi->priv;
216 uint8_t coupling = 0xFF & ((devc->coupling[1] << 4) | devc->coupling[0]);
218 if (devc->has_coupling) {
219 sr_dbg("update coupling 0x%x", coupling);
220 return write_control(sdi, COUPLING_REG, coupling);
222 sr_dbg("coupling not supported");
227 SR_PRIV int hantek_6xxx_update_channels(const struct sr_dev_inst *sdi)
229 struct dev_context *devc = sdi->priv;
230 uint8_t chan = devc->ch_enabled[1] ? 2 : 1;
231 sr_dbg("update channels amount %d", chan);
233 return write_control(sdi, CHANNELS_REG, chan);
236 SR_PRIV int hantek_6xxx_init(const struct sr_dev_inst *sdi)
238 sr_dbg("Initializing");
240 hantek_6xxx_update_samplerate(sdi);
241 hantek_6xxx_update_vdiv(sdi);
242 hantek_6xxx_update_coupling(sdi);
243 // hantek_6xxx_update_channels(sdi); /* Only 2 channel mode supported. */