Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6d1c76d4 authored by Paul Mundt's avatar Paul Mundt
Browse files

sh: Kill off broken snapgear ds1302 code. 



This will force the snapgear boards to use the on-chip SH RTC instead,
until the rtc-ds1302 driver is merged. The current code is broken
and hasn't built in some time, so just kill it off and get the board
working again.

Signed-off-by: default avatarPaul Mundt <lethal@linux-sh.org>
parent cbeb1344

arch/sh/boards/snapgear/Makefile

+1 −2
Original line number Diff line number Diff line
@@ -2,5 +2,4 @@ 
# Makefile for the SnapGear specific parts of the kernel

#



obj-y	 := setup.o io.o rtc.o

obj-y	 := setup.o io.o

arch/sh/boards/snapgear/rtc.c

deleted100644 → 0
+0 −309
Original line number Diff line number Diff line 
/****************************************************************************/

/*

 * linux/arch/sh/boards/snapgear/rtc.c -- Secureedge5410 RTC code

 *

 *  Copyright (C) 2002  David McCullough <davidm@snapgear.com>

 *  Copyright (C) 2003  Paul Mundt <lethal@linux-sh.org>

 *

 * The SecureEdge5410 can have one of 2 real time clocks, the SH

 * built in version or the preferred external DS1302.  Here we work out

 * each to see what we have and then run with it.

 */

/****************************************************************************/



#include <linux/init.h>

#include <linux/kernel.h>

#include <linux/sched.h>

#include <linux/time.h>

#include <linux/rtc.h>

#include <linux/mc146818rtc.h>

#include <asm/io.h>



static int use_ds1302;



/****************************************************************************/

/*

 *	we need to implement a DS1302 driver here that can operate in

 *	conjunction with the builtin rtc driver which is already quite friendly

 */

/*****************************************************************************/



#define	RTC_CMD_READ	0x81		/* Read command */

#define	RTC_CMD_WRITE	0x80		/* Write command */



#define	RTC_ADDR_YEAR	0x06		/* Address of year register */

#define	RTC_ADDR_DAY	0x05		/* Address of day of week register */

#define	RTC_ADDR_MON	0x04		/* Address of month register */

#define	RTC_ADDR_DATE	0x03		/* Address of day of month register */

#define	RTC_ADDR_HOUR	0x02		/* Address of hour register */

#define	RTC_ADDR_MIN	0x01		/* Address of minute register */

#define	RTC_ADDR_SEC	0x00		/* Address of second register */



#define	RTC_RESET	0x1000

#define	RTC_IODATA	0x0800

#define	RTC_SCLK	0x0400



#define set_dirp(x)

#define get_dirp(x) 0

#define set_dp(x)	SECUREEDGE_WRITE_IOPORT(x, 0x1c00)

#define get_dp(x)	SECUREEDGE_READ_IOPORT()



static void ds1302_sendbits(unsigned int val)

{

	int	i;



	for (i = 8; (i); i--, val >>= 1) {

		set_dp((get_dp() & ~RTC_IODATA) | ((val & 0x1) ? RTC_IODATA : 0));

		set_dp(get_dp() | RTC_SCLK);	// clock high

		set_dp(get_dp() & ~RTC_SCLK);	// clock low

	}

}



static unsigned int ds1302_recvbits(void)

{

	unsigned int	val;

	int		i;



	for (i = 0, val = 0; (i < 8); i++) {

		val |= (((get_dp() & RTC_IODATA) ? 1 : 0) << i);

		set_dp(get_dp() | RTC_SCLK);	// clock high

		set_dp(get_dp() & ~RTC_SCLK);	// clock low

	}

	return(val);

}



static unsigned int ds1302_readbyte(unsigned int addr)

{

	unsigned int	val;

	unsigned long	flags;



	local_irq_save(flags);

	set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);

	set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));



	set_dp(get_dp() | RTC_RESET);

	ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_READ);

	set_dirp(get_dirp() & ~RTC_IODATA);

	val = ds1302_recvbits();

	set_dp(get_dp() & ~RTC_RESET);

	local_irq_restore(flags);



	return(val);

}



static void ds1302_writebyte(unsigned int addr, unsigned int val)

{

	unsigned long	flags;



	local_irq_save(flags);

	set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);

	set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));

	set_dp(get_dp() | RTC_RESET);

	ds1302_sendbits(((addr & 0x3f) << 1) | RTC_CMD_WRITE);

	ds1302_sendbits(val);

	set_dp(get_dp() & ~RTC_RESET);

	local_irq_restore(flags);

}



static void ds1302_reset(void)

