void usb_periodic()
{
// call ever registered driver
- usb_driver *drv;
- element *iterator = core.drivers->head;
+ struct usb_driver *drv;
+ struct element *iterator = core.drivers->head;
while (iterator != NULL) {
- drv = (usb_driver *) iterator->data;
+ drv = (struct usb_driver *) iterator->data;
drv->check();
iterator = iterator->next;
}
* for the core. usb_add_device expected that
* the device answers to address zero.
*/
-usb_device *usb_add_device()
+struct usb_device *usb_add_device()
{
- usb_device *dev = (usb_device *) malloc(sizeof(usb_device));
+ struct usb_device *dev = (struct usb_device *) malloc(sizeof(struct usb_device));
dev->address = 0;
/* send at first time only 8 bytes */
dev->bMaxPacketSize0 = 8;
* Find currently detached device and remove
* data structures
*/
-u8 usb_remove_device(usb_device * dev)
+u8 usb_remove_device(struct usb_device * dev)
{
// FIXME!!!! dieser quatsch ist nur temporaer
free(core.devices->head);
/**
* Register new driver at usb stack.
*/
-u8 usb_register_driver(usb_driver * dev)
+u8 usb_register_driver(struct usb_driver * dev)
{
/* add driver to driver list */
- element *tmp = (element *) malloc(sizeof(element));
+ struct element *tmp = (struct element *) malloc(sizeof(struct element));
tmp->data = (void *) dev;
tmp->next = NULL;
list_add_tail(core.drivers, tmp);
void usb_probe_driver()
{
// call ever registered driver
- usb_driver *drv;
- element *iterator = core.drivers->head;
+ struct usb_driver *drv;
+ struct element *iterator = core.drivers->head;
while (iterator != NULL) {
- drv = (usb_driver *) iterator->data;
+ drv = (struct usb_driver *) iterator->data;
drv->probe();
iterator = iterator->next;
}
/**
* Not implemented.
*/
-usb_irp *usb_get_irp()
+struct usb_irp *usb_get_irp()
{
return 0;
}
/**
* Not implemented.
*/
-u8 usb_remove_irp(usb_irp * irp)
+u8 usb_remove_irp(struct usb_irp *irp)
{
return 1;
* In the usbstack they are transported with the
* usb_transfer_descriptor data structure.
*/
-u16 usb_submit_irp(usb_irp *irp)
+u16 usb_submit_irp(struct usb_irp *irp)
{
- usb_transfer_descriptor *td;
+ struct usb_transfer_descriptor *td;
u8 runloop = 1;
u16 restlength = irp->len;
u8 *td_buf_ptr = irp->buffer;
/**
* Create a transfer descriptor with an parent irp.
*/
-usb_transfer_descriptor *usb_create_transfer_descriptor(usb_irp * irp)
+struct usb_transfer_descriptor *usb_create_transfer_descriptor(struct usb_irp * irp)
{
- usb_transfer_descriptor *td =
- (usb_transfer_descriptor *) malloc(sizeof(usb_transfer_descriptor));
+ struct usb_transfer_descriptor *td =
+ (struct usb_transfer_descriptor *) malloc(sizeof(struct usb_transfer_descriptor));
td->devaddress = irp->dev->address;
td->endpoint = irp->endpoint;
udelay(1000);
}
-/**
- * Main datastructure of the usbstack, which have to be instanced
- * in the main application.
- */
-
-typedef struct usb_device_t usb_device;
-struct usb_device_t {
+struct usb_device {
u8 address;
u8 fullspeed;
u8 epSize[16];
u8 epTogl[16];
- usb_device *next;
+ struct usb_conf *conf;
+ struct usb_device *next;
};
+struct usb_conf {
+ u8 bLength;
+ u8 bDescriptorType;
+ u16 wTotalLength;
+ u8 bNumInterfaces;
+ u8 bConfigurationValue;
+ u8 iConfiguration;
+ u8 bmAttributes;
+ u8 bMaxPower;
+};
-typedef struct usb_endpoint_t usb_endpoint;
-struct usb_endpoint_t {
+struct usb_endpoint {
u8 type;
u8 size;
u8 togl;
- usb_endpoint *next;
+ struct usb_endpoint *next;
};
-
-
-
-typedef struct usb_transfer_descriptor_ep_t usb_transfer_descriptor_ep;
-struct usb_transfer_descriptor_ep_t {
- usb_transfer_descriptor_ep *next;
+struct usb_transfer_descriptor_ep {
+ struct usb_transfer_descriptor_ep *next;
u8 device_address;
u8 endpoint;
- struct usb_transfer_descriptor_t *start;
+ struct usb_transfer_descriptor *start;
};
/**
* USB Driver data structure
*/
-typedef struct usb_driver_t usb_driver;
-struct usb_driver_t {
+struct usb_driver {
char* name;
void (*probe)(void);
void (*check)(void);
void * data;
- usb_driver *next;
+ struct usb_driver *next;
};
* I/O Request Block
*/
-typedef struct usb_irp_t usb_irp;
-struct usb_irp_t {
- usb_device * dev;
- u8 endpoint; /* ep -> bit 7 is for direction 1=from dev to host */
+struct usb_irp {
+ struct usb_device *dev;
+ /* ep -> bit 7 is for direction 1=from dev to host */
+ u8 endpoint;
u8 epsize;
- u8 type; /* control, interrupt, bulk or isochron */
+ /* control, interrupt, bulk or isochron */
+ u8 type;
u8 *buffer;
u16 len;
/**
* usb transfer descriptor
*/
-typedef struct usb_transfer_descriptor_t usb_transfer_descriptor;
-struct usb_transfer_descriptor_t {
+struct usb_transfer_descriptor {
u8 devaddress;
u8 endpoint;
u16 actlen;
u8 state;
- usb_transfer_descriptor *next;
+ struct usb_transfer_descriptor *next;
u8 maxp;
};
-//typedef struct usb_core_t usb_core;
-struct usb_core_t {
+struct usb_core {
u8 nextaddress;
void (*stdout)(char * arg);
// driver list
- list * drivers;
- list * devices;
+ struct list *drivers;
+ struct list *devices;
} core;
void usb_init();
u8 usb_next_address();
-usb_device * usb_add_device();
-u8 usb_remove_device(usb_device *dev);
-u8 usb_register_driver(usb_driver *driver);
+struct usb_device *usb_add_device();
+u8 usb_remove_device(struct usb_device *dev);
+u8 usb_register_driver(struct usb_driver *driver);
void usb_probe_driver();
-usb_irp * usb_get_irp();
-u8 usb_remove_irp(usb_irp *irp);
-u16 usb_submit_irp(usb_irp *irp);
+struct usb_irp *usb_get_irp();
+u8 usb_remove_irp(struct usb_irp *irp);
+u16 usb_submit_irp(struct usb_irp *irp);
-usb_transfer_descriptor * usb_create_transfer_descriptor(usb_irp *irp);
+struct usb_transfer_descriptor *usb_create_transfer_descriptor(struct usb_irp *irp);
#define USB_IRP_WAITING 1
/**
* Open a device with verndor- and product-id for a communication.
*/
-usb_device *usb_open(u32 vendor_id, u32 product_id)
+struct usb_device *usb_open(u32 vendor_id, u32 product_id)
{
- usb_device* dev;
- element * iterator = core.devices->head;
+ struct usb_device* dev;
+ struct element * iterator = core.devices->head;
while(iterator != NULL) {
- dev = (usb_device*)iterator->data;
+ dev = (struct usb_device*)iterator->data;
if(dev->idVendor==vendor_id&&dev->idProduct==product_id)
return dev;
/**
* Open a device with an class code for a communication.
*/
-usb_device *usb_open_class(u8 class)
+struct usb_device *usb_open_class(u8 class)
{
- usb_device* dev;
- element * iterator = core.devices->head;
+ struct usb_device* dev;
+ struct element * iterator = core.devices->head;
while(iterator != NULL) {
- dev = (usb_device*)iterator->data;
+ dev = (struct usb_device*)iterator->data;
if(dev->bDeviceClass==class)
return dev;
/* Close device after a communication.
*/
-s8 usb_close(usb_device *dev)
+s8 usb_close(struct usb_device *dev)
{
return 0;
}
-s8 usb_reset(usb_device *dev)
+s8 usb_reset(struct usb_device *dev)
{
/**
* Create a control transfer.
*/
-s8 usb_control_msg(usb_device *dev, u8 requesttype, u8 request,
+s8 usb_control_msg(struct usb_device *dev, u8 requesttype, u8 request,
u16 value, u16 index, u16 length, u8 *buf, u16 timeout)
{
- usb_irp *irp = (usb_irp*)malloc(sizeof(usb_irp));
+ struct usb_irp *irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
irp->dev = dev;
irp->endpoint = 0;
}
-s8 usb_get_string(usb_device *dev, u8 index, u8 langid, u8 *buf, u8 buflen)
+s8 usb_get_string(struct usb_device *dev, u8 index, u8 langid, u8 *buf, u8 buflen)
{
return 0;
}
-char *usb_get_string_simple(usb_device *dev, u8 index, u8 *buf, u8 size)
+char *usb_get_string_simple(struct usb_device *dev, u8 index, u8 *buf, u8 size)
{
if(size < 8) {
return (char*) -1;
return str;
}
-s8 usb_get_descriptor(usb_device *dev, u8 type, u8 index, u8 *buf, u8 size)
+s8 usb_get_descriptor(struct usb_device *dev, u8 type, u8 index, u8 *buf, u8 size)
{
usb_control_msg(dev, 0x80, GET_DESCRIPTOR, (type << 8) | index, 0, size, buf, 0);
return 0;
/* ask first 8 bytes of device descriptor with this special
* GET Descriptor Request, when device address = 0
*/
-s8 usb_get_dev_desc_simple(usb_device *dev, u8 *buf, u8 size)
+s8 usb_get_dev_desc_simple(struct usb_device *dev, u8 *buf, u8 size)
{
if(size < 8) {
return -1;
return 0;
}
-s8 usb_get_dev_desc(usb_device *dev, u8 *buf, u8 size)
+s8 usb_get_dev_desc(struct usb_device *dev, u8 *buf, u8 size)
{
if (size < 0x12 || usb_get_dev_desc_simple(dev, buf, size) < 0) {
return -1;
return 0;
}
-s8 usb_get_configuration(usb_device *dev, u8 index, u8 *buf, u8 size)
+s8 usb_get_configuration(struct usb_device *dev, u8 index, u8 *buf, u8 size)
{
if(size < 8) {
return -1;
return 0;
}
-s8 usb_set_address(usb_device *dev, u8 address)
+s8 usb_set_address(struct usb_device *dev, u8 address)
{
u8 buf[64];
usb_control_msg(dev, 0x00, SET_ADDRESS, address, 0, 0, buf, 0);
return 0;
}
-s8 usb_set_configuration(usb_device *dev, u8 configuration)
+s8 usb_set_configuration(struct usb_device *dev, u8 configuration)
{
return 0;
}
-s8 usb_set_altinterface(usb_device *dev, u8 alternate)
+s8 usb_set_altinterface(struct usb_device *dev, u8 alternate)
{
return 0;
/**
* Write to an a bulk endpoint.
*/
-s8 usb_bulk_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_bulk_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
- usb_irp * irp = (usb_irp*)malloc(sizeof(usb_irp));
+ struct usb_irp * irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
irp->dev = dev;
//irp->devaddress = dev->address;
/**
* Read from an bulk endpoint.
*/
-s8 usb_bulk_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_bulk_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
- usb_irp * irp = (usb_irp*)malloc(sizeof(usb_irp));
+ struct usb_irp * irp = (struct usb_irp*)malloc(sizeof(struct usb_irp));
//irp->devaddress = dev->address;
irp->dev = dev;
/**
* Write to an interrupt endpoint.
*/
-s8 usb_interrupt_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_interrupt_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
return 0;
/**
* Read from an interrupt endpoint.
*/
-s8 usb_interrupt_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_interrupt_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
return 0;
/**
* Write to an isochron endpoint.
*/
-s8 usb_isochron_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_isochron_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
return 0;
/**
* Read from an isochron endpoint.
*/
-s8 usb_isochron_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
+s8 usb_isochron_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout)
{
/******************* Device Operations **********************/
// use an own usb device
-usb_device * usb_open(u32 vendor_id, u32 product_id);
-usb_device * usb_open_class(u8 class);
+struct usb_device *usb_open(u32 vendor_id, u32 product_id);
+struct usb_device *usb_open_class(u8 class);
-s8 usb_close(usb_device *dev);
+s8 usb_close(struct usb_device *dev);
-s8 usb_get_device_descriptor(usb_device *dev, u8 *buf, u8 buflen);
-s8 usb_set_address(usb_device *dev, u8 address);
-s8 usb_set_configuration(usb_device *dev, u8 configuration);
-s8 usb_set_altinterface(usb_device *dev, u8 alternate);
+s8 usb_get_device_descriptor(struct usb_device *dev, u8 *buf, u8 buflen);
+s8 usb_set_address(struct usb_device *dev, u8 address);
+s8 usb_set_configuration(struct usb_device *dev, u8 configuration);
+s8 usb_set_altinterface(struct usb_device *dev, u8 alternate);
/**
* it is connected to. Returns 0 on success or < 0 on error.
*/
-s8 usb_reset(usb_device *dev);
+s8 usb_reset(struct usb_device *dev);
/******************* Control Transfer **********************/
-s8 usb_control_msg(usb_device *dev, u8 requesttype, u8 request, u16 value, u16 index, u16 length, u8 *buf, u16 timeout);
-s8 usb_get_string(usb_device *dev, u8 index, u8 langid, u8 *buf, u8 buflen);
-char *usb_get_string_simple(usb_device *dev, u8 index, u8 *buf, u8 size);
-s8 usb_get_dev_desc_simple(usb_device *dev, u8 *buf, u8 size);
-s8 usb_get_configuration(usb_device *dev, u8 index, u8 *buf, u8 size);
-s8 usb_get_dev_desc(usb_device *dev, u8 *buf, u8 size);
-s8 usb_get_descriptor(usb_device *dev, u8 type, u8 index, u8 *buf, u8 size);
+s8 usb_control_msg(struct usb_device *dev, u8 requesttype, u8 request, u16 value, u16 index, u16 length, u8 *buf, u16 timeout);
+s8 usb_get_string(struct usb_device *dev, u8 index, u8 langid, u8 *buf, u8 buflen);
+char *usb_get_string_simple(struct usb_device *dev, u8 index, u8 *buf, u8 size);
+s8 usb_get_dev_desc_simple(struct usb_device *dev, u8 *buf, u8 size);
+s8 usb_get_configuration(struct usb_device *dev, u8 index, u8 *buf, u8 size);
+s8 usb_get_dev_desc(struct usb_device *dev, u8 *buf, u8 size);
+s8 usb_get_descriptor(struct usb_device *dev, u8 type, u8 index, u8 *buf, u8 size);
/******************* Bulk Transfer **********************/
-s8 usb_bulk_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
-s8 usb_bulk_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_bulk_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_bulk_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
/******************* Interrupt Transfer **********************/
-s8 usb_u8errupt_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
-s8 usb_u8errupt_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_u8errupt_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_u8errupt_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
/******************* Isochron Transfer **********************/
-s8 usb_isochron_write(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
-s8 usb_isochron_read(usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_isochron_write(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
+s8 usb_isochron_read(struct usb_device *dev, u8 ep, u8 *buf, u8 size, u8 timeout);
#endif //_USB_H_
void usb_hub_check();
-usb_driver hub = {
+struct usb_driver hub = {
.name = "hub",
.probe = usb_hub_probe,
.check = usb_hub_check,
#endif
wait_ms(1000);
- usb_device * dev;
- dev = usb_open_class(HUB_CLASSCODE);
+ struct usb_device *dev = usb_open_class(HUB_CLASSCODE);
if(dev != NULL){
hub.data = (void*)dev; /* save handle */
#if DEBUG
}
-u8 usb_hub_get_hub_descriptor(usb_device *dev, char * buf)
+u8 usb_hub_get_hub_descriptor(struct usb_device *dev, char * buf)
{
return 0;
}
-u8 usb_hub_get_hub_status(usb_device *dev, char *buf)
+u8 usb_hub_get_hub_status(struct usb_device *dev, char *buf)
{
}
-u8 usb_hub_get_port_status(usb_device *dev, char *buf)
+u8 usb_hub_get_port_status(struct usb_device *dev, char *buf)
{
return 0;
}
-u8 usb_hub_clear_port_feature(usb_device *dev)
+u8 usb_hub_clear_port_feature(struct usb_device *dev)
{
return 0;
}
-u8 usb_hub_set_port_feature(usb_device *dev, u8 value)
+u8 usb_hub_set_port_feature(struct usb_device *dev, u8 value)
{
return 0;
}
-u8 usb_hub_clear_hub_feature(usb_device *dev)
+u8 usb_hub_clear_hub_feature(struct usb_device *dev)
{
return 0;
}
-u8 usb_hub_set_hub_feature(usb_device *dev)
+u8 usb_hub_set_hub_feature(struct usb_device *dev)
{
return 0;
}
-u8 usb_hub_set_hub_descriptor(usb_device *dev)
+u8 usb_hub_set_hub_descriptor(struct usb_device *dev)
{
return 0;
void usb_storage_probe();
void usb_storage_check();
-usb_device * massstorage[MAX_DEVICES];
+struct usb_device *massstorage[MAX_DEVICES];
u16 sectorsize[MAX_DEVICES];
u8 massstorage_in_use;
-usb_driver storage = {
+struct usb_driver storage = {
.name = "storage",
.probe = usb_storage_probe,
.check = usb_storage_check,
/* read interface descriptor for class code */
u8 buf[32];
- usb_device* dev;
- element * iterator = core.devices->head;
+ struct usb_device* dev;
+ struct element * iterator = core.devices->head;
while(iterator != NULL) {
- dev = (usb_device*)iterator->data;
+ dev = (struct usb_device*)iterator->data;
/* get interface descriptor */
usb_control_msg(dev, 0x80, GET_DESCRIPTOR,2, 0, 32, buf, 0);
/**
* Enqueue a transfer descriptor.
*/
-u8 hcdi_enqueue(const usb_transfer_descriptor *td);
+u8 hcdi_enqueue(const struct usb_transfer_descriptor *td);
/**
* Remove an transfer descriptor from transfer queue.
*/
-u8 hcdi_dequeue(usb_transfer_descriptor *td);
+u8 hcdi_dequeue(struct usb_transfer_descriptor *td);
void hcdi_fire(void);
}
#endif
-static void general_td_fill(struct general_td *dest, const usb_transfer_descriptor *src)
+static void general_td_fill(struct general_td *dest, const struct usb_transfer_descriptor *src)
{
if(src->actlen) {
dest->cbp = LE(virt_to_phys(src->buffer));
/**
* Enqueue a transfer descriptor.
*/
-u8 hcdi_enqueue(const usb_transfer_descriptor *td) {
+u8 hcdi_enqueue(const struct usb_transfer_descriptor *td) {
#ifdef _DU_OHCI_Q
printf("*()*()*()*()*()*()*() hcdi_enqueue(start)\n");
#endif
/**
* Remove an transfer descriptor from transfer queue.
*/
-u8 hcdi_dequeue(usb_transfer_descriptor *td) {
+u8 hcdi_dequeue(struct usb_transfer_descriptor *td) {
return 0;
}
#include "list.h"
#include "../../malloc.h"
-list* list_create()
+struct list* list_create()
{
- list *l = (list*)malloc(sizeof(list));
+ struct list *l = (struct list*)malloc(sizeof(struct list));
l->head = NULL;
return l;
}
-u8 list_add_tail(list *l, element *e)
+u8 list_add_tail(struct list *l, struct element *e)
{
e->next = NULL;
}
/* find last element */
- element * iterator;
- iterator = l->head;
+ struct element * iterator = l->head;
while(iterator->next!=NULL) {
iterator = iterator->next;
// FIXME: untested and unused!!
-u8 list_delete_element(list *l, element *e)
+u8 list_delete_element(struct list *l, struct element *e)
{
return 1;
}
// FIXME: untested and unused!!
-u8 list_is_element_last(list *l, element *e)
+u8 list_is_element_last(struct list *l, struct element *e)
{
if(e->next==NULL)
return 1;
// FIXME: untested and unused!!
-element * list_find_next_element(list *l, element *e)
+struct element *list_find_next_element(struct list *l, struct element *e)
{
- element * iterator;
- iterator = l->head;
+ struct element *iterator = l->head;
while(iterator!=NULL){
if(iterator == e)
#include "../../types.h"
-typedef struct element_t element;
-struct element_t {
- void * data;
- element * next;
+struct element {
+ void *data;
+ struct element *next;
};
-typedef struct list_t list;
-struct list_t {
- element * head;
+struct list {
+ struct element *head;
};
+struct list *list_create(void);
-list* list_create();
+u8 list_add_tail(struct list *l, struct element *e);
+u8 list_delete_element(struct list *l, struct element *e);
-u8 list_add_tail(list *l, element *e);
-u8 list_delete_element(list *l, element *e);
-
-u8 list_is_element_last(list *l, element *e);
-
-element * list_find_next_element(list *l, element *e);
+u8 list_is_element_last(struct list *l, struct element *e);
+struct element *list_find_next_element(struct list *l, struct element *e);
#endif // _LIST_H_
+