/**
 *
 * 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>
 *
 *
 */
/** bulk-only protocol specific implementation */

/* References:
 * USB Mass Storage Class specifications:
 * http://www.usb.org/developers/data/devclass/usbmassover_11.pdf	[1]
 * http://www.usb.org/developers/data/devclass/usbmassbulk_10.pdf	[2]
 */
#include "usb_scsi.h"

#include "device_info.h"

#include "proto_module.h"
#include "proto_common.h"
#include "proto_bulk.h"

#include "usb_defs.h"

#include <string.h>	/* strncpy */

/*Bulk-Only protocol specifics*/
#define USB_REQ_MS_RESET			 0xff		/* Bulk-Only reset */
#define USB_REQ_MS_GET_MAX_LUN 0xfe		/* Get maximum lun */

/* Command Block Wrapper */
typedef struct _usb_mass_CBW{
	uint32 signature;
	uint32 tag;
	uint32 data_transfer_len;
	uint8	flags;
	uint8	lun;
	uint8	cdb_len;
#define CBW_CDB_LENGTH	16
	uint8	CDB[CBW_CDB_LENGTH];
} usb_mass_CBW; /*sizeof(usb_mass_CBW) must be 31*/
#define CBW_LENGTH 0x1f

/* Command Status Wrapper */
typedef struct _usb_mass_CSW{
	uint32 signature;
	uint32 tag;
	uint32 data_residue;
	uint8	status;
} usb_mass_CSW; /*sizeof(usb_mass_CSW) must be 13*/
#define CSW_LENGTH 0x0d

#define CSW_STATUS_GOOD		0x0
#define CSW_STATUS_FAILED	0x1
#define CSW_STATUS_PHASE	0x2

#define CBW_SIGNATURE 0x43425355
#define CSW_SIGNATURE 0x53425355

#define CBW_FLAGS_OUT	0x00
#define CBW_FLAGS_IN	0x80

static void 	trace_CBW(usb_device_info *udi, const usb_mass_CBW *cbw);
static void 	trace_CSW(usb_device_info *udi, const usb_mass_CSW *csw);
static status_t	bulk_only_initialize(usb_device_info *udi);
static status_t	bulk_only_reset(usb_device_info *udi);
static void		bulk_only_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);

/*=========================== tracing helpers ==================================*/
void trace_CBW(usb_device_info *udi, const usb_mass_CBW *cbw)
{
	char buf[sizeof(uint32) + 1] = {0};
	strncpy(buf, (char *)&cbw->signature, sizeof(uint32));
	PTRACE(udi, "\nCBW:{'%s'; tag:%d; data_len:%d; flags:0x%02x; lun:%d; cdb_len:%d;}\n",
		buf, cbw->tag, cbw->data_transfer_len,
		cbw->flags,	cbw->lun, cbw->cdb_len);
	udi->trace_bytes("CDB:\n", cbw->CDB, CBW_CDB_LENGTH);
}

void trace_CSW(usb_device_info *udi, const usb_mass_CSW *csw)
{
	char buf[sizeof(uint32) + 1] = {0};
	strncpy(buf, (char *)&csw->signature, sizeof(uint32));
	PTRACE(udi, "CSW:{'%s'; tag:%d; residue:%d; status:0x%02x}\n",
		buf, csw->tag, csw->data_residue, csw->status);
}

