drivers/hid/intel-ish-hid/ishtp/hbm.c

   1 /*
   2  * ISHTP bus layer messages handling
   3  *
   4  * Copyright (c) 2003-2016, Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16
  17 #include <linux/export.h>
  18 #include <linux/slab.h>
  19 #include <linux/sched.h>
  20 #include <linux/wait.h>
  21 #include <linux/spinlock.h>
  22 #include <linux/miscdevice.h>
  23 #include "ishtp-dev.h"
  24 #include "hbm.h"
  25 #include "client.h"
  26
  27 /**
  28  * ishtp_hbm_fw_cl_allocate() - Allocate FW clients
  29  * @dev: ISHTP device instance
  30  *
  31  * Allocates storage for fw clients
  32  */
  33 static void ishtp_hbm_fw_cl_allocate(struct ishtp_device *dev)
  34 {
  35         struct ishtp_fw_client *clients;
  36         int b;
  37
  38         /* count how many ISH clients we have */
  39         for_each_set_bit(b, dev->fw_clients_map, ISHTP_CLIENTS_MAX)
  40                 dev->fw_clients_num++;
  41
  42         if (dev->fw_clients_num <= 0)
  43                 return;
  44
  45         /* allocate storage for fw clients representation */
  46         clients = kcalloc(dev->fw_clients_num, sizeof(struct ishtp_fw_client),
  47                           GFP_KERNEL);
  48         if (!clients) {
  49                 dev->dev_state = ISHTP_DEV_RESETTING;
  50                 ish_hw_reset(dev);
  51                 return;
  52         }
  53         dev->fw_clients = clients;
  54 }
  55
  56 /**
  57  * ishtp_hbm_cl_hdr() - construct client hbm header
  58  * @cl: client
  59  * @hbm_cmd: host bus message command
  60  * @buf: buffer for cl header
  61  * @len: buffer length
  62  *
  63  * Initialize HBM buffer
  64  */
  65 static inline void ishtp_hbm_cl_hdr(struct ishtp_cl *cl, uint8_t hbm_cmd,
  66         void *buf, size_t len)
  67 {
  68         struct ishtp_hbm_cl_cmd *cmd = buf;
  69
  70         memset(cmd, 0, len);
  71
  72         cmd->hbm_cmd = hbm_cmd;
  73         cmd->host_addr = cl->host_client_id;
  74         cmd->fw_addr = cl->fw_client_id;
  75 }
  76
  77 /**
  78  * ishtp_hbm_cl_addr_equal() - Compare client address
  79  * @cl: client
  80  * @buf: Client command buffer
  81  *
  82  * Compare client address with the address in command buffer
  83  *
  84  * Return: True if they have the same address
  85  */
  86 static inline bool ishtp_hbm_cl_addr_equal(struct ishtp_cl *cl, void *buf)
  87 {
  88         struct ishtp_hbm_cl_cmd *cmd = buf;
  89
  90         return cl->host_client_id == cmd->host_addr &&
  91                 cl->fw_client_id == cmd->fw_addr;
  92 }
  93
  94 /**
  95  * ishtp_hbm_start_wait() - Wait for HBM start message
  96  * @dev: ISHTP device instance
  97  *
  98  * Wait for HBM start message from firmware
  99  *
 100  * Return: 0 if HBM start is/was received else timeout error
 101  */
 102 int ishtp_hbm_start_wait(struct ishtp_device *dev)
 103 {
 104         int ret;
 105
 106         if (dev->hbm_state > ISHTP_HBM_START)
 107                 return 0;
 108
 109         dev_dbg(dev->devc, "Going to wait for ishtp start. hbm_state=%08X\n",
 110                 dev->hbm_state);
 111         ret = wait_event_interruptible_timeout(dev->wait_hbm_recvd_msg,
 112                                         dev->hbm_state >= ISHTP_HBM_STARTED,
 113                                         (ISHTP_INTEROP_TIMEOUT * HZ));
 114
 115         dev_dbg(dev->devc,
 116                 "Woke up from waiting for ishtp start. hbm_state=%08X\n",
 117                 dev->hbm_state);
 118
 119         if (ret <= 0 && (dev->hbm_state <= ISHTP_HBM_START)) {
 120                 dev->hbm_state = ISHTP_HBM_IDLE;
 121                 dev_err(dev->devc,
 122                 "waiting for ishtp start failed. ret=%d hbm_state=%08X\n",
 123                         ret, dev->hbm_state);
 124                 return -ETIMEDOUT;
 125         }
 126         return 0;
 127 }
 128
 129 /**
 130  * ishtp_hbm_start_req() - Send HBM start message
 131  * @dev: ISHTP device instance
 132  *
 133  * Send HBM start message to firmware
 134  *
 135  * Return: 0 if success else error code
 136  */
 137 int ishtp_hbm_start_req(struct ishtp_device *dev)
 138 {
 139         struct ishtp_msg_hdr hdr;
 140         unsigned char data[128];
 141         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 142         struct hbm_host_version_request *start_req;
 143         const size_t len = sizeof(struct hbm_host_version_request);
 144
 145         ishtp_hbm_hdr(ishtp_hdr, len);
 146
 147         /* host start message */
 148         start_req = (struct hbm_host_version_request *)data;
 149         memset(start_req, 0, len);
 150         start_req->hbm_cmd = HOST_START_REQ_CMD;
 151         start_req->host_version.major_version = HBM_MAJOR_VERSION;
 152         start_req->host_version.minor_version = HBM_MINOR_VERSION;
 153
 154         /*
 155          * (!) Response to HBM start may be so quick that this thread would get
 156          * preempted BEFORE managing to set hbm_state = ISHTP_HBM_START.
 157          * So set it at first, change back to ISHTP_HBM_IDLE upon failure
 158          */
 159         dev->hbm_state = ISHTP_HBM_START;
 160         if (ishtp_write_message(dev, ishtp_hdr, data)) {
 161                 dev_err(dev->devc, "version message send failed\n");
 162                 dev->dev_state = ISHTP_DEV_RESETTING;
 163                 dev->hbm_state = ISHTP_HBM_IDLE;
 164                 ish_hw_reset(dev);
 165                 return -ENODEV;
 166         }
 167
 168         return 0;
 169 }
 170
 171 /**
 172  * ishtp_hbm_enum_clients_req() - Send client enum req
 173  * @dev: ISHTP device instance
 174  *
 175  * Send enumeration client request message
 176  *
 177  * Return: 0 if success else error code
 178  */
 179 void ishtp_hbm_enum_clients_req(struct ishtp_device *dev)
 180 {
 181         struct ishtp_msg_hdr hdr;
 182         unsigned char data[128];
 183         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 184         struct hbm_host_enum_request *enum_req;
 185         const size_t len = sizeof(struct hbm_host_enum_request);
 186
 187         /* enumerate clients */
 188         ishtp_hbm_hdr(ishtp_hdr, len);
 189
 190         enum_req = (struct hbm_host_enum_request *)data;
 191         memset(enum_req, 0, len);
 192         enum_req->hbm_cmd = HOST_ENUM_REQ_CMD;
 193
 194         if (ishtp_write_message(dev, ishtp_hdr, data)) {
 195                 dev->dev_state = ISHTP_DEV_RESETTING;
 196                 dev_err(dev->devc, "enumeration request send failed\n");
 197                 ish_hw_reset(dev);
 198         }
 199         dev->hbm_state = ISHTP_HBM_ENUM_CLIENTS;
 200 }
 201
 202 /**
 203  * ishtp_hbm_prop_req() - Request property
 204  * @dev: ISHTP device instance
 205  *
 206  * Request property for a single client
 207  *
 208  * Return: 0 if success else error code
 209  */
 210 static int ishtp_hbm_prop_req(struct ishtp_device *dev)
 211 {
 212
 213         struct ishtp_msg_hdr hdr;
 214         unsigned char data[128];
 215         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 216         struct hbm_props_request *prop_req;
 217         const size_t len = sizeof(struct hbm_props_request);
 218         unsigned long next_client_index;
 219         uint8_t client_num;
 220
 221         client_num = dev->fw_client_presentation_num;
 222
 223         next_client_index = find_next_bit(dev->fw_clients_map,
 224                 ISHTP_CLIENTS_MAX, dev->fw_client_index);
 225
 226         /* We got all client properties */
 227         if (next_client_index == ISHTP_CLIENTS_MAX) {
 228                 dev->hbm_state = ISHTP_HBM_WORKING;
 229                 dev->dev_state = ISHTP_DEV_ENABLED;
 230
 231                 for (dev->fw_client_presentation_num = 1;
 232                         dev->fw_client_presentation_num < client_num + 1;
 233                                 ++dev->fw_client_presentation_num)
 234                         /* Add new client device */
 235                         ishtp_bus_new_client(dev);
 236                 return 0;
 237         }
 238
 239         dev->fw_clients[client_num].client_id = next_client_index;
 240
 241         ishtp_hbm_hdr(ishtp_hdr, len);
 242         prop_req = (struct hbm_props_request *)data;
 243
 244         memset(prop_req, 0, sizeof(struct hbm_props_request));
 245
 246         prop_req->hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
 247         prop_req->address = next_client_index;
 248
 249         if (ishtp_write_message(dev, ishtp_hdr, data)) {
 250                 dev->dev_state = ISHTP_DEV_RESETTING;
 251                 dev_err(dev->devc, "properties request send failed\n");
 252                 ish_hw_reset(dev);
 253                 return -EIO;
 254         }
 255
 256         dev->fw_client_index = next_client_index;
 257
 258         return 0;
 259 }
 260
 261 /**
 262  * ishtp_hbm_stop_req() - Send HBM stop
 263  * @dev: ISHTP device instance
 264  *
 265  * Send stop request message
 266  */
 267 static void ishtp_hbm_stop_req(struct ishtp_device *dev)
 268 {
 269         struct ishtp_msg_hdr hdr;
 270         unsigned char data[128];
 271         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 272         struct hbm_host_stop_request *req;
 273         const size_t len = sizeof(struct hbm_host_stop_request);
 274
 275         ishtp_hbm_hdr(ishtp_hdr, len);
 276         req = (struct hbm_host_stop_request *)data;
 277
 278         memset(req, 0, sizeof(struct hbm_host_stop_request));
 279         req->hbm_cmd = HOST_STOP_REQ_CMD;
 280         req->reason = DRIVER_STOP_REQUEST;
 281
 282         ishtp_write_message(dev, ishtp_hdr, data);
 283 }
 284
 285 /**
 286  * ishtp_hbm_cl_flow_control_req() - Send flow control request
 287  * @dev: ISHTP device instance
 288  * @cl: ISHTP client instance
 289  *
 290  * Send flow control request
 291  *
 292  * Return: 0 if success else error code
 293  */
 294 int ishtp_hbm_cl_flow_control_req(struct ishtp_device *dev,
 295                                   struct ishtp_cl *cl)
 296 {
 297         struct ishtp_msg_hdr hdr;
 298         unsigned char data[128];
 299         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 300         const size_t len = sizeof(struct hbm_flow_control);
 301         int     rv;
 302         unsigned int    num_frags;
 303         unsigned long   flags;
 304
 305         spin_lock_irqsave(&cl->fc_spinlock, flags);
 306         ishtp_hbm_hdr(ishtp_hdr, len);
 307         ishtp_hbm_cl_hdr(cl, ISHTP_FLOW_CONTROL_CMD, data, len);
 308
 309         /*
 310          * Sync possible race when RB recycle and packet receive paths
 311          * both try to send an out FC
 312          */
 313         if (cl->out_flow_ctrl_creds) {
 314                 spin_unlock_irqrestore(&cl->fc_spinlock, flags);
 315                 return  0;
 316         }
 317
 318         num_frags = cl->recv_msg_num_frags;
 319         cl->recv_msg_num_frags = 0;
 320
 321         rv = ishtp_write_message(dev, ishtp_hdr, data);
 322         if (!rv) {
 323                 ++cl->out_flow_ctrl_creds;
 324                 ++cl->out_flow_ctrl_cnt;
 325                 getnstimeofday(&cl->ts_out_fc);
 326                 if (cl->ts_rx.tv_sec && cl->ts_rx.tv_nsec) {
 327                         struct timespec ts_diff;
 328
 329                         ts_diff = timespec_sub(cl->ts_out_fc, cl->ts_rx);
 330                         if (timespec_compare(&ts_diff, &cl->ts_max_fc_delay)
 331                                         > 0)
 332                                 cl->ts_max_fc_delay = ts_diff;
 333                 }
 334         } else {
 335                 ++cl->err_send_fc;
 336         }
 337
 338         spin_unlock_irqrestore(&cl->fc_spinlock, flags);
 339         return  rv;
 340 }
 341
 342 /**
 343  * ishtp_hbm_cl_disconnect_req() - Send disconnect request
 344  * @dev: ISHTP device instance
 345  * @cl: ISHTP client instance
 346  *
 347  * Send disconnect message to fw
 348  *
 349  * Return: 0 if success else error code
 350  */
 351 int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
 352 {
 353         struct ishtp_msg_hdr hdr;
 354         unsigned char data[128];
 355         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 356         const size_t len = sizeof(struct hbm_client_connect_request);
 357
 358         ishtp_hbm_hdr(ishtp_hdr, len);
 359         ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_REQ_CMD, data, len);
 360
 361         return ishtp_write_message(dev, ishtp_hdr, data);
 362 }
 363
 364 /**
 365  * ishtp_hbm_cl_disconnect_res() - Get disconnect response
 366  * @dev: ISHTP device instance
 367  * @rs: Response message
 368  *
 369  * Received disconnect response from fw
 370  */
 371 static void ishtp_hbm_cl_disconnect_res(struct ishtp_device *dev,
 372         struct hbm_client_connect_response *rs)
 373 {
 374         struct ishtp_cl *cl = NULL;
 375         unsigned long   flags;
 376
 377         spin_lock_irqsave(&dev->cl_list_lock, flags);
 378         list_for_each_entry(cl, &dev->cl_list, link) {
 379                 if (!rs->status && ishtp_hbm_cl_addr_equal(cl, rs)) {
 380                         cl->state = ISHTP_CL_DISCONNECTED;
 381                         break;
 382                 }
 383         }
 384         if (cl)
 385                 wake_up_interruptible(&cl->wait_ctrl_res);
 386         spin_unlock_irqrestore(&dev->cl_list_lock, flags);
 387 }
 388
 389 /**
 390  * ishtp_hbm_cl_connect_req() - Send connect request
 391  * @dev: ISHTP device instance
 392  * @cl: client device instance
 393  *
 394  * Send connection request to specific fw client
 395  *
 396  * Return: 0 if success else error code
 397  */
 398 int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl)
 399 {
 400         struct ishtp_msg_hdr hdr;
 401         unsigned char data[128];
 402         struct ishtp_msg_hdr *ishtp_hdr = &hdr;
 403         const size_t len = sizeof(struct hbm_client_connect_request);
 404
 405         ishtp_hbm_hdr(ishtp_hdr, len);
 406         ishtp_hbm_cl_hdr(cl, CLIENT_CONNECT_REQ_CMD, data, len);
 407
 408         return ishtp_write_message(dev, ishtp_hdr, data);
 409 }
 410
 411 /**
 412  * ishtp_hbm_cl_connect_res() - Get connect response
 413  * @dev: ISHTP device instance
 414  * @rs: Response message
 415  *
 416  * Received connect response from fw
 417  */
 418 static void ishtp_hbm_cl_connect_res(struct ishtp_device *dev,
 419         struct hbm_client_connect_response *rs)
 420 {
 421         struct ishtp_cl *cl = NULL;
 422         unsigned long   flags;
 423
 424         spin_lock_irqsave(&dev->cl_list_lock, flags);
 425         list_for_each_entry(cl, &dev->cl_list, link) {
 426                 if (ishtp_hbm_cl_addr_equal(cl, rs)) {
 427                         if (!rs->status) {
 428                                 cl->state = ISHTP_CL_CONNECTED;
 429                                 cl->status = 0;
 430                         } else {
 431                                 cl->state = ISHTP_CL_DISCONNECTED;
 432                                 cl->status = -ENODEV;
 433                         }
 434                         break;
 435                 }
 436         }
 437         if (cl)
 438                 wake_up_interruptible(&cl->wait_ctrl_res);
 439         spin_unlock_irqrestore(&dev->cl_list_lock, flags);
 440 }
 441
 442 /**
 443  * ishtp_client_disconnect_request() - Receive disconnect request
 444  * @dev: ISHTP device instance
 445  * @disconnect_req: disconnect request structure
 446  *
 447  * Disconnect request bus message from the fw. Send diconnect response.
 448  */
 449 static void ishtp_hbm_fw_disconnect_req(struct ishtp_device *dev,
 450         struct hbm_client_connect_request *disconnect_req)
 451 {
 452         struct ishtp_cl *cl;
 453         const size_t len = sizeof(struct hbm_client_connect_response);
 454         unsigned long   flags;
 455         struct ishtp_msg_hdr hdr;
 456         unsigned char data[4];  /* All HBM messages are 4 bytes */
 457
 458         spin_lock_irqsave(&dev->cl_list_lock, flags);
 459         list_for_each_entry(cl, &dev->cl_list, link) {
 460                 if (ishtp_hbm_cl_addr_equal(cl, disconnect_req)) {
 461                         cl->state = ISHTP_CL_DISCONNECTED;
 462
 463                         /* send disconnect response */
 464                         ishtp_hbm_hdr(&hdr, len);
 465                         ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, data,
 466                                 len);
 467                         ishtp_write_message(dev, &hdr, data);
 468                         break;
 469                 }
 470         }
 471         spin_unlock_irqrestore(&dev->cl_list_lock, flags);
 472 }
 473
 474 /**
 475  * ishtp_hbm_dma_xfer_ack(() - Receive transfer ACK
 476  * @dev: ISHTP device instance
 477  * @dma_xfer: HBM transfer message
 478  *
 479  * Receive ack for ISHTP-over-DMA client message
 480  */
 481 static void ishtp_hbm_dma_xfer_ack(struct ishtp_device *dev,
 482                                    struct dma_xfer_hbm *dma_xfer)
 483 {
 484         void    *msg;
 485         uint64_t        offs;
 486         struct ishtp_msg_hdr    *ishtp_hdr =
 487                 (struct ishtp_msg_hdr *)&dev->ishtp_msg_hdr;
 488         unsigned int    msg_offs;
 489         struct ishtp_cl *cl;
 490
 491         for (msg_offs = 0; msg_offs < ishtp_hdr->length;
 492                 msg_offs += sizeof(struct dma_xfer_hbm)) {
 493                 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_tx_buf_phys;
 494                 if (offs > dev->ishtp_host_dma_tx_buf_size) {
 495                         dev_err(dev->devc, "Bad DMA Tx ack message address\n");
 496                         return;
 497                 }
 498                 if (dma_xfer->msg_length >
 499                                 dev->ishtp_host_dma_tx_buf_size - offs) {
 500                         dev_err(dev->devc, "Bad DMA Tx ack message size\n");
 501                         return;
 502                 }
 503
 504                 /* logical address of the acked mem */
 505                 msg = (unsigned char *)dev->ishtp_host_dma_tx_buf + offs;
 506                 ishtp_cl_release_dma_acked_mem(dev, msg, dma_xfer->msg_length);
 507
 508                 list_for_each_entry(cl, &dev->cl_list, link) {
 509                         if (cl->fw_client_id == dma_xfer->fw_client_id &&
 510                             cl->host_client_id == dma_xfer->host_client_id)
 511                                 /*
 512                                  * in case that a single ack may be sent
 513                                  * over several dma transfers, and the last msg
 514                                  * addr was inside the acked memory, but not in
 515                                  * its start
 516                                  */
 517                                 if (cl->last_dma_addr >=
 518                                                         (unsigned char *)msg &&
 519                                                 cl->last_dma_addr <
 520                                                 (unsigned char *)msg +
 521                                                 dma_xfer->msg_length) {
 522                                         cl->last_dma_acked = 1;
 523
 524                                         if (!list_empty(&cl->tx_list.list) &&
 525                                                 cl->ishtp_flow_ctrl_creds) {
 526                                                 /*
 527                                                  * start sending the first msg
 528                                                  */
 529                                                 ishtp_cl_send_msg(dev, cl);
 530                                         }
 531                                 }
 532                 }
 533                 ++dma_xfer;
 534         }
 535 }
 536
 537 /**
 538  * ishtp_hbm_dma_xfer() - Receive DMA transfer message
 539  * @dev: ISHTP device instance
 540  * @dma_xfer: HBM transfer message
 541  *
 542  * Receive ISHTP-over-DMA client message
 543  */
 544 static void ishtp_hbm_dma_xfer(struct ishtp_device *dev,
 545                                struct dma_xfer_hbm *dma_xfer)
 546 {
 547         void    *msg;
 548         uint64_t        offs;
 549         struct ishtp_msg_hdr    hdr;
 550         struct ishtp_msg_hdr    *ishtp_hdr =
 551                 (struct ishtp_msg_hdr *) &dev->ishtp_msg_hdr;
 552         struct dma_xfer_hbm     *prm = dma_xfer;
 553         unsigned int    msg_offs;
 554
 555         for (msg_offs = 0; msg_offs < ishtp_hdr->length;
 556                 msg_offs += sizeof(struct dma_xfer_hbm)) {
 557
 558                 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_rx_buf_phys;
 559                 if (offs > dev->ishtp_host_dma_rx_buf_size) {
 560                         dev_err(dev->devc, "Bad DMA Rx message address\n");
 561                         return;
 562                 }
 563                 if (dma_xfer->msg_length >
 564                                 dev->ishtp_host_dma_rx_buf_size - offs) {
 565                         dev_err(dev->devc, "Bad DMA Rx message size\n");
 566                         return;
 567                 }
 568                 msg = dev->ishtp_host_dma_rx_buf + offs;
 569                 recv_ishtp_cl_msg_dma(dev, msg, dma_xfer);
 570                 dma_xfer->hbm = DMA_XFER_ACK;   /* Prepare for response */
 571                 ++dma_xfer;
 572         }
 573
 574         /* Send DMA_XFER_ACK [...] */
 575         ishtp_hbm_hdr(&hdr, ishtp_hdr->length);
 576         ishtp_write_message(dev, &hdr, (unsigned char *)prm);
 577 }
 578
 579 /**
 580  * ishtp_hbm_dispatch() - HBM dispatch function
 581  * @dev: ISHTP device instance
 582  * @hdr: bus message
 583  *
 584  * Bottom half read routine after ISR to handle the read bus message cmd
 585  * processing
 586  */
 587 void ishtp_hbm_dispatch(struct ishtp_device *dev,
 588                         struct ishtp_bus_message *hdr)
 589 {
 590         struct ishtp_bus_message *ishtp_msg;
 591         struct ishtp_fw_client *fw_client;
 592         struct hbm_host_version_response *version_res;
 593         struct hbm_client_connect_response *connect_res;
 594         struct hbm_client_connect_response *disconnect_res;
 595         struct hbm_client_connect_request *disconnect_req;
 596         struct hbm_props_response *props_res;
 597         struct hbm_host_enum_response *enum_res;
 598         struct ishtp_msg_hdr ishtp_hdr;
 599         struct dma_alloc_notify dma_alloc_notify;
 600         struct dma_xfer_hbm     *dma_xfer;
 601
 602         ishtp_msg = hdr;
 603
 604         switch (ishtp_msg->hbm_cmd) {
 605         case HOST_START_RES_CMD:
 606                 version_res = (struct hbm_host_version_response *)ishtp_msg;
 607                 if (!version_res->host_version_supported) {
 608                         dev->version = version_res->fw_max_version;
 609
 610                         dev->hbm_state = ISHTP_HBM_STOPPED;
 611                         ishtp_hbm_stop_req(dev);
 612                         return;
 613                 }
 614
 615                 dev->version.major_version = HBM_MAJOR_VERSION;
 616                 dev->version.minor_version = HBM_MINOR_VERSION;
 617                 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
 618                                 dev->hbm_state == ISHTP_HBM_START) {
 619                         dev->hbm_state = ISHTP_HBM_STARTED;
 620                         ishtp_hbm_enum_clients_req(dev);
 621                 } else {
 622                         dev_err(dev->devc,
 623                                 "reset: wrong host start response\n");
 624                         /* BUG: why do we arrive here? */
 625                         ish_hw_reset(dev);
 626                         return;
 627                 }
 628
 629                 wake_up_interruptible(&dev->wait_hbm_recvd_msg);
 630                 break;
 631
 632         case CLIENT_CONNECT_RES_CMD:
 633                 connect_res = (struct hbm_client_connect_response *)ishtp_msg;
 634                 ishtp_hbm_cl_connect_res(dev, connect_res);
 635                 break;
 636
 637         case CLIENT_DISCONNECT_RES_CMD:
 638                 disconnect_res =
 639                         (struct hbm_client_connect_response *)ishtp_msg;
 640                 ishtp_hbm_cl_disconnect_res(dev, disconnect_res);
 641                 break;
 642
 643         case HOST_CLIENT_PROPERTIES_RES_CMD:
 644                 props_res = (struct hbm_props_response *)ishtp_msg;
 645                 fw_client = &dev->fw_clients[dev->fw_client_presentation_num];
 646
 647                 if (props_res->status || !dev->fw_clients) {
 648                         dev_err(dev->devc,
 649                         "reset: properties response hbm wrong status\n");
 650                         ish_hw_reset(dev);
 651                         return;
 652                 }
 653
 654                 if (fw_client->client_id != props_res->address) {
 655                         dev_err(dev->devc,
 656                                 "reset: host properties response address mismatch [%02X %02X]\n",
 657                                 fw_client->client_id, props_res->address);
 658                         ish_hw_reset(dev);
 659                         return;
 660                 }
 661
 662                 if (dev->dev_state != ISHTP_DEV_INIT_CLIENTS ||
 663                         dev->hbm_state != ISHTP_HBM_CLIENT_PROPERTIES) {
 664                         dev_err(dev->devc,
 665                                 "reset: unexpected properties response\n");
 666                         ish_hw_reset(dev);
 667                         return;
 668                 }
 669
 670                 fw_client->props = props_res->client_properties;
 671                 dev->fw_client_index++;
 672                 dev->fw_client_presentation_num++;
 673
 674                 /* request property for the next client */
 675                 ishtp_hbm_prop_req(dev);
 676
 677                 if (dev->dev_state != ISHTP_DEV_ENABLED)
 678                         break;
 679
 680                 if (!ishtp_use_dma_transfer())
 681                         break;
 682
 683                 dev_dbg(dev->devc, "Requesting to use DMA\n");
 684                 ishtp_cl_alloc_dma_buf(dev);
 685                 if (dev->ishtp_host_dma_rx_buf) {
 686                         const size_t len = sizeof(dma_alloc_notify);
 687
 688                         memset(&dma_alloc_notify, 0, sizeof(dma_alloc_notify));
 689                         dma_alloc_notify.hbm = DMA_BUFFER_ALLOC_NOTIFY;
 690                         dma_alloc_notify.buf_size =
 691                                         dev->ishtp_host_dma_rx_buf_size;
 692                         dma_alloc_notify.buf_address =
 693                                         dev->ishtp_host_dma_rx_buf_phys;
 694                         ishtp_hbm_hdr(&ishtp_hdr, len);
 695                         ishtp_write_message(dev, &ishtp_hdr,
 696                                 (unsigned char *)&dma_alloc_notify);
 697                 }
 698
 699                 break;
 700
 701         case HOST_ENUM_RES_CMD:
 702                 enum_res = (struct hbm_host_enum_response *) ishtp_msg;
 703                 memcpy(dev->fw_clients_map, enum_res->valid_addresses, 32);
 704                 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS &&
 705                         dev->hbm_state == ISHTP_HBM_ENUM_CLIENTS) {
 706                         dev->fw_client_presentation_num = 0;
 707                         dev->fw_client_index = 0;
 708
 709                         ishtp_hbm_fw_cl_allocate(dev);
 710                         dev->hbm_state = ISHTP_HBM_CLIENT_PROPERTIES;
 711
 712                         /* first property request */
 713                         ishtp_hbm_prop_req(dev);
 714                 } else {
 715                         dev_err(dev->devc,
 716                               "reset: unexpected enumeration response hbm\n");
 717                         ish_hw_reset(dev);
 718                         return;
 719                 }
 720                 break;
 721
 722         case HOST_STOP_RES_CMD:
 723                 if (dev->hbm_state != ISHTP_HBM_STOPPED)
 724                         dev_err(dev->devc, "unexpected stop response\n");
 725
 726                 dev->dev_state = ISHTP_DEV_DISABLED;
 727                 dev_info(dev->devc, "reset: FW stop response\n");
 728                 ish_hw_reset(dev);
 729                 break;
 730
 731         case CLIENT_DISCONNECT_REQ_CMD:
 732                 /* search for client */
 733                 disconnect_req =
 734                         (struct hbm_client_connect_request *)ishtp_msg;
 735                 ishtp_hbm_fw_disconnect_req(dev, disconnect_req);
 736                 break;
 737
 738         case FW_STOP_REQ_CMD:
 739                 dev->hbm_state = ISHTP_HBM_STOPPED;
 740                 break;
 741
 742         case DMA_BUFFER_ALLOC_RESPONSE:
 743                 dev->ishtp_host_dma_enabled = 1;
 744                 break;
 745
 746         case DMA_XFER:
 747                 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
 748                 if (!dev->ishtp_host_dma_enabled) {
 749                         dev_err(dev->devc,
 750                                 "DMA XFER requested but DMA is not enabled\n");
 751                         break;
 752                 }
 753                 ishtp_hbm_dma_xfer(dev, dma_xfer);
 754                 break;
 755
 756         case DMA_XFER_ACK:
 757                 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg;
 758                 if (!dev->ishtp_host_dma_enabled ||
 759                     !dev->ishtp_host_dma_tx_buf) {
 760                         dev_err(dev->devc,
 761                                 "DMA XFER acked but DMA Tx is not enabled\n");
 762                         break;
 763                 }
 764                 ishtp_hbm_dma_xfer_ack(dev, dma_xfer);
 765                 break;
 766
 767         default:
 768                 dev_err(dev->devc, "unknown HBM: %u\n",
 769                         (unsigned int)ishtp_msg->hbm_cmd);
 770
 771                 break;
 772         }
 773 }
 774
 775 /**
 776  * bh_hbm_work_fn() - HBM work function
 777  * @work: work struct
 778  *
 779  * Bottom half processing work function (instead of thread handler)
 780  * for processing hbm messages
 781  */
 782 void    bh_hbm_work_fn(struct work_struct *work)
 783 {
 784         unsigned long   flags;
 785         struct ishtp_device     *dev;
 786         unsigned char   hbm[IPC_PAYLOAD_SIZE];
 787
 788         dev = container_of(work, struct ishtp_device, bh_hbm_work);
 789         spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
 790         if (dev->rd_msg_fifo_head != dev->rd_msg_fifo_tail) {
 791                 memcpy(hbm, dev->rd_msg_fifo + dev->rd_msg_fifo_head,
 792                         IPC_PAYLOAD_SIZE);
 793                 dev->rd_msg_fifo_head =
 794                         (dev->rd_msg_fifo_head + IPC_PAYLOAD_SIZE) %
 795                         (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
 796                 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 797                 ishtp_hbm_dispatch(dev, (struct ishtp_bus_message *)hbm);
 798         } else {
 799                 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 800         }
 801 }
 802
 803 /**
 804  * recv_hbm() - Receive HBM message
 805  * @dev: ISHTP device instance
 806  * @ishtp_hdr: received bus message
 807  *
 808  * Receive and process ISHTP bus messages in ISR context. This will schedule
 809  * work function to process message
 810  */
 811 void    recv_hbm(struct ishtp_device *dev, struct ishtp_msg_hdr *ishtp_hdr)
 812 {
 813         uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
 814         struct ishtp_bus_message        *ishtp_msg =
 815                 (struct ishtp_bus_message *)rd_msg_buf;
 816         unsigned long   flags;
 817
 818         dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
 819
 820         /* Flow control - handle in place */
 821         if (ishtp_msg->hbm_cmd == ISHTP_FLOW_CONTROL_CMD) {
 822                 struct hbm_flow_control *flow_control =
 823                         (struct hbm_flow_control *)ishtp_msg;
 824                 struct ishtp_cl *cl = NULL;
 825                 unsigned long   flags, tx_flags;
 826
 827                 spin_lock_irqsave(&dev->cl_list_lock, flags);
 828                 list_for_each_entry(cl, &dev->cl_list, link) {
 829                         if (cl->host_client_id == flow_control->host_addr &&
 830                                         cl->fw_client_id ==
 831                                         flow_control->fw_addr) {
 832                                 /*
 833                                  * NOTE: It's valid only for counting
 834                                  * flow-control implementation to receive a
 835                                  * FC in the middle of sending. Meanwhile not
 836                                  * supported
 837                                  */
 838                                 if (cl->ishtp_flow_ctrl_creds)
 839                                         dev_err(dev->devc,
 840                                          "recv extra FC from FW client %u (host client %u) (FC count was %d)\n",
 841                                          (unsigned int)cl->fw_client_id,
 842                                          (unsigned int)cl->host_client_id,
 843                                          cl->ishtp_flow_ctrl_creds);
 844                                 else {
 845                                         ++cl->ishtp_flow_ctrl_creds;
 846                                         ++cl->ishtp_flow_ctrl_cnt;
 847                                         cl->last_ipc_acked = 1;
 848                                         spin_lock_irqsave(
 849                                                         &cl->tx_list_spinlock,
 850                                                         tx_flags);
 851                                         if (!list_empty(&cl->tx_list.list)) {
 852                                                 /*
 853                                                  * start sending the first msg
 854                                                  *      = the callback function
 855                                                  */
 856                                                 spin_unlock_irqrestore(
 857                                                         &cl->tx_list_spinlock,
 858                                                         tx_flags);
 859                                                 ishtp_cl_send_msg(dev, cl);
 860                                         } else {
 861                                                 spin_unlock_irqrestore(
 862                                                         &cl->tx_list_spinlock,
 863                                                         tx_flags);
 864                                         }
 865                                 }
 866                                 break;
 867                         }
 868                 }
 869                 spin_unlock_irqrestore(&dev->cl_list_lock, flags);
 870                 goto    eoi;
 871         }
 872
 873         /*
 874          * Some messages that are safe for ISR processing and important
 875          * to be done "quickly" and in-order, go here
 876          */
 877         if (ishtp_msg->hbm_cmd == CLIENT_CONNECT_RES_CMD ||
 878                         ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_RES_CMD ||
 879                         ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_REQ_CMD ||
 880                         ishtp_msg->hbm_cmd == DMA_XFER) {
 881                 ishtp_hbm_dispatch(dev, ishtp_msg);
 882                 goto    eoi;
 883         }
 884
 885         /*
 886          * All other HBMs go here.
 887          * We schedule HBMs for processing serially by using system wq,
 888          * possibly there will be multiple HBMs scheduled at the same time.
 889          */
 890         spin_lock_irqsave(&dev->rd_msg_spinlock, flags);
 891         if ((dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
 892                         (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE) ==
 893                         dev->rd_msg_fifo_head) {
 894                 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 895                 dev_err(dev->devc, "BH buffer overflow, dropping HBM %u\n",
 896                         (unsigned int)ishtp_msg->hbm_cmd);
 897                 goto    eoi;
 898         }
 899         memcpy(dev->rd_msg_fifo + dev->rd_msg_fifo_tail, ishtp_msg,
 900                 ishtp_hdr->length);
 901         dev->rd_msg_fifo_tail = (dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) %
 902                 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE);
 903         spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags);
 904         schedule_work(&dev->bh_hbm_work);
 905 eoi:
 906         return;
 907 }
 908
 909 /**
 910  * recv_fixed_cl_msg() - Receive fixed client message
 911  * @dev: ISHTP device instance
 912  * @ishtp_hdr: received bus message
 913  *
 914  * Receive and process ISHTP fixed client messages (address == 0)
 915  * in ISR context
 916  */
 917 void recv_fixed_cl_msg(struct ishtp_device *dev,
 918         struct ishtp_msg_hdr *ishtp_hdr)
 919 {
 920         uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE];
 921
 922         dev->print_log(dev,
 923                 "%s() got fixed client msg from client #%d\n",
 924                 __func__, ishtp_hdr->fw_addr);
 925         dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length);
 926         if (ishtp_hdr->fw_addr == ISHTP_SYSTEM_STATE_CLIENT_ADDR) {
 927                 struct ish_system_states_header *msg_hdr =
 928                         (struct ish_system_states_header *)rd_msg_buf;
 929                 if (msg_hdr->cmd == SYSTEM_STATE_SUBSCRIBE)
 930                         ishtp_send_resume(dev);
 931                 /* if FW request arrived here, the system is not suspended */
 932                 else
 933                         dev_err(dev->devc, "unknown fixed client msg [%02X]\n",
 934                                 msg_hdr->cmd);
 935         }
 936 }
 937
 938 /**
 939  * fix_cl_hdr() - Initialize fixed client header
 940  * @hdr: message header
 941  * @length: length of message
 942  * @cl_addr: Client address
 943  *
 944  * Initialize message header for fixed client
 945  */
 946 static inline void fix_cl_hdr(struct ishtp_msg_hdr *hdr, size_t length,
 947         uint8_t cl_addr)
 948 {
 949         hdr->host_addr = 0;
 950         hdr->fw_addr = cl_addr;
 951         hdr->length = length;
 952         hdr->msg_complete = 1;
 953         hdr->reserved = 0;
 954 }
 955
 956 /*** Suspend and resume notification ***/
 957
 958 static uint32_t current_state;
 959 static uint32_t supported_states = 0 | SUSPEND_STATE_BIT;
 960
 961 /**
 962  * ishtp_send_suspend() - Send suspend message to FW
 963  * @dev: ISHTP device instance
 964  *
 965  * Send suspend message to FW. This is useful for system freeze (non S3) case
 966  */
 967 void ishtp_send_suspend(struct ishtp_device *dev)
 968 {
 969         struct ishtp_msg_hdr    ishtp_hdr;
 970         struct ish_system_states_status state_status_msg;
 971         const size_t len = sizeof(struct ish_system_states_status);
 972
 973         fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
 974
 975         memset(&state_status_msg, 0, len);
 976         state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
 977         state_status_msg.supported_states = supported_states;
 978         current_state |= SUSPEND_STATE_BIT;
 979         dev->print_log(dev, "%s() sends SUSPEND notification\n", __func__);
 980         state_status_msg.states_status = current_state;
 981
 982         ishtp_write_message(dev, &ishtp_hdr,
 983                 (unsigned char *)&state_status_msg);
 984 }
 985 EXPORT_SYMBOL(ishtp_send_suspend);
 986
 987 /**
 988  * ishtp_send_resume() - Send resume message to FW
 989  * @dev: ISHTP device instance
 990  *
 991  * Send resume message to FW. This is useful for system freeze (non S3) case
 992  */
 993 void ishtp_send_resume(struct ishtp_device *dev)
 994 {
 995         struct ishtp_msg_hdr    ishtp_hdr;
 996         struct ish_system_states_status state_status_msg;
 997         const size_t len = sizeof(struct ish_system_states_status);
 998
 999         fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
1000
1001         memset(&state_status_msg, 0, len);
1002         state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS;
1003         state_status_msg.supported_states = supported_states;
1004         current_state &= ~SUSPEND_STATE_BIT;
1005         dev->print_log(dev, "%s() sends RESUME notification\n", __func__);
1006         state_status_msg.states_status = current_state;
1007
1008         ishtp_write_message(dev, &ishtp_hdr,
1009                 (unsigned char *)&state_status_msg);
1010 }
1011 EXPORT_SYMBOL(ishtp_send_resume);
1012
1013 /**
1014  * ishtp_query_subscribers() - Send query subscribers message
1015  * @dev: ISHTP device instance
1016  *
1017  * Send message to query subscribers
1018  */
1019 void ishtp_query_subscribers(struct ishtp_device *dev)
1020 {
1021         struct ishtp_msg_hdr    ishtp_hdr;
1022         struct ish_system_states_query_subscribers query_subscribers_msg;
1023         const size_t len = sizeof(struct ish_system_states_query_subscribers);
1024
1025         fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR);
1026
1027         memset(&query_subscribers_msg, 0, len);
1028         query_subscribers_msg.hdr.cmd = SYSTEM_STATE_QUERY_SUBSCRIBERS;
1029
1030         ishtp_write_message(dev, &ishtp_hdr,
1031                 (unsigned char *)&query_subscribers_msg);
1032 }