common.c revision f427eb64f4c5433a91da5eb139970dd5cbad9082
1/* 2 * Renesas USB driver 3 * 4 * Copyright (C) 2011 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 15 * 16 */ 17#include <linux/io.h> 18#include <linux/module.h> 19#include <linux/pm_runtime.h> 20#include <linux/slab.h> 21#include <linux/sysfs.h> 22#include "./common.h" 23 24/* 25 * image of renesas_usbhs 26 * 27 * ex) gadget case 28 29 * mod.c 30 * mod_gadget.c 31 * mod_host.c pipe.c fifo.c 32 * 33 * +-------+ +-----------+ 34 * | pipe0 |------>| fifo pio | 35 * +------------+ +-------+ +-----------+ 36 * | mod_gadget |=====> | pipe1 |--+ 37 * +------------+ +-------+ | +-----------+ 38 * | pipe2 | | +-| fifo dma0 | 39 * +------------+ +-------+ | | +-----------+ 40 * | mod_host | | pipe3 |<-|--+ 41 * +------------+ +-------+ | +-----------+ 42 * | .... | +--->| fifo dma1 | 43 * | .... | +-----------+ 44 */ 45 46 47#define USBHSF_RUNTIME_PWCTRL (1 << 0) 48 49/* status */ 50#define usbhsc_flags_init(p) do {(p)->flags = 0; } while (0) 51#define usbhsc_flags_set(p, b) ((p)->flags |= (b)) 52#define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b)) 53#define usbhsc_flags_has(p, b) ((p)->flags & (b)) 54 55/* 56 * platform call back 57 * 58 * renesas usb support platform callback function. 59 * Below macro call it. 60 * if platform doesn't have callback, it return 0 (no error) 61 */ 62#define usbhs_platform_call(priv, func, args...)\ 63 (!(priv) ? -ENODEV : \ 64 !((priv)->pfunc->func) ? 0 : \ 65 (priv)->pfunc->func(args)) 66 67/* 68 * common functions 69 */ 70u16 usbhs_read(struct usbhs_priv *priv, u32 reg) 71{ 72 return ioread16(priv->base + reg); 73} 74 75void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data) 76{ 77 iowrite16(data, priv->base + reg); 78} 79 80void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data) 81{ 82 u16 val = usbhs_read(priv, reg); 83 84 val &= ~mask; 85 val |= data & mask; 86 87 usbhs_write(priv, reg, val); 88} 89 90struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev) 91{ 92 return dev_get_drvdata(&pdev->dev); 93} 94 95/* 96 * syscfg functions 97 */ 98void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable) 99{ 100 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0); 101} 102 103void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable) 104{ 105 usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0); 106} 107 108void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable) 109{ 110 usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0); 111} 112 113void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable) 114{ 115 u16 mask = DCFM | DRPD | DPRPU; 116 u16 val = DCFM | DRPD; 117 int has_otg = usbhs_get_dparam(priv, has_otg); 118 119 if (has_otg) 120 usbhs_bset(priv, DVSTCTR, (EXTLP | PWEN), (EXTLP | PWEN)); 121 122 /* 123 * if enable 124 * 125 * - select Host mode 126 * - D+ Line/D- Line Pull-down 127 */ 128 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 129} 130 131void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable) 132{ 133 u16 mask = DCFM | DRPD | DPRPU; 134 u16 val = DPRPU; 135 136 /* 137 * if enable 138 * 139 * - select Function mode 140 * - D+ Line Pull-up 141 */ 142 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 143} 144 145/* 146 * frame functions 147 */ 148int usbhs_frame_get_num(struct usbhs_priv *priv) 149{ 150 return usbhs_read(priv, FRMNUM) & FRNM_MASK; 151} 152 153/* 154 * usb request functions 155 */ 156void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 157{ 158 u16 val; 159 160 val = usbhs_read(priv, USBREQ); 161 req->bRequest = (val >> 8) & 0xFF; 162 req->bRequestType = (val >> 0) & 0xFF; 163 164 req->wValue = usbhs_read(priv, USBVAL); 165 req->wIndex = usbhs_read(priv, USBINDX); 166 req->wLength = usbhs_read(priv, USBLENG); 167} 168 169void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 170{ 171 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType); 172 usbhs_write(priv, USBVAL, req->wValue); 173 usbhs_write(priv, USBINDX, req->wIndex); 174 usbhs_write(priv, USBLENG, req->wLength); 175 176 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ); 177} 178 179/* 180 * bus/vbus functions 181 */ 182void usbhs_bus_send_sof_enable(struct usbhs_priv *priv) 183{ 184 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT); 185} 186 187void usbhs_bus_send_reset(struct usbhs_priv *priv) 188{ 189 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST); 190} 191 192int usbhs_bus_get_speed(struct usbhs_priv *priv) 193{ 194 u16 dvstctr = usbhs_read(priv, DVSTCTR); 195 196 switch (RHST & dvstctr) { 197 case RHST_LOW_SPEED: 198 return USB_SPEED_LOW; 199 case RHST_FULL_SPEED: 200 return USB_SPEED_FULL; 201 case RHST_HIGH_SPEED: 202 return USB_SPEED_HIGH; 203 } 204 205 return USB_SPEED_UNKNOWN; 206} 207 208int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable) 209{ 210 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 211 212 return usbhs_platform_call(priv, set_vbus, pdev, enable); 213} 214 215static void usbhsc_bus_init(struct usbhs_priv *priv) 216{ 217 usbhs_write(priv, DVSTCTR, 0); 218 219 usbhs_vbus_ctrl(priv, 0); 220} 221 222/* 223 * local functions 224 */ 225static void usbhsc_set_buswait(struct usbhs_priv *priv) 226{ 227 int wait = usbhs_get_dparam(priv, buswait_bwait); 228 229 /* set bus wait if platform have */ 230 if (wait) 231 usbhs_bset(priv, BUSWAIT, 0x000F, wait); 232} 233 234/* 235 * platform default param 236 */ 237static u32 usbhsc_default_pipe_type[] = { 238 USB_ENDPOINT_XFER_CONTROL, 239 USB_ENDPOINT_XFER_ISOC, 240 USB_ENDPOINT_XFER_ISOC, 241 USB_ENDPOINT_XFER_BULK, 242 USB_ENDPOINT_XFER_BULK, 243 USB_ENDPOINT_XFER_BULK, 244 USB_ENDPOINT_XFER_INT, 245 USB_ENDPOINT_XFER_INT, 246 USB_ENDPOINT_XFER_INT, 247 USB_ENDPOINT_XFER_INT, 248}; 249 250/* 251 * power control 252 */ 253static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable) 254{ 255 struct device *dev = usbhs_priv_to_dev(priv); 256 257 if (enable) { 258 /* enable PM */ 259 pm_runtime_get_sync(dev); 260 261 /* USB on */ 262 usbhs_sys_clock_ctrl(priv, enable); 263 } else { 264 /* USB off */ 265 usbhs_sys_clock_ctrl(priv, enable); 266 267 /* disable PM */ 268 pm_runtime_put_sync(dev); 269 } 270} 271 272/* 273 * hotplug 274 */ 275static void usbhsc_hotplug(struct usbhs_priv *priv) 276{ 277 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 278 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 279 int id; 280 int enable; 281 int ret; 282 283 /* 284 * get vbus status from platform 285 */ 286 enable = usbhs_platform_call(priv, get_vbus, pdev); 287 288 /* 289 * get id from platform 290 */ 291 id = usbhs_platform_call(priv, get_id, pdev); 292 293 if (enable && !mod) { 294 ret = usbhs_mod_change(priv, id); 295 if (ret < 0) 296 return; 297 298 dev_dbg(&pdev->dev, "%s enable\n", __func__); 299 300 /* power on */ 301 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 302 usbhsc_power_ctrl(priv, enable); 303 304 /* bus init */ 305 usbhsc_set_buswait(priv); 306 usbhsc_bus_init(priv); 307 308 /* module start */ 309 usbhs_mod_call(priv, start, priv); 310 311 } else if (!enable && mod) { 312 dev_dbg(&pdev->dev, "%s disable\n", __func__); 313 314 /* module stop */ 315 usbhs_mod_call(priv, stop, priv); 316 317 /* bus init */ 318 usbhsc_bus_init(priv); 319 320 /* power off */ 321 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 322 usbhsc_power_ctrl(priv, enable); 323 324 usbhs_mod_change(priv, -1); 325 326 /* reset phy for next connection */ 327 usbhs_platform_call(priv, phy_reset, pdev); 328 } 329} 330 331/* 332 * notify hotplug 333 */ 334static void usbhsc_notify_hotplug(struct work_struct *work) 335{ 336 struct usbhs_priv *priv = container_of(work, 337 struct usbhs_priv, 338 notify_hotplug_work.work); 339 usbhsc_hotplug(priv); 340} 341 342int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev) 343{ 344 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 345 int delay = usbhs_get_dparam(priv, detection_delay); 346 347 /* 348 * This functions will be called in interrupt. 349 * To make sure safety context, 350 * use workqueue for usbhs_notify_hotplug 351 */ 352 schedule_delayed_work(&priv->notify_hotplug_work, delay); 353 return 0; 354} 355 356/* 357 * platform functions 358 */ 359static int __devinit usbhs_probe(struct platform_device *pdev) 360{ 361 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 362 struct renesas_usbhs_driver_callback *dfunc; 363 struct usbhs_priv *priv; 364 struct resource *res; 365 unsigned int irq; 366 int ret; 367 368 /* check platform information */ 369 if (!info || 370 !info->platform_callback.get_id) { 371 dev_err(&pdev->dev, "no platform information\n"); 372 return -EINVAL; 373 } 374 375 /* platform data */ 376 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 377 irq = platform_get_irq(pdev, 0); 378 if (!res || (int)irq <= 0) { 379 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n"); 380 return -ENODEV; 381 } 382 383 /* usb private data */ 384 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 385 if (!priv) { 386 dev_err(&pdev->dev, "Could not allocate priv\n"); 387 return -ENOMEM; 388 } 389 390 priv->base = ioremap_nocache(res->start, resource_size(res)); 391 if (!priv->base) { 392 dev_err(&pdev->dev, "ioremap error.\n"); 393 ret = -ENOMEM; 394 goto probe_end_kfree; 395 } 396 397 /* 398 * care platform info 399 */ 400 priv->pfunc = &info->platform_callback; 401 priv->dparam = &info->driver_param; 402 403 /* set driver callback functions for platform */ 404 dfunc = &info->driver_callback; 405 dfunc->notify_hotplug = usbhsc_drvcllbck_notify_hotplug; 406 407 /* set default param if platform doesn't have */ 408 if (!priv->dparam->pipe_type) { 409 priv->dparam->pipe_type = usbhsc_default_pipe_type; 410 priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type); 411 } 412 if (!priv->dparam->pio_dma_border) 413 priv->dparam->pio_dma_border = 64; /* 64byte */ 414 415 /* FIXME */ 416 /* runtime power control ? */ 417 if (priv->pfunc->get_vbus) 418 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL); 419 420 /* 421 * priv settings 422 */ 423 priv->irq = irq; 424 priv->pdev = pdev; 425 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug); 426 spin_lock_init(usbhs_priv_to_lock(priv)); 427 428 /* call pipe and module init */ 429 ret = usbhs_pipe_probe(priv); 430 if (ret < 0) 431 goto probe_end_iounmap; 432 433 ret = usbhs_fifo_probe(priv); 434 if (ret < 0) 435 goto probe_end_pipe_exit; 436 437 ret = usbhs_mod_probe(priv); 438 if (ret < 0) 439 goto probe_end_fifo_exit; 440 441 /* dev_set_drvdata should be called after usbhs_mod_init */ 442 dev_set_drvdata(&pdev->dev, priv); 443 444 /* 445 * deviece reset here because 446 * USB device might be used in boot loader. 447 */ 448 usbhs_sys_clock_ctrl(priv, 0); 449 450 /* 451 * platform call 452 * 453 * USB phy setup might depend on CPU/Board. 454 * If platform has its callback functions, 455 * call it here. 456 */ 457 ret = usbhs_platform_call(priv, hardware_init, pdev); 458 if (ret < 0) { 459 dev_err(&pdev->dev, "platform prove failed.\n"); 460 goto probe_end_mod_exit; 461 } 462 463 /* reset phy for connection */ 464 usbhs_platform_call(priv, phy_reset, pdev); 465 466 /* power control */ 467 pm_runtime_enable(&pdev->dev); 468 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) { 469 usbhsc_power_ctrl(priv, 1); 470 usbhs_mod_autonomy_mode(priv); 471 } 472 473 /* 474 * manual call notify_hotplug for cold plug 475 */ 476 ret = usbhsc_drvcllbck_notify_hotplug(pdev); 477 if (ret < 0) 478 goto probe_end_call_remove; 479 480 dev_info(&pdev->dev, "probed\n"); 481 482 return ret; 483 484probe_end_call_remove: 485 usbhs_platform_call(priv, hardware_exit, pdev); 486probe_end_mod_exit: 487 usbhs_mod_remove(priv); 488probe_end_fifo_exit: 489 usbhs_fifo_remove(priv); 490probe_end_pipe_exit: 491 usbhs_pipe_remove(priv); 492probe_end_iounmap: 493 iounmap(priv->base); 494probe_end_kfree: 495 kfree(priv); 496 497 dev_info(&pdev->dev, "probe failed\n"); 498 499 return ret; 500} 501 502static int __devexit usbhs_remove(struct platform_device *pdev) 503{ 504 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 505 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 506 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback; 507 508 dev_dbg(&pdev->dev, "usb remove\n"); 509 510 dfunc->notify_hotplug = NULL; 511 512 /* power off */ 513 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 514 usbhsc_power_ctrl(priv, 0); 515 516 pm_runtime_disable(&pdev->dev); 517 518 usbhs_platform_call(priv, hardware_exit, pdev); 519 usbhs_mod_remove(priv); 520 usbhs_fifo_remove(priv); 521 usbhs_pipe_remove(priv); 522 iounmap(priv->base); 523 kfree(priv); 524 525 return 0; 526} 527 528static int usbhsc_suspend(struct device *dev) 529{ 530 struct usbhs_priv *priv = dev_get_drvdata(dev); 531 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 532 533 if (mod) { 534 usbhs_mod_call(priv, stop, priv); 535 usbhs_mod_change(priv, -1); 536 } 537 538 if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 539 usbhsc_power_ctrl(priv, 0); 540 541 return 0; 542} 543 544static int usbhsc_resume(struct device *dev) 545{ 546 struct usbhs_priv *priv = dev_get_drvdata(dev); 547 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 548 549 usbhs_platform_call(priv, phy_reset, pdev); 550 551 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 552 usbhsc_power_ctrl(priv, 1); 553 554 usbhsc_hotplug(priv); 555 556 return 0; 557} 558 559static int usbhsc_runtime_nop(struct device *dev) 560{ 561 /* Runtime PM callback shared between ->runtime_suspend() 562 * and ->runtime_resume(). Simply returns success. 563 * 564 * This driver re-initializes all registers after 565 * pm_runtime_get_sync() anyway so there is no need 566 * to save and restore registers here. 567 */ 568 return 0; 569} 570 571static const struct dev_pm_ops usbhsc_pm_ops = { 572 .suspend = usbhsc_suspend, 573 .resume = usbhsc_resume, 574 .runtime_suspend = usbhsc_runtime_nop, 575 .runtime_resume = usbhsc_runtime_nop, 576}; 577 578static struct platform_driver renesas_usbhs_driver = { 579 .driver = { 580 .name = "renesas_usbhs", 581 .pm = &usbhsc_pm_ops, 582 }, 583 .probe = usbhs_probe, 584 .remove = __devexit_p(usbhs_remove), 585}; 586 587static int __init usbhs_init(void) 588{ 589 return platform_driver_register(&renesas_usbhs_driver); 590} 591 592static void __exit usbhs_exit(void) 593{ 594 platform_driver_unregister(&renesas_usbhs_driver); 595} 596 597module_init(usbhs_init); 598module_exit(usbhs_exit); 599 600MODULE_LICENSE("GPL"); 601MODULE_DESCRIPTION("Renesas USB driver"); 602MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 603