mei: name space for mei device state

1. add MEI_DEV_ prefix for mei device state enums
2. rename mei_state to dev_state
3. add constant to string translation for debug purposes

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/misc/mei/init.c b/drivers/misc/mei/init.c
index 58b3bf47c8ebc68f255b4745c6281f6f967bfb63..cd6a7f1ff9160f8bfb3c5c3843ca84b7ac5e454f 100644 (file)
--- a/drivers/misc/mei/init.c
+++ b/drivers/misc/mei/init.c
@@ -24,6 +24,25 @@
 #include "interface.h"
 #include <linux/mei.h>
 
+const char *mei_dev_state_str(int state)
+{
+#define MEI_DEV_STATE(state) case MEI_DEV_##state: return #state
+       switch (state) {
+       MEI_DEV_STATE(INITIALIZING);
+       MEI_DEV_STATE(INIT_CLIENTS);
+       MEI_DEV_STATE(ENABLED);
+       MEI_DEV_STATE(RESETING);
+       MEI_DEV_STATE(DISABLED);
+       MEI_DEV_STATE(RECOVERING_FROM_RESET);
+       MEI_DEV_STATE(POWER_DOWN);
+       MEI_DEV_STATE(POWER_UP);
+       default:
+               return "unkown";
+       }
+#undef MEI_DEV_STATE
+}
+
+
 const uuid_le mei_amthi_guid  = UUID_LE(0x12f80028, 0xb4b7, 0x4b2d, 0xac,
                                                0xa8, 0x46, 0xe0, 0xff, 0x65,
                                                0x81, 0x4c);
@@ -123,7 +142,7 @@ struct mei_device *mei_device_init(struct pci_dev *pdev)
        mutex_init(&dev->device_lock);
        init_waitqueue_head(&dev->wait_recvd_msg);
        init_waitqueue_head(&dev->wait_stop_wd);
-       dev->mei_state = MEI_INITIALIZING;
+       dev->dev_state = MEI_DEV_INITIALIZING;
        dev->iamthif_state = MEI_IAMTHIF_IDLE;
        dev->wd_interface_reg = false;
 
