Major layout change to the packages directory

Having one monolithic packages directory makes it hard to find things
and is generally overwhelming. This commit splits it into several
logical sections roughly based on function, recipes.txt gives more
information about the classifications used.

The opportunity is also used to switch from "packages" to "recipes"
as used in OpenEmbedded as the term "packages" can be confusing to
people and has many different meanings.

Not all recipes have been classified yet, this is just a first pass
at separating things out. Some packages are moved to meta-extras as
they're no longer actively used or maintained.

Signed-off-by: Richard Purdie <rpurdie@linux.intel.com>

1 files changed, 1548 insertions, 0 deletions

diff --git a/meta/recipes-kernel/linux/linux-rp-2.6.23/zylonite_touch-r0.patch b/meta/recipes-kernel/linux/linux-rp-2.6.23/zylonite_touch-r0.patch
new file mode 100644
index 0000000000..1c00696051
--- /dev/null
+++ b/meta/recipes-kernel/linux/linux-rp-2.6.23/zylonite_touch-r0.patch
@@ -0,0 +1,1548 @@
+Index: linux-2.6.23/drivers/input/touchscreen/Kconfig
+===================================================================
+--- linux-2.6.23.orig/drivers/input/touchscreen/Kconfig	2008-02-13 01:12:29.000000000 +0000
++++ linux-2.6.23/drivers/input/touchscreen/Kconfig	2008-02-13 01:13:20.000000000 +0000
+@@ -54,6 +54,12 @@
+ 	  To compile this driver as a module, choose M here: the
+ 	  module will be called corgi_ts.
+ 
++config TOUCHSCREEN_ZYLONITE
++	tristate "Zylonite touchscreen driver"
++	default y
++	help
++	  Say Y here for the Zylonite touchscreen driver
++
+ config TOUCHSCREEN_FUJITSU
+ 	tristate "Fujitsu serial touchscreen"
+ 	select SERIO
+Index: linux-2.6.23/drivers/input/touchscreen/Makefile
+===================================================================
+--- linux-2.6.23.orig/drivers/input/touchscreen/Makefile	2008-02-13 01:12:29.000000000 +0000
++++ linux-2.6.23/drivers/input/touchscreen/Makefile	2008-02-13 01:13:38.000000000 +0000
+@@ -19,3 +19,4 @@
+ obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)	+= touchwin.o
+ obj-$(CONFIG_TOUCHSCREEN_UCB1400)	+= ucb1400_ts.o
+ obj-$(CONFIG_TOUCHSCREEN_TSC2101)	+= tsc2101_ts.o
++obj-$(CONFIG_TOUCHSCREEN_ZYLONITE)	+= zylonite-ts.o
+Index: linux-2.6.23/drivers/input/touchscreen/zylonite-ts.c
+===================================================================
+--- /dev/null	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.6.23/drivers/input/touchscreen/zylonite-ts.c	2008-02-13 16:19:15.000000000 +0000
+@@ -0,0 +1,1517 @@
++/*
++ *  drivers/input/touchscreen/mhn_audio_touch.c.
++ *
++ *  Author:	bridge.wu@marvell.com
++ *  Created:	Nov 17, 2006
++ *  Copyright:	Marvell Corporation.
++ *
++ *  This program is free software; you can redistribute it and/or modify
++ *  it under the terms of the GNU General Public License version 2 as
++ *  published by the Free Software Foundation.
++ */
++#include <linux/init.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/device.h>
++#include <linux/platform_device.h>
++#include <linux/interrupt.h>
++#include <linux/delay.h>
++
++#include <sound/driver.h>
++#include <sound/core.h>
++#include <sound/pcm.h>
++#include <sound/initval.h>
++
++#include <asm/semaphore.h>
++#include <asm/hardware.h>
++#include <asm/arch/pxa-regs.h>
++#include <asm/arch/gpio.h>
++#include <asm/arch/mfp.h>
++//#include <asm/arch/ipmc.h>
++#include <linux/suspend.h>
++#include <linux/spinlock.h>
++
++//#include <asm/arch/codec/acodec.h>
++//#include <asm/arch/mhn_audio_plat.h>
++
++#define OSCC               __REG(0x41350000)  /* Oscillator Configuration Register */
++#define AC97_DIV	__REG(0x41340014)
++
++#define ALSA_ZY_CARD_DEBUG
++#undef ALSA_ZY_CARD_DEBUG
++
++#define WM_9713_ID  0x4C13 /* this should be the 7E register value */
++
++#ifdef ALSA_ZY_CARD_DEBUG
++#define dbg(format, arg...) printk(KERN_DEBUG format, ##arg)
++#else
++#define dbg(format, arg...)
++#endif
++
++#define DEBUG
++#undef DEBUG
++#ifdef DEBUG
++unsigned int start_time;
++unsigned int end_time;
++unsigned int time;
++#define PRINT_TIME() do {\
++        time = ((end_time > start_time))?\
++                (end_time - start_time)*100/325:\
++                (0xffffffff - start_time + end_time)*100/325;\
++        printk("\n%s:%dus\n", __FUNCTION__, time);\
++} while(0)
++#endif
++
++
++
++
++/* 9713 specific
++ *	Register Name			Index
++ */
++#define RESET				0X00
++#define SPEAKER_VOLUME 			0X02
++#define HEADPHONE_VOLUME		0X04
++#define OUT3_OUT4_VOLUME  		0X06
++#define MONOVOL_MONOINPGA_ROUTE		0X08
++#define LINE_IN_PGA_VOL_ROUTE		0X0A
++#define DAC_PGA_VOL_ROUTE		0X0C
++#define MIC_PGA_VOLUME			0X0E
++#define MIC_ROUTING			0X10
++#define REC_PGA_VOL			0X12
++#define REC_ROUTE_MUX_SEL		0X14
++#define PCBEEP_VOL_ROUTE		0X16
++#define VXDAC_VOLUME_ROUTE		0X18
++#define AUX_DAC_VOL_ROUTE		0X1A
++#define OUTPUT_PGA_MUX			0X1C
++#define DAC_3D_CTRL_INV_MUX_SEL		0X1E
++#define DAC_TONE_CTRL			0X20
++#define MIC_BIAS			0X22
++#define OUTPUT_VOL_MAPPING_JACK		0X24
++#define POWERDOWN_CTRL_STAT		0X26
++#define EXTENDED_AUD_ID			0X28
++#define EXTENDED_AUD_STAT_CTRL  	0X2A
++#define AUDIO_DAC_RATE			0X2C
++#define AUX_DAC_RATE			0X2E
++#define AUDIO_ADC_RATE			0X32
++#define PCM_CODEC_CTRL			0X36
++#define SPDIF_CTRL			0X3A
++#define POWER_DOWN_1			0X3C
++#define POWER_DOWN_2			0X3E
++#define GENERAL_PURPOSE_WM_13		0X40
++#define FAST_POWERUP_CTRL		0X42
++#define MCLK_PLL_CTRL_1			0X44
++#define MCLK_PLL_CTRL_2			0X46
++#define GPIO_PIN_CFG			0X4C
++#define GPIO_PIN_POL_TYPE		0X4E
++#define GPIO_PIN_STICKY 		0X50
++#define GPIO_PIN_WAKEUP			0X52
++#define GPIO_PIN_STATUS			0X54
++#define GPIO_PIN_SHARING		0X56
++#define GPIO_PULL_UP_DOWN_CTRL		0X58
++#define ADD_FUNC_1         		0X5A
++#define ADD_FUNC_2        		0X5C
++#define ALC_CTRL         		0X60
++#define ALC_NOISE_GATE_CTRL		0X62
++#define AUX_DAC_INPUT_CTRL 		0X64
++#define TEST_REG_1 			0X68
++#define TEST_REG_2 			0X6A
++#define TEST_REG_3 			0X6C
++#define TEST_REG_4 			0X6E
++#define DIGITIZER_1_WM13	    	0x74
++#define DIGITIZER_2_WM13	    	0x76
++#define DIGITIZER_3_WM13	    	0x78
++#define DIGITIZER_READ_BACK	    	0x7a
++#define VENDOR_ID1	  		0x7c
++#define VENDOR_ID2	  		0x7e
++
++#define ZY_TOUCH_SAMPLE_X 1
++#define ZY_TOUCH_SAMPLE_Y 2
++
++#define ZY_EVENT_TYPE_NONE			0
++#define ZY_EVENT_TYPE_PDN			1
++
++
++typedef enum _zy_acodec_error_t {
++    ZY_ACODEC_SUCCESS = 0,    /* successful completion of a function */
++    ZY_ACODEC_GENERAL_SW_ERR, /* null pointer to registers or other software error */
++    ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT, /* time-out for waiting for respponse */
++    ZY_ACODEC_SAMPLERATE_NOT_SUPPORTED, /* the sample rate is not supported either in controller or codec */
++    ZY_ACODEC_FEATURE_NO_SUPPORTED, /* this codec feature is not supported  */
++    ZY_ACODEC_GENERAL_HW_ERR ,/* other hardware error besides time out */
++    ZY_ACODEC_ROUTE_NO_SUPPORTED, /* the codec can not set the route required */
++    ZY_ACODEC_SLEEP /* the codec is sleep */
++} zy_acodec_error_t;
++
++typedef unsigned int zy_acodec_device_id_t;
++
++typedef enum _codec_state {
++	ZY_CODEC_SLEEP  = 0,
++	ZY_CODEC_WAKEUP = 1
++} acodec_state_t;
++
++typedef enum {
++       ZY_FM = 0,
++       ZY_MIC1 = 1,
++       ZY_MIC2 = 2,
++       ZY_SPEAKER =3,
++       ZY_HEADSET =4,
++       ZY_HANDSET =5,
++} vol_port_type_t;
++
++typedef struct _context_t {
++	int  use_count; 		/* probe/remove and suspend/resume usage count, sync among multiple devices */
++	zy_acodec_device_id_t acodec_id;/* - an ID that uniquely identifies the codec to be used */
++	unsigned long init_number; 	/* used by driver to track whether it is inited or not */
++
++	void *p_voice_reg;       	/* pointer to Monahans registers that has PCM interface to codec */
++	void *p_hifi_reg;        	/* pointer to Monahans registers that has hifi interface to codec */
++	void *p_ctrl_reg;        	/* pointer to Monahans registers that has control interface to codec */
++	int  *p_ost_regs;		/* needed for time out */
++	void *p_save_memory;        	/* pointer to a memory region to save context while suspend */
++    	void *p_zy_scenario;        	/* pointer to the scenario data structure  */
++    	long u_max_read_write_time_out_ms;/* input the max time to wait in milliseconds before giving up on a read or write operation */
++	long u_max_setup_time_out_ms;	/* input the maximum time in milliseconds to wait during initial setup of the ACODEC controller and codec */
++
++	/* member functions these pointers must be set by */
++	zy_acodec_error_t (* g_pfn_codec_specific_init)      (struct _context_t *p_device_context);
++	zy_acodec_error_t (* g_pfn_codec_specific_dinit)    (struct _context_t *p_device_context);
++	zy_acodec_error_t (* g_pfn_acodec_read)             (struct _context_t *p_dev_context, unsigned short reg_addr, unsigned short *p_reg_value);
++	zy_acodec_error_t (* g_pfn_acodec_write)            (struct _context_t *p_dev_context, unsigned short reg_addr, unsigned short reg_value);
++
++	/* add for route */
++	zy_acodec_error_t (* g_pfn_set_route)           (struct _context_t *p_device_context, unsigned short * rout_map ,unsigned short* current_map);
++	/* add for sleep the codec */
++	zy_acodec_error_t (* g_pfn_sleep_codec)           (struct _context_t *p_device_context);
++	/* add for Wake up the codec */
++	zy_acodec_error_t (* g_pfn_wake_codec)           (struct _context_t *p_device_context);
++	/* add for get codec state */
++	zy_acodec_error_t (* g_pfn_get_state)           (struct _context_t *p_device_context, acodec_state_t *p_state);
++	/* add for volume */
++	zy_acodec_error_t (* g_pfn_get_vol)(struct _context_t *p_device_context, vol_port_type_t port,  unsigned short *gain_in_db);
++	zy_acodec_error_t (* g_pfn_set_vol)(struct _context_t *p_device_context, vol_port_type_t port,  unsigned short gain_in_db);
++
++        void (* g_pfn_get_event)(struct _context_t *p_device_context, unsigned char * event_type);
++        void (* g_pfn_event_ack)(struct _context_t *p_device_context, unsigned char event_type);
++        zy_acodec_error_t (* g_pfn_enable_touch)(struct _context_t *p_device_context);
++        zy_acodec_error_t (* g_pfn_disable_touch)(struct _context_t *p_device_context);
++} zy_acocec_context_t, *p_zy_acocec_context_t;
++
++
++
++
++
++static p_zy_acocec_context_t p_zy_codec_ctxt = NULL;
++
++#include <linux/input.h>
++//#include <asm/arch/codec/wm9713.h>
++
++#define PEN_DOWN 		1
++#define PEN_UP			0
++#define TS_SAMPLE_INTERVAL 	1
++
++typedef struct {
++	struct input_dev *idev;
++	struct timer_list *timer;
++	int  use_count;
++} codec_zy_ts_t;
++
++codec_zy_ts_t codec_zy_ts;
++
++static struct input_dev *codec_zy_ts_input;
++
++#ifdef CONFIG_PM
++static volatile int touch_suspend = 0 ;
++#endif
++
++#define ZY_AC97_CODEC_REGS_NUM        0x40
++
++typedef struct
++{  //   Register symbol     // Usage
++    volatile unsigned long pocr;           // PCM Out Control Register
++    volatile unsigned long picr;           // PCM In Control Register
++    volatile unsigned long mccr;           // Mic In Control Register
++    volatile unsigned long gcr;            // Global Control Register
++    volatile unsigned long posr;           // PCM Out Status Register
++    volatile unsigned long pisr;           // PCM In Status Register
++    volatile unsigned long mcsr;           // Mic In Status Register
++    volatile unsigned long gsr;            // Global Status Register
++    volatile unsigned long car;            // CODEC Access Register
++    volatile unsigned long pcscr;          // PCM Surround Out Control
++    volatile unsigned long pcssr;          // PCM Surround Out Status
++    volatile unsigned long pcsdr;          // PCM Surround Out Data
++    volatile unsigned long pcclcr;         // PCM Center/LFE Out Control
++    volatile unsigned long pcclsr;         // PCM Center/LFE Out Status
++    volatile unsigned long pccldr;         // PCM Center/LFE Out Data
++    volatile unsigned long reserved1;       //
++    volatile unsigned long pcdr;           // PCM FIFO Data Register
++    volatile unsigned long reserved2 [0x7];      // 0x4050-0044 through 0x4050-005C
++    volatile unsigned long mcdr;           // Mic-in FIFO Data Register
++    volatile unsigned long reserved3 [0x27];   // 0x4050-0064 through 0x4050-00FC
++    volatile unsigned long mocr;           // MODEM Out Control Register
++    volatile unsigned long reserved4;
++    volatile unsigned long micr;           // MODEM In Control Register
++    volatile unsigned long reserved5;
++    volatile unsigned long mosr;           // MODEM Out Status Register
++    volatile unsigned long reserved6;
++    volatile unsigned long misr;           // MODEM In Status Register
++    volatile unsigned long reserved7 [0x9];      // 0x4050-011C through 0x4050-013C
++    volatile unsigned long modr;           // MODEM FIFO Data Register
++    volatile unsigned long reserved8 [0x2F];   // 0x4050-0144 through 0x4050-01FC
++                            // Primary Audio CODEC registers access
++    volatile unsigned long codec_regs_primary_aud   [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 01 Audio CODEC registers access
++    volatile unsigned long codec_regs_secondary_aud [ZY_AC97_CODEC_REGS_NUM];
++                            // Primary MODEM CODEC registers access
++    volatile unsigned long codec_regs_primary_mdm   [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 01 MODEM CODEC registers access
++    volatile unsigned long codec_regs_secondary_mdm [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 10 MODEM CODEC registers access
++    volatile unsigned long codec_regs_third_mdm [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 11 MODEM CODEC registers access
++    volatile unsigned long codec_regs_fouth_mdm [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 10 Audio CODEC registers access
++    volatile unsigned long codec_regs_third_aud [ZY_AC97_CODEC_REGS_NUM];
++                            // Secondary ID 11 Audio CODEC registers access
++    volatile unsigned long codec_regs_fouth_aud [ZY_AC97_CODEC_REGS_NUM];
++}  zy_ac97_acodec_t, *p_zy_ac97acodec_t ;
++
++
++/* Constants for the Global Control Register and Global Status Register */
++
++// AC97 Global Control Register bit mask constants
++
++#define ZY_AC97_GCR_GIE_MSK          (1u << 0 )
++#define ZY_AC97_GCR_COLD_RESET_MSK   (1u << 1 )
++#define ZY_AC97_GCR_WARM_RESET_MSK   (1u << 2 )
++#define ZY_AC97_GCR_LINK_OFF_MSK     (1u << 3 )
++#define ZY_AC97_GCR_PCRSM_IEN_MSK    (1u << 4 )
++#define ZY_AC97_GCR_SCRSM_IEN_MSK    (1u << 5 )
++#define ZY_AC97_GCR_PCRDY_IEN_MSK    (1u << 8 )
++#define ZY_AC97_GCR_SCRDY_IEN_MSK    (1u << 9 )
++#define ZY_AC97_GCR_SDONE_IE_MSK     (1u << 18)
++#define ZY_AC97_GCR_CDONE_IE_MSK     (1u << 19)
++#define ZY_AC97_GCR_nDMAEN_MSK       (1u << 24)
++#define ZY_AC97_GCR_CLKBPB_MSK       (1u << 31)
++#define ZY_AC97_GCR_FRCRST_MSK       (1u << 30)
++// Global Status Register bit mask constants
++
++#define ZY_AC97_GSR_GSCI_MSK       (1u << 0 )
++#define ZY_AC97_GSR_MIINT_MSK      (1u << 1 )
++#define ZY_AC97_GSR_MOINT_MSK      (1u << 2 )
++#define ZY_AC97_GSR_ACOFFD_MSK     (1u << 3 )
++#define ZY_AC97_GSR_PIINT_MSK      (1u << 5 )
++#define ZY_AC97_GSR_POINT_MSK      (1u << 6 )
++#define ZY_AC97_GSR_MINT_MSK       (1u << 7 )
++#define ZY_AC97_GSR_PCRDY_MSK      (1u << 8 )
++#define ZY_AC97_GSR_SCRDY_MSK      (1u << 9 )
++#define ZY_AC97_GSR_PCRSM_MSK      (1u << 10)
++#define ZY_AC97_GSR_SCRSM_MSK      (1u << 11)
++#define ZY_AC97_GSR_SLT12_BITS_MSK (7u << 12)
++#define ZY_AC97_GSR_RCS_ERR_MSK    (1u << 15)
++#define ZY_AC97_GSR_SDONE_MSK      (1u << 18)
++#define ZY_AC97_GSR_CDONE_MSK      (1u << 19)
++
++
++// Bit mask and values for CAIP bit in car register.
++#define ZY_AC97_CAR_CAIP_MSK       (0x1<<0)
++#define ZY_AC97_CAR_CAIP_LOCKED    (0x1<<0)
++#define ZY_AC97_CAR_CAIP_CLEAR     (0<<0)
++
++/* Constants for FIFO status reporting and control */
++
++// One bit location is used to report FIFO error conditions and clear
++//  interrupts on those conditions in the various non-global status registers.
++
++// ZY_AC97_FIFOSTAT_FIFOE is used in:
++                                                // posr
++                                                // pisr
++                                                // mcsr
++                                                // mosr
++                                                // misr
++
++#define ZY_AC97_FIFOSTAT_FIFOE  (1u << 4)
++#define ZY_AC97_FIFOSTAT_EOC	  (1u << 3)
++#define ZY_AC97_FIFOSTAT_FSR	  (1u << 2)
++
++// A different bit location is used to enable or disable interrupts based on
++//  FIFO error conditions in the various non-global control registers.
++
++// ZY_AC97_FIFOCTRL_FEIE is used in:
++                                                // pocr
++                                                // picr
++                                                // mccr
++                                                // mocr
++                                                // micr
++
++#define ZY_AC97_FIFOCTRL_FEIE  (1u << 3)
++#define ZY_AC97_FIFOCTRL_FSRIE (1u << 1)
++
++/*
++*******************************************************************************
++    AC'97 Codec Registers Location and Bit Definition
++*******************************************************************************
++*/
++
++/* */
++
++    // Includes symbolic values for certain proprietary register asssignments
++    //   in AC'97 devices that might be used with ZY_AC97.
++
++    // Valid for subset of R 2.1 specification.
++    // Leading "e" in comment means it is an "expanded" register definition as
++    //  found in one or more of the Appendices A-D of the R 2.1 specification.
++    //  Appendix identifier will immediately follow the "e", such as "eA"
++    // R/O indicates read-only
++    // Registers not supported by the assumed controller will be commented out.
++
++#define    ZY_AC97_CR_RESET_ID             0x00  // RESET CODEC TO DEFAULT, get ID info
++#define    ZY_AC97_CR_MASTER_VOLUME        0x02  // LINE OUT VOLUME
++#define    ZY_AC97_CR_HEADPHONE_VOLUME     0x04  //
++#define    ZY_AC97_CR_MASTER_VOLUME_MONO   0x06  //
++#define    ZY_AC97_CR_MASTER_TONE_R_L      0x08  //
++#define    ZY_AC97_CR_PC_BEEP_VOLUME       0x0A  //
++#define    ZY_AC97_CR_PHONE_VOLUME         0x0C  //
++#define    ZY_AC97_CR_MIC_VOLUME           0x0E  //   micrOPHONE VOLUME/ AGC
++#define    ZY_AC97_CR_LINE_IN_VOLUME       0x10  //   LINE IN VOLUME
++#define    ZY_AC97_CR_CD_VOLUME            0x12  //
++#define    ZY_AC97_CR_VIDEO_VOLUME         0x14  //
++#define    ZY_AC97_CR_AUX_VOLUME           0x16  //
++#define    ZY_AC97_CR_PCM_OUT_VOLUME       0x18  //
++#define    ZY_AC97_CR_RECORD_SELECT        0x1A  //   SELECT LINE IN OR micrOPHONE
++#define    ZY_AC97_CR_RECORD_GAIN          0x1C  //
++#define    ZY_AC97_CR_RECORD_GAIN_MIC      0x1E  //
++#define    ZY_AC97_CR_GENERAL_PURPOSE      0x20  //
++#define    ZY_AC97_CR_CONTROL_3D           0x22  //
++#define    ZY_AC97_CR_POWERDOWN_CTRL_STAT  0x26  //   POWER MANAGEMENT
++#define    ZY_AC97_CR_E_AUDIO_ID           0x28  // eA Extended audio sprt info, R/O
++#define    ZY_AC97_CR_E_AUDIO_CTRL_STAT    0x2A  // eA Extended audio stat + control
++
++//
++// Audio Sample Rate Control Registers, 0x2C - 0x34
++//
++                                           // eA PCM Front DAC rate control
++#define    ZY_AC97_CR_E_ASR_PCM_FRNT_DAC_RT 0x2C  //  (output slots 3, 4, 6)
++#define    ZY_AC97_CR_E_ASR_PCM_LR_ADC_RT   0x32  // eA PCM L+R ADC rate control (3+4)
++#define    ZY_AC97_CR_E_ASR_MIC_ADC_RT      0x34  // eA PCM Mic ADC rate control (5)
++
++
++#define    ZY_AC97_CR_E_MDM_GPIO_PIN_STAT     0x54
++//
++// 5Ah-7Ah: Vendor Reserved
++//
++//
++// 7Ch-7Eh: Vendor ID registers.  Optional but standardized for Plug'n'Play
++//
++#define    ZY_AC97_CR_VENDOR_ID1         0x7C
++#define    ZY_AC97_CR_VENDOR_ID2         0x7E
++
++#define    ZY_AC97_CR_MAX               ZY_AC97_CR_VENDOR_ID2
++
++#define    ZY_AC97_CR_END_OF_LIST       (ZY_AC97_CR_MAX +  2)
++
++
++
++/* Other Constants */
++
++// For accessing the Codec mixer registers, each increment of one 32-bit word
++//  in processor space increments the addressed mixer register by two.
++// This does not cause any ambiguities because only even mixer register
++//  addresses are currently supported (AC '97 spec, R 2.2)
++#define ZY_AC97_CODEC_REGS_PER_WORD   	2
++
++/* Default timeout and holdtime settings */
++
++// timeout in reading and writing codec registers through AC link
++#define ZY_AC97_RW_TIMEOUT_DEF		200	//unit is us
++
++// timeout in waiting for codec's ready signal during setup process
++#define ZY_AC97_SETUP_TIMEOUT_DEF		500	//unit is us
++
++// timeout in waiting for locking the link successfully
++#define ZY_AC97_LOCK_TIMEOUT_DEF   		300	//unit is us
++
++// timeout in shutting down the link
++#define ZY_AC97_LINKOFF_TIMEOUT_DEF   	500	//unit is us
++
++// holdtime for keeping nReset signal active(low) in AC link
++#define ZY_AC97_COLD_HOLDTIME			100	//unit is us
++
++/*
++*******************************************************************************
++  ZY AC97 data structure used in function interface
++*******************************************************************************
++*/
++
++typedef struct
++{
++    unsigned long pocr;           // PCM Out Control Register
++    unsigned long picr;           // PCM In Control Register
++    unsigned long mccr;           // Mic In Control Register
++    unsigned long gcr;            // Global Control Register
++    unsigned long pcscr;          // PCM Surround Out Control
++    unsigned long pcclcr;         // PCM Center/LFE Out Control
++    unsigned long mocr;           // MODEM Out Control Register
++    unsigned long micr;           // MODEM In Control Register
++}zy_ac97_save_context_t;
++
++
++#define AC97_SAVE_CONTEXT_SIZE (sizeof(zy_ac97_save_context_t))
++
++static int zy_ac97_acodec_link_lock(p_zy_ac97acodec_t p_ac97_reg)
++{
++	int		status = 1;
++	volatile unsigned long	car_tmp;
++
++	car_tmp = p_ac97_reg->car;
++	if (car_tmp & ZY_AC97_CAR_CAIP_MSK)	/*  "1" in CAIP bit means lock failed. */
++	{
++		status = 0;
++	}
++	return (status);
++}
++
++
++zy_acodec_error_t zy_ac97_acodec_write (zy_acocec_context_t *p_dev_context, unsigned short offset, unsigned short data)
++{
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	int			got_link;
++	unsigned long		time_remaining;
++	volatile unsigned long *	p_codec_reg;
++	p_zy_ac97acodec_t p_ac97_reg = (p_zy_ac97acodec_t)(p_dev_context->p_ctrl_reg);
++	unsigned long max_rw_time_out_us = (p_dev_context->u_max_read_write_time_out_ms) * 1000;
++
++
++	if(offset == ZY_AC97_CR_E_MDM_GPIO_PIN_STAT)
++	{/* it is a special register and sent out on slot 12 */
++		p_codec_reg = &(p_ac97_reg->codec_regs_primary_mdm[0]);
++		p_codec_reg += offset / ZY_AC97_CODEC_REGS_PER_WORD;
++		/*  The data will be sent out on slot 12. */
++		*p_codec_reg = (unsigned long)data;
++		goto done;
++	}
++
++	/*  Point to specified register within area mapped to target codec regs */
++	p_codec_reg = &(p_ac97_reg->codec_regs_primary_aud[0]);
++	p_codec_reg += offset / ZY_AC97_CODEC_REGS_PER_WORD;
++
++
++	/* Lock the ACLINK */
++	time_remaining = ZY_AC97_LOCK_TIMEOUT_DEF;
++	do
++	{
++		got_link = zy_ac97_acodec_link_lock(p_ac97_reg);
++		if (0 == got_link)	/*  1 usec is a long time.  Skip delay if possible. */
++		{
++			udelay(1);
++		}
++	}		/*  Wait while time remaining and ACLINK not available */
++	while (time_remaining-- && (0 == got_link));
++
++	if (0 == got_link)	/*  Didn't get the ACLINK */
++	{
++		status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++		printk(KERN_ERR "AC97 Write Link Timeout\n");
++	}
++	else	/*  We got the link. Perform the write operation and don't wait. */
++	{
++		/*  First, clear old write status indication CDONE by writing a ONE to that bit. */
++		p_ac97_reg->gsr = ZY_AC97_GSR_CDONE_MSK;
++
++		*p_codec_reg = (unsigned long)data;	   /*  Now the write! */
++
++		/* Wait until write cycle is complete. There should be a way
++		 * to do this speculatively at the beginning of the procedure.
++		 * Need to discover it. Too inefficient to always wait.
++		 */
++
++		time_remaining = max_rw_time_out_us;
++		do
++		{
++			udelay(1);
++		}	 /*  Wait while time remaining and command I/O still incomplete. */
++		while ( (time_remaining--) && !(p_ac97_reg->gsr & ZY_AC97_GSR_CDONE_MSK));
++		if (!(p_ac97_reg->gsr & ZY_AC97_GSR_CDONE_MSK))
++		{
++			status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++			p_ac97_reg->car = ZY_AC97_CAR_CAIP_CLEAR;
++		}
++	}  /*  Got AC link */
++
++done:
++	return(status);
++} /*  Ac97CtrlCodecWrite() */
++
++#define CKENA		__REG(0x4134000C)	/* A Clock Enable Register */
++#define CKENB		__REG(0x41340010)
++
++zy_acodec_error_t zy_ac97_acodec_read  (zy_acocec_context_t *p_dev_context, unsigned short offset,  unsigned short *pdata)
++{
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	int			got_link;
++	unsigned long		time_remaining;
++	volatile unsigned long *	p_codec_reg;
++	p_zy_ac97acodec_t p_ac97_reg = (p_zy_ac97acodec_t)(p_dev_context->p_ctrl_reg);
++	unsigned long max_rw_time_out_us = (p_dev_context->u_max_read_write_time_out_ms) * 1000;
++
++	/*  Point to specified register within area mapped to target codec regs */
++	p_codec_reg = &(p_ac97_reg->codec_regs_primary_aud[0]);
++	p_codec_reg += offset / ZY_AC97_CODEC_REGS_PER_WORD;
++
++	/* Lock the ACLINK */
++	time_remaining = ZY_AC97_LOCK_TIMEOUT_DEF;
++	do
++	{
++		got_link = zy_ac97_acodec_link_lock(p_ac97_reg);
++		if (0 == got_link)	/*  1 usec is a long time.  Skip delay if possible. */
++		{
++			udelay(1);
++		}
++	}		/*  Wait while time remaining and ACLINK not available */
++	while (time_remaining-- && (0 == got_link));
++
++	if (0 == got_link)	/*  Didn't get the ACLINK */
++	{
++		status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++		printk(KERN_ERR "AC97 Read Link Timeout\n");
++	}
++	else	/*  We got the link. Perform the write operation and don't wait. */
++	{
++		 /*  First, clear old read status indications. */
++		p_ac97_reg->gsr = ZY_AC97_GSR_SDONE_MSK | ZY_AC97_GSR_RCS_ERR_MSK;
++
++		*pdata = (unsigned short)(*p_codec_reg); /*  This is THE DUMMY READ. */
++
++		 /*  Wait for read I/O with codec to complete before doing real read. */
++		time_remaining = max_rw_time_out_us;
++		do
++		{
++			udelay(1);
++		}   /*  Wait while time remaining and read I/O still incomplete */
++		while( (time_remaining--) && (!(p_ac97_reg->gsr & ZY_AC97_GSR_SDONE_MSK)) );
++
++		if ((p_ac97_reg->gsr & ZY_AC97_GSR_SDONE_MSK) && (!(p_ac97_reg->gsr & ZY_AC97_GSR_RCS_ERR_MSK)) )
++		{
++			if (p_ac97_reg->gsr & ZY_AC97_GSR_RCS_ERR_MSK)
++			{/* timeout indicated by RCS bit */
++				status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++			}
++			/*  succeed in reading. clear status bits first. */
++			p_ac97_reg->gsr = ZY_AC97_GSR_SDONE_MSK | ZY_AC97_GSR_RCS_ERR_MSK;
++			*pdata = (unsigned short)(*p_codec_reg);	/*  THE REAL READ. */
++			if (*pdata == 0xffff)
++			{/* timeout indicated by returned value */
++				status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++			}
++			/* check later: is second waiting really needed? */
++	 		time_remaining = max_rw_time_out_us;
++			do
++			{
++				udelay(1);
++  			}   /*  Wait while time remaining and read I/O still incomplete */
++			while( (time_remaining--) && (!(p_ac97_reg->gsr & ZY_AC97_GSR_SDONE_MSK)) );
++			//printk(KERN_ERR "AC97 Read Result %d\n", (p_ac97_reg->gsr & ZY_AC97_GSR_SDONE_MSK) );
++		}
++		else	/*  failed */
++		{
++			status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++			p_ac97_reg->car = ZY_AC97_CAR_CAIP_CLEAR;
++			//printk(KERN_ERR "AC97 Read Link Timeout2 %x %x %x\n", CKENA, OSCC, CKENB);
++		} /*  else  (OK to do real read) */
++
++	} /*  else  (We got the link.  Perform the read operations.) */
++
++	return (status);
++}
++
++
++
++zy_acodec_error_t zy_acodec_get_adc_sample(zy_acocec_context_t *p_device_context, unsigned short *p_sample_data, unsigned short adc_type, int *p_pen_down)
++{
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	unsigned short value;
++	unsigned long wait;
++
++	if (adc_type == ZY_TOUCH_SAMPLE_X)
++	{
++		value = 0x202;
++	}
++	else
++	{/* Y sample */
++		value = 0x204;
++	}
++
++	status = zy_ac97_acodec_write(p_device_context, DIGITIZER_1_WM13, value);
++
++	wait = 0;
++	do
++	{
++		status = zy_ac97_acodec_read(p_device_context, DIGITIZER_1_WM13, &value);
++		if ( !(value & 0x200 ) )
++		{
++			break;
++		}
++	}while ( 100 > wait++ );
++
++	status = zy_ac97_acodec_read(p_device_context, DIGITIZER_READ_BACK, &value);
++	if (value & 0x8000)
++	{/* means pen down */
++		*p_pen_down = 1;
++	}
++	else
++	{
++		*p_pen_down = 0;
++	}
++	*p_sample_data = value & 0xfff;
++
++	return status;
++}
++
++
++
++/*
++ * add a touch event
++ */
++static int codec_zy_ts_evt_add(codec_zy_ts_t* ts, u16 pressure, u16 x, u16 y)
++{
++        /* add event and remove adc src bits */
++        static u16 pre_press = 0;
++
++        input_report_abs(ts->idev, ABS_X, x & 0xfff);
++        input_report_abs(ts->idev, ABS_Y, y & 0xfff);
++        if (pressure == pre_press){
++                pressure--;
++        }
++        pre_press = pressure;
++        input_report_abs(ts->idev, ABS_PRESSURE, pressure & 0xfff);
++	input_sync(ts->idev);
++#ifdef CONFIG_IPM
++	ipm_event_notify(IPM_EVENT_UI, IPM_EVENT_DEVICE_TSI, NULL, 0);
++#endif
++        return 0;
++}
++
++/*
++ * add a pen up event
++ */
++static void codec_zy_ts_evt_release(codec_zy_ts_t* ts)
++{
++	input_report_abs(ts->idev, ABS_PRESSURE, 0);
++	input_sync(ts->idev);
++
++#ifdef CONFIG_IPM
++	ipm_event_notify(IPM_EVENT_UI, IPM_EVENT_DEVICE_TSI, NULL, 0);
++#endif
++	p_zy_codec_ctxt->g_pfn_event_ack(p_zy_codec_ctxt,ZY_EVENT_TYPE_PDN);
++}
++
++/*
++ * Kill the touchscreen thread and stop
++ * the touch digitiser.
++ */
++static void codec_zy_ts_input_close(struct input_dev *idev)
++{
++	codec_zy_ts_t *ts = (codec_zy_ts_t *) &codec_zy_ts;
++
++#ifdef CONFIG_PM
++	if(touch_suspend){
++		pr_info("touch is suspended!\n");
++		return -1;
++	}
++#endif
++	dbg("close ts input!\n");
++	if (--ts->use_count == 0) {
++		del_timer(ts->timer);
++		if (ts->timer != NULL)
++			kfree(ts->timer);
++		p_zy_codec_ctxt->g_pfn_disable_touch(p_zy_codec_ctxt);
++	}
++}
++
++/*
++ * Sample the touchscreen
++ */
++int ac97_poll_touch(codec_zy_ts_t *ts)
++{
++	unsigned short x=0, y=0;
++	int if_down= 0;
++	zy_acodec_error_t status = ZY_ACODEC_SUCCESS;
++
++#ifdef DEBUG
++        start_time = OSCR;
++#endif
++
++	/* get x value */
++	status = zy_acodec_get_adc_sample(p_zy_codec_ctxt, &x, ZY_TOUCH_SAMPLE_X, &if_down);
++	if (ZY_ACODEC_SUCCESS != status ){
++		return -EIO;
++	}
++	dbg("x:0x%x\n", x);
++
++	/* the pen is up */
++	if (1 != if_down){
++		return PEN_UP;
++	}
++
++	/* get y vaule */
++	status = zy_acodec_get_adc_sample(p_zy_codec_ctxt, &y, ZY_TOUCH_SAMPLE_Y, &if_down);
++	if (ZY_ACODEC_SUCCESS != status ){
++		return -EIO;
++	}
++	dbg("y:0x%x\n",y);
++
++	/* the pen is up */
++	if (1 != if_down){
++		return PEN_UP;
++	}
++
++	/* the pen is down, can not get the pressure value,
++	 * so if pen is down, give the max pressure value
++	 */
++	codec_zy_ts_evt_add(ts,0xfff, x, y);
++
++#ifdef DEBUG
++        end_time = OSCR;
++        PRINT_TIME();
++#endif
++
++	return PEN_DOWN;
++}
++
++static void touch_timer_handler(unsigned long unused)
++{
++	int event;
++	codec_zy_ts_t *ts = &codec_zy_ts;
++
++	event = ac97_poll_touch(ts);
++
++	if (event == PEN_DOWN) {
++		dbg("pen down!\n");
++		ts->timer->expires = jiffies + TS_SAMPLE_INTERVAL;
++		add_timer(ts->timer);
++	} else if(event == PEN_UP) {
++		dbg("pen up!\n");
++		codec_zy_ts_evt_release(ts);
++	} else if(event == -EIO) {
++		printk(KERN_ERR "Access touch interface error!\n");
++	}
++	return;
++}
++
++static zy_acodec_error_t  zy_ac97_acodec_cold_reset(zy_acocec_context_t * p_ac97_ctxt)
++{
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	p_zy_ac97acodec_t p_ac97 = (p_zy_ac97acodec_t)(p_ac97_ctxt->p_ctrl_reg);
++	int		 pri_codec_ready;
++	unsigned long		time_remaining;
++
++	p_ac97->gcr = 0;
++	p_ac97->gcr |= ZY_AC97_GCR_CLKBPB_MSK;
++	/*  Hold reset active for a minimum time */
++	udelay(ZY_AC97_COLD_HOLDTIME);
++	p_ac97->gcr &= ~ZY_AC97_GCR_CLKBPB_MSK;
++
++	/*  Deactivate cold reset condition */
++	p_ac97->gcr |= (ZY_AC97_GCR_COLD_RESET_MSK | ZY_AC97_GCR_WARM_RESET_MSK);
++
++
++	pri_codec_ready = 0;
++	time_remaining = (p_ac97_ctxt->u_max_setup_time_out_ms) * 10;
++	do
++	{
++		udelay(1);
++		if (p_ac97->gsr & ZY_AC97_GSR_PCRDY_MSK)
++			pri_codec_ready = 1;
++	}
++	while (time_remaining-- && (pri_codec_ready == 0));
++
++	/*  Timeout status if some of the devices weren't ready. */
++	if (pri_codec_ready == 0)
++	{
++		status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++	}
++
++	return (status);
++}
++
++
++zy_acodec_error_t  zy_ac97_acodec_init(zy_acocec_context_t *p_ac97_ctxt)
++{
++	zy_acodec_error_t	status ;
++
++	status = zy_ac97_acodec_cold_reset(p_ac97_ctxt);
++
++	return (status);
++}
++
++
++/*
++ * Start the touchscreen thread and
++ * the touch digitiser.
++ */
++static int codec_zy_ts_input_open(struct input_dev *idev)
++{
++	codec_zy_ts_t *ts = (codec_zy_ts_t *) &codec_zy_ts;
++
++#ifdef CONFIG_PM
++	if(touch_suspend){
++		pr_info("touch is suspended!\n");
++		return -1;
++	}
++#endif
++
++	if (ts->use_count++ > 0)
++		return 0;
++
++	dbg("Touch is opened. Use count: %d\n", ts->use_count);
++	ts->idev = idev;
++	ts->timer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
++	if (!ts->timer) {
++		printk(KERN_ERR "Alloc memory error for timer!\n");
++		return -ENOMEM;
++	}
++
++	init_timer(ts->timer);
++	ts->timer->function = touch_timer_handler;
++	ts->timer->data = 0;
++	p_zy_codec_ctxt->g_pfn_enable_touch(p_zy_codec_ctxt);
++
++	return 0;
++}
++
++/*
++ * initilze the pxa touch screen
++ */
++static int alsa_ts_init( void )
++{
++	codec_zy_ts_t* ts = &codec_zy_ts;
++
++	memset(ts, 0, sizeof(codec_zy_ts_t));
++
++	codec_zy_ts_input = input_allocate_device();
++	if (!codec_zy_ts_input)
++		return -ENOMEM;
++
++
++	/* tell input system what we events we accept and register */
++	codec_zy_ts_input->name = "codec zy touchscreen";
++	codec_zy_ts_input->open = codec_zy_ts_input_open;
++	codec_zy_ts_input->close = codec_zy_ts_input_close;
++	__set_bit(EV_ABS, codec_zy_ts_input->evbit);
++	__set_bit(ABS_X, codec_zy_ts_input->absbit);
++	__set_bit(ABS_Y, codec_zy_ts_input->absbit);
++	__set_bit(ABS_PRESSURE, codec_zy_ts_input->absbit);
++	input_register_device(codec_zy_ts_input);
++
++	return 0;
++}
++
++static irqreturn_t pxa_touch_irq(int irq, void *dev)
++{
++	unsigned char event_type;
++
++	//printk(KERN_ERR "%s: enter codec event handler\n", __FUNCTION__);
++
++	dbg("%s: enter codec event handler\n", __FUNCTION__);
++	p_zy_codec_ctxt->g_pfn_get_event(p_zy_codec_ctxt, &event_type);
++	switch (event_type) {
++		case ZY_EVENT_TYPE_PDN:
++		{
++			codec_zy_ts_t *ts = &codec_zy_ts;
++			/*if the touch is not open need not acknowledge the event*/
++			if (ts->use_count <= 0)
++				break;
++			ts->timer->expires = jiffies + TS_SAMPLE_INTERVAL;
++			add_timer(ts->timer);
++			break;
++		}
++		default:
++			printk("unsupported codec event:0x%x\n", event_type);
++	}
++
++	return IRQ_HANDLED;
++}
++
++
++
++
++
++
++
++
++
++static mfp_cfg_t extra_cfg[] = {
++	MFP_CFG_X(GPIO17, AF3, DS03X, PULL_LOW),
++	MFP_CFG_X(GPIO25, AF0, DS01X, PULL_LOW),
++};
++
++#define ARRAY_AND_SIZE(x)	(x), ARRAY_SIZE(x)
++
++extern void dump_mfp(void);
++
++zy_acodec_error_t	zy_ac97_acodec_mfp_init(zy_acocec_context_t *p_device_context)
++{
++	unsigned short codec_id;
++
++	//mhn_mfp_set_afds(MFP_RSVD_AC97_SDATA_IN_0, MFP_AF0, MFP_DS03X);
++	//enable_ac97_pins();
++	zy_ac97_acodec_init(p_device_context);
++    	if (zy_ac97_acodec_read(p_device_context, 0x0, &codec_id)){
++
++		/*
++		 * there is a bug on MonahansL/MonhansPL PC card: AC97_SDATA_IN is not connected to CODEC
++		 * ECO 72: Connect PWM_0(MFP_RSVD_AC97_SDATA_IN_0) to CODEC as AC97_SDATA_IN
++		 */
++
++		//mhn_mfp_set_afds(MFP_RSVD_AC97_SDATA_IN_0, MFP_RSVD_AC97_SDATA_IN_0_AF, MFP_DS03X);
++		//mhn_mfp_set_afds(MFP_AC97_SDATA_IN_0, MFP_AF0, MFP_DS01X);
++
++		gpio_direction_output(mfp_to_gpio(MFP_PIN_GPIO17), 0);
++		pxa3xx_mfp_config(ARRAY_AND_SIZE(extra_cfg));
++		gpio_direction_input(mfp_to_gpio(MFP_PIN_GPIO25));
++	}
++
++
++	return ZY_ACODEC_SUCCESS;
++}
++
++#define ZY_AC97_WM9713_GPIO_PIN_PDN ( 0x1 << 13 )  /* Pen down */
++
++/*power enable bit in 3ch and 3eh */
++/*3ch */
++#define ZY_AC97_9713_PWR_PADCPD   ( 0x1 << 15 )
++#define ZY_AC97_9713_PWR_VMID     ( 0x1 << 14 )
++#define ZY_AC97_9713_PWR_TSHUT    ( 0x1 << 13 )
++#define ZY_AC97_9713_PWR_VXDAC    ( 0x1 << 12 )
++#define ZY_AC97_9713_PWR_AUXDAC   ( 0x1 << 11 )
++#define ZY_AC97_9713_PWR_MBIAS    ( 0x1 << 10 )
++#define ZY_AC97_9713_PWR_PLL      ( 0x1 << 9 )
++#define ZY_AC97_9713_PWR_DACL     ( 0x1 << 7 )
++#define ZY_AC97_9713_PWR_DACR     ( 0x1 << 6 )
++#define ZY_AC97_9713_PWR_ADCL     ( 0x1 << 5 )
++#define ZY_AC97_9713_PWR_ADCR     ( 0x1 << 4 )
++#define ZY_AC97_9713_PWR_HPLX     ( 0x1 << 3 )
++#define ZY_AC97_9713_PWR_HPRX     ( 0x1 << 2 )
++#define ZY_AC97_9713_PWR_SPKX     ( 0x1 << 1 )
++#define ZY_AC97_9713_PWR_MX       ( 0x1 << 0 )
++
++/*3EH */
++#define ZY_AC97_9713_PWR_MCD      ( 0x1 << 15 )
++#define ZY_AC97_9713_PWR_MICBIAS  ( 0x1 << 14 )
++#define ZY_AC97_9713_PWR_MONO     ( 0x1 << 13 )
++#define ZY_AC97_9713_PWR_OUT4     ( 0x1 << 12 )
++#define ZY_AC97_9713_PWR_OUT3     ( 0x1 << 11 )
++#define ZY_AC97_9713_PWR_HPL      ( 0x1 << 10 )
++#define ZY_AC97_9713_PWR_HPR      ( 0x1 << 9 )
++#define ZY_AC97_9713_PWR_SPKL     ( 0x1 << 8 )
++#define ZY_AC97_9713_PWR_SPKR     ( 0x1 << 7 )
++#define ZY_AC97_9713_PWR_LL       ( 0x1 << 6 )
++#define ZY_AC97_9713_PWR_LR       ( 0x1 << 5 )
++#define ZY_AC97_9713_PWR_MOIN     ( 0x1 << 4 )
++#define ZY_AC97_9713_PWR_MA       ( 0x1 << 3 )
++#define ZY_AC97_9713_PWR_MB       ( 0x1 << 2 )
++#define ZY_AC97_9713_PWR_MPA      ( 0x1 << 1 )
++#define ZY_AC97_9713_PWR_MPB      ( 0x1 << 0 )
++
++
++void zy_wm9713_get_event(zy_acocec_context_t *p_device_context, unsigned char * event_type)
++{
++	unsigned short event_state = 0;
++	zy_ac97_acodec_read(p_device_context, GPIO_PIN_STATUS, &event_state);
++	if(event_state & ZY_AC97_WM9713_GPIO_PIN_PDN){
++		*event_type = ZY_EVENT_TYPE_PDN;
++		return;
++	}
++	return;
++}
++
++void zy_wm9713_event_ack(zy_acocec_context_t *p_device_context, unsigned char event_type)
++{
++	unsigned short event_state = 0;
++	zy_ac97_acodec_read(p_device_context, GPIO_PIN_STATUS, &event_state);
++	if( event_type == ZY_EVENT_TYPE_PDN){
++		zy_ac97_acodec_write(p_device_context,
++					GPIO_PIN_STATUS,
++					(event_state & (~ZY_AC97_WM9713_GPIO_PIN_PDN)));
++	}
++
++	zy_ac97_acodec_read(p_device_context, GPIO_PIN_STATUS, &event_state);
++	return;
++}
++
++static void * p_saved_memory = NULL;
++static void * p_zy_scenario = NULL;
++static p_zy_acocec_context_t p_zy_ctxt = NULL;
++
++#define WM9713_SAVE_REGISTER_NO (64-11)
++typedef struct {
++    unsigned short wm9713RegisterContext [WM9713_SAVE_REGISTER_NO + 1]; /* Fixed (data misalignment error) */
++}ZY_9713_CONTEXT_SAVE_T;
++
++
++/**
++ * alsa_prepare_for_zy - create and initialize the p_zy_acocec_context_t
++ * 				   open the clock of data link
++ * @p_p_zy_ctxt: return the data structure p_zy_acocec_context_t
++ * return: 0 success ; -ENOMEM
++ **/
++int alsa_prepare_for_zy(p_zy_acocec_context_t * p_p_zy_ctxt)
++{
++	if (p_zy_ctxt) {
++		p_zy_ctxt->use_count++;
++		*p_p_zy_ctxt = p_zy_ctxt;
++		return 0;
++	}
++
++	p_zy_ctxt = kzalloc(sizeof(zy_acocec_context_t), GFP_KERNEL);
++	if (!p_zy_ctxt)
++		return -ENOMEM;
++
++	/* enable CLK_POUT as CODEC clock input */
++	OSCC |= 0x800;
++
++	p_saved_memory = kzalloc(sizeof(ZY_9713_CONTEXT_SAVE_T) +
++				sizeof(zy_ac97_save_context_t), GFP_KERNEL);
++	if (NULL == p_saved_memory) {
++		if (p_zy_ctxt)
++			kfree(p_zy_ctxt);
++		return -ENOMEM;
++	}
++
++	p_zy_ctxt->acodec_id = (zy_acodec_device_id_t) (WM_9713_ID);
++	p_zy_ctxt->use_count++;
++	/*
++	p_zy_ctxt->pMfpRegBase = (unsigned long) (MFP_BASE);
++	p_zy_ctxt->pMfpRmDb = ZY_MFP_RM_DATABASE;
++	p_zy_ctxt->p_ost_regs = OST_BASE;
++	*/
++	p_zy_ctxt->p_voice_reg = NULL;
++	p_zy_ctxt->p_hifi_reg = (void *) (&POCR);
++	p_zy_ctxt->p_ctrl_reg = (void *) (&POCR);
++	p_zy_ctxt->u_max_read_write_time_out_ms = ZY_AC97_RW_TIMEOUT_DEF;
++	p_zy_ctxt->u_max_setup_time_out_ms = ZY_AC97_SETUP_TIMEOUT_DEF;
++	p_zy_ctxt->p_save_memory = p_saved_memory;
++	p_zy_ctxt->p_zy_scenario = p_zy_scenario;
++//	pxa_set_cken(24, 1);
++	CKENA |= (1 << 24);
++	AC97_DIV = 1625<<12 | 128;
++#ifdef DEBUG_ALSA_ZY
++	debug_pac97ctxt = p_zy_ctxt;
++	misc_register(&audio_dev);
++#endif
++
++	(*p_p_zy_ctxt) = p_zy_ctxt;
++
++	return 0;
++}
++
++
++/* this is platform specific */
++/* do later: not to enable recording route and playback route in this function,
++ * leave it to driver to call other function
++ */
++zy_acodec_error_t zy_wm9713_specific_init (zy_acocec_context_t *p_device_context)
++{
++
++	unsigned short value;
++
++	/* this assumes that the aclink is initialized wait some time and then
++	 * do a warm reset to enabled the ACLINK, required for wm9713
++	 * (not wm9712 or ucb1400)
++	 */
++
++	/* pay attention: whether the workaround is still needed? */
++	p_zy_ac97acodec_t p_ac97_reg = (p_zy_ac97acodec_t)(p_device_context->p_ctrl_reg);
++
++	p_ac97_reg->gcr |= ZY_AC97_GCR_WARM_RESET_MSK;
++
++	mdelay(5);
++
++	/* power on all the necessary unit */
++	zy_ac97_acodec_write(p_device_context,POWERDOWN_CTRL_STAT, 0x000);	/*26*/
++	/* open left headphone mixer */
++	/* open right headphone mixer */
++	/* open right/left dac */
++	/* open right/left adc */
++	/* open temperature sensor */
++	/* enable reference generator */
++	zy_ac97_acodec_write(p_device_context,POWER_DOWN_1, 0xda00);		/*3c */
++	/* open microphone bias */
++	/* open HPL output PGA */
++	/* open HPR output PGA */
++	/* open mic PGA MA */
++	/* open mic pre-amp MPA */
++	/* if here we enable SPKL and SPKR PGA, then Touch screen will doesn't work */
++	zy_ac97_acodec_write(p_device_context,POWER_DOWN_2,0xb9f5);   /*3e */
++
++	/* recording route and microphone input */
++	/* microphone selection, now fixed to MIC1 input and mic bias output */
++	/* MIC1 only, MICBIAS enable */
++	zy_ac97_acodec_write (p_device_context, MIC_BIAS, 0xC440);	/*0x22h*/
++
++	/* mic pga setting to mixer (side tone) */
++	/* comment the below code to make MICA/B play back volume gain + 0db */
++	/* zy_ac97_acodec_write (p_device_context, MIC_PGA_VOLUME, 0x0000); */	/*0x0eh*/
++
++	/* recording side tone and ADC boost, now fixed to default (14h) */
++	/* recording volume  0dB */
++	zy_ac97_acodec_write(p_device_context, REC_PGA_VOL, 0x0); /*12*/
++
++	/* hifi playback route and output mixer	 */
++	/* by default, fixed to enable headphone only */
++
++	/* comment the below code to make SPEAKER default MUTE */
++	zy_ac97_acodec_write (p_device_context, SPEAKER_VOLUME, 0x0);		/*02*/
++
++	/* comment the below code to make OUT3_OUT4 default MUTE */
++	/* zy_ac97_acodec_write (p_device_context, OUT3_OUT4_VOLUME, 0x8000); */	/*06*/
++
++	/* remove all  the mute bit  volume gain + 0db  */
++	zy_ac97_acodec_write(p_device_context, HEADPHONE_VOLUME, 0x0);	/*04*/
++
++	/* DAC route */
++	/* open DAC to headphone mixer path */
++	/* left DAC gain +0db */
++	/* right DAC gain +0db */
++	zy_ac97_acodec_write(p_device_context, DAC_PGA_VOL_ROUTE,0x0808);	/*0c*/
++
++	/* out3 configure, invert to HPMIXR */
++	/* zy_ac97_acodec_write(p_device_context,DAC_3D_CTRL_INV_MUX_SEL, 0x8000); */	/*1e*/
++
++	/* output control */
++	 /* select HPMIXR HPMIXL out */
++	 /* other out are all VIM */
++	zy_ac97_acodec_write(p_device_context,OUTPUT_PGA_MUX, 0x9BA8);		/*1c*/
++
++	/* set sample rates */
++	/* enable variable rate conversion */
++	zy_ac97_acodec_write(p_device_context, EXTENDED_AUD_STAT_CTRL , 0x1); /*2a*/
++	/*  DAC 44kHZ */
++	zy_ac97_acodec_write(p_device_context,AUDIO_DAC_RATE,0xac44); /*2c*/
++	/*  ADC 16KHZ */
++	zy_ac97_acodec_write(p_device_context,AUDIO_ADC_RATE,0x3E80); /*32*/
++
++	/* clock scheme, use external clock, it is 24MHZ from MCLK_A */
++
++
++	zy_ac97_acodec_read(p_device_context, MCLK_PLL_CTRL_1, &value);
++	zy_ac97_acodec_write(p_device_context, MCLK_PLL_CTRL_1, value | 0x2);
++
++	return ZY_ACODEC_SUCCESS;
++}
++
++zy_acodec_error_t zy_wm9713_specific_deinit (zy_acocec_context_t *p_device_context)
++{/* do later: shut down all power */
++	unsigned short value = 0;
++
++	/* close the power of all units */
++	zy_ac97_acodec_write(p_device_context, POWER_DOWN_1, 0xffff);
++	zy_ac97_acodec_write(p_device_context, POWER_DOWN_2, 0xffff);
++	zy_ac97_acodec_read(p_device_context, POWER_DOWN_1, &value);
++ 	value &= ~(ZY_AC97_9713_PWR_MBIAS);
++	zy_ac97_acodec_write(p_device_context, POWER_DOWN_1, value);
++
++	return ZY_ACODEC_SUCCESS;
++}
++
++zy_acodec_error_t zy_acodec_set_pen_down_interrupt(zy_acocec_context_t *p_device_context, int enable)
++{/* disable/enable pen down interrupt in the codec. This function is not implemented for Wm9713 */
++	/* because the pen down detection could not be disabled in codec */
++	return ZY_ACODEC_SUCCESS;
++}
++
++zy_acodec_error_t zy_wm9713_enable_touch(zy_acocec_context_t *p_device_context)
++{/* enable touch functionality in the codec */
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	unsigned short value;
++
++	/* power setting */
++	status = zy_ac97_acodec_read(p_device_context, POWER_DOWN_1, &value);
++	value &= ~(ZY_AC97_9713_PWR_PADCPD);
++	status = zy_ac97_acodec_write(p_device_context, POWER_DOWN_1, value);
++
++	/* basic touch setting	 */
++	status = zy_ac97_acodec_write(p_device_context, DIGITIZER_3_WM13, 0xc008);
++	status = zy_ac97_acodec_write(p_device_context, DIGITIZER_2_WM13, 0x6);
++
++
++	/* 9713 powerdown virtual gpio setting (polarity, sticky, wakeup) */
++	/* 9713 gpio 2(pin45) route to IRQ */
++	/*  Notes: Can use defaults for IRQ polarity, PENDOWN polarity in IRQ, */
++	/*   sticky for PENDOWN in IRQ and wakeup for PENDOWN.	 */
++	status = zy_ac97_acodec_read(p_device_context, GPIO_PIN_CFG, &value);
++	value &= ~(0x4);
++	status = zy_ac97_acodec_write(p_device_context, GPIO_PIN_CFG, value);
++
++	status = zy_ac97_acodec_read(p_device_context, GPIO_PIN_SHARING, &value);
++	value &= ~(0x4);
++	status = zy_ac97_acodec_write(p_device_context, GPIO_PIN_SHARING, value);
++
++	status = zy_ac97_acodec_read(p_device_context, GPIO_PIN_WAKEUP, &value);
++	value |= (0x2000);
++	status = zy_ac97_acodec_write(p_device_context, GPIO_PIN_WAKEUP, value);
++
++	status = zy_ac97_acodec_read(p_device_context, GPIO_PIN_STICKY, &value);
++	value |= (0x2000);
++	status = zy_ac97_acodec_write(p_device_context, GPIO_PIN_STICKY, value);
++
++	return status;
++}
++
++zy_acodec_error_t zy_wm9713_disable_touch(zy_acocec_context_t *p_device_context)
++{/* disable touch functionality in the codec */
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	unsigned short value;
++
++	/* power setting */
++	status = zy_ac97_acodec_read(p_device_context, POWER_DOWN_1, &value);
++	value |= (ZY_AC97_9713_PWR_PADCPD);
++	status = zy_ac97_acodec_write(p_device_context, POWER_DOWN_1, value);
++
++	return status;
++}
++zy_acodec_error_t	zy_ac97_acodec_mfp_deinit(zy_acocec_context_t *p_device_context)
++{/* do later: free all MFP resources. */
++    return ZY_ACODEC_SUCCESS;
++}
++
++static zy_acodec_error_t  zy_ac97_acodec_shut_down_aclink(p_zy_ac97acodec_t p_ac97_reg, int * p_ost_regs)
++{
++	zy_acodec_error_t	status = ZY_ACODEC_SUCCESS;
++	unsigned long time_remaining = ZY_AC97_LINKOFF_TIMEOUT_DEF;
++
++	p_ac97_reg->gcr |= ZY_AC97_GCR_LINK_OFF_MSK;
++	p_ac97_reg->gcr |= ZY_AC97_GCR_CLKBPB_MSK;
++
++	while (!(p_ac97_reg->gsr & ZY_AC97_GSR_ACOFFD_MSK))
++	{
++		time_remaining --;
++		if (0 == time_remaining)
++		{
++			status = ZY_ACODEC_CONTROLLER_INTERFACE_TIMEOUT;
++			break;
++		}
++		udelay(1);
++	}
++	p_ac97_reg->gcr |= ZY_AC97_GCR_FRCRST_MSK;
++	/* check later: any delay needed */
++	p_ac97_reg->gcr &= ~ZY_AC97_GCR_FRCRST_MSK;
++	p_ac97_reg->gcr &= ~ZY_AC97_GCR_CLKBPB_MSK;
++
++	return(status);
++}
++
++
++zy_acodec_error_t  zy_ac97_acodec_deinit(zy_acocec_context_t * p_ac97_ctxt)
++{
++	zy_acodec_error_t	status ;
++
++	status = zy_ac97_acodec_shut_down_aclink((p_zy_ac97acodec_t)(p_ac97_ctxt->p_ctrl_reg), p_ac97_ctxt->p_ost_regs);
++
++	return (status);
++}
++
++zy_acodec_error_t zy_acodec_deinit(zy_acocec_context_t *p_device_context)
++{
++	/* power down codec by codec specific power down function */
++	if (p_device_context->g_pfn_codec_specific_dinit)
++	{
++		p_device_context->g_pfn_codec_specific_dinit(p_device_context);
++	}
++	/* call bus deinit function */
++	zy_ac97_acodec_deinit(p_device_context);
++	/* restore MFP, set GPIO to suitable value */
++	zy_ac97_acodec_mfp_deinit(p_device_context);
++
++	return ZY_ACODEC_SUCCESS;
++}
++
++void alsa_zy_codec_put(p_zy_acocec_context_t p_acodectxt)
++{
++
++	zy_acodec_deinit(p_acodectxt);
++	//pxa_set_cken(24, 0);
++	CKENA &= ~(1 << 24);
++
++	if(p_acodectxt->p_save_memory){
++		kfree(p_saved_memory);
++	}
++	if(p_acodectxt->p_zy_scenario){
++		kfree(p_zy_scenario);
++	}
++}
++
++
++zy_acodec_error_t zy_acodec_init(zy_acocec_context_t *p_device_context, int hw_init)
++{
++	/* set codec specific functions
++	 * set mfp for Zylonite platform
++	 * call bus init function (AC97, I2S, I2C, SSP)
++	 * call specific init of codec
++	 */
++	zy_acodec_error_t retval = ZY_ACODEC_SUCCESS;
++
++	if (p_device_context->acodec_id != WM_9713_ID)
++	{/* on Zylonite, it is Wolfson 9713 codec only */
++		return ZY_ACODEC_GENERAL_SW_ERR;
++	}
++
++	if (1 == hw_init)
++	{
++		zy_ac97_acodec_mfp_init(p_device_context);
++		zy_ac97_acodec_init(p_device_context);  /* codec init common to ac97 */
++	}
++
++	/* wm9713-specific functions */
++	(p_device_context->g_pfn_codec_specific_init)	= zy_wm9713_specific_init;
++	(p_device_context->g_pfn_codec_specific_dinit)  = zy_wm9713_specific_deinit;
++	(p_device_context->g_pfn_acodec_read)		= zy_ac97_acodec_read;
++	(p_device_context->g_pfn_acodec_write)		= zy_ac97_acodec_write;
++
++	(p_device_context->g_pfn_event_ack)    = zy_wm9713_event_ack;
++	(p_device_context->g_pfn_get_event)    = zy_wm9713_get_event;
++	(p_device_context->g_pfn_disable_touch)        = zy_wm9713_disable_touch;
++	(p_device_context->g_pfn_enable_touch) = zy_wm9713_enable_touch;
++
++	if (1 == hw_init)
++	{
++		retval = p_device_context->g_pfn_codec_specific_init(p_device_context);
++	}
++
++	return retval;
++}
++
++static int __devinit touch_codec_zy_probe(struct platform_device *dev)
++{
++	int ret = 0;
++	struct snd_card *card = NULL;
++	zy_acodec_error_t status;
++
++	/* will increase codec context use count */
++	ret = alsa_prepare_for_zy(&p_zy_codec_ctxt);
++	if (ret)
++		goto err;
++
++	/* codec specific initialization, audio will do it either */
++	if (1 == p_zy_codec_ctxt->use_count) {
++		status = zy_acodec_init(p_zy_codec_ctxt, 1);
++		if (ZY_ACODEC_SUCCESS != status) {
++			printk(KERN_ERR "initialize codec error\n");
++			ret = -EIO;
++			goto err;
++		}
++
++	/* power down the units of the acodec, sleep the acodec, zy_acodec_init()
++	 * will open all the units' power of the codec while ALSA need all the codec
++	 * units power down and the codec should sleep if it can.
++	 * So on the zylonite platform we call below function to power down and sleep
++	 * wm9713 codec.
++	 */
++	p_zy_codec_ctxt->g_pfn_codec_specific_dinit(p_zy_codec_ctxt);
++
++	}
++
++	alsa_ts_init();
++
++	//mhn_mfp_set_afds(MFP_AC97_INT_N_GPIO,0,0);
++	//mhn_gpio_set_direction(MFP_AC97_INT_N_GPIO, GPIO_DIR_IN);
++	//mhn_gpio_clear_edge_detect_status(MFP_AC97_INT_N_GPIO);
++	gpio_direction_input(mfp_to_gpio(MFP_PIN_GPIO26));
++	ret = request_irq(IRQ_GPIO(mfp_to_gpio(MFP_PIN_GPIO26)),
++			pxa_touch_irq, IRQF_TRIGGER_RISING,
++			"wm9713 touch event interrupt", NULL);
++	if (ret) {
++		printk(KERN_ERR "Request IRQ for touch failed (%d).\n", ret);
++		goto err;
++	}
++
++	return 0;
++err:
++	if (p_zy_codec_ctxt && (!--p_zy_codec_ctxt->use_count)) {
++		zy_acodec_deinit(p_zy_codec_ctxt);
++		//pxa_set_cken(24, 0);
++		CKENA &= ~(1 << 24);
++		kfree(p_zy_codec_ctxt);
++		p_zy_codec_ctxt = NULL;
++	}
++
++	if (card)
++		snd_card_free(card);
++
++	return ret;
++}
++
++static int __devexit touch_codec_zy_remove(struct platform_device *dev)
++{
++	struct snd_card *card = platform_get_drvdata(dev);
++
++	input_unregister_device(codec_zy_ts_input);
++
++	if (p_zy_codec_ctxt && (!--p_zy_codec_ctxt->use_count)) {
++		alsa_zy_codec_put(p_zy_codec_ctxt);
++		kfree(p_zy_codec_ctxt);
++		p_zy_codec_ctxt = NULL;
++	}
++
++	if (card) {
++		snd_card_free(card);
++		platform_set_drvdata(dev, NULL);
++	}
++
++	return 0;
++}
++
++#ifdef CONFIG_PM
++static int touch_codec_zy_suspend(struct platform_device *_dev, pm_message_t state, u32 level)
++{
++	int ret=0;
++	
++	if (level == SUSPEND_DISABLE) {
++		ret = audio_codec_zy_do_suspend(NULL, SNDRV_CTL_POWER_D3cold, p_zy_codec_ctxt);
++		touch_suspend = 1;
++	}
++	return ret;
++}
++
++static int touch_codec_zy_resume(struct platform_device *_dev, u32 level)
++{
++	int ret = 0;
++	
++	if (level == RESUME_ENABLE) {
++		ret = audio_codec_zy_do_resume(NULL, SNDRV_CTL_POWER_D0, p_zy_codec_ctxt);
++		touch_suspend = 0;
++	}
++	return ret;
++}
++#else
++#define touch_codec_zy_suspend	NULL
++#define touch_codec_zy_resume	NULL
++#endif
++
++static struct platform_driver touch_codec_zy_driver = {
++	.probe 	= 	touch_codec_zy_probe,
++	.remove = 	__devexit_p(touch_codec_zy_remove),
++	.suspend= 	touch_codec_zy_suspend,
++	.resume = 	touch_codec_zy_resume,
++	.driver = {
++		.name 	= 	"pxa2xx-touch",
++	},
++};
++
++static int __init touch_codec_zy_init(void)
++{
++	return platform_driver_register(&touch_codec_zy_driver);
++}
++
++static void __exit touch_code_zy_exit(void)
++{
++	platform_driver_unregister(&touch_codec_zy_driver);
++}
++module_init(touch_codec_zy_init);
++module_exit(touch_code_zy_exit);
++
++EXPORT_SYMBOL(p_zy_codec_ctxt);
++
++MODULE_AUTHOR("bridge.wu@marvell.com");
++MODULE_DESCRIPTION("zylonite audio touch codec driver on ALSA");
++MODULE_LICENSE("GPL");
++