taglinefilesource code
base96arch/alpha/kernel/bios32.cunsigned int base, mask, size, reg;
base108arch/alpha/kernel/bios32.cpcibios_read_config_dword(bus->number, dev->devfn, reg, &base);
base109arch/alpha/kernel/bios32.cif (!base) {
base117arch/alpha/kernel/bios32.cif (base & PCI_BASE_ADDRESS_SPACE_IO) {
base123arch/alpha/kernel/bios32.cbase &= PCI_BASE_ADDRESS_IO_MASK;
base124arch/alpha/kernel/bios32.cmask = (~base << 1) | 0x1;
base125arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
base126arch/alpha/kernel/bios32.cbase = ALIGN(io_base, size);
base127arch/alpha/kernel/bios32.cio_base = base + size;
base129arch/alpha/kernel/bios32.creg, base | 0x1);
base137arch/alpha/kernel/bios32.ctype = base & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
base138arch/alpha/kernel/bios32.cbase &= PCI_BASE_ADDRESS_MEM_MASK;
base139arch/alpha/kernel/bios32.cmask = (~base << 1) | 0x1;
base140arch/alpha/kernel/bios32.csize = (mask & base) & 0xffffffff;
base186arch/alpha/kernel/bios32.cbase = ALIGN(mem_base, size);
base195arch/alpha/kernel/bios32.cif (((base / 16*MB) & 0x7) == 0) {
base196arch/alpha/kernel/bios32.cbase &= ~(128*MB - 1);
base197arch/alpha/kernel/bios32.cbase += 16*MB;
base198arch/alpha/kernel/bios32.cbase  = ALIGN(base, size);
base200arch/alpha/kernel/bios32.cif (base / 128*MB != (base + size) / 128*MB) {
base201arch/alpha/kernel/bios32.cbase &= ~(128*MB - 1);
base202arch/alpha/kernel/bios32.cbase += (128 + 16)*MB;
base203arch/alpha/kernel/bios32.cbase  = ALIGN(base, size);
base206arch/alpha/kernel/bios32.cmem_base = base + size;
base208arch/alpha/kernel/bios32.creg, base);
base15arch/i386/kernel/ioport.cstatic void set_bitmap(unsigned long *bitmap, short base, short extent, int new_value)
base18arch/i386/kernel/ioport.cunsigned long *bitmap_base = bitmap + (base >> 5);
base19arch/i386/kernel/ioport.cunsigned short low_index = base & 0x1f;
base41arch/i386/kernel/ldt.cunsigned long base, limit;
base56arch/i386/kernel/ldt.cbase = ldt_info.base_addr;
base60arch/i386/kernel/ldt.climit += base;
base61arch/i386/kernel/ldt.cif (limit < base || limit >= 0xC0000000)
base259arch/i386/kernel/smp.cvoid smp_scan_config(unsigned long base, unsigned long length)
base261arch/i386/kernel/smp.cunsigned long *bp=(unsigned long *)base;
base233arch/i386/kernel/vm86.c#define pushb(base, ptr, val) \
base238arch/i386/kernel/vm86.c: "r" (base), "q" (val), "0" (ptr))
base240arch/i386/kernel/vm86.c#define pushw(base, ptr, val) \
base247arch/i386/kernel/vm86.c: "r" (base), "q" (val), "0" (ptr))
base249arch/i386/kernel/vm86.c#define pushl(base, ptr, val) \
base262arch/i386/kernel/vm86.c: "r" (base), "q" (val), "0" (ptr))
base264arch/i386/kernel/vm86.c#define popb(base, ptr) \
base269arch/i386/kernel/vm86.c: "=r" (ptr), "=r" (base), "=q" (__res) \
base270arch/i386/kernel/vm86.c: "0" (ptr), "1" (base), "2" (0)); \
base273arch/i386/kernel/vm86.c#define popw(base, ptr) \
base280arch/i386/kernel/vm86.c: "=r" (ptr), "=r" (base), "=q" (__res) \
base281arch/i386/kernel/vm86.c: "0" (ptr), "1" (base), "2" (0)); \
base284arch/i386/kernel/vm86.c#define popl(base, ptr) \
base297arch/i386/kernel/vm86.c: "=r" (ptr), "=r" (base), "=q" (__res) \
base298arch/i386/kernel/vm86.c: "0" (ptr), "1" (base)); \
base76arch/i386/math-emu/get_address.cunsigned char ss,index,base;
base81arch/i386/math-emu/get_address.cbase = get_fs_byte((char *) (*fpu_eip));   /* The SIB byte */
base84arch/i386/math-emu/get_address.css = base >> 6;
base85arch/i386/math-emu/get_address.cindex = (base >> 3) & 7;
base86arch/i386/math-emu/get_address.cbase &= 7;
base88arch/i386/math-emu/get_address.cif ((mod == 0) && (base == 5))
base91arch/i386/math-emu/get_address.coffset = REG_(base);
base114arch/i386/math-emu/get_address.celse if (mod == 2 || base == 5) /* The second condition also has mod==0 */
base555arch/ppc/kernel/raw_printf.cbase = Crtat;
base574arch/ppc/kernel/raw_printf.cif (d->cp > base) {
base618arch/ppc/kernel/raw_printf.cif (d->cp >= base + COL)
base632arch/ppc/kernel/raw_printf.cif (d->cp > base) {
base641arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), d->cp, base + COL * ROW - d->cp);
base645arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), d->cp, COL - (d->cp - base) % COL);
base657arch/ppc/kernel/raw_printf.cd->cp = base + (d->cx - 1) * COL + d->cy - 1;
base682arch/ppc/kernel/raw_printf.ci = (d->cp - base) / COL;
base684arch/ppc/kernel/raw_printf.cpp = base + COL * (ROW-2);
base687arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), base + i * COL, COL);
base691arch/ppc/kernel/raw_printf.ci = (d->cp - base) / COL;
base692arch/ppc/kernel/raw_printf.cpp = base + i * COL;
base694arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), base + COL * (ROW - 1), COL);
base768arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), base, COL * ROW);
base769arch/ppc/kernel/raw_printf.cd->cp = base;
base785arch/ppc/kernel/raw_printf.cif (d->cp >= base + (COL * ROW)) { /* scroll check */
base786arch/ppc/kernel/raw_printf.cbcopy(base + COL, base, COL * (ROW - 1) * CHR);
base787arch/ppc/kernel/raw_printf.cfillw(d->color|(' '<<8), base + COL * (ROW - 1), COL);
base1092arch/ppc/kernel/raw_printf.c_dump_buf_with_offset(unsigned char *p, int s, unsigned char *base)
base1101arch/ppc/kernel/raw_printf.cif (base)
base1103arch/ppc/kernel/raw_printf.c_printk("%06X: ", (int)p - (int)base);
base1145arch/ppc/kernel/raw_printf.cdump_buf_with_offset(unsigned char *p, int s, unsigned char *base)
base1154arch/ppc/kernel/raw_printf.cif (base)
base1156arch/ppc/kernel/raw_printf.cprintk("%06X: ", (int)p - (int)base);
base165arch/sparc/mm/init.cunsigned long base = sp_banks[tmp2].base_addr;
base166arch/sparc/mm/init.cunsigned long limit = base + sp_banks[tmp2].num_bytes;
base168arch/sparc/mm/init.cif((phys_addr >= base) && (phys_addr < limit) &&
base2207drivers/block/floppy.cchar *base;
base2209drivers/block/floppy.cbase = CURRENT->buffer;
base2215drivers/block/floppy.cwhile (bh && bh->b_data == base + size){
base314drivers/block/triton.cstatic void init_triton_dma (ide_hwif_t *hwif, unsigned short base)
base318drivers/block/triton.cprintk("    %s: BusMaster DMA at 0x%04x-0x%04x", hwif->name, base, base+7);
base319drivers/block/triton.cif (check_region(base, 8)) {
base322drivers/block/triton.crequest_region(base, 8, "triton DMA");
base323drivers/block/triton.chwif->dma_base = base;
base335drivers/block/triton.coutl(virt_to_bus(hwif->dmatable), base + 4);
base214drivers/cdrom/cdu31a.cunsigned short base;         /* I/O Base Address */
base3042drivers/cdrom/cdu31a.cwhile (   (cdu31a_addresses[i].base != 0)
base3045drivers/cdrom/cdu31a.cif (check_region(cdu31a_addresses[i].base, 4)) {
base3049drivers/cdrom/cdu31a.cget_drive_configuration(cdu31a_addresses[i].base,
base1074drivers/cdrom/cm206.cint probe_base_port(int base)
base1082drivers/cdrom/cm206.cif (base) b=e=base;
base1083drivers/cdrom/cm206.cfor (base=b; base<=e; base += 0x10) {
base1084drivers/cdrom/cm206.cif (check_region(base, 0x10)) continue;
base1085drivers/cdrom/cm206.cfool = inw(base+2);    /* empty possibly uart_receive_buffer */
base1086drivers/cdrom/cm206.cif((inw(base+6) & 0xffef) != 0x0001 || /* line_status */
base1087drivers/cdrom/cm206.c(inw(base) & 0xad00) != 0) /* data status */
base1090drivers/cdrom/cm206.coutw(dc_normal | pattern1, base+8); 
base1091drivers/cdrom/cm206.cif ((inw(base) & 0x7f) != pattern1) continue;
base1092drivers/cdrom/cm206.coutw(dc_normal | pattern2, base+8);
base1093drivers/cdrom/cm206.cif ((inw(base) & 0x7f) != pattern2) continue;
base1094drivers/cdrom/cm206.coutw(dc_normal | READ_AHEAD, base+8);
base1096drivers/cdrom/cm206.creturn(base);
base55drivers/cdrom/optcd_isp16.hstatic short isp16_cdi_config( int base, u_char drive_type, int irq, int dma );
base182drivers/cdrom/optcd_isp16.hisp16_cdi_config( int base, u_char drive_type, int irq, int dma )
base192drivers/cdrom/optcd_isp16.hswitch (base) {
base198drivers/cdrom/optcd_isp16.hprintk( "Base address 0x%03X not supported by cdrom interface on ISP16.\n", base );
base121drivers/cdrom/sjcd.cstatic short isp16_cdi_config( int base, u_char drive_type, int irq, int dma );
base1751drivers/cdrom/sjcd.cisp16_cdi_config( int base, u_char drive_type, int irq, int dma )
base1761drivers/cdrom/sjcd.cswitch (base) {
base1767drivers/cdrom/sjcd.cprintk( "Base address 0x%03X not supported by cdrom interface on ISP16.\n", base );
base192drivers/char/console.cextern int serial_echo_init (int base);
base262drivers/char/console.cserial_echo_init(int base)
base266drivers/char/console.cif (base != 0x2f8 && base != 0x3f8) {
base270drivers/char/console.cserial_echo_port = base;
base1917drivers/char/console.clong base = (long) vc_scrbuf[currcons];
base1925drivers/char/console.cpos = origin = video_mem_start = base;
base1926drivers/char/console.cscr_end = base + video_screen_size;
base1927drivers/char/console.cvideo_mem_end = base + video_screen_size;
base844drivers/char/keyboard.cif (accent_table[i].diacr == d && accent_table[i].base == ch)
base1016drivers/char/keyboard.cint base;
base1022drivers/char/keyboard.cbase = 10;
base1025drivers/char/keyboard.cbase = 16;
base1031drivers/char/keyboard.cnpadch = npadch * base + value;
base537drivers/char/lp.cint base, size;
base540drivers/char/lp.cbase = LP_B(offset);
base541drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
base542drivers/char/lp.cif (check_region(base, size) < 0)
base545drivers/char/lp.coutb_p(LP_DUMMY, base);
base547drivers/char/lp.ctestvalue = inb_p(base);
base551drivers/char/lp.cprintk("lp%d at 0x%04x, ", offset, base);
base552drivers/char/lp.crequest_region(base, size, "lp");
base622drivers/char/lp.cint base, size;
base623drivers/char/lp.cbase = LP_B(offset);
base624drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
base388drivers/net/3c507.cint base;
base393drivers/net/3c507.cbase = 0xf00000 + (mem_config & 0x08 ? 0x080000
base397drivers/net/3c507.cbase = 0x0c0000 + ( (mem_config & 0x18) << 12);
base399drivers/net/3c507.cdev->mem_start = base;
base400drivers/net/3c507.cdev->mem_end = base + size;
base310drivers/net/depca.cvolatile s32 base;
base316drivers/net/depca.cvolatile s32 base;
base750drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
base756drivers/net/depca.c&lp->tx_ring[i].base);
base897drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
base899drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
base968drivers/net/depca.cwritel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
base969drivers/net/depca.c&lp->rx_ring[lp->rx_old].base);
base971drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
base995drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
base1536drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
base1553drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
base1559drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
base1564drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
base1566drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
base1570drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
base1573drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
base1634drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
base1637drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
base1641drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
base1644drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
base1648drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
base1651drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
base1655drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
base1658drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
base167drivers/net/lance.cint base;
base173drivers/net/lance.cint    base;
base672drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
base678drivers/net/lance.clp->tx_ring[i].base = 0;
base730drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
base734drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
base800drivers/net/lance.clp->tx_ring[entry].base =
base805drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
base818drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
base868drivers/net/lance.cint status = lp->tx_ring[entry].base;
base873drivers/net/lance.clp->tx_ring[entry].base = 0;
base964drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
base965drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
base978drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
base998drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
base1004drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
base1013drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
base1023drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
base106drivers/net/ni52.c#define make24(ptr32) ((char *) (ptr32) - p->base)
base183drivers/net/ni52.cunsigned long base;
base253drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
base255drivers/net/ni52.cp->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
base291drivers/net/ni52.cp->scp  = (struct scp_struct *)  (p->base + SCP_DEFAULT_ADDRESS);
base402drivers/net/ni52.c((struct priv *) (dev->priv))->base =  dev->mem_start + size - 0x01000000;
base823drivers/net/ni52.cmemcpy(skb_put(skb,totlen),(char *) p->base+(unsigned long) rbd->buffer, totlen);
base223drivers/net/pi2.cswitch (lp->base & 2) {
base250drivers/net/pi2.ccmd = lp->base + CTL;
base315drivers/net/pi2.cif (lp->base & 2) {    /* If A channel */
base323drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
base334drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R15, CTSIE);
base335drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_EXT_INT);
base351drivers/net/pi2.ccmd = CTL + lp->base;
base407drivers/net/pi2.cst = rdscc(lp->cardbase, lp->base + CTL, R0);  /* Fetch status */
base410drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R0, RES_EXT_INT);
base411drivers/net/pi2.ccmd = lp->base + CTL;
base480drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R15, CTSIE | DCDIE);
base517drivers/net/pi2.ccmd = lp->base + CTL;
base576drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, ERR_RES);  /* error reset */
base592drivers/net/pi2.ccmd = CTL + lp->base;
base682drivers/net/pi2.ccmd = CTL + lp->base;
base781drivers/net/pi2.ccmd = CTL + lp->base;
base945drivers/net/pi2.cint base, tmr0, tmr1, tmrcmd;
base949drivers/net/pi2.cbase = ioaddr & 0x3f0;
base950drivers/net/pi2.ctmr0 = TMR0 + base;
base951drivers/net/pi2.ctmr1 = TMR1 + base;
base952drivers/net/pi2.ctmrcmd = TMRCMD + base;
base1006drivers/net/pi2.ccmd = CTL + lp->base;
base1101drivers/net/pi2.ccmd = CTL + lp->base;
base1337drivers/net/pi2.clp->base = dev->base_addr;
base1375drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R1, EXT_INT_ENAB);
base1377drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
base1481drivers/net/pi2.cwrtscc(lp->cardbase, CTL + lp->base, R9, MIE | NV);
base1560drivers/net/pi2.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
base119drivers/net/pi2.hint base;       /* Base of I/O registers */
base229drivers/net/pt.cprintk("PTd hardware_send_packet(): kickflag = %d (%d).\n", kickflag, lp->base & CHANA);
base259drivers/net/pt.ccmd = lp->base + CTL;
base325drivers/net/pt.cif (lp->base & CHANA) {
base365drivers/net/pt.cregister int cmd = lp->base + CTL;
base369drivers/net/pt.cprintk("PTd scc_init(): (%d).\n", lp->base & CHANA);
base451drivers/net/pt.cif (lp->base & CHANA)
base459drivers/net/pt.cif (lp->base & CHANA)
base471drivers/net/pt.cif (lp->base & CHANA)
base493drivers/net/pt.cif ( ((lp->base & CHANA) && !(pt_sercfg & PT_DTRB_ON)) ||
base494drivers/net/pt.c(!(lp->base & CHANA) && !(pt_sercfg & PT_DTRA_ON)) ) 
base496drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, FHWRES);
base501drivers/net/pt.cprintk("PTd chipset_init() Resetting SCC, called by ch (%d).\n", lp->base & CHANA);
base505drivers/net/pt.cif (lp->base & CHANA) {
base506drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | DLC | NV | CHRA);
base509drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | DLC | NV | CHRB);
base642drivers/net/pt.cint cmd = lp->base + CTL;
base644drivers/net/pt.cprintk("PTd pt_rts(): Transmitter status will be %d (%d).\n", x, lp->base & CHANA);
base801drivers/net/pt.clp->base = dev->base_addr;
base953drivers/net/pt.clp->saved_RR0 = rdscc(lp->cardbase, lp->base + CTL, R0) & ~ZCOUNT;
base958drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R9, MIE | NV);
base977drivers/net/pt.cprintk("PTd pt_send_packet(): (%d)\n", lp->base & CHANA);
base1002drivers/net/pt.ccmd = lp->base + CTL;
base1022drivers/net/pt.cprintk("PTd pt_close(): Closing down channel (%d).\n", lp->base & CHANA);  
base1133drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R1, INT_ALL_Rx | EXT_INT_ENAB);
base1135drivers/net/pt.cif (lp->base & CHANA) {
base1153drivers/net/pt.ccmd = lp->base + CTL;
base1156drivers/net/pt.cprintk("PTd pt_txisr(): tstate = %d (%d).\n", lp->tstate, lp->base & CHANA);
base1267drivers/net/pt.cint cmd = lp->base + CTL;
base1283drivers/net/pt.cprintk("PTd pt_rxisr(): R1 = %#3x. (%d)\n", rse, lp->base & CHANA);
base1434drivers/net/pt.cwhile( rdscc(lp->cardbase, lp->base + CTL, R0) & Rx_CH_AV) {
base1436drivers/net/pt.c(void) inb_p(lp->base + DATA);
base1450drivers/net/pt.cprintk("PTd pt_tmrisr(): tstate = %d (%d).\n", lp->tstate, lp->base & CHANA);
base1469drivers/net/pt.cif (lp->base & CHANA)
base1535drivers/net/pt.cwrtscc(lp->cardbase, lp->base + CTL, R0, RES_H_IUS);
base1564drivers/net/pt.cint cmd = lp->base + CTL;
base1576drivers/net/pt.cprintk("PTd exisr(): R0 = %#3x tstate = %d (%d).\n", st, lp->tstate, lp->base & CHANA);
base160drivers/net/pt.hint base;       /* Base of I/O registers */
base532drivers/pci/pci.cunsigned long base;
base625drivers/pci/pci.cbase = l;
base626drivers/pci/pci.cif (!base) {
base630drivers/pci/pci.cif (base & PCI_BASE_ADDRESS_SPACE_IO) {
base633drivers/pci/pci.cbase & PCI_BASE_ADDRESS_IO_MASK);
base637drivers/pci/pci.cif (base & PCI_BASE_ADDRESS_MEM_PREFETCH) {
base642drivers/pci/pci.cswitch (base & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
base652drivers/pci/pci.cbase |= ((u64) l) << 32;
base658drivers/pci/pci.cbase & PCI_BASE_ADDRESS_MEM_MASK);
base499drivers/scsi/53c7,8xx.cint base;  /* Memory address - indicates memory mapped regs */
base585drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.base = ints[1];
base1173drivers/scsi/53c7,8xx.cu32 base, int io_port, int irq, int dma, int pci_valid, 
base1201drivers/scsi/53c7,8xx.cchip_str, (unsigned) base, io_port, irq);
base1291drivers/scsi/53c7,8xx.cif (base) {
base1292drivers/scsi/53c7,8xx.cinstance->base = (unsigned char *) (unsigned long) base;
base1393drivers/scsi/53c7,8xx.cbase, io_port; 
base1418drivers/scsi/53c7,8xx.cPCI_BASE_ADDRESS_1, &base)) ||
base1457drivers/scsi/53c7,8xx.cif ((base & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
base1460drivers/scsi/53c7,8xx.cbase = 0;
base1462drivers/scsi/53c7,8xx.cbase &= PCI_BASE_ADDRESS_MEM_MASK;
base1464drivers/scsi/53c7,8xx.cbase = 0;
base1467drivers/scsi/53c7,8xx.cif (!io_port && !base) {
base1505drivers/scsi/53c7,8xx.creturn normal_init (tpnt, board, chip, (int) base, io_port, 
base1546drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.base, 
base1596drivers/scsi/53c7,8xx.cu32 base;
base1654drivers/scsi/53c7,8xx.cbase = (u32) host->io_port;
base1658drivers/scsi/53c7,8xx.cbase = virt_to_bus(host->base);
base1662drivers/scsi/53c7,8xx.cpatch_abs_32 (hostdata->script, 0, addr_scratch, base + SCRATCHA_REG_800);
base1663drivers/scsi/53c7,8xx.cpatch_abs_32 (hostdata->script, 0, addr_temp, base + TEMP_REG);
base1502drivers/scsi/53c7,8xx.hNCR53c7x0_address_memory = (void *) (host)->base;      \
base173drivers/scsi/AM53C974.cunsigned long  class_revision, base; 
base187drivers/scsi/AM53C974.cbase = AM53C974_PCIREG_READ_DWORD(instance, PCI_BASE_ADDRESS_0);
base202drivers/scsi/AM53C974.cprintk("PCI_BASE_ADDRESS_0:  0x%lx\n", base);
base604drivers/scsi/AM53C974.cinstance->base = NULL;
base3056drivers/scsi/advansys.cshp->base = (char *) ((ulong) AscGetChipBiosAddress(
base3162drivers/scsi/advansys.c(unsigned) shp->base, shp->io_port,
base3185drivers/scsi/advansys.c(unsigned) shp->base, shp->io_port,
base4748drivers/scsi/advansys.cs->wish_block, (unsigned) s->base, s->io_port, s->n_io_port,
base122drivers/scsi/aha1542.c#define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
base159drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
base166drivers/scsi/aha1542.cWAIT(STATUS(base), CDF, 0, CDF);
base168drivers/scsi/aha1542.cif(inb(STATUS(base)) & CDF) {restore_flags(flags); continue;}
base169drivers/scsi/aha1542.coutb(*cmdp, DATA(base));
base177drivers/scsi/aha1542.cWAIT(STATUS(base), CDF, 0, CDF);
base178drivers/scsi/aha1542.coutb(*cmdp++, DATA(base));
base191drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
base199drivers/scsi/aha1542.cWAIT(STATUS(base), DF, DF, 0);
base200drivers/scsi/aha1542.c*cmdp++ = inb(DATA(base));
base213drivers/scsi/aha1542.cstatic int aha1542_in1(unsigned int base, unchar *cmdp, int len)
base221drivers/scsi/aha1542.cWAITd(STATUS(base), DF, DF, 0, 100);
base222drivers/scsi/aha1542.c*cmdp++ = inb(DATA(base));
base789drivers/scsi/aha1542.cstatic int aha1542_mbenable(int base)
base798drivers/scsi/aha1542.caha1542_out(base,mbenable_cmd,1);
base799drivers/scsi/aha1542.cif(aha1542_in1(base,mbenable_result,2))
base801drivers/scsi/aha1542.cWAITd(INTRFLAGS(base),INTRMASK,HACC,0,100);
base802drivers/scsi/aha1542.caha1542_intr_reset(base);
base809drivers/scsi/aha1542.caha1542_out(base,mbenable_cmd,3);
base810drivers/scsi/aha1542.cWAIT(INTRFLAGS(base),INTRMASK,HACC,0);
base816drivers/scsi/aha1542.caha1542_intr_reset(base);
base39drivers/scsi/aha1542.h#define STATUS(base) base
base49drivers/scsi/aha1542.h#define INTRFLAGS(base) (STATUS(base)+2)
base58drivers/scsi/aha1542.h#define CONTROL(base) STATUS(base)
base65drivers/scsi/aha1542.h#define DATA(base) (STATUS(base)+1)
base62drivers/scsi/aha1740.cstatic unsigned int slot, base;
base450drivers/scsi/aha1740.cbase = SLOTBASE(slot);
base456drivers/scsi/aha1740.cif(check_region(base, 0x5c)) continue;  /* See if in use */
base470drivers/scsi/aha1740.cprintk("Configuring Adaptec at IO:%x, IRQ %d\n",base,
base480drivers/scsi/aha1740.crequest_region(base, 0x5c,"aha1740");  /* Reserve the space that we need to use */
base21drivers/scsi/aha1740.h#define  BASE    (base)
base24drivers/scsi/aha1740.h#define  HID0  (base + 0x0)
base25drivers/scsi/aha1740.h#define  HID1  (base + 0x1)
base26drivers/scsi/aha1740.h#define HID2  (base + 0x2)
base27drivers/scsi/aha1740.h#define  HID3  (base + 0x3)
base28drivers/scsi/aha1740.h#define  EBCNTRL  (base + 0x4)
base29drivers/scsi/aha1740.h#define  PORTADR  (base + 0x40)
base30drivers/scsi/aha1740.h#define BIOSADR (base + 0x41)
base31drivers/scsi/aha1740.h#define INTDEF  (base + 0x42)
base32drivers/scsi/aha1740.h#define SCSIDEF (base + 0x43)
base33drivers/scsi/aha1740.h#define BUSDEF  (base + 0x44)
base34drivers/scsi/aha1740.h#define  RESV0  (base + 0x45)
base35drivers/scsi/aha1740.h#define RESV1  (base + 0x46)
base36drivers/scsi/aha1740.h#define  RESV2  (base + 0x47)
base865drivers/scsi/aic7xxx.coutb(p->pause, HCNTRL(p->base));      \
base866drivers/scsi/aic7xxx.cwhile ((inb(HCNTRL(p->base)) & PAUSE) == 0)    \
base874drivers/scsi/aic7xxx.coutb(p->unpause, HCNTRL(p->base))
base881drivers/scsi/aic7xxx.coutb(SEQRESET | FASTMODE, SEQCTL(p->base));    \
base882drivers/scsi/aic7xxx.c} while (inb(SEQADDR0(p->base)) != 0 &&    \
base883drivers/scsi/aic7xxx.cinb(SEQADDR1(p->base)) != 0);    \
base1045drivers/scsi/aic7xxx.cint                      base;             /* card base address */
base1097drivers/scsi/aic7xxx.cint              base;       /* I/O base */
base1172drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(p->base));
base1173drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(p->base));
base1202drivers/scsi/aic7xxx.cp->base >> 12);
base1207drivers/scsi/aic7xxx.cp->base >> 12);
base1364drivers/scsi/aic7xxx.caic7xxx_loadseq(int base)
base1388drivers/scsi/aic7xxx.coutb(PERRORDIS | SEQRESET | LOADRAM, SEQCTL(base));
base1394drivers/scsi/aic7xxx.c:"S" (seqprog), "c" (sizeof(seqprog)), "d" (SEQRAM(base))
base1413drivers/scsi/aic7xxx.coutb(SEQRESET | FASTMODE, SEQCTL(base));
base1414drivers/scsi/aic7xxx.c} while ((inb(SEQADDR0(base)) != 0) && (inb(SEQADDR1(base)) != 0));
base1617drivers/scsi/aic7xxx.caic7xxx_putscb(int base, struct aic7xxx_scb *scb)
base1624drivers/scsi/aic7xxx.coutb(scb->position, QINFIFO(base));
base1635drivers/scsi/aic7xxx.caic7xxx_putscb_dma(int base, struct aic7xxx_scb *scb)
base1643drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base1649drivers/scsi/aic7xxx.c:"S" (scb), "c" (31), "d" (SCBARRAY(base))
base1652drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base1663drivers/scsi/aic7xxx.caic7xxx_getscb(int base, struct aic7xxx_scb *scb)
base1668drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base1674drivers/scsi/aic7xxx.c:"D" (scb), "c" (SCB_UPLOAD_SIZE), "d" (SCBARRAY(base))
base1677drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base1718drivers/scsi/aic7xxx.caic7xxx_unbusy_target(unsigned char target, char channel, int base)
base1721drivers/scsi/aic7xxx.cunsigned long active_port = HA_ACTIVE0(base);
base1786drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(u_long              base,
base1793drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(base));
base1794drivers/scsi/aic7xxx.chead = inb(WAITING_SCBH(base));
base1795drivers/scsi/aic7xxx.ctail = inb(WAITING_SCBT(base));
base1808drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1809drivers/scsi/aic7xxx.coutb(head, SCBARRAY(base) + 30);
base1820drivers/scsi/aic7xxx.coutb(head, SCBPTR(base));
base1821drivers/scsi/aic7xxx.coutb(tail, SCBARRAY(base) + 30);
base1829drivers/scsi/aic7xxx.coutb(head, SCBPTR(base));
base1830drivers/scsi/aic7xxx.cthird_scb = inb(SCBARRAY(base) + 30);
base1831drivers/scsi/aic7xxx.coutb(scb->position, SCBARRAY(base) + 30);
base1832drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1833drivers/scsi/aic7xxx.coutb(third_scb, SCBARRAY(base) + 30);
base1837drivers/scsi/aic7xxx.coutb(tail, SCBPTR(base));
base1839drivers/scsi/aic7xxx.coutb(tail, SCBARRAY(base) + 30);
base1844drivers/scsi/aic7xxx.coutb(head, WAITING_SCBH(base));
base1845drivers/scsi/aic7xxx.coutb(tail, WAITING_SCBT(base));
base1846drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(base));
base1864drivers/scsi/aic7xxx.cint base = p->base;
base1870drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(base));
base1871drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1872drivers/scsi/aic7xxx.cnext = inb(SCBARRAY(base) + 30);
base1877drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base1878drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, SCBARRAY(base) + 30);
base1879drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
base1889drivers/scsi/aic7xxx.coutb(next, WAITING_SCBH(base));
base1896drivers/scsi/aic7xxx.coutb(prev, SCBPTR(base));
base1897drivers/scsi/aic7xxx.coutb(next, SCBARRAY(base) + 30);
base1902drivers/scsi/aic7xxx.cif (inb(WAITING_SCBT(base)) == scb->position)
base1904drivers/scsi/aic7xxx.coutb(prev, WAITING_SCBT(base));
base1912drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(base));
base1936drivers/scsi/aic7xxx.cint base = p->base;
base1945drivers/scsi/aic7xxx.cactive_scb = inb(SCBPTR(base));
base1956drivers/scsi/aic7xxx.cint queued = inb(QINCNT(base));
base1960drivers/scsi/aic7xxx.csaved_queue[i] = inb(QINFIFO(base));
base1970drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1971drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base1981drivers/scsi/aic7xxx.coutb(saved_queue[queued], QINFIFO(base));
base1991drivers/scsi/aic7xxx.cnext = inb(WAITING_SCBH(base));  /* Start at head of list. */
base2007drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base2009drivers/scsi/aic7xxx.cnext = inb(SCBARRAY(base) + 30);
base2028drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
base2029drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base2030drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2038drivers/scsi/aic7xxx.coutb(active_scb, SCBPTR(base));
base2050drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(int base)
base2055drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base2057drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base2071drivers/scsi/aic7xxx.cint base = p->base;
base2091drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base2092drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base) + 8;
base2093drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 16;
base2103drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base2104drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base2105drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base);
base2106drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 16;
base2112drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base2113drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base);
base2114drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 8;
base2137drivers/scsi/aic7xxx.csblkctl = inb(SBLKCTL(base));
base2148drivers/scsi/aic7xxx.coutb(sblkctl ^ SELBUSB, SBLKCTL(base));
base2149drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(base);
base2150drivers/scsi/aic7xxx.coutb(sblkctl, SBLKCTL(base));
base2163drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(base);
base2183drivers/scsi/aic7xxx.cint base, intstat;
base2203drivers/scsi/aic7xxx.cwhile ((p != NULL) && !(inb(INTSTAT(p->base)) & INT_PEND))
base2250drivers/scsi/aic7xxx.cbase = p->base;
base2255drivers/scsi/aic7xxx.cintstat = inb(INTSTAT(base));
base2260drivers/scsi/aic7xxx.cunsigned char errno = inb(ERROR(base));
base2272drivers/scsi/aic7xxx.cinb(ERROR(base)), (inb(SEQADDR1(base)) << 8) | inb(SEQADDR0(base)));
base2284drivers/scsi/aic7xxx.cscsi_id = (inb(SCSIID(base)) >> 4) & 0x0F;
base2287drivers/scsi/aic7xxx.cif (inb(SBLKCTL(base)) & SELBUSB)
base2301drivers/scsi/aic7xxx.crej_byte = inb(HA_REJBYTE(base));
base2309drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2321drivers/scsi/aic7xxx.cscsi_id, channel, inb(SAVED_TCL(base)));
base2327drivers/scsi/aic7xxx.cscsi_id, channel, inb(SAVED_TCL(base)));
base2328drivers/scsi/aic7xxx.caic7xxx_unbusy_target(scsi_id, channel, base);
base2329drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2331drivers/scsi/aic7xxx.coutb(CLRSELTIMEO, CLRSINT1(base));
base2342drivers/scsi/aic7xxx.ctransfer = (inb(HA_ARG_1(base)) << 2);
base2343drivers/scsi/aic7xxx.coffset = inb(ACCUM(base));
base2344drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2362drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2363drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2371drivers/scsi/aic7xxx.coutb(SEND_REJ, HA_RETURN_1(base));
base2383drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));
base2391drivers/scsi/aic7xxx.coutb(SEND_SDTR, HA_RETURN_1(base));
base2400drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2409drivers/scsi/aic7xxx.cbus_width = inb(ACCUM(base));
base2412drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2419drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));
base2458drivers/scsi/aic7xxx.coutb(bus_width | SEND_WDTR, HA_RETURN_1(base));
base2462drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2463drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2476drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2486drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2500drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2509drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2510drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2515drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2517drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));   /* CHECK_CONDITION may change this */
base2527drivers/scsi/aic7xxx.caic7xxx_getscb(base, scb);
base2576drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base2581drivers/scsi/aic7xxx.c:"S" (scb), "c" (SCB_DOWNLOAD_SIZE), "d" (SCBARRAY(base))
base2583drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base2584drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, (SCBARRAY(base) + 30));
base2589drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE0(base)) | (inb(HA_ACTIVE1(base)) << 8);
base2591drivers/scsi/aic7xxx.coutb(active & 0xFF, HA_ACTIVE0(base));
base2592drivers/scsi/aic7xxx.coutb((active >> 8) & 0xFF, HA_ACTIVE1(base));
base2594drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(base, scb, LIST_HEAD);
base2595drivers/scsi/aic7xxx.coutb(SEND_SENSE, HA_RETURN_1(base));
base2637drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2662drivers/scsi/aic7xxx.cactual -= ((inb(SCBARRAY(base + 17)) << 16) |
base2663drivers/scsi/aic7xxx.c(inb(SCBARRAY(base + 16)) <<  8) |
base2664drivers/scsi/aic7xxx.cinb(SCBARRAY(base + 15)));
base2671drivers/scsi/aic7xxx.cinb(SCBARRAY(base + 18)));
base2680drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2705drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2726drivers/scsi/aic7xxx.coutb(MSG_BUS_DEVICE_RESET, HA_MSG_START(base));
base2727drivers/scsi/aic7xxx.coutb(1, HA_MSG_LEN(base));
base2738drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2751drivers/scsi/aic7xxx.caic7xxx_unbusy_target(scsi_id, channel, base);
base2756drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2758drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base));
base2769drivers/scsi/aic7xxx.cintstat, inb(SCSISIGI(base)));
base2772drivers/scsi/aic7xxx.coutb(CLRSEQINT, CLRINT(base));
base2778drivers/scsi/aic7xxx.cint status = inb(SSTAT1(base));
base2780drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2790drivers/scsi/aic7xxx.coutb(status, CLRSINT1(base));
base2792drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2816drivers/scsi/aic7xxx.coutb(ENRSELI, SCSISEQ(base));
base2822drivers/scsi/aic7xxx.cha_flags = inb(HA_FLAGS(base));
base2823drivers/scsi/aic7xxx.coutb(ha_flags & ~ACTIVE_MSG, HA_FLAGS(base));
base2827drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE1(base));
base2829drivers/scsi/aic7xxx.coutb(active, HA_ACTIVE1(base));
base2833drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE0(base));
base2835drivers/scsi/aic7xxx.coutb(active, HA_ACTIVE0(base));
base2838drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2855drivers/scsi/aic7xxx.coutb(CLRSELTIMEO, CLRSINT1(base));
base2857drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2862drivers/scsi/aic7xxx.cwaiting = inb(WAITING_SCBH(base));
base2863drivers/scsi/aic7xxx.coutb(waiting, SCBPTR(base));
base2864drivers/scsi/aic7xxx.cwaiting = inb(SCBARRAY(base) + 30);
base2865drivers/scsi/aic7xxx.coutb(waiting, WAITING_SCBH(base));
base2889drivers/scsi/aic7xxx.coutb(CLRSCSIPERR, CLRSINT1(base));
base2892drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2904drivers/scsi/aic7xxx.coutb(status, CLRSINT1(base));
base2906drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2924drivers/scsi/aic7xxx.ccomplete = inb(QOUTFIFO(base));
base2931drivers/scsi/aic7xxx.ccomplete, inb(QOUTFIFO(base)),
base2933drivers/scsi/aic7xxx.coutb(CLRCMDINT, CLRINT(base));
base2960drivers/scsi/aic7xxx.coutb(CLRCMDINT, CLRINT(base));
base3013drivers/scsi/aic7xxx.c} while (inb(QOUTCNT(base)));
base3040drivers/scsi/aic7xxx.caic7xxx_probe(int slot, int base)
base3062drivers/scsi/aic7xxx.coutb(0x80 + i, base);
base3063drivers/scsi/aic7xxx.cbuf[i] = inb(base + i);
base3073drivers/scsi/aic7xxx.cif (inb(base + 4) & 1)
base3108drivers/scsi/aic7xxx.cread_2840_seeprom(int base, struct seeprom_config *sc)
base3121drivers/scsi/aic7xxx.cwhile ((inb(STATUS_2840(base)) & EEPROM_TF) == 0)  \
base3125drivers/scsi/aic7xxx.c(void) inb(SEECTL_2840(base));
base3138drivers/scsi/aic7xxx.coutb(CK_2840 | CS_2840, SEECTL_2840(base));
base3139drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3148drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3149drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3151drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3152drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3162drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3163drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3165drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3166drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3178drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3179drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3181drivers/scsi/aic7xxx.cseeprom[k] = (seeprom[k] << 1) | (inb(STATUS_2840(base)) & DI_2840);
base3182drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3183drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3199drivers/scsi/aic7xxx.coutb(0, SEECTL_2840(base));
base3200drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3201drivers/scsi/aic7xxx.coutb(CK_2840, SEECTL_2840(base));
base3202drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3203drivers/scsi/aic7xxx.coutb(0, SEECTL_2840(base));
base3204drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3281drivers/scsi/aic7xxx.cread_seeprom(int base, int offset, struct seeprom_config *sc)
base3295drivers/scsi/aic7xxx.cwhile ((inb(SEECTL(base)) & SEERDY) == 0)  \
base3307drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3309drivers/scsi/aic7xxx.cwhile ((jiffies < timeout) && ((inb(SEECTL(base)) & SEERDY) == 0))
base3313drivers/scsi/aic7xxx.cif ((inb(SEECTL(base)) & SEERDY) == 0)
base3315drivers/scsi/aic7xxx.coutb(0, SEECTL(base));
base3330drivers/scsi/aic7xxx.coutb(SEEMS | SEECK | SEECS, SEECTL(base));
base3331drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3340drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3341drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3343drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3344drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3354drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3355drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3357drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3358drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3370drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3371drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3373drivers/scsi/aic7xxx.cseeprom[k] = (seeprom[k] << 1) | (inb(SEECTL(base)) & SEEDI);
base3374drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3375drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3392drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3393drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3394drivers/scsi/aic7xxx.coutb(SEEMS | SEECK, SEECTL(base));
base3395drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3396drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3397drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3403drivers/scsi/aic7xxx.coutb(0, SEECTL(base));
base3437drivers/scsi/aic7xxx.cdetect_maxscb(aha_type type, int base, int walk_scbs)
base3456drivers/scsi/aic7xxx.csblkctl_reg = inb(SBLKCTL(base)) ^ AUTOFLUSHDIS;
base3457drivers/scsi/aic7xxx.coutb(sblkctl_reg, SBLKCTL(base));
base3458drivers/scsi/aic7xxx.cif (inb(SBLKCTL(base)) == sblkctl_reg)
base3464drivers/scsi/aic7xxx.coutb(sblkctl_reg ^ AUTOFLUSHDIS, SBLKCTL(base));
base3513drivers/scsi/aic7xxx.coutb(i, SCBPTR(base));
base3514drivers/scsi/aic7xxx.cscb_byte = ~(inb(SCBARRAY(base)));  /* complement the byte */
base3515drivers/scsi/aic7xxx.coutb(scb_byte, SCBARRAY(base));     /* write it back out */
base3516drivers/scsi/aic7xxx.cif (inb(SCBARRAY(base)) != scb_byte)
base3542drivers/scsi/aic7xxx.cint found = 1, base;
base3551drivers/scsi/aic7xxx.cbase = config->base;
base3556drivers/scsi/aic7xxx.crequest_region(MINREG(base), MAXREG(base) - MINREG(base), "aic7xxx");
base3572drivers/scsi/aic7xxx.cconfig->unpause = (inb(HCNTRL(base)) & IRQMS) | INTEN;
base3576drivers/scsi/aic7xxx.coutb(config->pause | CHIPRST, HCNTRL(base));
base3578drivers/scsi/aic7xxx.cif (inb(HCNTRL(base)) & CHIPRST)
base3582drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3588drivers/scsi/aic7xxx.cconfig->irq = inb(HA_INTDEF(base)) & 0x0F;
base3589drivers/scsi/aic7xxx.cif ((inb(HA_274_BIOSCTRL(base)) & BIOSMODE) == BIOSDISABLED)
base3593drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(base));
base3597drivers/scsi/aic7xxx.coutb(host_conf & DFTHRSH, BUSSPD(base));
base3598drivers/scsi/aic7xxx.coutb((host_conf << 2) & BOFF, BUSTIME(base));
base3608drivers/scsi/aic7xxx.coutb(CHIPRST, HCNTRL(base));
base3612drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3615drivers/scsi/aic7xxx.cconfig->irq = inb(HA_INTDEF(base)) & 0x0F;
base3616drivers/scsi/aic7xxx.cif ((inb(HA_274_BIOSCTRL(base)) & BIOSMODE) == BIOSDISABLED)
base3620drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(base));
base3623drivers/scsi/aic7xxx.chave_seeprom = read_2840_seeprom(base, &sc);
base3650drivers/scsi/aic7xxx.coutb(host_conf & DFTHRSH, BUSSPD(base));
base3651drivers/scsi/aic7xxx.coutb((host_conf << 2) & BOFF, BUSTIME(base));
base3668drivers/scsi/aic7xxx.coutb(CHIPRST, HCNTRL(base));
base3672drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3678drivers/scsi/aic7xxx.chave_seeprom = read_seeprom(base, config->chan_num * (sizeof(sc) / 2), &sc);
base3708drivers/scsi/aic7xxx.coutb(inb(DSPCISTATUS(base)) | DFTHRESH, DSPCISTATUS(base));
base3709drivers/scsi/aic7xxx.coutb(config->scsi_id | DFTHRESH, HA_SCSICONF(base));
base3714drivers/scsi/aic7xxx.coutb(config->scsi_id, (HA_SCSICONF(base) + 1));
base3724drivers/scsi/aic7xxx.cconfig->maxscb = detect_maxscb(config->type, base, config->walk_scbs);
base3742drivers/scsi/aic7xxx.csblkctl = inb(SBLKCTL(base));
base3746drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base)) & 0x07;
base3748drivers/scsi/aic7xxx.coutb(SINGLE_BUS, HA_FLAGS(base));
base3752drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base) + 1) & 0x0F;
base3756drivers/scsi/aic7xxx.coutb(WIDE_BUS, HA_FLAGS(base));
base3760drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base)) & 0x07;
base3762drivers/scsi/aic7xxx.cconfig->scsi_id_b = inb(HA_SCSICONF(base) + 1) & 0x07;
base3766drivers/scsi/aic7xxx.coutb(TWIN_BUS, HA_FLAGS(base));
base3771drivers/scsi/aic7xxx.coutb(0, HA_FLAGS(base));
base3777drivers/scsi/aic7xxx.c"mail deang@ims.com\n", inb(SBLKCTL(base)));
base3778drivers/scsi/aic7xxx.coutb(0, HA_FLAGS(base));
base3787drivers/scsi/aic7xxx.coutb(sblkctl & ~(DIAGLEDEN | DIAGLEDON), SBLKCTL(base));
base3883drivers/scsi/aic7xxx.cp->base = base;
base3940drivers/scsi/aic7xxx.caic7xxx_loadseq(base);
base3945drivers/scsi/aic7xxx.coutb(FASTMODE, SEQCTL(base));
base3949drivers/scsi/aic7xxx.coutb(ENABLE, BCTL(base));
base3962drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELBUSB, SBLKCTL(base));
base3964drivers/scsi/aic7xxx.coutb(config->scsi_id_b, SCSIID(base));
base3965drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(base) + 1) & (ENSPCHK | STIMESEL);
base3966drivers/scsi/aic7xxx.coutb(scsi_conf | ENSTIMER | ACTNEGEN | STPWEN, SXFRCTL1(base));
base3967drivers/scsi/aic7xxx.coutb(ENSELTIMO | ENSCSIPERR, SIMODE1(base));
base3970drivers/scsi/aic7xxx.coutb(ULTRAEN, SXFRCTL0(base));
base3976drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELSINGLE, SBLKCTL(base));
base3978drivers/scsi/aic7xxx.coutb(config->scsi_id, SCSIID(base));
base3979drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(base)) & (ENSPCHK | STIMESEL);
base3980drivers/scsi/aic7xxx.coutb(scsi_conf | ENSTIMER | ACTNEGEN | STPWEN, SXFRCTL1(base));
base3981drivers/scsi/aic7xxx.coutb(ENSELTIMO | ENSCSIPERR, SIMODE1(base));
base3984drivers/scsi/aic7xxx.coutb(ULTRAEN, SXFRCTL0(base));
base4025drivers/scsi/aic7xxx.cp->discenable = ~((inb(HA_DISC_DSB(base) + 1) << 8) |
base4026drivers/scsi/aic7xxx.cinb(HA_DISC_DSB(base)));
base4050drivers/scsi/aic7xxx.ctarget_settings = inb(HA_TARG_SCRATCH(base) + i);
base4070drivers/scsi/aic7xxx.coutb(target_settings, (HA_TARG_SCRATCH(base) + i));
base4086drivers/scsi/aic7xxx.coutb(i, SCBPTR(base));
base4087drivers/scsi/aic7xxx.coutb(0, SCBARRAY(base));
base4094drivers/scsi/aic7xxx.coutb(config->maxscb, HA_SCBCOUNT(base));
base4099drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base4100drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base4105drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, WAITING_SCBH(base));
base4106drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, WAITING_SCBT(base));
base4129drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELBUSB, SBLKCTL(base));
base4131drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base4133drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base4138drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELSINGLE, SBLKCTL(base));
base4141drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base4143drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base4169drivers/scsi/aic7xxx.cint found = 0, slot, base;
base4199drivers/scsi/aic7xxx.cbase = SLOTBASE(slot);
base4201drivers/scsi/aic7xxx.cif (check_region(MINREG(base), MAXREG(base) - MINREG(base)))
base4210drivers/scsi/aic7xxx.cconfig.type = aic7xxx_probe(slot, HID0(base));
base4224drivers/scsi/aic7xxx.cconfig.base = base;
base4371drivers/scsi/aic7xxx.cbase = io_port - 0xC01;
base4380drivers/scsi/aic7xxx.cconfig.base = base;
base4639drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(p->base));
base4640drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(p->base));
base4641drivers/scsi/aic7xxx.caic7xxx_putscb_dma(p->base, scb);
base4642drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(p->base));
base4684drivers/scsi/aic7xxx.caic7xxx_putscb(p->base, scb);
base4722drivers/scsi/aic7xxx.cint base = p->base;
base4768drivers/scsi/aic7xxx.cactive_scb = inb(SCBPTR(base));
base4770drivers/scsi/aic7xxx.ccontrol = inb(SCBARRAY(base));
base4775drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base4776drivers/scsi/aic7xxx.cif (inb(SCBARRAY(base)) & SCB_DIS)
base4786drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base4791drivers/scsi/aic7xxx.c:"S" (scb), "c" (SCB_DOWNLOAD_SIZE), "d" (SCBARRAY(base))
base4793drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base4796drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(base, scb, LIST_SECOND);
base4806drivers/scsi/aic7xxx.cunsigned char flags = inb(HA_FLAGS(base));
base4831drivers/scsi/aic7xxx.coutb(flags | ACTIVE_MSG, HA_FLAGS(base));
base4832drivers/scsi/aic7xxx.coutb(1, HA_MSG_LEN(base));
base4833drivers/scsi/aic7xxx.coutb(MSG_BUS_DEVICE_RESET, HA_MSG_START(base));
base166drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "               Base IO: %#.4x\n", p->base);
base160drivers/scsi/eata_dma.cuint base;
base172drivers/scsi/eata_dma.cwhile(inb((uint)sh->base + HA_RAUXSTAT) & HA_AIRQ) {
base180drivers/scsi/eata_dma.ceata_stat = inb((uint)sh->base + HA_RSTATUS);
base187drivers/scsi/eata_dma.cbase = (uint) cmd->host->base;
base193drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS);
base196drivers/scsi/eata_dma.c"spadrirq %lx, irq%d\n", base, (long)cp, eata_stat, 
base205drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS);
base211drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS); 
base214drivers/scsi/eata_dma.c"%#.2x \n", irq, base, cmd->pid, cmd->target,
base309drivers/scsi/eata_dma.cinline int eata_send_command(u32 addr, u32 base, u8 command)
base313drivers/scsi/eata_dma.cwhile (inb(base + HA_RAUXSTAT) & HA_ABUSY)
base318drivers/scsi/eata_dma.coutb( addr & 0x000000ff,      base + HA_WDMAADDR);
base319drivers/scsi/eata_dma.coutb((addr & 0x0000ff00) >> 8,  base + HA_WDMAADDR + 1);
base320drivers/scsi/eata_dma.coutb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
base321drivers/scsi/eata_dma.coutb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
base322drivers/scsi/eata_dma.coutb(command, base + HA_WCOMMAND);
base327drivers/scsi/eata_dma.cinline int eata_send_immediate(u32 addr, u32 base, u8 cmnd, u8 cmnd2, u8 id, 
base331drivers/scsi/eata_dma.coutb( addr & 0x000000ff,  base + HA_WDMAADDR);
base332drivers/scsi/eata_dma.coutb((addr & 0x0000ff00) >> 8,  base + HA_WDMAADDR + 1);
base333drivers/scsi/eata_dma.coutb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
base334drivers/scsi/eata_dma.coutb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
base336drivers/scsi/eata_dma.coutb(id,  base + HA_WSUBCODE);
base337drivers/scsi/eata_dma.coutb(lun, base + HA_WSUBLUN);
base340drivers/scsi/eata_dma.coutb(cmnd2, base + HA_WCOMMAND2);
base341drivers/scsi/eata_dma.coutb(cmnd,  base + HA_WCOMMAND);
base510drivers/scsi/eata_dma.cif(eata_send_command((u32) cp, (u32) sh->base, EATA_CMD_DMA_SEND_CP) == FALSE) {
base521drivers/scsi/eata_dma.c"slot %d irq %d\n", (s32)sh->base, cmd->pid, 
base542drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY) {
base599drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
base638drivers/scsi/eata_dma.cinb((u32) (cmd->host->base) + HA_RSTATUS);  /* This might cause trouble */
base639drivers/scsi/eata_dma.ceata_send_command(0, (u32) cmd->host->base, EATA_CMD_RESET);
base691drivers/scsi/eata_dma.cchar * get_board_data(u32 base, u32 irq, u32 id)
base730drivers/scsi/eata_dma.cfake_int_base = (struct eata_register *) base;
base734drivers/scsi/eata_dma.ceata_send_command((u32) cp, (u32) base, EATA_CMD_DMA_SEND_CP);
base750drivers/scsi/eata_dma.cinb((u32) (base) + HA_RSTATUS);
base751drivers/scsi/eata_dma.ceata_send_command(0, base, EATA_CMD_RESET);
base760drivers/scsi/eata_dma.cint check_blink_state(long base)
base770drivers/scsi/eata_dma.cstate = inl((uint) base + 1);
base782drivers/scsi/eata_dma.cint get_conf_PIO(u32 base, struct get_conf *buf)
base787drivers/scsi/eata_dma.cif(check_region(base, 9)) 
base792drivers/scsi/eata_dma.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY)
base797drivers/scsi/eata_dma.cprintk("Issuing PIO READ CONFIG to HBA at %#x\n", base));
base798drivers/scsi/eata_dma.ceata_send_command(0, base, EATA_CMD_PIO_READ_CONFIG);
base803drivers/scsi/eata_dma.cwhile (!(inb(base + HA_RSTATUS) & HA_SDRQ))
base808drivers/scsi/eata_dma.c*p = inw(base + HA_RDATA);
base811drivers/scsi/eata_dma.cif (!(inb(base + HA_RSTATUS) & HA_SERROR)) {      /* Error ? */
base814drivers/scsi/eata_dma.c"EATA Level: %x\n", (uint) base, 
base817drivers/scsi/eata_dma.cwhile (inb(base + HA_RSTATUS) & HA_SDRQ) 
base818drivers/scsi/eata_dma.cinw(base + HA_RDATA);
base823drivers/scsi/eata_dma.c"for HBA at %lx\n", (long)base));
base846drivers/scsi/eata_dma.cshort register_HBA(u32 base, struct get_conf *gc, Scsi_Host_Template * tpnt, 
base862drivers/scsi/eata_dma.c"Please use the EATA-PIO driver.\n", base);
base892drivers/scsi/eata_dma.cdma_channel, base);
base905drivers/scsi/eata_dma.cbuff = get_board_data(base, gc->IRQ, gc->scsi_id[3]);
base914drivers/scsi/eata_dma.cprintk("HBA at %#.4x doesn't support DMA. Sorry\n", base);
base917drivers/scsi/eata_dma.cbase);
base933drivers/scsi/eata_dma.c&buff[16], base);
base935drivers/scsi/eata_dma.crequest_region(base, 9, "eata_dma"); /* We already checked the 
base1032drivers/scsi/eata_dma.csh->unique_id = base;
base1033drivers/scsi/eata_dma.csh->base = (char *) base;
base1034drivers/scsi/eata_dma.csh->io_port = base;
base1110drivers/scsi/eata_dma.cu32 base;
base1120drivers/scsi/eata_dma.cbase = 0x1c88 + (i * 0x1000);
base1122drivers/scsi/eata_dma.cpal1 = inb((u16)base - 8);
base1123drivers/scsi/eata_dma.cpal2 = inb((u16)base - 7);
base1124drivers/scsi/eata_dma.cpal3 = inb((u16)base - 6);
base1132drivers/scsi/eata_dma.cif (get_conf_PIO(base, buf) == TRUE) {
base1135drivers/scsi/eata_dma.cregister_HBA(base, buf, tpnt, IS_EISA);
base1139drivers/scsi/eata_dma.cif (check_blink_state(base)) 
base1182drivers/scsi/eata_dma.cu32 base = 0;
base1223drivers/scsi/eata_dma.cPCI_BASE_ADDRESS_0, (int *) &base))){
base1226drivers/scsi/eata_dma.cif (base & 0x01) {
base1227drivers/scsi/eata_dma.cbase &= 0xfffffffe;
base1229drivers/scsi/eata_dma.cpal1 = inb(base);
base1230drivers/scsi/eata_dma.cpal2 = inb(base + 1);
base1231drivers/scsi/eata_dma.cpal3 = inb(base + 2);
base1237drivers/scsi/eata_dma.cbase += 0x08;
base1239drivers/scsi/eata_dma.cbase += 0x10;   /* Now, THIS is the real address */
base1241drivers/scsi/eata_dma.cif (base != 0x1f8) {
base1243drivers/scsi/eata_dma.cif (get_conf_PIO(base, buf) == TRUE) {
base1250drivers/scsi/eata_dma.cregister_HBA(base, buf, tpnt, IS_PCI);
base1252drivers/scsi/eata_dma.cif (base < 0x1000) {
base1254drivers/scsi/eata_dma.cif (ISAbases[x] == base) {
base1259drivers/scsi/eata_dma.c} else if ((base & 0x0fff) == 0x0c88) 
base1260drivers/scsi/eata_dma.cEISAbases[(base >> 12) & 0x0f] = 0;
base1262drivers/scsi/eata_dma.c} else if (check_blink_state(base) == TRUE) {
base1328drivers/scsi/eata_dma.c(u32) HBA_ptr->base, HBA_ptr->irq);
base147drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
base210drivers/scsi/eata_dma_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
base133drivers/scsi/eata_pio.cuint base;
base146drivers/scsi/eata_pio.cif (inb((uint)sh->base + HA_RSTATUS) & HA_SBUSY)
base155drivers/scsi/eata_pio.cbase = (uint) cmd->host->base;
base159drivers/scsi/eata_pio.cstat=inb(base+HA_RSTATUS);
base173drivers/scsi/eata_pio.cinsw(base+HA_RDATA,cmd->SCp.ptr,x);
base178drivers/scsi/eata_pio.czwickel=inw(base+HA_RDATA); 
base185drivers/scsi/eata_pio.czwickel=inw(base+HA_RDATA); 
base198drivers/scsi/eata_pio.coutw(zwickel,base+HA_RDATA); 
base203drivers/scsi/eata_pio.coutsw(base+HA_RDATA,cmd->SCp.ptr,x);
base215drivers/scsi/eata_pio.coutw(zwickel,base+HA_RDATA); 
base231drivers/scsi/eata_pio.cif (!(inb(base+HA_RSTATUS)&HA_SERROR))
base242drivers/scsi/eata_pio.ceata_stat = inb(base + HA_RSTATUS);
base267drivers/scsi/eata_pio.cinline uint eata_pio_send_command(uint base, unchar command)
base271drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY)
base275drivers/scsi/eata_pio.coutb(command, base + HA_WCOMMAND);
base283drivers/scsi/eata_pio.cuint base;
base296drivers/scsi/eata_pio.cbase = (uint) sh->base;
base378drivers/scsi/eata_pio.cif (eata_pio_send_command(base, EATA_CMD_PIO_SEND_CP)) 
base388drivers/scsi/eata_pio.cwhile (!(inb(base + HA_RSTATUS) & HA_SDRQ));
base389drivers/scsi/eata_pio.coutsw(base + HA_RDATA, cp, hd->cplen);
base390drivers/scsi/eata_pio.coutb(EATA_CMD_PIO_TRUNC, base + HA_WCOMMAND);
base391drivers/scsi/eata_pio.cfor (x = 0; x < hd->cppadlen; x++) outw(0, base + HA_RDATA);
base394drivers/scsi/eata_pio.c"slot %d irq %d\n", (long)sh->base, cmd->pid, 
base416drivers/scsi/eata_pio.cwhile (inb((uint)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
base493drivers/scsi/eata_pio.coutb((uint) cmd->host->base+HA_WCOMMAND, EATA_CMD_RESET);
base536drivers/scsi/eata_pio.cchar * get_pio_board_data(ulong base, uint irq, uint id, ulong cplen, ushort cppadlen)
base561drivers/scsi/eata_pio.cif (eata_pio_send_command((uint) base, EATA_CMD_PIO_SEND_CP)) 
base563drivers/scsi/eata_pio.cwhile (!(inb(base + HA_RSTATUS) & HA_SDRQ));
base564drivers/scsi/eata_pio.coutsw(base + HA_RDATA, &cp, cplen);
base565drivers/scsi/eata_pio.coutb(EATA_CMD_PIO_TRUNC, base + HA_WCOMMAND);
base566drivers/scsi/eata_pio.cfor (z = 0; z < cppadlen; z++) outw(0, base + HA_RDATA);
base568drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY);
base569drivers/scsi/eata_pio.cif (inb(base + HA_RSTATUS) & HA_SERROR)
base571drivers/scsi/eata_pio.celse if (!(inb(base + HA_RSTATUS) & HA_SDRQ))
base575drivers/scsi/eata_pio.cinsw(base+HA_RDATA, &buff, 127);
base576drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS)&HA_SDRQ) inw(base + HA_RDATA);
base581drivers/scsi/eata_pio.cint get_pio_conf_PIO(u32 base, struct get_conf *buf)
base587drivers/scsi/eata_pio.cif(check_region(base, 9))  
base592drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY)
base597drivers/scsi/eata_pio.cprintk("Issuing PIO READ CONFIG to HBA at %#x\n", base));
base598drivers/scsi/eata_pio.ceata_pio_send_command(base, EATA_CMD_PIO_READ_CONFIG);
base603drivers/scsi/eata_pio.cwhile (!(inb(base + HA_RSTATUS) & HA_SDRQ))
base608drivers/scsi/eata_pio.c*p = inw(base + HA_RDATA);
base610drivers/scsi/eata_pio.cif (!(inb(base + HA_RSTATUS) & HA_SERROR)) {            /* Error ? */
base613drivers/scsi/eata_pio.c"EATA Level: %x\n", base, 
base616drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SDRQ) 
base617drivers/scsi/eata_pio.cinw(base + HA_RDATA);
base620drivers/scsi/eata_pio.cif (base == ISAbases[z]) {
base629drivers/scsi/eata_pio.c"for HBA at %x\n", base));
base649drivers/scsi/eata_pio.cstatic uint print_selftest(uint base)
base657drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY);
base658drivers/scsi/eata_pio.coutb(EATA_CMD_PIO_SETUPTEST, base + HA_WCOMMAND);
base660drivers/scsi/eata_pio.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY)
base662drivers/scsi/eata_pio.cif (inb(base + HA_RSTATUS) & HA_SDRQ)
base664drivers/scsi/eata_pio.cinsw(base + HA_RDATA, &buffer, 256);
base671drivers/scsi/eata_pio.c} while (inb(base+HA_RSTATUS) & (HA_SBUSY|HA_SDRQ));
base673drivers/scsi/eata_pio.creturn (!(inb(base+HA_RSTATUS) & HA_SERROR)); 
base676drivers/scsi/eata_pio.cint register_pio_HBA(long base, struct get_conf *gc, Scsi_Host_Template * tpnt)
base688drivers/scsi/eata_pio.cprintk("HBA at %#.4lx supports DMA. Please use EATA-DMA driver.\n",base);
base693drivers/scsi/eata_pio.cif ((buff = get_pio_board_data((uint)base, gc->IRQ, gc->scsi_id[3], 
base697drivers/scsi/eata_pio.cprintk("HBA at %#lx didn't react on INQUIRY. Sorry.\n", (ulong) base);
base701drivers/scsi/eata_pio.cif (print_selftest(base) == FALSE && ALLOW_DMA_BOARDS == FALSE)
base704drivers/scsi/eata_pio.c(ulong) base);
base727drivers/scsi/eata_pio.crequest_region(base, 8, "eata_pio");
base785drivers/scsi/eata_pio.csh->unique_id = base;
base786drivers/scsi/eata_pio.csh->base = (char *) base;
base787drivers/scsi/eata_pio.csh->io_port = base;
base836drivers/scsi/eata_pio.cu32 base;
base846drivers/scsi/eata_pio.cbase = 0x1c88 + (i * 0x1000);
base848drivers/scsi/eata_pio.cpal1 = inb((u16)base - 8);
base849drivers/scsi/eata_pio.cpal2 = inb((u16)base - 7);
base850drivers/scsi/eata_pio.cpal3 = inb((u16)base - 6);
base858drivers/scsi/eata_pio.cif (get_pio_conf_PIO(base, buf) == TRUE) {
base861drivers/scsi/eata_pio.cregister_pio_HBA(base, buf, tpnt);
base884drivers/scsi/eata_pio.cu32 base = 0;
base923drivers/scsi/eata_pio.cPCI_BASE_ADDRESS_0, (int *) &base))){
base926drivers/scsi/eata_pio.cif (base & 0x01) {
base927drivers/scsi/eata_pio.cbase &= 0xfffffffe;
base929drivers/scsi/eata_pio.cif ((inb(base) == 0x12) && (inb(base + 1) == 0x14))
base931drivers/scsi/eata_pio.cbase += 0x10;   /* Now, THIS is the real address */
base932drivers/scsi/eata_pio.cif (base != 0x1f8) {
base934drivers/scsi/eata_pio.cif (get_pio_conf_PIO(base, buf) == TRUE) {
base943drivers/scsi/eata_pio.cregister_pio_HBA(base, buf, tpnt);
base945drivers/scsi/eata_pio.cif (base < 0x1000) {
base947drivers/scsi/eata_pio.cif (ISAbases[x] == base) {
base952drivers/scsi/eata_pio.c} else if ((base & 0x0fff) == 0x0c88) {
base953drivers/scsi/eata_pio.cx = (base >> 12) & 0x0f;
base1012drivers/scsi/eata_pio.c(uint) HBA_ptr->base, HBA_ptr->irq, SD(HBA_ptr)->channel, 
base83drivers/scsi/eata_pio_proc.csize = sprintf(buffer + len, "Base IO : %#.4x\n", (u32) HBA_ptr->base);
base580drivers/scsi/fdomain.cstatic int fdomain_get_irq( int base )
base582drivers/scsi/fdomain.cint options = inb( base + Configuration1 );
base603drivers/scsi/fdomain.cint base;
base618drivers/scsi/fdomain.cbase = *((char *)bios_base + 0x1fa2)
base622drivers/scsi/fdomain.cbase = *((char *)bios_base + 0x1fa3)
base626drivers/scsi/fdomain.cbase = *((char *)bios_base + 0x1fcc)
base632drivers/scsi/fdomain.cprintk( " %x,", base );
base636drivers/scsi/fdomain.cif (base == ports[i])
base640drivers/scsi/fdomain.cif (flag && fdomain_is_valid_port( base )) {
base641drivers/scsi/fdomain.c*irq    = fdomain_get_irq( base );
base642drivers/scsi/fdomain.c*iobase = base;
base665drivers/scsi/fdomain.cbase = ports[i];
base666drivers/scsi/fdomain.cif (check_region( base, 0x10 )) {
base668drivers/scsi/fdomain.cprintk( " (%x inuse),", base );
base673drivers/scsi/fdomain.cprintk( " %x,", base );
base675drivers/scsi/fdomain.cif ((flag = fdomain_is_valid_port( base ))) break;
base680drivers/scsi/fdomain.c*irq    = fdomain_get_irq( base );
base681drivers/scsi/fdomain.c*iobase = base;
base118drivers/scsi/g_NCR5380.h#define NCR5380_map_name base
base120drivers/scsi/g_NCR5380.h#define NCR5380_instance_name base
base271drivers/scsi/hosts.hunsigned char *base;
base122drivers/scsi/in2000.cstatic unsigned int base;
base596drivers/scsi/in2000.cbase = base_tab[loop];
base632drivers/scsi/in2000.c"\n",base, irq_level);
base649drivers/scsi/in2000.cshpnt->io_port = base;
base652drivers/scsi/in2000.crequest_region(base, 12,"in2000");  /* Prevent other drivers from using this space */
base14drivers/scsi/in2000.h#define  INSTAT  (base + 0x0)  /* R: Auxiliary Status; W: register select */
base15drivers/scsi/in2000.h#define  INDATA  (base + 0x1)  /* R/W: Data port */
base16drivers/scsi/in2000.h#define  INFIFO  (base + 0x2)  /* R/W FIFO, Word access only */
base17drivers/scsi/in2000.h#define  INREST  (base + 0x3)  /* W: Reset everything */
base18drivers/scsi/in2000.h#define  INFCNT  (base + 0x4)  /* R: FIFO byte count */
base19drivers/scsi/in2000.h#define  INFRST  (base + 0x5)  /* W: Reset Fifo count and to write */
base20drivers/scsi/in2000.h#define  INFWRT  (base + 0x7)  /* W: Set FIFO to read */
base21drivers/scsi/in2000.h#define  INFLED  (base + 0x8)  /* W: Set LED; R: Dip Switch settings */
base22drivers/scsi/in2000.h#define  INNLED  (base + 0x9)  /* W: reset LED */
base23drivers/scsi/in2000.h#define  INVERS  (base + 0xa)  /* R: Read hw version, end-reset */
base24drivers/scsi/in2000.h#define  ININTR  (base + 0xc)  /* W: Interrupt Mask Port */
base166drivers/scsi/pas16.c#define NO_BASES (sizeof (bases) / sizeof (struct base))
base148drivers/scsi/t128.c#define NO_BASES (sizeof (bases) / sizeof (struct base))
base203drivers/scsi/t128.cunsigned char *base;
base209drivers/scsi/t128.cbase = NULL;
base212drivers/scsi/t128.cbase = overrides[current_override].address;
base214drivers/scsi/t128.cfor (; !base && (current_base < NO_BASES); ++current_base) {
base222drivers/scsi/t128.cbase = bases[current_base].address;
base231drivers/scsi/t128.cprintk("scsi-t128 : base = %08x\n", (unsigned int) base);
base234drivers/scsi/t128.cif (!base)
base238drivers/scsi/t128.cinstance->base = base;
base264drivers/scsi/t128.cinstance->base);
base324drivers/scsi/t128.cregister unsigned char *reg = (unsigned char *) (instance->base + 
base331drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base333drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base339drivers/scsi/t128.cif (*(instance->base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
base342drivers/scsi/t128.cfoo = instance->base + T_CONTROL_REG_OFFSET;
base368drivers/scsi/t128.cregister unsigned char *reg = (unsigned char *) (instance->base + 
base374drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base376drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base382drivers/scsi/t128.cif (*(instance->base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
base385drivers/scsi/t128.cfoo = instance->base + T_CONTROL_REG_OFFSET;
base133drivers/scsi/t128.hvolatile unsigned char *base
base136drivers/scsi/t128.hvolatile unsigned char *base
base139drivers/scsi/t128.hbase = (volatile unsigned char *) (instance)->base
base141drivers/scsi/t128.h#define T128_address(reg) (base + T_5380_OFFSET + ((reg) * 0x20))
base436drivers/scsi/u14-34f.csh[j]->base = bios_segment_table[config_1.bios_segment];
base454drivers/scsi/u14-34f.cif (sh[j]->base == 0) outb(CMD_ENA_INTR, sh[j]->io_port + REG_SYS_MASK);
base507drivers/scsi/u14-34f.c(int)sh[j]->base, sh[j]->irq, 
base53drivers/sound/ad1848.cint             base;
base112drivers/sound/ad1848.c#define io_Index_Addr(d)  ((d)->base)
base113drivers/sound/ad1848.c#define io_Indexed_Data(d)  ((d)->base+1)
base114drivers/sound/ad1848.c#define io_Status(d)    ((d)->base+2)
base115drivers/sound/ad1848.c#define io_Polled_IO(d)    ((d)->base+3)
base138drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base158drivers/sound/ad1848.cinb (devc->base) == 0x80)  /*Are we initializing */
base182drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) & 0x80)
base184drivers/sound/ad1848.cif (inb (devc->base) & 0x80)
base237drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base262drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base981drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
base995drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
base1153drivers/sound/ad1848.cdevc->base = io_base;
base1174drivers/sound/ad1848.cif ((inb (devc->base) & 0x80) != 0x00)  /* Not a AD1848 */
base1177drivers/sound/ad1848.cinb (devc->base)));
base1399drivers/sound/ad1848.crequest_region (devc->base, 4, devc->chip_name);
base1458drivers/sound/ad1848.cdevc->base, devc->irq, dma_playback, dma_capture);
base1552drivers/sound/ad1848.cif (dev_info[i].base == io_base)
base1560drivers/sound/ad1848.crelease_region (devc->base, 4);
base1654drivers/sound/ad1848.ccheck_opl3 (int base, struct address_info *hw_config)
base1657drivers/sound/ad1848.cif (check_region (base, 4))
base1659drivers/sound/ad1848.cprintk ("\n\nopl3.c: I/O port %x already in use\n\n", base);
base1663drivers/sound/ad1848.cif (!opl3_detect (base, hw_config->osp))
base1666drivers/sound/ad1848.copl3_init (0, base, hw_config->osp);
base1667drivers/sound/ad1848.crequest_region (base, 4, "OPL3/OPL2");
base79drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base86drivers/sound/cs4232.cif (check_region (base, 4))
base88drivers/sound/cs4232.cprintk ("cs4232.c: I/O port 0x%03x not free\n", base);
base121drivers/sound/cs4232.cCS_OUT3 (0x47, (base >> 8) & 0xff, base & 0xff);  /* WSSbase */
base168drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base174drivers/sound/cs4232.cad1848_init ("CS4232", base,
base215drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base221drivers/sound/cs4232.cad1848_unload (base,
base50drivers/sound/mpu401.cint             base;  /*
base88drivers/sound/mpu401.c#define  DATAPORT(base)   (base)
base89drivers/sound/mpu401.c#define  COMDPORT(base)   (base+1)
base90drivers/sound/mpu401.c#define  STATPORT(base)   (base+1)
base92drivers/sound/mpu401.c#define mpu401_status(devc)    inb( STATPORT(devc->base))
base95drivers/sound/mpu401.c#define write_command(devc, cmd)  outb( cmd,  COMDPORT(devc->base))
base96drivers/sound/mpu401.c#define read_data(devc)    inb( DATAPORT(devc->base))
base98drivers/sound/mpu401.c#define write_data(devc, byte)  outb( byte,  DATAPORT(devc->base))
base476drivers/sound/mpu401.cif (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
base1036drivers/sound/mpu401.cdevc->base = hw_config->io_base;
base1264drivers/sound/mpu401.ctmp_devc.base = hw_config->io_base;
base37drivers/sound/pss.c#define REG(x)  (devc->base+x)
base77drivers/sound/pss.cint             base;
base97drivers/sound/pss.cdevc->base = hw_config->io_base;
base102drivers/sound/pss.cif (devc->base != 0x220 && devc->base != 0x240)
base103drivers/sound/pss.cif (devc->base != 0x230 && devc->base != 0x250)  /* Some cards use these */
base106drivers/sound/pss.cif (check_region (devc->base, 16))
base151drivers/sound/pss.cset_io_base (pss_config * devc, int dev, int base)
base154drivers/sound/pss.cunsigned short  bits = (base & 0x0ffc) << 4;
base327drivers/sound/pss.cdevc->base = hw_config->io_base;
base1014drivers/sound/sb_dsp.csmw_putmem (int base, int addr, unsigned char val)
base1021drivers/sound/sb_dsp.coutb (addr & 0xff, base + 1);  /* Low address bits */
base1022drivers/sound/sb_dsp.coutb (addr >> 8, base + 2);  /* High address bits */
base1023drivers/sound/sb_dsp.coutb (val, base);    /* Data */
base1029drivers/sound/sb_dsp.csmw_getmem (int base, int addr)
base1037drivers/sound/sb_dsp.coutb (addr & 0xff, base + 1);  /* Low address bits */
base1038drivers/sound/sb_dsp.coutb (addr >> 8, base + 2);  /* High address bits */
base1039drivers/sound/sb_dsp.cval = inb (base);    /* Data */
base91drivers/sound/sound_calls.hvoid conf_printf2(char *name, int base, int irq, int dma, int dma2);
base780drivers/sound/soundcard.cconf_printf2 (char *name, int base, int irq, int dma, int dma2)
base785drivers/sound/soundcard.cprintk ("<%s> at 0x%03x", name, base);
base68drivers/sound/sscape.c#define PORT(name)  (devc->base+name)
base91drivers/sound/sscape.cint             base, irq, dma;
base384drivers/sound/sscape.cif (inb (devc->base + HOST_CTRL) & 0x80)
base387drivers/sound/sscape.cif (inb (devc->base) != 0x00)
base1008drivers/sound/sscape.cdevc->base = hw_config->io_base;
base1070drivers/sound/sscape.cinb (devc->base + ODIE_ADDR);
base61drivers/sound/trix.cdownload_boot (int base)
base67drivers/sound/trix.coutb (0x01, base + 6);  /* Clear the internal data pointer */
base68drivers/sound/trix.coutb (0x00, base + 6);  /* Restart */
base74drivers/sound/trix.coutb (0x01, base + 6);  /* Clear the internal data pointer */
base81drivers/sound/trix.coutb (0x00, base + 6);  /* Reset */
base215fs/namei.cstruct inode * base, struct inode **res_inode)
base223fs/namei.cif (!base) {
base224fs/namei.cbase = current->fs->pwd;
base225fs/namei.cbase->i_count++;
base228fs/namei.ciput(base);
base229fs/namei.cbase = current->fs->root;
base231fs/namei.cbase->i_count++;
base239fs/namei.cbase->i_count++;
base240fs/namei.cerror = lookup(base, thisname, len, &inode);
base242fs/namei.ciput(base);
base245fs/namei.cerror = follow_link(base,inode,0,0,&base);
base249fs/namei.cif (!base->i_op || !base->i_op->lookup) {
base250fs/namei.ciput(base);
base255fs/namei.c*res_inode = base;
base259fs/namei.cstatic int _namei(const char * pathname, struct inode * base,
base267fs/namei.cerror = dir_namei(pathname, &namelen, &basename, base, &base);
base270fs/namei.cbase->i_count++;  /* lookup uses up base */
base271fs/namei.cerror = lookup(base, basename, namelen, &inode);
base273fs/namei.ciput(base);
base277fs/namei.cerror = follow_link(base, inode, 0, 0, &inode);
base281fs/namei.ciput(base);
base333fs/namei.cstruct inode ** res_inode, struct inode * base)
base341fs/namei.cerror = dir_namei(pathname, &namelen, &basename, base, &dir);
base235fs/read_write.cvoid * base;
base238fs/read_write.cbase = vector->iov_base;
base242fs/read_write.cnr = fn(inode, file, base, len);
base296fs/vfat/namei.cchar base[9], ext[4];
base368fs/vfat/namei.cfor (baselen = i = 0, p = base, ip = name; i < sz && baselen < 8; i++)
base406fs/vfat/namei.cstrcpy(msdos_name, base);
base423fs/vfat/namei.cstrncpy(msdos_name, base, baselen);
base127include/asm-i386/system.h#define _set_base(addr,base) \
base136include/asm-i386/system.h"d" (base) \
base152include/asm-i386/system.h#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , base )
base258include/asm-i386/system.h#define _set_seg_desc(gate_addr,type,dpl,base,limit) {\
base259include/asm-i386/system.h*((gate_addr)+1) = ((base) & 0xff000000) | \
base260include/asm-i386/system.h(((base) & 0x00ff0000)>>16) | \
base265include/asm-i386/system.h*(gate_addr) = (((base) & 0x0000ffff)<<16) | \
base41include/linux/etherdevice.hunsigned char *src, int length, int base);
base564include/linux/fs.hstruct inode ** res_inode, struct inode * base);
base118include/linux/kd.hu_char diacr, base, result;
base81include/linux/lp.h#define LP_B(minor)  lp_table[(minor)].base    /* IO address */
base84include/linux/lp.h#define LP_C(minor)  (lp_table[(minor)].base + 2)  /* control port */
base104include/linux/lp.hint base;
base6include/linux/pipe_fs_i.hchar * base;
base17include/linux/pipe_fs_i.h#define PIPE_BASE(inode)  ((inode).u.pipe_i.base)
base281include/net/tcp.hunsigned long saddr, unsigned long daddr, unsigned long base)
base283include/net/tcp.hreturn csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
base17lib/vsprintf.cunsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
base21lib/vsprintf.cif (!base) {
base22lib/vsprintf.cbase = 10;
base24lib/vsprintf.cbase = 8;
base28lib/vsprintf.cbase = 16;
base33lib/vsprintf.c? toupper(*cp) : *cp)-'A'+10) < base) {
base34lib/vsprintf.cresult = result*base + value;
base62lib/vsprintf.c#define do_div(n,base) ({ \
base64lib/vsprintf.c__res = ((unsigned long) n) % (unsigned) base; \
base65lib/vsprintf.cn = ((unsigned long) n) / (unsigned) base; \
base68lib/vsprintf.cstatic char * number(char * str, long num, int base, int size, int precision
base79lib/vsprintf.cif (base < 2 || base > 36)
base97lib/vsprintf.cif (base == 16)
base99lib/vsprintf.celse if (base == 8)
base106lib/vsprintf.ctmp[i++] = digits[do_div(num,base)];
base116lib/vsprintf.cif (base==8)
base118lib/vsprintf.celse if (base==16) {
base138lib/vsprintf.cint i, base;
base204lib/vsprintf.cbase = 10;
base255lib/vsprintf.cbase = 8;
base261lib/vsprintf.cbase = 16;
base290lib/vsprintf.cstr = number(str, num, base, field_width, precision, flags);
base265net/ethernet/eth.cvoid eth_copy_and_sum(struct sk_buff *dest, unsigned char *src, int length, int base)
base293net/ethernet/eth.cdest->csum=csum_partial_copy(src+sizeof(struct iphdr)+ETH_HLEN,dest->data+sizeof(struct iphdr)+ETH_HLEN,length,base);
base130net/ipv4/af_inet.cunsigned short get_new_socknum(struct proto *prot, unsigned short base)
base144net/ipv4/af_inet.cif (base == 0) 
base145net/ipv4/af_inet.cbase = PROT_SOCK+1+(start % 1024);
base146net/ipv4/af_inet.cif (base <= PROT_SOCK) 
base148net/ipv4/af_inet.cbase += PROT_SOCK+(start % 1024);
base158net/ipv4/af_inet.csk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
base167net/ipv4/af_inet.creturn(i+base+1);
base178net/ipv4/af_inet.cwhile(sk_inuse(prot, base +best+1)) 
base182net/ipv4/af_inet.creturn(best+base+1);
base211net/ipv4/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
base213net/ipv4/udp.creturn(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));