HSI: cmt_speech: use timespec64 instead of timespec
[muen/linux.git] / drivers / hsi / clients / cmt_speech.c
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>
34 #include <linux/sched/signal.h>
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
44 struct char_queue {
45         struct list_head        list;
46         u32                     msg;
47 };
48
49 struct 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)
92 struct 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
134 static struct cs_char cs_char_data;
135
136 static void cs_hsi_read_on_control(struct cs_hsi_iface *hi);
137 static void cs_hsi_read_on_data(struct cs_hsi_iface *hi);
138
139 static inline void rx_ptr_shift_too_big(void)
140 {
141         BUILD_BUG_ON((1LLU << RX_PTR_MAX_SHIFT) > UINT_MAX);
142 }
143
144 static 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
171 out:
172         return;
173 }
174
175 static 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
188 static void cs_notify_control(u32 message)
189 {
190         cs_notify(message, &cs_char_data.chardev_queue);
191 }
192
193 static 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
210 static 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
216 static inline u32 cs_get_cmd(struct hsi_msg *msg)
217 {
218         u32 *data = sg_virt(msg->sgt.sgl);
219         return *data;
220 }
221
222 static 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
229 static 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
252 static 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
265 static 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
277 static 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
302 out:
303         cs_free_cmds(hi);
304         return -ENOMEM;
305 }
306
307 static 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
331 static 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
359 out2:
360         hsi_free_msg(rxmsg);
361 out1:
362         return res;
363 }
364
365 static 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
372 static 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
378 static 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
387 static inline void __cs_hsi_error_post(struct cs_hsi_iface *hi)
388 {
389         spin_unlock(&hi->lock);
390 }
391
392 static 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
398 static 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
404 static 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
413 static 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
423 static 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
430 static 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
438 static 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");
447                 spin_unlock(&hi->lock);
448                 cs_hsi_control_read_error(hi, msg);
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) {
454                 struct timespec64 tspec;
455                 struct cs_timestamp *tstamp =
456                         &hi->mmap_cfg->tstamp_rx_ctrl;
457
458                 ktime_get_ts64(&tspec);
459
460                 tstamp->tv_sec = (__u32) tspec.tv_sec;
461                 tstamp->tv_nsec = (__u32) tspec.tv_nsec;
462         }
463         spin_unlock(&hi->lock);
464
465         cs_notify_control(cmd);
466
467 out:
468         cs_hsi_read_on_control(hi);
469 }
470
471 static 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
492 static 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
522 static 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
539 static 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
586 static 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
613 static 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  */
649 static 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  */
658 static inline int cs_state_idle(unsigned int state)
659 {
660         return !(state & ~SSI_CHANNEL_STATE_ERROR);
661 }
662
663 static 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
689 static 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
704 static 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
740 error:
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
748 static unsigned int cs_hsi_get_state(struct cs_hsi_iface *hi)
749 {
750         return hi->iface_state;
751 }
752
753 static 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
777 static 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
801 static 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
823 static 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  */
846 static 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
885 out:
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
892 static 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
928 static 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
937 static 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
993 error:
994         spin_unlock_bh(&hi->lock);
995         return r;
996 }
997
998 static 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)) {
1036                 err = PTR_ERR(hsi_if->master);
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
1059 leave4:
1060         hsi_release_port(cl);
1061 leave3:
1062         cs_hsi_free_data(hsi_if);
1063 leave2:
1064         cs_free_cmds(hsi_if);
1065 leave1:
1066         kfree(hsi_if);
1067 leave0:
1068         dev_dbg(&cl->device, "cs_hsi_start...done/error\n\n");
1069
1070         return err;
1071 }
1072
1073 static 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
1101 static int cs_char_vma_fault(struct vm_fault *vmf)
1102 {
1103         struct cs_char *csdata = vmf->vma->vm_private_data;
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
1113 static const struct vm_operations_struct cs_char_vm_ops = {
1114         .fault  = cs_char_vma_fault,
1115 };
1116
1117 static 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
1127 static unsigned int cs_char_poll(struct file *file, poll_table *wait)
1128 {
1129         struct cs_char *csdata = file->private_data;
1130         unsigned int ret = 0;
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
1143 static 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
1186 out:
1187         return retval;
1188 }
1189
1190 static 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
1213 static 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
1273 static 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
1278         if (vma_pages(vma) != 1)
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
1288 static 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
1323 out3:
1324         free_page(p);
1325 out2:
1326         spin_lock_bh(&cs_char_data.lock);
1327         cs_char_data.opened = 0;
1328         spin_unlock_bh(&cs_char_data.lock);
1329 out1:
1330         return ret;
1331 }
1332
1333 static 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
1348 static 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
1364 static 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
1376 static struct miscdevice cs_char_miscdev = {
1377         .minor  = MISC_DYNAMIC_MINOR,
1378         .name   = "cmt_speech",
1379         .fops   = &cs_char_fops
1380 };
1381
1382 static 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
1419 static 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
1435 static 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
1444 static 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 }
1449 module_init(cs_char_init);
1450
1451 static void __exit cs_char_exit(void)
1452 {
1453         hsi_unregister_client_driver(&cs_hsi_driver);
1454         pr_info("CMT speech driver removed\n");
1455 }
1456 module_exit(cs_char_exit);
1457
1458 MODULE_ALIAS("hsi:cmt-speech");
1459 MODULE_AUTHOR("Kai Vehmanen <kai.vehmanen@nokia.com>");
1460 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@nokia.com>");
1461 MODULE_DESCRIPTION("CMT speech driver");
1462 MODULE_LICENSE("GPL v2");