[linux-2.6-block.git] / include / linux / slimbus.h

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2011-2017, The Linux Foundation
 */

#ifndef _LINUX_SLIMBUS_H
#define _LINUX_SLIMBUS_H
#include <linux/device.h>
#include <linux/module.h>
#include <linux/completion.h>
#include <linux/mod_devicetable.h>

extern struct bus_type slimbus_bus;

/**
 * struct slim_eaddr - Enumeration address for a SLIMbus device
 * @manf_id: Manufacturer Id for the device
 * @prod_code: Product code
 * @dev_index: Device index
 * @instance: Instance value
 */
struct slim_eaddr {
	u16 manf_id;
	u16 prod_code;
	u8 dev_index;
	u8 instance;
} __packed;

/**
 * enum slim_device_status - slim device status
 * @SLIM_DEVICE_STATUS_DOWN: Slim device is absent or not reported yet.
 * @SLIM_DEVICE_STATUS_UP: Slim device is announced on the bus.
 * @SLIM_DEVICE_STATUS_RESERVED: Reserved for future use.
 */
enum slim_device_status {
	SLIM_DEVICE_STATUS_DOWN = 0,
	SLIM_DEVICE_STATUS_UP,
	SLIM_DEVICE_STATUS_RESERVED,
};

struct slim_controller;

/**
 * struct slim_device - Slim device handle.
 * @dev: Driver model representation of the device.
 * @e_addr: Enumeration address of this device.
 * @status: slim device status
 * @ctrl: slim controller instance.
 * @laddr: 1-byte Logical address of this device.
 * @is_laddr_valid: indicates if the laddr is valid or not
 *
 * This is the client/device handle returned when a SLIMbus
 * device is registered with a controller.
 * Pointer to this structure is used by client-driver as a handle.
 */
struct slim_device {
	struct device		dev;
	struct slim_eaddr	e_addr;
	struct slim_controller	*ctrl;
	enum slim_device_status	status;
	u8			laddr;
	bool			is_laddr_valid;
};

#define to_slim_device(d) container_of(d, struct slim_device, dev)

/**
 * struct slim_driver - SLIMbus 'generic device' (slave) device driver
 *				(similar to 'spi_device' on SPI)
 * @probe: Binds this driver to a SLIMbus device.
 * @remove: Unbinds this driver from the SLIMbus device.
 * @shutdown: Standard shutdown callback used during powerdown/halt.
 * @device_status: This callback is called when
 *	- The device reports present and gets a laddr assigned
 *	- The device reports absent, or the bus goes down.
 * @driver: SLIMbus device drivers should initialize name and owner field of
 *	    this structure
 * @id_table: List of SLIMbus devices supported by this driver
 */

struct slim_driver {
	int	(*probe)(struct slim_device *sl);
	void	(*remove)(struct slim_device *sl);
	void	(*shutdown)(struct slim_device *sl);
	int	(*device_status)(struct slim_device *sl,
				 enum slim_device_status s);
	struct device_driver		driver;
	const struct slim_device_id	*id_table;
};
#define to_slim_driver(d) container_of(d, struct slim_driver, driver)

/**
 * struct slim_val_inf - Slimbus value or information element
 * @start_offset: Specifies starting offset in information/value element map
 * @rbuf: buffer to read the values
 * @wbuf: buffer to write
 * @num_bytes: upto 16. This ensures that the message will fit the slicesize
 *		per SLIMbus spec
 * @comp: completion for asynchronous operations, valid only if TID is
 *	  required for transaction, like REQUEST operations.
 *	  Rest of the transactions are synchronous anyway.
 */
struct slim_val_inf {
	u16			start_offset;
	u8			num_bytes;
	u8			*rbuf;
	const u8		*wbuf;
	struct	completion	*comp;
};

/*
 * use a macro to avoid include chaining to get THIS_MODULE
 */
#define slim_driver_register(drv) \
	__slim_driver_register(drv, THIS_MODULE)
int __slim_driver_register(struct slim_driver *drv, struct module *owner);
void slim_driver_unregister(struct slim_driver *drv);

/**
 * module_slim_driver() - Helper macro for registering a SLIMbus driver
 * @__slim_driver: slimbus_driver struct
 *
 * Helper macro for SLIMbus drivers which do not do anything special in module
 * init/exit. This eliminates a lot of boilerplate. Each module may only
 * use this macro once, and calling it replaces module_init() and module_exit()
 */
