drivers/misc/max77693.c

   1 /*
   2  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * See file CREDITS for list of people who contributed to this
   5  * project.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License as
   9  * published by the Free Software Foundation; either version 2 of
  10  * the License, or (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., 59 Temple Place, Suite 330, Boston,
  20  * MA 02111-1307 USA
  21  */
  22
  23 #include <common.h>
  24 #include <i2c.h>
  25 #include <asm/arch/gpio.h>
  26 #include <max77693.h>
  27
  28 /*
  29  * PMIC REGISTER
  30  */
  31
  32 #define MAX77693_PMIC_PREFIX    "max77693-pmic:"
  33
  34 #define MAX77693_PMIC_ID1       0x20
  35 #define MAX77693_PMIC_ID2       0x21
  36
  37 /* MAX77693_PMIC_ID1 */
  38 #define MAX77693_PMIC_ID        0x93
  39
  40 /* MAX77693_PMIC_ID2 */
  41 #define MAX77693_PMIC_REV_PASS1 0x0
  42 #define MAX77693_PMIC_REV_PASS2 0x1
  43 #define MAX77693_PMIC_REV_PASS3 0x2
  44
  45 /*
  46  * PMIC(CHARGER) REGISTER
  47  */
  48
  49 #define MAX77693_CHG_PREFIX     "max77693-chg:"
  50
  51 #define MAX77693_CHG_BASE       0xB0
  52 #define MAX77693_CHG_INT_OK     0xB2
  53 #define MAX77693_CHG_CNFG_00    0xB7
  54 #define MAX77693_CHG_CNFG_02    0xB9
  55 #define MAX77693_CHG_CNFG_06    0xBD
  56 #define MAX77693_SAFEOUT        0xC6
  57
  58 /* MAX77693_CHG_INT_OK */
  59 #define MAX77693_CHG_DETBAT     (0x1 << 7)
  60
  61 /* MAX77693_CHG_CNFG_00 */
  62 #define MAX77693_CHG_MODE_ON    0x05
  63
  64 /* MAX77693_CHG_CNFG_02 */
  65 #define MAX77693_CHG_CC         0x3F
  66
  67 /* MAX77693_CHG_CNFG_06 */
  68 #define MAX77693_CHG_LOCK       (0x0 << 2)
  69 #define MAX77693_CHG_UNLOCK     (0x3 << 2)
  70
  71 /*
  72  * MUIC REGISTER
  73  */
  74
  75 #define MAX77693_MUIC_PREFIX    "max77693-muic:"
  76
  77 #define MAX77693_MUIC_STATUS1   0x04
  78 #define MAX77693_MUIC_STATUS2   0x05
  79 #define MAX77693_MUIC_CONTROL1  0x0C
  80
  81 /* MAX77693_MUIC_STATUS1 */
  82 #define MAX77693_MUIC_ADC_MASK  0x1F
  83
  84 /* MAX77693_MUIC_STATUS2 */
  85 #define MAX77693_MUIC_CHG_NO    0x00
  86 #define MAX77693_MUIC_CHG_USB   0x01
  87 #define MAX77693_MUIC_CHG_USB_D 0x02
  88 #define MAX77693_MUIC_CHG_TA    0x03
  89 #define MAX77693_MUIC_CHG_TA_500 0x04
  90 #define MAX77693_MUIC_CHG_TA_1A 0x05
  91 #define MAX77693_MUIC_CHG_MASK  0x07
  92
  93 /* MAX77693_MUIC_CONTROL1 */
  94 #define MAX77693_MUIC_CTRL1_DN1DP2      ((0x1 << 3) | 0x1)
  95 #define MAX77693_MUIC_CTRL1_UT1UR2      ((0x3 << 3) | 0x3)
  96 #define MAX77693_MUIC_CTRL1_ADN1ADP2    ((0x4 << 3) | 0x4)
  97 #define MAX77693_MUIC_CTRL1_AUT1AUR2    ((0x5 << 3) | 0x5)
  98 #define MAX77693_MUIC_CTRL1_MASK        0xC0
  99
 100 /* MUIC INFO - passing to kernel driver by pmic_info field of cmdline */
 101 #define MUIC_PATH_USB   0
 102 #define MUIC_PATH_UART  1
 103
 104 #define MUIC_PATH_CP    0
 105 #define MUIC_PATH_AP    1
 106
 107 enum muic_path {
 108         MUIC_PATH_USB_CP,
 109         MUIC_PATH_USB_AP,
 110         MUIC_PATH_UART_CP,
 111         MUIC_PATH_UART_AP,
 112 };
 113
 114 static unsigned int pmic_bus = -1;
 115 static unsigned int muic_bus = -1;
 116
 117 static unsigned int revision;
 118
 119 static int usb_path = MUIC_PATH_AP;
 120
 121 static void set_muic_path_info(void)
 122 {
 123         int val = 0;
 124         char *path;
 125         char buf[32];
 126
 127         path = getenv("uartpath");
 128         if (path && !strncmp(path, "cp", 2))
 129                 val |= MUIC_PATH_CP << MUIC_PATH_UART;
 130         else
 131                 val |= MUIC_PATH_AP << MUIC_PATH_UART;
 132
 133         path = getenv("usbpath");
 134         if (path && !strncmp(path, "cp", 2))
 135                 val |= MUIC_PATH_CP << MUIC_PATH_USB;
 136         else
 137                 val |= MUIC_PATH_AP << MUIC_PATH_USB;
 138
 139         sprintf(buf, "pmic_info=%d", val);
 140         setenv("muicpathinfo", buf);
 141 }
 142
 143 void max77693_pmic_bus_init(int bus_num)
 144 {
 145         pmic_bus = bus_num;
 146 }
 147
 148 int max77693_pmic_probe(void)
 149 {
 150         unsigned char addr = MAX77693_PMIC_ADDR;
 151
 152         i2c_set_bus_num(pmic_bus);
 153
 154         if (i2c_probe(addr)) {
 155                 puts("Can't found max77693 pmic\n");
 156                 return 1;
 157         }
 158
 159         return 0;
 160 }
 161
 162 int max77693_init(void)
 163 {
 164         unsigned char addr = MAX77693_PMIC_ADDR;
 165         unsigned char val[2];
 166
 167         if (max77693_pmic_probe())
 168                 return -1;
 169
 170         /* revision */
 171         i2c_read(addr, MAX77693_PMIC_ID1, 1, val, 2);
 172
 173         debug(MAX77693_PMIC_PREFIX "\tID:0x%x, REV:0x%x, VER:0x%x\n",
 174                         val[0], val[1] & 0x7, val[1] & 0xF8);
 175
 176         revision = val[1] & 0x3;
 177
 178         /* muic path */
 179         set_muic_path_info();
 180         return 0;
 181 }
 182
 183 static int max77693_charger_en(int set_current)
 184 {
 185         unsigned char addr = MAX77693_PMIC_ADDR;
 186         unsigned char val[2];
 187
 188         if (max77693_pmic_probe())
 189                 return -1;
 190
 191         /* unlock write capability */
 192         val[0] = MAX77693_CHG_UNLOCK;
 193         i2c_write(addr, MAX77693_CHG_CNFG_06, 1, val, 1);
 194
 195         if (!set_current) {
 196                 puts(MAX77693_CHG_PREFIX "\tdisabled\n");
 197                 i2c_read(addr, MAX77693_CHG_CNFG_00, 1, val, 1);
 198                 val[0] &= ~0x01;
 199                 i2c_write(addr, MAX77693_CHG_CNFG_00, 1, val, 1);
 200                 return 0;
 201         }
 202
 203         /* set charging current */
 204         i2c_read(addr, MAX77693_CHG_CNFG_02, 1, val, 1);
 205         val[0] &= ~MAX77693_CHG_CC;
 206         val[0] |= set_current * 10 / 333;       /* 0.1A/3 steps */
 207         i2c_write(addr, MAX77693_CHG_CNFG_02, 1, val, 1);
 208
 209         /* enable charging */
 210         val[0] = MAX77693_CHG_MODE_ON;
 211         i2c_write(addr, MAX77693_CHG_CNFG_00, 1, val, 1);
 212
 213         /* check charging current */
 214         i2c_read(addr, MAX77693_CHG_CNFG_02, 1, val, 1);
 215         val[0] &= 0x3f;
 216         printf(MAX77693_CHG_PREFIX "\tenabled @ %d mA\n", val[0] * 333 / 10);
 217
 218         return 0;
 219 }
 220
 221 int max77693_charger_detbat(void)
 222 {
 223         unsigned char addr = MAX77693_PMIC_ADDR;
 224         unsigned char val[2];
 225
 226         if (max77693_pmic_probe())
 227                 return -1;
 228
 229         i2c_read(addr, MAX77693_CHG_INT_OK, 1, val, 1);
 230
 231         if (val[0] & MAX77693_CHG_DETBAT)
 232                 return 0;
 233         else
 234                 return 1;
 235 }
 236
 237 int max77693_charger_status(void)
 238 {
 239         unsigned char addr = MAX77693_PMIC_ADDR;
 240         unsigned char base = MAX77693_CHG_BASE;
 241         unsigned char val[0x10];
 242
 243         if (max77693_pmic_probe())
 244                 return -1;
 245
 246         i2c_read(addr, base, 1, val, 0x10);
 247
 248         printf("\n");
 249         printf("INT    (%02Xh) = 0x%02x\n", base + 0x00, val[0x0]);
 250         printf("INT_MSK(%02Xh) = 0x%02x\n", base + 0x01, val[0x1]);
 251         printf("INT_OK (%02Xh) = 0x%02x\n", base + 0x02, val[0x2]);
 252         printf("DTLS00 (%02Xh) = 0x%02x\n", base + 0x03, val[0x3]);
 253         printf("DTLS01 (%02Xh) = 0x%02x\n", base + 0x04, val[0x4]);
 254         printf("DTLS02 (%02Xh) = 0x%02x\n", base + 0x05, val[0x5]);
 255         printf("CNFG00 (%02Xh) = 0x%02x\n", base + 0x07, val[0x7]);
 256         printf("CNFG01 (%02Xh) = 0x%02x\n", base + 0x08, val[0x8]);
 257         printf("CNFG02 (%02Xh) = 0x%02x\n", base + 0x09, val[0x9]);
 258         printf("CNFG03 (%02Xh) = 0x%02x\n", base + 0x0a, val[0xa]);
 259         printf("CNFG04 (%02Xh) = 0x%02x\n", base + 0x0b, val[0xb]);
 260         printf("CNFG06 (%02Xh) = 0x%02x\n", base + 0x0d, val[0xd]);
 261
 262         return 0;
 263 }
 264
 265 void max77693_muic_bus_init(int bus_num)
 266 {
 267         muic_bus = bus_num;
 268 }
 269
 270 int max77693_muic_probe(void)
 271 {
 272         unsigned char addr = MAX77693_MUIC_ADDR;
 273
 274         i2c_set_bus_num(muic_bus);
 275
 276         if (i2c_probe(addr)) {
 277                 puts("Can't found max77693 muic\n");
 278                 return 1;
 279         }
 280
 281         return 0;
 282 }
 283
 284 int max77693_muic_check(void)
 285 {
 286         unsigned char addr = MAX77693_MUIC_ADDR;
 287         unsigned char val[2];
 288         unsigned char charge_type, charger;
 289
 290         /* if probe failed, return cable none */
 291         if (max77693_muic_probe())
 292                 return CHARGER_NO;
 293
 294         i2c_read(addr, MAX77693_MUIC_STATUS2, 1, val, 1);
 295
 296         charge_type = val[0] & MAX77693_MUIC_CHG_MASK;
 297
 298         switch (charge_type) {
 299         case MAX77693_MUIC_CHG_NO:
 300                 charger = CHARGER_NO;
 301                 break;
 302         case MAX77693_MUIC_CHG_USB:
 303         case MAX77693_MUIC_CHG_USB_D:
 304                 charger = CHARGER_USB;
 305                 break;
 306         case MAX77693_MUIC_CHG_TA:
 307         case MAX77693_MUIC_CHG_TA_1A:
 308                 charger = CHARGER_TA;
 309                 break;
 310         case MAX77693_MUIC_CHG_TA_500:
 311                 charger = CHARGER_TA_500;
 312                 break;
 313         default:
 314                 charger = CHARGER_UNKNOWN;
 315                 break;
 316         }
 317
 318         return charger;
 319 }
 320
 321 void __board_muic_gpio_control(int sw, int path) { }
 322 void board_muic_gpio_control(int sw, int path)
 323         __attribute__((weak, alias("__board_muic_gpio_control")));
 324
 325 static int max77693_muic_switch(enum muic_path path)
 326 {
 327         unsigned char addr = MAX77693_MUIC_ADDR;
 328         unsigned char val;
 329
 330         if (max77693_muic_probe())
 331                 return -1;
 332
 333         i2c_read(addr, MAX77693_MUIC_CONTROL1, 1, &val, 1);
 334
 335         val &= MAX77693_MUIC_CTRL1_MASK;
 336
 337         if (revision >= MAX77693_PMIC_REV_PASS2)
 338                 switch (path) {
 339                 case MUIC_PATH_USB_AP:
 340                         val |= MAX77693_MUIC_CTRL1_DN1DP2;
 341                         break;
 342                 case MUIC_PATH_USB_CP:
 343                         val |= MAX77693_MUIC_CTRL1_ADN1ADP2;
 344                         break;
 345                 case MUIC_PATH_UART_AP:
 346                         val |= MAX77693_MUIC_CTRL1_UT1UR2;
 347                         break;
 348                 case MUIC_PATH_UART_CP:
 349                         val |= MAX77693_MUIC_CTRL1_AUT1AUR2;
 350                         break;
 351                 }
 352         else
 353                 switch (path) {
 354                 case MUIC_PATH_USB_AP:
 355                         val |= MAX77693_MUIC_CTRL1_DN1DP2;
 356                         break;
 357                 case MUIC_PATH_USB_CP:
 358                         val |= MAX77693_MUIC_CTRL1_UT1UR2;
 359                         board_muic_gpio_control(MUIC_PATH_USB, MUIC_PATH_CP);
 360                         break;
 361                 case MUIC_PATH_UART_AP:
 362                         val |= MAX77693_MUIC_CTRL1_UT1UR2;
 363                         board_muic_gpio_control(MUIC_PATH_UART, MUIC_PATH_AP);
 364                         board_muic_gpio_control(MUIC_PATH_USB, MUIC_PATH_AP);
 365                         break;
 366                 case MUIC_PATH_UART_CP:
 367                         val |= MAX77693_MUIC_CTRL1_UT1UR2;
 368                         board_muic_gpio_control(MUIC_PATH_UART, MUIC_PATH_CP);
 369                         board_muic_gpio_control(MUIC_PATH_USB, MUIC_PATH_AP);
 370                         break;
 371                 }
 372
 373         i2c_write(addr, MAX77693_MUIC_CONTROL1, 1, &val, 1);
 374
 375                 return 0;
 376 }
 377
 378 /* To detect the attached accessory type on anyway jig box */
 379 int max77693_muic_get_adc(void)
 380 {
 381         unsigned char addr = MAX77693_MUIC_ADDR;
 382         unsigned char val[2];
 383
 384         if (max77693_muic_probe())
 385                 return -1;
 386
 387         i2c_read(addr, MAX77693_MUIC_STATUS1, 1, val, 1);
 388
 389         return (val[0] & MAX77693_MUIC_ADC_MASK);
 390 }
 391
 392 static int max77693_status(void)
 393 {
 394         unsigned char addr = MAX77693_PMIC_ADDR;
 395         unsigned char val[2];
 396
 397         if (max77693_pmic_probe())
 398                 return -1;
 399
 400         i2c_read(addr, MAX77693_SAFEOUT, 1, val, 1);
 401         printf("SAFEOUT1 %s\n", (val[0] & (1 << 6)) ? "on" : "off");
 402         printf("SAFEOUT2 %s\n", (val[0] & (1 << 7)) ? "on" : "off");
 403
 404         return 0;
 405 }
 406
 407 static int max77693_safeout_control(int safeout, int on)
 408 {
 409         unsigned char addr = MAX77693_PMIC_ADDR;
 410         unsigned char val[2];
 411         unsigned int reg, set;
 412
 413         if (safeout < 1 || safeout > 2)
 414                 return -1;
 415         reg = MAX77693_SAFEOUT;
 416         set = 1 << (5 + safeout);
 417
 418         if (max77693_pmic_probe())
 419                 return -1;
 420
 421         i2c_read(addr, reg, 1, val, 1);
 422         if (on)
 423                 val[0] |= set;
 424         else
 425                 val[0] &= ~set;
 426
 427         i2c_write(addr, reg, 1, val, 1);
 428         i2c_read(addr, reg, 1, val, 1);
 429
 430         return 0;
 431 }
 432
 433 static int do_max77693(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 434 {
 435         int ret = 0;
 436         int safeout;
 437         enum muic_path path;
 438
 439         if (argc < 2)
 440                 return cmd_usage(cmdtp);
 441
 442         if (!strncmp(argv[1], "status", 6))
 443                 return max77693_status();
 444
 445         if (!strncmp(argv[1], "safeout", 7)) {
 446                 if (argc != 4)
 447                         return cmd_usage(cmdtp);
 448
 449                 safeout = simple_strtoul(argv[2], NULL, 10);
 450
 451                 if (!strncmp(argv[3], "on", 2))
 452                         ret = max77693_safeout_control(safeout, 1);
 453                 else if (!strncmp(argv[3], "off", 3))
 454                         ret = max77693_safeout_control(safeout, 0);
 455                 else
 456                         return cmd_usage(cmdtp);
 457
 458                 if (!ret)
 459                         printf("%s %s %s\n", argv[1], argv[2], argv[3]);
 460                 else if (ret < 0)
 461                         printf("Error.\n");
 462                 return ret;
 463         }
 464
 465         if (!strncmp(argv[1], "usb", 4)) {
 466                 if (!strncmp(argv[2], "cp", 2))
 467                         path = MUIC_PATH_USB_CP;
 468                 else if (!strncmp(argv[2], "ap", 2))
 469                         path = MUIC_PATH_USB_AP;
 470                 else
 471                         return cmd_usage(cmdtp);
 472
 473                 max77693_muic_switch(path);
 474
 475                 setenv("usbpath", argv[2]);
 476                 set_muic_path_info();
 477                 return 0;
 478         }
 479
 480         if (!strncmp(argv[1], "uart", 4)) {
 481                 if (!strncmp(argv[2], "cp", 2))
 482                         path = MUIC_PATH_UART_CP;
 483                 else if (!strncmp(argv[2], "ap", 2))
 484                         path = MUIC_PATH_UART_AP;
 485                 else
 486                         return cmd_usage(cmdtp);
 487
 488                 max77693_muic_switch(path);
 489
 490                 setenv("uartpath", argv[2]);
 491                 set_muic_path_info();
 492                 return 0;
 493         }
 494
 495         if (!strncmp(argv[1], "charger", 1)) {
 496                 if (!strncmp(argv[2], "start", 5)) {
 497                         int current;
 498                         if (argc != 4)
 499                                 return cmd_usage(cmdtp);
 500                         current = simple_strtoul(argv[3], NULL, 10);
 501                         max77693_charger_en(current);
 502                 } else if (!strncmp(argv[2], "stop", 4)) {
 503                         max77693_charger_en(0);
 504                 } else if (!strncmp(argv[2], "status", 6)) {
 505                         max77693_fg_show_battery();
 506                 } else {
 507                         return cmd_usage(cmdtp);
 508                 }
 509
 510                 return 0;
 511         }
 512
 513         return cmd_usage(cmdtp);
 514 }
 515
 516 U_BOOT_CMD(
 517         max77693, 4, 1, do_max77693,
 518         "PMIC/MUIC control for MAX77693",
 519         "status\n"
 520         "max77693 safeout num on/off - Turn on/off the SAFEOUT\n"
 521         "max77693 charger start/stop/status current\n"
 522         "max77693 uart ap/cp - Switching UART path between AP/CP\n"
 523         "max77693 usb ap/cp - Switching USB path between AP/CP\n"
 524 );
 525