Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / drivers / usb / gadget / m66592-udc.c
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);