drivers/mfd/cpcap-whisper.c

   1 /*
   2  * Copyright (C) 2010 Motorola, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  16  * 02111-1307, USA
  17  */
  18
  19 #include <linux/delay.h>
  20 #include <linux/errno.h>
  21 #include <linux/err.h>
  22 #include <linux/gpio.h>
  23 #include <linux/module.h>
  24 #include <linux/platform_device.h>
  25 #include <linux/switch.h>
  26 #include <linux/wakelock.h>
  27 #include <linux/workqueue.h>
  28
  29 #include <linux/regulator/consumer.h>
  30 #include <linux/usb/otg.h>
  31
  32 #include <linux/spi/cpcap.h>
  33 #include <linux/spi/cpcap-regbits.h>
  34 #include <linux/spi/spi.h>
  35
  36 void tegra_cpcap_audio_dock_state(bool connected);
  37
  38 #define SENSE_USB_CLIENT    (CPCAP_BIT_ID_FLOAT_S  | \
  39                              CPCAP_BIT_VBUSVLD_S   | \
  40                              CPCAP_BIT_SESSVLD_S)
  41
  42 #define SENSE_USB_FLASH     (CPCAP_BIT_VBUSVLD_S   | \
  43                              CPCAP_BIT_SESSVLD_S)
  44
  45 #define SENSE_USB_HOST      (CPCAP_BIT_ID_GROUND_S)
  46 #define SENSE_USB_HOST_MASK (~CPCAP_BIT_SE1_S)
  47
  48 #define SENSE_FACTORY       (CPCAP_BIT_ID_FLOAT_S  | \
  49                              CPCAP_BIT_ID_GROUND_S | \
  50                              CPCAP_BIT_VBUSVLD_S   | \
  51                              CPCAP_BIT_SESSVLD_S)
  52
  53 #define SENSE_WHISPER_SPD   (CPCAP_BIT_SE1_S)
  54
  55 #define SENSE_WHISPER_PPD   (0)
  56
  57 #define SENSE_WHISPER_SMART (CPCAP_BIT_ID_GROUND_S | \
  58                              CPCAP_BIT_VBUSVLD_S   | \
  59                              CPCAP_BIT_SESSVLD_S)
  60
  61 #define SENSE_CHARGER_FLOAT (CPCAP_BIT_ID_FLOAT_S  | \
  62                              CPCAP_BIT_VBUSVLD_S   | \
  63                              CPCAP_BIT_SESSVLD_S   | \
  64                              CPCAP_BIT_SE1_S)
  65
  66 #define SENSE_CHARGER       (CPCAP_BIT_VBUSVLD_S   | \
  67                              CPCAP_BIT_SESSVLD_S   | \
  68                              CPCAP_BIT_SE1_S)
  69
  70 /* TODO: Update with appropriate value. */
  71 #define ADC_AUDIO_THRES     0x12C
  72
  73 enum cpcap_det_state {
  74         CONFIG,
  75         SAMPLE_1,
  76         SAMPLE_2,
  77         IDENTIFY,
  78         IDENTIFY_WHISPER,
  79         USB,
  80         USB_POWER,
  81         WHISPER,
  82         WHISPER_SMART,
  83 };
  84
  85 enum cpcap_accy {
  86         CPCAP_ACCY_USB,
  87         CPCAP_ACCY_USB_HOST,
  88         CPCAP_ACCY_WHISPER,
  89         CPCAP_ACCY_WHISPER_SMART,
  90         CPCAP_ACCY_CHARGER,
  91         CPCAP_ACCY_NONE,
  92
  93         /* Used while debouncing the accessory. */
  94         CPCAP_ACCY_UNKNOWN,
  95 };
  96
  97 enum {
  98         NO_DOCK,
  99         DESK_DOCK,
 100         CAR_DOCK,
 101         LE_DOCK,
 102         HE_DOCK,
 103 };
 104
 105 struct cpcap_whisper_data {
 106         struct cpcap_device *cpcap;
 107         struct cpcap_whisper_pdata *pdata;
 108         struct delayed_work work;
 109         struct workqueue_struct *wq;
 110         unsigned short sense;
 111         unsigned short prev_sense;
 112         enum cpcap_det_state state;
 113         struct regulator *regulator;
 114         struct wake_lock wake_lock;
 115         unsigned char is_vusb_enabled;
 116         struct switch_dev wsdev; /* Whisper switch */
 117         struct switch_dev dsdev; /* Dock switch */
 118         struct switch_dev asdev; /* Audio switch */
 119         struct switch_dev csdev; /* Invalid charger switch */
 120         char dock_id[CPCAP_WHISPER_ID_SIZE];
 121         char dock_prop[CPCAP_WHISPER_PROP_SIZE];
 122         struct otg_transceiver *otg;
 123 };
 124
 125 static struct cpcap_whisper_data *whisper_di;
 126
 127 static int whisper_debug;
 128 module_param(whisper_debug, int, S_IRUGO | S_IWUSR | S_IWGRP);
 129
 130 static ssize_t print_name(struct switch_dev *dsdev, char *buf)
 131 {
 132         switch (switch_get_state(dsdev)) {
 133         case NO_DOCK:
 134                 return sprintf(buf, "None\n");
 135         case DESK_DOCK:
 136                 return sprintf(buf, "DESK\n");
 137         case CAR_DOCK:
 138                 return sprintf(buf, "CAR\n");
 139         case LE_DOCK:
 140                 return sprintf(buf, "LE\n");
 141         case HE_DOCK:
 142                 return sprintf(buf, "HE\n");
 143         }
 144
 145         return -EINVAL;
 146 }
 147
 148 static ssize_t dock_id_show(struct device *dev, struct device_attribute *attr,
 149                             char *buf)
 150 {
 151         struct switch_dev *dsdev = dev_get_drvdata(dev);
 152         struct cpcap_whisper_data *data =
 153                 container_of(dsdev, struct cpcap_whisper_data, dsdev);
 154
 155         return snprintf(buf, PAGE_SIZE, "%s\n", data->dock_id);
 156 }
 157 static DEVICE_ATTR(dock_addr, S_IRUGO | S_IWUSR, dock_id_show, NULL);
 158
 159 static ssize_t dock_prop_show(struct device *dev, struct device_attribute *attr,
 160                               char *buf)
 161 {
 162         struct switch_dev *dsdev = dev_get_drvdata(dev);
 163         struct cpcap_whisper_data *data =
 164                 container_of(dsdev, struct cpcap_whisper_data, dsdev);
 165
 166         return snprintf(buf, PAGE_SIZE, "%s\n", data->dock_prop);
 167 }
 168 static DEVICE_ATTR(dock_prop, S_IRUGO | S_IWUSR, dock_prop_show, NULL);
 169
 170 static void vusb_enable(struct cpcap_whisper_data *data)
 171 {
 172         if (!data->is_vusb_enabled) {
 173                 regulator_enable(data->regulator);
 174                 data->is_vusb_enabled = 1;
 175         }
 176 }
 177
 178 static void vusb_disable(struct cpcap_whisper_data *data)
 179 {
 180         if (data->is_vusb_enabled) {
 181                 regulator_disable(data->regulator);
 182                 data->is_vusb_enabled = 0;
 183         }
 184 }
 185
 186 static int get_sense(struct cpcap_whisper_data *data)
 187 {
 188         int retval = -EFAULT;
 189         unsigned short value;
 190         struct cpcap_device *cpcap;
 191
 192         if (!data)
 193                 return -EFAULT;
 194         cpcap = data->cpcap;
 195
 196         retval = cpcap_regacc_read(cpcap, CPCAP_REG_INTS1, &value);
 197         if (retval)
 198                 return retval;
 199
 200         /* Clear ASAP after read. */
 201         retval = cpcap_regacc_write(cpcap, CPCAP_REG_INT1,
 202                                      (CPCAP_BIT_CHRG_DET_I |
 203                                       CPCAP_BIT_ID_FLOAT_I |
 204                                       CPCAP_BIT_ID_GROUND_I),
 205                                      (CPCAP_BIT_CHRG_DET_I |
 206                                       CPCAP_BIT_ID_FLOAT_I |
 207                                       CPCAP_BIT_ID_GROUND_I));
 208         if (retval)
 209                 return retval;
 210
 211         data->sense = value & (CPCAP_BIT_ID_FLOAT_S |
 212                                CPCAP_BIT_ID_GROUND_S);
 213
 214         retval = cpcap_regacc_read(cpcap, CPCAP_REG_INTS2, &value);
 215         if (retval)
 216                 return retval;
 217
 218         /* Clear ASAP after read. */
 219         retval = cpcap_regacc_write(cpcap, CPCAP_REG_INT2,
 220                                     (CPCAP_BIT_VBUSVLD_I |
 221                                      CPCAP_BIT_SESSVLD_I |
 222                                      CPCAP_BIT_SE1_I),
 223                                     (CPCAP_BIT_VBUSVLD_I |
 224                                      CPCAP_BIT_SESSVLD_I |
 225                                      CPCAP_BIT_SE1_I));
 226         if (retval)
 227                 return retval;
 228
 229         data->sense |= value & (CPCAP_BIT_VBUSVLD_S |
 230                                 CPCAP_BIT_SESSVLD_S |
 231                                 CPCAP_BIT_SE1_S);
 232         return 0;
 233 }
 234
 235 static int configure_hardware(struct cpcap_whisper_data *data,
 236                               enum cpcap_accy accy)
 237 {
 238         int retval;
 239
 240         retval = cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1,
 241                                     CPCAP_BIT_DP150KPU,
 242                                     (CPCAP_BIT_DP150KPU | CPCAP_BIT_DP1K5PU |
 243                                      CPCAP_BIT_DM1K5PU | CPCAP_BIT_DPPD |
 244                                      CPCAP_BIT_DMPD));
 245
 246         switch (accy) {
 247         case CPCAP_ACCY_USB:
 248                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1, 0,
 249                                              CPCAP_BIT_VBUSPD);
 250                 gpio_set_value(data->pdata->data_gpio, 1);
 251                 if (data->otg)
 252                         blocking_notifier_call_chain(&data->otg->notifier,
 253                                                      USB_EVENT_VBUS, NULL);
 254                 break;
 255
 256         case CPCAP_ACCY_USB_HOST:
 257                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1, 0,
 258                                              CPCAP_BIT_VBUSPD);
 259                 gpio_set_value(data->pdata->data_gpio, 1);
 260                 if (data->otg)
 261                         blocking_notifier_call_chain(&data->otg->notifier,
 262                                                      USB_EVENT_ID, NULL);
 263                 break;
 264
 265         case CPCAP_ACCY_WHISPER:
 266                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1, 0,
 267                                              CPCAP_BIT_VBUSPD);
 268                 break;
 269
 270         case CPCAP_ACCY_WHISPER_SMART:
 271                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1, 0,
 272                                              CPCAP_BIT_VBUSPD);
 273                 gpio_set_value(data->pdata->data_gpio, 1);
 274                 if (data->otg)
 275                         blocking_notifier_call_chain(&data->otg->notifier,
 276                                                      USB_EVENT_ID, NULL);
 277                 break;
 278
 279         case CPCAP_ACCY_UNKNOWN:
 280                 gpio_set_value(data->pdata->pwr_gpio, 0);
 281                 gpio_set_value(data->pdata->data_gpio, 0);
 282                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1, 0,
 283                                              (CPCAP_BIT_VBUSPD |
 284                                               CPCAP_BIT_ID100KPU));
 285                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC2, 0,
 286                                              (CPCAP_BIT_EMUMODE2 |
 287                                               CPCAP_BIT_EMUMODE1 |
 288                                               CPCAP_BIT_EMUMODE0));
 289                 break;
 290
 291         case CPCAP_ACCY_CHARGER:
 292                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1,
 293                                              CPCAP_BIT_VBUSPD,
 294                                              CPCAP_BIT_VBUSPD);
 295                 break;
 296
 297         case CPCAP_ACCY_NONE:
 298         default:
 299                 gpio_set_value(data->pdata->pwr_gpio, 0);
 300                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC1,
 301                                              CPCAP_BIT_VBUSPD,
 302                                              CPCAP_BIT_VBUSPD);
 303                 retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC2, 0,
 304                                              CPCAP_BIT_USBXCVREN);
 305                 vusb_disable(data);
 306                 if (data->otg)
 307                         blocking_notifier_call_chain(&data->otg->notifier,
 308                                                      USB_EVENT_NONE, NULL);
 309                 break;
 310         }
 311
 312         if (retval != 0)
 313                 retval = -EFAULT;
 314
 315         return retval;
 316 }
 317
 318 static const char *accy_names[6] = {"USB", "USB host", "whisper",
 319                                     "whisper_smart", "charger", "none"};
 320
 321 static void whisper_notify(struct cpcap_whisper_data *di, enum cpcap_accy accy)
 322 {
 323         pr_info("%s: accy=%s\n", __func__, accy_names[accy]);
 324
 325         configure_hardware(di, accy);
 326
 327         if (accy == CPCAP_ACCY_WHISPER)
 328                 switch_set_state(&di->wsdev, 1);
 329         else if (accy == CPCAP_ACCY_CHARGER)
 330                 switch_set_state(&di->csdev, 1);
 331         else {
 332                 switch_set_state(&di->wsdev, 0);
 333                 switch_set_state(&di->dsdev, NO_DOCK);
 334                 switch_set_state(&di->asdev, 0);
 335                 switch_set_state(&di->csdev, 0);
 336                 memset(di->dock_id, 0, CPCAP_WHISPER_ID_SIZE);
 337                 memset(di->dock_prop, 0, CPCAP_WHISPER_PROP_SIZE);
 338                 tegra_cpcap_audio_dock_state(false);
 339         }
 340
 341         wake_lock_timeout(&di->wake_lock, HZ / 2);
 342 }
 343
 344 static void whisper_audio_check(struct cpcap_whisper_data *di)
 345 {
 346         struct cpcap_adc_request req;
 347         int ret;
 348         unsigned short value;
 349         int audio;
 350
 351         if (!switch_get_state(&di->dsdev))
 352                 return;
 353
 354         cpcap_regacc_read(di->cpcap, CPCAP_REG_USBC1, &value);
 355         value &= CPCAP_BIT_ID100KPU;
 356
 357         cpcap_regacc_write(di->cpcap, CPCAP_REG_USBC1, CPCAP_BIT_IDPUCNTRL,
 358                            (CPCAP_BIT_ID100KPU | CPCAP_BIT_IDPUCNTRL));
 359
 360         msleep(200);
 361
 362         req.format = CPCAP_ADC_FORMAT_RAW;
 363         req.timing = CPCAP_ADC_TIMING_IMM;
 364         req.type = CPCAP_ADC_TYPE_BANK_0;
 365
 366         ret = cpcap_adc_sync_read(di->cpcap, &req);
 367
 368         cpcap_regacc_write(di->cpcap, CPCAP_REG_USBC1, value,
 369                            (CPCAP_BIT_ID100KPU | CPCAP_BIT_IDPUCNTRL));
 370
 371         if (whisper_debug)
 372                 pr_info("%s: ADC result=0x%X (ret=%d, status=%d)\n", __func__,
 373                         req.result[CPCAP_ADC_USB_ID], ret, req.status);
 374
 375         audio = (req.result[CPCAP_ADC_USB_ID] > ADC_AUDIO_THRES) ? 1 : 0;
 376         switch_set_state(&di->asdev, audio);
 377         tegra_cpcap_audio_dock_state(!!audio);
 378
 379         pr_info("%s: Audio cable %s present\n", __func__,
 380                 (audio ? "is" : "not"));
 381 }
 382
 383 static void whisper_det_work(struct work_struct *work)
 384 {
 385         struct cpcap_whisper_data *data =
 386                 container_of(work, struct cpcap_whisper_data, work.work);
 387
 388         switch (data->state) {
 389         case CONFIG:
 390                 wake_lock(&data->wake_lock);
 391                 vusb_enable(data);
 392                 cpcap_irq_mask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 393                 cpcap_irq_mask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 394                 cpcap_irq_mask(data->cpcap, CPCAP_IRQ_IDGND);
 395
 396                 configure_hardware(data, CPCAP_ACCY_UNKNOWN);
 397
 398                 data->state = SAMPLE_1;
 399                 queue_delayed_work(data->wq, &data->work, msecs_to_jiffies(11));
 400                 break;
 401
 402         case SAMPLE_1:
 403                 get_sense(data);
 404                 data->state = SAMPLE_2;
 405                 queue_delayed_work(data->wq, &data->work,
 406                                    msecs_to_jiffies(100));
 407                 break;
 408
 409         case SAMPLE_2:
 410                 data->prev_sense = data->sense;
 411                 get_sense(data);
 412
 413                 if (data->prev_sense != data->sense) {
 414                         /* Stay in this state */
 415                         data->state = SAMPLE_2;
 416                 } else
 417                         data->state = IDENTIFY;
 418
 419                 queue_delayed_work(data->wq, &data->work,
 420                                    msecs_to_jiffies(100));
 421                 break;
 422
 423         case IDENTIFY:
 424                 get_sense(data);
 425                 data->state = CONFIG;
 426
 427                 if (whisper_debug)
 428                         pr_info("%s: sense=0x%04x\n", __func__, data->sense);
 429
 430                 if ((data->sense == SENSE_USB_CLIENT) ||
 431                     (data->sense == SENSE_USB_FLASH) ||
 432                     (data->sense == SENSE_FACTORY)) {
 433                         whisper_notify(data, CPCAP_ACCY_USB);
 434
 435                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 436                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDGND);
 437
 438                         /* Special handling of USB undetect. */
 439                         data->state = USB;
 440                 } else if ((data->sense & SENSE_USB_HOST_MASK) ==
 441                            SENSE_USB_HOST) {
 442                         whisper_notify(data, CPCAP_ACCY_USB_HOST);
 443
 444                         data->state = USB_POWER;
 445                         queue_delayed_work(data->wq, &data->work,
 446                                            msecs_to_jiffies(200));
 447                 } else if ((data->sense == SENSE_WHISPER_SPD) ||
 448                            (data->sense == SENSE_WHISPER_PPD)) {
 449                         gpio_set_value(data->pdata->pwr_gpio, 1);
 450
 451                         /* Extra identification step for Whisper. */
 452                         data->state = IDENTIFY_WHISPER;
 453                         queue_delayed_work(data->wq, &data->work,
 454                                            msecs_to_jiffies(47));
 455                 } else if (data->sense == SENSE_WHISPER_SMART) {
 456                         whisper_notify(data, CPCAP_ACCY_WHISPER_SMART);
 457
 458                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 459                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDGND);
 460
 461                         /* Special handling of Whisper Smart accessories. */
 462                         data->state = WHISPER_SMART;
 463                 } else if ((data->sense == SENSE_CHARGER_FLOAT) ||
 464                            (data->sense == SENSE_CHARGER)) {
 465                         whisper_notify(data, CPCAP_ACCY_CHARGER);
 466
 467                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 468                 } else {
 469                         whisper_notify(data, CPCAP_ACCY_NONE);
 470
 471                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 472                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 473                 }
 474                 break;
 475
 476         case IDENTIFY_WHISPER:
 477                 get_sense(data);
 478                 data->state = CONFIG;
 479
 480                 if (whisper_debug)
 481                         pr_info("%s: sense=0x%04x\n", __func__, data->sense);
 482
 483                 if (data->sense & CPCAP_BIT_SE1_S) {
 484                         whisper_notify(data, CPCAP_ACCY_WHISPER);
 485
 486                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 487                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDGND);
 488
 489                         /* Special handling of Whisper undetect. */
 490                         data->state = WHISPER;
 491                 } else {
 492                         whisper_notify(data, CPCAP_ACCY_NONE);
 493
 494                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 495                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 496                 }
 497                 break;
 498
 499         case USB:
 500                 get_sense(data);
 501
 502                 /* Check if Smart Whisper accessory fully inserted. */
 503                 if (data->sense == SENSE_WHISPER_SMART) {
 504                         data->state = WHISPER_SMART;
 505
 506                         whisper_notify(data, CPCAP_ACCY_NONE);
 507                         whisper_notify(data, CPCAP_ACCY_WHISPER_SMART);
 508
 509                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 510                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDGND);
 511                 } else {
 512                         data->state = CONFIG;
 513                         queue_delayed_work(data->wq, &data->work, 0);
 514                 }
 515
 516                 break;
 517
 518         case USB_POWER:
 519                 gpio_set_value(data->pdata->pwr_gpio, 1);
 520                 data->state = CONFIG;
 521                 cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 522                 break;
 523
 524         case WHISPER:
 525                 get_sense(data);
 526
 527                 /* The removal of a Whisper accessory can only be detected
 528                  * if ID is floating.
 529                  */
 530                 if (data->sense & CPCAP_BIT_ID_FLOAT_S) {
 531                         data->state = CONFIG;
 532                         queue_delayed_work(data->wq, &data->work, 0);
 533                 } else {
 534                         if (!(data->sense & CPCAP_BIT_ID_GROUND_S))
 535                                 whisper_audio_check(data);
 536
 537                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDFLOAT);
 538                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_IDGND);
 539                 }
 540                 break;
 541
 542         case WHISPER_SMART:
 543                 get_sense(data);
 544
 545                 /* The removal of a Whisper Smart accessory can only be detected
 546                  * when VBUS disappears.
 547                  */
 548                 if (!(data->sense & CPCAP_BIT_VBUSVLD_S)) {
 549                         data->state = CONFIG;
 550                         queue_delayed_work(data->wq, &data->work, 0);
 551                 } else {
 552                         if (!(data->sense & CPCAP_BIT_ID_GROUND_S))
 553                                 pr_info("%s: ID no longer ground\n", __func__);
 554
 555                         cpcap_irq_unmask(data->cpcap, CPCAP_IRQ_CHRG_DET);
 556                 }
 557                 break;
 558
 559         default:
 560                 /* This shouldn't happen.  Need to reset state machine. */
 561                 vusb_disable(data);
 562                 data->state = CONFIG;
 563                 queue_delayed_work(data->wq, &data->work, 0);
 564                 break;
 565         }
 566 }
 567
 568 static void whisper_int_handler(enum cpcap_irqs int_event, void *data)
 569 {
 570         struct cpcap_whisper_data *di = data;
 571
 572         if (whisper_debug)
 573                 pr_info("%s: irq=%d\n", __func__, int_event);
 574
 575         queue_delayed_work(di->wq, &(di->work), 0);
 576 }
 577
 578 int cpcap_accy_whisper(struct cpcap_device *cpcap,
 579                        struct cpcap_whisper_request *req)
 580 {
 581         struct cpcap_whisper_data *di = cpcap->accydata;
 582         int retval = -EAGAIN;
 583         unsigned short value = 0;
 584         int dock;
 585
 586         if (!di)
 587                 return -ENODEV;
 588
 589         /* Can only change settings if not debouncing and whisper device
 590          * is present. */
 591         if (di->state == WHISPER) {
 592                 if (req->cmd & CPCAP_WHISPER_ENABLE_UART)
 593                         value = CPCAP_BIT_EMUMODE0;
 594                 retval = cpcap_regacc_write(cpcap, CPCAP_REG_USBC2, value,
 595                                             (CPCAP_BIT_EMUMODE2 |
 596                                              CPCAP_BIT_EMUMODE1 |
 597                                              CPCAP_BIT_EMUMODE0));
 598
 599                 value = (req->cmd & CPCAP_WHISPER_MODE_PU) ?
 600                         CPCAP_BIT_ID100KPU : 0;
 601                 retval |= cpcap_regacc_write(cpcap, CPCAP_REG_USBC1,
 602                                              value, CPCAP_BIT_ID100KPU);
 603                 if (value) {
 604                         retval |= cpcap_regacc_write(cpcap, CPCAP_REG_USBC2,
 605                                                      (CPCAP_BIT_EMUMODE2 |
 606                                                       CPCAP_BIT_EMUMODE0),
 607                                                      (CPCAP_BIT_EMUMODE2 |
 608                                                       CPCAP_BIT_EMUMODE1 |
 609                                                       CPCAP_BIT_EMUMODE0));
 610                 }
 611
 612                 /* Report dock type to system. */
 613                 dock = (req->cmd & CPCAP_WHISPER_ACCY_MASK) >>
 614                         CPCAP_WHISPER_ACCY_SHFT;
 615                 if (dock && (strlen(req->dock_id) < CPCAP_WHISPER_ID_SIZE))
 616                         strncpy(di->dock_id, req->dock_id,
 617                                 CPCAP_WHISPER_ID_SIZE);
 618                 if (dock && (strlen(req->dock_prop) < CPCAP_WHISPER_PROP_SIZE))
 619                         strncpy(di->dock_prop, req->dock_prop,
 620                                 CPCAP_WHISPER_PROP_SIZE);
 621                 switch_set_state(&di->dsdev, dock);
 622
 623                 whisper_audio_check(di);
 624         } else if (di->state == WHISPER_SMART) {
 625                 /* Report dock type to system. */
 626                 dock = (req->cmd & CPCAP_WHISPER_ACCY_MASK) >>
 627                         CPCAP_WHISPER_ACCY_SHFT;
 628                 if (dock && (strlen(req->dock_id) < CPCAP_WHISPER_ID_SIZE))
 629                         strncpy(di->dock_id, req->dock_id,
 630                                 CPCAP_WHISPER_ID_SIZE);
 631                 if (dock && (strlen(req->dock_prop) < CPCAP_WHISPER_PROP_SIZE))
 632                         strncpy(di->dock_prop, req->dock_prop,
 633                                 CPCAP_WHISPER_PROP_SIZE);
 634                 switch_set_state(&di->dsdev, dock);
 635                 retval = 0;
 636         }
 637
 638         return retval;
 639 }
 640
 641 void cpcap_accy_whisper_spdif_set_state(int state)
 642 {
 643         if (!whisper_di)
 644                 return;
 645
 646         if (!switch_get_state(&whisper_di->dsdev))
 647                 return;
 648
 649         state = ((state > 0) ? 2 : 0);
 650         switch_set_state(&whisper_di->asdev, state);
 651
 652         pr_info("%s: Audio cable %s present\n", __func__,
 653                 (state ? "is" : "not"));
 654 }
 655
 656 static int cpcap_whisper_probe(struct platform_device *pdev)
 657 {
 658         int retval;
 659         struct cpcap_whisper_data *data;
 660
 661         if (pdev->dev.platform_data == NULL) {
 662                 dev_err(&pdev->dev, "no platform_data\n");
 663                 return -EINVAL;
 664         }
 665
 666         data = kzalloc(sizeof(*data), GFP_KERNEL);
 667         if (!data)
 668                 return -ENOMEM;
 669
 670         data->pdata = pdev->dev.platform_data;
 671         data->cpcap = platform_get_drvdata(pdev);
 672         data->state = CONFIG;
 673         data->wq = create_singlethread_workqueue("cpcap_whisper");
 674         INIT_DELAYED_WORK(&data->work, whisper_det_work);
 675         wake_lock_init(&data->wake_lock, WAKE_LOCK_SUSPEND, "whisper");
 676
 677         data->wsdev.name = "whisper";
 678         switch_dev_register(&data->wsdev);
 679
 680         data->asdev.name = "usb_audio";
 681         switch_dev_register(&data->asdev);
 682
 683         data->csdev.name = "invalid_charger";
 684         switch_dev_register(&data->csdev);
 685
 686         data->dsdev.name = "dock";
 687         data->dsdev.print_name = print_name;
 688         switch_dev_register(&data->dsdev);
 689         retval = device_create_file(data->dsdev.dev, &dev_attr_dock_addr);
 690         if (retval < 0) {
 691                 dev_err(&pdev->dev, "Failed to create dock_addr file\n");
 692                 goto free_mem;
 693         }
 694         retval = device_create_file(data->dsdev.dev, &dev_attr_dock_prop);
 695         if (retval < 0) {
 696                 dev_err(&pdev->dev, "Failed to create dock_prop file\n");
 697                 goto free_dock_id;
 698         }
 699
 700         platform_set_drvdata(pdev, data);
 701
 702         data->regulator = regulator_get(&pdev->dev, "vusb");
 703         if (IS_ERR(data->regulator)) {
 704                 dev_err(&pdev->dev,
 705                         "Could not get regulator for cpcap_whisper\n");
 706                 retval = PTR_ERR(data->regulator);
 707                 goto free_dock_prop;
 708         }
 709         regulator_set_voltage(data->regulator, 3300000, 3300000);
 710
 711         retval = cpcap_irq_clear(data->cpcap, CPCAP_IRQ_CHRG_DET);
 712         retval |= cpcap_irq_clear(data->cpcap, CPCAP_IRQ_IDFLOAT);
 713         retval |= cpcap_irq_clear(data->cpcap, CPCAP_IRQ_IDGND);
 714
 715         retval |= cpcap_irq_register(data->cpcap, CPCAP_IRQ_CHRG_DET,
 716                                      whisper_int_handler, data);
 717         retval |= cpcap_irq_register(data->cpcap, CPCAP_IRQ_IDFLOAT,
 718                                      whisper_int_handler, data);
 719         retval |= cpcap_irq_register(data->cpcap, CPCAP_IRQ_IDGND,
 720                                      whisper_int_handler, data);
 721
 722         retval |= cpcap_regacc_write(data->cpcap, CPCAP_REG_USBC2,
 723                                      (data->pdata->uartmux << 8),
 724                                      (CPCAP_BIT_UARTMUX1 | CPCAP_BIT_UARTMUX0));
 725
 726         if (retval != 0) {
 727                 dev_err(&pdev->dev, "Initialization Error\n");
 728                 retval = -ENODEV;
 729                 goto free_irqs;
 730         }
 731
 732 #ifdef CONFIG_USB_CPCAP_OTG
 733         data->otg = otg_get_transceiver();
 734 #endif
 735
 736         data->cpcap->accydata = data;
 737         whisper_di = data;
 738         dev_info(&pdev->dev, "CPCAP Whisper detection probed\n");
 739
 740         /* Perform initial detection */
 741         whisper_det_work(&(data->work.work));
 742
 743         return 0;
 744
 745 free_irqs:
 746         cpcap_irq_free(data->cpcap, CPCAP_IRQ_IDGND);
 747         cpcap_irq_free(data->cpcap, CPCAP_IRQ_IDFLOAT);
 748         cpcap_irq_free(data->cpcap, CPCAP_IRQ_CHRG_DET);
 749         regulator_put(data->regulator);
 750 free_dock_prop:
 751         device_remove_file(data->dsdev.dev, &dev_attr_dock_prop);
 752 free_dock_id:
 753         device_remove_file(data->dsdev.dev, &dev_attr_dock_addr);
 754 free_mem:
 755         switch_dev_unregister(&data->wsdev);
 756         switch_dev_unregister(&data->dsdev);
 757         switch_dev_unregister(&data->asdev);
 758         switch_dev_unregister(&data->csdev);
 759         wake_lock_destroy(&data->wake_lock);
 760         kfree(data);
 761
 762         return retval;
 763 }
 764
 765 static int __exit cpcap_whisper_remove(struct platform_device *pdev)
 766 {
 767         struct cpcap_whisper_data *data = platform_get_drvdata(pdev);
 768
 769         cpcap_irq_free(data->cpcap, CPCAP_IRQ_CHRG_DET);
 770         cpcap_irq_free(data->cpcap, CPCAP_IRQ_IDFLOAT);
 771         cpcap_irq_free(data->cpcap, CPCAP_IRQ_IDGND);
 772
 773         configure_hardware(data, CPCAP_ACCY_NONE);
 774         cancel_delayed_work_sync(&data->work);
 775         destroy_workqueue(data->wq);
 776
 777         device_remove_file(data->dsdev.dev, &dev_attr_dock_prop);
 778         device_remove_file(data->dsdev.dev, &dev_attr_dock_addr);
 779         switch_dev_unregister(&data->wsdev);
 780         switch_dev_unregister(&data->dsdev);
 781         switch_dev_unregister(&data->asdev);
 782         switch_dev_unregister(&data->csdev);
 783
 784         gpio_set_value(data->pdata->data_gpio, 1);
 785
 786         vusb_disable(data);
 787         regulator_put(data->regulator);
 788
 789 #ifdef CONFIG_USB_CPCAP_OTG
 790         if (data->otg)
 791                 otg_put_transceiver(data->otg);
 792 #endif
 793
 794         wake_lock_destroy(&data->wake_lock);
 795
 796         data->cpcap->accydata = NULL;
 797         kfree(data);
 798
 799         return 0;
 800 }
 801
 802 static struct platform_driver cpcap_whisper_driver = {
 803         .probe          = cpcap_whisper_probe,
 804         .remove         = __exit_p(cpcap_whisper_remove),
 805         .driver         = {
 806                 .name   = "cpcap_whisper",
 807                 .owner  = THIS_MODULE,
 808         },
 809 };
 810
 811 static int __init cpcap_whisper_init(void)
 812 {
 813         return cpcap_driver_register(&cpcap_whisper_driver);
 814 }
 815 late_initcall(cpcap_whisper_init);
 816
 817 static void __exit cpcap_whisper_exit(void)
 818 {
 819         cpcap_driver_unregister(&cpcap_whisper_driver);
 820 }
 821 module_exit(cpcap_whisper_exit);
 822
 823 MODULE_ALIAS("platform:cpcap_whisper");
 824 MODULE_DESCRIPTION("CPCAP Whisper detection driver");
 825 MODULE_AUTHOR("Motorola");
 826 MODULE_LICENSE("GPL");