source: mainline/uspace/drv/bus/usb/xhci/hw_struct/context.h@ b2dca8de

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since b2dca8de was ae3a941, checked in by Ondřej Hlavatý <aearsis@…>, 8 years ago

usb: cstyle
  • Property mode set to 100644
File size: 10.6 KB
Line 
1/*
2 * Copyright (c) 2018 Ondrej Hlavaty, Michal Staruch, Jaroslav Jindrak, Jan Hrach
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup drvusbxhci
30 * @{
31 */
32/** @file
33 * Context data structures of the xHC.
34 *
35 * Most of them are to be initialized to zero and passed ownership to the HC,
36 * so they are mostly read-only.
37 *
38 * Feel free to write a setter when in need.
39 */
40
41#ifndef XHCI_CONTEXT_H
42#define XHCI_CONTEXT_H
43
44#include <stdint.h>
45#include "common.h"
46
47/**
48 * Endpoint context: section 6.2.3
49 */
50typedef struct xhci_endpoint_ctx {
51 xhci_dword_t data[2];
52 xhci_qword_t data2;
53 xhci_dword_t data3;
54 xhci_dword_t reserved[3];
55
56#define XHCI_EP_COUNT 31
57
58#define XHCI_EP_TYPE_ISOCH_OUT 1
59#define XHCI_EP_TYPE_BULK_OUT 2
60#define XHCI_EP_TYPE_INTERRUPT_OUT 3
61#define XHCI_EP_TYPE_CONTROL 4
62#define XHCI_EP_TYPE_ISOCH_IN 5
63#define XHCI_EP_TYPE_BULK_IN 6
64#define XHCI_EP_TYPE_INTERRUPT_IN 7
65
66#define XHCI_EP_TYPE_SET(ctx, val) \
67 xhci_dword_set_bits(&(ctx).data[1], val, 5, 3)
68#define XHCI_EP_MAX_PACKET_SIZE_SET(ctx, val) \
69 xhci_dword_set_bits(&(ctx).data[1], val, 31, 16)
70#define XHCI_EP_MAX_BURST_SIZE_SET(ctx, val) \
71 xhci_dword_set_bits(&(ctx).data[1], val, 15, 8)
72#define XHCI_EP_TR_DPTR_SET(ctx, val) \
73 xhci_qword_set_bits(&(ctx).data2, (val >> 4), 63, 4)
74#define XHCI_EP_DCS_SET(ctx, val) \
75 xhci_qword_set_bits(&(ctx).data2, val, 0, 0)
76#define XHCI_EP_MAX_ESIT_PAYLOAD_LO_SET(ctx, val) \
77 xhci_dword_set_bits(&(ctx).data3, val, 31, 16)
78#define XHCI_EP_MAX_ESIT_PAYLOAD_HI_SET(ctx, val) \
79 xhci_dword_set_bits(&(ctx).data[0], val, 31, 24)
80#define XHCI_EP_INTERVAL_SET(ctx, val) \
81 xhci_dword_set_bits(&(ctx).data[0], val, 23, 16)
82#define XHCI_EP_MAX_P_STREAMS_SET(ctx, val) \
83 xhci_dword_set_bits(&(ctx).data[0], val, 14, 10)
84#define XHCI_EP_LSA_SET(ctx, val) \
85 xhci_dword_set_bits(&(ctx).data[0], val, 15, 15)
86#define XHCI_EP_MULT_SET(ctx, val) \
87 xhci_dword_set_bits(&(ctx).data[0], val, 9, 8)
88#define XHCI_EP_ERROR_COUNT_SET(ctx, val) \
89 xhci_dword_set_bits(&(ctx).data[1], val, 2, 1)
90
91#define XHCI_EP_STATE(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 2, 0)
92#define XHCI_EP_MULT(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 9, 8)
93#define XHCI_EP_MAX_P_STREAMS(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 14, 10)
94#define XHCI_EP_LSA(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 15, 15)
95#define XHCI_EP_INTERVAL(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 23, 16)
96
97#define XHCI_EP_ERROR_COUNT(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 2, 1)
98#define XHCI_EP_TYPE(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 5, 3)
99#define XHCI_EP_HID(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 7, 7)
100#define XHCI_EP_MAX_BURST_SIZE(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 15, 8)
101#define XHCI_EP_MAX_PACKET_SIZE(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 31, 16)
102
103#define XHCI_EP_DCS(ctx) XHCI_QWORD_EXTRACT((ctx).data2, 0, 0)
104#define XHCI_EP_TR_DPTR(ctx) XHCI_QWORD_EXTRACT((ctx).data2, 63, 4)
105
106#define XHCI_EP_MAX_ESIT_PAYLOAD_LO(ctx) XHCI_DWORD_EXTRACT((ctx).data3, 31, 16)
107#define XHCI_EP_MAX_ESIT_PAYLOAD_HI(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 31, 24)
108
109} __attribute__((packed)) xhci_ep_ctx_t;
110
111enum {
112 EP_STATE_DISABLED = 0,
113 EP_STATE_RUNNING = 1,
114 EP_STATE_HALTED = 2,
115 EP_STATE_STOPPED = 3,
116 EP_STATE_ERROR = 4,
117};
118
119/**
120 * Slot context: section 6.2.2
121 */
122typedef struct xhci_slot_ctx {
123 xhci_dword_t data [4];
124 xhci_dword_t reserved [4];
125
126#define XHCI_SLOT_ROUTE_STRING_SET(ctx, val) \
127 xhci_dword_set_bits(&(ctx).data[0], (val & 0xFFFFF), 19, 0)
128#define XHCI_SLOT_SPEED_SET(ctx, val) \
129 xhci_dword_set_bits(&(ctx).data[0], (val & 0xF), 23, 20)
130#define XHCI_SLOT_MTT_SET(ctx, val) \
131 xhci_dword_set_bits(&(ctx).data[0], !!val, 25, 25)
132#define XHCI_SLOT_HUB_SET(ctx, val) \
133 xhci_dword_set_bits(&(ctx).data[0], !!val, 26, 26)
134#define XHCI_SLOT_CTX_ENTRIES_SET(ctx, val) \
135 xhci_dword_set_bits(&(ctx).data[0], val, 31, 27)
136
137#define XHCI_SLOT_ROOT_HUB_PORT_SET(ctx, val) \
138 xhci_dword_set_bits(&(ctx).data[1], val, 23, 16)
139#define XHCI_SLOT_NUM_PORTS_SET(ctx, val) \
140 xhci_dword_set_bits(&(ctx).data[1], val, 31, 24)
141
142#define XHCI_SLOT_TT_HUB_SLOT_ID_SET(ctx, val) \
143 xhci_dword_set_bits(&(ctx).data[2], (val & 0xFF), 7, 0)
144#define XHCI_SLOT_TT_HUB_PORT_SET(ctx, val) \
145 xhci_dword_set_bits(&(ctx).data[2], (val & 0xFF), 15, 8)
146#define XHCI_SLOT_TT_THINK_TIME_SET(ctx, val) \
147 xhci_dword_set_bits(&(ctx).data[2], (val & 0xFF), 17, 16)
148
149#define XHCI_SLOT_ROUTE_STRING(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 19, 0)
150#define XHCI_SLOT_SPEED(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 23, 20)
151#define XHCI_SLOT_MTT(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 25, 25)
152#define XHCI_SLOT_HUB(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 26, 26)
153#define XHCI_SLOT_CTX_ENTRIES(ctx) XHCI_DWORD_EXTRACT((ctx).data[0], 31, 27)
154
155#define XHCI_SLOT_MAX_EXIT_LATENCY(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 15, 0)
156#define XHCI_SLOT_ROOT_HUB_PORT(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 23, 16)
157#define XHCI_SLOT_NUM_PORTS(ctx) XHCI_DWORD_EXTRACT((ctx).data[1], 31, 24)
158
159#define XHCI_SLOT_TT_HUB_SLOT_ID(ctx) XHCI_DWORD_EXTRACT((ctx).data[2], 7, 0)
160#define XHCI_SLOT_TT_PORT_NUM(ctx) XHCI_DWORD_EXTRACT((ctx).data[2], 15, 8)
161#define XHCI_SLOT_TT_THINK_TIME(ctx) XHCI_DWORD_EXTRACT((ctx).data[2], 17, 16)
162#define XHCI_SLOT_INTERRUPTER(ctx) XHCI_DWORD_EXTRACT((ctx).data[2], 31, 22)
163
164#define XHCI_SLOT_DEVICE_ADDRESS(ctx) XHCI_DWORD_EXTRACT((ctx).data[3], 7, 0)
165#define XHCI_SLOT_STATE(ctx) XHCI_DWORD_EXTRACT((ctx).data[3], 31, 27)
166
167} __attribute__((packed)) xhci_slot_ctx_t;
168
169enum {
170 SLOT_STATE_DISABLED = 0,
171 SLOT_STATE_DEFAULT = 1,
172 SLOT_STATE_ADDRESS = 2,
173 SLOT_STATE_CONFIGURED = 3,
174};
175
176/**
177 * Handling HCs with 32 or 64-bytes context size (CSZ)
178 */
179#define XHCI_CTX_SIZE_SMALL 32
180#define XHCI_ONE_CTX_SIZE(hc) (XHCI_CTX_SIZE_SMALL << hc->csz)
181#define XHCI_GET_CTX_FIELD(type, ctx, hc, ci) \
182 (xhci_##type##_ctx_to_charptr(ctx) + (ci) * XHCI_ONE_CTX_SIZE(hc))
183
184/**
185 * Device context: section 6.2.1
186 */
187#define XHCI_DEVICE_CTX_SIZE(hc) ((1 + XHCI_EP_COUNT) * XHCI_ONE_CTX_SIZE(hc))
188#define XHCI_GET_EP_CTX(dev_ctx, hc, dci) \
189 ((xhci_ep_ctx_t *) XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), (dci)))
190#define XHCI_GET_SLOT_CTX(dev_ctx, hc) \
191 ((xhci_slot_ctx_t *) XHCI_GET_CTX_FIELD(device, (dev_ctx), (hc), 0))
192
193/**
194 * As control, slot and endpoint contexts differ in size on different HCs,
195 * we need to use macros to access them at the correct offsets. The following
196 * empty structs (xhci_device_ctx_t and xhci_input_ctx_t) are used only as
197 * void pointers for type-checking.
198 */
199typedef struct xhci_device_ctx {
200} xhci_device_ctx_t;
201
202/**
203 * Force type checking.
204 */
205static inline char *xhci_device_ctx_to_charptr(const xhci_device_ctx_t *ctx)
206{
207 return (char *) ctx;
208}
209
210/**
211 * Stream context: section 6.2.4 {
212 */
213typedef struct xhci_stream_ctx {
214 uint64_t data [2];
215#define XHCI_STREAM_DCS(ctx) XHCI_QWORD_EXTRACT((ctx).data[0], 0, 0)
216#define XHCI_STREAM_SCT(ctx) XHCI_QWORD_EXTRACT((ctx).data[0], 3, 1)
217#define XHCI_STREAM_DEQ_PTR(ctx) (XHCI_QWORD_EXTRACT((ctx).data[0], 63, 4) << 4)
218#define XHCI_STREAM_EDTLA(ctx) XHCI_QWORD_EXTRACT((ctx).data[1], 24, 0)
219
220#define XHCI_STREAM_SCT_SET(ctx, val) \
221 xhci_qword_set_bits(&(ctx).data[0], val, 3, 1)
222#define XHCI_STREAM_DEQ_PTR_SET(ctx, val) \
223 xhci_qword_set_bits(&(ctx).data[0], (val >> 4), 63, 4)
224} __attribute__((packed)) xhci_stream_ctx_t;
225
226/**
227 * Input control context: section 6.2.5.1
228 * Note: According to section 6.2.5.1 figure 78,
229 * the context size register value in hccparams1
230 * dictates whether input control context shall have
231 * 32 or 64 bytes, but in any case only dwords 0, 1 and 7
232 * are used, the rest are reserved.
233 */
234typedef struct xhci_input_ctrl_ctx {
235 uint32_t data [8];
236#define XHCI_INPUT_CTRL_CTX_DROP(ctx, idx) \
237 XHCI_DWORD_EXTRACT((ctx).data[0], (idx), (idx))
238
239#define XHCI_INPUT_CTRL_CTX_DROP_SET(ctx, idx) (ctx).data[0] |= (1 << (idx))
240#define XHCI_INPUT_CTRL_CTX_DROP_CLEAR(ctx, idx) (ctx).data[0] &= ~(1 << (idx))
241
242#define XHCI_INPUT_CTRL_CTX_ADD(ctx, idx) \
243 XHCI_DWORD_EXTRACT((ctx).data[1], (idx), (idx))
244
245#define XHCI_INPUT_CTRL_CTX_ADD_SET(ctx, idx) (ctx).data[1] |= (1 << (idx))
246#define XHCI_INPUT_CTRL_CTX_ADD_CLEAR(ctx, idx) (ctx).data[1] &= ~(1 << (idx))
247
248#define XHCI_INPUT_CTRL_CTX_CONFIG_VALUE(ctx) \
249 XHCI_DWORD_EXTRACT((ctx).data[7], 7, 0)
250#define XHCI_INPUT_CTRL_CTX_IFACE_NUMBER(ctx) \
251 XHCI_DWORD_EXTRACT((ctx).data[7], 15, 8)
252#define XHCI_INPUT_CTRL_CTX_ALTER_SETTING(ctx) \
253 XHCI_DWORD_EXTRACT((ctx).data[7], 23, 16)
254} __attribute__((packed)) xhci_input_ctrl_ctx_t;
255
256/**
257 * Input context: section 6.2.5
258 */
259#define XHCI_INPUT_CTX_SIZE(hc) (XHCI_ONE_CTX_SIZE(hc) + XHCI_DEVICE_CTX_SIZE(hc))
260#define XHCI_GET_CTRL_CTX(ictx, hc) \
261 ((xhci_input_ctrl_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 0))
262#define XHCI_GET_DEVICE_CTX(dev_ctx, hc) \
263 ((xhci_device_ctx_t *) XHCI_GET_CTX_FIELD(input, (ictx), (hc), 1))
264
265typedef struct xhci_input_ctx {
266} xhci_input_ctx_t;
267
268/**
269 * Force type checking.
270 */
271static inline char *xhci_input_ctx_to_charptr(const xhci_input_ctx_t *ctx)
272{
273 return (char *) ctx;
274}
275
276/**
277 * Port bandwidth context: section 6.2.6
278 * The number of ports depends on the amount of ports available to the hub.
279 */
280typedef struct xhci_port_bandwidth_ctx {
281 uint8_t reserved;
282 uint8_t ports [];
283} __attribute__((packed)) xhci_port_bandwidth_ctx_t;
284
285#endif
Note: See TracBrowser for help on using the repository browser.