/**
 *
 * TODO: description
 *
 * This file is a part of USB SCSI CAM for Haiku.
 * May be used under terms of the MIT License
 *
 * Author(s):
 *      Siarzhuk Zharski <imker@gmx.li>
 *
 *
 */
/* References:
 * USB Mass Storage Class specifications:
 * http://www.usb.org/developers/data/devclass/usbmassover_11.pdf
 * http://www.usb.org/developers/data/devclass/usbmass-ufi10.pdf
 * http://www.usb.org/developers/data/devclass/usbmass-cbi10.pdf
 */

#include <string.h>

#include "usb_scsi.h"

#include "device_info.h"

#include "proto_module.h"
#include "proto_common.h"
#include "proto_cbi.h"

#include "usb_defs.h"

#define USB_REQ_CBI_ADSC 0x00


typedef struct _usb_mass_CBI_CB{
        uint8 op;
        uint8 op2;
        uint8 padding[14];
} usb_mass_CBI_CB;

#define CDB_LEN 16
#define CDB_RESET_LEN 12

//typedef uint8 usb_mass_CDB[CDB_LEN];

typedef union _usb_mass_CBI_IDB{
        struct {
                uint8 type;
                uint8 value;
        } common;
        struct {
                uint8 asc;
                uint8 ascq;
        } ufi;
} usb_mass_CBI_IDB;

#define CBI_IDB_TYPE_CCI                        0x00
#define CBI_IDB_VALUE_PASS                      0x00
#define CBI_IDB_VALUE_FAIL                      0x01
#define CBI_IDB_VALUE_PHASE                     0x02
#define CBI_IDB_VALUE_PERSISTENT        0x03
#define CBI_IDB_VALUE_STATUS_MASK       0x03

static void trace_CDB(usb_device_info *udi, const usb_mass_CBI_CB *cb, int len);
static status_t cbi_reset(usb_device_info *udi);
static status_t cbi_initialize(usb_device_info *udi);
static void cbi_transfer(usb_device_info *udi, uint8 *cmd, uint8 cmdlen, //sg_buffer *sgb,
                                                iovec *sg_data, int32 sg_count,  int32  transfer_len,
                                                EDirection      dir, CCB_SCSIIO *ccbio, ud_transfer_callback cb);

/** returns size of private protocol buffer */
//int cbi_buffer_length(){ return sizeof(usb_mass_CBI_CB) + sizeof(usb_mass_CBI_IDB); }
/** casts private protocol buffer to CBI_IDB */
/*#define IDB_BUFFER(__buff)\
                                                         ((usb_mass_CBI_IDB*)(((uint8*)__buff) + sizeof(usb_mass_CBI_CB)))
*/
/** casts private protocol buffer to CBI_CB */
/*#define CB_BUFFER(__buff)\
                                                         ((usb_mass_CBI_CB*)(__buff))
*/
void trace_CDB(usb_device_info *udi, const usb_mass_CBI_CB *cb, int len)
{
        PTRACE(udi, "CB:{op:0x%02x; op2:0x%02x;}\n", cb->op, cb->op2);
        udi->trace_bytes(" padding:", cb->padding, len - 2);
}

static status_t
send_request_adsc(usb_device_info *udi, void *cb, int length)
{
        status_t status = B_ERROR;
        size_t len = 0;
        trace_CDB(udi, cb, length);
        status = (*udi->usb_m->send_request)(udi->device,
                                                USB_REQTYPE_CLASS | USB_REQTYPE_INTERFACE_OUT,
                                                USB_REQ_CBI_ADSC, 0,
                                                udi->interface, length,
                                                cb, &len);
        return status;
}

static status_t
request_interrupt(usb_device_info *udi, usb_mass_CBI_IDB *idb)
{
        status_t status = B_ERROR;
        status = (*udi->usb_m->queue_interrupt)(udi->pipe_intr, idb,
                                         sizeof(usb_mass_CBI_IDB), bulk_callback, udi);
        if(status != B_OK){
                PTRACE(udi, "request_interrupt:failed:%08x\n", status);
        } else {
                status = acquire_sem_etc(udi->trans_sem, 1, B_RELATIVE_TIMEOUT, udi->trans_timeout/*LOCK_TIMEOUT*/);
                if(status != B_OK){
                        PTRACE(udi, "request_interrupt:acquire_sem_etc failed:%08x\n", status);
                        (*udi->usb_m->cancel_queued_transfers)(udi->pipe_intr);
                }
        }
        udi->trace_bytes("Intr status:", (uint8*)idb, sizeof(usb_mass_CBI_IDB));
        return status;
}

