Cleanup conversions between slots and data.
Define MEI_SLOT_SIZE instead of using 4 or sizeof(u32) across
the source code.
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
        /* Split the message only if we can write the whole host buffer */
        } else if ((u32)slots == dev->hbuf_depth) {
                msg_slots = slots;
-               len = (slots * sizeof(u32)) - sizeof(struct mei_msg_hdr);
+               len = mei_slots2data(slots) - sizeof(struct mei_msg_hdr);
                mei_hdr.length = len;
                mei_hdr.msg_complete = 0;
        } else {
 
  */
 static size_t mei_me_hbuf_max_len(const struct mei_device *dev)
 {
-       return dev->hbuf_depth * sizeof(u32) - sizeof(struct mei_msg_hdr);
+       return mei_slots2data(dev->hbuf_depth) - sizeof(struct mei_msg_hdr);
 }
 
 
 
        mei_me_hcbww_write(dev, *((u32 *) header));
 
-       for (i = 0; i < length / 4; i++)
+       for (i = 0; i < length / MEI_SLOT_SIZE; i++)
                mei_me_hcbww_write(dev, reg_buf[i]);
 
        rem = length & 0x3;
  * Return: always 0
  */
 static int mei_me_read_slots(struct mei_device *dev, unsigned char *buffer,
-                   unsigned long buffer_length)
+                            unsigned long buffer_length)
 {
        u32 *reg_buf = (u32 *)buffer;
 
-       for (; buffer_length >= sizeof(u32); buffer_length -= sizeof(u32))
+       for (; buffer_length >= MEI_SLOT_SIZE; buffer_length -= MEI_SLOT_SIZE)
                *reg_buf++ = mei_me_mecbrw_read(dev);
 
        if (buffer_length > 0) {
 
        struct mei_txe_hw *hw = to_txe_hw(dev);
 
        /* Doesn't change in runtime */
-       dev->hbuf_depth = PAYLOAD_SIZE / 4;
+       dev->hbuf_depth = PAYLOAD_SIZE / MEI_SLOT_SIZE;
 
        hw->aliveness = mei_txe_aliveness_get(dev);
        hw->readiness = mei_txe_readiness_get(dev);
  *
  * @dev: the device structure
  *
- * Return: the PAYLOAD_SIZE - 4
+ * Return: the PAYLOAD_SIZE - header size
  */
 static size_t mei_txe_hbuf_max_len(const struct mei_device *dev)
 {
 static int mei_txe_count_full_read_slots(struct mei_device *dev)
 {
        /* read buffers has static size */
-       return  PAYLOAD_SIZE / 4;
+       return  PAYLOAD_SIZE / MEI_SLOT_SIZE;
 }
 
 /**
        dev_dbg(dev->dev, "buffer-length = %lu buf[0]0x%08X\n",
                len, mei_txe_out_data_read(dev, 0));
 
-       for (i = 0; i < len / 4; i++) {
+       for (i = 0; i < len / MEI_SLOT_SIZE; i++) {
                /* skip header: index starts from 1 */
                reg = mei_txe_out_data_read(dev, i + 1);
                dev_dbg(dev->dev, "buf[%d] = 0x%08X\n", i, reg);
 
 #include "hw.h"
 #include "hbm.h"
 
-#define MEI_RD_MSG_BUF_SIZE           (128 * sizeof(u32))
+#define MEI_SLOT_SIZE             sizeof(u32)
+#define MEI_RD_MSG_BUF_SIZE       (128 * MEI_SLOT_SIZE)
+
 
 /*
  * Number of Maximum MEI Clients
  */
 static inline u32 mei_data2slots(size_t length)
 {
-       return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, 4);
+       return DIV_ROUND_UP(sizeof(struct mei_msg_hdr) + length, MEI_SLOT_SIZE);
 }
 
 /**
  */
 static inline u32 mei_slots2data(int slots)
 {
-       return slots * 4;
+       return slots * MEI_SLOT_SIZE;
 }
 
 /*