1 /*
2 * Copyright (c) 2001 by David Brownell
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 */
18
19 /* this file is part of ehci-hcd.c */
20
21 /*-------------------------------------------------------------------------*/
22
23 /*
24 * There's basically three types of memory:
25 * - data used only by the HCD ... kmalloc is fine
26 * - async and periodic schedules, shared by HC and HCD ... these
27 * need to use pci_pool or pci_alloc_consistent
28 * - driver buffers, read/written by HC ... single shot DMA mapped
29 *
30 * There's also PCI "register" data, which is memory mapped.
31 * No memory seen by this driver is pageable.
32 */
33
34 /*-------------------------------------------------------------------------*/
35 /*
36 * Allocator / cleanup for the per device structure
37 * Called by hcd init / removal code
38 */
ehci_hcd_alloc(void)39 static struct usb_hcd *ehci_hcd_alloc (void)
40 {
41 struct ehci_hcd *ehci;
42
43 ehci = (struct ehci_hcd *)
44 kmalloc (sizeof (struct ehci_hcd), GFP_KERNEL);
45 if (ehci != 0) {
46 memset (ehci, 0, sizeof (struct ehci_hcd));
47 return &ehci->hcd;
48 }
49 return 0;
50 }
51
ehci_hcd_free(struct usb_hcd * hcd)52 static void ehci_hcd_free (struct usb_hcd *hcd)
53 {
54 kfree (hcd_to_ehci (hcd));
55 }
56
57 /*-------------------------------------------------------------------------*/
58
59 /* Allocate the key transfer structures from the previously allocated pool */
60
ehci_qtd_init(struct ehci_qtd * qtd,dma_addr_t dma)61 static inline void ehci_qtd_init (struct ehci_qtd *qtd, dma_addr_t dma)
62 {
63 memset (qtd, 0, sizeof *qtd);
64 qtd->qtd_dma = dma;
65 qtd->hw_token = cpu_to_le32 (QTD_STS_HALT);
66 qtd->hw_next = EHCI_LIST_END;
67 qtd->hw_alt_next = EHCI_LIST_END;
68 INIT_LIST_HEAD (&qtd->qtd_list);
69 }
70
ehci_qtd_alloc(struct ehci_hcd * ehci,int flags)71 static struct ehci_qtd *ehci_qtd_alloc (struct ehci_hcd *ehci, int flags)
72 {
73 struct ehci_qtd *qtd;
74 dma_addr_t dma;
75
76 qtd = pci_pool_alloc (ehci->qtd_pool, flags, &dma);
77 if (qtd != 0) {
78 ehci_qtd_init (qtd, dma);
79 }
80 return qtd;
81 }
82
ehci_qtd_free(struct ehci_hcd * ehci,struct ehci_qtd * qtd)83 static inline void ehci_qtd_free (struct ehci_hcd *ehci, struct ehci_qtd *qtd)
84 {
85 pci_pool_free (ehci->qtd_pool, qtd, qtd->qtd_dma);
86 }
87
88
ehci_qh_alloc(struct ehci_hcd * ehci,int flags)89 static struct ehci_qh *ehci_qh_alloc (struct ehci_hcd *ehci, int flags)
90 {
91 struct ehci_qh *qh;
92 dma_addr_t dma;
93
94 qh = (struct ehci_qh *)
95 pci_pool_alloc (ehci->qh_pool, flags, &dma);
96 if (!qh)
97 return qh;
98
99 memset (qh, 0, sizeof *qh);
100 atomic_set (&qh->refcount, 1);
101 qh->qh_dma = dma;
102 // INIT_LIST_HEAD (&qh->qh_list);
103 INIT_LIST_HEAD (&qh->qtd_list);
104
105 /* dummy td enables safe urb queuing */
106 qh->dummy = ehci_qtd_alloc (ehci, flags);
107 if (qh->dummy == 0) {
108 ehci_dbg (ehci, "no dummy td\n");
109 pci_pool_free (ehci->qh_pool, qh, qh->qh_dma);
110 qh = 0;
111 }
112 return qh;
113 }
114
115 /* to share a qh (cpu threads, or hc) */
qh_get(struct ehci_qh * qh)116 static inline struct ehci_qh *qh_get (/* ehci, */ struct ehci_qh *qh)
117 {
118 atomic_inc (&qh->refcount);
119 return qh;
120 }
121
qh_put(struct ehci_hcd * ehci,struct ehci_qh * qh)122 static void qh_put (struct ehci_hcd *ehci, struct ehci_qh *qh)
123 {
124 if (!atomic_dec_and_test (&qh->refcount))
125 return;
126 /* clean qtds first, and know this is not linked */
127 if (!list_empty (&qh->qtd_list) || qh->qh_next.ptr) {
128 ehci_dbg (ehci, "unused qh not empty!\n");
129 BUG ();
130 }
131 if (qh->dummy)
132 ehci_qtd_free (ehci, qh->dummy);
133 // usb_put_dev (qh->dev);
134 pci_pool_free (ehci->qh_pool, qh, qh->qh_dma);
135 }
136
137 /*-------------------------------------------------------------------------*/
138
139 /* The queue heads and transfer descriptors are managed from pools tied
140 * to each of the "per device" structures.
141 * This is the initialisation and cleanup code.
142 */
143
ehci_mem_cleanup(struct ehci_hcd * ehci)144 static void ehci_mem_cleanup (struct ehci_hcd *ehci)
145 {
146 if (ehci->async)
147 qh_put (ehci, ehci->async);
148 ehci->async = 0;
149
150 /* PCI consistent memory and pools */
151 if (ehci->qtd_pool)
152 pci_pool_destroy (ehci->qtd_pool);
153 ehci->qtd_pool = 0;
154
155 if (ehci->qh_pool) {
156 pci_pool_destroy (ehci->qh_pool);
157 ehci->qh_pool = 0;
158 }
159
160 if (ehci->itd_pool)
161 pci_pool_destroy (ehci->itd_pool);
162 ehci->itd_pool = 0;
163
164 if (ehci->sitd_pool)
165 pci_pool_destroy (ehci->sitd_pool);
166 ehci->sitd_pool = 0;
167
168 if (ehci->periodic)
169 pci_free_consistent (ehci->hcd.pdev,
170 ehci->periodic_size * sizeof (u32),
171 ehci->periodic, ehci->periodic_dma);
172 ehci->periodic = 0;
173
174 /* shadow periodic table */
175 if (ehci->pshadow)
176 kfree (ehci->pshadow);
177 ehci->pshadow = 0;
178 }
179
180 /* remember to add cleanup code (above) if you add anything here */
ehci_mem_init(struct ehci_hcd * ehci,int flags)181 static int ehci_mem_init (struct ehci_hcd *ehci, int flags)
182 {
183 int i;
184
185 /* QTDs for control/bulk/intr transfers */
186 ehci->qtd_pool = pci_pool_create ("ehci_qtd", ehci->hcd.pdev,
187 sizeof (struct ehci_qtd),
188 32 /* byte alignment (for hw parts) */,
189 4096 /* can't cross 4K */,
190 flags);
191 if (!ehci->qtd_pool) {
192 goto fail;
193 }
194
195 /* QHs for control/bulk/intr transfers */
196 ehci->qh_pool = pci_pool_create ("ehci_qh", ehci->hcd.pdev,
197 sizeof (struct ehci_qh),
198 32 /* byte alignment (for hw parts) */,
199 4096 /* can't cross 4K */,
200 flags);
201 if (!ehci->qh_pool) {
202 goto fail;
203 }
204 ehci->async = ehci_qh_alloc (ehci, flags);
205 if (!ehci->async) {
206 goto fail;
207 }
208
209 /* ITD for high speed ISO transfers */
210 ehci->itd_pool = pci_pool_create ("ehci_itd", ehci->hcd.pdev,
211 sizeof (struct ehci_itd),
212 32 /* byte alignment (for hw parts) */,
213 4096 /* can't cross 4K */,
214 flags);
215 if (!ehci->itd_pool) {
216 goto fail;
217 }
218
219 /* SITD for full/low speed split ISO transfers */
220 ehci->sitd_pool = pci_pool_create ("ehci_sitd", ehci->hcd.pdev,
221 sizeof (struct ehci_sitd),
222 32 /* byte alignment (for hw parts) */,
223 4096 /* can't cross 4K */,
224 flags);
225 if (!ehci->sitd_pool) {
226 goto fail;
227 }
228
229 /* Hardware periodic table */
230 ehci->periodic = (u32 *)
231 pci_alloc_consistent (ehci->hcd.pdev,
232 ehci->periodic_size * sizeof (u32),
233 &ehci->periodic_dma);
234 if (ehci->periodic == 0) {
235 goto fail;
236 }
237 for (i = 0; i < ehci->periodic_size; i++)
238 ehci->periodic [i] = EHCI_LIST_END;
239
240 /* software shadow of hardware table */
241 ehci->pshadow = kmalloc (ehci->periodic_size * sizeof (void *), flags);
242 if (ehci->pshadow == 0) {
243 goto fail;
244 }
245 memset (ehci->pshadow, 0, ehci->periodic_size * sizeof (void *));
246
247 return 0;
248
249 fail:
250 ehci_dbg (ehci, "couldn't init memory\n");
251 ehci_mem_cleanup (ehci);
252 return -ENOMEM;
253 }
254