taglinefilesource code
dev23fs/block_dev.cunsigned int dev;
dev27fs/block_dev.cdev = inode->i_rdev;
dev28fs/block_dev.cif (blk_size[MAJOR(dev)])
dev29fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)];
dev39fs/block_dev.cbh = getblk(dev, block, BLOCK_SIZE);
dev41fs/block_dev.cbh = breada(dev,block,block+1,block+2,-1);
dev73fs/block_dev.cunsigned int dev;
dev76fs/block_dev.cdev = inode->i_rdev;
dev78fs/block_dev.cif (blk_size[MAJOR(dev)])
dev79fs/block_dev.csize = blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS;
dev98fs/block_dev.cblocks += read_ahead[MAJOR(dev)] / (BLOCK_SIZE >> 9);
dev118fs/block_dev.c*bhb = getblk(dev, block++, BLOCK_SIZE);
dev75fs/buffer.cstatic void sync_buffers(dev_t dev)
dev82fs/buffer.cif (dev && bh->b_dev != dev)
dev92fs/buffer.cvoid sync_dev(dev_t dev)
dev94fs/buffer.csync_buffers(dev);
dev95fs/buffer.csync_supers(dev);
dev96fs/buffer.csync_inodes(dev);
dev97fs/buffer.csync_buffers(dev);
dev111fs/buffer.cvoid invalidate_buffers(dev_t dev)
dev118fs/buffer.cif (bh->b_dev != dev)
dev121fs/buffer.cif (bh->b_dev == dev)
dev140fs/buffer.cvoid check_disk_change(dev_t dev)
dev145fs/buffer.cswitch(MAJOR(dev)){
dev147fs/buffer.cif (!(bh = getblk(dev,0,1024)))
dev155fs/buffer.ci = check_scsidisk_media_change(dev, 0);
dev161fs/buffer.ci = check_cdrom_media_change(dev, 0);
dev172fs/buffer.cMAJOR(dev), MINOR(dev));
dev174fs/buffer.cif (super_block[i].s_dev == dev)
dev176fs/buffer.cinvalidate_inodes(dev);
dev177fs/buffer.cinvalidate_buffers(dev);
dev182fs/buffer.cif (MAJOR(dev) == 8)
dev183fs/buffer.crevalidate_scsidisk(dev, 0);
dev187fs/buffer.c#define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH)
dev188fs/buffer.c#define hash(dev,block) hash_table[_hashfn(dev,block)]
dev265fs/buffer.cstatic struct buffer_head * find_buffer(dev_t dev, int block, int size)
dev269fs/buffer.cfor (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next)
dev270fs/buffer.cif (tmp->b_dev==dev && tmp->b_blocknr==block)
dev275fs/buffer.cMAJOR(dev), MINOR(dev));
dev288fs/buffer.cstruct buffer_head * get_hash_table(dev_t dev, int block, int size)
dev293fs/buffer.cif (!(bh=find_buffer(dev,block,size)))
dev297fs/buffer.cif (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size)
dev314fs/buffer.cstruct buffer_head * getblk(dev_t dev, int block, int size)
dev321fs/buffer.cbh = get_hash_table(dev, block, size);
dev372fs/buffer.cif (find_buffer(dev,block,size))
dev380fs/buffer.cbh->b_dev=dev;
dev404fs/buffer.cstruct buffer_head * bread(dev_t dev, int block, int size)
dev408fs/buffer.cif (!(bh = getblk(dev, block, size))) {
dev410fs/buffer.cMAJOR(dev), MINOR(dev));
dev428fs/buffer.cstruct buffer_head * breada(dev_t dev,int first, ...)
dev434fs/buffer.cif (!(bh = getblk(dev, first, 1024))) {
dev436fs/buffer.cMAJOR(dev), MINOR(dev));
dev442fs/buffer.ctmp = getblk(dev, first, 1024);
dev504fs/buffer.cstatic inline unsigned long try_to_share_buffers(unsigned long address, dev_t dev, int b[], int size)
dev521fs/buffer.cunsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int prot)
dev530fs/buffer.cwhere = try_to_share_buffers(address,dev,b,size);
dev537fs/buffer.cbh[i] = getblk(dev, b[i], size);
dev61fs/ext/inode.cint dev = s->s_dev,block;
dev64fs/ext/inode.cif (!(bh = bread(dev, 1, BLOCK_SIZE))) {
dev88fs/ext/inode.cdev);
dev94fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeblock = bread(dev,
dev105fs/ext/inode.cif (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) {
dev115fs/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 ||
dev105fs/ext2/dcache.cp->dev, p->dir, p->name);
dev171fs/ext2/dcache.cvoid ext2_dcache_invalidate (unsigned short dev)
dev180fs/ext2/dcache.cif (p->dev == dev) {
dev182fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
dev197fs/ext2/dcache.cunsigned long ext2_dcache_lookup (unsigned short dev, unsigned long dir,
dev211fs/ext2/dcache.cprintk ("dcache_lookup (%04x, %d, %s, %d)\n", dev, dir, our_name, len);
dev213fs/ext2/dcache.cqueue = hash(dev, dir);
dev214fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, our_name, len))) {
dev249fs/ext2/dcache.cvoid ext2_dcache_add (unsigned short dev, unsigned long dir, const char *name,
dev259fs/ext2/dcache.cdev, dir, name, len, ino);
dev263fs/ext2/dcache.cqueue = hash(dev, dir);
dev264fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
dev287fs/ext2/dcache.cremove_from_queue (hash (p->dev, p->dir), p);
dev290fs/ext2/dcache.cp->dev = dev;
dev311fs/ext2/dcache.cvoid ext2_dcache_remove (unsigned short dev, unsigned long dir,
dev320fs/ext2/dcache.cprintk ("dcache_remove (%04x, %d, %s, %d)\n", dev, dir, name, len);
dev324fs/ext2/dcache.cqueue = hash(dev, dir);
dev325fs/ext2/dcache.cif ((p = find_name (queue, dev, dir, name, len))) {
dev120fs/ext2/inode.cint dev = s->s_dev;
dev128fs/ext2/inode.cif (!(bh = bread (dev, 1, BLOCK_SIZE))) {
dev198fs/ext2/inode.cdev);
dev221fs/ext2/inode.cs->u.ext2_sb.s_group_desc[i] = bread (dev, i + 2, s->s_blocksize);
dev242fs/ext2/inode.cs->s_dev = dev;
dev72fs/inode.cint fs_may_mount(dev_t dev)
dev77fs/inode.cif (inode->i_dev != dev)
dev86fs/inode.cint fs_may_umount(dev_t dev, struct inode * mount_root)
dev91fs/inode.cif (inode->i_dev==dev && inode->i_count)
dev157fs/inode.cvoid invalidate_inodes(dev_t dev)
dev165fs/inode.cif (inode->i_dev == dev) {
dev168fs/inode.cMAJOR(dev), MINOR(dev));
dev176fs/inode.cvoid sync_inodes(dev_t dev)
dev181fs/inode.cif (dev && inode->i_dev != dev)
dev198fs/isofs/dir.ccache.dev = inode->i_dev;
dev100fs/isofs/inode.cint dev=s->s_dev;
dev121fs/isofs/inode.cif (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-ISOFS_BUFFER_BITS), ISOFS_BUFFER_SIZE))) {
dev124fs/isofs/inode.cdev, iso_blknum);
dev215fs/isofs/inode.cs->s_dev = dev;
dev577fs/isofs/inode.cstruct buffer_head * leak_check_bread(int dev, int block, int size){
dev579fs/isofs/inode.creturn bread(dev, block, size);
dev214fs/isofs/namei.cif (dir->i_dev == cache.dev && 
dev56fs/minix/inode.cint i,dev=s->s_dev,block;
dev61fs/minix/inode.cif (!(bh = bread(dev,1,BLOCK_SIZE))) {
dev89fs/minix/inode.cdev);
dev98fs/minix/inode.cif ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
dev103fs/minix/inode.cif ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL)
dev120fs/minix/inode.cs->s_dev = dev;
dev381fs/namei.cint do_mknod(const char * filename, int mode, dev_t dev)
dev407fs/namei.creturn dir->i_op->mknod(dir,basename,namelen,mode,dev);
dev410fs/namei.cint sys_mknod(const char * filename, int mode, dev_t dev)
dev419fs/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)
dev66fs/nfs/inode.cdev_t dev = sb->s_dev;
dev92fs/nfs/inode.csb->s_dev = dev;
dev24fs/open.cint sys_ustat(int dev, struct ustat * ubuf)
dev96fs/proc/link.cunsigned int dev,ino;
dev104fs/proc/link.cdev = inode->i_dev;
dev107fs/proc/link.ci = sprintf(buf,"[%04x]:%u", dev, ino);
dev67fs/super.cvoid sync_supers(dev_t dev)
dev74fs/super.cif (dev && sb->s_dev != dev)
dev79fs/super.cif (dev && (dev != sb->s_dev))
dev86fs/super.cstatic struct super_block * get_super(dev_t dev)
dev90fs/super.cif (!dev)
dev94fs/super.cif (s->s_dev == dev) {
dev96fs/super.cif (s->s_dev == dev)
dev104fs/super.cvoid put_super(dev_t dev)
dev108fs/super.cif (dev == ROOT_DEV) {
dev110fs/super.cMAJOR(dev), MINOR(dev));
dev113fs/super.cif (!(sb = get_super(dev)))
dev117fs/super.cMAJOR(dev), MINOR(dev));
dev124fs/super.cstatic struct super_block * read_super(dev_t dev,char *name,int flags,
dev130fs/super.cif (!dev)
dev132fs/super.ccheck_disk_change(dev);
dev133fs/super.cs = get_super(dev);
dev138fs/super.cMAJOR(dev), MINOR(dev), name);
dev147fs/super.cs->s_dev = dev;
dev153fs/super.cs->s_dev = dev;
dev186fs/super.cstatic void put_unnamed_dev(dev_t dev)
dev188fs/super.cif (!dev)
dev190fs/super.cif (!unnamed_dev_in_use[dev]) {
dev192fs/super.cMAJOR(dev), MINOR(dev));
dev195fs/super.cunnamed_dev_in_use[dev] = 0;
dev198fs/super.cstatic int do_umount(dev_t dev)
dev202fs/super.cif (dev==ROOT_DEV)
dev204fs/super.cif (!(sb=get_super(dev)) || !(sb->s_covered))
dev208fs/super.cMAJOR(dev), MINOR(dev));
dev209fs/super.cif (!fs_may_umount(dev, sb->s_mounted))
dev218fs/super.cput_super(dev);
dev236fs/super.cdev_t dev;
dev247fs/super.cdev = inode->i_rdev;
dev257fs/super.cdev = inode->i_sb->s_dev;
dev260fs/super.cdummy_inode.i_rdev = dev;
dev266fs/super.cif (MAJOR(dev) >= MAX_BLKDEV) {
dev270fs/super.cif (!(retval = do_umount(dev))) {
dev271fs/super.cfops = blkdev_fops[MAJOR(dev)];
dev274fs/super.cif (MAJOR(dev) == UNNAMED_MAJOR)
dev275fs/super.cput_unnamed_dev(dev);
dev281fs/super.csync_dev(dev);
dev294fs/super.cstatic int do_mount(dev_t dev, const char * dir, char * type, int flags, void * data)
dev311fs/super.cif (!fs_may_mount(dev)) {
dev315fs/super.csb = read_super(dev,type,flags,data,0);
dev369fs/super.cdev_t dev;
dev406fs/super.cdev = inode->i_rdev;
dev407fs/super.cif (MAJOR(dev) >= MAX_BLKDEV) {
dev412fs/super.cif (!(dev = get_unnamed_dev()))
dev416fs/super.cfops = blkdev_fops[MAJOR(dev)];
dev438fs/super.cretval = do_mount(dev,dir_name,t,flags,(void *) page);
dev63fs/xiafs/inode.cint i, z, dev;
dev65fs/xiafs/inode.cdev=s->s_dev;
dev67fs/xiafs/inode.cif (!(bh = bread(dev, 0, BLOCK_SIZE))) {
dev81fs/xiafs/inode.cdev);
dev108fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
dev118fs/xiafs/inode.cif (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
dev124fs/xiafs/inode.cs->s_dev = dev;
dev326include/linux/fs.hextern int fs_may_mount(dev_t dev);
dev327include/linux/fs.hextern int fs_may_umount(dev_t dev, struct inode * mount_root);
dev339include/linux/fs.hextern void check_disk_change(dev_t dev);
dev340include/linux/fs.hextern void invalidate_inodes(dev_t dev);
dev341include/linux/fs.hextern void invalidate_buffers(dev_t dev);
dev343include/linux/fs.hextern int ticks_to_floppy_on(unsigned int dev);
dev344include/linux/fs.hextern void floppy_on(unsigned int dev);
dev345include/linux/fs.hextern void floppy_off(unsigned int dev);
dev346include/linux/fs.hextern void sync_inodes(dev_t dev);
dev347include/linux/fs.hextern void sync_dev(dev_t dev);
dev348include/linux/fs.hextern void sync_supers(dev_t dev);
dev356include/linux/fs.hextern int do_mknod(const char * filename, int mode, dev_t dev);
dev363include/linux/fs.hextern struct buffer_head * get_hash_table(dev_t dev, int block, int size);
dev364include/linux/fs.hextern struct buffer_head * getblk(dev_t dev, int block, int size);
dev366include/linux/fs.hextern void ll_rw_page(int rw, int dev, int nr, char * buffer);
dev367include/linux/fs.hextern void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buffer);
dev369include/linux/fs.hextern struct buffer_head * bread(dev_t dev, int block, int size);
dev370include/linux/fs.hextern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int prot);
dev371include/linux/fs.hextern struct buffer_head * breada(dev_t dev,int block,...);
dev372include/linux/fs.hextern void put_super(dev_t dev);
dev161include/linux/iso_fs.hextern int isofs_new_block(int dev);
dev162include/linux/iso_fs.hextern int isofs_free_block(int dev, int block);
dev188include/linux/iso_fs.hdev_t dev;  /* And this matches */
dev204include/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)))
dev108include/linux/xd.hextern void resetup_one_dev (struct gendisk *dev,unsigned int drive);
dev119include/linux/xd.hstatic int xd_reread_partitions (int dev);
dev25kernel/blk_drv/blk.hint dev;    /* -1 if no request */
dev45kernel/blk_drv/blk.h((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \
dev74kernel/blk_drv/blk.hextern int is_read_only(int dev);
dev75kernel/blk_drv/blk.hextern void set_device_ro(int dev,int flag);
dev83kernel/blk_drv/blk.h#define RO_IOCTLS(dev,where) \
dev85kernel/blk_drv/blk.hset_device_ro((dev),get_fs_long((long *) (where))); return 0; \
dev87kernel/blk_drv/blk.hif (!__err) put_fs_long(is_read_only(dev),(long *) (where)); return __err; }
dev172kernel/blk_drv/blk.h#define CURRENT_DEV DEVICE_NR(CURRENT->dev)
dev219kernel/blk_drv/blk.hprintk("dev %04x, sector %d\n",req->dev,req->sector);
dev241kernel/blk_drv/blk.hDEVICE_OFF(req->dev);
dev249kernel/blk_drv/blk.hreq->dev = -1;
dev265kernel/blk_drv/blk.hif (MAJOR(CURRENT->dev) != MAJOR_NR) \
dev228kernel/blk_drv/floppy.c(CURRENT->dev))
dev600kernel/blk_drv/floppy.cint drive = MINOR(CURRENT->dev);
dev928kernel/blk_drv/floppy.cif (CURRENT && CURRENT->dev < 0) return;
dev942kernel/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;
dev273kernel/blk_drv/hd.cint dev;
dev277kernel/blk_drv/hd.cdev = MINOR(CURRENT->dev) >> 6;
dev280kernel/blk_drv/hd.crecalibrate[dev] = 1;
dev284kernel/blk_drv/hd.crecalibrate[dev] = 1;
dev334kernel/blk_drv/hd.cMINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> 
dev435kernel/blk_drv/hd.cunsigned int block,dev;
dev439kernel/blk_drv/hd.cif (CURRENT && CURRENT->dev < 0) return;
dev447kernel/blk_drv/hd.cdev = MINOR(CURRENT->dev);
dev450kernel/blk_drv/hd.cif (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) {
dev453kernel/blk_drv/hd.cblock, hd[dev].nr_sects);
dev458kernel/blk_drv/hd.cblock += hd[dev].start_sect;
dev459kernel/blk_drv/hd.cdev >>= 6;
dev460kernel/blk_drv/hd.csec = block % hd_info[dev].sect + 1;
dev461kernel/blk_drv/hd.ctrack = block / hd_info[dev].sect;
dev462kernel/blk_drv/hd.chead = track % hd_info[dev].head;
dev463kernel/blk_drv/hd.ccyl = track / hd_info[dev].head;
dev466kernel/blk_drv/hd.cdev, cyl, head, sec, CURRENT->buffer);
dev478kernel/blk_drv/hd.cif (recalibrate[dev]) {
dev479kernel/blk_drv/hd.crecalibrate[dev] = 0;
dev480kernel/blk_drv/hd.chd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr);
dev487kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr);
dev500kernel/blk_drv/hd.chd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr);
dev513kernel/blk_drv/hd.cint dev, err;
dev517kernel/blk_drv/hd.cdev = MINOR(inode->i_rdev) >> 6;
dev518kernel/blk_drv/hd.cif (dev >= NR_HD)
dev526kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].head,
dev528kernel/blk_drv/hd.cput_fs_byte(hd_info[dev].sect,
dev530kernel/blk_drv/hd.cput_fs_word(hd_info[dev].cyl,
dev736kernel/blk_drv/hd.cstatic int revalidate_hddisk(int dev, int maxusage)
dev744kernel/blk_drv/hd.ctarget =  DEVICE_NR(MINOR(dev));
dev66kernel/blk_drv/ll_rw_blk.cint is_read_only(int dev)
dev70kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev71kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev76kernel/blk_drv/ll_rw_blk.cvoid set_device_ro(int dev,int flag)
dev80kernel/blk_drv/ll_rw_blk.cmajor = MAJOR(dev);
dev81kernel/blk_drv/ll_rw_blk.cminor = MINOR(dev);
dev92kernel/blk_drv/ll_rw_blk.cstatic void add_request(struct blk_dev_struct * dev, struct request * req)
dev100kernel/blk_drv/ll_rw_blk.cif (!(tmp = dev->current_request)) {
dev101kernel/blk_drv/ll_rw_blk.cdev->current_request = req;
dev102kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev116kernel/blk_drv/ll_rw_blk.cif(MAJOR(req->dev) == 8 || 
dev117kernel/blk_drv/ll_rw_blk.cMAJOR(req->dev) == 9 ||
dev118kernel/blk_drv/ll_rw_blk.cMAJOR(req->dev) == 11)
dev119kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev166kernel/blk_drv/ll_rw_blk.cif (req->dev == bh->b_dev &&
dev191kernel/blk_drv/ll_rw_blk.cif (req->dev < 0)
dev205kernel/blk_drv/ll_rw_blk.creq->dev = bh->b_dev;
dev220kernel/blk_drv/ll_rw_blk.cvoid ll_rw_page(int rw, int dev, int page, char * buffer)
dev223kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev226kernel/blk_drv/ll_rw_blk.cprintk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8);
dev231kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev232kernel/blk_drv/ll_rw_blk.cprintk("Can't page to read-only device 0x%X\n",dev);
dev239kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev247kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev272kernel/blk_drv/ll_rw_blk.cstruct blk_dev_struct * dev;
dev313kernel/blk_drv/ll_rw_blk.cplug.dev = -1;
dev323kernel/blk_drv/ll_rw_blk.cdev = major+blk_dev;
dev324kernel/blk_drv/ll_rw_blk.c(dev->request_fn)();
dev329kernel/blk_drv/ll_rw_blk.cvoid ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf)
dev333kernel/blk_drv/ll_rw_blk.cunsigned int major = MAJOR(dev);
dev344kernel/blk_drv/ll_rw_blk.cif (rw == WRITE && is_read_only(dev)) {
dev345kernel/blk_drv/ll_rw_blk.cprintk("Can't swap to read-only device 0x%X\n",dev);
dev354kernel/blk_drv/ll_rw_blk.cif (req->dev<0)
dev361kernel/blk_drv/ll_rw_blk.creq->dev = dev;
dev382kernel/blk_drv/ll_rw_blk.crequest[i].dev = -1;
dev32kernel/blk_drv/ramdisk.cif ((MINOR(CURRENT->dev) != 1) || (addr+len > rd_start+rd_length)) {
dev775kernel/blk_drv/scsi/aha1542.cint aha1542_biosparam(int size, int dev, int* info){
dev481kernel/blk_drv/scsi/aha1740.cint aha1740_biosparam(int size, int dev, int* info)
dev1289kernel/blk_drv/scsi/fdomain.cint fdomain_16x0_biosparam( int size, int dev, int *info )
dev1322kernel/blk_drv/scsi/fdomain.cdrive = MINOR(dev) / 16;
dev148kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xfffe;
dev160kernel/blk_drv/scsi/scsi.cint host_nr , dev, lun, type;
dev175kernel/blk_drv/scsi/scsi.cfor (dev = 0; dev < 8; ++dev)
dev176kernel/blk_drv/scsi/scsi.cif (scsi_hosts[host_nr].this_id != dev)
dev180kernel/blk_drv/scsi/scsi.cscsi_devices[NR_SCSI_DEVICES].id = dev;
dev191kernel/blk_drv/scsi/scsi.cSCmd.target = dev;
dev194kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev204kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev230kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev237kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev288kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev293kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev299kernel/blk_drv/scsi/scsi.chost_nr , dev, lun); 
dev327kernel/blk_drv/scsi/scsi.cSCmd.request.dev = 0xffff; /* Mark not busy */
dev334kernel/blk_drv/scsi/scsi.cwhile (SCmd.request.dev != 0xfffe);
dev424kernel/blk_drv/scsi/scsi.cif (req && req->dev <= 0)
dev432kernel/blk_drv/scsi/scsi.cif(SCpnt->request.dev < 0) break;
dev443kernel/blk_drv/scsi/scsi.creq->dev = -1;
dev445kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy, but no request */
dev466kernel/blk_drv/scsi/scsi.cint host, dev = -1;
dev477kernel/blk_drv/scsi/scsi.cif (req && (dev = req->dev) <= 0) return NULL;
dev487kernel/blk_drv/scsi/scsi.cif(SCpnt->request.dev < 0) break;
dev493kernel/blk_drv/scsi/scsi.cif (req && ((req->dev < 0) || (req->dev != dev))) {
dev497kernel/blk_drv/scsi/scsi.cif (!SCpnt || SCpnt->request.dev >= 0)  /* Might have changed */
dev507kernel/blk_drv/scsi/scsi.c(SCwait->request.dev > 0));
dev511kernel/blk_drv/scsi/scsi.creq->dev = -1;
dev514kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = 0xffff; /* Busy */
dev1135kernel/blk_drv/scsi/scsi.cif ((SCpnt1->request.dev > 0) &&
dev1395kernel/blk_drv/scsi/scsi.cSCpnt->request.dev = -1; /* Mark not busy */
dev457kernel/blk_drv/scsi/scsi.hprintk("dev %04x, sector %d\n",req->dev,req->sector);
dev482kernel/blk_drv/scsi/scsi.hDEVICE_OFF(req->dev);
dev489kernel/blk_drv/scsi/scsi.hreq->dev = -1;
dev505kernel/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);
dev225kernel/blk_drv/scsi/scsi_ioctl.cint scsi_ioctl (Scsi_Device *dev, int cmd, void *arg)
dev229kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd != 0 && dev->index > NR_SCSI_DEVICES))
dev231kernel/blk_drv/scsi/scsi_ioctl.cif ((cmd == 0 && dev->host_no > max_scsi_hosts))
dev237kernel/blk_drv/scsi/scsi_ioctl.cput_fs_long(dev->id + (dev->lun << 8) + 
dev238kernel/blk_drv/scsi/scsi_ioctl.c(dev->host_no << 16), (long *) arg);
dev241kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_probe(dev->host_no, arg);
dev243kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_command((Scsi_Device *) dev, arg);
dev245kernel/blk_drv/scsi/scsi_ioctl.cif (!dev->removable || !dev->lockable) return 0;
dev247kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev250kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev253kernel/blk_drv/scsi/scsi_ioctl.cif (!dev->removable || !dev->lockable) return 0;
dev255kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev258kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev261kernel/blk_drv/scsi/scsi_ioctl.cscsi_cmd[1] = dev->lun << 5;
dev264kernel/blk_drv/scsi/scsi_ioctl.creturn ioctl_internal_command((Scsi_Device *) dev, scsi_cmd);
dev144kernel/blk_drv/scsi/sd.cprintk("sd%d : rw_intr(%d, %x)\n", MINOR(SCpnt->request.dev), SCpnt->host, result);
dev156kernel/blk_drv/scsi/sd.cprintk("sd%d : %d sectors remain.\n", MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors);
dev199kernel/blk_drv/scsi/sd.cMINOR(SCpnt->request.dev));
dev257kernel/blk_drv/scsi/sd.cif rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap
dev271kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
dev287kernel/blk_drv/scsi/sd.cif (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) {
dev288kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0;
dev297kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host_no,
dev298kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
dev299kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
dev326kernel/blk_drv/scsi/sd.cif (CURRENT != NULL && CURRENT->dev == -1) {
dev346kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
dev364kernel/blk_drv/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(req->dev))].device->index);
dev389kernel/blk_drv/scsi/sd.cint dev, block, this_count;
dev395kernel/blk_drv/scsi/sd.cif(SCpnt->request.dev <= 0)
dev398kernel/blk_drv/scsi/sd.cdev =  MINOR(SCpnt->request.dev);
dev403kernel/blk_drv/scsi/sd.cprintk("Doing sd request, dev = %d, block = %d\n", dev, block);
dev406kernel/blk_drv/scsi/sd.cif (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects)
dev412kernel/blk_drv/scsi/sd.cblock += sd[dev].start_sect;
dev413kernel/blk_drv/scsi/sd.cdev = DEVICE_NR(dev);
dev415kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].device->changed)
dev426kernel/blk_drv/scsi/sd.cprintk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block);
dev432kernel/blk_drv/scsi/sd.cif (!rscsi_disks[dev].device->writeable)
dev485kernel/blk_drv/scsi/sd.cthis_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff);
dev563kernel/blk_drv/scsi/sd.cprintk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(SCpnt->request.dev),
dev570kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].sector_size == 1024){
dev577kernel/blk_drv/scsi/sd.cif (rscsi_disks[dev].sector_size == 256){
dev582kernel/blk_drv/scsi/sd.cif (((this_count > 0xff) ||  (block > 0x1fffff)) && rscsi_disks[dev].ten)
dev614kernel/blk_drv/scsi/sd.cSCpnt->transfersize = rscsi_disks[dev].sector_size;
dev618kernel/blk_drv/scsi/sd.cthis_count * rscsi_disks[dev].sector_size,
dev660kernel/blk_drv/scsi/sd.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev689kernel/blk_drv/scsi/sd.cSCpnt->request.dev = 0xffff;  /* Mark as really busy again */
dev699kernel/blk_drv/scsi/sd.cwhile(SCpnt->request.dev != 0xfffe);
dev701kernel/blk_drv/scsi/sd.cif (SCpnt->request.dev != 0xfffe){
dev704kernel/blk_drv/scsi/sd.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev712kernel/blk_drv/scsi/sd.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev866kernel/blk_drv/scsi/sd.cint revalidate_scsidisk(int dev, int maxusage){
dev873kernel/blk_drv/scsi/sd.ctarget =  DEVICE_NR(MINOR(dev));
dev14kernel/blk_drv/scsi/sd_ioctl.cextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
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,
dev56kernel/blk_drv/scsi/sd_ioctl.creturn revalidate_scsidisk(dev, 1);
dev58kernel/blk_drv/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
dev1398kernel/blk_drv/scsi/seagate.cextern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg);
dev1400kernel/blk_drv/scsi/seagate.cint seagate_st0x_biosparam(int size, int dev, int* info) {
dev1408kernel/blk_drv/scsi/seagate.cdisk = rscsi_disks[MINOR(dev) >> 4].device;
dev207kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
dev216kernel/blk_drv/scsi/sr.cif (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) {
dev217kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0;
dev241kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host_no, 
dev242kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
dev243kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
dev283kernel/blk_drv/scsi/sr.cif (CURRENT != NULL && CURRENT->dev == -1) {
dev292kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); 
dev311kernel/blk_drv/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(req->dev))].device->index);
dev337kernel/blk_drv/scsi/sr.cunsigned int dev, block, realcount;
dev344kernel/blk_drv/scsi/sr.cif(SCpnt->request.dev <= 0)
dev347kernel/blk_drv/scsi/sr.cdev =  MINOR(SCpnt->request.dev);
dev352kernel/blk_drv/scsi/sr.cif (dev >= NR_SR)
dev360kernel/blk_drv/scsi/sr.cif (!scsi_CDs[dev].use)
dev368kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].device->changed)
dev422kernel/blk_drv/scsi/sr.cthis_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4;
dev550kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].sector_size == 2048)
dev557kernel/blk_drv/scsi/sr.cif (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2;
dev559kernel/blk_drv/scsi/sr.cif (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) 
dev564kernel/blk_drv/scsi/sr.cthis_count = realcount * (scsi_CDs[dev].sector_size >> 9);
dev581kernel/blk_drv/scsi/sr.cthis_count = realcount * (scsi_CDs[dev].sector_size >> 9);
dev597kernel/blk_drv/scsi/sr.crealcount * scsi_CDs[dev].sector_size, 
dev618kernel/blk_drv/scsi/sr.creq->dev = 0xfffe; /* Busy, but indicate request done */
dev655kernel/blk_drv/scsi/sr.cSCpnt->request.dev = 0xffff;  /* Mark as really busy */
dev663kernel/blk_drv/scsi/sr.cwhile(SCpnt->request.dev != 0xfffe);
dev665kernel/blk_drv/scsi/sr.cif (SCpnt->request.dev != 0xfffe){
dev668kernel/blk_drv/scsi/sr.cwhile (SCpnt->request.dev != 0xfffe) schedule();
dev676kernel/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);
dev96kernel/blk_drv/scsi/st.cif ((st_nbr = SCpnt->request.dev) < NR_ST && st_nbr >= 0) {
dev104kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev106kernel/blk_drv/scsi/st.cSCpnt->request.dev = 0xffff;
dev120kernel/blk_drv/scsi/st.cstatic void decode_sns(int dev, char *sense_buffer)
dev133kernel/blk_drv/scsi/st.cprintk( "st%d: sense key %s\n", dev, snstext[sense_buffer[2] & 0x0f]);
dev136kernel/blk_drv/scsi/st.cprintk("st%d: old sense key %s\n", dev, snstext[sense_buffer[0] & 0x0f]);
dev138kernel/blk_drv/scsi/st.cprintk("st%d: sns = %2x %2x\n", dev, sense_buffer[0], sense_buffer[2]);
dev147kernel/blk_drv/scsi/st.cstatic int st_chk_result(int dev, int result, char *sense)
dev152kernel/blk_drv/scsi/st.cprintk("st%d: Error: %x\n", dev, result);
dev153kernel/blk_drv/scsi/st.cdecode_sns(dev, sense);
dev164kernel/blk_drv/scsi/st.cstatic void write_behind_check(int dev)
dev167kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result < 0) {
dev168kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing);
dev169kernel/blk_drv/scsi/st.csleep_on( &scsi_tapes[dev].waiting );
dev170kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing);
dev174kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing < scsi_tapes[dev].buffer->buffer_bytes)
dev175kernel/blk_drv/scsi/st.cmemcpy(scsi_tapes[dev].buffer->b_data,
dev176kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data + scsi_tapes[dev].buffer->writing,
dev177kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -
dev178kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing);
dev179kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -= scsi_tapes[dev].buffer->writing;
dev180kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = 0;
dev188kernel/blk_drv/scsi/st.cstatic int flush_write_buffer(int dev)
dev196kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing) {
dev197kernel/blk_drv/scsi/st.cwrite_behind_check(dev);
dev198kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result) {
dev200kernel/blk_drv/scsi/st.cprintk("st%d: Async write error %x.\n", dev,
dev201kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->last_result);
dev209kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].dirty==1) {
dev210kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev212kernel/blk_drv/scsi/st.coffset = scsi_tapes[dev].buffer->buffer_bytes;
dev213kernel/blk_drv/scsi/st.ctransfer = ((offset + scsi_tapes[dev].block_size - 1) /
dev214kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size) * scsi_tapes[dev].block_size;
dev216kernel/blk_drv/scsi/st.cprintk("st%d: Flushing %d bytes.\n", dev, transfer);
dev218kernel/blk_drv/scsi/st.cmemset(scsi_tapes[dev].buffer->b_data + offset, 0, transfer - offset);
dev224kernel/blk_drv/scsi/st.cblks = transfer / scsi_tapes[dev].block_size;
dev228kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev230kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data, transfer,
dev233kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev236kernel/blk_drv/scsi/st.cprintk("st%d: Error on flush:\n", dev);
dev238kernel/blk_drv/scsi/st.cst_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev243kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev244kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev246kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev257kernel/blk_drv/scsi/st.cint dev;
dev260kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
dev262kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 2)  /* Writing */
dev263kernel/blk_drv/scsi/st.creturn flush_write_buffer(dev);
dev265kernel/blk_drv/scsi/st.cbackspace = (scsi_tapes[dev].buffer->buffer_bytes +
dev266kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer) / scsi_tapes[dev].block_size -
dev267kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->read_pointer + scsi_tapes[dev].block_size - 1) /
dev268kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev269kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev270kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev275kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev276kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev287kernel/blk_drv/scsi/st.cint dev;
dev293kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
dev294kernel/blk_drv/scsi/st.cif (dev >= NR_ST)
dev296kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].in_use) {
dev297kernel/blk_drv/scsi/st.cprintk("st%d: Device already in use.\n", dev);
dev306kernel/blk_drv/scsi/st.cprintk("st%d: No free buffers.\n", dev);
dev311kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer = st_buffers[i];
dev312kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 1;
dev315kernel/blk_drv/scsi/st.cscsi_tapes[dev].write_prot = ((flags & O_ACCMODE) == O_RDONLY);
dev317kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev318kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 0;
dev319kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev320kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev322kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev324kernel/blk_drv/scsi/st.cprintk("st%d: Tape request not allocated", dev);
dev331kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev333kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev336kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev341kernel/blk_drv/scsi/st.cdecode_sns(dev, SCpnt->sense_buffer);
dev346kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev348kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev351kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev356kernel/blk_drv/scsi/st.cdecode_sns(dev, SCpnt->sense_buffer);
dev360kernel/blk_drv/scsi/st.cprintk("st%d: No tape.\n", dev);
dev362kernel/blk_drv/scsi/st.cprintk("st%d: Error %x.\n", dev, SCpnt->result);
dev363kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev364kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev365kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev372kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev374kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev377kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev380kernel/blk_drv/scsi/st.cscsi_tapes[dev].max_block = (scsi_tapes[dev].buffer->b_data[1] << 16) |
dev381kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->b_data[2] << 8) | scsi_tapes[dev].buffer->b_data[3];
dev382kernel/blk_drv/scsi/st.cscsi_tapes[dev].min_block = (scsi_tapes[dev].buffer->b_data[4] << 8) |
dev383kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[5];
dev385kernel/blk_drv/scsi/st.cprintk("st%d: Block limits %d - %d bytes.\n", dev, scsi_tapes[dev].min_block,
dev386kernel/blk_drv/scsi/st.cscsi_tapes[dev].max_block);
dev390kernel/blk_drv/scsi/st.cscsi_tapes[dev].min_block = scsi_tapes[dev].max_block = (-1);
dev392kernel/blk_drv/scsi/st.cprintk("st%d: Can't read block limits.\n", dev);
dev400kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev402kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev405kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev407kernel/blk_drv/scsi/st.ci = st_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev410kernel/blk_drv/scsi/st.cprintk("st%d: No Mode Sense.\n", dev);
dev412kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2] =
dev413kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[3] = 0;
dev415kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev418kernel/blk_drv/scsi/st.cprintk("st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", dev,
dev419kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[0], scsi_tapes[dev].buffer->b_data[1],
dev420kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2], scsi_tapes[dev].buffer->b_data[3]);
dev423kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->b_data[3] >= 8) {
dev424kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = scsi_tapes[dev].buffer->b_data[9] * 65536 +
dev425kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] * 256 + scsi_tapes[dev].buffer->b_data[11];
dev427kernel/blk_drv/scsi/st.cprintk("st%d: Density %x, tape length: %x, blocksize: %d\n", dev,
dev428kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4], scsi_tapes[dev].buffer->b_data[5] *
dev429kernel/blk_drv/scsi/st.c65536 + scsi_tapes[dev].buffer->b_data[6] * 256 +
dev430kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[7], scsi_tapes[dev].buffer->b_data[9] *
dev431kernel/blk_drv/scsi/st.c65536 + scsi_tapes[dev].buffer->b_data[10] * 256 +
dev432kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11]);
dev434kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size > ST_BUFFER_SIZE) {
dev435kernel/blk_drv/scsi/st.cprintk("st%d: Blocksize %d too large for buffer.\n", dev,
dev436kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size);
dev437kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev438kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev442kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].block_size == 0) {
dev443kernel/blk_drv/scsi/st.cprintk("st%d: Fixing block size to 512 bytes.\n", dev);
dev445kernel/blk_drv/scsi/st.cprintk("st%d: Can't set fixed block size.\n", dev);
dev446kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev447kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev450kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = ST_BLOCK_SIZE;
dev454kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = ST_BLOCK_SIZE;
dev456kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks =
dev457kernel/blk_drv/scsi/st.cST_BUFFER_SIZE / scsi_tapes[dev].block_size;
dev458kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size =
dev459kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size;
dev460kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = scsi_tapes[dev].buffer->read_pointer = 0;
dev463kernel/blk_drv/scsi/st.cprintk("st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev,
dev464kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size, scsi_tapes[dev].buffer->buffer_size,
dev465kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks);
dev468kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->b_data[2] & 0x80) {
dev469kernel/blk_drv/scsi/st.cscsi_tapes[dev].write_prot = 1;
dev471kernel/blk_drv/scsi/st.cprintk( "st%d: Write protected\n", dev);
dev482kernel/blk_drv/scsi/st.cint dev;
dev488kernel/blk_drv/scsi/st.cdev = inode->i_rdev;
dev489kernel/blk_drv/scsi/st.crewind = (dev & 0x80) == 0;
dev490kernel/blk_drv/scsi/st.cdev = dev & 127;
dev492kernel/blk_drv/scsi/st.cif ( scsi_tapes[dev].rw == 2) {
dev494kernel/blk_drv/scsi/st.cresult = flush_write_buffer(dev);
dev497kernel/blk_drv/scsi/st.cprintk("st%d: File length %d bytes.\n", dev, filp->f_pos);
dev501kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev507kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev509kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data,
dev512kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev515kernel/blk_drv/scsi/st.cprintk("st%d: Error on write filemark:\n", dev);
dev517kernel/blk_drv/scsi/st.cst_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev520kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev524kernel/blk_drv/scsi/st.cprintk("st%d: Buffer flushed, EOF written\n", dev);
dev528kernel/blk_drv/scsi/st.cif ((scsi_tapes[dev].eof == 1) && !scsi_tapes[dev].eof_hit)
dev538kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->in_use = 0;
dev539kernel/blk_drv/scsi/st.cscsi_tapes[dev].in_use = 0;
dev548kernel/blk_drv/scsi/st.cint dev;
dev554kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
dev556kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev557kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev562kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev565kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 1) {
dev569kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 2;
dev573kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->writing) {
dev574kernel/blk_drv/scsi/st.cwrite_behind_check(dev);
dev575kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->last_result) {
dev577kernel/blk_drv/scsi/st.cprintk("st%d: Async write error %x.\n", dev,
dev578kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->last_result);
dev589kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev597kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 2;
dev600kernel/blk_drv/scsi/st.cwhile((scsi_tapes[dev].buffer->buffer_bytes + count) >=
dev601kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size) {
dev602kernel/blk_drv/scsi/st.cdo_count = scsi_tapes[dev].buffer->buffer_size -
dev603kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes;
dev604kernel/blk_drv/scsi/st.cmemcpy_fromfs(scsi_tapes[dev].buffer->b_data +
dev605kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes,b_point,do_count);
dev607kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->buffer_blocks;
dev612kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev614kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev615kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size,
dev618kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev622kernel/blk_drv/scsi/st.cprintk("st%d: Error on write:\n", dev);
dev623kernel/blk_drv/scsi/st.cst_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev630kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev639kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes = 0;
dev640kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev643kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 1;
dev644kernel/blk_drv/scsi/st.cmemcpy_fromfs(scsi_tapes[dev].buffer->b_data +
dev645kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes,b_point,count);
dev647kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes += count;
dev651kernel/blk_drv/scsi/st.cdo_count = st_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev653kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev658kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes >= ST_WRITE_THRESHOLD) {
dev660kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing = (scsi_tapes[dev].buffer->buffer_bytes /
dev661kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size) * scsi_tapes[dev].block_size;
dev662kernel/blk_drv/scsi/st.cscsi_tapes[dev].dirty = 0;
dev664kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->writing / scsi_tapes[dev].block_size;
dev668kernel/blk_drv/scsi/st.cSCpnt->result = scsi_tapes[dev].buffer->last_result = -1;
dev670kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev672kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev673kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->writing,
dev678kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev687kernel/blk_drv/scsi/st.cint dev;
dev693kernel/blk_drv/scsi/st.cdev = inode->i_rdev & 127;
dev695kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev696kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev701kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].rw == 2) {
dev705kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 1;
dev709kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].eof)
dev710kernel/blk_drv/scsi/st.cprintk("st%d: EOF flag up. Bytes %d\n", dev,
dev711kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes);
dev713kernel/blk_drv/scsi/st.cif ((scsi_tapes[dev].buffer->buffer_bytes == 0) &&
dev714kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof == 2)  /* EOM or Blank Check */
dev717kernel/blk_drv/scsi/st.cscsi_tapes[dev].rw = 1;
dev719kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev723kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes == 0 &&
dev724kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof == 0) {
dev729kernel/blk_drv/scsi/st.cblks = scsi_tapes[dev].buffer->buffer_blocks;
dev735kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev737kernel/blk_drv/scsi/st.c(void *) cmd, scsi_tapes[dev].buffer->b_data,
dev738kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size,
dev741kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev743kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev744kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev748kernel/blk_drv/scsi/st.cprintk("st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", dev,
dev762kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect block size.\n", dev);
dev763kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev767kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 2; /* What should be done at EOM ? */
dev768kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev769kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_blocks - transfer) *
dev770kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev772kernel/blk_drv/scsi/st.cprintk("st%d: EOM detected (%d blocks read).\n", dev,
dev773kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks - transfer);
dev777kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 1;
dev778kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev779kernel/blk_drv/scsi/st.c(scsi_tapes[dev].buffer->buffer_blocks - transfer) *
dev780kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size;
dev783kernel/blk_drv/scsi/st.cdev, scsi_tapes[dev].buffer->buffer_blocks - transfer, total);
dev789kernel/blk_drv/scsi/st.cprintk("st%d: Tape error. Sense key %x\n", dev,
dev791kernel/blk_drv/scsi/st.cdecode_sns(dev, SCpnt->sense_buffer);
dev793kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;
dev801kernel/blk_drv/scsi/st.ctransfer = st_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev802kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev807kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev808kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size;
dev812kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].buffer->buffer_bytes > 0) {
dev814kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].eof)
dev815kernel/blk_drv/scsi/st.cprintk("st%d: EOF up. Left %d, needed %d.\n", dev,
dev816kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes, count - total);
dev818kernel/blk_drv/scsi/st.ctransfer = scsi_tapes[dev].buffer->buffer_bytes < count - total ?
dev819kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes : count - total;
dev820kernel/blk_drv/scsi/st.cmemcpy_tofs(buf, scsi_tapes[dev].buffer->b_data +
dev821kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer,transfer);
dev825kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes -= transfer;
dev826kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer += transfer;
dev828kernel/blk_drv/scsi/st.celse if (scsi_tapes[dev].eof) {
dev829kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 1;
dev830kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev831kernel/blk_drv/scsi/st.cif (total == 0 && scsi_tapes[dev].eof == 1)
dev832kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev833kernel/blk_drv/scsi/st.cif (total == 0 && scsi_tapes[dev].eof == 2)
dev840kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev850kernel/blk_drv/scsi/st.cint dev = inode->i_rdev;
dev857kernel/blk_drv/scsi/st.cdev = dev & 127;
dev869kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape forward %d files.\n", dev,
dev885kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape backward %d files.\n", dev, (-ltmp));
dev895kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape forward %d blocks.\n", dev,
dev910kernel/blk_drv/scsi/st.cprintk("st%d: Spacing tape backward %d blocks.\n", dev, (-ltmp));
dev914kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev922kernel/blk_drv/scsi/st.cprintk("st%d: Writing %d filemarks.\n", dev,
dev933kernel/blk_drv/scsi/st.cprintk("st%d: Rewinding tape.\n", dev);
dev943kernel/blk_drv/scsi/st.cprintk("st%d: Unloading tape.\n", dev);
dev948kernel/blk_drv/scsi/st.cprintk("st%d: No op on tape.\n", dev);
dev960kernel/blk_drv/scsi/st.cprintk("st%d: Retensioning tape.\n", dev);
dev967kernel/blk_drv/scsi/st.cprintk("st%d: Spacing to end of recorded medium.\n", dev);
dev971kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].write_prot)
dev976kernel/blk_drv/scsi/st.cprintk("st%d: Erasing tape.\n", dev);
dev980kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2) {
dev1000kernel/blk_drv/scsi/st.cprintk("st%d: Seeking tape to block %d.\n", dev, arg);
dev1005kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].dirty || scsi_tapes[dev].buffer->buffer_bytes != 0)
dev1008kernel/blk_drv/scsi/st.c(arg < scsi_tapes[dev].min_block || arg > scsi_tapes[dev].max_block ||
dev1010kernel/blk_drv/scsi/st.cprintk("st%d: Illegal block size.\n", dev);
dev1016kernel/blk_drv/scsi/st.cmemset(scsi_tapes[dev].buffer->b_data, 0, 12);
dev1017kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[2] = 0x10;  /* buffered mode */
dev1018kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[3] = 8;     /* block descriptor length */
dev1022kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4] = arg;
dev1023kernel/blk_drv/scsi/st.cltmp = scsi_tapes[dev].block_size;
dev1025kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[9] = (ltmp >> 16);
dev1026kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] = (ltmp >> 8);
dev1027kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11] = ltmp;
dev1031kernel/blk_drv/scsi/st.cprintk("st%d: Setting block size to %d bytes.\n", dev,
dev1032kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[9] * 65536 +
dev1033kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[10] * 256 +
dev1034kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[11]);
dev1036kernel/blk_drv/scsi/st.cprintk("st%d: Setting density code to %x.\n", dev,
dev1037kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->b_data[4]);
dev1041kernel/blk_drv/scsi/st.cprintk("st%d: Unknown st_ioctl command %x.\n", dev, cmd_in);
dev1045kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev1047kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev1049kernel/blk_drv/scsi/st.c(void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, ST_BLOCK_SIZE,
dev1052kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev1054kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev1056kernel/blk_drv/scsi/st.cioctl_result = st_chk_result(dev, SCpnt->result, SCpnt->sense_buffer);
dev1064kernel/blk_drv/scsi/st.cscsi_tapes[dev].block_size = arg;
dev1065kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks =
dev1066kernel/blk_drv/scsi/st.cST_BUFFER_SIZE / scsi_tapes[dev].block_size;
dev1067kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_size =
dev1068kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size;
dev1069kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->buffer_bytes =
dev1070kernel/blk_drv/scsi/st.cscsi_tapes[dev].buffer->read_pointer = 0;
dev1073kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 2;
dev1074kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev1077kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof = 0;
dev1078kernel/blk_drv/scsi/st.cscsi_tapes[dev].eof_hit = 0;
dev1091kernel/blk_drv/scsi/st.cint dev = inode->i_rdev;
dev1098kernel/blk_drv/scsi/st.cdev = dev & 127;
dev1100kernel/blk_drv/scsi/st.cif (!scsi_tapes[dev].in_use) {
dev1101kernel/blk_drv/scsi/st.cprintk("st%d: Incorrect device.\n", dev);
dev1134kernel/blk_drv/scsi/st.cmemcpy_tofs((char *)arg, (char *)scsi_tapes[dev].buffer->mt_status,
dev1140kernel/blk_drv/scsi/st.cprintk("st%d: get tape position.\n", dev);
dev1153kernel/blk_drv/scsi/st.cSCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1);
dev1157kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2) {
dev1165kernel/blk_drv/scsi/st.cSCpnt->request.dev = dev;
dev1168kernel/blk_drv/scsi/st.c(void *) scmd, (void *) scsi_tapes[dev].buffer->b_data,
dev1171kernel/blk_drv/scsi/st.cif (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting );
dev1176kernel/blk_drv/scsi/st.cprintk("st%d: Can't read tape position.\n", dev);
dev1182kernel/blk_drv/scsi/st.cif (scsi_tapes[dev].device->scsi_level < SCSI_2)
dev1183kernel/blk_drv/scsi/st.cmt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[0] << 16) 
dev1184kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[1] << 8) 
dev1185kernel/blk_drv/scsi/st.c+ scsi_tapes[dev].buffer->b_data[2];
dev1187kernel/blk_drv/scsi/st.cmt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[4] << 24)
dev1188kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[5] << 16) 
dev1189kernel/blk_drv/scsi/st.c+ (scsi_tapes[dev].buffer->b_data[6] << 8) 
dev1190kernel/blk_drv/scsi/st.c+ scsi_tapes[dev].buffer->b_data[7];
dev1194kernel/blk_drv/scsi/st.cSCpnt->request.dev = -1;  /* Mark as not busy */
dev1200kernel/blk_drv/scsi/st.creturn scsi_ioctl(scsi_tapes[dev].device, cmd_in, (void *) arg);
dev494kernel/blk_drv/scsi/ultrastor.cint ultrastor_biosparam(int size, int dev, int *info)
dev600kernel/blk_drv/scsi/wd7000.cint wd7000_biosparam(int size, int dev, int* info)
dev152kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
dev154kernel/blk_drv/xd.cif (dev < xd_drives) {
dev155kernel/blk_drv/xd.cwhile (!xd_valid[dev])
dev158kernel/blk_drv/xd.cxd_access[dev]++;
dev176kernel/blk_drv/xd.cif (CURRENT_DEV < xd_drives && CURRENT->sector + CURRENT->nr_sectors <= xd[MINOR(CURRENT->dev)].nr_sects) {
dev177kernel/blk_drv/xd.cblock = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect;
dev196kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev)),err;
dev198kernel/blk_drv/xd.cif (inode && (dev < xd_drives))
dev203kernel/blk_drv/xd.cput_fs_byte(xd_info[dev].heads,(char *) &geometry->heads);
dev204kernel/blk_drv/xd.cput_fs_byte(xd_info[dev].sectors,(char *) &geometry->sectors);
dev205kernel/blk_drv/xd.cput_fs_word(xd_info[dev].cylinders,(short *) &geometry->cylinders);
dev228kernel/blk_drv/xd.cint dev = DEVICE_NR(MINOR(inode->i_rdev));
dev230kernel/blk_drv/xd.cif (dev < xd_drives) {
dev231kernel/blk_drv/xd.csync_dev(dev);
dev232kernel/blk_drv/xd.cxd_access[dev]--;
dev239kernel/blk_drv/xd.cstatic int xd_reread_partitions(int dev)
dev241kernel/blk_drv/xd.cint target = DEVICE_NR(MINOR(dev)),start = target << xd_gendisk.minor_shift,partition;
dev235kernel/chr_drv/tty_io.cint dev;
dev239kernel/chr_drv/tty_io.cdev = 0x0400 + tty->line;
dev244kernel/chr_drv/tty_io.cif (filp->f_rdev != dev)
dev922kernel/chr_drv/tty_io.cint i, dev;
dev925kernel/chr_drv/tty_io.cdev = file->f_rdev;
dev926kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev927kernel/chr_drv/tty_io.cprintk("tty_read: bad pseudo-major nr #%d\n", MAJOR(dev));
dev930kernel/chr_drv/tty_io.cdev = MINOR(dev);
dev931kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev936kernel/chr_drv/tty_io.c(current->tty == dev) &&
dev955kernel/chr_drv/tty_io.cint dev, i, is_console;
dev958kernel/chr_drv/tty_io.cdev = file->f_rdev;
dev960kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev964kernel/chr_drv/tty_io.cdev = MINOR(dev);
dev968kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev972kernel/chr_drv/tty_io.c(current->tty == dev) && (tty->pgrp != current->pgrp)) {
dev994kernel/chr_drv/tty_io.cstatic int init_dev(int dev)
dev1001kernel/chr_drv/tty_io.co_dev = PTY_OTHER(dev);
dev1006kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev) && tty_table[dev] && tty_table[dev]->count)
dev1009kernel/chr_drv/tty_io.cif (!tty_table[dev] && !tty) {
dev1013kernel/chr_drv/tty_io.cinitialize_tty_struct(dev, tty);
dev1016kernel/chr_drv/tty_io.cif (!tty_termios[dev] && !tp) {
dev1020kernel/chr_drv/tty_io.cinitialize_termios(dev, tp);
dev1023kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1040kernel/chr_drv/tty_io.cif (!tty_termios[dev]) {
dev1041kernel/chr_drv/tty_io.ctty_termios[dev] = tp;
dev1044kernel/chr_drv/tty_io.cif (!tty_table[dev]) {
dev1045kernel/chr_drv/tty_io.ctty->termios = tty_termios[dev];
dev1046kernel/chr_drv/tty_io.ctty_table[dev] = tty;
dev1049kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1059kernel/chr_drv/tty_io.ctty_table[dev]->link = tty_table[o_dev];
dev1060kernel/chr_drv/tty_io.ctty_table[o_dev]->link = tty_table[dev];
dev1062kernel/chr_drv/tty_io.ctty_table[dev]->count++;
dev1063kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev))
dev1083kernel/chr_drv/tty_io.cstatic void release_dev(int dev, struct file * filp)
dev1089kernel/chr_drv/tty_io.ctty = tty_table[dev];
dev1090kernel/chr_drv/tty_io.ctp = tty_termios[dev];
dev1094kernel/chr_drv/tty_io.cprintk("release_dev: tty_table[%d] was NULL\n", dev);
dev1098kernel/chr_drv/tty_io.cprintk("release_dev: tty_termios[%d] was NULL\n", dev);
dev1101kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1102kernel/chr_drv/tty_io.co_tty = tty_table[PTY_OTHER(dev)];
dev1103kernel/chr_drv/tty_io.co_tp = tty_termios[PTY_OTHER(dev)];
dev1105kernel/chr_drv/tty_io.cprintk("release_dev: pty pair(%d) was NULL\n", dev);
dev1109kernel/chr_drv/tty_io.cprintk("release_dev: pty pair(%d) termios was NULL\n", dev);
dev1120kernel/chr_drv/tty_io.cif (IS_A_PTY_MASTER(dev)) {
dev1123kernel/chr_drv/tty_io.cdev, tty->count);
dev1129kernel/chr_drv/tty_io.cdev, tty->count);
dev1151kernel/chr_drv/tty_io.ctty_table[PTY_OTHER(dev)] = NULL;
dev1152kernel/chr_drv/tty_io.ctty_termios[PTY_OTHER(dev)] = NULL;
dev1155kernel/chr_drv/tty_io.ctty_table[dev] = NULL;
dev1156kernel/chr_drv/tty_io.cif (IS_A_PTY(dev)) {
dev1157kernel/chr_drv/tty_io.ctty_termios[dev] = NULL;
dev1254kernel/chr_drv/tty_io.cint dev;
dev1256kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev1257kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev1261kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev1262kernel/chr_drv/tty_io.cif (!dev) {
dev1266kernel/chr_drv/tty_io.crelease_dev(dev, filp);
dev1271kernel/chr_drv/tty_io.cint dev;
dev1274kernel/chr_drv/tty_io.cdev = filp->f_rdev;
dev1275kernel/chr_drv/tty_io.cif (MAJOR(dev) != 4) {
dev1279kernel/chr_drv/tty_io.cdev = MINOR(filp->f_rdev);
dev1280kernel/chr_drv/tty_io.ctty = TTY_TABLE(dev);
dev1282kernel/chr_drv/tty_io.cprintk("tty_select: tty struct for dev %d was NULL\n", dev);
dev310kernel/chr_drv/tty_ioctl.cint dev;
dev318kernel/chr_drv/tty_ioctl.cdev = MINOR(file->f_rdev);
dev319kernel/chr_drv/tty_ioctl.ctty = TTY_TABLE(dev);
dev322kernel/chr_drv/tty_ioctl.cif (IS_A_PTY(dev))
dev323kernel/chr_drv/tty_ioctl.cother_tty = tty_table[PTY_OTHER(dev)];
dev327kernel/chr_drv/tty_ioctl.ctermios_dev = dev;
dev328kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev)) {
dev330kernel/chr_drv/tty_ioctl.ctermios_dev = PTY_OTHER(dev);
dev393kernel/chr_drv/tty_ioctl.ccurrent->tty = dev;
dev437kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev455kernel/chr_drv/tty_ioctl.cif (IS_A_CONSOLE(dev)) {
dev465kernel/chr_drv/tty_ioctl.cif (IS_A_PTY_MASTER(dev))
dev467kernel/chr_drv/tty_ioctl.celse if (IS_A_PTY_SLAVE(dev))
dev501kernel/chr_drv/tty_ioctl.cif (!IS_A_PTY_MASTER(dev))
dev36net/tcp/Space.cextern int loopback_init(struct device *dev);
dev125net/tcp/arp.cif (!skb->dev->rebuild_header (skb+1, skb->dev))
dev130net/tcp/arp.cskb->dev->queue_xmit (skb, skb->dev, 0);
dev242net/tcp/arp.carp_response (struct arp *arp1, struct device *dev)
dev250net/tcp/arp.c2*arp1->hlen + 2*arp1->plen + dev->hard_header_len,
dev257net/tcp/arp.c2*arp1->plen + dev->hard_header_len;
dev259net/tcp/arp.c2*arp1->plen + dev->hard_header_len;
dev261net/tcp/arp.ctmp = dev->hard_header((unsigned char *)(skb+1), dev,
dev272net/tcp/arp.cmemcpy(arp_sourceh(arp2), dev->dev_addr, arp1->hlen);
dev285net/tcp/arp.cdev->queue_xmit (skb, dev, 0);
dev364net/tcp/arp.carp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
dev375net/tcp/arp.cif (arp->hlen != dev->addr_len || dev->type !=NET16( arp->hrd))
dev416net/tcp/arp.cret = arp_response(arp, dev);
dev422net/tcp/arp.carp_snd (unsigned long paddr, struct device *dev, unsigned long saddr)
dev428net/tcp/arp.cPRINTK (("arp_snd (paddr=%X, dev=%X, saddr=%X)\n",paddr, dev, saddr));
dev434net/tcp/arp.cskb = arp_malloc (sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
dev435net/tcp/arp.c2*dev->addr_len+8, GFP_ATOMIC);
dev441net/tcp/arp.cskb->mem_len = sizeof (*arp) + sizeof (*skb) + dev->hard_header_len +
dev442net/tcp/arp.c2*dev->addr_len+8;
dev444net/tcp/arp.cskb->dev = dev;
dev445net/tcp/arp.cskb->len = sizeof (*arp) + dev->hard_header_len + 2*dev->addr_len+8;
dev448net/tcp/arp.ctmp = dev->hard_header ((unsigned char *)(skb+1), dev,
dev457net/tcp/arp.carp->hrd = net16(dev->type);
dev459net/tcp/arp.carp->hlen = dev->addr_len;
dev464net/tcp/arp.cmemcpy (arp_sourceh(arp), dev->dev_addr, dev->addr_len);
dev465net/tcp/arp.cmemcpy (arp_targeth(arp), dev->broadcast, dev->addr_len);
dev468net/tcp/arp.cdev->queue_xmit (skb, dev, 0);
dev472net/tcp/arp.carp_find(unsigned char *haddr, unsigned long paddr, struct device *dev,
dev477net/tcp/arp.chaddr, paddr, dev, saddr));
dev480net/tcp/arp.cmemcpy (haddr, dev->dev_addr, dev->addr_len);
dev493net/tcp/arp.cmemcpy (haddr, apt->hard, dev->addr_len);
dev509net/tcp/arp.carp_snd(paddr,dev,saddr);
dev515net/tcp/arp.carp_add (unsigned long addr, unsigned char *haddr, struct device *dev)
dev523net/tcp/arp.cmemcpy (apt->hard, haddr , dev->addr_len);
dev526net/tcp/arp.ccreate_arp (addr, haddr, dev->addr_len);
dev530net/tcp/arp.carp_add_broad (unsigned long addr, struct device *dev)
dev532net/tcp/arp.carp_add (addr,  dev->broadcast , dev);
dev78net/tcp/arp.hint arp_find (unsigned char *, unsigned long, struct device *dev,
dev80net/tcp/arp.hvoid arp_add_broad (unsigned long, struct device *dev);
dev82net/tcp/arp.hvoid arp_add (unsigned long addr, unsigned char *haddr, struct device *dev);
dev157net/tcp/dev.cstruct device *dev;
dev158net/tcp/dev.cfor (dev = dev_base; dev != NULL; dev=dev->next)
dev160net/tcp/dev.cif (strcmp (dev->name, name) == 0) return (dev);
dev166net/tcp/dev.cdev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri)
dev172net/tcp/dev.cPRINTK (("dev_queue_xmit (skb=%X, dev=%X, pri = %d)\n", skb, dev, pri));
dev174net/tcp/dev.cif (dev == NULL)
dev180net/tcp/dev.cskb->dev = dev;
dev184net/tcp/dev.cdev->hard_start_xmit (NULL, dev);
dev200net/tcp/dev.cif (dev->hard_start_xmit(skb, dev) == 0)
dev206net/tcp/dev.cPRINTK (("dev_queue_xmit dev->buffs[%d]=%X\n",pri, dev->buffs[pri]));
dev209net/tcp/dev.cif (dev->buffs[pri] == NULL)
dev211net/tcp/dev.cdev->buffs[pri]=skb;
dev219net/tcp/dev.cskb->next = (struct sk_buff *)dev->buffs[pri];
dev220net/tcp/dev.cskb->prev = (struct sk_buff *)dev->buffs[pri]->prev;
dev223net/tcp/dev.cdev->buffs[pri] = skb;
dev227net/tcp/dev.cskb2= (struct sk_buff *)dev->buffs[pri];
dev257net/tcp/dev.cstruct device * dev)
dev263net/tcp/dev.cif (dev == NULL || buff == NULL || len <= 0) return (1);
dev285net/tcp/dev.camount = min (len, (unsigned long) dev->rmem_end -
dev291net/tcp/dev.cif ((unsigned long)buff == dev->rmem_end)
dev292net/tcp/dev.cbuff = (unsigned char *)dev->rmem_start;
dev297net/tcp/dev.cskb->dev = dev;
dev326net/tcp/dev.cstruct device *dev;
dev328net/tcp/dev.cfor (dev = dev_base; dev != NULL; dev=dev->next)
dev330net/tcp/dev.cif (!dev->tbusy)
dev332net/tcp/dev.cdev_tint (dev);
dev375net/tcp/dev.cskb->h.raw = (unsigned char *)(skb+1) + skb->dev->hard_header_len;
dev376net/tcp/dev.cskb->len -= skb->dev->hard_header_len;
dev379net/tcp/dev.ctype = skb->dev->type_trans ((struct sk_buff *)skb, skb->dev);
dev407net/tcp/dev.cptype->func (skb2, skb->dev, ptype);
dev432net/tcp/dev.cdev_tint( struct device *dev)
dev438net/tcp/dev.cwhile (dev->buffs[i]!=NULL)
dev441net/tcp/dev.cskb=(struct sk_buff *)dev->buffs[i];
dev447net/tcp/dev.cdev->buffs[i] = NULL;
dev456net/tcp/dev.cdev->buffs[i] = NULL;
dev470net/tcp/dev.cdev->buffs[i] = NULL;
dev474net/tcp/dev.cdev->buffs[i]= skb->next;
dev483net/tcp/dev.cdev->queue_xmit (skb, dev, -i-1);
dev484net/tcp/dev.cif (dev->tbusy)
dev73net/tcp/dev.hint (*init)(struct device *dev);
dev77net/tcp/dev.hint  (*open)(struct device *dev);
dev78net/tcp/dev.hint  (*stop)(struct device *dev);
dev79net/tcp/dev.hint (*hard_start_xmit) (struct sk_buff *skb, struct device *dev);
dev80net/tcp/dev.hint (*hard_header) (unsigned char *buff, struct device *dev,
dev84net/tcp/dev.hstruct device *dev);
dev85net/tcp/dev.hvoid (*queue_xmit)(struct sk_buff *skb, struct device *dev, int pri);
dev86net/tcp/dev.hint (*rebuild_header)(void *eth, struct device *dev);
dev87net/tcp/dev.hunsigned short (*type_trans) (struct sk_buff *skb, struct device *dev);
dev88net/tcp/dev.hvoid (*send_packet)(struct sk_buff *skb, struct device *dev); /* no longer
dev118net/tcp/dev.hvoid dev_queue_xmit (struct sk_buff *skb, struct device *dev, int pri);
dev119net/tcp/dev.hint dev_rint (unsigned char *buff, long len, int flags, struct device *dev);
dev120net/tcp/dev.hvoid dev_tint ( struct device *dev);
dev88net/tcp/eth.ceth_hard_header (unsigned char *buff, struct device *dev,
dev95net/tcp/eth.cmemcpy (eth->saddr, dev->dev_addr, dev->addr_len);
dev98net/tcp/eth.cmemset (eth->daddr, 0xff, dev->addr_len);
dev101net/tcp/eth.cif (!arp_find (eth->daddr, daddr, dev, saddr))
dev113net/tcp/eth.ceth_rebuild_header (void *buff, struct device *dev)
dev117net/tcp/eth.cif (arp_find(eth->daddr, *(unsigned long*)eth->daddr, dev, 
dev120net/tcp/eth.cmemcpy (eth->saddr, dev->dev_addr, dev->addr_len);
dev125net/tcp/eth.ceth_add_arp (unsigned long addr, struct sk_buff *skb, struct device *dev)
dev129net/tcp/eth.carp_add (addr, eh->saddr, dev);
dev133net/tcp/eth.ceth_type_trans (struct sk_buff *skb, struct device *dev)
dev94net/tcp/eth.hint eth_hard_header (unsigned char *buff, struct device *dev,
dev98net/tcp/eth.hint eth_rebuild_header(void *eth, struct device *dev);
dev100net/tcp/eth.hstruct device *dev);
dev101net/tcp/eth.hunsigned short eth_type_trans (struct sk_buff *skb, struct device *dev);
dev120net/tcp/icmp.cicmp_reply (struct sk_buff *skb_in,  int type, int code, struct device *dev)
dev129net/tcp/icmp.cskb_in, type, code, dev));
dev135net/tcp/icmp.cdev->hard_header_len;
dev148net/tcp/icmp.ciph = (struct ip_header *)((unsigned char *)iph + dev->hard_header_len);
dev152net/tcp/icmp.c&dev, IPPROTO_ICMP, NULL, len );
dev171net/tcp/icmp.cip_queue_xmit (NULL, dev, skb, 1);
dev178net/tcp/icmp.cicmp_rcv(struct sk_buff *skb1, struct device *dev, struct options *opt,
dev267net/tcp/icmp.crt->dev = dev;
dev280net/tcp/icmp.csize = sizeof( struct sk_buff ) + dev->hard_header_len + 64 + len;
dev294net/tcp/icmp.coffset = ip_build_header( skb, daddr, saddr, &dev, IPPROTO_ICMP, opt, len );
dev321net/tcp/icmp.cip_queue_xmit( (volatile struct sock *)NULL, dev, skb, 1 );
dev71net/tcp/icmp.hicmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev76net/tcp/icmp.hicmp_reply (struct sk_buff *skb_in,  int type, int code, struct device *dev);
dev242net/tcp/ip.c(long) rt, (long) rt->next, (long) rt->dev,
dev243net/tcp/ip.crt->dev->name, in_ntoa(rt->net));
dev267net/tcp/ip.cPRINTK (("IP: %X via %s (%X)\n", daddr, rt->dev->name, rt->router));
dev269net/tcp/ip.creturn (rt->dev);
dev277net/tcp/ip.cdel_devroute (struct device *dev)
dev283net/tcp/ip.c(long) dev, dev->name));
dev288net/tcp/ip.c(long) r, (long) r->next, (long) p, (long) r->dev,
dev289net/tcp/ip.cr->dev->name, in_ntoa(r->net)));
dev290net/tcp/ip.cif (r->dev == dev)
dev382net/tcp/ip.cstruct device *dev;
dev390net/tcp/ip.cdev = get_dev (ipc.name);
dev398net/tcp/ip.cif (dev == NULL) return (-EINVAL);
dev405net/tcp/ip.cPRINTK (("new broadcast for %s: %08X\n", dev->name, ipc.net));
dev406net/tcp/ip.carp_add_broad (ipc.net, dev);
dev410net/tcp/ip.crt->dev = dev;
dev418net/tcp/ip.cPRINTK (("new router for %s: %08X\n", dev->name, ipc.router));
dev422net/tcp/ip.crt->dev = dev;
dev427net/tcp/ip.cif (dev->loopback)
dev433net/tcp/ip.crt->dev = dev;
dev473net/tcp/ip.cdev->up = ipc.up;
dev474net/tcp/ip.cif (dev->up)
dev476net/tcp/ip.cif (dev->open)
dev477net/tcp/ip.cdev->open(dev);
dev481net/tcp/ip.cif (dev->stop)
dev482net/tcp/ip.cdev->stop(dev);
dev483net/tcp/ip.cdel_devroute(dev);    /* clear routing table for dev  */
dev515net/tcp/ip.cunsigned long daddr, struct device **dev, int type,
dev527net/tcp/ip.cskb, saddr, daddr, *dev, type, opt, len));
dev530net/tcp/ip.cif (*dev == NULL)
dev532net/tcp/ip.c*dev = ip_route(&optmem,daddr, &raddr);
dev533net/tcp/ip.cif (*dev == NULL)
dev549net/tcp/ip.cif ((*dev)->hard_header)
dev551net/tcp/ip.ctmp = (*dev)->hard_header(buff, *dev, ETHERTYPE_IP, raddr, saddr, len);
dev568net/tcp/ip.cskb->dev = *dev;
dev811net/tcp/ip.cip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
dev852net/tcp/ip.cicmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
dev891net/tcp/ip.cipprot->handler (skb2, dev, &opt, iph->daddr,
dev898net/tcp/ip.cicmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev);
dev914net/tcp/ip.cip_queue_xmit (volatile struct sock *sk, struct device *dev, 
dev921net/tcp/ip.cif (dev == NULL)
dev928net/tcp/ip.cskb->dev = dev;
dev932net/tcp/ip.cptr += dev->hard_header_len;
dev934net/tcp/ip.ciph->tot_len = net16(skb->len-dev->hard_header_len);
dev967net/tcp/ip.cif (dev->up)
dev971net/tcp/ip.cdev->queue_xmit(skb, dev, sk->priority);
dev975net/tcp/ip.cdev->queue_xmit (skb, dev, SOPRI_NORMAL);
dev990net/tcp/ip.cstruct device *dev;
dev996net/tcp/ip.cdev = skb->dev;
dev1001net/tcp/ip.cif (dev->rebuild_header ((struct enet_header *)(skb+1),dev))
dev1011net/tcp/ip.cif (dev->up)
dev1013net/tcp/ip.cdev->queue_xmit(skb, dev, sk->priority);
dev1015net/tcp/ip.cdev->queue_xmit(skb, dev, SOPRI_NORMAL );
dev52net/tcp/ip.hstruct device *dev;
dev138net/tcp/ip.hint (*handler) (struct sk_buff *skb, struct device *dev,
dev176net/tcp/ip.hunsigned long daddr, struct device **dev, int type,
dev178net/tcp/ip.hvoid ip_queue_xmit (volatile struct sock *sk, struct device *dev, 
dev181net/tcp/ip.hint ip_rcv(struct sk_buff *buff, struct device *dev, struct packet_type *);
dev86net/tcp/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
dev89net/tcp/loopback.cif (!skb || !dev) return 0;
dev90net/tcp/loopback.cPRINTK (("loopback_xmit (dev = %X)\n", dev));
dev92net/tcp/loopback.cif (dev->tbusy != 0)
dev97net/tcp/loopback.cdev->tbusy = 1;
dev100net/tcp/loopback.cdone = dev_rint ((unsigned char *)(skb+1), skb->len, 0, dev);
dev107net/tcp/loopback.cdone = dev_rint (NULL, 0, 0, dev);
dev110net/tcp/loopback.cdev->tbusy = 0;
dev116net/tcp/loopback.cloopback_init(struct device *dev)
dev120net/tcp/loopback.cdev->mtu = 2000; /* mtu */
dev121net/tcp/loopback.cdev->tbusy = 0;
dev122net/tcp/loopback.cdev->hard_start_xmit = loopback_xmit;
dev123net/tcp/loopback.cdev->open = NULL;
dev124net/tcp/loopback.cdev->hard_header = eth_hard_header;
dev125net/tcp/loopback.cdev->add_arp = NULL;
dev126net/tcp/loopback.cdev->hard_header_len = sizeof (struct enet_header);
dev127net/tcp/loopback.cdev->addr_len = ETHER_ADDR_LEN;
dev128net/tcp/loopback.cdev->type = ETHER_TYPE;
dev129net/tcp/loopback.cdev->queue_xmit = dev_queue_xmit;
dev130net/tcp/loopback.cdev->rebuild_header = eth_rebuild_header;
dev131net/tcp/loopback.cdev->type_trans = eth_type_trans;
dev132net/tcp/loopback.cdev->loopback = 1;
dev42net/tcp/pack_type.cextern int arp_rcv (struct sk_buff *skb, struct device *dev,
dev54net/tcp/pack_type.cextern int ip_rcv (struct sk_buff *skb, struct device *dev,
dev76net/tcp/packet.cpacket_rcv (struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
dev81net/tcp/packet.cskb->dev = dev;
dev82net/tcp/packet.cskb->len += dev->hard_header_len;
dev138net/tcp/packet.cstruct device *dev;
dev170net/tcp/packet.cdev = get_dev (saddr.sa_data);
dev171net/tcp/packet.cif (dev == NULL)
dev180net/tcp/packet.cif (dev->up)
dev181net/tcp/packet.cdev->queue_xmit (skb, dev, sk->priority);
dev291net/tcp/packet.caddr.sa_family = skb->dev->type;
dev292net/tcp/packet.cmemcpy (addr.sa_data,skb->dev->name, 14);
dev36net/tcp/protocols.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev44net/tcp/protocols.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev51net/tcp/protocols.cint icmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev137net/tcp/raw.craw_rcv (struct sk_buff *skb, struct device *dev, struct options *opt,
dev146net/tcp/raw.cskb, dev, opt, daddr, len, saddr, redo, protocol));
dev164net/tcp/raw.cskb->dev = dev;
dev231net/tcp/raw.cstruct device *dev=NULL;
dev302net/tcp/raw.csin.sin_addr.s_addr, &dev,
dev315net/tcp/raw.csk->prot->queue_xmit (sk, dev, skb, 1);
dev561net/tcp/sock.cif (skb->dev && skb->dev->buffs[i] == skb)
dev571net/tcp/sock.cskb->dev->buffs[i]= skb->next;
dev594net/tcp/sock.cif (skb->dev && skb->dev->buffs[i] == skb)
dev604net/tcp/sock.cskb->dev->buffs[i]= NULL;
dev611net/tcp/sock.cskb->dev = NULL;
dev879net/tcp/sock.cstruct device *dev, *dev2;
dev905net/tcp/sock.cfor (dev = dev_base; dev != NULL; dev=dev->next)
dev907net/tcp/sock.cif (dev->init && dev->init(dev))
dev910net/tcp/sock.cdev_base = dev->next;
dev912net/tcp/sock.cdev2->next = dev->next;
dev916net/tcp/sock.cdev2 = dev;
dev1869net/tcp/sock.csk->prot->rcv(skb, skb->dev, sk->opt,
dev130net/tcp/sock.hunsigned long daddr, struct device **dev, int type,
dev135net/tcp/sock.hvoid  (*queue_xmit) (volatile struct sock *sk, struct device *dev, 
dev140net/tcp/sock.hint (*rcv)(struct sk_buff *buff, struct device *dev, struct options *opt,
dev171net/tcp/sock.hstruct device *dev;
dev557net/tcp/tcp.csk->prot->queue_xmit (sk, skb->dev, skb,0);
dev572net/tcp/tcp.cstruct device *dev=NULL;
dev599net/tcp/tcp.ctmp = sk->prot->build_header (buff, sk->saddr, daddr, &dev,
dev641net/tcp/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev679net/tcp/tcp.cstruct device *dev=NULL;
dev882net/tcp/tcp.ctmp = prot->build_header (skb, sk->saddr, sk->daddr, &dev,
dev893net/tcp/tcp.cskb->dev = dev;
dev953net/tcp/tcp.cprot->queue_xmit (sk, dev, skb,0);
dev984net/tcp/tcp.cstruct device *dev = NULL;
dev1014net/tcp/tcp.ctmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
dev1041net/tcp/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev1432net/tcp/tcp.cstruct device *dev=NULL;
dev1470net/tcp/tcp.ctmp = prot->build_header (buff,sk->saddr, sk->daddr, &dev,
dev1483net/tcp/tcp.cbuff->dev = dev;
dev1512net/tcp/tcp.csk->prot->queue_xmit (sk, dev, buff,0);
dev1553net/tcp/tcp.cstruct proto *prot, struct options *opt, struct device *dev)
dev1569net/tcp/tcp.cbuff->dev = dev;
dev1573net/tcp/tcp.ctmp = prot->build_header (buff, saddr, daddr, &dev, IPPROTO_TCP, opt,
dev1596net/tcp/tcp.cprot->queue_xmit(NULL, dev, buff, 1);
dev1609net/tcp/tcp.cunsigned long saddr, struct options *opt, struct device *dev)
dev1621net/tcp/tcp.csk, skb, daddr, saddr, opt, dev));
dev1631net/tcp/tcp.ctcp_reset (daddr, saddr, th, sk->prot, opt, dev);
dev1727net/tcp/tcp.cdev->mtu-HEADER_SIZE);
dev1750net/tcp/tcp.ctmp = sk->prot->build_header (buff, newsk->saddr, newsk->daddr, &dev,
dev1789net/tcp/tcp.cptr[2]=((dev->mtu - HEADER_SIZE) >> 8) & 0xff;
dev1790net/tcp/tcp.cptr[3]=(dev->mtu - HEADER_SIZE) & 0xff;
dev1793net/tcp/tcp.cnewsk->prot->queue_xmit(newsk, dev, buff, 0);
dev1829net/tcp/tcp.cstruct device *dev=NULL;
dev1923net/tcp/tcp.ctmp = prot->build_header (buff,sk->saddr, sk->daddr, &dev,
dev1936net/tcp/tcp.cbuff->dev = dev;
dev1954net/tcp/tcp.cprot->queue_xmit(sk, dev, buff, 0);
dev2013net/tcp/tcp.csk->prot->queue_xmit (sk, skb->dev, skb, skb->free);
dev2086net/tcp/tcp.cif (skb->dev->buffs[i] == skb)
dev2089net/tcp/tcp.cskb->dev->buffs[i] = NULL;
dev2091net/tcp/tcp.cskb->dev->buffs[i] = skb->next;
dev2176net/tcp/tcp.cif (oskb->dev->buffs[i] == oskb)
dev2179net/tcp/tcp.coskb->dev->buffs[i]= NULL;
dev2181net/tcp/tcp.coskb->dev->buffs[i] = oskb->next;
dev2332net/tcp/tcp.csk->prot, NULL, skb->dev);
dev2532net/tcp/tcp.cunsigned long saddr, struct device *dev)
dev2535net/tcp/tcp.csk, th, saddr, dev));
dev2591net/tcp/tcp.ctmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
dev2641net/tcp/tcp.csk->prot->queue_xmit (sk, dev, buff,0);
dev2709net/tcp/tcp.cstruct device *dev=NULL;
dev2743net/tcp/tcp.ctmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
dev2771net/tcp/tcp.cptr[2]=(dev->mtu- HEADER_SIZE) >> 8;
dev2772net/tcp/tcp.cptr[3]=(dev->mtu- HEADER_SIZE) & 0xff;
dev2773net/tcp/tcp.csk->mtu = dev->mtu - HEADER_SIZE;
dev2780net/tcp/tcp.csk->prot->queue_xmit(sk, dev, buff, 0);
dev2854net/tcp/tcp.ctcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev2878net/tcp/tcp.cif (!dev)
dev2912net/tcp/tcp.ctcp_reset (daddr, saddr, th, &tcp_prot, opt,dev);
dev3047net/tcp/tcp.ctcp_reset (daddr, saddr,  th, sk->prot, opt,dev);
dev3076net/tcp/tcp.cif (th->fin && tcp_fin (sk, th, saddr, dev))
dev3107net/tcp/tcp.ctcp_reset (daddr, saddr, th, sk->prot, opt,dev);
dev3122net/tcp/tcp.ctcp_reset (daddr, saddr, th, sk->prot, opt,dev );
dev3142net/tcp/tcp.ctcp_conn_request (sk, skb, daddr, saddr, opt, dev);
dev3180net/tcp/tcp.ctcp_reset (daddr, saddr,  th, sk->prot, opt, dev);
dev3207net/tcp/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt,dev);
dev3232net/tcp/tcp.ctcp_reset(daddr, saddr, th, sk->prot, opt, dev);
dev3264net/tcp/tcp.ctcp_fin(sk, th, saddr, dev);
dev3292net/tcp/tcp.ctcp_fin (sk, th, saddr, dev);
dev3307net/tcp/tcp.cstruct device *dev=NULL;
dev3325net/tcp/tcp.ctmp = sk->prot->build_header (buff, sk->saddr, sk->daddr, &dev,
dev3355net/tcp/tcp.csk->prot->queue_xmit(sk, dev, buff, 1);
dev324net/tcp/udp.cstruct device *dev=NULL;
dev415net/tcp/udp.csin.sin_addr.s_addr, &dev,
dev427net/tcp/udp.camt = min (len + tmp + sizeof (*uh), dev->mtu);
dev430net/tcp/udp.camt, dev, dev->mtu));
dev458net/tcp/udp.csk->prot->queue_xmit (sk, dev, skb, 1);
dev642net/tcp/udp.cudp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
dev653net/tcp/udp.cif (dev->add_arp) dev->add_arp (saddr, skb, dev);
dev663net/tcp/udp.cicmp_reply (skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev);
dev682net/tcp/udp.cskb->dev = dev;
dev128net/tcp/we.cwd_start(struct device *dev)
dev139net/tcp/we.cdev->start = 1;
dev143net/tcp/we.cwd8003_open(struct device *dev)
dev178net/tcp/we.coutb_p(dev->dev_addr[i],WD_PAR0+i);
dev185net/tcp/we.coutb_p(dev->broadcast[i],WD_MAR0+i);
dev192net/tcp/we.cwd_start(dev); 
dev198net/tcp/we.cwdget(volatile struct wd_ring *ring, struct device *dev)
dev210net/tcp/we.creturn (dev_rint(fptr, len, 0, dev));
dev214net/tcp/we.cwd8003_start_xmit(struct sk_buff *skb, struct device *dev)
dev220net/tcp/we.cif (dev->tbusy)
dev223net/tcp/we.cif (jiffies - dev->trans_start < 30)
dev231net/tcp/we.cdev->tbusy = 1;
dev236net/tcp/we.cwd_trs(dev);
dev241net/tcp/we.cif (skb->dev != dev)
dev250net/tcp/we.cif ( dev->rebuild_header (skb+1, dev)) 
dev253net/tcp/we.cif (skb->dev == dev)
dev258net/tcp/we.cdev->tbusy = 0;
dev264net/tcp/we.cmemcpy ((unsigned char *)dev->mem_start, skb+1, skb->len);
dev269net/tcp/we.cdev->trans_start = jiffies;
dev279net/tcp/we.cif (!(dev->interrupt))
dev299net/tcp/we.cwd_put_bnd(unsigned char bnd, struct device *dev )
dev316net/tcp/we.cwd_get_bnd( struct device *dev )
dev334net/tcp/we.cwd_get_cur( struct device *dev )
dev356net/tcp/we.cwd_rcv( struct device *dev )
dev367net/tcp/we.ccur = wd_get_cur( dev );
dev368net/tcp/we.cbnd = wd_get_bnd( dev );
dev378net/tcp/we.cring = (volatile struct wd_ring *) (dev->mem_start + (pkt << 8));
dev392net/tcp/we.cdone = wdget( ring, dev ); /* get the packet */
dev400net/tcp/we.cwd_put_bnd(bnd, dev);
dev403net/tcp/we.ccur = wd_get_cur(dev);
dev414net/tcp/we.cif( ( bnd = wd_get_cur( dev ) - 1 ) < WD_TXBS )
dev416net/tcp/we.cwd_put_bnd( bnd, dev );
dev423net/tcp/we.cdone = dev_rint(NULL, 0,0, dev);
dev438net/tcp/we.cwd_rx_over( struct device *dev )
dev451net/tcp/we.cwd_rcv( dev );  /* clear out received packets */
dev467net/tcp/we.cwd_trs( struct device *dev )
dev479net/tcp/we.cdev->tbusy = 0;
dev484net/tcp/we.clen = dev_tint( (unsigned char *)dev->mem_start, dev );
dev496net/tcp/we.cdev->tbusy = 0
dev522net/tcp/we.cstruct device *dev;
dev529net/tcp/we.cfor (dev = dev_base; dev != NULL; dev = dev->next)
dev531net/tcp/we.cif (dev->irq == irq) break;
dev533net/tcp/we.cif (dev == NULL) 
dev549net/tcp/we.cdev->interrupt = 1;
dev557net/tcp/we.cprintk("\nwd8013 overrun bnd = %d, cur = %d", wd_get_bnd( dev ), wd_get_cur( dev ) );
dev558net/tcp/we.cwd_rx_over( dev ); /* performs wd_rcv() as well */
dev562net/tcp/we.cwd_rcv( dev );
dev568net/tcp/we.cwd_trs( dev );
dev601net/tcp/we.cwd_trs( dev );
dev626net/tcp/we.cdev->interrupt = 0;
dev639net/tcp/we.cwd8003_init(struct device *dev)
dev650net/tcp/we.cprintk ("Warning WD8013 board not found at i/o = %X.\n",dev->base_addr);
dev657net/tcp/we.cdev->mtu = 1500; /* eth_mtu */
dev658net/tcp/we.cdev->hard_start_xmit = wd8003_start_xmit;
dev659net/tcp/we.cdev->open = wd8003_open;
dev660net/tcp/we.cdev->hard_header = eth_hard_header;
dev661net/tcp/we.cdev->add_arp = eth_add_arp;
dev662net/tcp/we.cdev->type_trans = eth_type_trans;
dev663net/tcp/we.cdev->hard_header_len = sizeof (struct enet_header);
dev664net/tcp/we.cdev->addr_len = ETHER_ADDR_LEN;
dev665net/tcp/we.cdev->type = ETHER_TYPE;
dev666net/tcp/we.cdev->queue_xmit = dev_queue_xmit;
dev667net/tcp/we.cdev->rebuild_header = eth_rebuild_header;
dev669net/tcp/we.cdev->buffs[i] = NULL;
dev693net/tcp/we.cfor (i = dev->mem_start; i < dev->mem_end; i++)
dev699net/tcp/we.cif( (i - dev->mem_start) > 4096 )
dev706net/tcp/we.cmax_pages = ( i - dev->mem_start )/256;
dev709net/tcp/we.cdev->rmem_end = i;
dev710net/tcp/we.cdev->mem_end = i;
dev717net/tcp/we.cdev->dev_addr[i]=inb_p(WD_ROM+i);
dev718net/tcp/we.cdev->broadcast[i]=0xff;
dev719net/tcp/we.cprintk ("%2.2X ",dev->dev_addr[i]);
dev727net/tcp/we.cdev->tbusy = 0;
dev728net/tcp/we.cdev->interrupt = 0;
dev730net/tcp/we.cif (irqaction (dev->irq, &wd8003_sigaction))
dev732net/tcp/we.cprintk ("Unable to get IRQ%d for wd8013 board\n", dev->irq);
dev125net/tcp/wereg.h#define WD_MEM (dev->mem_start)
dev126net/tcp/wereg.h#define WD_BUFFEND (dev->mem_end)
dev128net/tcp/wereg.h#define WD_BASE (dev->base_addr)