[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [cdi-devel] [PATCH] "Better" indent, wait for ACK instead of sleep



On Sat, Aug 22, 2009 at 02:34:21PM +0200, max@xxxxxxxxxx wrote:
> From: Max Reitz <max@??yndur.org>
> 
> * indent done with the program "indent"
> + While a USB device is not ready, it sends NAK in
>   response to IN/OUT - it is a lot better to wait
>   for an ACK instead of sleeping randomly.
> 
> Signed-off-by: Max Reitz <max@xxxxxxxxxx>

Please, please, don't do this. Coding style cleanup should never be
mixed with functional changes. This makes it extremely difficult to
review the patch. And it makes it impossible to drop to changes made by
indent if they aren't nice (they are not, at least not all of them).

> ---
>  usb/include/msd.h  |   50 +++----
>  usb/include/uhci.h |   80 ++++++------
>  usb/include/usb.h  |   67 ++++------
>  usb/main.c         |  192 ++++++++++++--------------
>  usb/msd.c          |  377 +++++++++++++++++++++++-----------------------------
>  usb/uhci.c         |  117 +++++++----------
>  6 files changed, 392 insertions(+), 491 deletions(-)
> 
> diff --git a/usb/include/msd.h b/usb/include/msd.h
> index 99c796d..cc3bb4d 100644
> --- a/usb/include/msd.h
> +++ b/usb/include/msd.h
> @@ -32,8 +32,7 @@
>  
>  //"USBC"
>  #define CBW_SIGNATURE 0x43425355
> -struct command_block_wrapper
> -{
> +struct command_block_wrapper {
>      uint32_t cbw_signature;
>      uint32_t cbw_tag;
>      uint32_t cbw_data_transfer_length;
> @@ -41,55 +40,50 @@ struct command_block_wrapper
>      uint8_t cbw_lun;
>      uint8_t cbw_cb_length;
>      uint8_t cbw_cb[16];
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
>  //"USBS"
>  #define CSW_SIGNATURE 0x53425355
> -struct command_status_wrapper
> -{
> +struct command_status_wrapper {
>      uint32_t csw_signature;
>      uint32_t csw_tag;
>      uint32_t csw_data_residue;
>      uint8_t csw_status;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct msc_sense
> -{
> -    unsigned error : 7;
> -    unsigned valid : 1;
> +struct msc_sense {
> +    unsigned error:7;
> +    unsigned valid:1;
>      uint8_t rsvd0;
> -    unsigned sense_key : 4;
> -    unsigned rsvd1 : 4;
> +    unsigned sense_key:4;
> +    unsigned rsvd1:4;

Much nicer to read with a space.

>      uint32_t information;
>      uint8_t additional_length;
>      uint32_t rsvd2;
>      uint8_t additional_code;
>      uint8_t additional_code_qualifier;
>      uint32_t rsvd;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct msd_capacity
> -{
> +struct msd_capacity {
>      uint32_t last_lba;
>      uint32_t block_length;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct cdi_msd
> -{
> +struct cdi_msd {
>      struct cdi_storage_device cdi_device;
>      struct usb_device *usb_device;
> -    uint32_t offset; //F??r Partitionen
> +    uint32_t offset;            //F??r Partitionen
>  };
>  
> -struct part_table_entry
> -{
> -   uint8_t active;
> -   uint8_t begin_chs[3];
> -   uint8_t type;
> -   uint8_t end_chs[3];
> -   uint32_t start;
> -   uint32_t size;
> -} __attribute__((packed));
> +struct part_table_entry {
> +    uint8_t active;
> +    uint8_t begin_chs[3];
> +    uint8_t type;
> +    uint8_t end_chs[3];
> +    uint32_t start;
> +    uint32_t size;
> +} __attribute__ ((packed));
>  
>  
>  #define MSC_CMD_REZERO   0x01
> diff --git a/usb/include/uhci.h b/usb/include/uhci.h
> index 0158bd2..bf22c4a 100644
> --- a/usb/include/uhci.h
> +++ b/usb/include/uhci.h
> @@ -31,15 +31,15 @@
>  #include "usb.h"
>  
>  
> -#define UHCI_USBCMD    0x00 //w
> -#define UHCI_USBSTS    0x02 //w
> -#define UHCI_USBINTR   0x04 //w
> -#define UHCI_FRNUM     0x06 //w
> -#define UHCI_FRBASEADD 0x08 //l
> -#define UHCI_SOFMOD    0x0C //b
> +#define UHCI_USBCMD    0x00     //w
> +#define UHCI_USBSTS    0x02     //w
> +#define UHCI_USBINTR   0x04     //w
> +#define UHCI_FRNUM     0x06     //w
> +#define UHCI_FRBASEADD 0x08     //l
> +#define UHCI_SOFMOD    0x0C     //b
>  #define UHCI_RPORTS    0x10
> -#define UHCI_PORTSC1   0x10 //w
> -#define UHCI_PORTSC2   0x12 //w
> +#define UHCI_PORTSC1   0x10     //w
> +#define UHCI_PORTSC2   0x12     //w
>  
>  #define MAXP    0x0080
>  #define GRESET  0x0004
> @@ -47,14 +47,13 @@
>  #define USB_RUN 0x0001
>  
>  #define RPORT_RESET  0x0200
> -#define RPORT_LOSPD  0x0100 //Low speed device attached
> +#define RPORT_LOSPD  0x0100     //Low speed device attached
>  #define RPORT_ENABLE 0x0004
> -#define RPORT_CSC    0x0002 //Connect status change
> +#define RPORT_CSC    0x0002     //Connect status change
>  #define RPORT_DEVICE 0x0001
>  
>  
> -struct uhci
> -{
> +struct uhci {
>      struct hci gen_hci;
>      uint16_t pbase;
>      uintptr_t phys_frame_list;
> @@ -62,46 +61,43 @@ struct uhci
>      int root_ports;
>  };
>  
> -struct uhci_qh
> -{
> +struct uhci_qh {
>      volatile uint32_t next;
>      volatile uint32_t transfer;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct uhci_td
> -{
> +struct uhci_td {
>      volatile uint32_t next;
>  
> -    unsigned trans_len : 11;
> -    unsigned rsvd0 : 6;
> -    unsigned bitstuff_err : 1;
> -    unsigned crc_time_err : 1;
> -    unsigned nak : 1;
> -    unsigned babble : 1;
> -    unsigned buf_err : 1;
> -    unsigned stalled_err : 1;
> -    unsigned active : 1;
> -    unsigned ioc : 1;
> -    unsigned isochronous : 1;
> -    unsigned low_speed : 1;
> -    unsigned errors : 2;
> -    unsigned spd : 1;
> -    unsigned rsvd1 : 2;
> -
> -    unsigned pid : 8;
> -    unsigned device : 7;
> -    unsigned endpoint : 4;
> -    unsigned data_toggle : 1;
> -    unsigned rsvd2 : 1;
> -    unsigned maxlen : 11;
> +    unsigned trans_len:11;
> +    unsigned rsvd0:6;
> +    unsigned bitstuff_err:1;
> +    unsigned crc_time_err:1;
> +    unsigned nak:1;
> +    unsigned babble:1;
> +    unsigned buf_err:1;
> +    unsigned stalled_err:1;
> +    unsigned active:1;
> +    unsigned ioc:1;
> +    unsigned isochronous:1;
> +    unsigned low_speed:1;
> +    unsigned errors:2;
> +    unsigned spd:1;
> +    unsigned rsvd1:2;
> +
> +    unsigned pid:8;
> +    unsigned device:7;
> +    unsigned endpoint:4;
> +    unsigned data_toggle:1;
> +    unsigned rsvd2:1;
> +    unsigned maxlen:11;
>  
>      uint32_t buffer;
>  
>      uint32_t user[4];
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct transfer
> -{
> +struct transfer {
>      void *virt;
>      uintptr_t phys;
>      volatile int error;
> diff --git a/usb/include/usb.h b/usb/include/usb.h
> index cca698a..9ec8b37 100644
> --- a/usb/include/usb.h
> +++ b/usb/include/usb.h
> @@ -30,8 +30,8 @@
>  
>  enum usb_packet_type {
>      PACKET_SETUP = 0x2D,
> -    PACKET_IN    = 0x69,
> -    PACKET_OUT   = 0xE1,
> +    PACKET_IN = 0x69,
> +    PACKET_OUT = 0xE1

Meh. Destroys nicely aligned initializers.

>  };
>  
>  #define NO_DATA       0x01
> @@ -124,42 +124,39 @@ enum usb_packet_type {
>  #define USB_TODS_STATUS         8
>  
>  
> -typedef enum
> -{
> +typedef enum {
>      HCI_UHCI,
>      HCI_OHCI,
>      HCI_EHCI
>  } hci_type_t;
>  
> -struct cdi_hci
> -{
> +struct cdi_hci {
>      struct cdi_device cdi_device;
>      struct hci *hci;
>  };
>  
>  struct usb_device;
>  
> -struct hci
> -{
> +struct hci {
>      struct cdi_pci_device *pcidev;
>      hci_type_t type;
> -    cdi_list_t (*find_devices)(struct hci *);
> -    void (*activate_device)(struct hci *, struct usb_device *);
> -    int (*do_packet)(struct hci *, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle);
> -    int (*get_frame)(struct hci *);
> +    cdi_list_t (*find_devices) (struct hci *);
> +    void (*activate_device) (struct hci *, struct usb_device *);
> +    int (*do_packet) (struct hci *, int frame, int type, int device,
> +        int endpoint, int low_speed, uintptr_t phys_data,
> +        int length, int datatoggle);
> +    int (*get_frame) (struct hci *);
>  };
>  
> -struct setup_packet
> -{
> +struct setup_packet {
>      uint8_t request_type;
>      uint8_t request;
>      uint16_t value;
>      uint16_t index;
>      uint16_t length;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct device_desc
> -{
> +struct device_desc {
>      uint8_t length;
>      uint8_t descriptor_type;
>      uint16_t bcdUSB;
> @@ -174,10 +171,9 @@ struct device_desc
>      uint8_t iProduct;
>      uint8_t iSerialNumber;
>      uint8_t num_configurations;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct config_desc
> -{
> +struct config_desc {
>      uint8_t length;
>      uint8_t descriptor_type;
>      uint16_t total_length;
> @@ -186,10 +182,9 @@ struct config_desc
>      uint8_t iConfiguration;
>      uint8_t attributes;
>      uint8_t max_power;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct interface_desc
> -{
> +struct interface_desc {
>      uint8_t length;
>      uint8_t descriptor_type;
>      uint8_t interface_number;
> @@ -199,30 +194,27 @@ struct interface_desc
>      uint8_t interface_subclass;
>      uint8_t interface_protocol;
>      uint8_t iInterface;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct endpoint_desc
> -{
> +struct endpoint_desc {
>      uint8_t length;
>      uint8_t descriptor_type;
>      uint8_t endpoint_address;
>      uint8_t attributes;
>      uint16_t max_packet_size;
>      uint8_t interval;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -struct hub_desc
> -{
> +struct hub_desc {
>      uint8_t length;
>      uint8_t descriptor_type;
>      uint8_t nbr_ports;
>      uint16_t hub_characteristics;
>      uint8_t pwron2pwrgood;
>      uint8_t hub_contr_current;
> -} __attribute__((packed));
> +} __attribute__ ((packed));
>  
> -typedef enum
> -{
> +typedef enum {
>      USBDC_COMPOSITE = 0x00,
>      USBDC_AUDIO = 0x01,
>      USBDC_COMM_CDC = 0x02,
> @@ -244,13 +236,11 @@ typedef enum
>      USBDC_VENDOR_SPEC = 0xFF
>  } usb_class_t;
>  
> -struct class_data
> -{
> +struct class_data {
>      usb_class_t type;
>  };
>  
> -struct usb_device
> -{
> +struct usb_device {
>      struct hci *hci;
>      int id;
>      int port;
> @@ -264,8 +254,7 @@ struct usb_device
>      int expects;
>  };
>  
> -struct msclass_data
> -{
> +struct msclass_data {
>      struct class_data gen_class;
>      struct endpoint_desc *bulk_ep_in;
>      struct endpoint_desc *bulk_ep_out;
> @@ -294,7 +283,7 @@ struct usb_packet {
>  #define HCI_STRUCT_SIZE sizeof(struct uhci)
>  
>  
> -int usb_do_packet(struct usb_device *device, struct usb_packet* packet);
> +int usb_do_packet(struct usb_device *device, struct usb_packet *packet);
>  void enumerate_hci(struct hci *);
>  struct cdi_driver *init_uhcd(void);
>  void init_msc_driver(void);
> diff --git a/usb/main.c b/usb/main.c
> index 9200613..51ef95b 100644
> --- a/usb/main.c
> +++ b/usb/main.c
> @@ -41,12 +41,13 @@ static int dprintf(const char *fmt, ...)
>  {
>      return 0;
>  }
> +
>  #define _dprintf(fmt, args...) dprintf(fmt, ##args)
>  #endif
>  
>  static struct usb_device *devices[128];
>  static cdi_list_t ehci, ohci, uhci;
> -static void (*ccdriver_take_device[0x100])(struct usb_device *);
> +static void (*ccdriver_take_device[0x100]) (struct usb_device *);
>  static int usb_dev_ids = 1;
>  
>  static void usb_init(void);
> @@ -94,18 +95,18 @@ static const int next_data_type[9] = {
>  };*/
>  
>  /**
> -* Verarbeitet ein USB-Paket.
> -*
> -* @param device Das USB-Ger??t
> -*/
> + * Verarbeitet ein USB-Paket.
> + *
> + * @param device Das USB-Ger??t
> + */
>  
> -int usb_do_packet(struct usb_device *device, struct usb_packet* packet)
> +int usb_do_packet(struct usb_device *device, struct usb_packet *packet)

Bah. ;-)

>  {
> -    int error;
> +    int error = USB_NAK;
>      int tod_short;
>  
>      if (!(device->expects & packet->type_of_data)) {
> -        dprintf("Expected 0x%04X, got 0x%04X...?\n", device->expects,
> +        dprintf("0x%04X erwartet, 0x%04X bekommen...?\n", device->expects,
>              packet->type_of_data);
>          // FIXME Das ist keine elegante Loesung des Problems
>          for (;;);
> @@ -118,18 +119,18 @@ int usb_do_packet(struct usb_device *device, struct usb_packet* packet)
>      device->expects = next_data_type[tod_short];
>      packet->endpoint &= 0x07;
>      packet->type &= 0xFF;
> -    if (device->stalled) //TODO: Irgendwie entstallen, evtl.? oO
> -    {
> +    if (device->stalled) {
> +        //TODO: Irgendwie entstallen, evtl.? oO
>          dprintf("Zugriff auf stalled-Ger??t verweigert.\n");
>          return USB_STALLED;
>      }
> -    error = device->hci->do_packet(device->hci,
> -        (device->hci->get_frame(device->hci) + 3) & 0x3FF,
> -        packet->type, device->id, packet->endpoint,
> -        device->low_speed, packet->phys_data, packet->length,
> -        packet->datatoggle);
> -    if (error == USB_STALLED)
> -    {
> +    while (error == USB_NAK) {
> +        error = device->hci->do_packet(device->hci,
> +            (device->hci->get_frame(device->hci) + 3) & 0x3FF,
> +            packet->type, device->id, packet->endpoint, device->low_speed,
> +            packet->phys_data, packet->length, packet->datatoggle);

Don't know, maybe here a short sleep would be nice in case of failure?

> +    }
> +    if (error == USB_STALLED) {
>          printf("[usb] ENDPOINT %i DES GER??TS %i STALLED!\n",
>              packet->endpoint, device->id);
>          device->stalled = 1;
> @@ -137,7 +138,8 @@ int usb_do_packet(struct usb_device *device, struct usb_packet* packet)
>      return error;
>  }
>  
> -static void *do_control(struct usb_device *device, int direction, void *buffer, int length, int rtype, int recipient, int request, int value, int index)
> +static void *do_control(struct usb_device *device, int direction, void *buffer,
> +    int length, int rtype, int recipient, int request, int value, int index)
>  {
>      void *rbuf;
>      int rval, no_data;
> @@ -149,7 +151,7 @@ static void *do_control(struct usb_device *device, int direction, void *buffer,
>          return NULL;
>      }
>      if (cdi_alloc_phys_mem(sizeof(struct setup_packet),
> -                           (void **)&setup, (void **)&psetup) == -1) {
> +            (void **)&setup, (void **)&psetup) == -1) {
>          return NULL;
>      }
>      direction &= 0x80;
> @@ -163,12 +165,12 @@ static void *do_control(struct usb_device *device, int direction, void *buffer,
>      setup->length = length;
>  
>      struct usb_packet setup_packet = {
> -        .type           = PACKET_SETUP,
> -        .endpoint       = 0,
> -        .phys_data      = psetup,
> -        .length         = sizeof(*setup),
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_SETUP,
> +        .type = PACKET_SETUP,
> +        .endpoint = 0,
> +        .phys_data = psetup,
> +        .length = sizeof(*setup),
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_SETUP,

*sigh*

>      };
>  
>  
> @@ -177,43 +179,38 @@ static void *do_control(struct usb_device *device, int direction, void *buffer,
>      }
>  
>      cdi_sleep_ms(20);
> -    if (no_data)
> -    {
> +    if (no_data) {
>          rval = USB_NO_ERROR;
> -        rbuf = (void *)0xFFFFFFFF; //Kein Fehler, aber auch keine Daten
> -    }
> -    else
> -    {
> +        rbuf = (void *)0xFFFFFFFF;      //Kein Fehler, aber auch keine Daten
> +    } else {
>          struct usb_packet data_packet = {
> -            .type           = (direction == DEV_TO_HOST ?
> -                              PACKET_IN : PACKET_OUT),
> -            .endpoint       = 0,
> -            .phys_data      = pbuf,
> -            .length         = length,
> -            .datatoggle     = 1,
> -            .type_of_data   = (direction == DEV_TO_HOST ?
> -                              USB_TOD_SETUP_DATA_IN : USB_TOD_SETUP_DATA_OUT),
> +            .type = (direction == DEV_TO_HOST ? PACKET_IN : PACKET_OUT),
> +            .endpoint = 0,
> +            .phys_data = pbuf,
> +            .length = length,
> +            .datatoggle = 1,
> +            .type_of_data = (direction == DEV_TO_HOST ?
> +                USB_TOD_SETUP_DATA_IN : USB_TOD_SETUP_DATA_OUT),
>          };
>  
>          rval = usb_do_packet(device, &data_packet);
>      }
>  
> -    if (rval == USB_NO_ERROR)
> -    {
> +    if (rval == USB_NO_ERROR) {
>          struct usb_packet ack_packet = {
> -            .endpoint       = 0,
> -            .phys_data      = 0,
> -            .length         = 0,
> -            .datatoggle     = 1,
> +            .endpoint = 0,
> +            .phys_data = 0,
> +            .length = 0,
> +            .datatoggle = 1,
>          };
>  
>          cdi_sleep_ms(20);
>  
>          if (no_data || (direction == HOST_TO_DEV)) {
> -            ack_packet.type         = PACKET_IN;
> +            ack_packet.type = PACKET_IN;
>              ack_packet.type_of_data = USB_TOD_SETUP_ACK_IN;
>          } else {
> -            ack_packet.type         = PACKET_OUT;
> +            ack_packet.type = PACKET_OUT;
>              ack_packet.type_of_data = USB_TOD_SETUP_ACK_OUT;
>          }
>  
> @@ -233,7 +230,8 @@ static void usb_init(void)
>  
>      init_msc_driver();
>  
> -    memset(ccdriver_take_device, 0, sizeof(void (*)(struct usb_device *)) * 0x100);
> +    memset(ccdriver_take_device, 0,
> +        sizeof(void (*)(struct usb_device *)) * 0x100);
>      ccdriver_take_device[8] = &register_msd;
>      ccdriver_take_device[9] = &enumerate_hub;
>  
> @@ -243,13 +241,11 @@ static void usb_init(void)
>  
>      cdi_list_t pci_devices = cdi_list_create();
>      cdi_pci_get_all_devices(pci_devices);
> -    for (i = 0; (dev = cdi_list_get(pci_devices, i)) != NULL; i++)
> -    {
> +    for (i = 0; (dev = cdi_list_get(pci_devices, i)) != NULL; i++) {
>          if ((dev->class_id != 0x0C) || (dev->subclass_id != 0x03)) {
>              cdi_pci_device_destroy(dev);
>          } else {
> -            switch (dev->interface_id)
> -            {
> +            switch (dev->interface_id) {
>                  case 0x00:
>                      hci = malloc(HCI_STRUCT_SIZE);
>                      hci->pcidev = dev;
> @@ -273,14 +269,12 @@ static void usb_init(void)
>  
>      cdi_list_destroy(pci_devices);
>  
> -    dprintf("%i EHCIs, %i OHCIs und %i UHCIs gefunden.\n", cdi_list_size(ehci),
> -                                                           cdi_list_size(ohci),
> -                                                           cdi_list_size(uhci));
> +    dprintf("%i EHCIs, %i OHCIs und %i UHCIs gefunden.\n",
> +        cdi_list_size(ehci), cdi_list_size(ohci), cdi_list_size(uhci));
>  
>      uhcd = init_uhcd();
>  
> -    for (i = 0; (hci = cdi_list_pop(uhci)) != NULL; i++)
> -    {
> +    for (i = 0; (hci = cdi_list_pop(uhci)) != NULL; i++) {
>          cdi_hci = malloc(sizeof(struct cdi_hci));
>          cdi_hci->cdi_device.type = CDI_UNKNOWN;
>          dev_name = malloc(10);
> @@ -313,23 +307,21 @@ static void enum_device(struct usb_device *usbdev)
>      usbdev->locked = 0;
>      usbdev->expects = USB_TOD_SETUP | USB_TOD_COMMAND;
>      dev_desc = do_control(usbdev, DEV_TO_HOST, NULL, sizeof(*dev_desc),
> -                          STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR,
> -                          DESC_DEVICE << 8, 0);
> +        STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_DEVICE << 8, 0);
>      if (dev_desc == NULL) {
>          return;
>      }
>      usbdev->device = dev_desc;
>      dprintf("0x%04X:0x%04X (%i) -> ", dev_desc->vendor_id, dev_desc->device_id,
> -                                      dev_desc->class_id);
> +        dev_desc->class_id);
>      do_control(usbdev, HOST_TO_DEV | NO_DATA, NULL, 0, STD_REQUEST, REC_DEVICE,
> -               SET_ADDRESS, (id = usb_dev_ids++), 0);
> +        SET_ADDRESS, (id = usb_dev_ids++), 0);
>      usbdev->id = id;
>      _dprintf("%i\n", id);
> -    if (dev_desc->iManufacturer)
> -    {
> +    if (dev_desc->iManufacturer) {
>          name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST,
> -                          REC_DEVICE, GET_DESCRIPTOR,
> -                          (DESC_STRING << 8) | dev_desc->iManufacturer, 0);
> +            REC_DEVICE, GET_DESCRIPTOR,
> +            (DESC_STRING << 8) | dev_desc->iManufacturer, 0);
>          if (name == NULL) {
>              return;
>          }
> @@ -339,11 +331,10 @@ static void enum_device(struct usb_device *usbdev)
>          }
>          _dprintf("\n");
>      }
> -    if (dev_desc->iProduct)
> -    {
> +    if (dev_desc->iProduct) {
>          name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST,
> -                          REC_DEVICE, GET_DESCRIPTOR,
> -                          (DESC_STRING << 8) | dev_desc->iProduct, 0);
> +            REC_DEVICE, GET_DESCRIPTOR,
> +            (DESC_STRING << 8) | dev_desc->iProduct, 0);
>          if (name == NULL) {
>              return;
>          }
> @@ -354,27 +345,25 @@ static void enum_device(struct usb_device *usbdev)
>          _dprintf("\n");
>      }
>      devices[id] = usbdev;
> -  //TODO: Man kann doch nicht immer den ersten nehmen...
> +    //TODO: Man kann doch nicht immer den ersten nehmen...
>      conf_desc = do_control(usbdev, DEV_TO_HOST, NULL,
> -                           sizeof(struct config_desc), STD_REQUEST, REC_DEVICE,
> -                           GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0);
> +        sizeof(struct config_desc), STD_REQUEST,
> +        REC_DEVICE, GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0);
>      if (conf_desc == NULL) {
>          return;
>      }
>      conf_desc = do_control(usbdev, DEV_TO_HOST, NULL, conf_desc->total_length,
> -                           STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR,
> -                           DESC_CONFIGURATION << 8, 0);
> +        STD_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_CONFIGURATION << 8, 0);
>      if (conf_desc == NULL) {
>          return;
>      }
>      usbdev->config = conf_desc;
>      do_control(usbdev, HOST_TO_DEV, NULL, 0, STD_REQUEST, REC_DEVICE,
> -               SET_CONFIGURATION, conf_desc->config_value, 0);
> -    if (conf_desc->iConfiguration)
> -    {
> +        SET_CONFIGURATION, conf_desc->config_value, 0);
> +    if (conf_desc->iConfiguration) {
>          name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST,
> -                          REC_DEVICE, GET_DESCRIPTOR,
> -                          (DESC_STRING << 8) | conf_desc->iConfiguration, 0);
> +            REC_DEVICE, GET_DESCRIPTOR,
> +            (DESC_STRING << 8) | conf_desc->iConfiguration, 0);
>          if (name == NULL) {
>              return;
>          }
> @@ -386,25 +375,25 @@ static void enum_device(struct usb_device *usbdev)
>      }
>      position = conf_desc;
>      position += sizeof(struct config_desc);
> -    best_if = position; //Standard-IF
> -    for (i = 0; i < conf_desc->num_interfaces; i++)
> -    {
> +    best_if = position;         //Standard-IF
> +    for (i = 0; i < conf_desc->num_interfaces; i++) {
>          if_desc = position;
> -        if (if_desc->interface_class == 8) //TODO: Mehr Klassencodes nat??rlich!
> -        {
> +        //TODO: Mehr Klassencodes nat??rlich!
> +        if (if_desc->interface_class == 8) {
>              best_if = if_desc;
>              break;
>          }
> -        position += sizeof(struct interface_desc) + if_desc->num_endpoints * sizeof(struct endpoint_desc);
> +        position +=
> +            sizeof(struct interface_desc) +
> +            if_desc->num_endpoints * sizeof(struct endpoint_desc);
>      }
>      do_control(usbdev, HOST_TO_DEV, NULL, 0, STD_REQUEST, REC_DEVICE,
> -               SET_INTERFACE, best_if->interface_number, 0);
> +        SET_INTERFACE, best_if->interface_number, 0);
>      usbdev->interface = best_if;
> -    if (best_if->iInterface)
> -    {
> +    if (best_if->iInterface) {
>          name = do_control(usbdev, DEV_TO_HOST, NULL, 64, STD_REQUEST,
> -                          REC_DEVICE, GET_DESCRIPTOR,
> -                          (DESC_STRING << 8) | best_if->iInterface, 0);
> +            REC_DEVICE, GET_DESCRIPTOR,
> +            (DESC_STRING << 8) | best_if->iInterface, 0);
>          if (name == NULL) {
>              return;
>          }
> @@ -415,10 +404,9 @@ static void enum_device(struct usb_device *usbdev)
>          _dprintf(".\n");
>      }
>      dprintf("Konfiguration: %i:%i (%i)\n", conf_desc->config_value,
> -                                           best_if->interface_number,
> -                                           best_if->interface_class);
> +        best_if->interface_number, best_if->interface_class);
>      if (ccdriver_take_device[best_if->interface_class] != NULL) {
> -        ccdriver_take_device[best_if->interface_class](usbdev);
> +        ccdriver_take_device[best_if->interface_class] (usbdev);
>      }
>  }
>  
> @@ -432,22 +420,20 @@ static void enumerate_hub(struct usb_device *usbdev)
>      //Mehr als 8 Ports sollte es nicht geben, die Gr????e des Deskriptors wird
>      //daher wohl nicht gr????er als sizeof()+16 werden
>      hub_desc = do_control(usbdev, DEV_TO_HOST, NULL, sizeof(*hub_desc) + 16,
> -                          CLS_REQUEST, REC_DEVICE, GET_DESCRIPTOR,
> -                          DESC_DEVICE << 8, 0);
> -    for (i = 0; i < hub_desc->nbr_ports; i++)
> -    {
> +        CLS_REQUEST, REC_DEVICE, GET_DESCRIPTOR, DESC_DEVICE << 8, 0);
> +    for (i = 0; i < hub_desc->nbr_ports; i++) {
>          port_status = do_control(usbdev, DEV_TO_HOST, NULL, 4, CLS_REQUEST,
> -                                 REC_OTHER, GET_STATUS, 0, i+1);
> +            REC_OTHER, GET_STATUS, 0, i + 1);
>          if (!(port_status[0] & PORT_DEVICE)) {
>              continue;
>          }
>          //Strom an
>          do_control(usbdev, HOST_TO_DEV, NULL, 0, CLS_REQUEST, REC_OTHER,
> -                   SET_FEATURE, PORTF_POWER, i+1);
> +            SET_FEATURE, PORTF_POWER, i + 1);
>          cdi_sleep_ms(hub_desc->pwron2pwrgood * 2);
>          //Resetten
>          do_control(usbdev, HOST_TO_DEV, NULL, 0, CLS_REQUEST, REC_OTHER,
> -                   SET_FEATURE, PORTF_RESET, i+1);
> +            SET_FEATURE, PORTF_RESET, i + 1);
>          //Reset sollte jetzt eigtl. schon beendet sein
>          //(do_control wartet ja 50 ms)
>          down = malloc(sizeof(struct usb_device));
> @@ -464,11 +450,9 @@ void enumerate_hci(struct hci *hci)
>      struct usb_device *usbdev;
>      cdi_list_t usb_devices;
>  
> -    if (hci->find_devices != NULL)
> -    {
> +    if (hci->find_devices != NULL) {
>          usb_devices = hci->find_devices(hci);
> -        while ((usbdev = cdi_list_pop(usb_devices)) != NULL)
> -        {
> +        while ((usbdev = cdi_list_pop(usb_devices)) != NULL) {
>              hci->activate_device(hci, usbdev);
>              cdi_sleep_ms(50);
>              enum_device(usbdev);
> diff --git a/usb/msd.c b/usb/msd.c
> index 0f9b79e..9614473 100644
> --- a/usb/msd.c
> +++ b/usb/msd.c
> @@ -48,6 +48,7 @@ static int dprintf(const char *fmt, ...)
>  {
>      return 0;
>  }
> +
>  #define _dprintf(fmt, args...) dprintf(fmt, ##args)
>  #endif
>  
> @@ -70,9 +71,12 @@ static void deinit_msd(struct cdi_device *cdi_msd);
>  static void get_partitions(struct cdi_storage_device *cdistrg);
>  static void init_msd(struct cdi_device *cdi_msd);
>  static void kill_driver(struct cdi_driver *cdi_msc_driver);
> -static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer);
> -static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer);
> -static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uint32_t *block_count);
> +static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start,
> +    uint64_t count, void *buffer);
> +static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start,
> +    uint64_t count, void *buffer);
> +static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size,
> +    uint32_t *block_count);
>  
>  //TODO: CDI-Funktion w??re hier sicher n??tzlich...
>  #define CPU_IS_LITTLE_ENDIAN
> @@ -125,10 +129,9 @@ void register_msd(struct usb_device *usbdev)
>      uint64_t size;
>      static int msdnum = 0;
>  
> -    if (usbdev->interface->interface_protocol != 0x50)
> -    {
> -       dprintf("Es werden nur bulk-only-Interfaces unterst??tzt.\n");
> -       return;
> +    if (usbdev->interface->interface_protocol != 0x50) {
> +        dprintf("Es werden nur bulk-only-Interfaces unterst??tzt.\n");
> +        return;
>      }
>      cdimsd = malloc(sizeof(struct cdi_msd));
>      if (cdimsd == NULL) {
> @@ -139,15 +142,13 @@ void register_msd(struct usb_device *usbdev)
>      strgdev = (struct cdi_storage_device *)cdimsd;
>      strgdev->dev.type = CDI_STORAGE;
>      strgdev->dev.name = malloc(10);
> -    if (strgdev->dev.name == NULL)
> -    {
> +    if (strgdev->dev.name == NULL) {
>          free(strgdev);
>          return;
>      }
>      sprintf((char *)strgdev->dev.name, "msd%i", msdnum++);
>      msc = malloc(sizeof(struct msclass_data));
> -    if (msc == NULL)
> -    {
> +    if (msc == NULL) {
>          free((void *)strgdev->dev.name);
>          free(strgdev);
>          return;
> @@ -156,38 +157,30 @@ void register_msd(struct usb_device *usbdev)
>      msc->bulk_ep_in = NULL;
>      msc->bulk_ep_out = NULL;
>      address = (void *)usbdev->interface + sizeof(struct interface_desc);
> -    for (i = 0; i < usbdev->interface->num_endpoints; i++)
> -    {
> +    for (i = 0; i < usbdev->interface->num_endpoints; i++) {
>          ep_desc = address;
> -        if ((ep_desc->endpoint_address & 0x80) &&
> -            (ep_desc->attributes      == 0x02) &&
> -            (msc->bulk_ep_in          == NULL)) { //BULK-IN
> +        if ((ep_desc->endpoint_address & 0x80) && (ep_desc->attributes == 0x02) && (msc->bulk_ep_in == NULL)) { //BULK-IN
>              msc->bulk_ep_in = ep_desc;
> -        } else if (!(ep_desc->endpoint_address & 0x80) &&
> -                    (ep_desc->attributes      == 0x02) &&
> -                    (msc->bulk_ep_out         == NULL)) { //BULK-OUT
> +        } else if (!(ep_desc->endpoint_address & 0x80) && (ep_desc->attributes == 0x02) && (msc->bulk_ep_out == NULL)) {        //BULK-OUT
>              msc->bulk_ep_out = ep_desc;
>          }
>          address += sizeof(struct endpoint_desc);
>      }
> -    if ((msc->bulk_ep_in == NULL) || (msc->bulk_ep_out == NULL))
> -    {
> +    if ((msc->bulk_ep_in == NULL) || (msc->bulk_ep_out == NULL)) {
>          dprintf("Nicht gen??gend Endpoints gefunden.\n");
>          return;
>      }
> -    if (!msd_get_capacity(usbdev, &bs, &bc))
> -    {
> +    if (!msd_get_capacity(usbdev, &bs, &bc)) {
>          strgdev->block_size = 0;
>          strgdev->block_count = 0;
>          dprintf("Konnte Gr????e f??r %s nicht ermitteln.\n", strgdev->dev.name);
> -    }
> -    else
> -    {
> +    } else {
>          strgdev->block_size = bs;
>          strgdev->block_count = bc;
>          size = bs;
>          size *= bc;
> -        dprintf("%s: %i * %i B (ca. %lld MB).\n", strgdev->dev.name, bc, bs, size >> 20);
> +        dprintf("%s: %i * %i B (ca. %lld MB).\n", strgdev->dev.name, bc, bs,
> +            size >> 20);
>      }
>      cdi_storage_device_init(strgdev);
>      cdi_list_push(cdi_driver.drv.devices, strgdev);
> @@ -210,58 +203,81 @@ static void deinit_msd(struct cdi_device *cdi_msd)
>      //TODO: Und gerade hier...
>  }
>  
> -static int write_cmd(struct usb_device* usbdev, uintptr_t src)
> +static int write_cmd(struct usb_device *usbdev, uintptr_t src)
>  {
> -    struct msclass_data *msc = (struct msclass_data*) usbdev->classd;
> +    struct msclass_data *msc = (struct msclass_data *)usbdev->classd;
>      struct usb_packet cmd_packet = {
> -        .type           = PACKET_OUT,
> -        .endpoint       = msc->bulk_ep_out->endpoint_address,
> -        .phys_data      = src,
> -        .length         = 0x1F,
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_COMMAND,
> +        .type = PACKET_OUT,
> +        .endpoint = msc->bulk_ep_out->endpoint_address,
> +        .phys_data = src,
> +        .length = 0x1F,
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_COMMAND,
>      };
>  
>      return usb_do_packet(usbdev, &cmd_packet);
>  }
>  
> -static int read_status(struct usb_device* usbdev, uintptr_t dest)
> +/**
> + * Liest den Status von einem MSD
> + *
> + * @param usbdev Das bewusste Ger??t
> + * @param expected_tag Das erwartete Tag
> + *
> + * @return Wenn der Status OK ist USB_NO_ERROR, sonst entsprechender Fehler
> + */
> +
> +static int read_status(struct usb_device *usbdev, uint32_t expected_tag)
>  {
> -    struct msclass_data *msc = (struct msclass_data*) usbdev->classd;
> +    uintptr_t pcsw;
> +    struct msclass_data *msc = (struct msclass_data *)usbdev->classd;
> +    struct command_status_wrapper *csw;
> +    int error;
> +
> +    if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper),

sizeof(*csw) would be shorter

> +            (void **)&csw, (void **)&pcsw) == -1) {
> +        return USB_TRIVIAL_ERROR;
> +    }
> +
>      struct usb_packet status_packet = {
> -        .type           = PACKET_IN,
> -        .endpoint       = msc->bulk_ep_in->endpoint_address,
> -        .phys_data      = dest,
> -        .length         = 0x0D,
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_STATUS,
> +        .type = PACKET_IN,
> +        .endpoint = msc->bulk_ep_in->endpoint_address,
> +        .phys_data = pcsw,
> +        .length = 0x0D,
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_STATUS,
>      };
>  
> -    return usb_do_packet(usbdev, &status_packet);
> +    error = usb_do_packet(usbdev, &status_packet);
> +    if (error != USB_NO_ERROR) {
> +        return error;
> +    }
> +    if ((csw->csw_signature != CSW_SIGNATURE) ||
> +        (csw->csw_tag != expected_tag) || csw->csw_status) {
> +        return USB_CRC; //Watt wei?? denn ich

Hm. Is this really the right value?

> +    }
> +
> +    return USB_NO_ERROR;
>  }
>  
> -static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uint32_t *block_count)
> +static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size,
> +    uint32_t *block_count)
>  {
>      struct msclass_data *msc;
>      struct command_block_wrapper *cbw;
> -    struct command_status_wrapper *csw;
>      struct msd_capacity *cap;
> -    uintptr_t pcbw, pcsw, pcap;
> +    uintptr_t pcbw, pcap;
>      uint32_t expected_tag;
>  
>      if ((usbdev == NULL) || (block_size == NULL) || (block_count == NULL)) {
>          return 0;
>      }
>      if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper),
> -                           (void **)&cbw, (void **)&pcbw) == -1) {
> -        return 0;
> -    }
> -    if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper),
> -                           (void **)&csw, (void **)&pcsw) == -1) {
> +            (void **)&cbw, (void **)&pcbw) == -1) {
>          return 0;
>      }
>      if (cdi_alloc_phys_mem(sizeof(struct msd_capacity),
> -                           (void **)&cap, (void **)&pcap) == -1) {
> +            (void **)&cap, (void **)&pcap) == -1) {
>          return 0;
>      }
>      msc = (struct msclass_data *)usbdev->classd;
> @@ -269,42 +285,30 @@ static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uin
>      cbw->cbw_signature = CBW_SIGNATURE;
>      cbw->cbw_tag = (expected_tag = cbw_tag++);
>      cbw->cbw_data_transfer_length = sizeof(struct msd_capacity);
> -    cbw->cbw_flags = 0x80; //IN
> -    cbw->cbw_lun = 0; //Was wei?? ich, wie viele LUNs datt Dingens hat?
> +    cbw->cbw_flags = 0x80;      //IN
> +    cbw->cbw_lun = 0;           //Was wei?? ich, wie viele LUNs datt Dingens hat?
>      cbw->cbw_cb_length = 12;
>      cbw->cbw_cb[0] = MSC_CMD_CAPACITY;
> -    cbw->cbw_cb[1] = 0; //LUN: 0
> +    cbw->cbw_cb[1] = 0;         //LUN: 0
>  
>      if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) {
>          return 0;
>      }
>  
> -    cdi_sleep_ms(20);
> -
>      struct usb_packet in_packet = {
> -        .type           = PACKET_IN,
> -        .endpoint       = msc->bulk_ep_in->endpoint_address,
> -        .phys_data      = pcap,
> -        .length         = sizeof(*cap),
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_DATA_IN,
> +        .type = PACKET_IN,
> +        .endpoint = msc->bulk_ep_in->endpoint_address,
> +        .phys_data = pcap,
> +        .length = sizeof(*cap),
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_DATA_IN,
>      };
>  
>      if (usb_do_packet(usbdev, &in_packet) != USB_NO_ERROR) {
>          return 0;
>      }
>  
> -    cdi_sleep_ms(5);
> -
> -    if (read_status(usbdev, pcsw) != USB_NO_ERROR) {
> -        return 0;
> -    }
> -
> -    cdi_sleep_ms(5);
> -
> -    if ((csw->csw_signature != CSW_SIGNATURE) ||
> -         (csw->csw_tag      !=  expected_tag) ||
> -          csw->csw_status) {
> +    if (read_status(usbdev, expected_tag) != USB_NO_ERROR) {
>          return 0;
>      }
>  
> @@ -317,46 +321,33 @@ static int msd_get_capacity(struct usb_device *usbdev, uint32_t *block_size, uin
>  #ifdef WAIT_FOR_MSD_READY
>  static int msd_ready(struct usb_device *usbdev)
>  {
> -   struct msclass_data *msc;
> -   struct command_block_wrapper *cbw;
> -   struct command_status_wrapper *csw;
> -   uintptr_t pcbw, pcsw;
> -   uint32_t expected_tag;
> -
> -   if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper),
> -                          (void **)&cbw, (void **)&pcbw) == -1) {
> -      return 0;
> -   }
> -   if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper),
> -                          (void **)&csw, (void **)&pcsw) == -1) {
> -      return 0;
> -   }
> -   msc = (struct msclass_data *)usbdev->classd;
> -   memset(cbw, 0, 0x1F);
> -   cbw->cbw_signature = CBW_SIGNATURE;
> -   cbw->cbw_tag = (expected_tag = cbw_tag++);
> -   cbw->cbw_data_transfer_length = 0;
> -   cbw->cbw_flags = 0x80; //IN
> -   cbw->cbw_lun = 0; //Was wei?? ich, wie viele LUNs datt Dingens hat?
> -   cbw->cbw_cb_length = 12; //Alles null, also "Test unit ready"
> -
> -   if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) {
> -       return 0;
> -   }
> -
> -   cdi_sleep_ms(7);
> -   if (read_status(usbdev, pcsw) != USB_NO_ERROR) {
> -       return 0;
> -   }
> -
> -   cdi_sleep_ms(4);
> -   if ((csw->csw_signature != CSW_SIGNATURE) ||
> -       (csw->csw_tag       !=  expected_tag) ||
> -        csw->csw_status) {
> -      return 0;
> -   }
> -
> -   return 1;
> +    struct msclass_data *msc;
> +    struct command_block_wrapper *cbw;
> +    uintptr_t pcbw;
> +    uint32_t expected_tag;
> +
> +    if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper),
> +            (void **)&cbw, (void **)&pcbw) == -1) {
> +        return 0;
> +    }
> +    msc = (struct msclass_data *)usbdev->classd;
> +    memset(cbw, 0, 0x1F);
> +    cbw->cbw_signature = CBW_SIGNATURE;
> +    cbw->cbw_tag = (expected_tag = cbw_tag++);
> +    cbw->cbw_data_transfer_length = 0;
> +    cbw->cbw_flags = 0x80;      //IN
> +    cbw->cbw_lun = 0;           //Was wei?? ich, wie viele LUNs datt Dingens hat?
> +    cbw->cbw_cb_length = 12;    //Alles null, also "Test unit ready"
> +
> +    if (write_cmd(usbdev, pcbw) != USB_NO_ERROR) {
> +        return 0;
> +    }
> +
> +    if (read_status(usbdev, expected_tag) != USB_NO_ERROR) {
> +        return 0;
> +    }
> +
> +    return 1;
>  }
>  #endif
>  
> @@ -368,9 +359,11 @@ static inline int tsl(volatile int *variable)
>      return rval;
>  }
>  
> -static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length);
> +static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba,
> +    uint16_t sectors, uintptr_t phys_buffer, size_t length);
>  
> -static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer)
> +static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start,
> +    uint64_t count, void *buffer)
>  {
>      void *vb;
>      uintptr_t pb;
> @@ -383,57 +376,48 @@ static int msd_cdi_read(struct cdi_storage_device *strgdev, uint64_t start, uint
>  
>      fdprintf("read(%i, %i)\n", (int)start, (int)count);
>      start += ((struct cdi_msd *)strgdev)->offset;
> -    if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1)
> -    {
> +    if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) {
>          dprintf("Blockspeicher konnte nicht allociert werden.\n");
>          return -1;
>      }
> -    if (!count)
> -    {
> +    if (!count) {
>          dprintf("Leere Leseanfrage.\n");
>          return 0;
>      }
> -    while (tsl(&usbdev->locked))
> -    {
> +    while (tsl(&usbdev->locked)) {
>  #ifndef CDI_STANDALONE
> -        __asm__ __volatile__ ("hlt");
> +        __asm__ __volatile__("hlt");
>  #endif
>      }
> -    for (i = 0; i < count; i++)
> -    {
> +    for (i = 0; i < count; i++) {
>  #ifdef WAIT_FOR_MSD_READY
>          for (j = 0; !msd_ready(usbdev) && (j < 10); j++) {
>              cdi_sleep_ms(20);
>          }
>  #endif
>          error = msd_read(usbdev, start + i, 1, pb, bs);
> -        if (error != USB_NO_ERROR)
> -        {
> +        if (error != USB_NO_ERROR) {
>              dprintf("Lesefehler 0x%X bei Block %i.\n", error, i);
>              usbdev->locked = 0;
>              return -1;
>          }
> -        memcpy(buffer + i*bs, vb, bs);
> +        memcpy(buffer + i * bs, vb, bs);
>      }
>      usbdev->locked = 0;
>      return 0;
>  }
>  
> -static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length)
> +static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba,
> +    uint16_t sectors, uintptr_t phys_buffer, size_t length)
>  {
>      struct msclass_data *msc;
>      struct command_block_wrapper *cbw;
> -    struct command_status_wrapper *csw;
> -    uintptr_t pcbw, pcsw;
> +    uintptr_t pcbw;
>      uint32_t expected_tag;
>      int error;
>  
>      if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper),
> -                           (void **)&cbw, (void **)&pcbw) == -1) {
> -        return USB_TRIVIAL_ERROR;
> -    }
> -    if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper),
> -                           (void **)&csw, (void **)&pcsw) == -1) {
> +            (void **)&cbw, (void **)&pcbw) == -1) {
>          return USB_TRIVIAL_ERROR;
>      }
>      if (!phys_buffer || !length) {
> @@ -444,61 +428,50 @@ static uint32_t msd_read(struct usb_device *usbdev, uint32_t lba, uint16_t secto
>      cbw->cbw_signature = CBW_SIGNATURE;
>      cbw->cbw_tag = (expected_tag = cbw_tag++);
>      cbw->cbw_data_transfer_length = length;
> -    cbw->cbw_flags = 0x80; //IN
> -    cbw->cbw_lun = 0; //Was wei?? ich, wie viele LUNs datt Dingens hat?
> +    cbw->cbw_flags = 0x80;      //IN
> +    cbw->cbw_lun = 0;           //Was wei?? ich, wie viele LUNs datt Dingens hat?
>      cbw->cbw_cb_length = 12;
>      cbw->cbw_cb[0] = MSC_CMD_READ10;
> -    cbw->cbw_cb[1] = 0; //LUN: 0
> +    cbw->cbw_cb[1] = 0;         //LUN: 0
>      cbw->cbw_cb[2] = (lba & 0xFF000000) >> 24;
>      cbw->cbw_cb[3] = (lba & 0x00FF0000) >> 16;
>      cbw->cbw_cb[4] = (lba & 0x0000FF00) >> 8;
> -    cbw->cbw_cb[5] =  lba & 0x000000FF;
> +    cbw->cbw_cb[5] = lba & 0x000000FF;
>      cbw->cbw_cb[7] = (sectors & 0x0000FF00) >> 8;
> -    cbw->cbw_cb[8] =  sectors & 0x000000FF;
> +    cbw->cbw_cb[8] = sectors & 0x000000FF;
>  
>      error = write_cmd(usbdev, pcbw);
>      if (error != USB_NO_ERROR) {
>          return error;
>      }
> -    cdi_sleep_ms(20);
>  
>      struct usb_packet in_packet = {
> -        .type           = PACKET_IN,
> -        .endpoint       = msc->bulk_ep_in->endpoint_address,
> -        .phys_data      = phys_buffer,
> -        .length         = length,
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_DATA_IN,
> +        .type = PACKET_IN,
> +        .endpoint = msc->bulk_ep_in->endpoint_address,
> +        .phys_data = phys_buffer,
> +        .length = length,
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_DATA_IN,
>      };
>  
>      error = usb_do_packet(usbdev, &in_packet);
>      if (error != USB_NO_ERROR) {
>          return error;
>      }
> -    cdi_sleep_ms(5);
>  
> -    error = read_status(usbdev, pcsw);
> +    error = read_status(usbdev, expected_tag);
>      if (error != USB_NO_ERROR) {
>          return error;
>      }
>  
> -    cdi_sleep_ms(4);
> -    if ((csw->csw_signature != CSW_SIGNATURE) ||
> -        (csw->csw_tag       !=  expected_tag) ||
> -         csw->csw_status)
> -    {
> -        dprintf("0x%08X 0x%08X==0x%08X 0x%02X\n", csw->csw_signature,
> -                                                  csw->csw_tag,
> -                                                  expected_tag,
> -                                                  csw->csw_status);
> -        return USB_CRC; //Watt wei?? denn ich...
> -    }
>      return USB_NO_ERROR;
>  }
>  
> -static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length);
> +static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba,
> +    uint16_t sectors, uintptr_t phys_buffer, size_t length);
>  
> -static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uint64_t count, void *buffer)
> +static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start,
> +    uint64_t count, void *buffer)
>  {
>      void *vb;
>      uintptr_t pb;
> @@ -511,28 +484,24 @@ static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uin
>  
>      fdprintf("write(%i, %i)\n", (int)start, (int)count);
>      start += ((struct cdi_msd *)strgdev)->offset;
> -    if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1)
> -    {
> +    if (cdi_alloc_phys_mem(bs, &vb, (void **)&pb) == -1) {
>          dprintf("Blockspeicher zum Schreiben konnte nicht allociert werden.\n");
>          return -1;
>      }
> -    while (tsl(&usbdev->locked))
> -    {
> +    while (tsl(&usbdev->locked)) {
>  #ifndef CDI_STANDALONE
> -        __asm__ __volatile__ ("hlt");
> +        __asm__ __volatile__("hlt");
>  #endif
>      }
> -    for (i = 0; i < count; i++)
> -    {
> -        memcpy(vb, buffer + i*bs, bs);
> +    for (i = 0; i < count; i++) {
> +        memcpy(vb, buffer + i * bs, bs);
>  #ifdef WAIT_FOR_MSD_READY
>          for (j = 0; !msd_ready(usbdev) && (j < 10); j++) {
>              cdi_sleep_ms(20);
>          }
>  #endif
>          error = msd_write(usbdev, start + i, 1, pb, bs);
> -        if (error != USB_NO_ERROR)
> -        {
> +        if (error != USB_NO_ERROR) {
>              dprintf("Schreibfehler 0x%X bei Block %i.\n", error, i);
>              usbdev->locked = 0;
>              return -1;
> @@ -542,7 +511,8 @@ static int msd_cdi_write(struct cdi_storage_device *strgdev, uint64_t start, uin
>      return 0;
>  }
>  
> -static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sectors, uintptr_t phys_buffer, size_t length)
> +static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba,
> +    uint16_t sectors, uintptr_t phys_buffer, size_t length)
>  {
>      struct msclass_data *msc;
>      struct command_block_wrapper *cbw;
> @@ -552,11 +522,11 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect
>      int error;
>  
>      if (cdi_alloc_phys_mem(sizeof(struct command_block_wrapper),
> -                           (void **)&cbw, (void **)&pcbw) == -1) {
> +            (void **)&cbw, (void **)&pcbw) == -1) {
>          return USB_TRIVIAL_ERROR;
>      }
>      if (cdi_alloc_phys_mem(sizeof(struct command_status_wrapper),
> -                           (void **)&csw, (void **)&pcsw) == -1) {
> +            (void **)&csw, (void **)&pcsw) == -1) {
>          return USB_TRIVIAL_ERROR;
>      }
>      if (!phys_buffer || !length) {
> @@ -567,31 +537,30 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect
>      cbw->cbw_signature = CBW_SIGNATURE;
>      cbw->cbw_tag = (expected_tag = cbw_tag++);
>      cbw->cbw_data_transfer_length = length;
> -    cbw->cbw_flags = 0x00; //OUT
> -    cbw->cbw_lun = 0; //Was wei?? ich, wie viele LUNs datt Dingens hat?
> +    cbw->cbw_flags = 0x00;      //OUT
> +    cbw->cbw_lun = 0;           //Was wei?? ich, wie viele LUNs datt Dingens hat?
>      cbw->cbw_cb_length = 12;
>      cbw->cbw_cb[0] = MSC_CMD_WRITE10;
> -    cbw->cbw_cb[1] = 0; //LUN: 0
> +    cbw->cbw_cb[1] = 0;         //LUN: 0
>      cbw->cbw_cb[2] = (lba & 0xFF000000) >> 24;
>      cbw->cbw_cb[3] = (lba & 0x00FF0000) >> 16;
>      cbw->cbw_cb[4] = (lba & 0x0000FF00) >> 8;
> -    cbw->cbw_cb[5] =  lba & 0x000000FF;
> +    cbw->cbw_cb[5] = lba & 0x000000FF;
>      cbw->cbw_cb[7] = (sectors & 0x0000FF00) >> 8;
> -    cbw->cbw_cb[8] =  sectors & 0x000000FF;
> +    cbw->cbw_cb[8] = sectors & 0x000000FF;
>  
>      error = write_cmd(usbdev, pcbw);
>      if (error != USB_NO_ERROR) {
>          return error;
>      }
> -    cdi_sleep_ms(20);
>  
>      struct usb_packet out_packet = {
> -        .type           = PACKET_OUT,
> -        .endpoint       = msc->bulk_ep_out->endpoint_address,
> -        .phys_data      = phys_buffer,
> -        .length         = length,
> -        .datatoggle     = 0,
> -        .type_of_data   = USB_TOD_DATA_OUT,
> +        .type = PACKET_OUT,
> +        .endpoint = msc->bulk_ep_out->endpoint_address,
> +        .phys_data = phys_buffer,
> +        .length = length,
> +        .datatoggle = 0,
> +        .type_of_data = USB_TOD_DATA_OUT,
>      };
>  
>      error = usb_do_packet(usbdev, &out_packet);
> @@ -599,23 +568,11 @@ static uint32_t msd_write(struct usb_device *usbdev, uint32_t lba, uint16_t sect
>          return error;
>      }
>  
> -    cdi_sleep_ms(5);
> -    error = read_status(usbdev, pcsw);
> +    error = read_status(usbdev, expected_tag);
>      if (error != USB_NO_ERROR) {
>          return error;
>      }
>  
> -    cdi_sleep_ms(4);
> -    if ((csw->csw_signature != CSW_SIGNATURE) ||
> -        (csw->csw_tag       !=  expected_tag) ||
> -         csw->csw_status)
> -    {
> -        dprintf("0x%08X 0x%08X==0x%08X 0x%02X\n", csw->csw_signature,
> -                                                  csw->csw_tag,
> -                                                  expected_tag,
> -                                                  csw->csw_status);
> -        return USB_CRC;
> -    }
>      return USB_NO_ERROR;
>  }
>  
> @@ -631,15 +588,15 @@ static void get_partitions(struct cdi_storage_device *cdistrg)
>          dprintf("MBR konnte nicht eingelesen werden.\n");
>          return;
>      }
> -    if (((uint16_t *)mbr)[255] != 0xAA55) {
> +    if (((uint16_t *) mbr)[255] != 0xAA55) {
>          return;
>      }
>      partition = mbr + 0x1BE;
>      dprintf("Partitionen auf %s:", cdistrg->dev.name);
> -    for (i = 0; i < 4; i++)
> -    {
> -        if (partition[i].type && partition[i].size && (partition[i].start + partition[i].size < cdistrg->block_count))
> -        {
> +    for (i = 0; i < 4; i++) {
> +        if (partition[i].type && partition[i].size
> +            && (partition[i].start + partition[i].size <
> +                cdistrg->block_count)) {
>              cdimsd = malloc(sizeof(struct cdi_msd));
>              if (cdimsd == NULL) {
>                  break;
> @@ -648,12 +605,12 @@ static void get_partitions(struct cdi_storage_device *cdistrg)
>              cdimsd->usb_device = base_cdimsd->usb_device;
>              cdimsd->cdi_device.dev.type = CDI_STORAGE;
>              cdimsd->cdi_device.dev.name = malloc(14);
> -            if (cdimsd->cdi_device.dev.name == NULL)
> -            {
> +            if (cdimsd->cdi_device.dev.name == NULL) {
>                  free(cdimsd);
>                  break;
>              }
> -            sprintf((char *)cdimsd->cdi_device.dev.name, "%sp%i", cdistrg->dev.name, j++);
> +            sprintf((char *)cdimsd->cdi_device.dev.name, "%sp%i",
> +                cdistrg->dev.name, j++);
>              cdimsd->cdi_device.block_size = base_cdimsd->cdi_device.block_size;
>              cdimsd->cdi_device.block_count = partition[i].size;
>              _dprintf(" %s", cdimsd->cdi_device.dev.name);
> diff --git a/usb/uhci.c b/usb/uhci.c
> index 799d526..6cdc44c 100644
> --- a/usb/uhci.c
> +++ b/usb/uhci.c
> @@ -43,6 +43,7 @@ static int dprintf(const char *fmt, ...)
>  {
>      return 0;
>  }
> +
>  #define _dprintf(fmt, args...) dprintf(fmt, ##args)
>  #endif
>  
> @@ -52,7 +53,9 @@ static struct cdi_driver cdi_driver;
>  static cdi_list_t active_transfers;
>  
>  static void uhci_handler(struct cdi_device *dev);
> -static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle);
> +static int enqueue_request(struct hci *gen_hci, int frame, int type,
> +    int device, int endpoint, int low_speed,
> +    uintptr_t phys_data, int length, int datatoggle);
>  static cdi_list_t get_devices(struct hci *gen_hci);
>  static void activate_device(struct hci *gen_hci, struct usb_device *device);
>  static int get_current_frame(struct hci *gen_hci);
> @@ -75,14 +78,13 @@ struct cdi_driver *init_uhcd()
>  
>  static void uhci_kill(struct cdi_driver *cdi_hcd)
>  {
> -  //TODO: Da geht doch noch was
> +    //TODO: Da geht doch noch was
>  }
>  
>  static void uhci_deinit(struct cdi_device *cdi_hci)
>  {
> -    cdi_outw(((struct uhci *)((struct cdi_hci *)cdi_hci)->hci)->pbase + UHCI_USBCMD,
> -             MAXP); //HC anhalten
> -  //TODO: Hier doch auch
> +    cdi_outw(((struct uhci *)((struct cdi_hci *)cdi_hci)->hci)->pbase + UHCI_USBCMD, MAXP);     //HC anhalten
> +    //TODO: Hier doch auch
>  }
>  
>  void uhci_init(struct cdi_device *cdi_hci)
> @@ -95,13 +97,10 @@ void uhci_init(struct cdi_device *cdi_hci)
>      //cdi_pci_alloc_ioports(gen_hci->pcidev);
>      uhci->pbase = 0;
>      for (i = 0; (res = cdi_list_get(gen_hci->pcidev->resources, i)) != NULL;
> -         i++)
> -    {
> -        if (res->type == CDI_PCI_IOPORTS)
> -        {
> +        i++) {
> +        if (res->type == CDI_PCI_IOPORTS) {
>              size = res->length ? res->length : 0x14;
> -            if (cdi_ioports_alloc(res->start, size) == -1)
> -            {
> +            if (cdi_ioports_alloc(res->start, size) == -1) {
>                  dprintf("I/O-Ports konnten nicht reserviert werden.\n");
>                  return;
>              }
> @@ -109,14 +108,12 @@ void uhci_init(struct cdi_device *cdi_hci)
>              break;
>          }
>      }
> -    if (!uhci->pbase)
> -    {
> +    if (!uhci->pbase) {
>          dprintf("I/O-Basis nicht gefunden!\n");
>          return;
>      }
>      if (cdi_alloc_phys_mem(4096, (void **)&uhci->frame_list,
> -                                 (void **)&uhci->phys_frame_list) == -1)
> -    {
> +            (void **)&uhci->phys_frame_list) == -1) {
>          dprintf("Frame List konnte nicht allociert werden!\n");
>          return;
>      }
> @@ -125,9 +122,10 @@ void uhci_init(struct cdi_device *cdi_hci)
>      if (uhci->root_ports > 7) { //Laut Linuxkernel ist das so "weird", dass da was nicht stimmen kann...
>          uhci->root_ports = 2;
>      }
> -    dprintf("UHC mit I/O 0x%04X (%i Ports) und IRQ %i\n", uhci->pbase, uhci->root_ports, gen_hci->pcidev->irq);
> +    dprintf("UHC mit I/O 0x%04X (%i Ports) und IRQ %i\n", uhci->pbase,
> +        uhci->root_ports, gen_hci->pcidev->irq);
>      for (i = 0; i < 1024; i++) {
> -        uhci->frame_list[i] = 1; //Invalid
> +        uhci->frame_list[i] = 1;        //Invalid
>      }
>      dprintf("Resetten...\n");
>      //HC zur??cksetzen
> @@ -144,10 +142,10 @@ void uhci_init(struct cdi_device *cdi_hci)
>      cdi_outw(uhci->pbase + UHCI_USBINTR, 0xF);
>      //Framelistadresse eintragen
>      cdi_outl(uhci->pbase + UHCI_FRBASEADD, uhci->phys_frame_list);
> -    cdi_outw(uhci->pbase + UHCI_FRNUM, 0); //Frame zur??cksetzen
> +    cdi_outw(uhci->pbase + UHCI_FRNUM, 0);      //Frame zur??cksetzen
>      //Ports abschalten, damit selektiv eingeschaltet werden kann (Enumeration)
>      for (i = 0; i < uhci->root_ports; i++) {
> -        cdi_outw(uhci->pbase + UHCI_RPORTS + i*2, RPORT_CSC);
> +        cdi_outw(uhci->pbase + UHCI_RPORTS + i * 2, RPORT_CSC);
>      }
>      dprintf("  Fertig\n");
>      gen_hci->find_devices = &get_devices;
> @@ -167,10 +165,8 @@ static cdi_list_t get_devices(struct hci *gen_hci)
>  
>      dprintf("Ger??te finden: ");
>      cdi_outw(uhci->pbase + UHCI_USBCMD, USB_RUN);
> -    for (i = 0; i < uhci->root_ports; i++)
> -    {
> -        if (!(cdi_inw(uhci->pbase + UHCI_RPORTS + 2*i) & RPORT_DEVICE))
> -        {
> +    for (i = 0; i < uhci->root_ports; i++) {
> +        if (!(cdi_inw(uhci->pbase + UHCI_RPORTS + 2 * i) & RPORT_DEVICE)) {
>              _dprintf("-");
>              continue;
>          }
> @@ -180,7 +176,7 @@ static cdi_list_t get_devices(struct hci *gen_hci)
>          dev->id = 0;
>          dev->port = i;
>          dev->low_speed =
> -                (cdi_inw(uhci->pbase + UHCI_RPORTS + 2*i) & RPORT_LOSPD) && 1;
> +            (cdi_inw(uhci->pbase + UHCI_RPORTS + 2 * i) & RPORT_LOSPD) && 1;
>          cdi_list_push(dlist, dev);
>      }
>      _dprintf("\n");
> @@ -193,7 +189,7 @@ static void activate_device(struct hci *gen_hci, struct usb_device *device)
>  
>      dprintf("Ger??t an Port %i wird aktiviert.\n", device->port);
>      cdi_outw(uhci->pbase + UHCI_RPORTS + 2 * device->port,
> -             RPORT_RESET | RPORT_ENABLE | RPORT_CSC);
> +        RPORT_RESET | RPORT_ENABLE | RPORT_CSC);
>      cdi_sleep_ms(20);
>  }
>  
> @@ -209,34 +205,37 @@ static inline int tsl(volatile int *variable)
>      *variable = 1;
>      return rval;
>  }
> +
>  static volatile int locked = 0;
>  
> -static int enqueue_request(struct hci *gen_hci, int frame, int type, int device, int endpoint, int low_speed, uintptr_t phys_data, int length, int datatoggle)
> +static int enqueue_request(struct hci *gen_hci, int frame, int type,
> +    int device, int endpoint, int low_speed,
> +    uintptr_t phys_data, int length, int datatoggle)
>  {
>      struct uhci *uhci = (struct uhci *)gen_hci;
>      struct uhci_td *td;
>      struct uhci_qh *qh;
>      uintptr_t ptd, pqh;
>      struct transfer *addr;
> +    int timeout;
>  
>      if (cdi_alloc_phys_mem(sizeof(struct uhci_td),
> -                           (void **)&td, (void **)&ptd) == -1) {
> +            (void **)&td, (void **)&ptd) == -1) {
>          return USB_TRIVIAL_ERROR;
>      }
>      if (cdi_alloc_phys_mem(sizeof(struct uhci_qh),
> -                           (void **)&qh, (void **)&pqh) == -1) {
> +            (void **)&qh, (void **)&pqh) == -1) {
>          return USB_TRIVIAL_ERROR;
>      }
> -    while (tsl(&locked))
> -    {
> +    while (tsl(&locked)) {
>  #ifndef CDI_STANDALONE
> -        __asm__ __volatile__ ("hlt");
> +        __asm__ __volatile__("hlt");
>  #endif
>      }
> -    qh->next = 1; //Invalid
> +    qh->next = 1;               //Invalid
>      qh->transfer = ptd;
>      memset(td, 0, sizeof(struct uhci_td));
> -    td->next = 1; //Invalid
> +    td->next = 1;               //Invalid
>      td->active = 1;
>      td->ioc = 1;
>      td->data_toggle = datatoggle;
> @@ -245,7 +244,7 @@ static int enqueue_request(struct hci *gen_hci, int frame, int type, int device,
>      td->pid = type;
>      td->device = device;
>      td->endpoint = endpoint;
> -    td->maxlen = length ? length-1 : 0x7FF;
> +    td->maxlen = length ? length - 1 : 0x7FF;
>      td->buffer = phys_data;
>      addr = malloc(sizeof(struct transfer));
>      addr->virt = td;
> @@ -253,20 +252,12 @@ static int enqueue_request(struct hci *gen_hci, int frame, int type, int device,
>      addr->error = 0xFFFF;
>      cdi_list_push(active_transfers, addr);
>      uhci->frame_list[frame] = pqh | 2;
> -#ifdef CDI_STANDALONE
> -    /*int cframe = get_current_frame(gen_hci), nframe;
> -    nframe = (cframe > frame) ? frame + 1024 : frame; //??berl??ufe korrigieren
> -    //Ann??hern, wann er wohl fertig ist
> -    cdi_sleep_ms(nframe + 30 - get_current_frame(gen_hci));*/
> -#else
> -    while (!(qh->transfer & 1)) {
> -        __asm__ __volatile__ ("hlt");
> +    for (timeout = 0; !(qh->transfer & 1) && (timeout < 1000); timeout++) {
> +        cdi_sleep_ms(1);
>      }
> -#endif
> -    while (addr->error == 0xFFFF)
> -    {
> +    while ((timeout < 1000) && (addr->error == 0xFFFF)) {
>  #ifndef CDI_STANDALONE
> -        __asm__ __volatile__ ("hlt");
> +        __asm__ __volatile__("hlt");
>  #endif
>      }
>      uhci->frame_list[frame] = 1;
> @@ -281,54 +272,44 @@ static void uhci_handler(struct cdi_device *cdi_hci)
>      struct transfer *addr;
>      struct uhci_td *td;
>  
> -    if (!status) { //Also, von hier kommt der IRQ nicht.
> +    if (!status) {              //Also, von hier kommt der IRQ nicht.
>          return;
>      }
>      if (status & ~0x0001) {
>          dprintf("Unerwarteter IRQ 0x%04X von %s\n", status, cdi_hci->name);
>      }
> -    if (status & 0x10)
> -    {
> +    if (status & 0x10) {
>          printf("[uhci] SCHWERWIEGENDER FEHLER - HC WIRD ANGEHALTEN\n");
> -        cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | HCRESET); //FU!
> -    }
> -    else
> -    {
> -        for (i = 0; (addr = cdi_list_get(active_transfers, i)) != NULL; i++)
> -        {
> +        cdi_outw(uhci->pbase + UHCI_USBCMD, MAXP | HCRESET);    //FU!
> +    } else {
> +        for (i = 0; (addr = cdi_list_get(active_transfers, i)) != NULL; i++) {
>              td = addr->virt;
>              if (td->active) {
>                  continue;
>              }
>              addr->error = USB_NO_ERROR;
>              cdi_list_remove(active_transfers, i--);
> -            if (td->stalled_err)
> -            {
> +            if (td->stalled_err) {
>                  dprintf("ENDPOINT STALLED\n");
>                  addr->error |= USB_STALLED;
>              }
> -            if (td->buf_err)
> -            {
> +            if (td->buf_err) {
>                  dprintf("Puffer??berlauf oder Underrun\n");
>                  addr->error |= USB_BUFFER_ERROR;
>              }
> -            if (td->babble)
> -            {
> -                dprintf("Puh, da war ein Ger??t wohl sehr gespr??chig: Babble.\n");
> +            if (td->babble) {
> +                dprintf("Da war ein Ger??t wohl sehr gespr??chig: Babble.\n");
>                  addr->error |= USB_BABBLE;
>              }
> -            if (td->nak)
> -            {
> +            if (td->nak) {
>                  dprintf("NAK empfangen\n");
>                  addr->error |= USB_NAK;
>              }
> -            if (td->crc_time_err)
> -            {
> +            if (td->crc_time_err) {
>                  dprintf("CRC-Fehler oder Timeout\n");
>                  addr->error |= USB_CRC | USB_TIMEOUT;
>              }
> -            if (td->bitstuff_err)
> -            {
> +            if (td->bitstuff_err) {
>                  dprintf("Bitstufffehler\n");
>                  addr->error |= USB_BITSTUFF;
>              }

Most likely there are some more points. This patch is just unreadable
and I can't be bothered reviewing each patch hunk if anything other than
style is changed.