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 * local functions 151 */ 152 static void usbhsc_bus_ctrl(struct usbhs_priv *priv, int enable) 153 { 154 int wait = usbhs_get_dparam(priv, buswait_bwait); 155 u16 data = 0; 156 157 if (enable) { 158 /* set bus wait if platform have */ 159 if (wait) 160 usbhs_bset(priv, BUSWAIT, 0x000F, wait); 161 } 162 usbhs_write(priv, DVSTCTR, data); 163 } 164 165 /* 166 * platform default param 167 */ 168 static u32 usbhsc_default_pipe_type[] = { 169 USB_ENDPOINT_XFER_CONTROL, 170 USB_ENDPOINT_XFER_ISOC, 171 USB_ENDPOINT_XFER_ISOC, 172 USB_ENDPOINT_XFER_BULK, 173 USB_ENDPOINT_XFER_BULK, 174 USB_ENDPOINT_XFER_BULK, 175 USB_ENDPOINT_XFER_INT, 176 USB_ENDPOINT_XFER_INT, 177 USB_ENDPOINT_XFER_INT, 178 USB_ENDPOINT_XFER_INT, 179 }; 180 181 /* 182 * power control 183 */ 184 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable) 185 { 186 struct device *dev = usbhs_priv_to_dev(priv); 187 188 if (enable) { 189 /* enable PM */ 190 pm_runtime_get_sync(dev); 191 192 /* USB on */ 193 usbhs_sys_clock_ctrl(priv, enable); 194 usbhsc_bus_ctrl(priv, enable); 195 } else { 196 /* USB off */ 197 usbhsc_bus_ctrl(priv, enable); 198 usbhs_sys_clock_ctrl(priv, enable); 199 200 /* disable PM */ 201 pm_runtime_put_sync(dev); 202 } 203 } 204 205 /* 206 * notify hotplug 207 */ 208 static void usbhsc_notify_hotplug(struct work_struct *work) 209 { 210 struct usbhs_priv *priv = container_of(work, 211 struct usbhs_priv, 212 notify_hotplug_work.work); 213 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 214 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 215 int id; 216 int enable; 217 int ret; 218 219 /* 220 * get vbus status from platform 221 */ 222 enable = usbhs_platform_call(priv, get_vbus, pdev); 223 224 /* 225 * get id from platform 226 */ 227 id = usbhs_platform_call(priv, get_id, pdev); 228 229 if (enable && !mod) { 230 ret = usbhs_mod_change(priv, id); 231 if (ret < 0) 232 return; 233 234 dev_dbg(&pdev->dev, "%s enable\n", __func__); 235 236 /* power on */ 237 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 238 usbhsc_power_ctrl(priv, enable); 239 240 /* module start */ 241 usbhs_mod_call(priv, start, priv); 242 243 } else if (!enable && mod) { 244 dev_dbg(&pdev->dev, "%s disable\n", __func__); 245 246 /* module stop */ 247 usbhs_mod_call(priv, stop, priv); 248 249 /* power off */ 250 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 251 usbhsc_power_ctrl(priv, enable); 252 253 usbhs_mod_change(priv, -1); 254 255 /* reset phy for next connection */ 256 usbhs_platform_call(priv, phy_reset, pdev); 257 } 258 } 259 260 int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev) 261 { 262 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 263 int delay = usbhs_get_dparam(priv, detection_delay); 264 265 /* 266 * This functions will be called in interrupt. 267 * To make sure safety context, 268 * use workqueue for usbhs_notify_hotplug 269 */ 270 schedule_delayed_work(&priv->notify_hotplug_work, delay); 271 return 0; 272 } 273 274 /* 275 * platform functions 276 */ 277 static int __devinit usbhs_probe(struct platform_device *pdev) 278 { 279 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 280 struct renesas_usbhs_driver_callback *dfunc; 281 struct usbhs_priv *priv; 282 struct resource *res; 283 unsigned int irq; 284 int ret; 285 286 /* check platform information */ 287 if (!info || 288 !info->platform_callback.get_id) { 289 dev_err(&pdev->dev, "no platform information\n"); 290 return -EINVAL; 291 } 292 293 /* platform data */ 294 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 295 irq = platform_get_irq(pdev, 0); 296 if (!res || (int)irq <= 0) { 297 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n"); 298 return -ENODEV; 299 } 300 301 /* usb private data */ 302 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 303 if (!priv) { 304 dev_err(&pdev->dev, "Could not allocate priv\n"); 305 return -ENOMEM; 306 } 307 308 priv->base = ioremap_nocache(res->start, resource_size(res)); 309 if (!priv->base) { 310 dev_err(&pdev->dev, "ioremap error.\n"); 311 ret = -ENOMEM; 312 goto probe_end_kfree; 313 } 314 315 /* 316 * care platform info 317 */ 318 priv->pfunc = &info->platform_callback; 319 priv->dparam = &info->driver_param; 320 321 /* set driver callback functions for platform */ 322 dfunc = &info->driver_callback; 323 dfunc->notify_hotplug = usbhsc_drvcllbck_notify_hotplug; 324 325 /* set default param if platform doesn't have */ 326 if (!priv->dparam->pipe_type) { 327 priv->dparam->pipe_type = usbhsc_default_pipe_type; 328 priv->dparam->pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type); 329 } 330 if (!priv->dparam->pio_dma_border) 331 priv->dparam->pio_dma_border = 64; /* 64byte */ 332 333 /* FIXME */ 334 /* runtime power control ? */ 335 if (priv->pfunc->get_vbus) 336 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL); 337 338 /* 339 * priv settings 340 */ 341 priv->irq = irq; 342 priv->pdev = pdev; 343 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug); 344 spin_lock_init(usbhs_priv_to_lock(priv)); 345 346 /* call pipe and module init */ 347 ret = usbhs_pipe_probe(priv); 348 if (ret < 0) 349 goto probe_end_iounmap; 350 351 ret = usbhs_fifo_probe(priv); 352 if (ret < 0) 353 goto probe_end_pipe_exit; 354 355 ret = usbhs_mod_probe(priv); 356 if (ret < 0) 357 goto probe_end_fifo_exit; 358 359 /* dev_set_drvdata should be called after usbhs_mod_init */ 360 dev_set_drvdata(&pdev->dev, priv); 361 362 /* 363 * deviece reset here because 364 * USB device might be used in boot loader. 365 */ 366 usbhs_sys_clock_ctrl(priv, 0); 367 368 /* 369 * platform call 370 * 371 * USB phy setup might depend on CPU/Board. 372 * If platform has its callback functions, 373 * call it here. 374 */ 375 ret = usbhs_platform_call(priv, hardware_init, pdev); 376 if (ret < 0) { 377 dev_err(&pdev->dev, "platform prove failed.\n"); 378 goto probe_end_mod_exit; 379 } 380 381 /* reset phy for connection */ 382 usbhs_platform_call(priv, phy_reset, pdev); 383 384 /* power control */ 385 pm_runtime_enable(&pdev->dev); 386 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) { 387 usbhsc_power_ctrl(priv, 1); 388 usbhs_mod_autonomy_mode(priv); 389 } 390 391 /* 392 * manual call notify_hotplug for cold plug 393 */ 394 ret = usbhsc_drvcllbck_notify_hotplug(pdev); 395 if (ret < 0) 396 goto probe_end_call_remove; 397 398 dev_info(&pdev->dev, "probed\n"); 399 400 return ret; 401 402 probe_end_call_remove: 403 usbhs_platform_call(priv, hardware_exit, pdev); 404 probe_end_mod_exit: 405 usbhs_mod_remove(priv); 406 probe_end_fifo_exit: 407 usbhs_fifo_remove(priv); 408 probe_end_pipe_exit: 409 usbhs_pipe_remove(priv); 410 probe_end_iounmap: 411 iounmap(priv->base); 412 probe_end_kfree: 413 kfree(priv); 414 415 dev_info(&pdev->dev, "probe failed\n"); 416 417 return ret; 418 } 419 420 static int __devexit usbhs_remove(struct platform_device *pdev) 421 { 422 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 423 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 424 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback; 425 426 dev_dbg(&pdev->dev, "usb remove\n"); 427 428 dfunc->notify_hotplug = NULL; 429 430 /* power off */ 431 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 432 usbhsc_power_ctrl(priv, 0); 433 434 pm_runtime_disable(&pdev->dev); 435 436 usbhs_platform_call(priv, hardware_exit, pdev); 437 usbhs_mod_remove(priv); 438 usbhs_fifo_remove(priv); 439 usbhs_pipe_remove(priv); 440 iounmap(priv->base); 441 kfree(priv); 442 443 return 0; 444 } 445 446 static struct platform_driver renesas_usbhs_driver = { 447 .driver = { 448 .name = "renesas_usbhs", 449 }, 450 .probe = usbhs_probe, 451 .remove = __devexit_p(usbhs_remove), 452 }; 453 454 static int __init usbhs_init(void) 455 { 456 return platform_driver_register(&renesas_usbhs_driver); 457 } 458 459 static void __exit usbhs_exit(void) 460 { 461 platform_driver_unregister(&renesas_usbhs_driver); 462 } 463 464 module_init(usbhs_init); 465 module_exit(usbhs_exit); 466 467 MODULE_LICENSE("GPL"); 468 MODULE_DESCRIPTION("Renesas USB driver"); 469 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 470