/*
* Implements the /sys/class/pcmcia_socket/??/status file.
*
* Returns: the number of characters added to the buffer
*/
static ssize_t show_status(
struct device *dev, struct device_attribute *attr, char *buf)
{
struct soc_pcmcia_socket *skt =
container_of(dev, struct soc_pcmcia_socket, socket.dev);
char *p = buf;
p += sprintf(p, "slot : %d\n", skt->nr);
dump_bits(&p, "status", skt->status,
status_bits, ARRAY_SIZE(status_bits));
dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
status_bits, ARRAY_SIZE(status_bits));
dump_bits(&p, "cs_flags", skt->cs_state.flags,
conf_bits, ARRAY_SIZE(conf_bits));
p += sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
p += sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
p += sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq,
skt->socket.pci_irq);
if (skt->ops->show_timing)
p += skt->ops->show_timing(skt, p);
return p-buf;
}
int main() {
/*
S2 s2;
s2.a = (1 << 23) - 1;
s2.b = 1;
s2.c = 1;
s2.r = 0;
dump_bits(*(unsigned long long*)&s2);
printf("%d\n", s2.a);
*/
S s;
//s.a = 0;
//s.ll = (1ULL << 50) - 1;
s.ll = 0x123456789aULL;
printf("%llx\n", s.ll);
printf("%llx\n", s.ll++);
s.r = 0;
//s.ll = 0x123456789a;
//s.r = 0;
//printf("%llu\n", 0xffffffffffffffffULL);
//printf("%llu\n", 0xffffffffffffULL);
dump_bits(s.ll);
printf("%llx\n", s.ll);
dump_bits(*(unsigned long long*)&s);
}
int
main (int argc, char *argv[])
{
int i;
SchroBuffer *buffer = schro_buffer_new_and_alloc (100);
SchroBits *bits;
int value;
int fail = 0;
int n;
schro_init();
printf("unsigned int\n");
for(i=0;i<21;i++) {
bits = schro_bits_new();
schro_bits_encode_init (bits, buffer);
schro_bits_encode_uint(bits,i);
schro_bits_flush (bits);
n = schro_bits_get_offset (bits);
schro_bits_free (bits);
bits = schro_bits_new();
schro_bits_decode_init (bits, buffer);
printf("%3d:", i);
dump_bits (bits, n);
value = schro_bits_decode_uint (bits);
if (value != i) {
printf("decode failed (%d != %d)\n", value, i);
fail = 1;
}
schro_bits_free (bits);
}
printf("\n");
printf("signed int\n");
for(i=-5;i<6;i++) {
bits = schro_bits_new();
schro_bits_encode_init (bits, buffer);
schro_bits_encode_sint(bits,i);
schro_bits_flush (bits);
n = schro_bits_get_offset (bits);
schro_bits_free (bits);
bits = schro_bits_new();
schro_bits_decode_init (bits, buffer);
printf("%3d:", i);
dump_bits (bits, n);
value = schro_bits_decode_sint (bits);
if (value != i) {
printf("decode failed (%d != %d)\n", value, i);
fail = 1;
}
schro_bits_free (bits);
}
printf("\n");
return fail;
}
int merge_check(Puzzle *puz, Solution *sol)
{
MergeElem *m;
//dir_t z;
int found= 0;
for (m= merge_list; m != NULL; m= m->next)
{
if (m->maxc == merge_no && m->cell != NULL)
{
if (VM)
{
printf("M: FOUND MERGED CONSEQUENCE ON CELL (%d,%d) BITS ",
m->cell->line[0], m->cell->line[1]);
dump_bits(stdout, puz, m->bit);
printf("\n");
}
/* Add to history as a necessary consequence */
add_hist(puz, m->cell, 0);
/* Set the new value in the cell */
#ifdef LIMITCOLORS
oldval[0]= m->cell->bit[0];
m->cell->bit[0]&= ~m->bit[0];
#else
for (z= 0; z < fbit_size; z++)
{
oldval[z]= m->cell->bit[z];
m->cell->bit[z]&= ~m->bit[z];
}
#endif
if (puz->ncolor <= 2)
m->cell->n= 1;
else
count_cell(puz,m->cell);
if (m->cell->n == 1) solved_a_cell(puz, m->cell,1);
/* Add rows/columns containing this cell to the job list */
add_jobs(puz, sol, -1, m->cell, 0, oldval);
found= 1;
}
/* Reset to unused state */
m->cell= NULL;
}
if (VM && !found) printf("M: NO MERGE CONSEQUENCES\n");
merge_list= NULL;
merge_no= -1;
merging= 0;
return found;
}
void dump_merge(Puzzle *puz)
{
MergeElem *m;
int n= 0;
for (m= merge_list; m != NULL; m= m->next)
{
if (n++ > 1000) {printf("Yicks!\n"); /*exit(1);*/ return;}
if (m->cell)
{
printf(" %d: CELL (%d,%d) BITS ",n,
m->cell->line[0], m->cell->line[1]);
dump_bits(stdout, puz, m->bit);
printf("\n");
}
else
printf(" %d: NULL\n",n);
}
}
static struct trace *blkiomon_do_trace(struct trace *t)
{
struct trace *t_stored, *t_old, *t_young;
/* store trace if there is no match yet */
t_stored = blkiomon_fetch_trace(&t->bit);
if (!t_stored) {
blkiomon_store_trace(t);
return blkiomon_alloc_trace();
}
/* figure out older trace and younger trace */
if (t_stored->bit.time < t->bit.time) {
t_old = t_stored;
t_young = t;
} else {
t_old = t;
t_young = t_stored;
}
/* we need an older D trace and a younger C trace */
if (t_old->bit.action & BLK_TC_ACT(BLK_TC_ISSUE) &&
t_young->bit.action & BLK_TC_ACT(BLK_TC_COMPLETE)) {
/* matching D and C traces - update statistics */
match++;
blkiomon_account(&t_old->bit, &t_young->bit);
blkiomon_free_trace(t_stored);
return t;
}
/* no matching D and C traces - keep more recent trace */
dump_bits(t_old, t_young, "mismatch");
mismatch++;
blkiomon_store_trace(t_young);
return t_old;
}
int backtrack(Puzzle *puz, Solution *sol)
{
Hist *h;
//color_t z, oldn, newn;
//dir_t k;
if (VB) printf("B: BACKTRACKING TO LAST GUESS\n");
/* Undo up to, but not including, the most recent branch point */
if (undo(puz,sol, 1))
{
if (VB) printf("B: CANNOT BACKTRACK\n");
return 1;
}
if (VB) print_solution(stdout,puz,sol);
/* This will be the branch point since undo() backed us up to it */
h= HIST(puz, puz->nhist-1);
if (VB || WC(h->cell))
{
printf("B: LAST GUESS WAS ");
print_coord(stdout,puz,h->cell);
printf(" |");
dump_bits(stdout,puz,h->bit);
printf("| -> |");
dump_bits(stdout,puz,h->cell->bit);
printf("|\n");
}
/* If undoing a solved cell, uncount it */
if (h->cell->n == 1) solved_a_cell(puz, h->cell, -1);
/* Reset any bits previously set */
#ifdef LIMITCOLORS
h->cell->bit[0]= ((~h->cell->bit[0]) & h->bit[0]);
#else
for (z= 0; z < fbit_size; z++)
h->cell->bit[z]= ((~h->cell->bit[z]) & h->bit[z]);
#endif
h->cell->n= h->n - h->cell->n; /* Since the bits set in h are always
a superset of those in h->cell,
this should always work */
/* If inverted cell is solved, count it */
if (h->cell->n == 1) solved_a_cell(puz, h->cell, 1);
if (VB || WC(h->cell))
{
printf("B: INVERTING GUESS TO |");
dump_bits(stdout,puz,h->cell->bit);
printf("| (%d)\n",h->cell->n);
}
/* Now that we've backtracked to it and inverted it, it is no
* longer a branch point. If there is no previous history, delete
* this node. Otherwise, convert it into a non-branch point.
* Next time we backtrack we will just delete it.
*/
if (puz->nhist == 1)
puz->nhist= 0;
else
h->branch= 0;
/* Remove everything from the job list except the lines containing
* the inverted cell.
*/
if (maylinesolve)
{
flush_jobs(puz);
add_jobs(puz, sol, -1, h->cell, 0, h->bit);
}
backtracks++;
return 0;
}
int undo(Puzzle *puz, Solution *sol, int leave_branch)
{
Hist *h;
Clue *clue;
Cell **line;
dir_t k;
int is_branch;
line_t i;
while (puz->nhist > 0)
{
h= HIST(puz, puz->nhist-1);
/* Invalidate any saved positions for lines crossing undone cell.
* We can't just have the fact that nhist < stamp mean the line is
* invalid, because we might backtrack and then advance past stamp
* again before we recheck the line.
*/
for (k= 0; k < puz->nset; k++)
{
i= h->cell->line[k];
clue= &(puz->clue[k][i]);
line= sol->line[k][i];
if ((VL && VU) || WL(*clue))
printf("U: CHECK %s %d", CLUENAME(puz->type,k),i);
left_undo(puz, clue, line, h->cell->index[k], h->bit);
right_undo(puz, clue, line, h->cell->index[k], h->bit);
if ((VL && VU) || WL(*clue)) printf("\n");
}
is_branch= h->branch;
if (!is_branch || !leave_branch)
{
/* If undoing a solved cell, decrement completion count */
if (h->cell->n == 1) solved_a_cell(puz, h->cell, -1);
/* Restore saved value */
h->cell->n= h->n;
fbit_cpy(h->cell->bit, h->bit);
if (VU || WC(h->cell))
{
printf("U: UNDOING CELL ");
for (k= 0; k < puz->nset; k++)
printf(" %d",h->cell->line[k]);
printf(" TO ");
dump_bits(stdout,puz,h->cell->bit);
printf(" (%d)\n",h->cell->n);
}
puz->nhist--;
}
if (is_branch)
return 0;
}
return 1;
}
int main(int argc, char *argv[])
{
int fd;
int res, x;
struct dahdi_params tp;
struct dahdi_bufferinfo bi;
int bs = BLOCK_SIZE;
int pos = 0;
unsigned char inbuf[BLOCK_SIZE];
unsigned char outbuf[BLOCK_SIZE];
int bytes = 0;
int out;
unsigned int olddata1;
int oldones1;
int oldbits1;
unsigned int olddata = 0;
int oldones = 0;
int oldbits = 0;
int hdlcmode = 0;
struct fasthdlc_state fs;
if (argc < 2) {
fprintf(stderr, "Usage: %s <DAHDI device>\n", argv[0]);
exit(1);
}
fd = open(argv[1], O_RDWR, 0600);
if (fd < 0) {
fprintf(stderr, "Unable to open %s: %s\n", argv[1], strerror(errno));
exit(1);
}
if (ioctl(fd, DAHDI_SET_BLOCKSIZE, &bs)) {
fprintf(stderr, "Unable to set block size to %d: %s\n", bs, strerror(errno));
exit(1);
}
if (ioctl(fd, DAHDI_GET_PARAMS, &tp)) {
fprintf(stderr, "Unable to get channel parameters\n");
exit(1);
}
if ((tp.sigtype & DAHDI_SIG_HDLCRAW) == DAHDI_SIG_HDLCRAW) {
printf("In HDLC mode\n");
hdlcmode = 1;
} else if ((tp.sigtype & DAHDI_SIG_CLEAR) == DAHDI_SIG_CLEAR) {
printf("In CLEAR mode\n");
hdlcmode = 0;
} else {
fprintf(stderr, "Not in a reasonable mode\n");
exit(1);
}
res = ioctl(fd, DAHDI_GET_BUFINFO, &bi);
if (!res) {
bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE;
bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE;
bi.numbufs = 4;
res = ioctl(fd, DAHDI_SET_BUFINFO, &bi);
if (res < 0) {
fprintf(stderr, "Unable to set buf info: %s\n", strerror(errno));
exit(1);
}
} else {
fprintf(stderr, "Unable to get buf info: %s\n", strerror(errno));
exit(1);
}
ioctl(fd, DAHDI_GETEVENT);
fasthdlc_precalc();
fasthdlc_init(&fs, FASTHDLC_MODE_64);
for (;;) {
res = read(fd, outbuf, sizeof(outbuf));
if (hdlcmode) {
if (res < 0) {
if (errno == ELAST) {
if (ioctl(fd, DAHDI_GETEVENT, &x) < 0) {
fprintf(stderr, "Unaable to get event: %s\n", strerror(errno));
exit(1);
}
fprintf(stderr, "Event: %d (%d bytes since last error)\n", x, bytes);
bytes = 0;
continue;
} else {
fprintf(stderr, "Error: %s\n", strerror(errno));
exit(1);
}
}
#if 0
printf("Res is %d, buf0 is %d, buf1 is %d\n", res, outbuf[0], outbuf[1]);
#endif
if (res < 2) {
fprintf(stderr, "Too small? Only got %d bytes\n", res);
}
check_frame(outbuf, res);
} else {
for (x = 0; x < res; x++) {
oldones1 = oldones;
oldbits1 = oldbits;
olddata1 = olddata;
oldones = fs.ones;
oldbits = fs.bits;
olddata = fs.data;
fasthdlc_rx_load(&fs, outbuf[x]);
out = fasthdlc_rx_run(&fs);
if (out & RETURN_EMPTY_FLAG) {
/* Empty */
} else if (out & RETURN_COMPLETE_FLAG) {
if (pos && (pos < 2)) {
printf("Too short? (%d)\n", pos);
} else if (pos) {
check_frame(inbuf, pos);
}
pos = 0;
} else if (out & RETURN_DISCARD_FLAG) {
printf("Discard (search = %d, len = %d, buf = %d, x=%d, res=%d, oldones: %d, oldbits: %d)\n",
c, pos, inbuf[0], x, res, oldones, oldbits);
dump_bitslong(olddata, oldbits);
printf("Discard oldones: %d, oldbits: %d)\n",
oldones1, oldbits1);
dump_bitslong(olddata1, oldbits1);
if (x > 64) {
dump_bits(outbuf + x - 64, 64);
dump_bits(outbuf + x, 64);
}
pos = 0;
} else {
if ((out != c) && (pos < c) && !pos) {
printf("Warning: Expecting %d at pos %d, got %d (x =%d)\n", c, pos, out, x);
if (x > 64) {
dump_bits(outbuf + x - 64, 64);
dump_bits(outbuf + x, 64);
}
}
inbuf[pos++] = out;
}
}
}
}
}
void merge_set(Puzzle *puz, Cell *cell, bit_type *bit)
{
MergeElem *m;
// MergeElem *p;
// color_t z;
// int zero;
/* Get the merge element for this cell */
m= &mergegrid[cell->id];
if (m->cell == NULL)
{
/* If this is not the first guess, and the cell is not already on the
* list, do nothing. */
if (merge_no > 0) return;
/* Otherwise, make a new merge list entry */
m->cell= cell;
m->maxc= merge_no;
#ifdef LIMITCOLORS
m->bit[0]= cell->bit[0] & ~bit[0];
#else
for (z= 0; z < fbit_size; z++)
m->bit[z]= cell->bit[z] & ~bit[z];
#endif
m->next= merge_list;
merge_list= m;
if (VM)
{
printf("M: NEW MERGE CELL (%d,%d) L%d BITS ",
m->cell->line[0], m->cell->line[1], merge_no);
dump_bits(stdout, puz, m->bit);
printf("\n");
}
return;
}
if (m->maxc == merge_no)
{
/* If cell has already been updated on this pass, and this is not
* pass zero, then we can't record the change correctly, so we don't
* record them. We might miss some merges this way, but this is a
* really rare occurance that happens only on really successful probes,
* which are likely to be our next guess anyway.
*/
if (merge_no == 0)
/* If this is pass zero, the we can OR the changes in because
* we haven't ANDed it with anything else yet */
m->bit[0]|= cell->bit[0] & ~bit[0];
if (VM)
{
printf("M: REVISITING MERGE CELL (%d,%d) L%d BITS ",
m->cell->line[0], m->cell->line[1], merge_no);
dump_bits(stdout, puz, m->bit);
printf("\n");
}
return;
}
/* If the cell is on the list from previous probe, intersect the changes */
#ifdef LIMITCOLORS
m->bit[0]&= cell->bit[0] & ~bit[0];
if (m->bit[0] == 0)
#else
zero= 1;
for (z= 0; z < fbit_size; z++)
{
m->bit[z]&= cell->bit[z] & ~bit[z];
if (m->bit[z]) zero= 0;
}
if (zero)
#endif
{
/* No intersection - mark the node for deletion. Actual
* deletion from linked list happens during merge_guess. */
if (VM) printf("M: DROPPING MERGE CELL (%d,%d) L%d\n",
m->cell->line[0], m->cell->line[1], merge_no);
m->cell= NULL;
}
else
{
/* Had some intersection - keep the node */
m->maxc= merge_no;
if (VM)
{
printf("M: UPDATING MERGE CELL (%d,%d) L%d BITS ",
m->cell->line[0], m->cell->line[1], merge_no);
dump_bits(stdout, puz, m->bit);
printf("\n");
}
}
}
