drivers/hsi/clients/cmt_speech.c

   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");