static ZERO_OR_ERROR FS_r_set_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 >> 3) & 0x07];
return 0;
}
void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
{
#ifdef CONFIG_RT_GROUP_SCHED
SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, task_group_path(rt_rq->tg));
#else
SEQ_printf(m, "\nrt_rq[%d]:\n", cpu);
#endif
#define P(x) \
SEQ_printf(m, " .%-30s: %Ld\n", #x, (long long)(rt_rq->x))
#define PN(x) \
SEQ_printf(m, " .%-30s: %Ld.%06ld\n", #x, SPLIT_NS(rt_rq->x))
P(rt_nr_running);
P(rt_throttled);
PN(rt_time);
PN(rt_runtime);
#undef PN
#undef P
}
static ZERO_OR_ERROR FS_w_mem(struct one_wire_query *owq)
{
size_t pagesize = 32;
ZERO_OR_ERROR error_code = COMMON_readwrite_paged(owq, 0, pagesize, OW_w_mem) ;
/* paged write */
if (error_code != 0) {
error_code = -EFAULT ;
}
OW_reset(PN(owq)) ; // DS2404 needs this to release for 3-wire communication
return error_code ;
}
void setup(void) {
/*
Test Envionment, ATMEGA with the following settings:
CS: PORTB, Bit 2
A0: PORTB, Bit 1
SCK: PORTB, Bit 5
MOSI: PORTB, Bit 3
*/
/* 1. Setup and create u8g device */
/* u8g_InitSPI(&u8g, &u8g_dev_st7565_dogm132_sw_spi, PN(1, 5), PN(1, 3), PN(1, 2), PN(1, 1), U8G_PIN_NONE); */
u8g_InitHWSPI(&u8g, &u8g_dev_st7565_dogm132_hw_spi, PN(1, 2), PN(1, 1), U8G_PIN_NONE);
/* 2. Setup m2 */
m2_Init(&el_top, m2_es_avr_u8g, m2_eh_4bs, m2_gh_u8g_bfs);
/* 3. Connect u8g display to m2 */
m2_SetU8g(&u8g, m2_u8g_box_icon);
/* 4. Set a font, use normal u8g_font's */
m2_SetFont(0, (const void *)u8g_font_5x8r);
/* 5. Define keys */
m2_SetPin(M2_KEY_EXIT, PN(3, 5));
m2_SetPin(M2_KEY_SELECT, PN(3, 6));
m2_SetPin(M2_KEY_NEXT, PN(3, 7));
m2_SetPin(M2_KEY_PREV, PN(1, 7));
}
void setup(void)
{
/*
Test Envionment, ATMEGA with the following settings:
CS: PORTB, Bit 2
A0: PORTB, Bit 1
SCK: PORTB, Bit 5
MOSI: PORTB, Bit 3
*/
/* 1. Setup and create u8g device: http://code.google.com/p/u8glib/wiki/avr#U8glib_Init */
/* u8g_InitSPI(&u8g, &u8g_dev_st7565_dogm132_sw_spi, PN(1, 5), PN(1, 3), PN(1, 2), PN(1, 1), U8G_PIN_NONE); */
u8g_InitHWSPI(&u8g, &u8g_dev_st7565_dogm132_hw_spi, PN(1, 2), PN(1, 1), U8G_PIN_NONE);
/* 2. Setup m2 */
m2_Init(&top_el_pin_list, m2_es_avr_u8g, m2_eh_4bs, m2_gh_u8g_bfs);
//m2_Init(&top_el_pin_list, m2_es_avr_rotary_encoder_u8g, m2_eh_4bd, m2_gh_u8g_bfs);
/* 3. Connect u8g display to m2 */
m2_SetU8g(&u8g, m2_u8g_box_icon);
/* 4. Set a font, use normal u8g_font's */
m2_SetFont(0, (const void *)u8g_font_5x8r);
/* 5. Define keys (PN() description, see http://code.google.com/p/u8glib/wiki/avr#U8glib_Init) */
m2_SetPin(M2_KEY_EXIT, PN(3, 5));
m2_SetPin(M2_KEY_SELECT, PN(3, 6));
m2_SetPin(M2_KEY_NEXT, PN(3, 7));
m2_SetPin(M2_KEY_PREV, PN(1, 7));
}
static ZERO_OR_ERROR FS_w_screenX(struct one_wire_query *owq)
{
struct one_wire_query * owq_line ;
int extension;
struct parsedname *pn = PN(owq);
int width = pn->selected_filetype->data.i;
int rows = (width == 40) ? 2 : 4; /* max number of rows */
char *start_of_remaining_text = OWQ_buffer(owq);
char *pointer_after_all_text = OWQ_buffer(owq) + OWQ_size(owq);
if (OWQ_offset(owq)) {
return -ERANGE;
}
if (BAD( OW_clear(pn) ) ) {
return -EFAULT;
}
owq_line = OWQ_create_separate( 0, owq ) ;
if ( owq_line == NO_ONE_WIRE_QUERY ) {
return -ENOMEM ;
}
for (extension = 0; extension < rows; ++extension) {
char *newline_location = memchr(start_of_remaining_text, '\n',
pointer_after_all_text - start_of_remaining_text);
OWQ_pn(owq_line).extension = extension;
OWQ_buffer(owq_line) = start_of_remaining_text;
if ((newline_location != NULL)
&& (newline_location < start_of_remaining_text + width)) {
OWQ_size(owq_line) = newline_location - start_of_remaining_text;
start_of_remaining_text = newline_location + 1; /* skip over newline */
} else {
char *lineend_location = start_of_remaining_text + width;
if (lineend_location > pointer_after_all_text) {
lineend_location = pointer_after_all_text;
}
OWQ_size(owq_line) = lineend_location - start_of_remaining_text;
start_of_remaining_text = lineend_location;
}
if (FS_w_lineX(owq_line)) {
OWQ_destroy( owq_line ) ;
return -EINVAL;
}
if (start_of_remaining_text >= pointer_after_all_text)
break;
}
OWQ_destroy( owq_line ) ;
return 0;
}
static int sched_debug_show(struct seq_file *m, void *v)
{
u64 ktime, sched_clk, cpu_clk;
unsigned long flags;
int cpu;
local_irq_save(flags);
ktime = ktime_to_ns(ktime_get());
sched_clk = sched_clock();
cpu_clk = local_clock();
local_irq_restore(flags);
SEQ_printf(m, "Sched Debug Version: v0.10, %s %.*s\n",
init_utsname()->release,
(int)strcspn(init_utsname()->version, " "),
init_utsname()->version);
#define P(x) \
SEQ_printf(m, "%-40s: %Ld\n", #x, (long long)(x))
#define PN(x) \
SEQ_printf(m, "%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
PN(ktime);
PN(sched_clk);
PN(cpu_clk);
P(jiffies);
#ifdef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
P(sched_clock_stable);
#endif
#undef PN
#undef P
SEQ_printf(m, "\n");
SEQ_printf(m, "sysctl_sched\n");
#define P(x) \
SEQ_printf(m, " .%-40s: %Ld\n", #x, (long long)(x))
#define PN(x) \
SEQ_printf(m, " .%-40s: %Ld.%06ld\n", #x, SPLIT_NS(x))
PN(sysctl_sched_latency);
PN(sysctl_sched_min_granularity);
PN(sysctl_sched_wakeup_granularity);
P(sysctl_sched_child_runs_first);
P(sysctl_sched_features);
#undef PN
#undef P
SEQ_printf(m, " .%-40s: %d (%s)\n", "sysctl_sched_tunable_scaling",
sysctl_sched_tunable_scaling,
sched_tunable_scaling_names[sysctl_sched_tunable_scaling]);
read_lock_irqsave(&tasklist_lock, flags);
//for_each_online_cpu(cpu)
for_each_possible_cpu(cpu)
print_cpu(m, cpu);
read_unlock_irqrestore(&tasklist_lock, flags);
SEQ_printf(m, "\n");
return 0;
}
static ZERO_OR_ERROR FS_redefchar(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if ( OWQ_size(owq) != LCD_REDEFCHAR_LENGTH ) {
return -ERANGE ;
}
if ( OWQ_offset(owq) != 0 ) {
return -ERANGE ;
}
return GB_to_Z_OR_E( OW_redefchar( OWQ_buffer(owq), pn ) ) ;
}
// 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;
}
/* 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;
}
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");
}
static ZERO_OR_ERROR FS_w_mem(struct one_wire_query *owq)
{
/* paged access */
size_t pagesize;
switch (PN(owq)->sn[0]) {
case 0x2D:
pagesize = 8 ;
return GB_to_Z_OR_E(COMMON_readwrite_paged(owq, 0, pagesize, OW_w_2Dpage)) ;
default:
pagesize = 8 ;
return GB_to_Z_OR_E(COMMON_readwrite_paged(owq, 0, pagesize, OW_w_23page)) ;
}
}
/* Write to interface dir */
static ZERO_OR_ERROR FS_w_interface(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
if ( pn->selected_connection == NO_CONNECTION ) {
LEVEL_DEBUG("Attempt to write to no bus for /settings");
return -ENODEV ;
} else if ( SpecifiedLocalBus(pn) ) {
return FS_w_local(owq);
} else {
return ServerWrite(owq);
}
}
static ZERO_OR_ERROR FS_r_ds2490status(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
char res[256];
char buffer[ DS9490_getstatus_BUFFER_LENGTH ];
int ret;
res[0] = '\0';
if (get_busmode(pn->selected_connection) == bus_usb) {
#if OW_USB
ret = DS9490_getstatus(buffer, 0, PN(owq));
if (ret < 0) {
sprintf(res, "DS9490_getstatus failed: %d\n", ret);
} else {
sprintf(res,
"%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n",
buffer[0], buffer[1], buffer[2], buffer[3],
buffer[4], buffer[5], buffer[6], buffer[7],
buffer[8], buffer[9], buffer[10], buffer[11], buffer[12], buffer[13], buffer[14], buffer[15]);
}
/*
uchar EnableFlags;
uchar OneWireSpeed;
uchar StrongPullUpDuration;
uchar ProgPulseDuration;
uchar PullDownSlewRate;
uchar Write1LowTime;
uchar DSOW0RecoveryTime;
uchar Reserved1;
uchar StatusFlags;
uchar CurrentCommCmd1;
uchar CurrentCommCmd2;
uchar CommBufferStatus; // Buffer for COMM commands
uchar WriteBufferStatus; // Buffer we write to
uchar ReadBufferStatus; // Buffer we read from
*/
#endif
}
return OWQ_format_output_offset_and_size_z(res, owq);
}
/* Use an aggregate OWQ as a template for a single element */
struct one_wire_query * OWQ_create_separate( int extension, struct one_wire_query * owq_aggregate )
{
int sz = sizeof( struct one_wire_query ) + OWQ_DEFAULT_READ_BUFFER_SIZE;
struct one_wire_query * owq_sep = owmalloc( sz );
LEVEL_DEBUG("%s with extension %d", PN(owq_aggregate)->path,extension);
if ( owq_sep== NO_ONE_WIRE_QUERY) {
LEVEL_DEBUG("No memory to create object for extension %d",extension) ;
return NO_ONE_WIRE_QUERY ;
}
memset(owq_sep, 0, sz);
OWQ_cleanup(owq_sep) = owq_cleanup_owq ;
memcpy( PN(owq_sep), PN(owq_aggregate), sizeof(struct parsedname) ) ;
PN(owq_sep)->extension = extension ;
OWQ_buffer(owq_sep) = (char *) (& owq_sep[1]) ; // point just beyond the one_wire_query struct
OWQ_size(owq_sep) = OWQ_DEFAULT_READ_BUFFER_SIZE ;
OWQ_offset(owq_sep) = 0 ;
return owq_sep ;
}
//Compute intersection points of 3D sub NURBS of original B-rep.
//Parameter values of this at intersection points will be returned.
//This(RLBRep) will be projected to 3D plane of coordinate kind
//(coordinate, coordinate+1, coordinate+2), then intersection will
//be computed.
MGCParam_list MGRLBRep::isect_3D(
const MGPlane& pl, // Plane.
size_t coordinate // Coordinate kind of 3D sub space.
)const{
assert(coordinate<sdim());
MGVector C(3,pl.root_point(),0,coordinate);
MGVector PN(3,pl.normal(),0,coordinate); //Plane Normal.
MGVector N(4,PN);
N(3)=-(C%PN);
//N is 4D vector that is normal to C, pl.u_deriv() and pl.v_deriv().
return isect_nD(N,3,coordinate);
}
/* fake adapter temperature limits */
static ZERO_OR_ERROR FS_r_templimit(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
switch ( get_busmode(pn->selected_connection) ) {
case bus_fake:
case bus_mock:
case bus_tester:
OWQ_F(owq) = pn->selected_filetype->data.i ? pn->selected_connection->master.fake.templow : pn->selected_connection->master.fake.temphigh;
return 0;
default:
return -ENOTSUP ;
}
}
/* read flag */
static ZERO_OR_ERROR FS_r_flag(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
BYTE cr;
BYTE fl = pn->selected_filetype->data.c;
OWQ_allocate_struct_and_pointer(owq_flag);
OWQ_create_temporary(owq_flag, (char *) &cr, 1, 0x0201, pn);
if (COMMON_read_memory_F0(owq_flag, 0, 0)) {
return -EINVAL;
}
OWQ_Y(owq) = (cr & fl) ? 1 : 0;
return 0;
}
/* No CRC -- 0xF0 code */
GOOD_OR_BAD COMMON_read_memory_F0(struct one_wire_query *owq, size_t page, size_t pagesize)
{
off_t offset = OWQ_offset(owq) + page * pagesize;
BYTE p[3] = { _1W_READ_F0, LOW_HIGH_ADDRESS(offset), };
struct transaction_log t[] = {
TRXN_START,
TRXN_WRITE3(p),
TRXN_READ((BYTE *) OWQ_buffer(owq), OWQ_size(owq)),
TRXN_END,
};
Set_OWQ_length(owq);
return BUS_transaction(t, PN(owq));
}
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 OW_script_read( FILE * script_f, struct one_wire_query * owq )
{
size_t fr_return ;
memset( OWQ_buffer(owq), 0, OWQ_size(owq) ) ;
fr_return = fread( OWQ_buffer(owq), OWQ_size(owq), 1, script_f ) ;
if ( fr_return == 0 && ferror(script_f) != 0 ) {
LEVEL_DEBUG( "Could not read script data back for %s",PN(owq)->path ) ;
return -EIO ;
}
return OWQ_parse_input( owq ) ;
}
static GOOD_OR_BAD OWQ_allocate_array( struct one_wire_query * owq )
{
struct parsedname * pn = PN(owq) ;
if (pn->extension == EXTENSION_ALL && pn->type != ePN_structure) {
OWQ_array(owq) = owcalloc((size_t) pn->selected_filetype->ag->elements, sizeof(union value_object));
if (OWQ_array(owq) == NO_ONE_WIRE_QUERY) {
return gbBAD ;
}
OWQ_cleanup(owq) |= owq_cleanup_array ;
} else {
OWQ_I(owq) = 0;
}
return gbGOOD ;
}
// Clear the display after potential initialization
static ZERO_OR_ERROR FS_Hclear(struct one_wire_query *owq)
{
struct parsedname *pn = PN(owq);
BYTE clear[] = {
NIBBLE_CTRL(LCD_COMMAND_CLEAR_DISPLAY),
NIBBLE_CTRL(LCD_COMMAND_DISPLAY_ON),
NIBBLE_CTRL(LCD_COMMAND_RIGHT_TO_LEFT),
};
if ( BAD( OW_Hinit(pn) ) ) {
LEVEL_DEBUG("Screen initialization error");
return -EINVAL ;
}
return GB_to_Z_OR_E(OW_w_pios(clear, 6, pn)) ;
}
static ZERO_OR_ERROR FS_w_port_raw(struct one_wire_query *owq)
{
BYTE *buf = (BYTE *) OWQ_buffer(owq);
size_t len = OWQ_size(owq);
if (OWQ_offset(owq) != 0)
return -EINVAL; /* ignore? */
// Hack for testing, otherwise we'll not be able to clear a port using owwrite.
if(len == 1 && (*buf == '0' || *buf == '1')) {
*buf -= '0';
}
return GB_to_Z_OR_E( OW_w_std( buf,len, M_PORT,OWQ_pn(owq).extension, PN(owq)) ) ;
}
/* Higher level add of a one-wire-query object */
GOOD_OR_BAD OWQ_Cache_Add(const struct one_wire_query *owq)
{
const struct parsedname *pn = PN(owq);
if (pn->extension == EXTENSION_ALL) {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
return gbBAD; // cache of string arrays not supported
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(OWQ_array(owq), (pn->selected_filetype->ag->elements) * sizeof(union value_object), pn);
default:
return gbBAD;
}
} else {
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
if (OWQ_offset(owq) > 0) {
return gbBAD;
}
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(OWQ_buffer(owq), OWQ_length(owq), pn);
case ft_integer:
case ft_unsigned:
case ft_yesno:
case ft_date:
case ft_float:
case ft_pressure:
case ft_temperature:
case ft_tempgap:
LEVEL_DEBUG("Adding data for %s", SAFESTRING(pn->path) );
return Cache_Add(&OWQ_val(owq), sizeof(union value_object), pn);
default:
return gbBAD;
}
}
}
struct one_wire_query * BYTEtoALL(struct one_wire_query *owq_byte)
{
struct one_wire_query * owq_all = OWQ_create_aggregate( owq_byte );
size_t elements = PN(owq_all)->selected_filetype->ag->elements ;
size_t extension ;
if ( owq_all == NO_ONE_WIRE_QUERY ) {
return NO_ONE_WIRE_QUERY ;
}
for ( extension = 0 ; extension < elements ; ++extension ) {
OWQ_array_Y(owq_all,extension) = UT_getbit_U( OWQ_U(owq_byte), extension ) ;
}
return owq_all ;
}
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 ;
}
struct one_wire_query * ALLtoBYTE(struct one_wire_query *owq_all)
{
struct one_wire_query * owq_byte = OWQ_create_separate( EXTENSION_BYTE, owq_all );
size_t elements = PN(owq_all)->selected_filetype->ag->elements ;
size_t extension ;
if ( owq_byte == NO_ONE_WIRE_QUERY ) {
return NO_ONE_WIRE_QUERY ;
}
for ( extension = 0 ; extension < elements ; ++extension ) {
UT_setbit_U( &OWQ_U(owq_byte), extension, OWQ_array_Y(owq_all,extension) ) ;
}
return owq_byte ;
}
/* Serial baud rate */
static ZERO_OR_ERROR FS_r_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_ha5:
case bus_ha7e:
case bus_pbm:
OWQ_U(owq) = COM_BaudRate( in->pown->baud ) ;
return 0;
default:
return -ENOTSUP ;
}
}
