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 #define USBHSF_RUNTIME_PWCTRL   (1 << 0)
  25
  26 /* status */
  27 #define usbhsc_flags_init(p)   do {(p)->flags = 0; } while (0)
  28 #define usbhsc_flags_set(p, b) ((p)->flags |=  (b))
  29 #define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b))
  30 #define usbhsc_flags_has(p, b) ((p)->flags &   (b))
  31
  32 /*
  33  * platform call back
  34  *
  35  * renesas usb support platform callback function.
  36  * Below macro call it.
  37  * if platform doesn't have callback, it return 0 (no error)
  38  */
  39 #define usbhs_platform_call(priv, func, args...)\
  40         (!(priv) ? -ENODEV :                    \
  41          !((priv)->pfunc->func) ? 0 :           \
  42          (priv)->pfunc->func(args))
  43
  44 /*
  45  *              common functions
  46  */
  47 u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
  48 {
  49         return ioread16(priv->base + reg);
  50 }
  51
  52 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
  53 {
  54         iowrite16(data, priv->base + reg);
  55 }
  56
  57 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
  58 {
  59         u16 val = usbhs_read(priv, reg);
  60
  61         val &= ~mask;
  62         val |= data & mask;
  63
  64         usbhs_write(priv, reg, val);
  65 }
  66
  67 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
  68 {
  69         return dev_get_drvdata(&pdev->dev);
  70 }
  71
  72 /*
  73  *              syscfg functions
  74  */
  75 void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
  76 {
  77         usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
  78 }
  79
  80 void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable)
  81 {
  82         usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0);
  83 }
  84
  85 void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable)
  86 {
  87         usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0);
  88 }
  89
  90 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
  91 {
  92         u16 mask = DCFM | DRPD | DPRPU;
  93         u16 val  = DCFM | DRPD;
  94
  95         /*
  96          * if enable
  97          *
  98          * - select Host mode
  99          * - D+ Line/D- Line Pull-down
 100          */
 101         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
 102 }
 103
 104 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
 105 {
 106         u16 mask = DCFM | DRPD | DPRPU;
 107         u16 val  = DPRPU;
 108
 109         /*
 110          * if enable
 111          *
 112          * - select Function mode
 113          * - D+ Line Pull-up
 114          */
 115         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
 116 }
 117
 118 /*
 119  *              frame functions
 120  */
 121 int usbhs_frame_get_num(struct usbhs_priv *priv)
 122 {
 123         return usbhs_read(priv, FRMNUM) & FRNM_MASK;
 124 }
 125
 126 /*
 127  *              local functions
 128  */
 129 static void usbhsc_bus_ctrl(struct usbhs_priv *priv, int enable)
 130 {
 131         int wait = usbhs_get_dparam(priv, buswait_bwait);
 132         u16 data = 0;
 133
 134         if (enable) {
 135                 /* set bus wait if platform have */
 136                 if (wait)
 137                         usbhs_bset(priv, BUSWAIT, 0x000F, wait);
 138         }
 139         usbhs_write(priv, DVSTCTR, data);
 140 }
 141
 142 /*
 143  *              platform default param
 144  */
 145 static u32 usbhsc_default_pipe_type[] = {
 146                 USB_ENDPOINT_XFER_CONTROL,
 147                 USB_ENDPOINT_XFER_ISOC,
 148                 USB_ENDPOINT_XFER_ISOC,
 149                 USB_ENDPOINT_XFER_BULK,
 150                 USB_ENDPOINT_XFER_BULK,
 151                 USB_ENDPOINT_XFER_BULK,
 152                 USB_ENDPOINT_XFER_INT,
 153                 USB_ENDPOINT_XFER_INT,
 154                 USB_ENDPOINT_XFER_INT,
 155                 USB_ENDPOINT_XFER_INT,
 156 };
 157
 158 /*
 159  *              power control
 160  */
 161 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
 162 {
 163         struct device *dev = usbhs_priv_to_dev(priv);
 164
 165         if (enable) {
 166                 /* enable PM */
 167                 pm_runtime_get_sync(dev);
 168
 169                 /* USB on */
 170                 usbhs_sys_clock_ctrl(priv, enable);
 171                 usbhsc_bus_ctrl(priv, enable);
 172         } else {
 173                 /* USB off */
 174                 usbhsc_bus_ctrl(priv, enable);
 175                 usbhs_sys_clock_ctrl(priv, enable);
 176
 177                 /* disable PM */
 178                 pm_runtime_put_sync(dev);
 179         }
 180 }
 181
 182 /*
 183  *              notify hotplug
 184  */
 185 static void usbhsc_notify_hotplug(struct work_struct *work)
 186 {
 187         struct usbhs_priv *priv = container_of(work,
 188                                                struct usbhs_priv,
 189                                                notify_hotplug_work.work);
 190         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
 191         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 192         int id;
 193         int enable;
 194         int ret;
 195
 196         /*
 197          * get vbus status from platform
 198          */
 199         enable = usbhs_platform_call(priv, get_vbus, pdev);
 200
 201         /*
 202          * get id from platform
 203          */
 204         id = usbhs_platform_call(priv, get_id, pdev);
 205
 206         if (enable && !mod) {
 207                 ret = usbhs_mod_change(priv, id);
 208                 if (ret < 0)
 209                         return;
 210
 211                 dev_dbg(&pdev->dev, "%s enable\n", __func__);
 212
 213                 /* power on */
 214                 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
 215                         usbhsc_power_ctrl(priv, enable);
 216
 217                 /* module start */
 218                 usbhs_mod_call(priv, start, priv);
 219
 220         } else if (!enable && mod) {
 221                 dev_dbg(&pdev->dev, "%s disable\n", __func__);
 222
 223                 /* module stop */
 224                 usbhs_mod_call(priv, stop, priv);
 225
 226                 /* power off */
 227                 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
 228                         usbhsc_power_ctrl(priv, enable);
 229
 230                 usbhs_mod_change(priv, -1);
 231
 232                 /* reset phy for next connection */
 233                 usbhs_platform_call(priv, phy_reset, pdev);
 234         }
 235 }
 236
 237 int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev)
 238 {
 239         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
 240         int delay = usbhs_get_dparam(priv, detection_delay);
 241
 242         /*
 243          * This functions will be called in interrupt.
 244          * To make sure safety context,
 245          * use workqueue for usbhs_notify_hotplug
 246          */
 247         schedule_delayed_work(&priv->notify_hotplug_work, delay);
 248         return 0;
 249 }
 250
 251 /*
 252  *              platform functions
 253  */
 254 static int __devinit usbhs_probe(struct platform_device *pdev)
 255 {
 256         struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
 257         struct renesas_usbhs_driver_callback *dfunc;
 258         struct usbhs_priv *priv;
 259         struct resource *res;
 260         unsigned int irq;
 261         int ret;
 262
 263         /* check platform information */
 264         if (!info ||
 265             !info->platform_callback.get_id) {
 266                 dev_err(&pdev->dev, "no platform information\n");
 267                 return -EINVAL;
 268         }
 269
 270         /* platform data */
 271         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 272         irq = platform_get_irq(pdev, 0);
 273         if (!res || (int)irq <= 0) {
 274                 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n");
 275                 return -ENODEV;
 276         }
 277
 278         /* usb private data */
 279         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 280         if (!priv) {
 281                 dev_err(&pdev->dev, "Could not allocate priv\n");
 282                 return -ENOMEM;
 283         }
 284
 285         priv->base = ioremap_nocache(res->start, resource_size(res));
 286         if (!priv->base) {
 287                 dev_err(&pdev->dev, "ioremap error.\n");
 288                 ret = -ENOMEM;
 289                 goto probe_end_kfree;
 290         }
 291
 292         /*
 293          * care platform info
 294          */
 295         priv->pfunc     = &info->platform_callback;
 296         priv->dparam    = &info->driver_param;
 297
 298         /* set driver callback functions for platform */
 299         dfunc                   = &info->driver_callback;
 300         dfunc->notify_hotplug   = usbhsc_drvcllbck_notify_hotplug;
 301
 302         /* set default param if platform doesn't have */
 303         if (!priv->dparam->pipe_type) {
 304                 priv->dparam->pipe_type = usbhsc_default_pipe_type;
 305                 priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type);
 306         }
 307         if (!priv->dparam->pio_dma_border)
 308                 priv->dparam->pio_dma_border = 64; /* 64byte */
 309
 310         /* FIXME */
 311         /* runtime power control ? */
 312         if (priv->pfunc->get_vbus)
 313                 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL);
 314
 315         /*
 316          * priv settings
 317          */
 318         priv->irq       = irq;
 319         priv->pdev      = pdev;
 320         INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
 321         spin_lock_init(usbhs_priv_to_lock(priv));
 322
 323         /* call pipe and module init */
 324         ret = usbhs_pipe_probe(priv);
 325         if (ret < 0)
 326                 goto probe_end_iounmap;
 327
 328         ret = usbhs_fifo_probe(priv);
 329         if (ret < 0)
 330                 goto probe_end_pipe_exit;
 331
 332         ret = usbhs_mod_probe(priv);
 333         if (ret < 0)
 334                 goto probe_end_fifo_exit;
 335
 336         /* dev_set_drvdata should be called after usbhs_mod_init */
 337         dev_set_drvdata(&pdev->dev, priv);
 338
 339         /*
 340          * deviece reset here because
 341          * USB device might be used in boot loader.
 342          */
 343         usbhs_sys_clock_ctrl(priv, 0);
 344
 345         /*
 346          * platform call
 347          *
 348          * USB phy setup might depend on CPU/Board.
 349          * If platform has its callback functions,
 350          * call it here.
 351          */
 352         ret = usbhs_platform_call(priv, hardware_init, pdev);
 353         if (ret < 0) {
 354                 dev_err(&pdev->dev, "platform prove failed.\n");
 355                 goto probe_end_mod_exit;
 356         }
 357
 358         /* reset phy for connection */
 359         usbhs_platform_call(priv, phy_reset, pdev);
 360
 361         /* power control */
 362         pm_runtime_enable(&pdev->dev);
 363         if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) {
 364                 usbhsc_power_ctrl(priv, 1);
 365                 usbhs_mod_autonomy_mode(priv);
 366         }
 367
 368         /*
 369          * manual call notify_hotplug for cold plug
 370          */
 371         ret = usbhsc_drvcllbck_notify_hotplug(pdev);
 372         if (ret < 0)
 373                 goto probe_end_call_remove;
 374
 375         dev_info(&pdev->dev, "probed\n");
 376
 377         return ret;
 378
 379 probe_end_call_remove:
 380         usbhs_platform_call(priv, hardware_exit, pdev);
 381 probe_end_mod_exit:
 382         usbhs_mod_remove(priv);
 383 probe_end_fifo_exit:
 384         usbhs_fifo_remove(priv);
 385 probe_end_pipe_exit:
 386         usbhs_pipe_remove(priv);
 387 probe_end_iounmap:
 388         iounmap(priv->base);
 389 probe_end_kfree:
 390         kfree(priv);
 391
 392         dev_info(&pdev->dev, "probe failed\n");
 393
 394         return ret;
 395 }
 396
 397 static int __devexit usbhs_remove(struct platform_device *pdev)
 398 {
 399         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
 400         struct renesas_usbhs_platform_info *info = pdev->dev.platform_data;
 401         struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback;
 402
 403         dev_dbg(&pdev->dev, "usb remove\n");
 404
 405         dfunc->notify_hotplug = NULL;
 406
 407         /* power off */
 408         if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL))
 409                 usbhsc_power_ctrl(priv, 0);
 410
 411         pm_runtime_disable(&pdev->dev);
 412
 413         usbhs_platform_call(priv, hardware_exit, pdev);
 414         usbhs_mod_remove(priv);
 415         usbhs_fifo_remove(priv);
 416         usbhs_pipe_remove(priv);
 417         iounmap(priv->base);
 418         kfree(priv);
 419
 420         return 0;
 421 }
 422
 423 static struct platform_driver renesas_usbhs_driver = {
 424         .driver         = {
 425                 .name   = "renesas_usbhs",
 426         },
 427         .probe          = usbhs_probe,
 428         .remove         = __devexit_p(usbhs_remove),
 429 };
 430
 431 static int __init usbhs_init(void)
 432 {
 433         return platform_driver_register(&renesas_usbhs_driver);
 434 }
 435
 436 static void __exit usbhs_exit(void)
 437 {
 438         platform_driver_unregister(&renesas_usbhs_driver);
 439 }
 440
 441 module_init(usbhs_init);
 442 module_exit(usbhs_exit);
 443
 444 MODULE_LICENSE("GPL");
 445 MODULE_DESCRIPTION("Renesas USB driver");
 446 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");