heci_main.c revision d3d50737e566cade9a08d73d2af95105ac7cd960
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Part of Intel(R) Manageability Engine Interface Linux driver
*
* Copyright (c) 2003 - 2008 Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*
*/
#pragma ident "@(#)heci_main.c 1.7 08/03/07 SMI"
#include <sys/types.h>
#include <sys/note.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/devops.h>
#include <sys/instance.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/sunddi.h>
#include <sys/file.h>
#include <sys/priv.h>
#include <sys/systm.h>
#include <sys/mkdev.h>
#include <sys/list.h>
#include <sys/pci.h>
#include "heci_data_structures.h"
#include "heci.h"
#include "heci_interface.h"
#define MAJOR_VERSION 5
#define MINOR_VERSION 0
#define QUICK_FIX_NUMBER 0
#define VER_BUILD 30
#define str(s) name(s)
#define name(s) #s
#define HECI_DRIVER_VERSION str(MAJOR_VERSION) "." str(MINOR_VERSION) \
"." str(QUICK_FIX_NUMBER) "." str(VER_BUILD)
#define HECI_READ_TIMEOUT 45
#define HECI_DRIVER_NAME "heci"
/*
* heci driver strings
*/
char heci_driver_name[] = HECI_DRIVER_NAME;
char heci_driver_string[] = "Intel(R) Management Engine Interface";
char heci_driver_version[] = HECI_DRIVER_VERSION;
char heci_copyright[] = "Copyright (c) 2003 - 2008 Intel Corporation.";
void * heci_soft_state_p = NULL;
#ifdef DEBUG
int heci_debug = 0;
#endif
/*
* Local Function Prototypes
*/
static int heci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int heci_initialize(dev_info_t *dip, struct iamt_heci_device *device);
static int heci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd,
void *arg, void **result);
static int heci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int heci_quiesce(dev_info_t *dip);
static int heci_open(dev_t *devp, int flags, int otyp, cred_t *credp);
static int heci_close(dev_t dev, int flag, int otyp, struct cred *cred);
static int heci_read(dev_t dev, struct uio *uio_p, cred_t *cred_p);
static int heci_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
cred_t *cr, int *rval);
static int heci_write(dev_t dev, struct uio *uio_p, struct cred *cred);
static int heci_poll(dev_t dev, short events, int anyyet,
short *reventsp, struct pollhead **phpp);
static struct heci_cb_private *find_read_list_entry(
struct iamt_heci_device *dev,
struct heci_file_private *file_ext);
static inline int heci_fe_same_id(struct heci_file_private *fe1,
struct heci_file_private *fe2);
static void heci_resume(dev_info_t *dip);
static int heci_suspend(dev_info_t *dip);
static uint16_t g_sus_wd_timeout;
static struct cb_ops heci_cb_ops = {
heci_open, /* open */
heci_close, /* close */
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
heci_read, /* read */
heci_write, /* write */
heci_ioctl, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
heci_poll, /* poll */
ddi_prop_op, /* cb_prop op */
NULL, /* stream tab */
D_MP /* Driver Compatability Flags */
};
static struct dev_ops heci_dev_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt */
heci_getinfo, /* get_dev_info */
nulldev, /* identify */
nulldev, /* probe */
heci_attach, /* attach */
heci_detach, /* detach */
nodev, /* reset */
&heci_cb_ops, /* Driver Ops */
(struct bus_ops *)NULL, /* Bus Operations */
NULL, /* power */
heci_quiesce /* devo_quiesce */
};
/*
* Module linkage information for the kernel
*/
static struct modldrv modldrv = {
&mod_driverops, /* Type of Module = Driver */
heci_driver_string, /* Driver Identifier string. */
&heci_dev_ops, /* Driver Ops. */
};
static struct modlinkage modlinkage = {
MODREV_1, (void *)&modldrv, NULL
};
/*
* Module Initialization functions.
*/
int
_init(void)
{
int stat;
/* Allocate soft state */
if ((stat = ddi_soft_state_init(&heci_soft_state_p,
sizeof (struct iamt_heci_device), 1)) != DDI_SUCCESS) {
return (stat);
}
if ((stat = mod_install(&modlinkage)) != 0)
ddi_soft_state_fini(&heci_soft_state_p);
return (stat);
}
int
_info(struct modinfo *infop)
{
return (mod_info(&modlinkage, infop));
}
int
_fini(void)
{
int stat;
if ((stat = mod_remove(&modlinkage)) != 0)
return (stat);
ddi_soft_state_fini(&heci_soft_state_p);
return (stat);
}
/*
* heci_attach - Driver Attach Routine
*/
static int
heci_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
int instance, status;
struct iamt_heci_device *device;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
heci_resume(dip);
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
DBG("%s - version %s\n", heci_driver_string, heci_driver_version);
DBG("%s\n", heci_copyright);
instance = ddi_get_instance(dip); /* find out which unit */
status = ddi_soft_state_zalloc(heci_soft_state_p, instance);
if (status != DDI_SUCCESS)
return (DDI_FAILURE);
device = ddi_get_soft_state(heci_soft_state_p, instance);
ASSERT(device != NULL); /* can't fail - we only just allocated it */
device->dip = dip;
status = heci_initialize(dip, device);
if (status != DDI_SUCCESS) {
ddi_soft_state_free(heci_soft_state_p, instance);
return (DDI_FAILURE);
}
status = ddi_create_minor_node(dip, "AMT", S_IFCHR,
MAKE_MINOR_NUM(HECI_MINOR_NUMBER, instance),
DDI_PSEUDO, 0);
if (status != DDI_SUCCESS) {
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(heci_soft_state_p, instance);
return (DDI_FAILURE);
}
return (status);
}
/*
* heci_probe - Device Initialization Routine
*/
static int
heci_initialize(dev_info_t *dip, struct iamt_heci_device *device)
{
int err;
ddi_device_acc_attr_t attr;
err = ddi_get_iblock_cookie(dip, 0, &device->sc_iblk);
if (err != DDI_SUCCESS) {
cmn_err(CE_WARN, "heci_probe():"
" ddi_get_iblock_cookie() failed\n");
goto end;
}
/* initializes the heci device structure */
init_heci_device(dip, device);
attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
if (ddi_regs_map_setup(dip, 1, (caddr_t *)&device->mem_addr, 0, 0,
&attr, &device->io_handle) != DDI_SUCCESS) {
cmn_err(CE_WARN, "heci%d: unable to map PCI regs\n",
ddi_get_instance(dip));
goto fini_heci_device;
}
err = ddi_add_intr(dip, 0, &device->sc_iblk, NULL,
heci_isr_interrupt, (caddr_t)device);
if (err != DDI_SUCCESS) {
cmn_err(CE_WARN, "heci_probe(): ddi_add_intr() failed\n");
goto unmap_memory;
}
if (heci_hw_init(device)) {
cmn_err(CE_WARN, "init hw failure.\n");
err = -ENODEV;
goto release_irq;
}
(void) heci_initialize_clients(device);
if (device->heci_state != HECI_ENABLED) {
err = -ENODEV;
goto release_hw;
}
if (device->wd_timeout)
device->wd_timer = timeout(heci_wd_timer, device, 1);
DBG("heci driver initialization successful.\n");
return (0);
release_hw:
/* disable interrupts */
device->host_hw_state = read_heci_register(device, H_CSR);
heci_csr_disable_interrupts(device);
release_irq:
ddi_remove_intr(dip, 0, device->sc_iblk);
unmap_memory:
if (device->mem_addr)
ddi_regs_map_free(&device->io_handle);
fini_heci_device:
fini_heci_device(device);
end:
cmn_err(CE_WARN, "heci driver initialization failed.\n");
return (err);
}
void
heci_destroy_locks(struct iamt_heci_device *device_object)
{
mutex_destroy(&device_object->iamthif_file_ext.file_lock);
mutex_destroy(&device_object->iamthif_file_ext.read_io_lock);
mutex_destroy(&device_object->iamthif_file_ext.write_io_lock);
mutex_destroy(&device_object->wd_file_ext.file_lock);
mutex_destroy(&device_object->wd_file_ext.read_io_lock);
mutex_destroy(&device_object->wd_file_ext.write_io_lock);
mutex_destroy(&device_object->device_lock);
cv_destroy(&device_object->iamthif_file_ext.rx_wait);
cv_destroy(&device_object->wd_file_ext.rx_wait);
cv_destroy(&device_object->wait_recvd_msg);
cv_destroy(&device_object->wait_stop_wd);
}
/*
* heci_remove - Device Removal Routine
*
* @pdev: PCI device information struct
*
* heci_remove is called by the PCI subsystem to alert the driver
* that it should release a PCI device.
*/
static int
heci_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
struct iamt_heci_device *dev;
int err;
dev = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
ASSERT(dev != NULL);
switch (cmd) {
case DDI_SUSPEND:
err = heci_suspend(dip);
if (err)
return (DDI_FAILURE);
else
return (DDI_SUCCESS);
case DDI_DETACH:
break;
default:
return (DDI_FAILURE);
}
if (dev->wd_timer)
(void) untimeout(dev->wd_timer);
mutex_enter(&dev->device_lock);
if (dev->wd_file_ext.state == HECI_FILE_CONNECTED &&
dev->wd_timeout) {
dev->wd_timeout = 0;
dev->wd_due_counter = 0;
(void) memcpy(dev->wd_data, stop_wd_params,
HECI_WD_PARAMS_SIZE);
dev->stop = 1;
if (dev->host_buffer_is_empty &&
flow_ctrl_creds(dev, &dev->wd_file_ext)) {
dev->host_buffer_is_empty = 0;
if (!heci_send_wd(dev)) {
DBG("send stop WD failed\n");
} else
flow_ctrl_reduce(dev, &dev->wd_file_ext);
dev->wd_pending = 0;
} else
dev->wd_pending = 1;
dev->wd_stoped = 0;
err = 0;
while (!dev->wd_stoped && err != -1) {
err = cv_reltimedwait(&dev->wait_stop_wd,
&dev->device_lock, 10*HZ, TR_CLOCK_TICK);
}
if (!dev->wd_stoped) {
DBG("stop wd failed to complete.\n");
} else {
DBG("stop wd complete.\n");
}
}
mutex_exit(&dev->device_lock);
if (dev->iamthif_file_ext.state == HECI_FILE_CONNECTED) {
dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTING;
(void) heci_disconnect_host_client(dev,
&dev->iamthif_file_ext);
}
if (dev->wd_file_ext.state == HECI_FILE_CONNECTED) {
dev->wd_file_ext.state = HECI_FILE_DISCONNECTING;
(void) heci_disconnect_host_client(dev,
&dev->wd_file_ext);
}
/* remove entry if already in list */
DBG("list del iamthif and wd file list.\n");
heci_remove_client_from_file_list(dev, dev->wd_file_ext.
host_client_id);
heci_remove_client_from_file_list(dev,
dev->iamthif_file_ext.host_client_id);
dev->iamthif_current_cb = NULL;
dev->iamthif_file_ext.file = NULL;
/* disable interrupts */
heci_csr_disable_interrupts(dev);
ddi_remove_intr(dip, 0, dev->sc_iblk);
if (dev->work)
ddi_taskq_destroy(dev->work);
if (dev->reinit_tsk)
ddi_taskq_destroy(dev->reinit_tsk);
if (dev->mem_addr)
ddi_regs_map_free(&dev->io_handle);
if (dev->me_clients && dev->num_heci_me_clients > 0) {
kmem_free(dev->me_clients, sizeof (struct heci_me_client) *
dev->num_heci_me_clients);
}
dev->num_heci_me_clients = 0;
heci_destroy_locks(dev);
ddi_remove_minor_node(dip, NULL);
ddi_soft_state_free(heci_soft_state_p, ddi_get_instance(dip));
return (DDI_SUCCESS);
}
static int
heci_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, void **result)
{
int error = DDI_SUCCESS;
struct iamt_heci_device *device;
int minor, instance;
_NOTE(ARGUNUSED(dip))
switch (cmd) {
case DDI_INFO_DEVT2DEVINFO:
minor = getminor((dev_t)arg);
instance = HECI_MINOR_TO_INSTANCE(minor);
if (!(device = ddi_get_soft_state(heci_soft_state_p, instance)))
*result = NULL;
else
*result = device->dip;
break;
case DDI_INFO_DEVT2INSTANCE:
minor = getminor((dev_t)arg);
instance = HECI_MINOR_TO_INSTANCE(minor);
*result = (void *)((long)minor);
break;
default:
error = DDI_FAILURE;
break;
}
return (error);
}
/*
* heci_clear_list - remove all callbacks associated with file
* from heci_cb_list
*
* @file: file information struct
* @heci_cb_list: callbacks list
*
* heci_clear_list is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
* @return 1 if callback removed from the list, 0 otherwise
*/
static int
heci_clear_list(struct iamt_heci_device *dev,
struct heci_file *file, struct list_node *heci_cb_list)
{
struct heci_cb_private *priv_cb_pos = NULL;
struct heci_cb_private *priv_cb_next = NULL;
struct heci_file *file_temp;
int rets = 0;
/* list all list member */
list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
heci_cb_list, cb_list, struct heci_cb_private) {
file_temp = (struct heci_file *)priv_cb_pos->file_object;
/* check if list member associated with a file */
if (file_temp == file) {
/* remove member from the list */
list_del(&priv_cb_pos->cb_list);
/* check if cb equal to current iamthif cb */
if (dev->iamthif_current_cb == priv_cb_pos) {
dev->iamthif_current_cb = NULL;
/* send flow control to iamthif client */
if (!heci_send_flow_control(dev,
&dev->iamthif_file_ext)) {
DBG("sending flow control failed\n");
}
}
/* free all allocated buffers */
heci_free_cb_private(priv_cb_pos);
rets = 1;
}
}
return (rets);
}
/*
* heci_clear_lists - remove all callbacks associated with file
*
* @dev: device information struct
* @file: file information struct
*
* heci_clear_lists is called to clear resources associated with file
* when application calls close function or Ctrl-C was pressed
*
* @return 1 if callback removed from the list, 0 otherwise
*/
static int
heci_clear_lists(struct iamt_heci_device *dev, struct heci_file *file)
{
int rets = 0;
/* remove callbacks associated with a file */
(void) heci_clear_list(dev, file, &dev->pthi_cmd_list.heci_cb.cb_list);
if (heci_clear_list(dev, file,
&dev->pthi_read_complete_list.heci_cb.cb_list))
rets = 1;
(void) heci_clear_list(dev, file, &dev->ctrl_rd_list.heci_cb.cb_list);
if (heci_clear_list(dev, file, &dev->ctrl_wr_list.heci_cb.cb_list))
rets = 1;
if (heci_clear_list(dev, file,
&dev->write_waiting_list.heci_cb.cb_list))
rets = 1;
if (heci_clear_list(dev, file, &dev->write_list.heci_cb.cb_list))
rets = 1;
/* check if iamthif_current_cb not NULL */
if (dev->iamthif_current_cb && (!rets)) {
/* check file and iamthif current cb association */
if (dev->iamthif_current_cb->file_object == file) {
/* remove cb */
heci_free_cb_private(dev->iamthif_current_cb);
dev->iamthif_current_cb = NULL;
rets = 1;
}
}
return (rets);
}
/*
* heci_open - the open function
*/
static int
heci_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
struct iamt_heci_device *dev;
struct heci_file_private *file_ext = NULL;
int minor, if_num, instance;
struct heci_file *file;
_NOTE(ARGUNUSED(flags, credp))
minor = getminor(*devp);
DBG("heci_open: enter...\n");
/*
* Make sure the open is for the right file type.
*/
if (otyp != OTYP_CHR)
return (EINVAL);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
dev = ddi_get_soft_state(heci_soft_state_p, instance);
if ((if_num < HECI_MINOR_NUMBER) || (!dev))
return (-ENODEV);
file_ext = heci_alloc_file_private(NULL);
if (file_ext == NULL)
return (-ENOMEM);
mutex_enter(&dev->device_lock);
if (dev->heci_state != HECI_ENABLED) {
mutex_exit(&dev->device_lock);
kmem_free(file_ext, sizeof (struct heci_file_private));
file_ext = NULL;
return (-ENODEV);
}
if (dev->open_handle_count >= HECI_MAX_OPEN_HANDLE_COUNT) {
mutex_exit(&dev->device_lock);
kmem_free(file_ext, sizeof (struct heci_file_private));
file_ext = NULL;
return (-ENFILE);
}
dev->open_handle_count++;
list_add_tail(&file_ext->link, &dev->file_list);
while ((dev->heci_host_clients[dev->current_host_client_id / 8]
& (1 << (dev->current_host_client_id % 8))) != 0) {
dev->current_host_client_id++;
dev->current_host_client_id %= HECI_MAX_OPEN_HANDLE_COUNT;
DBG("current_host_client_id = %d\n",
dev->current_host_client_id);
DBG("dev->open_handle_count = %lu\n",
dev->open_handle_count);
}
DBG("current_host_client_id = %d\n", dev->current_host_client_id);
file_ext->host_client_id = dev->current_host_client_id;
*devp = makedevice(getmajor(*devp),
MAKE_MINOR_NUM(dev->current_host_client_id, instance));
file = &dev->files[dev->current_host_client_id];
dev->heci_host_clients[file_ext->host_client_id / 8] |=
(1 << (file_ext->host_client_id % 8));
mutex_exit(&dev->device_lock);
mutex_enter(&file_ext->file_lock);
file_ext->state = HECI_FILE_INITIALIZING;
file_ext->sm_state = 0;
file->private_data = file_ext;
mutex_exit(&file_ext->file_lock);
return (0);
}
/*
* heci_close - the close function
*/
static int
heci_close(dev_t devt, int flag, int otyp, struct cred *cred)
{
int rets = 0;
int minor, if_num, instance;
struct heci_file_private *file_ext;
struct heci_cb_private *priv_cb = NULL;
struct iamt_heci_device *dev;
struct heci_file *file;
_NOTE(ARGUNUSED(flag, otyp, cred))
minor = getminor(devt);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
dev = ddi_get_soft_state(heci_soft_state_p, instance);
file = &dev->files[if_num];
file_ext = file->private_data;
if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
return (-ENODEV);
if (file_ext != &dev->iamthif_file_ext) {
mutex_enter(&file_ext->file_lock);
if (file_ext->state == HECI_FILE_CONNECTED) {
file_ext->state = HECI_FILE_DISCONNECTING;
mutex_exit(&file_ext->file_lock);
DBG("disconnecting client host client = %d, "
"ME client = %d\n",
file_ext->host_client_id,
file_ext->me_client_id);
rets = heci_disconnect_host_client(dev, file_ext);
mutex_enter(&file_ext->file_lock);
}
mutex_enter(&dev->device_lock);
heci_flush_queues(dev, file_ext);
DBG("remove client host client = %d, ME client = %d\n",
file_ext->host_client_id,
file_ext->me_client_id);
if (dev->open_handle_count > 0) {
dev->heci_host_clients[file_ext->host_client_id / 8] &=
~(1 << (file_ext->host_client_id % 8));
dev->open_handle_count--;
}
heci_remove_client_from_file_list(dev,
file_ext->host_client_id);
/* free read cb */
if (file_ext->read_cb != NULL) {
priv_cb = find_read_list_entry(dev, file_ext);
/* Remove entry from read list */
if (priv_cb != NULL)
list_del(&priv_cb->cb_list);
priv_cb = file_ext->read_cb;
file_ext->read_cb = NULL;
}
mutex_exit(&dev->device_lock);
file->private_data = NULL;
mutex_exit(&file_ext->file_lock);
if (priv_cb != NULL)
heci_free_cb_private(priv_cb);
heci_free_file_private(file_ext);
} else {
mutex_enter(&dev->device_lock);
if (dev->open_handle_count > 0)
dev->open_handle_count--;
if (dev->iamthif_file_object == file &&
dev->iamthif_state != HECI_IAMTHIF_IDLE) {
DBG("pthi canceled iamthif state %d\n",
dev->iamthif_state);
dev->iamthif_canceled = 1;
if (dev->iamthif_state == HECI_IAMTHIF_READ_COMPLETE) {
DBG("run next pthi iamthif cb\n");
run_next_iamthif_cmd(dev);
}
}
if (heci_clear_lists(dev, file))
dev->iamthif_state = HECI_IAMTHIF_IDLE;
mutex_exit(&dev->device_lock);
}
return (rets);
}
static struct heci_cb_private *
find_read_list_entry(struct iamt_heci_device *dev,
struct heci_file_private *file_ext)
{
struct heci_cb_private *priv_cb_pos = NULL;
struct heci_cb_private *priv_cb_next = NULL;
struct heci_file_private *file_ext_list_temp;
if (dev->read_list.status == 0 &&
!list_empty(&dev->read_list.heci_cb.cb_list)) {
DBG("remove read_list CB \n");
list_for_each_entry_safe(priv_cb_pos,
priv_cb_next,
&dev->read_list.heci_cb.cb_list, cb_list,
struct heci_cb_private) {
file_ext_list_temp = (struct heci_file_private *)
priv_cb_pos->file_private;
if ((file_ext_list_temp != NULL) &&
heci_fe_same_id(file_ext, file_ext_list_temp))
return (priv_cb_pos);
}
}
return (NULL);
}
/*
* heci_read - the read client message function.
*/
static int
heci_read(dev_t devt, struct uio *uio_p, cred_t *cred_p)
{
int i;
int rets = 0;
size_t length;
struct heci_file *file;
struct heci_file_private *file_ext;
struct heci_cb_private *priv_cb_pos = NULL;
int instance, minor, if_num, err;
struct heci_cb_private *priv_cb = NULL;
struct iamt_heci_device *dev;
_NOTE(ARGUNUSED(cred_p))
minor = getminor(devt);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
dev = ddi_get_soft_state(heci_soft_state_p, instance);
file = &dev->files[if_num];
file_ext = file->private_data;
if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
return (-ENODEV);
mutex_enter(&dev->device_lock);
if (dev->heci_state != HECI_ENABLED) {
mutex_exit(&dev->device_lock);
return (-ENODEV);
}
mutex_exit(&dev->device_lock);
if (!file_ext)
return (-ENODEV);
mutex_enter(&file_ext->file_lock);
if ((file_ext->sm_state & HECI_WD_STATE_INDEPENDENCE_MSG_SENT) == 0) {
mutex_exit(&file_ext->file_lock);
/* Do not allow to read watchdog client */
for (i = 0; i < dev->num_heci_me_clients; i++) {
if (memcmp(&heci_wd_guid,
&dev->me_clients[i].props.protocol_name,
sizeof (struct guid)) == 0) {
if (file_ext->me_client_id ==
dev->me_clients[i].client_id)
return (-EBADF);
}
}
} else {
file_ext->sm_state &= ~HECI_WD_STATE_INDEPENDENCE_MSG_SENT;
mutex_exit(&file_ext->file_lock);
}
if (file_ext == &dev->iamthif_file_ext) {
rets = pthi_read(dev, if_num, file, uio_p);
goto out;
}
if (file_ext->read_cb &&
file_ext->read_cb->information > UIO_OFFSET(uio_p)) {
priv_cb = file_ext->read_cb;
goto copy_buffer;
} else if (file_ext->read_cb && file_ext->read_cb->information > 0 &&
file_ext->read_cb->information <= UIO_OFFSET(uio_p)) {
priv_cb = file_ext->read_cb;
rets = 0;
goto free;
} else if (
(!file_ext->read_cb || file_ext->read_cb->information == 0) &&
UIO_OFFSET(uio_p) > 0) {
/* Offset needs to be cleaned for contingous reads */
UIO_OFFSET(uio_p) = 0;
rets = 0;
goto out;
}
mutex_enter(&file_ext->read_io_lock);
err = heci_start_read(dev, if_num, file_ext);
if (err != 0 && err != -EBUSY) {
DBG("heci start read failure with status = %d\n", err);
mutex_exit(&file_ext->read_io_lock);
rets = err;
goto out;
}
while (HECI_READ_COMPLETE != file_ext->reading_state &&
HECI_FILE_INITIALIZING != file_ext->state &&
HECI_FILE_DISCONNECTED != file_ext->state &&
HECI_FILE_DISCONNECTING != file_ext->state) {
mutex_exit(&file_ext->read_io_lock);
mutex_enter(&dev->device_lock);
if (cv_wait_sig(&file_ext->rx_wait, &dev->device_lock) == 0) {
mutex_exit(&dev->device_lock);
priv_cb = file_ext->read_cb;
rets = -EINTR;
goto free;
}
mutex_exit(&dev->device_lock);
if (HECI_FILE_INITIALIZING == file_ext->state ||
HECI_FILE_DISCONNECTED == file_ext->state ||
HECI_FILE_DISCONNECTING == file_ext->state) {
rets = -EBUSY;
goto out;
}
mutex_enter(&file_ext->read_io_lock);
}
priv_cb = file_ext->read_cb;
if (!priv_cb) {
mutex_exit(&file_ext->read_io_lock);
return (-ENODEV);
}
if (file_ext->reading_state != HECI_READ_COMPLETE) {
mutex_exit(&file_ext->read_io_lock);
return (0);
}
mutex_exit(&file_ext->read_io_lock);
/* now copy the data to user space */
copy_buffer:
DBG("priv_cb->response_buffer size - %d\n",
priv_cb->response_buffer.size);
DBG("priv_cb->information - %lu\n", priv_cb->information);
if (uio_p->uio_resid == 0 || uio_p->uio_resid < priv_cb->information) {
rets = -EMSGSIZE;
goto free;
}
length = (uio_p->uio_resid <
(priv_cb->information - uio_p->uio_offset) ?
uio_p->uio_resid : (priv_cb->information - uio_p->uio_offset));
if (uiomove(priv_cb->response_buffer.data,
length, UIO_READ, uio_p)) {
rets = -EFAULT;
goto free;
}
else
rets = 0;
free:
mutex_enter(&dev->device_lock);
priv_cb_pos = find_read_list_entry(dev, file_ext);
/* Remove entry from read list */
if (priv_cb_pos != NULL)
list_del(&priv_cb_pos->cb_list);
mutex_exit(&dev->device_lock);
heci_free_cb_private(priv_cb);
mutex_enter(&file_ext->read_io_lock);
file_ext->reading_state = HECI_IDLE;
file_ext->read_cb = NULL;
file_ext->read_pending = 0;
mutex_exit(&file_ext->read_io_lock);
out: DBG("end heci read rets= %d\n", rets);
return (rets);
}
/*
* heci_write - the write function.
*/
static int
heci_write(dev_t devt, struct uio *uio_p, struct cred *cred)
{
int rets = 0;
uint8_t i;
size_t length;
struct heci_file_private *file_ext;
struct heci_cb_private *priv_write_cb = NULL;
struct heci_msg_hdr heci_hdr;
struct iamt_heci_device *dev;
unsigned long currtime = ddi_get_time();
int instance, minor, if_num, err;
struct heci_file *file;
_NOTE(ARGUNUSED(cred))
DBG("heci_write enter...\n");
minor = getminor(devt);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
dev = ddi_get_soft_state(heci_soft_state_p, instance);
file = &dev->files[if_num];
file_ext = file->private_data;
if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
return (-ENODEV);
mutex_enter(&dev->device_lock);
if (dev->heci_state != HECI_ENABLED) {
mutex_exit(&dev->device_lock);
return (-ENODEV);
}
if (file_ext == &dev->iamthif_file_ext) {
priv_write_cb = find_pthi_read_list_entry(dev, file);
if ((priv_write_cb != NULL) &&
(((currtime - priv_write_cb->read_time) >
IAMTHIF_READ_TIMER) ||
(file_ext->reading_state == HECI_READ_COMPLETE))) {
UIO_OFFSET(uio_p) = 0;
list_del(&priv_write_cb->cb_list);
heci_free_cb_private(priv_write_cb);
priv_write_cb = NULL;
}
}
/* free entry used in read */
if (file_ext->reading_state == HECI_READ_COMPLETE) {
UIO_OFFSET(uio_p) = 0;
priv_write_cb = find_read_list_entry(dev, file_ext);
if (priv_write_cb != NULL) {
list_del(&priv_write_cb->cb_list);
heci_free_cb_private(priv_write_cb);
priv_write_cb = NULL;
mutex_enter(&file_ext->read_io_lock);
file_ext->reading_state = HECI_IDLE;
file_ext->read_cb = NULL;
file_ext->read_pending = 0;
mutex_exit(&file_ext->read_io_lock);
}
} else if (file_ext->reading_state == HECI_IDLE &&
file_ext->read_pending == 0)
UIO_OFFSET(uio_p) = 0;
mutex_exit(&dev->device_lock);
priv_write_cb = kmem_zalloc(sizeof (struct heci_cb_private), KM_SLEEP);
if (!priv_write_cb)
return (-ENOMEM);
priv_write_cb->file_object = file;
priv_write_cb->file_private = file_ext;
priv_write_cb->request_buffer.data =
kmem_zalloc(uio_p->uio_resid, KM_SLEEP);
if (!priv_write_cb->request_buffer.data) {
kmem_free(priv_write_cb, sizeof (struct heci_cb_private));
return (-ENOMEM);
}
length = (int)uio_p->uio_resid;
DBG("length =%d\n", (int)length);
err = uiomove(priv_write_cb->request_buffer.data,
length, UIO_WRITE, uio_p);
if (err) {
rets = err;
goto fail;
}
#define UBUFF UIO_BUFF(uio_p)
mutex_enter(&file_ext->file_lock);
file_ext->sm_state = 0;
if ((length == 4) &&
((memcmp(heci_wd_state_independence_msg[0], UBUFF, 4) == 0) ||
(memcmp(heci_wd_state_independence_msg[1], UBUFF, 4) == 0) ||
(memcmp(heci_wd_state_independence_msg[2], UBUFF, 4) == 0)))
file_ext->sm_state |= HECI_WD_STATE_INDEPENDENCE_MSG_SENT;
mutex_exit(&file_ext->file_lock);
LIST_INIT_HEAD(&priv_write_cb->cb_list);
if (file_ext == &dev->iamthif_file_ext) {
priv_write_cb->response_buffer.data =
kmem_zalloc(IAMTHIF_MTU, KM_SLEEP);
if (!priv_write_cb->response_buffer.data) {
rets = -ENOMEM;
goto fail;
}
mutex_enter(&dev->device_lock);
if (dev->heci_state != HECI_ENABLED) {
mutex_exit(&dev->device_lock);
rets = -ENODEV;
goto fail;
}
for (i = 0; i < dev->num_heci_me_clients; i++) {
if (dev->me_clients[i].client_id ==
dev->iamthif_file_ext.me_client_id)
break;
}
ASSERT(dev->me_clients[i].client_id == file_ext->me_client_id);
if ((i == dev->num_heci_me_clients) ||
(dev->me_clients[i].client_id !=
dev->iamthif_file_ext.me_client_id)) {
mutex_exit(&dev->device_lock);
rets = -ENODEV;
goto fail;
} else if ((length >
dev->me_clients[i].props.max_msg_length) ||
(length == 0)) {
mutex_exit(&dev->device_lock);
rets = -EMSGSIZE;
goto fail;
}
priv_write_cb->response_buffer.size = IAMTHIF_MTU;
priv_write_cb->major_file_operations = HECI_IOCTL;
priv_write_cb->information = 0;
priv_write_cb->request_buffer.size = (uint32_t)length;
if (dev->iamthif_file_ext.state != HECI_FILE_CONNECTED) {
mutex_exit(&dev->device_lock);
rets = -ENODEV;
goto fail;
}
if (!list_empty(&dev->pthi_cmd_list.heci_cb.cb_list) ||
dev->iamthif_state != HECI_IAMTHIF_IDLE) {
DBG("pthi_state = %d\n", (int)dev->iamthif_state);
DBG("add PTHI cb to pthi cmd waiting list\n");
list_add_tail(&priv_write_cb->cb_list,
&dev->pthi_cmd_list.heci_cb.cb_list);
rets = 0; /* length; */
} else {
DBG("call pthi write\n");
rets = pthi_write(dev, priv_write_cb);
if (rets != 0) {
DBG("pthi write failed with status = %d\n",
rets);
mutex_exit(&dev->device_lock);
goto fail;
}
rets = 0; /* length; */
}
mutex_exit(&dev->device_lock);
return (rets);
}
priv_write_cb->major_file_operations = HECI_WRITE;
/* make sure information is zero before we start */
priv_write_cb->information = 0;
priv_write_cb->request_buffer.size = (uint32_t)length;
mutex_enter(&dev->device_lock);
mutex_enter(&file_ext->write_io_lock);
DBG("host client = %d, ME client = %d\n",
file_ext->host_client_id, file_ext->me_client_id);
if (file_ext->state != HECI_FILE_CONNECTED) {
rets = -ENODEV;
DBG("host client = %d, is not connected to ME client = %d",
file_ext->host_client_id,
file_ext->me_client_id);
goto unlock;
}
for (i = 0; i < dev->num_heci_me_clients; i++) {
if (dev->me_clients[i].client_id ==
file_ext->me_client_id)
break;
}
ASSERT(dev->me_clients[i].client_id == file_ext->me_client_id);
if (i == dev->num_heci_me_clients) {
rets = -ENODEV;
goto unlock;
}
if (length > dev->me_clients[i].props.max_msg_length || length == 0) {
rets = -EINVAL;
goto unlock;
}
priv_write_cb->file_private = file_ext;
if (flow_ctrl_creds(dev, file_ext) &&
dev->host_buffer_is_empty) {
dev->host_buffer_is_empty = 0;
if (length > ((((dev->host_hw_state & H_CBD) >> 24) *
sizeof (uint32_t)) - sizeof (struct heci_msg_hdr))) {
heci_hdr.length =
(((dev->host_hw_state & H_CBD) >> 24) *
sizeof (uint32_t)) -
sizeof (struct heci_msg_hdr);
heci_hdr.msg_complete = 0;
} else {
heci_hdr.length = (uint32_t)length;
heci_hdr.msg_complete = 1;
}
heci_hdr.host_addr = file_ext->host_client_id;
heci_hdr.me_addr = file_ext->me_client_id;
heci_hdr.reserved = 0;
DBG("call heci_write_message header=%08x.\n",
*((uint32_t *)(void *)&heci_hdr));
/* protect heci low level write */
if (!heci_write_message(dev, &heci_hdr,
(unsigned char *)(priv_write_cb->request_buffer.data),
heci_hdr.length)) {
mutex_exit(&file_ext->write_io_lock);
mutex_exit(&dev->device_lock);
heci_free_cb_private(priv_write_cb);
rets = -ENODEV;
priv_write_cb->information = 0;
return (rets);
}
file_ext->writing_state = HECI_WRITING;
priv_write_cb->information = heci_hdr.length;
if (heci_hdr.msg_complete) {
flow_ctrl_reduce(dev, file_ext);
list_add_tail(&priv_write_cb->cb_list,
&dev->write_waiting_list.heci_cb.cb_list);
} else {
list_add_tail(&priv_write_cb->cb_list,
&dev->write_list.heci_cb.cb_list);
}
} else {
priv_write_cb->information = 0;
file_ext->writing_state = HECI_WRITING;
list_add_tail(&priv_write_cb->cb_list,
&dev->write_list.heci_cb.cb_list);
}
mutex_exit(&file_ext->write_io_lock);
mutex_exit(&dev->device_lock);
return (0);
unlock:
mutex_exit(&file_ext->write_io_lock);
mutex_exit(&dev->device_lock);
fail:
heci_free_cb_private(priv_write_cb);
return (rets);
}
/*
* heci_ioctl - the IOCTL function
*/
static int
heci_ioctl(dev_t devt, int cmd, intptr_t arg, int mode, cred_t *cr, int *rval)
{
int rets = 0;
struct heci_file_private *file_ext;
/* in user space */
struct heci_message_data *u_msg = (struct heci_message_data *)arg;
struct heci_message_data k_msg; /* all in kernel on the stack */
struct iamt_heci_device *dev;
int instance, minor, if_num;
struct heci_file *file;
_NOTE(ARGUNUSED(cr, rval))
minor = getminor(devt);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
dev = ddi_get_soft_state(heci_soft_state_p, instance);
file = &dev->files[if_num];
file_ext = file->private_data;
if ((if_num < HECI_MINOR_NUMBER) || (!dev) || (!file_ext))
return (-ENODEV);
mutex_enter(&dev->device_lock);
if (dev->heci_state != HECI_ENABLED) {
mutex_exit(&dev->device_lock);
return (-ENODEV);
}
mutex_exit(&dev->device_lock);
/* first copy from user all data needed */
if (ddi_copyin(u_msg, &k_msg, sizeof (k_msg), mode)) {
DBG("first copy from user all data needed filled\n");
return (-EFAULT);
}
#ifdef _LP64
if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
uint32_t addr32 = (uint32_t)(uint64_t)k_msg.data;
k_msg.data = (char *)(uint64_t)addr32;
DBG("IPL32: k_msg.data=%p\n", (void *)k_msg.data);
}
#endif
DBG("user message size is %d, cmd = 0x%x\n", k_msg.size, cmd);
switch (cmd) {
case IOCTL_HECI_GET_VERSION:
DBG(": IOCTL_HECI_GET_VERSION\n");
rets = heci_ioctl_get_version(dev, if_num, u_msg, k_msg,
file_ext, mode);
break;
case IOCTL_HECI_CONNECT_CLIENT:
DBG(": IOCTL_HECI_CONNECT_CLIENT.\n");
rets = heci_ioctl_connect_client(dev, if_num, u_msg, k_msg,
file, mode);
break;
case IOCTL_HECI_WD:
DBG(": IOCTL_HECI_WD.\n");
rets = heci_ioctl_wd(dev, if_num, k_msg, file_ext, mode);
break;
case IOCTL_HECI_BYPASS_WD:
DBG(": IOCTL_HECI_BYPASS_WD.\n");
rets = heci_ioctl_bypass_wd(dev, if_num, k_msg, file_ext, mode);
break;
default:
rets = -EINVAL;
break;
}
return (rets);
}
/*
* heci_poll - the poll function
*/
static int
heci_poll(dev_t devt, short events, int anyyet,
short *reventsp, struct pollhead **phpp)
{
struct heci_file *file;
struct heci_file_private *file_extension;
struct iamt_heci_device *device = NULL;
int instance, minor, if_num;
_NOTE(ARGUNUSED(events))
minor = getminor(devt);
instance = HECI_MINOR_TO_INSTANCE(minor);
if_num = HECI_MINOR_TO_IFNUM(minor);
device = ddi_get_soft_state(heci_soft_state_p, instance);
file = &device->files[if_num];
file_extension = file->private_data;
if ((if_num < HECI_MINOR_NUMBER) || (!device) || (!file_extension))
return (-ENODEV);
mutex_enter(&device->device_lock);
if (device->heci_state != HECI_ENABLED) {
mutex_exit(&device->device_lock);
return (-ENXIO);
}
mutex_exit(&device->device_lock);
if (file_extension == &device->iamthif_file_ext) {
mutex_enter(&device->iamthif_file_ext.file_lock);
if (device->iamthif_state == HECI_IAMTHIF_READ_COMPLETE &&
device->iamthif_file_object == file) {
*reventsp |= (POLLIN | POLLRDNORM);
mutex_enter(&device->device_lock);
DBG("heci_poll: run next pthi cb\n");
run_next_iamthif_cmd(device);
mutex_exit(&device->device_lock);
} else {
DBG("heci_poll: iamthif no event\n");
*reventsp = 0;
if (!anyyet)
*phpp = &device->iamthif_file_ext.pollwait;
}
mutex_exit(&device->iamthif_file_ext.file_lock);
} else {
mutex_enter(&file_extension->write_io_lock);
if (HECI_WRITE_COMPLETE == file_extension->writing_state) {
*reventsp |= (POLLIN | POLLRDNORM);
DBG("heci_poll: file_extension poll event\n");
} else {
DBG("heci_poll: file_extension no event\n");
*reventsp = 0;
if (!anyyet)
*phpp = &file_extension->tx_pollwait;
}
mutex_exit(&file_extension->write_io_lock);
}
return (0);
}
/*
* heci_fe_same_id - tell if file private data have same id
*
* @fe1: private data of 1. file object
* @fe2: private data of 2. file object
*
* @return !=0 - if ids are the same, 0 - if differ.
*/
static inline int heci_fe_same_id(struct heci_file_private *fe1,
struct heci_file_private *fe2)
{
return ((fe1->host_client_id == fe2->host_client_id) &&
(fe1->me_client_id == fe2->me_client_id));
}
/*
* Since the ME firmware won't reset itself during OS reboot, it's not enough
* to only disable interrupts in quiesce(), here we do a full hand-shake
* with the firmware.
*/
static int
heci_quiesce(dev_info_t *dip)
{
struct iamt_heci_device *dev;
int err;
dev = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
ASSERT(dev != NULL);
if (dev->wd_timer)
(void) untimeout(dev->wd_timer);
mutex_enter(&dev->device_lock);
if (dev->wd_file_ext.state == HECI_FILE_CONNECTED &&
dev->wd_timeout) {
dev->wd_timeout = 0;
dev->wd_due_counter = 0;
(void) memcpy(dev->wd_data, stop_wd_params,
HECI_WD_PARAMS_SIZE);
dev->stop = 1;
if (dev->host_buffer_is_empty &&
flow_ctrl_creds(dev, &dev->wd_file_ext)) {
dev->host_buffer_is_empty = 0;
if (!heci_send_wd(dev)) {
DBG("send stop WD failed\n");
} else
flow_ctrl_reduce(dev, &dev->wd_file_ext);
dev->wd_pending = 0;
} else
dev->wd_pending = 1;
dev->wd_stoped = 0;
err = 0;
while (!dev->wd_stoped && err != -1) {
err = cv_reltimedwait(&dev->wait_stop_wd,
&dev->device_lock, 10*HZ, TR_CLOCK_TICK);
}
if (!dev->wd_stoped) {
DBG("stop wd failed to complete.\n");
} else {
DBG("stop wd complete.\n");
}
}
mutex_exit(&dev->device_lock);
if (dev->iamthif_file_ext.state == HECI_FILE_CONNECTED) {
dev->iamthif_file_ext.state = HECI_FILE_DISCONNECTING;
(void) heci_disconnect_host_client(dev,
&dev->iamthif_file_ext);
}
if (dev->wd_file_ext.state == HECI_FILE_CONNECTED) {
dev->wd_file_ext.state = HECI_FILE_DISCONNECTING;
(void) heci_disconnect_host_client(dev,
&dev->wd_file_ext);
}
/* disable interrupts */
heci_csr_disable_interrupts(dev);
return (DDI_SUCCESS);
}
static int
heci_suspend(dev_info_t *dip)
{
struct iamt_heci_device *device;
int err = 0;
device = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
if (device->reinit_tsk)
ddi_taskq_wait(device->reinit_tsk);
/* Stop watchdog if exists */
if (device->wd_timer)
(void) untimeout(device->wd_timer);
mutex_enter(&device->device_lock);
if (device->wd_file_ext.state == HECI_FILE_CONNECTED &&
device->wd_timeout) {
g_sus_wd_timeout = device->wd_timeout;
device->wd_timeout = 0;
device->wd_due_counter = 0;
(void) memcpy(device->wd_data, stop_wd_params,
HECI_WD_PARAMS_SIZE);
device->stop = 1;
if (device->host_buffer_is_empty &&
flow_ctrl_creds(device, &device->wd_file_ext)) {
device->host_buffer_is_empty = 0;
if (!heci_send_wd(device)) {
DBG("send stop WD failed\n");
}
else
flow_ctrl_reduce(device, &device->wd_file_ext);
device->wd_pending = 0;
} else {
device->wd_pending = 1;
}
device->wd_stoped = 0;
err = 0;
while (!device->wd_stoped && err != -1) {
err = cv_reltimedwait(&device->wait_stop_wd,
&device->device_lock, 10*HZ, TR_CLOCK_TICK);
}
if (!device->wd_stoped) {
DBG("stop wd failed to complete.\n");
} else {
DBG("stop wd complete %d.\n", err);
err = 0;
}
}
/* Set new heci state */
if (device->heci_state == HECI_ENABLED ||
device->heci_state == HECI_RECOVERING_FROM_RESET) {
device->heci_state = HECI_POWER_DOWN;
heci_reset(device, 0);
}
/* Here interrupts are already disabled by heci_reset() */
mutex_exit(&device->device_lock);
return (err);
}
static void
heci_resume(dev_info_t *dip)
{
struct iamt_heci_device *device;
device = ddi_get_soft_state(heci_soft_state_p, ddi_get_instance(dip));
mutex_enter(&device->device_lock);
device->heci_state = HECI_POWER_UP;
heci_reset(device, 1);
mutex_exit(&device->device_lock);
/* Start watchdog if stopped in suspend */
if (g_sus_wd_timeout != 0) {
device->wd_timeout = g_sus_wd_timeout;
(void) memcpy(device->wd_data, start_wd_params,
HECI_WD_PARAMS_SIZE);
(void) memcpy(device->wd_data + HECI_WD_PARAMS_SIZE,
&device->wd_timeout, sizeof (uint16_t));
device->wd_due_counter = 1;
if (device->wd_timeout)
device->wd_timer = timeout(heci_wd_timer, device, 1);
g_sus_wd_timeout = 0;
}
}