/***************************************************************************** Function name : orc_ReturnNumberOfAdapters Description : This function will scan PCI bus to get all Orchid card Input : None. Output : None. Return : SUCCESSFUL - Successful scan ohterwise - No drives founded *****************************************************************************/ int orc_ReturnNumberOfAdapters(void) { unsigned int i, iAdapters; iAdapters = 0; /* * PCI-bus probe. */ if (pcibios_present()) { struct { unsigned short vendor_id; unsigned short device_id; } const inia100_pci_devices[] = { {ORC_VENDOR_ID, I920_DEVICE_ID}, {ORC_VENDOR_ID, ORC_DEVICE_ID} }; unsigned int dRegValue; unsigned short command; WORD wBIOS, wBASE; BYTE bPCIBusNum, bInterrupt, bPCIDeviceNum; #ifdef MMAPIO unsigned long page_offset, base; #endif #if LINUX_VERSION_CODE > CVT_LINUX_VERSION(2,1,92) struct pci_dev *pdev = NULL; #else int index; unsigned char pci_bus, pci_devfn; #endif bPCIBusNum = 0; bPCIDeviceNum = 0; init_inia100Adapter_table(); for (i = 0; i < NUMBER(inia100_pci_devices); i++) { #if LINUX_VERSION_CODE > CVT_LINUX_VERSION(2,1,92) pdev = NULL; while ((pdev = pci_find_device(inia100_pci_devices[i].vendor_id, inia100_pci_devices[i].device_id, pdev))) #else index = 0; while (!(pcibios_find_device(inia100_pci_devices[i].vendor_id, inia100_pci_devices[i].device_id, index++, &pci_bus, &pci_devfn))) #endif { if (iAdapters >= MAX_SUPPORTED_ADAPTERS) break; /* Never greater than maximum */ if (i == 0) { /* printk("inia100: The RAID controller is not supported by\n"); printk("inia100: this driver, we are ignoring it.\n"); */ } else { /* * Read sundry information from PCI BIOS. */ #if LINUX_VERSION_CODE > CVT_LINUX_VERSION(2,1,92) bPCIBusNum = pdev->bus->number; bPCIDeviceNum = pdev->devfn; dRegValue = pdev->base_address[0]; if (dRegValue == -1) { /* Check return code */ printk("\n\rinia100: orchid read configuration error.\n"); return (0); /* Read configuration space error */ } /* <02> read from base address + 0x50 offset to get the wBIOS balue. */ wBASE = (WORD) dRegValue; /* Now read the interrupt line */ dRegValue = pdev->irq; bInterrupt = dRegValue & 0xFF; /* Assign interrupt line */ pci_read_config_word(pdev, PCI_COMMAND, &command); pci_write_config_word(pdev, PCI_COMMAND, command | PCI_COMMAND_MASTER | PCI_COMMAND_IO); #else bPCIBusNum = pci_bus; bPCIDeviceNum = pci_devfn; pcibios_read_config_dword(pci_bus, pci_devfn, PCI_BASE_ADDRESS_0, &dRegValue); if (dRegValue == -1) { /* Check return code */ printk("\n\rinia100: Orchid read configuration error.\n"); return (0); /* Read configuration space error */ } /* <02> read from base address + 0x50 offset to get the wBIOS balue. */ wBASE = (WORD) dRegValue; /* Now read the interrupt line */ pcibios_read_config_dword(pci_bus, pci_devfn, PCI_INTERRUPT_LINE, &dRegValue); bInterrupt = dRegValue & 0xFF; /* Assign interrupt line */ pcibios_read_config_word(pci_bus, pci_devfn, PCI_COMMAND, &command); pcibios_write_config_word(pci_bus, pci_devfn, PCI_COMMAND, command | PCI_COMMAND_MASTER | PCI_COMMAND_IO); #endif wBASE &= PCI_BASE_ADDRESS_IO_MASK; wBIOS = ORC_RDWORD(wBASE, 0x50); #ifdef MMAPIO base = wBASE & PAGE_MASK; page_offset = wBASE - base; /* * replace the next line with this one if you are using 2.1.x: * temp_p->maddr = ioremap(base, page_offset + 256); */ #if LINUX_VERSION_CODE >= CVT_LINUX_VERSION(2,1,0) wBASE = ioremap(base, page_offset + 256); #else wBASE = (WORD) vremap(base, page_offset + 256); #endif if (wBASE) { wBASE += page_offset; } #endif if (Addinia100_into_Adapter_table(wBIOS, wBASE, bInterrupt, bPCIBusNum, bPCIDeviceNum) == SUCCESSFUL) iAdapters++; } } /* while(pdev=....) */ } /* for PCI_DEVICES */ } /* PCI BIOS present */ return (iAdapters); }
static struct device * RCfound_device(struct device *dev, int memaddr, int irq, int bus, int function, int product_index, int card_idx) { int dev_size = 32768; unsigned long *vaddr=0; PDPA pDpa; int init_status; /* * Allocate and fill new device structure. * We need enough for struct device plus DPA plus the LAN API private * area, which requires a minimum of 16KB. The top of the allocated * area will be assigned to struct device; the next chunk will be * assigned to DPA; and finally, the rest will be assigned to the * the LAN API layer. */ dev = (struct device *) kmalloc(dev_size, GFP_DMA | GFP_KERNEL |GFP_ATOMIC); memset(dev, 0, dev_size); #ifdef RCDEBUG printk("rc: dev = 0x%08X\n", (uint)dev); #endif /* * dev->priv will point to the start of DPA. */ dev->priv = (void *)(((long)dev + sizeof(struct device) + 15) & ~15); pDpa = dev->priv; dev->name = pDpa->devname; pDpa->dev = dev; /* this is just for easy reference */ pDpa->function = function; pDpa->bus = bus; pDpa->id = card_idx; /* the device number */ pDpa->pci_addr = memaddr; PCIAdapters[card_idx] = pDpa; #ifdef RCDEBUG printk("rc: pDpa = 0x%x, id = %d \n", (uint)pDpa, (uint)pDpa->id); #endif /* * Save the starting address of the LAN API private area. We'll * pass that to InitRCApiMsgLayer(). */ pDpa->PLanApiPA = (void *)(((long)pDpa + sizeof(DPA) + 0xff) & ~0xff); #ifdef RCDEBUG printk("rc: pDpa->PLanApiPA = 0x%x\n", (uint)pDpa->PLanApiPA); #endif /* The adapter is accessable through memory-access read/write, not * I/O read/write. Thus, we need to map it to some virtual address * area in order to access the registers are normal memory. */ vaddr = (ulong *) vremap (memaddr, 32768); #ifdef RCDEBUG printk("rc: RCfound_device: 0x%x, priv = 0x%x, vaddr = 0x%x\n", (uint)dev, (uint)dev->priv, (uint)vaddr); #endif dev->base_addr = (unsigned long)vaddr; dev->irq = irq; dev->interrupt = 0; /* * Request a shared interrupt line. */ if ( request_irq(dev->irq, (void *)RCinterrupt, SA_INTERRUPT|SA_SHIRQ, "RedCreek VPN Adapter", dev) ) { printk( "RC PCI 45: %s: unable to get IRQ %d\n", (PU8)dev->name, (uint)dev->irq ); vfree(vaddr); kfree(dev); return 0; } init_status = InitRCApiMsgLayer(pDpa->id, dev->base_addr, pDpa->PLanApiPA, pDpa->PLanApiPA, (PFNTXCALLBACK)RCxmit_callback, (PFNRXCALLBACK)RCrecv_callback, (PFNCALLBACK)RCreboot_callback); #ifdef RCDEBUG printk("rc: msg initted: status = 0x%x\n", init_status); #endif if (init_status) { printk("rc: Unable to initialize msg layer\n"); free_irq(dev->irq, dev); vfree(vaddr); kfree(dev); return 0; } if (RCGetMAC(pDpa->id, dev->dev_addr, NULL)) { printk("rc: Unable to get adapter MAC\n"); free_irq(dev->irq, dev); vfree(vaddr); kfree(dev); return 0; } DriverControlWord |= WARM_REBOOT_CAPABLE; RCReportDriverCapability(pDpa->id, DriverControlWord); dev->init = RCprobe1; ether_setup(dev); /* linux kernel interface */ pDpa->next = root_RCdev; root_RCdev = dev; if (register_netdev(dev) != 0) /* linux kernel interface */ { printk("rc: unable to register device \n"); free_irq(dev->irq, dev); vfree(vaddr); kfree(dev); return 0; } return dev; }
__initfunc(int setup_telespci(struct IsdnCard *card)) { int found=0; struct IsdnCardState *cs = card->cs; char tmp[64]; u_char pci_bus, pci_device_fn, pci_irq; u_int pci_memaddr; strcpy(tmp, telespci_revision); printk(KERN_INFO "HiSax: Teles/PCI driver Rev. %s\n", HiSax_getrev(tmp)); if (cs->typ != ISDN_CTYPE_TELESPCI) return (0); #if CONFIG_PCI for (; pci_index < 0xff; pci_index++) { if (pcibios_find_device (0x11DE, 0x6120, pci_index, &pci_bus, &pci_device_fn) == PCIBIOS_SUCCESSFUL) { found = 1; } else { break; } pcibios_read_config_dword(pci_bus, pci_device_fn, PCI_BASE_ADDRESS_0, &pci_memaddr); pcibios_read_config_byte(pci_bus, pci_device_fn, PCI_INTERRUPT_LINE, &pci_irq); printk(KERN_INFO "Found: Zoran, base-address: 0x%x," " irq: 0x%x\n", pci_memaddr, pci_irq); break; } if (!found) { printk(KERN_WARNING "TelesPCI: No PCI card found\n"); return(0); } pci_index++; cs->hw.teles0.membase = (u_int) vremap(pci_memaddr, PAGE_SIZE); cs->irq = pci_irq; #else printk(KERN_WARNING "HiSax: Teles/PCI and NO_PCI_BIOS\n"); printk(KERN_WARNING "HiSax: Teles/PCI unable to config\n"); return (0); #endif /* CONFIG_PCI */ /* Initialize Zoran PCI controller */ writel(0x00000000, cs->hw.teles0.membase + 0x28); writel(0x01000000, cs->hw.teles0.membase + 0x28); writel(0x01000000, cs->hw.teles0.membase + 0x28); writel(0x7BFFFFFF, cs->hw.teles0.membase + 0x2C); writel(0x70000000, cs->hw.teles0.membase + 0x3C); writel(0x61000000, cs->hw.teles0.membase + 0x40); /* writel(0x00800000, cs->hw.teles0.membase + 0x200); */ printk(KERN_INFO "HiSax: %s config irq:%d mem:%x\n", CardType[cs->typ], cs->irq, cs->hw.teles0.membase); cs->readisac = &ReadISAC; cs->writeisac = &WriteISAC; cs->readisacfifo = &ReadISACfifo; cs->writeisacfifo = &WriteISACfifo; cs->BC_Read_Reg = &ReadHSCX; cs->BC_Write_Reg = &WriteHSCX; cs->BC_Send_Data = &hscx_fill_fifo; cs->cardmsg = &TelesPCI_card_msg; ISACVersion(cs, "TelesPCI:"); if (HscxVersion(cs, "TelesPCI:")) { printk(KERN_WARNING "TelesPCI: wrong HSCX versions check IO/MEM addresses\n"); release_io_telespci(cs); return (0); } return (1); }