aboutsummaryrefslogtreecommitdiffstats
path: root/target/linux/olpc/files/arch/i386/kernel/olpc.c
blob: d540cb0eae524958fdab7c196865b2c84d08ba9b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
/* Support for the OLPC DCON and OLPC EC access
 * Copyright (C) 2006, Advanced Micro Devices, Inc.
 *
 * 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/autoconf.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mc146818rtc.h>
#include <linux/delay.h>
#include <linux/spinlock.h>

#include <asm/olpc.h>
#include <asm/ofw.h>

/* This is our new multi-purpose structure used to contain the
 * information about the platform that we detect
 */

struct olpc_platform_t olpc_platform_info;
EXPORT_SYMBOL_GPL(olpc_platform_info);

/*********************************************************************
 *		EC locking and access
 *********************************************************************/

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 *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:  waited %u ms for IBF (%d)!\n",
				EC_BASE_TIMEOUT-timeo, line);
	}

	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:  waited %u ms for OBF (%d)!\n",
				EC_BASE_TIMEOUT-timeo, line);
	}

	return !(state == desired);
}

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);

	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);

/*********************************************************************
 *		DCON stuff
 *********************************************************************/

static void olpc_power_off(void)
{
	printk(KERN_INFO "OLPC power off sequence...\n");
	outb(0xff, 0x381);
	outb(0x14, 0x382);
	outb(0x01, 0x383);
	outb(0xff, 0x381);
	outb(0x14, 0x382);
	outb(0x00, 0x383);
}

static void __init
ec_detect(void)
{
	olpc_ec_cmd(0x08, NULL, 0, (unsigned char *) &olpc_platform_info.ecver, 1);
}

/* Check to see if this version of the OLPC board has VSA built
 * in, and set a flag
 */

static void __init vsa_detect(void)
{
	u16 rev;

	outw(0xFC53, 0xAC1C);
	outw(0x0003, 0xAC1C);

	rev = inw(0xAC1E);

	if (rev == 0x4132)
		olpc_platform_info.flags |= OLPC_F_VSA;
}

/* Map OFW revisions to what OLPC_REV_* */
static const char __initdata *olpc_boardrev_str[] = {
	"A1",
	"preB1",
	"B1",
	"preB2",
	"B2",
	"preB3",
	"B3",
	"B4",
	"C1",
	"R1",
};

static void __init platform_detect(char *revision, size_t len)
{
	size_t propsize;
	int i;

	BUG_ON(ARRAY_SIZE(olpc_boardrev_str) != OLPC_REV_UNKNOWN);

	if (ofw("getprop", 4, 1, NULL, "model", revision, len, &propsize)) {
		printk(KERN_ERR "ofw: getprop call failed!\n");
		goto failed;
	}
	if (len < propsize) {
		printk(KERN_ERR "ofw: revision string is too long!\n");
		goto failed;
	}

	for (i=0; i < ARRAY_SIZE(olpc_boardrev_str); i++) {
		if (strcmp(revision, olpc_boardrev_str[i]) == 0) {
			olpc_platform_info.boardrev = i;
			return;
		}
	}

failed:
	strncpy(revision, "Unknown", len);
	olpc_platform_info.boardrev = OLPC_REV_UNKNOWN;
}

static int olpc_dcon_present = -1;
module_param(olpc_dcon_present, int, 0444);

/* REV_A CMOS map:
 * bit 440;  DCON present bit
 */

#define OLPC_CMOS_DCON_OFFSET (440 / 8)
#define OLPC_CMOS_DCON_MASK   0x01

static int __init olpc_init(void)
{
	unsigned char *romsig;
	char revision[10];

	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;

	pm_power_off = olpc_power_off;

	/* Get the platform revision */
	platform_detect(revision, sizeof(revision));

	/* If olpc_dcon_present isn't set by the command line, then
	 * "detect" it
	 */

	if (olpc_dcon_present == -1) {
		/* B1 and greater always has a DCON */
		if (olpc_platform_info.boardrev >= OLPC_REV_B1 &&
				olpc_platform_info.boardrev < OLPC_REV_UNKNOWN)
			olpc_dcon_present = 1;
	}

	if (olpc_dcon_present)
		olpc_platform_info.flags |= OLPC_F_DCON;

	/* Get the EC revision */
	ec_detect();

	/* Check to see if the VSA exists */
	vsa_detect();

	printk(KERN_INFO "OLPC board revision: %s (EC=%x)\n", revision,
			olpc_platform_info.ecver);

 unmap:
	iounmap(romsig);

	return 0;
}

postcore_initcall(olpc_init);