path: root/drivers/usb/host/s3c-otg/s3c-otg-transfer-common.c

/****************************************************************************
 *  (C) Copyright 2008 Samsung Electronics Co., Ltd., All rights reserved
 *
 *  [File Name]   : Commons3c-otg-transfer-transfer.h
 *  [Description] : This source file implements the functions to be defined at CommonTransfer Module.
 *  [Author]      : Yang Soon Yeal { syatom.yang@samsung.com }
 *  [Department]  : System LSI Division/System SW Lab
 *  [Created Date]: 2008/06/03
 *  [Revision History]
 *      (1) 2008/06/03   by Yang Soon Yeal { syatom.yang@samsung.com }
 *          - Created this file and implements some functions of CommonTransfer.
 *  	(2) 2008/07/15   by SeungSoo Yang ( ss1.yang@samsung.com )n
 *	    - Optimizing for performance \n
 *      (3) 2008/08/18   by SeungSoo Yang ( ss1.yang@samsung.com )
 *          - Modifying for successful rmmod & disconnecting \n
 *
 ****************************************************************************/
/****************************************************************************
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 ****************************************************************************/

#include "s3c-otg-transfer-transfer.h"

// the header pointer to indicate the ED_list to manage the ed_t to be created and initiated.
static otg_list_head ed_list_head;
static u32 ref_periodic_transfer;

/******************************************************************************/
/*!
 * @name	void		init_transfer(void)
 *
 * @brief		this function initiates the S3CTranfer module. that is, this functions initiates
 *			the ED_list_head OTG List which manages the all ed_t to be existed.
 *
 * @param	void
 *
 * @return	void
 */
/******************************************************************************/

void init_transfer(void)
{
	otg_dbg(OTG_DBG_TRANSFER,"start to init_transfer\n");
	otg_list_init(&ed_list_head);
	ref_periodic_transfer = 0;
}


/******************************************************************************/
/*!
 * @name	void		DeInitTransfer(void)
 *
 * @brief		this function Deinitiates the S3CTranfer module. this functions check which there are
 *			some ed_t on ED_list_head. if some ed_t exists, deinit_transfer() deletes the ed_t.
 *
 *
 * @param	void
 *
 * @return	void
 */
/******************************************************************************/
void deinit_transfer(struct sec_otghost *otghost)
{
	otg_list_head	*ed_list_member;
	ed_t 		*delete_ed_p;

	while(otg_list_empty(&ed_list_head) != true) {
		ed_list_member = ed_list_head.next;

		/* otg_list_pop(ed_list_member); */

		delete_ed_p= otg_list_get_node(ed_list_member,ed_t,ed_list_entry);

		delete_ed(otghost, delete_ed_p);
	}
}

/******************************************************************************/
/*!
 * @name	int 	delete_ed(ed_t *delete_ed)
 *
 * @brief		this function delete the delete_ed.
 *		if there is some available  TD_ts on delete_ed, then this function also deletes these td_t
 *
 *
 * @param	[IN]	delete_ed = indicates the address of ed_t to be deleted.
 *
 * @return	USB_ERR_SUCCESS	-if successes to delete the ed_t.
 *		USB_ERR_FAILl		-if fails to delete the ed_t.
 */
/******************************************************************************/
int delete_ed(struct sec_otghost *otghost, ed_t *delete_ed)
{
	otg_kal_make_ep_null(delete_ed);

	if(delete_ed->num_td) {
		cancel_all_td(otghost, delete_ed);
		/**
		    need to giveback of td's urb with considering life-cycle of
		    TD, ED, urb->hcpriv, td->private, ep->hcpriv, td->parentED
		    (commented by ss1.yang)
		*/
	}

	otg_list_pop(&delete_ed->ed_list_entry);

	if(delete_ed->ed_desc.endpoint_type == INT_TRANSFER ||
		delete_ed->ed_desc.endpoint_type == ISOCH_TRANSFER) {
		ref_periodic_transfer--;
	}

	if(ref_periodic_transfer==0) {
		disable_sof();
	}
	otg_mem_free(delete_ed);

	return USB_ERR_SUCCESS;
}

