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

adxl34x-i2c.c (4072B)

      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * ADLX345/346 Three-Axis Digital Accelerometers (I2C Interface)
      4 *
      5 * Enter bugs at http://blackfin.uclinux.org/
      6 *
      7 * Copyright (C) 2009 Michael Hennerich, Analog Devices Inc.
      8 */
      9
     10#include <linux/input.h>	/* BUS_I2C */
     11#include <linux/i2c.h>
     12#include <linux/module.h>
     13#include <linux/of.h>
     14#include <linux/types.h>
     15#include <linux/pm.h>
     16#include "adxl34x.h"
     17
     18static int adxl34x_smbus_read(struct device *dev, unsigned char reg)
     19{
     20	struct i2c_client *client = to_i2c_client(dev);
     21
     22	return i2c_smbus_read_byte_data(client, reg);
     23}
     24
     25static int adxl34x_smbus_write(struct device *dev,
     26			       unsigned char reg, unsigned char val)
     27{
     28	struct i2c_client *client = to_i2c_client(dev);
     29
     30	return i2c_smbus_write_byte_data(client, reg, val);
     31}
     32
     33static int adxl34x_smbus_read_block(struct device *dev,
     34				    unsigned char reg, int count,
     35				    void *buf)
     36{
     37	struct i2c_client *client = to_i2c_client(dev);
     38
     39	return i2c_smbus_read_i2c_block_data(client, reg, count, buf);
     40}
     41
     42static int adxl34x_i2c_read_block(struct device *dev,
     43				  unsigned char reg, int count,
     44				  void *buf)
     45{
     46	struct i2c_client *client = to_i2c_client(dev);
     47	int ret;
     48
     49	ret = i2c_master_send(client, &reg, 1);
     50	if (ret < 0)
     51		return ret;
     52
     53	ret = i2c_master_recv(client, buf, count);
     54	if (ret < 0)
     55		return ret;
     56
     57	if (ret != count)
     58		return -EIO;
     59
     60	return 0;
     61}
     62
     63static const struct adxl34x_bus_ops adxl34x_smbus_bops = {
     64	.bustype	= BUS_I2C,
     65	.write		= adxl34x_smbus_write,
     66	.read		= adxl34x_smbus_read,
     67	.read_block	= adxl34x_smbus_read_block,
     68};
     69
     70static const struct adxl34x_bus_ops adxl34x_i2c_bops = {
     71	.bustype	= BUS_I2C,
     72	.write		= adxl34x_smbus_write,
     73	.read		= adxl34x_smbus_read,
     74	.read_block	= adxl34x_i2c_read_block,
     75};
     76
     77static int adxl34x_i2c_probe(struct i2c_client *client,
     78				       const struct i2c_device_id *id)
     79{
     80	struct adxl34x *ac;
     81	int error;
     82
     83	error = i2c_check_functionality(client->adapter,
     84			I2C_FUNC_SMBUS_BYTE_DATA);
     85	if (!error) {
     86		dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
     87		return -EIO;
     88	}
     89
     90	ac = adxl34x_probe(&client->dev, client->irq, false,
     91			   i2c_check_functionality(client->adapter,
     92						   I2C_FUNC_SMBUS_READ_I2C_BLOCK) ?
     93				&adxl34x_smbus_bops : &adxl34x_i2c_bops);
     94	if (IS_ERR(ac))
     95		return PTR_ERR(ac);
     96
     97	i2c_set_clientdata(client, ac);
     98
     99	return 0;
    100}
    101
    102static int adxl34x_i2c_remove(struct i2c_client *client)
    103{
    104	struct adxl34x *ac = i2c_get_clientdata(client);
    105
    106	adxl34x_remove(ac);
    107
    108	return 0;
    109}
    110
    111static int __maybe_unused adxl34x_i2c_suspend(struct device *dev)
    112{
    113	struct i2c_client *client = to_i2c_client(dev);
    114	struct adxl34x *ac = i2c_get_clientdata(client);
    115
    116	adxl34x_suspend(ac);
    117
    118	return 0;
    119}
    120
    121static int __maybe_unused adxl34x_i2c_resume(struct device *dev)
    122{
    123	struct i2c_client *client = to_i2c_client(dev);
    124	struct adxl34x *ac = i2c_get_clientdata(client);
    125
    126	adxl34x_resume(ac);
    127
    128	return 0;
    129}
    130
    131static SIMPLE_DEV_PM_OPS(adxl34x_i2c_pm, adxl34x_i2c_suspend,
    132			 adxl34x_i2c_resume);
    133
    134static const struct i2c_device_id adxl34x_id[] = {
    135	{ "adxl34x", 0 },
    136	{ }
    137};
    138
    139MODULE_DEVICE_TABLE(i2c, adxl34x_id);
    140
    141static const struct of_device_id adxl34x_of_id[] = {
    142	/*
    143	 * The ADXL346 is backward-compatible with the ADXL345. Differences are
    144	 * handled by runtime detection of the device model, there's thus no
    145	 * need for listing the "adi,adxl346" compatible value explicitly.
    146	 */
    147	{ .compatible = "adi,adxl345", },
    148	/*
    149	 * Deprecated, DT nodes should use one or more of the device-specific
    150	 * compatible values "adi,adxl345" and "adi,adxl346".
    151	 */
    152	{ .compatible = "adi,adxl34x", },
    153	{ }
    154};
    155
    156MODULE_DEVICE_TABLE(of, adxl34x_of_id);
    157
    158static struct i2c_driver adxl34x_driver = {
    159	.driver = {
    160		.name = "adxl34x",
    161		.pm = &adxl34x_i2c_pm,
    162		.of_match_table = adxl34x_of_id,
    163	},
    164	.probe    = adxl34x_i2c_probe,
    165	.remove   = adxl34x_i2c_remove,
    166	.id_table = adxl34x_id,
    167};
    168
    169module_i2c_driver(adxl34x_driver);
    170
    171MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
    172MODULE_DESCRIPTION("ADXL345/346 Three-Axis Digital Accelerometer I2C Bus Driver");
    173MODULE_LICENSE("GPL");