static void wcd_clsh_state_ear(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (mode != CLS_H_NORMAL) { dev_err(codec->dev, "%s: mode: %s cannot be used for EAR\n", __func__, mode_to_str(mode)); return; } if (is_enable) { wcd_enable_clsh_block(codec, clsh_d, true); snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x40); wcd_clsh_set_buck_mode(codec, mode); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true); wcd_clsh_set_flyback_current(codec, mode); wcd_clsh_buck_ctrl(codec, clsh_d, mode, true); } else { snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x00); wcd_enable_clsh_block(codec, clsh_d, false); wcd_clsh_buck_ctrl(codec, clsh_d, mode, false); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, false); wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL); } }
/* * Open the device with the operating system and * initialize buffer pointers. * * Returns: true on success * false on error * * Note, for a tape, the VolName is the name we give to the * volume (not really used here), but for a file, the * VolName represents the name of the file to be created/opened. * In the case of a file, the full name is the device name * (archive_name) with the VolName concatenated. */ bool DEVICE::open(DCR *dcr, int omode) { char preserve[ST_BYTES]; clear_all_bits(ST_MAX, preserve); if (is_open()) { if (open_mode == omode) { return true; } else { d_close(m_fd); clear_opened(); Dmsg0(100, "Close fd for mode change.\n"); if (bit_is_set(ST_LABEL, state)) set_bit(ST_LABEL, preserve); if (bit_is_set(ST_APPENDREADY, state)) set_bit(ST_APPENDREADY, preserve); if (bit_is_set(ST_READREADY, state)) set_bit(ST_READREADY, preserve); } } if (dcr) { dcr->setVolCatName(dcr->VolumeName); VolCatInfo = dcr->VolCatInfo; /* structure assign */ } Dmsg4(100, "open dev: type=%d dev_name=%s vol=%s mode=%s\n", dev_type, print_name(), getVolCatName(), mode_to_str(omode)); clear_bit(ST_LABEL, state); clear_bit(ST_APPENDREADY, state); clear_bit(ST_READREADY, state); clear_bit(ST_EOT, state); clear_bit(ST_WEOT, state); clear_bit(ST_EOF, state); label_type = B_BAREOS_LABEL; /* * We are about to open the device so let any plugin know we are. */ if (dcr && generate_plugin_event(dcr->jcr, bsdEventDeviceOpen, dcr) != bRC_OK) { Dmsg0(100, "open_dev: bsdEventDeviceOpen failed\n"); return false; } Dmsg1(100, "call open_device mode=%s\n", mode_to_str(omode)); open_device(dcr, omode); /* * Reset any important state info */ clone_bits(ST_MAX, preserve, state); Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd); return m_fd >= 0; }
/* * Open a file device. For Aligned type we open both Volumes */ void DEVICE::open_file_device(DCR *dcr, int omode) { POOL_MEM archive_name(PM_FNAME); POOL_MEM aligned_name(PM_FNAME); get_autochanger_loaded_slot(dcr); /* * Handle opening of File Archive (not a tape) */ pm_strcpy(archive_name, dev_name); /* * If this is a virtual autochanger (i.e. changer_res != NULL) * we simply use the device name, assuming it has been * appropriately setup by the "autochanger". */ if (!device->changer_res || device->changer_command[0] == 0 || strcmp(device->changer_command, "/dev/null") == 0) { if (VolCatInfo.VolCatName[0] == 0) { Mmsg(errmsg, _("Could not open file device %s. No Volume name given.\n"), print_name()); clear_opened(); return; } if (!IsPathSeparator(archive_name.c_str()[strlen(archive_name.c_str())-1])) { pm_strcat(archive_name, "/"); } pm_strcat(archive_name, getVolCatName()); } mount(1); /* do mount if required */ openmode = omode; set_mode(omode); /* If creating file, give 0640 permissions */ Dmsg3(100, "open disk: mode=%s open(%s, 0x%x, 0640)\n", mode_to_str(omode), archive_name.c_str(), mode); /* Use system open() */ if ((m_fd = ::open(archive_name.c_str(), mode, 0640)) < 0) { berrno be; dev_errno = errno; Mmsg3(errmsg, _("Could not open(%s,%s,0640): ERR=%s\n"), archive_name.c_str(), mode_to_str(omode), be.bstrerror()); Dmsg1(40, "open failed: %s", errmsg); } if (m_fd >= 0) { dev_errno = 0; file = 0; file_addr = 0; } Dmsg1(100, "open dev: disk fd=%d opened\n", m_fd); }
int main(int argc,char **argv) { DIR * dir; struct dirent *mydir; struct stat mystat; char str[256]; char str_mode[11]; char *p_time; if(argc==1) { dir=opendir("./"); } else dir=opendir(argv[1]); while((mydir=readdir(dir))!=NULL) { memset(&mystat,0,sizeof(mystat)); memset(str,0,256); memset(str_mode,0,11); if(argv[1]) sprintf(str,"%s%s",argv[1],mydir->d_name); else sprintf(str,"%s%s","./",mydir->d_name); stat(str,&mystat); mode_to_str(mystat.st_mode,str_mode); p_time=ctime(&mystat.st_atime); time_pro(p_time); printf("%s %d %s %s %d %d %s %s\n ",str_mode,mystat.st_nlink,getpwuid(mystat.st_uid)->pw_name,getgrgid(mystat.st_gid)->gr_name,mystat.st_size,mystat.st_blocks,p_time+4,mydir->d_name ); } return 0; }
static void wcd_clsh_state_hph_st(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (mode == CLS_AB) return; if (is_enable) { if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x40); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x40); } else { if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x00); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x00); } }
static void wcd_clsh_state_lo(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (mode != CLS_AB) { dev_err(codec->dev, "%s: LO cannot be in this mode: %d\n", __func__, mode); return; } if (is_enable) { wcd_clsh_set_buck_regulator_mode(codec, mode); wcd_clsh_set_buck_mode(codec, mode); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true); wcd_clsh_set_flyback_current(codec, mode); wcd_clsh_buck_ctrl(codec, clsh_d, mode, true); } else { wcd_clsh_buck_ctrl(codec, clsh_d, mode, false); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, false); wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_regulator_mode(codec, CLS_H_NORMAL); } }
static void wcd_clsh_state_hph_l(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (mode == CLS_H_NORMAL) { dev_err(codec->dev, "%s: Normal mode not applicable for hph_l\n", __func__); return; } if (is_enable) { if (mode != CLS_AB) { wcd_enable_clsh_block(codec, clsh_d, true); /* * These K1 values depend on the Headphone Impedance * For now it is assumed to be 16 ohm */ snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_MSB, 0x0F, 0x00); snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_LSB, 0xFF, 0xC0); snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x40); } wcd_clsh_set_buck_regulator_mode(codec, mode); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true); wcd_clsh_set_flyback_current(codec, mode); wcd_clsh_set_buck_mode(codec, mode); wcd_clsh_buck_ctrl(codec, clsh_d, mode, true); wcd_clsh_set_hph_mode(codec, mode); wcd_clsh_set_gain_path(codec, mode); } else { wcd_clsh_set_hph_mode(codec, CLS_H_NORMAL); if (mode != CLS_AB) { snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x00); wcd_enable_clsh_block(codec, clsh_d, false); } /* set buck and flyback to Default Mode */ wcd_clsh_buck_ctrl(codec, clsh_d, CLS_H_NORMAL, false); wcd_clsh_flyback_ctrl(codec, clsh_d, CLS_H_NORMAL, false); wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_regulator_mode(codec, CLS_H_NORMAL); } }
static void wcd_clsh_flyback_ctrl(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, int mode, bool enable) { struct wcd9xxx *wcd9xxx = dev_get_drvdata(codec->dev->parent); struct wcd9xxx_reg_val bulk_reg[2]; u8 vneg[] = {0x00, 0x40}; /* enable/disable flyback */ if ((enable && (++clsh_d->flyback_users == 1)) || (!enable && (--clsh_d->flyback_users == 0))) { snd_soc_update_bits(codec, WCD9XXX_A_ANA_RX_SUPPLIES, (1 << 6), (enable << 6)); /* 100usec delay is needed as per HW requirement */ usleep_range(100, 110); if (enable && (TASHA_IS_1_1(wcd9xxx->version))) { wcd_clsh_set_flyback_mode(codec, CLS_H_HIFI); snd_soc_update_bits(codec, WCD9XXX_FLYBACK_EN, 0x60, 0x40); snd_soc_update_bits(codec, WCD9XXX_FLYBACK_EN, 0x10, 0x10); vneg[0] = snd_soc_read(codec, WCD9XXX_A_ANA_RX_SUPPLIES); vneg[0] &= ~(0x40); vneg[1] = vneg[0] | 0x40; bulk_reg[0].reg = WCD9XXX_A_ANA_RX_SUPPLIES; bulk_reg[0].buf = &vneg[0]; bulk_reg[0].bytes = 1; bulk_reg[1].reg = WCD9XXX_A_ANA_RX_SUPPLIES; bulk_reg[1].buf = &vneg[1]; bulk_reg[1].bytes = 1; /* 500usec delay is needed as per HW requirement */ usleep_range(500, 510); wcd9xxx_slim_bulk_write(wcd9xxx, bulk_reg, 2, false); snd_soc_update_bits(codec, WCD9XXX_FLYBACK_EN, 0x10, 0x00); wcd_clsh_set_flyback_mode(codec, mode); } } dev_dbg(codec->dev, "%s: flyback_users %d, enable %d, mode: %s", __func__, clsh_d->flyback_users, enable, mode_to_str(mode)); /* * 500us sleep is required after flyback enable/disable * as per HW requirement */ usleep_range(500, 500 + WCD_USLEEP_RANGE); }
/* * Open the device with the operating system and * initialize buffer pointers. * * Returns: true on success * false on error * * Note, for a tape, the VolName is the name we give to the * volume (not really used here), but for a file, the * VolName represents the name of the file to be created/opened. * In the case of a file, the full name is the device name * (archive_name) with the VolName concatenated. */ bool DEVICE::open(DCR *dcr, int omode) { int preserve = 0; if (is_open()) { if (openmode == omode) { return true; } else { Dmsg1(200, "Close fd=%d for mode change in open().\n", m_fd); d_close(m_fd); clear_opened(); preserve = state & (ST_LABEL|ST_APPEND|ST_READ); } } if (dcr) { dcr->setVolCatName(dcr->VolumeName); VolCatInfo = dcr->VolCatInfo; /* structure assign */ } state &= ~(ST_NOSPACE|ST_LABEL|ST_APPEND|ST_READ|ST_EOT|ST_WEOT|ST_EOF); label_type = B_BACULA_LABEL; if (is_tape() || is_fifo()) { open_tape_device(dcr, omode); } else if (is_ftp()) { open_device(dcr, omode); } else { Dmsg1(100, "call open_file_device mode=%s\n", mode_to_str(omode)); open_file_device(dcr, omode); } state |= preserve; /* reset any important state info */ Dmsg2(100, "preserve=0x%x fd=%d\n", preserve, m_fd); Dmsg7(100, "open dev: fd=%d dev=%p dcr=%p vol=%s type=%d dev_name=%s mode=%s\n", m_fd, getVolCatName(), this, dcr, dev_type, print_name(), mode_to_str(omode)); return m_fd >= 0; }
static void wcd_clsh_buck_ctrl(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, int mode, bool enable) { /* enable/disable buck */ if ((enable && (++clsh_d->buck_users == 1)) || (!enable && (--clsh_d->buck_users == 0))) snd_soc_update_bits(codec, WCD9XXX_A_ANA_RX_SUPPLIES, (1 << 7), (enable << 7)); dev_dbg(codec->dev, "%s: buck_users %d, enable %d, mode: %s", __func__, clsh_d->buck_users, enable, mode_to_str(mode)); /* * 500us sleep is required after buck enable/disable * as per HW requirement */ usleep_range(500, 500 + WCD_USLEEP_RANGE); }
int main(int argc, char* argv[]) { struct stat my_stat ; memset(&my_stat, 0, sizeof(my_stat)); char buf[11] ; if(-1 == stat(argv[1], &my_stat)) { perror("stat"); exit(1); } printf("mode: %04x\nlink: %u\nuid: %u\ngid: %u\nsize:%u\nmtime:%u\n",my_stat.st_mode, my_stat.st_nlink, my_stat.st_uid, my_stat.st_gid, my_stat.st_size, my_stat.st_mtime ); mode_to_str(my_stat.st_mode, buf); puts(buf); printf("%s %s\n", getpwuid(my_stat.st_uid) -> pw_name, getgrgid(my_stat.st_gid) ->gr_name); printf("%s\n", ctime(&my_stat.st_mtime)); return 0 ; }
/** * Common initialization function for RpFile's constructors. * Filename must be set in m_filename. */ void RpFile::init(void) { const mode_str_t *mode_str = mode_to_str(m_mode); if (!mode_str) { m_lastError = EINVAL; return; } // TODO: On Windows, prepend "\\\\?\\" for super-long filenames? #if defined(_WIN32) // Windows: Use RP2W_s() to convert the filename to wchar_t. // If this is an absolute path, make sure it starts with // "\\?\" in order to support filenames longer than MAX_PATH. wstring filenameW; if (m_filename.size() > 3 && isascii(m_filename[0]) && isalpha(m_filename[0]) && m_filename[1] == ':' && m_filename[2] == '\\') { // Absolute path. Prepend "\\?\" to the path. filenameW = L"\\\\?\\"; filenameW += RP2W_s(m_filename); } else { // Not an absolute path, or "\\?\" is already // prepended. Use it as-is. filenameW = RP2W_s(m_filename); } m_file.reset(_wfopen(filenameW.c_str(), mode_str), myFile_deleter()); #else /* !_WIN32 */ // Linux: Use UTF-8 filenames directly. m_file.reset(fopen(m_filename.c_str(), mode_str), myFile_deleter()); #endif /* _WIN32 */ if (!m_file) { // An error occurred while opening the file. m_lastError = errno; } }
int main(int argc, char* argv[]) { DIR* pDir ; char* ptm ; struct stat mystat ; struct dirent* myent; char str_mode[11]=""; int col = 0 ; if(argc == 1) { pDir = opendir("."); }else { pDir = opendir(argv[1]); } if(pDir == NULL) { perror("open dir fail: "); exit(-1); } printf("nlink,mode,uid,gid,size,atime,name\n"); while( (myent = readdir(pDir) ) != NULL ) { memset(&mystat, 0, sizeof(mystat)); stat(myent ->d_name, &mystat); memset(str_mode,0, 11); mode_to_str(mystat.st_mode,str_mode); ptm = ctime(&mystat.st_atime); format(ptm); if(strncmp(myent ->d_name, ".",1) !=0 && strncmp(myent->d_name,"..",2)!=0) { printf("%10s.%2d %-5s %-5s %5d %s %s\n",str_mode,mystat.st_nlink,getpwuid(mystat.st_uid)->pw_name,getgrgid(mystat.st_gid)->gr_name,mystat.st_size,ptm+4,myent ->d_name); } } printf("\n"); return 0 ; }
static void wcd_clsh_state_ear_lo(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (is_enable && (req_state == WCD_CLSH_STATE_LO)) { wcd_clsh_set_buck_regulator_mode(codec, CLS_AB); } else { if (req_state == WCD_CLSH_STATE_EAR) goto end; /* LO powerdown. * If EAR Class-H is already enabled, just * turn on regulator other enable Class-H * configuration */ if (wcd_clsh_enable_status(codec)) { wcd_clsh_set_buck_regulator_mode(codec, CLS_H_NORMAL); goto end; } wcd_enable_clsh_block(codec, clsh_d, true); snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x40); wcd_clsh_set_buck_regulator_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, mode); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_flyback_ctrl(codec, clsh_d, mode, true); wcd_clsh_buck_ctrl(codec, clsh_d, mode, true); } end: return; }
int main(int argc, char* argv[]) { int i = 0; int opt = 0; int action = 0; unsigned long long ecid = 0; int mode = -1; char* argument = NULL; irecv_error_t error = 0; char* buffer = NULL; uint64_t buffer_length = 0; if (argc == 1) { print_usage(argc, argv); return 0; } while ((opt = getopt(argc, argv, "i:vhrsmnc:f:e:k::")) > 0) { switch (opt) { case 'i': if (optarg) { char* tail = NULL; ecid = strtoull(optarg, &tail, 16); if (tail && (tail[0] != '\0')) { ecid = 0; } if (ecid == 0) { fprintf(stderr, "ERROR: Could not parse ECID from argument '%s'\n", optarg); return -1; } } break; case 'v': verbose += 1; break; case 'h': print_usage(argc, argv); return 0; case 'm': action = kShowMode; break; case 'n': action = kRebootToNormalMode; break; case 'r': action = kResetDevice; break; case 's': action = kStartShell; break; case 'f': action = kSendFile; argument = optarg; break; case 'c': action = kSendCommand; argument = optarg; break; case 'k': action = kSendExploit; argument = optarg; break; case 'e': action = kSendScript; argument = optarg; break; default: fprintf(stderr, "Unknown argument\n"); return -1; } } if (verbose) irecv_set_debug_level(verbose); irecv_init(); irecv_client_t client = NULL; for (i = 0; i <= 5; i++) { debug("Attempting to connect... \n"); if (irecv_open_with_ecid(&client, ecid) != IRECV_E_SUCCESS) sleep(1); else break; if (i == 5) { return -1; } } irecv_device_t device = NULL; irecv_devices_get_device_by_client(client, &device); if (device) debug("Connected to %s, model %s, cpid 0x%04x, bdid 0x%02x\n", device->product_type, device->hardware_model, device->chip_id, device->board_id); switch (action) { case kResetDevice: irecv_reset(client); break; case kSendFile: irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 1); debug("%s\n", irecv_strerror(error)); break; case kSendCommand: error = irecv_send_command(client, argument); debug("%s\n", irecv_strerror(error)); break; case kSendExploit: if (argument != NULL) { irecv_event_subscribe(client, IRECV_PROGRESS, &progress_cb, NULL); error = irecv_send_file(client, argument, 0); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } } error = irecv_trigger_limera1n_exploit(client); debug("%s\n", irecv_strerror(error)); break; case kStartShell: init_shell(client); break; case kSendScript: buffer_read_from_filename(argument, &buffer, &buffer_length); if (buffer) { buffer[buffer_length] = '\0'; error = irecv_execute_script(client, buffer); if(error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); } free(buffer); } else { fprintf(stderr, "Could not read file '%s'\n", argument); } break; case kShowMode: irecv_get_mode(client, &mode); printf("%s Mode\n", mode_to_str(mode)); break; case kRebootToNormalMode: error = irecv_setenv(client, "auto-boot", "true"); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } error = irecv_saveenv(client); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); break; } error = irecv_reboot(client); if (error != IRECV_E_SUCCESS) { debug("%s\n", irecv_strerror(error)); } else { debug("%s\n", irecv_strerror(error)); } break; default: fprintf(stderr, "Unknown action\n"); break; } irecv_close(client); return 0; }
static void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) { char* cmd = strdup((char*)command); char* action = strtok(cmd, " "); if (!strcmp(cmd, "/exit")) { quit = 1; } else if (!strcmp(cmd, "/help")) { shell_usage(); } else if (!strcmp(cmd, "/upload")) { char* filename = strtok(NULL, " "); debug("Uploading file %s\n", filename); if (filename != NULL) { irecv_send_file(client, filename, 0); } } else if (!strcmp(cmd, "/deviceinfo")) { int ret, mode; const struct irecv_device_info *devinfo = irecv_get_device_info(client); if (devinfo) { printf("CPID: %04x\n", devinfo->cpid); printf("CPRV: %02x\n", devinfo->cprv); printf("BDID: %02x\n", devinfo->bdid); printf("ECID: " _FMT_lld "\n", devinfo->ecid); printf("CPFM: %02x\n", devinfo->cpfm); printf("SCEP: %02x\n", devinfo->scep); printf("IBFL: %02x\n", devinfo->ibfl); printf("SRNM: %s\n", (devinfo->srnm) ? devinfo->srnm : "N/A"); printf("IMEI: %s\n", (devinfo->imei) ? devinfo->imei : "N/A"); } else { printf("Could not get device info?!\n"); } ret = irecv_get_mode(client, &mode); if (ret == IRECV_E_SUCCESS) { printf("MODE: %s\n", mode_to_str(mode)); } } else if (!strcmp(cmd, "/limera1n")) { char* filename = strtok(NULL, " "); debug("Sending limera1n payload %s\n", filename); if (filename != NULL) { irecv_send_file(client, filename, 0); } irecv_trigger_limera1n_exploit(client); } else if (!strcmp(cmd, "/execute")) { char* filename = strtok(NULL, " "); debug("Executing script %s\n", filename); if (filename != NULL) { char* buffer = NULL; uint64_t buffer_length = 0; buffer_read_from_filename(filename, &buffer, &buffer_length); if (buffer) { buffer[buffer_length] = '\0'; irecv_execute_script(client, buffer); free(buffer); } else { printf("Could not read file '%s'\n", filename); } } } else { printf("Unsupported command %s. Use /help to get a list of available commands.\n", cmd); } free(action); }
/* * Open a fifo device */ void win32_fifo_device::open_device(DCR *dcr, int omode) { file_size = 0; int timeout = max_open_wait; utime_t start_time = time(NULL); mount(dcr, 1); /* do mount if required */ Dmsg0(100, "Open dev: device is fifo\n"); get_autochanger_loaded_slot(dcr); open_mode = omode; set_mode(omode); if (timeout < 1) { timeout = 1; } errno = 0; if (timeout) { /* * Set open timer */ tid = start_thread_timer(dcr->jcr, pthread_self(), timeout); } Dmsg2(100, "Try open %s mode=%s\n", prt_name, mode_to_str(omode)); /* * If busy retry each second for max_open_wait seconds */ for ( ;; ) { /* * Try non-blocking open */ m_fd = d_open(dev_name, oflags | O_NONBLOCK, 0); if (m_fd < 0) { berrno be; dev_errno = errno; Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n", prt_name, omode, oflags, errno, be.bstrerror()); } else { d_close(m_fd); m_fd = d_open(dev_name, oflags, 0); /* open normally */ if (m_fd < 0) { berrno be; dev_errno = errno; Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n", prt_name, omode, oflags, errno, be.bstrerror()); break; } dev_errno = 0; lock_door(); break; /* Successfully opened and rewound */ } bmicrosleep(5, 0); /* * Exceed wait time ? */ if (time(NULL) - start_time >= max_open_wait) { break; /* yes, get out */ } } if (!is_open()) { berrno be; Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"), prt_name, be.bstrerror(dev_errno)); Dmsg1(100, "%s", errmsg); } /* * Stop any open() timer we started */ if (tid) { stop_thread_timer(tid); tid = 0; } Dmsg1(100, "open dev: fifo %d opened\n", m_fd); }
static void wcd_clsh_state_hph_lo(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { int hph_mode; dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (is_enable) { /* * If requested state is LO, put regulator * in class-AB or if requested state is HPH, * which means LO is already enabled, keep * the regulator config the same at class-AB * and just set the power modes for flyback * and buck. */ if (req_state == WCD_CLSH_STATE_LO) wcd_clsh_set_buck_regulator_mode(codec, CLS_AB); else { if (!wcd_clsh_enable_status(codec)) { wcd_enable_clsh_block(codec, clsh_d, true); snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_MSB, 0x0F, 0x00); snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_LSB, 0xFF, 0xC0); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_set_buck_mode(codec, mode); wcd_clsh_set_hph_mode(codec, mode); wcd_clsh_set_gain_path(codec, mode); } else { dev_dbg(codec->dev, "%s:clsh is already enabled\n", __func__); } if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x40); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x40); } } else { if ((req_state == WCD_CLSH_STATE_HPHL) || (req_state == WCD_CLSH_STATE_HPHR)) { if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x00); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x00); /* * If HPH is powering down first, then disable clsh, * set the buck/flyback mode to default and keep the * regulator at Class-AB */ if ((clsh_d->state & WCD_CLSH_STATE_HPH_ST) != WCD_CLSH_STATE_HPH_ST) { wcd_enable_clsh_block(codec, clsh_d, false); wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL); } } else { /* LO powerdown. * If HPH mode also is CLS-AB, no need * to turn-on class-H, otherwise enable * Class-H configuration. */ if (clsh_d->state & WCD_CLSH_STATE_HPHL) hph_mode = wcd_clsh_get_int_mode(clsh_d, WCD_CLSH_STATE_HPHL); else if (clsh_d->state & WCD_CLSH_STATE_HPHR) hph_mode = wcd_clsh_get_int_mode(clsh_d, WCD_CLSH_STATE_HPHR); dev_dbg(codec->dev, "%s: hph_mode = %d\n", __func__, hph_mode); if ((hph_mode == CLS_AB) || (hph_mode == CLS_NONE)) goto end; /* * If Class-H is already enabled (HPH ON and then * LO ON), no need to turn on again, just set the * regulator mode. */ if (wcd_clsh_enable_status(codec)) { wcd_clsh_set_buck_regulator_mode(codec, hph_mode); goto end; } else { dev_dbg(codec->dev, "%s: clsh is not enabled\n", __func__); } wcd_enable_clsh_block(codec, clsh_d, true); snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_MSB, 0x0F, 0x00); snd_soc_update_bits(codec, WCD9XXX_A_CDC_CLSH_K1_LSB, 0xFF, 0xC0); wcd_clsh_set_buck_regulator_mode(codec, hph_mode); if (clsh_d->state & WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x40); if (clsh_d->state & WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x40); wcd_clsh_set_hph_mode(codec, hph_mode); } } end: return; }
static void wcd_clsh_state_hph_ear(struct snd_soc_codec *codec, struct wcd_clsh_cdc_data *clsh_d, u8 req_state, bool is_enable, int mode) { int hph_mode; dev_dbg(codec->dev, "%s: mode: %s, %s\n", __func__, mode_to_str(mode), is_enable ? "enable" : "disable"); if (is_enable) { if (req_state == WCD_CLSH_STATE_EAR) { /* If HPH is running in CLS-AB when * EAR comes, let it continue to run * in Class-AB, no need to enable Class-H * for EAR. */ if (clsh_d->state & WCD_CLSH_STATE_HPHL) hph_mode = wcd_clsh_get_int_mode(clsh_d, WCD_CLSH_STATE_HPHL); else if (clsh_d->state & WCD_CLSH_STATE_HPHR) hph_mode = wcd_clsh_get_int_mode(clsh_d, WCD_CLSH_STATE_HPHR); if (hph_mode != CLS_AB) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x40); } if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x40); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x40); if ((req_state == WCD_CLSH_STATE_HPHL) || (req_state == WCD_CLSH_STATE_HPHR)) { wcd_clsh_set_gain_path(codec, mode); wcd_clsh_set_flyback_mode(codec, mode); wcd_clsh_set_buck_mode(codec, mode); } } else { if (req_state == WCD_CLSH_STATE_EAR) { /* * If EAR goes away, disable EAR Channel Enable * if HPH running in Class-H otherwise * and if HPH requested mode is CLS_AB then * no need to disable EAR channel enable bit. */ if (wcd_clsh_enable_status(codec)) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x00); } if (req_state == WCD_CLSH_STATE_HPHL) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX1_RX_PATH_CFG0, 0x40, 0x00); if (req_state == WCD_CLSH_STATE_HPHR) snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX2_RX_PATH_CFG0, 0x40, 0x00); if ((req_state & WCD_CLSH_STATE_HPH_ST) && !wcd_clsh_enable_status(codec)) { /* If Class-H is not enabled when HPH is turned * off, enable it as EAR is in progress */ wcd_enable_clsh_block(codec, clsh_d, true); snd_soc_update_bits(codec, WCD9XXX_A_CDC_RX0_RX_PATH_CFG0, 0x40, 0x40); wcd_clsh_set_flyback_mode(codec, CLS_H_NORMAL); wcd_clsh_set_buck_mode(codec, CLS_H_NORMAL); } } }
/* * Open a tape device */ void generic_tape_device::open_device(DCR *dcr, int omode) { file_size = 0; int timeout = max_open_wait; #if !defined(HAVE_WIN32) struct mtop mt_com; utime_t start_time = time(NULL); #endif mount(dcr, 1); /* do mount if required */ Dmsg0(100, "Open dev: device is tape\n"); get_autochanger_loaded_slot(dcr); open_mode = omode; set_mode(omode); if (timeout < 1) { timeout = 1; } errno = 0; Dmsg2(100, "Try open %s mode=%s\n", prt_name, mode_to_str(omode)); #if defined(HAVE_WIN32) /* * Windows Code */ if ((m_fd = d_open(dev_name, oflags, 0)) < 0) { dev_errno = errno; } #else /* * UNIX Code * * If busy retry each second for max_open_wait seconds */ for ( ;; ) { /* * Try non-blocking open */ m_fd = d_open(dev_name, oflags | O_NONBLOCK, 0); if (m_fd < 0) { berrno be; dev_errno = errno; Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n", prt_name, omode, oflags, errno, be.bstrerror()); } else { /* * Tape open, now rewind it */ Dmsg0(100, "Rewind after open\n"); mt_com.mt_op = MTREW; mt_com.mt_count = 1; /* * Rewind only if dev is a tape */ if (d_ioctl(m_fd, MTIOCTOP, (char *)&mt_com) < 0) { berrno be; dev_errno = errno; /* set error status from rewind */ d_close(m_fd); clear_opened(); Dmsg2(100, "Rewind error on %s close: ERR=%s\n", prt_name, be.bstrerror(dev_errno)); /* * If we get busy, device is probably rewinding, try again */ if (dev_errno != EBUSY) { break; /* error -- no medium */ } } else { /* * Got fd and rewind worked, so we must have medium in drive */ d_close(m_fd); m_fd = d_open(dev_name, oflags, 0); /* open normally */ if (m_fd < 0) { berrno be; dev_errno = errno; Dmsg5(100, "Open error on %s omode=%d oflags=%x errno=%d: ERR=%s\n", prt_name, omode, oflags, errno, be.bstrerror()); break; } dev_errno = 0; lock_door(); set_os_device_parameters(dcr); /* do system dependent stuff */ break; /* Successfully opened and rewound */ } } bmicrosleep(5, 0); /* * Exceed wait time ? */ if (time(NULL) - start_time >= max_open_wait) { break; /* yes, get out */ } } #endif if (!is_open()) { berrno be; Mmsg2(errmsg, _("Unable to open device %s: ERR=%s\n"), prt_name, be.bstrerror(dev_errno)); Dmsg1(100, "%s", errmsg); } Dmsg1(100, "open dev: tape %d opened\n", m_fd); }
static void parse_command(irecv_client_t client, unsigned char* command, unsigned int size) { char* cmd = strdup((char*)command); char* action = strtok(cmd, " "); if (!strcmp(cmd, "/exit")) { quit = 1; } else if (!strcmp(cmd, "/help")) { shell_usage(); } else if (!strcmp(cmd, "/upload")) { char* filename = strtok(NULL, " "); debug("Uploading files %s\n", filename); if (filename != NULL) { irecv_send_file(client, filename, 0); } } else if (!strcmp(cmd, "/deviceinfo")) { int ret, mode; unsigned int cpid, bdid; unsigned long long ecid; char srnm[12], imei[15]; ret = irecv_get_cpid(client, &cpid); if(ret == IRECV_E_SUCCESS) { printf("CPID: %d\n", cpid); } ret = irecv_get_bdid(client, &bdid); if(ret == IRECV_E_SUCCESS) { printf("BDID: %d\n", bdid); } ret = irecv_get_ecid(client, &ecid); if(ret == IRECV_E_SUCCESS) { printf("ECID: " _FMT_lld "\n", ecid); } ret = irecv_get_srnm(client, srnm); if(ret == IRECV_E_SUCCESS) { printf("SRNM: %s\n", srnm); } ret = irecv_get_imei(client, imei); if(ret == IRECV_E_SUCCESS) { printf("IMEI: %s\n", imei); } ret = irecv_get_mode(client, &mode); if (ret == IRECV_E_SUCCESS) { printf("MODE: %s\n", mode_to_str(mode)); } } else if (!strcmp(cmd, "/limera1n")) { char* filename = strtok(NULL, " "); debug("Sending limera1n payload %s\n", filename); if (filename != NULL) { irecv_send_file(client, filename, 0); } irecv_trigger_limera1n_exploit(client); } else if (!strcmp(cmd, "/execute")) { char* filename = strtok(NULL, " "); debug("Executing script %s\n", filename); if (filename != NULL) { char* buffer = NULL; uint64_t buffer_length = 0; buffer_read_from_filename(filename, &buffer, &buffer_length); if (buffer) { buffer[buffer_length] = '\0'; irecv_execute_script(client, buffer); free(buffer); } else { printf("Could not read file '%s'\n", filename); } } } free(action); }