/******************************************************************************/
/*!
 * @name	int	delete_td(struct sec_otghost *otghost, td_t *delete_td)
 *
 * @brief		this function frees memory resource for the delete_td.
 *		and if delete_td is transferring USB Transfer, then this function request to cancel
 *		the USB Transfer to S3CScheduler.
 *
 *
 * @param	[OUT]	new_td_p = returns the address of the new td_t .
 *
 * @return	USB_ERR_SUCCESS	-if successes to create the new td_t.
 *		USB_ERR_FAILl		-if fails to create to new td_t.
 */
/******************************************************************************/
int delete_td(struct sec_otghost *otghost, td_t *delete_td)
{
	if(delete_td->is_transferring) {
		//at this case, we should cancel the USB Transfer.
		cancel_to_transfer_td(otghost, delete_td);
	}

	otg_mem_free(delete_td);
	return USB_ERR_SUCCESS;
}

int create_isoch_packet_desc(isoch_packet_desc_t **new_isoch_packet_desc,
						u32 isoch_packet_num)
{
	return otg_mem_alloc((void **)new_isoch_packet_desc,
	       	(u16)sizeof(isoch_packet_desc_t)*isoch_packet_num,USB_MEM_SYNC);
}

int delete_isoch_packet_desc(isoch_packet_desc_t *del_isoch_packet_desc,
						u32 isoch_packet_num)
{
	return otg_mem_free(del_isoch_packet_desc);
}

/******************************************************************************/
/*!
 * @name	void	init_isoch_packet_desc(  	isoch_packet_desc_t 	*init_isoch_packet_desc,
 *						u32                  		isoch_packet_start_addr,
 *						u32                  		isoch_packet_size,
 *						u32			index)
 *
 * @brief		this function initiates the isoch_packet_desc_t[index].
 *
 *
 * @param	[OUT]	init_isoch_packet_desc 	= indicates the pointer of IsochPackDesc_t to be initiated.
 *		[IN]	isoch_packet_start_addr	= indicates the start address of the buffer to be used
 *							at USB Isochronous Transfer.
 *		[IN]	isoch_packet_size	    	= indicates the size of Isochronous packet.
 *		[IN]	index			= indicates the index to be mapped with this init_isoch_packet_desc.
 *
 * @return	void
 */
/******************************************************************************/
void init_isoch_packet_desc(isoch_packet_desc_t *init_isoch_packet_desc,
					u32 isoch_packet_start_addr,
					u32 isoch_packet_size,
					u32 index)
{
	init_isoch_packet_desc[index].buf_size 			= isoch_packet_size;
	init_isoch_packet_desc[index].isoch_packiet_start_addr	= isoch_packet_start_addr;
	init_isoch_packet_desc[index].isoch_status		= 0;
	init_isoch_packet_desc[index].transferred_szie 		= 0;
}

/******************************************************************************/
/*!
 * @name	int 	create_ed(ed_t 	**new_ed)
 *
 * @brief		this function creates a new ed_t and returns the ed_t to Caller
 *
 *
 * @param	[OUT]	new_ed = returns the address of the new ed_t .
 *
 * @return	USB_ERR_SUCCESS	-if successes to create the new ed_t.
 *		USB_ERR_FAILl		-if fails to create to new ed_t.
 */
/******************************************************************************/
int create_ed(ed_t **new_ed)
{
	int err_code = USB_ERR_SUCCESS;

	err_code =  otg_mem_alloc((void **)new_ed,(u16)sizeof(ed_t), USB_MEM_ASYNC);
	otg_mem_set(*new_ed, 0, sizeof(ed_t));
	return err_code;
}


