void check_channels(void)
{
int s, i, k;
int64_t starts[] = {0, 7};
int nstarts = sizeof(starts)/sizeof(int64_t);
int64_t lens[] = {1, 2, 3, qbytes_iobuf_size + 13, 4 * qbytes_iobuf_size};
int nlens = sizeof(lens)/sizeof(int64_t);
int64_t chunkszs[] = {1, 7, 16, qbytes_iobuf_size + 13, 2 * qbytes_iobuf_size};
int nchunkszs = sizeof(chunkszs)/sizeof(int64_t);
qio_chtype_t type;
char threadsafe;
char unboundedness[] = {0,1,-1,-2};
int nunbounded = sizeof(unboundedness)/sizeof(char);
int unbounded;
char reopen;
qio_hint_t hints[] = {QIO_METHOD_DEFAULT, QIO_METHOD_READWRITE, QIO_METHOD_PREADPWRITE, QIO_METHOD_FREADFWRITE, QIO_METHOD_MEMORY, QIO_METHOD_MMAP, QIO_METHOD_MMAP|QIO_HINT_PARALLEL, QIO_METHOD_PREADPWRITE | QIO_HINT_NOFAST};
int nhints = sizeof(hints)/sizeof(qio_hint_t);
int file_hint, ch_hint;
check_channel(false, 1, 0, 16384, 1, 0, 17, 1, 1);
check_channel(false, 3, 0, 16384, 1, QIO_METHOD_DEFAULT, QIO_METHOD_DEFAULT, 0, 1);
for( file_hint = 0; file_hint < nhints; file_hint++ ) {
for( ch_hint = 0; ch_hint < nhints; ch_hint++ ) {
for( i = 0; i < nlens; i++ ) {
for( s = 0; s < nstarts; s++ ) {
for( k = 0; k < nchunkszs; k++ ) {
for( type = 1; type <= QIO_CH_MAX_TYPE; type++ ) {
for( threadsafe = 0; threadsafe < 2; threadsafe++ ) {
for( unbounded = 0; unbounded < nunbounded; unbounded++ ) {
for( reopen = 0; reopen < 2; reopen++ ) {
check_channel(threadsafe, type, starts[s], lens[i], chunkszs[k], hints[file_hint], hints[ch_hint], unboundedness[unbounded], reopen);
}
}
}
}
}
}
}
}
}
return;
/*
for( file_hint = 0; file_hint < nhints; file_hint++ ) {
printf("Checking very large channel with hints %x\n", hints[file_hint]);
// Check a very large file.
check_channel(0, QIO_CH_BUFFERED, 0, 5L*1024L*1024L*1024L, 1024*1024, hints[file_hint], hints[file_hint], 0, 0);
check_channel(0, QIO_CH_BUFFERED, 0, 5L*1024L*1024L*1024L, 1024*1024, hints[file_hint], hints[file_hint], 1, 0);
check_channel(0, QIO_CH_BUFFERED, 0, 5L*1024L*1024L*1024L, 1024*1024, hints[file_hint], hints[file_hint], 0, 1);
check_channel(0, QIO_CH_BUFFERED, 0, 5L*1024L*1024L*1024L, 1024*1024, hints[file_hint], hints[file_hint], 1, 1);
}*/
}
/* tick: repeatedly check variables and perform actions if conditions met */
void TwitchBot::tick()
{
/* check every second */
while (bot_connected) {
for (std::vector<std::string>::size_type i = 0;
i < evtman.messages()->size(); ++i) {
if (evtman.ready("msg" + std::to_string(i))) {
if (evtman.active())
send_msg(&client, bot_channel,
((*evtman.messages())[i])
.first.c_str());
evtman.set_used("msg" + std::to_string(i));
break;
}
}
if (giveaway.active() && evtman.ready("checkgiveaway")) {
if (giveaway.check(time(nullptr)))
send_msg(&client, bot_channel,
giveaway.giveaway().c_str());
evtman.set_used("checkgiveaway");
}
if (evtman.ready("checkuptime")) {
check_channel(bot_channel + 1, bot_token, CID);
evtman.set_used("checkuptime");
if (auto_disable) {
if (channel_uptime())
evtman.activate();
else
evtman.deactivate();
}
}
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
}
int s3c2410_dma_free(dmach_t channel, s3c2410_dma_client_t *client)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
unsigned long flags;
check_channel(channel);
local_irq_save(flags);
if (chan->client != client) {
printk(KERN_WARNING "dma%d: possible free from different client (channel %p, passed %p)\n",
channel, chan->client, client);
}
/* sort out stopping and freeing the channel */
if (chan->state != S3C2410_DMA_IDLE) {
pr_debug("%s: need to stop dma channel %p\n",
__FUNCTION__, chan);
/* possibly flush the channel */
s3c2410_dma_ctrl(channel, S3C2410_DMAOP_STOP);
}
chan->client = NULL;
chan->in_use = 0;
local_irq_restore(flags);
return 0;
}
int output_direction(int channel, direction_t direction) {
check_channel(channel);
check_direction(direction);
if (direction == DIR_HALT) {
if (channel == 0) {
gpio_clear(CTRL_PORT, M0INa);
gpio_clear(CTRL_PORT, M0INb);
} else {
gpio_clear(CTRL_PORT, M1INa);
gpio_clear(CTRL_PORT, M1INb);
}
} else if (direction == DIR_FWD) {
if (channel == 0) {
gpio_set(CTRL_PORT, M0INa);
gpio_clear(CTRL_PORT, M0INb);
} else {
gpio_set(CTRL_PORT, M1INa);
gpio_clear(CTRL_PORT, M1INb);
}
} else if (direction == DIR_REV) {
if (channel == 0) {
gpio_clear(CTRL_PORT, M0INa);
gpio_set(CTRL_PORT, M0INb);
} else {
gpio_clear(CTRL_PORT, M1INa);
gpio_set(CTRL_PORT, M1INb);
}
}
return 0;
}
int
s3c2410_dma_ctrl(dmach_t channel, s3c2410_chan_op_t op)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
switch (op) {
case S3C2410_DMAOP_START:
return s3c2410_dma_start(chan);
case S3C2410_DMAOP_STOP:
return s3c2410_dma_dostop(chan);
case S3C2410_DMAOP_PAUSE:
return -ENOENT;
case S3C2410_DMAOP_RESUME:
return -ENOENT;
case S3C2410_DMAOP_FLUSH:
return s3c2410_dma_flush(chan);
case S3C2410_DMAOP_TIMEOUT:
return 0;
}
return -ENOENT; /* unknown, don't bother */
}
/* get channel config to config
*
* RETURN of non-zero means error */
int omap3_dma_get_conf_chan(uint32_t chan, struct dma4_chan *config)
{
if (check_channel(chan))
return -EINVAL;
*config = dma4_cfg->chan[chan];
return 0;
}
int s3c2410_dma_request(unsigned int channel, s3c2410_dma_client_t *client,
void *dev)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
unsigned long flags;
int err;
pr_debug("dma%d: s3c2410_request_dma: client=%s, dev=%p\n",
channel, client->name, dev);
check_channel(channel);
local_irq_save(flags);
dbg_showchan(chan);
if (chan->in_use) {
if (client != chan->client) {
printk(KERN_ERR "dma%d: already in use\n", channel);
local_irq_restore(flags);
return -EBUSY;
} else {
printk(KERN_ERR "dma%d: client already has channel\n", channel);
}
}
chan->client = client;
chan->in_use = 1;
if (!chan->irq_claimed) {
pr_debug("dma%d: %s : requesting irq %d\n",
channel, __FUNCTION__, chan->irq);
err = request_irq(chan->irq, s3c2410_dma_irq, SA_INTERRUPT,
client->name, (void *)chan);
if (err) {
chan->in_use = 0;
local_irq_restore(flags);
printk(KERN_ERR "%s: cannot get IRQ %d for DMA %d\n",
client->name, chan->irq, chan->number);
return err;
}
chan->irq_claimed = 1;
chan->irq_enabled = 1;
}
local_irq_restore(flags);
/* need to setup */
pr_debug("%s: channel initialised, %p\n", __FUNCTION__, chan);
return 0;
}
int output_speed(int channel, int speed) {
check_channel(channel);
check_speed(speed);
if (channel == 0) {
timer_set_oc_value(TIM2, TIM_OC2, speed*20);
} else {
timer_set_oc_value(TIM2, TIM_OC1, speed*20);
}
return 0;
}
/* Set Source, Destination and Size of DMA transfer for the
* specified channel.
* PARAMETERS:
* chan: channel to use
* src: source of the transfer
* dst: destination of the transfer
* sze: Size of the transfer
*
* RETURN of non-zero means error */
int omap3_dma_conf_transfer(uint32_t chan, uint32_t *src, uint32_t *dst,
uint32_t sze)
{
if (check_channel(chan))
return -EINVAL;
/* CDSA0 */
writel((uint32_t)src, &dma4_cfg->chan[chan].cssa);
writel((uint32_t)dst, &dma4_cfg->chan[chan].cdsa);
writel(sze, &dma4_cfg->chan[chan].cen);
return 0;
}
int output_disable(int channel) {
check_channel(channel);
if (channel == 0) {
gpio_clear(CTRL_PORT, M0ENa);
gpio_clear(CTRL_PORT, M0ENb);
} else {
gpio_clear(CTRL_PORT, M1ENa);
gpio_clear(CTRL_PORT, M1ENb);
}
return 0;
}
int s3c2410_dma_set_opfn(dmach_t channel, s3c2410_dma_opfn_t rtn)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
pr_debug("%s: chan=%p, op rtn=%p\n", __FUNCTION__, chan, rtn);
chan->op_fn = rtn;
return 0;
}
int s3c2410_dma_set_buffdone_fn(dmach_t channel, s3c2410_dma_cbfn_t rtn)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
pr_debug("%s: chan=%p, callback rtn=%p\n", __FUNCTION__, chan, rtn);
chan->callback_fn = rtn;
return 0;
}
int s3c2410_dma_setflags(dmach_t channel, unsigned int flags)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
pr_debug("%s: chan=%p, flags=%08x\n", __FUNCTION__, chan, flags);
chan->flags = flags;
return 0;
}
int s3c2410_dma_getposition(dmach_t channel, dma_addr_t *src, dma_addr_t *dst)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
if (src != NULL)
*src = dma_rdreg(chan, S3C2410_DMA_DCSRC);
if (dst != NULL)
*dst = dma_rdreg(chan, S3C2410_DMA_DCDST);
return 0;
}
int samcop_dma_getposition(dmach_t channel, dma_addr_t *src, dma_addr_t *dst)
{
samcop_dma_chan_t *chan = &samcop_chans[channel];
check_channel(channel);
if (src != NULL)
*src = chan->rdreg(chan->regs, SAMCOP_DMA_DCSRC);
if (dst != NULL)
*dst = chan->rdreg(chan->regs, SAMCOP_DMA_DCDST);
return 0;
}
int samcop_dma_devconfig(int channel,
samcop_dmasrc_t source,
int hwcfg,
unsigned long devaddr)
{
samcop_dma_chan_t *chan = &samcop_chans[channel];
check_channel(channel);
pr_debug("%s: source=%d, hwcfg=%08x, devaddr=%08lx\n",
__FUNCTION__, (int)source, hwcfg, devaddr);
chan->source = source;
chan->dev_addr = devaddr;
switch (source) {
case SAMCOP_DMASRC_HW:
/* source is hardware */
pr_debug("%s: hw source, devaddr=%08lx, hwcfg=%d\n",
__FUNCTION__, devaddr, hwcfg);
chan->wrreg(chan->regs, SAMCOP_DMA_DISRC,
devaddr | ((hwcfg & 3) << SAMCOP_DIxxx_INC_LOC_SHIFT));
/* The address gets written later. */
chan->wrreg(chan->regs, SAMCOP_DMA_DIDST,
SAMCOP_DIDST_AHB | SAMCOP_DIDST_INC_INC);
chan->addr_reg = SAMCOP_DMA_DIDST;
return 0;
case SAMCOP_DMASRC_MEM:
/* source is memory */
pr_debug( "%s: mem source, devaddr=%08lx, hwcfg=%d\n",
__FUNCTION__, devaddr, hwcfg);
/* The address gets written later. */
chan->wrreg(chan->regs, SAMCOP_DMA_DISRC,
SAMCOP_DISRC_AHB | SAMCOP_DISRC_INC_INC);
chan->wrreg(chan->regs, SAMCOP_DMA_DIDST,
devaddr | ((hwcfg & 3) << SAMCOP_DIxxx_INC_LOC_SHIFT));
chan->addr_reg = SAMCOP_DMA_DISRC;
return 0;
}
printk(KERN_ERR "dma%d: invalid source type (%d)\n", channel, source);
return -EINVAL;
}
/* Start the DMA transfer */
int omap3_dma_start_transfer(uint32_t chan)
{
uint32_t val;
if (check_channel(chan))
return -EINVAL;
val = readl(&dma4_cfg->chan[chan].ccr);
/* Test for channel already in use */
if (val & CCR_ENABLE_ENABLE)
return -EBUSY;
writel((val | CCR_ENABLE_ENABLE), &dma4_cfg->chan[chan].ccr);
dma_active |= (1 << chan);
debug("started transfer...\n");
return 0;
}
int s3c2410_dma_devconfig(int channel,
s3c2410_dmasrc_t source,
int hwcfg,
unsigned long devaddr)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
check_channel(channel);
pr_debug("%s: source=%d, hwcfg=%08x, devaddr=%08lx\n",
__FUNCTION__, (int)source, hwcfg, devaddr);
chan->source = source;
chan->dev_addr = devaddr;
switch (source) {
case S3C2410_DMASRC_HW:
/* source is hardware */
pr_debug("%s: hw source, devaddr=%08lx, hwcfg=%d\n",
__FUNCTION__, devaddr, hwcfg);
dma_wrreg(chan, S3C2410_DMA_DISRCC, hwcfg & 3);
dma_wrreg(chan, S3C2410_DMA_DISRC, devaddr);
dma_wrreg(chan, S3C2410_DMA_DIDSTC, (0<<1) | (0<<0));
chan->addr_reg = dma_regaddr(chan, S3C2410_DMA_DIDST);
return 0;
case S3C2410_DMASRC_MEM:
/* source is memory */
pr_debug( "%s: mem source, devaddr=%08lx, hwcfg=%d\n",
__FUNCTION__, devaddr, hwcfg);
dma_wrreg(chan, S3C2410_DMA_DISRCC, (0<<1) | (0<<0));
dma_wrreg(chan, S3C2410_DMA_DIDST, devaddr);
dma_wrreg(chan, S3C2410_DMA_DIDSTC, hwcfg & 3);
chan->addr_reg = dma_regaddr(chan, S3C2410_DMA_DISRC);
return 0;
}
printk(KERN_ERR "dma%d: invalid source type (%d)\n", channel, source);
return -EINVAL;
}
void zsg2_device::control_w(int reg, UINT16 data)
{
switch(reg)
{
case 0x00: case 0x02: case 0x04:
{
int base = (reg & 6) << 3;
int i;
for(i=0; i<16; i++)
if(data & (1<<i))
keyon(base+i);
break;
}
case 0x08: case 0x0a: case 0x0c:
{
int base = (reg & 6) << 3;
int i;
for(i=0; i<16; i++)
if(data & (1<<i))
check_channel(base+i);
break;
}
case 0x30:
break;
case 0x38:
m_alow = data;
break;
case 0x3a:
m_ahigh = data;
break;
default:
// log_event("ZOOMCTRL", "%02x = %04x", reg, data);
break;
}
}
int s3c2410_dma_config(dmach_t channel,
int xferunit,
int dcon)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
pr_debug("%s: chan=%d, xfer_unit=%d, dcon=%08x\n",
__FUNCTION__, channel, xferunit, dcon);
check_channel(channel);
switch (xferunit) {
case 1:
dcon |= S3C2410_DCON_BYTE;
break;
case 2:
dcon |= S3C2410_DCON_HALFWORD;
break;
case 4:
dcon |= S3C2410_DCON_WORD;
break;
default:
pr_debug("%s: bad transfer size %d\n", __FUNCTION__, xferunit);
return -EINVAL;
}
dcon |= S3C2410_DCON_HWTRIG;
dcon |= S3C2410_DCON_INTREQ;
pr_debug("%s: dcon now %08x\n", __FUNCTION__, dcon);
chan->dcon = dcon;
chan->xfer_unit = xferunit;
return 0;
}
char *ft_who(char *buff, t_client *client, t_server *server)
{
int i;
int count;
i = 0;
count = 0;
(void)buff;
while (i < MAX_CLIENTS)
{
if (server->clients[i].name)
{
if (check_channel(*client, server->clients[i]))
{
if (count)
write_client(client->sock, "\n");
write_client(client->sock, server->clients[i].name);
count++;
}
}
i++;
}
return (NULL);
}
struct response *evresp_itp(char *stalst, char *chalst, char *net_code,
char *locidlst, char *date_time, char *units,
char *file, double *freqs, int nfreqs,
char *rtype, char *verbose, int start_stage,
int stop_stage, int stdio_flag,
int listinterp_out_flag, int listinterp_in_flag,
double listinterp_tension, int useTotalSensitivityFlag)
{
struct channel this_channel;
struct scn *scn;
struct string_array *sta_list, *chan_list;
struct string_array *locid_list;
int i, j, k, count = 0, which_matched, test = 1, mode, new_file;
int locid_pos;
int err_type;
char out_name[MAXLINELEN], locid[LOCIDLEN+1];
char *locid_ptr, *end_locid_ptr;
struct matched_files *flst_head = (struct matched_files *)NULL;
struct matched_files *flst_ptr = NULL, *output_files = NULL;
struct file_list *lst_ptr = NULL, *tmp_ptr = NULL, *out_file = NULL, *tmp_file = NULL;
struct response *resp = NULL, *next_ptr = NULL;
struct response *prev_ptr = (struct response *)NULL;
struct response *first_resp = (struct response *)NULL;
struct complex *output = NULL;
struct scn_list *scns = NULL;
FILE *fptr = NULL;
double *freqs_orig = NULL; /* for saving the original frequencies */
int nfreqs_orig;
/* Let's save the original frequencies requested by a user since they can be overwritten */
/* if we process blockette 55 IGD for version 3.2.17 of evalresp*/
nfreqs_orig = nfreqs;
freqs_orig = (double *) malloc(sizeof(double) * nfreqs_orig);
memcpy (freqs_orig, freqs, sizeof(double) * nfreqs_orig);
/* set 'GblChanPtr' to point to 'this_channel' */
GblChanPtr = &this_channel;
/* clear out the FirstLine buffer */
memset(FirstLine, 0, sizeof(FirstLine));
/* if the verbose flag is set, then print some diagnostic output (other than
errors) */
if(verbose && !strcmp(verbose,"-v")) {
fprintf(stderr, "<< EVALRESP RESPONSE OUTPUT V%s >>\n", REVNUM);
fflush(stderr);
}
/* first, determine the values of Pi and twoPi for use in evaluating
the instrument responses later */
Pi = acos(-1.0);
twoPi = 2.0 * Pi;
/* set the values of first_units and last_units to null strings */
strncpy(this_channel.staname,"",STALEN);
strncpy(this_channel.network,"",NETLEN);
strncpy(this_channel.locid,"",LOCIDLEN);
strncpy(this_channel.chaname,"",CHALEN);
strncpy(this_channel.beg_t,"",DATIMLEN);
strncpy(this_channel.end_t,"",DATIMLEN);
strncpy(this_channel.first_units,"",MAXLINELEN);
strncpy(this_channel.last_units,"",MAXLINELEN);
/* and initialize the linked list of pointers to filters */
this_channel.first_stage = (struct stage *)NULL;
/* parse the "stalst" string to form a list of stations */
for(i = 0; i < (int)strlen(stalst); i++) {
if(stalst[i] == ',')
stalst[i] = ' ';
}
sta_list = ev_parse_line(stalst);
/* remove any blank spaces from the beginning and end of the string */
locid_ptr = locidlst; locid_pos = 0;
strncpy(locid, "", LOCIDLEN);
while(*locid_ptr && *locid_ptr == ' ') locid_ptr++;
end_locid_ptr = locid_ptr + strlen(locid_ptr) - 1;
while(end_locid_ptr > locid_ptr && *end_locid_ptr == ' ') end_locid_ptr--;
strncpy(locid, locid_ptr, (end_locid_ptr - locid_ptr + 1));
/* parse the "locidlst" string to form a list of channels */
locid_list = parse_delim_line(locid,",");
/* parse the "chalst" string to form a list of channels */
for(i = 0; i < (int)strlen(chalst); i++) {
if(chalst[i] == ',')
chalst[i] = ' ';
}
chan_list = ev_parse_line(chalst);
/* then form a set of network-station-locid-channel tuples to search for */
scns = alloc_scn_list(chan_list->nstrings*sta_list->nstrings*locid_list->nstrings);
for(i = 0; i < sta_list->nstrings; i++) {
for(j = 0; j < locid_list->nstrings; j++) {
for(k = 0; k < chan_list->nstrings; k++, count++) {
scn = scns->scn_vec[count];
strncpy(scn->station, sta_list->strings[i], STALEN);
if(strlen(locid_list->strings[j]) == strspn(locid_list->strings[j], " "))
memset(scn->locid, 0, LOCIDLEN);
else
strncpy(scn->locid, locid_list->strings[j], LOCIDLEN);
strncpy(scn->channel, chan_list->strings[k], CHALEN);
strncpy(scn->network, net_code, NETLEN);
}
}
}
#ifdef LOG_LABEL
sprintf(myLabel, "[%s.%s.%s.%s]", scn->network, scn->station, scn->locid, scn->channel);
#else
myLabel[0] = '\0';
#endif
/* if input is from stdin, set fptr to stdin, else find whatever matching
files there are */
if(stdio_flag) {
fptr = stdin;
mode = 0;
}
else {
flst_head = find_files(file, scns, &mode);
flst_ptr = flst_head;
}
/* find the responses for each of the station channel pairs as they
occur in the file */
if(!mode && !stdio_flag) {
curr_file = file;
if((fptr = fopen(file,"r")) == (FILE *)NULL) {
#ifdef LIB_MODE
fprintf(stderr, "%s failed to open file %s\n", myLabel, file);
return NULL;
#else
error_exit(OPEN_FILE_ERROR,"failed to open file %s", file);
#endif
}
}
/* allocate space for the first response */
resp = alloc_response(nfreqs);
for(i = 0; i < scns->nscn && (mode || test); i++) {
/* allocate space for 'matched_files' pointer used to determine if a
file has already been read */
if(!stdio_flag)
output_files = alloc_matched_files();
/* then check the mode to determine if are parsing one file or a list
of files (note: if input is from stdin, is one file) */
if(!mode) {
which_matched = 0;
while(test && which_matched >= 0) {
if(!(err_type = setjmp(jump_buffer))) {
new_file = 0;
which_matched = find_resp(fptr, scns, date_time, &this_channel);
#ifdef LIB_MODE /* IGD 25-Sep-2007 Looks like we do not need this: function returns anyway */
// if(which_matched < 0) {
// if(!stdio_flag) /* if not input from console then */
// fclose(fptr); /* close input file
// return NULL;
// }
#endif
/* found a station-channel-network that matched. First construct
an output filename and compare to other output files. If this
filename doesn't match any of them, (or if it is the first
file found) parse the channel's response information.
Otherwise skip it (since a match has already been found) */
sprintf(out_name,"%s.%s.%s.%s",this_channel.network,
this_channel.staname,this_channel.locid,
this_channel.chaname);
#ifdef LOG_LABEL
sprintf(myLabel, "[%s]", out_name);
#else
myLabel[0] = '\0';
#endif
if(!stdio_flag) {
tmp_file = output_files->first_list;
for(k = 0; k < output_files->nfiles; k++) {
out_file = tmp_file;
if(!strcmp(out_file->name,out_name))
break;
tmp_file = out_file->next_file;
}
}
if((stdio_flag && !new_file) || !output_files->nfiles) {
if(!stdio_flag) {
output_files->nfiles++;
out_file = alloc_file_list();
output_files->first_list = out_file;
out_file->name = alloc_char(strlen(out_name)+1);
strcpy(out_file->name,out_name);
}
new_file = 1;
}
else if((stdio_flag && !new_file) || k == output_files->nfiles) {
if(!stdio_flag) {
output_files->nfiles++;
out_file->next_file = alloc_file_list();
tmp_file = out_file->next_file;
out_file = tmp_file;
out_file->name = alloc_char(strlen(out_name)+1);
strcpy(out_file->name,out_name);
}
new_file = 1;
}
else
new_file = 0;
if(new_file && which_matched >= 0) {
/* fill in station-channel-net information for the response */
strncpy(resp->station,this_channel.staname,STALEN);
strncpy(resp->locid,this_channel.locid,LOCIDLEN);
strncpy(resp->channel,this_channel.chaname,CHALEN);
strncpy(resp->network,this_channel.network,NETLEN);
output = resp->rvec;
/* found a station channel pair that matched a response, so parse
the response into a channel/filter list */
test = parse_channel(fptr, &this_channel);
if(listinterp_in_flag &&
this_channel.first_stage->first_blkt->type == LIST)
{ /* flag set for interpolation and stage type is "List" */
interpolate_list_blockette(
&(this_channel.first_stage->first_blkt->blkt_info.list.freq),
&(this_channel.first_stage->first_blkt->blkt_info.list.amp),
&(this_channel.first_stage->first_blkt->blkt_info.list.phase),
&(this_channel.first_stage->first_blkt->blkt_info.list.nresp),
freqs,nfreqs,listinterp_tension);
}
/* check the filter sequence that was just read */
check_channel(&this_channel);
/* If we process blockette 55, we should recompute resp->rvec */
/* because the number of output responses is generally different from */
/* what is the user requested */
/*if we don't use blockette 55, we should set the frequencies to the original */
/* user defined position if we did mess up with frequencies in -possible - blockette 55*/
/* containing previous file. Modifications by I.Dricker IGD*/
free(resp->rvec);
/* 'freqs' array is passed in and should not be freed -- 10/18/2005 -- [ET] */
/* free(freqs); */
if (this_channel.first_stage->first_blkt != NULL && this_channel.first_stage->first_blkt->type == LIST)
{
/*to prevent segmentation in case of bogus input files */
nfreqs = this_channel.first_stage->first_blkt->blkt_info.list.nresp;
freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (freqs, this_channel.first_stage->first_blkt->blkt_info.list.freq, sizeof(double) * nfreqs); /*cp*/
resp->rvec = alloc_complex(nfreqs);
output=resp->rvec;
resp->nfreqs = nfreqs;
resp->freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (resp->freqs, this_channel.first_stage->first_blkt->blkt_info.list.freq, sizeof(double) * nfreqs); /*cp*/
}
else
{
nfreqs = nfreqs_orig;
freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (freqs, freqs_orig, sizeof(double) * nfreqs); /*cp*/
resp->rvec = alloc_complex(nfreqs);
output=resp->rvec;
resp->nfreqs = nfreqs;
resp->freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (resp->freqs, freqs_orig, sizeof(double) * nfreqs); /*cp*/
}
/* normalize the response of the filter sequence */
norm_resp(&this_channel, start_stage, stop_stage);
/* calculate the response at the requested frequencies */
calc_resp(&this_channel, freqs, nfreqs, output, units,
start_stage, stop_stage, useTotalSensitivityFlag);
/* diagnostic output, if the user requested it */
if(verbose && !strcmp(verbose,"-v")) {
print_chan(&this_channel, start_stage, stop_stage,
stdio_flag, listinterp_out_flag, listinterp_in_flag, useTotalSensitivityFlag);
}
free(freqs); /* free array that was allocated above */
/* and, finally, free the memory associated with this channel/filter
list and continue searching for the next match */
free_channel(&this_channel);
if(first_resp == (struct response *)NULL) {
first_resp = resp;
}
next_ptr = alloc_response(nfreqs);
resp->next = next_ptr;
prev_ptr = resp;
resp = next_ptr;
}
else {
strncpy(FirstLine,"",MAXLINELEN);
test = next_resp(fptr);
}
}
else {
if(new_file)
output_files->nfiles--;
free_channel(&this_channel);
/* catch errors that cause parsing to fail midstream */
if(err_type == PARSE_ERROR || err_type == UNRECOG_FILTYPE ||
err_type == UNDEF_SEPSTR || err_type == IMPROP_DATA_TYPE ||
err_type == RE_COMP_FAILED || err_type == UNRECOG_UNITS) {
strncpy(FirstLine,"",MAXLINELEN);
test = next_resp(fptr);
}
else if(err_type == UNDEF_PREFIX) {
test = 0;
}
}
}
if(!stdio_flag)
free_matched_files(output_files); /* added 3/28/2006 -- [ET] */
/* allocated one too many responses */
free_response(resp);
if(prev_ptr != (struct response *)NULL)
prev_ptr->next = (struct response *)NULL;
break;
}
else if(mode) {
lst_ptr = flst_ptr->first_list;
scn = scns->scn_vec[i];
next_scn:
for(j = 0; j < flst_ptr->nfiles; j++) {
if(!stdio_flag) {
fptr = fopen(lst_ptr->name,"r");
}
if(fptr != (FILE *)NULL) {
curr_file = lst_ptr->name;
look_again:
if(!(err_type = setjmp(jump_buffer))) {
new_file = 0;
which_matched = get_resp(fptr, scn, date_time, &this_channel);
#ifdef LIB_MODE /* IGD 25-Sep-2007 Looks like we do not need this: function returns anyway */
// if(which_matched < 1) {
// if(!stdio_flag) /* if not input from console then */
// fclose(fptr); /* close input file */
// return NULL;
// }
#endif
if(which_matched >= 0) {
/* found a station-channel-network that matched. First construct
an output filename and compare to other output files. If this
filename doesn't match any of them, (or if it is the first
file found) parse the channel's response information.
Otherwise skip it (since a match has already been found) */
sprintf(out_name,"%s.%s.%s.%s",this_channel.network,
this_channel.staname,this_channel.locid,
this_channel.chaname);
#ifdef LOG_LABEL
sprintf (myLabel, "[%s]", out_name);
#else
myLabel[0] = '\0';
#endif
tmp_file = output_files->first_list;
for(k = 0; k < output_files->nfiles; k++) {
out_file = tmp_file;
if(!strcmp(out_file->name,out_name))
break;
tmp_file = out_file->next_file;
}
if(!output_files->nfiles) {
output_files->nfiles++;
out_file = alloc_file_list();
output_files->first_list = out_file;
out_file->name = alloc_char(strlen(out_name)+1);
strcpy(out_file->name,out_name);
new_file = 1;
}
else if(k == output_files->nfiles) {
output_files->nfiles++;
out_file->next_file = alloc_file_list();
tmp_file = out_file->next_file;
out_file = tmp_file;
out_file->name = alloc_char(strlen(out_name)+1);
strcpy(out_file->name,out_name);
new_file = 1;
}
else
new_file = 0;
if(new_file) {
/* fill in station-channel-net information for the response */
strncpy(resp->station,this_channel.staname,STALEN);
strncpy(resp->locid,this_channel.locid,LOCIDLEN);
strncpy(resp->channel,this_channel.chaname,CHALEN);
strncpy(resp->network,this_channel.network,NETLEN);
output = resp->rvec;
/* parse the response into a channel/filter list */
test = parse_channel(fptr, &this_channel);
/* IGD 01/04/01 Add code preventing a user from defining output units as DIS and ACC if
the input units are PRESSURE after */
if (strncmp (this_channel.first_units, "PA -",4) == 0) {
if (strcmp(units, "VEL") != 0) {
if(strcmp(units, "DEF") != 0) {
fprintf(stderr, "%s WARNING: OUTPUT %s does not make sense if INPUT is PRESSURE\n",
myLabel, units);
strcpy (units, "VEL");
fprintf(stderr, "%s OUTPUT units are reset and interpreted as PRESSURE\n", myLabel);
}
}
}
/* IGD 08/21/06 Add code preventing a user from defining output units as DIS and ACC if
the input units are TESLA */
if (strncmp (this_channel.first_units, "T -", 3) == 0) {
if (strcmp(units, "VEL") != 0) {
if(strcmp(units, "DEF") != 0) {
fprintf(stderr, "%s WARNING: OUTPUT %s does not make sense if INPUT is MAGNETIC FLUX\n",
myLabel, units);
strcpy (units, "VEL");
fprintf(stderr, "%s OUTPUT units are reset and interpreted as TESLA\n", myLabel);
}
}
}
if(listinterp_in_flag &&
this_channel.first_stage->first_blkt->type == LIST) {
/* flag set for interpolation and stage type is "List" */
interpolate_list_blockette(
&(this_channel.first_stage->first_blkt->blkt_info.list.freq),
&(this_channel.first_stage->first_blkt->blkt_info.list.amp),
&(this_channel.first_stage->first_blkt->blkt_info.list.phase),
&(this_channel.first_stage->first_blkt->blkt_info.list.nresp),
freqs,nfreqs,listinterp_tension);
}
/* check the filter sequence that was just read */
check_channel(&this_channel);
/* If we process blockette 55, we should recompute resp->rvec */
/* because the number of output responses is generally different from */
/* what is the user requested */
/*if we don't use blockette 55, we should set the frequencies to the original */
/* user defined position if we did mess up with frequencies in -possible - blockette 55*/
/* containing previous file. Modifications by I.Dricker / IGD */
free(resp->rvec);
/* 'freqs' array is passed in and should not be freed -- 10/18/2005 -- [ET] */
/* free(freqs); */
if (this_channel.first_stage->first_blkt != NULL && this_channel.first_stage->first_blkt->type == LIST) {
/* This is to prevent segmentation if the response input is bogus responses */
nfreqs = this_channel.first_stage->first_blkt->blkt_info.list.nresp;
freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (freqs, this_channel.first_stage->first_blkt->blkt_info.list.freq, sizeof(double) * nfreqs); /*cp*/
resp->rvec = alloc_complex(nfreqs);
output=resp->rvec;
resp->nfreqs = nfreqs;
resp->freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (resp->freqs, this_channel.first_stage->first_blkt->blkt_info.list.freq, sizeof(double) * nfreqs); /*cp*/
}
else {
nfreqs = nfreqs_orig;
freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (freqs, freqs_orig, sizeof(double) * nfreqs); /*cp*/
resp->rvec = alloc_complex(nfreqs);
output=resp->rvec;
resp->nfreqs = nfreqs;
resp->freqs = (double *) malloc(sizeof(double) * nfreqs); /* malloc a new vector */
memcpy (resp->freqs, freqs_orig, sizeof(double) * nfreqs); /*cp*/
}
/* normalize the response of the filter sequence */
norm_resp(&this_channel, start_stage, stop_stage);
/* calculate the response at the requested frequencies */
calc_resp(&this_channel, freqs, nfreqs, output, units,
start_stage, stop_stage, useTotalSensitivityFlag);
/* diagnostic output, if the user requested it */
if(verbose && !strcmp(verbose,"-v")) {
print_chan(&this_channel, start_stage, stop_stage,
stdio_flag, listinterp_out_flag, listinterp_in_flag, useTotalSensitivityFlag);
}
free(freqs); /* free array that was allocated above */
/* and, finally, free the memory associated with this
channel/filter list and continue searching for the
next match */
free_channel(&this_channel);
if(first_resp == (struct response *)NULL) {
first_resp = resp;
}
next_ptr = alloc_response(nfreqs);
resp->next = next_ptr;
prev_ptr = resp;
resp = next_ptr;
}
FirstField = 0;
strncpy(FirstLine,"",MAXLINELEN);
if(!stdio_flag) {
fclose(fptr);
}
}
else {
strncpy(FirstLine,"",MAXLINELEN);
test = next_resp(fptr);
if (!test) {
if(!stdio_flag) {
fclose(fptr);
}
}
}
/* if not the last file in the list, move on to the next one */
if(lst_ptr->next_file != (struct file_list *)NULL) {
tmp_ptr = lst_ptr->next_file;
lst_ptr = tmp_ptr;
}
}
else {
if (new_file)
output_files->nfiles--;
/* catch errors that cause parsing to fail midstream */
if(err_type == PARSE_ERROR || err_type == UNRECOG_FILTYPE ||
err_type == UNDEF_SEPSTR || err_type == IMPROP_DATA_TYPE ||
err_type == RE_COMP_FAILED || err_type == UNRECOG_UNITS) {
strncpy(FirstLine,"",MAXLINELEN);
test = next_resp(fptr);
}
else if(err_type == UNDEF_PREFIX) {
test = 0;
}
free_channel(&this_channel);
if (!test) {
FirstField = 0;
strncpy(FirstLine,"",MAXLINELEN);
if(!stdio_flag) {
fclose(fptr);
}
}
else
goto look_again;
/* if not the last file in the list, move on to the next one */
if(lst_ptr->next_file != (struct file_list *)NULL) {
tmp_ptr = lst_ptr->next_file;
lst_ptr = tmp_ptr;
}
}
}
}
/* if not the last station-channel-network in the list,
move on to the next one */
if(i < (scns->nscn-1)) {
flst_ptr = flst_ptr->ptr_next;
lst_ptr = flst_ptr->first_list;
i++;
scn = scns->scn_vec[i];
goto next_scn;
}
if(!stdio_flag)
free_matched_files(output_files);
/* allocated one too many responses */
free_response(resp);
if(prev_ptr != (struct response *)NULL)
prev_ptr->next = (struct response *)NULL;
} /* end else if mode */
} /* end for loop */
/* added file close if single input file -- 2/13/2006 -- [ET]: */
if(!mode && !stdio_flag) /* if single file was opened then */
fclose(fptr); /* close input file */
/* and print a list of WARNINGS about the station-channel pairs that were not
found in the input RESP files */
for(i = 0; i < scns->nscn; i++) {
scn = scns->scn_vec[i];
if(!scn->found) {
fprintf(stderr,"%s WARNING: no response found for NET=%s,STA=%s,LOCID=%s,CHAN=%s,DATE=%s\n",
myLabel, scn->network, scn->station, scn->locid, scn->channel, date_time);
fflush(stderr);
}
}
free_scn_list(scns);
if(flst_head != (struct matched_files *)NULL)
free_matched_files(flst_head);
free_string_array(chan_list);
free_string_array(locid_list);
free_string_array(sta_list);
free(freqs_orig); /* added 3/28/2006 -- [ET] */
return(first_resp);
}
int main(void)
{
int init_res;
puts("\nRIOT netdev test");
dev = NETDEV_DEFAULT;
if (dev == NULL) {
puts("Default device was NULL");
return 1;
}
printf("Initialized dev ");
switch (dev->type) {
case NETDEV_TYPE_UNKNOWN:
printf("of unknown type\n");
break;
case NETDEV_TYPE_BASE:
printf("as basic device\n");
break;
default:
printf("of undefined type\n");
break;
}
if (dev->driver == NULL) {
puts("Default driver is defined as NULL!");
return 1;
}
dev->driver->init(dev);
if (!(init_res = init_channel())) {
return 1;
}
if (check_channel() == 0) {
printf("Channel is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_address())) {
return 1;
}
if (check_address() == 0) {
printf("Address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_long_address())) {
return 1;
}
if (check_long_address() == 0) {
printf("Long address is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (!(init_res = init_nid())) {
return 1;
}
if (check_nid() == 0) {
printf("Network ID is not as expected. ");
if (init_res == 2) {
printf("But initialization is not supported. Continuing.\n");
}
else {
printf("Aborting\n");
return 1;
}
}
if (check_max_packet_size() == 0) {
return 1;
}
if (check_protocol() == 0) {
return 1;
}
if (!init_state()) {
return 1;
}
if (!check_state()) {
return 1;
}
#ifdef SENDER
if (!send_packet()) {
return 1;
}
#elif RECEIVER
if (!init_receiver_callback()) {
return 1;
}
#endif
return 0;
}
int s3c2410_dma_enqueue(unsigned int channel, void *id,
dma_addr_t data, int size)
{
s3c2410_dma_chan_t *chan = &s3c2410_chans[channel];
s3c2410_dma_buf_t *buf;
unsigned long flags;
check_channel(channel);
pr_debug("%s: id=%p, data=%08x, size=%d\n",
__FUNCTION__, id, (unsigned int)data, size);
buf = kmem_cache_alloc(dma_kmem, GFP_ATOMIC);
if (buf == NULL) {
pr_debug("%s: out of memory (%d alloc)\n",
__FUNCTION__, sizeof(*buf));
return -ENOMEM;
}
pr_debug("%s: new buffer %p\n", __FUNCTION__, buf);
//dbg_showchan(chan);
buf->next = NULL;
buf->data = buf->ptr = data;
buf->size = size;
buf->id = id;
buf->magic = BUF_MAGIC;
local_irq_save(flags);
if (chan->curr == NULL) {
/* we've got nothing loaded... */
pr_debug("%s: buffer %p queued onto empty channel\n",
__FUNCTION__, buf);
chan->curr = buf;
chan->end = buf;
chan->next = NULL;
} else {
pr_debug("dma%d: %s: buffer %p queued onto non-empty channel\n",
chan->number, __FUNCTION__, buf);
if (chan->end == NULL)
pr_debug("dma%d: %s: %p not empty, and chan->end==NULL?\n",
chan->number, __FUNCTION__, chan);
chan->end->next = buf;
chan->end = buf;
}
/* if necessary, update the next buffer field */
if (chan->next == NULL)
chan->next = buf;
/* check to see if we can load a buffer */
if (chan->state == S3C2410_DMA_RUNNING) {
if (chan->load_state == S3C2410_DMALOAD_1LOADED && 1) {
if (s3c2410_dma_waitforload(chan, __LINE__) == 0) {
printk(KERN_ERR "dma%d: loadbuffer:"
"timeout loading buffer\n",
chan->number);
dbg_showchan(chan);
local_irq_restore(flags);
return -EINVAL;
}
}
while (s3c2410_dma_canload(chan) && chan->next != NULL) {
s3c2410_dma_loadbuffer(chan, chan->next);
}
} else if (chan->state == S3C2410_DMA_IDLE) {
if (chan->flags & S3C2410_DMAF_AUTOSTART) {
s3c2410_dma_ctrl(chan->number, S3C2410_DMAOP_START);
}
}
local_irq_restore(flags);
return 0;
}
/* Handle Command, special char or attribute and also check for
* channel changes.
* Returns 1 if something was written to screen, 0 otherwise */
int disCommand(unsigned char hi, unsigned char lo, ccx_decoder_608_context *context, struct cc_subtitle *sub)
{
int wrote_to_screen=0;
/* Full channel changes are only allowed for "GLOBAL CODES",
* "OTHER POSITIONING CODES", "BACKGROUND COLOR CODES",
* "MID-ROW CODES".
* "PREAMBLE ACCESS CODES", "BACKGROUND COLOR CODES" and
* SPECIAL/SPECIAL CHARACTERS allow only switching
* between 1&3 or 2&4. */
context->new_channel = check_channel(hi, context);
//if (wb->data608->channel!=cc_channel)
// continue;
if (hi>=0x18 && hi<=0x1f)
hi=hi-8;
switch (hi)
{
case 0x10:
if (lo>=0x40 && lo<=0x5f)
handle_pac(hi, lo, context);
break;
case 0x11:
if (lo>=0x20 && lo<=0x2f)
handle_text_attr(hi, lo, context);
if (lo>=0x30 && lo<=0x3f)
{
wrote_to_screen=1;
handle_double(hi, lo, context);
}
if (lo>=0x40 && lo<=0x7f)
handle_pac(hi, lo, context);
break;
case 0x12:
case 0x13:
if (lo>=0x20 && lo<=0x3f)
{
wrote_to_screen = handle_extended(hi, lo, context);
}
if (lo>=0x40 && lo<=0x7f)
handle_pac(hi, lo, context);
break;
case 0x14:
case 0x15:
if (lo>=0x20 && lo<=0x2f)
handle_command(hi, lo, context, sub);
if (lo>=0x40 && lo<=0x7f)
handle_pac(hi, lo, context);
break;
case 0x16:
if (lo>=0x40 && lo<=0x7f)
handle_pac(hi, lo, context);
break;
case 0x17:
if (lo>=0x21 && lo<=0x23)
handle_command(hi, lo, context, sub);
if (lo>=0x2e && lo<=0x2f)
handle_text_attr(hi, lo, context);
if (lo>=0x40 && lo<=0x7f)
handle_pac(hi, lo, context);
break;
}
return wrote_to_screen;
}
/* init_timers: initialize bot and channel start timers */
void init_timers(const char *channel, const char *token, const char *cid)
{
bot_time = time(NULL);
check_channel(channel, token, cid);
}
static int atcmd_done(struct gsmd *g, struct gsmd_atcmd *cmd,
const char *buf, u_int8_t channel)
{
int rc = 0;
#if ENABLE_TIMEOUTS
remove_channel_timeout(g, channel);
#endif
if (!cmd) {
gsmd_log(GSMD_ERROR, "* Null cmd? *\n");
return -1;
}
if (!cmd->cb) {
gsmd_log(GSMD_NOTICE, "command without cb!!!\n");
} else {
cmd->flags = ATCMD_FINAL_CB_FLAG;
/* send final result code if there is no information
* response in mlbuf */
if (g->mlbuf_len[channel]) {
cmd->resp = g->mlbuf[channel];
cmd->resplen = g->mlbuf_len[channel];
cmd->resp[cmd->resplen] = 0;
} else {
cmd->resp = (char*) buf;
cmd->resplen = strlen(buf);
}
DEBUGP("Calling final cmd->cb() %d <%s>(%d) <%d>\n",
g->mlbuf_len[channel],cmd->resp,cmd->resplen,cmd->ret);
rc = cmd->cb(cmd, cmd->ctx, cmd->resp);
if (rc < 0) {
gsmd_log(GSMD_ERROR, "Failed to create response for client\n");
}
DEBUGP("Clearing mlbuf\n");
g->mlbuf_len[channel] = 0;
g->mlbuf[channel][0] = 0;
}
/* remove from list of currently executing cmds */
llist_del(&cmd->list);
#if ENABLE_TIMEOUTS
if (TIMEOUT_ERRORCODE == cmd->ret && STATUS_OK == g->modem_status)
check_channel(g,channel);
#endif
atcmd_free(cmd);
/* We're finished with the current command, but if still have pending
* command(s) then pop off the first pending */
if (llist_empty(&g->busy_atcmds[channel])) {
struct gsmd_atcmd *cur = NULL;
u_int32_t initial_delay_secs = 0;
if (!llist_empty(&g->pending_atcmds[channel])) {
gsmd_log(GSMD_INFO, "cmds pending\n");
cur = llist_entry(g->pending_atcmds[channel].next,
struct gsmd_atcmd, list);
if (cur) {
initial_delay_secs = cur->initial_delay_secs;
} else {
gsmd_log(GSMD_ERROR, "First pending is null?\n");
}
}
if (g->pin_status) {
if (cur) {
if (cur->flags & ATCMD_PIN_SENSITIVE) {
gsmd_log(GSMD_INFO, "pin_status %d\n",g->pin_status);
if (g->sim_status == GSM0707_CME_SIM_NOT_INSERTED) {
gsmd_log(GSMD_INFO, "sim not inserted\n");
/* allow the modem to fail the cmd */
wake_pending_after_delay(
g,channel,initial_delay_secs);
} else {
gsmd_log(GSMD_INFO, "* pin sensitive cmd delayed *\n");
g->pin_sensitive_cmds_waiting = 1;
}
} else {
gsmd_log(GSMD_INFO, "wake pending after %d\n", initial_delay_secs);
wake_pending_after_delay(g,channel,initial_delay_secs);
}
}
} else {
if (g->pin_sensitive_cmds_waiting) {
if (cur && (cur->flags & ATCMD_PIN_SENSITIVE)) {
u_int8_t ch_iter = 0;
gsmd_log(GSMD_INFO, "chk chnls for pin delayed cmds\n");
for (ch_iter = 0; ch_iter < g->number_channels; ch_iter++) {
if (ch_iter == channel)
continue;
if (!llist_empty(&g->pending_atcmds[ch_iter])) {
struct gsmd_atcmd *cur2 =
llist_entry(g->pending_atcmds[ch_iter].next,
struct gsmd_atcmd, list);
if (cur2 && (cur2->flags & ATCMD_PIN_SENSITIVE)) {
gsmd_log(GSMD_INFO, "* waking chnl %d *\n",
ch_iter);
wake_pending_after_delay(
g, ch_iter, initial_delay_secs);
}
}
}
g->pin_sensitive_cmds_waiting = 0;
}
}
gsmd_log(GSMD_INFO, "wake pending after %d secs\n", initial_delay_secs);
wake_pending_after_delay(g, channel,initial_delay_secs);
}
