API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 10th, 2022
188
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 29.69 KB | Source Code | 0 0
raw download clone embed print report
  1. //#include <linux/init.h>
  2. //#include <linux/module.h>
  3. #include <linux/i2c.h>           /* For of_device_id, i2c_driver,
  4.                   * of_match_ptr, module_i2c_driver
  5.                   */
  6. #include <linux/module.h>        // For module_i2c_driver
  7. #include <media/tegracam_core.h> // For tegracam_device
  8. #include <linux/of_device.h>     // For of_match_device
  9. #include <linux/of_gpio.h>       // For of_get_named_gpio
  10.  
  11. // For define arguments type
  12. #define INPUT_ARGUMENT
  13. #define MODIFIED_ARGUMENT
  14. #define OUTPUT_ARGUMENT
  15.  
  16. /* imx219 - sensor parameter limits */
  17. #define IMX219_MIN_GAIN             0x0000
  18. #define IMX219_MAX_GAIN             0x00e8
  19. #define IMX219_MIN_FRAME_LENGTH         0x0100
  20. #define IMX219_MAX_FRAME_LENGTH         0xffff
  21. #define IMX219_MIN_COARSE_EXPOSURE      0x0001
  22. #define IMX219_MAX_COARSE_DIFF          0x0004
  23.  
  24. /* imx219 sensor register address */
  25. #define IMX219_MODEL_ID_ADDR_MSB        0x0000
  26. #define IMX219_MODEL_ID_ADDR_LSB        0x0001
  27. #define IMX219_GAIN_ADDR            0x0157
  28. #define IMX219_FRAME_LENGTH_ADDR_MSB        0x0160
  29. #define IMX219_FRAME_LENGTH_ADDR_LSB        0x0161
  30. #define IMX219_COARSE_INTEG_TIME_ADDR_MSB   0x015a
  31. #define IMX219_COARSE_INTEG_TIME_ADDR_LSB   0x015b
  32. #define IMX219_FINE_INTEG_TIME_ADDR_MSB     0x0388
  33. #define IMX219_FINE_INTEG_TIME_ADDR_LSB     0x0389
  34.  
  35.  
  36. //--- from imx219_mode_tbls.h ---
  37. #define IMX219_TABLE_WAIT_MS    0
  38. #define IMX219_TABLE_END    1
  39.  
  40. #define imx219_reg struct reg_8
  41.  
  42. static imx219_reg imx219_start_stream[] = {
  43.     {0x0100, 0x01},
  44.     {IMX219_TABLE_WAIT_MS, 3},
  45.     {IMX219_TABLE_END, 0x00}
  46. };
  47.  
  48. static imx219_reg imx219_stop_stream[] = {
  49.     {0x0100, 0x00},
  50.     {IMX219_TABLE_END, 0x00}
  51. };
  52.  
  53. static imx219_reg imx219_mode_common[] = {
  54.     /* software reset */
  55.     {0x0103, 0x01},
  56.     {IMX219_TABLE_WAIT_MS, 10},
  57.     /* sensor config */
  58.     {0x0114, 0x01}, /* D-Phy, 2-lane */
  59.     {0x0128, 0x00},
  60.     {0x012A, 0x18}, /* 24 MHz INCK */
  61.     {0x012B, 0x00},
  62.     /* access code - vendor addr. ranges */
  63.     {0x30EB, 0x05},
  64.     {0x30EB, 0x0C},
  65.     {0x300A, 0xFF},
  66.     {0x300B, 0xFF},
  67.     {0x30EB, 0x05},
  68.     {0x30EB, 0x09},
  69.     /* cis tuning */
  70.     {0x455E, 0x00},
  71.     {0x471E, 0x4B},
  72.     {0x4767, 0x0F},
  73.     {0x4750, 0x14},
  74.     {0x4540, 0x00},
  75.     {0x47B4, 0x14},
  76.     {0x4713, 0x30},
  77.     {0x478B, 0x10},
  78.     {0x478F, 0x10},
  79.     {0x4793, 0x10},
  80.     {0x4797, 0x0E},
  81.     {0x479B, 0x0E},
  82.     {IMX219_TABLE_END, 0x00}
  83. };
  84.  
  85. static imx219_reg imx219_mode_1920x1080_30fps[] = {
  86.     /* capture settings */
  87.     {0x0157, 0x00}, /* ANALOG_GAIN_GLOBAL[7:0] */
  88.     {0x015A, 0x06}, /* COARSE_INTEG_TIME[15:8] */
  89.     {0x015B, 0xde}, /* COARSE_INTEG_TIME[7:0] */
  90.     /* format settings */
  91.     {0x0160, 0x06}, /* FRM_LENGTH[15:8] */
  92.     {0x0161, 0xE2}, /* FRM_LENGTH[7:0] */
  93.     {0x0162, 0x0D}, /* LINE_LENGTH[15:8] */
  94.     {0x0163, 0x78}, /* LINE_LENGTH[7:0] */
  95.     {0x0164, 0x02},
  96.     {0x0165, 0xA8},
  97.     {0x0166, 0x0A},
  98.     {0x0167, 0x27},
  99.     {0x0168, 0x02},
  100.     {0x0169, 0xB4},
  101.     {0x016A, 0x06},
  102.     {0x016B, 0xEB},
  103.     {0x016C, 0x07},
  104.     {0x016D, 0x80},
  105.     {0x016E, 0x04},
  106.     {0x016F, 0x38},
  107.     {0x0170, 0x01},
  108.     {0x0171, 0x01},
  109.     {0x0174, 0x00},
  110.     {0x0175, 0x00},
  111.     {0x018C, 0x0A},
  112.     {0x018D, 0x0A},
  113.     /* clocks dividers */
  114.     {0x0301, 0x05},
  115.     {0x0303, 0x01},
  116.     {0x0304, 0x03},
  117.     {0x0305, 0x03},
  118.     {0x0306, 0x00},
  119.     {0x0307, 0x39},
  120.     {0x0309, 0x0A},
  121.     {0x030B, 0x01},
  122.     {0x030C, 0x00},
  123.     {0x030D, 0x72},
  124.     {IMX219_TABLE_END, 0x00}
  125. };
  126.  
  127. static imx219_reg imx219_mode_1640x1232_30fps[] = {
  128.     /* capture settings */
  129.     {0x0157, 0x00}, /* ANALOG_GAIN_GLOBAL[7:0] */
  130.     {0x015A, 0x06}, /* COARSE_INTEG_TIME[15:8] */
  131.     {0x015B, 0xA8}, /* COARSE_INTEG_TIME[7:0] */
  132.     /* format settings */
  133.     {0x0160, 0x06}, /* FRM_LENGTH[15:8] */
  134.     {0x0161, 0xE2}, /* FRM_LENGTH[7:0] */
  135.     {0x0162, 0x0D}, /* LINE_LENGTH[15:8] */
  136.     {0x0163, 0x78}, /* LINE_LENGTH[7:0] */
  137.     {0x0164, 0x00},
  138.     {0x0165, 0x00},
  139.     {0x0166, 0x0C},
  140.     {0x0167, 0xCF},
  141.     {0x0168, 0x00},
  142.     {0x0169, 0x00},
  143.     {0x016A, 0x09},
  144.     {0x016B, 0x9F},
  145.     {0x016C, 0x06},
  146.     {0x016D, 0x68},
  147.     {0x016E, 0x04},
  148.     {0x016F, 0xD0},
  149.     {0x0170, 0x01},
  150.     {0x0171, 0x01},
  151.     {0x0174, 0x01},
  152.     {0x0175, 0x01},
  153.     {0x018C, 0x0A},
  154.     {0x018D, 0x0A},
  155.     /* clocks dividers */
  156.     {0x0301, 0x05},
  157.     {0x0303, 0x01},
  158.     {0x0304, 0x03},
  159.     {0x0305, 0x03},
  160.     {0x0306, 0x00},
  161.     {0x0307, 0x39},
  162.     {0x0309, 0x0A},
  163.     {0x030B, 0x01},
  164.     {0x030C, 0x00},
  165.     {0x030D, 0x72},
  166.     {IMX219_TABLE_END, 0x00}
  167. };
  168.  
  169. static imx219_reg imx219_mode_1280x720_60fps[] = {
  170.     /* capture settings */
  171.     {0x0157, 0x00}, /* ANALOG_GAIN_GLOBAL[7:0] */
  172.     {0x015A, 0x03}, /* COARSE_INTEG_TIME[15:8] */
  173.     {0x015B, 0x6c}, /* COARSE_INTEG_TIME[7:0] */
  174.     /* format settings */
  175.     {0x0160, 0x03}, /* FRM_LENGTH[15:8] */
  176.     {0x0161, 0x70}, /* FRM_LENGTH[7:0] */
  177.     {0x0162, 0x0D}, /* LINE_LENGTH[15:8] */
  178.     {0x0163, 0x78}, /* LINE_LENGTH[7:0] */
  179.     {0x0164, 0x01},
  180.     {0x0165, 0x68},
  181.     {0x0166, 0x0B},
  182.     {0x0167, 0x67},
  183.     {0x0168, 0x02},
  184.     {0x0169, 0x00},
  185.     {0x016A, 0x07},
  186.     {0x016B, 0x9F},
  187.     {0x016C, 0x05},
  188.     {0x016D, 0x00},
  189.     {0x016E, 0x02},
  190.     {0x016F, 0xD0},
  191.     {0x0170, 0x01},
  192.     {0x0171, 0x01},
  193.     {0x0174, 0x01},
  194.     {0x0175, 0x01},
  195.     {0x018C, 0x0A},
  196.     {0x018D, 0x0A},
  197.     /* clocks dividers */
  198.     {0x0301, 0x05},
  199.     {0x0303, 0x01},
  200.     {0x0304, 0x03},
  201.     {0x0305, 0x03},
  202.     {0x0306, 0x00},
  203.     {0x0307, 0x39},
  204.     {0x0309, 0x0A},
  205.     {0x030B, 0x01},
  206.     {0x030C, 0x00},
  207.     {0x030D, 0x72},
  208.     {IMX219_TABLE_END, 0x00}
  209. };
  210.  
  211. enum {
  212.   IMX219_MODE_1920x1080_30FPS,
  213.   IMX219_MODE_1640x1232_30FPS,
  214.   IMX219_MODE_1280x720_60FPS,
  215.  
  216.   IMX219_MODE_COMMON,
  217.   IMX219_START_STREAM,
  218.   IMX219_STOP_STREAM,
  219. };
  220.  
  221. static imx219_reg *mode_table[] = {
  222.   [IMX219_MODE_1920x1080_30FPS] = imx219_mode_1920x1080_30fps,
  223.   [IMX219_MODE_1640x1232_30FPS] = imx219_mode_1640x1232_30fps,
  224.   [IMX219_MODE_1280x720_60FPS] = imx219_mode_1280x720_60fps,
  225.  
  226.   [IMX219_MODE_COMMON]  = imx219_mode_common,
  227.   [IMX219_START_STREAM]  = imx219_start_stream,
  228.   [IMX219_STOP_STREAM]  = imx219_stop_stream,
  229. };
  230.  
  231. static const int imx219_21fps[] = {
  232.     21,
  233. };
  234.  
  235. static const int imx219_28fps[] = {
  236.     28,
  237. };
  238.  
  239. static const int imx219_30fps[] = {
  240.     30,
  241. };
  242.  
  243. static const int imx219_60fps[] = {
  244.     60,
  245. };
  246.  
  247. /*
  248.  * WARNING: frmfmt ordering need to match mode definition in
  249.  * device tree!
  250.  */
  251. static const struct camera_common_frmfmt imx219_frmfmt[] = {
  252.   {{1920, 1080},    imx219_30fps, 1, 0, IMX219_MODE_1920x1080_30FPS},
  253.   {{1640, 1232},    imx219_30fps, 1, 0, IMX219_MODE_1640x1232_30FPS},
  254.   {{1280, 720}, imx219_60fps, 1, 0, IMX219_MODE_1280x720_60FPS},
  255. };
  256.  
  257. //--- from imx219_mode_tbls.h ---
  258.  
  259. static const struct of_device_id imx219_of_match[] = {
  260.     { .compatible = "nvidia,imx219", },
  261.     { },
  262. };
  263. MODULE_DEVICE_TABLE(of, imx219_of_match);
  264.  
  265. static const u32 ctrl_cid_list[] = {
  266.     TEGRA_CAMERA_CID_GAIN,
  267.     TEGRA_CAMERA_CID_EXPOSURE,
  268.     TEGRA_CAMERA_CID_FRAME_RATE,
  269.     TEGRA_CAMERA_CID_SENSOR_MODE_ID,
  270. };
  271.  
  272. struct imx219 {
  273.     struct i2c_client       *i2c_client;
  274.     struct v4l2_subdev      *subdev;
  275.     u16             fine_integ_time;
  276.     u32             frame_length;
  277.     struct camera_common_data   *s_data;
  278.     struct tegracam_device      *tc_dev;
  279. };
  280.  
  281. static const struct regmap_config sensor_regmap_config = {
  282.     .reg_bits = 16,
  283.     .val_bits = 8,
  284.     .cache_type = REGCACHE_RBTREE,
  285.     .use_single_rw = true,
  286. };
  287.  
  288. static inline void imx219_get_frame_length_regs(imx219_reg *regs,
  289.     u32 frame_length)
  290. {
  291.   printk("#PUSA : imx219_get_frame_length_regs");
  292.   regs->addr = IMX219_FRAME_LENGTH_ADDR_MSB;
  293.   regs->val = (frame_length >> 8) & 0xff;
  294.   (regs + 1)->addr = IMX219_FRAME_LENGTH_ADDR_LSB;
  295.   (regs + 1)->val = (frame_length) & 0xff;
  296. }
  297.  
  298. static inline void imx219_get_coarse_integ_time_regs(imx219_reg *regs,
  299.     u32 coarse_time)
  300. {
  301.  
  302.     regs->addr = IMX219_COARSE_INTEG_TIME_ADDR_MSB;
  303.     regs->val = (coarse_time >> 8) & 0xff;
  304.     (regs + 1)->addr = IMX219_COARSE_INTEG_TIME_ADDR_LSB;
  305.     (regs + 1)->val = (coarse_time) & 0xff;
  306.     printk("#IMX219 : imx219_get_coarse_integ_time_regs");
  307. }
  308.  
  309. static inline void imx219_get_gain_reg(imx219_reg *reg, u8 gain)
  310. {
  311.  
  312.     reg->addr = IMX219_GAIN_ADDR;
  313.     reg->val = gain & 0xff;
  314.     printk("#IMX219 : imx219_get_gain_reg");
  315. }
  316.  
  317. static inline int imx219_read_reg(struct camera_common_data *s_data,
  318.     u16 addr, u8 *val)
  319. {
  320.  
  321.     int err = 0;
  322.     u32 reg_val = 0;
  323.  
  324.     err = regmap_read(s_data->regmap, addr, &reg_val);
  325.     *val = reg_val & 0xff;
  326.  
  327.     printk("#IMX219 : imx219_read_reg");
  328.     return err;
  329. }
  330.  
  331. static inline int imx219_write_reg(struct camera_common_data *s_data,
  332.                    u16 addr, u8 val)
  333. {
  334.   int err = 0;
  335.  
  336.   printk("#PUSA219 : imx219_write_reg\n");
  337.   printk("#PUSA219 : imx219_write_reg : addr= %d, val= %d\n", addr, val);
  338.  
  339.   // To deal with i2c errors and warnings
  340.   if ((addr != 352 && val != 1) &&
  341.       (addr != 353 && val != 0)) {
  342.     err = regmap_write(s_data->regmap, addr, val);
  343.   } else {
  344.     err = 0;
  345.   }
  346.  
  347.   if (err)
  348.     dev_err(s_data->dev, "%s: i2c write failed, 0x%x = %x",
  349.         __func__, addr, val);
  350.  
  351.   return err;
  352. }
  353.  
  354. static int imx219_write_table(struct imx219 *priv, const imx219_reg table[])
  355. {
  356.   int tmp = 0;
  357.   int index = -1;
  358.   printk("#PUSA : imx219_write_table");
  359.   //  printk("#IMX219 : imx219_write_table : priv->s_data->regmap->name = %d",
  360.   //     priv->s_data->regmap->async_ret);
  361.   do {
  362.     index++;
  363.     printk("#PUSA : imx219_write_table : mode_table[IMX219_MODE_COMMON][%d] : addr = 0x%x, val = 0x%x",
  364.        index,
  365.        table[index].addr,
  366.        table[index].val);
  367.   } while ((table[index].addr != IMX219_TABLE_END) ||
  368.        (table[index].val != 0));
  369.  
  370.   tmp = regmap_util_write_table_8(priv->s_data->regmap, table, NULL, 0,
  371.                   IMX219_TABLE_WAIT_MS, IMX219_TABLE_END);
  372.   printk("#IMX219 : imx219_write_table : result = %d", tmp);
  373.   return tmp;
  374. }
  375.  
  376. static int imx219_set_group_hold(struct tegracam_device *tc_dev, bool val)
  377. {
  378.   printk("#IMX219 : imx219_set_group_hold");
  379.     /* imx219 does not support group hold */
  380.     return 0;
  381. }
  382.  
  383. static int imx219_get_fine_integ_time(struct imx219 *priv, u16 *fine_time)
  384. {
  385.  
  386.     struct camera_common_data *s_data = priv->s_data;
  387.     int err = 0;
  388.     u8 reg_val[2];
  389.  
  390.     printk("#PUSA : imx219_get_fine_integ_time\n");
  391.     goto done;
  392.    
  393.     err = imx219_read_reg(s_data, IMX219_FINE_INTEG_TIME_ADDR_MSB,
  394.         &reg_val[0]);
  395.     if (err){
  396.       printk("#PUSA : imx219_get_fine_integ_time : result = %d. Error!\n", err);
  397.       goto done;
  398.     }
  399.    
  400.     err = imx219_read_reg(s_data, IMX219_FINE_INTEG_TIME_ADDR_LSB,
  401.         &reg_val[1]);
  402.     if (err)
  403.         goto done;
  404.  
  405.     *fine_time = (reg_val[0] << 8) | reg_val[1];
  406.  
  407.     /* For IMX219 fine_time = 500 */
  408.     //printk("#IMX219 : imx219_get_fine_integ_time time = %d", *fine_time);
  409.  
  410.    
  411. done:
  412.     /* Just workaround */
  413.     *fine_time = 500;
  414.     err = 0;
  415.    
  416.     return err;
  417. }
  418.  
  419. static int imx219_set_gain(struct tegracam_device *tc_dev, s64 val)
  420. {
  421.  
  422.     struct camera_common_data *s_data = tc_dev->s_data;
  423.     struct device *dev = s_data->dev;
  424.     const struct sensor_mode_properties *mode =
  425.         &s_data->sensor_props.sensor_modes[s_data->mode_prop_idx];
  426.  
  427.     int err = 0;
  428.     imx219_reg gain_reg;
  429.     s16 gain;
  430.  
  431.     goto finish;
  432.    
  433.     if (val < mode->control_properties.min_gain_val)
  434.         val = mode->control_properties.min_gain_val;
  435.     else if (val > mode->control_properties.max_gain_val)
  436.         val = mode->control_properties.max_gain_val;
  437.  
  438.     /* translate value (from normalized analog gain) */
  439.     gain = (s16)((256 * mode->control_properties.gain_factor) / val);
  440.     gain = 256 - gain;
  441.  
  442.     if (gain < IMX219_MIN_GAIN)
  443.         gain = IMX219_MAX_GAIN;
  444.     else if (gain > IMX219_MAX_GAIN)
  445.         gain = IMX219_MAX_GAIN;
  446.  
  447.     dev_dbg(dev, "%s: val: %lld (/%d) [times], gain: %u\n",
  448.         __func__, val, mode->control_properties.gain_factor, gain);
  449.  
  450.     imx219_get_gain_reg(&gain_reg, (u8)gain);
  451.     err = imx219_write_reg(s_data, gain_reg.addr, gain_reg.val);
  452.     if (err)
  453.         dev_dbg(dev, "%s: gain control error\n", __func__);
  454.  
  455.     printk("#IMX219 : imx219_set_gain");
  456.    
  457.  finish:
  458.     return 0;
  459. }
  460.  
  461. static int imx219_set_frame_rate(struct tegracam_device *tc_dev, s64 val)
  462. {
  463.  
  464.     struct camera_common_data *s_data = tc_dev->s_data;
  465.     struct imx219 *priv = (struct imx219 *)tc_dev->priv;
  466.     struct device *dev = tc_dev->dev;
  467.     const struct sensor_mode_properties *mode =
  468.         &s_data->sensor_props.sensor_modes[s_data->mode_prop_idx];
  469.  
  470.     int err = 0;
  471.     imx219_reg fl_regs[2];
  472.     u32 frame_length;
  473.     int i;
  474.  
  475.     frame_length = (u32)(mode->signal_properties.pixel_clock.val *
  476.         (u64)mode->control_properties.framerate_factor /
  477.         mode->image_properties.line_length / val);
  478.  
  479.     if (frame_length < IMX219_MIN_FRAME_LENGTH)
  480.         frame_length = IMX219_MIN_FRAME_LENGTH;
  481.     else if (frame_length > IMX219_MAX_FRAME_LENGTH)
  482.         frame_length = IMX219_MAX_FRAME_LENGTH;
  483.  
  484.     dev_dbg(dev,
  485.         "%s: val: %llde-6 [fps], frame_length: %u [lines]\n",
  486.         __func__, val, frame_length);
  487.  
  488.     imx219_get_frame_length_regs(fl_regs, frame_length);
  489.     for (i = 0; i < 2; i++) {
  490.         err = imx219_write_reg(s_data, fl_regs[i].addr, fl_regs[i].val);
  491.         if (err) {
  492.             dev_dbg(dev,
  493.                 "%s: frame_length control error\n", __func__);
  494.             return err;
  495.         }
  496.     }
  497.  
  498.     priv->frame_length = frame_length;
  499.     printk("#IMX219 : imx219_set_frame_rate");
  500.    
  501.     return 0;
  502. }
  503.  
  504. static int imx219_set_exposure(struct tegracam_device *tc_dev, s64 val)
  505. {
  506.  
  507.     struct camera_common_data *s_data = tc_dev->s_data;
  508.     struct imx219 *priv = (struct imx219 *)tc_dev->priv;
  509.     struct device *dev = tc_dev->dev;
  510.     const struct sensor_mode_properties *mode =
  511.         &s_data->sensor_props.sensor_modes[s_data->mode_prop_idx];
  512.  
  513.     int err = 0;
  514.     imx219_reg ct_regs[2];
  515.     const s32 max_coarse_time = priv->frame_length - IMX219_MAX_COARSE_DIFF;
  516.     const s32 fine_integ_time_factor = priv->fine_integ_time *
  517.         mode->control_properties.exposure_factor /
  518.         mode->signal_properties.pixel_clock.val;
  519.     u32 coarse_time;
  520.     int i;
  521.  
  522.     return 0;
  523.     coarse_time = (val - fine_integ_time_factor)
  524.         * mode->signal_properties.pixel_clock.val
  525.         / mode->control_properties.exposure_factor
  526.         / mode->image_properties.line_length;
  527.  
  528.     if (coarse_time < IMX219_MIN_COARSE_EXPOSURE)
  529.         coarse_time = IMX219_MIN_COARSE_EXPOSURE;
  530.     else if (coarse_time > max_coarse_time) {
  531.         coarse_time = max_coarse_time;
  532.         dev_dbg(dev,
  533.             "%s: exposure limited by frame_length: %d [lines]\n",
  534.             __func__, max_coarse_time);
  535.     }
  536.  
  537.     dev_dbg(dev, "%s: val: %lld [us], coarse_time: %d [lines]\n",
  538.         __func__, val, coarse_time);
  539.  
  540.     imx219_get_coarse_integ_time_regs(ct_regs, coarse_time);
  541.  
  542.     for (i = 0; i < 2; i++) {
  543.         err = imx219_write_reg(s_data, ct_regs[i].addr, ct_regs[i].val);
  544.         if (err) {
  545.             dev_dbg(dev,
  546.                 "%s: coarse_time control error\n", __func__);
  547.             return err;
  548.         }
  549.     }
  550.     printk("#IMX219 : imx219_set_exposure");
  551.    
  552.     return 0;
  553. }
  554.  
  555. static struct tegracam_ctrl_ops imx219_ctrl_ops = {
  556.     .numctrls = ARRAY_SIZE(ctrl_cid_list),
  557.     .ctrl_cid_list = ctrl_cid_list,
  558.     .set_gain = imx219_set_gain,
  559.     .set_exposure = imx219_set_exposure,
  560.     .set_frame_rate = imx219_set_frame_rate,
  561.     .set_group_hold = imx219_set_group_hold,
  562. };
  563.  
  564. /* camera_common_data - various camera properties structure */
  565. static int imx219_power_on(struct camera_common_data *s_data)
  566. {
  567.  
  568.     int err = 0;
  569.  
  570.     struct camera_common_power_rail *pw = s_data->power;
  571.  
  572.     struct camera_common_pdata *pdata = s_data->pdata;
  573.     struct device *dev = s_data->dev;
  574.  
  575.     dev_dbg(dev, "%s: power on\n", __func__);
  576.     printk("#IMX219 : imx219_power_on");
  577.     printk("#IMX219 : imx219_power_on : pwdn_gpio = %d, reset_gpio = %d, af_gpio = %d",
  578.            s_data->pdata->pwdn_gpio, s_data->pdata->reset_gpio, s_data->pdata->af_gpio);
  579.     printk("#IMX219 : imx219_power_on : mclk_name = %s, parentclk_name = %s",
  580.            pdata->mclk_name, pdata->parentclk_name);
  581.     if (pdata && pdata->power_on) {
  582.         err = pdata->power_on(pw);
  583.         if (err)
  584.             dev_err(dev, "%s failed.\n", __func__);
  585.         else
  586.             pw->state = SWITCH_ON;
  587.         return err;
  588.     }
  589.  
  590.     if (pw->reset_gpio) {
  591.         if (gpio_cansleep(pw->reset_gpio))
  592.             gpio_set_value_cansleep(pw->reset_gpio, 0);
  593.         else
  594.             gpio_set_value(pw->reset_gpio, 0);
  595.     }
  596.  
  597.     if (unlikely(!(pw->avdd || pw->iovdd || pw->dvdd)))
  598.         goto skip_power_seqn;
  599.  
  600.     usleep_range(10, 20);
  601.  
  602.     if (pw->avdd) {
  603.         err = regulator_enable(pw->avdd);
  604.         if (err)
  605.             goto imx219_avdd_fail;
  606.     }
  607.  
  608.     if (pw->iovdd) {
  609.         err = regulator_enable(pw->iovdd);
  610.         if (err)
  611.             goto imx219_iovdd_fail;
  612.     }
  613.  
  614.     if (pw->dvdd) {
  615.         err = regulator_enable(pw->dvdd);
  616.         if (err)
  617.             goto imx219_dvdd_fail;
  618.     }
  619.  
  620.     usleep_range(10, 20);
  621.  
  622. skip_power_seqn:
  623.     if (pw->reset_gpio) {
  624.         if (gpio_cansleep(pw->reset_gpio))
  625.             gpio_set_value_cansleep(pw->reset_gpio, 1);
  626.         else
  627.             gpio_set_value(pw->reset_gpio, 1);
  628.     }
  629.  
  630.     /* Need to wait for t4 + t5 + t9 time as per the data sheet */
  631.     /* t4 - 200us, t5 - 21.2ms, t9 - 1.2ms */
  632.     usleep_range(23000, 23100);
  633.  
  634.     pw->state = SWITCH_ON;
  635.  
  636.     return 0;
  637.  
  638. imx219_dvdd_fail:
  639.     regulator_disable(pw->iovdd);
  640.  
  641. imx219_iovdd_fail:
  642.     regulator_disable(pw->avdd);
  643.  
  644. imx219_avdd_fail:
  645.     dev_err(dev, "%s failed.\n", __func__);
  646.  
  647.     return -ENODEV;
  648. }
  649.  
  650. static int imx219_power_off(struct camera_common_data *s_data)
  651. {
  652.  
  653.     int err = 0;
  654.     struct camera_common_power_rail *pw = s_data->power;
  655.     struct camera_common_pdata *pdata = s_data->pdata;
  656.     struct device *dev = s_data->dev;
  657.  
  658.     // for debug
  659.     return err;
  660.     // ---- for debug ----
  661.    
  662.     dev_dbg(dev, "%s: power off\n", __func__);
  663.     printk("#IMX219 : imx219_power_off");
  664.    
  665.     if (pdata && pdata->power_off) {
  666.         err = pdata->power_off(pw);
  667.         if (err) {
  668.             dev_err(dev, "%s failed.\n", __func__);
  669.             return err;
  670.         }
  671.     } else {
  672.         if (pw->reset_gpio) {
  673.             if (gpio_cansleep(pw->reset_gpio))
  674.                 gpio_set_value_cansleep(pw->reset_gpio, 0);
  675.             else
  676.                 gpio_set_value(pw->reset_gpio, 0);
  677.         }
  678.  
  679.         usleep_range(10, 10);
  680.  
  681.         if (pw->dvdd)
  682.             regulator_disable(pw->dvdd);
  683.         if (pw->iovdd)
  684.             regulator_disable(pw->iovdd);
  685.         if (pw->avdd)
  686.             regulator_disable(pw->avdd);
  687.     }
  688.  
  689.     pw->state = SWITCH_OFF;
  690.  
  691.     return 0;
  692. }
  693.  
  694. static int imx219_power_put(struct tegracam_device *tc_dev)
  695. {
  696.  
  697.     struct camera_common_data *s_data = tc_dev->s_data;
  698.     struct camera_common_power_rail *pw = s_data->power;
  699.  
  700.     if (unlikely(!pw))
  701.         return -EFAULT;
  702.  
  703.     if (likely(pw->dvdd))
  704.         devm_regulator_put(pw->dvdd);
  705.  
  706.     if (likely(pw->avdd))
  707.         devm_regulator_put(pw->avdd);
  708.  
  709.     if (likely(pw->iovdd))
  710.         devm_regulator_put(pw->iovdd);
  711.  
  712.     pw->dvdd = NULL;
  713.     pw->avdd = NULL;
  714.     pw->iovdd = NULL;
  715.  
  716.     if (likely(pw->reset_gpio))
  717.         gpio_free(pw->reset_gpio);
  718.     printk("#IMX219 : imx219_power_put");
  719.      
  720.     return 0;
  721. }
  722.  
  723. static int imx219_power_get(struct tegracam_device *tc_dev)
  724. {
  725.     struct device *dev = tc_dev->dev;
  726.     struct camera_common_data *s_data = tc_dev->s_data;
  727.     struct camera_common_power_rail *pw = s_data->power;
  728.     struct camera_common_pdata *pdata = s_data->pdata;
  729.     struct clk *parent;
  730.     int err = 0;
  731.  
  732.     printk("#PUSA : imx219_power_get");
  733.     if (!pdata) {
  734.       printk("#PUSA : imx219_power_get : pdata not found! Error!\n");
  735.       dev_err(dev, "pdata missing\n");
  736.       return -EFAULT;
  737.     }
  738.     printk("#PUSA : imx219_power_get : pdata found. Continue.\n");
  739.  
  740.     /* Sensor MCLK (aka. INCK) */
  741.     if (pdata->mclk_name) {
  742.       printk("#PUSA : imx219_power_get : pdata->mclk_name found.\n");
  743.         pw->mclk = devm_clk_get(dev, pdata->mclk_name);
  744.         if (IS_ERR(pw->mclk)) {
  745.             dev_err(dev, "unable to get clock %s\n",
  746.                 pdata->mclk_name);
  747.             return PTR_ERR(pw->mclk);
  748.         }
  749.  
  750.         if (pdata->parentclk_name) {
  751.             parent = devm_clk_get(dev, pdata->parentclk_name);
  752.             if (IS_ERR(parent)) {
  753.                 dev_err(dev, "unable to get parent clock %s",
  754.                     pdata->parentclk_name);
  755.             } else
  756.                 clk_set_parent(pw->mclk, parent);
  757.         }
  758.     } else {
  759.       printk("#PUSA : imx219_power_get : pdata->mclk_name not found.\n");
  760.     }
  761.  
  762.     /* analog 2.8v */
  763.     if (pdata->regulators.avdd) {
  764.       printk("#PUSA : imx219_power_get : pdata->regulators.avdd found.\n");
  765.       err |= camera_common_regulator_get(dev,
  766.                          &pw->avdd, pdata->regulators.avdd);
  767.     } else {
  768.       printk("#PUSA : imx219_power_get : pdata->regulators.avdd not found.\n");
  769.     }
  770.    
  771.     /* IO 1.8v */
  772.     if (pdata->regulators.iovdd) {
  773.       printk("#PUSA : imx219_power_get : pdata->regulators.iovdd found.\n");
  774.       err |= camera_common_regulator_get(dev,
  775.                          &pw->iovdd, pdata->regulators.iovdd);
  776.     } else {
  777.       printk("#PUSA : imx219_power_get : pdata->regulators.iovdd not found.\n");
  778.     }
  779.     /* dig 1.2v */
  780.     if (pdata->regulators.dvdd) {
  781.       printk("#PUSA : imx219_power_get : pdata->regulators.dvdd found.\n");
  782.       err |= camera_common_regulator_get(dev,
  783.                          &pw->dvdd, pdata->regulators.dvdd);
  784.     } else {
  785.       printk("#PUSA : imx219_power_get : pdata->regulators.dvdd not found.\n");
  786.     }
  787.    
  788.     if (err) {
  789.       printk("#PUSA : imx219_power_get : error= %d\n", err);
  790.       dev_err(dev, "%s: unable to get regulator(s)\n", __func__);
  791.       goto done;
  792.     } else {
  793.       printk("#PUSA : imx219_power_get : no error\n");
  794.     }
  795.  
  796.     /* Reset or ENABLE GPIO */
  797.     pw->reset_gpio = pdata->reset_gpio;
  798.     //err = gpio_request(pw->reset_gpio, "cam_reset_gpio");
  799.     err = 0;
  800.     if (err < 0) {
  801.       printk("#PUSA : imx219_power_get : gpio_request error= %d\n", err);
  802.       dev_err(dev, "%s: unable to request reset_gpio (%d)\n",
  803.           __func__, err);
  804.       goto done;
  805.     } else {
  806.       printk("#PUSA : imx219_power_get : gpio_request no error\n");
  807.     }
  808.  
  809. done:
  810.     pw->state = SWITCH_OFF;
  811.     printk("#PUSA : imx219_power_get : end of function\n");
  812.     return err;
  813. }
  814.  
  815. static struct camera_common_pdata *imx219_parse_dt(
  816.     struct tegracam_device *tc_dev)
  817. {
  818.  
  819.     struct device *dev = tc_dev->dev;
  820.     struct device_node *np = dev->of_node;
  821.     struct camera_common_pdata *board_priv_pdata;
  822.     const struct of_device_id *match;
  823.     struct camera_common_pdata *ret = NULL;
  824.     int err = 0;
  825.     int gpio;
  826.  
  827.     printk("#IMX219 : *imx219_parse_dt");
  828.     if (!np)
  829.         return NULL;
  830.  
  831.     match = of_match_device(imx219_of_match, dev);
  832.     if (!match) {
  833.         dev_err(dev, "Failed to find matching dt id\n");
  834.         return NULL;
  835.     }
  836.  
  837.     board_priv_pdata = devm_kzalloc(dev,
  838.         sizeof(*board_priv_pdata), GFP_KERNEL);
  839.     if (!board_priv_pdata)
  840.         return NULL;
  841.  
  842.     gpio = of_get_named_gpio(np, "reset-gpios", 0);
  843.     if (gpio < 0) {
  844.         if (gpio == -EPROBE_DEFER)
  845.             ret = ERR_PTR(-EPROBE_DEFER);
  846.         dev_err(dev, "reset-gpios not found\n");
  847.         goto error;
  848.     }
  849.     board_priv_pdata->reset_gpio = (unsigned int)gpio;
  850.  
  851.     err = of_property_read_string(np, "mclk", &board_priv_pdata->mclk_name);
  852.     if (err)
  853.         dev_dbg(dev, "mclk name not present, "
  854.             "assume sensor driven externally\n");
  855.  
  856.     err = of_property_read_string(np, "avdd-reg",
  857.         &board_priv_pdata->regulators.avdd);
  858.     err |= of_property_read_string(np, "iovdd-reg",
  859.         &board_priv_pdata->regulators.iovdd);
  860.     err |= of_property_read_string(np, "dvdd-reg",
  861.         &board_priv_pdata->regulators.dvdd);
  862.     if (err)
  863.         dev_dbg(dev, "avdd, iovdd and/or dvdd reglrs. not present, "
  864.             "assume sensor powered independently\n");
  865.  
  866.     board_priv_pdata->has_eeprom =
  867.         of_property_read_bool(np, "has-eeprom");
  868.  
  869.     return board_priv_pdata;
  870.  
  871. error:
  872.     devm_kfree(dev, board_priv_pdata);
  873.  
  874.     return ret;
  875. }
  876.  
  877. static int imx219_set_mode(struct tegracam_device *tc_dev)
  878. {
  879.  
  880.   int err = 0;
  881.   int index = 0;
  882.   printk("#PUSA : imx219_set_mode");
  883.  
  884.   index = -1;
  885.   do {
  886.     index++;
  887.     printk("#PUSA : imx219_set_mode : mode_table[IMX219_MODE_COMMON][%d] : addr = 0x%x, val = 0x%x",
  888.        index,
  889.        mode_table[IMX219_MODE_COMMON][index].addr,
  890.        mode_table[IMX219_MODE_COMMON][index].val);
  891.   } while ((mode_table[IMX219_MODE_COMMON][index].addr != IMX219_TABLE_END) ||
  892.        (mode_table[IMX219_MODE_COMMON][index].val != 0));
  893.  
  894.   printk("#PUSA : imx219_set_mode : err = %d", err);
  895.   if (err)
  896.     return err;
  897.  
  898.   printk("#PUSA : imx219_set_mode : err = %d", err);
  899.   if (err)
  900.     return err;
  901.  
  902.   return 0;
  903. }
  904.  
  905. static int imx219_start_streaming(struct tegracam_device *tc_dev)
  906. {
  907.   int res = 0;
  908.  
  909.   printk("#PUSA : imx219_start_streaming");
  910.   printk("#PUSA : imx219_start_streaming : result = %d", res);
  911.   return res;
  912. }
  913.  
  914. static int imx219_stop_streaming(struct tegracam_device *tc_dev)
  915. {
  916.     int err;
  917.  
  918.     struct imx219 *priv = (struct imx219 *)tegracam_get_privdata(tc_dev);
  919.  
  920.     /* --- debug ---*/
  921.     return 0;
  922.     /* --- debug ---*/
  923.  
  924.     err = imx219_write_table(priv, mode_table[IMX219_STOP_STREAM]);
  925.  
  926.     usleep_range(50000, 51000);
  927.     printk("#IMX219 : imx219_stop_streaming");
  928.    
  929.     return err;
  930. }
  931.  
  932. static struct camera_common_sensor_ops imx219_common_ops = {
  933.     .numfrmfmts = ARRAY_SIZE(imx219_frmfmt),
  934.     .frmfmt_table = imx219_frmfmt,
  935.     .power_on = imx219_power_on,
  936.     .power_off = imx219_power_off,
  937.     .write_reg = imx219_write_reg,
  938.     .read_reg = imx219_read_reg,
  939.     .parse_dt = imx219_parse_dt,
  940.     .power_get = imx219_power_get,
  941.     .power_put = imx219_power_put,
  942.     .set_mode = imx219_set_mode,
  943.     .start_streaming = imx219_start_streaming,
  944.     .stop_streaming = imx219_stop_streaming,
  945. };
  946.  
  947. static int imx219_board_setup(struct imx219 *priv)
  948. {
  949.  
  950.     struct camera_common_data *s_data = priv->s_data;
  951.     struct camera_common_pdata *pdata = s_data->pdata;
  952.     struct device *dev = s_data->dev;
  953.  
  954.     //u8 reg_val[2];
  955.     int err = 0;
  956.  
  957.     printk("#PUSA : imx219_board_setup");
  958.     if (pdata->mclk_name) {
  959.         err = camera_common_mclk_enable(s_data);
  960.         printk("#PUSA : imx219_board_setup : camera_common_mclk_enable result = %d\n", err);
  961.         if (err) {
  962.             dev_err(dev, "error turning on mclk (%d)\n", err);
  963.             goto done;
  964.         }
  965.     } else {
  966.       printk("#PUSA : imx219_board_setup : mclk_name not setted\n");
  967.     }
  968.  
  969.     err = imx219_power_on(s_data);
  970.     if (err) {
  971.       printk("#PUSA : imx219_board_setup : imx219_power_on result = %d. Error!\n", err);
  972.       dev_err(dev, "error during power on sensor (%d)\n", err);
  973.       goto err_power_on;
  974.     }
  975.     printk("#PUSA : imx219_board_setup : imx219_power_on result = %d."
  976.            " Power on is ok. Going on\n", err);
  977.    
  978.     /* Sensor fine integration time */
  979.     err = imx219_get_fine_integ_time(priv, &priv->fine_integ_time);
  980.     if (err) {
  981.       dev_err(dev, "%s: error querying sensor fine integ. time\n",
  982.           __func__);
  983.       printk("#PUSA : imx219_board_setup : imx219_get_fine_integ_time result = %d."
  984.          " Error!\n", err);
  985.      
  986.     }
  987.  
  988.     goto err_reg_probe;
  989.    
  990. err_reg_probe:
  991.     imx219_power_off(s_data);
  992.  
  993. err_power_on:
  994.     if (pdata->mclk_name)
  995.         camera_common_mclk_disable(s_data);
  996.  
  997. done:
  998.     return err;
  999. }
  1000.  
  1001. static int imx219_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
  1002. {
  1003.  
  1004.     struct i2c_client *client = v4l2_get_subdevdata(sd);
  1005.  
  1006.     dev_dbg(&client->dev, "%s:\n", __func__);
  1007.     printk("#IMX219 : imx219_open");
  1008.    
  1009.     return 0;
  1010. }
  1011.  
  1012. static const struct v4l2_subdev_internal_ops imx219_subdev_internal_ops = {
  1013.     .open = imx219_open,
  1014. };
  1015.  
  1016. static int imx219_probe(struct i2c_client *client,
  1017.             const struct i2c_device_id *id)
  1018. {
  1019.  
  1020.   struct device *dev = &client->dev;
  1021.   struct tegracam_device *tc_dev;
  1022.   struct imx219 *priv;
  1023.   int err;
  1024.  
  1025.   dev_dbg(dev, "probing v4l2 sensor at addr 0x%0x\n", client->addr);
  1026.   printk("#PUSA : imx219_probe");
  1027.   printk("#PUSA : imx219_probe : probing v4l2 sensor at addr 0x%0x", client->addr);
  1028.  
  1029.   if (!IS_ENABLED(CONFIG_OF) || !client->dev.of_node) {
  1030.     printk("#PUSA : imx219_probe : not enabled CONFIG_OF or not set client->dev.of_node. Stop");
  1031.     return -EINVAL;
  1032.   }
  1033.   printk("#PUSA : imx219_probe : enabled CONFIG_OF or set client->dev.of_node. Continue.");
  1034.  
  1035.   printk("#PUSA : imx219_probe : trying to allocate size for structure imx219, variable [priv]");
  1036.   priv = devm_kzalloc(dev,
  1037.               sizeof(struct imx219), GFP_KERNEL);
  1038.   if (!priv) {
  1039.     printk("#PUSA : imx219_probe : no such space for structure. Error!");
  1040.     return -ENOMEM;
  1041.   }
  1042.   printk("#PUSA : imx219_probe : memory allocated. Continue.");
  1043.  
  1044.   printk("#PUSA : imx219_probe : trying to allocate size for structure tegracam_device, variable [tc_dev].");
  1045.   tc_dev = devm_kzalloc(dev,
  1046.             sizeof(struct tegracam_device), GFP_KERNEL);
  1047.   if (!tc_dev) {
  1048.     printk("#PUSA : imx219_probe : no such space for structure. Error!");
  1049.     return -ENOMEM;
  1050.   }
  1051.   printk("#PUSA : imx219_probe : memory for tc_dev allocated. Continue.");
  1052.  
  1053.   priv->i2c_client = tc_dev->client = client;
  1054.   tc_dev->dev = dev;
  1055.   strncpy(tc_dev->name, "imx219", sizeof(tc_dev->name));
  1056.   tc_dev->dev_regmap_config = &sensor_regmap_config;
  1057.   tc_dev->sensor_ops = &imx219_common_ops;
  1058.   tc_dev->v4l2sd_internal_ops = &imx219_subdev_internal_ops;
  1059.   tc_dev->tcctrl_ops = &imx219_ctrl_ops;
  1060.  
  1061.   printk("#PUSA : imx219_probe : starting tegracam_device_register");
  1062.   err = tegracam_device_register(tc_dev);
  1063.   if (err) {
  1064.     printk("#PUSA : imx219_probe : tegracam_device_register error code = %d", err);
  1065.     dev_err(dev, "tegra camera driver registration failed\n");
  1066.     return err;
  1067.   } else {
  1068.     printk("#PUSA : imx219_probe : tegracam_device_register finished successfully. Continue.\n");
  1069.   }
  1070.  
  1071.   priv->tc_dev = tc_dev;
  1072.   priv->s_data = tc_dev->s_data;
  1073.   priv->subdev = &tc_dev->s_data->subdev;
  1074.   tegracam_set_privdata(tc_dev, (void *)priv);
  1075.  
  1076.   printk("#PUSA : imx219_probe : trying execute imx219_board_setup");
  1077.   err = imx219_board_setup(priv);
  1078.   printk("#PUSA : imx219_probe : imx219_board_setup error code = %d", err);
  1079.   if (err) {
  1080.     printk("#PUSA : imx219_probe : imx219_board_setup error code = %d", err);
  1081.     tegracam_device_unregister(tc_dev);
  1082.     dev_err(dev, "board setup failed\n");
  1083.     return err;
  1084.   }
  1085.  
  1086.   printk("#PUSA : imx219_probe : tegracam_v4l2subdev_register start\n");
  1087.   err = tegracam_v4l2subdev_register(tc_dev, true);
  1088.   if (err) {
  1089.     printk("#PUSA : imx219_probe : tegracam_v4l2subdev_register error code = %d\n", err);
  1090.     dev_err(dev, "tegra camera subdev registration failed\n");
  1091.     return err;
  1092.   } else {
  1093.     printk("#PUSA : imx219_probe : tegracam_v4l2subdev_register no error\n");
  1094.   }
  1095.  
  1096.   dev_dbg(dev, "detected imx219 sensor\n");
  1097.   printk("#PUSA : imx219_probe : detected imx219 sensor");
  1098.   return 0;
  1099. }
  1100.  
  1101. static int imx219_remove(struct i2c_client *client)
  1102. {
  1103.  
  1104.     struct camera_common_data *s_data = to_camera_common_data(&client->dev);
  1105.     struct imx219 *priv = (struct imx219 *)s_data->priv;
  1106.  
  1107.     tegracam_v4l2subdev_unregister(priv->tc_dev);
  1108.     tegracam_device_unregister(priv->tc_dev);
  1109.     printk("#IMX219 : imx219_remove");
  1110.    
  1111.     return 0;
  1112. }
  1113.  
  1114. static const struct i2c_device_id imx219_id[] = {
  1115.     { "imx219", 0 },
  1116.     { }
  1117. };
  1118.  
  1119. MODULE_DEVICE_TABLE(i2c, imx219_id);
  1120.  
  1121. static struct i2c_driver imx219_i2c_driver = {
  1122.     .driver = {
  1123.         .name = "pusa",
  1124.         .owner = THIS_MODULE,
  1125.         .of_match_table = of_match_ptr(imx219_of_match),
  1126.     },
  1127.     .probe = imx219_probe,
  1128.     .remove = imx219_remove,
  1129.     .id_table = imx219_id,
  1130. };
  1131.  
  1132. module_i2c_driver(imx219_i2c_driver);
  1133.  
  1134. MODULE_DESCRIPTION("Media Controller driver for Sony IMX219");
  1135. MODULE_AUTHOR("NVIDIA Corporation");
  1136. MODULE_LICENSE("GPL v2");
  1137.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!