/******************************************************************************/
/*!
 * @name	int 	init_ed(	ed_t 		*init_ed,
 *				u8 		dev_addr,
 *				u8 		ep_num,
 *				bool  		f_is_ep_in,
 *				u8 		dev_speed,
 *				u8 		ep_type,
 *				u32		max_packet_size,
 *				u8  		multi_count,
 *				u8  		interval,
 *				u32    		sched_frame,
 *				u8     		hub_addr,
 *				u8     		hub_port,
 *				bool        	f_is_do_split)
 *
 * @brief		this function initiates the init_ed by using the another parameters.
 *
 *
 * @param	[OUT]	init_ed = returns the ed_t to be initiated.
 *                  	[IN]	dev_addr = inidcates the address of USB Device.
 *                  	[IN]	ep_num = inidcates the number of the specific endpoint on USB Device.
 *                  	[IN]	f_is_ep_in = inidcates whether the endpoint is IN or not
 *                  	[IN]	dev_speed = inidcates the speed of USB Device.
 *                  	[IN]	max_packet_size = inidcates the maximum packet size of a specific endpoint on USB Device.
 *                  	[IN]	multi_count = if the endpoint supports periodic transfer
 *								, this indicates the multiple packet to be transferred on a uframe
 *                  	[IN]	interval= if the endpoint support periodic transfer, this indicates the polling rate.
 *                  	[IN]	sched_frame= if the endpoint supports periodic transfer, this indicates the start frame number.
 *                  	[IN]	hub_addr= indicate the address of hub which the USB device attachs to.
 *                  	[IN]	hub_port= inidcates the port number of the hub which the USB device attachs to.
 *                  	[IN]	f_is_do_split= inidcates whether this tranfer is split transaction or not.
 *
 * @return	USB_ERR_SUCCESS	-if successes to initiate the ed_t.
 *		USB_ERR_FAILl		-if fails to initiate the ed_t.
 *		USB_ERR_NOSPACE	-if fails to initiate the ed_t
 *					because there is no USB Resource for this init_ed.
 */
