int num_msg;
        struct i2c_msg msg;
        unsigned char data[6] = {0};
-       u16 *wreg;
+       __be16 *wreg;
        int retry = 0;
 
        if (!client->adapter) {
        msg.buf = data;
 
        /* high byte goes out first */
-       wreg = (u16 *)data;
+       wreg = (void *)data;
        *wreg = cpu_to_be16(reg);
 
        if (data_length == MISENSOR_8BIT) {
                data[2] = (u8)(val);
        } else if (data_length == MISENSOR_16BIT) {
-               u16 *wdata = (u16 *)&data[2];
-               *wdata = be16_to_cpu((u16)val);
+               u16 *wdata = (void *)&data[2];
+
+               *wdata = be16_to_cpu(*(__be16 *)&data[2]);
        } else {
                /* MISENSOR_32BIT */
-               u32 *wdata = (u32 *)&data[2];
-               *wdata = be32_to_cpu(val);
+               u32 *wdata = (void *)&data[2];
+
+               *wdata = be32_to_cpu(*(__be32 *)&data[2]);
        }
 
        num_msg = i2c_transfer(client->adapter, &msg, 1);
        const int num_msg = 1;
        int ret;
        int retry = 0;
+       __be16 *data16 = (void *)&ctrl->buffer.addr;
 
        if (ctrl->index == 0)
                return 0;
        msg.addr = client->addr;
        msg.flags = 0;
        msg.len = 2 + ctrl->index;
-       ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
+       *data16 = cpu_to_be16(ctrl->buffer.addr);
        msg.buf = (u8 *)&ctrl->buffer;
 
        ret = i2c_transfer(client->adapter, &msg, num_msg);
                                   struct mt9m114_write_ctrl *ctrl,
                                   const struct misensor_reg *next)
 {
-       u16 *data16;
-       u32 *data32;
+       __be16 *data16;
+       __be32 *data32;
        int err;
 
        /* Insufficient buffer? Let's flush and get more free space. */
                ctrl->buffer.data[ctrl->index] = (u8)next->val;
                break;
        case MISENSOR_16BIT:
-               data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
+               data16 = (__be16 *)&ctrl->buffer.data[ctrl->index];
                *data16 = cpu_to_be16((u16)next->val);
                break;
        case MISENSOR_32BIT:
-               data32 = (u32 *)&ctrl->buffer.data[ctrl->index];
+               data32 = (__be32 *)&ctrl->buffer.data[ctrl->index];
                *data32 = cpu_to_be32(next->val);
                break;
        default:
 
        if (data_length == OV2680_8BIT)
                *val = (u8)data[0];
        else if (data_length == OV2680_16BIT)
-               *val = be16_to_cpu(*(u16 *)&data[0]);
+               *val = be16_to_cpu(*(__be16 *)&data[0]);
        else
-               *val = be32_to_cpu(*(u32 *)&data[0]);
+               *val = be32_to_cpu(*(__be32 *)&data[0]);
        //dev_dbg(&client->dev,  "++++i2c read adr%x = %x\n", reg,*val);
        return 0;
 }
 {
        int ret;
        unsigned char data[4] = {0};
-       u16 *wreg = (u16 *)data;
+       __be16 *wreg = (void *)data;
        const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
 
        if (data_length != OV2680_8BIT && data_length != OV2680_16BIT) {
                data[2] = (u8)(val);
        } else {
                /* OV2680_16BIT */
-               u16 *wdata = (u16 *)&data[2];
+               __be16 *wdata = (void *)&data[2];
+
                *wdata = cpu_to_be16(val);
        }
 
                                    struct ov2680_write_ctrl *ctrl)
 {
        u16 size;
+       __be16 *data16 = (void *)&ctrl->buffer.addr;
 
        if (ctrl->index == 0)
                return 0;
 
        size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
-       ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
+       *data16 = cpu_to_be16(ctrl->buffer.addr);
        ctrl->index = 0;
 
        return ov2680_i2c_write(client, size, (u8 *)&ctrl->buffer);
                                  const struct ov2680_reg *next)
 {
        int size;
-       u16 *data16;
+       __be16 *data16;
 
        switch (next->type) {
        case OV2680_8BIT:
                break;
        case OV2680_16BIT:
                size = 2;
-               data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
+               data16 = (void *)&ctrl->buffer.data[ctrl->index];
                *data16 = cpu_to_be16((u16)next->val);
                break;
        default:
 
        if (data_length == OV2722_8BIT)
                *val = (u8)data[0];
        else if (data_length == OV2722_16BIT)
-               *val = be16_to_cpu(*(u16 *)&data[0]);
+               *val = be16_to_cpu(*(__be16 *)&data[0]);
        else
-               *val = be32_to_cpu(*(u32 *)&data[0]);
+               *val = be32_to_cpu(*(__be32 *)&data[0]);
 
        return 0;
 }
 {
        int ret;
        unsigned char data[4] = {0};
-       u16 *wreg = (u16 *)data;
+       __be16 *wreg = (__be16 *)data;
        const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
 
        if (data_length != OV2722_8BIT && data_length != OV2722_16BIT) {
                data[2] = (u8)(val);
        } else {
                /* OV2722_16BIT */
-               u16 *wdata = (u16 *)&data[2];
+               __be16 *wdata = (__be16 *)&data[2];
+
                *wdata = cpu_to_be16(val);
        }
 
                                    struct ov2722_write_ctrl *ctrl)
 {
        u16 size;
+       __be16 *data16 = (void *)&ctrl->buffer.addr;
 
        if (ctrl->index == 0)
                return 0;
 
        size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
-       ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
+       *data16 = cpu_to_be16(ctrl->buffer.addr);
        ctrl->index = 0;
 
        return ov2722_i2c_write(client, size, (u8 *)&ctrl->buffer);
                                  const struct ov2722_reg *next)
 {
        int size;
-       u16 *data16;
+       __be16 *data16;
 
        switch (next->type) {
        case OV2722_8BIT:
                break;
        case OV2722_16BIT:
                size = 2;
-               data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
+               data16 = (void *)&ctrl->buffer.data[ctrl->index];
                *data16 = cpu_to_be16((u16)next->val);
                break;
        default:
 
        if (data_length == OV5693_8BIT)
                *val = (u8)data[0];
        else if (data_length == OV5693_16BIT)
-               *val = be16_to_cpu(*(u16 *)&data[0]);
+               *val = be16_to_cpu(*(__be16 *)&data[0]);
        else
-               *val = be32_to_cpu(*(u32 *)&data[0]);
+               *val = be32_to_cpu(*(__be32 *)&data[0]);
 
        return 0;
 }
        struct i2c_msg msg;
        const int num_msg = 1;
        int ret;
-       u16 val;
+       __be16 val;
 
        val = cpu_to_be16(data);
        msg.addr = VCM_ADDR;
        msg.flags = 0;
        msg.len = OV5693_16BIT;
-       msg.buf = (u8 *)&val;
+       msg.buf = (void *)&val;
 
        ret = i2c_transfer(client->adapter, &msg, 1);
 
 {
        int ret;
        unsigned char data[4] = {0};
-       u16 *wreg = (u16 *)data;
+       __be16 *wreg = (void *)data;
        const u16 len = data_length + sizeof(u16); /* 16-bit address + data */
 
        if (data_length != OV5693_8BIT && data_length != OV5693_16BIT) {
                data[2] = (u8)(val);
        } else {
                /* OV5693_16BIT */
-               u16 *wdata = (u16 *)&data[2];
+               __be16 *wdata = (void *)&data[2];
+
                *wdata = cpu_to_be16(val);
        }
 
                                    struct ov5693_write_ctrl *ctrl)
 {
        u16 size;
+       __be16 *reg = (void *)&ctrl->buffer.addr;
 
        if (ctrl->index == 0)
                return 0;
 
        size = sizeof(u16) + ctrl->index; /* 16-bit address + data */
-       ctrl->buffer.addr = cpu_to_be16(ctrl->buffer.addr);
+
+       *reg = cpu_to_be16(ctrl->buffer.addr);
        ctrl->index = 0;
 
-       return ov5693_i2c_write(client, size, (u8 *)&ctrl->buffer);
+       return ov5693_i2c_write(client, size, (u8 *)reg);
 }
 
 static int __ov5693_buf_reg_array(struct i2c_client *client,
                                  const struct ov5693_reg *next)
 {
        int size;
-       u16 *data16;
+       __be16 *data16;
 
        switch (next->type) {
        case OV5693_8BIT:
                break;
        case OV5693_16BIT:
                size = 2;
-               data16 = (u16 *)&ctrl->buffer.data[ctrl->index];
+
+               data16 = (void *)&ctrl->buffer.data[ctrl->index];
                *data16 = cpu_to_be16((u16)next->val);
                break;
        default: