Ejemplo n.º 1
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_GetDeviceList(const char *devpath,void *descr_buffer,u8 num_descr,u8 b0,u8 *cnt_descr)
{
	s32 fd,ret;
	char *path;
	u32 cntdevs;

	if(devpath==NULL || *devpath=='\0') return IPC_EINVAL;

	path = (char*)iosAlloc(hId,IPC_MAXPATH_LEN);
	if(path==NULL) return IPC_ENOMEM;
	
	strncpy(path,devpath,IPC_MAXPATH_LEN);
	fd = IOS_Open(path,IPC_OPEN_NONE);
	if(fd<0) {
		iosFree(hId,path);
		return fd;
	}

	cntdevs = 0;
	ret = IOS_IoctlvFormat(hId,fd,USB_IOCTL_GETDEVLIST,"bb:bd",num_descr,b0,&cntdevs,descr_buffer,(num_descr<<3));
	if(ret>=0) *cnt_descr = cntdevs;
	
	iosFree(hId,path);
	IOS_Close(fd);
	return ret;
}
Ejemplo n.º 2
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_DeviceInsertNotifyAsync(const char *devpath,u16 vid,u16 pid,usbcallback cb,void *usrdata)
{
	char *path;
	s32 fd = -1;
	s32 ret = IPC_ENOMEM;
	u16 *pvid = NULL;
	u16 *ppid = NULL;
	ioctlv *vec = NULL;
	struct _usb_cb *msgcb = NULL;

	if(devpath==NULL || *devpath=='\0') return IPC_EINVAL;

	path = (char*)iosAlloc(hId,IPC_MAXPATH_LEN);
	if(path==NULL) return IPC_ENOMEM;
	
	strncpy(path,devpath,IPC_MAXPATH_LEN);
	fd = IOS_Open(path,IPC_OPEN_NONE);
	if(fd<0) {
		ret = fd;
		goto done;
	}

	vec = iosAlloc(hId,sizeof(ioctlv)*2);
	if(vec==NULL) goto done;

	msgcb = iosAlloc(hId,sizeof(struct _usb_cb));
	if(msgcb==NULL) goto done;

	pvid = iosAlloc(hId,32);
	if(pvid==NULL) goto done;
	*pvid = vid;

	ppid = iosAlloc(hId,32);
	if(ppid==NULL) goto done;
	*ppid = pid;

	vec[0].data = pvid;
	vec[0].len = sizeof(u16);
	vec[1].data = ppid;
	vec[1].len = sizeof(u16);

	msgcb->fd = fd;
	msgcb->cb = cb;
	msgcb->vec = vec;
	msgcb->usrdata = usrdata;
	return IOS_IoctlvAsync(fd,USB_IOCTL_DEVINSERTHOOK,2,0,vec,__usb_device_notificationCB,msgcb);

done:
	if(ppid!=NULL) iosFree(hId,ppid);
	if(pvid!=NULL) iosFree(hId,pvid);
	if(msgcb!=NULL) iosFree(hId,msgcb);
	if(vec!=NULL) iosFree(hId,vec);
	if(path!=NULL) iosFree(hId,path);
	
	if(fd>=0) IOS_Close(fd);

	return ret;
}
Ejemplo n.º 3
0
Archivo: usb.c Proyecto: comex/libogc
static inline s32 __usb_interrupt_bulk_message(s32 fd,u8 ioctl,u8 bEndpoint,u16 wLength,void *rpData,usbcallback cb,void *usrdata)
{
	s32 ret = IPC_ENOMEM;
	u8 *pEndP = NULL;
	u16 *pLength = NULL;
	ioctlv *vec = NULL;
	struct _usb_cb *msgcb = NULL;

	if(((s32)rpData%32)!=0) return IPC_EINVAL;
	if(wLength && !rpData) return IPC_EINVAL;
	if(!wLength && rpData) return IPC_EINVAL;

	vec = iosAlloc(hId,sizeof(ioctlv)*3);
	if(vec==NULL) return IPC_ENOMEM;

	pEndP = iosAlloc(hId,32);
	if(pEndP==NULL) goto done;
	*pEndP = bEndpoint;

	pLength = iosAlloc(hId,32);
	if(pLength==NULL) goto done;
	*pLength = wLength;

	vec[0].data = pEndP;
	vec[0].len = sizeof(u8);
	vec[1].data = pLength;
	vec[1].len = sizeof(u16);
	vec[2].data = rpData;
	vec[2].len = wLength;

	if(cb==NULL)
		ret = IOS_Ioctlv(fd,ioctl,2,1,vec);
	else {
		msgcb = iosAlloc(hId,sizeof(struct _usb_cb));
		if(msgcb==NULL) goto done;

		msgcb->fd = -1;
		msgcb->cb = cb;
		msgcb->usrdata = usrdata;
		msgcb->vec = vec;
		return IOS_IoctlvAsync(fd,ioctl,2,1,vec,__usb_bulk_messageCB,msgcb);
	}

done:
	if(pLength!=NULL) iosFree(hId,pLength);
	if(pEndP!=NULL) iosFree(hId,pEndP);
	if(vec!=NULL) iosFree(hId,vec);

	return ret;
}
Ejemplo n.º 4
0
s32 ssl_new(u8 * CN, u32 ssl_verify_options){

	s32 ret;
	s32 aContext[8] ATTRIBUTE_ALIGN(32);
	u32 aVerify_options[8] ATTRIBUTE_ALIGN(32);

	ret = ssl_open();
	if(ret){
		return ret;
	}

	aVerify_options[0] = ssl_verify_options;

	if(ISALIGNED(CN)){ //Avoid alignment if the input is aligned
		ret = IOS_IoctlvFormat(__ssl_hid, __ssl_fd, IOCTLV_SSL_NEW, "d:dd", aContext, 0x20, aVerify_options, 0x20, CN, 0x100);
	}else{
		u8 *aCN = NULL;

		aCN = iosAlloc(__ssl_hid, 0x100);
		if (!aCN) {
			return IPC_ENOMEM;
		}

		memcpy(aCN, CN, 0x100);
		ret = IOS_IoctlvFormat(__ssl_hid, __ssl_fd, IOCTLV_SSL_NEW, "d:dd", aContext, 0x20, aVerify_options, 0x20, aCN, 0x100);

		if(aCN){
			iosFree(__ssl_hid, aCN);
		}
	}

	ssl_close();

return (ret ? ret : aContext[0]);
}
Ejemplo n.º 5
0
s32 ssl_read(s32 ssl_context, void* buffer, s32 length){
	s32 aSsl_context[8] ATTRIBUTE_ALIGN(32);
	s32 aResponse[8] ATTRIBUTE_ALIGN(32);
	s32 ret;

	ret = ssl_open();
	if(ret){
		return ret;
	}

	if(!buffer){
		return IPC_EINVAL;
	}

	u8 *aBuffer = NULL;
	aBuffer = iosAlloc(__ssl_hid, length);
	if (!aBuffer) {
		return IPC_ENOMEM;
	}

	aSsl_context[0] = ssl_context;
	ret = IOS_IoctlvFormat(__ssl_hid, __ssl_fd, IOCTLV_SSL_READ, "dd:d", aResponse, 0x20, aBuffer, length, aSsl_context, 0x20);
	ssl_close();

	if(ret == IPC_OK){
		memcpy(buffer, aBuffer, aResponse[0]);
	}

	if(aBuffer){
		iosFree(__ssl_hid, aBuffer);
	}

return (ret ? ret : aResponse[0]);
}
Ejemplo n.º 6
0
s32 ssl_setrootca(s32 ssl_context, const void *root, u32 length){

	s32 aSsl_context[8] ATTRIBUTE_ALIGN(32);
	s32 aResponse[8] ATTRIBUTE_ALIGN(32);
	s32 ret;

	ret = ssl_open();
	if(ret){
		return ret;
	}

	aSsl_context[0] = ssl_context;

	if(ISALIGNED(root)){ //Avoid alignment if the input is aligned
		ret = IOS_IoctlvFormat(__ssl_hid, __ssl_fd, IOCTLV_SSL_SETROOTCA, "d:dd", aResponse, 0x20, aSsl_context, 0x20, root, length);
	}else{
		u8 *aRoot = NULL;

		aRoot = iosAlloc(__ssl_hid, length);
		if (!aRoot) {
			return IPC_ENOMEM;
		}

		memcpy(aRoot, root, length);
		ret = IOS_IoctlvFormat(__ssl_hid, __ssl_fd, IOCTLV_SSL_SETROOTCA, "d:dd", aResponse, 0x20, aSsl_context, 0x20, aRoot, length);

		if(aRoot){
			iosFree(__ssl_hid, aRoot);
		}
	}

	ssl_close();

return (ret ? ret : aResponse[0]);
}
Ejemplo n.º 7
0
bool SDHC_ReadSectors(u32 sector, u32 count, void *buffer)
{
	void *buf = (void *)buffer;
	u32   len = (sector_size * count);

	s32 ret;

	/* Device not opened */
	if (fd < 0)
		return false;

	/* Buffer not aligned */
	if ((u32)buffer & 0x1F) {
		/* Allocate memory */
		buf = iosAlloc(hid, len);
		if (!buf)
			return false;
	}

	/* Read data */
	ret = IOS_IoctlvFormat(hid, fd, IOCTL_SDHC_READ, "ii:d", sector, count, buf, len);

	/* Copy data */
	if (buf != buffer) {
		memcpy(buffer, buf, len);
		iosFree(hid, buf);
	}

	return (!ret) ? true : false;
}
Ejemplo n.º 8
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_GetAsciiString(s32 fd,u16 wIndex,u16 wLangID,u16 wLength,void *rpData)
{
	s32 ret;
	u8 bo, ro;
	u8 *buf;
	u8 *rp = (u8 *)rpData;

	if(wLength > 255)
		wLength = 255;

	buf = iosAlloc(hId, 255); /* 255 is the highest possible length of a descriptor */
	if(buf == NULL)
		return IPC_ENOMEM;

	ret = __usb_control_message(fd, USB_ENDPOINT_IN, USB_REQ_GETDESCRIPTOR, ((USB_DT_STRING << 8) + wIndex), wLangID, 255, buf, NULL, NULL);

	/* index 0 gets a list of supported languages */
	if(wIndex == 0)
	{
		if(ret > 0)
			memcpy(rpData, buf, wLength);
		iosFree(hId, buf);
		return ret;
	}

	if(ret > 0)
	{
		bo = 2;
		ro = 0;
		while(ro < (wLength - 1) && bo < buf[0])
		{
			if(buf[bo + 1])
				rp[ro++] = '?';
			else
				rp[ro++] = buf[bo];
			bo += 2;
		}
		rp[ro] = 0;
		ret = ro - 1;
	}

	iosFree(hId, buf);
 	return ret;
}
Ejemplo n.º 9
0
Archivo: usb.c Proyecto: comex/libogc
static s32 __usb_bulk_messageCB(s32 result,void *usrdata)
{
	ioctlv *vec = NULL;
	struct _usb_cb *msgcb = (struct _usb_cb*)usrdata;

	if(msgcb==NULL) return IPC_EINVAL;
	
	if(msgcb->cb!=NULL) msgcb->cb(result,msgcb->usrdata);

	vec = msgcb->vec;
	if(vec==NULL) return IPC_EINVAL;

	if(vec[0].data!=NULL) iosFree(hId,vec[0].data);
	if(vec[1].data!=NULL) iosFree(hId,vec[1].data);

	iosFree(hId,vec);
	iosFree(hId,msgcb);

	return IPC_OK;
}
Ejemplo n.º 10
0
Archivo: usb.c Proyecto: comex/libogc
static s32 __usb_device_notificationCB(s32 result,void *usrdata)
{
	ioctlv *vec = NULL;
	struct _usb_cb *msgcb = (struct _usb_cb*)usrdata;

	if(msgcb==NULL) return IPC_EINVAL;

	if(msgcb->cb!=NULL) msgcb->cb(result,msgcb->usrdata);

	if(msgcb->fd>=0) IOS_Close(msgcb->fd);

	vec = msgcb->vec;
	if(vec==NULL) return IPC_EINVAL;

	if(vec[0].data!=NULL) iosFree(hId,vec[0].data);
	if(vec[1].data!=NULL) iosFree(hId,vec[1].data);

	iosFree(hId,vec);
	iosFree(hId,msgcb);

	return IPC_OK;
}
Ejemplo n.º 11
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_GetDeviceDescription(s32 fd,usb_devdesc *devdesc)
{
	s32 ret;
	usb_devdesc *p;
	
	p = iosAlloc(hId,USB_DT_DEVICE_SIZE);
	if(p==NULL) return IPC_ENOMEM;

	ret = __usb_control_message(fd,USB_ENDPOINT_IN,USB_REQ_GETDESCRIPTOR,(USB_DT_DEVICE<<8),0,USB_DT_DEVICE_SIZE,p,NULL,NULL);
	if(ret>=0) memcpy(devdesc,p,USB_DT_DEVICE_SIZE);
	devdesc->configurations = NULL;

	if(p!=NULL) iosFree(hId,p);
	return ret;
}
Ejemplo n.º 12
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_GetConfiguration(s32 fd, u8 *configuration)
{
	u8 *_configuration;
	s32 retval;

	_configuration = iosAlloc(hId, 1);
	if(_configuration == NULL)
		return IPC_ENOMEM;

	retval = __usb_control_message(fd, (USB_CTRLTYPE_DIR_DEVICE2HOST | USB_CTRLTYPE_TYPE_STANDARD | USB_CTRLTYPE_REC_DEVICE), USB_REQ_GETCONFIG, 0, 0, 1, _configuration, NULL, NULL);
	if(retval >= 0)
		*configuration = *_configuration;
	iosFree(hId, _configuration);

	return retval;
}
Ejemplo n.º 13
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_OpenDevice(const char *device,u16 vid,u16 pid,s32 *fd)
{
	s32 _fd = -1;
	s32 ret = USB_OK;
	char *devicepath = NULL;

	devicepath = iosAlloc(hId,USB_MAXPATH);
	if(devicepath==NULL) return IPC_ENOMEM;

	snprintf(devicepath,USB_MAXPATH,"/dev/usb/%s/%x/%x",device,vid,pid);

	_fd = IOS_Open(devicepath,0);
	if(_fd<0) ret = _fd;

	*fd = _fd;

	if(devicepath!=NULL) iosFree(hId,devicepath);
	return ret;
}
Ejemplo n.º 14
0
Archivo: usb.c Proyecto: comex/libogc
s32 USB_GetDescriptors(s32 fd, usb_devdesc *udd)
{
	u8 *buffer = NULL;
	u8 *ptr = NULL;
	usb_configurationdesc *ucd = NULL;
	usb_interfacedesc *uid = NULL;
	usb_endpointdesc *ued = NULL;
	s32 retval = 0;
	u32 iConf, iInterface, iEndpoint;

	buffer = iosAlloc(hId, sizeof(*udd));
	if(buffer == NULL)
	{
		retval = IPC_ENOHEAP;
		goto free_and_error;
	}

	retval = __usb_getdesc(fd, buffer, USB_DT_DEVICE, 0, USB_DT_DEVICE_SIZE);
	if(retval < 0)
		goto free_and_error;
	memcpy(udd, buffer, USB_DT_DEVICE_SIZE);
	iosFree(hId, buffer);

	udd->bcdUSB = bswap16(udd->bcdUSB);
	udd->idVendor = bswap16(udd->idVendor);
	udd->idProduct = bswap16(udd->idProduct);
	udd->bcdDevice = bswap16(udd->bcdDevice);

	udd->configurations = calloc(udd->bNumConfigurations, sizeof(*udd->configurations));
	if(udd->configurations == NULL)
	{
		retval = IPC_ENOMEM;
		goto free_and_error;
	}
	for(iConf = 0; iConf < udd->bNumConfigurations; iConf++)
	{
		buffer = iosAlloc(hId, USB_DT_CONFIG_SIZE);
		if(buffer == NULL)
		{
			retval = IPC_ENOHEAP;
			goto free_and_error;
		}

		retval = __usb_getdesc(fd, buffer, USB_DT_CONFIG, iConf, USB_DT_CONFIG_SIZE);
		ucd = &udd->configurations[iConf];
		memcpy(ucd, buffer, USB_DT_CONFIG_SIZE);
		iosFree(hId, buffer);

		ucd->wTotalLength = bswap16(ucd->wTotalLength);
		buffer = iosAlloc(hId, ucd->wTotalLength);
		if(buffer == NULL)
		{
			retval = IPC_ENOHEAP;
			goto free_and_error;
		}

		retval = __usb_getdesc(fd, buffer, USB_DT_CONFIG, iConf, ucd->wTotalLength);
		if(retval < 0)
			goto free_and_error;

		ptr = buffer;
		ptr += ucd->bLength;

		retval = IPC_ENOMEM;
		ucd->interfaces = calloc(ucd->bNumInterfaces, sizeof(*ucd->interfaces));
		if(ucd->interfaces == NULL)
			goto free_and_error;
		for(iInterface = 0; iInterface < ucd->bNumInterfaces; iInterface++)
		{
			uid = &ucd->interfaces[iInterface];
			memcpy(uid, ptr, USB_DT_INTERFACE_SIZE);
			ptr += uid->bLength;

			uid->endpoints = calloc(uid->bNumEndpoints, sizeof(*uid->endpoints));
			if(uid->endpoints == NULL)
				goto free_and_error;
			for(iEndpoint = 0; iEndpoint < uid->bNumEndpoints; iEndpoint++)
			{
				ued = &uid->endpoints[iEndpoint];
				memcpy(ued, ptr, USB_DT_ENDPOINT_SIZE);
				ptr += ued->bLength;
				ued->wMaxPacketSize = bswap16(ued->wMaxPacketSize);
			}
		}
		iosFree(hId, buffer);
		buffer = NULL;
	}
	retval = IPC_OK;

free_and_error:
	if(buffer != NULL)
		iosFree(hId, buffer);
	if(retval < 0)
		USB_FreeDescriptors(udd);
	return retval;
}
Ejemplo n.º 15
0
Archivo: usb.c Proyecto: comex/libogc
static inline s32 __usb_control_message(s32 fd,u8 bmRequestType,u8 bmRequest,u16 wValue,u16 wIndex,u16 wLength,void *rpData,usbcallback cb,void *usrdata)
{
	s32 ret = IPC_ENOMEM;
	u8 *pRqType = NULL;
	u8 *pRq = NULL;
	u8 *pNull = NULL;
	u16 *pValue = NULL;
	u16 *pIndex = NULL;
	u16 *pLength = NULL;
	ioctlv *vec = NULL;
	struct _usb_cb *msgcb = NULL;

	if(((s32)rpData%32)!=0) return IPC_EINVAL;
	if(wLength && !rpData) return IPC_EINVAL;
	if(!wLength && rpData) return IPC_EINVAL;

	vec = iosAlloc(hId,sizeof(ioctlv)*7);
	if(vec==NULL) return IPC_ENOMEM;

	pRqType = iosAlloc(hId,32);
	if(pRqType==NULL) goto done;
	*pRqType = bmRequestType;

	pRq = iosAlloc(hId,32);
	if(pRq==NULL) goto done;
	*pRq = bmRequest;

	pValue = iosAlloc(hId,32);
	if(pValue==NULL) goto done;
	*pValue = bswap16(wValue);

	pIndex = iosAlloc(hId,32);
	if(pIndex==NULL) goto done;
	*pIndex = bswap16(wIndex);

	pLength = iosAlloc(hId,32);
	if(pLength==NULL) goto done;
	*pLength = bswap16(wLength);

	pNull = iosAlloc(hId,32);
	if(pNull==NULL) goto done;
	*pNull = 0;

	vec[0].data = pRqType;
	vec[0].len = sizeof(u8);
	vec[1].data = pRq;
	vec[1].len = sizeof(u8);
	vec[2].data = pValue;
	vec[2].len = sizeof(u16);
	vec[3].data = pIndex;
	vec[3].len = sizeof(u16);
	vec[4].data = pLength;
	vec[4].len = sizeof(u16);
	vec[5].data = pNull;
	vec[5].len = sizeof(u8);
	vec[6].data = rpData;
	vec[6].len = wLength;

	if(cb==NULL)
		ret = IOS_Ioctlv(fd,USB_IOCTL_CTRLMSG,6,1,vec);
	else {
		msgcb = iosAlloc(hId,sizeof(struct _usb_cb));
		if(msgcb==NULL) goto done;

		msgcb->fd = -1;
		msgcb->cb = cb;
		msgcb->usrdata = usrdata;
		msgcb->vec = vec;
		return IOS_IoctlvAsync(fd,USB_IOCTL_CTRLMSG,6,1,vec,__usb_control_messageCB,msgcb);
	}

done:
	if(pNull!=NULL) iosFree(hId,pNull);
	if(pLength!=NULL) iosFree(hId,pLength);
	if(pIndex!=NULL) iosFree(hId,pIndex);
	if(pValue!=NULL) iosFree(hId,pValue);
	if(pRq!=NULL) iosFree(hId,pRq);
	if(pRqType!=NULL) iosFree(hId,pRqType);
	if(vec!=NULL) iosFree(hId,vec);

	return ret;
}
Ejemplo n.º 16
0
s32 IOS_GetPreferredVersion()
{
	int ver = IOS_EBADVERSION;
	s32 res;
	u32 count;
	u64 *titles;
	u32 tmd_size;
	u32 i;
	u32 a,b;

	res = __IOS_InitHeap();
	if(res<0) return res;

	res = ES_GetNumTitles(&count);
	if(res < 0) {
#ifdef DEBUG_IOS
		printf(" GetNumTitles failed: %d\n",res);
#endif
		return res;
	}
#ifdef DEBUG_IOS
	printf(" %d titles on card:\n",count);
#endif
	titles = iosAlloc(__ios_hid, sizeof(u64)*count);
	if(!titles) {
		printf(" iosAlloc titles failed\n");
		return -1;
	}
	res = ES_GetTitles(titles, count);
	if(res < 0) {
#ifdef DEBUG_IOS
		printf(" GetTitles failed: %d\n",res);
#endif
		iosFree(__ios_hid, titles);
		return res;
	}
	
	u32 *tmdbuffer = memalign(32, MAX_SIGNED_TMD_SIZE);

	if(!tmdbuffer)
	{
		iosFree(__ios_hid, titles);
		return -1;
	}

	for(i=0; i<count; i++) {
		a = titles[i]>>32;
		b = titles[i]&0xFFFFFFFF;
		if(a != 1) continue;
		if(b < IOS_MIN_VERSION) continue;
		if(b > IOS_MAX_VERSION) continue;
		
		if (ES_GetStoredTMDSize(titles[i], &tmd_size) < 0)
			continue;

		if (tmd_size < 0 || tmd_size > 4096)
			continue;

		if(ES_GetStoredTMD(titles[i], (signed_blob *)tmdbuffer, tmd_size) < 0)
			continue;

		if (!tmdbuffer[1] && !tmdbuffer[2])
			continue;
		
		if((((s32)b) > ((s32)ver) && ver != 58) || b == 58) ver = b;
	}
#ifdef DEBUG_IOS
	printf(" Preferred verson: %d\n",ver);
#endif
	iosFree(__ios_hid, titles);
	free(tmdbuffer);
	return ver;
}