drivers/i2c/chips/isp1301_omap.c

   1 /*
   2  * isp1301_omap - ISP 1301 USB transceiver, talking to OMAP OTG controller
   3  *
   4  * Copyright (C) 2004 Texas Instruments
   5  * Copyright (C) 2004 David Brownell
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/usb/ch9.h>
  29 #include <linux/usb/gadget.h>
  30 #include <linux/usb.h>
  31 #include <linux/usb/otg.h>
  32 #include <linux/i2c.h>
  33 #include <linux/workqueue.h>
  34
  35 #include <asm/irq.h>
  36 #include <mach/usb.h>
  37
  38
  39 #ifndef DEBUG
  40 #undef  VERBOSE
  41 #endif
  42
  43
  44 #define DRIVER_VERSION  "24 August 2004"
  45 #define DRIVER_NAME     (isp1301_driver.driver.name)
  46
  47 MODULE_DESCRIPTION("ISP1301 USB OTG Transceiver Driver");
  48 MODULE_LICENSE("GPL");
  49
  50 struct isp1301 {
  51         struct otg_transceiver  otg;
  52         struct i2c_client       *client;
  53         void                    (*i2c_release)(struct device *dev);
  54
  55         int                     irq_type;
  56
  57         u32                     last_otg_ctrl;
  58         unsigned                working:1;
  59
  60         struct timer_list       timer;
  61
  62         /* use keventd context to change the state for us */
  63         struct work_struct      work;
  64
  65         unsigned long           todo;
  66 #               define WORK_UPDATE_ISP  0       /* update ISP from OTG */
  67 #               define WORK_UPDATE_OTG  1       /* update OTG from ISP */
  68 #               define WORK_HOST_RESUME 4       /* resume host */
  69 #               define WORK_TIMER       6       /* timer fired */
  70 #               define WORK_STOP        7       /* don't resubmit */
  71 };
  72
  73
  74 /* bits in OTG_CTRL */
  75
  76 #define OTG_XCEIV_OUTPUTS \
  77         (OTG_ASESSVLD|OTG_BSESSEND|OTG_BSESSVLD|OTG_VBUSVLD|OTG_ID)
  78 #define OTG_XCEIV_INPUTS \
  79         (OTG_PULLDOWN|OTG_PULLUP|OTG_DRV_VBUS|OTG_PD_VBUS|OTG_PU_VBUS|OTG_PU_ID)
  80 #define OTG_CTRL_BITS \
  81         (OTG_A_BUSREQ|OTG_A_SETB_HNPEN|OTG_B_BUSREQ|OTG_B_HNPEN|OTG_BUSDROP)
  82         /* and OTG_PULLUP is sometimes written */
  83
  84 #define OTG_CTRL_MASK   (OTG_DRIVER_SEL| \
  85         OTG_XCEIV_OUTPUTS|OTG_XCEIV_INPUTS| \
  86         OTG_CTRL_BITS)
  87
  88
  89 /*-------------------------------------------------------------------------*/
  90
  91 #ifdef  CONFIG_MACH_OMAP_H2
  92
  93 /* board-specific PM hooks */
  94
  95 #include <asm/gpio.h>
  96 #include <mach/mux.h>
  97 #include <asm/mach-types.h>
  98
  99
 100 #if     defined(CONFIG_TPS65010) || defined(CONFIG_TPS65010_MODULE)
 101
 102 #include <linux/i2c/tps65010.h>
 103
 104 #else
 105
 106 static inline int tps65010_set_vbus_draw(unsigned mA)
 107 {
 108         pr_debug("tps65010: draw %d mA (STUB)\n", mA);
 109         return 0;
 110 }
 111
 112 #endif
 113
 114 static void enable_vbus_draw(struct isp1301 *isp, unsigned mA)
 115 {
 116         int status = tps65010_set_vbus_draw(mA);
 117         if (status < 0)
 118                 pr_debug("  VBUS %d mA error %d\n", mA, status);
 119 }
 120
 121 static void enable_vbus_source(struct isp1301 *isp)
 122 {
 123         /* this board won't supply more than 8mA vbus power.
 124          * some boards can switch a 100ma "unit load" (or more).
 125          */
 126 }
 127
 128
 129 /* products will deliver OTG messages with LEDs, GUI, etc */
 130 static inline void notresponding(struct isp1301 *isp)
 131 {
 132         printk(KERN_NOTICE "OTG device not responding.\n");
 133 }
 134
 135
 136 #endif
 137
 138 /*-------------------------------------------------------------------------*/
 139
 140 static struct i2c_driver isp1301_driver;
 141
 142 /* smbus apis are used for portability */
 143
 144 static inline u8
 145 isp1301_get_u8(struct isp1301 *isp, u8 reg)
 146 {
 147         return i2c_smbus_read_byte_data(isp->client, reg + 0);
 148 }
 149
 150 static inline int
 151 isp1301_get_u16(struct isp1301 *isp, u8 reg)
 152 {
 153         return i2c_smbus_read_word_data(isp->client, reg);
 154 }
 155
 156 static inline int
 157 isp1301_set_bits(struct isp1301 *isp, u8 reg, u8 bits)
 158 {
 159         return i2c_smbus_write_byte_data(isp->client, reg + 0, bits);
 160 }
 161
 162 static inline int
 163 isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 164 {
 165         return i2c_smbus_write_byte_data(isp->client, reg + 1, bits);
 166 }
 167
 168 /*-------------------------------------------------------------------------*/
 169
 170 /* identification */
 171 #define ISP1301_VENDOR_ID               0x00    /* u16 read */
 172 #define ISP1301_PRODUCT_ID              0x02    /* u16 read */
 173 #define ISP1301_BCD_DEVICE              0x14    /* u16 read */
 174
 175 #define I2C_VENDOR_ID_PHILIPS           0x04cc
 176 #define I2C_PRODUCT_ID_PHILIPS_1301     0x1301
 177
 178 /* operational registers */
 179 #define ISP1301_MODE_CONTROL_1          0x04    /* u8 read, set, +1 clear */
 180 #       define  MC1_SPEED               (1 << 0)
 181 #       define  MC1_SUSPEND             (1 << 1)
 182 #       define  MC1_DAT_SE0             (1 << 2)
 183 #       define  MC1_TRANSPARENT         (1 << 3)
 184 #       define  MC1_BDIS_ACON_EN        (1 << 4)
 185 #       define  MC1_OE_INT_EN           (1 << 5)
 186 #       define  MC1_UART_EN             (1 << 6)
 187 #       define  MC1_MASK                0x7f
 188 #define ISP1301_MODE_CONTROL_2          0x12    /* u8 read, set, +1 clear */
 189 #       define  MC2_GLOBAL_PWR_DN       (1 << 0)
 190 #       define  MC2_SPD_SUSP_CTRL       (1 << 1)
 191 #       define  MC2_BI_DI               (1 << 2)
 192 #       define  MC2_TRANSP_BDIR0        (1 << 3)
 193 #       define  MC2_TRANSP_BDIR1        (1 << 4)
 194 #       define  MC2_AUDIO_EN            (1 << 5)
 195 #       define  MC2_PSW_EN              (1 << 6)
 196 #       define  MC2_EN2V7               (1 << 7)
 197 #define ISP1301_OTG_CONTROL_1           0x06    /* u8 read, set, +1 clear */
 198 #       define  OTG1_DP_PULLUP          (1 << 0)
 199 #       define  OTG1_DM_PULLUP          (1 << 1)
 200 #       define  OTG1_DP_PULLDOWN        (1 << 2)
 201 #       define  OTG1_DM_PULLDOWN        (1 << 3)
 202 #       define  OTG1_ID_PULLDOWN        (1 << 4)
 203 #       define  OTG1_VBUS_DRV           (1 << 5)
 204 #       define  OTG1_VBUS_DISCHRG       (1 << 6)
 205 #       define  OTG1_VBUS_CHRG          (1 << 7)
 206 #define ISP1301_OTG_STATUS              0x10    /* u8 readonly */
 207 #       define  OTG_B_SESS_END          (1 << 6)
 208 #       define  OTG_B_SESS_VLD          (1 << 7)
 209
 210 #define ISP1301_INTERRUPT_SOURCE        0x08    /* u8 read */
 211 #define ISP1301_INTERRUPT_LATCH         0x0A    /* u8 read, set, +1 clear */
 212
 213 #define ISP1301_INTERRUPT_FALLING       0x0C    /* u8 read, set, +1 clear */
 214 #define ISP1301_INTERRUPT_RISING        0x0E    /* u8 read, set, +1 clear */
 215
 216 /* same bitfields in all interrupt registers */
 217 #       define  INTR_VBUS_VLD           (1 << 0)
 218 #       define  INTR_SESS_VLD           (1 << 1)
 219 #       define  INTR_DP_HI              (1 << 2)
 220 #       define  INTR_ID_GND             (1 << 3)
 221 #       define  INTR_DM_HI              (1 << 4)
 222 #       define  INTR_ID_FLOAT           (1 << 5)
 223 #       define  INTR_BDIS_ACON          (1 << 6)
 224 #       define  INTR_CR_INT             (1 << 7)
 225
 226 /*-------------------------------------------------------------------------*/
 227
 228 static const char *state_string(enum usb_otg_state state)
 229 {
 230         switch (state) {
 231         case OTG_STATE_A_IDLE:          return "a_idle";
 232         case OTG_STATE_A_WAIT_VRISE:    return "a_wait_vrise";
 233         case OTG_STATE_A_WAIT_BCON:     return "a_wait_bcon";
 234         case OTG_STATE_A_HOST:          return "a_host";
 235         case OTG_STATE_A_SUSPEND:       return "a_suspend";
 236         case OTG_STATE_A_PERIPHERAL:    return "a_peripheral";
 237         case OTG_STATE_A_WAIT_VFALL:    return "a_wait_vfall";
 238         case OTG_STATE_A_VBUS_ERR:      return "a_vbus_err";
 239         case OTG_STATE_B_IDLE:          return "b_idle";
 240         case OTG_STATE_B_SRP_INIT:      return "b_srp_init";
 241         case OTG_STATE_B_PERIPHERAL:    return "b_peripheral";
 242         case OTG_STATE_B_WAIT_ACON:     return "b_wait_acon";
 243         case OTG_STATE_B_HOST:          return "b_host";
 244         default:                        return "UNDEFINED";
 245         }
 246 }
 247
 248 static inline const char *state_name(struct isp1301 *isp)
 249 {
 250         return state_string(isp->otg.state);
 251 }
 252
 253 /*-------------------------------------------------------------------------*/
 254
 255 /* NOTE:  some of this ISP1301 setup is specific to H2 boards;
 256  * not everything is guarded by board-specific checks, or even using
 257  * omap_usb_config data to deduce MC1_DAT_SE0 and MC2_BI_DI.
 258  *
 259  * ALSO:  this currently doesn't use ISP1301 low-power modes
 260  * while OTG is running.
 261  */
 262
 263 static void power_down(struct isp1301 *isp)
 264 {
 265         isp->otg.state = OTG_STATE_UNDEFINED;
 266
 267         // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
 268         isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
 269
 270         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_ID_PULLDOWN);
 271         isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
 272 }
 273
 274 static void power_up(struct isp1301 *isp)
 275 {
 276         // isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
 277         isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
 278
 279         /* do this only when cpu is driving transceiver,
 280          * so host won't see a low speed device...
 281          */
 282         isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
 283 }
 284
 285 #define NO_HOST_SUSPEND
 286
 287 static int host_suspend(struct isp1301 *isp)
 288 {
 289 #ifdef  NO_HOST_SUSPEND
 290         return 0;
 291 #else
 292         struct device   *dev;
 293
 294         if (!isp->otg.host)
 295                 return -ENODEV;
 296
 297         /* Currently ASSUMES only the OTG port matters;
 298          * other ports could be active...
 299          */
 300         dev = isp->otg.host->controller;
 301         return dev->driver->suspend(dev, 3, 0);
 302 #endif
 303 }
 304
 305 static int host_resume(struct isp1301 *isp)
 306 {
 307 #ifdef  NO_HOST_SUSPEND
 308         return 0;
 309 #else
 310         struct device   *dev;
 311
 312         if (!isp->otg.host)
 313                 return -ENODEV;
 314
 315         dev = isp->otg.host->controller;
 316         return dev->driver->resume(dev, 0);
 317 #endif
 318 }
 319
 320 static int gadget_suspend(struct isp1301 *isp)
 321 {
 322         isp->otg.gadget->b_hnp_enable = 0;
 323         isp->otg.gadget->a_hnp_support = 0;
 324         isp->otg.gadget->a_alt_hnp_support = 0;
 325         return usb_gadget_vbus_disconnect(isp->otg.gadget);
 326 }
 327
 328 /*-------------------------------------------------------------------------*/
 329
 330 #define TIMER_MINUTES   10
 331 #define TIMER_JIFFIES   (TIMER_MINUTES * 60 * HZ)
 332
 333 /* Almost all our I2C messaging comes from a work queue's task context.
 334  * NOTE: guaranteeing certain response times might mean we shouldn't
 335  * share keventd's work queue; a realtime task might be safest.
 336  */
 337 void
 338 isp1301_defer_work(struct isp1301 *isp, int work)
 339 {
 340         int status;
 341
 342         if (isp && !test_and_set_bit(work, &isp->todo)) {
 343                 (void) get_device(&isp->client->dev);
 344                 status = schedule_work(&isp->work);
 345                 if (!status && !isp->working)
 346                         dev_vdbg(&isp->client->dev,
 347                                 "work item %d may be lost\n", work);
 348         }
 349 }
 350
 351 /* called from irq handlers */
 352 static void a_idle(struct isp1301 *isp, const char *tag)
 353 {
 354         u32 l;
 355
 356         if (isp->otg.state == OTG_STATE_A_IDLE)
 357                 return;
 358
 359         isp->otg.default_a = 1;
 360         if (isp->otg.host) {
 361                 isp->otg.host->is_b_host = 0;
 362                 host_suspend(isp);
 363         }
 364         if (isp->otg.gadget) {
 365                 isp->otg.gadget->is_a_peripheral = 1;
 366                 gadget_suspend(isp);
 367         }
 368         isp->otg.state = OTG_STATE_A_IDLE;
 369         l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 370         omap_writel(l, OTG_CTRL);
 371         isp->last_otg_ctrl = l;
 372         pr_debug("  --> %s/%s\n", state_name(isp), tag);
 373 }
 374
 375 /* called from irq handlers */
 376 static void b_idle(struct isp1301 *isp, const char *tag)
 377 {
 378         u32 l;
 379
 380         if (isp->otg.state == OTG_STATE_B_IDLE)
 381                 return;
 382
 383         isp->otg.default_a = 0;
 384         if (isp->otg.host) {
 385                 isp->otg.host->is_b_host = 1;
 386                 host_suspend(isp);
 387         }
 388         if (isp->otg.gadget) {
 389                 isp->otg.gadget->is_a_peripheral = 0;
 390                 gadget_suspend(isp);
 391         }
 392         isp->otg.state = OTG_STATE_B_IDLE;
 393         l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 394         omap_writel(l, OTG_CTRL);
 395         isp->last_otg_ctrl = l;
 396         pr_debug("  --> %s/%s\n", state_name(isp), tag);
 397 }
 398
 399 static void
 400 dump_regs(struct isp1301 *isp, const char *label)
 401 {
 402 #ifdef  DEBUG
 403         u8      ctrl = isp1301_get_u8(isp, ISP1301_OTG_CONTROL_1);
 404         u8      status = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
 405         u8      src = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
 406
 407         pr_debug("otg: %06x, %s %s, otg/%02x stat/%02x.%02x\n",
 408                 omap_readl(OTG_CTRL), label, state_name(isp),
 409                 ctrl, status, src);
 410         /* mode control and irq enables don't change much */
 411 #endif
 412 }
 413
 414 /*-------------------------------------------------------------------------*/
 415
 416 #ifdef  CONFIG_USB_OTG
 417
 418 /*
 419  * The OMAP OTG controller handles most of the OTG state transitions.
 420  *
 421  * We translate isp1301 outputs (mostly voltage comparator status) into
 422  * OTG inputs; OTG outputs (mostly pullup/pulldown controls) and HNP state
 423  * flags into isp1301 inputs ... and infer state transitions.
 424  */
 425
 426 #ifdef  VERBOSE
 427
 428 static void check_state(struct isp1301 *isp, const char *tag)
 429 {
 430         enum usb_otg_state      state = OTG_STATE_UNDEFINED;
 431         u8                      fsm = omap_readw(OTG_TEST) & 0x0ff;
 432         unsigned                extra = 0;
 433
 434         switch (fsm) {
 435
 436         /* default-b */
 437         case 0x0:
 438                 state = OTG_STATE_B_IDLE;
 439                 break;
 440         case 0x3:
 441         case 0x7:
 442                 extra = 1;
 443         case 0x1:
 444                 state = OTG_STATE_B_PERIPHERAL;
 445                 break;
 446         case 0x11:
 447                 state = OTG_STATE_B_SRP_INIT;
 448                 break;
 449
 450         /* extra dual-role default-b states */
 451         case 0x12:
 452         case 0x13:
 453         case 0x16:
 454                 extra = 1;
 455         case 0x17:
 456                 state = OTG_STATE_B_WAIT_ACON;
 457                 break;
 458         case 0x34:
 459                 state = OTG_STATE_B_HOST;
 460                 break;
 461
 462         /* default-a */
 463         case 0x36:
 464                 state = OTG_STATE_A_IDLE;
 465                 break;
 466         case 0x3c:
 467                 state = OTG_STATE_A_WAIT_VFALL;
 468                 break;
 469         case 0x7d:
 470                 state = OTG_STATE_A_VBUS_ERR;
 471                 break;
 472         case 0x9e:
 473         case 0x9f:
 474                 extra = 1;
 475         case 0x89:
 476                 state = OTG_STATE_A_PERIPHERAL;
 477                 break;
 478         case 0xb7:
 479                 state = OTG_STATE_A_WAIT_VRISE;
 480                 break;
 481         case 0xb8:
 482                 state = OTG_STATE_A_WAIT_BCON;
 483                 break;
 484         case 0xb9:
 485                 state = OTG_STATE_A_HOST;
 486                 break;
 487         case 0xba:
 488                 state = OTG_STATE_A_SUSPEND;
 489                 break;
 490         default:
 491                 break;
 492         }
 493         if (isp->otg.state == state && !extra)
 494                 return;
 495         pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
 496                 state_string(state), fsm, state_name(isp),
 497                 omap_readl(OTG_CTRL));
 498 }
 499
 500 #else
 501
 502 static inline void check_state(struct isp1301 *isp, const char *tag) { }
 503
 504 #endif
 505
 506 /* outputs from ISP1301_INTERRUPT_SOURCE */
 507 static void update_otg1(struct isp1301 *isp, u8 int_src)
 508 {
 509         u32     otg_ctrl;
 510
 511         otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
 512         otg_ctrl &= ~OTG_XCEIV_INPUTS;
 513         otg_ctrl &= ~(OTG_ID|OTG_ASESSVLD|OTG_VBUSVLD);
 514
 515
 516         if (int_src & INTR_SESS_VLD)
 517                 otg_ctrl |= OTG_ASESSVLD;
 518         else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
 519                 a_idle(isp, "vfall");
 520                 otg_ctrl &= ~OTG_CTRL_BITS;
 521         }
 522         if (int_src & INTR_VBUS_VLD)
 523                 otg_ctrl |= OTG_VBUSVLD;
 524         if (int_src & INTR_ID_GND) {            /* default-A */
 525                 if (isp->otg.state == OTG_STATE_B_IDLE
 526                                 || isp->otg.state == OTG_STATE_UNDEFINED) {
 527                         a_idle(isp, "init");
 528                         return;
 529                 }
 530         } else {                                /* default-B */
 531                 otg_ctrl |= OTG_ID;
 532                 if (isp->otg.state == OTG_STATE_A_IDLE
 533                                 || isp->otg.state == OTG_STATE_UNDEFINED) {
 534                         b_idle(isp, "init");
 535                         return;
 536                 }
 537         }
 538         omap_writel(otg_ctrl, OTG_CTRL);
 539 }
 540
 541 /* outputs from ISP1301_OTG_STATUS */
 542 static void update_otg2(struct isp1301 *isp, u8 otg_status)
 543 {
 544         u32     otg_ctrl;
 545
 546         otg_ctrl = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
 547         otg_ctrl &= ~OTG_XCEIV_INPUTS;
 548         otg_ctrl &= ~(OTG_BSESSVLD | OTG_BSESSEND);
 549         if (otg_status & OTG_B_SESS_VLD)
 550                 otg_ctrl |= OTG_BSESSVLD;
 551         else if (otg_status & OTG_B_SESS_END)
 552                 otg_ctrl |= OTG_BSESSEND;
 553         omap_writel(otg_ctrl, OTG_CTRL);
 554 }
 555
 556 /* inputs going to ISP1301 */
 557 static void otg_update_isp(struct isp1301 *isp)
 558 {
 559         u32     otg_ctrl, otg_change;
 560         u8      set = OTG1_DM_PULLDOWN, clr = OTG1_DM_PULLUP;
 561
 562         otg_ctrl = omap_readl(OTG_CTRL);
 563         otg_change = otg_ctrl ^ isp->last_otg_ctrl;
 564         isp->last_otg_ctrl = otg_ctrl;
 565         otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
 566
 567         switch (isp->otg.state) {
 568         case OTG_STATE_B_IDLE:
 569         case OTG_STATE_B_PERIPHERAL:
 570         case OTG_STATE_B_SRP_INIT:
 571                 if (!(otg_ctrl & OTG_PULLUP)) {
 572                         // if (otg_ctrl & OTG_B_HNPEN) {
 573                         if (isp->otg.gadget->b_hnp_enable) {
 574                                 isp->otg.state = OTG_STATE_B_WAIT_ACON;
 575                                 pr_debug("  --> b_wait_acon\n");
 576                         }
 577                         goto pulldown;
 578                 }
 579 pullup:
 580                 set |= OTG1_DP_PULLUP;
 581                 clr |= OTG1_DP_PULLDOWN;
 582                 break;
 583         case OTG_STATE_A_SUSPEND:
 584         case OTG_STATE_A_PERIPHERAL:
 585                 if (otg_ctrl & OTG_PULLUP)
 586                         goto pullup;
 587                 /* FALLTHROUGH */
 588         // case OTG_STATE_B_WAIT_ACON:
 589         default:
 590 pulldown:
 591                 set |= OTG1_DP_PULLDOWN;
 592                 clr |= OTG1_DP_PULLUP;
 593                 break;
 594         }
 595
 596 #       define toggle(OTG,ISP) do { \
 597                 if (otg_ctrl & OTG) set |= ISP; \
 598                 else clr |= ISP; \
 599                 } while (0)
 600
 601         if (!(isp->otg.host))
 602                 otg_ctrl &= ~OTG_DRV_VBUS;
 603
 604         switch (isp->otg.state) {
 605         case OTG_STATE_A_SUSPEND:
 606                 if (otg_ctrl & OTG_DRV_VBUS) {
 607                         set |= OTG1_VBUS_DRV;
 608                         break;
 609                 }
 610                 /* HNP failed for some reason (A_AIDL_BDIS timeout) */
 611                 notresponding(isp);
 612
 613                 /* FALLTHROUGH */
 614         case OTG_STATE_A_VBUS_ERR:
 615                 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
 616                 pr_debug("  --> a_wait_vfall\n");
 617                 /* FALLTHROUGH */
 618         case OTG_STATE_A_WAIT_VFALL:
 619                 /* FIXME usbcore thinks port power is still on ... */
 620                 clr |= OTG1_VBUS_DRV;
 621                 break;
 622         case OTG_STATE_A_IDLE:
 623                 if (otg_ctrl & OTG_DRV_VBUS) {
 624                         isp->otg.state = OTG_STATE_A_WAIT_VRISE;
 625                         pr_debug("  --> a_wait_vrise\n");
 626                 }
 627                 /* FALLTHROUGH */
 628         default:
 629                 toggle(OTG_DRV_VBUS, OTG1_VBUS_DRV);
 630         }
 631
 632         toggle(OTG_PU_VBUS, OTG1_VBUS_CHRG);
 633         toggle(OTG_PD_VBUS, OTG1_VBUS_DISCHRG);
 634
 635 #       undef toggle
 636
 637         isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, set);
 638         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, clr);
 639
 640         /* HNP switch to host or peripheral; and SRP */
 641         if (otg_change & OTG_PULLUP) {
 642                 u32 l;
 643
 644                 switch (isp->otg.state) {
 645                 case OTG_STATE_B_IDLE:
 646                         if (clr & OTG1_DP_PULLUP)
 647                                 break;
 648                         isp->otg.state = OTG_STATE_B_PERIPHERAL;
 649                         pr_debug("  --> b_peripheral\n");
 650                         break;
 651                 case OTG_STATE_A_SUSPEND:
 652                         if (clr & OTG1_DP_PULLUP)
 653                                 break;
 654                         isp->otg.state = OTG_STATE_A_PERIPHERAL;
 655                         pr_debug("  --> a_peripheral\n");
 656                         break;
 657                 default:
 658                         break;
 659                 }
 660                 l = omap_readl(OTG_CTRL);
 661                 l |= OTG_PULLUP;
 662                 omap_writel(l, OTG_CTRL);
 663         }
 664
 665         check_state(isp, __func__);
 666         dump_regs(isp, "otg->isp1301");
 667 }
 668
 669 static irqreturn_t omap_otg_irq(int irq, void *_isp)
 670 {
 671         u16             otg_irq = omap_readw(OTG_IRQ_SRC);
 672         u32             otg_ctrl;
 673         int             ret = IRQ_NONE;
 674         struct isp1301  *isp = _isp;
 675
 676         /* update ISP1301 transciever from OTG controller */
 677         if (otg_irq & OPRT_CHG) {
 678                 omap_writew(OPRT_CHG, OTG_IRQ_SRC);
 679                 isp1301_defer_work(isp, WORK_UPDATE_ISP);
 680                 ret = IRQ_HANDLED;
 681
 682         /* SRP to become b_peripheral failed */
 683         } else if (otg_irq & B_SRP_TMROUT) {
 684                 pr_debug("otg: B_SRP_TIMEOUT, %06x\n", omap_readl(OTG_CTRL));
 685                 notresponding(isp);
 686
 687                 /* gadget drivers that care should monitor all kinds of
 688                  * remote wakeup (SRP, normal) using their own timer
 689                  * to give "check cable and A-device" messages.
 690                  */
 691                 if (isp->otg.state == OTG_STATE_B_SRP_INIT)
 692                         b_idle(isp, "srp_timeout");
 693
 694                 omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
 695                 ret = IRQ_HANDLED;
 696
 697         /* HNP to become b_host failed */
 698         } else if (otg_irq & B_HNP_FAIL) {
 699                 pr_debug("otg: %s B_HNP_FAIL, %06x\n",
 700                                 state_name(isp), omap_readl(OTG_CTRL));
 701                 notresponding(isp);
 702
 703                 otg_ctrl = omap_readl(OTG_CTRL);
 704                 otg_ctrl |= OTG_BUSDROP;
 705                 otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 706                 omap_writel(otg_ctrl, OTG_CTRL);
 707
 708                 /* subset of b_peripheral()... */
 709                 isp->otg.state = OTG_STATE_B_PERIPHERAL;
 710                 pr_debug("  --> b_peripheral\n");
 711
 712                 omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
 713                 ret = IRQ_HANDLED;
 714
 715         /* detect SRP from B-device ... */
 716         } else if (otg_irq & A_SRP_DETECT) {
 717                 pr_debug("otg: %s SRP_DETECT, %06x\n",
 718                                 state_name(isp), omap_readl(OTG_CTRL));
 719
 720                 isp1301_defer_work(isp, WORK_UPDATE_OTG);
 721                 switch (isp->otg.state) {
 722                 case OTG_STATE_A_IDLE:
 723                         if (!isp->otg.host)
 724                                 break;
 725                         isp1301_defer_work(isp, WORK_HOST_RESUME);
 726                         otg_ctrl = omap_readl(OTG_CTRL);
 727                         otg_ctrl |= OTG_A_BUSREQ;
 728                         otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
 729                                         & ~OTG_XCEIV_INPUTS
 730                                         & OTG_CTRL_MASK;
 731                         omap_writel(otg_ctrl, OTG_CTRL);
 732                         break;
 733                 default:
 734                         break;
 735                 }
 736
 737                 omap_writew(A_SRP_DETECT, OTG_IRQ_SRC);
 738                 ret = IRQ_HANDLED;
 739
 740         /* timer expired:  T(a_wait_bcon) and maybe T(a_wait_vrise)
 741          * we don't track them separately
 742          */
 743         } else if (otg_irq & A_REQ_TMROUT) {
 744                 otg_ctrl = omap_readl(OTG_CTRL);
 745                 pr_info("otg: BCON_TMOUT from %s, %06x\n",
 746                                 state_name(isp), otg_ctrl);
 747                 notresponding(isp);
 748
 749                 otg_ctrl |= OTG_BUSDROP;
 750                 otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 751                 omap_writel(otg_ctrl, OTG_CTRL);
 752                 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
 753
 754                 omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
 755                 ret = IRQ_HANDLED;
 756
 757         /* A-supplied voltage fell too low; overcurrent */
 758         } else if (otg_irq & A_VBUS_ERR) {
 759                 otg_ctrl = omap_readl(OTG_CTRL);
 760                 printk(KERN_ERR "otg: %s, VBUS_ERR %04x ctrl %06x\n",
 761                         state_name(isp), otg_irq, otg_ctrl);
 762
 763                 otg_ctrl |= OTG_BUSDROP;
 764                 otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 765                 omap_writel(otg_ctrl, OTG_CTRL);
 766                 isp->otg.state = OTG_STATE_A_VBUS_ERR;
 767
 768                 omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
 769                 ret = IRQ_HANDLED;
 770
 771         /* switch driver; the transciever code activates it,
 772          * ungating the udc clock or resuming OHCI.
 773          */
 774         } else if (otg_irq & DRIVER_SWITCH) {
 775                 int     kick = 0;
 776
 777                 otg_ctrl = omap_readl(OTG_CTRL);
 778                 printk(KERN_NOTICE "otg: %s, SWITCH to %s, ctrl %06x\n",
 779                                 state_name(isp),
 780                                 (otg_ctrl & OTG_DRIVER_SEL)
 781                                         ? "gadget" : "host",
 782                                 otg_ctrl);
 783                 isp1301_defer_work(isp, WORK_UPDATE_ISP);
 784
 785                 /* role is peripheral */
 786                 if (otg_ctrl & OTG_DRIVER_SEL) {
 787                         switch (isp->otg.state) {
 788                         case OTG_STATE_A_IDLE:
 789                                 b_idle(isp, __func__);
 790                                 break;
 791                         default:
 792                                 break;
 793                         }
 794                         isp1301_defer_work(isp, WORK_UPDATE_ISP);
 795
 796                 /* role is host */
 797                 } else {
 798                         if (!(otg_ctrl & OTG_ID)) {
 799                                 otg_ctrl &= OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
 800                                 omap_writel(otg_ctrl | OTG_A_BUSREQ, OTG_CTRL);
 801                         }
 802
 803                         if (isp->otg.host) {
 804                                 switch (isp->otg.state) {
 805                                 case OTG_STATE_B_WAIT_ACON:
 806                                         isp->otg.state = OTG_STATE_B_HOST;
 807                                         pr_debug("  --> b_host\n");
 808                                         kick = 1;
 809                                         break;
 810                                 case OTG_STATE_A_WAIT_BCON:
 811                                         isp->otg.state = OTG_STATE_A_HOST;
 812                                         pr_debug("  --> a_host\n");
 813                                         break;
 814                                 case OTG_STATE_A_PERIPHERAL:
 815                                         isp->otg.state = OTG_STATE_A_WAIT_BCON;
 816                                         pr_debug("  --> a_wait_bcon\n");
 817                                         break;
 818                                 default:
 819                                         break;
 820                                 }
 821                                 isp1301_defer_work(isp, WORK_HOST_RESUME);
 822                         }
 823                 }
 824
 825                 omap_writew(DRIVER_SWITCH, OTG_IRQ_SRC);
 826                 ret = IRQ_HANDLED;
 827
 828                 if (kick)
 829                         usb_bus_start_enum(isp->otg.host,
 830                                                 isp->otg.host->otg_port);
 831         }
 832
 833         check_state(isp, __func__);
 834         return ret;
 835 }
 836
 837 static struct platform_device *otg_dev;
 838
 839 static int otg_init(struct isp1301 *isp)
 840 {
 841         u32 l;
 842
 843         if (!otg_dev)
 844                 return -ENODEV;
 845
 846         dump_regs(isp, __func__);
 847         /* some of these values are board-specific... */
 848         l = omap_readl(OTG_SYSCON_2);
 849         l |= OTG_EN
 850                 /* for B-device: */
 851                 | SRP_GPDATA            /* 9msec Bdev D+ pulse */
 852                 | SRP_GPDVBUS           /* discharge after VBUS pulse */
 853                 // | (3 << 24)          /* 2msec VBUS pulse */
 854                 /* for A-device: */
 855                 | (0 << 20)             /* 200ms nominal A_WAIT_VRISE timer */
 856                 | SRP_DPW               /* detect 167+ns SRP pulses */
 857                 | SRP_DATA | SRP_VBUS   /* accept both kinds of SRP pulse */
 858                 ;
 859         omap_writel(l, OTG_SYSCON_2);
 860
 861         update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
 862         update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
 863
 864         check_state(isp, __func__);
 865         pr_debug("otg: %s, %s %06x\n",
 866                         state_name(isp), __func__, omap_readl(OTG_CTRL));
 867
 868         omap_writew(DRIVER_SWITCH | OPRT_CHG
 869                         | B_SRP_TMROUT | B_HNP_FAIL
 870                         | A_VBUS_ERR | A_SRP_DETECT | A_REQ_TMROUT, OTG_IRQ_EN);
 871
 872         l = omap_readl(OTG_SYSCON_2);
 873         l |= OTG_EN;
 874         omap_writel(l, OTG_SYSCON_2);
 875
 876         return 0;
 877 }
 878
 879 static int otg_probe(struct platform_device *dev)
 880 {
 881         // struct omap_usb_config *config = dev->platform_data;
 882
 883         otg_dev = dev;
 884         return 0;
 885 }
 886
 887 static int otg_remove(struct platform_device *dev)
 888 {
 889         otg_dev = 0;
 890         return 0;
 891 }
 892
 893 struct platform_driver omap_otg_driver = {
 894         .probe          = otg_probe,
 895         .remove         = otg_remove,
 896         .driver         = {
 897                 .owner  = THIS_MODULE,
 898                 .name   = "omap_otg",
 899         },
 900 };
 901
 902 static int otg_bind(struct isp1301 *isp)
 903 {
 904         int     status;
 905
 906         if (otg_dev)
 907                 return -EBUSY;
 908
 909         status = platform_driver_register(&omap_otg_driver);
 910         if (status < 0)
 911                 return status;
 912
 913         if (otg_dev)
 914                 status = request_irq(otg_dev->resource[1].start, omap_otg_irq,
 915                                 IRQF_DISABLED, DRIVER_NAME, isp);
 916         else
 917                 status = -ENODEV;
 918
 919         if (status < 0)
 920                 platform_driver_unregister(&omap_otg_driver);
 921         return status;
 922 }
 923
 924 static void otg_unbind(struct isp1301 *isp)
 925 {
 926         if (!otg_dev)
 927                 return;
 928         free_irq(otg_dev->resource[1].start, isp);
 929 }
 930
 931 #else
 932
 933 /* OTG controller isn't clocked */
 934
 935 #endif  /* CONFIG_USB_OTG */
 936
 937 /*-------------------------------------------------------------------------*/
 938
 939 static void b_peripheral(struct isp1301 *isp)
 940 {
 941         u32 l;
 942
 943         l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
 944         omap_writel(l, OTG_CTRL);
 945
 946         usb_gadget_vbus_connect(isp->otg.gadget);
 947
 948 #ifdef  CONFIG_USB_OTG
 949         enable_vbus_draw(isp, 8);
 950         otg_update_isp(isp);
 951 #else
 952         enable_vbus_draw(isp, 100);
 953         /* UDC driver just set OTG_BSESSVLD */
 954         isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
 955         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
 956         isp->otg.state = OTG_STATE_B_PERIPHERAL;
 957         pr_debug("  --> b_peripheral\n");
 958         dump_regs(isp, "2periph");
 959 #endif
 960 }
 961
 962 static void isp_update_otg(struct isp1301 *isp, u8 stat)
 963 {
 964         u8                      isp_stat, isp_bstat;
 965         enum usb_otg_state      state = isp->otg.state;
 966
 967         if (stat & INTR_BDIS_ACON)
 968                 pr_debug("OTG:  BDIS_ACON, %s\n", state_name(isp));
 969
 970         /* start certain state transitions right away */
 971         isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
 972         if (isp_stat & INTR_ID_GND) {
 973                 if (isp->otg.default_a) {
 974                         switch (state) {
 975                         case OTG_STATE_B_IDLE:
 976                                 a_idle(isp, "idle");
 977                                 /* FALLTHROUGH */
 978                         case OTG_STATE_A_IDLE:
 979                                 enable_vbus_source(isp);
 980                                 /* FALLTHROUGH */
 981                         case OTG_STATE_A_WAIT_VRISE:
 982                                 /* we skip over OTG_STATE_A_WAIT_BCON, since
 983                                  * the HC will transition to A_HOST (or
 984                                  * A_SUSPEND!) without our noticing except
 985                                  * when HNP is used.
 986                                  */
 987                                 if (isp_stat & INTR_VBUS_VLD)
 988                                         isp->otg.state = OTG_STATE_A_HOST;
 989                                 break;
 990                         case OTG_STATE_A_WAIT_VFALL:
 991                                 if (!(isp_stat & INTR_SESS_VLD))
 992                                         a_idle(isp, "vfell");
 993                                 break;
 994                         default:
 995                                 if (!(isp_stat & INTR_VBUS_VLD))
 996                                         isp->otg.state = OTG_STATE_A_VBUS_ERR;
 997                                 break;
 998                         }
 999                         isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
1000                 } else {
1001                         switch (state) {
1002                         case OTG_STATE_B_PERIPHERAL:
1003                         case OTG_STATE_B_HOST:
1004                         case OTG_STATE_B_WAIT_ACON:
1005                                 usb_gadget_vbus_disconnect(isp->otg.gadget);
1006                                 break;
1007                         default:
1008                                 break;
1009                         }
1010                         if (state != OTG_STATE_A_IDLE)
1011                                 a_idle(isp, "id");
1012                         if (isp->otg.host && state == OTG_STATE_A_IDLE)
1013                                 isp1301_defer_work(isp, WORK_HOST_RESUME);
1014                         isp_bstat = 0;
1015                 }
1016         } else {
1017                 u32 l;
1018
1019                 /* if user unplugged mini-A end of cable,
1020                  * don't bypass A_WAIT_VFALL.
1021                  */
1022                 if (isp->otg.default_a) {
1023                         switch (state) {
1024                         default:
1025                                 isp->otg.state = OTG_STATE_A_WAIT_VFALL;
1026                                 break;
1027                         case OTG_STATE_A_WAIT_VFALL:
1028                                 state = OTG_STATE_A_IDLE;
1029                                 /* khubd may take a while to notice and
1030                                  * handle this disconnect, so don't go
1031                                  * to B_IDLE quite yet.
1032                                  */
1033                                 break;
1034                         case OTG_STATE_A_IDLE:
1035                                 host_suspend(isp);
1036                                 isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
1037                                                 MC1_BDIS_ACON_EN);
1038                                 isp->otg.state = OTG_STATE_B_IDLE;
1039                                 l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
1040                                 l &= ~OTG_CTRL_BITS;
1041                                 omap_writel(l, OTG_CTRL);
1042                                 break;
1043                         case OTG_STATE_B_IDLE:
1044                                 break;
1045                         }
1046                 }
1047                 isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
1048
1049                 switch (isp->otg.state) {
1050                 case OTG_STATE_B_PERIPHERAL:
1051                 case OTG_STATE_B_WAIT_ACON:
1052                 case OTG_STATE_B_HOST:
1053                         if (likely(isp_bstat & OTG_B_SESS_VLD))
1054                                 break;
1055                         enable_vbus_draw(isp, 0);
1056 #ifndef CONFIG_USB_OTG
1057                         /* UDC driver will clear OTG_BSESSVLD */
1058                         isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1059                                                 OTG1_DP_PULLDOWN);
1060                         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1061                                                 OTG1_DP_PULLUP);
1062                         dump_regs(isp, __func__);
1063 #endif
1064                         /* FALLTHROUGH */
1065                 case OTG_STATE_B_SRP_INIT:
1066                         b_idle(isp, __func__);
1067                         l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
1068                         omap_writel(l, OTG_CTRL);
1069                         /* FALLTHROUGH */
1070                 case OTG_STATE_B_IDLE:
1071                         if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
1072 #ifdef  CONFIG_USB_OTG
1073                                 update_otg1(isp, isp_stat);
1074                                 update_otg2(isp, isp_bstat);
1075 #endif
1076                                 b_peripheral(isp);
1077                         } else if (!(isp_stat & (INTR_VBUS_VLD|INTR_SESS_VLD)))
1078                                 isp_bstat |= OTG_B_SESS_END;
1079                         break;
1080                 case OTG_STATE_A_WAIT_VFALL:
1081                         break;
1082                 default:
1083                         pr_debug("otg: unsupported b-device %s\n",
1084                                 state_name(isp));
1085                         break;
1086                 }
1087         }
1088
1089         if (state != isp->otg.state)
1090                 pr_debug("  isp, %s -> %s\n",
1091                                 state_string(state), state_name(isp));
1092
1093 #ifdef  CONFIG_USB_OTG
1094         /* update the OTG controller state to match the isp1301; may
1095          * trigger OPRT_CHG irqs for changes going to the isp1301.
1096          */
1097         update_otg1(isp, isp_stat);
1098         update_otg2(isp, isp_bstat);
1099         check_state(isp, __func__);
1100 #endif
1101
1102         dump_regs(isp, "isp1301->otg");
1103 }
1104
1105 /*-------------------------------------------------------------------------*/
1106
1107 static u8 isp1301_clear_latch(struct isp1301 *isp)
1108 {
1109         u8 latch = isp1301_get_u8(isp, ISP1301_INTERRUPT_LATCH);
1110         isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, latch);
1111         return latch;
1112 }
1113
1114 static void
1115 isp1301_work(struct work_struct *work)
1116 {
1117         struct isp1301  *isp = container_of(work, struct isp1301, work);
1118         int             stop;
1119
1120         /* implicit lock:  we're the only task using this device */
1121         isp->working = 1;
1122         do {
1123                 stop = test_bit(WORK_STOP, &isp->todo);
1124
1125 #ifdef  CONFIG_USB_OTG
1126                 /* transfer state from otg engine to isp1301 */
1127                 if (test_and_clear_bit(WORK_UPDATE_ISP, &isp->todo)) {
1128                         otg_update_isp(isp);
1129                         put_device(&isp->client->dev);
1130                 }
1131 #endif
1132                 /* transfer state from isp1301 to otg engine */
1133                 if (test_and_clear_bit(WORK_UPDATE_OTG, &isp->todo)) {
1134                         u8              stat = isp1301_clear_latch(isp);
1135
1136                         isp_update_otg(isp, stat);
1137                         put_device(&isp->client->dev);
1138                 }
1139
1140                 if (test_and_clear_bit(WORK_HOST_RESUME, &isp->todo)) {
1141                         u32     otg_ctrl;
1142
1143                         /*
1144                          * skip A_WAIT_VRISE; hc transitions invisibly
1145                          * skip A_WAIT_BCON; same.
1146                          */
1147                         switch (isp->otg.state) {
1148                         case OTG_STATE_A_WAIT_BCON:
1149                         case OTG_STATE_A_WAIT_VRISE:
1150                                 isp->otg.state = OTG_STATE_A_HOST;
1151                                 pr_debug("  --> a_host\n");
1152                                 otg_ctrl = omap_readl(OTG_CTRL);
1153                                 otg_ctrl |= OTG_A_BUSREQ;
1154                                 otg_ctrl &= ~(OTG_BUSDROP|OTG_B_BUSREQ)
1155                                                 & OTG_CTRL_MASK;
1156                                 omap_writel(otg_ctrl, OTG_CTRL);
1157                                 break;
1158                         case OTG_STATE_B_WAIT_ACON:
1159                                 isp->otg.state = OTG_STATE_B_HOST;
1160                                 pr_debug("  --> b_host (acon)\n");
1161                                 break;
1162                         case OTG_STATE_B_HOST:
1163                         case OTG_STATE_B_IDLE:
1164                         case OTG_STATE_A_IDLE:
1165                                 break;
1166                         default:
1167                                 pr_debug("  host resume in %s\n",
1168                                                 state_name(isp));
1169                         }
1170                         host_resume(isp);
1171                         // mdelay(10);
1172                         put_device(&isp->client->dev);
1173                 }
1174
1175                 if (test_and_clear_bit(WORK_TIMER, &isp->todo)) {
1176 #ifdef  VERBOSE
1177                         dump_regs(isp, "timer");
1178                         if (!stop)
1179                                 mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1180 #endif
1181                         put_device(&isp->client->dev);
1182                 }
1183
1184                 if (isp->todo)
1185                         dev_vdbg(&isp->client->dev,
1186                                 "work done, todo = 0x%lx\n",
1187                                 isp->todo);
1188                 if (stop) {
1189                         dev_dbg(&isp->client->dev, "stop\n");
1190                         break;
1191                 }
1192         } while (isp->todo);
1193         isp->working = 0;
1194 }
1195
1196 static irqreturn_t isp1301_irq(int irq, void *isp)
1197 {
1198         isp1301_defer_work(isp, WORK_UPDATE_OTG);
1199         return IRQ_HANDLED;
1200 }
1201
1202 static void isp1301_timer(unsigned long _isp)
1203 {
1204         isp1301_defer_work((void *)_isp, WORK_TIMER);
1205 }
1206
1207 /*-------------------------------------------------------------------------*/
1208
1209 static void isp1301_release(struct device *dev)
1210 {
1211         struct isp1301  *isp;
1212
1213         isp = dev_get_drvdata(dev);
1214
1215         /* ugly -- i2c hijacks our memory hook to wait_for_completion() */
1216         if (isp->i2c_release)
1217                 isp->i2c_release(dev);
1218         kfree (isp);
1219 }
1220
1221 static struct isp1301 *the_transceiver;
1222
1223 static int __exit isp1301_remove(struct i2c_client *i2c)
1224 {
1225         struct isp1301  *isp;
1226
1227         isp = i2c_get_clientdata(i2c);
1228
1229         isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1230         isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1231         free_irq(i2c->irq, isp);
1232 #ifdef  CONFIG_USB_OTG
1233         otg_unbind(isp);
1234 #endif
1235         if (machine_is_omap_h2())
1236                 omap_free_gpio(2);
1237
1238         isp->timer.data = 0;
1239         set_bit(WORK_STOP, &isp->todo);
1240         del_timer_sync(&isp->timer);
1241         flush_scheduled_work();
1242
1243         put_device(&i2c->dev);
1244         the_transceiver = 0;
1245
1246         return 0;
1247 }
1248
1249 /*-------------------------------------------------------------------------*/
1250
1251 /* NOTE:  three modes are possible here, only one of which
1252  * will be standards-conformant on any given system:
1253  *
1254  *  - OTG mode (dual-role), required if there's a Mini-AB connector
1255  *  - HOST mode, for when there's one or more A (host) connectors
1256  *  - DEVICE mode, for when there's a B/Mini-B (device) connector
1257  *
1258  * As a rule, you won't have an isp1301 chip unless it's there to
1259  * support the OTG mode.  Other modes help testing USB controllers
1260  * in isolation from (full) OTG support, or maybe so later board
1261  * revisions can help to support those feature.
1262  */
1263
1264 #ifdef  CONFIG_USB_OTG
1265
1266 static int isp1301_otg_enable(struct isp1301 *isp)
1267 {
1268         power_up(isp);
1269         otg_init(isp);
1270
1271         /* NOTE:  since we don't change this, this provides
1272          * a few more interrupts than are strictly needed.
1273          */
1274         isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1275                 INTR_VBUS_VLD | INTR_SESS_VLD | INTR_ID_GND);
1276         isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1277                 INTR_VBUS_VLD | INTR_SESS_VLD | INTR_ID_GND);
1278
1279         dev_info(&isp->client->dev, "ready for dual-role USB ...\n");
1280
1281         return 0;
1282 }
1283
1284 #endif
1285
1286 /* add or disable the host device+driver */
1287 static int
1288 isp1301_set_host(struct otg_transceiver *otg, struct usb_bus *host)
1289 {
1290         struct isp1301  *isp = container_of(otg, struct isp1301, otg);
1291
1292         if (!otg || isp != the_transceiver)
1293                 return -ENODEV;
1294
1295         if (!host) {
1296                 omap_writew(0, OTG_IRQ_EN);
1297                 power_down(isp);
1298                 isp->otg.host = 0;
1299                 return 0;
1300         }
1301
1302 #ifdef  CONFIG_USB_OTG
1303         isp->otg.host = host;
1304         dev_dbg(&isp->client->dev, "registered host\n");
1305         host_suspend(isp);
1306         if (isp->otg.gadget)
1307                 return isp1301_otg_enable(isp);
1308         return 0;
1309
1310 #elif   !defined(CONFIG_USB_GADGET_OMAP)
1311         // FIXME update its refcount
1312         isp->otg.host = host;
1313
1314         power_up(isp);
1315
1316         if (machine_is_omap_h2())
1317                 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1318
1319         dev_info(&isp->client->dev, "A-Host sessions ok\n");
1320         isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1321                 INTR_ID_GND);
1322         isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1323                 INTR_ID_GND);
1324
1325         /* If this has a Mini-AB connector, this mode is highly
1326          * nonstandard ... but can be handy for testing, especially with
1327          * the Mini-A end of an OTG cable.  (Or something nonstandard
1328          * like MiniB-to-StandardB, maybe built with a gender mender.)
1329          */
1330         isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_VBUS_DRV);
1331
1332         dump_regs(isp, __func__);
1333
1334         return 0;
1335
1336 #else
1337         dev_dbg(&isp->client->dev, "host sessions not allowed\n");
1338         return -EINVAL;
1339 #endif
1340
1341 }
1342
1343 static int
1344 isp1301_set_peripheral(struct otg_transceiver *otg, struct usb_gadget *gadget)
1345 {
1346         struct isp1301  *isp = container_of(otg, struct isp1301, otg);
1347         u32 l;
1348
1349         if (!otg || isp != the_transceiver)
1350                 return -ENODEV;
1351
1352         if (!gadget) {
1353                 omap_writew(0, OTG_IRQ_EN);
1354                 if (!isp->otg.default_a)
1355                         enable_vbus_draw(isp, 0);
1356                 usb_gadget_vbus_disconnect(isp->otg.gadget);
1357                 isp->otg.gadget = 0;
1358                 power_down(isp);
1359                 return 0;
1360         }
1361
1362 #ifdef  CONFIG_USB_OTG
1363         isp->otg.gadget = gadget;
1364         dev_dbg(&isp->client->dev, "registered gadget\n");
1365         /* gadget driver may be suspended until vbus_connect () */
1366         if (isp->otg.host)
1367                 return isp1301_otg_enable(isp);
1368         return 0;
1369
1370 #elif   !defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OHCI_HCD_MODULE)
1371         isp->otg.gadget = gadget;
1372         // FIXME update its refcount
1373
1374         l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
1375         l &= ~(OTG_XCEIV_OUTPUTS|OTG_CTRL_BITS);
1376         l |= OTG_ID;
1377         omap_writel(l, OTG_CTRL);
1378
1379         power_up(isp);
1380         isp->otg.state = OTG_STATE_B_IDLE;
1381
1382         if (machine_is_omap_h2())
1383                 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
1384
1385         isp1301_set_bits(isp, ISP1301_INTERRUPT_RISING,
1386                 INTR_SESS_VLD);
1387         isp1301_set_bits(isp, ISP1301_INTERRUPT_FALLING,
1388                 INTR_VBUS_VLD);
1389         dev_info(&isp->client->dev, "B-Peripheral sessions ok\n");
1390         dump_regs(isp, __func__);
1391
1392         /* If this has a Mini-AB connector, this mode is highly
1393          * nonstandard ... but can be handy for testing, so long
1394          * as you don't plug a Mini-A cable into the jack.
1395          */
1396         if (isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE) & INTR_VBUS_VLD)
1397                 b_peripheral(isp);
1398
1399         return 0;
1400
1401 #else
1402         dev_dbg(&isp->client->dev, "peripheral sessions not allowed\n");
1403         return -EINVAL;
1404 #endif
1405 }
1406
1407
1408 /*-------------------------------------------------------------------------*/
1409
1410 static int
1411 isp1301_set_power(struct otg_transceiver *dev, unsigned mA)
1412 {
1413         if (!the_transceiver)
1414                 return -ENODEV;
1415         if (dev->state == OTG_STATE_B_PERIPHERAL)
1416                 enable_vbus_draw(the_transceiver, mA);
1417         return 0;
1418 }
1419
1420 static int
1421 isp1301_start_srp(struct otg_transceiver *dev)
1422 {
1423         struct isp1301  *isp = container_of(dev, struct isp1301, otg);
1424         u32             otg_ctrl;
1425
1426         if (!dev || isp != the_transceiver
1427                         || isp->otg.state != OTG_STATE_B_IDLE)
1428                 return -ENODEV;
1429
1430         otg_ctrl = omap_readl(OTG_CTRL);
1431         if (!(otg_ctrl & OTG_BSESSEND))
1432                 return -EINVAL;
1433
1434         otg_ctrl |= OTG_B_BUSREQ;
1435         otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK;
1436         omap_writel(otg_ctrl, OTG_CTRL);
1437         isp->otg.state = OTG_STATE_B_SRP_INIT;
1438
1439         pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
1440                         omap_readl(OTG_CTRL));
1441 #ifdef  CONFIG_USB_OTG
1442         check_state(isp, __func__);
1443 #endif
1444         return 0;
1445 }
1446
1447 static int
1448 isp1301_start_hnp(struct otg_transceiver *dev)
1449 {
1450 #ifdef  CONFIG_USB_OTG
1451         struct isp1301  *isp = container_of(dev, struct isp1301, otg);
1452         u32 l;
1453
1454         if (!dev || isp != the_transceiver)
1455                 return -ENODEV;
1456         if (isp->otg.default_a && (isp->otg.host == NULL
1457                         || !isp->otg.host->b_hnp_enable))
1458                 return -ENOTCONN;
1459         if (!isp->otg.default_a && (isp->otg.gadget == NULL
1460                         || !isp->otg.gadget->b_hnp_enable))
1461                 return -ENOTCONN;
1462
1463         /* We want hardware to manage most HNP protocol timings.
1464          * So do this part as early as possible...
1465          */
1466         switch (isp->otg.state) {
1467         case OTG_STATE_B_HOST:
1468                 isp->otg.state = OTG_STATE_B_PERIPHERAL;
1469                 /* caller will suspend next */
1470                 break;
1471         case OTG_STATE_A_HOST:
1472 #if 0
1473                 /* autoconnect mode avoids irq latency bugs */
1474                 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
1475                                 MC1_BDIS_ACON_EN);
1476 #endif
1477                 /* caller must suspend then clear A_BUSREQ */
1478                 usb_gadget_vbus_connect(isp->otg.gadget);
1479                 l = omap_readl(OTG_CTRL);
1480                 l |= OTG_A_SETB_HNPEN;
1481                 omap_writel(l, OTG_CTRL);
1482
1483                 break;
1484         case OTG_STATE_A_PERIPHERAL:
1485                 /* initiated by B-Host suspend */
1486                 break;
1487         default:
1488                 return -EILSEQ;
1489         }
1490         pr_debug("otg: HNP %s, %06x ...\n",
1491                 state_name(isp), omap_readl(OTG_CTRL));
1492         check_state(isp, __func__);
1493         return 0;
1494 #else
1495         /* srp-only */
1496         return -EINVAL;
1497 #endif
1498 }
1499
1500 /*-------------------------------------------------------------------------*/
1501
1502 static int __init isp1301_probe(struct i2c_client *i2c)
1503 {
1504         int                     status;
1505         struct isp1301          *isp;
1506
1507         if (the_transceiver)
1508                 return 0;
1509
1510         isp = kzalloc(sizeof *isp, GFP_KERNEL);
1511         if (!isp)
1512                 return 0;
1513
1514         INIT_WORK(&isp->work, isp1301_work);
1515         init_timer(&isp->timer);
1516         isp->timer.function = isp1301_timer;
1517         isp->timer.data = (unsigned long) isp;
1518
1519         i2c_set_clientdata(i2c, isp);
1520         isp->client = i2c;
1521
1522         /* verify the chip (shouldn't be necesary) */
1523         status = isp1301_get_u16(isp, ISP1301_VENDOR_ID);
1524         if (status != I2C_VENDOR_ID_PHILIPS) {
1525                 dev_dbg(&i2c->dev, "not philips id: %d\n", status);
1526                 goto fail;
1527         }
1528         status = isp1301_get_u16(isp, ISP1301_PRODUCT_ID);
1529         if (status != I2C_PRODUCT_ID_PHILIPS_1301) {
1530                 dev_dbg(&i2c->dev, "not isp1301, %d\n", status);
1531                 goto fail;
1532         }
1533         isp->i2c_release = i2c->dev.release;
1534         i2c->dev.release = isp1301_release;
1535
1536         /* initial development used chiprev 2.00 */
1537         status = i2c_smbus_read_word_data(i2c, ISP1301_BCD_DEVICE);
1538         dev_info(&i2c->dev, "chiprev %x.%02x, driver " DRIVER_VERSION "\n",
1539                 status >> 8, status & 0xff);
1540
1541         /* make like power-on reset */
1542         isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1, MC1_MASK);
1543
1544         isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_BI_DI);
1545         isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_2, ~MC2_BI_DI);
1546
1547         isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1,
1548                                 OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN);
1549         isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1,
1550                                 ~(OTG1_DM_PULLDOWN | OTG1_DP_PULLDOWN));
1551
1552         isp1301_clear_bits(isp, ISP1301_INTERRUPT_LATCH, ~0);
1553         isp1301_clear_bits(isp, ISP1301_INTERRUPT_FALLING, ~0);
1554         isp1301_clear_bits(isp, ISP1301_INTERRUPT_RISING, ~0);
1555
1556 #ifdef  CONFIG_USB_OTG
1557         status = otg_bind(isp);
1558         if (status < 0) {
1559                 dev_dbg(&i2c->dev, "can't bind OTG\n");
1560                 goto fail;
1561         }
1562 #endif
1563
1564         if (machine_is_omap_h2()) {
1565                 /* full speed signaling by default */
1566                 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1,
1567                         MC1_SPEED);
1568                 isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2,
1569                         MC2_SPD_SUSP_CTRL);
1570
1571                 /* IRQ wired at M14 */
1572                 omap_cfg_reg(M14_1510_GPIO2);
1573                 if (gpio_request(2, "isp1301") == 0)
1574                         gpio_direction_input(2);
1575                 isp->irq_type = IRQF_TRIGGER_FALLING;
1576         }
1577
1578         isp->irq_type |= IRQF_SAMPLE_RANDOM;
1579         status = request_irq(i2c->irq, isp1301_irq,
1580                         isp->irq_type, DRIVER_NAME, isp);
1581         if (status < 0) {
1582                 dev_dbg(&i2c->dev, "can't get IRQ %d, err %d\n",
1583                                 i2c->irq, status);
1584                 goto fail;
1585         }
1586
1587         isp->otg.dev = &i2c->dev;
1588         isp->otg.label = DRIVER_NAME;
1589
1590         isp->otg.set_host = isp1301_set_host,
1591         isp->otg.set_peripheral = isp1301_set_peripheral,
1592         isp->otg.set_power = isp1301_set_power,
1593         isp->otg.start_srp = isp1301_start_srp,
1594         isp->otg.start_hnp = isp1301_start_hnp,
1595
1596         enable_vbus_draw(isp, 0);
1597         power_down(isp);
1598         the_transceiver = isp;
1599
1600 #ifdef  CONFIG_USB_OTG
1601         update_otg1(isp, isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE));
1602         update_otg2(isp, isp1301_get_u8(isp, ISP1301_OTG_STATUS));
1603 #endif
1604
1605         dump_regs(isp, __func__);
1606
1607 #ifdef  VERBOSE
1608         mod_timer(&isp->timer, jiffies + TIMER_JIFFIES);
1609         dev_dbg(&i2c->dev, "scheduled timer, %d min\n", TIMER_MINUTES);
1610 #endif
1611
1612         status = otg_set_transceiver(&isp->otg);
1613         if (status < 0)
1614                 dev_err(&i2c->dev, "can't register transceiver, %d\n",
1615                         status);
1616
1617         return 0;
1618
1619 fail:
1620         kfree(isp);
1621         return -ENODEV;
1622 }
1623
1624 static const struct i2c_device_id isp1301_id[] = {
1625         { "isp1301_omap", 0 },
1626         { }
1627 };
1628 MODULE_DEVICE_TABLE(i2c, isp1301_id);
1629
1630 static struct i2c_driver isp1301_driver = {
1631         .driver = {
1632                 .name   = "isp1301_omap",
1633         },
1634         .probe          = isp1301_probe,
1635         .remove         = __exit_p(isp1301_remove),
1636         .id_table       = isp1301_id,
1637 };
1638
1639 /*-------------------------------------------------------------------------*/
1640
1641 static int __init isp_init(void)
1642 {
1643         return i2c_add_driver(&isp1301_driver);
1644 }
1645 module_init(isp_init);
1646
1647 static void __exit isp_exit(void)
1648 {
1649         if (the_transceiver)
1650                 otg_set_transceiver(0);
1651         i2c_del_driver(&isp1301_driver);
1652 }
1653 module_exit(isp_exit);
1654