Commit 3272244c authored by Al Viro's avatar Al Viro Committed by Linus Torvalds
Browse files

[PATCH] m68k: switch mac/misc.c to direct use of appropriate cuda/pmu/maciisi requests 



kill ADBREQ_RAW use, replace adb_read_time(), etc.  with per-type variants,
eliminated remapping from pmu ones, fix the ifdefs (PMU->PMU68K)

Signed-off-by: default avatarAl Viro <viro@zeniv.linux.org.uk>
Cc: Roman Zippel <zippel@linux-m68k.org>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent b4290a23

arch/m68k/mac/misc.c

+218 −105
Original line number Diff line number Diff line
@@ -39,72 +39,163 @@ 
extern struct mac_booter_data mac_bi_data;

static void (*rom_reset)(void);



#ifdef CONFIG_ADB

/*

 * Return the current time as the number of seconds since January 1, 1904.

 */



static long adb_read_time(void)

#ifdef CONFIG_ADB_CUDA

static long cuda_read_time(void)

{

	volatile struct adb_request req;

	struct adb_request req;

	long time;



	adb_request((struct adb_request *) &req, NULL,

			ADBREQ_RAW|ADBREQ_SYNC,

			2, CUDA_PACKET, CUDA_GET_TIME);

	if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME) < 0)

		return 0;

	while (!req.complete)

		cuda_poll();



	time = (req.reply[3] << 24) | (req.reply[4] << 16)

		| (req.reply[5] << 8) | req.reply[6];

	return time - RTC_OFFSET;

}



/*

 * Set the current system time

 */

static void cuda_write_time(long data)

{

	struct adb_request req;

	data += RTC_OFFSET;

	if (cuda_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,

			(data >> 24) & 0xFF, (data >> 16) & 0xFF,

			(data >> 8) & 0xFF, data & 0xFF) < 0)

		return;

	while (!req.complete)

		cuda_poll();

}



static void adb_write_time(long data)

static __u8 cuda_read_pram(int offset)

{

	volatile struct adb_request req;

	struct adb_request req;

	if (cuda_request(&req, NULL, 4, CUDA_PACKET, CUDA_GET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF) < 0)

		return 0;

	while (!req.complete)

		cuda_poll();

	return req.reply[3];

}



	data += RTC_OFFSET;

static void cuda_write_pram(int offset, __u8 data)

{

	struct adb_request req;

	if (cuda_request(&req, NULL, 5, CUDA_PACKET, CUDA_SET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF, data) < 0)

		return;

	while (!req.complete)

		cuda_poll();

}

#else

#define cuda_read_time() 0

#define cuda_write_time(n)

#define cuda_read_pram NULL

#define cuda_write_pram NULL

#endif



#ifdef CONFIG_ADB_PMU68K

static long pmu_read_time(void)

{

	struct adb_request req;

	long time;



	adb_request((struct adb_request *) &req, NULL,

			ADBREQ_RAW|ADBREQ_SYNC,

			6, CUDA_PACKET, CUDA_SET_TIME,

	if (pmu_request(&req, NULL, 1, PMU_READ_RTC) < 0)

		return 0;

	while (!req.complete)

		pmu_poll();



	time = (req.reply[0] << 24) | (req.reply[1] << 16)

		| (req.reply[2] << 8) | req.reply[3];

	return time - RTC_OFFSET;

}



static void pmu_write_time(long data)

{

	struct adb_request req;

	data += RTC_OFFSET;

	if (pmu_request(&req, NULL, 5, PMU_SET_RTC,

			(data >> 24) & 0xFF, (data >> 16) & 0xFF,

			(data >> 8) & 0xFF, data & 0xFF);

			(data >> 8) & 0xFF, data & 0xFF) < 0)

		return;

	while (!req.complete)

		pmu_poll();

}



/*

 * Get a byte from the NVRAM

 */

static __u8 pmu_read_pram(int offset)