/**
	\fn:get_max_luns
	\param udi: device for wich max LUN info is requested
	\return:always B_OK - if info was not retrieved max LUN is defaulted to 0

	tries to retrieve the maximal Logical Unit Number supported by
	this device. If device doesn't support GET_MAX_LUN request - single LUN is
	assumed. ([2] 3.2)
*/
static status_t
get_max_luns(usb_device_info *udi)
{
	status_t status = B_OK;
	udi->max_lun = 0;
	if(!HAS_FIXES(udi->properties, FIX_NO_GETMAXLUN)){
		size_t len = 0;
		if(B_OK != (status = (*udi->usb_m->send_request)(udi->device,
							 USB_REQTYPE_INTERFACE_IN | USB_REQTYPE_CLASS,
							 USB_REQ_MS_GET_MAX_LUN, 0x0, udi->interface,
							 0x1, &udi->max_lun, &len)))
		{
			if(status == B_DEV_STALLED){
				PTRACE_ALWAYS(udi, "get_max_luns[%d]:not supported. "
									"Assuming single LUN available.\n", udi->dev_num);
			} else {
				PTRACE(udi, "get_max_luns[%d]:failed(%08x)."
							"Assuming single LUN available.\n", udi->dev_num, status);
			}
			udi->max_lun = 0;
			status = B_OK;
		} /* else - all is OK - max luns info readed */
	}
	return status;
}
/**
	\fn:queue_bulk
	\param udi: device for which que_bulk request is performed
	\param buffer: data buffer, used in bulk i/o operation
	\param len: length of data buffer
	\param b_in: is "true" if input (device->host) data transfer, "false" otherwise
	\return: status of operation.

	performs queue_bulk USB request for corresponding pipe and handle timeout of this
	operation.
*/
static status_t
queue_bulk(usb_device_info *udi, void* buffer, size_t len, bool b_in)
{
	status_t status = B_OK;
	usb_pipe pipe = b_in ? udi->pipe_in : udi->pipe_out;
	status = (*udi->usb_m->queue_bulk)(pipe, buffer, len, bulk_callback, udi);
	if(status != B_OK){
		PTRACE_ALWAYS(udi, "queue_bulk: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_ALWAYS(udi, "queue_bulk:acquire_sem_etc failed:%08x\n", status);
			(*udi->usb_m->cancel_queued_transfers)(pipe);
		}
	}
	return status;
}
/**
	\fn:check_CSW
	\param udi:corresponding device info
	\param csw: CSW to be checked for validity and meaningfullness
	\param transfer_len: data transferred during operation, which is checked for status
	\return: "true" if CSW valid and meanigfull, "false" otherwise

	checks CSW for validity and meaningfullness as required by USB mass strorge
	BulkOnly specification ([2] 6.3)
*/
static bool
check_CSW(usb_device_info *udi,	usb_mass_CSW* csw, int transfer_len)
{
	bool is_valid = false;
	do{
		/* check for CSW validity */
		if(udi->actual_len != CSW_LENGTH){
			PTRACE_ALWAYS(udi, "check_CSW:wrong length %d instead of %d\n",
							 udi->actual_len, CSW_LENGTH);
			break;/* failed */
		}
		if(csw->signature != CSW_SIGNATURE){
			PTRACE_ALWAYS(udi, "check_CSW:wrong signature %08x instead of %08x\n",
							 csw->signature, CSW_SIGNATURE);
			break;/* failed */
		}
		if(csw->tag != udi->tag - 1){
			PTRACE_ALWAYS(udi, "check_CSW:tag mismatch received:%d, awaited:%d\n",
							 csw->tag, udi->tag-1);
			break;/* failed */
		}
		/* check for CSW meaningfullness */
		if(CSW_STATUS_PHASE == csw->status){
			PTRACE_ALWAYS(udi, "check_CSW:not meaningfull: phase error\n");
			break;/* failed */
		}
		if(transfer_len < csw->data_residue){
			PTRACE_ALWAYS(udi, "check_CSW:not meaningfull: "
							 "residue:%d is greater than transfer length:%d\n",
									csw->data_residue, transfer_len);
			break;/* failed */
		}
		is_valid = true;
	}while(false);
	return is_valid;
}
/**
	\fn:read_status
	\param udi: corresponding device
	\param csw: buffer for CSW data
	\param transfer_len: data transferred during operation, which is checked for status
	\return: success status code

	reads CSW from device as proposed in ([2] 5.3.3; Figure 2.).
*/
static status_t
read_status(usb_device_info *udi, usb_mass_CSW* csw, int transfer_len)
{
	status_t status = B_ERROR;
	int try = 0;
	do{
		status = queue_bulk(udi, csw, CSW_LENGTH, true);
		if(try == 0){
			if(B_OK != status || B_OK != udi->status){
				status = (*udi->usb_m->clear_feature)(udi->pipe_in, USB_FEATURE_ENDPOINT_HALT);
				if(status != 0){
					PTRACE_ALWAYS(udi, "read_status:failed 1st try, "
						"status:%08x; usb_status:%08x\n", status, udi->status);
					(*udi->protocol_m->reset)(udi);
					break;
				}
				continue; /* go to second try*/
			}
			/* CSW was readed without errors */
		} else { /* second try */
			if(B_OK != status || B_OK != udi->status){
				PTRACE_ALWAYS(udi, "read_status:failed 2nd try status:%08x; usb_status:%08x\n",
								status, udi->status);
				(*udi->protocol_m->reset)(udi);
				status = (B_OK == status) ? udi->status : status;
				break;
			}
		}
		if(!check_CSW(udi, csw, transfer_len)){
			(*udi->protocol_m->reset)(udi);
			status = B_ERROR;
			break;
		}
		trace_CSW(udi, csw);
		break; /* CSW was read successfully */
	}while(try++ < 2);
	return status;
}

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

