drivers/usb/host/r8a66597-hcd.c

   1 /*
   2  * R8A66597 HCD (Host Controller Driver)
   3  *
   4  * Copyright (C) 2006-2007 Renesas Solutions Corp.
   5  * Portions Copyright (C) 2004 Psion Teklogix (for NetBook PRO)
   6  * Portions Copyright (C) 2004-2005 David Brownell
   7  * Portions Copyright (C) 1999 Roman Weissgaerber
   8  *
   9  * Author : Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; version 2 of the License.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/kernel.h>
  28 #include <linux/sched.h>
  29 #include <linux/errno.h>
  30 #include <linux/timer.h>
  31 #include <linux/delay.h>
  32 #include <linux/list.h>
  33 #include <linux/interrupt.h>
  34 #include <linux/usb.h>
  35 #include <linux/usb/hcd.h>
  36 #include <linux/platform_device.h>
  37 #include <linux/io.h>
  38 #include <linux/mm.h>
  39 #include <linux/irq.h>
  40 #include <linux/slab.h>
  41 #include <asm/cacheflush.h>
  42
  43 #include "r8a66597.h"
  44
  45 MODULE_DESCRIPTION("R8A66597 USB Host Controller Driver");
  46 MODULE_LICENSE("GPL");
  47 MODULE_AUTHOR("Yoshihiro Shimoda");
  48 MODULE_ALIAS("platform:r8a66597_hcd");
  49
  50 #define DRIVER_VERSION  "2009-05-26"
  51
  52 static const char hcd_name[] = "r8a66597_hcd";
  53
  54 static void packet_write(struct r8a66597 *r8a66597, u16 pipenum);
  55 static int r8a66597_get_frame(struct usb_hcd *hcd);
  56
  57 /* this function must be called with interrupt disabled */
  58 static void enable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
  59                             unsigned long reg)
  60 {
  61         u16 tmp;
  62
  63         tmp = r8a66597_read(r8a66597, INTENB0);
  64         r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
  65         r8a66597_bset(r8a66597, 1 << pipenum, reg);
  66         r8a66597_write(r8a66597, tmp, INTENB0);
  67 }
  68
  69 /* this function must be called with interrupt disabled */
  70 static void disable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
  71                              unsigned long reg)
  72 {
  73         u16 tmp;
  74
  75         tmp = r8a66597_read(r8a66597, INTENB0);
  76         r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
  77         r8a66597_bclr(r8a66597, 1 << pipenum, reg);
  78         r8a66597_write(r8a66597, tmp, INTENB0);
  79 }
  80
  81 static void set_devadd_reg(struct r8a66597 *r8a66597, u8 r8a66597_address,
  82                            u16 usbspd, u8 upphub, u8 hubport, int port)
  83 {
  84         u16 val;
  85         unsigned long devadd_reg = get_devadd_addr(r8a66597_address);
  86
  87         val = (upphub << 11) | (hubport << 8) | (usbspd << 6) | (port & 0x0001);
  88         r8a66597_write(r8a66597, val, devadd_reg);
  89 }
  90
  91 static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
  92 {
  93         u16 tmp;
  94         int i = 0;
  95
  96         if (r8a66597->pdata->on_chip) {
  97                 clk_prepare_enable(r8a66597->clk);
  98                 do {
  99                         r8a66597_write(r8a66597, SCKE, SYSCFG0);
 100                         tmp = r8a66597_read(r8a66597, SYSCFG0);
 101                         if (i++ > 1000) {
 102                                 printk(KERN_ERR "r8a66597: reg access fail.\n");
 103                                 return -ENXIO;
 104                         }
 105                 } while ((tmp & SCKE) != SCKE);
 106                 r8a66597_write(r8a66597, 0x04, 0x02);
 107         } else {
 108                 do {
 109                         r8a66597_write(r8a66597, USBE, SYSCFG0);
 110                         tmp = r8a66597_read(r8a66597, SYSCFG0);
 111                         if (i++ > 1000) {
 112                                 printk(KERN_ERR "r8a66597: reg access fail.\n");
 113                                 return -ENXIO;
 114                         }
 115                 } while ((tmp & USBE) != USBE);
 116                 r8a66597_bclr(r8a66597, USBE, SYSCFG0);
 117                 r8a66597_mdfy(r8a66597, get_xtal_from_pdata(r8a66597->pdata),
 118                               XTAL, SYSCFG0);
 119
 120                 i = 0;
 121                 r8a66597_bset(r8a66597, XCKE, SYSCFG0);
 122                 do {
 123                         msleep(1);
 124                         tmp = r8a66597_read(r8a66597, SYSCFG0);
 125                         if (i++ > 500) {
 126                                 printk(KERN_ERR "r8a66597: reg access fail.\n");
 127                                 return -ENXIO;
 128                         }
 129                 } while ((tmp & SCKE) != SCKE);
 130         }
 131
 132         return 0;
 133 }
 134
 135 static void r8a66597_clock_disable(struct r8a66597 *r8a66597)
 136 {
 137         r8a66597_bclr(r8a66597, SCKE, SYSCFG0);
 138         udelay(1);
 139
 140         if (r8a66597->pdata->on_chip) {
 141                 clk_disable_unprepare(r8a66597->clk);
 142         } else {
 143                 r8a66597_bclr(r8a66597, PLLC, SYSCFG0);
 144                 r8a66597_bclr(r8a66597, XCKE, SYSCFG0);
 145                 r8a66597_bclr(r8a66597, USBE, SYSCFG0);
 146         }
 147 }
 148
 149 static void r8a66597_enable_port(struct r8a66597 *r8a66597, int port)
 150 {
 151         u16 val;
 152
 153         val = port ? DRPD : DCFM | DRPD;
 154         r8a66597_bset(r8a66597, val, get_syscfg_reg(port));
 155         r8a66597_bset(r8a66597, HSE, get_syscfg_reg(port));
 156
 157         r8a66597_write(r8a66597, BURST | CPU_ADR_RD_WR, get_dmacfg_reg(port));
 158         r8a66597_bclr(r8a66597, DTCHE, get_intenb_reg(port));
 159         r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
 160 }
 161
 162 static void r8a66597_disable_port(struct r8a66597 *r8a66597, int port)
 163 {
 164         u16 val, tmp;
 165
 166         r8a66597_write(r8a66597, 0, get_intenb_reg(port));
 167         r8a66597_write(r8a66597, 0, get_intsts_reg(port));
 168
 169         r8a66597_port_power(r8a66597, port, 0);
 170
 171         do {
 172                 tmp = r8a66597_read(r8a66597, SOFCFG) & EDGESTS;
 173                 udelay(640);
 174         } while (tmp == EDGESTS);
 175
 176         val = port ? DRPD : DCFM | DRPD;
 177         r8a66597_bclr(r8a66597, val, get_syscfg_reg(port));
 178         r8a66597_bclr(r8a66597, HSE, get_syscfg_reg(port));
 179 }
 180
 181 static int enable_controller(struct r8a66597 *r8a66597)
 182 {
 183         int ret, port;
 184         u16 vif = r8a66597->pdata->vif ? LDRV : 0;
 185         u16 irq_sense = r8a66597->irq_sense_low ? INTL : 0;
 186         u16 endian = r8a66597->pdata->endian ? BIGEND : 0;
 187
 188         ret = r8a66597_clock_enable(r8a66597);
 189         if (ret < 0)
 190                 return ret;
 191
 192         r8a66597_bset(r8a66597, vif & LDRV, PINCFG);
 193         r8a66597_bset(r8a66597, USBE, SYSCFG0);
 194
 195         r8a66597_bset(r8a66597, BEMPE | NRDYE | BRDYE, INTENB0);
 196         r8a66597_bset(r8a66597, irq_sense & INTL, SOFCFG);
 197         r8a66597_bset(r8a66597, BRDY0, BRDYENB);
 198         r8a66597_bset(r8a66597, BEMP0, BEMPENB);
 199
 200         r8a66597_bset(r8a66597, endian & BIGEND, CFIFOSEL);
 201         r8a66597_bset(r8a66597, endian & BIGEND, D0FIFOSEL);
 202         r8a66597_bset(r8a66597, endian & BIGEND, D1FIFOSEL);
 203         r8a66597_bset(r8a66597, TRNENSEL, SOFCFG);
 204
 205         r8a66597_bset(r8a66597, SIGNE | SACKE, INTENB1);
 206
 207         for (port = 0; port < r8a66597->max_root_hub; port++)
 208                 r8a66597_enable_port(r8a66597, port);
 209
 210         return 0;
 211 }
 212
 213 static void disable_controller(struct r8a66597 *r8a66597)
 214 {
 215         int port;
 216
 217         /* disable interrupts */
 218         r8a66597_write(r8a66597, 0, INTENB0);
 219         r8a66597_write(r8a66597, 0, INTENB1);
 220         r8a66597_write(r8a66597, 0, BRDYENB);
 221         r8a66597_write(r8a66597, 0, BEMPENB);
 222         r8a66597_write(r8a66597, 0, NRDYENB);
 223
 224         /* clear status */
 225         r8a66597_write(r8a66597, 0, BRDYSTS);
 226         r8a66597_write(r8a66597, 0, NRDYSTS);
 227         r8a66597_write(r8a66597, 0, BEMPSTS);
 228
 229         for (port = 0; port < r8a66597->max_root_hub; port++)
 230                 r8a66597_disable_port(r8a66597, port);
 231
 232         r8a66597_clock_disable(r8a66597);
 233 }
 234
 235 static int get_parent_r8a66597_address(struct r8a66597 *r8a66597,
 236                                        struct usb_device *udev)
 237 {
 238         struct r8a66597_device *dev;
 239
 240         if (udev->parent && udev->parent->devnum != 1)
 241                 udev = udev->parent;
 242
 243         dev = dev_get_drvdata(&udev->dev);
 244         if (dev)
 245                 return dev->address;
 246         else
 247                 return 0;
 248 }
 249
 250 static int is_child_device(char *devpath)
 251 {
 252         return (devpath[2] ? 1 : 0);
 253 }
 254
 255 static int is_hub_limit(char *devpath)
 256 {
 257         return ((strlen(devpath) >= 4) ? 1 : 0);
 258 }
 259
 260 static void get_port_number(struct r8a66597 *r8a66597,
 261                             char *devpath, u16 *root_port, u16 *hub_port)
 262 {
 263         if (root_port) {
 264                 *root_port = (devpath[0] & 0x0F) - 1;
 265                 if (*root_port >= r8a66597->max_root_hub)
 266                         printk(KERN_ERR "r8a66597: Illegal root port number.\n");
 267         }
 268         if (hub_port)
 269                 *hub_port = devpath[2] & 0x0F;
 270 }
 271
 272 static u16 get_r8a66597_usb_speed(enum usb_device_speed speed)
 273 {
 274         u16 usbspd = 0;
 275
 276         switch (speed) {
 277         case USB_SPEED_LOW:
 278                 usbspd = LSMODE;
 279                 break;
 280         case USB_SPEED_FULL:
 281                 usbspd = FSMODE;
 282                 break;
 283         case USB_SPEED_HIGH:
 284                 usbspd = HSMODE;
 285                 break;
 286         default:
 287                 printk(KERN_ERR "r8a66597: unknown speed\n");
 288                 break;
 289         }
 290
 291         return usbspd;
 292 }
 293
 294 static void set_child_connect_map(struct r8a66597 *r8a66597, int address)
 295 {
 296         int idx;
 297
 298         idx = address / 32;
 299         r8a66597->child_connect_map[idx] |= 1 << (address % 32);
 300 }
 301
 302 static void put_child_connect_map(struct r8a66597 *r8a66597, int address)
 303 {
 304         int idx;
 305
 306         idx = address / 32;
 307         r8a66597->child_connect_map[idx] &= ~(1 << (address % 32));
 308 }
 309
 310 static void set_pipe_reg_addr(struct r8a66597_pipe *pipe, u8 dma_ch)
 311 {
 312         u16 pipenum = pipe->info.pipenum;
 313         const unsigned long fifoaddr[] = {D0FIFO, D1FIFO, CFIFO};
 314         const unsigned long fifosel[] = {D0FIFOSEL, D1FIFOSEL, CFIFOSEL};
 315         const unsigned long fifoctr[] = {D0FIFOCTR, D1FIFOCTR, CFIFOCTR};
 316
 317         if (dma_ch > R8A66597_PIPE_NO_DMA)      /* dma fifo not use? */
 318                 dma_ch = R8A66597_PIPE_NO_DMA;
 319
 320         pipe->fifoaddr = fifoaddr[dma_ch];
 321         pipe->fifosel = fifosel[dma_ch];
 322         pipe->fifoctr = fifoctr[dma_ch];
 323
 324         if (pipenum == 0)
 325                 pipe->pipectr = DCPCTR;
 326         else
 327                 pipe->pipectr = get_pipectr_addr(pipenum);
 328
 329         if (check_bulk_or_isoc(pipenum)) {
 330                 pipe->pipetre = get_pipetre_addr(pipenum);
 331                 pipe->pipetrn = get_pipetrn_addr(pipenum);
 332         } else {
 333                 pipe->pipetre = 0;
 334                 pipe->pipetrn = 0;
 335         }
 336 }
 337
 338 static struct r8a66597_device *
 339 get_urb_to_r8a66597_dev(struct r8a66597 *r8a66597, struct urb *urb)
 340 {
 341         if (usb_pipedevice(urb->pipe) == 0)
 342                 return &r8a66597->device0;
 343
 344         return dev_get_drvdata(&urb->dev->dev);
 345 }
 346
 347 static int make_r8a66597_device(struct r8a66597 *r8a66597,
 348                                 struct urb *urb, u8 addr)
 349 {
 350         struct r8a66597_device *dev;
 351         int usb_address = urb->setup_packet[2]; /* urb->pipe is address 0 */
 352
 353         dev = kzalloc(sizeof(struct r8a66597_device), GFP_ATOMIC);
 354         if (dev == NULL)
 355                 return -ENOMEM;
 356
 357         dev_set_drvdata(&urb->dev->dev, dev);
 358         dev->udev = urb->dev;
 359         dev->address = addr;
 360         dev->usb_address = usb_address;
 361         dev->state = USB_STATE_ADDRESS;
 362         dev->ep_in_toggle = 0;
 363         dev->ep_out_toggle = 0;
 364         INIT_LIST_HEAD(&dev->device_list);
 365         list_add_tail(&dev->device_list, &r8a66597->child_device);
 366
 367         get_port_number(r8a66597, urb->dev->devpath,
 368                         &dev->root_port, &dev->hub_port);
 369         if (!is_child_device(urb->dev->devpath))
 370                 r8a66597->root_hub[dev->root_port].dev = dev;
 371
 372         set_devadd_reg(r8a66597, dev->address,
 373                        get_r8a66597_usb_speed(urb->dev->speed),
 374                        get_parent_r8a66597_address(r8a66597, urb->dev),
 375                        dev->hub_port, dev->root_port);
 376
 377         return 0;
 378 }
 379
 380 /* this function must be called with interrupt disabled */
 381 static u8 alloc_usb_address(struct r8a66597 *r8a66597, struct urb *urb)
 382 {
 383         u8 addr;        /* R8A66597's address */
 384         struct r8a66597_device *dev;
 385
 386         if (is_hub_limit(urb->dev->devpath)) {
 387                 dev_err(&urb->dev->dev, "External hub limit reached.\n");
 388                 return 0;
 389         }
 390
 391         dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 392         if (dev && dev->state >= USB_STATE_ADDRESS)
 393                 return dev->address;
 394
 395         for (addr = 1; addr <= R8A66597_MAX_DEVICE; addr++) {
 396                 if (r8a66597->address_map & (1 << addr))
 397                         continue;
 398
 399                 dev_dbg(&urb->dev->dev, "alloc_address: r8a66597_addr=%d\n", addr);
 400                 r8a66597->address_map |= 1 << addr;
 401
 402                 if (make_r8a66597_device(r8a66597, urb, addr) < 0)
 403                         return 0;
 404
 405                 return addr;
 406         }
 407
 408         dev_err(&urb->dev->dev,
 409                 "cannot communicate with a USB device more than 10.(%x)\n",
 410                 r8a66597->address_map);
 411
 412         return 0;
 413 }
 414
 415 /* this function must be called with interrupt disabled */
 416 static void free_usb_address(struct r8a66597 *r8a66597,
 417                              struct r8a66597_device *dev, int reset)
 418 {
 419         int port;
 420
 421         if (!dev)
 422                 return;
 423
 424         dev_dbg(&dev->udev->dev, "free_addr: addr=%d\n", dev->address);
 425
 426         dev->state = USB_STATE_DEFAULT;
 427         r8a66597->address_map &= ~(1 << dev->address);
 428         dev->address = 0;
 429         /*
 430          * Only when resetting USB, it is necessary to erase drvdata. When
 431          * a usb device with usb hub is disconnect, "dev->udev" is already
 432          * freed on usb_desconnect(). So we cannot access the data.
 433          */
 434         if (reset)
 435                 dev_set_drvdata(&dev->udev->dev, NULL);
 436         list_del(&dev->device_list);
 437         kfree(dev);
 438
 439         for (port = 0; port < r8a66597->max_root_hub; port++) {
 440                 if (r8a66597->root_hub[port].dev == dev) {
 441                         r8a66597->root_hub[port].dev = NULL;
 442                         break;
 443                 }
 444         }
 445 }
 446
 447 static void r8a66597_reg_wait(struct r8a66597 *r8a66597, unsigned long reg,
 448                               u16 mask, u16 loop)
 449 {
 450         u16 tmp;
 451         int i = 0;
 452
 453         do {
 454                 tmp = r8a66597_read(r8a66597, reg);
 455                 if (i++ > 1000000) {
 456                         printk(KERN_ERR "r8a66597: register%lx, loop %x "
 457                                "is timeout\n", reg, loop);
 458                         break;
 459                 }
 460                 ndelay(1);
 461         } while ((tmp & mask) != loop);
 462 }
 463
 464 /* this function must be called with interrupt disabled */
 465 static void pipe_start(struct r8a66597 *r8a66597, struct r8a66597_pipe *pipe)
 466 {
 467         u16 tmp;
 468
 469         tmp = r8a66597_read(r8a66597, pipe->pipectr) & PID;
 470         if ((pipe->info.pipenum != 0) & ((tmp & PID_STALL) != 0)) /* stall? */
 471                 r8a66597_mdfy(r8a66597, PID_NAK, PID, pipe->pipectr);
 472         r8a66597_mdfy(r8a66597, PID_BUF, PID, pipe->pipectr);
 473 }
 474
 475 /* this function must be called with interrupt disabled */
 476 static void pipe_stop(struct r8a66597 *r8a66597, struct r8a66597_pipe *pipe)
 477 {
 478         u16 tmp;
 479
 480         tmp = r8a66597_read(r8a66597, pipe->pipectr) & PID;
 481         if ((tmp & PID_STALL11) != PID_STALL11) /* force stall? */
 482                 r8a66597_mdfy(r8a66597, PID_STALL, PID, pipe->pipectr);
 483         r8a66597_mdfy(r8a66597, PID_NAK, PID, pipe->pipectr);
 484         r8a66597_reg_wait(r8a66597, pipe->pipectr, PBUSY, 0);
 485 }
 486
 487 /* this function must be called with interrupt disabled */
 488 static void clear_all_buffer(struct r8a66597 *r8a66597,
 489                              struct r8a66597_pipe *pipe)
 490 {
 491         u16 tmp;
 492
 493         if (!pipe || pipe->info.pipenum == 0)
 494                 return;
 495
 496         pipe_stop(r8a66597, pipe);
 497         r8a66597_bset(r8a66597, ACLRM, pipe->pipectr);
 498         tmp = r8a66597_read(r8a66597, pipe->pipectr);
 499         tmp = r8a66597_read(r8a66597, pipe->pipectr);
 500         tmp = r8a66597_read(r8a66597, pipe->pipectr);
 501         r8a66597_bclr(r8a66597, ACLRM, pipe->pipectr);
 502 }
 503
 504 /* this function must be called with interrupt disabled */
 505 static void r8a66597_pipe_toggle(struct r8a66597 *r8a66597,
 506                                  struct r8a66597_pipe *pipe, int toggle)
 507 {
 508         if (toggle)
 509                 r8a66597_bset(r8a66597, SQSET, pipe->pipectr);
 510         else
 511                 r8a66597_bset(r8a66597, SQCLR, pipe->pipectr);
 512 }
 513
 514 static inline unsigned short mbw_value(struct r8a66597 *r8a66597)
 515 {
 516         if (r8a66597->pdata->on_chip)
 517                 return MBW_32;
 518         else
 519                 return MBW_16;
 520 }
 521
 522 /* this function must be called with interrupt disabled */
 523 static inline void cfifo_change(struct r8a66597 *r8a66597, u16 pipenum)
 524 {
 525         unsigned short mbw = mbw_value(r8a66597);
 526
 527         r8a66597_mdfy(r8a66597, mbw | pipenum, mbw | CURPIPE, CFIFOSEL);
 528         r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, pipenum);
 529 }
 530
 531 /* this function must be called with interrupt disabled */
 532 static inline void fifo_change_from_pipe(struct r8a66597 *r8a66597,
 533                                          struct r8a66597_pipe *pipe)
 534 {
 535         unsigned short mbw = mbw_value(r8a66597);
 536
 537         cfifo_change(r8a66597, 0);
 538         r8a66597_mdfy(r8a66597, mbw | 0, mbw | CURPIPE, D0FIFOSEL);
 539         r8a66597_mdfy(r8a66597, mbw | 0, mbw | CURPIPE, D1FIFOSEL);
 540
 541         r8a66597_mdfy(r8a66597, mbw | pipe->info.pipenum, mbw | CURPIPE,
 542                       pipe->fifosel);
 543         r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE, pipe->info.pipenum);
 544 }
 545
 546 static u16 r8a66597_get_pipenum(struct urb *urb, struct usb_host_endpoint *hep)
 547 {
 548         struct r8a66597_pipe *pipe = hep->hcpriv;
 549
 550         if (usb_pipeendpoint(urb->pipe) == 0)
 551                 return 0;
 552         else
 553                 return pipe->info.pipenum;
 554 }
 555
 556 static u16 get_urb_to_r8a66597_addr(struct r8a66597 *r8a66597, struct urb *urb)
 557 {
 558         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 559
 560         return (usb_pipedevice(urb->pipe) == 0) ? 0 : dev->address;
 561 }
 562
 563 static unsigned short *get_toggle_pointer(struct r8a66597_device *dev,
 564                                           int urb_pipe)
 565 {
 566         if (!dev)
 567                 return NULL;
 568
 569         return usb_pipein(urb_pipe) ? &dev->ep_in_toggle : &dev->ep_out_toggle;
 570 }
 571
 572 /* this function must be called with interrupt disabled */
 573 static void pipe_toggle_set(struct r8a66597 *r8a66597,
 574                             struct r8a66597_pipe *pipe,
 575                             struct urb *urb, int set)
 576 {
 577         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 578         unsigned char endpoint = usb_pipeendpoint(urb->pipe);
 579         unsigned short *toggle = get_toggle_pointer(dev, urb->pipe);
 580
 581         if (!toggle)
 582                 return;
 583
 584         if (set)
 585                 *toggle |= 1 << endpoint;
 586         else
 587                 *toggle &= ~(1 << endpoint);
 588 }
 589
 590 /* this function must be called with interrupt disabled */
 591 static void pipe_toggle_save(struct r8a66597 *r8a66597,
 592                              struct r8a66597_pipe *pipe,
 593                              struct urb *urb)
 594 {
 595         if (r8a66597_read(r8a66597, pipe->pipectr) & SQMON)
 596                 pipe_toggle_set(r8a66597, pipe, urb, 1);
 597         else
 598                 pipe_toggle_set(r8a66597, pipe, urb, 0);
 599 }
 600
 601 /* this function must be called with interrupt disabled */
 602 static void pipe_toggle_restore(struct r8a66597 *r8a66597,
 603                                 struct r8a66597_pipe *pipe,
 604                                 struct urb *urb)
 605 {
 606         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 607         unsigned char endpoint = usb_pipeendpoint(urb->pipe);
 608         unsigned short *toggle = get_toggle_pointer(dev, urb->pipe);
 609
 610         if (!toggle)
 611                 return;
 612
 613         r8a66597_pipe_toggle(r8a66597, pipe, *toggle & (1 << endpoint));
 614 }
 615
 616 /* this function must be called with interrupt disabled */
 617 static void pipe_buffer_setting(struct r8a66597 *r8a66597,
 618                                 struct r8a66597_pipe_info *info)
 619 {
 620         u16 val = 0;
 621
 622         if (info->pipenum == 0)
 623                 return;
 624
 625         r8a66597_bset(r8a66597, ACLRM, get_pipectr_addr(info->pipenum));
 626         r8a66597_bclr(r8a66597, ACLRM, get_pipectr_addr(info->pipenum));
 627         r8a66597_write(r8a66597, info->pipenum, PIPESEL);
 628         if (!info->dir_in)
 629                 val |= R8A66597_DIR;
 630         if (info->type == R8A66597_BULK && info->dir_in)
 631                 val |= R8A66597_DBLB | R8A66597_SHTNAK;
 632         val |= info->type | info->epnum;
 633         r8a66597_write(r8a66597, val, PIPECFG);
 634
 635         r8a66597_write(r8a66597, (info->buf_bsize << 10) | (info->bufnum),
 636                        PIPEBUF);
 637         r8a66597_write(r8a66597, make_devsel(info->address) | info->maxpacket,
 638                        PIPEMAXP);
 639         r8a66597_write(r8a66597, info->interval, PIPEPERI);
 640 }
 641
 642 /* this function must be called with interrupt disabled */
 643 static void pipe_setting(struct r8a66597 *r8a66597, struct r8a66597_td *td)
 644 {
 645         struct r8a66597_pipe_info *info;
 646         struct urb *urb = td->urb;
 647
 648         if (td->pipenum > 0) {
 649                 info = &td->pipe->info;
 650                 cfifo_change(r8a66597, 0);
 651                 pipe_buffer_setting(r8a66597, info);
 652
 653                 if (!usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
 654                                    usb_pipeout(urb->pipe)) &&
 655                     !usb_pipecontrol(urb->pipe)) {
 656                         r8a66597_pipe_toggle(r8a66597, td->pipe, 0);
 657                         pipe_toggle_set(r8a66597, td->pipe, urb, 0);
 658                         clear_all_buffer(r8a66597, td->pipe);
 659                         usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
 660                                       usb_pipeout(urb->pipe), 1);
 661                 }
 662                 pipe_toggle_restore(r8a66597, td->pipe, urb);
 663         }
 664 }
 665
 666 /* this function must be called with interrupt disabled */
 667 static u16 get_empty_pipenum(struct r8a66597 *r8a66597,
 668                              struct usb_endpoint_descriptor *ep)
 669 {
 670         u16 array[R8A66597_MAX_NUM_PIPE], i = 0, min;
 671
 672         memset(array, 0, sizeof(array));
 673         switch (usb_endpoint_type(ep)) {
 674         case USB_ENDPOINT_XFER_BULK:
 675                 if (usb_endpoint_dir_in(ep))
 676                         array[i++] = 4;
 677                 else {
 678                         array[i++] = 3;
 679                         array[i++] = 5;
 680                 }
 681                 break;
 682         case USB_ENDPOINT_XFER_INT:
 683                 if (usb_endpoint_dir_in(ep)) {
 684                         array[i++] = 6;
 685                         array[i++] = 7;
 686                         array[i++] = 8;
 687                 } else
 688                         array[i++] = 9;
 689                 break;
 690         case USB_ENDPOINT_XFER_ISOC:
 691                 if (usb_endpoint_dir_in(ep))
 692                         array[i++] = 2;
 693                 else
 694                         array[i++] = 1;
 695                 break;
 696         default:
 697                 printk(KERN_ERR "r8a66597: Illegal type\n");
 698                 return 0;
 699         }
 700
 701         i = 1;
 702         min = array[0];
 703         while (array[i] != 0) {
 704                 if (r8a66597->pipe_cnt[min] > r8a66597->pipe_cnt[array[i]])
 705                         min = array[i];
 706                 i++;
 707         }
 708
 709         return min;
 710 }
 711
 712 static u16 get_r8a66597_type(__u8 type)
 713 {
 714         u16 r8a66597_type;
 715
 716         switch (type) {
 717         case USB_ENDPOINT_XFER_BULK:
 718                 r8a66597_type = R8A66597_BULK;
 719                 break;
 720         case USB_ENDPOINT_XFER_INT:
 721                 r8a66597_type = R8A66597_INT;
 722                 break;
 723         case USB_ENDPOINT_XFER_ISOC:
 724                 r8a66597_type = R8A66597_ISO;
 725                 break;
 726         default:
 727                 printk(KERN_ERR "r8a66597: Illegal type\n");
 728                 r8a66597_type = 0x0000;
 729                 break;
 730         }
 731
 732         return r8a66597_type;
 733 }
 734
 735 static u16 get_bufnum(u16 pipenum)
 736 {
 737         u16 bufnum = 0;
 738
 739         if (pipenum == 0)
 740                 bufnum = 0;
 741         else if (check_bulk_or_isoc(pipenum))
 742                 bufnum = 8 + (pipenum - 1) * R8A66597_BUF_BSIZE*2;
 743         else if (check_interrupt(pipenum))
 744                 bufnum = 4 + (pipenum - 6);
 745         else
 746                 printk(KERN_ERR "r8a66597: Illegal pipenum (%d)\n", pipenum);
 747
 748         return bufnum;
 749 }
 750
 751 static u16 get_buf_bsize(u16 pipenum)
 752 {
 753         u16 buf_bsize = 0;
 754
 755         if (pipenum == 0)
 756                 buf_bsize = 3;
 757         else if (check_bulk_or_isoc(pipenum))
 758                 buf_bsize = R8A66597_BUF_BSIZE - 1;
 759         else if (check_interrupt(pipenum))
 760                 buf_bsize = 0;
 761         else
 762                 printk(KERN_ERR "r8a66597: Illegal pipenum (%d)\n", pipenum);
 763
 764         return buf_bsize;
 765 }
 766
 767 /* this function must be called with interrupt disabled */
 768 static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
 769                                      struct r8a66597_device *dev,
 770                                      struct r8a66597_pipe *pipe,
 771                                      struct urb *urb)
 772 {
 773         int i;
 774         struct r8a66597_pipe_info *info = &pipe->info;
 775         unsigned short mbw = mbw_value(r8a66597);
 776
 777         /* pipe dma is only for external controlles */
 778         if (r8a66597->pdata->on_chip)
 779                 return;
 780
 781         if ((pipe->info.pipenum != 0) && (info->type != R8A66597_INT)) {
 782                 for (i = 0; i < R8A66597_MAX_DMA_CHANNEL; i++) {
 783                         if ((r8a66597->dma_map & (1 << i)) != 0)
 784                                 continue;
 785
 786                         dev_info(&dev->udev->dev,
 787                                  "address %d, EndpointAddress 0x%02x use "
 788                                  "DMA FIFO\n", usb_pipedevice(urb->pipe),
 789                                  info->dir_in ?
 790                                         USB_ENDPOINT_DIR_MASK + info->epnum
 791                                         : info->epnum);
 792
 793                         r8a66597->dma_map |= 1 << i;
 794                         dev->dma_map |= 1 << i;
 795                         set_pipe_reg_addr(pipe, i);
 796
 797                         cfifo_change(r8a66597, 0);
 798                         r8a66597_mdfy(r8a66597, mbw | pipe->info.pipenum,
 799                                       mbw | CURPIPE, pipe->fifosel);
 800
 801                         r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE,
 802                                           pipe->info.pipenum);
 803                         r8a66597_bset(r8a66597, BCLR, pipe->fifoctr);
 804                         break;
 805                 }
 806         }
 807 }
 808
 809 /* this function must be called with interrupt disabled */
 810 static void enable_r8a66597_pipe(struct r8a66597 *r8a66597, struct urb *urb,
 811                                  struct usb_host_endpoint *hep,
 812                                  struct r8a66597_pipe_info *info)
 813 {
 814         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 815         struct r8a66597_pipe *pipe = hep->hcpriv;
 816
 817         dev_dbg(&dev->udev->dev, "enable_pipe:\n");
 818
 819         pipe->info = *info;
 820         set_pipe_reg_addr(pipe, R8A66597_PIPE_NO_DMA);
 821         r8a66597->pipe_cnt[pipe->info.pipenum]++;
 822         dev->pipe_cnt[pipe->info.pipenum]++;
 823
 824         enable_r8a66597_pipe_dma(r8a66597, dev, pipe, urb);
 825 }
 826
 827 static void r8a66597_urb_done(struct r8a66597 *r8a66597, struct urb *urb,
 828                               int status)
 829 __releases(r8a66597->lock)
 830 __acquires(r8a66597->lock)
 831 {
 832         if (usb_pipein(urb->pipe) && usb_pipetype(urb->pipe) != PIPE_CONTROL) {
 833                 void *ptr;
 834
 835                 for (ptr = urb->transfer_buffer;
 836                      ptr < urb->transfer_buffer + urb->transfer_buffer_length;
 837                      ptr += PAGE_SIZE)
 838                         flush_dcache_page(virt_to_page(ptr));
 839         }
 840
 841         usb_hcd_unlink_urb_from_ep(r8a66597_to_hcd(r8a66597), urb);
 842         spin_unlock(&r8a66597->lock);
 843         usb_hcd_giveback_urb(r8a66597_to_hcd(r8a66597), urb, status);
 844         spin_lock(&r8a66597->lock);
 845 }
 846
 847 /* this function must be called with interrupt disabled */
 848 static void force_dequeue(struct r8a66597 *r8a66597, u16 pipenum, u16 address)
 849 {
 850         struct r8a66597_td *td, *next;
 851         struct urb *urb;
 852         struct list_head *list = &r8a66597->pipe_queue[pipenum];
 853
 854         if (list_empty(list))
 855                 return;
 856
 857         list_for_each_entry_safe(td, next, list, queue) {
 858                 if (td->address != address)
 859                         continue;
 860
 861                 urb = td->urb;
 862                 list_del(&td->queue);
 863                 kfree(td);
 864
 865                 if (urb)
 866                         r8a66597_urb_done(r8a66597, urb, -ENODEV);
 867
 868                 break;
 869         }
 870 }
 871
 872 /* this function must be called with interrupt disabled */
 873 static void disable_r8a66597_pipe_all(struct r8a66597 *r8a66597,
 874                                       struct r8a66597_device *dev)
 875 {
 876         int check_ep0 = 0;
 877         u16 pipenum;
 878
 879         if (!dev)
 880                 return;
 881
 882         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
 883                 if (!dev->pipe_cnt[pipenum])
 884                         continue;
 885
 886                 if (!check_ep0) {
 887                         check_ep0 = 1;
 888                         force_dequeue(r8a66597, 0, dev->address);
 889                 }
 890
 891                 r8a66597->pipe_cnt[pipenum] -= dev->pipe_cnt[pipenum];
 892                 dev->pipe_cnt[pipenum] = 0;
 893                 force_dequeue(r8a66597, pipenum, dev->address);
 894         }
 895
 896         dev_dbg(&dev->udev->dev, "disable_pipe\n");
 897
 898         r8a66597->dma_map &= ~(dev->dma_map);
 899         dev->dma_map = 0;
 900 }
 901
 902 static u16 get_interval(struct urb *urb, __u8 interval)
 903 {
 904         u16 time = 1;
 905         int i;
 906
 907         if (urb->dev->speed == USB_SPEED_HIGH) {
 908                 if (interval > IITV)
 909                         time = IITV;
 910                 else
 911                         time = interval ? interval - 1 : 0;
 912         } else {
 913                 if (interval > 128) {
 914                         time = IITV;
 915                 } else {
 916                         /* calculate the nearest value for PIPEPERI */
 917                         for (i = 0; i < 7; i++) {
 918                                 if ((1 << i) < interval &&
 919                                     (1 << (i + 1) > interval))
 920                                         time = 1 << i;
 921                         }
 922                 }
 923         }
 924
 925         return time;
 926 }
 927
 928 static unsigned long get_timer_interval(struct urb *urb, __u8 interval)
 929 {
 930         __u8 i;
 931         unsigned long time = 1;
 932
 933         if (usb_pipeisoc(urb->pipe))
 934                 return 0;
 935
 936         if (get_r8a66597_usb_speed(urb->dev->speed) == HSMODE) {
 937                 for (i = 0; i < (interval - 1); i++)
 938                         time *= 2;
 939                 time = time * 125 / 1000;       /* uSOF -> msec */
 940         } else {
 941                 time = interval;
 942         }
 943
 944         return time;
 945 }
 946
 947 /* this function must be called with interrupt disabled */
 948 static void init_pipe_info(struct r8a66597 *r8a66597, struct urb *urb,
 949                            struct usb_host_endpoint *hep,
 950                            struct usb_endpoint_descriptor *ep)
 951 {
 952         struct r8a66597_pipe_info info;
 953
 954         info.pipenum = get_empty_pipenum(r8a66597, ep);
 955         info.address = get_urb_to_r8a66597_addr(r8a66597, urb);
 956         info.epnum = usb_endpoint_num(ep);
 957         info.maxpacket = usb_endpoint_maxp(ep);
 958         info.type = get_r8a66597_type(usb_endpoint_type(ep));
 959         info.bufnum = get_bufnum(info.pipenum);
 960         info.buf_bsize = get_buf_bsize(info.pipenum);
 961         if (info.type == R8A66597_BULK) {
 962                 info.interval = 0;
 963                 info.timer_interval = 0;
 964         } else {
 965                 info.interval = get_interval(urb, ep->bInterval);
 966                 info.timer_interval = get_timer_interval(urb, ep->bInterval);
 967         }
 968         if (usb_endpoint_dir_in(ep))
 969                 info.dir_in = 1;
 970         else
 971                 info.dir_in = 0;
 972
 973         enable_r8a66597_pipe(r8a66597, urb, hep, &info);
 974 }
 975
 976 static void init_pipe_config(struct r8a66597 *r8a66597, struct urb *urb)
 977 {
 978         struct r8a66597_device *dev;
 979
 980         dev = get_urb_to_r8a66597_dev(r8a66597, urb);
 981         dev->state = USB_STATE_CONFIGURED;
 982 }
 983
 984 static void pipe_irq_enable(struct r8a66597 *r8a66597, struct urb *urb,
 985                             u16 pipenum)
 986 {
 987         if (pipenum == 0 && usb_pipeout(urb->pipe))
 988                 enable_irq_empty(r8a66597, pipenum);
 989         else
 990                 enable_irq_ready(r8a66597, pipenum);
 991
 992         if (!usb_pipeisoc(urb->pipe))
 993                 enable_irq_nrdy(r8a66597, pipenum);
 994 }
 995
 996 static void pipe_irq_disable(struct r8a66597 *r8a66597, u16 pipenum)
 997 {
 998         disable_irq_ready(r8a66597, pipenum);
 999         disable_irq_nrdy(r8a66597, pipenum);
1000 }
1001
1002 static void r8a66597_root_hub_start_polling(struct r8a66597 *r8a66597)
1003 {
1004         mod_timer(&r8a66597->rh_timer,
1005                         jiffies + msecs_to_jiffies(R8A66597_RH_POLL_TIME));
1006 }
1007
1008 static void start_root_hub_sampling(struct r8a66597 *r8a66597, int port,
1009                                         int connect)
1010 {
1011         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
1012
1013         rh->old_syssts = r8a66597_read(r8a66597, get_syssts_reg(port)) & LNST;
1014         rh->scount = R8A66597_MAX_SAMPLING;
1015         if (connect)
1016                 rh->port |= USB_PORT_STAT_CONNECTION;
1017         else
1018                 rh->port &= ~USB_PORT_STAT_CONNECTION;
1019         rh->port |= USB_PORT_STAT_C_CONNECTION << 16;
1020
1021         r8a66597_root_hub_start_polling(r8a66597);
1022 }
1023
1024 /* this function must be called with interrupt disabled */
1025 static void r8a66597_check_syssts(struct r8a66597 *r8a66597, int port,
1026                                         u16 syssts)
1027 __releases(r8a66597->lock)
1028 __acquires(r8a66597->lock)
1029 {
1030         if (syssts == SE0) {
1031                 r8a66597_write(r8a66597, ~ATTCH, get_intsts_reg(port));
1032                 r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
1033         } else {
1034                 if (syssts == FS_JSTS)
1035                         r8a66597_bset(r8a66597, HSE, get_syscfg_reg(port));
1036                 else if (syssts == LS_JSTS)
1037                         r8a66597_bclr(r8a66597, HSE, get_syscfg_reg(port));
1038
1039                 r8a66597_write(r8a66597, ~DTCH, get_intsts_reg(port));
1040                 r8a66597_bset(r8a66597, DTCHE, get_intenb_reg(port));
1041
1042                 if (r8a66597->bus_suspended)
1043                         usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
1044         }
1045
1046         spin_unlock(&r8a66597->lock);
1047         usb_hcd_poll_rh_status(r8a66597_to_hcd(r8a66597));
1048         spin_lock(&r8a66597->lock);
1049 }
1050
1051 /* this function must be called with interrupt disabled */
1052 static void r8a66597_usb_connect(struct r8a66597 *r8a66597, int port)
1053 {
1054         u16 speed = get_rh_usb_speed(r8a66597, port);
1055         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
1056
1057         rh->port &= ~(USB_PORT_STAT_HIGH_SPEED | USB_PORT_STAT_LOW_SPEED);
1058         if (speed == HSMODE)
1059                 rh->port |= USB_PORT_STAT_HIGH_SPEED;
1060         else if (speed == LSMODE)
1061                 rh->port |= USB_PORT_STAT_LOW_SPEED;
1062
1063         rh->port &= ~USB_PORT_STAT_RESET;
1064         rh->port |= USB_PORT_STAT_ENABLE;
1065 }
1066
1067 /* this function must be called with interrupt disabled */
1068 static void r8a66597_usb_disconnect(struct r8a66597 *r8a66597, int port)
1069 {
1070         struct r8a66597_device *dev = r8a66597->root_hub[port].dev;
1071
1072         disable_r8a66597_pipe_all(r8a66597, dev);
1073         free_usb_address(r8a66597, dev, 0);
1074
1075         start_root_hub_sampling(r8a66597, port, 0);
1076 }
1077
1078 /* this function must be called with interrupt disabled */
1079 static void prepare_setup_packet(struct r8a66597 *r8a66597,
1080                                  struct r8a66597_td *td)
1081 {
1082         int i;
1083         __le16 *p = (__le16 *)td->urb->setup_packet;
1084         unsigned long setup_addr = USBREQ;
1085
1086         r8a66597_write(r8a66597, make_devsel(td->address) | td->maxpacket,
1087                        DCPMAXP);
1088         r8a66597_write(r8a66597, ~(SIGN | SACK), INTSTS1);
1089
1090         for (i = 0; i < 4; i++) {
1091                 r8a66597_write(r8a66597, le16_to_cpu(p[i]), setup_addr);
1092                 setup_addr += 2;
1093         }
1094         r8a66597_write(r8a66597, SUREQ, DCPCTR);
1095 }
1096
1097 /* this function must be called with interrupt disabled */
1098 static void prepare_packet_read(struct r8a66597 *r8a66597,
1099                                 struct r8a66597_td *td)
1100 {
1101         struct urb *urb = td->urb;
1102
1103         if (usb_pipecontrol(urb->pipe)) {
1104                 r8a66597_bclr(r8a66597, R8A66597_DIR, DCPCFG);
1105                 r8a66597_mdfy(r8a66597, 0, ISEL | CURPIPE, CFIFOSEL);
1106                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
1107                 if (urb->actual_length == 0) {
1108                         r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
1109                         r8a66597_write(r8a66597, BCLR, CFIFOCTR);
1110                 }
1111                 pipe_irq_disable(r8a66597, td->pipenum);
1112                 pipe_start(r8a66597, td->pipe);
1113                 pipe_irq_enable(r8a66597, urb, td->pipenum);
1114         } else {
1115                 if (urb->actual_length == 0) {
1116                         pipe_irq_disable(r8a66597, td->pipenum);
1117                         pipe_setting(r8a66597, td);
1118                         pipe_stop(r8a66597, td->pipe);
1119                         r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
1120
1121                         if (td->pipe->pipetre) {
1122                                 r8a66597_write(r8a66597, TRCLR,
1123                                                 td->pipe->pipetre);
1124                                 r8a66597_write(r8a66597,
1125                                                 DIV_ROUND_UP
1126                                                   (urb->transfer_buffer_length,
1127                                                    td->maxpacket),
1128                                                 td->pipe->pipetrn);
1129                                 r8a66597_bset(r8a66597, TRENB,
1130                                                 td->pipe->pipetre);
1131                         }
1132
1133                         pipe_start(r8a66597, td->pipe);
1134                         pipe_irq_enable(r8a66597, urb, td->pipenum);
1135                 }
1136         }
1137 }
1138
1139 /* this function must be called with interrupt disabled */
1140 static void prepare_packet_write(struct r8a66597 *r8a66597,
1141                                  struct r8a66597_td *td)
1142 {
1143         u16 tmp;
1144         struct urb *urb = td->urb;
1145
1146         if (usb_pipecontrol(urb->pipe)) {
1147                 pipe_stop(r8a66597, td->pipe);
1148                 r8a66597_bset(r8a66597, R8A66597_DIR, DCPCFG);
1149                 r8a66597_mdfy(r8a66597, ISEL, ISEL | CURPIPE, CFIFOSEL);
1150                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
1151                 if (urb->actual_length == 0) {
1152                         r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
1153                         r8a66597_write(r8a66597, BCLR, CFIFOCTR);
1154                 }
1155         } else {
1156                 if (urb->actual_length == 0)
1157                         pipe_setting(r8a66597, td);
1158                 if (td->pipe->pipetre)
1159                         r8a66597_bclr(r8a66597, TRENB, td->pipe->pipetre);
1160         }
1161         r8a66597_write(r8a66597, ~(1 << td->pipenum), BRDYSTS);
1162
1163         fifo_change_from_pipe(r8a66597, td->pipe);
1164         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
1165         if (unlikely((tmp & FRDY) == 0))
1166                 pipe_irq_enable(r8a66597, urb, td->pipenum);
1167         else
1168                 packet_write(r8a66597, td->pipenum);
1169         pipe_start(r8a66597, td->pipe);
1170 }
1171
1172 /* this function must be called with interrupt disabled */
1173 static void prepare_status_packet(struct r8a66597 *r8a66597,
1174                                   struct r8a66597_td *td)
1175 {
1176         struct urb *urb = td->urb;
1177
1178         r8a66597_pipe_toggle(r8a66597, td->pipe, 1);
1179         pipe_stop(r8a66597, td->pipe);
1180
1181         if (urb->setup_packet[0] & USB_ENDPOINT_DIR_MASK) {
1182                 r8a66597_bset(r8a66597, R8A66597_DIR, DCPCFG);
1183                 r8a66597_mdfy(r8a66597, ISEL, ISEL | CURPIPE, CFIFOSEL);
1184                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
1185                 r8a66597_write(r8a66597, ~BEMP0, BEMPSTS);
1186                 r8a66597_write(r8a66597, BCLR | BVAL, CFIFOCTR);
1187                 enable_irq_empty(r8a66597, 0);
1188         } else {
1189                 r8a66597_bclr(r8a66597, R8A66597_DIR, DCPCFG);
1190                 r8a66597_mdfy(r8a66597, 0, ISEL | CURPIPE, CFIFOSEL);
1191                 r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, 0);
1192                 r8a66597_write(r8a66597, BCLR, CFIFOCTR);
1193                 enable_irq_ready(r8a66597, 0);
1194         }
1195         enable_irq_nrdy(r8a66597, 0);
1196         pipe_start(r8a66597, td->pipe);
1197 }
1198
1199 static int is_set_address(unsigned char *setup_packet)
1200 {
1201         if (((setup_packet[0] & USB_TYPE_MASK) == USB_TYPE_STANDARD) &&
1202                         setup_packet[1] == USB_REQ_SET_ADDRESS)
1203                 return 1;
1204         else
1205                 return 0;
1206 }
1207
1208 /* this function must be called with interrupt disabled */
1209 static int start_transfer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
1210 {
1211         BUG_ON(!td);
1212
1213         switch (td->type) {
1214         case USB_PID_SETUP:
1215                 if (is_set_address(td->urb->setup_packet)) {
1216                         td->set_address = 1;
1217                         td->urb->setup_packet[2] = alloc_usb_address(r8a66597,
1218                                                                      td->urb);
1219                         if (td->urb->setup_packet[2] == 0)
1220                                 return -EPIPE;
1221                 }
1222                 prepare_setup_packet(r8a66597, td);
1223                 break;
1224         case USB_PID_IN:
1225                 prepare_packet_read(r8a66597, td);
1226                 break;
1227         case USB_PID_OUT:
1228                 prepare_packet_write(r8a66597, td);
1229                 break;
1230         case USB_PID_ACK:
1231                 prepare_status_packet(r8a66597, td);
1232                 break;
1233         default:
1234                 printk(KERN_ERR "r8a66597: invalid type.\n");
1235                 break;
1236         }
1237
1238         return 0;
1239 }
1240
1241 static int check_transfer_finish(struct r8a66597_td *td, struct urb *urb)
1242 {
1243         if (usb_pipeisoc(urb->pipe)) {
1244                 if (urb->number_of_packets == td->iso_cnt)
1245                         return 1;
1246         }
1247
1248         /* control or bulk or interrupt */
1249         if ((urb->transfer_buffer_length <= urb->actual_length) ||
1250             (td->short_packet) || (td->zero_packet))
1251                 return 1;
1252
1253         return 0;
1254 }
1255
1256 /* this function must be called with interrupt disabled */
1257 static void set_td_timer(struct r8a66597 *r8a66597, struct r8a66597_td *td)
1258 {
1259         unsigned long time;
1260
1261         BUG_ON(!td);
1262
1263         if (!list_empty(&r8a66597->pipe_queue[td->pipenum]) &&
1264             !usb_pipecontrol(td->urb->pipe) && usb_pipein(td->urb->pipe)) {
1265                 r8a66597->timeout_map |= 1 << td->pipenum;
1266                 switch (usb_pipetype(td->urb->pipe)) {
1267                 case PIPE_INTERRUPT:
1268                 case PIPE_ISOCHRONOUS:
1269                         time = 30;
1270                         break;
1271                 default:
1272                         time = 50;
1273                         break;
1274                 }
1275
1276                 mod_timer(&r8a66597->td_timer[td->pipenum],
1277                           jiffies + msecs_to_jiffies(time));
1278         }
1279 }
1280
1281 /* this function must be called with interrupt disabled */
1282 static void finish_request(struct r8a66597 *r8a66597, struct r8a66597_td *td,
1283                 u16 pipenum, struct urb *urb, int status)
1284 __releases(r8a66597->lock) __acquires(r8a66597->lock)
1285 {
1286         int restart = 0;
1287         struct usb_hcd *hcd = r8a66597_to_hcd(r8a66597);
1288
1289         r8a66597->timeout_map &= ~(1 << pipenum);
1290
1291         if (likely(td)) {
1292                 if (td->set_address && (status != 0 || urb->unlinked))
1293                         r8a66597->address_map &= ~(1 << urb->setup_packet[2]);
1294
1295                 pipe_toggle_save(r8a66597, td->pipe, urb);
1296                 list_del(&td->queue);
1297                 kfree(td);
1298         }
1299
1300         if (!list_empty(&r8a66597->pipe_queue[pipenum]))
1301                 restart = 1;
1302
1303         if (likely(urb)) {
1304                 if (usb_pipeisoc(urb->pipe))
1305                         urb->start_frame = r8a66597_get_frame(hcd);
1306
1307                 r8a66597_urb_done(r8a66597, urb, status);
1308         }
1309
1310         if (restart) {
1311                 td = r8a66597_get_td(r8a66597, pipenum);
1312                 if (unlikely(!td))
1313                         return;
1314
1315                 start_transfer(r8a66597, td);
1316                 set_td_timer(r8a66597, td);
1317         }
1318 }
1319
1320 static void packet_read(struct r8a66597 *r8a66597, u16 pipenum)
1321 {
1322         u16 tmp;
1323         int rcv_len, bufsize, urb_len, size;
1324         u16 *buf;
1325         struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
1326         struct urb *urb;
1327         int finish = 0;
1328         int status = 0;
1329
1330         if (unlikely(!td))
1331                 return;
1332         urb = td->urb;
1333
1334         fifo_change_from_pipe(r8a66597, td->pipe);
1335         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
1336         if (unlikely((tmp & FRDY) == 0)) {
1337                 pipe_stop(r8a66597, td->pipe);
1338                 pipe_irq_disable(r8a66597, pipenum);
1339                 printk(KERN_ERR "r8a66597: in fifo not ready (%d)\n", pipenum);
1340                 finish_request(r8a66597, td, pipenum, td->urb, -EPIPE);
1341                 return;
1342         }
1343
1344         /* prepare parameters */
1345         rcv_len = tmp & DTLN;
1346         if (usb_pipeisoc(urb->pipe)) {
1347                 buf = (u16 *)(urb->transfer_buffer +
1348                                 urb->iso_frame_desc[td->iso_cnt].offset);
1349                 urb_len = urb->iso_frame_desc[td->iso_cnt].length;
1350         } else {
1351                 buf = (void *)urb->transfer_buffer + urb->actual_length;
1352                 urb_len = urb->transfer_buffer_length - urb->actual_length;
1353         }
1354         bufsize = min(urb_len, (int) td->maxpacket);
1355         if (rcv_len <= bufsize) {
1356                 size = rcv_len;
1357         } else {
1358                 size = bufsize;
1359                 status = -EOVERFLOW;
1360                 finish = 1;
1361         }
1362
1363         /* update parameters */
1364         urb->actual_length += size;
1365         if (rcv_len == 0)
1366                 td->zero_packet = 1;
1367         if (rcv_len < bufsize) {
1368                 td->short_packet = 1;
1369         }
1370         if (usb_pipeisoc(urb->pipe)) {
1371                 urb->iso_frame_desc[td->iso_cnt].actual_length = size;
1372                 urb->iso_frame_desc[td->iso_cnt].status = status;
1373                 td->iso_cnt++;
1374                 finish = 0;
1375         }
1376
1377         /* check transfer finish */
1378         if (finish || check_transfer_finish(td, urb)) {
1379                 pipe_stop(r8a66597, td->pipe);
1380                 pipe_irq_disable(r8a66597, pipenum);
1381                 finish = 1;
1382         }
1383
1384         /* read fifo */
1385         if (urb->transfer_buffer) {
1386                 if (size == 0)
1387                         r8a66597_write(r8a66597, BCLR, td->pipe->fifoctr);
1388                 else
1389                         r8a66597_read_fifo(r8a66597, td->pipe->fifoaddr,
1390                                            buf, size);
1391         }
1392
1393         if (finish && pipenum != 0)
1394                 finish_request(r8a66597, td, pipenum, urb, status);
1395 }
1396
1397 static void packet_write(struct r8a66597 *r8a66597, u16 pipenum)
1398 {
1399         u16 tmp;
1400         int bufsize, size;
1401         u16 *buf;
1402         struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
1403         struct urb *urb;
1404
1405         if (unlikely(!td))
1406                 return;
1407         urb = td->urb;
1408
1409         fifo_change_from_pipe(r8a66597, td->pipe);
1410         tmp = r8a66597_read(r8a66597, td->pipe->fifoctr);
1411         if (unlikely((tmp & FRDY) == 0)) {
1412                 pipe_stop(r8a66597, td->pipe);
1413                 pipe_irq_disable(r8a66597, pipenum);
1414                 printk(KERN_ERR "r8a66597: out fifo not ready (%d)\n", pipenum);
1415                 finish_request(r8a66597, td, pipenum, urb, -EPIPE);
1416                 return;
1417         }
1418
1419         /* prepare parameters */
1420         bufsize = td->maxpacket;
1421         if (usb_pipeisoc(urb->pipe)) {
1422                 buf = (u16 *)(urb->transfer_buffer +
1423                                 urb->iso_frame_desc[td->iso_cnt].offset);
1424                 size = min(bufsize,
1425                            (int)urb->iso_frame_desc[td->iso_cnt].length);
1426         } else {
1427                 buf = (u16 *)(urb->transfer_buffer + urb->actual_length);
1428                 size = min_t(u32, bufsize,
1429                            urb->transfer_buffer_length - urb->actual_length);
1430         }
1431
1432         /* write fifo */
1433         if (pipenum > 0)
1434                 r8a66597_write(r8a66597, ~(1 << pipenum), BEMPSTS);
1435         if (urb->transfer_buffer) {
1436                 r8a66597_write_fifo(r8a66597, td->pipe, buf, size);
1437                 if (!usb_pipebulk(urb->pipe) || td->maxpacket != size)
1438                         r8a66597_write(r8a66597, BVAL, td->pipe->fifoctr);
1439         }
1440
1441         /* update parameters */
1442         urb->actual_length += size;
1443         if (usb_pipeisoc(urb->pipe)) {
1444                 urb->iso_frame_desc[td->iso_cnt].actual_length = size;
1445                 urb->iso_frame_desc[td->iso_cnt].status = 0;
1446                 td->iso_cnt++;
1447         }
1448
1449         /* check transfer finish */
1450         if (check_transfer_finish(td, urb)) {
1451                 disable_irq_ready(r8a66597, pipenum);
1452                 enable_irq_empty(r8a66597, pipenum);
1453                 if (!usb_pipeisoc(urb->pipe))
1454                         enable_irq_nrdy(r8a66597, pipenum);
1455         } else
1456                 pipe_irq_enable(r8a66597, urb, pipenum);
1457 }
1458
1459
1460 static void check_next_phase(struct r8a66597 *r8a66597, int status)
1461 {
1462         struct r8a66597_td *td = r8a66597_get_td(r8a66597, 0);
1463         struct urb *urb;
1464         u8 finish = 0;
1465
1466         if (unlikely(!td))
1467                 return;
1468         urb = td->urb;
1469
1470         switch (td->type) {
1471         case USB_PID_IN:
1472         case USB_PID_OUT:
1473                 if (check_transfer_finish(td, urb))
1474                         td->type = USB_PID_ACK;
1475                 break;
1476         case USB_PID_SETUP:
1477                 if (urb->transfer_buffer_length == urb->actual_length)
1478                         td->type = USB_PID_ACK;
1479                 else if (usb_pipeout(urb->pipe))
1480                         td->type = USB_PID_OUT;
1481                 else
1482                         td->type = USB_PID_IN;
1483                 break;
1484         case USB_PID_ACK:
1485                 finish = 1;
1486                 break;
1487         }
1488
1489         if (finish || status != 0 || urb->unlinked)
1490                 finish_request(r8a66597, td, 0, urb, status);
1491         else
1492                 start_transfer(r8a66597, td);
1493 }
1494
1495 static int get_urb_error(struct r8a66597 *r8a66597, u16 pipenum)
1496 {
1497         struct r8a66597_td *td = r8a66597_get_td(r8a66597, pipenum);
1498
1499         if (td) {
1500                 u16 pid = r8a66597_read(r8a66597, td->pipe->pipectr) & PID;
1501
1502                 if (pid == PID_NAK)
1503                         return -ECONNRESET;
1504                 else
1505                         return -EPIPE;
1506         }
1507         return 0;
1508 }
1509
1510 static void irq_pipe_ready(struct r8a66597 *r8a66597)
1511 {
1512         u16 check;
1513         u16 pipenum;
1514         u16 mask;
1515         struct r8a66597_td *td;
1516
1517         mask = r8a66597_read(r8a66597, BRDYSTS)
1518                & r8a66597_read(r8a66597, BRDYENB);
1519         r8a66597_write(r8a66597, ~mask, BRDYSTS);
1520         if (mask & BRDY0) {
1521                 td = r8a66597_get_td(r8a66597, 0);
1522                 if (td && td->type == USB_PID_IN)
1523                         packet_read(r8a66597, 0);
1524                 else
1525                         pipe_irq_disable(r8a66597, 0);
1526                 check_next_phase(r8a66597, 0);
1527         }
1528
1529         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
1530                 check = 1 << pipenum;
1531                 if (mask & check) {
1532                         td = r8a66597_get_td(r8a66597, pipenum);
1533                         if (unlikely(!td))
1534                                 continue;
1535
1536                         if (td->type == USB_PID_IN)
1537                                 packet_read(r8a66597, pipenum);
1538                         else if (td->type == USB_PID_OUT)
1539                                 packet_write(r8a66597, pipenum);
1540                 }
1541         }
1542 }
1543
1544 static void irq_pipe_empty(struct r8a66597 *r8a66597)
1545 {
1546         u16 tmp;
1547         u16 check;
1548         u16 pipenum;
1549         u16 mask;
1550         struct r8a66597_td *td;
1551
1552         mask = r8a66597_read(r8a66597, BEMPSTS)
1553                & r8a66597_read(r8a66597, BEMPENB);
1554         r8a66597_write(r8a66597, ~mask, BEMPSTS);
1555         if (mask & BEMP0) {
1556                 cfifo_change(r8a66597, 0);
1557                 td = r8a66597_get_td(r8a66597, 0);
1558                 if (td && td->type != USB_PID_OUT)
1559                         disable_irq_empty(r8a66597, 0);
1560                 check_next_phase(r8a66597, 0);
1561         }
1562
1563         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
1564                 check = 1 << pipenum;
1565                 if (mask &  check) {
1566                         struct r8a66597_td *td;
1567                         td = r8a66597_get_td(r8a66597, pipenum);
1568                         if (unlikely(!td))
1569                                 continue;
1570
1571                         tmp = r8a66597_read(r8a66597, td->pipe->pipectr);
1572                         if ((tmp & INBUFM) == 0) {
1573                                 disable_irq_empty(r8a66597, pipenum);
1574                                 pipe_irq_disable(r8a66597, pipenum);
1575                                 finish_request(r8a66597, td, pipenum, td->urb,
1576                                                 0);
1577                         }
1578                 }
1579         }
1580 }
1581
1582 static void irq_pipe_nrdy(struct r8a66597 *r8a66597)
1583 {
1584         u16 check;
1585         u16 pipenum;
1586         u16 mask;
1587         int status;
1588
1589         mask = r8a66597_read(r8a66597, NRDYSTS)
1590                & r8a66597_read(r8a66597, NRDYENB);
1591         r8a66597_write(r8a66597, ~mask, NRDYSTS);
1592         if (mask & NRDY0) {
1593                 cfifo_change(r8a66597, 0);
1594                 status = get_urb_error(r8a66597, 0);
1595                 pipe_irq_disable(r8a66597, 0);
1596                 check_next_phase(r8a66597, status);
1597         }
1598
1599         for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
1600                 check = 1 << pipenum;
1601                 if (mask & check) {
1602                         struct r8a66597_td *td;
1603                         td = r8a66597_get_td(r8a66597, pipenum);
1604                         if (unlikely(!td))
1605                                 continue;
1606
1607                         status = get_urb_error(r8a66597, pipenum);
1608                         pipe_irq_disable(r8a66597, pipenum);
1609                         pipe_stop(r8a66597, td->pipe);
1610                         finish_request(r8a66597, td, pipenum, td->urb, status);
1611                 }
1612         }
1613 }
1614
1615 static irqreturn_t r8a66597_irq(struct usb_hcd *hcd)
1616 {
1617         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1618         u16 intsts0, intsts1, intsts2;
1619         u16 intenb0, intenb1, intenb2;
1620         u16 mask0, mask1, mask2;
1621         int status;
1622
1623         spin_lock(&r8a66597->lock);
1624
1625         intsts0 = r8a66597_read(r8a66597, INTSTS0);
1626         intsts1 = r8a66597_read(r8a66597, INTSTS1);
1627         intsts2 = r8a66597_read(r8a66597, INTSTS2);
1628         intenb0 = r8a66597_read(r8a66597, INTENB0);
1629         intenb1 = r8a66597_read(r8a66597, INTENB1);
1630         intenb2 = r8a66597_read(r8a66597, INTENB2);
1631
1632         mask2 = intsts2 & intenb2;
1633         mask1 = intsts1 & intenb1;
1634         mask0 = intsts0 & intenb0 & (BEMP | NRDY | BRDY);
1635         if (mask2) {
1636                 if (mask2 & ATTCH) {
1637                         r8a66597_write(r8a66597, ~ATTCH, INTSTS2);
1638                         r8a66597_bclr(r8a66597, ATTCHE, INTENB2);
1639
1640                         /* start usb bus sampling */
1641                         start_root_hub_sampling(r8a66597, 1, 1);
1642                 }
1643                 if (mask2 & DTCH) {
1644                         r8a66597_write(r8a66597, ~DTCH, INTSTS2);
1645                         r8a66597_bclr(r8a66597, DTCHE, INTENB2);
1646                         r8a66597_usb_disconnect(r8a66597, 1);
1647                 }
1648                 if (mask2 & BCHG) {
1649                         r8a66597_write(r8a66597, ~BCHG, INTSTS2);
1650                         r8a66597_bclr(r8a66597, BCHGE, INTENB2);
1651                         usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
1652                 }
1653         }
1654
1655         if (mask1) {
1656                 if (mask1 & ATTCH) {
1657                         r8a66597_write(r8a66597, ~ATTCH, INTSTS1);
1658                         r8a66597_bclr(r8a66597, ATTCHE, INTENB1);
1659
1660                         /* start usb bus sampling */
1661                         start_root_hub_sampling(r8a66597, 0, 1);
1662                 }
1663                 if (mask1 & DTCH) {
1664                         r8a66597_write(r8a66597, ~DTCH, INTSTS1);
1665                         r8a66597_bclr(r8a66597, DTCHE, INTENB1);
1666                         r8a66597_usb_disconnect(r8a66597, 0);
1667                 }
1668                 if (mask1 & BCHG) {
1669                         r8a66597_write(r8a66597, ~BCHG, INTSTS1);
1670                         r8a66597_bclr(r8a66597, BCHGE, INTENB1);
1671                         usb_hcd_resume_root_hub(r8a66597_to_hcd(r8a66597));
1672                 }
1673
1674                 if (mask1 & SIGN) {
1675                         r8a66597_write(r8a66597, ~SIGN, INTSTS1);
1676                         status = get_urb_error(r8a66597, 0);
1677                         check_next_phase(r8a66597, status);
1678                 }
1679                 if (mask1 & SACK) {
1680                         r8a66597_write(r8a66597, ~SACK, INTSTS1);
1681                         check_next_phase(r8a66597, 0);
1682                 }
1683         }
1684         if (mask0) {
1685                 if (mask0 & BRDY)
1686                         irq_pipe_ready(r8a66597);
1687                 if (mask0 & BEMP)
1688                         irq_pipe_empty(r8a66597);
1689                 if (mask0 & NRDY)
1690                         irq_pipe_nrdy(r8a66597);
1691         }
1692
1693         spin_unlock(&r8a66597->lock);
1694         return IRQ_HANDLED;
1695 }
1696
1697 /* this function must be called with interrupt disabled */
1698 static void r8a66597_root_hub_control(struct r8a66597 *r8a66597, int port)
1699 {
1700         u16 tmp;
1701         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
1702
1703         if (rh->port & USB_PORT_STAT_RESET) {
1704                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
1705
1706                 tmp = r8a66597_read(r8a66597, dvstctr_reg);
1707                 if ((tmp & USBRST) == USBRST) {
1708                         r8a66597_mdfy(r8a66597, UACT, USBRST | UACT,
1709                                       dvstctr_reg);
1710                         r8a66597_root_hub_start_polling(r8a66597);
1711                 } else
1712                         r8a66597_usb_connect(r8a66597, port);
1713         }
1714
1715         if (!(rh->port & USB_PORT_STAT_CONNECTION)) {
1716                 r8a66597_write(r8a66597, ~ATTCH, get_intsts_reg(port));
1717                 r8a66597_bset(r8a66597, ATTCHE, get_intenb_reg(port));
1718         }
1719
1720         if (rh->scount > 0) {
1721                 tmp = r8a66597_read(r8a66597, get_syssts_reg(port)) & LNST;
1722                 if (tmp == rh->old_syssts) {
1723                         rh->scount--;
1724                         if (rh->scount == 0)
1725                                 r8a66597_check_syssts(r8a66597, port, tmp);
1726                         else
1727                                 r8a66597_root_hub_start_polling(r8a66597);
1728                 } else {
1729                         rh->scount = R8A66597_MAX_SAMPLING;
1730                         rh->old_syssts = tmp;
1731                         r8a66597_root_hub_start_polling(r8a66597);
1732                 }
1733         }
1734 }
1735
1736 static void r8a66597_interval_timer(unsigned long _r8a66597)
1737 {
1738         struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
1739         unsigned long flags;
1740         u16 pipenum;
1741         struct r8a66597_td *td;
1742
1743         spin_lock_irqsave(&r8a66597->lock, flags);
1744
1745         for (pipenum = 0; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
1746                 if (!(r8a66597->interval_map & (1 << pipenum)))
1747                         continue;
1748                 if (timer_pending(&r8a66597->interval_timer[pipenum]))
1749                         continue;
1750
1751                 td = r8a66597_get_td(r8a66597, pipenum);
1752                 if (td)
1753                         start_transfer(r8a66597, td);
1754         }
1755
1756         spin_unlock_irqrestore(&r8a66597->lock, flags);
1757 }
1758
1759 static void r8a66597_td_timer(unsigned long _r8a66597)
1760 {
1761         struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
1762         unsigned long flags;
1763         u16 pipenum;
1764         struct r8a66597_td *td, *new_td = NULL;
1765         struct r8a66597_pipe *pipe;
1766
1767         spin_lock_irqsave(&r8a66597->lock, flags);
1768         for (pipenum = 0; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
1769                 if (!(r8a66597->timeout_map & (1 << pipenum)))
1770                         continue;
1771                 if (timer_pending(&r8a66597->td_timer[pipenum]))
1772                         continue;
1773
1774                 td = r8a66597_get_td(r8a66597, pipenum);
1775                 if (!td) {
1776                         r8a66597->timeout_map &= ~(1 << pipenum);
1777                         continue;
1778                 }
1779
1780                 if (td->urb->actual_length) {
1781                         set_td_timer(r8a66597, td);
1782                         break;
1783                 }
1784
1785                 pipe = td->pipe;
1786                 pipe_stop(r8a66597, pipe);
1787
1788                 /* Select a different address or endpoint */
1789                 new_td = td;
1790                 do {
1791                         list_move_tail(&new_td->queue,
1792                                        &r8a66597->pipe_queue[pipenum]);
1793                         new_td = r8a66597_get_td(r8a66597, pipenum);
1794                         if (!new_td) {
1795                                 new_td = td;
1796                                 break;
1797                         }
1798                 } while (td != new_td && td->address == new_td->address &&
1799                         td->pipe->info.epnum == new_td->pipe->info.epnum);
1800
1801                 start_transfer(r8a66597, new_td);
1802
1803                 if (td == new_td)
1804                         r8a66597->timeout_map &= ~(1 << pipenum);
1805                 else
1806                         set_td_timer(r8a66597, new_td);
1807                 break;
1808         }
1809         spin_unlock_irqrestore(&r8a66597->lock, flags);
1810 }
1811
1812 static void r8a66597_timer(unsigned long _r8a66597)
1813 {
1814         struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
1815         unsigned long flags;
1816         int port;
1817
1818         spin_lock_irqsave(&r8a66597->lock, flags);
1819
1820         for (port = 0; port < r8a66597->max_root_hub; port++)
1821                 r8a66597_root_hub_control(r8a66597, port);
1822
1823         spin_unlock_irqrestore(&r8a66597->lock, flags);
1824 }
1825
1826 static int check_pipe_config(struct r8a66597 *r8a66597, struct urb *urb)
1827 {
1828         struct r8a66597_device *dev = get_urb_to_r8a66597_dev(r8a66597, urb);
1829
1830         if (dev && dev->address && dev->state != USB_STATE_CONFIGURED &&
1831             (urb->dev->state == USB_STATE_CONFIGURED))
1832                 return 1;
1833         else
1834                 return 0;
1835 }
1836
1837 static int r8a66597_start(struct usb_hcd *hcd)
1838 {
1839         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1840
1841         hcd->state = HC_STATE_RUNNING;
1842         return enable_controller(r8a66597);
1843 }
1844
1845 static void r8a66597_stop(struct usb_hcd *hcd)
1846 {
1847         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1848
1849         disable_controller(r8a66597);
1850 }
1851
1852 static void set_address_zero(struct r8a66597 *r8a66597, struct urb *urb)
1853 {
1854         unsigned int usb_address = usb_pipedevice(urb->pipe);
1855         u16 root_port, hub_port;
1856
1857         if (usb_address == 0) {
1858                 get_port_number(r8a66597, urb->dev->devpath,
1859                                 &root_port, &hub_port);
1860                 set_devadd_reg(r8a66597, 0,
1861                                get_r8a66597_usb_speed(urb->dev->speed),
1862                                get_parent_r8a66597_address(r8a66597, urb->dev),
1863                                hub_port, root_port);
1864         }
1865 }
1866
1867 static struct r8a66597_td *r8a66597_make_td(struct r8a66597 *r8a66597,
1868                                             struct urb *urb,
1869                                             struct usb_host_endpoint *hep)
1870 {
1871         struct r8a66597_td *td;
1872         u16 pipenum;
1873
1874         td = kzalloc(sizeof(struct r8a66597_td), GFP_ATOMIC);
1875         if (td == NULL)
1876                 return NULL;
1877
1878         pipenum = r8a66597_get_pipenum(urb, hep);
1879         td->pipenum = pipenum;
1880         td->pipe = hep->hcpriv;
1881         td->urb = urb;
1882         td->address = get_urb_to_r8a66597_addr(r8a66597, urb);
1883         td->maxpacket = usb_maxpacket(urb->dev, urb->pipe,
1884                                       !usb_pipein(urb->pipe));
1885         if (usb_pipecontrol(urb->pipe))
1886                 td->type = USB_PID_SETUP;
1887         else if (usb_pipein(urb->pipe))
1888                 td->type = USB_PID_IN;
1889         else
1890                 td->type = USB_PID_OUT;
1891         INIT_LIST_HEAD(&td->queue);
1892
1893         return td;
1894 }
1895
1896 static int r8a66597_urb_enqueue(struct usb_hcd *hcd,
1897                                 struct urb *urb,
1898                                 gfp_t mem_flags)
1899 {
1900         struct usb_host_endpoint *hep = urb->ep;
1901         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1902         struct r8a66597_td *td = NULL;
1903         int ret, request = 0;
1904         unsigned long flags;
1905
1906         spin_lock_irqsave(&r8a66597->lock, flags);
1907         if (!get_urb_to_r8a66597_dev(r8a66597, urb)) {
1908                 ret = -ENODEV;
1909                 goto error_not_linked;
1910         }
1911
1912         ret = usb_hcd_link_urb_to_ep(hcd, urb);
1913         if (ret)
1914                 goto error_not_linked;
1915
1916         if (!hep->hcpriv) {
1917                 hep->hcpriv = kzalloc(sizeof(struct r8a66597_pipe),
1918                                 GFP_ATOMIC);
1919                 if (!hep->hcpriv) {
1920                         ret = -ENOMEM;
1921                         goto error;
1922                 }
1923                 set_pipe_reg_addr(hep->hcpriv, R8A66597_PIPE_NO_DMA);
1924                 if (usb_pipeendpoint(urb->pipe))
1925                         init_pipe_info(r8a66597, urb, hep, &hep->desc);
1926         }
1927
1928         if (unlikely(check_pipe_config(r8a66597, urb)))
1929                 init_pipe_config(r8a66597, urb);
1930
1931         set_address_zero(r8a66597, urb);
1932         td = r8a66597_make_td(r8a66597, urb, hep);
1933         if (td == NULL) {
1934                 ret = -ENOMEM;
1935                 goto error;
1936         }
1937         if (list_empty(&r8a66597->pipe_queue[td->pipenum]))
1938                 request = 1;
1939         list_add_tail(&td->queue, &r8a66597->pipe_queue[td->pipenum]);
1940         urb->hcpriv = td;
1941
1942         if (request) {
1943                 if (td->pipe->info.timer_interval) {
1944                         r8a66597->interval_map |= 1 << td->pipenum;
1945                         mod_timer(&r8a66597->interval_timer[td->pipenum],
1946                                   jiffies + msecs_to_jiffies(
1947                                         td->pipe->info.timer_interval));
1948                 } else {
1949                         ret = start_transfer(r8a66597, td);
1950                         if (ret < 0) {
1951                                 list_del(&td->queue);
1952                                 kfree(td);
1953                         }
1954                 }
1955         } else
1956                 set_td_timer(r8a66597, td);
1957
1958 error:
1959         if (ret)
1960                 usb_hcd_unlink_urb_from_ep(hcd, urb);
1961 error_not_linked:
1962         spin_unlock_irqrestore(&r8a66597->lock, flags);
1963         return ret;
1964 }
1965
1966 static int r8a66597_urb_dequeue(struct usb_hcd *hcd, struct urb *urb,
1967                 int status)
1968 {
1969         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1970         struct r8a66597_td *td;
1971         unsigned long flags;
1972         int rc;
1973
1974         spin_lock_irqsave(&r8a66597->lock, flags);
1975         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
1976         if (rc)
1977                 goto done;
1978
1979         if (urb->hcpriv) {
1980                 td = urb->hcpriv;
1981                 pipe_stop(r8a66597, td->pipe);
1982                 pipe_irq_disable(r8a66597, td->pipenum);
1983                 disable_irq_empty(r8a66597, td->pipenum);
1984                 finish_request(r8a66597, td, td->pipenum, urb, status);
1985         }
1986  done:
1987         spin_unlock_irqrestore(&r8a66597->lock, flags);
1988         return rc;
1989 }
1990
1991 static void r8a66597_endpoint_disable(struct usb_hcd *hcd,
1992                                       struct usb_host_endpoint *hep)
1993 {
1994         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
1995         struct r8a66597_pipe *pipe = (struct r8a66597_pipe *)hep->hcpriv;
1996         struct r8a66597_td *td;
1997         struct urb *urb = NULL;
1998         u16 pipenum;
1999         unsigned long flags;
2000
2001         if (pipe == NULL)
2002                 return;
2003         pipenum = pipe->info.pipenum;
2004
2005         if (pipenum == 0) {
2006                 kfree(hep->hcpriv);
2007                 hep->hcpriv = NULL;
2008                 return;
2009         }
2010
2011         spin_lock_irqsave(&r8a66597->lock, flags);
2012         pipe_stop(r8a66597, pipe);
2013         pipe_irq_disable(r8a66597, pipenum);
2014         disable_irq_empty(r8a66597, pipenum);
2015         td = r8a66597_get_td(r8a66597, pipenum);
2016         if (td)
2017                 urb = td->urb;
2018         finish_request(r8a66597, td, pipenum, urb, -ESHUTDOWN);
2019         kfree(hep->hcpriv);
2020         hep->hcpriv = NULL;
2021         spin_unlock_irqrestore(&r8a66597->lock, flags);
2022 }
2023
2024 static int r8a66597_get_frame(struct usb_hcd *hcd)
2025 {
2026         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
2027         return r8a66597_read(r8a66597, FRMNUM) & 0x03FF;
2028 }
2029
2030 static void collect_usb_address_map(struct usb_device *udev, unsigned long *map)
2031 {
2032         int chix;
2033         struct usb_device *childdev;
2034
2035         if (udev->state == USB_STATE_CONFIGURED &&
2036             udev->parent && udev->parent->devnum > 1 &&
2037             udev->parent->descriptor.bDeviceClass == USB_CLASS_HUB)
2038                 map[udev->devnum/32] |= (1 << (udev->devnum % 32));
2039
2040         usb_hub_for_each_child(udev, chix, childdev)
2041                 collect_usb_address_map(childdev, map);
2042 }
2043
2044 /* this function must be called with interrupt disabled */
2045 static struct r8a66597_device *get_r8a66597_device(struct r8a66597 *r8a66597,
2046                                                    int addr)
2047 {
2048         struct r8a66597_device *dev;
2049         struct list_head *list = &r8a66597->child_device;
2050
2051         list_for_each_entry(dev, list, device_list) {
2052                 if (dev->usb_address != addr)
2053                         continue;
2054
2055                 return dev;
2056         }
2057
2058         printk(KERN_ERR "r8a66597: get_r8a66597_device fail.(%d)\n", addr);
2059         return NULL;
2060 }
2061
2062 static void update_usb_address_map(struct r8a66597 *r8a66597,
2063                                    struct usb_device *root_hub,
2064                                    unsigned long *map)
2065 {
2066         int i, j, addr;
2067         unsigned long diff;
2068         unsigned long flags;
2069
2070         for (i = 0; i < 4; i++) {
2071                 diff = r8a66597->child_connect_map[i] ^ map[i];
2072                 if (!diff)
2073                         continue;
2074
2075                 for (j = 0; j < 32; j++) {
2076                         if (!(diff & (1 << j)))
2077                                 continue;
2078
2079                         addr = i * 32 + j;
2080                         if (map[i] & (1 << j))
2081                                 set_child_connect_map(r8a66597, addr);
2082                         else {
2083                                 struct r8a66597_device *dev;
2084
2085                                 spin_lock_irqsave(&r8a66597->lock, flags);
2086                                 dev = get_r8a66597_device(r8a66597, addr);
2087                                 disable_r8a66597_pipe_all(r8a66597, dev);
2088                                 free_usb_address(r8a66597, dev, 0);
2089                                 put_child_connect_map(r8a66597, addr);
2090                                 spin_unlock_irqrestore(&r8a66597->lock, flags);
2091                         }
2092                 }
2093         }
2094 }
2095
2096 static void r8a66597_check_detect_child(struct r8a66597 *r8a66597,
2097                                         struct usb_hcd *hcd)
2098 {
2099         struct usb_bus *bus;
2100         unsigned long now_map[4];
2101
2102         memset(now_map, 0, sizeof(now_map));
2103
2104         mutex_lock(&usb_bus_idr_lock);
2105         bus = idr_find(&usb_bus_idr, hcd->self.busnum);
2106         if (bus && bus->root_hub) {
2107                 collect_usb_address_map(bus->root_hub, now_map);
2108                 update_usb_address_map(r8a66597, bus->root_hub, now_map);
2109         }
2110         mutex_unlock(&usb_bus_idr_lock);
2111 }
2112
2113 static int r8a66597_hub_status_data(struct usb_hcd *hcd, char *buf)
2114 {
2115         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
2116         unsigned long flags;
2117         int i;
2118
2119         r8a66597_check_detect_child(r8a66597, hcd);
2120
2121         spin_lock_irqsave(&r8a66597->lock, flags);
2122
2123         *buf = 0;       /* initialize (no change) */
2124
2125         for (i = 0; i < r8a66597->max_root_hub; i++) {
2126                 if (r8a66597->root_hub[i].port & 0xffff0000)
2127                         *buf |= 1 << (i + 1);
2128         }
2129
2130         spin_unlock_irqrestore(&r8a66597->lock, flags);
2131
2132         return (*buf != 0);
2133 }
2134
2135 static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
2136                                     struct usb_hub_descriptor *desc)
2137 {
2138         desc->bDescriptorType = USB_DT_HUB;
2139         desc->bHubContrCurrent = 0;
2140         desc->bNbrPorts = r8a66597->max_root_hub;
2141         desc->bDescLength = 9;
2142         desc->bPwrOn2PwrGood = 0;
2143         desc->wHubCharacteristics =
2144                 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM);
2145         desc->u.hs.DeviceRemovable[0] =
2146                 ((1 << r8a66597->max_root_hub) - 1) << 1;
2147         desc->u.hs.DeviceRemovable[1] = ~0;
2148 }
2149
2150 static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
2151                                 u16 wIndex, char *buf, u16 wLength)
2152 {
2153         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
2154         int ret;
2155         int port = (wIndex & 0x00FF) - 1;
2156         struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
2157         unsigned long flags;
2158
2159         ret = 0;
2160
2161         spin_lock_irqsave(&r8a66597->lock, flags);
2162         switch (typeReq) {
2163         case ClearHubFeature:
2164         case SetHubFeature:
2165                 switch (wValue) {
2166                 case C_HUB_OVER_CURRENT:
2167                 case C_HUB_LOCAL_POWER:
2168                         break;
2169                 default:
2170                         goto error;
2171                 }
2172                 break;
2173         case ClearPortFeature:
2174                 if (wIndex > r8a66597->max_root_hub)
2175                         goto error;
2176                 if (wLength != 0)
2177                         goto error;
2178
2179                 switch (wValue) {
2180                 case USB_PORT_FEAT_ENABLE:
2181                         rh->port &= ~USB_PORT_STAT_POWER;
2182                         break;
2183                 case USB_PORT_FEAT_SUSPEND:
2184                         break;
2185                 case USB_PORT_FEAT_POWER:
2186                         r8a66597_port_power(r8a66597, port, 0);
2187                         break;
2188                 case USB_PORT_FEAT_C_ENABLE:
2189                 case USB_PORT_FEAT_C_SUSPEND:
2190                 case USB_PORT_FEAT_C_CONNECTION:
2191                 case USB_PORT_FEAT_C_OVER_CURRENT:
2192                 case USB_PORT_FEAT_C_RESET:
2193                         break;
2194                 default:
2195                         goto error;
2196                 }
2197                 rh->port &= ~(1 << wValue);
2198                 break;
2199         case GetHubDescriptor:
2200                 r8a66597_hub_descriptor(r8a66597,
2201                                         (struct usb_hub_descriptor *)buf);
2202                 break;
2203         case GetHubStatus:
2204                 *buf = 0x00;
2205                 break;
2206         case GetPortStatus:
2207                 if (wIndex > r8a66597->max_root_hub)
2208                         goto error;
2209                 *(__le32 *)buf = cpu_to_le32(rh->port);
2210                 break;
2211         case SetPortFeature:
2212                 if (wIndex > r8a66597->max_root_hub)
2213                         goto error;
2214                 if (wLength != 0)
2215                         goto error;
2216
2217                 switch (wValue) {
2218                 case USB_PORT_FEAT_SUSPEND:
2219                         break;
2220                 case USB_PORT_FEAT_POWER:
2221                         r8a66597_port_power(r8a66597, port, 1);
2222                         rh->port |= USB_PORT_STAT_POWER;
2223                         break;
2224                 case USB_PORT_FEAT_RESET: {
2225                         struct r8a66597_device *dev = rh->dev;
2226
2227                         rh->port |= USB_PORT_STAT_RESET;
2228
2229                         disable_r8a66597_pipe_all(r8a66597, dev);
2230                         free_usb_address(r8a66597, dev, 1);
2231
2232                         r8a66597_mdfy(r8a66597, USBRST, USBRST | UACT,
2233                                       get_dvstctr_reg(port));
2234                         mod_timer(&r8a66597->rh_timer,
2235                                   jiffies + msecs_to_jiffies(50));
2236                         }
2237                         break;
2238                 default:
2239                         goto error;
2240                 }
2241                 rh->port |= 1 << wValue;
2242                 break;
2243         default:
2244 error:
2245                 ret = -EPIPE;
2246                 break;
2247         }
2248
2249         spin_unlock_irqrestore(&r8a66597->lock, flags);
2250         return ret;
2251 }
2252
2253 #if defined(CONFIG_PM)
2254 static int r8a66597_bus_suspend(struct usb_hcd *hcd)
2255 {
2256         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
2257         int port;
2258
2259         dev_dbg(&r8a66597->device0.udev->dev, "%s\n", __func__);
2260
2261         for (port = 0; port < r8a66597->max_root_hub; port++) {
2262                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
2263                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
2264
2265                 if (!(rh->port & USB_PORT_STAT_ENABLE))
2266                         continue;
2267
2268                 dev_dbg(&rh->dev->udev->dev, "suspend port = %d\n", port);
2269                 r8a66597_bclr(r8a66597, UACT, dvstctr_reg);     /* suspend */
2270                 rh->port |= USB_PORT_STAT_SUSPEND;
2271
2272                 if (rh->dev->udev->do_remote_wakeup) {
2273                         msleep(3);      /* waiting last SOF */
2274                         r8a66597_bset(r8a66597, RWUPE, dvstctr_reg);
2275                         r8a66597_write(r8a66597, ~BCHG, get_intsts_reg(port));
2276                         r8a66597_bset(r8a66597, BCHGE, get_intenb_reg(port));
2277                 }
2278         }
2279
2280         r8a66597->bus_suspended = 1;
2281
2282         return 0;
2283 }
2284
2285 static int r8a66597_bus_resume(struct usb_hcd *hcd)
2286 {
2287         struct r8a66597 *r8a66597 = hcd_to_r8a66597(hcd);
2288         int port;
2289
2290         dev_dbg(&r8a66597->device0.udev->dev, "%s\n", __func__);
2291
2292         for (port = 0; port < r8a66597->max_root_hub; port++) {
2293                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
2294                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
2295
2296                 if (!(rh->port & USB_PORT_STAT_SUSPEND))
2297                         continue;
2298
2299                 dev_dbg(&rh->dev->udev->dev, "resume port = %d\n", port);
2300                 rh->port &= ~USB_PORT_STAT_SUSPEND;
2301                 rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
2302                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
2303                 msleep(USB_RESUME_TIMEOUT);
2304                 r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
2305         }
2306
2307         return 0;
2308
2309 }
2310 #else
2311 #define r8a66597_bus_suspend    NULL
2312 #define r8a66597_bus_resume     NULL
2313 #endif
2314
2315 static struct hc_driver r8a66597_hc_driver = {
2316         .description =          hcd_name,
2317         .hcd_priv_size =        sizeof(struct r8a66597),
2318         .irq =                  r8a66597_irq,
2319
2320         /*
2321          * generic hardware linkage
2322          */
2323         .flags =                HCD_USB2,
2324
2325         .start =                r8a66597_start,
2326         .stop =                 r8a66597_stop,
2327
2328         /*
2329          * managing i/o requests and associated device resources
2330          */
2331         .urb_enqueue =          r8a66597_urb_enqueue,
2332         .urb_dequeue =          r8a66597_urb_dequeue,
2333         .endpoint_disable =     r8a66597_endpoint_disable,
2334
2335         /*
2336          * periodic schedule support
2337          */
2338         .get_frame_number =     r8a66597_get_frame,
2339
2340         /*
2341          * root hub support
2342          */
2343         .hub_status_data =      r8a66597_hub_status_data,
2344         .hub_control =          r8a66597_hub_control,
2345         .bus_suspend =          r8a66597_bus_suspend,
2346         .bus_resume =           r8a66597_bus_resume,
2347 };
2348
2349 #if defined(CONFIG_PM)
2350 static int r8a66597_suspend(struct device *dev)
2351 {
2352         struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
2353         int port;
2354
2355         dev_dbg(dev, "%s\n", __func__);
2356
2357         disable_controller(r8a66597);
2358
2359         for (port = 0; port < r8a66597->max_root_hub; port++) {
2360                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
2361
2362                 rh->port = 0x00000000;
2363         }
2364
2365         return 0;
2366 }
2367
2368 static int r8a66597_resume(struct device *dev)
2369 {
2370         struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
2371         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
2372
2373         dev_dbg(dev, "%s\n", __func__);
2374
2375         enable_controller(r8a66597);
2376         usb_root_hub_lost_power(hcd->self.root_hub);
2377
2378         return 0;
2379 }
2380
2381 static const struct dev_pm_ops r8a66597_dev_pm_ops = {
2382         .suspend = r8a66597_suspend,
2383         .resume = r8a66597_resume,
2384         .poweroff = r8a66597_suspend,
2385         .restore = r8a66597_resume,
2386 };
2387
2388 #define R8A66597_DEV_PM_OPS     (&r8a66597_dev_pm_ops)
2389 #else   /* if defined(CONFIG_PM) */
2390 #define R8A66597_DEV_PM_OPS     NULL
2391 #endif
2392
2393 static int r8a66597_remove(struct platform_device *pdev)
2394 {
2395         struct r8a66597         *r8a66597 = platform_get_drvdata(pdev);
2396         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
2397
2398         del_timer_sync(&r8a66597->rh_timer);
2399         usb_remove_hcd(hcd);
2400         iounmap(r8a66597->reg);
2401         if (r8a66597->pdata->on_chip)
2402                 clk_put(r8a66597->clk);
2403         usb_put_hcd(hcd);
2404         return 0;
2405 }
2406
2407 static int r8a66597_probe(struct platform_device *pdev)
2408 {
2409         char clk_name[8];
2410         struct resource *res = NULL, *ires;
2411         int irq = -1;
2412         void __iomem *reg = NULL;
2413         struct usb_hcd *hcd = NULL;
2414         struct r8a66597 *r8a66597;
2415         int ret = 0;
2416         int i;
2417         unsigned long irq_trigger;
2418
2419         if (usb_disabled())
2420                 return -ENODEV;
2421
2422         if (pdev->dev.dma_mask) {
2423                 ret = -EINVAL;
2424                 dev_err(&pdev->dev, "dma not supported\n");
2425                 goto clean_up;
2426         }
2427
2428         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
2429         if (!res) {
2430                 ret = -ENODEV;
2431                 dev_err(&pdev->dev, "platform_get_resource error.\n");
2432                 goto clean_up;
2433         }
2434
2435         ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
2436         if (!ires) {
2437                 ret = -ENODEV;
2438                 dev_err(&pdev->dev,
2439                         "platform_get_resource IORESOURCE_IRQ error.\n");
2440                 goto clean_up;
2441         }
2442
2443         irq = ires->start;
2444         irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
2445
2446         reg = ioremap(res->start, resource_size(res));
2447         if (reg == NULL) {
2448                 ret = -ENOMEM;
2449                 dev_err(&pdev->dev, "ioremap error.\n");
2450                 goto clean_up;
2451         }
2452
2453         if (pdev->dev.platform_data == NULL) {
2454                 dev_err(&pdev->dev, "no platform data\n");
2455                 ret = -ENODEV;
2456                 goto clean_up;
2457         }
2458
2459         /* initialize hcd */
2460         hcd = usb_create_hcd(&r8a66597_hc_driver, &pdev->dev, (char *)hcd_name);
2461         if (!hcd) {
2462                 ret = -ENOMEM;
2463                 dev_err(&pdev->dev, "Failed to create hcd\n");
2464                 goto clean_up;
2465         }
2466         r8a66597 = hcd_to_r8a66597(hcd);
2467         memset(r8a66597, 0, sizeof(struct r8a66597));
2468         platform_set_drvdata(pdev, r8a66597);
2469         r8a66597->pdata = dev_get_platdata(&pdev->dev);
2470         r8a66597->irq_sense_low = irq_trigger == IRQF_TRIGGER_LOW;
2471
2472         if (r8a66597->pdata->on_chip) {
2473                 snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id);
2474                 r8a66597->clk = clk_get(&pdev->dev, clk_name);
2475                 if (IS_ERR(r8a66597->clk)) {
2476                         dev_err(&pdev->dev, "cannot get clock \"%s\"\n",
2477                                 clk_name);
2478                         ret = PTR_ERR(r8a66597->clk);
2479                         goto clean_up2;
2480                 }
2481                 r8a66597->max_root_hub = 1;
2482         } else
2483                 r8a66597->max_root_hub = 2;
2484
2485         spin_lock_init(&r8a66597->lock);
2486         setup_timer(&r8a66597->rh_timer, r8a66597_timer,
2487                     (unsigned long)r8a66597);
2488         r8a66597->reg = reg;
2489
2490         /* make sure no interrupts are pending */
2491         ret = r8a66597_clock_enable(r8a66597);
2492         if (ret < 0)
2493                 goto clean_up3;
2494         disable_controller(r8a66597);
2495
2496         for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
2497                 INIT_LIST_HEAD(&r8a66597->pipe_queue[i]);
2498                 setup_timer(&r8a66597->td_timer[i], r8a66597_td_timer,
2499                             (unsigned long)r8a66597);
2500                 setup_timer(&r8a66597->interval_timer[i],
2501                                 r8a66597_interval_timer,
2502                                 (unsigned long)r8a66597);
2503         }
2504         INIT_LIST_HEAD(&r8a66597->child_device);
2505
2506         hcd->rsrc_start = res->start;
2507         hcd->has_tt = 1;
2508
2509         ret = usb_add_hcd(hcd, irq, irq_trigger);
2510         if (ret != 0) {
2511                 dev_err(&pdev->dev, "Failed to add hcd\n");
2512                 goto clean_up3;
2513         }
2514         device_wakeup_enable(hcd->self.controller);
2515
2516         return 0;
2517
2518 clean_up3:
2519         if (r8a66597->pdata->on_chip)
2520                 clk_put(r8a66597->clk);
2521 clean_up2:
2522         usb_put_hcd(hcd);
2523
2524 clean_up:
2525         if (reg)
2526                 iounmap(reg);
2527
2528         return ret;
2529 }
2530
2531 static struct platform_driver r8a66597_driver = {
2532         .probe =        r8a66597_probe,
2533         .remove =       r8a66597_remove,
2534         .driver         = {
2535                 .name = hcd_name,
2536                 .pm     = R8A66597_DEV_PM_OPS,
2537         },
2538 };
2539
2540 module_platform_driver(r8a66597_driver);