/******************************************************************************/
int init_ed(ed_t *init_ed,
	u8      	dev_addr,
	u8      	ep_num,
	bool        f_is_ep_in,
	u8      	dev_speed,
	u8      	ep_type,
	u16    	max_packet_size,
	u8      	multi_count,
	u8      	interval,
	u32    	sched_frame,
	u8     	hub_addr,
	u8     	hub_port,
	bool        f_is_do_split,
	void	*ep)
{
	init_ed->is_halted 		= false;
	init_ed->is_need_to_insert_scheduler= true;
	init_ed->ed_id 			= (u32)init_ed;
	init_ed->num_td 			= 0;
	init_ed->ed_private = ep;

	otg_list_init(&init_ed->td_list_entry);

	//start to initiate struct ed_desc....
	init_ed->ed_desc.is_do_split	= f_is_do_split;
	init_ed->ed_desc.is_ep_in		= f_is_ep_in;
	init_ed->ed_desc.dev_speed	= dev_speed;
	init_ed->ed_desc.hub_addr		= hub_addr;
	init_ed->ed_desc.hub_port		= hub_port;
	init_ed->ed_desc.mc		= multi_count;
	init_ed->ed_desc.device_addr	= dev_addr;
	init_ed->ed_desc.endpoint_num	= ep_num;
	init_ed->ed_desc.endpoint_type	= ep_type;
	init_ed->ed_desc.max_packet_size	= max_packet_size;
	init_ed->ed_desc.sched_frame	= sched_frame;

	if(init_ed->ed_desc.endpoint_type == INT_TRANSFER) {
		if(init_ed->ed_desc.dev_speed == LOW_SPEED_OTG ||init_ed->ed_desc.dev_speed == FULL_SPEED_OTG) {
			init_ed->ed_desc.interval	=interval;
		}
		else if(init_ed->ed_desc.dev_speed == HIGH_SPEED_OTG) {
			u8	count = 0;
			u8	cal_interval = 1;

			for(count = 0;count<(init_ed->ed_desc.interval-1);count++) {
				cal_interval *=2;
			}

			init_ed->ed_desc.interval	=cal_interval;
		}
		else {
			otg_dbg(OTG_DBG_TRANSFER,"Super-Speed is not supported\n");
		}
		init_ed->ed_desc.sched_frame = (SCHEDULE_SLOT+oci_get_frame_num())&HFNUM_MAX_FRNUM;
		ref_periodic_transfer++;
	}
	if(init_ed->ed_desc.endpoint_type==ISOCH_TRANSFER) {
		u8	count = 0;
		u8	cal_interval = 1;

		for(count = 0;count<(init_ed->ed_desc.interval-1);count++)
		{
			cal_interval *=2;
		}

		init_ed->ed_desc.interval	= cal_interval;
		init_ed->ed_desc.sched_frame = (SCHEDULE_SLOT+oci_get_frame_num())&HFNUM_MAX_FRNUM;
		ref_periodic_transfer++;
	}

	//start to initiate struct ed_status....

	//initiates PID
	switch(ep_type) {
	case BULK_TRANSFER:
	case INT_TRANSFER:
		init_ed->ed_status.data_tgl	= DATA0;
		break;

	case CONTROL_TRANSFER:
		init_ed->ed_status.control_data_tgl.setup_tgl	= SETUP;
		init_ed->ed_status.control_data_tgl.data_tgl	= DATA1;
		init_ed->ed_status.control_data_tgl.status_tgl	= DATA1;
		break;

	case ISOCH_TRANSFER:
		if(f_is_ep_in) {
			switch(multi_count) {
			case MULTI_COUNT_ZERO :
				init_ed->ed_status.data_tgl	= DATA0;
				break;
			case MULTI_COUNT_ONE :
				init_ed->ed_status.data_tgl	= DATA1;
				break;
			case MULTI_COUNT_TWO :
				init_ed->ed_status.data_tgl	= DATA2;
				break;
			default:
				break;
			}
		}
		else {
			switch(multi_count) {
			case MULTI_COUNT_ZERO :
				init_ed->ed_status.data_tgl	= DATA0;
				break;
			case MULTI_COUNT_ONE :
				init_ed->ed_status.data_tgl	= MDATA;
				break;
			case MULTI_COUNT_TWO :
				init_ed->ed_status.data_tgl	= MDATA;
				break;
			default:
				break;
			}
		}
		break;
	default:
		break;
	}

	if(init_ed->ed_desc.endpoint_type == INT_TRANSFER ||
		init_ed->ed_desc.endpoint_type == ISOCH_TRANSFER) {
		u32 usb_time = 0, byte_count = 0;

		//calculates the bytes to be transferred at one (uframe)frame.
		byte_count = (init_ed->ed_desc.mc+1)*init_ed->ed_desc.max_packet_size;

		usb_time =	(u32)otg_usbcore_get_calc_bustime(init_ed->ed_desc.dev_speed,
									init_ed->ed_desc.is_ep_in,
									(init_ed->ed_desc.endpoint_type==ISOCH_TRANSFER?true:false),
									byte_count);
		usb_time /= 1000;	//convert nanosec unit to usec unit

		if(reserve_used_resource_for_periodic(usb_time, init_ed->ed_desc.dev_speed, init_ed->ed_desc.endpoint_type) != USB_ERR_SUCCESS) {
			return USB_ERR_NOSPACE;
		}

		init_ed->ed_status.is_alloc_resource_for_ed	=true;
		init_ed->ed_desc.used_bus_time		=usb_time;
		init_ed->ed_desc.mc			=multi_count+1;
	}

	init_ed->ed_status.is_in_transfer_ready_q 	=false;
	init_ed->ed_status.is_in_transferring		=false;
	init_ed->ed_status.is_ping_enable		=false;
	init_ed->ed_status.in_transferring_td		=0;

// sztupy: split transaction support
	init_ed->ed_status.is_complete_split = false;
	init_ed->ed_status.split_pos = ED_STATUS_SPLIT_POS_ALL;
	init_ed->ed_status.split_offset = 0;

	//push the ed_t to ED_list.
	otg_list_push_prev(&init_ed->ed_list_entry,&ed_list_head);

	if(ref_periodic_transfer) {
		enable_sof();
	}
	return USB_ERR_SUCCESS;
}


