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