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

regmap-sccb.c (3474B)

      1// SPDX-License-Identifier: GPL-2.0
      2// Register map access API - SCCB support
      3
      4#include <linux/i2c.h>
      5#include <linux/module.h>
      6#include <linux/regmap.h>
      7
      8#include "internal.h"
      9
     10/**
     11 * sccb_is_available - Check if the adapter supports SCCB protocol
     12 * @adap: I2C adapter
     13 *
     14 * Return true if the I2C adapter is capable of using SCCB helper functions,
     15 * false otherwise.
     16 */
     17static bool sccb_is_available(struct i2c_adapter *adap)
     18{
     19	u32 needed_funcs = I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA;
     20
     21	/*
     22	 * If we ever want support for hardware doing SCCB natively, we will
     23	 * introduce a sccb_xfer() callback to struct i2c_algorithm and check
     24	 * for it here.
     25	 */
     26
     27	return (i2c_get_functionality(adap) & needed_funcs) == needed_funcs;
     28}
     29
     30/**
     31 * regmap_sccb_read - Read data from SCCB slave device
     32 * @context: Device that will be interacted with
     33 * @reg: Register to be read from
     34 * @val: Pointer to store read value
     35 *
     36 * This executes the 2-phase write transmission cycle that is followed by a
     37 * 2-phase read transmission cycle, returning negative errno else zero on
     38 * success.
     39 */
     40static int regmap_sccb_read(void *context, unsigned int reg, unsigned int *val)
     41{
     42	struct device *dev = context;
     43	struct i2c_client *i2c = to_i2c_client(dev);
     44	int ret;
     45	union i2c_smbus_data data;
     46
     47	i2c_lock_bus(i2c->adapter, I2C_LOCK_SEGMENT);
     48
     49	ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
     50			       I2C_SMBUS_WRITE, reg, I2C_SMBUS_BYTE, NULL);
     51	if (ret < 0)
     52		goto out;
     53
     54	ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags,
     55			       I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &data);
     56	if (ret < 0)
     57		goto out;
     58
     59	*val = data.byte;
     60out:
     61	i2c_unlock_bus(i2c->adapter, I2C_LOCK_SEGMENT);
     62
     63	return ret;
     64}
     65
     66/**
     67 * regmap_sccb_write - Write data to SCCB slave device
     68 * @context: Device that will be interacted with
     69 * @reg: Register to write to
     70 * @val: Value to be written
     71 *
     72 * This executes the SCCB 3-phase write transmission cycle, returning negative
     73 * errno else zero on success.
     74 */
     75static int regmap_sccb_write(void *context, unsigned int reg, unsigned int val)
     76{
     77	struct device *dev = context;
     78	struct i2c_client *i2c = to_i2c_client(dev);
     79
     80	return i2c_smbus_write_byte_data(i2c, reg, val);
     81}
     82
     83static const struct regmap_bus regmap_sccb_bus = {
     84	.reg_write = regmap_sccb_write,
     85	.reg_read = regmap_sccb_read,
     86};
     87
     88static const struct regmap_bus *regmap_get_sccb_bus(struct i2c_client *i2c,
     89					const struct regmap_config *config)
     90{
     91	if (config->val_bits == 8 && config->reg_bits == 8 &&
     92			sccb_is_available(i2c->adapter))
     93		return &regmap_sccb_bus;
     94
     95	return ERR_PTR(-ENOTSUPP);
     96}
     97
     98struct regmap *__regmap_init_sccb(struct i2c_client *i2c,
     99				  const struct regmap_config *config,
    100				  struct lock_class_key *lock_key,
    101				  const char *lock_name)
    102{
    103	const struct regmap_bus *bus = regmap_get_sccb_bus(i2c, config);
    104
    105	if (IS_ERR(bus))
    106		return ERR_CAST(bus);
    107
    108	return __regmap_init(&i2c->dev, bus, &i2c->dev, config,
    109			     lock_key, lock_name);
    110}
    111EXPORT_SYMBOL_GPL(__regmap_init_sccb);
    112
    113struct regmap *__devm_regmap_init_sccb(struct i2c_client *i2c,
    114				       const struct regmap_config *config,
    115				       struct lock_class_key *lock_key,
    116				       const char *lock_name)
    117{
    118	const struct regmap_bus *bus = regmap_get_sccb_bus(i2c, config);
    119
    120	if (IS_ERR(bus))
    121		return ERR_CAST(bus);
    122
    123	return __devm_regmap_init(&i2c->dev, bus, &i2c->dev, config,
    124				  lock_key, lock_name);
    125}
    126EXPORT_SYMBOL_GPL(__devm_regmap_init_sccb);
    127
    128MODULE_LICENSE("GPL v2");