text:
#include <linux/clk.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/workqueue.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <sound/initval.h>

#include <video/sh_mobile_hdmi.h>
#include <video/sh_mobile_lcdc.h>

#include "sh_mobile_lcdcfb.h"

#define HDMI_SYSTEM_CTRL			0x00 /* System control */
#define HDMI_L_R_DATA_SWAP_CTRL_RPKT		0x01 /* L/R data swap control,
							bits 19..16 of 20-bit N for Audio Clock Regeneration packet */
#define HDMI_20_BIT_N_FOR_AUDIO_RPKT_15_8	0x02 /* bits 15..8 of 20-bit N for Audio Clock Regeneration packet */
#define HDMI_20_BIT_N_FOR_AUDIO_RPKT_7_0	0x03 /* bits 7..0 of 20-bit N for Audio Clock Regeneration packet */
#define HDMI_SPDIF_AUDIO_SAMP_FREQ_CTS		0x04 /* SPDIF audio sampling frequency,
							bits 19..16 of Internal CTS */
#define HDMI_INTERNAL_CTS_15_8			0x05 /* bits 15..8 of Internal CTS */
#define HDMI_INTERNAL_CTS_7_0			0x06 /* bits 7..0 of Internal CTS */
#define HDMI_EXTERNAL_CTS_19_16			0x07 /* External CTS */
#define HDMI_EXTERNAL_CTS_15_8			0x08 /* External CTS */
#define HDMI_EXTERNAL_CTS_7_0			0x09 /* External CTS */
#define HDMI_AUDIO_SETTING_1			0x0A /* Audio setting.1 */
#define HDMI_AUDIO_SETTING_2			0x0B /* Audio setting.2 */
#define HDMI_I2S_AUDIO_SET			0x0C /* I2S audio setting */
#define HDMI_DSD_AUDIO_SET			0x0D /* DSD audio setting */
#define HDMI_DEBUG_MONITOR_1			0x0E /* Debug monitor.1 */
#define HDMI_DEBUG_MONITOR_2			0x0F /* Debug monitor.2 */
#define HDMI_I2S_INPUT_PIN_SWAP			0x10 /* I2S input pin swap */
#define HDMI_AUDIO_STATUS_BITS_SETTING_1	0x11 /* Audio status bits setting.1 */
#define HDMI_AUDIO_STATUS_BITS_SETTING_2	0x12 /* Audio status bits setting.2 */
#define HDMI_CATEGORY_CODE			0x13 /* Category code */
#define HDMI_SOURCE_NUM_AUDIO_WORD_LEN		0x14 /* Source number/Audio word length */
#define HDMI_AUDIO_VIDEO_SETTING_1		0x15 /* Audio/Video setting.1 */
#define HDMI_VIDEO_SETTING_1			0x16 /* Video setting.1 */
#define HDMI_DEEP_COLOR_MODES			0x17 /* Deep Color Modes */

/* 12 16- and 10-bit Color space conversion parameters: 0x18..0x2f */
#define HDMI_COLOR_SPACE_CONVERSION_PARAMETERS	0x18

#define HDMI_EXTERNAL_VIDEO_PARAM_SETTINGS	0x30 /* External video parameter settings */
#define HDMI_EXTERNAL_H_TOTAL_7_0		0x31 /* External horizontal total (LSB) */
#define HDMI_EXTERNAL_H_TOTAL_11_8		0x32 /* External horizontal total (MSB) */
#define HDMI_EXTERNAL_H_BLANK_7_0		0x33 /* External horizontal blank (LSB) */
#define HDMI_EXTERNAL_H_BLANK_9_8		0x34 /* External horizontal blank (MSB) */
#define HDMI_EXTERNAL_H_DELAY_7_0		0x35 /* External horizontal delay (LSB) */
#define HDMI_EXTERNAL_H_DELAY_9_8		0x36 /* External horizontal delay (MSB) */
#define HDMI_EXTERNAL_H_DURATION_7_0		0x37 /* External horizontal duration (LSB) */
#define HDMI_EXTERNAL_H_DURATION_9_8		0x38 /* External horizontal duration (MSB) */
#define HDMI_EXTERNAL_V_TOTAL_7_0		0x39 /* External vertical total (LSB) */
#define HDMI_EXTERNAL_V_TOTAL_9_8		0x3A /* External vertical total (MSB) */
#define HDMI_AUDIO_VIDEO_SETTING_2		0x3B /* Audio/Video setting.2 */
#define HDMI_EXTERNAL_V_BLANK			0x3D /* External vertical blank */
#define HDMI_EXTERNAL_V_DELAY			0x3E /* External vertical delay */
#define HDMI_EXTERNAL_V_DURATION		0x3F /* External vertical duration */
#define HDMI_CTRL_PKT_MANUAL_SEND_CONTROL	0x40 /* Control packet manual send control */
#define HDMI_CTRL_PKT_AUTO_SEND			0x41 /* Control packet auto send with VSYNC control */
#define HDMI_AUTO_CHECKSUM_OPTION		0x42 /* Auto checksum option */
#define HDMI_VIDEO_SETTING_2			0x45 /* Video setting.2 */
#define HDMI_OUTPUT_OPTION			0x46 /* Output option */
#define HDMI_SLIPHDMIT_PARAM_OPTION		0x51 /* SLIPHDMIT parameter option */
#define HDMI_HSYNC_PMENT_AT_EMB_7_0		0x52 /* HSYNC placement at embedded sync (LSB) */
#define HDMI_HSYNC_PMENT_AT_EMB_15_8		0x53 /* HSYNC placement at embedded sync (MSB) */
#define HDMI_VSYNC_PMENT_AT_EMB_7_0		0x54 /* VSYNC placement at embedded sync (LSB) */
#define HDMI_VSYNC_PMENT_AT_EMB_14_8		0x55 /* VSYNC placement at embedded sync (MSB) */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_1		0x56 /* SLIPHDMIT parameter settings.1 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_2		0x57 /* SLIPHDMIT parameter settings.2 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_3		0x58 /* SLIPHDMIT parameter settings.3 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_5		0x59 /* SLIPHDMIT parameter settings.5 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_6		0x5A /* SLIPHDMIT parameter settings.6 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_7		0x5B /* SLIPHDMIT parameter settings.7 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_8		0x5C /* SLIPHDMIT parameter settings.8 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_9		0x5D /* SLIPHDMIT parameter settings.9 */
#define HDMI_SLIPHDMIT_PARAM_SETTINGS_10	0x5E /* SLIPHDMIT parameter settings.10 */
#define HDMI_CTRL_PKT_BUF_INDEX			0x5F /* Control packet buffer index */
#define HDMI_CTRL_PKT_BUF_ACCESS_HB0		0x60 /* Control packet data buffer access window - HB0 */
#define HDMI_CTRL_PKT_BUF_ACCESS_HB1		0x61 /* Control packet data buffer access window - HB1 */
#define HDMI_CTRL_PKT_BUF_ACCESS_HB2		0x62 /* Control packet data buffer access window - HB2 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB0		0x63 /* Control packet data buffer access window - PB0 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB1		0x64 /* Control packet data buffer access window - PB1 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB2		0x65 /* Control packet data buffer access window - PB2 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB3		0x66 /* Control packet data buffer access window - PB3 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB4		0x67 /* Control packet data buffer access window - PB4 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB5		0x68 /* Control packet data buffer access window - PB5 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB6		0x69 /* Control packet data buffer access window - PB6 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB7		0x6A /* Control packet data buffer access window - PB7 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB8		0x6B /* Control packet data buffer access window - PB8 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB9		0x6C /* Control packet data buffer access window - PB9 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB10		0x6D /* Control packet data buffer access window - PB10 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB11		0x6E /* Control packet data buffer access window - PB11 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB12		0x6F /* Control packet data buffer access window - PB12 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB13		0x70 /* Control packet data buffer access window - PB13 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB14		0x71 /* Control packet data buffer access window - PB14 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB15		0x72 /* Control packet data buffer access window - PB15 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB16		0x73 /* Control packet data buffer access window - PB16 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB17		0x74 /* Control packet data buffer access window - PB17 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB18		0x75 /* Control packet data buffer access window - PB18 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB19		0x76 /* Control packet data buffer access window - PB19 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB20		0x77 /* Control packet data buffer access window - PB20 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB21		0x78 /* Control packet data buffer access window - PB21 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB22		0x79 /* Control packet data buffer access window - PB22 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB23		0x7A /* Control packet data buffer access window - PB23 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB24		0x7B /* Control packet data buffer access window - PB24 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB25		0x7C /* Control packet data buffer access window - PB25 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB26		0x7D /* Control packet data buffer access window - PB26 */
#define HDMI_CTRL_PKT_BUF_ACCESS_PB27		0x7E /* Control packet data buffer access window - PB27 */
#define HDMI_EDID_KSV_FIFO_ACCESS_WINDOW	0x80 /* EDID/KSV FIFO access window */
#define HDMI_DDC_BUS_ACCESS_FREQ_CTRL_7_0	0x81 /* DDC bus access frequency control (LSB) */
#define HDMI_DDC_BUS_ACCESS_FREQ_CTRL_15_8	0x82 /* DDC bus access frequency control (MSB) */
#define HDMI_INTERRUPT_MASK_1			0x92 /* Interrupt mask.1 */
#define HDMI_INTERRUPT_MASK_2			0x93 /* Interrupt mask.2 */
#define HDMI_INTERRUPT_STATUS_1			0x94 /* Interrupt status.1 */
#define HDMI_INTERRUPT_STATUS_2			0x95 /* Interrupt status.2 */
#define HDMI_INTERRUPT_MASK_3			0x96 /* Interrupt mask.3 */
#define HDMI_INTERRUPT_MASK_4			0x97 /* Interrupt mask.4 */
#define HDMI_INTERRUPT_STATUS_3			0x98 /* Interrupt status.3 */
#define HDMI_INTERRUPT_STATUS_4			0x99 /* Interrupt status.4 */
#define HDMI_SOFTWARE_HDCP_CONTROL_1		0x9A /* Software HDCP control.1 */
#define HDMI_FRAME_COUNTER			0x9C /* Frame counter */
#define HDMI_FRAME_COUNTER_FOR_RI_CHECK		0x9D /* Frame counter for Ri check */
#define HDMI_HDCP_CONTROL			0xAF /* HDCP control */
#define HDMI_RI_FRAME_COUNT_REGISTER		0xB2 /* Ri frame count register */
#define HDMI_DDC_BUS_CONTROL			0xB7 /* DDC bus control */
#define HDMI_HDCP_STATUS			0xB8 /* HDCP status */
#define HDMI_SHA0				0xB9 /* sha0 */
#define HDMI_SHA1				0xBA /* sha1 */
#define HDMI_SHA2				0xBB /* sha2 */
#define HDMI_SHA3				0xBC /* sha3 */
#define HDMI_SHA4				0xBD /* sha4 */
#define HDMI_BCAPS_READ				0xBE /* BCAPS read / debug */
#define HDMI_AKSV_BKSV_7_0_MONITOR		0xBF /* AKSV/BKSV[7:0] monitor */
#define HDMI_AKSV_BKSV_15_8_MONITOR		0xC0 /* AKSV/BKSV[15:8] monitor */
#define HDMI_AKSV_BKSV_23_16_MONITOR		0xC1 /* AKSV/BKSV[23:16] monitor */
#define HDMI_AKSV_BKSV_31_24_MONITOR		0xC2 /* AKSV/BKSV[31:24] monitor */
#define HDMI_AKSV_BKSV_39_32_MONITOR		0xC3 /* AKSV/BKSV[39:32] monitor */
#define HDMI_EDID_SEGMENT_POINTER		0xC4 /* EDID segment pointer */
#define HDMI_EDID_WORD_ADDRESS			0xC5 /* EDID word address */
#define HDMI_EDID_DATA_FIFO_ADDRESS		0xC6 /* EDID data FIFO address */
#define HDMI_NUM_OF_HDMI_DEVICES		0xC7 /* Number of HDMI devices */
#define HDMI_HDCP_ERROR_CODE			0xC8 /* HDCP error code */
#define HDMI_100MS_TIMER_SET			0xC9 /* 100ms timer setting */
#define HDMI_5SEC_TIMER_SET			0xCA /* 5sec timer setting */
#define HDMI_RI_READ_COUNT			0xCB /* Ri read count */
#define HDMI_AN_SEED				0xCC /* An seed */
#define HDMI_MAX_NUM_OF_RCIVRS_ALLOWED		0xCD /* Maximum number of receivers allowed */
#define HDMI_HDCP_MEMORY_ACCESS_CONTROL_1	0xCE /* HDCP memory access control.1 */
#define HDMI_HDCP_MEMORY_ACCESS_CONTROL_2	0xCF /* HDCP memory access control.2 */
#define HDMI_HDCP_CONTROL_2			0xD0 /* HDCP Control 2 */
#define HDMI_HDCP_KEY_MEMORY_CONTROL		0xD2 /* HDCP Key Memory Control */
#define HDMI_COLOR_SPACE_CONV_CONFIG_1		0xD3 /* Color space conversion configuration.1 */
#define HDMI_VIDEO_SETTING_3			0xD4 /* Video setting.3 */
#define HDMI_RI_7_0				0xD5 /* Ri[7:0] */
#define HDMI_RI_15_8				0xD6 /* Ri[15:8] */
#define HDMI_PJ					0xD7 /* Pj */
#define HDMI_SHA_RD				0xD8 /* sha_rd */
#define HDMI_RI_7_0_SAVED			0xD9 /* Ri[7:0] saved */
#define HDMI_RI_15_8_SAVED			0xDA /* Ri[15:8] saved */
#define HDMI_PJ_SAVED				0xDB /* Pj saved */
#define HDMI_NUM_OF_DEVICES			0xDC /* Number of devices */
#define HDMI_HOT_PLUG_MSENS_STATUS		0xDF /* Hot plug/MSENS status */
#define HDMI_BCAPS_WRITE			0xE0 /* bcaps */
#define HDMI_BSTAT_7_0				0xE1 /* bstat[7:0] */
#define HDMI_BSTAT_15_8				0xE2 /* bstat[15:8] */
#define HDMI_BKSV_7_0				0xE3 /* bksv[7:0] */
#define HDMI_BKSV_15_8				0xE4 /* bksv[15:8] */
#define HDMI_BKSV_23_16				0xE5 /* bksv[23:16] */
#define HDMI_BKSV_31_24				0xE6 /* bksv[31:24] */
#define HDMI_BKSV_39_32				0xE7 /* bksv[39:32] */
#define HDMI_AN_7_0				0xE8 /* An[7:0] */
#define HDMI_AN_15_8				0xE9 /* An [15:8] */
#define HDMI_AN_23_16				0xEA /* An [23:16] */
#define HDMI_AN_31_24				0xEB /* An [31:24] */
#define HDMI_AN_39_32				0xEC /* An [39:32] */
#define HDMI_AN_47_40				0xED /* An [47:40] */
#define HDMI_AN_55_48				0xEE /* An [55:48] */
#define HDMI_AN_63_56				0xEF /* An [63:56] */
#define HDMI_PRODUCT_ID				0xF0 /* Product ID */
#define HDMI_REVISION_ID			0xF1 /* Revision ID */
#define HDMI_TEST_MODE				0xFE /* Test mode */

