BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

baylibre-acme: Add basic support for ACME revB. 

Revision B of ACME hardware introduces probes with on-board at24cs02
EEPROM. Extend the ACME driver to support reading the contents of
the EEPROM via linux' sysfs interface.

Also: make the driver be able to tell the difference between revisions,
add new GPIO layout and set the shunt resistance for revB at probe
registration.

Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
This commit is contained in:
Bartosz Golaszewski 2015-09-16 14:18:11 +02:00 committed by Uwe Hermann
parent 8f1961209b
commit 4678bdb607
1 changed files with 122 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
src/hardware/baylibre-acme/protocol.c
View File

@ -22,10 +22,14 @@
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <glib/gstdio.h>
#include "protocol.h"
#include "gpio.h"
#define ACME_REV_A 1
#define ACME_REV_B 2
enum channel_type {
ENRG_PWR = 1,
ENRG_CURR,
@ -35,10 +39,12 @@ enum channel_type {
};
struct channel_group_priv {
uint8_t rev;
int hwmon_num;
int probe_type;
int index;
int has_pws;
uint32_t pws_gpio;
};
struct channel_priv {
@ -48,6 +54,22 @@ struct channel_priv {
struct channel_group_priv *probe;
};
#define EEPROM_SERIAL_SIZE 16
#define EEPROM_TAG_SIZE 32
#define EEPROM_PROBE_TYPE_USB 1
#define EEPROM_PROBE_TYPE_JACK 2
#define EEPROM_PROBE_TYPE_HE10 3
struct probe_eeprom {
int type;
int rev;
unsigned long shunt;
uint8_t pwr_sw;
uint8_t serial[EEPROM_SERIAL_SIZE];
char tag[EEPROM_TAG_SIZE];
} __attribute__((packed));
static const uint8_t enrg_i2c_addrs[] = {
0x40, 0x41, 0x44, 0x45, 0x42, 0x43, 0x46, 0x47,
};
@ -56,14 +78,18 @@ static const uint8_t temp_i2c_addrs[] = {
0x0, 0x0, 0x0, 0x0, 0x4c, 0x49, 0x4f, 0x4b,
};
static const uint32_t pws_gpios[] = {
static const uint32_t revA_pws_gpios[] = {
486, 498, 502, 482, 478, 506, 510, 474,
};
static const uint32_t pws_info_gpios[] = {
static const uint32_t revA_pws_info_gpios[] = {
487, 499, 503, 483, 479, 507, 511, 475,
};
static const uint32_t revB_pws_gpios[] = {
489, 491, 493, 495, 497, 499, 501, 503,
};
#define MOHM_TO_UOHM(x) ((x) * 1000)
#define UOHM_TO_MOHM(x) ((x) / 1000)
@ -110,6 +136,13 @@ static void probe_hwmon_path(unsigned int addr, GString *path)
"/sys/class/i2c-adapter/i2c-1/1-00%02x/hwmon", addr);
}
static void probe_eeprom_path(unsigned int addr, GString *path)
{
g_string_printf(path,
"/sys/class/i2c-dev/i2c-1/device/1-00%02x/eeprom",
addr + 0x10);
}
SR_PRIV gboolean bl_acme_detect_probe(unsigned int addr,
int prb_num, const char *prb_name)
{
@ -221,12 +254,66 @@ static void append_channel(struct sr_dev_inst *sdi, struct sr_channel_group *cg,
cg->channels = g_slist_append(cg->channels, ch);
}
static int read_probe_eeprom(unsigned int addr, struct probe_eeprom *eeprom)
{
static const ssize_t len = sizeof(struct probe_eeprom);
GString *path = g_string_sized_new(64);
ssize_t rd;
int fd;
probe_eeprom_path(addr, path);
fd = g_open(path->str, O_RDONLY);
g_string_free(path, TRUE);
if (fd < 0)
return -1;
rd = read(fd, eeprom, len);
g_close(fd, NULL);
if (rd != len)
return -1;
/*
* All integer types are in network byte order. Convert them to
* host order before proceeding.
*/
eeprom->type = ntohl(eeprom->type);
eeprom->rev = ntohl(eeprom->rev);
eeprom->shunt = ntohl(eeprom->shunt);
/* Check if we have some sensible values. */
if (eeprom->rev != 'B')
/* 'B' is the only supported revision with EEPROM for now. */
return -1;
if (eeprom->type != EEPROM_PROBE_TYPE_USB &&
eeprom->type != EEPROM_PROBE_TYPE_JACK &&
eeprom->type != EEPROM_PROBE_TYPE_HE10)
return -1;
return 0;
}
/* Some i2c slave addresses on revision B probes differ from revision A. */
static int revB_addr_to_num(unsigned int addr)
{
switch (addr) {
case 0x44: return 5;
case 0x45: return 6;
case 0x42: return 3;
case 0x43: return 4;
default: return addr - 0x3f;
}
}
SR_PRIV gboolean bl_acme_register_probe(struct sr_dev_inst *sdi, int type,
unsigned int addr, int prb_num)
{
struct sr_channel_group *cg;
struct channel_group_priv *cgp;
int hwmon;
struct probe_eeprom eeprom;
int hwmon, status;
uint32_t gpio;
/* Obtain the hwmon index. */
hwmon = get_hwmon_index(addr);
@ -235,12 +322,39 @@ SR_PRIV gboolean bl_acme_register_probe(struct sr_dev_inst *sdi, int type,
cg = g_malloc0(sizeof(struct sr_channel_group));
cgp = g_malloc0(sizeof(struct channel_group_priv));
cg->priv = cgp;
/*
* See if we can read the EEPROM contents. If not, assume it's
* a revision A probe.
*/
status = read_probe_eeprom(addr, &eeprom);
cgp->rev = status < 0 ? ACME_REV_A : ACME_REV_B;
prb_num = cgp->rev == ACME_REV_A ? prb_num : revB_addr_to_num(addr);
cgp->hwmon_num = hwmon;
cgp->probe_type = type;
cgp->index = prb_num - 1;
cgp->has_pws = sr_gpio_getval_export(pws_info_gpios[cgp->index]);
cg->name = g_strdup_printf("Probe_%d", prb_num);
cg->priv = cgp;
if (cgp->rev == ACME_REV_A) {
gpio = revA_pws_info_gpios[cgp->index];
cgp->has_pws = sr_gpio_getval_export(gpio);
cgp->pws_gpio = revA_pws_gpios[cgp->index];
} else {
cgp->has_pws = eeprom.pwr_sw;
cgp->pws_gpio = revB_pws_gpios[cgp->index];
/*
* For revision B we can already try to set the shunt
* resistance according to the EEPROM contents.
*
* Keep the default value if shunt in EEPROM == 0.
*/
if (eeprom.shunt > 0)
bl_acme_set_shunt(cg, UOHM_TO_MOHM(eeprom.shunt));
}
if (type == PROBE_ENRG) {
append_channel(sdi, cg, prb_num, ENRG_PWR);
@ -417,7 +531,7 @@ SR_PRIV int bl_acme_read_power_state(const struct sr_channel_group *cg,
return SR_ERR_ARG;
}
val = sr_gpio_getval_export(pws_gpios[cgp->index]);
val = sr_gpio_getval_export(cgp->pws_gpio);
*off = val ? FALSE : TRUE;
return SR_OK;
@ -436,10 +550,10 @@ SR_PRIV int bl_acme_set_power_off(const struct sr_channel_group *cg,
return SR_ERR_ARG;
}
val = sr_gpio_setval_export(pws_gpios[cgp->index], off ? 0 : 1);
val = sr_gpio_setval_export(cgp->pws_gpio, off ? 0 : 1);
if (val < 0) {
sr_err("Error setting power-off state: gpio: %d",
pws_gpios[cgp->index]);
cgp->pws_gpio);
return SR_ERR_IO;
}