]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blame - drivers/hsi/clients/cmt_speech.c
projects / mirror_ubuntu-jammy-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
the rest of drivers/*: annotate ->poll() instances
[mirror_ubuntu-jammy-kernel.git] / drivers / hsi / clients / cmt_speech.c
CommitLineData
7f62fe8a
KV		 1/*
2 * cmt_speech.c - HSI CMT speech driver
3 *
4 * Copyright (C) 2008,2009,2010 Nokia Corporation. All rights reserved.
5 *
6 * Contact: Kai Vehmanen <kai.vehmanen@nokia.com>
7 * Original author: Peter Ujfalusi <peter.ujfalusi@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/module.h>
26#include <linux/types.h>
27#include <linux/init.h>
28#include <linux/device.h>
29#include <linux/miscdevice.h>
30#include <linux/mm.h>
31#include <linux/slab.h>
32#include <linux/fs.h>
33#include <linux/poll.h>
174cd4b1 34#include <linux/sched/signal.h>
7f62fe8a
KV		 35#include <linux/ioctl.h>
36#include <linux/uaccess.h>
37#include <linux/pm_qos.h>
38#include <linux/hsi/hsi.h>
39#include <linux/hsi/ssi_protocol.h>
40#include <linux/hsi/cs-protocol.h>
41
42#define CS_MMAP_SIZE PAGE_SIZE
43
44struct char_queue {
45 struct list_head list;
46 u32 msg;
47};
48
49struct cs_char {
50 unsigned int opened;
51 struct hsi_client *cl;
52 struct cs_hsi_iface *hi;
53 struct list_head chardev_queue;
54 struct list_head dataind_queue;
55 int dataind_pending;
56 /* mmap things */
57 unsigned long mmap_base;
58 unsigned long mmap_size;
59 spinlock_t lock;
60 struct fasync_struct *async_queue;
61 wait_queue_head_t wait;
62 /* hsi channel ids */
63 int channel_id_cmd;
64 int channel_id_data;
65};
66
67#define SSI_CHANNEL_STATE_READING 1
68#define SSI_CHANNEL_STATE_WRITING (1 << 1)
69#define SSI_CHANNEL_STATE_POLL (1 << 2)
70#define SSI_CHANNEL_STATE_ERROR (1 << 3)
71
72#define TARGET_MASK 0xf000000
73#define TARGET_REMOTE (1 << CS_DOMAIN_SHIFT)
74#define TARGET_LOCAL 0
75
76/* Number of pre-allocated commands buffers */
77#define CS_MAX_CMDS 4
78
79/*
80 * During data transfers, transactions must be handled
81 * within 20ms (fixed value in cmtspeech HSI protocol)
82 */
83#define CS_QOS_LATENCY_FOR_DATA_USEC 20000
84
85/* Timeout to wait for pending HSI transfers to complete */
86#define CS_HSI_TRANSFER_TIMEOUT_MS 500
87
88
89#define RX_PTR_BOUNDARY_SHIFT 8
90#define RX_PTR_MAX_SHIFT (RX_PTR_BOUNDARY_SHIFT + \
91 CS_MAX_BUFFERS_SHIFT)
92struct cs_hsi_iface {
93 struct hsi_client *cl;
94 struct hsi_client *master;
95
96 unsigned int iface_state;
97 unsigned int wakeline_state;
98 unsigned int control_state;
99 unsigned int data_state;
100
101 /* state exposed to application */
102 struct cs_mmap_config_block *mmap_cfg;
103
104 unsigned long mmap_base;
105 unsigned long mmap_size;
106
107 unsigned int rx_slot;
108 unsigned int tx_slot;
109
110 /* note: for security reasons, we do not trust the contents of
111 * mmap_cfg, but instead duplicate the variables here */
112 unsigned int buf_size;
113 unsigned int rx_bufs;
114 unsigned int tx_bufs;
115 unsigned int rx_ptr_boundary;
116 unsigned int rx_offsets[CS_MAX_BUFFERS];
117 unsigned int tx_offsets[CS_MAX_BUFFERS];
118
119 /* size of aligned memory blocks */
120 unsigned int slot_size;
121 unsigned int flags;
122
123 struct list_head cmdqueue;
124
125 struct hsi_msg *data_rx_msg;
126 struct hsi_msg *data_tx_msg;
127 wait_queue_head_t datawait;
128
129 struct pm_qos_request pm_qos_req;
130
131 spinlock_t lock;
132};
133
134static struct cs_char cs_char_data;
135
136static void cs_hsi_read_on_control(struct cs_hsi_iface *hi);
137static void cs_hsi_read_on_data(struct cs_hsi_iface *hi);
138
139static inline void rx_ptr_shift_too_big(void)
140{
141 BUILD_BUG_ON((1LLU << RX_PTR_MAX_SHIFT) > UINT_MAX);
142}
143
144static void cs_notify(u32 message, struct list_head *head)
145{
146 struct char_queue *entry;
147
148 spin_lock(&cs_char_data.lock);
149
150 if (!cs_char_data.opened) {
151 spin_unlock(&cs_char_data.lock);
152 goto out;
153 }
154
155 entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
156 if (!entry) {
157 dev_err(&cs_char_data.cl->device,
158 "Can't allocate new entry for the queue.\n");
159 spin_unlock(&cs_char_data.lock);
160 goto out;
161 }
162
163 entry->msg = message;
164 list_add_tail(&entry->list, head);
165
166 spin_unlock(&cs_char_data.lock);
167
168 wake_up_interruptible(&cs_char_data.wait);
169 kill_fasync(&cs_char_data.async_queue, SIGIO, POLL_IN);
170
171out:
172 return;
173}
174
175static u32 cs_pop_entry(struct list_head *head)
176{
177 struct char_queue *entry;
178 u32 data;
179
180 entry = list_entry(head->next, struct char_queue, list);
181 data = entry->msg;
182 list_del(&entry->list);
183 kfree(entry);
184
185 return data;
186}
187
188static void cs_notify_control(u32 message)
189{
190 cs_notify(message, &cs_char_data.chardev_queue);
191}
192
193static void cs_notify_data(u32 message, int maxlength)
194{
195 cs_notify(message, &cs_char_data.dataind_queue);
196
197 spin_lock(&cs_char_data.lock);
198 cs_char_data.dataind_pending++;
199 while (cs_char_data.dataind_pending > maxlength &&
200 !list_empty(&cs_char_data.dataind_queue)) {
201 dev_dbg(&cs_char_data.cl->device, "data notification "
202 "queue overrun (%u entries)\n", cs_char_data.dataind_pending);
203
204 cs_pop_entry(&cs_char_data.dataind_queue);
205 cs_char_data.dataind_pending--;
206 }
207 spin_unlock(&cs_char_data.lock);
208}
209
210static inline void cs_set_cmd(struct hsi_msg *msg, u32 cmd)
211{
212 u32 *data = sg_virt(msg->sgt.sgl);
213 *data = cmd;
214}
215
216static inline u32 cs_get_cmd(struct hsi_msg *msg)
217{
218 u32 *data = sg_virt(msg->sgt.sgl);
219 return *data;
220}
221
222static void cs_release_cmd(struct hsi_msg *msg)
223{
224 struct cs_hsi_iface *hi = msg->context;
225
226 list_add_tail(&msg->link, &hi->cmdqueue);
227}
228
229static void cs_cmd_destructor(struct hsi_msg *msg)
230{
231 struct cs_hsi_iface *hi = msg->context;
232
233 spin_lock(&hi->lock);
234
235 dev_dbg(&cs_char_data.cl->device, "control cmd destructor\n");
236
237 if (hi->iface_state != CS_STATE_CLOSED)
238 dev_err(&hi->cl->device, "Cmd flushed while driver active\n");
239
240 if (msg->ttype == HSI_MSG_READ)
241 hi->control_state &=
242 ~(SSI_CHANNEL_STATE_POLL | SSI_CHANNEL_STATE_READING);
243 else if (msg->ttype == HSI_MSG_WRITE &&
244 hi->control_state & SSI_CHANNEL_STATE_WRITING)
245 hi->control_state &= ~SSI_CHANNEL_STATE_WRITING;
246
247 cs_release_cmd(msg);
248
249 spin_unlock(&hi->lock);
250}
251
252static struct hsi_msg *cs_claim_cmd(struct cs_hsi_iface* ssi)
253{
254 struct hsi_msg *msg;
255
256 BUG_ON(list_empty(&ssi->cmdqueue));
257
258 msg = list_first_entry(&ssi->cmdqueue, struct hsi_msg, link);
259 list_del(&msg->link);
260 msg->destructor = cs_cmd_destructor;
261
262 return msg;
263}
264
265static void cs_free_cmds(struct cs_hsi_iface *ssi)
266{
267 struct hsi_msg *msg, *tmp;
268
269 list_for_each_entry_safe(msg, tmp, &ssi->cmdqueue, link) {
270 list_del(&msg->link);
271 msg->destructor = NULL;
272 kfree(sg_virt(msg->sgt.sgl));
273 hsi_free_msg(msg);
274 }
275}
276
277static int cs_alloc_cmds(struct cs_hsi_iface *hi)
278{
279 struct hsi_msg *msg;
280 u32 *buf;
281 unsigned int i;
282
283 INIT_LIST_HEAD(&hi->cmdqueue);
284
285 for (i = 0; i < CS_MAX_CMDS; i++) {
286 msg = hsi_alloc_msg(1, GFP_KERNEL);
287 if (!msg)
288 goto out;
289 buf = kmalloc(sizeof(*buf), GFP_KERNEL);
290 if (!buf) {
291 hsi_free_msg(msg);
292 goto out;
293 }
294 sg_init_one(msg->sgt.sgl, buf, sizeof(*buf));
295 msg->channel = cs_char_data.channel_id_cmd;
296 msg->context = hi;
297 list_add_tail(&msg->link, &hi->cmdqueue);
298 }
299
300 return 0;
301
302out:
303 cs_free_cmds(hi);
304 return -ENOMEM;
305}
306
307static void cs_hsi_data_destructor(struct hsi_msg *msg)
308{
309 struct cs_hsi_iface *hi = msg->context;
310 const char *dir = (msg->ttype == HSI_MSG_READ) ? "TX" : "RX";
311
312 dev_dbg(&cs_char_data.cl->device, "Freeing data %s message\n", dir);
313
314 spin_lock(&hi->lock);
315 if (hi->iface_state != CS_STATE_CLOSED)
316 dev_err(&cs_char_data.cl->device,
317 "Data %s flush while device active\n", dir);
318 if (msg->ttype == HSI_MSG_READ)
319 hi->data_state &=
320 ~(SSI_CHANNEL_STATE_POLL | SSI_CHANNEL_STATE_READING);
321 else
322 hi->data_state &= ~SSI_CHANNEL_STATE_WRITING;
323
324 msg->status = HSI_STATUS_COMPLETED;
325 if (unlikely(waitqueue_active(&hi->datawait)))
326 wake_up_interruptible(&hi->datawait);
327
328 spin_unlock(&hi->lock);
329}
330
331static int cs_hsi_alloc_data(struct cs_hsi_iface *hi)
332{
333 struct hsi_msg *txmsg, *rxmsg;
334 int res = 0;
335
336 rxmsg = hsi_alloc_msg(1, GFP_KERNEL);
337 if (!rxmsg) {
338 res = -ENOMEM;
339 goto out1;
340 }
341 rxmsg->channel = cs_char_data.channel_id_data;
342 rxmsg->destructor = cs_hsi_data_destructor;
343 rxmsg->context = hi;
344
345 txmsg = hsi_alloc_msg(1, GFP_KERNEL);
346 if (!txmsg) {
347 res = -ENOMEM;
348 goto out2;
349 }
350 txmsg->channel = cs_char_data.channel_id_data;
351 txmsg->destructor = cs_hsi_data_destructor;
352 txmsg->context = hi;
353
354 hi->data_rx_msg = rxmsg;
355 hi->data_tx_msg = txmsg;
356
357 return 0;
358
359out2:
360 hsi_free_msg(rxmsg);
361out1:
362 return res;
363}
364
365static void cs_hsi_free_data_msg(struct hsi_msg *msg)
366{
367 WARN_ON(msg->status != HSI_STATUS_COMPLETED &&
368 msg->status != HSI_STATUS_ERROR);
369 hsi_free_msg(msg);
370}
371
372static void cs_hsi_free_data(struct cs_hsi_iface *hi)
373{
374 cs_hsi_free_data_msg(hi->data_rx_msg);
375 cs_hsi_free_data_msg(hi->data_tx_msg);
376}
377
378static inline void __cs_hsi_error_pre(struct cs_hsi_iface *hi,
379 struct hsi_msg *msg, const char *info,
380 unsigned int *state)
381{
382 spin_lock(&hi->lock);
383 dev_err(&hi->cl->device, "HSI %s error, msg %d, state %u\n",
384 info, msg->status, *state);
385}
386
387static inline void __cs_hsi_error_post(struct cs_hsi_iface *hi)
388{
389 spin_unlock(&hi->lock);
390}
391
392static inline void __cs_hsi_error_read_bits(unsigned int *state)
393{
394 *state |= SSI_CHANNEL_STATE_ERROR;
395 *state &= ~(SSI_CHANNEL_STATE_READING | SSI_CHANNEL_STATE_POLL);
396}
397
398static inline void __cs_hsi_error_write_bits(unsigned int *state)
399{
400 *state |= SSI_CHANNEL_STATE_ERROR;
401 *state &= ~SSI_CHANNEL_STATE_WRITING;
402}
403
404static void cs_hsi_control_read_error(struct cs_hsi_iface *hi,
405 struct hsi_msg *msg)
406{
407 __cs_hsi_error_pre(hi, msg, "control read", &hi->control_state);
408 cs_release_cmd(msg);
409 __cs_hsi_error_read_bits(&hi->control_state);
410 __cs_hsi_error_post(hi);
411}
412
413static void cs_hsi_control_write_error(struct cs_hsi_iface *hi,
414 struct hsi_msg *msg)
415{
416 __cs_hsi_error_pre(hi, msg, "control write", &hi->control_state);
417 cs_release_cmd(msg);
418 __cs_hsi_error_write_bits(&hi->control_state);
419 __cs_hsi_error_post(hi);
420
421}
422
423static void cs_hsi_data_read_error(struct cs_hsi_iface *hi, struct hsi_msg *msg)
424{
425 __cs_hsi_error_pre(hi, msg, "data read", &hi->data_state);
426 __cs_hsi_error_read_bits(&hi->data_state);
427 __cs_hsi_error_post(hi);
428}
429
430static void cs_hsi_data_write_error(struct cs_hsi_iface *hi,
431 struct hsi_msg *msg)
432{
433 __cs_hsi_error_pre(hi, msg, "data write", &hi->data_state);
434 __cs_hsi_error_write_bits(&hi->data_state);
435 __cs_hsi_error_post(hi);
436}
437
438static void cs_hsi_read_on_control_complete(struct hsi_msg *msg)
439{
440 u32 cmd = cs_get_cmd(msg);
441 struct cs_hsi_iface *hi = msg->context;
442
443 spin_lock(&hi->lock);
444 hi->control_state &= ~SSI_CHANNEL_STATE_READING;
445 if (msg->status == HSI_STATUS_ERROR) {
446 dev_err(&hi->cl->device, "Control RX error detected\n");
7f62fe8a 447 spin_unlock(&hi->lock);
3c13ab1d 448 cs_hsi_control_read_error(hi, msg);
7f62fe8a
KV		 449 goto out;
450 }
451 dev_dbg(&hi->cl->device, "Read on control: %08X\n", cmd);
452 cs_release_cmd(msg);
453 if (hi->flags & CS_FEAT_TSTAMP_RX_CTRL) {
5023a5ca
SR		 454 struct timespec tspec;
455 struct cs_timestamp *tstamp =
7f62fe8a 456 &hi->mmap_cfg->tstamp_rx_ctrl;
5023a5ca
SR		 457
458 ktime_get_ts(&tspec);
459
460 tstamp->tv_sec = (__u32) tspec.tv_sec;
461 tstamp->tv_nsec = (__u32) tspec.tv_nsec;
7f62fe8a
KV		 462 }
463 spin_unlock(&hi->lock);
464
465 cs_notify_control(cmd);
466
467out:
468 cs_hsi_read_on_control(hi);
469}
470
471static void cs_hsi_peek_on_control_complete(struct hsi_msg *msg)
472{
473 struct cs_hsi_iface *hi = msg->context;
474 int ret;
475
476 if (msg->status == HSI_STATUS_ERROR) {
477 dev_err(&hi->cl->device, "Control peek RX error detected\n");
478 cs_hsi_control_read_error(hi, msg);
479 return;
480 }
481
482 WARN_ON(!(hi->control_state & SSI_CHANNEL_STATE_READING));
483
484 dev_dbg(&hi->cl->device, "Peek on control complete, reading\n");
485 msg->sgt.nents = 1;
486 msg->complete = cs_hsi_read_on_control_complete;
487 ret = hsi_async_read(hi->cl, msg);
488 if (ret)
489 cs_hsi_control_read_error(hi, msg);
490}
491
492static void cs_hsi_read_on_control(struct cs_hsi_iface *hi)
493{
494 struct hsi_msg *msg;
495 int ret;
496
497 spin_lock(&hi->lock);
498 if (hi->control_state & SSI_CHANNEL_STATE_READING) {
499 dev_err(&hi->cl->device, "Control read already pending (%d)\n",
500 hi->control_state);
501 spin_unlock(&hi->lock);
502 return;
503 }
504 if (hi->control_state & SSI_CHANNEL_STATE_ERROR) {
505 dev_err(&hi->cl->device, "Control read error (%d)\n",
506 hi->control_state);
507 spin_unlock(&hi->lock);
508 return;
509 }
510 hi->control_state |= SSI_CHANNEL_STATE_READING;
511 dev_dbg(&hi->cl->device, "Issuing RX on control\n");
512 msg = cs_claim_cmd(hi);
513 spin_unlock(&hi->lock);
514
515 msg->sgt.nents = 0;
516 msg->complete = cs_hsi_peek_on_control_complete;
517 ret = hsi_async_read(hi->cl, msg);
518 if (ret)
519 cs_hsi_control_read_error(hi, msg);
520}
521
522static void cs_hsi_write_on_control_complete(struct hsi_msg *msg)
523{
524 struct cs_hsi_iface *hi = msg->context;
525 if (msg->status == HSI_STATUS_COMPLETED) {
526 spin_lock(&hi->lock);
527 hi->control_state &= ~SSI_CHANNEL_STATE_WRITING;
528 cs_release_cmd(msg);
529 spin_unlock(&hi->lock);
530 } else if (msg->status == HSI_STATUS_ERROR) {
531 cs_hsi_control_write_error(hi, msg);
532 } else {
533 dev_err(&hi->cl->device,
534 "unexpected status in control write callback %d\n",
535 msg->status);
536 }
537}
538
539static int cs_hsi_write_on_control(struct cs_hsi_iface *hi, u32 message)
540{
541 struct hsi_msg *msg;
542 int ret;
543
544 spin_lock(&hi->lock);
545 if (hi->control_state & SSI_CHANNEL_STATE_ERROR) {
546 spin_unlock(&hi->lock);
547 return -EIO;
548 }
549 if (hi->control_state & SSI_CHANNEL_STATE_WRITING) {
550 dev_err(&hi->cl->device,
551 "Write still pending on control channel.\n");
552 spin_unlock(&hi->lock);
553 return -EBUSY;
554 }
555 hi->control_state |= SSI_CHANNEL_STATE_WRITING;
556 msg = cs_claim_cmd(hi);
557 spin_unlock(&hi->lock);
558
559 cs_set_cmd(msg, message);
560 msg->sgt.nents = 1;
561 msg->complete = cs_hsi_write_on_control_complete;
562 dev_dbg(&hi->cl->device,
563 "Sending control message %08X\n", message);
564 ret = hsi_async_write(hi->cl, msg);
565 if (ret) {
566 dev_err(&hi->cl->device,
567 "async_write failed with %d\n", ret);
568 cs_hsi_control_write_error(hi, msg);
569 }
570
571 /*
572 * Make sure control read is always pending when issuing
573 * new control writes. This is needed as the controller
574 * may flush our messages if e.g. the peer device reboots
575 * unexpectedly (and we cannot directly resubmit a new read from
576 * the message destructor; see cs_cmd_destructor()).
577 */
578 if (!(hi->control_state & SSI_CHANNEL_STATE_READING)) {
579 dev_err(&hi->cl->device, "Restarting control reads\n");
580 cs_hsi_read_on_control(hi);
581 }
582
583 return 0;
584}
585
586static void cs_hsi_read_on_data_complete(struct hsi_msg *msg)
587{
588 struct cs_hsi_iface *hi = msg->context;
589 u32 payload;
590
591 if (unlikely(msg->status == HSI_STATUS_ERROR)) {
592 cs_hsi_data_read_error(hi, msg);
593 return;
594 }
595
596 spin_lock(&hi->lock);
597 WARN_ON(!(hi->data_state & SSI_CHANNEL_STATE_READING));
598 hi->data_state &= ~SSI_CHANNEL_STATE_READING;
599 payload = CS_RX_DATA_RECEIVED;
600 payload |= hi->rx_slot;
601 hi->rx_slot++;
602 hi->rx_slot %= hi->rx_ptr_boundary;
603 /* expose current rx ptr in mmap area */
604 hi->mmap_cfg->rx_ptr = hi->rx_slot;
605 if (unlikely(waitqueue_active(&hi->datawait)))
606 wake_up_interruptible(&hi->datawait);
607 spin_unlock(&hi->lock);
608
609 cs_notify_data(payload, hi->rx_bufs);
610 cs_hsi_read_on_data(hi);
611}
612
613static void cs_hsi_peek_on_data_complete(struct hsi_msg *msg)
614{
615 struct cs_hsi_iface *hi = msg->context;
616 u32 *address;
617 int ret;
618
619 if (unlikely(msg->status == HSI_STATUS_ERROR)) {
620 cs_hsi_data_read_error(hi, msg);
621 return;
622 }
623 if (unlikely(hi->iface_state != CS_STATE_CONFIGURED)) {
624 dev_err(&hi->cl->device, "Data received in invalid state\n");
625 cs_hsi_data_read_error(hi, msg);
626 return;
627 }
628
629 spin_lock(&hi->lock);
630 WARN_ON(!(hi->data_state & SSI_CHANNEL_STATE_POLL));
631 hi->data_state &= ~SSI_CHANNEL_STATE_POLL;
632 hi->data_state |= SSI_CHANNEL_STATE_READING;
633 spin_unlock(&hi->lock);
634
635 address = (u32 *)(hi->mmap_base +
636 hi->rx_offsets[hi->rx_slot % hi->rx_bufs]);
637 sg_init_one(msg->sgt.sgl, address, hi->buf_size);
638 msg->sgt.nents = 1;
639 msg->complete = cs_hsi_read_on_data_complete;
640 ret = hsi_async_read(hi->cl, msg);
641 if (ret)
642 cs_hsi_data_read_error(hi, msg);
643}
644
645/*
646 * Read/write transaction is ongoing. Returns false if in
647 * SSI_CHANNEL_STATE_POLL state.
648 */
649static inline int cs_state_xfer_active(unsigned int state)
650{
651 return (state & SSI_CHANNEL_STATE_WRITING) ||
652 (state & SSI_CHANNEL_STATE_READING);
653}
654
655/*
656 * No pending read/writes
657 */
658static inline int cs_state_idle(unsigned int state)
659{
660 return !(state & ~SSI_CHANNEL_STATE_ERROR);
661}
662
663static void cs_hsi_read_on_data(struct cs_hsi_iface *hi)
664{
665 struct hsi_msg *rxmsg;
666 int ret;
667
668 spin_lock(&hi->lock);
669 if (hi->data_state &
670 (SSI_CHANNEL_STATE_READING | SSI_CHANNEL_STATE_POLL)) {
671 dev_dbg(&hi->cl->device, "Data read already pending (%u)\n",
672 hi->data_state);
673 spin_unlock(&hi->lock);
674 return;
675 }
676 hi->data_state |= SSI_CHANNEL_STATE_POLL;
677 spin_unlock(&hi->lock);
678
679 rxmsg = hi->data_rx_msg;
680 sg_init_one(rxmsg->sgt.sgl, (void *)hi->mmap_base, 0);
681 rxmsg->sgt.nents = 0;
682 rxmsg->complete = cs_hsi_peek_on_data_complete;
683
684 ret = hsi_async_read(hi->cl, rxmsg);
685 if (ret)
686 cs_hsi_data_read_error(hi, rxmsg);
687}
688
689static void cs_hsi_write_on_data_complete(struct hsi_msg *msg)
690{
691 struct cs_hsi_iface *hi = msg->context;
692
693 if (msg->status == HSI_STATUS_COMPLETED) {
694 spin_lock(&hi->lock);
695 hi->data_state &= ~SSI_CHANNEL_STATE_WRITING;
696 if (unlikely(waitqueue_active(&hi->datawait)))
697 wake_up_interruptible(&hi->datawait);
698 spin_unlock(&hi->lock);
699 } else {
700 cs_hsi_data_write_error(hi, msg);
701 }
702}
703
704static int cs_hsi_write_on_data(struct cs_hsi_iface *hi, unsigned int slot)
705{
706 u32 *address;
707 struct hsi_msg *txmsg;
708 int ret;
709
710 spin_lock(&hi->lock);
711 if (hi->iface_state != CS_STATE_CONFIGURED) {
712 dev_err(&hi->cl->device, "Not configured, aborting\n");
713 ret = -EINVAL;
714 goto error;
715 }
716 if (hi->data_state & SSI_CHANNEL_STATE_ERROR) {
717 dev_err(&hi->cl->device, "HSI error, aborting\n");
718 ret = -EIO;
719 goto error;
720 }
721 if (hi->data_state & SSI_CHANNEL_STATE_WRITING) {
722 dev_err(&hi->cl->device, "Write pending on data channel.\n");
723 ret = -EBUSY;
724 goto error;
725 }
726 hi->data_state |= SSI_CHANNEL_STATE_WRITING;
727 spin_unlock(&hi->lock);
728
729 hi->tx_slot = slot;
730 address = (u32 *)(hi->mmap_base + hi->tx_offsets[hi->tx_slot]);
731 txmsg = hi->data_tx_msg;
732 sg_init_one(txmsg->sgt.sgl, address, hi->buf_size);
733 txmsg->complete = cs_hsi_write_on_data_complete;
734 ret = hsi_async_write(hi->cl, txmsg);
735 if (ret)
736 cs_hsi_data_write_error(hi, txmsg);
737
738 return ret;
739
740error:
741 spin_unlock(&hi->lock);
742 if (ret == -EIO)
743 cs_hsi_data_write_error(hi, hi->data_tx_msg);
744
745 return ret;
746}
747
748static unsigned int cs_hsi_get_state(struct cs_hsi_iface *hi)
749{
750 return hi->iface_state;
751}
752
753static int cs_hsi_command(struct cs_hsi_iface *hi, u32 cmd)
754{
755 int ret = 0;
756
757 local_bh_disable();
758 switch (cmd & TARGET_MASK) {
759 case TARGET_REMOTE:
760 ret = cs_hsi_write_on_control(hi, cmd);
761 break;
762 case TARGET_LOCAL:
763 if ((cmd & CS_CMD_MASK) == CS_TX_DATA_READY)
764 ret = cs_hsi_write_on_data(hi, cmd & CS_PARAM_MASK);
765 else
766 ret = -EINVAL;
767 break;
768 default:
769 ret = -EINVAL;
770 break;
771 }
772 local_bh_enable();
773
774 return ret;
775}
776
777static void cs_hsi_set_wakeline(struct cs_hsi_iface *hi, bool new_state)
778{
779 int change = 0;
780
781 spin_lock_bh(&hi->lock);
782 if (hi->wakeline_state != new_state) {
783 hi->wakeline_state = new_state;
784 change = 1;
785 dev_dbg(&hi->cl->device, "setting wake line to %d (%p)\n",
786 new_state, hi->cl);
787 }
788 spin_unlock_bh(&hi->lock);
789
790 if (change) {
791 if (new_state)
792 ssip_slave_start_tx(hi->master);
793 else
794 ssip_slave_stop_tx(hi->master);
795 }
796
797 dev_dbg(&hi->cl->device, "wake line set to %d (%p)\n",
798 new_state, hi->cl);
799}
800
801static void set_buffer_sizes(struct cs_hsi_iface *hi, int rx_bufs, int tx_bufs)
802{
803 hi->rx_bufs = rx_bufs;
804 hi->tx_bufs = tx_bufs;
805 hi->mmap_cfg->rx_bufs = rx_bufs;
806 hi->mmap_cfg->tx_bufs = tx_bufs;
807
808 if (hi->flags & CS_FEAT_ROLLING_RX_COUNTER) {
809 /*
810 * For more robust overrun detection, let the rx
811 * pointer run in range 0..'boundary-1'. Boundary
812 * is a multiple of rx_bufs, and limited in max size
813 * by RX_PTR_MAX_SHIFT to allow for fast ptr-diff
814 * calculation.
815 */
816 hi->rx_ptr_boundary = (rx_bufs << RX_PTR_BOUNDARY_SHIFT);
817 hi->mmap_cfg->rx_ptr_boundary = hi->rx_ptr_boundary;
818 } else {
819 hi->rx_ptr_boundary = hi->rx_bufs;
820 }
821}
822
823static int check_buf_params(struct cs_hsi_iface *hi,
824 const struct cs_buffer_config *buf_cfg)
825{
826 size_t buf_size_aligned = L1_CACHE_ALIGN(buf_cfg->buf_size) *
827 (buf_cfg->rx_bufs + buf_cfg->tx_bufs);
828 size_t ctrl_size_aligned = L1_CACHE_ALIGN(sizeof(*hi->mmap_cfg));
829 int r = 0;
830
831 if (buf_cfg->rx_bufs > CS_MAX_BUFFERS ||
832 buf_cfg->tx_bufs > CS_MAX_BUFFERS) {
833 r = -EINVAL;
834 } else if ((buf_size_aligned + ctrl_size_aligned) >= hi->mmap_size) {
835 dev_err(&hi->cl->device, "No space for the requested buffer "
836 "configuration\n");
837 r = -ENOBUFS;
838 }
839
840 return r;
841}
842
843/**
844 * Block until pending data transfers have completed.
845 */
846static int cs_hsi_data_sync(struct cs_hsi_iface *hi)
847{
848 int r = 0;
849
850 spin_lock_bh(&hi->lock);
851
852 if (!cs_state_xfer_active(hi->data_state)) {
853 dev_dbg(&hi->cl->device, "hsi_data_sync break, idle\n");
854 goto out;
855 }
856
857 for (;;) {
858 int s;
859 DEFINE_WAIT(wait);
860 if (!cs_state_xfer_active(hi->data_state))
861 goto out;
862 if (signal_pending(current)) {
863 r = -ERESTARTSYS;
864 goto out;
865 }
866 /**
867 * prepare_to_wait must be called with hi->lock held
868 * so that callbacks can check for waitqueue_active()
869 */
870 prepare_to_wait(&hi->datawait, &wait, TASK_INTERRUPTIBLE);
871 spin_unlock_bh(&hi->lock);
872 s = schedule_timeout(
873 msecs_to_jiffies(CS_HSI_TRANSFER_TIMEOUT_MS));
874 spin_lock_bh(&hi->lock);
875 finish_wait(&hi->datawait, &wait);
876 if (!s) {
877 dev_dbg(&hi->cl->device,
878 "hsi_data_sync timeout after %d ms\n",
879 CS_HSI_TRANSFER_TIMEOUT_MS);
880 r = -EIO;
881 goto out;
882 }
883 }
884
885out:
886 spin_unlock_bh(&hi->lock);
887 dev_dbg(&hi->cl->device, "hsi_data_sync done with res %d\n", r);
888
889 return r;
890}
891
892static void cs_hsi_data_enable(struct cs_hsi_iface *hi,
893 struct cs_buffer_config *buf_cfg)
894{
895 unsigned int data_start, i;
896
897 BUG_ON(hi->buf_size == 0);
898
899 set_buffer_sizes(hi, buf_cfg->rx_bufs, buf_cfg->tx_bufs);
900
901 hi->slot_size = L1_CACHE_ALIGN(hi->buf_size);
902 dev_dbg(&hi->cl->device,
903 "setting slot size to %u, buf size %u, align %u\n",
904 hi->slot_size, hi->buf_size, L1_CACHE_BYTES);
905
906 data_start = L1_CACHE_ALIGN(sizeof(*hi->mmap_cfg));
907 dev_dbg(&hi->cl->device,
908 "setting data start at %u, cfg block %u, align %u\n",
909 data_start, sizeof(*hi->mmap_cfg), L1_CACHE_BYTES);
910
911 for (i = 0; i < hi->mmap_cfg->rx_bufs; i++) {
912 hi->rx_offsets[i] = data_start + i * hi->slot_size;
913 hi->mmap_cfg->rx_offsets[i] = hi->rx_offsets[i];
914 dev_dbg(&hi->cl->device, "DL buf #%u at %u\n",
915 i, hi->rx_offsets[i]);
916 }
917 for (i = 0; i < hi->mmap_cfg->tx_bufs; i++) {
918 hi->tx_offsets[i] = data_start +
919 (i + hi->mmap_cfg->rx_bufs) * hi->slot_size;
920 hi->mmap_cfg->tx_offsets[i] = hi->tx_offsets[i];
921 dev_dbg(&hi->cl->device, "UL buf #%u at %u\n",
922 i, hi->rx_offsets[i]);
923 }
924
925 hi->iface_state = CS_STATE_CONFIGURED;
926}
927
928static void cs_hsi_data_disable(struct cs_hsi_iface *hi, int old_state)
929{
930 if (old_state == CS_STATE_CONFIGURED) {
931 dev_dbg(&hi->cl->device,
932 "closing data channel with slot size 0\n");
933 hi->iface_state = CS_STATE_OPENED;
934 }
935}
936
937static int cs_hsi_buf_config(struct cs_hsi_iface *hi,
938 struct cs_buffer_config *buf_cfg)
939{
940 int r = 0;
941 unsigned int old_state = hi->iface_state;
942
943 spin_lock_bh(&hi->lock);
944 /* Prevent new transactions during buffer reconfig */
945 if (old_state == CS_STATE_CONFIGURED)
946 hi->iface_state = CS_STATE_OPENED;
947 spin_unlock_bh(&hi->lock);
948
949 /*
950 * make sure that no non-zero data reads are ongoing before
951 * proceeding to change the buffer layout
952 */
953 r = cs_hsi_data_sync(hi);
954 if (r < 0)
955 return r;
956
957 WARN_ON(cs_state_xfer_active(hi->data_state));
958
959 spin_lock_bh(&hi->lock);
960 r = check_buf_params(hi, buf_cfg);
961 if (r < 0)
962 goto error;
963
964 hi->buf_size = buf_cfg->buf_size;
965 hi->mmap_cfg->buf_size = hi->buf_size;
966 hi->flags = buf_cfg->flags;
967
968 hi->rx_slot = 0;
969 hi->tx_slot = 0;
970 hi->slot_size = 0;
971
972 if (hi->buf_size)
973 cs_hsi_data_enable(hi, buf_cfg);
974 else
975 cs_hsi_data_disable(hi, old_state);
976
977 spin_unlock_bh(&hi->lock);
978
979 if (old_state != hi->iface_state) {
980 if (hi->iface_state == CS_STATE_CONFIGURED) {
981 pm_qos_add_request(&hi->pm_qos_req,
982 PM_QOS_CPU_DMA_LATENCY,
983 CS_QOS_LATENCY_FOR_DATA_USEC);
984 local_bh_disable();
985 cs_hsi_read_on_data(hi);
986 local_bh_enable();
987 } else if (old_state == CS_STATE_CONFIGURED) {
988 pm_qos_remove_request(&hi->pm_qos_req);
989 }
990 }
991 return r;
992
993error:
994 spin_unlock_bh(&hi->lock);
995 return r;
996}
997
998static int cs_hsi_start(struct cs_hsi_iface **hi, struct hsi_client *cl,
999 unsigned long mmap_base, unsigned long mmap_size)
1000{
1001 int err = 0;
1002 struct cs_hsi_iface *hsi_if = kzalloc(sizeof(*hsi_if), GFP_KERNEL);
1003
1004 dev_dbg(&cl->device, "cs_hsi_start\n");
1005
1006 if (!hsi_if) {
1007 err = -ENOMEM;
1008 goto leave0;
1009 }
1010 spin_lock_init(&hsi_if->lock);
1011 hsi_if->cl = cl;
1012 hsi_if->iface_state = CS_STATE_CLOSED;
1013 hsi_if->mmap_cfg = (struct cs_mmap_config_block *)mmap_base;
1014 hsi_if->mmap_base = mmap_base;
1015 hsi_if->mmap_size = mmap_size;
1016 memset(hsi_if->mmap_cfg, 0, sizeof(*hsi_if->mmap_cfg));
1017 init_waitqueue_head(&hsi_if->datawait);
1018 err = cs_alloc_cmds(hsi_if);
1019 if (err < 0) {
1020 dev_err(&cl->device, "Unable to alloc HSI messages\n");
1021 goto leave1;
1022 }
1023 err = cs_hsi_alloc_data(hsi_if);
1024 if (err < 0) {
1025 dev_err(&cl->device, "Unable to alloc HSI messages for data\n");
1026 goto leave2;
1027 }
1028 err = hsi_claim_port(cl, 1);
1029 if (err < 0) {
1030 dev_err(&cl->device,
1031 "Could not open, HSI port already claimed\n");
1032 goto leave3;
1033 }
1034 hsi_if->master = ssip_slave_get_master(cl);
1035 if (IS_ERR(hsi_if->master)) {
265ef3ee 1036 err = PTR_ERR(hsi_if->master);
7f62fe8a
KV		 1037 dev_err(&cl->device, "Could not get HSI master client\n");
1038 goto leave4;
1039 }
1040 if (!ssip_slave_running(hsi_if->master)) {
1041 err = -ENODEV;
1042 dev_err(&cl->device,
1043 "HSI port not initialized\n");
1044 goto leave4;
1045 }
1046
1047 hsi_if->iface_state = CS_STATE_OPENED;
1048 local_bh_disable();
1049 cs_hsi_read_on_control(hsi_if);
1050 local_bh_enable();
1051
1052 dev_dbg(&cl->device, "cs_hsi_start...done\n");
1053
1054 BUG_ON(!hi);
1055 *hi = hsi_if;
1056
1057 return 0;
1058
1059leave4:
1060 hsi_release_port(cl);
1061leave3:
1062 cs_hsi_free_data(hsi_if);
1063leave2:
1064 cs_free_cmds(hsi_if);
1065leave1:
1066 kfree(hsi_if);
1067leave0:
1068 dev_dbg(&cl->device, "cs_hsi_start...done/error\n\n");
1069
1070 return err;
1071}
1072
1073static void cs_hsi_stop(struct cs_hsi_iface *hi)
1074{
1075 dev_dbg(&hi->cl->device, "cs_hsi_stop\n");
1076 cs_hsi_set_wakeline(hi, 0);
1077 ssip_slave_put_master(hi->master);
1078
1079 /* hsi_release_port() needs to be called with CS_STATE_CLOSED */
1080 hi->iface_state = CS_STATE_CLOSED;
1081 hsi_release_port(hi->cl);
1082
1083 /*
1084 * hsi_release_port() should flush out all the pending
1085 * messages, so cs_state_idle() should be true for both
1086 * control and data channels.
1087 */
1088 WARN_ON(!cs_state_idle(hi->control_state));
1089 WARN_ON(!cs_state_idle(hi->data_state));
1090
1091 if (pm_qos_request_active(&hi->pm_qos_req))
1092 pm_qos_remove_request(&hi->pm_qos_req);
1093
1094 spin_lock_bh(&hi->lock);
1095 cs_hsi_free_data(hi);
1096 cs_free_cmds(hi);
1097 spin_unlock_bh(&hi->lock);
1098 kfree(hi);
1099}
1100
11bac800 1101static int cs_char_vma_fault(struct vm_fault *vmf)
7f62fe8a 1102{
11bac800 1103 struct cs_char *csdata = vmf->vma->vm_private_data;
7f62fe8a
KV		 1104 struct page *page;
1105
1106 page = virt_to_page(csdata->mmap_base);
1107 get_page(page);
1108 vmf->page = page;
1109
1110 return 0;
1111}
1112
7cbea8dc 1113static const struct vm_operations_struct cs_char_vm_ops = {
7f62fe8a
KV		 1114 .fault = cs_char_vma_fault,
1115};
1116
1117static int cs_char_fasync(int fd, struct file *file, int on)
1118{
1119 struct cs_char *csdata = file->private_data;
1120
1121 if (fasync_helper(fd, file, on, &csdata->async_queue) < 0)
1122 return -EIO;
1123
1124 return 0;
1125}
1126
afc9a42b 1127static __poll_t cs_char_poll(struct file *file, poll_table *wait)
7f62fe8a
KV		 1128{
1129 struct cs_char *csdata = file->private_data;
afc9a42b 1130 __poll_t ret = 0;
7f62fe8a
KV		 1131
1132 poll_wait(file, &cs_char_data.wait, wait);
1133 spin_lock_bh(&csdata->lock);
1134 if (!list_empty(&csdata->chardev_queue))
1135 ret = POLLIN | POLLRDNORM;
1136 else if (!list_empty(&csdata->dataind_queue))
1137 ret = POLLIN | POLLRDNORM;
1138 spin_unlock_bh(&csdata->lock);
1139
1140 return ret;
1141}
1142
1143static ssize_t cs_char_read(struct file *file, char __user *buf, size_t count,
1144 loff_t *unused)
1145{
1146 struct cs_char *csdata = file->private_data;
1147 u32 data;
1148 ssize_t retval;
1149
1150 if (count < sizeof(data))
1151 return -EINVAL;
1152
1153 for (;;) {
1154 DEFINE_WAIT(wait);
1155
1156 spin_lock_bh(&csdata->lock);
1157 if (!list_empty(&csdata->chardev_queue)) {
1158 data = cs_pop_entry(&csdata->chardev_queue);
1159 } else if (!list_empty(&csdata->dataind_queue)) {
1160 data = cs_pop_entry(&csdata->dataind_queue);
1161 csdata->dataind_pending--;
1162 } else {
1163 data = 0;
1164 }
1165 spin_unlock_bh(&csdata->lock);
1166
1167 if (data)
1168 break;
1169 if (file->f_flags & O_NONBLOCK) {
1170 retval = -EAGAIN;
1171 goto out;
1172 } else if (signal_pending(current)) {
1173 retval = -ERESTARTSYS;
1174 goto out;
1175 }
1176 prepare_to_wait_exclusive(&csdata->wait, &wait,
1177 TASK_INTERRUPTIBLE);
1178 schedule();
1179 finish_wait(&csdata->wait, &wait);
1180 }
1181
1182 retval = put_user(data, (u32 __user *)buf);
1183 if (!retval)
1184 retval = sizeof(data);
1185
1186out:
1187 return retval;
1188}
1189
1190static ssize_t cs_char_write(struct file *file, const char __user *buf,
1191 size_t count, loff_t *unused)
1192{
1193 struct cs_char *csdata = file->private_data;
1194 u32 data;
1195 int err;
1196 ssize_t retval;
1197
1198 if (count < sizeof(data))
1199 return -EINVAL;
1200
1201 if (get_user(data, (u32 __user *)buf))
1202 retval = -EFAULT;
1203 else
1204 retval = count;
1205
1206 err = cs_hsi_command(csdata->hi, data);
1207 if (err < 0)
1208 retval = err;
1209
1210 return retval;
1211}
1212
1213static long cs_char_ioctl(struct file *file, unsigned int cmd,
1214 unsigned long arg)
1215{
1216 struct cs_char *csdata = file->private_data;
1217 int r = 0;
1218
1219 switch (cmd) {
1220 case CS_GET_STATE: {
1221 unsigned int state;
1222
1223 state = cs_hsi_get_state(csdata->hi);
1224 if (copy_to_user((void __user *)arg, &state, sizeof(state)))
1225 r = -EFAULT;
1226
1227 break;
1228 }
1229 case CS_SET_WAKELINE: {
1230 unsigned int state;
1231
1232 if (copy_from_user(&state, (void __user *)arg, sizeof(state))) {
1233 r = -EFAULT;
1234 break;
1235 }
1236
1237 if (state > 1) {
1238 r = -EINVAL;
1239 break;
1240 }
1241
1242 cs_hsi_set_wakeline(csdata->hi, !!state);
1243
1244 break;
1245 }
1246 case CS_GET_IF_VERSION: {
1247 unsigned int ifver = CS_IF_VERSION;
1248
1249 if (copy_to_user((void __user *)arg, &ifver, sizeof(ifver)))
1250 r = -EFAULT;
1251
1252 break;
1253 }
1254 case CS_CONFIG_BUFS: {
1255 struct cs_buffer_config buf_cfg;
1256
1257 if (copy_from_user(&buf_cfg, (void __user *)arg,
1258 sizeof(buf_cfg)))
1259 r = -EFAULT;
1260 else
1261 r = cs_hsi_buf_config(csdata->hi, &buf_cfg);
1262
1263 break;
1264 }
1265 default:
1266 r = -ENOTTY;
1267 break;
1268 }
1269
1270 return r;
1271}
1272
1273static int cs_char_mmap(struct file *file, struct vm_area_struct *vma)
1274{
1275 if (vma->vm_end < vma->vm_start)
1276 return -EINVAL;
1277
f6004b7b 1278 if (vma_pages(vma) != 1)
7f62fe8a
KV		 1279 return -EINVAL;
1280
1281 vma->vm_flags |= VM_IO | VM_DONTDUMP | VM_DONTEXPAND;
1282 vma->vm_ops = &cs_char_vm_ops;
1283 vma->vm_private_data = file->private_data;
1284
1285 return 0;
1286}
1287
1288static int cs_char_open(struct inode *unused, struct file *file)
1289{
1290 int ret = 0;
1291 unsigned long p;
1292
1293 spin_lock_bh(&cs_char_data.lock);
1294 if (cs_char_data.opened) {
1295 ret = -EBUSY;
1296 spin_unlock_bh(&cs_char_data.lock);
1297 goto out1;
1298 }
1299 cs_char_data.opened = 1;
1300 cs_char_data.dataind_pending = 0;
1301 spin_unlock_bh(&cs_char_data.lock);
1302
1303 p = get_zeroed_page(GFP_KERNEL);
1304 if (!p) {
1305 ret = -ENOMEM;
1306 goto out2;
1307 }
1308
1309 ret = cs_hsi_start(&cs_char_data.hi, cs_char_data.cl, p, CS_MMAP_SIZE);
1310 if (ret) {
1311 dev_err(&cs_char_data.cl->device, "Unable to initialize HSI\n");
1312 goto out3;
1313 }
1314
1315 /* these are only used in release so lock not needed */
1316 cs_char_data.mmap_base = p;
1317 cs_char_data.mmap_size = CS_MMAP_SIZE;
1318
1319 file->private_data = &cs_char_data;
1320
1321 return 0;
1322
1323out3:
1324 free_page(p);
1325out2:
1326 spin_lock_bh(&cs_char_data.lock);
1327 cs_char_data.opened = 0;
1328 spin_unlock_bh(&cs_char_data.lock);
1329out1:
1330 return ret;
1331}
1332
1333static void cs_free_char_queue(struct list_head *head)
1334{
1335 struct char_queue *entry;
1336 struct list_head *cursor, *next;
1337
1338 if (!list_empty(head)) {
1339 list_for_each_safe(cursor, next, head) {
1340 entry = list_entry(cursor, struct char_queue, list);
1341 list_del(&entry->list);
1342 kfree(entry);
1343 }
1344 }
1345
1346}
1347
1348static int cs_char_release(struct inode *unused, struct file *file)
1349{
1350 struct cs_char *csdata = file->private_data;
1351
1352 cs_hsi_stop(csdata->hi);
1353 spin_lock_bh(&csdata->lock);
1354 csdata->hi = NULL;
1355 free_page(csdata->mmap_base);
1356 cs_free_char_queue(&csdata->chardev_queue);
1357 cs_free_char_queue(&csdata->dataind_queue);
1358 csdata->opened = 0;
1359 spin_unlock_bh(&csdata->lock);
1360
1361 return 0;
1362}
1363
1364static const struct file_operations cs_char_fops = {
1365 .owner = THIS_MODULE,
1366 .read = cs_char_read,
1367 .write = cs_char_write,
1368 .poll = cs_char_poll,
1369 .unlocked_ioctl = cs_char_ioctl,
1370 .mmap = cs_char_mmap,
1371 .open = cs_char_open,
1372 .release = cs_char_release,
1373 .fasync = cs_char_fasync,
1374};
1375
1376static struct miscdevice cs_char_miscdev = {
1377 .minor = MISC_DYNAMIC_MINOR,
1378 .name = "cmt_speech",
1379 .fops = &cs_char_fops
1380};
1381
1382static int cs_hsi_client_probe(struct device *dev)
1383{
1384 int err = 0;
1385 struct hsi_client *cl = to_hsi_client(dev);
1386
1387 dev_dbg(dev, "hsi_client_probe\n");
1388 init_waitqueue_head(&cs_char_data.wait);
1389 spin_lock_init(&cs_char_data.lock);
1390 cs_char_data.opened = 0;
1391 cs_char_data.cl = cl;
1392 cs_char_data.hi = NULL;
1393 INIT_LIST_HEAD(&cs_char_data.chardev_queue);
1394 INIT_LIST_HEAD(&cs_char_data.dataind_queue);
1395
1396 cs_char_data.channel_id_cmd = hsi_get_channel_id_by_name(cl,
1397 "speech-control");
1398 if (cs_char_data.channel_id_cmd < 0) {
1399 err = cs_char_data.channel_id_cmd;
1400 dev_err(dev, "Could not get cmd channel (%d)\n", err);
1401 return err;
1402 }
1403
1404 cs_char_data.channel_id_data = hsi_get_channel_id_by_name(cl,
1405 "speech-data");
1406 if (cs_char_data.channel_id_data < 0) {
1407 err = cs_char_data.channel_id_data;
1408 dev_err(dev, "Could not get data channel (%d)\n", err);
1409 return err;
1410 }
1411
1412 err = misc_register(&cs_char_miscdev);
1413 if (err)
1414 dev_err(dev, "Failed to register: %d\n", err);
1415
1416 return err;
1417}
1418
1419static int cs_hsi_client_remove(struct device *dev)
1420{
1421 struct cs_hsi_iface *hi;
1422
1423 dev_dbg(dev, "hsi_client_remove\n");
1424 misc_deregister(&cs_char_miscdev);
1425 spin_lock_bh(&cs_char_data.lock);
1426 hi = cs_char_data.hi;
1427 cs_char_data.hi = NULL;
1428 spin_unlock_bh(&cs_char_data.lock);
1429 if (hi)
1430 cs_hsi_stop(hi);
1431
1432 return 0;
1433}
1434
1435static struct hsi_client_driver cs_hsi_driver = {
1436 .driver = {
1437 .name = "cmt-speech",
1438 .owner = THIS_MODULE,
1439 .probe = cs_hsi_client_probe,
1440 .remove = cs_hsi_client_remove,
1441 },
1442};
1443
1444static int __init cs_char_init(void)
1445{
1446 pr_info("CMT speech driver added\n");
1447 return hsi_register_client_driver(&cs_hsi_driver);
1448}
1449module_init(cs_char_init);
1450
1451static void __exit cs_char_exit(void)
1452{
1453 hsi_unregister_client_driver(&cs_hsi_driver);
1454 pr_info("CMT speech driver removed\n");
1455}
1456module_exit(cs_char_exit);
1457
1458MODULE_ALIAS("hsi:cmt-speech");
1459MODULE_AUTHOR("Kai Vehmanen <kai.vehmanen@nokia.com>");
1460MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@nokia.com>");
1461MODULE_DESCRIPTION("CMT speech driver");
1462MODULE_LICENSE("GPL v2");
Ubuntu Jammy Linux kernel mirror