drivers/video/fbdev/mxc/adv7535.c - linux-imx - Git at Google

 /*
  * Copyright 2017 NXP
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */

 #include <linux/device.h>
 #include <linux/i2c.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
 #include <linux/of_graph.h>
 #include <linux/pm_runtime.h>
 #include <video/mxc_edid.h>

 #include "mipi_dsi.h"

 /* main registers addr*/
 #define ADV7535_CHIP_REVISION		0x0
 #define ADV7535_DSI_CEC_ADDR		0xE1

 #define TEST_PATTERN_ENABLE    0

 struct adv7535_info {
 	int rev;
 	struct device *dev;
 	struct i2c_client *i2c_main;
 	struct i2c_client *i2c_dsi_cec;
 	struct fb_videomode *fb_vmode;
 	unsigned int bpp;
 };

 static int adv7535_probe(struct i2c_client *client,
 			 const struct i2c_device_id *id);
 static int adv7535_remove(struct i2c_client *client);
 static int adv7535_detect(struct i2c_client *client,
 			  struct i2c_board_info *info);

 static const struct i2c_device_id adv7535_id[] = {
 	{"adv7535", 0},
 	{},
 };
 MODULE_DEVICE_TABLE(i2c, adv7535_id);

 static const struct of_device_id adv7535_dt_ids[] = {
 	{ .compatible = "adi,adv7535", .data = NULL, },
 	{ /* sentinel */ }
 };

 static struct i2c_driver adv7535_i2c_driver = {
 	.driver = {
 		.name = "adv7535",
 		.owner = THIS_MODULE,
 		.of_match_table = adv7535_dt_ids,
 	},
 	.probe  = adv7535_probe,
 	.remove = adv7535_remove,
 	.id_table = adv7535_id,
 	.detect = adv7535_detect,
 };

 #define adv7535_write_reg(reg, val) {				\
 	int err;						\
 								\
 	err = i2c_smbus_write_byte_data(client, reg, val);	\
 	if (err < 0) {						\
 		dev_err(&client->dev,				\
 			"%s:write reg error:reg=%2x, val=%2x\n",\
 			__func__, reg, val);			\
 		return err;					\
 	}							\
 }								\

 static int adv7535_detect(struct i2c_client *client,
 			  struct i2c_board_info *info)
 {
 	s8 ret;
 	u8 chip_rev;
 	struct i2c_adapter *adapter = client->adapter;

 	/* check i2c functionality */
 	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C |
 					     I2C_FUNC_SMBUS_BYTE_DATA))
 		return -ENODEV;

 	/* i2c detection */
 	ret = i2c_smbus_read_byte_data(client,
 				       ADV7535_CHIP_REVISION);
 	if (ret < 0) {
 		dev_err(&adapter->dev, "ADV7535 not found\n");
 		return -ENODEV;
 	}

 	chip_rev = ret;
 	if (chip_rev != 0x14) {
 		dev_info(&adapter->dev, "Unsupported chip id: 0x%2x\n",
 			 chip_rev);
 		return -ENODEV;
 	}

 	dev_info(&adapter->dev, "chip_rev = 0x%x\n", ret);
 	return 0;
 }

 static int adv7535_setup_cfg(struct adv7535_info *info)
 {
 	struct i2c_client *client = NULL;

 	client = info->i2c_main;
 	adv7535_write_reg(0xd6, 0x48); /* HPD Override */
 	adv7535_write_reg(0x41, 0x10); /* Power Up   */

 	adv7535_write_reg(0x16, 0x20); /* Fixed Init */
 	adv7535_write_reg(0x9A, 0xE0);
 	adv7535_write_reg(0xBA, 0x70);
 	adv7535_write_reg(0xDE, 0x82);
 	adv7535_write_reg(0xE4, 0x40);
 	adv7535_write_reg(0xE5, 0x80);

 	client = info->i2c_dsi_cec;
 	adv7535_write_reg(0x15, 0xD0);
 	adv7535_write_reg(0x17, 0xD0);
 	adv7535_write_reg(0x24, 0x20);
 	adv7535_write_reg(0x57, 0x11);

 	return 0;
 }

 static int adv7535_vmode_cfg(struct adv7535_info *info)
 {
 	struct i2c_client *client = NULL;
 	struct fb_videomode *fb_vmode = info->fb_vmode;
 	u32 line_length, frame_height;
 	u8 low, high;

 	line_length  = fb_vmode->xres + fb_vmode->left_margin +
 		       fb_vmode->right_margin + fb_vmode->hsync_len;
 	frame_height = fb_vmode->yres + fb_vmode->upper_margin +
 		       fb_vmode->lower_margin + fb_vmode->vsync_len;

 	client = info->i2c_dsi_cec;
 #ifdef CONFIG_FB_IMX64
 	adv7535_write_reg(0x1C, 0x40); /* 4 Data Lanes */
 #else
 	adv7535_write_reg(0x1C, 0x20); /* 2 Data Lanes */
 #endif

 #if TEST_PATTERN_ENABLE
 	adv7535_write_reg(0x55, 0x80);
 	adv7535_write_reg(0x16, 0x1C);
 #else
 	adv7535_write_reg(0x16, 0x00); /* Pixel Clock  */
 #endif
 	adv7535_write_reg(0x27, 0xCB); /* INT_TIMING_GEN */

 	/* video mode settings */
 	low  = (line_length << 4);
 	high = (line_length >> 4);
 	adv7535_write_reg(0x28, high); /* Total Line Length */
 	adv7535_write_reg(0x29, low);

 	low  = (fb_vmode->hsync_len << 4);
 	high = (fb_vmode->hsync_len >> 4);
 	adv7535_write_reg(0x2A, high); /* Hsync Active Width */
 	adv7535_write_reg(0x2B, low);

 	low  = (fb_vmode->right_margin << 4);
 	high = (fb_vmode->right_margin >> 4);
 	adv7535_write_reg(0x2C, high); /* Horizontal FP Width */
 	adv7535_write_reg(0x2D, low);

 	low  = (fb_vmode->left_margin << 4);
 	high = (fb_vmode->left_margin >> 4);
 	adv7535_write_reg(0x2E, high); /* Horizontal BP Width */
 	adv7535_write_reg(0x2F, low);

 	low  = (frame_height << 4);
 	high = (frame_height >> 4);
 	adv7535_write_reg(0x30, high); /* Total Frame Height */
 	adv7535_write_reg(0x31, low);

 	low  = (fb_vmode->vsync_len << 4);
 	high = (fb_vmode->vsync_len >> 4);
 	adv7535_write_reg(0x32, high); /* Vsync Active Height */
 	adv7535_write_reg(0x33, low);

 	low  = (fb_vmode->lower_margin << 4);
 	high = (fb_vmode->lower_margin >> 4);
 	adv7535_write_reg(0x34, high); /* Vertical FP Height */
 	adv7535_write_reg(0x35, low);

 	low  = (fb_vmode->upper_margin << 4);
 	high = (fb_vmode->upper_margin >> 4);
 	adv7535_write_reg(0x36, high); /* Vertical BP Height */
 	adv7535_write_reg(0x37, low);

 	/* Reset Internal Timing Generator */
 	adv7535_write_reg(0x27, 0xCB);
 	adv7535_write_reg(0x27, 0x8B);
 	adv7535_write_reg(0x27, 0xCB);

 	client = info->i2c_main;
 	adv7535_write_reg(0xAF, 0x16); /* HDMI Output */
 	adv7535_write_reg(0x55, 0x10); /* AVI Info-frame */
 #ifdef CONFIG_FB_IMX64
 	adv7535_write_reg(0x56, 0x28); /* 16:9 */
 #else
 	adv7535_write_reg(0x56, 0x18);
 #endif
 	adv7535_write_reg(0x40, 0x80); /* GCP Enable */
 	adv7535_write_reg(0x4C, 0x04); /* 24bpp */
 	adv7535_write_reg(0x49, 0x00);

 #ifdef CONFIG_FB_IMX64
 	/* low refresh rate */
 	if (fb_vmode->refresh < 50)
 		adv7535_write_reg(0x4A, 0x8C);
 #else
 	adv7535_write_reg(0x17, 0x60); /* VS & HS Low Polarity, DE disabled */
 #endif

 	/*TODO Audio Setup */

 	client = info->i2c_dsi_cec;
 	adv7535_write_reg(0xBE, 0x3D); /* CEC Power Mode */

 	adv7535_write_reg(0x03, 0x89);

 	return 0;
 }

 static int adv7535_probe(struct i2c_client *client,
 			 const struct i2c_device_id *id)
 {
 	u32 vmode_index;
 	int ret = 0, addr;
 	struct adv7535_info *info;
 	struct device *dev = &client->dev;
 	struct device_node *endpoint = NULL;

 	pr_info("adv7535 probing phase\n");
 	info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);

 	if (!info)
 		return -ENOMEM;

 	info->dev = &client->dev;
 	info->i2c_main = client;
 	i2c_set_clientdata(client, info);

 	dev_info(dev, "main addr = 0x%x\n", info->i2c_main->addr);
 	/* get dsi source endpoint */
 	endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
 	if (!endpoint) {
 		dev_err(dev, "DSI source endpoint not exsit\n");
 		ret = -ENODEV;
 		goto err1;
 	}

 	info->fb_vmode = devm_kzalloc(dev, sizeof(struct fb_videomode),
 				      GFP_KERNEL);
 	if (!info->fb_vmode) {
 		ret = -ENOMEM;
 		goto err1;
 	}

 	ret = of_property_read_u32(dev->of_node, "video-mode", &vmode_index);
 	if (ret < 0) {
 		dev_err(dev, "failed to get required video mode\n");
 		goto err2;
 	}
 	if (vmode_index >= ARRAY_SIZE(mxc_cea_mode))
 		goto err2;

 	memcpy(info->fb_vmode, &mxc_cea_mode[vmode_index],
 	       sizeof(struct fb_videomode));

 	ret = of_property_read_u32(dev->of_node, "bpp", &info->bpp);
 	if (ret < 0) {
 		dev_err(dev, "failed to get bpp\n");
 		goto err2;
 	}

 	if ((ret = adv7535_detect(client, NULL)))
 		goto err2;

 	addr = i2c_smbus_read_byte_data(client,
 					ADV7535_DSI_CEC_ADDR);
 	if (addr < 0) {
 		dev_err(dev, "Cannot get dsi_cec addr\n");
 		ret = addr;
 		goto err2;
 	}

 	dev_info(dev, "dsi cec addr = 0x%x\n", addr);
 	info->i2c_dsi_cec = i2c_new_dummy(client->adapter, addr >> 1);
 	if (!info->i2c_dsi_cec) {
 		dev_err(dev, "Failed to allocate I2C device for dsi_cec\n");
 		ret = -ENOMEM;
 		goto err2;
 	}

 	i2c_set_clientdata(info->i2c_dsi_cec, info);

 	/*TODO interrupts */

 	if ((ret = adv7535_setup_cfg(info)))
 		goto err3;

 	if ((ret = adv7535_vmode_cfg(info)))
 		goto err3;

 #ifndef CONFIG_FB_IMX64
 	pm_runtime_enable(info->dev);
 #endif

 	dev_info(dev, "adv7535 probe finished\n");

 	return 0;
 err3:
 	i2c_unregister_device(info->i2c_dsi_cec);
 err2:
 	devm_kfree(dev, info->fb_vmode);
 err1:
 	devm_kfree(dev, info);

 	return ret;
 }

 static int adv7535_remove(struct i2c_client *client)
 {
 	struct adv7535_info *info;

 	info = i2c_get_clientdata(client);
 	i2c_set_clientdata(client, NULL);

 #ifndef CONFIG_FB_IMX64
 	pm_runtime_disable(info->dev);
 #endif

 	i2c_unregister_device(info->i2c_dsi_cec);

 	kfree(info->fb_vmode);
 	kfree(info);

 	return 0;
 }

 static __init int adv7535_init(void)
 {
 	u8 err = 0;


 	err = i2c_add_driver(&adv7535_i2c_driver);
 	if (err != 0)
 		pr_err("%s: i2c driver register failed, error = %d\n",
 			__func__, err);

 	pr_debug("%s (ret=%d)\n", __func__, err);
 	return err;
 }

 static void __exit adv7535_exit(void)
 {
 	i2c_del_driver(&adv7535_i2c_driver);
 }

 module_init(adv7535_init);
 module_exit(adv7535_exit);

 MODULE_AUTHOR("NXP Semiconductor");
 MODULE_DESCRIPTION("ADV7535 video encoder driver");
 MODULE_LICENSE("GPL");
	/*
	* Copyright 2017 NXP
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*/

	#include <linux/device.h>
	#include <linux/i2c.h>
	#include <linux/init.h>
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/of_device.h>
	#include <linux/of_graph.h>
	#include <linux/pm_runtime.h>
	#include <video/mxc_edid.h>

	#include "mipi_dsi.h"

	/* main registers addr*/
	#define ADV7535_CHIP_REVISION 0x0
	#define ADV7535_DSI_CEC_ADDR 0xE1

	#define TEST_PATTERN_ENABLE 0

	struct adv7535_info {
	int rev;
	struct device *dev;
	struct i2c_client *i2c_main;
	struct i2c_client *i2c_dsi_cec;
	struct fb_videomode *fb_vmode;
	unsigned int bpp;
	};

	static int adv7535_probe(struct i2c_client *client,
	const struct i2c_device_id *id);
	static int adv7535_remove(struct i2c_client *client);
	static int adv7535_detect(struct i2c_client *client,
	struct i2c_board_info *info);

	static const struct i2c_device_id adv7535_id[] = {
	{"adv7535", 0},
	{},
	};
	MODULE_DEVICE_TABLE(i2c, adv7535_id);

	static const struct of_device_id adv7535_dt_ids[] = {
	{ .compatible = "adi,adv7535", .data = NULL, },
	{ /* sentinel */ }
	};

	static struct i2c_driver adv7535_i2c_driver = {
	.driver = {
	.name = "adv7535",
	.owner = THIS_MODULE,
	.of_match_table = adv7535_dt_ids,
	},
	.probe = adv7535_probe,
	.remove = adv7535_remove,
	.id_table = adv7535_id,
	.detect = adv7535_detect,
	};

	#define adv7535_write_reg(reg, val) { \
	int err; \
	\
	err = i2c_smbus_write_byte_data(client, reg, val); \
	if (err < 0) { \
	dev_err(&client->dev, \
	"%s:write reg error:reg=%2x, val=%2x\n",\
	__func__, reg, val); \
	return err; \
	} \
	} \

	static int adv7535_detect(struct i2c_client *client,
	struct i2c_board_info *info)
	{
	s8 ret;
	u8 chip_rev;
	struct i2c_adapter *adapter = client->adapter;

	/* check i2c functionality */
	if (!i2c_check_functionality(adapter, I2C_FUNC_I2C \|
	I2C_FUNC_SMBUS_BYTE_DATA))
	return -ENODEV;

	/* i2c detection */
	ret = i2c_smbus_read_byte_data(client,
	ADV7535_CHIP_REVISION);
	if (ret < 0) {
	dev_err(&adapter->dev, "ADV7535 not found\n");
	return -ENODEV;
	}

	chip_rev = ret;
	if (chip_rev != 0x14) {
	dev_info(&adapter->dev, "Unsupported chip id: 0x%2x\n",
	chip_rev);
	return -ENODEV;
	}

	dev_info(&adapter->dev, "chip_rev = 0x%x\n", ret);
	return 0;
	}

	static int adv7535_setup_cfg(struct adv7535_info *info)
	{
	struct i2c_client *client = NULL;

	client = info->i2c_main;
	adv7535_write_reg(0xd6, 0x48); /* HPD Override */
	adv7535_write_reg(0x41, 0x10); /* Power Up */

	adv7535_write_reg(0x16, 0x20); /* Fixed Init */
	adv7535_write_reg(0x9A, 0xE0);
	adv7535_write_reg(0xBA, 0x70);
	adv7535_write_reg(0xDE, 0x82);
	adv7535_write_reg(0xE4, 0x40);
	adv7535_write_reg(0xE5, 0x80);

	client = info->i2c_dsi_cec;
	adv7535_write_reg(0x15, 0xD0);
	adv7535_write_reg(0x17, 0xD0);
	adv7535_write_reg(0x24, 0x20);
	adv7535_write_reg(0x57, 0x11);

	return 0;
	}

	static int adv7535_vmode_cfg(struct adv7535_info *info)
	{
	struct i2c_client *client = NULL;
	struct fb_videomode *fb_vmode = info->fb_vmode;
	u32 line_length, frame_height;
	u8 low, high;

	line_length = fb_vmode->xres + fb_vmode->left_margin +
	fb_vmode->right_margin + fb_vmode->hsync_len;
	frame_height = fb_vmode->yres + fb_vmode->upper_margin +
	fb_vmode->lower_margin + fb_vmode->vsync_len;

	client = info->i2c_dsi_cec;
	#ifdef CONFIG_FB_IMX64
	adv7535_write_reg(0x1C, 0x40); /* 4 Data Lanes */
	#else
	adv7535_write_reg(0x1C, 0x20); /* 2 Data Lanes */
	#endif

	#if TEST_PATTERN_ENABLE
	adv7535_write_reg(0x55, 0x80);
	adv7535_write_reg(0x16, 0x1C);
	#else
	adv7535_write_reg(0x16, 0x00); /* Pixel Clock */
	#endif
	adv7535_write_reg(0x27, 0xCB); /* INT_TIMING_GEN */

	/* video mode settings */
	low = (line_length << 4);
	high = (line_length >> 4);
	adv7535_write_reg(0x28, high); /* Total Line Length */
	adv7535_write_reg(0x29, low);

	low = (fb_vmode->hsync_len << 4);
	high = (fb_vmode->hsync_len >> 4);
	adv7535_write_reg(0x2A, high); /* Hsync Active Width */
	adv7535_write_reg(0x2B, low);

	low = (fb_vmode->right_margin << 4);
	high = (fb_vmode->right_margin >> 4);
	adv7535_write_reg(0x2C, high); /* Horizontal FP Width */
	adv7535_write_reg(0x2D, low);

	low = (fb_vmode->left_margin << 4);
	high = (fb_vmode->left_margin >> 4);
	adv7535_write_reg(0x2E, high); /* Horizontal BP Width */
	adv7535_write_reg(0x2F, low);

	low = (frame_height << 4);
	high = (frame_height >> 4);
	adv7535_write_reg(0x30, high); /* Total Frame Height */
	adv7535_write_reg(0x31, low);

	low = (fb_vmode->vsync_len << 4);
	high = (fb_vmode->vsync_len >> 4);
	adv7535_write_reg(0x32, high); /* Vsync Active Height */
	adv7535_write_reg(0x33, low);

	low = (fb_vmode->lower_margin << 4);
	high = (fb_vmode->lower_margin >> 4);
	adv7535_write_reg(0x34, high); /* Vertical FP Height */
	adv7535_write_reg(0x35, low);

	low = (fb_vmode->upper_margin << 4);
	high = (fb_vmode->upper_margin >> 4);
	adv7535_write_reg(0x36, high); /* Vertical BP Height */
	adv7535_write_reg(0x37, low);

	/* Reset Internal Timing Generator */
	adv7535_write_reg(0x27, 0xCB);
	adv7535_write_reg(0x27, 0x8B);
	adv7535_write_reg(0x27, 0xCB);

	client = info->i2c_main;
	adv7535_write_reg(0xAF, 0x16); /* HDMI Output */
	adv7535_write_reg(0x55, 0x10); /* AVI Info-frame */
	#ifdef CONFIG_FB_IMX64
	adv7535_write_reg(0x56, 0x28); /* 16:9 */
	#else
	adv7535_write_reg(0x56, 0x18);
	#endif
	adv7535_write_reg(0x40, 0x80); /* GCP Enable */
	adv7535_write_reg(0x4C, 0x04); /* 24bpp */
	adv7535_write_reg(0x49, 0x00);

	#ifdef CONFIG_FB_IMX64
	/* low refresh rate */
	if (fb_vmode->refresh < 50)
	adv7535_write_reg(0x4A, 0x8C);
	#else
	adv7535_write_reg(0x17, 0x60); /* VS & HS Low Polarity, DE disabled */
	#endif

	/TODO Audio Setup /

	client = info->i2c_dsi_cec;
	adv7535_write_reg(0xBE, 0x3D); /* CEC Power Mode */

	adv7535_write_reg(0x03, 0x89);

	return 0;
	}

	static int adv7535_probe(struct i2c_client *client,
	const struct i2c_device_id *id)
	{
	u32 vmode_index;
	int ret = 0, addr;
	struct adv7535_info *info;
	struct device *dev = &client->dev;
	struct device_node *endpoint = NULL;

	pr_info("adv7535 probing phase\n");
	info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);

	if (!info)
	return -ENOMEM;

	info->dev = &client->dev;
	info->i2c_main = client;
	i2c_set_clientdata(client, info);

	dev_info(dev, "main addr = 0x%x\n", info->i2c_main->addr);
	/* get dsi source endpoint */
	endpoint = of_graph_get_next_endpoint(dev->of_node, NULL);
	if (!endpoint) {
	dev_err(dev, "DSI source endpoint not exsit\n");
	ret = -ENODEV;
	goto err1;
	}

	info->fb_vmode = devm_kzalloc(dev, sizeof(struct fb_videomode),
	GFP_KERNEL);
	if (!info->fb_vmode) {
	ret = -ENOMEM;
	goto err1;
	}

	ret = of_property_read_u32(dev->of_node, "video-mode", &vmode_index);
	if (ret < 0) {
	dev_err(dev, "failed to get required video mode\n");
	goto err2;
	}
	if (vmode_index >= ARRAY_SIZE(mxc_cea_mode))
	goto err2;

	memcpy(info->fb_vmode, &mxc_cea_mode[vmode_index],
	sizeof(struct fb_videomode));

	ret = of_property_read_u32(dev->of_node, "bpp", &info->bpp);
	if (ret < 0) {
	dev_err(dev, "failed to get bpp\n");
	goto err2;
	}

	if ((ret = adv7535_detect(client, NULL)))
	goto err2;

	addr = i2c_smbus_read_byte_data(client,
	ADV7535_DSI_CEC_ADDR);
	if (addr < 0) {
	dev_err(dev, "Cannot get dsi_cec addr\n");
	ret = addr;
	goto err2;
	}

	dev_info(dev, "dsi cec addr = 0x%x\n", addr);
	info->i2c_dsi_cec = i2c_new_dummy(client->adapter, addr >> 1);
	if (!info->i2c_dsi_cec) {
	dev_err(dev, "Failed to allocate I2C device for dsi_cec\n");
	ret = -ENOMEM;
	goto err2;
	}

	i2c_set_clientdata(info->i2c_dsi_cec, info);

	/TODO interrupts /

	if ((ret = adv7535_setup_cfg(info)))
	goto err3;

	if ((ret = adv7535_vmode_cfg(info)))
	goto err3;

	#ifndef CONFIG_FB_IMX64
	pm_runtime_enable(info->dev);
	#endif

	dev_info(dev, "adv7535 probe finished\n");

	return 0;
	err3:
	i2c_unregister_device(info->i2c_dsi_cec);
	err2:
	devm_kfree(dev, info->fb_vmode);
	err1:
	devm_kfree(dev, info);

	return ret;
	}

	static int adv7535_remove(struct i2c_client *client)
	{
	struct adv7535_info *info;

	info = i2c_get_clientdata(client);
	i2c_set_clientdata(client, NULL);

	#ifndef CONFIG_FB_IMX64
	pm_runtime_disable(info->dev);
	#endif

	i2c_unregister_device(info->i2c_dsi_cec);

	kfree(info->fb_vmode);
	kfree(info);

	return 0;
	}

	static __init int adv7535_init(void)
	{
	u8 err = 0;


	err = i2c_add_driver(&adv7535_i2c_driver);
	if (err != 0)
	pr_err("%s: i2c driver register failed, error = %d\n",
	__func__, err);

	pr_debug("%s (ret=%d)\n", __func__, err);
	return err;
	}

	static void __exit adv7535_exit(void)
	{
	i2c_del_driver(&adv7535_i2c_driver);
	}

	module_init(adv7535_init);
	module_exit(adv7535_exit);

	MODULE_AUTHOR("NXP Semiconductor");
	MODULE_DESCRIPTION("ADV7535 video encoder driver");
	MODULE_LICENSE("GPL");