{

	struct adb_request req;

	if (pmu_request(&req, NULL, 3, PMU_READ_NVRAM,

			(offset >> 8) & 0xFF, offset & 0xFF) < 0)

		return 0;

	while (!req.complete)

		pmu_poll();

	return req.reply[3];

}



static void pmu_write_pram(int offset, __u8 data)

{

	struct adb_request req;

	if (pmu_request(&req, NULL, 4, PMU_WRITE_NVRAM,

			(offset >> 8) & 0xFF, offset & 0xFF, data) < 0)

		return;

	while (!req.complete)

		pmu_poll();

}

#else

#define pmu_read_time() 0

#define pmu_write_time(n)

#define pmu_read_pram NULL

#define pmu_write_pram NULL

#endif



#ifdef CONFIG_ADB_MACIISI

extern int maciisi_request(struct adb_request *req,

			void (*done)(struct adb_request *), int nbytes, ...);



static __u8 adb_read_pram(int offset)

static long maciisi_read_time(void)

{

	volatile struct adb_request req;

	struct adb_request req;

	long time;



	adb_request((struct adb_request *) &req, NULL,

			ADBREQ_RAW|ADBREQ_SYNC,

			4, CUDA_PACKET, CUDA_GET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF);

	return req.reply[3];

	if (maciisi_request(&req, NULL, 2, CUDA_PACKET, CUDA_GET_TIME))

		return 0;



	time = (req.reply[3] << 24) | (req.reply[4] << 16)

		| (req.reply[5] << 8) | req.reply[6];

	return time - RTC_OFFSET;

}



/*

 * Write a byte to the NVRAM

 */

static void maciisi_write_time(long data)

{

	struct adb_request req;

	data += RTC_OFFSET;

	maciisi_request(&req, NULL, 6, CUDA_PACKET, CUDA_SET_TIME,

			(data >> 24) & 0xFF, (data >> 16) & 0xFF,

			(data >> 8) & 0xFF, data & 0xFF);

}



static void adb_write_pram(int offset, __u8 data)

static __u8 maciisi_read_pram(int offset)

{

	volatile struct adb_request req;

	struct adb_request req;

	if (maciisi_request(&req, NULL, 4, CUDA_PACKET, CUDA_GET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF))

		return 0;

	return req.reply[3];

}



	adb_request((struct adb_request *) &req, NULL,

			ADBREQ_RAW|ADBREQ_SYNC,

			5, CUDA_PACKET, CUDA_SET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF,

			data);

static void maciisi_write_pram(int offset, __u8 data)

{

	struct adb_request req;

	maciisi_request(&req, NULL, 5, CUDA_PACKET, CUDA_SET_PRAM,

			(offset >> 8) & 0xFF, offset & 0xFF, data);

}

#endif /* CONFIG_ADB */

#else

#define maciisi_read_time() 0

#define maciisi_write_time(n)

#define maciisi_read_pram NULL

#define maciisi_write_pram NULL

#endif



/*

 * VIA PRAM/RTC access routines
@@ -305,42 +396,55 @@ static void oss_shutdown(void) 


static void cuda_restart(void)

{

	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			2, CUDA_PACKET, CUDA_RESET_SYSTEM);

	struct adb_request req;

	if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_RESET_SYSTEM) < 0)

		return;

	while (!req.complete)

		cuda_poll();

}



static void cuda_shutdown(void)

{

	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			2, CUDA_PACKET, CUDA_POWERDOWN);

	struct adb_request req;

	if (cuda_request(&req, NULL, 2, CUDA_PACKET, CUDA_POWERDOWN) < 0)

		return;

	while (!req.complete)

		cuda_poll();

}



#endif /* CONFIG_ADB_CUDA */



#ifdef CONFIG_ADB_PMU

#ifdef CONFIG_ADB_PMU68K



void pmu_restart(void)

