first and last commit

drivers/samsung/arm7m/arm7m.c

@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2007-2009 Apple Inc. All rights reserved.
+ *
+ * This document is the property of Apple Inc.
+ * It is considered confidential and proprietary.
+ *
+ * This document may not be reproduced or transmitted in any form,
+ * in whole or in part, without the express written permission of
+ * Apple Inc.
+ */
+#include <arch.h>
+#include <debug.h>
+#include <drivers/arm7m/arm7m.h>
+#include <platform.h>
+#include <platform/clocks.h>
+#include <platform/int.h>
+#include <platform/soc/arm7m.h>
+#include <platform/soc/hwisr.h>
+#include <sys.h>
+#include <sys/boot.h>
+#include <sys/callout.h>
+#include <sys/task.h>
+
+/*
+ * Early init is done every time the ARM7 starts.
+ */
+int
+arm7m_init(void)
+{
+	
+	/*
+	 * Cache starts off.  Invalidate and then turn it on.
+	 */
+	rARM7M_CACHE_INV = 1;
+	rARM7M_CACHE_ON = ARM7M_CACHE_ON_ENABLE;
+
+	return(0);
+}
+
+/*
+ * Halt waiting for an interrupt.
+ */
+void
+arm7m_halt(void)
+{
+	/* XXX need to avoid doing this until cache operations are complete */
+	rARM7M_SLEEP = 1;
+}
+
+/*
+ * Cache control
+ */
+void
+arm7m_cache_operation(int operation, void *address, u_int32_t length)
+{
+	uint32_t	actual_base, lines;
+
+	if (length == 0) {
+		/*
+		 * To perform whole-cache operations, we have to turn the cache off.
+		 *
+		 * Since this introduces both a coherency risk and also since our use
+		 * of the hardware needs to be exclusive, we disable interrupts.
+		 */
+		enter_critical_section();
+		rARM7M_CACHE_ON = 0;
+
+		if (operation & CACHE_CLEAN)
+			rARM7M_CACHE_SYNC = 0;
+		if (operation & CACHE_INVALIDATE)		
+			rARM7M_CACHE_INV = 0;
+
+		/* on the panic path, leave the cache off */
+		if (!(operation & CACHE_PANIC))
+			rARM7M_CACHE_ON = ARM7M_CACHE_ON_ENABLE;
+		
+		exit_critical_section();
+	} else {
+		actual_base = (uint32_t)address;
+		ASSERT((actual_base & ARM7M_CACHE_LINE_MASK) == actual_base);
+		ASSERT((length % ARM7M_CACHE_LINE_SIZE) == 0);
+
+		lines = length >> ARM7M_CACHE_LINE_SHIFT;
+		ASSERT(lines > 0);
+
+		/*
+		 * Disable interrupts to prevent re-entrance from an interrupt
+		 * handler.
+		 */
+		enter_critical_section();
+		for (;;) {
+			rARM7M_CLINE_ADDR = actual_base;
+			if (operation & CACHE_CLEAN)
+				rARM7M_CLINE_SYNC = 0;
+			if (operation & CACHE_INVALIDATE)
+				rARM7M_CLINE_INV = 0;
+			if (--lines < 1)
+				break;
+			actual_base += ARM7M_CACHE_LINE_SIZE;
+		}
+		exit_critical_section();
+	}
+}
+
+#if SUPPORT_SLEEP
+static struct task	*sleeping_task;
+extern u_int32_t	arch_sleep_magic;
+
+void
+platform_sleep(void)
+{
+	/*
+	 * Disable interrupts; this is matched by the
+	 * exit_critical_section call in interrupt_init on the wake
+	 * path.
+	 */
+	enter_critical_section();
+
+	/* we are the sleeping task */
+	sleeping_task = task_get_current_task();
+
+	/* fool the upcoming test on the sleep path */
+	arch_sleep_magic = SLEEP_MAGIC_NOT_ASLEEP;
+	
+	/* save our current context - on wake we will return from this call */
+	arch_task_context_switch(&sleeping_task->arch, &sleeping_task->arch);
+
+	/* if we are on the wake path, go back */
+	if (SLEEP_MAGIC_WAKEY_WAKEY == arch_sleep_magic)
+		return;
+
+	/* flip the switch and wait for us to go to sleep */
+	arch_sleep_magic = SLEEP_MAGIC_WAKEY_WAKEY;
+
+	/* disable and flush the cache, since we're about to be turned off */
+	rARM7M_CACHE_ON = 0;
+	rARM7M_CACHE_SYNC = 0;
+
+	/* XXX really need to know how long the cache operation will take to complete */
+	for (;;) {
+	}
+}
+
+void
+platform_wakeup(void)
+{
+	/*
+	 * Cache starts off.  Invalidate and then turn it on.
+	 */
+	rARM7M_CACHE_INV = 1;
+	rARM7M_CACHE_ON = ARM7M_CACHE_ON_ENABLE;
+
+	/*
+	 * The VIC init is sleep/wake friendly - note this unmasks
+	 * interrupts that were unmasked at sleep time, so handlers
+	 * must be ready (or interrupt sources should be masked before
+	 * sleep).
+	 *
+	 * This call also exits the critical section that was entered
+	 * in platform_sleep (current_task has not changed).
+	 */
+	interrupt_init();
+
+	/* kick the callout system to re-evaluate deadlines */
+	callout_reset_deadline();
+
+	/* and switch back to the context that went to sleep */
+	arch_task_context_restore(&sleeping_task->arch);
+	
+	panic("arch_task_context_restore didn't");
+}
+#endif	/* SUPPORT_SLEEP */
+

drivers/samsung/arm7m/include/drivers/arm7m/arm7m.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2009 Apple Inc. All rights reserved.
+ *
+ * This document is the property of Apple Inc.
+ * It is considered confidential and proprietary.
+ *
+ * This document may not be reproduced or transmitted in any form,
+ * in whole or in part, without the express written permission of
+ * Apple Inc.
+ */
+
+#ifndef __ARM7M_H
+#define __ARM7M_H
+
+#include <sys/types.h>
+
+__BEGIN_DECLS
+
+extern int	arm7m_init(void);
+extern void	arm7m_halt(void);
+extern void	arm7m_cache_operation(int operation, void *address, u_int32_t length);
+
+__END_DECLS
+
+#endif

drivers/samsung/arm7m/rules.mk

@@ -0,0 +1,14 @@
+# Copyright (C) 2009 Apple Inc. All rights reserved.
+#
+# This document is the property of Apple Inc.
+# It is considered confidential and proprietary.
+#
+# This document may not be reproduced or transmitted in any form,
+# in whole or in part, without the express written permission of
+# Apple Inc.
+#
+LOCAL_DIR	:=	$(GET_LOCAL_DIR)
+
+ALL_OBJS	+=	${LOCAL_DIR}/arm7m.o
+
+GLOBAL_INCLUDES	+=	${LOCAL_DIR}/include