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 308 /* FIXME */ 309 /* runtime power control ? */ 310 if (priv->pfunc->get_vbus) 311 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL); 312 313 /* 314 * priv settings 315 */ 316 priv->irq = irq; 317 priv->pdev = pdev; 318 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug); 319 spin_lock_init(usbhs_priv_to_lock(priv)); 320 321 /* call pipe and module init */ 322 ret = usbhs_pipe_probe(priv); 323 if (ret < 0) 324 goto probe_end_iounmap; 325 326 ret = usbhs_mod_probe(priv); 327 if (ret < 0) 328 goto probe_end_pipe_exit; 329 330 /* dev_set_drvdata should be called after usbhs_mod_init */ 331 dev_set_drvdata(&pdev->dev, priv); 332 333 /* 334 * deviece reset here because 335 * USB device might be used in boot loader. 336 */ 337 usbhs_sys_clock_ctrl(priv, 0); 338 339 /* 340 * platform call 341 * 342 * USB phy setup might depend on CPU/Board. 343 * If platform has its callback functions, 344 * call it here. 345 */ 346 ret = usbhs_platform_call(priv, hardware_init, pdev); 347 if (ret < 0) { 348 dev_err(&pdev->dev, "platform prove failed.\n"); 349 goto probe_end_mod_exit; 350 } 351 352 /* reset phy for connection */ 353 usbhs_platform_call(priv, phy_reset, pdev); 354 355 /* power control */ 356 pm_runtime_enable(&pdev->dev); 357 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) { 358 usbhsc_power_ctrl(priv, 1); 359 usbhs_mod_autonomy_mode(priv); 360 } 361 362 /* 363 * manual call notify_hotplug for cold plug 364 */ 365 ret = usbhsc_drvcllbck_notify_hotplug(pdev); 366 if (ret < 0) 367 goto probe_end_call_remove; 368 369 dev_info(&pdev->dev, "probed\n"); 370 371 return ret; 372 373 probe_end_call_remove: 374 usbhs_platform_call(priv, hardware_exit, pdev); 375 probe_end_mod_exit: 376 usbhs_mod_remove(priv); 377 probe_end_pipe_exit: 378 usbhs_pipe_remove(priv); 379 probe_end_iounmap: 380 iounmap(priv->base); 381 probe_end_kfree: 382 kfree(priv); 383 384 dev_info(&pdev->dev, "probe failed\n"); 385 386 return ret; 387 } 388 389 static int __devexit usbhs_remove(struct platform_device *pdev) 390 { 391 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 392 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 393 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback; 394 395 dev_dbg(&pdev->dev, "usb remove\n"); 396 397 dfunc->notify_hotplug = NULL; 398 399 /* power off */ 400 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 401 usbhsc_power_ctrl(priv, 0); 402 403 pm_runtime_disable(&pdev->dev); 404 405 usbhs_platform_call(priv, hardware_exit, pdev); 406 usbhs_mod_remove(priv); 407 usbhs_pipe_remove(priv); 408 iounmap(priv->base); 409 kfree(priv); 410 411 return 0; 412 } 413 414 static struct platform_driver renesas_usbhs_driver = { 415 .driver = { 416 .name = "renesas_usbhs", 417 }, 418 .probe = usbhs_probe, 419 .remove = __devexit_p(usbhs_remove), 420 }; 421 422 static int __init usbhs_init(void) 423 { 424 return platform_driver_register(&renesas_usbhs_driver); 425 } 426 427 static void __exit usbhs_exit(void) 428 { 429 platform_driver_unregister(&renesas_usbhs_driver); 430 } 431 432 module_init(usbhs_init); 433 module_exit(usbhs_exit); 434 435 MODULE_LICENSE("GPL"); 436 MODULE_DESCRIPTION("Renesas USB driver"); 437 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 438