1 /*
2 * drivers/misc/usb_cam_gpio.c
3 *
4 * Copyright (C) 2012-2016 Rockchip Co.,Ltd.
5 * Author: Bin Yang <yangbin@rock-chips.com>
6 *
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17
18 #include <linux/platform_device.h>
19 #include <linux/slab.h>
20 #include <linux/miscdevice.h>
21 #include <linux/gpio.h>
22 #include <linux/uaccess.h>
23 #include <linux/atomic.h>
24 #include <linux/delay.h>
25 #include <linux/input.h>
26 #include <linux/freezer.h>
27 #include <linux/of_gpio.h>
28
29 static struct class *usb_cam_gpio_class;
30
31 struct usb_cam_gpio {
32 struct device *dev;
33 struct device sys_dev;
34
35 struct gpio_desc *gpio_cam_hd;
36 struct gpio_desc *gpio_cam_ir;
37 };
38
hd_camera_on_show(struct device * sys_dev,struct device_attribute * attr,char * buf)39 static ssize_t hd_camera_on_show(struct device *sys_dev,
40 struct device_attribute *attr,
41 char *buf)
42 {
43 struct usb_cam_gpio *gpiod = container_of(sys_dev, struct usb_cam_gpio,
44 sys_dev);
45
46 return sprintf(buf, "%d\n", gpiod_get_value(gpiod->gpio_cam_hd));
47 }
48
hd_camera_on_store(struct device * sys_dev,struct device_attribute * attr,const char * buf,size_t count)49 static ssize_t hd_camera_on_store(struct device *sys_dev,
50 struct device_attribute *attr,
51 const char *buf, size_t count)
52 {
53 struct usb_cam_gpio *gpiod = container_of(sys_dev, struct usb_cam_gpio,
54 sys_dev);
55 int val = 0;
56 int ret = 0;
57
58 ret = kstrtoint(buf, 0, &val);
59 if (ret < 0)
60 return ret;
61 if (val)
62 val = 1;
63 gpiod_set_value(gpiod->gpio_cam_hd, val);
64
65 return count;
66 }
67 static DEVICE_ATTR_RW(hd_camera_on);
68
ir_camera_on_show(struct device * sys_dev,struct device_attribute * attr,char * buf)69 static ssize_t ir_camera_on_show(struct device *sys_dev,
70 struct device_attribute *attr,
71 char *buf)
72 {
73 struct usb_cam_gpio *gpiod = container_of(sys_dev,
74 struct usb_cam_gpio, sys_dev);
75
76 return sprintf(buf, "%d\n", gpiod_get_value(gpiod->gpio_cam_ir));
77 }
78
ir_camera_on_store(struct device * sys_dev,struct device_attribute * attr,const char * buf,size_t count)79 static ssize_t ir_camera_on_store(struct device *sys_dev,
80 struct device_attribute *attr,
81 const char *buf, size_t count)
82 {
83 struct usb_cam_gpio *gpiod = container_of(sys_dev,
84 struct usb_cam_gpio, sys_dev);
85 int val;
86 int ret;
87
88 ret = kstrtoint(buf, 0, &val);
89 if (ret < 0)
90 return ret;
91 if (val)
92 val = 1;
93 gpiod_set_value(gpiod->gpio_cam_ir, val);
94
95 return count;
96 }
97 static DEVICE_ATTR_RW(ir_camera_on);
98
99 static struct attribute *usb_cam_gpio_attrs[] = {
100 &dev_attr_hd_camera_on.attr,
101 &dev_attr_ir_camera_on.attr,
102 NULL,
103 };
104 ATTRIBUTE_GROUPS(usb_cam_gpio);
105
usb_cam_gpio_device_register(struct usb_cam_gpio * gpiod)106 static int usb_cam_gpio_device_register(struct usb_cam_gpio *gpiod)
107 {
108 int ret;
109 struct device *dev = &gpiod->sys_dev;
110 const char *name = {"usb_camera_on"};
111
112 dev->class = usb_cam_gpio_class;
113 dev_set_name(dev, "%s", name);
114 dev_set_drvdata(dev, gpiod);
115 ret = device_register(dev);
116
117 return ret;
118 }
119
usb_cam_gpio_probe(struct platform_device * pdev)120 static int usb_cam_gpio_probe(struct platform_device *pdev)
121 {
122 struct usb_cam_gpio *gpiod;
123 int ret = 0;
124
125 usb_cam_gpio_class = class_create(THIS_MODULE, "usb_cam_gpio");
126 if (IS_ERR(usb_cam_gpio_class)) {
127 pr_err("create uvc_detection class failed (%ld)\n",
128 PTR_ERR(usb_cam_gpio_class));
129 return PTR_ERR(usb_cam_gpio_class);
130 }
131 usb_cam_gpio_class->dev_groups = usb_cam_gpio_groups;
132
133 gpiod = devm_kzalloc(&pdev->dev, sizeof(*gpiod), GFP_KERNEL);
134 if (!gpiod)
135 return -ENOMEM;
136
137 gpiod->dev = &pdev->dev;
138
139 gpiod->gpio_cam_hd = devm_gpiod_get_optional(gpiod->dev,
140 "hd-cam", GPIOD_OUT_LOW);
141 if (IS_ERR(gpiod->gpio_cam_hd)) {
142 dev_warn(gpiod->dev, "Could not get hd-cam-gpios!\n");
143 gpiod->gpio_cam_hd = NULL;
144 }
145
146 gpiod->gpio_cam_ir = devm_gpiod_get_optional(gpiod->dev,
147 "ir-cam", GPIOD_OUT_HIGH);
148 if (IS_ERR(gpiod->gpio_cam_ir)) {
149 dev_warn(gpiod->dev, "Could not get ir-cam-gpios!\n");
150 gpiod->gpio_cam_ir = NULL;
151 }
152
153 ret = usb_cam_gpio_device_register(gpiod);
154 if (ret < 0) {
155 dev_err(gpiod->dev, "usb_cam_gpio device register fail\n");
156 return ret;
157 }
158
159 dev_info(gpiod->dev, "usb_cam_gpio_probe success\n");
160
161 return 0;
162 }
163
164 static const struct of_device_id usb_cam_gpio_match[] = {
165 { .compatible = "usb-cam-gpio" },
166 { /* Sentinel */ }
167 };
168
usb_cam_gpio_remove(struct platform_device * pdev)169 static int usb_cam_gpio_remove(struct platform_device *pdev)
170 {
171 if (!IS_ERR(usb_cam_gpio_class))
172 class_destroy(usb_cam_gpio_class);
173
174 return 0;
175 }
176
177 static struct platform_driver usb_cam_gpio_driver = {
178 .probe = usb_cam_gpio_probe,
179 .remove = usb_cam_gpio_remove,
180 .driver = {
181 .name = "usb_cam_gpio",
182 .owner = THIS_MODULE,
183 .of_match_table = usb_cam_gpio_match,
184 },
185 };
186
187 module_platform_driver(usb_cam_gpio_driver);
188
189 MODULE_ALIAS("platform:usb_cam_gpio");
190 MODULE_AUTHOR("Bin Yang <yangbin@rock-chips.com>");
191 MODULE_LICENSE("GPL v2");
192 MODULE_DESCRIPTION("usb camera gpio driver");
193