Commit | Line | Data |
---|---|---|
4e69fc22 AD |
1 | /* |
2 | * HSI character device driver, implements the character device | |
3 | * interface. | |
4 | * | |
5 | * Copyright (C) 2010 Nokia Corporation. All rights reserved. | |
6 | * | |
7 | * Contact: Andras Domokos <andras.domokos@nokia.com> | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License | |
11 | * version 2 as published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License | |
19 | * along with this program; if not, write to the Free Software | |
20 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA | |
21 | * 02110-1301 USA | |
22 | */ | |
23 | ||
24 | #include <linux/errno.h> | |
25 | #include <linux/types.h> | |
26 | #include <linux/atomic.h> | |
27 | #include <linux/kernel.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/module.h> | |
30 | #include <linux/mutex.h> | |
31 | #include <linux/list.h> | |
32 | #include <linux/slab.h> | |
33 | #include <linux/kmemleak.h> | |
34 | #include <linux/ioctl.h> | |
35 | #include <linux/wait.h> | |
36 | #include <linux/fs.h> | |
37 | #include <linux/sched.h> | |
38 | #include <linux/device.h> | |
39 | #include <linux/cdev.h> | |
40 | #include <linux/uaccess.h> | |
41 | #include <linux/scatterlist.h> | |
42 | #include <linux/stat.h> | |
43 | #include <linux/hsi/hsi.h> | |
44 | #include <linux/hsi/hsi_char.h> | |
45 | ||
46 | #define HSC_DEVS 16 /* Num of channels */ | |
47 | #define HSC_MSGS 4 | |
48 | ||
49 | #define HSC_RXBREAK 0 | |
50 | ||
51 | #define HSC_ID_BITS 6 | |
52 | #define HSC_PORT_ID_BITS 4 | |
53 | #define HSC_ID_MASK 3 | |
54 | #define HSC_PORT_ID_MASK 3 | |
55 | #define HSC_CH_MASK 0xf | |
56 | ||
57 | /* | |
58 | * We support up to 4 controllers that can have up to 4 | |
59 | * ports, which should currently be more than enough. | |
60 | */ | |
61 | #define HSC_BASEMINOR(id, port_id) \ | |
62 | ((((id) & HSC_ID_MASK) << HSC_ID_BITS) | \ | |
63 | (((port_id) & HSC_PORT_ID_MASK) << HSC_PORT_ID_BITS)) | |
64 | ||
65 | enum { | |
66 | HSC_CH_OPEN, | |
67 | HSC_CH_READ, | |
68 | HSC_CH_WRITE, | |
69 | HSC_CH_WLINE, | |
70 | }; | |
71 | ||
72 | enum { | |
73 | HSC_RX, | |
74 | HSC_TX, | |
75 | }; | |
76 | ||
77 | struct hsc_client_data; | |
78 | /** | |
79 | * struct hsc_channel - hsi_char internal channel data | |
80 | * @ch: channel number | |
81 | * @flags: Keeps state of the channel (open/close, reading, writing) | |
82 | * @free_msgs_list: List of free HSI messages/requests | |
83 | * @rx_msgs_queue: List of pending RX requests | |
84 | * @tx_msgs_queue: List of pending TX requests | |
85 | * @lock: Serialize access to the lists | |
86 | * @cl: reference to the associated hsi_client | |
87 | * @cl_data: reference to the client data that this channels belongs to | |
88 | * @rx_wait: RX requests wait queue | |
89 | * @tx_wait: TX requests wait queue | |
90 | */ | |
91 | struct hsc_channel { | |
92 | unsigned int ch; | |
93 | unsigned long flags; | |
94 | struct list_head free_msgs_list; | |
95 | struct list_head rx_msgs_queue; | |
96 | struct list_head tx_msgs_queue; | |
97 | spinlock_t lock; | |
98 | struct hsi_client *cl; | |
99 | struct hsc_client_data *cl_data; | |
100 | wait_queue_head_t rx_wait; | |
101 | wait_queue_head_t tx_wait; | |
102 | }; | |
103 | ||
104 | /** | |
105 | * struct hsc_client_data - hsi_char internal client data | |
106 | * @cdev: Characther device associated to the hsi_client | |
107 | * @lock: Lock to serialize open/close access | |
108 | * @flags: Keeps track of port state (rx hwbreak armed) | |
109 | * @usecnt: Use count for claiming the HSI port (mutex protected) | |
110 | * @cl: Referece to the HSI client | |
111 | * @channels: Array of channels accessible by the client | |
112 | */ | |
113 | struct hsc_client_data { | |
114 | struct cdev cdev; | |
115 | struct mutex lock; | |
116 | unsigned long flags; | |
117 | unsigned int usecnt; | |
118 | struct hsi_client *cl; | |
119 | struct hsc_channel channels[HSC_DEVS]; | |
120 | }; | |
121 | ||
122 | /* Stores the major number dynamically allocated for hsi_char */ | |
123 | static unsigned int hsc_major; | |
124 | /* Maximum buffer size that hsi_char will accept from userspace */ | |
125 | static unsigned int max_data_size = 0x1000; | |
fdadb6e9 | 126 | module_param(max_data_size, uint, 0); |
4e69fc22 AD |
127 | MODULE_PARM_DESC(max_data_size, "max read/write data size [4,8..65536] (^2)"); |
128 | ||
129 | static void hsc_add_tail(struct hsc_channel *channel, struct hsi_msg *msg, | |
130 | struct list_head *queue) | |
131 | { | |
132 | unsigned long flags; | |
133 | ||
134 | spin_lock_irqsave(&channel->lock, flags); | |
135 | list_add_tail(&msg->link, queue); | |
136 | spin_unlock_irqrestore(&channel->lock, flags); | |
137 | } | |
138 | ||
139 | static struct hsi_msg *hsc_get_first_msg(struct hsc_channel *channel, | |
140 | struct list_head *queue) | |
141 | { | |
142 | struct hsi_msg *msg = NULL; | |
143 | unsigned long flags; | |
144 | ||
145 | spin_lock_irqsave(&channel->lock, flags); | |
146 | ||
147 | if (list_empty(queue)) | |
148 | goto out; | |
149 | ||
150 | msg = list_first_entry(queue, struct hsi_msg, link); | |
151 | list_del(&msg->link); | |
152 | out: | |
153 | spin_unlock_irqrestore(&channel->lock, flags); | |
154 | ||
155 | return msg; | |
156 | } | |
157 | ||
158 | static inline void hsc_msg_free(struct hsi_msg *msg) | |
159 | { | |
160 | kfree(sg_virt(msg->sgt.sgl)); | |
161 | hsi_free_msg(msg); | |
162 | } | |
163 | ||
164 | static void hsc_free_list(struct list_head *list) | |
165 | { | |
166 | struct hsi_msg *msg, *tmp; | |
167 | ||
168 | list_for_each_entry_safe(msg, tmp, list, link) { | |
169 | list_del(&msg->link); | |
170 | hsc_msg_free(msg); | |
171 | } | |
172 | } | |
173 | ||
174 | static void hsc_reset_list(struct hsc_channel *channel, struct list_head *l) | |
175 | { | |
176 | unsigned long flags; | |
177 | LIST_HEAD(list); | |
178 | ||
179 | spin_lock_irqsave(&channel->lock, flags); | |
180 | list_splice_init(l, &list); | |
181 | spin_unlock_irqrestore(&channel->lock, flags); | |
182 | ||
183 | hsc_free_list(&list); | |
184 | } | |
185 | ||
186 | static inline struct hsi_msg *hsc_msg_alloc(unsigned int alloc_size) | |
187 | { | |
188 | struct hsi_msg *msg; | |
189 | void *buf; | |
190 | ||
191 | msg = hsi_alloc_msg(1, GFP_KERNEL); | |
192 | if (!msg) | |
193 | goto out; | |
194 | buf = kmalloc(alloc_size, GFP_KERNEL); | |
195 | if (!buf) { | |
196 | hsi_free_msg(msg); | |
197 | goto out; | |
198 | } | |
199 | sg_init_one(msg->sgt.sgl, buf, alloc_size); | |
200 | /* Ignore false positive, due to sg pointer handling */ | |
201 | kmemleak_ignore(buf); | |
202 | ||
203 | return msg; | |
204 | out: | |
205 | return NULL; | |
206 | } | |
207 | ||
208 | static inline int hsc_msgs_alloc(struct hsc_channel *channel) | |
209 | { | |
210 | struct hsi_msg *msg; | |
211 | int i; | |
212 | ||
213 | for (i = 0; i < HSC_MSGS; i++) { | |
214 | msg = hsc_msg_alloc(max_data_size); | |
215 | if (!msg) | |
216 | goto out; | |
217 | msg->channel = channel->ch; | |
218 | list_add_tail(&msg->link, &channel->free_msgs_list); | |
219 | } | |
220 | ||
221 | return 0; | |
222 | out: | |
223 | hsc_free_list(&channel->free_msgs_list); | |
224 | ||
225 | return -ENOMEM; | |
226 | } | |
227 | ||
228 | static inline unsigned int hsc_msg_len_get(struct hsi_msg *msg) | |
229 | { | |
230 | return msg->sgt.sgl->length; | |
231 | } | |
232 | ||
233 | static inline void hsc_msg_len_set(struct hsi_msg *msg, unsigned int len) | |
234 | { | |
235 | msg->sgt.sgl->length = len; | |
236 | } | |
237 | ||
238 | static void hsc_rx_completed(struct hsi_msg *msg) | |
239 | { | |
240 | struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); | |
241 | struct hsc_channel *channel = cl_data->channels + msg->channel; | |
242 | ||
243 | if (test_bit(HSC_CH_READ, &channel->flags)) { | |
244 | hsc_add_tail(channel, msg, &channel->rx_msgs_queue); | |
245 | wake_up(&channel->rx_wait); | |
246 | } else { | |
247 | hsc_add_tail(channel, msg, &channel->free_msgs_list); | |
248 | } | |
249 | } | |
250 | ||
251 | static void hsc_rx_msg_destructor(struct hsi_msg *msg) | |
252 | { | |
253 | msg->status = HSI_STATUS_ERROR; | |
254 | hsc_msg_len_set(msg, 0); | |
255 | hsc_rx_completed(msg); | |
256 | } | |
257 | ||
258 | static void hsc_tx_completed(struct hsi_msg *msg) | |
259 | { | |
260 | struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); | |
261 | struct hsc_channel *channel = cl_data->channels + msg->channel; | |
262 | ||
263 | if (test_bit(HSC_CH_WRITE, &channel->flags)) { | |
264 | hsc_add_tail(channel, msg, &channel->tx_msgs_queue); | |
265 | wake_up(&channel->tx_wait); | |
266 | } else { | |
267 | hsc_add_tail(channel, msg, &channel->free_msgs_list); | |
268 | } | |
269 | } | |
270 | ||
271 | static void hsc_tx_msg_destructor(struct hsi_msg *msg) | |
272 | { | |
273 | msg->status = HSI_STATUS_ERROR; | |
274 | hsc_msg_len_set(msg, 0); | |
275 | hsc_tx_completed(msg); | |
276 | } | |
277 | ||
278 | static void hsc_break_req_destructor(struct hsi_msg *msg) | |
279 | { | |
280 | struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); | |
281 | ||
282 | hsi_free_msg(msg); | |
283 | clear_bit(HSC_RXBREAK, &cl_data->flags); | |
284 | } | |
285 | ||
286 | static void hsc_break_received(struct hsi_msg *msg) | |
287 | { | |
288 | struct hsc_client_data *cl_data = hsi_client_drvdata(msg->cl); | |
289 | struct hsc_channel *channel = cl_data->channels; | |
290 | int i, ret; | |
291 | ||
292 | /* Broadcast HWBREAK on all channels */ | |
293 | for (i = 0; i < HSC_DEVS; i++, channel++) { | |
294 | struct hsi_msg *msg2; | |
295 | ||
296 | if (!test_bit(HSC_CH_READ, &channel->flags)) | |
297 | continue; | |
298 | msg2 = hsc_get_first_msg(channel, &channel->free_msgs_list); | |
299 | if (!msg2) | |
300 | continue; | |
301 | clear_bit(HSC_CH_READ, &channel->flags); | |
302 | hsc_msg_len_set(msg2, 0); | |
303 | msg2->status = HSI_STATUS_COMPLETED; | |
304 | hsc_add_tail(channel, msg2, &channel->rx_msgs_queue); | |
305 | wake_up(&channel->rx_wait); | |
306 | } | |
307 | hsi_flush(msg->cl); | |
308 | ret = hsi_async_read(msg->cl, msg); | |
309 | if (ret < 0) | |
310 | hsc_break_req_destructor(msg); | |
311 | } | |
312 | ||
313 | static int hsc_break_request(struct hsi_client *cl) | |
314 | { | |
315 | struct hsc_client_data *cl_data = hsi_client_drvdata(cl); | |
316 | struct hsi_msg *msg; | |
317 | int ret; | |
318 | ||
319 | if (test_and_set_bit(HSC_RXBREAK, &cl_data->flags)) | |
320 | return -EBUSY; | |
321 | ||
322 | msg = hsi_alloc_msg(0, GFP_KERNEL); | |
323 | if (!msg) { | |
324 | clear_bit(HSC_RXBREAK, &cl_data->flags); | |
325 | return -ENOMEM; | |
326 | } | |
327 | msg->break_frame = 1; | |
328 | msg->complete = hsc_break_received; | |
329 | msg->destructor = hsc_break_req_destructor; | |
330 | ret = hsi_async_read(cl, msg); | |
331 | if (ret < 0) | |
332 | hsc_break_req_destructor(msg); | |
333 | ||
334 | return ret; | |
335 | } | |
336 | ||
337 | static int hsc_break_send(struct hsi_client *cl) | |
338 | { | |
339 | struct hsi_msg *msg; | |
340 | int ret; | |
341 | ||
342 | msg = hsi_alloc_msg(0, GFP_ATOMIC); | |
343 | if (!msg) | |
344 | return -ENOMEM; | |
345 | msg->break_frame = 1; | |
346 | msg->complete = hsi_free_msg; | |
347 | msg->destructor = hsi_free_msg; | |
348 | ret = hsi_async_write(cl, msg); | |
349 | if (ret < 0) | |
350 | hsi_free_msg(msg); | |
351 | ||
352 | return ret; | |
353 | } | |
354 | ||
355 | static int hsc_rx_set(struct hsi_client *cl, struct hsc_rx_config *rxc) | |
356 | { | |
357 | struct hsi_config tmp; | |
358 | int ret; | |
359 | ||
360 | if ((rxc->mode != HSI_MODE_STREAM) && (rxc->mode != HSI_MODE_FRAME)) | |
361 | return -EINVAL; | |
362 | if ((rxc->channels == 0) || (rxc->channels > HSC_DEVS)) | |
363 | return -EINVAL; | |
364 | if (rxc->channels & (rxc->channels - 1)) | |
365 | return -EINVAL; | |
366 | if ((rxc->flow != HSI_FLOW_SYNC) && (rxc->flow != HSI_FLOW_PIPE)) | |
367 | return -EINVAL; | |
368 | tmp = cl->rx_cfg; | |
369 | cl->rx_cfg.mode = rxc->mode; | |
a088cf16 | 370 | cl->rx_cfg.num_hw_channels = rxc->channels; |
4e69fc22 AD |
371 | cl->rx_cfg.flow = rxc->flow; |
372 | ret = hsi_setup(cl); | |
373 | if (ret < 0) { | |
374 | cl->rx_cfg = tmp; | |
375 | return ret; | |
376 | } | |
377 | if (rxc->mode == HSI_MODE_FRAME) | |
378 | hsc_break_request(cl); | |
379 | ||
380 | return ret; | |
381 | } | |
382 | ||
383 | static inline void hsc_rx_get(struct hsi_client *cl, struct hsc_rx_config *rxc) | |
384 | { | |
385 | rxc->mode = cl->rx_cfg.mode; | |
a088cf16 | 386 | rxc->channels = cl->rx_cfg.num_hw_channels; |
4e69fc22 AD |
387 | rxc->flow = cl->rx_cfg.flow; |
388 | } | |
389 | ||
390 | static int hsc_tx_set(struct hsi_client *cl, struct hsc_tx_config *txc) | |
391 | { | |
392 | struct hsi_config tmp; | |
393 | int ret; | |
394 | ||
395 | if ((txc->mode != HSI_MODE_STREAM) && (txc->mode != HSI_MODE_FRAME)) | |
396 | return -EINVAL; | |
397 | if ((txc->channels == 0) || (txc->channels > HSC_DEVS)) | |
398 | return -EINVAL; | |
399 | if (txc->channels & (txc->channels - 1)) | |
400 | return -EINVAL; | |
401 | if ((txc->arb_mode != HSI_ARB_RR) && (txc->arb_mode != HSI_ARB_PRIO)) | |
402 | return -EINVAL; | |
403 | tmp = cl->tx_cfg; | |
404 | cl->tx_cfg.mode = txc->mode; | |
a088cf16 | 405 | cl->tx_cfg.num_hw_channels = txc->channels; |
4e69fc22 AD |
406 | cl->tx_cfg.speed = txc->speed; |
407 | cl->tx_cfg.arb_mode = txc->arb_mode; | |
408 | ret = hsi_setup(cl); | |
409 | if (ret < 0) { | |
410 | cl->tx_cfg = tmp; | |
411 | return ret; | |
412 | } | |
413 | ||
414 | return ret; | |
415 | } | |
416 | ||
417 | static inline void hsc_tx_get(struct hsi_client *cl, struct hsc_tx_config *txc) | |
418 | { | |
419 | txc->mode = cl->tx_cfg.mode; | |
a088cf16 | 420 | txc->channels = cl->tx_cfg.num_hw_channels; |
4e69fc22 AD |
421 | txc->speed = cl->tx_cfg.speed; |
422 | txc->arb_mode = cl->tx_cfg.arb_mode; | |
423 | } | |
424 | ||
425 | static ssize_t hsc_read(struct file *file, char __user *buf, size_t len, | |
426 | loff_t *ppos __maybe_unused) | |
427 | { | |
428 | struct hsc_channel *channel = file->private_data; | |
429 | struct hsi_msg *msg; | |
430 | ssize_t ret; | |
431 | ||
432 | if (len == 0) | |
433 | return 0; | |
434 | if (!IS_ALIGNED(len, sizeof(u32))) | |
435 | return -EINVAL; | |
436 | if (len > max_data_size) | |
437 | len = max_data_size; | |
a088cf16 | 438 | if (channel->ch >= channel->cl->rx_cfg.num_hw_channels) |
4e69fc22 AD |
439 | return -ECHRNG; |
440 | if (test_and_set_bit(HSC_CH_READ, &channel->flags)) | |
441 | return -EBUSY; | |
442 | msg = hsc_get_first_msg(channel, &channel->free_msgs_list); | |
443 | if (!msg) { | |
444 | ret = -ENOSPC; | |
445 | goto out; | |
446 | } | |
447 | hsc_msg_len_set(msg, len); | |
448 | msg->complete = hsc_rx_completed; | |
449 | msg->destructor = hsc_rx_msg_destructor; | |
450 | ret = hsi_async_read(channel->cl, msg); | |
451 | if (ret < 0) { | |
452 | hsc_add_tail(channel, msg, &channel->free_msgs_list); | |
453 | goto out; | |
454 | } | |
455 | ||
456 | ret = wait_event_interruptible(channel->rx_wait, | |
457 | !list_empty(&channel->rx_msgs_queue)); | |
458 | if (ret < 0) { | |
459 | clear_bit(HSC_CH_READ, &channel->flags); | |
460 | hsi_flush(channel->cl); | |
461 | return -EINTR; | |
462 | } | |
463 | ||
464 | msg = hsc_get_first_msg(channel, &channel->rx_msgs_queue); | |
465 | if (msg) { | |
466 | if (msg->status != HSI_STATUS_ERROR) { | |
467 | ret = copy_to_user((void __user *)buf, | |
468 | sg_virt(msg->sgt.sgl), hsc_msg_len_get(msg)); | |
469 | if (ret) | |
470 | ret = -EFAULT; | |
471 | else | |
472 | ret = hsc_msg_len_get(msg); | |
473 | } else { | |
474 | ret = -EIO; | |
475 | } | |
476 | hsc_add_tail(channel, msg, &channel->free_msgs_list); | |
477 | } | |
478 | out: | |
479 | clear_bit(HSC_CH_READ, &channel->flags); | |
480 | ||
481 | return ret; | |
482 | } | |
483 | ||
484 | static ssize_t hsc_write(struct file *file, const char __user *buf, size_t len, | |
485 | loff_t *ppos __maybe_unused) | |
486 | { | |
487 | struct hsc_channel *channel = file->private_data; | |
488 | struct hsi_msg *msg; | |
489 | ssize_t ret; | |
490 | ||
491 | if ((len == 0) || !IS_ALIGNED(len, sizeof(u32))) | |
492 | return -EINVAL; | |
493 | if (len > max_data_size) | |
494 | len = max_data_size; | |
a088cf16 | 495 | if (channel->ch >= channel->cl->tx_cfg.num_hw_channels) |
4e69fc22 AD |
496 | return -ECHRNG; |
497 | if (test_and_set_bit(HSC_CH_WRITE, &channel->flags)) | |
498 | return -EBUSY; | |
499 | msg = hsc_get_first_msg(channel, &channel->free_msgs_list); | |
500 | if (!msg) { | |
501 | clear_bit(HSC_CH_WRITE, &channel->flags); | |
502 | return -ENOSPC; | |
503 | } | |
504 | if (copy_from_user(sg_virt(msg->sgt.sgl), (void __user *)buf, len)) { | |
505 | ret = -EFAULT; | |
506 | goto out; | |
507 | } | |
508 | hsc_msg_len_set(msg, len); | |
509 | msg->complete = hsc_tx_completed; | |
510 | msg->destructor = hsc_tx_msg_destructor; | |
511 | ret = hsi_async_write(channel->cl, msg); | |
512 | if (ret < 0) | |
513 | goto out; | |
514 | ||
515 | ret = wait_event_interruptible(channel->tx_wait, | |
516 | !list_empty(&channel->tx_msgs_queue)); | |
517 | if (ret < 0) { | |
518 | clear_bit(HSC_CH_WRITE, &channel->flags); | |
519 | hsi_flush(channel->cl); | |
520 | return -EINTR; | |
521 | } | |
522 | ||
523 | msg = hsc_get_first_msg(channel, &channel->tx_msgs_queue); | |
524 | if (msg) { | |
525 | if (msg->status == HSI_STATUS_ERROR) | |
526 | ret = -EIO; | |
527 | else | |
528 | ret = hsc_msg_len_get(msg); | |
529 | ||
530 | hsc_add_tail(channel, msg, &channel->free_msgs_list); | |
531 | } | |
532 | out: | |
533 | clear_bit(HSC_CH_WRITE, &channel->flags); | |
534 | ||
535 | return ret; | |
536 | } | |
537 | ||
538 | static long hsc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |
539 | { | |
540 | struct hsc_channel *channel = file->private_data; | |
541 | unsigned int state; | |
542 | struct hsc_rx_config rxc; | |
543 | struct hsc_tx_config txc; | |
544 | long ret = 0; | |
545 | ||
546 | switch (cmd) { | |
547 | case HSC_RESET: | |
548 | hsi_flush(channel->cl); | |
549 | break; | |
550 | case HSC_SET_PM: | |
551 | if (copy_from_user(&state, (void __user *)arg, sizeof(state))) | |
552 | return -EFAULT; | |
553 | if (state == HSC_PM_DISABLE) { | |
554 | if (test_and_set_bit(HSC_CH_WLINE, &channel->flags)) | |
555 | return -EINVAL; | |
556 | ret = hsi_start_tx(channel->cl); | |
557 | } else if (state == HSC_PM_ENABLE) { | |
558 | if (!test_and_clear_bit(HSC_CH_WLINE, &channel->flags)) | |
559 | return -EINVAL; | |
560 | ret = hsi_stop_tx(channel->cl); | |
561 | } else { | |
562 | ret = -EINVAL; | |
563 | } | |
564 | break; | |
565 | case HSC_SEND_BREAK: | |
566 | return hsc_break_send(channel->cl); | |
567 | case HSC_SET_RX: | |
568 | if (copy_from_user(&rxc, (void __user *)arg, sizeof(rxc))) | |
569 | return -EFAULT; | |
570 | return hsc_rx_set(channel->cl, &rxc); | |
571 | case HSC_GET_RX: | |
572 | hsc_rx_get(channel->cl, &rxc); | |
573 | if (copy_to_user((void __user *)arg, &rxc, sizeof(rxc))) | |
574 | return -EFAULT; | |
575 | break; | |
576 | case HSC_SET_TX: | |
577 | if (copy_from_user(&txc, (void __user *)arg, sizeof(txc))) | |
578 | return -EFAULT; | |
579 | return hsc_tx_set(channel->cl, &txc); | |
580 | case HSC_GET_TX: | |
581 | hsc_tx_get(channel->cl, &txc); | |
582 | if (copy_to_user((void __user *)arg, &txc, sizeof(txc))) | |
583 | return -EFAULT; | |
584 | break; | |
585 | default: | |
586 | return -ENOIOCTLCMD; | |
587 | } | |
588 | ||
589 | return ret; | |
590 | } | |
591 | ||
592 | static inline void __hsc_port_release(struct hsc_client_data *cl_data) | |
593 | { | |
594 | BUG_ON(cl_data->usecnt == 0); | |
595 | ||
596 | if (--cl_data->usecnt == 0) { | |
597 | hsi_flush(cl_data->cl); | |
598 | hsi_release_port(cl_data->cl); | |
599 | } | |
600 | } | |
601 | ||
602 | static int hsc_open(struct inode *inode, struct file *file) | |
603 | { | |
604 | struct hsc_client_data *cl_data; | |
605 | struct hsc_channel *channel; | |
606 | int ret = 0; | |
607 | ||
608 | pr_debug("open, minor = %d\n", iminor(inode)); | |
609 | ||
610 | cl_data = container_of(inode->i_cdev, struct hsc_client_data, cdev); | |
611 | mutex_lock(&cl_data->lock); | |
612 | channel = cl_data->channels + (iminor(inode) & HSC_CH_MASK); | |
613 | ||
614 | if (test_and_set_bit(HSC_CH_OPEN, &channel->flags)) { | |
615 | ret = -EBUSY; | |
616 | goto out; | |
617 | } | |
618 | /* | |
619 | * Check if we have already claimed the port associated to the HSI | |
620 | * client. If not then try to claim it, else increase its refcount | |
621 | */ | |
622 | if (cl_data->usecnt == 0) { | |
623 | ret = hsi_claim_port(cl_data->cl, 0); | |
624 | if (ret < 0) | |
625 | goto out; | |
626 | hsi_setup(cl_data->cl); | |
627 | } | |
628 | cl_data->usecnt++; | |
629 | ||
630 | ret = hsc_msgs_alloc(channel); | |
631 | if (ret < 0) { | |
632 | __hsc_port_release(cl_data); | |
633 | goto out; | |
634 | } | |
635 | ||
636 | file->private_data = channel; | |
637 | mutex_unlock(&cl_data->lock); | |
638 | ||
639 | return ret; | |
640 | out: | |
641 | mutex_unlock(&cl_data->lock); | |
642 | ||
643 | return ret; | |
644 | } | |
645 | ||
646 | static int hsc_release(struct inode *inode __maybe_unused, struct file *file) | |
647 | { | |
648 | struct hsc_channel *channel = file->private_data; | |
649 | struct hsc_client_data *cl_data = channel->cl_data; | |
650 | ||
651 | mutex_lock(&cl_data->lock); | |
652 | file->private_data = NULL; | |
653 | if (test_and_clear_bit(HSC_CH_WLINE, &channel->flags)) | |
654 | hsi_stop_tx(channel->cl); | |
655 | __hsc_port_release(cl_data); | |
656 | hsc_reset_list(channel, &channel->rx_msgs_queue); | |
657 | hsc_reset_list(channel, &channel->tx_msgs_queue); | |
658 | hsc_reset_list(channel, &channel->free_msgs_list); | |
659 | clear_bit(HSC_CH_READ, &channel->flags); | |
660 | clear_bit(HSC_CH_WRITE, &channel->flags); | |
661 | clear_bit(HSC_CH_OPEN, &channel->flags); | |
662 | wake_up(&channel->rx_wait); | |
663 | wake_up(&channel->tx_wait); | |
664 | mutex_unlock(&cl_data->lock); | |
665 | ||
666 | return 0; | |
667 | } | |
668 | ||
669 | static const struct file_operations hsc_fops = { | |
670 | .owner = THIS_MODULE, | |
671 | .read = hsc_read, | |
672 | .write = hsc_write, | |
673 | .unlocked_ioctl = hsc_ioctl, | |
674 | .open = hsc_open, | |
675 | .release = hsc_release, | |
676 | }; | |
677 | ||
0fe763c5 | 678 | static void hsc_channel_init(struct hsc_channel *channel) |
4e69fc22 AD |
679 | { |
680 | init_waitqueue_head(&channel->rx_wait); | |
681 | init_waitqueue_head(&channel->tx_wait); | |
682 | spin_lock_init(&channel->lock); | |
683 | INIT_LIST_HEAD(&channel->free_msgs_list); | |
684 | INIT_LIST_HEAD(&channel->rx_msgs_queue); | |
685 | INIT_LIST_HEAD(&channel->tx_msgs_queue); | |
686 | } | |
687 | ||
0fe763c5 | 688 | static int hsc_probe(struct device *dev) |
4e69fc22 AD |
689 | { |
690 | const char devname[] = "hsi_char"; | |
691 | struct hsc_client_data *cl_data; | |
692 | struct hsc_channel *channel; | |
693 | struct hsi_client *cl = to_hsi_client(dev); | |
694 | unsigned int hsc_baseminor; | |
695 | dev_t hsc_dev; | |
696 | int ret; | |
697 | int i; | |
698 | ||
699 | cl_data = kzalloc(sizeof(*cl_data), GFP_KERNEL); | |
700 | if (!cl_data) { | |
701 | dev_err(dev, "Could not allocate hsc_client_data\n"); | |
702 | return -ENOMEM; | |
703 | } | |
704 | hsc_baseminor = HSC_BASEMINOR(hsi_id(cl), hsi_port_id(cl)); | |
705 | if (!hsc_major) { | |
706 | ret = alloc_chrdev_region(&hsc_dev, hsc_baseminor, | |
707 | HSC_DEVS, devname); | |
84d93b5e | 708 | if (ret == 0) |
4e69fc22 AD |
709 | hsc_major = MAJOR(hsc_dev); |
710 | } else { | |
711 | hsc_dev = MKDEV(hsc_major, hsc_baseminor); | |
712 | ret = register_chrdev_region(hsc_dev, HSC_DEVS, devname); | |
713 | } | |
714 | if (ret < 0) { | |
715 | dev_err(dev, "Device %s allocation failed %d\n", | |
716 | hsc_major ? "minor" : "major", ret); | |
717 | goto out1; | |
718 | } | |
719 | mutex_init(&cl_data->lock); | |
720 | hsi_client_set_drvdata(cl, cl_data); | |
721 | cdev_init(&cl_data->cdev, &hsc_fops); | |
722 | cl_data->cdev.owner = THIS_MODULE; | |
723 | cl_data->cl = cl; | |
724 | for (i = 0, channel = cl_data->channels; i < HSC_DEVS; i++, channel++) { | |
725 | hsc_channel_init(channel); | |
726 | channel->ch = i; | |
727 | channel->cl = cl; | |
728 | channel->cl_data = cl_data; | |
729 | } | |
730 | ||
731 | /* 1 hsi client -> N char devices (one for each channel) */ | |
732 | ret = cdev_add(&cl_data->cdev, hsc_dev, HSC_DEVS); | |
733 | if (ret) { | |
734 | dev_err(dev, "Could not add char device %d\n", ret); | |
735 | goto out2; | |
736 | } | |
737 | ||
738 | return 0; | |
739 | out2: | |
740 | unregister_chrdev_region(hsc_dev, HSC_DEVS); | |
741 | out1: | |
742 | kfree(cl_data); | |
743 | ||
744 | return ret; | |
745 | } | |
746 | ||
0fe763c5 | 747 | static int hsc_remove(struct device *dev) |
4e69fc22 AD |
748 | { |
749 | struct hsi_client *cl = to_hsi_client(dev); | |
750 | struct hsc_client_data *cl_data = hsi_client_drvdata(cl); | |
751 | dev_t hsc_dev = cl_data->cdev.dev; | |
752 | ||
753 | cdev_del(&cl_data->cdev); | |
754 | unregister_chrdev_region(hsc_dev, HSC_DEVS); | |
755 | hsi_client_set_drvdata(cl, NULL); | |
756 | kfree(cl_data); | |
757 | ||
758 | return 0; | |
759 | } | |
760 | ||
761 | static struct hsi_client_driver hsc_driver = { | |
762 | .driver = { | |
763 | .name = "hsi_char", | |
764 | .owner = THIS_MODULE, | |
765 | .probe = hsc_probe, | |
0fe763c5 | 766 | .remove = hsc_remove, |
4e69fc22 AD |
767 | }, |
768 | }; | |
769 | ||
770 | static int __init hsc_init(void) | |
771 | { | |
772 | int ret; | |
773 | ||
774 | if ((max_data_size < 4) || (max_data_size > 0x10000) || | |
775 | (max_data_size & (max_data_size - 1))) { | |
776 | pr_err("Invalid max read/write data size"); | |
777 | return -EINVAL; | |
778 | } | |
779 | ||
780 | ret = hsi_register_client_driver(&hsc_driver); | |
781 | if (ret) { | |
782 | pr_err("Error while registering HSI/SSI driver %d", ret); | |
783 | return ret; | |
784 | } | |
785 | ||
786 | pr_info("HSI/SSI char device loaded\n"); | |
787 | ||
788 | return 0; | |
789 | } | |
790 | module_init(hsc_init); | |
791 | ||
792 | static void __exit hsc_exit(void) | |
793 | { | |
794 | hsi_unregister_client_driver(&hsc_driver); | |
795 | pr_info("HSI char device removed\n"); | |
796 | } | |
797 | module_exit(hsc_exit); | |
798 | ||
799 | MODULE_AUTHOR("Andras Domokos <andras.domokos@nokia.com>"); | |
800 | MODULE_ALIAS("hsi:hsi_char"); | |
801 | MODULE_DESCRIPTION("HSI character device"); | |
802 | MODULE_LICENSE("GPL v2"); |