usb.c

本程序为ST公司开发的源代码

void InitMGCPeriheralLists(void)
{
 MGC_aHidPeripheralList1_p = MGC_aHidPeripheralList1;
 #ifdef _USB_HUB
 MGC_aHubPeripheralList_p = MGC_aHubPeripheralList;
 #endif
 MGC_aMsdPeripheralList1_p = MGC_aMsdPeripheralList1;
 MGC_aMsdPeripheralList2_p = MGC_aMsdPeripheralList2;
#if (1 == HAVE_WMDRM)
 MGC_aMtpPeripheralList1_p = MGC_aMtpPeripheralList1;
 MGC_aMtpPeripheralList2_p = MGC_aMtpPeripheralList2;
#endif
}

/*************************** USB TASK FUNCTIONS ****************************/
t_child_cmd_event usb_cmd_event_data[EVENT_MAX_STAGES];
void *get_usb_cmd_event_data(t_event_stage i)
{
 return (void *)&usb_cmd_event_data[i];
}

t_usb_status_event usb_status_event_data[EVENT_MAX_STAGES];
void *get_usb_status_event_data(t_event_stage i)
{
 return (void *)&usb_status_event_data[i];
}

RETVAL usb_cmd(t_child_cmd_event* cmd_event)
{   
  t_child_cmd_event* pout_event;
  
  pout_event = (t_child_cmd_event *)pevent_get_out(USB_CMD_EVENT);

  event_set_out(USB_CMD_EVENT);      /* priority dependent (semaphore signal immediatelly) */

  *pout_event = *cmd_event;

#ifdef _USB_DEBUG
	DBG_PRINTF("usb: NEW COMMAND FROM CONTROLLER\r\n");
#endif /*_USB_DEBUG*/
 

  event_out_shedule(USB_CMD_EVENT);
  return BUSY;
}




#if ((0!=IPOD_PASSTHROUGH) || (0!=IPOD_AP))	//[LL]new
/* Commands */
/* DownStream */
/******************************************************************************/
/* Function:  get_usb_downstream_cmd_event_data                               */
/*                                                                            */
/*! \brief    USB_DOWNSTREAM_CMD_EVENT data
*             
*  \param    
*  \return    pointer to the usb downstream command event
*  \remark
*******************************************************************************/
t_usb_downstream_cmd_event usb_downstream_cmd_event[EVENT_MAX_STAGES];
void * get_usb_downstream_cmd_event_data(t_event_stage i)
{
  return (void *)&usb_downstream_cmd_event[i];
}

