git.oblomov.eu Git - linux-2.6/blob - drivers/staging/heci/heci_main.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 <linux/module.h>
  43 #include <linux/moduleparam.h>
  44 #include <linux/kernel.h>
  45 #include <linux/slab.h>
  46 #include <linux/fs.h>
  47 #include <linux/errno.h>
  48 #include <linux/types.h>
  49 #include <linux/fcntl.h>
  50 #include <linux/aio.h>
  51 #include <linux/pci.h>
  52 #include <linux/reboot.h>
  53 #include <linux/poll.h>
  54 #include <linux/init.h>
  55 #include <linux/kdev_t.h>
  56 #include <linux/ioctl.h>
  57 #include <linux/cdev.h>
  58 #include <linux/device.h>
  59 #include <linux/unistd.h>
  60 #include <linux/kthread.h>
  61
  62 #include "heci.h"
  63 #include "heci_interface.h"
  64 #include "heci_version.h"
  65
  66
  67 #define HECI_READ_TIMEOUT       45
  68
  69 #define HECI_DRIVER_NAME        "heci"
  70
  71 /*
  72  *  heci driver strings
  73  */
  74 static char heci_driver_name[] = HECI_DRIVER_NAME;
  75 static char heci_driver_string[] = "Intel(R) Management Engine Interface";
  76 static char heci_driver_version[] = HECI_DRIVER_VERSION;
  77 static char heci_copyright[] = "Copyright (c) 2003 - 2008 Intel Corporation.";
  78
  79
  80 #ifdef HECI_DEBUG
  81 int heci_debug = 1;
  82 #else
  83 int heci_debug;
  84 #endif
  85 MODULE_PARM_DESC(heci_debug,  "Debug enabled or not");
  86 module_param(heci_debug, int, 0644);
  87
  88
  89 #define HECI_DEV_NAME   "heci"
  90
  91 /* heci char device for registration */
  92 static struct cdev heci_cdev;
  93
  94 /* major number for device */
  95 static int heci_major;
  96 /* The device pointer */
  97 static struct pci_dev *heci_device;
  98
  99 static struct class *heci_class;
 100
 101
 102 /* heci_pci_tbl - PCI Device ID Table */
 103 static struct pci_device_id heci_pci_tbl[] = {
 104         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82946GZ)},
 105         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82G35)},
 106         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82Q965)},
 107         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82G965)},
 108         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82GM965)},
 109         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_82GME965)},
 110         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_82Q35)},
 111         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_82G33)},
 112         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_82Q33)},
 113         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_82X38)},
 114         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_3200)},
 115         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_6)},
 116         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_7)},
 117         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_8)},
 118         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_9)},
 119         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9_10)},
 120         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9M_1)},
 121         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9M_2)},
 122         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9M_3)},
 123         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH9M_4)},
 124         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH10_1)},
 125         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH10_2)},
 126         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH10_3)},
 127         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, HECI_DEV_ID_ICH10_4)},
 128         /* required last entry */
 129         {0, }
 130 };
 131
 132 MODULE_DEVICE_TABLE(pci, heci_pci_tbl);
 133
 134 /*
 135  * Local Function Prototypes
 136  */
 137 static int __init heci_init_module(void);
 138 static void __exit heci_exit_module(void);
 139 static int __devinit heci_probe(struct pci_dev *pdev,
 140                                 const struct pci_device_id *ent);
 141 static void __devexit heci_remove(struct pci_dev *pdev);
 142 static int heci_open(struct inode *inode, struct file *file);
 143 static int heci_release(struct inode *inode, struct file *file);
 144 static ssize_t heci_read(struct file *file, char __user *ubuf,
 145                          size_t length, loff_t *offset);
 146 static int heci_ioctl(struct inode *inode, struct file *file,
 147                       unsigned int cmd, unsigned long data);
 148 static ssize_t heci_write(struct file *file, const char __user *ubuf,
 149                           size_t length, loff_t *offset);
 150 static unsigned int heci_poll(struct file *file, poll_table *wait);
 151 static struct heci_cb_private *find_read_list_entry(
 152                 struct iamt_heci_device *dev,
 153                 struct heci_file_private *file_ext);
 154 #ifdef CONFIG_PM
 155 static int heci_suspend(struct pci_dev *pdev, pm_message_t state);
 156 static int heci_resume(struct pci_dev *pdev);
 157 static __u16 g_sus_wd_timeout;
 158 #else
 159 #define heci_suspend NULL
 160 #define heci_resume NULL
 161 #endif
 162 /*
 163  *  PCI driver structure
 164  */
 165 static struct pci_driver heci_driver = {
 166         .name = heci_driver_name,
 167         .id_table = heci_pci_tbl,
 168         .probe = heci_probe,
 169         .remove = __devexit_p(heci_remove),
 170         .shutdown = __devexit_p(heci_remove),
 171         .suspend = heci_suspend,
 172         .resume = heci_resume
 173 };
 174
 175 /*
 176  * file operations structure will be use heci char device.
 177  */
 178 static const struct file_operations heci_fops = {
 179         .owner = THIS_MODULE,
 180         .read = heci_read,
 181         .ioctl = heci_ioctl,
 182         .open = heci_open,
 183         .release = heci_release,
 184         .write = heci_write,
 185         .poll = heci_poll,
 186 };
 187
 188 /**
 189  * heci_registration_cdev - set up the cdev structure for heci device.
 190  *
 191  * @dev: char device struct
 192  * @hminor: minor number for registration char device
 193  * @fops: file operations structure
 194  *
 195  * returns 0 on success, <0 on failure.
 196  */
 197 static int heci_registration_cdev(struct cdev *dev, int hminor,
 198                                   const struct file_operations *fops)
 199 {
 200         int ret, devno = MKDEV(heci_major, hminor);
 201
 202         cdev_init(dev, fops);
 203         dev->owner = THIS_MODULE;
 204         ret = cdev_add(dev, devno, 1);
 205         /* Fail gracefully if need be */
 206         if (ret) {
 207                 printk(KERN_ERR "heci: Error %d registering heci device %d\n",
 208                        ret, hminor);
 209         }
 210         return ret;
 211 }
 212
 213 /* Display the version of heci driver. */
 214 static ssize_t version_show(struct class *dev, char *buf)
 215 {
 216         return sprintf(buf, "%s %s.\n",
 217                        heci_driver_string, heci_driver_version);
 218 }
 219
 220 static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
 221
 222 /**
 223  * heci_register_cdev - registers heci char device
 224  *
 225  * returns 0 on success, <0 on failure.
 226  */
 227 static int heci_register_cdev(void)
 228 {
 229         int ret;
 230         dev_t dev;
 231
 232         /* registration of char devices */
 233         ret = alloc_chrdev_region(&dev, HECI_MINORS_BASE, HECI_MINORS_COUNT,
 234                                   HECI_DRIVER_NAME);
 235         if (ret) {
 236                 printk(KERN_ERR "heci: Error allocating char device region.\n");
 237                 return ret;
 238         }
 239
 240         heci_major = MAJOR(dev);
 241
 242         ret = heci_registration_cdev(&heci_cdev, HECI_MINOR_NUMBER,
 243                                      &heci_fops);
 244         if (ret)
 245                 unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
 246                                          HECI_MINORS_COUNT);
 247
 248         return ret;
 249 }
 250
 251 /**
 252  * heci_unregister_cdev - unregisters heci char device
 253  */
 254 static void heci_unregister_cdev(void)
 255 {
 256         cdev_del(&heci_cdev);
 257         unregister_chrdev_region(MKDEV(heci_major, HECI_MINORS_BASE),
 258                                  HECI_MINORS_COUNT);
 259 }
 260
 261 #ifndef HECI_DEVICE_CREATE
 262 #define HECI_DEVICE_CREATE device_create
 263 #endif
 264 /**
 265  * heci_sysfs_device_create - adds device entry to sysfs
 266  *
 267  * returns 0 on success, <0 on failure.
 268  */
 269 static int heci_sysfs_device_create(void)
 270 {
 271         struct class *class;
 272         void *tmphdev;
 273         int err = 0;
 274
 275         class = class_create(THIS_MODULE, HECI_DRIVER_NAME);
 276         if (IS_ERR(class)) {
 277                 err = PTR_ERR(class);
 278                 printk(KERN_ERR "heci: Error creating heci class.\n");
 279                 goto err_out;
 280         }
 281
 282         err = class_create_file(class, &class_attr_version);
 283         if (err) {
 284                 class_destroy(class);
 285                 printk(KERN_ERR "heci: Error creating heci class file.\n");
 286                 goto err_out;
 287         }
 288
 289         tmphdev = HECI_DEVICE_CREATE(class, NULL, heci_cdev.dev, NULL,
 290                                         HECI_DEV_NAME);
 291         if (IS_ERR(tmphdev)) {
 292                 err = PTR_ERR(tmphdev);
 293                 class_remove_file(class, &class_attr_version);
 294                 class_destroy(class);
 295                 goto err_out;
 296         }
 297
 298         heci_class = class;
 299 err_out:
 300         return err;
 301 }
 302
 303 /**
 304  * heci_sysfs_device_remove - unregisters the device entry on sysfs
 305  */
 306 static void heci_sysfs_device_remove(void)
 307 {
 308         if ((heci_class == NULL) || (IS_ERR(heci_class)))
 309                 return;
 310
 311         device_destroy(heci_class, heci_cdev.dev);
 312         class_remove_file(heci_class, &class_attr_version);
 313         class_destroy(heci_class);
 314 }
 315
 316 /**
 317  * heci_init_module - Driver Registration Routine
 318  *
 319  * heci_init_module is the first routine called when the driver is
 320  * loaded. All it does is register with the PCI subsystem.
 321  *
 322  * returns 0 on success, <0 on failure.
 323  */
 324 static int __init heci_init_module(void)
 325 {
 326         int ret = 0;
 327
 328         printk(KERN_INFO "heci: %s - version %s\n", heci_driver_string,
 329                         heci_driver_version);
 330         printk(KERN_INFO "heci: %s\n", heci_copyright);
 331
 332         /* init pci module */
 333         ret = pci_register_driver(&heci_driver);
 334         if (ret < 0) {
 335                 printk(KERN_ERR "heci: Error registering driver.\n");
 336                 goto end;
 337         }
 338
 339         ret = heci_register_cdev();
 340         if (ret)
 341                 goto unregister_pci;
 342
 343         ret = heci_sysfs_device_create();
 344         if (ret)
 345                 goto unregister_cdev;
 346
 347         return ret;
 348
 349 unregister_cdev:
 350         heci_unregister_cdev();
 351 unregister_pci:
 352         pci_unregister_driver(&heci_driver);
 353 end:
 354         return ret;
 355 }
 356
 357 module_init(heci_init_module);
 358
 359
 360 /**
 361  * heci_exit_module - Driver Exit Cleanup Routine
 362  *
 363  * heci_exit_module is called just before the driver is removed
 364  * from memory.
 365  */
 366 static void __exit heci_exit_module(void)
 367 {
 368         pci_unregister_driver(&heci_driver);
 369         heci_sysfs_device_remove();
 370         heci_unregister_cdev();
 371 }
 372
 373 module_exit(heci_exit_module);
 374
 375
 376 /**
 377  * heci_probe - Device Initialization Routine
 378  *
 379  * @pdev: PCI device information struct
 380  * @ent: entry in kcs_pci_tbl
 381  *
 382  * returns 0 on success, <0 on failure.
 383  */
 384 static int __devinit heci_probe(struct pci_dev *pdev,
 385                                 const struct pci_device_id *ent)
 386 {
 387         struct iamt_heci_device *dev = NULL;
 388         int i, err = 0;
 389
 390         if (heci_device) {
 391                 err = -EEXIST;
 392                 goto end;
 393         }
 394         /* enable pci dev */
 395         err = pci_enable_device(pdev);
 396         if (err) {
 397                 printk(KERN_ERR "heci: Failed to enable pci device.\n");
 398                 goto end;
 399         }
 400         /* set PCI host mastering  */
 401         pci_set_master(pdev);
 402         /* pci request regions for heci driver */
 403         err = pci_request_regions(pdev, heci_driver_name);
 404         if (err) {
 405                 printk(KERN_ERR "heci: Failed to get pci regions.\n");
 406                 goto disable_device;
 407         }
 408         /* allocates and initializes the heci dev structure */
 409         dev = init_heci_device(pdev);
 410         if (!dev) {
 411                 err = -ENOMEM;
 412                 goto release_regions;
 413         }
 414         /* mapping  IO device memory */
 415         for (i = 0; i <= 5; i++) {
 416                 if (pci_resource_len(pdev, i) == 0)
 417                         continue;
 418                 if (pci_resource_flags(pdev, i) & IORESOURCE_IO) {
 419                         printk(KERN_ERR "heci: heci has IO ports.\n");
 420                         goto free_device;
 421                 } else if (pci_resource_flags(pdev, i) & IORESOURCE_MEM) {
 422                         if (dev->mem_base) {
 423                                 printk(KERN_ERR
 424                                         "heci: Too many mem addresses.\n");
 425                                 goto free_device;
 426                         }
 427                         dev->mem_base = pci_resource_start(pdev, i);
 428                         dev->mem_length = pci_resource_len(pdev, i);
 429                 }
 430         }
 431         if (!dev->mem_base) {
 432                 printk(KERN_ERR "heci: No address to use.\n");
 433                 err = -ENODEV;
 434                 goto free_device;
 435         }
 436         dev->mem_addr = ioremap_nocache(dev->mem_base,
 437                         dev->mem_length);
 438         if (!dev->mem_addr) {
 439                 printk(KERN_ERR "heci: Remap IO device memory failure.\n");
 440                 err = -ENOMEM;
 441                 goto free_device;
 442         }
 443         /* request and enable interrupt   */
 444         err = request_irq(pdev->irq, heci_isr_interrupt, IRQF_SHARED,
 445                         heci_driver_name, dev);
 446         if (err) {
 447                 printk(KERN_ERR "heci: Request_irq failure. irq = %d \n",
 448                        pdev->irq);
 449                 goto unmap_memory;
 450         }
 451
 452         if (heci_hw_init(dev)) {
 453                 printk(KERN_ERR "heci: Init hw failure.\n");
 454                 err = -ENODEV;
 455                 goto release_irq;
 456         }
 457         init_timer(&dev->wd_timer);
 458
 459         heci_initialize_clients(dev);
 460         if (dev->heci_state != HECI_ENABLED) {
 461                 err = -ENODEV;
 462                 goto release_hw;
 463         }
 464
 465         spin_lock_bh(&dev->device_lock);
 466         heci_device = pdev;
 467         pci_set_drvdata(pdev, dev);
 468         spin_unlock_bh(&dev->device_lock);
 469
 470         if (dev->wd_timeout)
 471                 mod_timer(&dev->wd_timer, jiffies);
 472
 473 #ifdef CONFIG_PM
 474         g_sus_wd_timeout = 0;
 475 #endif
 476         printk(KERN_INFO "heci driver initialization successful.\n");
 477         return 0;
 478
 479 release_hw:
 480         /* disable interrupts */
 481         dev->host_hw_state = read_heci_register(dev, H_CSR);
 482         heci_csr_disable_interrupts(dev);
 483
 484         del_timer_sync(&dev->wd_timer);
 485
 486         flush_scheduled_work();
 487
 488 release_irq:
 489         free_irq(pdev->irq, dev);
 490 unmap_memory:
 491         if (dev->mem_addr)
 492                 iounmap(dev->mem_addr);
 493 free_device:
 494         kfree(dev);
 495 release_regions:
 496         pci_release_regions(pdev);
 497 disable_device:
 498         pci_disable_device(pdev);
 499 end:
 500         printk(KERN_ERR "heci driver initialization failed.\n");
 501         return err;
 502 }
 503
 504 /**
 505  * heci_remove - Device Removal Routine
 506  *
 507  * @pdev: PCI device information struct
 508  *
 509  * heci_remove is called by the PCI subsystem to alert the driver
 510  * that it should release a PCI device.
 511  */
 512 static void __devexit heci_remove(struct pci_dev *pdev)
 513 {
 514         struct iamt_heci_device *dev = pci_get_drvdata(pdev);
 515
 516         if (heci_device != pdev)
 517                 return;
 518
 519         if (dev == NULL)
 520                 return;
 521
 522         spin_lock_bh(&dev->device_lock);
 523         if (heci_device != pdev) {
 524                 spin_unlock_bh(&dev->device_lock);
 525                 return;
 526         }
 527
 528         if (dev->reinit_tsk != NULL) {
 529                 kthread_stop(dev->reinit_tsk);
 530                 dev->reinit_tsk = NULL;
 531         }
 532
 533         del_timer_sync(&dev->wd_timer);
 534         if (dev->wd_file_ext.state == HECI_FILE_CONNECTED
 535             && dev->wd_timeout) {
 536                 dev->wd_timeout = 0;
 537                 dev->wd_due_counter = 0;
 538                 memcpy(dev->wd_data, heci_stop_wd_params, HECI_WD_PARAMS_SIZE);
 539                 dev->stop = 1;
 540                 if (dev->host_buffer_is_empty &&
 541                     flow_ctrl_creds(dev, &dev->wd_file_ext)) {
 542                         dev->host_buffer_is_empty = 0;
 543
 544                         if (!heci_send_wd(dev))
 545                                 DBG("send stop WD failed\n");
 546                         else
 547                                 flow_ctrl_reduce(dev, &dev->wd_file_ext);
 548
 549                         dev->wd_pending = 0;
 550                 } else {
 551                         dev->wd_pending = 1;
 552                 }
 553                 dev->wd_stoped = 0;
 554                 spin_unlock_bh(&dev->device_lock);
 555
 556                 wait_event_interruptible_timeout(dev->wait_stop_wd,
 557                                 (dev->wd_stoped), 10 * HZ);
 558                 spin_lock_bh(&dev->device_lock);
 559                 if (!dev->wd_stoped)
 560                         DBG("stop wd failed to complete.\n");
 561                 else
 562                         DBG("stop wd complete.\n");
 563
 564         }
 565
 566         heci_device = NULL;
 567         spin_unlock_bh(&dev->device_lock);
 568
 569         if (dev->iamthif_file_ext.state == HECI_FILE_CONNECTED) {
 570                 dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTING;
 571                 heci_disconnect_host_client(dev,
 572                                             &dev->iamthif_file_ext);
 573         }
 574         if (dev->wd_file_ext.state == HECI_FILE_CONNECTED) {
 575                 dev->wd_file_ext.state = HECI_FILE_DISCONNECTING;
 576                 heci_disconnect_host_client(dev,
 577                                             &dev->wd_file_ext);
 578         }
 579
 580         spin_lock_bh(&dev->device_lock);
 581
 582         /* remove entry if already in list */
 583         DBG("list del iamthif and wd file list.\n");
 584         heci_remove_client_from_file_list(dev, dev->wd_file_ext.
 585                                           host_client_id);
 586         heci_remove_client_from_file_list(dev,
 587                         dev->iamthif_file_ext.host_client_id);
 588
 589         dev->iamthif_current_cb = NULL;
 590         dev->iamthif_file_ext.file = NULL;
 591         dev->num_heci_me_clients = 0;
 592
 593         spin_unlock_bh(&dev->device_lock);
 594
 595         flush_scheduled_work();
 596
 597         /* disable interrupts */
 598         heci_csr_disable_interrupts(dev);
 599
 600         free_irq(pdev->irq, dev);
 601         pci_set_drvdata(pdev, NULL);
 602
 603         if (dev->mem_addr)
 604                 iounmap(dev->mem_addr);
 605
 606         kfree(dev);
 607
 608         pci_release_regions(pdev);
 609         pci_disable_device(pdev);
 610 }
 611
 612 /**
 613  * heci_clear_list - remove all callbacks associated with file
 614  *              from heci_cb_list
 615  *
 616  * @file: file information struct
 617  * @heci_cb_list: callbacks list
 618  *
 619  * heci_clear_list is called to clear resources associated with file
 620  * when application calls close function or Ctrl-C was pressed
 621  *
 622  * returns 1 if callback removed from the list, 0 otherwise
 623  */
 624 static int heci_clear_list(struct iamt_heci_device *dev,
 625                 struct file *file, struct list_head *heci_cb_list)
 626 {
 627         struct heci_cb_private *priv_cb_pos = NULL;
 628         struct heci_cb_private *priv_cb_next = NULL;
 629         struct file *file_temp;
 630         int rets = 0;
 631
 632         /* list all list member */
 633         list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
 634                                  heci_cb_list, cb_list) {
 635                 file_temp = (struct file *)priv_cb_pos->file_object;
 636                 /* check if list member associated with a file */
 637                 if (file_temp == file) {
 638                         /* remove member from the list */
 639                         list_del(&priv_cb_pos->cb_list);
 640                         /* check if cb equal to current iamthif cb */
 641                         if (dev->iamthif_current_cb == priv_cb_pos) {
 642                                 dev->iamthif_current_cb = NULL;
 643                                 /* send flow control to iamthif client */
 644                                 heci_send_flow_control(dev,
 645                                                        &dev->iamthif_file_ext);
 646                         }
 647                         /* free all allocated buffers */
 648                         heci_free_cb_private(priv_cb_pos);
 649                         rets = 1;
 650                 }
 651         }
 652         return rets;
 653 }
 654
 655 /**
 656  * heci_clear_lists - remove all callbacks associated with file
 657  *
 658  * @dev: device information struct
 659  * @file: file information struct
 660  *
 661  * heci_clear_lists is called to clear resources associated with file
 662  * when application calls close function or Ctrl-C was pressed
 663  *
 664  * returns 1 if callback removed from the list, 0 otherwise
 665  */
 666 static int heci_clear_lists(struct iamt_heci_device *dev, struct file *file)
 667 {
 668         int rets = 0;
 669
 670         /* remove callbacks associated with a file */
 671         heci_clear_list(dev, file, &dev->pthi_cmd_list.heci_cb.cb_list);
 672         if (heci_clear_list(dev, file,
 673                             &dev->pthi_read_complete_list.heci_cb.cb_list))
 674                 rets = 1;
 675
 676         heci_clear_list(dev, file, &dev->ctrl_rd_list.heci_cb.cb_list);
 677
 678         if (heci_clear_list(dev, file, &dev->ctrl_wr_list.heci_cb.cb_list))
 679                 rets = 1;
 680
 681         if (heci_clear_list(dev, file,
 682                             &dev->write_waiting_list.heci_cb.cb_list))
 683                 rets = 1;
 684
 685         if (heci_clear_list(dev, file, &dev->write_list.heci_cb.cb_list))
 686                 rets = 1;
 687
 688         /* check if iamthif_current_cb not NULL */
 689         if (dev->iamthif_current_cb && (!rets)) {
 690                 /* check file and iamthif current cb association */
 691                 if (dev->iamthif_current_cb->file_object == file) {
 692                         /* remove cb */
 693                         heci_free_cb_private(dev->iamthif_current_cb);
 694                         dev->iamthif_current_cb = NULL;
 695                         rets = 1;
 696                 }
 697         }
 698         return rets;
 699 }
 700
 701 /**
 702  * heci_open - the open function
 703  *
 704  * @inode: pointer to inode structure
 705  * @file: pointer to file structure
 706  *
 707  * returns 0 on success, <0 on error
 708  */
 709 static int heci_open(struct inode *inode, struct file *file)
 710 {
 711         struct heci_file_private *file_ext;
 712         int if_num = iminor(inode);
 713         struct iamt_heci_device *dev;
 714
 715         if (!heci_device)
 716                 return -ENODEV;
 717
 718         dev = pci_get_drvdata(heci_device);
 719         if ((if_num != HECI_MINOR_NUMBER) || (!dev))
 720                 return -ENODEV;
 721
 722         file_ext = heci_alloc_file_private(file);
 723         if (file_ext == NULL)
 724                 return -ENOMEM;
 725
 726         spin_lock_bh(&dev->device_lock);
 727         if (dev->heci_state != HECI_ENABLED) {
 728                 spin_unlock_bh(&dev->device_lock);
 729                 kfree(file_ext);
 730                 return -ENODEV;
 731         }
 732         if (dev->open_handle_count >= HECI_MAX_OPEN_HANDLE_COUNT) {
 733                 spin_unlock_bh(&dev->device_lock);
 734                 kfree(file_ext);
 735                 return -ENFILE;
 736         };
 737         dev->open_handle_count++;
 738         list_add_tail(&file_ext->link, &dev->file_list);
 739         while ((dev->heci_host_clients[dev->current_host_client_id / 8]
 740                 & (1 << (dev->current_host_client_id % 8))) != 0) {
 741
 742                 dev->current_host_client_id++; /* allow overflow */
 743                 DBG("current_host_client_id = %d\n",
 744                     dev->current_host_client_id);
 745                 DBG("dev->open_handle_count = %lu\n",
 746                     dev->open_handle_count);
 747         }
 748         DBG("current_host_client_id = %d\n", dev->current_host_client_id);
 749         file_ext->host_client_id = dev->current_host_client_id;
 750         dev->heci_host_clients[file_ext->host_client_id / 8] |=
 751                 (1 << (file_ext->host_client_id % 8));
 752         spin_unlock_bh(&dev->device_lock);
 753         spin_lock(&file_ext->file_lock);
 754         file_ext->state = HECI_FILE_INITIALIZING;
 755         file_ext->sm_state = 0;
 756
 757         file->private_data = file_ext;
 758         spin_unlock(&file_ext->file_lock);
 759
 760         return 0;
 761 }
 762
 763 /**
 764  * heci_release - the release function
 765  *
 766  * @inode: pointer to inode structure
 767  * @file: pointer to file structure
 768  *
 769  * returns 0 on success, <0 on error
 770  */
 771 static int heci_release(struct inode *inode, struct file *file)
 772 {
 773         int rets = 0;
 774         int if_num = iminor(inode);
 775         struct heci_file_private *file_ext = file->private_data;
 776         struct heci_cb_private *priv_cb = NULL;
 777         struct iamt_heci_device *dev;
 778
 779         if (!heci_device)
 780                 return -ENODEV;
 781
 782         dev = pci_get_drvdata(heci_device);
 783         if ((if_num != HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
 784                 return -ENODEV;
 785
 786         if (file_ext != &dev->iamthif_file_ext) {
 787                 spin_lock(&file_ext->file_lock);
 788                 if (file_ext->state == HECI_FILE_CONNECTED) {
 789                         file_ext->state = HECI_FILE_DISCONNECTING;
 790                         spin_unlock(&file_ext->file_lock);
 791                         DBG("disconnecting client host client = %d, "
 792                             "ME client = %d\n",
 793                             file_ext->host_client_id,
 794                             file_ext->me_client_id);
 795                         rets = heci_disconnect_host_client(dev, file_ext);
 796                         spin_lock(&file_ext->file_lock);
 797                 }
 798                 spin_lock_bh(&dev->device_lock);
 799                 heci_flush_queues(dev, file_ext);
 800                 DBG("remove client host client = %d, ME client = %d\n",
 801                     file_ext->host_client_id,
 802                     file_ext->me_client_id);
 803
 804                 if (dev->open_handle_count > 0) {
 805                         dev->heci_host_clients[file_ext->host_client_id / 8] &=
 806                         ~(1 << (file_ext->host_client_id % 8));
 807                         dev->open_handle_count--;
 808                 }
 809                 heci_remove_client_from_file_list(dev,
 810                                 file_ext->host_client_id);
 811
 812                 /* free read cb */
 813                 if (file_ext->read_cb != NULL) {
 814                         priv_cb = find_read_list_entry(dev, file_ext);
 815                         /* Remove entry from read list */
 816                         if (priv_cb != NULL)
 817                                 list_del(&priv_cb->cb_list);
 818
 819                         priv_cb = file_ext->read_cb;
 820                         file_ext->read_cb = NULL;
 821                 }
 822
 823                 spin_unlock_bh(&dev->device_lock);
 824                 file->private_data = NULL;
 825                 spin_unlock(&file_ext->file_lock);
 826
 827                 if (priv_cb != NULL)
 828                         heci_free_cb_private(priv_cb);
 829
 830                 kfree(file_ext);
 831         } else {
 832                 spin_lock_bh(&dev->device_lock);
 833
 834                 if (dev->open_handle_count > 0)
 835                         dev->open_handle_count--;
 836
 837                 if (dev->iamthif_file_object == file
 838                     && dev->iamthif_state != HECI_IAMTHIF_IDLE) {
 839                         DBG("pthi canceled iamthif state %d\n",
 840                             dev->iamthif_state);
 841                         dev->iamthif_canceled = 1;
 842                         if (dev->iamthif_state == HECI_IAMTHIF_READ_COMPLETE) {
 843                                 DBG("run next pthi iamthif cb\n");
 844                                 run_next_iamthif_cmd(dev);
 845                         }
 846                 }
 847
 848                 if (heci_clear_lists(dev, file))
 849                         dev->iamthif_state = HECI_IAMTHIF_IDLE;
 850
 851                 spin_unlock_bh(&dev->device_lock);
 852         }
 853         return rets;
 854 }
 855
 856 static struct heci_cb_private *find_read_list_entry(
 857                 struct iamt_heci_device *dev,
 858                 struct heci_file_private *file_ext)
 859 {
 860         struct heci_cb_private *priv_cb_pos = NULL;
 861         struct heci_cb_private *priv_cb_next = NULL;
 862         struct heci_file_private *file_ext_list_temp;
 863
 864         if (dev->read_list.status == 0
 865             && !list_empty(&dev->read_list.heci_cb.cb_list)) {
 866                 DBG("remove read_list CB \n");
 867                 list_for_each_entry_safe(priv_cb_pos,
 868                                 priv_cb_next,
 869                                 &dev->read_list.heci_cb.cb_list, cb_list) {
 870
 871                         file_ext_list_temp = (struct heci_file_private *)
 872                                 priv_cb_pos->file_private;
 873
 874                         if ((file_ext_list_temp != NULL) &&
 875                             heci_fe_same_id(file_ext, file_ext_list_temp))
 876                                 return priv_cb_pos;
 877
 878                 }
 879         }
 880         return NULL;
 881 }
 882
 883 /**
 884  * heci_read - the read client message function.
 885  *
 886  * @file: pointer to file structure
 887  * @ubuf: pointer to user buffer
 888  * @length: buffer length
 889  * @offset: data offset in buffer
 890  *
 891  * returns >=0 data length on success , <0 on error
 892  */
 893 static ssize_t heci_read(struct file *file, char __user *ubuf,
 894                          size_t length, loff_t *offset)
 895 {
 896         int i;
 897         int rets = 0, err = 0;
 898         int if_num = iminor(file->f_dentry->d_inode);
 899         struct heci_file_private *file_ext = file->private_data;
 900         struct heci_cb_private *priv_cb_pos = NULL;
 901         struct heci_cb_private *priv_cb = NULL;
 902         struct iamt_heci_device *dev;
 903
 904         if (!heci_device)
 905                 return -ENODEV;
 906
 907         dev = pci_get_drvdata(heci_device);
 908         if ((if_num != HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
 909                 return -ENODEV;
 910
 911         spin_lock_bh(&dev->device_lock);
 912         if (dev->heci_state != HECI_ENABLED) {
 913                 spin_unlock_bh(&dev->device_lock);
 914                 return -ENODEV;
 915         }
 916         spin_unlock_bh(&dev->device_lock);
 917
 918         spin_lock(&file_ext->file_lock);
 919         if ((file_ext->sm_state & HECI_WD_STATE_INDEPENDENCE_MSG_SENT) == 0) {
 920                 spin_unlock(&file_ext->file_lock);
 921                 /* Do not allow to read watchdog client */
 922                 for (i = 0; i < dev->num_heci_me_clients; i++) {
 923                         if (memcmp(&heci_wd_guid,
 924                                    &dev->me_clients[i].props.protocol_name,
 925                                    sizeof(struct guid)) == 0) {
 926                                 if (file_ext->me_client_id ==
 927                                     dev->me_clients[i].client_id)
 928                                         return -EBADF;
 929                         }
 930                 }
 931         } else {
 932                 file_ext->sm_state &= ~HECI_WD_STATE_INDEPENDENCE_MSG_SENT;
 933                 spin_unlock(&file_ext->file_lock);
 934         }
 935
 936         if (file_ext == &dev->iamthif_file_ext) {
 937                 rets = pthi_read(dev, if_num, file, ubuf, length, offset);
 938                 goto out;
 939         }
 940
 941         if (file_ext->read_cb && file_ext->read_cb->information > *offset) {
 942                 priv_cb = file_ext->read_cb;
 943                 goto copy_buffer;
 944         } else if (file_ext->read_cb && file_ext->read_cb->information > 0 &&
 945                    file_ext->read_cb->information <= *offset) {
 946                 priv_cb = file_ext->read_cb;
 947                 rets = 0;
 948                 goto free;
 949         } else if ((!file_ext->read_cb || file_ext->read_cb->information == 0)
 950                     && *offset > 0) {
 951                 /*Offset needs to be cleaned for contingous reads*/
 952                 *offset = 0;
 953                 rets = 0;
 954                 goto out;
 955         }
 956
 957         spin_lock(&file_ext->read_io_lock);
 958         err = heci_start_read(dev, if_num, file_ext);
 959         if (err != 0 && err != -EBUSY) {
 960                 DBG("heci start read failure with status = %d\n", err);
 961                 spin_unlock(&file_ext->read_io_lock);
 962                 rets = err;
 963                 goto out;
 964         }
 965         if (HECI_READ_COMPLETE != file_ext->reading_state
 966                         && !waitqueue_active(&file_ext->rx_wait)) {
 967                 if (file->f_flags & O_NONBLOCK) {
 968                         rets = -EAGAIN;
 969                         spin_unlock(&file_ext->read_io_lock);
 970                         goto out;
 971                 }
 972                 spin_unlock(&file_ext->read_io_lock);
 973
 974                 if (wait_event_interruptible(file_ext->rx_wait,
 975                         (HECI_READ_COMPLETE == file_ext->reading_state
 976                          || HECI_FILE_INITIALIZING == file_ext->state
 977                          || HECI_FILE_DISCONNECTED == file_ext->state
 978                          || HECI_FILE_DISCONNECTING == file_ext->state))) {
 979                         if (signal_pending(current)) {
 980                                 rets = -EINTR;
 981                                 goto out;
 982                         }
 983                         return -ERESTARTSYS;
 984                 }
 985
 986                 if (HECI_FILE_INITIALIZING == file_ext->state ||
 987                     HECI_FILE_DISCONNECTED == file_ext->state ||
 988                     HECI_FILE_DISCONNECTING == file_ext->state) {
 989                         rets = -EBUSY;
 990                         goto out;
 991                 }
 992                 spin_lock(&file_ext->read_io_lock);
 993         }
 994
 995         priv_cb = file_ext->read_cb;
 996
 997         if (!priv_cb) {
 998                 spin_unlock(&file_ext->read_io_lock);
 999                 return -ENODEV;
1000         }
1001         if (file_ext->reading_state != HECI_READ_COMPLETE) {
1002                 spin_unlock(&file_ext->read_io_lock);
1003                 return 0;
1004         }
1005         spin_unlock(&file_ext->read_io_lock);
1006         /* now copy the data to user space */
1007 copy_buffer:
1008         DBG("priv_cb->response_buffer size - %d\n",
1009             priv_cb->response_buffer.size);
1010         DBG("priv_cb->information - %lu\n",
1011             priv_cb->information);
1012         if (length == 0 || ubuf == NULL ||
1013             *offset > priv_cb->information) {
1014                 rets = -EMSGSIZE;
1015                 goto free;
1016         }
1017
1018         /* length is being turncated to PAGE_SIZE, however, */
1019         /* information size may be longer */
1020         length = (length < (priv_cb->information - *offset) ?
1021                         length : (priv_cb->information - *offset));
1022
1023         if (copy_to_user(ubuf,
1024                          priv_cb->response_buffer.data + *offset,
1025                          length)) {
1026                 rets = -EFAULT;
1027                 goto free;
1028         }
1029
1030         rets = length;
1031         *offset += length;
1032         if ((unsigned long)*offset < priv_cb->information)
1033                 goto out;
1034
1035 free:
1036         spin_lock_bh(&dev->device_lock);
1037         priv_cb_pos = find_read_list_entry(dev, file_ext);
1038         /* Remove entry from read list */
1039         if (priv_cb_pos != NULL)
1040                 list_del(&priv_cb_pos->cb_list);
1041         spin_unlock_bh(&dev->device_lock);
1042         heci_free_cb_private(priv_cb);
1043         spin_lock(&file_ext->read_io_lock);
1044         file_ext->reading_state = HECI_IDLE;
1045         file_ext->read_cb = NULL;
1046         file_ext->read_pending = 0;
1047         spin_unlock(&file_ext->read_io_lock);
1048 out:    DBG("end heci read rets= %d\n", rets);
1049         return rets;
1050 }
1051
1052 /**
1053  * heci_write - the write function.
1054  *
1055  * @file: pointer to file structure
1056  * @ubuf: pointer to user buffer
1057  * @length: buffer length
1058  * @offset: data offset in buffer
1059  *
1060  * returns >=0 data length on success , <0 on error
1061  */
1062 static ssize_t heci_write(struct file *file, const char __user *ubuf,
1063                           size_t length, loff_t *offset)
1064 {
1065         int rets = 0;
1066         __u8 i;
1067         int if_num = iminor(file->f_dentry->d_inode);
1068         struct heci_file_private *file_ext = file->private_data;
1069         struct heci_cb_private *priv_write_cb = NULL;
1070         struct heci_msg_hdr heci_hdr;
1071         struct iamt_heci_device *dev;
1072         unsigned long currtime = get_seconds();
1073
1074         if (!heci_device)
1075                 return -ENODEV;
1076
1077         dev = pci_get_drvdata(heci_device);
1078
1079         if ((if_num != HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
1080                 return -ENODEV;
1081
1082         spin_lock_bh(&dev->device_lock);
1083
1084         if (dev->heci_state != HECI_ENABLED) {
1085                 spin_unlock_bh(&dev->device_lock);
1086                 return -ENODEV;
1087         }
1088         if (file_ext == &dev->iamthif_file_ext) {
1089                 priv_write_cb = find_pthi_read_list_entry(dev, file);
1090                 if ((priv_write_cb != NULL) &&
1091                      (((currtime - priv_write_cb->read_time) >
1092                             IAMTHIF_READ_TIMER) ||
1093                       (file_ext->reading_state == HECI_READ_COMPLETE))) {
1094                         (*offset) = 0;
1095                         list_del(&priv_write_cb->cb_list);
1096                         heci_free_cb_private(priv_write_cb);
1097                         priv_write_cb = NULL;
1098                 }
1099         }
1100
1101         /* free entry used in read */
1102         if (file_ext->reading_state == HECI_READ_COMPLETE) {
1103                 *offset = 0;
1104                 priv_write_cb = find_read_list_entry(dev, file_ext);
1105                 if (priv_write_cb != NULL) {
1106                         list_del(&priv_write_cb->cb_list);
1107                         heci_free_cb_private(priv_write_cb);
1108                         priv_write_cb = NULL;
1109                         spin_lock(&file_ext->read_io_lock);
1110                         file_ext->reading_state = HECI_IDLE;
1111                         file_ext->read_cb = NULL;
1112                         file_ext->read_pending = 0;
1113                         spin_unlock(&file_ext->read_io_lock);
1114                 }
1115         } else if (file_ext->reading_state == HECI_IDLE &&
1116                         file_ext->read_pending == 0)
1117                 (*offset) = 0;
1118
1119         spin_unlock_bh(&dev->device_lock);
1120
1121         priv_write_cb = kzalloc(sizeof(struct heci_cb_private), GFP_KERNEL);
1122         if (!priv_write_cb)
1123                 return -ENOMEM;
1124
1125         priv_write_cb->file_object = file;
1126         priv_write_cb->file_private = file_ext;
1127         priv_write_cb->request_buffer.data = kmalloc(length, GFP_KERNEL);
1128         if (!priv_write_cb->request_buffer.data) {
1129                 kfree(priv_write_cb);
1130                 return -ENOMEM;
1131         }
1132         DBG("length =%d\n", (int) length);
1133
1134         if (copy_from_user(priv_write_cb->request_buffer.data,
1135                 ubuf, length)) {
1136                 rets = -EFAULT;
1137                 goto fail;
1138         }
1139
1140         spin_lock(&file_ext->file_lock);
1141         file_ext->sm_state = 0;
1142         if ((length == 4) &&
1143             ((memcmp(heci_wd_state_independence_msg[0], ubuf, 4) == 0) ||
1144              (memcmp(heci_wd_state_independence_msg[1], ubuf, 4) == 0) ||
1145              (memcmp(heci_wd_state_independence_msg[2], ubuf, 4) == 0)))
1146                 file_ext->sm_state |= HECI_WD_STATE_INDEPENDENCE_MSG_SENT;
1147         spin_unlock(&file_ext->file_lock);
1148
1149         INIT_LIST_HEAD(&priv_write_cb->cb_list);
1150         if (file_ext == &dev->iamthif_file_ext) {
1151                 priv_write_cb->response_buffer.data =
1152                     kmalloc(IAMTHIF_MTU, GFP_KERNEL);
1153                 if (!priv_write_cb->response_buffer.data) {
1154                         rets = -ENOMEM;
1155                         goto fail;
1156                 }
1157                 spin_lock_bh(&dev->device_lock);
1158                 if (dev->heci_state != HECI_ENABLED) {
1159                         spin_unlock_bh(&dev->device_lock);
1160                         rets = -ENODEV;
1161                         goto fail;
1162                 }
1163                 for (i = 0; i < dev->num_heci_me_clients; i++) {
1164                         if (dev->me_clients[i].client_id ==
1165                                 dev->iamthif_file_ext.me_client_id)
1166                                 break;
1167                 }
1168
1169                 BUG_ON(dev->me_clients[i].client_id != file_ext->me_client_id);
1170                 if ((i == dev->num_heci_me_clients) ||
1171                     (dev->me_clients[i].client_id !=
1172                       dev->iamthif_file_ext.me_client_id)) {
1173
1174                         spin_unlock_bh(&dev->device_lock);
1175                         rets = -ENODEV;
1176                         goto fail;
1177                 } else if ((length > dev->me_clients[i].props.max_msg_length)
1178                             || (length <= 0)) {
1179                         spin_unlock_bh(&dev->device_lock);
1180                         rets = -EMSGSIZE;
1181                         goto fail;
1182                 }
1183
1184
1185                 priv_write_cb->response_buffer.size = IAMTHIF_MTU;
1186                 priv_write_cb->major_file_operations = HECI_IOCTL;
1187                 priv_write_cb->information = 0;
1188                 priv_write_cb->request_buffer.size = length;
1189                 if (dev->iamthif_file_ext.state != HECI_FILE_CONNECTED) {
1190                         spin_unlock_bh(&dev->device_lock);
1191                         rets = -ENODEV;
1192                         goto fail;
1193                 }
1194
1195                 if (!list_empty(&dev->pthi_cmd_list.heci_cb.cb_list)
1196                                 || dev->iamthif_state != HECI_IAMTHIF_IDLE) {
1197                         DBG("pthi_state = %d\n", (int) dev->iamthif_state);
1198                         DBG("add PTHI cb to pthi cmd waiting list\n");
1199                         list_add_tail(&priv_write_cb->cb_list,
1200                                         &dev->pthi_cmd_list.heci_cb.cb_list);
1201                         rets = length;
1202                 } else {
1203                         DBG("call pthi write\n");
1204                         rets = pthi_write(dev, priv_write_cb);
1205
1206                         if (rets != 0) {
1207                                 DBG("pthi write failed with status = %d\n",
1208                                     rets);
1209                                 spin_unlock_bh(&dev->device_lock);
1210                                 goto fail;
1211                         }
1212                         rets = length;
1213                 }
1214                 spin_unlock_bh(&dev->device_lock);
1215                 return rets;
1216         }
1217
1218         priv_write_cb->major_file_operations = HECI_WRITE;
1219         /* make sure information is zero before we start */
1220
1221         priv_write_cb->information = 0;
1222         priv_write_cb->request_buffer.size = length;
1223
1224         spin_lock(&file_ext->write_io_lock);
1225         DBG("host client = %d, ME client = %d\n",
1226             file_ext->host_client_id, file_ext->me_client_id);
1227         if (file_ext->state != HECI_FILE_CONNECTED) {
1228                 rets = -ENODEV;
1229                 DBG("host client = %d,  is not connected to ME client = %d",
1230                     file_ext->host_client_id,
1231                     file_ext->me_client_id);
1232
1233                 goto unlock;
1234         }
1235         for (i = 0; i < dev->num_heci_me_clients; i++) {
1236                 if (dev->me_clients[i].client_id ==
1237                     file_ext->me_client_id)
1238                         break;
1239         }
1240         BUG_ON(dev->me_clients[i].client_id != file_ext->me_client_id);
1241         if (i == dev->num_heci_me_clients) {
1242                 rets = -ENODEV;
1243                 goto unlock;
1244         }
1245         if (length > dev->me_clients[i].props.max_msg_length || length <= 0) {
1246                 rets = -EINVAL;
1247                 goto unlock;
1248         }
1249         priv_write_cb->file_private = file_ext;
1250
1251         spin_lock_bh(&dev->device_lock);
1252         if (flow_ctrl_creds(dev, file_ext) &&
1253                 dev->host_buffer_is_empty) {
1254                 spin_unlock_bh(&dev->device_lock);
1255                 dev->host_buffer_is_empty = 0;
1256                 if (length > ((((dev->host_hw_state & H_CBD) >> 24) *
1257                         sizeof(__u32)) - sizeof(struct heci_msg_hdr))) {
1258
1259                         heci_hdr.length =
1260                                 (((dev->host_hw_state & H_CBD) >> 24) *
1261                                 sizeof(__u32)) -
1262                                 sizeof(struct heci_msg_hdr);
1263                         heci_hdr.msg_complete = 0;
1264                 } else {
1265                         heci_hdr.length = length;
1266                         heci_hdr.msg_complete = 1;
1267                 }
1268                 heci_hdr.host_addr = file_ext->host_client_id;
1269                 heci_hdr.me_addr = file_ext->me_client_id;
1270                 heci_hdr.reserved = 0;
1271                 DBG("call heci_write_message header=%08x.\n",
1272                     *((__u32 *) &heci_hdr));
1273                 spin_unlock(&file_ext->write_io_lock);
1274                 /*  protect heci low level write */
1275                 spin_lock_bh(&dev->device_lock);
1276                 if (!heci_write_message(dev, &heci_hdr,
1277                         (unsigned char *) (priv_write_cb->request_buffer.data),
1278                         heci_hdr.length)) {
1279
1280                         spin_unlock_bh(&dev->device_lock);
1281                         heci_free_cb_private(priv_write_cb);
1282                         rets = -ENODEV;
1283                         priv_write_cb->information = 0;
1284                         return rets;
1285                 }
1286                 file_ext->writing_state = HECI_WRITING;
1287                 priv_write_cb->information = heci_hdr.length;
1288                 if (heci_hdr.msg_complete) {
1289                         flow_ctrl_reduce(dev, file_ext);
1290                         list_add_tail(&priv_write_cb->cb_list,
1291                                       &dev->write_waiting_list.heci_cb.cb_list);
1292                 } else {
1293                         list_add_tail(&priv_write_cb->cb_list,
1294                                       &dev->write_list.heci_cb.cb_list);
1295                 }
1296                 spin_unlock_bh(&dev->device_lock);
1297
1298         } else {
1299
1300                 spin_unlock_bh(&dev->device_lock);
1301                 priv_write_cb->information = 0;
1302                 file_ext->writing_state = HECI_WRITING;
1303                 spin_unlock(&file_ext->write_io_lock);
1304                 list_add_tail(&priv_write_cb->cb_list,
1305                               &dev->write_list.heci_cb.cb_list);
1306         }
1307         return length;
1308
1309 unlock:
1310         spin_unlock(&file_ext->write_io_lock);
1311 fail:
1312         heci_free_cb_private(priv_write_cb);
1313         return rets;
1314
1315 }
1316
1317 /**
1318  * heci_ioctl - the IOCTL function
1319  *
1320  * @inode: pointer to inode structure
1321  * @file: pointer to file structure
1322  * @cmd: ioctl command
1323  * @data: pointer to heci message structure
1324  *
1325  * returns 0 on success , <0 on error
1326  */
1327 static int heci_ioctl(struct inode *inode, struct file *file,
1328                       unsigned int cmd, unsigned long data)
1329 {
1330         int rets = 0;
1331         int if_num = iminor(inode);
1332         struct heci_file_private *file_ext = file->private_data;
1333         /* in user space */
1334         struct heci_message_data __user *u_msg;
1335         struct heci_message_data k_msg; /* all in kernel on the stack */
1336         struct iamt_heci_device *dev;
1337
1338         if (!capable(CAP_SYS_ADMIN))
1339                 return -EPERM;
1340
1341         if (!heci_device)
1342                 return -ENODEV;
1343
1344         dev = pci_get_drvdata(heci_device);
1345         if ((if_num != HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
1346                 return -ENODEV;
1347
1348         spin_lock_bh(&dev->device_lock);
1349         if (dev->heci_state != HECI_ENABLED) {
1350                 spin_unlock_bh(&dev->device_lock);
1351                 return -ENODEV;
1352         }
1353         spin_unlock_bh(&dev->device_lock);
1354
1355         /* first copy from user all data needed */
1356         u_msg = (struct heci_message_data __user *)data;
1357         if (copy_from_user(&k_msg, u_msg, sizeof(k_msg))) {
1358                 DBG("first copy from user all data needed filled\n");
1359                 return -EFAULT;
1360         }
1361         DBG("user message size is %d\n", k_msg.size);
1362
1363         switch (cmd) {
1364         case IOCTL_HECI_GET_VERSION:
1365                 DBG(": IOCTL_HECI_GET_VERSION\n");
1366                 rets = heci_ioctl_get_version(dev, if_num, u_msg, k_msg,
1367                                               file_ext);
1368                 break;
1369
1370         case IOCTL_HECI_CONNECT_CLIENT:
1371                 DBG(": IOCTL_HECI_CONNECT_CLIENT.\n");
1372                 rets = heci_ioctl_connect_client(dev, if_num, u_msg, k_msg,
1373                                                  file);
1374                 break;
1375
1376         case IOCTL_HECI_WD:
1377                 DBG(": IOCTL_HECI_WD.\n");
1378                 rets = heci_ioctl_wd(dev, if_num, k_msg, file_ext);
1379                 break;
1380
1381         case IOCTL_HECI_BYPASS_WD:
1382                 DBG(": IOCTL_HECI_BYPASS_WD.\n");
1383                 rets = heci_ioctl_bypass_wd(dev, if_num, k_msg, file_ext);
1384                 break;
1385
1386         default:
1387                 rets = -EINVAL;
1388                 break;
1389         }
1390         return rets;
1391 }
1392
1393 /**
1394  * heci_poll - the poll function
1395  *
1396  * @file: pointer to file structure
1397  * @wait: pointer to poll_table structure
1398  *
1399  * returns poll mask
1400  */
1401 static unsigned int heci_poll(struct file *file, poll_table *wait)
1402 {
1403         int if_num = iminor(file->f_dentry->d_inode);
1404         unsigned int mask = 0;
1405         struct heci_file_private *file_ext = file->private_data;
1406         struct iamt_heci_device *dev;
1407
1408         if (!heci_device)
1409                 return mask;
1410
1411         dev = pci_get_drvdata(heci_device);
1412
1413         if ((if_num != HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
1414                 return mask;
1415
1416         spin_lock_bh(&dev->device_lock);
1417         if (dev->heci_state != HECI_ENABLED) {
1418                 spin_unlock_bh(&dev->device_lock);
1419                 return mask;
1420         }
1421         spin_unlock_bh(&dev->device_lock);
1422
1423         if (file_ext == &dev->iamthif_file_ext) {
1424                 poll_wait(file, &dev->iamthif_file_ext.wait, wait);
1425                 spin_lock(&dev->iamthif_file_ext.file_lock);
1426                 if (dev->iamthif_state == HECI_IAMTHIF_READ_COMPLETE
1427                     && dev->iamthif_file_object == file) {
1428                         mask |= (POLLIN | POLLRDNORM);
1429                         spin_lock_bh(&dev->device_lock);
1430                         DBG("run next pthi cb\n");
1431                         run_next_iamthif_cmd(dev);
1432                         spin_unlock_bh(&dev->device_lock);
1433                 }
1434                 spin_unlock(&dev->iamthif_file_ext.file_lock);
1435
1436         } else{
1437                 poll_wait(file, &file_ext->tx_wait, wait);
1438                 spin_lock(&file_ext->write_io_lock);
1439                 if (HECI_WRITE_COMPLETE == file_ext->writing_state)
1440                         mask |= (POLLIN | POLLRDNORM);
1441
1442                 spin_unlock(&file_ext->write_io_lock);
1443         }
1444
1445         return mask;
1446 }
1447
1448 #ifdef CONFIG_PM
1449 static int heci_suspend(struct pci_dev *pdev, pm_message_t state)
1450 {
1451         struct iamt_heci_device *dev = pci_get_drvdata(pdev);
1452         int err = 0;
1453
1454         spin_lock_bh(&dev->device_lock);
1455         if (dev->reinit_tsk != NULL) {
1456                 kthread_stop(dev->reinit_tsk);
1457                 dev->reinit_tsk = NULL;
1458         }
1459         spin_unlock_bh(&dev->device_lock);
1460
1461         /* Stop watchdog if exists */
1462         del_timer_sync(&dev->wd_timer);
1463         if (dev->wd_file_ext.state == HECI_FILE_CONNECTED
1464             && dev->wd_timeout) {
1465                 spin_lock_bh(&dev->device_lock);
1466                 g_sus_wd_timeout = dev->wd_timeout;
1467                 dev->wd_timeout = 0;
1468                 dev->wd_due_counter = 0;
1469                 memcpy(dev->wd_data, heci_stop_wd_params,
1470                                         HECI_WD_PARAMS_SIZE);
1471                 dev->stop = 1;
1472                 if (dev->host_buffer_is_empty &&
1473                     flow_ctrl_creds(dev, &dev->wd_file_ext)) {
1474                         dev->host_buffer_is_empty = 0;
1475                         if (!heci_send_wd(dev))
1476                                 DBG("send stop WD failed\n");
1477                         else
1478                                 flow_ctrl_reduce(dev, &dev->wd_file_ext);
1479
1480                         dev->wd_pending = 0;
1481                 } else {
1482                         dev->wd_pending = 1;
1483                 }
1484                 spin_unlock_bh(&dev->device_lock);
1485                 dev->wd_stoped = 0;
1486
1487                 err = wait_event_interruptible_timeout(dev->wait_stop_wd,
1488                                                        (dev->wd_stoped),
1489                                                        10 * HZ);
1490                 if (!dev->wd_stoped)
1491                         DBG("stop wd failed to complete.\n");
1492                 else {
1493                         DBG("stop wd complete %d.\n", err);
1494                         err = 0;
1495                 }
1496         }
1497         /* Set new heci state */
1498         spin_lock_bh(&dev->device_lock);
1499         if (dev->heci_state == HECI_ENABLED ||
1500             dev->heci_state == HECI_RECOVERING_FROM_RESET) {
1501                 dev->heci_state = HECI_POWER_DOWN;
1502                 heci_reset(dev, 0);
1503         }
1504         spin_unlock_bh(&dev->device_lock);
1505
1506         pci_save_state(pdev);
1507
1508         pci_disable_device(pdev);
1509         free_irq(pdev->irq, dev);
1510
1511         pci_set_power_state(pdev, PCI_D3hot);
1512
1513         return err;
1514 }
1515
1516 static int heci_resume(struct pci_dev *pdev)
1517 {
1518         struct iamt_heci_device *dev;
1519         int err = 0;
1520
1521         pci_set_power_state(pdev, PCI_D0);
1522         pci_restore_state(pdev);
1523
1524         dev = pci_get_drvdata(pdev);
1525         if (!dev)
1526                 return -ENODEV;
1527
1528         /* request and enable interrupt   */
1529         err = request_irq(pdev->irq, heci_isr_interrupt, IRQF_SHARED,
1530                         heci_driver_name, dev);
1531         if (err) {
1532                 printk(KERN_ERR "heci: Request_irq failure. irq = %d \n",
1533                        pdev->irq);
1534                 return err;
1535         }
1536
1537         spin_lock_bh(&dev->device_lock);
1538         dev->heci_state = HECI_POWER_UP;
1539         heci_reset(dev, 1);
1540         spin_unlock_bh(&dev->device_lock);
1541
1542         /* Start watchdog if stopped in suspend */
1543         if (g_sus_wd_timeout != 0) {
1544                 dev->wd_timeout = g_sus_wd_timeout;
1545
1546                 memcpy(dev->wd_data, heci_start_wd_params,
1547                                         HECI_WD_PARAMS_SIZE);
1548                 memcpy(dev->wd_data + HECI_WD_PARAMS_SIZE,
1549                        &dev->wd_timeout, sizeof(__u16));
1550                 dev->wd_due_counter = 1;
1551
1552                 if (dev->wd_timeout)
1553                         mod_timer(&dev->wd_timer, jiffies);
1554
1555                 g_sus_wd_timeout = 0;
1556         }
1557         return err;
1558 }
1559 #endif
1560
1561 MODULE_AUTHOR("Intel Corporation");
1562 MODULE_DESCRIPTION("Intel(R) Management Engine Interface");
1563 MODULE_LICENSE("Dual BSD/GPL");
1564 MODULE_VERSION(HECI_DRIVER_VERSION);