xref: /openbmc/linux/drivers/hsi/clients/cmt_speech.c (revision 9fb29c73)
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 vm_fault_t 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 __poll_t cs_char_poll(struct file *file, poll_table *wait)
1128 {
1129 	struct cs_char *csdata = file->private_data;
1130 	__poll_t 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 = EPOLLIN | EPOLLRDNORM;
1136 	else if (!list_empty(&csdata->dataind_queue))
1137 		ret = EPOLLIN | EPOLLRDNORM;
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");
1463