drivers/usb/renesas_usbhs/common.c

   1 // SPDX-License-Identifier: GPL-1.0+
   2 /*
   3  * Renesas USB driver
   4  *
   5  * Copyright (C) 2011 Renesas Solutions Corp.
   6  * Copyright (C) 2019 Renesas Electronics Corporation
   7  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   8  */
   9 #include <linux/clk.h>
  10 #include <linux/err.h>
  11 #include <linux/gpio.h>
  12 #include <linux/io.h>
  13 #include <linux/module.h>
  14 #include <linux/of_device.h>
  15 #include <linux/of_gpio.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/reset.h>
  18 #include <linux/slab.h>
  19 #include <linux/sysfs.h>
  20 #include "common.h"
  21 #include "rcar2.h"
  22 #include "rcar3.h"
  23 #include "rza.h"
  24
  25 /*
  26  *              image of renesas_usbhs
  27  *
  28  * ex) gadget case
  29
  30  * mod.c
  31  * mod_gadget.c
  32  * mod_host.c           pipe.c          fifo.c
  33  *
  34  *                      +-------+       +-----------+
  35  *                      | pipe0 |------>| fifo pio  |
  36  * +------------+       +-------+       +-----------+
  37  * | mod_gadget |=====> | pipe1 |--+
  38  * +------------+       +-------+  |    +-----------+
  39  *                      | pipe2 |  |  +-| fifo dma0 |
  40  * +------------+       +-------+  |  | +-----------+
  41  * | mod_host   |       | pipe3 |<-|--+
  42  * +------------+       +-------+  |    +-----------+
  43  *                      | ....  |  +--->| fifo dma1 |
  44  *                      | ....  |       +-----------+
  45  */
  46
  47 /*
  48  * platform call back
  49  *
  50  * renesas usb support platform callback function.
  51  * Below macro call it.
  52  * if platform doesn't have callback, it return 0 (no error)
  53  */
  54 #define usbhs_platform_call(priv, func, args...)\
  55         (!(priv) ? -ENODEV :                    \
  56          !((priv)->pfunc->func) ? 0 :           \
  57          (priv)->pfunc->func(args))
  58
  59 /*
  60  *              common functions
  61  */
  62 u16 usbhs_read(struct usbhs_priv *priv, u32 reg)
  63 {
  64         return ioread16(priv->base + reg);
  65 }
  66
  67 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data)
  68 {
  69         iowrite16(data, priv->base + reg);
  70 }
  71
  72 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data)
  73 {
  74         u16 val = usbhs_read(priv, reg);
  75
  76         val &= ~mask;
  77         val |= data & mask;
  78
  79         usbhs_write(priv, reg, val);
  80 }
  81
  82 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev)
  83 {
  84         return dev_get_drvdata(&pdev->dev);
  85 }
  86
  87 int usbhs_get_id_as_gadget(struct platform_device *pdev)
  88 {
  89         return USBHS_GADGET;
  90 }
  91
  92 /*
  93  *              syscfg functions
  94  */
  95 static void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable)
  96 {
  97         usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0);
  98 }
  99
 100 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable)
 101 {
 102         u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
 103         u16 val  = DCFM | DRPD | HSE | USBE;
 104
 105         /*
 106          * if enable
 107          *
 108          * - select Host mode
 109          * - D+ Line/D- Line Pull-down
 110          */
 111         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
 112 }
 113
 114 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable)
 115 {
 116         u16 mask = DCFM | DRPD | DPRPU | HSE | USBE;
 117         u16 val  = HSE | USBE;
 118
 119         /* CNEN bit is required for function operation */
 120         if (usbhs_get_dparam(priv, has_cnen)) {
 121                 mask |= CNEN;
 122                 val  |= CNEN;
 123         }
 124
 125         /*
 126          * if enable
 127          *
 128          * - select Function mode
 129          * - D+ Line Pull-up is disabled
 130          *      When D+ Line Pull-up is enabled,
 131          *      calling usbhs_sys_function_pullup(,1)
 132          */
 133         usbhs_bset(priv, SYSCFG, mask, enable ? val : 0);
 134 }
 135
 136 void usbhs_sys_function_pullup(struct usbhs_priv *priv, int enable)
 137 {
 138         usbhs_bset(priv, SYSCFG, DPRPU, enable ? DPRPU : 0);
 139 }
 140
 141 void usbhs_sys_set_test_mode(struct usbhs_priv *priv, u16 mode)
 142 {
 143         usbhs_write(priv, TESTMODE, mode);
 144 }
 145
 146 /*
 147  *              frame functions
 148  */
 149 int usbhs_frame_get_num(struct usbhs_priv *priv)
 150 {
 151         return usbhs_read(priv, FRMNUM) & FRNM_MASK;
 152 }
 153
 154 /*
 155  *              usb request functions
 156  */
 157 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
 158 {
 159         u16 val;
 160
 161         val = usbhs_read(priv, USBREQ);
 162         req->bRequest           = (val >> 8) & 0xFF;
 163         req->bRequestType       = (val >> 0) & 0xFF;
 164
 165         req->wValue     = usbhs_read(priv, USBVAL);
 166         req->wIndex     = usbhs_read(priv, USBINDX);
 167         req->wLength    = usbhs_read(priv, USBLENG);
 168 }
 169
 170 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req)
 171 {
 172         usbhs_write(priv, USBREQ,  (req->bRequest << 8) | req->bRequestType);
 173         usbhs_write(priv, USBVAL,  req->wValue);
 174         usbhs_write(priv, USBINDX, req->wIndex);
 175         usbhs_write(priv, USBLENG, req->wLength);
 176
 177         usbhs_bset(priv, DCPCTR, SUREQ, SUREQ);
 178 }
 179
 180 /*
 181  *              bus/vbus functions
 182  */
 183 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv)
 184 {
 185         u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT);
 186
 187         if (status != USBRST) {
 188                 struct device *dev = usbhs_priv_to_dev(priv);
 189                 dev_err(dev, "usbhs should be reset\n");
 190         }
 191
 192         usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT);
 193 }
 194
 195 void usbhs_bus_send_reset(struct usbhs_priv *priv)
 196 {
 197         usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST);
 198 }
 199
 200 int usbhs_bus_get_speed(struct usbhs_priv *priv)
 201 {
 202         u16 dvstctr = usbhs_read(priv, DVSTCTR);
 203
 204         switch (RHST & dvstctr) {
 205         case RHST_LOW_SPEED:
 206                 return USB_SPEED_LOW;
 207         case RHST_FULL_SPEED:
 208                 return USB_SPEED_FULL;
 209         case RHST_HIGH_SPEED:
 210                 return USB_SPEED_HIGH;
 211         }
 212
 213         return USB_SPEED_UNKNOWN;
 214 }
 215
 216 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable)
 217 {
 218         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
 219
 220         return usbhs_platform_call(priv, set_vbus, pdev, enable);
 221 }
 222
 223 static void usbhsc_bus_init(struct usbhs_priv *priv)
 224 {
 225         usbhs_write(priv, DVSTCTR, 0);
 226
 227         usbhs_vbus_ctrl(priv, 0);
 228 }
 229
 230 /*
 231  *              device configuration
 232  */
 233 int usbhs_set_device_config(struct usbhs_priv *priv, int devnum,
 234                            u16 upphub, u16 hubport, u16 speed)
 235 {
 236         struct device *dev = usbhs_priv_to_dev(priv);
 237         u16 usbspd = 0;
 238         u32 reg = DEVADD0 + (2 * devnum);
 239
 240         if (devnum > 10) {
 241                 dev_err(dev, "cannot set speed to unknown device %d\n", devnum);
 242                 return -EIO;
 243         }
 244
 245         if (upphub > 0xA) {
 246                 dev_err(dev, "unsupported hub number %d\n", upphub);
 247                 return -EIO;
 248         }
 249
 250         switch (speed) {
 251         case USB_SPEED_LOW:
 252                 usbspd = USBSPD_SPEED_LOW;
 253                 break;
 254         case USB_SPEED_FULL:
 255                 usbspd = USBSPD_SPEED_FULL;
 256                 break;
 257         case USB_SPEED_HIGH:
 258                 usbspd = USBSPD_SPEED_HIGH;
 259                 break;
 260         default:
 261                 dev_err(dev, "unsupported speed %d\n", speed);
 262                 return -EIO;
 263         }
 264
 265         usbhs_write(priv, reg,  UPPHUB(upphub)  |
 266                                 HUBPORT(hubport)|
 267                                 USBSPD(usbspd));
 268
 269         return 0;
 270 }
 271
 272 /*
 273  *              interrupt functions
 274  */
 275 void usbhs_xxxsts_clear(struct usbhs_priv *priv, u16 sts_reg, u16 bit)
 276 {
 277         u16 pipe_mask = (u16)GENMASK(usbhs_get_dparam(priv, pipe_size), 0);
 278
 279         usbhs_write(priv, sts_reg, ~(1 << bit) & pipe_mask);
 280 }
 281
 282 /*
 283  *              local functions
 284  */
 285 static void usbhsc_set_buswait(struct usbhs_priv *priv)
 286 {
 287         int wait = usbhs_get_dparam(priv, buswait_bwait);
 288
 289         /* set bus wait if platform have */
 290         if (wait)
 291                 usbhs_bset(priv, BUSWAIT, 0x000F, wait);
 292 }
 293
 294 static bool usbhsc_is_multi_clks(struct usbhs_priv *priv)
 295 {
 296         return priv->dparam.multi_clks;
 297 }
 298
 299 static int usbhsc_clk_get(struct device *dev, struct usbhs_priv *priv)
 300 {
 301         if (!usbhsc_is_multi_clks(priv))
 302                 return 0;
 303
 304         /* The first clock should exist */
 305         priv->clks[0] = of_clk_get(dev_of_node(dev), 0);
 306         if (IS_ERR(priv->clks[0]))
 307                 return PTR_ERR(priv->clks[0]);
 308
 309         /*
 310          * To backward compatibility with old DT, this driver checks the return
 311          * value if it's -ENOENT or not.
 312          */
 313         priv->clks[1] = of_clk_get(dev_of_node(dev), 1);
 314         if (PTR_ERR(priv->clks[1]) == -ENOENT)
 315                 priv->clks[1] = NULL;
 316         else if (IS_ERR(priv->clks[1]))
 317                 return PTR_ERR(priv->clks[1]);
 318
 319         return 0;
 320 }
 321
 322 static void usbhsc_clk_put(struct usbhs_priv *priv)
 323 {
 324         int i;
 325
 326         if (!usbhsc_is_multi_clks(priv))
 327                 return;
 328
 329         for (i = 0; i < ARRAY_SIZE(priv->clks); i++)
 330                 clk_put(priv->clks[i]);
 331 }
 332
 333 static int usbhsc_clk_prepare_enable(struct usbhs_priv *priv)
 334 {
 335         int i, ret;
 336
 337         if (!usbhsc_is_multi_clks(priv))
 338                 return 0;
 339
 340         for (i = 0; i < ARRAY_SIZE(priv->clks); i++) {
 341                 ret = clk_prepare_enable(priv->clks[i]);
 342                 if (ret) {
 343                         while (--i >= 0)
 344                                 clk_disable_unprepare(priv->clks[i]);
 345                         return ret;
 346                 }
 347         }
 348
 349         return ret;
 350 }
 351
 352 static void usbhsc_clk_disable_unprepare(struct usbhs_priv *priv)
 353 {
 354         int i;
 355
 356         if (!usbhsc_is_multi_clks(priv))
 357                 return;
 358
 359         for (i = 0; i < ARRAY_SIZE(priv->clks); i++)
 360                 clk_disable_unprepare(priv->clks[i]);
 361 }
 362
 363 /*
 364  *              platform default param
 365  */
 366
 367 /* commonly used on old SH-Mobile SoCs */
 368 static struct renesas_usbhs_driver_pipe_config usbhsc_default_pipe[] = {
 369         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_CONTROL, 64, 0x00, false),
 370         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x08, false),
 371         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x18, false),
 372         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x28, true),
 373         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x38, true),
 374         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x48, true),
 375         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x04, false),
 376         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x05, false),
 377         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x06, false),
 378         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x07, false),
 379 };
 380
 381 /* commonly used on newer SH-Mobile and R-Car SoCs */
 382 static struct renesas_usbhs_driver_pipe_config usbhsc_new_pipe[] = {
 383         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_CONTROL, 64, 0x00, false),
 384         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x08, true),
 385         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_ISOC, 1024, 0x28, true),
 386         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x48, true),
 387         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x58, true),
 388         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x68, true),
 389         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x04, false),
 390         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x05, false),
 391         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_INT, 64, 0x06, false),
 392         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x78, true),
 393         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x88, true),
 394         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0x98, true),
 395         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xa8, true),
 396         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xb8, true),
 397         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xc8, true),
 398         RENESAS_USBHS_PIPE(USB_ENDPOINT_XFER_BULK, 512, 0xd8, true),
 399 };
 400
 401 /*
 402  *              power control
 403  */
 404 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable)
 405 {
 406         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
 407         struct device *dev = usbhs_priv_to_dev(priv);
 408
 409         if (enable) {
 410                 /* enable PM */
 411                 pm_runtime_get_sync(dev);
 412
 413                 /* enable clks */
 414                 if (usbhsc_clk_prepare_enable(priv))
 415                         return;
 416
 417                 /* enable platform power */
 418                 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
 419
 420                 /* USB on */
 421                 usbhs_sys_clock_ctrl(priv, enable);
 422         } else {
 423                 /* USB off */
 424                 usbhs_sys_clock_ctrl(priv, enable);
 425
 426                 /* disable platform power */
 427                 usbhs_platform_call(priv, power_ctrl, pdev, priv->base, enable);
 428
 429                 /* disable clks */
 430                 usbhsc_clk_disable_unprepare(priv);
 431
 432                 /* disable PM */
 433                 pm_runtime_put_sync(dev);
 434         }
 435 }
 436
 437 /*
 438  *              hotplug
 439  */
 440 static void usbhsc_hotplug(struct usbhs_priv *priv)
 441 {
 442         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
 443         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 444         int id;
 445         int enable;
 446         int cable;
 447         int ret;
 448
 449         /*
 450          * get vbus status from platform
 451          */
 452         enable = usbhs_mod_info_call(priv, get_vbus, pdev);
 453
 454         /*
 455          * get id from platform
 456          */
 457         id = usbhs_platform_call(priv, get_id, pdev);
 458
 459         if (enable && !mod) {
 460                 if (priv->edev) {
 461                         cable = extcon_get_state(priv->edev, EXTCON_USB_HOST);
 462                         if ((cable > 0 && id != USBHS_HOST) ||
 463                             (!cable && id != USBHS_GADGET)) {
 464                                 dev_info(&pdev->dev,
 465                                          "USB cable plugged in doesn't match the selected role!\n");
 466                                 return;
 467                         }
 468                 }
 469
 470                 ret = usbhs_mod_change(priv, id);
 471                 if (ret < 0)
 472                         return;
 473
 474                 dev_dbg(&pdev->dev, "%s enable\n", __func__);
 475
 476                 /* power on */
 477                 if (usbhs_get_dparam(priv, runtime_pwctrl))
 478                         usbhsc_power_ctrl(priv, enable);
 479
 480                 /* bus init */
 481                 usbhsc_set_buswait(priv);
 482                 usbhsc_bus_init(priv);
 483
 484                 /* module start */
 485                 usbhs_mod_call(priv, start, priv);
 486
 487         } else if (!enable && mod) {
 488                 dev_dbg(&pdev->dev, "%s disable\n", __func__);
 489
 490                 /* module stop */
 491                 usbhs_mod_call(priv, stop, priv);
 492
 493                 /* bus init */
 494                 usbhsc_bus_init(priv);
 495
 496                 /* power off */
 497                 if (usbhs_get_dparam(priv, runtime_pwctrl))
 498                         usbhsc_power_ctrl(priv, enable);
 499
 500                 usbhs_mod_change(priv, -1);
 501
 502                 /* reset phy for next connection */
 503                 usbhs_platform_call(priv, phy_reset, pdev);
 504         }
 505 }
 506
 507 /*
 508  *              notify hotplug
 509  */
 510 static void usbhsc_notify_hotplug(struct work_struct *work)
 511 {
 512         struct usbhs_priv *priv = container_of(work,
 513                                                struct usbhs_priv,
 514                                                notify_hotplug_work.work);
 515         usbhsc_hotplug(priv);
 516 }
 517
 518 int usbhsc_schedule_notify_hotplug(struct platform_device *pdev)
 519 {
 520         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
 521         int delay = usbhs_get_dparam(priv, detection_delay);
 522
 523         /*
 524          * This functions will be called in interrupt.
 525          * To make sure safety context,
 526          * use workqueue for usbhs_notify_hotplug
 527          */
 528         schedule_delayed_work(&priv->notify_hotplug_work,
 529                               msecs_to_jiffies(delay));
 530         return 0;
 531 }
 532
 533 /*
 534  *              platform functions
 535  */
 536 static const struct of_device_id usbhs_of_match[] = {
 537         {
 538                 .compatible = "renesas,usbhs-r8a774c0",
 539                 .data = &usbhs_rcar_gen3_with_pll_plat_info,
 540         },
 541         {
 542                 .compatible = "renesas,usbhs-r8a7790",
 543                 .data = &usbhs_rcar_gen2_plat_info,
 544         },
 545         {
 546                 .compatible = "renesas,usbhs-r8a7791",
 547                 .data = &usbhs_rcar_gen2_plat_info,
 548         },
 549         {
 550                 .compatible = "renesas,usbhs-r8a7794",
 551                 .data = &usbhs_rcar_gen2_plat_info,
 552         },
 553         {
 554                 .compatible = "renesas,usbhs-r8a7795",
 555                 .data = &usbhs_rcar_gen3_plat_info,
 556         },
 557         {
 558                 .compatible = "renesas,usbhs-r8a7796",
 559                 .data = &usbhs_rcar_gen3_plat_info,
 560         },
 561         {
 562                 .compatible = "renesas,usbhs-r8a77990",
 563                 .data = &usbhs_rcar_gen3_with_pll_plat_info,
 564         },
 565         {
 566                 .compatible = "renesas,usbhs-r8a77995",
 567                 .data = &usbhs_rcar_gen3_with_pll_plat_info,
 568         },
 569         {
 570                 .compatible = "renesas,rcar-gen2-usbhs",
 571                 .data = &usbhs_rcar_gen2_plat_info,
 572         },
 573         {
 574                 .compatible = "renesas,rcar-gen3-usbhs",
 575                 .data = &usbhs_rcar_gen3_plat_info,
 576         },
 577         {
 578                 .compatible = "renesas,rza1-usbhs",
 579                 .data = &usbhs_rza1_plat_info,
 580         },
 581         {
 582                 .compatible = "renesas,rza2-usbhs",
 583                 .data = &usbhs_rza2_plat_info,
 584         },
 585         { },
 586 };
 587 MODULE_DEVICE_TABLE(of, usbhs_of_match);
 588
 589 static int usbhs_probe(struct platform_device *pdev)
 590 {
 591         const struct renesas_usbhs_platform_info *info;
 592         struct usbhs_priv *priv;
 593         struct resource *res, *irq_res;
 594         struct device *dev = &pdev->dev;
 595         int ret, gpio;
 596         u32 tmp;
 597
 598         /* check device node */
 599         if (dev_of_node(dev))
 600                 info = of_device_get_match_data(dev);
 601         else
 602                 info = renesas_usbhs_get_info(pdev);
 603
 604         /* check platform information */
 605         if (!info) {
 606                 dev_err(dev, "no platform information\n");
 607                 return -EINVAL;
 608         }
 609
 610         /* platform data */
 611         irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 612         if (!irq_res) {
 613                 dev_err(dev, "Not enough Renesas USB platform resources.\n");
 614                 return -ENODEV;
 615         }
 616
 617         /* usb private data */
 618         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 619         if (!priv)
 620                 return -ENOMEM;
 621
 622         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 623         priv->base = devm_ioremap_resource(&pdev->dev, res);
 624         if (IS_ERR(priv->base))
 625                 return PTR_ERR(priv->base);
 626
 627         if (of_property_read_bool(dev_of_node(dev), "extcon")) {
 628                 priv->edev = extcon_get_edev_by_phandle(dev, 0);
 629                 if (IS_ERR(priv->edev))
 630                         return PTR_ERR(priv->edev);
 631         }
 632
 633         priv->rsts = devm_reset_control_array_get_optional_shared(dev);
 634         if (IS_ERR(priv->rsts))
 635                 return PTR_ERR(priv->rsts);
 636
 637         /*
 638          * care platform info
 639          */
 640
 641         priv->dparam = info->driver_param;
 642
 643         if (!info->platform_callback.get_id) {
 644                 dev_err(dev, "no platform callbacks\n");
 645                 return -EINVAL;
 646         }
 647         priv->pfunc = &info->platform_callback;
 648
 649         /* set default param if platform doesn't have */
 650         if (usbhs_get_dparam(priv, has_new_pipe_configs)) {
 651                 priv->dparam.pipe_configs = usbhsc_new_pipe;
 652                 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_new_pipe);
 653         } else if (!priv->dparam.pipe_configs) {
 654                 priv->dparam.pipe_configs = usbhsc_default_pipe;
 655                 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe);
 656         }
 657         if (!priv->dparam.pio_dma_border)
 658                 priv->dparam.pio_dma_border = 64; /* 64byte */
 659         if (!of_property_read_u32(dev_of_node(dev), "renesas,buswait", &tmp))
 660                 priv->dparam.buswait_bwait = tmp;
 661         gpio = of_get_named_gpio_flags(dev_of_node(dev), "renesas,enable-gpio",
 662                                        0, NULL);
 663         if (gpio > 0)
 664                 priv->dparam.enable_gpio = gpio;
 665
 666         /* FIXME */
 667         /* runtime power control ? */
 668         if (priv->pfunc->get_vbus)
 669                 usbhs_get_dparam(priv, runtime_pwctrl) = 1;
 670
 671         /*
 672          * priv settings
 673          */
 674         priv->irq       = irq_res->start;
 675         if (irq_res->flags & IORESOURCE_IRQ_SHAREABLE)
 676                 priv->irqflags = IRQF_SHARED;
 677         priv->pdev      = pdev;
 678         INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug);
 679         spin_lock_init(usbhs_priv_to_lock(priv));
 680
 681         /* call pipe and module init */
 682         ret = usbhs_pipe_probe(priv);
 683         if (ret < 0)
 684                 return ret;
 685
 686         ret = usbhs_fifo_probe(priv);
 687         if (ret < 0)
 688                 goto probe_end_pipe_exit;
 689
 690         ret = usbhs_mod_probe(priv);
 691         if (ret < 0)
 692                 goto probe_end_fifo_exit;
 693
 694         /* dev_set_drvdata should be called after usbhs_mod_init */
 695         platform_set_drvdata(pdev, priv);
 696
 697         ret = reset_control_deassert(priv->rsts);
 698         if (ret)
 699                 goto probe_fail_rst;
 700
 701         ret = usbhsc_clk_get(dev, priv);
 702         if (ret)
 703                 goto probe_fail_clks;
 704
 705         /*
 706          * deviece reset here because
 707          * USB device might be used in boot loader.
 708          */
 709         usbhs_sys_clock_ctrl(priv, 0);
 710
 711         /* check GPIO determining if USB function should be enabled */
 712         if (priv->dparam.enable_gpio) {
 713                 gpio_request_one(priv->dparam.enable_gpio, GPIOF_IN, NULL);
 714                 ret = !gpio_get_value(priv->dparam.enable_gpio);
 715                 gpio_free(priv->dparam.enable_gpio);
 716                 if (ret) {
 717                         dev_warn(dev, "USB function not selected (GPIO %d)\n",
 718                                  priv->dparam.enable_gpio);
 719                         ret = -ENOTSUPP;
 720                         goto probe_end_mod_exit;
 721                 }
 722         }
 723
 724         /*
 725          * platform call
 726          *
 727          * USB phy setup might depend on CPU/Board.
 728          * If platform has its callback functions,
 729          * call it here.
 730          */
 731         ret = usbhs_platform_call(priv, hardware_init, pdev);
 732         if (ret < 0) {
 733                 dev_err(dev, "platform init failed.\n");
 734                 goto probe_end_mod_exit;
 735         }
 736
 737         /* reset phy for connection */
 738         usbhs_platform_call(priv, phy_reset, pdev);
 739
 740         /* power control */
 741         pm_runtime_enable(dev);
 742         if (!usbhs_get_dparam(priv, runtime_pwctrl)) {
 743                 usbhsc_power_ctrl(priv, 1);
 744                 usbhs_mod_autonomy_mode(priv);
 745         } else {
 746                 usbhs_mod_non_autonomy_mode(priv);
 747         }
 748
 749         /*
 750          * manual call notify_hotplug for cold plug
 751          */
 752         usbhsc_schedule_notify_hotplug(pdev);
 753
 754         dev_info(dev, "probed\n");
 755
 756         return ret;
 757
 758 probe_end_mod_exit:
 759         usbhsc_clk_put(priv);
 760 probe_fail_clks:
 761         reset_control_assert(priv->rsts);
 762 probe_fail_rst:
 763         usbhs_mod_remove(priv);
 764 probe_end_fifo_exit:
 765         usbhs_fifo_remove(priv);
 766 probe_end_pipe_exit:
 767         usbhs_pipe_remove(priv);
 768
 769         dev_info(dev, "probe failed (%d)\n", ret);
 770
 771         return ret;
 772 }
 773
 774 static int usbhs_remove(struct platform_device *pdev)
 775 {
 776         struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev);
 777
 778         dev_dbg(&pdev->dev, "usb remove\n");
 779
 780         /* power off */
 781         if (!usbhs_get_dparam(priv, runtime_pwctrl))
 782                 usbhsc_power_ctrl(priv, 0);
 783
 784         pm_runtime_disable(&pdev->dev);
 785
 786         usbhs_platform_call(priv, hardware_exit, pdev);
 787         usbhsc_clk_put(priv);
 788         reset_control_assert(priv->rsts);
 789         usbhs_mod_remove(priv);
 790         usbhs_fifo_remove(priv);
 791         usbhs_pipe_remove(priv);
 792
 793         return 0;
 794 }
 795
 796 static __maybe_unused int usbhsc_suspend(struct device *dev)
 797 {
 798         struct usbhs_priv *priv = dev_get_drvdata(dev);
 799         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
 800
 801         if (mod) {
 802                 usbhs_mod_call(priv, stop, priv);
 803                 usbhs_mod_change(priv, -1);
 804         }
 805
 806         if (mod || !usbhs_get_dparam(priv, runtime_pwctrl))
 807                 usbhsc_power_ctrl(priv, 0);
 808
 809         return 0;
 810 }
 811
 812 static __maybe_unused int usbhsc_resume(struct device *dev)
 813 {
 814         struct usbhs_priv *priv = dev_get_drvdata(dev);
 815         struct platform_device *pdev = usbhs_priv_to_pdev(priv);
 816
 817         if (!usbhs_get_dparam(priv, runtime_pwctrl)) {
 818                 usbhsc_power_ctrl(priv, 1);
 819                 usbhs_mod_autonomy_mode(priv);
 820         }
 821
 822         usbhs_platform_call(priv, phy_reset, pdev);
 823
 824         usbhsc_schedule_notify_hotplug(pdev);
 825
 826         return 0;
 827 }
 828
 829 static SIMPLE_DEV_PM_OPS(usbhsc_pm_ops, usbhsc_suspend, usbhsc_resume);
 830
 831 static struct platform_driver renesas_usbhs_driver = {
 832         .driver         = {
 833                 .name   = "renesas_usbhs",
 834                 .pm     = &usbhsc_pm_ops,
 835                 .of_match_table = of_match_ptr(usbhs_of_match),
 836         },
 837         .probe          = usbhs_probe,
 838         .remove         = usbhs_remove,
 839 };
 840
 841 module_platform_driver(renesas_usbhs_driver);
 842
 843 MODULE_LICENSE("GPL");
 844 MODULE_DESCRIPTION("Renesas USB driver");
 845 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");