enum hotplug_state {
	HDMI_HOTPLUG_DISCONNECTED,
	HDMI_HOTPLUG_CONNECTED,
	HDMI_HOTPLUG_EDID_DONE,
};

struct sh_hdmi {
	void __iomem *base;
	enum hotplug_state hp_state;	/* hot-plug status */
	u8 preprogrammed_vic;		/* use a pre-programmed VIC or
					   the external mode */
	u8 edid_block_addr;
	u8 edid_segment_nr;
	u8 edid_blocks;
	struct clk *hdmi_clk;
	struct device *dev;
	struct fb_info *info;
	struct mutex mutex;		/* Protect the info pointer */
	struct delayed_work edid_work;
	struct fb_var_screeninfo var;
	struct fb_monspecs monspec;
	struct notifier_block notifier;
};

static void hdmi_write(struct sh_hdmi *hdmi, u8 data, u8 reg)
{
	iowrite8(data, hdmi->base + reg);
}

static u8 hdmi_read(struct sh_hdmi *hdmi, u8 reg)
{
	return ioread8(hdmi->base + reg);
}

/*
 *	HDMI sound
 */
static unsigned int sh_hdmi_snd_read(struct snd_soc_codec *codec,
				     unsigned int reg)
{
	struct sh_hdmi *hdmi = snd_soc_codec_get_drvdata(codec);

	return hdmi_read(hdmi, reg);
}

static int sh_hdmi_snd_write(struct snd_soc_codec *codec,
			     unsigned int reg,
			     unsigned int value)
{
	struct sh_hdmi *hdmi = snd_soc_codec_get_drvdata(codec);

	hdmi_write(hdmi, value, reg);
	return 0;
}

static struct snd_soc_dai_driver sh_hdmi_dai = {
	.name = "sh_mobile_hdmi-hifi",
	.playback = {
		.stream_name = "Playback",
		.channels_min = 2,
		.channels_max = 8,
		.rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100  |
			 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200  |
			 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |
			 SNDRV_PCM_RATE_192000,
		.formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE,
	},
};

static int sh_hdmi_snd_probe(struct snd_soc_codec *codec)
{
	dev_info(codec->dev, "SH Mobile HDMI Audio Codec");

	return 0;
}

static struct snd_soc_codec_driver soc_codec_dev_sh_hdmi = {
	.probe		= sh_hdmi_snd_probe,
	.read		= sh_hdmi_snd_read,
	.write		= sh_hdmi_snd_write,
};

/*
 *	HDMI video
 */

/* External video parameter settings */
static void sh_hdmi_external_video_param(struct sh_hdmi *hdmi)
{
	struct fb_var_screeninfo *var = &hdmi->var;
	u16 htotal, hblank, hdelay, vtotal, vblank, vdelay, voffset;
	u8 sync = 0;

	htotal = var->xres + var->right_margin + var->left_margin + var->hsync_len;

	hdelay = var->hsync_len + var->left_margin;
	hblank = var->right_margin + hdelay;

	/*
	 * Vertical timing looks a bit different in Figure 18,
	 * but let's try the same first by setting offset = 0
	 */
	vtotal = var->yres + var->upper_margin + var->lower_margin + var->vsync_len;

	vdelay = var->vsync_len + var->upper_margin;
	vblank = var->lower_margin + vdelay;
	voffset = min(var->upper_margin / 2, 6U);

	/*
	 * [3]: VSYNC polarity: Positive
	 * [2]: HSYNC polarity: Positive
	 * [1]: Interlace/Progressive: Progressive
	 * [0]: External video settings enable: used.
	 */
	if (var->sync & FB_SYNC_HOR_HIGH_ACT)
		sync |= 4;
	if (var->sync & FB_SYNC_VERT_HIGH_ACT)
		sync |= 8;

	dev_dbg(hdmi->dev, "H: %u, %u, %u, %u; V: %u, %u, %u, %u; sync 0x%x\n",
		htotal, hblank, hdelay, var->hsync_len,
		vtotal, vblank, vdelay, var->vsync_len, sync);

	hdmi_write(hdmi, sync | (voffset << 4), HDMI_EXTERNAL_VIDEO_PARAM_SETTINGS);

	hdmi_write(hdmi, htotal, HDMI_EXTERNAL_H_TOTAL_7_0);
	hdmi_write(hdmi, htotal >> 8, HDMI_EXTERNAL_H_TOTAL_11_8);

	hdmi_write(hdmi, hblank, HDMI_EXTERNAL_H_BLANK_7_0);
	hdmi_write(hdmi, hblank >> 8, HDMI_EXTERNAL_H_BLANK_9_8);

	hdmi_write(hdmi, hdelay, HDMI_EXTERNAL_H_DELAY_7_0);
	hdmi_write(hdmi, hdelay >> 8, HDMI_EXTERNAL_H_DELAY_9_8);

	hdmi_write(hdmi, var->hsync_len, HDMI_EXTERNAL_H_DURATION_7_0);
	hdmi_write(hdmi, var->hsync_len >> 8, HDMI_EXTERNAL_H_DURATION_9_8);

	hdmi_write(hdmi, vtotal, HDMI_EXTERNAL_V_TOTAL_7_0);
	hdmi_write(hdmi, vtotal >> 8, HDMI_EXTERNAL_V_TOTAL_9_8);

	hdmi_write(hdmi, vblank, HDMI_EXTERNAL_V_BLANK);

	hdmi_write(hdmi, vdelay, HDMI_EXTERNAL_V_DELAY);

	hdmi_write(hdmi, var->vsync_len, HDMI_EXTERNAL_V_DURATION);

	/* Set bit 0 of HDMI_EXTERNAL_VIDEO_PARAM_SETTINGS here for external mode */
	if (!hdmi->preprogrammed_vic)
		hdmi_write(hdmi, sync | 1 | (voffset << 4),
			   HDMI_EXTERNAL_VIDEO_PARAM_SETTINGS);
}

/**
 * sh_hdmi_video_config()
 */
static void sh_hdmi_video_config(struct sh_hdmi *hdmi)
{
	/*
	 * [7:4]: Audio sampling frequency: 48kHz
	 * [3:1]: Input video format: RGB and YCbCr 4:4:4 (Y on Green)
	 * [0]: Internal/External DE select: internal
	 */
	hdmi_write(hdmi, 0x20, HDMI_AUDIO_VIDEO_SETTING_1);

	/*
	 * [7:6]: Video output format: RGB 4:4:4
	 * [5:4]: Input video data width: 8 bit
	 * [3:1]: EAV/SAV location: channel 1
	 * [0]: Video input color space: RGB
	 */
	hdmi_write(hdmi, 0x34, HDMI_VIDEO_SETTING_1);

	/*
	 * [7:6]: Together with bit [6] of HDMI_AUDIO_VIDEO_SETTING_2, which is
	 * left at 0 by default, this configures 24bpp and sets the Color Depth
	 * (CD) field in the General Control Packet
	 */
	hdmi_write(hdmi, 0x20, HDMI_DEEP_COLOR_MODES);
}

/**
 * sh_hdmi_audio_config()
 */
static void sh_hdmi_audio_config(struct sh_hdmi *hdmi)
{
	u8 data;
	struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data;

	/*
	 * [7:4] L/R data swap control
	 * [3:0] appropriate N[19:16]
	 */
	hdmi_write(hdmi, 0x00, HDMI_L_R_DATA_SWAP_CTRL_RPKT);
	/* appropriate N[15:8] */
	hdmi_write(hdmi, 0x18, HDMI_20_BIT_N_FOR_AUDIO_RPKT_15_8);
	/* appropriate N[7:0] */
	hdmi_write(hdmi, 0x00, HDMI_20_BIT_N_FOR_AUDIO_RPKT_7_0);

	/* [7:4] 48 kHz	SPDIF not used */
	hdmi_write(hdmi, 0x20, HDMI_SPDIF_AUDIO_SAMP_FREQ_CTS);

	/*
	 * [6:5] set required down sampling rate if required
	 * [4:3] set required audio source
	 */
	switch (pdata->flags & HDMI_SND_SRC_MASK) {
	default:
		/* fall through */
	case HDMI_SND_SRC_I2S:
		data = 0x0 << 3;
		break;
	case HDMI_SND_SRC_SPDIF:
		data = 0x1 << 3;
		break;
	case HDMI_SND_SRC_DSD:
		data = 0x2 << 3;
		break;
	case HDMI_SND_SRC_HBR:
		data = 0x3 << 3;
		break;
	}
	hdmi_write(hdmi, data, HDMI_AUDIO_SETTING_1);

	/* [3:0] set sending channel number for channel status */
	hdmi_write(hdmi, 0x40, HDMI_AUDIO_SETTING_2);

	/*
	 * [5:2] set valid I2S source input pin
	 * [1:0] set input I2S source mode
	 */
	hdmi_write(hdmi, 0x04, HDMI_I2S_AUDIO_SET);

	/* [7:4] set valid DSD source input pin */
	hdmi_write(hdmi, 0x00, HDMI_DSD_AUDIO_SET);

	/* [7:0] set appropriate I2S input pin swap settings if required */
	hdmi_write(hdmi, 0x00, HDMI_I2S_INPUT_PIN_SWAP);

	/*
	 * [7] set validity bit for channel status
	 * [3:0] set original sample frequency for channel status
	 */
	hdmi_write(hdmi, 0x00, HDMI_AUDIO_STATUS_BITS_SETTING_1);

	/*
	 * [7] set value for channel status
	 * [6] set value for channel status
	 * [5] set copyright bit for channel status
	 * [4:2] set additional information for channel status
	 * [1:0] set clock accuracy for channel status
	 */
	hdmi_write(hdmi, 0x00, HDMI_AUDIO_STATUS_BITS_SETTING_2);

	/* [7:0] set category code for channel status */
	hdmi_write(hdmi, 0x00, HDMI_CATEGORY_CODE);

	/*
	 * [7:4] set source number for channel status
	 * [3:0] set word length for channel status
	 */
	hdmi_write(hdmi, 0x00, HDMI_SOURCE_NUM_AUDIO_WORD_LEN);

	/* [7:4] set sample frequency for channel status */
	hdmi_write(hdmi, 0x20, HDMI_AUDIO_VIDEO_SETTING_1);
}

/**
 * sh_hdmi_phy_config() - configure the HDMI PHY for the used video mode
 */
