Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2001 by David Brownell |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 3 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 dma_pool or dma_alloc_coherent |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 28 | * - driver buffers, read/written by HC ... single shot DMA mapped |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | * |
Stefan Roese | 6dbd682 | 2007-05-01 09:29:37 -0700 | [diff] [blame] | 30 | * There's also "register" data (e.g. PCI or SOC), which is memory mapped. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | * No memory seen by this driver is pageable. |
| 32 | */ |
| 33 | |
| 34 | /*-------------------------------------------------------------------------*/ |
| 35 | |
| 36 | /* Allocate the key transfer structures from the previously allocated pool */ |
| 37 | |
Stefan Roese | 6dbd682 | 2007-05-01 09:29:37 -0700 | [diff] [blame] | 38 | static inline void ehci_qtd_init(struct ehci_hcd *ehci, struct ehci_qtd *qtd, |
| 39 | dma_addr_t dma) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | { |
| 41 | memset (qtd, 0, sizeof *qtd); |
| 42 | qtd->qtd_dma = dma; |
| 43 | qtd->hw_token = cpu_to_le32 (QTD_STS_HALT); |
Stefan Roese | 6dbd682 | 2007-05-01 09:29:37 -0700 | [diff] [blame] | 44 | qtd->hw_next = EHCI_LIST_END(ehci); |
| 45 | qtd->hw_alt_next = EHCI_LIST_END(ehci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | INIT_LIST_HEAD (&qtd->qtd_list); |
| 47 | } |
| 48 | |
Al Viro | 55016f1 | 2005-10-21 03:21:58 -0400 | [diff] [blame] | 49 | static struct ehci_qtd *ehci_qtd_alloc (struct ehci_hcd *ehci, gfp_t flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | { |
| 51 | struct ehci_qtd *qtd; |
| 52 | dma_addr_t dma; |
| 53 | |
| 54 | qtd = dma_pool_alloc (ehci->qtd_pool, flags, &dma); |
| 55 | if (qtd != NULL) { |
Stefan Roese | 6dbd682 | 2007-05-01 09:29:37 -0700 | [diff] [blame] | 56 | ehci_qtd_init(ehci, qtd, dma); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | } |
| 58 | return qtd; |
| 59 | } |
| 60 | |
| 61 | static inline void ehci_qtd_free (struct ehci_hcd *ehci, struct ehci_qtd *qtd) |
| 62 | { |
| 63 | dma_pool_free (ehci->qtd_pool, qtd, qtd->qtd_dma); |
| 64 | } |
| 65 | |
| 66 | |
David Brownell | 9c033e8 | 2007-05-17 12:21:19 -0700 | [diff] [blame] | 67 | static void qh_destroy(struct ehci_qh *qh) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 69 | struct ehci_hcd *ehci = qh->ehci; |
| 70 | |
| 71 | /* clean qtds first, and know this is not linked */ |
| 72 | if (!list_empty (&qh->qtd_list) || qh->qh_next.ptr) { |
| 73 | ehci_dbg (ehci, "unused qh not empty!\n"); |
| 74 | BUG (); |
| 75 | } |
| 76 | if (qh->dummy) |
| 77 | ehci_qtd_free (ehci, qh->dummy); |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 78 | dma_pool_free(ehci->qh_pool, qh->hw, qh->qh_dma); |
| 79 | kfree(qh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | } |
| 81 | |
Al Viro | 55016f1 | 2005-10-21 03:21:58 -0400 | [diff] [blame] | 82 | static struct ehci_qh *ehci_qh_alloc (struct ehci_hcd *ehci, gfp_t flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | { |
| 84 | struct ehci_qh *qh; |
| 85 | dma_addr_t dma; |
| 86 | |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 87 | qh = kzalloc(sizeof *qh, GFP_ATOMIC); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | if (!qh) |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 89 | goto done; |
| 90 | qh->hw = (struct ehci_qh_hw *) |
| 91 | dma_pool_alloc(ehci->qh_pool, flags, &dma); |
| 92 | if (!qh->hw) |
| 93 | goto fail; |
| 94 | memset(qh->hw, 0, sizeof *qh->hw); |
David Brownell | 9c033e8 | 2007-05-17 12:21:19 -0700 | [diff] [blame] | 95 | qh->refcount = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | qh->ehci = ehci; |
| 97 | qh->qh_dma = dma; |
| 98 | // INIT_LIST_HEAD (&qh->qh_list); |
| 99 | INIT_LIST_HEAD (&qh->qtd_list); |
| 100 | |
| 101 | /* dummy td enables safe urb queuing */ |
| 102 | qh->dummy = ehci_qtd_alloc (ehci, flags); |
| 103 | if (qh->dummy == NULL) { |
| 104 | ehci_dbg (ehci, "no dummy td\n"); |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 105 | goto fail1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | } |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 107 | done: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 108 | return qh; |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 109 | fail1: |
| 110 | dma_pool_free(ehci->qh_pool, qh->hw, qh->qh_dma); |
| 111 | fail: |
| 112 | kfree(qh); |
| 113 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | } |
| 115 | |
| 116 | /* to share a qh (cpu threads, or hc) */ |
| 117 | static inline struct ehci_qh *qh_get (struct ehci_qh *qh) |
| 118 | { |
David Brownell | 9c033e8 | 2007-05-17 12:21:19 -0700 | [diff] [blame] | 119 | WARN_ON(!qh->refcount); |
| 120 | qh->refcount++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | return qh; |
| 122 | } |
| 123 | |
| 124 | static inline void qh_put (struct ehci_qh *qh) |
| 125 | { |
David Brownell | 9c033e8 | 2007-05-17 12:21:19 -0700 | [diff] [blame] | 126 | if (!--qh->refcount) |
| 127 | qh_destroy(qh); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | } |
| 129 | |
| 130 | /*-------------------------------------------------------------------------*/ |
| 131 | |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 132 | /* The queue heads and transfer descriptors are managed from pools tied |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | * to each of the "per device" structures. |
| 134 | * This is the initialisation and cleanup code. |
| 135 | */ |
| 136 | |
| 137 | static void ehci_mem_cleanup (struct ehci_hcd *ehci) |
| 138 | { |
Alan Stern | 0e5f231 | 2010-04-08 16:56:37 -0400 | [diff] [blame] | 139 | free_cached_lists(ehci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | if (ehci->async) |
| 141 | qh_put (ehci->async); |
| 142 | ehci->async = NULL; |
| 143 | |
| 144 | /* DMA consistent memory and pools */ |
| 145 | if (ehci->qtd_pool) |
| 146 | dma_pool_destroy (ehci->qtd_pool); |
| 147 | ehci->qtd_pool = NULL; |
| 148 | |
| 149 | if (ehci->qh_pool) { |
| 150 | dma_pool_destroy (ehci->qh_pool); |
| 151 | ehci->qh_pool = NULL; |
| 152 | } |
| 153 | |
| 154 | if (ehci->itd_pool) |
| 155 | dma_pool_destroy (ehci->itd_pool); |
| 156 | ehci->itd_pool = NULL; |
| 157 | |
| 158 | if (ehci->sitd_pool) |
| 159 | dma_pool_destroy (ehci->sitd_pool); |
| 160 | ehci->sitd_pool = NULL; |
| 161 | |
| 162 | if (ehci->periodic) |
| 163 | dma_free_coherent (ehci_to_hcd(ehci)->self.controller, |
| 164 | ehci->periodic_size * sizeof (u32), |
| 165 | ehci->periodic, ehci->periodic_dma); |
| 166 | ehci->periodic = NULL; |
| 167 | |
| 168 | /* shadow periodic table */ |
Jesper Juhl | 1bc3c9e | 2005-04-18 17:39:34 -0700 | [diff] [blame] | 169 | kfree(ehci->pshadow); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | ehci->pshadow = NULL; |
| 171 | } |
| 172 | |
| 173 | /* remember to add cleanup code (above) if you add anything here */ |
Al Viro | 55016f1 | 2005-10-21 03:21:58 -0400 | [diff] [blame] | 174 | static int ehci_mem_init (struct ehci_hcd *ehci, gfp_t flags) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | { |
| 176 | int i; |
| 177 | |
| 178 | /* QTDs for control/bulk/intr transfers */ |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 179 | ehci->qtd_pool = dma_pool_create ("ehci_qtd", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | ehci_to_hcd(ehci)->self.controller, |
| 181 | sizeof (struct ehci_qtd), |
| 182 | 32 /* byte alignment (for hw parts) */, |
| 183 | 4096 /* can't cross 4K */); |
| 184 | if (!ehci->qtd_pool) { |
| 185 | goto fail; |
| 186 | } |
| 187 | |
| 188 | /* QHs for control/bulk/intr transfers */ |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 189 | ehci->qh_pool = dma_pool_create ("ehci_qh", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | ehci_to_hcd(ehci)->self.controller, |
Alek Du | 3807e26 | 2009-07-14 07:23:29 +0800 | [diff] [blame] | 191 | sizeof(struct ehci_qh_hw), |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | 32 /* byte alignment (for hw parts) */, |
| 193 | 4096 /* can't cross 4K */); |
| 194 | if (!ehci->qh_pool) { |
| 195 | goto fail; |
| 196 | } |
| 197 | ehci->async = ehci_qh_alloc (ehci, flags); |
| 198 | if (!ehci->async) { |
| 199 | goto fail; |
| 200 | } |
| 201 | |
| 202 | /* ITD for high speed ISO transfers */ |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 203 | ehci->itd_pool = dma_pool_create ("ehci_itd", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | ehci_to_hcd(ehci)->self.controller, |
| 205 | sizeof (struct ehci_itd), |
| 206 | 32 /* byte alignment (for hw parts) */, |
| 207 | 4096 /* can't cross 4K */); |
| 208 | if (!ehci->itd_pool) { |
| 209 | goto fail; |
| 210 | } |
| 211 | |
| 212 | /* SITD for full/low speed split ISO transfers */ |
David Brownell | 53bd6a6 | 2006-08-30 14:50:06 -0700 | [diff] [blame] | 213 | ehci->sitd_pool = dma_pool_create ("ehci_sitd", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | ehci_to_hcd(ehci)->self.controller, |
| 215 | sizeof (struct ehci_sitd), |
| 216 | 32 /* byte alignment (for hw parts) */, |
| 217 | 4096 /* can't cross 4K */); |
| 218 | if (!ehci->sitd_pool) { |
| 219 | goto fail; |
| 220 | } |
| 221 | |
| 222 | /* Hardware periodic table */ |
| 223 | ehci->periodic = (__le32 *) |
| 224 | dma_alloc_coherent (ehci_to_hcd(ehci)->self.controller, |
| 225 | ehci->periodic_size * sizeof(__le32), |
| 226 | &ehci->periodic_dma, 0); |
| 227 | if (ehci->periodic == NULL) { |
| 228 | goto fail; |
| 229 | } |
| 230 | for (i = 0; i < ehci->periodic_size; i++) |
Stefan Roese | 6dbd682 | 2007-05-01 09:29:37 -0700 | [diff] [blame] | 231 | ehci->periodic [i] = EHCI_LIST_END(ehci); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | |
| 233 | /* software shadow of hardware table */ |
Eric Sesterhenn | 80b6ca4 | 2006-02-27 21:29:43 +0100 | [diff] [blame] | 234 | ehci->pshadow = kcalloc(ehci->periodic_size, sizeof(void *), flags); |
| 235 | if (ehci->pshadow != NULL) |
| 236 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
| 238 | fail: |
| 239 | ehci_dbg (ehci, "couldn't init memory\n"); |
| 240 | ehci_mem_cleanup (ehci); |
| 241 | return -ENOMEM; |
| 242 | } |