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