AetherDroid/android_kernel_samsung_on5xelte
1
0
Fork 0
mirror of https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git synced 2025-09-08 17:18:05 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
android_kernel_samsung_on5x.../drivers/net/wireless/scsc/hip4_sampler.c
awab228 f6dfaef42e Fixed MTP to work with TWRP
2018-06-19 23:16:04 +02:00

578 lines
17 KiB
C
Raw Permalink Blame History

/*****************************************************************************
*
* Copyright (c) 2014 - 2016 Samsung Electronics Co., Ltd. All rights reserved
*
****************************************************************************/
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kfifo.h>
#include <linux/poll.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/version.h>
#include <linux/hardirq.h>
#include <linux/ktime.h>
#include <linux/hrtimer.h>
#include <asm/page.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <scsc/scsc_mx.h>
#include <linux/delay.h>
#include <linux/mutex.h>
#include "hip4_sampler.h"
#include "debug.h"
struct hip4_record {
u32 record_num;
ktime_t ts;
u32 record;
} __packed;
static bool hip4_sampler_enable;
module_param(hip4_sampler_enable, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_enable, "Enable hip4_sampler_enable. Run-time option - (default: N)");
static int hip4_sampler_kfifo_len = 256 * 1024;
module_param(hip4_sampler_kfifo_len, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_kfifo_len, "Streaming fifo buffer length in num of records- default: 262144 Max: 262144. Loaded at /dev open");
static int hip4_sampler_static_kfifo_len = 256 * 1024;
module_param(hip4_sampler_static_kfifo_len, int, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_static_kfifo_len, "Offline fifo buffer length in num of records- default: 262144 Max: 262144. Loaded at /dev open");
bool hip4_sampler_sample_q = true;
module_param(hip4_sampler_sample_q, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_q, "Sample Queues. Default: Y. Run time option");
bool hip4_sampler_sample_qref = true;
module_param(hip4_sampler_sample_qref, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_qref, "Sample Queue References. Default: Y. Run time option");
bool hip4_sampler_sample_int = true;
module_param(hip4_sampler_sample_int, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_int, "Sample WQ/Tasklet Intr BH in/out. Default: Y. Run time option");
bool hip4_sampler_sample_fapi = true;
module_param(hip4_sampler_sample_fapi, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_fapi, "Sample FAPI ctrl signals. Default: Y. Run time option");
bool hip4_sampler_sample_through = true;
module_param(hip4_sampler_sample_through, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_through, "Sample throughput. Default: Y. Run time option");
bool hip4_sampler_sample_start_stop_q = true;
module_param(hip4_sampler_sample_start_stop_q , bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_start_stop_q , "Sample Stop/Start queues. Default: Y. Run time option");
bool hip4_sampler_sample_mbulk = true;
module_param(hip4_sampler_sample_mbulk, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_mbulk, "Sample Mbulk counter. Default: Y. Run time option");
bool hip4_sampler_sample_qfull;
module_param(hip4_sampler_sample_qfull, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_qfull, "Sample Q full event. Default: N. Run time option");
bool hip4_sampler_sample_mfull = true;
module_param(hip4_sampler_sample_mfull, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_sample_mfull, "Sample Mbulk full event. Default: Y. Run time option");
bool hip4_sampler_vif = true;
module_param(hip4_sampler_vif, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_vif, "Sample VIF. Default: Y. Run time option");
bool hip4_sampler_bot = true;
module_param(hip4_sampler_bot, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_bot, "Sample BOT. Default: Y. Run time option");
bool hip4_sampler_pkt_tx = true;
module_param(hip4_sampler_pkt_tx, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(hip4_sampler_pkt_tx, "Track TX Data packet TX->HIP4->FB. Default: Y. Run time option");
#define DRV_NAME "hip4_sampler"
#define DEVICE_NAME "hip4_sampler"
#ifndef VM_RESERVED
#define VM_RESERVED (VM_DONTEXPAND | VM_DONTDUMP)
#endif
#define VER_MAJOR 0
#define VER_MINOR 0
DECLARE_BITMAP(bitmap_hip4_sampler_minor, SCSC_HIP4_DEBUG_INTERFACES);
enum hip4_dg_errors {
NO_ERROR = 0,
BUFFER_OVERFLOW,
KFIFO_ERROR,
KFIFO_FULL,
};
enum hip4_type {
STREAMING = 0,
OFFLINE,
};
struct hip4_sampler_dev {
/* file pointer */
struct file *filp;
/* char device */
struct cdev cdev;
/*device pointer*/
struct device *dev;
/*mx pointer*/
struct scsc_mx *mx;
/* Associated kfifo */
DECLARE_KFIFO_PTR(fifo, struct hip4_record);
/* Associated read_wait queue.*/
wait_queue_head_t read_wait;
/* Device in error */
enum hip4_dg_errors error;
/* Device node spinlock for IRQ */
spinlock_t spinlock;
/* Device node mutex for fops */
struct mutex mutex;
/* Record number */
u32 record_num;
/* To profile kfifo num elements */
u32 kfifo_max;
/* Sampler type streaming/offline */
enum hip4_type type;
};
/**
* SCSC User Space debug sampler interface (singleton)
*/
static struct {
bool init;
dev_t device;
struct class *class_hip4_sampler;
struct hip4_sampler_dev devs[SCSC_HIP4_DEBUG_INTERFACES];
} hip4_sampler;
void hip4_sampler_update_record(u32 minor, u8 param1, u8 param2, u8 param3, u8 param4)
{
struct hip4_sampler_dev *hip4_dev;
struct hip4_record ev;
u32 ret;
if (!hip4_sampler_enable)
return;
if (minor >= SCSC_HIP4_INTERFACES)
return;
hip4_dev = &hip4_sampler.devs[minor];
/* If char device if open, use streaming buffer */
if (hip4_dev->filp) {
/* put string into the Streaming fifo */
if (kfifo_avail(&hip4_dev->fifo)) {
spin_lock_bh(&hip4_dev->spinlock);
/* Push values in Fifo*/
ev.record_num = (0x3fffffff & hip4_dev->record_num++) | (in_irq() << 31) | (irqs_disabled() << 30);
ev.ts = ktime_get();
ev.record = ((param1 & 0xff) << 24) | ((param2 & 0xff) << 16) | ((param3 & 0xff) << 8) | (param4 & 0xff);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0))
kfifo_put(&hip4_dev->fifo, ev);
#else
kfifo_put(&hip4_dev->fifo, &ev);
#endif
spin_unlock_bh(&hip4_dev->spinlock);
ret = kfifo_len(&hip4_dev->fifo);
if (ret > hip4_dev->kfifo_max)
hip4_dev->kfifo_max = ret;
} else {
hip4_dev->error = KFIFO_FULL;
return;
}
wake_up_interruptible(&hip4_dev->read_wait);
/* If streaming buffer is not in use, put samples in offline buffer */
} else {
/* Get associated Offline buffer */
hip4_dev = &hip4_sampler.devs[minor + 1];
/* Record in offline fifo */
spin_lock_bh(&hip4_dev->spinlock);
/* if fifo is full, remove last item */
if (kfifo_is_full(&hip4_dev->fifo))
ret = kfifo_get(&hip4_dev->fifo, &ev);
/* Push values in Static Fifo*/
ev.record_num = (0x3fffffff & hip4_dev->record_num++) | (in_irq() << 31) | (irqs_disabled() << 30);
ev.ts = ktime_get();
ev.record = ((param1 & 0xff) << 24) | ((param2 & 0xff) << 16) | ((param3 & 0xff) << 8) | (param4 & 0xff);
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 12, 0))
kfifo_put(&hip4_dev->fifo, ev);
#else
kfifo_put(&hip4_dev->fifo, &ev);
#endif
spin_unlock_bh(&hip4_dev->spinlock);
}
}
static int hip4_sampler_open(struct inode *inode, struct file *filp)
{
struct hip4_sampler_dev *hip4_dev;
int ret = 0;
hip4_dev = container_of(inode->i_cdev, struct hip4_sampler_dev, cdev);
if (hip4_dev->type == OFFLINE) {
/* Offline buffer skip open */
filp->private_data = hip4_dev;
return 0;
}
if (mutex_lock_interruptible(&hip4_dev->mutex))
return -ERESTARTSYS;
if (filp->private_data) {
SLSI_INFO_NODEV("Service already started\n");
ret = 0;
goto end;
}
if (hip4_sampler_kfifo_len > 256 * 1024) {
SLSI_DBG1_NODEV(SLSI_HIP, "hip4_sampler_kfifo_len %d > 2262144. Set to MAX", hip4_sampler_kfifo_len);
hip4_sampler_kfifo_len = 256 * 1024;
}
ret = kfifo_alloc(&hip4_dev->fifo, hip4_sampler_kfifo_len, GFP_KERNEL);
if (ret) {
SLSI_ERR_NODEV("kfifo_alloc failed");
ret = -ENOMEM;
goto end;
}
filp->private_data = hip4_dev;
/* Clear any remaining error */
hip4_dev->error = NO_ERROR;
hip4_dev->record_num = 0;
hip4_dev->kfifo_max = 0;
SLSI_INFO_NODEV("%s: Sampling....\n", DRV_NAME);
hip4_dev->filp = filp;
end:
mutex_unlock(&hip4_dev->mutex);
return ret;
}
static ssize_t hip4_sampler_read(struct file *filp, char __user *buf, size_t len, loff_t *offset)
{
unsigned int copied;
int ret = 0;
struct hip4_sampler_dev *hip4_dev;
hip4_dev = filp->private_data;
if (hip4_dev->type == OFFLINE) {
/* Offline buffer skip open */
if (mutex_lock_interruptible(&hip4_dev->mutex))
return -EINTR;
ret = kfifo_to_user(&hip4_dev->fifo, buf, len, &copied);
mutex_unlock(&hip4_dev->mutex);
return ret ? ret : copied;
}
if (mutex_lock_interruptible(&hip4_dev->mutex))
return -EINTR;
/* Check whether the device is in error */
if (hip4_dev->error != NO_ERROR) {
SLSI_ERR_NODEV("Device in error\n");
ret = -EIO;
goto end;
}
while (len) {
if (kfifo_len(&hip4_dev->fifo)) {
ret = kfifo_to_user(&hip4_dev->fifo, buf, len, &copied);
if (!ret)
ret = copied;
break;
}
if (filp->f_flags & O_NONBLOCK) {
ret = -EAGAIN;
break;
}
ret = wait_event_interruptible(hip4_dev->read_wait,
!kfifo_is_empty(&hip4_dev->fifo));
if (ret < 0)
break;
}
end:
mutex_unlock(&hip4_dev->mutex);
return ret;
}
static unsigned hip4_sampler_poll(struct file *filp, poll_table *wait)
{
struct hip4_sampler_dev *hip4_dev;
int ret;
hip4_dev = filp->private_data;
if (hip4_dev->type == OFFLINE)
/* Offline buffer skip poll */
return 0;
if (mutex_lock_interruptible(&hip4_dev->mutex))
return -EINTR;
if (hip4_dev->error != NO_ERROR) {
ret = POLLERR;
goto end;
}
poll_wait(filp, &hip4_dev->read_wait, wait);
if (!kfifo_is_empty(&hip4_dev->fifo)) {
ret = POLLIN | POLLRDNORM; /* readeable */
goto end;
}
ret = POLLOUT | POLLWRNORM; /* writable */
end:
mutex_unlock(&hip4_dev->mutex);
return ret;
}
static int hip4_sampler_release(struct inode *inode, struct file *filp)
{
struct hip4_sampler_dev *hip4_dev;
hip4_dev = container_of(inode->i_cdev, struct hip4_sampler_dev, cdev);
if (hip4_dev->type == OFFLINE)
/* Offline buffer skip release */
return 0;
if (mutex_lock_interruptible(&hip4_dev->mutex))
return -EINTR;
if (hip4_dev->filp == NULL) {
SLSI_ERR_NODEV("Device already closed\n");
mutex_unlock(&hip4_dev->mutex);
return -EIO;
}
if (hip4_dev != filp->private_data) {
SLSI_ERR_NODEV("Data mismatch\n");
mutex_unlock(&hip4_dev->mutex);
return -EIO;
}
spin_lock(&hip4_dev->spinlock);
filp->private_data = NULL;
hip4_dev->filp = NULL;
kfifo_free(&hip4_dev->fifo);
spin_unlock(&hip4_dev->spinlock);
mutex_unlock(&hip4_dev->mutex);
SLSI_INFO_NODEV("%s: Sampling... end. Kfifo_max = %d\n", DRV_NAME, hip4_dev->kfifo_max);
return 0;
}
static const struct file_operations hip4_sampler_fops = {
.owner = THIS_MODULE,
.open = hip4_sampler_open,
.read = hip4_sampler_read,
.release = hip4_sampler_release,
.poll = hip4_sampler_poll,
};
/* Return minor (if exists) associated with this maxwell instance */
int hip4_sampler_register_hip(struct scsc_mx *mx)
{
int i = SCSC_HIP4_DEBUG_INTERFACES;
while (i--)
if (hip4_sampler.devs[i].mx == mx &&
hip4_sampler.devs[i].type == STREAMING)
return i;
return -ENODEV;
}
void hip4_sampler_create(struct scsc_mx *mx)
{
dev_t devn;
int ret;
char dev_name[20];
long uid = 0;
int minor;
int i;
SLSI_INFO_NODEV("hip4_sampler version: %d.%d\n", VER_MAJOR, VER_MINOR);
/* Check whether exists */
if (!hip4_sampler.init) {
ret = alloc_chrdev_region(&hip4_sampler.device, 0, SCSC_HIP4_DEBUG_INTERFACES, "hip4_sampler_char");
if (ret)
goto error;
hip4_sampler.class_hip4_sampler = class_create(THIS_MODULE, DEVICE_NAME);
if (IS_ERR(hip4_sampler.class_hip4_sampler)) {
SLSI_ERR_NODEV("hip4_sampler class creation failed\n");
ret = PTR_ERR(hip4_sampler.class_hip4_sampler);
goto error_class;
}
}
/* Search for free minors */
minor = find_first_zero_bit(bitmap_hip4_sampler_minor, SCSC_HIP4_DEBUG_INTERFACES);
if (minor == SCSC_HIP4_DEBUG_INTERFACES) {
SLSI_INFO_NODEV("minor %d > SCSC_TTY_MINORS\n", minor);
return;
}
#ifdef CONFIG_SCSC_DEBUG_CODE_COMMENTED_OUT
/* TODO GET UID */
if (kstrtol(dev_uid, 10, &uid)) {
SLSI_ERR_NODEV("Invalid device uid default to zero\n");
uid = 0;
}
#endif
/* Create Stream channels */
/* Each Stream channel will have an associated Offline channel */
for (i = 0; i < SCSC_HIP4_STREAM_CH; i++) {
minor += i;
devn = MKDEV(MAJOR(hip4_sampler.device), MINOR(minor));
snprintf(dev_name, sizeof(dev_name), "%s_%d_%s", "hip4", (int)uid, "sam_str");
cdev_init(&hip4_sampler.devs[minor].cdev, &hip4_sampler_fops);
hip4_sampler.devs[minor].cdev.owner = THIS_MODULE;
hip4_sampler.devs[minor].cdev.ops = &hip4_sampler_fops;
ret = cdev_add(&hip4_sampler.devs[minor].cdev, devn, 1);
if (ret) {
hip4_sampler.devs[minor].cdev.dev = 0;
return;
}
hip4_sampler.devs[minor].dev =
device_create(hip4_sampler.class_hip4_sampler, NULL, hip4_sampler.devs[minor].cdev.dev, NULL, dev_name);
if (hip4_sampler.devs[minor].dev == NULL) {
SLSI_ERR_NODEV("dev is NULL\n");
hip4_sampler.devs[minor].cdev.dev = 0;
cdev_del(&hip4_sampler.devs[minor].cdev);
return;
}
hip4_sampler.devs[minor].mx = mx;
mutex_init(&hip4_sampler.devs[minor].mutex);
spin_lock_init(&hip4_sampler.devs[minor].spinlock);
hip4_sampler.devs[minor].kfifo_max = 0;
hip4_sampler.devs[minor].type = STREAMING;
init_waitqueue_head(&hip4_sampler.devs[minor].read_wait);
/* Update bit mask */
set_bit(minor, bitmap_hip4_sampler_minor);
minor++;
/* Create associated offline channel */
devn = MKDEV(MAJOR(hip4_sampler.device), MINOR(minor));
snprintf(dev_name, sizeof(dev_name), "%s_%d_%s", "hip4", (int)uid, "sam_off");
cdev_init(&hip4_sampler.devs[minor].cdev, &hip4_sampler_fops);
hip4_sampler.devs[minor].cdev.owner = THIS_MODULE;
hip4_sampler.devs[minor].cdev.ops = &hip4_sampler_fops;
ret = cdev_add(&hip4_sampler.devs[minor].cdev, devn, 1);
if (ret) {
hip4_sampler.devs[minor].cdev.dev = 0;
return;
}
hip4_sampler.devs[minor].dev =
device_create(hip4_sampler.class_hip4_sampler, NULL, hip4_sampler.devs[minor].cdev.dev, NULL, dev_name);
if (hip4_sampler.devs[minor].dev == NULL) {
hip4_sampler.devs[minor].cdev.dev = 0;
cdev_del(&hip4_sampler.devs[minor].cdev);
return;
}
if (hip4_sampler_static_kfifo_len > 256 * 1024) {
SLSI_DBG1_NODEV(SLSI_HIP, "hip4_sampler_static_kfifo_len %d > 2262144. Set to MAX", hip4_sampler_static_kfifo_len);
hip4_sampler_static_kfifo_len = 256 * 1024;
}
ret = kfifo_alloc(&hip4_sampler.devs[minor].fifo, hip4_sampler_static_kfifo_len, GFP_KERNEL);
if (ret) {
SLSI_ERR_NODEV("kfifo_alloc failed");
hip4_sampler.devs[minor].dev = NULL;
hip4_sampler.devs[minor].cdev.dev = 0;
cdev_del(&hip4_sampler.devs[minor].cdev);
return;
}
hip4_sampler.devs[minor].mx = mx;
mutex_init(&hip4_sampler.devs[minor].mutex);
spin_lock_init(&hip4_sampler.devs[minor].spinlock);
hip4_sampler.devs[minor].kfifo_max = 0;
hip4_sampler.devs[minor].type = OFFLINE;
/* Update bit mask */
set_bit(minor, bitmap_hip4_sampler_minor);
}
hip4_sampler.init = true;
SLSI_INFO_NODEV("%s: Ready to start sampling....\n", DRV_NAME);
return;
error_class:
unregister_chrdev_region(hip4_sampler.device, SCSC_HIP4_DEBUG_INTERFACES);
hip4_sampler.init = false;
error:
return;
}
void hip4_sampler_destroy(struct scsc_mx *mx)
{
int i = SCSC_HIP4_DEBUG_INTERFACES;
struct hip4_sampler_dev *hip4_dev;
while (i--)
if (hip4_sampler.devs[i].cdev.dev && hip4_sampler.devs[i].mx) {
hip4_dev = &hip4_sampler.devs[i];
/* This should be never be true - as knod should prevent unloading while
* the service (device node) is open
*/
if (hip4_sampler.devs[i].filp) {
spin_lock(&hip4_sampler.devs[i].spinlock);
hip4_sampler.devs[i].filp = NULL;
kfifo_free(&hip4_sampler.devs[i].fifo);
spin_unlock(&hip4_dev->spinlock);
}
if (hip4_sampler.devs[i].type == OFFLINE)
kfifo_free(&hip4_sampler.devs[i].fifo);
device_destroy(hip4_sampler.class_hip4_sampler, hip4_sampler.devs[i].cdev.dev);
cdev_del(&hip4_sampler.devs[i].cdev);
memset(&hip4_sampler.devs[i].cdev, 0, sizeof(struct cdev));
hip4_sampler.devs[i].mx = NULL;
clear_bit(i, bitmap_hip4_sampler_minor);
}
class_destroy(hip4_sampler.class_hip4_sampler);
unregister_chrdev_region(hip4_sampler.device, SCSC_HIP4_DEBUG_INTERFACES);
hip4_sampler.init = false;
}
Reference in a new issue View git blame Copy permalink