taglinefilesource code
device95arch/alpha/kernel/apecs.cint device = device_fn >> 3;
device99arch/alpha/kernel/apecs.cif (device > 20) {
device100arch/alpha/kernel/apecs.cDBG(("mk_conf_addr: device (%d) > 20, returning -1\n", device));
device357arch/alpha/kernel/bios32.cif (dev->vendor == vendor && dev->device == device_id) {
device672arch/alpha/kernel/bios32.cdev->vendor, dev->device, PCI_SLOT(dev->devfn));
device96arch/alpha/kernel/lca.cint device = device_fn >> 3;
device101arch/alpha/kernel/lca.cif (device > 12) {
device106arch/alpha/kernel/lca.caddr = (1 << (11 + device)) | (func << 8) | where;
device1940drivers/block/floppy.cstatic void set_floppy(kdev_t device)
device1942drivers/block/floppy.cif (TYPE(device))
device1943drivers/block/floppy.cfloppy = TYPE(device) + floppy_type;
device1945drivers/block/floppy.cfloppy = current_type[ DRIVE(device) ];
device2045drivers/block/floppy.cstatic int do_format(kdev_t device, struct format_descr *tmp_format_req)
device2048drivers/block/floppy.cint drive=DRIVE(device);
device2051drivers/block/floppy.cset_floppy(device);
device2592drivers/block/floppy.ckdev_t device;
device2615drivers/block/floppy.cdevice = CURRENT->rq_dev;
device2616drivers/block/floppy.cset_fdc(DRIVE(device));
device2619drivers/block/floppy.cset_floppy(device);
device3025drivers/block/floppy.cint drive, int type, kdev_t device)
device3080drivers/block/floppy.cinvalidate_drive(device);
device3173drivers/block/floppy.ckdev_t device;
device3184drivers/block/floppy.cdevice = inode->i_rdev;
device3186drivers/block/floppy.cRO_IOCTLS(device,param);
device3188drivers/block/floppy.ctype = TYPE(device);
device3189drivers/block/floppy.cdrive = DRIVE(device);
device3219drivers/block/floppy.creturn invalidate_drive(device);
device3223drivers/block/floppy.cdrive, type, device);
device3253drivers/block/floppy.creturn do_format(device, &inparam.f);
device3257drivers/block/floppy.creturn invalidate_drive(device);
device3296drivers/block/floppy.cset_floppy(device);
device2954drivers/block/ide.cstatic void ide_probe_pci (unsigned short vendor, unsigned short device, ide_pci_init_proc_t *init, int func_adj)
device2962drivers/block/ide.cfor (index = 0; !pcibios_find_device (vendor, device, index, &bus, &fn); ++index) {
device261drivers/block/rd.cidentify_ramdisk_image(kdev_t device, struct file *fp, int start_block)
device335drivers/block/rd.cif ((nblocks > 0) && blk_size[MAJOR(device)]) {
device336drivers/block/rd.cmax_blocks = blk_size[MAJOR(device)][MINOR(device)];
device358drivers/block/rd.ckdev_t device, ram_device;
device367drivers/block/rd.cdevice = ROOT_DEV;
device370drivers/block/rd.cif (MAJOR(device) != FLOPPY_MAJOR) return;
device380drivers/block/rd.cinode.i_rdev = device;
device396drivers/block/rd.cnblocks = identify_ramdisk_image(device, &infile, rd_image_start);
device236drivers/char/apm_bios.c#define APM_ENABLE_POWER_MANAGEMENT(device, error) \
device239drivers/char/apm_bios.c: "a" (0x5308), "b" (device), "c" (1) \
device261drivers/char/apm_bios.c#define APM_ENGAGE_POWER_MANAGEMENT(device, error) \
device264drivers/char/apm_bios.c: "a" (0x530f), "b" (device), "c" (1) \
device441drivers/char/apm_bios.cstatic int apm_engage_power_management(u_short device)
device445drivers/char/apm_bios.cAPM_ENGAGE_POWER_MANAGEMENT(device, error);
device1346drivers/char/console.cconsole_num = MINOR(tty->device) - (tty->driver.minor_start);
device1361drivers/char/console.cconsole_num = MINOR(tty->device) - (tty->driver.minor_start);
device2252drivers/char/console.cidx = MINOR(tty->device) - tty->driver.minor_start;
device429drivers/char/cyclades.ckdev_t device, const char *routine)
device440drivers/char/cyclades.cprintk(badinfo, kdevname(device), routine);
device446drivers/char/cyclades.cprintk(badrange, kdevname(device), routine);
device451drivers/char/cyclades.cprintk(badmagic, kdevname(device), routine);
device533drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_stop"))
device565drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_start"))
device1551drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_put_char"))
device1582drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_flush_chars"))
device1622drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_write")){
device1676drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_write_room"))
device1694drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_chars_in_buffer"))
device1711drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_flush_buffer"))
device1743drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_nthrottle")){
device1785drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_nthrottle")){
device2321drivers/char/cyclades.c|| serial_paranoia_check(info, tty->device, "cy_close")){
device2414drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_hangup"))
device2594drivers/char/cyclades.cline = MINOR(tty->device) - tty->driver.minor_start;
device2605drivers/char/cyclades.cif (serial_paranoia_check(info, tty->device, "cy_open")){
device860drivers/char/istallion.cprintk("stli_open(tty=%x,filp=%x): device=%x\n", (int) tty, (int) filp, tty->device);
device863drivers/char/istallion.cminordev = MINOR(tty->device);
device191drivers/char/pty.cline = MINOR(tty->device) - tty->driver.minor_start;
device505drivers/char/scc.cprintk("z8530drv: %s: can't allocate memory for rx buffer pool", kdevname(scc->tty->device));
device530drivers/char/scc.cprintk("z8530drv: %s: can't allocate memory for tx buffer pool", kdevname(scc->tty->device));
device669drivers/char/scc.cprintk("z8530drv: scc_get_buffer(%s): tx buffer pool empty\n", kdevname(scc->tty->device));
device685drivers/char/scc.cprintk("z8530drv: scc_get_buffer(%s): rx buffer pool empty\n", kdevname(scc->tty->device));
device1544drivers/char/scc.ckdevname(scc->tty->device));
device1926drivers/char/scc.cstatic inline int scc_paranoia_check(struct scc_channel *scc, kdev_t device,
device1938drivers/char/scc.cprintk(badinfo, kdevname(device), routine);
device1944drivers/char/scc.cprintk(badmagic, kdevname(device), routine);
device1960drivers/char/scc.cchan = MINOR(tty->device) - tty->driver.minor_start;
device1980drivers/char/scc.ckdevname(tty->device));
device2106drivers/char/scc.ckdevname(tty->device));
device2473drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_write"))
device2533drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_put_char"))
device2544drivers/char/scc.cscc_paranoia_check(scc, tty->device, "scc_flush_chars"); /* just to annoy the user... */
device2554drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_write_room"))
device2574drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_flush_buffer"))
device2586drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_throttle"))
device2590drivers/char/scc.cprintk("scc: scc_throttle() called for device %d\n", MINOR(tty->device));
device2603drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_unthrottle"))
device2607drivers/char/scc.cprintk("scc: scc_unthrottle() called for device %d\n", MINOR(tty->device));
device2620drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_start"))
device2630drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_stop"))
device2641drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_set_termios"))
device2655drivers/char/scc.cif (scc_paranoia_check(scc, tty->device, "scc_set_ldisc"))
device209drivers/char/serial.ckdev_t device, const char *routine)
device218drivers/char/serial.cprintk(badinfo, kdevname(device), routine);
device222drivers/char/serial.cprintk(badmagic, kdevname(device), routine);
device302drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_stop"))
device318drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_start"))
device1282drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_put_char"))
device1305drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_flush_chars"))
device1325drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_write"))
device1371drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_write_room"))
device1383drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer"))
device1392drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_flush_buffer"))
device1421drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_throttle"))
device1444drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_unthrottle"))
device1875drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_ioctl"))
device2080drivers/char/serial.cif (!info || serial_paranoia_check(info, tty->device, "rs_close"))
device2191drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_hangup"))
device2352drivers/char/serial.cline = MINOR(tty->device) - tty->driver.minor_start;
device2356drivers/char/serial.cif (serial_paranoia_check(info, tty->device, "rs_open"))
device625drivers/char/stallion.cprintk("stl_open(tty=%x,filp=%x): device=%x\n", (int) tty, (int) filp, tty->device);
device628drivers/char/stallion.cminordev = MINOR(tty->device);
device138drivers/char/tty_io.cMINOR(tty->device) - tty->driver.minor_start +
device152drivers/char/tty_io.cinline int tty_paranoia_check(struct tty_struct *tty, kdev_t device,
device162drivers/char/tty_io.cprintk(badtty, kdevname(device), routine);
device166drivers/char/tty_io.cprintk(badmagic, kdevname(device), routine);
device192drivers/char/tty_io.ckdevname(tty->device), tty->count, count, routine);
device272drivers/char/tty_io.cstruct tty_driver *get_tty_driver(kdev_t device)
device277drivers/char/tty_io.cminor = MINOR(device);
device278drivers/char/tty_io.cmajor = MAJOR(device);
device796drivers/char/tty_io.cstatic int init_dev(kdev_t device, struct tty_struct **ret_tty)
device805drivers/char/tty_io.cdriver = get_tty_driver(device);
device809drivers/char/tty_io.cidx = MINOR(device) - driver->minor_start;
device831drivers/char/tty_io.ctty->device = device;
device866drivers/char/tty_io.co_tty->device = o_device;
device992drivers/char/tty_io.cidx = MINOR(tty->device) - tty->driver.minor_start;
device996drivers/char/tty_io.ckdevname(tty->device));
device1001drivers/char/tty_io.cidx, kdevname(tty->device));
device1007drivers/char/tty_io.cidx, kdevname(tty->device));
device1013drivers/char/tty_io.cidx, kdevname(tty->device));
device1032drivers/char/tty_io.cidx, kdevname(tty->device));
device1038drivers/char/tty_io.cidx, kdevname(tty->device));
device1044drivers/char/tty_io.cidx, kdevname(tty->device));
device1170drivers/char/tty_io.ckdev_t device;
device1174drivers/char/tty_io.cdevice = inode->i_rdev;
device1175drivers/char/tty_io.cif (device == TTY_DEV) {
device1178drivers/char/tty_io.cdevice = current->tty->device;
device1181drivers/char/tty_io.cif (device == CONSOLE_DEV) {
device1182drivers/char/tty_io.cdevice = MKDEV(TTY_MAJOR, fg_console+1);
device1185drivers/char/tty_io.cminor = MINOR(device);
device1187drivers/char/tty_io.cretval = init_dev(device, &tty);
device125drivers/char/vt.cif ( p->tty && MAJOR(p->tty->device) == TTY_MAJOR &&
device126drivers/char/vt.cMINOR(p->tty->device) <= MAX_NR_CONSOLES && MINOR(p->tty->device) )
device119drivers/net/3c501.cint el1_probe(struct device *dev);
device120drivers/net/3c501.cstatic int  el1_probe1(struct device *dev, int ioaddr);
device121drivers/net/3c501.cstatic int  el_open(struct device *dev);
device122drivers/net/3c501.cstatic int  el_start_xmit(struct sk_buff *skb, struct device *dev);
device124drivers/net/3c501.cstatic void el_receive(struct device *dev);
device125drivers/net/3c501.cstatic void el_reset(struct device *dev);
device126drivers/net/3c501.cstatic int  el1_close(struct device *dev);
device127drivers/net/3c501.cstatic struct enet_statistics *el1_get_stats(struct device *dev);
device128drivers/net/3c501.cstatic void set_multicast_list(struct device *dev);
device212drivers/net/3c501.cint el1_probe(struct device *dev)
device239drivers/net/3c501.cstatic int el1_probe1(struct device *dev, int ioaddr)
device357drivers/net/3c501.cstatic int el_open(struct device *dev)
device377drivers/net/3c501.cstatic int el_start_xmit(struct sk_buff *skb, struct device *dev)
device494drivers/net/3c501.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device674drivers/net/3c501.cstatic void el_receive(struct device *dev)
device729drivers/net/3c501.cstatic void  el_reset(struct device *dev)
device754drivers/net/3c501.cstatic int el1_close(struct device *dev)
device776drivers/net/3c501.cstatic struct enet_statistics *el1_get_stats(struct device *dev)
device787drivers/net/3c501.cstatic void set_multicast_list(struct device *dev)
device812drivers/net/3c501.cstatic struct device dev_3c501 = 
device52drivers/net/3c503.cint el2_probe(struct device *dev);
device53drivers/net/3c503.cint el2_pio_probe(struct device *dev);
device54drivers/net/3c503.cint el2_probe1(struct device *dev, int ioaddr);
device71drivers/net/3c503.cstatic int el2_open(struct device *dev);
device72drivers/net/3c503.cstatic int el2_close(struct device *dev);
device73drivers/net/3c503.cstatic void el2_reset_8390(struct device *dev);
device74drivers/net/3c503.cstatic void el2_init_card(struct device *dev);
device75drivers/net/3c503.cstatic void el2_block_output(struct device *dev, int count,
device77drivers/net/3c503.cstatic void el2_block_input(struct device *dev, int count, struct sk_buff *skb,
device79drivers/net/3c503.cstatic void el2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device91drivers/net/3c503.cel2_probe(struct device *dev)
device126drivers/net/3c503.cel2_pio_probe(struct device *dev)
device152drivers/net/3c503.cel2_probe1(struct device *dev, int ioaddr)
device329drivers/net/3c503.cel2_open(struct device *dev)
device365drivers/net/3c503.cel2_close(struct device *dev)
device382drivers/net/3c503.cel2_reset_8390(struct device *dev)
device398drivers/net/3c503.cel2_init_card(struct device *dev)
device428drivers/net/3c503.cel2_block_output(struct device *dev, int count,
device474drivers/net/3c503.cel2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device513drivers/net/3c503.cel2_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device561drivers/net/3c503.cstatic struct device dev_el2[MAX_EL2_CARDS] = {
device582drivers/net/3c503.cstruct device *dev = &dev_el2[this_dev];
device609drivers/net/3c503.cstruct device *dev = &dev_el2[this_dev];
device261drivers/net/3c505.cstatic int start_receive (struct device *, pcb_struct *);
device262drivers/net/3c505.cstatic void adapter_hard_reset (struct device *);
device265drivers/net/3c505.cadapter_reset (struct device * dev)
device322drivers/net/3c505.csend_pcb (struct device * dev, pcb_struct * pcb)
device400drivers/net/3c505.creceive_pcb (struct device * dev, pcb_struct * pcb)
device473drivers/net/3c505.cadapter_hard_reset (struct device * dev)
device525drivers/net/3c505.cstart_receive (struct device * dev, pcb_struct * tx_pcb)
device551drivers/net/3c505.creceive_packet (struct device * dev, int len)
device642drivers/net/3c505.cstruct device *dev;
device814drivers/net/3c505.celp_open (struct device *dev)
device942drivers/net/3c505.csend_packet (struct device * dev, unsigned char * ptr, int len)
device1005drivers/net/3c505.celp_start_xmit (struct sk_buff *skb, struct device *dev)
device1079drivers/net/3c505.celp_get_stats (struct device *dev)
device1118drivers/net/3c505.celp_close (struct device *dev)
device1176drivers/net/3c505.celp_set_mc_list (struct device *dev)
device1241drivers/net/3c505.celp_init (struct device *dev)
device1281drivers/net/3c505.celp_sense (struct device * dev)
device1362drivers/net/3c505.celp_autodetect (struct device * dev)
device1390drivers/net/3c505.celplus_probe (struct device *dev)
device1482drivers/net/3c505.cstatic struct device dev_3c505 = {
device278drivers/net/3c507.cextern int el16_probe(struct device *dev);  /* Called from Space.c */
device280drivers/net/3c507.cstatic int  el16_probe1(struct device *dev, int ioaddr);
device281drivers/net/3c507.cstatic int  el16_open(struct device *dev);
device282drivers/net/3c507.cstatic int  el16_send_packet(struct sk_buff *skb, struct device *dev);
device284drivers/net/3c507.cstatic void el16_rx(struct device *dev);
device285drivers/net/3c507.cstatic int  el16_close(struct device *dev);
device286drivers/net/3c507.cstatic struct enet_statistics *el16_get_stats(struct device *dev);
device288drivers/net/3c507.cstatic void hardware_send_packet(struct device *dev, void *buf, short length);
device289drivers/net/3c507.cvoid init_82586_mem(struct device *dev);
device304drivers/net/3c507.cel16_probe(struct device *dev)
device325drivers/net/3c507.cint el16_probe1(struct device *dev, int ioaddr)
device434drivers/net/3c507.cel16_open(struct device *dev)
device451drivers/net/3c507.cel16_send_packet(struct sk_buff *skb, struct device *dev)
device518drivers/net/3c507.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device592drivers/net/3c507.cstatic void init_rx_bufs(struct device *);
device616drivers/net/3c507.cel16_close(struct device *dev)
device646drivers/net/3c507.cel16_get_stats(struct device *dev)
device657drivers/net/3c507.cinit_rx_bufs(struct device *dev)
device703drivers/net/3c507.cinit_82586_mem(struct device *dev)
device762drivers/net/3c507.chardware_send_packet(struct device *dev, void *buf, short length)
device808drivers/net/3c507.cel16_rx(struct device *dev)
device879drivers/net/3c507.cstatic struct device dev_3c507 = {
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);
device110drivers/net/3c509.cstatic void set_multicast_list(struct device *dev);
device114drivers/net/3c509.cint el3_probe(struct device *dev)
device306drivers/net/3c509.cel3_open(struct device *dev)
device382drivers/net/3c509.cel3_start_xmit(struct sk_buff *skb, struct device *dev)
device469drivers/net/3c509.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device527drivers/net/3c509.cel3_get_stats(struct device *dev)
device544drivers/net/3c509.cstatic void update_stats(int ioaddr, struct device *dev)
device573drivers/net/3c509.cel3_rx(struct device *dev)
device633drivers/net/3c509.cstatic void set_multicast_list(struct device *dev)
device657drivers/net/3c509.cel3_close(struct device *dev)
device699drivers/net/3c509.cstatic struct device dev_3c509 = {
device218drivers/net/3c59x.cstruct device *next_module;
device232drivers/net/3c59x.cstatic int vortex_scan(struct device *dev);
device233drivers/net/3c59x.cstatic int vortex_found_device(struct device *dev, int ioaddr, int irq,
device235drivers/net/3c59x.cstatic int vortex_probe1(struct device *dev);
device236drivers/net/3c59x.cstatic int vortex_open(struct device *dev);
device238drivers/net/3c59x.cstatic int vortex_start_xmit(struct sk_buff *skb, struct device *dev);
device239drivers/net/3c59x.cstatic int vortex_rx(struct device *dev);
device241drivers/net/3c59x.cstatic int vortex_close(struct device *dev);
device242drivers/net/3c59x.cstatic void update_stats(int addr, struct device *dev);
device243drivers/net/3c59x.cstatic struct enet_statistics *vortex_get_stats(struct device *dev);
device244drivers/net/3c59x.cstatic void set_multicast_list(struct device *dev);
device268drivers/net/3c59x.cstatic struct device *root_vortex_dev = NULL;
device286drivers/net/3c59x.cunsigned long tc59x_probe(struct device *dev)
device299drivers/net/3c59x.cstatic int vortex_scan(struct device *dev)
device379drivers/net/3c59x.cstatic int vortex_found_device(struct device *dev, int ioaddr, int irq,
device386drivers/net/3c59x.cint dev_size = sizeof(struct device) +
device389drivers/net/3c59x.cdev = (struct device *) kmalloc(dev_size, GFP_KERNEL);
device391drivers/net/3c59x.cdev->priv = ((void *)dev) + sizeof(struct device);
device439drivers/net/3c59x.cstatic int vortex_probe1(struct device *dev)
device505drivers/net/3c59x.cvortex_open(struct device *dev)
device629drivers/net/3c59x.cstruct device *dev = (struct device *)data;
device636drivers/net/3c59x.cvortex_start_xmit(struct sk_buff *skb, struct device *dev)
device742drivers/net/3c59x.cstruct device *dev = (struct device *)(irq == 0 ? regs : irq2dev_map[irq]);
device744drivers/net/3c59x.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device867drivers/net/3c59x.cvortex_rx(struct device *dev)
device928drivers/net/3c59x.cvortex_close(struct device *dev)
device972drivers/net/3c59x.cvortex_get_stats(struct device *dev)
device991drivers/net/3c59x.cstatic void update_stats(int ioaddr, struct device *dev)
device1025drivers/net/3c59x.cset_multicast_list(struct device *dev)
device1047drivers/net/3c59x.cstruct device *next_dev;
device101drivers/net/8390.cstatic void ei_tx_intr(struct device *dev);
device102drivers/net/8390.cstatic void ei_receive(struct device *dev);
device103drivers/net/8390.cstatic void ei_rx_overrun(struct device *dev);
device106drivers/net/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
device108drivers/net/8390.cstatic void set_multicast_list(struct device *dev);
device115drivers/net/8390.cint ei_open(struct device *dev)
device133drivers/net/8390.cint ei_close(struct device *dev)
device140drivers/net/8390.cstatic int ei_start_xmit(struct sk_buff *skb, struct device *dev)
device262drivers/net/8390.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device345drivers/net/8390.cstatic void ei_tx_intr(struct device *dev)
device409drivers/net/8390.cstatic void ei_receive(struct device *dev)
device521drivers/net/8390.cstatic void ei_rx_overrun(struct device *dev)
device558drivers/net/8390.cstatic struct enet_statistics *get_stats(struct device *dev)
device578drivers/net/8390.cstatic void set_multicast_list(struct device *dev)
device597drivers/net/8390.cint ethdev_init(struct device *dev)
device625drivers/net/8390.cvoid NS8390_init(struct device *dev, int startp)
device687drivers/net/8390.cstatic void NS8390_trigger_send(struct device *dev, unsigned int length,
device31drivers/net/8390.hextern int ethif_init(struct device *dev);
device32drivers/net/8390.hextern int ethdev_init(struct device *dev);
device33drivers/net/8390.hextern void NS8390_init(struct device *dev, int startp);
device34drivers/net/8390.hextern int ei_open(struct device *dev);
device35drivers/net/8390.hextern int ei_close(struct device *dev);
device40drivers/net/8390.hextern struct device *irq2dev_map[16];
device50drivers/net/8390.hvoid (*reset_8390)(struct device *);
device51drivers/net/8390.hvoid (*get_8390_hdr)(struct device *, struct e8390_pkt_hdr *, int);
device52drivers/net/8390.hvoid (*block_output)(struct device *, int, const unsigned char *, int);
device53drivers/net/8390.hvoid (*block_input)(struct device *, int, struct sk_buff *, int);
device41drivers/net/Space.cextern int hp100_probe(struct device *dev);
device42drivers/net/Space.cextern int ultra_probe(struct device *dev);
device43drivers/net/Space.cextern int wd_probe(struct device *dev);
device44drivers/net/Space.cextern int el2_probe(struct device *dev);
device45drivers/net/Space.cextern int ne_probe(struct device *dev);
device46drivers/net/Space.cextern int hp_probe(struct device *dev);
device47drivers/net/Space.cextern int hp_plus_probe(struct device *dev);
device48drivers/net/Space.cextern int znet_probe(struct device *);
device49drivers/net/Space.cextern int express_probe(struct device *);
device50drivers/net/Space.cextern int eepro_probe(struct device *);
device51drivers/net/Space.cextern int el3_probe(struct device *);
device52drivers/net/Space.cextern int at1500_probe(struct device *);
device53drivers/net/Space.cextern int at1700_probe(struct device *);
device54drivers/net/Space.cextern int eth16i_probe(struct device *);
device55drivers/net/Space.cextern int depca_probe(struct device *);
device56drivers/net/Space.cextern int apricot_probe(struct device *);
device57drivers/net/Space.cextern int ewrk3_probe(struct device *);
device58drivers/net/Space.cextern int de4x5_probe(struct device *);
device59drivers/net/Space.cextern int el1_probe(struct device *);
device61drivers/net/Space.cextern int wavelan_probe(struct device *);
device63drivers/net/Space.cextern int el16_probe(struct device *);
device64drivers/net/Space.cextern int elplus_probe(struct device *);
device65drivers/net/Space.cextern int ac3200_probe(struct device *);
device66drivers/net/Space.cextern int e2100_probe(struct device *);
device67drivers/net/Space.cextern int ni52_probe(struct device *);
device68drivers/net/Space.cextern int ni65_probe(struct device *);
device69drivers/net/Space.cextern int SK_init(struct device *);
device70drivers/net/Space.cextern int seeq8005_probe(struct device *);
device71drivers/net/Space.cextern int tc59x_probe(struct device *);
device74drivers/net/Space.cextern int atp_init(struct device *);
device75drivers/net/Space.cextern int de600_probe(struct device *);
device76drivers/net/Space.cextern int de620_probe(struct device *);
device79drivers/net/Space.cethif_probe(struct device *dev)
device188drivers/net/Space.cextern int nr_init(struct device *);
device190drivers/net/Space.cstatic struct device nr3_dev = { "nr3", 0, 0, 0, 0, 0, 0, 0, 0, 0, NEXT_DEV, nr_init, };
device191drivers/net/Space.cstatic struct device nr2_dev = { "nr2", 0, 0, 0, 0, 0, 0, 0, 0, 0, &nr3_dev, nr_init, };
device192drivers/net/Space.cstatic struct device nr1_dev = { "nr1", 0, 0, 0, 0, 0, 0, 0, 0, 0, &nr2_dev, nr_init, };
device193drivers/net/Space.cstatic struct device nr0_dev = { "nr0", 0, 0, 0, 0, 0, 0, 0, 0, 0, &nr1_dev, nr_init, };
device201drivers/net/Space.cstatic struct device atp_dev = {
device208drivers/net/Space.cextern int arcnet_probe(struct device *dev);
device209drivers/net/Space.cstatic struct device arcnet_dev = {
device226drivers/net/Space.cstatic struct device eth3_dev = {
device228drivers/net/Space.cstatic struct device eth2_dev = {
device230drivers/net/Space.cstatic struct device eth1_dev = {
device233drivers/net/Space.cstatic struct device eth0_dev = {
device240drivers/net/Space.cextern int plip_init(struct device *);
device241drivers/net/Space.cstatic struct device plip2_dev = {
device243drivers/net/Space.cstatic struct device plip1_dev = {
device245drivers/net/Space.cstatic struct device plip0_dev = {
device254drivers/net/Space.cextern int slip_init_ctrl_dev(struct device *);
device255drivers/net/Space.cstatic struct device slip_bootstrap = {
device262drivers/net/Space.cextern int ppp_init(struct device *);
device263drivers/net/Space.cstatic struct device ppp_bootstrap = {
device270drivers/net/Space.cextern int dummy_init(struct device *dev);
device271drivers/net/Space.cstatic struct device dummy_dev = {
device278drivers/net/Space.cextern int eql_init(struct device *dev);
device279drivers/net/Space.cstruct device eql_dev = {
device295drivers/net/Space.cextern int tok_probe(struct device *dev);
device296drivers/net/Space.cstatic struct device ibmtr_dev1 = {
device312drivers/net/Space.cstatic struct device ibmtr_dev0 = {
device330drivers/net/Space.cextern int tunnel_init(struct device *);
device332drivers/net/Space.cstatic struct device tunnel_dev1 = 
device346drivers/net/Space.cstatic struct device tunnel_dev0 = 
device365drivers/net/Space.cextern int loopback_init(struct device *dev);
device366drivers/net/Space.cstruct device loopback_dev = {
device379drivers/net/Space.cstruct device *dev_base = &loopback_dev;
device70drivers/net/ac3200.cint ac3200_probe(struct device *dev);
device71drivers/net/ac3200.cstatic int ac_probe1(int ioaddr, struct device *dev);
device73drivers/net/ac3200.cstatic int ac_open(struct device *dev);
device74drivers/net/ac3200.cstatic void ac_reset_8390(struct device *dev);
device75drivers/net/ac3200.cstatic void ac_block_input(struct device *dev, int count,
device77drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, const int count,
device79drivers/net/ac3200.cstatic void ac_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device82drivers/net/ac3200.cstatic int ac_close_card(struct device *dev);
device91drivers/net/ac3200.cint ac3200_probe(struct device *dev)
device114drivers/net/ac3200.cstatic int ac_probe1(int ioaddr, struct device *dev)
device224drivers/net/ac3200.cstatic int ac_open(struct device *dev)
device241drivers/net/ac3200.cstatic void ac_reset_8390(struct device *dev)
device260drivers/net/ac3200.cac_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device269drivers/net/ac3200.cstatic void ac_block_input(struct device *dev, int count, struct sk_buff *skb,
device286drivers/net/ac3200.cstatic void ac_block_output(struct device *dev, int count,
device294drivers/net/ac3200.cstatic int ac_close_card(struct device *dev)
device320drivers/net/ac3200.cstatic struct device dev_ac32[MAX_AC32_CARDS] = {
device339drivers/net/ac3200.cstruct device *dev = &dev_ac32[this_dev];
device364drivers/net/ac3200.cstruct device *dev = &dev_ac32[this_dev];
device184drivers/net/apricot.cstatic int i596_open(struct device *dev);
device185drivers/net/apricot.cstatic int i596_start_xmit(struct sk_buff *skb, struct device *dev);
device187drivers/net/apricot.cstatic int i596_close(struct device *dev);
device188drivers/net/apricot.cstatic struct enet_statistics *i596_get_stats(struct device *dev);
device189drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd);
device191drivers/net/apricot.cstatic void set_multicast_list(struct device *dev);
device195drivers/net/apricot.cinit_rx_bufs(struct device *dev, int num)
device233drivers/net/apricot.cremove_rx_bufs(struct device *dev)
device250drivers/net/apricot.cinit_i596_mem(struct device *dev)
device325drivers/net/apricot.ci596_rx(struct device *dev)
device442drivers/net/apricot.ci596_reset(struct device *dev, struct i596_private *lp, int ioaddr)
device482drivers/net/apricot.cstatic void i596_add_cmd(struct device *dev, struct i596_cmd *cmd)
device533drivers/net/apricot.ci596_open(struct device *dev)
device569drivers/net/apricot.ci596_start_xmit(struct sk_buff *skb, struct device *dev)
device678drivers/net/apricot.cint apricot_probe(struct device *dev)
device748drivers/net/apricot.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device912drivers/net/apricot.ci596_close(struct device *dev)
device946drivers/net/apricot.ci596_get_stats(struct device *dev)
device957drivers/net/apricot.cstatic void set_multicast_list(struct device *dev)
device1011drivers/net/apricot.cstatic struct device dev_apricot = {
device565drivers/net/arcnet.cstruct device *adev;  /* RFC1201 protocol device */
device568drivers/net/arcnet.cstruct device *edev;  /* Ethernet-Encap device */
device572drivers/net/arcnet.cstruct device *sdev;  /* RFC1051 protocol device */
device578drivers/net/arcnet.cextern int arcnet_probe(struct device *dev);
device579drivers/net/arcnet.cstatic int arcnet_found(struct device *dev,int port,int airq,u_long shmem);
device581drivers/net/arcnet.cstatic void arcnet_setup(struct device *dev);
device582drivers/net/arcnet.cstatic int arcnet_open(struct device *dev);
device583drivers/net/arcnet.cstatic int arcnet_close(struct device *dev);
device584drivers/net/arcnet.cstatic int arcnet_reset(struct device *dev,int reset_delay);
device586drivers/net/arcnet.cstatic int arcnet_send_packet_bad(struct sk_buff *skb,struct device *dev);
device587drivers/net/arcnet.cstatic int arcnetA_send_packet(struct sk_buff *skb, struct device *dev);
device588drivers/net/arcnet.cstatic void arcnetA_continue_tx(struct device *dev);
device589drivers/net/arcnet.cstatic void arcnetAS_prepare_tx(struct device *dev,u_char *hdr,int hdrlen,
device591drivers/net/arcnet.cstatic int arcnet_go_tx(struct device *dev,int enable_irq);
device594drivers/net/arcnet.cstatic void arcnet_inthandler(struct device *dev);
device596drivers/net/arcnet.cstatic void arcnet_rx(struct device *dev,int recbuf);
device597drivers/net/arcnet.cstatic void arcnetA_rx(struct device *dev,u_char *buf,
device600drivers/net/arcnet.cstatic struct enet_statistics *arcnet_get_stats(struct device *dev);
device602drivers/net/arcnet.cint arcnetA_header(struct sk_buff *skb,struct device *dev,
device604drivers/net/arcnet.cint arcnetA_rebuild_header(void *eth,struct device *dev,unsigned long raddr,
device606drivers/net/arcnet.cunsigned short arcnetA_type_trans(struct sk_buff *skb,struct device *dev);
device610drivers/net/arcnet.cstatic int arcnetE_init(struct device *dev);
device611drivers/net/arcnet.cstatic int arcnetE_send_packet(struct sk_buff *skb, struct device *dev);
device612drivers/net/arcnet.cstatic void arcnetE_rx(struct device *dev,u_char *arcsoft,
device618drivers/net/arcnet.cstatic int arcnetS_init(struct device *dev);
device619drivers/net/arcnet.cstatic int arcnetS_send_packet(struct sk_buff *skb, struct device *dev);
device620drivers/net/arcnet.cstatic void arcnetS_rx(struct device *dev,u_char *buf,
device622drivers/net/arcnet.cint arcnetS_header(struct sk_buff *skb,struct device *dev,
device624drivers/net/arcnet.cint arcnetS_rebuild_header(void *eth,struct device *dev,unsigned long raddr,
device626drivers/net/arcnet.cunsigned short arcnetS_type_trans(struct sk_buff *skb,struct device *dev);
device655drivers/net/arcnet.cint arcnet_probe(struct device *dev)
device1015drivers/net/arcnet.cint arcnet_found(struct device *dev,int port,int airq, u_long shmem)
device1112drivers/net/arcnet.cint arcnet_reset(struct device *dev,int reset_delay)
device1180drivers/net/arcnet.cvoid arcnet_setup(struct device *dev)
device1218drivers/net/arcnet.carcnet_open(struct device *dev)
device1256drivers/net/arcnet.clp->edev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
device1259drivers/net/arcnet.cmemcpy(lp->edev,dev,sizeof(struct device));
device1275drivers/net/arcnet.clp->sdev=(struct device *)kmalloc(sizeof(struct device),GFP_KERNEL);
device1276drivers/net/arcnet.cmemcpy(lp->sdev,dev,sizeof(struct device));
device1308drivers/net/arcnet.carcnet_close(struct device *dev)
device1369drivers/net/arcnet.carcnet_send_packet_bad(struct sk_buff *skb, struct device *dev)
device1485drivers/net/arcnet.carcnetA_send_packet(struct sk_buff *skb, struct device *dev)
device1604drivers/net/arcnet.cstatic void arcnetA_continue_tx(struct device *dev)
device1651drivers/net/arcnet.carcnetAS_prepare_tx(struct device *dev,u_char *hdr,int hdrlen,
device1774drivers/net/arcnet.carcnet_go_tx(struct device *dev,int enable_irq)
device1825drivers/net/arcnet.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device1857drivers/net/arcnet.carcnet_inthandler(struct device *dev)
device2099drivers/net/arcnet.carcnet_rx(struct device *dev,int recbuf)
device2206drivers/net/arcnet.carcnetA_rx(struct device *dev,u_char *buf,
device2511drivers/net/arcnet.carcnet_get_stats(struct device *dev)
device2526drivers/net/arcnet.cset_multicast_list(struct device *dev)
device2545drivers/net/arcnet.cint arcnetA_header(struct sk_buff *skb,struct device *dev,
device2619drivers/net/arcnet.cint arcnetA_rebuild_header(void *buff,struct device *dev,unsigned long dst,
device2661drivers/net/arcnet.cunsigned short arcnetA_type_trans(struct sk_buff *skb,struct device *dev)
device2711drivers/net/arcnet.cstatic int arcnetE_init(struct device *dev)
device2732drivers/net/arcnet.carcnetE_send_packet(struct sk_buff *skb, struct device *dev)
device2854drivers/net/arcnet.carcnetE_rx(struct device *dev,u_char *arcsoft,
device2905drivers/net/arcnet.cstatic int arcnetS_init(struct device *dev)
device2930drivers/net/arcnet.carcnetS_send_packet(struct sk_buff *skb, struct device *dev)
device3004drivers/net/arcnet.carcnetS_rx(struct device *dev,u_char *buf,
device3063drivers/net/arcnet.cint arcnetS_header(struct sk_buff *skb,struct device *dev,
device3119drivers/net/arcnet.cint arcnetS_rebuild_header(void *buff,struct device *dev,unsigned long dst,
device3155drivers/net/arcnet.cunsigned short arcnetS_type_trans(struct sk_buff *skb,struct device *dev)
device3202drivers/net/arcnet.cstatic struct device thiscard = {
device114drivers/net/at1700.cextern int at1700_probe(struct device *dev);
device116drivers/net/at1700.cstatic int at1700_probe1(struct device *dev, short ioaddr);
device118drivers/net/at1700.cstatic int net_open(struct device *dev);
device119drivers/net/at1700.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
device121drivers/net/at1700.cstatic void net_rx(struct device *dev);
device122drivers/net/at1700.cstatic int net_close(struct device *dev);
device123drivers/net/at1700.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device124drivers/net/at1700.cstatic void set_multicast_list(struct device *dev);
device140drivers/net/at1700.cat1700_probe(struct device *dev)
device170drivers/net/at1700.cint at1700_probe1(struct device *dev, short ioaddr)
device319drivers/net/at1700.cstatic int net_open(struct device *dev)
device364drivers/net/at1700.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device445drivers/net/at1700.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device492drivers/net/at1700.cnet_rx(struct device *dev)
device573drivers/net/at1700.cstatic int net_close(struct device *dev)
device596drivers/net/at1700.cnet_get_stats(struct device *dev)
device614drivers/net/at1700.cset_multicast_list(struct device *dev)
device633drivers/net/at1700.cstatic struct device dev_at1700 = {
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);
device153drivers/net/atp.catp_init(struct device *dev)
device175drivers/net/atp.cstatic int atp_probe1(struct device *dev, short ioaddr)
device261drivers/net/atp.cstatic void get_node_ID(struct device *dev)
device323drivers/net/atp.cstatic int net_open(struct device *dev)
device342drivers/net/atp.cstatic void hardware_init(struct device *dev)
device416drivers/net/atp.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device489drivers/net/atp.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device646drivers/net/atp.cstatic void net_rx(struct device *dev)
device725drivers/net/atp.cnet_close(struct device *dev)
device751drivers/net/atp.cnet_get_stats(struct device *dev)
device761drivers/net/atp.cstatic void set_multicast_list(struct device *dev)
device42drivers/net/auto_irq.cstruct device *irq2dev_map[16] = {0, 0, /* ... zeroed */};
device397drivers/net/de4x5.cstatic int     de4x5_open(struct device *dev);
device398drivers/net/de4x5.cstatic int     de4x5_queue_pkt(struct sk_buff *skb, struct device *dev);
device400drivers/net/de4x5.cstatic int     de4x5_close(struct device *dev);
device401drivers/net/de4x5.cstatic struct  enet_statistics *de4x5_get_stats(struct device *dev);
device402drivers/net/de4x5.cstatic void    set_multicast_list(struct device *dev);
device403drivers/net/de4x5.cstatic int     de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd);
device408drivers/net/de4x5.cstatic int     de4x5_hw_init(struct device *dev, u_long iobase);
device409drivers/net/de4x5.cstatic int     de4x5_init(struct device *dev);
device410drivers/net/de4x5.cstatic int     de4x5_rx(struct device *dev);
device411drivers/net/de4x5.cstatic int     de4x5_tx(struct device *dev);
device412drivers/net/de4x5.cstatic int     de4x5_ast(struct device *dev);
device414drivers/net/de4x5.cstatic int     autoconf_media(struct device *dev);
device415drivers/net/de4x5.cstatic void    create_packet(struct device *dev, char *frame, int len);
device418drivers/net/de4x5.cstatic void    load_packet(struct device *dev, char *buf, u32 flags, struct sk_buff *skb);
device419drivers/net/de4x5.cstatic void    dc21040_autoconf(struct device *dev);
device420drivers/net/de4x5.cstatic void    dc21041_autoconf(struct device *dev);
device421drivers/net/de4x5.cstatic void    dc21140_autoconf(struct device *dev);
device422drivers/net/de4x5.cstatic int     test_media(struct device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec);
device424drivers/net/de4x5.cstatic int     ping_media(struct device *dev);
device425drivers/net/de4x5.cstatic void    reset_init_sia(struct device *dev, s32 sicr, s32 strr, s32 sigr);
device426drivers/net/de4x5.cstatic int     test_ans(struct device *dev, s32 irqs, s32 irq_mask, s32 msec);
device427drivers/net/de4x5.cstatic void    load_ms_timer(struct device *dev, u32 msec);
device438drivers/net/de4x5.cstatic void    SetMulticastFilter(struct device *dev);
device439drivers/net/de4x5.cstatic int     get_hw_addr(struct device *dev);
device441drivers/net/de4x5.cstatic void    eisa_probe(struct device *dev, u_long iobase);
device442drivers/net/de4x5.cstatic void    pci_probe(struct device *dev, u_long iobase);
device443drivers/net/de4x5.cstatic struct  device *alloc_device(struct device *dev, u_long iobase);
device444drivers/net/de4x5.cstatic char    *build_setup_frame(struct device *dev, int mode);
device445drivers/net/de4x5.cstatic void    disable_ast(struct device *dev);
device446drivers/net/de4x5.cstatic void    enable_ast(struct device *dev, u32 time_out);
device447drivers/net/de4x5.cstatic void    kick_tx(struct device *dev);
device469drivers/net/de4x5.cint device;
device492drivers/net/de4x5.cint de4x5_probe(struct device *dev)
device523drivers/net/de4x5.cde4x5_hw_init(struct device *dev, u_long iobase)
device562drivers/net/de4x5.ciobase, lp->bus_num, lp->device);
device749drivers/net/de4x5.cde4x5_open(struct device *dev)
device862drivers/net/de4x5.cde4x5_init(struct device *dev)
device938drivers/net/de4x5.cde4x5_queue_pkt(struct sk_buff *skb, struct device *dev)
device1070drivers/net/de4x5.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device1125drivers/net/de4x5.cde4x5_rx(struct device *dev)
device1218drivers/net/de4x5.cde4x5_tx(struct device *dev)
device1265drivers/net/de4x5.cde4x5_ast(struct device *dev)
device1311drivers/net/de4x5.cde4x5_close(struct device *dev)
device1350drivers/net/de4x5.cde4x5_get_stats(struct device *dev)
device1360drivers/net/de4x5.cstatic void load_packet(struct device *dev, char *buf, u32 flags, struct sk_buff *skb)
device1385drivers/net/de4x5.cset_multicast_list(struct device *dev)
device1421drivers/net/de4x5.cstatic void SetMulticastFilter(struct device *dev)
device1482drivers/net/de4x5.cstatic void eisa_probe(struct device *dev, u_long ioaddr)
device1485drivers/net/de4x5.cu_short vendor, device;
device1509drivers/net/de4x5.cdevice = (u_short)(cfid >> 16);
device1513drivers/net/de4x5.clp->chipset = device;
device1552drivers/net/de4x5.cstatic void pci_probe(struct device *dev, u_long ioaddr)
device1556drivers/net/de4x5.cu_short vendor, device, index, status;
device1581drivers/net/de4x5.cpcibios_read_config_word(pb, PCI_DEVICE, PCI_DEVICE_ID, &device);
device1584drivers/net/de4x5.clp->device = dev_num;
device1588drivers/net/de4x5.clp->chipset = device;
device1633drivers/net/de4x5.cstatic struct device *alloc_device(struct device *dev, u_long iobase)
device1636drivers/net/de4x5.cstruct device *tmp = NULL, *ret;
device1637drivers/net/de4x5.cint (*init)(struct device *) = NULL;
device1665drivers/net/de4x5.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1678drivers/net/de4x5.cdev->name = (char *)(dev + sizeof(struct device));
device1705drivers/net/de4x5.ctmp->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1717drivers/net/de4x5.ctmp->name = (char *)(tmp + sizeof(struct device));
device1745drivers/net/de4x5.cstatic int autoconf_media(struct device *dev)
device1801drivers/net/de4x5.cstatic void dc21040_autoconf(struct device *dev)
device1862drivers/net/de4x5.cstatic void dc21041_autoconf(struct device *dev)
device1947drivers/net/de4x5.cstatic void dc21140_autoconf(struct device *dev)
device1973drivers/net/de4x5.ctest_media(struct device *dev, s32 irqs, s32 irq_mask, s32 csr13, s32 csr14, s32 csr15, s32 msec)
device2025drivers/net/de4x5.cstatic int ping_media(struct device *dev)
device2059drivers/net/de4x5.cstatic int test_ans(struct device *dev, s32 irqs, s32 irq_mask, s32 msec)
device2086drivers/net/de4x5.cstatic void reset_init_sia(struct device *dev, s32 sicr, s32 strr, s32 sigr)
device2102drivers/net/de4x5.cstatic void load_ms_timer(struct device *dev, u32 msec)
device2125drivers/net/de4x5.cstatic void create_packet(struct device *dev, char *frame, int len)
device2265drivers/net/de4x5.cstatic int get_hw_addr(struct device *dev)
device2421drivers/net/de4x5.cstatic char *build_setup_frame(struct device *dev, int mode)
device2452drivers/net/de4x5.cstatic void enable_ast(struct device *dev, u32 time_out)
device2464drivers/net/de4x5.cstatic void disable_ast(struct device *dev)
device2476drivers/net/de4x5.cstatic void kick_tx(struct device *dev)
device2494drivers/net/de4x5.cstatic int de4x5_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device2738drivers/net/de4x5.cstatic struct device thisDE4X5 = {
device115drivers/net/de4x5.h#define is_DC21040 ((vendor == DC21040_VID) && (device == DC21040_DID))
device116drivers/net/de4x5.h#define is_DC21041 ((vendor == DC21041_VID) && (device == DC21041_DID))
device117drivers/net/de4x5.h#define is_DC21140 ((vendor == DC21140_VID) && (device == DC21140_DID))
device240drivers/net/de600.cstatic byte  de600_read_status(struct device *dev);
device241drivers/net/de600.cstatic byte  de600_read_byte(unsigned char type, struct device *dev);
device244drivers/net/de600.cstatic int  de600_open(struct device *dev);
device245drivers/net/de600.cstatic int  de600_close(struct device *dev);
device246drivers/net/de600.cstatic struct netstats *get_stats(struct device *dev);
device247drivers/net/de600.cstatic int  de600_start_xmit(struct sk_buff *skb, struct device *dev);
device251drivers/net/de600.cstatic int  de600_tx_intr(struct device *dev, int irq_status);
device252drivers/net/de600.cstatic void  de600_rx_intr(struct device *dev);
device255drivers/net/de600.cstatic void  trigger_interrupt(struct device *dev);
device256drivers/net/de600.cint    de600_probe(struct device *dev);
device257drivers/net/de600.cstatic int  adapter_init(struct device *dev);
device307drivers/net/de600.cde600_read_status(struct device *dev)
device319drivers/net/de600.cde600_read_byte(unsigned char type, struct device *dev) { /* dev used by macros */
device337drivers/net/de600.cde600_open(struct device *dev)
device358drivers/net/de600.cde600_close(struct device *dev)
device377drivers/net/de600.cget_stats(struct device *dev)
device383drivers/net/de600.ctrigger_interrupt(struct device *dev)
device397drivers/net/de600.cde600_start_xmit(struct sk_buff *skb, struct device *dev)
device493drivers/net/de600.cstruct device  *dev = irq2dev_map[irq];
device542drivers/net/de600.cde600_tx_intr(struct device *dev, int irq_status)
device578drivers/net/de600.cde600_rx_intr(struct device *dev)
device638drivers/net/de600.cde600_probe(struct device *dev)
device718drivers/net/de600.cadapter_init(struct device *dev)
device829drivers/net/de600.cstatic struct device de600_dev = {
device206drivers/net/de620.cstatic int  de620_open(struct device *);
device207drivers/net/de620.cstatic int  de620_close(struct device *);
device208drivers/net/de620.cstatic struct netstats *get_stats(struct device *);
device209drivers/net/de620.cstatic void  de620_set_multicast_list(struct device *);
device210drivers/net/de620.cstatic int  de620_start_xmit(struct sk_buff *, struct device *);
device214drivers/net/de620.cstatic int  de620_rx_intr(struct device *);
device217drivers/net/de620.cstatic int  adapter_init(struct device *);
device218drivers/net/de620.cint    de620_probe(struct device *);
device219drivers/net/de620.cstatic int  read_eeprom(struct device *);
device257drivers/net/de620.cde620_ready(struct device *dev)
device272drivers/net/de620.cde620_send_command(struct device *dev, byte cmd)
device286drivers/net/de620.cde620_put_byte(struct device *dev, byte value)
device295drivers/net/de620.cde620_read_byte(struct device *dev)
device307drivers/net/de620.cde620_write_block(struct device *dev, byte *buffer, int count)
device343drivers/net/de620.cde620_read_block(struct device *dev, byte *data, int count)
device378drivers/net/de620.cde620_set_delay(struct device *dev)
device402drivers/net/de620.cde620_set_register(struct device *dev, byte reg, byte value)
device412drivers/net/de620.cde620_get_register(struct device *dev, byte reg)
device433drivers/net/de620.cde620_open(struct device *dev)
device455drivers/net/de620.cde620_close(struct device *dev)
device474drivers/net/de620.cget_stats(struct device *dev)
device486drivers/net/de620.cstatic void de620_set_multicast_list(struct device *dev)
device511drivers/net/de620.cde620_start_xmit(struct sk_buff *skb, struct device *dev)
device603drivers/net/de620.cstruct device *dev = irq2dev_map[irq_in];
device645drivers/net/de620.cde620_rx_intr(struct device *dev)
device744drivers/net/de620.cadapter_init(struct device *dev)
device832drivers/net/de620.cde620_probe(struct device *dev)
device926drivers/net/de620.cReadAWord(struct device *dev, int from)
device969drivers/net/de620.cread_eeprom(struct device *dev)
device1012drivers/net/de620.cstatic struct device de620_dev = {
device382drivers/net/depca.cstatic int    depca_open(struct device *dev);
device383drivers/net/depca.cstatic int    depca_start_xmit(struct sk_buff *skb, struct device *dev);
device385drivers/net/depca.cstatic int    depca_close(struct device *dev);
device386drivers/net/depca.cstatic int    depca_ioctl(struct device *dev, struct ifreq *rq, int cmd);
device387drivers/net/depca.cstatic struct enet_statistics *depca_get_stats(struct device *dev);
device388drivers/net/depca.cstatic void   set_multicast_list(struct device *dev);
device393drivers/net/depca.cstatic int    depca_hw_init(struct device *dev, u_long ioaddr);
device394drivers/net/depca.cstatic void   depca_init_ring(struct device *dev);
device395drivers/net/depca.cstatic int    depca_rx(struct device *dev);
device396drivers/net/depca.cstatic int    depca_tx(struct device *dev);
device398drivers/net/depca.cstatic void   LoadCSRs(struct device *dev);
device399drivers/net/depca.cstatic int    InitRestartDepca(struct device *dev);
device402drivers/net/depca.cstatic int    get_hw_addr(struct device *dev);
device404drivers/net/depca.cstatic void   SetMulticastFilter(struct device *dev);
device405drivers/net/depca.cstatic void   isa_probe(struct device *dev, u_long iobase);
device406drivers/net/depca.cstatic void   eisa_probe(struct device *dev, u_long iobase);
device407drivers/net/depca.cstatic struct device *alloc_device(struct device *dev, u_long iobase);
device408drivers/net/depca.cstatic int    load_packet(struct device *dev, struct sk_buff *skb);
device409drivers/net/depca.cstatic void   depca_dbg_open(struct device *dev);
device439drivers/net/depca.cint depca_probe(struct device *dev)
device470drivers/net/depca.cdepca_hw_init(struct device *dev, u_long ioaddr)
device684drivers/net/depca.cdepca_open(struct device *dev)
device736drivers/net/depca.cdepca_init_ring(struct device *dev)
device779drivers/net/depca.cdepca_start_xmit(struct sk_buff *skb, struct device *dev)
device841drivers/net/depca.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device890drivers/net/depca.cdepca_rx(struct device *dev)
device987drivers/net/depca.cdepca_tx(struct device *dev)
device1025drivers/net/depca.cdepca_close(struct device *dev)
device1067drivers/net/depca.cstatic void LoadCSRs(struct device *dev)
device1084drivers/net/depca.cstatic int InitRestartDepca(struct device *dev)
device1116drivers/net/depca.cdepca_get_stats(struct device *dev)
device1129drivers/net/depca.cset_multicast_list(struct device *dev)
device1161drivers/net/depca.cstatic void SetMulticastFilter(struct device *dev)
device1209drivers/net/depca.cstatic void isa_probe(struct device *dev, u_long ioaddr)
device1247drivers/net/depca.cstatic void eisa_probe(struct device *dev, u_long ioaddr)
device1291drivers/net/depca.cstatic struct device *alloc_device(struct device *dev, u_long iobase)
device1294drivers/net/depca.cstruct device *tmp = NULL, *ret;
device1295drivers/net/depca.cint (*init)(struct device *) = NULL;
device1323drivers/net/depca.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1336drivers/net/depca.cdev->name = (char *)(dev + sizeof(struct device));
device1363drivers/net/depca.ctmp->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1375drivers/net/depca.ctmp->name = (char *)(tmp + sizeof(struct device));
device1498drivers/net/depca.cstatic int get_hw_addr(struct device *dev)
device1529drivers/net/depca.cstatic int load_packet(struct device *dev, struct sk_buff *skb)
device1617drivers/net/depca.cstatic void depca_dbg_open(struct device *dev)
device1696drivers/net/depca.cstatic int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device1855drivers/net/depca.cstatic struct device thisDepca = {
device56drivers/net/dummy.cstatic int dummy_xmit(struct sk_buff *skb, struct device *dev);
device58drivers/net/dummy.cstatic struct enet_statistics *dummy_get_stats(struct device *dev);
device62drivers/net/dummy.cstatic int dummy_open(struct device *dev)
device68drivers/net/dummy.cstatic int dummy_close(struct device *dev)
device76drivers/net/dummy.cint dummy_init(struct device *dev)
device105drivers/net/dummy.cdummy_xmit(struct sk_buff *skb, struct device *dev)
device126drivers/net/dummy.cdummy_get_stats(struct device *dev)
device135drivers/net/dummy.cstatic int dummy_probe(struct device *dev)
device141drivers/net/dummy.cstatic struct device dev_dummy = {
device96drivers/net/e2100.cint e2100_probe(struct device *dev);
device97drivers/net/e2100.cint e21_probe1(struct device *dev, int ioaddr);
device99drivers/net/e2100.cstatic int e21_open(struct device *dev);
device100drivers/net/e2100.cstatic void e21_reset_8390(struct device *dev);
device101drivers/net/e2100.cstatic void e21_block_input(struct device *dev, int count,
device103drivers/net/e2100.cstatic void e21_block_output(struct device *dev, int count,
device105drivers/net/e2100.cstatic void e21_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device108drivers/net/e2100.cstatic int e21_close(struct device *dev);
device118drivers/net/e2100.cint e2100_probe(struct device *dev)
device138drivers/net/e2100.cint e21_probe1(struct device *dev, int ioaddr)
device252drivers/net/e2100.ce21_open(struct device *dev)
device276drivers/net/e2100.ce21_reset_8390(struct device *dev)
device294drivers/net/e2100.ce21_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device318drivers/net/e2100.ce21_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device332drivers/net/e2100.ce21_block_output(struct device *dev, int count, const unsigned char *buf,
device348drivers/net/e2100.ce21_close(struct device *dev)
device387drivers/net/e2100.cstatic struct device dev_e21[MAX_E21_CARDS] = {
device409drivers/net/e2100.cstruct device *dev = &dev_e21[this_dev];
device437drivers/net/e2100.cstruct device *dev = &dev_e21[this_dev];
device133drivers/net/eepro.cextern int eepro_probe(struct device *dev);  
device135drivers/net/eepro.cstatic int  eepro_probe1(struct device *dev, short ioaddr);
device136drivers/net/eepro.cstatic int  eepro_open(struct device *dev);
device137drivers/net/eepro.cstatic int  eepro_send_packet(struct sk_buff *skb, struct device *dev);
device139drivers/net/eepro.cstatic void   eepro_rx(struct device *dev);
device140drivers/net/eepro.cstatic void   eepro_transmit_interrupt(struct device *dev);
device141drivers/net/eepro.cstatic int  eepro_close(struct device *dev);
device142drivers/net/eepro.cstatic struct enet_statistics *eepro_get_stats(struct device *dev);
device143drivers/net/eepro.cstatic void set_multicast_list(struct device *dev);
device146drivers/net/eepro.cstatic void hardware_send_packet(struct device *dev, void *buf, short length);
device147drivers/net/eepro.cstatic int  eepro_grab_irq(struct device *dev);
device276drivers/net/eepro.ceepro_probe(struct device *dev)
device302drivers/net/eepro.cint eepro_probe1(struct device *dev, short ioaddr)
device439drivers/net/eepro.cstatic int  eepro_grab_irq(struct device *dev)
device498drivers/net/eepro.ceepro_open(struct device *dev)
device595drivers/net/eepro.ceepro_send_packet(struct sk_buff *skb, struct device *dev)
device666drivers/net/eepro.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device715drivers/net/eepro.ceepro_close(struct device *dev)
device764drivers/net/eepro.ceepro_get_stats(struct device *dev)
device774drivers/net/eepro.cset_multicast_list(struct device *dev)
device934drivers/net/eepro.chardware_send_packet(struct device *dev, void *buf, short length)
device1024drivers/net/eepro.ceepro_rx(struct device *dev)
device1096drivers/net/eepro.ceepro_transmit_interrupt(struct device *dev)
device1137drivers/net/eepro.cstatic struct device dev_eepro = {
device284drivers/net/eexpress.cextern int express_probe(struct device *dev);  /* Called from Space.c */
device286drivers/net/eexpress.cstatic int  eexp_probe1(struct device *dev, short ioaddr);
device287drivers/net/eexpress.cstatic int  eexp_open(struct device *dev);
device288drivers/net/eexpress.cstatic int  eexp_send_packet(struct sk_buff *skb, struct device *dev);
device290drivers/net/eexpress.cstatic void eexp_rx(struct device *dev);
device291drivers/net/eexpress.cstatic int  eexp_close(struct device *dev);
device292drivers/net/eexpress.cstatic struct enet_statistics *eexp_get_stats(struct device *dev);
device293drivers/net/eexpress.cstatic void set_multicast_list(struct device *dev);
device296drivers/net/eexpress.cstatic void hardware_send_packet(struct device *dev, void *buf, short length);
device297drivers/net/eexpress.cstatic void init_82586_mem(struct device *dev);
device298drivers/net/eexpress.cstatic void init_rx_bufs(struct device *dev);
device308drivers/net/eexpress.cexpress_probe(struct device *dev)
device341drivers/net/eexpress.cint eexp_probe1(struct device *dev, short ioaddr)
device422drivers/net/eexpress.ceexp_open(struct device *dev)
device450drivers/net/eexpress.ceexp_send_packet(struct sk_buff *skb, struct device *dev)
device518drivers/net/eexpress.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device637drivers/net/eexpress.ceexp_close(struct device *dev)
device664drivers/net/eexpress.ceexp_get_stats(struct device *dev)
device676drivers/net/eexpress.cset_multicast_list(struct device *dev)
device744drivers/net/eexpress.cinit_82586_mem(struct device *dev)
device802drivers/net/eexpress.cstatic void init_rx_bufs(struct device *dev)
device843drivers/net/eexpress.chardware_send_packet(struct device *dev, void *buf, short length)
device892drivers/net/eexpress.ceexp_rx(struct device *dev)
device994drivers/net/eexpress.cstatic struct device dev_eexpress = {
device145drivers/net/eql.cint        eql_init(struct device *dev); /*  */
device146drivers/net/eql.cstatic int eql_open(struct device *dev); /*  */
device147drivers/net/eql.cstatic int eql_close(struct device *dev); /*  */
device148drivers/net/eql.cstatic int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd); /*  */
device149drivers/net/eql.cstatic int eql_slave_xmit(struct sk_buff *skb, struct device *dev); /*  */
device151drivers/net/eql.cstatic struct enet_statistics *eql_get_stats(struct device *dev); /*  */
device152drivers/net/eql.cstatic int eql_header(struct sk_buff *skb, struct device *dev, 
device155drivers/net/eql.cstatic int eql_rebuild_header(void *buff, struct device *dev, 
device160drivers/net/eql.cstatic int eql_enslave(struct device *dev,  slaving_request_t *srq); /*  */
device161drivers/net/eql.cstatic int eql_emancipate(struct device *dev, slaving_request_t *srq); /*  */
device163drivers/net/eql.cstatic int eql_g_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
device164drivers/net/eql.cstatic int eql_s_slave_cfg(struct device *dev, slave_config_t *sc); /*  */
device166drivers/net/eql.cstatic int eql_g_master_cfg(struct device *dev, master_config_t *mc); /*  */
device167drivers/net/eql.cstatic int eql_s_master_cfg(struct device *dev, master_config_t *mc); /*  */
device169drivers/net/eql.cstatic inline int eql_is_slave(struct device *dev); /*  */
device170drivers/net/eql.cstatic inline int eql_is_master(struct device *dev); /*  */
device181drivers/net/eql.cstatic slave_queue_t *eql_new_slave_queue(struct device *dev); /*  */
device188drivers/net/eql.cstatic int eql_remove_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
device190drivers/net/eql.cstatic inline struct device *eql_best_slave_dev(slave_queue_t *queue); /*  */
device198drivers/net/eql.cstatic slave_t *eql_find_slave_dev(slave_queue_t *queue, struct device *dev); /*  */
device209drivers/net/eql.cint eql_init(struct device *dev)
device280drivers/net/eql.cstatic int eql_open(struct device *dev)
device311drivers/net/eql.cstatic int eql_close(struct device *dev)
device337drivers/net/eql.cstatic int eql_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
device361drivers/net/eql.cstatic int eql_slave_xmit(struct sk_buff *skb, struct device *dev)
device364drivers/net/eql.cstruct device *slave_dev = 0;
device401drivers/net/eql.cstatic struct enet_statistics * eql_get_stats(struct device *dev)
device408drivers/net/eql.cstatic int  eql_header(struct sk_buff *skb, struct device *dev, 
device416drivers/net/eql.cstatic int eql_rebuild_header(void *buff, struct device *dev, 
device426drivers/net/eql.cstatic int eql_enslave(struct device *dev, slaving_request_t *srqp)
device428drivers/net/eql.cstruct device *master_dev;
device429drivers/net/eql.cstruct device *slave_dev;
device466drivers/net/eql.cstatic int eql_emancipate(struct device *dev, slaving_request_t *srqp)
device468drivers/net/eql.cstruct device *master_dev;
device469drivers/net/eql.cstruct device *slave_dev;
device496drivers/net/eql.cstatic int eql_g_slave_cfg(struct device *dev, slave_config_t *scp)
device500drivers/net/eql.cstruct device *slave_dev;
device533drivers/net/eql.cstatic int eql_s_slave_cfg(struct device *dev, slave_config_t *scp)
device537drivers/net/eql.cstruct device *slave_dev;
device570drivers/net/eql.cstatic int eql_g_master_cfg(struct device *dev, master_config_t *mcp)
device596drivers/net/eql.cstatic int eql_s_master_cfg(struct device *dev, master_config_t *mcp)
device624drivers/net/eql.cstatic inline int eql_is_slave(struct device *dev)
device635drivers/net/eql.cstatic inline int eql_is_master(struct device *dev)
device701drivers/net/eql.cstatic slave_queue_t *eql_new_slave_queue(struct device *dev)
device810drivers/net/eql.cstatic int eql_insert_slave_dev(slave_queue_t *queue, struct device *dev)
device833drivers/net/eql.cstatic int eql_remove_slave_dev(slave_queue_t *queue, struct device *dev)
device861drivers/net/eql.cstatic inline struct device *eql_best_slave_dev(slave_queue_t *queue)
device882drivers/net/eql.cstruct device *master_dev = queue->master_dev;
device965drivers/net/eql.cstatic slave_t * eql_find_slave_dev(slave_queue_t *queue, struct device *dev)
device1078drivers/net/eql.cstatic struct device dev_eql = 
device313drivers/net/eth16i.cextern int eth16i_probe(struct device *dev);
device315drivers/net/eth16i.cstatic int eth16i_probe1(struct device *dev, short ioaddr);
device325drivers/net/eth16i.cstatic int eth16i_open(struct device *dev);
device326drivers/net/eth16i.cstatic int eth16i_close(struct device *dev);
device327drivers/net/eth16i.cstatic int eth16i_tx(struct sk_buff *skb, struct device *dev);
device328drivers/net/eth16i.cstatic void eth16i_rx(struct device *dev);
device330drivers/net/eth16i.cstatic void eth16i_multicast(struct device *dev, int num_addrs, void *addrs); 
device332drivers/net/eth16i.cstatic void eth16i_initialize(struct device *dev);
device333drivers/net/eth16i.cstatic struct enet_statistics *eth16i_get_stats(struct device *dev);
device343drivers/net/eth16i.cint eth16i_probe(struct device *dev)
device377drivers/net/eth16i.cstatic int eth16i_probe1(struct device *dev, short ioaddr)
device467drivers/net/eth16i.cstatic void eth16i_initialize(struct device *dev)
device789drivers/net/eth16i.cstatic int eth16i_open(struct device *dev)
device833drivers/net/eth16i.cstatic int eth16i_close(struct device *dev)
device859drivers/net/eth16i.cstatic int eth16i_tx(struct sk_buff *skb, struct device *dev)
device978drivers/net/eth16i.cstatic void eth16i_rx(struct device *dev)
device1091drivers/net/eth16i.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device1150drivers/net/eth16i.cstatic void eth16i_multicast(struct device *dev, int num_addrs, void *addrs)
device1163drivers/net/eth16i.cstatic struct enet_statistics *eth16i_get_stats(struct device *dev)
device1180drivers/net/eth16i.cstatic struct device dev_eth16i = {
device287drivers/net/ewrk3.cstatic int    ewrk3_open(struct device *dev);
device288drivers/net/ewrk3.cstatic int    ewrk3_queue_pkt(struct sk_buff *skb, struct device *dev);
device290drivers/net/ewrk3.cstatic int    ewrk3_close(struct device *dev);
device291drivers/net/ewrk3.cstatic struct enet_statistics *ewrk3_get_stats(struct device *dev);
device292drivers/net/ewrk3.cstatic void   set_multicast_list(struct device *dev);
device293drivers/net/ewrk3.cstatic int    ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd);
device298drivers/net/ewrk3.cstatic int    ewrk3_hw_init(struct device *dev, u_long iobase);
device299drivers/net/ewrk3.cstatic void   ewrk3_init(struct device *dev);
device300drivers/net/ewrk3.cstatic int    ewrk3_rx(struct device *dev);
device301drivers/net/ewrk3.cstatic int    ewrk3_tx(struct device *dev);
device305drivers/net/ewrk3.cstatic void   SetMulticastFilter(struct device *dev);
device310drivers/net/ewrk3.cstatic u_char get_hw_addr (struct device *dev, u_char *eeprom_image, char chipType);
device312drivers/net/ewrk3.cstatic void   isa_probe(struct device *dev, u_long iobase);
device313drivers/net/ewrk3.cstatic void   eisa_probe(struct device *dev, u_long iobase);
device314drivers/net/ewrk3.cstatic struct device *alloc_device(struct device *dev, u_long iobase);
device342drivers/net/ewrk3.cint ewrk3_probe(struct device *dev)
device374drivers/net/ewrk3.cewrk3_hw_init(struct device *dev, u_long iobase)
device612drivers/net/ewrk3.cewrk3_open(struct device *dev)
device685drivers/net/ewrk3.cewrk3_init(struct device *dev)
device720drivers/net/ewrk3.cewrk3_queue_pkt(struct sk_buff *skb, struct device *dev)
device874drivers/net/ewrk3.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device936drivers/net/ewrk3.cewrk3_rx(struct device *dev)
device1080drivers/net/ewrk3.cewrk3_tx(struct device *dev)
device1115drivers/net/ewrk3.cewrk3_close(struct device *dev)
device1158drivers/net/ewrk3.cewrk3_get_stats(struct device *dev)
device1171drivers/net/ewrk3.cset_multicast_list(struct device *dev)
device1206drivers/net/ewrk3.cstatic void SetMulticastFilter(struct device *dev)
device1290drivers/net/ewrk3.cstatic void isa_probe(struct device *dev, u_long ioaddr)
device1328drivers/net/ewrk3.cstatic void eisa_probe(struct device *dev, u_long ioaddr)
device1371drivers/net/ewrk3.cstatic struct device *alloc_device(struct device *dev, u_long iobase)
device1374drivers/net/ewrk3.cstruct device *tmp = NULL, *ret;
device1375drivers/net/ewrk3.cint (*init)(struct device *) = NULL;
device1403drivers/net/ewrk3.cdev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1416drivers/net/ewrk3.cdev->name = (char *)(dev + sizeof(struct device));
device1443drivers/net/ewrk3.ctmp->next = (struct device *)kmalloc(sizeof(struct device) + 8,
device1455drivers/net/ewrk3.ctmp->name = (char *)(tmp + sizeof(struct device));
device1587drivers/net/ewrk3.cstatic u_char get_hw_addr(struct device *dev, u_char *eeprom_image, char chipType)
device1670drivers/net/ewrk3.cstatic int ewrk3_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device1891drivers/net/ewrk3.cstatic struct device thisEthwrk = {
device95drivers/net/hp-plus.cint hp_plus_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 void 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 void hpp_mem_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device107drivers/net/hp-plus.cstatic void hpp_io_block_input(struct device *dev, int count,
device109drivers/net/hp-plus.cstatic void hpp_io_block_output(struct device *dev, int count,
device111drivers/net/hp-plus.cstatic void hpp_io_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device124drivers/net/hp-plus.cint hp_plus_probe(struct device *dev)
device147drivers/net/hp-plus.cint hpp_probe1(struct device *dev, int ioaddr)
device256drivers/net/hp-plus.chpp_open(struct device *dev)
device285drivers/net/hp-plus.chpp_close(struct device *dev)
device301drivers/net/hp-plus.chpp_reset_8390(struct device *dev)
device329drivers/net/hp-plus.chpp_io_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device340drivers/net/hp-plus.chpp_io_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device354drivers/net/hp-plus.chpp_mem_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device367drivers/net/hp-plus.chpp_mem_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device387drivers/net/hp-plus.chpp_io_block_output(struct device *dev, int count,
device397drivers/net/hp-plus.chpp_mem_block_output(struct device *dev, int count,
device416drivers/net/hp-plus.cstatic struct device dev_hpp[MAX_HPP_CARDS] = {
device436drivers/net/hp-plus.cstruct device *dev = &dev_hpp[this_dev];
device462drivers/net/hp-plus.cstruct device *dev = &dev_hpp[this_dev];
device57drivers/net/hp.cint hp_probe(struct device *dev);
device58drivers/net/hp.cint hp_probe1(struct device *dev, int ioaddr);
device60drivers/net/hp.cstatic int hp_open(struct device *dev);
device61drivers/net/hp.cstatic int hp_close(struct device *dev);
device62drivers/net/hp.cstatic void hp_reset_8390(struct device *dev);
device63drivers/net/hp.cstatic void hp_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device65drivers/net/hp.cstatic void hp_block_input(struct device *dev, int count,
device67drivers/net/hp.cstatic void hp_block_output(struct device *dev, int count,
device70drivers/net/hp.cstatic void hp_init_card(struct device *dev);
device85drivers/net/hp.cint hp_probe(struct device *dev)
device107drivers/net/hp.cint hp_probe1(struct device *dev, int ioaddr)
device210drivers/net/hp.chp_open(struct device *dev)
device218drivers/net/hp.chp_close(struct device *dev)
device226drivers/net/hp.chp_reset_8390(struct device *dev)
device249drivers/net/hp.chp_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device276drivers/net/hp.chp_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device311drivers/net/hp.chp_block_output(struct device *dev, int count,
device370drivers/net/hp.chp_init_card(struct device *dev)
device383drivers/net/hp.cstatic struct device dev_hp[MAX_HP_CARDS] = {
device403drivers/net/hp.cstruct device *dev = &dev_hp[this_dev];
device429drivers/net/hp.cstruct device *dev = &dev_hp[this_dev];
device190drivers/net/hp100.cstatic int hp100_probe1( struct device *dev, int ioaddr, int bus );
device191drivers/net/hp100.cstatic int hp100_open( struct device *dev );
device192drivers/net/hp100.cstatic int hp100_close( struct device *dev );
device193drivers/net/hp100.cstatic int hp100_start_xmit( struct sk_buff *skb, struct device *dev );
device194drivers/net/hp100.cstatic void hp100_rx( struct device *dev );
device195drivers/net/hp100.cstatic struct enet_statistics *hp100_get_stats( struct device *dev );
device196drivers/net/hp100.cstatic void hp100_update_stats( struct device *dev );
device198drivers/net/hp100.cstatic void hp100_set_multicast_list( struct device *dev);
device201drivers/net/hp100.cstatic void hp100_start_interface( struct device *dev );
device202drivers/net/hp100.cstatic void hp100_stop_interface( struct device *dev );
device203drivers/net/hp100.cstatic void hp100_load_eeprom( struct device *dev );
device204drivers/net/hp100.cstatic int hp100_sense_lan( struct device *dev );
device205drivers/net/hp100.cstatic int hp100_login_to_vg_hub( struct device *dev );
device206drivers/net/hp100.cstatic int hp100_down_vg_link( struct device *dev );
device212drivers/net/hp100.cint hp100_probe( struct device *dev )
device300drivers/net/hp100.cstatic int hp100_probe1( struct device *dev, int ioaddr, int bus )
device485drivers/net/hp100.cstatic int hp100_open( struct device *dev )
device548drivers/net/hp100.cstatic int hp100_close( struct device *dev )
device574drivers/net/hp100.cstatic int hp100_start_xmit( struct sk_buff *skb, struct device *dev )
device704drivers/net/hp100.cstatic void hp100_rx( struct device *dev )
device801drivers/net/hp100.cstatic struct enet_statistics *hp100_get_stats( struct device *dev )
device811drivers/net/hp100.cstatic void hp100_update_stats( struct device *dev )
device849drivers/net/hp100.cstatic void hp100_set_multicast_list( struct device *dev)
device895drivers/net/hp100.cstruct device *dev = (struct device *)irq2dev_map[ irq ];
device937drivers/net/hp100.cstatic void hp100_start_interface( struct device *dev )
device961drivers/net/hp100.cstatic void hp100_stop_interface( struct device *dev )
device981drivers/net/hp100.cstatic void hp100_load_eeprom( struct device *dev )
device996drivers/net/hp100.cstatic int hp100_sense_lan( struct device *dev )
device1021drivers/net/hp100.cstatic int hp100_down_vg_link( struct device *dev )
device1045drivers/net/hp100.cstatic int hp100_login_to_vg_hub( struct device *dev )
device1112drivers/net/hp100.cstatic struct device dev_hp100 = {
device117drivers/net/ibmtr.cvoid (*do_tok_int)(struct device *dev)=NULL;
device133drivers/net/ibmtr.cint tok_probe(struct device *dev);
device139drivers/net/ibmtr.cstatic void initial_tok_int(struct device *dev);
device141drivers/net/ibmtr.cstatic void open_sap(unsigned char type,struct device *dev);
device143drivers/net/ibmtr.cstatic void tr_rx(struct device *dev);
device144drivers/net/ibmtr.cstatic void tr_tx(struct device *dev);
device146drivers/net/ibmtr.cstatic int tok_open(struct device *dev);
device147drivers/net/ibmtr.cstatic int tok_close(struct device *dev);
device148drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev);
device149drivers/net/ibmtr.cstatic struct enet_statistics * tok_get_stats(struct device *dev);
device177drivers/net/ibmtr.cint tok_probe(struct device *dev)
device544drivers/net/ibmtr.cstatic int tok_open(struct device *dev) {
device572drivers/net/ibmtr.cstatic int tok_close(struct device *dev) {
device599drivers/net/ibmtr.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device880drivers/net/ibmtr.cstatic void initial_tok_int(struct device *dev) {
device949drivers/net/ibmtr.cstruct  device *dev=(struct device *)dev_addr;
device983drivers/net/ibmtr.cstatic void open_sap(unsigned char type,struct device *dev) {
device1003drivers/net/ibmtr.cstruct device *dev=(struct device *)dev_addr;
device1034drivers/net/ibmtr.cstatic void tr_tx(struct device *dev) {
device1129drivers/net/ibmtr.cstatic void tr_rx(struct device *dev) {
device1235drivers/net/ibmtr.cstatic int tok_send_packet(struct sk_buff *skb, struct device *dev) {
device1282drivers/net/ibmtr.cstatic struct enet_statistics * tok_get_stats(struct device *dev) {
device1291drivers/net/ibmtr.cstatic struct device dev_ibmtr = {
device253drivers/net/lance.cstatic int lance_open(struct device *dev);
device254drivers/net/lance.cstatic void lance_init_ring(struct device *dev);
device255drivers/net/lance.cstatic int lance_start_xmit(struct sk_buff *skb, struct device *dev);
device256drivers/net/lance.cstatic int lance_rx(struct device *dev);
device258drivers/net/lance.cstatic int lance_close(struct device *dev);
device259drivers/net/lance.cstatic struct enet_statistics *lance_get_stats(struct device *dev);
device260drivers/net/lance.cstatic void set_multicast_list(struct device *dev);
device335drivers/net/lance.cstruct device *dev;
device560drivers/net/lance.clance_open(struct device *dev)
device646drivers/net/lance.clance_purge_tx_ring(struct device *dev)
device662drivers/net/lance.clance_init_ring(struct device *dev)
device691drivers/net/lance.clance_restart(struct device *dev, unsigned int csr0_bits, int must_reinit)
device705drivers/net/lance.clance_start_xmit(struct sk_buff *skb, struct device *dev)
device831drivers/net/lance.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device957drivers/net/lance.clance_rx(struct device *dev)
device1034drivers/net/lance.clance_close(struct device *dev)
device1067drivers/net/lance.clance_get_stats(struct device *dev)
device1090drivers/net/lance.cstatic void set_multicast_list(struct device *dev)
device56drivers/net/loopback.cstatic int loopback_xmit(struct sk_buff *skb, struct device *dev)
device103drivers/net/loopback.cstatic struct enet_statistics *get_stats(struct device *dev)
device108drivers/net/loopback.cstatic int loopback_open(struct device *dev)
device115drivers/net/loopback.cint loopback_init(struct device *dev)
device99drivers/net/ne.cint ne_probe(struct device *dev);
device100drivers/net/ne.cstatic int ne_probe1(struct device *dev, int ioaddr);
device102drivers/net/ne.cstatic int ne_open(struct device *dev);
device103drivers/net/ne.cstatic int ne_close(struct device *dev);
device105drivers/net/ne.cstatic void ne_reset_8390(struct device *dev);
device106drivers/net/ne.cstatic void ne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device108drivers/net/ne.cstatic void ne_block_input(struct device *dev, int count,
device110drivers/net/ne.cstatic void ne_block_output(struct device *dev, const int count,
device144drivers/net/ne.cint ne_probe(struct device *dev)
device202drivers/net/ne.cstatic int ne_probe1(struct device *dev, int ioaddr)
device415drivers/net/ne.cne_open(struct device *dev)
device423drivers/net/ne.cne_close(struct device *dev)
device435drivers/net/ne.cne_reset_8390(struct device *dev)
device461drivers/net/ne.cne_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device498drivers/net/ne.cne_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device560drivers/net/ne.cne_block_output(struct device *dev, int count,
device664drivers/net/ne.cstatic struct device dev_ne[MAX_NE_CARDS] = {
device687drivers/net/ne.cstruct device *dev = &dev_ne[this_dev];
device714drivers/net/ne.cstruct device *dev = &dev_ne[this_dev];
device60drivers/net/net_init.cstatic struct device *ethdev_index[MAX_ETH_CARDS];
device73drivers/net/net_init.cstruct device *
device74drivers/net/net_init.cinit_etherdev(struct device *dev, int sizeof_priv)
device81drivers/net/net_init.cint alloc_size = sizeof(struct device) + sizeof("eth%d  ")
device83drivers/net/net_init.cstruct device *cur_dev;
device104drivers/net/net_init.cdev = (struct device *)kmalloc(alloc_size, GFP_KERNEL);
device128drivers/net/net_init.cstruct device **old_devp = &dev_base;
device138drivers/net/net_init.cstatic int eth_mac_addr(struct device *dev, void *p)
device147drivers/net/net_init.cvoid ether_setup(struct device *dev)
device193drivers/net/net_init.cvoid tr_setup(struct device *dev)
device223drivers/net/net_init.cint ether_config(struct device *dev, struct ifmap *map)
device240drivers/net/net_init.cint register_netdev(struct device *dev)
device242drivers/net/net_init.cstruct device *d = dev_base;
device283drivers/net/net_init.cvoid unregister_netdev(struct device *dev)
device285drivers/net/net_init.cstruct device *d = dev_base;
device162drivers/net/ni52.cstatic int     ni52_probe1(struct device *dev,int ioaddr);
device164drivers/net/ni52.cstatic int     ni52_open(struct device *dev);
device165drivers/net/ni52.cstatic int     ni52_close(struct device *dev);
device166drivers/net/ni52.cstatic int     ni52_send_packet(struct sk_buff *,struct device *);
device167drivers/net/ni52.cstatic struct  enet_statistics *ni52_get_stats(struct device *dev);
device168drivers/net/ni52.cstatic void    set_multicast_list(struct device *dev);
device171drivers/net/ni52.cstatic int     init586(struct device *dev);
device172drivers/net/ni52.cstatic int     check586(struct device *dev,char *where,unsigned size);
device173drivers/net/ni52.cstatic void    alloc586(struct device *dev);
device174drivers/net/ni52.cstatic void    startrecv586(struct device *dev);
device175drivers/net/ni52.cstatic void   *alloc_rfa(struct device *dev,void *ptr);
device176drivers/net/ni52.cstatic void    ni52_rcv_int(struct device *dev);
device177drivers/net/ni52.cstatic void    ni52_xmt_int(struct device *dev);
device178drivers/net/ni52.cstatic void    ni52_rnr_int(struct device *dev);
device206drivers/net/ni52.cstatic int ni52_close(struct device *dev)
device223drivers/net/ni52.cstatic int ni52_open(struct device *dev)
device247drivers/net/ni52.cstatic int check586(struct device *dev,char *where,unsigned size)
device284drivers/net/ni52.cvoid alloc586(struct device *dev)
device318drivers/net/ni52.cint ni52_probe(struct device *dev)
device347drivers/net/ni52.cstatic int ni52_probe1(struct device *dev,int ioaddr)
device451drivers/net/ni52.cstatic int init586(struct device *dev)
device697drivers/net/ni52.cstatic void *alloc_rfa(struct device *dev,void *ptr) 
device743drivers/net/ni52.cstruct device *dev = (struct device *) irq2dev_map[irq];
device800drivers/net/ni52.cstatic void ni52_rcv_int(struct device *dev)
device854drivers/net/ni52.cstatic void ni52_rnr_int(struct device *dev)
device876drivers/net/ni52.cstatic void ni52_xmt_int(struct device *dev)
device926drivers/net/ni52.cstatic void startrecv586(struct device *dev)
device940drivers/net/ni52.cstatic int ni52_send_packet(struct sk_buff *skb, struct device *dev)
device1067drivers/net/ni52.cstatic struct enet_statistics *ni52_get_stats(struct device *dev)
device1093drivers/net/ni52.cstatic void set_multicast_list(struct device *dev)
device116drivers/net/ni65.cstatic int   ni65_probe1(struct device *dev,int);
device118drivers/net/ni65.cstatic void recv_intr(struct device *dev);
device119drivers/net/ni65.cstatic void xmit_intr(struct device *dev);
device120drivers/net/ni65.cstatic int   ni65_open(struct device *dev);
device121drivers/net/ni65.cstatic int am7990_reinit(struct device *dev);
device122drivers/net/ni65.cstatic int   ni65_send_packet(struct sk_buff *skb, struct device *dev);
device123drivers/net/ni65.cstatic int   ni65_close(struct device *dev);
device124drivers/net/ni65.cstatic struct enet_statistics *ni65_get_stats(struct device *);
device126drivers/net/ni65.cstatic void set_multicast_list(struct device *dev);
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)
device310drivers/net/ni65.cstatic int am7990_reinit(struct device *dev)
device406drivers/net/ni65.cstruct device *dev = (struct device *) irq2dev_map[irq];
device448drivers/net/ni65.cstatic void xmit_intr(struct device *dev)
device499drivers/net/ni65.cstatic void recv_intr(struct device *dev)
device567drivers/net/ni65.cstatic int ni65_send_packet(struct sk_buff *skb, struct device *dev)
device636drivers/net/ni65.cstatic struct enet_statistics *ni65_get_stats(struct device *dev)
device641drivers/net/ni65.cstatic void set_multicast_list(struct device *dev)
device138drivers/net/pi2.cstatic int pi0_preprobe(struct device *dev){return 0;}  /* Dummy probe function */
device139drivers/net/pi2.cstatic struct device pi0a = { "pi0a", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, pi0_preprobe };
device140drivers/net/pi2.cstatic struct device pi0b = { "pi0b", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, pi0_preprobe };
device149drivers/net/pi2.cstatic int pi_probe(struct device *dev, int card_type);
device150drivers/net/pi2.cstatic int pi_open(struct device *dev);
device151drivers/net/pi2.cstatic int pi_send_packet(struct sk_buff *skb, struct device *dev);
device153drivers/net/pi2.cstatic int pi_close(struct device *dev);
device154drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
device155drivers/net/pi2.cstatic struct enet_statistics *pi_get_stats(struct device *dev);
device157drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp);
device160drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp);
device504drivers/net/pi2.cstatic void a_rxint(struct device *dev, struct pi_local *lp)
device580drivers/net/pi2.cstatic void b_rxint(struct device *dev, struct pi_local *lp)
device1077drivers/net/pi2.cstatic int pi_header(struct sk_buff *skb, struct device *dev, unsigned short type,
device1084drivers/net/pi2.cstatic int pi_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
device1090drivers/net/pi2.cstatic void scc_init(struct device *dev)
device1192drivers/net/pi2.cstatic void chipset_init(struct device *dev)
device1278drivers/net/pi2.cstatic int pi_set_mac_address(struct device *dev, struct sockaddr *sa)
device1300drivers/net/pi2.cstatic int pi_probe(struct device *dev, int card_type)
device1454drivers/net/pi2.cstatic int pi_open(struct device *dev)
device1493drivers/net/pi2.cstatic int pi_send_packet(struct sk_buff *skb, struct device *dev)
device1567drivers/net/pi2.cstatic int pi_close(struct device *dev)
device1595drivers/net/pi2.cstatic int pi_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
device1677drivers/net/pi2.cpi_get_stats(struct device *dev)
device138drivers/net/plip.cstatic void plip_kick_bh(struct device *dev);
device139drivers/net/plip.cstatic void plip_bh(struct device *dev);
device145drivers/net/plip.cstatic int plip_rebuild_header(void *buff, struct device *dev,
device147drivers/net/plip.cstatic int plip_tx_packet(struct sk_buff *skb, struct device *dev);
device148drivers/net/plip.cstatic int plip_open(struct device *dev);
device149drivers/net/plip.cstatic int plip_close(struct device *dev);
device150drivers/net/plip.cstatic struct enet_statistics *plip_get_stats(struct device *dev);
device151drivers/net/plip.cstatic int plip_config(struct device *dev, struct ifmap *map);
device152drivers/net/plip.cstatic int plip_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
device211drivers/net/plip.cint (*orig_rebuild_header)(void *eth, struct device *dev,
device218drivers/net/plip.cplip_init(struct device *dev)
device310drivers/net/plip.cplip_kick_bh(struct device *dev)
device321drivers/net/plip.cstatic int plip_none(struct device *, struct net_local *,
device323drivers/net/plip.cstatic int plip_receive_packet(struct device *, struct net_local *,
device325drivers/net/plip.cstatic int plip_send_packet(struct device *, struct net_local *,
device327drivers/net/plip.cstatic int plip_connection_close(struct device *, struct net_local *,
device329drivers/net/plip.cstatic int plip_error(struct device *, struct net_local *,
device331drivers/net/plip.cstatic int plip_bh_timeout_error(struct device *dev, struct net_local *nl,
device340drivers/net/plip.ctypedef int (*plip_func)(struct device *dev, struct net_local *nl,
device354drivers/net/plip.cplip_bh(struct device *dev)
device372drivers/net/plip.cplip_bh_timeout_error(struct device *dev, struct net_local *nl,
device436drivers/net/plip.cplip_none(struct device *dev, struct net_local *nl,
device495drivers/net/plip.cplip_receive_packet(struct device *dev, struct net_local *nl,
device658drivers/net/plip.cplip_send_packet(struct device *dev, struct net_local *nl,
device763drivers/net/plip.cplip_connection_close(struct device *dev, struct net_local *nl,
device778drivers/net/plip.cplip_error(struct device *dev, struct net_local *nl,
device805drivers/net/plip.cstruct device *dev = (struct device *) irq2dev_map[irq];
device857drivers/net/plip.cplip_rebuild_header(void *buff, struct device *dev, unsigned long dst,
device880drivers/net/plip.cplip_tx_packet(struct sk_buff *skb, struct device *dev)
device933drivers/net/plip.cplip_open(struct device *dev)
device977drivers/net/plip.cplip_close(struct device *dev)
device1012drivers/net/plip.cplip_get_stats(struct device *dev)
device1021drivers/net/plip.cplip_config(struct device *dev, struct ifmap *map)
device1036drivers/net/plip.cplip_ioctl(struct device *dev, struct ifreq *rq, int cmd)
device1060drivers/net/plip.cstatic struct device dev_plip[] = {
device181drivers/net/ppp.cint ppp_init (struct device *);
device187drivers/net/ppp.cstatic int ppp_dev_open (struct device *);
device188drivers/net/ppp.cstatic int ppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd);
device189drivers/net/ppp.cstatic int ppp_dev_close (struct device *);
device190drivers/net/ppp.cstatic int ppp_dev_xmit (sk_buff *, struct device *);
device191drivers/net/ppp.cstatic struct enet_statistics *ppp_dev_stats (struct device *);
device201drivers/net/ppp.cstatic unsigned short ppp_dev_type (sk_buff *, struct device *);
device202drivers/net/ppp.cstatic int ppp_dev_header (unsigned char *buff, struct device *dev,
device212drivers/net/ppp.cstatic int ppp_dev_header (sk_buff *, struct device *, unsigned short,
device223drivers/net/ppp.cstatic int ppp_dev_rebuild (void *, struct device *, unsigned long,
device258drivers/net/ppp.c#define ppp2dev(ppp)  ((struct device *) ppp->dev)
device272drivers/net/ppp.cstruct device   dev;    /* Device information table  */
device278drivers/net/ppp.c#define ctl2dev(ctl) (struct device *) &ctl->dev
device460drivers/net/ppp.cppp_init_dev (struct device *dev)
device552drivers/net/ppp.cppp_init (struct device *dev)
device642drivers/net/ppp.cstruct device *dev;
device770drivers/net/ppp.cstruct device *dev;
device2693drivers/net/ppp.cppp_dev_open (struct device *dev)
device2722drivers/net/ppp.cppp_dev_close (struct device *dev)
device2775drivers/net/ppp.cppp_dev_ioctl_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
device2818drivers/net/ppp.cppp_dev_ioctl_comp_stats (struct ppp *ppp, struct ifreq *ifr, struct device *dev)
device2855drivers/net/ppp.cppp_dev_ioctl (struct device *dev, struct ifreq *ifr, int cmd)
device2890drivers/net/ppp.cppp_dev_xmit_ip1 (struct device *dev, struct ppp *ppp, u_char *data)
device2987drivers/net/ppp.cppp_dev_xmit_ip (struct device *dev, struct ppp *ppp, u_char *data)
device3019drivers/net/ppp.cppp_dev_xmit_ipx1 (struct device *dev, struct ppp *ppp,
device3090drivers/net/ppp.cppp_dev_xmit_ipx (struct device *dev, struct ppp *ppp,
device3116drivers/net/ppp.cppp_dev_xmit (sk_buff *skb, struct device *dev)
device3198drivers/net/ppp.cppp_dev_stats (struct device *dev)
device3276drivers/net/ppp.cppp_dev_type (sk_buff *skb, struct device *dev)
device3283drivers/net/ppp.cstatic int ppp_dev_header (unsigned char *buff, struct device *dev,
device3287drivers/net/ppp.cstatic int ppp_dev_header (sk_buff *skb, struct device *dev,
device3296drivers/net/ppp.cppp_dev_rebuild (void *buff, struct device *dev, unsigned long raddr,
device3315drivers/net/ppp.cstruct device  *dev;
device3547drivers/net/ppp.cstruct device *dev;
device106drivers/net/pt.cstatic int pt0_preprobe(struct device *dev) {return 0;} /* Dummy probe function */
device107drivers/net/pt.cstatic struct device pt0a = { "pt0a", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, pt0_preprobe };
device108drivers/net/pt.cstatic struct device pt0b = { "pt0b", 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, pt0_preprobe };
device120drivers/net/pt.cstatic int pt_probe(struct device *dev);
device121drivers/net/pt.cstatic int pt_open(struct device *dev);
device122drivers/net/pt.cstatic int pt_send_packet(struct sk_buff *skb, struct device *dev);
device124drivers/net/pt.cstatic int pt_close(struct device *dev);
device125drivers/net/pt.cstatic int pt_ioctl(struct device *dev, struct ifreq *ifr, int cmd);
device126drivers/net/pt.cstatic struct enet_statistics *pt_get_stats(struct device *dev);
device128drivers/net/pt.cstatic void pt_rxisr(struct device *dev);
device137drivers/net/pt.cstatic void chipset_init(struct device *dev);
device138drivers/net/pt.cstatic void send_kiss(struct device *dev, unsigned char arg, unsigned char val);
device182drivers/net/pt.cstruct device *dev;
device339drivers/net/pt.cstatic int pt_header (struct sk_buff *skb, struct device *dev, unsigned short type,
device347drivers/net/pt.cstatic int pt_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
device361drivers/net/pt.cstatic void scc_init(struct device *dev)
device484drivers/net/pt.cstatic void chipset_init(struct device *dev)
device741drivers/net/pt.cstatic int pt_set_mac_address(struct device *dev, struct sockaddr *sa)
device767drivers/net/pt.cstatic int pt_probe(struct device *dev)
device923drivers/net/pt.cstatic int pt_open(struct device *dev)
device972drivers/net/pt.cstatic int pt_send_packet(struct sk_buff *skb, struct device *dev)
device995drivers/net/pt.cstatic int pt_close(struct device *dev)
device1029drivers/net/pt.cstatic int pt_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
device1111drivers/net/pt.cpt_get_stats(struct device *dev)
device1264drivers/net/pt.cstatic void pt_rxisr(struct device *dev)
device1486drivers/net/pt.cstruct device *dev = &pt0a;
device1808drivers/net/pt.cstatic void send_kiss(struct device *dev, unsigned char arg, unsigned char val)
device79drivers/net/seeq8005.cextern int seeq8005_probe(struct device *dev);
device81drivers/net/seeq8005.cstatic int seeq8005_probe1(struct device *dev, int ioaddr);
device82drivers/net/seeq8005.cstatic int seeq8005_open(struct device *dev);
device83drivers/net/seeq8005.cstatic int seeq8005_send_packet(struct sk_buff *skb, struct device *dev);
device85drivers/net/seeq8005.cstatic void seeq8005_rx(struct device *dev);
device86drivers/net/seeq8005.cstatic int seeq8005_close(struct device *dev);
device87drivers/net/seeq8005.cstatic struct enet_statistics *seeq8005_get_stats(struct device *dev);
device88drivers/net/seeq8005.cstatic void set_multicast_list(struct device *dev);
device92drivers/net/seeq8005.cextern void hardware_send_packet(struct device *dev, char *buf, int length);
device93drivers/net/seeq8005.cextern void seeq8005_init(struct device *dev, int startp);
device94drivers/net/seeq8005.cinline void wait_for_buffer(struct device *dev);
device110drivers/net/seeq8005.cseeq8005_probe(struct device *dev)
device136drivers/net/seeq8005.cstatic int seeq8005_probe1(struct device *dev, int ioaddr)
device348drivers/net/seeq8005.cseeq8005_open(struct device *dev)
device374drivers/net/seeq8005.cseeq8005_send_packet(struct sk_buff *skb, struct device *dev)
device423drivers/net/seeq8005.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device473drivers/net/seeq8005.cseeq8005_rx(struct device *dev)
device571drivers/net/seeq8005.cseeq8005_close(struct device *dev)
device597drivers/net/seeq8005.cseeq8005_get_stats(struct device *dev)
device611drivers/net/seeq8005.cset_multicast_list(struct device *dev)
device633drivers/net/seeq8005.cvoid seeq8005_init(struct device *dev, int startp)
device693drivers/net/seeq8005.cvoid hardware_send_packet(struct device * dev, char *buf, int length)
device738drivers/net/seeq8005.cinline void wait_for_buffer(struct device * dev)
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);
device499drivers/net/sk_g16.cstatic void set_multicast_list(struct device *dev);
device506drivers/net/sk_g16.cstatic int SK_lance_init(struct device *dev, unsigned short mode);
device518drivers/net/sk_g16.cvoid SK_print_pos(struct device *dev, char *text);
device519drivers/net/sk_g16.cvoid SK_print_dev(struct device *dev, char *text);
device520drivers/net/sk_g16.cvoid SK_print_ram(struct device *dev);
device550drivers/net/sk_g16.cint SK_init(struct device *dev)
device634drivers/net/sk_g16.cint SK_probe(struct device *dev, short ioaddr)
device861drivers/net/sk_g16.cstatic int SK_open(struct device *dev)
device1026drivers/net/sk_g16.cstatic int SK_lance_init(struct device *dev, unsigned short mode)
device1192drivers/net/sk_g16.cstatic int SK_send_packet(struct sk_buff *skb, struct device *dev)
device1314drivers/net/sk_g16.cstruct device *dev = (struct device *) irq2dev_map[irq];
device1386drivers/net/sk_g16.cstatic void SK_txintr(struct device *dev)
device1505drivers/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)
device1733drivers/net/sk_g16.cstatic void set_multicast_list(struct device *dev)
device1996drivers/net/sk_g16.cvoid SK_print_pos(struct device *dev, char *text)
device2031drivers/net/sk_g16.cvoid SK_print_dev(struct device *dev, char *text)
device2074drivers/net/sk_g16.cvoid SK_print_ram(struct device *dev)
device98drivers/net/skeleton.cextern int netcard_probe(struct device *dev);
device100drivers/net/skeleton.cstatic int netcard_probe1(struct device *dev, int ioaddr);
device101drivers/net/skeleton.cstatic int net_open(struct device *dev);
device102drivers/net/skeleton.cstatic int  net_send_packet(struct sk_buff *skb, struct device *dev);
device104drivers/net/skeleton.cstatic void net_rx(struct device *dev);
device105drivers/net/skeleton.cstatic int net_close(struct device *dev);
device106drivers/net/skeleton.cstatic struct enet_statistics *net_get_stats(struct device *dev);
device107drivers/net/skeleton.cstatic void set_multicast_list(struct device *dev);
device112drivers/net/skeleton.cextern void chipset_init(struct device *dev, int startp);
device130drivers/net/skeleton.cnetcard_probe(struct device *dev)
device157drivers/net/skeleton.cstatic int netcard_probe1(struct device *dev, int ioaddr)
device308drivers/net/skeleton.cnet_open(struct device *dev)
device344drivers/net/skeleton.cnet_send_packet(struct sk_buff *skb, struct device *dev)
device402drivers/net/skeleton.cstruct device *dev = (struct device *)(irq2dev_map[irq]);
device438drivers/net/skeleton.cnet_rx(struct device *dev)
device491drivers/net/skeleton.cnet_close(struct device *dev)
device526drivers/net/skeleton.cnet_get_stats(struct device *dev)
device547drivers/net/skeleton.cset_multicast_list(struct device *dev)
device576drivers/net/skeleton.cstatic struct device this_device = {
device97drivers/net/slip.cstruct device  dev;    /* the device      */
device225drivers/net/slip.cstruct device *dev = sl->dev;
device487drivers/net/slip.csl_xmit(struct sk_buff *skb, struct device *dev)
device539drivers/net/slip.csl_header(struct sk_buff *skb, struct device *dev, unsigned short type,
device557drivers/net/slip.csl_rebuild_header(void *buff, struct device *dev, unsigned long raddr,
device575drivers/net/slip.csl_open(struct device *dev)
device668drivers/net/slip.csl_close(struct device *dev)
device813drivers/net/slip.csl_get_stats(struct device *dev)
device1010drivers/net/slip.csl_set_mac_address(struct device *dev, void *addr)
device1025drivers/net/slip.csl_set_dev_mac_address(struct device *dev, void *addr)
device1179drivers/net/slip.cstatic int sl_open_dev(struct device *dev)
device1191drivers/net/slip.cint slip_init_ctrl_dev(struct device *dummy)
device1256drivers/net/slip.cslip_init(struct device *dev)
device53drivers/net/slip.hstruct device    *dev;    /* easy for intr handling  */
device114drivers/net/slip.hextern int slip_init(struct device *dev);
device65drivers/net/smc-ultra.cint ultra_probe(struct device *dev);
device66drivers/net/smc-ultra.cint ultra_probe1(struct device *dev, int ioaddr);
device68drivers/net/smc-ultra.cstatic int ultra_open(struct device *dev);
device69drivers/net/smc-ultra.cstatic void ultra_reset_8390(struct device *dev);
device70drivers/net/smc-ultra.cstatic void ultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, 
device72drivers/net/smc-ultra.cstatic void ultra_block_input(struct device *dev, int count,
device74drivers/net/smc-ultra.cstatic void ultra_block_output(struct device *dev, int count,
device76drivers/net/smc-ultra.cstatic int ultra_close_card(struct device *dev);
device96drivers/net/smc-ultra.cint ultra_probe(struct device *dev)
device118drivers/net/smc-ultra.cint ultra_probe1(struct device *dev, int ioaddr)
device232drivers/net/smc-ultra.cultra_open(struct device *dev)
device248drivers/net/smc-ultra.cultra_reset_8390(struct device *dev)
device267drivers/net/smc-ultra.cultra_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device286drivers/net/smc-ultra.cultra_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device308drivers/net/smc-ultra.cultra_block_output(struct device *dev, int count, const unsigned char *buf,
device322drivers/net/smc-ultra.cultra_close_card(struct device *dev)
device351drivers/net/smc-ultra.cstatic struct device dev_ultra[MAX_ULTRA_CARDS] = {
device371drivers/net/smc-ultra.cstruct device *dev = &dev_ultra[this_dev];
device397drivers/net/smc-ultra.cstruct device *dev = &dev_ultra[this_dev];
device208drivers/net/sunlance.clance_init_ring (struct device *dev)
device304drivers/net/sunlance.clance_rx (struct device *dev)
device417drivers/net/sunlance.clance_tx (struct device *dev)
device464drivers/net/sunlance.cstruct device *dev = (struct device *) (irq2dev_map [irq]);
device505drivers/net/sunlance.cstruct device *last_dev = 0;
device508drivers/net/sunlance.clance_open (struct device *dev)
device560drivers/net/sunlance.clance_close (struct device *dev)
device578drivers/net/sunlance.cinline static int lance_reset (struct device *dev)
device602drivers/net/sunlance.cstatic int lance_start_xmit (struct sk_buff *skb, struct device *dev)
device687drivers/net/sunlance.clance_get_stats (struct device *dev)
device695drivers/net/sunlance.clance_set_multicast (struct device *dev)
device717drivers/net/sunlance.cint sparc_lance_probe (struct device *dev)
device154drivers/net/tulip.cstatic int tulip_open(struct device *dev);
device155drivers/net/tulip.cstatic void tulip_init_ring(struct device *dev);
device156drivers/net/tulip.cstatic int tulip_start_xmit(struct sk_buff *skb, struct device *dev);
device157drivers/net/tulip.cstatic int tulip_rx(struct device *dev);
device159drivers/net/tulip.cstatic int tulip_close(struct device *dev);
device160drivers/net/tulip.cstatic struct enet_statistics *tulip_get_stats(struct device *dev);
device161drivers/net/tulip.cstatic void set_multicast_list(struct device *dev);
device162drivers/net/tulip.cstatic int set_mac_address(struct device *dev, void *addr);
device201drivers/net/tulip.cstatic int tulip_probe(struct device *dev)
device211drivers/net/tulip.cstruct device *dev;
device265drivers/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)
device635drivers/net/tulip.ctulip_close(struct device *dev)
device662drivers/net/tulip.ctulip_get_stats(struct device *dev)
device676drivers/net/tulip.cstatic void set_multicast_list(struct device *dev)
device727drivers/net/tulip.cset_mac_address(struct device *dev, void *addr)
device742drivers/net/tulip.cstatic struct device dev_tulip = {
device42drivers/net/tunnel.cstatic int tunnel_xmit(struct sk_buff *skb, struct device *dev);
device43drivers/net/tunnel.cstatic struct enet_statistics *tunnel_get_stats(struct device *dev);
device46drivers/net/tunnel.cstatic int tunnel_open(struct device *dev)
device52drivers/net/tunnel.cstatic int tunnel_close(struct device *dev)
device61drivers/net/tunnel.cint tunnel_init(struct device *dev)
device123drivers/net/tunnel.cstatic int tunnel_xmit(struct sk_buff *skb, struct device *dev)
device269drivers/net/tunnel.ctunnel_get_stats(struct device *dev)
device276drivers/net/tunnel.cstatic int tunnel_probe(struct device *dev)
device282drivers/net/tunnel.cstatic struct device dev_tunnel = {
device44drivers/net/wavelan.ctypedef struct device    device;
device65drivers/net/wavelan.cdevice    *dev;
device70drivers/net/wavelan.cextern int    wavelan_probe(device *);  /* See Space.c */
device77drivers/net/wavelan.cstatic int    wavelan_probe1(device *, unsigned short);
device78drivers/net/wavelan.cstatic int    wavelan_open(device *);
device79drivers/net/wavelan.cstatic int    wavelan_send_packet(struct sk_buff *, device *);
device81drivers/net/wavelan.cstatic int    wavelan_close(device *);
device82drivers/net/wavelan.cstatic en_stats    *wavelan_get_stats(device *);
device83drivers/net/wavelan.cstatic void    wavelan_set_multicast_list(device *);
device89drivers/net/wavelan.cstatic void    wavelan_cu_show_one(device *, net_local *, int, unsigned short);
device90drivers/net/wavelan.cstatic void    wavelan_cu_start(device *);
device91drivers/net/wavelan.cstatic void    wavelan_ru_start(device *);
device98drivers/net/wavelan.cstatic void    wavelan_ru_show(device *);
device99drivers/net/wavelan.cstatic void    wavelan_cu_show(device *);
device100drivers/net/wavelan.cstatic void    wavelan_dev_show(device *);
device101drivers/net/wavelan.cstatic void    wavelan_local_show(device *);
device189drivers/net/wavelan.cwavelan_ints_off(device *dev)
device208drivers/net/wavelan.cwavelan_ints_on(device *dev)
device379drivers/net/wavelan.cwavelan_mmc_init(device *dev, psa_t *psa)
device456drivers/net/wavelan.cwavelan_ack(device *dev)
device495drivers/net/wavelan.cwavelan_synchronous_cmd(device *dev, const char *str)
device534drivers/net/wavelan.cwavelan_hardware_reset(device *dev)
device773drivers/net/wavelan.cwavelan_probe(device *dev)
device784drivers/net/wavelan.cuse 0x390 and leave 0x300 for the Ethernet device.
device856drivers/net/wavelan.cwavelan_probe1(device *dev, unsigned short ioaddr)
device1070drivers/net/wavelan.cwavelan_ru_start(device *dev)
device1137drivers/net/wavelan.cwavelan_cu_start(device *dev)
device1216drivers/net/wavelan.cwavelan_open(device *dev)
device1238drivers/net/wavelan.cirq2dev_map[dev->irq] != (device *)0
device1241drivers/net/wavelan.c(irq2dev_map[dev->irq] = dev) == (device *)0
device1246drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device1263drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device1279drivers/net/wavelan.chardware_send_packet(device *dev, void *buf, short length)
device1389drivers/net/wavelan.cwavelan_send_packet(struct sk_buff *skb, device *dev)
device1481drivers/net/wavelan.cwavelan_receive(device *dev)
device1710drivers/net/wavelan.cwavelan_complete(device *dev, unsigned short ioaddr, net_local *lp)
device1816drivers/net/wavelan.cdevice    *dev;
device1824drivers/net/wavelan.cdev = (device *)a;
device1861drivers/net/wavelan.cdevice    *dev;
device1868drivers/net/wavelan.cif ((dev = (device *)(irq2dev_map[irq])) == (device *)0)
device1963drivers/net/wavelan.cwavelan_close(device *dev)
device1988drivers/net/wavelan.cirq2dev_map[dev->irq] = (device *)0;
device2009drivers/net/wavelan.cwavelan_get_stats(device *dev)
device2020drivers/net/wavelan.cwavelan_set_multicast_list(device *dev)
device2069drivers/net/wavelan.csprintf_stats(char *buffer, device *dev)
device2170drivers/net/wavelan.cstatic struct device  dev_wavelan    =
device2204drivers/net/wavelan.cwavelan_cu_show_one(device *dev, net_local *lp, int i, unsigned short p)
device2415drivers/net/wavelan.cwavelan_ru_show(device *dev)
device2430drivers/net/wavelan.cwavelan_cu_show(device *dev)
device2453drivers/net/wavelan.cwavelan_dev_show(device *dev)
device2466drivers/net/wavelan.cwavelan_local_show(device *dev)
device47drivers/net/wd.cint wd_probe(struct device *dev);
device48drivers/net/wd.cint wd_probe1(struct device *dev, int ioaddr);
device50drivers/net/wd.cstatic int wd_open(struct device *dev);
device51drivers/net/wd.cstatic void wd_reset_8390(struct device *dev);
device52drivers/net/wd.cstatic void wd_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
device54drivers/net/wd.cstatic void wd_block_input(struct device *dev, int count,
device56drivers/net/wd.cstatic void wd_block_output(struct device *dev, int count,
device58drivers/net/wd.cstatic int wd_close_card(struct device *dev);
device88drivers/net/wd.cint wd_probe(struct device *dev)
device110drivers/net/wd.cint wd_probe1(struct device *dev, int ioaddr)
device310drivers/net/wd.cwd_open(struct device *dev)
device329drivers/net/wd.cwd_reset_8390(struct device *dev)
device351drivers/net/wd.cwd_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
device376drivers/net/wd.cwd_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
device398drivers/net/wd.cwd_block_output(struct device *dev, int count, const unsigned char *buf,
device416drivers/net/wd.cwd_close_card(struct device *dev)
device441drivers/net/wd.cstatic struct device dev_wd[MAX_WD_CARDS] = {
device463drivers/net/wd.cstruct device *dev = &dev_wd[this_dev];
device491drivers/net/wd.cstruct device *dev = &dev_wd[this_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);
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)
device594drivers/net/znet.cstatic int znet_close(struct device *dev)
device619drivers/net/znet.cstatic struct enet_statistics *net_get_stats(struct device *dev)
device634drivers/net/znet.cstatic void set_multicast_list(struct device *dev)
device675drivers/net/znet.cstatic void hardware_init(struct device *dev)
device306drivers/pci/pci.corder = dev_info[i].device - (long) dev;
device481drivers/pci/pci.cconst char *pci_strdev(unsigned int vendor, unsigned int device)
device485drivers/pci/pci.cinfo =   pci_lookup_dev(vendor, device);
device547drivers/pci/pci.cunsigned short vendor, device, status;
device557drivers/pci/pci.cpcibios_read_config_word (bus, devfn, PCI_DEVICE_ID, &device);
device574drivers/pci/pci.cpci_strdev(vendor, device), class_rev & 0xff);
device576drivers/pci/pci.cif (!pci_lookup_dev(vendor, device)) {
device579drivers/pci/pci.cvendor, device);
device765drivers/pci/pci.cdev->device = (l >> 16) & 0xffff;
device772drivers/pci/pci.cinfo = pci_lookup_dev(dev->vendor, dev->device);
device775drivers/pci/pci.cdev->vendor, dev->device);
device506drivers/scsi/53c7,8xx.cint device;
device595drivers/scsi/53c7,8xx.coverrides[commandline_current].data.pci.device = ints[2];
device1543drivers/scsi/53c7,8xx.c(((overrides[current_override].data.pci.device
device3423drivers/scsi/53c7,8xx.ccmd->device && cmd->device->has_cmdblocks
device828drivers/scsi/AM53C974.ccmd->device->disconnect = 0;
device1116drivers/scsi/AM53C974.cif (!hostdata->connected->device->tagged_queue)
device1191drivers/scsi/AM53C974.cif (cmd->device->disconnect) {
device1606drivers/scsi/AM53C974.ccmd->device->disconnect = 0;
device1667drivers/scsi/AM53C974.ccmd->device->tagged_queue = 0;
device1680drivers/scsi/AM53C974.ccmd->device->disconnect = 1;
device1803drivers/scsi/AM53C974.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
device1807drivers/scsi/AM53C974.cif (cmd->device->current_tag == 0) cmd->device->current_tag = 1;
device1808drivers/scsi/AM53C974.ccmd->tag = cmd->device->current_tag;
device1809drivers/scsi/AM53C974.ccmd->device->current_tag++; }
device338drivers/scsi/AM53C974.hunsigned short device;
device343drivers/scsi/AM53C974.h#define _device dv_id.dv.device
device2127drivers/scsi/BusLogic.cCommand->device->tagged_supported &&
device2477drivers/scsi/BusLogic.c(BusLogic_HostAdapter_T *) Disk->device->host->hostdata;
device1522drivers/scsi/NCR5380.cif (cmd->device->tagged_queue && (tag != TAG_NONE)) {
device1526drivers/scsi/NCR5380.cif (cmd->device->current_tag == 0)
device1527drivers/scsi/NCR5380.ccmd->device->current_tag = 1;
device1529drivers/scsi/NCR5380.ccmd->tag = cmd->device->current_tag;
device1530drivers/scsi/NCR5380.ccmd->device->current_tag++;
device1554drivers/scsi/NCR5380.cif (!cmd->device->tagged_queue)
device2235drivers/scsi/NCR5380.cif (!cmd->device->borken &&
device2246drivers/scsi/NCR5380.cif (!cmd->device->borken && transfersize && 
device2260drivers/scsi/NCR5380.ccmd->device->borken = 1;
device2411drivers/scsi/NCR5380.ccmd->device->tagged_queue = 0;
device2420drivers/scsi/NCR5380.ccmd->device->disconnect = 1;
device3410drivers/scsi/advansys.cif ((ASC_BOARD(dp->device->host)->board.dvc_cntl & ASC_CNTL_BIOS_GT_1GB) &&
device1144drivers/scsi/aha152x.cif(ptr && !ptr->device->soft_reset)
device1157drivers/scsi/aha152x.cif(!ptr->device->soft_reset)
device1089drivers/scsi/aha1542.c!(HOSTDATA(shost)->SCint[i]->device->soft_reset))
device1300drivers/scsi/aha1542.ctranslation_algorithm = HOSTDATA(disk->device->host)->bios_translation;
device1812drivers/scsi/aic7xxx.cscb->cmd->device->tagged_supported = 0;
device1813drivers/scsi/aic7xxx.cscb->cmd->device->tagged_queue = 0;
device4032drivers/scsi/aic7xxx.cif (cmd->device->tagged_supported)
device4034drivers/scsi/aic7xxx.cif (cmd->device->tagged_queue == 0)
device4038drivers/scsi/aic7xxx.ccmd->device->tagged_queue = 1;
device4039drivers/scsi/aic7xxx.ccmd->device->current_tag = 1;  /* enable tagging */
device4041drivers/scsi/aic7xxx.ccmd->tag = cmd->device->current_tag;
device4042drivers/scsi/aic7xxx.ccmd->device->current_tag++;
device4589drivers/scsi/aic7xxx.cp = (struct aic7xxx_host *) disk->device->host->hostdata;
device978drivers/scsi/eata.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
device983drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
device989drivers/scsi/eata.c&& SCpnt->device->type == TYPE_DISK
device999drivers/scsi/eata.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
device1022drivers/scsi/eata.cif (SCpnt->device->type != TYPE_TAPE)
device220drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
device246drivers/scsi/eata_dma.c&& cmd->device->type == TYPE_DISK
device266drivers/scsi/eata_dma.cif (cmd->device->type != TYPE_TAPE)
device290drivers/scsi/eata_dma.c|| cmd->scsi_done == NULL || cmd->device->id == 7) 
device294drivers/scsi/eata_dma.ccmd->device->channel, cmd->device->id, cmd->device->lun,
device178drivers/scsi/eata_dma_proc.cscmd.device = &SDev;
device1949drivers/scsi/fdomain.cretcode = kernel_scsi_ioctl( disk->device,
device540drivers/scsi/scsi.cSCpnt->device = SDpnt;
device839drivers/scsi/scsi.cScsi_Cmnd * request_queueable (struct request * req, Scsi_Device * device)
device846drivers/scsi/scsi.cif (!device)
device852drivers/scsi/scsi.cSCpnt =  device->host->host_queue;
device860drivers/scsi/scsi.cSCpnt = device->host->host_queue;
device861drivers/scsi/scsi.cif (!device->single_lun) {
device863drivers/scsi/scsi.cif(SCpnt->target == device->id &&
device864drivers/scsi/scsi.cSCpnt->lun == device->lun) {
device871drivers/scsi/scsi.cif(SCpnt->target == device->id) {
device872drivers/scsi/scsi.cif (SCpnt->lun == device->lun) {
device895drivers/scsi/scsi.cif (SCSI_BLOCK(device->host)) return NULL;
device899drivers/scsi/scsi.ctablesize = device->host->sg_tablesize;
device944drivers/scsi/scsi.cSCpnt->channel = device->channel;
device945drivers/scsi/scsi.cSCpnt->lun = device->lun;
device946drivers/scsi/scsi.cSCpnt->target = device->id;
device961drivers/scsi/scsi.cScsi_Cmnd * allocate_device (struct request ** reqp, Scsi_Device * device,
device974drivers/scsi/scsi.cif (!device)
device986drivers/scsi/scsi.chost = device->host;
device991drivers/scsi/scsi.cSCpnt = device->host->host_queue;
device992drivers/scsi/scsi.cif (!device->single_lun) {
device994drivers/scsi/scsi.cif(SCpnt->target == device->id &&
device995drivers/scsi/scsi.cSCpnt->lun == device->lun) {
device1003drivers/scsi/scsi.cif(SCpnt->target == device->id) {
device1004drivers/scsi/scsi.cif (SCpnt->lun == device->lun) {
device1041drivers/scsi/scsi.c"lun %d\n", device->channel, device->id, device->lun);
device1044drivers/scsi/scsi.cSCSI_SLEEP(&device->device_wait,
device1049drivers/scsi/scsi.ctablesize = device->host->sg_tablesize;
device1101drivers/scsi/scsi.cSCpnt->channel = device->channel;
device1102drivers/scsi/scsi.cSCpnt->lun = device->lun;
device1103drivers/scsi/scsi.cSCpnt->target = device->id;
device1359drivers/scsi/scsi.cif( SCpnt->device->expecting_cc_ua )
device1361drivers/scsi/scsi.cSCpnt->device->expecting_cc_ua = 0;
device1791drivers/scsi/scsi.cif ((SCpnt->flags & IS_RESETTING) && SCpnt->device->soft_reset) {
device1884drivers/scsi/scsi.cscsi_mark_device_reset(SCpnt->device);
device1998drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
device2008drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
device2017drivers/scsi/scsi.celse scsi_mark_device_reset(SCpnt->device);
device2291drivers/scsi/scsi.cSCpnt->device = SDpnt;
device2988drivers/scsi/scsi.cif(SCpnt->device == SDpnt)
device346drivers/scsi/scsi.hScsi_Device * device;
device507drivers/scsi/scsi.hwake_up(&SCpnt->device->device_wait);
device152drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
device272drivers/scsi/scsi_ioctl.cif(SCpnt->device->scsi_request_fn)
device273drivers/scsi/scsi_ioctl.c(*SCpnt->device->scsi_request_fn)();
device275drivers/scsi/scsi_ioctl.cwake_up(&SCpnt->device->device_wait);
device63drivers/scsi/sd.cSC->device->type != TYPE_MOD)
device99drivers/scsi/sd.cif(target >= sd_template.dev_max || !rscsi_disks[target].device)
device108drivers/scsi/sd.cwhile (rscsi_disks[target].device->busy)
device110drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
device129drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
device140drivers/scsi/sd.crscsi_disks[target].device->access_count++;
device141drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
device142drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)++;
device154drivers/scsi/sd.crscsi_disks[target].device->access_count--;
device155drivers/scsi/sd.cif (rscsi_disks[target].device->host->hostt->usage_count)
device156drivers/scsi/sd.c(*rscsi_disks[target].device->host->hostt->usage_count)--;
device159drivers/scsi/sd.cif(rscsi_disks[target].device->removable) {
device160drivers/scsi/sd.cif(!rscsi_disks[target].device->access_count)
device202drivers/scsi/sd.cif(rscsi_disks[i].device) 
device345drivers/scsi/sd.cif(rscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->removable) {
device349drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
device387drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no,
device388drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->channel,
device389drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
device390drivers/scsi/sd.crscsi_disks[DEVICE_NR(SCpnt->request.rq_dev)].device->lun, result);
device423drivers/scsi/sd.cSDev = rscsi_disks[DEVICE_NR(CURRENT->rq_dev)].device;
device460drivers/scsi/sd.crscsi_disks[DEVICE_NR(CURRENT->rq_dev)].device, 0); 
device485drivers/scsi/sd.cSCpnt = request_queueable(req, rscsi_disks[DEVICE_NR(req->rq_dev)].device);
device533drivers/scsi/sd.c!rscsi_disks[dev].device ||
device542drivers/scsi/sd.cif (rscsi_disks[dev].device->changed)
device579drivers/scsi/sd.cif (!rscsi_disks[dev].device->writeable)
device892drivers/scsi/sd.c(SCpnt->device->type == TYPE_DISK ? 
device906drivers/scsi/sd.c!rscsi_disks[target].device) {
device911drivers/scsi/sd.cif(!rscsi_disks[target].device->removable) return 0;
device922drivers/scsi/sd.crscsi_disks[target].device->changed = 1;
device935drivers/scsi/sd.cretval = rscsi_disks[target].device->changed;
device936drivers/scsi/sd.cif(!flag) rscsi_disks[target].device->changed = 0;
device965drivers/scsi/sd.cSCpnt = allocate_device(NULL, rscsi_disks[i].device, 1);
device977drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device1004drivers/scsi/sd.cif(the_result && !rscsi_disks[i].device->removable && 
device1010drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device1050drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device1076drivers/scsi/sd.cwake_up(&SCpnt->device->device_wait); 
device1117drivers/scsi/sd.cif(rscsi_disks[i].device->removable && 
device1119drivers/scsi/sd.crscsi_disks[i].device->changed = 1;
device1149drivers/scsi/sd.cif(rscsi_disks[i].device->removable){
device1153drivers/scsi/sd.crscsi_disks[i].device = NULL;
device1184drivers/scsi/sd.cif ( rscsi_disks[i].device->removable && rscsi_disks[i].ready ) {
device1196drivers/scsi/sd.ccmd[1] = (rscsi_disks[i].device->lun << 5) & 0xe0;
device1217drivers/scsi/sd.cwake_up(&SCpnt->device->device_wait); 
device1305drivers/scsi/sd.crscsi_disks[i].device)
device1322drivers/scsi/sd.cif(rscsi_disks[0].device && rscsi_disks[0].device->host->sg_tablesize)
device1352drivers/scsi/sd.cif(!dpnt->device) break;
device1357drivers/scsi/sd.crscsi_disks[i].device = SDp;
device1364drivers/scsi/sd.c#define DEVICE_BUSY rscsi_disks[target].device->busy
device1365drivers/scsi/sd.c#define USAGE rscsi_disks[target].device->access_count
device1440drivers/scsi/sd.cif(dpnt->device == SDp) {
device1459drivers/scsi/sd.cdpnt->device = NULL;
device31drivers/scsi/sd.hScsi_Device   *device;      
device36drivers/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);
device656drivers/scsi/seagate.cborken = (int) SCint->device->borken;
device1647drivers/scsi/seagate.cif (disk->device->scsi_level < 2) 
device1654drivers/scsi/seagate.ccmd[1] = (disk->device->lun << 5) & 0xe5;
device1670drivers/scsi/seagate.cif (!(result = kernel_scsi_ioctl (disk->device, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) {
device1683drivers/scsi/seagate.cif (!(result = kernel_scsi_ioctl (disk->device, SCSI_IOCTL_SEND_COMMAND, (void *) buf))) {
device49drivers/scsi/sg.cScsi_Device *device;
device84drivers/scsi/sg.creturn scsi_ioctl(scsi_generics[dev].device, cmd_in, (void *) arg);
device92drivers/scsi/sg.cif (dev>=sg_template.dev_max || !scsi_generics[dev].device)
device143drivers/scsi/sg.cif (scsi_generics[dev].device->host->hostt->usage_count)
device144drivers/scsi/sg.c(*scsi_generics[dev].device->host->hostt->usage_count)++;
device154drivers/scsi/sg.cif (scsi_generics[dev].device->host->hostt->usage_count)
device155drivers/scsi/sg.c(*scsi_generics[dev].device->host->hostt->usage_count)--;
device204drivers/scsi/sg.cstruct scsi_generic *device=&scsi_generics[dev];
device213drivers/scsi/sg.cwhile(!device->pending || !device->complete)
device220drivers/scsi/sg.cinterruptible_sleep_on(&device->read_wait);
device232drivers/scsi/sg.cdevice->header.pack_len=device->header.reply_len;
device233drivers/scsi/sg.cdevice->header.result=0;
device236drivers/scsi/sg.cmemcpy_tofs(buf,&device->header,sizeof(struct sg_header));
device238drivers/scsi/sg.cif (count>device->header.pack_len)
device239drivers/scsi/sg.ccount=device->header.pack_len;
device241drivers/scsi/sg.cmemcpy_tofs(buf,device->buff,count-sizeof(struct sg_header));
device251drivers/scsi/sg.csg_free(device->buff,device->buff_len);
device252drivers/scsi/sg.cdevice->buff = NULL;
device253drivers/scsi/sg.cdevice->pending=0;
device254drivers/scsi/sg.cwake_up(&device->write_wait);
device266drivers/scsi/sg.cstruct scsi_generic *device = &scsi_generics[dev];
device267drivers/scsi/sg.cif (!device->pending)
device278drivers/scsi/sg.cmemcpy(device->header.sense_buffer, SCpnt->sense_buffer, sizeof(SCpnt->sense_buffer));
device281drivers/scsi/sg.cdevice->header.result=EIO;
device284drivers/scsi/sg.cdevice->header.result=SCpnt->result;
device290drivers/scsi/sg.cdevice->complete=1;
device301drivers/scsi/sg.cstruct scsi_generic   * device=&scsi_generics[dev];
device320drivers/scsi/sg.cwhile(device->pending)
device327drivers/scsi/sg.cinterruptible_sleep_on(&device->write_wait);
device335drivers/scsi/sg.cdevice->pending=1;
device336drivers/scsi/sg.cdevice->complete=0;
device337drivers/scsi/sg.cmemcpy_fromfs(&device->header,buf,sizeof(struct sg_header));
device339drivers/scsi/sg.cdevice->header.pack_len=count;
device347drivers/scsi/sg.cif (opcode >= 0xc0 && device->header.twelve_byte) size = 12;
device352drivers/scsi/sg.cinput_size = device->header.pack_len - size;
device353drivers/scsi/sg.cif( input_size > device->header.reply_len)
device357drivers/scsi/sg.cbsize = device->header.reply_len;
device371drivers/scsi/sg.cdevice->pending=0;
device372drivers/scsi/sg.cwake_up( &device->write_wait );
device389drivers/scsi/sg.cif ((bsize<0) || !(device->buff=sg_malloc(device->buff_len=bsize)))
device391drivers/scsi/sg.cdevice->pending=0;
device392drivers/scsi/sg.cwake_up(&device->write_wait);
device404drivers/scsi/sg.cif (!(SCpnt=allocate_device(NULL,device->device, !(filp->f_flags & O_NONBLOCK))))
device406drivers/scsi/sg.cdevice->pending=0;
device407drivers/scsi/sg.cwake_up(&device->write_wait);
device408drivers/scsi/sg.csg_free(device->buff,device->buff_len);
device409drivers/scsi/sg.cdevice->buff = NULL;
device432drivers/scsi/sg.cif (input_size > 0) memcpy_fromfs(device->buff, buf, input_size);
device437drivers/scsi/sg.ccmnd[1]= (cmnd[1] & 0x1f) | (device->device->lun<<5);
device449drivers/scsi/sg.c(void *) device->buff,amt,
device450drivers/scsi/sg.csg_command_done,device->timeout,SG_DEFAULT_RETRIES);
device463drivers/scsi/sg.cstruct scsi_generic *device=&scsi_generics[dev];
device466drivers/scsi/sg.cif(device->pending && device->complete)
device474drivers/scsi/sg.cif(!device->pending){
device567drivers/scsi/sg.cif(!gpnt->device) break;
device571drivers/scsi/sg.cscsi_generics[i].device=SDp;
device592drivers/scsi/sg.cif(gpnt->device == SDp) {
device593drivers/scsi/sg.cgpnt->device = NULL;
device71drivers/scsi/sr.cif(! --scsi_CDs[MINOR(inode->i_rdev)].device->access_count)
device77drivers/scsi/sr.cif (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
device78drivers/scsi/sr.c(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)--;
device129drivers/scsi/sr.cscsi_CDs[target].device->changed = 1;
device134drivers/scsi/sr.cretval = scsi_CDs[target].device->changed;
device136drivers/scsi/sr.cscsi_CDs[target].device->changed = 0;
device244drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->changed = 1;
device280drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->host->host_no, 
device281drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->id,
device282drivers/scsi/sr.cscsi_CDs[DEVICE_NR(SCpnt->request.rq_dev)].device->lun,
device340drivers/scsi/sr.cif (1 == scsi_CDs[MINOR(inode->i_rdev)].device->access_count) {
device352drivers/scsi/sr.cswitch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
device364drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device399drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device406drivers/scsi/sr.cif (kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device436drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device461drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device482drivers/scsi/sr.crc = kernel_scsi_ioctl(scsi_CDs[MINOR(inode->i_rdev)].device,
device522drivers/scsi/sr.c!scsi_CDs[MINOR(inode->i_rdev)].device) return -ENXIO;   /* No such device */
device529drivers/scsi/sr.cif(!scsi_CDs[MINOR(inode->i_rdev)].device->access_count++)
device531drivers/scsi/sr.cif (scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)
device532drivers/scsi/sr.c(*scsi_CDs[MINOR(inode->i_rdev)].device->host->hostt->usage_count)++;
device573drivers/scsi/sr.cSDev = scsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device;
device597drivers/scsi/sr.cscsi_CDs[DEVICE_NR(CURRENT->rq_dev)].device, 0); 
device616drivers/scsi/sr.cscsi_CDs[DEVICE_NR(req->rq_dev)].device);
device673drivers/scsi/sr.cif (scsi_CDs[dev].device->changed) {
device950drivers/scsi/sr.cif(!cpnt->device) break;
device955drivers/scsi/sr.cscsi_CDs[i].device = SDp;
device982drivers/scsi/sr.cSCpnt = allocate_device(NULL, scsi_CDs[i].device, 1);
device987drivers/scsi/sr.ccmd[1] = (scsi_CDs[i].device->lun << 5) & 0xe0;
device1012drivers/scsi/sr.cwake_up(&SCpnt->device->device_wait); 
device1104drivers/scsi/sr.cif(scsi_CDs[0].device && scsi_CDs[0].device->host->sg_tablesize)
device1118drivers/scsi/sr.cif(cpnt->device == SDp) {
device1132drivers/scsi/sr.ccpnt->device = NULL;
device26drivers/scsi/sr.hScsi_Device    *device;    
device42drivers/scsi/sr_ioctl.cSCpnt = allocate_device(NULL, scsi_CDs[target].device, 1);
device58drivers/scsi/sr_ioctl.cscsi_CDs[target].device->changed = 1;
device69drivers/scsi/sr_ioctl.cscsi_CDs[target].device->host->host_no, 
device70drivers/scsi/sr_ioctl.cscsi_CDs[target].device->id,
device71drivers/scsi/sr_ioctl.cscsi_CDs[target].device->lun,
device82drivers/scsi/sr_ioctl.cwake_up(&SCpnt->device->device_wait);
device97drivers/scsi/sr_ioctl.c!scsi_CDs[target].device) return -ENXIO;
device105drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device117drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device137drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device161drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device185drivers/scsi/sr_ioctl.csr_cmd[1] = scsi_CDs[target].device->lun << 5;
device206drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device242drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device275drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
device284drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 1;
device295drivers/scsi/sr_ioctl.cif (scsi_CDs[target].device -> access_count > 1)
device300drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 1;
device305drivers/scsi/sr_ioctl.cscsi_CDs[target].device -> changed = 1;
device326drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
device342drivers/scsi/sr_ioctl.csr_cmd[1] = (scsi_CDs[target].device -> lun) << 5;
device370drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device -> lun) << 5) | 0x10;    /* Params are SCSI-2 */
device387drivers/scsi/sr_ioctl.csr_cmd[1] = ((scsi_CDs[target].device->lun) << 5) | 0x02;    /* MSF format */
device468drivers/scsi/sr_ioctl.creturn scsi_ioctl(scsi_CDs[target].device,cmd,(void *) arg);
device234drivers/scsi/st.cif ((SCpnt = allocate_device(NULL, STp->device, 1)) == NULL) {
device411drivers/scsi/st.cif( STp->device->was_reset )
device462drivers/scsi/st.cif (dev >= st_template.dev_max || !scsi_tapes[dev].device)
device521drivers/scsi/st.c(STp->device)->was_reset = 0;
device541drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device542drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)++;
device649drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device650drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)++;
device671drivers/scsi/st.cif ( STp->rw == ST_WRITING && !(STp->device)->was_reset) {
device734drivers/scsi/st.cif (scsi_tapes[dev].device->host->hostt->usage_count)
device735drivers/scsi/st.c(*scsi_tapes[dev].device->host->hostt->usage_count)--;
device763drivers/scsi/st.cif( STp->device->was_reset )
device956drivers/scsi/st.cSCpnt = allocate_device(NULL, STp->device, 1);
device1551drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2) {
device1776drivers/scsi/st.creturn scsi_ioctl(STp->device, cmd_in, (void *) arg);
device1791drivers/scsi/st.cif (!(STp->device)->was_reset) {
device1824drivers/scsi/st.cSTp->device->was_reset = 0;
device1925drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2) {
device1947drivers/scsi/st.cif ((STp->device)->scsi_level < SCSI_2)
device1965drivers/scsi/st.creturn scsi_ioctl(STp->device, cmd_in, (void *) arg);
device2109drivers/scsi/st.cif(!tpnt->device) break;
device2113drivers/scsi/st.cscsi_tapes[i].device = SDp;
device2194drivers/scsi/st.cSTp->device = NULL;
device2265drivers/scsi/st.cif(tpnt->device == SDp) {
device2266drivers/scsi/st.ctpnt->device = NULL;
device30drivers/scsi/st.hScsi_Device* device;
device924drivers/scsi/u14-34f.cif (tstatus == BUSY && SCpnt->device->type != TYPE_TAPE) 
device929drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
device935drivers/scsi/u14-34f.c&& SCpnt->device->type == TYPE_DISK
device945drivers/scsi/u14-34f.cif (spp->target_status && SCpnt->device->type == TYPE_DISK)
device970drivers/scsi/u14-34f.cif (SCpnt->device->type != TYPE_TAPE)
device715drivers/scsi/ultrastor.cmy_mscp->ca = SCpnt->device->type != TYPE_TAPE;
device1198drivers/sound/opl3.cdevc->fm_info.device = 0;
device1740drivers/sound/sequencer.cdev = inf.device;
device1774drivers/sound/sequencer.cdev = inf.device;
device1796drivers/sound/sequencer.cdev = inf->device;
device1834drivers/sound/sequencer.cdev = inf->device;
device111fs/fat/cache.ccache[count].device = 0;
device128fs/fat/cache.cif (inode->i_dev == walk->device
device150fs/fat/cache.cif (walk->device)
device151fs/fat/cache.cprintk("<%s,%d>(%d,%d) ", kdevname(walk->device),
device170fs/fat/cache.cif (inode->i_dev == walk->device
device188fs/fat/cache.cwalk->device = inode->i_dev;
device209fs/fat/cache.cif (walk->device == inode->i_dev
device211fs/fat/cache.cwalk->device = 0;
device215fs/fat/cache.cvoid fat_cache_inval_dev(kdev_t device)
device220fs/fat/cache.cif (walk->device == device)
device221fs/fat/cache.cwalk->device = 0;
device66fs/nfs/nfsroot.cstruct device *dev;
device72fs/nfs/nfsroot.cstatic struct device *root_dev = NULL;
device95fs/nfs/nfsroot.cstruct device *dev;
device166fs/nfs/nfsroot.cstruct device *dev, unsigned long src_ip,
device170fs/nfs/nfsroot.cstatic int root_rarp_recv(struct sk_buff *skb, struct device *dev,
device207fs/nfs/nfsroot.cstatic int root_rarp_recv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device289fs/nfs/nfsroot.cstruct device *dev;
device319fs/nfs/nfsroot.cvolatile struct device **root_dev_ptr = (volatile struct device **) &root_dev;
device519fs/proc/array.ctsk->tty ? kdev_t_to_nr(tsk->tty->device) : 0,
device87include/asm-sparc/sbus.h#define for_each_sbusdev(device, bus) \
device88include/asm-sparc/sbus.hfor((device) = (bus)->devices; (device); (device)=(device)->next)
device43include/linux/atalk.hstruct device *dev;
device52include/linux/atalk.hstruct device *dev;
device139include/linux/atalk.hextern struct atalk_iface *atalk_find_dev(struct device *dev);
device140include/linux/atalk.hextern struct at_addr *atalk_find_dev_addr(struct device *dev);
device141include/linux/atalk.hextern int aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr);
device142include/linux/atalk.hextern void aarp_send_probe(struct device *dev, struct at_addr *addr);
device100include/linux/blk.h#define DEVICE_NR(device)  (MINOR(device) >> PARTN_BITS)
device101include/linux/blk.h#define DEVICE_ON(device)  /* nothing */
device102include/linux/blk.h#define DEVICE_OFF(device)  /* nothing */
device109include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device110include/linux/blk.h#define DEVICE_ON(device) 
device111include/linux/blk.h#define DEVICE_OFF(device)
device121include/linux/blk.h#define DEVICE_NR(device) ( (MINOR(device) & 3) | ((MINOR(device) & 0x80 ) >> 5 ))
device122include/linux/blk.h#define DEVICE_ON(device)
device123include/linux/blk.h#define DEVICE_OFF(device) floppy_off(DEVICE_NR(device))
device133include/linux/blk.h#define DEVICE_NR(device) (MINOR(device)>>6)
device134include/linux/blk.h#define DEVICE_ON(device)
device135include/linux/blk.h#define DEVICE_OFF(device)
device143include/linux/blk.h#define DEVICE_NR(device) (MINOR(device) >> 4)
device144include/linux/blk.h#define DEVICE_ON(device)
device145include/linux/blk.h#define DEVICE_OFF(device)
device151include/linux/blk.h#define DEVICE_NR(device) (MINOR(device) & 0x7f)
device152include/linux/blk.h#define DEVICE_ON(device)
device153include/linux/blk.h#define DEVICE_OFF(device)
device160include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device161include/linux/blk.h#define DEVICE_ON(device)
device162include/linux/blk.h#define DEVICE_OFF(device)
device168include/linux/blk.h#define DEVICE_NR(device) (MINOR(device) >> 6)
device169include/linux/blk.h#define DEVICE_ON(device)
device170include/linux/blk.h#define DEVICE_OFF(device)
device176include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device177include/linux/blk.h#define DEVICE_ON(device)
device178include/linux/blk.h#define DEVICE_OFF(device)
device185include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device186include/linux/blk.h#define DEVICE_ON(device)
device187include/linux/blk.h#define DEVICE_OFF(device)
device194include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device195include/linux/blk.h#define DEVICE_ON(device)
device196include/linux/blk.h#define DEVICE_OFF(device)
device202include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device203include/linux/blk.h#define DEVICE_ON(device)
device204include/linux/blk.h#define DEVICE_OFF(device)
device210include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device211include/linux/blk.h#define DEVICE_ON(device)
device212include/linux/blk.h#define DEVICE_OFF(device)
device218include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device219include/linux/blk.h#define DEVICE_ON(device)
device220include/linux/blk.h#define DEVICE_OFF(device)
device226include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device227include/linux/blk.h#define DEVICE_ON(device)
device228include/linux/blk.h#define DEVICE_OFF(device)
device234include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device235include/linux/blk.h#define DEVICE_ON(device)
device236include/linux/blk.h#define DEVICE_OFF(device)
device243include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device244include/linux/blk.h#define DEVICE_ON(device)
device245include/linux/blk.h#define DEVICE_OFF(device)
device251include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device252include/linux/blk.h#define DEVICE_ON(device)
device253include/linux/blk.h#define DEVICE_OFF(device)
device258include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device259include/linux/blk.h#define DEVICE_ON(device)
device260include/linux/blk.h#define DEVICE_OFF(device)
device266include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device267include/linux/blk.h#define DEVICE_ON(device)
device268include/linux/blk.h#define DEVICE_OFF(device)
device274include/linux/blk.h#define DEVICE_NR(device) (MINOR(device))
device275include/linux/blk.h#define DEVICE_ON(device)
device276include/linux/blk.h#define DEVICE_OFF(device)
device31include/linux/etherdevice.hextern int    eth_header(struct sk_buff *skb, struct device *dev,
device34include/linux/etherdevice.hextern int    eth_rebuild_header(void *buff, struct device *dev,
device36include/linux/etherdevice.hextern unsigned short  eth_type_trans(struct sk_buff *skb, struct device *dev);
device37include/linux/etherdevice.hextern void eth_header_cache_bind(struct hh_cache ** hhp, struct device *dev,
device39include/linux/etherdevice.hextern void eth_header_cache_update(struct hh_cache *hh, struct device *dev, unsigned char * haddr);
device42include/linux/etherdevice.hextern struct device  * init_etherdev(struct device *, int);
device65include/linux/fd.hunsigned int device,head,track;
device39include/linux/if_eql.hstruct device *dev;
device51include/linux/if_eql.hstruct device *master_dev;
device117include/linux/if_pppvar.hstruct device    *dev;  /* easy for intr handling  */
device84include/linux/igmp.hstruct device *multidev[IP_MAX_MEMBERSHIPS];
device89include/linux/igmp.hstruct device *interface;
device99include/linux/igmp.hstruct device *dev;
device109include/linux/igmp.hextern int igmp_rcv(struct sk_buff *, struct device *, struct options *, __u32, unsigned short,
device111include/linux/igmp.hextern void ip_mc_drop_device(struct device *dev);
device112include/linux/igmp.hextern int ip_mc_join_group(struct sock *sk, struct device *dev, unsigned long addr);
device113include/linux/igmp.hextern int ip_mc_leave_group(struct sock *sk, struct device *dev,unsigned long addr);
device59include/linux/ip_fw.hstruct device *fw_viadev;    /* device of interface "via" */
device192include/linux/ip_fw.hextern void ip_fw_masquerade(struct sk_buff **, struct device *);
device206include/linux/ip_fw.hextern void ip_acct_cnt(struct iphdr *, struct device *, struct ip_fw *);
device211include/linux/ip_fw.hextern int ip_fw_chk(struct iphdr *, struct device *rif,struct ip_fw *, int, int);
device129include/linux/mroute.hstruct device   *dev;      /* Device we are using */
device162include/linux/msdos_fs.hkdev_t device; /* device number. 0 means unused. */
device191include/linux/msdos_fs.hvoid fat_cache_inval_dev(kdev_t device);
device42include/linux/net_alias.hstruct device dev;    /* alias device defn*/
device47include/linux/net_alias.hstruct device *main_dev;  /* pointer to main device */
device61include/linux/net_alias.hstruct device *taildev;  /* my last (alias) device */
device79include/linux/net_alias.h(struct net_alias_type *this, struct device *, struct sockaddr *);
device80include/linux/net_alias.hstruct device * (*dev_select)  /* closest alias selector*/
device81include/linux/net_alias.h(struct net_alias_type *this, struct device *, struct sockaddr *sa);
device97include/linux/net_alias.hnet_alias_is(struct device *dev)
device108include/linux/net_alias.hnet_alias_has(struct device *dev)
device116include/linux/net_alias.hextern struct device * net_alias_dev_get(char *dev_name, int aliasing_ok, int *err, struct sockaddr *sa, void *data);
device117include/linux/net_alias.hextern int net_alias_dev_rehash(struct device *dev, struct sockaddr *sa);
device125include/linux/net_alias.hextern struct device * net_alias_dev_chk(struct device *main_dev, struct sockaddr *sa, int flags_on, int flags_off);
device126include/linux/net_alias.hextern struct device * net_alias_dev_chk32(struct device *main_dev, int family, __u32 addr32, int flags_on, int flags_off);
device128include/linux/net_alias.hextern struct device * net_alias_dev_rcv_sel(struct device *main_dev, struct sockaddr *sa_src, struct sockaddr *sa_dst);
device129include/linux/net_alias.hextern struct device * net_alias_dev_rcv_sel32(struct device *main_dev, int family, __u32 src, __u32 dst);
device137include/linux/net_alias.hstatic __inline__ struct device *net_alias_main_dev(struct device *dev)
device148include/linux/net_alias.hstatic __inline__ struct device *
device149include/linux/net_alias.hnet_alias_nextdev(struct device *dev)
device160include/linux/net_alias.hstatic __inline__ struct device *
device161include/linux/net_alias.hnet_alias_nextdev_set(struct device *dev, struct device *nextdev)
device163include/linux/net_alias.hstruct device *pdev = dev;
device105include/linux/netdevice.hstruct device      *next;
device108include/linux/netdevice.hint        (*init)(struct device *dev);
device115include/linux/netdevice.hstruct enet_statistics* (*get_stats)(struct device *dev);
device155include/linux/netdevice.hstruct device      *slave;  /* Slave device */
device163include/linux/netdevice.hint        (*open)(struct device *dev);
device164include/linux/netdevice.hint        (*stop)(struct device *dev);
device166include/linux/netdevice.hstruct device *dev);
device168include/linux/netdevice.hstruct device *dev,
device173include/linux/netdevice.hint        (*rebuild_header)(void *eth, struct device *dev,
device176include/linux/netdevice.hvoid        (*set_multicast_list)(struct device *dev);
device178include/linux/netdevice.hint        (*set_mac_address)(struct device *dev, void *addr);
device180include/linux/netdevice.hint        (*do_ioctl)(struct device *dev, struct ifreq *ifr, int cmd);
device182include/linux/netdevice.hint        (*set_config)(struct device *dev, struct ifmap *map);
device184include/linux/netdevice.hvoid        (*header_cache_bind)(struct hh_cache **hhp, struct device *dev, unsigned short htype, __u32 daddr);
device185include/linux/netdevice.hvoid        (*header_cache_update)(struct hh_cache *hh, struct device *dev, unsigned char *  haddr);
device191include/linux/netdevice.hstruct device *  dev;
device192include/linux/netdevice.hint      (*func) (struct sk_buff *, struct device *,
device208include/linux/netdevice.hextern struct device  loopback_dev;
device209include/linux/netdevice.hextern struct device  *dev_base;
device215include/linux/netdevice.hextern struct device  *ip_dev_check(unsigned long daddr);
device218include/linux/netdevice.hextern struct device   *ip_dev_find(unsigned long addr);
device219include/linux/netdevice.hextern struct device    *dev_getbytype(unsigned short type);
device223include/linux/netdevice.hextern struct device  *dev_get(const char *name);
device224include/linux/netdevice.hextern int    dev_open(struct device *dev);
device225include/linux/netdevice.hextern int    dev_close(struct device *dev);
device226include/linux/netdevice.hextern void    dev_queue_xmit(struct sk_buff *skb, struct device *dev,
device233include/linux/netdevice.hextern void    dev_tint(struct device *dev);
device280include/linux/netdevice.hextern void    ether_setup(struct device *dev);
device281include/linux/netdevice.hextern void    tr_setup(struct device *dev);
device282include/linux/netdevice.hextern int    ether_config(struct device *dev, struct ifmap *map);
device284include/linux/netdevice.hextern int    register_netdev(struct device *dev);
device285include/linux/netdevice.hextern void    unregister_netdev(struct device *dev);
device289include/linux/netdevice.hextern void    dev_mc_upload(struct device *dev);
device290include/linux/netdevice.hextern void     dev_mc_delete(struct device *dev, void *addr, int alen, int all);
device291include/linux/netdevice.hextern void    dev_mc_add(struct device *dev, void *addr, int alen, int newonly);
device292include/linux/netdevice.hextern void    dev_mc_discard(struct device *dev);
device294include/linux/netdevice.hextern void    ip_mc_allhost(struct device *dev);
device19include/linux/netrom.hchar device[16];
device550include/linux/pci.hunsigned short  device;
device589include/linux/pci.hunsigned short  device;    /* device id */
device605include/linux/pci.hextern const char *pci_strdev (unsigned int vendor, unsigned int device);
device348include/linux/sched.hunsigned long flags, const char *device);
device58include/linux/skbuff.hstruct device  *dev;      /* Device we arrived on/are leaving by    */
device268include/linux/soundcard.hint device;
device483include/linux/soundcard.hshort    device;    /*  Synth# (0-4)  */
device490include/linux/soundcard.hint  device;    /* 0-N. INITIALIZE BEFORE CALLING */
device523include/linux/soundcard.hint    device;    /* 0-N. INITIALIZE BEFORE CALLING */
device962include/linux/soundcard.h_pm_info.device=dev, _pm_info.data.data8[0]=pgm, \
device966include/linux/soundcard.h_pm_info.device=dev, memcpy(_pm_info.data.data8, pgm, 128), \
device1115include/linux/soundcard.h#define SEQ_MIDIOUT(device, byte)  {_SEQ_NEEDBUF(4);\
device1118include/linux/soundcard.h_seqbuf[_seqbufptr+2] = (device);\
device31include/linux/trdevice.hextern int    tr_header(struct sk_buff *skb, struct device *dev,
device34include/linux/trdevice.hextern int    tr_rebuild_header(void *buff, struct device *dev,
device36include/linux/trdevice.hextern unsigned short  tr_type_trans(struct sk_buff *skb, struct device *dev);
device206include/linux/tty.hkdev_t  device;
device288include/linux/tty.hextern int tty_paranoia_check(struct tty_struct *tty, kdev_t device,
device6include/net/arp.hextern int  arp_rcv(struct sk_buff *skb, struct device *dev,
device8include/net/arp.hextern int  arp_query(unsigned char *haddr, u32 paddr, struct device *dev);
device10include/net/arp.hstruct device *dev, u32 saddr, struct sk_buff *skb);
device13include/net/arp.hstruct device *dev, u32 src_ip, 
device15include/net/arp.hextern int  arp_bind_cache(struct hh_cache ** hhp, struct device *dev, unsigned short type, __u32 daddr);
device145include/net/ax25.hstruct device    *device;
device168include/net/ax25.hextern int  ax25_send_frame(struct sk_buff *, ax25_address *, ax25_address *, ax25_digi *, struct device *);
device170include/net/ax25.hextern struct device *ax25rtr_get_dev(ax25_address *);
device171include/net/ax25.hextern int  ax25_encapsulate(struct sk_buff *, struct device *, unsigned short,
device173include/net/ax25.hextern int  ax25_rebuild_header(unsigned char *, struct device *, unsigned long, struct sk_buff *);
device177include/net/ax25.hextern void ax25_queue_xmit(struct sk_buff *, struct device *, int);
device178include/net/ax25.hextern int  ax25_dev_is_dama_slave(struct device *);  /* dl1bke 951121 */
device201include/net/ax25.hextern void ax25_rt_rx_frame(ax25_address *, struct device *, ax25_digi *);
device206include/net/ax25.hextern void ax25_rt_device_down(struct device *);
device208include/net/ax25.hextern void ax25_ip_mode_set(ax25_address *, struct device *, char);
device209include/net/ax25.hextern char ax25_ip_mode_get(ax25_address *, struct device *);
device210include/net/ax25.hextern unsigned short ax25_dev_get_value(struct device *, int);
device211include/net/ax25.hextern void ax25_dev_device_up(struct device *);
device212include/net/ax25.hextern void ax25_dev_device_down(struct device *);
device215include/net/ax25.hextern ax25_address *ax25_bpq_get_addr(struct device *);
device233include/net/ax25.hextern void ax25_return_dm(struct device *, ax25_address *, ax25_address *, ax25_digi *);
device9include/net/datalink.hint  (*rcvfunc)(struct sk_buff *, struct device *, 
device31include/net/icmp.hunsigned long info, struct device *dev);
device32include/net/icmp.hextern int  icmp_rcv(struct sk_buff *skb1, struct device *dev,
device46include/net/ip.hextern void    ip_mc_dropdevice(struct device *dev);
device79include/net/ip.hstruct device  *dev;    /* Device - for icmp replies */
device89include/net/ip.hextern int     ip_send(struct rtable *rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr);
device93include/net/ip.hstruct device **dev, int type,
device96include/net/ip.hextern int    ip_rcv(struct sk_buff *skb, struct device *dev,
device105include/net/ip.hstruct device *dev, struct sk_buff *skb,
device129include/net/ip.hstruct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev);
device130include/net/ip.hvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag);
device136include/net/ip.hextern int ip_forward(struct sk_buff *skb, struct device *dev, int is_frag, __u32 target_addr);
device1include/net/ipip.hextern int ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
device49include/net/ipx.hextern int ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt);
device50include/net/ipx.hextern void ipxrtr_device_down(struct device *dev);
device58include/net/ipx.hstruct device  *if_dev;
device51include/net/netrom.hstruct device    *device;
device85include/net/netrom.hstruct device   *dev;
device94include/net/netrom.hextern int  nr_rx_frame(struct sk_buff *, struct device *);
device98include/net/netrom.hextern int  nr_rx_ip(struct sk_buff *, struct device *);
device99include/net/netrom.hextern int  nr_init(struct device *);
device116include/net/netrom.hextern void nr_rt_device_down(struct device *);
device117include/net/netrom.hextern struct device *nr_dev_first(void);
device118include/net/netrom.hextern struct device *nr_dev_get(ax25_address *);
device120include/net/netrom.hextern void nr_link_failed(ax25_address *, struct device *);
device1include/net/p8022.hstruct datalink_proto *register_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
device31include/net/protocol.hint      (*handler)(struct sk_buff *skb, struct device *dev,
device1include/net/psnap.hstruct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *));
device31include/net/raw.hextern int   raw_rcv(struct sock *, struct sk_buff *, struct device *, 
device181include/net/route.hstruct device    *rt_dev;
device188include/net/route.hextern void    ip_rt_flush(struct device *dev);
device189include/net/route.hextern void    ip_rt_redirect(__u32 src, __u32 dst, __u32 gw, struct device *dev);
device83include/net/sock.hstruct device    *bound_dev;
device284include/net/sock.hstruct device **dev, int type,
device291include/net/sock.hstruct device *dev, struct sk_buff *skb,
device296include/net/sock.hint      (*rcv)(struct sk_buff *buff, struct device *dev,
device122include/net/tcp.hextern int  tcp_rcv(struct sk_buff *skb, struct device *dev,
device147include/net/tcp.hstruct proto *prot, struct options *opt, struct device *dev, int tos, int ttl);
device45include/net/udp.hextern int  udp_rcv(struct sk_buff *skb, struct device *dev,
device30net/802/p8022.cp8022_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device50net/802/p8022.cstruct device  *dev = skb->dev;
device77net/802/p8022.cregister_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *))
device11net/802/p8023.cstruct device  *dev = skb->dev;
device40net/802/psnap.cint snap_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device96net/802/psnap.cstruct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *))
device20net/802/tr.cstatic void tr_source_route(struct trh_hdr *trh,struct device *dev);
device41net/802/tr.cint tr_header(struct sk_buff *skb, struct device *dev, unsigned short type,
device71net/802/tr.cint tr_rebuild_header(void *buff, struct device *dev, unsigned long dest,
device91net/802/tr.cunsigned short tr_type_trans(struct sk_buff *skb, struct device *dev) {
device122net/802/tr.cstatic void tr_source_route(struct trh_hdr *trh,struct device *dev) {
device64net/appletalk/aarp.cstruct device *dev;      /* Device to use */
device104net/appletalk/aarp.cstruct device *dev=a->dev;
device164net/appletalk/aarp.cstatic void aarp_send_reply(struct device *dev, struct at_addr *us, struct at_addr *them, unsigned char *sha)
device226net/appletalk/aarp.cvoid aarp_send_probe(struct device *dev, struct at_addr *us)
device334net/appletalk/aarp.cstatic void aarp_expire_device(struct aarp_entry **n, struct device *dev)
device407net/appletalk/aarp.cstatic struct aarp_entry *aarp_find_entry(struct aarp_entry *list, struct device *dev, struct at_addr *sat)
device427net/appletalk/aarp.cint aarp_send_ddp(struct device *dev,struct sk_buff *skb, struct at_addr *sa, void *hwaddr)
device597net/appletalk/aarp.cstatic int aarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device298net/appletalk/ddp.cstatic void atif_drop_device(struct device *dev)
device315net/appletalk/ddp.cstatic struct atalk_iface *atif_add_device(struct device *dev, struct at_addr *sa)
device406net/appletalk/ddp.cstruct at_addr *atalk_find_dev_addr(struct device *dev)
device432net/appletalk/ddp.cstruct atalk_iface *atalk_find_dev(struct device *dev)
device446net/appletalk/ddp.cstatic struct atalk_iface *atalk_find_anynet(int node, struct device *dev)
device506net/appletalk/ddp.cstatic struct device *atrtr_get_dev(struct at_addr *sa)
device519net/appletalk/ddp.cstatic void atrtr_set_default(struct device *dev)
device533net/appletalk/ddp.cstatic int atrtr_create(struct rtentry *r, struct device *devhint)
device643net/appletalk/ddp.cvoid atrtr_device_down(struct device *dev)
device672net/appletalk/ddp.catrtr_device_down((struct device *)ptr);
device673net/appletalk/ddp.catif_drop_device((struct device *)ptr);
device692net/appletalk/ddp.cstruct device *dev;
device1363net/appletalk/ddp.cint atalk_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device1521net/appletalk/ddp.cstruct device *dev;
device208net/ax25/af_ax25.cstatic void ax25_kill_by_device(struct device *dev)
device213net/ax25/af_ax25.cif (s->device == dev) {
device215net/ax25/af_ax25.cs->device = NULL;
device232net/ax25/af_ax25.cstruct device *dev = (struct device *)ptr;
device270net/ax25/af_ax25.cstatic struct sock *ax25_find_listener(ax25_address *addr, struct device *dev, int type)
device281net/ax25/af_ax25.cif (s->device == NULL || s->device == dev) {
device319net/ax25/af_ax25.cstatic ax25_cb *ax25_find_cb(ax25_address *my_addr, ax25_address *dest_addr, struct device *dev)
device330net/ax25/af_ax25.cif (ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->device == dev) {
device568net/ax25/af_ax25.cax25->device   = NULL;
device587net/ax25/af_ax25.cint ax25_dev_is_dama_slave(struct device *dev)
device593net/ax25/af_ax25.cif ( (ax25->device == dev) && ax25->dama_slave )
device606net/ax25/af_ax25.cstatic void ax25_fillin_cb(ax25_cb *ax25, struct device *dev)
device608net/ax25/af_ax25.cax25->device = dev;
device630net/ax25/af_ax25.cax25_digi *digi, struct device *dev)
device644net/ax25/af_ax25.cif (ax25cmp(&ax25->source_addr, src) == 0 && ax25cmp(&ax25->dest_addr, dest) == 0 && ax25->device == dev) {
device668net/ax25/af_ax25.cif (ax25_dev_is_dama_slave(ax25->device))  /* dl1bke 960116 */
device687net/ax25/af_ax25.cstruct device *ax25rtr_get_dev(ax25_address *addr)
device689net/ax25/af_ax25.cstruct device *dev;
device980net/ax25/af_ax25.cstatic struct sock *ax25_make_new(struct sock *osk, struct device *dev)
device1157net/ax25/af_ax25.cstruct device *dev;
device1282net/ax25/af_ax25.cax25_fillin_cb(sk->ax25, sk->ax25->device);
device1285net/ax25/af_ax25.cif (sk->ax25->device == NULL)
device1289net/ax25/af_ax25.cif (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->ax25->source_addr, &addr->sax25_call, sk->ax25->device) != NULL)
device1305net/ax25/af_ax25.cif (ax25_dev_is_dama_slave(sk->ax25->device))
device1434net/ax25/af_ax25.cstatic int ax25_rcv(struct sk_buff *skb, struct device *dev, ax25_address *dev_addr, struct packet_type *ptype)
device1481net/ax25/af_ax25.cstruct device *dev_out = dev;
device1492net/ax25/af_ax25.cstruct device *dev_scan;
device1713net/ax25/af_ax25.cax25->device = dev;
device1740net/ax25/af_ax25.cstatic int kiss_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
device1758net/ax25/af_ax25.cstatic int bpq_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
device1803net/ax25/af_ax25.cif (sk->ax25->device == NULL)
device1912net/ax25/af_ax25.cax25_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
device2110net/ax25/af_ax25.cstruct device *dev;
device2121net/ax25/af_ax25.cif ((dev = ax25->device) == NULL)
device2271net/ax25/af_ax25.cvoid ax25_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
device2345net/ax25/af_ax25.cint ax25_encapsulate(struct sk_buff *skb, struct device *dev, unsigned short type, void *daddr,
device2394net/ax25/af_ax25.cint ax25_rebuild_header(unsigned char *bp, struct device *dev, unsigned long dest, struct sk_buff *skb)
device144net/ax25/ax25_in.cif (ax25_dev_get_value(ax25->device, AX25_VALUES_NETROM)) {
device154net/ax25/ax25_in.cax25_ip_mode_set(&ax25->dest_addr, ax25->device, 'V');
device155net/ax25/ax25_in.cip_rcv(skb, ax25->device, NULL);  /* Wrong ptype */
device166net/ax25/ax25_in.cif (ax25->sk != NULL && ax25_dev_get_value(ax25->device, AX25_VALUES_TEXT) && ax25->sk->protocol == pid) {
device189net/ax25/ax25_in.cax25->window  = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
device195net/ax25/ax25_in.cax25->window  = ax25_dev_get_value(ax25->device, AX25_VALUES_EWINDOW);
device240net/ax25/ax25_in.cax25->window  = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
device354net/ax25/ax25_in.cax25->window    = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
device369net/ax25/ax25_in.cax25->window    = ax25_dev_get_value(ax25->device, AX25_VALUES_EWINDOW);
device550net/ax25/ax25_in.cax25->window    = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
device567net/ax25/ax25_in.cax25->window    = ax25_dev_get_value(ax25->device, AX25_VALUES_EWINDOW);
device63net/ax25/ax25_out.cmtu = ax25->device->mtu;
device222net/ax25/ax25_out.cif (ax25->device == NULL) {
device245net/ax25/ax25_out.cax25_queue_xmit(skb, ax25->device, SOPRI_NORMAL);
device372net/ax25/ax25_out.cif (ax25o->device != ax25->device)
device65net/ax25/ax25_route.cstruct device *dev;
device74net/ax25/ax25_route.cstruct device *dev;
device78net/ax25/ax25_route.cvoid ax25_rt_rx_frame(ax25_address *src, struct device *dev, ax25_digi *digi)
device143net/ax25/ax25_route.cvoid ax25_rt_device_down(struct device *dev)
device177net/ax25/ax25_route.cstruct device *dev;
device402net/ax25/ax25_route.ccall = (ax25_address *)ax25->device->dev_addr;
device435net/ax25/ax25_route.cax25->device = ax25_rt->dev;
device446net/ax25/ax25_route.cvoid ax25_ip_mode_set(ax25_address *callsign, struct device *dev, char ip_mode)
device461net/ax25/ax25_route.cchar ax25_ip_mode_get(ax25_address *callsign, struct device *dev)
device472net/ax25/ax25_route.cstatic struct ax25_dev *ax25_dev_get_dev(struct device *dev)
device486net/ax25/ax25_route.cunsigned short ax25_dev_get_value(struct device *dev, int valueno)
device502net/ax25/ax25_route.cvoid ax25_dev_device_up(struct device *dev)
device535net/ax25/ax25_route.cvoid ax25_dev_device_down(struct device *dev)
device563net/ax25/ax25_route.cstruct device *dev;
device645net/ax25/ax25_route.cstruct device *dev;
device686net/ax25/ax25_route.cax25_address *ax25_bpq_get_addr(struct device *dev)
device702net/ax25/ax25_route.cstruct device *dev;
device205net/ax25/ax25_subr.cstruct device *dev;
device207net/ax25/ax25_subr.cif ((dev = ax25->device) == NULL)
device250net/ax25/ax25_subr.cvoid ax25_return_dm(struct device *dev, ax25_address *src, ax25_address *dest, ax25_digi *digi)
device481net/ax25/ax25_subr.cif (ax25->device == NULL)
device503net/ax25/ax25_subr.cdev_queue_xmit(skb, ax25->device, SOPRI_NORMAL);  
device508net/ax25/ax25_subr.cint count = ax25_dev_is_dama_slave(ax25->device);
device520net/ax25/ax25_subr.cint count = ax25_dev_is_dama_slave(ax25->device);
device150net/ax25/ax25_timer.cnr_link_failed(&ax25->dest_addr, ax25->device);
device187net/ax25/ax25_timer.cif (!ax25_dev_is_dama_slave(ax25->device))
device212net/ax25/ax25_timer.cnr_link_failed(&ax25->dest_addr, ax25->device);
device225net/ax25/ax25_timer.cax25->window  = ax25_dev_get_value(ax25->device, AX25_VALUES_WINDOW);
device227net/ax25/ax25_timer.cax25_send_control(ax25, SABM, ax25_dev_is_dama_slave(ax25->device)? POLLOFF : POLLON, C_COMMAND);
device232net/ax25/ax25_timer.cax25_send_control(ax25, SABM, ax25_dev_is_dama_slave(ax25->device)? POLLOFF : POLLON, C_COMMAND);
device234net/ax25/ax25_timer.cax25_send_control(ax25, SABME, ax25_dev_is_dama_slave(ax25->device)? POLLOFF : POLLON, C_COMMAND);
device242net/ax25/ax25_timer.cnr_link_failed(&ax25->dest_addr, ax25->device);
device257net/ax25/ax25_timer.cif (!ax25_dev_is_dama_slave(ax25->device))  /* dl1bke */
device272net/ax25/ax25_timer.cnr_link_failed(&ax25->dest_addr, ax25->device);
device197net/core/dev.cstruct device *dev_get(const char *name)
device199net/core/dev.cstruct device *dev;
device227net/core/dev.cint dev_open(struct device *dev)
device258net/core/dev.cint dev_close(struct device *dev)
device329net/core/dev.cvoid dev_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
device510net/core/dev.cstruct device *dev;
device700net/core/dev.cvoid dev_tint(struct device *dev)
device758net/core/dev.cstruct device *dev;
device834net/core/dev.cstatic int sprintf_stats(char *buffer, struct device *dev)
device869net/core/dev.cstruct device *dev;
device927net/core/dev.cstruct device *dev;
device1315net/core/dev.cstruct device *dev, **dp;
device62net/core/dev_mcast.cvoid dev_mc_upload(struct device *dev)
device85net/core/dev_mcast.cvoid dev_mc_delete(struct device *dev, void *addr, int alen, int all)
device108net/core/dev_mcast.cvoid dev_mc_add(struct device *dev, void *addr, int alen, int newonly)
device136net/core/dev_mcast.cvoid dev_mc_discard(struct device *dev)
device62net/core/net_alias.cstatic int net_alias_devinit(struct device *dev);
device63net/core/net_alias.cstatic int net_alias_hard_start_xmit(struct sk_buff *skb, struct device *dev);
device66net/core/net_alias.cstatic struct device *net_alias_dev_create(struct device *main_dev, int slot, int *err, struct sockaddr *sa, void *data);
device67net/core/net_alias.cstatic struct device *net_alias_dev_delete(struct device *main_dev, int slot, int *err);
device68net/core/net_alias.cstatic void net_alias_free(struct device *dev);
device192net/core/net_alias.cstruct device *dev, struct sockaddr *sa)
device207net/core/net_alias.cnet_alias_devinit(struct device *dev)
device222net/core/net_alias.cnet_alias_hard_start_xmit(struct sk_buff *skb, struct device *dev)
device238net/core/net_alias.cstruct device *main_dev;
device239net/core/net_alias.cstruct device *dev;
device252net/core/net_alias.cmemset(dev, '\0', sizeof(struct device));
device324net/core/net_alias.cstatic struct device *
device325net/core/net_alias.cnet_alias_dev_create(struct device *main_dev, int slot, int *err, struct sockaddr *sa, void *data)
device330net/core/net_alias.cstruct device *dev;
device460net/core/net_alias.cstatic struct device *
device461net/core/net_alias.cnet_alias_dev_delete(struct device *main_dev, int slot, int *err)
device465net/core/net_alias.cstruct device *dev;
device469net/core/net_alias.cstruct device *prevdev;
device582net/core/net_alias.cnet_alias_free(struct device *main_dev)
device587net/core/net_alias.cstruct device *dev;
device656net/core/net_alias.cstruct device *
device660net/core/net_alias.cstruct device *dev;
device727net/core/net_alias.cnet_alias_dev_rehash(struct device *dev, struct sockaddr *sa)
device731net/core/net_alias.cstruct device *main_dev;
device912net/core/net_alias.cstruct device *dev;
device966net/core/net_alias.cstruct device *dev = ptr;
device994net/core/net_alias.cstatic __inline__ struct device *
device1019net/core/net_alias.cstatic __inline__ struct device *
device1045net/core/net_alias.cstruct device *
device1046net/core/net_alias.cnet_alias_dev_chk(struct device *main_dev, struct sockaddr *sa,int flags_on, int flags_off)
device1073net/core/net_alias.cstruct device *
device1074net/core/net_alias.cnet_alias_dev_chk32(struct device *main_dev, int family, __u32 addr32,
device1096net/core/net_alias.cstruct device *
device1097net/core/net_alias.cnet_alias_dev_rcv_sel(struct device *main_dev, struct sockaddr *sa_src, struct sockaddr *sa_dst)
device1102net/core/net_alias.cstruct device *dev;
device1168net/core/net_alias.cstruct device *
device1169net/core/net_alias.cnet_alias_dev_rcv_sel32(struct device *main_dev, int family, __u32 src, __u32 dst)
device1174net/core/net_alias.cstruct device *dev;
device59net/ethernet/eth.cstruct device *d = dev_base;
device89net/ethernet/eth.cint eth_header(struct sk_buff *skb, struct device *dev, unsigned short type,
device139net/ethernet/eth.cint eth_rebuild_header(void *buff, struct device *dev, unsigned long dst,
device172net/ethernet/eth.cunsigned short eth_type_trans(struct sk_buff *skb, struct device *dev)
device226net/ethernet/eth.cvoid eth_header_cache_bind(struct hh_cache ** hhp, struct device *dev,
device250net/ethernet/eth.cvoid eth_header_cache_update(struct hh_cache *hh, struct device *dev, unsigned char * haddr)
device11net/ethernet/pe2.cstruct device  *dev = skb->dev;
device124net/ipv4/arp.cstruct device      *dev;      /* Device the entry is tied to   */
device437net/ipv4/arp.cstruct device * dev = entry->dev;
device515net/ipv4/arp.cstruct device *dev = entry->dev;
device535net/ipv4/arp.cstruct device *dev = entry->dev;
device583net/ipv4/arp.cstruct device *dev=ptr;
device625net/ipv4/arp.cstruct device *dev, u32 src_ip, 
device774net/ipv4/arp.cint arp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device1085net/ipv4/arp.cstatic struct arp_table *arp_lookup(u32 paddr, unsigned short flags, struct device * dev)
device1118net/ipv4/arp.cint arp_query(unsigned char *haddr, u32 paddr, struct device * dev)
device1141net/ipv4/arp.cstatic int arp_set_predefined(int addr_hint, unsigned char * haddr, __u32 paddr, struct device * dev)
device1181net/ipv4/arp.cint arp_find(unsigned char *haddr, u32 paddr, struct device *dev,
device1405net/ipv4/arp.cint arp_bind_cache(struct hh_cache ** hhp, struct device *dev, unsigned short htype, u32 paddr)
device1568net/ipv4/arp.cstruct device  * dev = entry->dev;
device1653net/ipv4/arp.cstatic int arp_req_set(struct arpreq *r, struct device * dev)
device1658net/ipv4/arp.cstruct device *dev1;
device1784net/ipv4/arp.cstatic int arp_req_get(struct arpreq *r, struct device *dev)
device1817net/ipv4/arp.cstatic int arp_req_delete(struct arpreq *r, struct device * dev)
device1867net/ipv4/arp.cstruct device * dev = NULL;
device78net/ipv4/devinet.cstruct device *dev;
device172net/ipv4/devinet.cstruct device *dev;
device189net/ipv4/devinet.cstruct device * ip_dev_check(unsigned long addr)
device191net/ipv4/devinet.cstruct device *dev;
device220net/ipv4/devinet.cstruct device *ip_dev_find(unsigned long addr)
device222net/ipv4/devinet.cstruct device *dev;
device231net/ipv4/devinet.cstruct device *dev_getbytype(unsigned short type)
device233net/ipv4/devinet.cstruct device *dev;
device151net/ipv4/icmp.cvoid (*handler)(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len);
device253net/ipv4/icmp.cvoid icmp_send(struct sk_buff *skb_in, int type, int code, unsigned long info, struct device *dev)
device339net/ipv4/icmp.cstatic void icmp_unreach(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
device470net/ipv4/icmp.cstatic void icmp_redirect(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 source, __u32 daddr, int len)
device540net/ipv4/icmp.cstatic void icmp_echo(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
device560net/ipv4/icmp.cstatic void icmp_timestamp(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
device610net/ipv4/icmp.cstatic void icmp_address(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
device627net/ipv4/icmp.cstatic void icmp_discard(struct icmphdr *icmph, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr, int len)
device636net/ipv4/icmp.cint icmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device106net/ipv4/igmp.cstatic  struct  ip_router_info  *igmp_get_mrouter_info(struct device *dev)
device142net/ipv4/igmp.cstatic  struct  ip_router_info  *igmp_set_mrouter_info(struct device *dev,int type,int time)
device235net/ipv4/igmp.cstatic void igmp_send_report(struct device *dev, unsigned long address, int type)
device284net/ipv4/igmp.cstatic void igmp_heard_report(struct device *dev, unsigned long address)
device298net/ipv4/igmp.cstatic void igmp_heard_query(struct device *dev,unsigned char max_resp_time)
device383net/ipv4/igmp.cvoid ip_mc_filter_add(struct device *dev, unsigned long addr)
device396net/ipv4/igmp.cvoid ip_mc_filter_del(struct device *dev, unsigned long addr)
device426net/ipv4/igmp.cint igmp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device484net/ipv4/igmp.cstatic void ip_mc_inc_group(struct device *dev, unsigned long addr)
device510net/ipv4/igmp.cstatic void ip_mc_dec_group(struct device *dev, unsigned long addr)
device534net/ipv4/igmp.cvoid ip_mc_drop_device(struct device *dev)
device550net/ipv4/igmp.cvoid ip_mc_allhost(struct device *dev)
device573net/ipv4/igmp.cint ip_mc_join_group(struct sock *sk , struct device *dev, unsigned long addr)
device607net/ipv4/igmp.cint ip_mc_leave_group(struct sock *sk, struct device *dev, unsigned long addr)
device80net/ipv4/ip_alias.cstruct device *
device81net/ipv4/ip_alias.cip_alias_dev_select(struct net_alias_type *this, struct device *main_dev, struct sockaddr *sa)
device45net/ipv4/ip_forward.cstatic void ip_encap(struct sk_buff *skb, int len, struct device *out, __u32 daddr)
device86net/ipv4/ip_forward.cint ip_forward(struct sk_buff *skb, struct device *dev, int is_frag,
device89net/ipv4/ip_forward.cstruct device *dev2;  /* Output device */
device253net/ipv4/ip_fragment.cstatic struct ipq *ip_create(struct sk_buff *skb, struct iphdr *iph, struct device *dev)
device409net/ipv4/ip_fragment.cstruct sk_buff *ip_defrag(struct iphdr *iph, struct sk_buff *skb, struct device *dev)
device618net/ipv4/ip_fragment.cvoid ip_fragment(struct sock *sk, struct sk_buff *skb, struct device *dev, int is_frag)
device203net/ipv4/ip_fw.cint ip_fw_chk(struct iphdr *ip, struct device *rif, struct ip_fw *chain, int policy, int opt)
device613net/ipv4/ip_fw.cstatic struct sk_buff *revamp(struct sk_buff *skb, struct device *dev, struct ip_masq *ftp)
device809net/ipv4/ip_fw.cvoid ip_fw_masquerade(struct sk_buff **skb_ptr, struct device *dev)
device1088net/ipv4/ip_fw.cftmp->fw_viadev = (struct device *) -1;
device1128net/ipv4/ip_fw.cftmp->fw_viadev = (struct device *) -1;
device1278net/ipv4/ip_fw.cvoid ip_acct_cnt(struct iphdr *iph, struct device *dev, struct ip_fw *f)
device1360net/ipv4/ip_fw.cstruct device *viadev;
device1652net/ipv4/ip_fw.cstruct device *dev=ptr;
device1673net/ipv4/ip_fw.cfw->fw_viadev = (struct device *) -1;
device198net/ipv4/ip_input.cint ip_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device67net/ipv4/ip_output.cstatic void ip_loopback(struct device *old_dev, struct sk_buff *skb)
device69net/ipv4/ip_output.cstruct device *dev=&loopback_dev;
device114net/ipv4/ip_output.cint ip_send(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
device151net/ipv4/ip_output.cstatic int ip_send_room(struct rtable * rt, struct sk_buff *skb, __u32 daddr, int len, struct device *dev, __u32 saddr)
device193net/ipv4/ip_output.cstruct device **dev, int type, struct options *opt,
device334net/ipv4/ip_output.cvoid ip_queue_xmit(struct sock *sk, struct device *dev,
device583net/ipv4/ip_output.cstruct device *dev = NULL;
device1069net/ipv4/ip_output.cstruct device *dev=ptr;
device49net/ipv4/ip_sockglue.cstruct device *dev;
device96net/ipv4/ip_sockglue.cstatic struct device *ip_mc_find_devfor(unsigned long addr)
device98net/ipv4/ip_sockglue.cstruct device *dev;
device215net/ipv4/ip_sockglue.cstruct device *dev=NULL;
device265net/ipv4/ip_sockglue.cstruct device *dev=NULL;
device322net/ipv4/ip_sockglue.cstruct device *dev=NULL;
device52net/ipv4/ipip.cint ipip_rcv(struct sk_buff *skb, struct device *dev, struct options *opt, 
device81net/ipv4/ipmr.cstatic int ipmr_vifi_find(struct device *dev)
device471net/ipv4/ipmr.cstruct device *dev;
device702net/ipv4/ipmr.cstatic void ipmr_queue_xmit(struct sk_buff *skb, struct vif_device *vif, struct device *in_dev, int frag)
device74net/ipv4/packet.cint packet_rcv(struct sk_buff *skb, struct device *dev,  struct packet_type *pt)
device126net/ipv4/packet.cstruct device *dev;
device82net/ipv4/rarp.cstruct device      *dev;              /* Device the entry is tied to */
device87net/ipv4/rarp.cstatic int rarp_rcv(struct sk_buff *, struct device *, struct packet_type *);
device141net/ipv4/rarp.cstatic void rarp_destroy_dev(struct device *dev)
device166net/ipv4/rarp.crarp_destroy_dev((struct device *)ptr);
device194net/ipv4/rarp.cstatic int rarp_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device292net/ipv4/rarp.cstruct device * dev;
device119net/ipv4/raw.cint raw_rcv(struct sock *sk, struct sk_buff *skb, struct device *dev, __u32 saddr, __u32 daddr)
device100net/ipv4/route.cstruct device    *fib_dev;
device134net/ipv4/route.cstruct device *dev;
device311net/ipv4/route.cstatic __inline__ struct device * get_gw_dev(__u32 gw)
device343net/ipv4/route.cstatic __u32 guess_mask(__u32 dst, struct device * dev)
device372net/ipv4/route.cstruct device * dev, __u32 gtw, short flags, short metric, __u32 mask)
device407net/ipv4/route.cstruct device * dev, __u32 gtw, short flags, short metric)
device451net/ipv4/route.cstatic struct fib_info * fib_create_info(__u32 gw, struct device * dev,
device517net/ipv4/route.c__u32 gw, struct device *dev, unsigned short mss,
device740net/ipv4/route.cstatic int rt_flush_list(struct fib_node ** fp, struct device *dev)
device761net/ipv4/route.cstatic __inline__ void fib_flush_1(struct device *dev)
device1110net/ipv4/route.cstatic void rt_redirect_1(__u32 dst, __u32 gw, struct device *dev)
device1284net/ipv4/route.cstruct device * dev, __u32 gtw, short rt_flags, short metric)
device1298net/ipv4/route.c__u32 gw, struct device *dev, unsigned short mss,
device1309net/ipv4/route.cvoid ip_rt_flush(struct device *dev)
device1323net/ipv4/route.cvoid ip_rt_redirect(__u32 src, __u32 dst, __u32 gw, struct device *dev)
device1607net/ipv4/route.cstruct device * dev = NULL;
device1653net/ipv4/route.cstruct device *dev2;
device1722net/ipv4/route.cstruct device * dev = NULL;
device903net/ipv4/tcp.cstruct device *dev = NULL;
device1212net/ipv4/tcp.cstruct device *dev = NULL;
device1916net/ipv4/tcp.cstruct device *dev=NULL;
device155net/ipv4/tcp_input.cstruct options *opt, unsigned long saddr, struct device *dev)
device313net/ipv4/tcp_input.cu32 daddr, u32 saddr, struct options *opt, struct device *dev, u32 seq)
device1573net/ipv4/tcp_input.cint tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device317net/ipv4/tcp_output.cstruct device *dev;
device493net/ipv4/tcp_output.cstruct proto *prot, struct options *opt, struct device *dev, int tos, int ttl)
device498net/ipv4/tcp_output.cstruct device *ndev=NULL;
device574net/ipv4/tcp_output.cstruct device *dev=NULL;
device666net/ipv4/tcp_output.cstruct device *ndev=NULL;
device761net/ipv4/tcp_output.cstruct device *dev = NULL;
device864net/ipv4/tcp_output.cstruct device *dev=NULL;
device138net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len);
device592net/ipv4/udp.cint udp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
device719net/ipv4/udp.cstatic int udp_deliver(struct sock *sk, struct udphdr *uh, struct sk_buff *skb, struct device *dev, long saddr, long daddr, int len)
device206net/ipx/af_ipx.cipxitf_find_using_phys(struct device *dev, unsigned short datalink)
device330net/ipx/af_ipx.cstruct device *dev = ptr;
device561net/ipx/af_ipx.cstruct device  *dev = intrfc->if_dev;
device839net/ipx/af_ipx.cstruct device  *dev;
device923net/ipx/af_ipx.cstruct device  *dev = NULL;
device951net/ipx/af_ipx.cipxitf_auto_create(struct device *dev, unsigned short dlink_type)
device1023net/ipx/af_ipx.cstruct device *dev;
device1923net/ipx/af_ipx.cint ipx_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *pt)
device102net/netrom/af_netrom.cstatic void nr_kill_by_device(struct device *dev)
device107net/netrom/af_netrom.cif (s->nr->device == dev) {
device109net/netrom/af_netrom.cs->nr->device = NULL;
device123net/netrom/af_netrom.cstruct device *dev = (struct device *)ptr;
device499net/netrom/af_netrom.cnr->device     = NULL;
device573net/netrom/af_netrom.cnr->device   = osk->nr->device;
device667net/netrom/af_netrom.cstruct device *dev;
device705net/netrom/af_netrom.csk->nr->device = dev;
device722net/netrom/af_netrom.cstruct device *dev;
device760net/netrom/af_netrom.csk->nr->device = dev;
device894net/netrom/af_netrom.cint nr_rx_frame(struct sk_buff *skb, struct device *dev)
device1030net/netrom/af_netrom.cif (sk->nr->device == NULL)
device1267net/netrom/af_netrom.cstruct device *dev;
device1278net/netrom/af_netrom.cif ((dev = s->nr->device) == NULL)
device54net/netrom/nr_dev.cint nr_rx_ip(struct sk_buff *skb, struct device *dev)
device76net/netrom/nr_dev.cstatic int nr_header(struct sk_buff *skb, struct device *dev, unsigned short type,
device108net/netrom/nr_dev.cstatic int nr_rebuild_header(void *buff, struct device *dev,
device142net/netrom/nr_dev.cstatic int nr_set_mac_address(struct device *dev, void *addr)
device150net/netrom/nr_dev.cstatic int nr_open(struct device *dev)
device158net/netrom/nr_dev.cstatic int nr_close(struct device *dev)
device166net/netrom/nr_dev.cstatic int nr_xmit(struct sk_buff *skb, struct device *dev)
device201net/netrom/nr_dev.cstatic struct enet_statistics *nr_get_stats(struct device *dev)
device206net/netrom/nr_dev.cint nr_init(struct device *dev)
device55net/netrom/nr_out.cmtu = sk->nr->device->mtu;
device68net/netrom/nr_route.cax25_digi *ax25_digi, struct device *dev, int quality, int obs_count)
device292net/netrom/nr_route.cstatic int nr_del_node(ax25_address *callsign, ax25_address *neighbour, struct device *dev)
device342net/netrom/nr_route.cstatic int nr_add_neigh(ax25_address *callsign, struct device *dev, unsigned int quality)
device382net/netrom/nr_route.cstatic int nr_del_neigh(ax25_address *callsign, struct device *dev, unsigned int quality)
device470net/netrom/nr_route.cvoid nr_rt_device_down(struct device *dev)
device515net/netrom/nr_route.cstatic struct device *nr_ax25_dev_get(char *devname)
device517net/netrom/nr_route.cstruct device *dev;
device537net/netrom/nr_route.cstruct device *nr_dev_first(void)
device539net/netrom/nr_route.cstruct device *dev, *first = NULL;
device552net/netrom/nr_route.cstruct device *nr_dev_get(ax25_address *addr)
device554net/netrom/nr_route.cstruct device *dev;
device569net/netrom/nr_route.cstruct device *dev;
device579net/netrom/nr_route.cif ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
device599net/netrom/nr_route.cif ((dev = nr_ax25_dev_get(nr_route.device)) == NULL)
device630net/netrom/nr_route.cvoid nr_link_failed(ax25_address *callsign, struct device *dev)
device656net/netrom/nr_route.cstruct device *dev;
device670net/netrom/nr_route.cnr_add_node(nr_src, "", &ax25->dest_addr, ax25->digipeat, ax25->device, 0, nr_default.obs_count);