{

	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			3, PMU_PACKET, PMU_SET_INTR_MASK,

			PMU_INT_ADB|PMU_INT_TICK);



	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			2, PMU_PACKET, PMU_RESET);

	struct adb_request req;

	if (pmu_request(&req, NULL,

			2, PMU_SET_INTR_MASK, PMU_INT_ADB|PMU_INT_TICK) < 0)

		return;

	while (!req.complete)

		pmu_poll();

	if (pmu_request(&req, NULL, 1, PMU_RESET) < 0)

		return;

	while (!req.complete)

		pmu_poll();

}



void pmu_shutdown(void)

{

	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			3, PMU_PACKET, PMU_SET_INTR_MASK,

			PMU_INT_ADB|PMU_INT_TICK);



	adb_request(NULL, NULL, ADBREQ_RAW|ADBREQ_SYNC,

			6, PMU_PACKET, PMU_SHUTDOWN,

			'M', 'A', 'T', 'T');

	struct adb_request req;

	if (pmu_request(&req, NULL,

			2, PMU_SET_INTR_MASK, PMU_INT_ADB|PMU_INT_TICK) < 0)

		return;

	while (!req.complete)

		pmu_poll();

	if (pmu_request(&req, NULL, 5, PMU_SHUTDOWN, 'M', 'A', 'T', 'T') < 0)

		return;

	while (!req.complete)

		pmu_poll();

}



#endif /* CONFIG_ADB_PMU */

#endif