static void sh_hdmi_phy_config(struct sh_hdmi *hdmi)
{
	if (hdmi->var.pixclock < 10000) {
		/* for 1080p8bit 148MHz */
		hdmi_write(hdmi, 0x1d, HDMI_SLIPHDMIT_PARAM_SETTINGS_1);
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_2);
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_3);
		hdmi_write(hdmi, 0x4c, HDMI_SLIPHDMIT_PARAM_SETTINGS_5);
		hdmi_write(hdmi, 0x1e, HDMI_SLIPHDMIT_PARAM_SETTINGS_6);
		hdmi_write(hdmi, 0x48, HDMI_SLIPHDMIT_PARAM_SETTINGS_7);
		hdmi_write(hdmi, 0x0e, HDMI_SLIPHDMIT_PARAM_SETTINGS_8);
		hdmi_write(hdmi, 0x25, HDMI_SLIPHDMIT_PARAM_SETTINGS_9);
		hdmi_write(hdmi, 0x04, HDMI_SLIPHDMIT_PARAM_SETTINGS_10);
	} else if (hdmi->var.pixclock < 30000) {
		/* 720p, 8bit, 74.25MHz. Might need to be adjusted for other formats */
		/*
		 * [1:0]	Speed_A
		 * [3:2]	Speed_B
		 * [4]		PLLA_Bypass
		 * [6]		DRV_TEST_EN
		 * [7]		DRV_TEST_IN
		 */
		hdmi_write(hdmi, 0x0f, HDMI_SLIPHDMIT_PARAM_SETTINGS_1);
		/* PLLB_CONFIG[17], PLLA_CONFIG[17] - not in PHY datasheet */
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_2);
		/*
		 * [2:0]	BGR_I_OFFSET
		 * [6:4]	BGR_V_OFFSET
		 */
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_3);
		/* PLLA_CONFIG[7:0]: VCO gain, VCO offset, LPF resistance[0] */
		hdmi_write(hdmi, 0x44, HDMI_SLIPHDMIT_PARAM_SETTINGS_5);
		/*
		 * PLLA_CONFIG[15:8]: regulator voltage[0], CP current,
		 * LPF capacitance, LPF resistance[1]
		 */
		hdmi_write(hdmi, 0x32, HDMI_SLIPHDMIT_PARAM_SETTINGS_6);
		/* PLLB_CONFIG[7:0]: LPF resistance[0], VCO offset, VCO gain */
		hdmi_write(hdmi, 0x4A, HDMI_SLIPHDMIT_PARAM_SETTINGS_7);
		/*
		 * PLLB_CONFIG[15:8]: regulator voltage[0], CP current,
		 * LPF capacitance, LPF resistance[1]
		 */
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_8);
		/* DRV_CONFIG, PE_CONFIG */
		hdmi_write(hdmi, 0x25, HDMI_SLIPHDMIT_PARAM_SETTINGS_9);
		/*
		 * [2:0]	AMON_SEL (4 == LPF voltage)
		 * [4]		PLLA_CONFIG[16]
		 * [5]		PLLB_CONFIG[16]
		 */
		hdmi_write(hdmi, 0x04, HDMI_SLIPHDMIT_PARAM_SETTINGS_10);
	} else {
		/* for 480p8bit 27MHz */
		hdmi_write(hdmi, 0x19, HDMI_SLIPHDMIT_PARAM_SETTINGS_1);
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_2);
		hdmi_write(hdmi, 0x00, HDMI_SLIPHDMIT_PARAM_SETTINGS_3);
		hdmi_write(hdmi, 0x44, HDMI_SLIPHDMIT_PARAM_SETTINGS_5);
		hdmi_write(hdmi, 0x32, HDMI_SLIPHDMIT_PARAM_SETTINGS_6);
		hdmi_write(hdmi, 0x48, HDMI_SLIPHDMIT_PARAM_SETTINGS_7);
		hdmi_write(hdmi, 0x0F, HDMI_SLIPHDMIT_PARAM_SETTINGS_8);
		hdmi_write(hdmi, 0x20, HDMI_SLIPHDMIT_PARAM_SETTINGS_9);
		hdmi_write(hdmi, 0x04, HDMI_SLIPHDMIT_PARAM_SETTINGS_10);
	}
}

/**
 * sh_hdmi_avi_infoframe_setup() - Auxiliary Video Information InfoFrame CONTROL PACKET
 */
static void sh_hdmi_avi_infoframe_setup(struct sh_hdmi *hdmi)
{
	u8 vic;

	/* AVI InfoFrame */
	hdmi_write(hdmi, 0x06, HDMI_CTRL_PKT_BUF_INDEX);

	/* Packet Type = 0x82 */
	hdmi_write(hdmi, 0x82, HDMI_CTRL_PKT_BUF_ACCESS_HB0);

	/* Version = 0x02 */
	hdmi_write(hdmi, 0x02, HDMI_CTRL_PKT_BUF_ACCESS_HB1);

	/* Length = 13 (0x0D) */
	hdmi_write(hdmi, 0x0D, HDMI_CTRL_PKT_BUF_ACCESS_HB2);

	/* N. A. Checksum */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB0);

	/*
	 * Y = RGB
	 * A0 = No Data
	 * B = Bar Data not valid
	 * S = No Data
	 */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB1);

	/*
	 * [7:6] C = Colorimetry: no data
	 * [5:4] M = 2: 16:9, 1: 4:3 Picture Aspect Ratio
	 * [3:0] R = 8: Active Frame Aspect Ratio: same as picture aspect ratio
	 */
	hdmi_write(hdmi, 0x28, HDMI_CTRL_PKT_BUF_ACCESS_PB2);

	/*
	 * ITC = No Data
	 * EC = xvYCC601
	 * Q = Default (depends on video format)
	 * SC = No Known non_uniform Scaling
	 */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB3);

	/*
	 * VIC should be ignored if external config is used, so, we could just use 0,
	 * but play safe and use a valid value in any case just in case
	 */
	if (hdmi->preprogrammed_vic)
		vic = hdmi->preprogrammed_vic;
	else
		vic = 4;
	hdmi_write(hdmi, vic, HDMI_CTRL_PKT_BUF_ACCESS_PB4);

	/* PR = No Repetition */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB5);

	/* Line Number of End of Top Bar (lower 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB6);

	/* Line Number of End of Top Bar (upper 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB7);

	/* Line Number of Start of Bottom Bar (lower 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB8);

	/* Line Number of Start of Bottom Bar (upper 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB9);

	/* Pixel Number of End of Left Bar (lower 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB10);

	/* Pixel Number of End of Left Bar (upper 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB11);

	/* Pixel Number of Start of Right Bar (lower 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB12);

	/* Pixel Number of Start of Right Bar (upper 8 bits) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB13);
}

/**
 * sh_hdmi_audio_infoframe_setup() - Audio InfoFrame of CONTROL PACKET
 */
static void sh_hdmi_audio_infoframe_setup(struct sh_hdmi *hdmi)
{
	/* Audio InfoFrame */
	hdmi_write(hdmi, 0x08, HDMI_CTRL_PKT_BUF_INDEX);

	/* Packet Type = 0x84 */
	hdmi_write(hdmi, 0x84, HDMI_CTRL_PKT_BUF_ACCESS_HB0);

	/* Version Number = 0x01 */
	hdmi_write(hdmi, 0x01, HDMI_CTRL_PKT_BUF_ACCESS_HB1);

	/* 0 Length = 10 (0x0A) */
	hdmi_write(hdmi, 0x0A, HDMI_CTRL_PKT_BUF_ACCESS_HB2);

	/* n. a. Checksum */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB0);

	/* Audio Channel Count = Refer to Stream Header */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB1);

	/* Refer to Stream Header */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB2);

	/* Format depends on coding type (i.e. CT0...CT3) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB3);

	/* Speaker Channel Allocation = Front Right + Front Left */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB4);

	/* Level Shift Value = 0 dB, Down - mix is permitted or no information */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB5);

	/* Reserved (0) */
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB6);
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB7);
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB8);
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB9);
	hdmi_write(hdmi, 0x00, HDMI_CTRL_PKT_BUF_ACCESS_PB10);
}

/**
 * sh_hdmi_configure() - Initialise HDMI for output
 */
static void sh_hdmi_configure(struct sh_hdmi *hdmi)
{
	/* Configure video format */
	sh_hdmi_video_config(hdmi);

	/* Configure audio format */
	sh_hdmi_audio_config(hdmi);

	/* Configure PHY */
	sh_hdmi_phy_config(hdmi);

	/* Auxiliary Video Information (AVI) InfoFrame */
	sh_hdmi_avi_infoframe_setup(hdmi);

	/* Audio InfoFrame */
	sh_hdmi_audio_infoframe_setup(hdmi);

	/*
	 * Control packet auto send with VSYNC control: auto send
	 * General control, Gamut metadata, ISRC, and ACP packets
	 */
	hdmi_write(hdmi, 0x8E, HDMI_CTRL_PKT_AUTO_SEND);

	/* FIXME */
	msleep(10);

	/* PS mode b->d, reset PLLA and PLLB */
	hdmi_write(hdmi, 0x4C, HDMI_SYSTEM_CTRL);

	udelay(10);

	hdmi_write(hdmi, 0x40, HDMI_SYSTEM_CTRL);
}

static unsigned long sh_hdmi_rate_error(struct sh_hdmi *hdmi,
		const struct fb_videomode *mode,
		unsigned long *hdmi_rate, unsigned long *parent_rate)
{
	unsigned long target = PICOS2KHZ(mode->pixclock) * 1000, rate_error;
	struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data;

	*hdmi_rate = clk_round_rate(hdmi->hdmi_clk, target);
	if ((long)*hdmi_rate < 0)
		*hdmi_rate = clk_get_rate(hdmi->hdmi_clk);

	rate_error = (long)*hdmi_rate > 0 ? abs(*hdmi_rate - target) : ULONG_MAX;
	if (rate_error && pdata->clk_optimize_parent)
		rate_error = pdata->clk_optimize_parent(target, hdmi_rate, parent_rate);
	else if (clk_get_parent(hdmi->hdmi_clk))
		*parent_rate = clk_get_rate(clk_get_parent(hdmi->hdmi_clk));

	dev_dbg(hdmi->dev, "%u-%u-%u-%u x %u-%u-%u-%u\n",
		mode->left_margin, mode->xres,
		mode->right_margin, mode->hsync_len,
		mode->upper_margin, mode->yres,
		mode->lower_margin, mode->vsync_len);

	dev_dbg(hdmi->dev, "\t@%lu(+/-%lu)Hz, e=%lu / 1000, r=%uHz, p=%luHz\n", target,
		rate_error, rate_error ? 10000 / (10 * target / rate_error) : 0,
		mode->refresh, *parent_rate);

	return rate_error;
}

static int sh_hdmi_read_edid(struct sh_hdmi *hdmi, unsigned long *hdmi_rate,
			     unsigned long *parent_rate)
{
	struct fb_var_screeninfo tmpvar;
	struct fb_var_screeninfo *var = &tmpvar;
	const struct fb_videomode *mode, *found = NULL;
	struct fb_info *info = hdmi->info;
	struct fb_modelist *modelist = NULL;
	unsigned int f_width = 0, f_height = 0, f_refresh = 0;
	unsigned long found_rate_error = ULONG_MAX; /* silly compiler... */
	bool scanning = false, preferred_bad = false;
	u8 edid[128];
	char *forced;
	int i;

	/* Read EDID */
	dev_dbg(hdmi->dev, "Read back EDID code:");
	for (i = 0; i < 128; i++) {
		edid[i] = hdmi_read(hdmi, HDMI_EDID_KSV_FIFO_ACCESS_WINDOW);
#ifdef DEBUG
		if ((i % 16) == 0) {
			printk(KERN_CONT "\n");
			printk(KERN_DEBUG "%02X | %02X", i, edid[i]);
		} else {
			printk(KERN_CONT " %02X", edid[i]);
		}
#endif
	}
#ifdef DEBUG
	printk(KERN_CONT "\n");
#endif

	if (!hdmi->edid_blocks) {
		fb_edid_to_monspecs(edid, &hdmi->monspec);
		hdmi->edid_blocks = edid[126] + 1;

		dev_dbg(hdmi->dev, "%d main modes, %d extension blocks\n",
			hdmi->monspec.modedb_len, hdmi->edid_blocks - 1);
	} else {
		dev_dbg(hdmi->dev, "Extension %u detected, DTD start %u\n",
			edid[0], edid[2]);
		fb_edid_add_monspecs(edid, &hdmi->monspec);
	}

	if (hdmi->edid_blocks > hdmi->edid_segment_nr * 2 +
	    (hdmi->edid_block_addr >> 7) + 1) {
		/* More blocks to read */
		if (hdmi->edid_block_addr) {
			hdmi->edid_block_addr = 0;
			hdmi->edid_segment_nr++;
		} else {
			hdmi->edid_block_addr = 0x80;
		}
		/* Set EDID word address  */
		hdmi_write(hdmi, hdmi->edid_block_addr, HDMI_EDID_WORD_ADDRESS);
		/* Enable EDID interrupt */
		hdmi_write(hdmi, 0xC6, HDMI_INTERRUPT_MASK_1);
		/* Set EDID segment pointer - starts reading EDID */
		hdmi_write(hdmi, hdmi->edid_segment_nr, HDMI_EDID_SEGMENT_POINTER);
		return -EAGAIN;
	}

	/* All E-EDID blocks ready */
	dev_dbg(hdmi->dev, "%d main and extended modes\n", hdmi->monspec.modedb_len);

	fb_get_options("sh_mobile_lcdc", &forced);
	if (forced && *forced) {
		/* Only primitive parsing so far */
		i = sscanf(forced, "%ux%u@%u",
			   &f_width, &f_height, &f_refresh);
		if (i < 2) {
			f_width = 0;
			f_height = 0;
		} else {
			/* The user wants us to use the EDID data */
			scanning = true;
		}
		dev_dbg(hdmi->dev, "Forced mode %ux%u@%uHz\n",
			f_width, f_height, f_refresh);
	}

	/* Walk monitor modes to find the best or the exact match */
	for (i = 0, mode = hdmi->monspec.modedb;
	     i < hdmi->monspec.modedb_len && scanning;
	     i++, mode++) {
		unsigned long rate_error;

		if (!f_width && !f_height) {
			/*
			 * A parameter string "video=sh_mobile_lcdc:0x0" means
			 * use the preferred EDID mode. If it is rejected by
			 * .fb_check_var(), keep looking, until an acceptable
			 * one is found.
			 */
			if ((mode->flag & FB_MODE_IS_FIRST) || preferred_bad)
				scanning = false;
			else
				continue;
		} else if (f_width != mode->xres || f_height != mode->yres) {
			/* No interest in unmatching modes */
			continue;
		}

		rate_error = sh_hdmi_rate_error(hdmi, mode, hdmi_rate, parent_rate);

		if (scanning) {
			if (f_refresh == mode->refresh || (!f_refresh && !rate_error))
				/*
				 * Exact match if either the refresh rate
				 * matches or it hasn't been specified and we've
				 * found a mode, for which we can configure the
				 * clock precisely
				 */
				scanning = false;
			else if (found && found_rate_error <= rate_error)
				/*
				 * We otherwise search for the closest matching
				 * clock rate - either if no refresh rate has
				 * been specified or we cannot find an exactly
				 * matching one
				 */
				continue;
		}

		/* Check if supported: sufficient fb memory, supported clock-rate */
		fb_videomode_to_var(var, mode);

		var->bits_per_pixel = info->var.bits_per_pixel;

		if (info && info->fbops->fb_check_var &&
		    info->fbops->fb_check_var(var, info)) {
			scanning = true;
			preferred_bad = true;
			continue;
		}

		found = mode;
		found_rate_error = rate_error;
	}

	hdmi->var.width = hdmi->monspec.max_x * 10;
	hdmi->var.height = hdmi->monspec.max_y * 10;

	/*
	 * TODO 1: if no ->info is present, postpone running the config until
	 * after ->info first gets registered.
	 * TODO 2: consider registering the HDMI platform device from the LCDC
	 * driver, and passing ->info with HDMI platform data.
	 */
	if (info && !found) {
		modelist = info->modelist.next &&
			!list_empty(&info->modelist) ?
			list_entry(info->modelist.next,
				   struct fb_modelist, list) :
			NULL;

		if (modelist) {
			found = &modelist->mode;
			found_rate_error = sh_hdmi_rate_error(hdmi, found, hdmi_rate, parent_rate);
		}
	}

	/* No cookie today */
	if (!found)
		return -ENXIO;

	if (found->xres == 640 && found->yres == 480 && found->refresh == 60)
		hdmi->preprogrammed_vic = 1;
	else if (found->xres == 720 && found->yres == 480 && found->refresh == 60)
		hdmi->preprogrammed_vic = 2;
	else if (found->xres == 720 && found->yres == 576 && found->refresh == 50)
		hdmi->preprogrammed_vic = 17;
	else if (found->xres == 1280 && found->yres == 720 && found->refresh == 60)
		hdmi->preprogrammed_vic = 4;
	else if (found->xres == 1920 && found->yres == 1080 && found->refresh == 24)
		hdmi->preprogrammed_vic = 32;
	else if (found->xres == 1920 && found->yres == 1080 && found->refresh == 50)
		hdmi->preprogrammed_vic = 31;
	else if (found->xres == 1920 && found->yres == 1080 && found->refresh == 60)
		hdmi->preprogrammed_vic = 16;
	else
		hdmi->preprogrammed_vic = 0;

	dev_dbg(hdmi->dev, "Using %s %s mode %ux%u@%uHz (%luHz), clock error %luHz\n",
		modelist ? "default" : "EDID", hdmi->preprogrammed_vic ? "VIC" : "external",
		found->xres, found->yres, found->refresh,
		PICOS2KHZ(found->pixclock) * 1000, found_rate_error);

	fb_videomode_to_var(&hdmi->var, found);
	sh_hdmi_external_video_param(hdmi);

	return 0;
}

