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  * @dev: the device structure
  32  * @offset: offset from which to read the data
  33  *
  34  * returns 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  * @dev: the device 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  * returns 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  * @dev: the device structure
  72  *
  73  * returns 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  * @dev: the device structure
  84  *
  85  * returns 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  * @dev: the device 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 /**
 106  * mei_me_hw_config - configure hw dependent settings
 107  *
 108  * @dev: mei device
 109  */
 110 static void mei_me_hw_config(struct mei_device *dev)
 111 {
 112         u32 hcsr = mei_hcsr_read(to_me_hw(dev));
 113         /* Doesn't change in runtime */
 114         dev->hbuf_depth = (hcsr & H_CBD) >> 24;
 115 }
 116
 117 /**
 118  * mei_me_pg_state  - translate internal pg state
 119  *   to the mei power gating state
 120  *
 121  * @hw -  me hardware
 122  * returns: MEI_PG_OFF if aliveness is on and MEI_PG_ON otherwise
 123  */
 124 static inline enum mei_pg_state mei_me_pg_state(struct mei_device *dev)
 125 {
 126         return MEI_PG_OFF;
 127 }
 128
 129 /**
 130  * mei_clear_interrupts - clear and stop interrupts
 131  *
 132  * @dev: the device structure
 133  */
 134 static void mei_me_intr_clear(struct mei_device *dev)
 135 {
 136         struct mei_me_hw *hw = to_me_hw(dev);
 137         u32 hcsr = mei_hcsr_read(hw);
 138         if ((hcsr & H_IS) == H_IS)
 139                 mei_me_reg_write(hw, H_CSR, hcsr);
 140 }
 141 /**
 142  * mei_me_intr_enable - enables mei device interrupts
 143  *
 144  * @dev: the device structure
 145  */
 146 static void mei_me_intr_enable(struct mei_device *dev)
 147 {
 148         struct mei_me_hw *hw = to_me_hw(dev);
 149         u32 hcsr = mei_hcsr_read(hw);
 150         hcsr |= H_IE;
 151         mei_hcsr_set(hw, hcsr);
 152 }
 153
 154 /**
 155  * mei_disable_interrupts - disables mei device interrupts
 156  *
 157  * @dev: the device structure
 158  */
 159 static void mei_me_intr_disable(struct mei_device *dev)
 160 {
 161         struct mei_me_hw *hw = to_me_hw(dev);
 162         u32 hcsr = mei_hcsr_read(hw);
 163         hcsr  &= ~H_IE;
 164         mei_hcsr_set(hw, hcsr);
 165 }
 166
 167 /**
 168  * mei_me_hw_reset_release - release device from the reset
 169  *
 170  * @dev: the device structure
 171  */
 172 static void mei_me_hw_reset_release(struct mei_device *dev)
 173 {
 174         struct mei_me_hw *hw = to_me_hw(dev);
 175         u32 hcsr = mei_hcsr_read(hw);
 176
 177         hcsr |= H_IG;
 178         hcsr &= ~H_RST;
 179         mei_hcsr_set(hw, hcsr);
 180 }
 181 /**
 182  * mei_me_hw_reset - resets fw via mei csr register.
 183  *
 184  * @dev: the device structure
 185  * @intr_enable: if interrupt should be enabled after reset.
 186  */
 187 static int mei_me_hw_reset(struct mei_device *dev, bool intr_enable)
 188 {
 189         struct mei_me_hw *hw = to_me_hw(dev);
 190         u32 hcsr = mei_hcsr_read(hw);
 191
 192         hcsr |= H_RST | H_IG | H_IS;
 193
 194         if (intr_enable)
 195                 hcsr |= H_IE;
 196         else
 197                 hcsr &= ~H_IE;
 198
 199         mei_me_reg_write(hw, H_CSR, hcsr);
 200
 201         if (intr_enable == false)
 202                 mei_me_hw_reset_release(dev);
 203
 204         return 0;
 205 }
 206
 207 /**
 208  * mei_me_host_set_ready - enable device
 209  *
 210  * @dev - mei device
 211  * returns bool
 212  */
 213
 214 static void mei_me_host_set_ready(struct mei_device *dev)
 215 {
 216         struct mei_me_hw *hw = to_me_hw(dev);
 217         hw->host_hw_state |= H_IE | H_IG | H_RDY;
 218         mei_hcsr_set(hw, hw->host_hw_state);
 219 }
 220 /**
 221  * mei_me_host_is_ready - check whether the host has turned ready
 222  *
 223  * @dev - mei device
 224  * returns bool
 225  */
 226 static bool mei_me_host_is_ready(struct mei_device *dev)
 227 {
 228         struct mei_me_hw *hw = to_me_hw(dev);
 229         hw->host_hw_state = mei_hcsr_read(hw);
 230         return (hw->host_hw_state & H_RDY) == H_RDY;
 231 }
 232
 233 /**
 234  * mei_me_hw_is_ready - check whether the me(hw) has turned ready
 235  *
 236  * @dev - mei device
 237  * returns bool
 238  */
 239 static bool mei_me_hw_is_ready(struct mei_device *dev)
 240 {
 241         struct mei_me_hw *hw = to_me_hw(dev);
 242         hw->me_hw_state = mei_me_mecsr_read(hw);
 243         return (hw->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA;
 244 }
 245
 246 static int mei_me_hw_ready_wait(struct mei_device *dev)
 247 {
 248         int err;
 249         if (mei_me_hw_is_ready(dev))
 250                 return 0;
 251
 252         dev->recvd_hw_ready = false;
 253         mutex_unlock(&dev->device_lock);
 254         err = wait_event_interruptible_timeout(dev->wait_hw_ready,
 255                         dev->recvd_hw_ready,
 256                         mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT));
 257         mutex_lock(&dev->device_lock);
 258         if (!err && !dev->recvd_hw_ready) {
 259                 if (!err)
 260                         err = -ETIME;
 261                 dev_err(&dev->pdev->dev,
 262                         "wait hw ready failed. status = %d\n", err);
 263                 return err;
 264         }
 265
 266         dev->recvd_hw_ready = false;
 267         return 0;
 268 }
 269
 270 static int mei_me_hw_start(struct mei_device *dev)
 271 {
 272         int ret = mei_me_hw_ready_wait(dev);
 273         if (ret)
 274                 return ret;
 275         dev_dbg(&dev->pdev->dev, "hw is ready\n");
 276
 277         mei_me_host_set_ready(dev);
 278         return ret;
 279 }
 280
 281
 282 /**
 283  * mei_hbuf_filled_slots - gets number of device filled buffer slots
 284  *
 285  * @dev: the device structure
 286  *
 287  * returns number of filled slots
 288  */
 289 static unsigned char mei_hbuf_filled_slots(struct mei_device *dev)
 290 {
 291         struct mei_me_hw *hw = to_me_hw(dev);
 292         char read_ptr, write_ptr;
 293
 294         hw->host_hw_state = mei_hcsr_read(hw);
 295
 296         read_ptr = (char) ((hw->host_hw_state & H_CBRP) >> 8);
 297         write_ptr = (char) ((hw->host_hw_state & H_CBWP) >> 16);
 298
 299         return (unsigned char) (write_ptr - read_ptr);
 300 }
 301
 302 /**
 303  * mei_me_hbuf_is_empty - checks if host buffer is empty.
 304  *
 305  * @dev: the device structure
 306  *
 307  * returns true if empty, false - otherwise.
 308  */
 309 static bool mei_me_hbuf_is_empty(struct mei_device *dev)
 310 {
 311         return mei_hbuf_filled_slots(dev) == 0;
 312 }
 313
 314 /**
 315  * mei_me_hbuf_empty_slots - counts write empty slots.
 316  *
 317  * @dev: the device structure
 318  *
 319  * returns -EOVERFLOW if overflow, otherwise empty slots count
 320  */
 321 static int mei_me_hbuf_empty_slots(struct mei_device *dev)
 322 {
 323         unsigned char filled_slots, empty_slots;
 324
 325         filled_slots = mei_hbuf_filled_slots(dev);
 326         empty_slots = dev->hbuf_depth - filled_slots;
 327
 328         /* check for overflow */
 329         if (filled_slots > dev->hbuf_depth)
 330                 return -EOVERFLOW;
 331
 332         return empty_slots;
 333 }
 334
 335 static size_t mei_me_hbuf_max_len(const struct mei_device *dev)
 336 {
 337         return dev->hbuf_depth * sizeof(u32) - sizeof(struct mei_msg_hdr);
 338 }
 339
 340
 341 /**
 342  * mei_me_write_message - writes a message to mei device.
 343  *
 344  * @dev: the device structure
 345  * @header: mei HECI header of message
 346  * @buf: message payload will be written
 347  *
 348  * This function returns -EIO if write has failed
 349  */
 350 static int mei_me_write_message(struct mei_device *dev,
 351                         struct mei_msg_hdr *header,
 352                         unsigned char *buf)
 353 {
 354         struct mei_me_hw *hw = to_me_hw(dev);
 355         unsigned long rem;
 356         unsigned long length = header->length;
 357         u32 *reg_buf = (u32 *)buf;
 358         u32 hcsr;
 359         u32 dw_cnt;
 360         int i;
 361         int empty_slots;
 362
 363         dev_dbg(&dev->pdev->dev, MEI_HDR_FMT, MEI_HDR_PRM(header));
 364
 365         empty_slots = mei_hbuf_empty_slots(dev);
 366         dev_dbg(&dev->pdev->dev, "empty slots = %hu.\n", empty_slots);
 367
 368         dw_cnt = mei_data2slots(length);
 369         if (empty_slots < 0 || dw_cnt > empty_slots)
 370                 return -EMSGSIZE;
 371
 372         mei_me_reg_write(hw, H_CB_WW, *((u32 *) header));
 373
 374         for (i = 0; i < length / 4; i++)
 375                 mei_me_reg_write(hw, H_CB_WW, reg_buf[i]);
 376
 377         rem = length & 0x3;
 378         if (rem > 0) {
 379                 u32 reg = 0;
 380                 memcpy(&reg, &buf[length - rem], rem);
 381                 mei_me_reg_write(hw, H_CB_WW, reg);
 382         }
 383
 384         hcsr = mei_hcsr_read(hw) | H_IG;
 385         mei_hcsr_set(hw, hcsr);
 386         if (!mei_me_hw_is_ready(dev))
 387                 return -EIO;
 388
 389         return 0;
 390 }
 391
 392 /**
 393  * mei_me_count_full_read_slots - counts read full slots.
 394  *
 395  * @dev: the device structure
 396  *
 397  * returns -EOVERFLOW if overflow, otherwise filled slots count
 398  */
 399 static int mei_me_count_full_read_slots(struct mei_device *dev)
 400 {
 401         struct mei_me_hw *hw = to_me_hw(dev);
 402         char read_ptr, write_ptr;
 403         unsigned char buffer_depth, filled_slots;
 404
 405         hw->me_hw_state = mei_me_mecsr_read(hw);
 406         buffer_depth = (unsigned char)((hw->me_hw_state & ME_CBD_HRA) >> 24);
 407         read_ptr = (char) ((hw->me_hw_state & ME_CBRP_HRA) >> 8);
 408         write_ptr = (char) ((hw->me_hw_state & ME_CBWP_HRA) >> 16);
 409         filled_slots = (unsigned char) (write_ptr - read_ptr);
 410
 411         /* check for overflow */
 412         if (filled_slots > buffer_depth)
 413                 return -EOVERFLOW;
 414
 415         dev_dbg(&dev->pdev->dev, "filled_slots =%08x\n", filled_slots);
 416         return (int)filled_slots;
 417 }
 418
 419 /**
 420  * mei_me_read_slots - reads a message from mei device.
 421  *
 422  * @dev: the device structure
 423  * @buffer: message buffer will be written
 424  * @buffer_length: message size will be read
 425  */
 426 static int mei_me_read_slots(struct mei_device *dev, unsigned char *buffer,
 427                     unsigned long buffer_length)
 428 {
 429         struct mei_me_hw *hw = to_me_hw(dev);
 430         u32 *reg_buf = (u32 *)buffer;
 431         u32 hcsr;
 432
 433         for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
 434                 *reg_buf++ = mei_me_mecbrw_read(dev);
 435
 436         if (buffer_length > 0) {
 437                 u32 reg = mei_me_mecbrw_read(dev);
 438                 memcpy(reg_buf, &reg, buffer_length);
 439         }
 440
 441         hcsr = mei_hcsr_read(hw) | H_IG;
 442         mei_hcsr_set(hw, hcsr);
 443         return 0;
 444 }
 445
 446 /**
 447  * mei_me_pg_enter - write pg enter register to mei device.
 448  *
 449  * @dev: the device structure
 450  */
 451 static void mei_me_pg_enter(struct mei_device *dev)
 452 {
 453         struct mei_me_hw *hw = to_me_hw(dev);
 454         u32 reg = mei_me_reg_read(hw, H_HPG_CSR);
 455         reg |= H_HPG_CSR_PGI;
 456         mei_me_reg_write(hw, H_HPG_CSR, reg);
 457 }
 458
 459 /**
 460  * mei_me_pg_enter - write pg enter register to mei device.
 461  *
 462  * @dev: the device structure
 463  */
 464 static void mei_me_pg_exit(struct mei_device *dev)
 465 {
 466         struct mei_me_hw *hw = to_me_hw(dev);
 467         u32 reg = mei_me_reg_read(hw, H_HPG_CSR);
 468
 469         WARN(!(reg & H_HPG_CSR_PGI), "PGI is not set\n");
 470
 471         reg |= H_HPG_CSR_PGIHEXR;
 472         mei_me_reg_write(hw, H_HPG_CSR, reg);
 473 }
 474
 475 /**
 476  * mei_me_pg_is_enabled - detect if PG is supported by HW
 477  *
 478  * @dev: the device structure
 479  *
 480  * returns: true is pg supported, false otherwise
 481  */
 482 static bool mei_me_pg_is_enabled(struct mei_device *dev)
 483 {
 484         struct mei_me_hw *hw = to_me_hw(dev);
 485         u32 reg = mei_me_reg_read(hw, ME_CSR_HA);
 486
 487         if ((reg & ME_PGIC_HRA) == 0)
 488                 goto notsupported;
 489
 490         if (dev->version.major_version < HBM_MAJOR_VERSION_PGI)
 491                 goto notsupported;
 492
 493         if (dev->version.major_version == HBM_MAJOR_VERSION_PGI &&
 494             dev->version.minor_version < HBM_MINOR_VERSION_PGI)
 495                 goto notsupported;
 496
 497         return true;
 498
 499 notsupported:
 500         dev_dbg(&dev->pdev->dev, "pg: not supported: HGP = %d hbm version %d.%d ?= %d.%d\n",
 501                 !!(reg & ME_PGIC_HRA),
 502                 dev->version.major_version,
 503                 dev->version.minor_version,
 504                 HBM_MAJOR_VERSION_PGI,
 505                 HBM_MINOR_VERSION_PGI);
 506
 507         return false;
 508 }
 509
 510 /**
 511  * mei_me_irq_quick_handler - The ISR of the MEI device
 512  *
 513  * @irq: The irq number
 514  * @dev_id: pointer to the device structure
 515  *
 516  * returns irqreturn_t
 517  */
 518
 519 irqreturn_t mei_me_irq_quick_handler(int irq, void *dev_id)
 520 {
 521         struct mei_device *dev = (struct mei_device *) dev_id;
 522         struct mei_me_hw *hw = to_me_hw(dev);
 523         u32 csr_reg = mei_hcsr_read(hw);
 524
 525         if ((csr_reg & H_IS) != H_IS)
 526                 return IRQ_NONE;
 527
 528         /* clear H_IS bit in H_CSR */
 529         mei_me_reg_write(hw, H_CSR, csr_reg);
 530
 531         return IRQ_WAKE_THREAD;
 532 }
 533
 534 /**
 535  * mei_me_irq_thread_handler - function called after ISR to handle the interrupt
 536  * processing.
 537  *
 538  * @irq: The irq number
 539  * @dev_id: pointer to the device structure
 540  *
 541  * returns irqreturn_t
 542  *
 543  */
 544 irqreturn_t mei_me_irq_thread_handler(int irq, void *dev_id)
 545 {
 546         struct mei_device *dev = (struct mei_device *) dev_id;
 547         struct mei_cl_cb complete_list;
 548         s32 slots;
 549         int rets = 0;
 550
 551         dev_dbg(&dev->pdev->dev, "function called after ISR to handle the interrupt processing.\n");
 552         /* initialize our complete list */
 553         mutex_lock(&dev->device_lock);
 554         mei_io_list_init(&complete_list);
 555
 556         /* Ack the interrupt here
 557          * In case of MSI we don't go through the quick handler */
 558         if (pci_dev_msi_enabled(dev->pdev))
 559                 mei_clear_interrupts(dev);
 560
 561         /* check if ME wants a reset */
 562         if (!mei_hw_is_ready(dev) && dev->dev_state != MEI_DEV_RESETTING) {
 563                 dev_warn(&dev->pdev->dev, "FW not ready: resetting.\n");
 564                 schedule_work(&dev->reset_work);
 565                 goto end;
 566         }
 567
 568         /*  check if we need to start the dev */
 569         if (!mei_host_is_ready(dev)) {
 570                 if (mei_hw_is_ready(dev)) {
 571                         dev_dbg(&dev->pdev->dev, "we need to start the dev.\n");
 572
 573                         dev->recvd_hw_ready = true;
 574                         wake_up_interruptible(&dev->wait_hw_ready);
 575                 } else {
 576
 577                         dev_dbg(&dev->pdev->dev, "Reset Completed.\n");
 578                         mei_me_hw_reset_release(dev);
 579                 }
 580                 goto end;
 581         }
 582         /* check slots available for reading */
 583         slots = mei_count_full_read_slots(dev);
 584         while (slots > 0) {
 585                 dev_dbg(&dev->pdev->dev, "slots to read = %08x\n", slots);
 586                 rets = mei_irq_read_handler(dev, &complete_list, &slots);
 587                 /* There is a race between ME write and interrupt delivery:
 588                  * Not all data is always available immediately after the
 589                  * interrupt, so try to read again on the next interrupt.
 590                  */
 591                 if (rets == -ENODATA)
 592                         break;
 593
 594                 if (rets && dev->dev_state != MEI_DEV_RESETTING) {
 595                         dev_err(&dev->pdev->dev, "mei_irq_read_handler ret = %d.\n",
 596                                                 rets);
 597                         schedule_work(&dev->reset_work);
 598                         goto end;
 599                 }
 600         }
 601
 602         dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
 603
 604         rets = mei_irq_write_handler(dev, &complete_list);
 605
 606         dev->hbuf_is_ready = mei_hbuf_is_ready(dev);
 607
 608         mei_irq_compl_handler(dev, &complete_list);
 609
 610 end:
 611         dev_dbg(&dev->pdev->dev, "interrupt thread end ret = %d\n", rets);
 612         mutex_unlock(&dev->device_lock);
 613         return IRQ_HANDLED;
 614 }
 615 static const struct mei_hw_ops mei_me_hw_ops = {
 616
 617         .pg_state  = mei_me_pg_state,
 618
 619         .host_is_ready = mei_me_host_is_ready,
 620
 621         .hw_is_ready = mei_me_hw_is_ready,
 622         .hw_reset = mei_me_hw_reset,
 623         .hw_config = mei_me_hw_config,
 624         .hw_start = mei_me_hw_start,
 625
 626         .pg_is_enabled = mei_me_pg_is_enabled,
 627
 628         .intr_clear = mei_me_intr_clear,
 629         .intr_enable = mei_me_intr_enable,
 630         .intr_disable = mei_me_intr_disable,
 631
 632         .hbuf_free_slots = mei_me_hbuf_empty_slots,
 633         .hbuf_is_ready = mei_me_hbuf_is_empty,
 634         .hbuf_max_len = mei_me_hbuf_max_len,
 635
 636         .write = mei_me_write_message,
 637
 638         .rdbuf_full_slots = mei_me_count_full_read_slots,
 639         .read_hdr = mei_me_mecbrw_read,
 640         .read = mei_me_read_slots
 641 };
 642
 643 /**
 644  * mei_me_dev_init - allocates and initializes the mei device structure
 645  *
 646  * @pdev: The pci device structure
 647  *
 648  * returns The mei_device_device pointer on success, NULL on failure.
 649  */
 650 struct mei_device *mei_me_dev_init(struct pci_dev *pdev)
 651 {
 652         struct mei_device *dev;
 653
 654         dev = kzalloc(sizeof(struct mei_device) +
 655                          sizeof(struct mei_me_hw), GFP_KERNEL);
 656         if (!dev)
 657                 return NULL;
 658
 659         mei_device_init(dev);
 660
 661         dev->ops = &mei_me_hw_ops;
 662
 663         dev->pdev = pdev;
 664         return dev;
 665 }
 666