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; } }