LXR linux/include/linux/slimbus.h

   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>
  10#include <linux/completion.h>
  11#include <linux/mod_devicetable.h>
  12
  13extern struct bus_type slimbus_bus;
  14
  15/**
  16 * struct slim_eaddr - Enumeration address for a SLIMbus device
  17 * @instance: Instance value
  18 * @dev_index: Device index
  19 * @prod_code: Product code
  20 * @manf_id: Manufacturer Id for the device
  21 */
  22struct slim_eaddr {
  23        u8 instance;
  24        u8 dev_index;
  25        u16 prod_code;
  26        u16 manf_id;
  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 */
  35enum slim_device_status {
  36        SLIM_DEVICE_STATUS_DOWN = 0,
  37        SLIM_DEVICE_STATUS_UP,
  38        SLIM_DEVICE_STATUS_RESERVED,
  39};
  40
  41struct slim_controller;
  42
  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
  48 * @ctrl: slim controller instance.
  49 * @laddr: 1-byte Logical address of this device.
  50 * @is_laddr_valid: indicates if the laddr is valid or not
  51 * @stream_list: List of streams on this device
  52 * @stream_list_lock: lock to protect the stream list
  53 *
  54 * This is the client/device handle returned when a SLIMbus
  55 * device is registered with a controller.
  56 * Pointer to this structure is used by client-driver as a handle.
  57 */
  58struct slim_device {
  59        struct device           dev;
  60        struct slim_eaddr       e_addr;
  61        struct slim_controller  *ctrl;
  62        enum slim_device_status status;
  63        u8                      laddr;
  64        bool                    is_laddr_valid;
  65        struct list_head        stream_list;
  66        spinlock_t stream_list_lock;
  67};
  68
  69#define to_slim_device(d) container_of(d, struct slim_device, dev)
  70
  71/**
  72 * struct slim_driver - SLIMbus 'generic device' (slave) device driver
  73 *                              (similar to 'spi_device' on SPI)
  74 * @probe: Binds this driver to a SLIMbus device.
  75 * @remove: Unbinds this driver from the SLIMbus device.
  76 * @shutdown: Standard shutdown callback used during powerdown/halt.
  77 * @device_status: This callback is called when
  78 *      - The device reports present and gets a laddr assigned
  79 *      - The device reports absent, or the bus goes down.
  80 * @driver: SLIMbus device drivers should initialize name and owner field of
  81 *          this structure
  82 * @id_table: List of SLIMbus devices supported by this driver
  83 */
  84
  85struct slim_driver {
  86        int     (*probe)(struct slim_device *sl);
  87        void    (*remove)(struct slim_device *sl);
  88        void    (*shutdown)(struct slim_device *sl);
  89        int     (*device_status)(struct slim_device *sl,
  90                                 enum slim_device_status s);
  91        struct device_driver            driver;
  92        const struct slim_device_id     *id_table;
  93};
  94#define to_slim_driver(d) container_of(d, struct slim_driver, driver)
  95
  96/**
  97 * struct slim_val_inf - Slimbus value or information element
  98 * @start_offset: Specifies starting offset in information/value element map
  99 * @rbuf: buffer to read the values
 100 * @wbuf: buffer to write
 101 * @num_bytes: upto 16. This ensures that the message will fit the slicesize
 102 *              per SLIMbus spec
 103 * @comp: completion for asynchronous operations, valid only if TID is
 104 *        required for transaction, like REQUEST operations.
 105 *        Rest of the transactions are synchronous anyway.
 106 */
 107struct slim_val_inf {
 108        u16                     start_offset;
 109        u8                      num_bytes;
 110        u8                      *rbuf;
 111        const u8                *wbuf;
 112        struct  completion      *comp;
 113};
 114
 115#define SLIM_DEVICE_MAX_CHANNELS        256
 116/* A SLIMBus Device may have frmo 0 to 31 Ports (inclusive) */
 117#define SLIM_DEVICE_MAX_PORTS           32
 118
 119/**
 120 * struct slim_stream_config - SLIMbus stream configuration
 121 *      Configuring a stream is done at hw_params or prepare call
 122 *      from audio drivers where they have all the required information
 123 *      regarding rate, number of channels and so on.
 124 *      There is a 1:1 mapping of channel and ports.
 125 *
 126 * @rate: data rate
 127 * @bps: bits per data sample
 128 * @ch_count: number of channels
 129 * @chs: pointer to list of channel numbers
 130 * @port_mask: port mask of ports to use for this stream
 131 * @direction: direction of the stream, SNDRV_PCM_STREAM_PLAYBACK
 132 *      or SNDRV_PCM_STREAM_CAPTURE.
 133 */
 134struct slim_stream_config {
 135        unsigned int rate;
 136        unsigned int bps;
 137        /* MAX 256 channels */
 138        unsigned int ch_count;
 139        unsigned int *chs;
 140        /* Max 32 ports per device */
 141        unsigned long port_mask;
 142        int direction;
 143};
 144
 145/*
 146 * use a macro to avoid include chaining to get THIS_MODULE
 147 */
 148#define slim_driver_register(drv) \
 149        __slim_driver_register(drv, THIS_MODULE)
 150int __slim_driver_register(struct slim_driver *drv, struct module *owner);
 151void slim_driver_unregister(struct slim_driver *drv);
 152
 153/**
 154 * module_slim_driver() - Helper macro for registering a SLIMbus driver
 155 * @__slim_driver: slimbus_driver struct
 156 *
 157 * Helper macro for SLIMbus drivers which do not do anything special in module
 158 * init/exit. This eliminates a lot of boilerplate. Each module may only
 159 * use this macro once, and calling it replaces module_init() and module_exit()
 160 */
 161#define module_slim_driver(__slim_driver) \
 162        module_driver(__slim_driver, slim_driver_register, \
 163                        slim_driver_unregister)
 164
 165static inline void *slim_get_devicedata(const struct slim_device *dev)
 166{
 167        return dev_get_drvdata(&dev->dev);
 168}
 169
 170static inline void slim_set_devicedata(struct slim_device *dev, void *data)
 171{
 172        dev_set_drvdata(&dev->dev, data);
 173}
 174
 175struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
 176                                       struct device_node *np);
 177struct slim_device *slim_get_device(struct slim_controller *ctrl,
 178                                    struct slim_eaddr *e_addr);
 179int slim_get_logical_addr(struct slim_device *sbdev);
 180
 181/* Information Element management messages */
 182#define SLIM_MSG_MC_REQUEST_INFORMATION          0x20
 183#define SLIM_MSG_MC_REQUEST_CLEAR_INFORMATION    0x21
 184#define SLIM_MSG_MC_REPLY_INFORMATION            0x24
 185#define SLIM_MSG_MC_CLEAR_INFORMATION            0x28
 186#define SLIM_MSG_MC_REPORT_INFORMATION           0x29
 187
 188/* Value Element management messages */
 189#define SLIM_MSG_MC_REQUEST_VALUE                0x60
 190#define SLIM_MSG_MC_REQUEST_CHANGE_VALUE         0x61
 191#define SLIM_MSG_MC_REPLY_VALUE                  0x64
 192#define SLIM_MSG_MC_CHANGE_VALUE                 0x68
 193
 194int slim_xfer_msg(struct slim_device *sbdev, struct slim_val_inf *msg,
 195                  u8 mc);
 196int slim_readb(struct slim_device *sdev, u32 addr);
 197int slim_writeb(struct slim_device *sdev, u32 addr, u8 value);
 198int slim_read(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
 199int slim_write(struct slim_device *sdev, u32 addr, size_t count, u8 *val);
 200
 201/* SLIMbus Stream apis */
 202struct slim_stream_runtime;
 203struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev,
 204                                                 const char *sname);
 205int slim_stream_prepare(struct slim_stream_runtime *stream,
 206                        struct slim_stream_config *c);
 207int slim_stream_enable(struct slim_stream_runtime *stream);
 208int slim_stream_disable(struct slim_stream_runtime *stream);
 209int slim_stream_unprepare(struct slim_stream_runtime *stream);
 210int slim_stream_free(struct slim_stream_runtime *stream);
 211
 212#endif /* _LINUX_SLIMBUS_H */
 213