Pileus Git - ~andy/linux/blob - drivers/usb/otg/fsl_otg.c

   1 /*
   2  * Copyright (C) 2007,2008 Freescale semiconductor, Inc.
   3  *
   4  * Author: Li Yang <LeoLi@freescale.com>
   5  *         Jerry Huang <Chang-Ming.Huang@freescale.com>
   6  *
   7  * Initialization based on code from Shlomi Gridish.
   8  *
   9  * This program is free software; you can redistribute  it and/or modify it
  10  * under  the terms of  the GNU General  Public License as published by the
  11  * Free Software Foundation;  either version 2 of the  License, or (at your
  12  * option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the  GNU General Public License along
  20  * with this program; if not, write  to the Free Software Foundation, Inc.,
  21  * 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/kernel.h>
  26 #include <linux/delay.h>
  27 #include <linux/slab.h>
  28 #include <linux/proc_fs.h>
  29 #include <linux/errno.h>
  30 #include <linux/init.h>
  31 #include <linux/interrupt.h>
  32 #include <linux/io.h>
  33 #include <linux/timer.h>
  34 #include <linux/usb.h>
  35 #include <linux/device.h>
  36 #include <linux/usb/ch9.h>
  37 #include <linux/usb/gadget.h>
  38 #include <linux/workqueue.h>
  39 #include <linux/time.h>
  40 #include <linux/fsl_devices.h>
  41 #include <linux/platform_device.h>
  42 #include <linux/uaccess.h>
  43
  44 #include <asm/unaligned.h>
  45
  46 #include "fsl_otg.h"
  47
  48 #define DRIVER_VERSION "Rev. 1.55"
  49 #define DRIVER_AUTHOR "Jerry Huang/Li Yang"
  50 #define DRIVER_DESC "Freescale USB OTG Transceiver Driver"
  51 #define DRIVER_INFO DRIVER_DESC " " DRIVER_VERSION
  52
  53 static const char driver_name[] = "fsl-usb2-otg";
  54
  55 const pm_message_t otg_suspend_state = {
  56         .event = 1,
  57 };
  58
  59 #define HA_DATA_PULSE
  60
  61 static struct usb_dr_mmap *usb_dr_regs;
  62 static struct fsl_otg *fsl_otg_dev;
  63 static int srp_wait_done;
  64
  65 /* FSM timers */
  66 struct fsl_otg_timer *a_wait_vrise_tmr, *a_wait_bcon_tmr, *a_aidl_bdis_tmr,
  67         *b_ase0_brst_tmr, *b_se0_srp_tmr;
  68
  69 /* Driver specific timers */
  70 struct fsl_otg_timer *b_data_pulse_tmr, *b_vbus_pulse_tmr, *b_srp_fail_tmr,
  71         *b_srp_wait_tmr, *a_wait_enum_tmr;
  72
  73 static struct list_head active_timers;
  74
  75 static struct fsl_otg_config fsl_otg_initdata = {
  76         .otg_port = 1,
  77 };
  78
  79 #ifdef CONFIG_PPC32
  80 static u32 _fsl_readl_be(const unsigned __iomem *p)
  81 {
  82         return in_be32(p);
  83 }
  84
  85 static u32 _fsl_readl_le(const unsigned __iomem *p)
  86 {
  87         return in_le32(p);
  88 }
  89
  90 static void _fsl_writel_be(u32 v, unsigned __iomem *p)
  91 {
  92         out_be32(p, v);
  93 }
  94
  95 static void _fsl_writel_le(u32 v, unsigned __iomem *p)
  96 {
  97         out_le32(p, v);
  98 }
  99
 100 static u32 (*_fsl_readl)(const unsigned __iomem *p);
 101 static void (*_fsl_writel)(u32 v, unsigned __iomem *p);
 102
 103 #define fsl_readl(p)            (*_fsl_readl)((p))
 104 #define fsl_writel(v, p)        (*_fsl_writel)((v), (p))
 105
 106 #else
 107 #define fsl_readl(addr)         readl(addr)
 108 #define fsl_writel(val, addr)   writel(val, addr)
 109 #endif /* CONFIG_PPC32 */
 110
 111 /* Routines to access transceiver ULPI registers */
 112 u8 view_ulpi(u8 addr)
 113 {
 114         u32 temp;
 115
 116         temp = 0x40000000 | (addr << 16);
 117         fsl_writel(temp, &usb_dr_regs->ulpiview);
 118         udelay(1000);
 119         while (temp & 0x40)
 120                 temp = fsl_readl(&usb_dr_regs->ulpiview);
 121         return (le32_to_cpu(temp) & 0x0000ff00) >> 8;
 122 }
 123
 124 int write_ulpi(u8 addr, u8 data)
 125 {
 126         u32 temp;
 127
 128         temp = 0x60000000 | (addr << 16) | data;
 129         fsl_writel(temp, &usb_dr_regs->ulpiview);
 130         return 0;
 131 }
 132
 133 /* -------------------------------------------------------------*/
 134 /* Operations that will be called from OTG Finite State Machine */
 135
 136 /* Charge vbus for vbus pulsing in SRP */
 137 void fsl_otg_chrg_vbus(int on)
 138 {
 139         u32 tmp;
 140
 141         tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
 142
 143         if (on)
 144                 /* stop discharging, start charging */
 145                 tmp = (tmp & ~OTGSC_CTRL_VBUS_DISCHARGE) |
 146                         OTGSC_CTRL_VBUS_CHARGE;
 147         else
 148                 /* stop charging */
 149                 tmp &= ~OTGSC_CTRL_VBUS_CHARGE;
 150
 151         fsl_writel(tmp, &usb_dr_regs->otgsc);
 152 }
 153
 154 /* Discharge vbus through a resistor to ground */
 155 void fsl_otg_dischrg_vbus(int on)
 156 {
 157         u32 tmp;
 158
 159         tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
 160
 161         if (on)
 162                 /* stop charging, start discharging */
 163                 tmp = (tmp & ~OTGSC_CTRL_VBUS_CHARGE) |
 164                         OTGSC_CTRL_VBUS_DISCHARGE;
 165         else
 166                 /* stop discharging */
 167                 tmp &= ~OTGSC_CTRL_VBUS_DISCHARGE;
 168
 169         fsl_writel(tmp, &usb_dr_regs->otgsc);
 170 }
 171
 172 /* A-device driver vbus, controlled through PP bit in PORTSC */
 173 void fsl_otg_drv_vbus(int on)
 174 {
 175         u32 tmp;
 176
 177         if (on) {
 178                 tmp = fsl_readl(&usb_dr_regs->portsc) & ~PORTSC_W1C_BITS;
 179                 fsl_writel(tmp | PORTSC_PORT_POWER, &usb_dr_regs->portsc);
 180         } else {
 181                 tmp = fsl_readl(&usb_dr_regs->portsc) &
 182                       ~PORTSC_W1C_BITS & ~PORTSC_PORT_POWER;
 183                 fsl_writel(tmp, &usb_dr_regs->portsc);
 184         }
 185 }
 186
 187 /*
 188  * Pull-up D+, signalling connect by periperal. Also used in
 189  * data-line pulsing in SRP
 190  */
 191 void fsl_otg_loc_conn(int on)
 192 {
 193         u32 tmp;
 194
 195         tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
 196
 197         if (on)
 198                 tmp |= OTGSC_CTRL_DATA_PULSING;
 199         else
 200                 tmp &= ~OTGSC_CTRL_DATA_PULSING;
 201
 202         fsl_writel(tmp, &usb_dr_regs->otgsc);
 203 }
 204
 205 /*
 206  * Generate SOF by host.  This is controlled through suspend/resume the
 207  * port.  In host mode, controller will automatically send SOF.
 208  * Suspend will block the data on the port.
 209  */
 210 void fsl_otg_loc_sof(int on)
 211 {
 212         u32 tmp;
 213
 214         tmp = fsl_readl(&fsl_otg_dev->dr_mem_map->portsc) & ~PORTSC_W1C_BITS;
 215         if (on)
 216                 tmp |= PORTSC_PORT_FORCE_RESUME;
 217         else
 218                 tmp |= PORTSC_PORT_SUSPEND;
 219
 220         fsl_writel(tmp, &fsl_otg_dev->dr_mem_map->portsc);
 221
 222 }
 223
 224 /* Start SRP pulsing by data-line pulsing, followed with v-bus pulsing. */
 225 void fsl_otg_start_pulse(void)
 226 {
 227         u32 tmp;
 228
 229         srp_wait_done = 0;
 230 #ifdef HA_DATA_PULSE
 231         tmp = fsl_readl(&usb_dr_regs->otgsc) & ~OTGSC_INTSTS_MASK;
 232         tmp |= OTGSC_HA_DATA_PULSE;
 233         fsl_writel(tmp, &usb_dr_regs->otgsc);
 234 #else
 235         fsl_otg_loc_conn(1);
 236 #endif
 237
 238         fsl_otg_add_timer(b_data_pulse_tmr);
 239 }
 240
 241 void b_data_pulse_end(unsigned long foo)
 242 {
 243 #ifdef HA_DATA_PULSE
 244 #else
 245         fsl_otg_loc_conn(0);
 246 #endif
 247
 248         /* Do VBUS pulse after data pulse */
 249         fsl_otg_pulse_vbus();
 250 }
 251
 252 void fsl_otg_pulse_vbus(void)
 253 {
 254         srp_wait_done = 0;
 255         fsl_otg_chrg_vbus(1);
 256         /* start the timer to end vbus charge */
 257         fsl_otg_add_timer(b_vbus_pulse_tmr);
 258 }
 259
 260 void b_vbus_pulse_end(unsigned long foo)
 261 {
 262         fsl_otg_chrg_vbus(0);
 263
 264         /*
 265          * As USB3300 using the same a_sess_vld and b_sess_vld voltage
 266          * we need to discharge the bus for a while to distinguish
 267          * residual voltage of vbus pulsing and A device pull up
 268          */
 269         fsl_otg_dischrg_vbus(1);
 270         fsl_otg_add_timer(b_srp_wait_tmr);
 271 }
 272
 273 void b_srp_end(unsigned long foo)
 274 {
 275         fsl_otg_dischrg_vbus(0);
 276         srp_wait_done = 1;
 277
 278         if ((fsl_otg_dev->phy.state == OTG_STATE_B_SRP_INIT) &&
 279             fsl_otg_dev->fsm.b_sess_vld)
 280                 fsl_otg_dev->fsm.b_srp_done = 1;
 281 }
 282
 283 /*
 284  * Workaround for a_host suspending too fast.  When a_bus_req=0,
 285  * a_host will start by SRP.  It needs to set b_hnp_enable before
 286  * actually suspending to start HNP
 287  */
 288 void a_wait_enum(unsigned long foo)
 289 {
 290         VDBG("a_wait_enum timeout\n");
 291         if (!fsl_otg_dev->phy.otg->host->b_hnp_enable)
 292                 fsl_otg_add_timer(a_wait_enum_tmr);
 293         else
 294                 otg_statemachine(&fsl_otg_dev->fsm);
 295 }
 296
 297 /* The timeout callback function to set time out bit */
 298 void set_tmout(unsigned long indicator)
 299 {
 300         *(int *)indicator = 1;
 301 }
 302
 303 /* Initialize timers */
 304 int fsl_otg_init_timers(struct otg_fsm *fsm)
 305 {
 306         /* FSM used timers */
 307         a_wait_vrise_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_VRISE,
 308                                 (unsigned long)&fsm->a_wait_vrise_tmout);
 309         if (!a_wait_vrise_tmr)
 310                 return -ENOMEM;
 311
 312         a_wait_bcon_tmr = otg_timer_initializer(&set_tmout, TA_WAIT_BCON,
 313                                 (unsigned long)&fsm->a_wait_bcon_tmout);
 314         if (!a_wait_bcon_tmr)
 315                 return -ENOMEM;
 316
 317         a_aidl_bdis_tmr = otg_timer_initializer(&set_tmout, TA_AIDL_BDIS,
 318                                 (unsigned long)&fsm->a_aidl_bdis_tmout);
 319         if (!a_aidl_bdis_tmr)
 320                 return -ENOMEM;
 321
 322         b_ase0_brst_tmr = otg_timer_initializer(&set_tmout, TB_ASE0_BRST,
 323                                 (unsigned long)&fsm->b_ase0_brst_tmout);
 324         if (!b_ase0_brst_tmr)
 325                 return -ENOMEM;
 326
 327         b_se0_srp_tmr = otg_timer_initializer(&set_tmout, TB_SE0_SRP,
 328                                 (unsigned long)&fsm->b_se0_srp);
 329         if (!b_se0_srp_tmr)
 330                 return -ENOMEM;
 331
 332         b_srp_fail_tmr = otg_timer_initializer(&set_tmout, TB_SRP_FAIL,
 333                                 (unsigned long)&fsm->b_srp_done);
 334         if (!b_srp_fail_tmr)
 335                 return -ENOMEM;
 336
 337         a_wait_enum_tmr = otg_timer_initializer(&a_wait_enum, 10,
 338                                 (unsigned long)&fsm);
 339         if (!a_wait_enum_tmr)
 340                 return -ENOMEM;
 341
 342         /* device driver used timers */
 343         b_srp_wait_tmr = otg_timer_initializer(&b_srp_end, TB_SRP_WAIT, 0);
 344         if (!b_srp_wait_tmr)
 345                 return -ENOMEM;
 346
 347         b_data_pulse_tmr = otg_timer_initializer(&b_data_pulse_end,
 348                                 TB_DATA_PLS, 0);
 349         if (!b_data_pulse_tmr)
 350                 return -ENOMEM;
 351
 352         b_vbus_pulse_tmr = otg_timer_initializer(&b_vbus_pulse_end,
 353                                 TB_VBUS_PLS, 0);
 354         if (!b_vbus_pulse_tmr)
 355                 return -ENOMEM;
 356
 357         return 0;
 358 }
 359
 360 /* Uninitialize timers */
 361 void fsl_otg_uninit_timers(void)
 362 {
 363         /* FSM used timers */
 364         if (a_wait_vrise_tmr != NULL)
 365                 kfree(a_wait_vrise_tmr);
 366         if (a_wait_bcon_tmr != NULL)
 367                 kfree(a_wait_bcon_tmr);
 368         if (a_aidl_bdis_tmr != NULL)
 369                 kfree(a_aidl_bdis_tmr);
 370         if (b_ase0_brst_tmr != NULL)
 371                 kfree(b_ase0_brst_tmr);
 372         if (b_se0_srp_tmr != NULL)
 373                 kfree(b_se0_srp_tmr);
 374         if (b_srp_fail_tmr != NULL)
 375                 kfree(b_srp_fail_tmr);
 376         if (a_wait_enum_tmr != NULL)
 377                 kfree(a_wait_enum_tmr);
 378
 379         /* device driver used timers */
 380         if (b_srp_wait_tmr != NULL)
 381                 kfree(b_srp_wait_tmr);
 382         if (b_data_pulse_tmr != NULL)
 383                 kfree(b_data_pulse_tmr);
 384         if (b_vbus_pulse_tmr != NULL)
 385                 kfree(b_vbus_pulse_tmr);
 386 }
 387
 388 /* Add timer to timer list */
 389 void fsl_otg_add_timer(void *gtimer)
 390 {
 391         struct fsl_otg_timer *timer = gtimer;
 392         struct fsl_otg_timer *tmp_timer;
 393
 394         /*
 395          * Check if the timer is already in the active list,
 396          * if so update timer count
 397          */
 398         list_for_each_entry(tmp_timer, &active_timers, list)
 399             if (tmp_timer == timer) {
 400                 timer->count = timer->expires;
 401                 return;
 402         }
 403         timer->count = timer->expires;
 404         list_add_tail(&timer->list, &active_timers);
 405 }
 406
 407 /* Remove timer from the timer list; clear timeout status */
 408 void fsl_otg_del_timer(void *gtimer)
 409 {
 410         struct fsl_otg_timer *timer = gtimer;
 411         struct fsl_otg_timer *tmp_timer, *del_tmp;
 412
 413         list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list)
 414                 if (tmp_timer == timer)
 415                         list_del(&timer->list);
 416 }
 417
 418 /*
 419  * Reduce timer count by 1, and find timeout conditions.
 420  * Called by fsl_otg 1ms timer interrupt
 421  */
 422 int fsl_otg_tick_timer(void)
 423 {
 424         struct fsl_otg_timer *tmp_timer, *del_tmp;
 425         int expired = 0;
 426
 427         list_for_each_entry_safe(tmp_timer, del_tmp, &active_timers, list) {
 428                 tmp_timer->count--;
 429                 /* check if timer expires */
 430                 if (!tmp_timer->count) {
 431                         list_del(&tmp_timer->list);
 432                         tmp_timer->function(tmp_timer->data);
 433                         expired = 1;
 434                 }
 435         }
 436
 437         return expired;
 438 }
 439
 440 /* Reset controller, not reset the bus */
 441 void otg_reset_controller(void)
 442 {
 443         u32 command;
 444
 445         command = fsl_readl(&usb_dr_regs->usbcmd);
 446         command |= (1 << 1);
 447         fsl_writel(command, &usb_dr_regs->usbcmd);
 448         while (fsl_readl(&usb_dr_regs->usbcmd) & (1 << 1))
 449                 ;
 450 }
 451
 452 /* Call suspend/resume routines in host driver */
 453 int fsl_otg_start_host(struct otg_fsm *fsm, int on)
 454 {
 455         struct usb_otg *otg = fsm->otg;
 456         struct device *dev;
 457         struct fsl_otg *otg_dev = container_of(otg->phy, struct fsl_otg, phy);
 458         u32 retval = 0;
 459
 460         if (!otg->host)
 461                 return -ENODEV;
 462         dev = otg->host->controller;
 463
 464         /*
 465          * Update a_vbus_vld state as a_vbus_vld int is disabled
 466          * in device mode
 467          */
 468         fsm->a_vbus_vld =
 469                 !!(fsl_readl(&usb_dr_regs->otgsc) & OTGSC_STS_A_VBUS_VALID);
 470         if (on) {
 471                 /* start fsl usb host controller */
 472                 if (otg_dev->host_working)
 473                         goto end;
 474                 else {
 475                         otg_reset_controller();
 476                         VDBG("host on......\n");
 477                         if (dev->driver->pm && dev->driver->pm->resume) {
 478                                 retval = dev->driver->pm->resume(dev);
 479                                 if (fsm->id) {
 480                                         /* default-b */
 481                                         fsl_otg_drv_vbus(1);
 482                                         /*
 483                                          * Workaround: b_host can't driver
 484                                          * vbus, but PP in PORTSC needs to
 485                                          * be 1 for host to work.
 486                                          * So we set drv_vbus bit in
 487                                          * transceiver to 0 thru ULPI.
 488                                          */
 489                                         write_ulpi(0x0c, 0x20);
 490                                 }
 491                         }
 492
 493                         otg_dev->host_working = 1;
 494                 }
 495         } else {
 496                 /* stop fsl usb host controller */
 497                 if (!otg_dev->host_working)
 498                         goto end;
 499                 else {
 500                         VDBG("host off......\n");
 501                         if (dev && dev->driver) {
 502                                 if (dev->driver->pm && dev->driver->pm->suspend)
 503                                         retval = dev->driver->pm->suspend(dev);
 504                                 if (fsm->id)
 505                                         /* default-b */
 506                                         fsl_otg_drv_vbus(0);
 507                         }
 508                         otg_dev->host_working = 0;
 509                 }
 510         }
 511 end:
 512         return retval;
 513 }
 514
 515 /*
 516  * Call suspend and resume function in udc driver
 517  * to stop and start udc driver.
 518  */
 519 int fsl_otg_start_gadget(struct otg_fsm *fsm, int on)
 520 {
 521         struct usb_otg *otg = fsm->otg;
 522         struct device *dev;
 523
 524         if (!otg->gadget || !otg->gadget->dev.parent)
 525                 return -ENODEV;
 526
 527         VDBG("gadget %s\n", on ? "on" : "off");
 528         dev = otg->gadget->dev.parent;
 529
 530         if (on) {
 531                 if (dev->driver->resume)
 532                         dev->driver->resume(dev);
 533         } else {
 534                 if (dev->driver->suspend)
 535                         dev->driver->suspend(dev, otg_suspend_state);
 536         }
 537
 538         return 0;
 539 }
 540
 541 /*
 542  * Called by initialization code of host driver.  Register host controller
 543  * to the OTG.  Suspend host for OTG role detection.
 544  */
 545 static int fsl_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
 546 {
 547         struct fsl_otg *otg_dev;
 548
 549         if (!otg)
 550                 return -ENODEV;
 551
 552         otg_dev = container_of(otg->phy, struct fsl_otg, phy);
 553         if (otg_dev != fsl_otg_dev)
 554                 return -ENODEV;
 555
 556         otg->host = host;
 557
 558         otg_dev->fsm.a_bus_drop = 0;
 559         otg_dev->fsm.a_bus_req = 1;
 560
 561         if (host) {
 562                 VDBG("host off......\n");
 563
 564                 otg->host->otg_port = fsl_otg_initdata.otg_port;
 565                 otg->host->is_b_host = otg_dev->fsm.id;
 566                 /*
 567                  * must leave time for khubd to finish its thing
 568                  * before yanking the host driver out from under it,
 569                  * so suspend the host after a short delay.
 570                  */
 571                 otg_dev->host_working = 1;
 572                 schedule_delayed_work(&otg_dev->otg_event, 100);
 573                 return 0;
 574         } else {
 575                 /* host driver going away */
 576                 if (!(fsl_readl(&otg_dev->dr_mem_map->otgsc) &
 577                       OTGSC_STS_USB_ID)) {
 578                         /* Mini-A cable connected */
 579                         struct otg_fsm *fsm = &otg_dev->fsm;
 580
 581                         otg->phy->state = OTG_STATE_UNDEFINED;
 582                         fsm->protocol = PROTO_UNDEF;
 583                 }
 584         }
 585
 586         otg_dev->host_working = 0;
 587
 588         otg_statemachine(&otg_dev->fsm);
 589
 590         return 0;
 591 }
 592
 593 /* Called by initialization code of udc.  Register udc to OTG. */
 594 static int fsl_otg_set_peripheral(struct usb_otg *otg,
 595                                         struct usb_gadget *gadget)
 596 {
 597         struct fsl_otg *otg_dev;
 598
 599         if (!otg)
 600                 return -ENODEV;
 601
 602         otg_dev = container_of(otg->phy, struct fsl_otg, phy);
 603         VDBG("otg_dev 0x%x\n", (int)otg_dev);
 604         VDBG("fsl_otg_dev 0x%x\n", (int)fsl_otg_dev);
 605         if (otg_dev != fsl_otg_dev)
 606                 return -ENODEV;
 607
 608         if (!gadget) {
 609                 if (!otg->default_a)
 610                         otg->gadget->ops->vbus_draw(otg->gadget, 0);
 611                 usb_gadget_vbus_disconnect(otg->gadget);
 612                 otg->gadget = 0;
 613                 otg_dev->fsm.b_bus_req = 0;
 614                 otg_statemachine(&otg_dev->fsm);
 615                 return 0;
 616         }
 617
 618         otg->gadget = gadget;
 619         otg->gadget->is_a_peripheral = !otg_dev->fsm.id;
 620
 621         otg_dev->fsm.b_bus_req = 1;
 622
 623         /* start the gadget right away if the ID pin says Mini-B */
 624         DBG("ID pin=%d\n", otg_dev->fsm.id);
 625         if (otg_dev->fsm.id == 1) {
 626                 fsl_otg_start_host(&otg_dev->fsm, 0);
 627                 otg_drv_vbus(&otg_dev->fsm, 0);
 628                 fsl_otg_start_gadget(&otg_dev->fsm, 1);
 629         }
 630
 631         return 0;
 632 }
 633
 634 /* Set OTG port power, only for B-device */
 635 static int fsl_otg_set_power(struct usb_phy *phy, unsigned mA)
 636 {
 637         if (!fsl_otg_dev)
 638                 return -ENODEV;
 639         if (phy->state == OTG_STATE_B_PERIPHERAL)
 640                 pr_info("FSL OTG: Draw %d mA\n", mA);
 641
 642         return 0;
 643 }
 644
 645 /*
 646  * Delayed pin detect interrupt processing.
 647  *
 648  * When the Mini-A cable is disconnected from the board,
 649  * the pin-detect interrupt happens before the disconnect
 650  * interrupts for the connected device(s).  In order to
 651  * process the disconnect interrupt(s) prior to switching
 652  * roles, the pin-detect interrupts are delayed, and handled
 653  * by this routine.
 654  */
 655 static void fsl_otg_event(struct work_struct *work)
 656 {
 657         struct fsl_otg *og = container_of(work, struct fsl_otg, otg_event.work);
 658         struct otg_fsm *fsm = &og->fsm;
 659
 660         if (fsm->id) {          /* switch to gadget */
 661                 fsl_otg_start_host(fsm, 0);
 662                 otg_drv_vbus(fsm, 0);
 663                 fsl_otg_start_gadget(fsm, 1);
 664         }
 665 }
 666
 667 /* B-device start SRP */
 668 static int fsl_otg_start_srp(struct usb_otg *otg)
 669 {
 670         struct fsl_otg *otg_dev;
 671
 672         if (!otg || otg->phy->state != OTG_STATE_B_IDLE)
 673                 return -ENODEV;
 674
 675         otg_dev = container_of(otg->phy, struct fsl_otg, phy);
 676         if (otg_dev != fsl_otg_dev)
 677                 return -ENODEV;
 678
 679         otg_dev->fsm.b_bus_req = 1;
 680         otg_statemachine(&otg_dev->fsm);
 681
 682         return 0;
 683 }
 684
 685 /* A_host suspend will call this function to start hnp */
 686 static int fsl_otg_start_hnp(struct usb_otg *otg)
 687 {
 688         struct fsl_otg *otg_dev;
 689
 690         if (!otg)
 691                 return -ENODEV;
 692
 693         otg_dev = container_of(otg->phy, struct fsl_otg, phy);
 694         if (otg_dev != fsl_otg_dev)
 695                 return -ENODEV;
 696
 697         DBG("start_hnp...n");
 698
 699         /* clear a_bus_req to enter a_suspend state */
 700         otg_dev->fsm.a_bus_req = 0;
 701         otg_statemachine(&otg_dev->fsm);
 702
 703         return 0;
 704 }
 705
 706 /*
 707  * Interrupt handler.  OTG/host/peripheral share the same int line.
 708  * OTG driver clears OTGSC interrupts and leaves USB interrupts
 709  * intact.  It needs to have knowledge of some USB interrupts
 710  * such as port change.
 711  */
 712 irqreturn_t fsl_otg_isr(int irq, void *dev_id)
 713 {
 714         struct otg_fsm *fsm = &((struct fsl_otg *)dev_id)->fsm;
 715         struct usb_otg *otg = ((struct fsl_otg *)dev_id)->phy.otg;
 716         u32 otg_int_src, otg_sc;
 717
 718         otg_sc = fsl_readl(&usb_dr_regs->otgsc);
 719         otg_int_src = otg_sc & OTGSC_INTSTS_MASK & (otg_sc >> 8);
 720
 721         /* Only clear otg interrupts */
 722         fsl_writel(otg_sc, &usb_dr_regs->otgsc);
 723
 724         /*FIXME: ID change not generate when init to 0 */
 725         fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
 726         otg->default_a = (fsm->id == 0);
 727
 728         /* process OTG interrupts */
 729         if (otg_int_src) {
 730                 if (otg_int_src & OTGSC_INTSTS_USB_ID) {
 731                         fsm->id = (otg_sc & OTGSC_STS_USB_ID) ? 1 : 0;
 732                         otg->default_a = (fsm->id == 0);
 733                         /* clear conn information */
 734                         if (fsm->id)
 735                                 fsm->b_conn = 0;
 736                         else
 737                                 fsm->a_conn = 0;
 738
 739                         if (otg->host)
 740                                 otg->host->is_b_host = fsm->id;
 741                         if (otg->gadget)
 742                                 otg->gadget->is_a_peripheral = !fsm->id;
 743                         VDBG("ID int (ID is %d)\n", fsm->id);
 744
 745                         if (fsm->id) {  /* switch to gadget */
 746                                 schedule_delayed_work(
 747                                         &((struct fsl_otg *)dev_id)->otg_event,
 748                                         100);
 749                         } else {        /* switch to host */
 750                                 cancel_delayed_work(&
 751                                                     ((struct fsl_otg *)dev_id)->
 752                                                     otg_event);
 753                                 fsl_otg_start_gadget(fsm, 0);
 754                                 otg_drv_vbus(fsm, 1);
 755                                 fsl_otg_start_host(fsm, 1);
 756                         }
 757                         return IRQ_HANDLED;
 758                 }
 759         }
 760         return IRQ_NONE;
 761 }
 762
 763 static struct otg_fsm_ops fsl_otg_ops = {
 764         .chrg_vbus = fsl_otg_chrg_vbus,
 765         .drv_vbus = fsl_otg_drv_vbus,
 766         .loc_conn = fsl_otg_loc_conn,
 767         .loc_sof = fsl_otg_loc_sof,
 768         .start_pulse = fsl_otg_start_pulse,
 769
 770         .add_timer = fsl_otg_add_timer,
 771         .del_timer = fsl_otg_del_timer,
 772
 773         .start_host = fsl_otg_start_host,
 774         .start_gadget = fsl_otg_start_gadget,
 775 };
 776
 777 /* Initialize the global variable fsl_otg_dev and request IRQ for OTG */
 778 static int fsl_otg_conf(struct platform_device *pdev)
 779 {
 780         struct fsl_otg *fsl_otg_tc;
 781         int status;
 782
 783         if (fsl_otg_dev)
 784                 return 0;
 785
 786         /* allocate space to fsl otg device */
 787         fsl_otg_tc = kzalloc(sizeof(struct fsl_otg), GFP_KERNEL);
 788         if (!fsl_otg_tc)
 789                 return -ENOMEM;
 790
 791         fsl_otg_tc->phy.otg = kzalloc(sizeof(struct usb_otg), GFP_KERNEL);
 792         if (!fsl_otg_tc->phy.otg) {
 793                 kfree(fsl_otg_tc);
 794                 return -ENOMEM;
 795         }
 796
 797         INIT_DELAYED_WORK(&fsl_otg_tc->otg_event, fsl_otg_event);
 798
 799         INIT_LIST_HEAD(&active_timers);
 800         status = fsl_otg_init_timers(&fsl_otg_tc->fsm);
 801         if (status) {
 802                 pr_info("Couldn't init OTG timers\n");
 803                 goto err;
 804         }
 805         spin_lock_init(&fsl_otg_tc->fsm.lock);
 806
 807         /* Set OTG state machine operations */
 808         fsl_otg_tc->fsm.ops = &fsl_otg_ops;
 809
 810         /* initialize the otg structure */
 811         fsl_otg_tc->phy.label = DRIVER_DESC;
 812         fsl_otg_tc->phy.set_power = fsl_otg_set_power;
 813
 814         fsl_otg_tc->phy.otg->phy = &fsl_otg_tc->phy;
 815         fsl_otg_tc->phy.otg->set_host = fsl_otg_set_host;
 816         fsl_otg_tc->phy.otg->set_peripheral = fsl_otg_set_peripheral;
 817         fsl_otg_tc->phy.otg->start_hnp = fsl_otg_start_hnp;
 818         fsl_otg_tc->phy.otg->start_srp = fsl_otg_start_srp;
 819
 820         fsl_otg_dev = fsl_otg_tc;
 821
 822         /* Store the otg transceiver */
 823         status = usb_add_phy(&fsl_otg_tc->phy, USB_PHY_TYPE_USB2);
 824         if (status) {
 825                 pr_warn(FSL_OTG_NAME ": unable to register OTG transceiver.\n");
 826                 goto err;
 827         }
 828
 829         return 0;
 830 err:
 831         fsl_otg_uninit_timers();
 832         kfree(fsl_otg_tc->phy.otg);
 833         kfree(fsl_otg_tc);
 834         return status;
 835 }
 836
 837 /* OTG Initialization */
 838 int usb_otg_start(struct platform_device *pdev)
 839 {
 840         struct fsl_otg *p_otg;
 841         struct usb_phy *otg_trans = usb_get_phy(USB_PHY_TYPE_USB2);
 842         struct otg_fsm *fsm;
 843         int status;
 844         struct resource *res;
 845         u32 temp;
 846         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
 847
 848         p_otg = container_of(otg_trans, struct fsl_otg, phy);
 849         fsm = &p_otg->fsm;
 850
 851         /* Initialize the state machine structure with default values */
 852         SET_OTG_STATE(otg_trans, OTG_STATE_UNDEFINED);
 853         fsm->otg = p_otg->phy.otg;
 854
 855         /* We don't require predefined MEM/IRQ resource index */
 856         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 857         if (!res)
 858                 return -ENXIO;
 859
 860         /* We don't request_mem_region here to enable resource sharing
 861          * with host/device */
 862
 863         usb_dr_regs = ioremap(res->start, sizeof(struct usb_dr_mmap));
 864         p_otg->dr_mem_map = (struct usb_dr_mmap *)usb_dr_regs;
 865         pdata->regs = (void *)usb_dr_regs;
 866
 867         if (pdata->init && pdata->init(pdev) != 0)
 868                 return -EINVAL;
 869
 870         if (pdata->big_endian_mmio) {
 871                 _fsl_readl = _fsl_readl_be;
 872                 _fsl_writel = _fsl_writel_be;
 873         } else {
 874                 _fsl_readl = _fsl_readl_le;
 875                 _fsl_writel = _fsl_writel_le;
 876         }
 877
 878         /* request irq */
 879         p_otg->irq = platform_get_irq(pdev, 0);
 880         status = request_irq(p_otg->irq, fsl_otg_isr,
 881                                 IRQF_SHARED, driver_name, p_otg);
 882         if (status) {
 883                 dev_dbg(p_otg->phy.dev, "can't get IRQ %d, error %d\n",
 884                         p_otg->irq, status);
 885                 iounmap(p_otg->dr_mem_map);
 886                 kfree(p_otg->phy.otg);
 887                 kfree(p_otg);
 888                 return status;
 889         }
 890
 891         /* stop the controller */
 892         temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
 893         temp &= ~USB_CMD_RUN_STOP;
 894         fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
 895
 896         /* reset the controller */
 897         temp = fsl_readl(&p_otg->dr_mem_map->usbcmd);
 898         temp |= USB_CMD_CTRL_RESET;
 899         fsl_writel(temp, &p_otg->dr_mem_map->usbcmd);
 900
 901         /* wait reset completed */
 902         while (fsl_readl(&p_otg->dr_mem_map->usbcmd) & USB_CMD_CTRL_RESET)
 903                 ;
 904
 905         /* configure the VBUSHS as IDLE(both host and device) */
 906         temp = USB_MODE_STREAM_DISABLE | (pdata->es ? USB_MODE_ES : 0);
 907         fsl_writel(temp, &p_otg->dr_mem_map->usbmode);
 908
 909         /* configure PHY interface */
 910         temp = fsl_readl(&p_otg->dr_mem_map->portsc);
 911         temp &= ~(PORTSC_PHY_TYPE_SEL | PORTSC_PTW);
 912         switch (pdata->phy_mode) {
 913         case FSL_USB2_PHY_ULPI:
 914                 temp |= PORTSC_PTS_ULPI;
 915                 break;
 916         case FSL_USB2_PHY_UTMI_WIDE:
 917                 temp |= PORTSC_PTW_16BIT;
 918                 /* fall through */
 919         case FSL_USB2_PHY_UTMI:
 920                 temp |= PORTSC_PTS_UTMI;
 921                 /* fall through */
 922         default:
 923                 break;
 924         }
 925         fsl_writel(temp, &p_otg->dr_mem_map->portsc);
 926
 927         if (pdata->have_sysif_regs) {
 928                 /* configure control enable IO output, big endian register */
 929                 temp = __raw_readl(&p_otg->dr_mem_map->control);
 930                 temp |= USB_CTRL_IOENB;
 931                 __raw_writel(temp, &p_otg->dr_mem_map->control);
 932         }
 933
 934         /* disable all interrupt and clear all OTGSC status */
 935         temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
 936         temp &= ~OTGSC_INTERRUPT_ENABLE_BITS_MASK;
 937         temp |= OTGSC_INTERRUPT_STATUS_BITS_MASK | OTGSC_CTRL_VBUS_DISCHARGE;
 938         fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
 939
 940         /*
 941          * The identification (id) input is FALSE when a Mini-A plug is inserted
 942          * in the devices Mini-AB receptacle. Otherwise, this input is TRUE.
 943          * Also: record initial state of ID pin
 944          */
 945         if (fsl_readl(&p_otg->dr_mem_map->otgsc) & OTGSC_STS_USB_ID) {
 946                 p_otg->phy.state = OTG_STATE_UNDEFINED;
 947                 p_otg->fsm.id = 1;
 948         } else {
 949                 p_otg->phy.state = OTG_STATE_A_IDLE;
 950                 p_otg->fsm.id = 0;
 951         }
 952
 953         DBG("initial ID pin=%d\n", p_otg->fsm.id);
 954
 955         /* enable OTG ID pin interrupt */
 956         temp = fsl_readl(&p_otg->dr_mem_map->otgsc);
 957         temp |= OTGSC_INTR_USB_ID_EN;
 958         temp &= ~(OTGSC_CTRL_VBUS_DISCHARGE | OTGSC_INTR_1MS_TIMER_EN);
 959         fsl_writel(temp, &p_otg->dr_mem_map->otgsc);
 960
 961         return 0;
 962 }
 963
 964 /*
 965  * state file in sysfs
 966  */
 967 static int show_fsl_usb2_otg_state(struct device *dev,
 968                                    struct device_attribute *attr, char *buf)
 969 {
 970         struct otg_fsm *fsm = &fsl_otg_dev->fsm;
 971         char *next = buf;
 972         unsigned size = PAGE_SIZE;
 973         unsigned long flags;
 974         int t;
 975
 976         spin_lock_irqsave(&fsm->lock, flags);
 977
 978         /* basic driver infomation */
 979         t = scnprintf(next, size,
 980                         DRIVER_DESC "\n" "fsl_usb2_otg version: %s\n\n",
 981                         DRIVER_VERSION);
 982         size -= t;
 983         next += t;
 984
 985         /* Registers */
 986         t = scnprintf(next, size,
 987                         "OTGSC:   0x%08x\n"
 988                         "PORTSC:  0x%08x\n"
 989                         "USBMODE: 0x%08x\n"
 990                         "USBCMD:  0x%08x\n"
 991                         "USBSTS:  0x%08x\n"
 992                         "USBINTR: 0x%08x\n",
 993                         fsl_readl(&usb_dr_regs->otgsc),
 994                         fsl_readl(&usb_dr_regs->portsc),
 995                         fsl_readl(&usb_dr_regs->usbmode),
 996                         fsl_readl(&usb_dr_regs->usbcmd),
 997                         fsl_readl(&usb_dr_regs->usbsts),
 998                         fsl_readl(&usb_dr_regs->usbintr));
 999         size -= t;
1000         next += t;
1001
1002         /* State */
1003         t = scnprintf(next, size,
1004                       "OTG state: %s\n\n",
1005                       otg_state_string(fsl_otg_dev->phy.state));
1006         size -= t;
1007         next += t;
1008
1009         /* State Machine Variables */
1010         t = scnprintf(next, size,
1011                         "a_bus_req: %d\n"
1012                         "b_bus_req: %d\n"
1013                         "a_bus_resume: %d\n"
1014                         "a_bus_suspend: %d\n"
1015                         "a_conn: %d\n"
1016                         "a_sess_vld: %d\n"
1017                         "a_srp_det: %d\n"
1018                         "a_vbus_vld: %d\n"
1019                         "b_bus_resume: %d\n"
1020                         "b_bus_suspend: %d\n"
1021                         "b_conn: %d\n"
1022                         "b_se0_srp: %d\n"
1023                         "b_sess_end: %d\n"
1024                         "b_sess_vld: %d\n"
1025                         "id: %d\n",
1026                         fsm->a_bus_req,
1027                         fsm->b_bus_req,
1028                         fsm->a_bus_resume,
1029                         fsm->a_bus_suspend,
1030                         fsm->a_conn,
1031                         fsm->a_sess_vld,
1032                         fsm->a_srp_det,
1033                         fsm->a_vbus_vld,
1034                         fsm->b_bus_resume,
1035                         fsm->b_bus_suspend,
1036                         fsm->b_conn,
1037                         fsm->b_se0_srp,
1038                         fsm->b_sess_end,
1039                         fsm->b_sess_vld,
1040                         fsm->id);
1041         size -= t;
1042         next += t;
1043
1044         spin_unlock_irqrestore(&fsm->lock, flags);
1045
1046         return PAGE_SIZE - size;
1047 }
1048
1049 static DEVICE_ATTR(fsl_usb2_otg_state, S_IRUGO, show_fsl_usb2_otg_state, NULL);
1050
1051
1052 /* Char driver interface to control some OTG input */
1053
1054 /*
1055  * Handle some ioctl command, such as get otg
1056  * status and set host suspend
1057  */
1058 static long fsl_otg_ioctl(struct file *file, unsigned int cmd,
1059                           unsigned long arg)
1060 {
1061         u32 retval = 0;
1062
1063         switch (cmd) {
1064         case GET_OTG_STATUS:
1065                 retval = fsl_otg_dev->host_working;
1066                 break;
1067
1068         case SET_A_SUSPEND_REQ:
1069                 fsl_otg_dev->fsm.a_suspend_req = arg;
1070                 break;
1071
1072         case SET_A_BUS_DROP:
1073                 fsl_otg_dev->fsm.a_bus_drop = arg;
1074                 break;
1075
1076         case SET_A_BUS_REQ:
1077                 fsl_otg_dev->fsm.a_bus_req = arg;
1078                 break;
1079
1080         case SET_B_BUS_REQ:
1081                 fsl_otg_dev->fsm.b_bus_req = arg;
1082                 break;
1083
1084         default:
1085                 break;
1086         }
1087
1088         otg_statemachine(&fsl_otg_dev->fsm);
1089
1090         return retval;
1091 }
1092
1093 static int fsl_otg_open(struct inode *inode, struct file *file)
1094 {
1095         return 0;
1096 }
1097
1098 static int fsl_otg_release(struct inode *inode, struct file *file)
1099 {
1100         return 0;
1101 }
1102
1103 static const struct file_operations otg_fops = {
1104         .owner = THIS_MODULE,
1105         .llseek = NULL,
1106         .read = NULL,
1107         .write = NULL,
1108         .unlocked_ioctl = fsl_otg_ioctl,
1109         .open = fsl_otg_open,
1110         .release = fsl_otg_release,
1111 };
1112
1113 static int fsl_otg_probe(struct platform_device *pdev)
1114 {
1115         int ret;
1116
1117         if (!pdev->dev.platform_data)
1118                 return -ENODEV;
1119
1120         /* configure the OTG */
1121         ret = fsl_otg_conf(pdev);
1122         if (ret) {
1123                 dev_err(&pdev->dev, "Couldn't configure OTG module\n");
1124                 return ret;
1125         }
1126
1127         /* start OTG */
1128         ret = usb_otg_start(pdev);
1129         if (ret) {
1130                 dev_err(&pdev->dev, "Can't init FSL OTG device\n");
1131                 return ret;
1132         }
1133
1134         ret = register_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME, &otg_fops);
1135         if (ret) {
1136                 dev_err(&pdev->dev, "unable to register FSL OTG device\n");
1137                 return ret;
1138         }
1139
1140         ret = device_create_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
1141         if (ret)
1142                 dev_warn(&pdev->dev, "Can't register sysfs attribute\n");
1143
1144         return ret;
1145 }
1146
1147 static int fsl_otg_remove(struct platform_device *pdev)
1148 {
1149         struct fsl_usb2_platform_data *pdata = pdev->dev.platform_data;
1150
1151         usb_remove_phy(&fsl_otg_dev->phy);
1152         free_irq(fsl_otg_dev->irq, fsl_otg_dev);
1153
1154         iounmap((void *)usb_dr_regs);
1155
1156         fsl_otg_uninit_timers();
1157         kfree(fsl_otg_dev->phy.otg);
1158         kfree(fsl_otg_dev);
1159
1160         device_remove_file(&pdev->dev, &dev_attr_fsl_usb2_otg_state);
1161
1162         unregister_chrdev(FSL_OTG_MAJOR, FSL_OTG_NAME);
1163
1164         if (pdata->exit)
1165                 pdata->exit(pdev);
1166
1167         return 0;
1168 }
1169
1170 struct platform_driver fsl_otg_driver = {
1171         .probe = fsl_otg_probe,
1172         .remove = fsl_otg_remove,
1173         .driver = {
1174                 .name = driver_name,
1175                 .owner = THIS_MODULE,
1176         },
1177 };
1178
1179 module_platform_driver(fsl_otg_driver);
1180
1181 MODULE_DESCRIPTION(DRIVER_INFO);
1182 MODULE_AUTHOR(DRIVER_AUTHOR);
1183 MODULE_LICENSE("GPL");