← Back to branch summary

~ubuntu-branches/ubuntu/saucy/linux-ti-omap4/saucy-proposed

« back to all changes in this revision

Viewing changes to drivers/mfd/ab8500-i2c.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati, Stefan Bader, Upstream Kernel Changes
  • Date: 2012-08-15 17:17:43 UTC
  • Revision ID: package-import@ubuntu.com-20120815171743-h5wnuf51xe7pvdid
Tags: 3.5.0-207.13
[ Paolo Pisati ]

* Start new release

[ Stefan Bader ]

* (config) Enable getabis to use local package copies

[ Upstream Kernel Changes ]

* fixup: gargabe collect iva_seq[0|1] init
* [Config] enable all SND_OMAP_SOC_*s
* fixup: cm2xxx_3xxx.o is needed for omap2_cm_read|write_reg
* fixup: add some snd_soc_dai* helper functions
* fixup: s/snd_soc_dpcm_params/snd_soc_dpcm/g
* fixup: typo, no_host_mode and useless SDP4430 init
* fixup: enable again aess hwmod

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/mfd/ab8500-i2c.c
1
 
/*
2
 
 * Copyright (C) ST-Ericsson SA 2010
3
 
 * Author: Mattias Wallin <mattias.wallin@stericsson.com> for ST-Ericsson.
4
 
 * License Terms: GNU General Public License v2
5
 
 * This file was based on drivers/mfd/ab8500-spi.c
6
 
 */
7
 
 
8
 
#include <linux/kernel.h>
9
 
#include <linux/slab.h>
10
 
#include <linux/init.h>
11
 
#include <linux/module.h>
12
 
#include <linux/platform_device.h>
13
 
#include <linux/mfd/abx500/ab8500.h>
14
 
#include <linux/mfd/dbx500-prcmu.h>
15
 
 
16
 
static int ab8500_i2c_write(struct ab8500 *ab8500, u16 addr, u8 data)
17
 
{
18
 
        int ret;
19
 
 
20
 
        ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
21
 
        if (ret < 0)
22
 
                dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
23
 
        return ret;
24
 
}
25
 
 
26
 
static int ab8500_i2c_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask,
27
 
        u8 data)
28
 
{
29
 
        int ret;
30
 
 
31
 
        ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data,
32
 
                &mask, 1);
33
 
        if (ret < 0)
34
 
                dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
35
 
        return ret;
36
 
}
37
 
 
38
 
static int ab8500_i2c_read(struct ab8500 *ab8500, u16 addr)
39
 
{
40
 
        int ret;
41
 
        u8 data;
42
 
 
43
 
        ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
44
 
        if (ret < 0) {
45
 
                dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
46
 
                return ret;
47
 
        }
48
 
        return (int)data;
49
 
}
50
 
 
51
 
static int __devinit ab8500_i2c_probe(struct platform_device *plf)
52
 
{
53
 
        const struct platform_device_id *platid = platform_get_device_id(plf);
54
 
        struct ab8500 *ab8500;
55
 
        struct resource *resource;
56
 
        int ret;
57
 
 
58
 
        ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
59
 
        if (!ab8500)
60
 
                return -ENOMEM;
61
 
 
62
 
        ab8500->dev = &plf->dev;
63
 
 
64
 
        resource = platform_get_resource(plf, IORESOURCE_IRQ, 0);
65
 
        if (!resource) {
66
 
                kfree(ab8500);
67
 
                return -ENODEV;
68
 
        }
69
 
 
70
 
        ab8500->irq = resource->start;
71
 
 
72
 
        ab8500->read = ab8500_i2c_read;
73
 
        ab8500->write = ab8500_i2c_write;
74
 
        ab8500->write_masked = ab8500_i2c_write_masked;
75
 
 
76
 
        platform_set_drvdata(plf, ab8500);
77
 
 
78
 
        ret = ab8500_init(ab8500, platid->driver_data);
79
 
        if (ret)
80
 
                kfree(ab8500);
81
 
 
82
 
 
83
 
        return ret;
84
 
}
85
 
 
86
 
static int __devexit ab8500_i2c_remove(struct platform_device *plf)
87
 
{
88
 
        struct ab8500 *ab8500 = platform_get_drvdata(plf);
89
 
 
90
 
        ab8500_exit(ab8500);
91
 
        kfree(ab8500);
92
 
 
93
 
        return 0;
94
 
}
95
 
 
96
 
static const struct platform_device_id ab8500_id[] = {
97
 
        { "ab8500-i2c", AB8500_VERSION_AB8500 },
98
 
        { "ab8505-i2c", AB8500_VERSION_AB8505 },
99
 
        { "ab9540-i2c", AB8500_VERSION_AB9540 },
100
 
        { "ab8540-i2c", AB8500_VERSION_AB8540 },
101
 
        { }
102
 
};
103
 
 
104
 
static struct platform_driver ab8500_i2c_driver = {
105
 
        .driver = {
106
 
                .name = "ab8500-i2c",
107
 
                .owner = THIS_MODULE,
108
 
        },
109
 
        .probe  = ab8500_i2c_probe,
110
 
        .remove = __devexit_p(ab8500_i2c_remove),
111
 
        .id_table = ab8500_id,
112
 
};
113
 
 
114
 
static int __init ab8500_i2c_init(void)
115
 
{
116
 
        return platform_driver_register(&ab8500_i2c_driver);
117
 
}
118
 
 
119
 
static void __exit ab8500_i2c_exit(void)
120
 
{
121
 
        platform_driver_unregister(&ab8500_i2c_driver);
122
 
}
123
 
arch_initcall(ab8500_i2c_init);
124
 
module_exit(ab8500_i2c_exit);
125
 
 
126
 
MODULE_AUTHOR("Mattias WALLIN <mattias.wallin@stericsson.com");
127
 
MODULE_DESCRIPTION("AB8500 Core access via PRCMU I2C");
128
 
MODULE_LICENSE("GPL v2");