/******************************************************************************/
/*!
 * @name	int 	create_td(td_t 	**new_td)
 *
 * @brief		this function creates a new td_t and returns the td_t to Caller
 *
 *
 * @param	[OUT]	new_td = returns the address of the new td_t .
 *
 * @return	USB_ERR_SUCCESS	-if successes to create the new td_t.
 *		USB_ERR_FAILl		-if fails to create to new td_t.
 */
/******************************************************************************/
int  	create_td(td_t 	**new_td)
{
	int	err_code = USB_ERR_SUCCESS;

	err_code =  otg_mem_alloc((void **)new_td,(u16)sizeof(td_t), USB_MEM_ASYNC);
	otg_mem_set(*new_td, 0, sizeof(td_t));
	return err_code;
}


/******************************************************************************/
/*!
 * @name	int 	init_td(	td_t			*init_td,
 *				ed_t 			*parent_ed,
 *				void 			*call_back_fun,
 *				void 			*call_back_param,
 *				u32			transfer_flag,
 *				bool                          	f_is_standard_dev_req,
 *				u32                        	phy_setup,
 *				u32			vir_setup,
 *				u32                      		vir_buf_addr,
 *				u32                      		phy_buf_addr,
 *				u32                      		buf_size,
 *				u32                      		isoch_start_frame,
 *				isoch_packet_desc_t 	*isoch_packet_desc,
 *				u32                       	isoch_packet_num,
 *				void 			*td_priv)
 *
 * @brief		this function initiates the init_td by using another parameter.
 *
 *
 * @param	[IN]	init_td			- indicate the td_t to be initiated.
 *		[IN]	parent_ed		- indicate the ed_t to manage this init_td
 *		[IN]	call_back_func		- indicate the call-back function of application.
 *		[IN]	call_back_param		- indicate the parameter of the call-back function.
 * 		[IN]	transfer_flag		- indicate the transfer flag.
 *		[IN]	f_is_standard_dev_req	- indicates the issue transfer request is USB Standard Request
 *		[IN]	phy_setup		- the physical address of buffer to store the USB Standard Request.
 *		[IN]	vir_setup		- the virtual address of buffer to store the USB Standard Request.
 *		[IN]	vir_buf_addr		- the virtual address of buffer to store the data to be transferred or received.
 *		[IN]	phy_buf_addr		- the physical address of buffer to store the data to be transferred or received.
 *		[IN]	buf_size			- indicates the buffer size.
 *		[IN]	isoch_start_frame		- if this usb transfer is isochronous transfer
 *						, this indicates the start frame to start the usb transfer.
 *		[IN]	isoch_packet_desc		- if the usb transfer is isochronous transfer
 *						, this indicates the structure to describe the isochronous transfer.
 *		[IN]	isoch_packet_num		- if the usb transfer is isochronous transfer
 *						, this indicates the number of packet to consist of the usb transfer.
 *		[IN]	td_priv			- indicate the private data to be delivered from usb core of linux.
 *							td_priv stores the urb of linux.
 *
 * @return	USB_ERR_SUCCESS -if successes to initiate the new td_t.
 *		USB_ERR_FAILl	  -if fails to create to new td_t.
 */
