jepler/mesaflash
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

libanyio: use base address from module descriptor, not from regmap

Browse source 
base addresses of modules are going to be changeable

Signed-off-by: Michael Geszkiewicz <micges@wp.pl>
This commit is contained in:
Michael Geszkiewicz 2015-03-11 00:40:08 +01:00
parent 3106d0df2b
commit 83b52e3b3c
6 changed files with 224 additions and 205 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
encoder_module.c
View file

@ -61,6 +61,7 @@ int encoder_init(encoder_module_t *enc, board_t *board, int instance, int delay)
memset(enc, 0, sizeof(encoder_module_t));
enc->scale = 1.0;
enc->board = board;
enc->base_address = md->base_address;
enc->instance = instance;
enc->instance_stride = (md->strides & 0xF0) == 0 ? board->llio.hm2.idrom.instance_stride0 : board->llio.hm2.idrom.instance_stride1;
@ -73,11 +74,11 @@ int encoder_init(encoder_module_t *enc, board_t *board, int instance, int delay)
clock = (enc->board->llio.hm2.idrom.clock_high / 1e6 * delay) - 2;
seconds_per_tsdiv_clock = (double)(clock + 2) / (double)enc->board->llio.hm2.idrom.clock_high;
}
enc->board->llio.write(&(enc->board->llio), HM2_MODULE_MUX_ENCODER_TSSDIV, &clock, sizeof(clock));
enc->board->llio.read(&(enc->board->llio), HM2_MODULE_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
enc->board->llio.write(&(enc->board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_TSSDIV, &clock, sizeof(clock));
enc->board->llio.read(&(enc->board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
control |= HM2_ENCODER_FILTER;
control &= ~(HM2_ENCODER_QUADRATURE_ERROR);
enc->board->llio.write(&(enc->board->llio), HM2_MODULE_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
enc->board->llio.write(&(enc->board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
}
int encoder_cleanup(encoder_module_t *enc) {
@ -99,9 +100,9 @@ int encoder_read(encoder_module_t *enc) {
}
board = enc->board;
board->llio.read(&(board->llio), HM2_MODULE_MUX_ENCODER_TS_COUNT, &tsc, sizeof(tsc));
board->llio.read(&(board->llio), HM2_MODULE_MUX_ENCODER_COUNTER + enc->instance*enc->instance_stride, &count, sizeof(count));
board->llio.read(&(board->llio), HM2_MODULE_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
board->llio.read(&(board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_TS_COUNT, &tsc, sizeof(tsc));
board->llio.read(&(board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_COUNTER + enc->instance*enc->instance_stride, &count, sizeof(count));
board->llio.read(&(board->llio), enc->base_address + HM2_MOD_OFFS_MUX_ENCODER_LATCH_CCR + enc->instance*enc->instance_stride, &control, sizeof(control));
if (enc->scale == 0) {
enc->scale = 1.0;

1
encoder_module.h
View file

@ -32,6 +32,7 @@ typedef struct {
double scale;
int quad_error;
board_t *board;
u16 base_address;
int instance;
int instance_stride;
} encoder_module_t;

22
hostmot2.c
View file

@ -265,13 +265,20 @@ hm2_module_desc_t *hm2_find_module(hostmot2_t *hm2, u8 gtag) {
void hm2_set_pin_source(hostmot2_t *hm2, int pin_number, u8 source) {
u32 data;
u16 addr;
hm2_module_desc_t *md = hm2_find_module(hm2, HM2_GTAG_IOPORT);
if (md == NULL) {
printf("hm2_set_pin_source(): no IOPORT module found\n");
return;
}
if ((pin_number < 0) || (pin_number >= (hm2->idrom.io_ports*hm2->idrom.io_width))) {
printf("hm2_set_pin_source(): invalid pin number %d\n", pin_number);
return;
}
hm2->llio->read(hm2->llio, HM2_MODULE_GPIO_ALT_SOURCE + (pin_number / 24)*4, &data, sizeof(data));
addr = md->base_address;
hm2->llio->read(hm2->llio, addr + HM2_MOD_OFFS_GPIO_ALT_SOURCE + (pin_number / 24)*4, &data, sizeof(data));
if (source == HM2_PIN_SOURCE_IS_PRIMARY) {
data &= ~(1 << (pin_number % 24));
} else if (source == HM2_PIN_SOURCE_IS_SECONDARY) {
@ -280,18 +287,25 @@ void hm2_set_pin_source(hostmot2_t *hm2, int pin_number, u8 source) {
printf("hm2_set_pin_source(): invalid pin source 0x%02X\n", source);
return;
}
hm2->llio->write(hm2->llio, HM2_MODULE_GPIO_ALT_SOURCE + (pin_number / 24)*4, &data, sizeof(data));
hm2->llio->write(hm2->llio, addr + HM2_MOD_OFFS_GPIO_ALT_SOURCE + (pin_number / 24)*4, &data, sizeof(data));
}
void hm2_set_pin_direction(hostmot2_t *hm2, int pin_number, u8 direction) {
u32 data;
u16 addr;
hm2_module_desc_t *md = hm2_find_module(hm2, HM2_GTAG_IOPORT);
if (md == NULL) {
printf("hm2_set_pin_direction(): no IOPORT module found\n");
return;
}
if ((pin_number < 0) || (pin_number >= (hm2->idrom.io_ports*hm2->idrom.io_width))) {
printf("hm2_set_pin_direction(): invalid pin number %d\n", pin_number);
return;
}
hm2->llio->read(hm2->llio, HM2_MODULE_GPIO_DDR + (pin_number / 24)*4, &data, sizeof(data));
addr = md->base_address;
hm2->llio->read(hm2->llio, addr + HM2_MOD_OFFS_GPIO_DDR + (pin_number / 24)*4, &data, sizeof(data));
if (direction == HM2_PIN_DIR_IS_INPUT) {
data &= ~(1 << (pin_number % 24));
} else if (direction == HM2_PIN_DIR_IS_OUTPUT) {
@ -300,7 +314,7 @@ void hm2_set_pin_direction(hostmot2_t *hm2, int pin_number, u8 direction) {
printf("hm2_set_pin_direction(): invalid pin direction 0x%02X\n", direction);
return;
}
hm2->llio->write(hm2->llio, HM2_MODULE_GPIO_DDR + (pin_number / 24)*4, &data, sizeof(data));
hm2->llio->write(hm2->llio, addr + HM2_MOD_OFFS_GPIO_DDR + (pin_number / 24)*4, &data, sizeof(data));
}
void hm2_print_idrom(hostmot2_t *hm2) {

79
hostmot2_def.h
View file

@ -141,58 +141,50 @@ typedef struct {
// LEDS MODULE
#define HM2_MODULE_LED 0x0200
#define HM2_MOD_OFFS_LED 0x0200
// WATCHDOG MODULE
#define HM2_MODULE_WD_TIMER 0x0C00
#define HM2_MODULE_WD_STATUS 0x0D00
#define HM2_MODULE_WD_RESET 0x0E00
#define HM2_MOD_OFFS_WD_TIMER 0x0000
#define HM2_MOD_OFFS_WD_STATUS 0x0100
#define HM2_MOD_OFFS_WD_RESET 0x0200
// GPIO MODULE
#define HM2_MODULE_GPIO 0x1000
#define HM2_MODULE_GPIO_DDR 0x1100
#define HM2_MODULE_GPIO_ALT_SOURCE 0x1200
#define HM2_MODULE_GPIO_OPEN_DRAIN 0x1300
#define HM2_MODULE_GPIO_INVERT_OUT 0x1400
#define HM2_MOD_OFFS_GPIO 0x0000
#define HM2_MOD_OFFS_GPIO_DDR 0x0100
#define HM2_MOD_OFFS_GPIO_ALT_SOURCE 0x0200
#define HM2_MOD_OFFS_GPIO_OPEN_DRAIN 0x0300
#define HM2_MOD_OFFS_GPIO_INVERT_OUT 0x0400
// STEPGEN MODULE
#define HM2_MODULE_STEPGEN_RATE 0x2000
#define HM2_MODULE_STEPGEN_ACCUM 0x2100
#define HM2_MODULE_STEPGEN_MODE 0x2200
#define HM2_MODULE_STEPGEN_DIR_SETUP 0x2300
#define HM2_MODULE_STEPGEN_DIR_HOLD 0x2400
#define HM2_MODULE_STEPGEN_STEP_LEN 0x2500
#define HM2_MODULE_STEPGEN_STEP_SPACE 0x2600
#define HM2_MODULE_STEPGEN_TABLE_DATA 0x2700
#define HM2_MODULE_STEPGEN_TABLE_LEN 0x2800
#define HM2_MODULE_STEPGEN_DDS 0x2900
// WAVEGEN MODULE
#define HM2_MODULE_WAVEGEN_RATE 0x2A00
#define HM2_MODULE_WAVEGEN_PDM 0x2B00
#define HM2_MODULE_WAVEGEN_TABLE_LEN 0x2C00
#define HM2_MODULE_WAVEGEN_TABLE_PTR 0x2D00
#define HM2_MODULE_WAVEGEN_TABLE_DATA 0x2E00
#define HM2_MOD_OFFS_STEPGEN_RATE 0x0000
#define HM2_MOD_OFFS_STEPGEN_ACCUM 0x0100
#define HM2_MOD_OFFS_STEPGEN_MODE 0x0200
#define HM2_MOD_OFFS_STEPGEN_DIR_SETUP 0x0300
#define HM2_MOD_OFFS_STEPGEN_DIR_HOLD 0x0400
#define HM2_MOD_OFFS_STEPGEN_STEP_LEN 0x0500
#define HM2_MOD_OFFS_STEPGEN_STEP_SPACE 0x0600
#define HM2_MOD_OFFS_STEPGEN_TABLE_DATA 0x0700
#define HM2_MOD_OFFS_STEPGEN_TABLE_LEN 0x0800
#define HM2_MOD_OFFS_STEPGEN_DDS 0x0900
// ENCODER MODULE
#define HM2_MODULE_ENCODER_COUNTER 0x3000
#define HM2_MODULE_ENCODER_LATCH_CCR 0x3100
#define HM2_MODULE_ENCODER_TSSDIV 0x3200
#define HM2_MODULE_ENCODER_TS_COUNT 0x3300
#define HM2_MODULE_ENCODER_FILTER_RATE 0x3400
#define HM2_MOD_OFFS_ENCODER_COUNTER 0x0000
#define HM2_MOD_OFFS_ENCODER_LATCH_CCR 0x0100
#define HM2_MOD_OFFS_ENCODER_TSSDIV 0x0200
#define HM2_MOD_OFFS_ENCODER_TS_COUNT 0x0300
#define HM2_MOD_OFFS_ENCODER_FILTER_RATE 0x0400
// MUXED ENCODER MODULE
#define HM2_MODULE_MUX_ENCODER_COUNTER 0x3500
#define HM2_MODULE_MUX_ENCODER_LATCH_CCR 0x3600
#define HM2_MODULE_MUX_ENCODER_TSSDIV 0x3700
#define HM2_MODULE_MUX_ENCODER_TS_COUNT 0x3800
#define HM2_MODULE_MUX_ENCODER_FILTER_RATE 0x3900
#define HM2_MOD_OFFS_MUX_ENCODER_COUNTER 0x0000
#define HM2_MOD_OFFS_MUX_ENCODER_LATCH_CCR 0x0100
#define HM2_MOD_OFFS_MUX_ENCODER_TSSDIV 0x0200
#define HM2_MOD_OFFS_MUX_ENCODER_TS_COUNT 0x0300
#define HM2_MOD_OFFS_MUX_ENCODER_FILTER_RATE 0x0400
#define HM2_ENCODER_QUADRATURE_ERROR (1 << 15)
#define HM2_ENCODER_AB_MASK_POLARITY (1 << 14)
@ -217,13 +209,12 @@ typedef struct {
#define HM2_SSERIAL_MAX_INTEFACES 4
#define HM2_SSERIAL_MAX_CHANNELS 8
#define HM2_MODULE_SSERIAL 0x5A00
#define HM2_MODULE_SSERIAL_CMD HM2_MODULE_SSERIAL
#define HM2_MODULE_SSERIAL_DATA 0x5B00
#define HM2_MODULE_SSERIAL_CS 0x5C00
#define HM2_MODULE_SSERIAL_INTERFACE0 0x5D00
#define HM2_MODULE_SSERIAL_INTERFACE1 0x5E00
#define HM2_MODULE_SSERIAL_INTERFACE2 0x5F00
#define HM2_MOD_OFFS_SSERIAL_CMD 0x0000
#define HM2_MOD_OFFS_SSERIAL_DATA 0x0100
#define HM2_MOD_OFFS_SSERIAL_CS 0x0200
#define HM2_MOD_OFFS_SSERIAL_INTERFACE0 0x0300
#define HM2_MOD_OFFS_SSERIAL_INTERFACE1 0x0400
#define HM2_MOD_OFFS_SSERIAL_INTERFACE2 0x0500
#define SSLBP_TYPE_LOC 0
#define SSLBP_WIDTH_LOC 1

313
sserial_module.c
View file

@ -29,6 +29,8 @@ static void enable_sserial_pins(llio_t *llio) {
int port_pin, port;
int pin = -1;
int chan_counts[] = {0,0,0,0,0,0,0,0};
hm2_module_desc_t *md = hm2_find_module(&(llio->hm2), HM2_GTAG_IOPORT);
u16 addr = md->base_address;
for (port = 0; port < 2; port ++) {
u32 ddr_reg = 0;
@ -47,8 +49,8 @@ static void enable_sserial_pins(llio_t *llio) {
ddr_reg |= (1 << port_pin);
}
}
llio->write(llio, 0x1100 + 4*port, &ddr_reg, sizeof(u32));
llio->write(llio, 0x1200 + 4*port, &src_reg, sizeof(u32));
llio->write(llio, addr + HM2_MOD_OFFS_GPIO_DDR + 4*port, &ddr_reg, sizeof(u32));
llio->write(llio, addr + HM2_MOD_OFFS_GPIO_ALT_SOURCE + 4*port, &src_reg, sizeof(u32));
}
}
@ -57,156 +59,158 @@ static void disable_sserial_pins(llio_t *llio) {
int port_pin, port;
u32 ddr_reg = 0;
u32 src_reg = 0;
hm2_module_desc_t *md = hm2_find_module(&(llio->hm2), HM2_GTAG_IOPORT);
u16 addr = md->base_address;
for (port = 0; port < 2; port ++) {
llio->write(llio, 0x1100 + 4*port, &ddr_reg, sizeof(u32));
llio->write(llio, 0x1200 + 4*port, &src_reg, sizeof(u32));
llio->write(llio, addr + HM2_MOD_OFFS_GPIO_DDR + 4*port, &ddr_reg, sizeof(u32));
llio->write(llio, addr + HM2_MOD_OFFS_GPIO_ALT_SOURCE + 4*port, &src_reg, sizeof(u32));
}
}
void sslbp_send_local_cmd(llio_t *llio, int interface, u32 cmd) {
llio->write(llio, HM2_MODULE_SSERIAL_CMD + interface*0x40, &(cmd), sizeof(u32));
void sslbp_send_local_cmd(sserial_module_t *ssmod, int interface, u32 cmd) {
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CMD + interface*0x40, &(cmd), sizeof(u32));
}
u32 sslbp_read_local_cmd(llio_t *llio, int interface) {
u32 sslbp_read_local_cmd(sserial_module_t *ssmod, int interface) {
u32 data;
llio->read(llio, HM2_MODULE_SSERIAL_CMD + interface*0x40, &(data), sizeof(u32));
ssmod->board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CMD + interface*0x40, &(data), sizeof(u32));
return data;
}
u8 sslbp_read_data(llio_t *llio, int interface) {
u8 sslbp_read_data(sserial_module_t *ssmod, int interface) {
u32 data;
llio->read(llio, HM2_MODULE_SSERIAL_DATA + interface*0x40, &(data), sizeof(u32));
ssmod->board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_DATA + interface*0x40, &(data), sizeof(u32));
return data & 0xFF;
}
void sslbp_wait_complete(llio_t *llio, int interface) {
while (sslbp_read_local_cmd(llio, interface) != 0) {}
void sslbp_wait_complete(sserial_module_t *ssmod, int interface) {
while (sslbp_read_local_cmd(ssmod, interface) != 0) {}
}
void sslbp_send_remote_cmd(llio_t *llio, int interface, int channel, u32 cmd) {
llio->write(llio, HM2_MODULE_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
void sslbp_send_remote_cmd(sserial_module_t *ssmod, int interface, int channel, u32 cmd) {
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
}
u8 sslbp_read_local8(llio_t *llio, int interface, u32 addr) {
u8 sslbp_read_local8(sserial_module_t *ssmod, int interface, u32 addr) {
u8 ret;
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_READ(addr));
sslbp_wait_complete(llio, interface);
return sslbp_read_data(llio, interface);
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_READ(addr));
sslbp_wait_complete(ssmod, interface);
return sslbp_read_data(ssmod, interface);
}
u32 sslbp_read_local32(llio_t *llio, int interface, u32 addr) {
u32 sslbp_read_local32(sserial_module_t *ssmod, int interface, u32 addr) {
int byte = 4;
u32 ret = 0;
for (; byte--;)
ret = (ret << 8) | sslbp_read_local8(llio, interface, addr + byte);
ret = (ret << 8) | sslbp_read_local8(ssmod, interface, addr + byte);
return ret;
}
u8 sslbp_read_remote8(llio_t *llio, int interface, int channel, u32 addr) {
u8 sslbp_read_remote8(sserial_module_t *ssmod, int interface, int channel, u32 addr) {
u32 data;
sslbp_send_remote_cmd(llio, interface, channel, ((LBP_CMD_READ | LBP_ADDR_AUTO_INC) << 24) | addr);
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
llio->read(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(data), sizeof(u32));
sslbp_send_remote_cmd(ssmod, interface, channel, ((LBP_CMD_READ | LBP_ADDR_AUTO_INC) << 24) | addr);
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
ssmod->board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(data), sizeof(u32));
return data & 0xFF;
}
u16 sslbp_read_remote16(llio_t *llio, int interface, int channel, u32 addr) {
u16 sslbp_read_remote16(sserial_module_t *ssmod, int interface, int channel, u32 addr) {
int byte;
u16 ret = 0;
for (byte = 1; byte >= 0; byte--)
ret = (ret << 8) | sslbp_read_remote8(llio, interface, channel, addr + byte);
ret = (ret << 8) | sslbp_read_remote8(ssmod, interface, channel, addr + byte);
return ret;
}
u32 sslbp_read_remote32(llio_t *llio, int interface, int channel, u32 addr) {
u32 sslbp_read_remote32(sserial_module_t *ssmod, int interface, int channel, u32 addr) {
int byte;
u32 ret = 0;
for (byte = 3; byte >=0; byte--)
ret = (ret << 8) | sslbp_read_remote8(llio, interface, channel, addr + byte);
ret = (ret << 8) | sslbp_read_remote8(ssmod, interface, channel, addr + byte);
return ret;
}
void sslbp_write_remote8(llio_t *llio, int interface, int channel, u32 addr, u8 data) {
void sslbp_write_remote8(sserial_module_t *ssmod, int interface, int channel, u32 addr, u8 data) {
u32 d = data;
sslbp_send_remote_cmd(llio, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_8BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
sslbp_send_remote_cmd(ssmod, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_8BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
}
void sslbp_write_remote16(llio_t *llio, int interface, int channel, u32 addr, u16 data) {
void sslbp_write_remote16(sserial_module_t *ssmod, int interface, int channel, u32 addr, u16 data) {
u32 d = data;
sslbp_send_remote_cmd(llio, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_16BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
sslbp_send_remote_cmd(ssmod, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_16BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
}
void sslbp_write_remote32(llio_t *llio, int interface, int channel, u32 addr, u32 data) {
void sslbp_write_remote32(sserial_module_t *ssmod, int interface, int channel, u32 addr, u32 data) {
u32 d = data;
sslbp_send_remote_cmd(llio, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_32BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
sslbp_send_remote_cmd(ssmod, interface, channel, ((LBP_CMD_WRITE | LBP_ARGS_32BIT | LBP_ADDR_AUTO_INC) << 24) | addr);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(d), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
}
u16 sslbp_read_nv_remote16(llio_t *llio, int interface, int channel, u32 addr) {
u16 sslbp_read_nv_remote16(sserial_module_t *ssmod, int interface, int channel, u32 addr) {
u16 data;
u32 cmd = LBP_CMD_READ_NV << 24;
llio->write(llio, HM2_MODULE_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
cmd = LBP_NVEEPROM_BYTE;
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
data = sslbp_read_remote16(llio, interface, channel, addr);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
data = sslbp_read_remote16(ssmod, interface, channel, addr);
cmd = LBP_CMD_READ_NV << 24;
llio->write(llio, HM2_MODULE_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
cmd = 0;
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
return data;
}
u32 sslbp_read_nv_remote32(llio_t *llio, int interface, int channel, u32 addr) {
u32 sslbp_read_nv_remote32(sserial_module_t *ssmod, int interface, int channel, u32 addr) {
u32 data;
u32 cmd = LBP_CMD_READ_NV << 24;
llio->write(llio, HM2_MODULE_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
cmd = LBP_NVEEPROM_BYTE;
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
data = sslbp_read_remote32(llio, interface, channel, addr);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
data = sslbp_read_remote32(ssmod, interface, channel, addr);
cmd = LBP_CMD_READ_NV << 24;
llio->write(llio, HM2_MODULE_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface*0x40 + channel*4, &(cmd), sizeof(u32));
cmd = 0;
llio->write(llio, HM2_MODULE_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(llio, interface);
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(ssmod, interface, SSLBP_CMD_DOIT(channel));
sslbp_wait_complete(ssmod, interface);
return data;
}
void sslbp_read_remote_bytes(llio_t *llio, int interface, int channel, u32 addr, void *buffer, int size) {
void sslbp_read_remote_bytes(sserial_module_t *ssmod, int interface, int channel, u32 addr, void *buffer, int size) {
char *ptr = (char *) buffer;
while (size != 0) {
u8 data = sslbp_read_remote8(llio, interface, channel, addr);
u8 data = sslbp_read_remote8(ssmod, interface, channel, addr);
*(ptr++) = data;
addr++;
size--;
@ -240,23 +244,24 @@ int sserial_init(sserial_module_t *ssmod, board_t *board, int interface_num, int
ssmod->board = board;
ssmod->interface_num = interface_num;
ssmod->channel_num = channel_num;
ssmod->base_address = md->base_address;
ssmod->instance_stride = (md->strides & 0xF0) == 0 ? board->llio.hm2.idrom.instance_stride0 : board->llio.hm2.idrom.instance_stride1;
enable_sserial_pins(&(ssmod->board->llio));
sslbp_send_local_cmd(&(ssmod->board->llio), interface_num, SSLBP_CMD_STOPALL | SSLBP_CMD_RESET); // assert reset flag
sslbp_send_local_cmd(&(ssmod->board->llio), interface_num, SSLBP_CMD_STOPALL); // deassert reset flag
sslbp_wait_complete(&(ssmod->board->llio), interface_num); // wait for reset to finish
sslbp_send_local_cmd(ssmod, interface_num, SSLBP_CMD_STOPALL | SSLBP_CMD_RESET); // assert reset flag
sslbp_send_local_cmd(ssmod, interface_num, SSLBP_CMD_STOPALL); // deassert reset flag
sslbp_wait_complete(ssmod, interface_num); // wait for reset to finish
ssmod->interface.type = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_TYPE_LOC);
ssmod->interface.width = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_WIDTH_LOC);
ssmod->interface.ver_major = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_MAJOR_REV_LOC);
ssmod->interface.ver_minor = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_MINOR_REV_LOC);
ssmod->interface.gp_inputs = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_CHANNEL_START_LOC);
ssmod->interface.gp_outputs = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_CHANNEL_STRIDE_LOC);
ssmod->interface.processor_type = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_PROCESSOR_TYPE_LOC);
ssmod->interface.channels_count = sslbp_read_local8(&(ssmod->board->llio), interface_num, SSLBP_NR_CHANNELS_LOC);
ssmod->interface.baud_rate = sslbp_read_local32(&(ssmod->board->llio), interface_num, ssmod->interface.gp_inputs + 42);
ssmod->interface.clock = sslbp_read_local32(&(ssmod->board->llio), interface_num, SSLBP_CLOCK_LOC);
ssmod->interface.type = sslbp_read_local8(ssmod, interface_num, SSLBP_TYPE_LOC);
ssmod->interface.width = sslbp_read_local8(ssmod, interface_num, SSLBP_WIDTH_LOC);
ssmod->interface.ver_major = sslbp_read_local8(ssmod, interface_num, SSLBP_MAJOR_REV_LOC);
ssmod->interface.ver_minor = sslbp_read_local8(ssmod, interface_num, SSLBP_MINOR_REV_LOC);
ssmod->interface.gp_inputs = sslbp_read_local8(ssmod, interface_num, SSLBP_CHANNEL_START_LOC);
ssmod->interface.gp_outputs = sslbp_read_local8(ssmod, interface_num, SSLBP_CHANNEL_STRIDE_LOC);
ssmod->interface.processor_type = sslbp_read_local8(ssmod, interface_num, SSLBP_PROCESSOR_TYPE_LOC);
ssmod->interface.channels_count = sslbp_read_local8(ssmod, interface_num, SSLBP_NR_CHANNELS_LOC);
ssmod->interface.baud_rate = sslbp_read_local32(ssmod, interface_num, ssmod->interface.gp_inputs + 42);
ssmod->interface.clock = sslbp_read_local32(ssmod, interface_num, SSLBP_CLOCK_LOC);
if (0) {//ssmod->board->llio.verbose == 1) {
printf("SSLBP port %d:\n", interface_num);
@ -272,35 +277,35 @@ int sserial_init(sserial_module_t *ssmod, board_t *board, int interface_num, int
}
cmd = 0;
board->llio.write(&(ssmod->board->llio), HM2_MODULE_SSERIAL_CS + interface_num*ssmod->instance_stride + channel_num*4, &(cmd), sizeof(u32));
board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface_num*ssmod->instance_stride + channel_num*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(&(ssmod->board->llio), interface_num, SSLBP_CMD_START_SETUP_MODE(channel_num));
sslbp_wait_complete(&(ssmod->board->llio), interface_num);
if (sslbp_read_data(&(ssmod->board->llio), interface_num) != 0) {
sslbp_send_local_cmd(ssmod, interface_num, SSLBP_CMD_START_SETUP_MODE(channel_num));
sslbp_wait_complete(ssmod, interface_num);
if (sslbp_read_data(ssmod, interface_num) != 0) {
printf("Error reading sserial interface %d channel %d\n", interface_num, channel_num);
return -1;
}
board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_CS + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE0 + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
if ((status & 0xFF000000) != remote_type) {
printf("Found wrong remote at %d:%d, reqeust %x but found %x\n", interface_num, channel_num, remote_type, status);
return -1;
}
ssmod->device.unit = status;
board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE1 + interface_num*ssmod->instance_stride + channel_num*4, &(ssmod->device.name), sizeof(u32));
board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE2 + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE1 + interface_num*ssmod->instance_stride + channel_num*4, &(ssmod->device.name), sizeof(u32));
board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE2 + interface_num*ssmod->instance_stride + channel_num*4, &(status), sizeof(u32));
printf("device at %d:%d: %.*s (unit 0x%08X)\n", interface_num, channel_num, 4, ssmod->device.name, ssmod->device.unit);
sslbp_send_local_cmd(&(ssmod->board->llio), 0, SSLBP_CMD_STOPALL);
sslbp_wait_complete(&(ssmod->board->llio), 0);
sslbp_send_local_cmd(ssmod, 0, SSLBP_CMD_STOPALL);
sslbp_wait_complete(ssmod, 0);
cmd = 0;
board->llio.write(&(ssmod->board->llio), HM2_MODULE_SSERIAL_CS + channel_num*4, &(cmd), sizeof(cmd));
board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + channel_num*4, &(cmd), sizeof(cmd));
printf("starting device %d:%d\n", interface_num, channel_num);
sslbp_send_local_cmd(&(ssmod->board->llio), 0, SSLBP_CMD_START_NORMAL_MODE(channel_num));
sslbp_wait_complete(&(ssmod->board->llio), 0);
board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_DATA + channel_num*4, &(status), sizeof(u32));
sslbp_send_local_cmd(ssmod, 0, SSLBP_CMD_START_NORMAL_MODE(channel_num));
sslbp_wait_complete(ssmod, 0);
board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_DATA + channel_num*4, &(status), sizeof(u32));
if (status != 0) {
printf("Error while starting sserial: %X\n", status);
return -1;
@ -315,13 +320,13 @@ int sserial_cleanup(sserial_module_t *ssmod) {
}
int sserial_write(sserial_module_t *ssmod) {
ssmod->board->llio.write(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE0 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface0), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE1 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface1), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), HM2_MODULE_SSERIAL_INTERFACE2 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface2), sizeof(u32));
sslbp_send_local_cmd(&(ssmod->board->llio), 0, SSLBP_CMD_DOIT(1));
sslbp_wait_complete(&(ssmod->board->llio), 0);
ssmod->board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_DATA + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->data), sizeof(u32));
ssmod->board->llio.read(&(ssmod->board->llio), HM2_MODULE_SSERIAL_CS + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->cs), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface0), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE1 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface1), sizeof(u32));
ssmod->board->llio.write(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE2 + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->interface2), sizeof(u32));
sslbp_send_local_cmd(ssmod, 0, SSLBP_CMD_DOIT(1));
sslbp_wait_complete(ssmod, 0);
ssmod->board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_DATA + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->data), sizeof(u32));
ssmod->board->llio.read(&(ssmod->board->llio), ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + ssmod->interface_num*ssmod->instance_stride + ssmod->channel_num*4, &(ssmod->cs), sizeof(u32));
return 0;
}
@ -330,31 +335,37 @@ void sserial_module_init(llio_t *llio) {
u32 cmd, status, data, addr;
u16 d;
int port, channel, i;
hm2_module_desc_t *sserial_mod = hm2_find_module(&(llio->hm2), HM2_GTAG_SSERIAL);
hm2_module_desc_t *md = hm2_find_module(&(llio->hm2), HM2_GTAG_SSERIAL);
sserial_module_t ssmodule, *ssmod = &ssmodule;
char *record_types[9] = {"PADDING", "BITFIELD", "UNSIGNED", "SIGNED", "NV UNSIGNED", "NV SIGNED", "STREAM", "BOOLEAN", "ENCODER"};
char *mode_types[2] = {"HARDWARE", "SOFTWARE"};
char *baud_rates[12] = {"9600b", "19200b", "38400b", "57600b", "115200b", "230400b", "460800b", "921600b", "1.25Mb", "2.5Mb", "5Mb", "10Mb"};
if (sserial_mod == NULL)
if (md == NULL)
return;
memset(ssmod, 0, sizeof(sserial_module_t));
ssmod->board = llio->board;
ssmod->base_address = md->base_address;
ssmod->instance_stride = (md->strides & 0xF0) == 0 ? llio->hm2.idrom.instance_stride0 : llio->hm2.idrom.instance_stride1;
enable_sserial_pins(llio);
for (port = 0; port < 1; port++) {
sslbp_send_local_cmd(llio, port, SSLBP_CMD_STOPALL | SSLBP_CMD_RESET); // assert reset flag
sslbp_send_local_cmd(llio, port, SSLBP_CMD_STOPALL); // deassert reset flag
sslbp_wait_complete(llio, port); // wait for reset to finish
sslbp_send_local_cmd(ssmod, port, SSLBP_CMD_STOPALL | SSLBP_CMD_RESET); // assert reset flag
sslbp_send_local_cmd(ssmod, port, SSLBP_CMD_STOPALL); // deassert reset flag
sslbp_wait_complete(ssmod, port); // wait for reset to finish
llio->ss_interface[port].type = sslbp_read_local8(llio, port, 0);
llio->ss_interface[port].width = sslbp_read_local8(llio, port, 1);
llio->ss_interface[port].ver_major = sslbp_read_local8(llio, port, SSLBP_MAJOR_REV_LOC);
llio->ss_interface[port].ver_minor = sslbp_read_local8(llio, port, SSLBP_MINOR_REV_LOC);
llio->ss_interface[port].gp_inputs = sslbp_read_local8(llio, port, SSLBP_CHANNEL_START_LOC);
llio->ss_interface[port].gp_outputs = sslbp_read_local8(llio, port, SSLBP_CHANNEL_STRIDE_LOC);
llio->ss_interface[port].processor_type = sslbp_read_local8(llio, port, SSLBP_PROCESSOR_TYPE_LOC);
llio->ss_interface[port].channels_count = sslbp_read_local8(llio, port, SSLBP_NR_CHANNELS_LOC);
llio->ss_interface[port].baud_rate = sslbp_read_local32(llio, port, llio->ss_interface[port].gp_inputs + 42);
llio->ss_interface[port].clock = sslbp_read_local32(llio, port, SSLBP_CLOCK_LOC);
llio->ss_interface[port].type = sslbp_read_local8(ssmod, port, 0);
llio->ss_interface[port].width = sslbp_read_local8(ssmod, port, 1);
llio->ss_interface[port].ver_major = sslbp_read_local8(ssmod, port, SSLBP_MAJOR_REV_LOC);
llio->ss_interface[port].ver_minor = sslbp_read_local8(ssmod, port, SSLBP_MINOR_REV_LOC);
llio->ss_interface[port].gp_inputs = sslbp_read_local8(ssmod, port, SSLBP_CHANNEL_START_LOC);
llio->ss_interface[port].gp_outputs = sslbp_read_local8(ssmod, port, SSLBP_CHANNEL_STRIDE_LOC);
llio->ss_interface[port].processor_type = sslbp_read_local8(ssmod, port, SSLBP_PROCESSOR_TYPE_LOC);
llio->ss_interface[port].channels_count = sslbp_read_local8(ssmod, port, SSLBP_NR_CHANNELS_LOC);
llio->ss_interface[port].baud_rate = sslbp_read_local32(ssmod, port, llio->ss_interface[port].gp_inputs + 42);
llio->ss_interface[port].clock = sslbp_read_local32(ssmod, port, SSLBP_CLOCK_LOC);
printf("SSLBP port %d:\n", port);
printf(" SSLBP Version: %d.%d\n", llio->ss_interface[port].ver_major, llio->ss_interface[port].ver_minor);
@ -371,22 +382,22 @@ void sserial_module_init(llio_t *llio) {
for (channel = 0; channel < llio->ss_interface[port].width; channel++) {
cmd = 0;
llio->write(llio, HM2_MODULE_SSERIAL_CS + port*0x40 + channel*4, &(cmd), sizeof(u32));
llio->write(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + port*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, port, SSLBP_CMD_START_SETUP_MODE(channel));
sslbp_wait_complete(llio, port);
if (sslbp_read_data(llio, port) != 0)
sslbp_send_local_cmd(ssmod, port, SSLBP_CMD_START_SETUP_MODE(channel));
sslbp_wait_complete(ssmod, port);
if (sslbp_read_data(ssmod, port) != 0)
continue;
llio->read(llio, HM2_MODULE_SSERIAL_CS + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, HM2_MODULE_SSERIAL_INTERFACE0 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE0 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->ss_device[channel].unit = status;
llio->read(llio, HM2_MODULE_SSERIAL_INTERFACE1 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE1 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->ss_device[channel].name[0] = status & 0xFF;
llio->ss_device[channel].name[1] = (status >> 8) & 0xFF;
llio->ss_device[channel].name[2] = (status >> 16) & 0xFF;
llio->ss_device[channel].name[3] = (status >> 24) & 0xFF;
llio->read(llio, HM2_MODULE_SSERIAL_INTERFACE2 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_INTERFACE2 + port*0x40 + channel*4, &(status), sizeof(u32));
printf(" sserial device at channel %d: %.*s", channel, 4, llio->ss_device[channel].name);
if ((llio->ss_device[channel].unit & 0xFF000000) == SSLBP_REMOTE_7I76_IO_SPINDLE) {
@ -410,40 +421,40 @@ void sserial_module_init(llio_t *llio) {
u8 record_type;
char name[48], unit[48], buff[32];
d = sslbp_read_remote16(llio, port, channel, addr);
d = sslbp_read_remote16(ssmod, port, channel, addr);
if (d == 0) break;
record_type = sslbp_read_remote8(llio, port, channel, d);
record_type = sslbp_read_remote8(ssmod, port, channel, d);
addr += 2;
if (record_type == LBP_DATA) {
sslbp_read_remote_bytes(llio, port, channel, d, &(sserial_pdd), sizeof(sserial_pdd_t));
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_pdd_t), &(unit), -1);
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_pdd_t) + strlen(unit) + 1, &(name), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d, &(sserial_pdd), sizeof(sserial_pdd_t));
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_pdd_t), &(unit), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_pdd_t) + strlen(unit) + 1, &(name), -1);
if (strncmp(name, "SwRevision", 10) == 0) {
sslbp_read_remote_bytes(llio, port, channel, sserial_pdd.param_addr, &(d), sserial_pdd.data_size/8);
sslbp_read_remote_bytes(ssmod, port, channel, sserial_pdd.param_addr, &(d), sserial_pdd.data_size/8);
llio->ss_device[channel].sw_revision = d;
printf(" SwRevision = %u\n", d);
} else if (strncmp(name, "HwRevision", 10) == 0) {
sslbp_read_remote_bytes(llio, port, channel, sserial_pdd.param_addr, &(d), sserial_pdd.data_size/8);
sslbp_read_remote_bytes(ssmod, port, channel, sserial_pdd.param_addr, &(d), sserial_pdd.data_size/8);
llio->ss_device[channel].hw_revision = d;
printf(" HwRevision = %u\n", d);
} else if (strncmp(name, "NVBaudRate", 10) == 0) {
d = sslbp_read_nv_remote16(llio, port, channel, sserial_pdd.param_addr);
d = sslbp_read_nv_remote16(ssmod, port, channel, sserial_pdd.param_addr);
printf(" NVBaudRate = %s\n", baud_rates[d]);
} else if (strncmp(name, "NVUnitNumber", 12) == 0) {
data = sslbp_read_nv_remote32(llio, port, channel, sserial_pdd.param_addr);
data = sslbp_read_nv_remote32(ssmod, port, channel, sserial_pdd.param_addr);
printf(" NVUnitNumber = 0x%08X\n", data);
} else if (strncmp(name, "NVWatchDogTimeout", 17) == 0) {
d = sslbp_read_nv_remote16(llio, port, channel, sserial_pdd.param_addr);
d = sslbp_read_nv_remote16(ssmod, port, channel, sserial_pdd.param_addr);
printf(" NVWatchDogTimeout = %ums\n", d);
} else if ((strncmp(name, "NV", 2) == 0) || (sserial_pdd.data_type == LBP_UNSIGNED && strncmp(unit, "None", 4) == 0)) {
if (llio->verbose == 1) {
printf(" %s", name);
if (sserial_pdd.data_type == LBP_UNSIGNED || sserial_pdd.data_type == LBP_NONVOL_UNSIGNED) {
if (sserial_pdd.data_size == 16) {
d = sslbp_read_nv_remote16(llio, port, channel, sserial_pdd.param_addr);
d = sslbp_read_nv_remote16(ssmod, port, channel, sserial_pdd.param_addr);
printf(" = %x", d);
} else if (sserial_pdd.data_size == 32) {
data = sslbp_read_nv_remote32(llio, port, channel, sserial_pdd.param_addr);
data = sslbp_read_nv_remote32(ssmod, port, channel, sserial_pdd.param_addr);
printf(" = %08X", data);
}
}
@ -465,8 +476,8 @@ void sserial_module_init(llio_t *llio) {
}
}
} else if (record_type == LBP_MODE) {
sslbp_read_remote_bytes(llio, port, channel, d, &(sserial_md), sizeof(sserial_md_t));
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_md_t), &(name), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d, &(sserial_md), sizeof(sserial_md_t));
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_md_t), &(name), -1);
if (sserial_md.mode_type == 0x01) {
llio->ss_device[channel].sw_modes[llio->ss_device[channel].sw_modes_cnt].index = sserial_md.mode_index;
strncpy(llio->ss_device[channel].sw_modes[llio->ss_device[channel].sw_modes_cnt].name, name, strlen(name));
@ -477,18 +488,18 @@ void sserial_module_init(llio_t *llio) {
for (i = 0; i < llio->ss_device[channel].sw_modes_cnt; i++) {
printf(" SOFTWARE MODE %s [index %02X]\n", llio->ss_device[channel].sw_modes[i].name, llio->ss_device[channel].sw_modes[i].index);
sslbp_send_local_cmd(llio, port, SSLBP_CMD_STOP(channel));
sslbp_wait_complete(llio, port);
sslbp_send_local_cmd(ssmod, port, SSLBP_CMD_STOP(channel));
sslbp_wait_complete(ssmod, port);
cmd = llio->ss_device[channel].sw_modes[i].index << 24;
llio->write(llio, HM2_MODULE_SSERIAL_CS + port*0x40 + channel*4, &(cmd), sizeof(u32));
llio->write(llio, ssmod->base_address + HM2_MOD_OFFS_SSERIAL_CS + port*0x40 + channel*4, &(cmd), sizeof(u32));
sslbp_send_local_cmd(llio, port, SSLBP_CMD_START_SETUP_MODE(channel));
sslbp_wait_complete(llio, port);
if (sslbp_read_data(llio, port) != 0)
sslbp_send_local_cmd(ssmod, port, SSLBP_CMD_START_SETUP_MODE(channel));
sslbp_wait_complete(ssmod, port);
if (sslbp_read_data(ssmod, port) != 0)
continue;
llio->read(llio, HM2_MODULE_SSERIAL_INTERFACE2 + port*0x40 + channel*4, &(status), sizeof(u32));
llio->read(llio, HM2_MOD_OFFS_SSERIAL_INTERFACE2 + port*0x40 + channel*4, &(status), sizeof(u32));
addr = status & 0xFFFF;
while (1) {
@ -497,14 +508,14 @@ void sserial_module_init(llio_t *llio) {
u8 record_type;
char name[48], unit[48];
d = sslbp_read_remote16(llio, port, channel, addr);
d = sslbp_read_remote16(ssmod, port, channel, addr);
if (d == 0) break;
record_type = sslbp_read_remote8(llio, port, channel, d);
record_type = sslbp_read_remote8(ssmod, port, channel, d);
addr += 2;
if (record_type == LBP_DATA) {
sslbp_read_remote_bytes(llio, port, channel, d, &(sserial_pdd), sizeof(sserial_pdd_t));
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_pdd_t), &(unit), -1);
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_pdd_t) + strlen(unit) + 1, &(name), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d, &(sserial_pdd), sizeof(sserial_pdd_t));
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_pdd_t), &(unit), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_pdd_t) + strlen(unit) + 1, &(name), -1);
if (llio->verbose == 1) {
printf(" DATA %s [%u bits %s", name, sserial_pdd.data_size, record_types[sserial_pdd.data_type]);
if (sserial_pdd.data_dir & LBP_IO) {
@ -523,8 +534,8 @@ void sserial_module_init(llio_t *llio) {
printf("]\n");
}
} else if (record_type == LBP_MODE) {
sslbp_read_remote_bytes(llio, port, channel, d, &(sserial_md), sizeof(sserial_md_t));
sslbp_read_remote_bytes(llio, port, channel, d + sizeof(sserial_md_t), &(name), -1);
sslbp_read_remote_bytes(ssmod, port, channel, d, &(sserial_md), sizeof(sserial_md_t));
sslbp_read_remote_bytes(ssmod, port, channel, d + sizeof(sserial_md_t), &(name), -1);
}
}

1
sserial_module.h
View file

@ -41,6 +41,7 @@ typedef struct {
int instance_stride;
int interface_num;
int channel_num;
u16 base_address;
u32 data;
u32 cs;
u32 interface0;