int action_clean(UmMainData *ad, int mode)
{
__USB_FUNC_ENTER__ ;
if(!ad) return -1;
int ret = -1;
int usbSelMode = -1;
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode);
switch(mode) {
case SETTING_USB_DEFAULT_MODE:
USB_LOG("Mode : SETTING_USB_DEFAULT_MODE action_clean\n");
call_cmd(SDBD_STOP);
break;
case SETTING_USB_DEBUG_MODE:
call_cmd(OPENSSHD_STOP);
if (SETTING_USB_MOBILE_HOTSPOT == usbSelMode) {
call_cmd(OPENSSHD_STOP);
}
break;
case SETTING_USB_MOBILE_HOTSPOT:
USB_LOG("Mode : SETTING_USB_MOBILE_HOTSPOT action_clean\n");
if (SETTING_USB_DEBUG_MODE == usbSelMode) {
call_cmd(UNSET_USB0_IP);
}
break;
case SETTING_USB_ACCESSORY_MODE:
default:
break;
}
ret = mode_set_kernel(ad->driverVersion, SETTING_USB_NONE_MODE);
um_retvm_if(0 != ret, -1, "FAIL: mode_set_kernel(SETTING_USB_SAMSUNG_KIES)");
__USB_FUNC_EXIT__ ;
return 0;
}
static s32 __usbstorage_reset(usbstorage_handle *dev)
{
s32 retval;
/*
retval = ehci_reset_device(dev->usb_fd);
if(retval < 0 && retval != -7004)
goto end;
*/
//debug_printf("usbstorage reset..\n");
USB_LOG("Resetting device.\n");
retval = __USB_CtrlMsgTimeout(dev, (USB_CTRLTYPE_DIR_HOST2DEVICE | USB_CTRLTYPE_TYPE_CLASS | USB_CTRLTYPE_REC_INTERFACE), USBSTORAGE_RESET, 0, dev->interface, 0, NULL);
/* FIXME?: some devices return -7004 here which definitely violates the usb ms protocol but they still seem to be working... */
if(retval < 0 && retval != -7004)
goto end;
/* gives device enough time to process the reset */
usleep(10);
USB_LOG("Clearing halts on both endpoints\n");
//debug_printf("cleat halt on bulk ep..\n");
retval = (*context.interface)->ClearPipeStallBothEnds(context.interface, dev->ep_in);
if(retval < 0)
goto end;
retval = (*context.interface)->ClearPipeStallBothEnds(context.interface, dev->ep_out);
end:
return retval;
}
int connectUsb(UmMainData *ad)
{
__USB_FUNC_ENTER__ ;
if(!ad) return -1;
int ret = -1;
int mh_status = -1;
int usbSelMode = -1;
/* If the mobile hotspot is on, USB-setting changes USB mode to mobile hotspot */
mh_status = check_mobile_hotspot_status();
if ((mh_status >= 0) && (mh_status & VCONFKEY_MOBILE_HOTSPOT_MODE_USB))
{
USB_LOG("Mobile hotspot is on\n");
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_MOBILE_HOTSPOT);
um_retvm_if (0 != ret, -1, "FAIL: vconf_set_int(VCONF_SETAPPL_USB_SEL_MODE_INT)\n");
__USB_FUNC_EXIT__ ;
return 0;
} else {
USB_LOG("Mobile hotspot is off\n");
}
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, &usbSelMode);
if (0 != ret) {
USB_LOG("FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT)\n");
usbSelMode = SETTING_USB_DEFAULT_MODE;
}
ret = set_USB_mode(ad, usbSelMode);
if (0 != ret) {
USB_LOG("ERROR: Cannot set USB mode \n");
}
__USB_FUNC_EXIT__ ;
return 0;
}
int set_USB_mode(UmMainData *ad, int mode)
{
__USB_FUNC_ENTER__ ;
if(!ad) return -1;
int ret = -1;
int done = ACT_FAIL;
int usbCurMode = -1;
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, IN_MODE_CHANGE);
if (0 != ret) {
USB_LOG("FAIL: vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)");
}
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode);
if (0 == ret && SETTING_USB_NONE_MODE != usbCurMode) {
action_clean(ad, usbCurMode);
}
USB_LOG("Mode change : %d\n", mode);
done = run_core_action(ad, mode);
ret = usb_mode_change_done(ad, done);
um_retvm_if(0 != ret, -1, "usb_mode_change_done(ad, done)");
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, CHANGE_COMPLETE);
if (0 != ret) {
USB_LOG("vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)");
}
__USB_FUNC_EXIT__ ;
return 0;
}
int disconnectUsb(UmMainData *ad)
{
__USB_FUNC_ENTER__ ;
if(!ad) return -1;
int ret = -1;
int usbCurMode = -1;
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode);
um_retvm_if(ret <0, -1, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n");
action_clean(ad, usbCurMode);
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT, SETTING_USB_NONE_MODE);
if (ret != 0) {
USB_LOG("ERROR: vconf_set_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n");
}
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_DEFAULT_MODE);
if (0 != ret) {
USB_LOG("ERROR: vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT)\n");
}
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE, CHANGE_COMPLETE);
if (0 != ret) {
USB_LOG("FAIL: vconf_set_int(VCONFKEY_SETAPPL_USB_IN_MODE_CHANGE)\n");
}
__USB_FUNC_EXIT__ ;
return 0;
}
static int run_core_action(UmMainData *ad, int mode)
{
__USB_FUNC_ENTER__ ;
if(!ad) return ACT_FAIL;
int ret = -1;
int usbCurMode = -1;
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode);
um_retvm_if(0 != ret, ACT_FAIL, "FAIL: vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT)\n");
switch(mode)
{
case SETTING_USB_DEFAULT_MODE:
USB_LOG("Mode : SETTING_USB_DFAULT_MODE\n");
ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEFAULT_MODE);
um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n");
start_dr(ad);
call_cmd(SDBD_START);
break;
case SETTING_USB_DEBUG_MODE:
USB_LOG("Mode: SETTING_USB_DEBUG_MODE\n");
if (SETTING_USB_MOBILE_HOTSPOT != usbCurMode) {
ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEBUG_MODE);
um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n");
call_cmd(SET_USB0_IP);
call_cmd(ADD_DEFAULT_GW);
}
call_cmd(OPENSSHD_START);
case SETTING_USB_MOBILE_HOTSPOT:
USB_LOG("Mode : SETTING_USB_MOBILE_HOTSPOT\n");
if (SETTING_USB_DEBUG_MODE != usbCurMode) {
ret = mode_set_kernel(ad->driverVersion, SETTING_USB_DEBUG_MODE);
um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n");
call_cmd(SET_USB0_IP);
call_cmd(ADD_DEFAULT_GW);
}
break;
case SETTING_USB_ACCESSORY_MODE:
USB_LOG("Mode : SETTING_USB_ACCESSORY_MODE\n");
ret = mode_set_kernel(ad->driverVersion, SETTING_USB_ACCESSORY_MODE);
um_retvm_if(0 != ret, ACT_FAIL, "FAIL : mode_set_kernel()\n");
break;
default:
break;
}
__USB_FUNC_EXIT__ ;
return ACT_SUCCESS;
}
int CALLBACK USBfreeze(int mode, freezeData *data) {
USBfreezeData *usbd;
switch( mode ) {
case FREEZE_LOAD:
if (data->size != sizeof(USBfreezeData)) {
USB_LOG( "Freeze load failure!\n" );
return -1;
}
usbd = (USBfreezeData*) (data->data);
if( usbd->version != 2 ) {
USB_LOG( "Freeze load failure = incorrect version (%d)\n", usbd->version );
return -1;
}
memcpy( usbregs, usbd->usbregs, sizeof(usbregs) );
memcpy( usbdevice, usbd->usbdevice, sizeof(usbdevice) );
USB_LOG( "Freeze load\n" );
USB_ResetRoothub(0);
break;
case FREEZE_SAVE:
usbd = (USBfreezeData*) (data->data);
usbd->version = 2;
memcpy( usbd->usbregs, usbregs, sizeof(usbregs) );
memcpy( usbd->usbdevice, usbdevice, sizeof(usbdevice) );
USB_LOG( "Freeze save\n" );
break;
case FREEZE_SIZE:
data->size = sizeof( USBfreezeData );
break;
}
return 0;
}
// ehci driver has its own timeout.
static s32 __USB_BlkMsgTimeout(usbstorage_handle *dev, u8 bEndpoint, u16 wLength, void *rpData)
{
IOReturn err;
UInt32 s;
if(bEndpoint == dev->ep_in) {
err = (*context.interface)->WritePipe(context.interface, bEndpoint, rpData, wLength);
USB_LOG("Sending bulk transfer, %d bytes sent, (0x%08x)\n", wLength, err);
} else if(bEndpoint == dev->ep_out) {
err = (*context.interface)->ReadPipe(context.interface, bEndpoint, rpData, &s);
USB_LOG("Receiving bulk transfer, %d bytes received, (0x%08x)\n", s, err);
}
return wLength;
}
static s32 __read_csw(usbstorage_handle *dev, u8 *status, u32 *dataResidue)
{
s32 retval = USBSTORAGE_OK;
u32 signature, tag, _dataResidue, _status;
memset(dev->buffer, 0xff, CSW_SIZE);
retval = __USB_BlkMsgTimeout(dev, dev->ep_in, CSW_SIZE, dev->buffer);
USB_LOG("Bulk timeout 0x%08x\n", retval);
//print_hex_dump_bytes("csv resp:",DUMP_PREFIX_OFFSET,dev->buffer,CSW_SIZE);
if(retval >= 0 && retval != CSW_SIZE) return USBSTORAGE_ESHORTREAD;
else if(retval < 0) return retval;
signature = le32_to_cpu(((u32*)dev->buffer)[0]);
tag = le32_to_cpu(((u32*)dev->buffer)[1]);
_dataResidue = le32_to_cpu(((u32*)dev->buffer)[2]);
_status = dev->buffer[12];
if(signature != CSW_SIGNATURE) {
return USBSTORAGE_ESIGNATURE;
}
if(dataResidue != NULL)
*dataResidue = _dataResidue;
if(status != NULL)
*status = _status;
if(tag != dev->tag) return USBSTORAGE_ETAG;
dev->tag++;
return USBSTORAGE_OK;
}
int call_cmd(char* cmd)
{
__USB_FUNC_ENTER__ ;
int ret = system(cmd);
USB_LOG("The result of %s is %d\n",cmd, ret);
__USB_FUNC_EXIT__ ;
return ret;
}
void Device_Request_Out()
{
switch( port_type[ device_port ] ) {
case PAD_TYPE_GUNCON: Guncon2_Request_Out(); break;
default:
USB_LOG( "\t\t\t*** Unknown device request out\n" );
break;
}
}
void Process_Request_Class()
{
switch( port_type[ device_port ] ) {
case PAD_TYPE_GUNCON: Guncon2_Request_Class(); break;
default:
USB_LOG( "\t\t\t*** Unknown device request class\n" );
break;
}
}
s32 USBStorage_Inquiry(usbstorage_handle *dev, u8 lun)
{
s32 retval;
u8 cmd[] = {SCSI_INQUIRY, lun << 5,0,0,36,0};
u8 *response = USB_Alloc(36);
USB_LOG("Inquiring about SCSI drive\n");
retval = __cycle(dev, lun, response, 36, cmd, 6, 0, NULL, NULL);
//print_hex_dump_bytes("inquiry result:",DUMP_PREFIX_OFFSET,response,36);
USB_Free(response);
return retval;
}
void change_hotspot_status_cb(keynode_t* in_key, void *data)
{
__USB_FUNC_ENTER__ ;
if(!data) return ;
UmMainData *ad = (UmMainData *)data;
int mh_status = -1;
int ret = -1;
int usbCurMode = -1;
if (VCONFKEY_SYSMAN_USB_AVAILABLE != check_usb_connection()) {
return;
}
mh_status = check_mobile_hotspot_status();
USB_LOG("mobile_hotspot_status: %d\n", mh_status);
um_retm_if (0 > mh_status, "FAIL: Getting mobile hotspot status\n");
ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usbCurMode);
um_retm_if (0 != ret, "FAIL: vconf_get_int(VCONF_SETAPPL_USB_MODE_INT)\n");
if (mh_status & VCONFKEY_MOBILE_HOTSPOT_MODE_USB) {
USB_LOG("USB Mobile hotspot is on\n");
if (usbCurMode != SETTING_USB_MOBILE_HOTSPOT) {
/* When mobile hotspot is on, this callabck only sets vconf key value of USB mode.
* And then, the callback function for vconf change will be called */
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, SETTING_USB_MOBILE_HOTSPOT);
um_retm_if (0 != ret, "FAIL: vconf_set_int(VCONF_SETAPPL_USB_MODE_INT)\n");
}
} else {
USB_LOG("USB Mobile hotspot is off\n");
if (usbCurMode == SETTING_USB_MOBILE_HOTSPOT) {
ret = vconf_set_int(VCONFKEY_SETAPPL_USB_SEL_MODE_INT, ad->usbSelMode);
if (0 != ret) {
USB_LOG("FAIL: vconf_set_int(VCONF_SETAPPL_USB_SEL_MODE_INT)\n");
return;
}
}
}
__USB_FUNC_EXIT__ ;
}
static s32 __USB_CtrlMsgTimeout(usbstorage_handle *dev, u8 bmRequestType, u8 bmRequest, u16 wValue, u16 wIndex, u16 wLength, void *rpData)
{
IOUSBDevRequest ctrl;
IOReturn err;
ctrl.bmRequestType = bmRequestType;
ctrl.bRequest = bmRequest;
ctrl.wValue = wValue;
ctrl.wIndex = wIndex;
ctrl.wLength = wLength;
ctrl.pData = rpData;
err = (*context.interface)->ControlRequest(context.interface, 0, &ctrl);
USB_LOG("Sending control transfer, %d bytes sent (%d attempted), (0x%08x)\n", ctrl.wLenDone, wLength, err);
return ctrl.wLenDone;
}
void usb_connection_selected_btn(UmMainData *ad, int input)
{
__USB_FUNC_ENTER__ ;
if(!ad) return ;
if (VCONFKEY_SYSMAN_USB_AVAILABLE != check_usb_connection()) {
return;
}
switch (input) {
case ERROR_POPUP_OK_BTN:
USB_LOG("The button on the error popup is selected\n");
response_error_popup(ad);
break;
default:
break;
}
__USB_FUNC_EXIT__ ;
}
void Process_Request_Standard()
{
if( ( DEVICE.req_format & REQ_TARGET ) == REQ_TARGET_DEVICE ) {
switch( DEVICE.req ) {
case DEVICE_GET_STATUS:
USB_LOG( "\t\tGet status\n" );
// return 2 bytes
DEVICE.data_buf[0] = 0;
DEVICE.data_buf[1] = 0;
break;
case DEVICE_CLEAR_FEATURE:
USB_LOG( "\t\t*** Clear feature\n" );
break;
case DEVICE_SET_FEATURE:
USB_LOG( "\t\t*** Set feature\n" );
break;
case DEVICE_SET_ADDRESS:
USB_LOG( "\t\tSet address = %d\n", DEVICE.req_arg1 );
// assign unique id
DEVICE.id = DEVICE.req_arg1;
break;
case DEVICE_GET_DESCRIPTOR:
USB_LOG( "\t\tGet descriptor = I%d : D%d\n", DEVICE.req_arg1 & 0xff, DEVICE.req_arg1>>8 );
memcpy( DEVICE.data_buf, Get_Device_Descriptor(), DEVICE.data_len );
break;
case DEVICE_SET_DESCRIPTOR:
USB_LOG( "\t\t*** Set descriptor = I%d : D%d\n", DEVICE.req_arg1 & 0xff, DEVICE.req_arg1>>8 );
break;
case DEVICE_GET_CONFIGURATION:
USB_LOG( "\t\t*** Get configuration\n" );
// return configuration #
DEVICE.data_buf[0] = DEVICE.config;
break;
case DEVICE_SET_CONFIGURATION:
USB_LOG( "\t\tSet configuration = %d\n", DEVICE.req_arg1 );
// device now configured
DEVICE.config = DEVICE.req_arg1;
break;
default:
USB_LOG( "\t\t*** Unknown request command\n" );
break;
}
}
else if( ( DEVICE.req_format & REQ_TARGET ) == REQ_TARGET_INTERFACE ) {
static int ep0_standard_setup (struct urb *urb)
{
struct device_request *request;
struct mt_dev *device;
char *cp = urb->buffer;
if (!urb || !urb->device)
{
USB_LOG ("\n!urb || !urb->device\n");
return -1;
}
request = &urb->device_request;
device = urb->device;
USB_LOG ("\nUSB: Device Request\n");
USB_LOG (" bmRequestType = %x\n", request->bmRequestType);
USB_LOG (" bRequest = %x\n", request->bRequest);
USB_LOG (" wValue = %x\n", request->wValue);
USB_LOG (" wIndex = %x\n", request->wIndex);
USB_LOG (" wLength = %x\n\n", request->wLength);
if ((request->bmRequestType & USB_TYPE_MASK) != 0)
{
return -1; /* Class-specific requests are handled elsewhere */
}
/* handle all requests that return data (direction bit set on bm RequestType) */
if ((request->bmRequestType & USB_DIR_MASK))
{
ep0_state = EP0_TX;
switch (request->bRequest)
{
/* data stage: from device to host */
case STDREQ_GET_STATUS:
urb->actual_length = 2;
cp[0] = cp[1] = 0;
switch (request->bmRequestType & USB_RECIP_MASK)
{
case USB_RECIP_DEVICE:
cp[0] = USB_STAT_SELFPOWERED;
break;
case USB_RECIP_OTHER:
urb->actual_length = 0;
break;
default:
break;
}
return 0;
case STDREQ_GET_DESCRIPTOR:
return usb_get_descriptor (device, urb,
(request->wLength),
(request->wValue) >> 8,
(request->wValue) & 0xff);
case STDREQ_GET_CONFIGURATION:
urb->actual_length = 1;
((char *) urb->buffer)[0] = device->configuration;
return 0;
case STDREQ_GET_INTERFACE:
urb->actual_length = 1;
((char *) urb->buffer)[0] = device->alternate;
return 0;
default:
USB_LOG ("Unsupported command with TX data stage\n");
break;
}
}
