1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * FOTG210 UDC Driver supports Bulk transfer so far |
4 | * |
5 | * Copyright (C) 2013 Faraday Technology Corporation |
6 | * |
7 | * Author : Yuan-Hsin Chen <yhchen@faraday-tech.com> |
8 | */ |
9 | |
10 | #include <linux/delay.h> |
11 | #include <linux/dma-mapping.h> |
12 | #include <linux/err.h> |
13 | #include <linux/interrupt.h> |
14 | #include <linux/io.h> |
15 | #include <linux/module.h> |
16 | #include <linux/platform_device.h> |
17 | #include <linux/usb/ch9.h> |
18 | #include <linux/usb/gadget.h> |
19 | #include <linux/usb/otg.h> |
20 | #include <linux/usb/phy.h> |
21 | |
22 | #include "fotg210.h" |
23 | #include "fotg210-udc.h" |
24 | |
25 | #define DRIVER_DESC "FOTG210 USB Device Controller Driver" |
26 | #define DRIVER_VERSION "30-April-2013" |
27 | |
28 | static const char udc_name[] = "fotg210_udc" ; |
29 | static const char * const fotg210_ep_name[] = { |
30 | "ep0" , "ep1" , "ep2" , "ep3" , "ep4" }; |
31 | |
32 | static void fotg210_ack_int(struct fotg210_udc *fotg210, u32 offset, u32 mask) |
33 | { |
34 | u32 value = ioread32(fotg210->reg + offset); |
35 | |
36 | value &= ~mask; |
37 | iowrite32(value, fotg210->reg + offset); |
38 | } |
39 | |
40 | static void fotg210_disable_fifo_int(struct fotg210_ep *ep) |
41 | { |
42 | u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1); |
43 | |
44 | if (ep->dir_in) |
45 | value |= DMISGR1_MF_IN_INT(ep->epnum - 1); |
46 | else |
47 | value |= DMISGR1_MF_OUTSPK_INT(ep->epnum - 1); |
48 | iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR1); |
49 | } |
50 | |
51 | static void fotg210_enable_fifo_int(struct fotg210_ep *ep) |
52 | { |
53 | u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1); |
54 | |
55 | if (ep->dir_in) |
56 | value &= ~DMISGR1_MF_IN_INT(ep->epnum - 1); |
57 | else |
58 | value &= ~DMISGR1_MF_OUTSPK_INT(ep->epnum - 1); |
59 | iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR1); |
60 | } |
61 | |
62 | static void fotg210_set_cxdone(struct fotg210_udc *fotg210) |
63 | { |
64 | u32 value = ioread32(fotg210->reg + FOTG210_DCFESR); |
65 | |
66 | value |= DCFESR_CX_DONE; |
67 | iowrite32(value, fotg210->reg + FOTG210_DCFESR); |
68 | } |
69 | |
70 | static void fotg210_done(struct fotg210_ep *ep, struct fotg210_request *req, |
71 | int status) |
72 | { |
73 | list_del_init(entry: &req->queue); |
74 | |
75 | /* don't modify queue heads during completion callback */ |
76 | if (ep->fotg210->gadget.speed == USB_SPEED_UNKNOWN) |
77 | req->req.status = -ESHUTDOWN; |
78 | else |
79 | req->req.status = status; |
80 | |
81 | spin_unlock(lock: &ep->fotg210->lock); |
82 | usb_gadget_giveback_request(ep: &ep->ep, req: &req->req); |
83 | spin_lock(lock: &ep->fotg210->lock); |
84 | |
85 | if (ep->epnum) { |
86 | if (list_empty(head: &ep->queue)) |
87 | fotg210_disable_fifo_int(ep); |
88 | } else { |
89 | fotg210_set_cxdone(fotg210: ep->fotg210); |
90 | } |
91 | } |
92 | |
93 | static void fotg210_fifo_ep_mapping(struct fotg210_ep *ep, u32 epnum, |
94 | u32 dir_in) |
95 | { |
96 | struct fotg210_udc *fotg210 = ep->fotg210; |
97 | u32 val; |
98 | |
99 | /* Driver should map an ep to a fifo and then map the fifo |
100 | * to the ep. What a brain-damaged design! |
101 | */ |
102 | |
103 | /* map a fifo to an ep */ |
104 | val = ioread32(fotg210->reg + FOTG210_EPMAP); |
105 | val &= ~EPMAP_FIFONOMSK(epnum, dir_in); |
106 | val |= EPMAP_FIFONO(epnum, dir_in); |
107 | iowrite32(val, fotg210->reg + FOTG210_EPMAP); |
108 | |
109 | /* map the ep to the fifo */ |
110 | val = ioread32(fotg210->reg + FOTG210_FIFOMAP); |
111 | val &= ~FIFOMAP_EPNOMSK(epnum); |
112 | val |= FIFOMAP_EPNO(epnum); |
113 | iowrite32(val, fotg210->reg + FOTG210_FIFOMAP); |
114 | |
115 | /* enable fifo */ |
116 | val = ioread32(fotg210->reg + FOTG210_FIFOCF); |
117 | val |= FIFOCF_FIFO_EN(epnum - 1); |
118 | iowrite32(val, fotg210->reg + FOTG210_FIFOCF); |
119 | } |
120 | |
121 | static void fotg210_set_fifo_dir(struct fotg210_ep *ep, u32 epnum, u32 dir_in) |
122 | { |
123 | struct fotg210_udc *fotg210 = ep->fotg210; |
124 | u32 val; |
125 | |
126 | val = ioread32(fotg210->reg + FOTG210_FIFOMAP); |
127 | val |= (dir_in ? FIFOMAP_DIRIN(epnum - 1) : FIFOMAP_DIROUT(epnum - 1)); |
128 | iowrite32(val, fotg210->reg + FOTG210_FIFOMAP); |
129 | } |
130 | |
131 | static void fotg210_set_tfrtype(struct fotg210_ep *ep, u32 epnum, u32 type) |
132 | { |
133 | struct fotg210_udc *fotg210 = ep->fotg210; |
134 | u32 val; |
135 | |
136 | val = ioread32(fotg210->reg + FOTG210_FIFOCF); |
137 | val |= FIFOCF_TYPE(type, epnum - 1); |
138 | iowrite32(val, fotg210->reg + FOTG210_FIFOCF); |
139 | } |
140 | |
141 | static void fotg210_set_mps(struct fotg210_ep *ep, u32 epnum, u32 mps, |
142 | u32 dir_in) |
143 | { |
144 | struct fotg210_udc *fotg210 = ep->fotg210; |
145 | u32 val; |
146 | u32 offset = dir_in ? FOTG210_INEPMPSR(epnum) : |
147 | FOTG210_OUTEPMPSR(epnum); |
148 | |
149 | val = ioread32(fotg210->reg + offset); |
150 | val |= INOUTEPMPSR_MPS(mps); |
151 | iowrite32(val, fotg210->reg + offset); |
152 | } |
153 | |
154 | static int fotg210_config_ep(struct fotg210_ep *ep, |
155 | const struct usb_endpoint_descriptor *desc) |
156 | { |
157 | struct fotg210_udc *fotg210 = ep->fotg210; |
158 | |
159 | fotg210_set_fifo_dir(ep, epnum: ep->epnum, dir_in: ep->dir_in); |
160 | fotg210_set_tfrtype(ep, epnum: ep->epnum, type: ep->type); |
161 | fotg210_set_mps(ep, epnum: ep->epnum, mps: ep->ep.maxpacket, dir_in: ep->dir_in); |
162 | fotg210_fifo_ep_mapping(ep, epnum: ep->epnum, dir_in: ep->dir_in); |
163 | |
164 | fotg210->ep[ep->epnum] = ep; |
165 | |
166 | return 0; |
167 | } |
168 | |
169 | static int fotg210_ep_enable(struct usb_ep *_ep, |
170 | const struct usb_endpoint_descriptor *desc) |
171 | { |
172 | struct fotg210_ep *ep; |
173 | |
174 | ep = container_of(_ep, struct fotg210_ep, ep); |
175 | |
176 | ep->desc = desc; |
177 | ep->epnum = usb_endpoint_num(epd: desc); |
178 | ep->type = usb_endpoint_type(epd: desc); |
179 | ep->dir_in = usb_endpoint_dir_in(epd: desc); |
180 | ep->ep.maxpacket = usb_endpoint_maxp(epd: desc); |
181 | |
182 | return fotg210_config_ep(ep, desc); |
183 | } |
184 | |
185 | static void fotg210_reset_tseq(struct fotg210_udc *fotg210, u8 epnum) |
186 | { |
187 | struct fotg210_ep *ep = fotg210->ep[epnum]; |
188 | u32 value; |
189 | void __iomem *reg; |
190 | |
191 | reg = (ep->dir_in) ? |
192 | fotg210->reg + FOTG210_INEPMPSR(epnum) : |
193 | fotg210->reg + FOTG210_OUTEPMPSR(epnum); |
194 | |
195 | /* Note: Driver needs to set and clear INOUTEPMPSR_RESET_TSEQ |
196 | * bit. Controller wouldn't clear this bit. WTF!!! |
197 | */ |
198 | |
199 | value = ioread32(reg); |
200 | value |= INOUTEPMPSR_RESET_TSEQ; |
201 | iowrite32(value, reg); |
202 | |
203 | value = ioread32(reg); |
204 | value &= ~INOUTEPMPSR_RESET_TSEQ; |
205 | iowrite32(value, reg); |
206 | } |
207 | |
208 | static int fotg210_ep_release(struct fotg210_ep *ep) |
209 | { |
210 | if (!ep->epnum) |
211 | return 0; |
212 | ep->epnum = 0; |
213 | ep->stall = 0; |
214 | ep->wedged = 0; |
215 | |
216 | fotg210_reset_tseq(fotg210: ep->fotg210, epnum: ep->epnum); |
217 | |
218 | return 0; |
219 | } |
220 | |
221 | static int fotg210_ep_disable(struct usb_ep *_ep) |
222 | { |
223 | struct fotg210_ep *ep; |
224 | struct fotg210_request *req; |
225 | unsigned long flags; |
226 | |
227 | BUG_ON(!_ep); |
228 | |
229 | ep = container_of(_ep, struct fotg210_ep, ep); |
230 | |
231 | while (!list_empty(head: &ep->queue)) { |
232 | req = list_entry(ep->queue.next, |
233 | struct fotg210_request, queue); |
234 | spin_lock_irqsave(&ep->fotg210->lock, flags); |
235 | fotg210_done(ep, req, status: -ECONNRESET); |
236 | spin_unlock_irqrestore(lock: &ep->fotg210->lock, flags); |
237 | } |
238 | |
239 | return fotg210_ep_release(ep); |
240 | } |
241 | |
242 | static struct usb_request *fotg210_ep_alloc_request(struct usb_ep *_ep, |
243 | gfp_t gfp_flags) |
244 | { |
245 | struct fotg210_request *req; |
246 | |
247 | req = kzalloc(size: sizeof(struct fotg210_request), flags: gfp_flags); |
248 | if (!req) |
249 | return NULL; |
250 | |
251 | INIT_LIST_HEAD(list: &req->queue); |
252 | |
253 | return &req->req; |
254 | } |
255 | |
256 | static void fotg210_ep_free_request(struct usb_ep *_ep, |
257 | struct usb_request *_req) |
258 | { |
259 | struct fotg210_request *req; |
260 | |
261 | req = container_of(_req, struct fotg210_request, req); |
262 | kfree(objp: req); |
263 | } |
264 | |
265 | static void fotg210_enable_dma(struct fotg210_ep *ep, |
266 | dma_addr_t d, u32 len) |
267 | { |
268 | u32 value; |
269 | struct fotg210_udc *fotg210 = ep->fotg210; |
270 | |
271 | /* set transfer length and direction */ |
272 | value = ioread32(fotg210->reg + FOTG210_DMACPSR1); |
273 | value &= ~(DMACPSR1_DMA_LEN(0xFFFF) | DMACPSR1_DMA_TYPE(1)); |
274 | value |= DMACPSR1_DMA_LEN(len) | DMACPSR1_DMA_TYPE(ep->dir_in); |
275 | iowrite32(value, fotg210->reg + FOTG210_DMACPSR1); |
276 | |
277 | /* set device DMA target FIFO number */ |
278 | value = ioread32(fotg210->reg + FOTG210_DMATFNR); |
279 | if (ep->epnum) |
280 | value |= DMATFNR_ACC_FN(ep->epnum - 1); |
281 | else |
282 | value |= DMATFNR_ACC_CXF; |
283 | iowrite32(value, fotg210->reg + FOTG210_DMATFNR); |
284 | |
285 | /* set DMA memory address */ |
286 | iowrite32(d, fotg210->reg + FOTG210_DMACPSR2); |
287 | |
288 | /* enable MDMA_EROR and MDMA_CMPLT interrupt */ |
289 | value = ioread32(fotg210->reg + FOTG210_DMISGR2); |
290 | value &= ~(DMISGR2_MDMA_CMPLT | DMISGR2_MDMA_ERROR); |
291 | iowrite32(value, fotg210->reg + FOTG210_DMISGR2); |
292 | |
293 | /* start DMA */ |
294 | value = ioread32(fotg210->reg + FOTG210_DMACPSR1); |
295 | value |= DMACPSR1_DMA_START; |
296 | iowrite32(value, fotg210->reg + FOTG210_DMACPSR1); |
297 | } |
298 | |
299 | static void fotg210_disable_dma(struct fotg210_ep *ep) |
300 | { |
301 | iowrite32(DMATFNR_DISDMA, ep->fotg210->reg + FOTG210_DMATFNR); |
302 | } |
303 | |
304 | static void fotg210_wait_dma_done(struct fotg210_ep *ep) |
305 | { |
306 | u32 value; |
307 | |
308 | do { |
309 | value = ioread32(ep->fotg210->reg + FOTG210_DISGR2); |
310 | if ((value & DISGR2_USBRST_INT) || |
311 | (value & DISGR2_DMA_ERROR)) |
312 | goto dma_reset; |
313 | } while (!(value & DISGR2_DMA_CMPLT)); |
314 | |
315 | fotg210_ack_int(fotg210: ep->fotg210, FOTG210_DISGR2, DISGR2_DMA_CMPLT); |
316 | return; |
317 | |
318 | dma_reset: |
319 | value = ioread32(ep->fotg210->reg + FOTG210_DMACPSR1); |
320 | value |= DMACPSR1_DMA_ABORT; |
321 | iowrite32(value, ep->fotg210->reg + FOTG210_DMACPSR1); |
322 | |
323 | /* reset fifo */ |
324 | if (ep->epnum) { |
325 | value = ioread32(ep->fotg210->reg + |
326 | FOTG210_FIBCR(ep->epnum - 1)); |
327 | value |= FIBCR_FFRST; |
328 | iowrite32(value, ep->fotg210->reg + |
329 | FOTG210_FIBCR(ep->epnum - 1)); |
330 | } else { |
331 | value = ioread32(ep->fotg210->reg + FOTG210_DCFESR); |
332 | value |= DCFESR_CX_CLR; |
333 | iowrite32(value, ep->fotg210->reg + FOTG210_DCFESR); |
334 | } |
335 | } |
336 | |
337 | static void fotg210_start_dma(struct fotg210_ep *ep, |
338 | struct fotg210_request *req) |
339 | { |
340 | struct device *dev = &ep->fotg210->gadget.dev; |
341 | dma_addr_t d; |
342 | u8 *buffer; |
343 | u32 length; |
344 | |
345 | if (ep->epnum) { |
346 | if (ep->dir_in) { |
347 | buffer = req->req.buf; |
348 | length = req->req.length; |
349 | } else { |
350 | buffer = req->req.buf + req->req.actual; |
351 | length = ioread32(ep->fotg210->reg + |
352 | FOTG210_FIBCR(ep->epnum - 1)) & FIBCR_BCFX; |
353 | if (length > req->req.length - req->req.actual) |
354 | length = req->req.length - req->req.actual; |
355 | } |
356 | } else { |
357 | buffer = req->req.buf + req->req.actual; |
358 | if (req->req.length - req->req.actual > ep->ep.maxpacket) |
359 | length = ep->ep.maxpacket; |
360 | else |
361 | length = req->req.length - req->req.actual; |
362 | } |
363 | |
364 | d = dma_map_single(dev, buffer, length, |
365 | ep->dir_in ? DMA_TO_DEVICE : DMA_FROM_DEVICE); |
366 | |
367 | if (dma_mapping_error(dev, dma_addr: d)) { |
368 | pr_err("dma_mapping_error\n" ); |
369 | return; |
370 | } |
371 | |
372 | fotg210_enable_dma(ep, d, len: length); |
373 | |
374 | /* check if dma is done */ |
375 | fotg210_wait_dma_done(ep); |
376 | |
377 | fotg210_disable_dma(ep); |
378 | |
379 | /* update actual transfer length */ |
380 | req->req.actual += length; |
381 | |
382 | dma_unmap_single(dev, d, length, DMA_TO_DEVICE); |
383 | } |
384 | |
385 | static void fotg210_ep0_queue(struct fotg210_ep *ep, |
386 | struct fotg210_request *req) |
387 | { |
388 | if (!req->req.length) { |
389 | fotg210_done(ep, req, status: 0); |
390 | return; |
391 | } |
392 | if (ep->dir_in) { /* if IN */ |
393 | fotg210_start_dma(ep, req); |
394 | if (req->req.length == req->req.actual) |
395 | fotg210_done(ep, req, status: 0); |
396 | } else { /* OUT */ |
397 | u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR0); |
398 | |
399 | value &= ~DMISGR0_MCX_OUT_INT; |
400 | iowrite32(value, ep->fotg210->reg + FOTG210_DMISGR0); |
401 | } |
402 | } |
403 | |
404 | static int fotg210_ep_queue(struct usb_ep *_ep, struct usb_request *_req, |
405 | gfp_t gfp_flags) |
406 | { |
407 | struct fotg210_ep *ep; |
408 | struct fotg210_request *req; |
409 | unsigned long flags; |
410 | int request = 0; |
411 | |
412 | ep = container_of(_ep, struct fotg210_ep, ep); |
413 | req = container_of(_req, struct fotg210_request, req); |
414 | |
415 | if (ep->fotg210->gadget.speed == USB_SPEED_UNKNOWN) |
416 | return -ESHUTDOWN; |
417 | |
418 | spin_lock_irqsave(&ep->fotg210->lock, flags); |
419 | |
420 | if (list_empty(head: &ep->queue)) |
421 | request = 1; |
422 | |
423 | list_add_tail(new: &req->queue, head: &ep->queue); |
424 | |
425 | req->req.actual = 0; |
426 | req->req.status = -EINPROGRESS; |
427 | |
428 | if (!ep->epnum) /* ep0 */ |
429 | fotg210_ep0_queue(ep, req); |
430 | else if (request && !ep->stall) |
431 | fotg210_enable_fifo_int(ep); |
432 | |
433 | spin_unlock_irqrestore(lock: &ep->fotg210->lock, flags); |
434 | |
435 | return 0; |
436 | } |
437 | |
438 | static int fotg210_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) |
439 | { |
440 | struct fotg210_ep *ep; |
441 | struct fotg210_request *req; |
442 | unsigned long flags; |
443 | |
444 | ep = container_of(_ep, struct fotg210_ep, ep); |
445 | req = container_of(_req, struct fotg210_request, req); |
446 | |
447 | spin_lock_irqsave(&ep->fotg210->lock, flags); |
448 | if (!list_empty(head: &ep->queue)) |
449 | fotg210_done(ep, req, status: -ECONNRESET); |
450 | spin_unlock_irqrestore(lock: &ep->fotg210->lock, flags); |
451 | |
452 | return 0; |
453 | } |
454 | |
455 | static void fotg210_set_epnstall(struct fotg210_ep *ep) |
456 | { |
457 | struct fotg210_udc *fotg210 = ep->fotg210; |
458 | u32 value; |
459 | void __iomem *reg; |
460 | |
461 | /* check if IN FIFO is empty before stall */ |
462 | if (ep->dir_in) { |
463 | do { |
464 | value = ioread32(fotg210->reg + FOTG210_DCFESR); |
465 | } while (!(value & DCFESR_FIFO_EMPTY(ep->epnum - 1))); |
466 | } |
467 | |
468 | reg = (ep->dir_in) ? |
469 | fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : |
470 | fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); |
471 | value = ioread32(reg); |
472 | value |= INOUTEPMPSR_STL_EP; |
473 | iowrite32(value, reg); |
474 | } |
475 | |
476 | static void fotg210_clear_epnstall(struct fotg210_ep *ep) |
477 | { |
478 | struct fotg210_udc *fotg210 = ep->fotg210; |
479 | u32 value; |
480 | void __iomem *reg; |
481 | |
482 | reg = (ep->dir_in) ? |
483 | fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : |
484 | fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); |
485 | value = ioread32(reg); |
486 | value &= ~INOUTEPMPSR_STL_EP; |
487 | iowrite32(value, reg); |
488 | } |
489 | |
490 | static int fotg210_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedge) |
491 | { |
492 | struct fotg210_ep *ep; |
493 | struct fotg210_udc *fotg210; |
494 | unsigned long flags; |
495 | |
496 | ep = container_of(_ep, struct fotg210_ep, ep); |
497 | |
498 | fotg210 = ep->fotg210; |
499 | |
500 | spin_lock_irqsave(&ep->fotg210->lock, flags); |
501 | |
502 | if (value) { |
503 | fotg210_set_epnstall(ep); |
504 | ep->stall = 1; |
505 | if (wedge) |
506 | ep->wedged = 1; |
507 | } else { |
508 | fotg210_reset_tseq(fotg210, epnum: ep->epnum); |
509 | fotg210_clear_epnstall(ep); |
510 | ep->stall = 0; |
511 | ep->wedged = 0; |
512 | if (!list_empty(head: &ep->queue)) |
513 | fotg210_enable_fifo_int(ep); |
514 | } |
515 | |
516 | spin_unlock_irqrestore(lock: &ep->fotg210->lock, flags); |
517 | return 0; |
518 | } |
519 | |
520 | static int fotg210_ep_set_halt(struct usb_ep *_ep, int value) |
521 | { |
522 | return fotg210_set_halt_and_wedge(_ep, value, wedge: 0); |
523 | } |
524 | |
525 | static int fotg210_ep_set_wedge(struct usb_ep *_ep) |
526 | { |
527 | return fotg210_set_halt_and_wedge(_ep, value: 1, wedge: 1); |
528 | } |
529 | |
530 | static void fotg210_ep_fifo_flush(struct usb_ep *_ep) |
531 | { |
532 | } |
533 | |
534 | static const struct usb_ep_ops fotg210_ep_ops = { |
535 | .enable = fotg210_ep_enable, |
536 | .disable = fotg210_ep_disable, |
537 | |
538 | .alloc_request = fotg210_ep_alloc_request, |
539 | .free_request = fotg210_ep_free_request, |
540 | |
541 | .queue = fotg210_ep_queue, |
542 | .dequeue = fotg210_ep_dequeue, |
543 | |
544 | .set_halt = fotg210_ep_set_halt, |
545 | .fifo_flush = fotg210_ep_fifo_flush, |
546 | .set_wedge = fotg210_ep_set_wedge, |
547 | }; |
548 | |
549 | static void fotg210_clear_tx0byte(struct fotg210_udc *fotg210) |
550 | { |
551 | u32 value = ioread32(fotg210->reg + FOTG210_TX0BYTE); |
552 | |
553 | value &= ~(TX0BYTE_EP1 | TX0BYTE_EP2 | TX0BYTE_EP3 |
554 | | TX0BYTE_EP4); |
555 | iowrite32(value, fotg210->reg + FOTG210_TX0BYTE); |
556 | } |
557 | |
558 | static void fotg210_clear_rx0byte(struct fotg210_udc *fotg210) |
559 | { |
560 | u32 value = ioread32(fotg210->reg + FOTG210_RX0BYTE); |
561 | |
562 | value &= ~(RX0BYTE_EP1 | RX0BYTE_EP2 | RX0BYTE_EP3 |
563 | | RX0BYTE_EP4); |
564 | iowrite32(value, fotg210->reg + FOTG210_RX0BYTE); |
565 | } |
566 | |
567 | /* read 8-byte setup packet only */ |
568 | static void fotg210_rdsetupp(struct fotg210_udc *fotg210, |
569 | u8 *buffer) |
570 | { |
571 | int i = 0; |
572 | u8 *tmp = buffer; |
573 | u32 data; |
574 | u32 length = 8; |
575 | |
576 | iowrite32(DMATFNR_ACC_CXF, fotg210->reg + FOTG210_DMATFNR); |
577 | |
578 | for (i = (length >> 2); i > 0; i--) { |
579 | data = ioread32(fotg210->reg + FOTG210_CXPORT); |
580 | *tmp = data & 0xFF; |
581 | *(tmp + 1) = (data >> 8) & 0xFF; |
582 | *(tmp + 2) = (data >> 16) & 0xFF; |
583 | *(tmp + 3) = (data >> 24) & 0xFF; |
584 | tmp = tmp + 4; |
585 | } |
586 | |
587 | switch (length % 4) { |
588 | case 1: |
589 | data = ioread32(fotg210->reg + FOTG210_CXPORT); |
590 | *tmp = data & 0xFF; |
591 | break; |
592 | case 2: |
593 | data = ioread32(fotg210->reg + FOTG210_CXPORT); |
594 | *tmp = data & 0xFF; |
595 | *(tmp + 1) = (data >> 8) & 0xFF; |
596 | break; |
597 | case 3: |
598 | data = ioread32(fotg210->reg + FOTG210_CXPORT); |
599 | *tmp = data & 0xFF; |
600 | *(tmp + 1) = (data >> 8) & 0xFF; |
601 | *(tmp + 2) = (data >> 16) & 0xFF; |
602 | break; |
603 | default: |
604 | break; |
605 | } |
606 | |
607 | iowrite32(DMATFNR_DISDMA, fotg210->reg + FOTG210_DMATFNR); |
608 | } |
609 | |
610 | static void fotg210_set_configuration(struct fotg210_udc *fotg210) |
611 | { |
612 | u32 value = ioread32(fotg210->reg + FOTG210_DAR); |
613 | |
614 | value |= DAR_AFT_CONF; |
615 | iowrite32(value, fotg210->reg + FOTG210_DAR); |
616 | } |
617 | |
618 | static void fotg210_set_dev_addr(struct fotg210_udc *fotg210, u32 addr) |
619 | { |
620 | u32 value = ioread32(fotg210->reg + FOTG210_DAR); |
621 | |
622 | value |= (addr & 0x7F); |
623 | iowrite32(value, fotg210->reg + FOTG210_DAR); |
624 | } |
625 | |
626 | static void fotg210_set_cxstall(struct fotg210_udc *fotg210) |
627 | { |
628 | u32 value = ioread32(fotg210->reg + FOTG210_DCFESR); |
629 | |
630 | value |= DCFESR_CX_STL; |
631 | iowrite32(value, fotg210->reg + FOTG210_DCFESR); |
632 | } |
633 | |
634 | static void fotg210_request_error(struct fotg210_udc *fotg210) |
635 | { |
636 | fotg210_set_cxstall(fotg210); |
637 | pr_err("request error!!\n" ); |
638 | } |
639 | |
640 | static void fotg210_set_address(struct fotg210_udc *fotg210, |
641 | struct usb_ctrlrequest *ctrl) |
642 | { |
643 | if (le16_to_cpu(ctrl->wValue) >= 0x0100) { |
644 | fotg210_request_error(fotg210); |
645 | } else { |
646 | fotg210_set_dev_addr(fotg210, le16_to_cpu(ctrl->wValue)); |
647 | fotg210_set_cxdone(fotg210); |
648 | } |
649 | } |
650 | |
651 | static void fotg210_set_feature(struct fotg210_udc *fotg210, |
652 | struct usb_ctrlrequest *ctrl) |
653 | { |
654 | switch (ctrl->bRequestType & USB_RECIP_MASK) { |
655 | case USB_RECIP_DEVICE: |
656 | fotg210_set_cxdone(fotg210); |
657 | break; |
658 | case USB_RECIP_INTERFACE: |
659 | fotg210_set_cxdone(fotg210); |
660 | break; |
661 | case USB_RECIP_ENDPOINT: { |
662 | u8 epnum; |
663 | epnum = le16_to_cpu(ctrl->wIndex) & USB_ENDPOINT_NUMBER_MASK; |
664 | if (epnum) |
665 | fotg210_set_epnstall(ep: fotg210->ep[epnum]); |
666 | else |
667 | fotg210_set_cxstall(fotg210); |
668 | fotg210_set_cxdone(fotg210); |
669 | } |
670 | break; |
671 | default: |
672 | fotg210_request_error(fotg210); |
673 | break; |
674 | } |
675 | } |
676 | |
677 | static void fotg210_clear_feature(struct fotg210_udc *fotg210, |
678 | struct usb_ctrlrequest *ctrl) |
679 | { |
680 | struct fotg210_ep *ep = |
681 | fotg210->ep[ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK]; |
682 | |
683 | switch (ctrl->bRequestType & USB_RECIP_MASK) { |
684 | case USB_RECIP_DEVICE: |
685 | fotg210_set_cxdone(fotg210); |
686 | break; |
687 | case USB_RECIP_INTERFACE: |
688 | fotg210_set_cxdone(fotg210); |
689 | break; |
690 | case USB_RECIP_ENDPOINT: |
691 | if (ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK) { |
692 | if (ep->wedged) { |
693 | fotg210_set_cxdone(fotg210); |
694 | break; |
695 | } |
696 | if (ep->stall) |
697 | fotg210_set_halt_and_wedge(ep: &ep->ep, value: 0, wedge: 0); |
698 | } |
699 | fotg210_set_cxdone(fotg210); |
700 | break; |
701 | default: |
702 | fotg210_request_error(fotg210); |
703 | break; |
704 | } |
705 | } |
706 | |
707 | static int fotg210_is_epnstall(struct fotg210_ep *ep) |
708 | { |
709 | struct fotg210_udc *fotg210 = ep->fotg210; |
710 | u32 value; |
711 | void __iomem *reg; |
712 | |
713 | reg = (ep->dir_in) ? |
714 | fotg210->reg + FOTG210_INEPMPSR(ep->epnum) : |
715 | fotg210->reg + FOTG210_OUTEPMPSR(ep->epnum); |
716 | value = ioread32(reg); |
717 | return value & INOUTEPMPSR_STL_EP ? 1 : 0; |
718 | } |
719 | |
720 | /* For EP0 requests triggered by this driver (currently GET_STATUS response) */ |
721 | static void fotg210_ep0_complete(struct usb_ep *_ep, struct usb_request *req) |
722 | { |
723 | struct fotg210_ep *ep; |
724 | struct fotg210_udc *fotg210; |
725 | |
726 | ep = container_of(_ep, struct fotg210_ep, ep); |
727 | fotg210 = ep->fotg210; |
728 | |
729 | if (req->status || req->actual != req->length) { |
730 | dev_warn(&fotg210->gadget.dev, "EP0 request failed: %d\n" , req->status); |
731 | } |
732 | } |
733 | |
734 | static void fotg210_get_status(struct fotg210_udc *fotg210, |
735 | struct usb_ctrlrequest *ctrl) |
736 | { |
737 | u8 epnum; |
738 | |
739 | switch (ctrl->bRequestType & USB_RECIP_MASK) { |
740 | case USB_RECIP_DEVICE: |
741 | fotg210->ep0_data = cpu_to_le16(1 << USB_DEVICE_SELF_POWERED); |
742 | break; |
743 | case USB_RECIP_INTERFACE: |
744 | fotg210->ep0_data = cpu_to_le16(0); |
745 | break; |
746 | case USB_RECIP_ENDPOINT: |
747 | epnum = ctrl->wIndex & USB_ENDPOINT_NUMBER_MASK; |
748 | if (epnum) |
749 | fotg210->ep0_data = |
750 | cpu_to_le16(fotg210_is_epnstall(fotg210->ep[epnum]) |
751 | << USB_ENDPOINT_HALT); |
752 | else |
753 | fotg210_request_error(fotg210); |
754 | break; |
755 | |
756 | default: |
757 | fotg210_request_error(fotg210); |
758 | return; /* exit */ |
759 | } |
760 | |
761 | fotg210->ep0_req->buf = &fotg210->ep0_data; |
762 | fotg210->ep0_req->length = 2; |
763 | |
764 | spin_unlock(lock: &fotg210->lock); |
765 | fotg210_ep_queue(ep: fotg210->gadget.ep0, req: fotg210->ep0_req, GFP_ATOMIC); |
766 | spin_lock(lock: &fotg210->lock); |
767 | } |
768 | |
769 | static int fotg210_setup_packet(struct fotg210_udc *fotg210, |
770 | struct usb_ctrlrequest *ctrl) |
771 | { |
772 | u8 *p = (u8 *)ctrl; |
773 | u8 ret = 0; |
774 | |
775 | fotg210_rdsetupp(fotg210, buffer: p); |
776 | |
777 | fotg210->ep[0]->dir_in = ctrl->bRequestType & USB_DIR_IN; |
778 | |
779 | if (fotg210->gadget.speed == USB_SPEED_UNKNOWN) { |
780 | u32 value = ioread32(fotg210->reg + FOTG210_DMCR); |
781 | fotg210->gadget.speed = value & DMCR_HS_EN ? |
782 | USB_SPEED_HIGH : USB_SPEED_FULL; |
783 | } |
784 | |
785 | /* check request */ |
786 | if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) { |
787 | switch (ctrl->bRequest) { |
788 | case USB_REQ_GET_STATUS: |
789 | fotg210_get_status(fotg210, ctrl); |
790 | break; |
791 | case USB_REQ_CLEAR_FEATURE: |
792 | fotg210_clear_feature(fotg210, ctrl); |
793 | break; |
794 | case USB_REQ_SET_FEATURE: |
795 | fotg210_set_feature(fotg210, ctrl); |
796 | break; |
797 | case USB_REQ_SET_ADDRESS: |
798 | fotg210_set_address(fotg210, ctrl); |
799 | break; |
800 | case USB_REQ_SET_CONFIGURATION: |
801 | fotg210_set_configuration(fotg210); |
802 | ret = 1; |
803 | break; |
804 | default: |
805 | ret = 1; |
806 | break; |
807 | } |
808 | } else { |
809 | ret = 1; |
810 | } |
811 | |
812 | return ret; |
813 | } |
814 | |
815 | static void fotg210_ep0out(struct fotg210_udc *fotg210) |
816 | { |
817 | struct fotg210_ep *ep = fotg210->ep[0]; |
818 | |
819 | if (!list_empty(head: &ep->queue) && !ep->dir_in) { |
820 | struct fotg210_request *req; |
821 | |
822 | req = list_first_entry(&ep->queue, |
823 | struct fotg210_request, queue); |
824 | |
825 | if (req->req.length) |
826 | fotg210_start_dma(ep, req); |
827 | |
828 | if ((req->req.length - req->req.actual) < ep->ep.maxpacket) |
829 | fotg210_done(ep, req, status: 0); |
830 | } else { |
831 | pr_err("%s : empty queue\n" , __func__); |
832 | } |
833 | } |
834 | |
835 | static void fotg210_ep0in(struct fotg210_udc *fotg210) |
836 | { |
837 | struct fotg210_ep *ep = fotg210->ep[0]; |
838 | |
839 | if ((!list_empty(head: &ep->queue)) && (ep->dir_in)) { |
840 | struct fotg210_request *req; |
841 | |
842 | req = list_entry(ep->queue.next, |
843 | struct fotg210_request, queue); |
844 | |
845 | if (req->req.length) |
846 | fotg210_start_dma(ep, req); |
847 | |
848 | if (req->req.actual == req->req.length) |
849 | fotg210_done(ep, req, status: 0); |
850 | } else { |
851 | fotg210_set_cxdone(fotg210); |
852 | } |
853 | } |
854 | |
855 | static void fotg210_in_fifo_handler(struct fotg210_ep *ep) |
856 | { |
857 | struct fotg210_request *req = list_entry(ep->queue.next, |
858 | struct fotg210_request, queue); |
859 | |
860 | if (req->req.length) |
861 | fotg210_start_dma(ep, req); |
862 | fotg210_done(ep, req, status: 0); |
863 | } |
864 | |
865 | static void fotg210_out_fifo_handler(struct fotg210_ep *ep) |
866 | { |
867 | struct fotg210_request *req = list_entry(ep->queue.next, |
868 | struct fotg210_request, queue); |
869 | int disgr1 = ioread32(ep->fotg210->reg + FOTG210_DISGR1); |
870 | |
871 | fotg210_start_dma(ep, req); |
872 | |
873 | /* Complete the request when it's full or a short packet arrived. |
874 | * Like other drivers, short_not_ok isn't handled. |
875 | */ |
876 | |
877 | if (req->req.length == req->req.actual || |
878 | (disgr1 & DISGR1_SPK_INT(ep->epnum - 1))) |
879 | fotg210_done(ep, req, status: 0); |
880 | } |
881 | |
882 | static irqreturn_t fotg210_irq(int irq, void *_fotg210) |
883 | { |
884 | struct fotg210_udc *fotg210 = _fotg210; |
885 | u32 int_grp = ioread32(fotg210->reg + FOTG210_DIGR); |
886 | u32 int_msk = ioread32(fotg210->reg + FOTG210_DMIGR); |
887 | |
888 | int_grp &= ~int_msk; |
889 | |
890 | spin_lock(lock: &fotg210->lock); |
891 | |
892 | if (int_grp & DIGR_INT_G2) { |
893 | void __iomem *reg = fotg210->reg + FOTG210_DISGR2; |
894 | u32 int_grp2 = ioread32(reg); |
895 | u32 int_msk2 = ioread32(fotg210->reg + FOTG210_DMISGR2); |
896 | |
897 | int_grp2 &= ~int_msk2; |
898 | |
899 | if (int_grp2 & DISGR2_USBRST_INT) { |
900 | usb_gadget_udc_reset(gadget: &fotg210->gadget, |
901 | driver: fotg210->driver); |
902 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_USBRST_INT); |
903 | pr_info("fotg210 udc reset\n" ); |
904 | } |
905 | if (int_grp2 & DISGR2_SUSP_INT) { |
906 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_SUSP_INT); |
907 | pr_info("fotg210 udc suspend\n" ); |
908 | } |
909 | if (int_grp2 & DISGR2_RESM_INT) { |
910 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_RESM_INT); |
911 | pr_info("fotg210 udc resume\n" ); |
912 | } |
913 | if (int_grp2 & DISGR2_ISO_SEQ_ERR_INT) { |
914 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_ISO_SEQ_ERR_INT); |
915 | pr_info("fotg210 iso sequence error\n" ); |
916 | } |
917 | if (int_grp2 & DISGR2_ISO_SEQ_ABORT_INT) { |
918 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_ISO_SEQ_ABORT_INT); |
919 | pr_info("fotg210 iso sequence abort\n" ); |
920 | } |
921 | if (int_grp2 & DISGR2_TX0BYTE_INT) { |
922 | fotg210_clear_tx0byte(fotg210); |
923 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_TX0BYTE_INT); |
924 | pr_info("fotg210 transferred 0 byte\n" ); |
925 | } |
926 | if (int_grp2 & DISGR2_RX0BYTE_INT) { |
927 | fotg210_clear_rx0byte(fotg210); |
928 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_RX0BYTE_INT); |
929 | pr_info("fotg210 received 0 byte\n" ); |
930 | } |
931 | if (int_grp2 & DISGR2_DMA_ERROR) { |
932 | fotg210_ack_int(fotg210, FOTG210_DISGR2, DISGR2_DMA_ERROR); |
933 | } |
934 | } |
935 | |
936 | if (int_grp & DIGR_INT_G0) { |
937 | void __iomem *reg = fotg210->reg + FOTG210_DISGR0; |
938 | u32 int_grp0 = ioread32(reg); |
939 | u32 int_msk0 = ioread32(fotg210->reg + FOTG210_DMISGR0); |
940 | struct usb_ctrlrequest ctrl; |
941 | |
942 | int_grp0 &= ~int_msk0; |
943 | |
944 | /* the highest priority in this source register */ |
945 | if (int_grp0 & DISGR0_CX_COMABT_INT) { |
946 | fotg210_ack_int(fotg210, FOTG210_DISGR0, DISGR0_CX_COMABT_INT); |
947 | pr_info("fotg210 CX command abort\n" ); |
948 | } |
949 | |
950 | if (int_grp0 & DISGR0_CX_SETUP_INT) { |
951 | if (fotg210_setup_packet(fotg210, ctrl: &ctrl)) { |
952 | spin_unlock(lock: &fotg210->lock); |
953 | if (fotg210->driver->setup(&fotg210->gadget, |
954 | &ctrl) < 0) |
955 | fotg210_set_cxstall(fotg210); |
956 | spin_lock(lock: &fotg210->lock); |
957 | } |
958 | } |
959 | if (int_grp0 & DISGR0_CX_COMEND_INT) |
960 | pr_info("fotg210 cmd end\n" ); |
961 | |
962 | if (int_grp0 & DISGR0_CX_IN_INT) |
963 | fotg210_ep0in(fotg210); |
964 | |
965 | if (int_grp0 & DISGR0_CX_OUT_INT) |
966 | fotg210_ep0out(fotg210); |
967 | |
968 | if (int_grp0 & DISGR0_CX_COMFAIL_INT) { |
969 | fotg210_set_cxstall(fotg210); |
970 | pr_info("fotg210 ep0 fail\n" ); |
971 | } |
972 | } |
973 | |
974 | if (int_grp & DIGR_INT_G1) { |
975 | void __iomem *reg = fotg210->reg + FOTG210_DISGR1; |
976 | u32 int_grp1 = ioread32(reg); |
977 | u32 int_msk1 = ioread32(fotg210->reg + FOTG210_DMISGR1); |
978 | int fifo; |
979 | |
980 | int_grp1 &= ~int_msk1; |
981 | |
982 | for (fifo = 0; fifo < FOTG210_MAX_FIFO_NUM; fifo++) { |
983 | if (int_grp1 & DISGR1_IN_INT(fifo)) |
984 | fotg210_in_fifo_handler(ep: fotg210->ep[fifo + 1]); |
985 | |
986 | if ((int_grp1 & DISGR1_OUT_INT(fifo)) || |
987 | (int_grp1 & DISGR1_SPK_INT(fifo))) |
988 | fotg210_out_fifo_handler(ep: fotg210->ep[fifo + 1]); |
989 | } |
990 | } |
991 | |
992 | spin_unlock(lock: &fotg210->lock); |
993 | |
994 | return IRQ_HANDLED; |
995 | } |
996 | |
997 | static void fotg210_disable_unplug(struct fotg210_udc *fotg210) |
998 | { |
999 | u32 reg = ioread32(fotg210->reg + FOTG210_PHYTMSR); |
1000 | |
1001 | reg &= ~PHYTMSR_UNPLUG; |
1002 | iowrite32(reg, fotg210->reg + FOTG210_PHYTMSR); |
1003 | } |
1004 | |
1005 | static int fotg210_udc_start(struct usb_gadget *g, |
1006 | struct usb_gadget_driver *driver) |
1007 | { |
1008 | struct fotg210_udc *fotg210 = gadget_to_fotg210(g); |
1009 | u32 value; |
1010 | int ret; |
1011 | |
1012 | /* hook up the driver */ |
1013 | fotg210->driver = driver; |
1014 | fotg210->gadget.dev.of_node = fotg210->dev->of_node; |
1015 | fotg210->gadget.speed = USB_SPEED_UNKNOWN; |
1016 | |
1017 | dev_info(fotg210->dev, "bound driver %s\n" , driver->driver.name); |
1018 | |
1019 | if (!IS_ERR_OR_NULL(ptr: fotg210->phy)) { |
1020 | ret = otg_set_peripheral(otg: fotg210->phy->otg, |
1021 | periph: &fotg210->gadget); |
1022 | if (ret) |
1023 | dev_err(fotg210->dev, "can't bind to phy\n" ); |
1024 | } |
1025 | |
1026 | /* chip enable */ |
1027 | value = ioread32(fotg210->reg + FOTG210_DMCR); |
1028 | value |= DMCR_CHIP_EN; |
1029 | iowrite32(value, fotg210->reg + FOTG210_DMCR); |
1030 | |
1031 | /* enable device global interrupt */ |
1032 | value = ioread32(fotg210->reg + FOTG210_DMCR); |
1033 | value |= DMCR_GLINT_EN; |
1034 | iowrite32(value, fotg210->reg + FOTG210_DMCR); |
1035 | |
1036 | return 0; |
1037 | } |
1038 | |
1039 | static void fotg210_init(struct fotg210_udc *fotg210) |
1040 | { |
1041 | u32 value; |
1042 | |
1043 | /* disable global interrupt and set int polarity to active high */ |
1044 | iowrite32(GMIR_MHC_INT | GMIR_MOTG_INT | GMIR_INT_POLARITY, |
1045 | fotg210->reg + FOTG210_GMIR); |
1046 | |
1047 | /* mask interrupts for groups other than 0-2 */ |
1048 | iowrite32(~(DMIGR_MINT_G0 | DMIGR_MINT_G1 | DMIGR_MINT_G2), |
1049 | fotg210->reg + FOTG210_DMIGR); |
1050 | |
1051 | /* udc software reset */ |
1052 | iowrite32(DMCR_SFRST, fotg210->reg + FOTG210_DMCR); |
1053 | /* Better wait a bit, but without a datasheet, no idea how long. */ |
1054 | usleep_range(min: 100, max: 200); |
1055 | |
1056 | /* disable device global interrupt */ |
1057 | value = ioread32(fotg210->reg + FOTG210_DMCR); |
1058 | value &= ~DMCR_GLINT_EN; |
1059 | iowrite32(value, fotg210->reg + FOTG210_DMCR); |
1060 | |
1061 | /* enable only grp2 irqs we handle */ |
1062 | iowrite32(~(DISGR2_DMA_ERROR | DISGR2_RX0BYTE_INT | DISGR2_TX0BYTE_INT |
1063 | | DISGR2_ISO_SEQ_ABORT_INT | DISGR2_ISO_SEQ_ERR_INT |
1064 | | DISGR2_RESM_INT | DISGR2_SUSP_INT | DISGR2_USBRST_INT), |
1065 | fotg210->reg + FOTG210_DMISGR2); |
1066 | |
1067 | /* disable all fifo interrupt */ |
1068 | iowrite32(~(u32)0, fotg210->reg + FOTG210_DMISGR1); |
1069 | |
1070 | /* disable cmd end */ |
1071 | value = ioread32(fotg210->reg + FOTG210_DMISGR0); |
1072 | value |= DMISGR0_MCX_COMEND; |
1073 | iowrite32(value, fotg210->reg + FOTG210_DMISGR0); |
1074 | } |
1075 | |
1076 | static int fotg210_udc_stop(struct usb_gadget *g) |
1077 | { |
1078 | struct fotg210_udc *fotg210 = gadget_to_fotg210(g); |
1079 | unsigned long flags; |
1080 | |
1081 | if (!IS_ERR_OR_NULL(ptr: fotg210->phy)) |
1082 | return otg_set_peripheral(otg: fotg210->phy->otg, NULL); |
1083 | |
1084 | spin_lock_irqsave(&fotg210->lock, flags); |
1085 | |
1086 | fotg210_init(fotg210); |
1087 | fotg210->driver = NULL; |
1088 | fotg210->gadget.speed = USB_SPEED_UNKNOWN; |
1089 | |
1090 | spin_unlock_irqrestore(lock: &fotg210->lock, flags); |
1091 | |
1092 | return 0; |
1093 | } |
1094 | |
1095 | /** |
1096 | * fotg210_vbus_session - Called by external transceiver to enable/disable udc |
1097 | * @g: usb gadget |
1098 | * @is_active: 0 if should disable UDC VBUS, 1 if should enable |
1099 | * |
1100 | * Returns: %0 |
1101 | */ |
1102 | static int fotg210_vbus_session(struct usb_gadget *g, int is_active) |
1103 | { |
1104 | struct fotg210_udc *fotg210 = gadget_to_fotg210(g); |
1105 | |
1106 | /* Call down to core integration layer to drive or disable VBUS */ |
1107 | fotg210_vbus(fotg: fotg210->fotg, enable: is_active); |
1108 | return 0; |
1109 | } |
1110 | |
1111 | static const struct usb_gadget_ops fotg210_gadget_ops = { |
1112 | .udc_start = fotg210_udc_start, |
1113 | .udc_stop = fotg210_udc_stop, |
1114 | .vbus_session = fotg210_vbus_session, |
1115 | }; |
1116 | |
1117 | /** |
1118 | * fotg210_phy_event - Called by phy upon VBus event |
1119 | * @nb: notifier block |
1120 | * @action: phy action, is vbus connect or disconnect |
1121 | * @data: the usb_gadget structure in fotg210 |
1122 | * |
1123 | * Called by the USB Phy when a cable connect or disconnect is sensed. |
1124 | * |
1125 | * Returns: NOTIFY_OK or NOTIFY_DONE |
1126 | */ |
1127 | static int fotg210_phy_event(struct notifier_block *nb, unsigned long action, |
1128 | void *data) |
1129 | { |
1130 | struct usb_gadget *gadget = data; |
1131 | |
1132 | if (!gadget) |
1133 | return NOTIFY_DONE; |
1134 | |
1135 | switch (action) { |
1136 | case USB_EVENT_VBUS: |
1137 | usb_gadget_vbus_connect(gadget); |
1138 | return NOTIFY_OK; |
1139 | case USB_EVENT_NONE: |
1140 | usb_gadget_vbus_disconnect(gadget); |
1141 | return NOTIFY_OK; |
1142 | default: |
1143 | return NOTIFY_DONE; |
1144 | } |
1145 | } |
1146 | |
1147 | static struct notifier_block fotg210_phy_notifier = { |
1148 | .notifier_call = fotg210_phy_event, |
1149 | }; |
1150 | |
1151 | int fotg210_udc_remove(struct platform_device *pdev) |
1152 | { |
1153 | struct fotg210_udc *fotg210 = platform_get_drvdata(pdev); |
1154 | int i; |
1155 | |
1156 | usb_del_gadget_udc(gadget: &fotg210->gadget); |
1157 | if (!IS_ERR_OR_NULL(ptr: fotg210->phy)) { |
1158 | usb_unregister_notifier(x: fotg210->phy, nb: &fotg210_phy_notifier); |
1159 | usb_put_phy(fotg210->phy); |
1160 | } |
1161 | iounmap(addr: fotg210->reg); |
1162 | free_irq(platform_get_irq(pdev, 0), fotg210); |
1163 | |
1164 | fotg210_ep_free_request(ep: &fotg210->ep[0]->ep, req: fotg210->ep0_req); |
1165 | for (i = 0; i < FOTG210_MAX_NUM_EP; i++) |
1166 | kfree(objp: fotg210->ep[i]); |
1167 | |
1168 | kfree(objp: fotg210); |
1169 | |
1170 | return 0; |
1171 | } |
1172 | |
1173 | int fotg210_udc_probe(struct platform_device *pdev, struct fotg210 *fotg) |
1174 | { |
1175 | struct fotg210_udc *fotg210 = NULL; |
1176 | struct device *dev = &pdev->dev; |
1177 | int irq; |
1178 | int ret = 0; |
1179 | int i; |
1180 | |
1181 | irq = platform_get_irq(pdev, 0); |
1182 | if (irq < 0) |
1183 | return irq; |
1184 | |
1185 | /* initialize udc */ |
1186 | fotg210 = kzalloc(size: sizeof(struct fotg210_udc), GFP_KERNEL); |
1187 | if (fotg210 == NULL) |
1188 | return -ENOMEM; |
1189 | |
1190 | fotg210->dev = dev; |
1191 | fotg210->fotg = fotg; |
1192 | |
1193 | fotg210->phy = devm_usb_get_phy_by_phandle(dev, phandle: "usb-phy" , index: 0); |
1194 | if (IS_ERR(ptr: fotg210->phy)) { |
1195 | ret = PTR_ERR(ptr: fotg210->phy); |
1196 | if (ret == -EPROBE_DEFER) |
1197 | goto err_free; |
1198 | dev_info(dev, "no PHY found\n" ); |
1199 | fotg210->phy = NULL; |
1200 | } else { |
1201 | ret = usb_phy_init(x: fotg210->phy); |
1202 | if (ret) |
1203 | goto err_free; |
1204 | dev_info(dev, "found and initialized PHY\n" ); |
1205 | } |
1206 | |
1207 | ret = -ENOMEM; |
1208 | |
1209 | for (i = 0; i < FOTG210_MAX_NUM_EP; i++) { |
1210 | fotg210->ep[i] = kzalloc(size: sizeof(struct fotg210_ep), GFP_KERNEL); |
1211 | if (!fotg210->ep[i]) |
1212 | goto err_alloc; |
1213 | } |
1214 | |
1215 | fotg210->reg = fotg->base; |
1216 | |
1217 | spin_lock_init(&fotg210->lock); |
1218 | |
1219 | platform_set_drvdata(pdev, data: fotg210); |
1220 | |
1221 | fotg210->gadget.ops = &fotg210_gadget_ops; |
1222 | |
1223 | fotg210->gadget.max_speed = USB_SPEED_HIGH; |
1224 | fotg210->gadget.dev.parent = dev; |
1225 | fotg210->gadget.dev.dma_mask = dev->dma_mask; |
1226 | fotg210->gadget.name = udc_name; |
1227 | |
1228 | INIT_LIST_HEAD(list: &fotg210->gadget.ep_list); |
1229 | |
1230 | for (i = 0; i < FOTG210_MAX_NUM_EP; i++) { |
1231 | struct fotg210_ep *ep = fotg210->ep[i]; |
1232 | |
1233 | if (i) { |
1234 | INIT_LIST_HEAD(list: &fotg210->ep[i]->ep.ep_list); |
1235 | list_add_tail(new: &fotg210->ep[i]->ep.ep_list, |
1236 | head: &fotg210->gadget.ep_list); |
1237 | } |
1238 | ep->fotg210 = fotg210; |
1239 | INIT_LIST_HEAD(list: &ep->queue); |
1240 | ep->ep.name = fotg210_ep_name[i]; |
1241 | ep->ep.ops = &fotg210_ep_ops; |
1242 | usb_ep_set_maxpacket_limit(ep: &ep->ep, maxpacket_limit: (unsigned short) ~0); |
1243 | |
1244 | if (i == 0) { |
1245 | ep->ep.caps.type_control = true; |
1246 | } else { |
1247 | ep->ep.caps.type_iso = true; |
1248 | ep->ep.caps.type_bulk = true; |
1249 | ep->ep.caps.type_int = true; |
1250 | } |
1251 | |
1252 | ep->ep.caps.dir_in = true; |
1253 | ep->ep.caps.dir_out = true; |
1254 | } |
1255 | usb_ep_set_maxpacket_limit(ep: &fotg210->ep[0]->ep, maxpacket_limit: 0x40); |
1256 | fotg210->gadget.ep0 = &fotg210->ep[0]->ep; |
1257 | INIT_LIST_HEAD(list: &fotg210->gadget.ep0->ep_list); |
1258 | |
1259 | fotg210->ep0_req = fotg210_ep_alloc_request(ep: &fotg210->ep[0]->ep, |
1260 | GFP_KERNEL); |
1261 | if (fotg210->ep0_req == NULL) |
1262 | goto err_map; |
1263 | |
1264 | fotg210->ep0_req->complete = fotg210_ep0_complete; |
1265 | |
1266 | fotg210_init(fotg210); |
1267 | |
1268 | fotg210_disable_unplug(fotg210); |
1269 | |
1270 | ret = request_irq(irq, handler: fotg210_irq, IRQF_SHARED, |
1271 | name: udc_name, dev: fotg210); |
1272 | if (ret < 0) { |
1273 | dev_err_probe(dev, err: ret, fmt: "request_irq error\n" ); |
1274 | goto err_req; |
1275 | } |
1276 | |
1277 | if (!IS_ERR_OR_NULL(ptr: fotg210->phy)) |
1278 | usb_register_notifier(x: fotg210->phy, nb: &fotg210_phy_notifier); |
1279 | |
1280 | ret = usb_add_gadget_udc(parent: dev, gadget: &fotg210->gadget); |
1281 | if (ret) |
1282 | goto err_add_udc; |
1283 | |
1284 | dev_info(dev, "version %s\n" , DRIVER_VERSION); |
1285 | |
1286 | return 0; |
1287 | |
1288 | err_add_udc: |
1289 | if (!IS_ERR_OR_NULL(ptr: fotg210->phy)) |
1290 | usb_unregister_notifier(x: fotg210->phy, nb: &fotg210_phy_notifier); |
1291 | free_irq(irq, fotg210); |
1292 | |
1293 | err_req: |
1294 | fotg210_ep_free_request(ep: &fotg210->ep[0]->ep, req: fotg210->ep0_req); |
1295 | |
1296 | err_map: |
1297 | iounmap(addr: fotg210->reg); |
1298 | |
1299 | err_alloc: |
1300 | for (i = 0; i < FOTG210_MAX_NUM_EP; i++) |
1301 | kfree(objp: fotg210->ep[i]); |
1302 | |
1303 | err_free: |
1304 | kfree(objp: fotg210); |
1305 | return ret; |
1306 | } |
1307 | |