void print_disk_tree (int block_nr) { struct buffer_head * bh; bh = bread (g_sb.s_dev, block_nr, g_sb.s_blocksize); if (B_IS_KEYS_LEVEL (bh)) { int i; struct disk_child * dc; g_stat_info.nr_internals ++; print_block (bh, print_mode (), -1, -1); dc = B_N_CHILD (bh, 0); for (i = 0; i <= B_NR_ITEMS (bh); i ++, dc ++) print_disk_tree (dc->dc_block_number); } else if (B_IS_ITEMS_LEVEL (bh)) { g_stat_info.nr_leaves ++; print_block (bh, print_mode (), -1, -1); } else { print_block (bh, print_mode (), -1, -1); die ("print_disk_tree: bad block type"); } brelse (bh); }
int main(int argc, char *argv[]) { SDL_DisplayMode mode; int num_displays, dpy; /* Enable standard application logging */ SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO); /* Load the SDL library */ if (SDL_Init(SDL_INIT_VIDEO) < 0) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError()); return 1; } SDL_Log("Using video target '%s'.\n", SDL_GetCurrentVideoDriver()); num_displays = SDL_GetNumVideoDisplays(); SDL_Log("See %d displays.\n", num_displays); for (dpy = 0; dpy < num_displays; dpy++) { const int num_modes = SDL_GetNumDisplayModes(dpy); SDL_Rect rect = { 0, 0, 0, 0 }; int m; SDL_GetDisplayBounds(dpy, &rect); SDL_Log("%d: \"%s\" (%dx%d, (%d, %d)), %d modes.\n", dpy, SDL_GetDisplayName(dpy), rect.w, rect.h, rect.x, rect.y, num_modes); if (SDL_GetCurrentDisplayMode(dpy, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " CURRENT: failed to query (%s)\n", SDL_GetError()); } else { print_mode("CURRENT", &mode); } if (SDL_GetDesktopDisplayMode(dpy, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " DESKTOP: failed to query (%s)\n", SDL_GetError()); } else { print_mode("DESKTOP", &mode); } for (m = 0; m < num_modes; m++) { if (SDL_GetDisplayMode(dpy, m, &mode) == -1) { SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, " MODE %d: failed to query (%s)\n", m, SDL_GetError()); } else { char prefix[64]; SDL_snprintf(prefix, sizeof (prefix), " MODE %d", m); print_mode(prefix, &mode); } } SDL_Log("\n"); } return 0; }
int8_t Rover::test_failsafe(uint8_t argc, const Menu::arg *argv) { uint8_t fail_test = 0; print_hit_enter(); for(int i = 0; i < 50; i++){ delay(20); read_radio(); } // read the radio to set trims // --------------------------- trim_radio(); oldSwitchPosition = readSwitch(); cliSerial->println("Unplug battery, throttle in neutral, turn off radio."); while(channel_throttle->get_control_in() > 0){ delay(20); read_radio(); } while(1){ delay(20); read_radio(); if(channel_throttle->get_control_in() > 0){ cliSerial->printf("THROTTLE CHANGED %d \n", channel_throttle->get_control_in()); fail_test++; } if (oldSwitchPosition != readSwitch()){ cliSerial->print("CONTROL MODE CHANGED: "); print_mode(cliSerial, readSwitch()); cliSerial->println(); fail_test++; } if(throttle_failsafe_active()) { cliSerial->printf("THROTTLE FAILSAFE ACTIVATED: %d, ", channel_throttle->get_radio_in()); print_mode(cliSerial, readSwitch()); cliSerial->println(); fail_test++; } if(fail_test > 0){ return (0); } if(cliSerial->available() > 0){ cliSerial->println("LOS caused no change in APM."); return (0); } } }
void first() { bwprintf (COM2, "I AM FIRST USER.\n\tMODE IS "); print_mode (); bwputstr (COM2, ".\n\tCREATE???\n"); //int z = Create (0xABCDEF01, (void*)0x10FEDCBA); int z = Create (3, second); int i=0,j=0,k=0; while (1) { bwprintf (COM2, "I AM FIRST USER.\n\tKERNEL SAID %d\n\tMODE IS ",z); print_mode (); bwputstr (COM2, ".\n\tPASS??\n"); i++; if (i>10) j++; if (j>10) k++; i %= 11; j %= 11; // bwprintf (COM2, "(i,j,k) = (%d,%d,%d)\n",i,j,k); Pass(); bwprintf (COM2, "I AM FIRST USER.\n\tMODE IS "); print_mode (); bwputstr (COM2, ".\n\tEXIT????\n"); Exit(); } // int i = 0xFFFFF; int r; while (i--) { bwprintf(COM2, "Hey, I'm a user(%d)!\n", i); r = swtch(i); bwprintf(COM2, "And the kernel gave me %d!\n", r); for (r = 0; r < 500000; ++r); } bwputstr (COM2, "CPU Mode: "); print_mode(); bwputstr (COM2, "\n\n"); int x = 42; int b[5]; b[0] = 0xDEADBEEF; b[1] = 0xDEADBEEF; b[2] = 0xDEADBEEF; b[3] = 0xDEADBEEF; b[4] = 0xDEADBEEF; bwprintf (COM2, "x is %d\n", x); i = 5; while (i--) { bwprintf (COM2, "b[%d] = ", i); bwputr(COM2, b[i]); bwputstr (COM2, "\n");} b[2] -= x; b[3]--; bwputstr (COM2, "now b[2] = b[2] - x and b[3] = b[3] - 1...\n"); i = 5; while (i--) { bwprintf (COM2, "b[%d] = ", i); bwputr(COM2, b[i]); bwputstr (COM2, "\n");} }
void tex::you_cant () { print_err("You can't use `"); print_cmd_chr(cur_cmd, cur_chr); print("' in "); print_mode(mode); }
int main(int argc, char *argv[]) { static const char* const sulogin_cmdline[] = {SULOGIN, NULL}; _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL; int r; log_set_target(LOG_TARGET_AUTO); log_parse_environment(); log_open(); print_mode(argc > 1 ? argv[1] : ""); (void) fork_wait(sulogin_cmdline); r = bus_connect_system_systemd(&bus); if (r < 0) { log_warning_errno(r, "Failed to get D-Bus connection: %m"); r = 0; } else { (void) reload_manager(bus); r = start_default_target(bus); } return r >= 0 ? EXIT_SUCCESS : EXIT_FAILURE; }
static void print_entry(char *prefix, const struct ipt_policy_elem *e, int numeric) { if (e->match.reqid) { PRINT_INVERT(e->invert.reqid); printf("%sreqid %u ", prefix, e->reqid); } if (e->match.spi) { PRINT_INVERT(e->invert.spi); printf("%sspi 0x%x ", prefix, e->spi); } if (e->match.proto) { PRINT_INVERT(e->invert.proto); print_proto(prefix, e->proto, numeric); } if (e->match.mode) { PRINT_INVERT(e->invert.mode); print_mode(prefix, e->mode, numeric); } if (e->match.daddr) { PRINT_INVERT(e->invert.daddr); printf("%stunnel-dst %s%s ", prefix, addr_to_dotted((struct in_addr *)&e->daddr), mask_to_dotted((struct in_addr *)&e->dmask)); } if (e->match.saddr) { PRINT_INVERT(e->invert.saddr); printf("%stunnel-src %s%s ", prefix, addr_to_dotted((struct in_addr *)&e->saddr), mask_to_dotted((struct in_addr *)&e->smask)); } }
static void msg_multi_mode(IRC_CHANNEL_REC *channel, const char *sender, const char *addr, const char *mode) { MODE_REC *rec; if (modes == NULL) signal_add("print starting", (SIGNAL_FUNC) sig_print_starting); rec = mode_find_channel(channel); if (rec != NULL && strcmp(rec->mode, mode) != 0) { /* different mode than last time, show and remove the old */ print_mode(rec); mode_destroy(rec); rec = NULL; } if (rec == NULL) { /* no previous mode, create new */ rec = g_new0(MODE_REC, 1); modes = g_slist_append(modes, rec); rec->channel = channel; rec->mode = g_strdup(mode); } rec->nicks = g_slist_append(rec->nicks, g_strdup(sender)); rec->last_mode = time(NULL); signal_stop(); }
static void hashlimit_mt_print(const struct xt_hashlimit_mtinfo1 *info, unsigned int dmask) { if (info->cfg.mode & XT_HASHLIMIT_INVERT) fputs("limit: above ", stdout); else fputs("limit: up to ", stdout); print_rate(info->cfg.avg); printf("burst %u ", info->cfg.burst); if (info->cfg.mode & (XT_HASHLIMIT_HASH_SIP | XT_HASHLIMIT_HASH_SPT | XT_HASHLIMIT_HASH_DIP | XT_HASHLIMIT_HASH_DPT)) { fputs("mode ", stdout); print_mode(info->cfg.mode, '-'); } if (info->cfg.size != 0) printf("htable-size %u ", info->cfg.size); if (info->cfg.max != 0) printf("htable-max %u ", info->cfg.max); if (info->cfg.gc_interval != XT_HASHLIMIT_GCINTERVAL) printf("htable-gcinterval %u ", info->cfg.gc_interval); if (info->cfg.expire != XT_HASHLIMIT_EXPIRE) printf("htable-expire %u ", info->cfg.expire); if (info->cfg.srcmask != dmask) printf("srcmask %u ", info->cfg.srcmask); if (info->cfg.dstmask != dmask) printf("dstmask %u ", info->cfg.dstmask); }
/* something is going to be printed to screen, print our current netsplit message before it. */ static void sig_print_starting(void) { while (modes != NULL) { print_mode(modes->data); mode_destroy(modes->data); } }
/* Saves the union ipt_targinfo in parsable form to stdout. */ static void save(const struct ipt_ip *ip, const struct ipt_entry_target *target) { struct ipt_porttrigger_info *info = (struct ipt_porttrigger_info *)(target)->data; print_mode(info->mode); /* Modification: for protocol type==all(any) can't work Modified by: ken_chiang Date:2007/8/21 */ //if( info->trigger_proto ) { printf("--trigger-proto:"); print_proto(info->trigger_proto); //} //if( info->forward_proto ) { printf("--forward-proto:"); print_proto(info->forward_proto); //} if( info->trigger_ports.ports[0]) { printf("--trigger-ports: "); print_multi_ports(info->trigger_ports); } if( info->forward_ports.ports[0] ) { printf(" --forward-ports: "); print_multi_ports(info->forward_ports); } if( info->timer >0) { printf(" --timer: %d", info->timer); } }
// Muestro primera y segunda fila (header) // tambien maneja posicion del cursor void show_header(WINDOW * win) { clr_header(win, 0); clr_header(win, 1); print_mult_pend(win); // imprimo modo print_mode(win); // imprimo texto de input #ifdef USECOLORS set_ucolor(win, &ucolors[INPUT]); #endif switch (curmode) { case COMMAND_MODE: mvwprintw(win, 0, 0 + rescol, ":%s", inputline); wmove(win, 0, inputline_pos + 1 + rescol); break; case INSERT_MODE: mvwprintw(win, 0, 1 + rescol, "%s", inputline); wmove(win, 0, inputline_pos + 1 + rescol); break; case EDIT_MODE: mvwprintw(win, 0, 0 + rescol, " %s", inputline); wmove(win, 0, inputline_pos + 1 + rescol); break; } wrefresh(win); return; }
static void hashlimit_mt_save(const struct xt_hashlimit_mtinfo1 *info, unsigned int dmask) { if (info->cfg.mode & XT_HASHLIMIT_INVERT) fputs("--hashlimit-above ", stdout); else fputs("--hashlimit-upto ", stdout); print_rate(info->cfg.avg); if (info->cfg.burst != XT_HASHLIMIT_BURST) printf("--hashlimit-burst %u ", info->cfg.burst); if (info->cfg.mode & (XT_HASHLIMIT_HASH_SIP | XT_HASHLIMIT_HASH_SPT | XT_HASHLIMIT_HASH_DIP | XT_HASHLIMIT_HASH_DPT)) { fputs("--hashlimit-mode ", stdout); print_mode(info->cfg.mode, ','); } printf("--hashlimit-name %s ", info->name); if (info->cfg.size != 0) printf("--hashlimit-htable-size %u ", info->cfg.size); if (info->cfg.max != 0) printf("--hashlimit-htable-max %u ", info->cfg.max); if (info->cfg.gc_interval != XT_HASHLIMIT_GCINTERVAL) printf("--hashlimit-htable-gcinterval %u", info->cfg.gc_interval); if (info->cfg.expire != XT_HASHLIMIT_EXPIRE) printf("--hashlimit-htable-expire %u ", info->cfg.expire); if (info->cfg.srcmask != dmask) printf("--hashlimit-srcmask %u ", info->cfg.srcmask); if (info->cfg.dstmask != dmask) printf("--hashlimit-dstmask %u ", info->cfg.dstmask); }
static void print_info(const struct iwinfo_ops *iw, const char *ifname) { printf("%-9s ESSID: %s\n", ifname, print_ssid(iw, ifname)); printf(" Access Point: %s\n", print_bssid(iw, ifname)); printf(" Type: %s HW Mode(s): %s\n", print_type(iw, ifname), print_hwmodes(iw, ifname)); printf(" Mode: %s Channel: %s (%s)\n", print_mode(iw, ifname), print_channel(iw, ifname), print_frequency(iw, ifname)); printf(" Tx-Power: %s Link Quality: %s/%s\n", print_txpower(iw, ifname), print_quality(iw, ifname), print_quality_max(iw, ifname)); printf(" Signal: %s Noise: %s\n", print_signal(iw, ifname), print_noise(iw, ifname)); printf(" Bit Rate: %s\n", print_rate(iw, ifname)); printf(" Encryption: %s\n", print_encryption(iw, ifname)); printf(" Supports VAPs: %s\n", print_mbssid_supp(iw, ifname)); }
int update_display_mode(struct display_controller *disp_ctrl, struct soc_nvidia_tegra132_config *config) { print_mode(config); printk(BIOS_ERR, "config: xres:yres: %d x %d\n ", config->xres, config->yres); printk(BIOS_ERR, " href_sync:vref_sync: %d x %d\n ", config->href_to_sync, config->vref_to_sync); printk(BIOS_ERR, " hsyn_width:vsyn_width: %d x %d\n ", config->hsync_width, config->vsync_width); printk(BIOS_ERR, " hfnt_porch:vfnt_porch: %d x %d\n ", config->hfront_porch, config->vfront_porch); printk(BIOS_ERR, " hbk_porch:vbk_porch: %d x %d\n ", config->hback_porch, config->vback_porch); WRITEL(0x0, &disp_ctrl->disp.disp_timing_opt); WRITEL(0x0, &disp_ctrl->disp.disp_color_ctrl); /* select win opt */ WRITEL(config->win_opt, &disp_ctrl->disp.disp_win_opt); WRITEL(config->vref_to_sync << 16 | config->href_to_sync, &disp_ctrl->disp.ref_to_sync); WRITEL(config->vsync_width << 16 | config->hsync_width, &disp_ctrl->disp.sync_width); WRITEL((config->vback_porch << 16) | config->hback_porch, &disp_ctrl->disp.back_porch); WRITEL((config->vfront_porch << 16) | config->hfront_porch, &disp_ctrl->disp.front_porch); WRITEL(config->xres | (config->yres << 16), &disp_ctrl->disp.disp_active); /** * We want to use PLLD_out0, which is PLLD / 2: * PixelClock = (PLLD / 2) / ShiftClockDiv / PixelClockDiv. * * Currently most panels work inside clock range 50MHz~100MHz, and PLLD * has some requirements to have VCO in range 500MHz~1000MHz (see * clock.c for more detail). To simplify calculation, we set * PixelClockDiv to 1 and ShiftClockDiv to 1. In future these values * may be calculated by clock_configure_plld(), to allow wider * frequency range. * * Note ShiftClockDiv is a 7.1 format value. */ const u32 shift_clock_div = 1; WRITEL((PIXEL_CLK_DIVIDER_PCD1 << PIXEL_CLK_DIVIDER_SHIFT) | ((shift_clock_div - 1) * 2 + 1) << SHIFT_CLK_DIVIDER_SHIFT, &disp_ctrl->disp.disp_clk_ctrl); printk(BIOS_DEBUG, "%s: PixelClock=%u, ShiftClockDiv=%u\n", __func__, config->pixel_clock, shift_clock_div); return 0; }
/* something is going to be printed to screen, print our current netsplit message before it. */ static void sig_print_starting(void) { while (modes != NULL) { print_mode(modes->data); mode_destroy(modes->data); } signal_remove("print starting", sig_print_starting); }
static void ratelimit_print(const void *ip, const struct xt_entry_match *match, int numeric) { const struct xt_ratelimit_mtinfo *info = (const void *)match->data; fputs("ratelimit:", stdout); printf(" set %s", info->name); fputs(" mode ", stdout); print_mode(info->mode); }
static void print_file_info(const struct stat *file_st, const struct print_f *format) { print_mode(file_st->st_mode, format->mode_flag); print_nlink(file_st->st_nlink, format->link_flag); print_uid(file_st->st_uid, format->id_name_flag); print_gid(file_st->st_gid, format->id_name_flag); print_size(file_st->st_size, format->size_flag); print_time(file_st, format->date_flag, format->time_form); return; }
static void ratelimit_save(const void *ip, const struct xt_entry_match *match) { const struct xt_ratelimit_mtinfo *info = (const void *)match->data; if (strcmp("DEFAULT", info->name)) printf(" --ratelimit-set %s", info->name); if (info->mode & XT_RATELIMIT_MODE) { fputs(" --ratelimit-mode ", stdout); print_mode(info->mode); } }
void draw_system(World * w) { char hp_str[32]; sprintf(hp_str, "HP:%7d", w->hero->hp); set_str((CHAR_INFO *) screen_buffer, hp_str, 62, 0, 0, 4 + 8); print_gauge(62, 1, w->hero->max_hp, w->hero->hp, 4 + 8, 4); char mp_str[32]; sprintf(mp_str, "MP:%7d", w->hero->mp); set_str((CHAR_INFO *) screen_buffer, mp_str, 62, 2, 0, 1 + 8); print_gauge(62, 3, w->hero->max_mp, w->hero->mp, 1 + 8, 1); print_mode(62, 4, w->hero); print_notice(w->hero, 0, 21); draw_examine(60, 20, w, w->hero->x, w->hero->y, w->hero); }
void Summary::print(xmrig::Controller *controller) { print_versions(controller); print_mode(controller); print_algo(controller); printPools(controller->config()); print_bind(controller); # ifndef XMRIG_NO_API print_api(controller); # endif print_commands(controller); }
void show_cur_cmd_chr() { begin_diagnostic(); print_nl("{"); if (mode != shown_mode) { print_mode(mode); print(": "); shown_mode = mode; } print_cmd_chr(cur_cmd, cur_chr); print("}"); end_diagnostic(FALSE); }
int tegra_dc_set_mode(struct tegra_dc *dc, const struct tegra_dc_mode *mode) { memcpy(&dc->mode, mode, sizeof(dc->mode)); if (dc->out->type == TEGRA_DC_OUT_RGB) panel_sync_rate = tegra_dc_calc_refresh(mode); else if (dc->out->type == TEGRA_DC_OUT_DSI) panel_sync_rate = dc->out->dsi->rated_refresh_rate * 1000; print_mode(dc, mode, __func__); dc->frametime_ns = calc_frametime_ns(mode); return 0; }
void init() { freenect_context *ctx; freenect_device *dev; if (freenect_init(&ctx, 0)) { printf("Error: Cannot get context\n"); return; } // fakenect doesn't support audio yet, so don't bother claiming the device freenect_select_subdevices(ctx, (freenect_device_flags)(FREENECT_DEVICE_MOTOR | FREENECT_DEVICE_CAMERA)); if (freenect_open_device(ctx, &dev, 0)) { printf("Error: Cannot get device\n"); return; } print_mode("Depth", freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT)); print_mode("Video", freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB)); freenect_set_depth_mode(dev, freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT)); freenect_start_depth(dev); freenect_set_video_mode(dev, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB)); freenect_start_video(dev); if (use_ffmpeg) { init_ffmpeg_streams(); freenect_set_depth_callback(dev, depth_cb_ffmpeg); freenect_set_video_callback(dev, rgb_cb_ffmpeg); } else { freenect_set_depth_callback(dev, depth_cb); freenect_set_video_callback(dev, rgb_cb); } while (running && freenect_process_events(ctx) >= 0) snapshot_accel(dev); freenect_stop_depth(dev); freenect_stop_video(dev); freenect_close_device(dev); freenect_shutdown(ctx); }
void fb_io_device::init (int width, int height, int mode) { m_width = width; m_height = height; m_mode = mode; DPRINTF ("init() %d %d %d\n", width, height, mode); switch(m_mode) { case NONE: EPRINTF("Mode not set\n"); break; case GREY: m_buf_size = height * width; break; case RGB: case BGR: m_buf_size = 3 * height * width; break; case ARGB: case BGRA: m_buf_size = 4 * height * width; break; case YVYU: /* YUV 4:2:2 */ case YV16: m_buf_size = 3 * height * width; break; case YV12: /* YUV 4:2:0 */ case IYUV: /* YUV 4:2:0 */ m_buf_size = 3 * height * width; break; default: EPRINTF ("Bad mode\n"); } DPRINTF ("new framebuffer: %dx%d mode: %s\n", width, height, print_mode(mode)); DPRINTF (" buf_size: [%dB--0x%xB]\n", m_buf_size, m_buf_size); if (nb_fb == 0) atexit (close_ramdacs); init_viewer (); m_io_res->mem = m_shm_buf; m_io_res->mem_size = m_buf_size; m_regs->m_status = FB_IO_RUNNING; }
void AircraftSim::update_mode() { const ElementStat stat = task_manager.get_stats().current_leg; switch (acstate) { case Cruise: if ((awp>0) && (task_manager.get_stats().total.solution_remaining.DistanceToFinal<= state.Speed)) { print_mode("# mode fg\n"); acstate = FinalGlide; } else { if (state.NavAltitude<=target_height()) { print_mode("# mode climb\n"); acstate = Climb; } } break; case FinalGlide: if (task_manager.get_stats().total.solution_remaining.AltitudeDifference<-fixed_20) { print_mode("# mode climb\n"); acstate = Climb; } break; case Climb: if ((awp>0) && (task_manager.get_stats().total.solution_remaining.DistanceToFinal<= state.Speed)) { print_mode("# mode fg\n"); acstate = FinalGlide; } else if (state.NavAltitude>=fixed_1500) { acstate = Cruise; print_mode("# mode cruise\n"); } break; }; }
/* * Check options and call the proper handler */ static int print_one_device(int skfd, int format, int wtype, const char* ifname) { int ret; /* Check wtype */ switch(wtype) { case WTYPE_AP: /* Try to print an AP */ ret = print_ap(skfd, ifname, format); break; case WTYPE_CHANNEL: /* Try to print channel */ ret = print_channel(skfd, ifname, format); break; case WTYPE_FREQ: /* Try to print frequency */ ret = print_freq(skfd, ifname, format); break; case WTYPE_MODE: /* Try to print the mode */ ret = print_mode(skfd, ifname, format); break; case WTYPE_PROTO: /* Try to print the protocol */ ret = print_protocol(skfd, ifname, format); break; default: /* Try to print an ESSID */ ret = print_essid(skfd, ifname, format); if(ret < 0) { /* Try to print a nwid */ ret = print_nwid(skfd, ifname, format); } } return(ret); }
void print_crtc(Crtc& cc, int ind) { printf("%sCRTC Id %d BufferId %d %dx%d at %dx%d gamma_size %d\n", width(ind, "").c_str(), cc.id(), cc.buffer_id(), cc.width(), cc.height(), cc.x(), cc.y(), cc.gamma_size()); printf("%s Mode ", width(ind, "").c_str()); print_mode(cc.mode(), 0); if (opts.print_props) print_properties(cc, ind+2); if (opts.recurse) for (auto p : cc.get_possible_planes()) print_plane(*p, ind + 2); }
void print(struct dirent *dir, struct stat *stbuf, int depth) { if (dir->d_name[0] == '.') return; for (int i = 0; i < depth*4; i++) printf(" "); if (l == 1) { print_mode(stbuf->st_mode); printf("%d ", (int)stbuf->st_nlink); printf("%s ", getpwuid(stbuf->st_uid)->pw_name); printf("%s ", getgrgid(stbuf->st_gid)->gr_name); printf("%.12s ", 4 + ctime(&(stbuf->st_mtime))); printf("%ld ", (long) stbuf->st_size); } printf("%s\n", dir->d_name); return; }
int update_display_mode(struct display_controller *disp_ctrl, struct soc_nvidia_tegra132_config *config) { print_mode(config); printk(BIOS_ERR, "config: xres:yres: %d x %d\n ", config->xres, config->yres); printk(BIOS_ERR, " href_sync:vref_sync: %d x %d\n ", config->href_to_sync, config->vref_to_sync); printk(BIOS_ERR, " hsyn_width:vsyn_width: %d x %d\n ", config->hsync_width, config->vsync_width); printk(BIOS_ERR, " hfnt_porch:vfnt_porch: %d x %d\n ", config->hfront_porch, config->vfront_porch); printk(BIOS_ERR, " hbk_porch:vbk_porch: %d x %d\n ", config->hback_porch, config->vback_porch); WRITEL(0x0, &disp_ctrl->disp.disp_timing_opt); WRITEL(0x0, &disp_ctrl->disp.disp_color_ctrl); /* select win opt */ WRITEL(config->win_opt, &disp_ctrl->disp.disp_win_opt); WRITEL(config->vref_to_sync << 16 | config->href_to_sync, &disp_ctrl->disp.ref_to_sync); WRITEL(config->vsync_width << 16 | config->hsync_width, &disp_ctrl->disp.sync_width); WRITEL((config->vback_porch << 16) | config->hback_porch, &disp_ctrl->disp.back_porch); WRITEL((config->vfront_porch << 16) | config->hfront_porch, &disp_ctrl->disp.front_porch); WRITEL(config->xres | (config->yres << 16), &disp_ctrl->disp.disp_active); /* * PixelClock = (PLLD / 2) / ShiftClockDiv / PixelClockDiv. * * default: Set both shift_clk_div and pixel_clock_div to 1 */ update_display_shift_clock_divider(disp_ctrl, SHIFT_CLK_DIVIDER(1)); return 0; }