/*
 * Copyright 2008 Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Alexander Coers         Alexander.Coers@gmx.de
 *              Fredrik Modéen                 fredrik@modeen.se
 *              Axel Dörfler           axeld@pinc-software.de
 */

#include "driver.h"

#include <stdio.h>
#include <string.h>

#include <KernelExport.h>
#include <PCI.h>

#define TRACE_DRIVER
#ifdef TRACE_DRIVER
#       define TRACE(x) dprintf x
#else
#       define TRACE(x) ;
#endif

int32   api_version = B_CUR_DRIVER_API_VERSION;

int num_names = 0;
int num_cards = 0;

char *gDeviceNames[MAX_CARDS + 1];
gameport_info cards[MAX_CARDS];

/* setup_card used to initialize cards, structures or hardware */
static status_t
setup_card (gameport_info* card)
{
        char * name = card->name;
        uint32 command_reg = 0; 
        area_id area;
        int32 base,size;
  
        dprintf (DRIVER_NAME ": setup_card() trying to init structures \n");
    /* enable PCI i/o  */
        command_reg = PCI_command_io || PCI_command_master ;
        
        (*pci->write_pci_config)(card->info.bus,card->info.device, 
                card->info.function, PCI_command, 2, 0);
        
        /* disable all i/o -regs and bus_mastering */
        base = card->info.u.h0.base_registers[0];
        size = card->info.u.h0.base_register_sizes[0];
        
        (*pci->write_pci_config) (card->info.bus,card->info.device, 
                card->info.function, 0x10, 2, base);
        
        (*pci->write_pci_config) (card->info.bus,card->info.device, 
                card->info.function, PCI_command, 2, command_reg);
        
        /* enable i/o- regs and possible bus_mastering */
        dprintf (DRIVER_NAME ": setup_card() enabled card with i/o regs from "
                "0x%04x to 0x%04x \n",base,base+size-1);
  
        if ((*gameport->create_device)((int32)base, &card->joy.driver) < B_OK) {
                dprintf (DRIVER_NAME ": setup_card() Gameport setup failed! Failed to "
                        "load Generic Gameport Module \n");
                return B_ERROR;
        }
        
        sprintf(card->joy.name1, "joystick/"DRIVER_NAME "/%x", base);
        gDeviceNames[num_names++] = card->joy.name1;
        gDeviceNames[num_names] = NULL;
        return B_OK;
}


extern "C" status_t
init_hardware (void)
{
        status_t err = ENODEV;
        pci_info info;
        int ix = 0;
        uint32 buffer;
        
        /* probe PCI bus */
        if (get_module (pci_name, (module_info **)&pci))
                return ENOSYS;
        while ((*pci->get_nth_pci_info)(ix, &info) == B_OK) {
                /* look for HARDWARE */
                if (info.vendor_id == VENDOR_ID_CREATIVE && 
                        info.device_id == DEVICE_ID_CREATIVE_EMU10K1) {
                        err = B_OK;
                        
                        dprintf (DRIVER_NAME ": init_hardware() found one, Revision %02x\n"
                                ,info.revision);
                        
                        if (!(info.u.h0.subsystem_id == 0x20 ||
                                info.u.h0.subsystem_id == 0xc400 || 
                                        (info.u.h0.subsystem_id == 0x21 && info.revision < 6))) {
                        buffer = (*pci->read_io_32)(info.u.h0.base_registers[0] + HCFG);
                        buffer |= HCFG_JOYENABLE;
                        (*pci->write_io_32)(info.u.h0.base_registers[0] + HCFG, buffer);
                        }
                        /* Some SB-Live cards need to the Joyenable Bit in the config 
                                Register, others don´t */ 
                }
        ix++;
        }
        put_module (B_PCI_MODULE_NAME);
        return err;
}


