cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

rtc-max6902.c (3807B)

      1// SPDX-License-Identifier: GPL-2.0-only
      2/* drivers/rtc/rtc-max6902.c
      3 *
      4 * Copyright (C) 2006 8D Technologies inc.
      5 * Copyright (C) 2004 Compulab Ltd.
      6 *
      7 * Driver for MAX6902 spi RTC
      8 */
      9
     10#include <linux/module.h>
     11#include <linux/kernel.h>
     12#include <linux/platform_device.h>
     13#include <linux/init.h>
     14#include <linux/rtc.h>
     15#include <linux/spi/spi.h>
     16#include <linux/bcd.h>
     17
     18#define MAX6902_REG_SECONDS		0x01
     19#define MAX6902_REG_MINUTES		0x03
     20#define MAX6902_REG_HOURS		0x05
     21#define MAX6902_REG_DATE		0x07
     22#define MAX6902_REG_MONTH		0x09
     23#define MAX6902_REG_DAY			0x0B
     24#define MAX6902_REG_YEAR		0x0D
     25#define MAX6902_REG_CONTROL		0x0F
     26#define MAX6902_REG_CENTURY		0x13
     27
     28static int max6902_set_reg(struct device *dev, unsigned char address,
     29				unsigned char data)
     30{
     31	struct spi_device *spi = to_spi_device(dev);
     32	unsigned char buf[2];
     33
     34	/* MSB must be '0' to write */
     35	buf[0] = address & 0x7f;
     36	buf[1] = data;
     37
     38	return spi_write_then_read(spi, buf, 2, NULL, 0);
     39}
     40
     41static int max6902_get_reg(struct device *dev, unsigned char address,
     42				unsigned char *data)
     43{
     44	struct spi_device *spi = to_spi_device(dev);
     45
     46	/* Set MSB to indicate read */
     47	*data = address | 0x80;
     48
     49	return spi_write_then_read(spi, data, 1, data, 1);
     50}
     51
     52static int max6902_read_time(struct device *dev, struct rtc_time *dt)
     53{
     54	int err, century;
     55	struct spi_device *spi = to_spi_device(dev);
     56	unsigned char buf[8];
     57
     58	buf[0] = 0xbf;	/* Burst read */
     59
     60	err = spi_write_then_read(spi, buf, 1, buf, 8);
     61	if (err != 0)
     62		return err;
     63
     64	/* The chip sends data in this order:
     65	 * Seconds, Minutes, Hours, Date, Month, Day, Year */
     66	dt->tm_sec	= bcd2bin(buf[0]);
     67	dt->tm_min	= bcd2bin(buf[1]);
     68	dt->tm_hour	= bcd2bin(buf[2]);
     69	dt->tm_mday	= bcd2bin(buf[3]);
     70	dt->tm_mon	= bcd2bin(buf[4]) - 1;
     71	dt->tm_wday	= bcd2bin(buf[5]);
     72	dt->tm_year	= bcd2bin(buf[6]);
     73
     74	/* Read century */
     75	err = max6902_get_reg(dev, MAX6902_REG_CENTURY, &buf[0]);
     76	if (err != 0)
     77		return err;
     78
     79	century = bcd2bin(buf[0]) * 100;
     80
     81	dt->tm_year += century;
     82	dt->tm_year -= 1900;
     83
     84	return 0;
     85}
     86
     87static int max6902_set_time(struct device *dev, struct rtc_time *dt)
     88{
     89	dt->tm_year = dt->tm_year + 1900;
     90
     91	/* Remove write protection */
     92	max6902_set_reg(dev, MAX6902_REG_CONTROL, 0);
     93
     94	max6902_set_reg(dev, MAX6902_REG_SECONDS, bin2bcd(dt->tm_sec));
     95	max6902_set_reg(dev, MAX6902_REG_MINUTES, bin2bcd(dt->tm_min));
     96	max6902_set_reg(dev, MAX6902_REG_HOURS, bin2bcd(dt->tm_hour));
     97
     98	max6902_set_reg(dev, MAX6902_REG_DATE, bin2bcd(dt->tm_mday));
     99	max6902_set_reg(dev, MAX6902_REG_MONTH, bin2bcd(dt->tm_mon + 1));
    100	max6902_set_reg(dev, MAX6902_REG_DAY, bin2bcd(dt->tm_wday));
    101	max6902_set_reg(dev, MAX6902_REG_YEAR, bin2bcd(dt->tm_year % 100));
    102	max6902_set_reg(dev, MAX6902_REG_CENTURY, bin2bcd(dt->tm_year / 100));
    103
    104	/* Compulab used a delay here. However, the datasheet
    105	 * does not mention a delay being required anywhere... */
    106	/* delay(2000); */
    107
    108	/* Write protect */
    109	max6902_set_reg(dev, MAX6902_REG_CONTROL, 0x80);
    110
    111	return 0;
    112}
    113
    114static const struct rtc_class_ops max6902_rtc_ops = {
    115	.read_time	= max6902_read_time,
    116	.set_time	= max6902_set_time,
    117};
    118
    119static int max6902_probe(struct spi_device *spi)
    120{
    121	struct rtc_device *rtc;
    122	unsigned char tmp;
    123	int res;
    124
    125	spi->mode = SPI_MODE_3;
    126	spi->bits_per_word = 8;
    127	spi_setup(spi);
    128
    129	res = max6902_get_reg(&spi->dev, MAX6902_REG_SECONDS, &tmp);
    130	if (res != 0)
    131		return res;
    132
    133	rtc = devm_rtc_device_register(&spi->dev, "max6902",
    134				&max6902_rtc_ops, THIS_MODULE);
    135	if (IS_ERR(rtc))
    136		return PTR_ERR(rtc);
    137
    138	spi_set_drvdata(spi, rtc);
    139	return 0;
    140}
    141
    142static struct spi_driver max6902_driver = {
    143	.driver = {
    144		.name	= "rtc-max6902",
    145	},
    146	.probe	= max6902_probe,
    147};
    148
    149module_spi_driver(max6902_driver);
    150
    151MODULE_DESCRIPTION("max6902 spi RTC driver");
    152MODULE_AUTHOR("Raphael Assenat");
    153MODULE_LICENSE("GPL");
    154MODULE_ALIAS("spi:rtc-max6902");