media/i2c/max9271.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Copyright (C) 2017-2020 Jacopo Mondi
0004  * Copyright (C) 2017-2020 Kieran Bingham
0005  * Copyright (C) 2017-2020 Laurent Pinchart
0006  * Copyright (C) 2017-2020 Niklas Söderlund
0007  * Copyright (C) 2016 Renesas Electronics Corporation
0008  * Copyright (C) 2015 Cogent Embedded, Inc.
0009  *
0010  * This file exports functions to control the Maxim MAX9271 GMSL serializer
0011  * chip. This is not a self-contained driver, as MAX9271 is usually embedded in
0012  * camera modules with at least one image sensor and optional additional
0013  * components, such as uController units or ISPs/DSPs.
0014  *
0015  * Drivers for the camera modules (i.e. rdacm20/21) are expected to use
0016  * functions exported from this library driver to maximize code re-use.
0017  */
0018
0019 #include <linux/delay.h>
0020 #include <linux/i2c.h>
0021 #include <linux/module.h>
0022
0023 #include "max9271.h"
0024
0025 static int max9271_read(struct max9271_device *dev, u8 reg)
0026 {
0027     int ret;
0028
0029     dev_dbg(&dev->client->dev, "%s(0x%02x)\n", __func__, reg);
0030
0031     ret = i2c_smbus_read_byte_data(dev->client, reg);
0032     if (ret < 0)
0033         dev_dbg(&dev->client->dev,
0034             "%s: register 0x%02x read failed (%d)\n",
0035             __func__, reg, ret);
0036
0037     return ret;
0038 }
0039
0040 static int max9271_write(struct max9271_device *dev, u8 reg, u8 val)
0041 {
0042     int ret;
0043
0044     dev_dbg(&dev->client->dev, "%s(0x%02x, 0x%02x)\n", __func__, reg, val);
0045
0046     ret = i2c_smbus_write_byte_data(dev->client, reg, val);
0047     if (ret < 0)
0048         dev_err(&dev->client->dev,
0049             "%s: register 0x%02x write failed (%d)\n",
0050             __func__, reg, ret);
0051
0052     return ret;
0053 }
0054
0055 /*
0056  * max9271_pclk_detect() - Detect valid pixel clock from image sensor
0057  *
0058  * Wait up to 10ms for a valid pixel clock.
0059  *
0060  * Returns 0 for success, < 0 for pixel clock not properly detected
0061  */
0062 static int max9271_pclk_detect(struct max9271_device *dev)
0063 {
0064     unsigned int i;
0065     int ret;
0066
0067     for (i = 0; i < 100; i++) {
0068         ret = max9271_read(dev, 0x15);
0069         if (ret < 0)
0070             return ret;
0071
0072         if (ret & MAX9271_PCLKDET)
0073             return 0;
0074
0075         usleep_range(50, 100);
0076     }
0077
0078     dev_err(&dev->client->dev, "Unable to detect valid pixel clock\n");
0079
0080     return -EIO;
0081 }
0082
0083 void max9271_wake_up(struct max9271_device *dev)
0084 {
0085     /*
0086      * Use the chip default address as this function has to be called
0087      * before any other one.
0088      */
0089     dev->client->addr = MAX9271_DEFAULT_ADDR;
0090     i2c_smbus_read_byte(dev->client);
0091     usleep_range(5000, 8000);
0092 }
0093 EXPORT_SYMBOL_GPL(max9271_wake_up);
0094
0095 int max9271_set_serial_link(struct max9271_device *dev, bool enable)
0096 {
0097     int ret;
0098     u8 val = MAX9271_REVCCEN | MAX9271_FWDCCEN;
0099
0100     if (enable) {
0101         ret = max9271_pclk_detect(dev);
0102         if (ret)
0103             return ret;
0104
0105         val |= MAX9271_SEREN;
0106     } else {
0107         val |= MAX9271_CLINKEN;
0108     }
0109
0110     /*
0111      * The serializer temporarily disables the reverse control channel for
0112      * 350µs after starting/stopping the forward serial link, but the
0113      * deserializer synchronization time isn't clearly documented.
0114      *
0115      * According to the serializer datasheet we should wait 3ms, while
0116      * according to the deserializer datasheet we should wait 5ms.
0117      *
0118      * Short delays here appear to show bit-errors in the writes following.
0119      * Therefore a conservative delay seems best here.
0120      */
0121     ret = max9271_write(dev, 0x04, val);
0122     if (ret < 0)
0123         return ret;
0124
0125     usleep_range(5000, 8000);
0126
0127     return 0;
0128 }
0129 EXPORT_SYMBOL_GPL(max9271_set_serial_link);
0130
0131 int max9271_configure_i2c(struct max9271_device *dev, u8 i2c_config)
0132 {
0133     int ret;
0134
0135     ret = max9271_write(dev, 0x0d, i2c_config);
0136     if (ret < 0)
0137         return ret;
0138
0139     /* The delay required after an I2C bus configuration change is not
0140      * characterized in the serializer manual. Sleep up to 5msec to
0141      * stay safe.
0142      */
0143     usleep_range(3500, 5000);
0144
0145     return 0;
0146 }
0147 EXPORT_SYMBOL_GPL(max9271_configure_i2c);
0148
0149 int max9271_set_high_threshold(struct max9271_device *dev, bool enable)
0150 {
0151     int ret;
0152
0153     ret = max9271_read(dev, 0x08);
0154     if (ret < 0)
0155         return ret;
0156
0157     /*
0158      * Enable or disable reverse channel high threshold to increase
0159      * immunity to power supply noise.
0160      */
0161     ret = max9271_write(dev, 0x08, enable ? ret | BIT(0) : ret & ~BIT(0));
0162     if (ret < 0)
0163         return ret;
0164
0165     usleep_range(2000, 2500);
0166
0167     return 0;
0168 }
0169 EXPORT_SYMBOL_GPL(max9271_set_high_threshold);
0170
0171 int max9271_configure_gmsl_link(struct max9271_device *dev)
0172 {
0173     int ret;
0174
0175     /*
0176      * Configure the GMSL link:
0177      *
0178      * - Double input mode, high data rate, 24-bit mode
0179      * - Latch input data on PCLKIN rising edge
0180      * - Enable HS/VS encoding
0181      * - 1-bit parity error detection
0182      *
0183      * TODO: Make the GMSL link configuration parametric.
0184      */
0185     ret = max9271_write(dev, 0x07, MAX9271_DBL | MAX9271_HVEN |
0186                 MAX9271_EDC_1BIT_PARITY);
0187     if (ret < 0)
0188         return ret;
0189
0190     usleep_range(5000, 8000);
0191
0192     /*
0193      * Adjust spread spectrum to +4% and auto-detect pixel clock
0194      * and serial link rate.
0195      */
0196     ret = max9271_write(dev, 0x02,
0197                 MAX9271_SPREAD_SPECT_4 | MAX9271_R02_RES |
0198                 MAX9271_PCLK_AUTODETECT |
0199                 MAX9271_SERIAL_AUTODETECT);
0200     if (ret < 0)
0201         return ret;
0202
0203     usleep_range(5000, 8000);
0204
0205     return 0;
0206 }
0207 EXPORT_SYMBOL_GPL(max9271_configure_gmsl_link);
0208
0209 int max9271_set_gpios(struct max9271_device *dev, u8 gpio_mask)
0210 {
0211     int ret;
0212
0213     ret = max9271_read(dev, 0x0f);
0214     if (ret < 0)
0215         return 0;
0216
0217     ret |= gpio_mask;
0218     ret = max9271_write(dev, 0x0f, ret);
0219     if (ret < 0) {
0220         dev_err(&dev->client->dev, "Failed to set gpio (%d)\n", ret);
0221         return ret;
0222     }
0223
0224     usleep_range(3500, 5000);
0225
0226     return 0;
0227 }
0228 EXPORT_SYMBOL_GPL(max9271_set_gpios);
0229
0230 int max9271_clear_gpios(struct max9271_device *dev, u8 gpio_mask)
0231 {
0232     int ret;
0233
0234     ret = max9271_read(dev, 0x0f);
0235     if (ret < 0)
0236         return 0;
0237
0238     ret &= ~gpio_mask;
0239     ret = max9271_write(dev, 0x0f, ret);
0240     if (ret < 0) {
0241         dev_err(&dev->client->dev, "Failed to clear gpio (%d)\n", ret);
0242         return ret;
0243     }
0244
0245     usleep_range(3500, 5000);
0246
0247     return 0;
0248 }
0249 EXPORT_SYMBOL_GPL(max9271_clear_gpios);
0250
0251 int max9271_enable_gpios(struct max9271_device *dev, u8 gpio_mask)
0252 {
0253     int ret;
0254
0255     ret = max9271_read(dev, 0x0e);
0256     if (ret < 0)
0257         return 0;
0258
0259     /* BIT(0) reserved: GPO is always enabled. */
0260     ret |= (gpio_mask & ~BIT(0));
0261     ret = max9271_write(dev, 0x0e, ret);
0262     if (ret < 0) {
0263         dev_err(&dev->client->dev, "Failed to enable gpio (%d)\n", ret);
0264         return ret;
0265     }
0266
0267     usleep_range(3500, 5000);
0268
0269     return 0;
0270 }
0271 EXPORT_SYMBOL_GPL(max9271_enable_gpios);
0272
0273 int max9271_disable_gpios(struct max9271_device *dev, u8 gpio_mask)
0274 {
0275     int ret;
0276
0277     ret = max9271_read(dev, 0x0e);
0278     if (ret < 0)
0279         return 0;
0280
0281     /* BIT(0) reserved: GPO cannot be disabled */
0282     ret &= ~(gpio_mask | BIT(0));
0283     ret = max9271_write(dev, 0x0e, ret);
0284     if (ret < 0) {
0285         dev_err(&dev->client->dev, "Failed to disable gpio (%d)\n", ret);
0286         return ret;
0287     }
0288
0289     usleep_range(3500, 5000);
0290
0291     return 0;
0292 }
0293 EXPORT_SYMBOL_GPL(max9271_disable_gpios);
0294
0295 int max9271_verify_id(struct max9271_device *dev)
0296 {
0297     int ret;
0298
0299     ret = max9271_read(dev, 0x1e);
0300     if (ret < 0) {
0301         dev_err(&dev->client->dev, "MAX9271 ID read failed (%d)\n",
0302             ret);
0303         return ret;
0304     }
0305
0306     if (ret != MAX9271_ID) {
0307         dev_err(&dev->client->dev, "MAX9271 ID mismatch (0x%02x)\n",
0308             ret);
0309         return -ENXIO;
0310     }
0311
0312     return 0;
0313 }
0314 EXPORT_SYMBOL_GPL(max9271_verify_id);
0315
0316 int max9271_set_address(struct max9271_device *dev, u8 addr)
0317 {
0318     int ret;
0319
0320     ret = max9271_write(dev, 0x00, addr << 1);
0321     if (ret < 0) {
0322         dev_err(&dev->client->dev,
0323             "MAX9271 I2C address change failed (%d)\n", ret);
0324         return ret;
0325     }
0326     usleep_range(3500, 5000);
0327
0328     return 0;
0329 }
0330 EXPORT_SYMBOL_GPL(max9271_set_address);
0331
0332 int max9271_set_deserializer_address(struct max9271_device *dev, u8 addr)
0333 {
0334     int ret;
0335
0336     ret = max9271_write(dev, 0x01, addr << 1);
0337     if (ret < 0) {
0338         dev_err(&dev->client->dev,
0339             "MAX9271 deserializer address set failed (%d)\n", ret);
0340         return ret;
0341     }
0342     usleep_range(3500, 5000);
0343
0344     return 0;
0345 }
0346 EXPORT_SYMBOL_GPL(max9271_set_deserializer_address);
0347
0348 int max9271_set_translation(struct max9271_device *dev, u8 source, u8 dest)
0349 {
0350     int ret;
0351
0352     ret = max9271_write(dev, 0x09, source << 1);
0353     if (ret < 0) {
0354         dev_err(&dev->client->dev,
0355             "MAX9271 I2C translation setup failed (%d)\n", ret);
0356         return ret;
0357     }
0358     usleep_range(3500, 5000);
0359
0360     ret = max9271_write(dev, 0x0a, dest << 1);
0361     if (ret < 0) {
0362         dev_err(&dev->client->dev,
0363             "MAX9271 I2C translation setup failed (%d)\n", ret);
0364         return ret;
0365     }
0366     usleep_range(3500, 5000);
0367
0368     return 0;
0369 }
0370 EXPORT_SYMBOL_GPL(max9271_set_translation);
0371
0372 MODULE_DESCRIPTION("Maxim MAX9271 GMSL Serializer");
0373 MODULE_AUTHOR("Jacopo Mondi");
0374 MODULE_LICENSE("GPL v2");