taglinefilesource code
st168arch/i386/math-emu/errors.cFPU_REG *r = &st(i);
st614arch/i386/math-emu/errors.creg_move(&CONST_QNaN, &st(0));
st630arch/i386/math-emu/errors.creg_move(&CONST_QNaN, &st(0));
st646arch/i386/math-emu/errors.creg_move(&CONST_QNaN, &(st(i)));
st662arch/i386/math-emu/errors.creg_move(&CONST_QNaN, &(st(i)));
st23arch/i386/math-emu/fpu_arith.creg_add(&st(0), &st(FPU_rm), &st(0), control_word);
st31arch/i386/math-emu/fpu_arith.creg_mul(&st(0), &st(FPU_rm), &st(0), control_word);
st40arch/i386/math-emu/fpu_arith.creg_sub(&st(0), &st(FPU_rm), &st(0), control_word);
st48arch/i386/math-emu/fpu_arith.creg_sub(&st(FPU_rm), &st(0), &st(0), control_word);
st56arch/i386/math-emu/fpu_arith.creg_div(&st(0), &st(FPU_rm), &st(0), control_word);
st64arch/i386/math-emu/fpu_arith.creg_div(&st(FPU_rm), &st(0), &st(0), control_word);
st73arch/i386/math-emu/fpu_arith.creg_add(&st(0), &st(FPU_rm), &st(FPU_rm), control_word);
st81arch/i386/math-emu/fpu_arith.creg_mul(&st(0), &st(FPU_rm), &st(FPU_rm), control_word);
st91arch/i386/math-emu/fpu_arith.creg_sub(&st(0), &st(FPU_rm), &st(FPU_rm), control_word);
st101arch/i386/math-emu/fpu_arith.creg_sub(&st(FPU_rm), &st(0), &st(FPU_rm), control_word);
st109arch/i386/math-emu/fpu_arith.creg_div(&st(0), &st(FPU_rm), &st(FPU_rm), control_word);
st117arch/i386/math-emu/fpu_arith.creg_div(&st(FPU_rm), &st(0), &st(FPU_rm), control_word);
st126arch/i386/math-emu/fpu_arith.cif ( !reg_add(&st(0), &st(FPU_rm), &st(FPU_rm), control_word) )
st135arch/i386/math-emu/fpu_arith.cif ( !reg_mul(&st(0), &st(FPU_rm), &st(FPU_rm), control_word) )
st147arch/i386/math-emu/fpu_arith.cif ( !reg_sub(&st(0), &st(FPU_rm), &st(FPU_rm), control_word) )
st158arch/i386/math-emu/fpu_arith.cif ( !reg_sub(&st(FPU_rm), &st(0), &st(FPU_rm), control_word) )
st167arch/i386/math-emu/fpu_arith.cif ( !reg_div(&st(0), &st(FPU_rm), &st(FPU_rm), control_word) )
st176arch/i386/math-emu/fpu_arith.cif ( !reg_div(&st(FPU_rm), &st(0), &st(FPU_rm), control_word) )
st108arch/i386/math-emu/fpu_aux.c{ reg_move(&st(FPU_rm), st_new_ptr); push(); }
st127arch/i386/math-emu/fpu_aux.cregister FPU_REG *sti_ptr = &st(FPU_rm), *st0_ptr = &st(0);
st159arch/i386/math-emu/fpu_aux.cst(FPU_rm).tag = TW_Empty;
st166arch/i386/math-emu/fpu_aux.cst(FPU_rm).tag = TW_Empty;
st174arch/i386/math-emu/fpu_aux.creg_move(&st(0), &st(FPU_rm));
st181arch/i386/math-emu/fpu_aux.creg_move(&st(0), &st(FPU_rm));
st122arch/i386/math-emu/fpu_emu.h#define  STACK_OVERFLOW  (st_new_ptr = &st(-1), st_new_ptr->tag != TW_Empty)
st123arch/i386/math-emu/fpu_emu.h#define  NOT_EMPTY(i)  (st(i).tag != TW_Empty)
st342arch/i386/math-emu/fpu_entry.cst0_ptr = &st(0);
st519arch/i386/math-emu/fpu_entry.cst0_ptr = &st(0);
st128arch/i386/math-emu/fpu_etc.c(fp_etc_table[FPU_rm])(&st(0));
st210arch/i386/math-emu/fpu_trig.cst_new_ptr = &st(-1);
st212arch/i386/math-emu/fpu_trig.creg_move(&st(1), st_new_ptr);
st218arch/i386/math-emu/fpu_trig.cst_new_ptr = &st(-1);
st220arch/i386/math-emu/fpu_trig.creg_move(&st(1), st_new_ptr);
st292arch/i386/math-emu/fpu_trig.cst_new_ptr = &st(-1);
st349arch/i386/math-emu/fpu_trig.cst_new_ptr = &st(-1);
st692arch/i386/math-emu/fpu_trig.cst_new_ptr = &st(-1);
st765arch/i386/math-emu/fpu_trig.cFPU_REG *st1_ptr = &st(1);
st984arch/i386/math-emu/fpu_trig.cFPU_REG *st1_ptr = &st(1), exponent;
st1103arch/i386/math-emu/fpu_trig.cpop(); st0_ptr = &st(0);
st1128arch/i386/math-emu/fpu_trig.cpop(); st0_ptr = &st(0);
st1194arch/i386/math-emu/fpu_trig.cFPU_REG *st1_ptr = &st(1);
st1334arch/i386/math-emu/fpu_trig.cFPU_REG *st1_ptr = &st(1);
st1547arch/i386/math-emu/fpu_trig.cFPU_REG *st1_ptr = &st(1);
st1706arch/i386/math-emu/fpu_trig.c(trig_table_a[FPU_rm])(&st(0));
st1717arch/i386/math-emu/fpu_trig.c(trig_table_b[FPU_rm])(&st(0));
st94arch/i386/math-emu/load_store.cst0_ptr = &st(0);       /* Some of these instructions pop after
st99arch/i386/math-emu/load_store.cst0_ptr = &st(-1);
st30arch/i386/math-emu/reg_compare.cst0_ptr = &st(0);
st230arch/i386/math-emu/reg_compare.cc = compare(&st(nr));
st280arch/i386/math-emu/reg_compare.cc = compare(&st(nr));
st557drivers/cdrom/aztcd.c{       int st;
st564drivers/cdrom/aztcd.c{     st = inb(DATA_PORT) & 0xFF;
st565drivers/cdrom/aztcd.creturn st;
st575drivers/cdrom/aztcd.c{       int st;
st579drivers/cdrom/aztcd.cst = inb(DATA_PORT) & 0xFF;
st581drivers/cdrom/aztcd.cprintk("aztcd: Status = %x\n",st);
st583drivers/cdrom/aztcd.cif ((st == 0xFF)||(st&AST_CMD_CHECK))
st588drivers/cdrom/aztcd.cif (((st&AST_MODE_BITS)!=AST_BUSY) && (aztAudioStatus == CDROM_AUDIO_PLAY))
st592drivers/cdrom/aztcd.cif ((st & AST_DSK_CHG)||(st & AST_NOT_READY))
st597drivers/cdrom/aztcd.creturn st;
st612drivers/cdrom/aztcd.c{       int i, st;
st676drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void*) arg, sizeof(struct cdrom_multisession));
st677drivers/cdrom/aztcd.cif (st) return st;
st689drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void*) arg, sizeof(struct cdrom_multisession));
st690drivers/cdrom/aztcd.cif (st) return st;
st706drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof ti);
st707drivers/cdrom/aztcd.cif (st) return st;
st737drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof msf);
st738drivers/cdrom/aztcd.cif (st) return st;
st767drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof tocHdr);
st768drivers/cdrom/aztcd.cif (st) return st;
st774drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof entry);
st775drivers/cdrom/aztcd.cif (st) return st;
st776drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof entry);
st777drivers/cdrom/aztcd.cif (st) return st;
st803drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_subchnl));
st804drivers/cdrom/aztcd.cif (st) { 
st808drivers/cdrom/aztcd.creturn st;
st810drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof(struct cdrom_subchnl));
st811drivers/cdrom/aztcd.cif (st) { 
st815drivers/cdrom/aztcd.creturn st;
st819drivers/cdrom/aztcd.cif (st) { 
st849drivers/cdrom/aztcd.cst=verify_area(VERIFY_READ,(void *) arg, sizeof(volctrl));
st850drivers/cdrom/aztcd.cif (st) return (st);
st889drivers/cdrom/aztcd.c{ st = verify_area(VERIFY_READ,  (void *) arg, sizeof msf);
st890drivers/cdrom/aztcd.cif (st) return st;
st891drivers/cdrom/aztcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof buf);
st892drivers/cdrom/aztcd.cif (st) return st;
st927drivers/cdrom/aztcd.cst = verify_area(VERIFY_READ,  (void *) arg, sizeof msf);
st928drivers/cdrom/aztcd.cif (st) return st;
st1040drivers/cdrom/aztcd.cint st = 0;
st1103drivers/cdrom/aztcd.cif ((st = aztStatus()) != -1) {
st1104drivers/cdrom/aztcd.cif ((st & AST_DSK_CHG)||(st & AST_NOT_READY)) {
st1115drivers/cdrom/aztcd.cif ((st & AST_DOOR_OPEN)||(st & AST_NOT_READY)) {
st1120drivers/cdrom/aztcd.cprintk((st & AST_DOOR_OPEN) ? "aztcd: door open\n" : "aztcd: disk removed\n");
st1153drivers/cdrom/aztcd.cif ((st = aztStatus()) != -1) {
st1154drivers/cdrom/aztcd.cif ((st & AST_DSK_CHG)||(st & AST_NOT_READY)) {
st1165drivers/cdrom/aztcd.cif ((st & AST_DOOR_OPEN)||(st & AST_NOT_READY)) {
st1168drivers/cdrom/aztcd.cprintk((st & AST_DOOR_OPEN) ? "aztcd: door open\n" : "aztcd: disk removed\n");
st1237drivers/cdrom/aztcd.cst = inb(STATUS_PORT) & AFL_STATUSorDATA;   /*???*/
st1239drivers/cdrom/aztcd.cswitch (st) {
st1243drivers/cdrom/aztcd.cif (st!=azt_st_old)  {
st1244drivers/cdrom/aztcd.cazt_st_old=st; 
st1245drivers/cdrom/aztcd.cprintk("---AFL_DATA st:%x\n",st);
st1265drivers/cdrom/aztcd.cif (st!=azt_st_old)  {
st1266drivers/cdrom/aztcd.cazt_st_old=st;
st1267drivers/cdrom/aztcd.cprintk("---AFL_STATUSorDATA st:%x\n",st);
st1274drivers/cdrom/aztcd.cif (st!=azt_st_old)  {
st1275drivers/cdrom/aztcd.cazt_st_old=st;
st1276drivers/cdrom/aztcd.cprintk("---default: st:%x\n",st);
st1384drivers/cdrom/aztcd.cif ((st = aztStatus()) == -1 && AztTimeout)
st1387drivers/cdrom/aztcd.cif ((st != -1) && ((st & AST_DSK_CHG)||(st & AST_NOT_READY))) {
st1402drivers/cdrom/aztcd.cif (st != -1) {
st1456drivers/cdrom/aztcd.c{       int st;
st1467drivers/cdrom/aztcd.cst = getAztStatus();                    /* check drive status */
st1468drivers/cdrom/aztcd.cif (st == -1) return -EIO;              /* drive doesn't respond */
st1470drivers/cdrom/aztcd.cif (st & AST_DOOR_OPEN)
st1474drivers/cdrom/aztcd.cst = getAztStatus();
st1477drivers/cdrom/aztcd.cif ((st & AST_NOT_READY) || (st & AST_DSK_CHG)) /*no disk in drive or changed*/
st1542drivers/cdrom/aztcd.cint st;
st1617drivers/cdrom/aztcd.cif ((st=getAztStatus())==-1)
st1618drivers/cdrom/aztcd.c{ printk("aztcd: Drive Status Error Status=%x\n",st);
st1622drivers/cdrom/aztcd.cprintk("aztcd: Status = %x\n",st);
st1748drivers/cdrom/aztcd.cint st;
st1753drivers/cdrom/aztcd.cif ((st=getAztStatus())==-1)        RETURNM("aztGetQChannelInfo 1",-1);
st1757drivers/cdrom/aztcd.cif ((st&AST_MODE_BITS)==AST_INITIAL)
st1791drivers/cdrom/aztcd.c{       int st;
st1824drivers/cdrom/aztcd.cfor (st=0;st<CD_FRAMESIZE;st++) inb(DATA_PORT);
st899drivers/cdrom/cm206.cint st;
st902drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, 
st904drivers/cdrom/cm206.cif (st) return (st);
st930drivers/cdrom/cm206.cint st;
st932drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(header));
st933drivers/cdrom/cm206.cif (st) return (st);
st942drivers/cdrom/cm206.cint st;
st944drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(entry));
st945drivers/cdrom/cm206.cif (st) return (st);
st953drivers/cdrom/cm206.cint st;
st955drivers/cdrom/cm206.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(msf));
st956drivers/cdrom/cm206.cif (st) return (st);
st963drivers/cdrom/cm206.cint st;
st965drivers/cdrom/cm206.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(track_index));
st966drivers/cdrom/cm206.cif (st) return (st);
st1000drivers/cdrom/cm206.cint st;
st1002drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(q));
st1003drivers/cdrom/cm206.cif (st) return (st);
st1013drivers/cdrom/cm206.cint st;
st1015drivers/cdrom/cm206.cst=verify_area(VERIFY_WRITE, (void *) arg, 8);
st1016drivers/cdrom/cm206.cif (st) return (st);
st364drivers/cdrom/gscd.cint   st;
st374drivers/cdrom/gscd.cst = disk_state & (ST_NO_DISK | ST_DOOR_OPEN);
st375drivers/cdrom/gscd.cif ( st )
st238drivers/cdrom/mcd.cint st, retry;
st244drivers/cdrom/mcd.cst = getMcdStatus(MCD_STATUS_DELAY);
st245drivers/cdrom/mcd.cif (st != -1)
st249drivers/cdrom/mcd.creturn st;
st260drivers/cdrom/mcd.cint retry, st;
st265drivers/cdrom/mcd.cst = getMcdStatus(2 * MCD_STATUS_DELAY);
st266drivers/cdrom/mcd.cif (st != -1)
st270drivers/cdrom/mcd.creturn st;
st288drivers/cdrom/mcd.cint i, st;
st301drivers/cdrom/mcd.cst = statusCmd();
st302drivers/cdrom/mcd.cif (st < 0)
st369drivers/cdrom/mcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof ti);
st370drivers/cdrom/mcd.cif (st)
st371drivers/cdrom/mcd.creturn st;
st412drivers/cdrom/mcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof msf);
st413drivers/cdrom/mcd.cif (st)
st414drivers/cdrom/mcd.creturn st;
st451drivers/cdrom/mcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof tocHdr);
st452drivers/cdrom/mcd.cif (st)
st453drivers/cdrom/mcd.creturn st;
st462drivers/cdrom/mcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof entry);
st463drivers/cdrom/mcd.cif (st)
st464drivers/cdrom/mcd.creturn st;
st499drivers/cdrom/mcd.cst = verify_area(VERIFY_WRITE, (void *) arg, sizeof subchnl);
st500drivers/cdrom/mcd.cif (st)
st501drivers/cdrom/mcd.creturn st;
st538drivers/cdrom/mcd.cst = verify_area(VERIFY_READ, (void *) arg, sizeof(volctrl));
st539drivers/cdrom/mcd.cif (st)
st540drivers/cdrom/mcd.creturn st;
st634drivers/cdrom/mcd.cint st;
st636drivers/cdrom/mcd.cst = inb(MCDPORT(1)) & 0xFF;
st638drivers/cdrom/mcd.cprintk("<int1-%02X>", st);
st640drivers/cdrom/mcd.cif (!(st & MFL_STATUS))
st642drivers/cdrom/mcd.cst = inb(MCDPORT(0)) & 0xFF;
st644drivers/cdrom/mcd.cprintk("<int0-%02X>", st);
st646drivers/cdrom/mcd.cif ((st & 0xFF) != 0xFF)
st647drivers/cdrom/mcd.cmcd_error = st ? st & 0xFF : -1;
st695drivers/cdrom/mcd.cint st;
st796drivers/cdrom/mcd.cif ((st = mcdStatus()) != -1) {
st798drivers/cdrom/mcd.cif (st & MST_DSK_CHG) {
st806drivers/cdrom/mcd.cif ((st & MST_DOOR_OPEN) || !(st & MST_READY)) {
st813drivers/cdrom/mcd.cprintk((st & MST_DOOR_OPEN) ? "mcd: door open\n" : "mcd: disk removed\n");
st836drivers/cdrom/mcd.cif ((st = mcdStatus()) != -1) {
st838drivers/cdrom/mcd.cif (st & MST_DSK_CHG) {
st846drivers/cdrom/mcd.cif ((st & MST_DOOR_OPEN) || !(st & MST_READY)) {
st853drivers/cdrom/mcd.cprintk((st & MST_DOOR_OPEN) ? "mcd: door open\n" : "mcd: disk removed\n");
st884drivers/cdrom/mcd.cst = inb(MCDPORT(1)) & (MFL_STATUSorDATA);
st887drivers/cdrom/mcd.cprintk("Status %02x\n",st);
st889drivers/cdrom/mcd.cswitch (st) {
st949drivers/cdrom/mcd.cif ((st = (inb(MCDPORT(1))) & (MFL_STATUSorDATA)) != (MFL_STATUSorDATA)) {
st1016drivers/cdrom/mcd.cif ((st = mcdStatus()) == -1 && McdTimeout)
st1019drivers/cdrom/mcd.cif ((st != -1) && (st & MST_DSK_CHG)) {
st1037drivers/cdrom/mcd.cst = -1;
st1048drivers/cdrom/mcd.cif (st != -1) {
st1096drivers/cdrom/mcd.cint st;
st1108drivers/cdrom/mcd.cst = statusCmd();      /* check drive status */
st1109drivers/cdrom/mcd.cif (st == -1)
st1112drivers/cdrom/mcd.cif ((st & MST_READY) == 0)    /* no disk in drive */
st1303drivers/cdrom/mcd.cint st;
st1305drivers/cdrom/mcd.cst = inb(MCDPORT(1)) & MFL_STATUS;
st1306drivers/cdrom/mcd.cif (!st)
st1367drivers/cdrom/mcd.cint st;
st1375drivers/cdrom/mcd.cst = inb(MCDPORT(0)) & 0xFF;
st1376drivers/cdrom/mcd.cif (st == 0xFF)
st1379drivers/cdrom/mcd.cif ((st & MST_BUSY) == 0 && audioStatus == CDROM_AUDIO_PLAY)
st1383drivers/cdrom/mcd.cif (st & MST_DSK_CHG)
st1390drivers/cdrom/mcd.creturn st;
st926drivers/cdrom/mcdx.cint st;
st953drivers/cdrom/mcdx.cfor (st = -1; st == -1 && tries; tries--) {
st967drivers/cdrom/mcdx.cst = *bp;
st971drivers/cdrom/mcdx.cTRACE((TALK, "talk() got status 0x%02x\n", st));
st974drivers/cdrom/mcdx.cif (e_cmderr(st)) {
st977drivers/cdrom/mcdx.cst = -1;
st984drivers/cdrom/mcdx.ce_audiobusy(st) ? CDROM_AUDIO_PLAY : CDROM_AUDIO_NO_STATUS;
st986drivers/cdrom/mcdx.c&& e_audiobusy(st) == 0)
st990drivers/cdrom/mcdx.cif (e_changed(st)) {
st1000drivers/cdrom/mcdx.cst = -1; break;
st1008drivers/cdrom/mcdx.cif (!tries && st == -1) INFO(("talk() giving up\n"));
st1014drivers/cdrom/mcdx.cTRACE((TALK, "talk() done with 0x%02x\n", st));
st1015drivers/cdrom/mcdx.creturn st;
st990drivers/cdrom/sbpcd.cint i,j,st=0;
st999drivers/cdrom/sbpcd.cst=inb(CDi_status);
st1000drivers/cdrom/sbpcd.cif (!(st&s_not_result_ready)) break;
st1026drivers/cdrom/sbpcd.cstatic void EvaluateStatus(int st)
st1029drivers/cdrom/sbpcd.cif (fam1_drive) D_S[d].status_bits=st|p_success;
st1032drivers/cdrom/sbpcd.cif (st&p_caddin_old) D_S[d].status_bits |= p_door_closed|p_caddy_in;
st1033drivers/cdrom/sbpcd.cif (st&p_spinning) D_S[d].status_bits |= p_spinning;
st1034drivers/cdrom/sbpcd.cif (st&p_check) D_S[d].status_bits |= p_check;
st1035drivers/cdrom/sbpcd.cif (st&p_success_old) D_S[d].status_bits |= p_success;
st1036drivers/cdrom/sbpcd.cif (st&p_busy_old) D_S[d].status_bits |= p_busy_new;
st1037drivers/cdrom/sbpcd.cif (st&p_disk_ok) D_S[d].status_bits |= p_disk_ok;
st1042drivers/cdrom/sbpcd.cif (st&p_caddin_old) D_S[d].status_bits |= p_disk_ok|p_caddy_in;
st1043drivers/cdrom/sbpcd.cif (st&p_spinning) D_S[d].status_bits |= p_spinning;
st1044drivers/cdrom/sbpcd.cif (st&p_check) D_S[d].status_bits |= p_check;
st1045drivers/cdrom/sbpcd.cif (st&p_busy_old) D_S[d].status_bits |= p_busy_new;
st1046drivers/cdrom/sbpcd.cif (st&p_lcs_door_closed) D_S[d].status_bits |= p_door_closed;
st1047drivers/cdrom/sbpcd.cif (st&p_lcs_door_locked) D_S[d].status_bits |= p_door_locked;
st1052drivers/cdrom/sbpcd.cif (st&p2_check) D_S[d].status_bits |= p1_check;
st1053drivers/cdrom/sbpcd.cif (st&p2_door_closed) D_S[d].status_bits |= p1_door_closed;
st1054drivers/cdrom/sbpcd.cif (st&p2_disk_in) D_S[d].status_bits |= p1_disk_in;
st1055drivers/cdrom/sbpcd.cif (st&p2_busy1) D_S[d].status_bits |= p1_busy;
st1056drivers/cdrom/sbpcd.cif (st&p2_busy2) D_S[d].status_bits |= p1_busy;
st1057drivers/cdrom/sbpcd.cif (st&p2_spinning) D_S[d].status_bits |= p1_spinning;
st1058drivers/cdrom/sbpcd.cif (st&p2_door_locked) D_S[d].status_bits |= p1_door_locked;
st1059drivers/cdrom/sbpcd.cif (st&p2_disk_ok) D_S[d].status_bits |= p1_disk_ok;
st1065drivers/cdrom/sbpcd.cif (st&p2_check) D_S[d].status_bits |= p1_check;
st1066drivers/cdrom/sbpcd.cif (st&p2_door_closed) D_S[d].status_bits |= p1_door_closed;
st1067drivers/cdrom/sbpcd.cif (st&p2_disk_in) D_S[d].status_bits |= p1_disk_in;
st1068drivers/cdrom/sbpcd.cif (st&p2_busy1) D_S[d].status_bits |= p1_busy;
st1069drivers/cdrom/sbpcd.cif (st&p2_busy2) D_S[d].status_bits |= p1_busy;
st1070drivers/cdrom/sbpcd.cif (st&p2_spinning) D_S[d].status_bits |= p1_spinning;
st1071drivers/cdrom/sbpcd.cif (st&p2_door_locked) D_S[d].status_bits |= p1_door_locked;
st1072drivers/cdrom/sbpcd.cif (st&p2_disk_ok) D_S[d].status_bits |= p1_disk_ok;
st3786drivers/cdrom/sbpcd.cint st;
st3788drivers/cdrom/sbpcd.cst=ResponseStatus();
st3789drivers/cdrom/sbpcd.cif (st<0)
st3834drivers/cdrom/sbpcd.cint i, st;
st3848drivers/cdrom/sbpcd.cst=GetStatus();
st3849drivers/cdrom/sbpcd.cif (st<0) return (-EIO);
st3917drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_msf));
st3918drivers/cdrom/sbpcd.cif (st) return (st);
st3945drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ,(void *) arg,sizeof(struct cdrom_ti));
st3946drivers/cdrom/sbpcd.cif (st<0)
st3949drivers/cdrom/sbpcd.creturn (st);
st3971drivers/cdrom/sbpcd.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(struct cdrom_tochdr));
st3972drivers/cdrom/sbpcd.cif (st) return (st);
st3978drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_tocentry));
st3979drivers/cdrom/sbpcd.cif (st) return (st);
st3996drivers/cdrom/sbpcd.cst=verify_area(VERIFY_WRITE,(void *) arg, sizeof(struct cdrom_tocentry));
st3997drivers/cdrom/sbpcd.cif (st) return (st);
st4042drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ,(void *) arg,sizeof(volctrl));
st4043drivers/cdrom/sbpcd.cif (st) return (st);
st4054drivers/cdrom/sbpcd.cst=verify_area(VERIFY_WRITE,(void *)arg,sizeof(volctrl));
st4055drivers/cdrom/sbpcd.cif (st) return (st);
st4056drivers/cdrom/sbpcd.cst=cc_GetVolume();
st4057drivers/cdrom/sbpcd.cif (st<0) return (st);
st4070drivers/cdrom/sbpcd.cst=verify_area(VERIFY_WRITE, (void *) arg, sizeof(struct cdrom_subchnl));
st4071drivers/cdrom/sbpcd.cif (st)  return (st);
st4072drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_subchnl));
st4073drivers/cdrom/sbpcd.cif (st) return (st);
st4358drivers/cdrom/sbpcd.cst=verify_area(VERIFY_READ, (void *) arg, sizeof(struct cdrom_multisession));
st4359drivers/cdrom/sbpcd.cif (st) return (st);
st4368drivers/cdrom/sbpcd.cst=verify_area(VERIFY_WRITE,(void *) arg, sizeof(struct cdrom_multisession));
st4369drivers/cdrom/sbpcd.cif (st) return (st);
st5401drivers/cdrom/sbpcd.cint i, st;
st5416drivers/cdrom/sbpcd.cst=ResponseStatus();
st5418drivers/cdrom/sbpcd.cif (st<0)
st114drivers/char/ftape/fdc-isr.cdecode_irq_cause(fdc_mode_enum fdc_mode, byte st[],
st122drivers/char/ftape/fdc-isr.cswitch (st[0] & ST0_INT_MASK) {
st131drivers/char/ftape/fdc-isr.cst[0], st[1], st[2]);
st133drivers/char/ftape/fdc-isr.cst[3], st[4], st[5], st[6]);
st134drivers/char/ftape/fdc-isr.cif (st[1] & 0x01) {
st135drivers/char/ftape/fdc-isr.cif (st[2] & 0x01) {
st140drivers/char/ftape/fdc-isr.c} else if (st[1] & 0x20) {
st141drivers/char/ftape/fdc-isr.cif (st[2] & 0x20) {
st146drivers/char/ftape/fdc-isr.c} else if (st[1] & 0x04) {
st148drivers/char/ftape/fdc-isr.c} else if (st[1] & 0x10) {
st832drivers/isdn/isdn_common.cstatic int isdn_select(struct inode *inode, struct file *file, int type, select_table * st)
st840drivers/isdn/isdn_common.cif (st)
st841drivers/isdn/isdn_common.cselect_wait(&(dev->info_waitq), st);
st849drivers/isdn/isdn_common.creturn (isdn_ppp_select(minor - ISDN_MINOR_PPP, file, type, st));
st362drivers/isdn/isdn_ppp.cint isdn_ppp_select(int minor, struct file *file, int type, select_table * st)
st381drivers/isdn/isdn_ppp.cselect_wait(&ippp_table[minor].wq, st);
st392drivers/isdn/isdn_ppp.cselect_wait(&ippp_table[minor].wq1, st);
st602drivers/isdn/teles/callc.clf->st->ma.manl1(lf->st, PH_ACTIVATE, NULL);
st624drivers/isdn/teles/callc.clf->st->ma.manl2(lf->st, DL_ESTABLISH, NULL);
st647drivers/isdn/teles/callc.clf->st->ma.manl2(lf->st, DL_RELEASE, NULL);
st650drivers/isdn/teles/callc.clf->st->ma.manl1(lf->st, PH_DEACTIVATE, NULL);
st661drivers/isdn/teles/callc.clf->st->ma.manl1(lf->st, PH_DEACTIVATE, NULL);
st706drivers/isdn/teles/callc.cstruct PStack  *st = &chanlist[chan].ds;
st710drivers/isdn/teles/callc.csp = st->l1.hardware;
st717drivers/isdn/teles/callc.creleasestack_isdnl2(st);
st720drivers/isdn/teles/callc.creleasestack_transl2(st);
st726drivers/isdn/teles/callc.ccc_l1man(struct PStack *st, int pr, void *arg)
st728drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st741drivers/isdn/teles/callc.ccc_l2man(struct PStack *st, int pr, void *arg)
st743drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st756drivers/isdn/teles/callc.cdcc_l1man(struct PStack *st, int pr, void *arg)
st758drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st771drivers/isdn/teles/callc.cdcc_l2man(struct PStack *st, int pr, void *arg)
st773drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st786drivers/isdn/teles/callc.cll_handler(struct PStack *st, int pr,
st789drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st819drivers/isdn/teles/callc.cstruct PStack  *st = &(chanlist[chan].is);
st823drivers/isdn/teles/callc.csetstack_teles(st, sp);
st825drivers/isdn/teles/callc.cst->l2.sap = 0;
st827drivers/isdn/teles/callc.cst->l2.tei = 255;
st829drivers/isdn/teles/callc.cst->l2.ces = ces;
st830drivers/isdn/teles/callc.cst->l2.extended = !0;
st831drivers/isdn/teles/callc.cst->l2.laptype = LAPD;
st832drivers/isdn/teles/callc.cst->l2.window = 1;
st833drivers/isdn/teles/callc.cst->l2.orig = !0;
st834drivers/isdn/teles/callc.cst->l2.t200 = 1000;               /* 1000 milliseconds  */
st835drivers/isdn/teles/callc.cif (st->protocol == ISDN_PTYPE_1TR6) {
st836drivers/isdn/teles/callc.cst->l2.n200 = 3;          /* try 3 times        */
st837drivers/isdn/teles/callc.cst->l2.t203 = 10000;      /* 10000 milliseconds */
st839drivers/isdn/teles/callc.cst->l2.n200 = 4;          /* try 4 times        */
st840drivers/isdn/teles/callc.cst->l2.t203 = 5000;       /* 5000 milliseconds  */
st844drivers/isdn/teles/callc.csetstack_isdnl2(st, tmp);
st845drivers/isdn/teles/callc.csetstack_isdnl3(st);
st846drivers/isdn/teles/callc.cst->l2.debug = 2;
st847drivers/isdn/teles/callc.cst->l3.debug = 2;
st848drivers/isdn/teles/callc.cst->l2.debug = 0xff;
st849drivers/isdn/teles/callc.cst->l3.debug = 0xff;
st850drivers/isdn/teles/callc.cst->l4.userdata = chanlist + chan;
st851drivers/isdn/teles/callc.cst->l4.l2writewakeup = NULL;
st853drivers/isdn/teles/callc.cst->l3.l3l4 = ll_handler;
st854drivers/isdn/teles/callc.cst->l1.l1man = cc_l1man;
st855drivers/isdn/teles/callc.cst->l2.l2man = cc_l2man;
st857drivers/isdn/teles/callc.cst->pa = &chanlist[chan].para;
st858drivers/isdn/teles/callc.cteles_addlist(sp, st);
st951drivers/isdn/teles/callc.cchanp->lc_d.st = &chanp->is;
st964drivers/isdn/teles/callc.cchanp->lc_b.st = &chanp->ds;
st1004drivers/isdn/teles/callc.cstruct PStack  *st = &chanlist[chan].is;
st1006drivers/isdn/teles/callc.creleasestack_isdnl2(st);
st1007drivers/isdn/teles/callc.cteles_rmlist(st->l1.hardware, st);
st1008drivers/isdn/teles/callc.cBufQueueRelease(&st->l2.i_queue);
st1031drivers/isdn/teles/callc.clldata_handler(struct PStack *st, int pr,
st1034drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st1056drivers/isdn/teles/callc.clltrans_handler(struct PStack *st, int pr,
st1059drivers/isdn/teles/callc.cstruct Channel *chanp = (struct Channel *) st->l4.userdata;
st1077drivers/isdn/teles/callc.cll_writewakeup(struct PStack *st)
st1079drivers/isdn/teles/callc.cstruct Channel *chanp = st->l4.userdata;
st1091drivers/isdn/teles/callc.cstruct PStack  *st = &(chanlist[chan].ds);
st1097drivers/isdn/teles/callc.cst->l1.hardware = sp;
st1102drivers/isdn/teles/callc.cif (setstack_hscx(st, hsp))
st1105drivers/isdn/teles/callc.cst->l2.extended = 0;
st1106drivers/isdn/teles/callc.cst->l2.laptype = LAPB;
st1107drivers/isdn/teles/callc.cst->l2.orig = !incoming;
st1108drivers/isdn/teles/callc.cst->l2.t200 = 1000;        /* 1000 milliseconds */
st1109drivers/isdn/teles/callc.cst->l2.window = 3;
st1110drivers/isdn/teles/callc.cst->l2.n200 = 4;           /* try 4 times       */
st1111drivers/isdn/teles/callc.cst->l2.t203 = 5000;        /* 5000 milliseconds */
st1113drivers/isdn/teles/callc.cst->l2.debug = 0xff;
st1114drivers/isdn/teles/callc.cst->l3.debug = 0xff;
st1118drivers/isdn/teles/callc.csetstack_isdnl2(st, tmp);
st1119drivers/isdn/teles/callc.cst->l2.l2l3 = lldata_handler;
st1120drivers/isdn/teles/callc.cst->l1.l1man = dcc_l1man;
st1121drivers/isdn/teles/callc.cst->l2.l2man = dcc_l2man;
st1122drivers/isdn/teles/callc.cst->l4.userdata = chanlist + chan;
st1123drivers/isdn/teles/callc.cst->l4.l1writewakeup = NULL;
st1124drivers/isdn/teles/callc.cst->l4.l2writewakeup = ll_writewakeup;
st1125drivers/isdn/teles/callc.cst->l2.l2m.debug = debugflags & 16;
st1126drivers/isdn/teles/callc.cst->ma.manl2(st, MDL_NOTEIPROC, NULL);
st1127drivers/isdn/teles/callc.cst->l1.hscxmode = 2;        /* Packet-Mode ? */
st1128drivers/isdn/teles/callc.cst->l1.hscxchannel = chanlist[chan].para.bchannel - 1;
st1131drivers/isdn/teles/callc.cst->l1.l1l2 = lltrans_handler;
st1132drivers/isdn/teles/callc.cst->l1.l1man = dcc_l1man;
st1133drivers/isdn/teles/callc.cst->l4.userdata = chanlist + chan;
st1134drivers/isdn/teles/callc.cst->l4.l1writewakeup = ll_writewakeup;
st1135drivers/isdn/teles/callc.cst->l1.hscxmode = 2;
st1136drivers/isdn/teles/callc.cst->l1.hscxchannel = chanlist[chan].para.bchannel - 1;
st1269drivers/isdn/teles/callc.cstruct PStack  *st = &chanp->ds;
st1274drivers/isdn/teles/callc.cerr = BufPoolGet(&ibh, st->l1.sbufpool, GFP_ATOMIC, st, 21);
st1284drivers/isdn/teles/callc.ci = st->l2.ihsize;
st23drivers/isdn/teles/card.cextern void     tei_handler(struct PStack *st, byte pr,
st483drivers/isdn/teles/card.cif (hsp->st->l4.l1writewakeup)
st484drivers/isdn/teles/card.chsp->st->l4.l1writewakeup(hsp->st);
st614drivers/isdn/teles/card.cstruct PStack  *st;
st616drivers/isdn/teles/card.cst = sp->stlist;
st617drivers/isdn/teles/card.cwhile (st)
st618drivers/isdn/teles/card.cif (st->l1.act_state)
st621drivers/isdn/teles/card.cst = st->next;
st831drivers/isdn/teles/card.cstruct PStack  *st;
st833drivers/isdn/teles/card.cst = sp->stlist;
st834drivers/isdn/teles/card.cwhile (st) {
st835drivers/isdn/teles/card.cif (st->l1.act_state == 1) {
st836drivers/isdn/teles/card.cst->l1.act_state = 2;
st837drivers/isdn/teles/card.cst->l1.l1man(st, PH_ACTIVATE, NULL);
st839drivers/isdn/teles/card.cst = st->next;
st945drivers/isdn/teles/card.cstruct PStack  *st = hsp->st;
st950drivers/isdn/teles/card.cif (st->l1.requestpull) {
st951drivers/isdn/teles/card.cst->l1.requestpull = 0;
st952drivers/isdn/teles/card.cst->l1.l1l2(st, PH_PULL_ACK, NULL);
st971drivers/isdn/teles/card.chsp->st->l1.l1l2(hsp->st, PH_DATA, ibh);
st1295drivers/isdn/teles/card.cstruct PStack *st)
st1297drivers/isdn/teles/card.cst->next = sp->stlist;
st1298drivers/isdn/teles/card.csp->stlist = st;
st1303drivers/isdn/teles/card.cstruct PStack *st)
st1307drivers/isdn/teles/card.cif (sp->stlist == st)
st1308drivers/isdn/teles/card.csp->stlist = st->next;
st1312drivers/isdn/teles/card.cif (p->next == st) {
st1313drivers/isdn/teles/card.cp->next = st->next;
st1322drivers/isdn/teles/card.cteles_l2l1(struct PStack *st, int pr,
st1326drivers/isdn/teles/card.cst->l1.hardware;
st1352drivers/isdn/teles/card.cst->l1.requestpull = 0;
st1353drivers/isdn/teles/card.cst->l1.l1l2(st, PH_PULL_ACK, NULL);
st1355drivers/isdn/teles/card.cst->l1.requestpull = !0;
st1363drivers/isdn/teles/card.cstruct PStack  *st = sp->stlist;
st1365drivers/isdn/teles/card.cwhile (st) {
st1366drivers/isdn/teles/card.cif (st->l1.act_state)
st1368drivers/isdn/teles/card.cst = st->next;
st1374drivers/isdn/teles/card.cteles_manl1(struct PStack *st, int pr,
st1378drivers/isdn/teles/card.cst->l1.hardware;
st1386drivers/isdn/teles/card.cst->l1.act_state = 2;
st1388drivers/isdn/teles/card.cst->l1.l1man(st, PH_ACTIVATE, NULL);
st1390drivers/isdn/teles/card.cst->l1.act_state = 1;
st1397drivers/isdn/teles/card.cst->l1.act_state = 0;
st1404drivers/isdn/teles/card.cteles_l2l1discardq(struct PStack *st, int pr,
st1407drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *) st->l1.hardware;
st1420drivers/isdn/teles/card.csetstack_teles(struct PStack *st, struct IsdnCardState *sp)
st1422drivers/isdn/teles/card.cst->l1.hardware = sp;
st1423drivers/isdn/teles/card.cst->l1.sbufpool = &(sp->sbufpool);
st1424drivers/isdn/teles/card.cst->l1.rbufpool = &(sp->rbufpool);
st1425drivers/isdn/teles/card.cst->l1.smallpool = &(sp->smallpool);
st1426drivers/isdn/teles/card.cst->protocol = sp->teistack->protocol;
st1428drivers/isdn/teles/card.csetstack_tei(st);
st1430drivers/isdn/teles/card.cst->l1.stlistp = &(sp->stlist);
st1431drivers/isdn/teles/card.cst->l1.act_state = 0;
st1432drivers/isdn/teles/card.cst->l2.l2l1 = teles_l2l1;
st1433drivers/isdn/teles/card.cst->l2.l2l1discardq = teles_l2l1discardq;
st1434drivers/isdn/teles/card.cst->ma.manl1 = teles_manl1;
st1435drivers/isdn/teles/card.cst->l1.requestpull = 0;
st1644drivers/isdn/teles/card.chscx_l2l1(struct PStack *st, int pr,
st1648drivers/isdn/teles/card.cst->l1.hardware;
st1649drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
st1674drivers/isdn/teles/card.cst->l1.requestpull = 0;
st1675drivers/isdn/teles/card.cst->l1.l1l2(st, PH_PULL_ACK, NULL);
st1677drivers/isdn/teles/card.cst->l1.requestpull = !0;
st1686drivers/isdn/teles/card.chscx_l2l1discardq(struct PStack *st, int pr, void *heldby,
st1690drivers/isdn/teles/card.cst->l1.hardware;
st1691drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
st1732drivers/isdn/teles/card.chscx_manl1(struct PStack *st, int pr,
st1736drivers/isdn/teles/card.cst->l1.hardware;
st1737drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
st1742drivers/isdn/teles/card.cmodehscx(hsp, st->l1.hscxmode, st->l1.hscxchannel);
st1743drivers/isdn/teles/card.cst->l1.l1man(st, PH_ACTIVATE, NULL);
st1755drivers/isdn/teles/card.csetstack_hscx(struct PStack *st, struct HscxState *hs)
st1757drivers/isdn/teles/card.cif (open_hscxstate(st->l1.hardware, hs->hscx))
st1760drivers/isdn/teles/card.cst->l1.hscx = hs->hscx;
st1761drivers/isdn/teles/card.cst->l2.l2l1 = hscx_l2l1;
st1762drivers/isdn/teles/card.cst->ma.manl1 = hscx_manl1;
st1763drivers/isdn/teles/card.cst->l2.l2l1discardq = hscx_l2l1discardq;
st1765drivers/isdn/teles/card.cst->l1.sbufpool = &hs->sbufpool;
st1766drivers/isdn/teles/card.cst->l1.rbufpool = &hs->rbufpool;
st1767drivers/isdn/teles/card.cst->l1.smallpool = &hs->smallpool;
st1768drivers/isdn/teles/card.cst->l1.act_state = 0;
st1769drivers/isdn/teles/card.cst->l1.requestpull = 0;
st1771drivers/isdn/teles/card.chs->st = st;
st120drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st123drivers/isdn/teles/isdnl2.cst->l1.service_down(st, PH_ACTIVATE, NULL);
st129drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st132drivers/isdn/teles/isdnl2.cst->l3.service_up(st, DL_ACTIVATE_CNF, NULL);
st138drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st141drivers/isdn/teles/isdnl2.cst->l1.service_down(st, PH_DEACTIVATE, NULL);
st147drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st150drivers/isdn/teles/isdnl2.cst->l3.service_up(st, DL_DEACTIVATE_IND, NULL);
st169drivers/isdn/teles/isdnl2.ccansend(struct PStack *st)
st173drivers/isdn/teles/isdnl2.cp1 = (st->l2.va + st->l2.window) % (st->l2.extended ? 128 : 8);
st174drivers/isdn/teles/isdnl2.creturn (st->l2.vs != p1);
st178drivers/isdn/teles/isdnl2.cdiscard_i_queue(struct PStack *st)
st182drivers/isdn/teles/isdnl2.cwhile (!BufQueueUnlink(&ibh, &st->l2.i_queue))
st188drivers/isdn/teles/isdnl2.cdiscard_window(struct PStack *st)
st194drivers/isdn/teles/isdnl2.cl2 = &st->l2;
st246drivers/isdn/teles/isdnl2.cenqueue_ui(struct PStack *st,
st255drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_DATA, ibh);
st259drivers/isdn/teles/isdnl2.cenqueue_super(struct PStack *st,
st268drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_DATA, ibh);
st272drivers/isdn/teles/isdnl2.clegalnr(struct PStack *st, int nr)
st274drivers/isdn/teles/isdnl2.cstruct Layer2  *l2 = &st->l2;
st283drivers/isdn/teles/isdnl2.csetva(struct PStack *st, int nr)
st285drivers/isdn/teles/isdnl2.cstruct Layer2  *l2 = &st->l2;
st293drivers/isdn/teles/isdnl2.cif (st->l4.l2writewakeup)
st294drivers/isdn/teles/isdnl2.cst->l4.l2writewakeup(st);
st301drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st303drivers/isdn/teles/isdnl2.cst->l2.l2tei(st, MDL_ASSIGN, (void *)st->l2.ces);
st310drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st316drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh, 0);
st321drivers/isdn/teles/isdnl2.cenqueue_ui(st, ibh);
st327drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st330drivers/isdn/teles/isdnl2.cst->l2.l2l3(st, DL_UNIT_DATA, ibh);
st336drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st342drivers/isdn/teles/isdnl2.cst->l2.rc = 0;
st344drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 1))
st345drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st346drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 1");
st349drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 15))
st351drivers/isdn/teles/isdnl2.ci = sethdraddr(&st->l2, ibh, 0);
st354drivers/isdn/teles/isdnl2.cif (st->l2.extended)
st360drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st372drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st373drivers/isdn/teles/isdnl2.cstruct Channel *chanp = st->l4.userdata;
st380drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 1);
st381drivers/isdn/teles/isdnl2.cif (st->l2.t200_running) {
st382drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 2);
st383drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st385drivers/isdn/teles/isdnl2.cst->l2.rc = 0;
st386drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 2))
st387drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st388drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 2");
st391drivers/isdn/teles/isdnl2.cif ((chanp->impair == 2) && (st->l2.laptype == LAPB))
st394drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 9))
st396drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh, 0);
st401drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st404drivers/isdn/teles/isdnl2.cdiscard_i_queue(st);
st410drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st416drivers/isdn/teles/isdnl2.cst->l2.vs = 0;
st417drivers/isdn/teles/isdnl2.cst->l2.va = 0;
st418drivers/isdn/teles/isdnl2.cst->l2.vr = 0;
st419drivers/isdn/teles/isdnl2.cst->l2.sow = 0;
st421drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 3))
st422drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st423drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 3");
st425drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_ESTABLISH, NULL);
st427drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 10))
st429drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh, 0);
st434drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st441drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st443drivers/isdn/teles/isdnl2.cstruct Channel *chanp = st->l4.userdata;
st448drivers/isdn/teles/isdnl2.cptr += l2addrsize(&(st->l2));
st454drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 3);
st455drivers/isdn/teles/isdnl2.cif (st->l2.t200_running) {
st456drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 4);
st457drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st459drivers/isdn/teles/isdnl2.cif ((chanp->impair == 1) && (st->l2.laptype == LAPB))
st462drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 11))
st464drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh, 0);
st469drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st472drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_RELEASE, NULL);
st479drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st485drivers/isdn/teles/isdnl2.cdata += l2addrsize(&(st->l2));
st491drivers/isdn/teles/isdnl2.cst->l2.vs = 0;
st492drivers/isdn/teles/isdnl2.cst->l2.va = 0;
st493drivers/isdn/teles/isdnl2.cst->l2.vr = 0;
st494drivers/isdn/teles/isdnl2.cst->l2.sow = 0;
st497drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 5);
st498drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 4))
st499drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st500drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 4");
st503drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_ESTABLISH, NULL);
st510drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st516drivers/isdn/teles/isdnl2.cdata += l2addrsize(&st->l2);
st522drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 6);
st524drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_RELEASE, NULL);
st531drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st532drivers/isdn/teles/isdnl2.cstruct Channel *chanp = st->l4.userdata;
st538drivers/isdn/teles/isdnl2.cl2 = &st->l2;
st562drivers/isdn/teles/isdnl2.cif ((chanp->impair == 4) && (st->l2.laptype == LAPB))
st566drivers/isdn/teles/isdnl2.cif (!BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 12)) {
st580drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st584drivers/isdn/teles/isdnl2.cif (legalnr(st, seq))
st585drivers/isdn/teles/isdnl2.cif (seq == st->l2.vs) {
st586drivers/isdn/teles/isdnl2.csetva(st, seq);
st587drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 7);
st588drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st589drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 8);
st590drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 5))
st591drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st592drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 5");
st594drivers/isdn/teles/isdnl2.cif (st->l2.i_queue.head)
st595drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st596drivers/isdn/teles/isdnl2.c} else if (st->l2.va != seq) {
st597drivers/isdn/teles/isdnl2.csetva(st, seq);
st598drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 9);
st599drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 6))
st600drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st601drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 6");
st603drivers/isdn/teles/isdnl2.cif (st->l2.i_queue.head)
st604drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st611drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st615drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
st618drivers/isdn/teles/isdnl2.ci = sethdraddr(&st->l2, ibh, 0);
st621drivers/isdn/teles/isdnl2.cif (st->l2.laptype == LAPD)
st623drivers/isdn/teles/isdnl2.csprintf(str, "Q.931 frame user->network tei %d", st->l2.tei);
st624drivers/isdn/teles/isdnl2.cdlogframe(sp, ptr + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st627drivers/isdn/teles/isdnl2.cBufQueueLink(&st->l2.i_queue, ibh);
st629drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st635drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st636drivers/isdn/teles/isdnl2.cstruct Channel *chanp = st->l4.userdata;
st640drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
st641drivers/isdn/teles/isdnl2.cstruct Layer2  *l2 = &(st->l2);
st664drivers/isdn/teles/isdnl2.cif (st->l2.laptype == LAPD)
st666drivers/isdn/teles/isdnl2.csprintf(str, "Q.931 frame network->user tei %d", st->l2.tei);
st667drivers/isdn/teles/isdnl2.cdlogframe(st->l1.hardware, ptr + l2->ihsize,
st671drivers/isdn/teles/isdnl2.cif ((chanp->impair == 3) && (st->l2.laptype == LAPB))
st674drivers/isdn/teles/isdnl2.cif (!BufPoolGet(&ibh2, st->l1.smallpool, GFP_ATOMIC, (void *) st, 13)) {
st675drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh2, p);
st688drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh2);
st695drivers/isdn/teles/isdnl2.cif (st->l2.rejexp) {
st699drivers/isdn/teles/isdnl2.cst->l2.rejexp = !0;
st700drivers/isdn/teles/isdnl2.cif (!BufPoolGet(&ibh2, st->l1.smallpool, GFP_ATOMIC, (void *) st, 14)) {
st701drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh2, p);
st714drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh2);
st719drivers/isdn/teles/isdnl2.cif (legalnr(st, nr))
st720drivers/isdn/teles/isdnl2.cif (nr == st->l2.vs) {
st721drivers/isdn/teles/isdnl2.csetva(st, nr);
st722drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 10);
st723drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st724drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 11);
st725drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 7))
st726drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st727drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 5");
st729drivers/isdn/teles/isdnl2.cif (st->l2.i_queue.head)
st730drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st731drivers/isdn/teles/isdnl2.c} else if (nr != st->l2.va) {
st732drivers/isdn/teles/isdnl2.csetva(st, nr);
st733drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 12);
st734drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 8))
st735drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st736drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 6");
st738drivers/isdn/teles/isdnl2.cif (st->l2.i_queue.head)
st739drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st742drivers/isdn/teles/isdnl2.cst->l2.l2l3(st, DL_DATA, ibh);
st749drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st751drivers/isdn/teles/isdnl2.cst->l2.tei = (int) arg;
st756drivers/isdn/teles/isdnl2.cenquiry_response(struct PStack *st)
st763drivers/isdn/teles/isdnl2.cl2 = &st->l2;
st764drivers/isdn/teles/isdnl2.cif (!BufPoolGet(&ibh2, st->l1.smallpool, GFP_ATOMIC, (void *) st, 16)) {
st765drivers/isdn/teles/isdnl2.ci = sethdraddr(&(st->l2), ibh2, !0);
st778drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh2);
st783drivers/isdn/teles/isdnl2.cinvoke_retransmission(struct PStack *st, int nr)
st785drivers/isdn/teles/isdnl2.cstruct Layer2  *l2 = &st->l2;
st802drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st809drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st815drivers/isdn/teles/isdnl2.cl2 = &(st->l2);
st841drivers/isdn/teles/isdnl2.cenquiry_response(st);
st843drivers/isdn/teles/isdnl2.cif (!legalnr(st, seq))
st846drivers/isdn/teles/isdnl2.csetva(st, seq);
st847drivers/isdn/teles/isdnl2.cinvoke_retransmission(st, seq);
st860drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st865drivers/isdn/teles/isdnl2.cif (st->l2.rc == st->l2.n200) {
st867drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_RELEASE, NULL);
st869drivers/isdn/teles/isdnl2.cst->l2.rc++;
st871drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 9))
st872drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st873drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 7");
st875drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 15))
st878drivers/isdn/teles/isdnl2.ci = sethdraddr(&st->l2, ibh, 0);
st881drivers/isdn/teles/isdnl2.cif (st->l2.extended)
st886drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st893drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st894drivers/isdn/teles/isdnl2.cstruct Channel *chanp = st->l4.userdata;
st899drivers/isdn/teles/isdnl2.cif (st->l2.rc == st->l2.n200) {
st901drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_RELEASE, NULL);
st903drivers/isdn/teles/isdnl2.cst->l2.rc++;
st905drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 10))
st906drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st907drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 8");
st910drivers/isdn/teles/isdnl2.cif ((chanp->impair == 2) && (st->l2.laptype == LAPB))
st913drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 15))
st916drivers/isdn/teles/isdnl2.ci = sethdraddr(&st->l2, ibh, 0);
st921drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st930drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st932drivers/isdn/teles/isdnl2.cstruct Layer2  *l2 = &st->l2;
st936drivers/isdn/teles/isdnl2.cif (!cansend(st))
st961drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_DATA_PULLED, ibh);
st963drivers/isdn/teles/isdnl2.cif (!st->l2.t200_running) {
st964drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 13);
st965drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 11))
st966drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st967drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 9");
st969drivers/isdn/teles/isdnl2.cst->l2.t200_running = !0;
st971drivers/isdn/teles/isdnl2.cif (l2->i_queue.head && cansend(st))
st972drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_REQUEST_PULL, NULL);
st977drivers/isdn/teles/isdnl2.ctransmit_enquiry(struct PStack *st)
st982drivers/isdn/teles/isdnl2.cif (!BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 12)) {
st984drivers/isdn/teles/isdnl2.cptr += sethdraddr(&st->l2, ibh, 0);
st986drivers/isdn/teles/isdnl2.cif (st->l2.extended) {
st988drivers/isdn/teles/isdnl2.c*ptr++ = (st->l2.vr << 1) | 1;
st990drivers/isdn/teles/isdnl2.c*ptr++ = (st->l2.vr << 5) | 0x11;
st993drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st994drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t200_timer, st->l2.t200, EV_L2_T200, NULL, 12))
st995drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st996drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 10");
st998drivers/isdn/teles/isdnl2.cst->l2.t200_running = !0;
st1005drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1007drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st1009drivers/isdn/teles/isdnl2.cst->l2.rc = 1;
st1011drivers/isdn/teles/isdnl2.ctransmit_enquiry(st);
st1017drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1023drivers/isdn/teles/isdnl2.cl2 = &st->l2;
st1049drivers/isdn/teles/isdnl2.cif (legalnr(st, seq)) {
st1051drivers/isdn/teles/isdnl2.csetva(st, seq);
st1052drivers/isdn/teles/isdnl2.cif (st->l2.t200_running) {
st1053drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 14);
st1054drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st1056drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 13))
st1057drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st1058drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 11");
st1060drivers/isdn/teles/isdnl2.cinvoke_retransmission(st, seq);
st1064drivers/isdn/teles/isdnl2.cenquiry_response(st);
st1065drivers/isdn/teles/isdnl2.cif (legalnr(st, seq)) {
st1066drivers/isdn/teles/isdnl2.csetva(st, seq);
st1074drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1076drivers/isdn/teles/isdnl2.cst->l2.rc = 0;
st1078drivers/isdn/teles/isdnl2.ctransmit_enquiry(st);
st1084drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1086drivers/isdn/teles/isdnl2.cif (st->l2.rc == st->l2.n200) {
st1089drivers/isdn/teles/isdnl2.cst->l2.rc++;
st1090drivers/isdn/teles/isdnl2.ctransmit_enquiry(st);
st1097drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1103drivers/isdn/teles/isdnl2.cptr += l2addrsize(&st->l2);
st1105drivers/isdn/teles/isdnl2.cif (st->l2.extended)
st1112drivers/isdn/teles/isdnl2.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 10))
st1114drivers/isdn/teles/isdnl2.ci = sethdraddr(&st->l2, ibh, 0);
st1119drivers/isdn/teles/isdnl2.cenqueue_super(st, ibh);
st1121drivers/isdn/teles/isdnl2.cif (st->l2.vs != st->l2.va) {
st1122drivers/isdn/teles/isdnl2.cdiscard_i_queue(st);
st1127drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 15);
st1128drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st1130drivers/isdn/teles/isdnl2.cif (FsmAddTimer(&st->l2.t203_timer, st->l2.t203, EV_L2_T203, NULL, 3))
st1131drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug)
st1132drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, "FAT 12");
st1134drivers/isdn/teles/isdnl2.cst->l2.vs = 0;
st1135drivers/isdn/teles/isdnl2.cst->l2.va = 0;
st1136drivers/isdn/teles/isdnl2.cst->l2.vr = 0;
st1137drivers/isdn/teles/isdnl2.cst->l2.sow = 0;
st1141drivers/isdn/teles/isdnl2.cst->l2.l2man(st, DL_ESTABLISH, NULL);
st1148drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1154drivers/isdn/teles/isdnl2.cptr += l2addrsize(&st->l2);
st1157drivers/isdn/teles/isdnl2.cif (st->l2.l2m.debug) {
st1158drivers/isdn/teles/isdnl2.cif (st->l2.extended)
st1165drivers/isdn/teles/isdnl2.cl2m_debug(&st->l2.l2m, tmp);
st1269drivers/isdn/teles/isdnl2.cisdnl2_l1l2(struct PStack *st, int pr, struct BufHeader *arg)
st1280drivers/isdn/teles/isdnl2.cdatap += l2addrsize(&st->l2);
st1282drivers/isdn/teles/isdnl2.cif (IsI(datap, st->l2.extended))
st1283drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_I, ibh);
st1284drivers/isdn/teles/isdnl2.celse if (IsRR(datap, st->l2.extended))
st1285drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_RR, ibh);
st1286drivers/isdn/teles/isdnl2.celse if (IsUI(datap, st->l2.extended))
st1287drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_UI, ibh);
st1288drivers/isdn/teles/isdnl2.celse if (IsSABMX(datap, st->l2.extended))
st1289drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_SABMX, ibh);
st1290drivers/isdn/teles/isdnl2.celse if (IsUA(datap, st->l2.extended))
st1291drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_UA, ibh);
st1292drivers/isdn/teles/isdnl2.celse if (IsDISC(datap, st->l2.extended))
st1293drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_DISC, ibh);
st1294drivers/isdn/teles/isdnl2.celse if (IsREJ(datap, st->l2.extended))
st1295drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_REJ, ibh);
st1296drivers/isdn/teles/isdnl2.celse if (IsFRMR(datap, st->l2.extended))
st1297drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_FRMR, ibh);
st1298drivers/isdn/teles/isdnl2.celse if (IsRNR(datap, st->l2.extended))
st1299drivers/isdn/teles/isdnl2.cret = FsmEvent(&st->l2.l2m, EV_L2_RNR, ibh);
st1306drivers/isdn/teles/isdnl2.cFsmEvent(&st->l2.l2m, EV_L2_ACK_PULL, arg);
st1312drivers/isdn/teles/isdnl2.cisdnl2_l3l2(struct PStack *st, int pr,
st1317drivers/isdn/teles/isdnl2.cif (FsmEvent(&st->l2.l2m, EV_L2_DL_DATA, arg))
st1321drivers/isdn/teles/isdnl2.cif (FsmEvent(&st->l2.l2m, EV_L2_DL_UNIT_DATA, arg))
st1328drivers/isdn/teles/isdnl2.cisdnl2_manl2(struct PStack *st, int pr,
st1333drivers/isdn/teles/isdnl2.cFsmEvent(&st->l2.l2m, EV_L2_DL_ESTABLISH, arg);
st1336drivers/isdn/teles/isdnl2.cFsmEvent(&st->l2.l2m, EV_L2_DL_RELEASE, arg);
st1339drivers/isdn/teles/isdnl2.cFsmEvent(&st->l2.l2m, EV_L2_MDL_NOTEIPROC, NULL);
st1345drivers/isdn/teles/isdnl2.cisdnl2_teil2(struct PStack *st, int pr,
st1350drivers/isdn/teles/isdnl2.cFsmEvent(&st->l2.l2m, EV_L2_MDL_ASSIGN, arg);
st1356drivers/isdn/teles/isdnl2.creleasestack_isdnl2(struct PStack *st)
st1358drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t200_timer, 15);
st1359drivers/isdn/teles/isdnl2.cFsmDelTimer(&st->l2.t203_timer, 16);
st1365drivers/isdn/teles/isdnl2.cstruct PStack  *st = fi->userdata;
st1369drivers/isdn/teles/isdnl2.csprintf(str, "%s %s %s\n", tm, st->l2.debug_id, s);
st1375drivers/isdn/teles/isdnl2.csetstack_isdnl2(struct PStack *st, char *debug_id)
st1377drivers/isdn/teles/isdnl2.cst->l1.l1l2 = isdnl2_l1l2;
st1378drivers/isdn/teles/isdnl2.cst->l3.l3l2 = isdnl2_l3l2;
st1379drivers/isdn/teles/isdnl2.cst->ma.manl2 = isdnl2_manl2;
st1380drivers/isdn/teles/isdnl2.cst->ma.teil2 = isdnl2_teil2;
st1382drivers/isdn/teles/isdnl2.cst->l2.uihsize = l2headersize(&st->l2, !0);
st1383drivers/isdn/teles/isdnl2.cst->l2.ihsize = l2headersize(&st->l2, 0);
st1384drivers/isdn/teles/isdnl2.cBufQueueInit(&(st->l2.i_queue));
st1385drivers/isdn/teles/isdnl2.cst->l2.rejexp = 0;
st1386drivers/isdn/teles/isdnl2.cst->l2.debug = 1;
st1388drivers/isdn/teles/isdnl2.cst->l2.l2m.fsm = &l2fsm;
st1389drivers/isdn/teles/isdnl2.cst->l2.l2m.state = ST_L2_1;
st1390drivers/isdn/teles/isdnl2.cst->l2.l2m.debug = 0;
st1391drivers/isdn/teles/isdnl2.cst->l2.l2m.userdata = st;
st1392drivers/isdn/teles/isdnl2.cst->l2.l2m.printdebug = l2m_debug;
st1393drivers/isdn/teles/isdnl2.cstrcpy(st->l2.debug_id, debug_id);
st1395drivers/isdn/teles/isdnl2.cFsmInitTimer(&st->l2.l2m, &st->l2.t200_timer);
st1396drivers/isdn/teles/isdnl2.cFsmInitTimer(&st->l2.l2m, &st->l2.t203_timer);
st1397drivers/isdn/teles/isdnl2.cst->l2.t200_running = 0;
st1402drivers/isdn/teles/isdnl2.ctrans_acceptph(struct PStack *st, struct BufHeader *ibh)
st1405drivers/isdn/teles/isdnl2.cst->l3.service_up(st, DL_DATA, ibh);
st1411drivers/isdn/teles/isdnl2.ctransdown(struct PStack *st, int pr,
st1416drivers/isdn/teles/isdnl2.cst->l2.l2l1(st, PH_DATA, ibh);
st1422drivers/isdn/teles/isdnl2.csetstack_transl2(struct PStack *st)
st1425drivers/isdn/teles/isdnl2.cst->l2.phdata_up = trans_acceptph;
st1426drivers/isdn/teles/isdnl2.cst->l2.service_down = (void *) transdown;
st1427drivers/isdn/teles/isdnl2.cst->l2.ihsize = 0;
st1428drivers/isdn/teles/isdnl2.cst->l2.debug = 0;
st1433drivers/isdn/teles/isdnl2.creleasestack_transl2(struct PStack *st)
st8drivers/isdn/teles/isdnl3.ci_down(struct PStack *st,
st11drivers/isdn/teles/isdnl3.cst->l3.l3l2(st, DL_DATA, ibh);
st15drivers/isdn/teles/isdnl3.cnewl3state(struct PStack *st, int state)
st17drivers/isdn/teles/isdnl3.cst->l3.state = state;
st20drivers/isdn/teles/isdnl3.cst->pa->bchannel, st->pa->callref, state);
st25drivers/isdn/teles/isdnl3.cl3_message(struct PStack *st, int mt)
st31drivers/isdn/teles/isdnl3.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 18);
st33drivers/isdn/teles/isdnl3.cp += st->l2.ihsize;
st34drivers/isdn/teles/isdnl3.csize = st->l2.ihsize;
st38drivers/isdn/teles/isdnl3.c*p++ = st->l3.callref;
st43drivers/isdn/teles/isdnl3.ci_down(st, dibh);
st47drivers/isdn/teles/isdnl3.cl3s3(struct PStack *st, byte pr, void *arg)
st49drivers/isdn/teles/isdnl3.cl3_message(st, MT_RELEASE);
st50drivers/isdn/teles/isdnl3.cnewl3state(st, 19);
st54drivers/isdn/teles/isdnl3.cl3s4(struct PStack *st, byte pr, void *arg)
st59drivers/isdn/teles/isdnl3.cnewl3state(st, 0);
st60drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_RELEASE_CNF, NULL);
st64drivers/isdn/teles/isdnl3.cl3s5(struct PStack *st, byte pr,
st71drivers/isdn/teles/isdnl3.cst->l3.callref = st->pa->callref;
st72drivers/isdn/teles/isdnl3.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 19);
st74drivers/isdn/teles/isdnl3.cp += st->l2.ihsize;
st78drivers/isdn/teles/isdnl3.c*p++ = st->l3.callref;
st85drivers/isdn/teles/isdnl3.cswitch (st->pa->info) {
st113drivers/isdn/teles/isdnl3.cif (st->pa->calling[0] != '\0') {
st115drivers/isdn/teles/isdnl3.c*p++ = strlen(st->pa->calling) + 1;
st118drivers/isdn/teles/isdnl3.cteln = st->pa->calling;
st123drivers/isdn/teles/isdnl3.c*p++ = strlen(st->pa->called) + 1;
st127drivers/isdn/teles/isdnl3.cteln = st->pa->called;
st134drivers/isdn/teles/isdnl3.cnewl3state(st, 1);
st135drivers/isdn/teles/isdnl3.ci_down(st, dibh);
st140drivers/isdn/teles/isdnl3.cl3s6(struct PStack *st, byte pr, void *arg)
st146drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st148drivers/isdn/teles/isdnl3.cst->pa->bchannel = p[2] & 0x3;
st153drivers/isdn/teles/isdnl3.cnewl3state(st, 3);
st154drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_PROCEEDING_IND, NULL);
st158drivers/isdn/teles/isdnl3.cl3s7(struct PStack *st, byte pr, void *arg)
st163drivers/isdn/teles/isdnl3.cnewl3state(st, 12);
st164drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_DISCONNECT_IND, NULL);
st168drivers/isdn/teles/isdnl3.cl3s8(struct PStack *st, byte pr, void *arg)
st173drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_SETUP_CNF, NULL);
st174drivers/isdn/teles/isdnl3.cnewl3state(st, 10);
st178drivers/isdn/teles/isdnl3.cl3s11(struct PStack *st, byte pr, void *arg)
st183drivers/isdn/teles/isdnl3.cnewl3state(st, 4);
st184drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_ALERTING_IND, NULL);
st188drivers/isdn/teles/isdnl3.cl3s12(struct PStack *st, byte pr, void *arg)
st194drivers/isdn/teles/isdnl3.cp += st->l2.uihsize;
st195drivers/isdn/teles/isdnl3.cst->pa->callref = getcallref(p);
st196drivers/isdn/teles/isdnl3.cst->l3.callref = 0x80 + st->pa->callref;
st202drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st204drivers/isdn/teles/isdnl3.cst->pa->bchannel = p[2] & 0x3;
st209drivers/isdn/teles/isdnl3.cif (st->protocol == ISDN_PTYPE_1TR6) {
st210drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize, 0x01, 6))) {
st211drivers/isdn/teles/isdnl3.cst->pa->info = p[2];
st212drivers/isdn/teles/isdnl3.cst->pa->info2 = p[3];
st219drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize, 0x04, 0))) {
st225drivers/isdn/teles/isdnl3.cst->pa->info = 1;
st229drivers/isdn/teles/isdnl3.cst->pa->info = 7;
st233drivers/isdn/teles/isdnl3.cst->pa->info = 2;
st237drivers/isdn/teles/isdnl3.cst->pa->info = 3;
st241drivers/isdn/teles/isdnl3.cst->pa->info = 4;
st244drivers/isdn/teles/isdnl3.cst->pa->info = 0;
st251drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st253drivers/isdn/teles/isdnl3.ciecpy(st->pa->called, p, 1);
st255drivers/isdn/teles/isdnl3.cstrcpy(st->pa->called, "");
st258drivers/isdn/teles/isdnl3.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st260drivers/isdn/teles/isdnl3.cif (st->protocol == ISDN_PTYPE_1TR6)
st261drivers/isdn/teles/isdnl3.ciecpy(st->pa->calling, p, 1);
st263drivers/isdn/teles/isdnl3.ciecpy(st->pa->calling, p, 2);
st265drivers/isdn/teles/isdnl3.cstrcpy(st->pa->calling, "");
st268drivers/isdn/teles/isdnl3.cif (st->pa->info == 7) {
st269drivers/isdn/teles/isdnl3.cnewl3state(st, 6);
st270drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_SETUP_IND, NULL);
st273drivers/isdn/teles/isdnl3.cst->pa->calling,
st274drivers/isdn/teles/isdnl3.cst->pa->called);
st279drivers/isdn/teles/isdnl3.cl3s13(struct PStack *st, byte pr, void *arg)
st281drivers/isdn/teles/isdnl3.cnewl3state(st, 0);
st286drivers/isdn/teles/isdnl3.cl3s15(struct PStack *st, byte pr, void *arg)
st288drivers/isdn/teles/isdnl3.cnewl3state(st, 0);
st289drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_REJECT, NULL);
st294drivers/isdn/teles/isdnl3.cl3s16(struct PStack *st, byte pr,
st297drivers/isdn/teles/isdnl3.cst->l3.callref = 0x80 + st->pa->callref;
st298drivers/isdn/teles/isdnl3.cl3_message(st, MT_CONNECT);
st299drivers/isdn/teles/isdnl3.cnewl3state(st, 8);
st303drivers/isdn/teles/isdnl3.cl3s17(struct PStack *st, byte pr, void *arg)
st308drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_SETUP_COMPLETE_IND, NULL);
st309drivers/isdn/teles/isdnl3.cnewl3state(st, 10);
st313drivers/isdn/teles/isdnl3.cl3s18(struct PStack *st, byte pr, void *arg)
st319drivers/isdn/teles/isdnl3.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 20);
st321drivers/isdn/teles/isdnl3.cp += st->l2.ihsize;
st322drivers/isdn/teles/isdnl3.csize = st->l2.ihsize;
st326drivers/isdn/teles/isdnl3.c*p++ = st->l3.callref;
st337drivers/isdn/teles/isdnl3.ci_down(st, dibh);
st339drivers/isdn/teles/isdnl3.cnewl3state(st, 11);
st343drivers/isdn/teles/isdnl3.cl3s19(struct PStack *st, byte pr, void *arg)
st348drivers/isdn/teles/isdnl3.cnewl3state(st, 0);
st349drivers/isdn/teles/isdnl3.cl3_message(st, MT_RELEASE_COMPLETE);
st350drivers/isdn/teles/isdnl3.cst->l3.l3l4(st, CC_RELEASE_IND, NULL);
st354drivers/isdn/teles/isdnl3.cl3s20(struct PStack *st, byte pr,
st357drivers/isdn/teles/isdnl3.cl3_message(st, MT_ALERTING);
st358drivers/isdn/teles/isdnl3.cnewl3state(st, 7);
st407drivers/isdn/teles/isdnl3.cl3up(struct PStack *st,
st416drivers/isdn/teles/isdnl3.cptr += st->l2.ihsize;
st417drivers/isdn/teles/isdnl3.csize = ibh->datasize - st->l2.ihsize;
st431drivers/isdn/teles/isdnl3.cif ((st->l3.state == datastatelist_1tr6t[i].state) &&
st438drivers/isdn/teles/isdnl3.cst->l3.state, mt_trans(PROTO_DIS_N1, mt));
st440drivers/isdn/teles/isdnl3.cdatastatelist_1tr6t[i].rout(st, pr, ibh);
st445drivers/isdn/teles/isdnl3.cif ((st->l3.state == datastatelist[i].state) &&
st451drivers/isdn/teles/isdnl3.cdatastatelist[i].rout(st, pr, ibh);
st455drivers/isdn/teles/isdnl3.cptr += st->l2.uihsize;
st456drivers/isdn/teles/isdnl3.csize = ibh->datasize - st->l2.uihsize;
st470drivers/isdn/teles/isdnl3.cif ((st->l3.state == datastatelist_1tr6t[i].state) &&
st476drivers/isdn/teles/isdnl3.c,st->l3.state, mt_trans(PROTO_DIS_N1, mt));
st480drivers/isdn/teles/isdnl3.cdatastatelist_1tr6t[i].rout(st, pr, ibh);
st485drivers/isdn/teles/isdnl3.cif ((st->l3.state == datastatelist[i].state) &&
st491drivers/isdn/teles/isdnl3.cdatastatelist[i].rout(st, pr, ibh);
st497drivers/isdn/teles/isdnl3.cl3down(struct PStack *st,
st503drivers/isdn/teles/isdnl3.cswitch (st->protocol) {
st507drivers/isdn/teles/isdnl3.cif ((st->l3.state == downstatelist_1tr6t[i].state) &&
st512drivers/isdn/teles/isdnl3.cprintk(KERN_INFO "isdnl3down unhandled 1tr6 state %d primitiv %x\n", st->l3.state, pr);
st515drivers/isdn/teles/isdnl3.cdownstatelist_1tr6t[i].rout(st, pr, ibh);
st520drivers/isdn/teles/isdnl3.cif ((st->l3.state == downstatelist[i].state) &&
st525drivers/isdn/teles/isdnl3.cdownstatelist[i].rout(st, pr, ibh);
st530drivers/isdn/teles/isdnl3.csetstack_isdnl3(struct PStack *st)
st532drivers/isdn/teles/isdnl3.cst->l4.l4l3 = l3down;
st533drivers/isdn/teles/isdnl3.cst->l2.l2l3 = l3up;
st534drivers/isdn/teles/isdnl3.cst->l3.state = 0;
st535drivers/isdn/teles/isdnl3.cst->l3.callref = 0;
st536drivers/isdn/teles/isdnl3.cst->l3.debug = 0;
st25drivers/isdn/teles/l3_1TR6.cl3_1TR6_message(struct PStack *st, int mt, int pd)
st30drivers/isdn/teles/l3_1TR6.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 18);
st32drivers/isdn/teles/l3_1TR6.cp += st->l2.ihsize;
st36drivers/isdn/teles/l3_1TR6.c*p++ = st->l3.callref;
st40drivers/isdn/teles/l3_1TR6.ci_down(st, dibh);
st44drivers/isdn/teles/l3_1TR6.cl3_1tr6_setup(struct PStack *st, byte pr, void *arg)
st54drivers/isdn/teles/l3_1TR6.cst->l3.callref = st->pa->callref;
st55drivers/isdn/teles/l3_1TR6.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 19);
st57drivers/isdn/teles/l3_1TR6.cp += st->l2.ihsize;
st61drivers/isdn/teles/l3_1TR6.c*p++ = st->l3.callref;
st65drivers/isdn/teles/l3_1TR6.cif (st->pa->calling[0] != '\0') {
st67drivers/isdn/teles/l3_1TR6.c*p++ = strlen(st->pa->calling) + 1;
st70drivers/isdn/teles/l3_1TR6.cteln = st->pa->calling;
st75drivers/isdn/teles/l3_1TR6.c*p++ = strlen(st->pa->called) + 1;
st79drivers/isdn/teles/l3_1TR6.cteln = st->pa->called;
st87drivers/isdn/teles/l3_1TR6.c*p++ = st->pa->info;
st88drivers/isdn/teles/l3_1TR6.c*p++ = st->pa->info2;
st92drivers/isdn/teles/l3_1TR6.cnewl3state(st, 1);
st93drivers/isdn/teles/l3_1TR6.ci_down(st, dibh);
st99drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_setup(struct PStack *st, byte pr, void *arg)
st109drivers/isdn/teles/l3_1TR6.cp += st->l2.uihsize;
st110drivers/isdn/teles/l3_1TR6.cst->pa->callref = getcallref(p);
st111drivers/isdn/teles/l3_1TR6.cst->l3.callref = 0x80 + st->pa->callref;
st117drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st119drivers/isdn/teles/l3_1TR6.cst->pa->bchannel = p[2] & 0x3;
st125drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize, WE6_serviceInd, 6))) {
st126drivers/isdn/teles/l3_1TR6.cst->pa->info = p[2];
st127drivers/isdn/teles/l3_1TR6.cst->pa->info2 = p[3];
st132drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st134drivers/isdn/teles/l3_1TR6.ciecpy(st->pa->called, p, 1);
st136drivers/isdn/teles/l3_1TR6.cstrcpy(st->pa->called, "");
st139drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.uihsize, ibh->datasize - st->l2.uihsize,
st141drivers/isdn/teles/l3_1TR6.ciecpy(st->pa->calling, p, 1);
st143drivers/isdn/teles/l3_1TR6.cstrcpy(st->pa->calling, "");
st147drivers/isdn/teles/l3_1TR6.cif (st->pa->info == 7) {
st148drivers/isdn/teles/l3_1TR6.cnewl3state(st, 6);
st149drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_SETUP_IND, NULL);
st154drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_setup_ack(struct PStack *st, byte pr, void *arg)
st164drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st166drivers/isdn/teles/l3_1TR6.cst->pa->bchannel = p[2] & 0x3;
st171drivers/isdn/teles/l3_1TR6.cnewl3state(st, 2);
st175drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_call_sent(struct PStack *st, byte pr, void *arg)
st185drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st187drivers/isdn/teles/l3_1TR6.cst->pa->bchannel = p[2] & 0x3;
st192drivers/isdn/teles/l3_1TR6.cnewl3state(st, 3);
st193drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_PROCEEDING_IND, NULL);
st197drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_alert(struct PStack *st, byte pr, void *arg)
st207drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st215drivers/isdn/teles/l3_1TR6.cnewl3state(st, 4);
st216drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_ALERTING_IND, NULL);
st220drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_info(struct PStack *st, byte pr, void *arg)
st232drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st235drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo = 0;
st237drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo *= 10;
st238drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo += a_charge[i] & 0xf;
st239drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_INFO_CHARGE, NULL);
st242drivers/isdn/teles/l3_1TR6.cprintk(KERN_INFO "chargingInfo %d\n", st->pa->chargeinfo);
st250drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_info_s2(struct PStack *st, byte pr, void *arg)
st270drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_connect(struct PStack *st, byte pr, void *arg)
st279drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_SETUP_CNF, NULL);
st280drivers/isdn/teles/l3_1TR6.cnewl3state(st, 10);
st284drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_rel(struct PStack *st, byte pr, void *arg)
st294drivers/isdn/teles/l3_1TR6.cl3_1TR6_message(st, MT_N1_REL_ACK, PROTO_DIS_N1);
st295drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_RELEASE_IND, NULL);
st296drivers/isdn/teles/l3_1TR6.cnewl3state(st, 0);
st300drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_rel_ack(struct PStack *st, byte pr, void *arg)
st310drivers/isdn/teles/l3_1TR6.cnewl3state(st, 0);
st311drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_RELEASE_CNF, NULL);
st315drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_disc(struct PStack *st, byte pr, void *arg)
st329drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st332drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo = 0;
st334drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo *= 10;
st335drivers/isdn/teles/l3_1TR6.cst->pa->chargeinfo += a_charge[i] & 0xf;
st336drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_INFO_CHARGE, NULL);
st339drivers/isdn/teles/l3_1TR6.cprintk(KERN_INFO "chargingInfo %d\n", st->pa->chargeinfo);
st344drivers/isdn/teles/l3_1TR6.cif ((p = findie(p + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
st347drivers/isdn/teles/l3_1TR6.cst->pa->cause = p[2];
st349drivers/isdn/teles/l3_1TR6.cst->pa->cause = 0;
st352drivers/isdn/teles/l3_1TR6.cprintk(KERN_INFO "Cause %x\n", st->pa->cause);
st357drivers/isdn/teles/l3_1TR6.cnewl3state(st, 12);
st358drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_DISCONNECT_IND, NULL);
st363drivers/isdn/teles/l3_1TR6.cl3_1tr6_tu_connect_ack(struct PStack *st, byte pr, void *arg)
st373drivers/isdn/teles/l3_1TR6.cst->l3.l3l4(st, CC_SETUP_COMPLETE_IND, NULL);
st374drivers/isdn/teles/l3_1TR6.cnewl3state(st, 10);
st378drivers/isdn/teles/l3_1TR6.cl3_1tr6_alert(struct PStack *st, byte pr,
st385drivers/isdn/teles/l3_1TR6.cl3_1TR6_message(st, MT_N1_ALERT, PROTO_DIS_N1);
st386drivers/isdn/teles/l3_1TR6.cnewl3state(st, 7);
st390drivers/isdn/teles/l3_1TR6.cl3_1tr6_conn(struct PStack *st, byte pr,
st397drivers/isdn/teles/l3_1TR6.cst->l3.callref = 0x80 + st->pa->callref;
st398drivers/isdn/teles/l3_1TR6.cl3_1TR6_message(st, MT_N1_CONN, PROTO_DIS_N1);
st399drivers/isdn/teles/l3_1TR6.cnewl3state(st, 8);
st403drivers/isdn/teles/l3_1TR6.cl3_1tr6_ignore(struct PStack *st, byte pr, void *arg)
st409drivers/isdn/teles/l3_1TR6.cnewl3state(st, 0);
st413drivers/isdn/teles/l3_1TR6.cl3_1tr6_disconn_req(struct PStack *st, byte pr, void *arg)
st422drivers/isdn/teles/l3_1TR6.cBufPoolGet(&dibh, st->l1.sbufpool, GFP_ATOMIC, (void *) st, 20);
st424drivers/isdn/teles/l3_1TR6.cp += st->l2.ihsize;
st428drivers/isdn/teles/l3_1TR6.c*p++ = st->l3.callref;
st436drivers/isdn/teles/l3_1TR6.ci_down(st, dibh);
st438drivers/isdn/teles/l3_1TR6.cnewl3state(st, 11);
st442drivers/isdn/teles/l3_1TR6.cl3_1tr6_rel_req(struct PStack *st, byte pr, void *arg)
st444drivers/isdn/teles/l3_1TR6.cl3_1TR6_message(st, MT_N1_REL, PROTO_DIS_N1);
st445drivers/isdn/teles/l3_1TR6.cnewl3state(st, 19);
st8drivers/isdn/teles/tei.cfindces(struct PStack *st, int ces)
st10drivers/isdn/teles/tei.cstruct PStack  *ptr = *(st->l1.stlistp);
st21drivers/isdn/teles/tei.cfindtei(struct PStack *st, int tei)
st23drivers/isdn/teles/tei.cstruct PStack  *ptr = *(st->l1.stlistp);
st37drivers/isdn/teles/tei.ctei_handler(struct PStack *st,
st45drivers/isdn/teles/tei.cif (st->l2.debug)
st51drivers/isdn/teles/tei.cBufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 6);
st55drivers/isdn/teles/tei.cbp += st->l2.uihsize;
st62drivers/isdn/teles/tei.cst->l3.l3l2(st, DL_UNIT_DATA, ibh);
st73drivers/isdn/teles/tei.cif (st->l3.debug)
st76drivers/isdn/teles/tei.cif ((otsp = findces(st, tces)))
st81drivers/isdn/teles/tei.cif (st->l3.debug)
st85drivers/isdn/teles/tei.cptr = *(st->l1.stlistp);
st88drivers/isdn/teles/tei.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 7))
st98drivers/isdn/teles/tei.cst->l3.l3l2(st, DL_UNIT_DATA, ibh);
st103drivers/isdn/teles/tei.cotsp = findtei(st, bp[4] >> 1);
st107drivers/isdn/teles/tei.cif (st->l3.debug)
st109drivers/isdn/teles/tei.cif (BufPoolGet(&ibh, st->l1.smallpool, GFP_ATOMIC, (void *) st, 7))
st119drivers/isdn/teles/tei.cst->l3.l3l2(st, DL_UNIT_DATA, ibh);
st124drivers/isdn/teles/tei.cif (st->l3.debug)
st149drivers/isdn/teles/tei.ctei_l2tei(struct PStack *st, int pr, void *arg)
st151drivers/isdn/teles/tei.cstruct IsdnCardState *sp = st->l1.hardware;
st157drivers/isdn/teles/tei.csetstack_tei(struct PStack *st)
st159drivers/isdn/teles/tei.cst->l2.l2tei = tei_l2tei;
st165drivers/isdn/teles/tei.cstruct PStack  *st;
st170drivers/isdn/teles/tei.cst = (struct PStack *) Smalloc(sizeof(struct PStack), GFP_KERNEL,
st174drivers/isdn/teles/tei.csp->teistack = st;                  /* struct is not initialized yet */
st179drivers/isdn/teles/tei.csetstack_teles(st, sp);
st181drivers/isdn/teles/tei.cst->l2.extended = !0;
st182drivers/isdn/teles/tei.cst->l2.laptype = LAPD;
st183drivers/isdn/teles/tei.cst->l2.window = 1;
st184drivers/isdn/teles/tei.cst->l2.orig = !0;
st185drivers/isdn/teles/tei.cst->protocol = protocol;
st191drivers/isdn/teles/tei.cst->l2.t200 = 500;  /* 500 milliseconds */
st192drivers/isdn/teles/tei.cst->l2.n200 = 4;  /* try 4 times */
st194drivers/isdn/teles/tei.cst->l2.sap = 63;
st195drivers/isdn/teles/tei.cst->l2.tei = 127;
st198drivers/isdn/teles/tei.csetstack_isdnl2(st, tmp);
st199drivers/isdn/teles/tei.cst->l2.debug = 0;
st200drivers/isdn/teles/tei.cst->l3.debug = 0;
st202drivers/isdn/teles/tei.cst->ma.manl2(st, MDL_NOTEIPROC, NULL);
st204drivers/isdn/teles/tei.cst->l2.l2l3 = (void *) tei_handler;
st205drivers/isdn/teles/tei.cst->l1.l1man = tei_man;
st206drivers/isdn/teles/tei.cst->l2.l2man = tei_man;
st207drivers/isdn/teles/tei.cst->l4.l2writewakeup = NULL;
st209drivers/isdn/teles/tei.cteles_addlist(sp, st);
st210drivers/isdn/teles/tei.csp->teistack = st;
st216drivers/isdn/teles/tei.cstruct PStack  *st = sp->teistack;
st218drivers/isdn/teles/tei.cteles_rmlist(sp, st);
st219drivers/isdn/teles/tei.cSfree((void *) st);
st306drivers/isdn/teles/teles.hstruct PStack  *st;
st372drivers/isdn/teles/teles.hvoid            l2down(struct PStack *st,
st374drivers/isdn/teles/teles.hvoid            l2up(struct PStack *st,
st376drivers/isdn/teles/teles.hvoid            acceptph(struct PStack *st,
st378drivers/isdn/teles/teles.hvoid            setstack_isdnl2(struct PStack *st, char *debug_id);
st382drivers/isdn/teles/teles.hvoid            setstack_teles(struct PStack *st, struct IsdnCardState *sp);
st384drivers/isdn/teles/teles.hvoid            setstack_isdnl3(struct PStack *st);
st386drivers/isdn/teles/teles.hstruct PStack *st);
st387drivers/isdn/teles/teles.hvoid            releasestack_isdnl2(struct PStack *st);
st389drivers/isdn/teles/teles.hstruct PStack *st);
st390drivers/isdn/teles/teles.hvoid            newcallref(struct PStack *st);
st394drivers/isdn/teles/teles.hint             setstack_hscx(struct PStack *st, struct HscxState *hs);
st424drivers/isdn/teles/teles.hvoid            setstack_transl2(struct PStack *st);
st425drivers/isdn/teles/teles.hvoid            releasestack_transl2(struct PStack *st);
st427drivers/isdn/teles/teles.hvoid            setstack_tei(struct PStack *st);
st434drivers/isdn/teles/teles.hstruct PStack  *st;
st401drivers/net/pi2.cchar st;
st407drivers/net/pi2.cst = rdscc(lp->cardbase, lp->base + CTL, R0);  /* Fetch status */
st413drivers/net/pi2.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT)) {
st777drivers/net/pi2.cchar st;
st784drivers/net/pi2.cst = rdscc(lp->cardbase, cmd, R0);  /* Fetch status */
st927drivers/net/pi2.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT)) {
st1516drivers/net/pi2.cint st;
st1531drivers/net/pi2.cwhile ((st = rdscc(lp->cardbase, pi0a.base_addr | CHANA | CTL, R3)) != 0) {
st1532drivers/net/pi2.cif (st & CHBTxIP) {
st1536drivers/net/pi2.c} else if (st & CHARxIP) {
st1540drivers/net/pi2.c} else if (st & CHATxIP) {
st1544drivers/net/pi2.c} else if (st & CHAEXT) {
st1548drivers/net/pi2.c} else if (st & CHBRxIP) {
st1552drivers/net/pi2.c} else if (st & CHBEXT) {
st1489drivers/net/pt.cunsigned char st;
st1497drivers/net/pt.cwhile ((st = rdscc(cbase, cbase + CHANA + CTL, R3)) != 0)
st1501drivers/net/pt.cprintk("PTd pt_interrupt(): R3 = %#3x", st);
st1505drivers/net/pt.cprintk(" R2 = %#3x.\n", st);
st1507drivers/net/pt.cif (st & CHARxIP) {
st1511drivers/net/pt.c} else if (st & CHATxIP) {
st1515drivers/net/pt.c} else if (st & CHAEXT) {
st1519drivers/net/pt.c} else if (st & CHBRxIP) {
st1523drivers/net/pt.c} else if (st & CHBTxIP) {
st1527drivers/net/pt.c} else if (st & CHBEXT) {
st1565drivers/net/pt.cunsigned char st;
st1573drivers/net/pt.cst = rdscc(lp->cardbase, cmd, R0);
st1576drivers/net/pt.cprintk("PTd exisr(): R0 = %#3x tstate = %d (%d).\n", st, lp->tstate, lp->base & CHANA);
st1581drivers/net/pt.cif ((lp->rstate >= ACTIVE) && (st & BRK_ABRT) && lp->dmachan)
st1746drivers/net/pt.cif ((lp->rstate == ACTIVE) && (st & BRK_ABRT) )
st1765drivers/net/pt.cif ( (st & DCD) != (lp->saved_RR0 & DCD))
st1768drivers/net/pt.cprintk("PTd: pt_exisr(): DCD is now %s.\n", (st & DCD)? "ON" : "OFF" );
st1770drivers/net/pt.cif (st & DCD)
st1799drivers/net/pt.clp->saved_RR0 = st &~ ZCOUNT;
st126drivers/scsi/aha1740.hst:1,    /* Suppress Transfer */
st79drivers/scsi/eata_dma_proc.cscsitrans   *st;
st109drivers/scsi/eata_dma_proc.cst = (scsitrans *)(buff + 0x164); 
st67include/asm-sparc/kgdb.hst      %reg_y, [%reg + REGWIN_SZ + KGDB_Y]; \
st68include/asm-sparc/kgdb.hst      %reg_psr, [%reg + REGWIN_SZ + KGDB_PSR]; \
st69include/asm-sparc/kgdb.hst      %reg_wim, [%reg + REGWIN_SZ + KGDB_WIM]; \
st70include/asm-sparc/kgdb.hst      %reg_tbr, [%reg + REGWIN_SZ + KGDB_TBR]; \
st71include/asm-sparc/kgdb.hst      %reg_pc, [%reg + REGWIN_SZ + KGDB_PC]; \
st72include/asm-sparc/kgdb.hst      %reg_npc, [%reg + REGWIN_SZ + KGDB_NPC];
st80include/asm-sparc/winmacro.hst      %g1, [%base_reg + REGWIN_SZ + PT_G1]; \
st87include/asm-sparc/winmacro.hst      %scratch, [%base_reg + REGWIN_SZ + PT_Y];
st90include/asm-sparc/winmacro.hst      %pt_psr, [%base_reg + REGWIN_SZ + PT_PSR]; \
st91include/asm-sparc/winmacro.hst      %pt_pc,  [%base_reg + REGWIN_SZ + PT_PC]; \
st92include/asm-sparc/winmacro.hst      %pt_npc, [%base_reg + REGWIN_SZ + PT_NPC];
st104include/asm-sparc/winmacro.hst       %sp, [%scratch + THREAD_STACK_PTRS]; \
st112include/asm-sparc/winmacro.hst       %scratch, [%cur_reg + THREAD_W_SAVED];
st731mm/mmap.cunsigned long st, end;
st738mm/mmap.cst = addr < mpnt->vm_start ? mpnt->vm_start : addr;
st743mm/mmap.cmpnt->vm_ops->unmap(mpnt, st, end-st);
st744mm/mmap.czap_page_range(current->mm, st, end-st);
st745mm/mmap.cunmap_fixup(mpnt, st, end-st);
st1267net/ipx/af_ipx.cstruct sockaddr_ipx *sg,*st;
st1276net/ipx/af_ipx.cst=(struct sockaddr_ipx *)&rt.rt_dst;
st1282net/ipx/af_ipx.cif(st->sipx_family!=AF_IPX)
st1288net/ipx/af_ipx.creturn ipxrtr_delete(st->sipx_network);
st1292net/ipx/af_ipx.cf.ipx_network=st->sipx_network;