Changeset ae3a941 in mainline for uspace/drv/bus/usb/xhci

Timestamp:

2018-02-26T16:51:40Z (8 years ago)

Author:

Ondřej Hlavatý <aearsis@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

e773f58

Parents:

3692678

Message:

usb: cstyle

Location:

uspace/drv/bus/usb/xhci

Files:

• bus.h (modified) (1 diff)
• commands.c (modified) (7 diffs)
• commands.h (modified) (1 diff)
• debug.h (modified) (1 diff)
• device.h (modified) (2 diffs)
• endpoint.h (modified) (6 diffs)
• hc.h (modified) (1 diff)
• hw_struct/context.h (modified) (6 diffs)
• hw_struct/trb.h (modified) (1 diff)
• isoch.h (modified) (2 diffs)
• main.c (modified) (1 diff)
• streams.h (modified) (2 diffs)
• transfers.h (modified) (1 diff)
• trb_ring.h (modified) (4 diffs)

uspace/drv/bus/usb/xhci/bus.h

@@ -45 +45 @@
 /** Endpoint management structure */
 typedef struct xhci_bus {
-        bus_t base;             /**< Inheritance. Keep this first. */
-
-        xhci_hc_t *hc;                          /**< Pointer to managing HC (to issue commands) */
-
-        xhci_device_t **devices_by_slot;        /**< Devices by Slot ID */
+        bus_t base; /**< Inheritance. Keep this first. */
+        xhci_hc_t *hc; /**< Pointer to managing HC (to issue commands) */
+        xhci_device_t **devices_by_slot; /**< Devices by Slot ID */
 } xhci_bus_t;
 

uspace/drv/bus/usb/xhci/commands.c

@@ -150 +150 @@
 
         while (cmd_link != NULL) {
-                xhci_cmd_t *cmd = list_get_instance(cmd_link, xhci_cmd_t, _header.link);
+                xhci_cmd_t *cmd = list_get_instance(cmd_link, xhci_cmd_t,
+                    _header.link);
 
                 if (cmd->_header.trb_phys == phys)
@@ -158 +159 @@
         }
 
-        return cmd_link ? list_get_instance(cmd_link, xhci_cmd_t, _header.link)
-                : NULL;
+        return cmd_link
+            ? list_get_instance(cmd_link, xhci_cmd_t, _header.link)
+            : NULL;
 }
 
@@ -167 +169 @@
 
         cr->state = state;
-        if (state == XHCI_CR_STATE_OPEN
-            || state == XHCI_CR_STATE_CLOSED)
+        if (state == XHCI_CR_STATE_OPEN || state == XHCI_CR_STATE_CLOSED)
                 fibril_condvar_broadcast(&cr->state_cv);
 }
@@ -206 +207 @@
         }
 
-        usb_log_debug("Sending command %s", xhci_trb_str_type(TRB_TYPE(cmd->_header.trb)));
+        usb_log_debug("Sending command %s",
+            xhci_trb_str_type(TRB_TYPE(cmd->_header.trb)));
 
         list_append(&cmd->_header.link, &cr->cmd_list);
@@ -337 +339 @@
                 usb_log_error("Command resulted in error: %s.", trb_codes[code]);
         else
-                usb_log_error("Command resulted in reserved or vendor specific error.");
+                usb_log_error("Command resulted in reserved or "
+                    "vendor specific error.");
 }
 
@@ -657 +660 @@
         }
 
-        usb_log_error("Timeout while waiting for command: aborting current command.");
+        usb_log_error("Timeout while waiting for command: "
+            "aborting current command.");
 
         cr_set_state(cr, XHCI_CR_STATE_CHANGING);
@@ -663 +667 @@
         abort_command_ring(hc);
 
