projects/linux·blob master · refs

276 lines · 6.2 KiB

1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Generic serial GNSS receiver driver
4 *
5 * Copyright (C) 2018 Johan Hovold <[email protected]>
6 */
7
8#include <linux/errno.h>
9#include <linux/gnss.h>
10#include <linux/init.h>
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/of.h>
14#include <linux/pm.h>
15#include <linux/pm_runtime.h>
16#include <linux/sched.h>
17#include <linux/serdev.h>
18#include <linux/slab.h>
19
20#include "serial.h"
21
22static int gnss_serial_open(struct gnss_device *gdev)
23{
24 struct gnss_serial *gserial = gnss_get_drvdata(gdev);
25 struct serdev_device *serdev = gserial->serdev;
26 int ret;
27
28 ret = serdev_device_open(serdev);
29 if (ret)
30 return ret;
31
32 serdev_device_set_baudrate(serdev, gserial->speed);
33 serdev_device_set_flow_control(serdev, false);
34
35 ret = pm_runtime_get_sync(&serdev->dev);
36 if (ret < 0) {
37 pm_runtime_put_noidle(&serdev->dev);
38 goto err_close;
39 }
40
41 return 0;
42
43err_close:
44 serdev_device_close(serdev);
45
46 return ret;
47}
48
49static void gnss_serial_close(struct gnss_device *gdev)
50{
51 struct gnss_serial *gserial = gnss_get_drvdata(gdev);
52 struct serdev_device *serdev = gserial->serdev;
53
54 serdev_device_close(serdev);
55
56 pm_runtime_put(&serdev->dev);
57}
58
59static int gnss_serial_write_raw(struct gnss_device *gdev,
60 const unsigned char *buf, size_t count)
61{
62 struct gnss_serial *gserial = gnss_get_drvdata(gdev);
63 struct serdev_device *serdev = gserial->serdev;
64 int ret;
65
66 /* write is only buffered synchronously */
67 ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT);
68 if (ret < 0 || ret < count)
69 return ret;
70
71 /* FIXME: determine if interrupted? */
72 serdev_device_wait_until_sent(serdev, 0);
73
74 return count;
75}
76
77static const struct gnss_operations gnss_serial_gnss_ops = {
78 .open = gnss_serial_open,
79 .close = gnss_serial_close,
80 .write_raw = gnss_serial_write_raw,
81};
82
83static size_t gnss_serial_receive_buf(struct serdev_device *serdev,
84 const u8 *buf, size_t count)
85{
86 struct gnss_serial *gserial = serdev_device_get_drvdata(serdev);
87 struct gnss_device *gdev = gserial->gdev;
88
89 return gnss_insert_raw(gdev, buf, count);
90}
91
92static const struct serdev_device_ops gnss_serial_serdev_ops = {
93 .receive_buf = gnss_serial_receive_buf,
94 .write_wakeup = serdev_device_write_wakeup,
95};
96
97static int gnss_serial_set_power(struct gnss_serial *gserial,
98 enum gnss_serial_pm_state state)
99{
100 if (!gserial->ops || !gserial->ops->set_power)
101 return 0;
102
103 return gserial->ops->set_power(gserial, state);
104}
105
106/*
107 * FIXME: need to provide subdriver defaults or separate dt parsing from
108 * allocation.
109 */
110static int gnss_serial_parse_dt(struct serdev_device *serdev)
111{
112 struct gnss_serial *gserial = serdev_device_get_drvdata(serdev);
113 struct device_node *node = serdev->dev.of_node;
114 u32 speed = 4800;
115
116 of_property_read_u32(node, "current-speed", &speed);
117
118 gserial->speed = speed;
119
120 return 0;
121}
122
123struct gnss_serial *gnss_serial_allocate(struct serdev_device *serdev,
124 size_t data_size)
125{
126 struct gnss_serial *gserial;
127 struct gnss_device *gdev;
128 int ret;
129
130 gserial = kzalloc(sizeof(*gserial) + data_size, GFP_KERNEL);
131 if (!gserial)
132 return ERR_PTR(-ENOMEM);
133
134 gdev = gnss_allocate_device(&serdev->dev);
135 if (!gdev) {
136 ret = -ENOMEM;
137 goto err_free_gserial;
138 }
139
140 gdev->ops = &gnss_serial_gnss_ops;
141 gnss_set_drvdata(gdev, gserial);
142
143 gserial->serdev = serdev;
144 gserial->gdev = gdev;
145
146 serdev_device_set_drvdata(serdev, gserial);
147 serdev_device_set_client_ops(serdev, &gnss_serial_serdev_ops);
148
149 ret = gnss_serial_parse_dt(serdev);
150 if (ret)
151 goto err_put_device;
152
153 return gserial;
154
155err_put_device:
156 gnss_put_device(gserial->gdev);
157err_free_gserial:
158 kfree(gserial);
159
160 return ERR_PTR(ret);
161}
162EXPORT_SYMBOL_GPL(gnss_serial_allocate);
163
164void gnss_serial_free(struct gnss_serial *gserial)
165{
166 gnss_put_device(gserial->gdev);
167 kfree(gserial);
168}
169EXPORT_SYMBOL_GPL(gnss_serial_free);
170
171int gnss_serial_register(struct gnss_serial *gserial)
172{
173 struct serdev_device *serdev = gserial->serdev;
174 int ret;
175
176 if (IS_ENABLED(CONFIG_PM)) {
177 pm_runtime_enable(&serdev->dev);
178 } else {
179 ret = gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
180 if (ret < 0)
181 return ret;
182 }
183
184 ret = gnss_register_device(gserial->gdev);
185 if (ret)
186 goto err_disable_rpm;
187
188 return 0;
189
190err_disable_rpm:
191 if (IS_ENABLED(CONFIG_PM))
192 pm_runtime_disable(&serdev->dev);
193 else
194 gnss_serial_set_power(gserial, GNSS_SERIAL_OFF);
195
196 return ret;
197}
198EXPORT_SYMBOL_GPL(gnss_serial_register);
199
200void gnss_serial_deregister(struct gnss_serial *gserial)
201{
202 struct serdev_device *serdev = gserial->serdev;
203
204 gnss_deregister_device(gserial->gdev);
205
206 if (IS_ENABLED(CONFIG_PM))
207 pm_runtime_disable(&serdev->dev);
208 else
209 gnss_serial_set_power(gserial, GNSS_SERIAL_OFF);
210}
211EXPORT_SYMBOL_GPL(gnss_serial_deregister);
212
213#ifdef CONFIG_PM
214static int gnss_serial_runtime_suspend(struct device *dev)
215{
216 struct gnss_serial *gserial = dev_get_drvdata(dev);
217
218 return gnss_serial_set_power(gserial, GNSS_SERIAL_STANDBY);
219}
220
221static int gnss_serial_runtime_resume(struct device *dev)
222{
223 struct gnss_serial *gserial = dev_get_drvdata(dev);
224
225 return gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
226}
227#endif /* CONFIG_PM */
228
229static int gnss_serial_prepare(struct device *dev)
230{
231 if (pm_runtime_suspended(dev))
232 return 1;
233
234 return 0;
235}
236
237#ifdef CONFIG_PM_SLEEP
238static int gnss_serial_suspend(struct device *dev)
239{
240 struct gnss_serial *gserial = dev_get_drvdata(dev);
241 int ret = 0;
242
243 /*
244 * FIXME: serdev currently lacks support for managing the underlying
245 * device's wakeup settings. A workaround would be to close the serdev
246 * device here if it is open.
247 */
248
249 if (!pm_runtime_suspended(dev))
250 ret = gnss_serial_set_power(gserial, GNSS_SERIAL_STANDBY);
251
252 return ret;
253}
254
255static int gnss_serial_resume(struct device *dev)
256{
257 struct gnss_serial *gserial = dev_get_drvdata(dev);
258 int ret = 0;
259
260 if (!pm_runtime_suspended(dev))
261 ret = gnss_serial_set_power(gserial, GNSS_SERIAL_ACTIVE);
262
263 return ret;
264}
265#endif /* CONFIG_PM_SLEEP */
266
267const struct dev_pm_ops gnss_serial_pm_ops = {
268 .prepare = gnss_serial_prepare,
269 SET_SYSTEM_SLEEP_PM_OPS(gnss_serial_suspend, gnss_serial_resume)
270 SET_RUNTIME_PM_OPS(gnss_serial_runtime_suspend, gnss_serial_runtime_resume, NULL)
271};
272EXPORT_SYMBOL_GPL(gnss_serial_pm_ops);
273
274MODULE_AUTHOR("Johan Hovold <[email protected]>");
275MODULE_DESCRIPTION("Generic serial GNSS receiver driver");
276MODULE_LICENSE("GPL v2");