← Back to branch summary

~ubuntu-branches/debian/wheezy/linux-2.6/wheezy

« back to all changes in this revision

Viewing changes to drivers/regulator/tps6105x-regulator.c

  • Committer: Bazaar Package Importer
  • Author(s): Ben Hutchings, Ben Hutchings, Aurelien Jarno
  • Date: 2011-06-07 12:14:05 UTC
  • mfrom: (43.1.9 sid)
  • Revision ID: james.westby@ubuntu.com-20110607121405-i3h1rd7nrnd2b73h
Tags: 2.6.39-2
http://bugs.debian.org/627492
http://bugs.debian.org/596626
http://bugs.debian.org/628932
http://bugs.debian.org/628191
http://bugs.debian.org/627837
http://bugs.debian.org/622997
http://bugs.debian.org/622745
http://bugs.debian.org/619827
http://bugs.debian.org/629401
[ Ben Hutchings ]
* [x86] Enable BACKLIGHT_APPLE, replacing BACKLIGHT_MBP_NVIDIA
  (Closes: #627492)
* cgroups: Disable memory resource controller by default. Allow it
  to be enabled using kernel parameter 'cgroup_enable=memory'.
* rt2800usb: Enable support for more USB devices including
  Linksys WUSB600N (Closes: #596626) (this change was accidentally
  omitted from 2.6.39-1)
* [x86] Remove Celeron from list of processors supporting PAE. Most
  'Celeron M' models do not.
* Update debconf template translations:
  - Swedish (Martin Bagge) (Closes: #628932)
  - French (David Prévot) (Closes: #628191)
* aufs: Update for 2.6.39 (Closes: #627837)
* Add stable 2.6.39.1, including:
  - ext4: dont set PageUptodate in ext4_end_bio()
  - pata_cmd64x: fix boot crash on parisc (Closes: #622997, #622745)
  - ext3: Fix fs corruption when make_indexed_dir() fails
  - netfilter: nf_ct_sip: validate Content-Length in TCP SIP messages
  - sctp: fix race between sctp_bind_addr_free() and
    sctp_bind_addr_conflict()
  - sctp: fix memory leak of the ASCONF queue when free asoc
  - md/bitmap: fix saving of events_cleared and other state
  - cdc_acm: Fix oops when Droids MuIn LCD is connected
  - cx88: Fix conversion from BKL to fine-grained locks (Closes: #619827)
  - keys: Set cred->user_ns in key_replace_session_keyring (CVE-2011-2184)
  - tmpfs: fix race between truncate and writepage
  - nfs41: Correct offset for LAYOUTCOMMIT
  - xen/mmu: fix a race window causing leave_mm BUG()
  - ext4: fix possible use-after-free in ext4_remove_li_request()
  For the complete list of changes, see:
   http://www.kernel.org/pub/linux/kernel/v2.6/ChangeLog-2.6.39.1
* Bump ABI to 2
* netfilter: Enable IP_SET, IP_SET_BITMAP_IP, IP_SET_BITMAP_IPMAC,
  IP_SET_BITMAP_PORT, IP_SET_HASH_IP, IP_SET_HASH_IPPORT,
  IP_SET_HASH_IPPORTIP, IP_SET_HASH_IPPORTNET, IP_SET_HASH_NET,
  IP_SET_HASH_NETPORT, IP_SET_LIST_SET, NETFILTER_XT_SET as modules
  (Closes: #629401)

[ Aurelien Jarno ]
* [mipsel/loongson-2f] Disable_SCSI_LPFC to workaround GCC ICE.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/regulator/tps6105x-regulator.c
 
1
/*
 
2
 * Driver for TPS61050/61052 boost converters, typically used for white LEDs
 
3
 * or audio amplifiers.
 
4
 *
 
5
 * Copyright (C) 2011 ST-Ericsson SA
 
6
 * Written on behalf of Linaro for ST-Ericsson
 
7
 *
 
8
 * Author: Linus Walleij <linus.walleij@linaro.org>
 
9
 *
 
10
 * License terms: GNU General Public License (GPL) version 2
 
11
 */
 
12
 
 
13
#include <linux/module.h>
 
14
#include <linux/kernel.h>
 
15
#include <linux/init.h>
 
16
#include <linux/err.h>
 
17
#include <linux/i2c.h>
 
18
#include <linux/platform_device.h>
 
19
#include <linux/regulator/driver.h>
 
20
#include <linux/mfd/core.h>
 
21
#include <linux/mfd/tps6105x.h>
 
22
 
 
23
static const int tps6105x_voltages[] = {
 
24
        4500000,
 
25
        5000000,
 
26
        5250000,
 
27
        5000000, /* There is an additional 5V */
 
28
};
 
29
 
 
30
static int tps6105x_regulator_enable(struct regulator_dev *rdev)
 
31
{
 
32
        struct tps6105x *tps6105x = rdev_get_drvdata(rdev);
 
33
        int ret;
 
34
 
 
35
        /* Activate voltage mode */
 
36
        ret = tps6105x_mask_and_set(tps6105x, TPS6105X_REG_0,
 
37
                TPS6105X_REG0_MODE_MASK,
 
38
                TPS6105X_REG0_MODE_VOLTAGE << TPS6105X_REG0_MODE_SHIFT);
 
39
        if (ret)
 
40
                return ret;
 
41
 
 
42
        return 0;
 
43
}
 
44
 
 
45
static int tps6105x_regulator_disable(struct regulator_dev *rdev)
 
46
{
 
47
        struct tps6105x *tps6105x = rdev_get_drvdata(rdev);
 
48
        int ret;
 
49
 
 
50
        /* Set into shutdown mode */
 
51
        ret = tps6105x_mask_and_set(tps6105x, TPS6105X_REG_0,
 
52
                TPS6105X_REG0_MODE_MASK,
 
53
                TPS6105X_REG0_MODE_SHUTDOWN << TPS6105X_REG0_MODE_SHIFT);
 
54
        if (ret)
 
55
                return ret;
 
56
 
 
57
        return 0;
 
58
}
 
59
 
 
60
static int tps6105x_regulator_is_enabled(struct regulator_dev *rdev)
 
61
{
 
62
        struct tps6105x *tps6105x = rdev_get_drvdata(rdev);
 
63
        u8 regval;
 
64
        int ret;
 
65
 
 
66
        ret = tps6105x_get(tps6105x, TPS6105X_REG_0, &regval);
 
67
        if (ret)
 
68
                return ret;
 
69
        regval &= TPS6105X_REG0_MODE_MASK;
 
70
        regval >>= TPS6105X_REG0_MODE_SHIFT;
 
71
 
 
72
        if (regval == TPS6105X_REG0_MODE_VOLTAGE)
 
73
                return 1;
 
74
 
 
75
        return 0;
 
76
}
 
77
 
 
78
static int tps6105x_regulator_get_voltage_sel(struct regulator_dev *rdev)
 
79
{
 
80
        struct tps6105x *tps6105x = rdev_get_drvdata(rdev);
 
81
        u8 regval;
 
82
        int ret;
 
83
 
 
84
        ret = tps6105x_get(tps6105x, TPS6105X_REG_0, &regval);
 
85
        if (ret)
 
86
                return ret;
 
87
 
 
88
        regval &= TPS6105X_REG0_VOLTAGE_MASK;
 
89
        regval >>= TPS6105X_REG0_VOLTAGE_SHIFT;
 
90
        return (int) regval;
 
91
}
 
92
 
 
93
static int tps6105x_regulator_set_voltage_sel(struct regulator_dev *rdev,
 
94
                                              unsigned selector)
 
95
{
 
96
        struct tps6105x *tps6105x = rdev_get_drvdata(rdev);
 
97
        int ret;
 
98
 
 
99
        ret = tps6105x_mask_and_set(tps6105x, TPS6105X_REG_0,
 
100
                                    TPS6105X_REG0_VOLTAGE_MASK,
 
101
                                    selector << TPS6105X_REG0_VOLTAGE_SHIFT);
 
102
        if (ret)
 
103
                return ret;
 
104
 
 
105
        return 0;
 
106
}
 
107
 
 
108
static int tps6105x_regulator_list_voltage(struct regulator_dev *rdev,
 
109
                                           unsigned selector)
 
110
{
 
111
        if (selector >= ARRAY_SIZE(tps6105x_voltages))
 
112
                return -EINVAL;
 
113
 
 
114
        return tps6105x_voltages[selector];
 
115
}
 
116
 
 
117
static struct regulator_ops tps6105x_regulator_ops = {
 
118
        .enable         = tps6105x_regulator_enable,
 
119
        .disable        = tps6105x_regulator_disable,
 
120
        .is_enabled     = tps6105x_regulator_is_enabled,
 
121
        .get_voltage_sel = tps6105x_regulator_get_voltage_sel,
 
122
        .set_voltage_sel = tps6105x_regulator_set_voltage_sel,
 
123
        .list_voltage   = tps6105x_regulator_list_voltage,
 
124
};
 
125
 
 
126
static struct regulator_desc tps6105x_regulator_desc = {
 
127
        .name           = "tps6105x-boost",
 
128
        .ops            = &tps6105x_regulator_ops,
 
129
        .type           = REGULATOR_VOLTAGE,
 
130
        .id             = 0,
 
131
        .owner          = THIS_MODULE,
 
132
        .n_voltages     = ARRAY_SIZE(tps6105x_voltages),
 
133
};
 
134
 
 
135
/*
 
136
 * Registers the chip as a voltage regulator
 
137
 */
 
138
static int __devinit tps6105x_regulator_probe(struct platform_device *pdev)
 
139
{
 
140
        struct tps6105x *tps6105x = mfd_get_data(pdev);
 
141
        struct tps6105x_platform_data *pdata = tps6105x->pdata;
 
142
        int ret;
 
143
 
 
144
        /* This instance is not set for regulator mode so bail out */
 
145
        if (pdata->mode != TPS6105X_MODE_VOLTAGE) {
 
146
                dev_info(&pdev->dev,
 
147
                         "chip not in voltage mode mode, exit probe \n");
 
148
                return 0;
 
149
        }
 
150
 
 
151
        /* Register regulator with framework */
 
152
        tps6105x->regulator = regulator_register(&tps6105x_regulator_desc,
 
153
                                             &tps6105x->client->dev,
 
154
                                             pdata->regulator_data, tps6105x);
 
155
        if (IS_ERR(tps6105x->regulator)) {
 
156
                ret = PTR_ERR(tps6105x->regulator);
 
157
                dev_err(&tps6105x->client->dev,
 
158
                        "failed to register regulator\n");
 
159
                return ret;
 
160
        }
 
161
 
 
162
        return 0;
 
163
}
 
164
 
 
165
static int __devexit tps6105x_regulator_remove(struct platform_device *pdev)
 
166
{
 
167
        struct tps6105x *tps6105x = platform_get_drvdata(pdev);
 
168
        regulator_unregister(tps6105x->regulator);
 
169
        return 0;
 
170
}
 
171
 
 
172
static struct platform_driver tps6105x_regulator_driver = {
 
173
        .driver = {
 
174
                .name  = "tps6105x-regulator",
 
175
                .owner = THIS_MODULE,
 
176
        },
 
177
        .probe = tps6105x_regulator_probe,
 
178
        .remove = __devexit_p(tps6105x_regulator_remove),
 
179
};
 
180
 
 
181
static __init int tps6105x_regulator_init(void)
 
182
{
 
183
        return platform_driver_register(&tps6105x_regulator_driver);
 
184
}
 
185
subsys_initcall(tps6105x_regulator_init);
 
186
 
 
187
static __exit void tps6105x_regulator_exit(void)
 
188
{
 
189
        platform_driver_unregister(&tps6105x_regulator_driver);
 
190
}
 
191
module_exit(tps6105x_regulator_exit);
 
192
 
 
193
MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
 
194
MODULE_DESCRIPTION("TPS6105x regulator driver");
 
195
MODULE_LICENSE("GPL v2");
 
196
MODULE_ALIAS("platform:tps6105x-regulator");