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

/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2021 Intel Corporation */

#ifndef __LINUX_PECI_H
#define __LINUX_PECI_H

#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/types.h>

/*
 * Currently we don't support any PECI command over 32 bytes.
 */
#define PECI_REQUEST_MAX_BUF_SIZE 32

struct peci_controller;
struct peci_request;

/**
 * struct peci_controller_ops - PECI controller specific methods
 * @xfer: PECI transfer function
 *
 * PECI controllers may have different hardware interfaces - the drivers
 * implementing PECI controllers can use this structure to abstract away those
 * differences by exposing a common interface for PECI core.
 */
struct peci_controller_ops {
	int (*xfer)(struct peci_controller *controller, u8 addr, struct peci_request *req);
};

/**
 * struct peci_controller - PECI controller
 * @dev: device object to register PECI controller to the device model
 * @ops: pointer to device specific controller operations
 * @bus_lock: lock used to protect multiple callers
 * @id: PECI controller ID
 *
 * PECI controllers usually connect to their drivers using non-PECI bus,
 * such as the platform bus.
 * Each PECI controller can communicate with one or more PECI devices.
 */
struct peci_controller {
	struct device dev;
	const struct peci_controller_ops *ops;
	struct mutex bus_lock; /* held for the duration of xfer */
	u8 id;
};

struct peci_controller *devm_peci_controller_add(struct device *parent,
						 const struct peci_controller_ops *ops);

static inline struct peci_controller *to_peci_controller(void *d)
{
	return container_of(d, struct peci_controller, dev);
}

/**
 * struct peci_device - PECI device
 * @dev: device object to register PECI device to the device model
 * @info: PECI device characteristics
 * @info.x86_vfm: device vendor-family-model
 * @info.peci_revision: PECI revision supported by the PECI device
 * @info.socket_id: the socket ID represented by the PECI device
 * @addr: address used on the PECI bus connected to the parent controller
 * @deleted: indicates that PECI device was already deleted
 *
 * A peci_device identifies a single device (i.e. CPU) connected to a PECI bus.
 * The behaviour exposed to the rest of the system is defined by the PECI driver
 * managing the device.
 */
struct peci_device {
	struct device dev;
	struct {
		u32 x86_vfm;
		u8 peci_revision;
		u8 socket_id;
	} info;
	u8 addr;
	bool deleted;
};

static inline struct peci_device *to_peci_device(struct device *d)
{
	return container_of(d, struct peci_device, dev);
}

/**
 * struct peci_request - PECI request
 * @device: PECI device to which the request is sent
 * @tx: TX buffer specific data
 * @tx.buf: TX buffer
 * @tx.len: transfer data length in bytes
 * @rx: RX buffer specific data
 * @rx.buf: RX buffer
 * @rx.len: received data length in bytes
 *
 * A peci_request represents a request issued by PECI originator (TX) and
 * a response received from PECI responder (RX).
 */
struct peci_request {
	struct peci_device *device;
	struct {
		u8 buf[PECI_REQUEST_MAX_BUF_SIZE];
		u8 len;
	} rx, tx;
};

#endif /* __LINUX_PECI_H */
Commit	Line	Data
6523d3b2 IW	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2	/* Copyright (c) 2018-2021 Intel Corporation */
	3
	4	#ifndef __LINUX_PECI_H
	5	#define __LINUX_PECI_H
	6
	7	#include <linux/device.h>
	8	#include <linux/kernel.h>
	9	#include <linux/mutex.h>
	10	#include <linux/types.h>
	11
	12	/*
	13	* Currently we don't support any PECI command over 32 bytes.
	14	*/
	15	#define PECI_REQUEST_MAX_BUF_SIZE 32
	16
	17	struct peci_controller;
	18	struct peci_request;
	19
	20	/**
	21	* struct peci_controller_ops - PECI controller specific methods
	22	* @xfer: PECI transfer function
	23	*
	24	* PECI controllers may have different hardware interfaces - the drivers
	25	* implementing PECI controllers can use this structure to abstract away those
	26	* differences by exposing a common interface for PECI core.
	27	*/
	28	struct peci_controller_ops {
	29	int (xfer)(struct peci_controller controller, u8 addr, struct peci_request *req);
	30	};
	31
	32	/**
	33	* struct peci_controller - PECI controller
	34	* @dev: device object to register PECI controller to the device model
	35	* @ops: pointer to device specific controller operations
	36	* @bus_lock: lock used to protect multiple callers
	37	* @id: PECI controller ID
	38	*
	39	* PECI controllers usually connect to their drivers using non-PECI bus,
	40	* such as the platform bus.
	41	* Each PECI controller can communicate with one or more PECI devices.
	42	*/
	43	struct peci_controller {
	44	struct device dev;
8306d6f3	45	const struct peci_controller_ops *ops;
6523d3b2 IW	46	struct mutex bus_lock; /* held for the duration of xfer */
	47	u8 id;
	48	};
	49
	50	struct peci_controller devm_peci_controller_add(struct device parent,
8306d6f3	51	const struct peci_controller_ops *ops);
6523d3b2 IW	52
	53	static inline struct peci_controller to_peci_controller(void d)
	54	{
	55	return container_of(d, struct peci_controller, dev);
	56	}
	57
	58	/**
	59	* struct peci_device - PECI device
	60	* @dev: device object to register PECI device to the device model
6b8145b0	61	* @info: PECI device characteristics
a43b9ec0	62	* @info.x86_vfm: device vendor-family-model
6b8145b0 IW	63	* @info.peci_revision: PECI revision supported by the PECI device
6b8145b0 IW	64	* @info.socket_id: the socket ID represented by the PECI device
6523d3b2	65	* @addr: address used on the PECI bus connected to the parent controller
52857e68	66	* @deleted: indicates that PECI device was already deleted
6523d3b2 IW	67	*
	68	* A peci_device identifies a single device (i.e. CPU) connected to a PECI bus.
	69	* The behaviour exposed to the rest of the system is defined by the PECI driver
	70	* managing the device.
	71	*/
	72	struct peci_device {
	73	struct device dev;
6b8145b0	74	struct {
a43b9ec0	75	u32 x86_vfm;
6b8145b0 IW	76	u8 peci_revision;
	77	u8 socket_id;
	78	} info;
6523d3b2	79	u8 addr;
52857e68	80	bool deleted;
6523d3b2 IW	81	};
	82
	83	static inline struct peci_device to_peci_device(struct device d)
	84	{
	85	return container_of(d, struct peci_device, dev);
	86	}
	87
	88	/**
	89	* struct peci_request - PECI request
	90	* @device: PECI device to which the request is sent
	91	* @tx: TX buffer specific data
	92	* @tx.buf: TX buffer
	93	* @tx.len: transfer data length in bytes
	94	* @rx: RX buffer specific data
	95	* @rx.buf: RX buffer
	96	* @rx.len: received data length in bytes
	97	*
	98	* A peci_request represents a request issued by PECI originator (TX) and
	99	* a response received from PECI responder (RX).
	100	*/
	101	struct peci_request {
	102	struct peci_device *device;
	103	struct {
	104	u8 buf[PECI_REQUEST_MAX_BUF_SIZE];
	105	u8 len;
	106	} rx, tx;
	107	};
	108
	109	#endif /* __LINUX_PECI_H */