1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * MUSB OTG driver - support for Mentor's DMA controller 4 * 5 * Copyright 2005 Mentor Graphics Corporation 6 * Copyright (C) 2005-2007 by Texas Instruments 7 */ 8 #include <linux/device.h> 9 #include <linux/interrupt.h> 10 #include <linux/platform_device.h> 11 #include <linux/slab.h> 12 #include "musb_core.h" 13 #include "musbhsdma.h" 14 15 static void dma_channel_release(struct dma_channel *channel); 16 17 static void dma_controller_stop(struct musb_dma_controller *controller) 18 { 19 struct musb *musb = controller->private_data; 20 struct dma_channel *channel; 21 u8 bit; 22 23 if (controller->used_channels != 0) { 24 dev_err(musb->controller, 25 "Stopping DMA controller while channel active\n"); 26 27 for (bit = 0; bit < MUSB_HSDMA_CHANNELS; bit++) { 28 if (controller->used_channels & (1 << bit)) { 29 channel = &controller->channel[bit].channel; 30 dma_channel_release(channel); 31 32 if (!controller->used_channels) 33 break; 34 } 35 } 36 } 37 } 38 39 static struct dma_channel *dma_channel_allocate(struct dma_controller *c, 40 struct musb_hw_ep *hw_ep, u8 transmit) 41 { 42 struct musb_dma_controller *controller = container_of(c, 43 struct musb_dma_controller, controller); 44 struct musb_dma_channel *musb_channel = NULL; 45 struct dma_channel *channel = NULL; 46 u8 bit; 47 48 for (bit = 0; bit < MUSB_HSDMA_CHANNELS; bit++) { 49 if (!(controller->used_channels & (1 << bit))) { 50 controller->used_channels |= (1 << bit); 51 musb_channel = &(controller->channel[bit]); 52 musb_channel->controller = controller; 53 musb_channel->idx = bit; 54 musb_channel->epnum = hw_ep->epnum; 55 musb_channel->transmit = transmit; 56 channel = &(musb_channel->channel); 57 channel->private_data = musb_channel; 58 channel->status = MUSB_DMA_STATUS_FREE; 59 channel->max_len = 0x100000; 60 /* Tx => mode 1; Rx => mode 0 */ 61 channel->desired_mode = transmit; 62 channel->actual_len = 0; 63 break; 64 } 65 } 66 67 return channel; 68 } 69 70 static void dma_channel_release(struct dma_channel *channel) 71 { 72 struct musb_dma_channel *musb_channel = channel->private_data; 73 74 channel->actual_len = 0; 75 musb_channel->start_addr = 0; 76 musb_channel->len = 0; 77 78 musb_channel->controller->used_channels &= 79 ~(1 << musb_channel->idx); 80 81 channel->status = MUSB_DMA_STATUS_UNKNOWN; 82 } 83 84 static void configure_channel(struct dma_channel *channel, 85 u16 packet_sz, u8 mode, 86 dma_addr_t dma_addr, u32 len) 87 { 88 struct musb_dma_channel *musb_channel = channel->private_data; 89 struct musb_dma_controller *controller = musb_channel->controller; 90 struct musb *musb = controller->private_data; 91 void __iomem *mbase = controller->base; 92 u8 bchannel = musb_channel->idx; 93 u16 csr = 0; 94 95 musb_dbg(musb, "%p, pkt_sz %d, addr %pad, len %d, mode %d", 96 channel, packet_sz, &dma_addr, len, mode); 97 98 if (mode) { 99 csr |= 1 << MUSB_HSDMA_MODE1_SHIFT; 100 BUG_ON(len < packet_sz); 101 } 102 csr |= MUSB_HSDMA_BURSTMODE_INCR16 103 << MUSB_HSDMA_BURSTMODE_SHIFT; 104 105 csr |= (musb_channel->epnum << MUSB_HSDMA_ENDPOINT_SHIFT) 106 | (1 << MUSB_HSDMA_ENABLE_SHIFT) 107 | (1 << MUSB_HSDMA_IRQENABLE_SHIFT) 108 | (musb_channel->transmit 109 ? (1 << MUSB_HSDMA_TRANSMIT_SHIFT) 110 : 0); 111 112 /* address/count */ 113 musb_write_hsdma_addr(mbase, bchannel, dma_addr); 114 musb_write_hsdma_count(mbase, bchannel, len); 115 116 /* control (this should start things) */ 117 musb_writew(mbase, 118 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_CONTROL), 119 csr); 120 } 121 122 static int dma_channel_program(struct dma_channel *channel, 123 u16 packet_sz, u8 mode, 124 dma_addr_t dma_addr, u32 len) 125 { 126 struct musb_dma_channel *musb_channel = channel->private_data; 127 struct musb_dma_controller *controller = musb_channel->controller; 128 struct musb *musb = controller->private_data; 129 130 musb_dbg(musb, "ep%d-%s pkt_sz %d, dma_addr %pad length %d, mode %d", 131 musb_channel->epnum, 132 musb_channel->transmit ? "Tx" : "Rx", 133 packet_sz, &dma_addr, len, mode); 134 135 BUG_ON(channel->status == MUSB_DMA_STATUS_UNKNOWN || 136 channel->status == MUSB_DMA_STATUS_BUSY); 137 138 /* Let targets check/tweak the arguments */ 139 if (musb->ops->adjust_channel_params) { 140 int ret = musb->ops->adjust_channel_params(channel, 141 packet_sz, &mode, &dma_addr, &len); 142 if (ret) 143 return ret; 144 } 145 146 /* 147 * The DMA engine in RTL1.8 and above cannot handle 148 * DMA addresses that are not aligned to a 4 byte boundary. 149 * It ends up masking the last two bits of the address 150 * programmed in DMA_ADDR. 151 * 152 * Fail such DMA transfers, so that the backup PIO mode 153 * can carry out the transfer 154 */ 155 if ((musb->hwvers >= MUSB_HWVERS_1800) && (dma_addr % 4)) 156 return false; 157 158 channel->actual_len = 0; 159 musb_channel->start_addr = dma_addr; 160 musb_channel->len = len; 161 musb_channel->max_packet_sz = packet_sz; 162 channel->status = MUSB_DMA_STATUS_BUSY; 163 164 configure_channel(channel, packet_sz, mode, dma_addr, len); 165 166 return true; 167 } 168 169 static int dma_channel_abort(struct dma_channel *channel) 170 { 171 struct musb_dma_channel *musb_channel = channel->private_data; 172 void __iomem *mbase = musb_channel->controller->base; 173 struct musb *musb = musb_channel->controller->private_data; 174 175 u8 bchannel = musb_channel->idx; 176 int offset; 177 u16 csr; 178 179 if (channel->status == MUSB_DMA_STATUS_BUSY) { 180 if (musb_channel->transmit) { 181 offset = musb->io.ep_offset(musb_channel->epnum, 182 MUSB_TXCSR); 183 184 /* 185 * The programming guide says that we must clear 186 * the DMAENAB bit before the DMAMODE bit... 187 */ 188 csr = musb_readw(mbase, offset); 189 csr &= ~(MUSB_TXCSR_AUTOSET | MUSB_TXCSR_DMAENAB); 190 musb_writew(mbase, offset, csr); 191 csr &= ~MUSB_TXCSR_DMAMODE; 192 musb_writew(mbase, offset, csr); 193 } else { 194 offset = musb->io.ep_offset(musb_channel->epnum, 195 MUSB_RXCSR); 196 197 csr = musb_readw(mbase, offset); 198 csr &= ~(MUSB_RXCSR_AUTOCLEAR | 199 MUSB_RXCSR_DMAENAB | 200 MUSB_RXCSR_DMAMODE); 201 musb_writew(mbase, offset, csr); 202 } 203 204 musb_writew(mbase, 205 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, MUSB_HSDMA_CONTROL), 206 0); 207 musb_write_hsdma_addr(mbase, bchannel, 0); 208 musb_write_hsdma_count(mbase, bchannel, 0); 209 channel->status = MUSB_DMA_STATUS_FREE; 210 } 211 212 return 0; 213 } 214 215 static irqreturn_t dma_controller_irq(int irq, void *private_data) 216 { 217 struct musb_dma_controller *controller = private_data; 218 struct musb *musb = controller->private_data; 219 struct musb_dma_channel *musb_channel; 220 struct dma_channel *channel; 221 222 void __iomem *mbase = controller->base; 223 224 irqreturn_t retval = IRQ_NONE; 225 226 unsigned long flags; 227 228 u8 bchannel; 229 u8 int_hsdma; 230 231 u32 addr, count; 232 u16 csr; 233 234 spin_lock_irqsave(&musb->lock, flags); 235 236 int_hsdma = musb_readb(mbase, MUSB_HSDMA_INTR); 237 238 if (!int_hsdma) { 239 musb_dbg(musb, "spurious DMA irq"); 240 241 for (bchannel = 0; bchannel < MUSB_HSDMA_CHANNELS; bchannel++) { 242 musb_channel = (struct musb_dma_channel *) 243 &(controller->channel[bchannel]); 244 channel = &musb_channel->channel; 245 if (channel->status == MUSB_DMA_STATUS_BUSY) { 246 count = musb_read_hsdma_count(mbase, bchannel); 247 248 if (count == 0) 249 int_hsdma |= (1 << bchannel); 250 } 251 } 252 253 musb_dbg(musb, "int_hsdma = 0x%x", int_hsdma); 254 255 if (!int_hsdma) 256 goto done; 257 } 258 259 for (bchannel = 0; bchannel < MUSB_HSDMA_CHANNELS; bchannel++) { 260 if (int_hsdma & (1 << bchannel)) { 261 musb_channel = (struct musb_dma_channel *) 262 &(controller->channel[bchannel]); 263 channel = &musb_channel->channel; 264 265 csr = musb_readw(mbase, 266 MUSB_HSDMA_CHANNEL_OFFSET(bchannel, 267 MUSB_HSDMA_CONTROL)); 268 269 if (csr & (1 << MUSB_HSDMA_BUSERROR_SHIFT)) { 270 musb_channel->channel.status = 271 MUSB_DMA_STATUS_BUS_ABORT; 272 } else { 273 u8 devctl; 274 275 addr = musb_read_hsdma_addr(mbase, 276 bchannel); 277 channel->actual_len = addr 278 - musb_channel->start_addr; 279 280 musb_dbg(musb, "ch %p, 0x%x -> 0x%x (%zu / %d) %s", 281 channel, musb_channel->start_addr, 282 addr, channel->actual_len, 283 musb_channel->len, 284 (channel->actual_len 285 < musb_channel->len) ? 286 "=> reconfig 0" : "=> complete"); 287 288 devctl = musb_readb(mbase, MUSB_DEVCTL); 289 290 channel->status = MUSB_DMA_STATUS_FREE; 291 292 /* completed */ 293 if ((devctl & MUSB_DEVCTL_HM) 294 && (musb_channel->transmit) 295 && ((channel->desired_mode == 0) 296 || (channel->actual_len & 297 (musb_channel->max_packet_sz - 1))) 298 ) { 299 u8 epnum = musb_channel->epnum; 300 int offset = musb->io.ep_offset(epnum, 301 MUSB_TXCSR); 302 u16 txcsr; 303 304 /* 305 * The programming guide says that we 306 * must clear DMAENAB before DMAMODE. 307 */ 308 musb_ep_select(mbase, epnum); 309 txcsr = musb_readw(mbase, offset); 310 txcsr &= ~(MUSB_TXCSR_DMAENAB 311 | MUSB_TXCSR_AUTOSET); 312 musb_writew(mbase, offset, txcsr); 313 /* Send out the packet */ 314 txcsr &= ~MUSB_TXCSR_DMAMODE; 315 txcsr |= MUSB_TXCSR_TXPKTRDY; 316 musb_writew(mbase, offset, txcsr); 317 } 318 musb_dma_completion(musb, musb_channel->epnum, 319 musb_channel->transmit); 320 } 321 } 322 } 323 324 retval = IRQ_HANDLED; 325 done: 326 spin_unlock_irqrestore(&musb->lock, flags); 327 return retval; 328 } 329 330 void musbhs_dma_controller_destroy(struct dma_controller *c) 331 { 332 struct musb_dma_controller *controller = container_of(c, 333 struct musb_dma_controller, controller); 334 335 dma_controller_stop(controller); 336 337 if (controller->irq) 338 free_irq(controller->irq, c); 339 340 kfree(controller); 341 } 342 EXPORT_SYMBOL_GPL(musbhs_dma_controller_destroy); 343 344 struct dma_controller *musbhs_dma_controller_create(struct musb *musb, 345 void __iomem *base) 346 { 347 struct musb_dma_controller *controller; 348 struct device *dev = musb->controller; 349 struct platform_device *pdev = to_platform_device(dev); 350 int irq = platform_get_irq_byname(pdev, "dma"); 351 352 if (irq <= 0) { 353 dev_err(dev, "No DMA interrupt line!\n"); 354 return NULL; 355 } 356 357 controller = kzalloc(sizeof(*controller), GFP_KERNEL); 358 if (!controller) 359 return NULL; 360 361 controller->channel_count = MUSB_HSDMA_CHANNELS; 362 controller->private_data = musb; 363 controller->base = base; 364 365 controller->controller.channel_alloc = dma_channel_allocate; 366 controller->controller.channel_release = dma_channel_release; 367 controller->controller.channel_program = dma_channel_program; 368 controller->controller.channel_abort = dma_channel_abort; 369 370 if (request_irq(irq, dma_controller_irq, 0, 371 dev_name(musb->controller), &controller->controller)) { 372 dev_err(dev, "request_irq %d failed!\n", irq); 373 musb_dma_controller_destroy(&controller->controller); 374 375 return NULL; 376 } 377 378 controller->irq = irq; 379 380 return &controller->controller; 381 } 382 EXPORT_SYMBOL_GPL(musbhs_dma_controller_create); 383