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