static irqreturn_t sh_hdmi_hotplug(int irq, void *dev_id)
{
	struct sh_hdmi *hdmi = dev_id;
	u8 status1, status2, mask1, mask2;

	/* mode_b and PLLA and PLLB reset */
	hdmi_write(hdmi, 0x2C, HDMI_SYSTEM_CTRL);

	/* How long shall reset be held? */
	udelay(10);

	/* mode_b and PLLA and PLLB reset release */
	hdmi_write(hdmi, 0x20, HDMI_SYSTEM_CTRL);

	status1 = hdmi_read(hdmi, HDMI_INTERRUPT_STATUS_1);
	status2 = hdmi_read(hdmi, HDMI_INTERRUPT_STATUS_2);

	mask1 = hdmi_read(hdmi, HDMI_INTERRUPT_MASK_1);
	mask2 = hdmi_read(hdmi, HDMI_INTERRUPT_MASK_2);

	/* Correct would be to ack only set bits, but the datasheet requires 0xff */
	hdmi_write(hdmi, 0xFF, HDMI_INTERRUPT_STATUS_1);
	hdmi_write(hdmi, 0xFF, HDMI_INTERRUPT_STATUS_2);

	if (printk_ratelimit())
		dev_dbg(hdmi->dev, "IRQ #%d: Status #1: 0x%x & 0x%x, #2: 0x%x & 0x%x\n",
			irq, status1, mask1, status2, mask2);

	if (!((status1 & mask1) | (status2 & mask2))) {
		return IRQ_NONE;
	} else if (status1 & 0xc0) {
		u8 msens;

		/* Datasheet specifies 10ms... */
		udelay(500);

		msens = hdmi_read(hdmi, HDMI_HOT_PLUG_MSENS_STATUS);
		dev_dbg(hdmi->dev, "MSENS 0x%x\n", msens);
		/* Check, if hot plug & MSENS pin status are both high */
		if ((msens & 0xC0) == 0xC0) {
			/* Display plug in */
			hdmi->edid_segment_nr = 0;
			hdmi->edid_block_addr = 0;
			hdmi->edid_blocks = 0;
			hdmi->hp_state = HDMI_HOTPLUG_CONNECTED;

			/* Set EDID word address  */
			hdmi_write(hdmi, 0x00, HDMI_EDID_WORD_ADDRESS);
			/* Enable EDID interrupt */
			hdmi_write(hdmi, 0xC6, HDMI_INTERRUPT_MASK_1);
			/* Set EDID segment pointer - starts reading EDID */
			hdmi_write(hdmi, 0x00, HDMI_EDID_SEGMENT_POINTER);
		} else if (!(status1 & 0x80)) {
			/* Display unplug, beware multiple interrupts */
			if (hdmi->hp_state != HDMI_HOTPLUG_DISCONNECTED) {
				hdmi->hp_state = HDMI_HOTPLUG_DISCONNECTED;
				schedule_delayed_work(&hdmi->edid_work, 0);
			}
			/* display_off will switch back to mode_a */
		}
	} else if (status1 & 2) {
		/* EDID error interrupt: retry */
		/* Set EDID word address  */
		hdmi_write(hdmi, hdmi->edid_block_addr, HDMI_EDID_WORD_ADDRESS);
		/* Set EDID segment pointer */
		hdmi_write(hdmi, hdmi->edid_segment_nr, HDMI_EDID_SEGMENT_POINTER);
	} else if (status1 & 4) {
		/* Disable EDID interrupt */
		hdmi_write(hdmi, 0xC0, HDMI_INTERRUPT_MASK_1);
		schedule_delayed_work(&hdmi->edid_work, msecs_to_jiffies(10));
	}

	return IRQ_HANDLED;
}

/* locking:	called with info->lock held, or before register_framebuffer() */
static void sh_hdmi_display_on(void *arg, struct fb_info *info)
{
	/*
	 * info is guaranteed to be valid, when we are called, because our
	 * FB_EVENT_FB_UNBIND notify is also called with info->lock held
	 */
	struct sh_hdmi *hdmi = arg;
	struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data;
	struct sh_mobile_lcdc_chan *ch = info->par;

	dev_dbg(hdmi->dev, "%s(%p): state %x\n", __func__,
		pdata->lcd_dev, info->state);

	/* No need to lock */
	hdmi->info = info;

	/*
	 * hp_state can be set to
	 * HDMI_HOTPLUG_DISCONNECTED:	on monitor unplug
	 * HDMI_HOTPLUG_CONNECTED:	on monitor plug-in
	 * HDMI_HOTPLUG_EDID_DONE:	on EDID read completion
	 */
	switch (hdmi->hp_state) {
	case HDMI_HOTPLUG_EDID_DONE:
		/* PS mode d->e. All functions are active */
		hdmi_write(hdmi, 0x80, HDMI_SYSTEM_CTRL);
		dev_dbg(hdmi->dev, "HDMI running\n");
		break;
	case HDMI_HOTPLUG_DISCONNECTED:
		info->state = FBINFO_STATE_SUSPENDED;
	default:
		hdmi->var = ch->display_var;
	}
}

/* locking: called with info->lock held */
static void sh_hdmi_display_off(void *arg)
{
	struct sh_hdmi *hdmi = arg;
	struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data;

	dev_dbg(hdmi->dev, "%s(%p)\n", __func__, pdata->lcd_dev);
	/* PS mode e->a */
	hdmi_write(hdmi, 0x10, HDMI_SYSTEM_CTRL);
}

static bool sh_hdmi_must_reconfigure(struct sh_hdmi *hdmi)
{
	struct fb_info *info = hdmi->info;
	struct sh_mobile_lcdc_chan *ch = info->par;
	struct fb_var_screeninfo *new_var = &hdmi->var, *old_var = &ch->display_var;
	struct fb_videomode mode1, mode2;

	fb_var_to_videomode(&mode1, old_var);
	fb_var_to_videomode(&mode2, new_var);

	dev_dbg(info->dev, "Old %ux%u, new %ux%u\n",
		mode1.xres, mode1.yres, mode2.xres, mode2.yres);

	if (fb_mode_is_equal(&mode1, &mode2)) {
		/* It can be a different monitor with an equal video-mode */
		old_var->width = new_var->width;
		old_var->height = new_var->height;
		return false;
	}

	dev_dbg(info->dev, "Switching %u -> %u lines\n",
		mode1.yres, mode2.yres);
	*old_var = *new_var;

	return true;
}

/**
 * sh_hdmi_clk_configure() - set HDMI clock frequency and enable the clock
 * @hdmi:		driver context
 * @hdmi_rate:		HDMI clock frequency in Hz
 * @parent_rate:	if != 0 - set parent clock rate for optimal precision
 * return:		configured positive rate if successful
 *			0 if couldn't set the rate, but managed to enable the
 *			clock, negative error, if couldn't enable the clock
 */
static long sh_hdmi_clk_configure(struct sh_hdmi *hdmi, unsigned long hdmi_rate,
				  unsigned long parent_rate)
{
	int ret;

	if (parent_rate && clk_get_parent(hdmi->hdmi_clk)) {
		ret = clk_set_rate(clk_get_parent(hdmi->hdmi_clk), parent_rate);
		if (ret < 0) {
			dev_warn(hdmi->dev, "Cannot set parent rate %ld: %d\n", parent_rate, ret);
			hdmi_rate = clk_round_rate(hdmi->hdmi_clk, hdmi_rate);
		} else {
			dev_dbg(hdmi->dev, "HDMI set parent frequency %lu\n", parent_rate);
		}
	}

	ret = clk_set_rate(hdmi->hdmi_clk, hdmi_rate);
	if (ret < 0) {
		dev_warn(hdmi->dev, "Cannot set rate %ld: %d\n", hdmi_rate, ret);
		hdmi_rate = 0;
	} else {
		dev_dbg(hdmi->dev, "HDMI set frequency %lu\n", hdmi_rate);
	}

	return hdmi_rate;
}

/* Hotplug interrupt occurred, read EDID */
static void sh_hdmi_edid_work_fn(struct work_struct *work)
{
	struct sh_hdmi *hdmi = container_of(work, struct sh_hdmi, edid_work.work);
	struct fb_info *info;
	struct sh_mobile_hdmi_info *pdata = hdmi->dev->platform_data;
	struct sh_mobile_lcdc_chan *ch;
	int ret;

	dev_dbg(hdmi->dev, "%s(%p): begin, hotplug status %d\n", __func__,
		pdata->lcd_dev, hdmi->hp_state);

	if (!pdata->lcd_dev)
		return;

	mutex_lock(&hdmi->mutex);

	info = hdmi->info;

	if (hdmi->hp_state == HDMI_HOTPLUG_CONNECTED) {
		unsigned long parent_rate = 0, hdmi_rate;

		ret = sh_hdmi_read_edid(hdmi, &hdmi_rate, &parent_rate);
		if (ret < 0)
			goto out;

		hdmi->hp_state = HDMI_HOTPLUG_EDID_DONE;

		/* Reconfigure the clock */
		ret = sh_hdmi_clk_configure(hdmi, hdmi_rate, parent_rate);
		if (ret < 0)
			goto out;

		msleep(10);
		sh_hdmi_configure(hdmi);
		/* Switched to another (d) power-save mode */
		msleep(10);

		if (!info)
			goto out;

		ch = info->par;

		if (lock_fb_info(info)) {
			console_lock();

			/* HDMI plug in */
			if (!sh_hdmi_must_reconfigure(hdmi) &&
			    info->state == FBINFO_STATE_RUNNING) {
				/*
				 * First activation with the default monitor - just turn
				 * on, if we run a resume here, the logo disappears
				 */
				info->var.width = hdmi->var.width;
				info->var.height = hdmi->var.height;
				sh_hdmi_display_on(hdmi, info);
			} else {
				/* New monitor or have to wake up */
				fb_set_suspend(info, 0);
			}

			console_unlock();
			unlock_fb_info(info);
		}
	} else {
		ret = 0;
		if (!info)
			goto out;

		hdmi->monspec.modedb_len = 0;
		fb_destroy_modedb(hdmi->monspec.modedb);
		hdmi->monspec.modedb = NULL;

		if (lock_fb_info(info)) {
			console_lock();

			/* HDMI disconnect */
			fb_set_suspend(info, 1);

			console_unlock();
			unlock_fb_info(info);
		}
	}

out:
	if (ret < 0 && ret != -EAGAIN)
		hdmi->hp_state = HDMI_HOTPLUG_DISCONNECTED;
	mutex_unlock(&hdmi->mutex);

	dev_dbg(hdmi->dev, "%s(%p): end\n", __func__, pdata->lcd_dev);
}

