u32 blocks;
        /* Number of segments read */
        u32 segments;
-       uint8_t data[EDID_MAX_SEGM * 256];
+       u8 data[EDID_MAX_SEGM * 256];
        /* Number of EDID read retries left */
        unsigned read_retries;
        bool complete;
        struct media_pad pad;
        struct v4l2_ctrl_handler hdl;
        int chip_revision;
-       uint8_t i2c_edid_addr;
-       uint8_t i2c_cec_addr;
+       u8 i2c_edid_addr;
+       u8 i2c_cec_addr;
        /* Is the adv7511 powered on? */
        bool power_on;
        /* Did we receive hotplug and rx-sense signals? */
 
 /* To set specific bits in the register, a clear-mask is given (to be AND-ed),
    and then the value-mask (to be OR-ed). */
-static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, uint8_t clr_mask, uint8_t val_mask)
+static inline void adv7511_wr_and_or(struct v4l2_subdev *sd, u8 reg, u8 clr_mask, u8 val_mask)
 {
        adv7511_wr(sd, reg, (adv7511_rd(sd, reg) & clr_mask) | val_mask);
 }
        return ret;
 }
 
-static inline void adv7511_edid_rd(struct v4l2_subdev *sd, uint16_t len, uint8_t *buf)
+static inline void adv7511_edid_rd(struct v4l2_subdev *sd, u16 len, u8 *buf)
 {
        struct adv7511_state *state = get_adv7511_state(sd);
        int i;
        return adv7511_rd(sd, 0x42) & MASK_ADV7511_MSEN_DETECT;
 }
 
-static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, uint8_t mode)
+static void adv7511_csc_conversion_mode(struct v4l2_subdev *sd, u8 mode)
 {
        adv7511_wr_and_or(sd, 0x18, 0x9f, (mode & 0x3)<<5);
 }
 static void adv7511_csc_rgb_full2limit(struct v4l2_subdev *sd, bool enable)
 {
        if (enable) {
-               uint8_t csc_mode = 0;
+               u8 csc_mode = 0;
                adv7511_csc_conversion_mode(sd, csc_mode);
                adv7511_csc_coeff(sd,
                                  4096-564, 0, 0, 256,
 /* Enable interrupts */
 static void adv7511_set_isr(struct v4l2_subdev *sd, bool enable)
 {
-       uint8_t irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
-       uint8_t irqs_rd;
+       u8 irqs = MASK_ADV7511_HPD_INT | MASK_ADV7511_MSEN_INT;
+       u8 irqs_rd;
        int retries = 100;
 
        v4l2_dbg(2, debug, sd, "%s: %s\n", __func__, enable ? "enable" : "disable");
 /* Interrupt handler */
 static int adv7511_isr(struct v4l2_subdev *sd, u32 status, bool *handled)
 {
-       uint8_t irq_status;
+       u8 irq_status;
 
        /* disable interrupts to prevent a race condition */
        adv7511_set_isr(sd, false);
 };
 
 /* ----------------------------------------------------------------------- */
-static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, uint8_t *buf)
+static void adv7511_dbg_dump_edid(int lvl, int debug, struct v4l2_subdev *sd, int segment, u8 *buf)
 {
        if (debug >= lvl) {
                int i, j;
 {
        struct adv7511_state *state = get_adv7511_state(sd);
        /* read hotplug and rx-sense state */
-       uint8_t status = adv7511_rd(sd, 0x42);
+       u8 status = adv7511_rd(sd, 0x42);
 
        v4l2_dbg(1, debug, sd, "%s: status: 0x%x%s%s\n",
                         __func__,
        }
 }
 
-static bool edid_block_verify_crc(uint8_t *edid_block)
+static bool edid_block_verify_crc(u8 *edid_block)
 {
-       uint8_t sum = 0;
+       u8 sum = 0;
        int i;
 
        for (i = 0; i < 128; i++)
 {
        struct adv7511_state *state = get_adv7511_state(sd);
        u32 blocks = state->edid.blocks;
-       uint8_t *data = state->edid.data;
+       u8 *data = state->edid.data;
 
        if (!edid_block_verify_crc(&data[segment * 256]))
                return false;
 static bool adv7511_check_edid_status(struct v4l2_subdev *sd)
 {
        struct adv7511_state *state = get_adv7511_state(sd);
-       uint8_t edidRdy = adv7511_rd(sd, 0xc5);
+       u8 edidRdy = adv7511_rd(sd, 0xc5);
 
        v4l2_dbg(1, debug, sd, "%s: edid ready (retries: %d)\n",
                         __func__, EDID_MAX_RETRIES - state->edid.read_retries);