taglinefilesource code
data460arch/alpha/kernel/bios32.cint data;
data463arch/alpha/kernel/bios32.cdata = inb(ide_base+1);    /* read the current contents */
data465arch/alpha/kernel/bios32.coutb(data | 0x40, ide_base+1);  /* turn on IDE */
data466arch/alpha/kernel/bios32.coutb(data | 0x40, ide_base+1);  /* turn on IDE, really! */
data369arch/alpha/kernel/osf_sys.casmlinkage int osf_mount(unsigned long typenr, char * path, int flag, void * data)
data376arch/alpha/kernel/osf_sys.cretval = osf_ufs_mount(path, (struct ufs_args *) data, flag);
data379arch/alpha/kernel/osf_sys.cretval = osf_cdfs_mount(path, (struct cdfs_args *) data, flag);
data382arch/alpha/kernel/osf_sys.cretval = osf_procfs_mount(path, (struct procfs_args *) data, flag);
data142arch/alpha/kernel/ptrace.cstatic inline int put_reg(struct task_struct *task, long regno, long data)
data153arch/alpha/kernel/ptrace.c*addr = data;
data216arch/alpha/kernel/ptrace.cunsigned long addr, unsigned long data)
data256arch/alpha/kernel/ptrace.c*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
data331arch/alpha/kernel/ptrace.cunsigned long data)
data352arch/alpha/kernel/ptrace.clow  |= data << (align * 8);
data353arch/alpha/kernel/ptrace.chigh |= data >> (64 - align * 8);
data357arch/alpha/kernel/ptrace.cput_long(tsk, vma, addr, data);
data365arch/alpha/kernel/ptrace.cunsigned int *data)
data378arch/alpha/kernel/ptrace.c*data = l;
data380arch/alpha/kernel/ptrace.c*data = l >> 32;
data392arch/alpha/kernel/ptrace.cunsigned int data)
data405arch/alpha/kernel/ptrace.cl = (l & 0xffffffff00000000UL) | ((unsigned long) data <<  0);
data407arch/alpha/kernel/ptrace.cl = (l & 0x00000000ffffffffUL) | ((unsigned long) data << 32);
data486arch/alpha/kernel/ptrace.casmlinkage long sys_ptrace(long request, long pid, long addr, long data,
data495arch/alpha/kernel/ptrace.crequest, pid, addr, data));
data569arch/alpha/kernel/ptrace.cDBG(DBG_MEM, ("poke %#lx<-%#lx\n", addr, data));
data570arch/alpha/kernel/ptrace.creturn write_long(child, addr, data);
data573arch/alpha/kernel/ptrace.cDBG(DBG_MEM, ("poke $%ld<-%#lx\n", addr, data));
data574arch/alpha/kernel/ptrace.creturn put_reg(child, addr, data);
data579arch/alpha/kernel/ptrace.cif ((unsigned long) data > NSIG)
data585arch/alpha/kernel/ptrace.cchild->exit_code = data;
data589arch/alpha/kernel/ptrace.creturn data;
data608arch/alpha/kernel/ptrace.cif ((unsigned long) data > NSIG)
data613arch/alpha/kernel/ptrace.cchild->exit_code = data;
data619arch/alpha/kernel/ptrace.cif ((unsigned long) data > NSIG)
data623arch/alpha/kernel/ptrace.cchild->exit_code = data;
data70arch/i386/kernel/ptrace.cunsigned long data)
data76arch/i386/kernel/ptrace.c*(unsigned long *) stack = data;
data138arch/i386/kernel/ptrace.cunsigned long data)
data178arch/i386/kernel/ptrace.c*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
data251arch/i386/kernel/ptrace.cunsigned long data)
data270arch/i386/kernel/ptrace.clow = data;
data274arch/i386/kernel/ptrace.clow |= data << 8;
data276arch/i386/kernel/ptrace.chigh |= data >> 24;
data280arch/i386/kernel/ptrace.clow |= data << 16;
data282arch/i386/kernel/ptrace.chigh |= data >> 16;
data286arch/i386/kernel/ptrace.clow |= data << 24;
data288arch/i386/kernel/ptrace.chigh |= data >> 8;
data294arch/i386/kernel/ptrace.cput_long(tsk, vma, addr, data);
data298arch/i386/kernel/ptrace.casmlinkage int sys_ptrace(long request, long pid, long addr, long data)
data360arch/i386/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
data362arch/i386/kernel/ptrace.cput_fs_long(tmp,(unsigned long *) data);
data375arch/i386/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
data394arch/i386/kernel/ptrace.cput_fs_long(tmp,(unsigned long *) data);
data401arch/i386/kernel/ptrace.creturn write_long(child,addr,data);
data415arch/i386/kernel/ptrace.cdata &= 0xffff;
data416arch/i386/kernel/ptrace.cif (data && (data & 3) != 3)
data420arch/i386/kernel/ptrace.cdata &= FLAG_MASK;
data421arch/i386/kernel/ptrace.cdata |= get_stack_long(child, EFL*sizeof(long)-MAGICNUMBER)  & ~FLAG_MASK;
data426arch/i386/kernel/ptrace.cif (put_stack_long(child, sizeof(long)*addr-MAGICNUMBER, data))
data443arch/i386/kernel/ptrace.c((unsigned long) data) >= 0xbffffffd) return -EIO;
data446arch/i386/kernel/ptrace.cdata &= ~DR_CONTROL_RESERVED;
data448arch/i386/kernel/ptrace.cif ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
data454arch/i386/kernel/ptrace.cchild->debugreg[addr] = data;
data463arch/i386/kernel/ptrace.cif ((unsigned long) data > NSIG)
data469arch/i386/kernel/ptrace.cchild->exit_code = data;
data498arch/i386/kernel/ptrace.cif ((unsigned long) data > NSIG)
data504arch/i386/kernel/ptrace.cchild->exit_code = data;
data512arch/i386/kernel/ptrace.cif ((unsigned long) data > NSIG)
data516arch/i386/kernel/ptrace.cchild->exit_code = data;
data935arch/i386/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
data995arch/i386/kernel/smp.csmp_msg_data=data;
data2387arch/m68k/amiga/amifb.cstatic void mono_amifb_interrupt(int irq, struct pt_regs *fp, void *data)
data3022arch/m68k/amiga/amifb.cu_long data[64*4];
data3026arch/m68k/amiga/amifb.cu_long data[32*4];
data3037arch/m68k/amiga/amifb.cu_long data[4];
data3927arch/m68k/amiga/amifb.cmemcpy(var->data, sprite->u.nonlaced.data, sizeof(var->data));
data3937arch/m68k/amiga/amifb.cmemcpy(sprite->u.nonlaced.data, var->data, sizeof(var->data));
data56arch/m68k/amiga/amiints.cami_int1(int irq, struct pt_regs *fp, void *data),
data57arch/m68k/amiga/amiints.cami_int2(int irq, struct pt_regs *fp, void *data),
data58arch/m68k/amiga/amiints.cami_int3(int irq, struct pt_regs *fp, void *data),
data59arch/m68k/amiga/amiints.cami_int4(int irq, struct pt_regs *fp, void *data),
data60arch/m68k/amiga/amiints.cami_int5(int irq, struct pt_regs *fp, void *data),
data61arch/m68k/amiga/amiints.cami_int6(int irq, struct pt_regs *fp, void *data),
data62arch/m68k/amiga/amiints.cami_int7(int irq, struct pt_regs *fp, void *data),
data63arch/m68k/amiga/amiints.cami_intcia(int irq, struct pt_regs *fp, void *data);
data108arch/m68k/amiga/amiints.cstatic void ami_int1 (int irq, struct pt_regs *fp, void *data)
data147arch/m68k/amiga/amiints.cstatic void ami_int2 (int irq, struct pt_regs *fp, void *data)
data161arch/m68k/amiga/amiints.cstatic void ami_int3 (int irq, struct pt_regs *fp, void *data)
data193arch/m68k/amiga/amiints.cstatic void ami_int4 (int irq, struct pt_regs *fp, void *data)
data234arch/m68k/amiga/amiints.cstatic void ami_int5 (int irq, struct pt_regs *fp, void *data)
data259arch/m68k/amiga/amiints.cstatic void ami_int6 (int irq, struct pt_regs *fp, void *data)
data273arch/m68k/amiga/amiints.cstatic void ami_int7 (int irq, struct pt_regs *fp, void *data)
data278arch/m68k/amiga/amiints.cstatic void ami_intcia (int irq, struct pt_regs *fp, void *data)
data328arch/m68k/amiga/amiints.c*data, char *name)
data341arch/m68k/amiga/amiints.cp->data = data;
data732arch/m68k/amiga/config.cchar data[0];
data754arch/m68k/amiga/config.cmemcpy(savekmsg->data+savekmsg->size, b, len);
data110arch/m68k/atari/ataints.cvoid  *data;
data415arch/m68k/atari/ataints.cp->isr( irq, fp, p->data );
data428arch/m68k/atari/ataints.c*data, char *name)
data459arch/m68k/atari/ataints.cirq_handler[source].data = data;
data485arch/m68k/atari/ataints.cp->data = irq_handler[source].data;
data490arch/m68k/atari/ataints.cirq_handler[source].data = p;
data497arch/m68k/atari/ataints.cp->data = data;
data500arch/m68k/atari/ataints.cp->next = irq_handler[source].data;
data501arch/m68k/atari/ataints.cirq_handler[source].data = p;
data541arch/m68k/atari/ataints.cirq_handler[source].data = NULL;
data553arch/m68k/atari/ataints.cfor( p = (isr_node_t **)&irq_handler[source].data; *p; p = &(*p)->next ) {
data566arch/m68k/atari/ataints.cq = (isr_node_t *)irq_handler[source].data;
data569arch/m68k/atari/ataints.cirq_handler[source].data = q->data;
data621arch/m68k/atari/ataints.cfor( p = (isr_node_t *)irq_handler[i].data; p; p = p->next ) {
data718arch/m68k/atari/atakeyb.cvoid ikbd_mem_write(int address, int size, char *data)
data724arch/m68k/atari/atakeyb.cvoid ikbd_mem_read(int address, char data[6])
data56arch/m68k/atari/atasound.ctt_microwire.data = MW_LM1992_ADDR | cmd;
data349arch/m68k/atari/config.chwreg_present( &tt_microwire.data ) &&
data352arch/m68k/atari/config.ctt_microwire.data = MW_LM1992_PSG_HIGH | MW_LM1992_ADDR,
data353arch/m68k/atari/config.ctt_microwire.data != 0)) {
data499arch/m68k/atari/config.c__val = tt_rtc.data;    \
data506arch/m68k/atari/config.ctt_rtc.data = (val);    \
data75arch/m68k/atari/stdma.cvoid stdma_lock(isrfunc isr, void *data)
data90arch/m68k/atari/stdma.cstdma_isr_data = data;
data1712arch/m68k/console/fbcon.cstatic int fbcon_get_font(struct vc_data *conp, int *w, int *h, char *data)
data1727arch/m68k/console/fbcon.cif ((i = verify_area( VERIFY_WRITE, (void *)data, size )))
data1730arch/m68k/console/fbcon.cmemcpy_tofs( data, p->fontdata, size );
data1737arch/m68k/console/fbcon.cstatic int fbcon_set_font(struct vc_data *conp, int w, int h, char *data)
data1753arch/m68k/console/fbcon.cif ((i = verify_area( VERIFY_READ, (void *)data, MAX_FONT_NAME )))
data1755arch/m68k/console/fbcon.cmemcpy_fromfs( name, data, MAX_FONT_NAME );
data1758arch/m68k/console/fbcon.cif (!findsoftfont( name, &w, &h, (u_char **)&data ))
data1797arch/m68k/console/fbcon.cif ((i = verify_area( VERIFY_READ, (void *)data, size )))
data1803arch/m68k/console/fbcon.cmemcpy_fromfs( new_data, data, size );
data1808arch/m68k/console/fbcon.cp->fontdata = data;
data41arch/m68k/console/fonts.cu_char *data;
data56arch/m68k/console/fonts.cint findsoftfont(char *name, int *width, int *height, u_char *data[])
data66arch/m68k/console/fonts.cif (data)
data67arch/m68k/console/fonts.c*data = softfonts[i].data;
data79arch/m68k/console/fonts.cu_char *data[])
data88arch/m68k/console/fonts.cif (data)
data89arch/m68k/console/fonts.c*data = fontdata_8x8;
data97arch/m68k/console/fonts.cif (data)
data98arch/m68k/console/fonts.c*data = fontdata_8x16;
data307arch/m68k/fpsp040/fpsp.h|        this can only be used if in a data register
data114arch/m68k/kernel/ints.cint add_isr (unsigned long source, isrfunc isr, int pri, void *data,
data121arch/m68k/kernel/ints.creturn mach_add_isr (source, isr, pri, data, name);
data132arch/m68k/kernel/ints.cp->data = data;
data158arch/m68k/kernel/ints.cp->isr (irq, fp, p->data);
data85arch/m68k/kernel/ptrace.cunsigned long data)
data95arch/m68k/kernel/ptrace.c*addr = data;
data159arch/m68k/kernel/ptrace.cunsigned long data)
data200arch/m68k/kernel/ptrace.c*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
data274arch/m68k/kernel/ptrace.cunsigned long data)
data293arch/m68k/kernel/ptrace.chigh = data;
data297arch/m68k/kernel/ptrace.clow |= data << 8;
data299arch/m68k/kernel/ptrace.chigh |= data >> 24;
data303arch/m68k/kernel/ptrace.clow |= data << 16;
data305arch/m68k/kernel/ptrace.chigh |= data >> 16;
data309arch/m68k/kernel/ptrace.clow |= data << 24;
data311arch/m68k/kernel/ptrace.chigh |= data >> 8;
data317arch/m68k/kernel/ptrace.cput_long(tsk, vma,addr,data);
data321arch/m68k/kernel/ptrace.casmlinkage int sys_ptrace(long request, long pid, long addr, long data)
data380arch/m68k/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
data382arch/m68k/kernel/ptrace.cput_user(tmp, (unsigned long *) data);
data394arch/m68k/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data,
data409arch/m68k/kernel/ptrace.cput_user(tmp,(unsigned long *) data);
data416arch/m68k/kernel/ptrace.creturn write_long(child,addr,data);
data427arch/m68k/kernel/ptrace.cdata &= SR_MASK;
data428arch/m68k/kernel/ptrace.cdata <<= 16;
data429arch/m68k/kernel/ptrace.cdata |= get_reg(child, PT_SR) & ~(SR_MASK << 16);
data432arch/m68k/kernel/ptrace.cif (put_reg(child, addr, data))
data438arch/m68k/kernel/ptrace.cchild->tss.fp[addr - 21] = data;
data447arch/m68k/kernel/ptrace.cif ((unsigned long) data >= NSIG)
data453arch/m68k/kernel/ptrace.cchild->exit_code = data;
data482arch/m68k/kernel/ptrace.cif ((unsigned long) data >= NSIG)
data489arch/m68k/kernel/ptrace.cchild->exit_code = data;
data497arch/m68k/kernel/ptrace.cif ((unsigned long) data >= NSIG)
data501arch/m68k/kernel/ptrace.cchild->exit_code = data;
data397arch/mips/kernel/irq.cbh_base[i].data = NULL;
data96arch/mips/kernel/jazz-c.cvoid jazz_rtc_write_data(unsigned char data)
data98arch/mips/kernel/jazz-c.c*(char *)JAZZ_RTC_BASE = data;
data70arch/mips/kernel/ptrace.cunsigned long data)
data76arch/mips/kernel/ptrace.c*(unsigned long *) stack = data;
data126arch/mips/kernel/ptrace.cunsigned long data)
data155arch/mips/kernel/ptrace.c*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
data228arch/mips/kernel/ptrace.cunsigned long data)
data247arch/mips/kernel/ptrace.clow = data;
data251arch/mips/kernel/ptrace.clow |= data << 8;
data253arch/mips/kernel/ptrace.chigh |= data >> 24;
data257arch/mips/kernel/ptrace.clow |= data << 16;
data259arch/mips/kernel/ptrace.chigh |= data >> 16;
data263arch/mips/kernel/ptrace.clow |= data << 24;
data265arch/mips/kernel/ptrace.chigh |= data >> 8;
data271arch/mips/kernel/ptrace.cput_long(vma, addr, data);
data276arch/mips/kernel/ptrace.casmlinkage int sys_ptrace(long request, long pid, long addr, long data)
data340arch/mips/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
data342arch/mips/kernel/ptrace.cput_fs_long(tmp,(unsigned long *) data);
data355arch/mips/kernel/ptrace.cres = verify_area(VERIFY_WRITE, (void *) data, sizeof(long));
data374arch/mips/kernel/ptrace.cput_fs_long(tmp,(unsigned long *) data);
data381arch/mips/kernel/ptrace.creturn write_long(child,addr,data);
data395arch/mips/kernel/ptrace.cdata &= 0xffff;
data396arch/mips/kernel/ptrace.cif (data && (data & 3) != 3)
data400arch/mips/kernel/ptrace.cdata &= FLAG_MASK;
data401arch/mips/kernel/ptrace.cdata |= get_stack_long(child, EFL*sizeof(long)-MAGICNUMBER)  & ~FLAG_MASK;
data406arch/mips/kernel/ptrace.cif (put_stack_long(child, sizeof(long)*addr-MAGICNUMBER, data))
data423arch/mips/kernel/ptrace.c((unsigned long) data) >= 0xbffffffd) return -EIO;
data426arch/mips/kernel/ptrace.cdata &= ~DR_CONTROL_RESERVED;
data428arch/mips/kernel/ptrace.cif ((0x5f54 >> ((data >> (16 + 4*i)) & 0xf)) & 1)
data434arch/mips/kernel/ptrace.cchild->debugreg[addr] = data;
data443arch/mips/kernel/ptrace.cif ((unsigned long) data > NSIG)
data449arch/mips/kernel/ptrace.cchild->exit_code = data;
data478arch/mips/kernel/ptrace.cif ((unsigned long) data > NSIG)
data484arch/mips/kernel/ptrace.cchild->exit_code = data;
data492arch/mips/kernel/ptrace.cif ((unsigned long) data > NSIG)
data496arch/mips/kernel/ptrace.cchild->exit_code = data;
data61arch/mips/kernel/setup.cvoid jazz_rtc_write_data(unsigned char data);
data148arch/mips/kernel/setup.cvoid jazz_rtc_write_data(unsigned char data);
data20arch/ppc/boot/cortstrip.cunsigned char data[SIZE];
data58arch/ppc/boot/cortstrip.cwhile ( (n = read(fd, data, SIZE)) > 0 )
data61arch/ppc/boot/cortstrip.ci = write(fdo, data, n);
data15arch/ppc/kernel/cortstrip.cunsigned char data[SIZE];
data49arch/ppc/kernel/cortstrip.cwhile ( (n = read(fd, data, SIZE)) > 0 )
data52arch/ppc/kernel/cortstrip.ci = write(fdo, data, n);
data16arch/ppc/kernel/mkboot.cunsigned char data[SIZE];
data54arch/ppc/kernel/mkboot.cwhile ( (n = read(fd, data, SIZE)) > 0 )
data57arch/ppc/kernel/mkboot.ci = write(fdo, data, n);
data91arch/sparc/kernel/ptrace.cunsigned long addr, unsigned long data)
data132arch/sparc/kernel/ptrace.c*(unsigned long *) (page + (addr & ~PAGE_MASK)) = data;
data207arch/sparc/kernel/ptrace.cunsigned long data)
data213arch/sparc/kernel/ptrace.cput_long(tsk, vma, addr, data);
data218arch/sparc/kernel/ptrace.cunsigned char data)
data229arch/sparc/kernel/ptrace.ctmp |= (data << 24);
data233arch/sparc/kernel/ptrace.ctmp |= ((data << 16) & 0x00ff0000);
data237arch/sparc/kernel/ptrace.ctmp |= ((data << 8) & 0x0000ff00);
data241arch/sparc/kernel/ptrace.ctmp |= (data & 0x000000ff);
data438arch/sparc/kernel/ptrace.cunsigned long data = regs->u_regs[UREG_I3];
data444arch/sparc/kernel/ptrace.c(int) request, (int) pid, addr, data, addr2);
data557arch/sparc/kernel/ptrace.cres = write_long(child, addr, data);
data675arch/sparc/kernel/ptrace.cint res, len = data;
data699arch/sparc/kernel/ptrace.cint res, len = data;
data719arch/sparc/kernel/ptrace.cdata = 0;
data723arch/sparc/kernel/ptrace.cif ((unsigned long) data > NSIG) {
data731arch/sparc/kernel/ptrace.cchild->exit_code = data;
data758arch/sparc/kernel/ptrace.cif ((unsigned long) data > NSIG) {
data764arch/sparc/kernel/ptrace.cchild->exit_code = data;
data310arch/sparc/kernel/smp.cvoid smp_message_pass(int target, int msg, unsigned long data, int wait)
data364arch/sparc/kernel/smp.csmp_msg_data = data;
data692arch/sparc/kernel/sys_sunos.casmlinkage int sunos_nfs_mount(char *dir_name, int linux_flags, void *data)
data698arch/sparc/kernel/sys_sunos.cstruct sunos_nfs_mount_args *sunos_mount = data;
data701arch/sparc/kernel/sys_sunos.cerror = verify_area(VERIFY_READ, data, sizeof (struct sunos_nfs_mount_args));
data753arch/sparc/kernel/sys_sunos.csunos_mount(char *type, char *dir, int flags, void *data)
data777arch/sparc/kernel/sys_sunos.cdev_fname = (char *) data;
data779arch/sparc/kernel/sys_sunos.cdev_fname = (char *) data;
data781arch/sparc/kernel/sys_sunos.cdev_fname = (char *) data;
data783arch/sparc/kernel/sys_sunos.cdev_fname = (char *) data;
data785arch/sparc/kernel/sys_sunos.cdev_fname = (char *) data;
data787arch/sparc/kernel/sys_sunos.cerror = sunos_nfs_mount (dir, flags, data);
data22arch/sparc/kernel/tadpole.cunsigned long data;
data25arch/sparc/kernel/tadpole.c"=r" (data) :
data27arch/sparc/kernel/tadpole.creturn data;
data61drivers/block/ali14xx.ctypedef struct { byte reg, data; } RegInitializer;
data109drivers/block/ali14xx.cstatic void outReg (byte data, byte reg)
data112drivers/block/ali14xx.coutb_p(data, dataPort);
data208drivers/block/ali14xx.coutReg(p->data, p->reg);
data269drivers/block/amiflop.cmotor_on_timer.data = nr;
data447drivers/block/amiflop.cstatic void encode(unsigned long data, unsigned long *dest)
data451drivers/block/amiflop.cdata &= 0x55555555;
data452drivers/block/amiflop.cdata2 = data ^ 0x55555555;
data453drivers/block/amiflop.cdata |= ((data2 >> 1) | 0x80000000) & (data2 << 1);
data456drivers/block/amiflop.cdata &= 0x7FFFFFFF;
data458drivers/block/amiflop.c*dest = data;
data464drivers/block/amiflop.cunsigned long data;
data468drivers/block/amiflop.cdata = src[cnt] >> 1;
data469drivers/block/amiflop.cencode(data, dest + to_cnt++);
data474drivers/block/amiflop.cdata = src[cnt];
data475drivers/block/amiflop.cencode(data, dest + to_cnt++);
data502drivers/block/amiflop.cunsigned char *data)
data523drivers/block/amiflop.chdr.datachk = checksum((ulong *)data, 512);
data533drivers/block/amiflop.cencode_block(raw, (ulong *)data, 512);
data543drivers/block/amiflop.cstatic void amiga_write(int disk, unsigned long raw, unsigned char *data,
data556drivers/block/amiflop.cptr = putsec (disk, ptr, track, cnt, data + cnt*512);
data561drivers/block/amiflop.cstatic unsigned long decode (unsigned long *data, unsigned long *raw,
data575drivers/block/amiflop.c*data++ = ((*odd++ & 0x55555555) << 1) | (*even++ & 0x55555555);
data690drivers/block/amiflop.cstatic inline ushort dos_data_crc(unsigned char *data)
data692drivers/block/amiflop.creturn dos_crc(data, 0xe2, 0x95 ,511); /* precomputed magic */
data790drivers/block/amiflop.cregister unsigned char *CRCT1, *CRCT2, *data, c, crch, crcl;
data794drivers/block/amiflop.cdata=data_a3;
data798drivers/block/amiflop.cc = (*data++) ^ crch;
data821drivers/block/amiflop.cstatic unsigned long dos_decode(unsigned char *data, unsigned short *raw, int len)
data826drivers/block/amiflop.c*data++=dos_decode_byte(*raw++);
data955drivers/block/amiflop.cunsigned char *data)
data990drivers/block/amiflop.cdos_encode_block((ushort *)raw,(unsigned char *)data,512);
data994drivers/block/amiflop.ccrc[0]=dos_data_crc(data);
data1009drivers/block/amiflop.cstatic void dos_write(int disk, unsigned long raw, unsigned char *data,
data1037drivers/block/amiflop.cptr=ms_putsec(disk,ptr,track,cnt,data+cnt*512);
data1249drivers/block/amiflop.cchar *data;
data1311drivers/block/amiflop.cdata = CURRENT->buffer + 512 * cnt;
data1340drivers/block/amiflop.ccopy_buffer(trackdata + sector * 512, data);
data1357drivers/block/amiflop.ccopy_buffer(data, trackdata + sector * 512);
data1370drivers/block/amiflop.cflush_track_timer.data = drive;
data1726drivers/block/amiflop.cmotor_on_timer.data = 0;
data1732drivers/block/amiflop.cmotor_off_timer[i].data = i;
data1741drivers/block/amiflop.cflush_track_timer.data = 0;
data1747drivers/block/amiflop.cpost_write_timer.data = 0;
data138drivers/block/floppy.cvoid *data;
data168drivers/block/floppy.cstatic int set_dor(int fdc, char mask, char data);
data599drivers/block/floppy.cunsigned char data;
data736drivers/block/floppy.cstatic int set_dor(int fdc, char mask, char data)
data744drivers/block/floppy.cnewdor =  (olddor & mask) | data;
data1084drivers/block/floppy.coutput_log[output_log_pos].data = byte;
data1788drivers/block/floppy.coutput_log[(i+output_log_pos) % OLOGSIZE].data,
data1848drivers/block/floppy.cint mask, data;
data1851drivers/block/floppy.cdata = UNIT(current_drive);
data1859drivers/block/floppy.cdata |= (0x10 << UNIT(current_drive));
data1867drivers/block/floppy.cset_dor(fdc, mask, data);
data2955drivers/block/floppy.cold_raw_cmd.data = ptr->data;
data2969drivers/block/floppy.cECALL(fd_copyout(ptr->data, 
data3017drivers/block/floppy.cptr->data = old_raw_cmd.data;
data3060drivers/block/floppy.cECALL( verify_area( VERIFY_WRITE, ptr->data, 
data3063drivers/block/floppy.cECALL(fd_copyin(ptr->data, ptr->kernel_data, 
data253drivers/block/genhd.cunsigned char *data;
data264drivers/block/genhd.cdata = bh->b_data;
data272drivers/block/genhd.cif (*(unsigned short *)  (0x1fe + data) != 0xAA55) {
data276drivers/block/genhd.cp = (struct partition *) (0x1be + data);
data284drivers/block/genhd.cunsigned int sig = *(unsigned short *)(data + 2);
data295drivers/block/genhd.cdata += 512;
data314drivers/block/genhd.c} else if (sig <= 0x1ae && *(unsigned short *)(data + sig) == 0x55AA
data315drivers/block/genhd.c&& (1 & *(unsigned char *)(data + sig + 2)) ) 
data380drivers/block/genhd.cif (*(unsigned short *) (data+0xfc) == 0x55AA) {
data381drivers/block/genhd.cp = (struct partition *) (0x1be + data);
data830drivers/block/ide-tape.cvoid idetape_poll_for_dsc (unsigned long data);
data831drivers/block/ide-tape.cvoid idetape_poll_for_dsc_direct (unsigned long data);
data1741drivers/block/ide-tape.ctape->dsc_timer.data=(unsigned long) drive;
data1772drivers/block/ide-tape.cvoid idetape_poll_for_dsc_direct (unsigned long data)
data1775drivers/block/ide-tape.cide_drive_t *drive=(ide_drive_t *) data;
data1827drivers/block/ide-tape.cvoid idetape_poll_for_dsc (unsigned long data)
data1830drivers/block/ide-tape.cide_drive_t *drive=(ide_drive_t *) data;
data1851drivers/block/ide-tape.cidetape_poll_for_dsc_direct (data);
data4313drivers/block/ide-tape.cnew_stage->bh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
data4314drivers/block/ide-tape.cif (new_stage->bh->data==NULL) {
data4327drivers/block/ide-tape.cbh->data=kmalloc (IDETAPE_ALLOCATION_BLOCK,GFP_KERNEL);
data4328drivers/block/ide-tape.cif (bh->data == NULL) {
data4358drivers/block/ide-tape.cif (bh->data != NULL)
data4359drivers/block/ide-tape.ckfree (bh->data);
data4394drivers/block/ide-tape.cif (bh->data == NULL) {
data4399drivers/block/ide-tape.cmemcpy (ptr,bh->data,IDETAPE_ALLOCATION_BLOCK);
data4432drivers/block/ide-tape.cif (bh->data == NULL) {
data4437drivers/block/ide-tape.cmemcpy (bh->data,ptr,IDETAPE_ALLOCATION_BLOCK);
data335drivers/block/ide-tape.hchar *data;          /* Pointer to data (512 bytes by default) */
data1557drivers/block/ide.cstatic void timer_expiry (unsigned long data)
data1559drivers/block/ide.cide_hwgroup_t *hwgroup = (ide_hwgroup_t *) data;
data3059drivers/block/ide.chwgroup->timer.data = (unsigned long) hwgroup;
data33drivers/block/linear.cstruct linear_data *data;
data38drivers/block/linear.cdata=(struct linear_data *) mddev->private;
data46drivers/block/linear.cdata->smallest=devices[minor];
data48drivers/block/linear.cif (data->smallest->size > devices[minor][i].size)
data49drivers/block/linear.cdata->smallest=devices[minor]+i;
data51drivers/block/linear.cnb_zone=data->nr_zones=
data52drivers/block/linear.cmd_size[minor]/data->smallest->size +
data53drivers/block/linear.c(md_size[minor]%data->smallest->size ? 1 : 0);
data55drivers/block/linear.cdata->hash_table=kmalloc (sizeof (struct linear_hash)*nb_zone, GFP_KERNEL);
data62drivers/block/linear.cdata->hash_table[i].dev0=devices[minor]+cur;
data64drivers/block/linear.cif (size>=data->smallest->size) /* If we completely fill the slot */
data66drivers/block/linear.cdata->hash_table[i++].dev1=NULL;
data67drivers/block/linear.csize-=data->smallest->size;
data80drivers/block/linear.cdata->hash_table[i].dev1=NULL;
data86drivers/block/linear.cdata->hash_table[i++].dev1=devices[minor]+cur;
data87drivers/block/linear.csize-=(data->smallest->size - dev0_size);
data95drivers/block/linear.cstruct linear_data *data=(struct linear_data *) mddev->private;
data97drivers/block/linear.ckfree (data->hash_table);
data98drivers/block/linear.ckfree (data);
data109drivers/block/linear.cstruct linear_data *data=(struct linear_data *) mddev->private;
data115drivers/block/linear.chash=data->hash_table+(block/data->smallest->size);
data146drivers/block/linear.cstruct linear_data *data=(struct linear_data *) mddev->private;
data149drivers/block/linear.cfor (j=0; j<data->nr_zones; j++)
data152drivers/block/linear.cpartition_name (data->hash_table[j].dev0->dev));
data154drivers/block/linear.cif (data->hash_table[j].dev1)
data156drivers/block/linear.cpartition_name(data->hash_table[j].dev1->dev));
data87drivers/block/ll_rw_blk.cvoid unplug_device(void * data)
data89drivers/block/ll_rw_blk.cstruct blk_dev_struct * dev = (struct blk_dev_struct *) data;
data595drivers/block/ll_rw_blk.cdev->plug_tq.data    = dev;
data34drivers/block/raid0.cstruct raid0_data *data=(struct raid0_data *) mddev->private;
data36drivers/block/raid0.cdata->nr_strip_zones=1;
data48drivers/block/raid0.cdata->nr_strip_zones++;
data53drivers/block/raid0.cdata->strip_zone=kmalloc (sizeof(struct strip_zone)*data->nr_strip_zones,
data56drivers/block/raid0.cdata->smallest=NULL;
data58drivers/block/raid0.cfor (i=0; i<data->nr_strip_zones; i++)
data60drivers/block/raid0.cdata->strip_zone[i].dev_offset=current_offset;
data67drivers/block/raid0.cdata->strip_zone[i].dev[c++]=devices[minor]+j;
data73drivers/block/raid0.cdata->strip_zone[i].nb_dev=c;
data74drivers/block/raid0.cdata->strip_zone[i].size=(smallest_by_zone->size-current_offset)*c;
data76drivers/block/raid0.cif (!data->smallest ||
data77drivers/block/raid0.cdata->smallest->size > data->strip_zone[i].size)
data78drivers/block/raid0.cdata->smallest=data->strip_zone+i;
data80drivers/block/raid0.cdata->strip_zone[i].zone_offset=i ? (data->strip_zone[i-1].zone_offset+
data81drivers/block/raid0.cdata->strip_zone[i-1].size) : 0;
data89drivers/block/raid0.cstruct raid0_data *data;
data113drivers/block/raid0.cdata=(struct raid0_data *) mddev->private;
data117drivers/block/raid0.cnb_zone=data->nr_zones=
data118drivers/block/raid0.cmd_size[minor]/data->smallest->size +
data119drivers/block/raid0.c(md_size[minor]%data->smallest->size ? 1 : 0);
data121drivers/block/raid0.cdata->hash_table=kmalloc (sizeof (struct raid0_hash)*nb_zone, GFP_KERNEL);
data123drivers/block/raid0.csize=data->strip_zone[cur].size;
data126drivers/block/raid0.cwhile (cur<data->nr_strip_zones)
data128drivers/block/raid0.cdata->hash_table[i].zone0=data->strip_zone+cur;
data130drivers/block/raid0.cif (size>=data->smallest->size)/* If we completely fill the slot */
data132drivers/block/raid0.cdata->hash_table[i++].zone1=NULL;
data133drivers/block/raid0.csize-=data->smallest->size;
data137drivers/block/raid0.cif (++cur==data->nr_strip_zones) continue;
data138drivers/block/raid0.csize=data->strip_zone[cur].size;
data144drivers/block/raid0.cif (++cur==data->nr_strip_zones) /* Last dev, set unit1 as NULL */
data146drivers/block/raid0.cdata->hash_table[i].zone1=NULL;
data151drivers/block/raid0.csize=data->strip_zone[cur].size;
data152drivers/block/raid0.cdata->hash_table[i++].zone1=data->strip_zone+cur;
data153drivers/block/raid0.csize-=(data->smallest->size - zone0_size);
data162drivers/block/raid0.cstruct raid0_data *data=(struct raid0_data *) mddev->private;
data164drivers/block/raid0.ckfree (data->hash_table);
data165drivers/block/raid0.ckfree (data->strip_zone);
data166drivers/block/raid0.ckfree (data);
data182drivers/block/raid0.cstruct raid0_data *data=(struct raid0_data *) mddev->private;
data192drivers/block/raid0.chash=data->hash_table+(block/data->smallest->size);
data233drivers/block/raid0.cstruct raid0_data *data=(struct raid0_data *) mddev->private;
data236drivers/block/raid0.cfor (j=0; j<data->nr_zones; j++)
data239drivers/block/raid0.cdata->hash_table[j].zone0-data->strip_zone);
data240drivers/block/raid0.cif (data->hash_table[j].zone1)
data242drivers/block/raid0.cdata->hash_table[j].zone1-data->strip_zone);
data249drivers/block/raid0.cfor (j=0; j<data->nr_strip_zones; j++)
data252drivers/block/raid0.cfor (k=0; k<data->strip_zone[j].nb_dev; k++)
data254drivers/block/raid0.cpartition_name(data->strip_zone[j].dev[k]->dev));
data257drivers/block/raid0.cdata->strip_zone[j].zone_offset,
data258drivers/block/raid0.cdata->strip_zone[j].dev_offset,
data259drivers/block/raid0.cdata->strip_zone[j].size);
data453drivers/cdrom/aztcd.c{  unsigned char data;
data474drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data475drivers/cdrom/aztcd.cif (data==AFL_OP_OK)
data477drivers/cdrom/aztcd.cif (data==AFL_OP_ERR)
data479drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data480drivers/cdrom/aztcd.cprintk("### Error 1 aztcd: aztSendCmd %x  Error Code %x\n",cmd,data);
data494drivers/cdrom/aztcd.c{  unsigned char data;
data511drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data512drivers/cdrom/aztcd.cif (data==AFL_PA_OK)
data514drivers/cdrom/aztcd.cif (data==AFL_PA_ERR)
data516drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data517drivers/cdrom/aztcd.cprintk("### Error 1 aztcd: sendAztCmd %x  Error Code %x\n",cmd,data);
data531drivers/cdrom/aztcd.c{  unsigned char data;
data544drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data545drivers/cdrom/aztcd.cif (data==AFL_PA_OK)
data547drivers/cdrom/aztcd.cif (data==AFL_PA_ERR)
data549drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data565drivers/cdrom/aztcd.c{  unsigned char data;
data575drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data576drivers/cdrom/aztcd.cif (data==AFL_PA_OK)     /*PA_OK ?*/
data580drivers/cdrom/aztcd.cif (data==AFL_PA_ERR)
data582drivers/cdrom/aztcd.cdata=inb(DATA_PORT);
data583drivers/cdrom/aztcd.cprintk("### Error 1 aztcd: aztSetDiskType %x Error Code %x\n",type,data);
data1183drivers/cdrom/cdu31a.chandle_abort_timeout(unsigned long data)
data159drivers/cdrom/cm206.cstruct wait_queue * data;
data240drivers/cdrom/cm206.cif ((cd->wait_back || !cd->background) && cd->data) 
data241drivers/cdrom/cm206.cwake_up_interruptible(&cd->data);
data295drivers/cdrom/cm206.ccd->timer.data=(unsigned long) wait;
data459drivers/cdrom/cm206.cif (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
data616drivers/cdrom/cm206.cif (sleep_or_timeout(&cd->data, DATA_TIMEOUT)) {
data391drivers/cdrom/optcd.cunsigned char data;
data396drivers/cdrom/optcd.cdata = inb(DATA_PORT);
data397drivers/cdrom/optcd.cDEBUG((DEBUG_DRIVE_IF, "returned data 0x%02x", data));
data398drivers/cdrom/optcd.creturn data;
data484drivers/char/cyclades.cSP(char *data){
data487drivers/char/cyclades.cconsole_print(data);
data491drivers/char/cyclades.cCP(char data){
data495drivers/char/cyclades.cscrn[0] = data;
data501drivers/char/cyclades.cvoid CP1(int data) { (data<10)?  CP(data+'0'): CP(data+'A'-10); }/* CP1 */
data502drivers/char/cyclades.cvoid CP2(int data) { CP1((data>>4) & 0x0f); CP1( data & 0x0f); }/* CP2 */
data503drivers/char/cyclades.cvoid CP4(int data) { CP2((data>>8) & 0xff); CP2(data & 0xff); }/* CP4 */
data504drivers/char/cyclades.cvoid CP8(long data) { CP4((data>>16) & 0xffff); CP4(data & 0xffff); }/* CP8 */
data673drivers/char/cyclades.cchar data;
data724drivers/char/cyclades.cdata = base_addr[CyRDSR<<index];
data728drivers/char/cyclades.cdata = base_addr[CyRDSR<<index];
data735drivers/char/cyclades.cdata = base_addr[CyRDSR<<index];
data736drivers/char/cyclades.cif(data & info->ignore_status_mask){
data741drivers/char/cyclades.cif (data & info->read_status_mask){
data742drivers/char/cyclades.cif(data & CyBREAK){
data750drivers/char/cyclades.c}else if(data & CyFRAME){
data755drivers/char/cyclades.c}else if(data & CyPARITY){
data760drivers/char/cyclades.c}else if(data & CyOVERRUN){
data807drivers/char/cyclades.cdata = base_addr[CyRDSR<<index];
data809drivers/char/cyclades.c*tty->flip.char_buf_ptr++ = data;
data2902drivers/char/cyclades.cinfo->tqueue.data = info;
data505drivers/char/ftape/ecc.cstatic inline void set_parity(unsigned long *data, int nblocks, unsigned long *p, int stride)
data510drivers/char/ftape/ecc.cend = data + nblocks * (SECTOR_SIZE / sizeof(long));
data512drivers/char/ftape/ecc.cwhile (data < end) {
data523drivers/char/ftape/ecc.ct1 = gfadd_long(*data, p0);
data549drivers/char/ftape/ecc.cdata += SECTOR_SIZE / sizeof(long);
data592drivers/char/ftape/ecc.cstatic int compute_syndromes(unsigned long *data, int nblocks, unsigned long *s)
data596drivers/char/ftape/ecc.cset_parity(data, nblocks, p, 1);
data623drivers/char/ftape/ecc.cstatic inline int correct_block(unsigned char *data, int nblocks,
data709drivers/char/ftape/ecc.cdp = &data[l * SECTOR_SIZE];
data735drivers/char/ftape/ecc.cstatic int sanity_check(unsigned long *data, int nblocks)
data740drivers/char/ftape/ecc.cif (!compute_syndromes(data, nblocks, s)) {
data761drivers/char/ftape/ecc.cparity_bytes = &mseg->data[(mseg->blocks - 3) * SECTOR_SIZE];
data763drivers/char/ftape/ecc.cset_parity((unsigned long *) &mseg->data[i], mseg->blocks - 3,
data767drivers/char/ftape/ecc.cif (!sanity_check((unsigned long *) &mseg->data[i], mseg->blocks)) {
data795drivers/char/ftape/ecc.cif (!compute_syndromes((unsigned long *) &mseg->data[col],
data849drivers/char/ftape/ecc.cresult = correct_block(&mseg->data[col + sizeof(long) - 1 - i],
data854drivers/char/ftape/ecc.cresult = correct_block(&mseg->data[col + i], mseg->blocks,
data870drivers/char/ftape/ecc.cif (!sanity_check((unsigned long *) &mseg->data[col], mseg->blocks)) {
data878drivers/char/ftape/ecc.cif (!compute_syndromes((unsigned long *) &mseg->data[col],
data68drivers/char/ftape/ecc.hunsigned char *data;
data82drivers/char/ftape/ecc.hextern int ecc_correct_data(struct memory_segment *data);
data83drivers/char/ftape/ecc.hextern int ecc_set_segment_parity(struct memory_segment *data);
data136drivers/char/ftape/fdc-io.cint fdc_write(byte data)
data142drivers/char/ftape/fdc-io.coutb(data, fdc.fifo);
data151drivers/char/ftape/fdc-io.cint fdc_read(byte * data)
data157drivers/char/ftape/fdc-io.c*data = inb(fdc.fifo);
data376drivers/char/ftape/fdc-io.cint data = unit | FDC_RESET_NOT | FDC_DMA_MODE;
data380drivers/char/ftape/fdc-io.cdata |= FDC_MOTOR_0 << unit;
data386drivers/char/ftape/fdc-io.coutb_p(data, fdc.dor2);
data388drivers/char/ftape/fdc-io.coutb_p(data, fdc.dor);
data154drivers/char/ftape/fdc-io.hextern int fdc_write(byte data);
data155drivers/char/ftape/fdc-io.hextern int fdc_read(byte * data);
data119drivers/char/ftape/ftape-read.cmseg.data = buffer[tail].address;
data139drivers/char/ftape/ftape-read.cmemcpy(destination, mseg.data, (mseg.blocks - 3) * SECTOR_SIZE);
data89drivers/char/ftape/ftape-write.cmseg.data = destination;
data90drivers/char/ftape/ftape-write.cmemcpy(mseg.data, source, (mseg.blocks - 3) * SECTOR_SIZE);
data982drivers/char/istallion.cnt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
data1429drivers/char/istallion.cif (ap->changed.data & DT_TXEMPTY)
data1430drivers/char/istallion.cap->changed.data &= ~DT_TXEMPTY;
data1561drivers/char/istallion.cif (ap->changed.data & DT_TXEMPTY)
data1562drivers/char/istallion.cap->changed.data &= ~DT_TXEMPTY;
data2445drivers/char/istallion.cif (nt.data & DT_TXEMPTY)
data2447drivers/char/istallion.cif (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
data2457drivers/char/istallion.cif ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
data2474drivers/char/istallion.cif (nt.data & DT_RXBUSY) {
data2793drivers/char/istallion.cportp->tqhangup.data = portp;
data1067drivers/char/keyboard.cstatic int send_data(unsigned char data)
data1077drivers/char/keyboard.coutb_p(data, 0x60);
data1259drivers/char/keyboard.cint     status, data;
data1273drivers/char/keyboard.cdata = inb(KBD_DATA_REG);
data1284drivers/char/keyboard.creturn (data & 0xff);
data1289drivers/char/keyboard.cstatic void kbd_write(int address, int data)
data1296drivers/char/keyboard.coutb(data, address);               /* write out the data*/
data1279drivers/char/pcxx.cch->tqueue.data = ch;
data601drivers/char/random.c#define subRound(a, b, c, d, e, f, k, data) \
data602drivers/char/random.c( e += ROTL( 5, a ) + f( b, c, d ) + k + data, b = ROTL( 30, b ) )
data605drivers/char/random.cvoid SHATransform(__u32 *digest, __u32 *data)
data616drivers/char/random.cmemcpy( eData, data, 16*sizeof(__u32));
data732drivers/char/random.c#define MD5STEP(f, w, x, y, z, data, s) \
data733drivers/char/random.c( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
data1792drivers/char/riscom8.crc_port[i].tqueue.data = &rc_port[i];
data1794drivers/char/riscom8.crc_port[i].tqueue_hangup.data = &rc_port[i];
data86drivers/char/rtc.cvoid rtc_dropped_irq(unsigned long data);
data174drivers/char/rtc.cunsigned long data, flags;
data177drivers/char/rtc.cdata = rtc_irq_data;
data180drivers/char/rtc.cmemcpy_tofs(buf, &data, sizeof(unsigned long));
data578drivers/char/rtc.cvoid rtc_dropped_irq(unsigned long data)
data460drivers/char/scc.cbuffer->rw_ptr = buffer->data;
data515drivers/char/scc.cbptr->rw_ptr = bptr->data;
data536drivers/char/scc.cbptr->rw_ptr = bptr->data;
data696drivers/char/scc.cbptr->rw_ptr = bptr->data;
data865drivers/char/scc.cOutb(scc->data,*bp->rw_ptr);  /* send byte */
data883drivers/char/scc.cOutb(scc->data,*bp->rw_ptr);    
data896drivers/char/scc.cInb(scc->data);
data1003drivers/char/scc.cInb(scc->data);    /* discard char */
data1016drivers/char/scc.cInb(scc->data);
data1032drivers/char/scc.cInb(scc->data);
data1038drivers/char/scc.c*bp->rw_ptr = Inb(scc->data);
data1060drivers/char/scc.cscc->rx_t.data = (unsigned long) scc;
data1075drivers/char/scc.cInb(scc->data);        /* throw away Rx byte */
data1571drivers/char/scc.cscc->tx_t.data = (unsigned long) scc;
data1576drivers/char/scc.cscc->rx_t.data = (unsigned long) scc;
data1643drivers/char/scc.cbp->rw_ptr = bp->data;
data2161drivers/char/scc.cSCC_Info[2*Nchips  ].data = hwcfg.data_a;
data2163drivers/char/scc.cSCC_Info[2*Nchips+1].data = hwcfg.data_b;
data2180drivers/char/scc.cSCC_Info[2*Nchips+chan].data, 
data2194drivers/char/scc.crequest_region(SCC_Info[2*Nchips+chan].data, 1, "scc data");
data2611drivers/char/scc.cscc_tx_timer(scc->rx_t.data);
data2782drivers/char/scc.crelease_region(scc->data, 1);
data2781drivers/char/serial.cinfo->tqueue.data = info;
data2783drivers/char/serial.cinfo->tqueue_hangup.data = info;
data43drivers/char/softdog.cstatic void watchdog_fire(unsigned long data)
data78drivers/char/softdog.cstatic int softdog_write(struct inode *inode, struct file *file, const char *data, int len)
data2472drivers/char/stallion.cportp->tqueue.data = portp;
data792drivers/char/tga.cregister unsigned int fgmask, bgmask, data, rowbits;
data843drivers/char/tga.cdata = fontmask_bits[(rowbits>>4)&0xf];
data844drivers/char/tga.cdata = (data & fgmask) | (~data & bgmask);
data845drivers/char/tga.cwritel(data, dst);
data846drivers/char/tga.cdata = fontmask_bits[rowbits&0xf];
data847drivers/char/tga.cdata = (data & fgmask) | (~data & bgmask);
data848drivers/char/tga.cwritel(data, (dst+1));
data870drivers/char/tga.cdata = 1 << (TGA_F_WIDTH - 1);
data871drivers/char/tga.cfor (j = 0; j < TGA_F_WIDTH; j++, data >>= 1) {
data872drivers/char/tga.cif (rowbits & data)
data1710drivers/char/tty_io.ctty->flip.tqueue.data = tty;
data148drivers/isdn/icn/icn.hunsigned char data[ICN_FRAGSIZE];  /* The data                            */
data254drivers/isdn/icn/icn.h#define sbuf_d dev->shmem->data_buffers.send_buf[sbuf_n].data
data268drivers/isdn/icn/icn.h#define rbuf_d dev->shmem->data_buffers.receive_buf[rbuf_n].data
data1649drivers/isdn/isdn_common.cisdn_receive_callback(drvidx, chan, skb->data, skb->len);
data1703drivers/isdn/isdn_common.cwritebuf(drvidx,chan,skb->data,skb->len,0))==skb->len)
data777drivers/isdn/isdn_net.cu_char *buf = skb->data;
data939drivers/isdn/isdn_net.crawp = skb->data;
data982drivers/isdn/isdn_net.cskb->mac.raw = skb->data;
data984drivers/isdn/isdn_net.cisdn_dumppkt("R:", skb->data, skb->len, 40);
data1005drivers/isdn/isdn_net.cskb->protocol = *(unsigned short *)&(skb->data[0]);
data1007drivers/isdn/isdn_net.cif (*(unsigned short *)skb->data == 0xFFFF)
data1147drivers/isdn/isdn_net.cskb->data[0] = 0x0f;
data1148drivers/isdn/isdn_net.cskb->data[1] = 0x00;
data1149drivers/isdn/isdn_net.c*((ushort*)&skb->data[2]) = htons(type);
data566drivers/isdn/isdn_ppp.cif(skb->data[0] == 0xff && skb->data[1] == 0x03)
data575drivers/isdn/isdn_ppp.cif (skb->data[0] & 0x1) {
data576drivers/isdn/isdn_ppp.cproto = skb->data[0];
data579drivers/isdn/isdn_ppp.cproto = ((int) skb->data[0] << 8) + skb->data[1];
data585drivers/isdn/isdn_ppp.cu_char BEbyte = skb->data[0];
data588drivers/isdn/isdn_ppp.c(int) skb->len, (int) skb->data[0], (int) skb->data[1], (int) skb->data[2], 
data589drivers/isdn/isdn_ppp.c(int) skb->data[3], (int) skb->data[4], (int) skb->data[5]);
data592drivers/isdn/isdn_ppp.csqno = ((int) skb->data[1] << 16) + ((int) skb->data[2] << 8) + (int) skb->data[3];
data595drivers/isdn/isdn_ppp.csqno = (((int) skb->data[0] & 0xf) << 8) + (int) skb->data[1];
data720drivers/isdn/isdn_ppp.cif (skb->data[0] & 0x01) {  /* is it odd? */
data721drivers/isdn/isdn_ppp.cproto = (unsigned char) skb->data[0];
data724drivers/isdn/isdn_ppp.cproto = ((int) (unsigned char) skb->data[0] << 8) + (unsigned char) skb->data[1];
data736drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
data741drivers/isdn/isdn_ppp.cslhc_remember(ippp_table[net_dev->local.ppp_minor]->slcomp, skb->data, skb->len);
data745drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
data762drivers/isdn/isdn_ppp.cmemcpy(skb->data, skb_old->data, skb_old->len);
data763drivers/isdn/isdn_ppp.cskb->mac.raw = skb->data;
data765drivers/isdn/isdn_ppp.cskb->data, skb_old->len);
data778drivers/isdn/isdn_ppp.cskb->data[0] = 0xff;
data779drivers/isdn/isdn_ppp.cskb->data[1] = 0x03;
data780drivers/isdn/isdn_ppp.cskb->data[2] = (proto>>8);
data781drivers/isdn/isdn_ppp.cskb->data[3] = proto & 0xff;
data782drivers/isdn/isdn_ppp.cisdn_ppp_fill_rq(skb->data, skb->len, lp->ppp_minor);  /* push data to pppd device */
data811drivers/isdn/isdn_ppp.cif (*((unsigned long *)skb->data) != 0)
data824drivers/isdn/isdn_ppp.cu_char *buf = skb->data;
data838drivers/isdn/isdn_ppp.cif(buf != skb->data+len) { /* copied to new buffer ??? (btw: WHY must slhc copy it?? *sigh*)  */
data839drivers/isdn/isdn_ppp.cmemcpy(skb->data+len,buf,pktlen);
data841drivers/isdn/isdn_ppp.cif (skb->data[len] & SL_TYPE_COMPRESSED_TCP) {  /* cslip? style -> PPP */
data843drivers/isdn/isdn_ppp.cskb->data[len] ^= SL_TYPE_COMPRESSED_TCP;
data845drivers/isdn/isdn_ppp.cif (skb->data[len] >= SL_TYPE_UNCOMPRESSED_TCP)
data847drivers/isdn/isdn_ppp.cskb->data[len] = (skb->data[len] & 0x0f) | 0x40;
data865drivers/isdn/isdn_ppp.cskb->data[4] = MP_BEGIN_FRAG | MP_END_FRAG | (mp_seqno >> 8);  /* (B)egin & (E)ndbit .. */
data866drivers/isdn/isdn_ppp.cskb->data[5] = mp_seqno & 0xff;
data867drivers/isdn/isdn_ppp.cskb->data[6] = proto;  /* PID compression */
data870drivers/isdn/isdn_ppp.cskb->data[4] = MP_BEGIN_FRAG | MP_END_FRAG;  /* (B)egin & (E)ndbit .. */
data871drivers/isdn/isdn_ppp.cskb->data[5] = (mp_seqno >> 16) & 0xff;  /* sequence number: 24bit */
data872drivers/isdn/isdn_ppp.cskb->data[6] = (mp_seqno >> 8) & 0xff;
data873drivers/isdn/isdn_ppp.cskb->data[7] = (mp_seqno >> 0) & 0xff;
data874drivers/isdn/isdn_ppp.cskb->data[8] = proto;  /* PID compression */
data879drivers/isdn/isdn_ppp.cskb->data[0] = 0xff;        /* All Stations */
data880drivers/isdn/isdn_ppp.cskb->data[1] = 0x03;        /* Unnumbered information */
data881drivers/isdn/isdn_ppp.cskb->data[2] = proto >> 8;
data882drivers/isdn/isdn_ppp.cskb->data[3] = proto & 0xff;
data1079drivers/isdn/isdn_ppp.cmemcpy((*skb)->data + cnt, q->skb->data, q->skb->len);
data55drivers/isdn/pcbit/callbacks.ccbdata->data.setup.CalledPN);
data62drivers/isdn/pcbit/callbacks.cif ((len = capi_conn_req(cbdata->data.setup.CalledPN, &skb)) < 0)
data87drivers/isdn/pcbit/callbacks.cstruct callb_data *data) 
data133drivers/isdn/pcbit/callbacks.cstruct callb_data *data) 
data166drivers/isdn/pcbit/callbacks.cif (cbdata->data.setup.CalledPN) 
data168drivers/isdn/pcbit/callbacks.ccbdata->data.setup.CallingPN, 
data170drivers/isdn/pcbit/callbacks.ccbdata->data.setup.CalledPN);
data174drivers/isdn/pcbit/callbacks.ccbdata->data.setup.CallingPN,
data204drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data230drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data256drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data285drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data309drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data320drivers/isdn/pcbit/callbacks.cstruct callb_data *data)
data328drivers/isdn/pcbit/callbacks.cstruct callb_data *data) 
data350drivers/isdn/pcbit/callbacks.cstruct callb_data *data) 
data20drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data23drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data26drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data29drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data31drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data33drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data36drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data38drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data40drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data43drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data46drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data48drivers/isdn/pcbit/callbacks.hstruct callb_data *data);
data304drivers/isdn/pcbit/capi.c*((u16 *) (skb->data)) = chan->callref;
data305drivers/isdn/pcbit/capi.cskb->data[2] = chan->layer2link;
data306drivers/isdn/pcbit/capi.c*((u16 *) (skb->data + 3)) = data_len;
data309drivers/isdn/pcbit/capi.c*((u32 *) (skb->data + 5)) = chan->s_refnum;
data311drivers/isdn/pcbit/capi.cskb->data[9] = 0;                           /* HDLC frame number */
data389drivers/isdn/pcbit/capi.cchan->callref = *((ushort*) skb->data);
data403drivers/isdn/pcbit/capi.cCIlen = skb->data[0];
data407drivers/isdn/pcbit/capi.cif ( ((skb->data[1]) & 0xFC) == 0x48 )
data409drivers/isdn/pcbit/capi.cprintk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03); 
data419drivers/isdn/pcbit/capi.clen = skb->data[0];
data425drivers/isdn/pcbit/capi.cprintk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
data427drivers/isdn/pcbit/capi.cif ((skb->data[1] & 0x80) == 0)
data430drivers/isdn/pcbit/capi.cif (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
data433drivers/isdn/pcbit/capi.cmemcpy(info->data.setup.CallingPN, skb->data + count + 1, 
data435drivers/isdn/pcbit/capi.cinfo->data.setup.CallingPN[len - count] = 0;
data439drivers/isdn/pcbit/capi.cinfo->data.setup.CallingPN = NULL;
data446drivers/isdn/pcbit/capi.cskb_pull(skb, skb->data[0] + 1);
data450drivers/isdn/pcbit/capi.clen = skb->data[0];
data455drivers/isdn/pcbit/capi.cif ((skb->data[1] & 0x80) == 0)
data458drivers/isdn/pcbit/capi.cif (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
data461drivers/isdn/pcbit/capi.cmemcpy(info->data.setup.CalledPN, skb->data + count + 1, 
data463drivers/isdn/pcbit/capi.cinfo->data.setup.CalledPN[len - count] = 0;
data467drivers/isdn/pcbit/capi.cinfo->data.setup.CalledPN = NULL;
data474drivers/isdn/pcbit/capi.cskb_pull(skb, skb->data[0] + 1);
data477drivers/isdn/pcbit/capi.cskb_pull(skb, skb->data[0] + 1);
data480drivers/isdn/pcbit/capi.cskb_pull(skb, skb->data[0] + 1);
data483drivers/isdn/pcbit/capi.cskb_pull(skb, skb->data[0] + 1);
data497drivers/isdn/pcbit/capi.cchan->callref = *((ushort *) skb->data);     /* Update CallReference */
data500drivers/isdn/pcbit/capi.cerrcode = *((ushort *) skb->data);   /* read errcode */
data503drivers/isdn/pcbit/capi.c*complete = *(skb->data);
data516drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data519drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data522drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data535drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data539drivers/isdn/pcbit/capi.clen=*(skb->data);
data543drivers/isdn/pcbit/capi.cmemcpy(str, skb->data + 2, len - 1);
data554drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data557drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data560drivers/isdn/pcbit/capi.cskb_pull(skb, *(skb->data) + 1);
data569drivers/isdn/pcbit/capi.cerrcode = *((ushort*) skb->data);
data583drivers/isdn/pcbit/capi.cchan->layer2link = *(skb->data);
data586drivers/isdn/pcbit/capi.cerrcode = *((ushort*) skb->data);
data596drivers/isdn/pcbit/capi.cif (chan->layer2link != *(skb->data) )
data601drivers/isdn/pcbit/capi.cerrcode = *((ushort*) skb->data);
data615drivers/isdn/pcbit/capi.clen = *(skb->data);
data622drivers/isdn/pcbit/capi.c*(skb->data + i));
data634drivers/isdn/pcbit/capi.cerrcode = *((ushort*) skb->data);
data73drivers/isdn/pcbit/capi.hcallref = *((ushort*) skb->data);
data66drivers/isdn/pcbit/drv.cextern void pcbit_deliver(void * data);
data115drivers/isdn/pcbit/drv.cdev->qdelivery.data = dev;
data240drivers/isdn/pcbit/drv.cinfo.data.setup.CalledPN = (char *) &ctl->num;
data241drivers/isdn/pcbit/drv.ccp = strchr(info.data.setup.CalledPN, ',');
data304drivers/isdn/pcbit/drv.cstatic void pcbit_block_timer(unsigned long data)
data310drivers/isdn/pcbit/drv.cchan = (struct pcbit_chan *) data;
data369drivers/isdn/pcbit/drv.cchan->block_timer.data = (long) chan;
data517drivers/isdn/pcbit/drv.cchan->r_refnum = skb->data[7];
data535drivers/isdn/pcbit/drv.cif ( (*((ushort *) (skb->data + 2) )) != 0) {
data568drivers/isdn/pcbit/drv.cif ((len = capi_disc_req(*(ushort*)(skb->data), &skb2, CAUSE_NOCHAN)) > 0)
data573drivers/isdn/pcbit/drv.ccbdata.data.setup.CalledPN = NULL;
data574drivers/isdn/pcbit/drv.ccbdata.data.setup.CallingPN = NULL;
data581drivers/isdn/pcbit/drv.cif (pcbit_check_msn(dev, cbdata.data.setup.CallingPN)) 
data586drivers/isdn/pcbit/drv.cif (cbdata.data.setup.CalledPN)
data587drivers/isdn/pcbit/drv.ckfree(cbdata.data.setup.CalledPN);
data588drivers/isdn/pcbit/drv.cif (cbdata.data.setup.CallingPN)
data589drivers/isdn/pcbit/drv.ckfree(cbdata.data.setup.CallingPN);
data730drivers/isdn/pcbit/drv.ccapi_decode_debug_188(skb->data, skb->len);
data868drivers/isdn/pcbit/drv.cdev->set_running_timer.data = (ulong) dev;
data260drivers/isdn/pcbit/edss1.cstatic void pcbit_fsm_timer(unsigned long data)
data265drivers/isdn/pcbit/edss1.cchan = (struct pcbit_chan *) data;
data282drivers/isdn/pcbit/edss1.cunsigned short event, struct callb_data *data)
data319drivers/isdn/pcbit/edss1.cchan->fsm_timer.data = (ulong) chan;
data327drivers/isdn/pcbit/edss1.caction->callb(dev, chan, data);
data80drivers/isdn/pcbit/edss1.h} data;
data86drivers/isdn/pcbit/layer2.cvoid pcbit_deliver(void * data);
data94drivers/isdn/pcbit/layer2.cstatic void pcbit_l2_err_recover(unsigned long data);
data286drivers/isdn/pcbit/layer2.cmemcpy_topcbit(dev, frame->skb->data + frame->copied, 
data327drivers/isdn/pcbit/layer2.cvoid pcbit_deliver(void * data)
data332drivers/isdn/pcbit/layer2.cstruct pcbit_dev *dev = (struct pcbit_dev *) data;
data348drivers/isdn/pcbit/layer2.cmsg.cmd = frame->skb->data[2];
data349drivers/isdn/pcbit/layer2.cmsg.scmd = frame->skb->data[3];
data351drivers/isdn/pcbit/layer2.cframe->refnum = *((ushort*) frame->skb->data + 4);
data678drivers/isdn/pcbit/layer2.cstatic void pcbit_l2_err_recover(unsigned long data) 
data684drivers/isdn/pcbit/layer2.cdev = (struct pcbit_dev *) data;
data752drivers/isdn/pcbit/layer2.cdev->error_recover_timer.data = (ulong) dev;
data201drivers/isdn/pcbit/layer2.hstatic __inline__ void memcpy_topcbit(struct pcbit_dev * dev, u_char * data, 
data210drivers/isdn/pcbit/layer2.hmemcpy_toio(dev->writeptr, data, len - diff);
data211drivers/isdn/pcbit/layer2.hmemcpy_toio(dev->sh_mem, data + (len - diff), diff);
data216drivers/isdn/pcbit/layer2.hmemcpy_toio(dev->writeptr, data, len);
data259drivers/isdn/pcbit/layer2.hstatic __inline__ void memcpy_frompcbit(struct pcbit_dev * dev, u_char * data, int len)
data266drivers/isdn/pcbit/layer2.hmemcpy_fromio(data, dev->readptr, len - diff);
data267drivers/isdn/pcbit/layer2.hmemcpy_fromio(data + (len - diff), dev->sh_mem + BANK2 , diff);
data272drivers/isdn/pcbit/layer2.hmemcpy_fromio(data, dev->readptr, len);
data92drivers/isdn/teles/card.cwritehscx_0(byte * base, byte hscx, byte offset, byte data)
data95drivers/isdn/teles/card.c((hscx & 1) ? 0x40 : 0) + offset) = data;
data99drivers/isdn/teles/card.cwritehscx_3(int iobase, byte hscx, byte offset, byte data)
data101drivers/isdn/teles/card.cbyteout(iobase - (hscx ? 0x820 : 0xc20) + offset, data);
data214drivers/isdn/teles/card.cwritehscxCMDR_0(byte * base, byte hscx, byte data)
data221drivers/isdn/teles/card.cwritehscx_0(base, hscx, HSCX_CMDR, data);
data226drivers/isdn/teles/card.cwritehscxCMDR_3(int iobase, byte hscx, byte data)
data233drivers/isdn/teles/card.cwritehscx_3(iobase, hscx, HSCX_CMDR, data);
data237drivers/isdn/teles/card.c#define WRITEHSCX_CMDR(mbase,ibase,hscx,data) \
data238drivers/isdn/teles/card.c((mbase)?writehscxCMDR_0(mbase,hscx,data):writehscxCMDR_3(ibase,hscx,data))
data1455drivers/isdn/teles/card.chsp->tqueue.data = hsp;
data1499drivers/isdn/teles/card.csp->tqueue.data = sp;
data84drivers/isdn/teles/fsm.cft->tl.data = (long) ft;
data490drivers/isdn/teles/isdnl2.cbyte           *data;
data492drivers/isdn/teles/isdnl2.cdata = DATAPTR(ibh);
data493drivers/isdn/teles/isdnl2.cdata += l2addrsize(&(st->l2));
data495drivers/isdn/teles/isdnl2.cf = *data & 0x10;
data521drivers/isdn/teles/isdnl2.cbyte           *data;
data523drivers/isdn/teles/isdnl2.cdata = DATAPTR(ibh);
data524drivers/isdn/teles/isdnl2.cdata += l2addrsize(&st->l2);
data526drivers/isdn/teles/isdnl2.cf = *data & 0x10;
data1179drivers/isdn/teles/isdnl2.cIsUI(byte * data, int ext)
data1181drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xef) == 0x3);
data1185drivers/isdn/teles/isdnl2.cIsUA(byte * data, int ext)
data1187drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xef) == 0x63);
data1191drivers/isdn/teles/isdnl2.cIsDISC(byte * data, int ext)
data1193drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xef) == 0x43);
data1197drivers/isdn/teles/isdnl2.cIsRR(byte * data, int ext)
data1200drivers/isdn/teles/isdnl2.creturn (data[0] == 0x1);
data1202drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xf) == 1);
data1206drivers/isdn/teles/isdnl2.cIsI(byte * data, int ext)
data1208drivers/isdn/teles/isdnl2.creturn ((data[0] & 0x1) == 0x0);
data1212drivers/isdn/teles/isdnl2.cIsSABMX(byte * data, int ext)
data1214drivers/isdn/teles/isdnl2.creturn (ext ? data[0] == 0x7f : data[0] == 0x3f);
data1218drivers/isdn/teles/isdnl2.cIsREJ(byte * data, int ext)
data1220drivers/isdn/teles/isdnl2.creturn (ext ? data[0] == 0x9 : (data[0] & 0xf) == 0x9);
data1224drivers/isdn/teles/isdnl2.cIsFRMR(byte * data, int ext)
data1226drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xef) == 0x87);
data1230drivers/isdn/teles/isdnl2.cIsRNR(byte * data, int ext)
data1233drivers/isdn/teles/isdnl2.creturn (data[0] == 0x5);
data1235drivers/isdn/teles/isdnl2.creturn ((data[0] & 0xf) == 5);
data51drivers/isdn/teles/tei.cunsigned int    data;
data58drivers/isdn/teles/tei.cdata = (unsigned int) ibh;
data65drivers/isdn/teles/tei.cbp[1] = data >> 8;
data66drivers/isdn/teles/tei.cbp[2] = data & 0xff;
data433drivers/net/3c501.cunsigned char *buf = skb->data;
data560drivers/net/3c503.cmemcpy_fromio(skb->data, dev->mem_start + ring_offset, semi_count);
data562drivers/net/3c503.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
data590drivers/net/3c503.cbuf =  (unsigned short int *) skb->data;
data477drivers/net/3c505.cif (send_pcb_fast(dev->base_addr, pcb->data.raw[i]))
data566drivers/net/3c505.cpcb->data.raw[i++] = inb_command(dev->base_addr);
data576drivers/net/3c505.ctotal_length = pcb->data.raw[--i];
data618drivers/net/3c505.ctx_pcb->data.rcv_pkt.buf_seg
data619drivers/net/3c505.c= tx_pcb->data.rcv_pkt.buf_ofs = 0;    /* Unused */
data620drivers/net/3c505.ctx_pcb->data.rcv_pkt.buf_len = 1600;
data621drivers/net/3c505.ctx_pcb->data.rcv_pkt.timeout = 0;  /* set timeout to zero */
data782drivers/net/3c505.clen = adapter->irx_pcb.data.rcv_resp.pkt_len;
data783drivers/net/3c505.cdlen = adapter->irx_pcb.data.rcv_resp.buf_len;
data784drivers/net/3c505.cif (adapter->irx_pcb.data.rcv_resp.timeout != 0) {
data823drivers/net/3c505.cadapter->irx_pcb.data.failed ? "failed" : "succeeded");
data833drivers/net/3c505.cadapter->irx_pcb.data.failed ? "failed" : "succeeded");
data843drivers/net/3c505.cadapter->irx_pcb.data.failed ? "failed" : "succeeded");
data851drivers/net/3c505.cadapter->stats.rx_packets += adapter->irx_pcb.data.netstat.tot_recv;
data852drivers/net/3c505.cadapter->stats.tx_packets += adapter->irx_pcb.data.netstat.tot_xmit;
data853drivers/net/3c505.cadapter->stats.rx_crc_errors += adapter->irx_pcb.data.netstat.err_CRC;
data854drivers/net/3c505.cadapter->stats.rx_frame_errors += adapter->irx_pcb.data.netstat.err_align;
data855drivers/net/3c505.cadapter->stats.rx_fifo_errors += adapter->irx_pcb.data.netstat.err_ovrrun;
data856drivers/net/3c505.cadapter->stats.rx_over_errors += adapter->irx_pcb.data.netstat.err_res;
data870drivers/net/3c505.cswitch (adapter->irx_pcb.data.xmit_resp.c_stat) {
data999drivers/net/3c505.cadapter->tx_pcb.data.memconf.cmd_q = 10;
data1000drivers/net/3c505.cadapter->tx_pcb.data.memconf.rcv_q = 20;
data1001drivers/net/3c505.cadapter->tx_pcb.data.memconf.mcast = 10;
data1002drivers/net/3c505.cadapter->tx_pcb.data.memconf.frame = 20;
data1003drivers/net/3c505.cadapter->tx_pcb.data.memconf.rcv_b = 20;
data1004drivers/net/3c505.cadapter->tx_pcb.data.memconf.progs = 0;
data1023drivers/net/3c505.cadapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
data1080drivers/net/3c505.cadapter->tx_pcb.data.xmit_pkt.buf_ofs
data1081drivers/net/3c505.c= adapter->tx_pcb.data.xmit_pkt.buf_seg = 0;  /* Unused */
data1082drivers/net/3c505.cadapter->tx_pcb.data.xmit_pkt.pkt_len = nlen;
data1095drivers/net/3c505.ctarget = virt_to_bus(skb->data);
data1097drivers/net/3c505.cmemcpy(adapter->dma_buffer, skb->data, nlen);
data1306drivers/net/3c505.cmemcpy(adapter->tx_pcb.data.multicast[i], dmi->dmi_addr, 6);
data1320drivers/net/3c505.cadapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD | RECV_MULTI;
data1322drivers/net/3c505.cadapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_BROAD;
data1324drivers/net/3c505.cadapter->tx_pcb.data.configure = NO_LOOPBACK | RECV_PROMISC;
data1629drivers/net/3c505.cdev->dev_addr[i] = adapter->rx_pcb.data.eth_addr[i];
data1655drivers/net/3c505.cprintk("rev %d.%d, %dk\n", adapter->rx_pcb.data.info.major_vers, adapter->rx_pcb.data.info.minor_vers, adapter->rx_pcb.data.info.RAM_sz);
data1662drivers/net/3c505.cadapter->tx_pcb.data.memconf.cmd_q = 8;
data1663drivers/net/3c505.cadapter->tx_pcb.data.memconf.rcv_q = 8;
data1664drivers/net/3c505.cadapter->tx_pcb.data.memconf.mcast = 10;
data1665drivers/net/3c505.cadapter->tx_pcb.data.memconf.frame = 10;
data1666drivers/net/3c505.cadapter->tx_pcb.data.memconf.rcv_b = 10;
data1667drivers/net/3c505.cadapter->tx_pcb.data.memconf.progs = 0;
data1674drivers/net/3c505.cif (adapter->rx_pcb.data.configure) {
data235drivers/net/3c505.h} data;
data496drivers/net/3c507.cunsigned char *buf = skb->data;
data486drivers/net/3c509.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
data620drivers/net/3c59x.cvp->timer.data = (unsigned long)dev;
data627drivers/net/3c59x.cstatic void vortex_timer(unsigned long data)
data629drivers/net/3c59x.cstruct device *dev = (struct device *)data;
data683drivers/net/3c59x.coutl((int)(skb->data), ioaddr + Wn7_MasterAddr);
data689drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
data699drivers/net/3c59x.coutsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
data228drivers/net/8390.cei_block_output(dev, length, skb->data, output_page);
data242drivers/net/8390.cei_block_output(dev, length, skb->data, ei_local->tx_start_page);
data123drivers/net/a2065.cstatic void a2065_interrupt(int irq, struct pt_regs *fp, void *data);
data332drivers/net/a2065.cstatic void a2065_interrupt(int irq, struct pt_regs *fp, void *data)
data334drivers/net/a2065.cstruct device *dev = (struct device *)data;
data576drivers/net/a2065.cprintk("TX pkt type 0x%04x from ", ((u_short *)skb->data)[6]);
data579drivers/net/a2065.cu_char *ptr = &((u_char *)skb->data)[6];
data586drivers/net/a2065.cu_char *ptr = (u_char *)skb->data;
data590drivers/net/a2065.cprintk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
data597drivers/net/a2065.cmemcpy(priv->tx_buff[entry], skb->data, skb->len);
data714drivers/net/a2065.c((u_short *)skb->data)[6]);
data717drivers/net/a2065.cu_char *ptr = &((u_char *)skb->data)[6];
data724drivers/net/a2065.cu_char *ptr = (u_char *)skb->data;
data729drivers/net/a2065.c(int)skb->data, (int)skb->len);
data277drivers/net/ac3200.cmemcpy_fromio(skb->data, xfer_start, semi_count);
data279drivers/net/ac3200.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
data101drivers/net/apricot.cchar *data;
data118drivers/net/apricot.cchar data[1532];
data334drivers/net/apricot.cif (i596_debug >2) print_eth(lp->scb.rfd->data);
data352drivers/net/apricot.cmemcpy(skb_put(skb,pkt_len), lp->scb.rfd->data, pkt_len);
data358drivers/net/apricot.cif (i596_debug > 4) print_eth(skb->data);
data406drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
data646drivers/net/apricot.ctx_cmd->tbd->data = skb->data;
data648drivers/net/apricot.cif (i596_debug > 3) print_eth(skb->data);
data804drivers/net/apricot.cstruct sk_buff *skb = ((struct sk_buff *)(tx_cmd->tbd->data)) -1;
data810drivers/net/apricot.cif (i596_debug >2) print_eth(skb->data);
data542drivers/net/arcnet.cu_char *data;      /* pointer to data in packet */
data617drivers/net/arcnet.cchar *data,int length,int daddr,int exceptA);
data688drivers/net/arcnet.cprintk("%02X ",((u_char *)skb->data)[i]);
data1600drivers/net/arcnet.cout->hdr=(struct ClientData*)skb->data;
data1620drivers/net/arcnet.c((char *)skb->data)+sizeof(struct ClientData),
data1639drivers/net/arcnet.cout->data=(u_char *)skb->data
data1727drivers/net/arcnet.cout->data,out->seglen,out->hdr->daddr,1);
data1730drivers/net/arcnet.cout->data+=out->seglen;
data1740drivers/net/arcnet.cchar *data,int length,int daddr,int exceptA)
data1757drivers/net/arcnet.chdr,length,data);
data1816drivers/net/arcnet.cfor (iptr=data,iend=iptr+length-hdrlen,optr=(char *)arcsoft+hdrlen;
data1824drivers/net/arcnet.cdata,length-hdrlen);
data2316drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
data2447drivers/net/arcnet.csoft=(struct ClientData *)skb->data;
data2498drivers/net/arcnet.csoft=(struct ClientData *)in->skb->data;
data2503drivers/net/arcnet.cmemcpy(skb->data+skb->len,
data2706drivers/net/arcnet.cskb->mac.raw=skb->data;
data2813drivers/net/arcnet.cif (((struct ethhdr*)(skb->data))->h_dest[0] == 0xFF)
data2817drivers/net/arcnet.c((struct ethhdr*)(skb->data))->h_dest[5];
data2845drivers/net/arcnet.cmemcpy(arcsoft,skb->data,skb->len);
data2897drivers/net/arcnet.cmemcpy(skb->data,(u_char *)arcsoft+1,length-1);
data2946drivers/net/arcnet.cstruct S_ClientData *hdr=(struct S_ClientData *)skb->data;
data2967drivers/net/arcnet.cskb->data+S_EXTRA_CLIENTDATA,
data2969drivers/net/arcnet.cskb->data+sizeof(struct S_ClientData),
data3030drivers/net/arcnet.csoft=(struct S_ClientData *)skb->data;
data3155drivers/net/arcnet.cskb->mac.raw=skb->data;
data129drivers/net/ariadne.cstatic void ariadne_interrupt(int irq, struct pt_regs *fp, void *data);
data380drivers/net/ariadne.cstatic void ariadne_interrupt(int irq, struct pt_regs *fp, void *data)
data382drivers/net/ariadne.cstruct device *dev = (struct device *)data;
data615drivers/net/ariadne.cprintk("TX pkt type 0x%04x from ", ((u_short *)skb->data)[6]);
data618drivers/net/ariadne.cu_char *ptr = &((u_char *)skb->data)[6];
data625drivers/net/ariadne.cu_char *ptr = (u_char *)skb->data;
data629drivers/net/ariadne.cprintk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
data639drivers/net/ariadne.cmemcpyw(priv->tx_buff[entry], (u_short *)skb->data, skb->len);
data748drivers/net/ariadne.cprintk("RX pkt type 0x%04x from ", ((u_short *)skb->data)[6]);
data751drivers/net/ariadne.cu_char *ptr = &((u_char *)skb->data)[6];
data758drivers/net/ariadne.cu_char *ptr = (u_char *)skb->data;
data762drivers/net/ariadne.cprintk(" data 0x%08x len %d\n", (int)skb->data, (int)skb->len);
data409drivers/net/at1700.cunsigned char *buf = skb->data;
data191drivers/net/atarilance.c/* base+0x0 */  volatile unsigned short  data;
data234drivers/net/atarilance.c#define  DREG  IO->data
data792drivers/net/atarilance.c((u_short *)skb->data)[6]);
data793drivers/net/atarilance.cfor( p = &((u_char *)skb->data)[6], i = 0; i < 6; i++ )
data796drivers/net/atarilance.cfor( p = (u_char *)skb->data, i = 0; i < 6; i++ )
data798drivers/net/atarilance.cprintk(" data at 0x%08x len %d\n", (int)skb->data,
data823drivers/net/atarilance.clp->memcpy_f( PKTBUF_ADDR(head), (void *)skb->data, skb->len );
data1012drivers/net/atarilance.cu_char *data = PKTBUF_ADDR(head), *p;
data1014drivers/net/atarilance.c((u_short *)data)[6]);
data1015drivers/net/atarilance.cfor( p = &data[6], i = 0; i < 6; i++ )
data1018drivers/net/atarilance.cfor( p = data, i = 0; i < 6; i++ )
data1022drivers/net/atarilance.cdata[15], data[16], data[17], data[18],
data1023drivers/net/atarilance.cdata[19], data[20], data[21], data[22],
data1030drivers/net/atarilance.clp->memcpy_f( skb->data, PKTBUF_ADDR(head), pkt_len );
data451drivers/net/atp.cunsigned char *buf = skb->data;
data686drivers/net/atp.cunsigned char *data = skb->data;
data689drivers/net/atp.cdata[0], data[1], data[2], data[3], data[4], data[5],
data690drivers/net/atp.cdata[6], data[7], data[8], data[9], data[10], data[11],
data691drivers/net/atp.cdata[12], data[13]);
data620drivers/net/de4x5.cstatic void    mii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr);
data622drivers/net/de4x5.cstatic void    mii_wdata(int data, int len, u_long ioaddr);
data624drivers/net/de4x5.cstatic int     mii_swap(int data, int len);
data626drivers/net/de4x5.cstatic void    sendto_mii(u32 command, int data, u_long ioaddr);
data641drivers/net/de4x5.cstatic void    timeout(struct device *dev, void (*fn)(u_long data), u_long data, u_long msec);
data1114drivers/net/de4x5.cload_packet(dev, skb->data, 
data1259drivers/net/de4x5.cbuf = skb->data;              /* Look at the dest addr */
data2638drivers/net/de4x5.ctmp = virt_to_bus(p->data);
data3268drivers/net/de4x5.cmii_wr(int data, u_char phyreg, u_char phyaddr, u_long ioaddr)
data3276drivers/net/de4x5.cdata = mii_swap(data, 16);             /* Swap data bit ordering         */
data3277drivers/net/de4x5.cmii_wdata(data, 16, ioaddr);           /* Write data                     */
data3297drivers/net/de4x5.cmii_wdata(int data, int len, u_long ioaddr)
data3302drivers/net/de4x5.csendto_mii(MII_MWR | MII_WR, data, ioaddr);
data3303drivers/net/de4x5.cdata >>= 1;
data3337drivers/net/de4x5.cmii_swap(int data, int len)
data3343drivers/net/de4x5.ctmp |= (data & 1);
data3344drivers/net/de4x5.cdata >>= 1;
data3351drivers/net/de4x5.csendto_mii(u32 command, int data, u_long ioaddr)
data3355drivers/net/de4x5.cj = (data & 1) << 17;
data3572drivers/net/de4x5.ctimeout(struct device *dev, void (*fn)(u_long data), u_long data, u_long msec)
data3587drivers/net/de4x5.clp->timer.data = data;
data3734drivers/net/de4x5.c(u_char)skb->data[0],
data3735drivers/net/de4x5.c(u_char)skb->data[1],
data3736drivers/net/de4x5.c(u_char)skb->data[2],
data3737drivers/net/de4x5.c(u_char)skb->data[3],
data3738drivers/net/de4x5.c(u_char)skb->data[4],
data3739drivers/net/de4x5.c(u_char)skb->data[5],
data3740drivers/net/de4x5.c(u_char)skb->data[6],
data3741drivers/net/de4x5.c(u_char)skb->data[7],
data3742drivers/net/de4x5.c(u_char)skb->data[8],
data3743drivers/net/de4x5.c(u_char)skb->data[9],
data3744drivers/net/de4x5.c(u_char)skb->data[10],
data3745drivers/net/de4x5.c(u_char)skb->data[11],
data3746drivers/net/de4x5.c(u_char)skb->data[12],
data3747drivers/net/de4x5.c(u_char)skb->data[13],
data3753drivers/net/de4x5.cprintk("%02x ",(u_char)skb->data[i+j]);
data3784drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
data3790drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data3794drivers/net/de4x5.cstatus = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN);
data3801drivers/net/de4x5.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN);
data3841drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, ioc->data, ioc->len);
data3843drivers/net/de4x5.cmemcpy_tofs(ioc->data, lp->setup_frame, ioc->len); 
data3851drivers/net/de4x5.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN * ioc->len))) {
data3852drivers/net/de4x5.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
data3884drivers/net/de4x5.cstatus = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len);
data3889drivers/net/de4x5.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
data3905drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, 1))) {
data3906drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, 1);
data3912drivers/net/de4x5.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, 1))) {
data3913drivers/net/de4x5.cmemcpy_fromfs(tmp.addr, ioc->data, 1);
data3932drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
data3933drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data4023drivers/net/de4x5.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
data4024drivers/net/de4x5.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data804drivers/net/de4x5.hunsigned char  *data;              /* Pointer to the data buffer */
data279drivers/net/de600.c#define de600_put_byte(data) ( \
data280drivers/net/de600.coutb_p(((data) << 4)   | WRITE_DATA            , DATA_PORT), \
data281drivers/net/de600.coutb_p(((data) & 0xf0) | WRITE_DATA | HI_NIBBLE, DATA_PORT))
data402drivers/net/de600.cbyte  *buffer = skb->data;
data343drivers/net/de620.cde620_read_block(struct device *dev, byte *data, int count)
data360drivers/net/de620.c*data++ = de620_read_byte(dev);
data371drivers/net/de620.c*data++ = value | inb(STATUS_PORT) >> 4; /* Low nibble */
data516drivers/net/de620.cbyte *buffer = skb->data;
data923drivers/net/de620.c#define sendit(dev,data) de620_set_register(dev, W_EIP, data | EIPRegister);
data928drivers/net/de620.cunsigned short data;
data953drivers/net/de620.cfor (data = 0, nbits = 16; nbits > 0; --nbits) {
data958drivers/net/de620.cdata = (data << 1) | ((de620_get_register(dev, R_STS) & EEDI) >> 7);
data965drivers/net/de620.creturn data;
data1461drivers/net/depca.cs8 data;
data1465drivers/net/depca.cdata = inb(DEPCA_PROM);                /* clear counter on DEPCA */
data1466drivers/net/depca.cdata = inb(DEPCA_PROM);                /* read data */
data1468drivers/net/depca.cif (data == 0x08) {                    /* Enable counter on DEPCA */
data1479drivers/net/depca.cdata = inb(DEPCA_PROM);
data1480drivers/net/depca.cif (dev.Sig[j] == data) {    /* track signature */
data1483drivers/net/depca.cif (data == dev.Sig[0]) {  /* rare case.... */
data1548drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, len);
data1549drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
data1551drivers/net/depca.cmemcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
data1719drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
data1720drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data1726drivers/net/depca.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN))) {
data1727drivers/net/depca.cmemcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
data1788drivers/net/depca.cif (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1789drivers/net/depca.cmemcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
data1795drivers/net/depca.cif (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
data1796drivers/net/depca.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
data1823drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1824drivers/net/depca.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
data1846drivers/net/depca.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1847drivers/net/depca.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data165drivers/net/depca.hunsigned char  *data;              /* Pointer to the data buffer */
data584drivers/net/dgrs.cmemcpy( (char *) S2H(rbdp->buf) + count, skb->data + i, amt);
data703drivers/net/dgrs.crc = verify_area(VERIFY_WRITE, (void *) ioc.data, ioc.len);
data705drivers/net/dgrs.cmemcpy_tofs(ioc.data, &dev->mem_start, ioc.len);
data708drivers/net/dgrs.crc = verify_area(VERIFY_READ, (void *) ioc.data, ioc.len);
data734drivers/net/dgrs.cioc.data, ioc.len);
data29drivers/net/dgrs.hunsigned char  *data;  /* Pointer to the data buffer */
data584drivers/net/dgrs_driver.cmemcpy( (char *) S2H(rbdp->buf) + count, skb->data + i, amt);
data703drivers/net/dgrs_driver.crc = verify_area(VERIFY_WRITE, (void *) ioc.data, ioc.len);
data705drivers/net/dgrs_driver.cmemcpy_tofs(ioc.data, &dev->mem_start, ioc.len);
data708drivers/net/dgrs_driver.crc = verify_area(VERIFY_READ, (void *) ioc.data, ioc.len);
data734drivers/net/dgrs_driver.cioc.data, ioc.len);
data79drivers/net/dgrs_i82596.huchar      data[1];
data135drivers/net/dgrs_i82596.huchar    data[1];
data165drivers/net/dlci.chdr = (struct frhdr *) skb->data;
data221drivers/net/dlci.cskb->mac.raw = skb->data; 
data701drivers/net/eepro.cunsigned char *buf = skb->data;
data459drivers/net/eexpress.cunsigned short *data = (unsigned short *)buf->data;
data462drivers/net/eexpress.ceexp_hw_tx(dev,data,length);
data243drivers/net/eql.ceql->timer.data       = (unsigned long) dev->priv;
data742drivers/net/eth16i.cint data = 0;
data746drivers/net/eth16i.cdata = eth16i_read_eeprom_word(ioaddr);
data749drivers/net/eth16i.creturn(data);  
data755drivers/net/eth16i.cint data = 0;
data762drivers/net/eth16i.cdata = (data << 1) | ((inb(ioaddr + EEPROM_DATA_REG) & DI_1) ? 1 : 0);
data766drivers/net/eth16i.creturn(data);
data933drivers/net/eth16i.cunsigned char *buf = skb->data;
data1059drivers/net/eth16i.cprintk(" %02x", skb->data[i]);
data1172drivers/net/eth16i.cunsigned char data;
data1174drivers/net/eth16i.cdata = inb(ioaddr + CONFIG_REG_1);
data1175drivers/net/eth16i.coutb( ((data & 0xF3) | ( (banknbr & 0x03) << 2)), ioaddr + CONFIG_REG_1); 
data312drivers/net/ewrk3.cstatic int    Write_EEPROM(short data, u_long iobase, u_char eaddr);
data809drivers/net/ewrk3.cu_char *p = skb->data;
data830drivers/net/ewrk3.cmemcpy_toio(buf, skb->data, PRELOAD);/* Write PRELOAD bytes*/
data832drivers/net/ewrk3.cmemcpy_toio(buf+PRELOAD, skb->data+PRELOAD, skb->len-PRELOAD);
data839drivers/net/ewrk3.cmemcpy_toio((char *)buf, skb->data, skb->len);/* Write data bytes */
data1035drivers/net/ewrk3.cp = skb->data;                  /* Look at the dest addr */
data1497drivers/net/ewrk3.cstatic int Write_EEPROM(short data, u_long iobase, u_char eaddr)
data1503drivers/net/ewrk3.coutw(data, EWRK3_EPROM1);             /* write data to register */
data1563drivers/net/ewrk3.cchar data;
data1571drivers/net/ewrk3.cdata = inb(EWRK3_APROM);
data1572drivers/net/ewrk3.cif (dev.Sig[j] == data) {   /* track signature */
data1575drivers/net/ewrk3.cif (data == dev.Sig[0]) {
data1691drivers/net/ewrk3.cif (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
data1692drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data1698drivers/net/ewrk3.cif (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN))) {
data1703drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
data1743drivers/net/ewrk3.cif (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1756drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len); 
data1763drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
data1764drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
data1794drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1795drivers/net/ewrk3.cmemcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
data1813drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1814drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data1820drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_READ, ioc->data, 1))) {
data1821drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, 1);
data1840drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1841drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data1850drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_READ, ioc->data, EEPROM_MAX))) {
data1851drivers/net/ewrk3.cmemcpy_fromfs(tmp.addr, ioc->data, EEPROM_MAX);
data1864drivers/net/ewrk3.cif (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
data1865drivers/net/ewrk3.cmemcpy_tofs(ioc->data, tmp.addr, ioc->len);
data299drivers/net/ewrk3.hunsigned char  *data;              /* Pointer to the data buffer */
data362drivers/net/fmv18x.cunsigned char *buf = skb->data;
data521drivers/net/fmv18x.cprintk(" %02x", skb->data[i]);
data343drivers/net/hp-plus.cchar *buf = skb->data;
data380drivers/net/hp-plus.cmemcpy_fromio(skb->data, dev->mem_start, count);
data281drivers/net/hp.cchar *buf = skb->data;
data668drivers/net/hp100.cmemcpy( lp -> mem_ptr_virt, skb -> data, skb -> len );
data674drivers/net/hp100.cmemcpy_toio( lp -> mem_ptr_phys, skb -> data, skb -> len );
data681drivers/net/hp100.coutsl( ioaddr + HP100_REG_DATA32, skb -> data, ( skb -> len + 3 ) >> 2 );
data346drivers/net/hp100.h#define hp100_outb( data, reg ) \
data347drivers/net/hp100.houtb( data, ioaddr + HP100_REG_##reg )
data348drivers/net/hp100.h#define hp100_outw( data, reg ) \
data349drivers/net/hp100.houtw( data, ioaddr + HP100_REG_##reg )
data350drivers/net/hp100.h#define hp100_outl( data, reg ) \
data351drivers/net/hp100.houtl( data, ioaddr + HP100_REG_##reg )
data352drivers/net/hp100.h#define hp100_orb( data, reg ) \
data353drivers/net/hp100.houtb( inb( ioaddr + HP100_REG_##reg ) | (data), ioaddr + HP100_REG_##reg )
data354drivers/net/hp100.h#define hp100_orw( data, reg ) \
data355drivers/net/hp100.houtw( inw( ioaddr + HP100_REG_##reg ) | (data), ioaddr + HP100_REG_##reg )
data356drivers/net/hp100.h#define hp100_andb( data, reg ) \
data357drivers/net/hp100.houtb( inb( ioaddr + HP100_REG_##reg ) & (data), ioaddr + HP100_REG_##reg )
data358drivers/net/hp100.h#define hp100_andw( data, reg ) \
data359drivers/net/hp100.houtw( inw( ioaddr + HP100_REG_##reg ) & (data), ioaddr + HP100_REG_##reg )
data275drivers/net/i82586.hand length/type field already prepended to the data,
data800drivers/net/ibmtr.ctr_timer.data=(unsigned long)dev;
data817drivers/net/ibmtr.ctr_timer.data=(unsigned long)dev;
data932drivers/net/ibmtr.ctr_timer.data=(unsigned long)dev;
data1187drivers/net/ibmtr.cstruct trh_hdr *trhdr=(struct trh_hdr *)ti->current_skb->data;
data1204drivers/net/ibmtr.cllc = (struct trllc *) &(ti->current_skb->data[sizeof(struct trh_hdr)]);
data1256drivers/net/ibmtr.cwriteb(*(unsigned char *)(ti->current_skb->data +i), dhb++);
data1264drivers/net/ibmtr.cwriteb(*(unsigned char *)(ti->current_skb->data +sizeof(struct trh_hdr)+i),
data1280drivers/net/ibmtr.cunsigned char *data;
data1302drivers/net/ibmtr.cllc=(rbuffer+offsetof(struct rec_buf, data) + lan_hdr_len);
data1306drivers/net/ibmtr.c(unsigned int)offsetof(struct rec_buf,data), (unsigned int)lan_hdr_len);
data1342drivers/net/ibmtr.ctrhhdr=(rbuffer+offsetof(struct rec_buf,data));
data1381drivers/net/ibmtr.cdata=skb->data;
data1383drivers/net/ibmtr.cdata[i]=readb(rbuffer + offsetof(struct rec_buf, data)+i);
data1386drivers/net/ibmtr.cmemset(data+lan_hdr_len, 0, sizeof(struct trh_hdr)-lan_hdr_len);
data1388drivers/net/ibmtr.cdata+=sizeof(struct trh_hdr);
data1392drivers/net/ibmtr.cstruct trllc  *local_llc = (struct trllc *)data;
data1395drivers/net/ibmtr.cdata += sizeof(struct trllc);
data1399drivers/net/ibmtr.cDPRINTK("rbuffer_len: %d, data: %p\n", rbuffer_len, data);
data1403drivers/net/ibmtr.cdata[i]=readb(rbuffer+ offsetof(struct rec_buf, data)+lan_hdr_len+i);
data1404drivers/net/ibmtr.cdata+=rbuffer_len;
data1411drivers/net/ibmtr.cdata[i]=readb(rbuffer + offsetof(struct rec_buf, data)+i);
data1412drivers/net/ibmtr.cdata+=rbuffer_len;
data1416drivers/net/ibmtr.cntohs((rbuffer + offsetof(struct rec_buf, buf_ptr))), data);
data404drivers/net/ibmtr.hunsigned char data[0];
data844drivers/net/lance.cif ((u32)virt_to_bus(skb->data) + skb->len > 0x01000000) {
data847drivers/net/lance.cdev->name, (u32)virt_to_bus(skb->data));
data848drivers/net/lance.cmemcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
data854drivers/net/lance.clp->tx_ring[entry].base = ((u32)virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
data512drivers/net/lance32.clp->tx_ring[entry].base = (u32)virt_to_bus(skb->data);
data504drivers/net/ne.cchar *buf = skb->data;
data166drivers/net/new_tunnel.ciph = (struct iphdr *) skb->data;
data261drivers/net/new_tunnel.cmemcpy(new_skb->ip_hdr, skb->data, skb->len);
data1179drivers/net/ni52.cmemcpy((char *)p->xmit_cbuffs[p->xmit_count],(char *)(skb->data),skb->len);
data325drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000 ) {
data394drivers/net/ni65.crmdp->u.buffer = (unsigned long) p->recv_skb[i]->data;
data635drivers/net/ni65.cif( (unsigned long) (skb->data + R_BUF_SIZE) > 0x1000000) {
data637drivers/net/ni65.ceth_copy_and_sum(skb, (unsigned char *)(p->recv_skb[p->rmdnum]->data),len,0);
data643drivers/net/ni65.crmdp->u.buffer = (unsigned long) skb->data;
data715drivers/net/ni65.cif( (unsigned long) (skb->data + skb->len) > 0x1000000) {
data718drivers/net/ni65.cmemcpy((char *) tmdp->u.buffer,(char *)skb->data,
data724drivers/net/ni65.ctmdp->u.buffer = (unsigned long) skb->data;
data127drivers/net/pi2.cchar data[0];
data248drivers/net/pi2.cdma_abs = (unsigned long) (lp->rcvbuf->data);
data444drivers/net/pi2.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
data567drivers/net/pi2.cmemcpy(cfix, (char *) cur_buf->data,
data570drivers/net/pi2.cskb->mac.raw=skb->data;
data603drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data612drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data634drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data656drivers/net/pi2.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
data658drivers/net/pi2.cskb->mac.raw=skb->data;
data663drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data701drivers/net/pi2.clp->txptr = lp->sndbuf->data;
data815drivers/net/pi2.clp->txptr = lp->sndbuf->data;
data931drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data1068drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data1326drivers/net/pi2.clp->rcp = lp->rcvbuf->data;
data197drivers/net/plip.cunsigned char  data;
data297drivers/net/plip.cnl->immediate.data = dev;
data302drivers/net/plip.cnl->deferred.data = dev;
data556drivers/net/plip.clbuf = rcv->skb->data;
data569drivers/net/plip.c&rcv->nibble, &rcv->data))
data571drivers/net/plip.cif (rcv->data != rcv->checksum) {
data614drivers/net/plip.cenum plip_nibble_state *ns_p, unsigned char data)
data621drivers/net/plip.coutb((data & 0x0f), data_addr);
data625drivers/net/plip.coutb(0x10 | (data & 0x0f), data_addr);
data636drivers/net/plip.coutb(0x10 | (data >> 4), --data_addr);
data640drivers/net/plip.coutb((data >> 4), data_addr);
data669drivers/net/plip.cif (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
data89drivers/net/ppp.c#define skb_data(skb)       ((__u8 *) (skb)->data)
data1051drivers/net/ppp.cppp_tty_receive (struct tty_struct *tty, const __u8 * data,
data1081drivers/net/ppp.cppp_print_buffer ("receive buffer", data, count);
data1088drivers/net/ppp.cchr = *data++;
data1187drivers/net/ppp.cppp_rcv_rx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
data1206drivers/net/ppp.cmemcpy (skb_put(skb,count), data, count);  /* move data */
data1221drivers/net/ppp.crcv_proto_ip (struct ppp *ppp, __u16 proto, __u8 * data, int count)
data1225drivers/net/ppp.creturn ppp_rcv_rx (ppp, htons (ETH_P_IP), data, count);
data1234drivers/net/ppp.crcv_proto_ipx (struct ppp *ppp, __u16 proto, __u8 * data, int count)
data1237drivers/net/ppp.creturn ppp_rcv_rx (ppp, htons (ETH_P_IPX), data, count);
data1247drivers/net/ppp.c__u8 *data, int count)
data1250drivers/net/ppp.cint new_count = slhc_uncompress (ppp->slcomp, data, count);
data1252drivers/net/ppp.creturn rcv_proto_ip (ppp, PPP_IP, data, new_count);
data1267drivers/net/ppp.c__u8 *data, int count)
data1270drivers/net/ppp.cif (slhc_remember (ppp->slcomp, data, count) > 0) {
data1271drivers/net/ppp.creturn rcv_proto_ip (ppp, PPP_IP, data, count);
data1286drivers/net/ppp.c__u8 *data, int len)
data1321drivers/net/ppp.cPUTC (*data++);
data1467drivers/net/ppp.crcv_proto_lqr (struct ppp *ppp, __u16 proto, __u8 * data, int len)
data1469drivers/net/ppp.creturn rcv_proto_unknown (ppp, proto, data, len);
data1475drivers/net/ppp.cstatic void ppp_doframe_lower (struct ppp *ppp, __u8 *data, int count)
data1477drivers/net/ppp.c__u16    proto = PPP_PROTOCOL (data);
data1489drivers/net/ppp.cppp_print_buffer ("receive frame", data, count);
data1501drivers/net/ppp.c&data[PPP_HARD_HDR_LEN],
data1514drivers/net/ppp.c__u8  *data = buf_base (ppp->rbuf);
data1567drivers/net/ppp.cif ((data[0] == PPP_ALLSTATIONS) && (data[1] == PPP_UI)) {
data1568drivers/net/ppp.cdata  += 2;
data1574drivers/net/ppp.cproto = (__u16) *data++;
data1576drivers/net/ppp.cproto = (proto << 8) | (__u16) *data++;
data1584drivers/net/ppp.c*(--data) = proto;
data1585drivers/net/ppp.c*(--data) = proto >> 8;
data1586drivers/net/ppp.c*(--data) = ctrl;
data1587drivers/net/ppp.c*(--data) = addr;
data1606drivers/net/ppp.cdata,
data1614drivers/net/ppp.cdata,
data1651drivers/net/ppp.cdata,
data1657drivers/net/ppp.cppp_doframe_lower (ppp, data, count);
data1863drivers/net/ppp.c__u8 *data, int count, int non_ip)
data1884drivers/net/ppp.caddress = PPP_ADDRESS  (data);
data1885drivers/net/ppp.ccontrol = PPP_CONTROL  (data);
data1886drivers/net/ppp.cproto  = PPP_PROTOCOL (data);
data1904drivers/net/ppp.cdata  += 4;
data1908drivers/net/ppp.cppp_stuff_char (ppp, buf, *data++);
data1951drivers/net/ppp.c__u8 *data, int count)
data1961drivers/net/ppp.cppp_print_buffer ("write frame", data, count);
data1966drivers/net/ppp.cproto  = PPP_PROTOCOL (data);
data1967drivers/net/ppp.caddress = PPP_ADDRESS  (data);
data1968drivers/net/ppp.ccontrol = PPP_CONTROL  (data);
data1985drivers/net/ppp.cdata,
data2013drivers/net/ppp.cppp_dev_xmit_lower (ppp, buf, data, count, !!(proto & 0xFF00));
data2022drivers/net/ppp.csend_revise_frame (register struct ppp *ppp, __u8 *data, int len)
data2026drivers/net/ppp.cswitch (PPP_PROTOCOL (data)) {
data2033drivers/net/ppp.cp   = (__u8 *) &data [40];  /* Point to last two items. */
data2042drivers/net/ppp.cdata + PPP_HARD_HDR_LEN,
data2060drivers/net/ppp.cppp_tty_write (struct tty_struct *tty, struct file *file, const __u8 * data,
data2120drivers/net/ppp.cstatus = verify_area (VERIFY_READ, data, count);
data2127drivers/net/ppp.cmemcpy_fromfs (new_data, data, count);
data2148drivers/net/ppp.cstruct ppp_option_data data;
data2156drivers/net/ppp.cerror = verify_area (VERIFY_READ, odp, sizeof (data));
data2158drivers/net/ppp.cmemcpy_fromfs (&data, odp, sizeof (data));
data2159drivers/net/ppp.cnb  = data.length;
data2160drivers/net/ppp.cptr = data.ptr;
data2182drivers/net/ppp.cif (data.transmit) {
data2847drivers/net/ppp.cppp_dev_xmit_ip (struct device *dev, struct ppp *ppp, __u8 *data)
data2856drivers/net/ppp.clen = ((struct iphdr *)data) -> tot_len;
data2931drivers/net/ppp.cppp_print_buffer ("ppp outpkt", data, len);
data2938drivers/net/ppp.clen = slhc_compress (ppp->slcomp, data, len,
data2940drivers/net/ppp.c&data,
data2943drivers/net/ppp.cif (data[0] & SL_TYPE_COMPRESSED_TCP) {
data2945drivers/net/ppp.cdata[0] ^= SL_TYPE_COMPRESSED_TCP;
data2947drivers/net/ppp.cif (data[0] >= SL_TYPE_UNCOMPRESSED_TCP)
data2949drivers/net/ppp.cdata[0] = (data[0] & 0x0f) | 0x40;
data2956drivers/net/ppp.chdr   = &((struct ppp_hdr *) data)[-1];
data2974drivers/net/ppp.c__u8 *data, int len, int proto)
data3019drivers/net/ppp.cppp_print_buffer ("ppp outpkt", data, len);
data3024drivers/net/ppp.chdr   = &((struct ppp_hdr *) data)[-1];
data3042drivers/net/ppp.c__u8      *data;
data3082drivers/net/ppp.cdata  = skb_data(skb);
data3089drivers/net/ppp.canswer = ppp_dev_xmit_ipx (dev, ppp, data, len, PPP_IPX);
data3093drivers/net/ppp.canswer = ppp_dev_xmit_ip (dev, ppp, data);
data100drivers/net/pt.cchar data[0];
data185drivers/net/pt.cptr = skb->data;
data257drivers/net/pt.cdma_abs = (unsigned long) (lp->rcvbuf->data);
data722drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data795drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1181drivers/net/pt.clp->txptr = lp->sndbuf->data;
data1298drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1308drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1366drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1407drivers/net/pt.cmemcpy(cfix, (char*)cur_buf->data, pkt_len - 1);
data1409drivers/net/pt.cmemcpy(cfix, lp->rcvbuf->data, pkt_len - 1);
data1411drivers/net/pt.cskb->mac.raw=skb->data;
data1418drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1622drivers/net/pt.clp->txptr = lp->sndbuf->data;
data1638drivers/net/pt.cmemcpy(lp->txdmabuf, &lp->sndbuf->data[1], length);
data1756drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1779drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1790drivers/net/pt.clp->rcp = lp->rcvbuf->data;
data1826drivers/net/pt.cskb->mac.raw=skb->data;
data267drivers/net/sdla.cchar data;
data273drivers/net/sdla.cdata = LOADER_READY;
data274drivers/net/sdla.csdla_write(dev, 0, &data, 1);
data280drivers/net/sdla.csdla_read(dev, 0, &data, 1);
data282drivers/net/sdla.cif (data == Z80_SCC_BAD)
data285drivers/net/sdla.cif (data != Z80_SCC_OK)
data325drivers/net/sdla.cstatic void sdla_errors(struct device *dev, int cmd, int dlci, int ret, int len, void *data) 
data335drivers/net/sdla.cstate = data;
data356drivers/net/sdla.cfor(pstatus = data, i=0;i < len;i++,pstatus++)
data377drivers/net/sdla.cfor(pdlci = data,i=0;i < len;i++,pdlci++)
data432drivers/net/sdla.cmemcpy(cmd_buf->data, inbuf, inlen);
data465drivers/net/sdla.cmemcpy(outbuf, cmd_buf->data, *outlen);
data470drivers/net/sdla.cmemcpy(&status, cmd_buf->data, len > sizeof(status) ? sizeof(status) : len);
data687drivers/net/sdla.cret = sdla_cmd(dev, SDLA_INFORMATION_WRITE, *(short *)(skb->dev->dev_addr), 0, skb->data, skb->len, NULL, NULL);
data700drivers/net/sdla.csdla_write(dev, pbuf->buf_addr, skb->data, skb->len);
data1000drivers/net/sdla.cstruct conf_data  data;
data1017drivers/net/sdla.cdata.dlci[len++] = abs(flp->dlci[i]);
data1020drivers/net/sdla.cmemcpy(&data.config, &flp->config, sizeof(struct frad_conf));
data1024drivers/net/sdla.csdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
data1072drivers/net/sdla.csdla_cmd(dev, SDLA_ADD_DLCI, 0, 0, data.dlci, len - sizeof(struct frad_conf), NULL, NULL);
data1099drivers/net/sdla.cstruct conf_data  data;
data1117drivers/net/sdla.cmemcpy_fromfs(&data.config, conf, sizeof(struct frad_conf));
data1119drivers/net/sdla.cif (data.config.station & ~FRAD_STATION_NODE)
data1122drivers/net/sdla.cif (data.config.flags & ~FRAD_VALID_FLAGS)
data1125drivers/net/sdla.cif ((data.config.kbaud < 0) || 
data1126drivers/net/sdla.c((data.config.kbaud > 128) && (flp->type != SDLA_S508)))
data1129drivers/net/sdla.cif (data.config.clocking & ~(FRAD_CLOCK_INT | SDLA_S508_PORT_RS232))
data1132drivers/net/sdla.cif ((data.config.mtu < 0) || (data.config.mtu > SDLA_MAX_MTU))
data1135drivers/net/sdla.cif ((data.config.T391 < 5) || (data.config.T391 > 30))
data1138drivers/net/sdla.cif ((data.config.T392 < 5) || (data.config.T392 > 30))
data1141drivers/net/sdla.cif ((data.config.N391 < 1) || (data.config.N391 > 255))
data1144drivers/net/sdla.cif ((data.config.N392 < 1) || (data.config.N392 > 10))
data1147drivers/net/sdla.cif ((data.config.N393 < 1) || (data.config.N393 > 10))
data1150drivers/net/sdla.cmemcpy(&flp->config, &data.config, sizeof(struct frad_conf));
data1182drivers/net/sdla.csize = sizeof(data);
data1183drivers/net/sdla.cif (sdla_cmd(dev, SDLA_READ_DLCI_CONFIGURATION, 0, 0, NULL, 0, &data, &size) != SDLA_RET_OK)
data1188drivers/net/sdla.cmemcpy(&data.config, &flp->config, sizeof(struct frad_conf));
data1190drivers/net/sdla.cmemset(&data.config, 0, sizeof(struct frad_conf));
data1192drivers/net/sdla.cmemcpy(&flp->config, &data.config, sizeof(struct frad_conf));
data1193drivers/net/sdla.cdata.config.flags &= FRAD_VALID_FLAGS;
data1194drivers/net/sdla.cdata.config.mtu -= data.config.mtu > sizeof(struct frhdr) ? sizeof(struct frhdr) : data.config.mtu;
data1195drivers/net/sdla.cmemcpy_tofs(conf, &data.config, sizeof(struct frad_conf));
data1214drivers/net/sdla.cerr = verify_area(VERIFY_WRITE, mem.data, mem.len);
data1222drivers/net/sdla.cmemcpy_tofs(mem.data, temp, mem.len);
data1227drivers/net/sdla.cerr = verify_area(VERIFY_READ, mem.data, mem.len);
data1234drivers/net/sdla.cmemcpy_fromfs(temp, mem.data, mem.len);
data1244drivers/net/sdla.cstruct conf_data  data;
data1252drivers/net/sdla.cdata.dlci[len++] = flp->dlci[i];
data1255drivers/net/sdla.cmemcpy(&data, &flp->config, sizeof(struct frad_conf));
data1259drivers/net/sdla.csdla_cmd(dev, SDLA_SET_DLCI_CONFIGURATION, 0, 0, &data, len, NULL, NULL);
data1670drivers/net/sdla.cflp->timer.data      = (unsigned long) dev;
data406drivers/net/seeq8005.cunsigned char *buf = skb->data;
data1256drivers/net/sk_g16.cmemcpy((char *) (tmdp->u.buffer & 0x00ffffff), (char *)skb->data,
data381drivers/net/skeleton.cunsigned char *buf = skb->data;
data474drivers/net/skeleton.cinsw(ioaddr, skb->data, (pkt_len + 1) >> 1);
data391drivers/net/slip.cskb->mac.raw=skb->data;
data527drivers/net/slip.csl_encaps(sl, skb->data, skb->len);
data634drivers/net/slip.csl->keepalive_timer.data=(unsigned long)sl;
data638drivers/net/slip.csl->outfill_timer.data=(unsigned long)sl;
data296drivers/net/smc-ultra.cmemcpy_fromio(skb->data, xfer_start, semi_count);
data298drivers/net/smc-ultra.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
data657drivers/net/smc9194.cbuf = skb->data;
data1464drivers/net/smc9194.cbyte    * data;
data1498drivers/net/smc9194.cdata = skb->data;
data1500drivers/net/smc9194.cdata = skb_put( skb, packet_length);
data1509drivers/net/smc9194.cinsl(ioaddr + DATA_1 , data, packet_length >> 2 ); 
data1511drivers/net/smc9194.cinsb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC), 
data1517drivers/net/smc9194.c*(data++) = inb( ioaddr + DATA_1 ); 
data1518drivers/net/smc9194.cinsw(ioaddr + DATA_1 , data, (packet_length + 1 ) >> 1);
data1520drivers/net/smc9194.cdata += packet_length & ~1;
data1521drivers/net/smc9194.c*((data++) = inb( ioaddr + DATA_1 ); 
data1525drivers/net/smc9194.cprint_packet( data, packet_length );
data187drivers/net/strip.c__u8 data[4];    /* Placeholder for payload (The IP packet) */
data606drivers/net/strip.cunsigned char  *icp        = skb->data;
data752drivers/net/strip.cskb->mac.raw=skb->data;
data1271drivers/net/strip.cstrip_info->idle_timer.data     = (long)&strip_info->dev;
data699drivers/net/sunlance.cprintk ("%2.2x ", skb->data [i]);
data708drivers/net/sunlance.cmemcpy ((char *)&ib->tx_buf [entry][0], skb->data, skblen);
data843drivers/net/tulip.ctp->tx_ring[entry].buffer1 = virt_to_bus(skb->data);
data1040drivers/net/wavelan.clp->watchdog.data = (unsigned long)dev;
data1445drivers/net/wavelan.cbuf = skb->data;
data1665drivers/net/wavelan.cc = skb->data[i];
data1667drivers/net/wavelan.cprintk(" %c", skb->data[i]);
data1669drivers/net/wavelan.cprintk("%02x", skb->data[i]);
data384drivers/net/wd.cmemcpy_fromio(skb->data, xfer_start, semi_count);
data386drivers/net/wd.cmemcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
data142drivers/net/wic.cunsigned char  data;
data226drivers/net/wic.cwc.len = recv_cmd_resp(dev, (unsigned char *)&wc.data);
data227drivers/net/wic.cwhile ((wc.len == 1) && (wc.data[0] == 0x7)) /* controller int */
data228drivers/net/wic.cwc.len = recv_cmd_resp(dev, (unsigned char *)&wc.data);
data232drivers/net/wic.cdev->dev_addr[i] = wc.data[i];
data255drivers/net/wic.cnl->immediate.data = dev;
data260drivers/net/wic.cnl->deferred.data = dev;
data326drivers/net/wic.cwc.len = recv_cmd_resp(dev, (unsigned char *)&wc.data);
data327drivers/net/wic.cwhile ((wc.len == 1) && (wc.data[0] == 0x7)) /* controller int */
data328drivers/net/wic.cwc.len = recv_cmd_resp(dev, (unsigned char *)&wc.data);
data329drivers/net/wic.cwn = (struct wic_net *)&wc.data;
data574drivers/net/wic.clbuf = rcv->skb->data;
data641drivers/net/wic.cenum wic_nibble_state *ns_p, unsigned char data)
data651drivers/net/wic.coutb(data, data_addr);
data669drivers/net/wic.cif (snd->skb == NULL || (lbuf = snd->skb->data) == NULL) {
data1105drivers/net/wic.cstrcpy(wc.data, version);
data1106drivers/net/wic.cwc.len = strlen(wc.data);
data1157drivers/net/wic.clen = (char)recv_cmd_resp(dev, wc.data);
data1158drivers/net/wic.cwhile ((len == 1) && (wc.data[0] == 0x7)) { /* controller int */
data1159drivers/net/wic.clen = (char)recv_cmd_resp(dev, wc.data);
data361drivers/net/znet.cunsigned char *buf = (void *)skb->data;
data568drivers/net/znet.cunsigned int *packet = (unsigned int *) skb->data;
data1552drivers/sbus/char/suncons.cunsigned long fgmask, bgmask, data, rowbits, attrib;
data1566drivers/sbus/char/suncons.cdata = fontmask_bits[(rowbits>>4)&0xf];
data1567drivers/sbus/char/suncons.cdata = (data & fgmask) | (~data & bgmask);
data1568drivers/sbus/char/suncons.c*dst = data;
data1569drivers/sbus/char/suncons.cdata = fontmask_bits[rowbits&0xf];
data1570drivers/sbus/char/suncons.cdata = (data & fgmask) | (~data & bgmask);
data1571drivers/sbus/char/suncons.c*(dst+1) = data;
data369drivers/sbus/char/sunserial.cch = info->zs_channel->data;
data463drivers/sbus/char/sunserial.cinfo->zs_channel->data = info->x_char;
data477drivers/sbus/char/sunserial.cinfo->zs_channel->data = info->xmit_buf[info->xmit_tail++];
data918drivers/sbus/char/sunserial.cchan->data = ch;
data937drivers/sbus/char/sunserial.cchan->data = ch;
data958drivers/sbus/char/sunserial.cchan->data = ch;
data973drivers/sbus/char/sunserial.cchan->data = kgdb_char;
data982drivers/sbus/char/sunserial.creturn chan->data;
data1069drivers/sbus/char/sunserial.cinfo->zs_channel->data = info->xmit_buf[info->xmit_tail++];
data2100drivers/sbus/char/sunserial.cinfo->tqueue.data = info;
data2102drivers/sbus/char/sunserial.cinfo->tqueue_hangup.data = info;
data12drivers/sbus/char/sunserial.hvolatile unsigned char data;
data413drivers/sbus/char/sunserial.hgarbage = channel->data; \
data415drivers/sbus/char/sunserial.hgarbage = channel->data; \
data417drivers/sbus/char/sunserial.hgarbage = channel->data; \
data525drivers/scsi/53c7,8xx.c} data;
data601drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.base = ints[1];
data602drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.io_port = ints[2];
data603drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.irq = ints[3];
data604drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.dma = (ints[0] >= 4) ?
data610drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.bus = ints[1];
data611drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.device = ints[2];
data612drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.function = ints[3];
data1562drivers/scsi/53c7,8xx.c(unsigned char) overrides[current_override].data.pci.bus,
data1563drivers/scsi/53c7,8xx.c(((overrides[current_override].data.pci.device
data1564drivers/scsi/53c7,8xx.c<< 3) & 0xf8)|(overrides[current_override].data.pci.function & 
data1568drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.base, 
data1569drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.io_port,
data1570drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.irq,
data1571drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.dma,
data1920drivers/scsi/53c7,8xx.cunsigned char data[36];
data1926drivers/scsi/53c7,8xx.ccmd[4] = sizeof(data); 
data1932drivers/scsi/53c7,8xx.cdsa[6] = sizeof(data);
data1933drivers/scsi/53c7,8xx.cdsa[7] = virt_to_bus(&data);
data1964drivers/scsi/53c7,8xx.cdata[35] = 0;
data1966drivers/scsi/53c7,8xx.chost->host_no, i, data + 8);
data147drivers/scsi/AM53C974.cunsigned long length, char *data);
data1997drivers/scsi/AM53C974.cunsigned long length, char *data)
data2008drivers/scsi/AM53C974.cAM53C974_write_32(DMASPA, (unsigned long)data);
data370drivers/scsi/NCR5380.cunsigned char status, data, basr, mr, icr, i;
data373drivers/scsi/NCR5380.cdata = NCR5380_read(CURRENT_SCSI_DATA_REG);
data1457drivers/scsi/NCR5380.cunsigned char *data;
data1741drivers/scsi/NCR5380.cdata = tmp;
data1743drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data1786drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
data1790drivers/scsi/NCR5380.cregister unsigned char *d = *data;
data1898drivers/scsi/NCR5380.c*data = d;
data2000drivers/scsi/NCR5380.cunsigned char *phase, int *count, unsigned char **data) {
data2004drivers/scsi/NCR5380.cregister unsigned char *d = *data;
data2166drivers/scsi/NCR5380.c*data += c;
data2175drivers/scsi/NCR5380.c**data = saved_data;
data2176drivers/scsi/NCR5380.c*data += 1;
data2184drivers/scsi/NCR5380.cprintk("Doing %d-byte PIO to 0x%X\n", cnt, *data);
data2186drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, phase, &cnt, data);
data2193drivers/scsi/NCR5380.c*data, *count, *(*data+*count-1), *(*data+*count));
data2321drivers/scsi/NCR5380.c*data = d + c;
data2362drivers/scsi/NCR5380.cunsigned char *data;
data2486drivers/scsi/NCR5380.cdata = &tmp;
data2487drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2701drivers/scsi/NCR5380.cdata = extended_msg + 1;
data2703drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2716drivers/scsi/NCR5380.cdata = extended_msg + 3;
data2719drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2768drivers/scsi/NCR5380.cdata = &msgout;
data2770drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2786drivers/scsi/NCR5380.cdata = cmd->cmnd;
data2793drivers/scsi/NCR5380.c&data);
data2808drivers/scsi/NCR5380.cdata = &tmp;
data2809drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2859drivers/scsi/NCR5380.cunsigned char *data;
data2899drivers/scsi/NCR5380.cdata = msg;
data2901drivers/scsi/NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data312drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
data315drivers/scsi/NCR5380.hunsigned char *phase, int *count, unsigned char **data);
data1710drivers/scsi/advansys.c#define AscPutChipIFC( port, data )         outp( (port)+IOP_REG_IFC, data )
data1714drivers/scsi/advansys.c#define AscPutChipLramData( port, data )    outpw( (port)+IOP_RAM_DATA, data )
data1717drivers/scsi/advansys.c#define AscWriteChipSyn( port, data )       outp( (port)+IOP_SYN_OFFSET, data )
data1720drivers/scsi/advansys.c#define AscWriteChipIH( port, data )        outpw( (port)+IOP_REG_IH, data )
data1723drivers/scsi/advansys.c#define AscWriteChipScsiID( port, data )    outp( (port)+IOP_REG_ID, data )
data1727drivers/scsi/advansys.c#define AscSetChipDmaSpeed( port, data )   outp( (port)+IOP_DMA_SPEED, data )
data1729drivers/scsi/advansys.c#define AscSetPCAddr( port, data )         outpw( (port)+IOP_REG_PC, data )
data1734drivers/scsi/advansys.c#define AscSetChipEEPCmd( port, data )     outp( (port)+IOP_EEP_CMD, data )
data1736drivers/scsi/advansys.c#define AscSetChipEEPData( port, data )    outpw( (port)+IOP_EEP_DATA, data )
data1746drivers/scsi/advansys.c#define AscSetChipCfgLsw( port, data )     outpw( (port)+IOP_CONFIG_LOW, data )
data1747drivers/scsi/advansys.c#define AscSetChipCfgMsw( port, data )     outpw( (port)+IOP_CONFIG_HIGH, data )
data1858drivers/scsi/advansys.cushort              data[ASC_MC_SAVE_DATA_WSIZE];
data4129drivers/scsi/advansys.cushort data;
data4140drivers/scsi/advansys.cdata = asc_get_cfg_word(&pciData);
data4141drivers/scsi/advansys.cif ((data != 0xFFFF) && (data != 0x0000)) {
data4142drivers/scsi/advansys.cASC_DBG2(4, "asc_scan_method: data %x, type %d\n", data, type);
data2103drivers/scsi/aha152x.cunsigned char *data;
data2111drivers/scsi/aha152x.cdata = (unsigned char *) CURRENT_SC->SCp.ptr;
data2113drivers/scsi/aha152x.cprintk("%2x ", *data++);
data621drivers/scsi/atari_NCR5380.cunsigned char status, data, basr, mr, icr, i;
data626drivers/scsi/atari_NCR5380.cdata = NCR5380_read(CURRENT_SCSI_DATA_REG);
data1273drivers/scsi/atari_NCR5380.cunsigned char **data, p;
data1311drivers/scsi/atari_NCR5380.cdata = (unsigned char **) &(hostdata->connected->SCp.ptr);
data1313drivers/scsi/atari_NCR5380.c*data += transfered;
data1323drivers/scsi/atari_NCR5380.c*(*data)++ = saved_data;
data1329drivers/scsi/atari_NCR5380.cprintk( "Doing %d-byte PIO to 0x%08lx\n", cnt, (long)*data );
data1332drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &p, &cnt, data);
data1508drivers/scsi/atari_NCR5380.cunsigned char *data;
data1809drivers/scsi/atari_NCR5380.cdata = tmp;
data1811drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data1854drivers/scsi/atari_NCR5380.cunsigned char **data)
data1858drivers/scsi/atari_NCR5380.cregister unsigned char *d = *data;
data1958drivers/scsi/atari_NCR5380.c*data = d;
data2049drivers/scsi/atari_NCR5380.cunsigned char **data)
data2054drivers/scsi/atari_NCR5380.cregister unsigned char *d = *data;
data2140drivers/scsi/atari_NCR5380.cunsigned char *data;
data2257drivers/scsi/atari_NCR5380.cdata = &tmp;
data2259drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2522drivers/scsi/atari_NCR5380.cdata = extended_msg + 1;
data2524drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2537drivers/scsi/atari_NCR5380.cdata = extended_msg + 3;
data2540drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2592drivers/scsi/atari_NCR5380.cdata = &msgout;
data2594drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2615drivers/scsi/atari_NCR5380.cdata = cmd->cmnd;
data2622drivers/scsi/atari_NCR5380.c&data);
data2626drivers/scsi/atari_NCR5380.cdata = &tmp;
data2627drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2662drivers/scsi/atari_NCR5380.cunsigned char *data;
data2701drivers/scsi/atari_NCR5380.cdata = msg;
data2703drivers/scsi/atari_NCR5380.cNCR5380_transfer_pio(instance, &phase, &len, &data);
data2723drivers/scsi/atari_NCR5380.cdata = msg+1;
data2724drivers/scsi/atari_NCR5380.cif (!NCR5380_transfer_pio(instance, &phase, &len, &data) &&
data607drivers/scsi/atari_scsi.c__val = tt_rtc.data;    \
data614drivers/scsi/atari_scsi.ctt_rtc.data = (val);    \
data924drivers/scsi/atari_scsi.cunsigned long atari_scsi_dma_setup( struct Scsi_Host *instance, void *data,
data927drivers/scsi/atari_scsi.cunsigned long addr = VTOP( data );
data931drivers/scsi/atari_scsi.cinstance->host_no, data, addr, count, dir);
data941drivers/scsi/atari_scsi.cmemcpy( atari_dma_buffer, data, count );
data943drivers/scsi/atari_scsi.catari_dma_orig_addr = data;
data467drivers/scsi/eata_dma.ccp->sg_list[i].data = htonl(virt_to_bus(sl->address));
data255drivers/scsi/eata_generic.h__u32 data;
data1924drivers/scsi/fdomain.cunsigned char    *data     = (unsigned char *)(sizes + 2);
data2010drivers/scsi/fdomain.cmemcpy( data, do_read, sizeof( do_read ) );
data2015drivers/scsi/fdomain.c&& data[511] == 0xaa && data[510] == 0x55 /* Partition table valid */
data2016drivers/scsi/fdomain.c&& data[0x1c2]) {          /* Partition type */
data2047drivers/scsi/fdomain.cinfo_array[0] = data[0x1c3] + 1;      /* heads */
data2048drivers/scsi/fdomain.cinfo_array[1] = data[0x1c4] & 0x3f;      /* sectors */
data346drivers/scsi/ppa.cstatic void ppa_interrupt( void *data);
data350drivers/scsi/ppa.cstatic void ppa_interrupt( void *data)
data90drivers/scsi/scsi.cstatic void print_inquiry(unsigned char *data);
data2558drivers/scsi/scsi.cstatic void print_inquiry(unsigned char *data)
data2565drivers/scsi/scsi.cif (data[i] >= 0x20 && i < data[4] + 5)
data2566drivers/scsi/scsi.cprintk("%c", data[i]);
data2574drivers/scsi/scsi.cif (data[i] >= 0x20 && i < data[4] + 5)
data2575drivers/scsi/scsi.cprintk("%c", data[i]);
data2583drivers/scsi/scsi.cif (data[i] >= 0x20 && i < data[4] + 5)
data2584drivers/scsi/scsi.cprintk("%c", data[i]);
data2591drivers/scsi/scsi.ci = data[0] & 0x1f;
data2595drivers/scsi/scsi.cprintk("                 ANSI SCSI revision: %02x", data[2] & 0x07);
data2596drivers/scsi/scsi.cif ((data[2] & 0x07) == 1 && (data[3] & 0x0f) == 1)
data622drivers/scsi/seagate.cunsigned char *data = NULL;  
data749drivers/scsi/seagate.cdata=current_data;      /* WDE add */
data949drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
data956drivers/scsi/seagate.cdata = (unsigned char *) SCint->request_buffer;
data1091drivers/scsi/seagate.cSCint->transfersize, len, data);
data1109drivers/scsi/seagate.c"D" (st0x_dr), "S" (data), "c" (SCint->transfersize) :
data1114drivers/scsi/seagate.cdata += transfersize;
data1118drivers/scsi/seagate.chostno, len, data);
data1174drivers/scsi/seagate.c"=S" (data), "=c" (len) :
data1176drivers/scsi/seagate.c"0" (data), "1" (len) :
data1185drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
data1188drivers/scsi/seagate.chostno, len, data);
data1201drivers/scsi/seagate.c*data++ = DATA;
data1218drivers/scsi/seagate.cSCint->transfersize, len, data);
data1236drivers/scsi/seagate.c"S" (st0x_dr), "D" (data), "c" (SCint->transfersize) :
data1241drivers/scsi/seagate.cdata += transfersize;
data1250drivers/scsi/seagate.chostno, len, data);
data1314drivers/scsi/seagate.c"=D" (data), "=c" (len) :
data1316drivers/scsi/seagate.c"0" (data), "1" (len) :
data1331drivers/scsi/seagate.cdata = (unsigned char *) buffer->address;
data1334drivers/scsi/seagate.chostno, len, data);
data1399drivers/scsi/seagate.ccurrent_data = data;    /* WDE add */
data1434drivers/scsi/seagate.ccurrent_data = data;  /* WDE mod */
data1443drivers/scsi/seagate.cdata=current_data;  /* WDE mod */
data1508drivers/scsi/seagate.cprintk ("%02x  ", ((unsigned char *) data)[i]);  /* WDE mod */
data1638drivers/scsi/seagate.cunsigned char buf[256 + sizeof(int) * 2], cmd[6], *data, *page;
data1652drivers/scsi/seagate.cdata = (unsigned char *) (sizes + 2);
data1669drivers/scsi/seagate.cmemcpy (data, cmd, 6);
data1677drivers/scsi/seagate.cpage = data + 4 + data[3];
data1682drivers/scsi/seagate.cmemcpy (data, cmd, 6);
data1685drivers/scsi/seagate.cpage = data + 4 + data[3];
data1694drivers/scsi/seagate.cformatted_sectors = (data[4 + 1] << 16) | (data[4 + 2] << 8) |
data1695drivers/scsi/seagate.cdata[4 + 3] ;
data457drivers/scsi/wd7000.cunchar data[14];              /* format-specific data */
data471drivers/scsi/wd7000.cunchar data[18];
data154drivers/sound/ad1848.cad_write (ad1848_info * devc, int reg, int data)
data166drivers/sound/ad1848.coutb ((unsigned char) (data & 0xff), io_Indexed_Data (devc));
data236drivers/sound/dev_table.hvoid (*inputintr)(int dev, unsigned char data),
data241drivers/sound/dev_table.hint (*putc) (int dev, unsigned char data);
data245drivers/sound/dev_table.hint (*command) (int dev, unsigned char *data);
data490drivers/sound/dmasound.cu_long data;  /* data for expanding */
data757drivers/sound/dmasound.cu_long data;
data764drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data765drivers/sound/dmasound.c*p++ = data;
data766drivers/sound/dmasound.c*p++ = data;
data785drivers/sound/dmasound.cu_long data;
data792drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8000;
data793drivers/sound/dmasound.c*p++ = data;
data794drivers/sound/dmasound.c*p++ = data;
data816drivers/sound/dmasound.cu_long data;
data824drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data825drivers/sound/dmasound.cdata = le2be16(data);
data826drivers/sound/dmasound.c*p++ = data;
data827drivers/sound/dmasound.c*p++ = data;
data836drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++);
data837drivers/sound/dmasound.cdata = le2be16dbl(data);
data838drivers/sound/dmasound.c*p++ = data;
data851drivers/sound/dmasound.cu_long data;
data859drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data860drivers/sound/dmasound.cdata = le2be16(data) ^ 0x8000;
data861drivers/sound/dmasound.c*p++ = data;
data862drivers/sound/dmasound.c*p++ = data;
data870drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++);
data871drivers/sound/dmasound.cdata = le2be16dbl(data) ^ 0x80008000;
data872drivers/sound/dmasound.c*p++ = data;
data886drivers/sound/dmasound.cu_long data = sound.data;
data899drivers/sound/dmasound.cdata = table[get_user(userPtr++)];
data903drivers/sound/dmasound.c*p++ = data;
data913drivers/sound/dmasound.cdata = table[get_user(userPtr++)] << 8;
data914drivers/sound/dmasound.cdata |= table[get_user(userPtr++)];
data918drivers/sound/dmasound.c*p++ = data;
data924drivers/sound/dmasound.csound.data = data;
data935drivers/sound/dmasound.cu_long data = sound.data;
data948drivers/sound/dmasound.cdata = get_user(userPtr++);
data952drivers/sound/dmasound.c*p++ = data;
data962drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data966drivers/sound/dmasound.c*p++ = data;
data972drivers/sound/dmasound.csound.data = data;
data983drivers/sound/dmasound.cu_long data = sound.data;
data996drivers/sound/dmasound.cdata = get_user(userPtr++) ^ 0x80;
data1000drivers/sound/dmasound.c*p++ = data;
data1010drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8080;
data1014drivers/sound/dmasound.c*p++ = data;
data1020drivers/sound/dmasound.csound.data = data;
data1031drivers/sound/dmasound.cu_long data = sound.data;
data1044drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1048drivers/sound/dmasound.c*p++ = data;
data1049drivers/sound/dmasound.c*p++ = data;
data1059drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++);
data1063drivers/sound/dmasound.c*p++ = data;
data1069drivers/sound/dmasound.csound.data = data;
data1080drivers/sound/dmasound.cu_long data = sound.data;
data1093drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8000;
data1097drivers/sound/dmasound.c*p++ = data;
data1098drivers/sound/dmasound.c*p++ = data;
data1108drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++) ^ 0x80008000;
data1112drivers/sound/dmasound.c*p++ = data;
data1118drivers/sound/dmasound.csound.data = data;
data1129drivers/sound/dmasound.cu_long data = sound.data;
data1142drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1143drivers/sound/dmasound.cdata = le2be16(data);
data1147drivers/sound/dmasound.c*p++ = data;
data1148drivers/sound/dmasound.c*p++ = data;
data1158drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++);
data1159drivers/sound/dmasound.cdata = le2be16dbl(data);
data1163drivers/sound/dmasound.c*p++ = data;
data1169drivers/sound/dmasound.csound.data = data;
data1180drivers/sound/dmasound.cu_long data = sound.data;
data1193drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1194drivers/sound/dmasound.cdata = le2be16(data) ^ 0x8000;
data1198drivers/sound/dmasound.c*p++ = data;
data1199drivers/sound/dmasound.c*p++ = data;
data1209drivers/sound/dmasound.cdata = get_user(((u_int *)userPtr)++);
data1210drivers/sound/dmasound.cdata = le2be16dbl(data) ^ 0x80008000;
data1214drivers/sound/dmasound.c*p++ = data;
data1220drivers/sound/dmasound.csound.data = data;
data1318drivers/sound/dmasound.cu_long data;
data1326drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1327drivers/sound/dmasound.c*high = data>>8;
data1328drivers/sound/dmasound.c*low = (data>>2) & 0x3f;
data1339drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1340drivers/sound/dmasound.c*lefth = data>>8;
data1341drivers/sound/dmasound.c*leftl = (data>>2) & 0x3f;
data1342drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1343drivers/sound/dmasound.c*righth = data>>8;
data1344drivers/sound/dmasound.c*rightl = (data>>2) & 0x3f;
data1357drivers/sound/dmasound.cu_long data;
data1365drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8000;
data1366drivers/sound/dmasound.c*high = data>>8;
data1367drivers/sound/dmasound.c*low = (data>>2) & 0x3f;
data1378drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8000;
data1379drivers/sound/dmasound.c*lefth = data>>8;
data1380drivers/sound/dmasound.c*leftl = (data>>2) & 0x3f;
data1381drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++) ^ 0x8000;
data1382drivers/sound/dmasound.c*righth = data>>8;
data1383drivers/sound/dmasound.c*rightl = (data>>2) & 0x3f;
data1396drivers/sound/dmasound.cu_long data;
data1404drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1405drivers/sound/dmasound.cdata = le2be16(data);
data1406drivers/sound/dmasound.c*high = data>>8;
data1407drivers/sound/dmasound.c*low = (data>>2) & 0x3f;
data1418drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1419drivers/sound/dmasound.cdata = le2be16(data);
data1420drivers/sound/dmasound.c*lefth = data>>8;
data1421drivers/sound/dmasound.c*leftl = (data>>2) & 0x3f;
data1422drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1423drivers/sound/dmasound.cdata = le2be16(data);
data1424drivers/sound/dmasound.c*righth = data>>8;
data1425drivers/sound/dmasound.c*rightl = (data>>2) & 0x3f;
data1438drivers/sound/dmasound.cu_long data;
data1446drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1447drivers/sound/dmasound.cdata = le2be16(data) ^ 0x8000;
data1448drivers/sound/dmasound.c*high = data>>8;
data1449drivers/sound/dmasound.c*low = (data>>2) & 0x3f;
data1460drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1461drivers/sound/dmasound.cdata = le2be16(data) ^ 0x8000;
data1462drivers/sound/dmasound.c*lefth = data>>8;
data1463drivers/sound/dmasound.c*leftl = (data>>2) & 0x3f;
data1464drivers/sound/dmasound.cdata = get_user(((u_short *)userPtr)++);
data1465drivers/sound/dmasound.cdata = le2be16(data) ^ 0x8000;
data1466drivers/sound/dmasound.c*righth = data>>8;
data1467drivers/sound/dmasound.c*rightl = (data>>2) & 0x3f;
data43drivers/sound/gus_midi.cstatic void     (*midi_input_intr) (int dev, unsigned char data);
data59drivers/sound/gus_midi.cvoid            (*input) (int dev, unsigned char data),
data271drivers/sound/gus_midi.cvolatile unsigned char stat, data;
data282drivers/sound/gus_midi.cdata = inb (u_MidiData);
data284drivers/sound/gus_midi.cmidi_input_intr (my_dev, data);
data181drivers/sound/gus_wave.cstatic void     gus_poke (long addr, unsigned char data);
data225drivers/sound/gus_wave.cgus_poke (long addr, unsigned char data)
data237drivers/sound/gus_wave.coutb (data, u_DRAMIO);
data262drivers/sound/gus_wave.cgus_write8 (int reg, unsigned int data)
data270drivers/sound/gus_wave.coutb ((unsigned char) (data & 0xff), u_DataHi);
data306drivers/sound/gus_wave.cgus_write16 (int reg, unsigned int data)
data315drivers/sound/gus_wave.coutb ((unsigned char) (data & 0xff), u_DataLo);
data316drivers/sound/gus_wave.coutb ((unsigned char) ((data >> 8) & 0xff), u_DataHi);
data1520drivers/sound/gus_wave.csizeof_patch = (long) &patch.data[0] - (long) &patch;    /* Header size */
data1667drivers/sound/gus_wave.cunsigned char   data;
data1672drivers/sound/gus_wave.cdata = get_fs_byte (&((addr)[sizeof_patch + i]));
data1676drivers/sound/gus_wave.cdata ^= 0x80;  /* Convert to signed */
data1677drivers/sound/gus_wave.cgus_poke (target + i, data);
data2559drivers/sound/gus_wave.crec->data.data8[i] = 0;
data2563drivers/sound/gus_wave.crec->data.data8[i]++;
data2578drivers/sound/gus_wave.crec->data.data32[n++] = ptr;
data2594drivers/sound/gus_wave.cmemcpy (rec->data.data8, (char *) &samples[ptr],
data2597drivers/sound/gus_wave.cpat = (struct patch_info *) rec->data.data8;
data2614drivers/sound/gus_wave.cpat = (struct patch_info *) rec->data.data8;
data2621drivers/sound/gus_wave.cmemcpy ((char *) &samples[ptr], rec->data.data8,
data2647drivers/sound/gus_wave.cif (l > sizeof (rec->data.data8))
data2648drivers/sound/gus_wave.cl = sizeof (rec->data.data8);
data2660drivers/sound/gus_wave.crec->data.data8[n] = gus_peek (offs++);
data2692drivers/sound/gus_wave.cif (l > sizeof (rec->data.data8))
data2693drivers/sound/gus_wave.cl = sizeof (rec->data.data8);
data2705drivers/sound/gus_wave.cgus_poke (offs++, rec->data.data8[n]);
data56drivers/sound/mad16_sb_midi.cvoid            (*midi_input_intr) (int dev, unsigned char data);
data98drivers/sound/mad16_sb_midi.cunsigned char   data;
data107drivers/sound/mad16_sb_midi.cdata = inb (DSP_READ);
data109drivers/sound/mad16_sb_midi.cmidi_input_intr (my_dev, data);
data203drivers/sound/mad16_sb_midi.cvoid            (*input) (int dev, unsigned char data),
data128drivers/sound/maui.cmaui_write (unsigned char data)
data132drivers/sound/maui.coutb (data, HOST_DATA_PORT);
data306drivers/sound/maui.cint             hdr_size = (unsigned long) &header.data[0] - (unsigned long) &header;
data344drivers/sound/maui.cunsigned char   data;
data346drivers/sound/maui.cdata = get_fs_byte (&((addr)[hdr_size + i]));
data347drivers/sound/maui.cif (i == 0 && !(data & 0x80))
data350drivers/sound/maui.cif (maui_write (data) == -1)
data114drivers/sound/midi_synth.cmidi_outc (int midi_dev, int data)
data119drivers/sound/midi_synth.cif (midi_devs[midi_dev]->putc (midi_dev, (unsigned char) (data & 0xff)))
data121drivers/sound/midi_synth.cif (data & 0x80)  /*
data125drivers/sound/midi_synth.c(unsigned char) (data & 0xff);  /*
data149drivers/sound/midi_synth.cmidi_synth_input (int orig_dev, unsigned char data)
data170drivers/sound/midi_synth.cif (data == 0xfe)    /* Ignore active sensing */
data179drivers/sound/midi_synth.cif (data & 0x80)    /* MIDI status byte */
data181drivers/sound/midi_synth.cif ((data & 0xf0) == 0xf0)  /* Common message */
data183drivers/sound/midi_synth.cswitch (data)
data194drivers/sound/midi_synth.cinc->m_buf[0] = data;
data201drivers/sound/midi_synth.cinc->m_buf[0] = data;
data205drivers/sound/midi_synth.cinc->m_buf[0] = data;
data216drivers/sound/midi_synth.cinc->m_left = len_tab[(data >> 4) - 8];
data217drivers/sound/midi_synth.cinc->m_buf[0] = inc->m_prev_status = data;
data224drivers/sound/midi_synth.cinc->m_left = len_tab[(data >> 4) - 8] - 1;
data226drivers/sound/midi_synth.cinc->m_buf[1] = data;
data231drivers/sound/midi_synth.cinc->m_buf[inc->m_ptr++] = data;
data241drivers/sound/midi_synth.cif (data == 0xf7)    /* Sysex end */
data251drivers/sound/midi_synth.c(int) data);
data512drivers/sound/midi_synth.cint             hdr_size = (unsigned long) &sysex.data[0] - (unsigned long) &sysex;
data554drivers/sound/midi_synth.cunsigned char   data;
data556drivers/sound/midi_synth.cdata = get_fs_byte (&((addr)[hdr_size + i]));
data558drivers/sound/midi_synth.ceox_seen = (i > 0 && data & 0x80);  /* End of sysex */
data560drivers/sound/midi_synth.cif (eox_seen && data != 0xf7)
data561drivers/sound/midi_synth.cdata = 0xf7;
data565drivers/sound/midi_synth.cif (data != 0xf0)
data572drivers/sound/midi_synth.cwhile (!midi_devs[orig_dev]->putc (orig_dev, (unsigned char) (data & 0xff)) &&
data592drivers/sound/midi_synth.cif (!first_byte && data & 0x80)
data82drivers/sound/midibuf.c#define QUEUE_BYTE(q, data) \
data87drivers/sound/midibuf.cq->queue[q->tail] = (data); \
data92drivers/sound/midibuf.c#define REMOVE_BYTE(q, data) \
data97drivers/sound/midibuf.cdata = q->queue[q->head]; \
data133drivers/sound/midibuf.cmidi_input_intr (int dev, unsigned char data)
data138drivers/sound/midibuf.cif (data == 0xfe)    /*
data147drivers/sound/midibuf.cQUEUE_BYTE (midi_in_buf[dev], data);
data82drivers/sound/mpu401.cvoid            (*inputintr) (int dev, unsigned char data);
data503drivers/sound/mpu401.cvoid            (*input) (int dev, unsigned char data),
data688drivers/sound/mpu401.cif (!mpu401_out (dev, cmd->data[i]))
data697drivers/sound/mpu401.ccmd->data[0] = 0;
data706drivers/sound/mpu401.ccmd->data[i] = read_data (devc);
data724drivers/sound/mpu401.cmpu_cmd (int dev, int cmd, int data)
data733drivers/sound/mpu401.crec.data[0] = data & 0xff;
data739drivers/sound/mpu401.creturn (unsigned char) rec.data[0];
data528drivers/sound/opl3.cunsigned char   data, fpc;
data712drivers/sound/opl3.cdata = fnum & 0xff;    /*
data715drivers/sound/opl3.copl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
data717drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);
data718drivers/sound/opl3.cdevc->voc[voice].keyon_byte = data;
data719drivers/sound/opl3.copl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
data721drivers/sound/opl3.copl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num + 3, data);
data994drivers/sound/opl3.cunsigned char   data;
data1016drivers/sound/opl3.cdata = fnum & 0xff;    /*
data1019drivers/sound/opl3.copl3_command (map->ioaddr, FNUM_LOW + map->voice_num, data);
data1021drivers/sound/opl3.cdata = 0x20 | ((block & 0x7) << 2) | ((fnum >> 8) & 0x3);  /*
data1029drivers/sound/opl3.cdevc->voc[voice].keyon_byte = data;
data1030drivers/sound/opl3.copl3_command (map->ioaddr, KEYON_BLOCK + map->voice_num, data);
data64drivers/sound/pas2_card.cextern void     mix_write (unsigned char data, int ioaddr);
data73drivers/sound/pas2_card.cpas_write (unsigned char data, int ioaddr)
data75drivers/sound/pas2_card.coutb (data, ioaddr ^ translat_code);
data46drivers/sound/pas2_midi.cstatic void     (*midi_input_intr) (int dev, unsigned char data);
data50drivers/sound/pas2_midi.cvoid            (*input) (int dev, unsigned char data),
data74drivers/sound/pas2_mixer.cmix_write (unsigned char data, int ioaddr)
data86drivers/sound/pas2_mixer.coutw (data | (data << 8), (ioaddr ^ translat_code) - 1);
data90drivers/sound/pas2_mixer.cpas_write (data, ioaddr);
data480drivers/sound/pss.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
data483drivers/sound/pss.cif (!pss_download_boot (devc, buf->data, buf->len, buf->flags))
data527drivers/sound/pss.cunsigned short *data;
data536drivers/sound/pss.cdata = (unsigned short *) (buf->data);
data543drivers/sound/pss.cif (!pss_put_dspword (devc, *data++))
data567drivers/sound/pss.cunsigned short *data;
data578drivers/sound/pss.cdata = (unsigned short *) buf->data;
data583drivers/sound/pss.cfor (i = 0; i < sizeof(buf->data); i++)
data585drivers/sound/pss.cif (!pss_get_dspword (devc, data++))
data593drivers/sound/pss.cif( i==sizeof(buf->data) )
data621drivers/sound/sb16_dsp.cint             data;
data623drivers/sound/sb16_dsp.cdata = inb (DSP_DATA_AVL16);  /*
data83drivers/sound/sb16_midi.cstatic void     (*midi_input_intr) (int dev, unsigned char data);
data119drivers/sound/sb16_midi.cvoid            (*input) (int dev, unsigned char data),
data152drivers/sound/sb_dsp.cess_write (unsigned char reg, unsigned char data)
data159drivers/sound/sb_dsp.creturn sb_dsp_command (data);
data68drivers/sound/sb_midi.cvoid            (*midi_input_intr) (int dev, unsigned char data);
data72drivers/sound/sb_midi.cvoid            (*input) (int dev, unsigned char data),
data206drivers/sound/sb_midi.cunsigned char   data;
data211drivers/sound/sb_midi.cdata = inb (DSP_READ);
data213drivers/sound/sb_midi.cmidi_input_intr (my_dev, data);
data212drivers/sound/sequencer.csequencer_midi_input (int dev, unsigned char data)
data217drivers/sound/sequencer.cif (data == 0xfe)    /* Ignore active sensing */
data230drivers/sound/sequencer.cevent_rec[1] = data;
data1378drivers/sound/sequencer.cmidi_outc (int dev, unsigned char data)
data1397drivers/sound/sequencer.cwhile (n && !midi_devs[dev]->putc (dev, data))
data150drivers/sound/sound_calls.hvoid pas_write(unsigned char data, int ioaddr);
data177drivers/sound/sound_calls.hvoid gus_write8(int reg, unsigned int data);
data143drivers/sound/sscape.csscape_write (struct sscape_info *devc, int reg, int data)
data150drivers/sound/sscape.coutb (data, PORT (ODIE_DATA));
data167drivers/sound/sscape.chost_write (struct sscape_info *devc, unsigned char *data, int count)
data191drivers/sound/sscape.coutb (data[i], PORT (HOST_DATA));
data205drivers/sound/sscape.cunsigned char   data;
data224drivers/sound/sscape.cdata = inb (PORT (HOST_DATA));
data228drivers/sound/sscape.creturn data;
data638drivers/sound/sscape.cif (buf->len <= 0 || buf->len > sizeof (buf->data))
data641drivers/sound/sscape.cif (!sscape_download_boot (devc, buf->data, buf->len, buf->flags))
data60drivers/sound/trix.ctrix_write (int addr, int data)
data63drivers/sound/trix.coutb ((unsigned char) data, 0x391);  /* MT-0002-PC ASIC data */
data80drivers/sound/uart6850.cstatic void     (*midi_input_intr) (int dev, unsigned char data);
data150drivers/sound/uart6850.cvoid            (*input) (int dev, unsigned char data),
data30fs/affs/amigaffs.cint affs_get_key_entry (int bsize, void *data, int entry_pos)
data32fs/affs/amigaffs.cstruct dir_front *dir_front = (struct dir_front *)data;
data118fs/affs/amigaffs.cint affs_checksum_block (int bsize, void *data, int *ptype, int *stype)
data121fs/affs/amigaffs.c*ptype = swap_long (((long *) data)[0]);
data123fs/affs/amigaffs.c*stype = swap_long (((long *) data)[bsize / 4 - 1]);
data127fs/affs/file.cvoid *data;
data152fs/affs/file.cbh = affs_pread (inode, sector, &data);
data157fs/affs/file.cmemcpy_tofs (buf, data + offset, size);
data131fs/affs/inode.cstruct super_block *affs_read_super(struct super_block *s,void *data,
data143fs/affs/inode.cif (!parse_options((char *) data, optp)) {
data863fs/binfmt_elf.cvoid *data;
data914fs/binfmt_elf.cDUMP_WRITE(men->data, men->datasz);
data1049fs/binfmt_elf.cnotes[0].data = &prstatus;
data1081fs/binfmt_elf.cnotes[1].data = &psinfo;
data1110fs/binfmt_elf.cnotes[2].data = current;
data1123fs/binfmt_elf.cnotes[3].data = &fpu;
data105fs/buffer.cunsigned int data[N_PARAM];
data1951fs/buffer.casmlinkage int sys_bdflush(int func, long data)
data1967fs/buffer.cerror = verify_area(VERIFY_WRITE, (void *) data, sizeof(int));
data1970fs/buffer.cput_user(bdf_prm.data[i], (int*)data);
data1973fs/buffer.cif (data < bdflush_min[i] || data > bdflush_max[i])
data1975fs/buffer.cbdf_prm.data[i] = data;
data60fs/ext/inode.cstruct super_block *ext_read_super(struct super_block *s,void *data, 
data365fs/ext2/super.cstruct super_block * ext2_read_super (struct super_block * sb, void * data,
data379fs/ext2/super.cif (!parse_options ((char *) data, &sb_block, &resuid, &resgid,
data623fs/ext2/super.cint ext2_remount (struct super_block * sb, int * flags, char * data)
data635fs/ext2/super.cif (!parse_options (data, &tmp, &resuid, &resgid,
data216fs/fat/file.cchar *data;
data236fs/fat/file.cdata = bh->b_data + offset;
data240fs/fat/file.cmemcpy_tofs(buf,data,size);
data245fs/fat/file.cchar ch = *data++;
data189fs/fat/inode.cstruct super_block *fat_read_super(struct super_block *sb,void *data, int silent)
data205fs/fat/inode.cif (!parse_options((char *) data, &fat, &blksize, &debug, &opts)
data340fs/fat/misc.cdone = !strncmp(data[entry].name,name,MSDOS_NAME) && \
data341fs/fat/misc.c!(data[entry].attr & ATTR_VOLUME);
data344fs/fat/misc.cdone = !IS_FREE(data[entry].name) && CF_LE_W(data[entry].start) == *number;
data348fs/fat/misc.cdone = IS_FREE(data[entry].name); \
data362fs/fat/misc.cif (!IS_FREE(data[entry].name) && (data[entry].attr & ATTR_DIR)) \
data371fs/fat/misc.cstruct msdos_dir_entry *data;
data376fs/fat/misc.cdata = (struct msdos_dir_entry *) bh->b_data;
data382fs/fat/misc.cdone = (data[entry].attr & ATTR_HIDDEN)
data395fs/fat/misc.cstart = CF_LE_W(data[entry].start);
data399fs/fat/misc.c*res_de = &data[entry];
data233fs/hpfs/hpfs_fs.cvoid *data;
data774fs/hpfs/hpfs_fs.cstatic int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
data1690fs/hpfs/hpfs_fs.cchar *data;
data1697fs/hpfs/hpfs_fs.cqbh->data = data = kmalloc(2048, GFP_KERNEL);
data1698fs/hpfs/hpfs_fs.cif (!data)
data1704fs/hpfs/hpfs_fs.cmemcpy(data, bh->b_data, 512);
data1709fs/hpfs/hpfs_fs.cmemcpy(data + 512, bh->b_data, 512);
data1714fs/hpfs/hpfs_fs.cmemcpy(data + 2 * 512, bh->b_data, 512);
data1719fs/hpfs/hpfs_fs.cmemcpy(data + 3 * 512, bh->b_data, 512);
data1721fs/hpfs/hpfs_fs.creturn data;
data1730fs/hpfs/hpfs_fs.ckfree_s(data, 2048);
data1744fs/hpfs/hpfs_fs.ckfree_s(qbh->data, 2048);
data197fs/isofs/inode.cstruct super_block *isofs_read_super(struct super_block *s,void *data,
data220fs/isofs/inode.cif (!parse_options((char *) data,&opt)) {
data292fs/isofs/rock.cfor(p=0;p<rr->u.ER.len_id;p++) printk("%c",rr->u.ER.data[p]);
data22fs/isofs/rock.hchar data[0];
data86fs/minix/inode.cint minix_remount (struct super_block * sb, int * flags, char * data)
data164fs/minix/inode.cstruct super_block *minix_read_super(struct super_block *s,void *data, 
data57fs/msdos/namei.cstruct super_block *msdos_read_super(struct super_block *sb,void *data, int silent)
data64fs/msdos/namei.cres =  fat_read_super(sb, data, silent);
data160fs/ncpfs/inode.cstruct ncp_mount_data *data = (struct ncp_mount_data *) raw_data;
data168fs/ncpfs/inode.cif (data == NULL)
data175fs/ncpfs/inode.cif (data->version != NCP_MOUNT_VERSION)
data178fs/ncpfs/inode.c(data->version < NCP_MOUNT_VERSION) ?
data184fs/ncpfs/inode.cif (   (data->ncp_fd >= NR_OPEN)
data185fs/ncpfs/inode.c|| ((ncp_filp = current->files->fd[data->ncp_fd]) == NULL)
data193fs/ncpfs/inode.cif (   (data->wdog_fd >= NR_OPEN)
data194fs/ncpfs/inode.c|| ((wdog_filp = current->files->fd[data->wdog_fd]) == NULL)
data202fs/ncpfs/inode.cif (   (data->message_fd >= NR_OPEN)
data203fs/ncpfs/inode.c|| ((msg_filp = current->files->fd[data->message_fd]) == NULL)
data244fs/ncpfs/inode.cserver->m = *data;
data71fs/ncpfs/ioctl.cif ((result = verify_area(VERIFY_WRITE, (char *)request.data,
data84fs/ncpfs/ioctl.cmemcpy_fromfs(server->packet, request.data, request.size);
data90fs/ncpfs/ioctl.cmemcpy_tofs(request.data, server->packet, server->reply_size);
data148fs/ncpfs/sock.csk   = (struct sock *)(sock->data);
data199fs/ncpfs/sock.csk = (struct sock *)(sock->data);
data291fs/ncpfs/sock.csk = (struct sock *)(sock->data);
data602fs/ncpfs/sock.c*(__u16 *)&(h->data[0]) = request_size - 2;
data105fs/nfs/inode.cstruct nfs_mount_data *data = (struct nfs_mount_data *) raw_data;
data113fs/nfs/inode.cif (!data) {
data119fs/nfs/inode.cfd = data->fd;
data120fs/nfs/inode.cif (data->version != NFS_MOUNT_VERSION) {
data122fs/nfs/inode.cdata->version < NFS_MOUNT_VERSION ? "older" : "newer");
data148fs/nfs/inode.cserver->flags = data->flags;
data149fs/nfs/inode.cserver->rsize = data->rsize;
data154fs/nfs/inode.cserver->wsize = data->wsize;
data159fs/nfs/inode.cserver->timeo = data->timeo*HZ/10;
data160fs/nfs/inode.cserver->retrans = data->retrans;
data161fs/nfs/inode.cserver->acregmin = data->acregmin*HZ;
data162fs/nfs/inode.cserver->acregmax = data->acregmax*HZ;
data163fs/nfs/inode.cserver->acdirmin = data->acdirmin*HZ;
data164fs/nfs/inode.cserver->acdirmax = data->acdirmax*HZ;
data165fs/nfs/inode.cstrcpy(server->hostname, data->hostname);
data169fs/nfs/inode.cif (data->addr.sin_addr.s_addr == INADDR_ANY) {  /* No address passed */
data188fs/nfs/inode.cmemcpy((char *)&(server->toaddr),(char *)(&data->addr),sizeof(server->toaddr));
data198fs/nfs/inode.csb->u.nfs_sb.s_root = data->root;
data200fs/nfs/inode.cif (!(sb->s_mounted = nfs_fhget(sb, &data->root, NULL))) {
data724fs/nfs/nfsroot.c((struct sock *) bootp_xmit_sock->data) -> broadcast = 1;
data725fs/nfs/nfsroot.c((struct sock *) bootp_xmit_sock->data) -> reuse = 1;
data726fs/nfs/nfsroot.c((struct sock *) bootp_recv_sock->data) -> reuse = 1;
data145fs/nfs/proc.cstatic inline int *xdr_encode_data(int *p, const char *data, int len)
data151fs/nfs/proc.cmemcpy_fromfs(p, data, len);
data155fs/nfs/proc.cstatic inline int *xdr_decode_data(int *p, char *data, int *lenp, int maxlen)
data160fs/nfs/proc.cmemcpy(data, p, len);
data374fs/nfs/proc.cint offset, int count, char *data, struct nfs_fattr *fattr)
data398fs/nfs/proc.cif (!(p = xdr_decode_data(p, data, &len, count))) {
data494fs/nfs/proc.cint count, const char *data, struct nfs_fattr *fattr)
data513fs/nfs/proc.cp = xdr_encode_data(p, data, count);
data540fs/nfs/rpcsock.csk = (struct sock *) sock->data;
data553fs/proc/array.cunsigned long data = 0, stack = 0;
data559fs/proc/array.cdata += len;
data584fs/proc/array.cdata - stack, stack,
data98fs/proc/inode.cstruct super_block *proc_read_super(struct super_block *s,void *data, 
data113fs/proc/inode.cparse_options(data, &s->s_mounted->i_uid, &s->s_mounted->i_gid);
data175fs/smbfs/inode.cstruct smb_mount_data *data = (struct smb_mount_data *) raw_data;
data183fs/smbfs/inode.cif (!data) {
data188fs/smbfs/inode.cfd = data->fd;
data189fs/smbfs/inode.cif (data->version != SMB_MOUNT_VERSION) {
data191fs/smbfs/inode.c(data->version < SMB_MOUNT_VERSION) ?
data231fs/smbfs/inode.cserver->max_xmit = data->max_xmit;
data239fs/smbfs/inode.cserver->m = *data;
data47fs/smbfs/proc.csmb_encode_word(byte *p, word data)
data50fs/smbfs/proc.c*((word *)p) = data;
data52fs/smbfs/proc.cp[0] = data & 0x00ffU;
data53fs/smbfs/proc.cp[1] = (data & 0xff00U) >> 8;
data60fs/smbfs/proc.csmb_decode_word(byte *p, word *data)
data63fs/smbfs/proc.c*data = *(word *)p;
data65fs/smbfs/proc.c*data = (word) p[0] | p[1] << 8;
data98fs/smbfs/proc.csmb_encode_vblock(byte *p, const byte *data, word len, int fs)
data103fs/smbfs/proc.cmemcpy_fromfs(p, data, len);
data105fs/smbfs/proc.cmemcpy(p, data, len);
data110fs/smbfs/proc.csmb_decode_data(byte *p, byte *data, word *data_len, int fs)
data123fs/smbfs/proc.cmemcpy_tofs(data, p, len);
data125fs/smbfs/proc.cmemcpy(data, p, len);
data615fs/smbfs/proc.coff_t offset, long count, char *data, int fs)
data635fs/smbfs/proc.csmb_decode_data(SMB_BUF(server->packet), data, &data_len, fs);
data653fs/smbfs/proc.coff_t offset, long count, char *data)
data670fs/smbfs/proc.cresult = smb_request_read_raw(server, data, count);
data677fs/smbfs/proc.coff_t offset, int count, const char *data)
data691fs/smbfs/proc.cmemcpy_fromfs(p+2, data, count);
data705fs/smbfs/proc.coff_t offset, long count, const char *data)
data735fs/smbfs/proc.cresult = smb_request_write_raw(server, data, count);
data132fs/smbfs/sock.csk   = (struct sock *)(sock->data);
data179fs/smbfs/sock.csk   = (struct sock *)(sock->data);
data326fs/smbfs/sock.cchar **data, char **param)
data356fs/smbfs/sock.cif ((*data  = smb_kmalloc(total_data, GFP_KERNEL)) == NULL) {
data363fs/smbfs/sock.csmb_kfree_s(*data, total_data);
data389fs/smbfs/sock.cmemcpy(*data + WVAL(inbuf,smb_drdisp),
data429fs/smbfs/sock.csmb_kfree_s(*data, 0);  *data = NULL;
data559fs/smbfs/sock.cchar **data, char **param)
data599fs/smbfs/sock.cdata, param);
data53fs/super.cstatic int do_remount_sb(struct super_block *sb, int flags, char * data);
data503fs/super.cvoid *data, int silent)
data527fs/super.cif (!type->read_super(s,data, silent)) {
data694fs/super.cint do_mount(kdev_t dev, const char * dev_name, const char * dir_name, const char * type, int flags, void * data)
data719fs/super.csb = read_super(dev,type,flags,data,0);
data745fs/super.cstatic int do_remount_sb(struct super_block *sb, int flags, char *data)
data758fs/super.cretval = sb->s_op->remount_fs(sb, &flags, data);
data770fs/super.cstatic int do_remount(const char *dir,int flags,char *data)
data782fs/super.cretval = do_remount_sb(dir_i->i_sb, flags, data);
data787fs/super.cstatic int copy_mount_options (const void * data, unsigned long *where)
data794fs/super.cif (!data)
data797fs/super.cvma = find_vma(current, (unsigned long) data);
data798fs/super.cif (!vma || (unsigned long) data < vma->vm_start)
data802fs/super.ci = vma->vm_end - (unsigned long) data;
data808fs/super.cmemcpy_fromfs((void *) page,data,i);
data828fs/super.cunsigned long new_flags, void * data)
data843fs/super.cretval = copy_mount_options (data, &page);
data903fs/super.cretval = copy_mount_options(data, &page);
data339fs/sysv/inode.cstruct super_block *sysv_read_super(struct super_block *sb,void *data, 
data28fs/ufs/ufs_super.cstruct super_block * ufs_read_super(struct super_block * sb, void * data, int silent);
data95fs/ufs/ufs_super.cufs_read_super(struct super_block * sb, void * data, int silent)
data385fs/umsdos/inode.cvoid *data,
data403fs/umsdos/inode.csb = msdos_read_super(s,data,silent);
data59fs/umsdos/ioctl.cunsigned long data)
data72fs/umsdos/ioctl.cif ((err = verify_area(VERIFY_WRITE,(void*)data,sizeof(struct umsdos_ioctl))) < 0) {
data76fs/umsdos/ioctl.cstruct umsdos_ioctl *idata = (struct umsdos_ioctl *)data;
data189fs/umsdos/ioctl.cstruct umsdos_ioctl data;
data190fs/umsdos/ioctl.cmemcpy_fromfs (&data,idata,sizeof(data));
data203fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
data204fs/umsdos/ioctl.c,sizeof(data.umsdos_dirent));
data205fs/umsdos/ioctl.cumsdos_parse (data.umsdos_dirent.name
data206fs/umsdos/ioctl.c,data.umsdos_dirent.name_len,&info);
data220fs/umsdos/ioctl.c,data.dos_dirent.d_name,data.dos_dirent.d_reclen
data222fs/umsdos/ioctl.c,data.umsdos_dirent.name,data.umsdos_dirent.name_len);
data235fs/umsdos/ioctl.cmemcpy (&info.entry,&data.umsdos_dirent
data236fs/umsdos/ioctl.c,sizeof(data.umsdos_dirent));
data237fs/umsdos/ioctl.cumsdos_parse (data.umsdos_dirent.name
data238fs/umsdos/ioctl.c,data.umsdos_dirent.name_len,&info);
data240fs/umsdos/ioctl.c,S_ISDIR(data.umsdos_dirent.mode));
data250fs/umsdos/ioctl.cret = msdos_unlink (dir,data.dos_dirent.d_name
data251fs/umsdos/ioctl.c,data.dos_dirent.d_reclen);
data261fs/umsdos/ioctl.cret = msdos_rmdir (dir,data.dos_dirent.d_name
data262fs/umsdos/ioctl.c,data.dos_dirent.d_reclen);
data275fs/umsdos/ioctl.cret = umsdos_real_lookup (dir,data.dos_dirent.d_name
data276fs/umsdos/ioctl.c,data.dos_dirent.d_reclen,&inode);
data278fs/umsdos/ioctl.cdata.stat.st_ino = inode->i_ino;
data279fs/umsdos/ioctl.cdata.stat.st_mode = inode->i_mode;
data280fs/umsdos/ioctl.cdata.stat.st_size = inode->i_size;
data281fs/umsdos/ioctl.cdata.stat.st_atime = inode->i_atime;
data282fs/umsdos/ioctl.cdata.stat.st_ctime = inode->i_ctime;
data283fs/umsdos/ioctl.cdata.stat.st_mtime = inode->i_mtime;
data284fs/umsdos/ioctl.cmemcpy_tofs (&idata->stat,&data.stat,sizeof(data.stat));
data307fs/umsdos/ioctl.cdir->i_sb->u.msdos_sb.options.fs_uid = data.umsdos_dirent.uid;
data308fs/umsdos/ioctl.cdir->i_sb->u.msdos_sb.options.fs_gid = data.umsdos_dirent.gid;
data309fs/umsdos/ioctl.cdir->i_sb->u.msdos_sb.options.fs_umask = data.umsdos_dirent.mode;
data130fs/vfat/namei.cstruct super_block *vfat_read_super(struct super_block *sb,void *data,
data138fs/vfat/namei.cres = fat_read_super(sb, data, silent);
data145fs/vfat/namei.cif (!parse_options((char *) data, &(MSDOS_SB(sb)->options))) {
data62fs/xiafs/inode.cstruct super_block *xiafs_read_super(struct super_block *s, void *data,
data204include/asm-alpha/io.h#define eth_io_copy_and_sum(skb,src,len,unused)  memcpy_fromio((skb)->data,(src),(len))
data11include/asm-m68k/atari_stdma.hvoid stdma_lock(isrfunc isr, void *data); 
data441include/asm-m68k/atarihw.hu_char  data;
data572include/asm-m68k/atarihw.hu_short  data;
data21include/asm-m68k/font.hextern int findsoftfont(char *name, int *width, int *height, u_char *data[]);
data29include/asm-m68k/font.hint *height, u_char *data[]);
data57include/asm-m68k/irq.htypedef void (*isrfunc) (int irq, struct pt_regs * regs, void *data);
data68include/asm-m68k/irq.hvoid            *data;
data93include/asm-m68k/irq.h*data, char *name);
data12include/asm-m68k/machdep.htypedef void (*isrfunc) (int irq, struct pt_regs *fp, void *data);
data22include/asm-m68k/machdep.hint pri, void *data, char *name);
data136include/asm-mips/asm.h.data;                          \
data146include/asm-mips/asm.h.data;                                  \
data101include/asm-mips/jazz.hunsigned char data;
data107include/asm-mips/jazz.hunsigned char data;
data96include/asm-mips/pica.hunsigned char data;
data102include/asm-mips/pica.hunsigned char data;
data48include/asm-sparc/cache.hunsigned int *data)
data60include/asm-sparc/cache.hdata[0] = value1; data[1] = value2;
data64include/asm-sparc/cache.hunsigned int *data)
data70include/asm-sparc/cache.hvalue1 = data[0]; value2 = data[1];
data150include/asm-sparc/viking.hunsigned long *data)
data162include/asm-sparc/viking.hdata[0] = info;
data163include/asm-sparc/viking.hdata[1] = page;
data50include/linux/affs_fs.hextern int affs_get_key_entry (int bsize, void *data, int entry_pos);
data55include/linux/affs_fs.hextern int affs_checksum_block (int bsize, void *data, int *ptype, int *stype);
data52include/linux/blkdev.hextern void unplug_device(void * data);
data311include/linux/cdk.hunsigned long  data;
data348include/linux/cdk.hunsigned long  data;
data247include/linux/fb.hu_char data[1];                 /* field with [height][width]        */
data340include/linux/fd.hvoid *data;
data11include/linux/if_wic.hunsigned char  data[120];
data45include/linux/ip.h__u32  data[9];
data17include/linux/iso_fs.hchar data[ISODCL(8,2048)];
data70include/linux/iso_fs.hchar data[ISODCL(16,2048)];
data121include/linux/minix_fs.hextern int minix_remount (struct super_block * sb, int * flags, char * data);
data206include/linux/msdos_fs.hextern struct super_block *fat_read_super(struct super_block *s, void *data, int silent);
data241include/linux/msdos_fs.hextern struct super_block *msdos_read_super(struct super_block *sb,void *data, int silent);
data28include/linux/ncp.h__u8    data[0]   __attribute__ ((packed));
data42include/linux/ncp.h__u8    data[0]          __attribute__ ((packed));
data26include/linux/ncp_fs.hchar          *data;
data76include/linux/net.hvoid      *data;    /* protocol data    */
data46include/linux/net_alias.hvoid *data;      /* private data */
data116include/linux/net_alias.hextern struct device * net_alias_dev_get(char *dev_name, int aliasing_ok, int *err, struct sockaddr *sa, void *data);
data200include/linux/netdevice.hvoid      *data;
data121include/linux/nfs.hchar data[NFS_FHSIZE];
data71include/linux/nfs_fs.hint offset, int count, char *data,
data74include/linux/nfs_fs.hint count, const char *data, struct nfs_fattr *fattr);
data114include/linux/nfs_fs.hvoid *data,int);
data180include/linux/proc_fs.hvoid *data;
data134include/linux/scc.hunsigned char data[0];  /* anchor for allocated buffer */
data240include/linux/scc.hio_port  data;    /* I/O address of DATA register */
data61include/linux/sdla.hvoid *data;
data305include/linux/sdla.hchar  data[SDLA_MAX_DATA]  __attribute__((packed));  /* transfer data buffer */
data110include/linux/skbuff.hunsigned char  *data;      /* Data head pointer        */
data401include/linux/skbuff.hskb->data-=len;
data403include/linux/skbuff.hif(skb->data<skb->head)
data405include/linux/skbuff.hreturn skb->data;
data412include/linux/skbuff.hskb->data+=len;
data414include/linux/skbuff.hreturn skb->data;
data419include/linux/skbuff.hreturn skb->data-skb->head;
data429include/linux/skbuff.hskb->data+=len;
data438include/linux/skbuff.hskb->tail=skb->data+len;
data129include/linux/smb_fs.hoff_t offset, long count, char *data, int fs);
data131include/linux/smb_fs.hoff_t offset, long count, char *data);
data133include/linux/smb_fs.hoff_t offset, int count, const char *data);
data135include/linux/smb_fs.hoff_t offset, long count, const char *data);
data174include/linux/smb_fs.hchar **data, char **param);
data12include/linux/smp.hextern void smp_message_pass(int target, int msg, unsigned long data, int wait);
data224include/linux/soundcard.hchar data[1];  /* The waveform data starts here */
data233include/linux/soundcard.hunsigned char data[1];  /* Sysex data starts here */
data306include/linux/soundcard.h} data;
data536include/linux/soundcard.hunsigned char data[30];
data667include/linux/soundcard.hunsigned char data[4000]; /* NOTE! 4000 is not 4k */
data680include/linux/soundcard.hunsigned char data[4000];
data965include/linux/soundcard.h_pm_info.device=dev, _pm_info.data.data8[0]=pgm, \
data969include/linux/soundcard.h_pm_info.device=dev, memcpy(_pm_info.data.data8, pgm, 128), \
data143include/linux/sysctl.hint rdwr, char *data, size_t max);
data146include/linux/sysctl.hint rdwr, int *data);
data149include/linux/sysctl.hint rdwr, void *data, size_t len);
data194include/linux/sysctl.hvoid *data;
data85include/linux/timer.hunsigned long data;
data46include/linux/tqueue.hvoid *data;      /* argument to function */
data134include/linux/tqueue.harg    = p -> data;
data42include/net/protocol.hvoid      *data;
data219ipc/msg.ckd_timer.data = (unsigned long)msgtyp;
data242kernel/fork.cp->real_timer.data = (unsigned long) p;
data390kernel/sched.ctimer.data = (unsigned long) prev;
data575kernel/sched.cunsigned long data = timer->data;
data580kernel/sched.cfn(data);
data314kernel/sysctl.cif (table->data && table->maxlen) {
data319kernel/sysctl.cmemcpy_tofs(oldval, table->data, len);
data326kernel/sysctl.cmemcpy_fromfs(table->data, newval, len);
data412kernel/sysctl.cde->data = (void *) table;
data463kernel/sysctl.cif (!de || !de->data)
data465kernel/sysctl.ctable = (struct ctl_table *) de->data;
data502kernel/sysctl.cif (!table->data || !table->maxlen || !*lenp ||
data516kernel/sysctl.cmemcpy_fromfs(table->data, buffer, len);
data517kernel/sysctl.c((char *) table->data)[len] = 0;
data520kernel/sysctl.clen = strlen(table->data) + 1;
data526kernel/sysctl.cmemcpy_tofs(buffer, table->data, len-1);
data546kernel/sysctl.cif (!table->data || !table->maxlen || !*lenp ||
data552kernel/sysctl.ci = (int *) table->data;
data621kernel/sysctl.cif (!table->data || !table->maxlen || !*lenp ||
data627kernel/sysctl.ci = (int *) table->data;
data730kernel/sysctl.cif (!table->data || !table->maxlen) 
data735kernel/sysctl.cl = strlen(table->data);
data739kernel/sysctl.cmemcpy_tofs(oldval, table->data, len);
data747kernel/sysctl.cmemcpy_fromfs(table->data, newval, len);
data750kernel/sysctl.c((char *) table->data)[len] = 0;
data794kernel/sysctl.cint rdwr, char *data, size_t max)
data796kernel/sysctl.cint l = strlen(data) + 1;
data805kernel/sysctl.cmemcpy_tofs(oldval, data, l);
data808kernel/sysctl.cmemcpy_fromfs(data, newval, newlen);
data809kernel/sysctl.cdata[newlen] = 0;
data816kernel/sysctl.cint rdwr, int *data)
data826kernel/sysctl.cmemcpy_tofs(oldval, data, sizeof(int));
data829kernel/sysctl.cmemcpy_fromfs(data, newval, sizeof(int));
data835kernel/sysctl.cint rdwr, void *data, size_t len)
data845kernel/sysctl.cmemcpy_tofs(oldval, data, len);
data848kernel/sysctl.cmemcpy_fromfs(data, newval, len);
data64net/802/p8022tr.colddata = skb->data;
data93net/802/tr.cstruct trh_hdr *trh=(struct trh_hdr *)skb->data;
data94net/802/tr.cstruct trllc *trllc=(struct trllc *)(skb->data+sizeof(struct trh_hdr));
data96net/802/tr.cskb->mac.raw = skb->data;
data439net/appletalk/aarp.cstruct ddpehdr *ddp=(struct ddpehdr *)skb->data;
data456net/appletalk/aarp.c*((__u16 *)skb->data)=htons(skb->len);
data465net/appletalk/aarp.cskb->data[0]=sa->s_node;
data466net/appletalk/aarp.cskb->data[1]=at->s_node;
data467net/appletalk/aarp.cskb->data[2]=ft;
data800net/appletalk/aarp.caarp_timer.data=0;
data205net/appletalk/ddp.cstatic void atalk_destroy_timer(unsigned long data)
data207net/appletalk/ddp.catalk_destroy_socket((atalk_socket *)data);
data233net/appletalk/ddp.csk->timer.data = (unsigned long)sk;
data975net/appletalk/ddp.cunsigned char *data=(unsigned char *)ddp;
data978net/appletalk/ddp.cdata+=4;  
data983net/appletalk/ddp.csum+=*data;
data990net/appletalk/ddp.cdata++;
data1022net/appletalk/ddp.csk=(atalk_socket *)sock->data;
data1062net/appletalk/ddp.csk=(atalk_socket *)sock->data;
data1163net/appletalk/ddp.csock->data=(void *)sk;
data1191net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data1197net/appletalk/ddp.csock->data=NULL;
data1245net/appletalk/ddp.csk=(atalk_socket *)sock->data;
data1297net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data1345net/appletalk/ddp.cif(newsock->data)
data1346net/appletalk/ddp.csk_free(newsock->data);
data1361net/appletalk/ddp.csk=(atalk_socket *)sock->data;
data1596net/appletalk/ddp.cddp=(struct ddpehdr *)skb->data;
data1622net/appletalk/ddp.cskb->h.raw = skb->data;
data1628net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data1787net/appletalk/ddp.cskb->mac.raw=skb->data;
data1788net/appletalk/ddp.cskb->h.raw = skb->data + ddp_dl->header_length + dev->hard_header_len;
data1815net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data1866net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data1879net/appletalk/ddp.catalk_socket *sk=(atalk_socket *)sock->data;
data401net/ax25/af_ax25.cstatic void ax25_destroy_timer(unsigned long data)
data403net/ax25/af_ax25.cax25_destroy_socket((ax25_cb *)data);
data442net/ax25/af_ax25.cax25->timer.data     = (unsigned long)ax25;
data882net/ax25/af_ax25.csk = (struct sock *)sock->data;
data970net/ax25/af_ax25.csk = (struct sock *)sock->data;
data1038net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data1126net/ax25/af_ax25.csock->data = (void *)sk;
data1221net/ax25/af_ax25.cstruct sock *sk = (struct sock *)oldsock->data;
data1228net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data1290net/ax25/af_ax25.csock->data = NULL;  
data1309net/ax25/af_ax25.csk = (struct sock *)sock->data;
data1367net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data1501net/ax25/af_ax25.cif (newsock->data)
data1502net/ax25/af_ax25.csk_free(newsock->data);
data1504net/ax25/af_ax25.cnewsock->data = NULL;
data1506net/ax25/af_ax25.csk = (struct sock *)sock->data;
data1541net/ax25/af_ax25.cnewsock->data = newsk;
data1554net/ax25/af_ax25.csk = (struct sock *)sock->data;
data1597net/ax25/af_ax25.cskb->h.raw = skb->data;
data1610net/ax25/af_ax25.cif (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type, &dama) == NULL) {
data1656net/ax25/af_ax25.cbuild_ax25_addr(skb->data, &src, &dest, &dp, type, MODULUS);
data1658net/ax25/af_ax25.cif (call_fw_firewall(PF_AX25, skb->dev, skb->data) != FW_ACCEPT) {
data1688net/ax25/af_ax25.cif ((*skb->data & ~0x10) == LAPB_UI) {  /* UI frame - bypass LAPB processing */
data1689net/ax25/af_ax25.cskb->h.raw = skb->data + 2;    /* skip control and pid */
data1692net/ax25/af_ax25.cax25_send_to_raw(raw, skb, skb->data[1]);
data1700net/ax25/af_ax25.cswitch (skb->data[1]) {
data1776net/ax25/af_ax25.cif ((*skb->data & ~PF) != SABM && (*skb->data & ~PF) != SABME) {
data1781net/ax25/af_ax25.cif ((*skb->data & ~PF) != DM && mine)
data1859net/ax25/af_ax25.cif ((*skb->data & ~PF) == SABME) {
data1898net/ax25/af_ax25.cif ((*skb->data & 0x0F) != 0) {
data1924net/ax25/af_ax25.clen = skb->data[0] + skb->data[1] * 256 - 5;
data1935net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data2059net/ax25/af_ax25.cprintk("base=%p pos=%p\n", skb->data, asmptr);
data2073net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data2099net/ax25/af_ax25.clength = skb->len + (skb->data - skb->h.raw);
data2104net/ax25/af_ax25.cskb->h.raw = skb->data;
data2119net/ax25/af_ax25.cax25_parse_addr(skb->data, skb->len, NULL, &dest, &digi, NULL, &dama);
data2156net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data2163net/ax25/af_ax25.cstruct sock *sk = (struct sock *)sock->data;
data2440net/ax25/af_ax25.cif (call_out_firewall(PF_AX25, skb->dev, skb->data) != FW_ACCEPT) {
data76net/ax25/ax25_in.cif (!(*skb->data & SEG_FIRST)) {
data77net/ax25/ax25_in.cif ((ax25->fragno - 1) == (*skb->data & SEG_REM)) {
data81net/ax25/ax25_in.cax25->fragno = *skb->data & SEG_REM;
data104net/ax25/ax25_in.chdrlen = skbo->data - skbo->h.raw - 2;  /* skip PID & fragno */
data107net/ax25/ax25_in.cskbn->data = skb_put(skbn, hdrlen);  /* get space for info */
data108net/ax25/ax25_in.cmemcpy(skbn->data, skbo->data, hdrlen);  /* copy address field */
data114net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
data120net/ax25/ax25_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
data144net/ax25/ax25_in.cif (*skb->data & SEG_FIRST) {
data145net/ax25/ax25_in.cax25->fragno = *skb->data & SEG_REM;
data169net/ax25/ax25_in.cpid = *skb->data;
data183net/ax25/ax25_in.cskb->h.raw = skb->data;
data80net/ax25/ax25_out.cif (*skb->data == AX25_P_TEXT) {
data123net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
data135net/ax25/ax25_out.cmemcpy(skb_put(skbn, len), skb->data, len);
data605net/ax25/ax25_route.cmemcpy(&dest, skb->data    , AX25_ADDR_LEN);
data606net/ax25/ax25_route.cmemcpy(&src,  skb->data + 7, AX25_ADDR_LEN);
data159net/ax25/ax25_subr.cframe = skb->data;
data65net/ax25/ax25_timer.cax25->timer.data     = (unsigned long)ax25;
data81net/ax25/ax25_timer.cax25->timer.data     = (unsigned long)ax25;
data922net/bridge/br.cskb->h.raw = skb->data + ETH_HLEN;
data978net/bridge/br.cskb->h.raw = skb->data + ETH_HLEN;
data1163net/bridge/br.cskb->h.raw = skb->data;
data1315net/bridge/br.cskb->h.raw = skb->data + ETH_HLEN;
data1361net/bridge/br.cnskb->h.raw = nskb->data + ETH_HLEN;
data1405net/bridge/br.cbpdu = (Tcn_bpdu *)skb->data + ETH_HLEN;
data379net/core/dev.cif (!skb->arp && dev->rebuild_header(skb->data, dev, skb->raddr, skb)) {
data438net/core/dev.c((struct sock *)ptype->data != skb->sk))
data443net/core/dev.cskb2->h.raw = skb2->data + dev->hard_header_len;
data444net/core/dev.cskb2->mac.raw = skb2->data;
data613net/core/dev.cint offset=skb->data-skb->mac.raw;
data634net/core/dev.cskb->h.raw = skb->data;
data74net/core/net_alias.cstatic struct device *net_alias_dev_create(struct device *main_dev, int slot, int *err, struct sockaddr *sa, void *data);
data333net/core/net_alias.cnet_alias_dev_create(struct device *main_dev, int slot, int *err, struct sockaddr *sa, void *data)
data410net/core/net_alias.calias->data = data;
data676net/core/net_alias.cstruct sockaddr *sa, void *data)
data736net/core/net_alias.creturn net_alias_dev_create(dev, slot, err, sa, data);
data157net/core/skbuff.cif(skb->head>skb->data)
data161net/core/skbuff.cskb,skb->head,skb->data);
data171net/core/skbuff.cif(skb->data>skb->tail)
data175net/core/skbuff.cskb,skb->data,skb->tail);
data178net/core/skbuff.cif(skb->tail-skb->data!=skb->len)
data182net/core/skbuff.cskb,skb->data,skb->end,skb->len);
data516net/core/skbuff.cskb->data-=len;
data519net/core/skbuff.cif(skb->data<skb->head)
data521net/core/skbuff.creturn skb->data;
data529net/core/skbuff.cskb->data+=len;
data531net/core/skbuff.creturn skb->data;
data537net/core/skbuff.creturn skb->data-skb->head;
data549net/core/skbuff.cskb->data+=len;
data553net/core/skbuff.cif(skb->data<skb->head)
data564net/core/skbuff.cskb->tail=skb->data+len;
data701net/core/skbuff.cskb->data=bptr;
data795net/core/skbuff.cskb_reserve(n,skb->data-skb->head);
data178net/ethernet/eth.cskb->mac.raw=skb->data;
data204net/ethernet/eth.crawp = skb->data;
data269net/ethernet/eth.cmemcpy(dest->data,src,length);
data276net/ethernet/eth.ceth=(struct ethhdr *)dest->data;
data279net/ethernet/eth.cmemcpy(dest->data,src,length);
data288net/ethernet/eth.cmemcpy(dest->data,src,sizeof(struct iphdr)+ETH_HLEN);  /* ethernet is always >= 34 */
data297net/ethernet/eth.cdest->csum=csum_partial_copy(src+sizeof(struct iphdr)+ETH_HLEN,dest->data+sizeof(struct iphdr)+ETH_HLEN,length,base);
data442net/ipv4/af_inet.csk = (struct sock *) sock->data;
data470net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;  
data486net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;    
data521net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
data682net/ipv4/af_inet.csk->timer.data = (unsigned long)sk;
data685net/ipv4/af_inet.csock->data =(void *) sk;
data742net/ipv4/af_inet.creturn(inet_create(newsock,((struct sock *)(oldsock->data))->protocol));
data754net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
data784net/ipv4/af_inet.csock->data = NULL;
data796net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data, *sk2;
data935net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
data1019net/ipv4/af_inet.csk1 = (struct sock *) sock->data;
data1027net/ipv4/af_inet.cif (newsock->data)
data1029net/ipv4/af_inet.cstruct sock *sk=(struct sock *)newsock->data;
data1030net/ipv4/af_inet.cnewsock->data=NULL;
data1054net/ipv4/af_inet.cnewsock->data = (void *)sk2;
data1071net/ipv4/af_inet.cnewsock->data = NULL;
data1081net/ipv4/af_inet.cnewsock->data = NULL;
data1100net/ipv4/af_inet.csk = (struct sock *) sock->data;
data1128net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
data1144net/ipv4/af_inet.cstruct sock *sk = (struct sock *) sock->data;
data1164net/ipv4/af_inet.cstruct sock *sk=(struct sock*)sock->data;
data1188net/ipv4/af_inet.cstruct sock *sk=(struct sock *) sock->data;
data1208net/ipv4/af_inet.cstruct sock *sk=(struct sock *)sock->data;
data917net/ipv4/arp.cif(!skb->dev->rebuild_header(skb->data,skb->dev,skb->raddr,skb))
data1247net/ipv4/arp.centry->timer.data = (unsigned long)entry;
data1488net/ipv4/arp.centry->timer.data = (unsigned long)entry;
data1727net/ipv4/arp.centry->timer.data = (unsigned long)entry;
data1957net/ipv4/arp.centry->timer.data = (unsigned long)entry;
data485net/ipv4/icmp.cstruct sock *sk=icmp_socket.data;
data1037net/ipv4/icmp.csk=icmp_socket.data;
data90net/ipv4/igmp.cstatic void ip_router_timer_expire(unsigned long data)
data92net/ipv4/igmp.cstruct ip_router_info *i=(struct ip_router_info *)data;
data135net/ipv4/igmp.ci->timer.data=(unsigned long)i;
data183net/ipv4/igmp.ci->timer.data=(unsigned long)i;
data263net/ipv4/igmp.cstatic void igmp_timer_expire(unsigned long data)
data265net/ipv4/igmp.cstruct ip_mc_list *im=(struct ip_mc_list *)data;
data282net/ipv4/igmp.cim->timer.data=(unsigned long)im;
data275net/ipv4/ip_fragment.cqp->timer.data = (unsigned long) qp;    /* pointer to queue  */
data351net/ipv4/ip_fragment.cskb->h.raw = skb->data;
data452net/ipv4/ip_fragment.cqp->timer.data = (unsigned long) qp;  /* pointer to queue */
data480net/ipv4/ip_fragment.cptr = skb->data + ihl;
data618net/ipv4/ip_fragment.craw = skb->data;
data713net/ipv4/ip_fragment.cskb2->h.raw=(char *) skb2->data;
data288net/ipv4/ip_masq.cstatic void masq_expire(unsigned long data)
data290net/ipv4/ip_masq.cstruct ip_masq *ms = (struct ip_masq *)data;
data341net/ipv4/ip_masq.cms->timer.data     = (unsigned long)ms;
data507net/ipv4/ip_masq_app.co_offset = o_buf - (char*) skb->data;
data511net/ipv4/ip_masq_app.cmemcpy(skb->data + o_offset + n_len,o_buf + o_len,
data515net/ipv4/ip_masq_app.cmemcpy(skb->data + o_offset, n_buf, n_len);
data535net/ipv4/ip_masq_app.cn_skb->h.raw = n_skb->data + (skb->h.raw - skb->data);
data541net/ipv4/ip_masq_app.cmemcpy(n_skb->data, skb->data, o_offset);
data542net/ipv4/ip_masq_app.cmemcpy(n_skb->data + o_offset, n_buf, n_len);
data543net/ipv4/ip_masq_app.cmemcpy(n_skb->data + o_offset + n_len, o_buf + o_len,
data56net/ipv4/ip_masq_ftp.cchar *p, *data, *data_limit;
data68net/ipv4/ip_masq_ftp.cdata = (char *)&th[1];
data72net/ipv4/ip_masq_ftp.cwhile (data < data_limit)
data74net/ipv4/ip_masq_ftp.cif (memcmp(data,"PORT ",5) && memcmp(data,"port ",5))
data76net/ipv4/ip_masq_ftp.cdata ++;
data79net/ipv4/ip_masq_ftp.cp = data+5;
data80net/ipv4/ip_masq_ftp.cp1 = simple_strtoul(data+5,&data,10);
data81net/ipv4/ip_masq_ftp.cif (*data!=',')
data83net/ipv4/ip_masq_ftp.cp2 = simple_strtoul(data+1,&data,10);
data84net/ipv4/ip_masq_ftp.cif (*data!=',')
data86net/ipv4/ip_masq_ftp.cp3 = simple_strtoul(data+1,&data,10);
data87net/ipv4/ip_masq_ftp.cif (*data!=',')
data89net/ipv4/ip_masq_ftp.cp4 = simple_strtoul(data+1,&data,10);
data90net/ipv4/ip_masq_ftp.cif (*data!=',')
data92net/ipv4/ip_masq_ftp.cp5 = simple_strtoul(data+1,&data,10);
data93net/ipv4/ip_masq_ftp.cif (*data!=',')
data95net/ipv4/ip_masq_ftp.cp6 = simple_strtoul(data+1,&data,10);
data96net/ipv4/ip_masq_ftp.cif (*data!='\r' && *data!='\n')
data151net/ipv4/ip_masq_ftp.cdiff = buf_len - (data-p);
data166net/ipv4/ip_masq_ftp.c*skb_p = ip_masq_skb_replace(skb, GFP_ATOMIC, p, data-p, buf, buf_len);
data57net/ipv4/ip_masq_irc.cchar *data, *data_limit;
data70net/ipv4/ip_masq_irc.cdata = (char *)&th[1];
data86net/ipv4/ip_masq_irc.cwhile (data < (data_limit - 25) )
data88net/ipv4/ip_masq_irc.cif (memcmp(data,"DCC ",4))  {
data89net/ipv4/ip_masq_irc.cdata ++;
data93net/ipv4/ip_masq_irc.cdcc_p = data;
data94net/ipv4/ip_masq_irc.cdata += 4;     /* point to DCC cmd */
data96net/ipv4/ip_masq_irc.cif (memcmp(data, "CHAT ", 5) == 0 ||
data97net/ipv4/ip_masq_irc.cmemcmp(data, "SEND ", 5) == 0)
data103net/ipv4/ip_masq_irc.cif (*data == 'S') xtra_args++;
data104net/ipv4/ip_masq_irc.cdata += 5;
data113net/ipv4/ip_masq_irc.cwhile( *data++ != ' ')
data119net/ipv4/ip_masq_irc.cif (data > (data_limit-12)) return 0;
data122net/ipv4/ip_masq_irc.caddr_beg_p = data;
data128net/ipv4/ip_masq_irc.cs_addr = simple_strtoul(data,&data,10);
data129net/ipv4/ip_masq_irc.cif (*data++ !=' ')
data136net/ipv4/ip_masq_irc.cs_port = simple_strtoul(data,&data,10);
data137net/ipv4/ip_masq_irc.caddr_end_p = data;
data144net/ipv4/ip_masq_irc.cif (*data != ' ')
data146net/ipv4/ip_masq_irc.cdata++;
data147net/ipv4/ip_masq_irc.csimple_strtoul(data,&data,10);
data157net/ipv4/ip_masq_irc.cif (data[0] != 0x01)
data159net/ipv4/ip_masq_irc.cif (data[1]!='\r' && data[1]!='\n')
data364net/ipv4/ip_output.ciph->tot_len = htons(skb->len-(((unsigned char *)iph)-skb->data));
data806net/ipv4/ip_output.cchar *data;
data835net/ipv4/ip_output.cdata = skb_put(skb, fraglen-dev->hard_header_len);
data867net/ipv4/ip_output.cskb->ip_hdr = iph = (struct iphdr *)data;
data899net/ipv4/ip_output.cdata += iph->ihl*4;
data912net/ipv4/ip_output.cgetfrag(frag, saddr, data, offset, fraglen-fragheaderlen);
data68net/ipv4/ipip.cskb_pull(skb, ((struct iphdr *)skb->data)->ihl<<2);
data74net/ipv4/ipip.cskb->h.iph=(struct iphdr *)skb->data;
data75net/ipv4/ipip.cskb->ip_hdr=(struct iphdr *)skb->data;
data150net/ipv4/ipmr.cstatic void ipmr_cache_timer(unsigned long data)
data152net/ipv4/ipmr.cstruct mfc_cache *cache=(struct mfc_cache *)data;
data204net/ipv4/ipmr.cc->mfc_timer.data=(long)c;
data269net/ipv4/ipmr.cmemcpy(skb->data,pkt->data,ihl);
data88net/ipv4/packet.csk = (struct sock *) pt->data;  
data95net/ipv4/packet.cskb_push(skb,skb->data-skb->mac.raw);
data263net/ipv4/packet.cp->data = (void *)sk;
data351net/ipv4/packet.cstatic int packet_unbind(struct notifier_block *this, unsigned long msg, void *data)
data354net/ipv4/packet.cif(msg==NETDEV_DOWN && data==ipo->bound_dev)
data450net/ipv4/packet.cmemcpy_toiovec(msg->msg_iov, skb->data, copied);  /* We can't use skb_copy_datagram here */
data199net/ipv4/rarp.cstruct arphdr *rarp = (struct arphdr *) skb->data;
data86net/ipv4/raw.csk = (struct sock *) protocol->data;
data1999net/ipv4/tcp.csk->delack_timer.data = (unsigned long) sk;
data2001net/ipv4/tcp.csk->retransmit_timer.data = (unsigned long)sk;
data440net/ipv4/tcp_input.cnewsk->timer.data = (unsigned long)newsk;
data443net/ipv4/tcp_input.cnewsk->delack_timer.data = (unsigned long)newsk;
data446net/ipv4/tcp_input.cnewsk->retransmit_timer.data = (unsigned long)newsk;
data1616net/ipv4/tcp_input.cskb_pull(skb, skb->h.raw-skb->data);
data53net/ipv4/tcp_output.csize = skb->len - ((unsigned char *) th - skb->data);
data62net/ipv4/tcp_output.cskb, skb->data, th, skb->len);
data208net/ipv4/tcp_output.csk->partial_timer.data = (unsigned long) sk;
data281net/ipv4/tcp_output.csize = skb->len - (((unsigned char *) th) - skb->data);
data358net/ipv4/tcp_output.cskb_pull(skb,((unsigned char *)skb->ip_hdr)-skb->data);
data369net/ipv4/tcp_output.ciph = (struct iphdr *)skb->data;
data25net/ipv4/tcp_timer.cvoid tcp_delack_timer(unsigned long data)
data27net/ipv4/tcp_timer.ctcp_send_ack((struct sock *) data);
data202net/ipv4/tcp_timer.cvoid tcp_retransmit_timer(unsigned long data)
data204net/ipv4/tcp_timer.cstruct sock *sk = (struct sock*)data;
data86net/ipv4/timer.cvoid net_timer (unsigned long data)
data88net/ipv4/timer.cstruct sock *sk = (struct sock*)data;
data687net/ipx/af_ipx.cdump_data("ETH hdr:", skb->data, skb->h.raw - skb->data);
data1594net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
data1632net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
data1712net/ipx/af_ipx.csock->data=(void *)sk;
data1728net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data1734net/ipx/af_ipx.csock->data=NULL;
data1768net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
data1865net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data1911net/ipx/af_ipx.cif(newsock->data) {
data1912net/ipx/af_ipx.ckfree_s(newsock->data,sizeof(ipx_socket));
data1925net/ipx/af_ipx.csk=(ipx_socket *)sock->data;
data2062net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data2118net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data2164net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data2173net/ipx/af_ipx.cipx_socket *sk=(ipx_socket *)sock->data;
data107net/netlink.cmemcpy_tofs(buf,skb->data,count);
data227net/netrom/af_netrom.cstatic void nr_destroy_timer(unsigned long data)
data229net/netrom/af_netrom.cnr_destroy_socket((struct sock *)data);
data265net/netrom/af_netrom.csk->timer.data     = (unsigned long)sk;
data367net/netrom/af_netrom.csk = (struct sock *)sock->data;
data424net/netrom/af_netrom.csk = (struct sock *)sock->data;
data472net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data536net/netrom/af_netrom.csock->data = (void *)sk;
data657net/netrom/af_netrom.cstruct sock *sk = (struct sock *)oldsock->data;
data664net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data712net/netrom/af_netrom.csock->data = NULL;  
data725net/netrom/af_netrom.csk = (struct sock *)sock->data;
data774net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data877net/netrom/af_netrom.cif (newsock->data)
data878net/netrom/af_netrom.csk_free(newsock->data);
data880net/netrom/af_netrom.cnewsock->data = NULL;
data882net/netrom/af_netrom.csk = (struct sock *)sock->data;
data917net/netrom/af_netrom.cnewsock->data = newsk;
data928net/netrom/af_netrom.csk = (struct sock *)sock->data;
data963net/netrom/af_netrom.csrc  = (ax25_address *)(skb->data + 0);
data964net/netrom/af_netrom.cdest = (ax25_address *)(skb->data + 7);
data966net/netrom/af_netrom.ccircuit_index = skb->data[15];
data967net/netrom/af_netrom.ccircuit_id    = skb->data[16];
data968net/netrom/af_netrom.cframetype     = skb->data[19];
data976net/netrom/af_netrom.cskb->h.raw = skb->data;
data988net/netrom/af_netrom.cskb->h.raw = skb->data;
data1003net/netrom/af_netrom.cuser = (ax25_address *)(skb->data + 21);
data1010net/netrom/af_netrom.cwindow = skb->data[20];
data1034net/netrom/af_netrom.ctimeout = skb->data[36] * 256 + skb->data[35];
data1067net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data1171net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data1196net/netrom/af_netrom.cskb->h.raw = skb->data;
data1206net/netrom/af_netrom.cmemcpy(&addr.sax25_call, skb->data + 7, AX25_ADDR_LEN);
data1225net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data1232net/netrom/af_netrom.cstruct sock *sk = (struct sock *)sock->data;
data71net/netrom/nr_dev.cskb->h.raw = skb->data;
data74net/netrom/nr_in.cskbn->h.raw = skbn->data;
data77net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
data82net/netrom/nr_in.cmemcpy(skb_put(skbn, skbo->len), skbo->data, skbo->len);
data103net/netrom/nr_in.csk->window         = skb->data[20];
data104net/netrom/nr_in.csk->nr->your_index = skb->data[17];
data105net/netrom/nr_in.csk->nr->your_id    = skb->data[18];
data179net/netrom/nr_in.cnr = skb->data[18];
data180net/netrom/nr_in.cns = skb->data[17];
data270net/netrom/nr_in.cns = skbn->data[17];
data325net/netrom/nr_in.cframetype = skb->data[19];
data59net/netrom/nr_out.cmemcpy(transport, skb->data, NR_TRANSPORT_LEN);
data77net/netrom/nr_out.cmemcpy(skb_put(skbn, len), skb->data, len);
data82net/netrom/nr_out.cmemcpy(skbn->data, transport, NR_TRANSPORT_LEN);
data85net/netrom/nr_out.cskbn->data[4] |= NR_MORE_FLAG;
data109net/netrom/nr_out.cskb->data[2] = sk->nr->vs;
data110net/netrom/nr_out.cskb->data[3] = sk->nr->vr;
data113net/netrom/nr_out.cskb->data[4] |= NR_CHOKE_FLAG;
data128net/netrom/nr_out.cskbn->data[2] = sk->nr->va;
data129net/netrom/nr_out.cskbn->data[3] = sk->nr->vr;
data132net/netrom/nr_out.cskbn->data[4] |= NR_CHOKE_FLAG;
data659net/netrom/nr_route.cif(ax25 && call_in_firewall(PF_NETROM, skb->dev, skb->data)!=FW_ACCEPT)
data661net/netrom/nr_route.cif(!ax25 && call_out_firewall(PF_NETROM, skb->dev, skb->data)!=FW_ACCEPT)
data664net/netrom/nr_route.cnr_src  = (ax25_address *)(skb->data + 0);
data665net/netrom/nr_route.cnr_dest = (ax25_address *)(skb->data + 7);
data677net/netrom/nr_route.cif (--skb->data[14] == 0)
data698net/netrom/nr_route.cif(ax25 && call_fw_firewall(PF_NETROM, skb->dev, skb->data)!=FW_ACCEPT)
data261net/netrom/nr_subr.cmemcpy(dptr, skb->data + 7, AX25_ADDR_LEN);
data267net/netrom/nr_subr.cmemcpy(dptr, skb->data + 0, AX25_ADDR_LEN);
data275net/netrom/nr_subr.c*dptr++ = skb->data[15];
data276net/netrom/nr_subr.c*dptr++ = skb->data[16];
data58net/netrom/nr_timer.csk->timer.data     = (unsigned long)sk;
data74net/netrom/nr_timer.csk->timer.data     = (unsigned long)sk;
data264net/socket.csock->data = NULL;
data144net/unix/af_unix.cstatic void unix_destroy_timer(unsigned long data)
data146net/unix/af_unix.cunix_socket *sk=(unix_socket *)data;
data166net/unix/af_unix.csk->timer.data=(unsigned long)sk;
data229net/unix/af_unix.cunix_socket *sk=sock->data;
data237net/unix/af_unix.cunix_socket *sk=sock->data;
data245net/unix/af_unix.cunix_socket *sk=sock->data;
data323net/unix/af_unix.csock->data=(void *)sk;
data336net/unix/af_unix.cunix_socket *sk=sock->data;
data396net/unix/af_unix.cunix_socket *sk=sock->data;
data442net/unix/af_unix.cunix_socket *sk=sock->data;
data575net/unix/af_unix.cska=a->data;
data576net/unix/af_unix.cskb=b->data;
data590net/unix/af_unix.cunix_socket *sk=sock->data;
data603net/unix/af_unix.cnewsk=newsock->data;
data651net/unix/af_unix.cunix_socket *sk=sock->data;
data873net/unix/af_unix.cunix_socket *sk=sock->data;
data1052net/unix/af_unix.cunix_socket *sk=sock->data;
data1137net/unix/af_unix.cmemcpy_tofs(sp, skb->data, num);
data1166net/unix/af_unix.cunix_socket *sk=(unix_socket *)sock->data;
data1195net/unix/af_unix.creturn datagram_select(sock->data,sel_type,wait);
data1200net/unix/af_unix.cunix_socket *sk=sock->data;
data88net/unix/garbage.creturn s->data;