taglinefilesource code
dev25fs/block_dev.cunsigned int dev;
dev29fs/block_dev.cdev = inode->i_rdev;
dev31fs/block_dev.cif (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)])
dev32fs/block_dev.cblocksize = blksize_size[MAJOR(dev)][MINOR(dev)];
dev44fs/block_dev.cif (blk_size[MAJOR(dev)])
dev45fs/block_dev.csize = (blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits;
dev55fs/block_dev.cbh = getblk(dev, block, blocksize);
dev57fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
dev91fs/block_dev.cunsigned int dev;
dev94fs/block_dev.cdev = inode->i_rdev;
dev96fs/block_dev.cif (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)])
dev97fs/block_dev.cblocksize = blksize_size[MAJOR(dev)][MINOR(dev)];
dev106fs/block_dev.cif (blk_size[MAJOR(dev)])
dev107fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
dev126fs/block_dev.cblocks += read_ahead[MAJOR(dev)] / (blocksize >> 9);
dev146fs/block_dev.c*bhb = getblk(dev, block++, blocksize);
dev89fs/buffer.cstatic int sync_buffers(dev_t dev, int wait)
dev103fs/buffer.cif (dev && bh->b_dev != dev)
dev147fs/buffer.cvoid sync_dev(dev_t dev)
dev149fs/buffer.csync_buffers(dev, 0);
dev150fs/buffer.csync_supers(dev);
dev151fs/buffer.csync_inodes(dev);
dev152fs/buffer.csync_buffers(dev, 0);
dev155fs/buffer.cint fsync_dev(dev_t dev)
dev157fs/buffer.csync_buffers(dev, 0);
dev158fs/buffer.csync_supers(dev);
dev159fs/buffer.csync_inodes(dev);
dev160fs/buffer.creturn sync_buffers(dev, 1);
dev188fs/buffer.cvoid invalidate_buffers(dev_t dev)
dev195fs/buffer.cif (bh->b_dev != dev)
dev198fs/buffer.cif (bh->b_dev == dev)
dev217fs/buffer.cvoid check_disk_change(dev_t dev)
dev222fs/buffer.cswitch(MAJOR(dev)){
dev224fs/buffer.cif (!(bh = getblk(dev,0,1024)))
dev232fs/buffer.ci = check_scsidisk_media_change(dev, 0);
dev238fs/buffer.ci = check_cdrom_media_change(dev, 0);
dev244fs/buffer.ci = check_cdu31a_media_change(dev, 0);
dev250fs/buffer.ci = check_mcd_media_change(dev, 0);
dev261fs/buffer.cMAJOR(dev), MINOR(dev));
dev263fs/buffer.cif (super_blocks[i].s_dev == dev)
dev265fs/buffer.cinvalidate_inodes(dev);
dev266fs/buffer.cinvalidate_buffers(dev);
dev271fs/buffer.cif (MAJOR(dev) == 8)
dev272fs/buffer.crevalidate_scsidisk(dev, 0);
dev276fs/buffer.c#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
dev277fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
dev354fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
dev358fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
dev359fs/buffer.cif (tmp->b_dev==dev && tmp->b_blocknr==block)
dev364fs/buffer.cMAJOR(dev), MINOR(dev));
dev377fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
dev382fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
dev386fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
dev392fs/buffer.cvoid set_blocksize(dev_t dev, int size)
dev397fs/buffer.cif (!blksize_size[MAJOR(dev)])
dev405fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) {
dev406fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
dev409fs/buffer.cif (blksize_size[MAJOR(dev)][MINOR(dev)] == size)
dev411fs/buffer.csync_buffers(dev, 2);
dev412fs/buffer.cblksize_size[MAJOR(dev)][MINOR(dev)] = size;
dev420fs/buffer.cif (bh->b_dev != dev)
dev426fs/buffer.cif (bh->b_dev == dev && bh->b_size != size)
dev444fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
dev451fs/buffer.cbh = get_hash_table(dev, block, size);
dev503fs/buffer.cif (find_buffer(dev,block,size))
dev512fs/buffer.cbh->b_dev=dev;
dev536fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
dev540fs/buffer.cif (!(bh = getblk(dev, block, size))) {
dev542fs/buffer.cMAJOR(dev), MINOR(dev));
dev560fs/buffer.cstruct buffer_head * breada(dev_t dev,int first, ...)
dev569fs/buffer.cif (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)])
dev570fs/buffer.cblocksize = blksize_size[MAJOR(dev)][MINOR(dev)];
dev572fs/buffer.cif (!(bh = getblk(dev, first, blocksize))) {
dev574fs/buffer.cMAJOR(dev), MINOR(dev));
dev580fs/buffer.ctmp = getblk(dev, first, blocksize);
dev698fs/buffer.cdev_t dev, int *b, int size)
dev718fs/buffer.cfirst = get_hash_table(dev, block, size);
dev739fs/buffer.cdev_t dev, int b[], int size)
dev754fs/buffer.ctmp = get_hash_table(dev, block, size);
dev768fs/buffer.cbh->b_dev = dev;
dev805fs/buffer.cdev_t dev, int *b, int size)
dev813fs/buffer.cbh = get_hash_table(dev, block, size);
dev815fs/buffer.creturn check_aligned(bh, address, dev, b, size);
dev816fs/buffer.creturn try_to_load_aligned(address, dev, b, size);
dev831fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int prot)
dev838fs/buffer.cwhere = try_to_share_buffers(address,dev,b,size);
dev846fs/buffer.cbh[i] = getblk(dev, b[i], size);
dev189fs/ext/freelists.cdev_t dev;
dev211fs/ext/freelists.cdev = inode->i_dev;
dev229fs/ext/freelists.cif (!(bh = bread(dev, block, sb->s_blocksize)))
dev62fs/ext/inode.cint dev = s->s_dev,block;
dev65fs/ext/inode.cset_blocksize(dev, BLOCK_SIZE);
dev66fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
dev91fs/ext/inode.cdev);
dev97fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeblock = bread(dev,
dev108fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
dev118fs/ext/inode.cs->s_dev = dev;
dev23fs/ext2/dcache.cunsigned short dev;
dev52fs/ext2/dcache.c#define hash(dev,dir)  ((dev ^ dir) % HASH_QUEUES)
dev81fs/ext2/dcache.cstatic struct dir_cache_entry * find_name (int queue, unsigned short dev,
dev87fs/ext2/dcache.cfor (p = queue_head[queue]; p != NULL && (p->dev != dev ||
dev106fs/ext2/dcache.cp->dev, p->dir, p->name);
dev172fs/ext2/dcache.cvoid ext2_dcache_invalidate (unsigned short dev)
dev181fs/ext2/dcache.cif (p->dev == dev) {
dev183fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
dev196fs/ext2/dcache.cunsigned long ext2_dcache_lookup (unsigned short dev, unsigned long dir,
dev210fs/ext2/dcache.cprintk ("dcache_lookup (%04x, %d, %s, %d)\n", dev, dir, our_name, len);
dev212fs/ext2/dcache.cqueue = hash (dev, dir);
dev213fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, our_name, len))) {
dev246fs/ext2/dcache.cvoid ext2_dcache_add (unsigned short dev, unsigned long dir, const char * name,
dev256fs/ext2/dcache.cdev, dir, name, len, ino);
dev260fs/ext2/dcache.cqueue = hash (dev, dir);
dev261fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
dev284fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
dev287fs/ext2/dcache.cp->dev = dev;
dev306fs/ext2/dcache.cvoid ext2_dcache_remove (unsigned short dev, unsigned long dir,
dev315fs/ext2/dcache.cprintk ("dcache_remove (%04x, %d, %s, %d)\n", dev, dir, name, len);
dev319fs/ext2/dcache.cqueue = hash (dev, dir);
dev320fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
dev123fs/ext2/inode.cint dev = s->s_dev;
dev131fs/ext2/inode.cset_blocksize (dev, BLOCK_SIZE);
dev132fs/ext2/inode.cif (!(bh = bread (dev, 1, BLOCK_SIZE))) {
dev153fs/ext2/inode.cdev);
dev162fs/ext2/inode.cset_blocksize (dev, s->s_blocksize);
dev163fs/ext2/inode.cbh = bread (dev, 0, s->s_blocksize);
dev232fs/ext2/inode.cdev);
dev241fs/ext2/inode.cdev);
dev273fs/ext2/inode.cs->u.ext2_sb.s_group_desc[i] = bread (dev, i + 2,
dev295fs/ext2/inode.cs->s_dev = dev;
dev20fs/inode.cstatic inline int const hashfn(dev_t dev, unsigned int i)
dev22fs/inode.creturn (dev ^ i) % NR_IHASH;
dev25fs/inode.cstatic inline struct inode ** const hash(dev_t dev, int i)
dev27fs/inode.creturn hash_table + hashfn(dev, i);
dev158fs/inode.cint fs_may_mount(dev_t dev)
dev167fs/inode.cif (inode->i_dev != dev)
dev176fs/inode.cint fs_may_umount(dev_t dev, struct inode * mount_root)
dev183fs/inode.cif (inode->i_dev != dev || !inode->i_count)
dev192fs/inode.cint fs_may_remount_ro(dev_t dev)
dev200fs/inode.cfile->f_inode->i_dev != dev)
dev265fs/inode.cvoid invalidate_inodes(dev_t dev)
dev274fs/inode.cif (inode->i_dev != dev)
dev277fs/inode.cprintk("VFS: inode busy on removed device %d/%d\n", MAJOR(dev), MINOR(dev));
dev284fs/inode.cvoid sync_inodes(dev_t dev)
dev291fs/inode.cif (dev && inode->i_dev != dev)
dev199fs/isofs/dir.ccache.dev = inode->i_dev;
dev124fs/isofs/inode.cint dev=s->s_dev;
dev148fs/isofs/inode.cset_blocksize(dev, blocksize);
dev155fs/isofs/inode.cif (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), blocksize))) {
dev158fs/isofs/inode.cdev, iso_blknum);
dev249fs/isofs/inode.cs->s_dev = dev;
dev631fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
dev633fs/isofs/inode.creturn bread(dev, block, size);
dev218fs/isofs/namei.cif (dir->i_dev == cache.dev && 
dev58fs/minix/inode.cint i,dev=s->s_dev,block;
dev63fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
dev92fs/minix/inode.cdev);
dev101fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
dev106fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
dev123fs/minix/inode.cs->s_dev = dev;
dev395fs/namei.cint do_mknod(const char * filename, int mode, dev_t dev)
dev421fs/namei.creturn dir->i_op->mknod(dir,basename,namelen,mode,dev);
dev424fs/namei.casmlinkage int sys_mknod(const char * filename, int mode, dev_t dev)
dev433fs/namei.cerror = do_mknod(tmp,mode,dev);
dev174fs/nfs/dir.cint dev;
dev190fs/nfs/dir.cif (entry->dev == dir->i_dev && entry->inode == dir->i_ino
dev211fs/nfs/dir.centry->dev = 0;
dev237fs/nfs/dir.centry->dev = dir->i_dev;
dev250fs/nfs/dir.cint dev;
dev255fs/nfs/dir.cdev = inode->i_dev;
dev259fs/nfs/dir.cdev = entry->dev;
dev266fs/nfs/dir.cif (entry->dev == dev && entry->fattr.fileid == fileid)
dev267fs/nfs/dir.centry->dev = 0;
dev275fs/nfs/dir.cint dev = file->i_dev;
dev281fs/nfs/dir.cif (entry->dev == dev && entry->fattr.fileid == fileid)
dev68fs/nfs/inode.cdev_t dev = sb->s_dev;
dev95fs/nfs/inode.csb->s_dev = dev;
dev24fs/open.casmlinkage int sys_ustat(int dev, struct ustat * ubuf)
dev107fs/proc/link.cunsigned int dev,ino;
dev115fs/proc/link.cdev = inode->i_dev;
dev118fs/proc/link.ci = sprintf(buf,"[%04x]:%u", dev, ino);
dev69fs/super.cvoid sync_supers(dev_t dev)
dev76fs/super.cif (dev && sb->s_dev != dev)
dev81fs/super.cif (dev && (dev != sb->s_dev))
dev88fs/super.cstatic struct super_block * get_super(dev_t dev)
dev92fs/super.cif (!dev)
dev96fs/super.cif (s->s_dev == dev) {
dev98fs/super.cif (s->s_dev == dev)
dev106fs/super.cvoid put_super(dev_t dev)
dev110fs/super.cif (dev == ROOT_DEV) {
dev112fs/super.cMAJOR(dev), MINOR(dev));
dev115fs/super.cif (!(sb = get_super(dev)))
dev119fs/super.cMAJOR(dev), MINOR(dev));
dev126fs/super.cstatic struct super_block * read_super(dev_t dev,char *name,int flags,
dev132fs/super.cif (!dev)
dev134fs/super.ccheck_disk_change(dev);
dev135fs/super.cs = get_super(dev);
dev140fs/super.cMAJOR(dev), MINOR(dev), name);
dev149fs/super.cs->s_dev = dev;
dev155fs/super.cs->s_dev = dev;
dev188fs/super.cstatic void put_unnamed_dev(dev_t dev)
dev190fs/super.cif (!dev)
dev192fs/super.cif (!unnamed_dev_in_use[dev]) {
dev194fs/super.cMAJOR(dev), MINOR(dev));
dev197fs/super.cunnamed_dev_in_use[dev] = 0;
dev200fs/super.cstatic int do_umount(dev_t dev)
dev205fs/super.cif (dev==ROOT_DEV) {
dev208fs/super.cif (!(sb=get_super(dev)))
dev217fs/super.cif (!(sb=get_super(dev)) || !(sb->s_covered))
dev221fs/super.cMAJOR(dev), MINOR(dev));
dev222fs/super.cif (!fs_may_umount(dev, sb->s_mounted))
dev231fs/super.cput_super(dev);
dev249fs/super.cdev_t dev;
dev263fs/super.cdev = inode->i_rdev;
dev273fs/super.cdev = inode->i_sb->s_dev;
dev276fs/super.cdummy_inode.i_rdev = dev;
dev279fs/super.cif (MAJOR(dev) >= MAX_BLKDEV) {
dev283fs/super.cif (!(retval = do_umount(dev)) && dev != ROOT_DEV) {
dev284fs/super.cfops = blkdev_fops[MAJOR(dev)];
dev287fs/super.cif (MAJOR(dev) == UNNAMED_MAJOR)
dev288fs/super.cput_unnamed_dev(dev);
dev294fs/super.cfsync_dev(dev);
dev307fs/super.cstatic int do_mount(dev_t dev, const char * dir, char * type, int flags, void * data)
dev324fs/super.cif (!fs_may_mount(dev)) {
dev328fs/super.csb = read_super(dev,type,flags,data,0);
dev399fs/super.cdev_t dev;
dev436fs/super.cdev = inode->i_rdev;
dev437fs/super.cif (MAJOR(dev) >= MAX_BLKDEV) {
dev442fs/super.cif (!(dev = get_unnamed_dev()))
dev446fs/super.cfops = blkdev_fops[MAJOR(dev)];
dev471fs/super.cretval = do_mount(dev,dir_name,t,flags,(void *) page);
dev64fs/xiafs/inode.cint i, z, dev;
dev66fs/xiafs/inode.cdev=s->s_dev;
dev69fs/xiafs/inode.cset_blocksize(dev, BLOCK_SIZE);
dev71fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
dev85fs/xiafs/inode.cdev);
dev94fs/xiafs/inode.cset_blocksize(dev, s->s_blocksize);
dev95fs/xiafs/inode.cbh = bread (dev, 0,  s->s_blocksize);
dev122fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
dev132fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
dev138fs/xiafs/inode.cs->s_dev = dev;
dev349include/linux/fs.hextern int fs_may_mount(dev_t dev);
dev350include/linux/fs.hextern int fs_may_umount(dev_t dev, struct inode * mount_root);
dev351include/linux/fs.hextern int fs_may_remount_ro(dev_t dev);
dev364include/linux/fs.hextern void check_disk_change(dev_t dev);
dev365include/linux/fs.hextern void invalidate_inodes(dev_t dev);
dev366include/linux/fs.hextern void invalidate_buffers(dev_t dev);
dev368include/linux/fs.hextern void sync_inodes(dev_t dev);
dev369include/linux/fs.hextern void sync_dev(dev_t dev);
dev370include/linux/fs.hextern int fsync_dev(dev_t dev);
dev371include/linux/fs.hextern void sync_supers(dev_t dev);
dev379include/linux/fs.hextern int do_mknod(const char * filename, int mode, dev_t dev);
dev388include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
dev389include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
dev391include/linux/fs.hextern void ll_rw_page(int rw, int dev, int nr, char * buffer);
dev392include/linux/fs.hextern void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buffer);
dev394include/linux/fs.hextern void set_blocksize(dev_t dev, int size);
dev395include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
dev396include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int prot);
dev397include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block,...);
dev398include/linux/fs.hextern void put_super(dev_t dev);
dev172include/linux/iso_fs.hextern int isofs_new_block(int dev);
dev173include/linux/iso_fs.hextern int isofs_free_block(int dev, int block);
dev196include/linux/iso_fs.hdev_t dev;  /* And this matches */
dev212include/linux/iso_fs.hextern struct buffer_head * leak_check_bread(int dev, int block, int size);
dev113include/linux/msdos_fs.hstatic inline struct buffer_head *msdos_sread(int dev,int sector,void **start)
dev117include/linux/msdos_fs.hif (!(bh = bread(dev,sector >> 1, 1024)))
dev278include/linux/tpqic02.h#define  TP_DENS(dev)  ((MINOR(dev) >> 1) & 0x07)         /* tape density */
dev279include/linux/tpqic02.h#define TP_UNIT(dev)  ((MINOR(dev) >> 4) & 0x07)         /* unit number */
dev280include/linux/tpqic02.h#define TP_DIAGS(dev)  (MINOR(dev) & 0x80)    /* print excessive diagnostics */
dev117include/linux/xd.hstatic int xd_reread_partitions (int dev);
dev27kernel/blk_drv/blk.hint dev;    /* -1 if no request */
dev47kernel/blk_drv/blk.h((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
dev66kernel/blk_drv/blk.hblksize_size[MAJOR_NR][MINOR(CURRENT->dev)] ? \
dev67kernel/blk_drv/blk.h((blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] >> 9) - 1) :  \
dev76kernel/blk_drv/blk.hextern void resetup_one_dev(struct gendisk *dev, int drive);
dev85kernel/blk_drv/blk.hextern int is_read_only(int dev);
dev86kernel/blk_drv/blk.hextern void set_device_ro(int dev,int flag);
dev94kernel/blk_drv/blk.h#define RO_IOCTLS(dev,where) \
dev96kernel/blk_drv/blk.hset_device_ro((dev),get_fs_long((long *) (where))); return 0; \
dev98kernel/blk_drv/blk.hif (!__err) put_fs_long(is_read_only(dev),(long *) (where)); return __err; }
dev203kernel/blk_drv/blk.h#define CURRENT_DEV DEVICE_NR(CURRENT->dev)
dev242kernel/blk_drv/blk.hprintk("dev %04x, sector %d\n",req->dev,req->sector);
dev264kernel/blk_drv/blk.hDEVICE_OFF(req->dev);
dev272kernel/blk_drv/blk.hreq->dev = -1;
dev288kernel/blk_drv/blk.hif (MAJOR(CURRENT->dev) != MAJOR_NR) \
dev843kernel/blk_drv/cdu31a.cunsigned int dev;
dev864kernel/blk_drv/cdu31a.cif (!(CURRENT) || CURRENT->dev < 0)
dev870kernel/blk_drv/cdu31a.cdev = MINOR(CURRENT->dev);
dev873kernel/blk_drv/cdu31a.cif (dev != 0)
dev1137kernel/blk_drv/cdu31a.cunsigned int dev;
dev1148kernel/blk_drv/cdu31a.cdev = MINOR(inode->i_rdev) >> 6;
dev1149kernel/blk_drv/cdu31a.cif (dev != 0)
dev239kernel/blk_drv/floppy.c(CURRENT->dev))
dev680kernel/blk_drv/floppy.cint drive = MINOR(CURRENT->dev);
dev998kernel/blk_drv/floppy.cif (CURRENT && CURRENT->dev < 0) return;
dev1012kernel/blk_drv/floppy.cif (MAJOR(CURRENT->dev) != MAJOR_NR)
dev36kernel/blk_drv/genhd.cstatic void extended_partition(struct gendisk *hd, int dev)
dev43kernel/blk_drv/genhd.cfirst_sector = hd->part[MINOR(dev)].start_sect;
dev49kernel/blk_drv/genhd.cif (!(bh = bread(dev,0,1024)))
dev84kernel/blk_drv/genhd.cdev = ((hd->major) << 8) | current_minor;
dev93kernel/blk_drv/genhd.cstatic void check_partition(struct gendisk *hd, unsigned int dev)
dev105kernel/blk_drv/genhd.cfirst_sector = hd->part[MINOR(dev)].start_sect;
dev106kernel/blk_drv/genhd.cif (!(bh = bread(dev,0,1024))) {
dev107kernel/blk_drv/genhd.cprintk("  unable to read partition table of device %04x\n",dev);
dev160kernel/blk_drv/genhd.cvoid resetup_one_dev(struct gendisk *dev, int drive)
dev163kernel/blk_drv/genhd.cint start = drive<<dev->minor_shift;
dev164kernel/blk_drv/genhd.cint j = start + dev->max_p;
dev165kernel/blk_drv/genhd.cint major = dev->major << 8;
dev167kernel/blk_drv/genhd.ccurrent_minor = 1+(drive<<dev->minor_shift);
dev168kernel/blk_drv/genhd.ccheck_partition(dev, major+(drive<<dev->minor_shift));
dev171kernel/blk_drv/genhd.cdev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
dev174kernel/blk_drv/genhd.cstatic void setup_dev(struct gendisk *dev)
dev177kernel/blk_drv/genhd.cint j = dev->max_nr * dev->max_p;
dev178kernel/blk_drv/genhd.cint major = dev->major << 8;
dev183kernel/blk_drv/genhd.cdev->part[i].start_sect = 0;
dev184kernel/blk_drv/genhd.cdev->part[i].nr_sects = 0;
dev186kernel/blk_drv/genhd.cdev->init();  
dev187kernel/blk_drv/genhd.cfor (drive=0 ; drive<dev->nr_real ; drive++) {
dev188kernel/blk_drv/genhd.ccurrent_minor = 1+(drive<<dev->minor_shift);
dev189kernel/blk_drv/genhd.ccheck_partition(dev, major+(drive<<dev->minor_shift));
dev192kernel/blk_drv/genhd.cdev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9);
dev193kernel/blk_drv/genhd.cblk_size[dev->major] = dev->sizes;
dev289kernel/blk_drv/hd.cint dev;
dev293kernel/blk_drv/hd.cdev = MINOR(CURRENT->dev) >> 6;
dev296kernel/blk_drv/hd.crecalibrate[dev] = 1;
dev300kernel/blk_drv/hd.crecalibrate[dev] = 1;
dev350kernel/blk_drv/hd.cMINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> 
dev451kernel/blk_drv/hd.cunsigned int block,dev;
dev455kernel/blk_drv/hd.cif (CURRENT && CURRENT->dev < 0) return;
dev463kernel/blk_drv/hd.cdev = MINOR(CURRENT->dev);
dev466kernel/blk_drv/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
dev469kernel/blk_drv/hd.cblock, hd[dev].nr_sects);
dev474kernel/blk_drv/hd.cblock += hd[dev].start_sect;
dev475kernel/blk_drv/hd.cdev >>= 6;
dev476kernel/blk_drv/hd.csec = block % hd_info[dev].sect + 1;
dev477kernel/blk_drv/hd.ctrack = block / hd_info[dev].sect;
dev478kernel/blk_drv/hd.chead = track % hd_info[dev].head;
dev479kernel/blk_drv/hd.ccyl = track / hd_info[dev].head;
dev482kernel/blk_drv/hd.cdev, cyl, head, sec, CURRENT->buffer);
dev494kernel/blk_drv/hd.cif (recalibrate[dev]) {
dev495kernel/blk_drv/hd.crecalibrate[dev] = 0;
dev496kernel/blk_drv/hd.chd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr);
dev503kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
dev516kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr);
dev529kernel/blk_drv/hd.cint dev, err;
dev533kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
dev534kernel/blk_drv/hd.cif (dev >= NR_HD)
dev542kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].head,
dev544kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].sect,
dev546kernel/blk_drv/hd.cput_fs_word(hd_info[dev].cyl,
dev763kernel/blk_drv/hd.cstatic int revalidate_hddisk(int dev, int maxusage)
dev771kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(dev));
dev76kernel/blk_drv/ll_rw_blk.cint is_read_only(int dev)
dev80kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev81kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev86kernel/blk_drv/ll_rw_blk.cvoid set_device_ro(int dev,int flag)
dev90kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev91kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev102kernel/blk_drv/ll_rw_blk.cstatic void add_request(struct blk_dev_struct * dev, struct request * req)
dev110kernel/blk_drv/ll_rw_blk.cif (!(tmp = dev->current_request)) {
dev111kernel/blk_drv/ll_rw_blk.cdev->current_request = req;
dev112kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev126kernel/blk_drv/ll_rw_blk.cif(MAJOR(req->dev) == 8 || 
dev127kernel/blk_drv/ll_rw_blk.cMAJOR(req->dev) == 9 ||
dev128kernel/blk_drv/ll_rw_blk.cMAJOR(req->dev) == 11)
dev129kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev176kernel/blk_drv/ll_rw_blk.cif (req->dev == bh->b_dev &&
dev188kernel/blk_drv/ll_rw_blk.celse if ( req->dev == bh->b_dev &&
dev217kernel/blk_drv/ll_rw_blk.cif (req->dev < 0)
dev231kernel/blk_drv/ll_rw_blk.creq->dev = bh->b_dev;
dev246kernel/blk_drv/ll_rw_blk.cvoid ll_rw_page(int rw, int dev, int page, char * buffer)
dev249kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev252kernel/blk_drv/ll_rw_blk.cprintk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
dev257kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev258kernel/blk_drv/ll_rw_blk.cprintk("Can't page to read-only device 0x%X\n",dev);
dev265kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev273kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev299kernel/blk_drv/ll_rw_blk.cstruct blk_dev_struct * dev;
dev349kernel/blk_drv/ll_rw_blk.cplug.dev = -1;
dev362kernel/blk_drv/ll_rw_blk.cdev = major+blk_dev;
dev363kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev368kernel/blk_drv/ll_rw_blk.cvoid ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf)
dev373kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev384kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev385kernel/blk_drv/ll_rw_blk.cprintk("Can't swap to read-only device 0x%X\n",dev);
dev396kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev403kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev424kernel/blk_drv/ll_rw_blk.crequest[i].dev = -1;
dev521kernel/blk_drv/mcd.cunsigned int block,dev;
dev526kernel/blk_drv/mcd.cdev = MINOR(CURRENT->dev);
dev42kernel/blk_drv/ramdisk.cif ((MINOR(CURRENT->dev) != MINOR_RAMDISK) ||
dev796kernel/blk_drv/scsi/aha1542.cint aha1542_biosparam(int size, int dev, int * ip)
dev489kernel/blk_drv/scsi/aha1740.cint aha1740_biosparam(int size, int dev, int* ip)
dev379kernel/blk_drv/scsi/constants.cint dev = SCpnt->request.dev;
dev413kernel/blk_drv/scsi/constants.cprintk( "%s%x: sense key %s\n", devclass, dev, snstext[sense_buffer[2] & 0x0f]);
dev415kernel/blk_drv/scsi/constants.cprintk("%s%x: sns = %2x %2x\n", devclass, dev, sense_buffer[0], sense_buffer[2]);
dev443kernel/blk_drv/scsi/constants.cprintk("%s%x: old sense key %s\n", devclass, dev, snstext[sense_buffer[0] & 0x0f]);
dev446kernel/blk_drv/scsi/constants.cprintk("%s%x: sns = %2x %2x\n", devclass, dev, sense_buffer[0], sense_buffer[2]);
dev1468kernel/blk_drv/scsi/fdomain.cint fdomain_16x0_biosparam( int size, int dev, int *info_array )
dev1509kernel/blk_drv/scsi/fdomain.cdrive = MINOR(dev) / 16;
dev156kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xfffe;
dev168kernel/blk_drv/scsi/scsi.cint host_nr , dev, lun, type;
dev183kernel/blk_drv/scsi/scsi.cfor (dev = 0; dev < 8; ++dev)
dev184kernel/blk_drv/scsi/scsi.cif (scsi_hosts[host_nr].this_id != dev)
dev196kernel/blk_drv/scsi/scsi.cscsi_devices[NR_SCSI_DEVICES].id = dev;
dev212kernel/blk_drv/scsi/scsi.cSCmd.target = dev;
dev215kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev227kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev229kernel/blk_drv/scsi/scsi.cprintk("scsi: scan SCSIS id %d lun %d\n", dev, lun);
dev262kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev269kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev334kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev339kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev345kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev396kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev403kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev493kernel/blk_drv/scsi/scsi.cif (req && req->dev <= 0)
dev501kernel/blk_drv/scsi/scsi.cif(SCpnt->request.dev < 0) break;
dev512kernel/blk_drv/scsi/scsi.creq->dev = -1;
dev514kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy, but no request */
dev536kernel/blk_drv/scsi/scsi.cint host, dev = -1;
dev547kernel/blk_drv/scsi/scsi.cif (req && (dev = req->dev) <= 0) return NULL;
dev557kernel/blk_drv/scsi/scsi.cif(SCpnt->request.dev < 0) break;
dev563kernel/blk_drv/scsi/scsi.cif (req && ((req->dev < 0) || (req->dev != dev))) {
dev567kernel/blk_drv/scsi/scsi.cif (!SCpnt || SCpnt->request.dev >= 0)  /* Might have changed */
dev577kernel/blk_drv/scsi/scsi.c(SCwait->request.dev > 0));
dev581kernel/blk_drv/scsi/scsi.creq->dev = -1;
dev584kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy */
dev1259kernel/blk_drv/scsi/scsi.cif ((SCpnt1->request.dev > 0) &&
dev1513kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = -1; /* Mark not busy */
dev442kernel/blk_drv/scsi/scsi.hprintk("dev %04x, sector %d\n",req->dev,req->sector);
dev467kernel/blk_drv/scsi/scsi.hDEVICE_OFF(req->dev);
dev474kernel/blk_drv/scsi/scsi.hreq->dev = -1;
dev490kernel/blk_drv/scsi/scsi.hif (MAJOR(CURRENT->dev) != MAJOR_NR) \
dev49kernel/blk_drv/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1];    \
dev55kernel/blk_drv/scsi/scsi_debug.cif (bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
dev61kernel/blk_drv/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xfff0) != ((target + NR_REAL) << 4) +(MAJOR_NR << 8)){  \
dev62kernel/blk_drv/scsi/scsi_debug.cprintk("Dev #s %x %x ",SCpnt->request.dev, target);      \
dev70kernel/blk_drv/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) > npart) panic ("Bad partition");  \
dev71kernel/blk_drv/scsi/scsi_debug.cif ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1];    \
dev80kernel/blk_drv/scsi/scsi_debug.cif (SCpnt->request.bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\
dev203kernel/blk_drv/scsi/scsi_debug.cif(NR_REAL < 0) NR_REAL = (SCpnt->request.dev >> 4) & 0x0f;
dev28kernel/blk_drv/scsi/scsi_ioctl.cstatic int ioctl_probe(int dev, void *buffer)
dev34kernel/blk_drv/scsi/scsi_ioctl.cif ((temp = scsi_hosts[dev].present) && buffer) {
dev36kernel/blk_drv/scsi/scsi_ioctl.cstring = scsi_hosts[dev].info();
dev79kernel/blk_drv/scsi/scsi_ioctl.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev89kernel/blk_drv/scsi/scsi_ioctl.cstatic int ioctl_internal_command(Scsi_Device *dev, char * cmd)
dev94kernel/blk_drv/scsi/scsi_ioctl.chost = dev->host_no;
dev96kernel/blk_drv/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev->index, 1);
dev101kernel/blk_drv/scsi/scsi_ioctl.cif (SCpnt->request.dev != 0xfffe){
dev104kernel/blk_drv/scsi/scsi_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev110kernel/blk_drv/scsi/scsi_ioctl.cif(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0;
dev114kernel/blk_drv/scsi/scsi_ioctl.cif(dev->removable){
dev119kernel/blk_drv/scsi/scsi_ioctl.cif (dev->removable){
dev120kernel/blk_drv/scsi/scsi_ioctl.cdev->changed = 1;
dev127kernel/blk_drv/scsi/scsi_ioctl.cdev->host_no,
dev128kernel/blk_drv/scsi/scsi_ioctl.cdev->id,
dev129kernel/blk_drv/scsi/scsi_ioctl.cdev->lun,
dev139kernel/blk_drv/scsi/scsi_ioctl.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev144kernel/blk_drv/scsi/scsi_ioctl.cstatic int ioctl_command(Scsi_Device *dev, void *buffer)
dev175kernel/blk_drv/scsi/scsi_ioctl.chost = dev->host_no;
dev176kernel/blk_drv/scsi/scsi_ioctl.ccmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5);
dev180kernel/blk_drv/scsi/scsi_ioctl.cSCpnt = allocate_device(NULL, dev->index, 1);
dev186kernel/blk_drv/scsi/scsi_ioctl.cif (SCpnt->request.dev != 0xfffe){
dev189kernel/blk_drv/scsi/scsi_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev197kernel/blk_drv/scsi/scsi_ioctl.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev204kernel/blk_drv/scsi/scsi_ioctl.cprintk("scsi_ioctl : device %d.  command = ", dev->id);
dev226kernel/blk_drv/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
dev230kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd != 0 && dev->index > NR_SCSI_DEVICES))
dev232kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd == 0 && dev->host_no > max_scsi_hosts))
dev238kernel/blk_drv/scsi/scsi_ioctl.cput_fs_long(dev->id + (dev->lun << 8) + 
dev239kernel/blk_drv/scsi/scsi_ioctl.c(dev->host_no << 16), (unsigned long *) arg);
dev242kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_probe(dev->host_no, arg);
dev244kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_command((Scsi_Device *) dev, arg);
dev246kernel/blk_drv/scsi/scsi_ioctl.cif (!dev->removable || !dev->lockable) return 0;
dev248kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev251kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev254kernel/blk_drv/scsi/scsi_ioctl.cif (!dev->removable || !dev->lockable) return 0;
dev256kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev259kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev262kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev265kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev277kernel/blk_drv/scsi/scsi_ioctl.cint kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) {
dev282kernel/blk_drv/scsi/scsi_ioctl.ctmp = scsi_ioctl (dev, cmd, arg);
dev15kernel/blk_drv/scsi/scsi_ioctl.hextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
dev16kernel/blk_drv/scsi/scsi_ioctl.hextern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
dev146kernel/blk_drv/scsi/sd.cprintk("sd%d : rw_intr(%d, %x)\n", MINOR(SCpnt->request.dev), SCpnt->host, result);
dev158kernel/blk_drv/scsi/sd.cprintk("sd%d : %d sectors remain.\n", MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
dev201kernel/blk_drv/scsi/sd.cMINOR(SCpnt->request.dev));
dev254kernel/blk_drv/scsi/sd.cif rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
dev268kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
dev284kernel/blk_drv/scsi/sd.cif (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
dev285kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
dev294kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host_no,
dev295kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
dev296kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
dev319kernel/blk_drv/scsi/sd.cif (CURRENT != NULL && CURRENT->dev == -1) {
dev340kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
dev358kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(req->dev))].device->index);
dev383kernel/blk_drv/scsi/sd.cint dev, block, this_count;
dev389kernel/blk_drv/scsi/sd.cif(SCpnt->request.dev <= 0) {
dev394kernel/blk_drv/scsi/sd.cdev =  MINOR(SCpnt->request.dev);
dev399kernel/blk_drv/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", dev, block);
dev402kernel/blk_drv/scsi/sd.cif (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
dev408kernel/blk_drv/scsi/sd.cblock += sd[dev].start_sect;
dev409kernel/blk_drv/scsi/sd.cdev = DEVICE_NR(dev);
dev411kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].device->changed)
dev422kernel/blk_drv/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
dev428kernel/blk_drv/scsi/sd.cif (!rscsi_disks[dev].device->writeable)
dev481kernel/blk_drv/scsi/sd.cthis_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
dev559kernel/blk_drv/scsi/sd.cprintk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(SCpnt->request.dev),
dev566kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].sector_size == 1024){
dev573kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].sector_size == 256){
dev578kernel/blk_drv/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
dev610kernel/blk_drv/scsi/sd.cSCpnt->transfersize = rscsi_disks[dev].sector_size;
dev614kernel/blk_drv/scsi/sd.cthis_count * rscsi_disks[dev].sector_size,
dev656kernel/blk_drv/scsi/sd.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev690kernel/blk_drv/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
dev699kernel/blk_drv/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
dev714kernel/blk_drv/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
dev723kernel/blk_drv/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
dev741kernel/blk_drv/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
dev751kernel/blk_drv/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
dev753kernel/blk_drv/scsi/sd.cif (SCpnt->request.dev != 0xfffe){
dev756kernel/blk_drv/scsi/sd.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev764kernel/blk_drv/scsi/sd.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev925kernel/blk_drv/scsi/sd.cint revalidate_scsidisk(int dev, int maxusage){
dev932kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(dev));
dev19kernel/blk_drv/scsi/sd_ioctl.cint dev = inode->i_rdev;
dev30kernel/blk_drv/scsi/sd_ioctl.chost = rscsi_disks[MINOR(dev) >> 4].device->host_no;
dev35kernel/blk_drv/scsi/sd_ioctl.cscsi_hosts[host].bios_param(rscsi_disks[MINOR(dev) >> 4].capacity,
dev36kernel/blk_drv/scsi/sd_ioctl.cdev,
dev63kernel/blk_drv/scsi/sd_ioctl.creturn revalidate_scsidisk(dev, 1);
dev65kernel/blk_drv/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
dev1588kernel/blk_drv/scsi/seagate.cint seagate_st0x_biosparam(int size, int dev, int* ip) {
dev1595kernel/blk_drv/scsi/seagate.cdisk = rscsi_disks[MINOR(dev) >> 4].device;
dev212kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
dev221kernel/blk_drv/scsi/sr.cif (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) {
dev222kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0;
dev246kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host_no, 
dev247kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
dev248kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
dev294kernel/blk_drv/scsi/sr.cif (CURRENT != NULL && CURRENT->dev == -1) {
dev303kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
dev322kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(req->dev))].device->index);
dev348kernel/blk_drv/scsi/sr.cunsigned int dev, block, realcount;
dev355kernel/blk_drv/scsi/sr.cif(SCpnt->request.dev <= 0) {
dev360kernel/blk_drv/scsi/sr.cdev =  MINOR(SCpnt->request.dev);
dev365kernel/blk_drv/scsi/sr.cif (dev >= NR_SR)
dev373kernel/blk_drv/scsi/sr.cif (!scsi_CDs[dev].use)
dev381kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].device->changed)
dev435kernel/blk_drv/scsi/sr.cthis_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4;
dev563kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].sector_size == 2048)
dev570kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2;
dev572kernel/blk_drv/scsi/sr.cif (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
dev577kernel/blk_drv/scsi/sr.cthis_count = realcount * (scsi_CDs[dev].sector_size >> 9);
dev594kernel/blk_drv/scsi/sr.cthis_count = realcount * (scsi_CDs[dev].sector_size >> 9);
dev610kernel/blk_drv/scsi/sr.crealcount * scsi_CDs[dev].sector_size, 
dev631kernel/blk_drv/scsi/sr.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev654kernel/blk_drv/scsi/sr.cSCpnt->request.dev = 0xffff;  /* Mark as really busy */
dev662kernel/blk_drv/scsi/sr.cwhile(SCpnt->request.dev != 0xfffe);
dev664kernel/blk_drv/scsi/sr.cif (SCpnt->request.dev != 0xfffe){
dev667kernel/blk_drv/scsi/sr.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev675kernel/blk_drv/scsi/sr.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev18kernel/blk_drv/scsi/sr_ioctl.cextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
dev26kernel/blk_drv/scsi/sr_ioctl.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev51kernel/blk_drv/scsi/sr_ioctl.cif (SCpnt->request.dev != 0xfffe){
dev54kernel/blk_drv/scsi/sr_ioctl.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev86kernel/blk_drv/scsi/sr_ioctl.cSCpnt->request.dev = -1; /* Deallocate */
dev96kernel/blk_drv/scsi/sr_ioctl.cint dev = inode->i_rdev;
dev99kernel/blk_drv/scsi/sr_ioctl.ctarget = MINOR(dev);
dev351kernel/blk_drv/scsi/sr_ioctl.cRO_IOCTLS(dev,arg);
dev107kernel/blk_drv/scsi/st.cif ((st_nbr = SCpnt->request.dev) < NR_ST && st_nbr >= 0) {
dev115kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev117kernel/blk_drv/scsi/st.cSCpnt->request.dev = 0xffff;
dev131kernel/blk_drv/scsi/st.cint dev = SCpnt->request.dev;
dev139kernel/blk_drv/scsi/st.cprintk("st%d: Error: %x\n", dev, result);
dev151kernel/blk_drv/scsi/st.cstatic void write_behind_check(int dev)
dev154kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result < 0) {
dev155kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing);
dev156kernel/blk_drv/scsi/st.csleep_on( &scsi_tapes[dev].waiting );
dev157kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing);
dev161kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing < scsi_tapes[dev].buffer->buffer_bytes)
dev162kernel/blk_drv/scsi/st.cmemcpy(scsi_tapes[dev].buffer->b_data,
dev163kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data + scsi_tapes[dev].buffer->writing,
dev164kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -
dev165kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing);
dev166kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -= scsi_tapes[dev].buffer->writing;
dev167kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = 0;
dev175kernel/blk_drv/scsi/st.cstatic int flush_write_buffer(int dev)
dev183kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing) {
dev184kernel/blk_drv/scsi/st.cwrite_behind_check(dev);
dev185kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result) {
dev187kernel/blk_drv/scsi/st.cprintk("st%d: Async write error %x.\n", dev,
dev188kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->last_result);
dev196kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].dirty==1) {
dev197kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev199kernel/blk_drv/scsi/st.coffset = scsi_tapes[dev].buffer->buffer_bytes;
dev200kernel/blk_drv/scsi/st.ctransfer = ((offset + scsi_tapes[dev].block_size - 1) /
dev201kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size) * scsi_tapes[dev].block_size;
dev203kernel/blk_drv/scsi/st.cprintk("st%d: Flushing %d bytes.\n", dev, transfer);
dev205kernel/blk_drv/scsi/st.cmemset(scsi_tapes[dev].buffer->b_data + offset, 0, transfer - offset);
dev211kernel/blk_drv/scsi/st.cblks = transfer / scsi_tapes[dev].block_size;
dev215kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev217kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data, transfer,
dev220kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev223kernel/blk_drv/scsi/st.cprintk("st%d: Error on flush:\n", dev);
dev230kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev231kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev233kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev244kernel/blk_drv/scsi/st.cint dev;
dev247kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
dev249kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 2)  /* Writing */
dev250kernel/blk_drv/scsi/st.creturn flush_write_buffer(dev);
dev252kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev255kernel/blk_drv/scsi/st.cbackspace = (scsi_tapes[dev].buffer->buffer_bytes +
dev256kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer) / scsi_tapes[dev].block_size -
dev257kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->read_pointer + scsi_tapes[dev].block_size - 1) /
dev258kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev259kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev260kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev265kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev266kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev277kernel/blk_drv/scsi/st.cint dev;
dev283kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
dev284kernel/blk_drv/scsi/st.cif (dev >= NR_ST)
dev286kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].in_use) {
dev287kernel/blk_drv/scsi/st.cprintk("st%d: Device already in use.\n", dev);
dev296kernel/blk_drv/scsi/st.cprintk("st%d: No free buffers.\n", dev);
dev301kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer = st_buffers[i];
dev302kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 1;
dev305kernel/blk_drv/scsi/st.cscsi_tapes[dev].write_prot = ((flags & O_ACCMODE) == O_RDONLY);
dev307kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev308kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 0;
dev309kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev310kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev312kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev314kernel/blk_drv/scsi/st.cprintk("st%d: Tape request not allocated", dev);
dev321kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev323kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev327kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev337kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev339kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev343kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev352kernel/blk_drv/scsi/st.cprintk("st%d: No tape.\n", dev);
dev354kernel/blk_drv/scsi/st.cprintk("st%d: Error %x.\n", dev, SCpnt->result);
dev355kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev356kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev357kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev364kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev366kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev369kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev372kernel/blk_drv/scsi/st.cscsi_tapes[dev].max_block = (scsi_tapes[dev].buffer->b_data[1] << 16) |
dev373kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->b_data[2] << 8) | scsi_tapes[dev].buffer->b_data[3];
dev374kernel/blk_drv/scsi/st.cscsi_tapes[dev].min_block = (scsi_tapes[dev].buffer->b_data[4] << 8) |
dev375kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[5];
dev377kernel/blk_drv/scsi/st.cprintk("st%d: Block limits %d - %d bytes.\n", dev, scsi_tapes[dev].min_block,
dev378kernel/blk_drv/scsi/st.cscsi_tapes[dev].max_block);
dev382kernel/blk_drv/scsi/st.cscsi_tapes[dev].min_block = scsi_tapes[dev].max_block = (-1);
dev384kernel/blk_drv/scsi/st.cprintk("st%d: Can't read block limits.\n", dev);
dev392kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev394kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev397kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev402kernel/blk_drv/scsi/st.cprintk("st%d: No Mode Sense.\n", dev);
dev404kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2] =
dev405kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[3] = 0;
dev407kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev410kernel/blk_drv/scsi/st.cprintk("st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", dev,
dev411kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[0], scsi_tapes[dev].buffer->b_data[1],
dev412kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2], scsi_tapes[dev].buffer->b_data[3]);
dev415kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->b_data[3] >= 8) {
dev416kernel/blk_drv/scsi/st.cscsi_tapes[dev].drv_buffer = (scsi_tapes[dev].buffer->b_data[2] >> 4) & 7;
dev417kernel/blk_drv/scsi/st.cscsi_tapes[dev].density = scsi_tapes[dev].buffer->b_data[4];
dev418kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = scsi_tapes[dev].buffer->b_data[9] * 65536 +
dev419kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] * 256 + scsi_tapes[dev].buffer->b_data[11];
dev421kernel/blk_drv/scsi/st.cprintk("st%d: Density %x, tape length: %x, blocksize: %d, drv buffer: %d\n", dev,
dev422kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4], scsi_tapes[dev].buffer->b_data[5] *
dev423kernel/blk_drv/scsi/st.c65536 + scsi_tapes[dev].buffer->b_data[6] * 256 +
dev424kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[7], scsi_tapes[dev].buffer->b_data[9] *
dev425kernel/blk_drv/scsi/st.c65536 + scsi_tapes[dev].buffer->b_data[10] * 256 +
dev426kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11],
dev427kernel/blk_drv/scsi/st.cscsi_tapes[dev].drv_buffer);
dev429kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size > ST_BUFFER_SIZE) {
dev430kernel/blk_drv/scsi/st.cprintk("st%d: Blocksize %d too large for buffer.\n", dev,
dev431kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size);
dev432kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev433kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev439kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = ST_BLOCK_SIZE;
dev441kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size > 0) {
dev442kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks =
dev443kernel/blk_drv/scsi/st.cST_BUFFER_SIZE / scsi_tapes[dev].block_size;
dev444kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size =
dev445kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size;
dev448kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks = 1;
dev449kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size = ST_BUFFER_SIZE;
dev451kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = scsi_tapes[dev].buffer->read_pointer = 0;
dev454kernel/blk_drv/scsi/st.cprintk("st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev,
dev455kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size, scsi_tapes[dev].buffer->buffer_size,
dev456kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks);
dev459kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->b_data[2] & 0x80) {
dev460kernel/blk_drv/scsi/st.cscsi_tapes[dev].write_prot = 1;
dev462kernel/blk_drv/scsi/st.cprintk( "st%d: Write protected\n", dev);
dev473kernel/blk_drv/scsi/st.cint dev;
dev479kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev);
dev480kernel/blk_drv/scsi/st.crewind = (dev & 0x80) == 0;
dev481kernel/blk_drv/scsi/st.cdev = dev & 127;
dev483kernel/blk_drv/scsi/st.cif ( scsi_tapes[dev].rw == 2) {
dev485kernel/blk_drv/scsi/st.cresult = flush_write_buffer(dev);
dev488kernel/blk_drv/scsi/st.cprintk("st%d: File length %d bytes.\n", dev, filp->f_pos);
dev492kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev498kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev500kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev503kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev506kernel/blk_drv/scsi/st.cprintk("st%d: Error on write filemark.\n", dev);
dev511kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev515kernel/blk_drv/scsi/st.cprintk("st%d: Buffer flushed, EOF written\n", dev);
dev519kernel/blk_drv/scsi/st.cif ((scsi_tapes[dev].eof == 1) && !scsi_tapes[dev].eof_hit)
dev529kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev530kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev539kernel/blk_drv/scsi/st.cint dev;
dev545kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
dev547kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev548kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev553kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev556kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0 && count > ST_BUFFER_SIZE)
dev559kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 1) {
dev563kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 2;
dev567kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing) {
dev568kernel/blk_drv/scsi/st.cwrite_behind_check(dev);
dev569kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result) {
dev571kernel/blk_drv/scsi/st.cprintk("st%d: Async write error %x.\n", dev,
dev572kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->last_result);
dev583kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev589kernel/blk_drv/scsi/st.ccmd[1] = (scsi_tapes[dev].block_size != 0);
dev591kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 2;
dev596kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size != 0 &&
dev597kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_bytes + count) >
dev598kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size)
dev600kernel/blk_drv/scsi/st.c(scsi_tapes[dev].block_size == 0 && count > 0) ||
dev601kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_bytes + count) >=
dev602kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size)
dev605kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev608kernel/blk_drv/scsi/st.cdo_count = scsi_tapes[dev].buffer->buffer_size -
dev609kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes;
dev610kernel/blk_drv/scsi/st.cmemcpy_fromfs(scsi_tapes[dev].buffer->b_data +
dev611kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes, b_point, do_count);
dev613kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev616kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->buffer_blocks;
dev621kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev623kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev624kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size,
dev627kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev631kernel/blk_drv/scsi/st.cprintk("st%d: Error on write:\n", dev);
dev639kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev648kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev649kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev652kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 1;
dev653kernel/blk_drv/scsi/st.cmemcpy_fromfs(scsi_tapes[dev].buffer->b_data +
dev654kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes,b_point,count);
dev656kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes += count;
dev662kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev667kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes >= ST_WRITE_THRESHOLD ||
dev668kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size == 0) {
dev670kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev671kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = scsi_tapes[dev].buffer->buffer_bytes;
dev673kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (scsi_tapes[dev].buffer->buffer_bytes /
dev674kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size) * scsi_tapes[dev].block_size;
dev675kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev677kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev678kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->writing;
dev680kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->writing / scsi_tapes[dev].block_size;
dev684kernel/blk_drv/scsi/st.cSCpnt->result = scsi_tapes[dev].buffer->last_result = -1;
dev686kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev688kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev689kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing,
dev694kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev703kernel/blk_drv/scsi/st.cint dev;
dev709kernel/blk_drv/scsi/st.cdev = MINOR(inode->i_rdev) & 127;
dev711kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev712kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev717kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0 && count > ST_BUFFER_SIZE)
dev720kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 2) {
dev724kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 1;
dev728kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].eof)
dev729kernel/blk_drv/scsi/st.cprintk("st%d: EOF flag up. Bytes %d\n", dev,
dev730kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes);
dev732kernel/blk_drv/scsi/st.cif ((scsi_tapes[dev].buffer->buffer_bytes == 0) &&
dev733kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof == 2)  /* EOM or Blank Check */
dev736kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 1;
dev738kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev742kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes == 0 &&
dev743kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof == 0) {
dev747kernel/blk_drv/scsi/st.ccmd[1] = (scsi_tapes[dev].block_size != 0);
dev748kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev751kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->buffer_blocks;
dev752kernel/blk_drv/scsi/st.cbytes = blks * scsi_tapes[dev].block_size;
dev759kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev761kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev762kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size,
dev765kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev767kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev768kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev772kernel/blk_drv/scsi/st.cprintk("st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", dev,
dev786kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0) {
dev789kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = count - transfer;
dev792kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect block size.\n", dev);
dev793kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev798kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 2; /* What should be done at EOM ? */
dev799kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev800kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_blocks - transfer) *
dev801kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev803kernel/blk_drv/scsi/st.cprintk("st%d: EOM detected (%d blocks read).\n", dev,
dev804kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks - transfer);
dev808kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 1;
dev809kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev810kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev813kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev814kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_blocks - transfer) *
dev815kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev818kernel/blk_drv/scsi/st.cdev, scsi_tapes[dev].buffer->buffer_blocks - transfer, total);
dev824kernel/blk_drv/scsi/st.cprintk("st%d: Tape error. Sense key %x\n", dev,
dev828kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev837kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev842kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = bytes;
dev847kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes > 0) {
dev849kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].eof)
dev850kernel/blk_drv/scsi/st.cprintk("st%d: EOF up. Left %d, needed %d.\n", dev,
dev851kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes, count - total);
dev853kernel/blk_drv/scsi/st.ctransfer = scsi_tapes[dev].buffer->buffer_bytes < count - total ?
dev854kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes : count - total;
dev855kernel/blk_drv/scsi/st.cmemcpy_tofs(buf, scsi_tapes[dev].buffer->b_data +
dev856kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer,transfer);
dev860kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -= transfer;
dev861kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer += transfer;
dev863kernel/blk_drv/scsi/st.celse if (scsi_tapes[dev].eof) {
dev864kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 1;
dev865kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev866kernel/blk_drv/scsi/st.cif (total == 0 && scsi_tapes[dev].eof == 1)
dev867kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev868kernel/blk_drv/scsi/st.cif (total == 0 && scsi_tapes[dev].eof == 2)
dev873kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0)
dev878kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev888kernel/blk_drv/scsi/st.cint dev = MINOR(inode->i_rdev);
dev895kernel/blk_drv/scsi/st.cdev = dev & 127;
dev907kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape forward %d files.\n", dev,
dev923kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape backward %d files.\n", dev, (-ltmp));
dev933kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape forward %d blocks.\n", dev,
dev948kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape backward %d blocks.\n", dev, (-ltmp));
dev952kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev960kernel/blk_drv/scsi/st.cprintk("st%d: Writing %d filemarks.\n", dev,
dev971kernel/blk_drv/scsi/st.cprintk("st%d: Rewinding tape.\n", dev);
dev981kernel/blk_drv/scsi/st.cprintk("st%d: Unloading tape.\n", dev);
dev986kernel/blk_drv/scsi/st.cprintk("st%d: No op on tape.\n", dev);
dev998kernel/blk_drv/scsi/st.cprintk("st%d: Retensioning tape.\n", dev);
dev1005kernel/blk_drv/scsi/st.cprintk("st%d: Spacing to end of recorded medium.\n", dev);
dev1009kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev1014kernel/blk_drv/scsi/st.cprintk("st%d: Erasing tape.\n", dev);
dev1018kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2) {
dev1038kernel/blk_drv/scsi/st.cprintk("st%d: Seeking tape to block %d.\n", dev, arg);
dev1044kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].dirty || scsi_tapes[dev].buffer->buffer_bytes != 0)
dev1048kernel/blk_drv/scsi/st.c(arg < scsi_tapes[dev].min_block || arg > scsi_tapes[dev].max_block ||
dev1050kernel/blk_drv/scsi/st.cprintk("st%d: Illegal block size.\n", dev);
dev1056kernel/blk_drv/scsi/st.cmemset(scsi_tapes[dev].buffer->b_data, 0, 12);
dev1058kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2] = (arg & 7) << 4;
dev1060kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2] = 
dev1061kernel/blk_drv/scsi/st.cscsi_tapes[dev].drv_buffer << 4;
dev1062kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[3] = 8;     /* block descriptor length */
dev1064kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4] = arg;
dev1066kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4] = scsi_tapes[dev].density;
dev1070kernel/blk_drv/scsi/st.cltmp = scsi_tapes[dev].block_size;
dev1071kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[9] = (ltmp >> 16);
dev1072kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] = (ltmp >> 8);
dev1073kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11] = ltmp;
dev1077kernel/blk_drv/scsi/st.cprintk("st%d: Setting block size to %d bytes.\n", dev,
dev1078kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[9] * 65536 +
dev1079kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] * 256 +
dev1080kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11]);
dev1082kernel/blk_drv/scsi/st.cprintk("st%d: Setting density code to %x.\n", dev,
dev1083kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4]);
dev1086kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->b_data[2] >> 4) & 7);
dev1090kernel/blk_drv/scsi/st.cprintk("st%d: Unknown st_ioctl command %x.\n", dev, cmd_in);
dev1094kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev1096kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev1098kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, ST_BLOCK_SIZE,
dev1101kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev1105kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev1113kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = arg;
dev1115kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks =
dev1116kernel/blk_drv/scsi/st.cST_BUFFER_SIZE / scsi_tapes[dev].block_size;
dev1117kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size =
dev1118kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size;
dev1121kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks = 1;
dev1122kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size = ST_BUFFER_SIZE;
dev1124kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev1125kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev1128kernel/blk_drv/scsi/st.cscsi_tapes[dev].drv_buffer = arg;
dev1130kernel/blk_drv/scsi/st.cscsi_tapes[dev].density = arg;
dev1132kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 2;
dev1133kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev1136kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev1137kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev1150kernel/blk_drv/scsi/st.cint dev = MINOR(inode->i_rdev);
dev1157kernel/blk_drv/scsi/st.cdev = dev & 127;
dev1159kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev1160kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev1193kernel/blk_drv/scsi/st.cmemcpy_tofs((char *)arg, (char *)scsi_tapes[dev].buffer->mt_status,
dev1199kernel/blk_drv/scsi/st.cprintk("st%d: get tape position.\n", dev);
dev1212kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev1216kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2) {
dev1224kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev1227kernel/blk_drv/scsi/st.c(void *) scmd, (void *) scsi_tapes[dev].buffer->b_data,
dev1230kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev1235kernel/blk_drv/scsi/st.cprintk("st%d: Can't read tape position.\n", dev);
dev1241kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2)
dev1242kernel/blk_drv/scsi/st.cmt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[0] << 16) 
dev1243kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[1] << 8) 
dev1244kernel/blk_drv/scsi/st.c+ scsi_tapes[dev].buffer->b_data[2];
dev1246kernel/blk_drv/scsi/st.cmt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[4] << 24)
dev1247kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[5] << 16) 
dev1248kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[6] << 8) 
dev1249kernel/blk_drv/scsi/st.c+ scsi_tapes[dev].buffer->b_data[7];
dev1253kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev1259kernel/blk_drv/scsi/st.creturn scsi_ioctl(scsi_tapes[dev].device, cmd_in, (void *) arg);
dev509kernel/blk_drv/scsi/ultrastor.cint ultrastor_biosparam(int size, int dev, int *ip)
dev604kernel/blk_drv/scsi/wd7000.cint wd7000_biosparam(int size, int dev, int* ip)
dev155kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
dev157kernel/blk_drv/xd.cif (dev < xd_drives) {
dev158kernel/blk_drv/xd.cwhile (!xd_valid[dev])
dev161kernel/blk_drv/xd.cxd_access[dev]++;
dev179kernel/blk_drv/xd.cif (CURRENT_DEV < xd_drives && CURRENT->sector + CURRENT->nr_sectors <= xd[MINOR(CURRENT->dev)].nr_sects) {
dev180kernel/blk_drv/xd.cblock = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect;
dev199kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev)),err;
dev201kernel/blk_drv/xd.cif (inode && (dev < xd_drives))
dev206kernel/blk_drv/xd.cput_fs_byte(xd_info[dev].heads,(char *) &geometry->heads);
dev207kernel/blk_drv/xd.cput_fs_byte(xd_info[dev].sectors,(char *) &geometry->sectors);
dev208kernel/blk_drv/xd.cput_fs_word(xd_info[dev].cylinders,(short *) &geometry->cylinders);
dev238kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
dev240kernel/blk_drv/xd.cif (dev < xd_drives) {
dev241kernel/blk_drv/xd.csync_dev(dev);
dev242kernel/blk_drv/xd.cxd_access[dev]--;
dev247kernel/blk_drv/xd.cstatic int xd_reread_partitions(int dev)
dev249kernel/blk_drv/xd.cint target = DEVICE_NR(MINOR(dev)),start = target << xd_gendisk.minor_shift,partition;
dev1810kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
dev1817kernel/chr_drv/tpqic02.cMINOR(dev), buf, count, filp->f_pos, flags);
dev1980kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
dev1986kernel/chr_drv/tpqic02.cMINOR(dev), buf, count, filp->f_pos, flags);
dev2126kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
dev2133kernel/chr_drv/tpqic02.cif (TP_DIAGS(dev)) {
dev2134kernel/chr_drv/tpqic02.cprintk("tape_qic02_open: dev=%x, flags=%x     ", dev, flags);
dev2137kernel/chr_drv/tpqic02.cif (MINOR(dev)==255)  /* special case for resetting */
dev2184kernel/chr_drv/tpqic02.cif ((TP_DENS(dev)!=0) && (TP_DENS(current_tape_dev) != TP_DENS(dev))) {
dev2195kernel/chr_drv/tpqic02.ccurrent_tape_dev = dev;
dev2234kernel/chr_drv/tpqic02.cif (TP_DENS(current_tape_dev) == TP_DENS(dev) )
dev2237kernel/chr_drv/tpqic02.ccurrent_tape_dev = dev;
dev2239kernel/chr_drv/tpqic02.cdens = TP_DENS(dev);
dev2245kernel/chr_drv/tpqic02.cswitch (TP_DENS(dev)) {
dev2289kernel/chr_drv/tpqic02.cdev_t dev = inode->i_rdev;
dev2291kernel/chr_drv/tpqic02.cif (TP_DIAGS(dev))
dev2292kernel/chr_drv/tpqic02.cprintk("tape_qic02_release: dev=%x\n", dev);
dev2309kernel/chr_drv/tpqic02.cif ((TP_REWCLOSE(dev)) && (status_bytes_rd | status_bytes_wr)) {
dev248kernel/chr_drv/tty_io.cint dev;
dev252kernel/chr_drv/tty_io.cdev = 0x0400 + tty->line;
dev256kernel/chr_drv/tty_io.cif (filp->f_rdev != dev)
dev990kernel/chr_drv/tty_io.cint i, dev;
dev993kernel/chr_drv/tty_io.cdev = file->f_rdev;
dev994kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev995kernel/chr_drv/tty_io.cprintk("tty_read: bad pseudo-major nr #%d\n", MAJOR(dev));
dev998kernel/chr_drv/tty_io.cdev = MINOR(dev);
dev999kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev1004kernel/chr_drv/tty_io.c(current->tty == dev) &&
dev1023kernel/chr_drv/tty_io.cint dev, i, is_console;
dev1026kernel/chr_drv/tty_io.cdev = file->f_rdev;
dev1028kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev1032kernel/chr_drv/tty_io.cdev = MINOR(dev);
dev1036kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev1040kernel/chr_drv/tty_io.c(current->tty == dev) && (tty->pgrp != current->pgrp)) {
dev1062kernel/chr_drv/tty_io.cstatic int init_dev(int dev)
dev1069kernel/chr_drv/tty_io.co_dev = PTY_OTHER(dev);
dev1075kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev) && tty_table[dev] && tty_table[dev]->count)
dev1078kernel/chr_drv/tty_io.cif (!tty_table[dev] && !tty) {
dev1081kernel/chr_drv/tty_io.cinitialize_tty_struct(dev, tty);
dev1084kernel/chr_drv/tty_io.cif (!tty_termios[dev] && !tp) {
dev1089kernel/chr_drv/tty_io.cinitialize_termios(dev, tp);
dev1092kernel/chr_drv/tty_io.cif (!termios_locked[dev] && !ltp) {
dev1100kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1128kernel/chr_drv/tty_io.cif (!tty_termios[dev]) {
dev1129kernel/chr_drv/tty_io.ctty_termios[dev] = tp;
dev1132kernel/chr_drv/tty_io.cif (!tty_table[dev]) {
dev1133kernel/chr_drv/tty_io.ctty->termios = tty_termios[dev];
dev1134kernel/chr_drv/tty_io.ctty_table[dev] = tty;
dev1137kernel/chr_drv/tty_io.cif (!termios_locked[dev]) {
dev1138kernel/chr_drv/tty_io.ctermios_locked[dev] = ltp;
dev1141kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1155kernel/chr_drv/tty_io.ctty_table[dev]->link = tty_table[o_dev];
dev1156kernel/chr_drv/tty_io.ctty_table[o_dev]->link = tty_table[dev];
dev1158kernel/chr_drv/tty_io.ctty_table[dev]->count++;
dev1159kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev))
dev1183kernel/chr_drv/tty_io.cstatic void release_dev(int dev, struct file * filp)
dev1189kernel/chr_drv/tty_io.ctty = tty_table[dev];
dev1190kernel/chr_drv/tty_io.ctp = tty_termios[dev];
dev1194kernel/chr_drv/tty_io.cprintk("release_dev: tty_table[%d] was NULL\n", dev);
dev1198kernel/chr_drv/tty_io.cprintk("release_dev: tty_termios[%d] was NULL\n", dev);
dev1201kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1202kernel/chr_drv/tty_io.co_tty = tty_table[PTY_OTHER(dev)];
dev1203kernel/chr_drv/tty_io.co_tp = tty_termios[PTY_OTHER(dev)];
dev1205kernel/chr_drv/tty_io.cprintk("release_dev: pty pair(%d) was NULL\n", dev);
dev1209kernel/chr_drv/tty_io.cprintk("release_dev: pty pair(%d) termios was NULL\n", dev);
dev1220kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev)) {
dev1223kernel/chr_drv/tty_io.cdev, tty->count);
dev1229kernel/chr_drv/tty_io.cdev, tty->count);
dev1251kernel/chr_drv/tty_io.ctty_table[PTY_OTHER(dev)] = NULL;
dev1252kernel/chr_drv/tty_io.ctty_termios[PTY_OTHER(dev)] = NULL;
dev1255kernel/chr_drv/tty_io.ctty_table[dev] = NULL;
dev1256kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1257kernel/chr_drv/tty_io.ctty_termios[dev] = NULL;
dev1353kernel/chr_drv/tty_io.cint dev;
dev1355kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev1356kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev1360kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev1361kernel/chr_drv/tty_io.cif (!dev) {
dev1365kernel/chr_drv/tty_io.crelease_dev(dev, filp);
dev1370kernel/chr_drv/tty_io.cint dev;
dev1373kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev1374kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev1378kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev1379kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev1381kernel/chr_drv/tty_io.cprintk("tty_select: tty struct for dev %d was NULL\n", dev);
dev407kernel/chr_drv/tty_ioctl.cint dev;
dev415kernel/chr_drv/tty_ioctl.cdev = MINOR(file->f_rdev);
dev416kernel/chr_drv/tty_ioctl.ctty = TTY_TABLE(dev);
dev419kernel/chr_drv/tty_ioctl.cif (IS_A_PTY(dev))
dev420kernel/chr_drv/tty_ioctl.cother_tty = tty_table[PTY_OTHER(dev)];
dev424kernel/chr_drv/tty_ioctl.ctermios_dev = dev;
dev425kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev)) {
dev427kernel/chr_drv/tty_ioctl.ctermios_dev = PTY_OTHER(dev);
dev494kernel/chr_drv/tty_ioctl.ccurrent->tty = dev;
dev538kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev562kernel/chr_drv/tty_ioctl.cif (IS_A_CONSOLE(dev)) {
dev572kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev574kernel/chr_drv/tty_ioctl.celse if (IS_A_PTY_SLAVE(dev))
dev616kernel/chr_drv/tty_ioctl.cif (!IS_A_PTY_MASTER(dev))
dev47net/ddi.cregister struct ddi_device *dev;
dev50net/ddi.cdev = devices;
dev51net/ddi.cwhile (dev->title != NULL) {
dev52net/ddi.cif (strncmp(dev->name, id, DDI_MAXNAME) == 0) {
dev53net/ddi.cPRINTK (("OK at 0x%X\n", dev));
dev54net/ddi.creturn(dev);
dev56net/ddi.cdev++;
dev72net/ddi.cstruct ddi_device *dev;
dev84net/ddi.cdev = devices;
dev85net/ddi.cwhile (dev->title != NULL) {
dev86net/ddi.c(*dev->init)(dev);
dev87net/ddi.cdev++;
dev280net/drv/slip/slip.cstruct device *dev;
dev293net/drv/slip/slip.cdev = sl->dev;
dev296net/drv/slip/slip.cdone = dev_rint(p, len, 0, dev);
dev361net/drv/slip/slip.csl_start_xmit(void /*struct sk_buff*/ *skb, void /*struct device*/ *dev)
dev368net/drv/slip/slip.csl = &sl_ctrl[dev->base_addr];
dev406net/drv/slip/slip.csl_type_trans (void /*struct sk_buff*/ *skb, void /*struct device*/ *dev)
dev411net/drv/slip/slip.csl = sl_ctrl[dev->base_addr];
dev421net/drv/slip/slip.csl_open(void /*struct device*/ *dev)
dev426net/drv/slip/slip.csl = &sl_ctrl[dev->base_addr];
dev442net/drv/slip/slip.csl_close(void /*struct device*/ *dev)
dev447net/drv/slip/slip.csl = &sl_ctrl[dev->base_addr];
dev460net/drv/slip/slip.cdel_devroute(dev);
dev461net/drv/slip/slip.cdev->up = 0;
dev575net/drv/slip/slip.c(void) sl_open(sl->dev);
dev600net/drv/slip/slip.c(void) sl_close(sl->dev);
dev607net/drv/slip/slip.cslip_init(struct ddi *dev)
dev616net/drv/slip/slip.csl = &sl_ctrl[dev->base_addr];
dev628net/drv/slip/slip.csl->line             = dev->base_addr;  /* SLIP channel number  */
dev630net/drv/slip/slip.csl->dev              = dev;    /* pointer to DEVICE  */
dev641net/drv/slip/slip.cdev->mtu             = SL_MTU;
dev642net/drv/slip/slip.cdev->rmem_end        = (unsigned long)&sl->rcv_queue.buf[SL_BUF_SIZE-1];
dev643net/drv/slip/slip.cdev->rmem_start      = (unsigned long)&sl->rcv_queue.buf[0];
dev644net/drv/slip/slip.cdev->mem_end         = (unsigned long)&sl->xbuff[(SL_MTU * 2) -1];
dev645net/drv/slip/slip.cdev->mem_start       = (unsigned long)&sl->xbuff[0];
dev646net/drv/slip/slip.cdev->hard_start_xmit = sl_start_xmit;
dev647net/drv/slip/slip.cdev->open            = sl_open;
dev648net/drv/slip/slip.cdev->stop            = sl_close;
dev649net/drv/slip/slip.cdev->hard_header     = sl_hard_header;
dev650net/drv/slip/slip.cdev->add_arp         = sl_add_arp;
dev651net/drv/slip/slip.cdev->type_trans      = sl_type_trans;
dev652net/drv/slip/slip.cdev->hard_header_len = 0;
dev653net/drv/slip/slip.cdev->addr_len        = 0;
dev654net/drv/slip/slip.cdev->type            = 0;  /* FIXME: ??? */
dev655net/drv/slip/slip.cdev->queue_xmit      = dev_queue_xmit;
dev656net/drv/slip/slip.cdev->rebuild_header  = sl_rebuild_header;
dev657net/drv/slip/slip.cfor (i = 0; i < DEV_NUMBUFFS; i++) dev->buffs[i] = NULL;
dev41net/drv/slip/slip.hstruct device    *dev;    /* easy for intr handling  */
dev62net/drv/slip/slip.hextern int slip_init(struct ddi *dev);
dev57net/drv/we8003/handler.cwd_start(struct device *dev)
dev68net/drv/we8003/handler.cdev->start = 1;
dev72net/drv/we8003/handler.cwd8003_open(struct device *dev)
dev107net/drv/we8003/handler.coutb_p(dev->dev_addr[i],WD_PAR0+i);
dev114net/drv/we8003/handler.coutb_p(dev->broadcast[i],WD_MAR0+i);
dev121net/drv/we8003/handler.cwd_start(dev); 
dev127net/drv/we8003/handler.cwdget(volatile struct wd_ring *ring, struct device *dev)
dev139net/drv/we8003/handler.creturn (dev_rint(fptr, len, 0, dev));
dev143net/drv/we8003/handler.cwd8003_start_xmit(struct sk_buff *skb, struct device *dev)
dev149net/drv/we8003/handler.cif (dev->tbusy)
dev152net/drv/we8003/handler.cif (jiffies - dev->trans_start < 30)
dev159net/drv/we8003/handler.cdev->tbusy = 1;
dev164net/drv/we8003/handler.cwd_trs(dev);
dev169net/drv/we8003/handler.cif (skb->dev != dev)
dev178net/drv/we8003/handler.cif ( dev->rebuild_header (skb+1, dev)) 
dev181net/drv/we8003/handler.cif (skb->dev == dev)
dev186net/drv/we8003/handler.cdev->tbusy = 0;
dev192net/drv/we8003/handler.cmemcpy ((unsigned char *)dev->mem_start, skb+1, skb->len);
dev197net/drv/we8003/handler.cdev->trans_start = jiffies;
dev207net/drv/we8003/handler.cif (!(dev->interrupt))
dev227net/drv/we8003/handler.cwd_put_bnd(unsigned char bnd, struct device *dev )
dev244net/drv/we8003/handler.cwd_get_bnd( struct device *dev )
dev262net/drv/we8003/handler.cwd_get_cur( struct device *dev )
dev284net/drv/we8003/handler.cwd_rcv( struct device *dev )
dev295net/drv/we8003/handler.ccur = wd_get_cur( dev );
dev296net/drv/we8003/handler.cbnd = wd_get_bnd( dev );
dev306net/drv/we8003/handler.cring = (volatile struct wd_ring *) (dev->mem_start + (pkt << 8));
dev320net/drv/we8003/handler.cdone = wdget( ring, dev ); /* get the packet */
dev328net/drv/we8003/handler.cwd_put_bnd(bnd, dev);
dev331net/drv/we8003/handler.ccur = wd_get_cur(dev);
dev342net/drv/we8003/handler.cif( ( bnd = wd_get_cur( dev ) - 1 ) < WD_TXBS )
dev344net/drv/we8003/handler.cwd_put_bnd( bnd, dev );
dev351net/drv/we8003/handler.cdone = dev_rint(NULL, 0,0, dev);
dev366net/drv/we8003/handler.cwd_rx_over( struct device *dev )
dev383net/drv/we8003/handler.cwd_rcv( dev );  /* clear out received packets */
dev399net/drv/we8003/handler.cwd_trs( struct device *dev )
dev411net/drv/we8003/handler.cdev->tbusy = 0;
dev416net/drv/we8003/handler.clen = dev_tint( (unsigned char *)dev->mem_start, dev );
dev428net/drv/we8003/handler.cdev->tbusy = 0
dev454net/drv/we8003/handler.cstruct device *dev;
dev461net/drv/we8003/handler.cfor (dev = dev_base; dev != NULL; dev = dev->next)
dev463net/drv/we8003/handler.cif (dev->irq == irq) break;
dev465net/drv/we8003/handler.cif (dev == NULL) 
dev481net/drv/we8003/handler.cdev->interrupt = 1;
dev489net/drv/we8003/handler.cprintk("\nwd8013 overrun bnd = %d, cur = %d", wd_get_bnd( dev ), wd_get_cur( dev ) );
dev490net/drv/we8003/handler.cwd_rx_over( dev ); /* performs wd_rcv() as well */
dev494net/drv/we8003/handler.cwd_rcv( dev );
dev500net/drv/we8003/handler.cwd_trs( dev );
dev533net/drv/we8003/handler.cwd_trs( dev );
dev558net/drv/we8003/handler.cdev->interrupt = 0;
dev594net/drv/we8003/handler.cwe8003_8bit(struct ddi *dev)
dev601net/drv/we8003/handler.cio = dev->config.ioaddr;
dev612net/drv/we8003/handler.cdev->flags |= DDI_FBUS16;
dev624net/drv/we8003/handler.cwe8003_cmem(struct ddi *dev)
dev628net/drv/we8003/handler.cio = dev->config.ioaddr;
dev637net/drv/we8003/handler.cwe8003_geth(struct ddi *dev)
dev642net/drv/we8003/handler.cio = dev->config.ioaddr;
dev644net/drv/we8003/handler.cdev->dev_addr[i] = inb_p(io + WD_ROM + i);
dev645net/drv/we8003/handler.cdev->broadcast[i] = 0xff;
dev652net/drv/we8003/handler.cwe8003_conf(struct ddi *dev)
dev659net/drv/we8003/handler.cif (dev->config.ioaddr == 0) return(0);  /* fake it's OK */
dev660net/drv/we8003/handler.cif (we8003_probe(&dev->config) < 0) return(1);
dev663net/drv/we8003/handler.cwe8003_8bit(dev);
dev666net/drv/we8003/handler.cwe8003_cmem(dev);
dev669net/drv/we8003/handler.cwe8003_geth(dev);
dev674net/drv/we8003/handler.cdev->tbusy = 0;
dev675net/drv/we8003/handler.cdev->interrupt = 0;
dev676net/drv/we8003/handler.cif (irqaction (dev->irq, &we8003_sigaction)) {
dev677net/drv/we8003/handler.cprintk("%s: unable to get IRQ%d\n", dev->name, dev->irq);
dev33net/drv/we8003/main.cwe_getconf(struct ddi_device *dev, struct ddconf *cp)
dev35net/drv/we8003/main.ccp->ioaddr = dev->config.ioaddr;  /* I/O base address    */
dev37net/drv/we8003/main.ccp->irq = dev->config.irq;    /* IRQ channel      */
dev39net/drv/we8003/main.ccp->memaddr = dev->config.memaddr;  /* RAM base address    */
dev40net/drv/we8003/main.ccp->memsize = dev->config.memsize;  /* RAM size      */
dev46net/drv/we8003/main.cwe_setconf(struct ddi_device *dev, struct ddconf *cp)
dev48net/drv/we8003/main.cdev->config.ioaddr = cp->ioaddr;  /* I/O base address    */
dev49net/drv/we8003/main.cdev->config.irq = cp->irq;    /* IRQ channel      */
dev50net/drv/we8003/main.cdev->config.memaddr = cp->memaddr;  /* RAM base address    */
dev51net/drv/we8003/main.cdev->config.memsize = cp->memsize;  /* RAM size      */
dev53net/drv/we8003/main.cdev->name, dev->config.ioaddr, dev->config.irq,
dev54net/drv/we8003/main.cdev->config.memaddr, dev->config.memsize));
dev66net/drv/we8003/main.cstruct ddi_device *dev;
dev70net/drv/we8003/main.cdev = we_ptrs[minor];
dev71net/drv/we8003/main.cif (dev == NULL || (dev->flags & DDI_FREADY) == 0) return(-ENODEV);
dev81net/drv/we8003/main.cstruct ddi_device *dev;
dev85net/drv/we8003/main.cdev = we_ptrs[minor];
dev86net/drv/we8003/main.cif (dev == NULL || (dev->flags & DDI_FREADY) == 0) return;
dev95net/drv/we8003/main.cstruct ddi_device *dev;
dev100net/drv/we8003/main.cdev = we_ptrs[minor];
dev101net/drv/we8003/main.cif (dev == NULL || (dev->flags & DDI_FREADY) == 0) return(-ENODEV);
dev106net/drv/we8003/main.cmemcpy_tofs((void *)arg, dev->name, DDI_MAXNAME);
dev110net/drv/we8003/main.cret = we_getconf(dev, &conf);
dev115net/drv/we8003/main.cret = we_setconf(dev, &conf);
dev139net/drv/we8003/main.cwe8003_init(struct ddi_device *dev)
dev150net/drv/we8003/main.cwe_ptrs[unit_nr] = dev;
dev151net/drv/we8003/main.cdev->unit = unit_nr++;
dev152net/drv/we8003/main.csprintf(dev->name, WE_NAME, dev->unit);
dev153net/drv/we8003/main.cdev->flags |= DDI_FREADY;
dev156net/drv/we8003/main.cPRINTK (("%s: version %s: ", dev->title, VERSION));
dev157net/drv/we8003/main.c(void) we_setconf(dev, &dev->config);
dev160net/drv/we8003/main.cif (dev->major != 0) {
dev161net/drv/we8003/main.cif (dev->flags & DDI_FBLKDEV) {
dev162net/drv/we8003/main.cif (register_blkdev(dev->major, "WE8003", &we_fops) < 0) {
dev164net/drv/we8003/main.cdev->name, dev->major);
dev168net/drv/we8003/main.cif (dev->flags & DDI_FCHRDEV) {
dev169net/drv/we8003/main.cif (register_chrdev(dev->major, "WE8003", &we_fops) < 0) {
dev171net/drv/we8003/main.cdev->name, dev->major);
dev31net/drv/we8003/we8003.hextern int  we8003_init(struct ddi_device *dev);
dev92net/inet/3c509.cstatic int el3_open(struct device *dev);
dev93net/inet/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
dev95net/inet/3c509.cstatic void update_stats(int addr, struct device *dev);
dev96net/inet/3c509.cstatic struct enet_statistics *el3_get_stats(struct device *dev);
dev97net/inet/3c509.cstatic int el3_rx(struct device *dev);
dev98net/inet/3c509.cstatic int el3_close(struct device *dev);
dev102net/inet/3c509.cint el3_probe(struct device *dev)
dev106net/inet/3c509.cshort *phys_addr = (short *)dev->dev_addr;
dev137net/inet/3c509.cdev->if_port = iobase >> 14;
dev145net/inet/3c509.cif (dev->base_addr != 0
dev146net/inet/3c509.c&&  dev->base_addr != (unsigned short)ioaddr) {
dev160net/inet/3c509.cdev->base_addr = ioaddr;
dev161net/inet/3c509.cdev->irq = irq;
dev162net/inet/3c509.csnarf_region(dev->base_addr, 16);
dev167net/inet/3c509.cdev->name, dev->base_addr, current_tag, if_names[dev->if_port]);
dev172net/inet/3c509.cprintk(" %2.2x", dev->dev_addr[i]);
dev173net/inet/3c509.cprintk(", IRQ %d.\n", dev->irq);
dev176net/inet/3c509.cdev->priv = kmalloc(sizeof(struct el3_private), GFP_KERNEL);
dev177net/inet/3c509.cmemset(dev->priv, 0, sizeof(struct el3_private));
dev183net/inet/3c509.cdev->open = &el3_open;
dev184net/inet/3c509.cdev->hard_start_xmit = &el3_start_xmit;
dev185net/inet/3c509.cdev->stop = &el3_close;
dev186net/inet/3c509.cdev->get_stats = &el3_get_stats;
dev190net/inet/3c509.cdev->buffs[i] = NULL;
dev192net/inet/3c509.cdev->hard_header  = eth_header;
dev193net/inet/3c509.cdev->add_arp  = eth_add_arp;
dev194net/inet/3c509.cdev->queue_xmit  = dev_queue_xmit;
dev195net/inet/3c509.cdev->rebuild_header  = eth_rebuild_header;
dev196net/inet/3c509.cdev->type_trans  = eth_type_trans;
dev198net/inet/3c509.cdev->type    = ARPHRD_ETHER;
dev199net/inet/3c509.cdev->hard_header_len = ETH_HLEN;
dev200net/inet/3c509.cdev->mtu    = 1500; /* eth_mtu */
dev201net/inet/3c509.cdev->addr_len  = ETH_ALEN;
dev203net/inet/3c509.cdev->broadcast[i]=0xff;
dev207net/inet/3c509.cdev->flags    = IFF_BROADCAST;
dev208net/inet/3c509.cdev->family    = AF_INET;
dev209net/inet/3c509.cdev->pa_addr  = 0;
dev210net/inet/3c509.cdev->pa_brdaddr  = 0;
dev211net/inet/3c509.cdev->pa_mask  = 0;
dev212net/inet/3c509.cdev->pa_alen  = sizeof(unsigned long);
dev243net/inet/3c509.cel3_open(struct device *dev)
dev245net/inet/3c509.cint ioaddr = dev->base_addr;
dev248net/inet/3c509.cif (request_irq(dev->irq, &el3_interrupt)) {
dev254net/inet/3c509.cprintk("%s: Opening, IRQ %d  status@%x %4.4x.\n", dev->name,
dev255net/inet/3c509.cdev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
dev260net/inet/3c509.cirq2dev_map[dev->irq] = dev;
dev263net/inet/3c509.coutw((dev->irq << 12) | 0x0f00, ioaddr + 8);
dev269net/inet/3c509.coutb(dev->dev_addr[i], ioaddr + i);
dev271net/inet/3c509.cif (dev->if_port == 3)
dev274net/inet/3c509.celse if (dev->if_port == 0) {
dev288net/inet/3c509.cdev->interrupt = 0;
dev289net/inet/3c509.cdev->tbusy = 0;
dev290net/inet/3c509.cdev->start = 1;
dev295net/inet/3c509.cdev->name, dev->irq, inw(ioaddr + EL3_STATUS));
dev301net/inet/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
dev303net/inet/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
dev304net/inet/3c509.cint ioaddr = dev->base_addr;
dev307net/inet/3c509.cif (dev->tbusy) {
dev308net/inet/3c509.cint tickssofar = jiffies - dev->trans_start;
dev312net/inet/3c509.cdev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS));
dev313net/inet/3c509.cdev->trans_start = jiffies;
dev317net/inet/3c509.cdev->tbusy = 0;
dev321net/inet/3c509.cdev_tint(dev);
dev326net/inet/3c509.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
dev327net/inet/3c509.cskb->dev = dev;
dev337net/inet/3c509.cdev->name, skb->len, inw(ioaddr + EL3_STATUS));
dev342net/inet/3c509.cdev->name, inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
dev350net/inet/3c509.cdev->tbusy=1;
dev358net/inet/3c509.cdev->trans_start = jiffies;
dev363net/inet/3c509.cdev->tbusy=0;
dev393net/inet/3c509.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
dev397net/inet/3c509.cif (dev == NULL) {
dev402net/inet/3c509.cif (dev->interrupt)
dev403net/inet/3c509.cprintk("%s: Re-entering the interrupt handler.\n", dev->name);
dev404net/inet/3c509.cdev->interrupt = 1;
dev406net/inet/3c509.cioaddr = dev->base_addr;
dev410net/inet/3c509.cprintk("%s: interrupt, status %4.4x.\n", dev->name, status);
dev415net/inet/3c509.cel3_rx(dev);
dev422net/inet/3c509.cdev->tbusy = 0;
dev426net/inet/3c509.cupdate_stats(ioaddr, dev);
dev430net/inet/3c509.cdev->name, status);
dev438net/inet/3c509.cprintk("%s: exiting interrupt, status %4.4x.\n", dev->name,
dev442net/inet/3c509.cdev->interrupt = 0;
dev448net/inet/3c509.cel3_get_stats(struct device *dev)
dev450net/inet/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
dev453net/inet/3c509.cupdate_stats(dev->base_addr, dev);
dev462net/inet/3c509.cstatic void update_stats(int ioaddr, struct device *dev)
dev464net/inet/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
dev491net/inet/3c509.cel3_rx(struct device *dev)
dev493net/inet/3c509.cstruct el3_private *lp = (struct el3_private *)dev->priv;
dev494net/inet/3c509.cint ioaddr = dev->base_addr;
dev527net/inet/3c509.cskb->dev = dev;
dev540net/inet/3c509.cIN_SKBUFF,dev)== 0){
dev553net/inet/3c509.cprintk("%s: receive buffers full.\n", dev->name);
dev559net/inet/3c509.cdev->name, sksize);
dev576net/inet/3c509.cel3_close(struct device *dev)
dev578net/inet/3c509.cint ioaddr = dev->base_addr;
dev581net/inet/3c509.cprintk("%s: Shutting down ethercard.\n", dev->name);
dev583net/inet/3c509.cdev->tbusy = 1;
dev584net/inet/3c509.cdev->start = 0;
dev593net/inet/3c509.cif (dev->if_port == 3)
dev596net/inet/3c509.celse if (dev->if_port == 0) {
dev602net/inet/3c509.cfree_irq(dev->irq);
dev609net/inet/3c509.cirq2dev_map[dev->irq] = 0;
dev611net/inet/3c509.cupdate_stats(ioaddr, dev);
dev78net/inet/8390.cint ei_open(struct device *dev);
dev81net/inet/8390.cstatic void ei_tx_intr(struct device *dev);
dev82net/inet/8390.cstatic void ei_receive(struct device *dev);
dev83net/inet/8390.cstatic void ei_rx_overrun(struct device *dev);
dev86net/inet/8390.cvoid NS8390_init(struct device *dev, int startp);
dev87net/inet/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
dev97net/inet/8390.cei_open(struct device *dev)
dev99net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev102net/inet/8390.cprintk("%s: Opening a non-existent physical device\n", dev->name);
dev106net/inet/8390.cirq2dev_map[dev->irq] = dev;
dev107net/inet/8390.cNS8390_init(dev, 1);
dev112net/inet/8390.cdev->tbusy = 0;
dev113net/inet/8390.cdev->interrupt = 0;
dev114net/inet/8390.cdev->start = 1;
dev120net/inet/8390.cei_start_xmit(struct sk_buff *skb, struct device *dev)
dev122net/inet/8390.cint e8390_base = dev->base_addr;
dev123net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev128net/inet/8390.cif (dev->tbusy) {  /* Do timeouts, just like the 8003 driver. */
dev130net/inet/8390.cint tickssofar = jiffies - dev->trans_start;
dev136net/inet/8390.cdev->name, txsr, isr);
dev140net/inet/8390.cprintk("%s: Possible IRQ conflict on IRQ%d?", dev->name, dev->irq);
dev142net/inet/8390.cprintk("%s: Possible network cable problem?\n", dev->name);
dev144net/inet/8390.cei_reset_8390(dev);
dev145net/inet/8390.cNS8390_init(dev, 1);
dev153net/inet/8390.cdev_tint(dev);
dev157net/inet/8390.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
dev158net/inet/8390.cskb->dev = dev;
dev169net/inet/8390.cif (dev->interrupt || ei_local->irqlock) {
dev174net/inet/8390.cdev->name, ei_local->irqlock ? " during interrupt" : "");
dev178net/inet/8390.ctmp_tbusy=dev->tbusy;
dev179net/inet/8390.cdev->tbusy = 1;                   /* lock dev_tint() in dev.c */
dev189net/inet/8390.cdev->name, ei_local->tx2, ei_local->lasttx,
dev196net/inet/8390.cdev->name, ei_local->tx1, ei_local->lasttx,
dev203net/inet/8390.cdev->name);
dev206net/inet/8390.cdev->tbusy = tmp_tbusy;
dev211net/inet/8390.cdev->trans_start = jiffies;
dev212net/inet/8390.cei_block_output(dev, length, (unsigned char *)(skb+1), output_page);
dev214net/inet/8390.cNS8390_trigger_send(dev, send_length, output_page);
dev225net/inet/8390.cdev->trans_start = jiffies;
dev226net/inet/8390.cei_block_output(dev, length, (unsigned char *)(skb+1),
dev228net/inet/8390.cNS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
dev239net/inet/8390.cdev->tbusy=tmp_tbusy;
dev250net/inet/8390.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
dev255net/inet/8390.cif (dev == NULL) {
dev259net/inet/8390.ce8390_base = dev->base_addr;
dev260net/inet/8390.cei_local = (struct ei_device *) dev->priv;
dev261net/inet/8390.cif (dev->interrupt || ei_local->irqlock) {
dev267net/inet/8390.cdev->name, inb_p(e8390_base + EN0_ISR),
dev272net/inet/8390.cdev->interrupt = 1;
dev278net/inet/8390.cprintk("%s: interrupt(isr=%#2.2x).\n", dev->name,
dev289net/inet/8390.cei_rx_overrun(dev);
dev292net/inet/8390.cei_receive(dev);
dev296net/inet/8390.cei_tx_intr(dev);
dev298net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev313net/inet/8390.cprintk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
dev317net/inet/8390.cdev->interrupt = 0;
dev324net/inet/8390.cei_tx_intr(struct device *dev)
dev326net/inet/8390.cint e8390_base = dev->base_addr;
dev328net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev339net/inet/8390.cdev->tbusy = 0;
dev341net/inet/8390.cNS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
dev342net/inet/8390.cdev->trans_start = jiffies;
dev353net/inet/8390.cdev->tbusy = 0;
dev355net/inet/8390.cNS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
dev356net/inet/8390.cdev->trans_start = jiffies;
dev364net/inet/8390.cdev->name, ei_local->lasttx);
dev367net/inet/8390.cdev->tbusy = 0;
dev394net/inet/8390.cei_receive(struct device *dev)
dev396net/inet/8390.cint e8390_base = dev->base_addr;
dev397net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev419net/inet/8390.cdev->name, this_frame, ei_local->current_page);
dev425net/inet/8390.cei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame,
dev446net/inet/8390.cdev->name, rx_frame.status, rx_frame.next, rx_frame.count,
dev453net/inet/8390.cdev->name, ei_local->current_page, next_frame,
dev461net/inet/8390.cdev->name, ei_local->stat.rx_packets);
dev463net/inet/8390.cei_reset_8390(dev);
dev464net/inet/8390.cNS8390_init(dev, 1);
dev473net/inet/8390.cdev->name, rx_frame.status, rx_frame.next, rx_frame.count);
dev483net/inet/8390.cei_block_input(dev, size, (char *)(skb+1),
dev485net/inet/8390.cif (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev)) {
dev486net/inet/8390.cprintk("%s: receive buffers full.\n", dev->name);
dev492net/inet/8390.cdev->name, sksize);
dev500net/inet/8390.cdev->name, rx_frame.status, rx_frame.next, rx_frame.count);
dev508net/inet/8390.cprintk("%s: next frame inconsistency, %#2x..", dev->name, next_frame);
dev527net/inet/8390.cei_rx_overrun(struct device *dev)
dev529net/inet/8390.cint e8390_base = dev->base_addr;
dev531net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev537net/inet/8390.cprintk("%s: Receiver overrun.\n", dev->name);
dev549net/inet/8390.cdev->name);
dev550net/inet/8390.cNS8390_init(dev, 1);
dev555net/inet/8390.cei_receive(dev);
dev564net/inet/8390.cget_stats(struct device *dev)
dev566net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev572net/inet/8390.cethdev_init(struct device *dev)
dev580net/inet/8390.cdev->buffs[i] = NULL;
dev583net/inet/8390.cif (dev->open == NULL)
dev584net/inet/8390.cdev->open = &ei_open;
dev586net/inet/8390.cdev->get_stats  = get_stats;
dev587net/inet/8390.cdev->hard_header  = eth_header;
dev588net/inet/8390.cdev->add_arp  = eth_add_arp;
dev589net/inet/8390.cdev->queue_xmit  = dev_queue_xmit;
dev590net/inet/8390.cdev->rebuild_header  = eth_rebuild_header;
dev591net/inet/8390.cdev->type_trans  = eth_type_trans;
dev593net/inet/8390.cif (dev->priv == NULL) {
dev596net/inet/8390.cdev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
dev597net/inet/8390.cmemset(dev->priv, 0, sizeof(struct ei_device));
dev598net/inet/8390.cei_local = (struct ei_device *)dev->priv;
dev604net/inet/8390.cdev->hard_start_xmit = &ei_start_xmit;
dev606net/inet/8390.cdev->type    = ARPHRD_ETHER;
dev607net/inet/8390.cdev->hard_header_len = ETH_HLEN;
dev608net/inet/8390.cdev->mtu    = 1500; /* eth_mtu */
dev609net/inet/8390.cdev->addr_len  = ETH_ALEN;
dev610net/inet/8390.cfor (i = 0; i < dev->addr_len; i++) {
dev611net/inet/8390.cdev->broadcast[i]=0xff;
dev615net/inet/8390.cdev->flags    = IFF_BROADCAST;
dev616net/inet/8390.cdev->family    = AF_INET;
dev617net/inet/8390.cdev->pa_addr  = 0;
dev618net/inet/8390.cdev->pa_brdaddr  = 0;
dev619net/inet/8390.cdev->pa_mask  = 0;
dev620net/inet/8390.cdev->pa_alen  = sizeof(unsigned long);
dev628net/inet/8390.cvoid NS8390_init(struct device *dev, int startp)
dev630net/inet/8390.cint e8390_base = dev->base_addr;
dev631net/inet/8390.cstruct ei_device *ei_local = (struct ei_device *) dev->priv;
dev660net/inet/8390.coutb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
dev680net/inet/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
dev683net/inet/8390.cint e8390_base = dev->base_addr;
dev690net/inet/8390.cdev->name);
dev23net/inet/8390.hextern int ethif_init(struct device *dev);
dev24net/inet/8390.hextern int ethdev_init(struct device *dev);
dev25net/inet/8390.hextern void NS8390_init(struct device *dev, int startp);
dev26net/inet/8390.hextern int ei_open(struct device *dev);
dev64net/inet/8390.h#define ei_status (*(struct ei_device *)(dev->priv))
dev40net/inet/Space.cextern int wd_probe(struct device *dev);
dev41net/inet/Space.cextern int el2_probe(struct device *dev);
dev42net/inet/Space.cextern int ne_probe(struct device *dev);
dev43net/inet/Space.cextern int hp_probe(struct device *dev);
dev53net/inet/Space.cethif_probe(struct device *dev)
dev55net/inet/Space.cshort base_addr = dev->base_addr;
dev62net/inet/Space.c&& wd_probe(dev)
dev65net/inet/Space.c&& el2_probe(dev)
dev68net/inet/Space.c&& ne_probe(dev)
dev71net/inet/Space.c&& hp_probe(dev)
dev74net/inet/Space.c&& at1500_probe(dev)
dev77net/inet/Space.c&& el3_probe(dev)
dev80net/inet/Space.c&& znet_probe(dev)
dev83net/inet/Space.c&& express_probe(dev)
dev86net/inet/Space.c&& atp_probe(dev)
dev89net/inet/Space.c&& depca_probe(dev)
dev92net/inet/Space.c&& el1_probe(dev)
dev216net/inet/Space.cextern int loopback_init(struct device *dev);
dev227net/inet/arp.cif (!skb->dev->rebuild_header(skb+1, skb->dev)) {
dev232net/inet/arp.cskb->dev->queue_xmit(skb, skb->dev, 0);
dev255net/inet/arp.carp_response(struct arphdr *arp1, struct device *dev)
dev267net/inet/arp.cdev->hard_header_len, GFP_ATOMIC);
dev281net/inet/arp.c(2 * arp1->ar_pln) + dev->hard_header_len;
dev283net/inet/arp.chlen = dev->hard_header((unsigned char *)(skb+1), dev,
dev302net/inet/arp.cmemcpy(ptr2, dev->dev_addr, arp2->ar_hln);
dev319net/inet/arp.cdev->queue_xmit(skb, dev, 0);
dev431net/inet/arp.carp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
dev444net/inet/arp.cif (arp->ar_hln != dev->addr_len || dev->type != NET16(arp->ar_hrd)) {
dev445net/inet/arp.cprintk("ARP: Bad packet received on device \"%s\" !\n", dev->name);
dev453net/inet/arp.cprintk("ARP: Non-IP request on device \"%s\" !\n", dev->name);
dev512net/inet/arp.cret = arp_response(arp, dev);
dev520net/inet/arp.carp_send(unsigned long paddr, struct device *dev, unsigned long saddr)
dev528net/inet/arp.cDPRINTF((DBG_ARP, "dev=%s, ", dev->name));
dev532net/inet/arp.csizeof(struct arphdr) + (2 * dev->addr_len) +
dev533net/inet/arp.cdev->hard_header_len +
dev545net/inet/arp.cdev->hard_header_len + (2 * dev->addr_len) + 8;
dev548net/inet/arp.cskb->dev = dev;
dev550net/inet/arp.ctmp = dev->hard_header((unsigned char *)(skb+1), dev,
dev557net/inet/arp.carp->ar_hrd = htons(dev->type);
dev559net/inet/arp.carp->ar_hln = dev->addr_len;
dev564net/inet/arp.cmemcpy(ptr, dev->dev_addr, arp->ar_hln);
dev568net/inet/arp.cmemcpy(ptr, dev->broadcast, arp->ar_hln);
dev574net/inet/arp.cdev->queue_xmit(skb, dev, 0);
dev580net/inet/arp.carp_find(unsigned char *haddr, unsigned long paddr, struct device *dev,
dev587net/inet/arp.cDPRINTF((DBG_ARP, "dev=%s, saddr=%s)\n", dev->name, in_ntoa(saddr)));
dev591net/inet/arp.cmemcpy(haddr, dev->dev_addr, dev->addr_len);
dev594net/inet/arp.cmemcpy(haddr, dev->broadcast, dev->addr_len);
dev608net/inet/arp.cmemcpy(haddr, apt->ha, dev->addr_len);
dev624net/inet/arp.carp_send(paddr, dev, saddr);
dev632net/inet/arp.carp_add(unsigned long addr, unsigned char *haddr, struct device *dev)
dev638net/inet/arp.cDPRINTF((DBG_ARP, "%d, %d)\n", dev->hard_header_len, dev->type));
dev651net/inet/arp.cmemcpy(apt->ha, haddr , dev->addr_len);
dev654net/inet/arp.carp_create(addr, haddr, dev->addr_len, dev->type);
dev660net/inet/arp.carp_add_broad(unsigned long addr, struct device *dev)
dev664net/inet/arp.carp_add(addr, dev->broadcast, dev);
dev52net/inet/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
dev55net/inet/arp.hstruct device *dev, unsigned long saddr);
dev57net/inet/arp.hstruct device *dev);
dev58net/inet/arp.hextern void  arp_add_broad(unsigned long addr, struct device *dev);
dev125net/inet/d_link.c#define DATA_PORT  (dev->base_addr + 0)
dev126net/inet/d_link.c#define STATUS_PORT  (dev->base_addr + 1)
dev127net/inet/d_link.c#define COMMAND_PORT  (dev->base_addr + 2)
dev228net/inet/d_link.cstatic int    d_link_read_status(struct device *dev);
dev229net/inet/d_link.cstatic unsigned  char  d_link_read_byte(int type, struct device *dev);
dev232net/inet/d_link.cstatic int  d_link_open(struct device *dev);
dev233net/inet/d_link.cstatic int  d_link_close(struct device *dev);
dev234net/inet/d_link.cstatic int  d_link_start_xmit(struct sk_buff *skb, struct device *dev);
dev238net/inet/d_link.cstatic void  d_link_tx_intr(struct device *dev);
dev239net/inet/d_link.cstatic void  d_link_rx_intr(struct device *dev);
dev242net/inet/d_link.cint    d_link_init(struct device *dev);
dev243net/inet/d_link.cstatic void  adapter_init(struct device *dev, int startp);
dev298net/inet/d_link.cd_link_read_status(struct device *dev)
dev313net/inet/d_link.cd_link_read_byte(int type, struct device *dev) { /* dev used by macros */
dev347net/inet/d_link.cd_link_open(struct device *dev)
dev349net/inet/d_link.cadapter_init(dev, 1);
dev350net/inet/d_link.cdev->tbusy = 0;    /* Transmit busy...  */
dev351net/inet/d_link.cdev->interrupt = 0;
dev352net/inet/d_link.cdev->start = 1;
dev360net/inet/d_link.cd_link_close(struct device *dev)
dev362net/inet/d_link.cdev->start = 0;
dev364net/inet/d_link.cadapter_init(dev, 0);
dev366net/inet/d_link.cirqaction(dev->irq, NULL);
dev376net/inet/d_link.cd_link_start_xmit(struct sk_buff *skb, struct device *dev)
dev391net/inet/d_link.cdev_tint(dev);
dev396net/inet/d_link.cif (!skb->arp  &&  dev->rebuild_header(skb + 1, dev)) {
dev397net/inet/d_link.cskb->dev = dev;
dev405net/inet/d_link.cif (dev->tbusy) {  /* Do timeouts, to avoid hangs. */
dev407net/inet/d_link.ctickssofar = jiffies - dev->trans_start;
dev415net/inet/d_link.cdev->name,
dev435net/inet/d_link.cdev->tbusy = !free_tx_page; /* any more free pages? */
dev460net/inet/d_link.cdev->trans_start = jiffies;
dev467net/inet/d_link.cdev->trans_start = jiffies;
dev487net/inet/d_link.cstruct device  *dev = realdev;
dev497net/inet/d_link.cif (dev == NULL) {
dev502net/inet/d_link.cif (dev->start == 0) {
dev507net/inet/d_link.cdev->interrupt = 1;
dev510net/inet/d_link.clocalstats = (struct netstats*) dev->priv;
dev512net/inet/d_link.cinterrupts = d_link_read_status(dev);
dev532net/inet/d_link.cd_link_tx_intr(dev);
dev536net/inet/d_link.cd_link_rx_intr(dev);
dev541net/inet/d_link.cprintk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
dev553net/inet/d_link.cdev->interrupt = 0;
dev565net/inet/d_link.cd_link_tx_intr(struct device *dev)
dev570net/inet/d_link.cdev->tbusy = 0;
dev579net/inet/d_link.cdev->trans_start = jiffies;
dev591net/inet/d_link.cd_link_rx_intr(struct device *dev)
dev601net/inet/d_link.csize = d_link_read_byte(RX_LEN, dev); /* low byte */
dev602net/inet/d_link.csize = size + (d_link_read_byte(RX_LEN, dev) << 8) - 4;
dev612net/inet/d_link.cprintk("%s: Bogus packet size %d.\n", dev->name, size);
dev618net/inet/d_link.cdev->name, sksize);
dev641net/inet/d_link.c*buffer++ = d_link_read_byte(READ_DATA, dev);
dev646net/inet/d_link.cif(dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev)) {
dev647net/inet/d_link.cprintk("%s: receive buffers full.\n", dev->name);
dev660net/inet/d_link.cd_link_init(struct device *dev)
dev664net/inet/d_link.cprintk("%s: D-Link pocket adapter", dev->name);
dev671net/inet/d_link.c(void)d_link_read_status(dev);
dev674net/inet/d_link.cif (d_link_read_status(dev) & 0xf0) {
dev675net/inet/d_link.cprintk(": probe failed at %#3x.\n", dev->base_addr);
dev687net/inet/d_link.cdev->dev_addr[i] = d_link_read_byte(READ_DATA, dev);
dev688net/inet/d_link.cdev->broadcast[i] = 0xff;
dev692net/inet/d_link.cif ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) {
dev694net/inet/d_link.cdev->dev_addr[0] = 0x00;
dev695net/inet/d_link.cdev->dev_addr[1] = 0x80;
dev696net/inet/d_link.cdev->dev_addr[2] = 0xc8;
dev697net/inet/d_link.cdev->dev_addr[3] &= 0x0f;
dev698net/inet/d_link.cdev->dev_addr[3] |= 0x70;
dev705net/inet/d_link.cdev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL);
dev706net/inet/d_link.cmemset(dev->priv, 0, sizeof(struct netstats));
dev709net/inet/d_link.cdev->buffs[i] = NULL;
dev711net/inet/d_link.cdev->hard_header = eth_header;
dev712net/inet/d_link.cdev->add_arp = eth_add_arp;
dev713net/inet/d_link.cdev->queue_xmit = dev_queue_xmit;
dev714net/inet/d_link.cdev->rebuild_header = eth_rebuild_header;
dev715net/inet/d_link.cdev->type_trans = eth_type_trans;
dev717net/inet/d_link.cdev->open = &d_link_open;
dev718net/inet/d_link.cdev->stop = &d_link_close;
dev719net/inet/d_link.cdev->hard_start_xmit = &d_link_start_xmit;
dev722net/inet/d_link.cdev->type = ARPHRD_ETHER;
dev723net/inet/d_link.cdev->hard_header_len = ETH_HLEN;
dev724net/inet/d_link.cdev->mtu = 1500; /* eth_mtu */
dev725net/inet/d_link.cdev->addr_len  = ETH_ALEN;
dev728net/inet/d_link.cdev->flags = IFF_BROADCAST;
dev729net/inet/d_link.cdev->family = AF_INET;
dev730net/inet/d_link.cdev->pa_addr = 0;
dev731net/inet/d_link.cdev->pa_brdaddr = 0;
dev732net/inet/d_link.cdev->pa_mask = 0;
dev733net/inet/d_link.cdev->pa_alen = sizeof(unsigned long);
dev735net/inet/d_link.cif (irqaction (dev->irq, &d_link_sigaction)) {
dev736net/inet/d_link.cprintk (": unable to get IRQ %d\n", dev->irq);
dev740net/inet/d_link.cprintk(", Ethernet Address: %2.2X", dev->dev_addr[0]);
dev742net/inet/d_link.cprintk(":%2.2X",dev->dev_addr[i]);
dev749net/inet/d_link.cadapter_init(struct device *dev, int startp)
dev761net/inet/d_link.cirqaction (dev->irq, &d_link_sigaction);
dev762net/inet/d_link.crealdev = dev;
dev770net/inet/d_link.cd_link_put_byte(dev->dev_addr[i]);
dev123net/inet/dev.cstruct device *dev;
dev147net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev148net/inet/dev.cif (dev->pa_addr == 0) continue;
dev151net/inet/dev.cif (addr == dev->pa_addr) {
dev157net/inet/dev.cif ((addr & dev->pa_mask) == (dev->pa_addr & dev->pa_mask)) {
dev158net/inet/dev.cif ((addr & ~dev->pa_mask) == 0) {
dev162net/inet/dev.cif (((addr & ~dev->pa_mask) | dev->pa_mask)
dev186net/inet/dev.cstruct device *dev;
dev188net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev189net/inet/dev.cif (dev->flags & IFF_LOOPBACK) return(dev->pa_addr);
dev246net/inet/dev.cstruct device *dev;
dev248net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev249net/inet/dev.cif (strcmp(dev->name, name) == 0) return(dev);
dev259net/inet/dev.cstruct device *dev;
dev261net/inet/dev.cfor (dev = dev_base; dev; dev = dev->next)
dev262net/inet/dev.cif ((dev->flags & IFF_UP) && (dev->flags & IFF_POINTOPOINT) &&
dev263net/inet/dev.c(addr == dev->pa_dstaddr))
dev264net/inet/dev.creturn dev;
dev265net/inet/dev.cfor (dev = dev_base; dev; dev = dev->next)
dev266net/inet/dev.cif ((dev->flags & IFF_UP) && !(dev->flags & IFF_POINTOPOINT) &&
dev267net/inet/dev.c(dev->flags & IFF_LOOPBACK ? (addr == dev->pa_addr) :
dev268net/inet/dev.c(dev->pa_addr & addr) == (dev->pa_addr & dev->pa_mask)))
dev271net/inet/dev.creturn dev;
dev277net/inet/dev.cdev_open(struct device *dev)
dev281net/inet/dev.cif (dev->open) ret = dev->open(dev);
dev282net/inet/dev.cif (ret == 0) dev->flags |= (IFF_UP | IFF_RUNNING);
dev290net/inet/dev.cdev_close(struct device *dev)
dev292net/inet/dev.cif (dev->flags != 0) {
dev293net/inet/dev.cdev->flags = 0;
dev294net/inet/dev.cif (dev->stop) dev->stop(dev);
dev295net/inet/dev.crt_flush(dev);
dev296net/inet/dev.cdev->pa_addr = 0;
dev297net/inet/dev.cdev->pa_dstaddr = 0;
dev298net/inet/dev.cdev->pa_brdaddr = 0;
dev299net/inet/dev.cdev->pa_mask = 0;
dev308net/inet/dev.cdev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
dev316net/inet/dev.cskb, dev, pri));
dev318net/inet/dev.cif (dev == NULL) {
dev323net/inet/dev.cskb->dev = dev;
dev326net/inet/dev.cdev->hard_start_xmit(NULL, dev);
dev340net/inet/dev.cif (dev->hard_start_xmit(skb, dev) == 0) {
dev346net/inet/dev.cpri, dev->buffs[pri]));
dev350net/inet/dev.cif (dev->buffs[pri] == NULL) {
dev351net/inet/dev.cdev->buffs[pri] = skb;
dev356net/inet/dev.cskb->next = (struct sk_buff *) dev->buffs[pri];
dev357net/inet/dev.cskb->prev = (struct sk_buff *) dev->buffs[pri]->prev;
dev360net/inet/dev.cdev->buffs[pri] = skb;
dev362net/inet/dev.cskb2 = (struct sk_buff *) dev->buffs[pri];
dev416net/inet/dev.cdev_rint(unsigned char *buff, long len, int flags, struct device *dev)
dev424net/inet/dev.cif (dev == NULL || buff == NULL || len <= 0) return(1);
dev438net/inet/dev.cdev->name);
dev451net/inet/dev.camount = min(len2, (unsigned long) dev->rmem_end -
dev458net/inet/dev.cif ((unsigned long) buff == dev->rmem_end)
dev459net/inet/dev.cbuff = (unsigned char *) dev->rmem_start;
dev463net/inet/dev.cskb->dev = dev;
dev475net/inet/dev.cstruct device *dev;
dev477net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev478net/inet/dev.cif (!dev->tbusy) {
dev479net/inet/dev.cdev_tint(dev);
dev524net/inet/dev.cskb->h.raw = (unsigned char *) (skb + 1) + skb->dev->hard_header_len;
dev525net/inet/dev.cskb->len -= skb->dev->hard_header_len;
dev536net/inet/dev.ctype = skb->dev->type_trans(skb, skb->dev);
dev570net/inet/dev.cptype->func(skb2, skb->dev, ptype);
dev599net/inet/dev.cdev_tint(struct device *dev)
dev606net/inet/dev.cwhile (dev->buffs[i] != NULL) {
dev607net/inet/dev.cskb = (struct sk_buff *) dev->buffs[i];
dev611net/inet/dev.cdev->buffs[i] = NULL;
dev618net/inet/dev.cdev->buffs[i] = NULL;
dev628net/inet/dev.cdev->buffs[i] = NULL;
dev630net/inet/dev.cdev->buffs[i]= skb->next;
dev641net/inet/dev.cdev->queue_xmit(skb, dev, -i - 1);
dev642net/inet/dev.cif (dev->tbusy) return;
dev656net/inet/dev.cstruct device *dev;
dev667net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev669net/inet/dev.cstrcpy(ifr.ifr_name, dev->name);
dev670net/inet/dev.c(*(struct sockaddr_in *) &ifr.ifr_addr).sin_family = dev->family;
dev671net/inet/dev.c(*(struct sockaddr_in *) &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
dev688net/inet/dev.cchar *sprintf_stats(char *buffer, struct device *dev)
dev691net/inet/dev.cstruct enet_statistics *stats = (dev->get_stats ? dev->get_stats(dev): NULL);
dev695net/inet/dev.cdev->name,
dev706net/inet/dev.cpos += sprintf(pos, "%6s: No statistics available.\n", dev->name);
dev716net/inet/dev.cstruct device *dev;
dev722net/inet/dev.cfor (dev = dev_base; dev != NULL; dev = dev->next) {
dev723net/inet/dev.cpos = sprintf_stats(pos, dev);
dev733net/inet/dev.cstruct device *dev;
dev741net/inet/dev.cif ((dev = dev_get(ifr.ifr_name)) == NULL) return(-EINVAL);
dev745net/inet/dev.cifr.ifr_flags = dev->flags;
dev751net/inet/dev.cint old_flags = dev->flags;
dev752net/inet/dev.cdev->flags = ifr.ifr_flags & (
dev756net/inet/dev.cif ((old_flags & IFF_UP) && ((dev->flags & IFF_UP) == 0)) {
dev757net/inet/dev.cret = dev_close(dev);
dev759net/inet/dev.cret = (! (old_flags & IFF_UP) && (dev->flags & IFF_UP))
dev760net/inet/dev.c? dev_open(dev) : 0;
dev765net/inet/dev.c&ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr;
dev767net/inet/dev.c&ifr.ifr_addr).sin_family = dev->family;
dev774net/inet/dev.cdev->pa_addr = (*(struct sockaddr_in *)
dev776net/inet/dev.cdev->family = ifr.ifr_addr.sa_family;
dev777net/inet/dev.cdev->pa_mask = get_mask(dev->pa_addr);
dev778net/inet/dev.cdev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask;
dev783net/inet/dev.c&ifr.ifr_broadaddr).sin_addr.s_addr = dev->pa_brdaddr;
dev785net/inet/dev.c&ifr.ifr_broadaddr).sin_family = dev->family;
dev792net/inet/dev.cdev->pa_brdaddr = (*(struct sockaddr_in *)
dev798net/inet/dev.c&ifr.ifr_dstaddr).sin_addr.s_addr = dev->pa_dstaddr;
dev800net/inet/dev.c&ifr.ifr_broadaddr).sin_family = dev->family;
dev807net/inet/dev.cdev->pa_dstaddr = (*(struct sockaddr_in *)
dev813net/inet/dev.c&ifr.ifr_netmask).sin_addr.s_addr = dev->pa_mask;
dev815net/inet/dev.c&ifr.ifr_netmask).sin_family = dev->family;
dev822net/inet/dev.cdev->pa_mask = (*(struct sockaddr_in *)
dev827net/inet/dev.cifr.ifr_metric = dev->metric;
dev832net/inet/dev.cdev->metric = ifr.ifr_metric;
dev836net/inet/dev.cifr.ifr_mtu = dev->mtu;
dev841net/inet/dev.cdev->mtu = ifr.ifr_mtu;
dev864net/inet/dev.cstruct ddi_device *dev;
dev870net/inet/dev.cstruct device *dev;
dev886net/inet/dev.cdev = dev_get( loopback ? "lo" : ipc.name);
dev887net/inet/dev.cif (dev == NULL)
dev890net/inet/dev.cdev->pa_addr = ipc.paddr;
dev891net/inet/dev.cdev->family = AF_INET;
dev892net/inet/dev.cdev->pa_mask = get_mask(dev->pa_addr);
dev893net/inet/dev.cdev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask;
dev895net/inet/dev.cdev->flags |= IFF_BROADCAST;
dev896net/inet/dev.cdev->pa_brdaddr = ipc.net;
dev901net/inet/dev.creturn (dev->flags & IFF_UP != 0) ? dev_close(dev) : 0;
dev903net/inet/dev.cif ((dev->flags & IFF_UP) == 0
dev904net/inet/dev.c&& (retval = dev_open(dev)) != 0)
dev906net/inet/dev.cprintk("%s: adding HOST route of %8.8x.\n", dev->name,
dev908net/inet/dev.crt_add(RTF_HOST, ipc.paddr, 0, dev);
dev910net/inet/dev.crt_add(RTF_GATEWAY, ipc.paddr, ipc.router, dev);
dev912net/inet/dev.cdev->name, htonl(ipc.paddr));
dev943net/inet/dev.cdev = ddi_map(iflink.id);
dev944net/inet/dev.cif (dev == NULL) return(-EINVAL);
dev948net/inet/dev.cdev->name, iflink.stream);
dev963net/inet/dev.cstruct device *dev, *dev2;
dev971net/inet/dev.cfor (dev = dev_base; dev != NULL; dev=dev->next) {
dev972net/inet/dev.cif (dev->init && dev->init(dev)) {
dev973net/inet/dev.cif (dev2 == NULL) dev_base = dev->next;
dev974net/inet/dev.celse dev2->next = dev->next;
dev976net/inet/dev.cdev2 = dev;
dev76net/inet/dev.hint        (*init)(struct device *dev);
dev83net/inet/dev.hstruct enet_statistics* (*get_stats)(struct device *dev);
dev117net/inet/dev.hint        (*open)(struct device *dev);
dev118net/inet/dev.hint        (*stop)(struct device *dev);
dev120net/inet/dev.hstruct device *dev);
dev122net/inet/dev.hstruct device *dev,
dev129net/inet/dev.hstruct device *dev);
dev131net/inet/dev.hstruct device *dev, int pri);
dev132net/inet/dev.hint        (*rebuild_header)(void *eth, struct device *dev);
dev134net/inet/dev.hstruct device *dev);
dev168net/inet/dev.hextern int    dev_open(struct device *dev);
dev169net/inet/dev.hextern int    dev_close(struct device *dev);
dev170net/inet/dev.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
dev176net/inet/dev.hstruct device * dev);
dev179net/inet/dev.hextern void    dev_tint(struct device *dev);
dev30net/inet/el.cextern void NS8390_init(struct device *dev, int startp);
dev34net/inet/el.cint el2autoprobe(int ioaddr, struct device *dev);
dev35net/inet/el.cint el2probe(int ioaddr, struct device *dev);
dev37net/inet/el.cstatic void el2_reset_8390(struct device *dev);
dev38net/inet/el.cstatic void el2_init_card(struct device *dev);
dev39net/inet/el.cstatic void el2_block_output(struct device *dev, int count,
dev41net/inet/el.cstatic int el2_block_input(struct device *dev, int count, char *buf,
dev46net/inet/el.cel2autoprobe(int ioaddr, struct device *dev)
dev53net/inet/el.creturn el2probe(ioaddr, dev);
dev65net/inet/el.cif (base_bits == 1 &&  el2probe(ports[i], dev))
dev66net/inet/el.creturn dev->base_addr;
dev75net/inet/el.c&& el2probe(ports[i], dev))
dev76net/inet/el.creturn dev->base_addr;
dev87net/inet/el.cel2probe(int ioaddr, struct device *dev)
dev90net/inet/el.cunsigned char *station_addr = dev->dev_addr;
dev121net/inet/el.cdev->base_addr = ioaddr;
dev126net/inet/el.cdev->mem_start = 0;
dev128net/inet/el.cdev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
dev135net/inet/el.cint *mem_base = (int *)dev->mem_start;
dev143net/inet/el.cdev->mem_start = 0;
dev154net/inet/el.cdev->mem_end = dev->rmem_end = dev->mem_start + EL2_MEMSIZE;
dev155net/inet/el.cdev->rmem_start = TX_PAGES*256 + dev->mem_start;
dev159net/inet/el.cdev->mem_start, dev->rmem_start, dev->mem_end, dev->rmem_end);
dev176net/inet/el.cif (dev->irq < 2) {
dev180net/inet/el.cif (request_irq (dev->irq = *irqp, NULL) != -EBUSY) {
dev183net/inet/el.coutb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
dev185net/inet/el.cif (dev->irq == autoirq_report(0)   /* It's a good IRQ line! */
dev186net/inet/el.c&& request_irq (dev->irq, &ei_interrupt) == 0) {
dev187net/inet/el.cprintk(" got IRQ %d", dev->irq);
dev190net/inet/el.cprintk(" IRQ%d busy..", dev->irq);
dev198net/inet/el.cif (dev->irq == 2)
dev199net/inet/el.cdev->irq = 9;
dev200net/inet/el.celse if (dev->irq > 5 && dev->irq != 9) {
dev202net/inet/el.cdev->irq);
dev205net/inet/el.cif (request_irq(dev->irq, &ei_interrupt)) {
dev206net/inet/el.cprintk (" unable to get IRQ%d.\n", dev->irq);
dev211net/inet/el.cdev->start = 0;
dev212net/inet/el.cel2_init_card(dev);
dev214net/inet/el.cif (dev->mem_start)
dev216net/inet/el.cdev->name, ei_status.name, dev->irq,
dev217net/inet/el.cdev->mem_start, dev->mem_end-1);
dev220net/inet/el.cdev->name, ei_status.name, dev->irq);
dev232net/inet/el.cel2_reset_8390(struct device *dev)
dev235net/inet/el.cprintk("%s: Resetting the 3c503 board...", dev->name);
dev242net/inet/el.cel2_init_card(dev);
dev248net/inet/el.cel2_init_card(struct device *dev)
dev263net/inet/el.coutb_p(0x00,  dev->base_addr + EN0_IMR);
dev268net/inet/el.coutb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
dev278net/inet/el.cel2_block_output(struct device *dev, int count,
dev287net/inet/el.cif (dev->mem_start) {  /* Shared memory transfer */
dev288net/inet/el.cvoid *dest_addr = (void *)(dev->mem_start +
dev293net/inet/el.cdev->name, dest_addr);
dev296net/inet/el.cdev->name, dest_addr);
dev314net/inet/el.cdev->name, i, count, boguscount);
dev325net/inet/el.cel2_block_input(struct device *dev, int count, char *buf, int ring_offset)
dev328net/inet/el.cint end_of_ring = dev->rmem_end;
dev332net/inet/el.cif (dev->mem_start) {  /* Use the shared memory. */
dev334net/inet/el.cif (dev->mem_start + ring_offset + count > end_of_ring) {
dev336net/inet/el.cint semi_count = end_of_ring - (dev->mem_start + ring_offset);
dev339net/inet/el.cdev->name, dev->mem_start, ring_offset,
dev340net/inet/el.c(char *)dev->mem_start + ring_offset);
dev341net/inet/el.cmemcpy(buf, (char *)dev->mem_start + ring_offset, semi_count);
dev343net/inet/el.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
dev344net/inet/el.creturn dev->rmem_start + count;
dev348net/inet/el.cdev->name, dev->mem_start, ring_offset,
dev349net/inet/el.c(char *)dev->mem_start + ring_offset);
dev350net/inet/el.cmemcpy(buf, (char *)dev->mem_start + ring_offset, count);
dev366net/inet/el.cdev->name, i, count, boguscount);
dev33net/inet/el2.cint el2_probe(struct device *dev);
dev34net/inet/el2.cint el2_pio_autoprobe(struct device *dev);
dev35net/inet/el2.cint el2probe1(int ioaddr, struct device *dev);
dev37net/inet/el2.cstatic int el2_open(struct device *dev);
dev38net/inet/el2.cstatic int el2_close(struct device *dev);
dev39net/inet/el2.cstatic void el2_reset_8390(struct device *dev);
dev40net/inet/el2.cstatic void el2_init_card(struct device *dev);
dev41net/inet/el2.cstatic void el2_block_output(struct device *dev, int count,
dev43net/inet/el2.cstatic int el2_block_input(struct device *dev, int count, char *buf,
dev58net/inet/el2.cel2_probe(struct device *dev)
dev61net/inet/el2.cshort ioaddr = dev->base_addr;
dev66net/inet/el2.creturn ! el2probe1(ioaddr, dev);
dev81net/inet/el2.cif (el2probe1(ports[i], dev))
dev85net/inet/el2.creturn el2_pio_autoprobe(dev);
dev94net/inet/el2.cel2_pio_autoprobe(struct device *dev)
dev106net/inet/el2.c&& el2probe1(ports[i], dev))
dev116net/inet/el2.cel2probe1(int ioaddr, struct device *dev)
dev119net/inet/el2.cunsigned char *station_addr = dev->dev_addr;
dev152net/inet/el2.cethdev_init(dev);
dev156net/inet/el2.cdev->base_addr = ioaddr;
dev168net/inet/el2.cei_status.interface_num = dev->mem_end & 0xf;
dev172net/inet/el2.cdev->mem_start = 0;
dev174net/inet/el2.cdev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
dev181net/inet/el2.cint *mem_base = (int *)dev->mem_start;
dev189net/inet/el2.cdev->mem_start = 0;
dev200net/inet/el2.cdev->mem_end = dev->rmem_end = dev->mem_start + EL2_MEMSIZE;
dev201net/inet/el2.cdev->rmem_start = TX_PAGES*256 + dev->mem_start;
dev205net/inet/el2.cdev->mem_start, dev->rmem_start, dev->mem_end, dev->rmem_end);
dev216net/inet/el2.cif (dev->irq == 2)
dev217net/inet/el2.cdev->irq = 9;
dev218net/inet/el2.celse if (dev->irq > 5 && dev->irq != 9) {
dev220net/inet/el2.cdev->irq);
dev221net/inet/el2.cdev->irq = 0;
dev224net/inet/el2.cei_status.saved_irq = dev->irq;
dev226net/inet/el2.cdev->start = 0;
dev227net/inet/el2.cdev->open = &el2_open;
dev228net/inet/el2.cdev->stop = &el2_close;
dev229net/inet/el2.cel2_init_card(dev);
dev231net/inet/el2.cif (dev->mem_start)
dev233net/inet/el2.cdev->name, ei_status.name, dev->mem_start, dev->mem_end-1);
dev236net/inet/el2.cdev->name, ei_status.name);
dev244net/inet/el2.cel2_open(struct device *dev)
dev247net/inet/el2.cif (dev->irq < 2) {
dev259net/inet/el2.c&& request_irq (dev->irq = *irqp, &ei_interrupt) == 0)
dev268net/inet/el2.cif (request_irq(dev->irq, &ei_interrupt)) {
dev272net/inet/el2.creturn ei_open(dev);
dev276net/inet/el2.cel2_close(struct device *dev)
dev278net/inet/el2.cfree_irq(dev->irq);
dev279net/inet/el2.cdev->irq = ei_status.saved_irq;
dev280net/inet/el2.cirq2dev_map[dev->irq] = NULL;
dev283net/inet/el2.cNS8390_init(dev, 0);
dev293net/inet/el2.cel2_reset_8390(struct device *dev)
dev296net/inet/el2.cprintk("%s: Resetting the 3c503 board...", dev->name);
dev303net/inet/el2.cel2_init_card(dev);
dev309net/inet/el2.cel2_init_card(struct device *dev)
dev324net/inet/el2.coutb_p(0x00,  dev->base_addr + EN0_IMR);
dev329net/inet/el2.coutb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
dev339net/inet/el2.cel2_block_output(struct device *dev, int count,
dev348net/inet/el2.cif (dev->mem_start) {  /* Shared memory transfer */
dev349net/inet/el2.cvoid *dest_addr = (void *)(dev->mem_start +
dev354net/inet/el2.cdev->name, (int) dest_addr);
dev357net/inet/el2.cdev->name, (int) dest_addr);
dev375net/inet/el2.cdev->name, i, count, boguscount);
dev386net/inet/el2.cel2_block_input(struct device *dev, int count, char *buf, int ring_offset)
dev389net/inet/el2.cint end_of_ring = dev->rmem_end;
dev393net/inet/el2.cif (dev->mem_start) {  /* Use the shared memory. */
dev395net/inet/el2.cif (dev->mem_start + ring_offset + count > end_of_ring) {
dev397net/inet/el2.cint semi_count = end_of_ring - (dev->mem_start + ring_offset);
dev400net/inet/el2.cdev->name, dev->mem_start, ring_offset,
dev401net/inet/el2.cdev->mem_start + ring_offset);
dev402net/inet/el2.cmemcpy(buf, (char *)dev->mem_start + ring_offset, semi_count);
dev404net/inet/el2.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
dev405net/inet/el2.creturn dev->rmem_start + count;
dev409net/inet/el2.cdev->name, dev->mem_start, ring_offset,
dev410net/inet/el2.cdev->mem_start + ring_offset);
dev411net/inet/el2.cmemcpy(buf, (char *)dev->mem_start + ring_offset, count);
dev427net/inet/el2.cdev->name, i, count, boguscount);
dev5net/inet/el2reg.h#define EL2H (dev->base_addr + 0x400)
dev6net/inet/el2reg.h#define EL2L (dev->base_addr)
dev5net/inet/elreg.h#define EL2H (dev->base_addr + 0x400)
dev6net/inet/elreg.h#define EL2L (dev->base_addr)
dev90net/inet/eth.ceth_header(unsigned char *buff, struct device *dev, unsigned short type,
dev101net/inet/eth.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
dev104net/inet/eth.cif (dev->flags & IFF_LOOPBACK) {
dev106net/inet/eth.cmemset(eth->h_dest, 0, dev->addr_len);
dev107net/inet/eth.creturn(dev->hard_header_len);
dev113net/inet/eth.cmemcpy(eth->h_dest, dev->broadcast, dev->addr_len);
dev114net/inet/eth.creturn(dev->hard_header_len);
dev118net/inet/eth.cif (arp_find(eth->h_dest, daddr, dev, saddr)) {
dev119net/inet/eth.creturn(-dev->hard_header_len);
dev120net/inet/eth.c} else return(dev->hard_header_len);
dev126net/inet/eth.ceth_rebuild_header(void *buff, struct device *dev)
dev139net/inet/eth.cif (src != dev->pa_addr) {
dev144net/inet/eth.csrc = dev->pa_addr;
dev146net/inet/eth.cif (arp_find(eth->h_dest, dst, dev, src)) return(1);
dev147net/inet/eth.cmemcpy(eth->h_source, dev->dev_addr, dev->addr_len);
dev154net/inet/eth.ceth_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
dev159net/inet/eth.carp_add(addr, eth->h_source, dev);
dev165net/inet/eth.ceth_type_trans(struct sk_buff *skb, struct device *dev)
dev27net/inet/eth.hextern int    eth_header(unsigned char *buff, struct device *dev,
dev30net/inet/eth.hextern int    eth_rebuild_header(void *buff, struct device *dev);
dev32net/inet/eth.hstruct device *dev);
dev33net/inet/eth.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
dev43net/inet/hp.cint hp_probe(struct device *dev);
dev44net/inet/hp.cint hpprobe1(int ioaddr, struct device *dev);
dev46net/inet/hp.cstatic void hp_reset_8390(struct device *dev);
dev47net/inet/hp.cstatic int hp_block_input(struct device *dev, int count,
dev49net/inet/hp.cstatic void hp_block_output(struct device *dev, int count,
dev51net/inet/hp.cstatic void hp_init_card(struct device *dev);
dev62net/inet/hp.cint hp_probe(struct device *dev)
dev65net/inet/hp.cshort ioaddr = dev->base_addr;
dev70net/inet/hp.creturn ! hpprobe1(ioaddr, dev);
dev77net/inet/hp.cif (inb_p(*port) != 0xff && hpprobe1(*port, dev)) {
dev81net/inet/hp.cdev->base_addr = ioaddr;
dev85net/inet/hp.cint hpprobe1(int ioaddr, struct device *dev)
dev88net/inet/hp.cunsigned char *station_addr = dev->dev_addr;
dev98net/inet/hp.cethdev_init(dev);
dev113net/inet/hp.cprintk("%s: %s at %#3x,", dev->name, ei_status.name, ioaddr);
dev120net/inet/hp.cdev->base_addr = ioaddr + NIC_OFFSET;
dev123net/inet/hp.cif (dev->irq < 2) {
dev128net/inet/hp.cif (request_irq (dev->irq = *irqp, NULL) != -EBUSY) {
dev131net/inet/hp.coutb_p(irqmap[dev->irq] | HP_RUN, ioaddr + HP_CONFIGURE);
dev133net/inet/hp.cif (dev->irq == autoirq_report(0)   /* It's a good IRQ line! */
dev134net/inet/hp.c&& request_irq (dev->irq, &ei_interrupt) == 0) {
dev135net/inet/hp.cprintk(" selecting IRQ %d.\n", dev->irq);
dev145net/inet/hp.cif (dev->irq == 2)
dev146net/inet/hp.cdev->irq = 9;
dev147net/inet/hp.cif (irqaction(dev->irq, &ei_sigaction)) {
dev148net/inet/hp.cprintk (" unable to get IRQ %d.\n", dev->irq);
dev163net/inet/hp.chp_init_card(dev);
dev164net/inet/hp.creturn dev->base_addr;
dev168net/inet/hp.chp_reset_8390(struct device *dev)
dev170net/inet/hp.cint hp_base = dev->base_addr - NIC_OFFSET;
dev193net/inet/hp.cprintk("%s: hp_reset_8390() did not complete.\n", dev->name);
dev205net/inet/hp.chp_block_input(struct device *dev, int count, char *buf, int ring_offset)
dev207net/inet/hp.cint nic_base = dev->base_addr;
dev233net/inet/hp.cdev->name, ring_offset + xfer_count, addr);
dev240net/inet/hp.chp_block_output(struct device *dev, int count,
dev243net/inet/hp.cint nic_base = dev->base_addr;
dev290net/inet/hp.cdev->name, (start_page << 8) + count, addr);
dev298net/inet/hp.chp_init_card(struct device *dev)
dev300net/inet/hp.cint irq = dev->irq;
dev301net/inet/hp.cNS8390_init(dev, 0);
dev303net/inet/hp.cdev->base_addr - NIC_OFFSET + HP_CONFIGURE);
dev75net/inet/icmp.cicmp_send(struct sk_buff *skb_in, int type, int code, struct device *dev)
dev84net/inet/icmp.cskb_in, type, code, dev));
dev87net/inet/icmp.clen = sizeof(struct sk_buff) + dev->hard_header_len +
dev102net/inet/icmp.ciph = (struct iphdr *) ((unsigned char *) iph + dev->hard_header_len);
dev106net/inet/icmp.c&dev, IPPROTO_ICMP, NULL, len);
dev129net/inet/icmp.cip_queue_xmit(NULL, dev, skb, 1);
dev199net/inet/icmp.cicmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev)
dev209net/inet/icmp.cip, icmph->un.gateway, dev);
dev213net/inet/icmp.cip, icmph->un.gateway, dev);
dev231net/inet/icmp.cicmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
dev239net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
dev252net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &dev,
dev277net/inet/icmp.cip_queue_xmit((struct sock *)NULL, dev, skb2, 1);
dev286net/inet/icmp.cicmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
dev298net/inet/icmp.cicmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
dev306net/inet/icmp.csize = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len;
dev319net/inet/icmp.coffset = ip_build_header(skb2, daddr, saddr, &dev,
dev339net/inet/icmp.cmemcpy((char *) (icmphr + 1), (char *) &dev->pa_mask, sizeof(dev->pa_mask));
dev346net/inet/icmp.cip_queue_xmit((struct sock *)NULL, dev, skb2, 1);
dev355net/inet/icmp.cicmp_rcv(struct sk_buff *skb1, struct device *dev, struct options *opt,
dev394net/inet/icmp.cicmp_redirect(icmph, skb1, dev);
dev397net/inet/icmp.cicmp_echo(icmph, skb1, dev, saddr, daddr, len, opt);
dev404net/inet/icmp.cicmp_info(icmph, skb1, dev, saddr, daddr, len, opt);
dev411net/inet/icmp.cicmp_address(icmph, skb1, dev, saddr, daddr, len, opt);
dev27net/inet/icmp.hstruct device *dev);
dev28net/inet/icmp.hextern int  icmp_rcv(struct sk_buff *skb1, struct device *dev,
dev146net/inet/ip.cip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev,
dev155net/inet/ip.cif (dev->hard_header) {
dev156net/inet/ip.cmac = dev->hard_header(ptr, dev, ETH_P_IP, daddr, saddr, len);
dev162net/inet/ip.cskb->dev = dev;
dev175net/inet/ip.cstruct device **dev, int type, struct options *opt, int len)
dev188net/inet/ip.cskb, saddr, daddr, *dev, type, opt, len));
dev192net/inet/ip.cif (*dev == NULL) {
dev196net/inet/ip.c*dev = rt->rt_dev;
dev210net/inet/ip.ctmp = ip_send(skb, raddr, len, *dev, saddr);
dev214net/inet/ip.cskb->dev = *dev;
dev474net/inet/ip.cip_forward(struct sk_buff *skb, struct device *dev)
dev496net/inet/ip.cicmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, dev);
dev512net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, dev);
dev530net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, dev);
dev575net/inet/ip.cip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
dev610net/inet/ip.cip_forward(skb, dev);
dev627net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
dev672net/inet/ip.cipprot->handler(skb2, dev, opts_p ? &opt : 0, iph->daddr,
dev686net/inet/ip.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
dev703net/inet/ip.cip_queue_xmit(struct sock *sk, struct device *dev, 
dev710net/inet/ip.cif (dev == NULL) {
dev715net/inet/ip.cskb->dev = dev;
dev720net/inet/ip.cptr += dev->hard_header_len;
dev722net/inet/ip.ciph->tot_len = ntohs(skb->len - dev->hard_header_len);
dev754net/inet/ip.cif (dev->flags & IFF_UP) {
dev756net/inet/ip.cdev->queue_xmit(skb, dev, sk->priority);
dev758net/inet/ip.cdev->queue_xmit(skb, dev, SOPRI_NORMAL);
dev771net/inet/ip.cstruct device *dev;
dev776net/inet/ip.cdev = skb->dev;
dev778net/inet/ip.cif(dev==NULL)
dev790net/inet/ip.cif (dev->rebuild_header((struct enet_header *)(skb+1),dev)) {
dev800net/inet/ip.cif (dev->flags & IFF_UP) {
dev801net/inet/ip.cif (sk) dev->queue_xmit(skb, dev, sk->priority);
dev802net/inet/ip.celse dev->queue_xmit(skb, dev, SOPRI_NORMAL );
dev35net/inet/ip.hstruct device **dev, int type,
dev38net/inet/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
dev41net/inet/ip.hstruct device *dev, struct sk_buff *skb,
dev110net/inet/lance.cint at1500_probe1(struct device *dev);
dev111net/inet/lance.cstatic int lance_open(struct device *dev);
dev112net/inet/lance.cstatic void lance_init_ring(struct device *dev);
dev113net/inet/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
dev114net/inet/lance.cstatic int lance_rx(struct device *dev);
dev116net/inet/lance.cstatic int lance_close(struct device *dev);
dev117net/inet/lance.cstatic struct enet_statistics *lance_get_stats(struct device *dev);
dev125net/inet/lance.cint at1500_probe(struct device *dev)
dev128net/inet/lance.cint base_addr = dev->base_addr;
dev133net/inet/lance.creturn at1500_probe1(dev);
dev157net/inet/lance.cdev->base_addr = probe_addr;
dev158net/inet/lance.cif (at1500_probe1(dev) == 0)
dev162net/inet/lance.cdev->base_addr = base_addr;
dev167net/inet/lance.cat1500_probe1(struct device *dev)
dev170net/inet/lance.cshort ioaddr = dev->base_addr;
dev174net/inet/lance.cprintk("%s: LANCE at %#3x, address", dev->name, ioaddr);
dev179net/inet/lance.cprintk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
dev185net/inet/lance.cdev->priv = kmalloc(sizeof(struct lance_private), GFP_KERNEL);
dev187net/inet/lance.cdev->priv = (void *)(((int)dev->priv + 7) & ~0x07);
dev189net/inet/lance.cif ((int)dev->priv & 0xff000000  ||  (int) rx_buffs & 0xff000000) {
dev194net/inet/lance.cmemset(dev->priv, 0, sizeof(struct lance_private));
dev195net/inet/lance.clp = (struct lance_private *)dev->priv;
dev199net/inet/lance.cdev->name);
dev206net/inet/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
dev220net/inet/lance.cif (dev->irq < 2) {
dev226net/inet/lance.cdev->irq = autoirq_report(1);
dev227net/inet/lance.cif (dev->irq)
dev228net/inet/lance.cprintk(", using IRQ %d.\n", dev->irq);
dev234net/inet/lance.cprintk(" assigned IRQ %d.\n", dev->irq);
dev237net/inet/lance.cdev->dma = dev->mem_start & 0x07;
dev254net/inet/lance.cdev->open = &lance_open;
dev255net/inet/lance.cdev->hard_start_xmit = &lance_start_xmit;
dev256net/inet/lance.cdev->stop = &lance_close;
dev257net/inet/lance.cdev->get_stats = &lance_get_stats;
dev259net/inet/lance.cdev->mem_start = 0;
dev263net/inet/lance.cdev->buffs[i] = NULL;
dev265net/inet/lance.cdev->hard_header  = eth_header;
dev266net/inet/lance.cdev->add_arp  = eth_add_arp;
dev267net/inet/lance.cdev->queue_xmit  = dev_queue_xmit;
dev268net/inet/lance.cdev->rebuild_header  = eth_rebuild_header;
dev269net/inet/lance.cdev->type_trans  = eth_type_trans;
dev271net/inet/lance.cdev->type    = ARPHRD_ETHER;
dev272net/inet/lance.cdev->hard_header_len = ETH_HLEN;
dev273net/inet/lance.cdev->mtu    = 1500; /* eth_mtu */
dev274net/inet/lance.cdev->addr_len  = ETH_ALEN;
dev275net/inet/lance.cfor (i = 0; i < dev->addr_len; i++) {
dev276net/inet/lance.cdev->broadcast[i]=0xff;
dev280net/inet/lance.cdev->flags    = IFF_BROADCAST;
dev281net/inet/lance.cdev->family    = AF_INET;
dev282net/inet/lance.cdev->pa_addr  = 0;
dev283net/inet/lance.cdev->pa_brdaddr  = 0;
dev284net/inet/lance.cdev->pa_mask  = 0;
dev285net/inet/lance.cdev->pa_alen  = sizeof(unsigned long);
dev292net/inet/lance.clance_open(struct device *dev)
dev294net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev295net/inet/lance.cint ioaddr = dev->base_addr;
dev298net/inet/lance.cif (request_irq(dev->irq, &lance_interrupt)) {
dev302net/inet/lance.clp->dma = dev->dma ? dev->dma : DEFAULT_DMA;
dev305net/inet/lance.cfree_irq(dev->irq);
dev308net/inet/lance.cirq2dev_map[dev->irq] = dev;
dev329net/inet/lance.cdev->name, dev->irq, lp->dma, (int) lp->tx_ring, (int) lp->rx_ring,
dev332net/inet/lance.clance_init_ring(dev);
dev345net/inet/lance.cdev->tbusy = 0;
dev346net/inet/lance.cdev->interrupt = 0;
dev347net/inet/lance.cdev->start = 1;
dev356net/inet/lance.cdev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
dev363net/inet/lance.clance_init_ring(struct device *dev)
dev365net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev379net/inet/lance.clp->init_block.phys_addr[i] = dev->dev_addr[i];
dev387net/inet/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
dev389net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev390net/inet/lance.cint ioaddr = dev->base_addr;
dev393net/inet/lance.cif (dev->tbusy) {
dev394net/inet/lance.cint tickssofar = jiffies - dev->trans_start;
dev399net/inet/lance.cdev->name, inw(ioaddr+LANCE_DATA));
dev401net/inet/lance.clance_init_ring(dev);
dev404net/inet/lance.cdev->tbusy=0;
dev405net/inet/lance.cdev->trans_start = jiffies;
dev411net/inet/lance.cdev_tint(dev);
dev416net/inet/lance.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
dev417net/inet/lance.cskb->dev = dev;
dev427net/inet/lance.cprintk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
dev433net/inet/lance.cdev->tbusy=1;
dev465net/inet/lance.cdev->name, entry, (int) &lp->tx_ring[entry],
dev468net/inet/lance.cdev->name, pkt[0], pkt[1], pkt[2], pkt[5], pkt[6],
dev473net/inet/lance.cdev->trans_start = jiffies;
dev476net/inet/lance.cdev->tbusy=0;
dev487net/inet/lance.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
dev491net/inet/lance.cif (dev == NULL) {
dev496net/inet/lance.cioaddr = dev->base_addr;
dev497net/inet/lance.clp = (struct lance_private *)dev->priv;
dev498net/inet/lance.cif (dev->interrupt)
dev499net/inet/lance.cprintk("%s: Re-entering the interrupt handler.\n", dev->name);
dev501net/inet/lance.cdev->interrupt = 1;
dev503net/inet/lance.coutw(0x00, dev->base_addr + LANCE_ADDR);
dev504net/inet/lance.ccsr0 = inw(dev->base_addr + LANCE_DATA);
dev507net/inet/lance.coutw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
dev511net/inet/lance.cdev->name, csr0, inw(dev->base_addr + LANCE_DATA));
dev514net/inet/lance.clance_rx(dev);
dev521net/inet/lance.cdev->name, dirty_tx, (lp->cur_tx & RING_MOD_MASK));
dev545net/inet/lance.cdev->name, dirty_tx,
dev555net/inet/lance.coutw(0x0000, dev->base_addr + LANCE_ADDR);
dev556net/inet/lance.coutw(0x7f40, dev->base_addr + LANCE_DATA);
dev560net/inet/lance.cdev->name, inw(ioaddr + LANCE_ADDR),
dev561net/inet/lance.cinw(dev->base_addr + LANCE_DATA));
dev563net/inet/lance.cdev->interrupt = 0;
dev568net/inet/lance.clance_rx(struct device *dev)
dev570net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev590net/inet/lance.cprintk("%s: Memory squeeze, deferring packet.\n", dev->name);
dev597net/inet/lance.cskb->dev = dev;
dev605net/inet/lance.cif (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
dev627net/inet/lance.clance_close(struct device *dev)
dev629net/inet/lance.cint ioaddr = dev->base_addr;
dev630net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev632net/inet/lance.cdev->start = 0;
dev633net/inet/lance.cdev->tbusy = 1;
dev642net/inet/lance.cdev->name, inw(ioaddr+LANCE_DATA));
dev650net/inet/lance.cfree_irq(dev->irq);
dev653net/inet/lance.cirq2dev_map[dev->irq] = 0;
dev659net/inet/lance.clance_get_stats(struct device *dev)
dev661net/inet/lance.cstruct lance_private *lp = (struct lance_private *)dev->priv;
dev662net/inet/lance.cshort ioaddr = dev->base_addr;
dev47net/inet/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
dev49net/inet/loopback.cstruct enet_statistics *stats = (struct enet_statistics *)dev->priv;
dev52net/inet/loopback.cDPRINTF((DBG_LOOPB, "loopback_xmit(dev=%X, skb=%X)\n", dev, skb));
dev53net/inet/loopback.cif (skb == NULL || dev == NULL) return(0);
dev56net/inet/loopback.cif (dev->tbusy != 0) {
dev61net/inet/loopback.cdev->tbusy = 1;
dev64net/inet/loopback.cdone = dev_rint((unsigned char *)(skb+1), skb->len, 0, dev);
dev68net/inet/loopback.cdone = dev_rint(NULL, 0, 0, dev);
dev72net/inet/loopback.cdev->tbusy = 0;
dev93net/inet/loopback.cget_stats(struct device *dev)
dev95net/inet/loopback.creturn (struct enet_statistics *)dev->priv;
dev100net/inet/loopback.cloopback_init(struct device *dev)
dev102net/inet/loopback.cdev->mtu    = 2000;      /* MTU      */
dev103net/inet/loopback.cdev->tbusy    = 0;
dev104net/inet/loopback.cdev->hard_start_xmit  = loopback_xmit;
dev105net/inet/loopback.cdev->open    = NULL;
dev107net/inet/loopback.cdev->hard_header  = eth_header;
dev108net/inet/loopback.cdev->add_arp    = NULL;
dev109net/inet/loopback.cdev->hard_header_len  = ETH_HLEN;    /* 14      */
dev110net/inet/loopback.cdev->addr_len    = ETH_ALEN;    /* 6      */
dev111net/inet/loopback.cdev->type    = ARPHRD_ETHER;    /* 0x0001    */
dev112net/inet/loopback.cdev->type_trans  = eth_type_trans;
dev113net/inet/loopback.cdev->rebuild_header  = eth_rebuild_header;
dev115net/inet/loopback.cdev->hard_header_length = 0;
dev116net/inet/loopback.cdev->add_arp    = NULL;
dev117net/inet/loopback.cdev->addr_len    = 0;
dev118net/inet/loopback.cdev->type    = 0;      /* loopback_type (0)  */
dev119net/inet/loopback.cdev->hard_header  = NULL;
dev120net/inet/loopback.cdev->type_trans  = NULL;
dev121net/inet/loopback.cdev->rebuild_header  = NULL;
dev123net/inet/loopback.cdev->queue_xmit  = dev_queue_xmit;
dev126net/inet/loopback.cdev->flags    = IFF_LOOPBACK;
dev127net/inet/loopback.cdev->family    = AF_INET;
dev128net/inet/loopback.cdev->pa_addr    = in_aton("127.0.0.1");
dev129net/inet/loopback.cdev->pa_brdaddr  = in_aton("127.255.255.255");
dev130net/inet/loopback.cdev->pa_mask    = in_aton("255.0.0.0");
dev131net/inet/loopback.cdev->pa_alen    = sizeof(unsigned long);
dev132net/inet/loopback.cdev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL);
dev133net/inet/loopback.cmemset(dev->priv, 0, sizeof(struct enet_statistics));
dev134net/inet/loopback.cdev->get_stats = get_stats;
dev35net/inet/ne.c#define NE_BASE   (dev->base_addr)
dev45net/inet/ne.cint ne_probe(struct device *dev);
dev46net/inet/ne.cstatic int neprobe1(int ioaddr, struct device *dev, int verbose);
dev48net/inet/ne.cstatic void ne_reset_8390(struct device *dev);
dev49net/inet/ne.cstatic int ne_block_input(struct device *dev, int count,
dev51net/inet/ne.cstatic void ne_block_output(struct device *dev, const int count,
dev76net/inet/ne.cint ne_probe(struct device *dev)
dev79net/inet/ne.cshort ioaddr = dev->base_addr;
dev84net/inet/ne.creturn ! neprobe1(ioaddr, dev, 1);
dev91net/inet/ne.cif (inb_p(*port) != 0xff && neprobe1(*port, dev, 0)) {
dev92net/inet/ne.cdev->base_addr = *port;
dev96net/inet/ne.cdev->base_addr = ioaddr;
dev100net/inet/ne.cstatic int neprobe1(int ioaddr, struct device *dev, int verbose)
dev177net/inet/ne.cdev->dev_addr[i] = SA_prom[i];
dev206net/inet/ne.cif (dev->irq < 2) {
dev213net/inet/ne.cdev->irq = autoirq_report(0);
dev215net/inet/ne.cprintk(" autoirq is %d", dev->irq);
dev216net/inet/ne.c} else if (dev->irq == 2)
dev219net/inet/ne.cdev->irq = 9;
dev224net/inet/ne.cint irqval = irqaction (dev->irq, &ei_sigaction);
dev226net/inet/ne.cprintk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval);
dev231net/inet/ne.cdev->base_addr = ioaddr;
dev237net/inet/ne.cethdev_init(dev);
dev239net/inet/ne.cdev->name, name, ioaddr, dev->irq);
dev258net/inet/ne.cNS8390_init(dev, 0);
dev259net/inet/ne.creturn dev->base_addr;
dev265net/inet/ne.cne_reset_8390(struct device *dev)
dev277net/inet/ne.cprintk("%s: ne_reset_8390() did not complete.\n", dev->name);
dev288net/inet/ne.cne_block_input(struct device *dev, int count, char *buf, int ring_offset)
dev291net/inet/ne.cint nic_base = dev->base_addr;
dev297net/inet/ne.cdev->name, ei_status.dmaing, ei_status.irqlock);
dev333net/inet/ne.cdev->name, ring_offset + xfer_count, addr);
dev340net/inet/ne.cne_block_output(struct device *dev, int count,
dev355net/inet/ne.cdev->name, ei_status.dmaing, ei_status.irqlock);
dev408net/inet/ne.cdev->name, (start_page << 8) + count, addr);
dev48net/inet/packet.cpacket_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
dev53net/inet/packet.cskb->dev = dev;
dev54net/inet/packet.cskb->len += dev->hard_header_len;
dev105net/inet/packet.cstruct device *dev;
dev133net/inet/packet.cdev = dev_get(saddr.sa_data);
dev134net/inet/packet.cif (dev == NULL) {
dev142net/inet/packet.cif (dev->flags & IFF_UP) dev->queue_xmit(skb, dev, sk->priority);
dev246net/inet/packet.caddr.sa_family = skb->dev->type;
dev247net/inet/packet.cmemcpy(addr.sa_data,skb->dev->name, 14);
dev122net/inet/plip.cextern int plip_probe(int ioaddr, struct device *dev);
dev123net/inet/plip.cstatic int plip_open(struct device *dev);
dev124net/inet/plip.cstatic int plip_close(struct device *dev);
dev125net/inet/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
dev126net/inet/plip.cstatic int plip_header (unsigned char *buff, struct device *dev,
dev136net/inet/plip.cstatic void plip_device_clear(struct device *dev);
dev137net/inet/plip.cstatic void plip_receiver_error(struct device *dev);
dev138net/inet/plip.cstatic void plip_set_physicaladdr(struct device *dev, unsigned long ipaddr);
dev140net/inet/plip.cstatic int plip_send_enethdr(struct device *dev, struct ethhdr *eth);
dev141net/inet/plip.cstatic int plip_rebuild_enethdr(struct device *dev, struct ethhdr *eth,
dev146net/inet/plip.cstatic int plip_receive_packet(struct device *dev);
dev147net/inet/plip.cstatic int plip_send_packet(struct device *dev, unsigned char *buf, int length);
dev148net/inet/plip.cstatic int plip_send_start(struct device *dev, struct ethhdr *eth);
dev150net/inet/plip.cstatic struct enet_statistics *plip_get_stats(struct device *dev);
dev153net/inet/plip.cplip_init(struct device *dev)
dev155net/inet/plip.cint port_base = dev->base_addr;
dev174net/inet/plip.cdev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL);
dev175net/inet/plip.cmemset(dev->priv, 0, sizeof(struct netstats));
dev178net/inet/plip.cdev->buffs[i] = NULL;
dev179net/inet/plip.cdev->hard_header = &plip_header;
dev180net/inet/plip.cdev->add_arp = eth_add_arp;
dev181net/inet/plip.cdev->queue_xmit = dev_queue_xmit;
dev182net/inet/plip.cdev->rebuild_header = eth_rebuild_header;
dev183net/inet/plip.cdev->type_trans = eth_type_trans;
dev185net/inet/plip.cdev->open = &plip_open;
dev186net/inet/plip.cdev->stop = &plip_close;
dev187net/inet/plip.cdev->hard_start_xmit = &plip_tx_packet;
dev188net/inet/plip.cdev->get_stats = &plip_get_stats;
dev191net/inet/plip.cdev->type = ARPHRD_ETHER;
dev192net/inet/plip.cdev->hard_header_len = ETH_HLEN;
dev193net/inet/plip.cdev->mtu = PLIP_MTU;  /* PLIP may later negotiate max pkt size */
dev194net/inet/plip.cdev->addr_len = ETH_ALEN;
dev195net/inet/plip.cfor (i = 0; i < dev->addr_len; i++) {
dev196net/inet/plip.cdev->broadcast[i]=0xff;
dev197net/inet/plip.cdev->dev_addr[i] = 0;
dev200net/inet/plip.cdev->name, dev->base_addr, dev->irq);
dev215net/inet/plip.cplip_open(struct device *dev)
dev217net/inet/plip.cif (dev->irq == 0)
dev218net/inet/plip.cdev->irq = 7;
dev219net/inet/plip.cif (request_irq(dev->irq , &plip_interrupt) != 0) {
dev220net/inet/plip.cPRINTK(("%s: couldn't get IRQ %d.\n", dev->name, dev->irq));
dev224net/inet/plip.cirq2dev_map[dev->irq] = dev;
dev225net/inet/plip.cplip_device_clear(dev);
dev226net/inet/plip.cdev->tbusy = 0;
dev227net/inet/plip.cdev->interrupt = 0;
dev228net/inet/plip.cdev->start = 1;
dev234net/inet/plip.cplip_close(struct device *dev)
dev236net/inet/plip.cdev->tbusy = 1;
dev237net/inet/plip.cdev->start = 0;
dev238net/inet/plip.cfree_irq(dev->irq);
dev239net/inet/plip.cirq2dev_map[dev->irq] = NULL;
dev240net/inet/plip.coutb(0x00, dev->base_addr);    /* Release the interrupt. */
dev245net/inet/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
dev249net/inet/plip.cif (dev->tbusy || dev->interrupt) {  /* Do timeouts, to avoid hangs. */
dev250net/inet/plip.cint tickssofar = jiffies - dev->trans_start;
dev253net/inet/plip.cprintk("%s: transmit timed out\n", dev->name);
dev255net/inet/plip.cplip_device_clear(dev);
dev263net/inet/plip.cdev_tint(dev);
dev269net/inet/plip.cif (!skb->arp  &&  dev->rebuild_header(skb+1, dev)) {
dev270net/inet/plip.cskb->dev = dev;
dev275net/inet/plip.cdev->trans_start = jiffies;
dev276net/inet/plip.cret_val = plip_send_packet(dev, (unsigned char *)(skb+1), skb->len);
dev279net/inet/plip.cdev->tbusy = 0;
dev285net/inet/plip.cplip_header (unsigned char *buff, struct device *dev,
dev289net/inet/plip.cif (dev->dev_addr[0] == 0) {
dev291net/inet/plip.cplip_set_physicaladdr(dev, h_source);
dev293net/inet/plip.creturn eth_header(buff, dev, type, h_dest, h_source, len);
dev297net/inet/plip.cplip_device_clear(struct device *dev)
dev299net/inet/plip.cdev->interrupt = 0;
dev300net/inet/plip.cdev->tbusy = 0;
dev301net/inet/plip.coutb(0x00, dev->base_addr + PAR_DATA);
dev302net/inet/plip.coutb(0x10, dev->base_addr + PAR_CONTROL);    /* Enable the rx interrupt. */
dev306net/inet/plip.cplip_receiver_error(struct device *dev)
dev308net/inet/plip.cdev->interrupt = 0;
dev309net/inet/plip.cdev->tbusy = 0;
dev310net/inet/plip.coutb(0x02, dev->base_addr + PAR_DATA);
dev311net/inet/plip.coutb(0x10, dev->base_addr + PAR_CONTROL);    /* Enable the rx interrupt. */
dev315net/inet/plip.cget_byte(struct device *dev)
dev321net/inet/plip.cval = inb(dev->base_addr + PAR_STATUS);
dev325net/inet/plip.cval = inb(dev->base_addr + PAR_STATUS);
dev332net/inet/plip.cval = inb(dev->base_addr + PAR_STATUS);
dev334net/inet/plip.coutb(0x11, dev->base_addr + PAR_DATA);
dev338net/inet/plip.cval = inb(dev->base_addr + PAR_STATUS);
dev345net/inet/plip.cval = inb(dev->base_addr + PAR_STATUS);
dev348net/inet/plip.coutb(0x01, dev->base_addr + PAR_DATA);
dev363net/inet/plip.cstruct device *dev = irq2dev_map[irq];
dev366net/inet/plip.cif (dev == NULL) {
dev370net/inet/plip.clocalstats = (struct netstats*) dev->priv;
dev371net/inet/plip.cif (dev->tbusy || dev->interrupt) return;
dev372net/inet/plip.cdev->interrupt = 1;
dev373net/inet/plip.coutb(0x00, dev->base_addr + PAR_CONTROL);  /* Disable the rx interrupt. */
dev375net/inet/plip.cPRINTK2(("%s: interrupt.  ", dev->name));
dev380net/inet/plip.cwhile ((inb(dev->base_addr + PAR_STATUS) & 0xf8) != 0xc0) {
dev383net/inet/plip.cdev->name, inb(dev->base_addr + PAR_STATUS)));
dev384net/inet/plip.cplip_device_clear(dev);
dev389net/inet/plip.cif (plip_receive_packet(dev)) {
dev392net/inet/plip.cplip_receiver_error(dev);
dev394net/inet/plip.cplip_device_clear(dev);
dev399net/inet/plip.cplip_receive_packet(struct device *dev)
dev408net/inet/plip.clocalstats = (struct netstats*) dev->priv;
dev410net/inet/plip.coutb(1, dev->base_addr + PAR_DATA);    /* Ack: 'Ready' */
dev414net/inet/plip.cplip_type = get_byte(dev);
dev416net/inet/plip.clength = get_byte(dev) << 8;
dev417net/inet/plip.clength |= get_byte(dev);
dev424net/inet/plip.c*eth_p = get_byte(dev);
dev432net/inet/plip.ch_dest = get_byte(dev);
dev433net/inet/plip.ch_source = get_byte(dev);
dev434net/inet/plip.ctype = get_byte(dev) << 8;
dev435net/inet/plip.ctype |= get_byte(dev);
dev436net/inet/plip.cplip_rebuild_enethdr(dev, &eth, h_dest, h_source, type);
dev440net/inet/plip.cPRINTK(("%s: wrong header octet\n", dev->name));
dev443net/inet/plip.cif (length > dev->mtu || length < 8) {
dev444net/inet/plip.cPRINTK2(("%s: bogus packet size %d.\n", dev->name, length));
dev457net/inet/plip.cdev->name, sksize));
dev475net/inet/plip.cunsigned char new_byte = get_byte(dev);
dev480net/inet/plip.cif (checksum != get_byte(dev)) {
dev484net/inet/plip.c} else if(dev_rint((unsigned char *)skb, length, IN_SKBUFF, dev)) {
dev485net/inet/plip.cprintk("%s: rcv buff full.\n", dev->name);
dev495net/inet/plip.coutb(0x00, dev->base_addr + PAR_DATA);
dev497net/inet/plip.cwhile ( (inb(dev->base_addr + PAR_STATUS) & 0xf8) != 0x80 ) {
dev510net/inet/plip.cstatic int send_byte(struct device *dev, unsigned char val)
dev514net/inet/plip.cif (!(inb(dev->base_addr+PAR_STATUS) & 0x08)) {
dev519net/inet/plip.coutb(val, dev->base_addr); /* this makes data bits more stable */
dev520net/inet/plip.coutb(0x10 | val, dev->base_addr);
dev522net/inet/plip.cwhile( inb(dev->base_addr+PAR_STATUS) & 0x80 )
dev527net/inet/plip.coutb(0x10 | (val >> 4), dev->base_addr);
dev528net/inet/plip.coutb(val >> 4, dev->base_addr);
dev530net/inet/plip.cwhile( (inb(dev->base_addr+PAR_STATUS) & 0x80) == 0 )
dev552net/inet/plip.cplip_send_start(struct device *dev, struct ethhdr *eth)
dev557net/inet/plip.cstruct netstats *localstats = (struct netstats*) dev->priv;
dev562net/inet/plip.cwhile ( ((status = inb(dev->base_addr+PAR_STATUS)) & 0x08) == 0 ) {
dev563net/inet/plip.cdev->tbusy = 1;
dev564net/inet/plip.coutb(0x00, dev->base_addr + PAR_CONTROL); /* Disable my rx intr. */
dev565net/inet/plip.coutb(0x08, dev->base_addr + PAR_DATA);   /* Trigger remote rx intr. */
dev575net/inet/plip.cif (plip_receive_packet(dev)) {
dev578net/inet/plip.coutb(0x02, dev->base_addr + PAR_DATA);
dev580net/inet/plip.coutb(0x00, dev->base_addr + PAR_DATA);
dev588net/inet/plip.coutb(0x00, dev->base_addr + PAR_DATA);
dev594net/inet/plip.cplip_device_clear(dev);
dev597net/inet/plip.cdev->name));
dev606net/inet/plip.cplip_send_packet(struct device *dev, unsigned char *buf, int length)
dev613net/inet/plip.cdev->name, length, buf[0], buf[1], buf[2], buf[3], buf[4]));
dev614net/inet/plip.cif (length > dev->mtu) {
dev615net/inet/plip.cprintk("%s: packet too big, %d.\n", dev->name, length);
dev618net/inet/plip.clocalstats = (struct netstats*) dev->priv;
dev624net/inet/plip.cwhile ( (i = (inb(dev->base_addr+PAR_STATUS) & 0xe8)) != 0x80 ) {
dev643net/inet/plip.cif (plip_send_start(dev, (struct ethhdr *)buf) < 0)
dev660net/inet/plip.csend_byte(dev, plip_type); /* send header octet */
dev670net/inet/plip.csend_byte(dev, length >> 8); send_byte(dev, length);
dev678net/inet/plip.cplip_send_enethdr(dev, (struct ethhdr*)buf);
dev682net/inet/plip.csend_byte(dev, *buf);
dev689net/inet/plip.cif (send_byte(dev, buf[i]) < 0) {
dev694net/inet/plip.csend_byte(dev, checksum & 0xff);
dev700net/inet/plip.coutb(0x00, dev->base_addr + PAR_DATA);
dev703net/inet/plip.cwhile ((inb(dev->base_addr + PAR_STATUS) & 0xe8) != 0x80) {
dev711net/inet/plip.cif (inb(dev->base_addr + PAR_STATUS) & 0x10) {
dev716net/inet/plip.cplip_device_clear(dev);
dev726net/inet/plip.cplip_set_physicaladdr(struct device *dev, unsigned long ipaddr)
dev733net/inet/plip.cunsigned char *addr = dev->dev_addr;
dev737net/inet/plip.cPRINTK2(("%s: set physical address to %08x\n", dev->name, ipaddr));
dev759net/inet/plip.cplip_send_enethdr(struct device *dev, struct ethhdr *eth)
dev761net/inet/plip.csend_byte(dev, eth->h_dest[ETH_ALEN-1]);
dev762net/inet/plip.csend_byte(dev, eth->h_source[ETH_ALEN-1]);
dev763net/inet/plip.csend_byte(dev, eth->h_proto >> 8);
dev764net/inet/plip.csend_byte(dev, eth->h_proto);
dev769net/inet/plip.cplip_rebuild_enethdr(struct device *dev, struct ethhdr *eth,
dev774net/inet/plip.cmemcpy(eth->h_dest, dev->dev_addr, ETH_ALEN-1);
dev776net/inet/plip.cmemcpy(eth->h_source, dev->dev_addr, ETH_ALEN-1);
dev803net/inet/plip.cplip_get_stats(struct device *dev)
dev805net/inet/plip.cstruct netstats *localstats = (struct netstats*) dev->priv;
dev26net/inet/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
dev85net/inet/raw.craw_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev93net/inet/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
dev109net/inet/raw.cskb->dev = dev;
dev167net/inet/raw.cstruct device *dev=NULL;
dev229net/inet/raw.csin.sin_addr.s_addr, &dev,
dev255net/inet/raw.csk->prot->queue_xmit(sk, dev, skb, 1);
dev26net/inet/raw.hextern int  raw_rcv(struct sk_buff *skb, struct device *dev,
dev85net/inet/route.crt_flush(struct device *dev)
dev89net/inet/route.cDPRINTF((DBG_RT, "RT: flushing for dev 0x%08lx (%s)\n", (long)dev, dev->name));
dev93net/inet/route.cif (r->rt_dev == dev) {
dev108net/inet/route.crt_add(short flags, unsigned long dst, unsigned long gw, struct device *dev)
dev125net/inet/route.crt->rt_dev = dev;
dev137net/inet/route.crt->rt_dst = (dst & dev->pa_mask);
dev202net/inet/route.cstruct device *dev;
dev221net/inet/route.cdev = dev_check(((struct sockaddr_in *) &r->rt_dst)->sin_addr.s_addr);
dev225net/inet/route.cdev = rt->rt_dev;
dev227net/inet/route.cdev = NULL;
dev233net/inet/route.cr->rt_flags, dev, (dev == NULL) ? "NONE" : dev->name));
dev235net/inet/route.cif (dev == NULL) return(-ENETUNREACH);
dev238net/inet/route.c(*(struct sockaddr_in *) &r->rt_gateway).sin_addr.s_addr, dev);
dev326net/inet/route.cstruct device *dev;
dev343net/inet/route.cdev = dev_get(namebuf);
dev344net/inet/route.crt.rt_dev = dev;
dev38net/inet/route.hextern void    rt_flush(struct device *dev);
dev40net/inet/route.hunsigned long gw, struct device *dev);
dev33net/inet/skbuff.hstruct device      *dev;
dev116net/inet/slip.csl_initialize(struct slip *sl, struct device *dev)
dev122net/inet/slip.csl->line    = dev->base_addr;
dev124net/inet/slip.csl->dev    = dev;
dev134net/inet/slip.cdev->rmem_end    = (unsigned long) NULL;
dev135net/inet/slip.cdev->rmem_start  = (unsigned long) NULL;
dev136net/inet/slip.cdev->mem_end    = (unsigned long) NULL;
dev137net/inet/slip.cdev->mem_start  = (unsigned long) NULL;
dev237net/inet/slip.csl->dev->tbusy = 1;
dev251net/inet/slip.csl->dev->tbusy = 0;
dev297net/inet/slip.cDPRINTF((DBG_SLIP, "<< \"%s\" recv:\r\n", sl->dev->name));
dev305net/inet/slip.cdone = dev_rint(sl->rbuff, count, 0, sl->dev);
dev319net/inet/slip.cdev_tint(sl->dev);
dev332net/inet/slip.cDPRINTF((DBG_SLIP, ">> \"%s\" sent:\r\n", sl->dev->name));
dev388net/inet/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
dev394net/inet/slip.csl = &sl_ctrl[dev->base_addr];
dev397net/inet/slip.cdev->name, skb, sl->sending));
dev422net/inet/slip.csl_type_trans (struct sk_buff *skb, struct device *dev)
dev430net/inet/slip.csl_header(unsigned char *buff, struct device *dev, unsigned short type,
dev439net/inet/slip.csl_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
dev446net/inet/slip.csl_rebuild_header(void *buff, struct device *dev)
dev454net/inet/slip.csl_open(struct device *dev)
dev460net/inet/slip.csl = &sl_ctrl[dev->base_addr];
dev465net/inet/slip.csl->dev = dev;
dev475net/inet/slip.cl = (dev->mtu * 2);
dev481net/inet/slip.csl->dev->mem_start  = (unsigned long) p;
dev482net/inet/slip.csl->dev->mem_end  = (unsigned long) (sl->dev->mem_start + l);
dev489net/inet/slip.csl->dev->rmem_start  = (unsigned long) p;
dev490net/inet/slip.csl->dev->rmem_end  = (unsigned long) (sl->dev->rmem_start + l);
dev492net/inet/slip.csl->xbuff    = (unsigned char *) sl->dev->mem_start;
dev493net/inet/slip.csl->rbuff    = (unsigned char *) sl->dev->rmem_start;
dev494net/inet/slip.csl->rend    = (unsigned char *) sl->dev->rmem_end;
dev521net/inet/slip.csl_close(struct device *dev)
dev525net/inet/slip.csl = &sl_ctrl[dev->base_addr];
dev538net/inet/slip.csl_initialize(sl, dev);
dev607net/inet/slip.ctty->line, sl->dev->name));
dev622net/inet/slip.c(void) sl_open(sl->dev);
dev624net/inet/slip.ctty->line, sl->dev->name));
dev648net/inet/slip.c(void) dev_close(sl->dev);
dev650net/inet/slip.ctty->line, sl->dev->name));
dev670net/inet/slip.cmemcpy_tofs(arg, sl->dev->name, strlen(sl->dev->name) + 1);
dev681net/inet/slip.cslip_init(struct device *dev)
dev686net/inet/slip.csl = &sl_ctrl[dev->base_addr];
dev706net/inet/slip.csl_initialize(sl, dev);
dev717net/inet/slip.cdev->mtu    = SL_MTU;
dev718net/inet/slip.cdev->hard_start_xmit  = sl_xmit;
dev719net/inet/slip.cdev->open    = sl_open;
dev720net/inet/slip.cdev->stop    = sl_close;
dev721net/inet/slip.cdev->hard_header  = sl_header;
dev722net/inet/slip.cdev->add_arp    = sl_add_arp;
dev723net/inet/slip.cdev->type_trans  = sl_type_trans;
dev724net/inet/slip.cdev->hard_header_len  = 0;
dev725net/inet/slip.cdev->addr_len    = 0;
dev726net/inet/slip.cdev->type    = 0;
dev727net/inet/slip.cdev->queue_xmit  = dev_queue_xmit;
dev728net/inet/slip.cdev->rebuild_header  = sl_rebuild_header;
dev730net/inet/slip.cdev->buffs[i] = NULL;
dev733net/inet/slip.cdev->flags    = 0;
dev734net/inet/slip.cdev->family    = AF_INET;
dev735net/inet/slip.cdev->pa_addr    = 0;
dev736net/inet/slip.cdev->pa_brdaddr  = 0;
dev737net/inet/slip.cdev->pa_mask    = 0;
dev738net/inet/slip.cdev->pa_alen    = sizeof(unsigned long);
dev35net/inet/slip.hstruct device    *dev;    /* easy for intr handling  */
dev57net/inet/slip.hextern int  slip_init(struct device *dev);
dev392net/inet/sock.cif (skb->dev &&
dev393net/inet/sock.cskb->dev->buffs[i] == skb) {
dev401net/inet/sock.cskb->dev->buffs[i]= skb->next;
dev417net/inet/sock.cif (skb->dev &&
dev418net/inet/sock.cskb->dev->buffs[i] == skb) {
dev426net/inet/sock.cskb->dev->buffs[i]= NULL;
dev433net/inet/sock.cskb->dev = NULL;
dev1601net/inet/sock.cif (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt,
dev137net/inet/sock.hstruct device **dev, int type,
dev143net/inet/sock.hstruct device *dev, struct sk_buff *skb,
dev148net/inet/sock.hint      (*rcv)(struct sk_buff *buff, struct device *dev,
dev477net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb,0);
dev491net/inet/tcp.cstruct device *dev = NULL;
dev517net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev,
dev557net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev598net/inet/tcp.cstruct device *dev = NULL;
dev784net/inet/tcp.ctmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev,
dev794net/inet/tcp.cskb->dev = dev;
dev841net/inet/tcp.cprot->queue_xmit(sk, dev, skb,0);
dev871net/inet/tcp.cstruct device *dev = NULL;
dev902net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
dev928net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev1294net/inet/tcp.cstruct device *dev = NULL;
dev1327net/inet/tcp.ctmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
dev1339net/inet/tcp.cbuff->dev = dev;
dev1362net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
dev1398net/inet/tcp.cstruct proto *prot, struct options *opt, struct device *dev)
dev1417net/inet/tcp.cbuff->dev = dev;
dev1422net/inet/tcp.ctmp = prot->build_header(buff, saddr, daddr, &dev, IPPROTO_TCP, opt,
dev1447net/inet/tcp.cprot->queue_xmit(NULL, dev, buff, 1);
dev1461net/inet/tcp.cstruct options *opt, struct device *dev)
dev1472net/inet/tcp.csk, skb, daddr, saddr, opt, dev));
dev1481net/inet/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt, dev);
dev1567net/inet/tcp.cnewsk->mtu = dev->mtu - HEADER_SIZE;
dev1571net/inet/tcp.cnewsk->mtu = dev->mtu - HEADER_SIZE;
dev1574net/inet/tcp.cdev->mtu - HEADER_SIZE);
dev1596net/inet/tcp.ctmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &dev,
dev1635net/inet/tcp.cptr[2] =((dev->mtu - HEADER_SIZE) >> 8) & 0xff;
dev1636net/inet/tcp.cptr[3] =(dev->mtu - HEADER_SIZE) & 0xff;
dev1639net/inet/tcp.cnewsk->prot->queue_xmit(newsk, dev, buff, 0);
dev1670net/inet/tcp.cstruct device *dev=NULL;
dev1751net/inet/tcp.ctmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev,
dev1763net/inet/tcp.cbuff->dev = dev;
dev1780net/inet/tcp.cprot->queue_xmit(sk, dev, buff, 0);
dev1837net/inet/tcp.csk->prot->queue_xmit(sk, skb->dev, skb, skb->free);
dev1938net/inet/tcp.cif (skb->dev->buffs[i] == skb) {
dev1940net/inet/tcp.cskb->dev->buffs[i] = NULL;
dev1942net/inet/tcp.cskb->dev->buffs[i] = skb->next;
dev2055net/inet/tcp.cif (oskb->dev->buffs[i] == oskb) {
dev2057net/inet/tcp.coskb->dev->buffs[i]= NULL;
dev2059net/inet/tcp.coskb->dev->buffs[i] = oskb->next;
dev2178net/inet/tcp.csk->prot, NULL, skb->dev);
dev2383net/inet/tcp.cunsigned long saddr, struct device *dev)
dev2386net/inet/tcp.csk, th, saddr, dev));
dev2483net/inet/tcp.cstruct device *dev=NULL;
dev2525net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
dev2553net/inet/tcp.cptr[2] = (dev->mtu- HEADER_SIZE) >> 8;
dev2554net/inet/tcp.cptr[3] = (dev->mtu- HEADER_SIZE) & 0xff;
dev2555net/inet/tcp.csk->mtu = dev->mtu - HEADER_SIZE;
dev2562net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
dev2633net/inet/tcp.ctcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev2654net/inet/tcp.cif (!dev) {
dev2684net/inet/tcp.cif (!th->rst) tcp_reset(daddr, saddr, th, &tcp_prot, opt,dev);
dev2806net/inet/tcp.ctcp_reset(daddr, saddr,  th, sk->prot, opt,dev);
dev2830net/inet/tcp.cif (th->fin && tcp_fin(sk, th, saddr, dev)) {
dev2856net/inet/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt,dev);
dev2869net/inet/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt,dev);
dev2878net/inet/tcp.ctcp_reset(daddr, saddr, th, prot, opt,dev);
dev2890net/inet/tcp.ctcp_conn_request(sk, skb, daddr, saddr, opt, dev);
dev2923net/inet/tcp.ctcp_reset(daddr, saddr,  th, sk->prot, opt, dev);
dev2946net/inet/tcp.csk->prot, opt,dev);
dev2971net/inet/tcp.csk->prot, opt, dev);
dev3004net/inet/tcp.cif (th->fin) tcp_fin(sk, th, saddr, dev);
dev3027net/inet/tcp.ctcp_fin(sk, th, saddr, dev);
dev3043net/inet/tcp.cstruct device *dev=NULL;
dev3061net/inet/tcp.ctmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev,
dev3094net/inet/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev132net/inet/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
dev200net/inet/udp.cstruct device *dev;
dev226net/inet/udp.cdev = NULL;
dev228net/inet/udp.csaddr, sin->sin_addr.s_addr, dev, IPPROTO_UDP, skb->mem_len));
dev230net/inet/udp.c&dev, IPPROTO_UDP, sk->opt, skb->mem_len);
dev236net/inet/udp.csaddr = dev->pa_addr;
dev240net/inet/udp.cskb->dev = dev;
dev247net/inet/udp.cif (len > dev->mtu) {
dev248net/inet/udp.cprintk("UDP: send: length %d > mtu %d (ignored)\n", len, dev->mtu);
dev270net/inet/udp.csk->prot->queue_xmit(sk, dev, skb, 1);
dev542net/inet/udp.cudp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev553net/inet/udp.cicmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
dev574net/inet/udp.cskb->dev = dev;
dev40net/inet/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,
dev31net/inet/wd.cint wdprobe(int ioaddr, struct device *dev);
dev32net/inet/wd.cint wdprobe1(int ioaddr, struct device *dev);
dev34net/inet/wd.cstatic int wd_open(struct device *dev);
dev35net/inet/wd.cstatic void wd_reset_8390(struct device *dev);
dev36net/inet/wd.cstatic int wd_block_input(struct device *dev, int count,
dev38net/inet/wd.cstatic void wd_block_output(struct device *dev, int count,
dev40net/inet/wd.cstatic int wd_close_card(struct device *dev);
dev63net/inet/wd.cint wd_probe(struct device *dev)
dev66net/inet/wd.cshort ioaddr = dev->base_addr;
dev71net/inet/wd.creturn ! wdprobe1(ioaddr, dev);
dev80net/inet/wd.c&& wdprobe1(*port, dev))
dev83net/inet/wd.cdev->base_addr = ioaddr;
dev87net/inet/wd.cint wdprobe1(int ioaddr, struct device *dev)
dev90net/inet/wd.cunsigned char *station_addr = dev->dev_addr;
dev101net/inet/wd.cprintk("%s: WD80x3 at %#3x, ", dev->name, ioaddr);
dev120net/inet/wd.cdev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12;
dev121net/inet/wd.cdev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1;
dev162net/inet/wd.cdev->mem_start = WD_SHMEM;
dev164net/inet/wd.cif (dev->mem_start == 0) {
dev169net/inet/wd.cdev->mem_start = 0xd0000;
dev170net/inet/wd.cprintk(" assigning address %#x", dev->mem_start);
dev176net/inet/wd.cdev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19);
dev182net/inet/wd.cdev->base_addr = ioaddr+WD_NIC_OFFSET;
dev184net/inet/wd.cif (dev->irq < 2) {
dev189net/inet/wd.cdev->irq = word16 ? 10 : 5;
dev191net/inet/wd.cdev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)];
dev192net/inet/wd.c} else if (dev->irq == 2)  /* Fixup bogosity: IRQ2 is really IRQ9 */
dev193net/inet/wd.cdev->irq = 9;
dev197net/inet/wd.c{ int irqval = irqaction (dev->irq, &ei_sigaction);
dev199net/inet/wd.cprintk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval);
dev208net/inet/wd.cethdev_init(dev);
dev217net/inet/wd.cdev->rmem_start = dev->mem_start + TX_PAGES*256;
dev218net/inet/wd.cdev->mem_end = dev->rmem_end
dev219net/inet/wd.c= dev->mem_start + (ei_status.stop_page - WD_START_PG)*256;
dev222net/inet/wd.cmodel_name, dev->irq, dev->mem_start, dev->mem_end-1);
dev229net/inet/wd.cdev->open = &wd_open;
dev230net/inet/wd.cdev->stop = &wd_close_card;
dev231net/inet/wd.cNS8390_init(dev, 0);
dev233net/inet/wd.creturn dev->base_addr;
dev237net/inet/wd.cwd_open(struct device *dev)
dev239net/inet/wd.cint ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
dev243net/inet/wd.cei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB;
dev244net/inet/wd.cei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16;
dev250net/inet/wd.creturn ei_open(dev);
dev254net/inet/wd.cwd_reset_8390(struct device *dev)
dev256net/inet/wd.cint wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
dev277net/inet/wd.coutb(NIC16 | ((dev->mem_start>>19) & 0x1f),
dev279net/inet/wd.coutb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port);
dev281net/inet/wd.cwhile ((inb(dev->base_addr+EN0_ISR) & ENISR_RESET) == 0)
dev283net/inet/wd.cprintk("%s: wd_reset_8390() did not complete.\n", dev->name);
dev294net/inet/wd.cwd_block_input(struct device *dev, int count, char *buf, int ring_offset)
dev296net/inet/wd.cvoid *xfer_start = (void *)(dev->mem_start + ring_offset
dev301net/inet/wd.cint wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
dev308net/inet/wd.cif (xfer_start + count > (void*) dev->rmem_end) {
dev310net/inet/wd.cint semi_count = (void*)dev->rmem_end - xfer_start;
dev313net/inet/wd.cmemcpy(buf + semi_count, (char *)dev->rmem_start, count);
dev314net/inet/wd.creturn dev->rmem_start + count;
dev327net/inet/wd.cwd_block_output(struct device *dev, int count, const unsigned char *buf,
dev331net/inet/wd.c= (unsigned char *)dev->mem_start + ((start_page - WD_START_PG)<<8);
dev334net/inet/wd.cint wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
dev352net/inet/wd.cwd_close_card(struct device *dev)
dev354net/inet/wd.cint wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */
dev357net/inet/wd.cprintk("%s: Shutting down ethercard.\n", dev->name);
dev358net/inet/wd.cNS8390_init(dev, 0);