drivers/misc/mei/hw-me.c

   1 /*
   2  *
   3  * Intel Management Engine Interface (Intel MEI) Linux driver
   4  * Copyright (c) 2003-2012, 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
  19 #include <linux/kthread.h>
  20 #include <linux/interrupt.h>
  21
  22 #include "mei_dev.h"
  23 #include "hbm.h"
  24
  25 #include "hw-me.h"
  26 #include "hw-me-regs.h"
  27
  28 /**
  29  * mei_me_reg_read - Reads 32bit data from the mei device
  30  *
  31  * @hw: the me hardware structure
  32  * @offset: offset from which to read the data
  33  *
  34  * Return: register value (u32)
  35  */
  36 static inline u32 mei_me_reg_read(const struct mei_me_hw *hw,
  37                                unsigned long offset)
  38 {
  39         return ioread32(hw->mem_addr + offset);
  40 }
  41
  42
  43 /**
  44  * mei_me_reg_write - Writes 32bit data to the mei device
  45  *
  46  * @hw: the me hardware structure
  47  * @offset: offset from which to write the data
  48  * @value: register value to write (u32)
  49  */
  50 static inline void mei_me_reg_write(const struct mei_me_hw *hw,
  51                                  unsigned long offset, u32 value)
  52 {
  53         iowrite32(value, hw->mem_addr + offset);
  54 }
  55
  56 /**
  57  * mei_me_mecbrw_read - Reads 32bit data from ME circular buffer
  58  *  read window register
  59  *
  60  * @dev: the device structure
  61  *
  62  * Return: ME_CB_RW register value (u32)
  63  */
  64 static u32 mei_me_mecbrw_read(const struct mei_device *dev)
  65 {
  66         return mei_me_reg_read(to_me_hw(dev), ME_CB_RW);
  67 }
  68 /**
  69  * mei_me_mecsr_read - Reads 32bit data from the ME CSR
  70  *
  71  * @hw: the me hardware structure
  72  *
  73  * Return: ME_CSR_HA register value (u32)
  74  */
  75 static inline u32 mei_me_mecsr_read(const struct mei_me_hw *hw)
  76 {
  77         return mei_me_reg_read(hw, ME_CSR_HA);
  78 }
  79
  80 /**
  81  * mei_hcsr_read - Reads 32bit data from the host CSR
  82  *
  83  * @hw: the me hardware structure
  84  *
  85  * Return: H_CSR register value (u32)
  86  */
  87 static inline u32 mei_hcsr_read(const struct mei_me_hw *hw)
  88 {
  89         return mei_me_reg_read(hw, H_CSR);
  90 }
  91
  92 /**
  93  * mei_hcsr_set - writes H_CSR register to the mei device,
  94  * and ignores the H_IS bit for it is write-one-to-zero.
  95  *
  96  * @hw: the me hardware structure
  97  */
  98 static inline void mei_hcsr_set(struct mei_me_hw *hw, u32 hcsr)
  99 {
 100         hcsr &= ~H_IS;
 101         mei_me_reg_write(hw, H_CSR, hcsr);
 102 }
 103
 104 /**
 105  * mei_me_fw_status - read fw status register from pci config space
 106  *
 107  * @dev: mei device
 108  * @fw_status: fw status register values
 109  */
 110 static int mei_me_fw_status(struct mei_device *dev,
 111                             struct mei_fw_status *fw_status)
 112 {
 113         struct pci_dev *pdev = to_pci_dev(dev->dev);
 114         struct mei_me_hw *hw = to_me_hw(dev);
 115         const struct mei_fw_status *fw_src = &hw->cfg->fw_status;
 116         int ret;
 117         int i;
 118
 119         if (!fw_status)
 120                 return -EINVAL;
 121
 122         fw_status->count = fw_src->count;
 123         for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) {
 124                 ret = pci_read_config_dword(pdev,
 125                         fw_src->status[i], &fw_status->status[i]);
 126                 if (ret)
 127                         return ret;
 128         }
 129
 130         return 0;
 131 }
 132
 133 /**
 134  * mei_me_hw_config - configure hw dependent settings
 135  *
 136  * @dev: mei device
 137  */
 138 static void mei_me_hw_config(struct mei_device *dev)
 139 {
 140         struct mei_me_hw *hw = to_me_hw(dev);
 141         u32 hcsr = mei_hcsr_read(to_me_hw(dev));
 142         /* Doesn't change in runtime */
 143         dev->hbuf_depth = (hcsr & H_CBD) >> 24;
 144
 145         hw->pg_state = MEI_PG_OFF;
 146 }
 147
 148 /**
 149  * mei_me_pg_state  - translate internal pg state
 150  *   to the mei power gating state
 151  *
 152  * @hw -  me hardware
 153  * returns: MEI_PG_OFF if aliveness is on and MEI_PG_ON otherwise
 154  */
 155 static inline enum mei_pg_state mei_me_pg_state(struct mei_device *dev)
 156 {
 157         struct mei_me_hw *hw = to_me_hw(dev);
 158
 159         return hw->pg_state;
 160 }
 161
 162 /**
 163  * mei_clear_interrupts - clear and stop interrupts
 164  *
 165  * @dev: the device structure
 166  */
 167 static void mei_me_intr_clear(struct mei_device *dev)
 168 {
 169         struct mei_me_hw *hw = to_me_hw(dev);
 170         u32 hcsr = mei_hcsr_read(hw);
 171
 172         if ((hcsr & H_IS) == H_IS)
 173                 mei_me_reg_write(hw, H_CSR, hcsr);
 174 }
 175 /**
 176  * mei_me_intr_enable - enables mei device interrupts
 177  *
 178  * @dev: the device structure
 179  */
 180 static void mei_me_intr_enable(struct mei_device *dev)
 181 {
 182         struct mei_me_hw *hw = to_me_hw(dev);
 183         u32 hcsr = mei_hcsr_read(hw);
 184
 185         hcsr |= H_IE;
 186         mei_hcsr_set(hw, hcsr);
 187 }
 188
 189 /**
 190  * mei_disable_interrupts - disables mei device interrupts
 191  *
 192  * @dev: the device structure
 193  */
 194 static void mei_me_intr_disable(struct mei_device *dev)
 195 {
 196         struct mei_me_hw *hw = to_me_hw(dev);
 197         u32 hcsr = mei_hcsr_read(hw);
 198
 199         hcsr  &= ~H_IE;
 200         mei_hcsr_set(hw, hcsr);
 201 }
 202
 203 /**
 204  * mei_me_hw_reset_release - release device from the reset
 205  *
 206  * @dev: the device structure
 207  */
 208 static void mei_me_hw_reset_release(struct mei_device *dev)
 209 {
 210         struct mei_me_hw *hw = to_me_hw(dev);
 211         u32 hcsr = mei_hcsr_read(hw);
 212
 213         hcsr |= H_IG;
 214         hcsr &= ~H_RST;
 215         mei_hcsr_set(hw, hcsr);
 216
 217         /* complete this write before we set host ready on another CPU */
 218         mmiowb();
 219 }
 220 /**
 221  * mei_me_hw_reset - resets fw via mei csr register.
 222  *
 223  * @dev: the device structure
 224  * @intr_enable: if interrupt should be enabled after reset.
 225  */
 226 static int mei_me_hw_reset(struct mei_device *dev, bool intr_enable)
 227 {
 228         struct mei_me_hw *hw = to_me_hw(dev);
 229         u32 hcsr = mei_hcsr_read(hw);
 230
 231         hcsr |= H_RST | H_IG | H_IS;
 232
 233         if (intr_enable)
 234                 hcsr |= H_IE;
 235         else
 236                 hcsr &= ~H_IE;
 237
 238         dev->recvd_hw_ready = false;
 239         mei_me_reg_write(hw, H_CSR, hcsr);
 240
 241         /*
 242          * Host reads the H_CSR once to ensure that the
 243          * posted write to H_CSR completes.
 244          */
 245         hcsr = mei_hcsr_read(hw);
 246
 247         if ((hcsr & H_RST) == 0)
 248                 dev_warn(dev->dev, "H_RST is not set = 0x%08X", hcsr);
 249
 250         if ((hcsr & H_RDY) == H_RDY)
 251                 dev_warn(dev->dev, "H_RDY is not cleared 0x%08X", hcsr);
 252
 253         if (intr_enable == false)
 254                 mei_me_hw_reset_release(dev);
 255
 256         return 0;
 257 }
 258
 259 /**
 260  * mei_me_host_set_ready - enable device
 261  *
 262  * @dev - mei device
 263  * returns bool
 264  */
 265
 266 static void mei_me_host_set_ready(struct mei_device *dev)
 267 {
 268         struct mei_me_hw *hw = to_me_hw(dev);
 269
 270         hw->host_hw_state = mei_hcsr_read(hw);
 271         hw->host_hw_state |= H_IE | H_IG | H_RDY;
 272         mei_hcsr_set(hw, hw->host_hw_state);
 273 }
 274 /**
 275  * mei_me_host_is_ready - check whether the host has turned ready
 276  *
 277  * @dev: mei device
 278  * Return: bool
 279  */
 280 static bool mei_me_host_is_ready(struct mei_device *dev)
 281 {
 282         struct mei_me_hw *hw = to_me_hw(dev);
 283
 284         hw->host_hw_state = mei_hcsr_read(hw);
 285         return (hw->host_hw_state & H_RDY) == H_RDY;
 286 }
 287
 288 /**
 289  * mei_me_hw_is_ready - check whether the me(hw) has turned ready
 290  *
 291  * @dev: mei device
 292  * Return: bool
 293  */
 294 static bool mei_me_hw_is_ready(struct mei_device *dev)
 295 {
 296         struct mei_me_hw *hw = to_me_hw(dev);
 297
 298         hw->me_hw_state = mei_me_mecsr_read(hw);
 299         return (hw->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA;
 300 }
 301
 302 static int mei_me_hw_ready_wait(struct mei_device *dev)
 303 {
 304         mutex_unlock(&dev->device_lock);
 305         wait_event_timeout(dev->wait_hw_ready,
 306                         dev->recvd_hw_ready,
 307                         mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT));
 308         mutex_lock(&dev->device_lock);
 309         if (!dev->recvd_hw_ready) {
 310                 dev_err(dev->dev, "wait hw ready failed\n");
 311                 return -ETIME;
 312         }
 313
 314         dev->recvd_hw_ready = false;
 315         return 0;
 316 }
 317
 318 static int mei_me_hw_start(struct mei_device *dev)
 319 {
 320         int ret = mei_me_hw_ready_wait(dev);
 321
 322         if (ret)
 323                 return ret;
 324         dev_dbg(dev->dev, "hw is ready\n");
 325
 326         mei_me_host_set_ready(dev);
 327         return ret;
 328 }
 329
 330
 331 /**
 332  * mei_hbuf_filled_slots - gets number of device filled buffer slots
 333  *
 334  * @dev: the device structure
 335  *
 336  * Return: number of filled slots
 337  */
 338 static unsigned char mei_hbuf_filled_slots(struct mei_device *dev)
 339 {
 340         struct mei_me_hw *hw = to_me_hw(dev);
 341         char read_ptr, write_ptr;
 342
 343         hw->host_hw_state = mei_hcsr_read(hw);
 344
 345         read_ptr = (char) ((hw->host_hw_state & H_CBRP) >> 8);
 346         write_ptr = (char) ((hw->host_hw_state & H_CBWP) >> 16);
 347
 348         return (unsigned char) (write_ptr - read_ptr);
 349 }
 350
 351 /**
 352  * mei_me_hbuf_is_empty - checks if host buffer is empty.
 353  *
 354  * @dev: the device structure
 355  *
 356  * Return: true if empty, false - otherwise.
 357  */
 358 static bool mei_me_hbuf_is_empty(struct mei_device *dev)
 359 {
 360         return mei_hbuf_filled_slots(dev) == 0;
 361 }
 362
 363 /**
 364  * mei_me_hbuf_empty_slots - counts write empty slots.
 365  *
 366  * @dev: the device structure
 367  *
 368  * Return: -EOVERFLOW if overflow, otherwise empty slots count
 369  */
 370 static int mei_me_hbuf_empty_slots(struct mei_device *dev)
 371 {
 372         unsigned char filled_slots, empty_slots;
 373
 374         filled_slots = mei_hbuf_filled_slots(dev);
 375         empty_slots = dev->hbuf_depth - filled_slots;
 376
 377         /* check for overflow */
 378         if (filled_slots > dev->hbuf_depth)
 379                 return -EOVERFLOW;
 380
 381         return empty_slots;
 382 }
 383
 384 static size_t mei_me_hbuf_max_len(const struct mei_device *dev)
 385 {
 386         return dev->hbuf_depth * sizeof(u32) - sizeof(struct mei_msg_hdr);
 387 }
 388
 389
 390 /**
 391  * mei_me_write_message - writes a message to mei device.
 392  *
 393  * @dev: the device structure
 394  * @header: mei HECI header of message
 395  * @buf: message payload will be written
 396  *
 397  * Return: -EIO if write has failed
 398  */
 399 static int mei_me_write_message(struct mei_device *dev,
 400                         struct mei_msg_hdr *header,
 401                         unsigned char *buf)
 402 {
 403         struct mei_me_hw *hw = to_me_hw(dev);
 404         unsigned long rem;
 405         unsigned long length = header->length;
 406         u32 *reg_buf = (u32 *)buf;
 407         u32 hcsr;
 408         u32 dw_cnt;
 409         int i;
 410         int empty_slots;
 411
 412         dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(header));
 413
 414         empty_slots = mei_hbuf_empty_slots(dev);
 415         dev_dbg(dev->dev, "empty slots = %hu.\n", empty_slots);
 416
 417         dw_cnt = mei_data2slots(length);
 418         if (empty_slots < 0 || dw_cnt > empty_slots)
 419                 return -EMSGSIZE;
 420
 421         mei_me_reg_write(hw, H_CB_WW, *((u32 *) header));
 422
 423         for (i = 0; i < length / 4; i++)
 424                 mei_me_reg_write(hw, H_CB_WW, reg_buf[i]);
 425
 426         rem = length & 0x3;
 427         if (rem > 0) {
 428                 u32 reg = 0;
 429
 430                 memcpy(&reg, &buf[length - rem], rem);
 431                 mei_me_reg_write(hw, H_CB_WW, reg);
 432         }
 433
 434         hcsr = mei_hcsr_read(hw) | H_IG;
 435         mei_hcsr_set(hw, hcsr);
 436         if (!mei_me_hw_is_ready(dev))
 437                 return -EIO;
 438
 439         return 0;
 440 }
 441
 442 /**
 443  * mei_me_count_full_read_slots - counts read full slots.
 444  *
 445  * @dev: the device structure
 446  *
 447  * Return: -EOVERFLOW if overflow, otherwise filled slots count
 448  */
 449 static int mei_me_count_full_read_slots(struct mei_device *dev)
 450 {
 451         struct mei_me_hw *hw = to_me_hw(dev);
 452         char read_ptr, write_ptr;
 453         unsigned char buffer_depth, filled_slots;
 454
 455         hw->me_hw_state = mei_me_mecsr_read(hw);
 456         buffer_depth = (unsigned char)((hw->me_hw_state & ME_CBD_HRA) >> 24);
 457         read_ptr = (char) ((hw->me_hw_state & ME_CBRP_HRA) >> 8);
 458         write_ptr = (char) ((hw->me_hw_state & ME_CBWP_HRA) >> 16);
 459         filled_slots = (unsigned char) (write_ptr - read_ptr);
 460
 461         /* check for overflow */
 462         if (filled_slots > buffer_depth)
 463                 return -EOVERFLOW;
 464
 465         dev_dbg(dev->dev, "filled_slots =%08x\n", filled_slots);
 466         return (int)filled_slots;
 467 }
 468
 469 /**
 470  * mei_me_read_slots - reads a message from mei device.
 471  *
 472  * @dev: the device structure
 473  * @buffer: message buffer will be written
 474  * @buffer_length: message size will be read
 475  */
 476 static int mei_me_read_slots(struct mei_device *dev, unsigned char *buffer,
 477                     unsigned long buffer_length)
 478 {
 479         struct mei_me_hw *hw = to_me_hw(dev);
 480         u32 *reg_buf = (u32 *)buffer;
 481         u32 hcsr;
 482
 483         for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
 484                 *reg_buf++ = mei_me_mecbrw_read(dev);
 485
 486         if (buffer_length > 0) {
 487                 u32 reg = mei_me_mecbrw_read(dev);
 488
 489                 memcpy(reg_buf, &reg, buffer_length);
 490         }
 491
 492         hcsr = mei_hcsr_read(hw) | H_IG;
 493         mei_hcsr_set(hw, hcsr);
 494         return 0;
 495 }
 496
 497 /**
 498  * mei_me_pg_enter - write pg enter register
 499  *
 500  * @dev: the device structure
 501  */
 502 static void mei_me_pg_enter(struct mei_device *dev)
 503 {
 504         struct mei_me_hw *hw = to_me_hw(dev);
 505         u32 reg = mei_me_reg_read(hw, H_HPG_CSR);
 506
 507         reg |= H_HPG_CSR_PGI;
 508         mei_me_reg_write(hw, H_HPG_CSR, reg);
 509 }
 510
 511 /**
 512  * mei_me_pg_exit - write pg exit register
 513  *
 514  * @dev: the device structure
 515  */
 516 static void mei_me_pg_exit(struct mei_device *dev)
 517 {
 518         struct mei_me_hw *hw = to_me_hw(dev);
 519         u32 reg = mei_me_reg_read(hw, H_HPG_CSR);
 520
 521         WARN(!(reg & H_HPG_CSR_PGI), "PGI is not set\n");
 522
 523         reg |= H_HPG_CSR_PGIHEXR;
 524         mei_me_reg_write(hw, H_HPG_CSR, reg);
 525 }
 526
 527 /**
 528  * mei_me_pg_set_sync - perform pg entry procedure
 529  *
 530  * @dev: the device structure
 531  *
 532  * Return: 0 on success an error code otherwise
 533  */
 534 int mei_me_pg_set_sync(struct mei_device *dev)
 535 {
 536         struct mei_me_hw *hw = to_me_hw(dev);
 537         unsigned long timeout = mei_secs_to_jiffies(MEI_PGI_TIMEOUT);
 538         int ret;
 539
 540         dev->pg_event = MEI_PG_EVENT_WAIT;
 541
 542         ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_ENTRY_REQ_CMD);
 543         if (ret)
 544                 return ret;
 545
 546         mutex_unlock(&dev->device_lock);
 547         wait_event_timeout(dev->wait_pg,
 548                 dev->pg_event == MEI_PG_EVENT_RECEIVED, timeout);
 549         mutex_lock(&dev->device_lock);
 550
 551         if (dev->pg_event == MEI_PG_EVENT_RECEIVED) {
 552                 mei_me_pg_enter(dev);
 553                 ret = 0;
 554         } else {
 555                 ret = -ETIME;
 556         }
 557
 558         dev->pg_event = MEI_PG_EVENT_IDLE;
 559         hw->pg_state = MEI_PG_ON;
 560
 561         return ret;
 562 }
 563
 564 /**
 565  * mei_me_pg_unset_sync - perform pg exit procedure
 566  *
 567  * @dev: the device structure
 568  *
 569  * Return: 0 on success an error code otherwise
 570  */
 571 int mei_me_pg_unset_sync(struct mei_device *dev)
 572 {
 573         struct mei_me_hw *hw = to_me_hw(dev);
 574         unsigned long timeout = mei_secs_to_jiffies(MEI_PGI_TIMEOUT);
 575         int ret;
 576
 577         if (dev->pg_event == MEI_PG_EVENT_RECEIVED)
 578                 goto reply;
 579
 580         dev->pg_event = MEI_PG_EVENT_WAIT;
 581
 582         mei_me_pg_exit(dev);
 583
 584         mutex_unlock(&dev->device_lock);
 585         wait_event_timeout(dev->wait_pg,
 586                 dev->pg_event == MEI_PG_EVENT_RECEIVED, timeout);
 587         mutex_lock(&dev->device_lock);
 588
 589 reply:
 590         if (dev->pg_event == MEI_PG_EVENT_RECEIVED)
 591                 ret = mei_hbm_pg(dev, MEI_PG_ISOLATION_EXIT_RES_CMD);
 592         else
 593                 ret = -ETIME;
 594
 595         dev->pg_event = MEI_PG_EVENT_IDLE;
 596         hw->pg_state = MEI_PG_OFF;
 597
 598         return ret;
 599 }
 600
 601 /**
 602  * mei_me_pg_is_enabled - detect if PG is supported by HW
 603  *
 604  * @dev: the device structure
 605  *
 606  * Return: true is pg supported, false otherwise
 607  */
 608 static bool mei_me_pg_is_enabled(struct mei_device *dev)
 609 {
 610         struct mei_me_hw *hw = to_me_hw(dev);
 611         u32 reg = mei_me_reg_read(hw, ME_CSR_HA);
 612
 613         if ((reg & ME_PGIC_HRA) == 0)
 614                 goto notsupported;
 615
 616         if (!dev->hbm_f_pg_supported)
 617                 goto notsupported;
 618
 619         return true;
 620
 621 notsupported:
 622         dev_dbg(dev->dev, "pg: not supported: HGP = %d hbm version %d.%d ?= %d.%d\n",
 623                 !!(reg & ME_PGIC_HRA),
 624                 dev->version.major_version,
 625                 dev->version.minor_version,
 626                 HBM_MAJOR_VERSION_PGI,
 627                 HBM_MINOR_VERSION_PGI);
 628
 629         return false;
 630 }
 631
 632 /**
 633  * mei_me_irq_quick_handler - The ISR of the MEI device
 634  *
 635  * @irq: The irq number
 636  * @dev_id: pointer to the device structure
 637  *
 638  * Return: irqreturn_t
 639  */
 640
 641 irqreturn_t mei_me_irq_quick_handler(int irq, void *dev_id)
 642 {
 643         struct mei_device *dev = (struct mei_device *) dev_id;
 644         struct mei_me_hw *hw = to_me_hw(dev);
 645         u32 csr_reg = mei_hcsr_read(hw);
 646
 647         if ((csr_reg & H_IS) != H_IS)
 648                 return IRQ_NONE;
 649
 650         /* clear H_IS bit in H_CSR */
 651         mei_me_reg_write(hw, H_CSR, csr_reg);
 652
 653         return IRQ_WAKE_THREAD;
 654 }
 655
 656 /**
 657  * mei_me_irq_thread_handler - function called after ISR to handle the interrupt
 658  * processing.
 659  *
 660  * @irq: The irq number
 661  * @dev_id: pointer to the device structure
 662  *
 663  * Return: irqreturn_t
 664  *
 665  */
 666 irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id)
 667 {
 668         struct mei_device *dev = (struct mei_device *) dev_id;
 669         struct mei_cl_cb complete_list;
 670         s32 slots;
 671         int rets = 0;
 672
 673         dev_dbg(dev->dev, "function called after ISR to handle the interrupt processing.\n");
 674         /* initialize our complete list */
 675         mutex_lock(&dev->device_lock);
 676         mei_io_list_init(&complete_list);
 677
 678         /* Ack the interrupt here
 679          * In case of MSI we don't go through the quick handler */
 680         if (pci_dev_msi_enabled(to_pci_dev(dev->dev)))
 681                 mei_clear_interrupts(dev);
 682
 683         /* check if ME wants a reset */
 684         if (!mei_hw_is_ready(dev) && dev->dev_state != MEI_DEV_RESETTING) {
 685                 dev_warn(dev->dev, "FW not ready: resetting.\n");
 686                 schedule_work(&dev->reset_work);
 687                 goto end;
 688         }
 689
 690         /*  check if we need to start the dev */
 691         if (!mei_host_is_ready(dev)) {
 692                 if (mei_hw_is_ready(dev)) {
 693                         mei_me_hw_reset_release(dev);
 694                         dev_dbg(dev->dev, "we need to start the dev.\n");
 695
 696                         dev->recvd_hw_ready = true;
 697                         wake_up(&dev->wait_hw_ready);
 698                 } else {
 699                         dev_dbg(dev->dev, "Spurious Interrupt\n");
 700                 }
 701                 goto end;
 702         }
 703         /* check slots available for reading */
 704         slots = mei_count_full_read_slots(dev);
 705         while (slots > 0) {
 706                 dev_dbg(dev->dev, "slots to read = %08x\n", slots);
 707                 rets = mei_irq_read_handler(dev, &complete_list, &slots);
 708                 /* There is a race between ME write and interrupt delivery:
 709                  * Not all data is always available immediately after the
 710                  * interrupt, so try to read again on the next interrupt.
 711                  */
 712                 if (rets == -ENODATA)
 713                         break;
 714
 715                 if (rets && dev->dev_state != MEI_DEV_RESETTING) {
 716                         dev_err(dev->dev, "mei_irq_read_handler ret = %d.\n",
 717                                                 rets);
 718                         schedule_work(&dev->reset_work);
 719                         goto end;
 720                 }
 721         }
 722
 723         dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
 724
 725         /*
 726          * During PG handshake only allowed write is the replay to the
 727          * PG exit message, so block calling write function
 728          * if the pg state is not idle
 729          */
 730         if (dev->pg_event == MEI_PG_EVENT_IDLE) {
 731                 rets = mei_irq_write_handler(dev, &complete_list);
 732                 dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
 733         }
 734
 735         mei_irq_compl_handler(dev, &complete_list);
 736
 737 end:
 738         dev_dbg(dev->dev, "interrupt thread end ret = %d\n", rets);
 739         mutex_unlock(&dev->device_lock);
 740         return IRQ_HANDLED;
 741 }
 742
 743 static const struct mei_hw_ops mei_me_hw_ops = {
 744
 745         .fw_status = mei_me_fw_status,
 746         .pg_state  = mei_me_pg_state,
 747
 748         .host_is_ready = mei_me_host_is_ready,
 749
 750         .hw_is_ready = mei_me_hw_is_ready,
 751         .hw_reset = mei_me_hw_reset,
 752         .hw_config = mei_me_hw_config,
 753         .hw_start = mei_me_hw_start,
 754
 755         .pg_is_enabled = mei_me_pg_is_enabled,
 756
 757         .intr_clear = mei_me_intr_clear,
 758         .intr_enable = mei_me_intr_enable,
 759         .intr_disable = mei_me_intr_disable,
 760
 761         .hbuf_free_slots = mei_me_hbuf_empty_slots,
 762         .hbuf_is_ready = mei_me_hbuf_is_empty,
 763         .hbuf_max_len = mei_me_hbuf_max_len,
 764
 765         .write = mei_me_write_message,
 766
 767         .rdbuf_full_slots = mei_me_count_full_read_slots,
 768         .read_hdr = mei_me_mecbrw_read,
 769         .read = mei_me_read_slots
 770 };
 771
 772 static bool mei_me_fw_type_nm(struct pci_dev *pdev)
 773 {
 774         u32 reg;
 775
 776         pci_read_config_dword(pdev, PCI_CFG_HFS_2, &reg);
 777         /* make sure that bit 9 (NM) is up and bit 10 (DM) is down */
 778         return (reg & 0x600) == 0x200;
 779 }
 780
 781 #define MEI_CFG_FW_NM                           \
 782         .quirk_probe = mei_me_fw_type_nm
 783
 784 static bool mei_me_fw_type_sps(struct pci_dev *pdev)
 785 {
 786         u32 reg;
 787         /* Read ME FW Status check for SPS Firmware */
 788         pci_read_config_dword(pdev, PCI_CFG_HFS_1, &reg);
 789         /* if bits [19:16] = 15, running SPS Firmware */
 790         return (reg & 0xf0000) == 0xf0000;
 791 }
 792
 793 #define MEI_CFG_FW_SPS                           \
 794         .quirk_probe = mei_me_fw_type_sps
 795
 796
 797 #define MEI_CFG_LEGACY_HFS                      \
 798         .fw_status.count = 0
 799
 800 #define MEI_CFG_ICH_HFS                        \
 801         .fw_status.count = 1,                   \
 802         .fw_status.status[0] = PCI_CFG_HFS_1
 803
 804 #define MEI_CFG_PCH_HFS                         \
 805         .fw_status.count = 2,                   \
 806         .fw_status.status[0] = PCI_CFG_HFS_1,   \
 807         .fw_status.status[1] = PCI_CFG_HFS_2
 808
 809
 810 /* ICH Legacy devices */
 811 const struct mei_cfg mei_me_legacy_cfg = {
 812         MEI_CFG_LEGACY_HFS,
 813 };
 814
 815 /* ICH devices */
 816 const struct mei_cfg mei_me_ich_cfg = {
 817         MEI_CFG_ICH_HFS,
 818 };
 819
 820 /* PCH devices */
 821 const struct mei_cfg mei_me_pch_cfg = {
 822         MEI_CFG_PCH_HFS,
 823 };
 824
 825
 826 /* PCH Cougar Point and Patsburg with quirk for Node Manager exclusion */
 827 const struct mei_cfg mei_me_pch_cpt_pbg_cfg = {
 828         MEI_CFG_PCH_HFS,
 829         MEI_CFG_FW_NM,
 830 };
 831
 832 /* PCH Lynx Point with quirk for SPS Firmware exclusion */
 833 const struct mei_cfg mei_me_lpt_cfg = {
 834         MEI_CFG_PCH_HFS,
 835         MEI_CFG_FW_SPS,
 836 };
 837
 838 /**
 839  * mei_me_dev_init - allocates and initializes the mei device structure
 840  *
 841  * @pdev: The pci device structure
 842  * @cfg: per device generation config
 843  *
 844  * Return: The mei_device_device pointer on success, NULL on failure.
 845  */
 846 struct mei_device *mei_me_dev_init(struct pci_dev *pdev,
 847                                    const struct mei_cfg *cfg)
 848 {
 849         struct mei_device *dev;
 850         struct mei_me_hw *hw;
 851
 852         dev = kzalloc(sizeof(struct mei_device) +
 853                          sizeof(struct mei_me_hw), GFP_KERNEL);
 854         if (!dev)
 855                 return NULL;
 856         hw = to_me_hw(dev);
 857
 858         mei_device_init(dev, &pdev->dev, &mei_me_hw_ops);
 859         hw->cfg = cfg;
 860         return dev;
 861 }
 862