projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'sched-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / drivers / mfd / twl4030-core.c
CommitLineData
a603a7fa
DB		 1/*
2 * twl4030_core.c - driver for TWL4030/TPS659x0 PM and audio CODEC devices
3 *
4 * Copyright (C) 2005-2006 Texas Instruments, Inc.
5 *
6 * Modifications to defer interrupt handling to a kernel thread:
7 * Copyright (C) 2006 MontaVista Software, Inc.
8 *
9 * Based on tlv320aic23.c:
10 * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
11 *
12 * Code cleanup and modifications to IRQ handler.
13 * by syed khasim <x0khasim@ti.com>
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 2 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, write to the Free Software
27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 */
29
a603a7fa
DB		 30#include <linux/init.h>
31#include <linux/mutex.h>
a603a7fa
DB		 32#include <linux/platform_device.h>
33#include <linux/clk.h>
a30d46c0 34#include <linux/err.h>
a603a7fa 35
dad759ff
DB		 36#include <linux/regulator/machine.h>
37
a603a7fa
DB		 38#include <linux/i2c.h>
39#include <linux/i2c/twl4030.h>
40
b29c06ae
SO		 41#ifdef CONFIG_ARM
42#include <mach/cpu.h>
43#endif
a603a7fa
DB		 44
45/*
46 * The TWL4030 "Triton 2" is one of a family of a multi-function "Power
47 * Management and System Companion Device" chips originally designed for
48 * use in OMAP2 and OMAP 3 based systems. Its control interfaces use I2C,
49 * often at around 3 Mbit/sec, including for interrupt handling.
50 *
51 * This driver core provides genirq support for the interrupts emitted,
52 * by the various modules, and exports register access primitives.
53 *
54 * FIXME this driver currently requires use of the first interrupt line
55 * (and associated registers).
56 */
57
58#define DRIVER_NAME "twl4030"
59
60#if defined(CONFIG_TWL4030_BCI_BATTERY) || \
61 defined(CONFIG_TWL4030_BCI_BATTERY_MODULE)
62#define twl_has_bci() true
63#else
64#define twl_has_bci() false
65#endif
66
67#if defined(CONFIG_KEYBOARD_TWL4030) || defined(CONFIG_KEYBOARD_TWL4030_MODULE)
68#define twl_has_keypad() true
69#else
70#define twl_has_keypad() false
71#endif
72
73#if defined(CONFIG_GPIO_TWL4030) || defined(CONFIG_GPIO_TWL4030_MODULE)
74#define twl_has_gpio() true
75#else
76#define twl_has_gpio() false
77#endif
78
dad759ff
DB		 79#if defined(CONFIG_REGULATOR_TWL4030) \
80 || defined(CONFIG_REGULATOR_TWL4030_MODULE)
81#define twl_has_regulator() true
82#else
83#define twl_has_regulator() false
84#endif
85
a603a7fa
DB		 86#if defined(CONFIG_TWL4030_MADC) || defined(CONFIG_TWL4030_MADC_MODULE)
87#define twl_has_madc() true
88#else
89#define twl_has_madc() false
90#endif
91
92#if defined(CONFIG_RTC_DRV_TWL4030) || defined(CONFIG_RTC_DRV_TWL4030_MODULE)
93#define twl_has_rtc() true
94#else
95#define twl_has_rtc() false
96#endif
97
98#if defined(CONFIG_TWL4030_USB) || defined(CONFIG_TWL4030_USB_MODULE)
99#define twl_has_usb() true
100#else
101#define twl_has_usb() false
102#endif
103
a603a7fa
DB		 104
105/* Triton Core internal information (BEGIN) */
106
107/* Last - for index max*/
108#define TWL4030_MODULE_LAST TWL4030_MODULE_SECURED_REG
109
110#define TWL4030_NUM_SLAVES 4
111
112
113/* Base Address defns for twl4030_map[] */
114
115/* subchip/slave 0 - USB ID */
116#define TWL4030_BASEADD_USB 0x0000
117
118/* subchip/slave 1 - AUD ID */
119#define TWL4030_BASEADD_AUDIO_VOICE 0x0000
120#define TWL4030_BASEADD_GPIO 0x0098
121#define TWL4030_BASEADD_INTBR 0x0085
122#define TWL4030_BASEADD_PIH 0x0080
123#define TWL4030_BASEADD_TEST 0x004C
124
125/* subchip/slave 2 - AUX ID */
126#define TWL4030_BASEADD_INTERRUPTS 0x00B9
127#define TWL4030_BASEADD_LED 0x00EE
128#define TWL4030_BASEADD_MADC 0x0000
129#define TWL4030_BASEADD_MAIN_CHARGE 0x0074
130#define TWL4030_BASEADD_PRECHARGE 0x00AA
131#define TWL4030_BASEADD_PWM0 0x00F8
132#define TWL4030_BASEADD_PWM1 0x00FB
133#define TWL4030_BASEADD_PWMA 0x00EF
134#define TWL4030_BASEADD_PWMB 0x00F1
135#define TWL4030_BASEADD_KEYPAD 0x00D2
136
137/* subchip/slave 3 - POWER ID */
138#define TWL4030_BASEADD_BACKUP 0x0014
139#define TWL4030_BASEADD_INT 0x002E
140#define TWL4030_BASEADD_PM_MASTER 0x0036
141#define TWL4030_BASEADD_PM_RECEIVER 0x005B
142#define TWL4030_BASEADD_RTC 0x001C
143#define TWL4030_BASEADD_SECURED_REG 0x0000
144
145/* Triton Core internal information (END) */
146
147
148/* Few power values */
149#define R_CFG_BOOT 0x05
150#define R_PROTECT_KEY 0x0E
151
152/* access control values for R_PROTECT_KEY */
153#define KEY_UNLOCK1 0xce
154#define KEY_UNLOCK2 0xec
155#define KEY_LOCK 0x00
156
157/* some fields in R_CFG_BOOT */
158#define HFCLK_FREQ_19p2_MHZ (1 << 0)
159#define HFCLK_FREQ_26_MHZ (2 << 0)
160#define HFCLK_FREQ_38p4_MHZ (3 << 0)
161#define HIGH_PERF_SQ (1 << 3)
162
163
dad759ff
DB		 164/* chip-specific feature flags, for i2c_device_id.driver_data */
165#define TWL4030_VAUX2 BIT(0) /* pre-5030 voltage ranges */
166#define TPS_SUBSET BIT(1) /* tps659[23]0 have fewer LDOs */
167
a603a7fa
DB		 168/*----------------------------------------------------------------------*/
169
a603a7fa
DB		 170/* is driver active, bound to a chip? */
171static bool inuse;
172
173/* Structure for each TWL4030 Slave */
174struct twl4030_client {
175 struct i2c_client *client;
176 u8 address;
177
178 /* max numb of i2c_msg required is for read =2 */
179 struct i2c_msg xfer_msg[2];
180
181 /* To lock access to xfer_msg */
182 struct mutex xfer_lock;
183};
184
185static struct twl4030_client twl4030_modules[TWL4030_NUM_SLAVES];
186
187
188/* mapping the module id to slave id and base address */
189struct twl4030mapping {
190 unsigned char sid; /* Slave ID */
191 unsigned char base; /* base address */
192};
193
194static struct twl4030mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
195 /*
196 * NOTE: don't change this table without updating the
197 * <linux/i2c/twl4030.h> defines for TWL4030_MODULE_*
198 * so they continue to match the order in this table.
199 */
200
201 { 0, TWL4030_BASEADD_USB },
202
203 { 1, TWL4030_BASEADD_AUDIO_VOICE },
204 { 1, TWL4030_BASEADD_GPIO },
205 { 1, TWL4030_BASEADD_INTBR },
206 { 1, TWL4030_BASEADD_PIH },
207 { 1, TWL4030_BASEADD_TEST },
208
209 { 2, TWL4030_BASEADD_KEYPAD },
210 { 2, TWL4030_BASEADD_MADC },
211 { 2, TWL4030_BASEADD_INTERRUPTS },
212 { 2, TWL4030_BASEADD_LED },
213 { 2, TWL4030_BASEADD_MAIN_CHARGE },
214 { 2, TWL4030_BASEADD_PRECHARGE },
215 { 2, TWL4030_BASEADD_PWM0 },
216 { 2, TWL4030_BASEADD_PWM1 },
217 { 2, TWL4030_BASEADD_PWMA },
218 { 2, TWL4030_BASEADD_PWMB },
219
220 { 3, TWL4030_BASEADD_BACKUP },
221 { 3, TWL4030_BASEADD_INT },
222 { 3, TWL4030_BASEADD_PM_MASTER },
223 { 3, TWL4030_BASEADD_PM_RECEIVER },
224 { 3, TWL4030_BASEADD_RTC },
225 { 3, TWL4030_BASEADD_SECURED_REG },
226};
227
228/*----------------------------------------------------------------------*/
229
a603a7fa
DB		 230/* Exported Functions */
231
232/**
233 * twl4030_i2c_write - Writes a n bit register in TWL4030
234 * @mod_no: module number
235 * @value: an array of num_bytes+1 containing data to write
236 * @reg: register address (just offset will do)
237 * @num_bytes: number of bytes to transfer
238 *
239 * IMPORTANT: for 'value' parameter: Allocate value num_bytes+1 and
240 * valid data starts at Offset 1.
241 *
242 * Returns the result of operation - 0 is success
243 */
3fba19ec 244int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
a603a7fa
DB		 245{
246 int ret;
247 int sid;
248 struct twl4030_client *twl;
249 struct i2c_msg *msg;
250
251 if (unlikely(mod_no > TWL4030_MODULE_LAST)) {
252 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
253 return -EPERM;
254 }
255 sid = twl4030_map[mod_no].sid;
256 twl = &twl4030_modules[sid];
257
258 if (unlikely(!inuse)) {
259 pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
260 return -EPERM;
261 }
262 mutex_lock(&twl->xfer_lock);
263 /*
264 * [MSG1]: fill the register address data
265 * fill the data Tx buffer
266 */
267 msg = &twl->xfer_msg[0];
268 msg->addr = twl->address;
269 msg->len = num_bytes + 1;
270 msg->flags = 0;
271 msg->buf = value;
272 /* over write the first byte of buffer with the register address */
273 *value = twl4030_map[mod_no].base + reg;
274 ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 1);
275 mutex_unlock(&twl->xfer_lock);
276
277 /* i2cTransfer returns num messages.translate it pls.. */
278 if (ret >= 0)
279 ret = 0;
280 return ret;
281}
282EXPORT_SYMBOL(twl4030_i2c_write);
283
284/**
285 * twl4030_i2c_read - Reads a n bit register in TWL4030
286 * @mod_no: module number
287 * @value: an array of num_bytes containing data to be read
288 * @reg: register address (just offset will do)
289 * @num_bytes: number of bytes to transfer
290 *
291 * Returns result of operation - num_bytes is success else failure.
292 */
3fba19ec 293int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
a603a7fa
DB		 294{
295 int ret;
296 u8 val;
297 int sid;
298 struct twl4030_client *twl;
299 struct i2c_msg *msg;
300
301 if (unlikely(mod_no > TWL4030_MODULE_LAST)) {
302 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
303 return -EPERM;
304 }
305 sid = twl4030_map[mod_no].sid;
306 twl = &twl4030_modules[sid];
307
308 if (unlikely(!inuse)) {
309 pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
310 return -EPERM;
311 }
312 mutex_lock(&twl->xfer_lock);
313 /* [MSG1] fill the register address data */
314 msg = &twl->xfer_msg[0];
315 msg->addr = twl->address;
316 msg->len = 1;
317 msg->flags = 0; /* Read the register value */
318 val = twl4030_map[mod_no].base + reg;
319 msg->buf = &val;
320 /* [MSG2] fill the data rx buffer */
321 msg = &twl->xfer_msg[1];
322 msg->addr = twl->address;
323 msg->flags = I2C_M_RD; /* Read the register value */
324 msg->len = num_bytes; /* only n bytes */
325 msg->buf = value;
326 ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 2);
327 mutex_unlock(&twl->xfer_lock);
328
329 /* i2cTransfer returns num messages.translate it pls.. */
330 if (ret >= 0)
331 ret = 0;
332 return ret;
333}
334EXPORT_SYMBOL(twl4030_i2c_read);
335
336/**
337 * twl4030_i2c_write_u8 - Writes a 8 bit register in TWL4030
338 * @mod_no: module number
339 * @value: the value to be written 8 bit
340 * @reg: register address (just offset will do)
341 *
342 * Returns result of operation - 0 is success
343 */
344int twl4030_i2c_write_u8(u8 mod_no, u8 value, u8 reg)
345{
346
347 /* 2 bytes offset 1 contains the data offset 0 is used by i2c_write */
348 u8 temp_buffer[2] = { 0 };
349 /* offset 1 contains the data */
350 temp_buffer[1] = value;
351 return twl4030_i2c_write(mod_no, temp_buffer, reg, 1);
352}
353EXPORT_SYMBOL(twl4030_i2c_write_u8);
354
355/**
356 * twl4030_i2c_read_u8 - Reads a 8 bit register from TWL4030
357 * @mod_no: module number
358 * @value: the value read 8 bit
359 * @reg: register address (just offset will do)
360 *
361 * Returns result of operation - 0 is success
362 */
363int twl4030_i2c_read_u8(u8 mod_no, u8 *value, u8 reg)
364{
365 return twl4030_i2c_read(mod_no, value, reg, 1);
366}
367EXPORT_SYMBOL(twl4030_i2c_read_u8);
368
369/*----------------------------------------------------------------------*/
370
dad759ff
DB		 371static struct device *
372add_numbered_child(unsigned chip, const char *name, int num,
5725d66b
DB		 373 void *pdata, unsigned pdata_len,
374 bool can_wakeup, int irq0, int irq1)
a603a7fa 375{
5725d66b
DB		 376 struct platform_device *pdev;
377 struct twl4030_client *twl = &twl4030_modules[chip];
378 int status;
379
dad759ff 380 pdev = platform_device_alloc(name, num);
5725d66b
DB		 381 if (!pdev) {
382 dev_dbg(&twl->client->dev, "can't alloc dev\n");
383 status = -ENOMEM;
384 goto err;
385 }
a603a7fa 386
5725d66b
DB		 387 device_init_wakeup(&pdev->dev, can_wakeup);
388 pdev->dev.parent = &twl->client->dev;
a603a7fa 389
5725d66b
DB		 390 if (pdata) {
391 status = platform_device_add_data(pdev, pdata, pdata_len);
392 if (status < 0) {
393 dev_dbg(&pdev->dev, "can't add platform_data\n");
a603a7fa
DB		 394 goto err;
395 }
5725d66b 396 }
a603a7fa 397
5725d66b
DB		 398 if (irq0) {
399 struct resource r[2] = {
400 { .start = irq0, .flags = IORESOURCE_IRQ, },
401 { .start = irq1, .flags = IORESOURCE_IRQ, },
402 };
a603a7fa 403
5725d66b 404 status = platform_device_add_resources(pdev, r, irq1 ? 2 : 1);
a603a7fa 405 if (status < 0) {
5725d66b 406 dev_dbg(&pdev->dev, "can't add irqs\n");
a603a7fa
DB		 407 goto err;
408 }
409 }
410
5725d66b 411 status = platform_device_add(pdev);
a603a7fa 412
5725d66b
DB		 413err:
414 if (status < 0) {
415 platform_device_put(pdev);
416 dev_err(&twl->client->dev, "can't add %s dev\n", name);
417 return ERR_PTR(status);
418 }
419 return &pdev->dev;
420}
a603a7fa 421
dad759ff
DB		 422static inline struct device *add_child(unsigned chip, const char *name,
423 void *pdata, unsigned pdata_len,
424 bool can_wakeup, int irq0, int irq1)
425{
426 return add_numbered_child(chip, name, -1, pdata, pdata_len,
427 can_wakeup, irq0, irq1);
428}
429
430static struct device *
431add_regulator_linked(int num, struct regulator_init_data *pdata,
432 struct regulator_consumer_supply *consumers,
433 unsigned num_consumers)
434{
435 /* regulator framework demands init_data ... */
436 if (!pdata)
437 return NULL;
438
b73eac78 439 if (consumers) {
dad759ff
DB		 440 pdata->consumer_supplies = consumers;
441 pdata->num_consumer_supplies = num_consumers;
442 }
443
444 /* NOTE: we currently ignore regulator IRQs, e.g. for short circuits */
445 return add_numbered_child(3, "twl4030_reg", num,
446 pdata, sizeof(*pdata), false, 0, 0);
447}
448
449static struct device *
450add_regulator(int num, struct regulator_init_data *pdata)
451{
452 return add_regulator_linked(num, pdata, NULL, 0);
453}
454
5725d66b
DB		 455/*
456 * NOTE: We know the first 8 IRQs after pdata->base_irq are
457 * for the PIH, and the next are for the PWR_INT SIH, since
458 * that's how twl_init_irq() sets things up.
459 */
a603a7fa 460
dad759ff
DB		 461static int
462add_children(struct twl4030_platform_data *pdata, unsigned long features)
5725d66b
DB		 463{
464 struct device *child;
dad759ff 465 struct device *usb_transceiver = NULL;
a603a7fa 466
dad759ff 467 if (twl_has_bci() && pdata->bci && !(features & TPS_SUBSET)) {
5725d66b
DB		 468 child = add_child(3, "twl4030_bci",
469 pdata->bci, sizeof(*pdata->bci),
470 false,
471 /* irq0 = CHG_PRES, irq1 = BCI */
472 pdata->irq_base + 8 + 1, pdata->irq_base + 2);
473 if (IS_ERR(child))
474 return PTR_ERR(child);
475 }
a603a7fa 476
5725d66b
DB		 477 if (twl_has_gpio() && pdata->gpio) {
478 child = add_child(1, "twl4030_gpio",
479 pdata->gpio, sizeof(*pdata->gpio),
480 false, pdata->irq_base + 0, 0);
481 if (IS_ERR(child))
482 return PTR_ERR(child);
a603a7fa
DB		 483 }
484
485 if (twl_has_keypad() && pdata->keypad) {
5725d66b
DB		 486 child = add_child(2, "twl4030_keypad",
487 pdata->keypad, sizeof(*pdata->keypad),
488 true, pdata->irq_base + 1, 0);
489 if (IS_ERR(child))
490 return PTR_ERR(child);
a603a7fa
DB		 491 }
492
493 if (twl_has_madc() && pdata->madc) {
5725d66b
DB		 494 child = add_child(2, "twl4030_madc",
495 pdata->madc, sizeof(*pdata->madc),
496 true, pdata->irq_base + 3, 0);
497 if (IS_ERR(child))
498 return PTR_ERR(child);
a603a7fa
DB		 499 }
500
501 if (twl_has_rtc()) {
a603a7fa 502 /*
5725d66b 503 * REVISIT platform_data here currently might expose the
a603a7fa 504 * "msecure" line ... but for now we just expect board
5725d66b 505 * setup to tell the chip "it's always ok to SET_TIME".
a603a7fa
DB		 506 * Eventually, Linux might become more aware of such
507 * HW security concerns, and "least privilege".
508 */
5725d66b
DB		 509 child = add_child(3, "twl4030_rtc",
510 NULL, 0,
511 true, pdata->irq_base + 8 + 3, 0);
512 if (IS_ERR(child))
513 return PTR_ERR(child);
a603a7fa
DB		 514 }
515
516 if (twl_has_usb() && pdata->usb) {
5725d66b
DB		 517 child = add_child(0, "twl4030_usb",
518 pdata->usb, sizeof(*pdata->usb),
519 true,
520 /* irq0 = USB_PRES, irq1 = USB */
521 pdata->irq_base + 8 + 2, pdata->irq_base + 4);
522 if (IS_ERR(child))
523 return PTR_ERR(child);
dad759ff
DB		 524
525 /* we need to connect regulators to this transceiver */
526 usb_transceiver = child;
527 }
528
529 if (twl_has_regulator()) {
530 /*
531 child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1);
532 if (IS_ERR(child))
533 return PTR_ERR(child);
534 */
535
536 child = add_regulator(TWL4030_REG_VMMC1, pdata->vmmc1);
537 if (IS_ERR(child))
538 return PTR_ERR(child);
539
540 child = add_regulator(TWL4030_REG_VDAC, pdata->vdac);
541 if (IS_ERR(child))
542 return PTR_ERR(child);
543
544 child = add_regulator((features & TWL4030_VAUX2)
545 ? TWL4030_REG_VAUX2_4030
546 : TWL4030_REG_VAUX2,
547 pdata->vaux2);
548 if (IS_ERR(child))
549 return PTR_ERR(child);
550 }
551
552 if (twl_has_regulator() && usb_transceiver) {
553 static struct regulator_consumer_supply usb1v5 = {
554 .supply = "usb1v5",
555 };
556 static struct regulator_consumer_supply usb1v8 = {
557 .supply = "usb1v8",
558 };
559 static struct regulator_consumer_supply usb3v1 = {
560 .supply = "usb3v1",
561 };
dad759ff
DB		 562
563 /* this is a template that gets copied */
564 struct regulator_init_data usb_fixed = {
565 .constraints.valid_modes_mask =
566 REGULATOR_MODE_NORMAL
567 | REGULATOR_MODE_STANDBY,
568 .constraints.valid_ops_mask =
569 REGULATOR_CHANGE_MODE
570 | REGULATOR_CHANGE_STATUS,
571 };
572
573 usb1v5.dev = usb_transceiver;
574 usb1v8.dev = usb_transceiver;
575 usb3v1.dev = usb_transceiver;
dad759ff
DB		 576
577 child = add_regulator_linked(TWL4030_REG_VUSB1V5, &usb_fixed,
578 &usb1v5, 1);
579 if (IS_ERR(child))
580 return PTR_ERR(child);
581
582 child = add_regulator_linked(TWL4030_REG_VUSB1V8, &usb_fixed,
583 &usb1v8, 1);
584 if (IS_ERR(child))
585 return PTR_ERR(child);
586
587 child = add_regulator_linked(TWL4030_REG_VUSB3V1, &usb_fixed,
588 &usb3v1, 1);
589 if (IS_ERR(child))
590 return PTR_ERR(child);
dad759ff
DB		 591 }
592
593 /* maybe add LDOs that are omitted on cost-reduced parts */
594 if (twl_has_regulator() && !(features & TPS_SUBSET)) {
595 /*
596 child = add_regulator(TWL4030_REG_VPLL2, pdata->vpll2);
597 if (IS_ERR(child))
598 return PTR_ERR(child);
599 */
600
601 child = add_regulator(TWL4030_REG_VMMC2, pdata->vmmc2);
602 if (IS_ERR(child))
603 return PTR_ERR(child);
604
605 child = add_regulator(TWL4030_REG_VSIM, pdata->vsim);
606 if (IS_ERR(child))
607 return PTR_ERR(child);
608
609 child = add_regulator(TWL4030_REG_VAUX1, pdata->vaux1);
610 if (IS_ERR(child))
611 return PTR_ERR(child);
612
613 child = add_regulator(TWL4030_REG_VAUX3, pdata->vaux3);
614 if (IS_ERR(child))
615 return PTR_ERR(child);
616
617 child = add_regulator(TWL4030_REG_VAUX4, pdata->vaux4);
618 if (IS_ERR(child))
619 return PTR_ERR(child);
a603a7fa
DB		 620 }
621
5725d66b 622 return 0;
a603a7fa
DB		 623}
624
625/*----------------------------------------------------------------------*/
626
627/*
628 * These three functions initialize the on-chip clock framework,
629 * letting it generate the right frequencies for USB, MADC, and
630 * other purposes.
631 */
632static inline int __init protect_pm_master(void)
633{
634 int e = 0;
635
636 e = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_LOCK,
637 R_PROTECT_KEY);
638 return e;
639}
640
641static inline int __init unprotect_pm_master(void)
642{
643 int e = 0;
644
645 e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK1,
646 R_PROTECT_KEY);
647 e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK2,
648 R_PROTECT_KEY);
649 return e;
650}
651
652static void __init clocks_init(void)
653{
654 int e = 0;
655 struct clk *osc;
656 u32 rate;
657 u8 ctrl = HFCLK_FREQ_26_MHZ;
658
659#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
660 if (cpu_is_omap2430())
661 osc = clk_get(NULL, "osc_ck");
662 else
663 osc = clk_get(NULL, "osc_sys_ck");
6354ab5c 664
a603a7fa
DB		 665 if (IS_ERR(osc)) {
666 printk(KERN_WARNING "Skipping twl4030 internal clock init and "
667 "using bootloader value (unknown osc rate)\n");
668 return;
669 }
670
671 rate = clk_get_rate(osc);
672 clk_put(osc);
673
6354ab5c
SO		 674#else
675 /* REVISIT for non-OMAP systems, pass the clock rate from
676 * board init code, using platform_data.
677 */
678 osc = ERR_PTR(-EIO);
679
680 printk(KERN_WARNING "Skipping twl4030 internal clock init and "
681 "using bootloader value (unknown osc rate)\n");
682
683 return;
684#endif
685
a603a7fa
DB		 686 switch (rate) {
687 case 19200000:
688 ctrl = HFCLK_FREQ_19p2_MHZ;
689 break;
690 case 26000000:
691 ctrl = HFCLK_FREQ_26_MHZ;
692 break;
693 case 38400000:
694 ctrl = HFCLK_FREQ_38p4_MHZ;
695 break;
696 }
697
698 ctrl |= HIGH_PERF_SQ;
699 e |= unprotect_pm_master();
700 /* effect->MADC+USB ck en */
701 e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, ctrl, R_CFG_BOOT);
702 e |= protect_pm_master();
703
704 if (e < 0)
705 pr_err("%s: clock init err [%d]\n", DRIVER_NAME, e);
706}
707
708/*----------------------------------------------------------------------*/
709
a30d46c0
DB		 710int twl_init_irq(int irq_num, unsigned irq_base, unsigned irq_end);
711int twl_exit_irq(void);
a603a7fa
DB		 712
713static int twl4030_remove(struct i2c_client *client)
714{
715 unsigned i;
a30d46c0 716 int status;
a603a7fa 717
a30d46c0
DB		 718 status = twl_exit_irq();
719 if (status < 0)
720 return status;
a603a7fa
DB		 721
722 for (i = 0; i < TWL4030_NUM_SLAVES; i++) {
723 struct twl4030_client *twl = &twl4030_modules[i];
724
725 if (twl->client && twl->client != client)
726 i2c_unregister_device(twl->client);
727 twl4030_modules[i].client = NULL;
728 }
729 inuse = false;
730 return 0;
731}
732
733/* NOTE: this driver only handles a single twl4030/tps659x0 chip */
734static int
735twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
736{
737 int status;
738 unsigned i;
739 struct twl4030_platform_data *pdata = client->dev.platform_data;
740
741 if (!pdata) {
742 dev_dbg(&client->dev, "no platform data?\n");
743 return -EINVAL;
744 }
745
746 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
747 dev_dbg(&client->dev, "can't talk I2C?\n");
748 return -EIO;
749 }
750
a30d46c0 751 if (inuse) {
a603a7fa
DB		 752 dev_dbg(&client->dev, "driver is already in use\n");
753 return -EBUSY;
754 }
755
756 for (i = 0; i < TWL4030_NUM_SLAVES; i++) {
757 struct twl4030_client *twl = &twl4030_modules[i];
758
759 twl->address = client->addr + i;
760 if (i == 0)
761 twl->client = client;
762 else {
763 twl->client = i2c_new_dummy(client->adapter,
764 twl->address);
765 if (!twl->client) {
766 dev_err(&twl->client->dev,
767 "can't attach client %d\n", i);
768 status = -ENOMEM;
769 goto fail;
770 }
771 strlcpy(twl->client->name, id->name,
772 sizeof(twl->client->name));
773 }
774 mutex_init(&twl->xfer_lock);
775 }
776 inuse = true;
777
778 /* setup clock framework */
779 clocks_init();
780
781 /* Maybe init the T2 Interrupt subsystem */
782 if (client->irq
783 && pdata->irq_base
784 && pdata->irq_end > pdata->irq_base) {
a30d46c0
DB		 785 status = twl_init_irq(client->irq, pdata->irq_base, pdata->irq_end);
786 if (status < 0)
787 goto fail;
a603a7fa
DB		 788 }
789
dad759ff 790 status = add_children(pdata, id->driver_data);
a603a7fa
DB		 791fail:
792 if (status < 0)
793 twl4030_remove(client);
794 return status;
795}
796
797static const struct i2c_device_id twl4030_ids[] = {
dad759ff
DB		 798 { "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */
799 { "twl5030", 0 }, /* T2 updated */
800 { "tps65950", 0 }, /* catalog version of twl5030 */
801 { "tps65930", TPS_SUBSET }, /* fewer LDOs and DACs; no charger */
802 { "tps65920", TPS_SUBSET }, /* fewer LDOs; no codec or charger */
a603a7fa
DB		 803 { /* end of list */ },
804};
805MODULE_DEVICE_TABLE(i2c, twl4030_ids);
806
807/* One Client Driver , 4 Clients */
808static struct i2c_driver twl4030_driver = {
809 .driver.name = DRIVER_NAME,
810 .id_table = twl4030_ids,
811 .probe = twl4030_probe,
812 .remove = twl4030_remove,
813};
814
815static int __init twl4030_init(void)
816{
817 return i2c_add_driver(&twl4030_driver);
818}
819subsys_initcall(twl4030_init);
820
821static void __exit twl4030_exit(void)
822{
823 i2c_del_driver(&twl4030_driver);
824}
825module_exit(twl4030_exit);
826
827MODULE_AUTHOR("Texas Instruments, Inc.");
828MODULE_DESCRIPTION("I2C Core interface for TWL4030");
829MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.121188 seconds and 5 git commands to generate.