Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 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", |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 31 | .driver_data = (kernel_ulong_t)&mc13xxx_variant_mc13783, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 32 | }, { |
| 33 | .name = "mc13892", |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 34 | .driver_data = (kernel_ulong_t)&mc13xxx_variant_mc13892, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 35 | }, { |
Uwe Kleine-König | 0312e02 | 2012-07-12 09:57:53 +0000 | [diff] [blame] | 36 | .name = "mc34708", |
| 37 | .driver_data = (kernel_ulong_t)&mc13xxx_variant_mc34708, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 38 | }, { |
| 39 | /* sentinel */ |
| 40 | } |
| 41 | }; |
| 42 | MODULE_DEVICE_TABLE(spi, mc13xxx_device_id); |
| 43 | |
| 44 | static const struct of_device_id mc13xxx_dt_ids[] = { |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 45 | { .compatible = "fsl,mc13783", .data = &mc13xxx_variant_mc13783, }, |
| 46 | { .compatible = "fsl,mc13892", .data = &mc13xxx_variant_mc13892, }, |
Uwe Kleine-König | 0312e02 | 2012-07-12 09:57:53 +0000 | [diff] [blame] | 47 | { .compatible = "fsl,mc34708", .data = &mc13xxx_variant_mc34708, }, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 48 | { /* sentinel */ } |
| 49 | }; |
| 50 | MODULE_DEVICE_TABLE(of, mc13xxx_dt_ids); |
| 51 | |
| 52 | static struct regmap_config mc13xxx_regmap_spi_config = { |
| 53 | .reg_bits = 7, |
| 54 | .pad_bits = 1, |
| 55 | .val_bits = 24, |
Philippe Rétornaz | 77a5b37 | 2012-05-29 11:06:28 +0200 | [diff] [blame] | 56 | .write_flag_mask = 0x80, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 57 | |
| 58 | .max_register = MC13XXX_NUMREGS, |
| 59 | |
| 60 | .cache_type = REGCACHE_NONE, |
Philippe Rétornaz | e4ecf6e | 2012-05-29 11:06:29 +0200 | [diff] [blame] | 61 | .use_single_rw = 1, |
| 62 | }; |
| 63 | |
| 64 | static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size, |
| 65 | void *val, size_t val_size) |
| 66 | { |
| 67 | unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0}; |
| 68 | unsigned char r[4]; |
| 69 | unsigned char *p = val; |
| 70 | struct device *dev = context; |
| 71 | struct spi_device *spi = to_spi_device(dev); |
| 72 | struct spi_transfer t = { |
| 73 | .tx_buf = w, |
| 74 | .rx_buf = r, |
| 75 | .len = 4, |
| 76 | }; |
| 77 | |
| 78 | struct spi_message m; |
| 79 | int ret; |
| 80 | |
| 81 | if (val_size != 3 || reg_size != 1) |
| 82 | return -ENOTSUPP; |
| 83 | |
| 84 | spi_message_init(&m); |
| 85 | spi_message_add_tail(&t, &m); |
| 86 | ret = spi_sync(spi, &m); |
| 87 | |
| 88 | memcpy(p, &r[1], 3); |
| 89 | |
| 90 | return ret; |
| 91 | } |
| 92 | |
| 93 | static int mc13xxx_spi_write(void *context, const void *data, size_t count) |
| 94 | { |
| 95 | struct device *dev = context; |
| 96 | struct spi_device *spi = to_spi_device(dev); |
Mark Brown | 0248b4b | 2013-09-23 19:14:32 +0100 | [diff] [blame^] | 97 | const char *reg = data; |
Philippe Rétornaz | e4ecf6e | 2012-05-29 11:06:29 +0200 | [diff] [blame] | 98 | |
| 99 | if (count != 4) |
| 100 | return -ENOTSUPP; |
| 101 | |
Mark Brown | 0248b4b | 2013-09-23 19:14:32 +0100 | [diff] [blame^] | 102 | /* include errata fix for spi audio problems */ |
| 103 | if (*reg == MC13783_AUDIO_CODEC || *reg == MC13783_AUDIO_DAC) |
| 104 | spi_write(spi, data, count); |
| 105 | |
Philippe Rétornaz | e4ecf6e | 2012-05-29 11:06:29 +0200 | [diff] [blame] | 106 | return spi_write(spi, data, count); |
| 107 | } |
| 108 | |
| 109 | /* |
| 110 | * We cannot use regmap-spi generic bus implementation here. |
| 111 | * The MC13783 chip will get corrupted if CS signal is deasserted |
| 112 | * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller |
| 113 | * has the following errata (DSPhl22960): |
| 114 | * "The CSPI negates SS when the FIFO becomes empty with |
| 115 | * SSCTL= 0. Software cannot guarantee that the FIFO will not |
| 116 | * drain because of higher priority interrupts and the |
| 117 | * non-realtime characteristics of the operating system. As a |
| 118 | * result, the SS will negate before all of the data has been |
| 119 | * transferred to/from the peripheral." |
| 120 | * We workaround this by accessing the SPI controller with a |
| 121 | * single transfert. |
| 122 | */ |
| 123 | |
| 124 | static struct regmap_bus regmap_mc13xxx_bus = { |
| 125 | .write = mc13xxx_spi_write, |
| 126 | .read = mc13xxx_spi_read, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 127 | }; |
| 128 | |
| 129 | static int mc13xxx_spi_probe(struct spi_device *spi) |
| 130 | { |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 131 | struct mc13xxx *mc13xxx; |
| 132 | struct mc13xxx_platform_data *pdata = dev_get_platdata(&spi->dev); |
| 133 | int ret; |
| 134 | |
Axel Lin | e7c706b | 2012-06-29 15:14:36 +0200 | [diff] [blame] | 135 | mc13xxx = devm_kzalloc(&spi->dev, sizeof(*mc13xxx), GFP_KERNEL); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 136 | if (!mc13xxx) |
| 137 | return -ENOMEM; |
| 138 | |
Jingoo Han | a720c30 | 2013-04-06 15:44:14 +0900 | [diff] [blame] | 139 | spi_set_drvdata(spi, mc13xxx); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 140 | spi->mode = SPI_MODE_0 | SPI_CS_HIGH; |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 141 | |
| 142 | mc13xxx->dev = &spi->dev; |
| 143 | mutex_init(&mc13xxx->lock); |
| 144 | |
Axel Lin | e030889 | 2012-07-02 16:03:00 +0800 | [diff] [blame] | 145 | mc13xxx->regmap = devm_regmap_init(&spi->dev, ®map_mc13xxx_bus, |
| 146 | &spi->dev, |
| 147 | &mc13xxx_regmap_spi_config); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 148 | if (IS_ERR(mc13xxx->regmap)) { |
| 149 | ret = PTR_ERR(mc13xxx->regmap); |
| 150 | dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n", |
| 151 | ret); |
Jingoo Han | a720c30 | 2013-04-06 15:44:14 +0900 | [diff] [blame] | 152 | spi_set_drvdata(spi, NULL); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 153 | return ret; |
| 154 | } |
| 155 | |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 156 | if (spi->dev.of_node) { |
| 157 | const struct of_device_id *of_id = |
| 158 | of_match_device(mc13xxx_dt_ids, &spi->dev); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 159 | |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 160 | mc13xxx->variant = of_id->data; |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 161 | } else { |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 162 | const struct spi_device_id *id_entry = spi_get_device_id(spi); |
| 163 | |
| 164 | mc13xxx->variant = (void *)id_entry->driver_data; |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 165 | } |
| 166 | |
Uwe Kleine-König | cd0f34b | 2012-07-12 09:57:52 +0000 | [diff] [blame] | 167 | return mc13xxx_common_init(mc13xxx, pdata, spi->irq); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 168 | } |
| 169 | |
Bill Pemberton | 4740f73 | 2012-11-19 13:26:01 -0500 | [diff] [blame] | 170 | static int mc13xxx_spi_remove(struct spi_device *spi) |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 171 | { |
Jingoo Han | a720c30 | 2013-04-06 15:44:14 +0900 | [diff] [blame] | 172 | struct mc13xxx *mc13xxx = spi_get_drvdata(spi); |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 173 | |
| 174 | mc13xxx_common_cleanup(mc13xxx); |
| 175 | |
| 176 | return 0; |
| 177 | } |
| 178 | |
| 179 | static struct spi_driver mc13xxx_spi_driver = { |
| 180 | .id_table = mc13xxx_device_id, |
| 181 | .driver = { |
| 182 | .name = "mc13xxx", |
| 183 | .owner = THIS_MODULE, |
| 184 | .of_match_table = mc13xxx_dt_ids, |
| 185 | }, |
| 186 | .probe = mc13xxx_spi_probe, |
Bill Pemberton | 8444921 | 2012-11-19 13:20:24 -0500 | [diff] [blame] | 187 | .remove = mc13xxx_spi_remove, |
Marc Reilly | a0c7c1d | 2012-04-01 16:41:38 +1000 | [diff] [blame] | 188 | }; |
| 189 | |
| 190 | static int __init mc13xxx_init(void) |
| 191 | { |
| 192 | return spi_register_driver(&mc13xxx_spi_driver); |
| 193 | } |
| 194 | subsys_initcall(mc13xxx_init); |
| 195 | |
| 196 | static void __exit mc13xxx_exit(void) |
| 197 | { |
| 198 | spi_unregister_driver(&mc13xxx_spi_driver); |
| 199 | } |
| 200 | module_exit(mc13xxx_exit); |
| 201 | |
| 202 | MODULE_DESCRIPTION("Core driver for Freescale MC13XXX PMIC"); |
| 203 | MODULE_AUTHOR("Uwe Kleine-Koenig <u.kleine-koenig@pengutronix.de>"); |
| 204 | MODULE_LICENSE("GPL v2"); |