x86: olpc: add One Laptop Per Child architecture support (3ef0e1f8) · Commits · 戴 / test

Documentation/kernel-parameters.txt

+7 −0

Original line number	Diff line number	Diff line
		@@ -1389,6 +1389,13 @@ and is between 256 and 4096 characters. It is defined in the file

		nr_uarts= [SERIAL] maximum number of UARTs to be registered.

		olpc_ec_timeout= [OLPC] ms delay when issuing EC commands
		Rather than timing out after 20 ms if an EC
		command is not properly ACKed, override the length
		of the timeout. We have interrupts disabled while
		waiting for the ACK, so if this is set too high
		interrupts may be lost!

		opl3= [HW,OSS]
		Format: <io>

arch/x86/Kconfig

+17 −1

Original line number	Diff line number	Diff line
		@@ -1504,6 +1504,10 @@ config PCI_GODIRECT
		config PCI_GOANY
		bool "Any"

		config PCI_GOOLPC
		bool "OLPC"
		depends on OLPC

		endchoice

		config PCI_BIOS
		@@ -1513,12 +1517,17 @@ config PCI_BIOS
		# x86-64 doesn't support PCI BIOS access from long mode so always go direct.
		config PCI_DIRECT
		def_bool y
		depends on PCI && (X86_64 \|\| (PCI_GODIRECT \|\| PCI_GOANY) \|\| X86_VISWS)
		depends on PCI && (X86_64 \|\| (PCI_GODIRECT \|\| PCI_GOANY \|\| PCI_GOOLPC) \|\| X86_VISWS)

		config PCI_MMCONFIG
		def_bool y
		depends on X86_32 && PCI && ACPI && (PCI_GOMMCONFIG \|\| PCI_GOANY)

		config PCI_OLPC
		bool
		depends on PCI && PCI_GOOLPC
		default y

		config PCI_DOMAINS
		def_bool y
		depends on PCI
		@@ -1638,6 +1647,13 @@ config GEODE_MFGPT_TIMER
		MFGPTs have a better resolution and max interval than the
		generic PIT, and are suitable for use as high-res timers.

		config OLPC
		bool "One Laptop Per Child support"
		default n
		help
		Add support for detecting the unique features of the OLPC
		XO hardware.

		endif # X86_32

		config K8_NB

arch/x86/kernel/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -91,6 +91,8 @@ endif
		obj-$(CONFIG_SCx200) += scx200.o
		scx200-y += scx200_32.o

		obj-$(CONFIG_OLPC) += olpc.o

		###
		# 64 bit specific files
		ifeq ($(CONFIG_X86_64),y)

arch/x86/kernel/olpc.c

0 → 100644

+260 −0

