History

rtc: remove v3020 driver

The v3020 RTC driver was exclusively used by the now removed cm-x300.c machine.

Arnd Bergmann committed 4 years ago

Commit 6388bba1 parent 0f9b85e4 files · +0 −420Browse files

Unified · Split

4 files
  1. drivers/rtc/Kconfig +0 −9
  2. drivers/rtc/Makefile +0 −1
  3. drivers/rtc/rtc-v3020.c +0 −369
  4. include/linux/platform_data/rtc-v3020.h +0 −41
drivers/rtc/Kconfig+0−9
@@ -1212,15 +1212,6 @@ config RTC_DRV_RP5C01 · 1211 unmodified lines
12121212 This driver can also be built as a module. If so, the module
12131213 will be called rtc-rp5c01.
12141214
1215−config RTC_DRV_V3020
1216− tristate "EM Microelectronic V3020"
1217− help
1218− If you say yes here you will get support for the
1219− EM Microelectronic v3020 RTC chip.
1220−
1221− This driver can also be built as a module. If so, the module
1222− will be called rtc-v3020.
1223−
12241215 config RTC_DRV_GAMECUBE
12251216 tristate "Nintendo GameCube, Wii and Wii U RTC"
12261217 depends on GAMECUBE || WII || COMPILE_TEST
drivers/rtc/Makefile+0−1
@@ -176,7 +176,6 @@ obj-$(CONFIG_RTC_DRV_TI_K3) += rtc-ti-k3.o · 175 unmodified lines
176176 obj-$(CONFIG_RTC_DRV_TPS6586X) += rtc-tps6586x.o
177177 obj-$(CONFIG_RTC_DRV_TPS65910) += rtc-tps65910.o
178178 obj-$(CONFIG_RTC_DRV_TWL4030) += rtc-twl.o
179−obj-$(CONFIG_RTC_DRV_V3020) += rtc-v3020.o
180179 obj-$(CONFIG_RTC_DRV_VT8500) += rtc-vt8500.o
181180 obj-$(CONFIG_RTC_DRV_WILCO_EC) += rtc-wilco-ec.o
182181 obj-$(CONFIG_RTC_DRV_WM831X) += rtc-wm831x.o
drivers/rtc/rtc-v3020.c+0−369
@@ -1,369 +0,0 @@
1−// SPDX-License-Identifier: GPL-2.0-only
2−/* drivers/rtc/rtc-v3020.c
3− *
4− * Copyright (C) 2006 8D Technologies inc.
5− * Copyright (C) 2004 Compulab Ltd.
6− *
7− * Driver for the V3020 RTC
8− *
9− * Changelog:
10− *
11− * 10-May-2006: Raphael Assenat <raph@8d.com>
12− * - Converted to platform driver
13− * - Use the generic rtc class
14− *
15− * ??-???-2004: Someone at Compulab
16− * - Initial driver creation.
17− */
18−#include <linux/platform_device.h>
19−#include <linux/module.h>
20−#include <linux/init.h>
21−#include <linux/rtc.h>
22−#include <linux/types.h>
23−#include <linux/bcd.h>
24−#include <linux/platform_data/rtc-v3020.h>
25−#include <linux/delay.h>
26−#include <linux/gpio.h>
27−#include <linux/slab.h>
28−
29−#include <linux/io.h>
30−
31−#undef DEBUG
32−
33−struct v3020;
34−
35−struct v3020_chip_ops {
36− int (*map_io)(struct v3020 *chip, struct platform_device *pdev,
37− struct v3020_platform_data *pdata);
38− void (*unmap_io)(struct v3020 *chip);
39− unsigned char (*read_bit)(struct v3020 *chip);
40− void (*write_bit)(struct v3020 *chip, unsigned char bit);
41−};
42−
43−#define V3020_CS 0
44−#define V3020_WR 1
45−#define V3020_RD 2
46−#define V3020_IO 3
47−
48−struct v3020 {
49− /* MMIO access */
50− void __iomem *ioaddress;
51− int leftshift;
52−
53− /* GPIO access */
54− struct gpio *gpio;
55−
56− const struct v3020_chip_ops *ops;
57−
58− struct rtc_device *rtc;
59−};
60−
61−
62−static int v3020_mmio_map(struct v3020 *chip, struct platform_device *pdev,
63− struct v3020_platform_data *pdata)
64−{
65− if (pdev->num_resources != 1)
66− return -EBUSY;
67−
68− if (pdev->resource[0].flags != IORESOURCE_MEM)
69− return -EBUSY;
70−
71− chip->leftshift = pdata->leftshift;
72− chip->ioaddress = ioremap(pdev->resource[0].start, 1);
73− if (chip->ioaddress == NULL)
74− return -EBUSY;
75−
76− return 0;
77−}
78−
79−static void v3020_mmio_unmap(struct v3020 *chip)
80−{
81− iounmap(chip->ioaddress);
82−}
83−
84−static void v3020_mmio_write_bit(struct v3020 *chip, unsigned char bit)
85−{
86− writel(bit << chip->leftshift, chip->ioaddress);
87−}
88−
89−static unsigned char v3020_mmio_read_bit(struct v3020 *chip)
90−{
91− return !!(readl(chip->ioaddress) & (1 << chip->leftshift));
92−}
93−
94−static const struct v3020_chip_ops v3020_mmio_ops = {
95− .map_io = v3020_mmio_map,
96− .unmap_io = v3020_mmio_unmap,
97− .read_bit = v3020_mmio_read_bit,
98− .write_bit = v3020_mmio_write_bit,
99−};
100−
101−static struct gpio v3020_gpio[] = {
102− { 0, GPIOF_OUT_INIT_HIGH, "RTC CS"},
103− { 0, GPIOF_OUT_INIT_HIGH, "RTC WR"},
104− { 0, GPIOF_OUT_INIT_HIGH, "RTC RD"},
105− { 0, GPIOF_OUT_INIT_HIGH, "RTC IO"},
106−};
107−
108−static int v3020_gpio_map(struct v3020 *chip, struct platform_device *pdev,
109− struct v3020_platform_data *pdata)
110−{
111− int err;
112−
113− v3020_gpio[V3020_CS].gpio = pdata->gpio_cs;
114− v3020_gpio[V3020_WR].gpio = pdata->gpio_wr;
115− v3020_gpio[V3020_RD].gpio = pdata->gpio_rd;
116− v3020_gpio[V3020_IO].gpio = pdata->gpio_io;
117−
118− err = gpio_request_array(v3020_gpio, ARRAY_SIZE(v3020_gpio));
119−
120− if (!err)
121− chip->gpio = v3020_gpio;
122−
123− return err;
124−}
125−
126−static void v3020_gpio_unmap(struct v3020 *chip)
127−{
128− gpio_free_array(v3020_gpio, ARRAY_SIZE(v3020_gpio));
129−}
130−
131−static void v3020_gpio_write_bit(struct v3020 *chip, unsigned char bit)
132−{
133− gpio_direction_output(chip->gpio[V3020_IO].gpio, bit);
134− gpio_set_value(chip->gpio[V3020_CS].gpio, 0);
135− gpio_set_value(chip->gpio[V3020_WR].gpio, 0);
136− udelay(1);
137− gpio_set_value(chip->gpio[V3020_WR].gpio, 1);
138− gpio_set_value(chip->gpio[V3020_CS].gpio, 1);
139−}
140−
141−static unsigned char v3020_gpio_read_bit(struct v3020 *chip)
142−{
143− int bit;
144−
145− gpio_direction_input(chip->gpio[V3020_IO].gpio);
146− gpio_set_value(chip->gpio[V3020_CS].gpio, 0);
147− gpio_set_value(chip->gpio[V3020_RD].gpio, 0);
148− udelay(1);
149− bit = !!gpio_get_value(chip->gpio[V3020_IO].gpio);
150− udelay(1);
151− gpio_set_value(chip->gpio[V3020_RD].gpio, 1);
152− gpio_set_value(chip->gpio[V3020_CS].gpio, 1);
153−
154− return bit;
155−}
156−
157−static const struct v3020_chip_ops v3020_gpio_ops = {
158− .map_io = v3020_gpio_map,
159− .unmap_io = v3020_gpio_unmap,
160− .read_bit = v3020_gpio_read_bit,
161− .write_bit = v3020_gpio_write_bit,
162−};
163−
164−static void v3020_set_reg(struct v3020 *chip, unsigned char address,
165− unsigned char data)
166−{
167− int i;
168− unsigned char tmp;
169−
170− tmp = address;
171− for (i = 0; i < 4; i++) {
172− chip->ops->write_bit(chip, (tmp & 1));
173− tmp >>= 1;
174− udelay(1);
175− }
176−
177− /* Commands dont have data */
178− if (!V3020_IS_COMMAND(address)) {
179− for (i = 0; i < 8; i++) {
180− chip->ops->write_bit(chip, (data & 1));
181− data >>= 1;
182− udelay(1);
183− }
184− }
185−}
186−
187−static unsigned char v3020_get_reg(struct v3020 *chip, unsigned char address)
188−{
189− unsigned int data = 0;
190− int i;
191−
192− for (i = 0; i < 4; i++) {
193− chip->ops->write_bit(chip, (address & 1));
194− address >>= 1;
195− udelay(1);
196− }
197−
198− for (i = 0; i < 8; i++) {
199− data >>= 1;
200− if (chip->ops->read_bit(chip))
201− data |= 0x80;
202− udelay(1);
203− }
204−
205− return data;
206−}
207−
208−static int v3020_read_time(struct device *dev, struct rtc_time *dt)
209−{
210− struct v3020 *chip = dev_get_drvdata(dev);
211− int tmp;
212−
213− /* Copy the current time to ram... */
214− v3020_set_reg(chip, V3020_CMD_CLOCK2RAM, 0);
215−
216− /* ...and then read constant values. */
217− tmp = v3020_get_reg(chip, V3020_SECONDS);
218− dt->tm_sec = bcd2bin(tmp);
219− tmp = v3020_get_reg(chip, V3020_MINUTES);
220− dt->tm_min = bcd2bin(tmp);
221− tmp = v3020_get_reg(chip, V3020_HOURS);
222− dt->tm_hour = bcd2bin(tmp);
223− tmp = v3020_get_reg(chip, V3020_MONTH_DAY);
224− dt->tm_mday = bcd2bin(tmp);
225− tmp = v3020_get_reg(chip, V3020_MONTH);
226− dt->tm_mon = bcd2bin(tmp) - 1;
227− tmp = v3020_get_reg(chip, V3020_WEEK_DAY);
228− dt->tm_wday = bcd2bin(tmp);
229− tmp = v3020_get_reg(chip, V3020_YEAR);
230− dt->tm_year = bcd2bin(tmp)+100;
231−
232− dev_dbg(dev, "\n%s : Read RTC values\n", __func__);
233− dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
234− dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
235− dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
236− dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
237− dev_dbg(dev, "tm_mon : %i\n", dt->tm_mon);
238− dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
239− dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
240−
241− return 0;
242−}
243−
244−
245−static int v3020_set_time(struct device *dev, struct rtc_time *dt)
246−{
247− struct v3020 *chip = dev_get_drvdata(dev);
248−
249− dev_dbg(dev, "\n%s : Setting RTC values\n", __func__);
250− dev_dbg(dev, "tm_sec : %i\n", dt->tm_sec);
251− dev_dbg(dev, "tm_min : %i\n", dt->tm_min);
252− dev_dbg(dev, "tm_hour: %i\n", dt->tm_hour);
253− dev_dbg(dev, "tm_mday: %i\n", dt->tm_mday);
254− dev_dbg(dev, "tm_wday: %i\n", dt->tm_wday);
255− dev_dbg(dev, "tm_year: %i\n", dt->tm_year);
256−
257− /* Write all the values to ram... */
258− v3020_set_reg(chip, V3020_SECONDS, bin2bcd(dt->tm_sec));
259− v3020_set_reg(chip, V3020_MINUTES, bin2bcd(dt->tm_min));
260− v3020_set_reg(chip, V3020_HOURS, bin2bcd(dt->tm_hour));
261− v3020_set_reg(chip, V3020_MONTH_DAY, bin2bcd(dt->tm_mday));
262− v3020_set_reg(chip, V3020_MONTH, bin2bcd(dt->tm_mon + 1));
263− v3020_set_reg(chip, V3020_WEEK_DAY, bin2bcd(dt->tm_wday));
264− v3020_set_reg(chip, V3020_YEAR, bin2bcd(dt->tm_year % 100));
265−
266− /* ...and set the clock. */
267− v3020_set_reg(chip, V3020_CMD_RAM2CLOCK, 0);
268−
269− /* Compulab used this delay here. I dont know why,
270− * the datasheet does not specify a delay. */
271− /*mdelay(5);*/
272−
273− return 0;
274−}
275−
276−static const struct rtc_class_ops v3020_rtc_ops = {
277− .read_time = v3020_read_time,
278− .set_time = v3020_set_time,
279−};
280−
281−static int rtc_probe(struct platform_device *pdev)
282−{
283− struct v3020_platform_data *pdata = dev_get_platdata(&pdev->dev);
284− struct v3020 *chip;
285− int retval;
286− int i;
287−
288− chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL);
289− if (!chip)
290− return -ENOMEM;
291−
292− if (pdata->use_gpio)
293− chip->ops = &v3020_gpio_ops;
294− else
295− chip->ops = &v3020_mmio_ops;
296−
297− retval = chip->ops->map_io(chip, pdev, pdata);
298− if (retval)
299− return retval;
300−
301− /* Make sure the v3020 expects a communication cycle
302− * by reading 8 times */
303− for (i = 0; i < 8; i++)
304− chip->ops->read_bit(chip);
305−
306− /* Test chip by doing a write/read sequence
307− * to the chip ram */
308− v3020_set_reg(chip, V3020_SECONDS, 0x33);
309− if (v3020_get_reg(chip, V3020_SECONDS) != 0x33) {
310− retval = -ENODEV;
311− goto err_io;
312− }
313−
314− /* Make sure frequency measurement mode, test modes, and lock
315− * are all disabled */
316− v3020_set_reg(chip, V3020_STATUS_0, 0x0);
317−
318− if (pdata->use_gpio)
319− dev_info(&pdev->dev, "Chip available at GPIOs "
320− "%d, %d, %d, %d\n",
321− chip->gpio[V3020_CS].gpio, chip->gpio[V3020_WR].gpio,
322− chip->gpio[V3020_RD].gpio, chip->gpio[V3020_IO].gpio);
323− else
324− dev_info(&pdev->dev, "Chip available at "
325− "physical address 0x%llx,"
326− "data connected to D%d\n",
327− (unsigned long long)pdev->resource[0].start,
328− chip->leftshift);
329−
330− platform_set_drvdata(pdev, chip);
331−
332− chip->rtc = devm_rtc_device_register(&pdev->dev, "v3020",
333− &v3020_rtc_ops, THIS_MODULE);
334− if (IS_ERR(chip->rtc)) {
335− retval = PTR_ERR(chip->rtc);
336− goto err_io;
337− }
338−
339− return 0;
340−
341−err_io:
342− chip->ops->unmap_io(chip);
343−
344− return retval;
345−}
346−
347−static int rtc_remove(struct platform_device *dev)
348−{
349− struct v3020 *chip = platform_get_drvdata(dev);
350−
351− chip->ops->unmap_io(chip);
352−
353− return 0;
354−}
355−
356−static struct platform_driver rtc_device_driver = {
357− .probe = rtc_probe,
358− .remove = rtc_remove,
359− .driver = {
360− .name = "v3020",
361− },
362−};
363−
364−module_platform_driver(rtc_device_driver);
365−
366−MODULE_DESCRIPTION("V3020 RTC");
367−MODULE_AUTHOR("Raphael Assenat");
368−MODULE_LICENSE("GPL");
369−MODULE_ALIAS("platform:v3020");
include/linux/platform_data/rtc-v3020.h+0−41
@@ -1,41 +0,0 @@
1−/*
2− * v3020.h - Registers definition and platform data structure for the v3020 RTC.
3− *
4− * This file is subject to the terms and conditions of the GNU General Public
5− * License. See the file "COPYING" in the main directory of this archive
6− * for more details.
7− *
8− * Copyright (C) 2006, 8D Technologies inc.
9− */
10−#ifndef __LINUX_V3020_H
11−#define __LINUX_V3020_H
12−
13−/* The v3020 has only one data pin but which one
14− * is used depends on the board. */
15−struct v3020_platform_data {
16− int leftshift; /* (1<<(leftshift)) & readl() */
17−
18− unsigned int use_gpio:1;
19− unsigned int gpio_cs;
20− unsigned int gpio_wr;
21− unsigned int gpio_rd;
22− unsigned int gpio_io;
23−};
24−
25−#define V3020_STATUS_0 0x00
26−#define V3020_STATUS_1 0x01
27−#define V3020_SECONDS 0x02
28−#define V3020_MINUTES 0x03
29−#define V3020_HOURS 0x04
30−#define V3020_MONTH_DAY 0x05
31−#define V3020_MONTH 0x06
32−#define V3020_YEAR 0x07
33−#define V3020_WEEK_DAY 0x08
34−#define V3020_WEEK 0x09
35−
36−#define V3020_IS_COMMAND(val) ((val)>=0x0E)
37−
38−#define V3020_CMD_RAM2CLOCK 0x0E
39−#define V3020_CMD_CLOCK2RAM 0x0F
40−
41−#endif /* __LINUX_V3020_H */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t