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