{

	unsigned long	flags;

	/* Hardware dependent reset/init */

	local_irq_save(flags);

	set_dirp(get_dirp() | RTC_RESET | RTC_IODATA | RTC_SCLK);

	set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));

	local_irq_restore(flags);

}



/*****************************************************************************/



static inline int bcd2int(int val)

{

	return((((val & 0xf0) >> 4) * 10) + (val & 0xf));

}



static inline int int2bcd(int val)

{

	return(((val / 10) << 4) + (val % 10));

}



/*****************************************************************************/

/*

 *	Write and Read some RAM in the DS1302,  if it works assume it's there

 *	Otherwise use the SH4 internal RTC

 */



void snapgear_rtc_gettimeofday(struct timespec *);

int snapgear_rtc_settimeofday(const time_t);



void __init secureedge5410_rtc_init(void)

{

	unsigned char *test = "snapgear";

	int i;



	ds1302_reset();



	use_ds1302 = 1;



	for (i = 0; test[i]; i++)

		ds1302_writebyte(32 + i, test[i]);



	for (i = 0; test[i]; i++)

		if (ds1302_readbyte(32 + i) != test[i]) {

			use_ds1302 = 0;

			break;

		}



	if (use_ds1302) {

		rtc_sh_get_time = snapgear_rtc_gettimeofday;

		rtc_sh_set_time = snapgear_rtc_settimeofday;

	}

		

	printk("SnapGear RTC: using %s rtc.\n", use_ds1302 ? "ds1302" : "internal");

}



/****************************************************************************/

/*

 *	our generic interface that chooses the correct code to use

 */



void snapgear_rtc_gettimeofday(struct timespec *ts)

{

	unsigned int sec, min, hr, day, mon, yr;



	if (!use_ds1302)

		return;



 	sec = bcd2int(ds1302_readbyte(RTC_ADDR_SEC));

 	min = bcd2int(ds1302_readbyte(RTC_ADDR_MIN));

 	hr  = bcd2int(ds1302_readbyte(RTC_ADDR_HOUR));

 	day = bcd2int(ds1302_readbyte(RTC_ADDR_DATE));

 	mon = bcd2int(ds1302_readbyte(RTC_ADDR_MON));

 	yr  = bcd2int(ds1302_readbyte(RTC_ADDR_YEAR));



bad_time:

	if (yr > 99 || mon < 1 || mon > 12 || day > 31 || day < 1 ||

	    hr > 23 || min > 59 || sec > 59) {

		printk(KERN_ERR

		       "SnapGear RTC: invalid value, resetting to 1 Jan 2000\n");

		ds1302_writebyte(RTC_ADDR_MIN,  min = 0);

		ds1302_writebyte(RTC_ADDR_HOUR, hr  = 0);

		ds1302_writebyte(RTC_ADDR_DAY,        7);

		ds1302_writebyte(RTC_ADDR_DATE, day = 1);

		ds1302_writebyte(RTC_ADDR_MON,  mon = 1);

		ds1302_writebyte(RTC_ADDR_YEAR, yr  = 0);

		ds1302_writebyte(RTC_ADDR_SEC,  sec = 0);

	}



	ts->tv_sec = mktime(2000 + yr, mon, day, hr, min, sec);

	if (ts->tv_sec < 0) {

#if 0

		printk("BAD TIME %d %d %d %d %d %d\n", yr, mon, day, hr, min, sec);

#endif

		yr = 100;

		goto bad_time;

	}

	ts->tv_nsec = 0;

}



int snapgear_rtc_settimeofday(const time_t secs)

{

	int retval = 0;

	int real_seconds, real_minutes, cmos_minutes;

	unsigned long nowtime;



	if (!use_ds1302)

		return 0;



/*

 *	This is called direct from the kernel timer handling code.

 *	It is supposed to synchronize the kernel clock to the RTC.

 */



	nowtime = secs;



	/* STOP RTC */

	ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);



	cmos_minutes = bcd2int(ds1302_readbyte(RTC_ADDR_MIN));



	/*

	 * since we're only adjusting minutes and seconds,

	 * don't interfere with hour overflow. This avoids

	 * messing with unknown time zones but requires your

	 * RTC not to be off by more than 15 minutes

	 */

	real_seconds = nowtime % 60;

	real_minutes = nowtime / 60;

	if (((abs(real_minutes - cmos_minutes) + 15)/30) & 1)

		real_minutes += 30;	/* correct for half hour time zone */

	real_minutes %= 60;



	if (abs(real_minutes - cmos_minutes) < 30) {

		ds1302_writebyte(RTC_ADDR_MIN, int2bcd(real_minutes));

		ds1302_writebyte(RTC_ADDR_SEC, int2bcd(real_seconds));

	} else {

		printk(KERN_WARNING

		       "SnapGear RTC: can't update from %d to %d\n",

		       cmos_minutes, real_minutes);

		retval = -1;

	}



	/* START RTC */

	ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);

	return(0);

}



