/*
 *      Davicom DM9601 USB 1.1 Ethernet Driver.
 *      Copyright (c) 2008, 2011 Siarzhuk Zharski <imker@gmx.li>
 *      Copyright (c) 2009 Adrien Destugues <pulkomandy@gmail.com>
 *      Distributed under the terms of the MIT license.
 *
 *      Heavily based on code of the
 *      Driver for USB Ethernet Control Model devices
 *      Copyright (C) 2008 Michael Lotz <mmlr@mlotz.ch>
 *      Distributed under the terms of the MIT license.
 */


#include "Driver.h"

#include <stdio.h>

#include <lock.h>
#include <util/AutoLock.h>

#include "DavicomDevice.h"
#include "Settings.h"


int32 api_version = B_CUR_DRIVER_API_VERSION;
static const char *sDeviceBaseName = "net/usb_davicom/";
DavicomDevice *gDavicomDevices[MAX_DEVICES];
char *gDeviceNames[MAX_DEVICES + 1];
usb_module_info *gUSBModule = NULL;
mutex gDriverLock;


// IMPORTANT: keep entries sorted by ids to let the
// binary search lookup procedure work correctly !!!
DeviceInfo gSupportedDevices[] = {
        { { 0x01e1, 0x9601 }, "Noname DM9601" },
        { { 0x07aa, 0x9601 }, "Corega FEther USB-TXC" },
        { { 0x0a46, 0x0268 }, "ShanTou ST268 USB NIC" },
        { { 0x0a46, 0x6688 }, "ZT6688 USB NIC" },
        { { 0x0a46, 0x8515 }, "ADMtek ADM8515 USB NIC" },
        { { 0x0a46, 0x9000 }, "DM9000E" },
        { { 0x0a46, 0x9601 }, "Davicom DM9601" },
        { { 0x0a47, 0x9601 }, "Hirose USB-100" },
        { { 0x0fe6, 0x8101 }, "Sunrising SR9600" },
        { { 0x0fe6, 0x9700 }, "Kontron DM9601" }
};


DavicomDevice *
lookup_and_create_device(usb_device device)
{
        const usb_device_descriptor *deviceDescriptor
                = gUSBModule->get_device_descriptor(device);

        if (deviceDescriptor == NULL) {
                TRACE_ALWAYS("Error of getting USB device descriptor.\n");
                return NULL;
        }

        TRACE("trying %#06x:%#06x.\n",
                        deviceDescriptor->vendor_id, deviceDescriptor->product_id);

        // use binary search to lookup device in table
        uint32 id = deviceDescriptor->vendor_id << 16
                                        | deviceDescriptor->product_id;
        int left  = -1;
        int right = B_COUNT_OF(gSupportedDevices);
        while ((right - left) > 1) {
                int i = (left + right) / 2;
                ((gSupportedDevices[i].Key() < id) ? left : right) = i;
        }

        if (gSupportedDevices[right].Key() == id)
                return new DavicomDevice(device, gSupportedDevices[right]);

        TRACE_ALWAYS("Search for %#x failed %d-%d.\n", id, left, right);
        return NULL;
}


status_t
usb_davicom_device_added(usb_device device, void **cookie)
{
        *cookie = NULL;

        MutexLocker lock(gDriverLock); // released on exit

        // check if this is a replug of an existing device first
        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i] == NULL)
                        continue;

                if (gDavicomDevices[i]->CompareAndReattach(device) != B_OK)
                        continue;

                TRACE("The device is plugged back. Use entry at %ld.\n", i);
                *cookie = gDavicomDevices[i];
                return B_OK;
        }

        // no such device yet, create a new one
        DavicomDevice *davicomDevice = lookup_and_create_device(device);
        if (davicomDevice == 0) {
                return ENODEV;
        }

        status_t status = davicomDevice->InitCheck();
        if (status < B_OK) {
                delete davicomDevice;
                return status;
        }

        status = davicomDevice->SetupDevice(false);
        if (status < B_OK) {
                delete davicomDevice;
                return status;
        }

        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i] != NULL)
                        continue;

                gDavicomDevices[i] = davicomDevice;
                *cookie = davicomDevice;

                TRACE("New device is added at %ld.\n", i);
                return B_OK;
        }

        // no space for the device
        TRACE_ALWAYS("Error: no more device entries availble.\n");

        delete davicomDevice;
        return B_ERROR;
}


status_t
usb_davicom_device_removed(void *cookie)
{
        MutexLocker lock(gDriverLock); // released on exit

        DavicomDevice *device = (DavicomDevice *)cookie;
        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i] == device) {
                        if (device->IsOpen()) {
                                // the device will be deleted upon being freed
                                device->Removed();
                        } else {
                                gDavicomDevices[i] = NULL;
                                delete device;
                                TRACE("Device at %ld deleted.\n", i);
                        }
                        break;
                }
        }

        return B_OK;
}


// #pragma mark -


