drivers/misc/samsung/scsc/mx140_clk_test.c

   1 /****************************************************************************
   2  *
   3  *   Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
   4  *
   5  ****************************************************************************/
   6
   7 #include <linux/version.h>
   8 #include <linux/slab.h>
   9 #include <linux/cdev.h>
  10 #include <linux/device.h>
  11 #include <linux/fs.h>
  12 #include <asm/uaccess.h>
  13
  14 #include <scsc/scsc_logring.h>
  15 #include <scsc/scsc_mx.h>
  16 #include "scsc_mx_impl.h"
  17
  18 /* char device entry declarations */
  19 static dev_t        mx140_clk_test_dev_t;
  20 static struct class *mx140_clk_test_class;
  21 static struct cdev  *mx140_clk_test_cdev;
  22
  23 /* Call back function registered with 20MHz clock framework */
  24 static void client_cb(void *data, enum mx140_clk20mhz_status event)
  25 {
  26         switch (event) {
  27         case MX140_CLK_STARTED:
  28                 SCSC_TAG_INFO(CLK20_TEST, "Event MX140_CLK_STARTED received\n");
  29                 break;
  30         case MX140_CLK_STOPPED:
  31                 SCSC_TAG_INFO(CLK20_TEST, "Event MX140_CLK_STOPPED received\n");
  32                 break;
  33         case MX140_CLK_NOT_STARTED:
  34                 SCSC_TAG_INFO(CLK20_TEST, "Event MX140_CLK_NOT_STARTED received\n");
  35                 break;
  36         case MX140_CLK_NOT_STOPPED:
  37                 SCSC_TAG_INFO(CLK20_TEST, "Event MX140_CLK_NOT_STOPPED received\n");
  38                 break;
  39         case MX140_CLK_ASYNC_FAIL:
  40                 SCSC_TAG_INFO(CLK20_TEST, "Event MX140_CLK_ASYNC_FAIL received\n");
  41                 break;
  42         default:
  43                 break;
  44         }
  45 }
  46
  47 static int mx140_clk_test_dev_open(struct inode *inode, struct file *file)
  48 {
  49         mx140_clk20mhz_register(client_cb, NULL);
  50         return 0;
  51 }
  52
  53 static int mx140_clk_test_dev_release(struct inode *inode, struct file *file)
  54 {
  55         mx140_clk20mhz_unregister();
  56         return 0;
  57 }
  58
  59
  60 static ssize_t mx140_clk_test_dev_write(struct file *file, const char *data, size_t len, loff_t *offset)
  61 {
  62         unsigned long count;
  63         char          str[2]; /* One value and carry return */
  64         long int      val = 0;
  65
  66         if (len > 2) {
  67                 SCSC_TAG_ERR(CLK20_TEST, "Incorrect value len %zd\n", len);
  68                 goto error;
  69         }
  70
  71         count = copy_from_user(str, data, len);
  72
  73         str[1] = 0;
  74
  75         if (kstrtol(str, 10, &val)) {
  76                 SCSC_TAG_ERR(CLK20_TEST, "Invalid value\n");
  77                 goto error;
  78         }
  79
  80         if (val == 1)
  81                 mx140_clk20mhz_request();
  82         else if (val == 0)
  83                 mx140_clk20mhz_release();
  84         else
  85                 SCSC_TAG_INFO(CLK20_TEST, "val %ld is not valid, 1 - on, 0 - off\n", val);
  86 error:
  87         return len;
  88 }
  89
  90 static ssize_t mx140_clk_test_dev_read(struct file *filp, char *buffer, size_t length, loff_t *offset)
  91 {
  92         return length;
  93 }
  94
  95 static const struct file_operations mx140_clk_test_dev_fops = {
  96         .owner = THIS_MODULE,
  97         .open = mx140_clk_test_dev_open,
  98         .read = mx140_clk_test_dev_read,
  99         .write = mx140_clk_test_dev_write,
 100         .release = mx140_clk_test_dev_release,
 101 };
 102
 103 /* 20MHz service driver registration */
 104 void mx140_clk_test_init(void)
 105 {
 106         int ret;
 107
 108         SCSC_TAG_INFO(CLK20_TEST, "Registering mx140 TEST\n");
 109
 110         ret = alloc_chrdev_region(&mx140_clk_test_dev_t, 0, 1, "mx140_clk_test-cdev");
 111         if (ret < 0) {
 112                 SCSC_TAG_ERR(CLK20_TEST, "failed to alloc chrdev region\n");
 113                 goto fail_alloc_chrdev_region;
 114         }
 115
 116         mx140_clk_test_cdev = cdev_alloc();
 117         if (!mx140_clk_test_cdev) {
 118                 ret = -ENOMEM;
 119                 SCSC_TAG_ERR(CLK20_TEST, "failed to alloc cdev\n");
 120                 goto fail_alloc_cdev;
 121         }
 122
 123         cdev_init(mx140_clk_test_cdev, &mx140_clk_test_dev_fops);
 124         ret = cdev_add(mx140_clk_test_cdev, mx140_clk_test_dev_t, 1);
 125         if (ret < 0) {
 126                 SCSC_TAG_ERR(CLK20_TEST, "failed to add cdev\n");
 127                 goto fail_add_cdev;
 128         }
 129
 130         mx140_clk_test_class = class_create(THIS_MODULE, "mx140_clk_test");
 131         if (!mx140_clk_test_class) {
 132                 ret = -EEXIST;
 133                 SCSC_TAG_ERR(CLK20_TEST, "failed to create class\n");
 134                 goto fail_create_class;
 135         }
 136
 137         if (!device_create(mx140_clk_test_class, NULL, mx140_clk_test_dev_t, NULL, "mx140_usb_clk_test_%d", MINOR(mx140_clk_test_dev_t))) {
 138                 ret = -EINVAL;
 139                 SCSC_TAG_ERR(CLK20_TEST, "failed to create device\n");
 140                 goto fail_create_device;
 141         }
 142
 143         return;
 144 fail_create_device:
 145         class_destroy(mx140_clk_test_class);
 146 fail_create_class:
 147         cdev_del(mx140_clk_test_cdev);
 148 fail_add_cdev:
 149 fail_alloc_cdev:
 150         unregister_chrdev_region(mx140_clk_test_dev_t, 1);
 151 fail_alloc_chrdev_region:
 152         return;
 153 }
 154
 155 void mx140_clk_test_exit(void)
 156 {
 157         device_destroy(mx140_clk_test_class, mx140_clk_test_dev_t);
 158         class_destroy(mx140_clk_test_class);
 159         cdev_del(mx140_clk_test_cdev);
 160         unregister_chrdev_region(mx140_clk_test_dev_t, 1);
 161 }