SHARE
TWEET

Untitled

a guest May 19th, 2019 73 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <linux/init.h>
  2. #include <linux/module.h>
  3. #include <linux/kernel.h>
  4. #include <linux/fs.h>
  5. #include <linux/errno.h>
  6. #include <linux/types.h>
  7. #include <linux/fcntl.h>
  8. #include <linux/miscdevice.h>
  9. #include <linux/platform_device.h>
  10. #include <linux/delay.h>
  11. #include <linux/gpio.h>
  12.  
  13. #include <mach/gpio.h>
  14. #include <mach/da8xx.h>
  15. #include <mach/mux.h>
  16.  
  17. #include "misc.h"
  18.  
  19. #define VERSION             0x0100
  20. #define DRV_NAME            "misc"
  21. #define DEV_NAME            DRV_NAME
  22. #define DEV_MAJOR           230
  23.  
  24. #define USB_EN0     GPIO_TO_PIN(3, 1)
  25. #define USB_EN1     GPIO_TO_PIN(3, 0)
  26. #define USB_FLG0    GPIO_TO_PIN(3, 3)
  27. #define USB_FLG1    GPIO_TO_PIN(3, 2)
  28. #define AS_IN1      GPIO_TO_PIN(0, 10)
  29. #define AS_IN2      GPIO_TO_PIN(0, 11)
  30.  
  31. #define DO0         GPIO_TO_PIN(5, 0)
  32. #define DO1         GPIO_TO_PIN(5, 1)
  33. #define DO2         GPIO_TO_PIN(5, 2)
  34. #define DO3         GPIO_TO_PIN(5, 3)
  35. #define DO4         GPIO_TO_PIN(5, 4)
  36. #define DO5         GPIO_TO_PIN(5, 5)
  37. #define DO6         GPIO_TO_PIN(5, 6)
  38. #define DO7         GPIO_TO_PIN(5, 7)
  39. #define DO8         GPIO_TO_PIN(5, 8)
  40. #define DO9         GPIO_TO_PIN(5, 9)
  41.  
  42. #define DI0         GPIO_TO_PIN(1, 9)
  43. #define DI1         GPIO_TO_PIN(1, 10)
  44. #define DI2         GPIO_TO_PIN(1, 11)
  45. #define DI3         GPIO_TO_PIN(1, 12)
  46. #define DI4         GPIO_TO_PIN(1, 13)
  47. #define DI5         GPIO_TO_PIN(1, 14)
  48. #define DI6         GPIO_TO_PIN(8, 7)
  49.  
  50. // MISC GPIO pins
  51. const short misc_pins[] = {
  52.     DA850_GPIO3_0, DA850_GPIO3_1, DA850_GPIO3_2, DA850_GPIO3_3,
  53.     DA850_GPIO0_10, DA850_GPIO0_11,
  54.     DA850_GPIO5_0, /*DA850_GPIO5_1, DA850_GPIO5_2,*/ DA850_GPIO5_3,
  55.     DA850_GPIO5_4, DA850_GPIO5_5, DA850_GPIO5_6, DA850_GPIO5_7,
  56.     DA850_GPIO5_8, DA850_GPIO5_9,
  57.     DA850_GPIO1_9, DA850_GPIO1_10, DA850_GPIO1_11, DA850_GPIO1_12,
  58.     DA850_GPIO1_13, DA850_GPIO1_14, DA850_GPIO8_7,
  59.     -1
  60. };
  61.  
  62. static int misc_probe(struct device *dev)
  63. {
  64.     printk(KERN_INFO "%s driver [ver : %04X]\n", DRV_NAME, VERSION);
  65.  
  66.     return 0;
  67. }
  68.  
  69. static int misc_remove(struct device *dev)
  70. {
  71.     return 0;
  72. }
  73.  
  74. static int misc_open(struct inode *inode, struct file *filp)
  75. {
  76.     return 0;
  77. }
  78.  
  79. static ssize_t misc_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
  80. {
  81.     return 0;
  82. }
  83.  
  84. static ssize_t misc_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
  85. {  
  86.     return 0;
  87. }
  88.  
  89. static int misc_release(struct inode *inode, struct file *filp)
  90. {
  91.     return 0;
  92. }
  93.  
  94. static DEFINE_MUTEX(misc_mutex);
  95. static long misc_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
  96. {
  97.     int err = 0,command_size;
  98.     int return_value = 0;
  99.     int ret = 0;
  100.     int param = 0;
  101.    
  102.     if (_IOC_TYPE(cmd) != _MISC_MAGIC)
  103.     {
  104.         printk("misc_io diff magic code(in:%d, check:%d)\n",
  105.                 _IOC_TYPE(cmd), _MISC_MAGIC);
  106.         return -EINVAL;
  107.     }
  108.  
  109.     if(_IOC_NR(cmd) >=  MISC_MAXNR)
  110.     {
  111.         printk("misc_io over maxnr (in:%d, max:%d)\n",
  112.                 _IOC_NR(cmd), MISC_MAXNR);
  113.         return -EINVAL;
  114.     }
  115.  
  116.     command_size = _IOC_SIZE(cmd);
  117.  
  118.     if(command_size) {
  119.         if (_IOC_DIR(cmd) & _IOC_READ)
  120.             err = !access_ok(VERIFY_WRITE, (void*) arg, command_size);
  121.         else if (_IOC_DIR(cmd) & _IOC_WRITE)
  122.             err = !access_ok(VERIFY_READ, (void*) arg, command_size);
  123.  
  124.         if (err)
  125.         {
  126.             printk("misc ioctl command_size error: %d\n", err);
  127.             return err;
  128.         }
  129.     }
  130.  
  131.     mutex_lock(&misc_mutex);
  132.     switch(cmd) {
  133.         case SET_USB11_POWER:
  134.             if (arg)
  135.                 gpio_set_value_cansleep(USB_EN1, 1);
  136.             else
  137.                 gpio_set_value_cansleep(USB_EN1, 0);
  138.             break;
  139.  
  140.         case GET_USB11_POWER:
  141.             ret = gpio_get_value(USB_EN1);
  142.             printk("get USB11 power: %d\n", ret);
  143.             copy_to_user((int *)arg, &ret, sizeof(int));
  144.             break;
  145.  
  146.         case SET_USB21_POWER:
  147.             if (arg)
  148.                 gpio_set_value_cansleep(USB_EN0, 1);
  149.             else
  150.                 gpio_set_value_cansleep(USB_EN0, 0);
  151.             break;
  152.  
  153.         case GET_USB21_POWER:
  154.             ret = gpio_get_value(USB_EN0);
  155.             printk("get USB21 power: %d\n", ret);
  156.             copy_to_user((int *)arg, &ret, sizeof(int));
  157.             break;
  158.  
  159.         case GET_USB11_OVER_CURRENT:
  160.             ret = gpio_get_value(USB_FLG1);
  161.             printk("get USB11 error: %d\n", ret);
  162.             copy_to_user((int *)arg, &ret, sizeof(int));
  163.             break;
  164.  
  165.         case GET_USB21_OVER_CURRENT:
  166.             ret = gpio_get_value(USB_FLG0);
  167.             printk("get USB21 error %d\n", ret);
  168.             copy_to_user((int *)arg, &ret, sizeof(int));
  169.             break;
  170.  
  171.         case SET_ANALOG_SWITCH_CH:
  172.             switch (arg)
  173.             {
  174.             case 1:
  175.                 gpio_set_value(AS_IN1, 1);
  176.                 gpio_set_value(AS_IN2, 0);
  177.                 break;
  178.  
  179.             case 2:
  180.                 gpio_set_value(AS_IN1, 0);
  181.                 gpio_set_value(AS_IN2, 1);
  182.                 break;
  183.  
  184.             case 3:
  185.                 gpio_set_value(AS_IN1, 1);
  186.                 gpio_set_value(AS_IN2, 1);
  187.                 break;
  188.  
  189.             default:
  190.                 gpio_set_value(AS_IN1, 0);
  191.                 gpio_set_value(AS_IN2, 0);
  192.                 break;
  193.             }
  194.             break;
  195.  
  196.         case GET_ANALOG_SWITCH_CH:
  197.             ret =
  198.                 gpio_get_value(AS_IN2)*2 + gpio_get_value(AS_IN1);
  199.             printk("get Analog switch: %d\n", ret);
  200.             copy_to_user((int *)arg, &ret, sizeof(int));
  201.             break;
  202.            
  203.         default:
  204.             printk("Don't defiend command: %d\n", cmd);
  205.             return_value = -EINVAL;
  206.            
  207.     }
  208.     mutex_unlock(&misc_mutex);
  209.  
  210.     return return_value;
  211. }
  212.  
  213. static struct file_operations misc_fops =
  214. {
  215.     .owner      = THIS_MODULE,
  216.     .read       = misc_read,
  217.     .write      = misc_write,
  218.     .open       = misc_open,
  219.     .release    = misc_release,
  220.     .unlocked_ioctl     = misc_ioctl,
  221. };
  222.  
  223. static struct miscdevice misc_dev =
  224. {
  225.     .minor      = MISC_DYNAMIC_MINOR,
  226.     .name       = DEV_NAME,
  227.     .fops       = &misc_fops,
  228. };
  229.  
  230. static int __init misc_init(void)
  231. {
  232.     int ret;
  233.  
  234.     // PIN mux setting
  235.     ret = davinci_cfg_reg_list(misc_pins);
  236.     if (ret)
  237.         printk("misc gpio pinmux setup failed: %d", ret);
  238.  
  239.     // Set gpio direction
  240.     ret = gpio_request(USB_EN0, "usb_en0");
  241.     if (ret)
  242.         printk("Cannot request usb_en0 pin\n");
  243.     gpio_direction_output(USB_EN0, 1);
  244.  
  245.     ret = gpio_request(USB_EN1, "usb_en1");
  246.     if (ret)
  247.         printk("Cannot request usb_en1 pin\n");
  248.     gpio_direction_output(USB_EN1, 1);
  249.  
  250.     ret = gpio_request(USB_FLG0, "usb_flg0");
  251.     if (ret)
  252.         printk("Cannot request usb_flg0 pin\n");
  253.     gpio_direction_input(USB_FLG0);
  254.  
  255.     ret = gpio_request(USB_FLG1, "usb_flg1");
  256.     if (ret)
  257.         printk("Cannot request usb_flg1 pin\n");
  258.     gpio_direction_input(USB_FLG1);
  259.  
  260.     ret = gpio_request(AS_IN1, "as_in1");
  261.     if (ret)
  262.         printk("Cannot request as_in1 pin\n");
  263.     gpio_direction_output(AS_IN1, 1);
  264.  
  265.     ret = gpio_request(AS_IN2, "as_in2");
  266.     if (ret)
  267.         printk("Cannot request as_in2 pin\n");
  268.     gpio_direction_output(AS_IN2, 0);
  269.    
  270.     ret = gpio_request(DO0, "do0");
  271.     if (ret)
  272.         printk("Cannot requeset do0 pin\n");
  273.     gpio_direction_output(DO0, 0);
  274.  
  275.     /*ret = gpio_request(DO1, "do1");
  276.     if (ret)
  277.         printk("Cannot request do1 pin\n");
  278.     gpio_direction_output(DO1, 0);
  279.  
  280.     ret = gpio_request(DO2, "do2");
  281.     if (ret)
  282.         printk("Cannot request do2 pin\n");
  283.     gpio_direction_output(DO2, 0);*/
  284.  
  285.     ret = gpio_request(DO3, "do3");
  286.     if (ret)
  287.         printk("Cannot request do3 pin\n");
  288.     gpio_direction_output(DO3, 0);
  289.  
  290.     ret = gpio_request(DO4, "do4");
  291.     if (ret)
  292.         printk("Cannot request do4 pin\n");
  293.     gpio_direction_output(DO4, 0);
  294.  
  295.     ret = gpio_request(DO5, "do5");
  296.     if (ret)
  297.         printk("Cannot request do5 pin\n");
  298.     gpio_direction_output(DO5, 0);
  299.  
  300.     ret = gpio_request(DO6, "do6");
  301.     if (ret)
  302.         printk("Cannot request do6 pin\n");
  303.     gpio_direction_output(DO6, 0);
  304.  
  305.     ret = gpio_request(DO7, "do7");
  306.     if (ret)
  307.         printk("Cannot request do7 pin\n");
  308.     gpio_direction_output(DO7, 0);
  309.  
  310.     ret = gpio_request(DO8, "do8");
  311.     if (ret)
  312.         printk("Cannot request do8 pin\n");
  313.     gpio_direction_output(DO8, 0);
  314.  
  315.     ret = gpio_request(DO9, "do9");
  316.     if (ret)
  317.         printk("Cannot request do9 pin\n");
  318.     gpio_direction_output(DO9, 0);
  319.  
  320.     ret = gpio_request(DI0, "di0");
  321.     if (ret)
  322.         printk("Cannot request di0 pin\n");
  323.     gpio_direction_input(DI0);
  324.  
  325.     ret = gpio_request(DI1, "di1");
  326.     if (ret)
  327.         printk("Cannot request di1 pin\n");
  328.     gpio_direction_input(DI1);
  329.  
  330.     ret = gpio_request(DI2, "di2");
  331.     if (ret)
  332.         printk("Cannot request di2 pin\n");
  333.     gpio_direction_input(DI2);
  334.  
  335.     ret = gpio_request(DI3, "di3");
  336.     if (ret)
  337.         printk("Cannot request di3 pin\n");
  338.     gpio_direction_input(DI3);
  339.  
  340.     ret = gpio_request(DI4, "di4");
  341.     if (ret)
  342.         printk("Cannot request di4 pin\n");
  343.     gpio_direction_input(DI4);
  344.  
  345.     ret = gpio_request(DI5, "di5");
  346.     if (ret)
  347.         printk("Cannot request di5 pin\n");
  348.     gpio_direction_input(DI5);
  349.  
  350.     ret = gpio_request(DI6, "di6");
  351.     if (ret)
  352.         printk("Cannot request di6 pin\n");
  353.     gpio_direction_input(DI6);
  354.  
  355.     // Register device driver
  356.     ret = misc_register(&misc_dev);
  357.  
  358.     return ret;
  359. }
  360.  
  361.  
  362. static void __exit misc_exit(void)
  363. {
  364.     misc_deregister(&misc_dev);
  365. }
  366.  
  367. module_init(misc_init);
  368. module_exit(misc_exit);
  369.  
  370. MODULE_AUTHOR("Lee, Inho");
  371. MODULE_DESCRIPTION("SMART-F1 Misc driver 1.0");
  372. MODULE_LICENSE("GPL");
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top