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