extern "C" status_t 
init_driver (void)
{
        area_id area;
        area_info       ainfo;
        pci_info info;
    int ix = 0;
        dprintf (DRIVER_NAME ": init_driver() " __DATE__ " " __TIME__ "\n");

        /* probe PCI bus */
        if (get_module (pci_name, (module_info **)&pci))
                return ENOSYS;
        
        if (get_module (gameport_name, (module_info **)&gameport)) {
                dprintf (DRIVER_NAME ": Failed to load Generic Gameport Module \n");
                put_module (pci_name);
                return ENOSYS;
        }
        
        while ((*pci->get_nth_pci_info)(ix, &info) == B_OK) {
                if (info.vendor_id == VENDOR_ID_CREATIVE && (
                        info.device_id == SBLIVE_ID || 
                        info.device_id == AUDIGY_ID ||
                        info.device_id == SBLIVE_DELL_ID)) {
                                
                        if (num_cards == MAX_CARDS) {
                                dprintf(DRIVER_NAME  ": Too many cards installed!\n");
                                break;
                        }
                                                
                        memset(&cards[num_cards], 0, sizeof(gameport_info));
                        cards[num_cards].info = info;
                        if (setup_card(&cards[num_cards]))
                                dprintf(DRIVER_NAME ": Setup of card %ld failed \n", 
                                        num_cards + 1);
                        else
                                num_cards++;
                }
                ix++;
        }
        
        if (!num_cards) {
                dprintf(DRIVER_NAME ": no cards \n");
                put_module(pci_name);
                return ENODEV;
    }
    return B_OK;
}


void
uninit_driver (void)
{
        int ix = 0;
        area_id area;
        dprintf (DRIVER_NAME ": uninit_driver()\n");
        for (ix = 0; ix < num_cards; ix++) {
                area = find_area (AREA_NAME);
                if (area >= 0)
                        delete_area (area);
                (*gameport->delete_device)(cards[ix].joy.driver);
        }
        memset(&cards, 0, sizeof(cards));
        put_module (gameport_name);
        put_module (pci_name);
        num_cards = 0;
}


extern "C" const char**
publish_devices()
{
        return (const char **)gDeviceNames;
}


static int
lookup_device_name (const char *name)
{
        int i;
        for (i = 0; gDeviceNames[i]; i++)
                if (!strcmp (gDeviceNames[i], name))
                        return i;
        return -1;
}


static status_t
device_open(const char* name, uint32 flags, void** cookie)
{
        int ix;
        int offset = -1;

        *cookie = NULL;
        for (ix = 0; ix < num_cards; ix++) {
                if (!strcmp(name, cards[ix].joy.name1)) {
                        offset = 0;
                        break;
                }
        }
        
        if (offset < 0) {
                return ENODEV;
        }
                        
   return (*gameport->open_hook)(cards[ix].joy.driver, flags, cookie);
}


static status_t
device_close(void * cookie)
{
        return (*gameport->close_hook)(cookie);
}


static status_t
device_free(void * cookie)
{
        return (*gameport->free_hook)(cookie);
}


static status_t
device_control(void * cookie, uint32 iop, void * data, size_t len)
{
        return (*gameport->control_hook)(cookie, iop, data, len);
}


static status_t
device_read(void * cookie, off_t pos, void * data, size_t * nread)
{       
        return (*gameport->read_hook)(cookie, pos, data, nread);
}


static status_t
device_write(void * cookie, off_t pos, const void * data, size_t * nwritten)
{
        (*pci->write_io_32) ((int)vaddr,0);     
        return (*gameport->write_hook)(cookie, pos, data, nwritten);
}

device_hooks gDeviceHooks = {
    device_open,
    device_close,
    device_free,
    device_control,
    device_read,
    device_write,
    NULL,               /* select */
    NULL,               /* deselect */
    NULL,               /* readv */
    NULL                /* writev */
};


device_hooks*
find_device(const char* name)
{
        if (lookup_device_name (name) >= 0) {
             return &gDeviceHooks;
        }
        return NULL;
}