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)
base246arch/i386/kernel/smp.cvoid smp_scan_config(unsigned long base, unsigned long length)
base248arch/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 */
base19arch/mips/kernel/ioport.cstatic void set_bitmap(unsigned long *bitmap, short base, short extent, int new_value)
base22arch/mips/kernel/ioport.cunsigned long *bitmap_base = bitmap + (base >> 5);
base23arch/mips/kernel/ioport.cunsigned short low_index = base & 0x1f;
base2209drivers/block/floppy.cchar *base;
base2211drivers/block/floppy.cbase = CURRENT->buffer;
base2217drivers/block/floppy.cwhile (bh && bh->b_data == base + size){
base347drivers/block/triton.cunsigned short base, time;
base350drivers/block/triton.cbase = bmiba;
base353drivers/block/triton.cbase = bmiba + 8;
base356drivers/block/triton.cprintk("    %s: BusMaster DMA at 0x%04x-0x%04x", hwif->name, base, base+7);
base357drivers/block/triton.cif (check_region(base, 8)) {
base360drivers/block/triton.crequest_region(base, 8, hwif->name);
base361drivers/block/triton.chwif->dma_base = base;
base373drivers/block/triton.coutl(virt_to_bus(hwif->dmatable), base + 4);
base215drivers/cdrom/cdu31a.cunsigned short base;         /* I/O Base Address */
base3041drivers/cdrom/cdu31a.cwhile (   (cdu31a_addresses[i].base != 0)
base3044drivers/cdrom/cdu31a.cif (check_region(cdu31a_addresses[i].base, 4)) {
base3048drivers/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);
base118drivers/cdrom/optcd.cstatic short isp16_config( int base, u_char drive_type, int irq, int dma );
base1586drivers/cdrom/optcd.cisp16_config( int base, u_char drive_type, int irq, int dma )
base1596drivers/cdrom/optcd.cswitch (base) {
base1602drivers/cdrom/optcd.cprintk( "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 );
base178drivers/char/console.cextern int serial_echo_init (int base);
base248drivers/char/console.cserial_echo_init(int base)
base252drivers/char/console.cif (base != 0x2f8 && base != 0x3f8) {
base256drivers/char/console.cserial_echo_port = base;
base1868drivers/char/console.clong base = (long) vc_scrbuf[currcons];
base1876drivers/char/console.cpos = origin = video_mem_start = base;
base1877drivers/char/console.cscr_end = base + video_screen_size;
base1878drivers/char/console.cvideo_mem_end = base + video_screen_size;
base847drivers/char/keyboard.cif (accent_table[i].diacr == d && accent_table[i].base == ch)
base1019drivers/char/keyboard.cint base;
base1025drivers/char/keyboard.cbase = 10;
base1028drivers/char/keyboard.cbase = 16;
base1034drivers/char/keyboard.cnpadch = npadch * base + value;
base527drivers/char/lp.cint base, size;
base530drivers/char/lp.cbase = LP_B(offset);
base531drivers/char/lp.csize = (base == 0x3bc)? 3 : 8;
base532drivers/char/lp.cif (check_region(base, size) < 0)
base535drivers/char/lp.coutb_p(LP_DUMMY, base);
base537drivers/char/lp.ctestvalue = inb_p(base);
base541drivers/char/lp.cprintk("lp%d at 0x%04x, ", offset, base);
base542drivers/char/lp.crequest_region(base, size, "lp");
base612drivers/char/lp.cint base, size;
base613drivers/char/lp.cbase = LP_B(offset);
base614drivers/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;
base288drivers/net/depca.cvolatile s32 base;
base294drivers/net/depca.cvolatile s32 base;
base685drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
base688drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
base692drivers/net/depca.cprintk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
base695drivers/net/depca.cprintk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
base699drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
base702drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
base706drivers/net/depca.cprintk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
base709drivers/net/depca.cprintk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
base777drivers/net/depca.cwritel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
base783drivers/net/depca.c&lp->tx_ring[i].base);
base924drivers/net/depca.c!(readl(&lp->rx_ring[entry].base) & R_OWN);
base926drivers/net/depca.cstatus = readl(&lp->rx_ring[entry].base) >> 16 ;
base995drivers/net/depca.cwritel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
base996drivers/net/depca.c&lp->rx_ring[lp->rx_old].base);
base998drivers/net/depca.cwritel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
base1022drivers/net/depca.cstatus = readl(&lp->tx_ring[entry].base) >> 16 ;
base1567drivers/net/depca.cif (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
base1584drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
base1590drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
base1595drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
base1597drivers/net/depca.cwritel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
base1601drivers/net/depca.cwritel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
base1604drivers/net/depca.cwritel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
base167drivers/net/lance.cint base;
base173drivers/net/lance.cint    base;
base674drivers/net/lance.clp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
base680drivers/net/lance.clp->tx_ring[i].base = 0;
base732drivers/net/lance.clp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
base736drivers/net/lance.clp->tx_ring[i].base, -lp->tx_ring[i].length,
base802drivers/net/lance.clp->tx_ring[entry].base =
base807drivers/net/lance.clp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
base820drivers/net/lance.cif (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
base870drivers/net/lance.cint status = lp->tx_ring[entry].base;
base875drivers/net/lance.clp->tx_ring[entry].base = 0;
base966drivers/net/lance.cwhile (lp->rx_ring[entry].base >= 0) {
base967drivers/net/lance.cint status = lp->rx_ring[entry].base >> 24;
base980drivers/net/lance.clp->rx_ring[entry].base &= 0x03ffffff;
base990drivers/net/lance.cif (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
base995drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
base1004drivers/net/lance.c(unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
base1014drivers/net/lance.clp->rx_ring[entry].base |= 0x80000000;
base104drivers/net/ni52.c#define make24(ptr32) ((char *) (ptr32) - p->base)
base181drivers/net/ni52.cunsigned long base;
base251drivers/net/ni52.cp->base = (unsigned long) where + size - 0x01000000;
base253drivers/net/ni52.cp->scp = (struct scp_struct *)(p->base + SCP_DEFAULT_ADDRESS);
base289drivers/net/ni52.cp->scp  = (struct scp_struct *)  (p->base + SCP_DEFAULT_ADDRESS);
base400drivers/net/ni52.c((struct priv *) (dev->priv))->base =  dev->mem_start + size - 0x01000000;
base810drivers/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 */
base495drivers/pci/pci.cunsigned long base;
base588drivers/pci/pci.cbase = l;
base589drivers/pci/pci.cif (!base) {
base593drivers/pci/pci.cif (base & PCI_BASE_ADDRESS_SPACE_IO) {
base596drivers/pci/pci.cbase & PCI_BASE_ADDRESS_IO_MASK);
base600drivers/pci/pci.cif (base & PCI_BASE_ADDRESS_MEM_PREFETCH) {
base605drivers/pci/pci.cswitch (base & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
base615drivers/pci/pci.cbase |= ((u64) l) << 32;
base621drivers/pci/pci.cbase & PCI_BASE_ADDRESS_MEM_MASK);
base303drivers/scsi/53c7,8xx.cint base;  /* Memory address - indicates memory mapped regs */
base351drivers/scsi/53c7,8xx.coverrides[commandline_current].data.normal.base = ints[1];
base681drivers/scsi/53c7,8xx.cu32 base, int io_port, int irq, int dma, int pci_valid, 
base708drivers/scsi/53c7,8xx.cchip_str, base, io_port, irq);
base795drivers/scsi/53c7,8xx.cif (base) {
base796drivers/scsi/53c7,8xx.cinstance->base = (unsigned char*) (unsigned long) base;
base864drivers/scsi/53c7,8xx.cu32 base;
base890drivers/scsi/53c7,8xx.cPCI_BASE_ADDRESS_1, (int *) &base)) ||
base928drivers/scsi/53c7,8xx.cif ((base & PCI_BASE_ADDRESS_SPACE) != PCI_BASE_ADDRESS_SPACE_MEMORY) {
base931drivers/scsi/53c7,8xx.cbase = 0;
base933drivers/scsi/53c7,8xx.cbase &= PCI_BASE_ADDRESS_MEM_MASK;
base935drivers/scsi/53c7,8xx.cbase = 0;
base938drivers/scsi/53c7,8xx.cif (!io_port && !base) {
base970drivers/scsi/53c7,8xx.creturn normal_init (tpnt, board, chip, (int) base, io_port, 
base1008drivers/scsi/53c7,8xx.coverrides[current_override].data.normal.base, 
base1054drivers/scsi/53c7,8xx.cu32 base;
base1102drivers/scsi/53c7,8xx.cbase = (u32) host->io_port;
base1107drivers/scsi/53c7,8xx.cbase = virt_to_phys(host->base);
base1111drivers/scsi/53c7,8xx.cpatch_abs_32 (hostdata->script, 0, addr_scratch, base + SCRATCHA_REG_800);
base1112drivers/scsi/53c7,8xx.cpatch_abs_32 (hostdata->script, 0, addr_sfbr, base + SFBR_REG);
base1113drivers/scsi/53c7,8xx.cpatch_abs_32 (hostdata->script, 0, addr_temp, base + TEMP_REG);
base1323drivers/scsi/53c7,8xx.hNCR53c7x0_address_memory = (void *) (host)->base;      \
base125drivers/scsi/aha1542.c#define aha1542_intr_reset(base)  outb(IRST, CONTROL(base))
base162drivers/scsi/aha1542.cstatic int aha1542_out(unsigned int base, unchar *cmdp, int len)
base169drivers/scsi/aha1542.cWAIT(STATUS(base), CDF, 0, CDF);
base171drivers/scsi/aha1542.cif(inb(STATUS(base)) & CDF) {restore_flags(flags); continue;}
base172drivers/scsi/aha1542.coutb(*cmdp, DATA(base));
base180drivers/scsi/aha1542.cWAIT(STATUS(base), CDF, 0, CDF);
base181drivers/scsi/aha1542.coutb(*cmdp++, DATA(base));
base194drivers/scsi/aha1542.cstatic int aha1542_in(unsigned int base, unchar *cmdp, int len)
base202drivers/scsi/aha1542.cWAIT(STATUS(base), DF, DF, 0);
base203drivers/scsi/aha1542.c*cmdp++ = inb(DATA(base));
base216drivers/scsi/aha1542.cstatic int aha1542_in1(unsigned int base, unchar *cmdp, int len)
base224drivers/scsi/aha1542.cWAITd(STATUS(base), DF, DF, 0, 100);
base225drivers/scsi/aha1542.c*cmdp++ = inb(DATA(base));
base792drivers/scsi/aha1542.cstatic int aha1542_mbenable(int base)
base801drivers/scsi/aha1542.caha1542_out(base,mbenable_cmd,1);
base802drivers/scsi/aha1542.cif(aha1542_in1(base,mbenable_result,2))
base804drivers/scsi/aha1542.cWAITd(INTRFLAGS(base),INTRMASK,HACC,0,100);
base805drivers/scsi/aha1542.caha1542_intr_reset(base);
base812drivers/scsi/aha1542.caha1542_out(base,mbenable_cmd,3);
base813drivers/scsi/aha1542.cWAIT(INTRFLAGS(base),INTRMASK,HACC,0);
base819drivers/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)
base819drivers/scsi/aic7xxx.coutb(p->pause, HCNTRL(p->base));      \
base820drivers/scsi/aic7xxx.cwhile ((inb(HCNTRL(p->base)) & PAUSE) == 0)    \
base828drivers/scsi/aic7xxx.coutb(p->unpause, HCNTRL(p->base))
base835drivers/scsi/aic7xxx.coutb(SEQRESET | FASTMODE, SEQCTL(p->base));    \
base836drivers/scsi/aic7xxx.c} while (inb(SEQADDR0(p->base)) != 0 &&    \
base837drivers/scsi/aic7xxx.cinb(SEQADDR1(p->base)) != 0);    \
base1008drivers/scsi/aic7xxx.cint                      base;             /* card base address */
base1059drivers/scsi/aic7xxx.cint              base;       /* I/O base */
base1133drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(p->base));
base1134drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(p->base));
base1161drivers/scsi/aic7xxx.cprintk("AIC7770%s AT EISA SLOT %d:\n", BUSW[p->bus_type], p->base >> 12);
base1165drivers/scsi/aic7xxx.cprintk("AIC7770%s AT VLB SLOT %d:\n", BUSW[p->bus_type], p->base >> 12);
base1328drivers/scsi/aic7xxx.caic7xxx_loadseq(int base)
base1352drivers/scsi/aic7xxx.coutb(PERRORDIS | SEQRESET | LOADRAM, SEQCTL(base));
base1358drivers/scsi/aic7xxx.c:"S" (seqprog), "c" (sizeof(seqprog)), "d" (SEQRAM(base))
base1377drivers/scsi/aic7xxx.coutb(SEQRESET | FASTMODE, SEQCTL(base));
base1378drivers/scsi/aic7xxx.c} while ((inb(SEQADDR0(base)) != 0) && (inb(SEQADDR1(base)) != 0));
base1684drivers/scsi/aic7xxx.caic7xxx_putscb(int base, struct aic7xxx_scb *scb)
base1691drivers/scsi/aic7xxx.coutb(scb->position, QINFIFO(base));
base1702drivers/scsi/aic7xxx.caic7xxx_putscb_dma(int base, struct aic7xxx_scb *scb)
base1710drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base1716drivers/scsi/aic7xxx.c:"S" (scb), "c" (31), "d" (SCBARRAY(base))
base1719drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base1730drivers/scsi/aic7xxx.caic7xxx_getscb(int base, struct aic7xxx_scb *scb)
base1735drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base1741drivers/scsi/aic7xxx.c:"D" (scb), "c" (SCB_UPLOAD_SIZE), "d" (SCBARRAY(base))
base1744drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base1781drivers/scsi/aic7xxx.caic7xxx_unbusy_target(unsigned char target, char channel, int base)
base1784drivers/scsi/aic7xxx.cunsigned long active_port = HA_ACTIVE0(base);
base1852drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(u_long              base,
base1859drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(base));
base1860drivers/scsi/aic7xxx.chead = inb(WAITING_SCBH(base));
base1861drivers/scsi/aic7xxx.ctail = inb(WAITING_SCBT(base));
base1874drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1875drivers/scsi/aic7xxx.coutb(head, SCBARRAY(base) + 30);
base1886drivers/scsi/aic7xxx.coutb(head, SCBPTR(base));
base1887drivers/scsi/aic7xxx.coutb(tail, SCBARRAY(base) + 30);
base1895drivers/scsi/aic7xxx.coutb(head, SCBPTR(base));
base1896drivers/scsi/aic7xxx.cthird_scb = inb(SCBARRAY(base) + 30);
base1897drivers/scsi/aic7xxx.coutb(scb->position, SCBARRAY(base) + 30);
base1898drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1899drivers/scsi/aic7xxx.coutb(third_scb, SCBARRAY(base) + 30);
base1903drivers/scsi/aic7xxx.coutb(tail, SCBPTR(base));
base1905drivers/scsi/aic7xxx.coutb(tail, SCBARRAY(base) + 30);
base1910drivers/scsi/aic7xxx.coutb(head, WAITING_SCBH(base));
base1911drivers/scsi/aic7xxx.coutb(tail, WAITING_SCBT(base));
base1912drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(base));
base1930drivers/scsi/aic7xxx.cint base = p->base;
base1936drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(base));
base1937drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base1938drivers/scsi/aic7xxx.cnext = inb(SCBARRAY(base) + 30);
base1943drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base1944drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, SCBARRAY(base) + 30);
base1945drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
base1955drivers/scsi/aic7xxx.coutb(next, WAITING_SCBH(base));
base1962drivers/scsi/aic7xxx.coutb(prev, SCBPTR(base));
base1963drivers/scsi/aic7xxx.coutb(next, SCBARRAY(base) + 30);
base1968drivers/scsi/aic7xxx.cif (inb(WAITING_SCBT(base)) == scb->position)
base1970drivers/scsi/aic7xxx.coutb(prev, WAITING_SCBT(base));
base1978drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(base));
base1998drivers/scsi/aic7xxx.cint base = p->base;
base2007drivers/scsi/aic7xxx.cactive_scb = inb(SCBPTR(base));
base2014drivers/scsi/aic7xxx.cint queued = inb(QINCNT(base));
base2018drivers/scsi/aic7xxx.csaved_queue[i] = inb(QINFIFO(base));
base2028drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base2029drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2039drivers/scsi/aic7xxx.coutb(saved_queue[queued], QINFIFO(base));
base2049drivers/scsi/aic7xxx.cnext = inb(WAITING_SCBH(base));  /* Start at head of list. */
base2065drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base2067drivers/scsi/aic7xxx.cnext = inb(SCBARRAY(base) + 30);
base2086drivers/scsi/aic7xxx.caic7xxx_unbusy_target(target, channel, base);
base2087drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base2088drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2096drivers/scsi/aic7xxx.coutb(active_scb, SCBPTR(base));
base2108drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(int base)
base2110drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base2112drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base2126drivers/scsi/aic7xxx.cint base = p->base;
base2142drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base2143drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base) + 8;
base2144drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 16;
base2154drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base2155drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base2156drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base);
base2157drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 16;
base2163drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base2164drivers/scsi/aic7xxx.coffset = HA_TARG_SCRATCH(base);
base2165drivers/scsi/aic7xxx.coffset_max = HA_TARG_SCRATCH(base) + 8;
base2188drivers/scsi/aic7xxx.csblkctl = inb(SBLKCTL(base));
base2195drivers/scsi/aic7xxx.coutb(sblkctl ^ SELBUSB, SBLKCTL(base));
base2196drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(base);
base2197drivers/scsi/aic7xxx.coutb(sblkctl, SBLKCTL(base));
base2206drivers/scsi/aic7xxx.caic7xxx_reset_current_bus(base);
base2226drivers/scsi/aic7xxx.cint base, intstat;
base2246drivers/scsi/aic7xxx.cwhile ((p != NULL) && !(inb(INTSTAT(p->base)) & INT_PEND))
base2293drivers/scsi/aic7xxx.cbase = p->base;
base2298drivers/scsi/aic7xxx.cintstat = inb(INTSTAT(base));
base2303drivers/scsi/aic7xxx.cunsigned char errno = inb(ERROR(base));
base2315drivers/scsi/aic7xxx.cinb(ERROR(base)), (inb(SEQADDR1(base)) << 8) | inb(SEQADDR0(base)));
base2327drivers/scsi/aic7xxx.cscsi_id = (inb(SCSIID(base)) >> 4) & 0x0F;
base2330drivers/scsi/aic7xxx.cif (inb(SBLKCTL(base)) & SELBUSB)
base2344drivers/scsi/aic7xxx.crej_byte = inb(HA_REJBYTE(base));
base2352drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2364drivers/scsi/aic7xxx.cscsi_id, channel, inb(SAVED_TCL(base)));
base2370drivers/scsi/aic7xxx.cprintk("SAVED_TCL = 0x%x\n", inb(SAVED_TCL(base)));
base2371drivers/scsi/aic7xxx.caic7xxx_unbusy_target(scsi_id, channel, base);
base2372drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2374drivers/scsi/aic7xxx.coutb(CLRSELTIMEO, CLRSINT1(base));
base2385drivers/scsi/aic7xxx.ctransfer = (inb(HA_ARG_1(base)) << 2);
base2386drivers/scsi/aic7xxx.coffset = inb(ACCUM(base));
base2387drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2405drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2406drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2414drivers/scsi/aic7xxx.coutb(SEND_REJ, HA_RETURN_1(base));
base2426drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));
base2434drivers/scsi/aic7xxx.coutb(SEND_SDTR, HA_RETURN_1(base));
base2443drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2452drivers/scsi/aic7xxx.cbus_width = inb(ACCUM(base));
base2455drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2462drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));
base2501drivers/scsi/aic7xxx.coutb(bus_width | SEND_WDTR, HA_RETURN_1(base));
base2505drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2506drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2519drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2529drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2543drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2551drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base) + scratch_offset);
base2552drivers/scsi/aic7xxx.coutb(scratch, SCSIRATE(base));
base2557drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2559drivers/scsi/aic7xxx.coutb(0, HA_RETURN_1(base));   /* CHECK_CONDITION may change this */
base2569drivers/scsi/aic7xxx.caic7xxx_getscb(base, scb);
base2618drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base2623drivers/scsi/aic7xxx.c:"S" (scb), "c" (SCB_DOWNLOAD_SIZE), "d" (SCBARRAY(base))
base2625drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base2626drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, (SCBARRAY(base) + 30));
base2631drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE0(base)) | (inb(HA_ACTIVE1(base)) << 8);
base2633drivers/scsi/aic7xxx.coutb(active & 0xFF, HA_ACTIVE0(base));
base2634drivers/scsi/aic7xxx.coutb((active >> 8) & 0xFF, HA_ACTIVE1(base));
base2636drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(base, scb, LIST_HEAD);
base2637drivers/scsi/aic7xxx.coutb(SEND_SENSE, HA_RETURN_1(base));
base2679drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2704drivers/scsi/aic7xxx.cactual -= ((inb(SCBARRAY(base + 17)) << 16) |
base2705drivers/scsi/aic7xxx.c(inb(SCBARRAY(base + 16)) <<  8) |
base2706drivers/scsi/aic7xxx.cinb(SCBARRAY(base + 15)));
base2712drivers/scsi/aic7xxx.ccmd->target, cmd->underflow, actual, inb(SCBARRAY(base + 18)));
base2721drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2746drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2763drivers/scsi/aic7xxx.coutb(MSG_BUS_DEVICE_RESET, HA_MSG_START(base));
base2764drivers/scsi/aic7xxx.coutb(1, HA_MSG_LEN(base));
base2775drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2784drivers/scsi/aic7xxx.caic7xxx_unbusy_target(scsi_id, channel, base);
base2789drivers/scsi/aic7xxx.cscratch = inb(HA_TARG_SCRATCH(base) + scratch_offset);
base2791drivers/scsi/aic7xxx.coutb(scratch, HA_TARG_SCRATCH(base));
base2802drivers/scsi/aic7xxx.cintstat, inb(SCSISIGI(base)));
base2805drivers/scsi/aic7xxx.coutb(CLRSEQINT, CLRINT(base));
base2811drivers/scsi/aic7xxx.cint status = inb(SSTAT1(base));
base2813drivers/scsi/aic7xxx.cscb_index = inb(SCBPTR(base));
base2823drivers/scsi/aic7xxx.coutb(status, CLRSINT1(base));
base2825drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2849drivers/scsi/aic7xxx.coutb(ENRSELI, SCSISEQ(base));
base2855drivers/scsi/aic7xxx.cha_flags = inb(HA_FLAGS(base));
base2856drivers/scsi/aic7xxx.coutb(ha_flags & ~ACTIVE_MSG, HA_FLAGS(base));
base2860drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE1(base));
base2862drivers/scsi/aic7xxx.coutb(active, HA_ACTIVE1(base));
base2866drivers/scsi/aic7xxx.cactive = inb(HA_ACTIVE0(base));
base2868drivers/scsi/aic7xxx.coutb(active, HA_ACTIVE0(base));
base2871drivers/scsi/aic7xxx.coutb(SCB_NEEDDMA, SCBARRAY(base));
base2888drivers/scsi/aic7xxx.coutb(CLRSELTIMEO, CLRSINT1(base));
base2890drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2895drivers/scsi/aic7xxx.cwaiting = inb(WAITING_SCBH(base));
base2896drivers/scsi/aic7xxx.coutb(waiting, SCBPTR(base));
base2897drivers/scsi/aic7xxx.cwaiting = inb(SCBARRAY(base) + 30);
base2898drivers/scsi/aic7xxx.coutb(waiting, WAITING_SCBH(base));
base2925drivers/scsi/aic7xxx.coutb(CLRSCSIPERR, CLRSINT1(base));
base2928drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2940drivers/scsi/aic7xxx.coutb(status, CLRSINT1(base));
base2942drivers/scsi/aic7xxx.coutb(CLRSCSIINT, CLRINT(base));
base2960drivers/scsi/aic7xxx.ccomplete = inb(QOUTFIFO(base));
base2968drivers/scsi/aic7xxx.ccomplete, inb(QOUTFIFO(base)),
base2970drivers/scsi/aic7xxx.coutb(CLRCMDINT, CLRINT(base));
base2997drivers/scsi/aic7xxx.coutb(CLRCMDINT, CLRINT(base));
base3050drivers/scsi/aic7xxx.c} while (inb(QOUTCNT(base)));
base3077drivers/scsi/aic7xxx.caic7xxx_probe(int slot, int base)
base3099drivers/scsi/aic7xxx.coutb(0x80 + i, base);
base3100drivers/scsi/aic7xxx.cbuf[i] = inb(base + i);
base3110drivers/scsi/aic7xxx.cif (inb(base + 4) & 1)
base3145drivers/scsi/aic7xxx.cread_2840_seeprom(int base, struct seeprom_config *sc)
base3158drivers/scsi/aic7xxx.cwhile ((inb(STATUS_2840(base)) & EEPROM_TF) == 0)  \
base3162drivers/scsi/aic7xxx.c(void) inb(SEECTL_2840(base));
base3175drivers/scsi/aic7xxx.coutb(CK_2840 | CS_2840, SEECTL_2840(base));
base3176drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3185drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3186drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3188drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3189drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3199drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3200drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3202drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3203drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3215drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3216drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3218drivers/scsi/aic7xxx.cseeprom[k] = (seeprom[k] << 1) | (inb(STATUS_2840(base)) & DI_2840);
base3219drivers/scsi/aic7xxx.coutb(temp, SEECTL_2840(base));
base3220drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3236drivers/scsi/aic7xxx.coutb(0, SEECTL_2840(base));
base3237drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3238drivers/scsi/aic7xxx.coutb(CK_2840, SEECTL_2840(base));
base3239drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3240drivers/scsi/aic7xxx.coutb(0, SEECTL_2840(base));
base3241drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3318drivers/scsi/aic7xxx.cread_seeprom(int base, int offset, struct seeprom_config *sc)
base3332drivers/scsi/aic7xxx.cwhile ((inb(SEECTL(base)) & SEERDY) == 0)  \
base3344drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3346drivers/scsi/aic7xxx.cwhile ((jiffies < timeout) && ((inb(SEECTL(base)) & SEERDY) == 0))
base3350drivers/scsi/aic7xxx.cif ((inb(SEECTL(base)) & SEERDY) == 0)
base3352drivers/scsi/aic7xxx.coutb(0, SEECTL(base));
base3367drivers/scsi/aic7xxx.coutb(SEEMS | SEECK | SEECS, SEECTL(base));
base3368drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3377drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3378drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3380drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3381drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3391drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3392drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3394drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3395drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3407drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3408drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3410drivers/scsi/aic7xxx.cseeprom[k] = (seeprom[k] << 1) | (inb(SEECTL(base)) & SEEDI);
base3411drivers/scsi/aic7xxx.coutb(temp, SEECTL(base));
base3412drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3429drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3430drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3431drivers/scsi/aic7xxx.coutb(SEEMS | SEECK, SEECTL(base));
base3432drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3433drivers/scsi/aic7xxx.coutb(SEEMS, SEECTL(base));
base3434drivers/scsi/aic7xxx.cCLOCK_PULSE(base);
base3440drivers/scsi/aic7xxx.coutb(0, SEECTL(base));
base3474drivers/scsi/aic7xxx.cdetect_maxscb(aha_type type, int base, int walk_scbs)
base3492drivers/scsi/aic7xxx.csblkctl_reg = inb(SBLKCTL(base)) ^ AUTOFLUSHDIS;
base3493drivers/scsi/aic7xxx.coutb(sblkctl_reg, SBLKCTL(base));
base3494drivers/scsi/aic7xxx.cif (inb(SBLKCTL(base)) == sblkctl_reg)
base3500drivers/scsi/aic7xxx.coutb(sblkctl_reg ^ AUTOFLUSHDIS, SBLKCTL(base));
base3543drivers/scsi/aic7xxx.coutb(i, SCBPTR(base));
base3544drivers/scsi/aic7xxx.cscb_byte = ~(inb(SCBARRAY(base)));  /* complement the byte */
base3545drivers/scsi/aic7xxx.coutb(scb_byte, SCBARRAY(base));     /* write it back out */
base3546drivers/scsi/aic7xxx.cif (inb(SCBARRAY(base)) != scb_byte)
base3574drivers/scsi/aic7xxx.cint found = 1, base;
base3583drivers/scsi/aic7xxx.cbase = config->base;
base3588drivers/scsi/aic7xxx.crequest_region(MINREG(base), MAXREG(base) - MINREG(base), "aic7xxx");
base3594drivers/scsi/aic7xxx.cprintk("aha274x: HCNTRL:0x%x\n", inb(HCNTRL(base)));
base3606drivers/scsi/aic7xxx.cconfig->unpause = (inb(HCNTRL(base)) & IRQMS) | INTEN;
base3610drivers/scsi/aic7xxx.coutb(config->pause | CHIPRST, HCNTRL(base));
base3612drivers/scsi/aic7xxx.cif (inb(HCNTRL(base)) & CHIPRST)
base3616drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3622drivers/scsi/aic7xxx.cconfig->irq = inb(HA_INTDEF(base)) & 0x0F;
base3623drivers/scsi/aic7xxx.cif ((inb(HA_274_BIOSCTRL(base)) & BIOSMODE) == BIOSDISABLED)
base3627drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(base));
base3631drivers/scsi/aic7xxx.coutb(host_conf & DFTHRSH, BUSSPD(base));
base3632drivers/scsi/aic7xxx.coutb((host_conf << 2) & BOFF, BUSTIME(base));
base3643drivers/scsi/aic7xxx.cprintk("aha284x: HCNTRL:0x%x\n", inb(HCNTRL(base)));
base3645drivers/scsi/aic7xxx.coutb(CHIPRST, HCNTRL(base));
base3649drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3652drivers/scsi/aic7xxx.cconfig->irq = inb(HA_INTDEF(base)) & 0x0F;
base3653drivers/scsi/aic7xxx.cif ((inb(HA_274_BIOSCTRL(base)) & BIOSMODE) == BIOSDISABLED)
base3657drivers/scsi/aic7xxx.chost_conf = inb(HA_HOSTCONF(base));
base3660drivers/scsi/aic7xxx.chave_seeprom = read_2840_seeprom(base, &sc);
base3681drivers/scsi/aic7xxx.coutb(host_conf & DFTHRSH, BUSSPD(base));
base3682drivers/scsi/aic7xxx.coutb((host_conf << 2) & BOFF, BUSTIME(base));
base3694drivers/scsi/aic7xxx.cprintk("aic%s HCNTRL:0x%x\n", board_name[config->type], inb(HCNTRL(base)));
base3697drivers/scsi/aic7xxx.coutb(CHIPRST, HCNTRL(base));
base3701drivers/scsi/aic7xxx.coutb(config->pause, HCNTRL(base));
base3707drivers/scsi/aic7xxx.chave_seeprom = read_seeprom(base, config->chan_num * (sizeof(sc) / 2), &sc);
base3736drivers/scsi/aic7xxx.coutb(inb(DSPCISTATUS(base)) | DFTHRESH, DSPCISTATUS(base));
base3737drivers/scsi/aic7xxx.coutb(config->scsi_id | DFTHRESH, HA_SCSICONF(base));
base3742drivers/scsi/aic7xxx.coutb(config->scsi_id, (HA_SCSICONF(base) + 1));
base3752drivers/scsi/aic7xxx.cconfig->maxscb = detect_maxscb(config->type, base, config->walk_scbs);
base3770drivers/scsi/aic7xxx.csblkctl = inb(SBLKCTL(base));
base3774drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base)) & 0x07;
base3776drivers/scsi/aic7xxx.coutb(SINGLE_BUS, HA_FLAGS(base));
base3780drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base) + 1) & 0x0F;
base3784drivers/scsi/aic7xxx.coutb(WIDE_BUS, HA_FLAGS(base));
base3788drivers/scsi/aic7xxx.cconfig->scsi_id = inb(HA_SCSICONF(base)) & 0x07;
base3790drivers/scsi/aic7xxx.cconfig->scsi_id_b = inb(HA_SCSICONF(base) + 1) & 0x07;
base3794drivers/scsi/aic7xxx.coutb(TWIN_BUS, HA_FLAGS(base));
base3799drivers/scsi/aic7xxx.coutb(0, HA_FLAGS(base));
base3805drivers/scsi/aic7xxx.c"mail deang@ims.com\n", inb(SBLKCTL(base)));
base3806drivers/scsi/aic7xxx.coutb(0, HA_FLAGS(base));
base3815drivers/scsi/aic7xxx.coutb(sblkctl & ~(DIAGLEDEN | DIAGLEDON), SBLKCTL(base));
base3912drivers/scsi/aic7xxx.cp->base = base;
base3968drivers/scsi/aic7xxx.caic7xxx_loadseq(base);
base3973drivers/scsi/aic7xxx.coutb(FASTMODE, SEQCTL(base));
base3977drivers/scsi/aic7xxx.coutb(ENABLE, BCTL(base));
base3990drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELBUSB, SBLKCTL(base));
base3992drivers/scsi/aic7xxx.coutb(config->scsi_id_b, SCSIID(base));
base3993drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(base) + 1) & (ENSPCHK | STIMESEL);
base3994drivers/scsi/aic7xxx.coutb(scsi_conf | ENSTIMER | ACTNEGEN | STPWEN, SXFRCTL1(base));
base3995drivers/scsi/aic7xxx.coutb(ENSELTIMO | ENSCSIPERR, SIMODE1(base));
base3998drivers/scsi/aic7xxx.coutb(ULTRAEN, SXFRCTL0(base));
base4004drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELSINGLE, SBLKCTL(base));
base4006drivers/scsi/aic7xxx.coutb(config->scsi_id, SCSIID(base));
base4007drivers/scsi/aic7xxx.cscsi_conf = inb(HA_SCSICONF(base)) & (ENSPCHK | STIMESEL);
base4008drivers/scsi/aic7xxx.coutb(scsi_conf | ENSTIMER | ACTNEGEN | STPWEN, SXFRCTL1(base));
base4009drivers/scsi/aic7xxx.coutb(ENSELTIMO | ENSCSIPERR, SIMODE1(base));
base4012drivers/scsi/aic7xxx.coutb(ULTRAEN, SXFRCTL0(base));
base4053drivers/scsi/aic7xxx.cp->discenable = ~((inb(HA_DISC_DSB(base + 1)) << 8) |
base4054drivers/scsi/aic7xxx.cinb(HA_DISC_DSB(base)));
base4078drivers/scsi/aic7xxx.ctarget_settings = inb(HA_TARG_SCRATCH(base) + i);
base4098drivers/scsi/aic7xxx.coutb(target_settings, (HA_TARG_SCRATCH(base) + i));
base4114drivers/scsi/aic7xxx.coutb(i, SCBPTR(base));
base4115drivers/scsi/aic7xxx.coutb(0, SCBARRAY(base));
base4122drivers/scsi/aic7xxx.coutb(config->maxscb, HA_SCBCOUNT(base));
base4127drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE0(base));
base4128drivers/scsi/aic7xxx.coutb(0, HA_ACTIVE1(base));
base4133drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, WAITING_SCBH(base));
base4134drivers/scsi/aic7xxx.coutb(SCB_LIST_NULL, WAITING_SCBT(base));
base4157drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELBUSB, SBLKCTL(base));
base4159drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base4161drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base4166drivers/scsi/aic7xxx.coutb((sblkctl & ~SELBUS_MASK) | SELSINGLE, SBLKCTL(base));
base4169drivers/scsi/aic7xxx.coutb(SCSIRSTO, SCSISEQ(base));
base4171drivers/scsi/aic7xxx.coutb(0, SCSISEQ(base));
base4198drivers/scsi/aic7xxx.cint found = 0, slot, base;
base4228drivers/scsi/aic7xxx.cbase = SLOTBASE(slot);
base4230drivers/scsi/aic7xxx.cif (check_region(MINREG(base), MAXREG(base) - MINREG(base)))
base4239drivers/scsi/aic7xxx.ctype = aic7xxx_probe(slot, HID0(base));
base4248drivers/scsi/aic7xxx.cprintk("aic7xxx: HCNTRL:0x%x\n", inb(HCNTRL(base)));
base4249drivers/scsi/aic7xxx.coutb(inb(HCNTRL(base)) | CHIPRST, HCNTRL(base));
base4258drivers/scsi/aic7xxx.cconfig.base = base;
base4399drivers/scsi/aic7xxx.cbase = io_port - 0xC01;
base4409drivers/scsi/aic7xxx.cconfig.base = base;
base4667drivers/scsi/aic7xxx.ccurscb = inb(SCBPTR(p->base));
base4668drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(p->base));
base4669drivers/scsi/aic7xxx.caic7xxx_putscb_dma(p->base, scb);
base4670drivers/scsi/aic7xxx.coutb(curscb, SCBPTR(p->base));
base4711drivers/scsi/aic7xxx.caic7xxx_putscb(p->base, scb);
base4748drivers/scsi/aic7xxx.cint base = p->base;
base4789drivers/scsi/aic7xxx.cactive_scb = inb(SCBPTR(base));
base4791drivers/scsi/aic7xxx.ccontrol = inb(SCBARRAY(base));
base4796drivers/scsi/aic7xxx.coutb(scb->position, SCBPTR(base));
base4797drivers/scsi/aic7xxx.cif (inb(SCBARRAY(base)) & SCB_DIS)
base4804drivers/scsi/aic7xxx.coutb(SCBAUTO, SCBCNT(base));
base4809drivers/scsi/aic7xxx.c:"S" (scb), "c" (SCB_DOWNLOAD_SIZE), "d" (SCBARRAY(base))
base4811drivers/scsi/aic7xxx.coutb(0, SCBCNT(base));
base4812drivers/scsi/aic7xxx.caic7xxx_add_waiting_scb(base, scb, LIST_SECOND);
base4822drivers/scsi/aic7xxx.cunsigned char flags = inb(HA_FLAGS(base));
base4839drivers/scsi/aic7xxx.coutb(flags | ACTIVE_MSG, HA_FLAGS(base));
base4840drivers/scsi/aic7xxx.coutb(1, HA_MSG_LEN(base));
base4841drivers/scsi/aic7xxx.coutb(MSG_BUS_DEVICE_RESET, HA_MSG_START(base));
base172drivers/scsi/aic7xxx_proc.csize += sprintf(BLS, "               Base IO: %#.4x\n", p->base);
base161drivers/scsi/eata_dma.cuint base;
base172drivers/scsi/eata_dma.cif (!(inb((uint)sh->base + HA_RAUXSTAT) & HA_AIRQ))
base180drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS);
base182drivers/scsi/eata_dma.c"received. CCB pointer not set.\n", base, (long)cp);
base187drivers/scsi/eata_dma.cbase = (uint) cmd->host->base;
base194drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS);
base197drivers/scsi/eata_dma.c"%lx, irq%d\n", base, (long)cp, eata_stat, hba_stat, 
base206drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS);
base213drivers/scsi/eata_dma.ceata_stat = inb(base + HA_RSTATUS); 
base216drivers/scsi/eata_dma.cirq, base, cmd->pid, cmd->target, cmd->lun, 
base310drivers/scsi/eata_dma.cinline int eata_send_command(u32 addr, u32 base, u8 command)
base314drivers/scsi/eata_dma.cwhile (inb(base + HA_RAUXSTAT) & HA_ABUSY)
base319drivers/scsi/eata_dma.coutb( addr & 0x000000ff,      base + HA_WDMAADDR);
base320drivers/scsi/eata_dma.coutb((addr & 0x0000ff00) >> 8,  base + HA_WDMAADDR + 1);
base321drivers/scsi/eata_dma.coutb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
base322drivers/scsi/eata_dma.coutb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
base323drivers/scsi/eata_dma.coutb(command, base + HA_WCOMMAND);
base328drivers/scsi/eata_dma.cinline int eata_send_immediate(u32 addr, u32 base, u8 cmnd, u8 cmnd2, u8 id, 
base332drivers/scsi/eata_dma.coutb( addr & 0x000000ff,  base + HA_WDMAADDR);
base333drivers/scsi/eata_dma.coutb((addr & 0x0000ff00) >> 8,  base + HA_WDMAADDR + 1);
base334drivers/scsi/eata_dma.coutb((addr & 0x00ff0000) >> 16, base + HA_WDMAADDR + 2);
base335drivers/scsi/eata_dma.coutb((addr & 0xff000000) >> 24, base + HA_WDMAADDR + 3);
base337drivers/scsi/eata_dma.coutb(id,  base + HA_WSUBCODE);
base338drivers/scsi/eata_dma.coutb(lun, base + HA_WSUBLUN);
base341drivers/scsi/eata_dma.coutb(cmnd2, base + HA_WCOMMAND2);
base342drivers/scsi/eata_dma.coutb(cmnd,  base + HA_WCOMMAND);
base511drivers/scsi/eata_dma.cif(eata_send_command((u32) cp, (u32) sh->base, EATA_CMD_DMA_SEND_CP) == FALSE) {
base522drivers/scsi/eata_dma.c"slot %d irq %d\n", (s32)sh->base, cmd->pid, 
base544drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
base600drivers/scsi/eata_dma.cwhile (inb((u32)(cmd->host->base) + HA_RAUXSTAT) & HA_ABUSY)
base639drivers/scsi/eata_dma.cinb((u32) (cmd->host->base) + HA_RSTATUS);  /* This might cause trouble */
base640drivers/scsi/eata_dma.ceata_send_command(0, (u32) cmd->host->base, EATA_CMD_RESET);
base692drivers/scsi/eata_dma.cchar * get_board_data(u32 base, u32 irq, u32 id)
base731drivers/scsi/eata_dma.cfake_int_base = base;
base735drivers/scsi/eata_dma.ceata_send_command((u32) cp, (u32) base, EATA_CMD_DMA_SEND_CP);
base751drivers/scsi/eata_dma.cinb((u32) (base) + HA_RSTATUS);
base752drivers/scsi/eata_dma.ceata_send_command(0, base, EATA_CMD_RESET);
base761drivers/scsi/eata_dma.cint check_blink_state(long base)
base771drivers/scsi/eata_dma.cstate = inl((uint) base + 1);
base783drivers/scsi/eata_dma.cint get_conf_PIO(u32 base, struct get_conf *buf)
base788drivers/scsi/eata_dma.cif(check_region(base, 9)) 
base793drivers/scsi/eata_dma.cwhile (inb(base + HA_RSTATUS) & HA_SBUSY)
base798drivers/scsi/eata_dma.cprintk("Issuing PIO READ CONFIG to HBA at %#x\n", base));
base799drivers/scsi/eata_dma.ceata_send_command(0, base, EATA_CMD_PIO_READ_CONFIG);
base804drivers/scsi/eata_dma.cwhile (!(inb(base + HA_RSTATUS) & HA_SDRQ))
base809drivers/scsi/eata_dma.c*p = inw(base + HA_RDATA);
base812drivers/scsi/eata_dma.cif (!(inb(base + HA_RSTATUS) & HA_SERROR)) {      /* Error ? */
base815drivers/scsi/eata_dma.c"EATA Level: %x\n", (uint) base, 
base818drivers/scsi/eata_dma.cwhile (inb(base + HA_RSTATUS) & HA_SDRQ) 
base819drivers/scsi/eata_dma.cinw(base + HA_RDATA);
base824drivers/scsi/eata_dma.c"for HBA at %lx\n", (long)base));
base848drivers/scsi/eata_dma.cshort register_HBA(u32 base, struct get_conf *gc, Scsi_Host_Template * tpnt, 
base864drivers/scsi/eata_dma.c"Please use the EATA-PIO driver.\n", base);
base894drivers/scsi/eata_dma.cdma_channel, base);
base907drivers/scsi/eata_dma.cbuff = get_board_data(base, gc->IRQ, gc->scsi_id[3]);
base916drivers/scsi/eata_dma.cprintk("HBA at %#.4x doesn't support DMA. Sorry\n", base);
base919drivers/scsi/eata_dma.cbase);
base935drivers/scsi/eata_dma.c&buff[16], base);
base937drivers/scsi/eata_dma.crequest_region(base, 9, "eata_dma"); /* We already checked the 
base1034drivers/scsi/eata_dma.csh->unique_id = base;
base1035drivers/scsi/eata_dma.csh->base = (char *) base;
base1036drivers/scsi/eata_dma.csh->io_port = base;
base1112drivers/scsi/eata_dma.cu32 base;
base1122drivers/scsi/eata_dma.cbase = 0x1c88 + (i * 0x1000);
base1124drivers/scsi/eata_dma.cpal1 = inb((u16)base - 8);
base1125drivers/scsi/eata_dma.cpal2 = inb((u16)base - 7);
base1126drivers/scsi/eata_dma.cpal3 = inb((u16)base - 6);
base1134drivers/scsi/eata_dma.cif (get_conf_PIO(base, buf) == TRUE) {
base1137drivers/scsi/eata_dma.cregister_HBA(base, buf, tpnt, IS_EISA);
base1141drivers/scsi/eata_dma.cif (check_blink_state(base)) 
base1184drivers/scsi/eata_dma.cu32 base = 0;
base1225drivers/scsi/eata_dma.cPCI_BASE_ADDRESS_0, (int *) &base))){
base1228drivers/scsi/eata_dma.cif (base & 0x01) {
base1229drivers/scsi/eata_dma.cbase &= 0xfffffffe;
base1231drivers/scsi/eata_dma.cpal1 = inb(base);
base1232drivers/scsi/eata_dma.cpal2 = inb(base + 1);
base1233drivers/scsi/eata_dma.cpal3 = inb(base + 2);
base1239drivers/scsi/eata_dma.cbase += 0x08;
base1241drivers/scsi/eata_dma.cbase += 0x10;   /* Now, THIS is the real address */
base1243drivers/scsi/eata_dma.cif (base != 0x1f8) {
base1245drivers/scsi/eata_dma.cif (get_conf_PIO(base, buf) == TRUE) {
base1252drivers/scsi/eata_dma.cregister_HBA(base, buf, tpnt, IS_PCI);
base1254drivers/scsi/eata_dma.cif (base < 0x1000) {
base1256drivers/scsi/eata_dma.cif (ISAbases[x] == base) {
base1261drivers/scsi/eata_dma.c} else if ((base & 0x0fff) == 0x0c88) 
base1262drivers/scsi/eata_dma.cEISAbases[(base >> 12) & 0x0f] = 0;
base1264drivers/scsi/eata_dma.c} else if (check_blink_state(base) == TRUE) {
base1330drivers/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;
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))
base147drivers/scsi/t128.c#define NO_BASES (sizeof (bases) / sizeof (struct base))
base202drivers/scsi/t128.cunsigned char *base;
base208drivers/scsi/t128.cbase = NULL;
base211drivers/scsi/t128.cbase = overrides[current_override].address;
base213drivers/scsi/t128.cfor (; !base && (current_base < NO_BASES); ++current_base) {
base221drivers/scsi/t128.cbase = bases[current_base].address;
base230drivers/scsi/t128.cprintk("scsi-t128 : base = %08x\n", (unsigned int) base);
base233drivers/scsi/t128.cif (!base)
base237drivers/scsi/t128.cinstance->base = base;
base263drivers/scsi/t128.cinstance->base);
base323drivers/scsi/t128.cregister unsigned char *reg = (unsigned char *) (instance->base + 
base330drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base332drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base338drivers/scsi/t128.cif (*(instance->base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
base341drivers/scsi/t128.cfoo = instance->base + T_CONTROL_REG_OFFSET;
base367drivers/scsi/t128.cregister unsigned char *reg = (unsigned char *) (instance->base + 
base373drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base375drivers/scsi/t128.cwhile (!(instance->base[T_STATUS_REG_OFFSET]) & T_ST_RDY) barrier();
base381drivers/scsi/t128.cif (*(instance->base + T_STATUS_REG_OFFSET) & T_ST_TIM) {
base384drivers/scsi/t128.cfoo = instance->base + T_CONTROL_REG_OFFSET;
base131drivers/scsi/t128.hvolatile unsigned char *base
base134drivers/scsi/t128.hvolatile unsigned char *base
base137drivers/scsi/t128.hbase = (volatile unsigned char *) (instance)->base
base139drivers/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;
base111drivers/sound/ad1848.c#define io_Index_Addr(d)  ((d)->base)
base112drivers/sound/ad1848.c#define io_Indexed_Data(d)  ((d)->base+1)
base113drivers/sound/ad1848.c#define io_Status(d)    ((d)->base+2)
base114drivers/sound/ad1848.c#define io_Polled_IO(d)    ((d)->base+3)
base137drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base156drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base180drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) & 0x80)
base182drivers/sound/ad1848.cif (inb (devc->base) & 0x80)
base235drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base260drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)  /*Are we initializing */
base969drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
base983drivers/sound/ad1848.cwhile (timeout > 0 && inb (devc->base) == 0x80)
base1133drivers/sound/ad1848.cdevc->base = io_base;
base1152drivers/sound/ad1848.cif ((inb (devc->base) & 0x80) != 0x00)  /* Not a AD1848 */
base1155drivers/sound/ad1848.cinb (devc->base)));
base1270drivers/sound/ad1848.cif (devc->base != MOZART_PORT + 4)
base1368drivers/sound/ad1848.crequest_region (devc->base, 4, devc->chip_name);
base1517drivers/sound/ad1848.cif (dev_info[i].base == io_base)
base1525drivers/sound/ad1848.crelease_region (devc->base, 4);
base78drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base85drivers/sound/cs4232.cif (check_region (base, 4))
base87drivers/sound/cs4232.cprintk ("cs4232.c: I/O port 0x%03x not free\n", base);
base125drivers/sound/cs4232.cCS_OUT3 (0x47, (base >> 8) & 0xff, base & 0xff);  /* WSSbase */
base172drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base178drivers/sound/cs4232.cad1848_init ("CS4232", base,
base218drivers/sound/cs4232.cint             base = hw_config->io_base, irq = hw_config->irq;
base224drivers/sound/cs4232.cad1848_unload (base,
base52drivers/sound/mpu401.cint             base;  /*
base90drivers/sound/mpu401.c#define  DATAPORT(base)   (base)
base91drivers/sound/mpu401.c#define  COMDPORT(base)   (base+1)
base92drivers/sound/mpu401.c#define  STATPORT(base)   (base+1)
base94drivers/sound/mpu401.c#define mpu401_status(devc)    inb( STATPORT(devc->base))
base97drivers/sound/mpu401.c#define write_command(devc, cmd)  outb( cmd,  COMDPORT(devc->base))
base98drivers/sound/mpu401.c#define read_data(devc)    inb( DATAPORT(devc->base))
base100drivers/sound/mpu401.c#define write_data(devc, byte)  outb( byte,  DATAPORT(devc->base))
base478drivers/sound/mpu401.cif (devc->base != 0 && (devc->opened & OPEN_READ || devc->mode == MODE_SYNTH))
base1037drivers/sound/mpu401.cdevc->base = hw_config->io_base;
base1270drivers/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))
base158drivers/sound/pss.cset_io_base (pss_config * devc, int dev, int base)
base161drivers/sound/pss.cunsigned short  bits = (base & 0x0ffc) << 4;
base333drivers/sound/pss.cdevc->base = hw_config->io_base;
base860drivers/sound/sb_dsp.csmw_putmem (int base, int addr, unsigned char val)
base867drivers/sound/sb_dsp.coutb (addr & 0xff, base + 1);  /* Low address bits */
base868drivers/sound/sb_dsp.coutb (addr >> 8, base + 2);  /* High address bits */
base869drivers/sound/sb_dsp.coutb (val, base);    /* Data */
base875drivers/sound/sb_dsp.csmw_getmem (int base, int addr)
base883drivers/sound/sb_dsp.coutb (addr & 0xff, base + 1);  /* Low address bits */
base884drivers/sound/sb_dsp.coutb (addr >> 8, base + 2);  /* High address bits */
base885drivers/sound/sb_dsp.cval = inb (base);    /* Data */
base68drivers/sound/sscape.c#define PORT(name)  (devc->base+name)
base91drivers/sound/sscape.cint             base, irq, dma;
base413drivers/sound/sscape.cif (inb (devc->base + HOST_CTRL) & 0x80)
base416drivers/sound/sscape.cif (inb (devc->base) != 0x00)
base1036drivers/sound/sscape.cdevc->base = hw_config->io_base;
base1099drivers/sound/sscape.cinb (devc->base + ODIE_ADDR);
base60drivers/sound/trix.cdownload_boot (int base)
base66drivers/sound/trix.coutb (0x01, base + 6);  /* Clear the internal data pointer */
base67drivers/sound/trix.coutb (0x00, base + 6);  /* Restart */
base73drivers/sound/trix.coutb (0x01, base + 6);  /* Clear the internal data pointer */
base80drivers/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);
base229fs/read_write.cvoid * base;
base232fs/read_write.cbase = vector->iov_base;
base236fs/read_write.cnr = fn(inode, file, base, len);
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);
base482include/linux/fs.hstruct inode ** res_inode, struct inode * base);
base118include/linux/kd.hu_char diacr, base, result;
base30include/linux/ldt.hextern int set_ldt_entry(int entry, unsigned long base, unsigned int limit,
base80include/linux/lp.h#define LP_B(minor)  lp_table[(minor)].base    /* IO address */
base83include/linux/lp.h#define LP_C(minor)  (lp_table[(minor)].base + 2)  /* control port */
base103include/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)
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);
base125net/ipv4/af_inet.cunsigned short get_new_socknum(struct proto *prot, unsigned short base)
base139net/ipv4/af_inet.cif (base == 0) 
base140net/ipv4/af_inet.cbase = PROT_SOCK+1+(start % 1024);
base141net/ipv4/af_inet.cif (base <= PROT_SOCK) 
base143net/ipv4/af_inet.cbase += PROT_SOCK+(start % 1024);
base153net/ipv4/af_inet.csk = prot->sock_array[(i+base+1) &(SOCK_ARRAY_SIZE -1)];
base162net/ipv4/af_inet.creturn(i+base+1);
base173net/ipv4/af_inet.cwhile(sk_inuse(prot, base +best+1)) 
base177net/ipv4/af_inet.creturn(best+base+1);
base1343net/ipv4/tcp.cunsigned long saddr, unsigned long daddr, unsigned long base)
base1345net/ipv4/tcp.creturn csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base);
base205net/ipv4/udp.cstatic unsigned short udp_check(struct udphdr *uh, int len, unsigned long saddr, unsigned long daddr, unsigned long base)
base207net/ipv4/udp.creturn(csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base));