status_t
init_hardware()
{
        return B_OK;
}


status_t
init_driver()
{
        status_t status = get_module(B_USB_MODULE_NAME,
                (module_info **)&gUSBModule);
        if (status < B_OK)
                return status;

        load_settings();

        TRACE_ALWAYS("%s\n", kVersion);

        for (int32 i = 0; i < MAX_DEVICES; i++)
                gDavicomDevices[i] = NULL;

        gDeviceNames[0] = NULL;
        mutex_init(&gDriverLock, DRIVER_NAME"_devices");

        static usb_notify_hooks notifyHooks = {
                &usb_davicom_device_added,
                &usb_davicom_device_removed
        };

        const size_t count = B_COUNT_OF(gSupportedDevices);
        static usb_support_descriptor sDescriptors[count] = {{ 0 }};

        for (size_t i = 0; i < count; i++) {
                sDescriptors[i].vendor  = gSupportedDevices[i].VendorId();
                sDescriptors[i].product = gSupportedDevices[i].ProductId();
        }

        gUSBModule->register_driver(DRIVER_NAME, sDescriptors, count, NULL);
        gUSBModule->install_notify(DRIVER_NAME, &notifyHooks);
        return B_OK;
}


void
uninit_driver()
{
        gUSBModule->uninstall_notify(DRIVER_NAME);
        mutex_lock(&gDriverLock);

        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i]) {
                        delete gDavicomDevices[i];
                        gDavicomDevices[i] = NULL;
                }
        }

        for (int32 i = 0; gDeviceNames[i]; i++) {
                free(gDeviceNames[i]);
                gDeviceNames[i] = NULL;
        }

        mutex_destroy(&gDriverLock);
        put_module(B_USB_MODULE_NAME);

        release_settings();
}


static status_t
usb_davicom_open(const char *name, uint32 flags, void **cookie)
{
        MutexLocker lock(gDriverLock); // released on exit

        *cookie = NULL;
        status_t status = ENODEV;
        int32 index = strtol(name + strlen(sDeviceBaseName), NULL, 10);
        if (index >= 0 && index < MAX_DEVICES && gDavicomDevices[index]) {
                status = gDavicomDevices[index]->Open(flags);
                *cookie = gDavicomDevices[index];
        }

        return status;
}


static status_t
usb_davicom_read(void *cookie, off_t position, void *buffer, size_t *numBytes)
{
        DavicomDevice *device = (DavicomDevice *)cookie;
        return device->Read((uint8 *)buffer, numBytes);
}


static status_t
usb_davicom_write(void *cookie, off_t position, const void *buffer,
        size_t *numBytes)
{
        DavicomDevice *device = (DavicomDevice *)cookie;
        return device->Write((const uint8 *)buffer, numBytes);
}


static status_t
usb_davicom_control(void *cookie, uint32 op, void *buffer, size_t length)
{
        DavicomDevice *device = (DavicomDevice *)cookie;
        return device->Control(op, buffer, length);
}


static status_t
usb_davicom_close(void *cookie)
{
        DavicomDevice *device = (DavicomDevice *)cookie;
        return device->Close();
}


static status_t
usb_davicom_free(void *cookie)
{
        DavicomDevice *device = (DavicomDevice *)cookie;

        MutexLocker lock(gDriverLock); // released on exit

        status_t status = device->Free();
        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i] == device) {
                        // the device is removed already but as it was open the
                        // removed hook has not deleted the object
                        gDavicomDevices[i] = NULL;
                        delete device;
                        TRACE("Device at %ld deleted.\n", i);
                        break;
                }
        }

        return status;
}


const char **
publish_devices()
{
        for (int32 i = 0; gDeviceNames[i]; i++) {
                free(gDeviceNames[i]);
                gDeviceNames[i] = NULL;
        }

        MutexLocker lock(gDriverLock); // released on exit

        int32 deviceCount = 0;
        for (int32 i = 0; i < MAX_DEVICES; i++) {
                if (gDavicomDevices[i] == NULL)
                        continue;

                gDeviceNames[deviceCount] = (char *)malloc(strlen(sDeviceBaseName) + 4);
                if (gDeviceNames[deviceCount]) {
                        sprintf(gDeviceNames[deviceCount], "%s%" B_PRId32, sDeviceBaseName, i);
                        TRACE("publishing %s\n", gDeviceNames[deviceCount]);
                        deviceCount++;
                } else
                        TRACE_ALWAYS("Error: out of memory during allocating dev.name.\n");
        }

        gDeviceNames[deviceCount] = NULL;
        return (const char **)&gDeviceNames[0];
}


device_hooks *
find_device(const char *name)
{
        static device_hooks deviceHooks = {
                usb_davicom_open,
                usb_davicom_close,
                usb_davicom_free,
                usb_davicom_control,
                usb_davicom_read,
                usb_davicom_write,
                NULL,                           // select
                NULL                            // deselect
        };

        return &deviceHooks;
}