drivers/usb/renesas_usbhs/common.c

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