xref: /linux/drivers/mfd/mc13xxx-spi.c (revision 8407884dd9164ec18ed2afc00f56b87e36c51fcf)
1 /*
2  * Copyright 2009-2010 Pengutronix
3  * Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>
4  *
5  * loosely based on an earlier driver that has
6  * Copyright 2009 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>
7  *
8  * This program is free software; you can redistribute it and/or modify it under
9  * the terms of the GNU General Public License version 2 as published by the
10  * Free Software Foundation.
11  */
12 
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
16 #include <linux/mutex.h>
17 #include <linux/interrupt.h>
18 #include <linux/mfd/core.h>
19 #include <linux/mfd/mc13xxx.h>
20 #include <linux/of.h>
21 #include <linux/of_device.h>
22 #include <linux/of_gpio.h>
23 #include <linux/err.h>
24 #include <linux/spi/spi.h>
25 
26 #include "mc13xxx.h"
27 
28 static const struct spi_device_id mc13xxx_device_id[] = {
29 	{
30 		.name = "mc13783",
31 		.driver_data = MC13XXX_ID_MC13783,
32 	}, {
33 		.name = "mc13892",
34 		.driver_data = MC13XXX_ID_MC13892,
35 	}, {
36 		/* sentinel */
37 	}
38 };
39 MODULE_DEVICE_TABLE(spi, mc13xxx_device_id);
40 
41 static const struct of_device_id mc13xxx_dt_ids[] = {
42 	{ .compatible = "fsl,mc13783", .data = (void *) MC13XXX_ID_MC13783, },
43 	{ .compatible = "fsl,mc13892", .data = (void *) MC13XXX_ID_MC13892, },
44 	{ /* sentinel */ }
45 };
46 MODULE_DEVICE_TABLE(of, mc13xxx_dt_ids);
47 
48 static struct regmap_config mc13xxx_regmap_spi_config = {
49 	.reg_bits = 7,
50 	.pad_bits = 1,
51 	.val_bits = 24,
52 	.write_flag_mask = 0x80,
53 
54 	.max_register = MC13XXX_NUMREGS,
55 
56 	.cache_type = REGCACHE_NONE,
57 	.use_single_rw = 1,
58 };
59 
60 static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size,
61 				void *val, size_t val_size)
62 {
63 	unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0};
64 	unsigned char r[4];
65 	unsigned char *p = val;
66 	struct device *dev = context;
67 	struct spi_device *spi = to_spi_device(dev);
68 	struct spi_transfer t = {
69 		.tx_buf = w,
70 		.rx_buf = r,
71 		.len = 4,
72 	};
73 
74 	struct spi_message m;
75 	int ret;
76 
77 	if (val_size != 3 || reg_size != 1)
78 		return -ENOTSUPP;
79 
80 	spi_message_init(&m);
81 	spi_message_add_tail(&t, &m);
82 	ret = spi_sync(spi, &m);
83 
84 	memcpy(p, &r[1], 3);
85 
86 	return ret;
87 }
88 
89 static int mc13xxx_spi_write(void *context, const void *data, size_t count)
90 {
91 	struct device *dev = context;
92 	struct spi_device *spi = to_spi_device(dev);
93 
94 	if (count != 4)
95 		return -ENOTSUPP;
96 
97 	return spi_write(spi, data, count);
98 }
99 
100 /*
101  * We cannot use regmap-spi generic bus implementation here.
102  * The MC13783 chip will get corrupted if CS signal is deasserted
103  * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller
104  * has the following errata (DSPhl22960):
105  * "The CSPI negates SS when the FIFO becomes empty with
106  * SSCTL= 0. Software cannot guarantee that the FIFO will not
107  * drain because of higher priority interrupts and the
108  * non-realtime characteristics of the operating system. As a
109  * result, the SS will negate before all of the data has been
110  * transferred to/from the peripheral."
111  * We workaround this by accessing the SPI controller with a
112  * single transfert.
113  */
114 
115 static struct regmap_bus regmap_mc13xxx_bus = {
116 	.write = mc13xxx_spi_write,
117 	.read = mc13xxx_spi_read,
118 };
119 
120 static int mc13xxx_spi_probe(struct spi_device *spi)
121 {
122 	const struct of_device_id *of_id;
123 	struct spi_driver *sdrv = to_spi_driver(spi->dev.driver);
124 	struct mc13xxx *mc13xxx;
125 	struct mc13xxx_platform_data *pdata = dev_get_platdata(&spi->dev);
126 	int ret;
127 
128 	of_id = of_match_device(mc13xxx_dt_ids, &spi->dev);
129 	if (of_id)
130 		sdrv->id_table = &mc13xxx_device_id[(enum mc13xxx_id) of_id->data];
131 
132 	mc13xxx = kzalloc(sizeof(*mc13xxx), GFP_KERNEL);
133 	if (!mc13xxx)
134 		return -ENOMEM;
135 
136 	dev_set_drvdata(&spi->dev, mc13xxx);
137 	spi->mode = SPI_MODE_0 | SPI_CS_HIGH;
138 
139 	mc13xxx->dev = &spi->dev;
140 	mutex_init(&mc13xxx->lock);
141 
142 	mc13xxx->regmap = regmap_init(&spi->dev, &regmap_mc13xxx_bus, &spi->dev,
143 					&mc13xxx_regmap_spi_config);
144 
145 	if (IS_ERR(mc13xxx->regmap)) {
146 		ret = PTR_ERR(mc13xxx->regmap);
147 		dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n",
148 				ret);
149 		dev_set_drvdata(&spi->dev, NULL);
150 		kfree(mc13xxx);
151 		return ret;
152 	}
153 
154 	ret = mc13xxx_common_init(mc13xxx, pdata, spi->irq);
155 
156 	if (ret) {
157 		dev_set_drvdata(&spi->dev, NULL);
158 	} else {
159 		const struct spi_device_id *devid =
160 			spi_get_device_id(spi);
161 		if (!devid || devid->driver_data != mc13xxx->ictype)
162 			dev_warn(mc13xxx->dev,
163 				"device id doesn't match auto detection!\n");
164 	}
165 
166 	return ret;
167 }
168 
169 static int __devexit mc13xxx_spi_remove(struct spi_device *spi)
170 {
171 	struct mc13xxx *mc13xxx = dev_get_drvdata(&spi->dev);
172 
173 	mc13xxx_common_cleanup(mc13xxx);
174 
175 	return 0;
176 }
177 
178 static struct spi_driver mc13xxx_spi_driver = {
179 	.id_table = mc13xxx_device_id,
180 	.driver = {
181 		.name = "mc13xxx",
182 		.owner = THIS_MODULE,
183 		.of_match_table = mc13xxx_dt_ids,
184 	},
185 	.probe = mc13xxx_spi_probe,
186 	.remove = __devexit_p(mc13xxx_spi_remove),
187 };
188 
189 static int __init mc13xxx_init(void)
190 {
191 	return spi_register_driver(&mc13xxx_spi_driver);
192 }
193 subsys_initcall(mc13xxx_init);
194 
195 static void __exit mc13xxx_exit(void)
196 {
197 	spi_unregister_driver(&mc13xxx_spi_driver);
198 }
199 module_exit(mc13xxx_exit);
200 
201 MODULE_DESCRIPTION("Core driver for Freescale MC13XXX PMIC");
202 MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>");
203 MODULE_LICENSE("GPL v2");
204