自学教程：C++ BAD函数代码示例

static void BUS_ERROR_fix(const struct parsedname *pn){	LEVEL_DEBUG("DS9490_Reset: ERROR -- will attempt a fix");	/* FIXME: FIXED. In ow_usb_msg.c an USB-reset was was issued:	* USB_Control_Msg(CONTROL_CMD, CTL_RESET_DEVICE, 0x0000, pn) ;	* So we need to setup the Adapter again 	* Though here is probably the wrong place, duplicated code from _setup_adaptor	*/	// enable both program and strong pulses	if ( BAD( USB_Control_Msg(MODE_CMD, MOD_PULSE_EN, ENABLE_PROGRAM_AND_PULSE, pn)) ) {		LEVEL_DATA("EnableProgram error");	}	// enable speed changes	if ( BAD( USB_Control_Msg(MODE_CMD, MOD_SPEED_CHANGE_EN, 1, pn)) ) {		LEVEL_DATA("RESET_Error: SpeedEnable error");	}	// set the strong pullup duration to infinite	if ( BAD( USB_Control_Msg(COMM_CMD, COMM_SET_DURATION | COMM_IM, 0x0000, pn)) ) {		LEVEL_DATA("StrongPullup error");	}		// Don't set speed right now, it calls reset for infinite recursion. Just set for next pass	++ 	pn->selected_connection->changed_bus_settings ;}

// Switch to overdrive speed -- 3 triesstatic GOOD_OR_BAD DS9490_overdrive(const struct parsedname *pn){	BYTE sp = _1W_OVERDRIVE_SKIP_ROM;	BYTE resp;	int i;	// we need to change speed to overdrive	for (i = 0; i < 3; i++) {		LEVEL_DATA("set overdrive speed. Attempt %d",i);		if ( BAD( gbRESET(BUS_reset(pn)) ) ) {			continue;		}		if ( BAD( DS9490_sendback_data(&sp, &resp, 1, pn) ) || (_1W_OVERDRIVE_SKIP_ROM != resp) ) {			LEVEL_DEBUG("error setting overdrive %.2X/0x%02X", _1W_OVERDRIVE_SKIP_ROM, resp);			continue;		}		if ( GOOD( USB_Control_Msg(MODE_CMD, MOD_1WIRE_SPEED, ONEWIREBUSSPEED_OVERDRIVE, pn)) ) {			LEVEL_DEBUG("speed is now set to overdrive");			return gbGOOD;		}	}	LEVEL_DEBUG("Error setting overdrive after 3 retries");	return gbBAD;}

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 ;}

