xref: /illumos-gate/usr/src/uts/common/sys/usb/hcd/ehci/ehcid.h (revision 4299bd645be7ebf435e24cf6731c42835ab5296e)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 #ifndef _SYS_USB_EHCID_H
26 #define	_SYS_USB_EHCID_H
27 
28 
29 #ifdef	__cplusplus
30 extern "C" {
31 #endif
32 
33 /*
34  * Enchanced Host Controller Driver (EHCI)
35  *
36  * The EHCI driver is a software driver which interfaces to the Universal
37  * Serial Bus layer (USBA) and the Host Controller (HC). The interface to
38  * the Host Controller is defined by the EHCI Host Controller Interface.
39  *
40  * This header file describes the data structures and function prototypes
41  * required for the EHCI Driver to maintain state of Host Controller (HC),
42  * to perform different USB transfers and for the bandwidth allocations.
43  */
44 
45 #include <sys/usb/hcd/ehci/ehci.h>
46 #include <sys/usb/hcd/ehci/ehci_hub.h>
47 
48 
49 /*
50  * EHCI Bandwidth Maintainence Structure.
51  *
52  * The ehci_bandwidth array keeps track of allocated bandwidth for ehci
53  * host controller. There are 32 bandwidth lists corresponding to 32 ms
54  * periodic frame lists.  Each bandwidth list inturn will contain eight
55  * micro frame bandwidth lists.
56  */
57 #define	EHCI_MAX_UFRAMES	8	/* Max uframes 125us per frame */
58 
59 typedef struct ehci_frame_bandwidth {
60 	uint_t			ehci_allocated_frame_bandwidth;
61 	uint_t			ehci_micro_frame_bandwidth[EHCI_MAX_UFRAMES];
62 } ehci_frame_bandwidth_t;
63 
64 
65 /*
66  * EHCI Host Controller state structure
67  *
68  * The Host Controller Driver (HCD) maintains the state of Host Controller
69  * (HC). There is an ehci_state structure per instance	of the EHCI
70  * host controller.
71  */
72 typedef struct ehci_state {
73 	dev_info_t		*ehci_dip;		/* Dip of HC */
74 	uint_t			ehci_instance;
75 	usba_hcdi_ops_t		*ehci_hcdi_ops;		/* HCDI structure */
76 	uint_t			ehci_flags;		/* Used for cleanup */
77 	uint16_t		ehci_vendor_id;		/* chip vendor */
78 	uint16_t		ehci_device_id;		/* chip device */
79 	uint8_t			ehci_rev_id;		/* chip revison */
80 
81 	ddi_acc_handle_t	ehci_caps_handle;	/* Caps Reg Handle */
82 	ehci_caps_t		*ehci_capsp;		/* Capability Regs */
83 	ehci_regs_t		*ehci_regsp;		/* Operational Regs */
84 
85 	ddi_acc_handle_t	ehci_config_handle;	/* Config space hndle */
86 	uint_t			ehci_frame_interval;	/* Frme inter reg */
87 	ddi_dma_attr_t		ehci_dma_attr;		/* DMA attributes */
88 
89 	ddi_intr_handle_t	*ehci_htable;		/* intr handle */
90 	int			ehci_intr_type;		/* intr type used */
91 	int			ehci_intr_cnt;		/* # of intrs inuse */
92 	uint_t			ehci_intr_pri;		/* intr priority */
93 	int			ehci_intr_cap;		/* intr capabilities */
94 	boolean_t		ehci_msi_enabled;	/* default to true */
95 	kmutex_t		ehci_int_mutex;		/* Global EHCI mutex */
96 
97 	/* Periodic Frame List area */
98 	ehci_periodic_frame_list_t	*ehci_periodic_frame_list_tablep;
99 				/* Virtual Periodic Frame List ptr */
100 	ddi_dma_cookie_t	ehci_pflt_cookie;	/* DMA cookie */
101 	ddi_dma_handle_t	ehci_pflt_dma_handle;	/* DMA handle */
102 	ddi_acc_handle_t	ehci_pflt_mem_handle;	/* Memory handle */
103 
104 	/*
105 	 * There are two pools of memory. One pool contains the memory for
106 	 * the transfer descriptors and other pool contains the memory for
107 	 * the endpoint descriptors. The advantage of the pools is that it's
108 	 * easy to go back and forth between the iommu and the cpu addresses.
109 	 *
110 	 * The pools are protected by the ehci_int_mutex because the memory
111 	 * in the pools may be accessed by either the host controller or the
112 	 * host controller driver.
113 	 */
114 
115 	/* Endpoint descriptor pool */
116 	ehci_qh_t		*ehci_qh_pool_addr;	/* Start of the pool */
117 	ddi_dma_cookie_t	ehci_qh_pool_cookie;	/* DMA cookie */
118 	ddi_dma_handle_t	ehci_qh_pool_dma_handle;	/* DMA handle */
119 	ddi_acc_handle_t	ehci_qh_pool_mem_handle;	/* Mem handle */
120 	uint_t			ehci_dma_addr_bind_flag;	/* DMA flag */
121 
122 	/* General transfer descriptor pool */
123 	ehci_qtd_t		*ehci_qtd_pool_addr;	/* Start of the pool */
124 	ddi_dma_cookie_t	ehci_qtd_pool_cookie;	/* DMA cookie */
125 	ddi_dma_handle_t	ehci_qtd_pool_dma_handle;	/* DMA hndle */
126 	ddi_acc_handle_t	ehci_qtd_pool_mem_handle;	/* Mem hndle */
127 
128 	/* Isochronous transfer descriptor pool */
129 	ehci_itd_t		*ehci_itd_pool_addr;	/* Start of the pool */
130 	ddi_dma_cookie_t	ehci_itd_pool_cookie;	/* DMA cookie */
131 	ddi_dma_handle_t	ehci_itd_pool_dma_handle;	/* DMA hndle */
132 	ddi_acc_handle_t	ehci_itd_pool_mem_handle;	/* Mem hndle */
133 
134 	/* Condition variable for advance on Asynchronous Schedule */
135 	kcondvar_t		ehci_async_schedule_advance_cv;
136 
137 	/* Head of Asynchronous Schedule List */
138 	ehci_qh_t		*ehci_head_of_async_sched_list;
139 
140 	/*
141 	 * List of QTD inserted either into Asynchronous or Periodic
142 	 * Schedule lists.
143 	 */
144 	ehci_qtd_t		*ehci_active_qtd_list;
145 	/*
146 	 * List of ITD active itd list.
147 	 */
148 	ehci_itd_t		*ehci_active_itd_list;
149 
150 	/*
151 	 * Bandwidth fields
152 	 *
153 	 * The ehci_bandwidth array keeps track of allocated bandwidth for
154 	 * ehci host controller. There are 32 bandwidth lists corresponding
155 	 * to 32 ms periodic frame lists. Each bandwidth list in turn will
156 	 * contain eight micro frame bandwidth lists.
157 	 *
158 	 * ehci_min_frame_bandwidth field indicates least allocated milli
159 	 * second bandwidth list.
160 	 */
161 	ehci_frame_bandwidth_t	ehci_frame_bandwidth[EHCI_NUM_INTR_QH_LISTS];
162 
163 	/* No. of open pipes, async qh, and periodic qh */
164 	uint_t			ehci_open_pipe_count;
165 	uint_t			ehci_open_async_count;
166 	uint_t			ehci_open_periodic_count;
167 
168 	/* No. of async and periodic requests */
169 	uint_t			ehci_async_req_count;
170 	uint_t			ehci_periodic_req_count;
171 
172 	/*
173 	 * Endpoint Reclamation List
174 	 *
175 	 * The interrupt list processing cannot be stopped when a periodic
176 	 * endpoint is removed from the list.  The endpoints are detached
177 	 * from the interrupt lattice tree and put on to the reclaimation
178 	 * list. On next SOF interrupt all those endpoints,  which are on
179 	 * the reclaimation list will be deallocated.
180 	 */
181 	ehci_qh_t		*ehci_reclaim_list;	/* Reclaimation list */
182 
183 	ehci_root_hub_t		ehci_root_hub;		/* Root hub info */
184 
185 	/* Frame number overflow information */
186 	usb_frame_number_t	ehci_fno;
187 
188 	/* For host controller error counter */
189 	uint_t			ehci_hc_error;
190 
191 	/*
192 	 * ehci_missed_intr_sts is used to save the normal mode interrupt
193 	 * status information  if an interrupt is pending for normal mode
194 	 * when polled code is entered.
195 	 */
196 	uint_t			ehci_missed_intr_sts;
197 
198 	/*
199 	 * Saved copy of the ehci registers of the normal mode & change
200 	 * required ehci registers values for the polled mode operation.
201 	 * Before returning from the polled mode to normal mode replace
202 	 * the required current registers with this saved ehci registers
203 	 * copy.
204 	 */
205 	ehci_regs_t	ehci_polled_save_regs;
206 
207 	/*
208 	 * Saved copy of the interrupt table used in normal ehci mode and
209 	 * replace this table by another interrupt table that used in the
210 	 * POLLED mode.
211 	 */
212 	ehci_qh_t *ehci_polled_frame_list_table[EHCI_NUM_PERIODIC_FRAME_LISTS];
213 
214 	/* ehci polled mode enter counter */
215 	uint_t			ehci_polled_enter_count;
216 
217 	/*
218 	 * counter for polled mode and used in suspend mode to see if
219 	 * there is a keyboard connected.
220 	 */
221 	uint_t			ehci_polled_kbd_count;
222 
223 	/* counter for polled read and use it to clean the interrupt status */
224 	uint_t			ehci_polled_read_count;
225 
226 #if defined(__x86)
227 	/* counter for polled root hub status */
228 	uint_t			ehci_polled_root_hub_count;
229 #endif	/* __x86 */
230 
231 	/* EHCI Host Controller Software State information */
232 	uint_t			ehci_hc_soft_state;
233 
234 	/* Log handle for debug, console, log messages */
235 	usb_log_handle_t	ehci_log_hdl;
236 
237 	/* Kstat structures */
238 	kstat_t			*ehci_intrs_stats;
239 	kstat_t			*ehci_total_stats;
240 	kstat_t			*ehci_count_stats[USB_N_COUNT_KSTATS];
241 } ehci_state_t;
242 
243 typedef struct ehci_intrs_stats {
244 	struct kstat_named	ehci_sts_async_sched_status;
245 	struct kstat_named	ehci_sts_periodic_sched_status;
246 	struct kstat_named	ehci_sts_empty_async_schedule;
247 	struct kstat_named	ehci_sts_host_ctrl_halted;
248 	struct kstat_named	ehci_sts_async_advance_intr;
249 	struct kstat_named	ehci_sts_host_system_error_intr;
250 	struct kstat_named	ehci_sts_frm_list_rollover_intr;
251 	struct kstat_named	ehci_sts_rh_port_change_intr;
252 	struct kstat_named	ehci_sts_usb_error_intr;
253 	struct kstat_named	ehci_sts_usb_intr;
254 	struct kstat_named	ehci_sts_not_claimed;
255 	struct kstat_named	ehci_sts_total;
256 } ehci_intrs_stats_t;
257 
258 /*
259  * ehci kstat defines
260  */
261 #define	EHCI_INTRS_STATS(ehci)	((ehci)->ehci_intrs_stats)
262 #define	EHCI_INTRS_STATS_DATA(ehci)	\
263 	((ehci_intrs_stats_t *)EHCI_INTRS_STATS((ehci))->ks_data)
264 
265 #define	EHCI_TOTAL_STATS(ehci)	((ehci)->ehci_total_stats)
266 #define	EHCI_TOTAL_STATS_DATA(ehci)	(KSTAT_IO_PTR((ehci)->ehci_total_stats))
267 #define	EHCI_CTRL_STATS(ehci)	\
268 	(KSTAT_IO_PTR((ehci)->ehci_count_stats[USB_EP_ATTR_CONTROL]))
269 #define	EHCI_BULK_STATS(ehci)	\
270 	(KSTAT_IO_PTR((ehci)->ehci_count_stats[USB_EP_ATTR_BULK]))
271 #define	EHCI_INTR_STATS(ehci)	\
272 	(KSTAT_IO_PTR((ehci)->ehci_count_stats[USB_EP_ATTR_INTR]))
273 #define	EHCI_ISOC_STATS(ehci)	\
274 	(KSTAT_IO_PTR((ehci)->ehci_count_stats[USB_EP_ATTR_ISOCH]))
275 
276 /* warlock directives, stable data */
277 _NOTE(MUTEX_PROTECTS_DATA(ehci_state_t::ehci_int_mutex, ehci_state_t))
278 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_intr_pri))
279 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_dip))
280 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_regsp))
281 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_instance))
282 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_vendor_id))
283 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_device_id))
284 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_rev_id))
285 
286 /* this may not be stable data in the future */
287 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qtd_pool_addr))
288 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qtd_pool_mem_handle))
289 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qtd_pool_cookie))
290 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qh_pool_addr))
291 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qh_pool_mem_handle))
292 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_qh_pool_cookie))
293 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_itd_pool_addr))
294 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_itd_pool_mem_handle))
295 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_itd_pool_cookie))
296 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_dma_addr_bind_flag))
297 _NOTE(DATA_READABLE_WITHOUT_LOCK(ehci_state_t::ehci_log_hdl))
298 
299 _NOTE(LOCK_ORDER(ehci_state::ehci_int_mutex \
300 		usba_pipe_handle_data::p_mutex \
301 		usba_device::usb_mutex \
302 		usba_ph_impl::usba_ph_mutex))
303 
304 /*
305  * Host Contoller Software States
306  *
307  * EHCI_CTLR_INIT_STATE:
308  *	The host controller soft state will be set to this during the
309  *	ehci_attach.
310  *
311  * EHCI_CTLR_SUSPEND_STATE:
312  *	The host controller soft state will be set to this during the
313  *	ehci_cpr_suspend.
314  *
315  * EHCI_CTLR_OPERATIONAL_STATE:
316  *	The host controller soft state will be set to this after moving
317  *	host controller to operational state and host controller start
318  *	generating SOF successfully.
319  *
320  * EHCI_CTLR_ERROR_STATE:
321  *	The host controller soft state will be set to this during the
322  *	no SOF or UE error conditions.
323  *
324  *	Under this state or condition, only pipe stop polling, pipe reset
325  *	and pipe close are allowed. But all other entry points like  pipe
326  *	open, get/set pipe policy, cotrol send/receive, bulk send/receive
327  *	isoch send/receive, start polling etc. will fail.
328  *
329  * State Diagram for the host controller software state
330  *
331  *
332  * ehci_attach->[INIT_STATE]
333  *	|
334  *	|	-------->----[ERROR_STATE]--<-----------<---
335  *	|      |      Failure (UE/no SOF condition)	    |
336  *	|      ^					    ^
337  *	V      |      Success				    |
338  * ehci_init_ctlr--->--------[OPERATIONAL_STATE]------>-ehci_send/recv/polling
339  *	^					    |
340  *	|					    |
341  *	|					    V
342  *	-<-ehci_cpr_resume--[SUSPEND_STATE]-<-ehci_cpr_suspend
343  */
344 #define	EHCI_CTLR_INIT_STATE		0	/* Initilization state */
345 #define	EHCI_CTLR_SUSPEND_STATE		1	/* Suspend state */
346 #define	EHCI_CTLR_OPERATIONAL_STATE	2	/* Operational state */
347 #define	EHCI_CTLR_ERROR_STATE		3	/* Ue error or no sof state */
348 
349 /*
350  * Flags for initializatoin of host controller
351  */
352 #define	EHCI_NORMAL_INITIALIZATION	0	/* Normal initialization */
353 #define	EHCI_REINITIALIZATION		1	/* Re-initialization */
354 
355 /*
356  * Periodic and non-periodic macros
357  */
358 #define	EHCI_PERIODIC_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
359 				USB_EP_ATTR_MASK) == USB_EP_ATTR_INTR) ||\
360 				((endpoint->bmAttributes &\
361 				USB_EP_ATTR_MASK) == USB_EP_ATTR_ISOCH))
362 
363 #define	EHCI_NON_PERIODIC_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
364 				USB_EP_ATTR_MASK) == USB_EP_ATTR_CONTROL) ||\
365 				((endpoint->bmAttributes &\
366 				USB_EP_ATTR_MASK) == USB_EP_ATTR_BULK))
367 
368 #define	EHCI_ISOC_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
369 				USB_EP_ATTR_MASK) == USB_EP_ATTR_ISOCH))
370 
371 #define	EHCI_INTR_ENDPOINT(endpoint) (((endpoint->bmAttributes &\
372 				USB_EP_ATTR_MASK) == USB_EP_ATTR_INTR))
373 
374 
375 /*
376  * EHCI QH and QTD Pool sizes.
377  */
378 #define	EHCI_QH_POOL_SIZE	1000
379 #define	EHCI_QTD_POOL_SIZE	200
380 #define	EHCI_ITD_POOL_SIZE	200
381 
382 /*
383  * ehci_dma_addr_bind_flag values
384  *
385  * This flag indicates if the various DMA addresses allocated by the EHCI
386  * have been bound to their respective handles. This is needed to recover
387  * without errors from ehci_cleanup when it calls ddi_dma_unbind_handle()
388  */
389 #define	EHCI_QTD_POOL_BOUND	0x01	/* For QTD pools  */
390 #define	EHCI_QH_POOL_BOUND	0x02	/* For QH pools  */
391 #define	EHCI_PFLT_DMA_BOUND	0x04	/* For Periodic Frame List area */
392 #define	EHCI_ITD_POOL_BOUND	0x08	/* For QTD pools  */
393 
394 /*
395  * Maximum SOF wait count
396  */
397 #define	MAX_SOF_WAIT_COUNT	2	/* Wait for maximum SOF frames */
398 
399 /*
400  * One uFrame	125 micro seconds
401  * One Frame	1 milli second or 8 uFrames
402  */
403 #define	EHCI_uFRAMES_PER_USB_FRAME		8
404 #define	EHCI_uFRAMES_PER_USB_FRAME_SHIFT	3
405 
406 
407 /*
408  * Pipe private structure
409  *
410  * There is an instance of this structure per pipe.  This structure holds
411  * HCD specific pipe information.  A pointer to this structure is kept in
412  * the USBA pipe handle (usba_pipe_handle_data_t).
413  */
414 typedef struct ehci_pipe_private {
415 	usba_pipe_handle_data_t	*pp_pipe_handle;	/* Back ptr to handle */
416 	ehci_qh_t		*pp_qh;			/* Pipe's qh */
417 
418 	/* State of the pipe */
419 	uint_t			pp_state;		/* See below */
420 
421 	/* Local copy of the pipe policy */
422 	usb_pipe_policy_t	pp_policy;
423 
424 	/* For Periodic Pipes Only */
425 	uint_t			pp_pnode;		/* periodic node */
426 	uchar_t			pp_smask;		/* Start split mask */
427 	uchar_t			pp_cmask;		/* Comp split mask */
428 	uint_t			pp_cur_periodic_req_cnt; /* Curr req count */
429 	uint_t			pp_max_periodic_req_cnt; /* Max req count */
430 
431 	/* For Isochronous pipes only */
432 	usb_frame_number_t	pp_next_frame_number;	/* Next frame no */
433 
434 	/*
435 	 * Each pipe may have multiple transfer wrappers. Each transfer
436 	 * wrapper represents a USB transfer on the bus.  A transfer is
437 	 * made up of one or more transactions.
438 	 */
439 	struct ehci_trans_wrapper *pp_tw_head;	/* Head of the list */
440 	struct ehci_trans_wrapper *pp_tw_tail;	/* Tail of the list */
441 
442 	struct ehci_isoc_xwrapper *pp_itw_head;	/* Head of the list */
443 	struct ehci_isoc_xwrapper *pp_itw_tail;	/* Tail of the list */
444 
445 	/*
446 	 * Pipe's transfer timeout handling & this transfer timeout handling
447 	 * will be per pipe.
448 	 */
449 	struct ehci_trans_wrapper *pp_timeout_list;	/* Timeout list */
450 	timeout_id_t		pp_timer_id;		/* Timer id  */
451 
452 	/* Done td count */
453 	uint_t			pp_count_done_qtds;	/* Done td count */
454 
455 	/* Errors */
456 	usb_cr_t		pp_error;		/* Pipe error */
457 
458 	/* Condition variable for transfers completion event */
459 	kcondvar_t		pp_xfer_cmpl_cv;	/* Xfer completion */
460 
461 	/* Pipe flag */
462 	uint_t			pp_flag;		/* For polled mode */
463 
464 	/* Halting States */
465 	uint_t			pp_halt_state;		/* Is it halting */
466 
467 	/* Condition variable for halt completion event */
468 	kcondvar_t		pp_halt_cmpl_cv;	/* Xfer completion */
469 
470 	/*
471 	 * HCD gets Interrupt/Isochronous IN polling request only once and
472 	 * it has to insert next polling requests after completion of first
473 	 * request until either stop polling/pipe close is called. So  HCD
474 	 * has to take copy of the original Interrupt/Isochronous IN request.
475 	 */
476 	usb_opaque_t		pp_client_periodic_in_reqp;
477 } ehci_pipe_private_t;
478 
479 _NOTE(MUTEX_PROTECTS_DATA(ehci_state_t::ehci_int_mutex, ehci_pipe_private_t))
480 
481 /*
482  * Pipe states
483  *
484  * ehci pipe states will be similar to usba. Refer usbai.h.
485  */
486 #define	EHCI_PIPE_STATE_IDLE		1	/* Pipe is in ready state */
487 #define	EHCI_PIPE_STATE_ACTIVE		2	/* Pipe is in busy state */
488 #define	EHCI_PIPE_STATE_ERROR		3	/* Pipe is in error state */
489 
490 /* Additional ehci pipe states for the ehci_pipe_cleanup */
491 #define	EHCI_PIPE_STATE_CLOSE		4	/* Pipe close */
492 #define	EHCI_PIPE_STATE_RESET		5	/* Pipe reset */
493 #define	EHCI_PIPE_STATE_STOP_POLLING	6	/* Pipe stop polling */
494 
495 /*
496  * Pipe flag
497  *
498  * Interrupt or polled mode.
499  */
500 #define	EHCI_INTERRUPT_MODE_FLAG	0	/* Interrupt mode flag */
501 #define	EHCI_POLLED_MODE_FLAG		1	/* Polled mode flag */
502 
503 /* Pipe specific flags */
504 #define	EHCI_ISOC_XFER_CONTINUE		1	/* For isoc transfers */
505 
506 /*
507  * Halting States
508  *  prevent halting from interleaving.
509  */
510 #define	EHCI_HALT_STATE_FREE		0	/* Pipe free to accept reqs */
511 #define	EHCI_HALT_STATE_HALTING		1	/* Currently Halting */
512 
513 /*
514  * Request values for Clear_TT_Buffer
515  */
516 #define	EHCI_CLEAR_TT_BUFFER_REQTYPE	(USB_DEV_REQ_TYPE_CLASS | \
517 					USB_DEV_REQ_RCPT_OTHER)
518 #define	EHCI_CLEAR_TT_BUFFER_BREQ	8
519 
520 /*
521  * USB frame offset
522  *
523  * Add appropriate frame offset to the current usb frame number and use it
524  * as a starting frame number for a given usb isochronous request.
525  */
526 #define	EHCI_FRAME_OFFSET		2	/* Frame offset */
527 
528 /*
529  * Different interrupt polling intervals supported for high speed
530  * devices and its range must be from 1 to 16 units. This value is
531  * used as th exponent for a 2 ^ (bInterval - 1). Ex: a Binterval
532  * of 4 means a period of 8us (2 ^ (4-1)).
533  *
534  * The following values are defined after above convertion in terms
535  * 125us units.
536  */
537 #define	EHCI_INTR_1US_POLL		1	/* 1us poll interval */
538 #define	EHCI_INTR_2US_POLL		2	/* 2us poll interval */
539 #define	EHCI_INTR_4US_POLL		4	/* 4us poll interval */
540 #define	EHCI_INTR_XUS_POLL		8	/* 8us and above */
541 
542 /*
543  * The following indecies are are used to calculate Start and complete
544  * masks as per the polling interval.
545  */
546 #define	EHCI_1US_MASK_INDEX		14	/* 1us mask index */
547 #define	EHCI_2US_MASK_INDEX		12	/* 2us mask index */
548 #define	EHCI_4US_MASK_INDEX		8	/* 4us mask index */
549 #define	EHCI_XUS_MASK_INDEX		0	/* 8us and above */
550 
551 /*
552  * Different interrupt polling intervals supported for low/full/high
553  * speed devices. For high speed devices, the following values are
554  * applicable after convertion.
555  */
556 #define	EHCI_INTR_1MS_POLL		1	/* 1ms poll interval */
557 #define	EHCI_INTR_2MS_POLL		2	/* 2ms poll interval */
558 #define	EHCI_INTR_4MS_POLL		4	/* 4ms poll interval */
559 #define	EHCI_INTR_8MS_POLL		8	/* 8ms poll interval */
560 #define	EHCI_INTR_16MS_POLL		16	/* 16ms poll interval */
561 #define	EHCI_INTR_32MS_POLL		32	/* 32ms poll interval */
562 
563 /*
564  * Number of interrupt transfer requests that should be maintained on
565  * the interrupt endpoint corresponding to different polling intervals
566  * supported.
567  */
568 #define	EHCI_INTR_1MS_REQS		4	/* 1ms polling interval */
569 #define	EHCI_INTR_2MS_REQS		2	/* 2ms polling interval */
570 #define	EHCI_INTR_XMS_REQS		1	/* Between 4ms and 32ms */
571 
572 /* Function prototype */
573 typedef void (*ehci_handler_function_t)(
574 	ehci_state_t			*ehcip,
575 	ehci_pipe_private_t		*pp,
576 	struct ehci_trans_wrapper	*tw,
577 	ehci_qtd_t			*qtd,
578 	void				*ehci_handle_callback_value);
579 
580 
581 /*
582  * Transfer wrapper
583  *
584  * The transfer wrapper represents a USB transfer on the bus and there
585  * is one instance per USB transfer.  A transfer is made up of one or
586  * more transactions. EHCI uses one QTD for one transaction. So one
587  * transfer wrapper may have one or more QTDs associated.
588  *
589  * The data to be transferred are contained in the TW buffer which is
590  * virtually contiguous but physically discontiguous. When preparing
591  * the QTDs for a USB transfer, the DMA cookies corresponding to the
592  * TW buffer need to be walked through to retrieve the DMA addresses.
593  *
594  * Control and bulk pipes will have one transfer wrapper per transfer
595  * and where as Isochronous and Interrupt pipes will only have one
596  * transfer wrapper. The transfers wrapper are continually reused for
597  * the Interrupt and Isochronous pipes as those pipes are polled.
598  */
599 typedef struct ehci_trans_wrapper {
600 	struct ehci_trans_wrapper	*tw_next;	/* Next wrapper */
601 	ehci_pipe_private_t		*tw_pipe_private; /* Back ptr */
602 	ddi_dma_handle_t		tw_dmahandle;	/* DMA handle */
603 	ddi_acc_handle_t		tw_accesshandle; /* Acc hndle */
604 	ddi_dma_cookie_t		tw_cookie;	/* DMA cookie */
605 	uint_t				tw_ncookies;	/* DMA cookie count */
606 	uint_t				tw_cookie_idx;	/* DMA cookie index */
607 	size_t				tw_dma_offs;	/* DMA buffer offset */
608 	uint32_t			tw_id;		/* 32bit ID */
609 	size_t				tw_length;	/* Txfer length */
610 	char				*tw_buf;	/* Buffer for Xfer */
611 	usb_flags_t			tw_flags;	/* Flags */
612 	uint_t				tw_num_qtds;	/* Number of QTDs */
613 	ehci_qtd_t			*tw_qtd_head;	/* Head QTD */
614 	ehci_qtd_t			*tw_qtd_tail;	/* Tail QTD */
615 	uint_t				tw_direction;	/* Direction of QTD */
616 
617 	/* Current transfer request pointer */
618 	usb_opaque_t			tw_curr_xfer_reqp;
619 
620 	/* Transfer timeout information */
621 	int				tw_timeout;	/* Timeout value */
622 	struct ehci_trans_wrapper	*tw_timeout_next; /* Xfer Timeout Q */
623 
624 	/*
625 	 * This is the function to call when this td is done. This way
626 	 * we don't have to look in the td to figure out what kind it is.
627 	 */
628 	ehci_handler_function_t		tw_handle_qtd;
629 
630 	/*
631 	 * This is the callback value used when processing a done td.
632 	 */
633 	usb_opaque_t			tw_handle_callback_value;
634 
635 	/* We preallocate all the td's for each tw and place them here */
636 	ehci_qtd_t			*tw_qtd_free_list;
637 	ehci_qtd_t			*tw_alt_qtd;
638 } ehci_trans_wrapper_t;
639 
640 _NOTE(MUTEX_PROTECTS_DATA(ehci_state_t::ehci_int_mutex, ehci_trans_wrapper))
641 
642 /*
643  * Isochronous Transfer Wrapper
644  *
645  * This transfer wrapper is built specifically for the LOW/FULL/HIGH speed
646  * isochronous transfers.  A transfer wrapper consists of one or more
647  * transactionsl, but there is one one instance per USB transfer request.
648  *
649  * The isochrnous transfer wrapper are continiously reused because these
650  * pipes are polled.
651  */
652 typedef struct ehci_isoc_xwrapper {
653 	struct ehci_isoc_xwrapper	*itw_next;	/* Next wrapper in pp */
654 	ehci_pipe_private_t		*itw_pipe_private;
655 
656 	/* DMA and memory pointers */
657 	ddi_dma_handle_t		itw_dmahandle;	/* DMA handle ETT */
658 	ddi_acc_handle_t		itw_accesshandle; /* Acc hndle */
659 	ddi_dma_cookie_t		itw_cookie;	/* DMA cookie */
660 
661 	/* Transfer information */
662 	char				*itw_buf;	/* Buffer for Xfer */
663 	size_t				itw_length;	/* Txfer length */
664 	usb_flags_t			itw_flags;	/* Flags */
665 	usb_port_status_t		itw_port_status; /* Port Speed */
666 	uint_t				itw_direction;	/* Direction of ITD */
667 
668 	/* ITD information */
669 	uint_t				itw_num_itds;	/* Number of ITDs */
670 	ehci_itd_t			*itw_itd_head;	/* Head ITD */
671 	ehci_itd_t			*itw_itd_tail;	/* Tail ITD */
672 	usb_isoc_req_t			*itw_curr_xfer_reqp;
673 	usb_isoc_pkt_descr_t		*itw_curr_isoc_pktp;
674 
675 	/* We preallocate all the td's for each tw and place them here */
676 	ehci_itd_t			*itw_itd_free_list;
677 
678 	/* Device and hub information needed by every iTD */
679 	uint_t				itw_hub_addr;
680 	uint_t				itw_hub_port;
681 	uint_t				itw_endpoint_num;
682 	uint_t				itw_device_addr;
683 
684 	/*
685 	 * Callback handling function and arguement.  Called when an iTD is
686 	 * is done.
687 	 */
688 	usb_opaque_t			itw_handle_callback_value;
689 
690 	/* 32bit ID */
691 	uint32_t			itw_id;
692 } ehci_isoc_xwrapper_t;
693 
694 _NOTE(MUTEX_PROTECTS_DATA(ehci_state_t::ehci_int_mutex, ehci_isoc_xwrapper_t))
695 
696 /*
697  * Time waits for the different EHCI specific operations.
698  * These timeout values are specified in terms of microseconds.
699  */
700 #define	EHCI_RESET_TIMEWAIT	10000	/* HC reset waiting time */
701 #define	EHCI_TIMEWAIT		10000	/* HC any other waiting time */
702 #define	EHCI_SOF_TIMEWAIT	20000	/* SOF Wait time */
703 #define	EHCI_TAKEOVER_DELAY	10000	/* HC take over waiting time */
704 #define	EHCI_TAKEOVER_WAIT_COUNT	25	/* HC take over waiting count */
705 
706 /* These timeout values are specified in seconds */
707 #define	EHCI_DEFAULT_XFER_TIMEOUT	5 /* Default transfer timeout */
708 #define	EHCI_XFER_CMPL_TIMEWAIT		3 /* Xfers completion timewait */
709 
710 /* EHCI flags for general use */
711 #define	EHCI_FLAGS_NOSLEEP	0x000	/* Don't wait for SOF */
712 #define	EHCI_FLAGS_SLEEP	0x100	/* Wait for SOF */
713 #define	EHCI_FLAGS_DMA_SYNC	0x200	/* Call ddi_dma_sync */
714 
715 /*
716  * Maximum allowable data transfer  size per transaction as supported
717  * by EHCI is 20k. (See EHCI Host Controller Interface Spec Rev 0.96)
718  *
719  * Also within QTD, there will be five buffer pointers abd each buffer
720  * pointer can transfer upto 4k bytes of data.
721  */
722 #define	EHCI_MAX_QTD_XFER_SIZE	0x5000	/* Maxmum data per transaction */
723 #define	EHCI_MAX_QTD_BUF_SIZE	0x1000	/* Maxmum data per buffer */
724 
725 /*
726  * The maximum allowable bulk data transfer size. It can be different
727  * from EHCI_MAX_QTD_XFER_SIZE and if it is more then ehci driver will
728  * take care of  breaking a bulk data request into  multiples of ehci
729  * EHCI_MAX_QTD_XFER_SIZE  until request is satisfied.	Currently this
730  * value is set to 640k bytes.
731  */
732 #define	EHCI_MAX_BULK_XFER_SIZE	0xA0000	/* Maximum bulk transfer size */
733 
734 /*
735  * Timeout flags
736  *
737  * These flags will be used to stop the timer before timeout handler
738  * gets executed.
739  */
740 #define	EHCI_REMOVE_XFER_IFLAST	1	/* Stop the timer if it is last QTD */
741 #define	EHCI_REMOVE_XFER_ALWAYS	2	/* Stop the timer without condition */
742 
743 
744 /*
745  * High speed bandwidth allocation
746  *
747  * The following definitions are used during bandwidth calculations
748  * for a given high speed endpoint or high speed split transactions.
749  */
750 #define	HS_BUS_BANDWIDTH	7500	/* Up to 7500 bytes per 125us */
751 #define	HS_MAX_POLL_INTERVAL	16	/* Max high speed polling interval */
752 #define	HS_MIN_POLL_INTERVAL	1	/* Min high speed polling interval */
753 #define	HS_SOF			12	/* Length in bytes of High speed SOF */
754 #define	HS_EOF			70	/* Length in bytes of High speed EOF */
755 #define	TREE_HEIGHT		5	/* Log base 2 of 32 */
756 
757 /*
758  * As per USB 2.0 specification section 5.5.4, 20% of bus time is reserved
759  * for the non-periodic high-speed transfers. Where as peridoic high-speed
760  * transfers will get 80% of the bus time. In one micro-frame or 125us, we
761  * can transfer 7500 bytes or 60,000 bits.
762  */
763 #define	HS_NON_PERIODIC_BANDWIDTH	1500
764 #define	HS_PERIODIC_BANDWIDTH		(HS_BUS_BANDWIDTH - HS_SOF - \
765 					HS_EOF - HS_NON_PERIODIC_BANDWIDTH)
766 
767 /*
768  * High speed periodic frame bandwidth will be eight times the micro frame
769  * high speed periodic bandwidth.
770  */
771 #define	HS_PERIODIC_FRAME_BANDWIDTH	HS_PERIODIC_BANDWIDTH * EHCI_MAX_UFRAMES
772 
773 /*
774  * The following are the protocol overheads in terms of Bytes for the
775  * different transfer types.  All these protocol overhead  values are
776  * derived from the 5.11.3 section of USB 2.0 Specification.
777  */
778 #define	HS_NON_ISOC_PROTO_OVERHEAD	55
779 #define	HS_ISOC_PROTO_OVERHEAD		38
780 
781 /*
782  * The following are THE protocol overheads in terms of Bytes for the
783  * start and complete split transactions tokens overheads.  All these
784  * protocol overhead values are derived from the 8.4.2.2 and 8.4.2.3
785  * of USB2.0 Specification.
786  */
787 #define	START_SPLIT_OVERHEAD		04
788 #define	COMPLETE_SPLIT_OVERHEAD		04
789 
790 /*
791  * The Host Controller (HC) delays are the USB host controller specific
792  * delays. The value shown below is the host  controller delay for  the
793  * given EHCI host controller.
794  */
795 #define	EHCI_HOST_CONTROLLER_DELAY	18
796 
797 /*
798  * Low/Full speed bandwidth allocation
799  *
800  * The following definitions are used during bandwidth calculations for
801  * a given high speed hub or  a transaction translator	(TT) and  for a
802  * given low/full speed device connected to high speed hub or TT  using
803  * split transactions
804  */
805 #define	FS_BUS_BANDWIDTH	1500	/* Up to 1500 bytes per 1ms */
806 #define	FS_MAX_POLL_INTERVAL	255	/* Max full speed poll interval */
807 #define	FS_MIN_POLL_INTERVAL	1	/* Min full speed polling interval */
808 #define	FS_SOF			6	/* Length in bytes of Full speed SOF */
809 #define	FS_EOF			4	/* Length in bytes of Full speed EOF */
810 
811 /*
812  * Minimum polling interval for low speed endpoint
813  *
814  * According USB 2.0 Specification, a full-speed endpoint can specify
815  * a desired polling interval 1ms to 255ms and a low speed endpoints
816  * are limited to specifying only 10ms to 255ms. But some old keyboards
817  * and mice uses polling interval of 8ms. For compatibility purpose,
818  * we are using polling interval between 8ms and 255ms for low speed
819  * endpoints. The ehci driver will use 8ms polling interval if a low
820  * speed device reports a polling interval that is less than 8ms.
821  */
822 #define	LS_MAX_POLL_INTERVAL	255	/* Max low speed poll interval */
823 #define	LS_MIN_POLL_INTERVAL	8	/* Min low speed polling interval */
824 
825 /*
826  * For non-periodic transfers, reserve atleast for one low-speed device
827  * transaction. According to USB Bandwidth Analysis white paper and also
828  * as per OHCI Specification 1.0a, section 7.3.5, page 123, one low-speed
829  * transaction takes 0x628h full speed bits (197 bytes), which comes to
830  * around 13% of USB frame time.
831  *
832  * The periodic transfers will	get around 87% of USB frame time.
833  */
834 #define	FS_NON_PERIODIC_BANDWIDTH	197
835 #define	FS_PERIODIC_BANDWIDTH		(FS_BUS_BANDWIDTH - FS_SOF - \
836 					FS_EOF - FS_NON_PERIODIC_BANDWIDTH)
837 
838 /*
839  * The following are the protocol overheads in terms of Bytes for the
840  * different transfer types.  All these protocol overhead  values are
841  * derived from the 5.11.3 section of USB Specification	and  with the
842  * help of Bandwidth Analysis white paper which is posted on the  USB
843  * developer forum.
844  */
845 #define	FS_NON_ISOC_PROTO_OVERHEAD	14
846 #define	FS_ISOC_INPUT_PROTO_OVERHEAD	11
847 #define	FS_ISOC_OUTPUT_PROTO_OVERHEAD	10
848 #define	LOW_SPEED_PROTO_OVERHEAD	97
849 #define	HUB_LOW_SPEED_PROTO_OVERHEAD	01
850 
851 /* The maximum amount of isoch data that can be transferred in one uFrame */
852 #define	MAX_UFRAME_SITD_XFER		188
853 
854 /*
855  * The low speed clock below represents that to transmit one low-speed
856  * bit takes eight times more than one full speed bit time.
857  */
858 #define	LOW_SPEED_CLOCK			8
859 
860 /*
861  * The Transaction Translator (TT) delay is the additional time needed
862  * to execute low/full speed transaction from high speed split transaction
863  * for the low/full device connected to the high speed extrenal hub.
864  */
865 #define	TT_DELAY			18
866 
867 
868 /*
869  * Macros for setting/getting information
870  */
871 #define	Get_QH(addr)		ddi_get32(ehcip->ehci_qh_pool_mem_handle, \
872 					(uint32_t *)&addr)
873 
874 #define	Set_QH(addr, val)	ddi_put32(ehcip->ehci_qh_pool_mem_handle,  \
875 					((uint32_t *)&addr), \
876 					((int32_t)(val)))
877 
878 #define	Get_QTD(addr)		ddi_get32(ehcip->ehci_qtd_pool_mem_handle, \
879 					(uint32_t *)&addr)
880 
881 #define	Set_QTD(addr, val)	ddi_put32(ehcip->ehci_qtd_pool_mem_handle, \
882 					((uint32_t *)&addr), \
883 					((int32_t)(val)))
884 
885 #define	Get_ITD(addr)		ddi_get32(ehcip->ehci_itd_pool_mem_handle, \
886 					(uint32_t *)&addr)
887 
888 #define	Set_ITD(addr, val)	ddi_put32(ehcip->ehci_itd_pool_mem_handle, \
889 					((uint32_t *)&addr), \
890 					((int32_t)(val)))
891 
892 #define	Get_ITD_BODY(ptr, addr)		ddi_get32( \
893 					    ehcip->ehci_itd_pool_mem_handle, \
894 					    (uint32_t *)&ptr->itd_body[addr])
895 
896 #define	Set_ITD_BODY(ptr, addr, val)	ddi_put32( \
897 					    ehcip->ehci_itd_pool_mem_handle, \
898 					    ((uint32_t *)&ptr->itd_body[addr]),\
899 					    ((int32_t)(val)))
900 
901 #define	Get_ITD_INDEX(ptr, pos)		ddi_get32( \
902 					    ehcip->ehci_itd_pool_mem_handle, \
903 					    (uint32_t *)&ptr->itd_index[pos])
904 
905 #define	Set_ITD_INDEX(ptr, pos, val)	ddi_put32( \
906 					    ehcip->ehci_itd_pool_mem_handle, \
907 					    ((uint32_t *)&ptr->itd_index[pos]),\
908 					    ((uint32_t)(val)))
909 
910 #define	Get_ITD_FRAME(addr)		ddi_get64( \
911 					    ehcip->ehci_itd_pool_mem_handle, \
912 					    (uint64_t *)&addr)
913 
914 #define	Set_ITD_FRAME(addr, val)	ddi_put64( \
915 					    ehcip->ehci_itd_pool_mem_handle, \
916 					    ((uint64_t *)&addr), \
917 					    (val))
918 
919 #define	Get_PFLT(addr)		ddi_get32(ehcip->ehci_pflt_mem_handle, \
920 					(uint32_t *)&addr)
921 
922 #define	Set_PFLT(addr, val)	ddi_put32(ehcip->ehci_pflt_mem_handle, \
923 					((uint32_t *)&addr), \
924 					((int32_t)(uintptr_t)(val)))
925 
926 #define	Get_8Cap(addr)		ddi_get8(ehcip->ehci_caps_handle, \
927 					(uint8_t *)&ehcip->ehci_capsp->addr)
928 
929 #define	Get_16Cap(addr)		ddi_get16(ehcip->ehci_caps_handle, \
930 					(uint16_t *)&ehcip->ehci_capsp->addr)
931 
932 #define	Get_Cap(addr)		ddi_get32(ehcip->ehci_caps_handle, \
933 					(uint32_t *)&ehcip->ehci_capsp->addr)
934 
935 #define	Get_OpReg(addr)		ddi_get32(ehcip->ehci_caps_handle, \
936 					(uint32_t *)&ehcip->ehci_regsp->addr)
937 
938 #define	Set_OpReg(addr, val)	ddi_put32(ehcip->ehci_caps_handle, \
939 				((uint32_t *)&ehcip->ehci_regsp->addr), \
940 					((int32_t)(val)))
941 
942 #define	CalculateITDMultiField(pkgSize)		(1 + (((pkgSize)>>11) & 0x03))
943 
944 #define	EHCI_MAX_RETRY		10
945 
946 #define	Set_OpRegRetry(addr, val, r) \
947 				while (Get_OpReg(addr) != val) { \
948 					if (r >= EHCI_MAX_RETRY) \
949 						break; \
950 					r++; \
951 					Set_OpReg(addr, val); \
952 				}
953 
954 #define	Sync_QH_QTD_Pool(ehcip) (void) ddi_dma_sync( \
955 				ehcip->ehci_qh_pool_dma_handle, \
956 				0, EHCI_QH_POOL_SIZE * sizeof (ehci_qh_t), \
957 				DDI_DMA_SYNC_FORCPU); \
958 				(void) ddi_dma_sync( \
959 				ehcip->ehci_qtd_pool_dma_handle, \
960 				0, EHCI_QTD_POOL_SIZE * sizeof (ehci_qtd_t), \
961 				DDI_DMA_SYNC_FORCPU);
962 
963 #define	Sync_ITD_Pool(ehcip) (void) ddi_dma_sync( \
964 				ehcip->ehci_itd_pool_dma_handle, \
965 				0, EHCI_ITD_POOL_SIZE * sizeof (ehci_itd_t), \
966 				DDI_DMA_SYNC_FORCPU);
967 
968 #define	Sync_IO_Buffer(dma_handle, length) \
969 				(void) ddi_dma_sync(dma_handle, \
970 				0, length, DDI_DMA_SYNC_FORCPU);
971 
972 #define	Sync_IO_Buffer_for_device(dma_handle, length) \
973 				(void) ddi_dma_sync(dma_handle, \
974 				0, length, DDI_DMA_SYNC_FORDEV);
975 
976 /*
977  * Macros to speed handling of 32bit IDs
978  */
979 #define	EHCI_GET_ID(x)		id32_alloc((void *)(x), KM_SLEEP)
980 #define	EHCI_LOOKUP_ID(x)	id32_lookup((x))
981 #define	EHCI_FREE_ID(x)		id32_free((x))
982 
983 
984 /*
985  * Miscellaneous definitions.
986  */
987 
988 /* Data toggle bits */
989 #define	DATA0		0
990 #define	DATA1		1
991 
992 /* Halt bit actions */
993 #define	CLEAR_HALT	0
994 #define	SET_HALT	1
995 
996 typedef uint_t		halt_bit_t;
997 
998 /*
999  * Setup Packet
1000  */
1001 typedef struct setup_pkt {
1002 	uchar_t	bmRequestType;
1003 	uchar_t	bRequest;
1004 	ushort_t wValue;
1005 	ushort_t wIndex;
1006 	ushort_t wLength;
1007 }setup_pkt_t;
1008 
1009 #define	SETUP_SIZE		8	/* Setup packet is always 8 bytes */
1010 
1011 #define	REQUEST_TYPE_OFFSET	0
1012 #define	REQUEST_OFFSET		1
1013 #define	VALUE_OFFSET		2
1014 #define	INDEX_OFFSET		4
1015 #define	LENGTH_OFFSET		6
1016 
1017 #define	TYPE_DEV_TO_HOST	0x80000000
1018 #define	DEVICE			0x00000001
1019 #define	CONFIGURATION		0x00000002
1020 
1021 /*
1022  * The following are used in attach to	 indicate
1023  * what has been succesfully allocated, so detach
1024  * can remove them.
1025  */
1026 #define	EHCI_ATTACH		0x01	/* ehci driver initilization */
1027 #define	EHCI_ZALLOC		0x02	/* Memory for ehci state structure */
1028 #define	EHCI_INTR		0x04	/* Interrupt handler registered */
1029 #define	EHCI_USBAREG		0x08	/* USBA registered */
1030 #define	EHCI_RHREG		0x10	/* Root hub driver loaded */
1031 
1032 /*
1033  * This variable is used in the EHCI_FLAGS to tell the ISR to broadcase
1034  * the ehci_async_schedule_advance_cv when an intr occurs.  It is used to
1035  * make sure that EHCI is receiving interrupts.
1036  */
1037 #define	EHCI_CV_INTR		0x20	/* Ask INTR to broadcast cv */
1038 
1039 #define	EHCI_UNIT(dev)	(getminor((dev)) & ~HUBD_IS_ROOT_HUB)
1040 
1041 /*
1042  * Debug printing
1043  * Masks
1044  */
1045 #define	PRINT_MASK_ATTA		0x00000001	/* Attach time */
1046 #define	PRINT_MASK_LISTS	0x00000002	/* List management */
1047 #define	PRINT_MASK_ROOT_HUB	0x00000004	/* Root hub stuff */
1048 #define	PRINT_MASK_ALLOC	0x00000008	/* Alloc/dealloc descr */
1049 #define	PRINT_MASK_INTR		0x00000010	/* Interrupt handling */
1050 #define	PRINT_MASK_BW		0x00000020	/* Bandwidth */
1051 #define	PRINT_MASK_CBOPS	0x00000040	/* CB-OPS */
1052 #define	PRINT_MASK_HCDI		0x00000080	/* HCDI entry points */
1053 #define	PRINT_MASK_DUMPING	0x00000100	/* Dump ehci info */
1054 #define	PRINT_MASK_ALL		0xFFFFFFFF
1055 
1056 #define	PCI_VENDOR_NVIDIA	0x10de		/* PCI Vendor-id NVIDIA */
1057 #define	PCI_DEVICE_NVIDIA_CK804	0x5b
1058 #define	PCI_DEVICE_NVIDIA_MCP04	0x3c
1059 /*
1060  * workaround for ALI chips
1061  */
1062 #define	PCI_VENDOR_ALI		0x10b9		/* PCI Vendor-id Acer */
1063 
1064 /*
1065  * NEC on COMBO and Uli M1575 can support PM
1066  */
1067 #define	PCI_VENDOR_NEC_COMBO	0x1033
1068 #define	PCI_DEVICE_NEC_COMBO	0xe0
1069 #define	PCI_VENDOR_ULi_M1575	0x10b9
1070 #define	PCI_DEVICE_ULi_M1575	0x5239
1071 
1072 /*
1073  * VIA chips have some problems, the workaround can ensure those chips
1074  * work reliably. Revisions >= 0x80 are part of a southbridge and appear
1075  * to be reliable.
1076  */
1077 #define	PCI_VENDOR_VIA		0x1106		/* PCI Vendor-id VIA */
1078 #define	PCI_VIA_REVISION_6212	0x80		/* VIA 6212 revision ID */
1079 
1080 #define	EHCI_VIA_LOST_INTERRUPTS	0x01
1081 #define	EHCI_VIA_ASYNC_SCHEDULE		0x02
1082 #define	EHCI_VIA_REDUCED_MAX_BULK_XFER_SIZE	0x04
1083 
1084 #define	EHCI_VIA_WORKAROUNDS \
1085 	(EHCI_VIA_LOST_INTERRUPTS | \
1086 	EHCI_VIA_ASYNC_SCHEDULE | \
1087 	EHCI_VIA_REDUCED_MAX_BULK_XFER_SIZE)
1088 
1089 #define	EHCI_VIA_MAX_BULK_XFER_SIZE 0x8000 /* Maximum bulk transfer size */
1090 
1091 
1092 /*
1093  * EHCI HCDI entry points
1094  *
1095  * The Host Controller Driver Interfaces (HCDI) are the software interfaces
1096  * between the Universal Serial Bus Driver (USBA) and the Host	Controller
1097  * Driver (HCD). The HCDI interfaces or entry points are subject to change.
1098  */
1099 int		ehci_hcdi_pipe_open(
1100 				usba_pipe_handle_data_t	*ph,
1101 				usb_flags_t		usb_flags);
1102 int		ehci_hcdi_pipe_close(
1103 				usba_pipe_handle_data_t	*ph,
1104 				usb_flags_t		usb_flags);
1105 int		ehci_hcdi_pipe_reset(
1106 				usba_pipe_handle_data_t	*ph,
1107 				usb_flags_t		usb_flags);
1108 void		ehci_hcdi_pipe_reset_data_toggle(
1109 				usba_pipe_handle_data_t	*ph);
1110 int		ehci_hcdi_pipe_ctrl_xfer(
1111 				usba_pipe_handle_data_t	*ph,
1112 				usb_ctrl_req_t		*ctrl_reqp,
1113 				usb_flags_t		usb_flags);
1114 int		ehci_hcdi_bulk_transfer_size(
1115 				usba_device_t		*usba_device,
1116 				size_t			*size);
1117 int		ehci_hcdi_pipe_bulk_xfer(
1118 				usba_pipe_handle_data_t	*ph,
1119 				usb_bulk_req_t		*bulk_reqp,
1120 				usb_flags_t		usb_flags);
1121 int		ehci_hcdi_pipe_intr_xfer(
1122 				usba_pipe_handle_data_t	*ph,
1123 				usb_intr_req_t		*intr_req,
1124 				usb_flags_t		usb_flags);
1125 int		ehci_hcdi_pipe_stop_intr_polling(
1126 				usba_pipe_handle_data_t	*ph,
1127 				usb_flags_t		usb_flags);
1128 int		ehci_hcdi_get_current_frame_number(
1129 				usba_device_t		*usba_device,
1130 				usb_frame_number_t	*frame_number);
1131 int		ehci_hcdi_get_max_isoc_pkts(
1132 				usba_device_t		*usba_device,
1133 				uint_t		*max_isoc_pkts_per_request);
1134 int		ehci_hcdi_pipe_isoc_xfer(
1135 				usba_pipe_handle_data_t	*ph,
1136 				usb_isoc_req_t		*isoc_reqp,
1137 				usb_flags_t		usb_flags);
1138 int		ehci_hcdi_pipe_stop_isoc_polling(
1139 				usba_pipe_handle_data_t	*ph,
1140 				usb_flags_t		usb_flags);
1141 
1142 /*
1143  * EHCI Polled entry points function prototypes.
1144  */
1145 int		ehci_hcdi_polled_input_init(
1146 				usba_pipe_handle_data_t	*ph,
1147 				uchar_t			**polled_buf,
1148 				usb_console_info_impl_t	*info);
1149 int		ehci_hcdi_polled_input_enter(
1150 				usb_console_info_impl_t	*info);
1151 int		ehci_hcdi_polled_read(
1152 				usb_console_info_impl_t	*info,
1153 				uint_t			*num_characters);
1154 int		ehci_hcdi_polled_input_exit(
1155 				usb_console_info_impl_t	*info);
1156 int		ehci_hcdi_polled_input_fini(
1157 				usb_console_info_impl_t	*info);
1158 int		ehci_hcdi_polled_output_init(
1159 				usba_pipe_handle_data_t	*ph,
1160 				usb_console_info_impl_t	*console_output_info);
1161 int		ehci_hcdi_polled_output_enter(
1162 				usb_console_info_impl_t	*info);
1163 int		ehci_hcdi_polled_write(
1164 				usb_console_info_impl_t *info,
1165 				uchar_t *buf,
1166 				uint_t num_characters,
1167 				uint_t *num_characters_written);
1168 int		ehci_hcdi_polled_output_exit(
1169 				usb_console_info_impl_t	*info);
1170 int		ehci_hcdi_polled_output_fini(
1171 				usb_console_info_impl_t *info);
1172 /*
1173  * EHCI Root Hub entry points function prototypes.
1174  */
1175 int		ehci_init_root_hub(
1176 				ehci_state_t		*ehcip);
1177 int		ehci_load_root_hub_driver(
1178 				ehci_state_t		*ehcip);
1179 int		ehci_unload_root_hub_driver(
1180 				ehci_state_t		*ehcip);
1181 int		ehci_handle_root_hub_pipe_open(
1182 				usba_pipe_handle_data_t	*ph,
1183 				usb_flags_t		flags);
1184 int		ehci_handle_root_hub_pipe_close(
1185 				usba_pipe_handle_data_t	*ph);
1186 int		ehci_handle_root_hub_pipe_reset(
1187 				usba_pipe_handle_data_t	*ph,
1188 				usb_flags_t		flags);
1189 int		ehci_handle_root_hub_request(
1190 				ehci_state_t		*ehcip,
1191 				usba_pipe_handle_data_t	*ph,
1192 				usb_ctrl_req_t		*ctrl_reqp);
1193 int		ehci_handle_root_hub_pipe_start_intr_polling(
1194 				usba_pipe_handle_data_t	*ph,
1195 				usb_intr_req_t		*intr_reqp,
1196 				usb_flags_t		flags);
1197 void		ehci_handle_root_hub_pipe_stop_intr_polling(
1198 				usba_pipe_handle_data_t	*ph,
1199 				usb_flags_t		flags);
1200 
1201 /*
1202  * EHCI Interrupt Handler entry point.
1203  */
1204 uint_t		ehci_intr(caddr_t			arg1,
1205 				caddr_t			arg2);
1206 
1207 #ifdef __cplusplus
1208 }
1209 #endif
1210 
1211 #endif /* _SYS_USB_EHCID_H */
1212