/**
 *
 * 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>
 *
 *
 */
/** handling SCSI data-buffer (both usual "plain" and scatter/gather ones) */

#include <string.h>

#include "usb_scsi.h"

#include <malloc.h>
#include "tracing.h"
#include "sg_buffer.h"

/**
	\fn:init_sg_buffer
	TODO!!!
*/
status_t
init_sg_buffer(sg_buffer *sgb, CCB_SCSIIO *ccbio)
{
	status_t status = B_NO_INIT;
	if(0 != sgb){
		memset(sgb, 0, sizeof(sg_buffer));
		/* setup scatter/gather if exists in CCBIO*/
		if(ccbio->cam_ch.cam_flags & CAM_SCATTER_VALID) {
			sgb->piov	= (iovec *) ccbio->cam_data_ptr;
			sgb->count = ccbio->cam_sglist_cnt;
		} else {
			sgb->iov.iov_base = (iovec *) ccbio->cam_data_ptr;
			sgb->iov.iov_len	= ccbio->cam_dxfer_len;
			sgb->piov	= &sgb->iov;
			sgb->count = 1;
		}
		status = B_OK;
	} else {
		TRACE_ALWAYS("init_sg_buffer fatal: not initialized!\n");
	}
	return status;
}

/**
	\fn:alloc_sg_buffer
	TODO!!!
*/
status_t
realloc_sg_buffer(sg_buffer *sgb, size_t size)
{
	status_t status = B_NO_INIT;
	if(0 != sgb){
		/* NOTE: no check for previously allocations! May be dangerous!*/
		void *ptr = malloc(size);
		status = (0 != ptr) ? B_OK : B_NO_MEMORY;
		if(B_OK == status) {
			memset(ptr, 0, size);
			sgb->iov.iov_base = (iovec *)ptr;
			sgb->iov.iov_len	= size;
			sgb->piov	= &sgb->iov;
			sgb->count = 1;
			sgb->b_own = true;
			status = B_OK;
		}
	} else {
		TRACE_ALWAYS("realloc_sg_buffer fatal: not initialized!\n");
	}
	return status;
}

status_t
sg_access_byte(sg_buffer *sgb, off_t offset, uchar *byte, bool b_set)
{
	status_t status = B_ERROR;
	int i = 0;
	for(; i < sgb->count; i++){
		if(offset >= sgb->piov[i].iov_len){
			offset -= sgb->piov[i].iov_len;
		} else {
			uchar *ptr = (uchar *)sgb->piov[i].iov_base;
			if(b_set){
				ptr[offset] = *byte;
			}else{
				*byte = ptr[offset];
			}
			status = B_OK;
			break;
		}
	}
	return status;
}

status_t
sg_memcpy(sg_buffer *d_sgb, off_t d_offset,
					sg_buffer *s_sgb, off_t s_offset, size_t size)
{
	status_t status = B_NO_INIT;
	while(0 != d_sgb && 0 != s_sgb){
		uchar *d_ptr = 0;
		uchar *s_ptr = 0;
		status = B_ERROR;
		if(1 == d_sgb->count){
			d_ptr = d_sgb->piov->iov_base + d_offset;
			if((d_offset + size) > d_sgb->piov->iov_len){
				TRACE_ALWAYS("sg_memcpy fatal: dest buffer overflow: has:%d req:%d\n",
							 d_sgb->piov->iov_len, d_offset + size);
				break;
			}
		}
		if(1 == s_sgb->count){
			s_ptr = s_sgb->piov->iov_base + s_offset;
			if((s_offset + size) > s_sgb->piov->iov_len){
				TRACE_ALWAYS("sg_memcpy fatal: src buffer overflow: has:%d req:%d\n",
							 s_sgb->piov->iov_len, s_offset + size);
				break;
			}
		}
		if(0 != d_ptr && 0 != s_ptr){
			memcpy(d_ptr, s_ptr, size);
		} else {
			uchar byte = 0;
			int i = 0;
			for(; i < size; i++){
				status = sg_access_byte(s_sgb, s_offset + i, &byte, false);
				if(B_OK == status)
					status = sg_access_byte(d_sgb, d_offset + i, &byte, true);
				if(B_OK != status){
					TRACE_ALWAYS("sg_memcpy fatal: dest:%d src:%d size:%d/%d\n",
										 d_offset, s_offset, i, size);
					break;
				}
			}
		}
		status = B_OK;
		break;
	}
	if(B_NO_INIT == status)
		TRACE_ALWAYS("sg_memcpy fatal: not initialized");
	return status;
}

/**
	\fn:free_sg_buffer
	TODO!!!
*/
void
free_sg_buffer(sg_buffer *sgb)
{
	if(0 != sgb && sgb->b_own){
		int i = 0;
		for(; i < sgb->count; i++){
			free(sgb->piov[i].iov_base);
		}
		memset(sgb, 0, sizeof(sg_buffer));
	}
}

status_t
sg_buffer_len(sg_buffer *sgb, size_t *size)
{
	status_t status = B_NO_INIT;
	if(0!=sgb && 0!=size){
		int i = 0;
		*size = 0;
		for(; i < sgb->count; i++){
			*size += sgb->piov[i].iov_len;
		}
		status = B_OK;
	} else {
		TRACE_ALWAYS("sg_buffer_len fatal: not initialized (sgb:%x/size:%x)", sgb, size);
	}
	return status;
}