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>

diff --git a/drivers/gpu/drm/nouveau/nouveau_dp.c b/drivers/gpu/drm/nouveau/nouveau_dp.c
index 33742b11188bdcddbee6e6b51cb77de15718281a..8a1b188b4cd13bcdff20d41484cd120618216293 100644 (file)
--- 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 cb0cb34440c6e835246136cd7f6ade3f29e71d21..9df711fdbbc5934d6800a60fb7c1d71f4c2f8055 100644 (file)
--- 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 6dd2f8713cd16befce5d0ce9b75bc5f5a20d662c..f71cb32f75715a9e4172a5b65359feca947994ac 100644 (file)
--- 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__ */