mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-27 14:43:58 +08:00
97fb5e8d9b
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license version 2 and only version 2 as published by the free software foundation this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 294 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190529141900.825281744@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
183 lines
5.5 KiB
C
183 lines
5.5 KiB
C
/* SPDX-License-Identifier: GPL-2.0-only */
|
|
/* Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
|
|
*/
|
|
#ifndef _LINUX_SPMI_H
|
|
#define _LINUX_SPMI_H
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/device.h>
|
|
#include <linux/mod_devicetable.h>
|
|
|
|
/* Maximum slave identifier */
|
|
#define SPMI_MAX_SLAVE_ID 16
|
|
|
|
/* SPMI Commands */
|
|
#define SPMI_CMD_EXT_WRITE 0x00
|
|
#define SPMI_CMD_RESET 0x10
|
|
#define SPMI_CMD_SLEEP 0x11
|
|
#define SPMI_CMD_SHUTDOWN 0x12
|
|
#define SPMI_CMD_WAKEUP 0x13
|
|
#define SPMI_CMD_AUTHENTICATE 0x14
|
|
#define SPMI_CMD_MSTR_READ 0x15
|
|
#define SPMI_CMD_MSTR_WRITE 0x16
|
|
#define SPMI_CMD_TRANSFER_BUS_OWNERSHIP 0x1A
|
|
#define SPMI_CMD_DDB_MASTER_READ 0x1B
|
|
#define SPMI_CMD_DDB_SLAVE_READ 0x1C
|
|
#define SPMI_CMD_EXT_READ 0x20
|
|
#define SPMI_CMD_EXT_WRITEL 0x30
|
|
#define SPMI_CMD_EXT_READL 0x38
|
|
#define SPMI_CMD_WRITE 0x40
|
|
#define SPMI_CMD_READ 0x60
|
|
#define SPMI_CMD_ZERO_WRITE 0x80
|
|
|
|
/**
|
|
* struct spmi_device - Basic representation of an SPMI device
|
|
* @dev: Driver model representation of the device.
|
|
* @ctrl: SPMI controller managing the bus hosting this device.
|
|
* @usid: This devices' Unique Slave IDentifier.
|
|
*/
|
|
struct spmi_device {
|
|
struct device dev;
|
|
struct spmi_controller *ctrl;
|
|
u8 usid;
|
|
};
|
|
|
|
static inline struct spmi_device *to_spmi_device(struct device *d)
|
|
{
|
|
return container_of(d, struct spmi_device, dev);
|
|
}
|
|
|
|
static inline void *spmi_device_get_drvdata(const struct spmi_device *sdev)
|
|
{
|
|
return dev_get_drvdata(&sdev->dev);
|
|
}
|
|
|
|
static inline void spmi_device_set_drvdata(struct spmi_device *sdev, void *data)
|
|
{
|
|
dev_set_drvdata(&sdev->dev, data);
|
|
}
|
|
|
|
struct spmi_device *spmi_device_alloc(struct spmi_controller *ctrl);
|
|
|
|
static inline void spmi_device_put(struct spmi_device *sdev)
|
|
{
|
|
if (sdev)
|
|
put_device(&sdev->dev);
|
|
}
|
|
|
|
int spmi_device_add(struct spmi_device *sdev);
|
|
|
|
void spmi_device_remove(struct spmi_device *sdev);
|
|
|
|
/**
|
|
* struct spmi_controller - interface to the SPMI master controller
|
|
* @dev: Driver model representation of the device.
|
|
* @nr: board-specific number identifier for this controller/bus
|
|
* @cmd: sends a non-data command sequence on the SPMI bus.
|
|
* @read_cmd: sends a register read command sequence on the SPMI bus.
|
|
* @write_cmd: sends a register write command sequence on the SPMI bus.
|
|
*/
|
|
struct spmi_controller {
|
|
struct device dev;
|
|
unsigned int nr;
|
|
int (*cmd)(struct spmi_controller *ctrl, u8 opcode, u8 sid);
|
|
int (*read_cmd)(struct spmi_controller *ctrl, u8 opcode,
|
|
u8 sid, u16 addr, u8 *buf, size_t len);
|
|
int (*write_cmd)(struct spmi_controller *ctrl, u8 opcode,
|
|
u8 sid, u16 addr, const u8 *buf, size_t len);
|
|
};
|
|
|
|
static inline struct spmi_controller *to_spmi_controller(struct device *d)
|
|
{
|
|
return container_of(d, struct spmi_controller, dev);
|
|
}
|
|
|
|
static inline
|
|
void *spmi_controller_get_drvdata(const struct spmi_controller *ctrl)
|
|
{
|
|
return dev_get_drvdata(&ctrl->dev);
|
|
}
|
|
|
|
static inline void spmi_controller_set_drvdata(struct spmi_controller *ctrl,
|
|
void *data)
|
|
{
|
|
dev_set_drvdata(&ctrl->dev, data);
|
|
}
|
|
|
|
struct spmi_controller *spmi_controller_alloc(struct device *parent,
|
|
size_t size);
|
|
|
|
/**
|
|
* spmi_controller_put() - decrement controller refcount
|
|
* @ctrl SPMI controller.
|
|
*/
|
|
static inline void spmi_controller_put(struct spmi_controller *ctrl)
|
|
{
|
|
if (ctrl)
|
|
put_device(&ctrl->dev);
|
|
}
|
|
|
|
int spmi_controller_add(struct spmi_controller *ctrl);
|
|
void spmi_controller_remove(struct spmi_controller *ctrl);
|
|
|
|
/**
|
|
* struct spmi_driver - SPMI slave device driver
|
|
* @driver: SPMI device drivers should initialize name and owner field of
|
|
* this structure.
|
|
* @probe: binds this driver to a SPMI device.
|
|
* @remove: unbinds this driver from the SPMI device.
|
|
*
|
|
* If PM runtime support is desired for a slave, a device driver can call
|
|
* pm_runtime_put() from their probe() routine (and a balancing
|
|
* pm_runtime_get() in remove()). PM runtime support for a slave is
|
|
* implemented by issuing a SLEEP command to the slave on runtime_suspend(),
|
|
* transitioning the slave into the SLEEP state. On runtime_resume(), a WAKEUP
|
|
* command is sent to the slave to bring it back to ACTIVE.
|
|
*/
|
|
struct spmi_driver {
|
|
struct device_driver driver;
|
|
int (*probe)(struct spmi_device *sdev);
|
|
void (*remove)(struct spmi_device *sdev);
|
|
};
|
|
|
|
static inline struct spmi_driver *to_spmi_driver(struct device_driver *d)
|
|
{
|
|
return container_of(d, struct spmi_driver, driver);
|
|
}
|
|
|
|
#define spmi_driver_register(sdrv) \
|
|
__spmi_driver_register(sdrv, THIS_MODULE)
|
|
int __spmi_driver_register(struct spmi_driver *sdrv, struct module *owner);
|
|
|
|
/**
|
|
* spmi_driver_unregister() - unregister an SPMI client driver
|
|
* @sdrv: the driver to unregister
|
|
*/
|
|
static inline void spmi_driver_unregister(struct spmi_driver *sdrv)
|
|
{
|
|
if (sdrv)
|
|
driver_unregister(&sdrv->driver);
|
|
}
|
|
|
|
#define module_spmi_driver(__spmi_driver) \
|
|
module_driver(__spmi_driver, spmi_driver_register, \
|
|
spmi_driver_unregister)
|
|
|
|
int spmi_register_read(struct spmi_device *sdev, u8 addr, u8 *buf);
|
|
int spmi_ext_register_read(struct spmi_device *sdev, u8 addr, u8 *buf,
|
|
size_t len);
|
|
int spmi_ext_register_readl(struct spmi_device *sdev, u16 addr, u8 *buf,
|
|
size_t len);
|
|
int spmi_register_write(struct spmi_device *sdev, u8 addr, u8 data);
|
|
int spmi_register_zero_write(struct spmi_device *sdev, u8 data);
|
|
int spmi_ext_register_write(struct spmi_device *sdev, u8 addr,
|
|
const u8 *buf, size_t len);
|
|
int spmi_ext_register_writel(struct spmi_device *sdev, u16 addr,
|
|
const u8 *buf, size_t len);
|
|
int spmi_command_reset(struct spmi_device *sdev);
|
|
int spmi_command_sleep(struct spmi_device *sdev);
|
|
int spmi_command_wakeup(struct spmi_device *sdev);
|
|
int spmi_command_shutdown(struct spmi_device *sdev);
|
|
|
|
#endif
|