/*

 *-------------------------------------------------------------------
@@ -351,21 +455,22 @@ void pmu_shutdown(void) 


void mac_pram_read(int offset, __u8 *buffer, int len)

{

	__u8 (*func)(int) = NULL;

	__u8 (*func)(int);

	int i;



	if (macintosh_config->adb_type == MAC_ADB_IISI ||

	    macintosh_config->adb_type == MAC_ADB_PB1 ||

	    macintosh_config->adb_type == MAC_ADB_PB2 ||

	    macintosh_config->adb_type == MAC_ADB_CUDA) {

#ifdef CONFIG_ADB

		func = adb_read_pram;

#else

		return;

#endif

	} else {

	switch(macintosh_config->adb_type) {

	case MAC_ADB_IISI:

		func = maciisi_read_pram; break;

	case MAC_ADB_PB1:

	case MAC_ADB_PB2:

		func = pmu_read_pram; break;

	case MAC_ADB_CUDA:

		func = cuda_read_pram; break;

	default:

		func = via_read_pram;

	}

	if (!func)

		return;

	for (i = 0 ; i < len ; i++) {

		buffer[i] = (*func)(offset++);

	}
@@ -373,21 +478,22 @@ void mac_pram_read(int offset, __u8 *buffer, int len) 


void mac_pram_write(int offset, __u8 *buffer, int len)

{

	void (*func)(int, __u8) = NULL;

	void (*func)(int, __u8);

	int i;



	if (macintosh_config->adb_type == MAC_ADB_IISI ||

	    macintosh_config->adb_type == MAC_ADB_PB1 ||

	    macintosh_config->adb_type == MAC_ADB_PB2 ||

	    macintosh_config->adb_type == MAC_ADB_CUDA) {

#ifdef CONFIG_ADB

		func = adb_write_pram;

#else

		return;

#endif

	} else {

	switch(macintosh_config->adb_type) {

	case MAC_ADB_IISI:

		func = maciisi_write_pram; break;

	case MAC_ADB_PB1:

	case MAC_ADB_PB2:

		func = pmu_write_pram; break;

	case MAC_ADB_CUDA:

		func = cuda_write_pram; break;

	default:

		func = via_write_pram;

	}

	if (!func)

		return;

	for (i = 0 ; i < len ; i++) {

		(*func)(offset++, buffer[i]);

	}
@@ -408,7 +514,7 @@ void mac_poweroff(void) 
	} else if (macintosh_config->adb_type == MAC_ADB_CUDA) {

		cuda_shutdown();

#endif

#ifdef CONFIG_ADB_PMU

#ifdef CONFIG_ADB_PMU68K

	} else if (macintosh_config->adb_type == MAC_ADB_PB1

		|| macintosh_config->adb_type == MAC_ADB_PB2) {

		pmu_shutdown();
@@ -448,7 +554,7 @@ void mac_reset(void) 
	} else if (macintosh_config->adb_type == MAC_ADB_CUDA) {

		cuda_restart();

#endif

#ifdef CONFIG_ADB_PMU

#ifdef CONFIG_ADB_PMU68K

	} else if (macintosh_config->adb_type == MAC_ADB_PB1

		|| macintosh_config->adb_type == MAC_ADB_PB2) {

		pmu_restart();
@@ -588,20 +694,22 @@ int mac_hwclk(int op, struct rtc_time *t) 
	unsigned long now;



	if (!op) { /* read */

		if (macintosh_config->adb_type == MAC_ADB_II) {

		switch (macintosh_config->adb_type) {

		case MAC_ADB_II:

		case MAC_ADB_IOP:

			now = via_read_time();

		} else

#ifdef CONFIG_ADB

		if ((macintosh_config->adb_type == MAC_ADB_IISI) ||

			   (macintosh_config->adb_type == MAC_ADB_PB1) ||

			   (macintosh_config->adb_type == MAC_ADB_PB2) ||

			   (macintosh_config->adb_type == MAC_ADB_CUDA)) {

			now = adb_read_time();

		} else

#endif

		if (macintosh_config->adb_type == MAC_ADB_IOP) {

			now = via_read_time();

		} else {

			break;

		case MAC_ADB_IISI:

			now = maciisi_read_time();

			break;

		case MAC_ADB_PB1:

		case MAC_ADB_PB2:

			now = pmu_read_time();

			break;

		case MAC_ADB_CUDA:

			now = cuda_read_time();

			break;

		default:

			now = 0;

		}
@@ -619,15 +727,20 @@ int mac_hwclk(int op, struct rtc_time *t) 
		now = mktime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,

			     t->tm_hour, t->tm_min, t->tm_sec);



		if (macintosh_config->adb_type == MAC_ADB_II) {

			via_write_time(now);

		} else if ((macintosh_config->adb_type == MAC_ADB_IISI) ||

			   (macintosh_config->adb_type == MAC_ADB_PB1) ||

			   (macintosh_config->adb_type == MAC_ADB_PB2) ||

			   (macintosh_config->adb_type == MAC_ADB_CUDA)) {

			adb_write_time(now);

		} else if (macintosh_config->adb_type == MAC_ADB_IOP) {

		switch (macintosh_config->adb_type) {

		case MAC_ADB_II:

		case MAC_ADB_IOP:

			via_write_time(now);

			break;

		case MAC_ADB_CUDA:

			cuda_write_time(now);

			break;

		case MAC_ADB_PB1:

		case MAC_ADB_PB2:

			pmu_write_time(now);

			break;

		case MAC_ADB_IISI:

			maciisi_write_time(now);

		}

#endif

	}

drivers/macintosh/via-maciisi.c

+18 −0
Original line number Diff line number Diff line
@@ -294,6 +294,24 @@ static void maciisi_sync(struct adb_request *req) 
		printk(KERN_ERR "maciisi_send_request: poll timed out!\n");

}



int

maciisi_request(struct adb_request *req, void (*done)(struct adb_request *),

	    int nbytes, ...)

{

	va_list list;

	int i;



	req->nbytes = nbytes;

	req->done = done;

	req->reply_expected = 0;

	va_start(list, nbytes);

	for (i = 0; i < nbytes; i++)

		req->data[i++] = va_arg(list, int);

	va_end(list);



	return maciisi_send_request(req, 1);

}



/* Enqueue a request, and run the queue if possible */

static int

maciisi_write(struct adb_request* req)