aboutsummaryrefslogtreecommitdiff
path: root/drivers/video/av8100/hdmi.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/video/av8100/hdmi.c')
-rwxr-xr-x[-rw-r--r--]drivers/video/av8100/hdmi.c1819
1 files changed, 1774 insertions, 45 deletions
diff --git a/drivers/video/av8100/hdmi.c b/drivers/video/av8100/hdmi.c
index cb6d1077876..14b15dedbf2 100644..100755
--- a/drivers/video/av8100/hdmi.c
+++ b/drivers/video/av8100/hdmi.c
@@ -11,76 +11,1653 @@
#include <linux/kernel.h>
#include <linux/miscdevice.h>
+#include <linux/device.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
-#include <video/hdmi.h>
#include <video/av8100.h>
+#include <video/hdmi.h>
+#include <linux/poll.h>
+#include <linux/mutex.h>
+#include <linux/ctype.h>
+#include "hdmi_loc.h"
-static int hdmi_open(struct inode *inode, struct file *filp)
+#define SYSFS_EVENT_FILENAME "evread"
+
+DEFINE_MUTEX(hdmi_events_mutex);
+#define LOCK_HDMI_EVENTS mutex_lock(&hdmi_events_mutex)
+#define UNLOCK_HDMI_EVENTS mutex_unlock(&hdmi_events_mutex)
+#define EVENTS_MASK 0xFF
+
+static int device_open;
+static int events;
+static int events_mask;
+static bool events_received;
+static wait_queue_head_t hdmi_event_wq;
+struct device *hdmidev;
+
+static ssize_t store_storeastext(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t store_plugdeten(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t store_edidread(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_edidread(struct device *dev, struct device_attribute *attr,
+ char *buf);
+static ssize_t store_ceceven(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_cecread(struct device *dev, struct device_attribute *attr,
+ char *buf);
+static ssize_t store_cecsend(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t store_infofrsend(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t store_hdcpeven(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_hdcpchkaesotp(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t store_hdcpfuseaes(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_hdcpfuseaes(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t store_hdcploadaes(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_hdcploadaes(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t store_hdcpauthencr(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t show_hdcpstateget(struct device *dev,
+ struct device_attribute *attr, char *buf);
+static ssize_t show_evread(struct device *dev, struct device_attribute *attr,
+ char *buf);
+static ssize_t store_evclr(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+static ssize_t store_audiocfg(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count);
+
+static DEVICE_ATTR(storeastext, S_IWUSR, NULL, store_storeastext);
+static DEVICE_ATTR(plugdeten, S_IWUSR, NULL, store_plugdeten);
+static DEVICE_ATTR(edidread, S_IRUGO | S_IWUSR, show_edidread, store_edidread);
+static DEVICE_ATTR(ceceven, S_IWUSR, NULL, store_ceceven);
+static DEVICE_ATTR(cecread, S_IRUGO, show_cecread, NULL);
+static DEVICE_ATTR(cecsend, S_IWUSR, NULL, store_cecsend);
+static DEVICE_ATTR(infofrsend, S_IWUSR, NULL, store_infofrsend);
+static DEVICE_ATTR(hdcpeven, S_IWUSR, NULL, store_hdcpeven);
+static DEVICE_ATTR(hdcpchkaesotp, S_IRUGO, show_hdcpchkaesotp, NULL);
+static DEVICE_ATTR(hdcpfuseaes, S_IRUGO | S_IWUSR, show_hdcpfuseaes,
+ store_hdcpfuseaes);
+static DEVICE_ATTR(hdcploadaes, S_IRUGO | S_IWUSR, show_hdcploadaes,
+ store_hdcploadaes);
+static DEVICE_ATTR(hdcpauthencr, S_IWUSR, NULL, store_hdcpauthencr);
+static DEVICE_ATTR(hdcpstateget, S_IRUGO, show_hdcpstateget, NULL);
+static DEVICE_ATTR(evread, S_IRUGO, show_evread, NULL);
+static DEVICE_ATTR(evclr, S_IWUSR, NULL, store_evclr);
+static DEVICE_ATTR(audiocfg, S_IWUSR, NULL, store_audiocfg);
+
+/* Hex to int conversion */
+static unsigned int htoi(const char *ptr)
{
- int retval = 0;
+ unsigned int value = 0;
+ char ch = *ptr;
+
+ if (!ptr)
+ return 0;
+
+ if (isdigit(ch))
+ value = ch - '0';
+ else
+ value = toupper(ch) - 'A' + 10;
+
+ value <<= 4;
+ ch = *(++ptr);
+
+ if (isdigit(ch))
+ value += ch - '0';
+ else
+ value += toupper(ch) - 'A' + 10;
+
+ return value;
+}
+
+static int event_enable(bool enable, enum hdmi_event ev)
+{
+ dev_dbg(hdmidev, "enable_event %d %02x\n", enable, ev);
+ if (enable)
+ events_mask |= ev;
+ else
+ events_mask &= ~ev;
+
+ return 0;
+}
+
+static int plugdeten(struct plug_detect *pldet)
+{
+ struct av8100_status status;
+ u8 denc_off_time = 0;
+ int retval;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ av8100_reg_hdmi_5_volt_time_r(&denc_off_time, NULL, NULL);
+
+ retval = av8100_reg_hdmi_5_volt_time_w(
+ denc_off_time,
+ pldet->hdmi_off_time,
+ pldet->on_time);
+
+ if (retval) {
+ dev_err(hdmidev, "Failed to write the value to av8100 "
+ "register\n");
+ return -EFAULT;
+ }
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_IDLE) {
+ av8100_disable_interrupt();
+ av8100_enable_interrupt();
+ }
+
+ event_enable(pldet->hdmi_detect_enable != 0,
+ HDMI_EVENT_HDMI_PLUGIN);
+ event_enable(pldet->hdmi_detect_enable != 0,
+ HDMI_EVENT_HDMI_PLUGOUT);
+
return retval;
}
+static int edidread(struct edid_read *edidread, u8 *len, u8 *data)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ config.edid_section_readback_format.address = edidread->address;
+ config.edid_section_readback_format.block_number = edidread->block_nr;
+
+ dev_dbg(hdmidev, "addr:%0x blnr:%0x",
+ config.edid_section_readback_format.address,
+ config.edid_section_readback_format.block_number);
+
+ if (av8100_conf_prep(AV8100_COMMAND_EDID_SECTION_READBACK,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_EDID_SECTION_READBACK,
+ len,
+ data, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ dev_dbg(hdmidev, "len:%0x\n", *len);
+
+ return 0;
+}
+
+static int cecread(u8 *src, u8 *dest, u8 *data_len, u8 *data)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+ u8 buf_len;
+ u8 buff[HDMI_CEC_READ_MAXSIZE];
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ if (av8100_conf_prep(AV8100_COMMAND_CEC_MESSAGE_READ_BACK,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_CEC_MESSAGE_READ_BACK,
+ &buf_len, buff, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ if (buf_len > 0) {
+ *src = (buff[0] & 0xF0) >> 4;
+ *dest = buff[0] & 0x0F;
+ *data_len = buf_len - 1;
+ memcpy(data, &buff[1], buf_len - 1);
+ } else
+ *data_len = 0;
+
+ return 0;
+}
+
+static int cecsend(u8 src, u8 dest, u8 data_len, u8 *data)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ if (data_len < 1)
+ return -EINVAL;
+
+ config.cec_message_write_format.buffer[0] = ((src & 0x0F) << 4) +
+ (dest & 0x0F);
+ config.cec_message_write_format.buffer_length = data_len + 1;
+ memcpy(&config.cec_message_write_format.buffer[1], data, data_len - 1);
+
+ if (av8100_conf_prep(AV8100_COMMAND_CEC_MESSAGE_WRITE,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_CEC_MESSAGE_WRITE,
+ NULL, NULL, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int infofrsend(u8 type, u8 version, u8 crc, u8 data_len, u8 *data)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ if ((data_len < 1) || (data_len > HDMI_INFOFRAME_MAX_SIZE))
+ return -EINVAL;
+
+ config.infoframes_format.type = type;
+ config.infoframes_format.version = version;
+ config.infoframes_format.crc = crc;
+ config.infoframes_format.length = data_len;
+ memcpy(&config.infoframes_format.data, data, data_len);
+
+ if (av8100_conf_prep(AV8100_COMMAND_INFOFRAMES,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_INFOFRAMES,
+ NULL, NULL, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int hdcpchkaesotp(u8 *crc, u8 *progged)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+ u8 buf_len;
+ u8 buf[2];
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) !=
+ 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ config.fuse_aes_key_format.fuse_operation = AV8100_FUSE_READ;
+ memset(config.fuse_aes_key_format.key, 0, AV8100_FUSE_KEY_SIZE);
+ if (av8100_conf_prep(AV8100_COMMAND_FUSE_AES_KEY,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_FUSE_AES_KEY,
+ &buf_len, buf, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ if (buf_len == 2) {
+ *crc = buf[0];
+ *progged = buf[1];
+ }
+
+ return 0;
+}
+
+static int hdcpfuseaes(u8 *key, u8 crc, u8 *result)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+ u8 buf_len;
+ u8 buf[2];
+
+ /* Default not OK */
+ *result = 1;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) !=
+ 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ config.fuse_aes_key_format.fuse_operation = AV8100_FUSE_WRITE;
+ memcpy(config.fuse_aes_key_format.key, key, AV8100_FUSE_KEY_SIZE);
+ if (av8100_conf_prep(AV8100_COMMAND_FUSE_AES_KEY,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_FUSE_AES_KEY,
+ &buf_len, buf, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ if (buf_len == 2) {
+ if ((crc == buf[0]) && (buf[1] == 1))
+ /* OK */
+ *result = 0;
+ }
+
+ return 0;
+}
+
+static int hdcploadaes(u8 block, u8 key_len, u8 *key, u8 *result)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ /* Default not OK */
+ *result = 1;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) !=
+ 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ config.hdcp_send_key_format.key_number = block;
+ config.hdcp_send_key_format.data_len = key_len;
+ memcpy(config.hdcp_send_key_format.data, key, key_len);
+ if (av8100_conf_prep(AV8100_COMMAND_HDCP_SENDKEY, &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_HDCP_SENDKEY,
+ NULL, NULL, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ *result = 0;
+
+ return 0;
+}
+
+static int hdcpauthencr(u8 auth_type, u8 encr_type)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ switch (auth_type) {
+ case HDMI_HDCP_AUTH_OFF:
+ default:
+ config.hdcp_management_format.req_type =
+ AV8100_HDCP_AUTH_REQ_OFF;
+ break;
+
+ case HDMI_HDCP_AUTH_START:
+ config.hdcp_management_format.req_type =
+ AV8100_HDCP_AUTH_REQ_ON;
+ break;
+
+ case HDMI_HDCP_AUTH_CONT:
+ config.hdcp_management_format.req_type =
+ AV8100_HDCP_AUTH_CONT;
+ break;
+ }
+
+ switch (encr_type) {
+ case HDMI_HDCP_ENCR_OFF:
+ config.hdcp_management_format.req_encr =
+ AV8100_HDCP_ENCR_REQ_OFF;
+ config.hdcp_management_format.encr_use =
+ AV8100_HDCP_ENCR_USE_OESS;
+ break;
+
+ case HDMI_HDCP_ENCR_OESS:
+ config.hdcp_management_format.req_encr =
+ AV8100_HDCP_ENCR_REQ_ON;
+ config.hdcp_management_format.encr_use =
+ AV8100_HDCP_ENCR_USE_OESS;
+ break;
+
+ case HDMI_HDCP_ENCR_EESS:
+ config.hdcp_management_format.req_encr =
+ AV8100_HDCP_ENCR_REQ_ON;
+ config.hdcp_management_format.encr_use =
+ AV8100_HDCP_ENCR_USE_EESS;
+ break;
+ }
+
+ if (av8100_conf_prep(AV8100_COMMAND_HDCP_MANAGEMENT,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_HDCP_MANAGEMENT,
+ NULL, NULL, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static u8 events_read(void)
+{
+ int ret;
+
+ LOCK_HDMI_EVENTS;
+ ret = events;
+ dev_dbg(hdmidev, "%s %02x\n", __func__, events);
+ UNLOCK_HDMI_EVENTS;
+
+ return ret;
+}
+
+static int events_clear(u8 ev)
+{
+ dev_dbg(hdmidev, "%s %02x\n", __func__, ev);
+
+ LOCK_HDMI_EVENTS;
+ events &= ~ev & EVENTS_MASK;
+ UNLOCK_HDMI_EVENTS;
+
+ return 0;
+}
+
+static int audiocfg(struct audio_cfg *cfg)
+{
+ union av8100_configuration config;
+ struct av8100_status status;
+
+ status = av8100_status_get();
+ if (status.av8100_state < AV8100_OPMODE_STANDBY) {
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup failed\n");
+ return -EINVAL;
+ }
+ }
+
+ if (status.av8100_state < AV8100_OPMODE_INIT) {
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
+ return -EINVAL;
+ }
+ }
+
+ config.audio_input_format.audio_input_if_format = cfg->if_format;
+ config.audio_input_format.i2s_input_nb = cfg->i2s_entries;
+ config.audio_input_format.sample_audio_freq = cfg->freq;
+ config.audio_input_format.audio_word_lg = cfg->word_length;
+ config.audio_input_format.audio_format = cfg->format;
+ config.audio_input_format.audio_if_mode = cfg->if_mode;
+ config.audio_input_format.audio_mute = cfg->mute;
+
+ if (av8100_conf_prep(AV8100_COMMAND_AUDIO_INPUT_FORMAT,
+ &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
+ return -EINVAL;
+ }
+
+ if (av8100_conf_w(AV8100_COMMAND_AUDIO_INPUT_FORMAT,
+ NULL, NULL, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/* sysfs */
+static ssize_t store_storeastext(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if ((count != HDMI_STOREASTEXT_BIN_SIZE) &&
+ (count != HDMI_STOREASTEXT_TEXT_SIZE) &&
+ (count != HDMI_STOREASTEXT_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ if ((count == HDMI_STOREASTEXT_BIN_SIZE) && (*buf == 0x1))
+ hdmi_driver_data->store_as_hextext = true;
+ else if (((count == HDMI_STOREASTEXT_TEXT_SIZE) ||
+ (count == HDMI_STOREASTEXT_TEXT_SIZE + 1)) && (*buf == '0') &&
+ (*(buf + 1) == '1'))
+ hdmi_driver_data->store_as_hextext = true;
+
+ dev_dbg(hdmidev, "store_as_hextext:%0d\n",
+ hdmi_driver_data->store_as_hextext);
+
+ return count;
+}
+
+static ssize_t store_plugdeten(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct plug_detect plug_detect;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_PLUGDETEN_TEXT_SIZE) &&
+ (count != HDMI_PLUGDETEN_TEXT_SIZE + 1))
+ return -EINVAL;
+ plug_detect.hdmi_detect_enable = htoi(buf + index);
+ index += 2;
+ plug_detect.on_time = htoi(buf + index);
+ index += 2;
+ plug_detect.hdmi_off_time = htoi(buf + index);
+ index += 2;
+ } else {
+ if (count != HDMI_PLUGDETEN_BIN_SIZE)
+ return -EINVAL;
+ plug_detect.hdmi_detect_enable = *(buf + index++);
+ plug_detect.on_time = *(buf + index++);
+ plug_detect.hdmi_off_time = *(buf + index++);
+ }
+
+ if (plugdeten(&plug_detect))
+ return -EINVAL;
+
+ return count;
+}
+
+static ssize_t store_edidread(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct edid_read edid_read;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+ dev_dbg(hdmidev, "count:%d\n", count);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_EDIDREAD_TEXT_SIZE) &&
+ (count != HDMI_EDIDREAD_TEXT_SIZE + 1))
+ return -EINVAL;
+ edid_read.address = htoi(buf + index);
+ index += 2;
+ edid_read.block_nr = htoi(buf + index);
+ index += 2;
+ } else {
+ if (count != HDMI_EDIDREAD_BIN_SIZE)
+ return -EINVAL;
+ edid_read.address = *(buf + index++);
+ edid_read.block_nr = *(buf + index++);
+ }
+
+ if (edidread(&edid_read, &hdmi_driver_data->edid_data.buf_len,
+ hdmi_driver_data->edid_data.buf))
+ return -EINVAL;
+
+ return count;
+}
+
+static ssize_t show_edidread(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ int len;
+ int index = 0;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ len = hdmi_driver_data->edid_data.buf_len;
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", len);
+ index += 2;
+ } else
+ *(buf + index++) = len;
+
+ dev_dbg(hdmidev, "len:%02x\n", len);
+
+ cnt = 0;
+ while (cnt < len) {
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x",
+ hdmi_driver_data->edid_data.buf[cnt]);
+ index += 2;
+ } else
+ *(buf + index++) =
+ hdmi_driver_data->edid_data.buf[cnt];
+
+ dev_dbg(hdmidev, "%02x ",
+ hdmi_driver_data->edid_data.buf[cnt]);
+
+ cnt++;
+ }
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t store_ceceven(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ bool enable = false;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_CECEVEN_TEXT_SIZE) &&
+ (count != HDMI_CECEVEN_TEXT_SIZE + 1))
+ return -EINVAL;
+ if ((*buf == '0') && (*(buf + 1) == '1'))
+ enable = true;
+ } else {
+ if (count != HDMI_CECEVEN_BIN_SIZE)
+ return -EINVAL;
+ if (*buf == 0x01)
+ enable = true;
+ }
+
+ event_enable(enable, HDMI_EVENT_CEC);
+
+ return count;
+}
+
+static ssize_t show_cecread(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct cec_rw cec_read;
+ int index = 0;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (cecread(&cec_read.src, &cec_read.dest, &cec_read.length,
+ cec_read.data))
+ return -EINVAL;
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", cec_read.src);
+ index += 2;
+ snprintf(buf + index, 3, "%02x", cec_read.dest);
+ index += 2;
+ snprintf(buf + index, 3, "%02x", cec_read.length);
+ } else {
+ *(buf + index++) = cec_read.src;
+ *(buf + index++) = cec_read.dest;
+ *(buf + index++) = cec_read.length;
+ }
+
+ dev_dbg(hdmidev, "len:%02x\n", cec_read.length);
+
+ cnt = 0;
+ while (cnt < cec_read.length) {
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", cec_read.data[cnt]);
+ index += 2;
+ } else
+ *(buf + index++) = cec_read.data[cnt];
+
+ dev_dbg(hdmidev, "%02x ", cec_read.data[cnt]);
+
+ cnt++;
+ }
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t store_cecsend(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct cec_rw cec_w;
+ int index = 0;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count < HDMI_CECSEND_TEXT_SIZE_MIN) ||
+ (count > HDMI_CECSEND_TEXT_SIZE_MAX))
+ return -EINVAL;
+
+ cec_w.src = htoi(buf + index);
+ index += 2;
+ cec_w.dest = htoi(buf + index);
+ index += 2;
+ cec_w.length = htoi(buf + index);
+ index += 2;
+ if (cec_w.length > HDMI_CEC_WRITE_MAXSIZE)
+ return -EINVAL;
+ cnt = 0;
+ while (cnt < cec_w.length) {
+ cec_w.data[cnt] = htoi(buf + index);
+ index += 2;
+ dev_dbg(hdmidev, "%02x ", cec_w.data[cnt]);
+ cnt++;
+ }
+ } else {
+ if ((count < HDMI_CECSEND_BIN_SIZE_MIN) ||
+ (count > HDMI_CECSEND_BIN_SIZE_MAX))
+ return -EINVAL;
+
+ cec_w.src = *(buf + index++);
+ cec_w.dest = *(buf + index++);
+ cec_w.length = *(buf + index++);
+ if (cec_w.length > HDMI_CEC_WRITE_MAXSIZE)
+ return -EINVAL;
+ memcpy(cec_w.data, buf + index, cec_w.length);
+ }
+
+ if (cecsend(cec_w.src,
+ cec_w.dest,
+ cec_w.length,
+ cec_w.data))
+ return -EINVAL;
+
+ return count;
+}
+
+static ssize_t store_infofrsend(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct info_fr info_fr;
+ int index = 0;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count < HDMI_INFOFRSEND_TEXT_SIZE_MIN) ||
+ (count > HDMI_INFOFRSEND_TEXT_SIZE_MAX))
+ return -EINVAL;
+
+ info_fr.type = htoi(&buf[index]);
+ index += 2;
+ info_fr.ver = htoi(&buf[index]);
+ index += 2;
+ info_fr.crc = htoi(&buf[index]);
+ index += 2;
+ info_fr.length = htoi(&buf[index]);
+ index += 2;
+
+ if (info_fr.length > HDMI_INFOFRAME_MAX_SIZE)
+ return -EINVAL;
+ cnt = 0;
+ while (cnt < info_fr.length) {
+ info_fr.data[cnt] = htoi(buf + index);
+ index += 2;
+ dev_dbg(hdmidev, "%02x ", info_fr.data[cnt]);
+ cnt++;
+ }
+ } else {
+ if ((count < HDMI_INFOFRSEND_BIN_SIZE_MIN) ||
+ (count > HDMI_INFOFRSEND_BIN_SIZE_MAX))
+ return -EINVAL;
+
+ info_fr.type = *(buf + index++);
+ info_fr.ver = *(buf + index++);
+ info_fr.crc = *(buf + index++);
+ info_fr.length = *(buf + index++);
+
+ if (info_fr.length > HDMI_INFOFRAME_MAX_SIZE)
+ return -EINVAL;
+ memcpy(info_fr.data, buf + index, info_fr.length);
+ }
+
+ if (infofrsend(info_fr.type, info_fr.ver, info_fr.crc,
+ info_fr.length, info_fr.data))
+ return -EINVAL;
+
+ return count;
+}
+
+static ssize_t store_hdcpeven(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ bool enable = false;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_HDCPEVEN_TEXT_SIZE) &&
+ (count != HDMI_HDCPEVEN_TEXT_SIZE + 1))
+ return -EINVAL;
+ if ((*buf == '0') && (*(buf + 1) == '1'))
+ enable = true;
+ } else {
+ if (count != HDMI_HDCPEVEN_BIN_SIZE)
+ return -EINVAL;
+ if (*buf == 0x01)
+ enable = true;
+ }
+
+ event_enable(enable, HDMI_EVENT_HDCP);
+
+ return count;
+}
+
+static ssize_t show_hdcpchkaesotp(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ u8 crc;
+ u8 status;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdcpchkaesotp(&crc, &status))
+ return -EINVAL;
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", status);
+ index += 2;
+ } else {
+ *(buf + index++) = status;
+ }
+
+ dev_dbg(hdmidev, "status:%02x\n", status);
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t store_hdcpfuseaes(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct hdcp_fuseaes hdcp_fuseaes;
+ int index = 0;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_HDCP_FUSEAES_TEXT_SIZE) &&
+ (count != HDMI_HDCP_FUSEAES_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ cnt = 0;
+ while (cnt < HDMI_HDCP_FUSEAES_KEYSIZE) {
+ hdcp_fuseaes.key[cnt] = htoi(buf + index);
+ index += 2;
+ dev_dbg(hdmidev, "%02x ", hdcp_fuseaes.key[cnt]);
+ cnt++;
+ }
+ hdcp_fuseaes.crc = htoi(&buf[index]);
+ index += 2;
+ } else {
+ if (count != HDMI_HDCP_FUSEAES_BIN_SIZE)
+ return -EINVAL;
+
+ memcpy(hdcp_fuseaes.key, buf + index,
+ HDMI_HDCP_FUSEAES_KEYSIZE);
+ index += HDMI_HDCP_FUSEAES_KEYSIZE;
+ hdcp_fuseaes.crc = *(buf + index++);
+ }
+
+ if (hdcpfuseaes(hdcp_fuseaes.key, hdcp_fuseaes.crc,
+ &hdcp_fuseaes.result))
+ return -EINVAL;
+
+ hdmi_driver_data->fuse_result = hdcp_fuseaes.result;
+
+ return count;
+}
+
+static ssize_t show_hdcpfuseaes(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x",
+ hdmi_driver_data->fuse_result);
+ index += 2;
+ } else
+ *(buf + index++) = hdmi_driver_data->fuse_result;
+
+ dev_dbg(hdmidev, "status:%02x\n", hdmi_driver_data->fuse_result);
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t store_hdcploadaes(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct hdcp_loadaesone hdcp_loadaes;
+ int index = 0;
+ int block_cnt;
+ int cnt;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ /* Default not OK */
+ hdmi_driver_data->loadaes_result = 1;
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_HDCP_LOADAES_TEXT_SIZE) &&
+ (count != HDMI_HDCP_LOADAES_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ /* AES */
+ block_cnt = 0;
+ while (block_cnt < HDMI_HDCP_AES_NR_OF_BLOCKS) {
+ cnt = 0;
+ while (cnt < HDMI_HDCP_AES_KEYSIZE) {
+ hdcp_loadaes.key[cnt] = htoi(buf + index);
+ index += 2;
+ dev_dbg(hdmidev, "%02x ",
+ hdcp_loadaes.key[cnt]);
+ cnt++;
+ }
+
+ if (hdcploadaes(block_cnt + HDMI_HDCP_AES_BLOCK_START,
+ HDMI_HDCP_AES_KEYSIZE,
+ hdcp_loadaes.key,
+ &hdcp_loadaes.result))
+ return -EINVAL;
+ if (hdcp_loadaes.result)
+ return -EINVAL;
+
+ block_cnt++;
+ }
+
+ /* KSV */
+ memset(hdcp_loadaes.key, 0, HDMI_HDCP_AES_KSVZEROESSIZE);
+ cnt = HDMI_HDCP_AES_KSVZEROESSIZE;
+ while (cnt < HDMI_HDCP_AES_KSVSIZE +
+ HDMI_HDCP_AES_KSVZEROESSIZE) {
+ hdcp_loadaes.key[cnt] =
+ htoi(&buf[index]);
+ index += 2;
+ dev_dbg(hdmidev, "%02x ", hdcp_loadaes.key[cnt]);
+ cnt++;
+ }
+
+ if (hdcploadaes(HDMI_HDCP_KSV_BLOCK,
+ HDMI_HDCP_AES_KSVSIZE +
+ HDMI_HDCP_AES_KSVZEROESSIZE,
+ hdcp_loadaes.key,
+ &hdcp_loadaes.result))
+ return -EINVAL;
+
+ if (hdcp_loadaes.result)
+ return -EINVAL;
+ } else {
+ if (count != HDMI_HDCP_LOADAES_BIN_SIZE)
+ return -EINVAL;
+
+ /* AES */
+ block_cnt = 0;
+ while (block_cnt < HDMI_HDCP_AES_NR_OF_BLOCKS) {
+ memcpy(hdcp_loadaes.key, buf + index,
+ HDMI_HDCP_AES_KEYSIZE);
+ index += HDMI_HDCP_AES_KEYSIZE;
+
+ if (hdcploadaes(block_cnt + HDMI_HDCP_AES_BLOCK_START,
+ HDMI_HDCP_AES_KEYSIZE,
+ hdcp_loadaes.key,
+ &hdcp_loadaes.result))
+ return -EINVAL;
+
+ if (hdcp_loadaes.result)
+ return -EINVAL;
+ }
+
+ /* KSV */
+ memset(hdcp_loadaes.key, 0, HDMI_HDCP_AES_KSVZEROESSIZE);
+ memcpy(hdcp_loadaes.key + HDMI_HDCP_AES_KSVZEROESSIZE,
+ buf + index,
+ HDMI_HDCP_AES_KSVSIZE);
+ index += HDMI_HDCP_AES_KSVSIZE;
+
+ if (hdcploadaes(HDMI_HDCP_KSV_BLOCK,
+ HDMI_HDCP_AES_KSVSIZE +
+ HDMI_HDCP_AES_KSVZEROESSIZE,
+ hdcp_loadaes.key,
+ &hdcp_loadaes.result))
+ return -EINVAL;
+
+ if (hdcp_loadaes.result)
+ return -EINVAL;
+ }
+
+ hdmi_driver_data->loadaes_result = hdcp_loadaes.result;
+
+ return count;
+}
+
+static ssize_t show_hdcploadaes(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x",
+ hdmi_driver_data->loadaes_result);
+ index += 2;
+ } else
+ *(buf + index++) = hdmi_driver_data->loadaes_result;
+
+ dev_dbg(hdmidev, "status:%02x\n", hdmi_driver_data->loadaes_result);
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t store_hdcpauthencr(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct hdcp_authencr hdcp_authencr;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_HDCPAUTHENCR_TEXT_SIZE) &&
+ (count != HDMI_HDCPAUTHENCR_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ hdcp_authencr.auth_type = htoi(buf + index);
+ index += 2;
+ hdcp_authencr.encr_type = htoi(buf + index);
+ index += 2;
+ } else {
+ if (count != HDMI_HDCPAUTHENCR_BIN_SIZE)
+ return -EINVAL;
+
+ hdcp_authencr.auth_type = *(buf + index++);
+ hdcp_authencr.encr_type = *(buf + index++);
+ }
+
+ if (hdcpauthencr(hdcp_authencr.auth_type, hdcp_authencr.encr_type))
+ return -EINVAL;
+
+ return count;
+}
+
+static ssize_t show_hdcpstateget(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ u8 hdcp_state;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (av8100_reg_gen_status_r(NULL, NULL, NULL, NULL, &hdcp_state))
+ return -EINVAL;
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", hdcp_state);
+ index += 2;
+ } else
+ *(buf + index++) = hdcp_state;
+
+ dev_dbg(hdmidev, "status:%02x\n", hdcp_state);
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ return index;
+}
+
+static ssize_t show_evread(struct device *dev, struct device_attribute *attr,
+ char *buf)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ int index = 0;
+ u8 ev;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ ev = events_read();
+
+ if (hdmi_driver_data->store_as_hextext) {
+ snprintf(buf + index, 3, "%02x", ev & 0xFF);
+ index += 2;
+ } else
+ *(buf + index++) = ev & 0xFF;
+
+ if (hdmi_driver_data->store_as_hextext)
+ *(buf + index++) = '\0';
+
+ /* Events are read: clear events */
+ events_clear(EVENTS_MASK);
+
+ return index;
+}
+
+static ssize_t store_evclr(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ u8 ev;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_EVCLR_TEXT_SIZE) &&
+ (count != HDMI_EVCLR_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ ev = htoi(&buf[index]);
+ index += 2;
+ } else {
+ if (count != HDMI_EVCLR_BIN_SIZE)
+ return -EINVAL;
+
+ ev = *(buf + index++);
+ }
+
+ events_clear(ev);
+
+ return count;
+}
+
+static ssize_t store_audiocfg(struct device *dev,
+ struct device_attribute *attr, const char *buf, size_t count)
+{
+ struct hdmi_driver_data *hdmi_driver_data;
+ struct audio_cfg audio_cfg;
+ int index = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ hdmi_driver_data = dev_get_drvdata(dev);
+
+ if (hdmi_driver_data->store_as_hextext) {
+ if ((count != HDMI_AUDIOCFG_TEXT_SIZE) &&
+ (count != HDMI_AUDIOCFG_TEXT_SIZE + 1))
+ return -EINVAL;
+
+ audio_cfg.if_format = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.i2s_entries = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.freq = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.word_length = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.format = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.if_mode = htoi(&buf[index]);
+ index += 2;
+ audio_cfg.mute = htoi(&buf[index]);
+ index += 2;
+ } else {
+ if (count != HDMI_AUDIOCFG_BIN_SIZE)
+ return -EINVAL;
+
+ audio_cfg.if_format = *(buf + index++);
+ audio_cfg.i2s_entries = *(buf + index++);
+ audio_cfg.freq = *(buf + index++);
+ audio_cfg.word_length = *(buf + index++);
+ audio_cfg.format = *(buf + index++);
+ audio_cfg.if_mode = *(buf + index++);
+ audio_cfg.mute = *(buf + index++);
+ }
+
+ audiocfg(&audio_cfg);
+
+ return count;
+}
+
+static int hdmi_open(struct inode *inode, struct file *filp)
+{
+ if (device_open)
+ return -EBUSY;
+
+ device_open++;
+
+ return 0;
+}
+
static int hdmi_release(struct inode *inode, struct file *filp)
{
- int retval = 0;
- return retval;
+ if (device_open)
+ device_open--;
+
+ return 0;
}
+/* ioctl */
static int hdmi_ioctl(struct inode *inode, struct file *file,
unsigned int cmd, unsigned long arg)
{
- int retval = 0;
- int value = 0;
+ u8 value = 0;
+ struct plug_detect plug_detect;
+ struct edid_read edid_read;
+ struct cec_rw cec_read;
+ struct cec_rw cec_send;
+ struct info_fr info_fr;
+ struct hdcp_fuseaes hdcp_fuseaes;
+ struct hdcp_loadaesall hdcp_loadaesall;
+ int block_cnt;
+ struct hdcp_loadaesone hdcp_loadaesone;
+ struct hdcp_authencr hdcp_authencr;
+ struct audio_cfg audio_cfg;
union av8100_configuration config;
struct hdmi_register reg;
struct hdmi_command_register command_reg;
struct av8100_status status;
+ u8 aes_status;
switch (cmd) {
+
+ case IOC_PLUG_DETECT_ENABLE:
+ if (copy_from_user(&plug_detect, (void *)arg,
+ sizeof(struct plug_detect)))
+ return -EINVAL;
+
+ if (plugdeten(&plug_detect))
+ return -EINVAL;
+ break;
+
+ case IOC_EDID_READ:
+ if (copy_from_user(&edid_read, (void *)arg,
+ sizeof(struct edid_read)))
+ return -EINVAL;
+
+ if (edidread(&edid_read, &edid_read.data_length,
+ edid_read.data))
+ return -EINVAL;
+
+ if (copy_to_user((void *)arg, (void *)&edid_read,
+ sizeof(struct edid_read))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_CEC_EVENT_ENABLE:
+ if (copy_from_user(&value, (void *)arg, sizeof(u8)))
+ return -EINVAL;
+
+ event_enable(value != 0, HDMI_EVENT_CEC);
+ break;
+
+ case IOC_CEC_READ:
+ if (cecread(&cec_read.src, &cec_read.dest, &cec_read.length,
+ cec_read.data))
+ return -EINVAL;
+
+ if (copy_to_user((void *)arg, (void *)&cec_read,
+ sizeof(struct cec_rw))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_CEC_SEND:
+ if (copy_from_user(&cec_send, (void *)arg,
+ sizeof(struct cec_rw)))
+ return -EINVAL;
+
+ if (cecsend(cec_send.src,
+ cec_send.dest,
+ cec_send.length,
+ cec_send.data))
+ return -EINVAL;
+ break;
+
+ case IOC_INFOFRAME_SEND:
+ if (copy_from_user(&info_fr, (void *)arg,
+ sizeof(struct info_fr)))
+ return -EINVAL;
+
+ if (infofrsend(info_fr.type, info_fr.ver, info_fr.crc,
+ info_fr.length, info_fr.data))
+ return -EINVAL;
+ break;
+
+ case IOC_HDCP_EVENT_ENABLE:
+ if (copy_from_user(&value, (void *)arg, sizeof(u8)))
+ return -EINVAL;
+
+ event_enable(value != 0, HDMI_EVENT_HDCP);
+ break;
+
+ case IOC_HDCP_CHKAESOTP:
+ if (hdcpchkaesotp(&value, &aes_status))
+ return -EINVAL;
+
+ if (copy_to_user((void *)arg, (void *)&aes_status,
+ sizeof(u8))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_HDCP_FUSEAES:
+ if (copy_from_user(&hdcp_fuseaes, (void *)arg,
+ sizeof(struct hdcp_fuseaes)))
+ return -EINVAL;
+
+ if (hdcpfuseaes(hdcp_fuseaes.key, hdcp_fuseaes.crc,
+ &hdcp_fuseaes.result))
+ return -EINVAL;
+
+ if (copy_to_user((void *)arg, (void *)&hdcp_fuseaes,
+ sizeof(struct hdcp_fuseaes))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_HDCP_LOADAES:
+ if (copy_from_user(&hdcp_loadaesall, (void *)arg,
+ sizeof(struct hdcp_loadaesall)))
+ return -EINVAL;
+
+ /* AES */
+ block_cnt = 0;
+ while (block_cnt < HDMI_HDCP_AES_NR_OF_BLOCKS) {
+ memcpy(hdcp_loadaesone.key, hdcp_loadaesall.key +
+ block_cnt * HDMI_HDCP_AES_KEYSIZE,
+ HDMI_HDCP_AES_KEYSIZE);
+
+ if (hdcploadaes(block_cnt + HDMI_HDCP_AES_BLOCK_START,
+ HDMI_HDCP_AES_KEYSIZE,
+ hdcp_loadaesone.key,
+ &hdcp_loadaesone.result))
+ return -EINVAL;
+
+ if (hdcp_loadaesone.result)
+ return -EINVAL;
+ }
+
+ /* KSV */
+ memset(hdcp_loadaesone.key, 0, HDMI_HDCP_AES_KSVZEROESSIZE);
+ memcpy(hdcp_loadaesone.key + HDMI_HDCP_AES_KSVZEROESSIZE,
+ hdcp_loadaesall.ksv, HDMI_HDCP_AES_KSVSIZE);
+
+ if (hdcploadaes(HDMI_HDCP_KSV_BLOCK,
+ HDMI_HDCP_AES_KSVSIZE +
+ HDMI_HDCP_AES_KSVZEROESSIZE,
+ hdcp_loadaesone.key,
+ &hdcp_loadaesone.result))
+ return -EINVAL;
+
+ if (hdcp_loadaesone.result)
+ return -EINVAL;
+
+ hdcp_loadaesall.result = hdcp_loadaesone.result;
+
+ if (copy_to_user((void *)arg, (void *)&hdcp_loadaesall,
+ sizeof(struct hdcp_loadaesall))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_HDCP_AUTHENCR_REQ:
+ if (copy_from_user(&hdcp_authencr, (void *)arg,
+ sizeof(struct hdcp_authencr)))
+ return -EINVAL;
+
+ if (hdcpauthencr(hdcp_authencr.auth_type,
+ hdcp_authencr.encr_type))
+ return -EINVAL;
+ break;
+
+ case IOC_HDCP_STATE_GET:
+ if (av8100_reg_gen_status_r(NULL, NULL, NULL, NULL,
+ &value))
+ return -EINVAL;
+
+ if (copy_to_user((void *)arg, (void *)&value,
+ sizeof(u8))) {
+ return -EINVAL;
+ }
+ break;
+
+ case IOC_EVENTS_READ:
+ value = events_read();
+
+ if (copy_to_user((void *)arg, (void *)&value,
+ sizeof(u8))) {
+ return -EINVAL;
+ }
+
+ /* Events are read: clear events */
+ events_clear(EVENTS_MASK);
+ break;
+
+ case IOC_EVENTS_CLEAR:
+ if (copy_from_user(&value, (void *)arg, sizeof(u8)))
+ return -EINVAL;
+
+ events_clear(value);
+ break;
+
+ case IOC_AUDIO_CFG:
+ if (copy_from_user(&audio_cfg, (void *)arg,
+ sizeof(struct audio_cfg)))
+ return -EINVAL;
+
+ audiocfg(&audio_cfg);
+ break;
+
+ /* Internal */
case IOC_HDMI_POWER:
/* Get desired power state on or off */
- if (copy_from_user(&value, (void *)arg, sizeof(int)))
+ if (copy_from_user(&value, (void *)arg, sizeof(u8)))
return -EINVAL;
if (value == 0) {
- if (av8100_powerdown() != AV8100_OK) {
- printk(KERN_ERR "av8100_powerdown FAIL\n");
+ if (av8100_powerdown() != 0) {
+ dev_err(hdmidev, "av8100_powerdown FAIL\n");
return -EINVAL;
}
} else {
- if (av8100_powerup() != AV8100_OK) {
- printk(KERN_ERR "av8100_powerup FAIL\n");
+ if (av8100_powerup() != 0) {
+ dev_err(hdmidev, "av8100_powerup FAIL\n");
return -EINVAL;
}
}
break;
case IOC_HDMI_ENABLE_INTERRUPTS:
- if (av8100_enable_interrupt() != AV8100_OK) {
- printk(KERN_ERR "av8100_configuration_get FAIL\n");
+ av8100_disable_interrupt();
+ if (av8100_enable_interrupt() != 0) {
+ dev_err(hdmidev, "av8100_conf_get FAIL\n");
return -EINVAL;
}
break;
case IOC_HDMI_DOWNLOAD_FW:
- if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) !=
- AV8100_OK) {
- printk(KERN_ERR "av8100_configuration_get FAIL\n");
+ if (av8100_download_firmware(NULL, 0, I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100 dl fw FAIL\n");
return -EINVAL;
}
break;
case IOC_HDMI_ONOFF:
/* Get desired HDMI mode on or off */
- if (copy_from_user(&value, (void *)arg, sizeof(int)))
+ if (copy_from_user(&value, (void *)arg, sizeof(u8)))
return -EFAULT;
- if (av8100_configuration_get(AV8100_COMMAND_HDMI, &config) !=
- AV8100_OK) {
- printk(KERN_ERR "av8100_configuration_get FAIL\n");
+ if (av8100_conf_get(AV8100_COMMAND_HDMI, &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_get FAIL\n");
return -EINVAL;
}
if (value == 0)
@@ -88,14 +1665,13 @@ static int hdmi_ioctl(struct inode *inode, struct file *file,
else
config.hdmi_format.hdmi_mode = AV8100_HDMI_ON;
- if (av8100_configuration_prepare(AV8100_COMMAND_HDMI, &config)
- != AV8100_OK) {
- printk(KERN_ERR "av8100_configuration_prepare FAIL\n");
+ if (av8100_conf_prep(AV8100_COMMAND_HDMI, &config) != 0) {
+ dev_err(hdmidev, "av8100_conf_prep FAIL\n");
return -EINVAL;
}
- if (av8100_configuration_write(AV8100_COMMAND_HDMI, NULL, NULL,
- I2C_INTERFACE) != AV8100_OK) {
- printk(KERN_ERR "av8100_configuration_write FAIL\n");
+ if (av8100_conf_w(AV8100_COMMAND_HDMI, NULL, NULL,
+ I2C_INTERFACE) != 0) {
+ dev_err(hdmidev, "av8100_conf_w FAIL\n");
return -EINVAL;
}
break;
@@ -106,9 +1682,8 @@ static int hdmi_ioctl(struct inode *inode, struct file *file,
return -EINVAL;
}
- if (av8100_register_write(reg.offset, reg.value) !=
- AV8100_OK) {
- printk(KERN_ERR "hdmi_register_write FAIL\n");
+ if (av8100_reg_w(reg.offset, reg.value) != 0) {
+ dev_err(hdmidev, "hdmi_register_write FAIL\n");
return -EINVAL;
}
break;
@@ -119,9 +1694,8 @@ static int hdmi_ioctl(struct inode *inode, struct file *file,
return -EINVAL;
}
- if (av8100_register_read(reg.offset, &reg.value) !=
- AV8100_OK) {
- printk(KERN_ERR "hdmi_register_write FAIL\n");
+ if (av8100_reg_r(reg.offset, &reg.value) != 0) {
+ dev_err(hdmidev, "hdmi_register_write FAIL\n");
return -EINVAL;
}
@@ -143,18 +1717,18 @@ static int hdmi_ioctl(struct inode *inode, struct file *file,
case IOC_HDMI_CONFIGURATION_WRITE:
if (copy_from_user(&command_reg, (void *)arg,
sizeof(struct hdmi_command_register)) != 0) {
- printk(KERN_ERR "IOC_HDMI_CONFIGURATION_WRITE fail 1\n");
- command_reg.return_status =
- HDMI_COMMAND_RETURN_STATUS_FAIL;
+ dev_err(hdmidev, "IOC_HDMI_CONFIGURATION_WRITE "
+ "fail 1\n");
+ command_reg.return_status = EINVAL;
} else {
- if (av8100_configuration_write_raw(command_reg.cmd_id,
+ if (av8100_conf_w_raw(command_reg.cmd_id,
command_reg.buf_len,
command_reg.buf,
&(command_reg.buf_len),
- command_reg.buf) != AV8100_OK) {
- printk(KERN_ERR "IOC_HDMI_CONFIGURATION_WRITE fail 1\n");
- command_reg.return_status =
- HDMI_COMMAND_RETURN_STATUS_FAIL;
+ command_reg.buf) != 0) {
+ dev_err(hdmidev, "IOC_HDMI_CONFIGURATION_WRITE "
+ "fail 2\n");
+ command_reg.return_status = EINVAL;
}
}
@@ -168,28 +1742,183 @@ static int hdmi_ioctl(struct inode *inode, struct file *file,
break;
}
- return retval;
+ return 0;
+}
+
+static unsigned int
+hdmi_poll(struct file *filp, poll_table *wait)
+{
+ unsigned int mask = 0;
+
+ dev_dbg(hdmidev, "%s\n", __func__);
+
+ poll_wait(filp, &hdmi_event_wq , wait);
+
+ LOCK_HDMI_EVENTS;
+ if (events_received == true) {
+ events_received = false;
+ mask = POLLIN | POLLRDNORM;
+ }
+ UNLOCK_HDMI_EVENTS;
+
+ return mask;
}
static const struct file_operations hdmi_fops = {
.owner = THIS_MODULE,
.open = hdmi_open,
.release = hdmi_release,
- .ioctl = hdmi_ioctl
+ .ioctl = hdmi_ioctl,
+ .poll = hdmi_poll
};
static struct miscdevice hdmi_miscdev = {
- HDMI_DRIVER_MINOR_NUMBER,
+ MISC_DYNAMIC_MINOR,
"hdmi",
&hdmi_fops
};
+/* Event callback function called by hw driver */
+void hdmi_event(enum av8100_hdmi_event ev)
+{
+ int events_old;
+ int events_new;
+ struct kobject *kobj = &hdmidev->kobj;
+
+ dev_dbg(hdmidev, "hdmi_event %02x\n", ev);
+
+ LOCK_HDMI_EVENTS;
+
+ events_old = events;
+
+ /* Set event */
+ switch (ev) {
+ case AV8100_HDMI_EVENT_HDMI_PLUGIN:
+ events |= events_mask & HDMI_EVENT_HDMI_PLUGIN;
+ break;
+
+ case AV8100_HDMI_EVENT_HDMI_PLUGOUT:
+ events |= events_mask & HDMI_EVENT_HDMI_PLUGOUT;
+ break;
+
+ case AV8100_HDMI_EVENT_CEC:
+ events |= events_mask & HDMI_EVENT_CEC;
+ break;
+
+ case AV8100_HDMI_EVENT_HDCP:
+ events |= events_mask & HDMI_EVENT_HDCP;
+ break;
+
+ default:
+ break;
+ }
+
+ events_new = events;
+
+ UNLOCK_HDMI_EVENTS;
+
+ dev_dbg(hdmidev, "hdmi events:%02x, events_old:%02x mask:%02x\n",
+ events_new, events_old, events_mask);
+
+ if (events_new != events_old) {
+ /* Wake up application waiting for event via call to poll() */
+ sysfs_notify(kobj, NULL, SYSFS_EVENT_FILENAME);
+
+ LOCK_HDMI_EVENTS;
+ events_received = true;
+ UNLOCK_HDMI_EVENTS;
+
+ wake_up_interruptible(&hdmi_event_wq);
+ }
+}
+
int __init hdmi_init(void)
{
- return misc_register(&hdmi_miscdev);
+ int ret;
+ struct hdmi_driver_data *hdmi_driver_data;
+
+ ret = misc_register(&hdmi_miscdev);
+ if (ret)
+ goto hdmi_init_out;
+
+ hdmidev = hdmi_miscdev.this_device;
+
+ hdmidev->driver_data =
+ kzalloc(sizeof(struct hdmi_driver_data), GFP_KERNEL);
+
+ if (!hdmidev->driver_data)
+ return -ENOMEM;
+
+ hdmi_driver_data = dev_get_drvdata(hdmidev);
+
+ /* Default sysfs file format is hextext */
+ hdmi_driver_data->store_as_hextext = true;
+
+ init_waitqueue_head(&hdmi_event_wq);
+
+ if (device_create_file(hdmidev, &dev_attr_storeastext))
+ dev_info(hdmidev, "Unable to create storeastext attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_plugdeten))
+ dev_info(hdmidev, "Unable to create plugdeten attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_edidread))
+ dev_info(hdmidev, "Unable to create edidread attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_ceceven))
+ dev_info(hdmidev, "Unable to create ceceven attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_cecread))
+ dev_info(hdmidev, "Unable to create cecread attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_cecsend))
+ dev_info(hdmidev, "Unable to create cecsend attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_infofrsend))
+ dev_info(hdmidev, "Unable to create infofrsend attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcpeven))
+ dev_info(hdmidev, "Unable to create hdcpeven attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcpchkaesotp))
+ dev_info(hdmidev, "Unable to create hdcpchkaesotp attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcpfuseaes))
+ dev_info(hdmidev, "Unable to create hdcpfuseaes attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcploadaes))
+ dev_info(hdmidev, "Unable to create hdcploadaes attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcpauthencr))
+ dev_info(hdmidev, "Unable to create hdcpauthreq attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_hdcpstateget))
+ dev_info(hdmidev, "Unable to create hdcpstateget attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_evread))
+ dev_info(hdmidev, "Unable to create evread attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_evclr))
+ dev_info(hdmidev, "Unable to create evclr attribute\n");
+ if (device_create_file(hdmidev, &dev_attr_audiocfg))
+ dev_info(hdmidev, "Unable to create audiocfg attribute\n");
+
+ /* Register event callback */
+ av8100_hdmi_event_cb_set(hdmi_event);
+
+hdmi_init_out:
+ return ret;
}
void hdmi_exit(void)
{
+ /* Deregister event callback */
+ av8100_hdmi_event_cb_set(NULL);
+
+ device_remove_file(hdmidev, &dev_attr_storeastext);
+ device_remove_file(hdmidev, &dev_attr_plugdeten);
+ device_remove_file(hdmidev, &dev_attr_edidread);
+ device_remove_file(hdmidev, &dev_attr_ceceven);
+ device_remove_file(hdmidev, &dev_attr_cecread);
+ device_remove_file(hdmidev, &dev_attr_cecsend);
+ device_remove_file(hdmidev, &dev_attr_infofrsend);
+ device_remove_file(hdmidev, &dev_attr_hdcpeven);
+ device_remove_file(hdmidev, &dev_attr_hdcpchkaesotp);
+ device_remove_file(hdmidev, &dev_attr_hdcpfuseaes);
+ device_remove_file(hdmidev, &dev_attr_hdcploadaes);
+ device_remove_file(hdmidev, &dev_attr_hdcpauthencr);
+ device_remove_file(hdmidev, &dev_attr_hdcpstateget);
+ device_remove_file(hdmidev, &dev_attr_evread);
+ device_remove_file(hdmidev, &dev_attr_evclr);
+ device_remove_file(hdmidev, &dev_attr_audiocfg);
+
+ kfree(hdmidev->driver_data);
+
misc_deregister(&hdmi_miscdev);
}