-        fibril_condvar_wait_timeout(&cr->stopped_cv, &cr->guard, XHCI_CR_ABORT_TIMEOUT);
+        fibril_condvar_wait_timeout(&cr->stopped_cv, &cr->guard,
+            XHCI_CR_ABORT_TIMEOUT);
 
         if (XHCI_REG_RD(hc->op_regs, XHCI_OP_CRR)) {

uspace/drv/bus/usb/xhci/commands.h

@@ -70 +70 @@
 
 typedef enum {
-        XHCI_CR_STATE_CLOSED,           /**< Commands are rejected with ENAK. */
-        XHCI_CR_STATE_OPEN,             /**< Commands are enqueued normally. */
-        XHCI_CR_STATE_CHANGING,         /**< Commands wait until state changes. */
-        XHCI_CR_STATE_FULL,             /**< Commands wait until something completes. */
+        XHCI_CR_STATE_CLOSED,   /**< Commands are rejected with ENAK. */
+        XHCI_CR_STATE_OPEN,     /**< Commands are enqueued normally. */
+        XHCI_CR_STATE_CHANGING, /**< Commands wait until state changes. */
+        XHCI_CR_STATE_FULL,     /**< Commands wait until something completes. */
 } xhci_cr_state_t;
 

uspace/drv/bus/usb/xhci/debug.h

@@ -63 +63 @@
 extern void xhci_dump_slot_ctx(const struct xhci_slot_ctx *);
 extern void xhci_dump_endpoint_ctx(const struct xhci_endpoint_ctx *);
-extern void xhci_dump_input_ctx(const struct xhci_hc *, const struct xhci_input_ctx *);
+extern void xhci_dump_input_ctx(const struct xhci_hc *,
+    const struct xhci_input_ctx *);
 
 #endif

uspace/drv/bus/usb/xhci/device.h

@@ -62 +62 @@
 
 #define XHCI_DEV_FMT  "(%s, slot %d)"
-#define XHCI_DEV_ARGS(dev)               ddf_fun_get_name((dev).base.fun), (dev).slot_id
+#define XHCI_DEV_ARGS(dev)      ddf_fun_get_name((dev).base.fun), (dev).slot_id
 
 /* Bus callbacks */
@@ -72 +72 @@
 void xhci_setup_slot_context(xhci_device_t *, xhci_slot_ctx_t *);
 
-static inline xhci_device_t * xhci_device_get(device_t *dev)
+static inline xhci_device_t *xhci_device_get(device_t *dev)
 {
         assert(dev);

uspace/drv/bus/usb/xhci/endpoint.h

@@ -76 +76 @@
         xhci_trb_ring_t ring;
 
-        /** Primary stream context data array (or NULL if endpoint doesn't use streams). */
+        /**
+         * Primary stream context data array
+         * (or NULL if endpoint doesn't use streams).
+         */
         xhci_stream_data_t *primary_stream_data_array;
 
@@ -83 +86 @@
         dma_buffer_t primary_stream_ctx_dma;
 
-        /** Size of the allocated primary stream data array (and context array). */
+        /** Size of the allocated primary stream data and context array. */
         uint16_t primary_stream_data_size;
 
@@ -89 +92 @@
         uint32_t max_streams;
 
-        /** Maximum number of consecutive USB transactions (0-15) that should be executed per scheduling opportunity */
+        /**
+         * Maximum number of consecutive USB transactions (0-15) that
+         * should be executed per scheduling opportunity
+         */
         uint8_t max_burst;
 
-        /** Maximum number of bursts within an interval that this endpoint supports */
+        /**
+         * Maximum number of bursts within an interval that
+         * this endpoint supports
+         */
         uint8_t mult;
 
-        /** Scheduling interval for periodic endpoints, as a number of 125us units. (0 - 2^16) */
+        /**
+         * Scheduling interval for periodic endpoints,
+         * as a number of 125us units. (0 - 2^16)
+         */
         uint32_t interval;
 
-        /** This field is a valid pointer for (and only for) isochronous transfers. */
+        /**
+         * This field is a valid pointer for (and only for) isochronous
+         * endpoints.
+         */
         xhci_isoch_t isoch [0];
 } xhci_endpoint_t;
@@ -111 +126 @@
 extern int xhci_endpoint_type(xhci_endpoint_t *ep);
 
-extern endpoint_t *xhci_endpoint_create(device_t *, const usb_endpoint_descriptors_t *);
+extern endpoint_t *xhci_endpoint_create(device_t *,
+    const usb_endpoint_descriptors_t *);
 extern errno_t xhci_endpoint_register(endpoint_t *);
 extern void xhci_endpoint_unregister(endpoint_t *);
@@ -122 +138 @@
 extern errno_t xhci_endpoint_clear_halt(xhci_endpoint_t *, unsigned);
 
-static inline xhci_endpoint_t * xhci_endpoint_get(endpoint_t *ep)
+static inline xhci_endpoint_t *xhci_endpoint_get(endpoint_t *ep)
 {
         assert(ep);
@@ -128 +144 @@
 }
 
-static inline xhci_device_t * xhci_ep_to_dev(xhci_endpoint_t *ep)
+static inline xhci_device_t *xhci_ep_to_dev(xhci_endpoint_t *ep)
 {
         assert(ep);

uspace/drv/bus/usb/xhci/hc.h

@@ -95 +95 @@
         bool ac64;
         bool csz;
-        uint64_t wrap_time;             /** The last time when mfindex wrap happened */
-        uint64_t wrap_count;    /** Amount of mfindex wraps HC has done */
-        unsigned ist;                   /**< IST in microframes */
+        uint64_t wrap_time;     /**< The last time when mfindex wrap happened */
+        uint64_t wrap_count;    /**< Amount of mfindex wraps HC has done */
+        unsigned ist;           /**< IST in microframes */
 
         /** Port speed mapping */

uspace/drv/bus/usb/xhci/hw_struct/context.h

@@ -179 +179 @@
 #define XHCI_CTX_SIZE_SMALL 32
 #define XHCI_ONE_CTX_SIZE(hc) (XHCI_CTX_SIZE_SMALL << hc->csz)
-#define XHCI_GET_CTX_FIELD(type, ctx, hc, ci) (xhci_##type##_ctx_to_charptr(ctx) + (ci) * XHCI_ONE_CTX_SIZE(hc))
+#define XHCI_GET_CTX_FIELD(type, ctx, hc, ci) \
+    (xhci_##type##_ctx_to_charptr(ctx) + (ci) * XHCI_ONE_CTX_SIZE(hc))
 
 /**
@@ -185 +186 @@
  */
 #define XHCI_DEVICE_CTX_SIZE(hc) ((1 + XHCI_EP_COUNT) * XHCI_ONE_CTX_SIZE(hc))
-#define XHCI_GET_EP_CTX(dev_ctx, hc, dci) ((xhci_ep_ctx_t *)   XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), (dci)))
-#define XHCI_GET_SLOT_CTX(dev_ctx, hc)    ((xhci_slot_ctx_t *) XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), 0))
+#define XHCI_GET_EP_CTX(dev_ctx, hc, dci) \
+    ((xhci_ep_ctx_t *)   XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), (dci)))
+#define XHCI_GET_SLOT_CTX(dev_ctx, hc) \
+    ((xhci_slot_ctx_t *) XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), 0))
 
 /**
@@ -210 +213 @@
 typedef struct xhci_stream_ctx {
         uint64_t data [2];
-#define XHCI_STREAM_DCS(ctx)       XHCI_QWORD_EXTRACT((ctx).data[0],  0, 0)
-#define XHCI_STREAM_SCT(ctx)       XHCI_QWORD_EXTRACT((ctx).data[0],  3, 1)
-#define XHCI_STREAM_DEQ_PTR(ctx)   (XHCI_QWORD_EXTRACT((ctx).data[0], 63, 4) << 4)
-#define XHCI_STREAM_EDTLA(ctx)     XHCI_QWORD_EXTRACT((ctx).data[1], 24, 0)
+#define XHCI_STREAM_DCS(ctx)     XHCI_QWORD_EXTRACT((ctx).data[0],  0, 0)
+#define XHCI_STREAM_SCT(ctx)     XHCI_QWORD_EXTRACT((ctx).data[0],  3, 1)
+#define XHCI_STREAM_DEQ_PTR(ctx) (XHCI_QWORD_EXTRACT((ctx).data[0], 63, 4) << 4)
+#define XHCI_STREAM_EDTLA(ctx)   XHCI_QWORD_EXTRACT((ctx).data[1], 24, 0)
 
 #define XHCI_STREAM_SCT_SET(ctx, val) \
@@ -232 +235 @@
         uint32_t data [8];
 #define XHCI_INPUT_CTRL_CTX_DROP(ctx, idx) \
-        XHCI_DWORD_EXTRACT((ctx).data[0], (idx), (idx))
+    XHCI_DWORD_EXTRACT((ctx).data[0], (idx), (idx))
 
 #define XHCI_INPUT_CTRL_CTX_DROP_SET(ctx, idx) (ctx).data[0] |= (1 << (idx))
@@ -238 +241 @@
 
 #define XHCI_INPUT_CTRL_CTX_ADD(ctx, idx) \
-        XHCI_DWORD_EXTRACT((ctx).data[1], (idx), (idx))
+    XHCI_DWORD_EXTRACT((ctx).data[1], (idx), (idx))
 
 #define XHCI_INPUT_CTRL_CTX_ADD_SET(ctx, idx) (ctx).data[1] |= (1 << (idx))
 #define XHCI_INPUT_CTRL_CTX_ADD_CLEAR(ctx, idx) (ctx).data[1] &= ~(1 << (idx))
 
-#define XHCI_INPUT_CTRL_CTX_CONFIG_VALUE(ctx)   XHCI_DWORD_EXTRACT((ctx).data[7],  7,  0)
-#define XHCI_INPUT_CTRL_CTX_IFACE_NUMBER(ctx)   XHCI_DWORD_EXTRACT((ctx).data[7], 15,  8)
-#define XHCI_INPUT_CTRL_CTX_ALTER_SETTING(ctx)  XHCI_DWORD_EXTRACT((ctx).data[7], 23, 16)
+#define XHCI_INPUT_CTRL_CTX_CONFIG_VALUE(ctx) \
+    XHCI_DWORD_EXTRACT((ctx).data[7],  7,  0)
+#define XHCI_INPUT_CTRL_CTX_IFACE_NUMBER(ctx) \
+    XHCI_DWORD_EXTRACT((ctx).data[7], 15,  8)
+#define XHCI_INPUT_CTRL_CTX_ALTER_SETTING(ctx) \
+    XHCI_DWORD_EXTRACT((ctx).data[7], 23, 16)
 } __attribute__((packed)) xhci_input_ctrl_ctx_t;
 
@@ -252 +258 @@
  */
 #define XHCI_INPUT_CTX_SIZE(hc) (XHCI_ONE_CTX_SIZE(hc) + XHCI_DEVICE_CTX_SIZE(hc))