/**
	\fn:bulk_only_initialize
	\param udi: device on wich we should perform initialization
	\return:error code if initialization failed or B_OK if it passed

	initialize procedure for bulk only protocol devices.
*/
status_t
bulk_only_initialize(usb_device_info *udi)
{
	status_t status = B_OK;
	status = get_max_luns(udi);
	return status;
}
/**
	\fn:bulk_only_reset
	\param udi: device on wich we should perform reset
	\return:error code if reset failed or B_OK if it passed

	reset procedure for bulk only protocol devices. Tries to send
	BulkOnlyReset USB request and clear USB_FEATURE_ENDPOINT_HALT features on
	input and output pipes. ([2] 3.1)
*/
status_t
bulk_only_reset(usb_device_info *udi)
{
	status_t status = B_ERROR;
	status = (*udi->usb_m->send_request)(udi->device,
						USB_REQTYPE_CLASS | USB_REQTYPE_INTERFACE_OUT,
						USB_REQ_MS_RESET, 0,
						udi->interface, 0, 0, 0);
	if(status != B_OK){
		PTRACE_ALWAYS(udi, "bulk_only_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, "bulk_only_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, "bulk_only_reset: clear_feature on pipe_out failed: %08x\n", status);
	}
	PTRACE(udi, "bulk_only_reset:%08x\n", status);
	return status;
}
/**
	\fn:bulk_only_transfer
	\param udi: corresponding device
	\param cmd: SCSI command to be performed on USB device
	\param cmdlen: length of SCSI command
	\param data_sg: io vectors array with data to transfer
	\param sglist_count: count of entries in io vector array
	\param transfer_len: overall length of data to be transferred
	\param dir: direction of data transfer
	\param ccbio: CCB_SCSIIO struct for original SCSI command
	\param cb: callback to handle of final stage of command performing (autosense \
						 request etc.)

	transfer procedure for bulk-only protocol. Performs	SCSI command on USB device
	[2]
*/
void
bulk_only_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_CSW csw = {0};
	/* initialize and fill in Command Block Wrapper */
	usb_mass_CBW cbw = {
		.signature	 = CBW_SIGNATURE,
		.tag		 = atomic_add(&udi->tag, 1),
		.data_transfer_len = transfer_len,
		.flags		 = (dir == eDirIn) ? CBW_FLAGS_IN : CBW_FLAGS_OUT,
		.lun		 = ccbio->cam_ch.cam_target_lun & 0xf,
		.cdb_len	 = cmdlen,
	};
	memcpy(cbw.CDB, cmd, cbw.cdb_len);
	do{
		trace_CBW(udi, &cbw);
		/* send CBW to device */
		status = queue_bulk(udi, &cbw, CBW_LENGTH, false);
		if(status != B_OK || udi->status != B_OK){
			PTRACE_ALWAYS(udi, "bulk_only_transfer: queue_bulk failed:"
							"status:%08x usb status:%08x\n", status, udi->status);
			(*udi->protocol_m->reset)(udi);
			command_status = B_CMD_WIRE_FAILED;
			break;
		}
		/* perform data transfer if required */
		if(transfer_len != 0x0){
			status = process_data_io(udi, sg_data, sg_count, dir);
			if(status != B_OK && status != B_DEV_STALLED){
				command_status = B_CMD_WIRE_FAILED;
				break;
			}
		}
		/* get status of command */
		status = read_status(udi, &csw, transfer_len);
		if(B_OK != status){
			command_status = B_CMD_WIRE_FAILED;
			break;
		}
		residue = csw.data_residue;
		if(csw.status == CSW_STATUS_FAILED){
			command_status = B_CMD_FAILED;
		}else{
			command_status = B_OK;
		}
	}while(false);
	/* finalize transfer */
	cb(udi, ccbio, residue, command_status);
}

protocol_module_info bulk_only_protocol_m = {
	{0, 0, 0}, /* this is not a real kernel module - just interface */
	bulk_only_initialize,
	bulk_only_reset,
	bulk_only_transfer,
};