#define module_slim_driver(__slim_driver) \
	module_driver(__slim_driver, slim_driver_register, \
			slim_driver_unregister)

static inline void *slim_get_devicedata(const struct slim_device *dev)
{
	return dev_get_drvdata(&dev->dev);
}

static inline void slim_set_devicedata(struct slim_device *dev, void *data)
{
	dev_set_drvdata(&dev->dev, data);
}

struct slim_device *slim_get_device(struct slim_controller *ctrl,
				    struct slim_eaddr *e_addr);
int slim_get_logical_addr(struct slim_device *sbdev);

/* Information Element management messages */
#define SLIM_MSG_MC_REQUEST_INFORMATION          0x20
#define SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION    0x21
#define SLIM_MSG_MC_REPLY_INFORMATION            0x24
#define SLIM_MSG_MC_CLEAR_INFORMATION            0x28
#define SLIM_MSG_MC_REPORT_INFORMATION           0x29

/* Value Element management messages */
#define SLIM_MSG_MC_REQUEST_VALUE                0x60
#define SLIM_MSG_MC_REQUEST_CHANGE_VALUE         0x61
#define SLIM_MSG_MC_REPLY_VALUE                  0x64
#define SLIM_MSG_MC_CHANGE_VALUE                 0x68

int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg,
		  u8 mc);
int slim_readb(struct slim_device *sdev, u32 addr);
int slim_writeb(struct slim_device *sdev, u32 addr, u8 value);
int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
#endif /* _LINUX_SLIMBUS_H */
Commit	Line	Data
3648e78e SD	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2011-2017, The Linux Foundation
	4	*/
	5
	6	#ifndef _LINUX_SLIMBUS_H
	7	#define _LINUX_SLIMBUS_H
	8	#include <linux/device.h>
	9	#include <linux/module.h>
afbdcc7c	10	#include <linux/completion.h>
3648e78e SD	11	#include <linux/mod_devicetable.h>
	12
	13	extern struct bus_type slimbus_bus;
	14
	15	/**
	16	* struct slim_eaddr - Enumeration address for a SLIMbus device
	17	* @manf_id: Manufacturer Id for the device
	18	* @prod_code: Product code
	19	* @dev_index: Device index
	20	* @instance: Instance value
	21	*/
	22	struct slim_eaddr {
	23	u16 manf_id;
	24	u16 prod_code;
	25	u8 dev_index;
	26	u8 instance;
	27	} __packed;
	28
	29	/**
	30	* enum slim_device_status - slim device status
	31	* @SLIM_DEVICE_STATUS_DOWN: Slim device is absent or not reported yet.
	32	* @SLIM_DEVICE_STATUS_UP: Slim device is announced on the bus.
	33	* @SLIM_DEVICE_STATUS_RESERVED: Reserved for future use.
	34	*/
	35	enum slim_device_status {
	36	SLIM_DEVICE_STATUS_DOWN = 0,
	37	SLIM_DEVICE_STATUS_UP,
	38	SLIM_DEVICE_STATUS_RESERVED,
	39	};
	40
46a2bb5a SD	41	struct slim_controller;
46a2bb5a SD	42
3648e78e SD	43	/**
	44	* struct slim_device - Slim device handle.
	45	* @dev: Driver model representation of the device.
	46	* @e_addr: Enumeration address of this device.
	47	* @status: slim device status
46a2bb5a	48	* @ctrl: slim controller instance.
3648e78e SD	49	* @laddr: 1-byte Logical address of this device.
	50	* @is_laddr_valid: indicates if the laddr is valid or not
	51	*
	52	* This is the client/device handle returned when a SLIMbus
	53	* device is registered with a controller.
	54	* Pointer to this structure is used by client-driver as a handle.
	55	*/
	56	struct slim_device {
	57	struct device dev;
	58	struct slim_eaddr e_addr;
46a2bb5a	59	struct slim_controller *ctrl;
3648e78e SD	60	enum slim_device_status status;
	61	u8 laddr;
	62	bool is_laddr_valid;
	63	};
	64
	65	#define to_slim_device(d) container_of(d, struct slim_device, dev)
	66
	67	/**
	68	* struct slim_driver - SLIMbus 'generic device' (slave) device driver
	69	* (similar to 'spi_device' on SPI)
	70	* @probe: Binds this driver to a SLIMbus device.
	71	* @remove: Unbinds this driver from the SLIMbus device.
	72	* @shutdown: Standard shutdown callback used during powerdown/halt.
	73	* @device_status: This callback is called when
	74	* - The device reports present and gets a laddr assigned
	75	* - The device reports absent, or the bus goes down.
	76	* @driver: SLIMbus device drivers should initialize name and owner field of
	77	* this structure
	78	* @id_table: List of SLIMbus devices supported by this driver
	79	*/
	80
	81	struct slim_driver {
	82	int (probe)(struct slim_device sl);
	83	void (remove)(struct slim_device sl);
	84	void (shutdown)(struct slim_device sl);
	85	int (device_status)(struct slim_device sl,
	86	enum slim_device_status s);
	87	struct device_driver driver;
	88	const struct slim_device_id *id_table;
	89	};
	90	#define to_slim_driver(d) container_of(d, struct slim_driver, driver)
	91
