drivers/misc/mei/hw-txe.c

   1 /*
   2  *
   3  * Intel Management Engine Interface (Intel MEI) Linux driver
   4  * Copyright (c) 2013-2014, 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/pci.h>
  18 #include <linux/jiffies.h>
  19 #include <linux/delay.h>
  20 #include <linux/kthread.h>
  21 #include <linux/irqreturn.h>
  22
  23 #include <linux/mei.h>
  24
  25 #include "mei_dev.h"
  26 #include "hw-txe.h"
  27 #include "client.h"
  28 #include "hbm.h"
  29
  30 /**
  31  * mei_txe_reg_read - Reads 32bit data from the txe device
  32  *
  33  * @base_addr: registers base address
  34  * @offset: register offset
  35  *
  36  * Return: register value
  37  */
  38 static inline u32 mei_txe_reg_read(void __iomem *base_addr,
  39                                         unsigned long offset)
  40 {
  41         return ioread32(base_addr + offset);
  42 }
  43
  44 /**
  45  * mei_txe_reg_write - Writes 32bit data to the txe device
  46  *
  47  * @base_addr: registers base address
  48  * @offset: register offset
  49  * @value: the value to write
  50  */
  51 static inline void mei_txe_reg_write(void __iomem *base_addr,
  52                                 unsigned long offset, u32 value)
  53 {
  54         iowrite32(value, base_addr + offset);
  55 }
  56
  57 /**
  58  * mei_txe_sec_reg_read_silent - Reads 32bit data from the SeC BAR
  59  *
  60  * @hw: the txe hardware structure
  61  * @offset: register offset
  62  *
  63  * Doesn't check for aliveness while Reads 32bit data from the SeC BAR
  64  *
  65  * Return: register value
  66  */
  67 static inline u32 mei_txe_sec_reg_read_silent(struct mei_txe_hw *hw,
  68                                 unsigned long offset)
  69 {
  70         return mei_txe_reg_read(hw->mem_addr[SEC_BAR], offset);
  71 }
  72
  73 /**
  74  * mei_txe_sec_reg_read - Reads 32bit data from the SeC BAR
  75  *
  76  * @hw: the txe hardware structure
  77  * @offset: register offset
  78  *
  79  * Reads 32bit data from the SeC BAR and shout loud if aliveness is not set
  80  *
  81  * Return: register value
  82  */
  83 static inline u32 mei_txe_sec_reg_read(struct mei_txe_hw *hw,
  84                                 unsigned long offset)
  85 {
  86         WARN(!hw->aliveness, "sec read: aliveness not asserted\n");
  87         return mei_txe_sec_reg_read_silent(hw, offset);
  88 }
  89 /**
  90  * mei_txe_sec_reg_write_silent - Writes 32bit data to the SeC BAR
  91  *   doesn't check for aliveness
  92  *
  93  * @hw: the txe hardware structure
  94  * @offset: register offset
  95  * @value: value to write
  96  *
  97  * Doesn't check for aliveness while writes 32bit data from to the SeC BAR
  98  */
  99 static inline void mei_txe_sec_reg_write_silent(struct mei_txe_hw *hw,
 100                                 unsigned long offset, u32 value)
 101 {
 102         mei_txe_reg_write(hw->mem_addr[SEC_BAR], offset, value);
 103 }
 104
 105 /**
 106  * mei_txe_sec_reg_write - Writes 32bit data to the SeC BAR
 107  *
 108  * @hw: the txe hardware structure
 109  * @offset: register offset
 110  * @value: value to write
 111  *
 112  * Writes 32bit data from the SeC BAR and shout loud if aliveness is not set
 113  */
 114 static inline void mei_txe_sec_reg_write(struct mei_txe_hw *hw,
 115                                 unsigned long offset, u32 value)
 116 {
 117         WARN(!hw->aliveness, "sec write: aliveness not asserted\n");
 118         mei_txe_sec_reg_write_silent(hw, offset, value);
 119 }
 120 /**
 121  * mei_txe_br_reg_read - Reads 32bit data from the Bridge BAR
 122  *
 123  * @hw: the txe hardware structure
 124  * @offset: offset from which to read the data
 125  *
 126  * Return: the byte read.
 127  */
 128 static inline u32 mei_txe_br_reg_read(struct mei_txe_hw *hw,
 129                                 unsigned long offset)
 130 {
 131         return mei_txe_reg_read(hw->mem_addr[BRIDGE_BAR], offset);
 132 }
 133
 134 /**
 135  * mei_txe_br_reg_write - Writes 32bit data to the Bridge BAR
 136  *
 137  * @hw: the txe hardware structure
 138  * @offset: offset from which to write the data
 139  * @value: the byte to write
 140  */
 141 static inline void mei_txe_br_reg_write(struct mei_txe_hw *hw,
 142                                 unsigned long offset, u32 value)
 143 {
 144         mei_txe_reg_write(hw->mem_addr[BRIDGE_BAR], offset, value);
 145 }
 146
 147 /**
 148  * mei_txe_aliveness_set - request for aliveness change
 149  *
 150  * @dev: the device structure
 151  * @req: requested aliveness value
 152  *
 153  * Request for aliveness change and returns true if the change is
 154  *   really needed and false if aliveness is already
 155  *   in the requested state
 156  *
 157  * Locking: called under "dev->device_lock" lock
 158  *
 159  * Return: true if request was send
 160  */
 161 static bool mei_txe_aliveness_set(struct mei_device *dev, u32 req)
 162 {
 163
 164         struct mei_txe_hw *hw = to_txe_hw(dev);
 165         bool do_req = hw->aliveness != req;
 166
 167         dev_dbg(dev->dev, "Aliveness current=%d request=%d\n",
 168                                 hw->aliveness, req);
 169         if (do_req) {
 170                 dev->pg_event = MEI_PG_EVENT_WAIT;
 171                 mei_txe_br_reg_write(hw, SICR_HOST_ALIVENESS_REQ_REG, req);
 172         }
 173         return do_req;
 174 }
 175
 176
 177 /**
 178  * mei_txe_aliveness_req_get - get aliveness requested register value
 179  *
 180  * @dev: the device structure
 181  *
 182  * Extract HICR_HOST_ALIVENESS_RESP_ACK bit from
 183  * from HICR_HOST_ALIVENESS_REQ register value
 184  *
 185  * Return: SICR_HOST_ALIVENESS_REQ_REQUESTED bit value
 186  */
 187 static u32 mei_txe_aliveness_req_get(struct mei_device *dev)
 188 {
 189         struct mei_txe_hw *hw = to_txe_hw(dev);
 190         u32 reg;
 191
 192         reg = mei_txe_br_reg_read(hw, SICR_HOST_ALIVENESS_REQ_REG);
 193         return reg & SICR_HOST_ALIVENESS_REQ_REQUESTED;
 194 }
 195
 196 /**
 197  * mei_txe_aliveness_get - get aliveness response register value
 198  *
 199  * @dev: the device structure
 200  *
 201  * Return: HICR_HOST_ALIVENESS_RESP_ACK bit from HICR_HOST_ALIVENESS_RESP
 202  *         register
 203  */
 204 static u32 mei_txe_aliveness_get(struct mei_device *dev)
 205 {
 206         struct mei_txe_hw *hw = to_txe_hw(dev);
 207         u32 reg;
 208
 209         reg = mei_txe_br_reg_read(hw, HICR_HOST_ALIVENESS_RESP_REG);
 210         return reg & HICR_HOST_ALIVENESS_RESP_ACK;
 211 }
 212
 213 /**
 214  * mei_txe_aliveness_poll - waits for aliveness to settle
 215  *
 216  * @dev: the device structure
 217  * @expected: expected aliveness value
 218  *
 219  * Polls for HICR_HOST_ALIVENESS_RESP.ALIVENESS_RESP to be set
 220  *
 221  * Return: > 0 if the expected value was received, -ETIME otherwise
 222  */
 223 static int mei_txe_aliveness_poll(struct mei_device *dev, u32 expected)
 224 {
 225         struct mei_txe_hw *hw = to_txe_hw(dev);
 226         int t = 0;
 227
 228         do {
 229                 hw->aliveness = mei_txe_aliveness_get(dev);
 230                 if (hw->aliveness == expected) {
 231                         dev->pg_event = MEI_PG_EVENT_IDLE;
 232                         dev_dbg(dev->dev,
 233                                 "aliveness settled after %d msecs\n", t);
 234                         return t;
 235                 }
 236                 mutex_unlock(&dev->device_lock);
 237                 msleep(MSEC_PER_SEC / 5);
 238                 mutex_lock(&dev->device_lock);
 239                 t += MSEC_PER_SEC / 5;
 240         } while (t < SEC_ALIVENESS_WAIT_TIMEOUT);
 241
 242         dev->pg_event = MEI_PG_EVENT_IDLE;
 243         dev_err(dev->dev, "aliveness timed out\n");
 244         return -ETIME;
 245 }
 246
 247 /**
 248  * mei_txe_aliveness_wait - waits for aliveness to settle
 249  *
 250  * @dev: the device structure
 251  * @expected: expected aliveness value
 252  *
 253  * Waits for HICR_HOST_ALIVENESS_RESP.ALIVENESS_RESP to be set
 254  *
 255  * Return: 0 on success and < 0 otherwise
 256  */
 257 static int mei_txe_aliveness_wait(struct mei_device *dev, u32 expected)
 258 {
 259         struct mei_txe_hw *hw = to_txe_hw(dev);
 260         const unsigned long timeout =
 261                         msecs_to_jiffies(SEC_ALIVENESS_WAIT_TIMEOUT);
 262         long err;
 263         int ret;
 264
 265         hw->aliveness = mei_txe_aliveness_get(dev);
 266         if (hw->aliveness == expected)
 267                 return 0;
 268
 269         mutex_unlock(&dev->device_lock);
 270         err = wait_event_timeout(hw->wait_aliveness_resp,
 271                         dev->pg_event == MEI_PG_EVENT_RECEIVED, timeout);
 272         mutex_lock(&dev->device_lock);
 273
 274         hw->aliveness = mei_txe_aliveness_get(dev);
 275         ret = hw->aliveness == expected ? 0 : -ETIME;
 276
 277         if (ret)
 278                 dev_warn(dev->dev, "aliveness timed out = %ld aliveness = %d event = %d\n",
 279                         err, hw->aliveness, dev->pg_event);
 280         else
 281                 dev_dbg(dev->dev, "aliveness settled after = %d msec aliveness = %d event = %d\n",
 282                         jiffies_to_msecs(timeout - err),
 283                         hw->aliveness, dev->pg_event);
 284
 285         dev->pg_event = MEI_PG_EVENT_IDLE;
 286         return ret;
 287 }
 288
 289 /**
 290  * mei_txe_aliveness_set_sync - sets an wait for aliveness to complete
 291  *
 292  * @dev: the device structure
 293  * @req: requested aliveness value
 294  *
 295  * Return: 0 on success and < 0 otherwise
 296  */
 297 int mei_txe_aliveness_set_sync(struct mei_device *dev, u32 req)
 298 {
 299         if (mei_txe_aliveness_set(dev, req))
 300                 return mei_txe_aliveness_wait(dev, req);
 301         return 0;
 302 }
 303
 304 /**
 305  * mei_txe_pg_is_enabled - detect if PG is supported by HW
 306  *
 307  * @dev: the device structure
 308  *
 309  * Return: true is pg supported, false otherwise
 310  */
 311 static bool mei_txe_pg_is_enabled(struct mei_device *dev)
 312 {
 313         return true;
 314 }
 315
 316 /**
 317  * mei_txe_pg_state  - translate aliveness register value
 318  *   to the mei power gating state
 319  *
 320  * @dev: the device structure
 321  *
 322  * Return: MEI_PG_OFF if aliveness is on and MEI_PG_ON otherwise
 323  */
 324 static inline enum mei_pg_state mei_txe_pg_state(struct mei_device *dev)
 325 {
 326         struct mei_txe_hw *hw = to_txe_hw(dev);
 327
 328         return hw->aliveness ? MEI_PG_OFF : MEI_PG_ON;
 329 }
 330
 331 /**
 332  * mei_txe_input_ready_interrupt_enable - sets the Input Ready Interrupt
 333  *
 334  * @dev: the device structure
 335  */
 336 static void mei_txe_input_ready_interrupt_enable(struct mei_device *dev)
 337 {
 338         struct mei_txe_hw *hw = to_txe_hw(dev);
 339         u32 hintmsk;
 340         /* Enable the SEC_IPC_HOST_INT_MASK_IN_RDY interrupt */
 341         hintmsk = mei_txe_sec_reg_read(hw, SEC_IPC_HOST_INT_MASK_REG);
 342         hintmsk |= SEC_IPC_HOST_INT_MASK_IN_RDY;
 343         mei_txe_sec_reg_write(hw, SEC_IPC_HOST_INT_MASK_REG, hintmsk);
 344 }
 345
 346 /**
 347  * mei_txe_input_doorbell_set - sets bit 0 in
 348  *    SEC_IPC_INPUT_DOORBELL.IPC_INPUT_DOORBELL.
 349  *
 350  * @hw: the txe hardware structure
 351  */
 352 static void mei_txe_input_doorbell_set(struct mei_txe_hw *hw)
 353 {
 354         /* Clear the interrupt cause */
 355         clear_bit(TXE_INTR_IN_READY_BIT, &hw->intr_cause);
 356         mei_txe_sec_reg_write(hw, SEC_IPC_INPUT_DOORBELL_REG, 1);
 357 }
 358
 359 /**
 360  * mei_txe_output_ready_set - Sets the SICR_SEC_IPC_OUTPUT_STATUS bit to 1
 361  *
 362  * @hw: the txe hardware structure
 363  */
 364 static void mei_txe_output_ready_set(struct mei_txe_hw *hw)
 365 {
 366         mei_txe_br_reg_write(hw,
 367                         SICR_SEC_IPC_OUTPUT_STATUS_REG,
 368                         SEC_IPC_OUTPUT_STATUS_RDY);
 369 }
 370
 371 /**
 372  * mei_txe_is_input_ready - check if TXE is ready for receiving data
 373  *
 374  * @dev: the device structure
 375  *
 376  * Return: true if INPUT STATUS READY bit is set
 377  */
 378 static bool mei_txe_is_input_ready(struct mei_device *dev)
 379 {
 380         struct mei_txe_hw *hw = to_txe_hw(dev);
 381         u32 status;
 382
 383         status = mei_txe_sec_reg_read(hw, SEC_IPC_INPUT_STATUS_REG);
 384         return !!(SEC_IPC_INPUT_STATUS_RDY & status);
 385 }
 386
 387 /**
 388  * mei_txe_intr_clear - clear all interrupts
 389  *
 390  * @dev: the device structure
 391  */
 392 static inline void mei_txe_intr_clear(struct mei_device *dev)
 393 {
 394         struct mei_txe_hw *hw = to_txe_hw(dev);
 395
 396         mei_txe_sec_reg_write_silent(hw, SEC_IPC_HOST_INT_STATUS_REG,
 397                 SEC_IPC_HOST_INT_STATUS_PENDING);
 398         mei_txe_br_reg_write(hw, HISR_REG, HISR_INT_STS_MSK);
 399         mei_txe_br_reg_write(hw, HHISR_REG, IPC_HHIER_MSK);
 400 }
 401
 402 /**
 403  * mei_txe_intr_disable - disable all interrupts
 404  *
 405  * @dev: the device structure
 406  */
 407 static void mei_txe_intr_disable(struct mei_device *dev)
 408 {
 409         struct mei_txe_hw *hw = to_txe_hw(dev);
 410
 411         mei_txe_br_reg_write(hw, HHIER_REG, 0);
 412         mei_txe_br_reg_write(hw, HIER_REG, 0);
 413 }
 414 /**
 415  * mei_txe_intr_disable - enable all interrupts
 416  *
 417  * @dev: the device structure
 418  */
 419 static void mei_txe_intr_enable(struct mei_device *dev)
 420 {
 421         struct mei_txe_hw *hw = to_txe_hw(dev);
 422
 423         mei_txe_br_reg_write(hw, HHIER_REG, IPC_HHIER_MSK);
 424         mei_txe_br_reg_write(hw, HIER_REG, HIER_INT_EN_MSK);
 425 }
 426
 427 /**
 428  * mei_txe_pending_interrupts - check if there are pending interrupts
 429  *      only Aliveness, Input ready, and output doorbell are of relevance
 430  *
 431  * @dev: the device structure
 432  *
 433  * Checks if there are pending interrupts
 434  * only Aliveness, Readiness, Input ready, and Output doorbell are relevant
 435  *
 436  * Return: true if there are pending interrupts
 437  */
 438 static bool mei_txe_pending_interrupts(struct mei_device *dev)
 439 {
 440
 441         struct mei_txe_hw *hw = to_txe_hw(dev);
 442         bool ret = (hw->intr_cause & (TXE_INTR_READINESS |
 443                                       TXE_INTR_ALIVENESS |
 444                                       TXE_INTR_IN_READY  |
 445                                       TXE_INTR_OUT_DB));
 446
 447         if (ret) {
 448                 dev_dbg(dev->dev,
 449                         "Pending Interrupts InReady=%01d Readiness=%01d, Aliveness=%01d, OutDoor=%01d\n",
 450                         !!(hw->intr_cause & TXE_INTR_IN_READY),
 451                         !!(hw->intr_cause & TXE_INTR_READINESS),
 452                         !!(hw->intr_cause & TXE_INTR_ALIVENESS),
 453                         !!(hw->intr_cause & TXE_INTR_OUT_DB));
 454         }
 455         return ret;
 456 }
 457
 458 /**
 459  * mei_txe_input_payload_write - write a dword to the host buffer
 460  *      at offset idx
 461  *
 462  * @dev: the device structure
 463  * @idx: index in the host buffer
 464  * @value: value
 465  */
 466 static void mei_txe_input_payload_write(struct mei_device *dev,
 467                         unsigned long idx, u32 value)
 468 {
 469         struct mei_txe_hw *hw = to_txe_hw(dev);
 470
 471         mei_txe_sec_reg_write(hw, SEC_IPC_INPUT_PAYLOAD_REG +
 472                         (idx * sizeof(u32)), value);
 473 }
 474
 475 /**
 476  * mei_txe_out_data_read - read dword from the device buffer
 477  *      at offset idx
 478  *
 479  * @dev: the device structure
 480  * @idx: index in the device buffer
 481  *
 482  * Return: register value at index
 483  */
 484 static u32 mei_txe_out_data_read(const struct mei_device *dev,
 485                                         unsigned long idx)
 486 {
 487         struct mei_txe_hw *hw = to_txe_hw(dev);
 488
 489         return mei_txe_br_reg_read(hw,
 490                 BRIDGE_IPC_OUTPUT_PAYLOAD_REG + (idx * sizeof(u32)));
 491 }
 492
 493 /* Readiness */
 494
 495 /**
 496  * mei_txe_readiness_set_host_rdy - set host readiness bit
 497  *
 498  * @dev: the device structure
 499  */
 500 static void mei_txe_readiness_set_host_rdy(struct mei_device *dev)
 501 {
 502         struct mei_txe_hw *hw = to_txe_hw(dev);
 503
 504         mei_txe_br_reg_write(hw,
 505                 SICR_HOST_IPC_READINESS_REQ_REG,
 506                 SICR_HOST_IPC_READINESS_HOST_RDY);
 507 }
 508
 509 /**
 510  * mei_txe_readiness_clear - clear host readiness bit
 511  *
 512  * @dev: the device structure
 513  */
 514 static void mei_txe_readiness_clear(struct mei_device *dev)
 515 {
 516         struct mei_txe_hw *hw = to_txe_hw(dev);
 517
 518         mei_txe_br_reg_write(hw, SICR_HOST_IPC_READINESS_REQ_REG,
 519                                 SICR_HOST_IPC_READINESS_RDY_CLR);
 520 }
 521 /**
 522  * mei_txe_readiness_get - Reads and returns
 523  *      the HICR_SEC_IPC_READINESS register value
 524  *
 525  * @dev: the device structure
 526  *
 527  * Return: the HICR_SEC_IPC_READINESS register value
 528  */
 529 static u32 mei_txe_readiness_get(struct mei_device *dev)
 530 {
 531         struct mei_txe_hw *hw = to_txe_hw(dev);
 532
 533         return mei_txe_br_reg_read(hw, HICR_SEC_IPC_READINESS_REG);
 534 }
 535
 536
 537 /**
 538  * mei_txe_readiness_is_sec_rdy - check readiness
 539  *  for HICR_SEC_IPC_READINESS_SEC_RDY
 540  *
 541  * @readiness: cached readiness state
 542  *
 543  * Return: true if readiness bit is set
 544  */
 545 static inline bool mei_txe_readiness_is_sec_rdy(u32 readiness)
 546 {
 547         return !!(readiness & HICR_SEC_IPC_READINESS_SEC_RDY);
 548 }
 549
 550 /**
 551  * mei_txe_hw_is_ready - check if the hw is ready
 552  *
 553  * @dev: the device structure
 554  *
 555  * Return: true if sec is ready
 556  */
 557 static bool mei_txe_hw_is_ready(struct mei_device *dev)
 558 {
 559         u32 readiness =  mei_txe_readiness_get(dev);
 560
 561         return mei_txe_readiness_is_sec_rdy(readiness);
 562 }
 563
 564 /**
 565  * mei_txe_host_is_ready - check if the host is ready
 566  *
 567  * @dev: the device structure
 568  *
 569  * Return: true if host is ready
 570  */
 571 static inline bool mei_txe_host_is_ready(struct mei_device *dev)
 572 {
 573         struct mei_txe_hw *hw = to_txe_hw(dev);
 574         u32 reg = mei_txe_br_reg_read(hw, HICR_SEC_IPC_READINESS_REG);
 575
 576         return !!(reg & HICR_SEC_IPC_READINESS_HOST_RDY);
 577 }
 578
 579 /**
 580  * mei_txe_readiness_wait - wait till readiness settles
 581  *
 582  * @dev: the device structure
 583  *
 584  * Return: 0 on success and -ETIME on timeout
 585  */
 586 static int mei_txe_readiness_wait(struct mei_device *dev)
 587 {
 588         if (mei_txe_hw_is_ready(dev))
 589                 return 0;
 590
 591         mutex_unlock(&dev->device_lock);
 592         wait_event_timeout(dev->wait_hw_ready, dev->recvd_hw_ready,
 593                         msecs_to_jiffies(SEC_RESET_WAIT_TIMEOUT));
 594         mutex_lock(&dev->device_lock);
 595         if (!dev->recvd_hw_ready) {
 596                 dev_err(dev->dev, "wait for readiness failed\n");
 597                 return -ETIME;
 598         }
 599
 600         dev->recvd_hw_ready = false;
 601         return 0;
 602 }
 603
 604 static const struct mei_fw_status mei_txe_fw_sts = {
 605         .count = 2,
 606         .status[0] = PCI_CFG_TXE_FW_STS0,
 607         .status[1] = PCI_CFG_TXE_FW_STS1
 608 };
 609
 610 /**
 611  * mei_txe_fw_status - read fw status register from pci config space
 612  *
 613  * @dev: mei device
 614  * @fw_status: fw status register values
 615  *
 616  * Return: 0 on success, error otherwise
 617  */
 618 static int mei_txe_fw_status(struct mei_device *dev,
 619                              struct mei_fw_status *fw_status)
 620 {
 621         const struct mei_fw_status *fw_src = &mei_txe_fw_sts;
 622         struct pci_dev *pdev = to_pci_dev(dev->dev);
 623         int ret;
 624         int i;
 625
 626         if (!fw_status)
 627                 return -EINVAL;
 628
 629         fw_status->count = fw_src->count;
 630         for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) {
 631                 ret = pci_read_config_dword(pdev,
 632                         fw_src->status[i], &fw_status->status[i]);
 633                 if (ret)
 634                         return ret;
 635         }
 636
 637         return 0;
 638 }
 639
 640 /**
 641  *  mei_txe_hw_config - configure hardware at the start of the devices
 642  *
 643  * @dev: the device structure
 644  *
 645  * Configure hardware at the start of the device should be done only
 646  *   once at the device probe time
 647  */
 648 static void mei_txe_hw_config(struct mei_device *dev)
 649 {
 650
 651         struct mei_txe_hw *hw = to_txe_hw(dev);
 652
 653         /* Doesn't change in runtime */
 654         dev->hbuf_depth = PAYLOAD_SIZE / 4;
 655
 656         hw->aliveness = mei_txe_aliveness_get(dev);
 657         hw->readiness = mei_txe_readiness_get(dev);
 658
 659         dev_dbg(dev->dev, "aliveness_resp = 0x%08x, readiness = 0x%08x.\n",
 660                 hw->aliveness, hw->readiness);
 661 }
 662
 663
 664 /**
 665  * mei_txe_write - writes a message to device.
 666  *
 667  * @dev: the device structure
 668  * @header: header of message
 669  * @buf: message buffer will be written
 670  *
 671  * Return: 0 if success, <0 - otherwise.
 672  */
 673
 674 static int mei_txe_write(struct mei_device *dev,
 675                 struct mei_msg_hdr *header, unsigned char *buf)
 676 {
 677         struct mei_txe_hw *hw = to_txe_hw(dev);
 678         unsigned long rem;
 679         unsigned long length;
 680         int slots = dev->hbuf_depth;
 681         u32 *reg_buf = (u32 *)buf;
 682         u32 dw_cnt;
 683         int i;
 684
 685         if (WARN_ON(!header || !buf))
 686                 return -EINVAL;
 687
 688         length = header->length;
 689
 690         dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(header));
 691
 692         dw_cnt = mei_data2slots(length);
 693         if (dw_cnt > slots)
 694                 return -EMSGSIZE;
 695
 696         if (WARN(!hw->aliveness, "txe write: aliveness not asserted\n"))
 697                 return -EAGAIN;
 698
 699         /* Enable Input Ready Interrupt. */
 700         mei_txe_input_ready_interrupt_enable(dev);
 701
 702         if (!mei_txe_is_input_ready(dev)) {
 703                 struct mei_fw_status fw_status;
 704
 705                 mei_fw_status(dev, &fw_status);
 706                 dev_err(dev->dev, "Input is not ready " FW_STS_FMT "\n",
 707                         FW_STS_PRM(fw_status));
 708                 return -EAGAIN;
 709         }
 710
 711         mei_txe_input_payload_write(dev, 0, *((u32 *)header));
 712
 713         for (i = 0; i < length / 4; i++)
 714                 mei_txe_input_payload_write(dev, i + 1, reg_buf[i]);
 715
 716         rem = length & 0x3;
 717         if (rem > 0) {
 718                 u32 reg = 0;
 719
 720                 memcpy(&reg, &buf[length - rem], rem);
 721                 mei_txe_input_payload_write(dev, i + 1, reg);
 722         }
 723
 724         /* after each write the whole buffer is consumed */
 725         hw->slots = 0;
 726
 727         /* Set Input-Doorbell */
 728         mei_txe_input_doorbell_set(hw);
 729
 730         return 0;
 731 }
 732
 733 /**
 734  * mei_txe_hbuf_max_len - mimics the me hbuf circular buffer
 735  *
 736  * @dev: the device structure
 737  *
 738  * Return: the PAYLOAD_SIZE - 4
 739  */
 740 static size_t mei_txe_hbuf_max_len(const struct mei_device *dev)
 741 {
 742         return PAYLOAD_SIZE - sizeof(struct mei_msg_hdr);
 743 }
 744
 745 /**
 746  * mei_txe_hbuf_empty_slots - mimics the me hbuf circular buffer
 747  *
 748  * @dev: the device structure
 749  *
 750  * Return: always hbuf_depth
 751  */
 752 static int mei_txe_hbuf_empty_slots(struct mei_device *dev)
 753 {
 754         struct mei_txe_hw *hw = to_txe_hw(dev);
 755
 756         return hw->slots;
 757 }
 758
 759 /**
 760  * mei_txe_count_full_read_slots - mimics the me device circular buffer
 761  *
 762  * @dev: the device structure
 763  *
 764  * Return: always buffer size in dwords count
 765  */
 766 static int mei_txe_count_full_read_slots(struct mei_device *dev)
 767 {
 768         /* read buffers has static size */
 769         return  PAYLOAD_SIZE / 4;
 770 }
 771
 772 /**
 773  * mei_txe_read_hdr - read message header which is always in 4 first bytes
 774  *
 775  * @dev: the device structure
 776  *
 777  * Return: mei message header
 778  */
 779
 780 static u32 mei_txe_read_hdr(const struct mei_device *dev)
 781 {
 782         return mei_txe_out_data_read(dev, 0);
 783 }
 784 /**
 785  * mei_txe_read - reads a message from the txe device.
 786  *
 787  * @dev: the device structure
 788  * @buf: message buffer will be written
 789  * @len: message size will be read
 790  *
 791  * Return: -EINVAL on error wrong argument and 0 on success
 792  */
 793 static int mei_txe_read(struct mei_device *dev,
 794                 unsigned char *buf, unsigned long len)
 795 {
 796
 797         struct mei_txe_hw *hw = to_txe_hw(dev);
 798         u32 *reg_buf, reg;
 799         u32 rem;
 800         u32 i;
 801
 802         if (WARN_ON(!buf || !len))
 803                 return -EINVAL;
 804
 805         reg_buf = (u32 *)buf;
 806         rem = len & 0x3;
 807
 808         dev_dbg(dev->dev, "buffer-length = %lu buf[0]0x%08X\n",
 809                 len, mei_txe_out_data_read(dev, 0));
 810
 811         for (i = 0; i < len / 4; i++) {
 812                 /* skip header: index starts from 1 */
 813                 reg = mei_txe_out_data_read(dev, i + 1);
 814                 dev_dbg(dev->dev, "buf[%d] = 0x%08X\n", i, reg);
 815                 *reg_buf++ = reg;
 816         }
 817
 818         if (rem) {
 819                 reg = mei_txe_out_data_read(dev, i + 1);
 820                 memcpy(reg_buf, &reg, rem);
 821         }
 822
 823         mei_txe_output_ready_set(hw);
 824         return 0;
 825 }
 826
 827 /**
 828  * mei_txe_hw_reset - resets host and fw.
 829  *
 830  * @dev: the device structure
 831  * @intr_enable: if interrupt should be enabled after reset.
 832  *
 833  * Return: 0 on success and < 0 in case of error
 834  */
 835 static int mei_txe_hw_reset(struct mei_device *dev, bool intr_enable)
 836 {
 837         struct mei_txe_hw *hw = to_txe_hw(dev);
 838
 839         u32 aliveness_req;
 840         /*
 841          * read input doorbell to ensure consistency between  Bridge and SeC
 842          * return value might be garbage return
 843          */
 844         (void)mei_txe_sec_reg_read_silent(hw, SEC_IPC_INPUT_DOORBELL_REG);
 845
 846         aliveness_req = mei_txe_aliveness_req_get(dev);
 847         hw->aliveness = mei_txe_aliveness_get(dev);
 848
 849         /* Disable interrupts in this stage we will poll */
 850         mei_txe_intr_disable(dev);
 851
 852         /*
 853          * If Aliveness Request and Aliveness Response are not equal then
 854          * wait for them to be equal
 855          * Since we might have interrupts disabled - poll for it
 856          */
 857         if (aliveness_req != hw->aliveness)
 858                 if (mei_txe_aliveness_poll(dev, aliveness_req) < 0) {
 859                         dev_err(dev->dev, "wait for aliveness settle failed ... bailing out\n");
 860                         return -EIO;
 861                 }
 862
 863         /*
 864          * If Aliveness Request and Aliveness Response are set then clear them
 865          */
 866         if (aliveness_req) {
 867                 mei_txe_aliveness_set(dev, 0);
 868                 if (mei_txe_aliveness_poll(dev, 0) < 0) {
 869                         dev_err(dev->dev, "wait for aliveness failed ... bailing out\n");
 870                         return -EIO;
 871                 }
 872         }
 873
 874         /*
 875          * Set readiness RDY_CLR bit
 876          */
 877         mei_txe_readiness_clear(dev);
 878
 879         return 0;
 880 }
 881
 882 /**
 883  * mei_txe_hw_start - start the hardware after reset
 884  *
 885  * @dev: the device structure
 886  *
 887  * Return: 0 on success an error code otherwise
 888  */
 889 static int mei_txe_hw_start(struct mei_device *dev)
 890 {
 891         struct mei_txe_hw *hw = to_txe_hw(dev);
 892         int ret;
 893
 894         u32 hisr;
 895
 896         /* bring back interrupts */
 897         mei_txe_intr_enable(dev);
 898
 899         ret = mei_txe_readiness_wait(dev);
 900         if (ret < 0) {
 901                 dev_err(dev->dev, "waiting for readiness failed\n");
 902                 return ret;
 903         }
 904
 905         /*
 906          * If HISR.INT2_STS interrupt status bit is set then clear it.
 907          */
 908         hisr = mei_txe_br_reg_read(hw, HISR_REG);
 909         if (hisr & HISR_INT_2_STS)
 910                 mei_txe_br_reg_write(hw, HISR_REG, HISR_INT_2_STS);
 911
 912         /* Clear the interrupt cause of OutputDoorbell */
 913         clear_bit(TXE_INTR_OUT_DB_BIT, &hw->intr_cause);
 914
 915         ret = mei_txe_aliveness_set_sync(dev, 1);
 916         if (ret < 0) {
 917                 dev_err(dev->dev, "wait for aliveness failed ... bailing out\n");
 918                 return ret;
 919         }
 920
 921         /* enable input ready interrupts:
 922          * SEC_IPC_HOST_INT_MASK.IPC_INPUT_READY_INT_MASK
 923          */
 924         mei_txe_input_ready_interrupt_enable(dev);
 925
 926
 927         /*  Set the SICR_SEC_IPC_OUTPUT_STATUS.IPC_OUTPUT_READY bit */
 928         mei_txe_output_ready_set(hw);
 929
 930         /* Set bit SICR_HOST_IPC_READINESS.HOST_RDY
 931          */
 932         mei_txe_readiness_set_host_rdy(dev);
 933
 934         return 0;
 935 }
 936
 937 /**
 938  * mei_txe_check_and_ack_intrs - translate multi BAR interrupt into
 939  *  single bit mask and acknowledge the interrupts
 940  *
 941  * @dev: the device structure
 942  * @do_ack: acknowledge interrupts
 943  *
 944  * Return: true if found interrupts to process.
 945  */
 946 static bool mei_txe_check_and_ack_intrs(struct mei_device *dev, bool do_ack)
 947 {
 948         struct mei_txe_hw *hw = to_txe_hw(dev);
 949         u32 hisr;
 950         u32 hhisr;
 951         u32 ipc_isr;
 952         u32 aliveness;
 953         bool generated;
 954
 955         /* read interrupt registers */
 956         hhisr = mei_txe_br_reg_read(hw, HHISR_REG);
 957         generated = (hhisr & IPC_HHIER_MSK);
 958         if (!generated)
 959                 goto out;
 960
 961         hisr = mei_txe_br_reg_read(hw, HISR_REG);
 962
 963         aliveness = mei_txe_aliveness_get(dev);
 964         if (hhisr & IPC_HHIER_SEC && aliveness)
 965                 ipc_isr = mei_txe_sec_reg_read_silent(hw,
 966                                 SEC_IPC_HOST_INT_STATUS_REG);
 967         else
 968                 ipc_isr = 0;
 969
 970         generated = generated ||
 971                 (hisr & HISR_INT_STS_MSK) ||
 972                 (ipc_isr & SEC_IPC_HOST_INT_STATUS_PENDING);
 973
 974         if (generated && do_ack) {
 975                 /* Save the interrupt causes */
 976                 hw->intr_cause |= hisr & HISR_INT_STS_MSK;
 977                 if (ipc_isr & SEC_IPC_HOST_INT_STATUS_IN_RDY)
 978                         hw->intr_cause |= TXE_INTR_IN_READY;
 979
 980
 981                 mei_txe_intr_disable(dev);
 982                 /* Clear the interrupts in hierarchy:
 983                  * IPC and Bridge, than the High Level */
 984                 mei_txe_sec_reg_write_silent(hw,
 985                         SEC_IPC_HOST_INT_STATUS_REG, ipc_isr);
 986                 mei_txe_br_reg_write(hw, HISR_REG, hisr);
 987                 mei_txe_br_reg_write(hw, HHISR_REG, hhisr);
 988         }
 989
 990 out:
 991         return generated;
 992 }
 993
 994 /**
 995  * mei_txe_irq_quick_handler - The ISR of the MEI device
 996  *
 997  * @irq: The irq number
 998  * @dev_id: pointer to the device structure
 999  *
1000  * Return: IRQ_WAKE_THREAD if interrupt is designed for the device
1001  *         IRQ_NONE otherwise
1002  */
1003 irqreturn_t mei_txe_irq_quick_handler(int irq, void *dev_id)
1004 {
1005         struct mei_device *dev = dev_id;
1006
1007         if (mei_txe_check_and_ack_intrs(dev, true))
1008                 return IRQ_WAKE_THREAD;
1009         return IRQ_NONE;
1010 }
1011
1012
1013 /**
1014  * mei_txe_irq_thread_handler - txe interrupt thread
1015  *
1016  * @irq: The irq number
1017  * @dev_id: pointer to the device structure
1018  *
1019  * Return: IRQ_HANDLED
1020  */
1021 irqreturn_t mei_txe_irq_thread_handler(int irq, void *dev_id)
1022 {
1023         struct mei_device *dev = (struct mei_device *) dev_id;
1024         struct mei_txe_hw *hw = to_txe_hw(dev);
1025         struct mei_cl_cb complete_list;
1026         s32 slots;
1027         int rets = 0;
1028
1029         dev_dbg(dev->dev, "irq thread: Interrupt Registers HHISR|HISR|SEC=%02X|%04X|%02X\n",
1030                 mei_txe_br_reg_read(hw, HHISR_REG),
1031                 mei_txe_br_reg_read(hw, HISR_REG),
1032                 mei_txe_sec_reg_read_silent(hw, SEC_IPC_HOST_INT_STATUS_REG));
1033
1034
1035         /* initialize our complete list */
1036         mutex_lock(&dev->device_lock);
1037         mei_io_list_init(&complete_list);
1038
1039         if (pci_dev_msi_enabled(to_pci_dev(dev->dev)))
1040                 mei_txe_check_and_ack_intrs(dev, true);
1041
1042         /* show irq events */
1043         mei_txe_pending_interrupts(dev);
1044
1045         hw->aliveness = mei_txe_aliveness_get(dev);
1046         hw->readiness = mei_txe_readiness_get(dev);
1047
1048         /* Readiness:
1049          * Detection of TXE driver going through reset
1050          * or TXE driver resetting the HECI interface.
1051          */
1052         if (test_and_clear_bit(TXE_INTR_READINESS_BIT, &hw->intr_cause)) {
1053                 dev_dbg(dev->dev, "Readiness Interrupt was received...\n");
1054
1055                 /* Check if SeC is going through reset */
1056                 if (mei_txe_readiness_is_sec_rdy(hw->readiness)) {
1057                         dev_dbg(dev->dev, "we need to start the dev.\n");
1058                         dev->recvd_hw_ready = true;
1059                 } else {
1060                         dev->recvd_hw_ready = false;
1061                         if (dev->dev_state != MEI_DEV_RESETTING) {
1062
1063                                 dev_warn(dev->dev, "FW not ready: resetting.\n");
1064                                 schedule_work(&dev->reset_work);
1065                                 goto end;
1066
1067                         }
1068                 }
1069                 wake_up(&dev->wait_hw_ready);
1070         }
1071
1072         /************************************************************/
1073         /* Check interrupt cause:
1074          * Aliveness: Detection of SeC acknowledge of host request that
1075          * it remain alive or host cancellation of that request.
1076          */
1077
1078         if (test_and_clear_bit(TXE_INTR_ALIVENESS_BIT, &hw->intr_cause)) {
1079                 /* Clear the interrupt cause */
1080                 dev_dbg(dev->dev,
1081                         "Aliveness Interrupt: Status: %d\n", hw->aliveness);
1082                 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1083                 if (waitqueue_active(&hw->wait_aliveness_resp))
1084                         wake_up(&hw->wait_aliveness_resp);
1085         }
1086
1087
1088         /* Output Doorbell:
1089          * Detection of SeC having sent output to host
1090          */
1091         slots = mei_count_full_read_slots(dev);
1092         if (test_and_clear_bit(TXE_INTR_OUT_DB_BIT, &hw->intr_cause)) {
1093                 /* Read from TXE */
1094                 rets = mei_irq_read_handler(dev, &complete_list, &slots);
1095                 if (rets && dev->dev_state != MEI_DEV_RESETTING) {
1096                         dev_err(dev->dev,
1097                                 "mei_irq_read_handler ret = %d.\n", rets);
1098
1099                         schedule_work(&dev->reset_work);
1100                         goto end;
1101                 }
1102         }
1103         /* Input Ready: Detection if host can write to SeC */
1104         if (test_and_clear_bit(TXE_INTR_IN_READY_BIT, &hw->intr_cause)) {
1105                 dev->hbuf_is_ready = true;
1106                 hw->slots = dev->hbuf_depth;
1107         }
1108
1109         if (hw->aliveness && dev->hbuf_is_ready) {
1110                 /* get the real register value */
1111                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
1112                 rets = mei_irq_write_handler(dev, &complete_list);
1113                 if (rets && rets != -EMSGSIZE)
1114                         dev_err(dev->dev, "mei_irq_write_handler ret = %d.\n",
1115                                 rets);
1116                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
1117         }
1118
1119         mei_irq_compl_handler(dev, &complete_list);
1120
1121 end:
1122         dev_dbg(dev->dev, "interrupt thread end ret = %d\n", rets);
1123
1124         mutex_unlock(&dev->device_lock);
1125
1126         mei_enable_interrupts(dev);
1127         return IRQ_HANDLED;
1128 }
1129
1130 static const struct mei_hw_ops mei_txe_hw_ops = {
1131
1132         .host_is_ready = mei_txe_host_is_ready,
1133
1134         .fw_status = mei_txe_fw_status,
1135         .pg_state = mei_txe_pg_state,
1136
1137         .hw_is_ready = mei_txe_hw_is_ready,
1138         .hw_reset = mei_txe_hw_reset,
1139         .hw_config = mei_txe_hw_config,
1140         .hw_start = mei_txe_hw_start,
1141
1142         .pg_is_enabled = mei_txe_pg_is_enabled,
1143
1144         .intr_clear = mei_txe_intr_clear,
1145         .intr_enable = mei_txe_intr_enable,
1146         .intr_disable = mei_txe_intr_disable,
1147
1148         .hbuf_free_slots = mei_txe_hbuf_empty_slots,
1149         .hbuf_is_ready = mei_txe_is_input_ready,
1150         .hbuf_max_len = mei_txe_hbuf_max_len,
1151
1152         .write = mei_txe_write,
1153
1154         .rdbuf_full_slots = mei_txe_count_full_read_slots,
1155         .read_hdr = mei_txe_read_hdr,
1156
1157         .read = mei_txe_read,
1158
1159 };
1160
1161 /**
1162  * mei_txe_dev_init - allocates and initializes txe hardware specific structure
1163  *
1164  * @pdev: pci device
1165  *
1166  * Return: struct mei_device * on success or NULL
1167  */
1168 struct mei_device *mei_txe_dev_init(struct pci_dev *pdev)
1169 {
1170         struct mei_device *dev;
1171         struct mei_txe_hw *hw;
1172
1173         dev = kzalloc(sizeof(struct mei_device) +
1174                          sizeof(struct mei_txe_hw), GFP_KERNEL);
1175         if (!dev)
1176                 return NULL;
1177
1178         mei_device_init(dev, &pdev->dev, &mei_txe_hw_ops);
1179
1180         hw = to_txe_hw(dev);
1181
1182         init_waitqueue_head(&hw->wait_aliveness_resp);
1183
1184         return dev;
1185 }
1186
1187 /**
1188  * mei_txe_setup_satt2 - SATT2 configuration for DMA support.
1189  *
1190  * @dev:   the device structure
1191  * @addr:  physical address start of the range
1192  * @range: physical range size
1193  *
1194  * Return: 0 on success an error code otherwise
1195  */
1196 int mei_txe_setup_satt2(struct mei_device *dev, phys_addr_t addr, u32 range)
1197 {
1198         struct mei_txe_hw *hw = to_txe_hw(dev);
1199
1200         u32 lo32 = lower_32_bits(addr);
1201         u32 hi32 = upper_32_bits(addr);
1202         u32 ctrl;
1203
1204         /* SATT is limited to 36 Bits */
1205         if (hi32 & ~0xF)
1206                 return -EINVAL;
1207
1208         /* SATT has to be 16Byte aligned */
1209         if (lo32 & 0xF)
1210                 return -EINVAL;
1211
1212         /* SATT range has to be 4Bytes aligned */
1213         if (range & 0x4)
1214                 return -EINVAL;
1215
1216         /* SATT is limited to 32 MB range*/
1217         if (range > SATT_RANGE_MAX)
1218                 return -EINVAL;
1219
1220         ctrl = SATT2_CTRL_VALID_MSK;
1221         ctrl |= hi32  << SATT2_CTRL_BR_BASE_ADDR_REG_SHIFT;
1222
1223         mei_txe_br_reg_write(hw, SATT2_SAP_SIZE_REG, range);
1224         mei_txe_br_reg_write(hw, SATT2_BRG_BA_LSB_REG, lo32);
1225         mei_txe_br_reg_write(hw, SATT2_CTRL_REG, ctrl);
1226         dev_dbg(dev->dev, "SATT2: SAP_SIZE_OFFSET=0x%08X, BRG_BA_LSB_OFFSET=0x%08X, CTRL_OFFSET=0x%08X\n",
1227                 range, lo32, ctrl);
1228
1229         return 0;
1230 }