/******************************************************************************/
/* Function:  usb_downstream_command                                          */
/*                                                                            */
/*! \brief    HOSTIF task sends command to USB task
*             
*  \param     t_usb_downstream_cmd_event * usb_downstream_cmd
*  \return
*  \remark
*******************************************************************************/
void usb_downstream_command(t_usb_downstream_cmd_event * usb_downstream_cmd)
{
  t_usb_downstream_cmd_event *pout_event;
  
  pout_event = (t_usb_downstream_cmd_event *)pevent_get_out(USB_DOWNSTREAM_CMD_EVENT);
  *pout_event = *usb_downstream_cmd;
  event_set_out(USB_DOWNSTREAM_CMD_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(USB_DOWNSTREAM_CMD_EVENT);
  //event_cmd_set(USB_DOWNSTREAM_CMD_EVENT);       //independent from priorities
}

/* UpStream */
/******************************************************************************/
/* Function:  get_usb_upstream_cmd_event_data                                 */
/*                                                                            */
/*! \brief    USB_UPSTREAM_CMD_EVENT data
*             
*  \param     
*  \return    pointer to thw usb downstream command event
*  \remark
*******************************************************************************/
t_usb_upstream_cmd_event usb_upstream_cmd_event[EVENT_MAX_STAGES];
void * get_usb_upstream_cmd_event_data(t_event_stage i)
{
  return (void *)&usb_upstream_cmd_event[i];
}

/******************************************************************************/
/* Function:  usb_upstream_command                                            */
/*                                                                            */
/*! \brief    HOSTIF task data acknowledge to USB task
*             
*  \param     t_usb_upstream_cmd_event * usb_upstream_cmd
*  \return
*  \remark
*******************************************************************************/
void usb_upstream_command(t_usb_upstream_cmd_event * usb_upstream_cmd)
{
  t_usb_upstream_cmd_event *pout_event;
  
  pout_event = (t_usb_upstream_cmd_event *)pevent_get_out(USB_UPSTREAM_CMD_EVENT);
  *pout_event = *usb_upstream_cmd;
  event_set_out(USB_UPSTREAM_CMD_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(USB_UPSTREAM_CMD_EVENT);
  //event_cmd_set(USB_UPSTREAM_CMD_EVENT);       //independent from priorities
}

/* Status channels */
/* DownStream */
/******************************************************************************/
/* Function:  get_usb_downstream_status_event_data                            */
/*                                                                            */
/*! \brief    USB_DOWNSTREAM_STATUS_EVENT data
*             
*  \param    
*  \return    pointer to usb status event
*  \remark
*******************************************************************************/
t_usb_downstream_status_event usb_downstream_status_event[EVENT_MAX_STAGES];
void * get_usb_downstream_status_event_data(t_event_stage i)
{
  return (void *)&usb_downstream_status_event[i];
}

/******************************************************************************/
/* Function:  usb_downstream_status                                           */
/*                                                                            */
/*! \brief    USB task sends status to HOSTIF task
*             
*  \param     t_usb_downstream_status_event * usb_downstream_status
*  \return
*  \remark
*******************************************************************************/
void usb_downstream_status(t_usb_downstream_status_event * usb_downstream_status)
{
  t_usb_downstream_status_event *pout_event;
  
  pout_event = (t_usb_downstream_status_event *)pevent_get_out(USB_DOWNSTREAM_STATUS_EVENT);
  *pout_event = *usb_downstream_status;
  event_set_out(USB_DOWNSTREAM_STATUS_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(USB_DOWNSTREAM_STATUS_EVENT);
  //event_cmd_set(USB_DOWNSTREAM_STATUS_EVENT);       //independent from priorities
}

/* UpStream*/
/******************************************************************************/
/* Function:  get_usb_upstream_status_event_data                              */
/*                                                                            */
/*! \brief    USB_UPSTREAM_STATUS_EVENT data
*             
*  \param    
*  \return    pointer to usb status event
*  \remark
*******************************************************************************/
t_usb_upstream_status_event usb_upstream_status_event[EVENT_MAX_STAGES];
void * get_usb_upstream_status_event_data(t_event_stage i)
{
  return (void *)&usb_upstream_status_event[i];
}

/******************************************************************************/
/* Function:  usb_upstream_status                                             */
/*                                                                            */
/*! \brief    USB task sends data to HOSTIF task
*             
*  \param     t_usb_upstream_status_event * usb_upstream_status
*  \return
*  \remark
*******************************************************************************/
void usb_upstream_status(t_usb_upstream_status_event * usb_upstream_status)
{
  t_usb_upstream_status_event *pout_event;
  
  pout_event = (t_usb_upstream_status_event *)pevent_get_out(USB_UPSTREAM_STATUS_EVENT);
  *pout_event = *usb_upstream_status;
  event_set_out(USB_UPSTREAM_STATUS_EVENT);     //priority dependent (semaphore signal immediatelly)
  event_out_shedule(USB_UPSTREAM_STATUS_EVENT);
  //event_cmd_set(USB_UPSTREAM_STATUS_EVENT);       //independent from priorities
}
#endif /*IPOD_PASSTHROUGH || IPOD_AP*/

/******************************************************************************/
/* Function:  InitUSBTask                                                     */
/*                                                                            */
/*! \brief    initialize the Usb Task
*  \param
*  \return
*  \remark
*******************************************************************************/
void InitUSBTask(void)
{
	usb_fsm_xfer.state = FSM_IDLE;
	usb_fsm_stop.state = FSM_IDLE;
	usb_fsm_background.state = FSM_IDLE;

	DYN_Init();

#ifdef _USB_DEBUG    
	memset(&USB_debug, 0, sizeof(USB_debug));	/* debug */
//	memset(&DRIVER_status_debug, 0, sizeof(DRIVER_status_debug));	/* debug */
//	memset(&TASK_status_debug, 0, sizeof(TASK_status_debug));	/* debug */
//	memset(&xfer_transition_sebug, 0, sizeof(xfer_transition_sebug));	/* debug */
//	memset(&process_preevents_debug, 0, sizeof(process_preevents_debug));	/* debug */
//	memset(&background_transition_debug, 0, sizeof(background_transition_debug));	/* debug */
#endif /*_USB_DEBUG*/
}

/******************************************************************************/
/* Function:  USBTask                                                         */
/*                                                                            */
/*! \brief    own Usb Task
*  \param
*  \return
*  \remark    reinitialization is used to reset the usb controller and driver
*******************************************************************************/
void USBTask(void *unused)
{
	t_usb_state status;

	status = USB_Init();

	if (status == USB_OK)
	{
		USB_ReinitializeUsb();
		while (1)
		{
			OSAL_wait_thread(OSAL_THREAD_USBTask);
			/* in scheduling */
			event_disable_scheduling();
//#if (0!=HAVE_USB_HIGH_Z)
//			event_in_shedule(USB_HIGH_Z_CMD_EVENT);
//#endif /*HAVE_USB_HIGH_Z*/
			event_in_shedule(USB_CMD_EVENT);
			
			event_in_shedule(USB_IRQ_EVENT);
#if ((0!=IPOD_PASSTHROUGH) || (0!=IPOD_AP))	//[LL]new
			event_in_shedule(USB_DOWNSTREAM_CMD_EVENT);
			event_in_shedule(USB_UPSTREAM_CMD_EVENT);
#endif /*IPOD_PASSTHROUGH || IPOD_AP*/
			event_enable_scheduling();

			usb_handler();

			/* out scheduling */
			event_disable_scheduling();
//#if (0!=HAVE_USB_HIGH_Z)
//			event_in_clear(USB_HIGH_Z_CMD_EVENT);
//#endif /*HAVE_USB_HIGH_Z*/
			event_in_clear(USB_CMD_EVENT);
			event_in_clear(USB_IRQ_EVENT);
#if ((0!=IPOD_PASSTHROUGH) || (0!=IPOD_AP))	//[LL]new
			event_in_clear(USB_DOWNSTREAM_CMD_EVENT);
			event_in_clear(USB_UPSTREAM_CMD_EVENT);

			event_out_shedule(USB_UPSTREAM_STATUS_EVENT);
			event_out_shedule(USB_DOWNSTREAM_STATUS_EVENT);
#endif /*IPOD_PASSTHROUGH || IPOD_AP*/
			event_out_shedule(USB_STOP_EVENT);
			event_out_shedule(USB_DATA_EVENT);
			event_out_shedule(USB_STATUS_EVENT);
			event_out_shedule(USB_IRQ_EVENT);
			event_enable_scheduling();    
			
			if (local_cmd_present)  
			  OSAL_wake_thread(OSAL_THREAD_USBTask); // wake up usb to continue processing
		}
	}
	else
	{
		DBG_PRINTF("usb: *E - USB_Init() failed\r\n");		
	}
}

/******************************************************************************/
/* Function:  usb_handler                                                     */
/*                                                                            */
/*! \brief    usb task handler
*             
*  \param
*  \return
*  \remark
*******************************************************************************/
//void usb_transition_handler(void)
void usb_handler(void)
{
	teUsbFsmCompl usb_awaited_transitions;


	usb_awaited_transitions = usb_process_preevents();
	if (usb_awaited_transitions == S_USB_FSM_END)
		return;	/* in order to skip the processing if forced destroy is requested */

	/* do loop is because transition listed below might require
	to start transision listed above without semaphore_signal */
	do 
	{
		usb_awaited_transitions = S_USB_FSM_END;

		if (usb_fsm_stop.state == FSM_RUN)	/* USB STOP */
		{
			usb_awaited_transitions |= usb_stop_transition();
		}

#if (1 == HAVE_WMDRM)
        if (usb_fsm_mtp.state == FSM_RUN)    /* MTP */
        {
			usb_awaited_transitions |= usb_mtp_transition();
        }
#endif
		if (usb_fsm_xfer.state == FSM_RUN)	/* USB XFER */
		{
			usb_awaited_transitions |= usb_xfer_transition();
		}

		if (usb_fsm_background.state == FSM_RUN)	/* USB BACKGROUND */
		{
			usb_background_transition();
		}

		usb_awaited_transitions |= usb_state_handling();

	} while(usb_awaited_transitions);
}

/******************************************************************************/
/* Function:  usb_process_preevents                                           */
/*                                                                            */
/*! \brief    pre-processing
*             
*  \param
*  \return
*  \remark
*******************************************************************************/
teUsbFsmCompl usb_process_preevents(void)
{
#ifdef _USB_DEBUG_PASSTHROUGH
	uint16 wIndex;
#endif /*_USB_DEBUG_PASSTHROUGH*/

#ifdef _USB_DEBUG
	static uint16 dbg_count = 0;
#endif /*_USB_DEBUG*/

#if ((0!=IPOD_PASSTHROUGH) || (0!=IPOD_AP))	//[LL]new
	tUsbIpodVolume* pUsbIpodVolume = NULL;
	tUsbPassthrough* pUsbPassthrough;
#endif /*IPOD_PASSTHROUGH || IPOD_AP*/
#ifdef _B32_BACK_COMPATIBILITY
	uint8 zero = 0;
#endif /*_B32_BACK_COMPATIBILITY*/
	t_usb_status_event *pout_event;


    /* DO a local copy of cmd_event ! */
#ifdef _USB_DEBUG
		DBG_PRINTF("usb: \tusb_process_preevents\r\n");
#endif /*_USB_DEBUG*/

	if(M_IS_SET(gUsbDevice.flag_check_enum))
	{ /* if USB enumeration check is requested */
		M_CLEAR_FLAG(gUsbDevice.flag_check_enum);
		USB_CheckEnumeration();
	}

	if(M_IS_SET(gUsbDevice.flag_check_medium))
	{ /* if USB medium check is requested */
		M_CLEAR_FLAG(gUsbDevice.flag_check_medium);
		MUSB_MsdCheckMedium(S_USB_MOUNT_ALL);
	}

#if ((0!=IPOD_PASSTHROUGH) || (0!=IPOD_AP))	//[LL]new
	if (EVENT_USB_IS_DOWNSTREAM_CMD)
	{
		MUSB_CisStatus send_status;
#ifdef _USB_DEBUG
		DBG_PRINTF("U:Dcmd\r\n");
#endif
        /* set ack status and send it */
		local_usb_downstream_cmd = EVENT_USB_DOWNSTREAM_CMD;
#ifdef _USB_DEBUG_PASSTHROUGH
		DBG_PRINTF(" OUT%d[%d]=", local_usb_downstream_cmd.bEndFlag, local_usb_downstream_cmd.DataLength);
		for(wIndex = 0; wIndex < local_usb_downstream_cmd.DataLength; wIndex++)
		{
			DBG_PRINTF("%02x ", local_usb_downstream_cmd.pData[wIndex]);
		}
		DBG_PRINTF("\r\n");
#endif /*_USB_DEBUG_PASSTHROUGH*/

#ifdef _B32_BACK_COMPATIBILITY
		pUsbIpodVolume = (tUsbIpodVolume*)USB_GetVolume(S_USB_TYPE_IPOD, S_USB_GET_FIRST, &zero);
#else /*_B32_BACK_COMPATIBILITY*/
		pUsbIpodVolume = (tUsbIpodVolume*)USB_GetVolume(S_USB_TYPE_IPOD, S_USB_GET_FIRST, local_usb_downstream_cmd.bVolNum);
#endif /*_B32_BACK_COMPATIBILITY*/
		if (pUsbIpodVolume)
		{
			send_status = MUSB_CisSendRawMessage(pUsbIpodVolume->DeviceInfo.pImplData,	//TBD - will be integrated ?