static int sh_hdmi_notify(struct notifier_block *nb,
			  unsigned long action, void *data)
{
	struct fb_event *event = data;
	struct fb_info *info = event->info;
	struct sh_mobile_lcdc_chan *ch = info->par;
	struct sh_mobile_lcdc_board_cfg	*board_cfg = &ch->cfg.board_cfg;
	struct sh_hdmi *hdmi = board_cfg->board_data;

	if (!hdmi || nb != &hdmi->notifier || hdmi->info != info)
		return NOTIFY_DONE;

	switch(action) {
	case FB_EVENT_FB_REGISTERED:
		/* Unneeded, activation taken care by sh_hdmi_display_on() */
		break;
	case FB_EVENT_FB_UNREGISTERED:
		/*
		 * We are called from unregister_framebuffer() with the
		 * info->lock held. This is bad for us, because we can race with
		 * the scheduled work, which has to call fb_set_suspend(), which
		 * takes info->lock internally, so, sh_hdmi_edid_work_fn()
		 * cannot take and hold info->lock for the whole function
		 * duration. Using an additional lock creates a classical AB-BA
		 * lock up. Therefore, we have to release the info->lock
		 * temporarily, synchronise with the work queue and re-acquire
		 * the info->lock.
		 */
		unlock_fb_info(info);
		mutex_lock(&hdmi->mutex);
		hdmi->info = NULL;
		mutex_unlock(&hdmi->mutex);
		lock_fb_info(info);
		return NOTIFY_OK;
	}
	return NOTIFY_DONE;
}

static int __init sh_hdmi_probe(struct platform_device *pdev)
{
	struct sh_mobile_hdmi_info *pdata = pdev->dev.platform_data;
	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	struct sh_mobile_lcdc_board_cfg	*board_cfg;
	int irq = platform_get_irq(pdev, 0), ret;
	struct sh_hdmi *hdmi;
	long rate;

	if (!res || !pdata || irq < 0)
		return -ENODEV;

	hdmi = kzalloc(sizeof(*hdmi), GFP_KERNEL);
	if (!hdmi) {
		dev_err(&pdev->dev, "Cannot allocate device data\n");
		return -ENOMEM;
	}

	mutex_init(&hdmi->mutex);

	hdmi->dev = &pdev->dev;

	hdmi->hdmi_clk = clk_get(&pdev->dev, "ick");
	if (IS_ERR(hdmi->hdmi_clk)) {
		ret = PTR_ERR(hdmi->hdmi_clk);
		dev_err(&pdev->dev, "Unable to get clock: %d\n", ret);
		goto egetclk;
	}

	/* An arbitrary relaxed pixclock just to get things started: from standard 480p */
	rate = clk_round_rate(hdmi->hdmi_clk, PICOS2KHZ(37037));
	if (rate > 0)
		rate = sh_hdmi_clk_configure(hdmi, rate, 0);

	if (rate < 0) {
		ret = rate;
		goto erate;
	}

	ret = clk_enable(hdmi->hdmi_clk);
	if (ret < 0) {
		dev_err(hdmi->dev, "Cannot enable clock: %d\n", ret);
		goto erate;
	}

	dev_dbg(&pdev->dev, "Enabled HDMI clock at %luHz\n", rate);

	if (!request_mem_region(res->start, resource_size(res), dev_name(&pdev->dev))) {
		dev_err(&pdev->dev, "HDMI register region already claimed\n");
		ret = -EBUSY;
		goto ereqreg;
	}

	hdmi->base = ioremap(res->start, resource_size(res));
	if (!hdmi->base) {
		dev_err(&pdev->dev, "HDMI register region already claimed\n");
		ret = -ENOMEM;
		goto emap;
	}

	platform_set_drvdata(pdev, hdmi);

	/* Set up LCDC callbacks */
	board_cfg = &pdata->lcd_chan->board_cfg;
	board_cfg->owner = THIS_MODULE;
	board_cfg->board_data = hdmi;
	board_cfg->display_on = sh_hdmi_display_on;
	board_cfg->display_off = sh_hdmi_display_off;

	INIT_DELAYED_WORK(&hdmi->edid_work, sh_hdmi_edid_work_fn);

	pm_runtime_enable(&pdev->dev);
	pm_runtime_get_sync(&pdev->dev);

	/* Product and revision IDs are 0 in sh-mobile version */
	dev_info(&pdev->dev, "Detected HDMI controller 0x%x:0x%x\n",
		 hdmi_read(hdmi, HDMI_PRODUCT_ID), hdmi_read(hdmi, HDMI_REVISION_ID));

	ret = request_irq(irq, sh_hdmi_hotplug, 0,
			  dev_name(&pdev->dev), hdmi);
	if (ret < 0) {
		dev_err(&pdev->dev, "Unable to request irq: %d\n", ret);
		goto ereqirq;
	}

	ret = snd_soc_register_codec(&pdev->dev,
			&soc_codec_dev_sh_hdmi, &sh_hdmi_dai, 1);
	if (ret < 0) {
		dev_err(&pdev->dev, "codec registration failed\n");
		goto ecodec;
	}

	hdmi->notifier.notifier_call = sh_hdmi_notify;
	fb_register_client(&hdmi->notifier);

	return 0;

ecodec:
	free_irq(irq, hdmi);
ereqirq:
	pm_runtime_put(&pdev->dev);
	pm_runtime_disable(&pdev->dev);
	iounmap(hdmi->base);
emap:
	release_mem_region(res->start, resource_size(res));
ereqreg:
	clk_disable(hdmi->hdmi_clk);
erate:
	clk_put(hdmi->hdmi_clk);
egetclk:
	mutex_destroy(&hdmi->mutex);
	kfree(hdmi);

	return ret;
}

static int __exit sh_hdmi_remove(struct platform_device *pdev)
{
	struct sh_mobile_hdmi_info *pdata = pdev->dev.platform_data;
	struct sh_hdmi *hdmi = platform_get_drvdata(pdev);
	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	struct sh_mobile_lcdc_board_cfg	*board_cfg = &pdata->lcd_chan->board_cfg;
	int irq = platform_get_irq(pdev, 0);

	snd_soc_unregister_codec(&pdev->dev);

	fb_unregister_client(&hdmi->notifier);

	board_cfg->display_on = NULL;
	board_cfg->display_off = NULL;
	board_cfg->board_data = NULL;
	board_cfg->owner = NULL;

	/* No new work will be scheduled, wait for running ISR */
	free_irq(irq, hdmi);
	/* Wait for already scheduled work */
	cancel_delayed_work_sync(&hdmi->edid_work);
	pm_runtime_put(&pdev->dev);
	pm_runtime_disable(&pdev->dev);
	clk_disable(hdmi->hdmi_clk);
	clk_put(hdmi->hdmi_clk);
	iounmap(hdmi->base);
	release_mem_region(res->start, resource_size(res));
	mutex_destroy(&hdmi->mutex);
	kfree(hdmi);

	return 0;
}

static struct platform_driver sh_hdmi_driver = {
	.remove		= __exit_p(sh_hdmi_remove),
	.driver = {
		.name	= "sh-mobile-hdmi",
	},
};

static int __init sh_hdmi_init(void)
{
	return platform_driver_probe(&sh_hdmi_driver, sh_hdmi_probe);
}
module_init(sh_hdmi_init);

static void __exit sh_hdmi_exit(void)
{
	platform_driver_unregister(&sh_hdmi_driver);
}
module_exit(sh_hdmi_exit);

MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
MODULE_DESCRIPTION("SuperH / ARM-shmobile HDMI driver");
MODULE_LICENSE("GPL v2");


text:
#include "CCActionFrame.h"
#include "CCActionEaseEx.h"

NS_CC_EXT_BEGIN

	ActionFrame::ActionFrame()
	: m_frameType(0)
	, m_frameIndex(0)
	, m_fTime(0.0f)
	, m_easingType(FrameEase_Linear)
{
}
ActionFrame::~ActionFrame()
{

}

void ActionFrame::setFrameIndex(int index)
{
	m_frameIndex = index;
}
int ActionFrame::getFrameIndex()
{
	return m_frameIndex;
}

void ActionFrame::setFrameTime(float fTime)
{
	m_fTime = fTime;
}
float ActionFrame::getFrameTime()
{
	return m_fTime;
}

void ActionFrame::setFrameType(int frameType)
{
	m_frameType = frameType;
}
int ActionFrame::getFrameType()
{
	return m_frameType;
}

void ActionFrame::setEasingType(int easingType)
{
	m_easingType = (FrameEaseType)easingType;
}
int ActionFrame::getEasingType()
{
	return (int)m_easingType;
}

CCActionInterval* ActionFrame::getAction(float fDuration)
{
	CCLog("Need a definition of <getAction> for ActionFrame");
	return NULL;
}

CCActionInterval* ActionFrame::getAction(float fDuration,ActionFrame* srcFrame)
{
	return this->getAction(fDuration);
}

void ActionFrame::setEasingParameter(std::vector<float> parameter)
{
	m_Parameter.clear();

	for ( unsigned int i = 0; i<parameter.size(); i++)
	{
		m_Parameter.push_back(parameter[i]);
	}
}

CCActionInterval* ActionFrame::getEasingAction(CCActionInterval* action)
{
	if (action == NULL)
	{
		return NULL;
	}

	switch (m_easingType)
	{
	case FrameEase_Custom:
		{
			CCEaseBezierAction* cAction = CCEaseBezierAction::create(action);
			cAction->setBezierParamer(m_Parameter[0],m_Parameter[1],m_Parameter[2],m_Parameter[3]);
			return cAction;
		}
		break;
	case FrameEase_Linear:
		return action;
		break;
	case FrameEase_Sine_EaseIn:
		return CCEaseSineIn::create(action);
		break;
	case FrameEase_Sine_EaseOut:
		return CCEaseSineOut::create(action);
		break;
	case FrameEase_Sine_EaseInOut:
		return CCEaseSineInOut::create(action);
		break;
	case FrameEase_Quad_EaseIn:
		return CCEaseQuadraticActionIn::create(action);
		break;
	case FrameEase_Quad_EaseOut:
		return CCEaseQuadraticActionOut::create(action);
		break;
	case FrameEase_Quad_EaseInOut:
		return CCEaseQuadraticActionInOut::create(action);
		break;
	case FrameEase_Cubic_EaseIn:
		return CCEaseCubicActionIn::create(action);
		break;
	case FrameEase_Cubic_EaseOut:
		return CCEaseCubicActionOut::create(action);
		break;
	case FrameEase_Cubic_EaseInOut:
		return CCEaseCubicActionInOut::create(action);
		break;
	case FrameEase_Quart_EaseIn:
		return CCEaseQuarticActionIn::create(action);
		break;
	case FrameEase_Quart_EaseOut:
		return CCEaseQuadraticActionOut::create(action);
		break;
	case FrameEase_Quart_EaseInOut:
		return CCEaseQuarticActionInOut::create(action);
		break;
	case FrameEase_Quint_EaseIn:
		return CCEaseQuinticActionIn::create(action);
		break;
	case FrameEase_Quint_EaseOut:
		return CCEaseQuinticActionOut::create(action);
		break;
	case FrameEase_Quint_EaseInOut:
		return CCEaseQuinticActionInOut::create(action);
		break;
	case FrameEase_Expo_EaseIn:
		return CCEaseExponentialIn::create(action);
		break;
	case FrameEase_Expo_EaseOut:
		return CCEaseExponentialOut::create(action);
		break;
	case FrameEase_Expo_EaseInOut:
		return CCEaseExponentialInOut::create(action);
		break;
	case FrameEase_Circ_EaseIn:
		return CCEaseCircleActionIn::create(action);
		break;
	case FrameEase_Circ_EaseOut:
		return CCEaseCircleActionOut::create(action);
		break;
	case FrameEase_Circ_EaseInOut:
		return CCEaseCircleActionInOut::create(action);
		break;
	case FrameEase_Elastic_EaseIn:
		{
			return CCEaseElasticIn::create(action);
		}
		break;
	case FrameEase_Elastic_EaseOut:
		{
			return CCEaseElasticOut::create(action);
		}
		break;
	case FrameEase_Elastic_EaseInOut:
		{
			return CCEaseElasticInOut::create(action);
		}
		break;
	case FrameEase_Back_EaseIn:
		return CCEaseBackIn::create(action);
		break;
	case FrameEase_Back_EaseOut:
		return CCEaseBackOut::create(action);
		break;
	case FrameEase_Back_EaseInOut:
		return CCEaseBackInOut::create(action);
		break;
	case FrameEase_Bounce_EaseIn:
		return CCEaseBounceIn::create(action);
		break;
	case FrameEase_Bounce_EaseOut:
		return CCEaseBounceOut::create(action);
		break;
	case FrameEase_Bounce_EaseInOut:
		return CCEaseBounceInOut::create(action);
		break;
	default:
		return action;
		break;
	}
}
//////////////////////////////////////////////////////////////////////////

