/*
* Value is between 3 and 10, which represents 3us and 10us.
* Default value is 8us. (with altUSB)
* Default value is 7us. (without altUSB)
*/
static ZERO_OR_ERROR FS_r_datasampleoffset(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb) {
OWQ_U(owq) = 8;
#if OW_USB
} else {
OWQ_U(owq) = pn->selected_connection->master.usb.datasampleoffset + 3;
#endif /* OW_USB */
}
return 0;
}
/*
* Value is between 8 and 15, which represents 8us and 15us.
* Default value is 10us. (with altUSB)
* Default value is 12us. (without altUSB)
*/
static ZERO_OR_ERROR FS_r_writeonelowtime(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb) {
OWQ_U(owq) = 10;
#if OW_USB
} else {
OWQ_U(owq) = pn->selected_connection->master.usb.writeonelowtime + 8;
#endif /* OW_USB */
}
return 0;
}
static ZERO_OR_ERROR FS_w_timeout(struct one_wire_query *owq)
{
UINT previous;
struct parsedname *pn = PN(owq);
CACHE_WLOCK;
//printf("FS_w_timeout!!!\n");
previous = ((UINT *) pn->selected_filetype->data.v)[0];
((UINT *) pn->selected_filetype->data.v)[0] = OWQ_U(owq);
CACHE_WUNLOCK;
if (previous > OWQ_U(owq)) {
Cache_Clear();
}
return 0;
}
static ZERO_OR_ERROR FS_r_data(struct one_wire_query *owq)
{
BYTE data;
RETURN_ERROR_IF_BAD( OW_r_data(&data, PN(owq)) ) ;
OWQ_U(owq) = data;
return 0;
}
static ZERO_OR_ERROR FS_r_gpio(struct one_wire_query *owq)
{
BYTE data;
RETURN_ERROR_IF_BAD( OW_r_gpio(&data, PN(owq)) );
OWQ_U(owq) = (~data) & 0x0F;
return 0;
}
static ZERO_OR_ERROR FS_w_vib_mode(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
UINT vib_request = OWQ_U(owq) ;
BYTE vib_stored ;
switch (vib_request) {
case e_mVM001_peak:
case e_mVM001_rms:
case e_mVM001_multi:
break ;
default:
return -EINVAL ;
}
if ( BAD( Cache_Get_SlaveSpecific(&vib_stored, sizeof(vib_stored), SlaveSpecificTag(VIB), pn)) ) {
if ( vib_stored == vib_request ) {
return 0 ;
}
}
if ( BAD( OW_set_vib_mode( vib_request, pn ) ) ) {
return -EINVAL ;
}
Cache_Add_SlaveSpecific(&vib_request, sizeof(vib_request), SlaveSpecificTag(VIB), pn);
return 0 ;
}
/* From register 0x8A */
static ZERO_OR_ERROR FS_r_latch(struct one_wire_query *owq)
{
BYTE data[6];
RETURN_ERROR_IF_BAD( OW_r_reg(data, PN(owq)) );
OWQ_U(owq) = data[2];
return 0;
}
static ZERO_OR_ERROR FS_r_timeout(struct one_wire_query *owq)
{
CACHE_RLOCK;
OWQ_U(owq) = ((UINT *) OWQ_pn(owq).selected_filetype->data.v)[0];
CACHE_RUNLOCK;
return 0;
}
static ZERO_OR_ERROR FS_stat_p(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
OWQ_U(owq) = pn->selected_connection->bus_stat[pn->selected_filetype->data.i];
return 0;
}
/* Read serialnumber */
static ZERO_OR_ERROR FS_r_PBM_serial(struct one_wire_query *owq)
{
struct connection_in * in = PN(owq)->selected_connection ;
OWQ_U(owq) = in->master.pbm.serial_number;
return 0 ;
}
// Handles: ALL
static ZERO_OR_ERROR FS_read_all( struct one_wire_query *owq_all)
{
struct parsedname * pn = PN(owq_all) ;
// bitfield, convert to .BYTE format and write ( and delete cache ) as BYTE.
if ( pn->selected_filetype->format == ft_bitfield ) {
struct one_wire_query * owq_byte = OWQ_create_separate( EXTENSION_BYTE, owq_all ) ;
int ret = -EINVAL ;
if ( owq_byte != NO_ONE_WIRE_QUERY ) {
if ( FS_read_owq( owq_byte ) >= 0 ) {
size_t elements = pn->selected_filetype->ag->elements;
size_t extension;
for ( extension=0 ; extension < elements ; ++extension ) {
OWQ_array_Y(owq_all,extension) = UT_getbit_U( OWQ_U(owq_byte), extension ) ;
}
ret = 0 ;
}
OWQ_destroy( owq_byte ) ;
}
return ret ;
}
return FS_read_owq( owq_all ) ;
}
/* From register 0x89 */
static ZERO_OR_ERROR FS_r_pio(struct one_wire_query *owq)
{
BYTE data[6];
RETURN_ERROR_IF_BAD( OW_r_reg(data, PN(owq)) ) ;
OWQ_U(owq) = BYTE_INVERSE(data[1]); /* reverse bits */
return 0;
}
static ZERO_OR_ERROR FS_CO2_ppm( struct one_wire_query *owq)
{
_FLOAT P = 0. ;
ZERO_OR_ERROR z_or_e = FS_r_sibling_F(&P,"volt.A",owq) ;
OWQ_U(owq) = P*1000. ;
return z_or_e ;
}
static ZERO_OR_ERROR FS_r_status(struct one_wire_query *owq)
{
BYTE data ;
ZERO_OR_ERROR z_or_e = OW_r_status(&data, PN(owq)) ;
OWQ_U(owq) = data ;
return z_or_e ;
}
static ZERO_OR_ERROR FS_w_pulldownslewrate(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb) {
return -ENOTSUP;
}
#if OW_USB
if (OWQ_U(owq) > 7) {
return -ENOTSUP;
}
pn->selected_connection->master.usb.pulldownslewrate = OWQ_U(owq);
pn->selected_connection->changed_bus_settings |= CHANGED_USB_SLEW ; // force a reset
LEVEL_DEBUG("Set slewrate to %d", pn->selected_connection->master.usb.pulldownslewrate);
#endif /* OW_USB */
return 0;
}
static ZERO_OR_ERROR FS_w_datasampleoffset(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb){
return -ENOTSUP;
}
#if OW_USB
if ((OWQ_U(owq) < 3) || (OWQ_U(owq) > 10)) {
return -ENOTSUP;
}
pn->selected_connection->master.usb.datasampleoffset = OWQ_U(owq) - 3;
pn->selected_connection->changed_bus_settings |= CHANGED_USB_OFFSET; // force a reset
#endif /* OW_USB */
return 0;
}
static ZERO_OR_ERROR FS_w_writeonelowtime(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb) {
return -ENOTSUP;
}
#if OW_USB
if ((OWQ_U(owq) < 8) || (OWQ_U(owq) > 15)) {
return -ENOTSUP;
}
pn->selected_connection->master.usb.writeonelowtime = OWQ_U(owq) - 8;
pn->selected_connection->changed_bus_settings |= CHANGED_USB_LOW ; // force a reset
#endif /* OW_USB */
return 0;
}
/* Wiper */
static ZERO_OR_ERROR FS_w_wiper(struct one_wire_query *owq)
{
UINT num = OWQ_U(owq);
if (num > 255) {
num = 255;
}
return GB_to_Z_OR_E(OW_w_wiper(num, PN(owq))) ;
}
static SIZE_OR_ERROR OWQ_parse_output_unsigned(struct one_wire_query *owq)
{
/* should only need suglen+1, but uClibc's snprintf()
seem to trash 'len' if not increased */
int len;
char c[PROPERTY_LENGTH_UNSIGNED + 2];
UCLIBCLOCK;
if ( ShouldTrim(PN(owq)) ) {
len = snprintf(c, PROPERTY_LENGTH_UNSIGNED + 1, "%1u", OWQ_U(owq));
} else {
len = snprintf(c, PROPERTY_LENGTH_UNSIGNED + 1, "%*u", PROPERTY_LENGTH_UNSIGNED, OWQ_U(owq));
}
UCLIBCUNLOCK;
if ((len < 0) || ((size_t) len > PROPERTY_LENGTH_UNSIGNED)) {
return -EMSGSIZE;
}
return OWQ_parse_output_offset_and_size(c, len, owq);
}
/* read clock */
static ZERO_OR_ERROR FS_r_counter4(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
uint64_t L;
if (OW_r_ulong(&L, 4, pn->selected_filetype->data.s, pn)) {
return -EINVAL;
}
OWQ_U(owq) = L;
return 0;
}
static ZERO_OR_ERROR FS_r_data(struct one_wire_query *owq)
{
BYTE data[2];
if ( BAD( OW_reading( data, PN(owq) ) ) ) {
return -EINVAL ;
}
OWQ_U(owq) = data[1] * 256 + data[0] ;
return 0 ;
}
/*
* Value is between 0 and 7.
* Default value is 3.
*
* PARMSET_Slew15Vus 0x0
* PARMSET_Slew2p20Vus 0x1
* PARMSET_Slew1p65Vus 0x2
* PARMSET_Slew1p37Vus 0x3 (default with altUSB)
* PARMSET_Slew1p10Vus 0x4
* PARMSET_Slew0p83Vus 0x5 (default without altUSB)
* PARMSET_Slew0p70Vus 0x6
* PARMSET_Slew0p55Vus 0x7
*/
static ZERO_OR_ERROR FS_r_pulldownslewrate(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if (get_busmode(pn->selected_connection) != bus_usb) {
return -ENOTSUP;
#if OW_USB
} else {
OWQ_U(owq) = pn->selected_connection->master.usb.pulldownslewrate;
#endif /* OW_USB */
}
return 0;
}
static ZERO_OR_ERROR FS_r_alarm(struct one_wire_query *owq)
{
BYTE c;
OWQ_allocate_struct_and_pointer(owq_alarm);
OWQ_create_temporary(owq_alarm, (char *) &c, 1, 0x0200, PN(owq));
if (COMMON_read_memory_F0(owq_alarm, 0, 0)) {
return -EINVAL;
}
OWQ_U(owq) = Avals[c & 0x07];
return 0;
}
/* data[0] selection */
static ZERO_OR_ERROR FS_w_s_alarm(struct one_wire_query *owq)
{
BYTE data[3];
int i;
UINT p;
UINT U = OWQ_U(owq);
for (i = 0, p = 1; i < 8; ++i, p *= 10) {
UT_setbit(&data[1], i, ((int) (U / p) % 10) & 0x01);
UT_setbit(&data[0], i, (((int) (U / p) % 10) & 0x02) >> 1);
}
data[2] = ((U / 100000000) % 10) & 0x03;
return GB_to_Z_OR_E(OW_w_s_alarm(data, PN(owq))) ;
}
/* Nathan Holmes helped troubleshoot this one! */
static GOOD_OR_BAD OW_r_counter(struct one_wire_query *owq, size_t page, size_t pagesize)
{
BYTE extra[8];
if (COMMON_read_memory_plus_counter(extra, page, pagesize, PN(owq))) {
return gbBAD;
}
if (extra[4] != _1W_COUNTER_FILL || extra[5] != _1W_COUNTER_FILL || extra[6] != _1W_COUNTER_FILL || extra[7] != _1W_COUNTER_FILL) {
return gbBAD;
}
/* counter is held in the 4 bytes after the data */
OWQ_U(owq) = UT_uint32(extra);
return gbGOOD;
}
//; Special version for the mTS017 that knows about multiplexing for the cache
static ZERO_OR_ERROR FS_r_data17(struct one_wire_query *owq)
{
if ( FS_r_data(owq) < 0 ) {
return -EINVAL ;
}
// Is it a multiplex? Then kill cache
if ( (OWQ_U(owq) & mTS017_plex) == mTS017_multi ) {
OWQ_Cache_Del(owq) ;
}
return 0 ;
}
// 0x01 => blinking cursor on
// 0x02 => cursor on
// 0x04 => display on
static ZERO_OR_ERROR FS_Honoff(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
BYTE onoff[] = { NIBBLE_DATA(OWQ_U(owq)) };
RETURN_ERROR_IF_BAD( OW_Hinit(pn) ) ;
// onoff
if ( BAD( OW_w_pios(onoff, 2, pn) ) ) {
LEVEL_DEBUG("Error setting LCD state");
return -EINVAL;
}
return 0;
}
void _print_owq(struct one_wire_query *owq)
{
char c[32];
fprintf(stderr,"OWQ OneWireQuery structure of %s\n", PN(owq)->path);
fprintf(stderr," OneWireQuery size=%lu offset=%lu, extension=%d\n",
(unsigned long) OWQ_size(owq), (unsigned long) OWQ_offset(owq), (int) OWQ_pn(owq).extension);
if ( OWQ_buffer(owq) != NULL ) {
Debug_Bytes("OneWireQuery buffer", (BYTE *) OWQ_buffer(owq), OWQ_size(owq));
}
fprintf(stderr," Cleanup = %.4X",OWQ_cleanup(owq));
fprintf(stderr," OneWireQuery I=%d U=%u F=%G Y=%d D=%s\n", OWQ_I(owq), OWQ_U(owq), OWQ_F(owq), OWQ_Y(owq), SAFESTRING(ctime_r(&OWQ_D(owq), c)));
fprintf(stderr,"--- OneWireQuery done\n");
}
// Handles: .n
static ZERO_OR_ERROR FS_write_a_bit(struct one_wire_query *owq_bit)
{
struct one_wire_query * owq_byte = OWQ_create_separate( EXTENSION_BYTE, owq_bit ) ;
ZERO_OR_ERROR z_or_e = -ENOENT ;
if ( owq_byte != NO_ONE_WIRE_QUERY ) {
if ( FS_read_local( owq_byte ) >= 0 ) {
UT_setbit( (BYTE *) &OWQ_U( owq_byte ), OWQ_pn(owq_bit).extension, OWQ_Y(owq_bit) ) ;
z_or_e = FS_write_owq( owq_byte ) ;
}
OWQ_destroy( owq_byte ) ;
}
return z_or_e ;
}
static ZERO_OR_ERROR FS_w_baud(struct one_wire_query *owq)
{
struct connection_in * in = PN(owq)->selected_connection ;
switch ( get_busmode(in) ) {
case bus_serial:
case bus_link:
case bus_pbm:
in->pown->baud = COM_MakeBaud( (speed_t) OWQ_U(owq) ) ;
++in->changed_bus_settings ;
break ;
default:
break ;
}
return 0 ;
}
