taglinefilesource code
sp23arch/alpha/kernel/traps.cunsigned long sp;
sp29arch/alpha/kernel/traps.csp = (unsigned long) (regs+1);
sp31arch/alpha/kernel/traps.cprintk("rp = [<%lx>] sp = %lx\n", regs->r26, sp);
sp42arch/alpha/kernel/traps.cregs->r28, regs->gp, sp);
sp301arch/i386/kernel/vm86.cstatic void do_int(struct vm86_regs *regs, int i, unsigned char * ssp, unsigned long sp)
sp317arch/i386/kernel/vm86.cpushw(ssp, sp, get_vflags(regs));
sp318arch/i386/kernel/vm86.cpushw(ssp, sp, regs->cs);
sp319arch/i386/kernel/vm86.cpushw(ssp, sp, IP(regs));
sp347arch/i386/kernel/vm86.cunsigned long ip, sp;
sp351arch/i386/kernel/vm86.csp = SP(regs);
sp364arch/i386/kernel/vm86.cpushl(ssp, sp, get_vflags(regs));
sp371arch/i386/kernel/vm86.cset_vflags_long(popl(ssp, sp), regs);
sp377arch/i386/kernel/vm86.cIP(regs) = (unsigned short)popl(ssp, sp);
sp378arch/i386/kernel/vm86.cregs->cs = (unsigned short)popl(ssp, sp);
sp379arch/i386/kernel/vm86.cset_vflags_long(popl(ssp, sp), regs);
sp388arch/i386/kernel/vm86.cpushw(ssp, sp, get_vflags(regs));
sp395arch/i386/kernel/vm86.cset_vflags_short(popw(ssp, sp), regs);
sp401arch/i386/kernel/vm86.cdo_int(regs, popb(csp, ip), ssp, sp);
sp407arch/i386/kernel/vm86.cIP(regs) = popw(ssp, sp);
sp408arch/i386/kernel/vm86.cregs->cs = popw(ssp, sp);
sp409arch/i386/kernel/vm86.cset_vflags_short(popw(ssp, sp), regs);
sp546arch/mips/kernel/gdb-stub.cif (sp != newsp)
sp547arch/mips/kernel/gdb-stub.csp = memcpy(newsp, sp, 16 * 4);
sp87arch/mips/kernel/traps.cu32  *sp, *pc, addr, module_start, module_end;
sp93arch/mips/kernel/traps.csp = (u32 *)regs->reg29;
sp109arch/mips/kernel/traps.cprintk("%08x ", *sp++);
sp110arch/mips/kernel/traps.cstack = (int *) sp;
sp119arch/mips/kernel/traps.cstack = (int *)sp;
sp228arch/ppc/kernel/process.cunsigned long *sp = (unsigned long *)_get_SP();
sp231arch/ppc/kernel/process.cwhile (*sp)
sp233arch/ppc/kernel/process.cprintk("%08X ", sp[2]);
sp234arch/ppc/kernel/process.csp = (unsigned long *)*sp;
sp156arch/sparc/kernel/process.cvoid copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
sp183arch/sparc/kernel/process.cchildregs->u_regs[UREG_FP] = sp;
sp448arch/sparc/kernel/sparc-stub.cunsigned long *sp;
sp475arch/sparc/kernel/sparc-stub.csp = (unsigned long *)registers[SP];
sp496arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *) (sp + 8 + 6), ptr, 4); /* FP */
sp502arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *)&sp, ptr, 4);
sp549arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *) (sp + 0), ptr, 16 * 4);
sp567arch/sparc/kernel/sparc-stub.chex2mem(ptr + 16 * 4 * 2, (char *) (sp + 0), 16 * 4);
sp578arch/sparc/kernel/sparc-stub.cif (sp != newsp)
sp579arch/sparc/kernel/sparc-stub.csp = memcpy(newsp, sp, 16 * 4);
sp50arch/sparc/kernel/windows.cunsigned long sp = tp->rwbuf_stkptrs[window];
sp53arch/sparc/kernel/windows.cif(verify_area(VERIFY_WRITE, (char *) sp, sizeof(struct reg_window)))
sp57arch/sparc/kernel/windows.cmemcpy((char *) sp, &tp->reg_window[window], sizeof(struct reg_window));
sp90arch/sparc/kernel/windows.c#define stack_is_bad(sp, rw) \
sp91arch/sparc/kernel/windows.c(((sp) & 7) || verify_area(rw, (char *) (sp), sizeof(struct reg_window)))
sp100arch/sparc/kernel/windows.cunsigned long sp = tp->rwbuf_stkptrs[window];
sp102arch/sparc/kernel/windows.cif(stack_is_bad(sp, VERIFY_WRITE))
sp105arch/sparc/kernel/windows.ccopy_aligned_window((char *) sp, &tp->reg_window[window]);
sp227arch/sparc/mm/fault.cunsigned long sp = current->tss.rwbuf_stkptrs[0];
sp229arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp230arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 1);
sp231arch/sparc/mm/fault.cforce_user_fault(sp, 1);
sp234arch/sparc/mm/fault.cvoid window_underflow_fault(unsigned long sp)
sp236arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp237arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 0);
sp238arch/sparc/mm/fault.cforce_user_fault(sp, 0);
sp243arch/sparc/mm/fault.cunsigned long sp = regs->u_regs[UREG_FP];
sp245arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp246arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 0);
sp247arch/sparc/mm/fault.cforce_user_fault(sp, 0);
sp1000arch/sparc/mm/sun4c.cunsigned long sp = regs->u_regs[UREG_FP];
sp1001arch/sparc/mm/sun4c.cunsigned long sp2 = sp + REGWIN_SZ - 0x8;
sp1004arch/sparc/mm/sun4c.cforce_user_fault(sp, 0);
sp1005arch/sparc/mm/sun4c.cif((sp&PAGE_MASK) != (sp2&PAGE_MASK))
sp670drivers/char/istallion.cstatic void  stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
sp673drivers/char/istallion.cstatic void  stli_getserial(stliport_t *portp, struct serial_struct *sp);
sp674drivers/char/istallion.cstatic int  stli_setserial(stliport_t *portp, struct serial_struct *sp);
sp1793drivers/char/istallion.cstatic void stli_getserial(stliport_t *portp, struct serial_struct *sp)
sp1799drivers/char/istallion.cprintk("stli_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1818drivers/char/istallion.cmemcpy_tofs(sp, &sio, sizeof(struct serial_struct));
sp1829drivers/char/istallion.cstatic int stli_setserial(stliport_t *portp, struct serial_struct *sp)
sp1835drivers/char/istallion.cprintk("stli_setserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1838drivers/char/istallion.cmemcpy_fromfs(&sio, sp, sizeof(struct serial_struct));
sp2814drivers/char/istallion.cstatic void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
sp2817drivers/char/istallion.cprintk("stli_mkasysigs(sp=%x,dtr=%d,rts=%d)\n", (int) sp, dtr, rts);
sp2820drivers/char/istallion.cmemset(sp, 0, sizeof(asysigs_t));
sp2822drivers/char/istallion.csp->signal |= SG_DTR;
sp2823drivers/char/istallion.csp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
sp2826drivers/char/istallion.csp->signal |= SG_RTS;
sp2827drivers/char/istallion.csp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
sp499drivers/char/stallion.cstatic void  stl_getserial(stlport_t *portp, struct serial_struct *sp);
sp500drivers/char/stallion.cstatic int  stl_setserial(stlport_t *portp, struct serial_struct *sp);
sp1144drivers/char/stallion.cstatic void stl_getserial(stlport_t *portp, struct serial_struct *sp)
sp1150drivers/char/stallion.cprintk("stl_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1169drivers/char/stallion.cmemcpy_tofs(sp, &sio, sizeof(struct serial_struct));
sp1180drivers/char/stallion.cstatic int stl_setserial(stlport_t *portp, struct serial_struct *sp)
sp1185drivers/char/stallion.cprintk("stl_setserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1188drivers/char/stallion.cmemcpy_fromfs(&sio, sp, sizeof(struct serial_struct));
sp262drivers/isdn/teles/buffers.cstruct BufHeader *sp;
sp268drivers/isdn/teles/buffers.csp = q->head;
sp269drivers/isdn/teles/buffers.cif (!sp)
sp271drivers/isdn/teles/buffers.cif ((sp->primitive == pr) && (sp->heldby == heldby)) {
sp272drivers/isdn/teles/buffers.cq->head = sp->next;
sp273drivers/isdn/teles/buffers.cif (q->tail == sp)
sp276drivers/isdn/teles/buffers.cBufPoolRelease(sp);
sp281drivers/isdn/teles/buffers.csp = q->head;
sp282drivers/isdn/teles/buffers.cif (sp)
sp283drivers/isdn/teles/buffers.cwhile (sp->next) {
sp284drivers/isdn/teles/buffers.cif ((sp->next->primitive == pr) && (sp->next->heldby == heldby)) {
sp285drivers/isdn/teles/buffers.cif (q->tail == sp->next)
sp286drivers/isdn/teles/buffers.cq->tail = sp;
sp288drivers/isdn/teles/buffers.cBufPoolRelease(sp->next);
sp289drivers/isdn/teles/buffers.csp->next = sp->next->next;
sp291drivers/isdn/teles/buffers.csp = sp->next;
sp707drivers/isdn/teles/callc.cstruct IsdnCardState *sp;
sp710drivers/isdn/teles/callc.csp = st->l1.hardware;
sp711drivers/isdn/teles/callc.chsp = sp->hs + chanlist[chan].hscx;
sp820drivers/isdn/teles/callc.cstruct IsdnCardState *sp = chanlist[chan].sp;
sp823drivers/isdn/teles/callc.csetstack_teles(st, sp);
sp858drivers/isdn/teles/callc.cteles_addlist(sp, st);
sp931drivers/isdn/teles/callc.cchanp->sp = card->sp;
sp981drivers/isdn/teles/callc.cif (cards[i].sp)
sp990drivers/isdn/teles/callc.cif (cards[i].sp) {
sp1092drivers/isdn/teles/callc.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1094drivers/isdn/teles/callc.cstruct HscxState *hsp = sp->hs + chanlist[chan].hscx;
sp1097drivers/isdn/teles/callc.cst->l1.hardware = sp;
sp1171drivers/isdn/teles/callc.cif (cards[i].sp)
sp1172drivers/isdn/teles/callc.ccards[i].sp->dlogflag = debugflags & 4;
sp1225drivers/isdn/teles/callc.cif (cards[i].sp)
sp250drivers/isdn/teles/card.cteles_hscxreport(struct IsdnCardState *sp, int hscx)
sp253drivers/isdn/teles/card.cif (sp->membase) {
sp254drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readhscx_0(sp->membase,
sp256drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readhscx_0(sp->membase,
sp258drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readhscx_0(sp->membase,
sp261drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readhscx_3(sp->iobase,
sp263drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readhscx_3(sp->iobase,
sp265drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readhscx_3(sp->iobase,
sp271drivers/isdn/teles/card.cteles_report(struct IsdnCardState *sp)
sp274drivers/isdn/teles/card.cif (sp->membase) {
sp275drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readisac_0(sp->membase,
sp277drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readisac_0(sp->membase,
sp279drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readisac_0(sp->membase,
sp282drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readisac_3(sp->iobase,
sp284drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readisac_3(sp->iobase,
sp286drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readisac_3(sp->iobase,
sp289drivers/isdn/teles/card.cteles_hscxreport(sp, 0);
sp290drivers/isdn/teles/card.cteles_hscxreport(sp, 1);
sp311drivers/isdn/teles/card.cif (hsp->sp->debug)
sp351drivers/isdn/teles/card.cif (hsp->sp->debug)
sp401drivers/isdn/teles/card.chscx_interrupt(struct IsdnCardState *sp, byte val, byte hscx)
sp404drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp412drivers/isdn/teles/card.cr = READHSCX(hsp->membase, sp->iobase, hsp->hscx, HSCX_RSTA);
sp440drivers/isdn/teles/card.ccount = READHSCX(hsp->membase, sp->iobase, hsp->hscx,
sp500drivers/isdn/teles/card.cisac_sched_event(struct IsdnCardState *sp, int event)
sp502drivers/isdn/teles/card.csp->event |= 1 << event;
sp503drivers/isdn/teles/card.cqueue_task_irq_off(&sp->tqueue, &tq_immediate);
sp508drivers/isdn/teles/card.cempty_fifo(struct IsdnCardState *sp, int count)
sp511drivers/isdn/teles/card.cstruct BufHeader *ibh = sp->rcvibh;
sp513drivers/isdn/teles/card.cif (sp->debug)
sp516drivers/isdn/teles/card.cif (sp->rcvptr >= 3072) {
sp517drivers/isdn/teles/card.cprintk(KERN_WARNING "empty_fifo rcvptr %d\n", sp->rcvptr);
sp521drivers/isdn/teles/card.cptr += sp->rcvptr;
sp522drivers/isdn/teles/card.csp->rcvptr += count;
sp524drivers/isdn/teles/card.cif (sp->membase) {
sp528drivers/isdn/teles/card.c*ptr = readisac_0(sp->membase, 0x0);
sp535drivers/isdn/teles/card.c*ptr++ = readisac_0(sp->membase, 0x0);
sp537drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_CMDR, 0x80);
sp542drivers/isdn/teles/card.creadisac_s(sp->iobase, 0x3e, ptr, count);
sp547drivers/isdn/teles/card.creadisac_s(sp->iobase, 0x3e, ptr, count);
sp549drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_CMDR, 0x80);
sp554drivers/isdn/teles/card.cfill_fifo(struct IsdnCardState *sp)
sp560drivers/isdn/teles/card.cif (sp->debug)
sp563drivers/isdn/teles/card.cibh = sp->xmtibh;
sp567drivers/isdn/teles/card.ccount = ibh->datasize - sp->sendptr;
sp579drivers/isdn/teles/card.cptr += sp->sendptr;
sp580drivers/isdn/teles/card.csp->sendptr += count;
sp582drivers/isdn/teles/card.cif (sp->membase) {
sp586drivers/isdn/teles/card.cwriteisac_0(sp->membase, 0x0, *ptr);
sp593drivers/isdn/teles/card.cwriteisac_0(sp->membase, 0x0, *ptr++);
sp595drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_CMDR, more ? 0x8 : 0xa);
sp599drivers/isdn/teles/card.cwriteisac_s(sp->iobase, 0x3e, ptr, count);
sp605drivers/isdn/teles/card.cwriteisac_s(sp->iobase, 0x3e, ptr, count);
sp607drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_CMDR, more ? 0x8 : 0xa);
sp612drivers/isdn/teles/card.cact_wanted(struct IsdnCardState *sp)
sp616drivers/isdn/teles/card.cst = sp->stlist;
sp626drivers/isdn/teles/card.cph_command(struct IsdnCardState *sp, unsigned int command)
sp629drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_CIX0, (command << 2) | 3);
sp633drivers/isdn/teles/card.cisac_new_ph(struct IsdnCardState *sp)
sp637drivers/isdn/teles/card.cenq = act_wanted(sp);
sp639drivers/isdn/teles/card.cswitch (sp->ph_state) {
sp643drivers/isdn/teles/card.cph_command(sp, 0);
sp645drivers/isdn/teles/card.cph_command(sp, 15);
sp649drivers/isdn/teles/card.cph_command(sp, 9);
sp653drivers/isdn/teles/card.csp->ph_active = 5;
sp654drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_PHCHANGE);
sp655drivers/isdn/teles/card.cif (!sp->xmtibh)
sp656drivers/isdn/teles/card.cif (!BufQueueUnlink(&sp->xmtibh, &sp->sq))
sp657drivers/isdn/teles/card.csp->sendptr = 0;
sp658drivers/isdn/teles/card.cif (sp->xmtibh)
sp659drivers/isdn/teles/card.cfill_fifo(sp);
sp665drivers/isdn/teles/card.csp->ph_active = 0;
sp674drivers/isdn/teles/card.cstruct IsdnCardState *sp;
sp678drivers/isdn/teles/card.csp = (struct IsdnCardState *) irq2dev_map[intno];
sp680drivers/isdn/teles/card.cif (!sp) {
sp684drivers/isdn/teles/card.cval = READHSCX(sp->membase, sp->iobase, 1, HSCX_ISTA);
sp687drivers/isdn/teles/card.chsp = sp->hs + 1;
sp689drivers/isdn/teles/card.cREADHSCX(sp->membase, sp->iobase, 1, HSCX_EXIR),
sp694drivers/isdn/teles/card.cif (sp->debug)
sp696drivers/isdn/teles/card.chscx_interrupt(sp, val, 1);
sp700drivers/isdn/teles/card.cREADHSCX(sp->membase, sp->iobase, 0, HSCX_EXIR));
sp704drivers/isdn/teles/card.cif (sp->membase) {
sp706drivers/isdn/teles/card.cval = readhscx_0(sp->membase, 0, HSCX_ISTA);
sp707drivers/isdn/teles/card.cif (sp->debug)
sp710drivers/isdn/teles/card.chscx_interrupt(sp, val, 0);
sp713drivers/isdn/teles/card.cval2 = readhscx_3(sp->iobase, 0, HSCX_ISTA);
sp714drivers/isdn/teles/card.cif (sp->debug)
sp717drivers/isdn/teles/card.cif (sp->debug)
sp720drivers/isdn/teles/card.chscx_interrupt(sp, val2, 0);
sp725drivers/isdn/teles/card.cval = READISAC(sp->membase, sp->iobase, ISAC_ISTA);
sp727drivers/isdn/teles/card.cif (sp->debug)
sp732drivers/isdn/teles/card.cr = READISAC(sp->membase, sp->iobase, ISAC_RSTA);
sp738drivers/isdn/teles/card.cif (sp->rcvibh)
sp739drivers/isdn/teles/card.cBufPoolRelease(sp->rcvibh);
sp740drivers/isdn/teles/card.csp->rcvibh = NULL;
sp741drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_CMDR, 0x80);
sp744drivers/isdn/teles/card.cif (!sp->rcvibh)
sp745drivers/isdn/teles/card.cif (BufPoolGet(&(sp->rcvibh), &(sp->rbufpool),
sp750drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, 
sp754drivers/isdn/teles/card.csp->rcvptr = 0;
sp756drivers/isdn/teles/card.ccount = READISAC(sp->membase, sp->iobase, ISAC_RBCL) & 0x1f;
sp759drivers/isdn/teles/card.cempty_fifo(sp, count);
sp760drivers/isdn/teles/card.csp->rcvibh->datasize = sp->rcvptr;
sp761drivers/isdn/teles/card.cBufQueueLink(&(sp->rq), sp->rcvibh);
sp762drivers/isdn/teles/card.csp->rcvibh = NULL;
sp763drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_RCVBUFREADY);
sp767drivers/isdn/teles/card.cif (!sp->rcvibh)
sp768drivers/isdn/teles/card.cif (BufPoolGet(&(sp->rcvibh), &(sp->rbufpool),
sp773drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase,
sp777drivers/isdn/teles/card.csp->rcvptr = 0;
sp778drivers/isdn/teles/card.cempty_fifo(sp, 32);
sp784drivers/isdn/teles/card.cif (sp->xmtibh)
sp785drivers/isdn/teles/card.cif (sp->xmtibh->datasize > sp->sendptr) {
sp786drivers/isdn/teles/card.cfill_fifo(sp);
sp789drivers/isdn/teles/card.cif (sp->releasebuf)
sp790drivers/isdn/teles/card.cBufPoolRelease(sp->xmtibh);
sp791drivers/isdn/teles/card.csp->xmtibh = NULL;
sp792drivers/isdn/teles/card.csp->sendptr = 0;
sp794drivers/isdn/teles/card.cif (!BufQueueUnlink(&sp->xmtibh, &sp->sq)) {
sp795drivers/isdn/teles/card.csp->releasebuf = !0;
sp796drivers/isdn/teles/card.cfill_fifo(sp);
sp798drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_XMTBUFREADY);
sp802drivers/isdn/teles/card.csp->ph_state = (READISAC(sp->membase, sp->iobase, ISAC_CIX0)
sp804drivers/isdn/teles/card.cprintk(KERN_DEBUG "l1state %d\n", sp->ph_state);
sp805drivers/isdn/teles/card.cisac_new_ph(sp);
sp807drivers/isdn/teles/card.cif (sp->membase) {
sp808drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_MASK, 0xFF);
sp809drivers/isdn/teles/card.cwritehscx_0(sp->membase, 0, HSCX_MASK, 0xFF);
sp810drivers/isdn/teles/card.cwritehscx_0(sp->membase, 1, HSCX_MASK, 0xFF);
sp811drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_MASK, 0x0);
sp812drivers/isdn/teles/card.cwritehscx_0(sp->membase, 0, HSCX_MASK, 0x0);
sp813drivers/isdn/teles/card.cwritehscx_0(sp->membase, 1, HSCX_MASK, 0x0);
sp815drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_MASK, 0xFF);
sp816drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 0, HSCX_MASK, 0xFF);
sp817drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 1, HSCX_MASK, 0xFF);
sp818drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_MASK, 0x0);
sp819drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 0, HSCX_MASK, 0x0);
sp820drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 1, HSCX_MASK, 0x0);
sp829drivers/isdn/teles/card.cact_ivated(struct IsdnCardState *sp)
sp833drivers/isdn/teles/card.cst = sp->stlist;
sp844drivers/isdn/teles/card.cprocess_new_ph(struct IsdnCardState *sp)
sp846drivers/isdn/teles/card.cif (sp->ph_active == 5)
sp847drivers/isdn/teles/card.cact_ivated(sp);
sp851drivers/isdn/teles/card.cprocess_xmt(struct IsdnCardState *sp)
sp855drivers/isdn/teles/card.cif (sp->xmtibh)
sp858drivers/isdn/teles/card.cstptr = sp->stlist;
sp869drivers/isdn/teles/card.cprocess_rcv(struct IsdnCardState *sp)
sp877drivers/isdn/teles/card.cwhile (!BufQueueUnlink(&ibh, &sp->rq)) {
sp878drivers/isdn/teles/card.cstptr = sp->stlist;
sp882drivers/isdn/teles/card.cif (broadc && sp->dlogflag && (!(ptr[0] >> 2)))
sp883drivers/isdn/teles/card.cdlogframe(sp, ptr + 3, ibh->datasize - 3,
sp889drivers/isdn/teles/card.cif (!BufPoolGet(&cibh, &sp->rbufpool, GFP_ATOMIC,
sp917drivers/isdn/teles/card.cdlogframe(sp, ptr + 4, ibh->datasize - 4, tmp);
sp928drivers/isdn/teles/card.cisac_bh(struct IsdnCardState *sp)
sp930drivers/isdn/teles/card.cif (!sp)
sp933drivers/isdn/teles/card.cif (clear_bit(ISAC_PHCHANGE, &sp->event))
sp934drivers/isdn/teles/card.cprocess_new_ph(sp);
sp935drivers/isdn/teles/card.cif (clear_bit(ISAC_RCVBUFREADY, &sp->event))
sp936drivers/isdn/teles/card.cprocess_rcv(sp);
sp937drivers/isdn/teles/card.cif (clear_bit(ISAC_XMTBUFREADY, &sp->event))
sp938drivers/isdn/teles/card.cprocess_xmt(sp);
sp994drivers/isdn/teles/card.crestart_ph(struct IsdnCardState *sp)
sp996drivers/isdn/teles/card.cswitch (sp->ph_active) {
sp998drivers/isdn/teles/card.cif (sp->ph_state == 6)
sp999drivers/isdn/teles/card.cph_command(sp, 0);
sp1001drivers/isdn/teles/card.cph_command(sp, 1);
sp1002drivers/isdn/teles/card.csp->ph_active = 1;
sp1176drivers/isdn/teles/card.cstruct IsdnCardState *sp = hs->sp;
sp1185drivers/isdn/teles/card.cif (sp->membase) {
sp1186drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR1, 0x85);
sp1187drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XAD1, 0xFF);
sp1188drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XAD2, 0xFF);
sp1189drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RAH2, 0xFF);
sp1190drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XBCH, 0x0);
sp1194drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1195drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0xff);
sp1196drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0xff);
sp1197drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1198drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1199drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0x84);
sp1203drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1204drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x7);
sp1205drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x7);
sp1206drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1207drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1209drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1210drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x3);
sp1211drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x3);
sp1212drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1213drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1215drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0xe4);
sp1216drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CMDR, 0x41);
sp1220drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1221drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x7);
sp1222drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x7);
sp1223drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1224drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1226drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1227drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x3);
sp1228drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x3);
sp1229drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1230drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1232drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0x8c);
sp1233drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CMDR, 0x41);
sp1236drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_ISTA, 0x00);
sp1238drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR1, 0x85);
sp1239drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XAD1, 0xFF);
sp1240drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XAD2, 0xFF);
sp1241drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RAH2, 0xFF);
sp1242drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XBCH, 0x00);
sp1243drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RLCR, 0x00);
sp1247drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1248drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0xff);
sp1249drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0xff);
sp1250drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1251drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1252drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0x84);
sp1256drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1257drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x2f);
sp1258drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x2f);
sp1259drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1260drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1262drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1263drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x3);
sp1264drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x3);
sp1265drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1266drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1268drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0xe4);
sp1269drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CMDR, 0x41);
sp1273drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1274drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x2f);
sp1275drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x2f);
sp1276drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1277drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1279drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1280drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x3);
sp1281drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x3);
sp1282drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1283drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1285drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0x8c);
sp1286drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CMDR, 0x41);
sp1289drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_ISTA, 0x00);
sp1294drivers/isdn/teles/card.cteles_addlist(struct IsdnCardState *sp,
sp1297drivers/isdn/teles/card.cst->next = sp->stlist;
sp1298drivers/isdn/teles/card.csp->stlist = st;
sp1302drivers/isdn/teles/card.cteles_rmlist(struct IsdnCardState *sp,
sp1307drivers/isdn/teles/card.cif (sp->stlist == st)
sp1308drivers/isdn/teles/card.csp->stlist = st->next;
sp1310drivers/isdn/teles/card.cp = sp->stlist;
sp1325drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1331drivers/isdn/teles/card.cif (sp->xmtibh)
sp1332drivers/isdn/teles/card.cBufQueueLink(&sp->sq, ibh);
sp1334drivers/isdn/teles/card.csp->xmtibh = ibh;
sp1335drivers/isdn/teles/card.csp->sendptr = 0;
sp1336drivers/isdn/teles/card.csp->releasebuf = !0;
sp1337drivers/isdn/teles/card.cfill_fifo(sp);
sp1341drivers/isdn/teles/card.cif (sp->xmtibh) {
sp1345drivers/isdn/teles/card.csp->xmtibh = ibh;
sp1346drivers/isdn/teles/card.csp->sendptr = 0;
sp1347drivers/isdn/teles/card.csp->releasebuf = 0;
sp1348drivers/isdn/teles/card.cfill_fifo(sp);
sp1351drivers/isdn/teles/card.cif (!sp->xmtibh) {
sp1361drivers/isdn/teles/card.ccheck_ph_act(struct IsdnCardState *sp)
sp1363drivers/isdn/teles/card.cstruct PStack  *st = sp->stlist;
sp1370drivers/isdn/teles/card.csp->ph_active = 0;
sp1377drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1385drivers/isdn/teles/card.cif (sp->ph_active == 5) {
sp1391drivers/isdn/teles/card.cif (sp->ph_active == 0)
sp1392drivers/isdn/teles/card.crestart_ph(sp);
sp1398drivers/isdn/teles/card.ccheck_ph_act(sp);
sp1407drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *) st->l1.hardware;
sp1410drivers/isdn/teles/card.cif (sp->magic != 301271) {
sp1416drivers/isdn/teles/card.cBufQueueDiscard(&sp->sq, pr, heldby, releasetoo);
sp1420drivers/isdn/teles/card.csetstack_teles(struct PStack *st, struct IsdnCardState *sp)
sp1422drivers/isdn/teles/card.cst->l1.hardware = sp;
sp1423drivers/isdn/teles/card.cst->l1.sbufpool = &(sp->sbufpool);
sp1424drivers/isdn/teles/card.cst->l1.rbufpool = &(sp->rbufpool);
sp1425drivers/isdn/teles/card.cst->l1.smallpool = &(sp->smallpool);
sp1426drivers/isdn/teles/card.cst->protocol = sp->teistack->protocol;
sp1430drivers/isdn/teles/card.cst->l1.stlistp = &(sp->stlist);
sp1439drivers/isdn/teles/card.cinit_hscxstate(struct IsdnCardState *sp,
sp1442drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp1444drivers/isdn/teles/card.chsp->sp = sp;
sp1446drivers/isdn/teles/card.chsp->membase = sp->membase;
sp1447drivers/isdn/teles/card.chsp->iobase = sp->iobase;
sp1466drivers/isdn/teles/card.cstruct IsdnCardState *sp;
sp1469drivers/isdn/teles/card.csp = (struct IsdnCardState *)
sp1473drivers/isdn/teles/card.csp->membase = card->membase;
sp1474drivers/isdn/teles/card.csp->iobase = card->iobase;
sp1475drivers/isdn/teles/card.csp->cardnr = cardnr;
sp1477drivers/isdn/teles/card.cBufPoolInit(&sp->sbufpool, ISAC_SBUF_ORDER, ISAC_SBUF_BPPS,
sp1479drivers/isdn/teles/card.cBufPoolInit(&sp->rbufpool, ISAC_RBUF_ORDER, ISAC_RBUF_BPPS,
sp1481drivers/isdn/teles/card.cBufPoolInit(&sp->smallpool, ISAC_SMALLBUF_ORDER, ISAC_SMALLBUF_BPPS,
sp1484drivers/isdn/teles/card.csp->dlogspace = Smalloc(4096, GFP_KERNEL, "dlogspace");
sp1488drivers/isdn/teles/card.csp->rcvibh = NULL;
sp1489drivers/isdn/teles/card.csp->rcvptr = 0;
sp1490drivers/isdn/teles/card.csp->xmtibh = NULL;
sp1491drivers/isdn/teles/card.csp->sendptr = 0;
sp1492drivers/isdn/teles/card.csp->event = 0;
sp1493drivers/isdn/teles/card.csp->tqueue.next = 0;
sp1494drivers/isdn/teles/card.csp->tqueue.sync = 0;
sp1495drivers/isdn/teles/card.csp->tqueue.routine = (void *) (void *) isac_bh;
sp1496drivers/isdn/teles/card.csp->tqueue.data = sp;
sp1498drivers/isdn/teles/card.cBufQueueInit(&sp->rq);
sp1499drivers/isdn/teles/card.cBufQueueInit(&sp->sq);
sp1501drivers/isdn/teles/card.csp->stlist = NULL;
sp1503drivers/isdn/teles/card.csp->ph_active = 0;
sp1505drivers/isdn/teles/card.csp->dlogflag = 0;
sp1506drivers/isdn/teles/card.csp->debug = 0;
sp1508drivers/isdn/teles/card.csp->releasebuf = 0;
sp1510drivers/isdn/teles/card.csp->magic = 301271;
sp1513drivers/isdn/teles/card.ccards[sp->cardnr].sp = sp;
sp1515drivers/isdn/teles/card.cinit_hscxstate(sp, 0);
sp1516drivers/isdn/teles/card.cinit_hscxstate(sp, 1);
sp1518drivers/isdn/teles/card.cmodehscx(sp->hs, 0, 0);
sp1519drivers/isdn/teles/card.cmodehscx(sp->hs + 1, 0, 0);
sp1521drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_MASK, 0x0);
sp1539drivers/isdn/teles/card.cirq2dev_map[card->interrupt] = (void *) card->sp;
sp1570drivers/isdn/teles/card.cstruct IsdnCardState *sp = cards[cardnr].sp;
sp1572drivers/isdn/teles/card.ccards[cardnr].sp = NULL;
sp1574drivers/isdn/teles/card.cSfree(sp->dlogspace);
sp1576drivers/isdn/teles/card.cBufPoolFree(&sp->smallpool);
sp1577drivers/isdn/teles/card.cBufPoolFree(&sp->rbufpool);
sp1578drivers/isdn/teles/card.cBufPoolFree(&sp->sbufpool);
sp1580drivers/isdn/teles/card.cclose_hscxstate(sp->hs + 1);
sp1581drivers/isdn/teles/card.cclose_hscxstate(sp->hs);
sp1586drivers/isdn/teles/card.cSfree((void *) sp);
sp1637drivers/isdn/teles/card.cif (cards[i].sp) {
sp1647drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1649drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp1689drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1691drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp1704drivers/isdn/teles/card.copen_hscxstate(struct IsdnCardState *sp,
sp1707drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp1735drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1737drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp615drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
sp622drivers/isdn/teles/isdnl2.cif (sp->dlogflag) {
sp624drivers/isdn/teles/isdnl2.cdlogframe(sp, ptr + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
sp640drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
sp665drivers/isdn/teles/isdnl2.cif (sp->dlogflag) {
sp787drivers/isdn/teles/q931.cdlogframe(struct IsdnCardState *sp, byte * buf, int size, char *comment)
sp794drivers/isdn/teles/q931.cdp = sp->dlogspace;
sp804drivers/isdn/teles/q931.cteles_putstatus(sp->dlogspace);
sp805drivers/isdn/teles/q931.cdp = sp->dlogspace;
sp868drivers/isdn/teles/q931.cteles_putstatus(sp->dlogspace);
sp143drivers/isdn/teles/tei.ctei_man(struct PStack *sp, int i, void *v)
sp151drivers/isdn/teles/tei.cstruct IsdnCardState *sp = st->l1.hardware;
sp153drivers/isdn/teles/tei.ctei_handler(sp->teistack, pr, arg);
sp163drivers/isdn/teles/tei.cinit_tei(struct IsdnCardState *sp, int protocol)
sp174drivers/isdn/teles/tei.csp->teistack = st;                  /* struct is not initialized yet */
sp175drivers/isdn/teles/tei.csp->teistack->protocol = protocol;  /* struct is not initialized yet */
sp179drivers/isdn/teles/tei.csetstack_teles(st, sp);
sp197drivers/isdn/teles/tei.csprintf(tmp, "Card %d tei ", sp->cardnr);
sp209drivers/isdn/teles/tei.cteles_addlist(sp, st);
sp210drivers/isdn/teles/tei.csp->teistack = st;
sp214drivers/isdn/teles/tei.crelease_tei(struct IsdnCardState *sp)
sp216drivers/isdn/teles/tei.cstruct PStack  *st = sp->teistack;
sp218drivers/isdn/teles/tei.cteles_rmlist(sp, st);
sp228drivers/isdn/teles/tei.cif (cards[i].sp)
sp229drivers/isdn/teles/tei.cinit_tei(cards[i].sp, cards[i].protocol);
sp238drivers/isdn/teles/tei.cif (cards[i].sp)
sp239drivers/isdn/teles/tei.crelease_tei(cards[i].sp);
sp301drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp346drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp382drivers/isdn/teles/teles.hvoid            setstack_teles(struct PStack *st, struct IsdnCardState *sp);
sp385drivers/isdn/teles/teles.hvoid            teles_addlist(struct IsdnCardState *sp,
sp388drivers/isdn/teles/teles.hvoid            teles_rmlist(struct IsdnCardState *sp,
sp422drivers/isdn/teles/teles.hvoid            dlogframe(struct IsdnCardState *sp, byte * p, int size, char *comment);
sp443drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp2520drivers/scsi/aic7xxx.cstruct aic7xxx_xferstats *sp;
sp2524drivers/scsi/aic7xxx.csp = &p->stats[cmd->channel & 0x01][cmd->target & 0x0F][cmd->lun & 0x07];
sp2525drivers/scsi/aic7xxx.csp->xfers++;
sp2529drivers/scsi/aic7xxx.csp->w_total++;
sp2530drivers/scsi/aic7xxx.csp->w_total512 += (actual >> 9);
sp2531drivers/scsi/aic7xxx.cptr = sp->w_bins;
sp2535drivers/scsi/aic7xxx.csp->r_total++;
sp2536drivers/scsi/aic7xxx.csp->r_total512 += (actual >> 9);
sp2537drivers/scsi/aic7xxx.cptr = sp->r_bins;
sp193drivers/scsi/aic7xxx_proc.cstruct aic7xxx_xferstats *sp;
sp207drivers/scsi/aic7xxx_proc.csp = &p->stats[channel][target][lun];
sp208drivers/scsi/aic7xxx_proc.cif (sp->xfers == 0)
sp215drivers/scsi/aic7xxx_proc.csp->xfers, sp->r_total, sp->w_total);
sp217drivers/scsi/aic7xxx_proc.csp->r_total512, sp->w_total512);
sp220drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[0],
sp221drivers/scsi/aic7xxx_proc.csp->r_bins[1], sp->r_bins[2], sp->r_bins[3]);
sp222drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[4],
sp223drivers/scsi/aic7xxx_proc.csp->r_bins[5], sp->r_bins[6], sp->r_bins[7]);
sp224drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->r_bins[8],
sp225drivers/scsi/aic7xxx_proc.csp->r_bins[9]);
sp227drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[0],
sp228drivers/scsi/aic7xxx_proc.csp->w_bins[1], sp->w_bins[2], sp->w_bins[3]);
sp229drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[4],
sp230drivers/scsi/aic7xxx_proc.csp->w_bins[5], sp->w_bins[6], sp->w_bins[7]);
sp231drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->w_bins[8],
sp232drivers/scsi/aic7xxx_proc.csp->w_bins[9]);
sp315drivers/scsi/eata.cstruct mssp sp[MAX_MAILBOXES];       /* Returned status for this board */
sp659drivers/scsi/eata.cspp = &HD(j)->sp[i];
sp925drivers/scsi/eata.cspp = &HD(j)->sp[i];
sp159drivers/scsi/eata_dma.cstruct eata_sp *sp;
sp176drivers/scsi/eata_dma.csp = &SD(sh)->sp;
sp177drivers/scsi/eata_dma.ccp = sp->ccb;
sp188drivers/scsi/eata_dma.chba_stat = sp->hba_stat;
sp190drivers/scsi/eata_dma.cscsi_stat = (sp->scsi_stat >> 1) & 0x1f; 
sp192drivers/scsi/eata_dma.cif (sp->EOC == FALSE) {
sp503drivers/scsi/eata_dma.ccp->cp_statDMA = htonl(virt_to_bus(&(hd->sp)));
sp583drivers/scsi/eata_dma.cScsi_Cmnd *sp; 
sp624drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
sp626drivers/scsi/eata_dma.cprintk("eata_reset: slot %d in reset, pid %ld.\n", x, sp->pid);
sp629drivers/scsi/eata_dma.cif (sp == NULL)
sp633drivers/scsi/eata_dma.cif (sp == cmd)
sp663drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
sp664drivers/scsi/eata_dma.csp->result = DID_RESET << 16;
sp670drivers/scsi/eata_dma.cx, sp->pid);
sp673drivers/scsi/eata_dma.csp->scsi_done(sp);
sp694drivers/scsi/eata_dma.cstruct eata_sp  *sp;
sp701drivers/scsi/eata_dma.csp = (struct eata_sp *) scsi_init_malloc(sizeof(struct eata_sp), 
sp707drivers/scsi/eata_dma.cmemset(sp, 0, sizeof(struct eata_sp));
sp717drivers/scsi/eata_dma.ccp->cp_statDMA = htonl(virt_to_bus(sp));
sp742drivers/scsi/eata_dma.cfake_int_result, (u32) (sp->hba_stat /*& 0x7f*/), 
sp743drivers/scsi/eata_dma.c(u32) sp->scsi_stat, buff, sp));
sp746drivers/scsi/eata_dma.cscsi_init_free((void *)sp, sizeof(struct eata_sp));
sp6drivers/scsi/eata_dma_proc.cu16 *sp, h_sp;
sp10drivers/scsi/eata_dma_proc.csp = ((short *)lp) + 1;      /* Convert Header */
sp11drivers/scsi/eata_dma_proc.ch_sp = *sp = ntohs(*sp);
sp15drivers/scsi/eata_dma_proc.csp = (u16 *)lp;      /* Convert SubHeader */
sp16drivers/scsi/eata_dma_proc.c*sp = ntohs(*sp);
sp358drivers/scsi/eata_generic.hstruct eata_sp sp;     /* status packet         */ 
sp454drivers/scsi/eata_pio.cScsi_Cmnd *sp; 
sp482drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
sp484drivers/scsi/eata_pio.cprintk("eata_pio_reset: slot %d in reset, pid %ld.\n", x, sp->pid);
sp487drivers/scsi/eata_pio.cif (sp == NULL)
sp510drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
sp511drivers/scsi/eata_pio.csp->result = DID_RESET << 16;
sp518drivers/scsi/eata_pio.csp->scsi_done(sp);
sp208fs/binfmt_aout.cunsigned long * sp;
sp212fs/binfmt_aout.csp = (unsigned long *) ((-(unsigned long)sizeof(char *)) & (unsigned long) p);
sp215fs/binfmt_aout.cput_user(0, --sp);
sp216fs/binfmt_aout.cput_user(0, --sp);
sp218fs/binfmt_aout.cput_user(0, --sp);
sp219fs/binfmt_aout.cput_user(0x3eb, --sp);
sp220fs/binfmt_aout.cput_user(bprm->loader, --sp);
sp221fs/binfmt_aout.cput_user(0x3ea, --sp);
sp223fs/binfmt_aout.cput_user(bprm->exec, --sp);
sp224fs/binfmt_aout.cput_user(0x3e9, --sp);
sp226fs/binfmt_aout.csp -= envc+1;
sp227fs/binfmt_aout.cenvp = sp;
sp228fs/binfmt_aout.csp -= argc+1;
sp229fs/binfmt_aout.cargv = sp;
sp232fs/binfmt_aout.cput_user(envp,--sp);
sp233fs/binfmt_aout.cput_user(argv,--sp);
sp236fs/binfmt_aout.cput_user(argc,--sp);
sp250fs/binfmt_aout.creturn sp;
sp96fs/binfmt_elf.cunsigned long * sp;
sp98fs/binfmt_elf.csp = (unsigned long *) (0xfffffffc & (unsigned long) p);
sp99fs/binfmt_elf.csp -= exec ? DLINFO_ITEMS*2 : 2;
sp100fs/binfmt_elf.cdlinfo = sp;
sp101fs/binfmt_elf.csp -= envc+1;
sp102fs/binfmt_elf.cenvp = sp;
sp103fs/binfmt_elf.csp -= argc+1;
sp104fs/binfmt_elf.cargv = sp;
sp106fs/binfmt_elf.cput_user(envp,--sp);
sp107fs/binfmt_elf.cput_user(argv,--sp);
sp132fs/binfmt_elf.cput_user((unsigned long)argc,--sp);
sp146fs/binfmt_elf.creturn sp;
sp66fs/xiafs/inode.cstruct xiafs_super_block *sp;
sp83fs/xiafs/inode.csp = (struct xiafs_super_block *) bh->b_data;
sp84fs/xiafs/inode.cs->s_magic = sp->s_magic;
sp95fs/xiafs/inode.cs->s_blocksize = sp->s_zone_size;
sp96fs/xiafs/inode.cs->s_blocksize_bits = 10 + sp->s_zone_shift;
sp107fs/xiafs/inode.csp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
sp109fs/xiafs/inode.cs->u.xiafs_sb.s_nzones = sp->s_nzones;
sp110fs/xiafs/inode.cs->u.xiafs_sb.s_ninodes = sp->s_ninodes;
sp111fs/xiafs/inode.cs->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
sp112fs/xiafs/inode.cs->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
sp113fs/xiafs/inode.cs->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
sp114fs/xiafs/inode.cs->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
sp115fs/xiafs/inode.cs->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
sp116fs/xiafs/inode.cs->u.xiafs_sb.s_max_size = sp->s_max_size;
sp11fs/xiafs/xiafs_mac.h#define XIAFS_ZSHIFT(sp)    ((sp)->u.xiafs_sb.s_zone_shift)
sp12fs/xiafs/xiafs_mac.h#define XIAFS_ZSIZE(sp)    (BLOCK_SIZE << XIAFS_ZSHIFT(sp))
sp13fs/xiafs/xiafs_mac.h#define XIAFS_ZSIZE_BITS(sp)  (BLOCK_SIZE_BITS + XIAFS_ZSHIFT(sp))
sp14fs/xiafs/xiafs_mac.h#define XIAFS_ADDRS_PER_Z(sp)     (BLOCK_SIZE >> (2 - XIAFS_ZSHIFT(sp)))
sp15fs/xiafs/xiafs_mac.h#define XIAFS_ADDRS_PER_Z_BITS(sp)   (BLOCK_SIZE_BITS - 2 + XIAFS_ZSHIFT(sp))
sp16fs/xiafs/xiafs_mac.h#define XIAFS_BITS_PER_Z(sp)  (BLOCK_SIZE  << (3 + XIAFS_ZSHIFT(sp)))
sp17fs/xiafs/xiafs_mac.h#define XIAFS_BITS_PER_Z_BITS(sp)  (BLOCK_SIZE_BITS + 3 + XIAFS_ZSHIFT(sp))
sp18fs/xiafs/xiafs_mac.h#define XIAFS_INODES_PER_Z(sp)  (_XIAFS_INODES_PER_BLOCK << XIAFS_ZSHIFT(sp))
sp77include/asm-alpha/processor.hstatic inline void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
sp81include/asm-alpha/processor.hwrusp(sp);
sp13include/asm-i386/locks.hextern __inline__ void prim_spin_lock(struct spinlock *sp)
sp21include/asm-i386/locks.hwhile(lock_set_bit(0,&sp->lock))
sp27include/asm-i386/locks.hif(sp->cpu==processor)
sp29include/asm-i386/locks.hsp->users++;
sp35include/asm-i386/locks.hwhile(sp->lock)
sp44include/asm-i386/locks.hsp->spins++;
sp51include/asm-i386/locks.hsp->users++;sp->cpu=processor;
sp59include/asm-i386/locks.hextern __inline__ int prim_spin_unlock(struct spinlock *sp)
sp63include/asm-i386/locks.hif(!--sp->users)
sp65include/asm-i386/locks.hlock_clear_bit(0,&sp->lock);sp->cpu= NO_PROC_ID;
sp76include/asm-i386/locks.hextern __inline__ int prim_spin_lock_nb(struct spinlock *sp)
sp78include/asm-i386/locks.hif(lock_set_bit(0,&sp->lock))
sp80include/asm-i386/locks.hsp->users++;
sp89include/asm-i386/locks.hextern __inline__ void spinlock(struct spinlock *sp)
sp91include/asm-i386/locks.hif(sp->priority<current->lock_order)
sp92include/asm-i386/locks.hpanic("lock order violation: %s (%d)\n", sp->name, current->lock_order);
sp93include/asm-i386/locks.hif(prim_spin_lock(sp))
sp98include/asm-i386/locks.hsp->oldpri=current->lock_order;
sp99include/asm-i386/locks.hcurrent->lock_order=sp->priority;
sp103include/asm-i386/locks.hextern __inline__ void spinunlock(struct spinlock *sp)
sp105include/asm-i386/locks.hif(current->lock_order!=sp->priority)
sp106include/asm-i386/locks.hpanic("lock release order violation %s (%d)\n", sp->name, current->lock_order);
sp107include/asm-i386/locks.hif(prim_spin_unlock(sp))
sp113include/asm-i386/locks.hcurrent->lock_order=sp->oldpri;
sp117include/asm-i386/locks.hextern __inline__ void spintestlock(struct spinlock *sp)
sp123include/asm-i386/locks.hprim_spin_lock_nb(sp);
sp126include/asm-i386/locks.hextern __inline__ void spintestunlock(struct spinlock *sp)
sp132include/asm-i386/locks.hprim_spin_unlock(sp);
sp85include/asm-mips/asm.hsymbol:      .frame  sp,0,ra
sp95include/asm-mips/asm.hsymbol:      .frame  sp, framesize, rpc
sp172include/asm-mips/processor.hvoid start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
sp188include/asm-mips/processor.hregs->reg29 = sp;
sp84include/asm-mips/stackframe.hmove  k1,sp;                          \
sp90include/asm-mips/stackframe.h8:    move  k0,sp;                          \
sp91include/asm-mips/stackframe.hsubu  sp,k1,FR_SIZE;                  \
sp92include/asm-mips/stackframe.hsw  k0,FR_REG29(sp);                \
sp93include/asm-mips/stackframe.hsw  $2,FR_REG2(sp);                 \
sp94include/asm-mips/stackframe.hsw  $2,FR_ORIG_REG2(sp);            \
sp96include/asm-mips/stackframe.hsw  v0,FR_STATUS(sp);               \
sp98include/asm-mips/stackframe.hsw  v0,FR_CAUSE(sp);                \
sp100include/asm-mips/stackframe.hsw  v0,FR_EPC(sp);                  \
sp102include/asm-mips/stackframe.hsw  v0,FR_HI(sp);                   \
sp104include/asm-mips/stackframe.hsw  v0,FR_LO(sp);                   \
sp105include/asm-mips/stackframe.hsw  $1,FR_REG1(sp);                 \
sp106include/asm-mips/stackframe.hsw  $3,FR_REG3(sp);                 \
sp107include/asm-mips/stackframe.hsw  $4,FR_REG4(sp);                 \
sp108include/asm-mips/stackframe.hsw  $5,FR_REG5(sp);                 \
sp109include/asm-mips/stackframe.hsw  $6,FR_REG6(sp);                 \
sp110include/asm-mips/stackframe.hsw  $7,FR_REG7(sp);                 \
sp111include/asm-mips/stackframe.hsw  $8,FR_REG8(sp);                 \
sp112include/asm-mips/stackframe.hsw  $9,FR_REG9(sp);                 \
sp113include/asm-mips/stackframe.hsw  $10,FR_REG10(sp);               \
sp114include/asm-mips/stackframe.hsw  $11,FR_REG11(sp);               \
sp115include/asm-mips/stackframe.hsw  $12,FR_REG12(sp);               \
sp116include/asm-mips/stackframe.hsw  $13,FR_REG13(sp);               \
sp117include/asm-mips/stackframe.hsw  $14,FR_REG14(sp);               \
sp118include/asm-mips/stackframe.hsw  $15,FR_REG15(sp);               \
sp119include/asm-mips/stackframe.hsw  $16,FR_REG16(sp);               \
sp120include/asm-mips/stackframe.hsw  $17,FR_REG17(sp);               \
sp121include/asm-mips/stackframe.hsw  $18,FR_REG18(sp);               \
sp122include/asm-mips/stackframe.hsw  $19,FR_REG19(sp);               \
sp123include/asm-mips/stackframe.hsw  $20,FR_REG20(sp);               \
sp124include/asm-mips/stackframe.hsw  $21,FR_REG21(sp);               \
sp125include/asm-mips/stackframe.hsw  $22,FR_REG22(sp);               \
sp126include/asm-mips/stackframe.hsw  $23,FR_REG23(sp);               \
sp127include/asm-mips/stackframe.hsw  $24,FR_REG24(sp);               \
sp128include/asm-mips/stackframe.hsw  $25,FR_REG25(sp);               \
sp129include/asm-mips/stackframe.hsw  $28,FR_REG28(sp);               \
sp130include/asm-mips/stackframe.hsw  $30,FR_REG30(sp);               \
sp131include/asm-mips/stackframe.hsw  $31,FR_REG31(sp)
sp144include/asm-mips/stackframe.hlw  v0,FR_STATUS(sp);               \
sp145include/asm-mips/stackframe.hlw  v1,FR_LO(sp);                   \
sp148include/asm-mips/stackframe.hlw  v0,FR_HI(sp);                   \
sp149include/asm-mips/stackframe.hlw  v1,FR_EPC(sp);                  \
sp152include/asm-mips/stackframe.hlw  $31,FR_REG31(sp);               \
sp153include/asm-mips/stackframe.hlw  $30,FR_REG30(sp);               \
sp154include/asm-mips/stackframe.hlw  $28,FR_REG28(sp);               \
sp155include/asm-mips/stackframe.hlw  $25,FR_REG25(sp);               \
sp156include/asm-mips/stackframe.hlw  $24,FR_REG24(sp);               \
sp157include/asm-mips/stackframe.hlw  $23,FR_REG23(sp);               \
sp158include/asm-mips/stackframe.hlw  $22,FR_REG22(sp);               \
sp159include/asm-mips/stackframe.hlw  $21,FR_REG21(sp);               \
sp160include/asm-mips/stackframe.hlw  $20,FR_REG20(sp);               \
sp161include/asm-mips/stackframe.hlw  $19,FR_REG19(sp);               \
sp162include/asm-mips/stackframe.hlw  $18,FR_REG18(sp);               \
sp163include/asm-mips/stackframe.hlw  $17,FR_REG17(sp);               \
sp164include/asm-mips/stackframe.hlw  $16,FR_REG16(sp);               \
sp165include/asm-mips/stackframe.hlw  $15,FR_REG15(sp);               \
sp166include/asm-mips/stackframe.hlw  $14,FR_REG14(sp);               \
sp167include/asm-mips/stackframe.hlw  $13,FR_REG13(sp);               \
sp168include/asm-mips/stackframe.hlw  $12,FR_REG12(sp);               \
sp169include/asm-mips/stackframe.hlw  $11,FR_REG11(sp);               \
sp170include/asm-mips/stackframe.hlw  $10,FR_REG10(sp);               \
sp171include/asm-mips/stackframe.hlw  $9,FR_REG9(sp);                 \
sp172include/asm-mips/stackframe.hlw  $8,FR_REG8(sp);                 \
sp173include/asm-mips/stackframe.hlw  $7,FR_REG7(sp);                 \
sp174include/asm-mips/stackframe.hlw  $6,FR_REG6(sp);                 \
sp175include/asm-mips/stackframe.hlw  $5,FR_REG5(sp);                 \
sp176include/asm-mips/stackframe.hlw  $4,FR_REG4(sp);                 \
sp177include/asm-mips/stackframe.hlw  $3,FR_REG3(sp);                 \
sp178include/asm-mips/stackframe.hlw  $2,FR_REG2(sp);                 \
sp179include/asm-mips/stackframe.hlw  $1,FR_REG1(sp);                 \
sp180include/asm-mips/stackframe.hlw  sp,FR_REG29(sp); /* Deallocate stack */ \
sp115include/asm-sparc/processor.hextern inline void start_thread(struct pt_regs * regs, unsigned long pc, unsigned long sp)
sp125include/asm-sparc/processor.hregs->u_regs[UREG_G1] = sp; /* Base of arg/env stack area */
sp127include/asm-sparc/processor.hregs->u_regs[UREG_FP] = (sp - REGWIN_SZ);
sp14include/asm-sparc/winmacro.h#define _SV  save  %sp, -REGWIN_SZ, %sp
sp104include/asm-sparc/winmacro.hst       %sp, [%scratch + THREAD_STACK_PTRS]; \
sp61net/ipv4/proc.cstruct sock *sp;
sp84net/ipv4/proc.csp = s_array[i];
sp85net/ipv4/proc.cwhile(sp != NULL) 
sp87net/ipv4/proc.cdest  = sp->daddr;
sp88net/ipv4/proc.csrc   = sp->saddr;
sp89net/ipv4/proc.cdestp = sp->dummy_th.dest;
sp90net/ipv4/proc.csrcp  = sp->dummy_th.source;
sp95net/ipv4/proc.ctimer_active1 = del_timer(&sp->retransmit_timer);
sp96net/ipv4/proc.ctimer_active2 = del_timer(&sp->timer);
sp97net/ipv4/proc.cif (!timer_active1) sp->retransmit_timer.expires=0;
sp98net/ipv4/proc.cif (!timer_active2) sp->timer.expires=0;
sp102net/ipv4/proc.csp->retransmit_timer.expires < timer_expires) {
sp104net/ipv4/proc.ctimer_expires=sp->retransmit_timer.expires;
sp107net/ipv4/proc.csp->timer.expires < timer_expires) {
sp109net/ipv4/proc.ctimer_expires=sp->timer.expires;
sp112net/ipv4/proc.ci, src, srcp, dest, destp, sp->state, 
sp113net/ipv4/proc.cformat==0?sp->write_seq-sp->rcv_ack_seq:sp->wmem_alloc, 
sp114net/ipv4/proc.cformat==0?sp->acked_seq-sp->copied_seq:sp->rmem_alloc,
sp115net/ipv4/proc.ctimer_active, timer_expires-jiffies, (unsigned) sp->retransmits,
sp116net/ipv4/proc.c(sp->socket&&SOCK_INODE(sp->socket))?SOCK_INODE(sp->socket)->i_uid:0,
sp117net/ipv4/proc.ctimer_active?sp->timeout:0);
sp118net/ipv4/proc.cif (timer_active1) add_timer(&sp->retransmit_timer);
sp119net/ipv4/proc.cif (timer_active2) add_timer(&sp->timer);
sp125net/ipv4/proc.csp = sp->next;
sp1079net/unix/af_unix.cunsigned char *sp;
sp1119net/unix/af_unix.csp=iov->iov_base;
sp1160net/unix/af_unix.cmemcpy_tofs(sp, skb->data, num);
sp1167net/unix/af_unix.csp+=num;
sp202scripts/lxdialog/util.cchar tempstr[MAX_LEN + 1], *word, *sp, *sp2;
sp224scripts/lxdialog/util.csp = index(word, ' ');
sp225scripts/lxdialog/util.cif (sp)
sp226scripts/lxdialog/util.c*sp++ = 0;
sp234scripts/lxdialog/util.c(newl && wlen < 4 && sp && wlen+1+strlen(sp) > room
sp235scripts/lxdialog/util.c&& (!(sp2 = index(sp, ' ')) || wlen+1+(sp2-sp) > room))) {
sp243scripts/lxdialog/util.cif (sp && *sp == ' ') {
sp245scripts/lxdialog/util.cwhile (*++sp == ' ');
sp249scripts/lxdialog/util.cword = sp;