/******************************************************************************/
int  	init_td(	td_t			*init_td,
		ed_t 			*parent_ed,
		void 			*call_back_fun,
		void 			*call_back_param,
		u32			transfer_flag,
		bool                          	f_is_standard_dev_req,
		u32                        	phy_setup,
		u32			vir_setup,
		u32                      		vir_buf_addr,
		u32                      		phy_buf_addr,
		u32                      		buf_size,
		u32                      		isoch_start_frame,
		isoch_packet_desc_t 	*isoch_packet_desc,
		u32                       	isoch_packet_num,
		void 			*td_priv)
{
	if(f_is_standard_dev_req) {
		if((phy_buf_addr>0) && (buf_size>0)) {
			init_td->standard_dev_req_info.is_data_stage = true;
		}
		else {
			init_td->standard_dev_req_info.is_data_stage = false;
		}
		init_td->standard_dev_req_info.conrol_transfer_stage 		= SETUP_STAGE;
		init_td->standard_dev_req_info.phy_standard_dev_req_addr 	= phy_setup;
		init_td->standard_dev_req_info.vir_standard_dev_req_addr 	= vir_setup;
	}

	init_td->call_back_func_p		=	call_back_fun;
	init_td->call_back_func_param_p	=	call_back_param;
	init_td->error_code 		= 	USB_ERR_SUCCESS;
	init_td->is_standard_dev_req	= 	f_is_standard_dev_req;
	init_td->is_transfer_done		= 	false;
	init_td->is_transferring		=	false;
	init_td->td_private		= 	td_priv;
	init_td->err_cnt 			=	0;
	init_td->parent_ed_p		=	parent_ed;
	init_td->phy_buf_addr		=	phy_buf_addr;
	init_td->vir_buf_addr		=	vir_buf_addr;
	init_td->buf_size 			=	buf_size;
	init_td->isoch_packet_desc_p	=	isoch_packet_desc;
	init_td->isoch_packet_num		= 	isoch_packet_num;
	init_td->isoch_packet_index	= 	0;
	init_td->isoch_packet_position	=	0;
	init_td->sched_frame		= 	isoch_start_frame;
	init_td->used_total_bus_time	=	parent_ed->ed_desc.used_bus_time;
	init_td->td_id			= 	(u32)init_td;
	init_td->transfer_flag		=	transfer_flag;
	init_td->transferred_szie		=	0;

	switch(parent_ed->ed_desc.endpoint_type) {
	case CONTROL_TRANSFER:
		init_nonperio_stransfer(true, init_td);
		break;

	case BULK_TRANSFER:
		init_nonperio_stransfer(false, init_td);
		break;

	case INT_TRANSFER:
		init_perio_stransfer(false, init_td);
		break;

	case ISOCH_TRANSFER:
		init_perio_stransfer(true, init_td);
		break;

	default:
		return USB_ERR_FAIL;
	}

	//insert the td_t to parent_ed->td_list_entry.
	otg_list_push_prev(&init_td->td_list_entry,&parent_ed->td_list_entry);
	parent_ed->num_td++;

	return USB_ERR_SUCCESS;
}

/******************************************************************************/
/*!
 * @name	int  	issue_transfer(struct sec_otghost *otghost,
 * 				ed_t 		*parent_ed,
 *				void 			*call_back_func,
 *				void 			*call_back_param,
 * 				u32			transfer_flag,
 *				bool                        	f_is_standard_dev_req,
 *				u32                     		setup_vir_addr,
 *				u32                     		setup_phy_addr,
 *				u32                     		vir_buf_addr,
 *				u32                     		phy_buf_addr,
 *				u32                     		buf_size,
 *				u32                     		start_frame,
 *				u32                     		isoch_packet_num,
 *				isoch_packet_desc_t 	*isoch_packet_desc,
 *				void			*td_priv,
 *				unsigned int 		*return_td_addr)
 *
 * @brief		this function start USB Transfer
 *
 *
 * @param	[IN]	parent_ed		- indicate the ed_t to manage this issue transfer.
 *		[IN]	call_back_func		- indicate the call-back function of application.
 *		[IN]	call_back_param		- indicate the parameter of the call-back function.
 * 		[IN]	transfer_flag		- indicate the transfer flag.
 *		[IN]	f_is_standard_dev_req	- indicates the issue transfer request is USB Standard Request
 *		[IN]	setup_vir_addr		- the virtual address of buffer to store the USB Standard Request.
 *		[IN]	setup_phy_addr		- the physical address of buffer to store the USB Standard Request.
 *		[IN]	vir_buf_addr		- the virtual address of buffer to store the data to be transferred or received.
 *		[IN]	phy_buf_addr		- the physical address of buffer to store the data to be transferred or received.
 *		[IN]	buf_size			- indicates the buffer size.
 *		[IN]	start_frame		- if this usb transfer is isochronous transfer
 *						, this indicates the start frame to start the usb transfer.
 *		[IN]	isoch_packet_num		- if the usb transfer is isochronous transfer
 *						, this indicates the number of packet to consist of the usb transfer.
 *		[IN]	isoch_packet_desc		- if the usb transfer is isochronous transfer
 *						, this indicates the structure to describe the isochronous transfer.
 *		[IN]	td_priv			- indicate the private data to be delivered from usb core of linux.
 *							td_priv stores the urb of linux.
 *		[OUT]	return_td_addr		- indicates the variable address to store the new td_t for this transfer
 *
 * @return	USB_ERR_SUCCESS -if successes to initiate the new td_t.
 *		USB_ERR_FAILl	  -if fails to create to new td_t.
 */
