280 lines
9.2 KiB
C
280 lines
9.2 KiB
C
|
/****************************************************************************
|
||
|
|
*
|
||
|
|
* Copyright (c) 2014 - 2019 Samsung Electronics Co., Ltd. All rights reserved
|
||
|
|
*
|
||
|
|
****************************************************************************/
|
||
|
|
|
||
|
|
|
||
|
|
#include <linux/init.h>
|
||
|
|
#include <linux/kernel.h>
|
||
|
|
#include <linux/cdev.h>
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/uaccess.h> /* Required for copy_to_user. */
|
||
|
|
#include <linux/completion.h>
|
||
|
|
#include <linux/atomic.h>
|
||
|
|
|
||
|
|
#include <scsc/scsc_logring.h>
|
||
|
|
|
||
|
|
#include "mxman.h"
|
||
|
|
#include "mxmgmt_transport_format.h" /* Required for MXMGR_MESSAGE_PAYLOAD_SIZE. */
|
||
|
|
|
||
|
|
#define DEVICE_NAME "lerna"
|
||
|
|
#define DEVICE_CLASS "scsc_config"
|
||
|
|
#define DEVICE_COUNT (1)
|
||
|
|
|
||
|
|
static const void *scsc_lerna_pending;
|
||
|
|
#define SCSC_LERNA_WAIT_TIMEOUT (2000)
|
||
|
|
static DECLARE_COMPLETION(scsc_lerna_wait);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* MSMGR_MESSAGE_PAYLOAD_SIZE is not a nice power of 2, so use sizeof(msmgr_message)
|
||
|
|
* just for something more aesthetically pleasing.
|
||
|
|
*/
|
||
|
|
#define SCSC_LERNA_BUFFER_SIZE (sizeof(struct mxmgr_message))
|
||
|
|
static uint8_t scsc_lerna_request_buffer[SCSC_LERNA_BUFFER_SIZE];
|
||
|
|
static uint8_t scsc_lerna_response_buffer[SCSC_LERNA_BUFFER_SIZE];
|
||
|
|
|
||
|
|
static dev_t scsc_lerna_device_id;
|
||
|
|
static struct class *scsc_lerna_class_p;
|
||
|
|
static struct device *scsc_lerna_device_p;
|
||
|
|
static struct cdev scsc_lerna_cdev;
|
||
|
|
|
||
|
|
static int scsc_lerna_chardev_open(struct inode *inodep, struct file *filep);
|
||
|
|
static ssize_t scsc_lerna_chardev_read(struct file *filep, char *buffer, size_t len, loff_t *offset);
|
||
|
|
static ssize_t scsc_lerna_chardev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset);
|
||
|
|
static int scsc_lerna_chardev_release(struct inode *inodep, struct file *filep);
|
||
|
|
|
||
|
|
static struct file_operations scsc_lerna_fops = {
|
||
|
|
.open = scsc_lerna_chardev_open,
|
||
|
|
.read = scsc_lerna_chardev_read,
|
||
|
|
.write = scsc_lerna_chardev_write,
|
||
|
|
.release = scsc_lerna_chardev_release,
|
||
|
|
};
|
||
|
|
|
||
|
|
static atomic_t scsc_lerna_atomic;
|
||
|
|
|
||
|
|
struct scsc_lerna_cmd_header {
|
||
|
|
uint8_t magic_number; /* Set to 0x08. */
|
||
|
|
uint8_t cid; /* Action command identifier. */
|
||
|
|
uint16_t payload_length; /* Payload length. 0 for value query. */
|
||
|
|
uint16_t psid; /* PSID to query. */
|
||
|
|
uint8_t row_index; /* Row index, or 0 for non-table querying. */
|
||
|
|
uint8_t group_index; /* Group index, or 0 for default (group not assigned). */
|
||
|
|
};
|
||
|
|
|
||
|
|
static int scsc_lerna_chardev_open(struct inode *inodep, struct file *filep)
|
||
|
|
{
|
||
|
|
(void)inodep;
|
||
|
|
(void)filep;
|
||
|
|
|
||
|
|
if (atomic_inc_return(&scsc_lerna_atomic) > 1) {
|
||
|
|
atomic_dec(&scsc_lerna_atomic);
|
||
|
|
/* Someone already has this open. Denied. */
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "character device busy, try again later.\n");
|
||
|
|
return -EBUSY;
|
||
|
|
}
|
||
|
|
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "opening lerna character device.\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t scsc_lerna_chardev_read(struct file *filep, char *buffer, size_t len, loff_t *offset)
|
||
|
|
{
|
||
|
|
const struct scsc_lerna_cmd_header *header;
|
||
|
|
unsigned long wait_result;
|
||
|
|
ssize_t read_count;
|
||
|
|
int error_count;
|
||
|
|
|
||
|
|
(void)filep;
|
||
|
|
(void)offset;
|
||
|
|
|
||
|
|
wait_result = wait_for_completion_timeout(&scsc_lerna_wait, msecs_to_jiffies(SCSC_LERNA_WAIT_TIMEOUT));
|
||
|
|
if (wait_result == 0) {
|
||
|
|
SCSC_TAG_ERR(LERNA, "read timeout; firmware not responding, or read without write.\n");
|
||
|
|
return -ETIMEDOUT;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!scsc_lerna_pending) {
|
||
|
|
/* Pointer is NULL, indicating that a reply hasn't been sent from firmware. */
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "pending reply is null.\n");
|
||
|
|
return -ENOMSG;
|
||
|
|
}
|
||
|
|
|
||
|
|
header = (const struct scsc_lerna_cmd_header *)(scsc_lerna_pending);
|
||
|
|
read_count = sizeof(struct scsc_lerna_cmd_header) + header->payload_length;
|
||
|
|
|
||
|
|
/* Make sure there's enough space to read out the buffer. */
|
||
|
|
if (len < read_count) {
|
||
|
|
SCSC_TAG_ERR(LERNA, "insufficient buffer space supplied for read.\n");
|
||
|
|
return -ENOBUFS;
|
||
|
|
}
|
||
|
|
|
||
|
|
error_count = copy_to_user(buffer, scsc_lerna_pending, read_count);
|
||
|
|
|
||
|
|
if (error_count) {
|
||
|
|
SCSC_TAG_ERR(LERNA, "could not read from lerna character device.\n");
|
||
|
|
return -EFAULT;
|
||
|
|
}
|
||
|
|
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "read buffer of size: %lu\n", read_count);
|
||
|
|
/* Value was read out, and is no longer considered valid. Need to write before another read. */
|
||
|
|
scsc_lerna_pending = NULL;
|
||
|
|
return read_count;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ssize_t scsc_lerna_chardev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset)
|
||
|
|
{
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "writing buffer of size: %lu\n", len);
|
||
|
|
/* At a minimum, any request (read or write) must include a command header. */
|
||
|
|
if (len >= sizeof(struct scsc_lerna_cmd_header)) {
|
||
|
|
/* Header at least fits, but maybe a write value wants more... */
|
||
|
|
if (len <= SCSC_LERNA_BUFFER_SIZE) {
|
||
|
|
if (copy_from_user(scsc_lerna_request_buffer, buffer, len)) {
|
||
|
|
SCSC_TAG_ERR(LERNA, "copy_from_user failed.\n");
|
||
|
|
return -EFAULT;
|
||
|
|
}
|
||
|
|
mxman_lerna_send(NULL, scsc_lerna_request_buffer, len);
|
||
|
|
} else {
|
||
|
|
/* Message size too long, don't write anything. */
|
||
|
|
return -EMSGSIZE;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
return -EBADR;
|
||
|
|
}
|
||
|
|
|
||
|
|
return len;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int scsc_lerna_chardev_release(struct inode *inodep, struct file *filep)
|
||
|
|
{
|
||
|
|
(void)inodep;
|
||
|
|
(void)filep;
|
||
|
|
if (atomic_read(&scsc_lerna_atomic) == 0) {
|
||
|
|
SCSC_TAG_ALERT(LERNA, "character device release without open.\n");
|
||
|
|
} else {
|
||
|
|
/* Done with the character device, release the lock on it. */
|
||
|
|
atomic_dec(&scsc_lerna_atomic);
|
||
|
|
}
|
||
|
|
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "lerna character device closed.\n");
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int scsc_lerna_init(void)
|
||
|
|
{
|
||
|
|
int result;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Reset important globals to some kind of sane value. This should be done
|
||
|
|
* whenever the module is loaded explicitly to be sure global values haven't
|
||
|
|
* been previously trashed.
|
||
|
|
*/
|
||
|
|
scsc_lerna_device_id = 0;
|
||
|
|
scsc_lerna_class_p = NULL;
|
||
|
|
scsc_lerna_device_p = NULL;
|
||
|
|
|
||
|
|
/* Make sure to initialise the atomic used to lock char device access. */
|
||
|
|
atomic_set(&scsc_lerna_atomic, 0);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Allocate device id(s) for the character device. Use alloc_register_chrdev
|
||
|
|
* because this is the new way of doing things, and it will dynamically allocate
|
||
|
|
* a major number. Returns non-zero on failure.
|
||
|
|
*/
|
||
|
|
result = alloc_chrdev_region(&scsc_lerna_device_id, 0, DEVICE_COUNT, DEVICE_NAME);
|
||
|
|
if (result) {
|
||
|
|
/* Failure to register char dev, auto fail to initialise module. */
|
||
|
|
SCSC_TAG_ALERT(LERNA, "lerna failed to register character device.\n");
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
scsc_lerna_class_p = class_create(THIS_MODULE, DEVICE_CLASS);
|
||
|
|
if (IS_ERR(scsc_lerna_class_p)) {
|
||
|
|
/* Could not create class, failure, remember to unregister device id(s). */
|
||
|
|
unregister_chrdev_region(scsc_lerna_device_id, DEVICE_COUNT);
|
||
|
|
SCSC_TAG_ALERT(LERNA, "lerna failed to create character class.\n");
|
||
|
|
return PTR_ERR(scsc_lerna_class_p);
|
||
|
|
}
|
||
|
|
|
||
|
|
scsc_lerna_device_p = device_create(scsc_lerna_class_p, NULL, scsc_lerna_device_id, NULL, DEVICE_NAME);
|
||
|
|
if (IS_ERR(scsc_lerna_device_p)) {
|
||
|
|
class_destroy(scsc_lerna_class_p);
|
||
|
|
unregister_chrdev_region(scsc_lerna_device_id, DEVICE_COUNT);
|
||
|
|
SCSC_TAG_ALERT(LERNA, "lerna failed to create character device.\n");
|
||
|
|
return PTR_ERR(scsc_lerna_device_p);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* At this point, the device is registered, along with class definition. The character device
|
||
|
|
* itself can now be initialised to provide the kernel with callback information for various
|
||
|
|
* actions taken on the device.
|
||
|
|
*/
|
||
|
|
cdev_init(&scsc_lerna_cdev, &scsc_lerna_fops);
|
||
|
|
scsc_lerna_cdev.owner = THIS_MODULE;
|
||
|
|
|
||
|
|
result = cdev_add(&scsc_lerna_cdev, scsc_lerna_device_id, DEVICE_COUNT);
|
||
|
|
if (result) {
|
||
|
|
/* Failure to add character device to file system. */
|
||
|
|
cdev_del(&scsc_lerna_cdev);
|
||
|
|
class_destroy(scsc_lerna_class_p);
|
||
|
|
unregister_chrdev_region(scsc_lerna_device_id, DEVICE_COUNT);
|
||
|
|
SCSC_TAG_ALERT(LERNA, "lerna failed to add character device.\n");
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
/* At this point, the cdev is live and can be used. */
|
||
|
|
|
||
|
|
SCSC_TAG_INFO(LERNA, "lerna intialisation complete.\n");
|
||
|
|
return 0; /* 0 for module loaded, non-zero for module load failure. */
|
||
|
|
}
|
||
|
|
|
||
|
|
void scsc_lerna_deinit(void)
|
||
|
|
{
|
||
|
|
/* Character device needs deleting. */
|
||
|
|
cdev_del(&scsc_lerna_cdev);
|
||
|
|
|
||
|
|
/* Destroy device. */
|
||
|
|
device_destroy(scsc_lerna_class_p, scsc_lerna_device_id);
|
||
|
|
|
||
|
|
/* Unregister the device class. Not sure if this means that a register earlier is required. */
|
||
|
|
class_unregister(scsc_lerna_class_p);
|
||
|
|
|
||
|
|
/* Destroy created class. Be careful of the order this is called in. */
|
||
|
|
class_destroy(scsc_lerna_class_p);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Don't forget to unregister device id(s). Major number is dynamically allocated,
|
||
|
|
* so the base id is remembered and passed along to the unregister here.
|
||
|
|
*/
|
||
|
|
unregister_chrdev_region(scsc_lerna_device_id, DEVICE_COUNT);
|
||
|
|
|
||
|
|
SCSC_TAG_INFO(LERNA, "lerna shutdown complete.\n");
|
||
|
|
}
|
||
|
|
|
||
|
|
void scsc_lerna_response(const void *message)
|
||
|
|
{
|
||
|
|
/**
|
||
|
|
* Buffer the response from the firmware so that future messages from firmware
|
||
|
|
* don't overwrite this accidentally. This means async messages are allowed while
|
||
|
|
* waiting for the character device read from userspace, without impacting lerna's
|
||
|
|
* request/response communications.
|
||
|
|
*/
|
||
|
|
const struct scsc_lerna_cmd_header *header;
|
||
|
|
ssize_t read_count;
|
||
|
|
|
||
|
|
if (message != NULL) {
|
||
|
|
header = (const struct scsc_lerna_cmd_header *)(message);
|
||
|
|
read_count = sizeof(struct scsc_lerna_cmd_header) + header->payload_length;
|
||
|
|
|
||
|
|
if (read_count <= SCSC_LERNA_BUFFER_SIZE) {
|
||
|
|
memcpy(scsc_lerna_response_buffer, message, read_count);
|
||
|
|
scsc_lerna_pending = scsc_lerna_response_buffer;
|
||
|
|
} else {
|
||
|
|
SCSC_TAG_DEBUG(LERNA, "readout too large for response buffering.\n");
|
||
|
|
/* No response possible, let the userspace application deal with it. */
|
||
|
|
scsc_lerna_pending = NULL;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
complete(&scsc_lerna_wait);
|
||
|
|
}
|