afbdcc7c SD	92	/**
	93	* struct slim_val_inf - Slimbus value or information element
	94	* @start_offset: Specifies starting offset in information/value element map
	95	* @rbuf: buffer to read the values
	96	* @wbuf: buffer to write
	97	* @num_bytes: upto 16. This ensures that the message will fit the slicesize
	98	* per SLIMbus spec
	99	* @comp: completion for asynchronous operations, valid only if TID is
	100	* required for transaction, like REQUEST operations.
	101	* Rest of the transactions are synchronous anyway.
	102	*/
	103	struct slim_val_inf {
	104	u16 start_offset;
	105	u8 num_bytes;
	106	u8 *rbuf;
	107	const u8 *wbuf;
	108	struct completion *comp;
	109	};
	110
3648e78e SD	111	/*
	112	* use a macro to avoid include chaining to get THIS_MODULE
	113	*/
	114	#define slim_driver_register(drv) \
	115	__slim_driver_register(drv, THIS_MODULE)
	116	int __slim_driver_register(struct slim_driver drv, struct module owner);
	117	void slim_driver_unregister(struct slim_driver *drv);
	118
	119	/**
	120	* module_slim_driver() - Helper macro for registering a SLIMbus driver
	121	* @__slim_driver: slimbus_driver struct
	122	*
	123	* Helper macro for SLIMbus drivers which do not do anything special in module
	124	* init/exit. This eliminates a lot of boilerplate. Each module may only
	125	* use this macro once, and calling it replaces module_init() and module_exit()
	126	*/
	127	#define module_slim_driver(__slim_driver) \
	128	module_driver(__slim_driver, slim_driver_register, \
	129	slim_driver_unregister)
	130
	131	static inline void slim_get_devicedata(const struct slim_device dev)
	132	{
	133	return dev_get_drvdata(&dev->dev);
	134	}
	135
	136	static inline void slim_set_devicedata(struct slim_device dev, void data)
	137	{
	138	dev_set_drvdata(&dev->dev, data);
	139	}
46a2bb5a SD	140
	141	struct slim_device slim_get_device(struct slim_controller ctrl,
	142	struct slim_eaddr *e_addr);
	143	int slim_get_logical_addr(struct slim_device *sbdev);
afbdcc7c SD	144
	145	/* Information Element management messages */
	146	#define SLIM_MSG_MC_REQUEST_INFORMATION 0x20
	147	#define SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION 0x21
	148	#define SLIM_MSG_MC_REPLY_INFORMATION 0x24
	149	#define SLIM_MSG_MC_CLEAR_INFORMATION 0x28
	150	#define SLIM_MSG_MC_REPORT_INFORMATION 0x29
	151
	152	/* Value Element management messages */
	153	#define SLIM_MSG_MC_REQUEST_VALUE 0x60
	154	#define SLIM_MSG_MC_REQUEST_CHANGE_VALUE 0x61
	155	#define SLIM_MSG_MC_REPLY_VALUE 0x64
	156	#define SLIM_MSG_MC_CHANGE_VALUE 0x68
	157
	158	int slim_xfer_msg(struct slim_device sbdev, struct slim_val_inf msg,
	159	u8 mc);
	160	int slim_readb(struct slim_device *sdev, u32 addr);
	161	int slim_writeb(struct slim_device *sdev, u32 addr, u8 value);
	162	int slim_read(struct slim_device sdev, u32 addr, size_t count, u8 val);
	163	int slim_write(struct slim_device sdev, u32 addr, size_t count, u8 val);
3648e78e	164	#endif /* _LINUX_SLIMBUS_H */