static RESET_TYPE LINK_reset_in(struct connection_in * in){	BYTE resp[1+in->CRLF_size];	if (in->changed_bus_settings > 0) {		--in->changed_bus_settings ;		LINK_set_baud(in);	// reset paramters	} else {		LINK_flush(in);	}	if ( BAD(LINK_write(LINK_string("r"), 1, in) || BAD( LINK_read(resp, 1, in))) ) {		LEVEL_DEBUG("Error resetting LINK device");		LINK_slurp(in);		return BUS_RESET_ERROR;	}	switch (resp[0]) {	case 'P':		in->AnyDevices = anydevices_yes;		return BUS_RESET_OK;	case 'N':		in->AnyDevices = anydevices_no;		return BUS_RESET_OK;	case 'S':		return BUS_RESET_SHORT;	default:		LEVEL_DEBUG("bad, Unknown LINK response %c", resp[0]);		LINK_slurp(in);		return BUS_RESET_ERROR;	}}

// return 1 shorted, 0 ok, <0 errorstatic RESET_TYPE DS2482_reset(const struct parsedname *pn){    BYTE status_byte;    struct connection_in * in = pn->selected_connection ;    FILE_DESCRIPTOR_OR_ERROR file_descriptor = in->pown->file_descriptor;    /* Make sure we're using the correct channel */    if ( BAD(DS2482_channel_select(in)) ) {        return BUS_RESET_ERROR;    }    /* write the RESET code */    if (i2c_smbus_write_byte(file_descriptor, DS2482_CMD_1WIRE_RESET)) {        return BUS_RESET_ERROR;    }    /* wait */    // rstl+rsth+.25 usec    /* read status */    if ( BAD( DS2482_readstatus(&status_byte, file_descriptor, DS2482_1wire_reset_usec) ) ) {        return BUS_RESET_ERROR;			// 8 * Tslot    }    in->AnyDevices = (status_byte & DS2482_REG_STS_PPD) ? anydevices_yes : anydevices_no ;    LEVEL_DEBUG("DS2482 "I2Cformat" Any devices found on reset? %s",I2Cvar(in),in->AnyDevices==anydevices_yes?"Yes":"No");    return (status_byte & DS2482_REG_STS_SD) ? BUS_RESET_SHORT : BUS_RESET_OK;}

/* Puts in 9600 baud, sends 11110000 then reads response */static RESET_TYPE DS9097_reset_in( struct connection_in * in ){	BYTE resetbyte = RESET_BYTE;	BYTE responsebyte;	if ( BAD( DS9097_pre_reset( in ) ) ) {		return BUS_RESET_ERROR ;	}	if ( BAD( DS9097_send_and_get(&resetbyte, &responsebyte, 1, in )) ) {		DS9097_post_reset( in) ;		return BUS_RESET_ERROR ;	}	DS9097_post_reset(in) ;		switch (responsebyte) {	case 0x00:		return BUS_RESET_SHORT;	case RESET_BYTE:		// no presence		in->AnyDevices = anydevices_no ;		return BUS_RESET_OK;	default:		in->AnyDevices = anydevices_yes ;		return BUS_RESET_OK;	}}

/* 2450 A/D */static ZERO_OR_ERROR FS_volts(struct one_wire_query *owq){	struct parsedname *pn = PN(owq);	int resolution ;	int range ;	_FLOAT V[4] ;	switch ( pn->selected_filetype->data.i ) {		case r_2V_8bit:			range = 2 ;			resolution = 8 ;			break ;		case r_5V_8bit:			range = 5 ;			resolution = 8 ;			break ;		case r_2V_16bit:			range = 2 ;			resolution = 16 ;			break ;		case r_5V_16bit:		default:			range = 5 ;			resolution = 16 ;			break ;	}	if ( BAD( OW_set_resolution( resolution, pn ) ) ) {		return -EINVAL ;	}		if ( BAD( OW_set_range( range, pn ) ) ) {		return -EINVAL ;	}		// Start A/D process if needed	if ( BAD( OW_convert( OWQ_SIMUL_TEST(owq), (int)(.5+.16+4.*resolution*.08), pn) )) {		return -EINVAL ;	}			if ( BAD( OW_volts( V, pn ) )) {		return -EINVAL ;	}	switch ( pn->selected_filetype->data.i ) {		case r_2V_8bit:		case r_2V_16bit:			OWQ_array_F(owq, 0) = V[0]*.5;			OWQ_array_F(owq, 1) = V[1]*.5;			OWQ_array_F(owq, 2) = V[2]*.5;			OWQ_array_F(owq, 3) = V[3]*.5;			break ;		case r_5V_8bit:		case r_5V_16bit:		default:			OWQ_array_F(owq, 0) = V[0];			OWQ_array_F(owq, 1) = V[1];			OWQ_array_F(owq, 2) = V[2];			OWQ_array_F(owq, 3) = V[3];			break ;	}	return 0 ;}

/* USB is a special case, in gets reenumerated, so we look for similar DS2401 chip */GOOD_OR_BAD TestConnection(const struct parsedname *pn){	GOOD_OR_BAD ret = 0;	struct connection_in *in ;	if ( pn == NO_PARSEDNAME ) {		return gbGOOD ;	}	in = pn->selected_connection ;	if ( in == NO_CONNECTION ) {		return gbGOOD ;	}		// Test without a lock -- efficient	if ( in->reconnect_state < reconnect_error ) {		return gbGOOD;	}		// Lock the bus	BUSLOCK(pn);	// Test again	if (in->reconnect_state >= reconnect_error) {		// Add Statistics		STAT_ADD1_BUS(e_bus_reconnects, in);		// Close the bus (should leave enough reconnection information available)		BUS_close(in);	// already locked		// Call reconnection		in->AnyDevices = anydevices_unknown ;		if ( in->iroutines.reconnect != NO_RECONNECT_ROUTINE ) {			// reconnect method exists			ret = (in->iroutines.reconnect) (pn) ;	// call bus-specific reconnect		} else {			ret = BUS_detect(in->pown) ;	// call initial opener		}		if ( BAD( ret ) ) {			in->reconnect_state = reconnect_ok + 1 ;			// delay to slow thrashing			UT_delay(200);		} else {			in->reconnect_state = reconnect_ok;		}	}	BUSUNLOCK(pn);	if ( BAD( ret ) ) {		LEVEL_DEFAULT("Failed to reconnect %s bus master!", in->adapter_name);	} else {		LEVEL_DEFAULT("%s bus master reconnected", in->adapter_name);	}	return ret;}

int c3db_dump( C3HDL *h, FILE *to, int show_empty, int ts_fmt ){	if( !h )	  	return C3E_BAD_HANDLE;	if( h->state == C3DB_ST_DIRTY )	  	BAD( C3E_BAD_STATE );	if( ts_fmt < C3DB_TS_SEC || ts_fmt >= C3DB_TS_MAX )		BAD( C3E_BAD_FORMAT );	return (h->f_dump)( h, to, show_empty, ts_fmt );}

/* Open a DS9490  -- low level code (to allow for repeats)  */static GOOD_OR_BAD DS9490_detect_all_adapters(struct port_in * pin_first){	// discover devices	struct port_in * pin = pin_first ;	libusb_device **device_list;	int n_devices = libusb_get_device_list( Globals.luc, &device_list) ;	int i_device ;		if ( n_devices < 1 ) {		LEVEL_CONNECT("Could not find a list of USB devices");		if ( n_devices<0 ) {			LEVEL_DEBUG("<%s>",libusb_error_name(n_devices));		}		return gbBAD ;	}	for ( i_device = 0 ; i_device < n_devices ; ++i_device ) {		libusb_device * current = device_list[i_device] ;		if ( GOOD( USB_match( current ) ) ) {			struct connection_in * in = pin->first ;			if ( BAD(DS9490_open_and_name( current, in)) ) {				LEVEL_DEBUG("Cannot open USB device %.d:%.d", libusb_get_device_address(current), libusb_get_bus_number(current) );				continue ;			} else if ( BAD(DS9490_ID_this_master(in)) ) {				DS9490_close(in) ;				LEVEL_DEBUG("Cannot access USB device %.d:%.d", libusb_get_device_address(current), libusb_get_bus_number(current) );				continue;			} else{				pin = NewPort(NULL) ; // no reason to copy anything				if ( pin == NULL ) {					return gbGOOD ;				}				// set up the new connection for the next adapter				DS9490_setroutines(in);			}		}	}		libusb_free_device_list(device_list, 1);	if ( pin == pin_first ) {		LEVEL_CONNECT("No USB DS9490 bus masters used");		return gbBAD;	}	// Remove the extra connection	RemovePort(pin);	return gbGOOD ;}

/* Open a DS9490  -- low level code (to allow for repeats)  */static GOOD_OR_BAD DS9490_detect_specific_adapter(int bus_nr, int dev_nr, struct connection_in * in){	// discover devices	libusb_device **device_list;	int n_devices = libusb_get_device_list( Globals.luc, &device_list) ;	int i_device ;		if ( n_devices < 1 ) {		LEVEL_CONNECT("Could not find a list of USB devices");		if ( n_devices<0 ) {			LEVEL_DEBUG("<%s>",libusb_error_name(n_devices));		}		return gbBAD ;	}	// Mark this connection as taking only this address pair. Important for reconnections.	in->master.usb.specific_usb_address = 1 ;	for ( i_device = 0 ; i_device < n_devices ; ++i_device ) {		libusb_device * current = device_list[i_device] ;		if ( GOOD( USB_match( current ) ) ) {			if ( libusb_get_bus_number(current) != bus_nr ) {				continue ;			}						if ( libusb_get_device_address(current) != dev_nr ) {				continue ;			}						if ( BAD(DS9490_open_and_name( current, in)) ) {				LEVEL_DEBUG("Cannot open USB device %.d:%.d", libusb_get_device_address(current), libusb_get_bus_number(current) );				break ;			} else if ( BAD(DS9490_ID_this_master(in)) ) {				DS9490_close(in) ;				LEVEL_DEBUG("Cannot access USB device %.d:%.d", libusb_get_device_address(current), libusb_get_bus_number(current) );				break ;			} else{				libusb_free_device_list(device_list, 1);				return gbGOOD ;			}		}	}		libusb_free_device_list(device_list, 1);	LEVEL_CONNECT("No USB DS9490 bus master found matching %d:%d", bus_nr,dev_nr);	return gbBAD;}

/* Write now that connection is set */static ZERO_OR_ERROR FS_w_given_bus(struct one_wire_query *owq){	struct parsedname *pn = PN(owq);	if ( BAD(TestConnection(pn)) ) {		return -ECONNABORTED;	} else if (KnownBus(pn) && BusIsServer(pn->selected_connection)) {		return ServerWrite(owq);	} else if (OWQ_pn(owq).type == ePN_real) {		ZERO_OR_ERROR write_or_error = DeviceLockGet(pn);		if (write_or_error == 0) {			write_or_error = FS_w_local(owq);			DeviceLockRelease(pn);		} else {			LEVEL_DEBUG("Cannot lock device for writing") ;		}		return write_or_error ;	} else if ( IsInterfaceDir(pn) ) {		ZERO_OR_ERROR write_or_error;		BUSLOCK(pn);		write_or_error = FS_w_local(owq);		BUSUNLOCK(pn);		return write_or_error ;	} else {		return FS_w_local(owq);	}}

float EDIT_scale_misfit( int nxyz , float fac , short *sar , float *far ){    float sf , ff , sum=0.0f , df ;    int ii , nf=0 ;    ENTRY("EDIT_scale_misfit") ;    if( nxyz <= 0 || sar == NULL || far == NULL ) RETURN(0.0f) ;    if( fac == 0.0f ) fac = 1.0f ;    df = 1.0f / fac ;    for( ii=0 ; ii < nxyz ; ii++ ) {        if( BAD(ii) ) continue ;        ff = far[ii] ;        if( ff == 0.0f ) continue ;        sf = (short)rintf(fac*sar[ii]) ;        if( sf == 0.0f ) {            if( fabsf(ff) < df ) sum += fabsf(ff)*fac ;            else                 sum += 1.0f ;        } else {            sf = fabsf((sf-ff)/ff) ;            if( sf > 1.0f ) sf = 1.0f ;            sum += sf ;        }        nf++ ;    }    if( nf > 0 ) sum /= nf ;    RETURN(sum) ;}

// range is 5=5V or 2=2.5Vstatic GOOD_OR_BAD OW_set_range( int range, struct parsedname * pn ){	int stored_range ;	/* Range */	if ( BAD( Cache_Get_SlaveSpecific(&stored_range, sizeof(stored_range), SlaveSpecificTag(RAN), pn))		|| stored_range != range) {			// need to set resolution		BYTE p[_1W_2450_PAGESIZE];		RETURN_BAD_IF_BAD( OW_r_mem(p, _1W_2450_PAGESIZE, _ADDRESS_CONTROL_PAGE, pn) ) ;		switch ( range ) {			case 2:				p[_1W_2450_REG_A+1] &= ~_1W_2450_IR ;				p[_1W_2450_REG_B+1] &= ~_1W_2450_IR ;				p[_1W_2450_REG_C+1] &= ~_1W_2450_IR ;				p[_1W_2450_REG_D+1] &= ~_1W_2450_IR ;				break ;			case 5:			default:				p[_1W_2450_REG_A+1] |= _1W_2450_IR ;				p[_1W_2450_REG_B+1] |= _1W_2450_IR ;				p[_1W_2450_REG_C+1] |= _1W_2450_IR ;				p[_1W_2450_REG_D+1] |= _1W_2450_IR ;				break ;		}		RETURN_BAD_IF_BAD( OW_w_mem(p, _1W_2450_PAGESIZE, _ADDRESS_CONTROL_PAGE, pn) );		return Cache_Add_SlaveSpecific(&range, sizeof(int), SlaveSpecificTag(RAN), pn);	}	return gbGOOD ;}

static ZERO_OR_ERROR FS_Mclear(struct one_wire_query *owq){	struct parsedname *pn = PN(owq);	int init = 1;	if ( BAD( Cache_Get_SlaveSpecific(&init, sizeof(init), SlaveSpecificTag(INI), pn)) ) {		OWQ_Y(owq) = 1;		if ( FS_r_strobe(owq) != 0 ) {	// set reset pin to strobe mode			return -EINVAL;		}		RETURN_ERROR_IF_BAD( OW_w_pio(0x30, pn) );		UT_delay(100);		// init		RETURN_ERROR_IF_BAD( OW_w_pio(0x38, pn) ) ;		UT_delay(10);		// Enable Display, Cursor, and Blinking		// Entry-mode: auto-increment, no shift		RETURN_ERROR_IF_BAD( OW_w_pio(0x0F, pn) ) ;		RETURN_ERROR_IF_BAD( OW_w_pio(0x06, pn) ) ;		Cache_Add_SlaveSpecific(&init, sizeof(init), SlaveSpecificTag(INI), pn);	}	// clear	RETURN_ERROR_IF_BAD( OW_w_pio(0x01, pn) );	UT_delay(2);	return FS_Mhome(owq);}

/* All general stored data will be assigned to this "head" channel */static GOOD_OR_BAD HeadChannel(struct connection_in *head){    /* Intentionally put the wrong index */    head->master.i2c.index = 1;    if ( BAD(DS2482_channel_select(head)) ) {	/* Couldn't switch */        head->master.i2c.index = 0;	/* restore correct value */        LEVEL_CONNECT("DS2482-100 (Single channel)");        if ( GOOD(DS2483_test(head->pown->file_descriptor)) ) {            head->master.i2c.type = ds2483 ;        } else {            head->master.i2c.type = ds2482_100 ;        }        return gbGOOD;				/* happy as DS2482-100 */    }    // It's a DS2482-800 (8 channels) to set up other 7 with this one as "head"    LEVEL_CONNECT("DS2482-800 (Eight channels)");    /* Must be a DS2482-800 */    head->master.i2c.channels = 8;    head->master.i2c.type = ds2482_800 ;    head->Adapter = adapter_DS2482_800;    return CreateChannels(head);}

/* Use an single OWQ as a template for the aggregate one */struct one_wire_query * OWQ_create_aggregate( struct one_wire_query * owq_single ){    int sz = sizeof( struct one_wire_query ) + OWQ_DEFAULT_READ_BUFFER_SIZE;	struct one_wire_query * owq_all = owmalloc( sz );		LEVEL_DEBUG("%s with extension ALL", PN(owq_single)->path);	if ( owq_all == NO_ONE_WIRE_QUERY) {		LEVEL_DEBUG("No memory to create object for extension ALL") ;		return NO_ONE_WIRE_QUERY ;	}		memset(owq_all, 0, sz);	OWQ_cleanup(owq_all) = owq_cleanup_owq ;		memcpy( PN(owq_all), PN(owq_single), sizeof(struct parsedname) ) ;	PN(owq_all)->extension = EXTENSION_ALL ;	OWQ_buffer(owq_all) = (char *) (& owq_all[1]) ; // point just beyond the one_wire_query struct	OWQ_size(owq_all) = OWQ_DEFAULT_READ_BUFFER_SIZE ;	OWQ_offset(owq_all) = 0 ;	if ( BAD( OWQ_allocate_array(owq_all)) ) {		OWQ_destroy(owq_all);		return NO_ONE_WIRE_QUERY ;	}	return owq_all ;}

static enum search_status LINK_next_both(struct device_search *ds, const struct parsedname *pn){	struct connection_in * in = pn->selected_connection ;	//Special case for DS2409 hub, use low-level code	if ( pn->ds2409_depth>0 ) {		return search_error ;	}	if (ds->LastDevice) {		return search_done;	}	if (ds->index == -1) {		if ( BAD(LINK_directory(ds, in)) ) {			return search_error;		}	}	// LOOK FOR NEXT ELEMENT	++ds->index;	LEVEL_DEBUG("Index %d", ds->index);	switch ( DirblobGet(ds->index, ds->sn, &(ds->gulp) ) ) {		case 0:			LEVEL_DEBUG("SN found: " SNformat "", SNvar(ds->sn));			return search_good;		case -ENODEV:		default:			ds->LastDevice = 1;			LEVEL_DEBUG("SN finished");			return search_done;	}}

static GOOD_OR_BAD OW_r_counters(UINT * data, const struct parsedname *pn){	BYTE d[8];	UINT cum[4];	RETURN_BAD_IF_BAD( LCD_byte(_LCD_COMMAND_COUNTER_READ_TO_SCRATCH, 1, pn)) ;	RETURN_BAD_IF_BAD( OW_r_scratch(d, 8, pn)) ;		data[0] = ((UINT) d[1]) << 8 | d[0];	data[1] = ((UINT) d[3]) << 8 | d[2];	data[2] = ((UINT) d[5]) << 8 | d[4];	data[3] = ((UINT) d[7]) << 8 | d[6];//printf("OW_COUNTER key=%s/n",key);	if ( BAD( Cache_Get_SlaveSpecific((void *) cum, sizeof(cum), SlaveSpecificTag(CUM), pn)) ) {	/* First pass at cumulative */		cum[0] = data[0];		cum[1] = data[1];		cum[2] = data[2];		cum[3] = data[3];	} else {		cum[0] += data[0];		cum[1] += data[1];		cum[2] += data[2];		cum[3] += data[3];	}	Cache_Add_SlaveSpecific((void *) cum, sizeof(cum), SlaveSpecificTag(CUM), pn);	return gbGOOD;}

/* Open a DS9490  -- low level code (to allow for repeats)  */static GOOD_OR_BAD DS9490_redetect_low(struct connection_in * in){	// discover devices	libusb_device **device_list;	int n_devices = libusb_get_device_list( Globals.luc, &device_list) ;	int i_device ;		if ( n_devices < 1 ) {		LEVEL_CONNECT("Could not find a list of USB devices");		if ( n_devices<0 ) {			LEVEL_DEBUG("<%s>",libusb_error_name(n_devices));		}		return gbBAD;	}	for ( i_device = 0 ; i_device < n_devices ; ++i_device ) {		libusb_device * current = device_list[i_device] ;		if ( GOOD( USB_match( current ) ) ) {			// try to open the DS9490			if ( BAD(DS9490_open_and_name( current, in )) ) {				LEVEL_CONNECT("Cannot open USB bus master, Find next...");				continue;			}			if ( GOOD( DS9490_redetect_match( in ) ) ) {				break ;			}			DS9490_close(in);		}	}		libusb_free_device_list(device_list, 1);	return (in->master.usb.lusb_handle!=NULL) ? gbGOOD : gbBAD ;}

static GOOD_OR_BAD DS9097_sendback_bits(const BYTE * outbits, BYTE * inbits, const size_t length, const struct parsedname *pn){	BYTE local_data[DS9097_MAX_BITS];	size_t global_counter ;	size_t local_counter ;	size_t offset ;	struct connection_in * in = pn->selected_connection ;	/* Split into smaller packets? */	for ( local_counter = global_counter = offset = 0 ; offset < length ; ) {		// encode this bit		local_data[local_counter] = outbits[global_counter] ? OneBit : ZeroBit;		// point to next one		++local_counter ;		++global_counter ;		// test if enough bits to send to master		if (local_counter == DS9097_MAX_BITS || global_counter == length) {			/* Communication with DS9097 routine */			/* Up to DS9097_MAX_BITS bits at a time */			if ( BAD( DS9097_send_and_get( local_data, &inbits[offset], local_counter, in )) ) {				STAT_ADD1_BUS(e_bus_errors, in);				return gbBAD;			}			offset += local_counter ;			local_counter = 0 ;		}	} 	/* Decode Bits */	for (global_counter = 0; global_counter < length; ++global_counter) {		inbits[global_counter] &= 0x01; // mask out all but lowest bit	}	return gbGOOD;}

GOOD_OR_BAD USB_next_match(struct usb_list *ul){	while (ul->bus) {		// First pass, look for next device		if (ul->dev == NULL) {			ul->dev = ul->bus->devices;		} else {				// New bus, find first device			ul->dev = ul->dev->next;			ul->usb_dev_number = -1 ;		}		if (ul->dev) {			// device found			if (ul->dev->descriptor.idVendor != DS2490_USB_VENDOR || ul->dev->descriptor.idProduct != DS2490_USB_PRODUCT) {				continue;		// not DS9490			}			if ( sscanf( ul->dev->filename, "%u", &(ul->usb_dev_number) ) <= 0 ) {				ul->usb_dev_number = -1 ;			}			if ( BAD ( usbdevice_in_use( ul ) ) ) {				continue ;			}			LEVEL_CONNECT("Bus master found: %.d:%.d", ul->usb_bus_number, ul->usb_dev_number);			return gbGOOD;		} else {			ul->bus = ul->bus->next;			if ( ul->bus == NULL || sscanf( ul->bus->dirname, "%u", &(ul->usb_bus_number) ) <= 0 ) {				ul->usb_bus_number = -1 ;			}			ul->dev = NULL;		}	}	return gbBAD;}

enum Netlink_Read_Status W1_Process_Response( void (* nrs_callback)( struct netlink_parse * nlp, void * v, const struct parsedname * pn), SEQ_OR_ERROR seq, void * v, const struct parsedname * pn ){	struct connection_in * in = pn->selected_connection ;	FILE_DESCRIPTOR_OR_ERROR file_descriptor ;	int bus ;	if ( seq == SEQ_BAD ) {		return nrs_bad_send ;	}	if ( in == NO_CONNECTION ) {		// Send to main netlink rather than a particular bus		file_descriptor = FILE_DESCRIPTOR_BAD ;		bus = 0 ;	} else {		// Bus-specifc		file_descriptor = in->master.w1.netlink_pipe[fd_pipe_read] ;		bus = in->master.w1.id ;	}	while ( GOOD( W1PipeSelect_timeout(file_descriptor)) ) {		struct netlink_parse nlp ;		nlp.nlm = NULL ;				LEVEL_DEBUG("Loop waiting for netlink piped message");		if ( BAD( Get_and_Parse_Pipe( file_descriptor, &nlp )) ) {			LEVEL_DEBUG("Error reading pipe for w1_bus_master%d",bus);			// Don't need to free since nlm not set if BAD			return nrs_error ;		}		if ( NL_SEQ(nlp.nlm->nlmsg_seq) != (unsigned int) seq ) {			LEVEL_DEBUG("Netlink sequence number out of order");			owfree(nlp.nlm) ;			continue ;		}		if ( nlp.w1m->status != 0) {			owfree(nlp.nlm) ;			return nrs_nodev ;		}		if ( nrs_callback == NULL ) { // status message			owfree(nlp.nlm) ;			return nrs_complete ;		}		LEVEL_DEBUG("About to call nrs_callback");		nrs_callback( &nlp, v, pn ) ;		LEVEL_DEBUG("Called nrs_callback");		owfree(nlp.nlm) ;		if ( nlp.cn->ack != 0 ) {			if ( nlp.w1m->type == W1_LIST_MASTERS ) {				continue ; // look for more data			}			if ( nlp.w1c && (nlp.w1c->cmd==W1_CMD_SEARCH || nlp.w1c->cmd==W1_CMD_ALARM_SEARCH) ) {				continue ; // look for more data			}		}		nrs_callback = NULL ; // now look for status message	}	return nrs_timeout ;}

static GOOD_OR_BAD OW_w_pio(const BYTE data, const struct parsedname *pn){	BYTE write_string[] = { _1W_CHANNEL_ACCESS_WRITE, data, (BYTE) ~ data, };	BYTE read_back[2];	struct transaction_log t[] = {		TRXN_START,		TRXN_WRITE3(write_string),		TRXN_READ2(read_back),		TRXN_END,	};	if ( BAD(BUS_transaction(t, pn)) ) {		// may be in test mode, which causes Channel Access Write to fail		// fix now, but need another attempt to see if will work		OW_out_of_test_mode(pn) ;		return gbBAD ;	}	if (read_back[0] != 0xAA) {		return gbBAD;	}	/* Ignore byte 5 read_back[1] the PIO status byte */	return gbGOOD;}

static GOOD_OR_BAD OW_w_std(BYTE *buf, size_t size, BYTE type, BYTE stype, const struct parsedname *pn){	BYTE p[4] = { _1W_WRITE_MOAT, type,stype, size};	BYTE crcbuf[2];	UINT crc;	struct transaction_log tfirst[] = {		TRXN_START,		TRXN_WRITE(p,4),		TRXN_WRITE(buf,size),		TRXN_READ2(crcbuf),		TRXN_END,	};	struct transaction_log xmit_crc[] = {		TRXN_WRITE2(crcbuf),		TRXN_END,	};	if (size == 0) {		return gbGOOD;	}	if (size > 255) {		return gbBAD;	}	LEVEL_DEBUG( "write: %d for %d %d",size,type,stype) ;		if ( BAD(BUS_transaction(tfirst, pn))) {		goto out_bad;	}	crc = CRC16compute(p,4,0);	crc = CRC16compute(buf,size,crc);	if ( CRC16seeded (crcbuf,2,crc) ) {		LEVEL_DEBUG("CRC error");		goto out_bad;	}	LEVEL_DEBUG( "read CRC: GOOD, got %02x%02x",crcbuf[0],crcbuf[1]) ;	crcbuf[0] = ~crcbuf[0];	crcbuf[1] = ~crcbuf[1];	if ( BAD(BUS_transaction(xmit_crc, pn)) ) {		goto out_bad;	}	return gbGOOD;out_bad:	return gbBAD;}

static int VISIBLE_19( const struct parsedname * pn ){	int device_id = unknown_19 ;		LEVEL_DEBUG("Checking visibility of %s",SAFESTRING(pn->path)) ;	if ( BAD( GetVisibilityCache( &device_id, pn ) ) ) {		BYTE a_byte[1] ;		// use technique and address only specified on DS2407		if ( BAD( OW_r_all( a_byte, 1, 0x0080, pn ) ) ) {			device_id = ds2502_19 ;		} else {			device_id = ds2407_19 ;		} 		SetVisibilityCache( device_id, pn ) ;	}	return device_id ;}

/* return GOOD if any found */static GOOD_OR_BAD DS2482_detect_sys( int any, enum ds2482_address chip_num, struct port_in *pin_original){    DIR * i2c_list_dir ;    struct dirent * i2c_bus ;    int found = 0 ;    struct port_in * pin_current = pin_original ;    // We'll look in this directory for available i2c adapters.    // This may be linux 2.6 specific    i2c_list_dir = opendir( SYSFS_I2C_Path ) ;    if ( i2c_list_dir == NULL ) {        ERROR_CONNECT( "Cannot open %d to find available i2c devices",SYSFS_I2C_Path ) ;        // Use the cruder approach of trying all possible numbers        return DS2482_detect_dir( any, chip_num, pin_original ) ;    }    /* cycle through entries in /sys/class/i2c-adapter */    while ( (i2c_bus=readdir(i2c_list_dir)) != NULL ) {        char dev_name[128] ; // room for /dev/name        int sn_ret ;        UCLIBCLOCK ;        sn_ret = snprintf( dev_name, 128, "/dev/%s", i2c_bus->d_name ) ;        UCLIBCUNLOCK ;        if ( sn_ret < 0 ) {            break ;        }        // Now look for the ds2482's        if ( BAD( DS2482_detect_bus( chip_num, dev_name, pin_current ) ) ) {            continue ; // none found on this i2c bus        }        // at least one found on this i2c bus        ++found ;        if ( any ) { // found one -- that's enough            closedir( i2c_list_dir ) ;            return gbGOOD ;        }        // ALL? then set up a new connection_in slot for the next one        pin_current = NewPort(pin_current) ;        if ( pin_current == NULL ) {            break ;        }    }    closedir( i2c_list_dir ) ;    if ( found==0 ) {        return gbBAD ;    }    if ( pin_current != pin_original ) {        RemovePort( pin_current ) ;    }    return gbGOOD ;}

/* Test for a simultaneous property * return true if simultaneous is the prefered method * bad if no simultaneous, or it's not the best*/static GOOD_OR_BAD Cache_Get_Simultaneous(enum simul_type type, struct one_wire_query *owq){	struct tree_node tn;	time_t duration ;	time_t time_left ;	time_t dwell_time_simul ;	struct parsedname * pn = PN(owq) ;	size_t dsize = sizeof(union value_object) ;		duration = TimeOut(pn->selected_filetype->change);	if (duration <= 0) {		// probably "uncached" requested		return gbBAD;	}		LoadTK( pn->sn, pn->selected_filetype, pn->extension, &tn ) ;		if ( Get_Stat(&cache_ext, Cache_Get_Common( &OWQ_val(owq), &dsize, &time_left, &tn)) == 0 ) {		// valid cached primary data -- see if a simultaneous conversion should be used instead		time_t dwell_time_data = duration - time_left ;				if ( BAD( Cache_Get_Simul_Time( type, &dwell_time_simul, pn)) ) {			// Simul not found or timed out			LEVEL_DEBUG("Simultaneous conversion not found.") ;			OWQ_SIMUL_CLR(owq) ;			return gbGOOD ;		}		if ( dwell_time_simul < dwell_time_data ) {			LEVEL_DEBUG("Simultaneous conversion is newer than previous reading.") ;			OWQ_SIMUL_SET(owq) ;			return gbBAD ; // Simul is newer		}		// Cached data is newer, so use it		OWQ_SIMUL_CLR(owq) ;		return gbGOOD ;	}	// fall through -- no cached primary data	if ( BAD( Cache_Get_Simul_Time( type, &dwell_time_simul, pn)) ) {		// no simultaneous either		OWQ_SIMUL_CLR(owq) ;		return gbBAD ;	}	OWQ_SIMUL_SET(owq) ;	return gbBAD ; // Simul is newer}

static void LINK_set_baud(struct connection_in * in){	struct port_in * pin = in->pown ;	char * speed_code ;	if ( pin->type == ct_telnet ) {		// telnet pinned at 115200		return ;	}	COM_BaudRestrict( &(pin->baud), B9600, B19200, B38400, B57600, 0 ) ;	LEVEL_DEBUG("to %d",COM_BaudRate(pin->baud));	// Find rate parameter	switch ( pin->baud ) {		case B9600:			COM_break(in) ;			LINK_flush(in);			return ;		case B19200:			speed_code = "," ;			break ;		case B38400:			speed_code = "`" ;			break ;#ifdef B57600		/* MacOSX support max 38400 in termios.h ? */		case B57600:			speed_code = "^" ;			break ;#endif		default:			LEVEL_DEBUG("Unrecognized baud rate");			return ;	}	LEVEL_DEBUG("LINK change baud string <%s>",speed_code);	LINK_flush(in);	if ( BAD( LINK_write(LINK_string(speed_code), 1, in) ) ) {		LEVEL_DEBUG("LINK change baud error -- will return to 9600");		pin->baud = B9600 ;		++in->changed_bus_settings ;		return ;	}	// Send configuration change	LINK_flush(in);	// Change OS view of rate	UT_delay(5);	COM_change(in) ;	UT_delay(5);	LINK_slurp(in);	return ;}

/* cm.ret is also set to an error <0 or the read length */void *ReadHandler(struct handlerdata *hd, struct client_msg *cm, struct one_wire_query *owq){	BYTE * retbuffer = NULL ;	SIZE_OR_ERROR read_or_error;	LEVEL_DEBUG("ReadHandler start");	if (hd == NULL || owq == NULL || cm == NULL) {		LEVEL_DEBUG("ReadHandler: illegal null inputs hd==%p owq==%p cm==%p", hd, owq, cm);		return NULL;			// only sane response for bad inputs	}	LEVEL_DEBUG("ReadHandler: From Client sm->payload=%d sm->size=%d sm->offset=%d", hd->sm.payload, hd->sm.size, hd->sm.offset);	if (hd->sm.payload >= PATH_MAX) {		cm->ret = -EMSGSIZE;	} else if ((hd->sm.size <= 0) || (hd->sm.size > MAX_OWSERVER_PROTOCOL_PAYLOAD_SIZE)) {		cm->ret = -EMSGSIZE;		LEVEL_DEBUG("ReadHandler: error hd->sm.size == %d", hd->sm.size);	} else if ( BAD( OWQ_allocate_read_buffer(owq)) ) {	// allocate read buffer		LEVEL_DEBUG("ReadHandler: can't allocate memory");		cm->ret = -ENOBUFS;	} else {		struct parsedname *pn = PN(owq);		if ( OWQ_size(owq) > (size_t) hd->sm.size ) {			OWQ_size(owq) = hd->sm.size ;		}		OWQ_offset(owq) = hd->sm.offset ;		LEVEL_DEBUG("ReadHandler: call FS_read_postparse on %s", pn->path);		read_or_error = FS_read_postparse(owq);		LEVEL_DEBUG("ReadHandler: FS_read_postparse read on %s return = %d", pn->path, read_or_error);		Debug_OWQ(owq);		if (read_or_error <= 0) {			LEVEL_DEBUG("ReadHandler: FS_read_postparse error %d", read_or_error);			cm->ret = read_or_error;		} else {			LEVEL_DEBUG("ReadHandler: FS_read_postparse ok size=%d", read_or_error);			// make return size smaller (just large enough)			cm->payload = read_or_error;			cm->offset = hd->sm.offset;			cm->size = read_or_error;			cm->ret = read_or_error;			/* Move this pointer, and let owfree remove it instead of OWQ_destroy() */			retbuffer = (BYTE *)OWQ_buffer(owq);			OWQ_buffer(owq) = NULL;		}	}	LEVEL_DEBUG("ReadHandler: To Client cm->payload=%d cm->size=%d cm->offset=%d", cm->payload, cm->size, cm->offset);	if ((cm->size > 0)) {		Debug_Bytes("Data returned to client",(BYTE *) OWQ_buffer(owq),cm->size) ;	}	return retbuffer;}