drivers/staging/heci/heci_interface.c

   1 /*
   2  * Part of Intel(R) Manageability Engine Interface Linux driver
   3  *
   4  * Copyright (c) 2003 - 2008 Intel Corp.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions, and the following disclaimer,
  12  *    without modification.
  13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  14  *    substantially similar to the "NO WARRANTY" disclaimer below
  15  *    ("Disclaimer") and any redistribution must be conditioned upon
  16  *    including a substantially similar Disclaimer requirement for further
  17  *    binary redistribution.
  18  * 3. Neither the names of the above-listed copyright holders nor the names
  19  *    of any contributors may be used to endorse or promote products derived
  20  *    from this software without specific prior written permission.
  21  *
  22  * Alternatively, this software may be distributed under the terms of the
  23  * GNU General Public License ("GPL") version 2 as published by the Free
  24  * Software Foundation.
  25  *
  26  * NO WARRANTY
  27  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  28  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  29  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  30  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  31  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  35  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  36  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37  * POSSIBILITY OF SUCH DAMAGES.
  38  *
  39  */
  40
  41
  42 #include "heci.h"
  43 #include "heci_interface.h"
  44
  45
  46 /**
  47  * heci_set_csr_register - write H_CSR register to the heci device,
  48  * and ignore the H_IS bit for it is write-one-to-zero.
  49  *
  50  * @dev: device object for our driver
  51  */
  52 void heci_set_csr_register(struct iamt_heci_device *dev)
  53 {
  54         if ((dev->host_hw_state & H_IS) == H_IS)
  55                 dev->host_hw_state &= ~H_IS;
  56         write_heci_register(dev, H_CSR, dev->host_hw_state);
  57         dev->host_hw_state = read_heci_register(dev, H_CSR);
  58 }
  59
  60 /**
  61  * heci_csr_enable_interrupts - enable heci device interrupts
  62  *
  63  * @dev: device object for our driver
  64  */
  65 void heci_csr_enable_interrupts(struct iamt_heci_device *dev)
  66 {
  67         dev->host_hw_state |= H_IE;
  68         heci_set_csr_register(dev);
  69 }
  70
  71 /**
  72  * heci_csr_disable_interrupts - disable heci device interrupts
  73  *
  74  * @dev: device object for our driver
  75  */
  76 void heci_csr_disable_interrupts(struct iamt_heci_device *dev)
  77 {
  78         dev->host_hw_state &= ~H_IE;
  79         heci_set_csr_register(dev);
  80 }
  81
  82 /**
  83  * heci_csr_clear_his - clear H_IS bit in H_CSR
  84  *
  85  * @dev: device object for our driver
  86  */
  87 void heci_csr_clear_his(struct iamt_heci_device *dev)
  88 {
  89         write_heci_register(dev, H_CSR, dev->host_hw_state);
  90         dev->host_hw_state = read_heci_register(dev, H_CSR);
  91 }
  92
  93 /**
  94  * _host_get_filled_slots - get number of device filled buffer slots
  95  *
  96  * @device: the device structure
  97  *
  98  * returns numer of filled slots
  99  */
 100 static unsigned char _host_get_filled_slots(const struct iamt_heci_device *dev)
 101 {
 102         char read_ptr, write_ptr;
 103
 104         read_ptr = (char) ((dev->host_hw_state & H_CBRP) >> 8);
 105         write_ptr = (char) ((dev->host_hw_state & H_CBWP) >> 16);
 106
 107         return (unsigned char) (write_ptr - read_ptr);
 108 }
 109
 110 /**
 111  * host_buffer_is_empty  - check if host buffer is empty.
 112  *
 113  * @dev: device object for our driver
 114  *
 115  * returns  1 if empty, 0 - otherwise.
 116  */
 117 int host_buffer_is_empty(struct iamt_heci_device *dev)
 118 {
 119         unsigned char filled_slots;
 120
 121         dev->host_hw_state = read_heci_register(dev, H_CSR);
 122         filled_slots = _host_get_filled_slots(dev);
 123
 124         if (filled_slots > 0)
 125                 return 0;
 126
 127         return 1;
 128 }
 129
 130 /**
 131  * count_empty_write_slots  - count write empty slots.
 132  *
 133  * @dev: device object for our driver
 134  *
 135  * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise empty slots count
 136  */
 137 __s32 count_empty_write_slots(const struct iamt_heci_device *dev)
 138 {
 139         unsigned char buffer_depth, filled_slots, empty_slots;
 140
 141         buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
 142         filled_slots = _host_get_filled_slots(dev);
 143         empty_slots = buffer_depth - filled_slots;
 144
 145         if (filled_slots > buffer_depth) {
 146                 /* overflow */
 147                 return -ESLOTS_OVERFLOW;
 148         }
 149
 150         return (__s32) empty_slots;
 151 }
 152
 153 /**
 154  * heci_write_message  - write a message to heci device.
 155  *
 156  * @dev: device object for our driver
 157  * @heci_hdr: header of  message
 158  * @write_buffer: message buffer will be write
 159  * @write_length: message size will be write
 160  *
 161  * returns 1 if success, 0 - otherwise.
 162  */
 163 int heci_write_message(struct iamt_heci_device *dev,
 164                              struct heci_msg_hdr *header,
 165                              unsigned char *write_buffer,
 166                              unsigned long write_length)
 167 {
 168         __u32 temp_msg = 0;
 169         unsigned long bytes_written = 0;
 170         unsigned char buffer_depth, filled_slots, empty_slots;
 171         unsigned long dw_to_write;
 172
 173         dev->host_hw_state = read_heci_register(dev, H_CSR);
 174         DBG("host_hw_state = 0x%08x.\n", dev->host_hw_state);
 175         DBG("heci_write_message header=%08x.\n", *((__u32 *) header));
 176         buffer_depth = (unsigned char) ((dev->host_hw_state & H_CBD) >> 24);
 177         filled_slots = _host_get_filled_slots(dev);
 178         empty_slots = buffer_depth - filled_slots;
 179         DBG("filled = %hu, empty = %hu.\n", filled_slots, empty_slots);
 180
 181         dw_to_write = ((write_length + 3) / 4);
 182
 183         if (dw_to_write > empty_slots)
 184                 return 0;
 185
 186         write_heci_register(dev, H_CB_WW, *((__u32 *) header));
 187
 188         while (write_length >= 4) {
 189                 write_heci_register(dev, H_CB_WW,
 190                                 *(__u32 *) (write_buffer + bytes_written));
 191                 bytes_written += 4;
 192                 write_length -= 4;
 193         }
 194
 195         if (write_length > 0) {
 196                 memcpy(&temp_msg, &write_buffer[bytes_written], write_length);
 197                 write_heci_register(dev, H_CB_WW, temp_msg);
 198         }
 199
 200         dev->host_hw_state |= H_IG;
 201         heci_set_csr_register(dev);
 202         dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
 203         if ((dev->me_hw_state & ME_RDY_HRA) != ME_RDY_HRA)
 204                 return 0;
 205
 206         dev->write_hang = 0;
 207         return 1;
 208 }
 209
 210 /**
 211  * count_full_read_slots  - count read full slots.
 212  *
 213  * @dev: device object for our driver
 214  *
 215  * returns -1(ESLOTS_OVERFLOW) if overflow, otherwise filled slots count
 216  */
 217 __s32 count_full_read_slots(struct iamt_heci_device *dev)
 218 {
 219         char read_ptr, write_ptr;
 220         unsigned char buffer_depth, filled_slots;
 221
 222         dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);
 223         buffer_depth = (unsigned char)((dev->me_hw_state & ME_CBD_HRA) >> 24);
 224         read_ptr = (char) ((dev->me_hw_state & ME_CBRP_HRA) >> 8);
 225         write_ptr = (char) ((dev->me_hw_state & ME_CBWP_HRA) >> 16);
 226         filled_slots = (unsigned char) (write_ptr - read_ptr);
 227
 228         if (filled_slots > buffer_depth) {
 229                 /* overflow */
 230                 return -ESLOTS_OVERFLOW;
 231         }
 232
 233         DBG("filled_slots =%08x  \n", filled_slots);
 234         return (__s32) filled_slots;
 235 }
 236
 237 /**
 238  * heci_read_slots  - read a message from heci device.
 239  *
 240  * @dev: device object for our driver
 241  * @buffer: message buffer will be write
 242  * @buffer_length: message size will be read
 243  */
 244 void heci_read_slots(struct iamt_heci_device *dev,
 245                      unsigned char *buffer, unsigned long buffer_length)
 246 {
 247         __u32 i = 0;
 248         unsigned char temp_buf[sizeof(__u32)];
 249
 250         while (buffer_length >= sizeof(__u32)) {
 251                 ((__u32 *) buffer)[i] = read_heci_register(dev, ME_CB_RW);
 252                 DBG("buffer[%d]= %d\n", i, ((__u32 *) buffer)[i]);
 253                 i++;
 254                 buffer_length -= sizeof(__u32);
 255         }
 256
 257         if (buffer_length > 0) {
 258                 *((__u32 *) &temp_buf) = read_heci_register(dev, ME_CB_RW);
 259                 memcpy(&buffer[i * 4], temp_buf, buffer_length);
 260         }
 261
 262         dev->host_hw_state |= H_IG;
 263         heci_set_csr_register(dev);
 264 }
 265
 266 /**
 267  * flow_ctrl_creds  - check flow_control credentials.
 268  *
 269  * @dev: device object for our driver
 270  * @file_ext: private data of the file object
 271  *
 272  * returns 1 if flow_ctrl_creds >0, 0 - otherwise.
 273  */
 274 int flow_ctrl_creds(struct iamt_heci_device *dev,
 275                                    struct heci_file_private *file_ext)
 276 {
 277         __u8 i;
 278
 279         if (!dev->num_heci_me_clients)
 280                 return 0;
 281
 282         if (file_ext == NULL)
 283                 return 0;
 284
 285         if (file_ext->flow_ctrl_creds > 0)
 286                 return 1;
 287
 288         for (i = 0; i < dev->num_heci_me_clients; i++) {
 289                 if (dev->me_clients[i].client_id == file_ext->me_client_id) {
 290                         if (dev->me_clients[i].flow_ctrl_creds > 0) {
 291                                 BUG_ON(dev->me_clients[i].props.single_recv_buf
 292                                          == 0);
 293                                 return 1;
 294                         }
 295                         return 0;
 296                 }
 297         }
 298         BUG();
 299         return 0;
 300 }
 301
 302 /**
 303  * flow_ctrl_reduce  - reduce flow_control.
 304  *
 305  * @dev: device object for our driver
 306  * @file_ext: private data of the file object
 307  */
 308 void flow_ctrl_reduce(struct iamt_heci_device *dev,
 309                          struct heci_file_private *file_ext)
 310 {
 311         __u8 i;
 312
 313         if (!dev->num_heci_me_clients)
 314                 return;
 315
 316         for (i = 0; i < dev->num_heci_me_clients; i++) {
 317                 if (dev->me_clients[i].client_id == file_ext->me_client_id) {
 318                         if (dev->me_clients[i].props.single_recv_buf != 0) {
 319                                 BUG_ON(dev->me_clients[i].flow_ctrl_creds <= 0);
 320                                 dev->me_clients[i].flow_ctrl_creds--;
 321                         } else {
 322                                 BUG_ON(file_ext->flow_ctrl_creds <= 0);
 323                                 file_ext->flow_ctrl_creds--;
 324                         }
 325                         return;
 326                 }
 327         }
 328         BUG();
 329 }
 330
 331 /**
 332  * heci_send_flow_control - send flow control to fw.
 333  *
 334  * @dev: device object for our driver
 335  * @file_ext: private data of the file object
 336  *
 337  * returns 1 if success, 0 - otherwise.
 338  */
 339 int heci_send_flow_control(struct iamt_heci_device *dev,
 340                                  struct heci_file_private *file_ext)
 341 {
 342         struct heci_msg_hdr *heci_hdr;
 343         struct hbm_flow_control *heci_flow_control;
 344
 345         heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
 346         heci_hdr->host_addr = 0;
 347         heci_hdr->me_addr = 0;
 348         heci_hdr->length = sizeof(struct hbm_flow_control);
 349         heci_hdr->msg_complete = 1;
 350         heci_hdr->reserved = 0;
 351
 352         heci_flow_control = (struct hbm_flow_control *) &dev->wr_msg_buf[1];
 353         memset(heci_flow_control, 0, sizeof(heci_flow_control));
 354         heci_flow_control->host_addr = file_ext->host_client_id;
 355         heci_flow_control->me_addr = file_ext->me_client_id;
 356         heci_flow_control->cmd.cmd = HECI_FLOW_CONTROL_CMD;
 357         memset(heci_flow_control->reserved, 0,
 358                         sizeof(heci_flow_control->reserved));
 359         DBG("sending flow control host client = %d, me client = %d\n",
 360             file_ext->host_client_id, file_ext->me_client_id);
 361         if (!heci_write_message(dev, heci_hdr,
 362                                 (unsigned char *) heci_flow_control,
 363                                 sizeof(struct hbm_flow_control)))
 364                 return 0;
 365
 366         return 1;
 367
 368 }
 369
 370 /**
 371  * other_client_is_connecting  - check if other
 372  *    client with the same client id is connected.
 373  *
 374  * @dev: device object for our driver
 375  * @file_ext: private data of the file object
 376  *
 377  * returns 1 if other client is connected, 0 - otherwise.
 378  */
 379 int other_client_is_connecting(struct iamt_heci_device *dev,
 380                 struct heci_file_private *file_ext)
 381 {
 382         struct heci_file_private *file_pos = NULL;
 383         struct heci_file_private *file_next = NULL;
 384
 385         list_for_each_entry_safe(file_pos, file_next, &dev->file_list, link) {
 386                 if ((file_pos->state == HECI_FILE_CONNECTING)
 387                         && (file_pos != file_ext)
 388                         && file_ext->me_client_id == file_pos->me_client_id)
 389                         return 1;
 390
 391         }
 392         return 0;
 393 }
 394
 395 /**
 396  * heci_send_wd  - send watch dog message to fw.
 397  *
 398  * @dev: device object for our driver
 399  *
 400  * returns 1 if success, 0 - otherwise.
 401  */
 402 int heci_send_wd(struct iamt_heci_device *dev)
 403 {
 404         struct heci_msg_hdr *heci_hdr;
 405
 406         heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
 407         heci_hdr->host_addr = dev->wd_file_ext.host_client_id;
 408         heci_hdr->me_addr = dev->wd_file_ext.me_client_id;
 409         heci_hdr->msg_complete = 1;
 410         heci_hdr->reserved = 0;
 411
 412         if (!memcmp(dev->wd_data, heci_start_wd_params,
 413                         HECI_WD_PARAMS_SIZE)) {
 414                 heci_hdr->length = HECI_START_WD_DATA_SIZE;
 415         } else {
 416                 BUG_ON(memcmp(dev->wd_data, heci_stop_wd_params,
 417                         HECI_WD_PARAMS_SIZE));
 418                 heci_hdr->length = HECI_WD_PARAMS_SIZE;
 419         }
 420
 421         if (!heci_write_message(dev, heci_hdr, dev->wd_data, heci_hdr->length))
 422                 return 0;
 423
 424         return 1;
 425 }
 426
 427 /**
 428  * heci_disconnect  - send disconnect message to fw.
 429  *
 430  * @dev: device object for our driver
 431  * @file_ext: private data of the file object
 432  *
 433  * returns 1 if success, 0 - otherwise.
 434  */
 435 int heci_disconnect(struct iamt_heci_device *dev,
 436                           struct heci_file_private *file_ext)
 437 {
 438         struct heci_msg_hdr *heci_hdr;
 439         struct hbm_client_disconnect_request *heci_cli_disconnect;
 440
 441         heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
 442         heci_hdr->host_addr = 0;
 443         heci_hdr->me_addr = 0;
 444         heci_hdr->length = sizeof(struct hbm_client_disconnect_request);
 445         heci_hdr->msg_complete = 1;
 446         heci_hdr->reserved = 0;
 447
 448         heci_cli_disconnect =
 449             (struct hbm_client_disconnect_request *) &dev->wr_msg_buf[1];
 450         memset(heci_cli_disconnect, 0, sizeof(heci_cli_disconnect));
 451         heci_cli_disconnect->host_addr = file_ext->host_client_id;
 452         heci_cli_disconnect->me_addr = file_ext->me_client_id;
 453         heci_cli_disconnect->cmd.cmd = CLIENT_DISCONNECT_REQ_CMD;
 454         heci_cli_disconnect->reserved[0] = 0;
 455
 456         if (!heci_write_message(dev, heci_hdr,
 457                                 (unsigned char *) heci_cli_disconnect,
 458                                 sizeof(struct hbm_client_disconnect_request)))
 459                 return 0;
 460
 461         return 1;
 462 }
 463
 464 /**
 465  * heci_connect - send connect message to fw.
 466  *
 467  * @dev: device object for our driver
 468  * @file_ext: private data of the file object
 469  *
 470  * returns 1 if success, 0 - otherwise.
 471  */
 472 int heci_connect(struct iamt_heci_device *dev,
 473                        struct heci_file_private *file_ext)
 474 {
 475         struct heci_msg_hdr *heci_hdr;
 476         struct hbm_client_connect_request *heci_cli_connect;
 477
 478         heci_hdr = (struct heci_msg_hdr *) &dev->wr_msg_buf[0];
 479         heci_hdr->host_addr = 0;
 480         heci_hdr->me_addr = 0;
 481         heci_hdr->length = sizeof(struct hbm_client_connect_request);
 482         heci_hdr->msg_complete = 1;
 483         heci_hdr->reserved = 0;
 484
 485         heci_cli_connect =
 486             (struct hbm_client_connect_request *) &dev->wr_msg_buf[1];
 487         heci_cli_connect->host_addr = file_ext->host_client_id;
 488         heci_cli_connect->me_addr = file_ext->me_client_id;
 489         heci_cli_connect->cmd.cmd = CLIENT_CONNECT_REQ_CMD;
 490         heci_cli_connect->reserved = 0;
 491
 492         if (!heci_write_message(dev, heci_hdr,
 493                                 (unsigned char *) heci_cli_connect,
 494                                 sizeof(struct hbm_client_connect_request)))
 495                 return 0;
 496
 497         return 1;
 498 }