?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fs: use kmem_cache_zalloc instead
[pv_ops_mirror.git] / drivers / i2c / chips / menelaus.c
blobd9c92c5e007730ac62f7140ef51f5edb9d5eafb3
1 /*
2 * Copyright (C) 2004 Texas Instruments, Inc.
3 *
4 * Some parts based tps65010.c:
5 * Copyright (C) 2004 Texas Instruments and
6 * Copyright (C) 2004-2005 David Brownell
7 *
8 * Some parts based on tlv320aic24.c:
9 * Copyright (C) by Kai Svahn <kai.svahn@nokia.com>
10 *
11 * Changes for interrupt handling and clean-up by
12 * Tony Lindgren <tony@atomide.com> and Imre Deak <imre.deak@nokia.com>
13 * Cleanup and generalized support for voltage setting by
14 * Juha Yrjola
15 * Added support for controlling VCORE and regulator sleep states,
16 * Amit Kucheria <amit.kucheria@nokia.com>
17 * Copyright (C) 2005, 2006 Nokia Corporation
18 *
19 * This program is free software; you can redistribute it and/or modify
20 * it under the terms of the GNU General Public License as published by
21 * the Free Software Foundation; either version 2 of the License, or
22 * (at your option) any later version.
23 *
24 * This program is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27 * GNU General Public License for more details.
28 *
29 * You should have received a copy of the GNU General Public License
30 * along with this program; if not, write to the Free Software
31 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 */
33
34 #include <linux/module.h>
35 #include <linux/i2c.h>
36 #include <linux/interrupt.h>
37 #include <linux/sched.h>
38 #include <linux/mutex.h>
39 #include <linux/workqueue.h>
40 #include <linux/delay.h>
41 #include <linux/rtc.h>
42 #include <linux/bcd.h>
43
44 #include <asm/mach-types.h>
45 #include <asm/mach/irq.h>
46
47 #include <asm/arch/gpio.h>
48 #include <asm/arch/menelaus.h>
49
50 #define DRIVER_NAME "menelaus"
51
52 #define pr_err(fmt, arg...) printk(KERN_ERR DRIVER_NAME ": ", ## arg);
53
54 #define MENELAUS_I2C_ADDRESS 0x72
55
56 #define MENELAUS_REV 0x01
57 #define MENELAUS_VCORE_CTRL1 0x02
58 #define MENELAUS_VCORE_CTRL2 0x03
59 #define MENELAUS_VCORE_CTRL3 0x04
60 #define MENELAUS_VCORE_CTRL4 0x05
61 #define MENELAUS_VCORE_CTRL5 0x06
62 #define MENELAUS_DCDC_CTRL1 0x07
63 #define MENELAUS_DCDC_CTRL2 0x08
64 #define MENELAUS_DCDC_CTRL3 0x09
65 #define MENELAUS_LDO_CTRL1 0x0A
66 #define MENELAUS_LDO_CTRL2 0x0B
67 #define MENELAUS_LDO_CTRL3 0x0C
68 #define MENELAUS_LDO_CTRL4 0x0D
69 #define MENELAUS_LDO_CTRL5 0x0E
70 #define MENELAUS_LDO_CTRL6 0x0F
71 #define MENELAUS_LDO_CTRL7 0x10
72 #define MENELAUS_LDO_CTRL8 0x11
73 #define MENELAUS_SLEEP_CTRL1 0x12
74 #define MENELAUS_SLEEP_CTRL2 0x13
75 #define MENELAUS_DEVICE_OFF 0x14
76 #define MENELAUS_OSC_CTRL 0x15
77 #define MENELAUS_DETECT_CTRL 0x16
78 #define MENELAUS_INT_MASK1 0x17
79 #define MENELAUS_INT_MASK2 0x18
80 #define MENELAUS_INT_STATUS1 0x19
81 #define MENELAUS_INT_STATUS2 0x1A
82 #define MENELAUS_INT_ACK1 0x1B
83 #define MENELAUS_INT_ACK2 0x1C
84 #define MENELAUS_GPIO_CTRL 0x1D
85 #define MENELAUS_GPIO_IN 0x1E
86 #define MENELAUS_GPIO_OUT 0x1F
87 #define MENELAUS_BBSMS 0x20
88 #define MENELAUS_RTC_CTRL 0x21
89 #define MENELAUS_RTC_UPDATE 0x22
90 #define MENELAUS_RTC_SEC 0x23
91 #define MENELAUS_RTC_MIN 0x24
92 #define MENELAUS_RTC_HR 0x25
93 #define MENELAUS_RTC_DAY 0x26
94 #define MENELAUS_RTC_MON 0x27
95 #define MENELAUS_RTC_YR 0x28
96 #define MENELAUS_RTC_WKDAY 0x29
97 #define MENELAUS_RTC_AL_SEC 0x2A
98 #define MENELAUS_RTC_AL_MIN 0x2B
99 #define MENELAUS_RTC_AL_HR 0x2C
100 #define MENELAUS_RTC_AL_DAY 0x2D
101 #define MENELAUS_RTC_AL_MON 0x2E
102 #define MENELAUS_RTC_AL_YR 0x2F
103 #define MENELAUS_RTC_COMP_MSB 0x30
104 #define MENELAUS_RTC_COMP_LSB 0x31
105 #define MENELAUS_S1_PULL_EN 0x32
106 #define MENELAUS_S1_PULL_DIR 0x33
107 #define MENELAUS_S2_PULL_EN 0x34
108 #define MENELAUS_S2_PULL_DIR 0x35
109 #define MENELAUS_MCT_CTRL1 0x36
110 #define MENELAUS_MCT_CTRL2 0x37
111 #define MENELAUS_MCT_CTRL3 0x38
112 #define MENELAUS_MCT_PIN_ST 0x39
113 #define MENELAUS_DEBOUNCE1 0x3A
114
115 #define IH_MENELAUS_IRQS 12
116 #define MENELAUS_MMC_S1CD_IRQ 0 /* MMC slot 1 card change */
117 #define MENELAUS_MMC_S2CD_IRQ 1 /* MMC slot 2 card change */
118 #define MENELAUS_MMC_S1D1_IRQ 2 /* MMC DAT1 low in slot 1 */
119 #define MENELAUS_MMC_S2D1_IRQ 3 /* MMC DAT1 low in slot 2 */
120 #define MENELAUS_LOWBAT_IRQ 4 /* Low battery */
121 #define MENELAUS_HOTDIE_IRQ 5 /* Hot die detect */
122 #define MENELAUS_UVLO_IRQ 6 /* UVLO detect */
123 #define MENELAUS_TSHUT_IRQ 7 /* Thermal shutdown */
124 #define MENELAUS_RTCTMR_IRQ 8 /* RTC timer */
125 #define MENELAUS_RTCALM_IRQ 9 /* RTC alarm */
126 #define MENELAUS_RTCERR_IRQ 10 /* RTC error */
127 #define MENELAUS_PSHBTN_IRQ 11 /* Push button */
128 #define MENELAUS_RESERVED12_IRQ 12 /* Reserved */
129 #define MENELAUS_RESERVED13_IRQ 13 /* Reserved */
130 #define MENELAUS_RESERVED14_IRQ 14 /* Reserved */
131 #define MENELAUS_RESERVED15_IRQ 15 /* Reserved */
132
133 static void menelaus_work(struct work_struct *_menelaus);
134
135 struct menelaus_chip {
136 struct mutex lock;
137 struct i2c_client *client;
138 struct work_struct work;
139 #ifdef CONFIG_RTC_DRV_TWL92330
140 struct rtc_device *rtc;
141 u8 rtc_control;
142 unsigned uie:1;
143 #endif
144 unsigned vcore_hw_mode:1;
145 u8 mask1, mask2;
146 void (*handlers[16])(struct menelaus_chip *);
147 void (*mmc_callback)(void *data, u8 mask);
148 void *mmc_callback_data;
149 };
150
151 static struct menelaus_chip *the_menelaus;
152
153 static int menelaus_write_reg(int reg, u8 value)
154 {
155 int val = i2c_smbus_write_byte_data(the_menelaus->client, reg, value);
156
157 if (val < 0) {
158 pr_err("write error");
159 return val;
160 }
161
162 return 0;
163 }
164
165 static int menelaus_read_reg(int reg)
166 {
167 int val = i2c_smbus_read_byte_data(the_menelaus->client, reg);
168
169 if (val < 0)
170 pr_err("read error");
171
172 return val;
173 }
174
175 static int menelaus_enable_irq(int irq)
176 {
177 if (irq > 7) {
178 irq -= 8;
179 the_menelaus->mask2 &= ~(1 << irq);
180 return menelaus_write_reg(MENELAUS_INT_MASK2,
181 the_menelaus->mask2);
182 } else {
183 the_menelaus->mask1 &= ~(1 << irq);
184 return menelaus_write_reg(MENELAUS_INT_MASK1,
185 the_menelaus->mask1);
186 }
187 }
188
189 static int menelaus_disable_irq(int irq)
190 {
191 if (irq > 7) {
192 irq -= 8;
193 the_menelaus->mask2 |= (1 << irq);
194 return menelaus_write_reg(MENELAUS_INT_MASK2,
195 the_menelaus->mask2);
196 } else {
197 the_menelaus->mask1 |= (1 << irq);
198 return menelaus_write_reg(MENELAUS_INT_MASK1,
199 the_menelaus->mask1);
200 }
201 }
202
203 static int menelaus_ack_irq(int irq)
204 {
205 if (irq > 7)
206 return menelaus_write_reg(MENELAUS_INT_ACK2, 1 << (irq - 8));
207 else
208 return menelaus_write_reg(MENELAUS_INT_ACK1, 1 << irq);
209 }
210
211 /* Adds a handler for an interrupt. Does not run in interrupt context */
212 static int menelaus_add_irq_work(int irq,
213 void (*handler)(struct menelaus_chip *))
214 {
215 int ret = 0;
216
217 mutex_lock(&the_menelaus->lock);
218 the_menelaus->handlers[irq] = handler;
219 ret = menelaus_enable_irq(irq);
220 mutex_unlock(&the_menelaus->lock);
221
222 return ret;
223 }
224
225 /* Removes handler for an interrupt */
226 static int menelaus_remove_irq_work(int irq)
227 {
228 int ret = 0;
229
230 mutex_lock(&the_menelaus->lock);
231 ret = menelaus_disable_irq(irq);
232 the_menelaus->handlers[irq] = NULL;
233 mutex_unlock(&the_menelaus->lock);
234
235 return ret;
236 }
237
238 /*
239 * Gets scheduled when a card detect interrupt happens. Note that in some cases
240 * this line is wired to card cover switch rather than the card detect switch
241 * in each slot. In this case the cards are not seen by menelaus.
242 * FIXME: Add handling for D1 too
243 */
244 static void menelaus_mmc_cd_work(struct menelaus_chip *menelaus_hw)
245 {
246 int reg;
247 unsigned char card_mask = 0;
248
249 reg = menelaus_read_reg(MENELAUS_MCT_PIN_ST);
250 if (reg < 0)
251 return;
252
253 if (!(reg & 0x1))
254 card_mask |= (1 << 0);
255
256 if (!(reg & 0x2))
257 card_mask |= (1 << 1);
258
259 if (menelaus_hw->mmc_callback)
260 menelaus_hw->mmc_callback(menelaus_hw->mmc_callback_data,
261 card_mask);
262 }
263
264 /*
265 * Toggles the MMC slots between open-drain and push-pull mode.
266 */
267 int menelaus_set_mmc_opendrain(int slot, int enable)
268 {
269 int ret, val;
270
271 if (slot != 1 && slot != 2)
272 return -EINVAL;
273 mutex_lock(&the_menelaus->lock);
274 ret = menelaus_read_reg(MENELAUS_MCT_CTRL1);
275 if (ret < 0) {
276 mutex_unlock(&the_menelaus->lock);
277 return ret;
278 }
279 val = ret;
280 if (slot == 1) {
281 if (enable)
282 val |= 1 << 2;
283 else
284 val &= ~(1 << 2);
285 } else {
286 if (enable)
287 val |= 1 << 3;
288 else
289 val &= ~(1 << 3);
290 }
291 ret = menelaus_write_reg(MENELAUS_MCT_CTRL1, val);
292 mutex_unlock(&the_menelaus->lock);
293
294 return ret;
295 }
296 EXPORT_SYMBOL(menelaus_set_mmc_opendrain);
297
298 int menelaus_set_slot_sel(int enable)
299 {
300 int ret;
301
302 mutex_lock(&the_menelaus->lock);
303 ret = menelaus_read_reg(MENELAUS_GPIO_CTRL);
304 if (ret < 0)
305 goto out;
306 ret |= 0x02;
307 if (enable)
308 ret |= 1 << 5;
309 else
310 ret &= ~(1 << 5);
311 ret = menelaus_write_reg(MENELAUS_GPIO_CTRL, ret);
312 out:
313 mutex_unlock(&the_menelaus->lock);
314 return ret;
315 }
316 EXPORT_SYMBOL(menelaus_set_slot_sel);
317
318 int menelaus_set_mmc_slot(int slot, int enable, int power, int cd_en)
319 {
320 int ret, val;
321
322 if (slot != 1 && slot != 2)
323 return -EINVAL;
324 if (power >= 3)
325 return -EINVAL;
326
327 mutex_lock(&the_menelaus->lock);
328
329 ret = menelaus_read_reg(MENELAUS_MCT_CTRL2);
330 if (ret < 0)
331 goto out;
332 val = ret;
333 if (slot == 1) {
334 if (cd_en)
335 val |= (1 << 4) | (1 << 6);
336 else
337 val &= ~((1 << 4) | (1 << 6));
338 } else {
339 if (cd_en)
340 val |= (1 << 5) | (1 << 7);
341 else
342 val &= ~((1 << 5) | (1 << 7));
343 }
344 ret = menelaus_write_reg(MENELAUS_MCT_CTRL2, val);
345 if (ret < 0)
346 goto out;
347
348 ret = menelaus_read_reg(MENELAUS_MCT_CTRL3);
349 if (ret < 0)
350 goto out;
351 val = ret;
352 if (slot == 1) {
353 if (enable)
354 val |= 1 << 0;
355 else
356 val &= ~(1 << 0);
357 } else {
358 int b;
359
360 if (enable)
361 ret |= 1 << 1;
362 else
363 ret &= ~(1 << 1);
364 b = menelaus_read_reg(MENELAUS_MCT_CTRL2);
365 b &= ~0x03;
366 b |= power;
367 ret = menelaus_write_reg(MENELAUS_MCT_CTRL2, b);
368 if (ret < 0)
369 goto out;
370 }
371 /* Disable autonomous shutdown */
372 val &= ~(0x03 << 2);
373 ret = menelaus_write_reg(MENELAUS_MCT_CTRL3, val);
374 out:
375 mutex_unlock(&the_menelaus->lock);
376 return ret;
377 }
378 EXPORT_SYMBOL(menelaus_set_mmc_slot);
379
380 int menelaus_register_mmc_callback(void (*callback)(void *data, u8 card_mask),
381 void *data)
382 {
383 int ret = 0;
384
385 the_menelaus->mmc_callback_data = data;
386 the_menelaus->mmc_callback = callback;
387 ret = menelaus_add_irq_work(MENELAUS_MMC_S1CD_IRQ,
388 menelaus_mmc_cd_work);
389 if (ret < 0)
390 return ret;
391 ret = menelaus_add_irq_work(MENELAUS_MMC_S2CD_IRQ,
392 menelaus_mmc_cd_work);
393 if (ret < 0)
394 return ret;
395 ret = menelaus_add_irq_work(MENELAUS_MMC_S1D1_IRQ,
396 menelaus_mmc_cd_work);
397 if (ret < 0)
398 return ret;
399 ret = menelaus_add_irq_work(MENELAUS_MMC_S2D1_IRQ,
400 menelaus_mmc_cd_work);
401
402 return ret;
403 }
404 EXPORT_SYMBOL(menelaus_register_mmc_callback);
405
406 void menelaus_unregister_mmc_callback(void)
407 {
408 menelaus_remove_irq_work(MENELAUS_MMC_S1CD_IRQ);
409 menelaus_remove_irq_work(MENELAUS_MMC_S2CD_IRQ);
410 menelaus_remove_irq_work(MENELAUS_MMC_S1D1_IRQ);
411 menelaus_remove_irq_work(MENELAUS_MMC_S2D1_IRQ);
412
413 the_menelaus->mmc_callback = NULL;
414 the_menelaus->mmc_callback_data = 0;
415 }
416 EXPORT_SYMBOL(menelaus_unregister_mmc_callback);
417
418 struct menelaus_vtg {
419 const char *name;
420 u8 vtg_reg;
421 u8 vtg_shift;
422 u8 vtg_bits;
423 u8 mode_reg;
424 };
425
426 struct menelaus_vtg_value {
427 u16 vtg;
428 u16 val;
429 };
430
431 static int menelaus_set_voltage(const struct menelaus_vtg *vtg, int mV,
432 int vtg_val, int mode)
433 {
434 int val, ret;
435 struct i2c_client *c = the_menelaus->client;
436
437 mutex_lock(&the_menelaus->lock);
438 if (vtg == 0)
439 goto set_voltage;
440
441 ret = menelaus_read_reg(vtg->vtg_reg);
442 if (ret < 0)
443 goto out;
444 val = ret & ~(((1 << vtg->vtg_bits) - 1) << vtg->vtg_shift);
445 val |= vtg_val << vtg->vtg_shift;
446
447 dev_dbg(&c->dev, "Setting voltage '%s'"
448 "to %d mV (reg 0x%02x, val 0x%02x)\n",
449 vtg->name, mV, vtg->vtg_reg, val);
450
451 ret = menelaus_write_reg(vtg->vtg_reg, val);
452 if (ret < 0)
453 goto out;
454 set_voltage:
455 ret = menelaus_write_reg(vtg->mode_reg, mode);
456 out:
457 mutex_unlock(&the_menelaus->lock);
458 if (ret == 0) {
459 /* Wait for voltage to stabilize */
460 msleep(1);
461 }
462 return ret;
463 }
464
465 static int menelaus_get_vtg_value(int vtg, const struct menelaus_vtg_value *tbl,
466 int n)
467 {
468 int i;
469
470 for (i = 0; i < n; i++, tbl++)
471 if (tbl->vtg == vtg)
472 return tbl->val;
473 return -EINVAL;
474 }
475
476 /*
477 * Vcore can be programmed in two ways:
478 * SW-controlled: Required voltage is programmed into VCORE_CTRL1
479 * HW-controlled: Required range (roof-floor) is programmed into VCORE_CTRL3
480 * and VCORE_CTRL4
481 *
482 * Call correct 'set' function accordingly
483 */
484
485 static const struct menelaus_vtg_value vcore_values[] = {
486 { 1000, 0 },
487 { 1025, 1 },
488 { 1050, 2 },
489 { 1075, 3 },
490 { 1100, 4 },
491 { 1125, 5 },
492 { 1150, 6 },
493 { 1175, 7 },
494 { 1200, 8 },
495 { 1225, 9 },
496 { 1250, 10 },
497 { 1275, 11 },
498 { 1300, 12 },
499 { 1325, 13 },
500 { 1350, 14 },
501 { 1375, 15 },
502 { 1400, 16 },
503 { 1425, 17 },
504 { 1450, 18 },
505 };
506
507 int menelaus_set_vcore_sw(unsigned int mV)
508 {
509 int val, ret;
510 struct i2c_client *c = the_menelaus->client;
511
512 val = menelaus_get_vtg_value(mV, vcore_values,
513 ARRAY_SIZE(vcore_values));
514 if (val < 0)
515 return -EINVAL;
516
517 dev_dbg(&c->dev, "Setting VCORE to %d mV (val 0x%02x)\n", mV, val);
518
519 /* Set SW mode and the voltage in one go. */
520 mutex_lock(&the_menelaus->lock);
521 ret = menelaus_write_reg(MENELAUS_VCORE_CTRL1, val);
522 if (ret == 0)
523 the_menelaus->vcore_hw_mode = 0;
524 mutex_unlock(&the_menelaus->lock);
525 msleep(1);
526
527 return ret;
528 }
529
530 int menelaus_set_vcore_hw(unsigned int roof_mV, unsigned int floor_mV)
531 {
532 int fval, rval, val, ret;
533 struct i2c_client *c = the_menelaus->client;
534
535 rval = menelaus_get_vtg_value(roof_mV, vcore_values,
536 ARRAY_SIZE(vcore_values));
537 if (rval < 0)
538 return -EINVAL;
539 fval = menelaus_get_vtg_value(floor_mV, vcore_values,
540 ARRAY_SIZE(vcore_values));
541 if (fval < 0)
542 return -EINVAL;
543
544 dev_dbg(&c->dev, "Setting VCORE FLOOR to %d mV and ROOF to %d mV\n",
545 floor_mV, roof_mV);
546
547 mutex_lock(&the_menelaus->lock);
548 ret = menelaus_write_reg(MENELAUS_VCORE_CTRL3, fval);
549 if (ret < 0)
550 goto out;
551 ret = menelaus_write_reg(MENELAUS_VCORE_CTRL4, rval);
552 if (ret < 0)
553 goto out;
554 if (!the_menelaus->vcore_hw_mode) {
555 val = menelaus_read_reg(MENELAUS_VCORE_CTRL1);
556 /* HW mode, turn OFF byte comparator */
557 val |= ((1 << 7) | (1 << 5));
558 ret = menelaus_write_reg(MENELAUS_VCORE_CTRL1, val);
559 the_menelaus->vcore_hw_mode = 1;
560 }
561 msleep(1);
562 out:
563 mutex_unlock(&the_menelaus->lock);
564 return ret;
565 }
566
567 static const struct menelaus_vtg vmem_vtg = {
568 .name = "VMEM",
569 .vtg_reg = MENELAUS_LDO_CTRL1,
570 .vtg_shift = 0,
571 .vtg_bits = 2,
572 .mode_reg = MENELAUS_LDO_CTRL3,
573 };
574
575 static const struct menelaus_vtg_value vmem_values[] = {
576 { 1500, 0 },
577 { 1800, 1 },
578 { 1900, 2 },
579 { 2500, 3 },
580 };
581
582 int menelaus_set_vmem(unsigned int mV)
583 {
584 int val;
585
586 if (mV == 0)
587 return menelaus_set_voltage(&vmem_vtg, 0, 0, 0);
588
589 val = menelaus_get_vtg_value(mV, vmem_values, ARRAY_SIZE(vmem_values));
590 if (val < 0)
591 return -EINVAL;
592 return menelaus_set_voltage(&vmem_vtg, mV, val, 0x02);
593 }
594 EXPORT_SYMBOL(menelaus_set_vmem);
595
596 static const struct menelaus_vtg vio_vtg = {
597 .name = "VIO",
598 .vtg_reg = MENELAUS_LDO_CTRL1,
599 .vtg_shift = 2,
600 .vtg_bits = 2,
601 .mode_reg = MENELAUS_LDO_CTRL4,
602 };
603
604 static const struct menelaus_vtg_value vio_values[] = {
605 { 1500, 0 },
606 { 1800, 1 },
607 { 2500, 2 },
608 { 2800, 3 },
609 };
610
611 int menelaus_set_vio(unsigned int mV)
612 {
613 int val;
614
615 if (mV == 0)
616 return menelaus_set_voltage(&vio_vtg, 0, 0, 0);
617
618 val = menelaus_get_vtg_value(mV, vio_values, ARRAY_SIZE(vio_values));
619 if (val < 0)
620 return -EINVAL;
621 return menelaus_set_voltage(&vio_vtg, mV, val, 0x02);
622 }
623 EXPORT_SYMBOL(menelaus_set_vio);
624
625 static const struct menelaus_vtg_value vdcdc_values[] = {
626 { 1500, 0 },
627 { 1800, 1 },
628 { 2000, 2 },
629 { 2200, 3 },
630 { 2400, 4 },
631 { 2800, 5 },
632 { 3000, 6 },
633 { 3300, 7 },
634 };
635
636 static const struct menelaus_vtg vdcdc2_vtg = {
637 .name = "VDCDC2",
638 .vtg_reg = MENELAUS_DCDC_CTRL1,
639 .vtg_shift = 0,
640 .vtg_bits = 3,
641 .mode_reg = MENELAUS_DCDC_CTRL2,
642 };
643
644 static const struct menelaus_vtg vdcdc3_vtg = {
645 .name = "VDCDC3",
646 .vtg_reg = MENELAUS_DCDC_CTRL1,
647 .vtg_shift = 3,
648 .vtg_bits = 3,
649 .mode_reg = MENELAUS_DCDC_CTRL3,
650 };
651
652 int menelaus_set_vdcdc(int dcdc, unsigned int mV)
653 {
654 const struct menelaus_vtg *vtg;
655 int val;
656
657 if (dcdc != 2 && dcdc != 3)
658 return -EINVAL;
659 if (dcdc == 2)
660 vtg = &vdcdc2_vtg;
661 else
662 vtg = &vdcdc3_vtg;
663
664 if (mV == 0)
665 return menelaus_set_voltage(vtg, 0, 0, 0);
666
667 val = menelaus_get_vtg_value(mV, vdcdc_values,
668 ARRAY_SIZE(vdcdc_values));
669 if (val < 0)
670 return -EINVAL;
671 return menelaus_set_voltage(vtg, mV, val, 0x03);
672 }
673
674 static const struct menelaus_vtg_value vmmc_values[] = {
675 { 1850, 0 },
676 { 2800, 1 },
677 { 3000, 2 },
678 { 3100, 3 },
679 };
680
681 static const struct menelaus_vtg vmmc_vtg = {
682 .name = "VMMC",
683 .vtg_reg = MENELAUS_LDO_CTRL1,
684 .vtg_shift = 6,
685 .vtg_bits = 2,
686 .mode_reg = MENELAUS_LDO_CTRL7,
687 };
688
689 int menelaus_set_vmmc(unsigned int mV)
690 {
691 int val;
692
693 if (mV == 0)
694 return menelaus_set_voltage(&vmmc_vtg, 0, 0, 0);
695
696 val = menelaus_get_vtg_value(mV, vmmc_values, ARRAY_SIZE(vmmc_values));
697 if (val < 0)
698 return -EINVAL;
699 return menelaus_set_voltage(&vmmc_vtg, mV, val, 0x02);
700 }
701 EXPORT_SYMBOL(menelaus_set_vmmc);
702
703
704 static const struct menelaus_vtg_value vaux_values[] = {
705 { 1500, 0 },
706 { 1800, 1 },
707 { 2500, 2 },
708 { 2800, 3 },
709 };
710
711 static const struct menelaus_vtg vaux_vtg = {
712 .name = "VAUX",
713 .vtg_reg = MENELAUS_LDO_CTRL1,
714 .vtg_shift = 4,
715 .vtg_bits = 2,
716 .mode_reg = MENELAUS_LDO_CTRL6,
717 };
718
719 int menelaus_set_vaux(unsigned int mV)
720 {
721 int val;
722
723 if (mV == 0)
724 return menelaus_set_voltage(&vaux_vtg, 0, 0, 0);
725
726 val = menelaus_get_vtg_value(mV, vaux_values, ARRAY_SIZE(vaux_values));
727 if (val < 0)
728 return -EINVAL;
729 return menelaus_set_voltage(&vaux_vtg, mV, val, 0x02);
730 }
731 EXPORT_SYMBOL(menelaus_set_vaux);
732
733 int menelaus_get_slot_pin_states(void)
734 {
735 return menelaus_read_reg(MENELAUS_MCT_PIN_ST);
736 }
737 EXPORT_SYMBOL(menelaus_get_slot_pin_states);
738
739 int menelaus_set_regulator_sleep(int enable, u32 val)
740 {
741 int t, ret;
742 struct i2c_client *c = the_menelaus->client;
743
744 mutex_lock(&the_menelaus->lock);
745 ret = menelaus_write_reg(MENELAUS_SLEEP_CTRL2, val);
746 if (ret < 0)
747 goto out;
748
749 dev_dbg(&c->dev, "regulator sleep configuration: %02x\n", val);
750
751 ret = menelaus_read_reg(MENELAUS_GPIO_CTRL);
752 if (ret < 0)
753 goto out;
754 t = ((1 << 6) | 0x04);
755 if (enable)
756 ret |= t;
757 else
758 ret &= ~t;
759 ret = menelaus_write_reg(MENELAUS_GPIO_CTRL, ret);
760 out:
761 mutex_unlock(&the_menelaus->lock);
762 return ret;
763 }
764
765 /*-----------------------------------------------------------------------*/
766
767 /* Handles Menelaus interrupts. Does not run in interrupt context */
768 static void menelaus_work(struct work_struct *_menelaus)
769 {
770 struct menelaus_chip *menelaus =
771 container_of(_menelaus, struct menelaus_chip, work);
772 void (*handler)(struct menelaus_chip *menelaus);
773
774 while (1) {
775 unsigned isr;
776
777 isr = (menelaus_read_reg(MENELAUS_INT_STATUS2)
778 & ~menelaus->mask2) << 8;
779 isr |= menelaus_read_reg(MENELAUS_INT_STATUS1)
780 & ~menelaus->mask1;
781 if (!isr)
782 break;
783
784 while (isr) {
785 int irq = fls(isr) - 1;
786 isr &= ~(1 << irq);
787
788 mutex_lock(&menelaus->lock);
789 menelaus_disable_irq(irq);
790 menelaus_ack_irq(irq);
791 handler = menelaus->handlers[irq];
792 if (handler)
793 handler(menelaus);
794 menelaus_enable_irq(irq);
795 mutex_unlock(&menelaus->lock);
796 }
797 }
798 enable_irq(menelaus->client->irq);
799 }
800
801 /*
802 * We cannot use I2C in interrupt context, so we just schedule work.
803 */
804 static irqreturn_t menelaus_irq(int irq, void *_menelaus)
805 {
806 struct menelaus_chip *menelaus = _menelaus;
807
808 disable_irq_nosync(irq);
809 (void)schedule_work(&menelaus->work);
810
811 return IRQ_HANDLED;
812 }
813
814 /*-----------------------------------------------------------------------*/
815
816 /*
817 * The RTC needs to be set once, then it runs on backup battery power.
818 * It supports alarms, including system wake alarms (from some modes);
819 * and 1/second IRQs if requested.
820 */
821 #ifdef CONFIG_RTC_DRV_TWL92330
822
823 #define RTC_CTRL_RTC_EN (1 << 0)
824 #define RTC_CTRL_AL_EN (1 << 1)
825 #define RTC_CTRL_MODE12 (1 << 2)
826 #define RTC_CTRL_EVERY_MASK (3 << 3)
827 #define RTC_CTRL_EVERY_SEC (0 << 3)
828 #define RTC_CTRL_EVERY_MIN (1 << 3)
829 #define RTC_CTRL_EVERY_HR (2 << 3)
830 #define RTC_CTRL_EVERY_DAY (3 << 3)
831
832 #define RTC_UPDATE_EVERY 0x08
833
834 #define RTC_HR_PM (1 << 7)
835
836 static void menelaus_to_time(char *regs, struct rtc_time *t)
837 {
838 t->tm_sec = BCD2BIN(regs[0]);
839 t->tm_min = BCD2BIN(regs[1]);
840 if (the_menelaus->rtc_control & RTC_CTRL_MODE12) {
841 t->tm_hour = BCD2BIN(regs[2] & 0x1f) - 1;
842 if (regs[2] & RTC_HR_PM)
843 t->tm_hour += 12;
844 } else
845 t->tm_hour = BCD2BIN(regs[2] & 0x3f);
846 t->tm_mday = BCD2BIN(regs[3]);
847 t->tm_mon = BCD2BIN(regs[4]) - 1;
848 t->tm_year = BCD2BIN(regs[5]) + 100;
849 }
850
851 static int time_to_menelaus(struct rtc_time *t, int regnum)
852 {
853 int hour, status;
854
855 status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_sec));
856 if (status < 0)
857 goto fail;
858
859 status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_min));
860 if (status < 0)
861 goto fail;
862
863 if (the_menelaus->rtc_control & RTC_CTRL_MODE12) {
864 hour = t->tm_hour + 1;
865 if (hour > 12)
866 hour = RTC_HR_PM | BIN2BCD(hour - 12);
867 else
868 hour = BIN2BCD(hour);
869 } else
870 hour = BIN2BCD(t->tm_hour);
871 status = menelaus_write_reg(regnum++, hour);
872 if (status < 0)
873 goto fail;
874
875 status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_mday));
876 if (status < 0)
877 goto fail;
878
879 status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_mon + 1));
880 if (status < 0)
881 goto fail;
882
883 status = menelaus_write_reg(regnum++, BIN2BCD(t->tm_year - 100));
884 if (status < 0)
885 goto fail;
886
887 return 0;
888 fail:
889 dev_err(&the_menelaus->client->dev, "rtc write reg %02x, err %d\n",
890 --regnum, status);
891 return status;
892 }
893
894 static int menelaus_read_time(struct device *dev, struct rtc_time *t)
895 {
896 struct i2c_msg msg[2];
897 char regs[7];
898 int status;
899
900 /* block read date and time registers */
901 regs[0] = MENELAUS_RTC_SEC;
902
903 msg[0].addr = MENELAUS_I2C_ADDRESS;
904 msg[0].flags = 0;
905 msg[0].len = 1;
906 msg[0].buf = regs;
907
908 msg[1].addr = MENELAUS_I2C_ADDRESS;
909 msg[1].flags = I2C_M_RD;
910 msg[1].len = sizeof(regs);
911 msg[1].buf = regs;
912
913 status = i2c_transfer(the_menelaus->client->adapter, msg, 2);
914 if (status != 2) {
915 dev_err(dev, "%s error %d\n", "read", status);
916 return -EIO;
917 }
918
919 menelaus_to_time(regs, t);
920 t->tm_wday = BCD2BIN(regs[6]);
921
922 return 0;
923 }
924
925 static int menelaus_set_time(struct device *dev, struct rtc_time *t)
926 {
927 int status;
928
929 /* write date and time registers */
930 status = time_to_menelaus(t, MENELAUS_RTC_SEC);
931 if (status < 0)
932 return status;
933 status = menelaus_write_reg(MENELAUS_RTC_WKDAY, BIN2BCD(t->tm_wday));
934 if (status < 0) {
935 dev_err(&the_menelaus->client->dev, "rtc write reg %02x "
936 "err %d\n", MENELAUS_RTC_WKDAY, status);
937 return status;
938 }
939
940 /* now commit the write */
941 status = menelaus_write_reg(MENELAUS_RTC_UPDATE, RTC_UPDATE_EVERY);
942 if (status < 0)
943 dev_err(&the_menelaus->client->dev, "rtc commit time, err %d\n",
944 status);
945
946 return 0;
947 }
948
949 static int menelaus_read_alarm(struct device *dev, struct rtc_wkalrm *w)
950 {
951 struct i2c_msg msg[2];
952 char regs[6];
953 int status;
954
955 /* block read alarm registers */
956 regs[0] = MENELAUS_RTC_AL_SEC;
957
958 msg[0].addr = MENELAUS_I2C_ADDRESS;
959 msg[0].flags = 0;
960 msg[0].len = 1;
961 msg[0].buf = regs;
962
963 msg[1].addr = MENELAUS_I2C_ADDRESS;
964 msg[1].flags = I2C_M_RD;
965 msg[1].len = sizeof(regs);
966 msg[1].buf = regs;
967
968 status = i2c_transfer(the_menelaus->client->adapter, msg, 2);
969 if (status != 2) {
970 dev_err(dev, "%s error %d\n", "alarm read", status);
971 return -EIO;
972 }
973
974 menelaus_to_time(regs, &w->time);
975
976 w->enabled = !!(the_menelaus->rtc_control & RTC_CTRL_AL_EN);
977
978 /* NOTE we *could* check if actually pending... */
979 w->pending = 0;
980
981 return 0;
982 }
983
984 static int menelaus_set_alarm(struct device *dev, struct rtc_wkalrm *w)
985 {
986 int status;
987
988 if (the_menelaus->client->irq <= 0 && w->enabled)
989 return -ENODEV;
990
991 /* clear previous alarm enable */
992 if (the_menelaus->rtc_control & RTC_CTRL_AL_EN) {
993 the_menelaus->rtc_control &= ~RTC_CTRL_AL_EN;
994 status = menelaus_write_reg(MENELAUS_RTC_CTRL,
995 the_menelaus->rtc_control);
996 if (status < 0)
997 return status;
998 }
999
1000 /* write alarm registers */
1001 status = time_to_menelaus(&w->time, MENELAUS_RTC_AL_SEC);
1002 if (status < 0)
1003 return status;
1004
1005 /* enable alarm if requested */
1006 if (w->enabled) {
1007 the_menelaus->rtc_control |= RTC_CTRL_AL_EN;
1008 status = menelaus_write_reg(MENELAUS_RTC_CTRL,
1009 the_menelaus->rtc_control);
1010 }
1011
1012 return status;
1013 }
1014
1015 #ifdef CONFIG_RTC_INTF_DEV
1016
1017 static void menelaus_rtc_update_work(struct menelaus_chip *m)
1018 {
1019 /* report 1/sec update */
1020 local_irq_disable();
1021 rtc_update_irq(m->rtc, 1, RTC_IRQF | RTC_UF);
1022 local_irq_enable();
1023 }
1024
1025 static int menelaus_ioctl(struct device *dev, unsigned cmd, unsigned long arg)
1026 {
1027 int status;
1028
1029 if (the_menelaus->client->irq <= 0)
1030 return -ENOIOCTLCMD;
1031
1032 switch (cmd) {
1033 /* alarm IRQ */
1034 case RTC_AIE_ON:
1035 if (the_menelaus->rtc_control & RTC_CTRL_AL_EN)
1036 return 0;
1037 the_menelaus->rtc_control |= RTC_CTRL_AL_EN;
1038 break;
1039 case RTC_AIE_OFF:
1040 if (!(the_menelaus->rtc_control & RTC_CTRL_AL_EN))
1041 return 0;
1042 the_menelaus->rtc_control &= ~RTC_CTRL_AL_EN;
1043 break;
1044 /* 1/second "update" IRQ */
1045 case RTC_UIE_ON:
1046 if (the_menelaus->uie)
1047 return 0;
1048 status = menelaus_remove_irq_work(MENELAUS_RTCTMR_IRQ);
1049 status = menelaus_add_irq_work(MENELAUS_RTCTMR_IRQ,
1050 menelaus_rtc_update_work);
1051 if (status == 0)
1052 the_menelaus->uie = 1;
1053 return status;
1054 case RTC_UIE_OFF:
1055 if (!the_menelaus->uie)
1056 return 0;
1057 status = menelaus_remove_irq_work(MENELAUS_RTCTMR_IRQ);
1058 if (status == 0)
1059 the_menelaus->uie = 0;
1060 return status;
1061 default:
1062 return -ENOIOCTLCMD;
1063 }
1064 return menelaus_write_reg(MENELAUS_RTC_CTRL, the_menelaus->rtc_control);
1065 }
1066
1067 #else
1068 #define menelaus_ioctl NULL
1069 #endif
1070
1071 /* REVISIT no compensation register support ... */
1072
1073 static const struct rtc_class_ops menelaus_rtc_ops = {
1074 .ioctl = menelaus_ioctl,
1075 .read_time = menelaus_read_time,
1076 .set_time = menelaus_set_time,
1077 .read_alarm = menelaus_read_alarm,
1078 .set_alarm = menelaus_set_alarm,
1079 };
1080
1081 static void menelaus_rtc_alarm_work(struct menelaus_chip *m)
1082 {
1083 /* report alarm */
1084 local_irq_disable();
1085 rtc_update_irq(m->rtc, 1, RTC_IRQF | RTC_AF);
1086 local_irq_enable();
1087
1088 /* then disable it; alarms are oneshot */
1089 the_menelaus->rtc_control &= ~RTC_CTRL_AL_EN;
1090 menelaus_write_reg(MENELAUS_RTC_CTRL, the_menelaus->rtc_control);
1091 }
1092
1093 static inline void menelaus_rtc_init(struct menelaus_chip *m)
1094 {
1095 int alarm = (m->client->irq > 0);
1096
1097 /* assume 32KDETEN pin is pulled high */
1098 if (!(menelaus_read_reg(MENELAUS_OSC_CTRL) & 0x80)) {
1099 dev_dbg(&m->client->dev, "no 32k oscillator\n");
1100 return;
1101 }
1102
1103 /* support RTC alarm; it can issue wakeups */
1104 if (alarm) {
1105 if (menelaus_add_irq_work(MENELAUS_RTCALM_IRQ,
1106 menelaus_rtc_alarm_work) < 0) {
1107 dev_err(&m->client->dev, "can't handle RTC alarm\n");
1108 return;
1109 }
1110 device_init_wakeup(&m->client->dev, 1);
1111 }
1112
1113 /* be sure RTC is enabled; allow 1/sec irqs; leave 12hr mode alone */
1114 m->rtc_control = menelaus_read_reg(MENELAUS_RTC_CTRL);
1115 if (!(m->rtc_control & RTC_CTRL_RTC_EN)
1116 || (m->rtc_control & RTC_CTRL_AL_EN)
1117 || (m->rtc_control & RTC_CTRL_EVERY_MASK)) {
1118 if (!(m->rtc_control & RTC_CTRL_RTC_EN)) {
1119 dev_warn(&m->client->dev, "rtc clock needs setting\n");
1120 m->rtc_control |= RTC_CTRL_RTC_EN;
1121 }
1122 m->rtc_control &= ~RTC_CTRL_EVERY_MASK;
1123 m->rtc_control &= ~RTC_CTRL_AL_EN;
1124 menelaus_write_reg(MENELAUS_RTC_CTRL, m->rtc_control);
1125 }
1126
1127 m->rtc = rtc_device_register(DRIVER_NAME,
1128 &m->client->dev,
1129 &menelaus_rtc_ops, THIS_MODULE);
1130 if (IS_ERR(m->rtc)) {
1131 if (alarm) {
1132 menelaus_remove_irq_work(MENELAUS_RTCALM_IRQ);
1133 device_init_wakeup(&m->client->dev, 0);
1134 }
1135 dev_err(&m->client->dev, "can't register RTC: %d\n",
1136 (int) PTR_ERR(m->rtc));
1137 the_menelaus->rtc = NULL;
1138 }
1139 }
1140
1141 #else
1142
1143 static inline void menelaus_rtc_init(struct menelaus_chip *m)
1144 {
1145 /* nothing */
1146 }
1147
1148 #endif
1149
1150 /*-----------------------------------------------------------------------*/
1151
1152 static struct i2c_driver menelaus_i2c_driver;
1153
1154 static int menelaus_probe(struct i2c_client *client)
1155 {
1156 struct menelaus_chip *menelaus;
1157 int rev = 0, val;
1158 int err = 0;
1159 struct menelaus_platform_data *menelaus_pdata =
1160 client->dev.platform_data;
1161
1162 if (the_menelaus) {
1163 dev_dbg(&client->dev, "only one %s for now\n",
1164 DRIVER_NAME);
1165 return -ENODEV;
1166 }
1167
1168 menelaus = kzalloc(sizeof *menelaus, GFP_KERNEL);
1169 if (!menelaus)
1170 return -ENOMEM;
1171
1172 i2c_set_clientdata(client, menelaus);
1173
1174 the_menelaus = menelaus;
1175 menelaus->client = client;
1176
1177 /* If a true probe check the device */
1178 rev = menelaus_read_reg(MENELAUS_REV);
1179 if (rev < 0) {
1180 pr_err("device not found");
1181 err = -ENODEV;
1182 goto fail1;
1183 }
1184
1185 /* Ack and disable all Menelaus interrupts */
1186 menelaus_write_reg(MENELAUS_INT_ACK1, 0xff);
1187 menelaus_write_reg(MENELAUS_INT_ACK2, 0xff);
1188 menelaus_write_reg(MENELAUS_INT_MASK1, 0xff);
1189 menelaus_write_reg(MENELAUS_INT_MASK2, 0xff);
1190 menelaus->mask1 = 0xff;
1191 menelaus->mask2 = 0xff;
1192
1193 /* Set output buffer strengths */
1194 menelaus_write_reg(MENELAUS_MCT_CTRL1, 0x73);
1195
1196 if (client->irq > 0) {
1197 err = request_irq(client->irq, menelaus_irq, IRQF_DISABLED,
1198 DRIVER_NAME, menelaus);
1199 if (err) {
1200 dev_dbg(&client->dev, "can't get IRQ %d, err %d",
1201 client->irq, err);
1202 goto fail1;
1203 }
1204 }
1205
1206 mutex_init(&menelaus->lock);
1207 INIT_WORK(&menelaus->work, menelaus_work);
1208
1209 pr_info("Menelaus rev %d.%d\n", rev >> 4, rev & 0x0f);
1210
1211 val = menelaus_read_reg(MENELAUS_VCORE_CTRL1);
1212 if (val < 0)
1213 goto fail2;
1214 if (val & (1 << 7))
1215 menelaus->vcore_hw_mode = 1;
1216 else
1217 menelaus->vcore_hw_mode = 0;
1218
1219 if (menelaus_pdata != NULL && menelaus_pdata->late_init != NULL) {
1220 err = menelaus_pdata->late_init(&client->dev);
1221 if (err < 0)
1222 goto fail2;
1223 }
1224
1225 menelaus_rtc_init(menelaus);
1226
1227 return 0;
1228 fail2:
1229 free_irq(client->irq, menelaus);
1230 flush_scheduled_work();
1231 fail1:
1232 kfree(menelaus);
1233 return err;
1234 }
1235
1236 static int __exit menelaus_remove(struct i2c_client *client)
1237 {
1238 struct menelaus_chip *menelaus = i2c_get_clientdata(client);
1239
1240 free_irq(client->irq, menelaus);
1241 kfree(menelaus);
1242 i2c_set_clientdata(client, NULL);
1243 the_menelaus = NULL;
1244 return 0;
1245 }
1246
1247 static struct i2c_driver menelaus_i2c_driver = {
1248 .driver = {
1249 .name = DRIVER_NAME,
1250 },
1251 .probe = menelaus_probe,
1252 .remove = __exit_p(menelaus_remove),
1253 };
1254
1255 static int __init menelaus_init(void)
1256 {
1257 int res;
1258
1259 res = i2c_add_driver(&menelaus_i2c_driver);
1260 if (res < 0) {
1261 pr_err("driver registration failed\n");
1262 return res;
1263 }
1264
1265 return 0;
1266 }
1267
1268 static void __exit menelaus_exit(void)
1269 {
1270 i2c_del_driver(&menelaus_i2c_driver);
1271
1272 /* FIXME: Shutdown menelaus parts that can be shut down */
1273 }
1274
1275 MODULE_AUTHOR("Texas Instruments, Inc. (and others)");
1276 MODULE_DESCRIPTION("I2C interface for Menelaus.");
1277 MODULE_LICENSE("GPL");
1278
1279 module_init(menelaus_init);
1280 module_exit(menelaus_exit);
Mirror for ia64_pv_ops.git