mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
212 lines
6.9 KiB
212 lines
6.9 KiB
// 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 |
|
* @instance: Instance value |
|
* @dev_index: Device index |
|
* @prod_code: Product code |
|
* @manf_id: Manufacturer Id for the device |
|
*/ |
|
struct slim_eaddr { |
|
u8 instance; |
|
u8 dev_index; |
|
u16 prod_code; |
|
u16 manf_id; |
|
} __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 |
|
* @stream_list: List of streams on this device |
|
* @stream_list_lock: lock to protect the stream list |
|
* |
|
* 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; |
|
struct list_head stream_list; |
|
spinlock_t stream_list_lock; |
|
}; |
|
|
|
#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; |
|
}; |
|
|
|
#define SLIM_DEVICE_MAX_CHANNELS 256 |
|
/* A SLIMBus Device may have frmo 0 to 31 Ports (inclusive) */ |
|
#define SLIM_DEVICE_MAX_PORTS 32 |
|
|
|
/** |
|
* struct slim_stream_config - SLIMbus stream configuration |
|
* Configuring a stream is done at hw_params or prepare call |
|
* from audio drivers where they have all the required information |
|
* regarding rate, number of channels and so on. |
|
* There is a 1:1 mapping of channel and ports. |
|
* |
|
* @rate: data rate |
|
* @bps: bits per data sample |
|
* @ch_count: number of channels |
|
* @chs: pointer to list of channel numbers |
|
* @port_mask: port mask of ports to use for this stream |
|
* @direction: direction of the stream, SNDRV_PCM_STREAM_PLAYBACK |
|
* or SNDRV_PCM_STREAM_CAPTURE. |
|
*/ |
|
struct slim_stream_config { |
|
unsigned int rate; |
|
unsigned int bps; |
|
/* MAX 256 channels */ |
|
unsigned int ch_count; |
|
unsigned int *chs; |
|
/* Max 32 ports per device */ |
|
unsigned long port_mask; |
|
int direction; |
|
}; |
|
|
|
/* |
|
* 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 *of_slim_get_device(struct slim_controller *ctrl, |
|
struct device_node *np); |
|
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); |
|
|
|
/* SLIMbus Stream apis */ |
|
struct slim_stream_runtime; |
|
struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev, |
|
const char *sname); |
|
int slim_stream_prepare(struct slim_stream_runtime *stream, |
|
struct slim_stream_config *c); |
|
int slim_stream_enable(struct slim_stream_runtime *stream); |
|
int slim_stream_disable(struct slim_stream_runtime *stream); |
|
int slim_stream_unprepare(struct slim_stream_runtime *stream); |
|
int slim_stream_free(struct slim_stream_runtime *stream); |
|
|
|
#endif /* _LINUX_SLIMBUS_H */
|
|
|