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;
sp224arch/sparc/kernel/process.cvoid copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
sp262arch/sparc/kernel/process.cchildregs->u_regs[UREG_FP] = sp;
sp457arch/sparc/kernel/sparc-stub.cunsigned long *sp;
sp484arch/sparc/kernel/sparc-stub.csp = (unsigned long *)registers[SP];
sp505arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *) (sp + 8 + 6), ptr, 4); /* FP */
sp511arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *)&sp, ptr, 4);
sp558arch/sparc/kernel/sparc-stub.cptr = mem2hex((char *) (sp + 0), ptr, 16 * 4);
sp576arch/sparc/kernel/sparc-stub.chex2mem(ptr + 16 * 4 * 2, (char *) (sp + 0), 16 * 4);
sp587arch/sparc/kernel/sparc-stub.cif (sp != newsp)
sp588arch/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]);
sp246arch/sparc/mm/fault.cunsigned long sp = current->tss.rwbuf_stkptrs[0];
sp248arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp249arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 1);
sp250arch/sparc/mm/fault.cforce_user_fault(sp, 1);
sp253arch/sparc/mm/fault.cvoid window_underflow_fault(unsigned long sp)
sp255arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp256arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 0);
sp257arch/sparc/mm/fault.cforce_user_fault(sp, 0);
sp262arch/sparc/mm/fault.cunsigned long sp = regs->u_regs[UREG_FP];
sp264arch/sparc/mm/fault.cif(((sp + 0x38) & PAGE_MASK) != (sp & PAGE_MASK))
sp265arch/sparc/mm/fault.cforce_user_fault(sp + 0x38, 0);
sp266arch/sparc/mm/fault.cforce_user_fault(sp, 0);
sp1218arch/sparc/mm/sun4c.cunsigned long sp = regs->u_regs[UREG_FP];
sp1219arch/sparc/mm/sun4c.cunsigned long sp2 = sp + REGWIN_SZ - 0x8;
sp1222arch/sparc/mm/sun4c.cforce_user_fault(sp, 0);
sp1223arch/sparc/mm/sun4c.cif((sp&PAGE_MASK) != (sp2&PAGE_MASK))
sp557drivers/char/istallion.cstatic void  stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
sp560drivers/char/istallion.cstatic void  stli_getserial(stliport_t *portp, struct serial_struct *sp);
sp561drivers/char/istallion.cstatic int  stli_setserial(stliport_t *portp, struct serial_struct *sp);
sp1684drivers/char/istallion.cstatic void stli_getserial(stliport_t *portp, struct serial_struct *sp)
sp1690drivers/char/istallion.cprintk("stli_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1709drivers/char/istallion.cmemcpy_tofs(sp, &sio, sizeof(struct serial_struct));
sp1720drivers/char/istallion.cstatic int stli_setserial(stliport_t *portp, struct serial_struct *sp)
sp1726drivers/char/istallion.cprintk("stli_setserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1729drivers/char/istallion.cmemcpy_fromfs(&sio, sp, sizeof(struct serial_struct));
sp2719drivers/char/istallion.cstatic void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
sp2722drivers/char/istallion.cprintk("stli_mkasysigs(sp=%x,dtr=%d,rts=%d)\n", (int) sp, dtr, rts);
sp2725drivers/char/istallion.cmemset(sp, 0, sizeof(asysigs_t));
sp2727drivers/char/istallion.csp->signal |= SG_DTR;
sp2728drivers/char/istallion.csp->sigvalue |= ((dtr > 0) ? SG_DTR : 0);
sp2731drivers/char/istallion.csp->signal |= SG_RTS;
sp2732drivers/char/istallion.csp->sigvalue |= ((rts > 0) ? SG_RTS : 0);
sp404drivers/char/stallion.cstatic void  stl_getserial(stlport_t *portp, struct serial_struct *sp);
sp405drivers/char/stallion.cstatic int  stl_setserial(stlport_t *portp, struct serial_struct *sp);
sp1059drivers/char/stallion.cstatic void stl_getserial(stlport_t *portp, struct serial_struct *sp)
sp1065drivers/char/stallion.cprintk("stl_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1084drivers/char/stallion.cmemcpy_tofs(sp, &sio, sizeof(struct serial_struct));
sp1095drivers/char/stallion.cstatic int stl_setserial(stlport_t *portp, struct serial_struct *sp)
sp1100drivers/char/stallion.cprintk("stl_setserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
sp1103drivers/char/stallion.cmemcpy_fromfs(&sio, sp, sizeof(struct serial_struct));
sp1058drivers/isdn/pcbit/drv.cchar *cp, *sp;
sp1078drivers/isdn/pcbit/drv.csp = list;
sp1081drivers/isdn/pcbit/drv.ccp=strchr(sp, ',');
sp1083drivers/isdn/pcbit/drv.clen = cp - sp;
sp1085drivers/isdn/pcbit/drv.clen = strlen(sp);
sp1101drivers/isdn/pcbit/drv.cmemcpy(ptr->msn, sp, len - 1);
sp1112drivers/isdn/pcbit/drv.csp += len;
sp270drivers/isdn/teles/buffers.cstruct BufHeader *sp;
sp276drivers/isdn/teles/buffers.csp = q->head;
sp277drivers/isdn/teles/buffers.cif (!sp)
sp279drivers/isdn/teles/buffers.cif ((sp->primitive == pr) && (sp->heldby == heldby)) {
sp280drivers/isdn/teles/buffers.cq->head = sp->next;
sp281drivers/isdn/teles/buffers.cif (q->tail == sp)
sp284drivers/isdn/teles/buffers.cBufPoolRelease(sp);
sp289drivers/isdn/teles/buffers.csp = q->head;
sp290drivers/isdn/teles/buffers.cif (sp)
sp291drivers/isdn/teles/buffers.cwhile (sp->next) {
sp292drivers/isdn/teles/buffers.cif ((sp->next->primitive == pr) && (sp->next->heldby == heldby)) {
sp293drivers/isdn/teles/buffers.cif (q->tail == sp->next)
sp294drivers/isdn/teles/buffers.cq->tail = sp;
sp296drivers/isdn/teles/buffers.cBufPoolRelease(sp->next);
sp297drivers/isdn/teles/buffers.csp->next = sp->next->next;
sp299drivers/isdn/teles/buffers.csp = sp->next;
sp820drivers/isdn/teles/callc.cstruct IsdnCardState *sp;
sp823drivers/isdn/teles/callc.csp = st->l1.hardware;
sp824drivers/isdn/teles/callc.chsp = sp->hs + chanlist[chan].hscx;
sp933drivers/isdn/teles/callc.cstruct IsdnCardState *sp = chanlist[chan].sp;
sp936drivers/isdn/teles/callc.csetstack_teles(st, sp);
sp971drivers/isdn/teles/callc.cteles_addlist(sp, st);
sp1044drivers/isdn/teles/callc.cchanp->sp = card->sp;
sp1094drivers/isdn/teles/callc.cif (cards[i].sp)
sp1103drivers/isdn/teles/callc.cif (cards[i].sp) {
sp1205drivers/isdn/teles/callc.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1207drivers/isdn/teles/callc.cstruct HscxState *hsp = sp->hs + chanlist[chan].hscx;
sp1210drivers/isdn/teles/callc.cst->l1.hardware = sp;
sp1284drivers/isdn/teles/callc.cif (cards[i].sp)
sp1285drivers/isdn/teles/callc.ccards[i].sp->dlogflag = debugflags & 4;
sp1338drivers/isdn/teles/callc.cif (cards[i].sp)
sp252drivers/isdn/teles/card.cteles_hscxreport(struct IsdnCardState *sp, int hscx)
sp255drivers/isdn/teles/card.cif (sp->membase) {
sp256drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readhscx_0(sp->membase,
sp258drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readhscx_0(sp->membase,
sp260drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readhscx_0(sp->membase,
sp263drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readhscx_3(sp->iobase,
sp265drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readhscx_3(sp->iobase,
sp267drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readhscx_3(sp->iobase,
sp273drivers/isdn/teles/card.cteles_report(struct IsdnCardState *sp)
sp276drivers/isdn/teles/card.cif (sp->membase) {
sp277drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readisac_0(sp->membase,
sp279drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readisac_0(sp->membase,
sp281drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readisac_0(sp->membase,
sp284drivers/isdn/teles/card.cprintk(KERN_DEBUG "  ISTA %x\n", readisac_3(sp->iobase,
sp286drivers/isdn/teles/card.cprintk(KERN_DEBUG "  STAR %x\n", readisac_3(sp->iobase,
sp288drivers/isdn/teles/card.cprintk(KERN_DEBUG "  EXIR %x\n", readisac_3(sp->iobase,
sp291drivers/isdn/teles/card.cteles_hscxreport(sp, 0);
sp292drivers/isdn/teles/card.cteles_hscxreport(sp, 1);
sp313drivers/isdn/teles/card.cif (hsp->sp->debug)
sp353drivers/isdn/teles/card.cif (hsp->sp->debug)
sp403drivers/isdn/teles/card.chscx_interrupt(struct IsdnCardState *sp, byte val, byte hscx)
sp406drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp414drivers/isdn/teles/card.cr = READHSCX(hsp->membase, sp->iobase, hsp->hscx, HSCX_RSTA);
sp442drivers/isdn/teles/card.ccount = READHSCX(hsp->membase, sp->iobase, hsp->hscx,
sp502drivers/isdn/teles/card.cisac_sched_event(struct IsdnCardState *sp, int event)
sp504drivers/isdn/teles/card.csp->event |= 1 << event;
sp505drivers/isdn/teles/card.cqueue_task_irq_off(&sp->tqueue, &tq_immediate);
sp510drivers/isdn/teles/card.cempty_fifo(struct IsdnCardState *sp, int count)
sp513drivers/isdn/teles/card.cstruct BufHeader *ibh = sp->rcvibh;
sp515drivers/isdn/teles/card.cif (sp->debug)
sp518drivers/isdn/teles/card.cif (sp->rcvptr >= 3072) {
sp519drivers/isdn/teles/card.cprintk(KERN_WARNING "empty_fifo rcvptr %d\n", sp->rcvptr);
sp523drivers/isdn/teles/card.cptr += sp->rcvptr;
sp524drivers/isdn/teles/card.csp->rcvptr += count;
sp526drivers/isdn/teles/card.cif (sp->membase) {
sp530drivers/isdn/teles/card.c*ptr = readisac_0(sp->membase, 0x0);
sp537drivers/isdn/teles/card.c*ptr++ = readisac_0(sp->membase, 0x0);
sp539drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_CMDR, 0x80);
sp544drivers/isdn/teles/card.creadisac_s(sp->iobase, 0x3e, ptr, count);
sp549drivers/isdn/teles/card.creadisac_s(sp->iobase, 0x3e, ptr, count);
sp551drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_CMDR, 0x80);
sp556drivers/isdn/teles/card.cfill_fifo(struct IsdnCardState *sp)
sp562drivers/isdn/teles/card.cif (sp->debug)
sp565drivers/isdn/teles/card.cibh = sp->xmtibh;
sp569drivers/isdn/teles/card.ccount = ibh->datasize - sp->sendptr;
sp581drivers/isdn/teles/card.cptr += sp->sendptr;
sp582drivers/isdn/teles/card.csp->sendptr += count;
sp584drivers/isdn/teles/card.cif (sp->membase) {
sp588drivers/isdn/teles/card.cwriteisac_0(sp->membase, 0x0, *ptr);
sp595drivers/isdn/teles/card.cwriteisac_0(sp->membase, 0x0, *ptr++);
sp597drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_CMDR, more ? 0x8 : 0xa);
sp601drivers/isdn/teles/card.cwriteisac_s(sp->iobase, 0x3e, ptr, count);
sp607drivers/isdn/teles/card.cwriteisac_s(sp->iobase, 0x3e, ptr, count);
sp609drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_CMDR, more ? 0x8 : 0xa);
sp614drivers/isdn/teles/card.cact_wanted(struct IsdnCardState *sp)
sp618drivers/isdn/teles/card.cst = sp->stlist;
sp628drivers/isdn/teles/card.cph_command(struct IsdnCardState *sp, unsigned int command)
sp631drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_CIX0, (command << 2) | 3);
sp635drivers/isdn/teles/card.cisac_new_ph(struct IsdnCardState *sp)
sp639drivers/isdn/teles/card.cenq = act_wanted(sp);
sp641drivers/isdn/teles/card.cswitch (sp->ph_state) {
sp645drivers/isdn/teles/card.cph_command(sp, 0);
sp647drivers/isdn/teles/card.cph_command(sp, 15);
sp651drivers/isdn/teles/card.cph_command(sp, 9);
sp655drivers/isdn/teles/card.cph_command(sp, 8);
sp656drivers/isdn/teles/card.csp->ph_active = 5;
sp657drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_PHCHANGE);
sp658drivers/isdn/teles/card.cif (!sp->xmtibh)
sp659drivers/isdn/teles/card.cif (!BufQueueUnlink(&sp->xmtibh, &sp->sq))
sp660drivers/isdn/teles/card.csp->sendptr = 0;
sp661drivers/isdn/teles/card.cif (sp->xmtibh)
sp662drivers/isdn/teles/card.cfill_fifo(sp);
sp668drivers/isdn/teles/card.csp->ph_active = 0;
sp677drivers/isdn/teles/card.cstruct IsdnCardState *sp;
sp681drivers/isdn/teles/card.csp = (struct IsdnCardState *) irq2dev_map[intno];
sp683drivers/isdn/teles/card.cif (!sp) {
sp687drivers/isdn/teles/card.cval = READHSCX(sp->membase, sp->iobase, 1, HSCX_ISTA);
sp690drivers/isdn/teles/card.chsp = sp->hs + 1;
sp692drivers/isdn/teles/card.cREADHSCX(sp->membase, sp->iobase, 1, HSCX_EXIR),
sp697drivers/isdn/teles/card.cif (sp->debug)
sp699drivers/isdn/teles/card.chscx_interrupt(sp, val, 1);
sp703drivers/isdn/teles/card.cREADHSCX(sp->membase, sp->iobase, 0, HSCX_EXIR));
sp707drivers/isdn/teles/card.cif (sp->membase) {
sp709drivers/isdn/teles/card.cval = readhscx_0(sp->membase, 0, HSCX_ISTA);
sp710drivers/isdn/teles/card.cif (sp->debug)
sp713drivers/isdn/teles/card.chscx_interrupt(sp, val, 0);
sp716drivers/isdn/teles/card.cval2 = readhscx_3(sp->iobase, 0, HSCX_ISTA);
sp717drivers/isdn/teles/card.cif (sp->debug)
sp720drivers/isdn/teles/card.cif (sp->debug)
sp723drivers/isdn/teles/card.chscx_interrupt(sp, val2, 0);
sp728drivers/isdn/teles/card.cval = READISAC(sp->membase, sp->iobase, ISAC_ISTA);
sp730drivers/isdn/teles/card.cif (sp->debug)
sp735drivers/isdn/teles/card.cr = READISAC(sp->membase, sp->iobase, ISAC_RSTA);
sp741drivers/isdn/teles/card.cif (sp->rcvibh)
sp742drivers/isdn/teles/card.cBufPoolRelease(sp->rcvibh);
sp743drivers/isdn/teles/card.csp->rcvibh = NULL;
sp744drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_CMDR, 0x80);
sp747drivers/isdn/teles/card.cif (!sp->rcvibh)
sp748drivers/isdn/teles/card.cif (BufPoolGet(&(sp->rcvibh), &(sp->rbufpool),
sp753drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, 
sp757drivers/isdn/teles/card.csp->rcvptr = 0;
sp759drivers/isdn/teles/card.ccount = READISAC(sp->membase, sp->iobase, ISAC_RBCL) & 0x1f;
sp762drivers/isdn/teles/card.cempty_fifo(sp, count);
sp763drivers/isdn/teles/card.csp->rcvibh->datasize = sp->rcvptr;
sp764drivers/isdn/teles/card.cBufQueueLink(&(sp->rq), sp->rcvibh);
sp765drivers/isdn/teles/card.csp->rcvibh = NULL;
sp766drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_RCVBUFREADY);
sp770drivers/isdn/teles/card.cif (!sp->rcvibh)
sp771drivers/isdn/teles/card.cif (BufPoolGet(&(sp->rcvibh), &(sp->rbufpool),
sp776drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase,
sp780drivers/isdn/teles/card.csp->rcvptr = 0;
sp781drivers/isdn/teles/card.cempty_fifo(sp, 32);
sp787drivers/isdn/teles/card.cif (sp->xmtibh)
sp788drivers/isdn/teles/card.cif (sp->xmtibh->datasize > sp->sendptr) {
sp789drivers/isdn/teles/card.cfill_fifo(sp);
sp792drivers/isdn/teles/card.cif (sp->releasebuf)
sp793drivers/isdn/teles/card.cBufPoolRelease(sp->xmtibh);
sp794drivers/isdn/teles/card.csp->xmtibh = NULL;
sp795drivers/isdn/teles/card.csp->sendptr = 0;
sp797drivers/isdn/teles/card.cif (!BufQueueUnlink(&sp->xmtibh, &sp->sq)) {
sp798drivers/isdn/teles/card.csp->releasebuf = !0;
sp799drivers/isdn/teles/card.cfill_fifo(sp);
sp801drivers/isdn/teles/card.cisac_sched_event(sp, ISAC_XMTBUFREADY);
sp805drivers/isdn/teles/card.csp->ph_state = (READISAC(sp->membase, sp->iobase, ISAC_CIX0)
sp807drivers/isdn/teles/card.cprintk(KERN_DEBUG "l1state %d\n", sp->ph_state);
sp808drivers/isdn/teles/card.cisac_new_ph(sp);
sp810drivers/isdn/teles/card.cif (sp->membase) {
sp811drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_MASK, 0xFF);
sp812drivers/isdn/teles/card.cwritehscx_0(sp->membase, 0, HSCX_MASK, 0xFF);
sp813drivers/isdn/teles/card.cwritehscx_0(sp->membase, 1, HSCX_MASK, 0xFF);
sp814drivers/isdn/teles/card.cwriteisac_0(sp->membase, ISAC_MASK, 0x0);
sp815drivers/isdn/teles/card.cwritehscx_0(sp->membase, 0, HSCX_MASK, 0x0);
sp816drivers/isdn/teles/card.cwritehscx_0(sp->membase, 1, HSCX_MASK, 0x0);
sp818drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_MASK, 0xFF);
sp819drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 0, HSCX_MASK, 0xFF);
sp820drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 1, HSCX_MASK, 0xFF);
sp821drivers/isdn/teles/card.cwriteisac_3(sp->iobase, ISAC_MASK, 0x0);
sp822drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 0, HSCX_MASK, 0x0);
sp823drivers/isdn/teles/card.cwritehscx_3(sp->iobase, 1, HSCX_MASK, 0x0);
sp832drivers/isdn/teles/card.cact_ivated(struct IsdnCardState *sp)
sp836drivers/isdn/teles/card.cst = sp->stlist;
sp847drivers/isdn/teles/card.cprocess_new_ph(struct IsdnCardState *sp)
sp849drivers/isdn/teles/card.cif (sp->ph_active == 5)
sp850drivers/isdn/teles/card.cact_ivated(sp);
sp854drivers/isdn/teles/card.cprocess_xmt(struct IsdnCardState *sp)
sp858drivers/isdn/teles/card.cif (sp->xmtibh)
sp861drivers/isdn/teles/card.cstptr = sp->stlist;
sp872drivers/isdn/teles/card.cprocess_rcv(struct IsdnCardState *sp)
sp880drivers/isdn/teles/card.cwhile (!BufQueueUnlink(&ibh, &sp->rq)) {
sp881drivers/isdn/teles/card.cstptr = sp->stlist;
sp885drivers/isdn/teles/card.cif (broadc && sp->dlogflag && (!(ptr[0] >> 2)))
sp886drivers/isdn/teles/card.cdlogframe(sp, ptr + 3, ibh->datasize - 3,
sp892drivers/isdn/teles/card.cif (!BufPoolGet(&cibh, &sp->rbufpool, GFP_ATOMIC,
sp920drivers/isdn/teles/card.cdlogframe(sp, ptr + 4, ibh->datasize - 4, tmp);
sp931drivers/isdn/teles/card.cisac_bh(struct IsdnCardState *sp)
sp933drivers/isdn/teles/card.cif (!sp)
sp936drivers/isdn/teles/card.cif (clear_bit(ISAC_PHCHANGE, &sp->event))
sp937drivers/isdn/teles/card.cprocess_new_ph(sp);
sp938drivers/isdn/teles/card.cif (clear_bit(ISAC_RCVBUFREADY, &sp->event))
sp939drivers/isdn/teles/card.cprocess_rcv(sp);
sp940drivers/isdn/teles/card.cif (clear_bit(ISAC_XMTBUFREADY, &sp->event))
sp941drivers/isdn/teles/card.cprocess_xmt(sp);
sp997drivers/isdn/teles/card.crestart_ph(struct IsdnCardState *sp)
sp999drivers/isdn/teles/card.cswitch (sp->ph_active) {
sp1001drivers/isdn/teles/card.cif (sp->ph_state == 6)
sp1002drivers/isdn/teles/card.cph_command(sp, 0);
sp1004drivers/isdn/teles/card.cph_command(sp, 1);
sp1005drivers/isdn/teles/card.csp->ph_active = 1;
sp1179drivers/isdn/teles/card.cstruct IsdnCardState *sp = hs->sp;
sp1188drivers/isdn/teles/card.cif (sp->membase) {
sp1189drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR1, 0x85);
sp1190drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XAD1, 0xFF);
sp1191drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XAD2, 0xFF);
sp1192drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RAH2, 0xFF);
sp1193drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XBCH, 0x0);
sp1197drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1198drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0xff);
sp1199drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0xff);
sp1200drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1201drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1202drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0x84);
sp1206drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1207drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x7);
sp1208drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x7);
sp1209drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1210drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1212drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1213drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x3);
sp1214drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x3);
sp1215drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1216drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1218drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0xe4);
sp1219drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CMDR, 0x41);
sp1223drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1224drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x7);
sp1225drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x7);
sp1226drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1227drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1229drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CCR2, 0x30);
sp1230drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAX, 0x3);
sp1231drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_TSAR, 0x3);
sp1232drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_XCCR, 7);
sp1233drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_RCCR, 7);
sp1235drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_MODE, 0x8c);
sp1236drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_CMDR, 0x41);
sp1239drivers/isdn/teles/card.cwritehscx_0(sp->membase, hscx, HSCX_ISTA, 0x00);
sp1241drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR1, 0x85);
sp1242drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XAD1, 0xFF);
sp1243drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XAD2, 0xFF);
sp1244drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RAH2, 0xFF);
sp1245drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XBCH, 0x00);
sp1246drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RLCR, 0x00);
sp1250drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1251drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0xff);
sp1252drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0xff);
sp1253drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1254drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1255drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0x84);
sp1259drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1260drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x2f);
sp1261drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x2f);
sp1262drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1263drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1265drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1266drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x3);
sp1267drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x3);
sp1268drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1269drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1271drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0xe4);
sp1272drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CMDR, 0x41);
sp1276drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1277drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x2f);
sp1278drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x2f);
sp1279drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1280drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1282drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CCR2, 0x30);
sp1283drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAX, 0x3);
sp1284drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_TSAR, 0x3);
sp1285drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_XCCR, 7);
sp1286drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_RCCR, 7);
sp1288drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_MODE, 0x8c);
sp1289drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_CMDR, 0x41);
sp1292drivers/isdn/teles/card.cwritehscx_3(sp->iobase, hscx, HSCX_ISTA, 0x00);
sp1297drivers/isdn/teles/card.cteles_addlist(struct IsdnCardState *sp,
sp1300drivers/isdn/teles/card.cst->next = sp->stlist;
sp1301drivers/isdn/teles/card.csp->stlist = st;
sp1305drivers/isdn/teles/card.cteles_rmlist(struct IsdnCardState *sp,
sp1310drivers/isdn/teles/card.cif (sp->stlist == st)
sp1311drivers/isdn/teles/card.csp->stlist = st->next;
sp1313drivers/isdn/teles/card.cp = sp->stlist;
sp1328drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1334drivers/isdn/teles/card.cif (sp->xmtibh)
sp1335drivers/isdn/teles/card.cBufQueueLink(&sp->sq, ibh);
sp1337drivers/isdn/teles/card.csp->xmtibh = ibh;
sp1338drivers/isdn/teles/card.csp->sendptr = 0;
sp1339drivers/isdn/teles/card.csp->releasebuf = !0;
sp1340drivers/isdn/teles/card.cfill_fifo(sp);
sp1344drivers/isdn/teles/card.cif (sp->xmtibh) {
sp1348drivers/isdn/teles/card.csp->xmtibh = ibh;
sp1349drivers/isdn/teles/card.csp->sendptr = 0;
sp1350drivers/isdn/teles/card.csp->releasebuf = 0;
sp1351drivers/isdn/teles/card.cfill_fifo(sp);
sp1354drivers/isdn/teles/card.cif (!sp->xmtibh) {
sp1364drivers/isdn/teles/card.ccheck_ph_act(struct IsdnCardState *sp)
sp1366drivers/isdn/teles/card.cstruct PStack  *st = sp->stlist;
sp1373drivers/isdn/teles/card.csp->ph_active = 0;
sp1380drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1388drivers/isdn/teles/card.cif (sp->ph_active == 5) {
sp1394drivers/isdn/teles/card.cif (sp->ph_active == 0)
sp1395drivers/isdn/teles/card.crestart_ph(sp);
sp1401drivers/isdn/teles/card.ccheck_ph_act(sp);
sp1410drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *) st->l1.hardware;
sp1413drivers/isdn/teles/card.cif (sp->magic != 301271) {
sp1419drivers/isdn/teles/card.cBufQueueDiscard(&sp->sq, pr, heldby, releasetoo);
sp1423drivers/isdn/teles/card.csetstack_teles(struct PStack *st, struct IsdnCardState *sp)
sp1425drivers/isdn/teles/card.cst->l1.hardware = sp;
sp1426drivers/isdn/teles/card.cst->l1.sbufpool = &(sp->sbufpool);
sp1427drivers/isdn/teles/card.cst->l1.rbufpool = &(sp->rbufpool);
sp1428drivers/isdn/teles/card.cst->l1.smallpool = &(sp->smallpool);
sp1429drivers/isdn/teles/card.cst->protocol = sp->teistack->protocol;
sp1433drivers/isdn/teles/card.cst->l1.stlistp = &(sp->stlist);
sp1442drivers/isdn/teles/card.cinit_hscxstate(struct IsdnCardState *sp,
sp1445drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp1447drivers/isdn/teles/card.chsp->sp = sp;
sp1449drivers/isdn/teles/card.chsp->membase = sp->membase;
sp1450drivers/isdn/teles/card.chsp->iobase = sp->iobase;
sp1469drivers/isdn/teles/card.cstruct IsdnCardState *sp;
sp1472drivers/isdn/teles/card.csp = (struct IsdnCardState *)
sp1476drivers/isdn/teles/card.csp->membase = card->membase;
sp1477drivers/isdn/teles/card.csp->iobase = card->iobase;
sp1478drivers/isdn/teles/card.csp->cardnr = cardnr;
sp1480drivers/isdn/teles/card.cBufPoolInit(&sp->sbufpool, ISAC_SBUF_ORDER, ISAC_SBUF_BPPS,
sp1482drivers/isdn/teles/card.cBufPoolInit(&sp->rbufpool, ISAC_RBUF_ORDER, ISAC_RBUF_BPPS,
sp1484drivers/isdn/teles/card.cBufPoolInit(&sp->smallpool, ISAC_SMALLBUF_ORDER, ISAC_SMALLBUF_BPPS,
sp1487drivers/isdn/teles/card.csp->dlogspace = Smalloc(4096, GFP_KERNEL, "dlogspace");
sp1491drivers/isdn/teles/card.csp->rcvibh = NULL;
sp1492drivers/isdn/teles/card.csp->rcvptr = 0;
sp1493drivers/isdn/teles/card.csp->xmtibh = NULL;
sp1494drivers/isdn/teles/card.csp->sendptr = 0;
sp1495drivers/isdn/teles/card.csp->event = 0;
sp1496drivers/isdn/teles/card.csp->tqueue.next = 0;
sp1497drivers/isdn/teles/card.csp->tqueue.sync = 0;
sp1498drivers/isdn/teles/card.csp->tqueue.routine = (void *) (void *) isac_bh;
sp1499drivers/isdn/teles/card.csp->tqueue.data = sp;
sp1501drivers/isdn/teles/card.cBufQueueInit(&sp->rq);
sp1502drivers/isdn/teles/card.cBufQueueInit(&sp->sq);
sp1504drivers/isdn/teles/card.csp->stlist = NULL;
sp1506drivers/isdn/teles/card.csp->ph_active = 0;
sp1508drivers/isdn/teles/card.csp->dlogflag = 0;
sp1509drivers/isdn/teles/card.csp->debug = 0;
sp1511drivers/isdn/teles/card.csp->releasebuf = 0;
sp1513drivers/isdn/teles/card.csp->magic = 301271;
sp1516drivers/isdn/teles/card.ccards[sp->cardnr].sp = sp;
sp1518drivers/isdn/teles/card.cinit_hscxstate(sp, 0);
sp1519drivers/isdn/teles/card.cinit_hscxstate(sp, 1);
sp1521drivers/isdn/teles/card.cmodehscx(sp->hs, 0, 0);
sp1522drivers/isdn/teles/card.cmodehscx(sp->hs + 1, 0, 0);
sp1524drivers/isdn/teles/card.cWRITEISAC(sp->membase, sp->iobase, ISAC_MASK, 0x0);
sp1542drivers/isdn/teles/card.cirq2dev_map[card->interrupt] = (void *) card->sp;
sp1573drivers/isdn/teles/card.cstruct IsdnCardState *sp = cards[cardnr].sp;
sp1575drivers/isdn/teles/card.ccards[cardnr].sp = NULL;
sp1577drivers/isdn/teles/card.cSfree(sp->dlogspace);
sp1579drivers/isdn/teles/card.cBufPoolFree(&sp->smallpool);
sp1580drivers/isdn/teles/card.cBufPoolFree(&sp->rbufpool);
sp1581drivers/isdn/teles/card.cBufPoolFree(&sp->sbufpool);
sp1583drivers/isdn/teles/card.cclose_hscxstate(sp->hs + 1);
sp1584drivers/isdn/teles/card.cclose_hscxstate(sp->hs);
sp1589drivers/isdn/teles/card.cSfree((void *) sp);
sp1640drivers/isdn/teles/card.cif (cards[i].sp) {
sp1650drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1652drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp1692drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1694drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp1707drivers/isdn/teles/card.copen_hscxstate(struct IsdnCardState *sp,
sp1710drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + hscx;
sp1738drivers/isdn/teles/card.cstruct IsdnCardState *sp = (struct IsdnCardState *)
sp1740drivers/isdn/teles/card.cstruct HscxState *hsp = sp->hs + st->l1.hscx;
sp623drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
sp630drivers/isdn/teles/isdnl2.cif (sp->dlogflag) {
sp632drivers/isdn/teles/isdnl2.cdlogframe(sp, ptr + st->l2.ihsize, ibh->datasize - st->l2.ihsize,
sp648drivers/isdn/teles/isdnl2.cstruct IsdnCardState *sp = st->l1.hardware;
sp673drivers/isdn/teles/isdnl2.cif (sp->dlogflag) {
sp796drivers/isdn/teles/q931.cdlogframe(struct IsdnCardState *sp, byte * buf, int size, char *comment)
sp803drivers/isdn/teles/q931.cdp = sp->dlogspace;
sp813drivers/isdn/teles/q931.cteles_putstatus(sp->dlogspace);
sp814drivers/isdn/teles/q931.cdp = sp->dlogspace;
sp877drivers/isdn/teles/q931.cteles_putstatus(sp->dlogspace);
sp151drivers/isdn/teles/tei.ctei_man(struct PStack *sp, int i, void *v)
sp159drivers/isdn/teles/tei.cstruct IsdnCardState *sp = st->l1.hardware;
sp161drivers/isdn/teles/tei.ctei_handler(sp->teistack, pr, arg);
sp171drivers/isdn/teles/tei.cinit_tei(struct IsdnCardState *sp, int protocol)
sp182drivers/isdn/teles/tei.csp->teistack = st;                  /* struct is not initialized yet */
sp183drivers/isdn/teles/tei.csp->teistack->protocol = protocol;  /* struct is not initialized yet */
sp187drivers/isdn/teles/tei.csetstack_teles(st, sp);
sp205drivers/isdn/teles/tei.csprintf(tmp, "Card %d tei ", sp->cardnr);
sp217drivers/isdn/teles/tei.cteles_addlist(sp, st);
sp218drivers/isdn/teles/tei.csp->teistack = st;
sp222drivers/isdn/teles/tei.crelease_tei(struct IsdnCardState *sp)
sp224drivers/isdn/teles/tei.cstruct PStack  *st = sp->teistack;
sp226drivers/isdn/teles/tei.cteles_rmlist(sp, st);
sp236drivers/isdn/teles/tei.cif (cards[i].sp)
sp237drivers/isdn/teles/tei.cinit_tei(cards[i].sp, cards[i].protocol);
sp246drivers/isdn/teles/tei.cif (cards[i].sp)
sp247drivers/isdn/teles/tei.crelease_tei(cards[i].sp);
sp309drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp354drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp390drivers/isdn/teles/teles.hvoid            setstack_teles(struct PStack *st, struct IsdnCardState *sp);
sp393drivers/isdn/teles/teles.hvoid            teles_addlist(struct IsdnCardState *sp,
sp396drivers/isdn/teles/teles.hvoid            teles_rmlist(struct IsdnCardState *sp,
sp430drivers/isdn/teles/teles.hvoid            dlogframe(struct IsdnCardState *sp, byte * p, int size, char *comment);
sp451drivers/isdn/teles/teles.hstruct IsdnCardState *sp;
sp2571drivers/scsi/aic7xxx.cstruct aic7xxx_xferstats *sp;
sp2575drivers/scsi/aic7xxx.csp = &p->stats[cmd->channel & 0x01][cmd->target & 0x0F][cmd->lun & 0x07];
sp2576drivers/scsi/aic7xxx.csp->xfers++;
sp2580drivers/scsi/aic7xxx.csp->w_total++;
sp2581drivers/scsi/aic7xxx.csp->w_total512 += (actual >> 9);
sp2582drivers/scsi/aic7xxx.cptr = sp->w_bins;
sp2586drivers/scsi/aic7xxx.csp->r_total++;
sp2587drivers/scsi/aic7xxx.csp->r_total512 += (actual >> 9);
sp2588drivers/scsi/aic7xxx.cptr = sp->r_bins;
sp199drivers/scsi/aic7xxx_proc.cstruct aic7xxx_xferstats *sp;
sp213drivers/scsi/aic7xxx_proc.csp = &p->stats[channel][target][lun];
sp214drivers/scsi/aic7xxx_proc.cif (sp->xfers == 0)
sp221drivers/scsi/aic7xxx_proc.csp->xfers, sp->r_total, sp->w_total);
sp223drivers/scsi/aic7xxx_proc.csp->r_total512, sp->w_total512);
sp226drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[0],
sp227drivers/scsi/aic7xxx_proc.csp->r_bins[1], sp->r_bins[2], sp->r_bins[3]);
sp228drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->r_bins[4],
sp229drivers/scsi/aic7xxx_proc.csp->r_bins[5], sp->r_bins[6], sp->r_bins[7]);
sp230drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->r_bins[8],
sp231drivers/scsi/aic7xxx_proc.csp->r_bins[9]);
sp233drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[0],
sp234drivers/scsi/aic7xxx_proc.csp->w_bins[1], sp->w_bins[2], sp->w_bins[3]);
sp235drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld %6ld %6ld ", sp->w_bins[4],
sp236drivers/scsi/aic7xxx_proc.csp->w_bins[5], sp->w_bins[6], sp->w_bins[7]);
sp237drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "%6ld %6ld\n", sp->w_bins[8],
sp238drivers/scsi/aic7xxx_proc.csp->w_bins[9]);
sp318drivers/scsi/eata.cstruct mssp sp[MAX_MAILBOXES];       /* Returned status for this board */
sp663drivers/scsi/eata.cspp = &HD(j)->sp[i];
sp929drivers/scsi/eata.cspp = &HD(j)->sp[i];
sp245drivers/scsi/eata_dma.cstruct eata_sp *sp;
sp262drivers/scsi/eata_dma.csp = &SD(sh)->sp;
sp263drivers/scsi/eata_dma.cccb = sp->ccb;
sp274drivers/scsi/eata_dma.chba_stat = sp->hba_stat;
sp276drivers/scsi/eata_dma.cscsi_stat = (sp->scsi_stat >> 1) & 0x1f; 
sp278drivers/scsi/eata_dma.cif (sp->EOC == FALSE) {
sp299drivers/scsi/eata_dma.csp->EOC = FALSE; /* Clean out this flag */
sp562drivers/scsi/eata_dma.cccb->cp_statDMA = htonl(virt_to_bus(&(hd->sp)));
sp642drivers/scsi/eata_dma.cScsi_Cmnd *sp; 
sp683drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
sp685drivers/scsi/eata_dma.cprintk("eata_reset: slot %d in reset, pid %ld.\n", x, sp->pid);
sp688drivers/scsi/eata_dma.cif (sp == NULL)
sp692drivers/scsi/eata_dma.cif (sp == cmd)
sp715drivers/scsi/eata_dma.csp = HD(cmd)->ccb[x].cmd;
sp716drivers/scsi/eata_dma.csp->result = DID_RESET << 16;
sp722drivers/scsi/eata_dma.cx, sp->pid);
sp725drivers/scsi/eata_dma.csp->scsi_done(sp);
sp848drivers/scsi/eata_dma.cstruct eata_sp  *sp;
sp855drivers/scsi/eata_dma.csp = (struct eata_sp *) scsi_init_malloc(sizeof(struct eata_sp), 
sp861drivers/scsi/eata_dma.cmemset(sp, 0, sizeof(struct eata_sp));
sp871drivers/scsi/eata_dma.ccp->cp_statDMA = htonl(virt_to_bus(sp));
sp896drivers/scsi/eata_dma.cfake_int_result, (u32) (sp->hba_stat /*& 0x7f*/), 
sp897drivers/scsi/eata_dma.c(u32) sp->scsi_stat, buff, sp));
sp900drivers/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);
sp368drivers/scsi/eata_generic.hstruct eata_sp sp;     /* status packet         */ 
sp458drivers/scsi/eata_pio.cScsi_Cmnd *sp; 
sp486drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
sp489drivers/scsi/eata_pio.csp->pid);
sp492drivers/scsi/eata_pio.cif (sp == NULL)
sp516drivers/scsi/eata_pio.csp = HD(cmd)->ccb[x].cmd;
sp517drivers/scsi/eata_pio.csp->result = DID_RESET << 16;
sp524drivers/scsi/eata_pio.csp->scsi_done(sp);
sp237drivers/scsi/in2000.c: "=D" (sp)                   /* output */   \
sp238drivers/scsi/in2000.c: "d" (f), "D" (sp), "c" (i)  /* input */    \
sp249drivers/scsi/in2000.c: "=S" (sp)                   /* output */   \
sp250drivers/scsi/in2000.c: "d" (f), "S" (sp), "c" (i)  /* input */    \
sp457drivers/scsi/in2000.cunsigned short *sp;
sp667drivers/scsi/in2000.csp = (unsigned short *)cmd->SCp.ptr;
sp675drivers/scsi/in2000.cwrite2_io(*sp++,IO_FIFO);
sp682drivers/scsi/in2000.csp = flushbuf;
sp764drivers/scsi/in2000.cunsigned short *sp;
sp823drivers/scsi/in2000.csp = (unsigned short *)cmd->SCp.ptr;
sp836drivers/scsi/in2000.cwrite2_io(*sp++,IO_FIFO);
sp867drivers/scsi/in2000.cunsigned short *sp;
sp950drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
sp960drivers/scsi/in2000.c*sp++ = read2_io(IO_FIFO);
sp964drivers/scsi/in2000.ci = sp - (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
sp995drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
sp1002drivers/scsi/in2000.cwrite2_io(*sp++,IO_FIFO);
sp1004drivers/scsi/in2000.ci = sp - (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
sp1054drivers/scsi/in2000.csp = (unsigned short *)(cmd->SCp.ptr + cmd->SCp.have_data_in);
sp1067drivers/scsi/in2000.c*sp++ = read2_io(IO_FIFO);
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;
sp231fs/binfmt_aout.cput_user(envp,--sp);
sp232fs/binfmt_aout.cput_user(argv,--sp);
sp234fs/binfmt_aout.cput_user(argc,--sp);
sp248fs/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_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;
sp89net/ipv4/proc.csp = s_array[i];
sp90net/ipv4/proc.cwhile(sp != NULL) 
sp95net/ipv4/proc.csp = sp->next;
sp98net/ipv4/proc.cdest  = sp->daddr;
sp99net/ipv4/proc.csrc   = sp->saddr;
sp100net/ipv4/proc.cdestp = sp->dummy_th.dest;
sp101net/ipv4/proc.csrcp  = sp->dummy_th.source;
sp106net/ipv4/proc.ctimer_active1 = del_timer(&sp->retransmit_timer);
sp107net/ipv4/proc.ctimer_active2 = del_timer(&sp->timer);
sp108net/ipv4/proc.cif (!timer_active1) sp->retransmit_timer.expires=0;
sp109net/ipv4/proc.cif (!timer_active2) sp->timer.expires=0;
sp113net/ipv4/proc.csp->retransmit_timer.expires < timer_expires) {
sp115net/ipv4/proc.ctimer_expires=sp->retransmit_timer.expires;
sp118net/ipv4/proc.csp->timer.expires < timer_expires) {
sp120net/ipv4/proc.ctimer_expires=sp->timer.expires;
sp124net/ipv4/proc.ci, src, srcp, dest, destp, sp->state, 
sp125net/ipv4/proc.cformat==0?sp->write_seq-sp->rcv_ack_seq:sp->wmem_alloc, 
sp126net/ipv4/proc.cformat==0?sp->acked_seq-sp->copied_seq:sp->rmem_alloc,
sp127net/ipv4/proc.ctimer_active, timer_expires-jiffies, (unsigned) sp->retransmits,
sp128net/ipv4/proc.c(sp->socket&&SOCK_INODE(sp->socket))?SOCK_INODE(sp->socket)->i_uid:0,
sp129net/ipv4/proc.ctimer_active?sp->timeout:0,
sp130net/ipv4/proc.csp->socket && SOCK_INODE(sp->socket) ?
sp131net/ipv4/proc.cSOCK_INODE(sp->socket)->i_ino : 0);
sp132net/ipv4/proc.cif (timer_active1) add_timer(&sp->retransmit_timer);
sp133net/ipv4/proc.cif (timer_active2) add_timer(&sp->timer);
sp142net/ipv4/proc.csp = sp->next;
sp1057net/unix/af_unix.cunsigned char *sp;
sp1097net/unix/af_unix.csp=iov->iov_base;
sp1138net/unix/af_unix.cmemcpy_tofs(sp, skb->data, num);
sp1145net/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;