taglinefilesource code
device53arch/alpha/kernel/lca.cint device = device_fn >> 3;
device58arch/alpha/kernel/lca.cif (device > 12) {
device63arch/alpha/kernel/lca.caddr = (1 << (11 + device)) | (func << 8) | where;
device513arch/i386/kernel/bios32.cunsigned short     device;
device516arch/i386/kernel/bios32.cbus, dev_fn, (unsigned char) PCI_DEVICE_ID, &device);
device518arch/i386/kernel/bios32.cif ((device==pci_device[i].device_id)
device520arch/i386/kernel/bios32.creturn 0x10000 + (int) device;
device91drivers/block/blk.h#define DEVICE_NR(device)  (MINOR(device) >> PARTN_BITS)
device92drivers/block/blk.h#define DEVICE_ON(device)  /* nothing */
device93drivers/block/blk.h#define DEVICE_OFF(device)  /* nothing */
device100drivers/block/blk.h#define DEVICE_NR(device) ((device) & 7)
device101drivers/block/blk.h#define DEVICE_ON(device) 
device102drivers/block/blk.h#define DEVICE_OFF(device)
device111drivers/block/blk.h#define DEVICE_NR(device) ( ((device) & 3) | (((device) & 0x80 ) >> 5 ))
device112drivers/block/blk.h#define DEVICE_ON(device)
device113drivers/block/blk.h#define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
device123drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device)>>6)
device124drivers/block/blk.h#define DEVICE_ON(device)
device125drivers/block/blk.h#define DEVICE_OFF(device)
device133drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device) >> 4)
device134drivers/block/blk.h#define DEVICE_ON(device)
device135drivers/block/blk.h#define DEVICE_OFF(device)
device141drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device) & 0x7f)
device142drivers/block/blk.h#define DEVICE_ON(device)
device143drivers/block/blk.h#define DEVICE_OFF(device)
device150drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device151drivers/block/blk.h#define DEVICE_ON(device)
device152drivers/block/blk.h#define DEVICE_OFF(device)
device158drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device) >> 6)
device159drivers/block/blk.h#define DEVICE_ON(device)
device160drivers/block/blk.h#define DEVICE_OFF(device)
device166drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device167drivers/block/blk.h#define DEVICE_ON(device)
device168drivers/block/blk.h#define DEVICE_OFF(device)
device175drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device176drivers/block/blk.h#define DEVICE_ON(device)
device177drivers/block/blk.h#define DEVICE_OFF(device)
device183drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device184drivers/block/blk.h#define DEVICE_ON(device)
device185drivers/block/blk.h#define DEVICE_OFF(device)
device192drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device193drivers/block/blk.h#define DEVICE_ON(device)
device194drivers/block/blk.h#define DEVICE_OFF(device)
device200drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device201drivers/block/blk.h#define DEVICE_ON(device)
device202drivers/block/blk.h#define DEVICE_OFF(device)
device208drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device209drivers/block/blk.h#define DEVICE_ON(device)
device210drivers/block/blk.h#define DEVICE_OFF(device)
device216drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device217drivers/block/blk.h#define DEVICE_ON(device)
device218drivers/block/blk.h#define DEVICE_OFF(device)
device224drivers/block/blk.h#define DEVICE_NR(device) (MINOR(device))
device225drivers/block/blk.h#define DEVICE_ON(device)
device226drivers/block/blk.h#define DEVICE_OFF(device)
device1785drivers/block/floppy.cstatic void set_floppy(int device)
device1787drivers/block/floppy.cif (TYPE(device))
device1788drivers/block/floppy.cfloppy = TYPE(device) + floppy_type;
device1790drivers/block/floppy.cfloppy = current_type[ DRIVE(device) ];
device1888drivers/block/floppy.cstatic int do_format(int device, struct format_descr *tmp_format_req)
device1891drivers/block/floppy.cint drive=DRIVE(device);
device1894drivers/block/floppy.cset_floppy(device);
device2420drivers/block/floppy.cint device;
device2449drivers/block/floppy.cdevice = CURRENT->dev;
device2450drivers/block/floppy.cset_fdc( DRIVE(device));
device2456drivers/block/floppy.cset_floppy(device);
device2717drivers/block/floppy.cint i,device,drive,type,cnt;
device2721drivers/block/floppy.cdevice = inode->i_rdev;
device2723drivers/block/floppy.cRO_IOCTLS(device,param);
device2725drivers/block/floppy.ctype = TYPE(device);
device2726drivers/block/floppy.cdrive = DRIVE(device);
device2778drivers/block/floppy.cset_floppy(device);
device2786drivers/block/floppy.creturn do_format(device, &tmp_format_req);
device2796drivers/block/floppy.creturn invalidate_drive(device);
device2800drivers/block/floppy.creturn invalidate_drive(device);
device2861drivers/block/floppy.cinvalidate_drive(device);
device1316drivers/char/console.cconsole_num = MINOR(tty->device) - (tty->driver.minor_start);
device1331drivers/char/console.cconsole_num = MINOR(tty->device) - (tty->driver.minor_start);
device2158drivers/char/console.cidx = MINOR(tty->device) - tty->driver.minor_start;
device347drivers/char/cyclades.cdev_t device, const char *routine)
device358drivers/char/cyclades.cprintk(badinfo, MAJOR(device), MINOR(device), routine);
device364drivers/char/cyclades.cprintk(badrange, MAJOR(device), MINOR(device), routine);
device369drivers/char/cyclades.cprintk(badmagic, MAJOR(device), MINOR(device), routine);
device451drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_stop"))
device482drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_start"))
device1434drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_put_char"))
device1465drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_flush_chars"))
device1504drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_write")){
device1558drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_write_room"))
device1576drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_chars_in_buffer"))
device1593drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_flush_buffer"))
device1625drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_nthrottle")){
device1666drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_nthrottle")){
device2021drivers/char/cyclades.c|| serial_paranoia_check(info, tty->device, "cy_close")){
device2110drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_hangup"))
device2291drivers/char/cyclades.cline = MINOR(tty->device) - tty->driver.minor_start;
device2299drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_open")){
device189drivers/char/pty.cline = MINOR(tty->device) - tty->driver.minor_start;
device208drivers/char/serial.cdev_t device, const char *routine)
device217drivers/char/serial.cprintk(badinfo, MAJOR(device), MINOR(device), routine);
device221drivers/char/serial.cprintk(badmagic, MAJOR(device), MINOR(device), routine);
device301drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_stop"))
device317drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_start"))
device1234drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_put_char"))
device1257drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
device1277drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_write"))
device1321drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_write_room"))
device1333drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
device1342drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
device1371drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_throttle"))
device1394drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
device1807drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_ioctl"))
device1962drivers/char/serial.cif (!info || serial_paranoia_check(info, tty->device, "rs_close"))
device2073drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_hangup"))
device2227drivers/char/serial.cline = MINOR(tty->device) - tty->driver.minor_start;
device2231drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_open"))
device116drivers/char/tty_io.cMINOR(tty->device) - tty->driver.minor_start +
device130drivers/char/tty_io.cinline int tty_paranoia_check(struct tty_struct *tty, dev_t device,
device140drivers/char/tty_io.cprintk(badtty, MAJOR(device), MINOR(device), routine);
device144drivers/char/tty_io.cprintk(badmagic, MAJOR(device), MINOR(device), routine);
device170drivers/char/tty_io.cMAJOR(tty->device), MINOR(tty->device), tty->count,
device240drivers/char/tty_io.cstruct tty_driver *get_tty_driver(dev_t device)
device245drivers/char/tty_io.cminor = MINOR(device);
device246drivers/char/tty_io.cmajor = MAJOR(device);
device752drivers/char/tty_io.cstatic int init_dev(dev_t device, struct tty_struct **ret_tty)
device761drivers/char/tty_io.cdriver = get_tty_driver(device);
device765drivers/char/tty_io.cidx = MINOR(device) - driver->minor_start;
device787drivers/char/tty_io.ctty->device = device;
device822drivers/char/tty_io.co_tty->device = o_device;
device941drivers/char/tty_io.cidx = MINOR(tty->device) - tty->driver.minor_start;
device945drivers/char/tty_io.cMAJOR(tty->device), MINOR(tty->device));
device950drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device955drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device960drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device978drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device983drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device988drivers/char/tty_io.cidx, MAJOR(tty->device), MINOR(tty->device));
device1111drivers/char/tty_io.cdev_t device;
device1115drivers/char/tty_io.cdevice = inode->i_rdev;
device1116drivers/char/tty_io.cif (device == TTY_DEV) {
device1119drivers/char/tty_io.cdevice = current->tty->device;
device1122drivers/char/tty_io.cif (device == CONSOLE_DEV) {
device1123drivers/char/tty_io.cdevice = MKDEV(TTY_MAJOR, fg_console+1);
device1126drivers/char/tty_io.cminor = MINOR(device);
device1128drivers/char/tty_io.cretval = init_dev(device, &tty);
device114drivers/net/3c501.cint el1_probe(struct device *dev);
device115drivers/net/3c501.cstatic int  el1_probe1(struct device *dev, int ioaddr);
device116drivers/net/3c501.cstatic int  el_open(struct device *dev);
device117drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
device119drivers/net/3c501.cstatic void el_receive(struct device *dev);
device120drivers/net/3c501.cstatic void el_reset(struct device *dev);
device121drivers/net/3c501.cstatic int  el1_close(struct device *dev);
device122drivers/net/3c501.cstatic struct enet_statistics *el1_get_stats(struct device *dev);
device123drivers/net/3c501.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device191drivers/net/3c501.cel1_probe(struct device *dev)
device215drivers/net/3c501.cel1_probe1(struct device *dev, int ioaddr)
device304drivers/net/3c501.cel_open(struct device *dev)
device326drivers/net/3c501.cel_start_xmit(struct sk_buff *skb, struct device *dev)
device405drivers/net/3c501.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device531drivers/net/3c501.cel_receive(struct device *dev)
device584drivers/net/3c501.cel_reset(struct device *dev)
device610drivers/net/3c501.cel1_close(struct device *dev)
device630drivers/net/3c501.cel1_get_stats(struct device *dev)
device643drivers/net/3c501.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device660drivers/net/3c501.cstatic struct device dev_3c501 = {
device41drivers/net/3c503.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device44drivers/net/3c503.cint el2_probe(struct device *dev);
device45drivers/net/3c503.cint el2_pio_probe(struct device *dev);
device46drivers/net/3c503.cint el2_probe1(struct device *dev, int ioaddr);
device63drivers/net/3c503.cstatic int el2_open(struct device *dev);
device64drivers/net/3c503.cstatic int el2_close(struct device *dev);
device65drivers/net/3c503.cstatic void el2_reset_8390(struct device *dev);
device66drivers/net/3c503.cstatic void el2_init_card(struct device *dev);
device67drivers/net/3c503.cstatic void el2_block_output(struct device *dev, int count,
device69drivers/net/3c503.cstatic int el2_block_input(struct device *dev, int count, char *buf,
device81drivers/net/3c503.cel2_probe(struct device *dev)
device116drivers/net/3c503.cel2_pio_probe(struct device *dev)
device142drivers/net/3c503.cel2_probe1(struct device *dev, int ioaddr)
device279drivers/net/3c503.cel2_open(struct device *dev)
device312drivers/net/3c503.cel2_close(struct device *dev)
device329drivers/net/3c503.cel2_reset_8390(struct device *dev)
device345drivers/net/3c503.cel2_init_card(struct device *dev)
device375drivers/net/3c503.cel2_block_output(struct device *dev, int count,
device419drivers/net/3c503.cel2_block_input(struct device *dev, int count, char *buf, int ring_offset)
device542drivers/net/3c505.cstatic void receive_packet(struct device * dev,
device673drivers/net/3c505.cstruct device *dev;
device848drivers/net/3c505.cstatic int elp_open (struct device *dev)
device1030drivers/net/3c505.cstatic int elp_start_xmit(struct sk_buff *skb, struct device *dev)
device1127drivers/net/3c505.cstatic struct enet_statistics * elp_get_stats(struct device *dev)
device1167drivers/net/3c505.cstatic int elp_close (struct device *dev)
device1222drivers/net/3c505.cstatic void elp_set_mc_list(struct device *dev, int num_addrs, void *addrs)
device1280drivers/net/3c505.cstatic void elp_init(struct device *dev)
device1420drivers/net/3c505.cstatic int elp_autodetect(struct device * dev)
device1459drivers/net/3c505.cint elplus_probe(struct device *dev)
device62drivers/net/3c507.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device280drivers/net/3c507.cextern int el16_probe(struct device *dev);  /* Called from Space.c */
device282drivers/net/3c507.cstatic int  el16_probe1(struct device *dev, int ioaddr);
device283drivers/net/3c507.cstatic int  el16_open(struct device *dev);
device284drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
device286drivers/net/3c507.cstatic void el16_rx(struct device *dev);
device287drivers/net/3c507.cstatic int  el16_close(struct device *dev);
device288drivers/net/3c507.cstatic struct enet_statistics *el16_get_stats(struct device *dev);
device290drivers/net/3c507.cstatic void hardware_send_packet(struct device *dev, void *buf, short length);
device291drivers/net/3c507.cvoid init_82586_mem(struct device *dev);
device306drivers/net/3c507.cel16_probe(struct device *dev)
device327drivers/net/3c507.cint el16_probe1(struct device *dev, int ioaddr)
device433drivers/net/3c507.cel16_open(struct device *dev)
device447drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
device514drivers/net/3c507.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device588drivers/net/3c507.cstatic void init_rx_bufs(struct device *);
device612drivers/net/3c507.cel16_close(struct device *dev)
device640drivers/net/3c507.cel16_get_stats(struct device *dev)
device651drivers/net/3c507.cinit_rx_bufs(struct device *dev)
device697drivers/net/3c507.cinit_82586_mem(struct device *dev)
device756drivers/net/3c507.chardware_send_packet(struct device *dev, void *buf, short length)
device802drivers/net/3c507.cel16_rx(struct device *dev)
device103drivers/net/3c509.cstatic int el3_open(struct device *dev);
device104drivers/net/3c509.cstatic int el3_start_xmit(struct sk_buff *skb, struct device *dev);
device106drivers/net/3c509.cstatic void update_stats(int addr, struct device *dev);
device107drivers/net/3c509.cstatic struct enet_statistics *el3_get_stats(struct device *dev);
device108drivers/net/3c509.cstatic int el3_rx(struct device *dev);
device109drivers/net/3c509.cstatic int el3_close(struct device *dev);
device111drivers/net/3c509.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device116drivers/net/3c509.cint el3_probe(struct device *dev)
device300drivers/net/3c509.cel3_open(struct device *dev)
device378drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
device465drivers/net/3c509.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device523drivers/net/3c509.cel3_get_stats(struct device *dev)
device540drivers/net/3c509.cstatic void update_stats(int ioaddr, struct device *dev)
device569drivers/net/3c509.cel3_rx(struct device *dev)
device632drivers/net/3c509.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device653drivers/net/3c509.cel3_close(struct device *dev)
device697drivers/net/3c509.cstatic struct device dev_3c509 = {
device90drivers/net/8390.cstatic void ei_tx_intr(struct device *dev);
device91drivers/net/8390.cstatic void ei_receive(struct device *dev);
device92drivers/net/8390.cstatic void ei_rx_overrun(struct device *dev);
device95drivers/net/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
device98drivers/net/8390.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device106drivers/net/8390.cint ei_open(struct device *dev)
device122drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
device243drivers/net/8390.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device324drivers/net/8390.cstatic void ei_tx_intr(struct device *dev)
device388drivers/net/8390.cstatic void ei_receive(struct device *dev)
device500drivers/net/8390.cstatic void ei_rx_overrun(struct device *dev)
device537drivers/net/8390.cstatic struct enet_statistics *get_stats(struct device *dev)
device557drivers/net/8390.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device573drivers/net/8390.cint ethdev_init(struct device *dev)
device607drivers/net/8390.cvoid NS8390_init(struct device *dev, int startp)
device665drivers/net/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
device23drivers/net/8390.hextern int ethif_init(struct device *dev);
device24drivers/net/8390.hextern int ethdev_init(struct device *dev);
device25drivers/net/8390.hextern void NS8390_init(struct device *dev, int startp);
device26drivers/net/8390.hextern int ei_open(struct device *dev);
device31drivers/net/8390.hextern struct device *irq2dev_map[16];
device41drivers/net/8390.hvoid (*reset_8390)(struct device *);
device42drivers/net/8390.hvoid (*block_output)(struct device *, int, const unsigned char *, int);
device43drivers/net/8390.hint  (*block_input)(struct device *, int, char *, int);
device38drivers/net/Space.cextern int ultra_probe(struct device *dev);
device39drivers/net/Space.cextern int wd_probe(struct device *dev);
device40drivers/net/Space.cextern int el2_probe(struct device *dev);
device41drivers/net/Space.cextern int ne_probe(struct device *dev);
device42drivers/net/Space.cextern int hp_probe(struct device *dev);
device43drivers/net/Space.cextern int hp_plus_probe(struct device *dev);
device44drivers/net/Space.cextern int znet_probe(struct device *);
device45drivers/net/Space.cextern int express_probe(struct device *);
device46drivers/net/Space.cextern int el3_probe(struct device *);
device47drivers/net/Space.cextern int at1500_probe(struct device *);
device48drivers/net/Space.cextern int at1700_probe(struct device *);
device49drivers/net/Space.cextern int depca_probe(struct device *);
device50drivers/net/Space.cextern int apricot_probe(struct device *);
device51drivers/net/Space.cextern int ewrk3_probe(struct device *);
device52drivers/net/Space.cextern int de4x5_probe(struct device *);
device53drivers/net/Space.cextern int el1_probe(struct device *);
device55drivers/net/Space.cextern int wavelan_probe(struct device *);
device57drivers/net/Space.cextern int el16_probe(struct device *);
device58drivers/net/Space.cextern int elplus_probe(struct device *);
device59drivers/net/Space.cextern int ac3200_probe(struct device *);
device60drivers/net/Space.cextern int e2100_probe(struct device *);
device61drivers/net/Space.cextern int ni52_probe(struct device *);
device62drivers/net/Space.cextern int ni65_probe(struct device *);
device63drivers/net/Space.cextern int SK_init(struct device *);
device66drivers/net/Space.cextern int atp_init(struct device *);
device67drivers/net/Space.cextern int de600_probe(struct device *);
device68drivers/net/Space.cextern int de620_probe(struct device *);
device71drivers/net/Space.cethif_probe(struct device *dev)
device167drivers/net/Space.cstatic struct device atp_dev = {
device184drivers/net/Space.cstatic struct device eth3_dev = {
device186drivers/net/Space.cstatic struct device eth2_dev = {
device188drivers/net/Space.cstatic struct device eth1_dev = {
device191drivers/net/Space.cstatic struct device eth0_dev = {
device198drivers/net/Space.cextern int plip_init(struct device *);
device199drivers/net/Space.cstatic struct device plip2_dev = {
device201drivers/net/Space.cstatic struct device plip1_dev = {
device203drivers/net/Space.cstatic struct device plip0_dev = {
device210drivers/net/Space.cextern int slip_init(struct device *);
device214drivers/net/Space.cstatic struct device slip15_dev={"sl15",0,0,0,0,15,0,0,0,0,NEXT_DEV,slip_init};
device215drivers/net/Space.cstatic struct device slip14_dev={"sl14",0,0,0,0,14,0,0,0,0,&slip15_dev,slip_init};
device216drivers/net/Space.cstatic struct device slip13_dev={"sl13",0,0,0,0,13,0,0,0,0,&slip14_dev,slip_init};
device217drivers/net/Space.cstatic struct device slip12_dev={"sl12",0,0,0,0,12,0,0,0,0,&slip13_dev,slip_init};
device218drivers/net/Space.cstatic struct device slip11_dev={"sl11",0,0,0,0,11,0,0,0,0,&slip12_dev,slip_init};
device219drivers/net/Space.cstatic struct device slip10_dev={"sl10",0,0,0,0,10,0,0,0,0,&slip11_dev,slip_init};
device220drivers/net/Space.cstatic struct device slip9_dev={"sl9",0,0,0,0,9,0,0,0,0,&slip10_dev,slip_init};
device221drivers/net/Space.cstatic struct device slip8_dev={"sl8",0,0,0,0,8,0,0,0,0,&slip9_dev,slip_init};
device222drivers/net/Space.cstatic struct device slip7_dev={"sl7",0,0,0,0,7,0,0,0,0,&slip8_dev,slip_init};
device223drivers/net/Space.cstatic struct device slip6_dev={"sl6",0,0,0,0,6,0,0,0,0,&slip7_dev,slip_init};
device224drivers/net/Space.cstatic struct device slip5_dev={"sl5",0,0,0,0,5,0,0,0,0,&slip6_dev,slip_init};
device225drivers/net/Space.cstatic struct device slip4_dev={"sl4",0,0,0,0,4,0,0,0,0,&slip5_dev,slip_init};
device230drivers/net/Space.cstatic struct device slip3_dev = {
device242drivers/net/Space.cstatic struct device slip2_dev = {
device254drivers/net/Space.cstatic struct device slip1_dev = {
device266drivers/net/Space.cstatic struct device slip0_dev = {
device283drivers/net/Space.cextern int ppp_init(struct device *);
device284drivers/net/Space.cstatic struct device ppp3_dev = {
device286drivers/net/Space.cstatic struct device ppp2_dev = {
device288drivers/net/Space.cstatic struct device ppp1_dev = {
device290drivers/net/Space.cstatic struct device ppp0_dev = {
device297drivers/net/Space.cextern int arcnet_probe(struct device *dev);
device298drivers/net/Space.cstatic struct device arcnet_dev = {
device305drivers/net/Space.cextern int dummy_init(struct device *dev);
device306drivers/net/Space.cstatic struct device dummy_dev = {
device312drivers/net/Space.cextern int loopback_init(struct device *dev);
device313drivers/net/Space.cstruct device loopback_dev = {
device326drivers/net/Space.cstruct device *dev_base = &loopback_dev;
device57drivers/net/ac3200.cint ac3200_probe(struct device *dev);
device58drivers/net/ac3200.cstatic int ac_probe1(int ioaddr, struct device *dev);
device60drivers/net/ac3200.cstatic int ac_open(struct device *dev);
device61drivers/net/ac3200.cstatic void ac_reset_8390(struct device *dev);
device62drivers/net/ac3200.cstatic int ac_block_input(struct device *dev, int count,
device64drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, const int count,
device66drivers/net/ac3200.cstatic int ac_close_card(struct device *dev);
device75drivers/net/ac3200.cint ac3200_probe(struct device *dev)
device95drivers/net/ac3200.cstatic int ac_probe1(int ioaddr, struct device *dev)
device190drivers/net/ac3200.cstatic int ac_open(struct device *dev)
device203drivers/net/ac3200.cstatic void ac_reset_8390(struct device *dev)
device220drivers/net/ac3200.cstatic int ac_block_input(struct device *dev, int count, char *buf,
device238drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, int count,
device246drivers/net/ac3200.cstatic int ac_close_card(struct device *dev)
device187drivers/net/apricot.cstatic int i596_open(struct device *dev);
device188drivers/net/apricot.cstatic int i596_start_xmit(struct sk_buff *skb, struct device *dev);
device190drivers/net/apricot.cstatic int i596_close(struct device *dev);
device191drivers/net/apricot.cstatic struct enet_statistics *i596_get_stats(struct device *dev);
device192drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd);
device195drivers/net/apricot.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device200drivers/net/apricot.cinit_rx_bufs(struct device *dev, int num)
device238drivers/net/apricot.cremove_rx_bufs(struct device *dev)
device255drivers/net/apricot.cinit_i596_mem(struct device *dev)
device330drivers/net/apricot.ci596_rx(struct device *dev)
device447drivers/net/apricot.ci596_reset(struct device *dev, struct i596_private *lp, int ioaddr)
device487drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd)
device538drivers/net/apricot.ci596_open(struct device *dev)
device576drivers/net/apricot.ci596_start_xmit(struct sk_buff *skb, struct device *dev)
device685drivers/net/apricot.cint apricot_probe(struct device *dev)
device757drivers/net/apricot.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device921drivers/net/apricot.ci596_close(struct device *dev)
device958drivers/net/apricot.ci596_get_stats(struct device *dev)
device973drivers/net/apricot.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device1017drivers/net/apricot.cstatic struct device dev_apricot = {
device165drivers/net/arcnet.cextern struct device *irq2dev_map[16];
device345drivers/net/arcnet.cextern int arcnet_probe(struct device *dev);
device347drivers/net/arcnet.cstatic int arcnet_memprobe(struct device *dev,u_char *addr);
device348drivers/net/arcnet.cstatic int arcnet_ioprobe(struct device *dev, short ioaddr);
device351drivers/net/arcnet.cstatic int arcnet_open(struct device *dev);
device352drivers/net/arcnet.cstatic int arcnet_close(struct device *dev);
device354drivers/net/arcnet.cstatic int arcnet_send_packet(struct sk_buff *skb, struct device *dev);
device356drivers/net/arcnet.cstatic void careful_xmit_wait(struct device *dev);
device360drivers/net/arcnet.cstatic void arcnet_continue_tx(struct device *dev);
device361drivers/net/arcnet.cstatic void arcnet_prepare_tx(struct device *dev,struct ClientData *hdr,
device363drivers/net/arcnet.cstatic void arcnet_go_tx(struct device *dev);
device366drivers/net/arcnet.cstatic void arcnet_inthandler(struct device *dev);
device367drivers/net/arcnet.cstatic void arcnet_rx(struct device *dev,int recbuf);
device373drivers/net/arcnet.cstatic struct enet_statistics *arcnet_get_stats(struct device *dev);
device374drivers/net/arcnet.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device377drivers/net/arcnet.cint arc_header(unsigned char *buff,struct device *dev,unsigned short type,
device379drivers/net/arcnet.cint arc_rebuild_header(void *eth,struct device *dev,unsigned long raddr,
device381drivers/net/arcnet.cunsigned short arc_type_trans(struct sk_buff *skb,struct device *dev);
device383drivers/net/arcnet.cstatic int arcnet_reset(struct device *dev);
device412drivers/net/arcnet.carcnet_probe(struct device *dev)
device585drivers/net/arcnet.cint arcnet_ioprobe(struct device *dev, short ioaddr)
device752drivers/net/arcnet.cint arcnet_memprobe(struct device *dev,u_char *addr)
device808drivers/net/arcnet.carcnet_open(struct device *dev)
device868drivers/net/arcnet.carcnet_close(struct device *dev)
device904drivers/net/arcnet.carcnet_send_packet(struct sk_buff *skb, struct device *dev)
device1116drivers/net/arcnet.cstatic void arcnet_continue_tx(struct device *dev)
device1154drivers/net/arcnet.cstatic void careful_xmit_wait(struct device *dev)
device1179drivers/net/arcnet.carcnet_prepare_tx(struct device *dev,struct ClientData *hdr,short length,
device1303drivers/net/arcnet.carcnet_go_tx(struct device *dev)
device1332drivers/net/arcnet.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device1344drivers/net/arcnet.carcnet_inthandler(struct device *dev)
device1505drivers/net/arcnet.carcnet_rx(struct device *dev,int recbuf)
device1844drivers/net/arcnet.cstruct device *dev=(struct device *)arg;
device1872drivers/net/arcnet.carcnet_get_stats(struct device *dev)
device1887drivers/net/arcnet.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device1900drivers/net/arcnet.cint arcnet_reset(struct device *dev)
device1962drivers/net/arcnet.cint arc_header(unsigned char *buff,struct device *dev,unsigned short type,
device2036drivers/net/arcnet.cint arc_rebuild_header(void *buff,struct device *dev,unsigned long dst,
device2069drivers/net/arcnet.cunsigned short arc_type_trans(struct sk_buff *skb,struct device *dev)
device2129drivers/net/arcnet.cstatic struct device thisARCnet = {
device55drivers/net/at1700.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device116drivers/net/at1700.cextern int at1700_probe(struct device *dev);
device118drivers/net/at1700.cstatic int at1700_probe1(struct device *dev, short ioaddr);
device120drivers/net/at1700.cstatic int net_open(struct device *dev);
device121drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
device123drivers/net/at1700.cstatic void net_rx(struct device *dev);
device124drivers/net/at1700.cstatic int net_close(struct device *dev);
device125drivers/net/at1700.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device126drivers/net/at1700.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device142drivers/net/at1700.cat1700_probe(struct device *dev)
device172drivers/net/at1700.cint at1700_probe1(struct device *dev, short ioaddr)
device320drivers/net/at1700.cstatic int net_open(struct device *dev)
device363drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device444drivers/net/at1700.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device491drivers/net/at1700.cnet_rx(struct device *dev)
device571drivers/net/at1700.cstatic int net_close(struct device *dev)
device593drivers/net/at1700.cnet_get_stats(struct device *dev)
device611drivers/net/at1700.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device122drivers/net/atp.cstatic struct device *atp_timed_dev;
device128drivers/net/atp.cextern int atp_probe(struct device *dev);
device130drivers/net/atp.cstatic int atp_probe1(struct device *dev, short ioaddr);
device131drivers/net/atp.cstatic void get_node_ID(struct device *dev);
device133drivers/net/atp.cstatic int net_open(struct device *dev);
device134drivers/net/atp.cstatic void hardware_init(struct device *dev);
device137drivers/net/atp.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
device139drivers/net/atp.cstatic void net_rx(struct device *dev);
device141drivers/net/atp.cstatic int net_close(struct device *dev);
device142drivers/net/atp.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device143drivers/net/atp.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device153drivers/net/atp.catp_init(struct device *dev)
device175drivers/net/atp.cstatic int atp_probe1(struct device *dev, short ioaddr)
device259drivers/net/atp.cstatic void get_node_ID(struct device *dev)
device321drivers/net/atp.cstatic int net_open(struct device *dev)
device340drivers/net/atp.cstatic void hardware_init(struct device *dev)
device414drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device487drivers/net/atp.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device644drivers/net/atp.cstatic void net_rx(struct device *dev)
device723drivers/net/atp.cnet_close(struct device *dev)
device749drivers/net/atp.cnet_get_stats(struct device *dev)
device762drivers/net/atp.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device42drivers/net/auto_irq.cstruct device *irq2dev_map[16] = {0, 0, /* ... zeroed */};
device322drivers/net/de4x5.cstatic int  de4x5_open(struct device *dev);
device323drivers/net/de4x5.cstatic int  de4x5_queue_pkt(struct sk_buff *skb, struct device *dev);
device325drivers/net/de4x5.cstatic int  de4x5_close(struct device *dev);
device326drivers/net/de4x5.cstatic struct enet_statistics *de4x5_get_stats(struct device *dev);
device327drivers/net/de4x5.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device328drivers/net/de4x5.cstatic int  de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd);
device333drivers/net/de4x5.cstatic int  de4x5_hw_init(struct device *dev, short iobase);
device334drivers/net/de4x5.cstatic int  de4x5_init(struct device *dev);
device335drivers/net/de4x5.cstatic int  de4x5_rx(struct device *dev);
device336drivers/net/de4x5.cstatic int  de4x5_tx(struct device *dev);
device338drivers/net/de4x5.cstatic int  autoconf_media(struct device *dev);
device339drivers/net/de4x5.cstatic void create_packet(struct device *dev, char *frame, int len);
device343drivers/net/de4x5.cstatic void load_packet(struct device *dev, char *buf, u_long flags, struct sk_buff *skb);
device346drivers/net/de4x5.cstatic void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table);
device348drivers/net/de4x5.cstatic int aprom_crc (struct device *dev);
device350drivers/net/de4x5.cstatic void eisa_probe(struct device *dev, short iobase);
device351drivers/net/de4x5.cstatic void pci_probe(struct device *dev, short iobase);
device352drivers/net/de4x5.cstatic struct device *alloc_device(struct device *dev, int iobase);
device373drivers/net/de4x5.cint device;
device390drivers/net/de4x5.cint de4x5_probe(struct device *dev)
device422drivers/net/de4x5.cde4x5_hw_init(struct device *dev, short iobase)
device454drivers/net/de4x5.cprintk("%s: %s at %#3x (PCI device %d)", dev->name, name, (u_short)iobase,lp->device);
device602drivers/net/de4x5.cde4x5_open(struct device *dev)
device709drivers/net/de4x5.cde4x5_init(struct device *dev)
device796drivers/net/de4x5.cde4x5_queue_pkt(struct sk_buff *skb, struct device *dev)
device887drivers/net/de4x5.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device937drivers/net/de4x5.cde4x5_rx(struct device *dev)
device1033drivers/net/de4x5.cde4x5_tx(struct device *dev)
device1074drivers/net/de4x5.cde4x5_close(struct device *dev)
device1107drivers/net/de4x5.cde4x5_get_stats(struct device *dev)
device1117drivers/net/de4x5.cstatic void load_packet(struct device *dev, char *buf, u_long flags, struct sk_buff *skb)
device1139drivers/net/de4x5.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device1174drivers/net/de4x5.cstatic void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table)
device1225drivers/net/de4x5.cstatic void eisa_probe(struct device *dev, short ioaddr)
device1271drivers/net/de4x5.cstatic void pci_probe(struct device *dev, short ioaddr)
device1276drivers/net/de4x5.cu_short vendor, device, status;
device1302drivers/net/de4x5.cpcibios_read_config_word(pb, PCI_DEVICE, PCI_DEVICE_ID, &device);
device1303drivers/net/de4x5.cif ((vendor == DC21040_VID) && (device == DC21040_DID)) {
device1305drivers/net/de4x5.clp->device = dev_num;
device1345drivers/net/de4x5.cstatic struct device *alloc_device(struct device *dev, int iobase)
device1348drivers/net/de4x5.cstruct device *tmp = NULL, *ret;
device1349drivers/net/de4x5.cint (*init)(struct device *) = NULL;
device1377drivers/net/de4x5.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1390drivers/net/de4x5.cdev->name = (char *)(dev + sizeof(struct device));
device1417drivers/net/de4x5.ctmp->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1429drivers/net/de4x5.ctmp->name = (char *)(tmp + sizeof(struct device));
device1457drivers/net/de4x5.cstatic int autoconf_media(struct device *dev)
device1579drivers/net/de4x5.cstatic void create_packet(struct device *dev, char *frame, int len)
device1743drivers/net/de4x5.cstatic int aprom_crc(struct device *dev)
device1792drivers/net/de4x5.cstatic int de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device2021drivers/net/de4x5.cstatic struct device thisDE4X5 = {
device243drivers/net/de600.cstatic byte  de600_read_status(struct device *dev);
device244drivers/net/de600.cstatic byte  de600_read_byte(unsigned char type, struct device *dev);
device247drivers/net/de600.cstatic int  de600_open(struct device *dev);
device248drivers/net/de600.cstatic int  de600_close(struct device *dev);
device249drivers/net/de600.cstatic struct netstats *get_stats(struct device *dev);
device250drivers/net/de600.cstatic int  de600_start_xmit(struct sk_buff *skb, struct device *dev);
device254drivers/net/de600.cstatic int  de600_tx_intr(struct device *dev, int irq_status);
device255drivers/net/de600.cstatic void  de600_rx_intr(struct device *dev);
device258drivers/net/de600.cstatic void  trigger_interrupt(struct device *dev);
device259drivers/net/de600.cint    de600_probe(struct device *dev);
device260drivers/net/de600.cstatic int  adapter_init(struct device *dev);
device310drivers/net/de600.cde600_read_status(struct device *dev)
device322drivers/net/de600.cde600_read_byte(unsigned char type, struct device *dev) { /* dev used by macros */
device340drivers/net/de600.cde600_open(struct device *dev)
device363drivers/net/de600.cde600_close(struct device *dev)
device384drivers/net/de600.cget_stats(struct device *dev)
device390drivers/net/de600.ctrigger_interrupt(struct device *dev)
device404drivers/net/de600.cde600_start_xmit(struct sk_buff *skb, struct device *dev)
device500drivers/net/de600.cstruct device  *dev = irq2dev_map[irq];
device549drivers/net/de600.cde600_tx_intr(struct device *dev, int irq_status)
device585drivers/net/de600.cde600_rx_intr(struct device *dev)
device642drivers/net/de600.cde600_probe(struct device *dev)
device720drivers/net/de600.cadapter_init(struct device *dev)
device831drivers/net/de600.cstatic struct device de600_dev = {
device179drivers/net/de620.cstatic int  de620_open(struct device *);
device180drivers/net/de620.cstatic int  de620_close(struct device *);
device181drivers/net/de620.cstatic struct netstats *get_stats(struct device *);
device182drivers/net/de620.cstatic void  de620_set_multicast_list(struct device *, int, void *);
device183drivers/net/de620.cstatic int  de620_start_xmit(struct sk_buff *, struct device *);
device187drivers/net/de620.cstatic int  de620_rx_intr(struct device *);
device190drivers/net/de620.cstatic int  adapter_init(struct device *);
device191drivers/net/de620.cint    de620_probe(struct device *);
device408drivers/net/de620.cde620_open(struct device *dev)
device432drivers/net/de620.cde620_close(struct device *dev)
device453drivers/net/de620.cget_stats(struct device *dev)
device469drivers/net/de620.cde620_set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device485drivers/net/de620.cde620_start_xmit(struct sk_buff *skb, struct device *dev)
device577drivers/net/de620.cstruct device *dev = irq2dev_map[irq];
device619drivers/net/de620.cde620_rx_intr(struct device *dev)
device715drivers/net/de620.cadapter_init(struct device *dev)
device803drivers/net/de620.cde620_probe(struct device *dev)
device978drivers/net/de620.cstatic struct device de620_dev = {
device326drivers/net/depca.cstatic int depca_open(struct device *dev);
device327drivers/net/depca.cstatic int depca_start_xmit(struct sk_buff *skb, struct device *dev);
device329drivers/net/depca.cstatic int depca_close(struct device *dev);
device330drivers/net/depca.cstatic struct enet_statistics *depca_get_stats(struct device *dev);
device332drivers/net/depca.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device338drivers/net/depca.cstatic int  depca_probe1(struct device *dev, short ioaddr);
device339drivers/net/depca.cstatic void depca_init_ring(struct device *dev);
device340drivers/net/depca.cstatic int  depca_rx(struct device *dev);
device341drivers/net/depca.cstatic int  depca_tx(struct device *dev);
device343drivers/net/depca.cstatic void LoadCSRs(struct device *dev);
device344drivers/net/depca.cstatic int  InitRestartDepca(struct device *dev);
device353drivers/net/depca.cstatic struct device *isa_probe(struct device *dev);
device354drivers/net/depca.cstatic struct device *eisa_probe(struct device *dev);
device355drivers/net/depca.cstatic struct device *alloc_device(struct device *dev, int ioaddr);
device375drivers/net/depca.cint depca_probe(struct device *dev)
device380drivers/net/depca.cstruct device *eth0;
device413drivers/net/depca.cdepca_probe1(struct device *dev, short ioaddr)
device679drivers/net/depca.cdepca_open(struct device *dev)
device775drivers/net/depca.cdepca_init_ring(struct device *dev)
device809drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
device961drivers/net/depca.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device1017drivers/net/depca.cdepca_rx(struct device *dev)
device1099drivers/net/depca.cdepca_tx(struct device *dev)
device1146drivers/net/depca.cdepca_close(struct device *dev)
device1185drivers/net/depca.cstatic void LoadCSRs(struct device *dev)
device1201drivers/net/depca.cstatic int InitRestartDepca(struct device *dev)
device1230drivers/net/depca.cdepca_get_stats(struct device *dev)
device1250drivers/net/depca.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device1317drivers/net/depca.cstatic struct device *isa_probe(struct device *dev)
device1344drivers/net/depca.cstatic struct device *eisa_probe(struct device *dev)
device1370drivers/net/depca.cstatic struct device *alloc_device(struct device *dev, int ioaddr)
device1386drivers/net/depca.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1545drivers/net/depca.cstatic struct device thisDepca = {
device59drivers/net/dummy.cstatic int dummy_xmit(struct sk_buff *skb, struct device *dev);
device61drivers/net/dummy.cstatic struct enet_statistics *dummy_get_stats(struct device *dev);
device65drivers/net/dummy.cstatic int dummy_open(struct device *dev)
device71drivers/net/dummy.cstatic int dummy_close(struct device *dev)
device80drivers/net/dummy.cint dummy_init(struct device *dev)
device107drivers/net/dummy.cdummy_xmit(struct sk_buff *skb, struct device *dev)
device128drivers/net/dummy.cdummy_get_stats(struct device *dev)
device138drivers/net/dummy.cstatic int dummy_probe(struct device *dev)
device144drivers/net/dummy.cstatic struct device dev_dummy = {
device92drivers/net/e2100.cint e2100_probe(struct device *dev);
device93drivers/net/e2100.cint e21_probe1(struct device *dev, int ioaddr);
device95drivers/net/e2100.cstatic int e21_open(struct device *dev);
device96drivers/net/e2100.cstatic void e21_reset_8390(struct device *dev);
device97drivers/net/e2100.cstatic int e21_block_input(struct device *dev, int count,
device99drivers/net/e2100.cstatic void e21_block_output(struct device *dev, int count,
device101drivers/net/e2100.cstatic int e21_close(struct device *dev);
device111drivers/net/e2100.cint e2100_probe(struct device *dev)
device131drivers/net/e2100.cint e21_probe1(struct device *dev, int ioaddr)
device233drivers/net/e2100.ce21_open(struct device *dev)
device255drivers/net/e2100.ce21_reset_8390(struct device *dev)
device273drivers/net/e2100.ce21_block_input(struct device *dev, int count, char *buf, int ring_offset)
device294drivers/net/e2100.ce21_block_output(struct device *dev, int count, const unsigned char *buf,
device310drivers/net/e2100.ce21_close(struct device *dev)
device288drivers/net/eexpress.cextern int express_probe(struct device *dev);  /* Called from Space.c */
device290drivers/net/eexpress.cstatic int  eexp_probe1(struct device *dev, short ioaddr);
device291drivers/net/eexpress.cstatic int  eexp_open(struct device *dev);
device292drivers/net/eexpress.cstatic int  eexp_send_packet(struct sk_buff *skb, struct device *dev);
device294drivers/net/eexpress.cstatic void eexp_rx(struct device *dev);
device295drivers/net/eexpress.cstatic int  eexp_close(struct device *dev);
device296drivers/net/eexpress.cstatic struct enet_statistics *eexp_get_stats(struct device *dev);
device297drivers/net/eexpress.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device300drivers/net/eexpress.cstatic void hardware_send_packet(struct device *dev, void *buf, short length);
device301drivers/net/eexpress.cstatic void init_82586_mem(struct device *dev);
device302drivers/net/eexpress.cstatic void init_rx_bufs(struct device *dev);
device312drivers/net/eexpress.cexpress_probe(struct device *dev)
device345drivers/net/eexpress.cint eexp_probe1(struct device *dev, short ioaddr)
device422drivers/net/eexpress.ceexp_open(struct device *dev)
device452drivers/net/eexpress.ceexp_send_packet(struct sk_buff *skb, struct device *dev)
device520drivers/net/eexpress.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device639drivers/net/eexpress.ceexp_close(struct device *dev)
device671drivers/net/eexpress.ceexp_get_stats(struct device *dev)
device687drivers/net/eexpress.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device755drivers/net/eexpress.cinit_82586_mem(struct device *dev)
device813drivers/net/eexpress.cstatic void init_rx_bufs(struct device *dev)
device854drivers/net/eexpress.chardware_send_packet(struct device *dev, void *buf, short length)
device903drivers/net/eexpress.ceexp_rx(struct device *dev)
device1004drivers/net/eexpress.cstatic struct device dev_eexpress = {
device291drivers/net/ewrk3.cstatic int ewrk3_open(struct device *dev);
device292drivers/net/ewrk3.cstatic int ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
device294drivers/net/ewrk3.cstatic int ewrk3_close(struct device *dev);
device295drivers/net/ewrk3.cstatic struct enet_statistics *ewrk3_get_stats(struct device *dev);
device296drivers/net/ewrk3.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device297drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
device302drivers/net/ewrk3.cstatic int  ewrk3_hw_init(struct device *dev, short iobase);
device303drivers/net/ewrk3.cstatic void ewrk3_init(struct device *dev);
device304drivers/net/ewrk3.cstatic int  ewrk3_rx(struct device *dev);
device305drivers/net/ewrk3.cstatic int  ewrk3_tx(struct device *dev);
device309drivers/net/ewrk3.cstatic void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table);
device313drivers/net/ewrk3.cstatic unsigned char aprom_crc (struct device *dev, unsigned char *eeprom_image, char chipType);
device316drivers/net/ewrk3.cstatic struct device *isa_probe(struct device *dev);
device317drivers/net/ewrk3.cstatic struct device *eisa_probe(struct device *dev);
device318drivers/net/ewrk3.cstatic struct device *alloc_device(struct device *dev, int iobase);
device343drivers/net/ewrk3.cint ewrk3_probe(struct device *dev)
device348drivers/net/ewrk3.cstruct device *eth0;
device397drivers/net/ewrk3.cewrk3_hw_init(struct device *dev, short iobase)
device648drivers/net/ewrk3.cewrk3_open(struct device *dev)
device725drivers/net/ewrk3.cewrk3_init(struct device *dev)
device760drivers/net/ewrk3.cewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
device911drivers/net/ewrk3.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device974drivers/net/ewrk3.cewrk3_rx(struct device *dev)
device1117drivers/net/ewrk3.cewrk3_tx(struct device *dev)
device1152drivers/net/ewrk3.cewrk3_close(struct device *dev)
device1197drivers/net/ewrk3.cewrk3_get_stats(struct device *dev)
device1214drivers/net/ewrk3.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device1249drivers/net/ewrk3.cstatic void SetMulticastFilter(struct device *dev, int num_addrs, char *addrs, char *multicast_table)
device1332drivers/net/ewrk3.cstatic struct device *isa_probe(struct device *dev)
device1375drivers/net/ewrk3.cstatic struct device *eisa_probe(struct device *dev)
device1410drivers/net/ewrk3.cstatic struct device *alloc_device(struct device *dev, int iobase)
device1426drivers/net/ewrk3.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1442drivers/net/ewrk3.cdev->name = (char *)(dev + sizeof(struct device));
device1574drivers/net/ewrk3.cstatic unsigned char aprom_crc(struct device *dev, unsigned char *eeprom_image, char chipType)
device1609drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device1826drivers/net/ewrk3.cstatic struct device thisEthwrk = {
device37drivers/net/hp-plus.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device95drivers/net/hp-plus.cint hpplus_probe(struct device *dev);
device96drivers/net/hp-plus.cint hpp_probe1(struct device *dev, int ioaddr);
device98drivers/net/hp-plus.cstatic void hpp_reset_8390(struct device *dev);
device99drivers/net/hp-plus.cstatic int hpp_open(struct device *dev);
device100drivers/net/hp-plus.cstatic int hpp_close(struct device *dev);
device101drivers/net/hp-plus.cstatic int hpp_mem_block_input(struct device *dev, int count,
device103drivers/net/hp-plus.cstatic void hpp_mem_block_output(struct device *dev, int count,
device105drivers/net/hp-plus.cstatic int hpp_io_block_input(struct device *dev, int count,
device107drivers/net/hp-plus.cstatic void hpp_io_block_output(struct device *dev, int count,
device120drivers/net/hp-plus.cint hp_plus_probe(struct device *dev)
device143drivers/net/hp-plus.cint hpp_probe1(struct device *dev, int ioaddr)
device241drivers/net/hp-plus.chpp_open(struct device *dev)
device268drivers/net/hp-plus.chpp_close(struct device *dev)
device283drivers/net/hp-plus.chpp_reset_8390(struct device *dev)
device311drivers/net/hp-plus.chpp_io_block_input(struct device *dev, int count, char *buf, int ring_offset)
device323drivers/net/hp-plus.chpp_mem_block_input(struct device *dev, int count, char *buf, int ring_offset)
device341drivers/net/hp-plus.chpp_io_block_output(struct device *dev, int count,
device351drivers/net/hp-plus.chpp_mem_block_output(struct device *dev, int count,
device34drivers/net/hp.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device55drivers/net/hp.cint hp_probe(struct device *dev);
device56drivers/net/hp.cint hp_probe1(struct device *dev, int ioaddr);
device58drivers/net/hp.cstatic void hp_reset_8390(struct device *dev);
device59drivers/net/hp.cstatic int hp_block_input(struct device *dev, int count,
device61drivers/net/hp.cstatic void hp_block_output(struct device *dev, int count,
device63drivers/net/hp.cstatic void hp_init_card(struct device *dev);
device78drivers/net/hp.cint hp_probe(struct device *dev)
device100drivers/net/hp.cint hp_probe1(struct device *dev, int ioaddr)
device191drivers/net/hp.chp_reset_8390(struct device *dev)
device219drivers/net/hp.chp_block_input(struct device *dev, int count, char *buf, int ring_offset)
device254drivers/net/hp.chp_block_output(struct device *dev, int count,
device312drivers/net/hp.chp_init_card(struct device *dev)
device39drivers/net/lance.cstruct device *init_etherdev(struct device *dev, int sizeof_private,
device235drivers/net/lance.cstatic int lance_open(struct device *dev);
device236drivers/net/lance.cstatic void lance_init_ring(struct device *dev);
device237drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
device238drivers/net/lance.cstatic int lance_rx(struct device *dev);
device240drivers/net/lance.cstatic int lance_close(struct device *dev);
device241drivers/net/lance.cstatic struct enet_statistics *lance_get_stats(struct device *dev);
device243drivers/net/lance.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device313drivers/net/lance.cstruct device *dev;
device547drivers/net/lance.clance_open(struct device *dev)
device622drivers/net/lance.clance_init_ring(struct device *dev)
device651drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
device776drivers/net/lance.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device892drivers/net/lance.clance_rx(struct device *dev)
device956drivers/net/lance.clance_close(struct device *dev)
device989drivers/net/lance.clance_get_stats(struct device *dev)
device1014drivers/net/lance.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device45drivers/net/loopback.cloopback_xmit(struct sk_buff *skb, struct device *dev)
device84drivers/net/loopback.cget_stats(struct device *dev)
device89drivers/net/loopback.cstatic int loopback_open(struct device *dev)
device97drivers/net/loopback.cloopback_init(struct device *dev)
device34drivers/net/ne.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device62drivers/net/ne.cint ne_probe(struct device *dev);
device63drivers/net/ne.cstatic int ne_probe1(struct device *dev, int ioaddr);
device65drivers/net/ne.cstatic void ne_reset_8390(struct device *dev);
device66drivers/net/ne.cstatic int ne_block_input(struct device *dev, int count,
device68drivers/net/ne.cstatic void ne_block_output(struct device *dev, const int count,
device98drivers/net/ne.cint ne_probe(struct device *dev)
device120drivers/net/ne.cstatic int ne_probe1(struct device *dev, int ioaddr)
device295drivers/net/ne.cne_reset_8390(struct device *dev)
device318drivers/net/ne.cne_block_input(struct device *dev, int count, char *buf, int ring_offset)
device371drivers/net/ne.cne_block_output(struct device *dev, int count,
device50drivers/net/net_init.cstatic struct device *ethdev_index[MAX_ETH_CARDS];
device91drivers/net/net_init.cstruct device *
device92drivers/net/net_init.cinit_etherdev(struct device *dev, int sizeof_priv, unsigned long *mem_startp)
device99drivers/net/net_init.cint alloc_size = sizeof(struct device) + sizeof("eth%d  ")
device101drivers/net/net_init.cstruct device *cur_dev;
device125drivers/net/net_init.cdev = (struct device *)*mem_startp;
device128drivers/net/net_init.cdev = (struct device *)kmalloc(alloc_size, GFP_KERNEL);
device152drivers/net/net_init.cstruct device **old_devp = &dev_base;
device161drivers/net/net_init.cvoid ether_setup(struct device *dev)
device203drivers/net/net_init.cint ether_config(struct device *dev, struct ifmap *map)
device220drivers/net/net_init.cint register_netdev(struct device *dev)
device222drivers/net/net_init.cstruct device *d = dev_base;
device261drivers/net/net_init.cvoid unregister_netdev(struct device *dev)
device263drivers/net/net_init.cstruct device *d = dev_base;
device163drivers/net/ni52.cstatic int     ni52_probe1(struct device *dev,int ioaddr);
device165drivers/net/ni52.cstatic int     ni52_open(struct device *dev);
device166drivers/net/ni52.cstatic int     ni52_close(struct device *dev);
device167drivers/net/ni52.cstatic int     ni52_send_packet(struct sk_buff *,struct device *);
device168drivers/net/ni52.cstatic struct  enet_statistics *ni52_get_stats(struct device *dev);
device169drivers/net/ni52.cstatic void    set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device172drivers/net/ni52.cstatic int     init586(struct device *dev,int num_addrs,void *addrs);
device173drivers/net/ni52.cstatic int     check586(struct device *dev,char *where,unsigned size);
device174drivers/net/ni52.cstatic void    alloc586(struct device *dev);
device175drivers/net/ni52.cstatic void    startrecv586(struct device *dev);
device176drivers/net/ni52.cstatic void   *alloc_rfa(struct device *dev,void *ptr);
device177drivers/net/ni52.cstatic void    ni52_rcv_int(struct device *dev);
device178drivers/net/ni52.cstatic void    ni52_xmt_int(struct device *dev);
device179drivers/net/ni52.cstatic void    ni52_rnr_int(struct device *dev);
device207drivers/net/ni52.cstatic int ni52_close(struct device *dev)
device224drivers/net/ni52.cstatic int ni52_open(struct device *dev)
device248drivers/net/ni52.cstatic int check586(struct device *dev,char *where,unsigned size)
device285drivers/net/ni52.cvoid alloc586(struct device *dev)
device319drivers/net/ni52.cint ni52_probe(struct device *dev)
device348drivers/net/ni52.cstatic int ni52_probe1(struct device *dev,int ioaddr)
device450drivers/net/ni52.cstatic int init586(struct device *dev,int num_addrs,void *addrs)
device685drivers/net/ni52.cstatic void *alloc_rfa(struct device *dev,void *ptr) 
device731drivers/net/ni52.cstruct device *dev = (struct device *) irq2dev_map[irq];
device788drivers/net/ni52.cstatic void ni52_rcv_int(struct device *dev)
device841drivers/net/ni52.cstatic void ni52_rnr_int(struct device *dev)
device863drivers/net/ni52.cstatic void ni52_xmt_int(struct device *dev)
device913drivers/net/ni52.cstatic void startrecv586(struct device *dev)
device927drivers/net/ni52.cstatic int ni52_send_packet(struct sk_buff *skb, struct device *dev)
device1054drivers/net/ni52.cstatic struct enet_statistics *ni52_get_stats(struct device *dev)
device1080drivers/net/ni52.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device114drivers/net/ni65.cstatic int   ni65_probe1(struct device *dev,int);
device116drivers/net/ni65.cstatic void recv_intr(struct device *dev);
device117drivers/net/ni65.cstatic void xmit_intr(struct device *dev);
device118drivers/net/ni65.cstatic int   ni65_open(struct device *dev);
device119drivers/net/ni65.cstatic int am7990_reinit(struct device *dev);
device120drivers/net/ni65.cstatic int   ni65_send_packet(struct sk_buff *skb, struct device *dev);
device121drivers/net/ni65.cstatic int   ni65_close(struct device *dev);
device122drivers/net/ni65.cstatic struct enet_statistics *ni65_get_stats(struct device *);
device124drivers/net/ni65.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device149drivers/net/ni65.cstatic int ni65_open(struct device *dev)
device165drivers/net/ni65.cstatic int ni65_close(struct device *dev)
device178drivers/net/ni65.cint ni65_probe(struct device *dev)
device206drivers/net/ni65.cstatic int ni65_probe1(struct device *dev,int ioaddr)
device307drivers/net/ni65.cstatic int am7990_reinit(struct device *dev)
device403drivers/net/ni65.cstruct device *dev = (struct device *) irq2dev_map[irq];
device445drivers/net/ni65.cstatic void xmit_intr(struct device *dev)
device496drivers/net/ni65.cstatic void recv_intr(struct device *dev)
device564drivers/net/ni65.cstatic int ni65_send_packet(struct sk_buff *skb, struct device *dev)
device633drivers/net/ni65.cstatic struct enet_statistics *ni65_get_stats(struct device *dev)
device638drivers/net/ni65.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device124drivers/net/plip.cstatic void plip_kick_bh(struct device *dev);
device125drivers/net/plip.cstatic void plip_bh(struct device *dev);
device131drivers/net/plip.cstatic int plip_rebuild_header(void *buff, struct device *dev,
device133drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
device134drivers/net/plip.cstatic int plip_open(struct device *dev);
device135drivers/net/plip.cstatic int plip_close(struct device *dev);
device136drivers/net/plip.cstatic struct enet_statistics *plip_get_stats(struct device *dev);
device137drivers/net/plip.cstatic int plip_config(struct device *dev, struct ifmap *map);
device138drivers/net/plip.cstatic int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
device209drivers/net/plip.cint (*orig_rebuild_header)(void *eth, struct device *dev,
device216drivers/net/plip.cplip_init(struct device *dev)
device304drivers/net/plip.cplip_kick_bh(struct device *dev)
device315drivers/net/plip.cstatic int plip_none(struct device *, struct net_local *,
device317drivers/net/plip.cstatic int plip_receive_packet(struct device *, struct net_local *,
device319drivers/net/plip.cstatic int plip_send_packet(struct device *, struct net_local *,
device321drivers/net/plip.cstatic int plip_connection_close(struct device *, struct net_local *,
device323drivers/net/plip.cstatic int plip_error(struct device *, struct net_local *,
device325drivers/net/plip.cstatic int plip_bh_timeout_error(struct device *dev, struct net_local *nl,
device334drivers/net/plip.ctypedef int (*plip_func)(struct device *dev, struct net_local *nl,
device348drivers/net/plip.cplip_bh(struct device *dev)
device366drivers/net/plip.cplip_bh_timeout_error(struct device *dev, struct net_local *nl,
device430drivers/net/plip.cplip_none(struct device *dev, struct net_local *nl,
device489drivers/net/plip.cplip_receive_packet(struct device *dev, struct net_local *nl,
device649drivers/net/plip.cplip_send_packet(struct device *dev, struct net_local *nl,
device751drivers/net/plip.cplip_connection_close(struct device *dev, struct net_local *nl,
device766drivers/net/plip.cplip_error(struct device *dev, struct net_local *nl,
device793drivers/net/plip.cstruct device *dev = (struct device *) irq2dev_map[irq];
device845drivers/net/plip.cplip_rebuild_header(void *buff, struct device *dev, unsigned long dst,
device868drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
device921drivers/net/plip.cplip_open(struct device *dev)
device965drivers/net/plip.cplip_close(struct device *dev)
device1000drivers/net/plip.cplip_get_stats(struct device *dev)
device1009drivers/net/plip.cplip_config(struct device *dev, struct ifmap *map)
device1024drivers/net/plip.cplip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device1047drivers/net/plip.cstatic struct device dev_plip0 = 
device1055drivers/net/plip.cstatic struct device dev_plip1 = 
device1063drivers/net/plip.cstatic struct device dev_plip2 = 
device99drivers/net/ppp.cint ppp_init(struct device *);
device101drivers/net/ppp.cstatic int ppp_dev_open(struct device *);
device102drivers/net/ppp.cstatic int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
device103drivers/net/ppp.cstatic int ppp_dev_close(struct device *);
device117drivers/net/ppp.cstatic int ppp_xmit(struct sk_buff *, struct device *);
device118drivers/net/ppp.cstatic unsigned short ppp_type_trans(struct sk_buff *, struct device *);
device121drivers/net/ppp.cstatic int ppp_header(unsigned char *buff, struct device *dev,
device124drivers/net/ppp.cstatic int ppp_rebuild_header(void *buff, struct device *dev);
device126drivers/net/ppp.cstruct device *dev);
device128drivers/net/ppp.cstatic int ppp_header(unsigned char *, struct device *, unsigned short,
device130drivers/net/ppp.cstatic int ppp_rebuild_header(void *, struct device *, unsigned long,
device134drivers/net/ppp.cstatic struct enet_statistics *ppp_get_stats (struct device *);
device212drivers/net/ppp.cppp_init(struct device *dev)
device369drivers/net/ppp.cstruct device *dev;
device581drivers/net/ppp.cppp_dev_open(struct device *dev)
device602drivers/net/ppp.cppp_dev_close(struct device *dev)
device622drivers/net/ppp.cstatic int ppp_dev_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
device1688drivers/net/ppp.cppp_xmit(struct sk_buff *skb, struct device *dev)
device1824drivers/net/ppp.cppp_type_trans (struct sk_buff *skb, struct device *dev)
device1831drivers/net/ppp.cppp_header(unsigned char *buff, struct device *dev, unsigned short type,
device1838drivers/net/ppp.cppp_rebuild_header(void *buff, struct device *dev)
device1844drivers/net/ppp.cppp_add_arp(unsigned long addr, struct sk_buff *skb, struct device *dev)
device1851drivers/net/ppp.cppp_header(unsigned char *buff, struct device *dev, unsigned short type,
device1858drivers/net/ppp.cppp_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
device1866drivers/net/ppp.cppp_get_stats (struct device *dev)
device2052drivers/net/ppp.cstatic struct device dev_ppp[PPP_NRUNIT] = {
device485drivers/net/sk_g16.cint          SK_init(struct device *dev);
device486drivers/net/sk_g16.cstatic int   SK_probe(struct device *dev, short ioaddr);
device488drivers/net/sk_g16.cstatic int   SK_open(struct device *dev);
device489drivers/net/sk_g16.cstatic int   SK_send_packet(struct sk_buff *skb, struct device *dev);
device491drivers/net/sk_g16.cstatic void  SK_rxintr(struct device *dev);
device492drivers/net/sk_g16.cstatic void  SK_txintr(struct device *dev);
device493drivers/net/sk_g16.cstatic int   SK_close(struct device *dev);
device495drivers/net/sk_g16.cstatic struct enet_statistics *SK_get_stats(struct device *dev);
device500drivers/net/sk_g16.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device508drivers/net/sk_g16.cstatic int SK_lance_init(struct device *dev, unsigned short mode);
device520drivers/net/sk_g16.cvoid SK_print_pos(struct device *dev, char *text);
device521drivers/net/sk_g16.cvoid SK_print_dev(struct device *dev, char *text);
device522drivers/net/sk_g16.cvoid SK_print_ram(struct device *dev);
device552drivers/net/sk_g16.cint SK_init(struct device *dev)
device636drivers/net/sk_g16.cint SK_probe(struct device *dev, short ioaddr)
device862drivers/net/sk_g16.cstatic int SK_open(struct device *dev)
device1027drivers/net/sk_g16.cstatic int SK_lance_init(struct device *dev, unsigned short mode)
device1193drivers/net/sk_g16.cstatic int SK_send_packet(struct sk_buff *skb, struct device *dev)
device1315drivers/net/sk_g16.cstruct device *dev = (struct device *) irq2dev_map[irq];
device1387drivers/net/sk_g16.cstatic void SK_txintr(struct device *dev)
device1506drivers/net/sk_g16.cstatic void SK_rxintr(struct device *dev)
device1654drivers/net/sk_g16.cstatic int SK_close(struct device *dev)
device1692drivers/net/sk_g16.cstatic struct enet_statistics *SK_get_stats(struct device *dev)
device1739drivers/net/sk_g16.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device2002drivers/net/sk_g16.cvoid SK_print_pos(struct device *dev, char *text)
device2037drivers/net/sk_g16.cvoid SK_print_dev(struct device *dev, char *text)
device2080drivers/net/sk_g16.cvoid SK_print_ram(struct device *dev)
device65drivers/net/skeleton.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device95drivers/net/skeleton.cextern int netcard_probe(struct device *dev);
device97drivers/net/skeleton.cstatic int netcard_probe1(struct device *dev, int ioaddr);
device98drivers/net/skeleton.cstatic int net_open(struct device *dev);
device99drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
device101drivers/net/skeleton.cstatic void net_rx(struct device *dev);
device102drivers/net/skeleton.cstatic int net_close(struct device *dev);
device103drivers/net/skeleton.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device104drivers/net/skeleton.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device109drivers/net/skeleton.cextern void chipset_init(struct device *dev, int startp);
device125drivers/net/skeleton.cnetcard_probe(struct device *dev)
device151drivers/net/skeleton.cstatic int netcard_probe1(struct device *dev, int ioaddr)
device278drivers/net/skeleton.cnet_open(struct device *dev)
device308drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device360drivers/net/skeleton.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device396drivers/net/skeleton.cnet_rx(struct device *dev)
device447drivers/net/skeleton.cnet_close(struct device *dev)
device478drivers/net/skeleton.cnet_get_stats(struct device *dev)
device498drivers/net/skeleton.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device157drivers/net/slip.cstruct device *dev = sl->dev;
device413drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
device463drivers/net/slip.csl_type_trans (struct sk_buff *skb, struct device *dev)
device478drivers/net/slip.csl_header(unsigned char *buff, struct device *dev, unsigned short type,
device496drivers/net/slip.csl_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
device514drivers/net/slip.csl_open(struct device *dev)
device598drivers/net/slip.csl_close(struct device *dev)
device746drivers/net/slip.csl_get_stats(struct device *dev)
device935drivers/net/slip.csl_set_mac_address(struct device *dev, void *addr)
device950drivers/net/slip.csl_set_dev_mac_address(struct device *dev, void *addr)
device1052drivers/net/slip.cslip_init(struct device *dev)
device1145drivers/net/slip.cstatic struct device dev_slip[SL_NRUNIT] =  {
device53drivers/net/slip.hstruct device    *dev;    /* easy for intr handling  */
device106drivers/net/slip.hextern int slip_init(struct device *dev);
device52drivers/net/smc-ultra.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device59drivers/net/smc-ultra.cint ultra_probe(struct device *dev);
device60drivers/net/smc-ultra.cint ultra_probe1(struct device *dev, int ioaddr);
device62drivers/net/smc-ultra.cstatic int ultra_open(struct device *dev);
device63drivers/net/smc-ultra.cstatic void ultra_reset_8390(struct device *dev);
device64drivers/net/smc-ultra.cstatic int ultra_block_input(struct device *dev, int count,
device66drivers/net/smc-ultra.cstatic void ultra_block_output(struct device *dev, int count,
device68drivers/net/smc-ultra.cstatic int ultra_close_card(struct device *dev);
device88drivers/net/smc-ultra.cint ultra_probe(struct device *dev)
device110drivers/net/smc-ultra.cint ultra_probe1(struct device *dev, int ioaddr)
device215drivers/net/smc-ultra.cultra_open(struct device *dev)
device229drivers/net/smc-ultra.cultra_reset_8390(struct device *dev)
device247drivers/net/smc-ultra.cultra_block_input(struct device *dev, int count, char *buf, int ring_offset)
device271drivers/net/smc-ultra.cultra_block_output(struct device *dev, int count, const unsigned char *buf,
device286drivers/net/smc-ultra.cultra_close_card(struct device *dev)
device39drivers/net/tulip.cstruct device *init_etherdev(struct device *dev, int sizeof_private,
device158drivers/net/tulip.cstatic int tulip_open(struct device *dev);
device159drivers/net/tulip.cstatic void tulip_init_ring(struct device *dev);
device160drivers/net/tulip.cstatic int tulip_start_xmit(struct sk_buff *skb, struct device *dev);
device161drivers/net/tulip.cstatic int tulip_rx(struct device *dev);
device163drivers/net/tulip.cstatic int tulip_close(struct device *dev);
device164drivers/net/tulip.cstatic struct enet_statistics *tulip_get_stats(struct device *dev);
device165drivers/net/tulip.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device166drivers/net/tulip.cstatic int set_mac_address(struct device *dev, void *addr);
device206drivers/net/tulip.cstruct device *dev;
device266drivers/net/tulip.ctulip_open(struct device *dev)
device349drivers/net/tulip.ctulip_init_ring(struct device *dev)
device376drivers/net/tulip.ctulip_start_xmit(struct sk_buff *skb, struct device *dev)
device449drivers/net/tulip.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device574drivers/net/tulip.ctulip_rx(struct device *dev)
device634drivers/net/tulip.ctulip_close(struct device *dev)
device660drivers/net/tulip.ctulip_get_stats(struct device *dev)
device677drivers/net/tulip.cset_multicast_list(struct device *dev, int num_addrs, void *addrs)
device717drivers/net/tulip.cset_mac_address(struct device *dev, void *addr)
device47drivers/net/wavelan.ctypedef struct device    device;
device67drivers/net/wavelan.cdevice    *dev;
device72drivers/net/wavelan.cextern int    wavelan_probe(device *);  /* See Space.c */
device79drivers/net/wavelan.cstatic int    wavelan_probe1(device *, unsigned short);
device80drivers/net/wavelan.cstatic int    wavelan_open(device *);
device81drivers/net/wavelan.cstatic int    wavelan_send_packet(struct sk_buff *, device *);
device83drivers/net/wavelan.cstatic int    wavelan_close(device *);
device84drivers/net/wavelan.cstatic en_stats    *wavelan_get_stats(device *);
device85drivers/net/wavelan.cstatic void    wavelan_set_multicast_list(device *, int, void *);
device90drivers/net/wavelan.cstatic void    wavelan_cu_show_one(device *, net_local *, int, unsigned short);
device91drivers/net/wavelan.cstatic void    wavelan_cu_start(device *);
device92drivers/net/wavelan.cstatic void    wavelan_ru_start(device *);
device99drivers/net/wavelan.cstatic void    wavelan_ru_show(device *);
device100drivers/net/wavelan.cstatic void    wavelan_cu_show(device *);
device101drivers/net/wavelan.cstatic void    wavelan_dev_show(device *);
device102drivers/net/wavelan.cstatic void    wavelan_local_show(device *);
device190drivers/net/wavelan.cwavelan_ints_off(device *dev)
device209drivers/net/wavelan.cwavelan_ints_on(device *dev)
device343drivers/net/wavelan.cwavelan_mmc_init(device *dev, psa_t *psa)
device420drivers/net/wavelan.cwavelan_ack(device *dev)
device459drivers/net/wavelan.cwavelan_synchronous_cmd(device *dev, char *str)
device498drivers/net/wavelan.cwavelan_hardware_reset(device *dev)
device708drivers/net/wavelan.cwavelan_probe(device *dev)
device718drivers/net/wavelan.cuse 0x390 and leave 0x300 for the Ethernet device.
device760drivers/net/wavelan.cwavelan_probe1(device *dev, unsigned short ioaddr)
device927drivers/net/wavelan.cwavelan_ru_start(device *dev)
device994drivers/net/wavelan.cwavelan_cu_start(device *dev)
device1073drivers/net/wavelan.cwavelan_open(device *dev)
device1086drivers/net/wavelan.cirq2dev_map[dev->irq] != (device *)0
device1089drivers/net/wavelan.c(irq2dev_map[dev->irq] = dev) == (device *)0
device1094drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device1101drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device1117drivers/net/wavelan.chardware_send_packet(device *dev, void *buf, short length)
device1227drivers/net/wavelan.cwavelan_send_packet(struct sk_buff *skb, device *dev)
device1319drivers/net/wavelan.cwavelan_receive(device *dev)
device1548drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
device1654drivers/net/wavelan.cdevice    *dev;
device1662drivers/net/wavelan.cdev = (device *)a;
device1699drivers/net/wavelan.cdevice    *dev;
device1706drivers/net/wavelan.cif ((dev = (device *)(irq2dev_map[irq])) == (device *)0)
device1801drivers/net/wavelan.cwavelan_close(device *dev)
device1823drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device1843drivers/net/wavelan.cwavelan_get_stats(device *dev)
device1854drivers/net/wavelan.cwavelan_set_multicast_list(device *dev, int num_addrs, void *addrs)
device1899drivers/net/wavelan.csprintf_stats(char *buffer, device *dev)
device2000drivers/net/wavelan.cstatic struct device  dev_wavelan    =
device2030drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
device2241drivers/net/wavelan.cwavelan_ru_show(device *dev)
device2256drivers/net/wavelan.cwavelan_cu_show(device *dev)
device2279drivers/net/wavelan.cwavelan_dev_show(device *dev)
device2292drivers/net/wavelan.cwavelan_local_show(device *dev)
device32drivers/net/wd.cextern struct device *init_etherdev(struct device *dev, int sizeof_private,
device39drivers/net/wd.cint wd_probe(struct device *dev);
device40drivers/net/wd.cint wd_probe1(struct device *dev, int ioaddr);
device42drivers/net/wd.cstatic int wd_open(struct device *dev);
device43drivers/net/wd.cstatic void wd_reset_8390(struct device *dev);
device44drivers/net/wd.cstatic int wd_block_input(struct device *dev, int count,
device46drivers/net/wd.cstatic void wd_block_output(struct device *dev, int count,
device48drivers/net/wd.cstatic int wd_close_card(struct device *dev);
device78drivers/net/wd.cint wd_probe(struct device *dev)
device100drivers/net/wd.cint wd_probe1(struct device *dev, int ioaddr)
device275drivers/net/wd.cwd_open(struct device *dev)
device292drivers/net/wd.cwd_reset_8390(struct device *dev)
device315drivers/net/wd.cwd_block_input(struct device *dev, int count, char *buf, int ring_offset)
device346drivers/net/wd.cwd_block_output(struct device *dev, int count, const unsigned char *buf,
device364drivers/net/wd.cwd_close_card(struct device *dev)
device182drivers/net/znet.cint znet_probe(struct device *dev);
device183drivers/net/znet.cstatic int  znet_open(struct device *dev);
device184drivers/net/znet.cstatic int  znet_send_packet(struct sk_buff *skb, struct device *dev);
device186drivers/net/znet.cstatic void  znet_rx(struct device *dev);
device187drivers/net/znet.cstatic int  znet_close(struct device *dev);
device188drivers/net/znet.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device189drivers/net/znet.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
device190drivers/net/znet.cstatic void hardware_init(struct device *dev);
device202drivers/net/znet.cint znet_probe(struct device *dev)
device286drivers/net/znet.cstatic int znet_open(struct device *dev)
device317drivers/net/znet.cstatic int znet_send_packet(struct sk_buff *skb, struct device *dev)
device407drivers/net/znet.cstruct device *dev = irq2dev_map[irq];
device470drivers/net/znet.cstatic void znet_rx(struct device *dev)
device604drivers/net/znet.cstatic int znet_close(struct device *dev)
device629drivers/net/znet.cstatic struct enet_statistics *net_get_stats(struct device *dev)
device649drivers/net/znet.cstatic void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
device691drivers/net/znet.cstatic void hardware_init(struct device *dev)
device328drivers/scsi/53c7,8xx.cint device;
device378drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.device = ints[2];
device379drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.device = ints[3];
device949drivers/scsi/53c7,8xx.c(((overrides[current_override].data.pci.device
device1397drivers/scsi/NCR5380.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
device1401drivers/scsi/NCR5380.cif (cmd->device->current_tag == 0)
device1402drivers/scsi/NCR5380.ccmd->device->current_tag = 1;
device1404drivers/scsi/NCR5380.ccmd->tag = cmd->device->current_tag;
device1405drivers/scsi/NCR5380.ccmd->device->current_tag++;
device1429drivers/scsi/NCR5380.cif (!cmd->device->tagged_queue)
device1988drivers/scsi/NCR5380.cif (!cmd->device->borken &&
device1998drivers/scsi/NCR5380.cif (!cmd->device->borken && transfersize && 
device2011drivers/scsi/NCR5380.ccmd->device->borken = 1;
device2160drivers/scsi/NCR5380.ccmd->device->tagged_queue = 0;
device2169drivers/scsi/NCR5380.ccmd->device->disconnect = 1;
device1020drivers/scsi/aha152x.cif(current_SC && !current_SC->device->soft_reset)
device1033drivers/scsi/aha152x.cif(!ptr->device->soft_reset)
device1077drivers/scsi/aha1542.c!(HOSTDATA(shost)->SCint[i]->device->soft_reset))
device1231drivers/scsi/aha1542.ctranslation_algorithm = HOSTDATA(disk->device->host)->bios_translation;
device1360drivers/scsi/buslogic.c&& !HOSTDATA(shpnt)->sc[i]->device->soft_reset) {
device1533drivers/scsi/buslogic.cif (HOSTDATA(disk->device->host)->bios_translation == BIOS_TRANSLATION_BIG
device947drivers/scsi/eata.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
device952drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
device958drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
device963drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
device973drivers/scsi/eata.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
device996drivers/scsi/eata.cif (SCpnt->device->type != TYPE_TAPE)
device188drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
device209drivers/scsi/eata_dma.cif (cmd->device->type != TYPE_TAPE)
device1627drivers/scsi/fdomain.cretcode = kernel_scsi_ioctl( disk->device,
device356drivers/scsi/scsi.cSCpnt->device = SDpnt;
device682drivers/scsi/scsi.cScsi_Cmnd * request_queueable (struct request * req, Scsi_Device * device)
device688drivers/scsi/scsi.cif (!device)
device694drivers/scsi/scsi.cSCpnt =  device->host->host_queue;
device696drivers/scsi/scsi.cif(SCpnt->target == device->id &&
device697drivers/scsi/scsi.cSCpnt->lun == device->lun)
device704drivers/scsi/scsi.cif (SCSI_BLOCK(device->host)) return NULL;
device708drivers/scsi/scsi.ctablesize = device->host->sg_tablesize;
device758drivers/scsi/scsi.cScsi_Cmnd * allocate_device (struct request ** reqp, Scsi_Device * device,
device770drivers/scsi/scsi.cif (!device)
device778drivers/scsi/scsi.chost = device->host;
device785drivers/scsi/scsi.cif(SCpnt->target == device->id &&
device786drivers/scsi/scsi.cSCpnt->lun == device->lun) {
device805drivers/scsi/scsi.cdevice->id ,device->lun);
device808drivers/scsi/scsi.cSCSI_SLEEP(&device->device_wait,
device813drivers/scsi/scsi.ctablesize = device->host->sg_tablesize;
device1556drivers/scsi/scsi.cSCpnt->device->soft_reset) {
device2018drivers/scsi/scsi.cSCpnt->device = SDpnt;
device2218drivers/scsi/scsi.cSCpnt->device = SDpnt;
device433drivers/scsi/scsi.hScsi_Device * device;
device582drivers/scsi/scsi.hwake_up(&SCpnt->device->device_wait);
device142drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
device214drivers/scsi/scsi_ioctl.cif(SCpnt->device->scsi_request_fn)
device215drivers/scsi/scsi_ioctl.c(*SCpnt->device->scsi_request_fn)();
device217drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
device51drivers/scsi/sd.cSC->device->type != TYPE_MOD)
device86drivers/scsi/sd.cif(target >= sd_template.dev_max || !rscsi_disks[target].device)
device92drivers/scsi/sd.cwhile (rscsi_disks[target].device->busy);
device94drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
device97drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
device107drivers/scsi/sd.crscsi_disks[target].device->access_count++;
device108drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
device109drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)++;
device120drivers/scsi/sd.crscsi_disks[target].device->access_count--;
device121drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
device122drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)--;
device124drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
device125drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
device167drivers/scsi/sd.cif(rscsi_disks[i].device) 
device305drivers/scsi/sd.cif(rscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->removable) {
device309drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
device336drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->host->host_no,
device337drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->id,
device338drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.dev)].device->lun, result);
device385drivers/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
device412drivers/scsi/sd.crscsi_disks[DEVICE_NR(MINOR(req->dev))].device);
device458drivers/scsi/sd.c!rscsi_disks[DEVICE_NR(dev)].device ||
device468drivers/scsi/sd.cif (rscsi_disks[dev].device->changed)
device503drivers/scsi/sd.cif (!rscsi_disks[dev].device->writeable)
device801drivers/scsi/sd.c(SCpnt->device->type == TYPE_DISK ? 
device815drivers/scsi/sd.c!rscsi_disks[target].device) {
device820drivers/scsi/sd.cif(!rscsi_disks[target].device->removable) return 0;
device830drivers/scsi/sd.crscsi_disks[target].device->changed = 1;
device835drivers/scsi/sd.cretval = rscsi_disks[target].device->changed;
device836drivers/scsi/sd.cif(!flag) rscsi_disks[target].device->changed = 0;
device864drivers/scsi/sd.cSCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
device873drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device891drivers/scsi/sd.cif(the_result && !rscsi_disks[i].device->removable && 
device897drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device933drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device964drivers/scsi/sd.cwake_up(&SCpnt->device->device_wait); 
device1002drivers/scsi/sd.cif(rscsi_disks[i].device->removable && 
device1004drivers/scsi/sd.crscsi_disks[i].device->changed = 1;
device1023drivers/scsi/sd.cif(rscsi_disks[i].device->removable){
device1027drivers/scsi/sd.crscsi_disks[i].device = NULL;
device1128drivers/scsi/sd.crscsi_disks[i].device)
device1142drivers/scsi/sd.cif(rscsi_disks[0].device && rscsi_disks[0].device->host->sg_tablesize)
device1174drivers/scsi/sd.cif(!dpnt->device) break;
device1179drivers/scsi/sd.crscsi_disks[i].device = SDp;
device1186drivers/scsi/sd.c#define DEVICE_BUSY rscsi_disks[target].device->busy
device1187drivers/scsi/sd.c#define USAGE rscsi_disks[target].device->access_count
device1257drivers/scsi/sd.cif(dpnt->device == SDp) {
device1274drivers/scsi/sd.cdpnt->device = NULL;
device37drivers/scsi/sd.hScsi_Device  *device;    
device32drivers/scsi/sd_ioctl.chost = rscsi_disks[MINOR(dev) >> 4].device->host;
device73drivers/scsi/sd_ioctl.creturn scsi_ioctl(rscsi_disks[MINOR(dev) >> 4].device , cmd, (void *) arg);
device617drivers/scsi/seagate.cborken = (int) SCint->device->borken;
device1608drivers/scsi/seagate.cif (disk->device->scsi_level < 2) 
device1615drivers/scsi/seagate.ccmd[1] = (disk->device->lun << 5) & 0xe5;
device1631drivers/scsi/seagate.cif (!(result = kernel_scsi_ioctl (disk->device, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) {
device1644drivers/scsi/seagate.cif (!(result = kernel_scsi_ioctl (disk->device, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) {
device48drivers/scsi/sg.cScsi_Device *device;
device79drivers/scsi/sg.creturn scsi_ioctl(scsi_generics[dev].device, cmd_in, (void *) arg);
device87drivers/scsi/sg.cif (dev>=sg_template.dev_max || !scsi_generics[dev].device)
device121drivers/scsi/sg.cif (scsi_generics[dev].device->host->hostt->usage_count)
device122drivers/scsi/sg.c(*scsi_generics[dev].device->host->hostt->usage_count)++;
device131drivers/scsi/sg.cif (scsi_generics[dev].device->host->hostt->usage_count)
device132drivers/scsi/sg.c(*scsi_generics[dev].device->host->hostt->usage_count)--;
device174drivers/scsi/sg.cstruct scsi_generic *device=&scsi_generics[dev];
device177drivers/scsi/sg.cwhile(!device->pending || !device->complete)
device181drivers/scsi/sg.cinterruptible_sleep_on(&device->read_wait);
device185drivers/scsi/sg.cdevice->header.pack_len=device->header.reply_len;
device186drivers/scsi/sg.cdevice->header.result=0;
device189drivers/scsi/sg.cmemcpy_tofs(buf,&device->header,sizeof(struct sg_header));
device191drivers/scsi/sg.cif (count>device->header.pack_len)
device192drivers/scsi/sg.ccount=device->header.pack_len;
device194drivers/scsi/sg.cmemcpy_tofs(buf,device->buff,count-sizeof(struct sg_header));
device199drivers/scsi/sg.csg_free(device->buff,device->buff_len);
device200drivers/scsi/sg.cdevice->buff = NULL;
device201drivers/scsi/sg.cdevice->pending=0;
device202drivers/scsi/sg.cwake_up(&device->write_wait);
device209drivers/scsi/sg.cstruct scsi_generic *device=&scsi_generics[dev];
device210drivers/scsi/sg.cif (!device->pending)
device216drivers/scsi/sg.cmemcpy(device->header.sense_buffer, SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
device219drivers/scsi/sg.cdevice->header.result=EIO;
device222drivers/scsi/sg.cdevice->header.result=SCpnt->result;
device223drivers/scsi/sg.cdevice->complete=1;
device235drivers/scsi/sg.cstruct scsi_generic *device=&scsi_generics[dev];
device246drivers/scsi/sg.cwhile(device->pending)
device253drivers/scsi/sg.cinterruptible_sleep_on(&device->write_wait);
device257drivers/scsi/sg.cdevice->pending=1;
device258drivers/scsi/sg.cdevice->complete=0;
device259drivers/scsi/sg.cmemcpy_fromfs(&device->header,buf,sizeof(struct sg_header));
device261drivers/scsi/sg.cdevice->header.pack_len=count;
device263drivers/scsi/sg.cbsize=(device->header.pack_len>device->header.reply_len) ? device->header.pack_len : device->header.reply_len;
device269drivers/scsi/sg.cif ((bsize<0) || !(device->buff=sg_malloc(device->buff_len=bsize)))
device271drivers/scsi/sg.cdevice->pending=0;
device272drivers/scsi/sg.cwake_up(&device->write_wait);
device278drivers/scsi/sg.cif (!(SCpnt=allocate_device(NULL,device->device, !(filp->f_flags & O_NONBLOCK))))
device280drivers/scsi/sg.cdevice->pending=0;
device281drivers/scsi/sg.cwake_up(&device->write_wait);
device282drivers/scsi/sg.csg_free(device->buff,device->buff_len);
device283drivers/scsi/sg.cdevice->buff = NULL;
device294drivers/scsi/sg.cif (opcode >= 0xc0 && device->header.twelve_byte) size = 12;
device301drivers/scsi/sg.cdevice->pending=0;
device302drivers/scsi/sg.cwake_up(&device->write_wait);
device303drivers/scsi/sg.csg_free(device->buff,device->buff_len);
device304drivers/scsi/sg.cdevice->buff = NULL;
device310drivers/scsi/sg.cmemcpy_fromfs(device->buff,buf,device->header.pack_len-size-sizeof(struct sg_header));
device311drivers/scsi/sg.ccmnd[1]=(cmnd[1] & 0x1f) | (device->device->lun<<5);
device316drivers/scsi/sg.c(void *) device->buff,amt,
device317drivers/scsi/sg.csg_command_done,device->timeout,SG_DEFAULT_RETRIES);
device392drivers/scsi/sg.cif(!gpnt->device) break;
device396drivers/scsi/sg.cscsi_generics[i].device=SDp;
device417drivers/scsi/sg.cif(gpnt->device == SDp) {
device418drivers/scsi/sg.cgpnt->device = NULL;
device67drivers/scsi/sr.cif(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
device69drivers/scsi/sr.cif (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
device70drivers/scsi/sr.c(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--;
device120drivers/scsi/sr.cscsi_CDs[target].device->changed = 1;
device125drivers/scsi/sr.cretval = scsi_CDs[target].device->changed;
device127drivers/scsi/sr.cscsi_CDs[target].device->changed = 0;
device235drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->changed = 1;
device271drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->host->host_no, 
device272drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->id,
device273drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.dev)].device->lun,
device324drivers/scsi/sr.cif (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) {
device336drivers/scsi/sr.cswitch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
device348drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device383drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device390drivers/scsi/sr.cif (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device420drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device445drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device475drivers/scsi/sr.c!scsi_CDs[MINOR(inode->i_rdev)].device) return -ENXIO;   /* No such device */
device482drivers/scsi/sr.cif(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
device484drivers/scsi/sr.cif (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
device485drivers/scsi/sr.c(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++;
device525drivers/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(CURRENT->dev))].device, 0); 
device544drivers/scsi/sr.cscsi_CDs[DEVICE_NR(MINOR(req->dev))].device);
device603drivers/scsi/sr.cif (scsi_CDs[dev].device->changed)
device879drivers/scsi/sr.cif(!cpnt->device) break;
device884drivers/scsi/sr.cscsi_CDs[i].device = SDp;
device911drivers/scsi/sr.cSCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
device916drivers/scsi/sr.ccmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
device946drivers/scsi/sr.cwake_up(&SCpnt->device->device_wait); 
device1034drivers/scsi/sr.cif(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
device1050drivers/scsi/sr.cif(cpnt->device == SDp) {
device1062drivers/scsi/sr.ccpnt->device = NULL;
device26drivers/scsi/sr.hScsi_Device    *device;    
device44drivers/scsi/sr_ioctl.cSCpnt = allocate_device(NULL, scsi_CDs[target].device, 1);
device64drivers/scsi/sr_ioctl.cscsi_CDs[target].device->changed = 1;
device75drivers/scsi/sr_ioctl.cscsi_CDs[target].device->host->host_no, 
device76drivers/scsi/sr_ioctl.cscsi_CDs[target].device->id,
device77drivers/scsi/sr_ioctl.cscsi_CDs[target].device->lun,
device88drivers/scsi/sr_ioctl.cwake_up(&SCpnt->device->device_wait);
device103drivers/scsi/sr_ioctl.c!scsi_CDs[target].device) return -ENXIO;
device111drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device123drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device139drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device159drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device180drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device214drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device247drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
device256drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
device264drivers/scsi/sr_ioctl.cif (scsi_CDs[target].device -> access_count == 1)
device268drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 1;
device273drivers/scsi/sr_ioctl.cscsi_CDs[target].device -> changed = 1;
device288drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
device304drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
device332drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 0x10;    /* Params are SCSI-2 */
device349drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device430drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
device260drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device306drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device415drivers/scsi/st.cif (dev >= st_template.dev_max || !scsi_tapes[dev].device)
device447drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device499drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device500drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)++;
device612drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device613drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)++;
device645drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device694drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device695drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)--;
device774drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device986drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device1466drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2) {
device1547drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device1788drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device1792drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2) {
device1818drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2)
device1836drivers/scsi/st.creturn scsi_ioctl(STp->device, cmd_in, (void *) arg);
device1886drivers/scsi/st.cif(!tpnt->device) break;
device1890drivers/scsi/st.cscsi_tapes[i].device = SDp;
device1941drivers/scsi/st.cSTp->device = NULL;
device1993drivers/scsi/st.cif(tpnt->device == SDp) {
device1994drivers/scsi/st.ctpnt->device = NULL;
device27drivers/scsi/st.hScsi_Device* device;
device883drivers/scsi/u14-34f.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
device888drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
device894drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
device899drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
device909drivers/scsi/u14-34f.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
device934drivers/scsi/u14-34f.cif (SCpnt->device->type != TYPE_TAPE)
device704drivers/scsi/ultrastor.cmy_mscp->ca = SCpnt->device->type != TYPE_TAPE;
device1514drivers/sound/sequencer.cdev = inf.device;
device1532drivers/sound/sequencer.cdev = inf.device;
device1550drivers/sound/sequencer.cdev = inf->device;
device1584drivers/sound/sequencer.cdev = inf->device;
device115fs/msdos/fat.ccache[count].device = 0;
device132fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
device153fs/msdos/fat.cif (walk->device)
device154fs/msdos/fat.cprintk("<%d,%d>(%d,%d) ",walk->device,walk->ino,
device172fs/msdos/fat.cif (inode->i_dev == walk->device && walk->ino == inode->i_ino &&
device189fs/msdos/fat.cwalk->device = inode->i_dev;
device210fs/msdos/fat.cif (walk->device == inode->i_dev && walk->ino == inode->i_ino)
device211fs/msdos/fat.cwalk->device = 0;
device215fs/msdos/fat.cvoid cache_inval_dev(int device)
device220fs/msdos/fat.cif (walk->device == device) walk->device = 0;
device492fs/proc/array.c(*p)->tty ? (*p)->tty->device : 0,
device31include/linux/etherdevice.hextern int    eth_header(unsigned char *buff, struct device *dev,
device35include/linux/etherdevice.hextern int    eth_rebuild_header(void *buff, struct device *dev,
device37include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
device73include/linux/fd.hunsigned int device,head,track;
device44include/linux/igmp.hstruct device *multidev[IP_MAX_MEMBERSHIPS];
device49include/linux/igmp.hstruct device *interface;
device60include/linux/igmp.hextern int igmp_rcv(struct sk_buff *, struct device *, struct options *, unsigned long, unsigned short,
device62include/linux/igmp.hextern void ip_mc_drop_device(struct device *dev); 
device63include/linux/igmp.hextern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
device64include/linux/igmp.hextern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
device132include/linux/ip_fw.hextern int ip_acct_cnt(struct iphdr *, struct device *, struct ip_fw *);
device135include/linux/ip_fw.hextern int ip_fw_chk(struct iphdr *, struct device *rif,struct ip_fw *, int);
device91include/linux/msdos_fs.hint device; /* device number. 0 means unused. */
device140include/linux/msdos_fs.hvoid cache_inval_dev(int device);
device83include/linux/netdevice.hstruct device      *next;
device86include/linux/netdevice.hint        (*init)(struct device *dev);
device93include/linux/netdevice.hstruct enet_statistics* (*get_stats)(struct device *dev);
device131include/linux/netdevice.hstruct device      *slave;  /* Slave device */
device138include/linux/netdevice.hint        (*open)(struct device *dev);
device139include/linux/netdevice.hint        (*stop)(struct device *dev);
device141include/linux/netdevice.hstruct device *dev);
device143include/linux/netdevice.hstruct device *dev,
device149include/linux/netdevice.hint        (*rebuild_header)(void *eth, struct device *dev,
device152include/linux/netdevice.hstruct device *dev);
device154include/linux/netdevice.hvoid        (*set_multicast_list)(struct device *dev,
device157include/linux/netdevice.hint        (*set_mac_address)(struct device *dev, void *addr);
device159include/linux/netdevice.hint        (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
device161include/linux/netdevice.hint        (*set_config)(struct device *dev, struct ifmap *map);
device168include/linux/netdevice.hstruct device *  dev;
device169include/linux/netdevice.hint      (*func) (struct sk_buff *, struct device *,
device185include/linux/netdevice.hextern struct device  loopback_dev;
device186include/linux/netdevice.hextern struct device  *dev_base;
device192include/linux/netdevice.hextern struct device  *ip_dev_check(unsigned long daddr);
device198include/linux/netdevice.hextern struct device  *dev_get(char *name);
device199include/linux/netdevice.hextern int    dev_open(struct device *dev);
device200include/linux/netdevice.hextern int    dev_close(struct device *dev);
device201include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
device207include/linux/netdevice.hstruct device * dev);
device211include/linux/netdevice.hextern void    dev_tint(struct device *dev);
device219include/linux/netdevice.hextern void    ether_setup(struct device *dev);
device220include/linux/netdevice.hextern int    ether_config(struct device *dev, struct ifmap *map);
device222include/linux/netdevice.hextern int    register_netdev(struct device *dev);
device223include/linux/netdevice.hextern void    unregister_netdev(struct device *dev);
device227include/linux/netdevice.hextern void    dev_mc_upload(struct device *dev);
device228include/linux/netdevice.hextern void     dev_mc_delete(struct device *dev, void *addr, int alen, int all);
device229include/linux/netdevice.hextern void    dev_mc_add(struct device *dev, void *addr, int alen, int newonly);
device230include/linux/netdevice.hextern void    dev_mc_discard(struct device *dev);
device232include/linux/netdevice.hextern void    ip_mc_allhost(struct device *dev);
device28include/linux/pci.h#define PCI_CONFIG1_TUPPLE(bus, device, function, register)  \
device30include/linux/pci.h((device) << 11) & 0xf800 | ((function) << 8) & 0x700 | \
device190include/linux/ppp.hstruct device    *dev;    /* easy for intr handling  */
device266include/linux/sched.hunsigned long flags, const char *device);
device49include/linux/skbuff.hstruct device      *dev;
device252include/linux/soundcard.hint device;
device473include/linux/soundcard.hshort    device;    /*  Synth# (0-4)  */
device480include/linux/soundcard.hint  device;    /* 0-N. INITIALIZE BEFORE CALLING */
device512include/linux/soundcard.hint    device;    /* 0-N. INITIALIZE BEFORE CALLING */
device821include/linux/soundcard.h_pm_info.device=dev, _pm_info.data.data8[0]=pgm, \
device825include/linux/soundcard.h_pm_info.device=dev, memcpy(_pm_info.data.data8, pgm, 128), \
device950include/linux/soundcard.h#define SEQ_MIDIOUT(device, byte)  {_SEQ_NEEDBUF(4);\
device953include/linux/soundcard.h_seqbuf[_seqbufptr+2] = (device);\
device201include/linux/tty.hdev_t  device;
device287include/linux/tty.hextern int tty_paranoia_check(struct tty_struct *tty, dev_t device,
device89net/inet/arp.cstruct device      *dev;      /* Device the entry is tied to   */
device256net/inet/arp.cstruct device *dev=ptr;
device296net/inet/arp.cstruct device *dev, unsigned long src_ip, 
device391net/inet/arp.cstruct device *dev = entry->dev;
device535net/inet/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device797net/inet/arp.cint arp_find(unsigned char *haddr, unsigned long paddr, struct device *dev,
device7net/inet/arp.hextern void  arp_device_down(struct device *dev);
device8net/inet/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
device11net/inet/arp.hstruct device *dev, unsigned long saddr, struct sk_buff *skb);
device15net/inet/arp.hstruct device *dev, unsigned long src_ip, 
device9net/inet/datalink.hint  (*rcvfunc)(struct sk_buff *, struct device *, 
device165net/inet/dev.cstruct device *dev_get(char *name)
device167net/inet/dev.cstruct device *dev;
device182net/inet/dev.cint dev_open(struct device *dev)
device219net/inet/dev.cint dev_close(struct device *dev)
device300net/inet/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
device501net/inet/dev.cint dev_rint(unsigned char *buff, long len, int flags, struct device *dev)
device580net/inet/dev.cstruct device *dev;
device769net/inet/dev.cvoid dev_tint(struct device *dev)
device822net/inet/dev.cstruct device *dev;
device897net/inet/dev.cstatic int sprintf_stats(char *buffer, struct device *dev)
device932net/inet/dev.cstruct device *dev;
device989net/inet/dev.cstruct device *dev;
device1267net/inet/dev.cstruct device *slave=dev_get(ifr.ifr_slave);
device1419net/inet/dev.cstruct device *dev, *dev2;
device60net/inet/dev_mcast.cvoid dev_mc_upload(struct device *dev)
device108net/inet/dev_mcast.cvoid dev_mc_delete(struct device *dev, void *addr, int alen, int all)
device131net/inet/dev_mcast.cvoid dev_mc_add(struct device *dev, void *addr, int alen, int newonly)
device159net/inet/dev_mcast.cvoid dev_mc_discard(struct device *dev)
device78net/inet/devinet.cstruct device *dev;
device171net/inet/devinet.cstruct device *dev;
device188net/inet/devinet.cstruct device * ip_dev_check(unsigned long addr)
device190net/inet/devinet.cstruct device *dev;
device54net/inet/eth.cstruct device *d = dev_base;
device84net/inet/eth.cint eth_header(unsigned char *buff, struct device *dev, unsigned short type,
device135net/inet/eth.cint eth_rebuild_header(void *buff, struct device *dev, unsigned long dst,
device168net/inet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
device27net/inet/eth.hextern int    eth_header(unsigned char *buff, struct device *dev,
device30net/inet/eth.hextern int    eth_rebuild_header(void *buff, struct device *dev);
device32net/inet/eth.hstruct device *dev);
device33net/inet/eth.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
device99net/inet/icmp.cvoid icmp_send(struct sk_buff *skb_in, int type, int code, unsigned long info, struct device *dev)
device106net/inet/icmp.cstruct device *ndev=NULL;  /* Make this =dev to force replies on the same interface */
device344net/inet/icmp.cstruct device *dev, unsigned long source)
device408net/inet/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
device414net/inet/icmp.cstruct device *ndev=NULL;
device475net/inet/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
device483net/inet/icmp.cstruct device *ndev=NULL;
device564net/inet/icmp.cstatic void icmp_info(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
device577net/inet/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev,
device584net/inet/icmp.cstruct device *ndev=NULL;
device646net/inet/icmp.cint icmp_rcv(struct sk_buff *skb1, struct device *dev, struct options *opt,
device29net/inet/icmp.hunsigned long info, struct device *dev);
device30net/inet/icmp.hextern int  icmp_rcv(struct sk_buff *skb1, struct device *dev,
device76net/inet/igmp.cstatic void igmp_send_report(struct device *dev, unsigned long address, int type)
device118net/inet/igmp.cstatic void igmp_heard_report(struct device *dev, unsigned long address)
device126net/inet/igmp.cstatic void igmp_heard_query(struct device *dev)
device155net/inet/igmp.cvoid ip_mc_filter_add(struct device *dev, unsigned long addr)
device168net/inet/igmp.cvoid ip_mc_filter_del(struct device *dev, unsigned long addr)
device193net/inet/igmp.cint igmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device223net/inet/igmp.cstatic void ip_mc_inc_group(struct device *dev, unsigned long addr)
device249net/inet/igmp.cstatic void ip_mc_dec_group(struct device *dev, unsigned long addr)
device273net/inet/igmp.cvoid ip_mc_drop_device(struct device *dev)
device289net/inet/igmp.cvoid ip_mc_allhost(struct device *dev)
device311net/inet/igmp.cint ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
device345net/inet/igmp.cint ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
device195net/inet/ip.cstatic int ip_send(struct sk_buff *skb, unsigned long daddr, int len, struct device *dev, unsigned long saddr)
device227net/inet/ip.cstruct device **dev, int type, struct options *opt, int len, int tos, int ttl)
device711net/inet/ip.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
device893net/inet/ip.cstatic struct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
device1085net/inet/ip.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
device1257net/inet/ip.cstatic void ip_forward(struct sk_buff *skb, struct device *dev, int is_frag)
device1259net/inet/ip.cstruct device *dev2;  /* Output device */
device1457net/inet/ip.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device1741net/inet/ip.cstatic void ip_loopback(struct device *old_dev, struct sk_buff *skb)
device1743net/inet/ip.cextern struct device loopback_dev;
device1744net/inet/ip.cstruct device *dev=&loopback_dev;
device1783net/inet/ip.cvoid ip_queue_xmit(struct sock *sk, struct device *dev,
device1997net/inet/ip.cstruct device *dev;
device2104net/inet/ip.cstruct device *dev=NULL;
device2161net/inet/ip.cstruct device *dev=NULL;
device2221net/inet/ip.cstruct device *dev=NULL;
device42net/inet/ip.hextern void    ip_mc_dropdevice(struct device *dev);
device70net/inet/ip.hstruct device *dev;    /* Device - for icmp replies */
device83net/inet/ip.hstruct device **dev, int type,
device87net/inet/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
device92net/inet/ip.hstruct device *dev, struct sk_buff *skb,
device141net/inet/ip_fw.cint ip_fw_chk(struct iphdr *ip, struct device *rif, struct ip_fw *chain, int policy)
device689net/inet/ip_fw.cint ip_acct_cnt(struct iphdr *iph, struct device *dev, struct ip_fw *f)
device196net/inet/ipx.cipxitf_find_using_phys(struct device *dev, unsigned short datalink)
device299net/inet/ipx.cstruct device *dev = ptr;
device464net/inet/ipx.cstruct device  *dev = intrfc->if_dev;
device651net/inet/ipx.cstruct device  *dev;
device738net/inet/ipx.cstruct device  *dev = NULL;
device766net/inet/ipx.cipxitf_auto_create(struct device *dev, unsigned short dlink_type)
device840net/inet/ipx.cstruct device *dev;
device1617net/inet/ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device48net/inet/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
device49net/inet/ipx.hextern void ipxrtr_device_down(struct device *dev);
device57net/inet/ipx.hstruct device  *if_dev;
device23net/inet/p8022.cp8022_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device43net/inet/p8022.cstruct device  *dev = skb->dev;
device77net/inet/p8022.cregister_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *))
device1net/inet/p8022.hstruct datalink_proto *register_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
device11net/inet/p8023.cstruct device  *dev = skb->dev;
device71net/inet/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
device145net/inet/packet.cstruct device *dev;
device11net/inet/pe2.cstruct device  *dev = skb->dev;
device31net/inet/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
device35net/inet/protocol.hint      (*frag_handler)(struct sk_buff *skb, struct device *dev,
device40net/inet/psnap.cint snap_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device77net/inet/psnap.cstruct device  *dev = skb->dev;
device101net/inet/psnap.cstruct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *))
device1net/inet/psnap.hstruct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
device73net/inet/rarp.cstruct device      *dev;              /* Device the entry is tied to */
device143net/inet/rarp.cint rarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device7net/inet/rarp.hstruct device *dev, 
device97net/inet/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, long saddr, long daddr)
device130net/inet/raw.cstruct device *dev=NULL;
device31net/inet/raw.hextern int   raw_rcv(struct sock *, struct sk_buff *, struct device *, 
device113net/inet/route.cvoid ip_rt_flush(struct device *dev)
device158net/inet/route.cstatic unsigned long guess_mask(unsigned long dst, struct device * dev)
device175net/inet/route.cstatic inline struct device * get_gw_dev(unsigned long gw)
device204net/inet/route.cunsigned long gw, struct device *dev, unsigned short mtu, unsigned long window)
device367net/inet/route.cstruct device * dev = NULL;
device410net/inet/route.cstruct device *dev2;
device41net/inet/route.hstruct device    *rt_dev;
device45net/inet/route.hextern void    ip_rt_flush(struct device *dev);
device47net/inet/route.hunsigned long gw, struct device *dev, unsigned short mss, unsigned long window);
device229net/inet/sock.hstruct device **dev, int type,
device235net/inet/sock.hstruct device *dev, struct sk_buff *skb,
device240net/inet/sock.hint      (*rcv)(struct sk_buff *buff, struct device *dev,
device405net/inet/tcp.cstruct device *dev;
device1299net/inet/tcp.cstruct device *dev = NULL;
device1446net/inet/tcp.cstruct device *dev = NULL;
device1793net/inet/tcp.cstruct device *dev = NULL;
device2306net/inet/tcp.cstruct device *dev=NULL;
device2491net/inet/tcp.cstruct proto *prot, struct options *opt, struct device *dev, int tos, int ttl)
device2496net/inet/tcp.cstruct device *ndev=NULL;
device2672net/inet/tcp.cstruct options *opt, struct device *dev, unsigned long seq)
device2679net/inet/tcp.cstruct device *ndev=NULL;
device4256net/inet/tcp.cstruct device *dev=NULL;
device4416net/inet/tcp.cstruct options *opt, unsigned long saddr, struct device *dev)
device4503net/inet/tcp.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device4903net/inet/tcp.cstruct device *dev=NULL;
device127net/inet/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
device83net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
device255net/inet/udp.cstruct device *dev;
device567net/inet/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device667net/inet/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
device43net/inet/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,