tag | line | file | source code |
dev | 25 | fs/block_dev.c | unsigned int dev; |
dev | 29 | fs/block_dev.c | dev = inode->i_rdev; |
dev | 31 | fs/block_dev.c | if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)]) |
dev | 32 | fs/block_dev.c | blocksize = blksize_size[MAJOR(dev)][MINOR(dev)]; |
dev | 44 | fs/block_dev.c | if (blk_size[MAJOR(dev)]) |
dev | 45 | fs/block_dev.c | size = (blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS) >> blocksize_bits; |
dev | 55 | fs/block_dev.c | bh = getblk(dev, block, blocksize); |
dev | 57 | fs/block_dev.c | bh = breada(dev,block,block+1,block+2,-1); |
dev | 91 | fs/block_dev.c | unsigned int dev; |
dev | 94 | fs/block_dev.c | dev = inode->i_rdev; |
dev | 96 | fs/block_dev.c | if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)]) |
dev | 97 | fs/block_dev.c | blocksize = blksize_size[MAJOR(dev)][MINOR(dev)]; |
dev | 106 | fs/block_dev.c | if (blk_size[MAJOR(dev)]) |
dev | 107 | fs/block_dev.c | size = blk_size[MAJOR(dev)][MINOR(dev)] << BLOCK_SIZE_BITS; |
dev | 126 | fs/block_dev.c | blocks += read_ahead[MAJOR(dev)] / (blocksize >> 9); |
dev | 146 | fs/block_dev.c | *bhb = getblk(dev, block++, blocksize); |
dev | 89 | fs/buffer.c | static int sync_buffers(dev_t dev, int wait) |
dev | 103 | fs/buffer.c | if (dev && bh->b_dev != dev) |
dev | 147 | fs/buffer.c | void sync_dev(dev_t dev) |
dev | 149 | fs/buffer.c | sync_buffers(dev, 0); |
dev | 150 | fs/buffer.c | sync_supers(dev); |
dev | 151 | fs/buffer.c | sync_inodes(dev); |
dev | 152 | fs/buffer.c | sync_buffers(dev, 0); |
dev | 155 | fs/buffer.c | int fsync_dev(dev_t dev) |
dev | 157 | fs/buffer.c | sync_buffers(dev, 0); |
dev | 158 | fs/buffer.c | sync_supers(dev); |
dev | 159 | fs/buffer.c | sync_inodes(dev); |
dev | 160 | fs/buffer.c | return sync_buffers(dev, 1); |
dev | 188 | fs/buffer.c | void invalidate_buffers(dev_t dev) |
dev | 195 | fs/buffer.c | if (bh->b_dev != dev) |
dev | 198 | fs/buffer.c | if (bh->b_dev == dev) |
dev | 217 | fs/buffer.c | void check_disk_change(dev_t dev) |
dev | 222 | fs/buffer.c | switch(MAJOR(dev)){ |
dev | 224 | fs/buffer.c | if (!(bh = getblk(dev,0,1024))) |
dev | 232 | fs/buffer.c | i = check_scsidisk_media_change(dev, 0); |
dev | 238 | fs/buffer.c | i = check_cdrom_media_change(dev, 0); |
dev | 244 | fs/buffer.c | i = check_cdu31a_media_change(dev, 0); |
dev | 250 | fs/buffer.c | i = check_mcd_media_change(dev, 0); |
dev | 261 | fs/buffer.c | MAJOR(dev), MINOR(dev)); |
dev | 263 | fs/buffer.c | if (super_blocks[i].s_dev == dev) |
dev | 265 | fs/buffer.c | invalidate_inodes(dev); |
dev | 266 | fs/buffer.c | invalidate_buffers(dev); |
dev | 271 | fs/buffer.c | if (MAJOR(dev) == 8) |
dev | 272 | fs/buffer.c | revalidate_scsidisk(dev, 0); |
dev | 276 | fs/buffer.c | #define _hashfn(dev,block) (((unsigned)(dev^block))%NR_HASH) |
dev | 277 | fs/buffer.c | #define hash(dev,block) hash_table[_hashfn(dev,block)] |
dev | 354 | fs/buffer.c | static struct buffer_head * find_buffer(dev_t dev, int block, int size) |
dev | 358 | fs/buffer.c | for (tmp = hash(dev,block) ; tmp != NULL ; tmp = tmp->b_next) |
dev | 359 | fs/buffer.c | if (tmp->b_dev==dev && tmp->b_blocknr==block) |
dev | 364 | fs/buffer.c | MAJOR(dev), MINOR(dev)); |
dev | 377 | fs/buffer.c | struct buffer_head * get_hash_table(dev_t dev, int block, int size) |
dev | 382 | fs/buffer.c | if (!(bh=find_buffer(dev,block,size))) |
dev | 386 | fs/buffer.c | if (bh->b_dev == dev && bh->b_blocknr == block && bh->b_size == size) |
dev | 392 | fs/buffer.c | void set_blocksize(dev_t dev, int size) |
dev | 397 | fs/buffer.c | if (!blksize_size[MAJOR(dev)]) |
dev | 405 | fs/buffer.c | if (blksize_size[MAJOR(dev)][MINOR(dev)] == 0 && size == BLOCK_SIZE) { |
dev | 406 | fs/buffer.c | blksize_size[MAJOR(dev)][MINOR(dev)] = size; |
dev | 409 | fs/buffer.c | if (blksize_size[MAJOR(dev)][MINOR(dev)] == size) |
dev | 411 | fs/buffer.c | sync_buffers(dev, 2); |
dev | 412 | fs/buffer.c | blksize_size[MAJOR(dev)][MINOR(dev)] = size; |
dev | 420 | fs/buffer.c | if (bh->b_dev != dev) |
dev | 426 | fs/buffer.c | if (bh->b_dev == dev && bh->b_size != size) |
dev | 444 | fs/buffer.c | struct buffer_head * getblk(dev_t dev, int block, int size) |
dev | 451 | fs/buffer.c | bh = get_hash_table(dev, block, size); |
dev | 503 | fs/buffer.c | if (find_buffer(dev,block,size)) |
dev | 512 | fs/buffer.c | bh->b_dev=dev; |
dev | 536 | fs/buffer.c | struct buffer_head * bread(dev_t dev, int block, int size) |
dev | 540 | fs/buffer.c | if (!(bh = getblk(dev, block, size))) { |
dev | 542 | fs/buffer.c | MAJOR(dev), MINOR(dev)); |
dev | 560 | fs/buffer.c | struct buffer_head * breada(dev_t dev,int first, ...) |
dev | 569 | fs/buffer.c | if (blksize_size[MAJOR(dev)] && blksize_size[MAJOR(dev)][MINOR(dev)]) |
dev | 570 | fs/buffer.c | blocksize = blksize_size[MAJOR(dev)][MINOR(dev)]; |
dev | 572 | fs/buffer.c | if (!(bh = getblk(dev, first, blocksize))) { |
dev | 574 | fs/buffer.c | MAJOR(dev), MINOR(dev)); |
dev | 580 | fs/buffer.c | tmp = getblk(dev, first, blocksize); |
dev | 698 | fs/buffer.c | dev_t dev, int *b, int size) |
dev | 718 | fs/buffer.c | first = get_hash_table(dev, block, size); |
dev | 739 | fs/buffer.c | dev_t dev, int b[], int size) |
dev | 754 | fs/buffer.c | tmp = get_hash_table(dev, block, size); |
dev | 768 | fs/buffer.c | bh->b_dev = dev; |
dev | 805 | fs/buffer.c | dev_t dev, int *b, int size) |
dev | 813 | fs/buffer.c | bh = get_hash_table(dev, block, size); |
dev | 815 | fs/buffer.c | return check_aligned(bh, address, dev, b, size); |
dev | 816 | fs/buffer.c | return try_to_load_aligned(address, dev, b, size); |
dev | 831 | fs/buffer.c | unsigned long bread_page(unsigned long address, dev_t dev, int b[], int size, int prot) |
dev | 838 | fs/buffer.c | where = try_to_share_buffers(address,dev,b,size); |
dev | 846 | fs/buffer.c | bh[i] = getblk(dev, b[i], size); |
dev | 189 | fs/ext/freelists.c | dev_t dev; |
dev | 211 | fs/ext/freelists.c | dev = inode->i_dev; |
dev | 229 | fs/ext/freelists.c | if (!(bh = bread(dev, block, sb->s_blocksize))) |
dev | 62 | fs/ext/inode.c | int dev = s->s_dev,block; |
dev | 65 | fs/ext/inode.c | set_blocksize(dev, BLOCK_SIZE); |
dev | 66 | fs/ext/inode.c | if (!(bh = bread(dev, 1, BLOCK_SIZE))) { |
dev | 91 | fs/ext/inode.c | dev); |
dev | 97 | fs/ext/inode.c | if (!(s->u.ext_sb.s_firstfreeblock = bread(dev, |
dev | 108 | fs/ext/inode.c | if (!(s->u.ext_sb.s_firstfreeinodeblock = bread(dev, block, BLOCK_SIZE))) { |
dev | 118 | fs/ext/inode.c | s->s_dev = dev; |
dev | 23 | fs/ext2/dcache.c | unsigned short dev; |
dev | 52 | fs/ext2/dcache.c | #define hash(dev,dir) ((dev ^ dir) % HASH_QUEUES) |
dev | 81 | fs/ext2/dcache.c | static struct dir_cache_entry * find_name (int queue, unsigned short dev, |
dev | 87 | fs/ext2/dcache.c | for (p = queue_head[queue]; p != NULL && (p->dev != dev || |
dev | 106 | fs/ext2/dcache.c | p->dev, p->dir, p->name); |
dev | 172 | fs/ext2/dcache.c | void ext2_dcache_invalidate (unsigned short dev) |
dev | 181 | fs/ext2/dcache.c | if (p->dev == dev) { |
dev | 183 | fs/ext2/dcache.c | remove_from_queue (hash (p->dev, p->dir), p); |
dev | 196 | fs/ext2/dcache.c | unsigned long ext2_dcache_lookup (unsigned short dev, unsigned long dir, |
dev | 210 | fs/ext2/dcache.c | printk ("dcache_lookup (%04x, %d, %s, %d)\n", dev, dir, our_name, len); |
dev | 212 | fs/ext2/dcache.c | queue = hash (dev, dir); |
dev | 213 | fs/ext2/dcache.c | if ((p = find_name (queue, dev, dir, our_name, len))) { |
dev | 246 | fs/ext2/dcache.c | void ext2_dcache_add (unsigned short dev, unsigned long dir, const char * name, |
dev | 256 | fs/ext2/dcache.c | dev, dir, name, len, ino); |
dev | 260 | fs/ext2/dcache.c | queue = hash (dev, dir); |
dev | 261 | fs/ext2/dcache.c | if ((p = find_name (queue, dev, dir, name, len))) { |
dev | 284 | fs/ext2/dcache.c | remove_from_queue (hash (p->dev, p->dir), p); |
dev | 287 | fs/ext2/dcache.c | p->dev = dev; |
dev | 306 | fs/ext2/dcache.c | void ext2_dcache_remove (unsigned short dev, unsigned long dir, |
dev | 315 | fs/ext2/dcache.c | printk ("dcache_remove (%04x, %d, %s, %d)\n", dev, dir, name, len); |
dev | 319 | fs/ext2/dcache.c | queue = hash (dev, dir); |
dev | 320 | fs/ext2/dcache.c | if ((p = find_name (queue, dev, dir, name, len))) { |
dev | 123 | fs/ext2/inode.c | int dev = s->s_dev; |
dev | 131 | fs/ext2/inode.c | set_blocksize (dev, BLOCK_SIZE); |
dev | 132 | fs/ext2/inode.c | if (!(bh = bread (dev, 1, BLOCK_SIZE))) { |
dev | 153 | fs/ext2/inode.c | dev); |
dev | 162 | fs/ext2/inode.c | set_blocksize (dev, s->s_blocksize); |
dev | 163 | fs/ext2/inode.c | bh = bread (dev, 0, s->s_blocksize); |
dev | 232 | fs/ext2/inode.c | dev); |
dev | 241 | fs/ext2/inode.c | dev); |
dev | 273 | fs/ext2/inode.c | s->u.ext2_sb.s_group_desc[i] = bread (dev, i + 2, |
dev | 295 | fs/ext2/inode.c | s->s_dev = dev; |
dev | 20 | fs/inode.c | static inline int const hashfn(dev_t dev, unsigned int i) |
dev | 22 | fs/inode.c | return (dev ^ i) % NR_IHASH; |
dev | 25 | fs/inode.c | static inline struct inode ** const hash(dev_t dev, int i) |
dev | 27 | fs/inode.c | return hash_table + hashfn(dev, i); |
dev | 158 | fs/inode.c | int fs_may_mount(dev_t dev) |
dev | 167 | fs/inode.c | if (inode->i_dev != dev) |
dev | 176 | fs/inode.c | int fs_may_umount(dev_t dev, struct inode * mount_root) |
dev | 183 | fs/inode.c | if (inode->i_dev != dev || !inode->i_count) |
dev | 192 | fs/inode.c | int fs_may_remount_ro(dev_t dev) |
dev | 200 | fs/inode.c | file->f_inode->i_dev != dev) |
dev | 265 | fs/inode.c | void invalidate_inodes(dev_t dev) |
dev | 274 | fs/inode.c | if (inode->i_dev != dev) |
dev | 277 | fs/inode.c | printk("VFS: inode busy on removed device %d/%d\n", MAJOR(dev), MINOR(dev)); |
dev | 284 | fs/inode.c | void sync_inodes(dev_t dev) |
dev | 291 | fs/inode.c | if (dev && inode->i_dev != dev) |
dev | 199 | fs/isofs/dir.c | cache.dev = inode->i_dev; |
dev | 124 | fs/isofs/inode.c | int dev=s->s_dev; |
dev | 148 | fs/isofs/inode.c | set_blocksize(dev, blocksize); |
dev | 155 | fs/isofs/inode.c | if (!(bh = bread(dev, iso_blknum << (ISOFS_BLOCK_BITS-blocksize_bits), blocksize))) { |
dev | 158 | fs/isofs/inode.c | dev, iso_blknum); |
dev | 249 | fs/isofs/inode.c | s->s_dev = dev; |
dev | 631 | fs/isofs/inode.c | struct buffer_head * leak_check_bread(int dev, int block, int size){ |
dev | 633 | fs/isofs/inode.c | return bread(dev, block, size); |
dev | 218 | fs/isofs/namei.c | if (dir->i_dev == cache.dev && |
dev | 58 | fs/minix/inode.c | int i,dev=s->s_dev,block; |
dev | 63 | fs/minix/inode.c | if (!(bh = bread(dev,1,BLOCK_SIZE))) { |
dev | 92 | fs/minix/inode.c | dev); |
dev | 101 | fs/minix/inode.c | if ((s->u.minix_sb.s_imap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
dev | 106 | fs/minix/inode.c | if ((s->u.minix_sb.s_zmap[i]=bread(dev,block,BLOCK_SIZE)) != NULL) |
dev | 123 | fs/minix/inode.c | s->s_dev = dev; |
dev | 395 | fs/namei.c | int do_mknod(const char * filename, int mode, dev_t dev) |
dev | 421 | fs/namei.c | return dir->i_op->mknod(dir,basename,namelen,mode,dev); |
dev | 424 | fs/namei.c | asmlinkage int sys_mknod(const char * filename, int mode, dev_t dev) |
dev | 433 | fs/namei.c | error = do_mknod(tmp,mode,dev); |
dev | 174 | fs/nfs/dir.c | int dev; |
dev | 190 | fs/nfs/dir.c | if (entry->dev == dir->i_dev && entry->inode == dir->i_ino |
dev | 211 | fs/nfs/dir.c | entry->dev = 0; |
dev | 237 | fs/nfs/dir.c | entry->dev = dir->i_dev; |
dev | 250 | fs/nfs/dir.c | int dev; |
dev | 255 | fs/nfs/dir.c | dev = inode->i_dev; |
dev | 259 | fs/nfs/dir.c | dev = entry->dev; |
dev | 266 | fs/nfs/dir.c | if (entry->dev == dev && entry->fattr.fileid == fileid) |
dev | 267 | fs/nfs/dir.c | entry->dev = 0; |
dev | 275 | fs/nfs/dir.c | int dev = file->i_dev; |
dev | 281 | fs/nfs/dir.c | if (entry->dev == dev && entry->fattr.fileid == fileid) |
dev | 68 | fs/nfs/inode.c | dev_t dev = sb->s_dev; |
dev | 95 | fs/nfs/inode.c | sb->s_dev = dev; |
dev | 24 | fs/open.c | asmlinkage int sys_ustat(int dev, struct ustat * ubuf) |
dev | 107 | fs/proc/link.c | unsigned int dev,ino; |
dev | 115 | fs/proc/link.c | dev = inode->i_dev; |
dev | 118 | fs/proc/link.c | i = sprintf(buf,"[%04x]:%u", dev, ino); |
dev | 69 | fs/super.c | void sync_supers(dev_t dev) |
dev | 76 | fs/super.c | if (dev && sb->s_dev != dev) |
dev | 81 | fs/super.c | if (dev && (dev != sb->s_dev)) |
dev | 88 | fs/super.c | static struct super_block * get_super(dev_t dev) |
dev | 92 | fs/super.c | if (!dev) |
dev | 96 | fs/super.c | if (s->s_dev == dev) { |
dev | 98 | fs/super.c | if (s->s_dev == dev) |
dev | 106 | fs/super.c | void put_super(dev_t dev) |
dev | 110 | fs/super.c | if (dev == ROOT_DEV) { |
dev | 112 | fs/super.c | MAJOR(dev), MINOR(dev)); |
dev | 115 | fs/super.c | if (!(sb = get_super(dev))) |
dev | 119 | fs/super.c | MAJOR(dev), MINOR(dev)); |
dev | 126 | fs/super.c | static struct super_block * read_super(dev_t dev,char *name,int flags, |
dev | 132 | fs/super.c | if (!dev) |
dev | 134 | fs/super.c | check_disk_change(dev); |
dev | 135 | fs/super.c | s = get_super(dev); |
dev | 140 | fs/super.c | MAJOR(dev), MINOR(dev), name); |
dev | 149 | fs/super.c | s->s_dev = dev; |
dev | 155 | fs/super.c | s->s_dev = dev; |
dev | 188 | fs/super.c | static void put_unnamed_dev(dev_t dev) |
dev | 190 | fs/super.c | if (!dev) |
dev | 192 | fs/super.c | if (!unnamed_dev_in_use[dev]) { |
dev | 194 | fs/super.c | MAJOR(dev), MINOR(dev)); |
dev | 197 | fs/super.c | unnamed_dev_in_use[dev] = 0; |
dev | 200 | fs/super.c | static int do_umount(dev_t dev) |
dev | 205 | fs/super.c | if (dev==ROOT_DEV) { |
dev | 208 | fs/super.c | if (!(sb=get_super(dev))) |
dev | 217 | fs/super.c | if (!(sb=get_super(dev)) || !(sb->s_covered)) |
dev | 221 | fs/super.c | MAJOR(dev), MINOR(dev)); |
dev | 222 | fs/super.c | if (!fs_may_umount(dev, sb->s_mounted)) |
dev | 231 | fs/super.c | put_super(dev); |
dev | 249 | fs/super.c | dev_t dev; |
dev | 263 | fs/super.c | dev = inode->i_rdev; |
dev | 273 | fs/super.c | dev = inode->i_sb->s_dev; |
dev | 276 | fs/super.c | dummy_inode.i_rdev = dev; |
dev | 279 | fs/super.c | if (MAJOR(dev) >= MAX_BLKDEV) { |
dev | 283 | fs/super.c | if (!(retval = do_umount(dev)) && dev != ROOT_DEV) { |
dev | 284 | fs/super.c | fops = blkdev_fops[MAJOR(dev)]; |
dev | 287 | fs/super.c | if (MAJOR(dev) == UNNAMED_MAJOR) |
dev | 288 | fs/super.c | put_unnamed_dev(dev); |
dev | 294 | fs/super.c | fsync_dev(dev); |
dev | 307 | fs/super.c | static int do_mount(dev_t dev, const char * dir, char * type, int flags, void * data) |
dev | 324 | fs/super.c | if (!fs_may_mount(dev)) { |
dev | 328 | fs/super.c | sb = read_super(dev,type,flags,data,0); |
dev | 399 | fs/super.c | dev_t dev; |
dev | 436 | fs/super.c | dev = inode->i_rdev; |
dev | 437 | fs/super.c | if (MAJOR(dev) >= MAX_BLKDEV) { |
dev | 442 | fs/super.c | if (!(dev = get_unnamed_dev())) |
dev | 446 | fs/super.c | fops = blkdev_fops[MAJOR(dev)]; |
dev | 471 | fs/super.c | retval = do_mount(dev,dir_name,t,flags,(void *) page); |
dev | 64 | fs/xiafs/inode.c | int i, z, dev; |
dev | 66 | fs/xiafs/inode.c | dev=s->s_dev; |
dev | 69 | fs/xiafs/inode.c | set_blocksize(dev, BLOCK_SIZE); |
dev | 71 | fs/xiafs/inode.c | if (!(bh = bread(dev, 0, BLOCK_SIZE))) { |
dev | 85 | fs/xiafs/inode.c | dev); |
dev | 94 | fs/xiafs/inode.c | set_blocksize(dev, s->s_blocksize); |
dev | 95 | fs/xiafs/inode.c | bh = bread (dev, 0, s->s_blocksize); |
dev | 122 | fs/xiafs/inode.c | if (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s)))) |
dev | 132 | fs/xiafs/inode.c | if (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s)))) |
dev | 138 | fs/xiafs/inode.c | s->s_dev = dev; |
dev | 349 | include/linux/fs.h | extern int fs_may_mount(dev_t dev); |
dev | 350 | include/linux/fs.h | extern int fs_may_umount(dev_t dev, struct inode * mount_root); |
dev | 351 | include/linux/fs.h | extern int fs_may_remount_ro(dev_t dev); |
dev | 364 | include/linux/fs.h | extern void check_disk_change(dev_t dev); |
dev | 365 | include/linux/fs.h | extern void invalidate_inodes(dev_t dev); |
dev | 366 | include/linux/fs.h | extern void invalidate_buffers(dev_t dev); |
dev | 368 | include/linux/fs.h | extern void sync_inodes(dev_t dev); |
dev | 369 | include/linux/fs.h | extern void sync_dev(dev_t dev); |
dev | 370 | include/linux/fs.h | extern int fsync_dev(dev_t dev); |
dev | 371 | include/linux/fs.h | extern void sync_supers(dev_t dev); |
dev | 379 | include/linux/fs.h | extern int do_mknod(const char * filename, int mode, dev_t dev); |
dev | 388 | include/linux/fs.h | extern struct buffer_head * get_hash_table(dev_t dev, int block, int size); |
dev | 389 | include/linux/fs.h | extern struct buffer_head * getblk(dev_t dev, int block, int size); |
dev | 391 | include/linux/fs.h | extern void ll_rw_page(int rw, int dev, int nr, char * buffer); |
dev | 392 | include/linux/fs.h | extern void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buffer); |
dev | 394 | include/linux/fs.h | extern void set_blocksize(dev_t dev, int size); |
dev | 395 | include/linux/fs.h | extern struct buffer_head * bread(dev_t dev, int block, int size); |
dev | 396 | include/linux/fs.h | extern unsigned long bread_page(unsigned long addr,dev_t dev,int b[],int size,int prot); |
dev | 397 | include/linux/fs.h | extern struct buffer_head * breada(dev_t dev,int block,...); |
dev | 398 | include/linux/fs.h | extern void put_super(dev_t dev); |
dev | 172 | include/linux/iso_fs.h | extern int isofs_new_block(int dev); |
dev | 173 | include/linux/iso_fs.h | extern int isofs_free_block(int dev, int block); |
dev | 196 | include/linux/iso_fs.h | dev_t dev; /* And this matches */ |
dev | 212 | include/linux/iso_fs.h | extern struct buffer_head * leak_check_bread(int dev, int block, int size); |
dev | 113 | include/linux/msdos_fs.h | static inline struct buffer_head *msdos_sread(int dev,int sector,void **start) |
dev | 117 | include/linux/msdos_fs.h | if (!(bh = bread(dev,sector >> 1, 1024))) |
dev | 278 | include/linux/tpqic02.h | #define TP_DENS(dev) ((MINOR(dev) >> 1) & 0x07) /* tape density */ |
dev | 279 | include/linux/tpqic02.h | #define TP_UNIT(dev) ((MINOR(dev) >> 4) & 0x07) /* unit number */ |
dev | 280 | include/linux/tpqic02.h | #define TP_DIAGS(dev) (MINOR(dev) & 0x80) /* print excessive diagnostics */ |
dev | 117 | include/linux/xd.h | static int xd_reread_partitions (int dev); |
dev | 27 | kernel/blk_drv/blk.h | int dev; /* -1 if no request */ |
dev | 47 | kernel/blk_drv/blk.h | ((s1)->dev < (s2)->dev || (((s1)->dev == (s2)->dev && \ |
dev | 66 | kernel/blk_drv/blk.h | blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] ? \ |
dev | 67 | kernel/blk_drv/blk.h | ((blksize_size[MAJOR_NR][MINOR(CURRENT->dev)] >> 9) - 1) : \ |
dev | 76 | kernel/blk_drv/blk.h | extern void resetup_one_dev(struct gendisk *dev, int drive); |
dev | 85 | kernel/blk_drv/blk.h | extern int is_read_only(int dev); |
dev | 86 | kernel/blk_drv/blk.h | extern void set_device_ro(int dev,int flag); |
dev | 94 | kernel/blk_drv/blk.h | #define RO_IOCTLS(dev,where) \ |
dev | 96 | kernel/blk_drv/blk.h | set_device_ro((dev),get_fs_long((long *) (where))); return 0; \ |
dev | 98 | kernel/blk_drv/blk.h | if (!__err) put_fs_long(is_read_only(dev),(long *) (where)); return __err; } |
dev | 203 | kernel/blk_drv/blk.h | #define CURRENT_DEV DEVICE_NR(CURRENT->dev) |
dev | 242 | kernel/blk_drv/blk.h | printk("dev %04x, sector %d\n",req->dev,req->sector); |
dev | 264 | kernel/blk_drv/blk.h | DEVICE_OFF(req->dev); |
dev | 272 | kernel/blk_drv/blk.h | req->dev = -1; |
dev | 288 | kernel/blk_drv/blk.h | if (MAJOR(CURRENT->dev) != MAJOR_NR) \ |
dev | 843 | kernel/blk_drv/cdu31a.c | unsigned int dev; |
dev | 864 | kernel/blk_drv/cdu31a.c | if (!(CURRENT) || CURRENT->dev < 0) |
dev | 870 | kernel/blk_drv/cdu31a.c | dev = MINOR(CURRENT->dev); |
dev | 873 | kernel/blk_drv/cdu31a.c | if (dev != 0) |
dev | 1137 | kernel/blk_drv/cdu31a.c | unsigned int dev; |
dev | 1148 | kernel/blk_drv/cdu31a.c | dev = MINOR(inode->i_rdev) >> 6; |
dev | 1149 | kernel/blk_drv/cdu31a.c | if (dev != 0) |
dev | 239 | kernel/blk_drv/floppy.c | (CURRENT->dev)) |
dev | 680 | kernel/blk_drv/floppy.c | int drive = MINOR(CURRENT->dev); |
dev | 998 | kernel/blk_drv/floppy.c | if (CURRENT && CURRENT->dev < 0) return; |
dev | 1012 | kernel/blk_drv/floppy.c | if (MAJOR(CURRENT->dev) != MAJOR_NR) |
dev | 36 | kernel/blk_drv/genhd.c | static void extended_partition(struct gendisk *hd, int dev) |
dev | 43 | kernel/blk_drv/genhd.c | first_sector = hd->part[MINOR(dev)].start_sect; |
dev | 49 | kernel/blk_drv/genhd.c | if (!(bh = bread(dev,0,1024))) |
dev | 84 | kernel/blk_drv/genhd.c | dev = ((hd->major) << 8) | current_minor; |
dev | 93 | kernel/blk_drv/genhd.c | static void check_partition(struct gendisk *hd, unsigned int dev) |
dev | 105 | kernel/blk_drv/genhd.c | first_sector = hd->part[MINOR(dev)].start_sect; |
dev | 106 | kernel/blk_drv/genhd.c | if (!(bh = bread(dev,0,1024))) { |
dev | 107 | kernel/blk_drv/genhd.c | printk(" unable to read partition table of device %04x\n",dev); |
dev | 160 | kernel/blk_drv/genhd.c | void resetup_one_dev(struct gendisk *dev, int drive) |
dev | 163 | kernel/blk_drv/genhd.c | int start = drive<<dev->minor_shift; |
dev | 164 | kernel/blk_drv/genhd.c | int j = start + dev->max_p; |
dev | 165 | kernel/blk_drv/genhd.c | int major = dev->major << 8; |
dev | 167 | kernel/blk_drv/genhd.c | current_minor = 1+(drive<<dev->minor_shift); |
dev | 168 | kernel/blk_drv/genhd.c | check_partition(dev, major+(drive<<dev->minor_shift)); |
dev | 171 | kernel/blk_drv/genhd.c | dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9); |
dev | 174 | kernel/blk_drv/genhd.c | static void setup_dev(struct gendisk *dev) |
dev | 177 | kernel/blk_drv/genhd.c | int j = dev->max_nr * dev->max_p; |
dev | 178 | kernel/blk_drv/genhd.c | int major = dev->major << 8; |
dev | 183 | kernel/blk_drv/genhd.c | dev->part[i].start_sect = 0; |
dev | 184 | kernel/blk_drv/genhd.c | dev->part[i].nr_sects = 0; |
dev | 186 | kernel/blk_drv/genhd.c | dev->init(); |
dev | 187 | kernel/blk_drv/genhd.c | for (drive=0 ; drive<dev->nr_real ; drive++) { |
dev | 188 | kernel/blk_drv/genhd.c | current_minor = 1+(drive<<dev->minor_shift); |
dev | 189 | kernel/blk_drv/genhd.c | check_partition(dev, major+(drive<<dev->minor_shift)); |
dev | 192 | kernel/blk_drv/genhd.c | dev->sizes[i] = dev->part[i].nr_sects >> (BLOCK_SIZE_BITS - 9); |
dev | 193 | kernel/blk_drv/genhd.c | blk_size[dev->major] = dev->sizes; |
dev | 289 | kernel/blk_drv/hd.c | int dev; |
dev | 293 | kernel/blk_drv/hd.c | dev = MINOR(CURRENT->dev) >> 6; |
dev | 296 | kernel/blk_drv/hd.c | recalibrate[dev] = 1; |
dev | 300 | kernel/blk_drv/hd.c | recalibrate[dev] = 1; |
dev | 350 | kernel/blk_drv/hd.c | MINOR(CURRENT->dev), CURRENT->sector, i, CURRENT-> |
dev | 451 | kernel/blk_drv/hd.c | unsigned int block,dev; |
dev | 455 | kernel/blk_drv/hd.c | if (CURRENT && CURRENT->dev < 0) return; |
dev | 463 | kernel/blk_drv/hd.c | dev = MINOR(CURRENT->dev); |
dev | 466 | kernel/blk_drv/hd.c | if (dev >= (NR_HD<<6) || block >= hd[dev].nr_sects) { |
dev | 469 | kernel/blk_drv/hd.c | block, hd[dev].nr_sects); |
dev | 474 | kernel/blk_drv/hd.c | block += hd[dev].start_sect; |
dev | 475 | kernel/blk_drv/hd.c | dev >>= 6; |
dev | 476 | kernel/blk_drv/hd.c | sec = block % hd_info[dev].sect + 1; |
dev | 477 | kernel/blk_drv/hd.c | track = block / hd_info[dev].sect; |
dev | 478 | kernel/blk_drv/hd.c | head = track % hd_info[dev].head; |
dev | 479 | kernel/blk_drv/hd.c | cyl = track / hd_info[dev].head; |
dev | 482 | kernel/blk_drv/hd.c | dev, cyl, head, sec, CURRENT->buffer); |
dev | 494 | kernel/blk_drv/hd.c | if (recalibrate[dev]) { |
dev | 495 | kernel/blk_drv/hd.c | recalibrate[dev] = 0; |
dev | 496 | kernel/blk_drv/hd.c | hd_out(dev,hd_info[dev].sect,0,0,0,WIN_RESTORE,&recal_intr); |
dev | 503 | kernel/blk_drv/hd.c | hd_out(dev,nsect,sec,head,cyl,WIN_WRITE,&write_intr); |
dev | 516 | kernel/blk_drv/hd.c | hd_out(dev,nsect,sec,head,cyl,WIN_READ,&read_intr); |
dev | 529 | kernel/blk_drv/hd.c | int dev, err; |
dev | 533 | kernel/blk_drv/hd.c | dev = MINOR(inode->i_rdev) >> 6; |
dev | 534 | kernel/blk_drv/hd.c | if (dev >= NR_HD) |
dev | 542 | kernel/blk_drv/hd.c | put_fs_byte(hd_info[dev].head, |
dev | 544 | kernel/blk_drv/hd.c | put_fs_byte(hd_info[dev].sect, |
dev | 546 | kernel/blk_drv/hd.c | put_fs_word(hd_info[dev].cyl, |
dev | 763 | kernel/blk_drv/hd.c | static int revalidate_hddisk(int dev, int maxusage) |
dev | 771 | kernel/blk_drv/hd.c | target = DEVICE_NR(MINOR(dev)); |
dev | 76 | kernel/blk_drv/ll_rw_blk.c | int is_read_only(int dev) |
dev | 80 | kernel/blk_drv/ll_rw_blk.c | major = MAJOR(dev); |
dev | 81 | kernel/blk_drv/ll_rw_blk.c | minor = MINOR(dev); |
dev | 86 | kernel/blk_drv/ll_rw_blk.c | void set_device_ro(int dev,int flag) |
dev | 90 | kernel/blk_drv/ll_rw_blk.c | major = MAJOR(dev); |
dev | 91 | kernel/blk_drv/ll_rw_blk.c | minor = MINOR(dev); |
dev | 102 | kernel/blk_drv/ll_rw_blk.c | static void add_request(struct blk_dev_struct * dev, struct request * req) |
dev | 110 | kernel/blk_drv/ll_rw_blk.c | if (!(tmp = dev->current_request)) { |
dev | 111 | kernel/blk_drv/ll_rw_blk.c | dev->current_request = req; |
dev | 112 | kernel/blk_drv/ll_rw_blk.c | (dev->request_fn)(); |
dev | 126 | kernel/blk_drv/ll_rw_blk.c | if(MAJOR(req->dev) == 8 || |
dev | 127 | kernel/blk_drv/ll_rw_blk.c | MAJOR(req->dev) == 9 || |
dev | 128 | kernel/blk_drv/ll_rw_blk.c | MAJOR(req->dev) == 11) |
dev | 129 | kernel/blk_drv/ll_rw_blk.c | (dev->request_fn)(); |
dev | 176 | kernel/blk_drv/ll_rw_blk.c | if (req->dev == bh->b_dev && |
dev | 188 | kernel/blk_drv/ll_rw_blk.c | else if ( req->dev == bh->b_dev && |
dev | 217 | kernel/blk_drv/ll_rw_blk.c | if (req->dev < 0) |
dev | 231 | kernel/blk_drv/ll_rw_blk.c | req->dev = bh->b_dev; |
dev | 246 | kernel/blk_drv/ll_rw_blk.c | void ll_rw_page(int rw, int dev, int page, char * buffer) |
dev | 249 | kernel/blk_drv/ll_rw_blk.c | unsigned int major = MAJOR(dev); |
dev | 252 | kernel/blk_drv/ll_rw_blk.c | printk("Trying to read nonexistent block-device %04x (%d)\n",dev,page*8); |
dev | 257 | kernel/blk_drv/ll_rw_blk.c | if (rw == WRITE && is_read_only(dev)) { |
dev | 258 | kernel/blk_drv/ll_rw_blk.c | printk("Can't page to read-only device 0x%X\n",dev); |
dev | 265 | kernel/blk_drv/ll_rw_blk.c | if (req->dev<0) |
dev | 273 | kernel/blk_drv/ll_rw_blk.c | req->dev = dev; |
dev | 299 | kernel/blk_drv/ll_rw_blk.c | struct blk_dev_struct * dev; |
dev | 349 | kernel/blk_drv/ll_rw_blk.c | plug.dev = -1; |
dev | 362 | kernel/blk_drv/ll_rw_blk.c | dev = major+blk_dev; |
dev | 363 | kernel/blk_drv/ll_rw_blk.c | (dev->request_fn)(); |
dev | 368 | kernel/blk_drv/ll_rw_blk.c | void ll_rw_swap_file(int rw, int dev, unsigned int *b, int nb, char *buf) |
dev | 373 | kernel/blk_drv/ll_rw_blk.c | unsigned int major = MAJOR(dev); |
dev | 384 | kernel/blk_drv/ll_rw_blk.c | if (rw == WRITE && is_read_only(dev)) { |
dev | 385 | kernel/blk_drv/ll_rw_blk.c | printk("Can't swap to read-only device 0x%X\n",dev); |
dev | 396 | kernel/blk_drv/ll_rw_blk.c | if (req->dev<0) |
dev | 403 | kernel/blk_drv/ll_rw_blk.c | req->dev = dev; |
dev | 424 | kernel/blk_drv/ll_rw_blk.c | request[i].dev = -1; |
dev | 521 | kernel/blk_drv/mcd.c | unsigned int block,dev; |
dev | 526 | kernel/blk_drv/mcd.c | dev = MINOR(CURRENT->dev); |
dev | 42 | kernel/blk_drv/ramdisk.c | if ((MINOR(CURRENT->dev) != MINOR_RAMDISK) || |
dev | 796 | kernel/blk_drv/scsi/aha1542.c | int aha1542_biosparam(int size, int dev, int * ip) |
dev | 489 | kernel/blk_drv/scsi/aha1740.c | int aha1740_biosparam(int size, int dev, int* ip) |
dev | 379 | kernel/blk_drv/scsi/constants.c | int dev = SCpnt->request.dev; |
dev | 413 | kernel/blk_drv/scsi/constants.c | printk( "%s%x: sense key %s\n", devclass, dev, snstext[sense_buffer[2] & 0x0f]); |
dev | 415 | kernel/blk_drv/scsi/constants.c | printk("%s%x: sns = %2x %2x\n", devclass, dev, sense_buffer[0], sense_buffer[2]); |
dev | 443 | kernel/blk_drv/scsi/constants.c | printk("%s%x: old sense key %s\n", devclass, dev, snstext[sense_buffer[0] & 0x0f]); |
dev | 446 | kernel/blk_drv/scsi/constants.c | printk("%s%x: sns = %2x %2x\n", devclass, dev, sense_buffer[0], sense_buffer[2]); |
dev | 1468 | kernel/blk_drv/scsi/fdomain.c | int fdomain_16x0_biosparam( int size, int dev, int *info_array ) |
dev | 1509 | kernel/blk_drv/scsi/fdomain.c | drive = MINOR(dev) / 16; |
dev | 156 | kernel/blk_drv/scsi/scsi.c | SCpnt->request.dev = 0xfffe; |
dev | 168 | kernel/blk_drv/scsi/scsi.c | int host_nr , dev, lun, type; |
dev | 183 | kernel/blk_drv/scsi/scsi.c | for (dev = 0; dev < 8; ++dev) |
dev | 184 | kernel/blk_drv/scsi/scsi.c | if (scsi_hosts[host_nr].this_id != dev) |
dev | 196 | kernel/blk_drv/scsi/scsi.c | scsi_devices[NR_SCSI_DEVICES].id = dev; |
dev | 212 | kernel/blk_drv/scsi/scsi.c | SCmd.target = dev; |
dev | 215 | kernel/blk_drv/scsi/scsi.c | SCmd.request.dev = 0xffff; /* Mark not busy */ |
dev | 227 | kernel/blk_drv/scsi/scsi.c | while (SCmd.request.dev != 0xfffe); |
dev | 229 | kernel/blk_drv/scsi/scsi.c | printk("scsi: scan SCSIS id %d lun %d\n", dev, lun); |
dev | 262 | kernel/blk_drv/scsi/scsi.c | SCmd.request.dev = 0xffff; /* Mark not busy */ |
dev | 269 | kernel/blk_drv/scsi/scsi.c | while (SCmd.request.dev != 0xfffe); |
dev | 334 | kernel/blk_drv/scsi/scsi.c | host_nr , dev, lun); |
dev | 339 | kernel/blk_drv/scsi/scsi.c | host_nr , dev, lun); |
dev | 345 | kernel/blk_drv/scsi/scsi.c | host_nr , dev, lun); |
dev | 396 | kernel/blk_drv/scsi/scsi.c | SCmd.request.dev = 0xffff; /* Mark not busy */ |
dev | 403 | kernel/blk_drv/scsi/scsi.c | while (SCmd.request.dev != 0xfffe); |
dev | 493 | kernel/blk_drv/scsi/scsi.c | if (req && req->dev <= 0) |
dev | 501 | kernel/blk_drv/scsi/scsi.c | if(SCpnt->request.dev < 0) break; |
dev | 512 | kernel/blk_drv/scsi/scsi.c | req->dev = -1; |
dev | 514 | kernel/blk_drv/scsi/scsi.c | SCpnt->request.dev = 0xffff; /* Busy, but no request */ |
dev | 536 | kernel/blk_drv/scsi/scsi.c | int host, dev = -1; |
dev | 547 | kernel/blk_drv/scsi/scsi.c | if (req && (dev = req->dev) <= 0) return NULL; |
dev | 557 | kernel/blk_drv/scsi/scsi.c | if(SCpnt->request.dev < 0) break; |
dev | 563 | kernel/blk_drv/scsi/scsi.c | if (req && ((req->dev < 0) || (req->dev != dev))) { |
dev | 567 | kernel/blk_drv/scsi/scsi.c | if (!SCpnt || SCpnt->request.dev >= 0) /* Might have changed */ |
dev | 577 | kernel/blk_drv/scsi/scsi.c | (SCwait->request.dev > 0)); |
dev | 581 | kernel/blk_drv/scsi/scsi.c | req->dev = -1; |
dev | 584 | kernel/blk_drv/scsi/scsi.c | SCpnt->request.dev = 0xffff; /* Busy */ |
dev | 1259 | kernel/blk_drv/scsi/scsi.c | if ((SCpnt1->request.dev > 0) && |
dev | 1513 | kernel/blk_drv/scsi/scsi.c | SCpnt->request.dev = -1; /* Mark not busy */ |
dev | 442 | kernel/blk_drv/scsi/scsi.h | printk("dev %04x, sector %d\n",req->dev,req->sector); |
dev | 467 | kernel/blk_drv/scsi/scsi.h | DEVICE_OFF(req->dev); |
dev | 474 | kernel/blk_drv/scsi/scsi.h | req->dev = -1; |
dev | 490 | kernel/blk_drv/scsi/scsi.h | if (MAJOR(CURRENT->dev) != MAJOR_NR) \ |
dev | 49 | kernel/blk_drv/scsi/scsi_debug.c | if ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1]; \ |
dev | 55 | kernel/blk_drv/scsi/scsi_debug.c | if (bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\ |
dev | 61 | kernel/blk_drv/scsi/scsi_debug.c | if ((SCpnt->request.dev & 0xfff0) != ((target + NR_REAL) << 4) +(MAJOR_NR << 8)){ \ |
dev | 62 | kernel/blk_drv/scsi/scsi_debug.c | printk("Dev #s %x %x ",SCpnt->request.dev, target); \ |
dev | 70 | kernel/blk_drv/scsi/scsi_debug.c | if ((SCpnt->request.dev & 0xf) > npart) panic ("Bad partition"); \ |
dev | 71 | kernel/blk_drv/scsi/scsi_debug.c | if ((SCpnt->request.dev & 0xf) != 0) start = starts[(SCpnt->request.dev & 0xf) - 1]; \ |
dev | 80 | kernel/blk_drv/scsi/scsi_debug.c | if (SCpnt->request.bh->b_dev != SCpnt->request.dev) panic ("Bad bh target");\ |
dev | 203 | kernel/blk_drv/scsi/scsi_debug.c | if(NR_REAL < 0) NR_REAL = (SCpnt->request.dev >> 4) & 0x0f; |
dev | 28 | kernel/blk_drv/scsi/scsi_ioctl.c | static int ioctl_probe(int dev, void *buffer) |
dev | 34 | kernel/blk_drv/scsi/scsi_ioctl.c | if ((temp = scsi_hosts[dev].present) && buffer) { |
dev | 36 | kernel/blk_drv/scsi/scsi_ioctl.c | string = scsi_hosts[dev].info(); |
dev | 79 | kernel/blk_drv/scsi/scsi_ioctl.c | req->dev = 0xfffe; /* Busy, but indicate request done */ |
dev | 89 | kernel/blk_drv/scsi/scsi_ioctl.c | static int ioctl_internal_command(Scsi_Device *dev, char * cmd) |
dev | 94 | kernel/blk_drv/scsi/scsi_ioctl.c | host = dev->host_no; |
dev | 96 | kernel/blk_drv/scsi/scsi_ioctl.c | SCpnt = allocate_device(NULL, dev->index, 1); |
dev | 101 | kernel/blk_drv/scsi/scsi_ioctl.c | if (SCpnt->request.dev != 0xfffe){ |
dev | 104 | kernel/blk_drv/scsi/scsi_ioctl.c | while (SCpnt->request.dev != 0xfffe) schedule(); |
dev | 110 | kernel/blk_drv/scsi/scsi_ioctl.c | if(cmd[0] == ALLOW_MEDIUM_REMOVAL) dev->lockable = 0; |
dev | 114 | kernel/blk_drv/scsi/scsi_ioctl.c | if(dev->removable){ |
dev | 119 | kernel/blk_drv/scsi/scsi_ioctl.c | if (dev->removable){ |
dev | 120 | kernel/blk_drv/scsi/scsi_ioctl.c | dev->changed = 1; |
dev | 127 | kernel/blk_drv/scsi/scsi_ioctl.c | dev->host_no, |
dev | 128 | kernel/blk_drv/scsi/scsi_ioctl.c | dev->id, |
dev | 129 | kernel/blk_drv/scsi/scsi_ioctl.c | dev->lun, |
dev | 139 | kernel/blk_drv/scsi/scsi_ioctl.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 144 | kernel/blk_drv/scsi/scsi_ioctl.c | static int ioctl_command(Scsi_Device *dev, void *buffer) |
dev | 175 | kernel/blk_drv/scsi/scsi_ioctl.c | host = dev->host_no; |
dev | 176 | kernel/blk_drv/scsi/scsi_ioctl.c | cmd[1] = ( cmd[1] & 0x1f ) | (dev->lun << 5); |
dev | 180 | kernel/blk_drv/scsi/scsi_ioctl.c | SCpnt = allocate_device(NULL, dev->index, 1); |
dev | 186 | kernel/blk_drv/scsi/scsi_ioctl.c | if (SCpnt->request.dev != 0xfffe){ |
dev | 189 | kernel/blk_drv/scsi/scsi_ioctl.c | while (SCpnt->request.dev != 0xfffe) schedule(); |
dev | 197 | kernel/blk_drv/scsi/scsi_ioctl.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 204 | kernel/blk_drv/scsi/scsi_ioctl.c | printk("scsi_ioctl : device %d. command = ", dev->id); |
dev | 226 | kernel/blk_drv/scsi/scsi_ioctl.c | int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) |
dev | 230 | kernel/blk_drv/scsi/scsi_ioctl.c | if ((cmd != 0 && dev->index > NR_SCSI_DEVICES)) |
dev | 232 | kernel/blk_drv/scsi/scsi_ioctl.c | if ((cmd == 0 && dev->host_no > max_scsi_hosts)) |
dev | 238 | kernel/blk_drv/scsi/scsi_ioctl.c | put_fs_long(dev->id + (dev->lun << 8) + |
dev | 239 | kernel/blk_drv/scsi/scsi_ioctl.c | (dev->host_no << 16), (unsigned long *) arg); |
dev | 242 | kernel/blk_drv/scsi/scsi_ioctl.c | return ioctl_probe(dev->host_no, arg); |
dev | 244 | kernel/blk_drv/scsi/scsi_ioctl.c | return ioctl_command((Scsi_Device *) dev, arg); |
dev | 246 | kernel/blk_drv/scsi/scsi_ioctl.c | if (!dev->removable || !dev->lockable) return 0; |
dev | 248 | kernel/blk_drv/scsi/scsi_ioctl.c | scsi_cmd[1] = dev->lun << 5; |
dev | 251 | kernel/blk_drv/scsi/scsi_ioctl.c | return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd); |
dev | 254 | kernel/blk_drv/scsi/scsi_ioctl.c | if (!dev->removable || !dev->lockable) return 0; |
dev | 256 | kernel/blk_drv/scsi/scsi_ioctl.c | scsi_cmd[1] = dev->lun << 5; |
dev | 259 | kernel/blk_drv/scsi/scsi_ioctl.c | return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd); |
dev | 262 | kernel/blk_drv/scsi/scsi_ioctl.c | scsi_cmd[1] = dev->lun << 5; |
dev | 265 | kernel/blk_drv/scsi/scsi_ioctl.c | return ioctl_internal_command((Scsi_Device *) dev, scsi_cmd); |
dev | 277 | kernel/blk_drv/scsi/scsi_ioctl.c | int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg) { |
dev | 282 | kernel/blk_drv/scsi/scsi_ioctl.c | tmp = scsi_ioctl (dev, cmd, arg); |
dev | 15 | kernel/blk_drv/scsi/scsi_ioctl.h | extern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg); |
dev | 16 | kernel/blk_drv/scsi/scsi_ioctl.h | extern int kernel_scsi_ioctl (Scsi_Device *dev, int cmd, void *arg); |
dev | 146 | kernel/blk_drv/scsi/sd.c | printk("sd%d : rw_intr(%d, %x)\n", MINOR(SCpnt->request.dev), SCpnt->host, result); |
dev | 158 | kernel/blk_drv/scsi/sd.c | printk("sd%d : %d sectors remain.\n", MINOR(SCpnt->request.dev), SCpnt->request.nr_sectors); |
dev | 201 | kernel/blk_drv/scsi/sd.c | MINOR(SCpnt->request.dev)); |
dev | 254 | kernel/blk_drv/scsi/sd.c | if rscsi_disks[DEVICE_NR(SCpnt->request.dev)].remap |
dev | 268 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1; |
dev | 284 | kernel/blk_drv/scsi/sd.c | if (rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten) { |
dev | 285 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(SCpnt->request.dev)].ten = 0; |
dev | 294 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host_no, |
dev | 295 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id, |
dev | 296 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result); |
dev | 319 | kernel/blk_drv/scsi/sd.c | if (CURRENT != NULL && CURRENT->dev == -1) { |
dev | 340 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); |
dev | 358 | kernel/blk_drv/scsi/sd.c | rscsi_disks[DEVICE_NR(MINOR(req->dev))].device->index); |
dev | 383 | kernel/blk_drv/scsi/sd.c | int dev, block, this_count; |
dev | 389 | kernel/blk_drv/scsi/sd.c | if(SCpnt->request.dev <= 0) { |
dev | 394 | kernel/blk_drv/scsi/sd.c | dev = MINOR(SCpnt->request.dev); |
dev | 399 | kernel/blk_drv/scsi/sd.c | printk("Doing sd request, dev = %d, block = %d\n", dev, block); |
dev | 402 | kernel/blk_drv/scsi/sd.c | if (dev >= (NR_SD << 4) || block + SCpnt->request.nr_sectors > sd[dev].nr_sects) |
dev | 408 | kernel/blk_drv/scsi/sd.c | block += sd[dev].start_sect; |
dev | 409 | kernel/blk_drv/scsi/sd.c | dev = DEVICE_NR(dev); |
dev | 411 | kernel/blk_drv/scsi/sd.c | if (rscsi_disks[dev].device->changed) |
dev | 422 | kernel/blk_drv/scsi/sd.c | printk("sd%d : real dev = /dev/sd%d, block = %d\n", MINOR(SCpnt->request.dev), dev, block); |
dev | 428 | kernel/blk_drv/scsi/sd.c | if (!rscsi_disks[dev].device->writeable) |
dev | 481 | kernel/blk_drv/scsi/sd.c | this_count_max = (rscsi_disks[dev].ten ? 0xffff : 0xff); |
dev | 559 | kernel/blk_drv/scsi/sd.c | printk("sd%d : %s %d/%d 512 byte blocks.\n", MINOR(SCpnt->request.dev), |
dev | 566 | kernel/blk_drv/scsi/sd.c | if (rscsi_disks[dev].sector_size == 1024){ |
dev | 573 | kernel/blk_drv/scsi/sd.c | if (rscsi_disks[dev].sector_size == 256){ |
dev | 578 | kernel/blk_drv/scsi/sd.c | if (((this_count > 0xff) || (block > 0x1fffff)) && rscsi_disks[dev].ten) |
dev | 610 | kernel/blk_drv/scsi/sd.c | SCpnt->transfersize = rscsi_disks[dev].sector_size; |
dev | 614 | kernel/blk_drv/scsi/sd.c | this_count * rscsi_disks[dev].sector_size, |
dev | 656 | kernel/blk_drv/scsi/sd.c | req->dev = 0xfffe; /* Busy, but indicate request done */ |
dev | 690 | kernel/blk_drv/scsi/sd.c | SCpnt->request.dev = 0xffff; /* Mark as really busy again */ |
dev | 699 | kernel/blk_drv/scsi/sd.c | while(SCpnt->request.dev != 0xfffe); |
dev | 714 | kernel/blk_drv/scsi/sd.c | SCpnt->request.dev = 0xffff; /* Mark as really busy again */ |
dev | 723 | kernel/blk_drv/scsi/sd.c | while(SCpnt->request.dev != 0xfffe); |
dev | 741 | kernel/blk_drv/scsi/sd.c | SCpnt->request.dev = 0xffff; /* Mark as really busy again */ |
dev | 751 | kernel/blk_drv/scsi/sd.c | while(SCpnt->request.dev != 0xfffe); |
dev | 753 | kernel/blk_drv/scsi/sd.c | if (SCpnt->request.dev != 0xfffe){ |
dev | 756 | kernel/blk_drv/scsi/sd.c | while (SCpnt->request.dev != 0xfffe) schedule(); |
dev | 764 | kernel/blk_drv/scsi/sd.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 925 | kernel/blk_drv/scsi/sd.c | int revalidate_scsidisk(int dev, int maxusage){ |
dev | 932 | kernel/blk_drv/scsi/sd.c | target = DEVICE_NR(MINOR(dev)); |
dev | 19 | kernel/blk_drv/scsi/sd_ioctl.c | int dev = inode->i_rdev; |
dev | 30 | kernel/blk_drv/scsi/sd_ioctl.c | host = rscsi_disks[MINOR(dev) >> 4].device->host_no; |
dev | 35 | kernel/blk_drv/scsi/sd_ioctl.c | scsi_hosts[host].bios_param(rscsi_disks[MINOR(dev) >> 4].capacity, |
dev | 36 | kernel/blk_drv/scsi/sd_ioctl.c | dev, |
dev | 63 | kernel/blk_drv/scsi/sd_ioctl.c | return revalidate_scsidisk(dev, 1); |
dev | 65 | kernel/blk_drv/scsi/sd_ioctl.c | return scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg); |
dev | 1588 | kernel/blk_drv/scsi/seagate.c | int seagate_st0x_biosparam(int size, int dev, int* ip) { |
dev | 1595 | kernel/blk_drv/scsi/seagate.c | disk = rscsi_disks[MINOR(dev) >> 4].device; |
dev | 212 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1; |
dev | 221 | kernel/blk_drv/scsi/sr.c | if (scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten) { |
dev | 222 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(SCpnt->request.dev)].ten = 0; |
dev | 246 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host_no, |
dev | 247 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id, |
dev | 248 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun, |
dev | 294 | kernel/blk_drv/scsi/sr.c | if (CURRENT != NULL && CURRENT->dev == -1) { |
dev | 303 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device->index, 0); |
dev | 322 | kernel/blk_drv/scsi/sr.c | scsi_CDs[DEVICE_NR(MINOR(req->dev))].device->index); |
dev | 348 | kernel/blk_drv/scsi/sr.c | unsigned int dev, block, realcount; |
dev | 355 | kernel/blk_drv/scsi/sr.c | if(SCpnt->request.dev <= 0) { |
dev | 360 | kernel/blk_drv/scsi/sr.c | dev = MINOR(SCpnt->request.dev); |
dev | 365 | kernel/blk_drv/scsi/sr.c | if (dev >= NR_SR) |
dev | 373 | kernel/blk_drv/scsi/sr.c | if (!scsi_CDs[dev].use) |
dev | 381 | kernel/blk_drv/scsi/sr.c | if (scsi_CDs[dev].device->changed) |
dev | 435 | kernel/blk_drv/scsi/sr.c | this_count_max = (scsi_CDs[dev].ten ? 0xffff : 0xff) << 4; |
dev | 563 | kernel/blk_drv/scsi/sr.c | if (scsi_CDs[dev].sector_size == 2048) |
dev | 570 | kernel/blk_drv/scsi/sr.c | if (scsi_CDs[dev].sector_size == 512) realcount = realcount << 2; |
dev | 572 | kernel/blk_drv/scsi/sr.c | if (((realcount > 0xff) || (block > 0x1fffff)) && scsi_CDs[dev].ten) |
dev | 577 | kernel/blk_drv/scsi/sr.c | this_count = realcount * (scsi_CDs[dev].sector_size >> 9); |
dev | 594 | kernel/blk_drv/scsi/sr.c | this_count = realcount * (scsi_CDs[dev].sector_size >> 9); |
dev | 610 | kernel/blk_drv/scsi/sr.c | realcount * scsi_CDs[dev].sector_size, |
dev | 631 | kernel/blk_drv/scsi/sr.c | req->dev = 0xfffe; /* Busy, but indicate request done */ |
dev | 654 | kernel/blk_drv/scsi/sr.c | SCpnt->request.dev = 0xffff; /* Mark as really busy */ |
dev | 662 | kernel/blk_drv/scsi/sr.c | while(SCpnt->request.dev != 0xfffe); |
dev | 664 | kernel/blk_drv/scsi/sr.c | if (SCpnt->request.dev != 0xfffe){ |
dev | 667 | kernel/blk_drv/scsi/sr.c | while (SCpnt->request.dev != 0xfffe) schedule(); |
dev | 675 | kernel/blk_drv/scsi/sr.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 18 | kernel/blk_drv/scsi/sr_ioctl.c | extern int scsi_ioctl (Scsi_Device *dev, int cmd, void *arg); |
dev | 26 | kernel/blk_drv/scsi/sr_ioctl.c | req->dev = 0xfffe; /* Busy, but indicate request done */ |
dev | 51 | kernel/blk_drv/scsi/sr_ioctl.c | if (SCpnt->request.dev != 0xfffe){ |
dev | 54 | kernel/blk_drv/scsi/sr_ioctl.c | while (SCpnt->request.dev != 0xfffe) schedule(); |
dev | 86 | kernel/blk_drv/scsi/sr_ioctl.c | SCpnt->request.dev = -1; /* Deallocate */ |
dev | 96 | kernel/blk_drv/scsi/sr_ioctl.c | int dev = inode->i_rdev; |
dev | 99 | kernel/blk_drv/scsi/sr_ioctl.c | target = MINOR(dev); |
dev | 351 | kernel/blk_drv/scsi/sr_ioctl.c | RO_IOCTLS(dev,arg); |
dev | 107 | kernel/blk_drv/scsi/st.c | if ((st_nbr = SCpnt->request.dev) < NR_ST && st_nbr >= 0) { |
dev | 115 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; |
dev | 117 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = 0xffff; |
dev | 131 | kernel/blk_drv/scsi/st.c | int dev = SCpnt->request.dev; |
dev | 139 | kernel/blk_drv/scsi/st.c | printk("st%d: Error: %x\n", dev, result); |
dev | 151 | kernel/blk_drv/scsi/st.c | static void write_behind_check(int dev) |
dev | 154 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->last_result < 0) { |
dev | 155 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing); |
dev | 156 | kernel/blk_drv/scsi/st.c | sleep_on( &scsi_tapes[dev].waiting ); |
dev | 157 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing = (- scsi_tapes[dev].buffer->writing); |
dev | 161 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->writing < scsi_tapes[dev].buffer->buffer_bytes) |
dev | 162 | kernel/blk_drv/scsi/st.c | memcpy(scsi_tapes[dev].buffer->b_data, |
dev | 163 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data + scsi_tapes[dev].buffer->writing, |
dev | 164 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes - |
dev | 165 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing); |
dev | 166 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes -= scsi_tapes[dev].buffer->writing; |
dev | 167 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing = 0; |
dev | 175 | kernel/blk_drv/scsi/st.c | static int flush_write_buffer(int dev) |
dev | 183 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->writing) { |
dev | 184 | kernel/blk_drv/scsi/st.c | write_behind_check(dev); |
dev | 185 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->last_result) { |
dev | 187 | kernel/blk_drv/scsi/st.c | printk("st%d: Async write error %x.\n", dev, |
dev | 188 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->last_result); |
dev | 196 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].dirty==1) { |
dev | 197 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 199 | kernel/blk_drv/scsi/st.c | offset = scsi_tapes[dev].buffer->buffer_bytes; |
dev | 200 | kernel/blk_drv/scsi/st.c | transfer = ((offset + scsi_tapes[dev].block_size - 1) / |
dev | 201 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size) * scsi_tapes[dev].block_size; |
dev | 203 | kernel/blk_drv/scsi/st.c | printk("st%d: Flushing %d bytes.\n", dev, transfer); |
dev | 205 | kernel/blk_drv/scsi/st.c | memset(scsi_tapes[dev].buffer->b_data + offset, 0, transfer - offset); |
dev | 211 | kernel/blk_drv/scsi/st.c | blks = transfer / scsi_tapes[dev].block_size; |
dev | 215 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 217 | kernel/blk_drv/scsi/st.c | (void *) cmd, scsi_tapes[dev].buffer->b_data, transfer, |
dev | 220 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 223 | kernel/blk_drv/scsi/st.c | printk("st%d: Error on flush:\n", dev); |
dev | 230 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].dirty = 0; |
dev | 231 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = 0; |
dev | 233 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 244 | kernel/blk_drv/scsi/st.c | int dev; |
dev | 247 | kernel/blk_drv/scsi/st.c | dev = MINOR(inode->i_rdev) & 127; |
dev | 249 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].rw == 2) /* Writing */ |
dev | 250 | kernel/blk_drv/scsi/st.c | return flush_write_buffer(dev); |
dev | 252 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 255 | kernel/blk_drv/scsi/st.c | backspace = (scsi_tapes[dev].buffer->buffer_bytes + |
dev | 256 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer) / scsi_tapes[dev].block_size - |
dev | 257 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->read_pointer + scsi_tapes[dev].block_size - 1) / |
dev | 258 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size; |
dev | 259 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = 0; |
dev | 260 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer = 0; |
dev | 265 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 0; |
dev | 266 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 0; |
dev | 277 | kernel/blk_drv/scsi/st.c | int dev; |
dev | 283 | kernel/blk_drv/scsi/st.c | dev = MINOR(inode->i_rdev) & 127; |
dev | 284 | kernel/blk_drv/scsi/st.c | if (dev >= NR_ST) |
dev | 286 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].in_use) { |
dev | 287 | kernel/blk_drv/scsi/st.c | printk("st%d: Device already in use.\n", dev); |
dev | 296 | kernel/blk_drv/scsi/st.c | printk("st%d: No free buffers.\n", dev); |
dev | 301 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer = st_buffers[i]; |
dev | 302 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].in_use = 1; |
dev | 305 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].write_prot = ((flags & O_ACCMODE) == O_RDONLY); |
dev | 307 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].dirty = 0; |
dev | 308 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].rw = 0; |
dev | 309 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 0; |
dev | 310 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 0; |
dev | 312 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 314 | kernel/blk_drv/scsi/st.c | printk("st%d: Tape request not allocated", dev); |
dev | 321 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 323 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 327 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 337 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 339 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 343 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 352 | kernel/blk_drv/scsi/st.c | printk("st%d: No tape.\n", dev); |
dev | 354 | kernel/blk_drv/scsi/st.c | printk("st%d: Error %x.\n", dev, SCpnt->result); |
dev | 355 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->in_use = 0; |
dev | 356 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].in_use = 0; |
dev | 357 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 364 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 366 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 369 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 372 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].max_block = (scsi_tapes[dev].buffer->b_data[1] << 16) | |
dev | 373 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->b_data[2] << 8) | scsi_tapes[dev].buffer->b_data[3]; |
dev | 374 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].min_block = (scsi_tapes[dev].buffer->b_data[4] << 8) | |
dev | 375 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[5]; |
dev | 377 | kernel/blk_drv/scsi/st.c | printk("st%d: Block limits %d - %d bytes.\n", dev, scsi_tapes[dev].min_block, |
dev | 378 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].max_block); |
dev | 382 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].min_block = scsi_tapes[dev].max_block = (-1); |
dev | 384 | kernel/blk_drv/scsi/st.c | printk("st%d: Can't read block limits.\n", dev); |
dev | 392 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 394 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 397 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 402 | kernel/blk_drv/scsi/st.c | printk("st%d: No Mode Sense.\n", dev); |
dev | 404 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[2] = |
dev | 405 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[3] = 0; |
dev | 407 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 410 | kernel/blk_drv/scsi/st.c | printk("st%d: Mode sense. Length %d, medium %x, WBS %x, BLL %d\n", dev, |
dev | 411 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[0], scsi_tapes[dev].buffer->b_data[1], |
dev | 412 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[2], scsi_tapes[dev].buffer->b_data[3]); |
dev | 415 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->b_data[3] >= 8) { |
dev | 416 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].drv_buffer = (scsi_tapes[dev].buffer->b_data[2] >> 4) & 7; |
dev | 417 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].density = scsi_tapes[dev].buffer->b_data[4]; |
dev | 418 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size = scsi_tapes[dev].buffer->b_data[9] * 65536 + |
dev | 419 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[10] * 256 + scsi_tapes[dev].buffer->b_data[11]; |
dev | 421 | kernel/blk_drv/scsi/st.c | printk("st%d: Density %x, tape length: %x, blocksize: %d, drv buffer: %d\n", dev, |
dev | 422 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[4], scsi_tapes[dev].buffer->b_data[5] * |
dev | 423 | kernel/blk_drv/scsi/st.c | 65536 + scsi_tapes[dev].buffer->b_data[6] * 256 + |
dev | 424 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[7], scsi_tapes[dev].buffer->b_data[9] * |
dev | 425 | kernel/blk_drv/scsi/st.c | 65536 + scsi_tapes[dev].buffer->b_data[10] * 256 + |
dev | 426 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[11], |
dev | 427 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].drv_buffer); |
dev | 429 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size > ST_BUFFER_SIZE) { |
dev | 430 | kernel/blk_drv/scsi/st.c | printk("st%d: Blocksize %d too large for buffer.\n", dev, |
dev | 431 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size); |
dev | 432 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->in_use = 0; |
dev | 433 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].in_use = 0; |
dev | 439 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size = ST_BLOCK_SIZE; |
dev | 441 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size > 0) { |
dev | 442 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks = |
dev | 443 | kernel/blk_drv/scsi/st.c | ST_BUFFER_SIZE / scsi_tapes[dev].block_size; |
dev | 444 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size = |
dev | 445 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size; |
dev | 448 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks = 1; |
dev | 449 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size = ST_BUFFER_SIZE; |
dev | 451 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = scsi_tapes[dev].buffer->read_pointer = 0; |
dev | 454 | kernel/blk_drv/scsi/st.c | printk("st%d: Block size: %d, buffer size: %d (%d blocks).\n", dev, |
dev | 455 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size, scsi_tapes[dev].buffer->buffer_size, |
dev | 456 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks); |
dev | 459 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->b_data[2] & 0x80) { |
dev | 460 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].write_prot = 1; |
dev | 462 | kernel/blk_drv/scsi/st.c | printk( "st%d: Write protected\n", dev); |
dev | 473 | kernel/blk_drv/scsi/st.c | int dev; |
dev | 479 | kernel/blk_drv/scsi/st.c | dev = MINOR(inode->i_rdev); |
dev | 480 | kernel/blk_drv/scsi/st.c | rewind = (dev & 0x80) == 0; |
dev | 481 | kernel/blk_drv/scsi/st.c | dev = dev & 127; |
dev | 483 | kernel/blk_drv/scsi/st.c | if ( scsi_tapes[dev].rw == 2) { |
dev | 485 | kernel/blk_drv/scsi/st.c | result = flush_write_buffer(dev); |
dev | 488 | kernel/blk_drv/scsi/st.c | printk("st%d: File length %d bytes.\n", dev, filp->f_pos); |
dev | 492 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 498 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 500 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 503 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 506 | kernel/blk_drv/scsi/st.c | printk("st%d: Error on write filemark.\n", dev); |
dev | 511 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 515 | kernel/blk_drv/scsi/st.c | printk("st%d: Buffer flushed, EOF written\n", dev); |
dev | 519 | kernel/blk_drv/scsi/st.c | if ((scsi_tapes[dev].eof == 1) && !scsi_tapes[dev].eof_hit) |
dev | 529 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->in_use = 0; |
dev | 530 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].in_use = 0; |
dev | 539 | kernel/blk_drv/scsi/st.c | int dev; |
dev | 545 | kernel/blk_drv/scsi/st.c | dev = MINOR(inode->i_rdev) & 127; |
dev | 547 | kernel/blk_drv/scsi/st.c | if (!scsi_tapes[dev].in_use) { |
dev | 548 | kernel/blk_drv/scsi/st.c | printk("st%d: Incorrect device.\n", dev); |
dev | 553 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].write_prot) |
dev | 556 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0 && count > ST_BUFFER_SIZE) |
dev | 559 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].rw == 1) { |
dev | 563 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].rw = 2; |
dev | 567 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->writing) { |
dev | 568 | kernel/blk_drv/scsi/st.c | write_behind_check(dev); |
dev | 569 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->last_result) { |
dev | 571 | kernel/blk_drv/scsi/st.c | printk("st%d: Async write error %x.\n", dev, |
dev | 572 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->last_result); |
dev | 583 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 589 | kernel/blk_drv/scsi/st.c | cmd[1] = (scsi_tapes[dev].block_size != 0); |
dev | 591 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].rw = 2; |
dev | 596 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size != 0 && |
dev | 597 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->buffer_bytes + count) > |
dev | 598 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size) |
dev | 600 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].block_size == 0 && count > 0) || |
dev | 601 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->buffer_bytes + count) >= |
dev | 602 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size) |
dev | 605 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 608 | kernel/blk_drv/scsi/st.c | do_count = scsi_tapes[dev].buffer->buffer_size - |
dev | 609 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes; |
dev | 610 | kernel/blk_drv/scsi/st.c | memcpy_fromfs(scsi_tapes[dev].buffer->b_data + |
dev | 611 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes, b_point, do_count); |
dev | 613 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 616 | kernel/blk_drv/scsi/st.c | blks = scsi_tapes[dev].buffer->buffer_blocks; |
dev | 621 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 623 | kernel/blk_drv/scsi/st.c | (void *) cmd, scsi_tapes[dev].buffer->b_data, |
dev | 624 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size, |
dev | 627 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 631 | kernel/blk_drv/scsi/st.c | printk("st%d: Error on write:\n", dev); |
dev | 639 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 648 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = 0; |
dev | 649 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].dirty = 0; |
dev | 652 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].dirty = 1; |
dev | 653 | kernel/blk_drv/scsi/st.c | memcpy_fromfs(scsi_tapes[dev].buffer->b_data + |
dev | 654 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes,b_point,count); |
dev | 656 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes += count; |
dev | 662 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; |
dev | 667 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->buffer_bytes >= ST_WRITE_THRESHOLD || |
dev | 668 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size == 0) { |
dev | 670 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 671 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing = scsi_tapes[dev].buffer->buffer_bytes; |
dev | 673 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing = (scsi_tapes[dev].buffer->buffer_bytes / |
dev | 674 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size) * scsi_tapes[dev].block_size; |
dev | 675 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].dirty = 0; |
dev | 677 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 678 | kernel/blk_drv/scsi/st.c | blks = scsi_tapes[dev].buffer->writing; |
dev | 680 | kernel/blk_drv/scsi/st.c | blks = scsi_tapes[dev].buffer->writing / scsi_tapes[dev].block_size; |
dev | 684 | kernel/blk_drv/scsi/st.c | SCpnt->result = scsi_tapes[dev].buffer->last_result = -1; |
dev | 686 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 688 | kernel/blk_drv/scsi/st.c | (void *) cmd, scsi_tapes[dev].buffer->b_data, |
dev | 689 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->writing, |
dev | 694 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 703 | kernel/blk_drv/scsi/st.c | int dev; |
dev | 709 | kernel/blk_drv/scsi/st.c | dev = MINOR(inode->i_rdev) & 127; |
dev | 711 | kernel/blk_drv/scsi/st.c | if (!scsi_tapes[dev].in_use) { |
dev | 712 | kernel/blk_drv/scsi/st.c | printk("st%d: Incorrect device.\n", dev); |
dev | 717 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0 && count > ST_BUFFER_SIZE) |
dev | 720 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].rw == 2) { |
dev | 724 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].rw = 1; |
dev | 728 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].eof) |
dev | 729 | kernel/blk_drv/scsi/st.c | printk("st%d: EOF flag up. Bytes %d\n", dev, |
dev | 730 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes); |
dev | 732 | kernel/blk_drv/scsi/st.c | if ((scsi_tapes[dev].buffer->buffer_bytes == 0) && |
dev | 733 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof == 2) /* EOM or Blank Check */ |
dev | 736 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].rw = 1; |
dev | 738 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 742 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->buffer_bytes == 0 && |
dev | 743 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof == 0) { |
dev | 747 | kernel/blk_drv/scsi/st.c | cmd[1] = (scsi_tapes[dev].block_size != 0); |
dev | 748 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 751 | kernel/blk_drv/scsi/st.c | blks = scsi_tapes[dev].buffer->buffer_blocks; |
dev | 752 | kernel/blk_drv/scsi/st.c | bytes = blks * scsi_tapes[dev].block_size; |
dev | 759 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 761 | kernel/blk_drv/scsi/st.c | (void *) cmd, scsi_tapes[dev].buffer->b_data, |
dev | 762 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size, |
dev | 765 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 767 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer = 0; |
dev | 768 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 0; |
dev | 772 | kernel/blk_drv/scsi/st.c | printk("st%d: Sense: %2x %2x %2x %2x %2x %2x %2x %2x\n", dev, |
dev | 786 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) { |
dev | 789 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = count - transfer; |
dev | 792 | kernel/blk_drv/scsi/st.c | printk("st%d: Incorrect block size.\n", dev); |
dev | 793 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 798 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 2; /* What should be done at EOM ? */ |
dev | 799 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = |
dev | 800 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->buffer_blocks - transfer) * |
dev | 801 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size; |
dev | 803 | kernel/blk_drv/scsi/st.c | printk("st%d: EOM detected (%d blocks read).\n", dev, |
dev | 804 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks - transfer); |
dev | 808 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 1; |
dev | 809 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 810 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = |
dev | 813 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = |
dev | 814 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->buffer_blocks - transfer) * |
dev | 815 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size; |
dev | 818 | kernel/blk_drv/scsi/st.c | dev, scsi_tapes[dev].buffer->buffer_blocks - transfer, total); |
dev | 824 | kernel/blk_drv/scsi/st.c | printk("st%d: Tape error. Sense key %x\n", dev, |
dev | 828 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; |
dev | 837 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 842 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = bytes; |
dev | 847 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].buffer->buffer_bytes > 0) { |
dev | 849 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].eof) |
dev | 850 | kernel/blk_drv/scsi/st.c | printk("st%d: EOF up. Left %d, needed %d.\n", dev, |
dev | 851 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes, count - total); |
dev | 853 | kernel/blk_drv/scsi/st.c | transfer = scsi_tapes[dev].buffer->buffer_bytes < count - total ? |
dev | 854 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes : count - total; |
dev | 855 | kernel/blk_drv/scsi/st.c | memcpy_tofs(buf, scsi_tapes[dev].buffer->b_data + |
dev | 856 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer,transfer); |
dev | 860 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes -= transfer; |
dev | 861 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer += transfer; |
dev | 863 | kernel/blk_drv/scsi/st.c | else if (scsi_tapes[dev].eof) { |
dev | 864 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 1; |
dev | 865 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 866 | kernel/blk_drv/scsi/st.c | if (total == 0 && scsi_tapes[dev].eof == 1) |
dev | 867 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 0; |
dev | 868 | kernel/blk_drv/scsi/st.c | if (total == 0 && scsi_tapes[dev].eof == 2) |
dev | 873 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].block_size == 0) |
dev | 878 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 888 | kernel/blk_drv/scsi/st.c | int dev = MINOR(inode->i_rdev); |
dev | 895 | kernel/blk_drv/scsi/st.c | dev = dev & 127; |
dev | 907 | kernel/blk_drv/scsi/st.c | printk("st%d: Spacing tape forward %d files.\n", dev, |
dev | 923 | kernel/blk_drv/scsi/st.c | printk("st%d: Spacing tape backward %d files.\n", dev, (-ltmp)); |
dev | 933 | kernel/blk_drv/scsi/st.c | printk("st%d: Spacing tape forward %d blocks.\n", dev, |
dev | 948 | kernel/blk_drv/scsi/st.c | printk("st%d: Spacing tape backward %d blocks.\n", dev, (-ltmp)); |
dev | 952 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].write_prot) |
dev | 960 | kernel/blk_drv/scsi/st.c | printk("st%d: Writing %d filemarks.\n", dev, |
dev | 971 | kernel/blk_drv/scsi/st.c | printk("st%d: Rewinding tape.\n", dev); |
dev | 981 | kernel/blk_drv/scsi/st.c | printk("st%d: Unloading tape.\n", dev); |
dev | 986 | kernel/blk_drv/scsi/st.c | printk("st%d: No op on tape.\n", dev); |
dev | 998 | kernel/blk_drv/scsi/st.c | printk("st%d: Retensioning tape.\n", dev); |
dev | 1005 | kernel/blk_drv/scsi/st.c | printk("st%d: Spacing to end of recorded medium.\n", dev); |
dev | 1009 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].write_prot) |
dev | 1014 | kernel/blk_drv/scsi/st.c | printk("st%d: Erasing tape.\n", dev); |
dev | 1018 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].device->scsi_level < SCSI_2) { |
dev | 1038 | kernel/blk_drv/scsi/st.c | printk("st%d: Seeking tape to block %d.\n", dev, arg); |
dev | 1044 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].dirty || scsi_tapes[dev].buffer->buffer_bytes != 0) |
dev | 1048 | kernel/blk_drv/scsi/st.c | (arg < scsi_tapes[dev].min_block || arg > scsi_tapes[dev].max_block || |
dev | 1050 | kernel/blk_drv/scsi/st.c | printk("st%d: Illegal block size.\n", dev); |
dev | 1056 | kernel/blk_drv/scsi/st.c | memset(scsi_tapes[dev].buffer->b_data, 0, 12); |
dev | 1058 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[2] = (arg & 7) << 4; |
dev | 1060 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[2] = |
dev | 1061 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].drv_buffer << 4; |
dev | 1062 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[3] = 8; /* block descriptor length */ |
dev | 1064 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[4] = arg; |
dev | 1066 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[4] = scsi_tapes[dev].density; |
dev | 1070 | kernel/blk_drv/scsi/st.c | ltmp = scsi_tapes[dev].block_size; |
dev | 1071 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[9] = (ltmp >> 16); |
dev | 1072 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[10] = (ltmp >> 8); |
dev | 1073 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[11] = ltmp; |
dev | 1077 | kernel/blk_drv/scsi/st.c | printk("st%d: Setting block size to %d bytes.\n", dev, |
dev | 1078 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[9] * 65536 + |
dev | 1079 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[10] * 256 + |
dev | 1080 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[11]); |
dev | 1082 | kernel/blk_drv/scsi/st.c | printk("st%d: Setting density code to %x.\n", dev, |
dev | 1083 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->b_data[4]); |
dev | 1086 | kernel/blk_drv/scsi/st.c | (scsi_tapes[dev].buffer->b_data[2] >> 4) & 7); |
dev | 1090 | kernel/blk_drv/scsi/st.c | printk("st%d: Unknown st_ioctl command %x.\n", dev, cmd_in); |
dev | 1094 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 1096 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 1098 | kernel/blk_drv/scsi/st.c | (void *) cmd, (void *) scsi_tapes[dev].buffer->b_data, ST_BLOCK_SIZE, |
dev | 1101 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 1105 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 1113 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].block_size = arg; |
dev | 1115 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks = |
dev | 1116 | kernel/blk_drv/scsi/st.c | ST_BUFFER_SIZE / scsi_tapes[dev].block_size; |
dev | 1117 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size = |
dev | 1118 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks * scsi_tapes[dev].block_size; |
dev | 1121 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_blocks = 1; |
dev | 1122 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_size = ST_BUFFER_SIZE; |
dev | 1124 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->buffer_bytes = |
dev | 1125 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].buffer->read_pointer = 0; |
dev | 1128 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].drv_buffer = arg; |
dev | 1130 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].density = arg; |
dev | 1132 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 2; |
dev | 1133 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 0; |
dev | 1136 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof = 0; |
dev | 1137 | kernel/blk_drv/scsi/st.c | scsi_tapes[dev].eof_hit = 0; |
dev | 1150 | kernel/blk_drv/scsi/st.c | int dev = MINOR(inode->i_rdev); |
dev | 1157 | kernel/blk_drv/scsi/st.c | dev = dev & 127; |
dev | 1159 | kernel/blk_drv/scsi/st.c | if (!scsi_tapes[dev].in_use) { |
dev | 1160 | kernel/blk_drv/scsi/st.c | printk("st%d: Incorrect device.\n", dev); |
dev | 1193 | kernel/blk_drv/scsi/st.c | memcpy_tofs((char *)arg, (char *)scsi_tapes[dev].buffer->mt_status, |
dev | 1199 | kernel/blk_drv/scsi/st.c | printk("st%d: get tape position.\n", dev); |
dev | 1212 | kernel/blk_drv/scsi/st.c | SCpnt = allocate_device(NULL, scsi_tapes[dev].device->index, 1); |
dev | 1216 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].device->scsi_level < SCSI_2) { |
dev | 1224 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = dev; |
dev | 1227 | kernel/blk_drv/scsi/st.c | (void *) scmd, (void *) scsi_tapes[dev].buffer->b_data, |
dev | 1230 | kernel/blk_drv/scsi/st.c | if (SCpnt->request.dev == dev) sleep_on( &scsi_tapes[dev].waiting ); |
dev | 1235 | kernel/blk_drv/scsi/st.c | printk("st%d: Can't read tape position.\n", dev); |
dev | 1241 | kernel/blk_drv/scsi/st.c | if (scsi_tapes[dev].device->scsi_level < SCSI_2) |
dev | 1242 | kernel/blk_drv/scsi/st.c | mt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[0] << 16) |
dev | 1243 | kernel/blk_drv/scsi/st.c | + (scsi_tapes[dev].buffer->b_data[1] << 8) |
dev | 1244 | kernel/blk_drv/scsi/st.c | + scsi_tapes[dev].buffer->b_data[2]; |
dev | 1246 | kernel/blk_drv/scsi/st.c | mt_pos.mt_blkno = (scsi_tapes[dev].buffer->b_data[4] << 24) |
dev | 1247 | kernel/blk_drv/scsi/st.c | + (scsi_tapes[dev].buffer->b_data[5] << 16) |
dev | 1248 | kernel/blk_drv/scsi/st.c | + (scsi_tapes[dev].buffer->b_data[6] << 8) |
dev | 1249 | kernel/blk_drv/scsi/st.c | + scsi_tapes[dev].buffer->b_data[7]; |
dev | 1253 | kernel/blk_drv/scsi/st.c | SCpnt->request.dev = -1; /* Mark as not busy */ |
dev | 1259 | kernel/blk_drv/scsi/st.c | return scsi_ioctl(scsi_tapes[dev].device, cmd_in, (void *) arg); |
dev | 509 | kernel/blk_drv/scsi/ultrastor.c | int ultrastor_biosparam(int size, int dev, int *ip) |
dev | 604 | kernel/blk_drv/scsi/wd7000.c | int wd7000_biosparam(int size, int dev, int* ip) |
dev | 155 | kernel/blk_drv/xd.c | int dev = DEVICE_NR(MINOR(inode->i_rdev)); |
dev | 157 | kernel/blk_drv/xd.c | if (dev < xd_drives) { |
dev | 158 | kernel/blk_drv/xd.c | while (!xd_valid[dev]) |
dev | 161 | kernel/blk_drv/xd.c | xd_access[dev]++; |
dev | 179 | kernel/blk_drv/xd.c | if (CURRENT_DEV < xd_drives && CURRENT->sector + CURRENT->nr_sectors <= xd[MINOR(CURRENT->dev)].nr_sects) { |
dev | 180 | kernel/blk_drv/xd.c | block = CURRENT->sector + xd[MINOR(CURRENT->dev)].start_sect; |
dev | 199 | kernel/blk_drv/xd.c | int dev = DEVICE_NR(MINOR(inode->i_rdev)),err; |
dev | 201 | kernel/blk_drv/xd.c | if (inode && (dev < xd_drives)) |
dev | 206 | kernel/blk_drv/xd.c | put_fs_byte(xd_info[dev].heads,(char *) &geometry->heads); |
dev | 207 | kernel/blk_drv/xd.c | put_fs_byte(xd_info[dev].sectors,(char *) &geometry->sectors); |
dev | 208 | kernel/blk_drv/xd.c | put_fs_word(xd_info[dev].cylinders,(short *) &geometry->cylinders); |
dev | 238 | kernel/blk_drv/xd.c | int dev = DEVICE_NR(MINOR(inode->i_rdev)); |
dev | 240 | kernel/blk_drv/xd.c | if (dev < xd_drives) { |
dev | 241 | kernel/blk_drv/xd.c | sync_dev(dev); |
dev | 242 | kernel/blk_drv/xd.c | xd_access[dev]--; |
dev | 247 | kernel/blk_drv/xd.c | static int xd_reread_partitions(int dev) |
dev | 249 | kernel/blk_drv/xd.c | int target = DEVICE_NR(MINOR(dev)),start = target << xd_gendisk.minor_shift,partition; |
dev | 1810 | kernel/chr_drv/tpqic02.c | dev_t dev = inode->i_rdev; |
dev | 1817 | kernel/chr_drv/tpqic02.c | MINOR(dev), buf, count, filp->f_pos, flags); |
dev | 1980 | kernel/chr_drv/tpqic02.c | dev_t dev = inode->i_rdev; |
dev | 1986 | kernel/chr_drv/tpqic02.c | MINOR(dev), buf, count, filp->f_pos, flags); |
dev | 2126 | kernel/chr_drv/tpqic02.c | dev_t dev = inode->i_rdev; |
dev | 2133 | kernel/chr_drv/tpqic02.c | if (TP_DIAGS(dev)) { |
dev | 2134 | kernel/chr_drv/tpqic02.c | printk("tape_qic02_open: dev=%x, flags=%x ", dev, flags); |
dev | 2137 | kernel/chr_drv/tpqic02.c | if (MINOR(dev)==255) /* special case for resetting */ |
dev | 2184 | kernel/chr_drv/tpqic02.c | if ((TP_DENS(dev)!=0) && (TP_DENS(current_tape_dev) != TP_DENS(dev))) { |
dev | 2195 | kernel/chr_drv/tpqic02.c | current_tape_dev = dev; |
dev | 2234 | kernel/chr_drv/tpqic02.c | if (TP_DENS(current_tape_dev) == TP_DENS(dev) ) |
dev | 2237 | kernel/chr_drv/tpqic02.c | current_tape_dev = dev; |
dev | 2239 | kernel/chr_drv/tpqic02.c | dens = TP_DENS(dev); |
dev | 2245 | kernel/chr_drv/tpqic02.c | switch (TP_DENS(dev)) { |
dev | 2289 | kernel/chr_drv/tpqic02.c | dev_t dev = inode->i_rdev; |
dev | 2291 | kernel/chr_drv/tpqic02.c | if (TP_DIAGS(dev)) |
dev | 2292 | kernel/chr_drv/tpqic02.c | printk("tape_qic02_release: dev=%x\n", dev); |
dev | 2309 | kernel/chr_drv/tpqic02.c | if ((TP_REWCLOSE(dev)) && (status_bytes_rd | status_bytes_wr)) { |
dev | 248 | kernel/chr_drv/tty_io.c | int dev; |
dev | 252 | kernel/chr_drv/tty_io.c | dev = 0x0400 + tty->line; |
dev | 256 | kernel/chr_drv/tty_io.c | if (filp->f_rdev != dev) |
dev | 990 | kernel/chr_drv/tty_io.c | int i, dev; |
dev | 993 | kernel/chr_drv/tty_io.c | dev = file->f_rdev; |
dev | 994 | kernel/chr_drv/tty_io.c | if (MAJOR(dev) != 4) { |
dev | 995 | kernel/chr_drv/tty_io.c | printk("tty_read: bad pseudo-major nr #%d\n", MAJOR(dev)); |
dev | 998 | kernel/chr_drv/tty_io.c | dev = MINOR(dev); |
dev | 999 | kernel/chr_drv/tty_io.c | tty = TTY_TABLE(dev); |
dev | 1004 | kernel/chr_drv/tty_io.c | (current->tty == dev) && |
dev | 1023 | kernel/chr_drv/tty_io.c | int dev, i, is_console; |
dev | 1026 | kernel/chr_drv/tty_io.c | dev = file->f_rdev; |
dev | 1028 | kernel/chr_drv/tty_io.c | if (MAJOR(dev) != 4) { |
dev | 1032 | kernel/chr_drv/tty_io.c | dev = MINOR(dev); |
dev | 1036 | kernel/chr_drv/tty_io.c | tty = TTY_TABLE(dev); |
dev | 1040 | kernel/chr_drv/tty_io.c | (current->tty == dev) && (tty->pgrp != current->pgrp)) { |
dev | 1062 | kernel/chr_drv/tty_io.c | static int init_dev(int dev) |
dev | 1069 | kernel/chr_drv/tty_io.c | o_dev = PTY_OTHER(dev); |
dev | 1075 | kernel/chr_drv/tty_io.c | if (IS_A_PTY_MASTER(dev) && tty_table[dev] && tty_table[dev]->count) |
dev | 1078 | kernel/chr_drv/tty_io.c | if (!tty_table[dev] && !tty) { |
dev | 1081 | kernel/chr_drv/tty_io.c | initialize_tty_struct(dev, tty); |
dev | 1084 | kernel/chr_drv/tty_io.c | if (!tty_termios[dev] && !tp) { |
dev | 1089 | kernel/chr_drv/tty_io.c | initialize_termios(dev, tp); |
dev | 1092 | kernel/chr_drv/tty_io.c | if (!termios_locked[dev] && !ltp) { |
dev | 1100 | kernel/chr_drv/tty_io.c | if (IS_A_PTY(dev)) { |
dev | 1128 | kernel/chr_drv/tty_io.c | if (!tty_termios[dev]) { |
dev | 1129 | kernel/chr_drv/tty_io.c | tty_termios[dev] = tp; |
dev | 1132 | kernel/chr_drv/tty_io.c | if (!tty_table[dev]) { |
dev | 1133 | kernel/chr_drv/tty_io.c | tty->termios = tty_termios[dev]; |
dev | 1134 | kernel/chr_drv/tty_io.c | tty_table[dev] = tty; |
dev | 1137 | kernel/chr_drv/tty_io.c | if (!termios_locked[dev]) { |
dev | 1138 | kernel/chr_drv/tty_io.c | termios_locked[dev] = ltp; |
dev | 1141 | kernel/chr_drv/tty_io.c | if (IS_A_PTY(dev)) { |
dev | 1155 | kernel/chr_drv/tty_io.c | tty_table[dev]->link = tty_table[o_dev]; |
dev | 1156 | kernel/chr_drv/tty_io.c | tty_table[o_dev]->link = tty_table[dev]; |
dev | 1158 | kernel/chr_drv/tty_io.c | tty_table[dev]->count++; |
dev | 1159 | kernel/chr_drv/tty_io.c | if (IS_A_PTY_MASTER(dev)) |
dev | 1183 | kernel/chr_drv/tty_io.c | static void release_dev(int dev, struct file * filp) |
dev | 1189 | kernel/chr_drv/tty_io.c | tty = tty_table[dev]; |
dev | 1190 | kernel/chr_drv/tty_io.c | tp = tty_termios[dev]; |
dev | 1194 | kernel/chr_drv/tty_io.c | printk("release_dev: tty_table[%d] was NULL\n", dev); |
dev | 1198 | kernel/chr_drv/tty_io.c | printk("release_dev: tty_termios[%d] was NULL\n", dev); |
dev | 1201 | kernel/chr_drv/tty_io.c | if (IS_A_PTY(dev)) { |
dev | 1202 | kernel/chr_drv/tty_io.c | o_tty = tty_table[PTY_OTHER(dev)]; |
dev | 1203 | kernel/chr_drv/tty_io.c | o_tp = tty_termios[PTY_OTHER(dev)]; |
dev | 1205 | kernel/chr_drv/tty_io.c | printk("release_dev: pty pair(%d) was NULL\n", dev); |
dev | 1209 | kernel/chr_drv/tty_io.c | printk("release_dev: pty pair(%d) termios was NULL\n", dev); |
dev | 1220 | kernel/chr_drv/tty_io.c | if (IS_A_PTY_MASTER(dev)) { |
dev | 1223 | kernel/chr_drv/tty_io.c | dev, tty->count); |
dev | 1229 | kernel/chr_drv/tty_io.c | dev, tty->count); |
dev | 1251 | kernel/chr_drv/tty_io.c | tty_table[PTY_OTHER(dev)] = NULL; |
dev | 1252 | kernel/chr_drv/tty_io.c | tty_termios[PTY_OTHER(dev)] = NULL; |
dev | 1255 | kernel/chr_drv/tty_io.c | tty_table[dev] = NULL; |
dev | 1256 | kernel/chr_drv/tty_io.c | if (IS_A_PTY(dev)) { |
dev | 1257 | kernel/chr_drv/tty_io.c | tty_termios[dev] = NULL; |
dev | 1353 | kernel/chr_drv/tty_io.c | int dev; |
dev | 1355 | kernel/chr_drv/tty_io.c | dev = filp->f_rdev; |
dev | 1356 | kernel/chr_drv/tty_io.c | if (MAJOR(dev) != 4) { |
dev | 1360 | kernel/chr_drv/tty_io.c | dev = MINOR(filp->f_rdev); |
dev | 1361 | kernel/chr_drv/tty_io.c | if (!dev) { |
dev | 1365 | kernel/chr_drv/tty_io.c | release_dev(dev, filp); |
dev | 1370 | kernel/chr_drv/tty_io.c | int dev; |
dev | 1373 | kernel/chr_drv/tty_io.c | dev = filp->f_rdev; |
dev | 1374 | kernel/chr_drv/tty_io.c | if (MAJOR(dev) != 4) { |
dev | 1378 | kernel/chr_drv/tty_io.c | dev = MINOR(filp->f_rdev); |
dev | 1379 | kernel/chr_drv/tty_io.c | tty = TTY_TABLE(dev); |
dev | 1381 | kernel/chr_drv/tty_io.c | printk("tty_select: tty struct for dev %d was NULL\n", dev); |
dev | 407 | kernel/chr_drv/tty_ioctl.c | int dev; |
dev | 415 | kernel/chr_drv/tty_ioctl.c | dev = MINOR(file->f_rdev); |
dev | 416 | kernel/chr_drv/tty_ioctl.c | tty = TTY_TABLE(dev); |
dev | 419 | kernel/chr_drv/tty_ioctl.c | if (IS_A_PTY(dev)) |
dev | 420 | kernel/chr_drv/tty_ioctl.c | other_tty = tty_table[PTY_OTHER(dev)]; |
dev | 424 | kernel/chr_drv/tty_ioctl.c | termios_dev = dev; |
dev | 425 | kernel/chr_drv/tty_ioctl.c | if (IS_A_PTY_MASTER(dev)) { |
dev | 427 | kernel/chr_drv/tty_ioctl.c | termios_dev = PTY_OTHER(dev); |
dev | 494 | kernel/chr_drv/tty_ioctl.c | current->tty = dev; |
dev | 538 | kernel/chr_drv/tty_ioctl.c | if (IS_A_PTY_MASTER(dev)) |
dev | 562 | kernel/chr_drv/tty_ioctl.c | if (IS_A_CONSOLE(dev)) { |
dev | 572 | kernel/chr_drv/tty_ioctl.c | if (IS_A_PTY_MASTER(dev)) |
dev | 574 | kernel/chr_drv/tty_ioctl.c | else if (IS_A_PTY_SLAVE(dev)) |
dev | 616 | kernel/chr_drv/tty_ioctl.c | if (!IS_A_PTY_MASTER(dev)) |
dev | 47 | net/ddi.c | register struct ddi_device *dev; |
dev | 50 | net/ddi.c | dev = devices; |
dev | 51 | net/ddi.c | while (dev->title != NULL) { |
dev | 52 | net/ddi.c | if (strncmp(dev->name, id, DDI_MAXNAME) == 0) { |
dev | 53 | net/ddi.c | PRINTK (("OK at 0x%X\n", dev)); |
dev | 54 | net/ddi.c | return(dev); |
dev | 56 | net/ddi.c | dev++; |
dev | 72 | net/ddi.c | struct ddi_device *dev; |
dev | 84 | net/ddi.c | dev = devices; |
dev | 85 | net/ddi.c | while (dev->title != NULL) { |
dev | 86 | net/ddi.c | (*dev->init)(dev); |
dev | 87 | net/ddi.c | dev++; |
dev | 280 | net/drv/slip/slip.c | struct device *dev; |
dev | 293 | net/drv/slip/slip.c | dev = sl->dev; |
dev | 296 | net/drv/slip/slip.c | done = dev_rint(p, len, 0, dev); |
dev | 361 | net/drv/slip/slip.c | sl_start_xmit(void /*struct sk_buff*/ *skb, void /*struct device*/ *dev) |
dev | 368 | net/drv/slip/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 406 | net/drv/slip/slip.c | sl_type_trans (void /*struct sk_buff*/ *skb, void /*struct device*/ *dev) |
dev | 411 | net/drv/slip/slip.c | sl = sl_ctrl[dev->base_addr]; |
dev | 421 | net/drv/slip/slip.c | sl_open(void /*struct device*/ *dev) |
dev | 426 | net/drv/slip/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 442 | net/drv/slip/slip.c | sl_close(void /*struct device*/ *dev) |
dev | 447 | net/drv/slip/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 460 | net/drv/slip/slip.c | del_devroute(dev); |
dev | 461 | net/drv/slip/slip.c | dev->up = 0; |
dev | 575 | net/drv/slip/slip.c | (void) sl_open(sl->dev); |
dev | 600 | net/drv/slip/slip.c | (void) sl_close(sl->dev); |
dev | 607 | net/drv/slip/slip.c | slip_init(struct ddi *dev) |
dev | 616 | net/drv/slip/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 628 | net/drv/slip/slip.c | sl->line = dev->base_addr; /* SLIP channel number */ |
dev | 630 | net/drv/slip/slip.c | sl->dev = dev; /* pointer to DEVICE */ |
dev | 641 | net/drv/slip/slip.c | dev->mtu = SL_MTU; |
dev | 642 | net/drv/slip/slip.c | dev->rmem_end = (unsigned long)&sl->rcv_queue.buf[SL_BUF_SIZE-1]; |
dev | 643 | net/drv/slip/slip.c | dev->rmem_start = (unsigned long)&sl->rcv_queue.buf[0]; |
dev | 644 | net/drv/slip/slip.c | dev->mem_end = (unsigned long)&sl->xbuff[(SL_MTU * 2) -1]; |
dev | 645 | net/drv/slip/slip.c | dev->mem_start = (unsigned long)&sl->xbuff[0]; |
dev | 646 | net/drv/slip/slip.c | dev->hard_start_xmit = sl_start_xmit; |
dev | 647 | net/drv/slip/slip.c | dev->open = sl_open; |
dev | 648 | net/drv/slip/slip.c | dev->stop = sl_close; |
dev | 649 | net/drv/slip/slip.c | dev->hard_header = sl_hard_header; |
dev | 650 | net/drv/slip/slip.c | dev->add_arp = sl_add_arp; |
dev | 651 | net/drv/slip/slip.c | dev->type_trans = sl_type_trans; |
dev | 652 | net/drv/slip/slip.c | dev->hard_header_len = 0; |
dev | 653 | net/drv/slip/slip.c | dev->addr_len = 0; |
dev | 654 | net/drv/slip/slip.c | dev->type = 0; /* FIXME: ??? */ |
dev | 655 | net/drv/slip/slip.c | dev->queue_xmit = dev_queue_xmit; |
dev | 656 | net/drv/slip/slip.c | dev->rebuild_header = sl_rebuild_header; |
dev | 657 | net/drv/slip/slip.c | for (i = 0; i < DEV_NUMBUFFS; i++) dev->buffs[i] = NULL; |
dev | 41 | net/drv/slip/slip.h | struct device *dev; /* easy for intr handling */ |
dev | 62 | net/drv/slip/slip.h | extern int slip_init(struct ddi *dev); |
dev | 57 | net/drv/we8003/handler.c | wd_start(struct device *dev) |
dev | 68 | net/drv/we8003/handler.c | dev->start = 1; |
dev | 72 | net/drv/we8003/handler.c | wd8003_open(struct device *dev) |
dev | 107 | net/drv/we8003/handler.c | outb_p(dev->dev_addr[i],WD_PAR0+i); |
dev | 114 | net/drv/we8003/handler.c | outb_p(dev->broadcast[i],WD_MAR0+i); |
dev | 121 | net/drv/we8003/handler.c | wd_start(dev); |
dev | 127 | net/drv/we8003/handler.c | wdget(volatile struct wd_ring *ring, struct device *dev) |
dev | 139 | net/drv/we8003/handler.c | return (dev_rint(fptr, len, 0, dev)); |
dev | 143 | net/drv/we8003/handler.c | wd8003_start_xmit(struct sk_buff *skb, struct device *dev) |
dev | 149 | net/drv/we8003/handler.c | if (dev->tbusy) |
dev | 152 | net/drv/we8003/handler.c | if (jiffies - dev->trans_start < 30) |
dev | 159 | net/drv/we8003/handler.c | dev->tbusy = 1; |
dev | 164 | net/drv/we8003/handler.c | wd_trs(dev); |
dev | 169 | net/drv/we8003/handler.c | if (skb->dev != dev) |
dev | 178 | net/drv/we8003/handler.c | if ( dev->rebuild_header (skb+1, dev)) |
dev | 181 | net/drv/we8003/handler.c | if (skb->dev == dev) |
dev | 186 | net/drv/we8003/handler.c | dev->tbusy = 0; |
dev | 192 | net/drv/we8003/handler.c | memcpy ((unsigned char *)dev->mem_start, skb+1, skb->len); |
dev | 197 | net/drv/we8003/handler.c | dev->trans_start = jiffies; |
dev | 207 | net/drv/we8003/handler.c | if (!(dev->interrupt)) |
dev | 227 | net/drv/we8003/handler.c | wd_put_bnd(unsigned char bnd, struct device *dev ) |
dev | 244 | net/drv/we8003/handler.c | wd_get_bnd( struct device *dev ) |
dev | 262 | net/drv/we8003/handler.c | wd_get_cur( struct device *dev ) |
dev | 284 | net/drv/we8003/handler.c | wd_rcv( struct device *dev ) |
dev | 295 | net/drv/we8003/handler.c | cur = wd_get_cur( dev ); |
dev | 296 | net/drv/we8003/handler.c | bnd = wd_get_bnd( dev ); |
dev | 306 | net/drv/we8003/handler.c | ring = (volatile struct wd_ring *) (dev->mem_start + (pkt << 8)); |
dev | 320 | net/drv/we8003/handler.c | done = wdget( ring, dev ); /* get the packet */ |
dev | 328 | net/drv/we8003/handler.c | wd_put_bnd(bnd, dev); |
dev | 331 | net/drv/we8003/handler.c | cur = wd_get_cur(dev); |
dev | 342 | net/drv/we8003/handler.c | if( ( bnd = wd_get_cur( dev ) - 1 ) < WD_TXBS ) |
dev | 344 | net/drv/we8003/handler.c | wd_put_bnd( bnd, dev ); |
dev | 351 | net/drv/we8003/handler.c | done = dev_rint(NULL, 0,0, dev); |
dev | 366 | net/drv/we8003/handler.c | wd_rx_over( struct device *dev ) |
dev | 383 | net/drv/we8003/handler.c | wd_rcv( dev ); /* clear out received packets */ |
dev | 399 | net/drv/we8003/handler.c | wd_trs( struct device *dev ) |
dev | 411 | net/drv/we8003/handler.c | dev->tbusy = 0; |
dev | 416 | net/drv/we8003/handler.c | len = dev_tint( (unsigned char *)dev->mem_start, dev ); |
dev | 428 | net/drv/we8003/handler.c | dev->tbusy = 0 |
dev | 454 | net/drv/we8003/handler.c | struct device *dev; |
dev | 461 | net/drv/we8003/handler.c | for (dev = dev_base; dev != NULL; dev = dev->next) |
dev | 463 | net/drv/we8003/handler.c | if (dev->irq == irq) break; |
dev | 465 | net/drv/we8003/handler.c | if (dev == NULL) |
dev | 481 | net/drv/we8003/handler.c | dev->interrupt = 1; |
dev | 489 | net/drv/we8003/handler.c | printk("\nwd8013 overrun bnd = %d, cur = %d", wd_get_bnd( dev ), wd_get_cur( dev ) ); |
dev | 490 | net/drv/we8003/handler.c | wd_rx_over( dev ); /* performs wd_rcv() as well */ |
dev | 494 | net/drv/we8003/handler.c | wd_rcv( dev ); |
dev | 500 | net/drv/we8003/handler.c | wd_trs( dev ); |
dev | 533 | net/drv/we8003/handler.c | wd_trs( dev ); |
dev | 558 | net/drv/we8003/handler.c | dev->interrupt = 0; |
dev | 594 | net/drv/we8003/handler.c | we8003_8bit(struct ddi *dev) |
dev | 601 | net/drv/we8003/handler.c | io = dev->config.ioaddr; |
dev | 612 | net/drv/we8003/handler.c | dev->flags |= DDI_FBUS16; |
dev | 624 | net/drv/we8003/handler.c | we8003_cmem(struct ddi *dev) |
dev | 628 | net/drv/we8003/handler.c | io = dev->config.ioaddr; |
dev | 637 | net/drv/we8003/handler.c | we8003_geth(struct ddi *dev) |
dev | 642 | net/drv/we8003/handler.c | io = dev->config.ioaddr; |
dev | 644 | net/drv/we8003/handler.c | dev->dev_addr[i] = inb_p(io + WD_ROM + i); |
dev | 645 | net/drv/we8003/handler.c | dev->broadcast[i] = 0xff; |
dev | 652 | net/drv/we8003/handler.c | we8003_conf(struct ddi *dev) |
dev | 659 | net/drv/we8003/handler.c | if (dev->config.ioaddr == 0) return(0); /* fake it's OK */ |
dev | 660 | net/drv/we8003/handler.c | if (we8003_probe(&dev->config) < 0) return(1); |
dev | 663 | net/drv/we8003/handler.c | we8003_8bit(dev); |
dev | 666 | net/drv/we8003/handler.c | we8003_cmem(dev); |
dev | 669 | net/drv/we8003/handler.c | we8003_geth(dev); |
dev | 674 | net/drv/we8003/handler.c | dev->tbusy = 0; |
dev | 675 | net/drv/we8003/handler.c | dev->interrupt = 0; |
dev | 676 | net/drv/we8003/handler.c | if (irqaction (dev->irq, &we8003_sigaction)) { |
dev | 677 | net/drv/we8003/handler.c | printk("%s: unable to get IRQ%d\n", dev->name, dev->irq); |
dev | 33 | net/drv/we8003/main.c | we_getconf(struct ddi_device *dev, struct ddconf *cp) |
dev | 35 | net/drv/we8003/main.c | cp->ioaddr = dev->config.ioaddr; /* I/O base address */ |
dev | 37 | net/drv/we8003/main.c | cp->irq = dev->config.irq; /* IRQ channel */ |
dev | 39 | net/drv/we8003/main.c | cp->memaddr = dev->config.memaddr; /* RAM base address */ |
dev | 40 | net/drv/we8003/main.c | cp->memsize = dev->config.memsize; /* RAM size */ |
dev | 46 | net/drv/we8003/main.c | we_setconf(struct ddi_device *dev, struct ddconf *cp) |
dev | 48 | net/drv/we8003/main.c | dev->config.ioaddr = cp->ioaddr; /* I/O base address */ |
dev | 49 | net/drv/we8003/main.c | dev->config.irq = cp->irq; /* IRQ channel */ |
dev | 50 | net/drv/we8003/main.c | dev->config.memaddr = cp->memaddr; /* RAM base address */ |
dev | 51 | net/drv/we8003/main.c | dev->config.memsize = cp->memsize; /* RAM size */ |
dev | 53 | net/drv/we8003/main.c | dev->name, dev->config.ioaddr, dev->config.irq, |
dev | 54 | net/drv/we8003/main.c | dev->config.memaddr, dev->config.memsize)); |
dev | 66 | net/drv/we8003/main.c | struct ddi_device *dev; |
dev | 70 | net/drv/we8003/main.c | dev = we_ptrs[minor]; |
dev | 71 | net/drv/we8003/main.c | if (dev == NULL || (dev->flags & DDI_FREADY) == 0) return(-ENODEV); |
dev | 81 | net/drv/we8003/main.c | struct ddi_device *dev; |
dev | 85 | net/drv/we8003/main.c | dev = we_ptrs[minor]; |
dev | 86 | net/drv/we8003/main.c | if (dev == NULL || (dev->flags & DDI_FREADY) == 0) return; |
dev | 95 | net/drv/we8003/main.c | struct ddi_device *dev; |
dev | 100 | net/drv/we8003/main.c | dev = we_ptrs[minor]; |
dev | 101 | net/drv/we8003/main.c | if (dev == NULL || (dev->flags & DDI_FREADY) == 0) return(-ENODEV); |
dev | 106 | net/drv/we8003/main.c | memcpy_tofs((void *)arg, dev->name, DDI_MAXNAME); |
dev | 110 | net/drv/we8003/main.c | ret = we_getconf(dev, &conf); |
dev | 115 | net/drv/we8003/main.c | ret = we_setconf(dev, &conf); |
dev | 139 | net/drv/we8003/main.c | we8003_init(struct ddi_device *dev) |
dev | 150 | net/drv/we8003/main.c | we_ptrs[unit_nr] = dev; |
dev | 151 | net/drv/we8003/main.c | dev->unit = unit_nr++; |
dev | 152 | net/drv/we8003/main.c | sprintf(dev->name, WE_NAME, dev->unit); |
dev | 153 | net/drv/we8003/main.c | dev->flags |= DDI_FREADY; |
dev | 156 | net/drv/we8003/main.c | PRINTK (("%s: version %s: ", dev->title, VERSION)); |
dev | 157 | net/drv/we8003/main.c | (void) we_setconf(dev, &dev->config); |
dev | 160 | net/drv/we8003/main.c | if (dev->major != 0) { |
dev | 161 | net/drv/we8003/main.c | if (dev->flags & DDI_FBLKDEV) { |
dev | 162 | net/drv/we8003/main.c | if (register_blkdev(dev->major, "WE8003", &we_fops) < 0) { |
dev | 164 | net/drv/we8003/main.c | dev->name, dev->major); |
dev | 168 | net/drv/we8003/main.c | if (dev->flags & DDI_FCHRDEV) { |
dev | 169 | net/drv/we8003/main.c | if (register_chrdev(dev->major, "WE8003", &we_fops) < 0) { |
dev | 171 | net/drv/we8003/main.c | dev->name, dev->major); |
dev | 31 | net/drv/we8003/we8003.h | extern int we8003_init(struct ddi_device *dev); |
dev | 92 | net/inet/3c509.c | static int el3_open(struct device *dev); |
dev | 93 | net/inet/3c509.c | static int el3_start_xmit(struct sk_buff *skb, struct device *dev); |
dev | 95 | net/inet/3c509.c | static void update_stats(int addr, struct device *dev); |
dev | 96 | net/inet/3c509.c | static struct enet_statistics *el3_get_stats(struct device *dev); |
dev | 97 | net/inet/3c509.c | static int el3_rx(struct device *dev); |
dev | 98 | net/inet/3c509.c | static int el3_close(struct device *dev); |
dev | 102 | net/inet/3c509.c | int el3_probe(struct device *dev) |
dev | 106 | net/inet/3c509.c | short *phys_addr = (short *)dev->dev_addr; |
dev | 137 | net/inet/3c509.c | dev->if_port = iobase >> 14; |
dev | 145 | net/inet/3c509.c | if (dev->base_addr != 0 |
dev | 146 | net/inet/3c509.c | && dev->base_addr != (unsigned short)ioaddr) { |
dev | 160 | net/inet/3c509.c | dev->base_addr = ioaddr; |
dev | 161 | net/inet/3c509.c | dev->irq = irq; |
dev | 162 | net/inet/3c509.c | snarf_region(dev->base_addr, 16); |
dev | 167 | net/inet/3c509.c | dev->name, dev->base_addr, current_tag, if_names[dev->if_port]); |
dev | 172 | net/inet/3c509.c | printk(" %2.2x", dev->dev_addr[i]); |
dev | 173 | net/inet/3c509.c | printk(", IRQ %d.\n", dev->irq); |
dev | 176 | net/inet/3c509.c | dev->priv = kmalloc(sizeof(struct el3_private), GFP_KERNEL); |
dev | 177 | net/inet/3c509.c | memset(dev->priv, 0, sizeof(struct el3_private)); |
dev | 183 | net/inet/3c509.c | dev->open = &el3_open; |
dev | 184 | net/inet/3c509.c | dev->hard_start_xmit = &el3_start_xmit; |
dev | 185 | net/inet/3c509.c | dev->stop = &el3_close; |
dev | 186 | net/inet/3c509.c | dev->get_stats = &el3_get_stats; |
dev | 190 | net/inet/3c509.c | dev->buffs[i] = NULL; |
dev | 192 | net/inet/3c509.c | dev->hard_header = eth_header; |
dev | 193 | net/inet/3c509.c | dev->add_arp = eth_add_arp; |
dev | 194 | net/inet/3c509.c | dev->queue_xmit = dev_queue_xmit; |
dev | 195 | net/inet/3c509.c | dev->rebuild_header = eth_rebuild_header; |
dev | 196 | net/inet/3c509.c | dev->type_trans = eth_type_trans; |
dev | 198 | net/inet/3c509.c | dev->type = ARPHRD_ETHER; |
dev | 199 | net/inet/3c509.c | dev->hard_header_len = ETH_HLEN; |
dev | 200 | net/inet/3c509.c | dev->mtu = 1500; /* eth_mtu */ |
dev | 201 | net/inet/3c509.c | dev->addr_len = ETH_ALEN; |
dev | 203 | net/inet/3c509.c | dev->broadcast[i]=0xff; |
dev | 207 | net/inet/3c509.c | dev->flags = IFF_BROADCAST; |
dev | 208 | net/inet/3c509.c | dev->family = AF_INET; |
dev | 209 | net/inet/3c509.c | dev->pa_addr = 0; |
dev | 210 | net/inet/3c509.c | dev->pa_brdaddr = 0; |
dev | 211 | net/inet/3c509.c | dev->pa_mask = 0; |
dev | 212 | net/inet/3c509.c | dev->pa_alen = sizeof(unsigned long); |
dev | 243 | net/inet/3c509.c | el3_open(struct device *dev) |
dev | 245 | net/inet/3c509.c | int ioaddr = dev->base_addr; |
dev | 248 | net/inet/3c509.c | if (request_irq(dev->irq, &el3_interrupt)) { |
dev | 254 | net/inet/3c509.c | printk("%s: Opening, IRQ %d status@%x %4.4x.\n", dev->name, |
dev | 255 | net/inet/3c509.c | dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS)); |
dev | 260 | net/inet/3c509.c | irq2dev_map[dev->irq] = dev; |
dev | 263 | net/inet/3c509.c | outw((dev->irq << 12) | 0x0f00, ioaddr + 8); |
dev | 269 | net/inet/3c509.c | outb(dev->dev_addr[i], ioaddr + i); |
dev | 271 | net/inet/3c509.c | if (dev->if_port == 3) |
dev | 274 | net/inet/3c509.c | else if (dev->if_port == 0) { |
dev | 288 | net/inet/3c509.c | dev->interrupt = 0; |
dev | 289 | net/inet/3c509.c | dev->tbusy = 0; |
dev | 290 | net/inet/3c509.c | dev->start = 1; |
dev | 295 | net/inet/3c509.c | dev->name, dev->irq, inw(ioaddr + EL3_STATUS)); |
dev | 301 | net/inet/3c509.c | el3_start_xmit(struct sk_buff *skb, struct device *dev) |
dev | 303 | net/inet/3c509.c | struct el3_private *lp = (struct el3_private *)dev->priv; |
dev | 304 | net/inet/3c509.c | int ioaddr = dev->base_addr; |
dev | 307 | net/inet/3c509.c | if (dev->tbusy) { |
dev | 308 | net/inet/3c509.c | int tickssofar = jiffies - dev->trans_start; |
dev | 312 | net/inet/3c509.c | dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS)); |
dev | 313 | net/inet/3c509.c | dev->trans_start = jiffies; |
dev | 317 | net/inet/3c509.c | dev->tbusy = 0; |
dev | 321 | net/inet/3c509.c | dev_tint(dev); |
dev | 326 | net/inet/3c509.c | if (!skb->arp && dev->rebuild_header(skb+1, dev)) { |
dev | 327 | net/inet/3c509.c | skb->dev = dev; |
dev | 337 | net/inet/3c509.c | dev->name, skb->len, inw(ioaddr + EL3_STATUS)); |
dev | 342 | net/inet/3c509.c | dev->name, inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS), |
dev | 350 | net/inet/3c509.c | dev->tbusy=1; |
dev | 358 | net/inet/3c509.c | dev->trans_start = jiffies; |
dev | 363 | net/inet/3c509.c | dev->tbusy=0; |
dev | 393 | net/inet/3c509.c | struct device *dev = (struct device *)(irq2dev_map[irq]); |
dev | 397 | net/inet/3c509.c | if (dev == NULL) { |
dev | 402 | net/inet/3c509.c | if (dev->interrupt) |
dev | 403 | net/inet/3c509.c | printk("%s: Re-entering the interrupt handler.\n", dev->name); |
dev | 404 | net/inet/3c509.c | dev->interrupt = 1; |
dev | 406 | net/inet/3c509.c | ioaddr = dev->base_addr; |
dev | 410 | net/inet/3c509.c | printk("%s: interrupt, status %4.4x.\n", dev->name, status); |
dev | 415 | net/inet/3c509.c | el3_rx(dev); |
dev | 422 | net/inet/3c509.c | dev->tbusy = 0; |
dev | 426 | net/inet/3c509.c | update_stats(ioaddr, dev); |
dev | 430 | net/inet/3c509.c | dev->name, status); |
dev | 438 | net/inet/3c509.c | printk("%s: exiting interrupt, status %4.4x.\n", dev->name, |
dev | 442 | net/inet/3c509.c | dev->interrupt = 0; |
dev | 448 | net/inet/3c509.c | el3_get_stats(struct device *dev) |
dev | 450 | net/inet/3c509.c | struct el3_private *lp = (struct el3_private *)dev->priv; |
dev | 453 | net/inet/3c509.c | update_stats(dev->base_addr, dev); |
dev | 462 | net/inet/3c509.c | static void update_stats(int ioaddr, struct device *dev) |
dev | 464 | net/inet/3c509.c | struct el3_private *lp = (struct el3_private *)dev->priv; |
dev | 491 | net/inet/3c509.c | el3_rx(struct device *dev) |
dev | 493 | net/inet/3c509.c | struct el3_private *lp = (struct el3_private *)dev->priv; |
dev | 494 | net/inet/3c509.c | int ioaddr = dev->base_addr; |
dev | 527 | net/inet/3c509.c | skb->dev = dev; |
dev | 540 | net/inet/3c509.c | IN_SKBUFF,dev)== 0){ |
dev | 553 | net/inet/3c509.c | printk("%s: receive buffers full.\n", dev->name); |
dev | 559 | net/inet/3c509.c | dev->name, sksize); |
dev | 576 | net/inet/3c509.c | el3_close(struct device *dev) |
dev | 578 | net/inet/3c509.c | int ioaddr = dev->base_addr; |
dev | 581 | net/inet/3c509.c | printk("%s: Shutting down ethercard.\n", dev->name); |
dev | 583 | net/inet/3c509.c | dev->tbusy = 1; |
dev | 584 | net/inet/3c509.c | dev->start = 0; |
dev | 593 | net/inet/3c509.c | if (dev->if_port == 3) |
dev | 596 | net/inet/3c509.c | else if (dev->if_port == 0) { |
dev | 602 | net/inet/3c509.c | free_irq(dev->irq); |
dev | 609 | net/inet/3c509.c | irq2dev_map[dev->irq] = 0; |
dev | 611 | net/inet/3c509.c | update_stats(ioaddr, dev); |
dev | 78 | net/inet/8390.c | int ei_open(struct device *dev); |
dev | 81 | net/inet/8390.c | static void ei_tx_intr(struct device *dev); |
dev | 82 | net/inet/8390.c | static void ei_receive(struct device *dev); |
dev | 83 | net/inet/8390.c | static void ei_rx_overrun(struct device *dev); |
dev | 86 | net/inet/8390.c | void NS8390_init(struct device *dev, int startp); |
dev | 87 | net/inet/8390.c | static void NS8390_trigger_send(struct device *dev, unsigned int length, |
dev | 97 | net/inet/8390.c | ei_open(struct device *dev) |
dev | 99 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 102 | net/inet/8390.c | printk("%s: Opening a non-existent physical device\n", dev->name); |
dev | 106 | net/inet/8390.c | irq2dev_map[dev->irq] = dev; |
dev | 107 | net/inet/8390.c | NS8390_init(dev, 1); |
dev | 112 | net/inet/8390.c | dev->tbusy = 0; |
dev | 113 | net/inet/8390.c | dev->interrupt = 0; |
dev | 114 | net/inet/8390.c | dev->start = 1; |
dev | 120 | net/inet/8390.c | ei_start_xmit(struct sk_buff *skb, struct device *dev) |
dev | 122 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 123 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 128 | net/inet/8390.c | if (dev->tbusy) { /* Do timeouts, just like the 8003 driver. */ |
dev | 130 | net/inet/8390.c | int tickssofar = jiffies - dev->trans_start; |
dev | 136 | net/inet/8390.c | dev->name, txsr, isr); |
dev | 140 | net/inet/8390.c | printk("%s: Possible IRQ conflict on IRQ%d?", dev->name, dev->irq); |
dev | 142 | net/inet/8390.c | printk("%s: Possible network cable problem?\n", dev->name); |
dev | 144 | net/inet/8390.c | ei_reset_8390(dev); |
dev | 145 | net/inet/8390.c | NS8390_init(dev, 1); |
dev | 153 | net/inet/8390.c | dev_tint(dev); |
dev | 157 | net/inet/8390.c | if (!skb->arp && dev->rebuild_header(skb+1, dev)) { |
dev | 158 | net/inet/8390.c | skb->dev = dev; |
dev | 169 | net/inet/8390.c | if (dev->interrupt || ei_local->irqlock) { |
dev | 174 | net/inet/8390.c | dev->name, ei_local->irqlock ? " during interrupt" : ""); |
dev | 178 | net/inet/8390.c | tmp_tbusy=dev->tbusy; |
dev | 179 | net/inet/8390.c | dev->tbusy = 1; /* lock dev_tint() in dev.c */ |
dev | 189 | net/inet/8390.c | dev->name, ei_local->tx2, ei_local->lasttx, |
dev | 196 | net/inet/8390.c | dev->name, ei_local->tx1, ei_local->lasttx, |
dev | 203 | net/inet/8390.c | dev->name); |
dev | 206 | net/inet/8390.c | dev->tbusy = tmp_tbusy; |
dev | 211 | net/inet/8390.c | dev->trans_start = jiffies; |
dev | 212 | net/inet/8390.c | ei_block_output(dev, length, (unsigned char *)(skb+1), output_page); |
dev | 214 | net/inet/8390.c | NS8390_trigger_send(dev, send_length, output_page); |
dev | 225 | net/inet/8390.c | dev->trans_start = jiffies; |
dev | 226 | net/inet/8390.c | ei_block_output(dev, length, (unsigned char *)(skb+1), |
dev | 228 | net/inet/8390.c | NS8390_trigger_send(dev, send_length, ei_local->tx_start_page); |
dev | 239 | net/inet/8390.c | dev->tbusy=tmp_tbusy; |
dev | 250 | net/inet/8390.c | struct device *dev = (struct device *)(irq2dev_map[irq]); |
dev | 255 | net/inet/8390.c | if (dev == NULL) { |
dev | 259 | net/inet/8390.c | e8390_base = dev->base_addr; |
dev | 260 | net/inet/8390.c | ei_local = (struct ei_device *) dev->priv; |
dev | 261 | net/inet/8390.c | if (dev->interrupt || ei_local->irqlock) { |
dev | 267 | net/inet/8390.c | dev->name, inb_p(e8390_base + EN0_ISR), |
dev | 272 | net/inet/8390.c | dev->interrupt = 1; |
dev | 278 | net/inet/8390.c | printk("%s: interrupt(isr=%#2.2x).\n", dev->name, |
dev | 289 | net/inet/8390.c | ei_rx_overrun(dev); |
dev | 292 | net/inet/8390.c | ei_receive(dev); |
dev | 296 | net/inet/8390.c | ei_tx_intr(dev); |
dev | 298 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 313 | net/inet/8390.c | printk("%s: unknown interrupt %#2x\n", dev->name, interrupts); |
dev | 317 | net/inet/8390.c | dev->interrupt = 0; |
dev | 324 | net/inet/8390.c | ei_tx_intr(struct device *dev) |
dev | 326 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 328 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 339 | net/inet/8390.c | dev->tbusy = 0; |
dev | 341 | net/inet/8390.c | NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6); |
dev | 342 | net/inet/8390.c | dev->trans_start = jiffies; |
dev | 353 | net/inet/8390.c | dev->tbusy = 0; |
dev | 355 | net/inet/8390.c | NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page); |
dev | 356 | net/inet/8390.c | dev->trans_start = jiffies; |
dev | 364 | net/inet/8390.c | dev->name, ei_local->lasttx); |
dev | 367 | net/inet/8390.c | dev->tbusy = 0; |
dev | 394 | net/inet/8390.c | ei_receive(struct device *dev) |
dev | 396 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 397 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 419 | net/inet/8390.c | dev->name, this_frame, ei_local->current_page); |
dev | 425 | net/inet/8390.c | ei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame, |
dev | 446 | net/inet/8390.c | dev->name, rx_frame.status, rx_frame.next, rx_frame.count, |
dev | 453 | net/inet/8390.c | dev->name, ei_local->current_page, next_frame, |
dev | 461 | net/inet/8390.c | dev->name, ei_local->stat.rx_packets); |
dev | 463 | net/inet/8390.c | ei_reset_8390(dev); |
dev | 464 | net/inet/8390.c | NS8390_init(dev, 1); |
dev | 473 | net/inet/8390.c | dev->name, rx_frame.status, rx_frame.next, rx_frame.count); |
dev | 483 | net/inet/8390.c | ei_block_input(dev, size, (char *)(skb+1), |
dev | 485 | net/inet/8390.c | if (dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev)) { |
dev | 486 | net/inet/8390.c | printk("%s: receive buffers full.\n", dev->name); |
dev | 492 | net/inet/8390.c | dev->name, sksize); |
dev | 500 | net/inet/8390.c | dev->name, rx_frame.status, rx_frame.next, rx_frame.count); |
dev | 508 | net/inet/8390.c | printk("%s: next frame inconsistency, %#2x..", dev->name, next_frame); |
dev | 527 | net/inet/8390.c | ei_rx_overrun(struct device *dev) |
dev | 529 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 531 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 537 | net/inet/8390.c | printk("%s: Receiver overrun.\n", dev->name); |
dev | 549 | net/inet/8390.c | dev->name); |
dev | 550 | net/inet/8390.c | NS8390_init(dev, 1); |
dev | 555 | net/inet/8390.c | ei_receive(dev); |
dev | 564 | net/inet/8390.c | get_stats(struct device *dev) |
dev | 566 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 572 | net/inet/8390.c | ethdev_init(struct device *dev) |
dev | 580 | net/inet/8390.c | dev->buffs[i] = NULL; |
dev | 583 | net/inet/8390.c | if (dev->open == NULL) |
dev | 584 | net/inet/8390.c | dev->open = &ei_open; |
dev | 586 | net/inet/8390.c | dev->get_stats = get_stats; |
dev | 587 | net/inet/8390.c | dev->hard_header = eth_header; |
dev | 588 | net/inet/8390.c | dev->add_arp = eth_add_arp; |
dev | 589 | net/inet/8390.c | dev->queue_xmit = dev_queue_xmit; |
dev | 590 | net/inet/8390.c | dev->rebuild_header = eth_rebuild_header; |
dev | 591 | net/inet/8390.c | dev->type_trans = eth_type_trans; |
dev | 593 | net/inet/8390.c | if (dev->priv == NULL) { |
dev | 596 | net/inet/8390.c | dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL); |
dev | 597 | net/inet/8390.c | memset(dev->priv, 0, sizeof(struct ei_device)); |
dev | 598 | net/inet/8390.c | ei_local = (struct ei_device *)dev->priv; |
dev | 604 | net/inet/8390.c | dev->hard_start_xmit = &ei_start_xmit; |
dev | 606 | net/inet/8390.c | dev->type = ARPHRD_ETHER; |
dev | 607 | net/inet/8390.c | dev->hard_header_len = ETH_HLEN; |
dev | 608 | net/inet/8390.c | dev->mtu = 1500; /* eth_mtu */ |
dev | 609 | net/inet/8390.c | dev->addr_len = ETH_ALEN; |
dev | 610 | net/inet/8390.c | for (i = 0; i < dev->addr_len; i++) { |
dev | 611 | net/inet/8390.c | dev->broadcast[i]=0xff; |
dev | 615 | net/inet/8390.c | dev->flags = IFF_BROADCAST; |
dev | 616 | net/inet/8390.c | dev->family = AF_INET; |
dev | 617 | net/inet/8390.c | dev->pa_addr = 0; |
dev | 618 | net/inet/8390.c | dev->pa_brdaddr = 0; |
dev | 619 | net/inet/8390.c | dev->pa_mask = 0; |
dev | 620 | net/inet/8390.c | dev->pa_alen = sizeof(unsigned long); |
dev | 628 | net/inet/8390.c | void NS8390_init(struct device *dev, int startp) |
dev | 630 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 631 | net/inet/8390.c | struct ei_device *ei_local = (struct ei_device *) dev->priv; |
dev | 660 | net/inet/8390.c | outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i); |
dev | 680 | net/inet/8390.c | static void NS8390_trigger_send(struct device *dev, unsigned int length, |
dev | 683 | net/inet/8390.c | int e8390_base = dev->base_addr; |
dev | 690 | net/inet/8390.c | dev->name); |
dev | 23 | net/inet/8390.h | extern int ethif_init(struct device *dev); |
dev | 24 | net/inet/8390.h | extern int ethdev_init(struct device *dev); |
dev | 25 | net/inet/8390.h | extern void NS8390_init(struct device *dev, int startp); |
dev | 26 | net/inet/8390.h | extern int ei_open(struct device *dev); |
dev | 64 | net/inet/8390.h | #define ei_status (*(struct ei_device *)(dev->priv)) |
dev | 40 | net/inet/Space.c | extern int wd_probe(struct device *dev); |
dev | 41 | net/inet/Space.c | extern int el2_probe(struct device *dev); |
dev | 42 | net/inet/Space.c | extern int ne_probe(struct device *dev); |
dev | 43 | net/inet/Space.c | extern int hp_probe(struct device *dev); |
dev | 53 | net/inet/Space.c | ethif_probe(struct device *dev) |
dev | 55 | net/inet/Space.c | short base_addr = dev->base_addr; |
dev | 62 | net/inet/Space.c | && wd_probe(dev) |
dev | 65 | net/inet/Space.c | && el2_probe(dev) |
dev | 68 | net/inet/Space.c | && ne_probe(dev) |
dev | 71 | net/inet/Space.c | && hp_probe(dev) |
dev | 74 | net/inet/Space.c | && at1500_probe(dev) |
dev | 77 | net/inet/Space.c | && el3_probe(dev) |
dev | 80 | net/inet/Space.c | && znet_probe(dev) |
dev | 83 | net/inet/Space.c | && express_probe(dev) |
dev | 86 | net/inet/Space.c | && atp_probe(dev) |
dev | 89 | net/inet/Space.c | && depca_probe(dev) |
dev | 92 | net/inet/Space.c | && el1_probe(dev) |
dev | 216 | net/inet/Space.c | extern int loopback_init(struct device *dev); |
dev | 227 | net/inet/arp.c | if (!skb->dev->rebuild_header(skb+1, skb->dev)) { |
dev | 232 | net/inet/arp.c | skb->dev->queue_xmit(skb, skb->dev, 0); |
dev | 255 | net/inet/arp.c | arp_response(struct arphdr *arp1, struct device *dev) |
dev | 267 | net/inet/arp.c | dev->hard_header_len, GFP_ATOMIC); |
dev | 281 | net/inet/arp.c | (2 * arp1->ar_pln) + dev->hard_header_len; |
dev | 283 | net/inet/arp.c | hlen = dev->hard_header((unsigned char *)(skb+1), dev, |
dev | 302 | net/inet/arp.c | memcpy(ptr2, dev->dev_addr, arp2->ar_hln); |
dev | 319 | net/inet/arp.c | dev->queue_xmit(skb, dev, 0); |
dev | 431 | net/inet/arp.c | arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt) |
dev | 444 | net/inet/arp.c | if (arp->ar_hln != dev->addr_len || dev->type != NET16(arp->ar_hrd)) { |
dev | 445 | net/inet/arp.c | printk("ARP: Bad packet received on device \"%s\" !\n", dev->name); |
dev | 453 | net/inet/arp.c | printk("ARP: Non-IP request on device \"%s\" !\n", dev->name); |
dev | 512 | net/inet/arp.c | ret = arp_response(arp, dev); |
dev | 520 | net/inet/arp.c | arp_send(unsigned long paddr, struct device *dev, unsigned long saddr) |
dev | 528 | net/inet/arp.c | DPRINTF((DBG_ARP, "dev=%s, ", dev->name)); |
dev | 532 | net/inet/arp.c | sizeof(struct arphdr) + (2 * dev->addr_len) + |
dev | 533 | net/inet/arp.c | dev->hard_header_len + |
dev | 545 | net/inet/arp.c | dev->hard_header_len + (2 * dev->addr_len) + 8; |
dev | 548 | net/inet/arp.c | skb->dev = dev; |
dev | 550 | net/inet/arp.c | tmp = dev->hard_header((unsigned char *)(skb+1), dev, |
dev | 557 | net/inet/arp.c | arp->ar_hrd = htons(dev->type); |
dev | 559 | net/inet/arp.c | arp->ar_hln = dev->addr_len; |
dev | 564 | net/inet/arp.c | memcpy(ptr, dev->dev_addr, arp->ar_hln); |
dev | 568 | net/inet/arp.c | memcpy(ptr, dev->broadcast, arp->ar_hln); |
dev | 574 | net/inet/arp.c | dev->queue_xmit(skb, dev, 0); |
dev | 580 | net/inet/arp.c | arp_find(unsigned char *haddr, unsigned long paddr, struct device *dev, |
dev | 587 | net/inet/arp.c | DPRINTF((DBG_ARP, "dev=%s, saddr=%s)\n", dev->name, in_ntoa(saddr))); |
dev | 591 | net/inet/arp.c | memcpy(haddr, dev->dev_addr, dev->addr_len); |
dev | 594 | net/inet/arp.c | memcpy(haddr, dev->broadcast, dev->addr_len); |
dev | 608 | net/inet/arp.c | memcpy(haddr, apt->ha, dev->addr_len); |
dev | 624 | net/inet/arp.c | arp_send(paddr, dev, saddr); |
dev | 632 | net/inet/arp.c | arp_add(unsigned long addr, unsigned char *haddr, struct device *dev) |
dev | 638 | net/inet/arp.c | DPRINTF((DBG_ARP, "%d, %d)\n", dev->hard_header_len, dev->type)); |
dev | 651 | net/inet/arp.c | memcpy(apt->ha, haddr , dev->addr_len); |
dev | 654 | net/inet/arp.c | arp_create(addr, haddr, dev->addr_len, dev->type); |
dev | 660 | net/inet/arp.c | arp_add_broad(unsigned long addr, struct device *dev) |
dev | 664 | net/inet/arp.c | arp_add(addr, dev->broadcast, dev); |
dev | 52 | net/inet/arp.h | extern int arp_rcv(struct sk_buff *skb, struct device *dev, |
dev | 55 | net/inet/arp.h | struct device *dev, unsigned long saddr); |
dev | 57 | net/inet/arp.h | struct device *dev); |
dev | 58 | net/inet/arp.h | extern void arp_add_broad(unsigned long addr, struct device *dev); |
dev | 125 | net/inet/d_link.c | #define DATA_PORT (dev->base_addr + 0) |
dev | 126 | net/inet/d_link.c | #define STATUS_PORT (dev->base_addr + 1) |
dev | 127 | net/inet/d_link.c | #define COMMAND_PORT (dev->base_addr + 2) |
dev | 228 | net/inet/d_link.c | static int d_link_read_status(struct device *dev); |
dev | 229 | net/inet/d_link.c | static unsigned char d_link_read_byte(int type, struct device *dev); |
dev | 232 | net/inet/d_link.c | static int d_link_open(struct device *dev); |
dev | 233 | net/inet/d_link.c | static int d_link_close(struct device *dev); |
dev | 234 | net/inet/d_link.c | static int d_link_start_xmit(struct sk_buff *skb, struct device *dev); |
dev | 238 | net/inet/d_link.c | static void d_link_tx_intr(struct device *dev); |
dev | 239 | net/inet/d_link.c | static void d_link_rx_intr(struct device *dev); |
dev | 242 | net/inet/d_link.c | int d_link_init(struct device *dev); |
dev | 243 | net/inet/d_link.c | static void adapter_init(struct device *dev, int startp); |
dev | 298 | net/inet/d_link.c | d_link_read_status(struct device *dev) |
dev | 313 | net/inet/d_link.c | d_link_read_byte(int type, struct device *dev) { /* dev used by macros */ |
dev | 347 | net/inet/d_link.c | d_link_open(struct device *dev) |
dev | 349 | net/inet/d_link.c | adapter_init(dev, 1); |
dev | 350 | net/inet/d_link.c | dev->tbusy = 0; /* Transmit busy... */ |
dev | 351 | net/inet/d_link.c | dev->interrupt = 0; |
dev | 352 | net/inet/d_link.c | dev->start = 1; |
dev | 360 | net/inet/d_link.c | d_link_close(struct device *dev) |
dev | 362 | net/inet/d_link.c | dev->start = 0; |
dev | 364 | net/inet/d_link.c | adapter_init(dev, 0); |
dev | 366 | net/inet/d_link.c | irqaction(dev->irq, NULL); |
dev | 376 | net/inet/d_link.c | d_link_start_xmit(struct sk_buff *skb, struct device *dev) |
dev | 391 | net/inet/d_link.c | dev_tint(dev); |
dev | 396 | net/inet/d_link.c | if (!skb->arp && dev->rebuild_header(skb + 1, dev)) { |
dev | 397 | net/inet/d_link.c | skb->dev = dev; |
dev | 405 | net/inet/d_link.c | if (dev->tbusy) { /* Do timeouts, to avoid hangs. */ |
dev | 407 | net/inet/d_link.c | tickssofar = jiffies - dev->trans_start; |
dev | 415 | net/inet/d_link.c | dev->name, |
dev | 435 | net/inet/d_link.c | dev->tbusy = !free_tx_page; /* any more free pages? */ |
dev | 460 | net/inet/d_link.c | dev->trans_start = jiffies; |
dev | 467 | net/inet/d_link.c | dev->trans_start = jiffies; |
dev | 487 | net/inet/d_link.c | struct device *dev = realdev; |
dev | 497 | net/inet/d_link.c | if (dev == NULL) { |
dev | 502 | net/inet/d_link.c | if (dev->start == 0) { |
dev | 507 | net/inet/d_link.c | dev->interrupt = 1; |
dev | 510 | net/inet/d_link.c | localstats = (struct netstats*) dev->priv; |
dev | 512 | net/inet/d_link.c | interrupts = d_link_read_status(dev); |
dev | 532 | net/inet/d_link.c | d_link_tx_intr(dev); |
dev | 536 | net/inet/d_link.c | d_link_rx_intr(dev); |
dev | 541 | net/inet/d_link.c | printk("%s: unknown interrupt %#2x\n", dev->name, interrupts); |
dev | 553 | net/inet/d_link.c | dev->interrupt = 0; |
dev | 565 | net/inet/d_link.c | d_link_tx_intr(struct device *dev) |
dev | 570 | net/inet/d_link.c | dev->tbusy = 0; |
dev | 579 | net/inet/d_link.c | dev->trans_start = jiffies; |
dev | 591 | net/inet/d_link.c | d_link_rx_intr(struct device *dev) |
dev | 601 | net/inet/d_link.c | size = d_link_read_byte(RX_LEN, dev); /* low byte */ |
dev | 602 | net/inet/d_link.c | size = size + (d_link_read_byte(RX_LEN, dev) << 8) - 4; |
dev | 612 | net/inet/d_link.c | printk("%s: Bogus packet size %d.\n", dev->name, size); |
dev | 618 | net/inet/d_link.c | dev->name, sksize); |
dev | 641 | net/inet/d_link.c | *buffer++ = d_link_read_byte(READ_DATA, dev); |
dev | 646 | net/inet/d_link.c | if(dev_rint((unsigned char *)skb, size, IN_SKBUFF, dev)) { |
dev | 647 | net/inet/d_link.c | printk("%s: receive buffers full.\n", dev->name); |
dev | 660 | net/inet/d_link.c | d_link_init(struct device *dev) |
dev | 664 | net/inet/d_link.c | printk("%s: D-Link pocket adapter", dev->name); |
dev | 671 | net/inet/d_link.c | (void)d_link_read_status(dev); |
dev | 674 | net/inet/d_link.c | if (d_link_read_status(dev) & 0xf0) { |
dev | 675 | net/inet/d_link.c | printk(": probe failed at %#3x.\n", dev->base_addr); |
dev | 687 | net/inet/d_link.c | dev->dev_addr[i] = d_link_read_byte(READ_DATA, dev); |
dev | 688 | net/inet/d_link.c | dev->broadcast[i] = 0xff; |
dev | 692 | net/inet/d_link.c | if ((dev->dev_addr[1] == 0xde) && (dev->dev_addr[2] == 0x15)) { |
dev | 694 | net/inet/d_link.c | dev->dev_addr[0] = 0x00; |
dev | 695 | net/inet/d_link.c | dev->dev_addr[1] = 0x80; |
dev | 696 | net/inet/d_link.c | dev->dev_addr[2] = 0xc8; |
dev | 697 | net/inet/d_link.c | dev->dev_addr[3] &= 0x0f; |
dev | 698 | net/inet/d_link.c | dev->dev_addr[3] |= 0x70; |
dev | 705 | net/inet/d_link.c | dev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL); |
dev | 706 | net/inet/d_link.c | memset(dev->priv, 0, sizeof(struct netstats)); |
dev | 709 | net/inet/d_link.c | dev->buffs[i] = NULL; |
dev | 711 | net/inet/d_link.c | dev->hard_header = eth_header; |
dev | 712 | net/inet/d_link.c | dev->add_arp = eth_add_arp; |
dev | 713 | net/inet/d_link.c | dev->queue_xmit = dev_queue_xmit; |
dev | 714 | net/inet/d_link.c | dev->rebuild_header = eth_rebuild_header; |
dev | 715 | net/inet/d_link.c | dev->type_trans = eth_type_trans; |
dev | 717 | net/inet/d_link.c | dev->open = &d_link_open; |
dev | 718 | net/inet/d_link.c | dev->stop = &d_link_close; |
dev | 719 | net/inet/d_link.c | dev->hard_start_xmit = &d_link_start_xmit; |
dev | 722 | net/inet/d_link.c | dev->type = ARPHRD_ETHER; |
dev | 723 | net/inet/d_link.c | dev->hard_header_len = ETH_HLEN; |
dev | 724 | net/inet/d_link.c | dev->mtu = 1500; /* eth_mtu */ |
dev | 725 | net/inet/d_link.c | dev->addr_len = ETH_ALEN; |
dev | 728 | net/inet/d_link.c | dev->flags = IFF_BROADCAST; |
dev | 729 | net/inet/d_link.c | dev->family = AF_INET; |
dev | 730 | net/inet/d_link.c | dev->pa_addr = 0; |
dev | 731 | net/inet/d_link.c | dev->pa_brdaddr = 0; |
dev | 732 | net/inet/d_link.c | dev->pa_mask = 0; |
dev | 733 | net/inet/d_link.c | dev->pa_alen = sizeof(unsigned long); |
dev | 735 | net/inet/d_link.c | if (irqaction (dev->irq, &d_link_sigaction)) { |
dev | 736 | net/inet/d_link.c | printk (": unable to get IRQ %d\n", dev->irq); |
dev | 740 | net/inet/d_link.c | printk(", Ethernet Address: %2.2X", dev->dev_addr[0]); |
dev | 742 | net/inet/d_link.c | printk(":%2.2X",dev->dev_addr[i]); |
dev | 749 | net/inet/d_link.c | adapter_init(struct device *dev, int startp) |
dev | 761 | net/inet/d_link.c | irqaction (dev->irq, &d_link_sigaction); |
dev | 762 | net/inet/d_link.c | realdev = dev; |
dev | 770 | net/inet/d_link.c | d_link_put_byte(dev->dev_addr[i]); |
dev | 123 | net/inet/dev.c | struct device *dev; |
dev | 147 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 148 | net/inet/dev.c | if (dev->pa_addr == 0) continue; |
dev | 151 | net/inet/dev.c | if (addr == dev->pa_addr) { |
dev | 157 | net/inet/dev.c | if ((addr & dev->pa_mask) == (dev->pa_addr & dev->pa_mask)) { |
dev | 158 | net/inet/dev.c | if ((addr & ~dev->pa_mask) == 0) { |
dev | 162 | net/inet/dev.c | if (((addr & ~dev->pa_mask) | dev->pa_mask) |
dev | 186 | net/inet/dev.c | struct device *dev; |
dev | 188 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 189 | net/inet/dev.c | if (dev->flags & IFF_LOOPBACK) return(dev->pa_addr); |
dev | 246 | net/inet/dev.c | struct device *dev; |
dev | 248 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 249 | net/inet/dev.c | if (strcmp(dev->name, name) == 0) return(dev); |
dev | 259 | net/inet/dev.c | struct device *dev; |
dev | 261 | net/inet/dev.c | for (dev = dev_base; dev; dev = dev->next) |
dev | 262 | net/inet/dev.c | if ((dev->flags & IFF_UP) && (dev->flags & IFF_POINTOPOINT) && |
dev | 263 | net/inet/dev.c | (addr == dev->pa_dstaddr)) |
dev | 264 | net/inet/dev.c | return dev; |
dev | 265 | net/inet/dev.c | for (dev = dev_base; dev; dev = dev->next) |
dev | 266 | net/inet/dev.c | if ((dev->flags & IFF_UP) && !(dev->flags & IFF_POINTOPOINT) && |
dev | 267 | net/inet/dev.c | (dev->flags & IFF_LOOPBACK ? (addr == dev->pa_addr) : |
dev | 268 | net/inet/dev.c | (dev->pa_addr & addr) == (dev->pa_addr & dev->pa_mask))) |
dev | 271 | net/inet/dev.c | return dev; |
dev | 277 | net/inet/dev.c | dev_open(struct device *dev) |
dev | 281 | net/inet/dev.c | if (dev->open) ret = dev->open(dev); |
dev | 282 | net/inet/dev.c | if (ret == 0) dev->flags |= (IFF_UP | IFF_RUNNING); |
dev | 290 | net/inet/dev.c | dev_close(struct device *dev) |
dev | 292 | net/inet/dev.c | if (dev->flags != 0) { |
dev | 293 | net/inet/dev.c | dev->flags = 0; |
dev | 294 | net/inet/dev.c | if (dev->stop) dev->stop(dev); |
dev | 295 | net/inet/dev.c | rt_flush(dev); |
dev | 296 | net/inet/dev.c | dev->pa_addr = 0; |
dev | 297 | net/inet/dev.c | dev->pa_dstaddr = 0; |
dev | 298 | net/inet/dev.c | dev->pa_brdaddr = 0; |
dev | 299 | net/inet/dev.c | dev->pa_mask = 0; |
dev | 308 | net/inet/dev.c | dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri) |
dev | 316 | net/inet/dev.c | skb, dev, pri)); |
dev | 318 | net/inet/dev.c | if (dev == NULL) { |
dev | 323 | net/inet/dev.c | skb->dev = dev; |
dev | 326 | net/inet/dev.c | dev->hard_start_xmit(NULL, dev); |
dev | 340 | net/inet/dev.c | if (dev->hard_start_xmit(skb, dev) == 0) { |
dev | 346 | net/inet/dev.c | pri, dev->buffs[pri])); |
dev | 350 | net/inet/dev.c | if (dev->buffs[pri] == NULL) { |
dev | 351 | net/inet/dev.c | dev->buffs[pri] = skb; |
dev | 356 | net/inet/dev.c | skb->next = (struct sk_buff *) dev->buffs[pri]; |
dev | 357 | net/inet/dev.c | skb->prev = (struct sk_buff *) dev->buffs[pri]->prev; |
dev | 360 | net/inet/dev.c | dev->buffs[pri] = skb; |
dev | 362 | net/inet/dev.c | skb2 = (struct sk_buff *) dev->buffs[pri]; |
dev | 416 | net/inet/dev.c | dev_rint(unsigned char *buff, long len, int flags, struct device *dev) |
dev | 424 | net/inet/dev.c | if (dev == NULL || buff == NULL || len <= 0) return(1); |
dev | 438 | net/inet/dev.c | dev->name); |
dev | 451 | net/inet/dev.c | amount = min(len2, (unsigned long) dev->rmem_end - |
dev | 458 | net/inet/dev.c | if ((unsigned long) buff == dev->rmem_end) |
dev | 459 | net/inet/dev.c | buff = (unsigned char *) dev->rmem_start; |
dev | 463 | net/inet/dev.c | skb->dev = dev; |
dev | 475 | net/inet/dev.c | struct device *dev; |
dev | 477 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 478 | net/inet/dev.c | if (!dev->tbusy) { |
dev | 479 | net/inet/dev.c | dev_tint(dev); |
dev | 524 | net/inet/dev.c | skb->h.raw = (unsigned char *) (skb + 1) + skb->dev->hard_header_len; |
dev | 525 | net/inet/dev.c | skb->len -= skb->dev->hard_header_len; |
dev | 536 | net/inet/dev.c | type = skb->dev->type_trans(skb, skb->dev); |
dev | 570 | net/inet/dev.c | ptype->func(skb2, skb->dev, ptype); |
dev | 599 | net/inet/dev.c | dev_tint(struct device *dev) |
dev | 606 | net/inet/dev.c | while (dev->buffs[i] != NULL) { |
dev | 607 | net/inet/dev.c | skb = (struct sk_buff *) dev->buffs[i]; |
dev | 611 | net/inet/dev.c | dev->buffs[i] = NULL; |
dev | 618 | net/inet/dev.c | dev->buffs[i] = NULL; |
dev | 628 | net/inet/dev.c | dev->buffs[i] = NULL; |
dev | 630 | net/inet/dev.c | dev->buffs[i]= skb->next; |
dev | 641 | net/inet/dev.c | dev->queue_xmit(skb, dev, -i - 1); |
dev | 642 | net/inet/dev.c | if (dev->tbusy) return; |
dev | 656 | net/inet/dev.c | struct device *dev; |
dev | 667 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 669 | net/inet/dev.c | strcpy(ifr.ifr_name, dev->name); |
dev | 670 | net/inet/dev.c | (*(struct sockaddr_in *) &ifr.ifr_addr).sin_family = dev->family; |
dev | 671 | net/inet/dev.c | (*(struct sockaddr_in *) &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr; |
dev | 688 | net/inet/dev.c | char *sprintf_stats(char *buffer, struct device *dev) |
dev | 691 | net/inet/dev.c | struct enet_statistics *stats = (dev->get_stats ? dev->get_stats(dev): NULL); |
dev | 695 | net/inet/dev.c | dev->name, |
dev | 706 | net/inet/dev.c | pos += sprintf(pos, "%6s: No statistics available.\n", dev->name); |
dev | 716 | net/inet/dev.c | struct device *dev; |
dev | 722 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev = dev->next) { |
dev | 723 | net/inet/dev.c | pos = sprintf_stats(pos, dev); |
dev | 733 | net/inet/dev.c | struct device *dev; |
dev | 741 | net/inet/dev.c | if ((dev = dev_get(ifr.ifr_name)) == NULL) return(-EINVAL); |
dev | 745 | net/inet/dev.c | ifr.ifr_flags = dev->flags; |
dev | 751 | net/inet/dev.c | int old_flags = dev->flags; |
dev | 752 | net/inet/dev.c | dev->flags = ifr.ifr_flags & ( |
dev | 756 | net/inet/dev.c | if ((old_flags & IFF_UP) && ((dev->flags & IFF_UP) == 0)) { |
dev | 757 | net/inet/dev.c | ret = dev_close(dev); |
dev | 759 | net/inet/dev.c | ret = (! (old_flags & IFF_UP) && (dev->flags & IFF_UP)) |
dev | 760 | net/inet/dev.c | ? dev_open(dev) : 0; |
dev | 765 | net/inet/dev.c | &ifr.ifr_addr).sin_addr.s_addr = dev->pa_addr; |
dev | 767 | net/inet/dev.c | &ifr.ifr_addr).sin_family = dev->family; |
dev | 774 | net/inet/dev.c | dev->pa_addr = (*(struct sockaddr_in *) |
dev | 776 | net/inet/dev.c | dev->family = ifr.ifr_addr.sa_family; |
dev | 777 | net/inet/dev.c | dev->pa_mask = get_mask(dev->pa_addr); |
dev | 778 | net/inet/dev.c | dev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask; |
dev | 783 | net/inet/dev.c | &ifr.ifr_broadaddr).sin_addr.s_addr = dev->pa_brdaddr; |
dev | 785 | net/inet/dev.c | &ifr.ifr_broadaddr).sin_family = dev->family; |
dev | 792 | net/inet/dev.c | dev->pa_brdaddr = (*(struct sockaddr_in *) |
dev | 798 | net/inet/dev.c | &ifr.ifr_dstaddr).sin_addr.s_addr = dev->pa_dstaddr; |
dev | 800 | net/inet/dev.c | &ifr.ifr_broadaddr).sin_family = dev->family; |
dev | 807 | net/inet/dev.c | dev->pa_dstaddr = (*(struct sockaddr_in *) |
dev | 813 | net/inet/dev.c | &ifr.ifr_netmask).sin_addr.s_addr = dev->pa_mask; |
dev | 815 | net/inet/dev.c | &ifr.ifr_netmask).sin_family = dev->family; |
dev | 822 | net/inet/dev.c | dev->pa_mask = (*(struct sockaddr_in *) |
dev | 827 | net/inet/dev.c | ifr.ifr_metric = dev->metric; |
dev | 832 | net/inet/dev.c | dev->metric = ifr.ifr_metric; |
dev | 836 | net/inet/dev.c | ifr.ifr_mtu = dev->mtu; |
dev | 841 | net/inet/dev.c | dev->mtu = ifr.ifr_mtu; |
dev | 864 | net/inet/dev.c | struct ddi_device *dev; |
dev | 870 | net/inet/dev.c | struct device *dev; |
dev | 886 | net/inet/dev.c | dev = dev_get( loopback ? "lo" : ipc.name); |
dev | 887 | net/inet/dev.c | if (dev == NULL) |
dev | 890 | net/inet/dev.c | dev->pa_addr = ipc.paddr; |
dev | 891 | net/inet/dev.c | dev->family = AF_INET; |
dev | 892 | net/inet/dev.c | dev->pa_mask = get_mask(dev->pa_addr); |
dev | 893 | net/inet/dev.c | dev->pa_brdaddr = dev->pa_addr | ~dev->pa_mask; |
dev | 895 | net/inet/dev.c | dev->flags |= IFF_BROADCAST; |
dev | 896 | net/inet/dev.c | dev->pa_brdaddr = ipc.net; |
dev | 901 | net/inet/dev.c | return (dev->flags & IFF_UP != 0) ? dev_close(dev) : 0; |
dev | 903 | net/inet/dev.c | if ((dev->flags & IFF_UP) == 0 |
dev | 904 | net/inet/dev.c | && (retval = dev_open(dev)) != 0) |
dev | 906 | net/inet/dev.c | printk("%s: adding HOST route of %8.8x.\n", dev->name, |
dev | 908 | net/inet/dev.c | rt_add(RTF_HOST, ipc.paddr, 0, dev); |
dev | 910 | net/inet/dev.c | rt_add(RTF_GATEWAY, ipc.paddr, ipc.router, dev); |
dev | 912 | net/inet/dev.c | dev->name, htonl(ipc.paddr)); |
dev | 943 | net/inet/dev.c | dev = ddi_map(iflink.id); |
dev | 944 | net/inet/dev.c | if (dev == NULL) return(-EINVAL); |
dev | 948 | net/inet/dev.c | dev->name, iflink.stream); |
dev | 963 | net/inet/dev.c | struct device *dev, *dev2; |
dev | 971 | net/inet/dev.c | for (dev = dev_base; dev != NULL; dev=dev->next) { |
dev | 972 | net/inet/dev.c | if (dev->init && dev->init(dev)) { |
dev | 973 | net/inet/dev.c | if (dev2 == NULL) dev_base = dev->next; |
dev | 974 | net/inet/dev.c | else dev2->next = dev->next; |
dev | 976 | net/inet/dev.c | dev2 = dev; |
dev | 76 | net/inet/dev.h | int (*init)(struct device *dev); |
dev | 83 | net/inet/dev.h | struct enet_statistics* (*get_stats)(struct device *dev); |
dev | 117 | net/inet/dev.h | int (*open)(struct device *dev); |
dev | 118 | net/inet/dev.h | int (*stop)(struct device *dev); |
dev | 120 | net/inet/dev.h | struct device *dev); |
dev | 122 | net/inet/dev.h | struct device *dev, |
dev | 129 | net/inet/dev.h | struct device *dev); |
dev | 131 | net/inet/dev.h | struct device *dev, int pri); |
dev | 132 | net/inet/dev.h | int (*rebuild_header)(void *eth, struct device *dev); |
dev | 134 | net/inet/dev.h | struct device *dev); |
dev | 168 | net/inet/dev.h | extern int dev_open(struct device *dev); |
dev | 169 | net/inet/dev.h | extern int dev_close(struct device *dev); |
dev | 170 | net/inet/dev.h | extern void dev_queue_xmit(struct sk_buff *skb, struct device *dev, |
dev | 176 | net/inet/dev.h | struct device * dev); |
dev | 179 | net/inet/dev.h | extern void dev_tint(struct device *dev); |
dev | 30 | net/inet/el.c | extern void NS8390_init(struct device *dev, int startp); |
dev | 34 | net/inet/el.c | int el2autoprobe(int ioaddr, struct device *dev); |
dev | 35 | net/inet/el.c | int el2probe(int ioaddr, struct device *dev); |
dev | 37 | net/inet/el.c | static void el2_reset_8390(struct device *dev); |
dev | 38 | net/inet/el.c | static void el2_init_card(struct device *dev); |
dev | 39 | net/inet/el.c | static void el2_block_output(struct device *dev, int count, |
dev | 41 | net/inet/el.c | static int el2_block_input(struct device *dev, int count, char *buf, |
dev | 46 | net/inet/el.c | el2autoprobe(int ioaddr, struct device *dev) |
dev | 53 | net/inet/el.c | return el2probe(ioaddr, dev); |
dev | 65 | net/inet/el.c | if (base_bits == 1 && el2probe(ports[i], dev)) |
dev | 66 | net/inet/el.c | return dev->base_addr; |
dev | 75 | net/inet/el.c | && el2probe(ports[i], dev)) |
dev | 76 | net/inet/el.c | return dev->base_addr; |
dev | 87 | net/inet/el.c | el2probe(int ioaddr, struct device *dev) |
dev | 90 | net/inet/el.c | unsigned char *station_addr = dev->dev_addr; |
dev | 121 | net/inet/el.c | dev->base_addr = ioaddr; |
dev | 126 | net/inet/el.c | dev->mem_start = 0; |
dev | 128 | net/inet/el.c | dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) + |
dev | 135 | net/inet/el.c | int *mem_base = (int *)dev->mem_start; |
dev | 143 | net/inet/el.c | dev->mem_start = 0; |
dev | 154 | net/inet/el.c | dev->mem_end = dev->rmem_end = dev->mem_start + EL2_MEMSIZE; |
dev | 155 | net/inet/el.c | dev->rmem_start = TX_PAGES*256 + dev->mem_start; |
dev | 159 | net/inet/el.c | dev->mem_start, dev->rmem_start, dev->mem_end, dev->rmem_end); |
dev | 176 | net/inet/el.c | if (dev->irq < 2) { |
dev | 180 | net/inet/el.c | if (request_irq (dev->irq = *irqp, NULL) != -EBUSY) { |
dev | 183 | net/inet/el.c | outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR); |
dev | 185 | net/inet/el.c | if (dev->irq == autoirq_report(0) /* It's a good IRQ line! */ |
dev | 186 | net/inet/el.c | && request_irq (dev->irq, &ei_interrupt) == 0) { |
dev | 187 | net/inet/el.c | printk(" got IRQ %d", dev->irq); |
dev | 190 | net/inet/el.c | printk(" IRQ%d busy..", dev->irq); |
dev | 198 | net/inet/el.c | if (dev->irq == 2) |
dev | 199 | net/inet/el.c | dev->irq = 9; |
dev | 200 | net/inet/el.c | else if (dev->irq > 5 && dev->irq != 9) { |
dev | 202 | net/inet/el.c | dev->irq); |
dev | 205 | net/inet/el.c | if (request_irq(dev->irq, &ei_interrupt)) { |
dev | 206 | net/inet/el.c | printk (" unable to get IRQ%d.\n", dev->irq); |
dev | 211 | net/inet/el.c | dev->start = 0; |
dev | 212 | net/inet/el.c | el2_init_card(dev); |
dev | 214 | net/inet/el.c | if (dev->mem_start) |
dev | 216 | net/inet/el.c | dev->name, ei_status.name, dev->irq, |
dev | 217 | net/inet/el.c | dev->mem_start, dev->mem_end-1); |
dev | 220 | net/inet/el.c | dev->name, ei_status.name, dev->irq); |
dev | 232 | net/inet/el.c | el2_reset_8390(struct device *dev) |
dev | 235 | net/inet/el.c | printk("%s: Resetting the 3c503 board...", dev->name); |
dev | 242 | net/inet/el.c | el2_init_card(dev); |
dev | 248 | net/inet/el.c | el2_init_card(struct device *dev) |
dev | 263 | net/inet/el.c | outb_p(0x00, dev->base_addr + EN0_IMR); |
dev | 268 | net/inet/el.c | outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR); |
dev | 278 | net/inet/el.c | el2_block_output(struct device *dev, int count, |
dev | 287 | net/inet/el.c | if (dev->mem_start) { /* Shared memory transfer */ |
dev | 288 | net/inet/el.c | void *dest_addr = (void *)(dev->mem_start + |
dev | 293 | net/inet/el.c | dev->name, dest_addr); |
dev | 296 | net/inet/el.c | dev->name, dest_addr); |
dev | 314 | net/inet/el.c | dev->name, i, count, boguscount); |
dev | 325 | net/inet/el.c | el2_block_input(struct device *dev, int count, char *buf, int ring_offset) |
dev | 328 | net/inet/el.c | int end_of_ring = dev->rmem_end; |
dev | 332 | net/inet/el.c | if (dev->mem_start) { /* Use the shared memory. */ |
dev | 334 | net/inet/el.c | if (dev->mem_start + ring_offset + count > end_of_ring) { |
dev | 336 | net/inet/el.c | int semi_count = end_of_ring - (dev->mem_start + ring_offset); |
dev | 339 | net/inet/el.c | dev->name, dev->mem_start, ring_offset, |
dev | 340 | net/inet/el.c | (char *)dev->mem_start + ring_offset); |
dev | 341 | net/inet/el.c | memcpy(buf, (char *)dev->mem_start + ring_offset, semi_count); |
dev | 343 | net/inet/el.c | memcpy(buf + semi_count, (char *)dev->rmem_start, count); |
dev | 344 | net/inet/el.c | return dev->rmem_start + count; |
dev | 348 | net/inet/el.c | dev->name, dev->mem_start, ring_offset, |
dev | 349 | net/inet/el.c | (char *)dev->mem_start + ring_offset); |
dev | 350 | net/inet/el.c | memcpy(buf, (char *)dev->mem_start + ring_offset, count); |
dev | 366 | net/inet/el.c | dev->name, i, count, boguscount); |
dev | 33 | net/inet/el2.c | int el2_probe(struct device *dev); |
dev | 34 | net/inet/el2.c | int el2_pio_autoprobe(struct device *dev); |
dev | 35 | net/inet/el2.c | int el2probe1(int ioaddr, struct device *dev); |
dev | 37 | net/inet/el2.c | static int el2_open(struct device *dev); |
dev | 38 | net/inet/el2.c | static int el2_close(struct device *dev); |
dev | 39 | net/inet/el2.c | static void el2_reset_8390(struct device *dev); |
dev | 40 | net/inet/el2.c | static void el2_init_card(struct device *dev); |
dev | 41 | net/inet/el2.c | static void el2_block_output(struct device *dev, int count, |
dev | 43 | net/inet/el2.c | static int el2_block_input(struct device *dev, int count, char *buf, |
dev | 58 | net/inet/el2.c | el2_probe(struct device *dev) |
dev | 61 | net/inet/el2.c | short ioaddr = dev->base_addr; |
dev | 66 | net/inet/el2.c | return ! el2probe1(ioaddr, dev); |
dev | 81 | net/inet/el2.c | if (el2probe1(ports[i], dev)) |
dev | 85 | net/inet/el2.c | return el2_pio_autoprobe(dev); |
dev | 94 | net/inet/el2.c | el2_pio_autoprobe(struct device *dev) |
dev | 106 | net/inet/el2.c | && el2probe1(ports[i], dev)) |
dev | 116 | net/inet/el2.c | el2probe1(int ioaddr, struct device *dev) |
dev | 119 | net/inet/el2.c | unsigned char *station_addr = dev->dev_addr; |
dev | 152 | net/inet/el2.c | ethdev_init(dev); |
dev | 156 | net/inet/el2.c | dev->base_addr = ioaddr; |
dev | 168 | net/inet/el2.c | ei_status.interface_num = dev->mem_end & 0xf; |
dev | 172 | net/inet/el2.c | dev->mem_start = 0; |
dev | 174 | net/inet/el2.c | dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) + |
dev | 181 | net/inet/el2.c | int *mem_base = (int *)dev->mem_start; |
dev | 189 | net/inet/el2.c | dev->mem_start = 0; |
dev | 200 | net/inet/el2.c | dev->mem_end = dev->rmem_end = dev->mem_start + EL2_MEMSIZE; |
dev | 201 | net/inet/el2.c | dev->rmem_start = TX_PAGES*256 + dev->mem_start; |
dev | 205 | net/inet/el2.c | dev->mem_start, dev->rmem_start, dev->mem_end, dev->rmem_end); |
dev | 216 | net/inet/el2.c | if (dev->irq == 2) |
dev | 217 | net/inet/el2.c | dev->irq = 9; |
dev | 218 | net/inet/el2.c | else if (dev->irq > 5 && dev->irq != 9) { |
dev | 220 | net/inet/el2.c | dev->irq); |
dev | 221 | net/inet/el2.c | dev->irq = 0; |
dev | 224 | net/inet/el2.c | ei_status.saved_irq = dev->irq; |
dev | 226 | net/inet/el2.c | dev->start = 0; |
dev | 227 | net/inet/el2.c | dev->open = &el2_open; |
dev | 228 | net/inet/el2.c | dev->stop = &el2_close; |
dev | 229 | net/inet/el2.c | el2_init_card(dev); |
dev | 231 | net/inet/el2.c | if (dev->mem_start) |
dev | 233 | net/inet/el2.c | dev->name, ei_status.name, dev->mem_start, dev->mem_end-1); |
dev | 236 | net/inet/el2.c | dev->name, ei_status.name); |
dev | 244 | net/inet/el2.c | el2_open(struct device *dev) |
dev | 247 | net/inet/el2.c | if (dev->irq < 2) { |
dev | 259 | net/inet/el2.c | && request_irq (dev->irq = *irqp, &ei_interrupt) == 0) |
dev | 268 | net/inet/el2.c | if (request_irq(dev->irq, &ei_interrupt)) { |
dev | 272 | net/inet/el2.c | return ei_open(dev); |
dev | 276 | net/inet/el2.c | el2_close(struct device *dev) |
dev | 278 | net/inet/el2.c | free_irq(dev->irq); |
dev | 279 | net/inet/el2.c | dev->irq = ei_status.saved_irq; |
dev | 280 | net/inet/el2.c | irq2dev_map[dev->irq] = NULL; |
dev | 283 | net/inet/el2.c | NS8390_init(dev, 0); |
dev | 293 | net/inet/el2.c | el2_reset_8390(struct device *dev) |
dev | 296 | net/inet/el2.c | printk("%s: Resetting the 3c503 board...", dev->name); |
dev | 303 | net/inet/el2.c | el2_init_card(dev); |
dev | 309 | net/inet/el2.c | el2_init_card(struct device *dev) |
dev | 324 | net/inet/el2.c | outb_p(0x00, dev->base_addr + EN0_IMR); |
dev | 329 | net/inet/el2.c | outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR); |
dev | 339 | net/inet/el2.c | el2_block_output(struct device *dev, int count, |
dev | 348 | net/inet/el2.c | if (dev->mem_start) { /* Shared memory transfer */ |
dev | 349 | net/inet/el2.c | void *dest_addr = (void *)(dev->mem_start + |
dev | 354 | net/inet/el2.c | dev->name, (int) dest_addr); |
dev | 357 | net/inet/el2.c | dev->name, (int) dest_addr); |
dev | 375 | net/inet/el2.c | dev->name, i, count, boguscount); |
dev | 386 | net/inet/el2.c | el2_block_input(struct device *dev, int count, char *buf, int ring_offset) |
dev | 389 | net/inet/el2.c | int end_of_ring = dev->rmem_end; |
dev | 393 | net/inet/el2.c | if (dev->mem_start) { /* Use the shared memory. */ |
dev | 395 | net/inet/el2.c | if (dev->mem_start + ring_offset + count > end_of_ring) { |
dev | 397 | net/inet/el2.c | int semi_count = end_of_ring - (dev->mem_start + ring_offset); |
dev | 400 | net/inet/el2.c | dev->name, dev->mem_start, ring_offset, |
dev | 401 | net/inet/el2.c | dev->mem_start + ring_offset); |
dev | 402 | net/inet/el2.c | memcpy(buf, (char *)dev->mem_start + ring_offset, semi_count); |
dev | 404 | net/inet/el2.c | memcpy(buf + semi_count, (char *)dev->rmem_start, count); |
dev | 405 | net/inet/el2.c | return dev->rmem_start + count; |
dev | 409 | net/inet/el2.c | dev->name, dev->mem_start, ring_offset, |
dev | 410 | net/inet/el2.c | dev->mem_start + ring_offset); |
dev | 411 | net/inet/el2.c | memcpy(buf, (char *)dev->mem_start + ring_offset, count); |
dev | 427 | net/inet/el2.c | dev->name, i, count, boguscount); |
dev | 5 | net/inet/el2reg.h | #define EL2H (dev->base_addr + 0x400) |
dev | 6 | net/inet/el2reg.h | #define EL2L (dev->base_addr) |
dev | 5 | net/inet/elreg.h | #define EL2H (dev->base_addr + 0x400) |
dev | 6 | net/inet/elreg.h | #define EL2L (dev->base_addr) |
dev | 90 | net/inet/eth.c | eth_header(unsigned char *buff, struct device *dev, unsigned short type, |
dev | 101 | net/inet/eth.c | memcpy(eth->h_source, dev->dev_addr, dev->addr_len); |
dev | 104 | net/inet/eth.c | if (dev->flags & IFF_LOOPBACK) { |
dev | 106 | net/inet/eth.c | memset(eth->h_dest, 0, dev->addr_len); |
dev | 107 | net/inet/eth.c | return(dev->hard_header_len); |
dev | 113 | net/inet/eth.c | memcpy(eth->h_dest, dev->broadcast, dev->addr_len); |
dev | 114 | net/inet/eth.c | return(dev->hard_header_len); |
dev | 118 | net/inet/eth.c | if (arp_find(eth->h_dest, daddr, dev, saddr)) { |
dev | 119 | net/inet/eth.c | return(-dev->hard_header_len); |
dev | 120 | net/inet/eth.c | } else return(dev->hard_header_len); |
dev | 126 | net/inet/eth.c | eth_rebuild_header(void *buff, struct device *dev) |
dev | 139 | net/inet/eth.c | if (src != dev->pa_addr) { |
dev | 144 | net/inet/eth.c | src = dev->pa_addr; |
dev | 146 | net/inet/eth.c | if (arp_find(eth->h_dest, dst, dev, src)) return(1); |
dev | 147 | net/inet/eth.c | memcpy(eth->h_source, dev->dev_addr, dev->addr_len); |
dev | 154 | net/inet/eth.c | eth_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev) |
dev | 159 | net/inet/eth.c | arp_add(addr, eth->h_source, dev); |
dev | 165 | net/inet/eth.c | eth_type_trans(struct sk_buff *skb, struct device *dev) |
dev | 27 | net/inet/eth.h | extern int eth_header(unsigned char *buff, struct device *dev, |
dev | 30 | net/inet/eth.h | extern int eth_rebuild_header(void *buff, struct device *dev); |
dev | 32 | net/inet/eth.h | struct device *dev); |
dev | 33 | net/inet/eth.h | extern unsigned short eth_type_trans(struct sk_buff *skb, struct device *dev); |
dev | 43 | net/inet/hp.c | int hp_probe(struct device *dev); |
dev | 44 | net/inet/hp.c | int hpprobe1(int ioaddr, struct device *dev); |
dev | 46 | net/inet/hp.c | static void hp_reset_8390(struct device *dev); |
dev | 47 | net/inet/hp.c | static int hp_block_input(struct device *dev, int count, |
dev | 49 | net/inet/hp.c | static void hp_block_output(struct device *dev, int count, |
dev | 51 | net/inet/hp.c | static void hp_init_card(struct device *dev); |
dev | 62 | net/inet/hp.c | int hp_probe(struct device *dev) |
dev | 65 | net/inet/hp.c | short ioaddr = dev->base_addr; |
dev | 70 | net/inet/hp.c | return ! hpprobe1(ioaddr, dev); |
dev | 77 | net/inet/hp.c | if (inb_p(*port) != 0xff && hpprobe1(*port, dev)) { |
dev | 81 | net/inet/hp.c | dev->base_addr = ioaddr; |
dev | 85 | net/inet/hp.c | int hpprobe1(int ioaddr, struct device *dev) |
dev | 88 | net/inet/hp.c | unsigned char *station_addr = dev->dev_addr; |
dev | 98 | net/inet/hp.c | ethdev_init(dev); |
dev | 113 | net/inet/hp.c | printk("%s: %s at %#3x,", dev->name, ei_status.name, ioaddr); |
dev | 120 | net/inet/hp.c | dev->base_addr = ioaddr + NIC_OFFSET; |
dev | 123 | net/inet/hp.c | if (dev->irq < 2) { |
dev | 128 | net/inet/hp.c | if (request_irq (dev->irq = *irqp, NULL) != -EBUSY) { |
dev | 131 | net/inet/hp.c | outb_p(irqmap[dev->irq] | HP_RUN, ioaddr + HP_CONFIGURE); |
dev | 133 | net/inet/hp.c | if (dev->irq == autoirq_report(0) /* It's a good IRQ line! */ |
dev | 134 | net/inet/hp.c | && request_irq (dev->irq, &ei_interrupt) == 0) { |
dev | 135 | net/inet/hp.c | printk(" selecting IRQ %d.\n", dev->irq); |
dev | 145 | net/inet/hp.c | if (dev->irq == 2) |
dev | 146 | net/inet/hp.c | dev->irq = 9; |
dev | 147 | net/inet/hp.c | if (irqaction(dev->irq, &ei_sigaction)) { |
dev | 148 | net/inet/hp.c | printk (" unable to get IRQ %d.\n", dev->irq); |
dev | 163 | net/inet/hp.c | hp_init_card(dev); |
dev | 164 | net/inet/hp.c | return dev->base_addr; |
dev | 168 | net/inet/hp.c | hp_reset_8390(struct device *dev) |
dev | 170 | net/inet/hp.c | int hp_base = dev->base_addr - NIC_OFFSET; |
dev | 193 | net/inet/hp.c | printk("%s: hp_reset_8390() did not complete.\n", dev->name); |
dev | 205 | net/inet/hp.c | hp_block_input(struct device *dev, int count, char *buf, int ring_offset) |
dev | 207 | net/inet/hp.c | int nic_base = dev->base_addr; |
dev | 233 | net/inet/hp.c | dev->name, ring_offset + xfer_count, addr); |
dev | 240 | net/inet/hp.c | hp_block_output(struct device *dev, int count, |
dev | 243 | net/inet/hp.c | int nic_base = dev->base_addr; |
dev | 290 | net/inet/hp.c | dev->name, (start_page << 8) + count, addr); |
dev | 298 | net/inet/hp.c | hp_init_card(struct device *dev) |
dev | 300 | net/inet/hp.c | int irq = dev->irq; |
dev | 301 | net/inet/hp.c | NS8390_init(dev, 0); |
dev | 303 | net/inet/hp.c | dev->base_addr - NIC_OFFSET + HP_CONFIGURE); |
dev | 75 | net/inet/icmp.c | icmp_send(struct sk_buff *skb_in, int type, int code, struct device *dev) |
dev | 84 | net/inet/icmp.c | skb_in, type, code, dev)); |
dev | 87 | net/inet/icmp.c | len = sizeof(struct sk_buff) + dev->hard_header_len + |
dev | 102 | net/inet/icmp.c | iph = (struct iphdr *) ((unsigned char *) iph + dev->hard_header_len); |
dev | 106 | net/inet/icmp.c | &dev, IPPROTO_ICMP, NULL, len); |
dev | 129 | net/inet/icmp.c | ip_queue_xmit(NULL, dev, skb, 1); |
dev | 199 | net/inet/icmp.c | icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev) |
dev | 209 | net/inet/icmp.c | ip, icmph->un.gateway, dev); |
dev | 213 | net/inet/icmp.c | ip, icmph->un.gateway, dev); |
dev | 231 | net/inet/icmp.c | icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, |
dev | 239 | net/inet/icmp.c | size = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len; |
dev | 252 | net/inet/icmp.c | offset = ip_build_header(skb2, daddr, saddr, &dev, |
dev | 277 | net/inet/icmp.c | ip_queue_xmit((struct sock *)NULL, dev, skb2, 1); |
dev | 286 | net/inet/icmp.c | icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, |
dev | 298 | net/inet/icmp.c | icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, |
dev | 306 | net/inet/icmp.c | size = sizeof(struct sk_buff) + dev->hard_header_len + 64 + len; |
dev | 319 | net/inet/icmp.c | offset = ip_build_header(skb2, daddr, saddr, &dev, |
dev | 339 | net/inet/icmp.c | memcpy((char *) (icmphr + 1), (char *) &dev->pa_mask, sizeof(dev->pa_mask)); |
dev | 346 | net/inet/icmp.c | ip_queue_xmit((struct sock *)NULL, dev, skb2, 1); |
dev | 355 | net/inet/icmp.c | icmp_rcv(struct sk_buff *skb1, struct device *dev, struct options *opt, |
dev | 394 | net/inet/icmp.c | icmp_redirect(icmph, skb1, dev); |
dev | 397 | net/inet/icmp.c | icmp_echo(icmph, skb1, dev, saddr, daddr, len, opt); |
dev | 404 | net/inet/icmp.c | icmp_info(icmph, skb1, dev, saddr, daddr, len, opt); |
dev | 411 | net/inet/icmp.c | icmp_address(icmph, skb1, dev, saddr, daddr, len, opt); |
dev | 27 | net/inet/icmp.h | struct device *dev); |
dev | 28 | net/inet/icmp.h | extern int icmp_rcv(struct sk_buff *skb1, struct device *dev, |
dev | 146 | net/inet/ip.c | ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, |
dev | 155 | net/inet/ip.c | if (dev->hard_header) { |
dev | 156 | net/inet/ip.c | mac = dev->hard_header(ptr, dev, ETH_P_IP, daddr, saddr, len); |
dev | 162 | net/inet/ip.c | skb->dev = dev; |
dev | 175 | net/inet/ip.c | struct device **dev, int type, struct options *opt, int len) |
dev | 188 | net/inet/ip.c | skb, saddr, daddr, *dev, type, opt, len)); |
dev | 192 | net/inet/ip.c | if (*dev == NULL) { |
dev | 196 | net/inet/ip.c | *dev = rt->rt_dev; |
dev | 210 | net/inet/ip.c | tmp = ip_send(skb, raddr, len, *dev, saddr); |
dev | 214 | net/inet/ip.c | skb->dev = *dev; |
dev | 474 | net/inet/ip.c | ip_forward(struct sk_buff *skb, struct device *dev) |
dev | 496 | net/inet/ip.c | icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, dev); |
dev | 512 | net/inet/ip.c | icmp_send(skb, ICMP_DEST_UNREACH, ICMP_NET_UNREACH, dev); |
dev | 530 | net/inet/ip.c | icmp_send(skb, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH, dev); |
dev | 575 | net/inet/ip.c | ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt) |
dev | 610 | net/inet/ip.c | ip_forward(skb, dev); |
dev | 627 | net/inet/ip.c | icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev); |
dev | 672 | net/inet/ip.c | ipprot->handler(skb2, dev, opts_p ? &opt : 0, iph->daddr, |
dev | 686 | net/inet/ip.c | icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PROT_UNREACH, dev); |
dev | 703 | net/inet/ip.c | ip_queue_xmit(struct sock *sk, struct device *dev, |
dev | 710 | net/inet/ip.c | if (dev == NULL) { |
dev | 715 | net/inet/ip.c | skb->dev = dev; |
dev | 720 | net/inet/ip.c | ptr += dev->hard_header_len; |
dev | 722 | net/inet/ip.c | iph->tot_len = ntohs(skb->len - dev->hard_header_len); |
dev | 754 | net/inet/ip.c | if (dev->flags & IFF_UP) { |
dev | 756 | net/inet/ip.c | dev->queue_xmit(skb, dev, sk->priority); |
dev | 758 | net/inet/ip.c | dev->queue_xmit(skb, dev, SOPRI_NORMAL); |
dev | 771 | net/inet/ip.c | struct device *dev; |
dev | 776 | net/inet/ip.c | dev = skb->dev; |
dev | 778 | net/inet/ip.c | if(dev==NULL) |
dev | 790 | net/inet/ip.c | if (dev->rebuild_header((struct enet_header *)(skb+1),dev)) { |
dev | 800 | net/inet/ip.c | if (dev->flags & IFF_UP) { |
dev | 801 | net/inet/ip.c | if (sk) dev->queue_xmit(skb, dev, sk->priority); |
dev | 802 | net/inet/ip.c | else dev->queue_xmit(skb, dev, SOPRI_NORMAL ); |
dev | 35 | net/inet/ip.h | struct device **dev, int type, |
dev | 38 | net/inet/ip.h | extern int ip_rcv(struct sk_buff *skb, struct device *dev, |
dev | 41 | net/inet/ip.h | struct device *dev, struct sk_buff *skb, |
dev | 110 | net/inet/lance.c | int at1500_probe1(struct device *dev); |
dev | 111 | net/inet/lance.c | static int lance_open(struct device *dev); |
dev | 112 | net/inet/lance.c | static void lance_init_ring(struct device *dev); |
dev | 113 | net/inet/lance.c | static int lance_start_xmit(struct sk_buff *skb, struct device *dev); |
dev | 114 | net/inet/lance.c | static int lance_rx(struct device *dev); |
dev | 116 | net/inet/lance.c | static int lance_close(struct device *dev); |
dev | 117 | net/inet/lance.c | static struct enet_statistics *lance_get_stats(struct device *dev); |
dev | 125 | net/inet/lance.c | int at1500_probe(struct device *dev) |
dev | 128 | net/inet/lance.c | int base_addr = dev->base_addr; |
dev | 133 | net/inet/lance.c | return at1500_probe1(dev); |
dev | 157 | net/inet/lance.c | dev->base_addr = probe_addr; |
dev | 158 | net/inet/lance.c | if (at1500_probe1(dev) == 0) |
dev | 162 | net/inet/lance.c | dev->base_addr = base_addr; |
dev | 167 | net/inet/lance.c | at1500_probe1(struct device *dev) |
dev | 170 | net/inet/lance.c | short ioaddr = dev->base_addr; |
dev | 174 | net/inet/lance.c | printk("%s: LANCE at %#3x, address", dev->name, ioaddr); |
dev | 179 | net/inet/lance.c | printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i)); |
dev | 185 | net/inet/lance.c | dev->priv = kmalloc(sizeof(struct lance_private), GFP_KERNEL); |
dev | 187 | net/inet/lance.c | dev->priv = (void *)(((int)dev->priv + 7) & ~0x07); |
dev | 189 | net/inet/lance.c | if ((int)dev->priv & 0xff000000 || (int) rx_buffs & 0xff000000) { |
dev | 194 | net/inet/lance.c | memset(dev->priv, 0, sizeof(struct lance_private)); |
dev | 195 | net/inet/lance.c | lp = (struct lance_private *)dev->priv; |
dev | 199 | net/inet/lance.c | dev->name); |
dev | 206 | net/inet/lance.c | lp->init_block.phys_addr[i] = dev->dev_addr[i]; |
dev | 220 | net/inet/lance.c | if (dev->irq < 2) { |
dev | 226 | net/inet/lance.c | dev->irq = autoirq_report(1); |
dev | 227 | net/inet/lance.c | if (dev->irq) |
dev | 228 | net/inet/lance.c | printk(", using IRQ %d.\n", dev->irq); |
dev | 234 | net/inet/lance.c | printk(" assigned IRQ %d.\n", dev->irq); |
dev | 237 | net/inet/lance.c | dev->dma = dev->mem_start & 0x07; |
dev | 254 | net/inet/lance.c | dev->open = &lance_open; |
dev | 255 | net/inet/lance.c | dev->hard_start_xmit = &lance_start_xmit; |
dev | 256 | net/inet/lance.c | dev->stop = &lance_close; |
dev | 257 | net/inet/lance.c | dev->get_stats = &lance_get_stats; |
dev | 259 | net/inet/lance.c | dev->mem_start = 0; |
dev | 263 | net/inet/lance.c | dev->buffs[i] = NULL; |
dev | 265 | net/inet/lance.c | dev->hard_header = eth_header; |
dev | 266 | net/inet/lance.c | dev->add_arp = eth_add_arp; |
dev | 267 | net/inet/lance.c | dev->queue_xmit = dev_queue_xmit; |
dev | 268 | net/inet/lance.c | dev->rebuild_header = eth_rebuild_header; |
dev | 269 | net/inet/lance.c | dev->type_trans = eth_type_trans; |
dev | 271 | net/inet/lance.c | dev->type = ARPHRD_ETHER; |
dev | 272 | net/inet/lance.c | dev->hard_header_len = ETH_HLEN; |
dev | 273 | net/inet/lance.c | dev->mtu = 1500; /* eth_mtu */ |
dev | 274 | net/inet/lance.c | dev->addr_len = ETH_ALEN; |
dev | 275 | net/inet/lance.c | for (i = 0; i < dev->addr_len; i++) { |
dev | 276 | net/inet/lance.c | dev->broadcast[i]=0xff; |
dev | 280 | net/inet/lance.c | dev->flags = IFF_BROADCAST; |
dev | 281 | net/inet/lance.c | dev->family = AF_INET; |
dev | 282 | net/inet/lance.c | dev->pa_addr = 0; |
dev | 283 | net/inet/lance.c | dev->pa_brdaddr = 0; |
dev | 284 | net/inet/lance.c | dev->pa_mask = 0; |
dev | 285 | net/inet/lance.c | dev->pa_alen = sizeof(unsigned long); |
dev | 292 | net/inet/lance.c | lance_open(struct device *dev) |
dev | 294 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 295 | net/inet/lance.c | int ioaddr = dev->base_addr; |
dev | 298 | net/inet/lance.c | if (request_irq(dev->irq, &lance_interrupt)) { |
dev | 302 | net/inet/lance.c | lp->dma = dev->dma ? dev->dma : DEFAULT_DMA; |
dev | 305 | net/inet/lance.c | free_irq(dev->irq); |
dev | 308 | net/inet/lance.c | irq2dev_map[dev->irq] = dev; |
dev | 329 | net/inet/lance.c | dev->name, dev->irq, lp->dma, (int) lp->tx_ring, (int) lp->rx_ring, |
dev | 332 | net/inet/lance.c | lance_init_ring(dev); |
dev | 345 | net/inet/lance.c | dev->tbusy = 0; |
dev | 346 | net/inet/lance.c | dev->interrupt = 0; |
dev | 347 | net/inet/lance.c | dev->start = 1; |
dev | 356 | net/inet/lance.c | dev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA)); |
dev | 363 | net/inet/lance.c | lance_init_ring(struct device *dev) |
dev | 365 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 379 | net/inet/lance.c | lp->init_block.phys_addr[i] = dev->dev_addr[i]; |
dev | 387 | net/inet/lance.c | lance_start_xmit(struct sk_buff *skb, struct device *dev) |
dev | 389 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 390 | net/inet/lance.c | int ioaddr = dev->base_addr; |
dev | 393 | net/inet/lance.c | if (dev->tbusy) { |
dev | 394 | net/inet/lance.c | int tickssofar = jiffies - dev->trans_start; |
dev | 399 | net/inet/lance.c | dev->name, inw(ioaddr+LANCE_DATA)); |
dev | 401 | net/inet/lance.c | lance_init_ring(dev); |
dev | 404 | net/inet/lance.c | dev->tbusy=0; |
dev | 405 | net/inet/lance.c | dev->trans_start = jiffies; |
dev | 411 | net/inet/lance.c | dev_tint(dev); |
dev | 416 | net/inet/lance.c | if (!skb->arp && dev->rebuild_header(skb+1, dev)) { |
dev | 417 | net/inet/lance.c | skb->dev = dev; |
dev | 427 | net/inet/lance.c | printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name, |
dev | 433 | net/inet/lance.c | dev->tbusy=1; |
dev | 465 | net/inet/lance.c | dev->name, entry, (int) &lp->tx_ring[entry], |
dev | 468 | net/inet/lance.c | dev->name, pkt[0], pkt[1], pkt[2], pkt[5], pkt[6], |
dev | 473 | net/inet/lance.c | dev->trans_start = jiffies; |
dev | 476 | net/inet/lance.c | dev->tbusy=0; |
dev | 487 | net/inet/lance.c | struct device *dev = (struct device *)(irq2dev_map[irq]); |
dev | 491 | net/inet/lance.c | if (dev == NULL) { |
dev | 496 | net/inet/lance.c | ioaddr = dev->base_addr; |
dev | 497 | net/inet/lance.c | lp = (struct lance_private *)dev->priv; |
dev | 498 | net/inet/lance.c | if (dev->interrupt) |
dev | 499 | net/inet/lance.c | printk("%s: Re-entering the interrupt handler.\n", dev->name); |
dev | 501 | net/inet/lance.c | dev->interrupt = 1; |
dev | 503 | net/inet/lance.c | outw(0x00, dev->base_addr + LANCE_ADDR); |
dev | 504 | net/inet/lance.c | csr0 = inw(dev->base_addr + LANCE_DATA); |
dev | 507 | net/inet/lance.c | outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA); |
dev | 511 | net/inet/lance.c | dev->name, csr0, inw(dev->base_addr + LANCE_DATA)); |
dev | 514 | net/inet/lance.c | lance_rx(dev); |
dev | 521 | net/inet/lance.c | dev->name, dirty_tx, (lp->cur_tx & RING_MOD_MASK)); |
dev | 545 | net/inet/lance.c | dev->name, dirty_tx, |
dev | 555 | net/inet/lance.c | outw(0x0000, dev->base_addr + LANCE_ADDR); |
dev | 556 | net/inet/lance.c | outw(0x7f40, dev->base_addr + LANCE_DATA); |
dev | 560 | net/inet/lance.c | dev->name, inw(ioaddr + LANCE_ADDR), |
dev | 561 | net/inet/lance.c | inw(dev->base_addr + LANCE_DATA)); |
dev | 563 | net/inet/lance.c | dev->interrupt = 0; |
dev | 568 | net/inet/lance.c | lance_rx(struct device *dev) |
dev | 570 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 590 | net/inet/lance.c | printk("%s: Memory squeeze, deferring packet.\n", dev->name); |
dev | 597 | net/inet/lance.c | skb->dev = dev; |
dev | 605 | net/inet/lance.c | if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) { |
dev | 627 | net/inet/lance.c | lance_close(struct device *dev) |
dev | 629 | net/inet/lance.c | int ioaddr = dev->base_addr; |
dev | 630 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 632 | net/inet/lance.c | dev->start = 0; |
dev | 633 | net/inet/lance.c | dev->tbusy = 1; |
dev | 642 | net/inet/lance.c | dev->name, inw(ioaddr+LANCE_DATA)); |
dev | 650 | net/inet/lance.c | free_irq(dev->irq); |
dev | 653 | net/inet/lance.c | irq2dev_map[dev->irq] = 0; |
dev | 659 | net/inet/lance.c | lance_get_stats(struct device *dev) |
dev | 661 | net/inet/lance.c | struct lance_private *lp = (struct lance_private *)dev->priv; |
dev | 662 | net/inet/lance.c | short ioaddr = dev->base_addr; |
dev | 47 | net/inet/loopback.c | loopback_xmit(struct sk_buff *skb, struct device *dev) |
dev | 49 | net/inet/loopback.c | struct enet_statistics *stats = (struct enet_statistics *)dev->priv; |
dev | 52 | net/inet/loopback.c | DPRINTF((DBG_LOOPB, "loopback_xmit(dev=%X, skb=%X)\n", dev, skb)); |
dev | 53 | net/inet/loopback.c | if (skb == NULL || dev == NULL) return(0); |
dev | 56 | net/inet/loopback.c | if (dev->tbusy != 0) { |
dev | 61 | net/inet/loopback.c | dev->tbusy = 1; |
dev | 64 | net/inet/loopback.c | done = dev_rint((unsigned char *)(skb+1), skb->len, 0, dev); |
dev | 68 | net/inet/loopback.c | done = dev_rint(NULL, 0, 0, dev); |
dev | 72 | net/inet/loopback.c | dev->tbusy = 0; |
dev | 93 | net/inet/loopback.c | get_stats(struct device *dev) |
dev | 95 | net/inet/loopback.c | return (struct enet_statistics *)dev->priv; |
dev | 100 | net/inet/loopback.c | loopback_init(struct device *dev) |
dev | 102 | net/inet/loopback.c | dev->mtu = 2000; /* MTU */ |
dev | 103 | net/inet/loopback.c | dev->tbusy = 0; |
dev | 104 | net/inet/loopback.c | dev->hard_start_xmit = loopback_xmit; |
dev | 105 | net/inet/loopback.c | dev->open = NULL; |
dev | 107 | net/inet/loopback.c | dev->hard_header = eth_header; |
dev | 108 | net/inet/loopback.c | dev->add_arp = NULL; |
dev | 109 | net/inet/loopback.c | dev->hard_header_len = ETH_HLEN; /* 14 */ |
dev | 110 | net/inet/loopback.c | dev->addr_len = ETH_ALEN; /* 6 */ |
dev | 111 | net/inet/loopback.c | dev->type = ARPHRD_ETHER; /* 0x0001 */ |
dev | 112 | net/inet/loopback.c | dev->type_trans = eth_type_trans; |
dev | 113 | net/inet/loopback.c | dev->rebuild_header = eth_rebuild_header; |
dev | 115 | net/inet/loopback.c | dev->hard_header_length = 0; |
dev | 116 | net/inet/loopback.c | dev->add_arp = NULL; |
dev | 117 | net/inet/loopback.c | dev->addr_len = 0; |
dev | 118 | net/inet/loopback.c | dev->type = 0; /* loopback_type (0) */ |
dev | 119 | net/inet/loopback.c | dev->hard_header = NULL; |
dev | 120 | net/inet/loopback.c | dev->type_trans = NULL; |
dev | 121 | net/inet/loopback.c | dev->rebuild_header = NULL; |
dev | 123 | net/inet/loopback.c | dev->queue_xmit = dev_queue_xmit; |
dev | 126 | net/inet/loopback.c | dev->flags = IFF_LOOPBACK; |
dev | 127 | net/inet/loopback.c | dev->family = AF_INET; |
dev | 128 | net/inet/loopback.c | dev->pa_addr = in_aton("127.0.0.1"); |
dev | 129 | net/inet/loopback.c | dev->pa_brdaddr = in_aton("127.255.255.255"); |
dev | 130 | net/inet/loopback.c | dev->pa_mask = in_aton("255.0.0.0"); |
dev | 131 | net/inet/loopback.c | dev->pa_alen = sizeof(unsigned long); |
dev | 132 | net/inet/loopback.c | dev->priv = kmalloc(sizeof(struct enet_statistics), GFP_KERNEL); |
dev | 133 | net/inet/loopback.c | memset(dev->priv, 0, sizeof(struct enet_statistics)); |
dev | 134 | net/inet/loopback.c | dev->get_stats = get_stats; |
dev | 35 | net/inet/ne.c | #define NE_BASE (dev->base_addr) |
dev | 45 | net/inet/ne.c | int ne_probe(struct device *dev); |
dev | 46 | net/inet/ne.c | static int neprobe1(int ioaddr, struct device *dev, int verbose); |
dev | 48 | net/inet/ne.c | static void ne_reset_8390(struct device *dev); |
dev | 49 | net/inet/ne.c | static int ne_block_input(struct device *dev, int count, |
dev | 51 | net/inet/ne.c | static void ne_block_output(struct device *dev, const int count, |
dev | 76 | net/inet/ne.c | int ne_probe(struct device *dev) |
dev | 79 | net/inet/ne.c | short ioaddr = dev->base_addr; |
dev | 84 | net/inet/ne.c | return ! neprobe1(ioaddr, dev, 1); |
dev | 91 | net/inet/ne.c | if (inb_p(*port) != 0xff && neprobe1(*port, dev, 0)) { |
dev | 92 | net/inet/ne.c | dev->base_addr = *port; |
dev | 96 | net/inet/ne.c | dev->base_addr = ioaddr; |
dev | 100 | net/inet/ne.c | static int neprobe1(int ioaddr, struct device *dev, int verbose) |
dev | 177 | net/inet/ne.c | dev->dev_addr[i] = SA_prom[i]; |
dev | 206 | net/inet/ne.c | if (dev->irq < 2) { |
dev | 213 | net/inet/ne.c | dev->irq = autoirq_report(0); |
dev | 215 | net/inet/ne.c | printk(" autoirq is %d", dev->irq); |
dev | 216 | net/inet/ne.c | } else if (dev->irq == 2) |
dev | 219 | net/inet/ne.c | dev->irq = 9; |
dev | 224 | net/inet/ne.c | int irqval = irqaction (dev->irq, &ei_sigaction); |
dev | 226 | net/inet/ne.c | printk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval); |
dev | 231 | net/inet/ne.c | dev->base_addr = ioaddr; |
dev | 237 | net/inet/ne.c | ethdev_init(dev); |
dev | 239 | net/inet/ne.c | dev->name, name, ioaddr, dev->irq); |
dev | 258 | net/inet/ne.c | NS8390_init(dev, 0); |
dev | 259 | net/inet/ne.c | return dev->base_addr; |
dev | 265 | net/inet/ne.c | ne_reset_8390(struct device *dev) |
dev | 277 | net/inet/ne.c | printk("%s: ne_reset_8390() did not complete.\n", dev->name); |
dev | 288 | net/inet/ne.c | ne_block_input(struct device *dev, int count, char *buf, int ring_offset) |
dev | 291 | net/inet/ne.c | int nic_base = dev->base_addr; |
dev | 297 | net/inet/ne.c | dev->name, ei_status.dmaing, ei_status.irqlock); |
dev | 333 | net/inet/ne.c | dev->name, ring_offset + xfer_count, addr); |
dev | 340 | net/inet/ne.c | ne_block_output(struct device *dev, int count, |
dev | 355 | net/inet/ne.c | dev->name, ei_status.dmaing, ei_status.irqlock); |
dev | 408 | net/inet/ne.c | dev->name, (start_page << 8) + count, addr); |
dev | 48 | net/inet/packet.c | packet_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt) |
dev | 53 | net/inet/packet.c | skb->dev = dev; |
dev | 54 | net/inet/packet.c | skb->len += dev->hard_header_len; |
dev | 105 | net/inet/packet.c | struct device *dev; |
dev | 133 | net/inet/packet.c | dev = dev_get(saddr.sa_data); |
dev | 134 | net/inet/packet.c | if (dev == NULL) { |
dev | 142 | net/inet/packet.c | if (dev->flags & IFF_UP) dev->queue_xmit(skb, dev, sk->priority); |
dev | 246 | net/inet/packet.c | addr.sa_family = skb->dev->type; |
dev | 247 | net/inet/packet.c | memcpy(addr.sa_data,skb->dev->name, 14); |
dev | 122 | net/inet/plip.c | extern int plip_probe(int ioaddr, struct device *dev); |
dev | 123 | net/inet/plip.c | static int plip_open(struct device *dev); |
dev | 124 | net/inet/plip.c | static int plip_close(struct device *dev); |
dev | 125 | net/inet/plip.c | static int plip_tx_packet(struct sk_buff *skb, struct device *dev); |
dev | 126 | net/inet/plip.c | static int plip_header (unsigned char *buff, struct device *dev, |
dev | 136 | net/inet/plip.c | static void plip_device_clear(struct device *dev); |
dev | 137 | net/inet/plip.c | static void plip_receiver_error(struct device *dev); |
dev | 138 | net/inet/plip.c | static void plip_set_physicaladdr(struct device *dev, unsigned long ipaddr); |
dev | 140 | net/inet/plip.c | static int plip_send_enethdr(struct device *dev, struct ethhdr *eth); |
dev | 141 | net/inet/plip.c | static int plip_rebuild_enethdr(struct device *dev, struct ethhdr *eth, |
dev | 146 | net/inet/plip.c | static int plip_receive_packet(struct device *dev); |
dev | 147 | net/inet/plip.c | static int plip_send_packet(struct device *dev, unsigned char *buf, int length); |
dev | 148 | net/inet/plip.c | static int plip_send_start(struct device *dev, struct ethhdr *eth); |
dev | 150 | net/inet/plip.c | static struct enet_statistics *plip_get_stats(struct device *dev); |
dev | 153 | net/inet/plip.c | plip_init(struct device *dev) |
dev | 155 | net/inet/plip.c | int port_base = dev->base_addr; |
dev | 174 | net/inet/plip.c | dev->priv = kmalloc(sizeof(struct netstats), GFP_KERNEL); |
dev | 175 | net/inet/plip.c | memset(dev->priv, 0, sizeof(struct netstats)); |
dev | 178 | net/inet/plip.c | dev->buffs[i] = NULL; |
dev | 179 | net/inet/plip.c | dev->hard_header = &plip_header; |
dev | 180 | net/inet/plip.c | dev->add_arp = eth_add_arp; |
dev | 181 | net/inet/plip.c | dev->queue_xmit = dev_queue_xmit; |
dev | 182 | net/inet/plip.c | dev->rebuild_header = eth_rebuild_header; |
dev | 183 | net/inet/plip.c | dev->type_trans = eth_type_trans; |
dev | 185 | net/inet/plip.c | dev->open = &plip_open; |
dev | 186 | net/inet/plip.c | dev->stop = &plip_close; |
dev | 187 | net/inet/plip.c | dev->hard_start_xmit = &plip_tx_packet; |
dev | 188 | net/inet/plip.c | dev->get_stats = &plip_get_stats; |
dev | 191 | net/inet/plip.c | dev->type = ARPHRD_ETHER; |
dev | 192 | net/inet/plip.c | dev->hard_header_len = ETH_HLEN; |
dev | 193 | net/inet/plip.c | dev->mtu = PLIP_MTU; /* PLIP may later negotiate max pkt size */ |
dev | 194 | net/inet/plip.c | dev->addr_len = ETH_ALEN; |
dev | 195 | net/inet/plip.c | for (i = 0; i < dev->addr_len; i++) { |
dev | 196 | net/inet/plip.c | dev->broadcast[i]=0xff; |
dev | 197 | net/inet/plip.c | dev->dev_addr[i] = 0; |
dev | 200 | net/inet/plip.c | dev->name, dev->base_addr, dev->irq); |
dev | 215 | net/inet/plip.c | plip_open(struct device *dev) |
dev | 217 | net/inet/plip.c | if (dev->irq == 0) |
dev | 218 | net/inet/plip.c | dev->irq = 7; |
dev | 219 | net/inet/plip.c | if (request_irq(dev->irq , &plip_interrupt) != 0) { |
dev | 220 | net/inet/plip.c | PRINTK(("%s: couldn't get IRQ %d.\n", dev->name, dev->irq)); |
dev | 224 | net/inet/plip.c | irq2dev_map[dev->irq] = dev; |
dev | 225 | net/inet/plip.c | plip_device_clear(dev); |
dev | 226 | net/inet/plip.c | dev->tbusy = 0; |
dev | 227 | net/inet/plip.c | dev->interrupt = 0; |
dev | 228 | net/inet/plip.c | dev->start = 1; |
dev | 234 | net/inet/plip.c | plip_close(struct device *dev) |
dev | 236 | net/inet/plip.c | dev->tbusy = 1; |
dev | 237 | net/inet/plip.c | dev->start = 0; |
dev | 238 | net/inet/plip.c | free_irq(dev->irq); |
dev | 239 | net/inet/plip.c | irq2dev_map[dev->irq] = NULL; |
dev | 240 | net/inet/plip.c | outb(0x00, dev->base_addr); /* Release the interrupt. */ |
dev | 245 | net/inet/plip.c | plip_tx_packet(struct sk_buff *skb, struct device *dev) |
dev | 249 | net/inet/plip.c | if (dev->tbusy || dev->interrupt) { /* Do timeouts, to avoid hangs. */ |
dev | 250 | net/inet/plip.c | int tickssofar = jiffies - dev->trans_start; |
dev | 253 | net/inet/plip.c | printk("%s: transmit timed out\n", dev->name); |
dev | 255 | net/inet/plip.c | plip_device_clear(dev); |
dev | 263 | net/inet/plip.c | dev_tint(dev); |
dev | 269 | net/inet/plip.c | if (!skb->arp && dev->rebuild_header(skb+1, dev)) { |
dev | 270 | net/inet/plip.c | skb->dev = dev; |
dev | 275 | net/inet/plip.c | dev->trans_start = jiffies; |
dev | 276 | net/inet/plip.c | ret_val = plip_send_packet(dev, (unsigned char *)(skb+1), skb->len); |
dev | 279 | net/inet/plip.c | dev->tbusy = 0; |
dev | 285 | net/inet/plip.c | plip_header (unsigned char *buff, struct device *dev, |
dev | 289 | net/inet/plip.c | if (dev->dev_addr[0] == 0) { |
dev | 291 | net/inet/plip.c | plip_set_physicaladdr(dev, h_source); |
dev | 293 | net/inet/plip.c | return eth_header(buff, dev, type, h_dest, h_source, len); |
dev | 297 | net/inet/plip.c | plip_device_clear(struct device *dev) |
dev | 299 | net/inet/plip.c | dev->interrupt = 0; |
dev | 300 | net/inet/plip.c | dev->tbusy = 0; |
dev | 301 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_DATA); |
dev | 302 | net/inet/plip.c | outb(0x10, dev->base_addr + PAR_CONTROL); /* Enable the rx interrupt. */ |
dev | 306 | net/inet/plip.c | plip_receiver_error(struct device *dev) |
dev | 308 | net/inet/plip.c | dev->interrupt = 0; |
dev | 309 | net/inet/plip.c | dev->tbusy = 0; |
dev | 310 | net/inet/plip.c | outb(0x02, dev->base_addr + PAR_DATA); |
dev | 311 | net/inet/plip.c | outb(0x10, dev->base_addr + PAR_CONTROL); /* Enable the rx interrupt. */ |
dev | 315 | net/inet/plip.c | get_byte(struct device *dev) |
dev | 321 | net/inet/plip.c | val = inb(dev->base_addr + PAR_STATUS); |
dev | 325 | net/inet/plip.c | val = inb(dev->base_addr + PAR_STATUS); |
dev | 332 | net/inet/plip.c | val = inb(dev->base_addr + PAR_STATUS); |
dev | 334 | net/inet/plip.c | outb(0x11, dev->base_addr + PAR_DATA); |
dev | 338 | net/inet/plip.c | val = inb(dev->base_addr + PAR_STATUS); |
dev | 345 | net/inet/plip.c | val = inb(dev->base_addr + PAR_STATUS); |
dev | 348 | net/inet/plip.c | outb(0x01, dev->base_addr + PAR_DATA); |
dev | 363 | net/inet/plip.c | struct device *dev = irq2dev_map[irq]; |
dev | 366 | net/inet/plip.c | if (dev == NULL) { |
dev | 370 | net/inet/plip.c | localstats = (struct netstats*) dev->priv; |
dev | 371 | net/inet/plip.c | if (dev->tbusy || dev->interrupt) return; |
dev | 372 | net/inet/plip.c | dev->interrupt = 1; |
dev | 373 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_CONTROL); /* Disable the rx interrupt. */ |
dev | 375 | net/inet/plip.c | PRINTK2(("%s: interrupt. ", dev->name)); |
dev | 380 | net/inet/plip.c | while ((inb(dev->base_addr + PAR_STATUS) & 0xf8) != 0xc0) { |
dev | 383 | net/inet/plip.c | dev->name, inb(dev->base_addr + PAR_STATUS))); |
dev | 384 | net/inet/plip.c | plip_device_clear(dev); |
dev | 389 | net/inet/plip.c | if (plip_receive_packet(dev)) { |
dev | 392 | net/inet/plip.c | plip_receiver_error(dev); |
dev | 394 | net/inet/plip.c | plip_device_clear(dev); |
dev | 399 | net/inet/plip.c | plip_receive_packet(struct device *dev) |
dev | 408 | net/inet/plip.c | localstats = (struct netstats*) dev->priv; |
dev | 410 | net/inet/plip.c | outb(1, dev->base_addr + PAR_DATA); /* Ack: 'Ready' */ |
dev | 414 | net/inet/plip.c | plip_type = get_byte(dev); |
dev | 416 | net/inet/plip.c | length = get_byte(dev) << 8; |
dev | 417 | net/inet/plip.c | length |= get_byte(dev); |
dev | 424 | net/inet/plip.c | *eth_p = get_byte(dev); |
dev | 432 | net/inet/plip.c | h_dest = get_byte(dev); |
dev | 433 | net/inet/plip.c | h_source = get_byte(dev); |
dev | 434 | net/inet/plip.c | type = get_byte(dev) << 8; |
dev | 435 | net/inet/plip.c | type |= get_byte(dev); |
dev | 436 | net/inet/plip.c | plip_rebuild_enethdr(dev, ð, h_dest, h_source, type); |
dev | 440 | net/inet/plip.c | PRINTK(("%s: wrong header octet\n", dev->name)); |
dev | 443 | net/inet/plip.c | if (length > dev->mtu || length < 8) { |
dev | 444 | net/inet/plip.c | PRINTK2(("%s: bogus packet size %d.\n", dev->name, length)); |
dev | 457 | net/inet/plip.c | dev->name, sksize)); |
dev | 475 | net/inet/plip.c | unsigned char new_byte = get_byte(dev); |
dev | 480 | net/inet/plip.c | if (checksum != get_byte(dev)) { |
dev | 484 | net/inet/plip.c | } else if(dev_rint((unsigned char *)skb, length, IN_SKBUFF, dev)) { |
dev | 485 | net/inet/plip.c | printk("%s: rcv buff full.\n", dev->name); |
dev | 495 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_DATA); |
dev | 497 | net/inet/plip.c | while ( (inb(dev->base_addr + PAR_STATUS) & 0xf8) != 0x80 ) { |
dev | 510 | net/inet/plip.c | static int send_byte(struct device *dev, unsigned char val) |
dev | 514 | net/inet/plip.c | if (!(inb(dev->base_addr+PAR_STATUS) & 0x08)) { |
dev | 519 | net/inet/plip.c | outb(val, dev->base_addr); /* this makes data bits more stable */ |
dev | 520 | net/inet/plip.c | outb(0x10 | val, dev->base_addr); |
dev | 522 | net/inet/plip.c | while( inb(dev->base_addr+PAR_STATUS) & 0x80 ) |
dev | 527 | net/inet/plip.c | outb(0x10 | (val >> 4), dev->base_addr); |
dev | 528 | net/inet/plip.c | outb(val >> 4, dev->base_addr); |
dev | 530 | net/inet/plip.c | while( (inb(dev->base_addr+PAR_STATUS) & 0x80) == 0 ) |
dev | 552 | net/inet/plip.c | plip_send_start(struct device *dev, struct ethhdr *eth) |
dev | 557 | net/inet/plip.c | struct netstats *localstats = (struct netstats*) dev->priv; |
dev | 562 | net/inet/plip.c | while ( ((status = inb(dev->base_addr+PAR_STATUS)) & 0x08) == 0 ) { |
dev | 563 | net/inet/plip.c | dev->tbusy = 1; |
dev | 564 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_CONTROL); /* Disable my rx intr. */ |
dev | 565 | net/inet/plip.c | outb(0x08, dev->base_addr + PAR_DATA); /* Trigger remote rx intr. */ |
dev | 575 | net/inet/plip.c | if (plip_receive_packet(dev)) { |
dev | 578 | net/inet/plip.c | outb(0x02, dev->base_addr + PAR_DATA); |
dev | 580 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_DATA); |
dev | 588 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_DATA); |
dev | 594 | net/inet/plip.c | plip_device_clear(dev); |
dev | 597 | net/inet/plip.c | dev->name)); |
dev | 606 | net/inet/plip.c | plip_send_packet(struct device *dev, unsigned char *buf, int length) |
dev | 613 | net/inet/plip.c | dev->name, length, buf[0], buf[1], buf[2], buf[3], buf[4])); |
dev | 614 | net/inet/plip.c | if (length > dev->mtu) { |
dev | 615 | net/inet/plip.c | printk("%s: packet too big, %d.\n", dev->name, length); |
dev | 618 | net/inet/plip.c | localstats = (struct netstats*) dev->priv; |
dev | 624 | net/inet/plip.c | while ( (i = (inb(dev->base_addr+PAR_STATUS) & 0xe8)) != 0x80 ) { |
dev | 643 | net/inet/plip.c | if (plip_send_start(dev, (struct ethhdr *)buf) < 0) |
dev | 660 | net/inet/plip.c | send_byte(dev, plip_type); /* send header octet */ |
dev | 670 | net/inet/plip.c | send_byte(dev, length >> 8); send_byte(dev, length); |
dev | 678 | net/inet/plip.c | plip_send_enethdr(dev, (struct ethhdr*)buf); |
dev | 682 | net/inet/plip.c | send_byte(dev, *buf); |
dev | 689 | net/inet/plip.c | if (send_byte(dev, buf[i]) < 0) { |
dev | 694 | net/inet/plip.c | send_byte(dev, checksum & 0xff); |
dev | 700 | net/inet/plip.c | outb(0x00, dev->base_addr + PAR_DATA); |
dev | 703 | net/inet/plip.c | while ((inb(dev->base_addr + PAR_STATUS) & 0xe8) != 0x80) { |
dev | 711 | net/inet/plip.c | if (inb(dev->base_addr + PAR_STATUS) & 0x10) { |
dev | 716 | net/inet/plip.c | plip_device_clear(dev); |
dev | 726 | net/inet/plip.c | plip_set_physicaladdr(struct device *dev, unsigned long ipaddr) |
dev | 733 | net/inet/plip.c | unsigned char *addr = dev->dev_addr; |
dev | 737 | net/inet/plip.c | PRINTK2(("%s: set physical address to %08x\n", dev->name, ipaddr)); |
dev | 759 | net/inet/plip.c | plip_send_enethdr(struct device *dev, struct ethhdr *eth) |
dev | 761 | net/inet/plip.c | send_byte(dev, eth->h_dest[ETH_ALEN-1]); |
dev | 762 | net/inet/plip.c | send_byte(dev, eth->h_source[ETH_ALEN-1]); |
dev | 763 | net/inet/plip.c | send_byte(dev, eth->h_proto >> 8); |
dev | 764 | net/inet/plip.c | send_byte(dev, eth->h_proto); |
dev | 769 | net/inet/plip.c | plip_rebuild_enethdr(struct device *dev, struct ethhdr *eth, |
dev | 774 | net/inet/plip.c | memcpy(eth->h_dest, dev->dev_addr, ETH_ALEN-1); |
dev | 776 | net/inet/plip.c | memcpy(eth->h_source, dev->dev_addr, ETH_ALEN-1); |
dev | 803 | net/inet/plip.c | plip_get_stats(struct device *dev) |
dev | 805 | net/inet/plip.c | struct netstats *localstats = (struct netstats*) dev->priv; |
dev | 26 | net/inet/protocol.h | int (*handler)(struct sk_buff *skb, struct device *dev, |
dev | 85 | net/inet/raw.c | raw_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, |
dev | 93 | net/inet/raw.c | skb, dev, opt, daddr, len, saddr, redo, protocol)); |
dev | 109 | net/inet/raw.c | skb->dev = dev; |
dev | 167 | net/inet/raw.c | struct device *dev=NULL; |
dev | 229 | net/inet/raw.c | sin.sin_addr.s_addr, &dev, |
dev | 255 | net/inet/raw.c | sk->prot->queue_xmit(sk, dev, skb, 1); |
dev | 26 | net/inet/raw.h | extern int raw_rcv(struct sk_buff *skb, struct device *dev, |
dev | 85 | net/inet/route.c | rt_flush(struct device *dev) |
dev | 89 | net/inet/route.c | DPRINTF((DBG_RT, "RT: flushing for dev 0x%08lx (%s)\n", (long)dev, dev->name)); |
dev | 93 | net/inet/route.c | if (r->rt_dev == dev) { |
dev | 108 | net/inet/route.c | rt_add(short flags, unsigned long dst, unsigned long gw, struct device *dev) |
dev | 125 | net/inet/route.c | rt->rt_dev = dev; |
dev | 137 | net/inet/route.c | rt->rt_dst = (dst & dev->pa_mask); |
dev | 202 | net/inet/route.c | struct device *dev; |
dev | 221 | net/inet/route.c | dev = dev_check(((struct sockaddr_in *) &r->rt_dst)->sin_addr.s_addr); |
dev | 225 | net/inet/route.c | dev = rt->rt_dev; |
dev | 227 | net/inet/route.c | dev = NULL; |
dev | 233 | net/inet/route.c | r->rt_flags, dev, (dev == NULL) ? "NONE" : dev->name)); |
dev | 235 | net/inet/route.c | if (dev == NULL) return(-ENETUNREACH); |
dev | 238 | net/inet/route.c | (*(struct sockaddr_in *) &r->rt_gateway).sin_addr.s_addr, dev); |
dev | 326 | net/inet/route.c | struct device *dev; |
dev | 343 | net/inet/route.c | dev = dev_get(namebuf); |
dev | 344 | net/inet/route.c | rt.rt_dev = dev; |
dev | 38 | net/inet/route.h | extern void rt_flush(struct device *dev); |
dev | 40 | net/inet/route.h | unsigned long gw, struct device *dev); |
dev | 33 | net/inet/skbuff.h | struct device *dev; |
dev | 116 | net/inet/slip.c | sl_initialize(struct slip *sl, struct device *dev) |
dev | 122 | net/inet/slip.c | sl->line = dev->base_addr; |
dev | 124 | net/inet/slip.c | sl->dev = dev; |
dev | 134 | net/inet/slip.c | dev->rmem_end = (unsigned long) NULL; |
dev | 135 | net/inet/slip.c | dev->rmem_start = (unsigned long) NULL; |
dev | 136 | net/inet/slip.c | dev->mem_end = (unsigned long) NULL; |
dev | 137 | net/inet/slip.c | dev->mem_start = (unsigned long) NULL; |
dev | 237 | net/inet/slip.c | sl->dev->tbusy = 1; |
dev | 251 | net/inet/slip.c | sl->dev->tbusy = 0; |
dev | 297 | net/inet/slip.c | DPRINTF((DBG_SLIP, "<< \"%s\" recv:\r\n", sl->dev->name)); |
dev | 305 | net/inet/slip.c | done = dev_rint(sl->rbuff, count, 0, sl->dev); |
dev | 319 | net/inet/slip.c | dev_tint(sl->dev); |
dev | 332 | net/inet/slip.c | DPRINTF((DBG_SLIP, ">> \"%s\" sent:\r\n", sl->dev->name)); |
dev | 388 | net/inet/slip.c | sl_xmit(struct sk_buff *skb, struct device *dev) |
dev | 394 | net/inet/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 397 | net/inet/slip.c | dev->name, skb, sl->sending)); |
dev | 422 | net/inet/slip.c | sl_type_trans (struct sk_buff *skb, struct device *dev) |
dev | 430 | net/inet/slip.c | sl_header(unsigned char *buff, struct device *dev, unsigned short type, |
dev | 439 | net/inet/slip.c | sl_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev) |
dev | 446 | net/inet/slip.c | sl_rebuild_header(void *buff, struct device *dev) |
dev | 454 | net/inet/slip.c | sl_open(struct device *dev) |
dev | 460 | net/inet/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 465 | net/inet/slip.c | sl->dev = dev; |
dev | 475 | net/inet/slip.c | l = (dev->mtu * 2); |
dev | 481 | net/inet/slip.c | sl->dev->mem_start = (unsigned long) p; |
dev | 482 | net/inet/slip.c | sl->dev->mem_end = (unsigned long) (sl->dev->mem_start + l); |
dev | 489 | net/inet/slip.c | sl->dev->rmem_start = (unsigned long) p; |
dev | 490 | net/inet/slip.c | sl->dev->rmem_end = (unsigned long) (sl->dev->rmem_start + l); |
dev | 492 | net/inet/slip.c | sl->xbuff = (unsigned char *) sl->dev->mem_start; |
dev | 493 | net/inet/slip.c | sl->rbuff = (unsigned char *) sl->dev->rmem_start; |
dev | 494 | net/inet/slip.c | sl->rend = (unsigned char *) sl->dev->rmem_end; |
dev | 521 | net/inet/slip.c | sl_close(struct device *dev) |
dev | 525 | net/inet/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 538 | net/inet/slip.c | sl_initialize(sl, dev); |
dev | 607 | net/inet/slip.c | tty->line, sl->dev->name)); |
dev | 622 | net/inet/slip.c | (void) sl_open(sl->dev); |
dev | 624 | net/inet/slip.c | tty->line, sl->dev->name)); |
dev | 648 | net/inet/slip.c | (void) dev_close(sl->dev); |
dev | 650 | net/inet/slip.c | tty->line, sl->dev->name)); |
dev | 670 | net/inet/slip.c | memcpy_tofs(arg, sl->dev->name, strlen(sl->dev->name) + 1); |
dev | 681 | net/inet/slip.c | slip_init(struct device *dev) |
dev | 686 | net/inet/slip.c | sl = &sl_ctrl[dev->base_addr]; |
dev | 706 | net/inet/slip.c | sl_initialize(sl, dev); |
dev | 717 | net/inet/slip.c | dev->mtu = SL_MTU; |
dev | 718 | net/inet/slip.c | dev->hard_start_xmit = sl_xmit; |
dev | 719 | net/inet/slip.c | dev->open = sl_open; |
dev | 720 | net/inet/slip.c | dev->stop = sl_close; |
dev | 721 | net/inet/slip.c | dev->hard_header = sl_header; |
dev | 722 | net/inet/slip.c | dev->add_arp = sl_add_arp; |
dev | 723 | net/inet/slip.c | dev->type_trans = sl_type_trans; |
dev | 724 | net/inet/slip.c | dev->hard_header_len = 0; |
dev | 725 | net/inet/slip.c | dev->addr_len = 0; |
dev | 726 | net/inet/slip.c | dev->type = 0; |
dev | 727 | net/inet/slip.c | dev->queue_xmit = dev_queue_xmit; |
dev | 728 | net/inet/slip.c | dev->rebuild_header = sl_rebuild_header; |
dev | 730 | net/inet/slip.c | dev->buffs[i] = NULL; |
dev | 733 | net/inet/slip.c | dev->flags = 0; |
dev | 734 | net/inet/slip.c | dev->family = AF_INET; |
dev | 735 | net/inet/slip.c | dev->pa_addr = 0; |
dev | 736 | net/inet/slip.c | dev->pa_brdaddr = 0; |
dev | 737 | net/inet/slip.c | dev->pa_mask = 0; |
dev | 738 | net/inet/slip.c | dev->pa_alen = sizeof(unsigned long); |
dev | 35 | net/inet/slip.h | struct device *dev; /* easy for intr handling */ |
dev | 57 | net/inet/slip.h | extern int slip_init(struct device *dev); |
dev | 392 | net/inet/sock.c | if (skb->dev && |
dev | 393 | net/inet/sock.c | skb->dev->buffs[i] == skb) { |
dev | 401 | net/inet/sock.c | skb->dev->buffs[i]= skb->next; |
dev | 417 | net/inet/sock.c | if (skb->dev && |
dev | 418 | net/inet/sock.c | skb->dev->buffs[i] == skb) { |
dev | 426 | net/inet/sock.c | skb->dev->buffs[i]= NULL; |
dev | 433 | net/inet/sock.c | skb->dev = NULL; |
dev | 1601 | net/inet/sock.c | if (sk->prot->rcv) sk->prot->rcv(skb, skb->dev, sk->opt, |
dev | 137 | net/inet/sock.h | struct device **dev, int type, |
dev | 143 | net/inet/sock.h | struct device *dev, struct sk_buff *skb, |
dev | 148 | net/inet/sock.h | int (*rcv)(struct sk_buff *buff, struct device *dev, |
dev | 477 | net/inet/tcp.c | sk->prot->queue_xmit(sk, skb->dev, skb,0); |
dev | 491 | net/inet/tcp.c | struct device *dev = NULL; |
dev | 517 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, daddr, &dev, |
dev | 557 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
dev | 598 | net/inet/tcp.c | struct device *dev = NULL; |
dev | 784 | net/inet/tcp.c | tmp = prot->build_header(skb, sk->saddr, sk->daddr, &dev, |
dev | 794 | net/inet/tcp.c | skb->dev = dev; |
dev | 841 | net/inet/tcp.c | prot->queue_xmit(sk, dev, skb,0); |
dev | 871 | net/inet/tcp.c | struct device *dev = NULL; |
dev | 902 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
dev | 928 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
dev | 1294 | net/inet/tcp.c | struct device *dev = NULL; |
dev | 1327 | net/inet/tcp.c | tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev, |
dev | 1339 | net/inet/tcp.c | buff->dev = dev; |
dev | 1362 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 0); |
dev | 1398 | net/inet/tcp.c | struct proto *prot, struct options *opt, struct device *dev) |
dev | 1417 | net/inet/tcp.c | buff->dev = dev; |
dev | 1422 | net/inet/tcp.c | tmp = prot->build_header(buff, saddr, daddr, &dev, IPPROTO_TCP, opt, |
dev | 1447 | net/inet/tcp.c | prot->queue_xmit(NULL, dev, buff, 1); |
dev | 1461 | net/inet/tcp.c | struct options *opt, struct device *dev) |
dev | 1472 | net/inet/tcp.c | sk, skb, daddr, saddr, opt, dev)); |
dev | 1481 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt, dev); |
dev | 1567 | net/inet/tcp.c | newsk->mtu = dev->mtu - HEADER_SIZE; |
dev | 1571 | net/inet/tcp.c | newsk->mtu = dev->mtu - HEADER_SIZE; |
dev | 1574 | net/inet/tcp.c | dev->mtu - HEADER_SIZE); |
dev | 1596 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, newsk->saddr, newsk->daddr, &dev, |
dev | 1635 | net/inet/tcp.c | ptr[2] =((dev->mtu - HEADER_SIZE) >> 8) & 0xff; |
dev | 1636 | net/inet/tcp.c | ptr[3] =(dev->mtu - HEADER_SIZE) & 0xff; |
dev | 1639 | net/inet/tcp.c | newsk->prot->queue_xmit(newsk, dev, buff, 0); |
dev | 1670 | net/inet/tcp.c | struct device *dev=NULL; |
dev | 1751 | net/inet/tcp.c | tmp = prot->build_header(buff,sk->saddr, sk->daddr, &dev, |
dev | 1763 | net/inet/tcp.c | buff->dev = dev; |
dev | 1780 | net/inet/tcp.c | prot->queue_xmit(sk, dev, buff, 0); |
dev | 1837 | net/inet/tcp.c | sk->prot->queue_xmit(sk, skb->dev, skb, skb->free); |
dev | 1938 | net/inet/tcp.c | if (skb->dev->buffs[i] == skb) { |
dev | 1940 | net/inet/tcp.c | skb->dev->buffs[i] = NULL; |
dev | 1942 | net/inet/tcp.c | skb->dev->buffs[i] = skb->next; |
dev | 2055 | net/inet/tcp.c | if (oskb->dev->buffs[i] == oskb) { |
dev | 2057 | net/inet/tcp.c | oskb->dev->buffs[i]= NULL; |
dev | 2059 | net/inet/tcp.c | oskb->dev->buffs[i] = oskb->next; |
dev | 2178 | net/inet/tcp.c | sk->prot, NULL, skb->dev); |
dev | 2383 | net/inet/tcp.c | unsigned long saddr, struct device *dev) |
dev | 2386 | net/inet/tcp.c | sk, th, saddr, dev)); |
dev | 2483 | net/inet/tcp.c | struct device *dev=NULL; |
dev | 2525 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
dev | 2553 | net/inet/tcp.c | ptr[2] = (dev->mtu- HEADER_SIZE) >> 8; |
dev | 2554 | net/inet/tcp.c | ptr[3] = (dev->mtu- HEADER_SIZE) & 0xff; |
dev | 2555 | net/inet/tcp.c | sk->mtu = dev->mtu - HEADER_SIZE; |
dev | 2562 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 0); |
dev | 2633 | net/inet/tcp.c | tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, |
dev | 2654 | net/inet/tcp.c | if (!dev) { |
dev | 2684 | net/inet/tcp.c | if (!th->rst) tcp_reset(daddr, saddr, th, &tcp_prot, opt,dev); |
dev | 2806 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt,dev); |
dev | 2830 | net/inet/tcp.c | if (th->fin && tcp_fin(sk, th, saddr, dev)) { |
dev | 2856 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt,dev); |
dev | 2869 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt,dev); |
dev | 2878 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, prot, opt,dev); |
dev | 2890 | net/inet/tcp.c | tcp_conn_request(sk, skb, daddr, saddr, opt, dev); |
dev | 2923 | net/inet/tcp.c | tcp_reset(daddr, saddr, th, sk->prot, opt, dev); |
dev | 2946 | net/inet/tcp.c | sk->prot, opt,dev); |
dev | 2971 | net/inet/tcp.c | sk->prot, opt, dev); |
dev | 3004 | net/inet/tcp.c | if (th->fin) tcp_fin(sk, th, saddr, dev); |
dev | 3027 | net/inet/tcp.c | tcp_fin(sk, th, saddr, dev); |
dev | 3043 | net/inet/tcp.c | struct device *dev=NULL; |
dev | 3061 | net/inet/tcp.c | tmp = sk->prot->build_header(buff, sk->saddr, sk->daddr, &dev, |
dev | 3094 | net/inet/tcp.c | sk->prot->queue_xmit(sk, dev, buff, 1); |
dev | 132 | net/inet/tcp.h | extern int tcp_rcv(struct sk_buff *skb, struct device *dev, |
dev | 200 | net/inet/udp.c | struct device *dev; |
dev | 226 | net/inet/udp.c | dev = NULL; |
dev | 228 | net/inet/udp.c | saddr, sin->sin_addr.s_addr, dev, IPPROTO_UDP, skb->mem_len)); |
dev | 230 | net/inet/udp.c | &dev, IPPROTO_UDP, sk->opt, skb->mem_len); |
dev | 236 | net/inet/udp.c | saddr = dev->pa_addr; |
dev | 240 | net/inet/udp.c | skb->dev = dev; |
dev | 247 | net/inet/udp.c | if (len > dev->mtu) { |
dev | 248 | net/inet/udp.c | printk("UDP: send: length %d > mtu %d (ignored)\n", len, dev->mtu); |
dev | 270 | net/inet/udp.c | sk->prot->queue_xmit(sk, dev, skb, 1); |
dev | 542 | net/inet/udp.c | udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, |
dev | 553 | net/inet/udp.c | icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, dev); |
dev | 574 | net/inet/udp.c | skb->dev = dev; |
dev | 40 | net/inet/udp.h | extern int udp_rcv(struct sk_buff *skb, struct device *dev, |
dev | 31 | net/inet/wd.c | int wdprobe(int ioaddr, struct device *dev); |
dev | 32 | net/inet/wd.c | int wdprobe1(int ioaddr, struct device *dev); |
dev | 34 | net/inet/wd.c | static int wd_open(struct device *dev); |
dev | 35 | net/inet/wd.c | static void wd_reset_8390(struct device *dev); |
dev | 36 | net/inet/wd.c | static int wd_block_input(struct device *dev, int count, |
dev | 38 | net/inet/wd.c | static void wd_block_output(struct device *dev, int count, |
dev | 40 | net/inet/wd.c | static int wd_close_card(struct device *dev); |
dev | 63 | net/inet/wd.c | int wd_probe(struct device *dev) |
dev | 66 | net/inet/wd.c | short ioaddr = dev->base_addr; |
dev | 71 | net/inet/wd.c | return ! wdprobe1(ioaddr, dev); |
dev | 80 | net/inet/wd.c | && wdprobe1(*port, dev)) |
dev | 83 | net/inet/wd.c | dev->base_addr = ioaddr; |
dev | 87 | net/inet/wd.c | int wdprobe1(int ioaddr, struct device *dev) |
dev | 90 | net/inet/wd.c | unsigned char *station_addr = dev->dev_addr; |
dev | 101 | net/inet/wd.c | printk("%s: WD80x3 at %#3x, ", dev->name, ioaddr); |
dev | 120 | net/inet/wd.c | dev->mem_start = ((reg5 & 0x1c) + 0xc0) << 12; |
dev | 121 | net/inet/wd.c | dev->irq = (reg5 & 0xe0) == 0xe0 ? 10 : (reg5 >> 5) + 1; |
dev | 162 | net/inet/wd.c | dev->mem_start = WD_SHMEM; |
dev | 164 | net/inet/wd.c | if (dev->mem_start == 0) { |
dev | 169 | net/inet/wd.c | dev->mem_start = 0xd0000; |
dev | 170 | net/inet/wd.c | printk(" assigning address %#x", dev->mem_start); |
dev | 176 | net/inet/wd.c | dev->mem_start = ((reg0&0x3f) << 13) + (high_addr_bits << 19); |
dev | 182 | net/inet/wd.c | dev->base_addr = ioaddr+WD_NIC_OFFSET; |
dev | 184 | net/inet/wd.c | if (dev->irq < 2) { |
dev | 189 | net/inet/wd.c | dev->irq = word16 ? 10 : 5; |
dev | 191 | net/inet/wd.c | dev->irq = irqmap[((reg4 >> 5) & 0x03) + (reg1 & 0x04)]; |
dev | 192 | net/inet/wd.c | } else if (dev->irq == 2) /* Fixup bogosity: IRQ2 is really IRQ9 */ |
dev | 193 | net/inet/wd.c | dev->irq = 9; |
dev | 197 | net/inet/wd.c | { int irqval = irqaction (dev->irq, &ei_sigaction); |
dev | 199 | net/inet/wd.c | printk (" unable to get IRQ %d (irqval=%d).\n", dev->irq, irqval); |
dev | 208 | net/inet/wd.c | ethdev_init(dev); |
dev | 217 | net/inet/wd.c | dev->rmem_start = dev->mem_start + TX_PAGES*256; |
dev | 218 | net/inet/wd.c | dev->mem_end = dev->rmem_end |
dev | 219 | net/inet/wd.c | = dev->mem_start + (ei_status.stop_page - WD_START_PG)*256; |
dev | 222 | net/inet/wd.c | model_name, dev->irq, dev->mem_start, dev->mem_end-1); |
dev | 229 | net/inet/wd.c | dev->open = &wd_open; |
dev | 230 | net/inet/wd.c | dev->stop = &wd_close_card; |
dev | 231 | net/inet/wd.c | NS8390_init(dev, 0); |
dev | 233 | net/inet/wd.c | return dev->base_addr; |
dev | 237 | net/inet/wd.c | wd_open(struct device *dev) |
dev | 239 | net/inet/wd.c | int ioaddr = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
dev | 243 | net/inet/wd.c | ei_status.reg0 = ((dev->mem_start>>13) & 0x3f) | WD_MEMENB; |
dev | 244 | net/inet/wd.c | ei_status.reg5 = ((dev->mem_start>>19) & 0x1f) | NIC16; |
dev | 250 | net/inet/wd.c | return ei_open(dev); |
dev | 254 | net/inet/wd.c | wd_reset_8390(struct device *dev) |
dev | 256 | net/inet/wd.c | int wd_cmd_port = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
dev | 277 | net/inet/wd.c | outb(NIC16 | ((dev->mem_start>>19) & 0x1f), |
dev | 279 | net/inet/wd.c | outb((((dev->mem_start>>13) & 0x3f)|WD_MEMENB), wd_cmd_port); |
dev | 281 | net/inet/wd.c | while ((inb(dev->base_addr+EN0_ISR) & ENISR_RESET) == 0) |
dev | 283 | net/inet/wd.c | printk("%s: wd_reset_8390() did not complete.\n", dev->name); |
dev | 294 | net/inet/wd.c | wd_block_input(struct device *dev, int count, char *buf, int ring_offset) |
dev | 296 | net/inet/wd.c | void *xfer_start = (void *)(dev->mem_start + ring_offset |
dev | 301 | net/inet/wd.c | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
dev | 308 | net/inet/wd.c | if (xfer_start + count > (void*) dev->rmem_end) { |
dev | 310 | net/inet/wd.c | int semi_count = (void*)dev->rmem_end - xfer_start; |
dev | 313 | net/inet/wd.c | memcpy(buf + semi_count, (char *)dev->rmem_start, count); |
dev | 314 | net/inet/wd.c | return dev->rmem_start + count; |
dev | 327 | net/inet/wd.c | wd_block_output(struct device *dev, int count, const unsigned char *buf, |
dev | 331 | net/inet/wd.c | = (unsigned char *)dev->mem_start + ((start_page - WD_START_PG)<<8); |
dev | 334 | net/inet/wd.c | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
dev | 352 | net/inet/wd.c | wd_close_card(struct device *dev) |
dev | 354 | net/inet/wd.c | int wd_cmdreg = dev->base_addr - WD_NIC_OFFSET; /* WD_CMDREG */ |
dev | 357 | net/inet/wd.c | printk("%s: Shutting down ethercard.\n", dev->name); |
dev | 358 | net/inet/wd.c | NS8390_init(dev, 0); |