@@ -182,7 +201,7 @@ int mei_hw_init(struct mei_device *dev)
        }
 
        if (err <= 0 && !dev->recvd_msg) {
-               dev->mei_state = MEI_DISABLED;
+               dev->dev_state = MEI_DEV_DISABLED;
                dev_dbg(&dev->pdev->dev,
                        "wait_event_interruptible_timeout failed"
                        "on wait for ME to turn on ME_RDY.\n");
@@ -192,7 +211,7 @@ int mei_hw_init(struct mei_device *dev)
 
        if (!(((dev->host_hw_state & H_RDY) == H_RDY) &&
              ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA))) {
-               dev->mei_state = MEI_DISABLED;
+               dev->dev_state = MEI_DEV_DISABLED;
                dev_dbg(&dev->pdev->dev,
                        "host_hw_state = 0x%08x, me_hw_state = 0x%08x.\n",
                        dev->host_hw_state, dev->me_hw_state);
@@ -258,15 +277,15 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
        struct mei_cl_cb *cb_next = NULL;
        bool unexpected;
 
-       if (dev->mei_state == MEI_RECOVERING_FROM_RESET) {
+       if (dev->dev_state == MEI_DEV_RECOVERING_FROM_RESET) {
                dev->need_reset = true;
                return;
        }
 
-       unexpected = (dev->mei_state != MEI_INITIALIZING &&
-                       dev->mei_state != MEI_DISABLED &&
-                       dev->mei_state != MEI_POWER_DOWN &&
-                       dev->mei_state != MEI_POWER_UP);
+       unexpected = (dev->dev_state != MEI_DEV_INITIALIZING &&
+                       dev->dev_state != MEI_DEV_DISABLED &&
+                       dev->dev_state != MEI_DEV_POWER_DOWN &&
+                       dev->dev_state != MEI_DEV_POWER_UP);
 
        dev->host_hw_state = mei_hcsr_read(dev);
 
@@ -285,10 +304,10 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
 
        dev->need_reset = false;
 
-       if (dev->mei_state != MEI_INITIALIZING) {
-               if (dev->mei_state != MEI_DISABLED &&
-                   dev->mei_state != MEI_POWER_DOWN)
-                       dev->mei_state = MEI_RESETING;
+       if (dev->dev_state != MEI_DEV_INITIALIZING) {
+               if (dev->dev_state != MEI_DEV_DISABLED &&
+                   dev->dev_state != MEI_DEV_POWER_DOWN)
+                       dev->dev_state = MEI_DEV_RESETING;
 
                list_for_each_entry_safe(cl_pos,
                                cl_next, &dev->file_list, link) {
@@ -322,7 +341,8 @@ void mei_reset(struct mei_device *dev, int interrupts_enabled)
            dev->host_hw_state, dev->me_hw_state);
 
        if (unexpected)
-               dev_warn(&dev->pdev->dev, "unexpected reset.\n");
+               dev_warn(&dev->pdev->dev, "unexpected reset: dev_state = %s\n",
+                        mei_dev_state_str(dev->dev_state));
 
        /* Wake up all readings so they can be interrupted */
        list_for_each_entry_safe(cl_pos, cl_next, &dev->file_list, link) {
@@ -371,7 +391,7 @@ void mei_host_start_message(struct mei_device *dev)
        if (mei_write_message(dev, mei_hdr, (unsigned char *)host_start_req,
                                       mei_hdr->length)) {
                dev_dbg(&dev->pdev->dev, "write send version message to FW fail.\n");
-               dev->mei_state = MEI_RESETING;
+               dev->dev_state = MEI_DEV_RESETING;
                mei_reset(dev, 1);
        }
        dev->init_clients_state = MEI_START_MESSAGE;
@@ -403,7 +423,7 @@ void mei_host_enum_clients_message(struct mei_device *dev)
        host_enum_req->hbm_cmd = HOST_ENUM_REQ_CMD;
        if (mei_write_message(dev, mei_hdr, (unsigned char *)host_enum_req,
                                mei_hdr->length)) {
-               dev->mei_state = MEI_RESETING;
+               dev->dev_state = MEI_DEV_RESETING;
                dev_dbg(&dev->pdev->dev, "write send enumeration request message to FW fail.\n");
                mei_reset(dev, 1);
        }
@@ -444,7 +464,7 @@ void mei_allocate_me_clients_storage(struct mei_device *dev)
                        sizeof(struct mei_me_client), GFP_KERNEL);
        if (!clients) {
                dev_dbg(&dev->pdev->dev, "memory allocation for ME clients failed.\n");
-               dev->mei_state = MEI_RESETING;
+               dev->dev_state = MEI_DEV_RESETING;
                mei_reset(dev, 1);
                return ;
        }
@@ -490,7 +510,7 @@ int mei_host_client_properties(struct mei_device *dev)
                if (mei_write_message(dev, mei_header,
                                (unsigned char *)host_cli_req,
                                mei_header->length)) {
-                       dev->mei_state = MEI_RESETING;
+                       dev->dev_state = MEI_DEV_RESETING;
                        dev_dbg(&dev->pdev->dev, "write send enumeration request message to FW fail.\n");
                        mei_reset(dev, 1);
                        return -EIO;

diff --git a/drivers/misc/mei/interrupt.c b/drivers/misc/mei/interrupt.c
index c6ffbbe5a6c014b11ee05855795c1c941d0f0abe..94370d26ed450b301865e368f0c46949290782cd 100644 (file)
--- a/drivers/misc/mei/interrupt.c
+++ b/drivers/misc/mei/interrupt.c
@@ -633,7 +633,7 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
                if (version_res->host_version_supported) {
                        dev->version.major_version = HBM_MAJOR_VERSION;
                        dev->version.minor_version = HBM_MINOR_VERSION;
-                       if (dev->mei_state == MEI_INIT_CLIENTS &&
+                       if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
                            dev->init_clients_state == MEI_START_MESSAGE) {
                                dev->init_clients_timer = 0;
                                mei_host_enum_clients_message(dev);
@@ -707,7 +707,7 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
                        dev->me_clients[dev->me_client_presentation_num].props
                                                = props_res->client_properties;
 
-                       if (dev->mei_state == MEI_INIT_CLIENTS &&
+                       if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
                            dev->init_clients_state ==
                                        MEI_CLIENT_PROPERTIES_MESSAGE) {
                                dev->me_client_index++;
@@ -734,7 +734,7 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
                                         * Client ID 2 - Reserved for AMTHI
                                         */
                                        bitmap_set(dev->host_clients_map, 0, 3);
-                                       dev->mei_state = MEI_ENABLED;
+                                       dev->dev_state = MEI_DEV_ENABLED;
 
                                        /* if wd initialization fails, initialization the AMTHI client,
                                         * otherwise the AMTHI client will be initialized after the WD client connect response
@@ -759,7 +759,7 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
        case HOST_ENUM_RES_CMD:
                enum_res = (struct hbm_host_enum_response *) mei_msg;
                memcpy(dev->me_clients_map, enum_res->valid_addresses, 32);
-               if (dev->mei_state == MEI_INIT_CLIENTS &&
+               if (dev->dev_state == MEI_DEV_INIT_CLIENTS &&
                    dev->init_clients_state == MEI_ENUM_CLIENTS_MESSAGE) {
                                dev->init_clients_timer = 0;
                                dev->me_client_presentation_num = 0;
@@ -776,7 +776,7 @@ static void mei_irq_thread_read_bus_message(struct mei_device *dev,
                break;
 
        case HOST_STOP_RES_CMD:
-               dev->mei_state = MEI_DISABLED;
+               dev->dev_state = MEI_DEV_DISABLED;
                dev_dbg(&dev->pdev->dev, "resetting because of FW stop response.\n");
                mei_reset(dev, 1);
                break;
@@ -1240,7 +1240,7 @@ static int mei_irq_thread_write_handler(struct mei_io_list *cmpl_list,
                *slots -= dev->extra_write_index;
                dev->extra_write_index = 0;
        }
-       if (dev->mei_state == MEI_ENABLED) {
+       if (dev->dev_state == MEI_DEV_ENABLED) {
                if (dev->wd_pending &&
                    mei_flow_ctrl_creds(dev, &dev->wd_cl) > 0) {
                        if (mei_wd_send(dev))
@@ -1361,8 +1361,8 @@ void mei_timer(struct work_struct *work)
 
 
        mutex_lock(&dev->device_lock);
-       if (dev->mei_state != MEI_ENABLED) {
-               if (dev->mei_state == MEI_INIT_CLIENTS) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
+               if (dev->dev_state == MEI_DEV_INIT_CLIENTS) {
                        if (dev->init_clients_timer) {
                                if (--dev->init_clients_timer == 0) {
                                        dev_dbg(&dev->pdev->dev, "IMEI reset due to init clients timeout ,init clients state = %d.\n",
@@ -1484,8 +1484,8 @@ irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id)
 
        /* check if ME wants a reset */
        if ((dev->me_hw_state & ME_RDY_HRA) == 0 &&
-           dev->mei_state != MEI_RESETING &&
-           dev->mei_state != MEI_INITIALIZING) {
+           dev->dev_state != MEI_DEV_RESETING &&
+           dev->dev_state != MEI_DEV_INITIALIZING) {
                dev_dbg(&dev->pdev->dev, "FW not ready.\n");
                mei_reset(dev, 1);
                mutex_unlock(&dev->device_lock);
@@ -1498,7 +1498,7 @@ irqreturn_t mei_interrupt_thread_handler(int irq, void *dev_id)
                        dev_dbg(&dev->pdev->dev, "we need to start the dev.\n");
                        dev->host_hw_state |= (H_IE | H_IG | H_RDY);
                        mei_hcsr_set(dev);
-                       dev->mei_state = MEI_INIT_CLIENTS;
+                       dev->dev_state = MEI_DEV_INIT_CLIENTS;
                        dev_dbg(&dev->pdev->dev, "link is established start sending messages.\n");
                        /* link is established
                         * start sending messages.

diff --git a/drivers/misc/mei/iorw.c b/drivers/misc/mei/iorw.c
index 9187d852ef9c702d575e7731d91fb2fdddc03099..fcba98eb892e1e410d62a4c198d978ab82b667f5 100644 (file)
--- a/drivers/misc/mei/iorw.c
+++ b/drivers/misc/mei/iorw.c
@@ -108,7 +108,7 @@ int mei_ioctl_connect_client(struct file *file,
 
        cb->major_file_operations = MEI_IOCTL;
 
-       if (dev->mei_state != MEI_ENABLED) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
                rets = -ENODEV;
                goto end;
        }
@@ -402,7 +402,7 @@ int mei_start_read(struct mei_device *dev, struct mei_cl *cl)
        if (cl->state != MEI_FILE_CONNECTED)
                return -ENODEV;
 
-       if (dev->mei_state != MEI_ENABLED)
+       if (dev->dev_state != MEI_DEV_ENABLED)
                return -ENODEV;
 
        dev_dbg(&dev->pdev->dev, "check if read is pending.\n");

diff --git a/drivers/misc/mei/main.c b/drivers/misc/mei/main.c
index dea65c2c9203ccff1d556e0e0afedd3ba1d3d242..5c557dd129d6bd9b6876ad5889a21a5523639395 100644 (file)
--- a/drivers/misc/mei/main.c
+++ b/drivers/misc/mei/main.c
@@ -232,9 +232,9 @@ static int mei_open(struct inode *inode, struct file *file)
                goto out_unlock;
 
        err = -ENODEV;
-       if (dev->mei_state != MEI_ENABLED) {
-               dev_dbg(&dev->pdev->dev, "mei_state != MEI_ENABLED  mei_state= %d\n",
-                   dev->mei_state);
+       if (dev->dev_state != MEI_DEV_ENABLED) {
+               dev_dbg(&dev->pdev->dev, "dev_state != MEI_ENABLED  dev_state = %s\n",
+                   mei_dev_state_str(dev->dev_state));
                goto out_unlock;
        }
        err = -EMFILE;
@@ -384,7 +384,7 @@ static ssize_t mei_read(struct file *file, char __user *ubuf,
        dev = cl->dev;
 
        mutex_lock(&dev->device_lock);
-       if (dev->mei_state != MEI_ENABLED) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
                rets = -ENODEV;
                goto out;
        }
@@ -538,7 +538,7 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
 
        mutex_lock(&dev->device_lock);
 
-       if (dev->mei_state != MEI_ENABLED) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
                mutex_unlock(&dev->device_lock);
                return -ENODEV;
        }
@@ -613,7 +613,7 @@ static ssize_t mei_write(struct file *file, const char __user *ubuf,
                        rets = -ENOMEM;
                        goto unlock_dev;
                }
-               if (dev->mei_state != MEI_ENABLED) {
+               if (dev->dev_state != MEI_DEV_ENABLED) {
                        rets = -ENODEV;
                        goto unlock_dev;
                }
@@ -769,7 +769,7 @@ static long mei_ioctl(struct file *file, unsigned int cmd, unsigned long data)
        dev_dbg(&dev->pdev->dev, "IOCTL cmd = 0x%x", cmd);
 
        mutex_lock(&dev->device_lock);
-       if (dev->mei_state != MEI_ENABLED) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
                rets = -ENODEV;
                goto out;
        }
@@ -848,7 +848,7 @@ static unsigned int mei_poll(struct file *file, poll_table *wait)
 
        mutex_lock(&dev->device_lock);
 
-       if (dev->mei_state != MEI_ENABLED)
+       if (dev->dev_state != MEI_DEV_ENABLED)
                goto out;
 
 
@@ -1118,9 +1118,9 @@ static int mei_pci_suspend(struct device *device)
        /* Stop watchdog if exists */
        err = mei_wd_stop(dev, true);
        /* Set new mei state */
-       if (dev->mei_state == MEI_ENABLED ||
-           dev->mei_state == MEI_RECOVERING_FROM_RESET) {
-               dev->mei_state = MEI_POWER_DOWN;
+       if (dev->dev_state == MEI_DEV_ENABLED ||
+           dev->dev_state == MEI_DEV_RECOVERING_FROM_RESET) {
+               dev->dev_state = MEI_DEV_POWER_DOWN;
                mei_reset(dev, 0);
        }
        mutex_unlock(&dev->device_lock);
@@ -1162,7 +1162,7 @@ static int mei_pci_resume(struct device *device)
        }
 
        mutex_lock(&dev->device_lock);
-       dev->mei_state = MEI_POWER_UP;
+       dev->dev_state = MEI_DEV_POWER_UP;
        mei_reset(dev, 1);
        mutex_unlock(&dev->device_lock);
 

diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h
index 1ff1fc678fb3aea807b4628bf192711226a21ed6..35d0538a59748305bce975dac94d1a178aa2508f 100644 (file)
--- a/drivers/misc/mei/mei_dev.h
+++ b/drivers/misc/mei/mei_dev.h
@@ -78,17 +78,19 @@ enum file_state {
 };
 
 /* MEI device states */
-enum mei_states {
-       MEI_INITIALIZING = 0,
-       MEI_INIT_CLIENTS,
-       MEI_ENABLED,
-       MEI_RESETING,
-       MEI_DISABLED,
-       MEI_RECOVERING_FROM_RESET,
-       MEI_POWER_DOWN,
-       MEI_POWER_UP
+enum mei_dev_state {
+       MEI_DEV_INITIALIZING = 0,
+       MEI_DEV_INIT_CLIENTS,
+       MEI_DEV_ENABLED,
+       MEI_DEV_RESETING,
+       MEI_DEV_DISABLED,
+       MEI_DEV_RECOVERING_FROM_RESET,
+       MEI_DEV_POWER_DOWN,
+       MEI_DEV_POWER_UP
 };
 
+const char *mei_dev_state_str(int state);
+
 /* init clients states*/
 enum mei_init_clients_states {
        MEI_START_MESSAGE = 0,
@@ -218,7 +220,7 @@ struct mei_device {
        /*
         * mei device  states
         */
-       enum mei_states mei_state;
+       enum mei_dev_state dev_state;
        enum mei_init_clients_states init_clients_state;
        u16 init_clients_timer;
        bool stop;

diff --git a/drivers/misc/mei/wd.c b/drivers/misc/mei/wd.c
index 912319e4fa90985ada27c14a8e534235280eda4a..3006cca34b16518a909ff316ba6213acebc09b36 100644 (file)
--- a/drivers/misc/mei/wd.c
+++ b/drivers/misc/mei/wd.c
@@ -202,10 +202,10 @@ static int mei_wd_ops_start(struct watchdog_device *wd_dev)
 
        mutex_lock(&dev->device_lock);
 
-       if (dev->mei_state != MEI_ENABLED) {
+       if (dev->dev_state != MEI_DEV_ENABLED) {
                dev_dbg(&dev->pdev->dev,
-                       "wd: mei_state != MEI_ENABLED  mei_state = %d\n",
-                       dev->mei_state);
+                       "wd: dev_state != MEI_DEV_ENABLED  dev_state = %s\n",
+                       mei_dev_state_str(dev->dev_state));
                goto end_unlock;
        }