/*
* Irda
*/
static void corgi_irda_transceiver_mode(struct device *dev, int mode)
{
if (mode & IR_OFF)
GPSR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
else
GPCR(CORGI_GPIO_IR_ON) = GPIO_bit(CORGI_GPIO_IR_ON);
}
int pxa_gpio_mode(int gpio_mode)
{
unsigned long flags;
int gpio = gpio_mode & GPIO_MD_MASK_NR;
int fn = (gpio_mode & GPIO_MD_MASK_FN) >> 8;
int gafr;
if (gpio > pxa_last_gpio)
return -EINVAL;
local_irq_save(flags);
if (gpio_mode & GPIO_DFLT_LOW)
GPCR(gpio) = GPIO_bit(gpio);
else if (gpio_mode & GPIO_DFLT_HIGH)
GPSR(gpio) = GPIO_bit(gpio);
if (gpio_mode & GPIO_MD_MASK_DIR)
GPDR(gpio) |= GPIO_bit(gpio);
else
GPDR(gpio) &= ~GPIO_bit(gpio);
gafr = GAFR(gpio) & ~(0x3 << (((gpio) & 0xf)*2));
GAFR(gpio) = gafr | (fn << (((gpio) & 0xf)*2));
local_irq_restore(flags);
return 0;
}
static int spitz_should_wakeup(unsigned int resume_on_alarm)
{
int is_resume = 0;
int acin = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
if (spitz_last_ac_status != acin) {
if (acin) {
/* charge on */
sharpsl_pm.flags |= SHARPSL_DO_OFFLINE_CHRG;
dev_dbg(sharpsl_pm.dev, "AC Inserted\n");
} else {
/* charge off */
dev_dbg(sharpsl_pm.dev, "AC Removed\n");
sharpsl_pm_led(SHARPSL_LED_OFF);
sharpsl_pm.machinfo->charge(0);
sharpsl_pm.charge_mode = CHRG_OFF;
}
spitz_last_ac_status = acin;
/* Return to suspend as this must be what we were woken for */
return 0;
}
if (PEDR & GPIO_bit(SPITZ_GPIO_KEY_INT))
is_resume |= GPIO_bit(SPITZ_GPIO_KEY_INT);
if (PKSR & GPIO_bit(SPITZ_GPIO_SYNC))
is_resume |= GPIO_bit(SPITZ_GPIO_SYNC);
if (resume_on_alarm && (PEDR & PWER_RTC))
is_resume |= PWER_RTC;
dev_dbg(sharpsl_pm.dev, "is_resume: %x\n",is_resume);
return is_resume;
}
static int pxa2xx_mfp_suspend(struct sys_device *d, pm_message_t state)
{
int i;
/* set corresponding PGSR bit of those marked MFP_LPM_KEEP_OUTPUT */
for (i = 0; i < pxa_last_gpio; i++) {
if ((gpio_desc[i].config & MFP_LPM_KEEP_OUTPUT) &&
(GPDR(i) & GPIO_bit(i))) {
if (GPLR(i) & GPIO_bit(i))
PGSR(i) |= GPIO_bit(i);
else
PGSR(i) &= ~GPIO_bit(i);
}
}
for (i = 0; i <= gpio_to_bank(pxa_last_gpio); i++) {
saved_gafr[0][i] = GAFR_L(i);
saved_gafr[1][i] = GAFR_U(i);
saved_gpdr[i] = GPDR(i * 32);
saved_pgsr[i] = PGSR(i);
GPDR(i * 32) = gpdr_lpm[i];
}
return 0;
}
static int palmtx_pcmcia_hw_init (struct soc_pcmcia_socket *skt)
{
GPSR(GPIO48_nPOE_MD) = GPIO_bit(GPIO48_nPOE_MD) |
GPIO_bit(GPIO49_nPWE_MD) |
GPIO_bit(GPIO50_nPIOR_MD) |
GPIO_bit(GPIO51_nPIOW_MD) |
GPIO_bit(GPIO85_nPCE_1_MD) |
GPIO_bit(GPIO53_nPCE_2_MD) |
GPIO_bit(GPIO54_pSKTSEL_MD) |
GPIO_bit(GPIO55_nPREG_MD) |
GPIO_bit(GPIO56_nPWAIT_MD) |
GPIO_bit(GPIO57_nIOIS16_MD);
pxa_gpio_mode(GPIO48_nPOE_MD);
pxa_gpio_mode(GPIO49_nPWE_MD);
pxa_gpio_mode(GPIO50_nPIOR_MD);
pxa_gpio_mode(GPIO51_nPIOW_MD);
pxa_gpio_mode(GPIO85_nPCE_1_MD);
pxa_gpio_mode(GPIO53_nPCE_2_MD);
pxa_gpio_mode(GPIO54_pSKTSEL_MD);
pxa_gpio_mode(GPIO55_nPREG_MD);
pxa_gpio_mode(GPIO56_nPWAIT_MD);
pxa_gpio_mode(GPIO57_nIOIS16_MD);
skt->irq = IRQ_GPIO(GPIO_NR_PALMTX_PCMCIA_READY);
palmtx_pcmcia_dbg("%s:%i, Socket:%d\n", __FUNCTION__, __LINE__, skt->nr);
return soc_pcmcia_request_irqs(skt, palmtx_socket_state_irqs,
ARRAY_SIZE(palmtx_socket_state_irqs));
}
static void corgi_measure_temp(int on)
{
if (on)
GPSR(CORGI_GPIO_ADC_TEMP_ON) = GPIO_bit(CORGI_GPIO_ADC_TEMP_ON);
else
GPCR(CORGI_GPIO_ADC_TEMP_ON) = GPIO_bit(CORGI_GPIO_ADC_TEMP_ON);
}
void pm_do_poweroff(void)
{
unsigned long start, flags;
PWER &= ~0x8000ffff;
local_irq_save(flags);
printk("Poweroff, Begin to wait BP_RDY signal.\n");
pm_send_all(PM_SUSPEND, (void *)3);
start = OSCR;
*(unsigned long *)(phys_to_virt(BPSIG_ADDR)) = NO_FLAG;
do {
if( !(GPLR(GPIO_BP_RDY) & GPIO_bit(GPIO_BP_RDY))){
printk(KERN_DEBUG"got BP_RDY signal.\n");
GPDR(GPIO_WDI_AP) |= GPIO_bit(GPIO_WDI_AP);
GPCR(GPIO_WDI_AP) = GPIO_bit(GPIO_WDI_AP);
while(1);
}
if ((OSCR - start) >= POWER_OFF_TIMEOUT) {
printk(KERN_DEBUG "timeout when power down\n");
mdelay(1);
GPDR(GPIO_WDI_AP) |= GPIO_bit(GPIO_WDI_AP);
GPCR(GPIO_WDI_AP) = GPIO_bit(GPIO_WDI_AP);
while(1);
}
} while(1);
pm_do_useroff();
printk(KERN_DEBUG "resume from useroff\n");
pm_send_all(PM_SUSPEND, (void *)0);
local_irq_restore(flags);
}
int dsp_reset(struct inode *inode, struct file *file, unsigned cmd,unsigned long arg)
{
/* ignore any argument, just do reset here */
/* raise reset */
GPSR(73) |= GPIO_bit(73);
/* udelay(1); DAVEDE */ /* wait 1/7.3728MHz = 135.6ns (par 11.13.4) */
/* sleep 1/10 second */
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(HZ/10);
/* Same PIOs of sa1110 */
GPSR(19) |= GPIO_bit(19);
GPCR(17) |= GPIO_bit(17);
/* sleep 2/10 second */
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(2*HZ/10);
/* lower reset */
GPCR(73) |= GPIO_bit(73);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(2*HZ/10);
writew(DSP_BOB, (unsigned short *)dsp_iopage); // little endian
return 0;
}
static int init_module(void)
{
/* u32 reg; */
int result=1;
result = misc_register(&dsp_misc);
printk("btpxa_dsp 2.0: dsp_init\n");
if (result)
printk("btweb: can't register /dev/dsp (error %i)\n",
result);
/* reg = GPDR; */
/* printk("btweb: dsp_init reg=%x letto\n",reg); DAVEDE */
/* reg &= ~GPIO_GPIO(1); */ /* GPIO1 is input */
GPDR(1) &= ~GPIO_bit(1); /* TODO: Da mettere nel boot loader */
/* reg |= GPIO_GPIO(17) | GPIO_GPIO(19); */ /* 17 and 19 are output DAVEDE */
/* TODO: Da mettere nel boot loader */
GPDR(19) |= GPIO_bit(19);
GPDR(17) |= GPIO_bit(17);
GPDR(73) |= GPIO_bit(73);
/* GPDR = reg; */
/* printk("btweb: dsp_init reg=%x scritto\n",reg); DAVEDE */
/* TODO: Da mettere nel boot loader */
MCIO0 = 0x00018103;
MCIO1 = 0x00018103;
MECR = 0x00000001;
return result;
}
static void corgi_discharge(int on)
{
if (on)
GPSR(CORGI_GPIO_DISCHARGE_ON) = GPIO_bit(CORGI_GPIO_DISCHARGE_ON);
else
GPCR(CORGI_GPIO_DISCHARGE_ON) = GPIO_bit(CORGI_GPIO_DISCHARGE_ON);
}
/*
* Irda
*/
static void poodle_irda_transceiver_mode(struct device *dev, int mode)
{
if (mode & IR_OFF) {
GPSR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
} else {
GPCR(POODLE_GPIO_IR_ON) = GPIO_bit(POODLE_GPIO_IR_ON);
}
}
static void corgiled_amber_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
if (value)
GPSR0 = GPIO_bit(CORGI_GPIO_LED_ORANGE);
else
GPCR0 = GPIO_bit(CORGI_GPIO_LED_ORANGE);
}
static void cmx270_green_set(struct led_classdev *led_cdev,
enum led_brightness value)
{
if (value)
GPCR(GPIO_GREEN_LED) = GPIO_bit(GPIO_GREEN_LED);
else
GPSR(GPIO_GREEN_LED) = GPIO_bit(GPIO_GREEN_LED);
}
static void gpio_set(int id, int on)
{
do {
if (on)
GPSR(id) = GPIO_bit(id);
else
GPCR(id) = GPIO_bit(id);
} while (0);
}
static __init int tdamc_init(void)
{
int retval=0;
printk(KERN_ERR"tdamc_init mc_power=%d (otherwise power up tda for attach only)\n",mc_power);
printk(KERN_ERR"btweb_features.abil_dem_video=%d,btweb_features.abil_mod_video=%d\n",btweb_features.abil_dem_video,btweb_features.abil_mod_video);
if ( (!mc_power) ){
/* Switching on demodulator only for i2c attach */
GPSR(btweb_features.abil_dem_video) =
GPIO_bit(btweb_features.abil_dem_video);
slave_address = SLAVE_ADDRESS_TDA;
}
else{
/* Switching on modulator only for i2c attach */
GPSR(btweb_features.abil_mod_video) =
GPIO_bit(btweb_features.abil_mod_video);
slave_address = SLAVE_ADDRESS_MC;
}
normal_addr[0] = slave_address;
if(normal_addr[0] >= 0x80)
{
printk(KERN_ERR"I2C: Invalid slave address for TDA (0x%x)\n",
normal_addr[0]);
return -EINVAL;
}
udelay(1000);
retval = i2c_add_driver(&tdamc_driver);
if (retval) return retval;
retval = misc_register (&tdamc_miscdev);
if (retval) {
i2c_del_driver(&tdamc_driver);
return retval;
}
printk("I2C: TDA9885-MC44BS driver successfully loaded\n");
if ( (!mc_power) ){
/* Switching on demodulator only for i2c attach */
GPCR(btweb_features.abil_dem_video) =
GPIO_bit(btweb_features.abil_dem_video);
slave_address = SLAVE_ADDRESS_TDA;
}
else{
/* Switching on modulator only for i2c attach */
GPCR(btweb_features.abil_mod_video) =
GPIO_bit(btweb_features.abil_mod_video);
slave_address = SLAVE_ADDRESS_MC;
}
slave_address=0;
normal_addr[0] = 0;
return 0;
}
void turn_off_gpio(int gpio) {
set_GPIO_mode(gpio | GPIO_OUT);
GPCR(gpio) = GPIO_bit(gpio);
if (GPLR(gpio) & GPIO_bit(gpio)) {
PDEBUG("LED gpio %d on\n", gpio);
} else {
PDEBUG("LED gpio %d off\n", gpio);
}
}
static void snd_h4000_audio_set_codec_reset(int mode) {
if (mode == 1) {
DPM_DEBUG("h4000_audio: Codec reset on\n");
GPSR(GPIO_NR_H4000_CODEC_RST) = GPIO_bit(GPIO_NR_H4000_CODEC_RST);
} else {
DPM_DEBUG("h4000_audio: Codec reset off\n");
GPCR(GPIO_NR_H4000_CODEC_RST) = GPIO_bit(GPIO_NR_H4000_CODEC_RST);
}
}
static void poodle_mci_setpower(struct device *dev, unsigned int vdd)
{
struct pxamci_platform_data* p_d = dev->platform_data;
if (( 1 << vdd) & p_d->ocr_mask)
GPSR1 = GPIO_bit(POODLE_GPIO_SD_PWR);
else
GPCR1 = GPIO_bit(POODLE_GPIO_SD_PWR);
}
void btweb_backlight(int onoff)
{
int btsys_lcd = onoff;
if (btsys_lcd)
GPSR(12) =
GPIO_bit(12);
else
GPCR(12) =
GPIO_bit(12);
}
ssize_t gpio_write(struct file *file, const char *ubuf, size_t count,
loff_t *offp)
{
unsigned int domode=0, inout=0, i, j;
char buf[16];
char *p;
if (count > 15) count = 15;
if (copy_from_user(buf, ubuf, count))
return -EFAULT;
buf[count] = '\0';
p = buf;
/* skip blanks: it may be all blanks, then accept it */
while (*p && isspace(*p))
p++;
if (!*p)
return count;
/* mode: accept M and I or O */
if (*p == 'm' || *p == 'M') {
domode++, p++;
if (*p == 'i' || *p == 'I')
inout= 0;
else if (*p == 'o' || *p == 'O')
inout = GPIO_MD_MASK_DIR;
else return -EINVAL;
p++;
}
/* get numbers */
if (sscanf(p, "%i=%i", &i, &j) != 2)
return -EINVAL;
if (!i || i > 80 || j > 3)
return -EINVAL;
if (!domode && j > 1)
return -EINVAL;
/* act */
if (domode) {
if (!j) domode = 0;
if (j == 1) domode = GPIO_ALT_FN_1_IN;
if (j == 2) domode = GPIO_ALT_FN_2_IN;
if (j == 3) domode = GPIO_ALT_FN_3_IN;
domode |= inout;
set_GPIO_mode( i | domode);
} else {
if (j)
GPSR(i) = GPIO_bit(i);
else
GPCR(i) = GPIO_bit(i);
}
*offp += count;
return count;
}
static void spitz_presuspend(void)
{
spitz_last_ac_status = sharpsl_pm.machinfo->read_devdata(SHARPSL_STATUS_ACIN);
/* GPIO Sleep Register */
PGSR0 = 0x00144018;
PGSR1 = 0x00EF0000;
if (machine_is_akita()) {
PGSR2 = 0x2121C000;
PGSR3 = 0x00600400;
} else {
PGSR2 = 0x0121C000;
PGSR3 = 0x00600000;
}
PGSR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
PGSR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
PGSR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
PGSR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
PGSR2 |= GPIO_bit(SPITZ_GPIO_KEY_STROBE0);
pxa_gpio_mode(GPIO18_RDY|GPIO_OUT | GPIO_DFLT_HIGH);
PRER = GPIO_bit(SPITZ_GPIO_KEY_INT);
PFER = GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET);
PWER = GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET) | PWER_RTC;
PKWR = GPIO_bit(SPITZ_GPIO_SYNC) | GPIO_bit(SPITZ_GPIO_KEY_INT) | GPIO_bit(SPITZ_GPIO_RESET);
PKSR = 0xffffffff; // clear
/* nRESET_OUT Disable */
PSLR |= PSLR_SL_ROD;
/* Stop 3.6MHz and drive HIGH to PCMCIA and CS */
PCFR = PCFR_GPR_EN | PCFR_OPDE;
}
static int cmx270_pcmcia_configure_socket(struct soc_pcmcia_socket *skt,
const socket_state_t *state)
{
GPSR(GPIO49_nPWE) = GPIO_bit(GPIO49_nPWE);
pxa_gpio_mode(GPIO49_nPWE | GPIO_OUT);
switch (skt->nr) {
case 0:
if (state->flags & SS_RESET) {
GPCR(GPIO49_nPWE) = GPIO_bit(GPIO49_nPWE);
GPSR(GPIO53_nPCE_2) = GPIO_bit(GPIO53_nPCE_2);
udelay(10);
GPCR(GPIO53_nPCE_2) = GPIO_bit(GPIO53_nPCE_2);
GPSR(GPIO49_nPWE) = GPIO_bit(GPIO49_nPWE);
}
break;
case 1:
if (state->flags & SS_RESET) {
GPCR(GPIO49_nPWE) = GPIO_bit(GPIO49_nPWE);
GPSR(GPIO53_nPCE_2) = GPIO_bit(GPIO53_nPCE_2);
udelay(10);
GPCR(GPIO53_nPCE_2) = GPIO_bit(GPIO53_nPCE_2);
GPSR(GPIO49_nPWE) = GPIO_bit(GPIO49_nPWE);
}
break;
}
pxa_gpio_mode(GPIO49_nPWE_MD);
return 0;
}
/*
* USB Device Controller
*/
static void poodle_udc_command(int cmd)
{
switch(cmd) {
case PXA2XX_UDC_CMD_CONNECT:
GPSR(POODLE_GPIO_USB_PULLUP) = GPIO_bit(POODLE_GPIO_USB_PULLUP);
break;
case PXA2XX_UDC_CMD_DISCONNECT:
GPCR(POODLE_GPIO_USB_PULLUP) = GPIO_bit(POODLE_GPIO_USB_PULLUP);
break;
}
}
/*
* USB Device Controller
*/
static void corgi_udc_command(int cmd)
{
switch(cmd) {
case PXA2XX_UDC_CMD_CONNECT:
GPSR(CORGI_GPIO_USB_PULLUP) = GPIO_bit(CORGI_GPIO_USB_PULLUP);
break;
case PXA2XX_UDC_CMD_DISCONNECT:
GPCR(CORGI_GPIO_USB_PULLUP) = GPIO_bit(CORGI_GPIO_USB_PULLUP);
break;
}
}
static void palmtt3_pxafb_lcd_power(int level, struct fb_var_screeninfo *var)
{
if(level) {
GPSR1 = GPIO_bit(38);
GPSR1 = GPIO_bit(41);
} else {
GPLR1 = GPIO_bit(38);
GPLR1 = GPIO_bit(41);
}
}
static int dot_reset(void){
GPCR(DOT_RESET) |= GPIO_bit(DOT_RESET);
GPSR(DOT_RESET) |= GPIO_bit(DOT_RESET);
/* DOT_COL_1 = 0x00;
DOT_COL_2 = 0x00;
DOT_COL_3 = 0x00;
DOT_COL_4 = 0x00;
DOT_COL_5 = 0x00;
*/ return 0;
}
static unsigned long corgi_charger_wakeup(void)
{
unsigned long ret;
ret = (!gpio_get_value(CORGI_GPIO_AC_IN) << GPIO_bit(CORGI_GPIO_AC_IN))
| (!gpio_get_value(CORGI_GPIO_KEY_INT)
<< GPIO_bit(CORGI_GPIO_KEY_INT))
| (!gpio_get_value(CORGI_GPIO_WAKEUP)
<< GPIO_bit(CORGI_GPIO_WAKEUP));
return ret;
}
int sg_ssp_release (struct inode *inode, struct file *filp)
{
SSCR0 = 0;
GPSR(22) = GPIO_bit(22); // MUX -> Serial Comm mode
/* Clear the reset */
GPSR(77) = GPIO_bit(77); // RSTN -> 1
MOD_DEC_USE_COUNT;
return 0;
}
static void corgi_mci_setpower(struct device *dev, unsigned int vdd)
{
struct pxamci_platform_data* p_d = dev->platform_data;
if (( 1 << vdd) & p_d->ocr_mask) {
printk(KERN_DEBUG "%s: on\n", __FUNCTION__);
GPSR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
} else {
printk(KERN_DEBUG "%s: off\n", __FUNCTION__);
GPCR1 = GPIO_bit(CORGI_GPIO_SD_PWR);
}
}
static void cmx270_mci_setpower(struct device *dev, unsigned int vdd)
{
struct pxamci_platform_data *p_d = dev->platform_data;
if ((1 << vdd) & p_d->ocr_mask) {
printk(KERN_DEBUG "%s: on\n", __FUNCTION__);
GPCR(105) = GPIO_bit(105);
} else {
GPSR(105) = GPIO_bit(105);
printk(KERN_DEBUG "%s: off\n", __FUNCTION__);
}
}