static status_t
parse_status(usb_device_info *udi, usb_mass_CBI_IDB *idb)
{
        status_t command_status = B_OK;
        if(CMDSET(udi->properties) == CMDSET_UFI){
                if(idb->ufi.asc == 0 && idb->ufi.ascq == 0){
                        command_status = B_OK;
                }else{
                        command_status = B_CMD_FAILED;
                }
        } else {
                if(idb->common.type == CBI_IDB_TYPE_CCI){
                        switch(idb->common.value & CBI_IDB_VALUE_STATUS_MASK){
                        case CBI_IDB_VALUE_PASS:
                                command_status = B_OK;
                                break;
                        case CBI_IDB_VALUE_FAIL:
                        case CBI_IDB_VALUE_PERSISTENT:
                                command_status = B_CMD_FAILED;
                                break;
                        case CBI_IDB_VALUE_PHASE:
                        default:
                                command_status = B_CMD_WIRE_FAILED;
                                break;
                        }
                } /* else ?? */
        }
        return command_status;
}

/*================= "standard" protocol procedures ==============================*/

/**
        \fn:
        \param udi: ???
        \return:??

        ??
*/
status_t
cbi_reset(usb_device_info *udi)
{
        status_t status = B_ERROR;
        //usb_mass_CBI_CB *cb = CB_BUFFER(udi->proto_buf);
        //usb_mass_CDB cdb = {0x1d, 0x04, 0x00};
        //memset(cdb + 2, 0xff, CDB_RESET_LEN - 2);
        usb_mass_CBI_CB cb = {
                .op     = 0x1D,
                .op2 = 0x04,
        };
        memset(cb.padding , 0xff, sizeof(cb.padding));
        status = send_request_adsc(udi, &cb, CDB_RESET_LEN);
        if(status != B_OK)
                PTRACE_ALWAYS(udi, "command_block_reset: reset request failed: %08x\n", status);

        if(B_OK != (status = (*udi->usb_m->clear_feature)(udi->pipe_in,
                                                                                 USB_FEATURE_ENDPOINT_HALT)))
                PTRACE_ALWAYS(udi, "command_block_reset: clear_feature on pipe_in failed: %08x\n", status);

        if(B_OK != (status = (*udi->usb_m->clear_feature)(udi->pipe_out,
                                                                                 USB_FEATURE_ENDPOINT_HALT)))
                PTRACE_ALWAYS(udi, "command_block_reset: clear_feature on pipe_out failed: %08x\n", status);
        PTRACE(udi, "command_block_reset:%08x\n", status);

        return status;
}

/**
        \fn:
*/
status_t
cbi_initialize(usb_device_info *udi)
{
        status_t status = B_OK;
        udi->max_lun = 0;
        return status;
}

/**
        \fn:bulk_only_transfer
        \param udi: ???
        \param cmd: ???
        \param cmdlen: ???
        \return:???

        ???
*/
void
cbi_transfer(usb_device_info *udi, uint8 *cmd, uint8    cmdlen,
                                                                                         //sg_buffer *sgb,
                        iovec *sg_data, int32 sg_count, int32   transfer_len,
                        EDirection      dir,CCB_SCSIIO *ccbio, ud_transfer_callback cb)
{
        status_t status = B_OK;
        status_t command_status = B_OK;
        int32 residue = transfer_len;
        usb_mass_CBI_IDB idb = {{0}};
        do{
                status = send_request_adsc(udi, cmd, cmdlen);
                if(status != B_OK){
                        PTRACE(udi, "cbi_transfer:send command block failed: %08x\n", status);
                        if(status == B_DEV_STALLED){
                                command_status = B_CMD_FAILED;
                        } else {
                                command_status = B_CMD_WIRE_FAILED;
                                (*udi->protocol_m->reset)(udi);
                        }
                        break;
                }
                if(transfer_len != 0){
                        status = process_data_io(udi, sg_data, sg_count, dir);
                        if(status != B_OK){
                                command_status = B_CMD_WIRE_FAILED;
                                break;
                        }
                }

                if(PROTO(udi->properties) == PROTO_CBI){
                        status = request_interrupt(udi, &idb);
                        PTRACE(udi, "cbi_transfer:request interrupt: %08x(%08x)\n", status, udi->status);
                        if(status != B_OK){
                                command_status = B_CMD_WIRE_FAILED;
                                break;
                        }
                        if(udi->status == B_DEV_STALLED){
                        }
                        command_status = parse_status(udi, &idb);
                } else { /* PROP_CB ???*/
                        command_status = B_CMD_UNKNOWN;
                }
                residue = 0; /* DEBUG!!!!!!!!!*/
        }while(false);
        cb(udi, ccbio, residue, command_status);
}

protocol_module_info cbi_protocol_m = {
        {0, 0, 0}, /* this is not a real kernel module - just interface */
        cbi_initialize,
        cbi_reset,
        cbi_transfer,
};