display_options() { /** Display all the available options.. **/ char *sort_name(); ClearScreen(); Centerline(0,"-- ELM Options Editor --"); #ifdef ENABLE_CALENDAR PutLine1(2, 0, "C)alendar file : %s", raw_calendar_file); #endif PutLine1(3, 0, "D)isplay mail using : %s", raw_pager); PutLine1(4, 0, "E)ditor : %s", raw_editor); PutLine1(5, 0, "F)older directory : %s", raw_folders); PutLine1(6, 0, "S)orting criteria : %s", sort_name(FULL)); PutLine1(7, 0, "O)utbound mail saved : %s", raw_sentmail); PutLine1(8, 0, "P)rint mail using : %s", raw_printout); PutLine1(9, 0, "Y)our full name : %s", full_username); PutLine1(12,0, "A)rrow cursor : %s", onoff(arrow_cursor)); PutLine1(13,0, "M)enu display : %s", onoff(mini_menu)); PutLine1(15,0, "U)ser level : %s", level_name(user_level)); PutLine1(16,0, "N)ames only : %s", onoff(names_only)); }
int mpssconfig_update_pm(char *name, int cpufreq, int corec6, int pc3, int pc6) { struct mic_info *miclist; struct mic_info *mic; struct mpss_env menv; int err = 0; if (mpssenv_init(&menv)) return CONFIG_ERROR_ENV; if ((miclist = mpss_get_miclist(&menv, NULL)) == NULL) return CONFIG_ERROR_EXIST; if ((mic = mpss_find_micname_inlist(miclist, name)) == NULL) { err = CONFIG_ERROR_EXIST; goto free_and_ret; } if (mpss_update_config(&menv, mic->config.name, "PowerManagement", NULL, "PowerManagement \"cpufreq_%s;corec6_%s;pc3_%s;pc6_%s\"\n", onoff(cpufreq), onoff(corec6), onoff(pc3), onoff(pc6))) err = CONFIG_ERROR_WRITE; free_and_ret: mpss_free_miclist(miclist); return err; }
static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv, bool wait_for_on) { u32 mask; u32 val; int err; mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK; val = wait_for_on ? mask : 0; #define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val) if (COND) return 0; DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n", onoff(wait_for_on), I915_READ(VLV_GTLC_PW_STATUS)); /* * RC6 transitioning can be delayed up to 2 msec (see * valleyview_enable_rps), use 3 msec for safety. */ err = wait_for(COND, 3); if (err) DRM_ERROR("timeout waiting for GT wells to go %s\n", onoff(wait_for_on)); return err; #undef COND }
irom io_error_t io_mcp_get_pin_info(string_t *dst, const struct io_info_entry_T *info, io_data_pin_entry_t *pin_data, const io_config_pin_entry_t *pin_config, int pin) { int bank, bankpin, tv; int io, olat, cached; mcp_data_pin_t *mcp_pin_data; bank = (pin & 0x08) >> 3; bankpin = pin & 0x07; mcp_pin_data = &mcp_data_pin_table[info->instance][pin]; switch(pin_config->llmode) { case(io_pin_ll_input_analog): { if(read_register(dst, info->address, GPIO(bank), &tv) != io_ok) return(io_error); string_format(dst, "current io: %s", onoff(tv & (1 << bankpin))); break; } case(io_pin_ll_counter): { if(read_register(dst, info->address, GPIO(bank), &tv) != io_ok) return(io_error); string_format(dst, "current io: %s, debounce: %d", onoff(tv & (1 << bankpin)), mcp_pin_data->debounce); break; } case(io_pin_ll_output_digital): { if(read_register(dst, info->address, GPIO(bank), &tv) != io_ok) return(io_error); io = tv & (1 << bankpin); if(read_register(dst, info->address, OLAT(bank), &tv) != io_ok) return(io_error); olat = tv & (1 << bankpin); cached = pin_output_cache[bank] & (1 << bankpin); string_format(dst, "current latch: %s, io: %s, cache: %s", onoff(io), onoff(olat), onoff(cached)); break; } default: { } } return(io_ok); }
/* For ILK+ */ void assert_shared_dpll(struct drm_i915_private *dev_priv, struct intel_shared_dpll *pll, bool state) { bool cur_state; struct intel_dpll_hw_state hw_state; if (WARN(!pll, "asserting DPLL %s with no DPLL\n", onoff(state))) return; cur_state = pll->funcs.get_hw_state(dev_priv, pll, &hw_state); I915_STATE_WARN(cur_state != state, "%s assertion failure (expected %s, current %s)\n", pll->name, onoff(state), onoff(cur_state)); }
/* * === FUNCTION ====================================================================== * Name: AUTOLOG * Description: * ===================================================================================== */ void AUTOMATIC(void) { automatic = !automatic; printf("automatic login/connect %s.\n", onoff(automatic)); code = automatic; } /* ----- end of function AUTOLOG ----- */
/* * === FUNCTION ====================================================================== * Name: PASSIVE * Description: * ===================================================================================== */ void PASSIVE (void) { passivemode = !passivemode; printf("Passive mode %s.\n", onoff(passivemode)); code = passivemode; } /* ----- end of function PASSIVE ----- */
void MarchingCubesGenerator::initCubes() { if (numCubes < 1) return; bool ***on = new bool**[numCubes]; for(int i=0;i<numCubes;i++) { on[i]=new bool*[numCubes]; for(int j=0;j<numCubes;j++) on[i][j]=new bool[numCubes]; } float ***noise=new float**[numCubes]; for(int i=0;i<numCubes;i++) { noise[i]=new float*[numCubes]; for(int j=0;j<numCubes;j++) noise[i][j]=new float[numCubes]; } Perlin3DNoise noises; noises.Generate3DArray(noise,numCubes,numCubes,numCubes, .7 , .5, 10, 1.4); cubes=new Cube**[numCubes-1]; for(int i=0; i<numCubes-1; i++) { cubes[i] = new Cube*[numCubes-1]; for(int j=0; j<numCubes-1; j++) cubes[i][j] = new Cube[numCubes-1]; } onoff(on, noise); initAllVertNormals(); }
irom static app_action_t set_unset_flag(application_parameters_t ap, bool_t value) { uint16_t length; if(ap.nargs < 2) { length = snprintf(ap.dst, ap.size, "%s", "flags: "); ap.dst += length; ap.size -= length; length = config_flags_to_string(ap.size, ap.dst, config->flags); ap.dst += length; ap.size -= length; strlcpy(ap.dst, "\n", ap.size); return(app_action_normal); } if(!config_set_flag_by_name((*ap.args)[1], value)) { snprintf(ap.dst, ap.size, "> unknown flag %s\n", (*ap.args)[1]); return(app_action_error); } snprintf(ap.dst, ap.size, "> flag %s %s\n", (*ap.args)[1], onoff(value)); return(app_action_normal); }
static void report(struct slabinfo *s) { if (strcmp(s->name, "*") == 0) return; printf("\nSlabcache: %-20s Aliases: %2d Order : %2d Objects: %lu\n", s->name, s->aliases, s->order, s->objects); if (s->hwcache_align) printf("** Hardware cacheline aligned\n"); if (s->cache_dma) printf("** Memory is allocated in a special DMA zone\n"); if (s->destroy_by_rcu) printf("** Slabs are destroyed via RCU\n"); if (s->reclaim_account) printf("** Reclaim accounting active\n"); printf("\nSizes (bytes) Slabs Debug Memory\n"); printf("------------------------------------------------------------------------\n"); printf("Object : %7d Total : %7ld Sanity Checks : %s Total: %7ld\n", s->object_size, s->slabs, onoff(s->sanity_checks), s->slabs * (page_size << s->order)); printf("SlabObj: %7d Full : %7ld Redzoning : %s Used : %7ld\n", s->slab_size, s->slabs - s->partial - s->cpu_slabs, onoff(s->red_zone), s->objects * s->object_size); printf("SlabSiz: %7d Partial: %7ld Poisoning : %s Loss : %7ld\n", page_size << s->order, s->partial, onoff(s->poison), s->slabs * (page_size << s->order) - s->objects * s->object_size); printf("Loss : %7d CpuSlab: %7d Tracking : %s Lalig: %7ld\n", s->slab_size - s->object_size, s->cpu_slabs, onoff(s->store_user), (s->slab_size - s->object_size) * s->objects); printf("Align : %7d Objects: %7d Tracing : %s Lpadd: %7ld\n", s->align, s->objs_per_slab, onoff(s->trace), ((page_size << s->order) - s->objs_per_slab * s->slab_size) * s->slabs); ops(s); show_tracking(s); slab_numa(s, 1); slab_stats(s); }
irom app_action_t application_function_gpio_get(application_parameters_t ap) { unsigned int gpio_index; gpio_t *gpio; const gpio_config_entry_t *cfg; if(ap.nargs < 2) { snprintf(ap.dst, ap.size, "gpio-get: too little arguments: %u\n", ap.nargs - 1); return(app_action_error); } gpio_index = atoi((*ap.args)[1]); if(!(gpio = find_gpio(gpio_index))) { snprintf(ap.dst, ap.size, "gpio-get: invalid gpio %u\n", gpio_index); return(app_action_error); } cfg = get_config(gpio); switch(cfg->mode) { case(gpio_disabled): { snprintf(ap.dst, ap.size, "gpio-get: gpio %s is disabled\n", gpio->name); return(app_action_error); } case(gpio_input): { snprintf(ap.dst, ap.size, "gpio-get: gpio %s is %s\n", gpio->name, onoff(get_input(gpio))); return(app_action_normal); } case(gpio_counter): { snprintf(ap.dst, ap.size, "gpio-get: gpio %s is %u (state: %s)\n", gpio->name, gpio->counter.count, onoff(get_input(gpio))); if(cfg->counter.reset_on_get) gpio->counter.count = 0; gpio->counter.debounce = 0; return(app_action_normal); } case(gpio_output): case(gpio_timer): { snprintf(ap.dst, ap.size, "gpio-get: gpio %s is output\n", gpio->name); return(app_action_error); } case(gpio_pwm): { dump(&config->gpios, gpio, ap.size, ap.dst); return(app_action_normal); } case(gpio_i2c): { snprintf(ap.dst, ap.size, "gpio-get: gpio %s is reserved for i2c\n", gpio->name); return(app_action_error); } default: { } } snprintf(ap.dst, ap.size, "gpio-get: invalid mode %u\n", cfg->mode); return(app_action_error); }
irom static void dump(const gpio_config_t *cfgs, const gpio_t *gpio_in, unsigned int size, char *str) { unsigned int current; unsigned int length; const gpio_t *gpio; const gpio_config_entry_t *cfg; for(current = 0; current < gpio_size; current++) { gpio = &gpios[current]; cfg = &cfgs->entry[current]; if(!gpio_in || (gpio_in->id == gpio->id)) { length = snprintf(str, size, "> gpio: %u, name: %s, mode: ", gpio->index, gpio->name); size -= length; str += length; length = 0; switch(cfg->mode) { case(gpio_disabled): { length = snprintf(str, size, "disabled"); break; } case(gpio_input): { length = snprintf(str, size, "input, state: %s", onoff(get_input(gpio))); break; } case(gpio_counter): { length = snprintf(str, size, "counter, state: %s, counter: %u, debounce: %u/%u, reset on get: %s", onoff(get_input(gpio)), gpio->counter.count, cfg->counter.debounce, gpio->counter.debounce, onoff(cfg->counter.reset_on_get)); break; } case(gpio_output): { length = snprintf(str, size, "output, state: %s, startup: %s", onoff(get_input(gpio)), onoff(cfg->output.startup_state)); break; } case(gpio_timer): { length = snprintf(str, size, "timer, direction: %s, delay: %u ms, repeat: %s, autotrigger: %s, active: %s, current state: %s", cfg->timer.direction == gpio_up ? "up" : "down", cfg->timer.delay, onoff(cfg->timer.repeat), onoff(cfg->timer.autotrigger), onoff(gpio->timer.delay > 0), onoff(get_input(gpio))); break; } case(gpio_pwm): { length = snprintf(str, size, "pwm, "); str += length; size -= length; if(gpio_flags.pwm_subsystem_active) length = snprintf(str, size, "active, channel: %u, current frequency: %u Hz, current duty: %u", gpio->pwm.channel, 1000000 / pwm_get_period(), pwm_get_duty(gpio->pwm.channel)); else length = snprintf(str, size, "inactive"); str += length; size -= length; length = snprintf(str, size, "\ndefault min duty: %u, max duty: %u, delay: %u", cfg->pwm.min_duty, cfg->pwm.max_duty, cfg->pwm.delay); str += length; size -= length; length = snprintf(str, size, "\ncurrent min duty: %u, max duty %u, delay: %u", gpio->pwm.min_duty, gpio->pwm.max_duty, gpio->pwm.delay_top); break; } case(gpio_i2c): { length = snprintf(str, size, "i2c, pin: %s", cfg->i2c.pin == gpio_i2c_sda ? "sda" : "scl"); break; } default: { length = snprintf(str, size, "unknown mode"); break; } } str += length; size =- length; length = snprintf(str, size, "\n"); str += length; size -= length; } } }
irom void config_flags_to_string(string_t *dst, const char *pre, const char *post, int flags) { config_flag_enum_t current; if(pre) string_format(dst, "%s", pre); for(current = 0; current < config_flag_size; current++) string_format(dst, "%s%s:%s", string_length(dst) > 0 ? " " : "", config_flag[current].long_name, onoff(flags & 1 << current)); if(post) string_format(dst, "%s", post); }
irom void io_config_dump(string_t *dst, const config_t *cfg, int io_id, int pin_id, bool html) { const io_info_entry_t *info; io_data_entry_t *data; io_data_pin_entry_t *pin_data; const io_config_pin_entry_t *pin_config; const string_array_t *strings; int io, pin, value; io_error_t error; if(html) strings = &dump_strings.html; else strings = &dump_strings.plain; string_cat_ptr(dst, (*strings)[ds_id_header]); for(io = 0; io < io_id_size; io++) { if((io_id >= 0) && (io_id != io)) continue; info = &io_info[io]; data = &io_data[io]; string_cat_ptr(dst, (*strings)[ds_id_preline]); string_format_ptr(dst, (*strings)[ds_id_io], io, info->name, info->address); string_cat_ptr(dst, (*strings)[ds_id_postline]); if(!data->detected) { string_cat_ptr(dst, (*strings)[ds_id_preline]); string_cat_ptr(dst, (*strings)[ds_id_not_detected]); string_cat_ptr(dst, (*strings)[ds_id_postline]); continue; } for(pin = 0; pin < info->pins; pin++) { if((pin_id >= 0) && (pin_id != pin)) continue; pin_config = &cfg->io_config[io][pin]; pin_data = &data->pin[pin]; string_cat_ptr(dst, (*strings)[ds_id_preline]); string_format_ptr(dst, (*strings)[ds_id_pin], pin); string_cat_ptr(dst, (*strings)[ds_id_flags_1]); pin_string_from_flags(dst, pin_config); string_cat_ptr(dst, (*strings)[ds_id_flags_2]); string_cat_ptr(dst, (*strings)[ds_id_mode]); if((pin_config->mode != io_pin_disabled) && (pin_config->mode != io_pin_i2c) && (pin_config->mode != io_pin_uart)) if((error = io_read_pin_x(dst, info, pin_data, pin_config, pin, &value)) != io_ok) string_cat(dst, "\n"); else (void)0; else error = io_ok; switch(pin_config->mode) { case(io_pin_disabled): { string_cat_ptr(dst, (*strings)[ds_id_disabled]); break; } case(io_pin_input_digital): { if(error == io_ok) string_format_ptr(dst, (*strings)[ds_id_input], onoff(value)); else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_counter): { if(error == io_ok) string_format_ptr(dst, (*strings)[ds_id_counter], value, pin_config->speed); else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_trigger): { if(error == io_ok) { string_format_ptr(dst, (*strings)[ds_id_trigger_1], value, pin_config->speed, pin_config->shared.trigger.io.io, pin_config->shared.trigger.io.pin); trigger_type_to_string(pin_config->shared.trigger.trigger_mode, dst); string_cat_ptr(dst, (*strings)[ds_id_trigger_2]); } else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_output_digital): { if(error == io_ok) string_format_ptr(dst, (*strings)[ds_id_output], onoff(value)); else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_timer): { if(error == io_ok) string_format_ptr(dst, (*strings)[ds_id_timer], pin_config->direction == io_dir_up ? "up" : (pin_config->direction == io_dir_down ? "down" : "none"), pin_config->speed, pin_data->direction == io_dir_up ? "up" : (pin_data->direction == io_dir_down ? "down" : "none"), pin_data->speed, onoff(value)); else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_output_analog): { if(error == io_ok) string_format_ptr(dst, (*strings)[ds_id_analog_output], pin_config->shared.output_analog.lower_bound, pin_config->shared.output_analog.upper_bound, pin_config->speed, pin_data->direction == io_dir_up ? "up" : (pin_data->direction == io_dir_down ? "down" : "none"), value); else string_cat_ptr(dst, (*strings)[ds_id_error]); break; } case(io_pin_i2c): { if(pin_config->shared.i2c.pin_mode == io_i2c_sda) string_cat_ptr(dst, (*strings)[ds_id_i2c_sda]); else string_cat_ptr(dst, (*strings)[ds_id_i2c_scl]); break; } case(io_pin_uart): { string_cat_ptr(dst, (*strings)[ds_id_uart]); break; } case(io_pin_lcd): { string_cat_ptr(dst, (*strings)[ds_id_lcd]); string_cat(dst, "/"); io_string_from_lcd_mode(dst, pin_config->shared.lcd.pin_use); break; } default: { string_cat_ptr(dst, (*strings)[ds_id_unknown]); break; } } string_cat(dst, " [hw: "); io_string_from_ll_mode(dst, pin_config->llmode); string_cat(dst, "]"); if(info->get_pin_info_fn) { string_cat_ptr(dst, (*strings)[ds_id_info_1]); info->get_pin_info_fn(dst, info, pin_data, pin_config, pin); string_cat_ptr(dst, (*strings)[ds_id_info_2]); } string_cat_ptr(dst, (*strings)[ds_id_postline]); } } string_cat_ptr(dst, (*strings)[ds_id_footer]); }