/** ioman close handler
@param file: Pointer to an ioman file structure
@returns 0 on success, else -1
*/
int devfs_close(iop_file_t *file)
{
devfs_device_t *dev;
ioman_data_t *data = (ioman_data_t *) file->privdata;
int loop;
if((data) && (data->hDev != INVALID_HDEV)) /* Invalid HDEV is a dir listing */
{
dev = data->dev;
if(dev != NULL)
{
if(dev->subdevs[data->subdev].open_refcount > 0)
{
dev->subdevs[data->subdev].open_refcount--;
}
if(dev->open_refcount > 0)
{
dev->open_refcount--;
}
loop = 0;
while((loop < MAX_OPENFILES)
&& (dev->subdevs[data->subdev].open_files[loop] != data))
{
loop++;
}
if(loop != MAX_OPENFILES)
{
dev->subdevs[data->subdev].open_files[loop] = NULL;
}
else
{
M_PRINTF("close: Could not find opened file\n");
}
M_PRINTF("close: Closing device %s subdev %d\n", dev->node.name, data->subdev);
FreeSysMemory(data);
}
else
{
FreeSysMemory(data);
file->privdata = NULL;
return -1;
}
}
else
{
return -1;
}
return 0;
}
void free(void *ptr){
int flags;
CpuSuspendIntr(&flags);
FreeSysMemory(ptr);
CpuResumeIntr(flags);
}
void free(void *buffer){
int OldState;
CpuSuspendIntr(&OldState);
FreeSysMemory(buffer);
CpuResumeIntr(OldState);
}
void apaFreeMem(void *ptr)
{
int intrStat;
CpuSuspendIntr(&intrStat);
FreeSysMemory(ptr);
CpuResumeIntr(intrStat);
}
/** Creates a new device based on the node data supplied
@param node: Pointer to a ::devfs_node_t structure
@returns A new device structure or NULL on error.
*/
devfs_device_t *devfs_create_device(const devfs_node_t *node)
{
devfs_device_t *dev;
if((node == NULL) || (node->name == NULL))
{
return NULL;
}
dev = AllocSysMemory(ALLOC_FIRST, sizeof(devfs_device_t), NULL);
if(dev == NULL)
{
printf("create_device: Alloc Failed\n");
return NULL;
}
memset(dev, 0, sizeof(devfs_device_t));
memcpy(&dev->node, node, sizeof(devfs_node_t));
if(dev->node.name != NULL)
{
dev->node.name = AllocSysMemory(ALLOC_FIRST, strlen(node->name) + 1, NULL);
if(dev->node.name == NULL)
{
FreeSysMemory(dev);
return NULL;
}
memcpy(dev->node.name, node->name, strlen(node->name) + 1);
}
if(dev->node.desc != NULL)
{
dev->node.desc = AllocSysMemory(ALLOC_FIRST, strlen(node->desc) + 1, NULL);
if(dev->node.name == NULL)
{
FreeSysMemory(dev->node.name);
FreeSysMemory(dev);
return NULL;
}
memcpy(dev->node.desc, node->desc, strlen(node->desc) + 1);
}
return dev;
}
int shutdown()
{
if (alloc_sema >= 0) {
DeleteSema(alloc_sema);
}
FreeSysMemory(heap_start);
return 0;
}
int devfs_delete_device(devfs_device_t *dev)
{
if(dev != NULL)
{
if(dev->node.name)
{
FreeSysMemory(dev->node.name);
}
if(dev->node.desc)
{
FreeSysMemory(dev->node.desc);
}
FreeSysMemory(dev);
}
return 0;
}
/** ioman ioctl2 handler
@param file: Pointer to an ioman file structure
@param cmd: ioctl command number
@param args: Pointer a buffer containing command arguments
@param arglen: Length of args buffer
@param buf: Pointer to a return buffer
@param buflen: Length of buf
@returns >= 0 Depends on command, -1 on error
*/
int devfs_ioctl2(iop_file_t *file, int cmd, void *args, unsigned int arglen, void *buf, unsigned int buflen)
{
devfs_device_t *dev;
ioman_data_t *data = (ioman_data_t *) file->privdata;
data = file->privdata;
if((data) && (data->hDev != INVALID_HDEV))
{
dev = data->dev;
if(dev == NULL) /* Device has been closed from under us */
{
/* Delete data to try and prevent a memory leak */
FreeSysMemory(data);
file->privdata = NULL;
return -1;
}
if((cmd == DEVFS_IOCTL_GETDESC) && (buf) && (buflen >= DEVFS_MAX_DESC_LENGTH))
{
if(dev->node.desc)
{
strncpy(buf, dev->node.desc, buflen-1);
*((u8 *) (buf + buflen)) = 0;
return strlen(buf);
}
return 0;
}
if(dev->node.ioctl != NULL)
{
devfs_info_t dev_info;
dev_info.data = dev->subdevs[data->subdev].data;
dev_info.subdev = data->subdev;
dev_info.mode = data->mode;
dev_info.loc = data->loc;
return dev->node.ioctl(&dev_info, DEVFS_IOCTL_TYPE_2, cmd, args, arglen, buf, buflen);
}
}
return -1;
}
void* filexioRpc_SetRWBufferSize(void *sbuff)
{
int OldState;
if(rwbuf!=NULL){
CpuSuspendIntr(&OldState);
FreeSysMemory(rwbuf);
CpuResumeIntr(OldState);
}
RWBufferSize=((struct fxio_rwbuff*)sbuff)->size;
CpuSuspendIntr(&OldState);
rwbuf=AllocSysMemory(ALLOC_FIRST, RWBufferSize, NULL);
CpuResumeIntr(OldState);
((int*)sbuff)[0] = rwbuf!=NULL?0:-ENOMEM;
return sbuff;
}
/** ioman lseek64 handler
@param file: Pointer to an ioman file structure
@param loc: 64bit seek location
@param whence: Seek base
*/
int devfs_lseek64(iop_file_t *file, long long loc, int whence)
{
devfs_device_t *dev;
ioman_data_t *data = (ioman_data_t *) file->privdata;
//printf("devfs_lseek64 file=%p loc= whence=%d\n", file, whence);
data = file->privdata;
if((data) && (data->hDev != INVALID_HDEV))
{
dev = data->dev;
if(dev == NULL) /* Device has been closed from under us */
{
/* Delete data to try and prevent a memory leak */
FreeSysMemory(data);
file->privdata = NULL;
return -1;
}
switch(whence)
{
case SEEK_SET: if(loc > 0)
data->loc.loc64 = (u64) loc;
break;
case SEEK_CUR: if(loc > 0)
data->loc.loc64 += (u64) loc;
else if(((s64) -loc) < data->loc.loc64)
data->loc.loc64 += (s64) loc;
break;
case SEEK_END: if((loc > 0) && (dev->subdevs[data->subdev].extent.loc64 >= (u64) loc))
data->loc.loc64 = dev->subdevs[data->subdev].extent.loc64 - (u64) loc;
break;
default: return -1;
}
}
else
{
return -1;
}
return data->loc.loc32[0];
}
int ps2kbd_disconnect(int devId)
{
int devLoop;
//printf("PS2Kbd_disconnect devId %d\n", devId);
for(devLoop = 0; devLoop < PS2KBD_MAXDEV; devLoop++)
{
if((devices[devLoop]) && (devices[devLoop]->devId == devId))
{
dev_count--;
FreeSysMemory(devices[devLoop]);
devices[devLoop] = NULL;
printf("PS2KBD: Disconnected device\n");
break;
}
}
return 0;
}
/** called after a camera is accepted */
void PS2CamInitializeNewDevice(CAMERA_DEVICE *cam)
{
unsigned char *temp_str;
UsbDeviceDescriptor *d;
PS2CamSetDeviceConfiguration(cam,1);
camStopStream(cam);
PS2CamSelectInterface(cam,0,0);
camStartStream(cam);
PS2CamSetDeviceDefaults(cam);
/* camStopStream(dev);
setReg16(dev, 0x30, 384);
camStartStream(dev);
*/
camStopStream(cam);
PS2CamSelectInterface(cam,0,EYETOY_ALTERNATE_SIZE_384);
camStartStream(cam);
cam->status = CAM_STATUS_CONNECTEDREADY;
// connected message (alloc som mem and get device string then print it and free the mem we alloced)
d = UsbGetDeviceStaticDescriptor(cam->device_id, NULL, USB_DT_DEVICE);
temp_str = AllocSysMemory(0, 128, 0);
temp_str[0]=0x00;
PS2CamGetDeviceSring(cam, d->iProduct, (char *)temp_str, 128);
printf("cam initialized(%s)\n",temp_str);
FreeSysMemory(temp_str);
DeleteThread(maintain_thread);
return;
}
/** ioman read handler
@param file: Pointer to an ioman file structure
@param buf: Buffer to read data to
@param len: Length of data to read
@returns Length of data read. 0 on eof or file pointer out of range. -1 on error.
*/
int devfs_read(iop_file_t *file, void *buf, int len)
{
devfs_device_t *dev;
ioman_data_t *data = (ioman_data_t *) file->privdata;
//printf("devfs_read file=%p buf=%p len=%d\n", file, buf, len);
data = file->privdata;
if((data) && (data->hDev != INVALID_HDEV))
{
dev = data->dev;
if(dev == NULL) /* Device has been closed from under us */
{
/* Delete data to try and prevent a memory leak */
FreeSysMemory(data);
file->privdata = NULL;
return -1;
}
if((dev->node.read != NULL)
&& (dev->subdevs[data->subdev].mode & DEVFS_MODE_R))
{
devfs_info_t dev_info;
int bytes_read;
dev_info.data = dev->subdevs[data->subdev].data;
dev_info.subdev = data->subdev;
dev_info.mode = data->mode;
dev_info.loc = data->loc;
bytes_read = dev->node.read(&dev_info, buf, len);
if(bytes_read > 0)
{
data->loc.loc64 += (u64) bytes_read;
}
return bytes_read;
}
}
return -1;
}
void usb_getstring(int endp, int index, char *desc)
{
u8 *data;
string_descriptor *str;
int ret;
data = (u8 *) AllocSysMemory(0, sizeof(string_descriptor), NULL);
str = (string_descriptor *) data;
if(data != NULL)
{
str->desc = desc;
ret = UsbControlTransfer(endp, 0x80, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) | index,
0, sizeof(string_descriptor) - 4, data, ps2kbd_getstring_set, data);
if(ret != USB_RC_OK)
{
printf("PS2KBD: Error sending string descriptor request\n");
FreeSysMemory(data);
}
}
}
/** ioman ioctl handler
@param file: Pointer to an ioman file structure
@param cmd: ioctl command number
@param args: Pointer to a buffer containing any arguments
@returns >= 0 Defined by the type of command, -1 on error
*/
int devfs_ioctl(iop_file_t *file, unsigned long cmd, void *args)
{
devfs_device_t *dev;
ioman_data_t *data = (ioman_data_t *) file->privdata;
if(cmd == DEVFS_IOCTL_GETDESC)
{
return -1; /* ioctl cannot support this call */
}
data = file->privdata;
if((data) && (data->hDev != INVALID_HDEV))
{
dev = data->dev;
if(dev == NULL) /* Device has been closed from under us */
{
/* Delete data to try and prevent a memory leak */
FreeSysMemory(data);
file->privdata = NULL;
return -1;
}
if(dev->node.ioctl != NULL)
{
devfs_info_t dev_info;
dev_info.data = dev->subdevs[data->subdev].data;
dev_info.subdev = data->subdev;
dev_info.mode = data->mode;
dev_info.loc = data->loc;
return dev->node.ioctl(&dev_info, DEVFS_IOCTL_TYPE_1, cmd, args, 0, NULL, 0);
}
}
return -1;
}
void ps2kbd_getstring_set(int resultCode, int bytes, void *arg)
{
UsbStringDescriptor *str = (UsbStringDescriptor *) arg;
string_descriptor *strBuf = (string_descriptor *) arg;
char string[50];
int strLoop;
/* printf("=========getstring=========\n"); */
/* printf("PS2KEYBOARD: GET_DESCRIPTOR res %d, bytes %d, arg %p\n", resultCode, bytes, arg); */
if(resultCode == USB_RC_OK)
{
memset(string, 0, 50);
for(strLoop = 0; strLoop < ((bytes - 2) / 2); strLoop++)
{
string[strLoop] = str->wData[strLoop] & 0xFF;
}
printf("PS2KBD %s: %s\n", strBuf->desc, string);
}
FreeSysMemory(arg);
}
int devfs_open(iop_file_t *file, const char *name, int mode, int unused)
#endif
{
devfs_device_t *dev;
int loop;
int fn_offset = 0;
//printf("devfs_open file=%p name=%s mode=%d\n", file, name, mode);
if(name == NULL)
{
M_PRINTF("open: Name is NULL\n");
return -1;
}
if((name[0] == '\\') || (name[0] == '/'))
{
fn_offset = 1;
}
dev = devfs_find_devicename(name + fn_offset);
if(dev != NULL)
{
char *endp;
int subdev;
int name_len;
name_len = strlen(dev->node.name);
if(name_len == strlen(name)) /* If this is has not got a subnumber */
{
M_PRINTF("open: No subdevice number in filename %s\n", name);
return -1;
}
subdev = strtoul(&name[name_len + fn_offset], &endp, 10);
if(((subdev == 0) && (name[name_len + fn_offset] != '0'))
|| (subdev >= DEVFS_MAX_SUBDEVS))
/* Invalid number */
{
M_PRINTF("open: Invalid subdev number %d\n", subdev);
return -1;
}
if(*endp)
/* Extra charactes after filename */
{
M_PRINTF("open: Invalid filename\n");
return -1;
}
if(!dev->subdevs[subdev].valid)
/* No subdev */
{
M_PRINTF("open: No subdev registered\n");
return -1;
}
if((dev->subdevs[subdev].mode & DEVFS_MODE_EX)
&& (dev->subdevs[subdev].open_refcount > 0))
/* Already opened in exclusive mode */
{
M_PRINTF("open: Exclusive subdevice already opened\n");
return -1;
}
if(dev->subdevs[subdev].open_refcount == MAX_OPENFILES)
{
M_PRINTF("open: Reached open file limit for sub device\n");
}
/* Tried to open read but not allowed */
if(((mode & O_RDONLY) || ((mode & O_RDWR) == O_RDWR))
&& !(dev->subdevs[subdev].mode & DEVFS_MODE_R))
{
M_PRINTF("open: Read mode requested but not permitted\n");
return -1;
}
if(((mode & O_WRONLY) || ((mode & O_RDWR) == O_RDWR))
&& !(dev->subdevs[subdev].mode & DEVFS_MODE_W))
{
M_PRINTF("open: Write mode requested but not permitted\n");
return -1;
}
file->privdata = AllocSysMemory(ALLOC_FIRST, sizeof(ioman_data_t), NULL);
if(file->privdata == NULL)
{
M_PRINTF("open: Allocation failure\n");
return -1;
}
((ioman_data_t *) file->privdata)->hDev = dev->hDev;
((ioman_data_t *) file->privdata)->subdev = subdev;
((ioman_data_t *) file->privdata)->loc.loc64 = 0;
((ioman_data_t *) file->privdata)->dev = dev;
((ioman_data_t *) file->privdata)->mode = mode;
dev->subdevs[subdev].open_refcount++;
loop = 0;
while((loop < MAX_OPENFILES) && (dev->subdevs[subdev].open_files[loop]))
{
loop++;
}
if(loop == MAX_OPENFILES)
{
FreeSysMemory(file->privdata);
M_PRINTF("open: Inconsistency between number of open files and available slot\n");
return -1;
}
dev->subdevs[subdev].open_files[loop] = file->privdata;
dev->open_refcount++;
M_PRINTF("open: Opened device %s subdev %d\n", dev->node.name, subdev);
}
else
{
M_PRINTF("open: Couldn't find the device\n");
return -1;
}
return 0;
}
