aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/misc
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/misc')
-rw-r--r--drivers/misc/Kconfig13
-rw-r--r--drivers/misc/Makefile1
-rw-r--r--drivers/misc/ep93xx_pwm.c286
-rw-r--r--drivers/misc/mic/card/mic_virtio.c2
-rw-r--r--drivers/misc/mic/host/mic_boot.c2
-rw-r--r--drivers/misc/ti-st/st_kim.c12
6 files changed, 8 insertions, 308 deletions
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index e760715bd9cb..a3e291d0df9a 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -381,19 +381,6 @@ config HMC6352
381 This driver provides support for the Honeywell HMC6352 compass, 381 This driver provides support for the Honeywell HMC6352 compass,
382 providing configuration and heading data via sysfs. 382 providing configuration and heading data via sysfs.
383 383
384config EP93XX_PWM
385 tristate "EP93xx PWM support"
386 depends on ARCH_EP93XX
387 help
388 This option enables device driver support for the PWM channels
389 on the Cirrus EP93xx processors. The EP9307 chip only has one
390 PWM channel all the others have two, the second channel is an
391 alternate function of the EGPIO14 pin. A sysfs interface is
392 provided to control the PWM channels.
393
394 To compile this driver as a module, choose M here: the module will
395 be called ep93xx_pwm.
396
397config DS1682 384config DS1682
398 tristate "Dallas DS1682 Total Elapsed Time Recorder with Alarm" 385 tristate "Dallas DS1682 Total Elapsed Time Recorder with Alarm"
399 depends on I2C 386 depends on I2C
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 0b7ea3ea8bb8..f45473e68bf7 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -33,7 +33,6 @@ obj-$(CONFIG_APDS9802ALS) += apds9802als.o
33obj-$(CONFIG_ISL29003) += isl29003.o 33obj-$(CONFIG_ISL29003) += isl29003.o
34obj-$(CONFIG_ISL29020) += isl29020.o 34obj-$(CONFIG_ISL29020) += isl29020.o
35obj-$(CONFIG_SENSORS_TSL2550) += tsl2550.o 35obj-$(CONFIG_SENSORS_TSL2550) += tsl2550.o
36obj-$(CONFIG_EP93XX_PWM) += ep93xx_pwm.o
37obj-$(CONFIG_DS1682) += ds1682.o 36obj-$(CONFIG_DS1682) += ds1682.o
38obj-$(CONFIG_TI_DAC7512) += ti_dac7512.o 37obj-$(CONFIG_TI_DAC7512) += ti_dac7512.o
39obj-$(CONFIG_C2PORT) += c2port/ 38obj-$(CONFIG_C2PORT) += c2port/
diff --git a/drivers/misc/ep93xx_pwm.c b/drivers/misc/ep93xx_pwm.c
deleted file mode 100644
index cdb67a9c1959..000000000000
--- a/drivers/misc/ep93xx_pwm.c
+++ /dev/null
@@ -1,286 +0,0 @@
1/*
2 * Simple PWM driver for EP93XX
3 *
4 * (c) Copyright 2009 Matthieu Crapet <mcrapet@gmail.com>
5 * (c) Copyright 2009 H Hartley Sweeten <hsweeten@visionengravers.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * EP9307 has only one channel:
13 * - PWMOUT
14 *
15 * EP9301/02/12/15 have two channels:
16 * - PWMOUT
17 * - PWMOUT1 (alternate function for EGPIO14)
18 */
19
20#include <linux/module.h>
21#include <linux/platform_device.h>
22#include <linux/slab.h>
23#include <linux/clk.h>
24#include <linux/err.h>
25#include <linux/io.h>
26
27#include <mach/platform.h>
28
29#define EP93XX_PWMx_TERM_COUNT 0x00
30#define EP93XX_PWMx_DUTY_CYCLE 0x04
31#define EP93XX_PWMx_ENABLE 0x08
32#define EP93XX_PWMx_INVERT 0x0C
33
34#define EP93XX_PWM_MAX_COUNT 0xFFFF
35
36struct ep93xx_pwm {
37 void __iomem *mmio_base;
38 struct clk *clk;
39 u32 duty_percent;
40};
41
42/*
43 * /sys/devices/platform/ep93xx-pwm.N
44 * /min_freq read-only minimum pwm output frequency
45 * /max_req read-only maximum pwm output frequency
46 * /freq read-write pwm output frequency (0 = disable output)
47 * /duty_percent read-write pwm duty cycle percent (1..99)
48 * /invert read-write invert pwm output
49 */
50
51static ssize_t ep93xx_pwm_get_min_freq(struct device *dev,
52 struct device_attribute *attr, char *buf)
53{
54 struct platform_device *pdev = to_platform_device(dev);
55 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
56 unsigned long rate = clk_get_rate(pwm->clk);
57
58 return sprintf(buf, "%ld\n", rate / (EP93XX_PWM_MAX_COUNT + 1));
59}
60
61static ssize_t ep93xx_pwm_get_max_freq(struct device *dev,
62 struct device_attribute *attr, char *buf)
63{
64 struct platform_device *pdev = to_platform_device(dev);
65 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
66 unsigned long rate = clk_get_rate(pwm->clk);
67
68 return sprintf(buf, "%ld\n", rate / 2);
69}
70
71static ssize_t ep93xx_pwm_get_freq(struct device *dev,
72 struct device_attribute *attr, char *buf)
73{
74 struct platform_device *pdev = to_platform_device(dev);
75 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
76
77 if (readl(pwm->mmio_base + EP93XX_PWMx_ENABLE) & 0x1) {
78 unsigned long rate = clk_get_rate(pwm->clk);
79 u16 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
80
81 return sprintf(buf, "%ld\n", rate / (term + 1));
82 } else {
83 return sprintf(buf, "disabled\n");
84 }
85}
86
87static ssize_t ep93xx_pwm_set_freq(struct device *dev,
88 struct device_attribute *attr, const char *buf, size_t count)
89{
90 struct platform_device *pdev = to_platform_device(dev);
91 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
92 long val;
93 int err;
94
95 err = kstrtol(buf, 10, &val);
96 if (err)
97 return -EINVAL;
98
99 if (val == 0) {
100 writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
101 } else if (val <= (clk_get_rate(pwm->clk) / 2)) {
102 u32 term, duty;
103
104 val = (clk_get_rate(pwm->clk) / val) - 1;
105 if (val > EP93XX_PWM_MAX_COUNT)
106 val = EP93XX_PWM_MAX_COUNT;
107 if (val < 1)
108 val = 1;
109
110 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
111 duty = ((val + 1) * pwm->duty_percent / 100) - 1;
112
113 /* If pwm is running, order is important */
114 if (val > term) {
115 writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
116 writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
117 } else {
118 writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
119 writel(val, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
120 }
121
122 if (!readl(pwm->mmio_base + EP93XX_PWMx_ENABLE) & 0x1)
123 writel(0x1, pwm->mmio_base + EP93XX_PWMx_ENABLE);
124 } else {
125 return -EINVAL;
126 }
127
128 return count;
129}
130
131static ssize_t ep93xx_pwm_get_duty_percent(struct device *dev,
132 struct device_attribute *attr, char *buf)
133{
134 struct platform_device *pdev = to_platform_device(dev);
135 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
136
137 return sprintf(buf, "%d\n", pwm->duty_percent);
138}
139
140static ssize_t ep93xx_pwm_set_duty_percent(struct device *dev,
141 struct device_attribute *attr, const char *buf, size_t count)
142{
143 struct platform_device *pdev = to_platform_device(dev);
144 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
145 long val;
146 int err;
147
148 err = kstrtol(buf, 10, &val);
149 if (err)
150 return -EINVAL;
151
152 if (val > 0 && val < 100) {
153 u32 term = readl(pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
154 u32 duty = ((term + 1) * val / 100) - 1;
155
156 writel(duty, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
157 pwm->duty_percent = val;
158 return count;
159 }
160
161 return -EINVAL;
162}
163
164static ssize_t ep93xx_pwm_get_invert(struct device *dev,
165 struct device_attribute *attr, char *buf)
166{
167 struct platform_device *pdev = to_platform_device(dev);
168 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
169 int inverted = readl(pwm->mmio_base + EP93XX_PWMx_INVERT) & 0x1;
170
171 return sprintf(buf, "%d\n", inverted);
172}
173
174static ssize_t ep93xx_pwm_set_invert(struct device *dev,
175 struct device_attribute *attr, const char *buf, size_t count)
176{
177 struct platform_device *pdev = to_platform_device(dev);
178 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
179 long val;
180 int err;
181
182 err = kstrtol(buf, 10, &val);
183 if (err)
184 return -EINVAL;
185
186 if (val == 0)
187 writel(0x0, pwm->mmio_base + EP93XX_PWMx_INVERT);
188 else if (val == 1)
189 writel(0x1, pwm->mmio_base + EP93XX_PWMx_INVERT);
190 else
191 return -EINVAL;
192
193 return count;
194}
195
196static DEVICE_ATTR(min_freq, S_IRUGO, ep93xx_pwm_get_min_freq, NULL);
197static DEVICE_ATTR(max_freq, S_IRUGO, ep93xx_pwm_get_max_freq, NULL);
198static DEVICE_ATTR(freq, S_IWUSR | S_IRUGO,
199 ep93xx_pwm_get_freq, ep93xx_pwm_set_freq);
200static DEVICE_ATTR(duty_percent, S_IWUSR | S_IRUGO,
201 ep93xx_pwm_get_duty_percent, ep93xx_pwm_set_duty_percent);
202static DEVICE_ATTR(invert, S_IWUSR | S_IRUGO,
203 ep93xx_pwm_get_invert, ep93xx_pwm_set_invert);
204
205static struct attribute *ep93xx_pwm_attrs[] = {
206 &dev_attr_min_freq.attr,
207 &dev_attr_max_freq.attr,
208 &dev_attr_freq.attr,
209 &dev_attr_duty_percent.attr,
210 &dev_attr_invert.attr,
211 NULL
212};
213
214static const struct attribute_group ep93xx_pwm_sysfs_files = {
215 .attrs = ep93xx_pwm_attrs,
216};
217
218static int ep93xx_pwm_probe(struct platform_device *pdev)
219{
220 struct ep93xx_pwm *pwm;
221 struct resource *res;
222 int ret;
223
224 pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);
225 if (!pwm)
226 return -ENOMEM;
227
228 pwm->clk = devm_clk_get(&pdev->dev, "pwm_clk");
229 if (IS_ERR(pwm->clk))
230 return PTR_ERR(pwm->clk);
231
232 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
233 pwm->mmio_base = devm_ioremap_resource(&pdev->dev, res);
234 if (IS_ERR(pwm->mmio_base))
235 return PTR_ERR(pwm->mmio_base);
236
237 ret = ep93xx_pwm_acquire_gpio(pdev);
238 if (ret)
239 return ret;
240
241 ret = sysfs_create_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
242 if (ret) {
243 ep93xx_pwm_release_gpio(pdev);
244 return ret;
245 }
246
247 pwm->duty_percent = 50;
248
249 /* disable pwm at startup. Avoids zero value. */
250 writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
251 writel(EP93XX_PWM_MAX_COUNT, pwm->mmio_base + EP93XX_PWMx_TERM_COUNT);
252 writel(EP93XX_PWM_MAX_COUNT/2, pwm->mmio_base + EP93XX_PWMx_DUTY_CYCLE);
253
254 clk_enable(pwm->clk);
255
256 platform_set_drvdata(pdev, pwm);
257 return 0;
258}
259
260static int ep93xx_pwm_remove(struct platform_device *pdev)
261{
262 struct ep93xx_pwm *pwm = platform_get_drvdata(pdev);
263
264 writel(0x0, pwm->mmio_base + EP93XX_PWMx_ENABLE);
265 clk_disable(pwm->clk);
266 sysfs_remove_group(&pdev->dev.kobj, &ep93xx_pwm_sysfs_files);
267 ep93xx_pwm_release_gpio(pdev);
268
269 return 0;
270}
271
272static struct platform_driver ep93xx_pwm_driver = {
273 .driver = {
274 .name = "ep93xx-pwm",
275 .owner = THIS_MODULE,
276 },
277 .probe = ep93xx_pwm_probe,
278 .remove = ep93xx_pwm_remove,
279};
280module_platform_driver(ep93xx_pwm_driver);
281
282MODULE_AUTHOR("Matthieu Crapet <mcrapet@gmail.com>, "
283 "H Hartley Sweeten <hsweeten@visionengravers.com>");
284MODULE_DESCRIPTION("EP93xx PWM driver");
285MODULE_LICENSE("GPL");
286MODULE_ALIAS("platform:ep93xx-pwm");
diff --git a/drivers/misc/mic/card/mic_virtio.c b/drivers/misc/mic/card/mic_virtio.c
index 914cc9b2caad..8aa42e738acc 100644
--- a/drivers/misc/mic/card/mic_virtio.c
+++ b/drivers/misc/mic/card/mic_virtio.c
@@ -493,7 +493,7 @@ static int mic_remove_device(struct mic_device_desc __iomem *d,
493 ioread8(&dc->config_change), ioread8(&d->type), mvdev); 493 ioread8(&dc->config_change), ioread8(&d->type), mvdev);
494 494
495 status = ioread8(&d->status); 495 status = ioread8(&d->status);
496 INIT_COMPLETION(mvdev->reset_done); 496 reinit_completion(&mvdev->reset_done);
497 unregister_virtio_device(&mvdev->vdev); 497 unregister_virtio_device(&mvdev->vdev);
498 mic_free_card_irq(mvdev->virtio_cookie, mvdev); 498 mic_free_card_irq(mvdev->virtio_cookie, mvdev);
499 if (status & VIRTIO_CONFIG_S_DRIVER_OK) 499 if (status & VIRTIO_CONFIG_S_DRIVER_OK)
diff --git a/drivers/misc/mic/host/mic_boot.c b/drivers/misc/mic/host/mic_boot.c
index b079c65eed6d..7558d9186438 100644
--- a/drivers/misc/mic/host/mic_boot.c
+++ b/drivers/misc/mic/host/mic_boot.c
@@ -38,7 +38,7 @@ static void mic_reset(struct mic_device *mdev)
38 38
39#define MIC_RESET_TO (45) 39#define MIC_RESET_TO (45)
40 40
41 INIT_COMPLETION(mdev->reset_wait); 41 reinit_completion(&mdev->reset_wait);
42 mdev->ops->reset_fw_ready(mdev); 42 mdev->ops->reset_fw_ready(mdev);
43 mdev->ops->reset(mdev); 43 mdev->ops->reset(mdev);
44 44
diff --git a/drivers/misc/ti-st/st_kim.c b/drivers/misc/ti-st/st_kim.c
index 83907c720594..96853a09788a 100644
--- a/drivers/misc/ti-st/st_kim.c
+++ b/drivers/misc/ti-st/st_kim.c
@@ -218,7 +218,7 @@ static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
218 218
219 pr_debug("%s", __func__); 219 pr_debug("%s", __func__);
220 220
221 INIT_COMPLETION(kim_gdata->kim_rcvd); 221 reinit_completion(&kim_gdata->kim_rcvd);
222 if (4 != st_int_write(kim_gdata->core_data, read_ver_cmd, 4)) { 222 if (4 != st_int_write(kim_gdata->core_data, read_ver_cmd, 4)) {
223 pr_err("kim: couldn't write 4 bytes"); 223 pr_err("kim: couldn't write 4 bytes");
224 return -EIO; 224 return -EIO;
@@ -229,7 +229,7 @@ static long read_local_version(struct kim_data_s *kim_gdata, char *bts_scr_name)
229 pr_err(" waiting for ver info- timed out "); 229 pr_err(" waiting for ver info- timed out ");
230 return -ETIMEDOUT; 230 return -ETIMEDOUT;
231 } 231 }
232 INIT_COMPLETION(kim_gdata->kim_rcvd); 232 reinit_completion(&kim_gdata->kim_rcvd);
233 /* the positions 12 & 13 in the response buffer provide with the 233 /* the positions 12 & 13 in the response buffer provide with the
234 * chip, major & minor numbers 234 * chip, major & minor numbers
235 */ 235 */
@@ -362,7 +362,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
362 /* reinit completion before sending for the 362 /* reinit completion before sending for the
363 * relevant wait 363 * relevant wait
364 */ 364 */
365 INIT_COMPLETION(kim_gdata->kim_rcvd); 365 reinit_completion(&kim_gdata->kim_rcvd);
366 366
367 /* 367 /*
368 * Free space found in uart buffer, call st_int_write 368 * Free space found in uart buffer, call st_int_write
@@ -398,7 +398,7 @@ static long download_firmware(struct kim_data_s *kim_gdata)
398 release_firmware(kim_gdata->fw_entry); 398 release_firmware(kim_gdata->fw_entry);
399 return -ETIMEDOUT; 399 return -ETIMEDOUT;
400 } 400 }
401 INIT_COMPLETION(kim_gdata->kim_rcvd); 401 reinit_completion(&kim_gdata->kim_rcvd);
402 break; 402 break;
403 case ACTION_DELAY: /* sleep */ 403 case ACTION_DELAY: /* sleep */
404 pr_info("sleep command in scr"); 404 pr_info("sleep command in scr");
@@ -474,7 +474,7 @@ long st_kim_start(void *kim_data)
474 gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH); 474 gpio_set_value(kim_gdata->nshutdown, GPIO_HIGH);
475 mdelay(100); 475 mdelay(100);
476 /* re-initialize the completion */ 476 /* re-initialize the completion */
477 INIT_COMPLETION(kim_gdata->ldisc_installed); 477 reinit_completion(&kim_gdata->ldisc_installed);
478 /* send notification to UIM */ 478 /* send notification to UIM */
479 kim_gdata->ldisc_install = 1; 479 kim_gdata->ldisc_install = 1;
480 pr_info("ldisc_install = 1"); 480 pr_info("ldisc_install = 1");
@@ -525,7 +525,7 @@ long st_kim_stop(void *kim_data)
525 kim_gdata->kim_pdev->dev.platform_data; 525 kim_gdata->kim_pdev->dev.platform_data;
526 struct tty_struct *tty = kim_gdata->core_data->tty; 526 struct tty_struct *tty = kim_gdata->core_data->tty;
527 527
528 INIT_COMPLETION(kim_gdata->ldisc_installed); 528 reinit_completion(&kim_gdata->ldisc_installed);
529 529
530 if (tty) { /* can be called before ldisc is installed */ 530 if (tty) { /* can be called before ldisc is installed */
531 /* Flush any pending characters in the driver and discipline. */ 531 /* Flush any pending characters in the driver and discipline. */
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-29 21:49:25 -0500