ActionMoveFrame::ActionMoveFrame()
	: m_position(ccp(0.0f,0.0f))
{
	m_frameType = (int)kKeyframeMove;
}
ActionMoveFrame::~ActionMoveFrame()
{

}
void ActionMoveFrame::setPosition(CCPoint pos)
{
	m_position = pos;
}
CCPoint ActionMoveFrame::getPosition()
{
	return m_position;
}
CCActionInterval* ActionMoveFrame::getAction(float fDuration)
{
	return this->getEasingAction(CCMoveTo::create(fDuration,m_position));
}

//////////////////////////////////////////////////////////////////////////

ActionScaleFrame::ActionScaleFrame()
	: m_scaleX(1.0f)
	, m_scaleY(1.0f)
{
	m_frameType = (int)kKeyframeScale;
}

ActionScaleFrame::~ActionScaleFrame()
{

}

void ActionScaleFrame::setScaleX(float scaleX)
{
	m_scaleX = scaleX;
}

float ActionScaleFrame::getScaleX()
{
	return m_scaleX;
}

void ActionScaleFrame::setScaleY(float scaleY)
{
	m_scaleY = scaleY;
}

float ActionScaleFrame::getScaleY()
{
	return m_scaleY;
}

CCActionInterval* ActionScaleFrame::getAction(float fDuration)
{
	return this->getEasingAction(CCScaleTo::create(fDuration,m_scaleX,m_scaleY));
}

ActionRotationFrame::ActionRotationFrame()
	: m_rotation(0.0f)
{
	m_frameType = (int)kKeyframeRotate;
}

ActionRotationFrame::~ActionRotationFrame()
{

}

void ActionRotationFrame::setRotation(float rotation)
{
	m_rotation = rotation;
}

float ActionRotationFrame::getRotation()
{
	return m_rotation;
}

CCActionInterval* ActionRotationFrame::getAction(float fDuration)
{
	return this->getEasingAction(CCRotateTo::create(fDuration,m_rotation));
}
CCActionInterval* ActionRotationFrame::getAction(float fDuration,ActionFrame* srcFrame)
{
	ActionRotationFrame* srcRotationFrame = static_cast<ActionRotationFrame*>(srcFrame);
	if (srcRotationFrame == NULL)
	{
		return this->getAction(fDuration);
	}
	else
	{
		float diffRotation = m_rotation - srcRotationFrame->m_rotation;
		return this->getEasingAction(CCRotateBy::create(fDuration,diffRotation));
	}
}

////////////////////////////////////////
ActionFadeFrame::ActionFadeFrame()
	: m_opacity(255)
{
	m_frameType = (int)kKeyframeFade;
}

ActionFadeFrame::~ActionFadeFrame()
{

}

void ActionFadeFrame::setOpacity(int opacity)
{
	m_opacity = opacity;
}

int ActionFadeFrame::getOpacity()
{
	return m_opacity;
}

CCActionInterval* ActionFadeFrame::getAction(float fDuration)
{
	return this->getEasingAction(CCFadeTo::create(fDuration,m_opacity));
}

ActionTintFrame::ActionTintFrame()
	: m_color(ccc3(255,255,255))
{
	m_frameType = (int)kKeyframeTint;
}

ActionTintFrame::~ActionTintFrame()
{

}

void ActionTintFrame::setColor(ccColor3B ccolor)
{
	m_color = ccolor;
}

ccColor3B ActionTintFrame::getColor()
{
	return m_color;
}

CCActionInterval* ActionTintFrame::getAction(float fDuration)
{
	return this->getEasingAction(CCTintTo::create(fDuration,m_color.r,m_color.g,m_color.b));
}

NS_CC_EXT_END

redpajama_set_name: RedPajamaGithub


text:
var system = require('system');

/**
 * Wait until the test condition is true or a timeout occurs. Useful for waiting
 * on a server response or for a ui change (fadeIn, etc.) to occur.
 *
 * @param testFx javascript condition that evaluates to a boolean,
 * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
 * as a callback function.
 * @param onReady what to do when testFx condition is fulfilled,
 * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
 * as a callback function.
 * @param timeOutMs the max amount of time to wait. If not specified, 3 sec is used.
 */
function waitFor(testFx, onReady, timeOutMs) {

  var cond = false;

  var interval = setInterval(function() {

    var maxMs     = timeOutMs ? timeOutMs : 3001;
    var startTime = new Date().getTime();

    // If not time-out yet and condition not yet fulfilled
    if ((new Date().getTime() - startTime < maxMs) && !cond) {
      cond = (typeof(testFx) === "string" ? eval(testFx) : testFx()); // defensive code
    } else {
      if(!cond) {
        console.log("'waitFor()' timeout");
        phantom.exit(1);
      } else {
        typeof(onReady) === "string" ? eval(onReady) : onReady();
        clearInterval(interval);
      }
    }

  }, 100);

}

if (system.args.length !== 2) {
  console.log('Usage: run-qunit.js <URL>');
  phantom.exit(1);
}

var page = require('webpage').create();

// Route "console.log()" calls from within the Page context to the main Phantom context (i.e. current "this")
page.onConsoleMessage = function(msg) {
  console.log(msg);
};

// I admit, this is some pretty hairy, abstraction-free JavaScript. --JAB (10/13/13)
page.evaluateFailure = function() {

  var collectErrorStrs = function() {

    var origFilter = NodeList.prototype.filter;
    var origMap    = NodeList.prototype.map;

    NodeList.prototype.filter = Array.prototype.filter;
    NodeList.prototype.map    = Array.prototype.map;

    NodeList.prototype.zipWithIndex = function() {

      var arr = [];
      var x   = 0;

      this.map(function(that) {
        arr.push([that, x]);
        x++;
      });

      return arr;

    };

    var failedGroups = document.querySelectorAll('.fail').filter(function(elem) { return elem.getAttribute('id') !== null; });

    var errorStrs = failedGroups.map(function(group) {

      var assertList = group.querySelector('.qunit-assert-list');
      var zipped     = assertList.childNodes.zipWithIndex();
      var testPairs  = zipped.filter(function(z) { return z[0].getAttribute('class') === 'fail'; });
      var descNodes  = group.childNodes[0].childNodes;
      var group      = descNodes[0].innerHTML;
      var test       = descNodes[2].innerHTML;

      var failStrs = testPairs.map(function(testPair) {

        var extract = function(className) {
          var parts = testPair[0].querySelector('.' + className).childNodes;
          var label = parts[0].innerHTML;
          var value = parts[1].childNodes[0].innerHTML;
          return label + value;
        };

        var results     = ['test-expected', 'test-actual', 'test-source'].map(extract);
        var errorHeader = 'Test #' + (testPair[1] + 1) + ': ' + results[0];
        return results.slice(1).reduce(function(acc, result) { return acc + ', ' + result; }, errorHeader);

      });

      var failHeader = 'FAILED: ' + group + ' - ' + test;
      return failStrs.reduce(function(acc, str) {
        return acc + '\n-' + str;
      }, failHeader);

    });

    NodeList.prototype.filter = origFilter;
    NodeList.prototype.map    = origMap;

    return errorStrs.slice(1).reduce(function(acc, str) { return acc + '\n' + str; }, errorStrs[0]);

  };

  var el = document.getElementById('qunit-testresult');
  console.log(collectErrorStrs() + '\n' + el.innerText);

  try {
    return el.getElementsByClassName('failed')[0].innerHTML;
  } catch(e) {
    return 10000;
  }

};

page.open(system.args[1], function(status) {

  if (status !== "success") {
    console.log("Unable to access network");
    phantom.exit(1);
  } else {

    var successFunc = function() {
      return page.evaluate(function() {
        var elem = document.getElementById('qunit-testresult');
        return elem && elem.innerText.match('completed');
      });
    };

    var failFunc = function() {
      var failedNum  = page.evaluate(page.evaluateFailure);
      var statusCode = (parseInt(failedNum, 10) > 0) ? 1 : 0;
      phantom.exit(statusCode);
    }

    waitFor(successFunc, failFunc);

  }

});


text:
/* line 1, ../scss/core.scss */
.select2-container {
  box-sizing: border-box;
  display: inline-block;
  margin: 0;
  position: relative;
  vertical-align: middle;
}
/* line 1, ../scss/_single.scss */
.select2-container .select2-selection--single {
  box-sizing: border-box;
  cursor: pointer;
  display: block;
  height: 38px;
  user-select: none;
  -webkit-user-select: none;
}
/* line 12, ../scss/_single.scss */
.select2-container .select2-selection--single .select2-selection__rendered {
  display: block;
  padding-left: 8px;
  padding-right: 20px;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
}
/* line 25, ../scss/_single.scss */
.select2-container[dir="rtl"] .select2-selection--single .select2-selection__rendered {
  padding-right: 8px;
  padding-left: 20px;
}
/* line 1, ../scss/_multiple.scss */
.select2-container .select2-selection--multiple {
  box-sizing: border-box;
  cursor: pointer;
  display: block;
  min-height: 38px;
  user-select: none;
  -webkit-user-select: none;
}
/* line 12, ../scss/_multiple.scss */
.select2-container .select2-selection--multiple .select2-selection__rendered {
  display: inline-block;
  overflow: hidden;
  padding-left: 8px;
  text-overflow: ellipsis;
  white-space: nowrap;
}
/* line 21, ../scss/_multiple.scss */
.select2-container .select2-search--inline {
  float: left;
}
/* line 24, ../scss/_multiple.scss */
.select2-container .select2-search--inline .select2-search__field {
  box-sizing: border-box;
  border: none;
  font-size: 100%;
  margin-top: 7px;
  margin-left: 3px;
}
/* line 31, ../scss/_multiple.scss */
.select2-container .select2-search--inline .select2-search__field::-webkit-search-cancel-button {
  -webkit-appearance: none;
}

/* line 1, ../scss/_dropdown.scss */
.select2-dropdown {
  background-color: white;
  border: 1px solid #DDD;
  border-radius: 4px;
  box-sizing: border-box;
  display: block;
  position: absolute;
  left: -100000px;
  width: 100%;
  z-index: 1051;
}

/* line 18, ../scss/_dropdown.scss */
.select2-results {
  display: block;
}

/* line 22, ../scss/_dropdown.scss */
.select2-results__options {
  list-style: none;
  margin: 0;
  padding: 0;
}

/* line 28, ../scss/_dropdown.scss */
.select2-results__option {
  padding: 6px;
  user-select: none;
  -webkit-user-select: none;
}
/* line 34, ../scss/_dropdown.scss */
.select2-results__option[aria-selected] {
  cursor: pointer;
}

/* line 39, ../scss/_dropdown.scss */
.select2-container--open .select2-dropdown {
  left: 0;
}

/* line 43, ../scss/_dropdown.scss */
.select2-container--open .select2-dropdown--above {
  border-bottom: none;
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
}

/* line 49, ../scss/_dropdown.scss */
.select2-container--open .select2-dropdown--below {
  border-top: none;
  border-top-left-radius: 0;
  border-top-right-radius: 0;
}

/* line 55, ../scss/_dropdown.scss */
.select2-search--dropdown {
  display: block;
  padding: 7px;
}
/* line 59, ../scss/_dropdown.scss */
.select2-search--dropdown .select2-search__field {
  padding: 4px;
  width: 100%;
  box-sizing: border-box;
}
/* line 64, ../scss/_dropdown.scss */
.select2-search--dropdown .select2-search__field::-webkit-search-cancel-button {
  -webkit-appearance: none;
}
/* line 69, ../scss/_dropdown.scss */
.select2-search--dropdown.select2-search--hide {
  display: none;
}

/* line 15, ../scss/core.scss */
.select2-close-mask {
  border: 0;
  margin: 0;
  padding: 0;
  display: block;
  position: fixed;
  left: 0;
  top: 0;
  min-height: 100%;
  min-width: 100%;
  height: auto;
  width: auto;
  opacity: 0;
  z-index: 99;
  background-color: #fff;
  filter: alpha(opacity=0);
}

