* Copyright (C) 2007 JiSheng Zhang <jszhang3@gmail.com>. All rights reserved
* Distributed under the terms of the MIT license.
*
* Kernel driver for firewire
*/
#include <OS.h>
#include <KernelExport.h>
#include <SupportDefs.h>
#include <PCI.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <dpc.h>
#include "fwdebug.h"
#include "queue.h"
#include "fwglue.h"
#include "firewire.h"
#include "iec13213.h"
#include "firewirereg.h"
#include "fwdma.h"
#include "fwohcireg.h"
#include "fwohcivar.h"
#include "firewire_module.h"
status_t fwohci_pci_attach(int index);
status_t fwohci_pci_detach(int index);
pci_info *pciInfo[MAX_CARDS];
fwohci_softc_t *gFwohci_softc[MAX_CARDS];
struct firewire_softc *gFirewire_softc[MAX_CARDS];
pci_module_info *gPci;
dpc_module_info *gDpc;
struct supported_device{
uint16 vendor_id;
uint32 device_id;
const char *name;
};
struct supported_device supported_devices[] = {
{FW_VENDORID_NATSEMI, FW_DEVICE_CS4210, "National Semiconductor CS4210"},
{FW_VENDORID_NEC, FW_DEVICE_UPD861, "NEC uPD72861"},
{FW_VENDORID_NEC, FW_DEVICE_UPD871, "NEC uPD72871/2"},
{FW_VENDORID_NEC, FW_DEVICE_UPD72870, "NEC uPD72870"},
{FW_VENDORID_NEC, FW_DEVICE_UPD72873, "NEC uPD72873"},
{FW_VENDORID_NEC, FW_DEVICE_UPD72874, "NEC uPD72874"},
{FW_VENDORID_SIS, FW_DEVICE_7007, "SiS 7007"},
{FW_VENDORID_TI, FW_DEVICE_TITSB22, "Texas Instruments TSB12LV22"},
{FW_VENDORID_TI, FW_DEVICE_TITSB23, "Texas Instruments TSB12LV23"},
{FW_VENDORID_TI, FW_DEVICE_TITSB26, "Texas Instruments TSB12LV26"},
{FW_VENDORID_TI, FW_DEVICE_TITSB43, "Texas Instruments TSB43AA22"},
{FW_VENDORID_TI, FW_DEVICE_TITSB43A, "Texas Instruments TSB43AB22/A"},
{FW_VENDORID_TI, FW_DEVICE_TITSB43AB21, "Texas Instruments TSB43AB21/A/AI/A-EP"},
{FW_VENDORID_TI, FW_DEVICE_TITSB43AB23, "Texas Instruments TSB43AB23"},
{FW_VENDORID_TI, FW_DEVICE_TITSB82AA2, "Texas Instruments TSB82AA2"},
{FW_VENDORID_TI, FW_DEVICE_TIPCI4450, "Texas Instruments PCI4450"},
{FW_VENDORID_TI, FW_DEVICE_TIPCI4410A, "Texas Instruments PCI4410A"},
{FW_VENDORID_TI, FW_DEVICE_TIPCI4451, "Texas Instruments PCI4451"},
{FW_VENDORID_VIA, FW_DEVICE_VT6306, "VIA Fire II (VT6306)"},
{FW_VENDORID_RICOH, FW_DEVICE_R5C551, "Ricoh R5C551"},
{FW_VENDORID_RICOH, FW_DEVICE_R5C552, "Ricoh R5C552"},
{FW_VENDORID_APPLE, FW_DEVICE_PANGEA, "Apple Pangea"},
{FW_VENDORID_APPLE, FW_DEVICE_UNINORTH, "Apple UniNorth"},
{FW_VENDORID_LUCENT, FW_DEVICE_FW322, "Lucent FW322/323"},
{FW_VENDORID_INTEL, FW_DEVICE_82372FB, "Intel 82372FB"},
{FW_VENDORID_ADAPTEC, FW_DEVICE_AIC5800, "Adaptec AHA-894x/AIC-5800"},
{FW_VENDORID_SUN, FW_DEVICE_PCIO2FW, "Sun PCIO-2"},
{FW_VENDORID_SONY, FW_DEVICE_CXD3222, "Sony i.LINK (CXD3222)"},
{0, 0, NULL}
};
static int
find_device_name(pci_info *info)
{
struct supported_device *device;
for (device = supported_devices; device->name; device++) {
if (info->vendor_id == device->vendor_id
&& info->device_id == device->device_id >> 16) {
dprintf("%s\n", device->name);
return 1;
}
}
return 0;
}
#if 0
static status_t
fw_add_child(const char *childname,
const struct firewire_notify_hooks *hooks)
{
status_t status;
int i;
TRACE("add child %s\n", childname);
for (i = 0; gFirewire_softc[i] != NULL; i++) {
status = firewire_add_child(gFirewire_softc[i], childname, hooks);
if (status != B_OK)
return status;
}
return B_OK;
}
static status_t
fw_remove_child(const char *childname)
{
status_t status;
int i;
TRACE("remove child %s\n", childname);
for (i = 0; gFirewire_softc[i] != NULL; i++) {
status = firewire_remove_child(gFirewire_softc[i], childname);
if (status != B_OK)
return status;
}
return B_OK;
}
#endif
static int
fw_get_handle(int socket, struct firewire_softc **handle)
{
if (handle == NULL)
return B_BAD_VALUE;
if (socket >= 0 && socket < MAX_CARDS && gFirewire_softc[socket]) {
*handle = gFirewire_softc[socket];
return B_OK;
}
*handle = NULL;
return ENODEV;
}
static status_t
fw_module_init(void)
{
status_t status;
int i, found;
fwohci_softc_t *fwohci_sc;
struct firewire_softc *fw_sc;
pci_info *info = (pci_info*)malloc(sizeof(pci_info));
if (!info)
return B_NO_MEMORY;
if ((status = get_module(B_PCI_MODULE_NAME,(module_info **)&gPci)) != B_OK) {
TRACE("pci module unavailable\n");
free(info);
return status;
}
if ((status = get_module(B_DPC_MODULE_NAME,(module_info **)&gDpc)) != B_OK) {
TRACE("pci module unavailable\n");
free(info);
put_module(B_PCI_MODULE_NAME);
return status;
}
memset(gFwohci_softc, 0, sizeof(gFwohci_softc));
for (i = 0, found = 0; (status = gPci->get_nth_pci_info(i, info)) == B_OK; i++) {
if (find_device_name(info)
|| ((info->class_base == PCI_serial_bus)
&& (info->class_sub == PCI_firewire)
&& (info->class_api == PCI_INTERFACE_OHCI))) {
dprintf( "vendor=%x, device=%x, revision = %x\n", info->vendor_id, info->device_id, info->revision);
pciInfo[found] = info;
fwohci_sc = (fwohci_softc_t*)malloc(sizeof(fwohci_softc_t));
if (!fwohci_sc) {
free(info);
goto err_outofmem;
}
memset(fwohci_sc, 0, sizeof(fwohci_softc_t));
gFwohci_softc[found] = fwohci_sc;
fw_sc = (firewire_softc*)malloc(sizeof(struct firewire_softc));
if (!fw_sc) {
free(info);
free(fwohci_sc);
goto err_outofmem;
}
memset(fw_sc, 0, sizeof(struct firewire_softc));
gFirewire_softc[found] = fw_sc;
if (found < MAX_CARDS - 1)
gFirewire_softc[found + 1] = NULL;
found++;
info = (pci_info*)malloc(sizeof(pci_info));
if (!info)
goto err_outofmem;
if (found == MAX_CARDS)
break;
}
}
TRACE("found %d cards\n", found);
free(info);
if ((status = initialize_timer()) != B_OK) {
ERROR("timer init failed\n");
goto err_timer;
}
for (i = 0; i < found; i++) {
if (fwohci_pci_attach(i) != B_OK) {
ERROR("fwohci_pci_attach failed\n");
goto err_pci;
}
}
return B_OK;
err_pci:
terminate_timer();
err_timer:
err_outofmem:
for (i = 0; i < found; i++) {
free(gFirewire_softc[i]);
free(gFwohci_softc[i]);
free(pciInfo[i]);
}
put_module(B_PCI_MODULE_NAME);
put_module(B_DPC_MODULE_NAME);
return B_ERROR;
}
static status_t
fw_module_uninit(void)
{
int i;
terminate_timer();
for (i = 0; i < MAX_CARDS && gFirewire_softc[i] != NULL; i++) {
fwohci_pci_detach(i);
free(gFirewire_softc[i]);
free(gFwohci_softc[i]);
free(pciInfo[i]);
}
put_module(B_PCI_MODULE_NAME);
put_module(B_DPC_MODULE_NAME);
return B_OK;
}
static status_t
fw_module_std_ops(int32 op, ...)
{
switch (op) {
case B_MODULE_INIT:
TRACE("fw_module_init\n");
return fw_module_init();
case B_MODULE_UNINIT:
TRACE("fw_module_uninit\n");
return fw_module_uninit();
}
return B_BAD_VALUE;
}
static struct fw_module_info gModuleInfo = {
{
{
FIREWIRE_MODULE_NAME,
0,
fw_module_std_ops
},
NULL
},
fw_noderesolve_nodeid,
fw_noderesolve_eui64,
fw_asyreq,
fw_xferwake,
fw_xferwait,
fw_bindlookup,
fw_bindadd,
fw_bindremove,
fw_xferlist_add,
fw_xferlist_remove,
fw_xfer_alloc,
fw_xfer_alloc_buf,
fw_xfer_done,
fw_xfer_unload,
fw_xfer_free_buf,
fw_xfer_free,
fw_asy_callback_free,
fw_open_isodma,
fw_get_handle,
fwdma_malloc_multiseg,
fwdma_free_multiseg
};
module_info *modules[] = {
(module_info *)&gModuleInfo,
NULL
};
