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.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 cs_hsi_control_read_error(hi, msg); 448 spin_unlock(&hi->lock); 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 timespec tspec; 455 struct cs_timestamp *tstamp = 456 &hi->mmap_cfg->tstamp_rx_ctrl; 457 458 ktime_get_ts(&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_area_struct *vma, struct vm_fault *vmf) 1102 { 1103 struct cs_char *csdata = 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->vm_end - vma->vm_start) >> PAGE_SHIFT) != 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