/* line 1, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single {
  background-color: #f0f0f0;
  border: 1px solid rgba(0, 0, 0, 0.1);
  border-radius: 2px;
}
/* line 6, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single:focus {
  outline: 0;
}
/* line 10, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single .select2-selection__rendered {
  color: #444;
  line-height: 34px;
}
/* line 15, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single .select2-selection__clear {
  cursor: pointer;
  float: right;
  font-weight: bold;
}
/* line 21, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single .select2-selection__placeholder {
  color: #999;
}
/* line 25, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single .select2-selection__arrow {
  height: 36px;
  position: absolute;
  top: 1px;
  right: 1px;
  width: 20px;
}
/* line 35, ../scss/theme/default/_single.scss */
.select2-container--default .select2-selection--single .select2-selection__arrow b {
  border-color: #888 transparent transparent transparent;
  border-style: solid;
  border-width: 5px 4px 0 4px;
  height: 0;
  left: 50%;
  margin-left: -4px;
  margin-top: -2px;
  position: absolute;
  top: 50%;
  width: 0;
}
/* line 56, ../scss/theme/default/_single.scss */
.select2-container--default[dir="rtl"] .select2-selection--single .select2-selection__clear {
  float: left;
}
/* line 60, ../scss/theme/default/_single.scss */
.select2-container--default[dir="rtl"] .select2-selection--single .select2-selection__arrow {
  left: 1px;
  right: auto;
}
/* line 68, ../scss/theme/default/_single.scss */
.select2-container--default.select2-container--disabled .select2-selection--single {
  background-color: #eee;
  cursor: default;
}
/* line 72, ../scss/theme/default/_single.scss */
.select2-container--default.select2-container--disabled .select2-selection--single .select2-selection__clear {
  display: none;
}
/* line 81, ../scss/theme/default/_single.scss */
.select2-container--default.select2-container--open .select2-selection--single .select2-selection__arrow b {
  border-color: transparent transparent #888 transparent;
  border-width: 0 4px 5px 4px;
}
/* line 1, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple {
  background-color: #f0f0f0;
  border: 1px solid rgba(0, 0, 0, 0.1);
  -webkit-border-radius: 2px;
  border-radius: 2px;
  cursor: text;
}
/* line 7, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__rendered {
  box-sizing: border-box;
  list-style: none;
  margin: 0;
  padding: 0 5px;
  width: 100%;
}
/* line 15, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__placeholder {
  color: #999;
  margin-top: 5px;
  float: left;
}
/* line 23, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__clear {
  cursor: pointer;
  float: right;
  font-weight: bold;
  margin-top: 8px;
  margin-right: 2px;
}
/* line 31, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__choice {
  color: #666;
  background-color: #fff;
  border: 1px solid #ddd;
  border-radius: 2px;
  cursor: default;
  float: left;
  margin-right: 5px;
  margin-top: 5px;
  padding: 3px 5px 2px;
}
/* line 46, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__choice__remove {
  color: #999;
  cursor: pointer;
  display: inline-block;
  font-weight: bold;
  margin-right: 2px;
}
/* line 55, ../scss/theme/default/_multiple.scss */
.select2-container--default .select2-selection--multiple .select2-selection__choice__remove:hover {
  color: #333;
}
/* line 63, ../scss/theme/default/_multiple.scss */
.select2-container--default[dir="rtl"] .select2-selection--multiple .select2-selection__choice, .select2-container--default[dir="rtl"] .select2-selection--multiple .select2-selection__placeholder {
  float: right;
}
/* line 67, ../scss/theme/default/_multiple.scss */
.select2-container--default[dir="rtl"] .select2-selection--multiple .select2-selection__choice {
  margin-left: 5px;
  margin-right: auto;
}
/* line 72, ../scss/theme/default/_multiple.scss */
.select2-container--default[dir="rtl"] .select2-selection--multiple .select2-selection__choice__remove {
  margin-left: 2px;
  margin-right: auto;
}
/* line 80, ../scss/theme/default/_multiple.scss */
.select2-container--default.select2-container--focus .select2-selection--multiple {
  border: 1px solid #CCC;
  outline: 0;
}
/* line 87, ../scss/theme/default/_multiple.scss */
.select2-container--default.select2-container--disabled .select2-selection--multiple {
  background-color: #eee;
  cursor: default;
}
/* line 92, ../scss/theme/default/_multiple.scss */
.select2-container--default.select2-container--disabled .select2-selection__choice__remove {
  display: none;
}
/* line 6, ../scss/theme/default/layout.scss */
.select2-container--default.select2-container--open.select2-container--above .select2-selection--single, .select2-container--default.select2-container--open.select2-container--above .select2-selection--multiple {
  border-top-left-radius: 0;
  border-top-right-radius: 0;
}
/* line 13, ../scss/theme/default/layout.scss */
.select2-container--default.select2-container--open.select2-container--below .select2-selection--single, .select2-container--default.select2-container--open.select2-container--below .select2-selection--multiple {
  border-bottom-left-radius: 0;
  border-bottom-right-radius: 0;
}
/* line 20, ../scss/theme/default/layout.scss */
.select2-container--default .select2-search--dropdown .select2-search__field {
  border: 1px solid #DDD;
}
/* line 22, ../scss/theme/default/layout.scss */
.select2-container--default .select2-search--dropdown .select2-search__field:focus {
  outline: 0;
}
/* line 29, ../scss/theme/default/layout.scss */
.select2-container--default .select2-search--inline .select2-search__field {
  background: transparent;
  border: none;
  outline: 0;
}
/* line 36, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results > .select2-results__options {
  max-height: 200px;
  overflow-y: auto;
}
/* line 42, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option[role=group] {
  padding: 0;
}
/* line 46, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option[aria-disabled=true] {
  color: #999;
}
/* line 50, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option[aria-selected=true] {
  background-color: #EEE;
}
/* line 54, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option {
  padding-left: 1em;
}
/* line 57, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__group {
  padding-left: 0;
}
/* line 61, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__option {
  margin-left: -1em;
  padding-left: 2em;
}
/* line 65, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option {
  margin-left: -2em;
  padding-left: 3em;
}
/* line 69, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option {
  margin-left: -3em;
  padding-left: 4em;
}
/* line 73, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option {
  margin-left: -4em;
  padding-left: 5em;
}
/* line 77, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option .select2-results__option {
  margin-left: -5em;
  padding-left: 6em;
}
/* line 88, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__option--highlighted[aria-selected] {
  background-color: #4a89dc;
  color: white;
}
/* line 93, ../scss/theme/default/layout.scss */
.select2-container--default .select2-results__group {
  cursor: default;
  display: block;
  padding: 6px;
}


text:
<?php

/**
 * MemberConfigScheduleForm.
 *
 * @package    opCalendarPlugin
 * @subpackage form
 * @author     Shinichi Urabe <urabe@tejimaya.com>
 */
class MemberConfigScheduleForm extends MemberConfigForm
{
  const PUBLIC_FLAG = 'schedule_public_flag';
  const IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE = 'is_Google_calendar_OAuth_key_revoke';
  const IS_GOOGLE_CALENDAR_ALWAYS_SYNC = 'is_Google_calendar_aliways_sync';

  protected
    $category = 'schedule';

  protected
    $opCalendarOAuth;

  public function configure()
  {
    $this->widgetSchema[self::PUBLIC_FLAG] = new sfWidgetFormChoice(array(
      'choices'  => Doctrine::getTable('Schedule')->getPublicFlags(),
      'expanded' => true,
      'default'  => $this->getConfig(self::PUBLIC_FLAG, ScheduleTable::PUBLIC_FLAG_SNS),
      'label'    => 'Public flag',
    ));
    $this->widgetSchema->setHelp(self::PUBLIC_FLAG, 'Default public flag for your new schedules. Past schedules are not changed.');

    $this->validatorSchema[self::PUBLIC_FLAG] = new sfValidatorChoice(array(
      'choices' => array_keys(Doctrine::getTable('Schedule')->getPublicFlags()),
    ));

    if ($this->isOAuthAuthenticate())
    {
      $check = array(1 => 'Is delete.');
      $this->setWidget(self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE, new sfWidgetFormChoice(array(
        'choices'  => $check,
        'multiple' => true,
        'expanded' => true,
      )));
      $this->setValidator(self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE, new sfValidatorChoice(array(
        'choices' => array_keys($check),
        'multiple' => true,
        'required' => false,
      )));
      $this->widgetSchema->setHelp(self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE, 'Please note that the schedule data in cooperation with OAuth key will disappear all.');

      $check = array(1 => 'Is sync.');
      $this->setWidget(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC, new sfWidgetFormChoice(array(
        'choices'  => $check,
        'multiple' => true,
        'expanded' => true,
      )));
      $this->setValidator(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC, new sfValidatorChoice(array(
        'choices' => array_keys($check),
        'multiple' => true,
        'required' => false,
      )));
      $this->setDefault(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC, $this->member->getConfig(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC));
    }
  }

  public function save()
  {
    if ($this->isOAuthAuthenticate())
    {
      try
      {
        $con = opDoctrineQuery::getMasterConnection();
        $con->beginTransaction();

        if (array_key_exists(self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE, $this->values))
        {
          $isDelete = (bool) $this->values[self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE];
          unset($this->values[self::IS_GOOGLE_CALENDAR_OAUTH_KEY_REVOKE]);

          if ($isDelete)
          {
            $this->opCalendarOAuth->getClient()->revokeToken();
            opCalendarPluginToolkit::deleteMemberGoogleCalendar($this->member);
          }
        }

        if (array_key_exists(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC, $this->values))
        {
          $isSync = (bool) $this->values[self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC];
          unset($this->values[self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC]);
          $this->member->setConfig(self::IS_GOOGLE_CALENDAR_ALWAYS_SYNC, $isSync);
        }

        $con->commit();

      }
      catch (Exception $e)
      {
        $con->rollback();

        return false;
      }
    }

    return parent::save();
  }

  private function getConfig($name, $default = null)
  {
    $value = $this->member->getConfig($name, $default);

    return null === $value ? $default : $value;
  }

  private function isOAuthAuthenticate()
  {
    $this->opCalendarOAuth = opCalendarOAuth::getInstance();

    return $this->opCalendarOAuth->authenticate($this->member);
  }
}