-#define XHCI_GET_CTRL_CTX(ictx, hc)  ((xhci_input_ctrl_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 0))
-#define XHCI_GET_DEVICE_CTX(dev_ctx, hc) ((xhci_device_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 1))
+#define XHCI_GET_CTRL_CTX(ictx, hc) \
+    ((xhci_input_ctrl_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 0))
+#define XHCI_GET_DEVICE_CTX(dev_ctx, hc) \
+    ((xhci_device_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 1))
 
 typedef struct xhci_input_ctx {

uspace/drv/bus/usb/xhci/hw_struct/trb.h

@@ -160 +160 @@
  * The Chain bit is valid only in specific TRB types.
  */
-static inline bool xhci_trb_is_chained(xhci_trb_t *trb) {
+static inline bool xhci_trb_is_chained(xhci_trb_t *trb)
+{
         const int type = TRB_TYPE(*trb);
         const bool chain_bit = XHCI_DWORD_EXTRACT(trb->control, 4, 4);

uspace/drv/bus/usb/xhci/isoch.h

@@ -84 +84 @@
         fibril_timer_t *reset_timer;
 
-        /** The maximum size of an isochronous transfer and therefore the size of buffers */
+        /**
+         * The maximum size of an isochronous transfer
+         * and therefore the size of buffers
+         */
         size_t max_size;
 
@@ -123 +126 @@
 extern errno_t isoch_schedule_out(xhci_transfer_t *);
 extern errno_t isoch_schedule_in(xhci_transfer_t *);
-extern void isoch_handle_transfer_event(xhci_hc_t *, xhci_endpoint_t *, xhci_trb_t *);
+extern void isoch_handle_transfer_event(xhci_hc_t *, xhci_endpoint_t *,
+    xhci_trb_t *);
 
 #endif

uspace/drv/bus/usb/xhci/main.c

@@ -68 +68 @@
 }
 
-static errno_t hcd_irq_code_gen(irq_code_t *code, hc_device_t *hcd, const hw_res_list_parsed_t *hw_res, int *irq)
+static errno_t hcd_irq_code_gen(irq_code_t *code, hc_device_t *hcd,
+    const hw_res_list_parsed_t *hw_res, int *irq)
 {
         xhci_hc_t *hc = hcd_to_hc(hcd);

uspace/drv/bus/usb/xhci/streams.h

@@ -48 +48 @@
         xhci_trb_ring_t ring;
 
-        /** Pointer to the array of secondary stream context data for primary data. */
+        /**
+         * Pointer to the array of secondary stream context data for primary
+         * data.
+         */
         xhci_stream_data_t *secondary_data;
 
@@ -61 +64 @@
 } xhci_stream_data_t;
 
-extern xhci_stream_data_t *xhci_get_stream_ctx_data(xhci_endpoint_t *ep, uint32_t stream_id);
-extern void xhci_stream_free_ds(xhci_endpoint_t *xhci_ep);
+extern xhci_stream_data_t *xhci_get_stream_ctx_data(xhci_endpoint_t *, uint32_t);
+extern void xhci_stream_free_ds(xhci_endpoint_t *);
 
-extern errno_t xhci_endpoint_remove_streams(xhci_hc_t *hc, xhci_device_t *dev, xhci_endpoint_t *xhci_ep);
-extern errno_t xhci_endpoint_request_primary_streams(xhci_hc_t *hc, xhci_device_t *dev,
-    xhci_endpoint_t *xhci_ep, unsigned count);
-extern errno_t xhci_endpoint_request_secondary_streams(xhci_hc_t *hc, xhci_device_t *dev,
-    xhci_endpoint_t *xhci_ep, unsigned *sizes, unsigned count);
+extern errno_t xhci_endpoint_remove_streams(xhci_hc_t *, xhci_device_t *,
+    xhci_endpoint_t *);
+extern errno_t xhci_endpoint_request_primary_streams(xhci_hc_t *,
+    xhci_device_t *, xhci_endpoint_t *, unsigned);
+extern errno_t xhci_endpoint_request_secondary_streams(xhci_hc_t *,
+    xhci_device_t *, xhci_endpoint_t *, unsigned *, unsigned);
 
 #endif

uspace/drv/bus/usb/xhci/transfers.h

@@ -59 +59 @@
 extern void xhci_transfer_destroy(usb_transfer_batch_t *);
 
-static inline xhci_transfer_t *xhci_transfer_from_batch(usb_transfer_batch_t *batch)
+static inline xhci_transfer_t *xhci_transfer_from_batch(
+    usb_transfer_batch_t *batch)
 {
         assert(batch);

uspace/drv/bus/usb/xhci/trb_ring.h

@@ -57 +57 @@
  */
 typedef struct xhci_trb_ring {
-        list_t segments;                /* List of assigned segments */
-        int segment_count;              /* Number of segments assigned */
+        list_t segments;                /**< List of assigned segments */
+        int segment_count;              /**< Number of segments assigned */
 
-        /*
-         * As the link TRBs connect physical addresses, we need to keep track of
-         * active segment in virtual memory. The enqueue ptr should always belong
-         * to the enqueue segment.
+        /**
+         * As the link TRBs connect physical addresses, we need to keep track
+         * of active segment in virtual memory. The enqueue ptr should always
+         * belong to the enqueue segment.
          */
         trb_segment_t *enqueue_segment;
         xhci_trb_t *enqueue_trb;
 
-        uintptr_t dequeue;              /* Last reported position of the dequeue pointer */
-        bool pcs;                       /* Producer Cycle State: section 4.9.2 */
+        uintptr_t dequeue; /**< Last reported position of the dequeue pointer */
+        bool pcs;          /**< Producer Cycle State: section 4.9.2 */
 
         fibril_mutex_t guard;
@@ -76 +76 @@
 extern errno_t xhci_trb_ring_init(xhci_trb_ring_t *, size_t);
 extern void xhci_trb_ring_fini(xhci_trb_ring_t *);
-extern errno_t xhci_trb_ring_enqueue(xhci_trb_ring_t *, xhci_trb_t *, uintptr_t *);
-extern errno_t xhci_trb_ring_enqueue_multiple(xhci_trb_ring_t *, xhci_trb_t *, size_t, uintptr_t *);
+extern errno_t xhci_trb_ring_enqueue(xhci_trb_ring_t *, xhci_trb_t *,
+    uintptr_t *);
+extern errno_t xhci_trb_ring_enqueue_multiple(xhci_trb_ring_t *, xhci_trb_t *,
+    size_t, uintptr_t *);
 extern size_t xhci_trb_ring_size(xhci_trb_ring_t *);
 
-extern void xhci_trb_ring_reset_dequeue_state(xhci_trb_ring_t *ring, uintptr_t *addr);
+extern void xhci_trb_ring_reset_dequeue_state(xhci_trb_ring_t *, uintptr_t *);
 
 /**
@@ -86 +88 @@
  * pointer inside the ring. Otherwise, the ring will soon show up as full.
  */
-static inline void xhci_trb_ring_update_dequeue(xhci_trb_ring_t *ring, uintptr_t phys)
+static inline void xhci_trb_ring_update_dequeue(xhci_trb_ring_t *ring,
+    uintptr_t phys)
 {
         ring->dequeue = phys;
@@ -95 +98 @@
  */
 typedef struct xhci_event_ring {
-        list_t segments;                /* List of assigned segments */
-        int segment_count;              /* Number of segments assigned */
+        list_t segments;                /**< List of assigned segments */
+        int segment_count;              /**< Number of segments assigned */
 
-        trb_segment_t *dequeue_segment; /* Current segment of the dequeue ptr */
-        xhci_trb_t *dequeue_trb;        /* Next TRB to be processed */
-        uintptr_t dequeue_ptr;          /* Physical address of the ERDP to be reported to the HC */
+        trb_segment_t *dequeue_segment; /**< Current segment */
+        xhci_trb_t *dequeue_trb;        /**< Next TRB to be processed */
+        uintptr_t dequeue_ptr;  /**< Physical ERDP to be reported to the HC */
 
-        dma_buffer_t erst;              /* ERST given to the HC */
+        dma_buffer_t erst;      /**< ERST given to the HC */
 
-        bool ccs;                       /* Consumer Cycle State: section 4.9.2 */
+        bool ccs;               /**< Consumer Cycle State: section 4.9.2 */
 
         fibril_mutex_t guard;