?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs: use kmem_cache_zalloc instead
[pv_ops_mirror.git] / drivers / usb / gadget / m66592-udc.c
blobebc5536aa271d8ad78b76dcf701670ee76b1982c
1 /*
2 * M66592 UDC (USB gadget)
3 *
4 * Copyright (C) 2006-2007 Renesas Solutions Corp.
5 *
6 * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 */
22
23 #include <linux/module.h>
24 #include <linux/interrupt.h>
25 #include <linux/delay.h>
26 #include <linux/io.h>
27 #include <linux/platform_device.h>
28
29 #include <linux/usb/ch9.h>
30 #include <linux/usb/gadget.h>
31
32 #include "m66592-udc.h"
33
34
35 MODULE_DESCRIPTION("M66592 USB gadget driver");
36 MODULE_LICENSE("GPL");
37 MODULE_AUTHOR("Yoshihiro Shimoda");
38
39 #define DRIVER_VERSION "29 May 2007"
40
41 /* module parameters */
42 static unsigned short clock = M66592_XTAL24;
43 module_param(clock, ushort, 0644);
44 MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 "
45 "(default=16384)");
46
47 static unsigned short vif = M66592_LDRV;
48 module_param(vif, ushort, 0644);
49 MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0 (default=32768)");
50
51 static unsigned short endian;
52 module_param(endian, ushort, 0644);
53 MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
54
55 static unsigned short irq_sense = M66592_INTL;
56 module_param(irq_sense, ushort, 0644);
57 MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=2, falling edge=0 "
58 "(default=2)");
59
60 static const char udc_name[] = "m66592_udc";
61 static const char *m66592_ep_name[] = {
62 "ep0", "ep1", "ep2", "ep3", "ep4", "ep5", "ep6", "ep7"
63 };
64
65 static void disable_controller(struct m66592 *m66592);
66 static void irq_ep0_write(struct m66592_ep *ep, struct m66592_request *req);
67 static void irq_packet_write(struct m66592_ep *ep, struct m66592_request *req);
68 static int m66592_queue(struct usb_ep *_ep, struct usb_request *_req,
69 gfp_t gfp_flags);
70
71 static void transfer_complete(struct m66592_ep *ep,
72 struct m66592_request *req, int status);
73
74 /*-------------------------------------------------------------------------*/
75 static inline u16 get_usb_speed(struct m66592 *m66592)
76 {
77 return (m66592_read(m66592, M66592_DVSTCTR) & M66592_RHST);
78 }
79
80 static void enable_pipe_irq(struct m66592 *m66592, u16 pipenum,
81 unsigned long reg)
82 {
83 u16 tmp;
84
85 tmp = m66592_read(m66592, M66592_INTENB0);
86 m66592_bclr(m66592, M66592_BEMPE | M66592_NRDYE | M66592_BRDYE,
87 M66592_INTENB0);
88 m66592_bset(m66592, (1 << pipenum), reg);
89 m66592_write(m66592, tmp, M66592_INTENB0);
90 }
91
92 static void disable_pipe_irq(struct m66592 *m66592, u16 pipenum,
93 unsigned long reg)
94 {
95 u16 tmp;
96
97 tmp = m66592_read(m66592, M66592_INTENB0);
98 m66592_bclr(m66592, M66592_BEMPE | M66592_NRDYE | M66592_BRDYE,
99 M66592_INTENB0);
100 m66592_bclr(m66592, (1 << pipenum), reg);
101 m66592_write(m66592, tmp, M66592_INTENB0);
102 }
103
104 static void m66592_usb_connect(struct m66592 *m66592)
105 {
106 m66592_bset(m66592, M66592_CTRE, M66592_INTENB0);
107 m66592_bset(m66592, M66592_WDST | M66592_RDST | M66592_CMPL,
108 M66592_INTENB0);
109 m66592_bset(m66592, M66592_BEMPE | M66592_BRDYE, M66592_INTENB0);
110
111 m66592_bset(m66592, M66592_DPRPU, M66592_SYSCFG);
112 }
113
114 static void m66592_usb_disconnect(struct m66592 *m66592)
115 __releases(m66592->lock)
116 __acquires(m66592->lock)
117 {
118 m66592_bclr(m66592, M66592_CTRE, M66592_INTENB0);
119 m66592_bclr(m66592, M66592_WDST | M66592_RDST | M66592_CMPL,
120 M66592_INTENB0);
121 m66592_bclr(m66592, M66592_BEMPE | M66592_BRDYE, M66592_INTENB0);
122 m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
123
124 m66592->gadget.speed = USB_SPEED_UNKNOWN;
125 spin_unlock(&m66592->lock);
126 m66592->driver->disconnect(&m66592->gadget);
127 spin_lock(&m66592->lock);
128
129 disable_controller(m66592);
130 INIT_LIST_HEAD(&m66592->ep[0].queue);
131 }
132
133 static inline u16 control_reg_get_pid(struct m66592 *m66592, u16 pipenum)
134 {
135 u16 pid = 0;
136 unsigned long offset;
137
138 if (pipenum == 0)
139 pid = m66592_read(m66592, M66592_DCPCTR) & M66592_PID;
140 else if (pipenum < M66592_MAX_NUM_PIPE) {
141 offset = get_pipectr_addr(pipenum);
142 pid = m66592_read(m66592, offset) & M66592_PID;
143 } else
144 printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
145
146 return pid;
147 }
148
149 static inline void control_reg_set_pid(struct m66592 *m66592, u16 pipenum,
150 u16 pid)
151 {
152 unsigned long offset;
153
154 if (pipenum == 0)
155 m66592_mdfy(m66592, pid, M66592_PID, M66592_DCPCTR);
156 else if (pipenum < M66592_MAX_NUM_PIPE) {
157 offset = get_pipectr_addr(pipenum);
158 m66592_mdfy(m66592, pid, M66592_PID, offset);
159 } else
160 printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
161 }
162
163 static inline void pipe_start(struct m66592 *m66592, u16 pipenum)
164 {
165 control_reg_set_pid(m66592, pipenum, M66592_PID_BUF);
166 }
167
168 static inline void pipe_stop(struct m66592 *m66592, u16 pipenum)
169 {
170 control_reg_set_pid(m66592, pipenum, M66592_PID_NAK);
171 }
172
173 static inline void pipe_stall(struct m66592 *m66592, u16 pipenum)
174 {
175 control_reg_set_pid(m66592, pipenum, M66592_PID_STALL);
176 }
177
178 static inline u16 control_reg_get(struct m66592 *m66592, u16 pipenum)
179 {
180 u16 ret = 0;
181 unsigned long offset;
182
183 if (pipenum == 0)
184 ret = m66592_read(m66592, M66592_DCPCTR);
185 else if (pipenum < M66592_MAX_NUM_PIPE) {
186 offset = get_pipectr_addr(pipenum);
187 ret = m66592_read(m66592, offset);
188 } else
189 printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
190
191 return ret;
192 }
193
194 static inline void control_reg_sqclr(struct m66592 *m66592, u16 pipenum)
195 {
196 unsigned long offset;
197
198 pipe_stop(m66592, pipenum);
199
200 if (pipenum == 0)
201 m66592_bset(m66592, M66592_SQCLR, M66592_DCPCTR);
202 else if (pipenum < M66592_MAX_NUM_PIPE) {
203 offset = get_pipectr_addr(pipenum);
204 m66592_bset(m66592, M66592_SQCLR, offset);
205 } else
206 printk(KERN_ERR "unexpect pipe num(%d)\n", pipenum);
207 }
208
209 static inline int get_buffer_size(struct m66592 *m66592, u16 pipenum)
210 {
211 u16 tmp;
212 int size;
213
214 if (pipenum == 0) {
215 tmp = m66592_read(m66592, M66592_DCPCFG);
216 if ((tmp & M66592_CNTMD) != 0)
217 size = 256;
218 else {
219 tmp = m66592_read(m66592, M66592_DCPMAXP);
220 size = tmp & M66592_MAXP;
221 }
222 } else {
223 m66592_write(m66592, pipenum, M66592_PIPESEL);
224 tmp = m66592_read(m66592, M66592_PIPECFG);
225 if ((tmp & M66592_CNTMD) != 0) {
226 tmp = m66592_read(m66592, M66592_PIPEBUF);
227 size = ((tmp >> 10) + 1) * 64;
228 } else {
229 tmp = m66592_read(m66592, M66592_PIPEMAXP);
230 size = tmp & M66592_MXPS;
231 }
232 }
233
234 return size;
235 }
236
237 static inline void pipe_change(struct m66592 *m66592, u16 pipenum)
238 {
239 struct m66592_ep *ep = m66592->pipenum2ep[pipenum];
240
241 if (ep->use_dma)
242 return;
243
244 m66592_mdfy(m66592, pipenum, M66592_CURPIPE, ep->fifosel);
245
246 ndelay(450);
247
248 m66592_bset(m66592, M66592_MBW, ep->fifosel);
249 }
250
251 static int pipe_buffer_setting(struct m66592 *m66592,
252 struct m66592_pipe_info *info)
253 {
254 u16 bufnum = 0, buf_bsize = 0;
255 u16 pipecfg = 0;
256
257 if (info->pipe == 0)
258 return -EINVAL;
259
260 m66592_write(m66592, info->pipe, M66592_PIPESEL);
261
262 if (info->dir_in)
263 pipecfg |= M66592_DIR;
264 pipecfg |= info->type;
265 pipecfg |= info->epnum;
266 switch (info->type) {
267 case M66592_INT:
268 bufnum = 4 + (info->pipe - M66592_BASE_PIPENUM_INT);
269 buf_bsize = 0;
270 break;
271 case M66592_BULK:
272 bufnum = m66592->bi_bufnum +
273 (info->pipe - M66592_BASE_PIPENUM_BULK) * 16;
274 m66592->bi_bufnum += 16;
275 buf_bsize = 7;
276 pipecfg |= M66592_DBLB;
277 if (!info->dir_in)
278 pipecfg |= M66592_SHTNAK;
279 break;
280 case M66592_ISO:
281 bufnum = m66592->bi_bufnum +
282 (info->pipe - M66592_BASE_PIPENUM_ISOC) * 16;
283 m66592->bi_bufnum += 16;
284 buf_bsize = 7;
285 break;
286 }
287 if (m66592->bi_bufnum > M66592_MAX_BUFNUM) {
288 printk(KERN_ERR "m66592 pipe memory is insufficient(%d)\n",
289 m66592->bi_bufnum);
290 return -ENOMEM;
291 }
292
293 m66592_write(m66592, pipecfg, M66592_PIPECFG);
294 m66592_write(m66592, (buf_bsize << 10) | (bufnum), M66592_PIPEBUF);
295 m66592_write(m66592, info->maxpacket, M66592_PIPEMAXP);
296 if (info->interval)
297 info->interval--;
298 m66592_write(m66592, info->interval, M66592_PIPEPERI);
299
300 return 0;
301 }
302
303 static void pipe_buffer_release(struct m66592 *m66592,
304 struct m66592_pipe_info *info)
305 {
306 if (info->pipe == 0)
307 return;
308
309 switch (info->type) {
310 case M66592_BULK:
311 if (is_bulk_pipe(info->pipe))
312 m66592->bi_bufnum -= 16;
313 break;
314 case M66592_ISO:
315 if (is_isoc_pipe(info->pipe))
316 m66592->bi_bufnum -= 16;
317 break;
318 }
319
320 if (is_bulk_pipe(info->pipe)) {
321 m66592->bulk--;
322 } else if (is_interrupt_pipe(info->pipe))
323 m66592->interrupt--;
324 else if (is_isoc_pipe(info->pipe)) {
325 m66592->isochronous--;
326 if (info->type == M66592_BULK)
327 m66592->bulk--;
328 } else
329 printk(KERN_ERR "ep_release: unexpect pipenum (%d)\n",
330 info->pipe);
331 }
332
333 static void pipe_initialize(struct m66592_ep *ep)
334 {
335 struct m66592 *m66592 = ep->m66592;
336
337 m66592_mdfy(m66592, 0, M66592_CURPIPE, ep->fifosel);
338
339 m66592_write(m66592, M66592_ACLRM, ep->pipectr);
340 m66592_write(m66592, 0, ep->pipectr);
341 m66592_write(m66592, M66592_SQCLR, ep->pipectr);
342 if (ep->use_dma) {
343 m66592_mdfy(m66592, ep->pipenum, M66592_CURPIPE, ep->fifosel);
344
345 ndelay(450);
346
347 m66592_bset(m66592, M66592_MBW, ep->fifosel);
348 }
349 }
350
351 static void m66592_ep_setting(struct m66592 *m66592, struct m66592_ep *ep,
352 const struct usb_endpoint_descriptor *desc,
353 u16 pipenum, int dma)
354 {
355 if ((pipenum != 0) && dma) {
356 if (m66592->num_dma == 0) {
357 m66592->num_dma++;
358 ep->use_dma = 1;
359 ep->fifoaddr = M66592_D0FIFO;
360 ep->fifosel = M66592_D0FIFOSEL;
361 ep->fifoctr = M66592_D0FIFOCTR;
362 ep->fifotrn = M66592_D0FIFOTRN;
363 } else if (m66592->num_dma == 1) {
364 m66592->num_dma++;
365 ep->use_dma = 1;
366 ep->fifoaddr = M66592_D1FIFO;
367 ep->fifosel = M66592_D1FIFOSEL;
368 ep->fifoctr = M66592_D1FIFOCTR;
369 ep->fifotrn = M66592_D1FIFOTRN;
370 } else {
371 ep->use_dma = 0;
372 ep->fifoaddr = M66592_CFIFO;
373 ep->fifosel = M66592_CFIFOSEL;
374 ep->fifoctr = M66592_CFIFOCTR;
375 ep->fifotrn = 0;
376 }
377 } else {
378 ep->use_dma = 0;
379 ep->fifoaddr = M66592_CFIFO;
380 ep->fifosel = M66592_CFIFOSEL;
381 ep->fifoctr = M66592_CFIFOCTR;
382 ep->fifotrn = 0;
383 }
384
385 ep->pipectr = get_pipectr_addr(pipenum);
386 ep->pipenum = pipenum;
387 ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
388 m66592->pipenum2ep[pipenum] = ep;
389 m66592->epaddr2ep[desc->bEndpointAddress&USB_ENDPOINT_NUMBER_MASK] = ep;
390 INIT_LIST_HEAD(&ep->queue);
391 }
392
393 static void m66592_ep_release(struct m66592_ep *ep)
394 {
395 struct m66592 *m66592 = ep->m66592;
396 u16 pipenum = ep->pipenum;
397
398 if (pipenum == 0)
399 return;
400
401 if (ep->use_dma)
402 m66592->num_dma--;
403 ep->pipenum = 0;
404 ep->busy = 0;
405 ep->use_dma = 0;
406 }
407
408 static int alloc_pipe_config(struct m66592_ep *ep,
409 const struct usb_endpoint_descriptor *desc)
410 {
411 struct m66592 *m66592 = ep->m66592;
412 struct m66592_pipe_info info;
413 int dma = 0;
414 int *counter;
415 int ret;
416
417 ep->desc = desc;
418
419 BUG_ON(ep->pipenum);
420
421 switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
422 case USB_ENDPOINT_XFER_BULK:
423 if (m66592->bulk >= M66592_MAX_NUM_BULK) {
424 if (m66592->isochronous >= M66592_MAX_NUM_ISOC) {
425 printk(KERN_ERR "bulk pipe is insufficient\n");
426 return -ENODEV;
427 } else {
428 info.pipe = M66592_BASE_PIPENUM_ISOC
429 + m66592->isochronous;
430 counter = &m66592->isochronous;
431 }
432 } else {
433 info.pipe = M66592_BASE_PIPENUM_BULK + m66592->bulk;
434 counter = &m66592->bulk;
435 }
436 info.type = M66592_BULK;
437 dma = 1;
438 break;
439 case USB_ENDPOINT_XFER_INT:
440 if (m66592->interrupt >= M66592_MAX_NUM_INT) {
441 printk(KERN_ERR "interrupt pipe is insufficient\n");
442 return -ENODEV;
443 }
444 info.pipe = M66592_BASE_PIPENUM_INT + m66592->interrupt;
445 info.type = M66592_INT;
446 counter = &m66592->interrupt;
447 break;
448 case USB_ENDPOINT_XFER_ISOC:
449 if (m66592->isochronous >= M66592_MAX_NUM_ISOC) {
450 printk(KERN_ERR "isochronous pipe is insufficient\n");
451 return -ENODEV;
452 }
453 info.pipe = M66592_BASE_PIPENUM_ISOC + m66592->isochronous;
454 info.type = M66592_ISO;
455 counter = &m66592->isochronous;
456 break;
457 default:
458 printk(KERN_ERR "unexpect xfer type\n");
459 return -EINVAL;
460 }
461 ep->type = info.type;
462
463 info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
464 info.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
465 info.interval = desc->bInterval;
466 if (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
467 info.dir_in = 1;
468 else
469 info.dir_in = 0;
470
471 ret = pipe_buffer_setting(m66592, &info);
472 if (ret < 0) {
473 printk(KERN_ERR "pipe_buffer_setting fail\n");
474 return ret;
475 }
476
477 (*counter)++;
478 if ((counter == &m66592->isochronous) && info.type == M66592_BULK)
479 m66592->bulk++;
480
481 m66592_ep_setting(m66592, ep, desc, info.pipe, dma);
482 pipe_initialize(ep);
483
484 return 0;
485 }
486
487 static int free_pipe_config(struct m66592_ep *ep)
488 {
489 struct m66592 *m66592 = ep->m66592;
490 struct m66592_pipe_info info;
491
492 info.pipe = ep->pipenum;
493 info.type = ep->type;
494 pipe_buffer_release(m66592, &info);
495 m66592_ep_release(ep);
496
497 return 0;
498 }
499
500 /*-------------------------------------------------------------------------*/
501 static void pipe_irq_enable(struct m66592 *m66592, u16 pipenum)
502 {
503 enable_irq_ready(m66592, pipenum);
504 enable_irq_nrdy(m66592, pipenum);
505 }
506
507 static void pipe_irq_disable(struct m66592 *m66592, u16 pipenum)
508 {
509 disable_irq_ready(m66592, pipenum);
510 disable_irq_nrdy(m66592, pipenum);
511 }
512
513 /* if complete is true, gadget driver complete function is not call */
514 static void control_end(struct m66592 *m66592, unsigned ccpl)
515 {
516 m66592->ep[0].internal_ccpl = ccpl;
517 pipe_start(m66592, 0);
518 m66592_bset(m66592, M66592_CCPL, M66592_DCPCTR);
519 }
520
521 static void start_ep0_write(struct m66592_ep *ep, struct m66592_request *req)
522 {
523 struct m66592 *m66592 = ep->m66592;
524
525 pipe_change(m66592, ep->pipenum);
526 m66592_mdfy(m66592, M66592_ISEL | M66592_PIPE0,
527 (M66592_ISEL | M66592_CURPIPE),
528 M66592_CFIFOSEL);
529 m66592_write(m66592, M66592_BCLR, ep->fifoctr);
530 if (req->req.length == 0) {
531 m66592_bset(m66592, M66592_BVAL, ep->fifoctr);
532 pipe_start(m66592, 0);
533 transfer_complete(ep, req, 0);
534 } else {
535 m66592_write(m66592, ~M66592_BEMP0, M66592_BEMPSTS);
536 irq_ep0_write(ep, req);
537 }
538 }
539
540 static void start_packet_write(struct m66592_ep *ep, struct m66592_request *req)
541 {
542 struct m66592 *m66592 = ep->m66592;
543 u16 tmp;
544
545 pipe_change(m66592, ep->pipenum);
546 disable_irq_empty(m66592, ep->pipenum);
547 pipe_start(m66592, ep->pipenum);
548
549 tmp = m66592_read(m66592, ep->fifoctr);
550 if (unlikely((tmp & M66592_FRDY) == 0))
551 pipe_irq_enable(m66592, ep->pipenum);
552 else
553 irq_packet_write(ep, req);
554 }
555
556 static void start_packet_read(struct m66592_ep *ep, struct m66592_request *req)
557 {
558 struct m66592 *m66592 = ep->m66592;
559 u16 pipenum = ep->pipenum;
560
561 if (ep->pipenum == 0) {
562 m66592_mdfy(m66592, M66592_PIPE0,
563 (M66592_ISEL | M66592_CURPIPE),
564 M66592_CFIFOSEL);
565 m66592_write(m66592, M66592_BCLR, ep->fifoctr);
566 pipe_start(m66592, pipenum);
567 pipe_irq_enable(m66592, pipenum);
568 } else {
569 if (ep->use_dma) {
570 m66592_bset(m66592, M66592_TRCLR, ep->fifosel);
571 pipe_change(m66592, pipenum);
572 m66592_bset(m66592, M66592_TRENB, ep->fifosel);
573 m66592_write(m66592,
574 (req->req.length + ep->ep.maxpacket - 1)
575 / ep->ep.maxpacket,
576 ep->fifotrn);
577 }
578 pipe_start(m66592, pipenum); /* trigger once */
579 pipe_irq_enable(m66592, pipenum);
580 }
581 }
582
583 static void start_packet(struct m66592_ep *ep, struct m66592_request *req)
584 {
585 if (ep->desc->bEndpointAddress & USB_DIR_IN)
586 start_packet_write(ep, req);
587 else
588 start_packet_read(ep, req);
589 }
590
591 static void start_ep0(struct m66592_ep *ep, struct m66592_request *req)
592 {
593 u16 ctsq;
594
595 ctsq = m66592_read(ep->m66592, M66592_INTSTS0) & M66592_CTSQ;
596
597 switch (ctsq) {
598 case M66592_CS_RDDS:
599 start_ep0_write(ep, req);
600 break;
601 case M66592_CS_WRDS:
602 start_packet_read(ep, req);
603 break;
604
605 case M66592_CS_WRND:
606 control_end(ep->m66592, 0);
607 break;
608 default:
609 printk(KERN_ERR "start_ep0: unexpect ctsq(%x)\n", ctsq);
610 break;
611 }
612 }
613
614 static void init_controller(struct m66592 *m66592)
615 {
616 m66592_bset(m66592, (vif & M66592_LDRV) | (endian & M66592_BIGEND),
617 M66592_PINCFG);
618 m66592_bset(m66592, M66592_HSE, M66592_SYSCFG); /* High spd */
619 m66592_mdfy(m66592, clock & M66592_XTAL, M66592_XTAL, M66592_SYSCFG);
620
621 m66592_bclr(m66592, M66592_USBE, M66592_SYSCFG);
622 m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
623 m66592_bset(m66592, M66592_USBE, M66592_SYSCFG);
624
625 m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
626
627 msleep(3);
628
629 m66592_bset(m66592, M66592_RCKE | M66592_PLLC, M66592_SYSCFG);
630
631 msleep(1);
632
633 m66592_bset(m66592, M66592_SCKE, M66592_SYSCFG);
634
635 m66592_bset(m66592, irq_sense & M66592_INTL, M66592_INTENB1);
636 m66592_write(m66592, M66592_BURST | M66592_CPU_ADR_RD_WR,
637 M66592_DMA0CFG);
638 }
639
640 static void disable_controller(struct m66592 *m66592)
641 {
642 m66592_bclr(m66592, M66592_SCKE, M66592_SYSCFG);
643 udelay(1);
644 m66592_bclr(m66592, M66592_PLLC, M66592_SYSCFG);
645 udelay(1);
646 m66592_bclr(m66592, M66592_RCKE, M66592_SYSCFG);
647 udelay(1);
648 m66592_bclr(m66592, M66592_XCKE, M66592_SYSCFG);
649 }
650
651 static void m66592_start_xclock(struct m66592 *m66592)
652 {
653 u16 tmp;
654
655 tmp = m66592_read(m66592, M66592_SYSCFG);
656 if (!(tmp & M66592_XCKE))
657 m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
658 }
659
660 /*-------------------------------------------------------------------------*/
661 static void transfer_complete(struct m66592_ep *ep,
662 struct m66592_request *req, int status)
663 __releases(m66592->lock)
664 __acquires(m66592->lock)
665 {
666 int restart = 0;
667
668 if (unlikely(ep->pipenum == 0)) {
669 if (ep->internal_ccpl) {
670 ep->internal_ccpl = 0;
671 return;
672 }
673 }
674
675 list_del_init(&req->queue);
676 if (ep->m66592->gadget.speed == USB_SPEED_UNKNOWN)
677 req->req.status = -ESHUTDOWN;
678 else
679 req->req.status = status;
680
681 if (!list_empty(&ep->queue))
682 restart = 1;
683
684 spin_unlock(&ep->m66592->lock);
685 req->req.complete(&ep->ep, &req->req);
686 spin_lock(&ep->m66592->lock);
687
688 if (restart) {
689 req = list_entry(ep->queue.next, struct m66592_request, queue);
690 if (ep->desc)
691 start_packet(ep, req);
692 }
693 }
694
695 static void irq_ep0_write(struct m66592_ep *ep, struct m66592_request *req)
696 {
697 int i;
698 u16 tmp;
699 unsigned bufsize;
700 size_t size;
701 void *buf;
702 u16 pipenum = ep->pipenum;
703 struct m66592 *m66592 = ep->m66592;
704
705 pipe_change(m66592, pipenum);
706 m66592_bset(m66592, M66592_ISEL, ep->fifosel);
707
708 i = 0;
709 do {
710 tmp = m66592_read(m66592, ep->fifoctr);
711 if (i++ > 100000) {
712 printk(KERN_ERR "pipe0 is busy. maybe cpu i/o bus"
713 "conflict. please power off this controller.");
714 return;
715 }
716 ndelay(1);
717 } while ((tmp & M66592_FRDY) == 0);
718
719 /* prepare parameters */
720 bufsize = get_buffer_size(m66592, pipenum);
721 buf = req->req.buf + req->req.actual;
722 size = min(bufsize, req->req.length - req->req.actual);
723
724 /* write fifo */
725 if (req->req.buf) {
726 if (size > 0)
727 m66592_write_fifo(m66592, ep->fifoaddr, buf, size);
728 if ((size == 0) || ((size % ep->ep.maxpacket) != 0))
729 m66592_bset(m66592, M66592_BVAL, ep->fifoctr);
730 }
731
732 /* update parameters */
733 req->req.actual += size;
734
735 /* check transfer finish */
736 if ((!req->req.zero && (req->req.actual == req->req.length))
737 || (size % ep->ep.maxpacket)
738 || (size == 0)) {
739 disable_irq_ready(m66592, pipenum);
740 disable_irq_empty(m66592, pipenum);
741 } else {
742 disable_irq_ready(m66592, pipenum);
743 enable_irq_empty(m66592, pipenum);
744 }
745 pipe_start(m66592, pipenum);
746 }
747
748 static void irq_packet_write(struct m66592_ep *ep, struct m66592_request *req)
749 {
750 u16 tmp;
751 unsigned bufsize;
752 size_t size;
753 void *buf;
754 u16 pipenum = ep->pipenum;
755 struct m66592 *m66592 = ep->m66592;
756
757 pipe_change(m66592, pipenum);
758 tmp = m66592_read(m66592, ep->fifoctr);
759 if (unlikely((tmp & M66592_FRDY) == 0)) {
760 pipe_stop(m66592, pipenum);
761 pipe_irq_disable(m66592, pipenum);
762 printk(KERN_ERR "write fifo not ready. pipnum=%d\n", pipenum);
763 return;
764 }
765
766 /* prepare parameters */
767 bufsize = get_buffer_size(m66592, pipenum);
768 buf = req->req.buf + req->req.actual;
769 size = min(bufsize, req->req.length - req->req.actual);
770
771 /* write fifo */
772 if (req->req.buf) {
773 m66592_write_fifo(m66592, ep->fifoaddr, buf, size);
774 if ((size == 0)
775 || ((size % ep->ep.maxpacket) != 0)
776 || ((bufsize != ep->ep.maxpacket)
777 && (bufsize > size)))
778 m66592_bset(m66592, M66592_BVAL, ep->fifoctr);
779 }
780
781 /* update parameters */
782 req->req.actual += size;
783 /* check transfer finish */
784 if ((!req->req.zero && (req->req.actual == req->req.length))
785 || (size % ep->ep.maxpacket)
786 || (size == 0)) {
787 disable_irq_ready(m66592, pipenum);
788 enable_irq_empty(m66592, pipenum);
789 } else {
790 disable_irq_empty(m66592, pipenum);
791 pipe_irq_enable(m66592, pipenum);
792 }
793 }
794
795 static void irq_packet_read(struct m66592_ep *ep, struct m66592_request *req)
796 {
797 u16 tmp;
798 int rcv_len, bufsize, req_len;
799 int size;
800 void *buf;
801 u16 pipenum = ep->pipenum;
802 struct m66592 *m66592 = ep->m66592;
803 int finish = 0;
804
805 pipe_change(m66592, pipenum);
806 tmp = m66592_read(m66592, ep->fifoctr);
807 if (unlikely((tmp & M66592_FRDY) == 0)) {
808 req->req.status = -EPIPE;
809 pipe_stop(m66592, pipenum);
810 pipe_irq_disable(m66592, pipenum);
811 printk(KERN_ERR "read fifo not ready");
812 return;
813 }
814
815 /* prepare parameters */
816 rcv_len = tmp & M66592_DTLN;
817 bufsize = get_buffer_size(m66592, pipenum);
818
819 buf = req->req.buf + req->req.actual;
820 req_len = req->req.length - req->req.actual;
821 if (rcv_len < bufsize)
822 size = min(rcv_len, req_len);
823 else
824 size = min(bufsize, req_len);
825
826 /* update parameters */
827 req->req.actual += size;
828
829 /* check transfer finish */
830 if ((!req->req.zero && (req->req.actual == req->req.length))
831 || (size % ep->ep.maxpacket)
832 || (size == 0)) {
833 pipe_stop(m66592, pipenum);
834 pipe_irq_disable(m66592, pipenum);
835 finish = 1;
836 }
837
838 /* read fifo */
839 if (req->req.buf) {
840 if (size == 0)
841 m66592_write(m66592, M66592_BCLR, ep->fifoctr);
842 else
843 m66592_read_fifo(m66592, ep->fifoaddr, buf, size);
844 }
845
846 if ((ep->pipenum != 0) && finish)
847 transfer_complete(ep, req, 0);
848 }
849
850 static void irq_pipe_ready(struct m66592 *m66592, u16 status, u16 enb)
851 {
852 u16 check;
853 u16 pipenum;
854 struct m66592_ep *ep;
855 struct m66592_request *req;
856
857 if ((status & M66592_BRDY0) && (enb & M66592_BRDY0)) {
858 m66592_write(m66592, ~M66592_BRDY0, M66592_BRDYSTS);
859 m66592_mdfy(m66592, M66592_PIPE0, M66592_CURPIPE,
860 M66592_CFIFOSEL);
861
862 ep = &m66592->ep[0];
863 req = list_entry(ep->queue.next, struct m66592_request, queue);
864 irq_packet_read(ep, req);
865 } else {
866 for (pipenum = 1; pipenum < M66592_MAX_NUM_PIPE; pipenum++) {
867 check = 1 << pipenum;
868 if ((status & check) && (enb & check)) {
869 m66592_write(m66592, ~check, M66592_BRDYSTS);
870 ep = m66592->pipenum2ep[pipenum];
871 req = list_entry(ep->queue.next,
872 struct m66592_request, queue);
873 if (ep->desc->bEndpointAddress & USB_DIR_IN)
874 irq_packet_write(ep, req);
875 else
876 irq_packet_read(ep, req);
877 }
878 }
879 }
880 }
881
882 static void irq_pipe_empty(struct m66592 *m66592, u16 status, u16 enb)
883 {
884 u16 tmp;
885 u16 check;
886 u16 pipenum;
887 struct m66592_ep *ep;
888 struct m66592_request *req;
889
890 if ((status & M66592_BEMP0) && (enb & M66592_BEMP0)) {
891 m66592_write(m66592, ~M66592_BEMP0, M66592_BEMPSTS);
892
893 ep = &m66592->ep[0];
894 req = list_entry(ep->queue.next, struct m66592_request, queue);
895 irq_ep0_write(ep, req);
896 } else {
897 for (pipenum = 1; pipenum < M66592_MAX_NUM_PIPE; pipenum++) {
898 check = 1 << pipenum;
899 if ((status & check) && (enb & check)) {
900 m66592_write(m66592, ~check, M66592_BEMPSTS);
901 tmp = control_reg_get(m66592, pipenum);
902 if ((tmp & M66592_INBUFM) == 0) {
903 disable_irq_empty(m66592, pipenum);
904 pipe_irq_disable(m66592, pipenum);
905 pipe_stop(m66592, pipenum);
906 ep = m66592->pipenum2ep[pipenum];
907 req = list_entry(ep->queue.next,
908 struct m66592_request,
909 queue);
910 if (!list_empty(&ep->queue))
911 transfer_complete(ep, req, 0);
912 }
913 }
914 }
915 }
916 }
917
918 static void get_status(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
919 __releases(m66592->lock)
920 __acquires(m66592->lock)
921 {
922 struct m66592_ep *ep;
923 u16 pid;
924 u16 status = 0;
925 u16 w_index = le16_to_cpu(ctrl->wIndex);
926
927 switch (ctrl->bRequestType & USB_RECIP_MASK) {
928 case USB_RECIP_DEVICE:
929 status = 1 << USB_DEVICE_SELF_POWERED;
930 break;
931 case USB_RECIP_INTERFACE:
932 status = 0;
933 break;
934 case USB_RECIP_ENDPOINT:
935 ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
936 pid = control_reg_get_pid(m66592, ep->pipenum);
937 if (pid == M66592_PID_STALL)
938 status = 1 << USB_ENDPOINT_HALT;
939 else
940 status = 0;
941 break;
942 default:
943 pipe_stall(m66592, 0);
944 return; /* exit */
945 }
946
947 m66592->ep0_data = cpu_to_le16(status);
948 m66592->ep0_req->buf = &m66592->ep0_data;
949 m66592->ep0_req->length = 2;
950 /* AV: what happens if we get called again before that gets through? */
951 spin_unlock(&m66592->lock);
952 m66592_queue(m66592->gadget.ep0, m66592->ep0_req, GFP_KERNEL);
953 spin_lock(&m66592->lock);
954 }
955
956 static void clear_feature(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
957 {
958 switch (ctrl->bRequestType & USB_RECIP_MASK) {
959 case USB_RECIP_DEVICE:
960 control_end(m66592, 1);
961 break;
962 case USB_RECIP_INTERFACE:
963 control_end(m66592, 1);
964 break;
965 case USB_RECIP_ENDPOINT: {
966 struct m66592_ep *ep;
967 struct m66592_request *req;
968 u16 w_index = le16_to_cpu(ctrl->wIndex);
969
970 ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
971 pipe_stop(m66592, ep->pipenum);
972 control_reg_sqclr(m66592, ep->pipenum);
973
974 control_end(m66592, 1);
975
976 req = list_entry(ep->queue.next,
977 struct m66592_request, queue);
978 if (ep->busy) {
979 ep->busy = 0;
980 if (list_empty(&ep->queue))
981 break;
982 start_packet(ep, req);
983 } else if (!list_empty(&ep->queue))
984 pipe_start(m66592, ep->pipenum);
985 }
986 break;
987 default:
988 pipe_stall(m66592, 0);
989 break;
990 }
991 }
992
993 static void set_feature(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
994 {
995
996 switch (ctrl->bRequestType & USB_RECIP_MASK) {
997 case USB_RECIP_DEVICE:
998 control_end(m66592, 1);
999 break;
1000 case USB_RECIP_INTERFACE:
1001 control_end(m66592, 1);
1002 break;
1003 case USB_RECIP_ENDPOINT: {
1004 struct m66592_ep *ep;
1005 u16 w_index = le16_to_cpu(ctrl->wIndex);
1006
1007 ep = m66592->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
1008 pipe_stall(m66592, ep->pipenum);
1009
1010 control_end(m66592, 1);
1011 }
1012 break;
1013 default:
1014 pipe_stall(m66592, 0);
1015 break;
1016 }
1017 }
1018
1019 /* if return value is true, call class driver's setup() */
1020 static int setup_packet(struct m66592 *m66592, struct usb_ctrlrequest *ctrl)
1021 {
1022 u16 *p = (u16 *)ctrl;
1023 unsigned long offset = M66592_USBREQ;
1024 int i, ret = 0;
1025
1026 /* read fifo */
1027 m66592_write(m66592, ~M66592_VALID, M66592_INTSTS0);
1028
1029 for (i = 0; i < 4; i++)
1030 p[i] = m66592_read(m66592, offset + i*2);
1031
1032 /* check request */
1033 if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
1034 switch (ctrl->bRequest) {
1035 case USB_REQ_GET_STATUS:
1036 get_status(m66592, ctrl);
1037 break;
1038 case USB_REQ_CLEAR_FEATURE:
1039 clear_feature(m66592, ctrl);
1040 break;
1041 case USB_REQ_SET_FEATURE:
1042 set_feature(m66592, ctrl);
1043 break;
1044 default:
1045 ret = 1;
1046 break;
1047 }
1048 } else
1049 ret = 1;
1050 return ret;
1051 }
1052
1053 static void m66592_update_usb_speed(struct m66592 *m66592)
1054 {
1055 u16 speed = get_usb_speed(m66592);
1056
1057 switch (speed) {
1058 case M66592_HSMODE:
1059 m66592->gadget.speed = USB_SPEED_HIGH;
1060 break;
1061 case M66592_FSMODE:
1062 m66592->gadget.speed = USB_SPEED_FULL;
1063 break;
1064 default:
1065 m66592->gadget.speed = USB_SPEED_UNKNOWN;
1066 printk(KERN_ERR "USB speed unknown\n");
1067 }
1068 }
1069
1070 static void irq_device_state(struct m66592 *m66592)
1071 {
1072 u16 dvsq;
1073
1074 dvsq = m66592_read(m66592, M66592_INTSTS0) & M66592_DVSQ;
1075 m66592_write(m66592, ~M66592_DVST, M66592_INTSTS0);
1076
1077 if (dvsq == M66592_DS_DFLT) { /* bus reset */
1078 m66592->driver->disconnect(&m66592->gadget);
1079 m66592_update_usb_speed(m66592);
1080 }
1081 if (m66592->old_dvsq == M66592_DS_CNFG && dvsq != M66592_DS_CNFG)
1082 m66592_update_usb_speed(m66592);
1083 if ((dvsq == M66592_DS_CNFG || dvsq == M66592_DS_ADDS)
1084 && m66592->gadget.speed == USB_SPEED_UNKNOWN)
1085 m66592_update_usb_speed(m66592);
1086
1087 m66592->old_dvsq = dvsq;
1088 }
1089
1090 static void irq_control_stage(struct m66592 *m66592)
1091 __releases(m66592->lock)
1092 __acquires(m66592->lock)
1093 {
1094 struct usb_ctrlrequest ctrl;
1095 u16 ctsq;
1096
1097 ctsq = m66592_read(m66592, M66592_INTSTS0) & M66592_CTSQ;
1098 m66592_write(m66592, ~M66592_CTRT, M66592_INTSTS0);
1099
1100 switch (ctsq) {
1101 case M66592_CS_IDST: {
1102 struct m66592_ep *ep;
1103 struct m66592_request *req;
1104 ep = &m66592->ep[0];
1105 req = list_entry(ep->queue.next, struct m66592_request, queue);
1106 transfer_complete(ep, req, 0);
1107 }
1108 break;
1109
1110 case M66592_CS_RDDS:
1111 case M66592_CS_WRDS:
1112 case M66592_CS_WRND:
1113 if (setup_packet(m66592, &ctrl)) {
1114 spin_unlock(&m66592->lock);
1115 if (m66592->driver->setup(&m66592->gadget, &ctrl) < 0)
1116 pipe_stall(m66592, 0);
1117 spin_lock(&m66592->lock);
1118 }
1119 break;
1120 case M66592_CS_RDSS:
1121 case M66592_CS_WRSS:
1122 control_end(m66592, 0);
1123 break;
1124 default:
1125 printk(KERN_ERR "ctrl_stage: unexpect ctsq(%x)\n", ctsq);
1126 break;
1127 }
1128 }
1129
1130 static irqreturn_t m66592_irq(int irq, void *_m66592)
1131 {
1132 struct m66592 *m66592 = _m66592;
1133 u16 intsts0;
1134 u16 intenb0;
1135 u16 brdysts, nrdysts, bempsts;
1136 u16 brdyenb, nrdyenb, bempenb;
1137 u16 savepipe;
1138 u16 mask0;
1139
1140 spin_lock(&m66592->lock);
1141
1142 intsts0 = m66592_read(m66592, M66592_INTSTS0);
1143 intenb0 = m66592_read(m66592, M66592_INTENB0);
1144
1145 savepipe = m66592_read(m66592, M66592_CFIFOSEL);
1146
1147 mask0 = intsts0 & intenb0;
1148 if (mask0) {
1149 brdysts = m66592_read(m66592, M66592_BRDYSTS);
1150 nrdysts = m66592_read(m66592, M66592_NRDYSTS);
1151 bempsts = m66592_read(m66592, M66592_BEMPSTS);
1152 brdyenb = m66592_read(m66592, M66592_BRDYENB);
1153 nrdyenb = m66592_read(m66592, M66592_NRDYENB);
1154 bempenb = m66592_read(m66592, M66592_BEMPENB);
1155
1156 if (mask0 & M66592_VBINT) {
1157 m66592_write(m66592, 0xffff & ~M66592_VBINT,
1158 M66592_INTSTS0);
1159 m66592_start_xclock(m66592);
1160
1161 /* start vbus sampling */
1162 m66592->old_vbus = m66592_read(m66592, M66592_INTSTS0)
1163 & M66592_VBSTS;
1164 m66592->scount = M66592_MAX_SAMPLING;
1165
1166 mod_timer(&m66592->timer,
1167 jiffies + msecs_to_jiffies(50));
1168 }
1169 if (intsts0 & M66592_DVSQ)
1170 irq_device_state(m66592);
1171
1172 if ((intsts0 & M66592_BRDY) && (intenb0 & M66592_BRDYE)
1173 && (brdysts & brdyenb)) {
1174 irq_pipe_ready(m66592, brdysts, brdyenb);
1175 }
1176 if ((intsts0 & M66592_BEMP) && (intenb0 & M66592_BEMPE)
1177 && (bempsts & bempenb)) {
1178 irq_pipe_empty(m66592, bempsts, bempenb);
1179 }
1180
1181 if (intsts0 & M66592_CTRT)
1182 irq_control_stage(m66592);
1183 }
1184
1185 m66592_write(m66592, savepipe, M66592_CFIFOSEL);
1186
1187 spin_unlock(&m66592->lock);
1188 return IRQ_HANDLED;
1189 }
1190
1191 static void m66592_timer(unsigned long _m66592)
1192 {
1193 struct m66592 *m66592 = (struct m66592 *)_m66592;
1194 unsigned long flags;
1195 u16 tmp;
1196
1197 spin_lock_irqsave(&m66592->lock, flags);
1198 tmp = m66592_read(m66592, M66592_SYSCFG);
1199 if (!(tmp & M66592_RCKE)) {
1200 m66592_bset(m66592, M66592_RCKE | M66592_PLLC, M66592_SYSCFG);
1201 udelay(10);
1202 m66592_bset(m66592, M66592_SCKE, M66592_SYSCFG);
1203 }
1204 if (m66592->scount > 0) {
1205 tmp = m66592_read(m66592, M66592_INTSTS0) & M66592_VBSTS;
1206 if (tmp == m66592->old_vbus) {
1207 m66592->scount--;
1208 if (m66592->scount == 0) {
1209 if (tmp == M66592_VBSTS)
1210 m66592_usb_connect(m66592);
1211 else
1212 m66592_usb_disconnect(m66592);
1213 } else {
1214 mod_timer(&m66592->timer,
1215 jiffies + msecs_to_jiffies(50));
1216 }
1217 } else {
1218 m66592->scount = M66592_MAX_SAMPLING;
1219 m66592->old_vbus = tmp;
1220 mod_timer(&m66592->timer,
1221 jiffies + msecs_to_jiffies(50));
1222 }
1223 }
1224 spin_unlock_irqrestore(&m66592->lock, flags);
1225 }
1226
1227 /*-------------------------------------------------------------------------*/
1228 static int m66592_enable(struct usb_ep *_ep,
1229 const struct usb_endpoint_descriptor *desc)
1230 {
1231 struct m66592_ep *ep;
1232
1233 ep = container_of(_ep, struct m66592_ep, ep);
1234 return alloc_pipe_config(ep, desc);
1235 }
1236
1237 static int m66592_disable(struct usb_ep *_ep)
1238 {
1239 struct m66592_ep *ep;
1240 struct m66592_request *req;
1241 unsigned long flags;
1242
1243 ep = container_of(_ep, struct m66592_ep, ep);
1244 BUG_ON(!ep);
1245
1246 while (!list_empty(&ep->queue)) {
1247 req = list_entry(ep->queue.next, struct m66592_request, queue);
1248 spin_lock_irqsave(&ep->m66592->lock, flags);
1249 transfer_complete(ep, req, -ECONNRESET);
1250 spin_unlock_irqrestore(&ep->m66592->lock, flags);
1251 }
1252
1253 pipe_irq_disable(ep->m66592, ep->pipenum);
1254 return free_pipe_config(ep);
1255 }
1256
1257 static struct usb_request *m66592_alloc_request(struct usb_ep *_ep,
1258 gfp_t gfp_flags)
1259 {
1260 struct m66592_request *req;
1261
1262 req = kzalloc(sizeof(struct m66592_request), gfp_flags);
1263 if (!req)
1264 return NULL;
1265
1266 INIT_LIST_HEAD(&req->queue);
1267
1268 return &req->req;
1269 }
1270
1271 static void m66592_free_request(struct usb_ep *_ep, struct usb_request *_req)
1272 {
1273 struct m66592_request *req;
1274
1275 req = container_of(_req, struct m66592_request, req);
1276 kfree(req);
1277 }
1278
1279 static int m66592_queue(struct usb_ep *_ep, struct usb_request *_req,
1280 gfp_t gfp_flags)
1281 {
1282 struct m66592_ep *ep;
1283 struct m66592_request *req;
1284 unsigned long flags;
1285 int request = 0;
1286
1287 ep = container_of(_ep, struct m66592_ep, ep);
1288 req = container_of(_req, struct m66592_request, req);
1289
1290 if (ep->m66592->gadget.speed == USB_SPEED_UNKNOWN)
1291 return -ESHUTDOWN;
1292
1293 spin_lock_irqsave(&ep->m66592->lock, flags);
1294
1295 if (list_empty(&ep->queue))
1296 request = 1;
1297
1298 list_add_tail(&req->queue, &ep->queue);
1299 req->req.actual = 0;
1300 req->req.status = -EINPROGRESS;
1301
1302 if (ep->desc == NULL) /* control */
1303 start_ep0(ep, req);
1304 else {
1305 if (request && !ep->busy)
1306 start_packet(ep, req);
1307 }
1308
1309 spin_unlock_irqrestore(&ep->m66592->lock, flags);
1310
1311 return 0;
1312 }
1313
1314 static int m66592_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1315 {
1316 struct m66592_ep *ep;
1317 struct m66592_request *req;
1318 unsigned long flags;
1319
1320 ep = container_of(_ep, struct m66592_ep, ep);
1321 req = container_of(_req, struct m66592_request, req);
1322
1323 spin_lock_irqsave(&ep->m66592->lock, flags);
1324 if (!list_empty(&ep->queue))
1325 transfer_complete(ep, req, -ECONNRESET);
1326 spin_unlock_irqrestore(&ep->m66592->lock, flags);
1327
1328 return 0;
1329 }
1330
1331 static int m66592_set_halt(struct usb_ep *_ep, int value)
1332 {
1333 struct m66592_ep *ep;
1334 struct m66592_request *req;
1335 unsigned long flags;
1336 int ret = 0;
1337
1338 ep = container_of(_ep, struct m66592_ep, ep);
1339 req = list_entry(ep->queue.next, struct m66592_request, queue);
1340
1341 spin_lock_irqsave(&ep->m66592->lock, flags);
1342 if (!list_empty(&ep->queue)) {
1343 ret = -EAGAIN;
1344 goto out;
1345 }
1346 if (value) {
1347 ep->busy = 1;
1348 pipe_stall(ep->m66592, ep->pipenum);
1349 } else {
1350 ep->busy = 0;
1351 pipe_stop(ep->m66592, ep->pipenum);
1352 }
1353
1354 out:
1355 spin_unlock_irqrestore(&ep->m66592->lock, flags);
1356 return ret;
1357 }
1358
1359 static void m66592_fifo_flush(struct usb_ep *_ep)
1360 {
1361 struct m66592_ep *ep;
1362 unsigned long flags;
1363
1364 ep = container_of(_ep, struct m66592_ep, ep);
1365 spin_lock_irqsave(&ep->m66592->lock, flags);
1366 if (list_empty(&ep->queue) && !ep->busy) {
1367 pipe_stop(ep->m66592, ep->pipenum);
1368 m66592_bclr(ep->m66592, M66592_BCLR, ep->fifoctr);
1369 }
1370 spin_unlock_irqrestore(&ep->m66592->lock, flags);
1371 }
1372
1373 static struct usb_ep_ops m66592_ep_ops = {
1374 .enable = m66592_enable,
1375 .disable = m66592_disable,
1376
1377 .alloc_request = m66592_alloc_request,
1378 .free_request = m66592_free_request,
1379
1380 .queue = m66592_queue,
1381 .dequeue = m66592_dequeue,
1382
1383 .set_halt = m66592_set_halt,
1384 .fifo_flush = m66592_fifo_flush,
1385 };
1386
1387 /*-------------------------------------------------------------------------*/
1388 static struct m66592 *the_controller;
1389
1390 int usb_gadget_register_driver(struct usb_gadget_driver *driver)
1391 {
1392 struct m66592 *m66592 = the_controller;
1393 int retval;
1394
1395 if (!driver
1396 || driver->speed != USB_SPEED_HIGH
1397 || !driver->bind
1398 || !driver->setup)
1399 return -EINVAL;
1400 if (!m66592)
1401 return -ENODEV;
1402 if (m66592->driver)
1403 return -EBUSY;
1404
1405 /* hook up the driver */
1406 driver->driver.bus = NULL;
1407 m66592->driver = driver;
1408 m66592->gadget.dev.driver = &driver->driver;
1409
1410 retval = device_add(&m66592->gadget.dev);
1411 if (retval) {
1412 printk(KERN_ERR "device_add error (%d)\n", retval);
1413 goto error;
1414 }
1415
1416 retval = driver->bind (&m66592->gadget);
1417 if (retval) {
1418 printk(KERN_ERR "bind to driver error (%d)\n", retval);
1419 device_del(&m66592->gadget.dev);
1420 goto error;
1421 }
1422
1423 m66592_bset(m66592, M66592_VBSE | M66592_URST, M66592_INTENB0);
1424 if (m66592_read(m66592, M66592_INTSTS0) & M66592_VBSTS) {
1425 m66592_start_xclock(m66592);
1426 /* start vbus sampling */
1427 m66592->old_vbus = m66592_read(m66592,
1428 M66592_INTSTS0) & M66592_VBSTS;
1429 m66592->scount = M66592_MAX_SAMPLING;
1430 mod_timer(&m66592->timer, jiffies + msecs_to_jiffies(50));
1431 }
1432
1433 return 0;
1434
1435 error:
1436 m66592->driver = NULL;
1437 m66592->gadget.dev.driver = NULL;
1438
1439 return retval;
1440 }
1441 EXPORT_SYMBOL(usb_gadget_register_driver);
1442
1443 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
1444 {
1445 struct m66592 *m66592 = the_controller;
1446 unsigned long flags;
1447
1448 if (driver != m66592->driver || !driver->unbind)
1449 return -EINVAL;
1450
1451 spin_lock_irqsave(&m66592->lock, flags);
1452 if (m66592->gadget.speed != USB_SPEED_UNKNOWN)
1453 m66592_usb_disconnect(m66592);
1454 spin_unlock_irqrestore(&m66592->lock, flags);
1455
1456 m66592_bclr(m66592, M66592_VBSE | M66592_URST, M66592_INTENB0);
1457
1458 driver->unbind(&m66592->gadget);
1459
1460 init_controller(m66592);
1461 disable_controller(m66592);
1462
1463 device_del(&m66592->gadget.dev);
1464 m66592->driver = NULL;
1465 return 0;
1466 }
1467 EXPORT_SYMBOL(usb_gadget_unregister_driver);
1468
1469 /*-------------------------------------------------------------------------*/
1470 static int m66592_get_frame(struct usb_gadget *_gadget)
1471 {
1472 struct m66592 *m66592 = gadget_to_m66592(_gadget);
1473 return m66592_read(m66592, M66592_FRMNUM) & 0x03FF;
1474 }
1475
1476 static struct usb_gadget_ops m66592_gadget_ops = {
1477 .get_frame = m66592_get_frame,
1478 };
1479
1480 static int __exit m66592_remove(struct platform_device *pdev)
1481 {
1482 struct m66592 *m66592 = dev_get_drvdata(&pdev->dev);
1483
1484 del_timer_sync(&m66592->timer);
1485 iounmap(m66592->reg);
1486 free_irq(platform_get_irq(pdev, 0), m66592);
1487 m66592_free_request(&m66592->ep[0].ep, m66592->ep0_req);
1488 kfree(m66592);
1489 return 0;
1490 }
1491
1492 static void nop_completion(struct usb_ep *ep, struct usb_request *r)
1493 {
1494 }
1495
1496 #define resource_len(r) (((r)->end - (r)->start) + 1)
1497
1498 static int __init m66592_probe(struct platform_device *pdev)
1499 {
1500 struct resource *res;
1501 int irq;
1502 void __iomem *reg = NULL;
1503 struct m66592 *m66592 = NULL;
1504 int ret = 0;
1505 int i;
1506
1507 res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
1508 (char *)udc_name);
1509 if (!res) {
1510 ret = -ENODEV;
1511 printk(KERN_ERR "platform_get_resource_byname error.\n");
1512 goto clean_up;
1513 }
1514
1515 irq = platform_get_irq(pdev, 0);
1516 if (irq < 0) {
1517 ret = -ENODEV;
1518 printk(KERN_ERR "platform_get_irq error.\n");
1519 goto clean_up;
1520 }
1521
1522 reg = ioremap(res->start, resource_len(res));
1523 if (reg == NULL) {
1524 ret = -ENOMEM;
1525 printk(KERN_ERR "ioremap error.\n");
1526 goto clean_up;
1527 }
1528
1529 /* initialize ucd */
1530 m66592 = kzalloc(sizeof(struct m66592), GFP_KERNEL);
1531 if (m66592 == NULL) {
1532 printk(KERN_ERR "kzalloc error\n");
1533 goto clean_up;
1534 }
1535
1536 spin_lock_init(&m66592->lock);
1537 dev_set_drvdata(&pdev->dev, m66592);
1538
1539 m66592->gadget.ops = &m66592_gadget_ops;
1540 device_initialize(&m66592->gadget.dev);
1541 strcpy(m66592->gadget.dev.bus_id, "gadget");
1542 m66592->gadget.is_dualspeed = 1;
1543 m66592->gadget.dev.parent = &pdev->dev;
1544 m66592->gadget.dev.dma_mask = pdev->dev.dma_mask;
1545 m66592->gadget.dev.release = pdev->dev.release;
1546 m66592->gadget.name = udc_name;
1547
1548 init_timer(&m66592->timer);
1549 m66592->timer.function = m66592_timer;
1550 m66592->timer.data = (unsigned long)m66592;
1551 m66592->reg = reg;
1552
1553 m66592->bi_bufnum = M66592_BASE_BUFNUM;
1554
1555 ret = request_irq(irq, m66592_irq, IRQF_DISABLED | IRQF_SHARED,
1556 udc_name, m66592);
1557 if (ret < 0) {
1558 printk(KERN_ERR "request_irq error (%d)\n", ret);
1559 goto clean_up;
1560 }
1561
1562 INIT_LIST_HEAD(&m66592->gadget.ep_list);
1563 m66592->gadget.ep0 = &m66592->ep[0].ep;
1564 INIT_LIST_HEAD(&m66592->gadget.ep0->ep_list);
1565 for (i = 0; i < M66592_MAX_NUM_PIPE; i++) {
1566 struct m66592_ep *ep = &m66592->ep[i];
1567
1568 if (i != 0) {
1569 INIT_LIST_HEAD(&m66592->ep[i].ep.ep_list);
1570 list_add_tail(&m66592->ep[i].ep.ep_list,
1571 &m66592->gadget.ep_list);
1572 }
1573 ep->m66592 = m66592;
1574 INIT_LIST_HEAD(&ep->queue);
1575 ep->ep.name = m66592_ep_name[i];
1576 ep->ep.ops = &m66592_ep_ops;
1577 ep->ep.maxpacket = 512;
1578 }
1579 m66592->ep[0].ep.maxpacket = 64;
1580 m66592->ep[0].pipenum = 0;
1581 m66592->ep[0].fifoaddr = M66592_CFIFO;
1582 m66592->ep[0].fifosel = M66592_CFIFOSEL;
1583 m66592->ep[0].fifoctr = M66592_CFIFOCTR;
1584 m66592->ep[0].fifotrn = 0;
1585 m66592->ep[0].pipectr = get_pipectr_addr(0);
1586 m66592->pipenum2ep[0] = &m66592->ep[0];
1587 m66592->epaddr2ep[0] = &m66592->ep[0];
1588
1589 the_controller = m66592;
1590
1591 m66592->ep0_req = m66592_alloc_request(&m66592->ep[0].ep, GFP_KERNEL);
1592 if (m66592->ep0_req == NULL)
1593 goto clean_up2;
1594 m66592->ep0_req->complete = nop_completion;
1595
1596 init_controller(m66592);
1597
1598 dev_info(&pdev->dev, "version %s\n", DRIVER_VERSION);
1599 return 0;
1600
1601 clean_up2:
1602 free_irq(irq, m66592);
1603 clean_up:
1604 if (m66592) {
1605 if (m66592->ep0_req)
1606 m66592_free_request(&m66592->ep[0].ep, m66592->ep0_req);
1607 kfree(m66592);
1608 }
1609 if (reg)
1610 iounmap(reg);
1611
1612 return ret;
1613 }
1614
1615 /*-------------------------------------------------------------------------*/
1616 static struct platform_driver m66592_driver = {
1617 .remove = __exit_p(m66592_remove),
1618 .driver = {
1619 .name = (char *) udc_name,
1620 },
1621 };
1622
1623 static int __init m66592_udc_init(void)
1624 {
1625 return platform_driver_probe(&m66592_driver, m66592_probe);
1626 }
1627 module_init(m66592_udc_init);
1628
1629 static void __exit m66592_udc_cleanup(void)
1630 {
1631 platform_driver_unregister(&m66592_driver);
1632 }
1633 module_exit(m66592_udc_cleanup);
Mirror for ia64_pv_ops.git