#include <linux/blkdev.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#define NR_HIDDEN_BYTES 16
static bool debug = false;
module_param(debug, bool, 0644);
#define ptn_dbg(fmt, args...) \
do { \
if (debug) { \
printk(KERN_DEBUG "[oem][%s] " fmt, \
func , ## args); \
} \
} while(0)
static int ptn_open_cnt = 0;
static loff_t g_ptn_size = 0;
static struct file *ptn_filp;
static struct kobject *ptn_kobj;
static unsigned char PTN_FILE[64] = {"/dev/block/mmcblk0p13"};
DEFINE_MUTEX(ptn_lock);
static loff_t ptn_llseek(struct file *file, loff_t offset, int origin)
{
int ret = 0;
mutex_lock(&ptn_lock);
switch (origin) {
case SEEK_SET:
if (offset < 0 || (unsigned int) offset > g_ptn_size) {
ret = -EINVAL;
break;
}
file->f_pos = offset;
ret = file->f_pos;
break;
case SEEK_CUR:
if ((file->f_pos + offset) < 0 || (file->f_pos + offset) > g_ptn_size) {
ret = -EINVAL;
break;
}
file->f_pos += offset;
ret = file->f_pos;
break;
case SEEK_END:
offset += g_ptn_size;
if (offset < 0 || offset > g_ptn_size) {
ret = -EINVAL;
break;
}
file->f_pos = offset;
ret = file->f_pos;
break;
default:
ret = -EINVAL;
}
mutex_unlock(&ptn_lock);
return ret;
}
static ssize_t ptn_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
loff_t offset;
unsigned nread = 0;
if (IS_ERR(ptn_filp)) {
return -EFAULT;
}
if (*ppos > g_ptn_size || (*ppos + count ) > g_ptn_size) {
return 0;
}
mutex_lock(&ptn_lock);
offset = *ppos + NR_HIDDEN_BYTES;
nread = vfs_read(ptn_filp, buf, count, &offset);
if (nread < 0) {
mutex_unlock(&ptn_lock);
ptn_dbg("FATAL, ppos: %lld, offset: %lld, count: %ld, nread: %d\n",
*ppos, offset, count, nread);
return nread;
}
ptn_dbg("ppos: %lld, count: %ld, nread: %d\n", *ppos, count, nread);
*ppos += nread;
mutex_unlock(&ptn_lock);
return nread;
}
static ssize_t ptn_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
char kbuf[8];
loff_t offset;
int nwritten;
if (IS_ERR(ptn_filp)) {
return -EFAULT;
}
if (*ppos > g_ptn_size || (*ppos + count ) > g_ptn_size) {
return 0;
}
if (copy_from_user(kbuf, buf, count > 6 ? 6 : count)) {
ptn_dbg("failed to copy data from user\n");
}
mutex_lock(&ptn_lock);
if (!strncmp(kbuf, "ffbm-0", 6)) {
offset = *ppos;
} else {
offset = *ppos + NR_HIDDEN_BYTES;
}
nwritten = vfs_write(ptn_filp, buf, count, &offset);
if (nwritten < 0) {
mutex_unlock(&ptn_lock);
ptn_dbg("FATAL, ppos: %lld, offset: %lld, count: %ld, nwritten: %d\n",
*ppos, offset, count, nwritten);
return nwritten;
}
ptn_dbg("ppos: %lld, count: %ld, nwritten: %d\n", *ppos, count, nwritten);
*ppos += nwritten;
mutex_unlock(&ptn_lock);
return nwritten;
}
static int ptn_open(struct inode *inode, struct file *file)
{
struct inode *ptn_inode = NULL;
loff_t size;
int ro = 0;
int rc = 0;
if (ptn_open_cnt > 0) {
return -EBUSY;
}
mutex_lock(&ptn_lock);
ptn_open_cnt++;
g_ptn_size = 0;
ptn_filp = filp_open(PTN_FILE, O_RDWR | O_LARGEFILE, 0);
if (PTR_ERR(ptn_filp) == -EROFS || PTR_ERR(ptn_filp) == -EACCES) {
ro = 1;
}
if (ro) {
ptn_filp = filp_open(PTN_FILE, O_RDONLY | O_LARGEFILE, 0);
}
if (IS_ERR(ptn_filp)) {
mutex_unlock(&ptn_lock);
ptn_dbg("unable to open backing file: %s\n", PTN_FILE);
return PTR_ERR(ptn_filp);
}
ptn_inode = file_inode(ptn_filp);
size = i_size_read(ptn_inode->i_mapping->host);
if (size < 0) {
ptn_dbg("unable to find file size: %s\n", PTN_FILE);
rc = (int) size;
goto drop_ptn_filp;
}
g_ptn_size = size - NR_HIDDEN_BYTES;
mutex_unlock(&ptn_lock);
ptn_dbg("succeeded in opening the ptn file: %s, g_ptn_size: %lld\n",
PTN_FILE, g_ptn_size);
return 0;
drop_ptn_filp:
if (ptn_filp) {
filp_close(ptn_filp, NULL);
ptn_filp = NULL;
}
mutex_unlock(&ptn_lock);
return rc;
}
static int ptn_release(struct inode *inode, struct file *file)
{
mutex_lock(&ptn_lock);
if (ptn_open_cnt <= 0) {
goto drop_ptn_filp;
}
ptn_open_cnt--;
if (0 != ptn_open_cnt) {
mutex_unlock(&ptn_lock);
return 0;
}
drop_ptn_filp:
if (ptn_filp) {
filp_close(ptn_filp, NULL);
ptn_filp = NULL;
ptn_dbg("succeeded in dropping the ptn file: %s\n", PTN_FILE);
}
mutex_unlock(&ptn_lock);
return 0;
}
static const struct file_operations ptn_fops = {
.owner = THIS_MODULE,
.llseek = ptn_llseek,
.read = ptn_read,
.write = ptn_write,
.open = ptn_open,
.release = ptn_release,
};
static struct miscdevice ptn_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "misc-ptn",
.fops = &ptn_fops
};
static ssize_t ptn_show(struct kobject *obj,
struct kobj_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%s\n", PTN_FILE);
}
static ssize_t ptn_store(struct kobject *kobj, struct kobj_attribute *attr,
const char *buf, size_t count)
{
mutex_lock(&ptn_lock);
strlcpy(PTN_FILE, buf, count);
mutex_unlock(&ptn_lock);
ptn_dbg("%s\n", PTN_FILE);
return strlen(PTN_FILE) + 1;
}
static struct kobj_attribute ptn_obj_attr = {
.attr = {
.mode = S_IRUGO | S_IWUGO,
.name = "blk-file",
},
.show = ptn_show,
.store = ptn_store,
};
static struct attribute *ptn_attr[] = {
&ptn_obj_attr.attr,
NULL,
};
static struct attribute_group ptn_grp = {
.attrs = ptn_attr,
};
static int ptn_add_sys_fs(void)
{
int rc;
ptn_kobj = kobject_create_and_add("misc-ptn", NULL);
if (!ptn_kobj) {
ptn_dbg("unable to create kobject\n");
return -ENOMEM;
}
rc = sysfs_create_group(ptn_kobj, &ptn_grp);
if (rc) {
ptn_dbg("failed to create attributes\n");
kobject_put(ptn_kobj);
return -ENOENT;
}
return rc;
}
static int __init ptn_init(void)
{
int ret;
ret = misc_register(&ptn_dev);
if (ret) {
ptn_dbg("can't misc_register\n");
goto out;
}
ret = ptn_add_sys_fs();
if (ret) {
ptn_dbg("can't create /sys/misc-ptn/blk-file\n");
}
out:
return ret;
}
static void __exit ptn_exit(void)
{
misc_deregister(&ptn_dev);
}
module_init(ptn_init);
module_exit(ptn_exit);
MODULE_AUTHOR("George<xxx@xxx.com>");
MODULE_DESCRIPTION("PTN character-device wrapper driver");
MODULE_LICENSE("GPL");