text:
_[www.codever.land/bookmarks/t/rxjs](https://www.codever.land/bookmarks/t/rxjs)_
---
#### [Angular - The RxJS library](https://angular.io/guide/rx-library)
_https://angular.io/guide/rx-library_

Reactive programming is an asynchronous programming paradigm concerned with data streams and the propagation of change (Wikipedia). RxJS (Reactive Extensions for JavaScript) is a library for reactive ...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [docs](../tagged/docs.md)
---
#### [Caching with RxJs Observables in Angular](https://www.syntaxsuccess.com/viewarticle/caching-with-rxjs-observables-in-angular-2.0)
_https://www.syntaxsuccess.com/viewarticle/caching-with-rxjs-observables-in-angular-2.0_

Simple caching with observables and `publishReplay(1)` and `refCount`

* :calendar: **published on**: 2016-04-23
* **tags**: [angular](../tagged/angular.md), [caching](../tagged/caching.md), [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md), [http-client](../tagged/http-client.md)
* :octocat: **[source code](https://github.com/thelgevold/angular-2-samples/tree/master/src/apps/shared-components/rxjs-caching)**
---
#### [RxJs Error Handling: Complete Practical Guide](https://blog.angular-university.io/rxjs-error-handling/)
_https://blog.angular-university.io/rxjs-error-handling/_

Error handling is an essential part of RxJs, as we will need it in just about any reactive program that we write.

Error handling in RxJS is likely not as well understood as other parts of the library...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [error-handling](../tagged/error-handling.md)
---
#### [Angular Application Architecture: Build Reux-like Apps with RxJs](https://blog.angular-university.io/angular-2-application-architecture-building-applications-using-rxjs-and-functional-reactive-programming-vs-redux/)
_https://blog.angular-university.io/angular-2-application-architecture-building-applications-using-rx..._

In this post, we are going to walk through how Angular applications can be built in a Functional Reactive style using the RxJs library that is part of Angular. We will go over the following topics:

*...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [functional-programming](../tagged/functional-programming.md), [redux](../tagged/redux.md)
---
#### [Aggregating Streams With Reduce And Scan using RxJS from @benlesh on @eggheadio](https://egghead.io/lessons/rxjs-aggregating-streams-with-reduce-and-scan-using-rxjs)
_https://egghead.io/lessons/rxjs-aggregating-streams-with-reduce-and-scan-using-rxjs_

What is the RxJS equivalent of Array reduce? What if I want to emit my reduced or aggregated value at each event? This brief tutorial covers Observable operators reduce() and scan(), their differences...
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [Functional Reactive Programming for Angular Developers](https://blog.angular-university.io/functional-reactive-programming-for-angular-2-developers-rxjs-and-observables/)
_https://blog.angular-university.io/functional-reactive-programming-for-angular-2-developers-rxjs-and..._

In this post, we are going to go over the concept of Functional Reactive Programming from the point of view of an Angular developer. Following topics are covered:

* A new asynchronous programming con...
* **tags**: [angular](../tagged/angular.md), [functional-programming](../tagged/functional-programming.md), [rxjs](../tagged/rxjs.md)
---
#### [3 Common Angular Rxjs Pitfalls](https://blog.angular-university.io/angular-2-rxjs-common-pitfalls/)
_https://blog.angular-university.io/angular-2-rxjs-common-pitfalls/_

These are 3 situations that we can come across  while building Angular apps using  RxJs. We are going to go over why the issue happens and how to fix it
* :calendar: **published on**: 2019-04-19
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md)
---
#### [Angular Multiple HTTP Requests with RxJS - Angular 7 | 8](https://coryrylan.com/blog/angular-multiple-http-requests-with-rxjs)
_https://coryrylan.com/blog/angular-multiple-http-requests-with-rxjs_

A typical pattern we run into with single page apps is to gather up data from multiple API endpoints and then display the gathered data to the user. Fetching numerous asynchronous requests and managin...
* :calendar: **published on**: 2019-06-18
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [parallel-processing](../tagged/parallel-processing.md)
* :octocat: **[source code](https://stackblitz.com/edit/angular-jjp2oy)**
---
#### [NGXS Home Page](https://www.ngxs.io/)
_https://www.ngxs.io/_

NGXS is a state management pattern + library for Angular. It acts as a single source of truth for your application's state, providing simple rules for predictable state mutations.

NGXS is modeled aft...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [redux](../tagged/redux.md), [ngrx](../tagged/ngrx.md), [cqrs](../tagged/cqrs.md)
* :octocat: **[source code](https://github.com/ngxs/store)**
---
#### [Material Autocomplete - startWith operator](https://stackoverflow.com/questions/55262108/material-autocomplete-startwith-operator)
_https://stackoverflow.com/questions/55262108/material-autocomplete-startwith-operator_

Ignore the generic type <string | User> and focus on the value of the passed in parameter. The value that is actually passed to startWith in your code is an empty string ''.

why would you want it to ...
* :calendar: **published on**: 2019-03-20
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md)
---
#### [RxJS: Understanding Lettable Operators — ncjamieson](https://ncjamieson.com/understanding-lettable-operators/)
_https://ncjamieson.com/understanding-lettable-operators/_

An update: lettable operators are now officially pipeable operators.

Lettable operators offer a new way of composing observable chains and they have advantages for both application developers and lib...
* :calendar: **published on**: 2017-09-26
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [Reading the RxJS 6 Sources: Map and Pipe - Angular In Depth - Medium](https://medium.com/angular-in-depth/reading-the-rxjs-6-sources-map-and-pipe-94d51fec71c2)
_https://medium.com/angular-in-depth/reading-the-rxjs-6-sources-map-and-pipe-94d51fec71c2_

Welcome back. Today I'm very excited, because I'm finally going to dig into how pipe is implemented in RxJS. This article will start with an overview of how map and pipe work, and then will delve into...
* :calendar: **published on**: 2019-01-11
* **tags**: [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md)
---
#### [RxJS: Don't Unsubscribe - Ben Lesh - Medium](https://medium.com/@benlesh/rxjs-dont-unsubscribe-6753ed4fda87)
_https://medium.com/@benlesh/rxjs-dont-unsubscribe-6753ed4fda87_

Well… okay, just don't unsubscribe quite so much.

I'm often enlisted to help someone debug an issue with their RxJS code or figure out how to structure an app that is composing a lot of async with Rx...
* :calendar: **published on**: 2016-07-27
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md)
---
#### [When To Subscribe – Angular In Depth](https://blog.angularindepth.com/when-to-subscribe-a83332ae053)
_https://blog.angularindepth.com/when-to-subscribe-a83332ae053_

When should you subscribe? The answer to that question is, "Only when you absolutely have to." Because (among other reasons) if you don't subscribe, you don't have to unsubscribe.

So, when do you abs...
* :calendar: **published on**: 2019-01-08
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md)
---
#### [rx-book RxJS - Javascript library for functional reactive programming.](http://xgrommx.github.io/rx-book)
_http://xgrommx.github.io/rx-book_

Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators.
* **tags**: [rxjs](../tagged/rxjs.md), [free-programming-books](../tagged/free-programming-books.md)
---
#### [Advanced caching with RxJS by thoughtram](https://blog.thoughtram.io/angular/2018/03/05/advanced-caching-with-rxjs.html)
_https://blog.thoughtram.io/angular/2018/03/05/advanced-caching-with-rxjs.html_

When building web applications, performance should always be a top priority. One very efficient way to optimize the performance of our applications and improve the experience of our site is to use cac...
* :calendar: **published on**: 2018-03-05
* **tags**: [angular](../tagged/angular.md), [caching](../tagged/caching.md), [rxjs](../tagged/rxjs.md)
* :octocat: **[source code](https://stackblitz.com/edit/advanced-caching-with-rxjs-step-4)**
---
#### [Introduction · learn-rxjs](https://www.learnrxjs.io/)
_https://www.learnrxjs.io/_

Clear examples, explanations, and resources for RxJS.
* **tags**: [rxjs](../tagged/rxjs.md), [free-programming-books](../tagged/free-programming-books.md)
---
#### [RxJs Mapping: switchMap vs mergeMap vs concatMap vs exhaustMap](https://blog.angular-university.io/rxjs-higher-order-mapping/)
_https://blog.angular-university.io/rxjs-higher-order-mapping/_

So that is what we will be doing in this post, we are going to learn in a logical order the concat, merge, switch and exhaust strategies and their corresponding mapping operators: concatMap, mergeMap,...
* :calendar: **published on**: 2018-07-18
* **tags**: [rxjs](../tagged/rxjs.md), [angular](../tagged/angular.md)
* :octocat: **[source code](https://github.com/angular-university/rxjs-course/tree/1-operators-finished)**
---
#### [RxJS: Understanding the publish and share Operators](https://blog.angularindepth.com/rxjs-understanding-the-publish-and-share-operators-16ea2f446635)
_https://blog.angularindepth.com/rxjs-understanding-the-publish-and-share-operators-16ea2f446635_

An in-depth look at the multicast, publish and share operators
* :calendar: **published on**: 2017-08-23
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [On The Subject Of Subjects (in RxJS) – Ben Lesh ](https://medium.com/@benlesh/on-the-subject-of-subjects-in-rxjs-2b08b7198b93)
_https://medium.com/@benlesh/on-the-subject-of-subjects-in-rxjs-2b08b7198b93_

Subjects in RxJS are often misunderstood. Because they allow you to imperatively push values into an observable stream, people tend to abuse Subjects when they're not quite sure how to make an Observa...
* :calendar: **published on**: 2016-12-10
* **tags**: [rxjs](../tagged/rxjs.md), [design-patterns](../tagged/design-patterns.md)
---
#### [Hot vs Cold Observables – Ben Lesh](https://medium.com/@benlesh/hot-vs-cold-observables-f8094ed53339)
_https://medium.com/@benlesh/hot-vs-cold-observables-f8094ed53339_

You want a HOT observable when you don't want to create your producer over and over again.
* COLD is when your observable creates the producer
* HOT is when your observable closes over the producer
* :calendar: **published on**: 2016-03-29
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md)
---
#### [angular - BehaviorSubject vs Observable? - Stack Overflow](https://stackoverflow.com/questions/39494058/behaviorsubject-vs-observable)
_https://stackoverflow.com/questions/39494058/behaviorsubject-vs-observable_

**BehaviorSubject** is a type of subject, a subject is a special type of observable so you can subscribe to messages like any other observable. The unique features of BehaviorSubject are:
* It needs a...
* :calendar: **published on**: 2016-11-01
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md)
---
#### [Introduction RxJS - Javascript library for functional reactive programming.](http://xgrommx.github.io/rx-book/)
_http://xgrommx.github.io/rx-book/_

Reactive Extensions (Rx) is a library for composing asynchronous and event-based programs using observable sequences and LINQ-style query operators.
* **tags**: [rxjs](../tagged/rxjs.md), [javascript](../tagged/javascript.md), [free-programming-books](../tagged/free-programming-books.md)
* :octocat: **[source code](https://github.com/xgrommx/rx-book/)**
---
#### [Learn to combine RxJs sequences with super intuitive interactive diagrams](https://blog.angularindepth.com/learn-to-combine-rxjs-sequences-with-super-intuitive-interactive-diagrams-20fce8e6511)
_https://blog.angularindepth.com/learn-to-combine-rxjs-sequences-with-super-intuitive-interactive-dia..._

Sequence composition is a technique that enables you to create complex queries across multiple data sources by combing relevant streams into one. RxJs provides a variety of operators that can help you...
* :calendar: **published on**: 2017-12-14
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [forkJoin · learn-rxjs](https://www.learnrxjs.io/operators/combination/forkjoin.html)
_https://www.learnrxjs.io/operators/combination/forkjoin.html_

This operator is best used when you have a group of observables and only care about the final emitted value of each. One common use case for this is if you wish to issue multiple requests on page load...
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [Map vs FlatMap by NamitaMalik](https://namitamalik.github.io/Map-vs-FlatMap/)
_https://namitamalik.github.io/Map-vs-FlatMap/_

This blog discusses difference between Map and FlatMap in RxJS.
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [RxJs SwitchMap Operator Deep Dive : How Does It Work ? Learn Selectors](http://blog.angular-university.io/rxjs-switchmap-operator/)
_http://blog.angular-university.io/rxjs-switchmap-operator/_

Although RxJs has a large number of operators, in practice we end up using a relatively small number of them.

And right after the most familiar operators that are also available in arrays (like map, ...
* :calendar: **published on**: 2017-05-05
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md)
---
#### [Angular2 Beta, RxJS, TypeScript - YouTube (1h40min)](https://youtu.be/R62iQvZ0bdQ?t=1633)
_https://youtu.be/R62iQvZ0bdQ?t=1633_

Talk on RxJs and Observables by @BenLesh. Explanation of the difference between the merge, concat and switch strategies for combining Observables.
* :calendar: **published on**: 2016-03-02
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [typescript](../tagged/typescript.md)
---
#### [The introduction to Reactive Programming you've been missing · GitHub](https://gist.github.com/staltz/868e7e9bc2a7b8c1f754)
_https://gist.github.com/staltz/868e7e9bc2a7b8c1f754_

The hardest part of the learning journey is thinking in Reactive. It's a lot about letting go of old imperative and stateful habits of typical programming, and forcing your brain to work in a differen...
* **tags**: [observable](../tagged/observable.md), [rxjs](../tagged/rxjs.md)
---
#### [ReactiveX - Observable](http://reactivex.io/documentation/observable.html)
_http://reactivex.io/documentation/observable.html_

In ReactiveX an _observer subscribes_ to an _Observable_. Then that observer reacts to whatever item or sequence of items the Observable _emits_. This pattern facilitates concurrent operations because...
* **tags**: [observable](../tagged/observable.md), [rxjs](../tagged/rxjs.md)
---
#### [3 Ways to Pass Async Data to Angular 2+ Child Components | Scotch](https://scotch.io/tutorials/3-ways-to-pass-async-data-to-angular-2-child-components)
_https://scotch.io/tutorials/3-ways-to-pass-async-data-to-angular-2-child-components_

The three ways :
1. Use `ngIf`
2. Use `ngOnChanges`
3. Use RxJs `BehaviorSubject`
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md)
---
#### [André Staltz - How to debug RxJS code](http://staltz.com/how-to-debug-rxjs-code.html)
_http://staltz.com/how-to-debug-rxjs-code.html_

* First, draw the dependency graph.
* Observables with two or more outgoing arrows in the dependency graph usually need to be hot.
* To debug with the console log, use `.do()`, not `.subscribe()`.
* D...
* **tags**: [rxjs](../tagged/rxjs.md), [debugging](../tagged/debugging.md)
---
#### [RxMarbles: Interactive diagrams of Rx Observables](http://rxmarbles.com/)
_http://rxmarbles.com/_

A webapp for experimenting with diagrams of [Rx](http://reactivex.io/) Observables, for learning purposes.
* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [RxJS 5   Thinking Reactively | Ben Lesh - YouTube](https://youtu.be/3LKMwkuK0ZE)
_https://youtu.be/3LKMwkuK0ZE_

* **tags**: [rxjs](../tagged/rxjs.md)
---
#### [Cold vs Hot Observables by thoughtram](https://blog.thoughtram.io/angular/2016/06/16/cold-vs-hot-observables.html)
_https://blog.thoughtram.io/angular/2016/06/16/cold-vs-hot-observables.html_

Helps with simple examples understand the nature of hot and cold observables.

 TABLE OF CONTENTS
* Hot vs Cold Observables
* Making Cold Observables Hot
* Understanding `publish`, `refCount` and ...
* **tags**: [angular](../tagged/angular.md), [observable](../tagged/observable.md), [rxjs](../tagged/rxjs.md)
---
#### [Angular 2 Application Architecture: Build Reux-like Apps with RxJs](http://blog.angular-university.io/angular-2-application-architecture-building-applications-using-rxjs-and-functional-reactive-programming-vs-redux/)
_http://blog.angular-university.io/angular-2-application-architecture-building-applications-using-rxj..._

In this post, we are going to walk through how Angular 2 applications can be built in a Functional Reactive style using the RxJs library that is part of Angular 2 (see Managing State in Angular 2 Appl...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [application-architecture](../tagged/application-architecture.md)
---
#### [Tackling State – Angular 2](http://victorsavkin.com/post/137821436516/managing-state-in-angular-2-applications)
_http://victorsavkin.com/post/137821436516/managing-state-in-angular-2-applications_

Managing application state is a hard problem. You need to coordinate between multiple backends, web workers, and UI components. Patterns like Redux and Flux are designed to address this problem by mak...
* **tags**: [angular](../tagged/angular.md), [rxjs](../tagged/rxjs.md), [observable](../tagged/observable.md)
---


text:
<?xml version="1.0" encoding="ascii"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
          "DTD/xhtml1-transitional.dtd">

  <title>couchdbkit.resource.CouchDBResponse</title>
  <link rel="stylesheet" href="epydoc.css" type="text/css" />

         Home

         Trees

         Indices

         Help

        Package couchdbkit ::
        Module resource ::
        Class CouchDBResponse

[hide private]

[frames] | no frames]

Class CouchDBResponse

source code

               object --+
                        |
restkit.wrappers.Response --+
                            |
                           CouchDBResponse

        Instance Methods
        [hide private]

Inherited from restkit.wrappers.Response:
      __contains__,
      __getitem__,
      __init__,
      __iter__,
      body_stream,
      body_string,
      can_read,
      tee

Inherited from object:
      __delattr__,
      __format__,
      __getattribute__,
      __hash__,
      __new__,
      __reduce__,
      __reduce_ex__,
      __repr__,
      __setattr__,
      __sizeof__,
      __str__,
      __subclasshook__

        Class Variables
        [hide private]

Inherited from restkit.wrappers.Response:
      charset,
      unicode_errors

        Properties
        [hide private]

        json_body

Inherited from object:
      __class__

        Property Details
        [hide private]

json_body

Get Method:

unreachable.json_body(self)

         Home

         Trees

         Indices

         Help

    Generated by Epydoc 3.0.1 on Fri Feb 18 10:31:28 2011

      http://epydoc.sourceforge.net