drm/nv50: use custom i2c algo for dp auxch

This makes it easier to see how this is working, and lets us transfer the
EDID in blocks of 16 bytes.

The primary reason for this change is because debug logs are rather hard
to read with the hundreds of single-byte auxch transactions that occur.

Signed-off-by: Ben Skeggs <bskeggs@redhat.com>

3 files changed, 72 insertions, 62 deletions

diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 33742b11188b..8a1b188b4cd1 100644
--- a/drivers/gpu/drm/nouveau/nouveau_dp.c
+++ b/drivers/gpu/drm/nouveau/nouveau_dp.c
@@ -572,47 +572,64 @@ out:
         return ret ? ret : (stat & NV50_AUXCH_STAT_REPLY);
 }
 
-int
-nouveau_dp_i2c_aux_ch(struct i2c_adapter *adapter, int mode,
-                      uint8_t write_byte, uint8_t *read_byte)
+static int
+nouveau_dp_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
 {
-        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
-        struct nouveau_i2c_chan *auxch = (struct nouveau_i2c_chan *)adapter;
+        struct nouveau_i2c_chan *auxch = (struct nouveau_i2c_chan *)adap;
         struct drm_device *dev = auxch->dev;
-        int ret = 0, cmd, addr = algo_data->address;
-        uint8_t *buf;
-
-        if (mode == MODE_I2C_READ) {
-                cmd = AUX_I2C_READ;
-                buf = read_byte;
-        } else {
-                cmd = (mode & MODE_I2C_READ) ? AUX_I2C_READ : AUX_I2C_WRITE;
-                buf = &write_byte;
-        }
+        struct i2c_msg *msg = msgs;
+        int ret, mcnt = num;
 
-        if (!(mode & MODE_I2C_STOP))
-                cmd |= AUX_I2C_MOT;
+        while (mcnt--) {
+                u8 remaining = msg->len;
+                u8 *ptr = msg->buf;
 
-        if (mode & MODE_I2C_START)
-                return 1;
+                while (remaining) {
+                        u8 cnt = (remaining > 16) ? 16 : remaining;
+                        u8 cmd;
 
-        for (;;) {
-                ret = nouveau_dp_auxch(auxch, cmd, addr, buf, 1);
-                if (ret < 0)
-                        return ret;
-
-                switch (ret & NV50_AUXCH_STAT_REPLY_I2C) {
-                case NV50_AUXCH_STAT_REPLY_I2C_ACK:
-                        return 1;
-                case NV50_AUXCH_STAT_REPLY_I2C_NACK:
-                        return -EREMOTEIO;
-                case NV50_AUXCH_STAT_REPLY_I2C_DEFER:
-                        udelay(100);
-                        break;
-                default:
-                        NV_ERROR(dev, "invalid auxch status: 0x%08x\n", ret);
-                        return -EREMOTEIO;
+                        if (msg->flags & I2C_M_RD)
+                                cmd = AUX_I2C_READ;
+                        else
+                                cmd = AUX_I2C_WRITE;
+
+                        if (mcnt || remaining > 16)
+                                cmd |= AUX_I2C_MOT;
+
+                        ret = nouveau_dp_auxch(auxch, cmd, msg->addr, ptr, cnt);
+                        if (ret < 0)
+                                return ret;
+
+                        switch (ret & NV50_AUXCH_STAT_REPLY_I2C) {
+                        case NV50_AUXCH_STAT_REPLY_I2C_ACK:
+                                break;
+                        case NV50_AUXCH_STAT_REPLY_I2C_NACK:
+                                return -EREMOTEIO;
+                        case NV50_AUXCH_STAT_REPLY_I2C_DEFER:
+                                udelay(100);
+                                continue;
+                        default:
+                                NV_ERROR(dev, "bad auxch reply: 0x%08x\n", ret);
+                                return -EREMOTEIO;
+                        }
+
+                        ptr += cnt;
+                        remaining -= cnt;
                 }
+
+                msg++;
         }
+
+        return num;
+}
+
+static u32
+nouveau_dp_i2c_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
 }
 
+const struct i2c_algorithm nouveau_dp_i2c_algo = {
+        .master_xfer = nouveau_dp_i2c_xfer,
+        .functionality = nouveau_dp_i2c_func
+};
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.c b/drivers/gpu/drm/nouveau/nouveau_i2c.c
index cb0cb34440c6..9df711fdbbc5 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.c
+++ b/drivers/gpu/drm/nouveau/nouveau_i2c.c
@@ -174,26 +174,26 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
 
         switch (entry->port_type) {
         case 0:
-                i2c->algo.bit.setsda = nv04_i2c_setsda;
-                i2c->algo.bit.setscl = nv04_i2c_setscl;
-                i2c->algo.bit.getsda = nv04_i2c_getsda;
-                i2c->algo.bit.getscl = nv04_i2c_getscl;
+                i2c->bit.setsda = nv04_i2c_setsda;
+                i2c->bit.setscl = nv04_i2c_setscl;
+                i2c->bit.getsda = nv04_i2c_getsda;
+                i2c->bit.getscl = nv04_i2c_getscl;
                 i2c->rd = entry->read;
                 i2c->wr = entry->write;
                 break;
         case 4:
-                i2c->algo.bit.setsda = nv4e_i2c_setsda;
-                i2c->algo.bit.setscl = nv4e_i2c_setscl;
-                i2c->algo.bit.getsda = nv4e_i2c_getsda;
-                i2c->algo.bit.getscl = nv4e_i2c_getscl;
+                i2c->bit.setsda = nv4e_i2c_setsda;
+                i2c->bit.setscl = nv4e_i2c_setscl;
+                i2c->bit.getsda = nv4e_i2c_getsda;
+                i2c->bit.getscl = nv4e_i2c_getscl;
                 i2c->rd = 0x600800 + entry->read;
                 i2c->wr = 0x600800 + entry->write;
                 break;
         case 5:
-                i2c->algo.bit.setsda = nv50_i2c_setsda;
-                i2c->algo.bit.setscl = nv50_i2c_setscl;
-                i2c->algo.bit.getsda = nv50_i2c_getsda;
-                i2c->algo.bit.getscl = nv50_i2c_getscl;
+                i2c->bit.setsda = nv50_i2c_setsda;
+                i2c->bit.setscl = nv50_i2c_setscl;
+                i2c->bit.getsda = nv50_i2c_getsda;
+                i2c->bit.getscl = nv50_i2c_getscl;
                 i2c->rd = nv50_i2c_port[entry->read];
                 i2c->wr = i2c->rd;
                 break;
@@ -216,17 +216,14 @@ nouveau_i2c_init(struct drm_device *dev, struct dcb_i2c_entry *entry, int index)
         i2c_set_adapdata(&i2c->adapter, i2c);
 
         if (entry->port_type < 6) {
-                i2c->adapter.algo_data = &i2c->algo.bit;
-                i2c->algo.bit.udelay = 40;
-                i2c->algo.bit.timeout = usecs_to_jiffies(5000);
-                i2c->algo.bit.data = i2c;
+                i2c->adapter.algo_data = &i2c->bit;
+                i2c->bit.udelay = 40;
+                i2c->bit.timeout = usecs_to_jiffies(5000);
+                i2c->bit.data = i2c;
                 ret = i2c_bit_add_bus(&i2c->adapter);
         } else {
-                i2c->adapter.algo_data = &i2c->algo.dp;
-                i2c->algo.dp.running = false;
-                i2c->algo.dp.address = 0;
-                i2c->algo.dp.aux_ch = nouveau_dp_i2c_aux_ch;
-                ret = i2c_dp_aux_add_bus(&i2c->adapter);
+                i2c->adapter.algo = &nouveau_dp_i2c_algo;
+                ret = i2c_add_adapter(&i2c->adapter);
         }
 
         if (ret) {
diff --git a/drivers/gpu/drm/nouveau/nouveau_i2c.h b/drivers/gpu/drm/nouveau/nouveau_i2c.h
index 6dd2f8713cd1..f71cb32f7571 100644
--- a/drivers/gpu/drm/nouveau/nouveau_i2c.h
+++ b/drivers/gpu/drm/nouveau/nouveau_i2c.h
@@ -33,10 +33,7 @@ struct dcb_i2c_entry;
 struct nouveau_i2c_chan {
         struct i2c_adapter adapter;
         struct drm_device *dev;
-        union {
-                struct i2c_algo_bit_data bit;
-                struct i2c_algo_dp_aux_data dp;
-        } algo;
+        struct i2c_algo_bit_data bit;
         unsigned rd;
         unsigned wr;
         unsigned data;
@@ -49,7 +46,6 @@ bool nouveau_probe_i2c_addr(struct nouveau_i2c_chan *i2c, int addr);
 int nouveau_i2c_identify(struct drm_device *dev, const char *what,
                          struct i2c_board_info *info, int index);
 
-int nouveau_dp_i2c_aux_ch(struct i2c_adapter *, int mode, uint8_t write_byte,
-                          uint8_t *read_byte);
+extern const struct i2c_algorithm nouveau_dp_i2c_algo;
 
 #endif /* __NOUVEAU_I2C_H__ */