/*****************************************************************************
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);
}