/******************************************************************************/
int  	issue_transfer(struct sec_otghost *otghost,
			ed_t 			*parent_ed,
			void 			*call_back_func,
			void 			*call_back_param,
			u32			transfer_flag,
			bool                        	f_is_standard_dev_req,
			u32                     		setup_vir_addr,
			u32                     		setup_phy_addr,
			u32                     		vir_buf_addr,
			u32                     		phy_buf_addr,
			u32                     		buf_size,
			u32                     		start_frame,
			u32                     		isoch_packet_num,
			isoch_packet_desc_t 	*isoch_packet_desc,
			void 			*td_priv,
			unsigned int 		*return_td_addr)
{
	td_t *new_td_p = NULL;

	int err = USB_ERR_SUCCESS;
	if(create_td(&new_td_p)==USB_ERR_SUCCESS) {
		err = init_td(	new_td_p,
				parent_ed,
				call_back_func,
				call_back_param,
				transfer_flag,
				f_is_standard_dev_req,
				setup_phy_addr,
				setup_vir_addr,
				vir_buf_addr,
				phy_buf_addr,
				buf_size,
				start_frame,
				isoch_packet_desc,
				isoch_packet_num,
				td_priv);

		if(err !=USB_ERR_SUCCESS) {
			return USB_ERR_NOMEM;
		}

		if(parent_ed->is_need_to_insert_scheduler) {
			insert_ed_to_scheduler(otghost, parent_ed);
		}

		*return_td_addr = (u32)new_td_p;

		return USB_ERR_SUCCESS;
	}
	else {
		return USB_ERR_NOMEM;
	}
}

/******************************************************************************/
/*!
 * @name	int  	cancel_transfer(struct sec_otghost *otghost,
 * 					ed_t 	*parent_ed,
 *					td_t 	*cancel_td)
 *
 * @brief		this function cancels to transfer USB Transfer of cancel_td.
 *			this function firstly check whether this cancel_td is transferring or not
 *			if the cancel_td is transferring, the this function requests to cancel the USB Transfer
 *			to S3CScheduler. if the parent_ed is for Periodic Transfer, and
 *			there is not any td_t at parent_ed, then this function requests to release
 *			some usb resources for the ed_t to S3CScheduler. finally this function deletes the cancel_td.
 *
 * @param	[IN]	pUpdateTD	= indicates the pointer ot the td_t to have STransfer to be updated.
 *
 * @return	USB_ERR_SUCCESS	- if success to update the STranfer of pUpdateTD.
 *		USB_ERR_FAIL		- if fail to update the STranfer of pUpdateTD.
 */
 /******************************************************************************/
