drivers/platform/x86/intel_scu_ipc.c

   1 /*
   2  * intel_scu_ipc.c: Driver for the Intel SCU IPC mechanism
   3  *
   4  * (C) Copyright 2008-2010 Intel Corporation
   5  * Author: Sreedhara DS (sreedhara.ds@intel.com)
   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
   9  * as published by the Free Software Foundation; version 2
  10  * of the License.
  11  *
  12  * SCU runing in ARC processor communicates with other entity running in IA
  13  * core through IPC mechanism which in turn messaging between IA core ad SCU.
  14  * SCU has two IPC mechanism IPC-1 and IPC-2. IPC-1 is used between IA32 and
  15  * SCU where IPC-2 is used between P-Unit and SCU. This driver delas with
  16  * IPC-1 Driver provides an API for power control unit registers (e.g. MSIC)
  17  * along with other APIs.
  18  */
  19 #include <linux/delay.h>
  20 #include <linux/errno.h>
  21 #include <linux/init.h>
  22 #include <linux/sysdev.h>
  23 #include <linux/pm.h>
  24 #include <linux/pci.h>
  25 #include <linux/interrupt.h>
  26 #include <asm/mrst.h>
  27 #include <asm/intel_scu_ipc.h>
  28
  29 /* IPC defines the following message types */
  30 #define IPCMSG_WATCHDOG_TIMER 0xF8 /* Set Kernel Watchdog Threshold */
  31 #define IPCMSG_BATTERY        0xEF /* Coulomb Counter Accumulator */
  32 #define IPCMSG_FW_UPDATE      0xFE /* Firmware update */
  33 #define IPCMSG_PCNTRL         0xFF /* Power controller unit read/write */
  34 #define IPCMSG_FW_REVISION    0xF4 /* Get firmware revision */
  35
  36 /* Command id associated with message IPCMSG_PCNTRL */
  37 #define IPC_CMD_PCNTRL_W      0 /* Register write */
  38 #define IPC_CMD_PCNTRL_R      1 /* Register read */
  39 #define IPC_CMD_PCNTRL_M      2 /* Register read-modify-write */
  40
  41 /*
  42  * IPC register summary
  43  *
  44  * IPC register blocks are memory mapped at fixed address of 0xFF11C000
  45  * To read or write information to the SCU, driver writes to IPC-1 memory
  46  * mapped registers (base address 0xFF11C000). The following is the IPC
  47  * mechanism
  48  *
  49  * 1. IA core cDMI interface claims this transaction and converts it to a
  50  *    Transaction Layer Packet (TLP) message which is sent across the cDMI.
  51  *
  52  * 2. South Complex cDMI block receives this message and writes it to
  53  *    the IPC-1 register block, causing an interrupt to the SCU
  54  *
  55  * 3. SCU firmware decodes this interrupt and IPC message and the appropriate
  56  *    message handler is called within firmware.
  57  */
  58
  59 #define IPC_BASE_ADDR     0xFF11C000    /* IPC1 base register address */
  60 #define IPC_MAX_ADDR      0x100         /* Maximum IPC regisers */
  61 #define IPC_WWBUF_SIZE    16            /* IPC Write buffer Size */
  62 #define IPC_RWBUF_SIZE    16            /* IPC Read buffer Size */
  63 #define IPC_I2C_BASE      0xFF12B000    /* I2C control register base address */
  64 #define IPC_I2C_MAX_ADDR  0x10          /* Maximum I2C regisers */
  65
  66 static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id);
  67 static void ipc_remove(struct pci_dev *pdev);
  68
  69 struct intel_scu_ipc_dev {
  70         struct pci_dev *pdev;
  71         void __iomem *ipc_base;
  72         void __iomem *i2c_base;
  73 };
  74
  75 static struct intel_scu_ipc_dev  ipcdev; /* Only one for now */
  76
  77 #define PLATFORM_LANGWELL 1
  78 #define PLATFORM_PENWELL 2
  79 static int platform;            /* Platform type */
  80
  81 /*
  82  * IPC Read Buffer (Read Only):
  83  * 16 byte buffer for receiving data from SCU, if IPC command
  84  * processing results in response data
  85  */
  86 #define IPC_READ_BUFFER         0x90
  87
  88 #define IPC_I2C_CNTRL_ADDR      0
  89 #define I2C_DATA_ADDR           0x04
  90
  91 static DEFINE_MUTEX(ipclock); /* lock used to prevent multiple call to SCU */
  92
  93 /*
  94  * Command Register (Write Only):
  95  * A write to this register results in an interrupt to the SCU core processor
  96  * Format:
  97  * |rfu2(8) | size(8) | command id(4) | rfu1(3) | ioc(1) | command(8)|
  98  */
  99 static inline void ipc_command(u32 cmd) /* Send ipc command */
 100 {
 101         writel(cmd, ipcdev.ipc_base);
 102 }
 103
 104 /*
 105  * IPC Write Buffer (Write Only):
 106  * 16-byte buffer for sending data associated with IPC command to
 107  * SCU. Size of the data is specified in the IPC_COMMAND_REG register
 108  */
 109 static inline void ipc_data_writel(u32 data, u32 offset) /* Write ipc data */
 110 {
 111         writel(data, ipcdev.ipc_base + 0x80 + offset);
 112 }
 113
 114 /*
 115  * Status Register (Read Only):
 116  * Driver will read this register to get the ready/busy status of the IPC
 117  * block and error status of the IPC command that was just processed by SCU
 118  * Format:
 119  * |rfu3(8)|error code(8)|initiator id(8)|cmd id(4)|rfu1(2)|error(1)|busy(1)|
 120  */
 121
 122 static inline u8 ipc_read_status(void)
 123 {
 124         return __raw_readl(ipcdev.ipc_base + 0x04);
 125 }
 126
 127 static inline u8 ipc_data_readb(u32 offset) /* Read ipc byte data */
 128 {
 129         return readb(ipcdev.ipc_base + IPC_READ_BUFFER + offset);
 130 }
 131
 132 static inline u32 ipc_data_readl(u32 offset) /* Read ipc u32 data */
 133 {
 134         return readl(ipcdev.ipc_base + IPC_READ_BUFFER + offset);
 135 }
 136
 137 static inline int busy_loop(void) /* Wait till scu status is busy */
 138 {
 139         u32 status = 0;
 140         u32 loop_count = 0;
 141
 142         status = ipc_read_status();
 143         while (status & 1) {
 144                 udelay(1); /* scu processing time is in few u secods */
 145                 status = ipc_read_status();
 146                 loop_count++;
 147                 /* break if scu doesn't reset busy bit after huge retry */
 148                 if (loop_count > 100000) {
 149                         dev_err(&ipcdev.pdev->dev, "IPC timed out");
 150                         return -ETIMEDOUT;
 151                 }
 152         }
 153         return (status >> 1) & 1;
 154 }
 155
 156 /* Read/Write power control(PMIC in Langwell, MSIC in PenWell) registers */
 157 static int pwr_reg_rdwr(u16 *addr, u8 *data, u32 count, u32 op, u32 id)
 158 {
 159         int nc;
 160         u32 offset = 0;
 161         u32 err = 0;
 162         u8 cbuf[IPC_WWBUF_SIZE] = { };
 163         u32 *wbuf = (u32 *)&cbuf;
 164
 165         mutex_lock(&ipclock);
 166
 167         if (ipcdev.pdev == NULL) {
 168                 mutex_unlock(&ipclock);
 169                 return -ENODEV;
 170         }
 171
 172         if (platform == PLATFORM_LANGWELL) {
 173                 /* Entry is 4 bytes for read/write, 5 bytes for read modify */
 174                 for (nc = 0; nc < count; nc++, offset += 3) {
 175                         cbuf[offset] = addr[nc];
 176                         cbuf[offset + 1] = addr[nc] >> 8;
 177                         if (id != IPC_CMD_PCNTRL_R)
 178                                 cbuf[offset + 2] = data[nc];
 179                         if (id == IPC_CMD_PCNTRL_M) {
 180                                 cbuf[offset + 3] = data[nc + 1];
 181                                 offset += 1;
 182                         }
 183                 }
 184                 for (nc = 0, offset = 0; nc < count; nc++, offset += 4)
 185                         ipc_data_writel(wbuf[nc], offset); /* Write wbuff */
 186
 187                 if (id != IPC_CMD_PCNTRL_M)
 188                         ipc_command((count*4) << 16 |  id << 12 | 0 << 8 | op);
 189                 else
 190                         ipc_command((count*5) << 16 |  id << 12 | 0 << 8 | op);
 191
 192         } else {
 193                 for (nc = 0; nc < count; nc++, offset += 2) {
 194                         cbuf[offset] = addr[nc];
 195                         cbuf[offset + 1] = addr[nc] >> 8;
 196                 }
 197
 198                 if (id == IPC_CMD_PCNTRL_R) {
 199                         for (nc = 0, offset = 0; nc < count; nc++, offset += 4)
 200                                 ipc_data_writel(wbuf[nc], offset);
 201                         ipc_command((count*2) << 16 |  id << 12 | 0 << 8 | op);
 202                 } else if (id == IPC_CMD_PCNTRL_W) {
 203                         for (nc = 0; nc < count; nc++, offset += 1)
 204                                 cbuf[offset] = data[nc];
 205                         for (nc = 0, offset = 0; nc < count; nc++, offset += 4)
 206                                 ipc_data_writel(wbuf[nc], offset);
 207                         ipc_command((count*3) << 16 |  id << 12 | 0 << 8 | op);
 208                 } else if (id == IPC_CMD_PCNTRL_M) {
 209                         cbuf[offset] = data[0];
 210                         cbuf[offset + 1] = data[1];
 211                         ipc_data_writel(wbuf[0], 0); /* Write wbuff */
 212                         ipc_command(4 << 16 |  id << 12 | 0 << 8 | op);
 213                 }
 214         }
 215
 216         err = busy_loop();
 217         if (id == IPC_CMD_PCNTRL_R) { /* Read rbuf */
 218                 /* Workaround: values are read as 0 without memcpy_fromio */
 219                 memcpy_fromio(cbuf, ipcdev.ipc_base + 0x90, 16);
 220                 if (platform == PLATFORM_LANGWELL) {
 221                         for (nc = 0, offset = 2; nc < count; nc++, offset += 3)
 222                                 data[nc] = ipc_data_readb(offset);
 223                 } else {
 224                         for (nc = 0; nc < count; nc++)
 225                                 data[nc] = ipc_data_readb(nc);
 226                 }
 227         }
 228         mutex_unlock(&ipclock);
 229         return err;
 230 }
 231
 232 /**
 233  *      intel_scu_ipc_ioread8           -       read a word via the SCU
 234  *      @addr: register on SCU
 235  *      @data: return pointer for read byte
 236  *
 237  *      Read a single register. Returns 0 on success or an error code. All
 238  *      locking between SCU accesses is handled for the caller.
 239  *
 240  *      This function may sleep.
 241  */
 242 int intel_scu_ipc_ioread8(u16 addr, u8 *data)
 243 {
 244         return pwr_reg_rdwr(&addr, data, 1, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_R);
 245 }
 246 EXPORT_SYMBOL(intel_scu_ipc_ioread8);
 247
 248 /**
 249  *      intel_scu_ipc_ioread16          -       read a word via the SCU
 250  *      @addr: register on SCU
 251  *      @data: return pointer for read word
 252  *
 253  *      Read a register pair. Returns 0 on success or an error code. All
 254  *      locking between SCU accesses is handled for the caller.
 255  *
 256  *      This function may sleep.
 257  */
 258 int intel_scu_ipc_ioread16(u16 addr, u16 *data)
 259 {
 260         u16 x[2] = {addr, addr + 1 };
 261         return pwr_reg_rdwr(x, (u8 *)data, 2, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_R);
 262 }
 263 EXPORT_SYMBOL(intel_scu_ipc_ioread16);
 264
 265 /**
 266  *      intel_scu_ipc_ioread32          -       read a dword via the SCU
 267  *      @addr: register on SCU
 268  *      @data: return pointer for read dword
 269  *
 270  *      Read four registers. Returns 0 on success or an error code. All
 271  *      locking between SCU accesses is handled for the caller.
 272  *
 273  *      This function may sleep.
 274  */
 275 int intel_scu_ipc_ioread32(u16 addr, u32 *data)
 276 {
 277         u16 x[4] = {addr, addr + 1, addr + 2, addr + 3};
 278         return pwr_reg_rdwr(x, (u8 *)data, 4, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_R);
 279 }
 280 EXPORT_SYMBOL(intel_scu_ipc_ioread32);
 281
 282 /**
 283  *      intel_scu_ipc_iowrite8          -       write a byte via the SCU
 284  *      @addr: register on SCU
 285  *      @data: byte to write
 286  *
 287  *      Write a single register. Returns 0 on success or an error code. All
 288  *      locking between SCU accesses is handled for the caller.
 289  *
 290  *      This function may sleep.
 291  */
 292 int intel_scu_ipc_iowrite8(u16 addr, u8 data)
 293 {
 294         return pwr_reg_rdwr(&addr, &data, 1, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_W);
 295 }
 296 EXPORT_SYMBOL(intel_scu_ipc_iowrite8);
 297
 298 /**
 299  *      intel_scu_ipc_iowrite16         -       write a word via the SCU
 300  *      @addr: register on SCU
 301  *      @data: word to write
 302  *
 303  *      Write two registers. Returns 0 on success or an error code. All
 304  *      locking between SCU accesses is handled for the caller.
 305  *
 306  *      This function may sleep.
 307  */
 308 int intel_scu_ipc_iowrite16(u16 addr, u16 data)
 309 {
 310         u16 x[2] = {addr, addr + 1 };
 311         return pwr_reg_rdwr(x, (u8 *)&data, 2, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_W);
 312 }
 313 EXPORT_SYMBOL(intel_scu_ipc_iowrite16);
 314
 315 /**
 316  *      intel_scu_ipc_iowrite32         -       write a dword via the SCU
 317  *      @addr: register on SCU
 318  *      @data: dword to write
 319  *
 320  *      Write four registers. Returns 0 on success or an error code. All
 321  *      locking between SCU accesses is handled for the caller.
 322  *
 323  *      This function may sleep.
 324  */
 325 int intel_scu_ipc_iowrite32(u16 addr, u32 data)
 326 {
 327         u16 x[4] = {addr, addr + 1, addr + 2, addr + 3};
 328         return pwr_reg_rdwr(x, (u8 *)&data, 4, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_W);
 329 }
 330 EXPORT_SYMBOL(intel_scu_ipc_iowrite32);
 331
 332 /**
 333  *      intel_scu_ipc_readvv            -       read a set of registers
 334  *      @addr: register list
 335  *      @data: bytes to return
 336  *      @len: length of array
 337  *
 338  *      Read registers. Returns 0 on success or an error code. All
 339  *      locking between SCU accesses is handled for the caller.
 340  *
 341  *      The largest array length permitted by the hardware is 5 items.
 342  *
 343  *      This function may sleep.
 344  */
 345 int intel_scu_ipc_readv(u16 *addr, u8 *data, int len)
 346 {
 347         return pwr_reg_rdwr(addr, data, len, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_R);
 348 }
 349 EXPORT_SYMBOL(intel_scu_ipc_readv);
 350
 351 /**
 352  *      intel_scu_ipc_writev            -       write a set of registers
 353  *      @addr: register list
 354  *      @data: bytes to write
 355  *      @len: length of array
 356  *
 357  *      Write registers. Returns 0 on success or an error code. All
 358  *      locking between SCU accesses is handled for the caller.
 359  *
 360  *      The largest array length permitted by the hardware is 5 items.
 361  *
 362  *      This function may sleep.
 363  *
 364  */
 365 int intel_scu_ipc_writev(u16 *addr, u8 *data, int len)
 366 {
 367         return pwr_reg_rdwr(addr, data, len, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_W);
 368 }
 369 EXPORT_SYMBOL(intel_scu_ipc_writev);
 370
 371
 372 /**
 373  *      intel_scu_ipc_update_register   -       r/m/w a register
 374  *      @addr: register address
 375  *      @bits: bits to update
 376  *      @mask: mask of bits to update
 377  *
 378  *      Read-modify-write power control unit register. The first data argument
 379  *      must be register value and second is mask value
 380  *      mask is a bitmap that indicates which bits to update.
 381  *      0 = masked. Don't modify this bit, 1 = modify this bit.
 382  *      returns 0 on success or an error code.
 383  *
 384  *      This function may sleep. Locking between SCU accesses is handled
 385  *      for the caller.
 386  */
 387 int intel_scu_ipc_update_register(u16 addr, u8 bits, u8 mask)
 388 {
 389         u8 data[2] = { bits, mask };
 390         return pwr_reg_rdwr(&addr, data, 1, IPCMSG_PCNTRL, IPC_CMD_PCNTRL_M);
 391 }
 392 EXPORT_SYMBOL(intel_scu_ipc_update_register);
 393
 394 /**
 395  *      intel_scu_ipc_simple_command    -       send a simple command
 396  *      @cmd: command
 397  *      @sub: sub type
 398  *
 399  *      Issue a simple command to the SCU. Do not use this interface if
 400  *      you must then access data as any data values may be overwritten
 401  *      by another SCU access by the time this function returns.
 402  *
 403  *      This function may sleep. Locking for SCU accesses is handled for
 404  *      the caller.
 405  */
 406 int intel_scu_ipc_simple_command(int cmd, int sub)
 407 {
 408         u32 err = 0;
 409
 410         mutex_lock(&ipclock);
 411         if (ipcdev.pdev == NULL) {
 412                 mutex_unlock(&ipclock);
 413                 return -ENODEV;
 414         }
 415         ipc_command(sub << 12 | cmd);
 416         err = busy_loop();
 417         mutex_unlock(&ipclock);
 418         return err;
 419 }
 420 EXPORT_SYMBOL(intel_scu_ipc_simple_command);
 421
 422 /**
 423  *      intel_scu_ipc_command   -       command with data
 424  *      @cmd: command
 425  *      @sub: sub type
 426  *      @in: input data
 427  *      @inlen: input length in dwords
 428  *      @out: output data
 429  *      @outlein: output length in dwords
 430  *
 431  *      Issue a command to the SCU which involves data transfers. Do the
 432  *      data copies under the lock but leave it for the caller to interpret
 433  */
 434
 435 int intel_scu_ipc_command(int cmd, int sub, u32 *in, int inlen,
 436                                                         u32 *out, int outlen)
 437 {
 438         u32 err = 0;
 439         int i = 0;
 440
 441         mutex_lock(&ipclock);
 442         if (ipcdev.pdev == NULL) {
 443                 mutex_unlock(&ipclock);
 444                 return -ENODEV;
 445         }
 446
 447         for (i = 0; i < inlen; i++)
 448                 ipc_data_writel(*in++, 4 * i);
 449
 450         ipc_command((sub << 12) | cmd | (inlen << 18));
 451         err = busy_loop();
 452
 453         for (i = 0; i < outlen; i++)
 454                 *out++ = ipc_data_readl(4 * i);
 455
 456         mutex_unlock(&ipclock);
 457         return err;
 458 }
 459 EXPORT_SYMBOL(intel_scu_ipc_command);
 460
 461 /*I2C commands */
 462 #define IPC_I2C_WRITE 1 /* I2C Write command */
 463 #define IPC_I2C_READ  2 /* I2C Read command */
 464
 465 /**
 466  *      intel_scu_ipc_i2c_cntrl         -       I2C read/write operations
 467  *      @addr: I2C address + command bits
 468  *      @data: data to read/write
 469  *
 470  *      Perform an an I2C read/write operation via the SCU. All locking is
 471  *      handled for the caller. This function may sleep.
 472  *
 473  *      Returns an error code or 0 on success.
 474  *
 475  *      This has to be in the IPC driver for the locking.
 476  */
 477 int intel_scu_ipc_i2c_cntrl(u32 addr, u32 *data)
 478 {
 479         u32 cmd = 0;
 480
 481         mutex_lock(&ipclock);
 482         if (ipcdev.pdev == NULL) {
 483                 mutex_unlock(&ipclock);
 484                 return -ENODEV;
 485         }
 486         cmd = (addr >> 24) & 0xFF;
 487         if (cmd == IPC_I2C_READ) {
 488                 writel(addr, ipcdev.i2c_base + IPC_I2C_CNTRL_ADDR);
 489                 /* Write not getting updated without delay */
 490                 mdelay(1);
 491                 *data = readl(ipcdev.i2c_base + I2C_DATA_ADDR);
 492         } else if (cmd == IPC_I2C_WRITE) {
 493                 writel(addr, ipcdev.i2c_base + I2C_DATA_ADDR);
 494                 mdelay(1);
 495                 writel(addr, ipcdev.i2c_base + IPC_I2C_CNTRL_ADDR);
 496         } else {
 497                 dev_err(&ipcdev.pdev->dev,
 498                         "intel_scu_ipc: I2C INVALID_CMD = 0x%x\n", cmd);
 499
 500                 mutex_unlock(&ipclock);
 501                 return -1;
 502         }
 503         mutex_unlock(&ipclock);
 504         return 0;
 505 }
 506 EXPORT_SYMBOL(intel_scu_ipc_i2c_cntrl);
 507
 508 #define IPC_FW_LOAD_ADDR 0xFFFC0000 /* Storage location for FW image */
 509 #define IPC_FW_UPDATE_MBOX_ADDR 0xFFFFDFF4 /* Mailbox between ipc and scu */
 510 #define IPC_MAX_FW_SIZE 262144 /* 256K storage size for loading the FW image */
 511 #define IPC_FW_MIP_HEADER_SIZE 2048 /* Firmware MIP header size */
 512 /* IPC inform SCU to get ready for update process */
 513 #define IPC_CMD_FW_UPDATE_READY  0x10FE
 514 /* IPC inform SCU to go for update process */
 515 #define IPC_CMD_FW_UPDATE_GO     0x20FE
 516 /* Status code for fw update */
 517 #define IPC_FW_UPDATE_SUCCESS   0x444f4e45 /* Status code 'DONE' */
 518 #define IPC_FW_UPDATE_BADN      0x4241444E /* Status code 'BADN' */
 519 #define IPC_FW_TXHIGH           0x54784849 /* Status code 'IPC_FW_TXHIGH' */
 520 #define IPC_FW_TXLOW            0x54784c4f /* Status code 'IPC_FW_TXLOW' */
 521
 522 struct fw_update_mailbox {
 523         u32    status;
 524         u32    scu_flag;
 525         u32    driver_flag;
 526 };
 527
 528
 529 /**
 530  *      intel_scu_ipc_fw_update -        Firmware update utility
 531  *      @buffer: firmware buffer
 532  *      @length: size of firmware buffer
 533  *
 534  *      This function provides an interface to load the firmware into
 535  *      the SCU. Returns 0 on success or -1 on failure
 536  */
 537 int intel_scu_ipc_fw_update(u8 *buffer, u32 length)
 538 {
 539         void __iomem *fw_update_base;
 540         struct fw_update_mailbox __iomem *mailbox = NULL;
 541         int retry_cnt = 0;
 542         u32 status;
 543
 544         mutex_lock(&ipclock);
 545         fw_update_base = ioremap_nocache(IPC_FW_LOAD_ADDR, (128*1024));
 546         if (fw_update_base == NULL) {
 547                 mutex_unlock(&ipclock);
 548                 return -ENOMEM;
 549         }
 550         mailbox = ioremap_nocache(IPC_FW_UPDATE_MBOX_ADDR,
 551                                         sizeof(struct fw_update_mailbox));
 552         if (mailbox == NULL) {
 553                 iounmap(fw_update_base);
 554                 mutex_unlock(&ipclock);
 555                 return -ENOMEM;
 556         }
 557
 558         ipc_command(IPC_CMD_FW_UPDATE_READY);
 559
 560         /* Intitialize mailbox */
 561         writel(0, &mailbox->status);
 562         writel(0, &mailbox->scu_flag);
 563         writel(0, &mailbox->driver_flag);
 564
 565         /* Driver copies the 2KB MIP header to SRAM at 0xFFFC0000*/
 566         memcpy_toio(fw_update_base, buffer, 0x800);
 567
 568         /* Driver sends "FW Update" IPC command (CMD_ID 0xFE; MSG_ID 0x02).
 569         * Upon receiving this command, SCU will write the 2K MIP header
 570         * from 0xFFFC0000 into NAND.
 571         * SCU will write a status code into the Mailbox, and then set scu_flag.
 572         */
 573
 574         ipc_command(IPC_CMD_FW_UPDATE_GO);
 575
 576         /*Driver stalls until scu_flag is set */
 577         while (readl(&mailbox->scu_flag) != 1) {
 578                 rmb();
 579                 mdelay(1);
 580         }
 581
 582         /* Driver checks Mailbox status.
 583          * If the status is 'BADN', then abort (bad NAND).
 584          * If the status is 'IPC_FW_TXLOW', then continue.
 585          */
 586         while (readl(&mailbox->status) != IPC_FW_TXLOW) {
 587                 rmb();
 588                 mdelay(10);
 589         }
 590         mdelay(10);
 591
 592 update_retry:
 593         if (retry_cnt > 5)
 594                 goto update_end;
 595
 596         if (readl(&mailbox->status) != IPC_FW_TXLOW)
 597                 goto update_end;
 598         buffer = buffer + 0x800;
 599         memcpy_toio(fw_update_base, buffer, 0x20000);
 600         writel(1, &mailbox->driver_flag);
 601         while (readl(&mailbox->scu_flag) == 1) {
 602                 rmb();
 603                 mdelay(1);
 604         }
 605
 606         /* check for 'BADN' */
 607         if (readl(&mailbox->status) == IPC_FW_UPDATE_BADN)
 608                 goto update_end;
 609
 610         while (readl(&mailbox->status) != IPC_FW_TXHIGH) {
 611                 rmb();
 612                 mdelay(10);
 613         }
 614         mdelay(10);
 615
 616         if (readl(&mailbox->status) != IPC_FW_TXHIGH)
 617                 goto update_end;
 618
 619         buffer = buffer + 0x20000;
 620         memcpy_toio(fw_update_base, buffer, 0x20000);
 621         writel(0, &mailbox->driver_flag);
 622
 623         while (mailbox->scu_flag == 0) {
 624                 rmb();
 625                 mdelay(1);
 626         }
 627
 628         /* check for 'BADN' */
 629         if (readl(&mailbox->status) == IPC_FW_UPDATE_BADN)
 630                 goto update_end;
 631
 632         if (readl(&mailbox->status) == IPC_FW_TXLOW) {
 633                 ++retry_cnt;
 634                 goto update_retry;
 635         }
 636
 637 update_end:
 638         status = readl(&mailbox->status);
 639
 640         iounmap(fw_update_base);
 641         iounmap(mailbox);
 642         mutex_unlock(&ipclock);
 643
 644         if (status == IPC_FW_UPDATE_SUCCESS)
 645                 return 0;
 646         return -1;
 647 }
 648 EXPORT_SYMBOL(intel_scu_ipc_fw_update);
 649
 650 /*
 651  * Interrupt handler gets called when ioc bit of IPC_COMMAND_REG set to 1
 652  * When ioc bit is set to 1, caller api must wait for interrupt handler called
 653  * which in turn unlocks the caller api. Currently this is not used
 654  *
 655  * This is edge triggered so we need take no action to clear anything
 656  */
 657 static irqreturn_t ioc(int irq, void *dev_id)
 658 {
 659         return IRQ_HANDLED;
 660 }
 661
 662 /**
 663  *      ipc_probe       -       probe an Intel SCU IPC
 664  *      @dev: the PCI device matching
 665  *      @id: entry in the match table
 666  *
 667  *      Enable and install an intel SCU IPC. This appears in the PCI space
 668  *      but uses some hard coded addresses as well.
 669  */
 670 static int ipc_probe(struct pci_dev *dev, const struct pci_device_id *id)
 671 {
 672         int err;
 673         resource_size_t pci_resource;
 674
 675         if (ipcdev.pdev)                /* We support only one SCU */
 676                 return -EBUSY;
 677
 678         ipcdev.pdev = pci_dev_get(dev);
 679
 680         err = pci_enable_device(dev);
 681         if (err)
 682                 return err;
 683
 684         err = pci_request_regions(dev, "intel_scu_ipc");
 685         if (err)
 686                 return err;
 687
 688         pci_resource = pci_resource_start(dev, 0);
 689         if (!pci_resource)
 690                 return -ENOMEM;
 691
 692         if (request_irq(dev->irq, ioc, 0, "intel_scu_ipc", &ipcdev))
 693                 return -EBUSY;
 694
 695         ipcdev.ipc_base = ioremap_nocache(IPC_BASE_ADDR, IPC_MAX_ADDR);
 696         if (!ipcdev.ipc_base)
 697                 return -ENOMEM;
 698
 699         ipcdev.i2c_base = ioremap_nocache(IPC_I2C_BASE, IPC_I2C_MAX_ADDR);
 700         if (!ipcdev.i2c_base) {
 701                 iounmap(ipcdev.ipc_base);
 702                 return -ENOMEM;
 703         }
 704         return 0;
 705 }
 706
 707 /**
 708  *      ipc_remove      -       remove a bound IPC device
 709  *      @pdev: PCI device
 710  *
 711  *      In practice the SCU is not removable but this function is also
 712  *      called for each device on a module unload or cleanup which is the
 713  *      path that will get used.
 714  *
 715  *      Free up the mappings and release the PCI resources
 716  */
 717 static void ipc_remove(struct pci_dev *pdev)
 718 {
 719         free_irq(pdev->irq, &ipcdev);
 720         pci_release_regions(pdev);
 721         pci_dev_put(ipcdev.pdev);
 722         iounmap(ipcdev.ipc_base);
 723         iounmap(ipcdev.i2c_base);
 724         ipcdev.pdev = NULL;
 725 }
 726
 727 static const struct pci_device_id pci_ids[] = {
 728         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x080e)},
 729         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x082a)},
 730         { 0,}
 731 };
 732 MODULE_DEVICE_TABLE(pci, pci_ids);
 733
 734 static struct pci_driver ipc_driver = {
 735         .name = "intel_scu_ipc",
 736         .id_table = pci_ids,
 737         .probe = ipc_probe,
 738         .remove = ipc_remove,
 739 };
 740
 741
 742 static int __init intel_scu_ipc_init(void)
 743 {
 744         if (boot_cpu_data.x86 == 6 &&
 745                 boot_cpu_data.x86_model == 0x27 &&
 746                 boot_cpu_data.x86_mask == 1)
 747                         platform = PLATFORM_PENWELL;
 748         else if (boot_cpu_data.x86 == 6 &&
 749                 boot_cpu_data.x86_model == 0x26)
 750                         platform = PLATFORM_LANGWELL;
 751
 752         return  pci_register_driver(&ipc_driver);
 753 }
 754
 755 static void __exit intel_scu_ipc_exit(void)
 756 {
 757         pci_unregister_driver(&ipc_driver);
 758 }
 759
 760 MODULE_AUTHOR("Sreedhara DS <sreedhara.ds@intel.com>");
 761 MODULE_DESCRIPTION("Intel SCU IPC driver");
 762 MODULE_LICENSE("GPL");
 763
 764 module_init(intel_scu_ipc_init);
 765 module_exit(intel_scu_ipc_exit);