/*
 * Copyright 2007, Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Michael Lotz <mmlr@mlotz.ch>
 */
#include <module.h>
#include <device_manager.h>
#include <bus/SCSI.h>


#define MODULE_NAME "example_scsi"


static scsi_for_sim_interface *sSimInterface;
static device_manager_info *sDeviceManager;


// module functions
static status_t
example_std_ops(int32 op, ...)
{
        dprintf(MODULE_NAME": std ops\n");

        switch (op) {
                case B_MODULE_INIT: {
                        dprintf(MODULE_NAME": B_MODULE_INIT\n");
                        return B_OK;
                }

                case B_MODULE_UNINIT: {
                        dprintf(MODULE_NAME": B_MODULE_UNINIT\n");
                        return B_OK;
                }
        }

        return B_ERROR;
}


// driver functions
static float
example_supports_device(device_node_handle parent, bool *noConnection)
{
        dprintf(MODULE_NAME": supports device\n");
        return 0.0f;
}


static status_t
example_register_device(device_node_handle parent)
{
        dprintf(MODULE_NAME": register device\n");
        return B_OK;
}


static status_t
example_init_driver(device_node_handle node, void *userCookie, void **cookie)
{
        dprintf(MODULE_NAME": init driver\n");
        return B_OK;
}


static status_t
example_uninit_driver(void *cookie)
{
        dprintf(MODULE_NAME": uninit driver\n");
        return B_OK;
}


static void
example_device_removed(device_node_handle node, void *cookie)
{
        dprintf(MODULE_NAME": device removed\n");
}


static void
example_device_cleanup(device_node_handle node)
{
        dprintf(MODULE_NAME": device cleanup\n");
}


static void
example_get_supported_paths(const char ***busses, const char ***devices)
{
        static const char *sBusses[] = { "pci", NULL };
        static const char *sDevices[] = { "drivers/dev/example", NULL };

        dprintf(MODULE_NAME": get supported paths\n");
        *busses = sBusses;
        *devices = sDevices;
}


// sim functions
static void
example_scsi_io(scsi_sim_cookie cookie, scsi_ccb *ccb)
{
        dprintf(MODULE_NAME": scsi io\n");
}


static uchar
example_abort(scsi_sim_cookie cookie, scsi_ccb *ccbToAbort)
{
        dprintf(MODULE_NAME": abort\n");
        return 0;
}


static uchar
example_reset_device(scsi_sim_cookie cookie, uchar targetID, uchar targetLUN)
{
        dprintf(MODULE_NAME": reset device\n");
        return 0;
}


static uchar
example_term_io(scsi_sim_cookie cookie, scsi_ccb *ccbToTerminate)
{
        dprintf(MODULE_NAME": terminate io\n");
        return 0;
}


static uchar
example_path_inquiry(scsi_sim_cookie cookie, scsi_path_inquiry *inquiryData)
{
        dprintf(MODULE_NAME": path inquiry\n");
        return 0;
}


static uchar
example_scan_bus(scsi_sim_cookie cookie)
{
        dprintf(MODULE_NAME": scan bus\n");
        return 0;
}


static uchar
example_reset_bus(scsi_sim_cookie cookie)
{
        dprintf(MODULE_NAME": reset bus\n");
        return 0;
}


static void
example_get_restrictions(scsi_sim_cookie cookie, uchar targetID, bool *isATAPI,
        bool *noAutosense, uint32 *maxBlocks)
{
        dprintf(MODULE_NAME": get restrictions\n");
}


static status_t
example_ioctl(scsi_sim_cookie cookie, uint8 targetID, uint32 op, void *buffer,
        size_t bufferLength)
{
        dprintf(MODULE_NAME": io control\n");
        return B_ERROR;
}


// module management
module_dependency module_dependencies[] = {
        { SCSI_FOR_SIM_MODULE_NAME, (module_info **)&sSimInterface },
        { B_DEVICE_MANAGER_MODULE_NAME, (module_info **)&sDeviceManager },
        {}
};


scsi_sim_interface example_sim = {
        {                                                                       // driver_module_info
                {                                                                       // module_info
                        "busses/scsi/example/v1",                       // module name
                        0,                                                                      // module flags
                        example_std_ops                                         // module standard ops
                },

                example_supports_device,                        // supports device
                example_register_device,                        // register device

                example_init_driver,                            // init driver
                example_uninit_driver,                          // uninit driver

                example_device_removed,                         // device removed
                example_device_cleanup,                         // device cleanup

                example_get_supported_paths                     // get supported paths
        },

        example_scsi_io,                                        // scsi io
        example_abort,                                          // abort
        example_reset_device,                           // reset device
        example_term_io,                                        // terminate io

        example_path_inquiry,                           // path inquiry
        example_scan_bus,                                       // scan bus
        example_reset_bus,                                      // reset bus

        example_get_restrictions,                       // get restrictions

        example_ioctl                                           // io control
};


module_info *modules[] = {
        (module_info *)&example_sim,
        NULL
};