Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / drivers / mfd / twl4030-power.c
1 /*
2  * linux/drivers/i2c/chips/twl4030-power.c
3  *
4  * Handle TWL4030 Power initialization
5  *
6  * Copyright (C) 2008 Nokia Corporation
7  * Copyright (C) 2006 Texas Instruments, Inc
8  *
9  * Written by   Kalle Jokiniemi
10  *              Peter De Schrijver <peter.de-schrijver@nokia.com>
11  * Several fixes by Amit Kucheria <amit.kucheria@verdurent.com>
12  *
13  * This file is subject to the terms and conditions of the GNU General
14  * Public License. See the file "COPYING" in the main directory of this
15  * archive for more details.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
25  */
26
27 #include <linux/module.h>
28 #include <linux/pm.h>
29 #include <linux/i2c/twl.h>
30 #include <linux/platform_device.h>
31
32 #include <asm/mach-types.h>
33
34 static u8 twl4030_start_script_address = 0x2b;
35
36 #define PWR_P1_SW_EVENTS        0x10
37 #define PWR_DEVOFF      (1<<0)
38
39 #define PHY_TO_OFF_PM_MASTER(p)         (p - 0x36)
40 #define PHY_TO_OFF_PM_RECEIVER(p)       (p - 0x5b)
41
42 /* resource - hfclk */
43 #define R_HFCLKOUT_DEV_GRP      PHY_TO_OFF_PM_RECEIVER(0xe6)
44
45 /* PM events */
46 #define R_P1_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x46)
47 #define R_P2_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x47)
48 #define R_P3_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x48)
49 #define R_CFG_P1_TRANSITION     PHY_TO_OFF_PM_MASTER(0x36)
50 #define R_CFG_P2_TRANSITION     PHY_TO_OFF_PM_MASTER(0x37)
51 #define R_CFG_P3_TRANSITION     PHY_TO_OFF_PM_MASTER(0x38)
52
53 #define LVL_WAKEUP      0x08
54
55 #define ENABLE_WARMRESET (1<<4)
56
57 #define END_OF_SCRIPT           0x3f
58
59 #define R_SEQ_ADD_A2S           PHY_TO_OFF_PM_MASTER(0x55)
60 #define R_SEQ_ADD_S2A12         PHY_TO_OFF_PM_MASTER(0x56)
61 #define R_SEQ_ADD_S2A3          PHY_TO_OFF_PM_MASTER(0x57)
62 #define R_SEQ_ADD_WARM          PHY_TO_OFF_PM_MASTER(0x58)
63 #define R_MEMORY_ADDRESS        PHY_TO_OFF_PM_MASTER(0x59)
64 #define R_MEMORY_DATA           PHY_TO_OFF_PM_MASTER(0x5a)
65
66 #define R_PROTECT_KEY           0x0E
67 #define R_KEY_1                 0xC0
68 #define R_KEY_2                 0x0C
69
70 /* resource configuration registers
71    <RESOURCE>_DEV_GRP   at address 'n+0'
72    <RESOURCE>_TYPE      at address 'n+1'
73    <RESOURCE>_REMAP     at address 'n+2'
74    <RESOURCE>_DEDICATED at address 'n+3'
75 */
76 #define DEV_GRP_OFFSET          0
77 #define TYPE_OFFSET             1
78 #define REMAP_OFFSET            2
79 #define DEDICATED_OFFSET        3
80
81 /* Bit positions in the registers */
82
83 /* <RESOURCE>_DEV_GRP */
84 #define DEV_GRP_SHIFT           5
85 #define DEV_GRP_MASK            (7 << DEV_GRP_SHIFT)
86
87 /* <RESOURCE>_TYPE */
88 #define TYPE_SHIFT              0
89 #define TYPE_MASK               (7 << TYPE_SHIFT)
90 #define TYPE2_SHIFT             3
91 #define TYPE2_MASK              (3 << TYPE2_SHIFT)
92
93 /* <RESOURCE>_REMAP */
94 #define SLEEP_STATE_SHIFT       0
95 #define SLEEP_STATE_MASK        (0xf << SLEEP_STATE_SHIFT)
96 #define OFF_STATE_SHIFT         4
97 #define OFF_STATE_MASK          (0xf << OFF_STATE_SHIFT)
98
99 static u8 res_config_addrs[] = {
100         [RES_VAUX1]     = 0x17,
101         [RES_VAUX2]     = 0x1b,
102         [RES_VAUX3]     = 0x1f,
103         [RES_VAUX4]     = 0x23,
104         [RES_VMMC1]     = 0x27,
105         [RES_VMMC2]     = 0x2b,
106         [RES_VPLL1]     = 0x2f,
107         [RES_VPLL2]     = 0x33,
108         [RES_VSIM]      = 0x37,
109         [RES_VDAC]      = 0x3b,
110         [RES_VINTANA1]  = 0x3f,
111         [RES_VINTANA2]  = 0x43,
112         [RES_VINTDIG]   = 0x47,
113         [RES_VIO]       = 0x4b,
114         [RES_VDD1]      = 0x55,
115         [RES_VDD2]      = 0x63,
116         [RES_VUSB_1V5]  = 0x71,
117         [RES_VUSB_1V8]  = 0x74,
118         [RES_VUSB_3V1]  = 0x77,
119         [RES_VUSBCP]    = 0x7a,
120         [RES_REGEN]     = 0x7f,
121         [RES_NRES_PWRON] = 0x82,
122         [RES_CLKEN]     = 0x85,
123         [RES_SYSEN]     = 0x88,
124         [RES_HFCLKOUT]  = 0x8b,
125         [RES_32KCLKOUT] = 0x8e,
126         [RES_RESET]     = 0x91,
127         [RES_Main_Ref]  = 0x94,
128 };
129
130 static int __init twl4030_write_script_byte(u8 address, u8 byte)
131 {
132         int err;
133
134         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
135                                 R_MEMORY_ADDRESS);
136         if (err)
137                 goto out;
138         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, byte,
139                                 R_MEMORY_DATA);
140 out:
141         return err;
142 }
143
144 static int __init twl4030_write_script_ins(u8 address, u16 pmb_message,
145                                            u8 delay, u8 next)
146 {
147         int err;
148
149         address *= 4;
150         err = twl4030_write_script_byte(address++, pmb_message >> 8);
151         if (err)
152                 goto out;
153         err = twl4030_write_script_byte(address++, pmb_message & 0xff);
154         if (err)
155                 goto out;
156         err = twl4030_write_script_byte(address++, delay);
157         if (err)
158                 goto out;
159         err = twl4030_write_script_byte(address++, next);
160 out:
161         return err;
162 }
163
164 static int __init twl4030_write_script(u8 address, struct twl4030_ins *script,
165                                        int len)
166 {
167         int err;
168
169         for (; len; len--, address++, script++) {
170                 if (len == 1) {
171                         err = twl4030_write_script_ins(address,
172                                                 script->pmb_message,
173                                                 script->delay,
174                                                 END_OF_SCRIPT);
175                         if (err)
176                                 break;
177                 } else {
178                         err = twl4030_write_script_ins(address,
179                                                 script->pmb_message,
180                                                 script->delay,
181                                                 address + 1);
182                         if (err)
183                                 break;
184                 }
185         }
186         return err;
187 }
188
189 static int __init twl4030_config_wakeup3_sequence(u8 address)
190 {
191         int err;
192         u8 data;
193
194         /* Set SLEEP to ACTIVE SEQ address for P3 */
195         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
196                                 R_SEQ_ADD_S2A3);
197         if (err)
198                 goto out;
199
200         /* P3 LVL_WAKEUP should be on LEVEL */
201         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
202                                 R_P3_SW_EVENTS);
203         if (err)
204                 goto out;
205         data |= LVL_WAKEUP;
206         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
207                                 R_P3_SW_EVENTS);
208 out:
209         if (err)
210                 pr_err("TWL4030 wakeup sequence for P3 config error\n");
211         return err;
212 }
213
214 static int __init twl4030_config_wakeup12_sequence(u8 address)
215 {
216         int err = 0;
217         u8 data;
218
219         /* Set SLEEP to ACTIVE SEQ address for P1 and P2 */
220         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
221                                 R_SEQ_ADD_S2A12);
222         if (err)
223                 goto out;
224
225         /* P1/P2 LVL_WAKEUP should be on LEVEL */
226         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
227                                 R_P1_SW_EVENTS);
228         if (err)
229                 goto out;
230
231         data |= LVL_WAKEUP;
232         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
233                                 R_P1_SW_EVENTS);
234         if (err)
235                 goto out;
236
237         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
238                                 R_P2_SW_EVENTS);
239         if (err)
240                 goto out;
241
242         data |= LVL_WAKEUP;
243         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
244                                 R_P2_SW_EVENTS);
245         if (err)
246                 goto out;
247
248         if (machine_is_omap_3430sdp() || machine_is_omap_ldp()) {
249                 /* Disabling AC charger effect on sleep-active transitions */
250                 err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
251                                         R_CFG_P1_TRANSITION);
252                 if (err)
253                         goto out;
254                 data &= ~(1<<1);
255                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data ,
256                                         R_CFG_P1_TRANSITION);
257                 if (err)
258                         goto out;
259         }
260
261 out:
262         if (err)
263                 pr_err("TWL4030 wakeup sequence for P1 and P2" \
264                         "config error\n");
265         return err;
266 }
267
268 static int __init twl4030_config_sleep_sequence(u8 address)
269 {
270         int err;
271
272         /* Set ACTIVE to SLEEP SEQ address in T2 memory*/
273         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
274                                 R_SEQ_ADD_A2S);
275
276         if (err)
277                 pr_err("TWL4030 sleep sequence config error\n");
278
279         return err;
280 }
281
282 static int __init twl4030_config_warmreset_sequence(u8 address)
283 {
284         int err;
285         u8 rd_data;
286
287         /* Set WARM RESET SEQ address for P1 */
288         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
289                                 R_SEQ_ADD_WARM);
290         if (err)
291                 goto out;
292
293         /* P1/P2/P3 enable WARMRESET */
294         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
295                                 R_P1_SW_EVENTS);
296         if (err)
297                 goto out;
298
299         rd_data |= ENABLE_WARMRESET;
300         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
301                                 R_P1_SW_EVENTS);
302         if (err)
303                 goto out;
304
305         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
306                                 R_P2_SW_EVENTS);
307         if (err)
308                 goto out;
309
310         rd_data |= ENABLE_WARMRESET;
311         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
312                                 R_P2_SW_EVENTS);
313         if (err)
314                 goto out;
315
316         err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
317                                 R_P3_SW_EVENTS);
318         if (err)
319                 goto out;
320
321         rd_data |= ENABLE_WARMRESET;
322         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
323                                 R_P3_SW_EVENTS);
324 out:
325         if (err)
326                 pr_err("TWL4030 warmreset seq config error\n");
327         return err;
328 }
329
330 static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
331 {
332         int rconfig_addr;
333         int err;
334         u8 type;
335         u8 grp;
336         u8 remap;
337
338         if (rconfig->resource > TOTAL_RESOURCES) {
339                 pr_err("TWL4030 Resource %d does not exist\n",
340                         rconfig->resource);
341                 return -EINVAL;
342         }
343
344         rconfig_addr = res_config_addrs[rconfig->resource];
345
346         /* Set resource group */
347         err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &grp,
348                               rconfig_addr + DEV_GRP_OFFSET);
349         if (err) {
350                 pr_err("TWL4030 Resource %d group could not be read\n",
351                         rconfig->resource);
352                 return err;
353         }
354
355         if (rconfig->devgroup != TWL4030_RESCONFIG_UNDEF) {
356                 grp &= ~DEV_GRP_MASK;
357                 grp |= rconfig->devgroup << DEV_GRP_SHIFT;
358                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
359                                        grp, rconfig_addr + DEV_GRP_OFFSET);
360                 if (err < 0) {
361                         pr_err("TWL4030 failed to program devgroup\n");
362                         return err;
363                 }
364         }
365
366         /* Set resource types */
367         err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &type,
368                                 rconfig_addr + TYPE_OFFSET);
369         if (err < 0) {
370                 pr_err("TWL4030 Resource %d type could not be read\n",
371                         rconfig->resource);
372                 return err;
373         }
374
375         if (rconfig->type != TWL4030_RESCONFIG_UNDEF) {
376                 type &= ~TYPE_MASK;
377                 type |= rconfig->type << TYPE_SHIFT;
378         }
379
380         if (rconfig->type2 != TWL4030_RESCONFIG_UNDEF) {
381                 type &= ~TYPE2_MASK;
382                 type |= rconfig->type2 << TYPE2_SHIFT;
383         }
384
385         err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
386                                 type, rconfig_addr + TYPE_OFFSET);
387         if (err < 0) {
388                 pr_err("TWL4030 failed to program resource type\n");
389                 return err;
390         }
391
392         /* Set remap states */
393         err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &remap,
394                               rconfig_addr + REMAP_OFFSET);
395         if (err < 0) {
396                 pr_err("TWL4030 Resource %d remap could not be read\n",
397                         rconfig->resource);
398                 return err;
399         }
400
401         if (rconfig->remap_off != TWL4030_RESCONFIG_UNDEF) {
402                 remap &= ~OFF_STATE_MASK;
403                 remap |= rconfig->remap_off << OFF_STATE_SHIFT;
404         }
405
406         if (rconfig->remap_sleep != TWL4030_RESCONFIG_UNDEF) {
407                 remap &= ~SLEEP_STATE_MASK;
408                 remap |= rconfig->remap_sleep << SLEEP_STATE_SHIFT;
409         }
410
411         err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
412                                remap,
413                                rconfig_addr + REMAP_OFFSET);
414         if (err < 0) {
415                 pr_err("TWL4030 failed to program remap\n");
416                 return err;
417         }
418
419         return 0;
420 }
421
422 static int __init load_twl4030_script(struct twl4030_script *tscript,
423                u8 address)
424 {
425         int err;
426         static int order;
427
428         /* Make sure the script isn't going beyond last valid address (0x3f) */
429         if ((address + tscript->size) > END_OF_SCRIPT) {
430                 pr_err("TWL4030 scripts too big error\n");
431                 return -EINVAL;
432         }
433
434         err = twl4030_write_script(address, tscript->script, tscript->size);
435         if (err)
436                 goto out;
437
438         if (tscript->flags & TWL4030_WRST_SCRIPT) {
439                 err = twl4030_config_warmreset_sequence(address);
440                 if (err)
441                         goto out;
442         }
443         if (tscript->flags & TWL4030_WAKEUP12_SCRIPT) {
444                 err = twl4030_config_wakeup12_sequence(address);
445                 if (err)
446                         goto out;
447                 order = 1;
448         }
449         if (tscript->flags & TWL4030_WAKEUP3_SCRIPT) {
450                 err = twl4030_config_wakeup3_sequence(address);
451                 if (err)
452                         goto out;
453         }
454         if (tscript->flags & TWL4030_SLEEP_SCRIPT)
455                 if (order)
456                         pr_warning("TWL4030: Bad order of scripts (sleep "\
457                                         "script before wakeup) Leads to boot"\
458                                         "failure on some boards\n");
459                 err = twl4030_config_sleep_sequence(address);
460 out:
461         return err;
462 }
463
464 int twl4030_remove_script(u8 flags)
465 {
466         int err = 0;
467
468         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1,
469                         R_PROTECT_KEY);
470         if (err) {
471                 pr_err("twl4030: unable to unlock PROTECT_KEY\n");
472                 return err;
473         }
474
475         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2,
476                         R_PROTECT_KEY);
477         if (err) {
478                 pr_err("twl4030: unable to unlock PROTECT_KEY\n");
479                 return err;
480         }
481
482         if (flags & TWL4030_WRST_SCRIPT) {
483                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, END_OF_SCRIPT,
484                                 R_SEQ_ADD_WARM);
485                 if (err)
486                         return err;
487         }
488         if (flags & TWL4030_WAKEUP12_SCRIPT) {
489                 if (err)
490                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, END_OF_SCRIPT,
491                                 R_SEQ_ADD_S2A12);
492                         return err;
493         }
494         if (flags & TWL4030_WAKEUP3_SCRIPT) {
495                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, END_OF_SCRIPT,
496                                 R_SEQ_ADD_S2A3);
497                 if (err)
498                         return err;
499         }
500         if (flags & TWL4030_SLEEP_SCRIPT) {
501                 err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, END_OF_SCRIPT,
502                                 R_SEQ_ADD_A2S);
503                 if (err)
504                         return err;
505         }
506
507         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);
508         if (err)
509                 pr_err("TWL4030 Unable to relock registers\n");
510
511         return err;
512 }
513
514 void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
515 {
516         int err = 0;
517         int i;
518         struct twl4030_resconfig *resconfig;
519         u8 address = twl4030_start_script_address;
520
521         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1,
522                                 R_PROTECT_KEY);
523         if (err)
524                 goto unlock;
525
526         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2,
527                                 R_PROTECT_KEY);
528         if (err)
529                 goto unlock;
530
531         for (i = 0; i < twl4030_scripts->num; i++) {
532                 err = load_twl4030_script(twl4030_scripts->scripts[i], address);
533                 if (err)
534                         goto load;
535                 address += twl4030_scripts->scripts[i]->size;
536         }
537
538         resconfig = twl4030_scripts->resource_config;
539         if (resconfig) {
540                 while (resconfig->resource) {
541                         err = twl4030_configure_resource(resconfig);
542                         if (err)
543                                 goto resource;
544                         resconfig++;
545
546                 }
547         }
548
549         err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);
550         if (err)
551                 pr_err("TWL4030 Unable to relock registers\n");
552         return;
553
554 unlock:
555         if (err)
556                 pr_err("TWL4030 Unable to unlock registers\n");
557         return;
558 load:
559         if (err)
560                 pr_err("TWL4030 failed to load scripts\n");
561         return;
562 resource:
563         if (err)
564                 pr_err("TWL4030 failed to configure resource\n");
565         return;
566 }