int  	cancel_transfer(struct sec_otghost *otghost,
	       				ed_t *parent_ed,
			       		td_t *cancel_td)
{
	int 		err = USB_ERR_DEQUEUED;
	otg_list_head	*tmp_list_p, *tmp_list2_p;
	bool		cond_found = false;

	if(parent_ed == NULL || cancel_td == NULL) {
		otg_dbg(OTG_DBG_TRANSFER, "parent_ed == NULL || cancel_td == NULL\n");
		cancel_td->error_code = USB_ERR_NOELEMENT;
		otg_usbcore_giveback(cancel_td);
		return cancel_td->error_code;
	}

	otg_list_for_each_safe(tmp_list_p, tmp_list2_p, &parent_ed->td_list_entry) {
		if(&cancel_td->td_list_entry == tmp_list_p) {
			cond_found = true;
			break;
		}
	}

	if (cond_found != true) {
		otg_dbg(OTG_DBG_TRANSFER, "cond_found != true \n");
		cancel_td->error_code = USB_ERR_NOELEMENT;
		otg_usbcore_giveback(cancel_td);
		return cancel_td->error_code;
	}


	if(cancel_td->is_transferring) {
		if(!parent_ed->ed_status.is_in_transfer_ready_q) {
			err = cancel_to_transfer_td(otghost, cancel_td);

			parent_ed->ed_status.in_transferring_td = 0;

			if(err != USB_ERR_SUCCESS) {
				otg_dbg(OTG_DBG_TRANSFER, "cancel_to_transfer_td \n");
				cancel_td->error_code = err;
				otg_usbcore_giveback(cancel_td);
				goto ErrorStatus;
			}

		}
		// kevinh - even if the record was in the ready queue it is important to delete it as well.  We can also always remove the ed from the scheduler
		// once all tds have been removed
		otg_list_pop(&cancel_td->td_list_entry);
		parent_ed->num_td--;
	}
	else {
		otg_list_pop(&cancel_td->td_list_entry);
		parent_ed->num_td--;

		if(parent_ed->num_td==0) {
			remove_ed_from_scheduler(parent_ed);
		}
	}

	if(parent_ed->num_td) {
          // kevinh - we do not want to force insert_scheduler, because if this endpoint _was_ already scheduled
          // because the deleted td was not the active td then we will now put ed into the scheduler list twice, thus
          // corrupting it.
          // parent_ed->is_need_to_insert_scheduler = true;
		insert_ed_to_scheduler(otghost, parent_ed);
	}
	else {
		if(parent_ed->ed_desc.endpoint_type == INT_TRANSFER ||
			parent_ed->ed_desc.endpoint_type == ISOCH_TRANSFER) {
			//Release channel and usb bus resource for this ed_t.
			//but, not release memory for this ed_t.
			free_usb_resource_for_periodic(parent_ed->ed_desc.used_bus_time,
							cancel_td->cur_stransfer.alloc_chnum,
							cancel_td->parent_ed_p->ed_desc.endpoint_type);

			parent_ed->ed_status.is_alloc_resource_for_ed	=false;
		}
	}
	// the caller of this functions should call otg_usbcore_giveback(cancel_td);
	cancel_td->error_code = USB_ERR_DEQUEUED;
	// kevinh - fixed bug, the caller should take care of calling delete_td because they might still want to do some
	// operations on that memory
	// delete_td(cancel_td);
	// otg_usbcore_giveback(cancel_td);

ErrorStatus:

	return err;
}


/******************************************************************************/
/*!
 * @name	int cancel_all_td(struct sec_otghost *otghost, ed_t *parent_ed)
 *
 * @brief		this function cancels all Transfer which parent_ed manages.
 *
 * @param	[IN]	parent_ed	= indicates the pointer ot the ed_t to manage TD_ts to be canceled.
 *
 * @return	USB_ERR_SUCCESS	- if success to cancel all TD_ts of pParentsED.
 *		USB_ERR_FAIL		- if fail to cancel all TD_ts of pParentsED.
 */
 /******************************************************************************/
int cancel_all_td(struct sec_otghost *otghost, ed_t *parent_ed)
{
	otg_list_head 	*cancel_td_list_entry;
	td_t 		*cancel_td;

	otg_dbg(OTG_DBG_OTGHCDI_HCD, "cancel_all_td \n");
	do {
		cancel_td_list_entry = parent_ed->td_list_entry.next;

		cancel_td = otg_list_get_node(cancel_td_list_entry,td_t, td_list_entry);

    		if(cancel_transfer(otghost, parent_ed, cancel_td) == USB_ERR_DEQUEUED)
		      // kevinh FIXME - do we also need to giveback?
		      delete_td(otghost,cancel_td);
	} while(parent_ed->num_td);

	return USB_ERR_SUCCESS;
}