Digi Release Code - 02142011 Missing Files Fix2.6.31-digi-201102141503

1 files changed, 815 insertions, 0 deletions

diff --git a/drivers/video/mxc/ad9389.c b/drivers/video/mxc/ad9389.c
new file mode 100644
index 000000000000..9765cfd1a17f
--- /dev/null
+++ b/drivers/video/mxc/ad9389.c
@@ -0,0 +1,815 @@
+/*
+ * ad9389.c
+ *
+ * Copyright 2010 - Digi International, Inc. All Rights Reserved.
+ *
+ * Based on ad9889.c driver from Armadeus:
+ * Copyright (C) 2009 Armadeus Systems <nicolas.colombain@armadeus.com>
+ * And also on mxcfb_sii9022.c from Pegatron:
+ * Copyright 2009 Pegatron Corporation. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <linux/fb.h>
+#include <linux/console.h>
+#include <video/ad9389.h>
+
+#define HPD_INT			0x80
+#define MSEN_INT		0x40
+#define	VS_INT			0x20
+#define	AUDIO_FIFO_FULL_INT	0x10
+#define	ITU656_ERR_INT		0x08
+#define EDID_RDY_INT		0x04
+#define EDID_LENGTH		256
+#define DRV_NAME		"ad9389"
+
+
+#define DEBUG
+#define I2C_DBG			0x0001
+#define EDID_DBG		0x0002
+#define REGS_DBG		0x0004
+#define SCREEN_DBG		0x0008
+
+//int debug = I2C_DBG | EDID_DBG | REGS_DBG | SCREEN_DBG;
+int debug = 0;
+#define DBG(flag, fmt, args...)	do {							\
+					if (debug & flag)				\
+						printk(KERN_DEBUG fmt, ## args);	\
+				} while (0)
+
+struct ad9389_dev *pad9389;
+
+
+static inline int ad9389_read_reg(struct i2c_client *client, u8 reg)
+{
+	return i2c_smbus_read_byte_data(client, reg);
+}
+
+static inline int ad9389_write_reg(struct i2c_client *client, u8 reg, u8 val)
+{
+	DBG(I2C_DBG, "I2C WR[%02x] = %02x\n", reg, val);
+	return i2c_smbus_write_byte_data(client, reg, val);
+}
+
+static inline int ad9389_update_reg(struct i2c_client *client, u8 reg, u8 mask, u8 val)
+{
+	u8 regval = i2c_smbus_read_byte_data(client, reg);
+	regval &= ~mask;
+	regval |= val;
+	return ad9389_write_reg(client, reg, regval);
+}
+
+static void ad9389_set_av_mute(struct i2c_client *client, int mute)
+{
+	if (mute) {
+		ad9389_update_reg(client, 0x45, 0x40, 0x40);
+		ad9389_update_reg(client, 0x45, 0x80, 0);
+	} else {
+		ad9389_update_reg(client, 0x45, 0x40, 0x0);
+		ad9389_update_reg(client, 0x45, 0x80, 0x80);
+	}
+}
+
+static void ad9389_set_power_down(struct i2c_client *client, int powerd)
+{
+	ad9389_update_reg(client, 0x41, 0x40, powerd ? 0x40 : 0);
+}
+
+static int ad9389_disp_connected(struct i2c_client *client)
+{
+	return (ad9389_read_reg(client, 0x42) & 0x40) != 0;
+}
+
+static void ad9389_enable_i2s_ch(struct i2c_client *client, u8 enable, u8 ch)
+{
+	u8 mask;
+
+	if (ch > 3)
+		return;
+
+	mask = 0x04 << ch;
+	ad9389_update_reg(client, 0x0c, mask, enable ? mask : 0);
+}
+
+static int ad9389_is_enabled_i2s_ch(struct i2c_client *client, u8 ch)
+{
+	u8 mask;
+
+	if (ch > 3)
+		return -EINVAL;
+
+	mask = 0x04 << ch;
+	return (i2c_smbus_read_byte_data(client, 0x0c) & mask) != 0;
+}
+
+static void ad9389_set_i2s_sf(struct i2c_client *client, int sample_freq)
+{
+	ad9389_update_reg(client, 0x15, 0xf0, sample_freq << 4);
+}
+
+static void ad9389_set_hdmi_mode(struct i2c_client *client, int hdmi)
+{
+	ad9389_update_reg(client, 0xaf, 0x02, hdmi ? 0x02 : 0);
+}
+
+static void ad9389_set_if_cc(struct i2c_client *client, int chcnt)
+{
+	ad9389_update_reg(client, 0x50, 0xe0, chcnt << 5);
+}
+
+static void ad9389_set_spk_map(struct i2c_client *client, int map)
+{
+	ad9389_write_reg(client, 0x51, map);
+}
+
+static void ad9389_set_N(struct i2c_client *client, int N_val)
+{
+	ad9389_write_reg(client, 0x1, N_val >> 16);
+	ad9389_write_reg(client, 0x2, N_val >> 8);
+	ad9389_write_reg(client, 0x3, N_val & 0xff);
+}
+
+static int ad9389_get_N(struct i2c_client *client)
+{
+	int N_val;
+
+	N_val = (ad9389_read_reg(client, 0x1) & 0x0f) << 16;
+	N_val |= (ad9389_read_reg(client, 0x2) << 8);
+	N_val |= ad9389_read_reg(client, 0x3);
+
+	return N_val;
+}
+
+#ifdef USED
+static void ad9389_audio_set_CTS(struct i2c_client *client, int cts)
+{
+	ad9389_update_reg(client, 0x04, 0x0f, (cts >> 16) & 0x0f);
+	ad9389_write_reg(client, 0x05, cts >> 8);
+	ad9389_write_reg(client, 0x6, cts & 0xff);
+}
+
+static void ad9389_set_i2s_nbits(struct i2c_client *client, int bits)
+{
+	if (bits <= 24)
+		ad9389_write_reg(client, 0x0d, bits);
+}
+
+static void ad9389_set_low_freq_vrr(struct i2c_client *client, int lowf)
+{
+	ad9389_update_reg(client, 0x15, 0x01, lowf ? 1 : 0);
+}
+#endif
+
+#ifdef DEBUG
+static void ad9389_dump_edid(u8 *edid)
+{
+	int i;
+
+	if (!(debug & EDID_DBG))
+		return;
+
+	printk("\nEDID data:\n");
+	for (i = 0; i < EDID_LENGTH; i++) {
+		if (i % 8 == 0)
+			printk("\n");
+		printk("%02x ", edid[i]);
+	}
+	printk("\n");
+}
+
+static void ad9389_dump_regs(struct i2c_client *client)
+{
+	int i;
+
+	if (!(debug & REGS_DBG))
+		return;
+
+	printk("\nAD9389 regs:\n");
+	for (i = 0; i < EDID_LENGTH; i++) {
+		if (i % 8 == 0)
+			printk("\n%03x: ", i);
+		printk("%02x ", ad9389_read_reg(client, i));
+	}
+	printk(KERN_DEBUG "\n");
+}
+
+static void fb_dump_modeline( struct fb_videomode *modedb, int num)
+{
+	struct fb_videomode *mode;
+	int i;
+
+	if (!(debug & SCREEN_DBG))
+		return;
+
+	printk(KERN_DEBUG "Monitor/TV supported modelines:\n");
+
+	for (i = 0; i < num; i++) {
+		mode = &modedb[i];
+
+		printk("   \"%dx%d%s%d\" %lu.%02lu ",
+			mode->xres, mode->yres, (mode->vmode & FB_VMODE_INTERLACED) ? "i@" : "@", mode->refresh,
+			(PICOS2KHZ(mode->pixclock) * 1000UL)/1000000,
+			(PICOS2KHZ(mode->pixclock) ) % 1000);
+		printk("%d %d %d %d ",
+			mode->xres,
+			mode->xres + mode->right_margin,
+			mode->xres + mode->right_margin + mode->hsync_len,
+			mode->xres + mode->right_margin + mode->hsync_len + mode->left_margin );
+		printk("%d %d %d %d ",
+			mode->yres,
+			mode->yres + mode->lower_margin,
+			mode->yres + mode->lower_margin + mode->vsync_len,
+			mode->yres + mode->lower_margin + mode->vsync_len + mode->upper_margin );
+		printk("%shsync %svsync\n", (mode->sync & FB_SYNC_HOR_HIGH_ACT) ? "+" : "-",
+			   (mode->sync & FB_SYNC_VERT_HIGH_ACT) ? "+" : "-" );
+	}
+}
+#else
+static void ad9389_dump_edid(u8 *edid) {}
+static void ad9389_dump_regs(struct i2c_client *client) {}
+static void fb_dump_modeline( struct fb_videomode *modedb, int num) {}
+#endif
+
+static int ad9389_read_edid(struct i2c_client *client, u8 *edid)
+{
+	union i2c_smbus_data data;
+	struct ad9389_pdata *config = client->dev.platform_data;
+	struct ad9389_dev *ad9389 = i2c_get_clientdata(client);
+	u8 *pd;
+	int status, i;
+
+	for (i = 0, pd = edid; i < EDID_LENGTH/I2C_SMBUS_BLOCK_MAX; i++, pd += I2C_SMBUS_BLOCK_MAX) {
+		data.block[0] = I2C_SMBUS_BLOCK_MAX;
+		status = i2c_smbus_xfer(ad9389->edid_ram->adapter, config->edid_addr,
+					ad9389->edid_ram->flags,
+					I2C_SMBUS_READ, i*I2C_SMBUS_BLOCK_MAX,
+					I2C_SMBUS_I2C_BLOCK_DATA, &data);
+		if (status < 0)
+			return status;
+		memcpy(pd, &data.block[1], data.block[0]);
+	}
+
+	return 0;
+}
+
+static int ad9389_parse_edid(struct fb_var_screeninfo *einfo, u8 *edid, int *dvi)
+{
+	int ret;
+
+	if (einfo == NULL || edid == NULL || dvi == NULL)
+		return -EINVAL;
+
+	if (edid[1] == 0x00)
+		return -ENOENT;
+
+	/* Assume dvi if no CEA extension */
+	*dvi = 1;
+	if (edid[126] > 0) {
+		/* CEA extensions */
+		if (edid[128] == 0x02 && edid[131] & 0x40) {
+			*dvi = 0;
+		}
+	}
+
+	ret = fb_parse_edid(edid, einfo);
+	if (ret)
+		return -ret;
+
+	/* This is valid for version 1.3 of the EDID */
+	if ((edid[18] == 1) && (edid[19] == 3)) {
+		einfo->height = edid[21] * 10;
+		einfo->width = edid[22] * 10;
+	}
+
+	return 0;
+}
+
+static void ad9389_audio_setup(struct ad9389_dev *ad9389)
+{
+	struct i2c_client *client = ad9389->client;
+
+	/* disable I2S channels */
+	ad9389_enable_i2s_ch(client, 0, 0);
+	ad9389_enable_i2s_ch(client, 0, 1);
+	ad9389_enable_i2s_ch(client, 0, 2);
+	ad9389_enable_i2s_ch(client, 0, 3);
+
+	/* Set sample freq, currently hardcoded to 44KHz */
+	ad9389_set_i2s_sf(client, 0);
+
+	/* By default, enable i2s ch0. Can be modified through the sysfs */
+	ad9389_set_N(client, 6272);
+	ad9389_set_if_cc(client, 1);
+	ad9389_set_spk_map(client, 0);
+	ad9389_enable_i2s_ch(client, 1, 0);
+	ad9389_set_av_mute(client, 0);
+}
+
+
+static void ad9389_fb_init(struct fb_info *info)
+{
+	struct ad9389_dev *ad9389 = pad9389;
+	struct i2c_client *client = ad9389->client;
+	struct ad9389_pdata *pdata = client->dev.platform_data;
+	static struct fb_var_screeninfo var;
+	int ret = 0;
+
+	dev_info(info->dev, "%s\n", __func__);
+
+	if (!ad9389_disp_connected(client)) {
+		ad9389_set_power_down(client, 1);
+		if(pdata->disp_disconnected)
+			pdata->disp_disconnected(ad9389);
+		return;
+	}
+
+	if(pdata->disp_connected)
+		pdata->disp_connected(ad9389);
+
+	dev_info(info->dev, "%s, display connected\n", __func__);
+	memset(&var, 0, sizeof(var));
+
+	/* Disable Power down and set mute to on */
+	ad9389_set_power_down(client, 0);
+	ad9389_set_av_mute(client, 1);
+
+	/* set static reserved registers*/
+	ad9389_write_reg(client,0x0a, 0x01);
+	ad9389_write_reg(client, 0x98, 0x03);
+	ad9389_write_reg(client, 0x9C, 0x38);
+
+	/* Write magic numbers */
+	ad9389_write_reg(client, 0xA2, 0x87);
+	ad9389_write_reg(client, 0xA3, 0x87);
+
+	/* set capture edge */
+	ad9389_write_reg(client, 0xba, 0x60);
+	ad9389_write_reg(client, 0x47, 0x80);
+
+	mdelay(250);
+
+	ret = ad9389_read_edid(ad9389->client, ad9389->edid_data);
+	if (!ret) {
+		ad9389_dump_edid(ad9389->edid_data);
+		ret = ad9389_parse_edid(&var, ad9389->edid_data, &ad9389->dvi);
+		if (!ret) {
+			if (!ad9389->dvi) {
+				ad9389_set_hdmi_mode(client, 1);
+				/* FIXME audio setup should be done once we know the pixclock */
+				ad9389_audio_setup(ad9389);
+			}
+
+			fb_edid_to_monspecs(ad9389->edid_data, &info->monspecs);
+			if (info->monspecs.modedb_len) {
+				fb_dump_modeline(info->monspecs.modedb, info->monspecs.modedb_len);
+				if (pdata->vmode_to_modelist)
+					pdata->vmode_to_modelist(info->monspecs.modedb,
+								 info->monspecs.modedb_len,
+								 &info->modelist, &var);
+				else
+					fb_videomode_to_modelist(info->monspecs.modedb,
+								 info->monspecs.modedb_len,
+								 &info->modelist);
+			}
+		}
+	} else {
+		/* TODO */
+		printk(KERN_WARNING "NO EDID information found, using default mode?\n");
+	}
+
+	ad9389_dump_regs(client);
+
+	if (pdata->vmode_to_var)
+		pdata->vmode_to_var(ad9389, &var);
+
+	var.activate = FB_ACTIVATE_ALL;
+	acquire_console_sem();
+	info->flags |= FBINFO_MISC_USEREVENT;
+	fb_set_var(info, &var);
+	info->flags &= ~FBINFO_MISC_USEREVENT;
+	fb_blank(info, FB_BLANK_UNBLANK);
+	fb_show_logo(info, 0);
+	release_console_sem();
+}
+
+int ad9389_fb_event(struct notifier_block *nb, unsigned long val, void *v)
+{
+	return 0;
+}
+
+static void ad9389_work(struct work_struct *work)
+{
+	struct ad9389_dev *ad9389 = container_of(work, struct ad9389_dev, work);
+	struct i2c_client *client =  ad9389->client;
+	unsigned char irq_reg1;
+	unsigned char irq_reg2;
+
+	dev_dbg(&client->dev, "%s\n", __func__);
+
+	mutex_lock(&ad9389->irq_lock);
+
+	/* Interrupts are disabled here... */
+	irq_reg1 = ad9389_read_reg(client, 0x96);
+	irq_reg2 = ad9389_read_reg(client, 0x97);
+
+	while ((irq_reg1 & 0xc4) | (irq_reg2 & 0xc0)) {
+
+		dev_dbg(&client->dev, "IRQ register %02x/%02x\n",
+			irq_reg1, irq_reg2);
+
+		/* hot plug detections interrupt? */
+		if (irq_reg1 & HPD_INT) {
+			dev_dbg(&client->dev, "HPD irq\n");
+			ad9389_fb_init(ad9389->fbi);
+		}
+
+		/* check for EDID ready flag, then call EDID Handler */
+		if (irq_reg1 & EDID_RDY_INT) {
+			dev_dbg(&client->dev, "EDID_RDY_INT\n");
+		}
+
+		/* ack and check again */
+		ad9389_write_reg(client, 0x96, irq_reg1);
+		ad9389_write_reg(client, 0x97, irq_reg2);
+
+		irq_reg1 = ad9389_read_reg(client, 0x96);
+		irq_reg2 = ad9389_read_reg(client, 0x97);
+	}
+
+	mutex_unlock(&ad9389->irq_lock);
+}
+
+
+static irqreturn_t ad9389_handler(int irq, void *dev_id)
+{
+	struct ad9389_dev *dev = (struct ad9389_dev *) dev_id;
+
+	dev_dbg(&dev->client->dev, "%s\n", __func__);
+	schedule_work(&dev->work);
+
+	return IRQ_HANDLED;
+}
+
+static ssize_t ad9389_show_mute(struct device *dev, struct device_attribute *attr,
+				char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int read, ret = 0;
+
+	read = ad9389_read_reg(client, 0x45);
+	if (read & 0x40)
+		ret = snprintf(buf, PAGE_SIZE, "on");
+	else if (read & 0x80)
+	  	ret = snprintf(buf, PAGE_SIZE, "off");
+
+	return ret;
+}
+
+static ssize_t ad9389_store_mute(struct device *dev, struct device_attribute *attr,
+				 const char *buf, size_t count)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int mute;
+
+	if (!strcmp(buf, "on"))
+	      mute = 1;
+	else if (!strcmp(buf, "off"))
+	      mute = 0;
+	else
+	      return 0;
+
+	ad9389_set_av_mute(client, mute);
+
+	return count;
+}
+
+static ssize_t ad9389_show_N_param(struct device *dev, struct device_attribute *attr,
+				char *buf)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	int N_val;
+
+	N_val = ad9389_get_N(client);
+
+	return snprintf(buf, PAGE_SIZE, "%d", N_val);
+}
+
+static ssize_t ad9389_store_N_param(struct device *dev, struct device_attribute *attr,
+				 const char *buf, size_t count)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	unsigned long N_val;
+
+	N_val = simple_strtoul(buf, NULL, 10);
+	ad9389_set_N(client, N_val);
+
+	return count;
+}
+
+#define	ad9389_show_i2s_ch(num)						\
+static ssize_t ad9389_show_i2s_ch##num(struct device *dev,		\
+				   struct device_attribute *attr,	\
+				   char *buf)				\
+{									\
+	struct i2c_client *client = to_i2c_client(dev);			\
+	int read, ret = 0;						\
+	read = ad9389_is_enabled_i2s_ch(client, num);			\
+	if (read < 0)							\
+		ret = snprintf(buf, PAGE_SIZE, "error");		\
+	else if (read == 1)						\
+		ret = snprintf(buf, PAGE_SIZE, "on");			\
+	else 								\
+	  	ret = snprintf(buf, PAGE_SIZE, "off");			\
+	return ret;							\
+}
+
+#define	ad9389_store_i2s_ch(num)					\
+static ssize_t ad9389_store_i2s_ch##num(struct device *dev,		\
+				    struct device_attribute *attr,	\
+				    const char *buf, size_t count)	\
+{									\
+	struct i2c_client *client = to_i2c_client(dev);			\
+	int enable;							\
+	if (!strcmp(buf, "on"))						\
+		enable = 1;						\
+	else if (!strcmp(buf, "off"))					\
+		enable = 0;						\
+	else								\
+		return 0;						\
+	ad9389_enable_i2s_ch(client, enable, num);			\
+	return count;							\
+}
+
+#define audio_ch(num)			\
+	static DEVICE_ATTR(i2s_ch##num, S_IWUSR | S_IRUGO, ad9389_show_i2s_ch##num, ad9389_store_i2s_ch##num)
+
+static DEVICE_ATTR(mute, S_IWUSR | S_IRUGO, ad9389_show_mute, ad9389_store_mute);
+static DEVICE_ATTR(N_param, S_IWUSR | S_IRUGO, ad9389_show_N_param, ad9389_store_N_param);
+
+ad9389_show_i2s_ch(0)
+ad9389_show_i2s_ch(1)
+ad9389_show_i2s_ch(2)
+ad9389_show_i2s_ch(3)
+ad9389_store_i2s_ch(0)
+ad9389_store_i2s_ch(1)
+ad9389_store_i2s_ch(2)
+ad9389_store_i2s_ch(3)
+audio_ch(0);
+audio_ch(1);
+audio_ch(2);
+audio_ch(3);
+
+static struct attribute *ad9389_attributes[] = {
+	&dev_attr_mute.attr,
+	&dev_attr_i2s_ch0.attr,
+	&dev_attr_i2s_ch1.attr,
+	&dev_attr_i2s_ch2.attr,
+	&dev_attr_i2s_ch3.attr,
+	&dev_attr_N_param.attr,
+	NULL
+};
+
+static const struct attribute_group ad9389_attr_group = {
+	.attrs = ad9389_attributes,
+};
+
+static struct notifier_block nb = {
+	.notifier_call = ad9389_fb_event,
+};
+
+static int ad9389_probe(struct i2c_client *client,
+        const struct i2c_device_id *id)
+{
+	struct ad9389_pdata *pdata = client->dev.platform_data;
+	struct ad9389_dev *ad9389;
+	int ret = -EINVAL;
+
+	/* Sanity checks */
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+		return -EIO;
+
+	if (!pdata) {
+		printk(KERN_ERR DRV_NAME ": Platform data not supplied\n");
+		return -ENOENT;
+	}
+
+	if (!client->irq) {
+		printk(KERN_ERR DRV_NAME ": Invalid irq value\n");
+		return -ENOENT;
+	}
+
+	ad9389 = kzalloc(sizeof(struct ad9389_dev), GFP_KERNEL);
+	if (ad9389 == NULL)
+		return -ENOMEM;
+
+	ad9389->edid_data = kmalloc(EDID_LENGTH, GFP_KERNEL);
+	if (ad9389->edid_data == NULL) {
+		ret = -ENOMEM;
+		goto err_edid_alloc;
+	}
+
+	pad9389 = ad9389;
+	ad9389->client = client;
+	i2c_set_clientdata(client, ad9389);
+
+	INIT_WORK(&ad9389->work, ad9389_work);
+	mutex_init(&ad9389->irq_lock);
+	mutex_lock(&ad9389->irq_lock);
+
+	/* platform specific initialization (gpio, irq...) */
+	if (pdata->hw_init)
+		pdata->hw_init(ad9389);
+
+	ret = request_irq(client->irq, ad9389_handler,
+			  IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, DRV_NAME, ad9389);
+	if (ret < 0) {
+		printk(KERN_ERR DRV_NAME ": Could not allocate IRQ (n %d)\n", client->irq);
+		goto err_irq;
+	}
+
+	/**
+	 * There is no good way to detect if the chip is present. We assume that its present
+	 * because somebody answered (ack) on the device address...
+	 */
+	ret = ad9389_read_reg(client, 0x00);
+	if (ret < 0) {
+		printk(KERN_WARNING DRV_NAME ": i2c transfer error, (device present?)\n");
+		ret = -ENODEV;
+		goto err_presence;
+	}
+
+	ad9389->chiprev = (u8)ret;
+	ad9389->edid_ram = i2c_new_dummy(client->adapter, pdata->edid_addr);
+	if (!ad9389->edid_ram) {
+		printk(KERN_WARNING DRV_NAME ": can't add i2c device at 0x%x\n", pdata->edid_addr);
+		goto err_presence;
+	}
+
+	/* Register sysfs hooks */
+	ret = sysfs_create_group(&client->dev.kobj, &ad9389_attr_group);
+	if (ret)
+		goto err_sysfs_file;
+
+	ad9389->fbi = registered_fb[pdata->dispif];
+	fb_register_client(&nb);
+
+	/* Ack any active interrupt and enable irqs */
+	ad9389_write_reg(client, 0x94, 0x84);
+	ad9389_write_reg(client, 0x95, 0xc3);
+	ad9389_write_reg(client, 0x96, 0x84);
+	ad9389_write_reg(client, 0x97, 0xc3);
+
+	mutex_unlock(&ad9389->irq_lock);
+
+	ad9389_fb_init(registered_fb[pdata->dispif]);
+
+	printk(KERN_INFO DRV_NAME ": device detected at address 0x%x, chip revision 0x%02x\n",
+	       client->addr << 1, ad9389->chiprev);
+
+	return 0;
+
+err_sysfs_file:
+	i2c_unregister_device(ad9389->edid_ram);
+err_presence:
+	free_irq(client->irq, ad9389);
+err_irq:
+	flush_scheduled_work();
+	if (pdata->hw_deinit)
+		pdata->hw_deinit(ad9389);
+	kfree(ad9389->edid_data);
+err_edid_alloc:
+	kfree(ad9389);
+	pad9389 = NULL;
+	return ret;
+}
+
+static int ad9389_remove(struct i2c_client *client)
+{
+	struct ad9389_pdata *pdata = client->dev.platform_data;
+	struct ad9389_dev *ad9389 = i2c_get_clientdata(client);
+
+	free_irq(client->irq, ad9389);
+	flush_scheduled_work();
+	sysfs_remove_group(&client->dev.kobj, &ad9389_attr_group);
+	i2c_unregister_device(ad9389->edid_ram);
+	fb_unregister_client(&nb);
+	kfree(ad9389->edid_data);
+	kfree(ad9389);
+	pad9389 = NULL;
+
+	if (pdata->hw_deinit)
+		pdata->hw_deinit(ad9389);
+
+	return 0;
+}
+
+#ifdef CONFIG_PM
+static int ad9389_suspend(struct i2c_client *client, pm_message_t state)
+{
+	dev_dbg(&client->dev, "PM suspend\n");
+	ad9389_set_power_down(client, 1);
+
+	return 0;
+}
+
+static int ad9389_resume(struct i2c_client *client)
+{
+	struct ad9389_dev *ad9389 = pad9389;
+	int ret;
+	static struct fb_var_screeninfo var;
+
+	dev_dbg(&client->dev, "PM resume\n");
+
+	/* Disable Power down and set mute to on */
+	ad9389_set_power_down(client, 0);
+	ad9389_set_av_mute(client, 1);
+
+	/* set static reserved registers*/
+	ad9389_write_reg(client,0x0a, 0x01);
+	ad9389_write_reg(client, 0x98, 0x03);
+	ad9389_write_reg(client, 0x9C, 0x38);
+
+	/* Write magic numbers */
+	ad9389_write_reg(client, 0xA2, 0x87);
+	ad9389_write_reg(client, 0xA3, 0x87);
+
+	/* set capture edge */
+	ad9389_write_reg(client, 0xba, 0x60);
+	ad9389_write_reg(client, 0x47, 0x80);
+
+	mdelay(250);
+
+	ret = ad9389_read_edid(ad9389->client, ad9389->edid_data);
+	if (!ret) {
+		ad9389_dump_edid(ad9389->edid_data);
+		ret = ad9389_parse_edid(&var, ad9389->edid_data, &ad9389->dvi);
+		if (!ret) {
+			if (!ad9389->dvi) {
+				ad9389_set_hdmi_mode(client, 1);
+				/* FIXME audio setup should be done once we know the pixclock */
+				ad9389_audio_setup(ad9389);
+			}
+		}
+	}
+	return 0;
+}
+#else
+#define ad9389_suspend	NULL
+#define ad9389_resume	NULL
+#endif
+
+
+static struct i2c_device_id ad9389_id[] = {
+	{ "ad9389", 0 },
+	{},
+};
+MODULE_DEVICE_TABLE(i2c, ad9389_id);
+
+static struct i2c_driver ad9389_driver = {
+	.driver = {
+		.name = "ad9389",
+	},
+	.probe		= ad9389_probe,
+	.remove		= ad9389_remove,
+	.suspend	= ad9389_suspend,
+	.resume		= ad9389_resume,
+	.id_table	= ad9389_id,
+
+};
+
+static int __init ad9389_init(void)
+{
+	return i2c_add_driver(&ad9389_driver);
+}
+
+static void __exit ad9389_exit(void)
+{
+	i2c_del_driver(&ad9389_driver);
+}
+
+module_init(ad9389_init);
+module_exit(ad9389_exit);
+
+MODULE_DESCRIPTION("AD9389 hdmi/dvi driver");
+MODULE_AUTHOR("Digi International Inc.");
+MODULE_LICENSE("GPL");