Original line number	Diff line number	Diff line
		/*
		* Support for the OLPC DCON and OLPC EC access
		*
		* Copyright © 2006 Advanced Micro Devices, Inc.
		* Copyright © 2007-2008 Andres Salomon <dilinger@debian.org>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or
		* (at your option) any later version.
		*/

		#include <linux/kernel.h>
		#include <linux/init.h>
		#include <linux/module.h>
		#include <linux/delay.h>
		#include <linux/spinlock.h>
		#include <linux/io.h>
		#include <linux/string.h>
		#include <asm/geode.h>
		#include <asm/olpc.h>

		#ifdef CONFIG_OPEN_FIRMWARE
		#include <asm/ofw.h>
		#endif

		struct olpc_platform_t olpc_platform_info;
		EXPORT_SYMBOL_GPL(olpc_platform_info);

		static DEFINE_SPINLOCK(ec_lock);

		/* what the timeout should be (in ms) */
		#define EC_BASE_TIMEOUT 20

		/* the timeout that bugs in the EC might force us to actually use */
		static int ec_timeout = EC_BASE_TIMEOUT;

		static int __init olpc_ec_timeout_set(char *str)
		{
		if (get_option(&str, &ec_timeout) != 1) {
		ec_timeout = EC_BASE_TIMEOUT;
		printk(KERN_ERR "olpc-ec: invalid argument to "
		"'olpc_ec_timeout=', ignoring!\n");
		}
		printk(KERN_DEBUG "olpc-ec: using %d ms delay for EC commands.\n",
		ec_timeout);
		return 1;
		}
		__setup("olpc_ec_timeout=", olpc_ec_timeout_set);

		/*
		* These {i,o}bf_status functions return whether the buffers are full or not.
		*/

		static inline unsigned int ibf_status(unsigned int port)
		{
		return !!(inb(port) & 0x02);
		}

		static inline unsigned int obf_status(unsigned int port)
		{
		return inb(port) & 0x01;
		}

		#define wait_on_ibf(p, d) __wait_on_ibf(__LINE__, (p), (d))
		static int __wait_on_ibf(unsigned int line, unsigned int port, int desired)
		{
		unsigned int timeo;
		int state = ibf_status(port);

		for (timeo = ec_timeout; state != desired && timeo; timeo--) {
		mdelay(1);
		state = ibf_status(port);
		}

		if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
		timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
		printk(KERN_WARNING "olpc-ec: %d: waited %u ms for IBF!\n",
		line, ec_timeout - timeo);
		}

		return !(state == desired);
		}

		#define wait_on_obf(p, d) __wait_on_obf(__LINE__, (p), (d))
		static int __wait_on_obf(unsigned int line, unsigned int port, int desired)
		{
		unsigned int timeo;
		int state = obf_status(port);

		for (timeo = ec_timeout; state != desired && timeo; timeo--) {
		mdelay(1);
		state = obf_status(port);
		}

		if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
		timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
		printk(KERN_WARNING "olpc-ec: %d: waited %u ms for OBF!\n",
		line, ec_timeout - timeo);
		}

		return !(state == desired);
		}

		/*
		* This allows the kernel to run Embedded Controller commands. The EC is
		* documented at <http://wiki.laptop.org/go/Embedded_controller>, and the
		* available EC commands are here:
		* <http://wiki.laptop.org/go/Ec_specification>. Unfortunately, while
		* OpenFirmware's source is available, the EC's is not.
		*/
		int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen,
		unsigned char *outbuf, size_t outlen)
		{
		unsigned long flags;
		int ret = -EIO;
		int i;

		spin_lock_irqsave(&ec_lock, flags);

		/* Clear OBF */
		for (i = 0; i < 10 && (obf_status(0x6c) == 1); i++)
		inb(0x68);
		if (i == 10) {
		printk(KERN_ERR "olpc-ec: timeout while attempting to "
		"clear OBF flag!\n");
		goto err;
		}

		if (wait_on_ibf(0x6c, 0)) {
		printk(KERN_ERR "olpc-ec: timeout waiting for EC to "
		"quiesce!\n");
		goto err;
		}

		restart:
		/*
		* Note that if we time out during any IBF checks, that's a failure;
		* we have to return. There's no way for the kernel to clear that.
		*
		* If we time out during an OBF check, we can restart the command;
		* reissuing it will clear the OBF flag, and we should be alright.
		* The OBF flag will sometimes misbehave due to what we believe
		* is a hardware quirk..
		*/
		printk(KERN_DEBUG "olpc-ec: running cmd 0x%x\n", cmd);
		outb(cmd, 0x6c);

		if (wait_on_ibf(0x6c, 0)) {
		printk(KERN_ERR "olpc-ec: timeout waiting for EC to read "
		"command!\n");
		goto err;
		}

		if (inbuf && inlen) {
		/* write data to EC */
		for (i = 0; i < inlen; i++) {
		if (wait_on_ibf(0x6c, 0)) {
		printk(KERN_ERR "olpc-ec: timeout waiting for"
		" EC accept data!\n");
		goto err;
		}
		printk(KERN_DEBUG "olpc-ec: sending cmd arg 0x%x\n",
		inbuf[i]);
		outb(inbuf[i], 0x68);
		}
		}
		if (outbuf && outlen) {
		/* read data from EC */
		for (i = 0; i < outlen; i++) {
		if (wait_on_obf(0x6c, 1)) {
		printk(KERN_ERR "olpc-ec: timeout waiting for"
		" EC to provide data!\n");
		goto restart;
		}
		outbuf[i] = inb(0x68);
		printk(KERN_DEBUG "olpc-ec: received 0x%x\n",
		outbuf[i]);
		}
		}

		ret = 0;
		err:
		spin_unlock_irqrestore(&ec_lock, flags);
		return ret;
		}
		EXPORT_SYMBOL_GPL(olpc_ec_cmd);

		#ifdef CONFIG_OPEN_FIRMWARE
		static void __init platform_detect(void)
		{
		size_t propsize;
		u32 rev;

		if (ofw("getprop", 4, 1, NULL, "board-revision-int", &rev, 4,
		&propsize) \|\| propsize != 4) {
		printk(KERN_ERR "ofw: getprop call failed!\n");
		rev = 0;
		}
		olpc_platform_info.boardrev = be32_to_cpu(rev);
		}
		#else
		static void __init platform_detect(void)
		{
		/* stopgap until OFW support is added to the kernel */
		olpc_platform_info.boardrev = be32_to_cpu(0xc2);
		}
		#endif

		static int __init olpc_init(void)
		{
		unsigned char *romsig;

		/* The ioremap check is dangerous; limit what we run it on */
		if (!is_geode() \|\| geode_has_vsa2())
		return 0;

		spin_lock_init(&ec_lock);

		romsig = ioremap(0xffffffc0, 16);
		if (!romsig)
		return 0;

		if (strncmp(romsig, "CL1 Q", 7))
		goto unmap;
		if (strncmp(romsig+6, romsig+13, 3)) {
		printk(KERN_INFO "OLPC BIOS signature looks invalid. "
		"Assuming not OLPC\n");
		goto unmap;
		}

		printk(KERN_INFO "OLPC board with OpenFirmware %.16s\n", romsig);
		olpc_platform_info.flags \|= OLPC_F_PRESENT;

		/* get the platform revision */
		platform_detect();

		/* assume B1 and above models always have a DCON */
		if (olpc_board_at_least(olpc_board(0xb1)))
		olpc_platform_info.flags \|= OLPC_F_DCON;

		/* get the EC revision */
		olpc_ec_cmd(EC_FIRMWARE_REV, NULL, 0,
		(unsigned char *) &olpc_platform_info.ecver, 1);

		/* check to see if the VSA exists */
		if (geode_has_vsa2())
		olpc_platform_info.flags \|= OLPC_F_VSA;

		printk(KERN_INFO "OLPC board revision %s%X (EC=%x)\n",
		((olpc_platform_info.boardrev & 0xf) < 8) ? "pre" : "",
		olpc_platform_info.boardrev >> 4,
		olpc_platform_info.ecver);

		unmap:
		iounmap(romsig);
		return 0;
		}

		postcore_initcall(olpc_init);

arch/x86/pci/Makefile_32

+1 −0

Original line number	Diff line number	Diff line
		@@ -3,6 +3,7 @@ obj-y := i386.o init.o
		obj-$(CONFIG_PCI_BIOS) += pcbios.o
		obj-$(CONFIG_PCI_MMCONFIG) += mmconfig_32.o direct.o mmconfig-shared.o
		obj-$(CONFIG_PCI_DIRECT) += direct.o
		obj-$(CONFIG_PCI_OLPC) += olpc.o

		pci-y := fixup.o
		pci-$(CONFIG_ACPI) += acpi.o

Admin message