summaryrefslogtreecommitdiff
path: root/drivers/video/mxc/ad9389.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/video/mxc/ad9389.c')
-rw-r--r--drivers/video/mxc/ad9389.c815
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");
generated by cgit v1.2.3 (git 2.0.4) at 2024-04-30 21:33:17 +0000