tas2557-regmap.c

   1 /*
   2 ** =============================================================================
   3 ** Copyright (c) 2016  Texas Instruments Inc.
   4 **
   5 ** This program is free software; you can redistribute it and/or modify it under
   6 ** the terms of the GNU General Public License as published by the Free Software
   7 ** Foundation; version 2.
   8 **
   9 ** This program is distributed in the hope that it will be useful, but WITHOUT
  10 ** ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11 ** FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12 **
  13 ** File:
  14 **     tas2557-regmap.c
  15 **
  16 ** Description:
  17 **     I2C driver with regmap for Texas Instruments TAS2557 High Performance 4W Smart Amplifier
  18 **
  19 ** =============================================================================
  20 */
  21
  22 #ifdef CONFIG_TAS2557_REGMAP
  23
  24 #define DEBUG
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/pm.h>
  30 #include <linux/i2c.h>
  31 #include <linux/gpio.h>
  32 #include <linux/regulator/consumer.h>
  33 #include <linux/firmware.h>
  34 #include <linux/regmap.h>
  35 #include <linux/of.h>
  36 #include <linux/of_gpio.h>
  37 #include <linux/slab.h>
  38 #include <linux/syscalls.h>
  39 #include <linux/fcntl.h>
  40 #include <linux/uaccess.h>
  41 #include "tas2557.h"
  42 #include "tas2557-core.h"
  43
  44 #ifdef CONFIG_TAS2557_CODEC
  45 #include "tas2557-codec.h"
  46 #endif
  47
  48 #ifdef CONFIG_TAS2557_MISC
  49 #include "tas2557-misc.h"
  50 #endif
  51
  52 #define ENABLE_TILOAD
  53 #ifdef ENABLE_TILOAD
  54 #include "tiload.h"
  55 #endif
  56
  57 #define LOW_TEMPERATURE_GAIN 6
  58 #define LOW_TEMPERATURE_COUNTER 12
  59
  60 static int tas2557_change_book_page(
  61         struct tas2557_priv *pTAS2557,
  62         unsigned char nBook,
  63         unsigned char nPage)
  64 {
  65         int nResult = 0;
  66
  67         if ((pTAS2557->mnCurrentBook == nBook)
  68                 && pTAS2557->mnCurrentPage == nPage)
  69                 goto end;
  70
  71         if (pTAS2557->mnCurrentBook != nBook) {
  72                 nResult = regmap_write(pTAS2557->mpRegmap, TAS2557_BOOKCTL_PAGE, 0);
  73                 if (nResult < 0) {
  74                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
  75                                 __func__, __LINE__, nResult);
  76                         goto end;
  77                 }
  78                 pTAS2557->mnCurrentPage = 0;
  79                 nResult = regmap_write(pTAS2557->mpRegmap, TAS2557_BOOKCTL_REG, nBook);
  80                 if (nResult < 0) {
  81                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
  82                                 __func__, __LINE__, nResult);
  83                         goto end;
  84                 }
  85                 pTAS2557->mnCurrentBook = nBook;
  86                 if (nPage != 0) {
  87                         nResult = regmap_write(pTAS2557->mpRegmap, TAS2557_BOOKCTL_PAGE, nPage);
  88                         if (nResult < 0) {
  89                                 dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
  90                                         __func__, __LINE__, nResult);
  91                                 goto end;
  92                         }
  93                         pTAS2557->mnCurrentPage = nPage;
  94                 }
  95         } else if (pTAS2557->mnCurrentPage != nPage) {
  96                 nResult = regmap_write(pTAS2557->mpRegmap, TAS2557_BOOKCTL_PAGE, nPage);
  97                 if (nResult < 0) {
  98                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
  99                                 __func__, __LINE__, nResult);
 100                         goto end;
 101                 }
 102                 pTAS2557->mnCurrentPage = nPage;
 103         }
 104
 105 end:
 106         if (nResult < 0)
 107                 pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 108         else
 109                 pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 110
 111         return nResult;
 112 }
 113
 114 static int tas2557_dev_read(
 115         struct tas2557_priv *pTAS2557,
 116         unsigned int nRegister,
 117         unsigned int *pValue)
 118 {
 119         int nResult = 0;
 120         unsigned int Value = 0;
 121
 122         mutex_lock(&pTAS2557->dev_lock);
 123
 124         if (pTAS2557->mbTILoadActive) {
 125                 if (!(nRegister & 0x80000000))
 126                         goto end; /* let only reads from TILoad pass. */
 127                 nRegister &= ~0x80000000;
 128
 129                 dev_dbg(pTAS2557->dev, "TiLoad R REG B[%d]P[%d]R[%d]\n",
 130                                 TAS2557_BOOK_ID(nRegister),
 131                                 TAS2557_PAGE_ID(nRegister),
 132                                 TAS2557_PAGE_REG(nRegister));
 133         }
 134
 135         nResult = tas2557_change_book_page(pTAS2557,
 136                                 TAS2557_BOOK_ID(nRegister),
 137                                 TAS2557_PAGE_ID(nRegister));
 138         if (nResult >= 0) {
 139                 nResult = regmap_read(pTAS2557->mpRegmap, TAS2557_PAGE_REG(nRegister), &Value);
 140                 if (nResult < 0) {
 141                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
 142                                 __func__, __LINE__, nResult);
 143                         pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 144                         goto end;
 145                 } else
 146                         pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 147                 *pValue = Value;
 148         }
 149
 150 end:
 151
 152         mutex_unlock(&pTAS2557->dev_lock);
 153         return nResult;
 154 }
 155
 156 static int tas2557_dev_write(
 157         struct tas2557_priv *pTAS2557,
 158         unsigned int nRegister,
 159         unsigned int nValue)
 160 {
 161         int nResult = 0;
 162
 163         mutex_lock(&pTAS2557->dev_lock);
 164         if ((nRegister == 0xAFFEAFFE) && (nValue == 0xBABEBABE)) {
 165                 pTAS2557->mbTILoadActive = true;
 166                 goto end;
 167         }
 168
 169         if ((nRegister == 0xBABEBABE) && (nValue == 0xAFFEAFFE)) {
 170                 pTAS2557->mbTILoadActive = false;
 171                 goto end;
 172         }
 173
 174         if (pTAS2557->mbTILoadActive) {
 175                 if (!(nRegister & 0x80000000))
 176                         goto end;/* let only writes from TILoad pass. */
 177                 nRegister &= ~0x80000000;
 178
 179                 dev_dbg(pTAS2557->dev, "TiLoad W REG B[%d]P[%d]R[%d] =0x%x\n",
 180                                                 TAS2557_BOOK_ID(nRegister),
 181                                                 TAS2557_PAGE_ID(nRegister),
 182                                                 TAS2557_PAGE_REG(nRegister),
 183                                                 nValue);
 184         }
 185
 186         nResult = tas2557_change_book_page(pTAS2557,
 187                                 TAS2557_BOOK_ID(nRegister),
 188                                 TAS2557_PAGE_ID(nRegister));
 189         if (nResult >= 0) {
 190                 nResult = regmap_write(pTAS2557->mpRegmap, TAS2557_PAGE_REG(nRegister), nValue);
 191                 if (nResult < 0) {
 192                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
 193                                 __func__, __LINE__, nResult);
 194                         pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 195                 } else
 196                         pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 197         }
 198
 199 end:
 200
 201         mutex_unlock(&pTAS2557->dev_lock);
 202
 203         return nResult;
 204 }
 205
 206 static int tas2557_dev_bulk_read(
 207         struct tas2557_priv *pTAS2557,
 208         unsigned int nRegister,
 209         u8 *pData,
 210         unsigned int nLength)
 211 {
 212         int nResult = 0;
 213
 214         mutex_lock(&pTAS2557->dev_lock);
 215         if (pTAS2557->mbTILoadActive) {
 216                 if (!(nRegister & 0x80000000))
 217                         goto end; /* let only writes from TILoad pass. */
 218
 219                 nRegister &= ~0x80000000;
 220                 dev_dbg(pTAS2557->dev, "TiLoad BR REG B[%d]P[%d]R[%d], count=%d\n",
 221                                 TAS2557_BOOK_ID(nRegister),
 222                                 TAS2557_PAGE_ID(nRegister),
 223                                 TAS2557_PAGE_REG(nRegister),
 224                                 nLength);
 225         }
 226
 227         nResult = tas2557_change_book_page(pTAS2557,
 228                                 TAS2557_BOOK_ID(nRegister),
 229                                 TAS2557_PAGE_ID(nRegister));
 230         if (nResult >= 0) {
 231                 nResult = regmap_bulk_read(pTAS2557->mpRegmap, TAS2557_PAGE_REG(nRegister), pData, nLength);
 232                 if (nResult < 0) {
 233                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
 234                                 __func__, __LINE__, nResult);
 235                         pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 236                 } else
 237                         pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 238         }
 239
 240 end:
 241
 242         mutex_unlock(&pTAS2557->dev_lock);
 243         return nResult;
 244 }
 245
 246 static int tas2557_dev_bulk_write(
 247         struct tas2557_priv *pTAS2557,
 248         unsigned int nRegister,
 249         u8 *pData,
 250         unsigned int nLength)
 251 {
 252         int nResult = 0;
 253
 254         mutex_lock(&pTAS2557->dev_lock);
 255         if (pTAS2557->mbTILoadActive) {
 256                 if (!(nRegister & 0x80000000))
 257                         goto end; /* let only writes from TILoad pass. */
 258
 259                 nRegister &= ~0x80000000;
 260
 261                 dev_dbg(pTAS2557->dev, "TiLoad BW REG B[%d]P[%d]R[%d], count=%d\n",
 262                                 TAS2557_BOOK_ID(nRegister),
 263                                 TAS2557_PAGE_ID(nRegister),
 264                                 TAS2557_PAGE_REG(nRegister),
 265                                 nLength);
 266         }
 267
 268         nResult = tas2557_change_book_page( pTAS2557,
 269                                 TAS2557_BOOK_ID(nRegister),
 270                                 TAS2557_PAGE_ID(nRegister));
 271         if (nResult >= 0) {
 272                 nResult = regmap_bulk_write(pTAS2557->mpRegmap, TAS2557_PAGE_REG(nRegister), pData, nLength);
 273                 if (nResult < 0) {
 274                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
 275                                 __func__, __LINE__, nResult);
 276                         pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 277                 } else
 278                         pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 279         }
 280
 281 end:
 282
 283         mutex_unlock(&pTAS2557->dev_lock);
 284         return nResult;
 285 }
 286
 287 static int tas2557_dev_update_bits(
 288         struct tas2557_priv *pTAS2557,
 289         unsigned int nRegister,
 290         unsigned int nMask,
 291         unsigned int nValue)
 292 {
 293         int nResult = 0;
 294
 295         mutex_lock(&pTAS2557->dev_lock);
 296
 297         if (pTAS2557->mbTILoadActive) {
 298                 if (!(nRegister & 0x80000000))
 299                         goto end; /* let only writes from TILoad pass. */
 300
 301                 nRegister &= ~0x80000000;
 302                 dev_dbg(pTAS2557->dev, "TiLoad SB REG B[%d]P[%d]R[%d], mask=0x%x, value=0x%x\n",
 303                                 TAS2557_BOOK_ID(nRegister),
 304                                 TAS2557_PAGE_ID(nRegister),
 305                                 TAS2557_PAGE_REG(nRegister),
 306                                 nMask, nValue);
 307         }
 308
 309         nResult = tas2557_change_book_page( pTAS2557,
 310                                 TAS2557_BOOK_ID(nRegister),
 311                                 TAS2557_PAGE_ID(nRegister));
 312         if (nResult >= 0) {
 313                 nResult = regmap_update_bits(pTAS2557->mpRegmap, TAS2557_PAGE_REG(nRegister), nMask, nValue);
 314                 if (nResult < 0) {
 315                         dev_err(pTAS2557->dev, "%s, %d, I2C error %d\n",
 316                                 __func__, __LINE__, nResult);
 317                         pTAS2557->mnErrCode |= ERROR_DEVA_I2C_COMM;
 318                 } else
 319                         pTAS2557->mnErrCode &= ~ERROR_DEVA_I2C_COMM;
 320         }
 321
 322 end:
 323         mutex_unlock(&pTAS2557->dev_lock);
 324         return nResult;
 325 }
 326
 327 void tas2557_clearIRQ(struct tas2557_priv *pTAS2557)
 328 {
 329         unsigned int nValue;
 330         int nResult = 0;
 331
 332         nResult = pTAS2557->read(pTAS2557, TAS2557_FLAGS_1, &nValue);
 333         if (nResult >= 0)
 334                 pTAS2557->read(pTAS2557, TAS2557_FLAGS_2, &nValue);
 335
 336 }
 337
 338
 339 void tas2557_enableIRQ(struct tas2557_priv *pTAS2557, bool enable)
 340 {
 341         if (enable) {
 342                 if (!pTAS2557->mbIRQEnable) {
 343                         if (gpio_is_valid(pTAS2557->mnGpioINT)) {
 344                                 enable_irq(pTAS2557->mnIRQ);
 345                                 /* check after 10 ms */
 346                                 schedule_delayed_work(&pTAS2557->irq_work, msecs_to_jiffies(10));
 347                                 pTAS2557->mbIRQEnable = true;
 348                         }
 349                 }
 350         } else {
 351                 if (pTAS2557->mbIRQEnable) {
 352                         if (gpio_is_valid(pTAS2557->mnGpioINT))
 353                                 disable_irq_nosync(pTAS2557->mnIRQ);
 354                         pTAS2557->mbIRQEnable = false;
 355                 }
 356         }
 357 }
 358
 359 static void tas2557_hw_reset(struct tas2557_priv *pTAS2557)
 360 {
 361         if (gpio_is_valid(pTAS2557->mnResetGPIO)) {
 362                 gpio_direction_output(pTAS2557->mnResetGPIO, 0);
 363                 msleep(5);
 364                 gpio_direction_output(pTAS2557->mnResetGPIO, 1);
 365                 msleep(2);
 366         }
 367
 368         pTAS2557->mnCurrentBook = -1;
 369         pTAS2557->mnCurrentPage = -1;
 370         if (pTAS2557->mnErrCode)
 371                 dev_info(pTAS2557->dev, "before reset, ErrCode=0x%x\n", pTAS2557->mnErrCode);
 372         pTAS2557->mnErrCode = 0;
 373 }
 374
 375 static void irq_work_routine(struct work_struct *work)
 376 {
 377         int nResult = 0;
 378         unsigned int nDevInt1Status = 0, nDevInt2Status = 0;
 379         unsigned int nDevPowerUpFlag = 0;
 380         struct tas2557_priv *pTAS2557 =
 381                 container_of(work, struct tas2557_priv, irq_work.work);
 382
 383 #ifdef CONFIG_TAS2557_CODEC
 384         mutex_lock(&pTAS2557->codec_lock);
 385 #endif
 386
 387 #ifdef CONFIG_TAS2557_MISC
 388         mutex_lock(&pTAS2557->file_lock);
 389 #endif
 390
 391         if (!pTAS2557->mbPowerUp)
 392                 goto end;
 393
 394         if ((!pTAS2557->mpFirmware->mnConfigurations)
 395                 || (!pTAS2557->mpFirmware->mnPrograms)) {
 396                 dev_info(pTAS2557->dev, "%s, firmware not loaded\n", __func__);
 397                 goto end;
 398         }
 399
 400         nResult = tas2557_dev_read(pTAS2557, TAS2557_FLAGS_1, &nDevInt1Status);
 401         if (nResult >= 0)
 402                 nResult = tas2557_dev_read(pTAS2557, TAS2557_FLAGS_2, &nDevInt2Status);
 403
 404         if (nResult < 0)
 405                 goto program;
 406
 407         if (((nDevInt1Status & 0xfc) != 0) || ((nDevInt2Status & 0x0c) != 0)) {
 408                 /* in case of INT_OC, INT_UV, INT_OT, INT_BO, INT_CL, INT_CLK1, INT_CLK2 */
 409                 dev_err(pTAS2557->dev, "critical error: 0x%x, 0x%x\n", nDevInt1Status, nDevInt2Status);
 410                         if (nDevInt1Status & 0x80) {
 411                                 pTAS2557->mnErrCode |= ERROR_OVER_CURRENT;
 412                                 dev_err(pTAS2557->dev, "DEVA SPK over current!\n");
 413                         } else
 414                                 pTAS2557->mnErrCode &= ~ERROR_OVER_CURRENT;
 415
 416                         if (nDevInt1Status & 0x40) {
 417                                 pTAS2557->mnErrCode |= ERROR_UNDER_VOLTAGE;
 418                                 dev_err(pTAS2557->dev, "DEVA SPK under voltage!\n");
 419                         } else
 420                                 pTAS2557->mnErrCode &= ~ERROR_UNDER_VOLTAGE;
 421
 422                         if (nDevInt1Status & 0x20) {
 423                                 pTAS2557->mnErrCode |= ERROR_CLK_HALT;
 424                                 dev_err(pTAS2557->dev, "DEVA clk halted!\n");
 425                         } else
 426                                 pTAS2557->mnErrCode &= ~ERROR_CLK_HALT;
 427
 428                         if (nDevInt1Status & 0x10) {
 429                                 pTAS2557->mnErrCode |= ERROR_DIE_OVERTEMP;
 430                                 dev_err(pTAS2557->dev, "DEVA die over temperature!\n");
 431                         } else
 432                                 pTAS2557->mnErrCode &= ~ERROR_DIE_OVERTEMP;
 433
 434                         if (nDevInt1Status & 0x08) {
 435                                 pTAS2557->mnErrCode |= ERROR_BROWNOUT;
 436                                 dev_err(pTAS2557->dev, "DEVA brownout!\n");
 437                         } else
 438                                 pTAS2557->mnErrCode &= ~ERROR_BROWNOUT;
 439
 440                         if (nDevInt1Status & 0x04) {
 441                                 pTAS2557->mnErrCode |= ERROR_CLK_LOST;
 442                                 dev_err(pTAS2557->dev, "DEVA clock lost!\n");
 443                         } else
 444                                 pTAS2557->mnErrCode &= ~ERROR_CLK_LOST;
 445
 446                         if (nDevInt2Status & 0x08) {
 447                                 pTAS2557->mnErrCode |= ERROR_CLK_DET1;
 448                                 dev_err(pTAS2557->dev, "DEVA clk detection 1!\n");
 449                         } else
 450                                 pTAS2557->mnErrCode &= ~ERROR_CLK_DET1;
 451
 452                         if (nDevInt2Status & 0x04) {
 453                                 pTAS2557->mnErrCode |= ERROR_CLK_DET2;
 454                                 dev_err(pTAS2557->dev, "DEVA clk detection 2!\n");
 455                         } else
 456                                 pTAS2557->mnErrCode &= ~ERROR_CLK_DET2;
 457
 458                 goto program;
 459         } else {
 460                 nResult = tas2557_dev_read(pTAS2557, TAS2557_POWER_UP_FLAG_REG, &nDevPowerUpFlag);
 461                 if (nResult < 0)
 462                         goto program;
 463                 if ((nDevPowerUpFlag & 0xc0) != 0xc0) {
 464                         dev_err(pTAS2557->dev, "%s, Critical ERROR B[%d]_P[%d]_R[%d]= 0x%x\n",
 465                                 __func__,
 466                                 TAS2557_BOOK_ID(TAS2557_POWER_UP_FLAG_REG),
 467                                 TAS2557_PAGE_ID(TAS2557_POWER_UP_FLAG_REG),
 468                                 TAS2557_PAGE_REG(TAS2557_POWER_UP_FLAG_REG),
 469                                 nDevPowerUpFlag);
 470                         pTAS2557->mnErrCode |= ERROR_CLASSD_PWR;
 471                         goto program;
 472                 }
 473                 pTAS2557->mnErrCode &= ~ERROR_CLASSD_PWR;
 474
 475                 dev_dbg(pTAS2557->dev, "%s: INT1=0x%x, INT2=0x%x; PowerUpFlag=0x%x\n",
 476                         __func__, nDevInt1Status, nDevInt2Status, nDevPowerUpFlag);
 477                 goto end;
 478         }
 479
 480 program:
 481         /* hardware reset and reload */
 482         tas2557_set_program(pTAS2557, pTAS2557->mnCurrentProgram, pTAS2557->mnCurrentConfiguration);
 483
 484 end:
 485
 486 #ifdef CONFIG_TAS2557_MISC
 487         mutex_unlock(&pTAS2557->file_lock);
 488 #endif
 489
 490 #ifdef CONFIG_TAS2557_CODEC
 491         mutex_unlock(&pTAS2557->codec_lock);
 492 #endif
 493 }
 494
 495 static irqreturn_t tas2557_irq_handler(int irq, void *dev_id)
 496 {
 497         struct tas2557_priv *pTAS2557 = (struct tas2557_priv *)dev_id;
 498
 499         tas2557_enableIRQ(pTAS2557, false);
 500         /* get IRQ status after 100 ms */
 501         schedule_delayed_work(&pTAS2557->irq_work, msecs_to_jiffies(100));
 502         return IRQ_HANDLED;
 503 }
 504
 505 static enum hrtimer_restart temperature_timer_func(struct hrtimer *timer)
 506 {
 507         struct tas2557_priv *pTAS2557 = container_of(timer, struct tas2557_priv, mtimer);
 508
 509         if (pTAS2557->mbPowerUp) {
 510                 schedule_work(&pTAS2557->mtimerwork);
 511                 schedule_delayed_work(&pTAS2557->irq_work, msecs_to_jiffies(1));
 512         }
 513         return HRTIMER_NORESTART;
 514 }
 515
 516 static void timer_work_routine(struct work_struct *work)
 517 {
 518         struct tas2557_priv *pTAS2557 = container_of(work, struct tas2557_priv, mtimerwork);
 519         int nResult, nTemp, nActTemp;
 520         struct TProgram *pProgram;
 521         static int nAvg;
 522
 523 #ifdef CONFIG_TAS2557_CODEC
 524         mutex_lock(&pTAS2557->codec_lock);
 525 #endif
 526
 527 #ifdef CONFIG_TAS2557_MISC
 528         mutex_lock(&pTAS2557->file_lock);
 529 #endif
 530
 531         if (!pTAS2557->mpFirmware->mnConfigurations) {
 532                 dev_info(pTAS2557->dev, "%s, firmware not loaded\n", __func__);
 533                 goto end;
 534         }
 535
 536         pProgram = &(pTAS2557->mpFirmware->mpPrograms[pTAS2557->mnCurrentProgram]);
 537         if (!pTAS2557->mbPowerUp
 538                 || (pProgram->mnAppMode != TAS2557_APP_TUNINGMODE)) {
 539                 dev_info(pTAS2557->dev, "%s, pass, Pow=%d, program=%s\n",
 540                         __func__, pTAS2557->mbPowerUp, pProgram->mpName);
 541                 goto end;
 542         }
 543
 544         nResult = tas2557_get_die_temperature(pTAS2557, &nTemp);
 545         if (nResult >= 0) {
 546                 nActTemp = (int)(nTemp >> 23);
 547                 dev_dbg(pTAS2557->dev, "Die=0x%x, degree=%d\n", nTemp, nActTemp);
 548                 if (!pTAS2557->mnDieTvReadCounter)
 549                         nAvg = 0;
 550                 pTAS2557->mnDieTvReadCounter++;
 551                 nAvg += nActTemp;
 552                 if (!(pTAS2557->mnDieTvReadCounter % LOW_TEMPERATURE_COUNTER)) {
 553                         nAvg /= LOW_TEMPERATURE_COUNTER;
 554                         dev_dbg(pTAS2557->dev, "check : avg=%d\n", nAvg);
 555                         if ((nAvg & 0x80000000) != 0) {
 556                                 /* if Die temperature is below ZERO */
 557                                 if (pTAS2557->mnDevCurrentGain != LOW_TEMPERATURE_GAIN) {
 558                                         nResult = tas2557_set_DAC_gain(pTAS2557, LOW_TEMPERATURE_GAIN);
 559                                         if (nResult < 0)
 560                                                 goto end;
 561                                         pTAS2557->mnDevCurrentGain = LOW_TEMPERATURE_GAIN;
 562                                         dev_dbg(pTAS2557->dev, "LOW Temp: set gain to %d\n", LOW_TEMPERATURE_GAIN);
 563                                 }
 564                         } else if (nAvg > 5) {
 565                                 /* if Die temperature is above 5 degree C */
 566                                 if (pTAS2557->mnDevCurrentGain != pTAS2557->mnDevGain) {
 567                                         nResult = tas2557_set_DAC_gain(pTAS2557, pTAS2557->mnDevGain);
 568                                         if (nResult < 0)
 569                                                 goto end;
 570                                         pTAS2557->mnDevCurrentGain = pTAS2557->mnDevGain;
 571                                         dev_dbg(pTAS2557->dev, "LOW Temp: set gain to original\n");
 572                                 }
 573                         }
 574                         nAvg = 0;
 575                 }
 576
 577                 if (pTAS2557->mbPowerUp)
 578                         hrtimer_start(&pTAS2557->mtimer,
 579                                 ns_to_ktime((u64)LOW_TEMPERATURE_CHECK_PERIOD * NSEC_PER_MSEC), HRTIMER_MODE_REL);
 580         }
 581
 582 end:
 583
 584 #ifdef CONFIG_TAS2557_MISC
 585         mutex_unlock(&pTAS2557->file_lock);
 586 #endif
 587
 588 #ifdef CONFIG_TAS2557_CODEC
 589         mutex_unlock(&pTAS2557->codec_lock);
 590 #endif
 591 }
 592
 593 #ifdef CONFIG_PM_SLEEP
 594 static int tas2557_suspend(struct device *dev)
 595 {
 596         struct tas2557_priv *pTAS2557 = dev_get_drvdata(dev);
 597
 598         dev_dbg(pTAS2557->dev, "%s\n", __func__);
 599         if (hrtimer_active(&pTAS2557->mtimer)) {
 600                 dev_dbg(pTAS2557->dev, "cancel die temp timer\n");
 601                 hrtimer_cancel(&pTAS2557->mtimer);
 602         }
 603
 604         return 0;
 605 }
 606
 607 static int tas2557_resume(struct device *dev)
 608 {
 609         struct tas2557_priv *pTAS2557 = dev_get_drvdata(dev);
 610         struct TProgram *pProgram;
 611
 612         dev_dbg(pTAS2557->dev, "%s\n", __func__);
 613         if (!pTAS2557->mpFirmware->mpPrograms) {
 614                 dev_dbg(pTAS2557->dev, "%s, firmware not loaded\n", __func__);
 615                 goto end;
 616         }
 617
 618         if (pTAS2557->mnCurrentProgram >= pTAS2557->mpCalFirmware->mnPrograms) {
 619                 dev_err(pTAS2557->dev, "%s, firmware corrupted\n", __func__);
 620                 goto end;
 621         }
 622
 623         pProgram = &(pTAS2557->mpFirmware->mpPrograms[pTAS2557->mnCurrentProgram]);
 624         if (pTAS2557->mbPowerUp && (pProgram->mnAppMode == TAS2557_APP_TUNINGMODE)) {
 625                 if (!hrtimer_active(&pTAS2557->mtimer)) {
 626                         dev_dbg(pTAS2557->dev, "%s, start Die Temp check timer\n", __func__);
 627                         pTAS2557->mnDieTvReadCounter = 0;
 628                         hrtimer_start(&pTAS2557->mtimer,
 629                                 ns_to_ktime((u64)LOW_TEMPERATURE_CHECK_PERIOD * NSEC_PER_MSEC), HRTIMER_MODE_REL);
 630                 }
 631         }
 632
 633 end:
 634
 635         return 0;
 636 }
 637 #endif
 638
 639 static bool tas2557_volatile(struct device *pDev, unsigned int nRegister)
 640 {
 641         return true;
 642 }
 643
 644 static bool tas2557_writeable(struct device *pDev, unsigned int nRegister)
 645 {
 646         return true;
 647 }
 648
 649 static const struct regmap_config tas2557_i2c_regmap = {
 650         .reg_bits = 8,
 651         .val_bits = 8,
 652         .writeable_reg = tas2557_writeable,
 653         .volatile_reg = tas2557_volatile,
 654         .cache_type = REGCACHE_NONE,
 655         .max_register = 128,
 656 };
 657
 658 /* tas2557_i2c_probe :
 659 * platform dependent
 660 * should implement hardware reset functionality
 661 */
 662 static int tas2557_i2c_probe(struct i2c_client *pClient,
 663         const struct i2c_device_id *pID)
 664 {
 665         struct tas2557_priv *pTAS2557;
 666         int nResult = 0;
 667         unsigned int nValue = 0;
 668         const char *pFWName;
 669
 670         dev_info(&pClient->dev, "%s enter\n", __func__);
 671
 672         pTAS2557 = devm_kzalloc(&pClient->dev, sizeof(struct tas2557_priv), GFP_KERNEL);
 673         if (!pTAS2557) {
 674                 nResult = -ENOMEM;
 675                 goto err;
 676         }
 677
 678         pTAS2557->dev = &pClient->dev;
 679         i2c_set_clientdata(pClient, pTAS2557);
 680         dev_set_drvdata(&pClient->dev, pTAS2557);
 681
 682         pTAS2557->mpRegmap = devm_regmap_init_i2c(pClient, &tas2557_i2c_regmap);
 683         if (IS_ERR(pTAS2557->mpRegmap)) {
 684                 nResult = PTR_ERR(pTAS2557->mpRegmap);
 685                 dev_err(&pClient->dev, "Failed to allocate register map: %d\n",
 686                         nResult);
 687                 goto err;
 688         }
 689
 690         if (pClient->dev.of_node)
 691                 tas2557_parse_dt(&pClient->dev, pTAS2557);
 692
 693         if (gpio_is_valid(pTAS2557->mnResetGPIO)) {
 694                 nResult = gpio_request(pTAS2557->mnResetGPIO, "TAS2557-RESET");
 695                 if (nResult < 0) {
 696                         dev_err(pTAS2557->dev, "%s: GPIO %d request error\n",
 697                                 __func__, pTAS2557->mnResetGPIO);
 698                         goto err;
 699                 }
 700                 tas2557_hw_reset(pTAS2557);
 701         }
 702
 703         pTAS2557->read = tas2557_dev_read;
 704         pTAS2557->write = tas2557_dev_write;
 705         pTAS2557->bulk_read = tas2557_dev_bulk_read;
 706         pTAS2557->bulk_write = tas2557_dev_bulk_write;
 707         pTAS2557->update_bits = tas2557_dev_update_bits;
 708         pTAS2557->enableIRQ = tas2557_enableIRQ;
 709         pTAS2557->clearIRQ = tas2557_clearIRQ;
 710         pTAS2557->set_config = tas2557_set_config;
 711         pTAS2557->set_calibration = tas2557_set_calibration;
 712         pTAS2557->hw_reset = tas2557_hw_reset;
 713
 714         mutex_init(&pTAS2557->dev_lock);
 715
 716         /* Reset the chip */
 717         nResult = tas2557_dev_write(pTAS2557, TAS2557_SW_RESET_REG, 0x01);
 718         if (nResult < 0) {
 719                 dev_err(&pClient->dev, "I2c fail, %d\n", nResult);
 720                 goto err;
 721         }
 722
 723         msleep(1);
 724         tas2557_dev_read(pTAS2557, TAS2557_REV_PGID_REG, &nValue);
 725         pTAS2557->mnPGID = nValue;
 726         if (pTAS2557->mnPGID == TAS2557_PG_VERSION_2P1) {
 727                 dev_info(pTAS2557->dev, "PG2.1 Silicon found\n");
 728                 pFWName = TAS2557_FW_NAME;
 729         } else if (pTAS2557->mnPGID == TAS2557_PG_VERSION_1P0) {
 730                 dev_info(pTAS2557->dev, "PG1.0 Silicon found\n");
 731                 pFWName = TAS2557_PG1P0_FW_NAME;
 732         } else {
 733                 nResult = -ENOTSUPP;
 734                 dev_info(pTAS2557->dev, "unsupport Silicon 0x%x\n", pTAS2557->mnPGID);
 735                 goto err;
 736         }
 737
 738         if (gpio_is_valid(pTAS2557->mnGpioINT)) {
 739                 nResult = gpio_request(pTAS2557->mnGpioINT, "TAS2557-IRQ");
 740                 if (nResult < 0) {
 741                         dev_err(pTAS2557->dev,
 742                                 "%s: GPIO %d request INT error\n",
 743                                 __func__, pTAS2557->mnGpioINT);
 744                         goto err;
 745                 }
 746
 747                 gpio_direction_input(pTAS2557->mnGpioINT);
 748                 pTAS2557->mnIRQ = gpio_to_irq(pTAS2557->mnGpioINT);
 749                 dev_dbg(pTAS2557->dev, "irq = %d\n", pTAS2557->mnIRQ);
 750                 INIT_DELAYED_WORK(&pTAS2557->irq_work, irq_work_routine);
 751                 nResult = request_threaded_irq(pTAS2557->mnIRQ, tas2557_irq_handler,
 752                                         NULL, IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
 753                                 pClient->name, pTAS2557);
 754                 if (nResult < 0) {
 755                         dev_err(pTAS2557->dev,
 756                                 "request_irq failed, %d\n", nResult);
 757                         goto err;
 758                 }
 759                 disable_irq_nosync(pTAS2557->mnIRQ);
 760         }
 761
 762         pTAS2557->mpFirmware = devm_kzalloc(&pClient->dev, sizeof(struct TFirmware), GFP_KERNEL);
 763         if (!pTAS2557->mpFirmware) {
 764                 nResult = -ENOMEM;
 765                 goto err;
 766         }
 767
 768         pTAS2557->mpCalFirmware = devm_kzalloc(&pClient->dev, sizeof(struct TFirmware), GFP_KERNEL);
 769         if (!pTAS2557->mpCalFirmware) {
 770                 nResult = -ENOMEM;
 771                 goto err;
 772         }
 773
 774 #ifdef CONFIG_TAS2557_CODEC
 775         mutex_init(&pTAS2557->codec_lock);
 776         tas2557_register_codec(pTAS2557);
 777 #endif
 778
 779 #ifdef CONFIG_TAS2557_MISC
 780         mutex_init(&pTAS2557->file_lock);
 781         tas2557_register_misc(pTAS2557);
 782 #endif
 783
 784 #ifdef ENABLE_TILOAD
 785         tiload_driver_init(pTAS2557);
 786 #endif
 787
 788         hrtimer_init(&pTAS2557->mtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 789         pTAS2557->mtimer.function = temperature_timer_func;
 790         INIT_WORK(&pTAS2557->mtimerwork, timer_work_routine);
 791
 792         nResult = request_firmware_nowait(THIS_MODULE, 1, pFWName,
 793                 pTAS2557->dev, GFP_KERNEL, pTAS2557, tas2557_fw_ready);
 794
 795 err:
 796
 797         return nResult;
 798 }
 799
 800 static int tas2557_i2c_remove(struct i2c_client *pClient)
 801 {
 802         struct tas2557_priv *pTAS2557 = i2c_get_clientdata(pClient);
 803
 804         dev_info(pTAS2557->dev, "%s\n", __func__);
 805
 806 #ifdef CONFIG_TAS2557_CODEC
 807         tas2557_deregister_codec(pTAS2557);
 808         mutex_destroy(&pTAS2557->codec_lock);
 809 #endif
 810
 811 #ifdef CONFIG_TAS2557_MISC
 812         tas2557_deregister_misc(pTAS2557);
 813         mutex_destroy(&pTAS2557->file_lock);
 814 #endif
 815
 816         mutex_destroy(&pTAS2557->dev_lock);
 817         return 0;
 818 }
 819
 820 static const struct i2c_device_id tas2557_i2c_id[] = {
 821         {"tas2557", 0},
 822         {}
 823 };
 824
 825 MODULE_DEVICE_TABLE(i2c, tas2557_i2c_id);
 826
 827 #if defined(CONFIG_OF)
 828 static const struct of_device_id tas2557_of_match[] = {
 829         {.compatible = "ti,tas2557"},
 830         {},
 831 };
 832
 833 MODULE_DEVICE_TABLE(of, tas2557_of_match);
 834 #endif
 835
 836 #ifdef CONFIG_PM_SLEEP
 837 static const struct dev_pm_ops tas2557_pm_ops = {
 838         SET_SYSTEM_SLEEP_PM_OPS(tas2557_suspend, tas2557_resume)
 839 };
 840 #endif
 841
 842 static struct i2c_driver tas2557_i2c_driver = {
 843         .driver = {
 844                         .name = "tas2557",
 845                         .owner = THIS_MODULE,
 846 #ifdef CONFIG_PM_SLEEP
 847                         .pm = &tas2557_pm_ops,
 848 #endif
 849 #if defined(CONFIG_OF)
 850                         .of_match_table = of_match_ptr(tas2557_of_match),
 851 #endif
 852                 },
 853         .probe = tas2557_i2c_probe,
 854         .remove = tas2557_i2c_remove,
 855         .id_table = tas2557_i2c_id,
 856 };
 857
 858 module_i2c_driver(tas2557_i2c_driver);
 859
 860 MODULE_AUTHOR("Texas Instruments Inc.");
 861 MODULE_DESCRIPTION("TAS2557 I2C Smart Amplifier driver");
 862 MODULE_LICENSE("GPL v2");
 863
 864 #endif