unsigned char secureedge5410_cmos_read(int addr)

{

	unsigned char val = 0;



	if (!use_ds1302)

		return(__CMOS_READ(addr, w));



	switch(addr) {

	case RTC_SECONDS:       val = ds1302_readbyte(RTC_ADDR_SEC);  break;

	case RTC_SECONDS_ALARM:                                       break;

	case RTC_MINUTES:       val = ds1302_readbyte(RTC_ADDR_MIN);  break;

	case RTC_MINUTES_ALARM:                                       break;

	case RTC_HOURS:         val = ds1302_readbyte(RTC_ADDR_HOUR); break;

	case RTC_HOURS_ALARM:                                         break;

	case RTC_DAY_OF_WEEK:   val = ds1302_readbyte(RTC_ADDR_DAY);  break;

	case RTC_DAY_OF_MONTH:  val = ds1302_readbyte(RTC_ADDR_DATE); break;

	case RTC_MONTH:         val = ds1302_readbyte(RTC_ADDR_MON);  break;

	case RTC_YEAR:          val = ds1302_readbyte(RTC_ADDR_YEAR); break;

	case RTC_REG_A:         /* RTC_FREQ_SELECT */                 break;

	case RTC_REG_B:	        /* RTC_CONTROL */                     break;

	case RTC_REG_C:	        /* RTC_INTR_FLAGS */                  break;

	case RTC_REG_D:         val = RTC_VRT /* RTC_VALID */;        break;

	default:                                                      break;

	}



	return(val);

}



void secureedge5410_cmos_write(unsigned char val, int addr)

{

	if (!use_ds1302) {

		__CMOS_WRITE(val, addr, w);

		return;

	}



	switch(addr) {

	case RTC_SECONDS:       ds1302_writebyte(RTC_ADDR_SEC, val);  break;

	case RTC_SECONDS_ALARM:                                       break;

	case RTC_MINUTES:       ds1302_writebyte(RTC_ADDR_MIN, val);  break;

	case RTC_MINUTES_ALARM:                                       break;

	case RTC_HOURS:         ds1302_writebyte(RTC_ADDR_HOUR, val); break;

	case RTC_HOURS_ALARM:                                         break;

	case RTC_DAY_OF_WEEK:   ds1302_writebyte(RTC_ADDR_DAY, val);  break;

	case RTC_DAY_OF_MONTH:  ds1302_writebyte(RTC_ADDR_DATE, val); break;

	case RTC_MONTH:         ds1302_writebyte(RTC_ADDR_MON, val);  break;

	case RTC_YEAR:          ds1302_writebyte(RTC_ADDR_YEAR, val); break;

	case RTC_REG_A:         /* RTC_FREQ_SELECT */                 break;

	case RTC_REG_B:        	/* RTC_CONTROL */                     break;

	case RTC_REG_C:	        /* RTC_INTR_FLAGS */                  break;

	case RTC_REG_D:	        /* RTC_VALID */                       break;

	default:                                                      break;

	}

}

arch/sh/boards/snapgear/setup.c

+1 −15
Original line number Diff line number Diff line
@@ -22,20 +22,15 @@ 
#include <asm/snapgear.h>

#include <asm/irq.h>

#include <asm/io.h>

#include <asm/rtc.h>

#include <asm/cpu/timer.h>



extern void secureedge5410_rtc_init(void);

extern void pcibios_init(void);



/****************************************************************************/

/*

 * EraseConfig handling functions

 */



static irqreturn_t eraseconfig_interrupt(int irq, void *dev_id)

{

	volatile char dummy __attribute__((unused)) = * (volatile char *) 0xb8000000;

	(void)ctrl_inb(0xb8000000);	/* dummy read */



	printk("SnapGear: erase switch interrupt!\n");
@@ -75,20 +70,11 @@ static void __init init_snapgear_IRQ(void) 
	plat_irq_setup_pins(IRQ_MODE_IRQ);

}



/*

 * Initialize the board

 */

static void __init snapgear_setup(char **cmdline_p)

{

	board_time_init = secureedge5410_rtc_init;

}



/*

 * The Machine Vector

 */

static struct sh_machine_vector mv_snapgear __initmv = {

	.mv_name		= "SnapGear SecureEdge5410",

	.mv_setup		= snapgear_setup,

	.mv_nr_irqs		= 72,



	.mv_inb			= snapgear_inb,