projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
ubicom32: add a 2.6.30 patch contributed by ubicom, with my cleanups and fixes split...
[openwrt.git] / target / linux / ubicom32 / patches-2.6.30 / 100-ubicom32_support.patch
1 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/aes_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/aes_ubicom32.c
2 --- linux-2.6.30.10/arch/ubicom32/crypto/aes_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
3 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/aes_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
4 @@ -0,0 +1,458 @@
5 +/*
6 + * arch/ubicom32/crypto/aes_ubicom32.c
7 + * Ubicom32 implementation of the AES Cipher Algorithm.
8 + *
9 + * (C) Copyright 2009, Ubicom, Inc.
10 + *
11 + * This file is part of the Ubicom32 Linux Kernel Port.
12 + *
13 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14 + * it and/or modify it under the terms of the GNU General Public License
15 + * as published by the Free Software Foundation, either version 2 of the
16 + * License, or (at your option) any later version.
17 + *
18 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
19 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
20 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
21 + * the GNU General Public License for more details.
22 + *
23 + * You should have received a copy of the GNU General Public License
24 + * along with the Ubicom32 Linux Kernel Port. If not,
25 + * see <http://www.gnu.org/licenses/>.
26 + *
27 + * Ubicom32 implementation derived from (with many thanks):
28 + * arch/m68knommu
29 + * arch/blackfin
30 + * arch/parisc
31 + */
32 +#include <crypto/aes.h>
33 +#include <crypto/algapi.h>
34 +#include <linux/err.h>
35 +#include <linux/module.h>
36 +#include <linux/init.h>
37 +#include <linux/spinlock.h>
38 +#include "crypto_ubicom32.h"
39 +#include <asm/linkage.h>
40 +
41 +struct ubicom32_aes_ctx {
42 + u8 key[AES_MAX_KEY_SIZE];
43 + u32 ctrl;
44 + int key_len;
45 +};
46 +
47 +static inline void aes_hw_set_key(const u8 *key, u8 key_len)
48 +{
49 + /*
50 + * switch case has more overhead than 4 move.4 instructions, so just copy 256 bits
51 + */
52 + SEC_SET_KEY_256(key);
53 +}
54 +
55 +static inline void aes_hw_set_iv(const u8 *iv)
56 +{
57 + SEC_SET_IV_4W(iv);
58 +}
59 +
60 +static inline void aes_hw_cipher(u8 *out, const u8 *in)
61 +{
62 + SEC_SET_INPUT_4W(in);
63 +
64 + asm volatile (
65 + " ; start AES by writing 0x40(SECURITY_BASE) \n\t"
66 + " move.4 0x40(%0), #0x01 \n\t"
67 + " pipe_flush 0 \n\t"
68 + " \n\t"
69 + " ; wait for the module to calculate the output \n\t"
70 + " btst 0x04(%0), #0 \n\t"
71 + " jmpne.f .-4 \n\t"
72 + :
73 + : "a" (SEC_BASE)
74 + : "cc"
75 + );
76 +
77 + SEC_GET_OUTPUT_4W(out);
78 +}
79 +
80 +static int __ocm_text aes_set_key(struct crypto_tfm *tfm, const u8 *in_key,
81 + unsigned int key_len)
82 +{
83 + struct ubicom32_aes_ctx *uctx = crypto_tfm_ctx(tfm);
84 +
85 + uctx->key_len = key_len;
86 + memcpy(uctx->key, in_key, key_len);
87 +
88 + /*
89 + * leave out HASH_ALG (none = 0), CBC (no = 0), DIR (unknown) yet
90 + */
91 + switch (uctx->key_len) {
92 + case 16:
93 + uctx->ctrl = SEC_KEY_128_BITS | SEC_ALG_AES;
94 + break;
95 + case 24:
96 + uctx->ctrl = SEC_KEY_192_BITS | SEC_ALG_AES;
97 + break;
98 + case 32:
99 + uctx->ctrl = SEC_KEY_256_BITS | SEC_ALG_AES;
100 + break;
101 + }
102 +
103 + return 0;
104 +}
105 +
106 +static inline void aes_cipher(struct crypto_tfm *tfm, u8 *out, const u8 *in, u32 extra_flags)
107 +{
108 + const struct ubicom32_aes_ctx *uctx = crypto_tfm_ctx(tfm);
109 +
110 + hw_crypto_lock();
111 + hw_crypto_check();
112 + hw_crypto_set_ctrl(uctx->ctrl | extra_flags);
113 +
114 + aes_hw_set_key(uctx->key, uctx->key_len);
115 + aes_hw_cipher(out, in);
116 +
117 + hw_crypto_unlock();
118 +}
119 +
120 +static void aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
121 +{
122 + aes_cipher(tfm, out, in, SEC_DIR_ENCRYPT);
123 +}
124 +
125 +static void aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
126 +{
127 + aes_cipher(tfm, out, in, SEC_DIR_DECRYPT);
128 +}
129 +
130 +static struct crypto_alg aes_alg = {
131 + .cra_name = "aes",
132 + .cra_driver_name = "aes-ubicom32",
133 + .cra_priority = CRYPTO_UBICOM32_PRIORITY,
134 + .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
135 + .cra_blocksize = AES_BLOCK_SIZE,
136 + .cra_ctxsize = sizeof(struct ubicom32_aes_ctx),
137 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
138 + .cra_module = THIS_MODULE,
139 + .cra_list = LIST_HEAD_INIT(aes_alg.cra_list),
140 + .cra_u = {
141 + .cipher = {
142 + .cia_min_keysize = AES_MIN_KEY_SIZE,
143 + .cia_max_keysize = AES_MAX_KEY_SIZE,
144 + .cia_setkey = aes_set_key,
145 + .cia_encrypt = aes_encrypt,
146 + .cia_decrypt = aes_decrypt,
147 + }
148 + }
149 +};
150 +
151 +static void __ocm_text ecb_aes_crypt_loop(u8 *out, u8 *in, unsigned int n)
152 +{
153 + while (likely(n)) {
154 + aes_hw_cipher(out, in);
155 + out += AES_BLOCK_SIZE;
156 + in += AES_BLOCK_SIZE;
157 + n -= AES_BLOCK_SIZE;
158 + }
159 +}
160 +
161 +static int __ocm_text ecb_aes_crypt(struct blkcipher_desc *desc, struct scatterlist *dst,
162 + struct scatterlist *src, unsigned int nbytes, u32 extra_flags)
163 +{
164 + const struct ubicom32_aes_ctx *uctx = crypto_blkcipher_ctx(desc->tfm);
165 + int ret;
166 +
167 + struct blkcipher_walk walk;
168 + blkcipher_walk_init(&walk, dst, src, nbytes);
169 + ret = blkcipher_walk_virt(desc, &walk);
170 + if (ret) {
171 + return ret;
172 + }
173 +
174 + hw_crypto_lock();
175 + hw_crypto_check();
176 +
177 + hw_crypto_set_ctrl(uctx->ctrl | extra_flags);
178 + aes_hw_set_key(uctx->key, uctx->key_len);
179 +
180 + while (likely((nbytes = walk.nbytes))) {
181 + /* only use complete blocks */
182 + unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
183 + u8 *out = walk.dst.virt.addr;
184 + u8 *in = walk.src.virt.addr;
185 +
186 + /* finish n/16 blocks */
187 + ecb_aes_crypt_loop(out, in, n);
188 +
189 + nbytes &= AES_BLOCK_SIZE - 1;
190 + ret = blkcipher_walk_done(desc, &walk, nbytes);
191 + }
192 +
193 + hw_crypto_unlock();
194 + return ret;
195 +}
196 +
197 +static int ecb_aes_encrypt(struct blkcipher_desc *desc,
198 + struct scatterlist *dst, struct scatterlist *src,
199 + unsigned int nbytes)
200 +{
201 + return ecb_aes_crypt(desc, dst, src, nbytes, SEC_DIR_ENCRYPT);
202 +}
203 +
204 +static int ecb_aes_decrypt(struct blkcipher_desc *desc,
205 + struct scatterlist *dst, struct scatterlist *src,
206 + unsigned int nbytes)
207 +{
208 + return ecb_aes_crypt(desc, dst, src, nbytes, SEC_DIR_DECRYPT);
209 +}
210 +
211 +static struct crypto_alg ecb_aes_alg = {
212 + .cra_name = "ecb(aes)",
213 + .cra_driver_name = "ecb-aes-ubicom32",
214 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
215 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
216 + .cra_blocksize = AES_BLOCK_SIZE,
217 + .cra_ctxsize = sizeof(struct ubicom32_aes_ctx),
218 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
219 + .cra_type = &crypto_blkcipher_type,
220 + .cra_module = THIS_MODULE,
221 + .cra_list = LIST_HEAD_INIT(ecb_aes_alg.cra_list),
222 + .cra_u = {
223 + .blkcipher = {
224 + .min_keysize = AES_MIN_KEY_SIZE,
225 + .max_keysize = AES_MAX_KEY_SIZE,
226 + .setkey = aes_set_key,
227 + .encrypt = ecb_aes_encrypt,
228 + .decrypt = ecb_aes_decrypt,
229 + }
230 + }
231 +};
232 +
233 +#if CRYPTO_UBICOM32_LOOP_ASM
234 +void __ocm_text cbc_aes_encrypt_loop(u8 *out, u8 *in, u8 *iv, unsigned int n)
235 +{
236 + asm volatile (
237 + "; set init. iv 4w \n\t"
238 + " move.4 0x50(%0), 0x0(%3) \n\t"
239 + " move.4 0x54(%0), 0x4(%3) \n\t"
240 + " move.4 0x58(%0), 0x8(%3) \n\t"
241 + " move.4 0x5c(%0), 0xc(%3) \n\t"
242 + " \n\t"
243 + "; we know n > 0, so we can always \n\t"
244 + "; load the first block \n\t"
245 + "; set input 4w \n\t"
246 + " move.4 0x30(%0), 0x0(%2) \n\t"
247 + " move.4 0x34(%0), 0x4(%2) \n\t"
248 + " move.4 0x38(%0), 0x8(%2) \n\t"
249 + " move.4 0x3c(%0), 0xc(%2) \n\t"
250 + " \n\t"
251 + "; kickoff hw \n\t"
252 + " move.4 0x40(%0), %2 \n\t"
253 + " \n\t"
254 + "; update n & flush \n\t"
255 + " add.4 %4, #-16, %4 \n\t"
256 + " pipe_flush 0 \n\t"
257 + " \n\t"
258 + "; while (n): work on 2nd block \n\t"
259 + " 1: lsl.4 d15, %4, #0x0 \n\t"
260 + " jmpeq.f 5f \n\t"
261 + " \n\t"
262 + "; set input 4w (2nd) \n\t"
263 + " move.4 0x30(%0), 0x10(%2) \n\t"
264 + " move.4 0x34(%0), 0x14(%2) \n\t"
265 + " move.4 0x38(%0), 0x18(%2) \n\t"
266 + " move.4 0x3c(%0), 0x1c(%2) \n\t"
267 + " \n\t"
268 + "; update n/in asap while waiting \n\t"
269 + " add.4 %4, #-16, %4 \n\t"
270 + " move.4 d15, 16(%2)++ \n\t"
271 + " \n\t"
272 + "; wait for the previous output \n\t"
273 + " btst 0x04(%0), #0 \n\t"
274 + " jmpne.f -4 \n\t"
275 + " \n\t"
276 + "; read previous output \n\t"
277 + " move.4 0x0(%1), 0x50(%0) \n\t"
278 + " move.4 0x4(%1), 0x54(%0) \n\t"
279 + " move.4 0x8(%1), 0x58(%0) \n\t"
280 + " move.4 0xc(%1), 0x5c(%0) \n\t"
281 + " \n\t"
282 + "; kick off hw for 2nd input \n\t"
283 + " move.4 0x40(%0), %2 \n\t"
284 + " \n\t"
285 + "; update out asap \n\t"
286 + " move.4 d15, 16(%1)++ \n\t"
287 + " \n\t"
288 + "; go back to loop \n\t"
289 + " jmpt 1b \n\t"
290 + " \n\t"
291 + "; wait for last output \n\t"
292 + " 5: btst 0x04(%0), #0 \n\t"
293 + " jmpne.f -4 \n\t"
294 + " \n\t"
295 + "; read last output \n\t"
296 + " move.4 0x0(%1), 0x50(%0) \n\t"
297 + " move.4 0x4(%1), 0x54(%0) \n\t"
298 + " move.4 0x8(%1), 0x58(%0) \n\t"
299 + " move.4 0xc(%1), 0x5c(%0) \n\t"
300 + " \n\t"
301 + "; copy out iv \n\t"
302 + " move.4 0x0(%3), 0x50(%0) \n\t"
303 + " move.4 0x4(%3), 0x54(%0) \n\t"
304 + " move.4 0x8(%3), 0x58(%0) \n\t"
305 + " move.4 0xc(%3), 0x5c(%0) \n\t"
306 + " \n\t"
307 + :
308 + : "a" (SEC_BASE), "a" (out), "a" (in), "a" (iv), "d" (n)
309 + : "d15", "cc"
310 + );
311 +}
312 +
313 +#else
314 +
315 +static void __ocm_text cbc_aes_encrypt_loop(u8 *out, u8 *in, u8 *iv, unsigned int n)
316 +{
317 + aes_hw_set_iv(iv);
318 + while (likely(n)) {
319 + aes_hw_cipher(out, in);
320 + out += AES_BLOCK_SIZE;
321 + in += AES_BLOCK_SIZE;
322 + n -= AES_BLOCK_SIZE;
323 + }
324 + SEC_COPY_4W(iv, out - AES_BLOCK_SIZE);
325 +}
326 +
327 +#endif
328 +
329 +static void __ocm_text cbc_aes_decrypt_loop(u8 *out, u8 *in, u8 *iv, unsigned int n)
330 +{
331 + while (likely(n)) {
332 + aes_hw_set_iv(iv);
333 + SEC_COPY_4W(iv, in);
334 + aes_hw_cipher(out, in);
335 + out += AES_BLOCK_SIZE;
336 + in += AES_BLOCK_SIZE;
337 + n -= AES_BLOCK_SIZE;
338 + }
339 +}
340 +
341 +static int __ocm_text cbc_aes_crypt(struct blkcipher_desc *desc,
342 + struct scatterlist *dst, struct scatterlist *src,
343 + unsigned int nbytes, u32 extra_flags)
344 +{
345 + struct ubicom32_aes_ctx *uctx = crypto_blkcipher_ctx(desc->tfm);
346 + int ret;
347 +
348 + struct blkcipher_walk walk;
349 + blkcipher_walk_init(&walk, dst, src, nbytes);
350 + ret = blkcipher_walk_virt(desc, &walk);
351 + if (unlikely(ret)) {
352 + return ret;
353 + }
354 +
355 + hw_crypto_lock();
356 + hw_crypto_check();
357 +
358 + hw_crypto_set_ctrl(uctx->ctrl | extra_flags);
359 + aes_hw_set_key(uctx->key, uctx->key_len);
360 +
361 + while (likely((nbytes = walk.nbytes))) {
362 + /* only use complete blocks */
363 + unsigned int n = nbytes & ~(AES_BLOCK_SIZE - 1);
364 + if (likely(n)) {
365 + u8 *out = walk.dst.virt.addr;
366 + u8 *in = walk.src.virt.addr;
367 +
368 + if (extra_flags & SEC_DIR_ENCRYPT) {
369 + cbc_aes_encrypt_loop(out, in, walk.iv, n);
370 + } else {
371 + cbc_aes_decrypt_loop(out, in, walk.iv, n);
372 + }
373 + }
374 +
375 + nbytes &= AES_BLOCK_SIZE - 1;
376 + ret = blkcipher_walk_done(desc, &walk, nbytes);
377 + }
378 + hw_crypto_unlock();
379 +
380 + return ret;
381 +}
382 +
383 +static int __ocm_text cbc_aes_encrypt(struct blkcipher_desc *desc,
384 + struct scatterlist *dst, struct scatterlist *src,
385 + unsigned int nbytes)
386 +{
387 + return cbc_aes_crypt(desc, dst, src, nbytes, SEC_DIR_ENCRYPT | SEC_CBC_SET);
388 +}
389 +
390 +static int __ocm_text cbc_aes_decrypt(struct blkcipher_desc *desc,
391 + struct scatterlist *dst, struct scatterlist *src,
392 + unsigned int nbytes)
393 +{
394 + return cbc_aes_crypt(desc, dst, src, nbytes, SEC_DIR_DECRYPT | SEC_CBC_SET);
395 +}
396 +
397 +static struct crypto_alg cbc_aes_alg = {
398 + .cra_name = "cbc(aes)",
399 + .cra_driver_name = "cbc-aes-ubicom32",
400 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
401 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
402 + .cra_blocksize = AES_BLOCK_SIZE,
403 + .cra_ctxsize = sizeof(struct ubicom32_aes_ctx),
404 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
405 + .cra_type = &crypto_blkcipher_type,
406 + .cra_module = THIS_MODULE,
407 + .cra_list = LIST_HEAD_INIT(cbc_aes_alg.cra_list),
408 + .cra_u = {
409 + .blkcipher = {
410 + .min_keysize = AES_MIN_KEY_SIZE,
411 + .max_keysize = AES_MAX_KEY_SIZE,
412 + .ivsize = AES_BLOCK_SIZE,
413 + .setkey = aes_set_key,
414 + .encrypt = cbc_aes_encrypt,
415 + .decrypt = cbc_aes_decrypt,
416 + }
417 + }
418 +};
419 +
420 +static int __init aes_init(void)
421 +{
422 + int ret;
423 +
424 + hw_crypto_init();
425 +
426 + ret = crypto_register_alg(&aes_alg);
427 + if (ret)
428 + goto aes_err;
429 +
430 + ret = crypto_register_alg(&ecb_aes_alg);
431 + if (ret)
432 + goto ecb_aes_err;
433 +
434 + ret = crypto_register_alg(&cbc_aes_alg);
435 + if (ret)
436 + goto cbc_aes_err;
437 +
438 +out:
439 + return ret;
440 +
441 +cbc_aes_err:
442 + crypto_unregister_alg(&ecb_aes_alg);
443 +ecb_aes_err:
444 + crypto_unregister_alg(&aes_alg);
445 +aes_err:
446 + goto out;
447 +}
448 +
449 +static void __exit aes_fini(void)
450 +{
451 + crypto_unregister_alg(&cbc_aes_alg);
452 + crypto_unregister_alg(&ecb_aes_alg);
453 + crypto_unregister_alg(&aes_alg);
454 +}
455 +
456 +module_init(aes_init);
457 +module_exit(aes_fini);
458 +
459 +MODULE_ALIAS("aes");
460 +
461 +MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm");
462 +MODULE_LICENSE("GPL");
463 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/crypto_des.h linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_des.h
464 --- linux-2.6.30.10/arch/ubicom32/crypto/crypto_des.h 1970-01-01 02:00:00.000000000 +0200
465 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_des.h 2009-12-11 11:45:11.000000000 +0200
466 @@ -0,0 +1,34 @@
467 +/*
468 + * arch/ubicom32/crypto/crypto_des.h
469 + * Function for checking keys for the DES and Triple DES Encryption
470 + * algorithms.
471 + *
472 + * (C) Copyright 2009, Ubicom, Inc.
473 + *
474 + * This file is part of the Ubicom32 Linux Kernel Port.
475 + *
476 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
477 + * it and/or modify it under the terms of the GNU General Public License
478 + * as published by the Free Software Foundation, either version 2 of the
479 + * License, or (at your option) any later version.
480 + *
481 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
482 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
483 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
484 + * the GNU General Public License for more details.
485 + *
486 + * You should have received a copy of the GNU General Public License
487 + * along with the Ubicom32 Linux Kernel Port. If not,
488 + * see <http://www.gnu.org/licenses/>.
489 + *
490 + * Ubicom32 implementation derived from (with many thanks):
491 + * arch/m68knommu
492 + * arch/blackfin
493 + * arch/parisc
494 + */
495 +#ifndef __CRYPTO_DES_H__
496 +#define __CRYPTO_DES_H__
497 +
498 +extern int crypto_des_check_key(const u8*, unsigned int, u32*);
499 +
500 +#endif /* __CRYPTO_DES_H__ */
501 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/crypto_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_ubicom32.c
502 --- linux-2.6.30.10/arch/ubicom32/crypto/crypto_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
503 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
504 @@ -0,0 +1,50 @@
505 +/*
506 + * arch/ubicom32/crypto/crypto_ubicom32.c
507 + * Generic code to support ubicom32 hardware crypto accelerator
508 + *
509 + * (C) Copyright 2009, Ubicom, Inc.
510 + *
511 + * This file is part of the Ubicom32 Linux Kernel Port.
512 + *
513 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
514 + * it and/or modify it under the terms of the GNU General Public License
515 + * as published by the Free Software Foundation, either version 2 of the
516 + * License, or (at your option) any later version.
517 + *
518 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
519 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
520 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
521 + * the GNU General Public License for more details.
522 + *
523 + * You should have received a copy of the GNU General Public License
524 + * along with the Ubicom32 Linux Kernel Port. If not,
525 + * see <http://www.gnu.org/licenses/>.
526 + *
527 + * Ubicom32 implementation derived from (with many thanks):
528 + * arch/m68knommu
529 + * arch/blackfin
530 + * arch/parisc
531 + */
532 +#include "crypto_ubicom32.h"
533 +
534 +spinlock_t crypto_ubicom32_lock;
535 +bool crypto_ubicom32_inited = false;
536 +volatile bool crypto_ubicom32_on = false;
537 +volatile unsigned long crypto_ubicom32_last_use;
538 +
539 +struct timer_list crypto_ubicom32_ps_timer;
540 +void crypto_ubicom32_ps_check(unsigned long data)
541 +{
542 + unsigned long idle_time = msecs_to_jiffies(HW_CRYPTO_PS_MAX_IDLE_MS);
543 +
544 + BUG_ON(!crypto_ubicom32_on);
545 +
546 + if (((jiffies - crypto_ubicom32_last_use) > idle_time) && spin_trylock_bh(&crypto_ubicom32_lock)) {
547 + hw_crypto_turn_off();
548 + spin_unlock_bh(&crypto_ubicom32_lock);
549 + return;
550 + }
551 +
552 + /* keep monitoring */
553 + hw_crypto_ps_start();
554 +}
555 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/crypto_ubicom32.h linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_ubicom32.h
556 --- linux-2.6.30.10/arch/ubicom32/crypto/crypto_ubicom32.h 1970-01-01 02:00:00.000000000 +0200
557 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/crypto_ubicom32.h 2009-12-11 11:45:11.000000000 +0200
558 @@ -0,0 +1,346 @@
559 +/*
560 + * arch/ubicom32/crypto/crypto_ubicom32.h
561 + * Support for Ubicom32 cryptographic instructions.
562 + *
563 + * (C) Copyright 2009, Ubicom, Inc.
564 + *
565 + * This file is part of the Ubicom32 Linux Kernel Port.
566 + *
567 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
568 + * it and/or modify it under the terms of the GNU General Public License
569 + * as published by the Free Software Foundation, either version 2 of the
570 + * License, or (at your option) any later version.
571 + *
572 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
573 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
574 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
575 + * the GNU General Public License for more details.
576 + *
577 + * You should have received a copy of the GNU General Public License
578 + * along with the Ubicom32 Linux Kernel Port. If not,
579 + * see <http://www.gnu.org/licenses/>.
580 + *
581 + * Ubicom32 implementation derived from (with many thanks):
582 + * arch/m68knommu
583 + * arch/blackfin
584 + * arch/parisc
585 + */
586 +#ifndef _CRYPTO_ARCH_UBICOM32_CRYPT_H
587 +#define _CRYPTO_ARCH_UBICOM32_CRYPT_H
588 +
589 +#include <linux/module.h>
590 +#include <linux/kernel.h>
591 +#include <linux/jiffies.h>
592 +#include <linux/timer.h>
593 +#include <linux/spinlock.h>
594 +#include <asm/errno.h>
595 +#include <asm/io.h>
596 +#include <asm/ip5000.h>
597 +
598 +#define CRYPTO_UBICOM32_LOOP_ASM 1
599 +#define CRYPTO_UBICOM32_ALIGNMENT 4
600 +#define SEC_ALIGNED(p) (((u32)p & 3) == 0)
601 +
602 +#define SEC_BASE SECURITY_BASE
603 +#define SEC_KEY_OFFSET SECURITY_KEY_VALUE(0)
604 +#define SEC_INPUT_OFFSET SECURITY_KEY_IN(0)
605 +#define SEC_OUTPUT_OFFSET SECURITY_KEY_OUT(0)
606 +#define SEC_HASH_OFFSET SECURITY_KEY_HASH(0)
607 +
608 +#define SEC_KEY_128_BITS SECURITY_CTRL_KEY_SIZE(0)
609 +#define SEC_KEY_192_BITS SECURITY_CTRL_KEY_SIZE(1)
610 +#define SEC_KEY_256_BITS SECURITY_CTRL_KEY_SIZE(2)
611 +
612 +#define SEC_HASH_NONE SECURITY_CTRL_HASH_ALG_NONE
613 +#define SEC_HASH_MD5 SECURITY_CTRL_HASH_ALG_MD5
614 +#define SEC_HASH_SHA1 SECURITY_CTRL_HASH_ALG_SHA1
615 +
616 +#define SEC_CBC_SET SECURITY_CTRL_CBC
617 +#define SEC_CBC_NONE 0
618 +
619 +#define SEC_ALG_AES SECURITY_CTRL_CIPHER_ALG_AES
620 +#define SEC_ALG_NONE SECURITY_CTRL_CIPHER_ALG_NONE
621 +#define SEC_ALG_DES SECURITY_CTRL_CIPHER_ALG_DES
622 +#define SEC_ALG_3DES SECURITY_CTRL_CIPHER_ALG_3DES
623 +
624 +#define SEC_DIR_ENCRYPT SECURITY_CTRL_ENCIPHER
625 +#define SEC_DIR_DECRYPT 0
626 +
627 +#define CRYPTO_UBICOM32_PRIORITY 300
628 +#define CRYPTO_UBICOM32_COMPOSITE_PRIORITY 400
629 +
630 +#define HW_CRYPTO_PS_MAX_IDLE_MS 100 /* idle time (ms) before shuting down sm */
631 +
632 +extern spinlock_t crypto_ubicom32_lock;
633 +extern bool crypto_ubicom32_inited;
634 +extern volatile bool crypto_ubicom32_on;
635 +extern volatile unsigned long crypto_ubicom32_last_use;
636 +extern struct timer_list crypto_ubicom32_ps_timer;
637 +extern void crypto_ubicom32_ps_check(unsigned long data);
638 +
639 +#define SEC_COPY_2W(t, s) \
640 + asm volatile ( \
641 + " move.4 0(%0), 0(%1) \n\t" \
642 + " move.4 4(%0), 4(%1) \n\t" \
643 + \
644 + : \
645 + : "a" (t), "a" (s) \
646 + )
647 +
648 +#define SEC_COPY_4W(t, s) \
649 + asm volatile ( \
650 + " move.4 0(%0), 0(%1) \n\t" \
651 + " move.4 4(%0), 4(%1) \n\t" \
652 + " move.4 8(%0), 8(%1) \n\t" \
653 + " move.4 12(%0), 12(%1) \n\t" \
654 + : \
655 + : "a" (t), "a" (s) \
656 + )
657 +
658 +#define SEC_COPY_5W(t, s) \
659 + asm volatile ( \
660 + " move.4 0(%0), 0(%1) \n\t" \
661 + " move.4 4(%0), 4(%1) \n\t" \
662 + " move.4 8(%0), 8(%1) \n\t" \
663 + " move.4 12(%0), 12(%1) \n\t" \
664 + " move.4 16(%0), 16(%1) \n\t" \
665 + : \
666 + : "a" (t), "a" (s) \
667 + )
668 +
669 +#define SEC_SET_KEY_2W(x) \
670 + asm volatile ( \
671 + " ; write key to Security Keyblock \n\t" \
672 + " move.4 0x10(%0), 0(%1) \n\t" \
673 + " move.4 0x14(%0), 4(%1) \n\t" \
674 + : \
675 + : "a" (SECURITY_BASE), "a" (x) \
676 + )
677 +
678 +#define SEC_SET_KEY_4W(x) \
679 + asm volatile ( \
680 + " ; write key to Security Keyblock \n\t" \
681 + " move.4 0x10(%0), 0(%1) \n\t" \
682 + " move.4 0x14(%0), 4(%1) \n\t" \
683 + " move.4 0x18(%0), 8(%1) \n\t" \
684 + " move.4 0x1c(%0), 12(%1) \n\t" \
685 + : \
686 + : "a"(SECURITY_BASE), "a"(x) \
687 + )
688 +
689 +#define SEC_SET_KEY_6W(x) \
690 + asm volatile ( \
691 + " ; write key to Security Keyblock \n\t" \
692 + " move.4 0x10(%0), 0(%1) \n\t" \
693 + " move.4 0x14(%0), 4(%1) \n\t" \
694 + " move.4 0x18(%0), 8(%1) \n\t" \
695 + " move.4 0x1c(%0), 12(%1) \n\t" \
696 + " move.4 0x20(%0), 16(%1) \n\t" \
697 + " move.4 0x24(%0), 20(%1) \n\t" \
698 + : \
699 + : "a" (SECURITY_BASE), "a" (x) \
700 + )
701 +
702 +#define SEC_SET_KEY_8W(x) \
703 + asm volatile ( \
704 + " ; write key to Security Keyblock \n\t" \
705 + " move.4 0x10(%0), 0(%1) \n\t" \
706 + " move.4 0x14(%0), 4(%1) \n\t" \
707 + " move.4 0x18(%0), 8(%1) \n\t" \
708 + " move.4 0x1c(%0), 12(%1) \n\t" \
709 + " move.4 0x20(%0), 16(%1) \n\t" \
710 + " move.4 0x24(%0), 20(%1) \n\t" \
711 + " move.4 0x28(%0), 24(%1) \n\t" \
712 + " move.4 0x2c(%0), 28(%1) \n\t" \
713 + : \
714 + : "a" (SECURITY_BASE), "a" (x) \
715 + )
716 +
717 +#define SEC_SET_KEY_64(k) SEC_SET_KEY_2W(k)
718 +#define SEC_SET_KEY_128(k) SEC_SET_KEY_4W(k)
719 +#define SEC_SET_KEY_192(k) SEC_SET_KEY_6W(k)
720 +#define SEC_SET_KEY_256(k) SEC_SET_KEY_8W(k)
721 +
722 +#define DES_SET_KEY(x) SEC_SET_KEY_64(x)
723 +#define DES3_SET_KEY(x) SEC_SET_KEY_192(x)
724 +
725 +#define SEC_SET_INPUT_2W(x) \
726 + asm volatile ( \
727 + " ; write key to Security Keyblock \n\t" \
728 + " move.4 0x30(%0), 0(%1) \n\t" \
729 + " move.4 0x34(%0), 4(%1) \n\t" \
730 + : \
731 + : "a" (SECURITY_BASE), "a" (x) \
732 + )
733 +
734 +#define SEC_GET_OUTPUT_2W(x) \
735 + asm volatile ( \
736 + " ; write key to Security Keyblock \n\t" \
737 + " move.4 0(%1), 0x50(%0) \n\t" \
738 + " move.4 4(%1), 0x54(%0) \n\t" \
739 + : \
740 + : "a" (SECURITY_BASE), "a" (x) \
741 + )
742 +
743 +#define SEC_SET_INPUT_4W(x) \
744 + asm volatile ( \
745 + " ; write key to Security Keyblock \n\t" \
746 + " move.4 0x30(%0), 0(%1) \n\t" \
747 + " move.4 0x34(%0), 4(%1) \n\t" \
748 + " move.4 0x38(%0), 8(%1) \n\t" \
749 + " move.4 0x3c(%0), 12(%1) \n\t" \
750 + : \
751 + : "a" (SECURITY_BASE), "a" (x) \
752 + )
753 +
754 +#define SEC_GET_OUTPUT_4W(x) \
755 + asm volatile ( \
756 + " ; read output from Security Keyblock \n\t" \
757 + " move.4 0(%1), 0x50(%0) \n\t" \
758 + " move.4 4(%1), 0x54(%0) \n\t" \
759 + " move.4 8(%1), 0x58(%0) \n\t" \
760 + " move.4 12(%1), 0x5c(%0) \n\t" \
761 + : \
762 + : "a" (SECURITY_BASE), "a" (x) \
763 + )
764 +
765 +#define SEC_SET_IV_4W(x) \
766 + asm volatile ( \
767 + " ; write IV to Security Keyblock \n\t" \
768 + " move.4 0x50(%0), 0(%1) \n\t" \
769 + " move.4 0x54(%0), 4(%1) \n\t" \
770 + " move.4 0x58(%0), 8(%1) \n\t" \
771 + " move.4 0x5c(%0), 12(%1) \n\t" \
772 + : \
773 + : "a" (SECURITY_BASE), "a" (x) \
774 + )
775 +
776 +#define SEC_PIPE_FLUSH() asm volatile ( " pipe_flush 0 \n\t" )
777 +
778 +static inline void hw_crypto_set_ctrl(uint32_t c)
779 +{
780 + asm volatile (
781 + " move.4 0(%0), %1 \n\t"
782 + :
783 + : "a" (SECURITY_BASE + SECURITY_CTRL), "d" (c)
784 + );
785 +}
786 +
787 +static inline void hw_crypto_ps_start(void)
788 +{
789 + crypto_ubicom32_ps_timer.expires = jiffies + msecs_to_jiffies(HW_CRYPTO_PS_MAX_IDLE_MS >> 1);
790 + add_timer(&crypto_ubicom32_ps_timer);
791 +}
792 +
793 +static inline void hw_crypto_turn_on(void)
794 +{
795 + asm volatile (
796 + " moveai A4, %0 \n\t"
797 + " bset 0x0(A4), 0x0(A4), %1 \n\t"
798 + " cycles 11 \n\t"
799 + :
800 + : "i" (OCP_BASE >> 7), "i" (GEN_CLK_PLL_SECURITY_BIT_NO)
801 + : "a4", "cc"
802 + );
803 + crypto_ubicom32_on = true;
804 +}
805 +
806 +static inline void hw_crypto_turn_off(void)
807 +{
808 + asm volatile (
809 + " moveai A4, %0 \n\t"
810 + " bclr 0x0(A4), 0x0(A4), %1 \n\t"
811 + :
812 + : "i" (OCP_BASE >> 7), "i" (GEN_CLK_PLL_SECURITY_BIT_NO)
813 + : "a4", "cc"
814 + );
815 + crypto_ubicom32_on = false;
816 +}
817 +
818 +/*
819 + * hw_crypto_check
820 + * Most probably hw crypto is called in clusters and it makes no sense to turn it off
821 + * and on and waster 13 cycles every time.
822 + */
823 +static inline void hw_crypto_check(void)
824 +{
825 + if (likely(crypto_ubicom32_on)) {
826 + return;
827 + }
828 + crypto_ubicom32_last_use = jiffies;
829 + hw_crypto_turn_on();
830 + hw_crypto_ps_start();
831 +}
832 +
833 +/*
834 + * hw_crypto_ps_init
835 + * Init power save timer
836 + */
837 +static inline void hw_crypto_ps_init(void)
838 +{
839 + init_timer_deferrable(&crypto_ubicom32_ps_timer);
840 + crypto_ubicom32_ps_timer.function = crypto_ubicom32_ps_check;
841 + crypto_ubicom32_ps_timer.data = 0;
842 +}
843 +
844 +/*
845 + * hw_crypto_init()
846 + * Initialize OCP security module lock and disables its clock.
847 + */
848 +static inline void hw_crypto_init(void)
849 +{
850 + if (!crypto_ubicom32_inited) {
851 + crypto_ubicom32_inited = true;
852 + spin_lock_init(&crypto_ubicom32_lock);
853 + hw_crypto_ps_init();
854 + hw_crypto_turn_off();
855 + }
856 +}
857 +
858 +/*
859 + * hw_crypto_lock()
860 + * Locks the OCP security module and enables its clock.
861 + */
862 +static inline void hw_crypto_lock(void)
863 +{
864 + spin_lock_bh(&crypto_ubicom32_lock);
865 +}
866 +
867 +/*
868 + * hw_crypto_unlock()
869 + * Unlocks the OCP security module and disables its clock.
870 + */
871 +static inline void hw_crypto_unlock(void)
872 +{
873 + crypto_ubicom32_last_use = jiffies;
874 + spin_unlock_bh(&crypto_ubicom32_lock);
875 +}
876 +
877 +#define CONFIG_CRYPTO_UBICOM32_DEBUG 1
878 +
879 +#ifdef CONFIG_CRYPTO_UBICOM32_DEBUG
880 +static inline void hex_dump(void *buf, int b_size, const char *msg)
881 +{
882 + u8 *b = (u8 *)buf;
883 + int i;
884 + if (msg) {
885 + printk("%s:\t", msg);
886 + }
887 +
888 + for (i=0; i < b_size; i++) {
889 + printk("%02x ", b[i]);
890 + if ((i & 3) == 3) {
891 + printk(" ");
892 + }
893 + if ((i & 31) == 31) {
894 + printk("\n");
895 + }
896 + }
897 + printk("\n");
898 +}
899 +#define UBICOM32_SEC_DUMP(a, b, c) hex_dump(a, b, c)
900 +#else
901 +#define UBICOM32_SEC_DUMP(a, b, c)
902 +#endif
903 +
904 +#endif /* _CRYPTO_ARCH_UBICOM32_CRYPT_H */
905 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/des_check_key.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/des_check_key.c
906 --- linux-2.6.30.10/arch/ubicom32/crypto/des_check_key.c 1970-01-01 02:00:00.000000000 +0200
907 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/des_check_key.c 2009-12-11 11:45:11.000000000 +0200
908 @@ -0,0 +1,148 @@
909 +/*
910 + * arch/ubicom32/crypto/des_check_key.c
911 + * Ubicom32 architecture function for checking keys for the DES and
912 + * Tripple DES Encryption algorithms.
913 + *
914 + * (C) Copyright 2009, Ubicom, Inc.
915 + *
916 + * Originally released as descore by Dana L. How <how@isl.stanford.edu>.
917 + * Modified by Raimar Falke <rf13@inf.tu-dresden.de> for the Linux-Kernel.
918 + * Derived from Cryptoapi and Nettle implementations, adapted for in-place
919 + * scatterlist interface. Changed LGPL to GPL per section 3 of the LGPL.
920 + *
921 + * s390 Version:
922 + * Copyright IBM Corp. 2003
923 + * Author(s): Thomas Spatzier
924 + * Jan Glauber (jan.glauber@de.ibm.com)
925 + *
926 + * Derived from "crypto/des.c"
927 + * Copyright (c) 1992 Dana L. How.
928 + * Copyright (c) Raimar Falke <rf13@inf.tu-dresden.de>
929 + * Copyright (c) Gisle Sflensminde <gisle@ii.uib.no>
930 + * Copyright (C) 2001 Niels Mvller.
931 + * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
932 + *
933 + * This file is part of the Ubicom32 Linux Kernel Port.
934 + *
935 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
936 + * it and/or modify it under the terms of the GNU General Public License
937 + * as published by the Free Software Foundation, either version 2 of the
938 + * License, or (at your option) any later version.
939 + *
940 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
941 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
942 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
943 + * the GNU General Public License for more details.
944 + *
945 + * You should have received a copy of the GNU General Public License
946 + * along with the Ubicom32 Linux Kernel Port. If not,
947 + * see <http://www.gnu.org/licenses/>.
948 + *
949 + * Ubicom32 implementation derived from (with many thanks):
950 + * arch/m68knommu
951 + * arch/blackfin
952 + * arch/parisc
953 + */
954 +#include <linux/init.h>
955 +#include <linux/module.h>
956 +#include <linux/errno.h>
957 +#include <linux/crypto.h>
958 +#include "crypto_des.h"
959 +
960 +#define ROR(d,c,o) ((d) = (d) >> (c) | (d) << (o))
961 +
962 +static const u8 parity[] = {
963 + 8,1,0,8,0,8,8,0,0,8,8,0,8,0,2,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,3,
964 + 0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
965 + 0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
966 + 8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
967 + 0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
968 + 8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
969 + 8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
970 + 4,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,5,0,8,0,8,8,0,0,8,8,0,8,0,6,8,
971 +};
972 +
973 +/*
974 + * RFC2451: Weak key checks SHOULD be performed.
975 + */
976 +int
977 +crypto_des_check_key(const u8 *key, unsigned int keylen, u32 *flags)
978 +{
979 + u32 n, w;
980 +
981 + n = parity[key[0]]; n <<= 4;
982 + n |= parity[key[1]]; n <<= 4;
983 + n |= parity[key[2]]; n <<= 4;
984 + n |= parity[key[3]]; n <<= 4;
985 + n |= parity[key[4]]; n <<= 4;
986 + n |= parity[key[5]]; n <<= 4;
987 + n |= parity[key[6]]; n <<= 4;
988 + n |= parity[key[7]];
989 + w = 0x88888888L;
990 +
991 + if ((*flags & CRYPTO_TFM_REQ_WEAK_KEY)
992 + && !((n - (w >> 3)) & w)) { /* 1 in 10^10 keys passes this test */
993 + if (n < 0x41415151) {
994 + if (n < 0x31312121) {
995 + if (n < 0x14141515) {
996 + /* 01 01 01 01 01 01 01 01 */
997 + if (n == 0x11111111) goto weak;
998 + /* 01 1F 01 1F 01 0E 01 0E */
999 + if (n == 0x13131212) goto weak;
1000 + } else {
1001 + /* 01 E0 01 E0 01 F1 01 F1 */
1002 + if (n == 0x14141515) goto weak;
1003 + /* 01 FE 01 FE 01 FE 01 FE */
1004 + if (n == 0x16161616) goto weak;
1005 + }
1006 + } else {
1007 + if (n < 0x34342525) {
1008 + /* 1F 01 1F 01 0E 01 0E 01 */
1009 + if (n == 0x31312121) goto weak;
1010 + /* 1F 1F 1F 1F 0E 0E 0E 0E (?) */
1011 + if (n == 0x33332222) goto weak;
1012 + } else {
1013 + /* 1F E0 1F E0 0E F1 0E F1 */
1014 + if (n == 0x34342525) goto weak;
1015 + /* 1F FE 1F FE 0E FE 0E FE */
1016 + if (n == 0x36362626) goto weak;
1017 + }
1018 + }
1019 + } else {
1020 + if (n < 0x61616161) {
1021 + if (n < 0x44445555) {
1022 + /* E0 01 E0 01 F1 01 F1 01 */
1023 + if (n == 0x41415151) goto weak;
1024 + /* E0 1F E0 1F F1 0E F1 0E */
1025 + if (n == 0x43435252) goto weak;
1026 + } else {
1027 + /* E0 E0 E0 E0 F1 F1 F1 F1 (?) */
1028 + if (n == 0x44445555) goto weak;
1029 + /* E0 FE E0 FE F1 FE F1 FE */
1030 + if (n == 0x46465656) goto weak;
1031 + }
1032 + } else {
1033 + if (n < 0x64646565) {
1034 + /* FE 01 FE 01 FE 01 FE 01 */
1035 + if (n == 0x61616161) goto weak;
1036 + /* FE 1F FE 1F FE 0E FE 0E */
1037 + if (n == 0x63636262) goto weak;
1038 + } else {
1039 + /* FE E0 FE E0 FE F1 FE F1 */
1040 + if (n == 0x64646565) goto weak;
1041 + /* FE FE FE FE FE FE FE FE */
1042 + if (n == 0x66666666) goto weak;
1043 + }
1044 + }
1045 + }
1046 + }
1047 + return 0;
1048 +weak:
1049 + *flags |= CRYPTO_TFM_RES_WEAK_KEY;
1050 + return -EINVAL;
1051 +}
1052 +
1053 +EXPORT_SYMBOL(crypto_des_check_key);
1054 +
1055 +MODULE_LICENSE("GPL");
1056 +MODULE_DESCRIPTION("Key Check function for DES & DES3 Cipher Algorithms");
1057 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/des_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/des_ubicom32.c
1058 --- linux-2.6.30.10/arch/ubicom32/crypto/des_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
1059 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/des_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
1060 @@ -0,0 +1,761 @@
1061 +/*
1062 + * arch/ubicom32/crypto/des_ubicom32.c
1063 + * Ubicom32 implementation of the DES Cipher Algorithm.
1064 + *
1065 + * (C) Copyright 2009, Ubicom, Inc.
1066 + *
1067 + * This file is part of the Ubicom32 Linux Kernel Port.
1068 + *
1069 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
1070 + * it and/or modify it under the terms of the GNU General Public License
1071 + * as published by the Free Software Foundation, either version 2 of the
1072 + * License, or (at your option) any later version.
1073 + *
1074 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
1075 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
1076 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
1077 + * the GNU General Public License for more details.
1078 + *
1079 + * You should have received a copy of the GNU General Public License
1080 + * along with the Ubicom32 Linux Kernel Port. If not,
1081 + * see <http://www.gnu.org/licenses/>.
1082 + *
1083 + * Ubicom32 implementation derived from (with many thanks):
1084 + * arch/m68knommu
1085 + * arch/blackfin
1086 + * arch/parisc
1087 + */
1088 +#include <crypto/algapi.h>
1089 +#include <linux/init.h>
1090 +#include <linux/module.h>
1091 +
1092 +#include "crypto_ubicom32.h"
1093 +extern int crypto_des_check_key(const u8 *key, unsigned int keylen, u32 *flags);
1094 +
1095 +#define DES_BLOCK_SIZE 8
1096 +#define DES_KEY_SIZE 8
1097 +
1098 +#define DES3_192_KEY_SIZE (3 * DES_KEY_SIZE)
1099 +#define DES3_192_BLOCK_SIZE DES_BLOCK_SIZE
1100 +
1101 +#define DES3_SUB_KEY(key, i) (((u8 *)key) + (i * DES_KEY_SIZE))
1102 +
1103 +enum des_ops {
1104 + DES_ENCRYPT,
1105 + DES_DECRYPT,
1106 +
1107 + DES3_EDE_ENCRYPT,
1108 + DES3_EDE_DECRYPT,
1109 +
1110 +#ifdef DES3_EEE
1111 + DES3_EEE_ENCRYPT,
1112 + DES3_EEE_DECRYPT,
1113 +#endif
1114 +};
1115 +
1116 +struct ubicom32_des_ctx {
1117 + u8 key[3 * DES_KEY_SIZE];
1118 + u32 ctrl;
1119 + int key_len;
1120 +};
1121 +
1122 +static inline void des_hw_set_key(const u8 *key, u8 key_len)
1123 +{
1124 + /*
1125 + * HW 3DES is not tested yet, use DES just as ipOS
1126 + */
1127 + DES_SET_KEY(key);
1128 +}
1129 +
1130 +static inline void des_hw_cipher(u8 *out, const u8 *in)
1131 +{
1132 + SEC_SET_INPUT_2W(in);
1133 +
1134 + asm volatile (
1135 + " ; start DES by writing 0x38(SECURITY_BASE) \n\t"
1136 + " move.4 0x38(%0), #0x01 \n\t"
1137 + " pipe_flush 0 \n\t"
1138 + " \n\t"
1139 + " ; wait for the module to calculate the output \n\t"
1140 + " btst 0x04(%0), #0 \n\t"
1141 + " jmpne.f .-4 \n\t"
1142 + :
1143 + : "a" (SEC_BASE)
1144 + : "cc"
1145 + );
1146 +
1147 + SEC_GET_OUTPUT_2W(out);
1148 +}
1149 +
1150 +
1151 +static void inline des3_hw_ede_encrypt(u8 *keys, u8 *out, const u8 *in)
1152 +{
1153 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1154 + des_hw_set_key(DES3_SUB_KEY(keys, 0), DES_KEY_SIZE);
1155 + des_hw_cipher(out, in);
1156 +
1157 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1158 + des_hw_set_key(DES3_SUB_KEY(keys, 1), DES_KEY_SIZE);
1159 + des_hw_cipher(out, out);
1160 +
1161 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1162 + des_hw_set_key(DES3_SUB_KEY(keys, 2), DES_KEY_SIZE);
1163 + des_hw_cipher(out, out);
1164 +}
1165 +
1166 +static void inline des3_hw_ede_decrypt(u8 *keys, u8 *out, const u8 *in)
1167 +{
1168 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1169 + des_hw_set_key(DES3_SUB_KEY(keys, 2), DES_KEY_SIZE);
1170 + des_hw_cipher(out, in);
1171 +
1172 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1173 + des_hw_set_key(DES3_SUB_KEY(keys, 1), DES_KEY_SIZE);
1174 + des_hw_cipher(out, out);
1175 +
1176 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1177 + des_hw_set_key(DES3_SUB_KEY(keys, 0), DES_KEY_SIZE);
1178 + des_hw_cipher(out, out);
1179 +}
1180 +
1181 +#ifdef DES3_EEE
1182 +static void inline des3_hw_eee_encrypt(u8 *keys, u8 *out, const u8 *in)
1183 +{
1184 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1185 + des_hw_set_key(DES3_SUB_KEY(keys, 0), 2);
1186 + des_hw_cipher(out, in);
1187 +
1188 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1189 + des_hw_set_key(DES3_SUB_KEY(keys, 1), 2);
1190 + des_hw_cipher(out, out);
1191 +
1192 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1193 + des_hw_set_key(DES3_SUB_KEY(keys, 2), 2);
1194 + des_hw_cipher(out, out);
1195 +}
1196 +
1197 +static void inline des3_hw_eee_decrypt(u8 *keys, u8 *out, const u8 *in)
1198 +{
1199 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1200 + des_hw_set_key(DES3_SUB_KEY(keys, 2), 2);
1201 + des_hw_cipher(out, in);
1202 +
1203 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1204 + des_hw_set_key(DES3_SUB_KEY(keys, 1), 2);
1205 + des_hw_cipher(out, out);
1206 +
1207 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1208 + des_hw_set_key(DES3_SUB_KEY(keys, 0), 2);
1209 + des_hw_cipher(out, out);
1210 +}
1211 +#endif
1212 +
1213 +static int des_setkey(struct crypto_tfm *tfm, const u8 *key,
1214 + unsigned int keylen)
1215 +{
1216 + struct ubicom32_des_ctx *dctx = crypto_tfm_ctx(tfm);
1217 + u32 *flags = &tfm->crt_flags;
1218 + int ret;
1219 +
1220 + /* test if key is valid (not a weak key) */
1221 + ret = crypto_des_check_key(key, keylen, flags);
1222 + if (ret == 0) {
1223 + memcpy(dctx->key, key, keylen);
1224 + dctx->key_len = keylen;
1225 + //dctx->ctrl = (keylen == DES_KEY_SIZE) ? SEC_ALG_DES : SEC_ALG_3DES
1226 + /* 2DES and 3DES are both implemented with DES hw function */
1227 + dctx->ctrl = SEC_ALG_DES;
1228 + }
1229 + return ret;
1230 +}
1231 +
1232 +static inline void des_cipher_1b(struct crypto_tfm *tfm, u8 *out, const u8 *in, u32 extra_flags)
1233 +{
1234 + const struct ubicom32_des_ctx *uctx = crypto_tfm_ctx(tfm);
1235 +
1236 + hw_crypto_lock();
1237 + hw_crypto_check();
1238 + hw_crypto_set_ctrl(uctx->ctrl | extra_flags);
1239 +
1240 + des_hw_set_key(uctx->key, uctx->key_len);
1241 + des_hw_cipher(out, in);
1242 +
1243 + hw_crypto_unlock();
1244 +}
1245 +
1246 +static void des_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
1247 +{
1248 + des_cipher_1b(tfm, out, in, SEC_DIR_ENCRYPT);
1249 +}
1250 +
1251 +static void des_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
1252 +{
1253 + des_cipher_1b(tfm, out, in, SEC_DIR_DECRYPT);
1254 +}
1255 +
1256 +static struct crypto_alg des_alg = {
1257 + .cra_name = "des",
1258 + .cra_driver_name = "des-ubicom32",
1259 + .cra_priority = CRYPTO_UBICOM32_PRIORITY,
1260 + .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
1261 + .cra_blocksize = DES_BLOCK_SIZE,
1262 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1263 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1264 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1265 + .cra_module = THIS_MODULE,
1266 + .cra_list = LIST_HEAD_INIT(des_alg.cra_list),
1267 + .cra_u = {
1268 + .cipher = {
1269 + .cia_min_keysize = DES_KEY_SIZE,
1270 + .cia_max_keysize = DES_KEY_SIZE,
1271 + .cia_setkey = des_setkey,
1272 + .cia_encrypt = des_encrypt,
1273 + .cia_decrypt = des_decrypt,
1274 + }
1275 + }
1276 +};
1277 +
1278 +static void ecb_des_ciper_loop(u8 *out, u8 *in, unsigned int n)
1279 +{
1280 + while (likely(n)) {
1281 + des_hw_cipher(out, in);
1282 + out += DES_BLOCK_SIZE;
1283 + in += DES_BLOCK_SIZE;
1284 + n -= DES_BLOCK_SIZE;
1285 + }
1286 +}
1287 +
1288 +static void ecb_des3_ede_encrypt_loop(u8 *keys, u8 *out, u8 *in, unsigned int n)
1289 +{
1290 + while (likely(n)) {
1291 + des3_hw_ede_encrypt(keys, out, in);
1292 +
1293 + out += DES_BLOCK_SIZE;
1294 + in += DES_BLOCK_SIZE;
1295 + n -= DES_BLOCK_SIZE;
1296 + }
1297 +}
1298 +
1299 +static void ecb_des3_ede_decrypt_loop(u8 *keys, u8 *out, u8 *in, unsigned int n)
1300 +{
1301 + while (likely(n)) {
1302 + des3_hw_ede_decrypt(keys, out, in);
1303 +
1304 + out += DES_BLOCK_SIZE;
1305 + in += DES_BLOCK_SIZE;
1306 + n -= DES_BLOCK_SIZE;
1307 + }
1308 +}
1309 +
1310 +#ifdef DES3_EEE
1311 +static void ecb_des3_eee_encrypt_loop(u8 *keys, u8 *out, u8 *in, unsigned int n)
1312 +{
1313 + while (likely(n)) {
1314 + des3_hw_eee_encrypt(keys, out, in);
1315 +
1316 + out += DES_BLOCK_SIZE;
1317 + in += DES_BLOCK_SIZE;
1318 + n -= DES_BLOCK_SIZE;
1319 + }
1320 +}
1321 +
1322 +static void ecb_des3_eee_decrypt_loop(u8 *keys, u8 *out, u8 *in, unsigned int n)
1323 +{
1324 + while (likely(n)) {
1325 + des3_hw_eee_decrypt(keys, out, in);
1326 +
1327 + out += DES_BLOCK_SIZE;
1328 + in += DES_BLOCK_SIZE;
1329 + n -= DES_BLOCK_SIZE;
1330 + }
1331 +}
1332 +#endif
1333 +
1334 +static inline void ecb_des_cipher_n(struct ubicom32_des_ctx *uctx, enum des_ops op, u8 *out, u8 *in, unsigned int n)
1335 +{
1336 + switch (op) {
1337 + case DES_ENCRYPT:
1338 + case DES_DECRYPT:
1339 + /* set the right algo, direction and key once */
1340 + hw_crypto_set_ctrl(SEC_ALG_DES | (op == DES_ENCRYPT ? SEC_DIR_ENCRYPT : 0));
1341 + des_hw_set_key(uctx->key, uctx->key_len);
1342 + ecb_des_ciper_loop(out, in, n);
1343 + break;
1344 +
1345 + case DES3_EDE_ENCRYPT:
1346 + ecb_des3_ede_encrypt_loop(uctx->key, out, in, n);
1347 + break;
1348 +
1349 + case DES3_EDE_DECRYPT:
1350 + ecb_des3_ede_decrypt_loop(uctx->key, out, in, n);
1351 + break;
1352 +
1353 +#ifdef DES3_EEE
1354 + case DES3_EEE_ENCRYPT:
1355 + ecb_des3_eee_encrypt_loop(uctx->key, out, in, n);
1356 + break;
1357 +
1358 + case DES3_EEE_DECRYPT:
1359 + ecb_des3_eee_decrypt_loop(uctx->key, out, in, n);
1360 + break;
1361 +#endif
1362 + }
1363 +}
1364 +
1365 +static inline void des_xor_2w(u32 *data, u32 *iv)
1366 +{
1367 + data[0] ^= iv[0];
1368 + data[1] ^= iv[1];
1369 +}
1370 +
1371 +static void cbc_des_encrypt_loop(u8 *out, u8 *in, u8 *iv, unsigned int n)
1372 +{
1373 + while (likely(n)) {
1374 + des_xor_2w((u32 *)in, (u32 *)iv);
1375 + des_hw_cipher(out, in);
1376 + SEC_COPY_2W(iv, out);
1377 + out += DES_BLOCK_SIZE;
1378 + in += DES_BLOCK_SIZE;
1379 + n -= DES_BLOCK_SIZE;
1380 + }
1381 +}
1382 +
1383 +static void cbc_des_decrypt_loop(u8 *out, u8 *in, u8 *iv, unsigned int n)
1384 +{
1385 + u8 next_iv[DES_BLOCK_SIZE];
1386 + while (likely(n)) {
1387 + SEC_COPY_2W(next_iv, in);
1388 + des_hw_cipher(out, in);
1389 + des_xor_2w((u32 *)out, (u32 *)iv);
1390 + SEC_COPY_2W(iv, next_iv);
1391 +
1392 + out += DES_BLOCK_SIZE;
1393 + in += DES_BLOCK_SIZE;
1394 + n -= DES_BLOCK_SIZE;
1395 + }
1396 +}
1397 +
1398 +static void cbc_des3_ede_encrypt_loop(u8 *keys, u8 *out, u8 *in, u8 *iv, unsigned int n)
1399 +{
1400 + while (likely(n)) {
1401 + des_xor_2w((u32 *)in, (u32 *)iv);
1402 + des3_hw_ede_encrypt(keys, out, in);
1403 + SEC_COPY_2W(iv, out);
1404 +
1405 + out += DES_BLOCK_SIZE;
1406 + in += DES_BLOCK_SIZE;
1407 + n -= DES_BLOCK_SIZE;
1408 + }
1409 +}
1410 +
1411 +static void cbc_des3_ede_decrypt_loop(u8 *keys, u8 *out, u8 *in, u8 *iv, unsigned int n)
1412 +{
1413 + u8 next_iv[DES_BLOCK_SIZE];
1414 + while (likely(n)) {
1415 + SEC_COPY_2W(next_iv, in);
1416 + des3_hw_ede_decrypt(keys, out, in);
1417 + des_xor_2w((u32 *)out, (u32 *)iv);
1418 + SEC_COPY_2W(iv, next_iv);
1419 +
1420 + out += DES_BLOCK_SIZE;
1421 + in += DES_BLOCK_SIZE;
1422 + n -= DES_BLOCK_SIZE;
1423 + }
1424 +}
1425 +
1426 +#ifdef DES3_EEE
1427 +static void cbc_des3_eee_encrypt_loop(u8 *keys, u8 *out, u8 *in, u8 *iv, unsigned int n)
1428 +{
1429 + while (likely(n)) {
1430 + des_xor_2w((u32 *)in, (u32 *)iv);
1431 + des3_hw_eee_encrypt(keys, out, in);
1432 + SEC_COPY_2W(iv, out);
1433 +
1434 + out += DES_BLOCK_SIZE;
1435 + in += DES_BLOCK_SIZE;
1436 + n -= DES_BLOCK_SIZE;
1437 + }
1438 +}
1439 +
1440 +static void cbc_des3_eee_decrypt_loop(u8 *keys, u8 *out, u8 *in, u8 *iv, unsigned int n)
1441 +{
1442 + u8 next_iv[DES_BLOCK_SIZE];
1443 + while (likely(n)) {
1444 + SEC_COPY_2W(next_iv, in);
1445 + des3_hw_eee_decrypt(keys, out, in);
1446 + des_xor_2w((u32 *)out, (u32 *)iv);
1447 + SEC_COPY_2W(iv, next_iv);
1448 +
1449 + out += DES_BLOCK_SIZE;
1450 + in += DES_BLOCK_SIZE;
1451 + n -= DES_BLOCK_SIZE;
1452 + }
1453 +}
1454 +#endif
1455 +
1456 +static inline void cbc_des_cipher_n(struct ubicom32_des_ctx *uctx, enum des_ops op, u8 *out, u8 *in, u8 *iv, unsigned int n)
1457 +{
1458 + switch (op) {
1459 + case DES_ENCRYPT:
1460 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_ENCRYPT);
1461 + des_hw_set_key(uctx->key, uctx->key_len);
1462 + cbc_des_encrypt_loop(out, in, iv, n);
1463 + break;
1464 +
1465 + case DES_DECRYPT:
1466 + /* set the right algo, direction and key once */
1467 + hw_crypto_set_ctrl(SEC_ALG_DES | SEC_DIR_DECRYPT);
1468 + des_hw_set_key(uctx->key, uctx->key_len);
1469 + cbc_des_decrypt_loop(out, in, iv, n);
1470 + break;
1471 +
1472 + case DES3_EDE_ENCRYPT:
1473 + cbc_des3_ede_encrypt_loop(uctx->key, out, in, iv, n);
1474 + break;
1475 +
1476 + case DES3_EDE_DECRYPT:
1477 + cbc_des3_ede_decrypt_loop(uctx->key, out, in, iv, n);
1478 + break;
1479 +
1480 +#ifdef DES3_EEE
1481 + case DES3_EEE_ENCRYPT:
1482 + cbc_des3_eee_encrypt_loop(uctx->key, out, in, iv, n);
1483 + break;
1484 +
1485 + case DES3_EEE_DECRYPT:
1486 + cbc_des3_eee_decrypt_loop(uctx->key, out, in, iv, n);
1487 + break;
1488 +#endif
1489 + }
1490 +}
1491 +
1492 +static int des_cipher(struct blkcipher_desc *desc, struct scatterlist *dst,
1493 + struct scatterlist *src, unsigned int nbytes, u32 extra_flags, enum des_ops op)
1494 +{
1495 + struct ubicom32_des_ctx *uctx = crypto_blkcipher_ctx(desc->tfm);
1496 + int ret;
1497 +
1498 + struct blkcipher_walk walk;
1499 + blkcipher_walk_init(&walk, dst, src, nbytes);
1500 + ret = blkcipher_walk_virt(desc, &walk);
1501 + if (ret) {
1502 + return ret;
1503 + }
1504 +
1505 + hw_crypto_lock();
1506 + hw_crypto_check();
1507 +
1508 + while ((nbytes = walk.nbytes)) {
1509 + /* only use complete blocks */
1510 + unsigned int n = nbytes & ~(DES_BLOCK_SIZE - 1);
1511 + u8 *out = walk.dst.virt.addr;
1512 + u8 *in = walk.src.virt.addr;
1513 +
1514 + /* finish n/16 blocks */
1515 + if (extra_flags & SEC_CBC_SET) {
1516 + cbc_des_cipher_n(uctx, op, out, in, walk.iv, n);
1517 + } else {
1518 + ecb_des_cipher_n(uctx, op, out, in, n);
1519 + }
1520 +
1521 + nbytes &= DES_BLOCK_SIZE - 1;
1522 + ret = blkcipher_walk_done(desc, &walk, nbytes);
1523 + }
1524 +
1525 + hw_crypto_unlock();
1526 + return ret;
1527 +}
1528 +
1529 +static int ecb_des_encrypt(struct blkcipher_desc *desc,
1530 + struct scatterlist *dst, struct scatterlist *src,
1531 + unsigned int nbytes)
1532 +{
1533 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_NONE, DES_ENCRYPT);
1534 +}
1535 +
1536 +static int ecb_des_decrypt(struct blkcipher_desc *desc,
1537 + struct scatterlist *dst, struct scatterlist *src,
1538 + unsigned int nbytes)
1539 +{
1540 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_NONE, DES_DECRYPT);
1541 +}
1542 +
1543 +static struct crypto_alg ecb_des_alg = {
1544 + .cra_name = "ecb(des)",
1545 + .cra_driver_name = "ecb-des-ubicom32",
1546 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
1547 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
1548 + .cra_blocksize = DES_BLOCK_SIZE,
1549 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1550 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1551 + .cra_type = &crypto_blkcipher_type,
1552 + .cra_module = THIS_MODULE,
1553 + .cra_list = LIST_HEAD_INIT(ecb_des_alg.cra_list),
1554 + .cra_u = {
1555 + .blkcipher = {
1556 + .min_keysize = DES_KEY_SIZE,
1557 + .max_keysize = DES_KEY_SIZE,
1558 + .setkey = des_setkey,
1559 + .encrypt = ecb_des_encrypt,
1560 + .decrypt = ecb_des_decrypt,
1561 + }
1562 + }
1563 +};
1564 +
1565 +static int cbc_des_encrypt(struct blkcipher_desc *desc,
1566 + struct scatterlist *dst, struct scatterlist *src,
1567 + unsigned int nbytes)
1568 +{
1569 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_SET, DES_ENCRYPT);
1570 +}
1571 +
1572 +static int cbc_des_decrypt(struct blkcipher_desc *desc,
1573 + struct scatterlist *dst, struct scatterlist *src,
1574 + unsigned int nbytes)
1575 +{
1576 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_SET, DES_DECRYPT);
1577 +}
1578 +
1579 +static struct crypto_alg cbc_des_alg = {
1580 + .cra_name = "cbc(des)",
1581 + .cra_driver_name = "cbc-des-ubicom32",
1582 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
1583 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
1584 + .cra_blocksize = DES_BLOCK_SIZE,
1585 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1586 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1587 + .cra_type = &crypto_blkcipher_type,
1588 + .cra_module = THIS_MODULE,
1589 + .cra_list = LIST_HEAD_INIT(cbc_des_alg.cra_list),
1590 + .cra_u = {
1591 + .blkcipher = {
1592 + .min_keysize = DES_KEY_SIZE,
1593 + .max_keysize = DES_KEY_SIZE,
1594 + .ivsize = DES_BLOCK_SIZE,
1595 + .setkey = des_setkey,
1596 + .encrypt = cbc_des_encrypt,
1597 + .decrypt = cbc_des_decrypt,
1598 + }
1599 + }
1600 +};
1601 +
1602 +/*
1603 + * RFC2451:
1604 + *
1605 + * For DES-EDE3, there is no known need to reject weak or
1606 + * complementation keys. Any weakness is obviated by the use of
1607 + * multiple keys.
1608 + *
1609 + * However, if the first two or last two independent 64-bit keys are
1610 + * equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
1611 + * same as DES. Implementers MUST reject keys that exhibit this
1612 + * property.
1613 + *
1614 + */
1615 +static int des3_192_setkey(struct crypto_tfm *tfm, const u8 *key,
1616 + unsigned int keylen)
1617 +{
1618 + int i, ret;
1619 + struct ubicom32_des_ctx *dctx = crypto_tfm_ctx(tfm);
1620 + const u8 *temp_key = key;
1621 + u32 *flags = &tfm->crt_flags;
1622 +
1623 + if (!(memcmp(key, &key[DES_KEY_SIZE], DES_KEY_SIZE) &&
1624 + memcmp(&key[DES_KEY_SIZE], &key[DES_KEY_SIZE * 2],
1625 + DES_KEY_SIZE))) {
1626 +
1627 + *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
1628 + return -EINVAL;
1629 + }
1630 + for (i = 0; i < 3; i++, temp_key += DES_KEY_SIZE) {
1631 + ret = crypto_des_check_key(temp_key, DES_KEY_SIZE, flags);
1632 + if (ret < 0)
1633 + return ret;
1634 + }
1635 + memcpy(dctx->key, key, keylen);
1636 + dctx->ctrl = SEC_ALG_DES; //hw 3DES not working yet
1637 + dctx->key_len = keylen;
1638 + return 0;
1639 +}
1640 +
1641 +static void des3_192_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
1642 +{
1643 + struct ubicom32_des_ctx *uctx = crypto_tfm_ctx(tfm);
1644 +
1645 + hw_crypto_lock();
1646 + hw_crypto_check();
1647 +
1648 + des3_hw_ede_encrypt(uctx->key, dst, src);
1649 +
1650 + hw_crypto_unlock();
1651 +}
1652 +
1653 +static void des3_192_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
1654 +{
1655 + struct ubicom32_des_ctx *uctx = crypto_tfm_ctx(tfm);
1656 +
1657 + hw_crypto_lock();
1658 + hw_crypto_check();
1659 +
1660 + des3_hw_ede_decrypt(uctx->key, dst, src);
1661 +
1662 + hw_crypto_unlock();
1663 +}
1664 +
1665 +static struct crypto_alg des3_192_alg = {
1666 + .cra_name = "des3_ede",
1667 + .cra_driver_name = "des3_ede-ubicom32",
1668 + .cra_priority = CRYPTO_UBICOM32_PRIORITY,
1669 + .cra_flags = CRYPTO_ALG_TYPE_CIPHER,
1670 + .cra_blocksize = DES3_192_BLOCK_SIZE,
1671 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1672 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1673 + .cra_module = THIS_MODULE,
1674 + .cra_list = LIST_HEAD_INIT(des3_192_alg.cra_list),
1675 + .cra_u = {
1676 + .cipher = {
1677 + .cia_min_keysize = DES3_192_KEY_SIZE,
1678 + .cia_max_keysize = DES3_192_KEY_SIZE,
1679 + .cia_setkey = des3_192_setkey,
1680 + .cia_encrypt = des3_192_encrypt,
1681 + .cia_decrypt = des3_192_decrypt,
1682 + }
1683 + }
1684 +};
1685 +
1686 +static int ecb_des3_192_encrypt(struct blkcipher_desc *desc,
1687 + struct scatterlist *dst,
1688 + struct scatterlist *src, unsigned int nbytes)
1689 +{
1690 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_NONE, DES3_EDE_ENCRYPT);
1691 +}
1692 +
1693 +static int ecb_des3_192_decrypt(struct blkcipher_desc *desc,
1694 + struct scatterlist *dst,
1695 + struct scatterlist *src, unsigned int nbytes)
1696 +{
1697 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_NONE, DES3_EDE_DECRYPT);
1698 +}
1699 +
1700 +static struct crypto_alg ecb_des3_192_alg = {
1701 + .cra_name = "ecb(des3_ede)",
1702 + .cra_driver_name = "ecb-des3_ede-ubicom32",
1703 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
1704 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
1705 + .cra_blocksize = DES3_192_BLOCK_SIZE,
1706 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1707 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1708 + .cra_type = &crypto_blkcipher_type,
1709 + .cra_module = THIS_MODULE,
1710 + .cra_list = LIST_HEAD_INIT(
1711 + ecb_des3_192_alg.cra_list),
1712 + .cra_u = {
1713 + .blkcipher = {
1714 + .min_keysize = DES3_192_KEY_SIZE,
1715 + .max_keysize = DES3_192_KEY_SIZE,
1716 + .setkey = des3_192_setkey,
1717 + .encrypt = ecb_des3_192_encrypt,
1718 + .decrypt = ecb_des3_192_decrypt,
1719 + }
1720 + }
1721 +};
1722 +
1723 +static int cbc_des3_192_encrypt(struct blkcipher_desc *desc,
1724 + struct scatterlist *dst,
1725 + struct scatterlist *src, unsigned int nbytes)
1726 +{
1727 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_SET, DES3_EDE_ENCRYPT);
1728 +}
1729 +
1730 +static int cbc_des3_192_decrypt(struct blkcipher_desc *desc,
1731 + struct scatterlist *dst,
1732 + struct scatterlist *src, unsigned int nbytes)
1733 +{
1734 + return des_cipher(desc, dst, src, nbytes, SEC_CBC_SET, DES3_EDE_DECRYPT);
1735 +}
1736 +
1737 +static struct crypto_alg cbc_des3_192_alg = {
1738 + .cra_name = "cbc(des3_ede)",
1739 + .cra_driver_name = "cbc-des3_ede-ubicom32",
1740 + .cra_priority = CRYPTO_UBICOM32_COMPOSITE_PRIORITY,
1741 + .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER,
1742 + .cra_blocksize = DES3_192_BLOCK_SIZE,
1743 + .cra_ctxsize = sizeof(struct ubicom32_des_ctx),
1744 + .cra_alignmask = CRYPTO_UBICOM32_ALIGNMENT - 1,
1745 + .cra_type = &crypto_blkcipher_type,
1746 + .cra_module = THIS_MODULE,
1747 + .cra_list = LIST_HEAD_INIT(
1748 + cbc_des3_192_alg.cra_list),
1749 + .cra_u = {
1750 + .blkcipher = {
1751 + .min_keysize = DES3_192_KEY_SIZE,
1752 + .max_keysize = DES3_192_KEY_SIZE,
1753 + .ivsize = DES3_192_BLOCK_SIZE,
1754 + .setkey = des3_192_setkey,
1755 + .encrypt = cbc_des3_192_encrypt,
1756 + .decrypt = cbc_des3_192_decrypt,
1757 + }
1758 + }
1759 +};
1760 +
1761 +static int init(void)
1762 +{
1763 + int ret = 0;
1764 +
1765 + hw_crypto_init();
1766 +
1767 + ret = crypto_register_alg(&des_alg);
1768 + if (ret)
1769 + goto des_err;
1770 + ret = crypto_register_alg(&ecb_des_alg);
1771 + if (ret)
1772 + goto ecb_des_err;
1773 + ret = crypto_register_alg(&cbc_des_alg);
1774 + if (ret)
1775 + goto cbc_des_err;
1776 +
1777 + ret = crypto_register_alg(&des3_192_alg);
1778 + if (ret)
1779 + goto des3_192_err;
1780 + ret = crypto_register_alg(&ecb_des3_192_alg);
1781 + if (ret)
1782 + goto ecb_des3_192_err;
1783 + ret = crypto_register_alg(&cbc_des3_192_alg);
1784 + if (ret)
1785 + goto cbc_des3_192_err;
1786 +
1787 +out:
1788 + return ret;
1789 +
1790 +cbc_des3_192_err:
1791 + crypto_unregister_alg(&ecb_des3_192_alg);
1792 +ecb_des3_192_err:
1793 + crypto_unregister_alg(&des3_192_alg);
1794 +des3_192_err:
1795 + crypto_unregister_alg(&cbc_des_alg);
1796 +cbc_des_err:
1797 + crypto_unregister_alg(&ecb_des_alg);
1798 +ecb_des_err:
1799 + crypto_unregister_alg(&des_alg);
1800 +des_err:
1801 + goto out;
1802 +}
1803 +
1804 +static void __exit fini(void)
1805 +{
1806 + crypto_unregister_alg(&cbc_des3_192_alg);
1807 + crypto_unregister_alg(&ecb_des3_192_alg);
1808 + crypto_unregister_alg(&des3_192_alg);
1809 + crypto_unregister_alg(&cbc_des_alg);
1810 + crypto_unregister_alg(&ecb_des_alg);
1811 + crypto_unregister_alg(&des_alg);
1812 +}
1813 +
1814 +module_init(init);
1815 +module_exit(fini);
1816 +
1817 +MODULE_ALIAS("des");
1818 +MODULE_ALIAS("des3_ede");
1819 +
1820 +MODULE_LICENSE("GPL");
1821 +MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms");
1822 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/Makefile linux-2.6.30.10-ubi/arch/ubicom32/crypto/Makefile
1823 --- linux-2.6.30.10/arch/ubicom32/crypto/Makefile 1970-01-01 02:00:00.000000000 +0200
1824 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/Makefile 2009-12-11 11:45:11.000000000 +0200
1825 @@ -0,0 +1,36 @@
1826 +#
1827 +# arch/ubicom32/crypto/Makefile
1828 +# <TODO: Replace with short file description>
1829 +#
1830 +# (C) Copyright 2009, Ubicom, Inc.
1831 +#
1832 +# This file is part of the Ubicom32 Linux Kernel Port.
1833 +#
1834 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
1835 +# it and/or modify it under the terms of the GNU General Public License
1836 +# as published by the Free Software Foundation, either version 2 of the
1837 +# License, or (at your option) any later version.
1838 +#
1839 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
1840 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
1841 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
1842 +# the GNU General Public License for more details.
1843 +#
1844 +# You should have received a copy of the GNU General Public License
1845 +# along with the Ubicom32 Linux Kernel Port. If not,
1846 +# see <http://www.gnu.org/licenses/>.
1847 +#
1848 +# Ubicom32 implementation derived from (with many thanks):
1849 +# arch/m68knommu
1850 +# arch/blackfin
1851 +# arch/parisc
1852 +#
1853 +obj-$(CONFIG_CRYPTO_UBICOM32) += crypto_ubicom32.o
1854 +obj-$(CONFIG_CRYPTO_AES_UBICOM32) += aes_ubicom32.o
1855 +obj-$(CONFIG_CRYPTO_DES_UBICOM32) += des.o
1856 +obj-$(CONFIG_CRYPTO_MD5_UBICOM32) += md5.o
1857 +obj-$(CONFIG_CRYPTO_SHA1_UBICOM32) += sha1.o
1858 +
1859 +des-y := des_ubicom32.o des_check_key.o
1860 +md5-y := md5_ubicom32.o md5_ubicom32_asm.o
1861 +sha1-y := sha1_ubicom32.o
1862 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/md5_ubicom32_asm.S linux-2.6.30.10-ubi/arch/ubicom32/crypto/md5_ubicom32_asm.S
1863 --- linux-2.6.30.10/arch/ubicom32/crypto/md5_ubicom32_asm.S 1970-01-01 02:00:00.000000000 +0200
1864 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/md5_ubicom32_asm.S 2009-12-11 11:45:11.000000000 +0200
1865 @@ -0,0 +1,234 @@
1866 +/*
1867 + * arch/ubicom32/crypto/md5_ubicom32_asm.S
1868 + * MD5 (Message Digest 5) support for Ubicom32 v3 architecture
1869 + *
1870 + * (C) Copyright 2009, Ubicom, Inc.
1871 + *
1872 + * This file is part of the Ubicom32 Linux Kernel Port.
1873 + *
1874 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
1875 + * it and/or modify it under the terms of the GNU General Public License
1876 + * as published by the Free Software Foundation, either version 2 of the
1877 + * License, or (at your option) any later version.
1878 + *
1879 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
1880 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
1881 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
1882 + * the GNU General Public License for more details.
1883 + *
1884 + * You should have received a copy of the GNU General Public License
1885 + * along with the Ubicom32 Linux Kernel Port. If not,
1886 + * see <http://www.gnu.org/licenses/>.
1887 + *
1888 + * Ubicom32 implementation derived from (with many thanks):
1889 + * arch/m68knommu
1890 + * arch/blackfin
1891 + * arch/parisc
1892 + */
1893 +
1894 +#define __ASM__
1895 +#include <asm/ip5000.h>
1896 +
1897 +#ifndef RP
1898 +#define RP A5
1899 +#endif
1900 +
1901 +;*****************************************************************************************
1902 +; The function prototypes
1903 +;*****************************************************************************************
1904 +; void md5_ip5k_init(void)
1905 +; void md5_ip5k_transform(u32_t *data_input)
1906 +; void md5_get_digest(u32_t *digest)
1907 +
1908 +;*****************************************************************************************
1909 +; Inputs
1910 +;*****************************************************************************************;
1911 +; data_input is the pointer to the block of data over which the digest will be calculated.
1912 +; It should be word aligned.
1913 +;
1914 +; digest is the pointer to the block of data into which the digest (the output) will be written.
1915 +; It should be word aligned.
1916 +;
1917 +
1918 +;*****************************************************************************************
1919 +; Outputs
1920 +;*****************************************************************************************
1921 +; None
1922 +
1923 +;*****************************************************************************************
1924 +; An: Address Registers
1925 +;*****************************************************************************************
1926 +#define an_digest A3
1927 +#define an_data_input A3
1928 +#define an_security_block A4
1929 +
1930 +;*****************************************************************************************
1931 +; Hash Constants
1932 +;*****************************************************************************************
1933 +#define HASH_MD5_IN0 0x01234567
1934 +#define HASH_MD5_IN1 0x89abcdef
1935 +#define HASH_MD5_IN2 0xfedcba98
1936 +#define HASH_MD5_IN3 0x76543210
1937 +
1938 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION 2
1939 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_MD5 ((1 << 4) | HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION)
1940 +
1941 +;*****************************************************************************************
1942 +; Hash related defines
1943 +;*****************************************************************************************
1944 +#define hash_control 0x00(an_security_block)
1945 +#define hash_control_low 0x02(an_security_block)
1946 +#define hash_status 0x04(an_security_block)
1947 +
1948 +#define hash_input_0 0x30(an_security_block)
1949 +#define hash_input_1 0x34(an_security_block)
1950 +#define hash_input_2 0x38(an_security_block)
1951 +#define hash_input_3 0x3c(an_security_block)
1952 +#define hash_input_4 0x40(an_security_block)
1953 +
1954 +#define hash_output_0 0x70(an_security_block)
1955 +#define hash_output_0_low 0x72(an_security_block)
1956 +#define hash_output_1 0x74(an_security_block)
1957 +#define hash_output_1_low 0x76(an_security_block)
1958 +#define hash_output_2 0x78(an_security_block)
1959 +#define hash_output_2_low 0x7a(an_security_block)
1960 +#define hash_output_3 0x7c(an_security_block)
1961 +#define hash_output_3_low 0x7e(an_security_block)
1962 +
1963 +;*****************************************************************************************
1964 +; Assembly macros
1965 +;*****************************************************************************************
1966 + ; C compiler reserves RP (A5) for return address during subroutine call.
1967 + ; Use RP to return to caller
1968 +.macro call_return_macro
1969 + calli RP, 0(RP)
1970 +.endm
1971 +
1972 +#if 0
1973 +;*****************************************************************************************
1974 +; void md5_ip5k_init(void)
1975 +; initialize the output registers of the hash module
1976 +;
1977 + ;.section .text.md5_ip5k_init,"ax",@progbits
1978 + .section .text
1979 + .global _md5_ip5k_init
1980 + .func md5_ip5k_init, _md5_ip5k_init
1981 +
1982 +_md5_ip5k_init:
1983 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
1984 +
1985 + movei hash_control, #%hi(HASH_SECURITY_BLOCK_CONTROL_INIT_MD5)
1986 + movei hash_control_low, #%lo(HASH_SECURITY_BLOCK_CONTROL_INIT_MD5)
1987 +
1988 + movei hash_output_0, #%hi(HASH_MD5_IN0)
1989 + movei hash_output_0_low, #%lo(HASH_MD5_IN0)
1990 +
1991 + movei hash_output_1, #%hi(HASH_MD5_IN1)
1992 + movei hash_output_1_low, #%lo(HASH_MD5_IN1)
1993 +
1994 + movei hash_output_2, #%hi(HASH_MD5_IN2)
1995 + movei hash_output_2_low, #%lo(HASH_MD5_IN2)
1996 +
1997 + movei hash_output_3, #%hi(HASH_MD5_IN3)
1998 + movei hash_output_3_low, #%lo(HASH_MD5_IN3)
1999 +
2000 + call_return_macro
2001 + .endfunc
2002 +#endif
2003 +
2004 +;*****************************************************************************************
2005 +; void md5_ip5k_init_digest(u32_t *hash_input)
2006 +; initialize the output registers of the hash module
2007 +
2008 + ;.section .text.md5_ip5k_init_digest,"ax",@progbits
2009 + .section .text
2010 + .global _md5_ip5k_init_digest
2011 + .func md5_ip5k_init_digest, _md5_ip5k_init_digest
2012 +
2013 +_md5_ip5k_init_digest:
2014 + movea an_data_input, D0
2015 +
2016 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2017 +
2018 + movei hash_control, #%hi(HASH_SECURITY_BLOCK_CONTROL_INIT_MD5)
2019 + movei hash_control_low, #%lo(HASH_SECURITY_BLOCK_CONTROL_INIT_MD5)
2020 +
2021 + move.4 hash_output_0, (an_data_input)4++
2022 + move.4 hash_output_1, (an_data_input)4++
2023 + move.4 hash_output_2, (an_data_input)4++
2024 + move.4 hash_output_3, (an_data_input)4++
2025 +
2026 + call_return_macro
2027 + .endfunc
2028 +
2029 +;*****************************************************************************************
2030 +; void md5_ip5k_transform(u32_t *data_input)
2031 +; performs intermediate transformation step for the hash calculation
2032 +;
2033 + ;.sect .text.md5_ip5k_transform,"ax",@progbits
2034 + .section .text
2035 + .global _md5_ip5k_transform
2036 + .func md5_ip5k_transform, _md5_ip5k_transform
2037 +
2038 +_md5_ip5k_transform:
2039 + movea an_data_input, D0
2040 +
2041 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2042 +
2043 + ; Write the first 128bits (16 bytes)
2044 + move.4 hash_input_0, (an_data_input)4++
2045 + move.4 hash_input_1, (an_data_input)4++
2046 + move.4 hash_input_2, (an_data_input)4++
2047 + move.4 hash_input_3, (an_data_input)4++
2048 + move.4 hash_input_4, D0
2049 +
2050 + move.4 hash_input_0, (an_data_input)4++
2051 + move.4 hash_input_1, (an_data_input)4++
2052 + move.4 hash_input_2, (an_data_input)4++
2053 + move.4 hash_input_3, (an_data_input)4++
2054 + move.4 hash_input_4, D0
2055 +
2056 + move.4 hash_input_0, (an_data_input)4++
2057 + move.4 hash_input_1, (an_data_input)4++
2058 + move.4 hash_input_2, (an_data_input)4++
2059 + move.4 hash_input_3, (an_data_input)4++
2060 + move.4 hash_input_4, D0
2061 +
2062 + move.4 hash_input_0, (an_data_input)4++
2063 + move.4 hash_input_1, (an_data_input)4++
2064 + move.4 hash_input_2, (an_data_input)4++
2065 + move.4 hash_input_3, (an_data_input)4++
2066 + move.4 hash_input_4, D0
2067 +
2068 + pipe_flush 0
2069 +
2070 +md5_ip5k_transform_wait:
2071 + ; wait for the module to calculate the output hash
2072 + btst hash_status, #0
2073 + jmpne.f md5_ip5k_transform_wait
2074 +
2075 + call_return_macro
2076 + .endfunc
2077 +
2078 +;*****************************************************************************************
2079 +; void md5_ip5k_get_digest(u32_t *digest)
2080 +; Return the hash of the input data
2081 +;
2082 + ;.sect .text.md5_get_digest,"ax",@progbits
2083 + .section .text
2084 + .global _md5_ip5k_get_digest
2085 + .func md5_ip5k_get_digest, _md5_ip5k_get_digest
2086 +
2087 +_md5_ip5k_get_digest:
2088 + movea an_digest, D0
2089 +
2090 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2091 +
2092 + ; we have finished
2093 + move.4 0(an_digest), hash_output_0
2094 + move.4 4(an_digest), hash_output_1
2095 + move.4 8(an_digest), hash_output_2
2096 + move.4 12(an_digest), hash_output_3
2097 +
2098 + call_return_macro
2099 + .endfunc
2100 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/md5_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/md5_ubicom32.c
2101 --- linux-2.6.30.10/arch/ubicom32/crypto/md5_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
2102 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/md5_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
2103 @@ -0,0 +1,200 @@
2104 +/*
2105 + * arch/ubicom32/crypto/md5_ubicom32.c
2106 + * Ubicom32 implementation of the MD5 Secure Hash Algorithm
2107 + *
2108 + * (C) Copyright 2009, Ubicom, Inc.
2109 + *
2110 + * This file is part of the Ubicom32 Linux Kernel Port.
2111 + *
2112 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
2113 + * it and/or modify it under the terms of the GNU General Public License
2114 + * as published by the Free Software Foundation, either version 2 of the
2115 + * License, or (at your option) any later version.
2116 + *
2117 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
2118 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
2119 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
2120 + * the GNU General Public License for more details.
2121 + *
2122 + * You should have received a copy of the GNU General Public License
2123 + * along with the Ubicom32 Linux Kernel Port. If not,
2124 + * see <http://www.gnu.org/licenses/>.
2125 + *
2126 + * Ubicom32 implementation derived from (with many thanks):
2127 + * arch/m68knommu
2128 + * arch/blackfin
2129 + * arch/parisc
2130 + */
2131 +#include <linux/init.h>
2132 +#include <linux/module.h>
2133 +#include <linux/crypto.h>
2134 +
2135 +#include "crypto_ubicom32.h"
2136 +
2137 +#define MD5_DIGEST_SIZE 16
2138 +#define MD5_BLOCK_SIZE 64
2139 +#define MD5_HASH_WORDS 4
2140 +
2141 +extern void _md5_ip5k_init_digest(u32_t *digest);
2142 +extern void _md5_ip5k_transform(u32_t *data_input);
2143 +extern void _md5_ip5k_get_digest(u32_t *digest);
2144 +
2145 +struct ubicom32_md5_ctx {
2146 + u64 count; /* message length */
2147 + u32 state[MD5_HASH_WORDS];
2148 + u8 buf[2 * MD5_BLOCK_SIZE];
2149 +};
2150 +
2151 +static void md5_init(struct crypto_tfm *tfm)
2152 +{
2153 + struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
2154 + mctx->state[0] = 0x01234567;
2155 + mctx->state[1] = 0x89abcdef;
2156 + mctx->state[2] = 0xfedcba98;
2157 + mctx->state[3] = 0x76543210;
2158 +
2159 + mctx->count = 0;
2160 +}
2161 +
2162 +static inline void _md5_process(u32 *digest, const u8 *data)
2163 +{
2164 + _md5_ip5k_transform((u32 *)data);
2165 +}
2166 +
2167 +static void md5_update(struct crypto_tfm *tfm, const u8 *data,
2168 + unsigned int len)
2169 +{
2170 + struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
2171 + int index, clen;
2172 +
2173 + /* how much is already in the buffer? */
2174 + index = mctx->count & 0x3f;
2175 +
2176 + mctx->count += len;
2177 +
2178 + if (index + len < MD5_BLOCK_SIZE) {
2179 + goto store_only;
2180 + }
2181 +
2182 + hw_crypto_lock();
2183 + hw_crypto_check();
2184 +
2185 + /* init digest set ctrl register too */
2186 + _md5_ip5k_init_digest(mctx->state);
2187 +
2188 + if (unlikely(index == 0 && SEC_ALIGNED(data))) {
2189 +fast_process:
2190 + while (len >= MD5_BLOCK_SIZE) {
2191 + _md5_process(mctx->state, data);
2192 + data += MD5_BLOCK_SIZE;
2193 + len -= MD5_BLOCK_SIZE;
2194 + }
2195 + goto store;
2196 + }
2197 +
2198 + /* process one stored block */
2199 + if (index) {
2200 + clen = MD5_BLOCK_SIZE - index;
2201 + memcpy(mctx->buf + index, data, clen);
2202 + _md5_process(mctx->state, mctx->buf);
2203 + data += clen;
2204 + len -= clen;
2205 + index = 0;
2206 + }
2207 +
2208 + if (likely(SEC_ALIGNED(data))) {
2209 + goto fast_process;
2210 + }
2211 +
2212 + /* process as many blocks as possible */
2213 + while (len >= MD5_BLOCK_SIZE) {
2214 + memcpy(mctx->buf, data, MD5_BLOCK_SIZE);
2215 + _md5_process(mctx->state, mctx->buf);
2216 + data += MD5_BLOCK_SIZE;
2217 + len -= MD5_BLOCK_SIZE;
2218 + }
2219 +
2220 +store:
2221 + _md5_ip5k_get_digest(mctx->state);
2222 + hw_crypto_unlock();
2223 +
2224 +store_only:
2225 + /* anything left? */
2226 + if (len)
2227 + memcpy(mctx->buf + index , data, len);
2228 +}
2229 +
2230 +/* Add padding and return the message digest. */
2231 +static void md5_final(struct crypto_tfm *tfm, u8 *out)
2232 +{
2233 + struct ubicom32_md5_ctx *mctx = crypto_tfm_ctx(tfm);
2234 + u32 bits[2];
2235 + unsigned int index, end;
2236 +
2237 + /* must perform manual padding */
2238 + index = mctx->count & 0x3f;
2239 + end = (index < 56) ? MD5_BLOCK_SIZE : (2 * MD5_BLOCK_SIZE);
2240 +
2241 + /* start pad with 1 */
2242 + mctx->buf[index] = 0x80;
2243 +
2244 + /* pad with zeros */
2245 + index++;
2246 + memset(mctx->buf + index, 0x00, end - index - 8);
2247 +
2248 + /* append message length */
2249 + bits[0] = mctx->count << 3;
2250 + bits[1] = mctx->count >> 29;
2251 + __cpu_to_le32s(bits);
2252 + __cpu_to_le32s(bits + 1);
2253 +
2254 + memcpy(mctx->buf + end - 8, &bits, sizeof(bits));
2255 +
2256 + /* force to use the mctx->buf and ignore the partial buf */
2257 + mctx->count = mctx->count & ~0x3f;
2258 + md5_update(tfm, mctx->buf, end);
2259 +
2260 + /* copy digest to out */
2261 + memcpy(out, mctx->state, MD5_DIGEST_SIZE);
2262 +
2263 + /* wipe context */
2264 + memset(mctx, 0, sizeof *mctx);
2265 +}
2266 +
2267 +static struct crypto_alg alg = {
2268 + .cra_name = "md5",
2269 + .cra_driver_name= "md5-ubicom32",
2270 + .cra_priority = CRYPTO_UBICOM32_PRIORITY,
2271 + .cra_flags = CRYPTO_ALG_TYPE_DIGEST,
2272 + .cra_blocksize = MD5_BLOCK_SIZE,
2273 + .cra_ctxsize = sizeof(struct ubicom32_md5_ctx),
2274 + .cra_module = THIS_MODULE,
2275 + .cra_list = LIST_HEAD_INIT(alg.cra_list),
2276 + .cra_u = {
2277 + .digest = {
2278 + .dia_digestsize = MD5_DIGEST_SIZE,
2279 + .dia_init = md5_init,
2280 + .dia_update = md5_update,
2281 + .dia_final = md5_final,
2282 + }
2283 + }
2284 +};
2285 +
2286 +static int __init init(void)
2287 +{
2288 + hw_crypto_init();
2289 + return crypto_register_alg(&alg);
2290 +}
2291 +
2292 +static void __exit fini(void)
2293 +{
2294 + crypto_unregister_alg(&alg);
2295 +}
2296 +
2297 +module_init(init);
2298 +module_exit(fini);
2299 +
2300 +MODULE_ALIAS("md5");
2301 +
2302 +MODULE_LICENSE("GPL");
2303 +MODULE_DESCRIPTION("MD5 Secure Hash Algorithm");
2304 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/sha1_ubicom32_asm.S linux-2.6.30.10-ubi/arch/ubicom32/crypto/sha1_ubicom32_asm.S
2305 --- linux-2.6.30.10/arch/ubicom32/crypto/sha1_ubicom32_asm.S 1970-01-01 02:00:00.000000000 +0200
2306 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/sha1_ubicom32_asm.S 2009-12-11 11:45:11.000000000 +0200
2307 @@ -0,0 +1,244 @@
2308 +/*
2309 + * arch/ubicom32/crypto/sha1_ubicom32_asm.S
2310 + * SHA1 hash support for Ubicom32 architecture V3.
2311 + *
2312 + * (C) Copyright 2009, Ubicom, Inc.
2313 + *
2314 + * This file is part of the Ubicom32 Linux Kernel Port.
2315 + *
2316 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
2317 + * it and/or modify it under the terms of the GNU General Public License
2318 + * as published by the Free Software Foundation, either version 2 of the
2319 + * License, or (at your option) any later version.
2320 + *
2321 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
2322 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
2323 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
2324 + * the GNU General Public License for more details.
2325 + *
2326 + * You should have received a copy of the GNU General Public License
2327 + * along with the Ubicom32 Linux Kernel Port. If not,
2328 + * see <http://www.gnu.org/licenses/>.
2329 + *
2330 + * Ubicom32 implementation derived from (with many thanks):
2331 + * arch/m68knommu
2332 + * arch/blackfin
2333 + * arch/parisc
2334 + */
2335 +
2336 +#define __ASM__
2337 +#include <asm/ip5000.h>
2338 +
2339 +#ifndef RP
2340 +#define RP A5
2341 +#endif
2342 +
2343 +;*****************************************************************************************
2344 +; The function prototype
2345 +;*****************************************************************************************
2346 +; void sha1_ip5k_init(void)
2347 +; void sha1_ip5k_transform(u32_t *data_input)
2348 +; void sha1_ip5k_output(u32_t *digest)
2349 +
2350 +;*****************************************************************************************
2351 +; Inputs
2352 +;*****************************************************************************************
2353 +; data_input is the pointer to the block of data over which the digest will be calculated.
2354 +; It should be word aligned.
2355 +;
2356 +; digest is the pointer to the block of data into which the digest (the output) will be written.
2357 +; It should be word aligned.
2358 +;
2359 +
2360 +;*****************************************************************************************
2361 +; Outputs
2362 +;*****************************************************************************************
2363 +; None
2364 +
2365 +;*****************************************************************************************
2366 +; Hash Constants
2367 +;*****************************************************************************************
2368 +#define HASH_SHA1_IN0 0x67452301
2369 +#define HASH_SHA1_IN1 0xefcdab89
2370 +#define HASH_SHA1_IN2 0x98badcfe
2371 +#define HASH_SHA1_IN3 0x10325476
2372 +#define HASH_SHA1_IN4 0xc3d2e1f0
2373 +
2374 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION 2
2375 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1 ((1 << 5) | HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION)
2376 +
2377 +;*****************************************************************************************
2378 +; An: Address Registers
2379 +;*****************************************************************************************
2380 +#define an_digest a4
2381 +#define an_data_input a4
2382 +#define an_security_block a3
2383 +
2384 +;*****************************************************************************************
2385 +; Hash related defines
2386 +;*****************************************************************************************
2387 +#define hash_control 0x00(an_security_block)
2388 +#define hash_control_low 0x02(an_security_block)
2389 +#define hash_status 0x04(an_security_block)
2390 +
2391 +#define hash_input_0 0x30(an_security_block)
2392 +#define hash_input_1 0x34(an_security_block)
2393 +#define hash_input_2 0x38(an_security_block)
2394 +#define hash_input_3 0x3c(an_security_block)
2395 +#define hash_input_4 0x40(an_security_block)
2396 +
2397 +#define hash_output_0 0x70(an_security_block)
2398 +#define hash_output_0_low 0x72(an_security_block)
2399 +#define hash_output_1 0x74(an_security_block)
2400 +#define hash_output_1_low 0x76(an_security_block)
2401 +#define hash_output_2 0x78(an_security_block)
2402 +#define hash_output_2_low 0x7a(an_security_block)
2403 +#define hash_output_3 0x7c(an_security_block)
2404 +#define hash_output_3_low 0x7e(an_security_block)
2405 +#define hash_output_4 0x80(an_security_block)
2406 +#define hash_output_4_low 0x82(an_security_block)
2407 +
2408 +;*****************************************************************************************
2409 +; Assembly macros
2410 +;*****************************************************************************************
2411 + ; C compiler reserves RP (A5) for return address during subroutine call.
2412 + ; Use RP to return to caller
2413 +.macro call_return_macro
2414 + calli RP, 0(RP)
2415 +.endm
2416 +
2417 +;*****************************************************************************************
2418 +; void sha1_ip5k_init(void)
2419 +; initialize the output registers of the hash module
2420 +
2421 + ;.section .text.sha1_ip5k_init,"ax",@progbits
2422 + .section .ocm_text,"ax",@progbits
2423 + .global _sha1_ip5k_init
2424 + .func sha1_ip5k_init, _sha1_ip5k_init
2425 +
2426 +_sha1_ip5k_init:
2427 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2428 +
2429 + movei hash_control, #%hi(HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1)
2430 + movei hash_control_low, #%lo(HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1)
2431 +
2432 + movei hash_output_0, #%hi(HASH_SHA1_IN0)
2433 + movei hash_output_0_low, #%lo(HASH_SHA1_IN0)
2434 +
2435 + movei hash_output_1, #%hi(HASH_SHA1_IN1)
2436 + movei hash_output_1_low, #%lo(HASH_SHA1_IN1)
2437 +
2438 + movei hash_output_2, #%hi(HASH_SHA1_IN2)
2439 + movei hash_output_2_low, #%lo(HASH_SHA1_IN2)
2440 +
2441 + movei hash_output_3, #%hi(HASH_SHA1_IN3)
2442 + movei hash_output_3_low, #%lo(HASH_SHA1_IN3)
2443 +
2444 + movei hash_output_4, #%hi(HASH_SHA1_IN4)
2445 + movei hash_output_4_low, #%lo(HASH_SHA1_IN4)
2446 +
2447 + call_return_macro
2448 + .endfunc
2449 +
2450 +;*****************************************************************************************
2451 +; void sha1_ip5k_init_digest(u32_t *hash_input)
2452 +; initialize the output registers of the hash module
2453 +
2454 + ;.section .text.sha1_ip5k_init_digest,"ax",@progbits
2455 + .section .ocm_text,"ax",@progbits
2456 + .global _sha1_ip5k_init_digest
2457 + .func sha1_ip5k_init_digest, _sha1_ip5k_init_digest
2458 +
2459 +_sha1_ip5k_init_digest:
2460 + movea an_data_input, D0
2461 +
2462 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2463 +
2464 + movei hash_control, #%hi(HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1)
2465 + movei hash_control_low, #%lo(HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1)
2466 +
2467 + move.4 hash_output_0, (an_data_input)4++
2468 + move.4 hash_output_1, (an_data_input)4++
2469 + move.4 hash_output_2, (an_data_input)4++
2470 + move.4 hash_output_3, (an_data_input)4++
2471 + move.4 hash_output_4, (an_data_input)4++
2472 +
2473 + call_return_macro
2474 + .endfunc
2475 +
2476 +;*****************************************************************************************
2477 +; void sha1_ip5k_transform(u32_t *data_input)
2478 +; performs intermediate transformation step for the hash calculation
2479 +
2480 + ;.section .text.sha1_ip5k_transform,"ax",@progbits
2481 + .section .ocm_text,"ax",@progbits
2482 + .global _sha1_ip5k_transform
2483 + .func sha1_ip5k_transform, _sha1_ip5k_transform
2484 +
2485 +_sha1_ip5k_transform:
2486 + movea an_data_input, D0
2487 +
2488 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2489 +
2490 + ; Write the first 128bits (16 bytes)
2491 + move.4 hash_input_0, (an_data_input)4++
2492 + move.4 hash_input_1, (an_data_input)4++
2493 + move.4 hash_input_2, (an_data_input)4++
2494 + move.4 hash_input_3, (an_data_input)4++
2495 + move.4 hash_input_4, D0
2496 +
2497 + move.4 hash_input_0, (an_data_input)4++
2498 + move.4 hash_input_1, (an_data_input)4++
2499 + move.4 hash_input_2, (an_data_input)4++
2500 + move.4 hash_input_3, (an_data_input)4++
2501 + move.4 hash_input_4, D0
2502 +
2503 + move.4 hash_input_0, (an_data_input)4++
2504 + move.4 hash_input_1, (an_data_input)4++
2505 + move.4 hash_input_2, (an_data_input)4++
2506 + move.4 hash_input_3, (an_data_input)4++
2507 + move.4 hash_input_4, D0
2508 +
2509 + move.4 hash_input_0, (an_data_input)4++
2510 + move.4 hash_input_1, (an_data_input)4++
2511 + move.4 hash_input_2, (an_data_input)4++
2512 + move.4 hash_input_3, (an_data_input)4++
2513 + move.4 hash_input_4, D0
2514 +
2515 + pipe_flush 0
2516 +
2517 +sha1_ip5k_transform_wait:
2518 + ; wait for the module to calculate the output hash
2519 + btst hash_status, #0
2520 + jmpne.f sha1_ip5k_transform_wait
2521 +
2522 + call_return_macro
2523 + .endfunc
2524 +
2525 +;*****************************************************************************************
2526 +; void sha1_ip5k_output(u32_t *digest)
2527 +; Return the hash of the input data
2528 +
2529 + ;.section .text.sha1_ip5k_output,"ax",@progbits
2530 + .section .ocm_text,"ax",@progbits
2531 + .global _sha1_ip5k_output
2532 + .func sha1_ip5k_output, _sha1_ip5k_output
2533 +
2534 +_sha1_ip5k_output:
2535 + movea an_digest, D0
2536 +
2537 + moveai an_security_block, #SECURITY_BASE_EFFECTIVE_ADDRESS
2538 +
2539 + ; we have finished
2540 + move.4 0(an_digest), hash_output_0
2541 + move.4 4(an_digest), hash_output_1
2542 + move.4 8(an_digest), hash_output_2
2543 + move.4 12(an_digest), hash_output_3
2544 + move.4 16(an_digest), hash_output_4
2545 +
2546 + call_return_macro
2547 + .endfunc
2548 +
2549 +;*****************************************************************************************
2550 +;END ;End of program code
2551 +;*****************************************************************************************
2552 diff -ruN linux-2.6.30.10/arch/ubicom32/crypto/sha1_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/crypto/sha1_ubicom32.c
2553 --- linux-2.6.30.10/arch/ubicom32/crypto/sha1_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
2554 +++ linux-2.6.30.10-ubi/arch/ubicom32/crypto/sha1_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
2555 @@ -0,0 +1,354 @@
2556 +/*
2557 + * arch/ubicom32/crypto/sha1_ubicom32.c
2558 + * Ubicom32 implementation of the SHA1 Secure Hash Algorithm.
2559 + *
2560 + * (C) Copyright 2009, Ubicom, Inc.
2561 + *
2562 + * This file is part of the Ubicom32 Linux Kernel Port.
2563 + *
2564 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
2565 + * it and/or modify it under the terms of the GNU General Public License
2566 + * as published by the Free Software Foundation, either version 2 of the
2567 + * License, or (at your option) any later version.
2568 + *
2569 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
2570 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
2571 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
2572 + * the GNU General Public License for more details.
2573 + *
2574 + * You should have received a copy of the GNU General Public License
2575 + * along with the Ubicom32 Linux Kernel Port. If not,
2576 + * see <http://www.gnu.org/licenses/>.
2577 + *
2578 + * Ubicom32 implementation derived from (with many thanks):
2579 + * arch/m68knommu
2580 + * arch/blackfin
2581 + * arch/parisc
2582 + */
2583 +#include <linux/init.h>
2584 +#include <linux/module.h>
2585 +#include <linux/crypto.h>
2586 +#include <crypto/sha.h>
2587 +#include <asm/linkage.h>
2588 +
2589 +#include "crypto_ubicom32.h"
2590 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION 2
2591 +#define HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1 ((1 << 5) | HASH_SECURITY_BLOCK_CONTROL_INIT_NO_ENCYPTION)
2592 +
2593 +struct ubicom32_sha1_ctx {
2594 + u64 count; /* message length */
2595 + u32 state[5];
2596 + u8 buf[2 * SHA1_BLOCK_SIZE];
2597 +};
2598 +
2599 +static inline void sha1_clear_2ws(u8 *buf, int wc)
2600 +{
2601 + asm volatile (
2602 + "1: move.4 (%0)4++, #0 \n\t"
2603 + " move.4 (%0)4++, #0 \n\t"
2604 + " sub.4 %1, #2, %1 \n\t"
2605 + " jmple.f 1b \n\t"
2606 + :
2607 + : "a" (buf), "d" (wc)
2608 + : "cc"
2609 + );
2610 +}
2611 +
2612 +/* only wipe out count, state, and 1st half of buf - 9 bytes at most */
2613 +#define sha1_wipe_out(sctx) sha1_clear_2ws((u8 *)sctx, 2 + 5 + 16 - 2)
2614 +
2615 +static inline void sha1_init_digest(u32 *digest)
2616 +{
2617 + hw_crypto_set_ctrl(HASH_SECURITY_BLOCK_CONTROL_INIT_SHA1);
2618 + asm volatile (
2619 + " ; move digests to hash_output regs \n\t"
2620 + " move.4 0x70(%0), 0x0(%1) \n\t"
2621 + " move.4 0x74(%0), 0x4(%1) \n\t"
2622 + " move.4 0x78(%0), 0x8(%1) \n\t"
2623 + " move.4 0x7c(%0), 0xc(%1) \n\t"
2624 + " move.4 0x80(%0), 0x10(%1) \n\t"
2625 + :
2626 + : "a" (SEC_BASE), "a" (digest)
2627 + );
2628 +}
2629 +
2630 +static inline void sha1_transform_feed(const u8 *in)
2631 +{
2632 + asm volatile (
2633 + " ; write the 1st 16 bytes \n\t"
2634 + " move.4 0x30(%0), 0x0(%1) \n\t"
2635 + " move.4 0x34(%0), 0x4(%1) \n\t"
2636 + " move.4 0x38(%0), 0x8(%1) \n\t"
2637 + " move.4 0x3c(%0), 0xc(%1) \n\t"
2638 + " move.4 0x40(%0), %1 \n\t"
2639 + " ; write the 2nd 16 bytes \n\t"
2640 + " move.4 0x30(%0), 0x10(%1) \n\t"
2641 + " move.4 0x34(%0), 0x14(%1) \n\t"
2642 + " move.4 0x38(%0), 0x18(%1) \n\t"
2643 + " move.4 0x3c(%0), 0x1c(%1) \n\t"
2644 + " move.4 0x40(%0), %1 \n\t"
2645 + " ; write the 3rd 16 bytes \n\t"
2646 + " move.4 0x30(%0), 0x20(%1) \n\t"
2647 + " move.4 0x34(%0), 0x24(%1) \n\t"
2648 + " move.4 0x38(%0), 0x28(%1) \n\t"
2649 + " move.4 0x3c(%0), 0x2c(%1) \n\t"
2650 + " move.4 0x40(%0), %1 \n\t"
2651 + " ; write the 4th 16 bytes \n\t"
2652 + " move.4 0x30(%0), 0x30(%1) \n\t"
2653 + " move.4 0x34(%0), 0x34(%1) \n\t"
2654 + " move.4 0x38(%0), 0x38(%1) \n\t"
2655 + " move.4 0x3c(%0), 0x3c(%1) \n\t"
2656 + " move.4 0x40(%0), %1 \n\t"
2657 + " pipe_flush 0 \n\t"
2658 + :
2659 + : "a"(SEC_BASE), "a"(in)
2660 + );
2661 +}
2662 +
2663 +static inline void sha1_transform_wait(void)
2664 +{
2665 + asm volatile (
2666 + " btst 0x04(%0), #0 \n\t"
2667 + " jmpne.f -4 \n\t"
2668 + :
2669 + : "a"(SEC_BASE)
2670 + : "cc"
2671 + );
2672 +}
2673 +
2674 +static inline void sha1_output_digest(u32 *digest)
2675 +{
2676 + asm volatile (
2677 + " move.4 0x0(%1), 0x70(%0) \n\t"
2678 + " move.4 0x4(%1), 0x74(%0) \n\t"
2679 + " move.4 0x8(%1), 0x78(%0) \n\t"
2680 + " move.4 0xc(%1), 0x7c(%0) \n\t"
2681 + " move.4 0x10(%1), 0x80(%0) \n\t"
2682 + :
2683 + : "a" (SEC_BASE), "a" (digest)
2684 + );
2685 +}
2686 +
2687 +static __ocm_text void sha1_init(struct crypto_tfm *tfm)
2688 +{
2689 + struct ubicom32_sha1_ctx *sctx = crypto_tfm_ctx(tfm);
2690 +
2691 + sctx->state[0] = SHA1_H0;
2692 + sctx->state[1] = SHA1_H1;
2693 + sctx->state[2] = SHA1_H2;
2694 + sctx->state[3] = SHA1_H3;
2695 + sctx->state[4] = SHA1_H4;
2696 + sctx->count = 0;
2697 +}
2698 +
2699 +static void __ocm_text sha1_update(struct crypto_tfm *tfm, const u8 *data,
2700 + unsigned int len)
2701 +{
2702 + struct ubicom32_sha1_ctx *sctx = crypto_tfm_ctx(tfm);
2703 + int index, clen;
2704 +
2705 + /* how much is already in the buffer? */
2706 + index = sctx->count & 0x3f;
2707 +
2708 + sctx->count += len;
2709 +
2710 + if (index + len < SHA1_BLOCK_SIZE) {
2711 + goto store_only;
2712 + }
2713 +
2714 + hw_crypto_lock();
2715 + hw_crypto_check();
2716 +
2717 + /* init digest set ctrl register too */
2718 + sha1_init_digest(sctx->state);
2719 +
2720 + if (unlikely(index == 0 && SEC_ALIGNED(data))) {
2721 +fast_process:
2722 +#if CRYPTO_UBICOM32_LOOP_ASM
2723 + if (likely(len >= SHA1_BLOCK_SIZE)) {
2724 + register unsigned int cnt = len >> 6; // loop = len / 64;
2725 + sha1_transform_feed(data);
2726 + data += SHA1_BLOCK_SIZE;
2727 +
2728 + /* cnt is pre-decremented in the loop */
2729 + asm volatile (
2730 + "; while (--loop): work on 2nd block \n\t"
2731 + "1: add.4 %2, #-1, %2 \n\t"
2732 + " jmpeq.f 5f \n\t"
2733 + " \n\t"
2734 + " ; write the 1st 16 bytes \n\t"
2735 + " move.4 0x30(%1), (%0)4++ \n\t"
2736 + " move.4 0x34(%1), (%0)4++ \n\t"
2737 + " move.4 0x38(%1), (%0)4++ \n\t"
2738 + " move.4 0x3c(%1), (%0)4++ \n\t"
2739 + " ; can not kick off hw before it \n\t"
2740 + " ; is done with the prev block \n\t"
2741 + " \n\t"
2742 + " btst 0x04(%1), #0 \n\t"
2743 + " jmpne.f -4 \n\t"
2744 + " \n\t"
2745 + " ; tell hw to load 1st 16 bytes \n\t"
2746 + " move.4 0x40(%1), %2 \n\t"
2747 + " \n\t"
2748 + " ; write the 2nd 16 bytes \n\t"
2749 + " move.4 0x30(%1), (%0)4++ \n\t"
2750 + " move.4 0x34(%1), (%0)4++ \n\t"
2751 + " move.4 0x38(%1), (%0)4++ \n\t"
2752 + " move.4 0x3c(%1), (%0)4++ \n\t"
2753 + " move.4 0x40(%1), %2 \n\t"
2754 + " \n\t"
2755 + " ; write the 3rd 16 bytes \n\t"
2756 + " move.4 0x30(%1), (%0)4++ \n\t"
2757 + " move.4 0x34(%1), (%0)4++ \n\t"
2758 + " move.4 0x38(%1), (%0)4++ \n\t"
2759 + " move.4 0x3c(%1), (%0)4++ \n\t"
2760 + " move.4 0x40(%1), %2 \n\t"
2761 + " \n\t"
2762 + " ; write the 4th 16 bytes \n\t"
2763 + " move.4 0x30(%1), (%0)4++ \n\t"
2764 + " move.4 0x34(%1), (%0)4++ \n\t"
2765 + " move.4 0x38(%1), (%0)4++ \n\t"
2766 + " move.4 0x3c(%1), (%0)4++ \n\t"
2767 + " move.4 0x40(%1), %2 \n\t"
2768 + " \n\t"
2769 + "; no need flush, enough insts \n\t"
2770 + "; before next hw wait \n\t"
2771 + " \n\t"
2772 + "; go back to loop \n\t"
2773 + " jmpt 1b \n\t"
2774 + " \n\t"
2775 + "; wait hw for last block \n\t"
2776 + "5: btst 0x04(%1), #0 \n\t"
2777 + " jmpne.f -4 \n\t"
2778 + " \n\t"
2779 + : "+a" (data)
2780 + : "a"( SEC_BASE), "d" (cnt)
2781 + : "cc"
2782 + );
2783 +
2784 + len = len & (64 - 1);
2785 + }
2786 +#else
2787 + while (likely(len >= SHA1_BLOCK_SIZE)) {
2788 + sha1_transform_feed(data);
2789 + data += SHA1_BLOCK_SIZE;
2790 + len -= SHA1_BLOCK_SIZE;
2791 + sha1_transform_wait();
2792 + }
2793 +#endif
2794 + goto store;
2795 + }
2796 +
2797 + /* process one stored block */
2798 + if (index) {
2799 + clen = SHA1_BLOCK_SIZE - index;
2800 + memcpy(sctx->buf + index, data, clen);
2801 + sha1_transform_feed(sctx->buf);
2802 + data += clen;
2803 + len -= clen;
2804 + index = 0;
2805 + sha1_transform_wait();
2806 + }
2807 +
2808 + if (likely(SEC_ALIGNED(data))) {
2809 + goto fast_process;
2810 + }
2811 +
2812 + /* process as many blocks as possible */
2813 + if (likely(len >= SHA1_BLOCK_SIZE)) {
2814 + memcpy(sctx->buf, data, SHA1_BLOCK_SIZE);
2815 + do {
2816 + sha1_transform_feed(sctx->buf);
2817 + data += SHA1_BLOCK_SIZE;
2818 + len -= SHA1_BLOCK_SIZE;
2819 + if (likely(len >= SHA1_BLOCK_SIZE)) {
2820 + memcpy(sctx->buf, data, SHA1_BLOCK_SIZE);
2821 + sha1_transform_wait();
2822 + continue;
2823 + }
2824 + /* it is the last block */
2825 + sha1_transform_wait();
2826 + break;
2827 + } while (1);
2828 + }
2829 +
2830 +store:
2831 + sha1_output_digest(sctx->state);
2832 + hw_crypto_unlock();
2833 +
2834 +store_only:
2835 + /* anything left? */
2836 + if (len)
2837 + memcpy(sctx->buf + index , data, len);
2838 +}
2839 +
2840 +/* Add padding and return the message digest. */
2841 +static void __ocm_text sha1_final(struct crypto_tfm *tfm, u8 *out)
2842 +{
2843 + struct ubicom32_sha1_ctx *sctx = crypto_tfm_ctx(tfm);
2844 + u64 bits;
2845 + unsigned int index, end;
2846 +
2847 + /* must perform manual padding */
2848 + index = sctx->count & 0x3f;
2849 + end = (index < 56) ? SHA1_BLOCK_SIZE : (2 * SHA1_BLOCK_SIZE);
2850 +
2851 + /* start pad with 1 */
2852 + sctx->buf[index] = 0x80;
2853 +
2854 + /* pad with zeros */
2855 + index++;
2856 + memset(sctx->buf + index, 0x00, end - index - 8);
2857 +
2858 + /* append message length */
2859 + bits = sctx->count << 3 ;
2860 + SEC_COPY_2W(sctx->buf + end - 8, &bits);
2861 +
2862 + /* force to use the sctx->buf and ignore the partial buf */
2863 + sctx->count = sctx->count & ~0x3f;
2864 + sha1_update(tfm, sctx->buf, end);
2865 +
2866 + /* copy digest to out */
2867 + SEC_COPY_5W(out, sctx->state);
2868 +
2869 + /* wipe context */
2870 + sha1_wipe_out(sctx);
2871 +}
2872 +
2873 +static struct crypto_alg alg = {
2874 + .cra_name = "sha1",
2875 + .cra_driver_name= "sha1-ubicom32",
2876 + .cra_priority = CRYPTO_UBICOM32_PRIORITY,
2877 + .cra_flags = CRYPTO_ALG_TYPE_DIGEST,
2878 + .cra_blocksize = SHA1_BLOCK_SIZE,
2879 + .cra_ctxsize = sizeof(struct ubicom32_sha1_ctx),
2880 + .cra_module = THIS_MODULE,
2881 + .cra_list = LIST_HEAD_INIT(alg.cra_list),
2882 + .cra_u = {
2883 + .digest = {
2884 + .dia_digestsize = SHA1_DIGEST_SIZE,
2885 + .dia_init = sha1_init,
2886 + .dia_update = sha1_update,
2887 + .dia_final = sha1_final,
2888 + }
2889 + }
2890 +};
2891 +
2892 +static int __init init(void)
2893 +{
2894 + hw_crypto_init();
2895 + return crypto_register_alg(&alg);
2896 +}
2897 +
2898 +static void __exit fini(void)
2899 +{
2900 + crypto_unregister_alg(&alg);
2901 +}
2902 +
2903 +module_init(init);
2904 +module_exit(fini);
2905 +
2906 +MODULE_ALIAS("sha1");
2907 +
2908 +MODULE_LICENSE("GPL");
2909 +MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm");
2910 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/a.out.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/a.out.h
2911 --- linux-2.6.30.10/arch/ubicom32/include/asm/a.out.h 1970-01-01 02:00:00.000000000 +0200
2912 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/a.out.h 2009-12-11 11:45:11.000000000 +0200
2913 @@ -0,0 +1,47 @@
2914 +/*
2915 + * arch/ubicom32/include/asm/a.out.h
2916 + * Definitions for Ubicom32 a.out executable format.
2917 + *
2918 + * (C) Copyright 2009, Ubicom, Inc.
2919 + *
2920 + * This file is part of the Ubicom32 Linux Kernel Port.
2921 + *
2922 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
2923 + * it and/or modify it under the terms of the GNU General Public License
2924 + * as published by the Free Software Foundation, either version 2 of the
2925 + * License, or (at your option) any later version.
2926 + *
2927 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
2928 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
2929 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
2930 + * the GNU General Public License for more details.
2931 + *
2932 + * You should have received a copy of the GNU General Public License
2933 + * along with the Ubicom32 Linux Kernel Port. If not,
2934 + * see <http://www.gnu.org/licenses/>.
2935 + *
2936 + * Ubicom32 implementation derived from (with many thanks):
2937 + * arch/m68knommu
2938 + * arch/blackfin
2939 + * arch/parisc
2940 + */
2941 +#ifndef _ASM_UBICOM32_A_OUT_H
2942 +#define _ASM_UBICOM32_A_OUT_H
2943 +
2944 +struct exec
2945 +{
2946 + unsigned long a_info; /* Use macros N_MAGIC, etc for access */
2947 + unsigned a_text; /* length of text, in bytes */
2948 + unsigned a_data; /* length of data, in bytes */
2949 + unsigned a_bss; /* length of uninitialized data area for file, in bytes */
2950 + unsigned a_syms; /* length of symbol table data in file, in bytes */
2951 + unsigned a_entry; /* start address */
2952 + unsigned a_trsize; /* length of relocation info for text, in bytes */
2953 + unsigned a_drsize; /* length of relocation info for data, in bytes */
2954 +};
2955 +
2956 +#define N_TRSIZE(a) ((a).a_trsize)
2957 +#define N_DRSIZE(a) ((a).a_drsize)
2958 +#define N_SYMSIZE(a) ((a).a_syms)
2959 +
2960 +#endif /* _ASM_UBICOM32_A_OUT_H */
2961 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/atomic.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/atomic.h
2962 --- linux-2.6.30.10/arch/ubicom32/include/asm/atomic.h 1970-01-01 02:00:00.000000000 +0200
2963 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/atomic.h 2009-12-11 11:45:11.000000000 +0200
2964 @@ -0,0 +1,348 @@
2965 +/*
2966 + * arch/ubicom32/include/asm/atomic.h
2967 + * Atomic operations definitions for Ubicom32 architecture.
2968 + *
2969 + * (C) Copyright 2009, Ubicom, Inc.
2970 + *
2971 + * This file is part of the Ubicom32 Linux Kernel Port.
2972 + *
2973 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
2974 + * it and/or modify it under the terms of the GNU General Public License
2975 + * as published by the Free Software Foundation, either version 2 of the
2976 + * License, or (at your option) any later version.
2977 + *
2978 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
2979 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
2980 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
2981 + * the GNU General Public License for more details.
2982 + *
2983 + * You should have received a copy of the GNU General Public License
2984 + * along with the Ubicom32 Linux Kernel Port. If not,
2985 + * see <http://www.gnu.org/licenses/>.
2986 + *
2987 + * Ubicom32 implementation derived from (with many thanks):
2988 + * arch/m68knommu
2989 + * arch/blackfin
2990 + * arch/parisc
2991 + */
2992 +#ifndef _ASM_UBICOM32_ATOMIC_H
2993 +#define _ASM_UBICOM32_ATOMIC_H
2994 +
2995 +#include <asm/system.h>
2996 +#include <asm/ubicom32-common.h>
2997 +#include <asm/types.h>
2998 +
2999 +/*
3000 + * Most instructions on the Ubicom32 processor are atomic in that they
3001 + * execute in one clock cycle. However, Linux has several operations
3002 + * (e.g. compare and swap) which will require more than a single instruction
3003 + * to perform. To achieve this, the Ubicom32 processor uses a single
3004 + * global bit in a scratchpad register as a critical section lock. All
3005 + * atomic operations acquire this lock.
3006 + *
3007 + * NOTE: To AVOID DEADLOCK(s), the atomic lock must only be used for atomic
3008 + * operations or by the ldsr to avoid disabling a thread performing an atomic
3009 + * operation.
3010 + *
3011 + * Do not attempt to disable interrupts while holding the atomic operations
3012 + * lock or you will DEADLOCK the system.
3013 + */
3014 +
3015 +#define ATOMIC_INIT(i) { (i) }
3016 +
3017 +/*
3018 + * __atomic_add()
3019 + * Add i to v and return the result.
3020 + */
3021 +static inline void __atomic_add(int i, atomic_t *v)
3022 +{
3023 + atomic_t *vt = v;
3024 +
3025 + __atomic_lock_acquire();
3026 + vt->counter += i;
3027 + __atomic_lock_release();
3028 +}
3029 +
3030 +/*
3031 + * __atomic_sub()
3032 + * Subtract i from v and return the result.
3033 + */
3034 +static inline void __atomic_sub(int i, atomic_t *v)
3035 +{
3036 + atomic_t *vt = v;
3037 +
3038 + __atomic_lock_acquire();
3039 + vt->counter -= i;
3040 + __atomic_lock_release();
3041 +}
3042 +
3043 +/*
3044 + * __atomic_add_return()
3045 + * Add i to v and return the result.
3046 + *
3047 + * The implementation here looks rather odd because we appear to be doing
3048 + * the addition twice. In fact that's exactly what we're doing but with
3049 + * the ubicom32 instruction set we can do the inner load and add with two
3050 + * instructions whereas generating both the atomic result and the "ret"
3051 + * result requires three instructions. The second add is generally only as
3052 + * costly as a move instruction and in cases where we compare the result
3053 + * with a constant the compiler can fold two constant values and do a
3054 + * single instruction, thus saving an instruction overall!
3055 + *
3056 + * At the worst we save one instruction inside the atomic lock.
3057 + */
3058 +static inline int __atomic_add_return(int i, atomic_t *v)
3059 +{
3060 + int ret;
3061 + atomic_t *vt = v;
3062 +
3063 + __atomic_lock_acquire();
3064 + ret = vt->counter;
3065 + vt->counter = ret + i;
3066 + __atomic_lock_release();
3067 +
3068 + return ret + i;
3069 +}
3070 +
3071 +/*
3072 + * __atomic_sub_return()
3073 + * Subtract i from v and return the result.
3074 + *
3075 + * The implementation here looks rather odd because we appear to be doing
3076 + * the subtraction twice. In fact that's exactly what we're doing but with
3077 + * the ubicom32 instruction set we can do the inner load and sub with two
3078 + * instructions whereas generating both the atomic result and the "ret"
3079 + * result requires three instructions. The second sub is generally only as
3080 + * costly as a move instruction and in cases where we compare the result
3081 + * with a constant the compiler can fold two constant values and do a
3082 + * single instruction, thus saving an instruction overall!
3083 + *
3084 + * At the worst we save one instruction inside the atomic lock.
3085 + */
3086 +static inline int __atomic_sub_return(int i, atomic_t *v)
3087 +{
3088 + int ret;
3089 + atomic_t *vt = v;
3090 +
3091 + __atomic_lock_acquire();
3092 + ret = vt->counter;
3093 + vt->counter = ret - i;
3094 + __atomic_lock_release();
3095 +
3096 + return ret - i;
3097 +}
3098 +
3099 +/*
3100 + * PUBLIC API FOR ATOMIC!
3101 + */
3102 +#define atomic_add(i,v) (__atomic_add( ((int)i),(v)))
3103 +#define atomic_sub(i,v) (__atomic_sub( ((int)i),(v)))
3104 +#define atomic_inc(v) (__atomic_add( 1,(v)))
3105 +#define atomic_dec(v) (__atomic_sub( 1,(v)))
3106 +#define atomic_add_return(i,v) (__atomic_add_return( ((int)i),(v)))
3107 +#define atomic_sub_return(i,v) (__atomic_sub_return( ((int)i),(v)))
3108 +#define atomic_inc_return(v) (__atomic_add_return( 1,(v)))
3109 +#define atomic_dec_return(v) (__atomic_sub_return( 1,(v)))
3110 +#define atomic_inc_and_test(v) (atomic_inc_return(v) == 0)
3111 +#define atomic_dec_and_test(v) (atomic_dec_return(v) == 0)
3112 +#define atomic_add_negative(a, v) (atomic_add_return((a), (v)) < 0)
3113 +#define atomic_sub_and_test(i,v) (atomic_sub_return((i),(v)) == 0)
3114 +
3115 +/*
3116 + * atomic_read()
3117 + * Acquire the atomic lock and read the variable.
3118 + */
3119 +static inline int atomic_read(const atomic_t *v)
3120 +{
3121 + int ret;
3122 + const atomic_t *vt = v;
3123 +
3124 + __atomic_lock_acquire();
3125 + ret = vt->counter;
3126 + __atomic_lock_release();
3127 +
3128 + return ret;
3129 +}
3130 +
3131 +/*
3132 + * atomic_set()
3133 + * Acquire the atomic lock and set the variable.
3134 + */
3135 +static inline void atomic_set(atomic_t *v, int i)
3136 +{
3137 + atomic_t *vt = v;
3138 +
3139 + __atomic_lock_acquire();
3140 + vt->counter = i;
3141 + __atomic_lock_release();
3142 +}
3143 +
3144 +/*
3145 + * atomic_cmpxchg
3146 + * Acquire the atomic lock and exchange if current == old.
3147 + */
3148 +static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
3149 +{
3150 + int prev;
3151 + atomic_t *vt = v;
3152 +
3153 + __atomic_lock_acquire();
3154 + prev = vt->counter;
3155 + if (prev == old) {
3156 + vt->counter = new;
3157 + }
3158 + __atomic_lock_release();
3159 +
3160 + return prev;
3161 +}
3162 +
3163 +/*
3164 + * atomic_xchg()
3165 + * Acquire the atomic lock and exchange values.
3166 + */
3167 +static inline int atomic_xchg(atomic_t *v, int new)
3168 +{
3169 + int prev;
3170 + atomic_t *vt = v;
3171 +
3172 + __atomic_lock_acquire();
3173 + prev = vt->counter;
3174 + vt->counter = new;
3175 + __atomic_lock_release();
3176 +
3177 + return prev;
3178 +}
3179 +
3180 +/*
3181 + * atomic_add_unless()
3182 + * Acquire the atomic lock and add a unless the value is u.
3183 + */
3184 +static inline int atomic_add_unless(atomic_t *v, int a, int u)
3185 +{
3186 + int prev;
3187 + atomic_t *vt = v;
3188 +
3189 + __atomic_lock_acquire();
3190 + prev = vt->counter;
3191 + if (prev != u) {
3192 + vt->counter += a;
3193 + __atomic_lock_release();
3194 + return 1;
3195 + }
3196 +
3197 + __atomic_lock_release();
3198 + return 0;
3199 +}
3200 +
3201 +#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
3202 +
3203 +#include <asm-generic/atomic.h>
3204 +
3205 +/*
3206 + * The following is not a real function. The compiler should remove the function
3207 + * call as long as the user does not pass in a size that __xchg and __cmpxchg
3208 + * are not prepared for. If the user does pass in an unknown size, the user
3209 + * will get a link time error.
3210 + *
3211 + * The no return is to prevent a compiler error that can occur when dealing with
3212 + * uninitialized variables. Given that the function doesn't exist there is no
3213 + * net effect (and if it did it would not return).
3214 + */
3215 +extern void __xchg_called_with_bad_pointer(void) __attribute__((noreturn));
3216 +
3217 +/*
3218 + * __xchg()
3219 + * Xchange *ptr for x atomically.
3220 + *
3221 + * Must be both locally atomic and atomic on SMP. Ubicom32 does not have an
3222 + * atomic exchange instruction so we use the global atomic_lock.
3223 + */
3224 +static inline unsigned long __xchg(unsigned long x, volatile void *ptr, int size)
3225 +{
3226 + unsigned long ret;
3227 +
3228 + __atomic_lock_acquire();
3229 +
3230 + switch (size) {
3231 + case 1:
3232 + ret = *(volatile unsigned char *)ptr;
3233 + *(volatile unsigned char *)ptr = x;
3234 + break;
3235 +
3236 + case 2:
3237 + ret = *(volatile unsigned short *)ptr;
3238 + *(volatile unsigned short *)ptr = x;
3239 + break;
3240 +
3241 + case 4:
3242 + ret = *(volatile unsigned int *)ptr;
3243 + *(volatile unsigned int *)ptr = x;
3244 + break;
3245 +
3246 + default:
3247 + __xchg_called_with_bad_pointer();
3248 + break;
3249 + }
3250 + __atomic_lock_release();
3251 + return ret;
3252 +}
3253 +
3254 +#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
3255 +
3256 +/*
3257 + * __cmpxchg()
3258 + * Compare and Xchange *ptr for x atomically.
3259 + *
3260 + * Must be both locally atomic and atomic on SMP. Ubicom32 does not have an
3261 + * atomic exchange instruction so we use the global atomic_lock.
3262 + */
3263 +static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old, unsigned long next, int size)
3264 +{
3265 + unsigned long prev;
3266 +
3267 + __atomic_lock_acquire();
3268 + switch (size) {
3269 + case 1:
3270 + prev = *(u8 *)ptr;
3271 + if (prev == old) {
3272 + *(u8 *)ptr = (u8)next;
3273 + }
3274 + break;
3275 +
3276 + case 2:
3277 + prev = *(u16 *)ptr;
3278 + if (prev == old) {
3279 + *(u16 *)ptr = (u16)next;
3280 + }
3281 + break;
3282 +
3283 + case 4:
3284 + prev = *(u32 *)ptr;
3285 + if (prev == old) {
3286 + *(u32 *)ptr = (u32)next;
3287 + }
3288 + break;
3289 +
3290 + default:
3291 + __xchg_called_with_bad_pointer();
3292 + break;
3293 + }
3294 + __atomic_lock_release();
3295 + return prev;
3296 +}
3297 +
3298 +/*
3299 + * cmpxchg_local and cmpxchg64_local are atomic wrt current CPU. Always make
3300 + * them available.
3301 + */
3302 +#define cmpxchg_local(ptr, o, n) \
3303 + ((__typeof__(*(ptr)))__cmpxchg((ptr), (unsigned long)(o), (unsigned long)(n), sizeof(*(ptr))))
3304 +
3305 +#define cmpxchg(ptr, o, n) __cmpxchg((ptr), (o), (n), sizeof(*(ptr)))
3306 +
3307 +#define smp_mb__before_atomic_inc() asm volatile ("" : : : "memory")
3308 +#define smp_mb__after_atomic_inc() asm volatile ("" : : : "memory")
3309 +#define smp_mb__before_atomic_dec() asm volatile ("" : : : "memory")
3310 +#define smp_mb__after_atomic_dec() asm volatile ("" : : : "memory")
3311 +
3312 +#endif /* _ASM_UBICOM32_ATOMIC_H */
3313 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/audio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/audio.h
3314 --- linux-2.6.30.10/arch/ubicom32/include/asm/audio.h 1970-01-01 02:00:00.000000000 +0200
3315 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/audio.h 2009-12-11 11:45:11.000000000 +0200
3316 @@ -0,0 +1,40 @@
3317 +/*
3318 + * arch/ubicom32/include/asm/audio.h
3319 + * Audio include file
3320 + *
3321 + * (C) Copyright 2009, Ubicom, Inc.
3322 + *
3323 + * This file is part of the Ubicom32 Linux Kernel Port.
3324 + *
3325 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3326 + * it and/or modify it under the terms of the GNU General Public License
3327 + * as published by the Free Software Foundation, either version 2 of the
3328 + * License, or (at your option) any later version.
3329 + *
3330 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3331 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3332 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3333 + * the GNU General Public License for more details.
3334 + *
3335 + * You should have received a copy of the GNU General Public License
3336 + * along with the Ubicom32 Linux Kernel Port. If not,
3337 + * see <http://www.gnu.org/licenses/>.
3338 + */
3339 +
3340 +#ifndef _AUDIO_H
3341 +#define _AUDIO_H
3342 +
3343 +#include <asm/devtree.h>
3344 +#include <asm/audionode.h>
3345 +
3346 +/*
3347 + * Resource indices used to access IRQs via platform_get_resource
3348 + */
3349 +#define AUDIO_MEM_RESOURCE 0
3350 +#define AUDIO_TX_IRQ_RESOURCE 0
3351 +#define AUDIO_RX_IRQ_RESOURCE 1
3352 +
3353 +extern struct platform_device * __init audio_device_alloc(const char *driver_name, const char *node_name, const char *inst_name, int priv_size);
3354 +
3355 +#define audio_device_priv(pdev) (((struct ubi32pcm_platform_data *)(((struct platform_device *)(pdev))->dev.platform_data))->priv_data)
3356 +#endif
3357 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/audionode.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/audionode.h
3358 --- linux-2.6.30.10/arch/ubicom32/include/asm/audionode.h 1970-01-01 02:00:00.000000000 +0200
3359 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/audionode.h 2009-12-11 11:45:11.000000000 +0200
3360 @@ -0,0 +1,152 @@
3361 +/*
3362 + * audionode.h
3363 + * audionode and DMA descriptors
3364 + *
3365 + * Copyright \81© 2009 Ubicom Inc. <www.ubicom.com>. All rights reserved.
3366 + *
3367 + * This file contains confidential information of Ubicom, Inc. and your use of
3368 + * this file is subject to the Ubicom Software License Agreement distributed with
3369 + * this file. If you are uncertain whether you are an authorized user or to report
3370 + * any unauthorized use, please contact Ubicom, Inc. at +1-408-789-2200.
3371 + * Unauthorized reproduction or distribution of this file is subject to civil and
3372 + * criminal penalties.
3373 + *
3374 + */
3375 +#ifndef _AUDIONODE_H_
3376 +#define _AUDIONODE_H_
3377 +
3378 +#define AUDIO_INT_FLAG_MORE_SAMPLES 0x00000001
3379 +#define AUDIO_INT_FLAG_COMMAND 0x00000002
3380 +
3381 +/*
3382 + * Commands the Primary OS sends to the audio device
3383 + */
3384 +enum audio_command {
3385 + AUDIO_CMD_NONE,
3386 + AUDIO_CMD_START,
3387 + AUDIO_CMD_STOP,
3388 + AUDIO_CMD_PAUSE,
3389 + AUDIO_CMD_RESUME,
3390 + AUDIO_CMD_MUTE,
3391 + AUDIO_CMD_UNMUTE,
3392 + AUDIO_CMD_SETUP,
3393 + AUDIO_CMD_ENABLE,
3394 + AUDIO_CMD_DISABLE,
3395 +};
3396 +
3397 +/*
3398 + * Flag bits passed in the registers
3399 + */
3400 +#define CMD_START_FLAG_LE (1 << 0) /* Use Little Endian Mode */
3401 +
3402 +/*
3403 + * Status bits that audio device can set to indicate reason
3404 + * for interrupting the Primary OS
3405 + */
3406 +#define AUDIO_STATUS_PLAY_DMA0_REQUEST (1 << 0) /* Audio device needs samples in DMA0 for playback */
3407 +#define AUDIO_STATUS_PLAY_DMA1_REQUEST (1 << 1) /* Audio device needs samples in DMA1 for playback */
3408 +
3409 +struct audio_dma {
3410 + /*
3411 + * NOTE: The active flag shall only be SET by the producer and CLEARED
3412 + * by the consumer, NEVER the other way around. For playback, the
3413 + * Primary OS sets this flag and ipAudio clears it.
3414 + *
3415 + * The producer shall not modify the ptr or ctr fields when the transfer
3416 + * is marked as active, as these are used by the consumer to do the
3417 + * transfer.
3418 + */
3419 + volatile u32_t active; /* Nonzero if data in ptr/ctr ready to be transferred */
3420 + volatile void *ptr; /* Pointer to data to be transferred */
3421 + volatile u32_t ctr; /* Counter: number of data units to transfer */
3422 +};
3423 +
3424 +#define AUDIONODE_CAP_BE (1 << 0)
3425 +#define AUDIONODE_CAP_LE (1 << 1)
3426 +
3427 +#define AUDIONODE_VERSION 7
3428 +struct audio_node {
3429 + struct devtree_node dn;
3430 +
3431 + /*
3432 + * Version of this node
3433 + */
3434 + u32_t version;
3435 +
3436 + /*
3437 + * Pointer to the registers
3438 + */
3439 + struct audio_regs *regs;
3440 +};
3441 +
3442 +/*
3443 + * [OCM] Audio registers
3444 + * Registers exposed as part of our MMIO area
3445 + */
3446 +#define AUDIO_REGS_VERSION 7
3447 +struct audio_regs {
3448 + /*
3449 + * Version of this register set
3450 + */
3451 + u32_t version;
3452 +
3453 + /*
3454 + * Interrupt status
3455 + */
3456 + volatile u32_t int_status;
3457 +
3458 + /*
3459 + * Interrupt request
3460 + */
3461 + volatile u32_t int_req;
3462 +
3463 + /*
3464 + * Current IRQ being serviced
3465 + */
3466 + u32_t cur_irq;
3467 +
3468 + /*
3469 + * Maximum number of devices supported
3470 + */
3471 + u32_t max_devs;
3472 +
3473 + /*
3474 + * [DDR] Device registers for each of the devices
3475 + */
3476 + struct audio_dev_regs *adr;
3477 +};
3478 +
3479 +#define AUDIO_DEV_REGS_VERSION 2
3480 +struct audio_dev_regs {
3481 + u32_t version; /* Version of this register set */
3482 +
3483 + u8_t name[32]; /* Name of this driver */
3484 + u32_t caps; /* Capabilities of this driver */
3485 + const u32_t *sample_rates; /* Sample Rates supported by this driver */
3486 + u32_t n_sample_rates; /* Number of sample rates supported by this driver */
3487 + u32_t channel_mask; /* A bit set in a particular position means we support this channel configuration */
3488 + volatile u32_t int_flags; /* Reason for interrupting audio device */
3489 + volatile enum audio_command command; /* Command from Primary OS */
3490 + volatile u32_t flags; /* Flag bits for this command */
3491 + volatile u32_t channels; /* Number of channels */
3492 + volatile u32_t sample_rate; /* Sample rate */
3493 + volatile u32_t status; /* Status bits sent from ipAudio to Primary OS */
3494 + void *primary_os_buffer_ptr; /*
3495 + * Playback: Pointer to next sample to be removed from
3496 + * Primary OS sample buffer
3497 + * Capture: Pointer to where next sample will be inserted
3498 + * into Primary OS sample buffer
3499 + */
3500 +
3501 + /*
3502 + * These are the transfer requests. They are used in alternating
3503 + * order so that when ipAudio is processing one request, the
3504 + * Primary OS can fill in the other one.
3505 + *
3506 + * NOTE: The active bit shall always be SET by the producer and
3507 + * CLEARED by the consumer, NEVER the other way around.
3508 + */
3509 + struct audio_dma dma_xfer_requests[2];
3510 +};
3511 +
3512 +#endif
3513 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/auxvec.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/auxvec.h
3514 --- linux-2.6.30.10/arch/ubicom32/include/asm/auxvec.h 1970-01-01 02:00:00.000000000 +0200
3515 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/auxvec.h 2009-12-11 11:45:11.000000000 +0200
3516 @@ -0,0 +1,32 @@
3517 +/*
3518 + * arch/ubicom32/include/asm/auxvec.h
3519 + * Symbolic values for the entries in the auxiliary table
3520 + * put on the initial stack.
3521 + *
3522 + * (C) Copyright 2009, Ubicom, Inc.
3523 + *
3524 + * This file is part of the Ubicom32 Linux Kernel Port.
3525 + *
3526 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3527 + * it and/or modify it under the terms of the GNU General Public License
3528 + * as published by the Free Software Foundation, either version 2 of the
3529 + * License, or (at your option) any later version.
3530 + *
3531 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3532 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3533 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3534 + * the GNU General Public License for more details.
3535 + *
3536 + * You should have received a copy of the GNU General Public License
3537 + * along with the Ubicom32 Linux Kernel Port. If not,
3538 + * see <http://www.gnu.org/licenses/>.
3539 + *
3540 + * Ubicom32 implementation derived from (with many thanks):
3541 + * arch/m68knommu
3542 + * arch/blackfin
3543 + * arch/parisc
3544 + */
3545 +#ifndef _ASM_UBICOM32_AUXVEC_H
3546 +#define _ASM_UBICOM32_AUXVEC_H
3547 +
3548 +#endif /* _ASM_UBICOM32_AUXVEC_H */
3549 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/bitops.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bitops.h
3550 --- linux-2.6.30.10/arch/ubicom32/include/asm/bitops.h 1970-01-01 02:00:00.000000000 +0200
3551 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bitops.h 2009-12-11 11:45:11.000000000 +0200
3552 @@ -0,0 +1,172 @@
3553 +/*
3554 + * arch/ubicom32/include/asm/bitops.h
3555 + * Bit manipulation definitions for Ubicom32 architecture.
3556 + *
3557 + * (C) Copyright 2009, Ubicom, Inc.
3558 + *
3559 + * This file is part of the Ubicom32 Linux Kernel Port.
3560 + *
3561 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3562 + * it and/or modify it under the terms of the GNU General Public License
3563 + * as published by the Free Software Foundation, either version 2 of the
3564 + * License, or (at your option) any later version.
3565 + *
3566 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3567 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3568 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3569 + * the GNU General Public License for more details.
3570 + *
3571 + * You should have received a copy of the GNU General Public License
3572 + * along with the Ubicom32 Linux Kernel Port. If not,
3573 + * see <http://www.gnu.org/licenses/>.
3574 + *
3575 + * Ubicom32 implementation derived from (with many thanks):
3576 + * arch/m68knommu
3577 + * arch/blackfin
3578 + * arch/parisc
3579 + */
3580 +#ifndef _ASM_UBICOM32_BITOPS_H
3581 +#define _ASM_UBICOM32_BITOPS_H
3582 +
3583 +/*
3584 + * Copyright 1992, Linus Torvalds.
3585 + */
3586 +
3587 +#include <linux/compiler.h>
3588 +#include <asm/byteorder.h> /* swab32 */
3589 +
3590 +#ifdef __KERNEL__
3591 +
3592 +#ifndef _LINUX_BITOPS_H
3593 +#error only <linux/bitops.h> can be included directly
3594 +#endif
3595 +
3596 +#include <asm-generic/bitops/ffs.h>
3597 +#include <asm-generic/bitops/__ffs.h>
3598 +
3599 +#include <asm-generic/bitops/sched.h>
3600 +#include <asm-generic/bitops/ffz.h>
3601 +
3602 +#include <asm/ubicom32-common.h>
3603 +
3604 +static inline void set_bit(int bit, volatile unsigned long *p)
3605 +{
3606 + unsigned long mask = 1UL << (bit & 31);
3607 +
3608 + p += bit >> 5;
3609 +
3610 + __atomic_lock_acquire();
3611 + *p |= mask;
3612 + __atomic_lock_release();
3613 +}
3614 +
3615 +static inline void clear_bit(int bit, volatile unsigned long *p)
3616 +{
3617 + unsigned long mask = 1UL << (bit & 31);
3618 +
3619 + p += bit >> 5;
3620 +
3621 + __atomic_lock_acquire();
3622 + *p &= ~mask;
3623 + __atomic_lock_release();
3624 +}
3625 +
3626 +/*
3627 + * clear_bit() doesn't provide any barrier for the compiler.
3628 + */
3629 +#define smp_mb__before_clear_bit() barrier()
3630 +#define smp_mb__after_clear_bit() barrier()
3631 +
3632 +static inline void change_bit(int bit, volatile unsigned long *p)
3633 +{
3634 + unsigned long mask = 1UL << (bit & 31);
3635 +
3636 + p += bit >> 5;
3637 +
3638 + __atomic_lock_acquire();
3639 + *p ^= mask;
3640 + __atomic_lock_release();
3641 +}
3642 +
3643 +static inline int test_and_set_bit(int bit, volatile unsigned long *p)
3644 +{
3645 + unsigned int res;
3646 + unsigned long mask = 1UL << (bit & 31);
3647 +
3648 + p += bit >> 5;
3649 +
3650 + __atomic_lock_acquire();
3651 + res = *p;
3652 + *p = res | mask;
3653 + __atomic_lock_release();
3654 +
3655 + return res & mask;
3656 +}
3657 +
3658 +static inline int test_and_clear_bit(int bit, volatile unsigned long *p)
3659 +{
3660 + unsigned int res;
3661 + unsigned long mask = 1UL << (bit & 31);
3662 +
3663 + p += bit >> 5;
3664 +
3665 + __atomic_lock_acquire();
3666 + res = *p;
3667 + *p = res & ~mask;
3668 + __atomic_lock_release();
3669 +
3670 + return res & mask;
3671 +}
3672 +
3673 +static inline int test_and_change_bit(int bit, volatile unsigned long *p)
3674 +{
3675 + unsigned int res;
3676 + unsigned long mask = 1UL << (bit & 31);
3677 +
3678 + p += bit >> 5;
3679 +
3680 + __atomic_lock_acquire();
3681 + res = *p;
3682 + *p = res ^ mask;
3683 + __atomic_lock_release();
3684 +
3685 + return res & mask;
3686 +}
3687 +
3688 +#include <asm-generic/bitops/non-atomic.h>
3689 +
3690 +/*
3691 + * This routine doesn't need to be atomic.
3692 + */
3693 +static inline int __constant_test_bit(int nr, const volatile unsigned long *addr)
3694 +{
3695 + return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
3696 +}
3697 +
3698 +static inline int __test_bit(int nr, const volatile unsigned long *addr)
3699 +{
3700 + int * a = (int *) addr;
3701 + int mask;
3702 +
3703 + a += nr >> 5;
3704 + mask = 1 << (nr & 0x1f);
3705 + return ((mask & *a) != 0);
3706 +}
3707 +
3708 +#define test_bit(nr,addr) (__builtin_constant_p(nr) ? __constant_test_bit((nr),(addr)) : __test_bit((nr),(addr)))
3709 +
3710 +#include <asm-generic/bitops/find.h>
3711 +#include <asm-generic/bitops/hweight.h>
3712 +#include <asm-generic/bitops/lock.h>
3713 +
3714 +#include <asm-generic/bitops/ext2-non-atomic.h>
3715 +#include <asm-generic/bitops/ext2-atomic.h>
3716 +#include <asm-generic/bitops/minix.h>
3717 +
3718 +#endif /* __KERNEL__ */
3719 +
3720 +#include <asm-generic/bitops/fls.h>
3721 +#include <asm-generic/bitops/__fls.h>
3722 +#include <asm-generic/bitops/fls64.h>
3723 +
3724 +#endif /* _ASM_UBICOM32_BITOPS_H */
3725 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/board.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/board.h
3726 --- linux-2.6.30.10/arch/ubicom32/include/asm/board.h 1970-01-01 02:00:00.000000000 +0200
3727 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/board.h 2009-12-11 11:45:11.000000000 +0200
3728 @@ -0,0 +1,34 @@
3729 +/*
3730 + * arch/ubicom32/include/asm/board.h
3731 + * Board init and revision definitions for Ubicom32 architecture.
3732 + *
3733 + * (C) Copyright 2009, Ubicom, Inc.
3734 + *
3735 + * This file is part of the Ubicom32 Linux Kernel Port.
3736 + *
3737 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3738 + * it and/or modify it under the terms of the GNU General Public License
3739 + * as published by the Free Software Foundation, either version 2 of the
3740 + * License, or (at your option) any later version.
3741 + *
3742 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3743 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3744 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3745 + * the GNU General Public License for more details.
3746 + *
3747 + * You should have received a copy of the GNU General Public License
3748 + * along with the Ubicom32 Linux Kernel Port. If not,
3749 + * see <http://www.gnu.org/licenses/>.
3750 + *
3751 + * Ubicom32 implementation derived from (with many thanks):
3752 + * arch/m68knommu
3753 + * arch/blackfin
3754 + * arch/parisc
3755 + */
3756 +#ifndef _ASM_UBICOM32_BOARD_H
3757 +#define _ASM_UBICOM32_BOARD_H
3758 +
3759 +extern const char *board_get_revision(void);
3760 +extern void __init board_init(void);
3761 +
3762 +#endif /* _ASM_UBICOM32_BOARD_H */
3763 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/bootargs.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bootargs.h
3764 --- linux-2.6.30.10/arch/ubicom32/include/asm/bootargs.h 1970-01-01 02:00:00.000000000 +0200
3765 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bootargs.h 2009-12-11 11:45:11.000000000 +0200
3766 @@ -0,0 +1,34 @@
3767 +/*
3768 + * arch/ubicom32/include/asm/bootargs.h
3769 + * Kernel command line via the devtree API.
3770 + *
3771 + * (C) Copyright 2009, Ubicom, Inc.
3772 + *
3773 + * This file is part of the Ubicom32 Linux Kernel Port.
3774 + *
3775 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3776 + * it and/or modify it under the terms of the GNU General Public License
3777 + * as published by the Free Software Foundation, either version 2 of the
3778 + * License, or (at your option) any later version.
3779 + *
3780 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3781 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3782 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3783 + * the GNU General Public License for more details.
3784 + *
3785 + * You should have received a copy of the GNU General Public License
3786 + * along with the Ubicom32 Linux Kernel Port. If not,
3787 + * see <http://www.gnu.org/licenses/>.
3788 + *
3789 + * Ubicom32 implementation derived from (with many thanks):
3790 + * arch/m68knommu
3791 + * arch/blackfin
3792 + * arch/parisc
3793 + */
3794 +#ifndef _ASM_UBICOM32_BOOTARGS_H
3795 +#define _ASM_UBICOM32_BOOTARGS_H
3796 +
3797 +extern const char *bootargs_get_cmdline(void);
3798 +extern void __init bootargs_init(void);
3799 +
3800 +#endif /* _ASM_UBICOM32_BOOTARGS_H */
3801 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/bootinfo.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bootinfo.h
3802 --- linux-2.6.30.10/arch/ubicom32/include/asm/bootinfo.h 1970-01-01 02:00:00.000000000 +0200
3803 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bootinfo.h 2009-12-11 11:45:11.000000000 +0200
3804 @@ -0,0 +1,34 @@
3805 +/*
3806 + * arch/ubicom32/include/asm/bootinfo.h
3807 + * Definitions of firmware boot parameters passed to the kernel.
3808 + *
3809 + * (C) Copyright 2009, Ubicom, Inc.
3810 + *
3811 + * This file is part of the Ubicom32 Linux Kernel Port.
3812 + *
3813 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3814 + * it and/or modify it under the terms of the GNU General Public License
3815 + * as published by the Free Software Foundation, either version 2 of the
3816 + * License, or (at your option) any later version.
3817 + *
3818 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3819 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3820 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3821 + * the GNU General Public License for more details.
3822 + *
3823 + * You should have received a copy of the GNU General Public License
3824 + * along with the Ubicom32 Linux Kernel Port. If not,
3825 + * see <http://www.gnu.org/licenses/>.
3826 + *
3827 + * Ubicom32 implementation derived from (with many thanks):
3828 + * arch/m68knommu
3829 + * arch/blackfin
3830 + * arch/parisc
3831 + */
3832 +
3833 +#ifndef _ASM_UBICOM32_BOOTINFO_H
3834 +#define _ASM_UBICOM32_BOOTINFO_H
3835 +
3836 +/* Nothing for ubicom32 */
3837 +
3838 +#endif /* _ASM_UBICOM32_BOOTINFO_H */
3839 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/bug.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bug.h
3840 --- linux-2.6.30.10/arch/ubicom32/include/asm/bug.h 1970-01-01 02:00:00.000000000 +0200
3841 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bug.h 2009-12-11 11:45:11.000000000 +0200
3842 @@ -0,0 +1,95 @@
3843 +/*
3844 + * arch/ubicom32/include/asm/bug.h
3845 + * Generic bug.h for Ubicom32 architecture.
3846 + *
3847 + * (C) Copyright 2009, Ubicom, Inc.
3848 + *
3849 + * This file is part of the Ubicom32 Linux Kernel Port.
3850 + *
3851 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3852 + * it and/or modify it under the terms of the GNU General Public License
3853 + * as published by the Free Software Foundation, either version 2 of the
3854 + * License, or (at your option) any later version.
3855 + *
3856 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3857 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3858 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3859 + * the GNU General Public License for more details.
3860 + *
3861 + * You should have received a copy of the GNU General Public License
3862 + * along with the Ubicom32 Linux Kernel Port. If not,
3863 + * see <http://www.gnu.org/licenses/>.
3864 + *
3865 + * Ubicom32 implementation derived from (with many thanks):
3866 + * arch/m68knommu
3867 + * arch/blackfin
3868 + * arch/parisc
3869 + */
3870 +#ifndef _ASM_UBICOM32_BUG_H
3871 +#define _ASM_UBICOM32_BUG_H
3872 +
3873 +#include <linux/kernel.h>
3874 +#include <asm/thread.h>
3875 +
3876 +#if defined(CONFIG_BUG) && defined(CONFIG_STOP_ON_BUG)
3877 +
3878 +/*
3879 + * BUG()
3880 + * Ubicom specific version of the BUG() macro.
3881 + *
3882 + * This implementation performs a THREAD_STALL stopping all threads before
3883 + * calling panic. This enables a developer to see the "real" state of the
3884 + * machine (since panic alters the system state). We do the printf first
3885 + * because while it is slow, it does not alter system state (like
3886 + * interrupts).
3887 + *
3888 + * TODO: Implement the trap sequence used by other architectures.
3889 + */
3890 +#define BUG() do { \
3891 + printk("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
3892 + THREAD_STALL; \
3893 + panic("BUG!"); \
3894 +} while (0)
3895 +
3896 +
3897 +/*
3898 + * __WARN()
3899 + * WARN() using printk() for now.
3900 + *
3901 + * TODO: Implement the trap sequence used by other architectures.
3902 + */
3903 +#define __WARN() \
3904 + do { \
3905 + printk("WARN: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __func__); \
3906 + } while(0)
3907 +
3908 +/*
3909 + * WARN_ON()
3910 + * Ubicom specific version of the WARN_ON macro.
3911 + *
3912 + * This implementation performs a printk for the WARN_ON() instead
3913 + * of faulting into the kernel and using report_bug().
3914 + *
3915 + * TODO: Implement the trap sequence used by other architectures.
3916 + */
3917 +#define WARN_ON(x) ({ \
3918 + int __ret_warn_on = !!(x); \
3919 + if (__builtin_constant_p(__ret_warn_on)) { \
3920 + if (__ret_warn_on) \
3921 + __WARN(); \
3922 + } else { \
3923 + if (unlikely(__ret_warn_on)) \
3924 + __WARN(); \
3925 + } \
3926 + unlikely(__ret_warn_on); \
3927 +})
3928 +
3929 +
3930 +#define HAVE_ARCH_BUG
3931 +#define HAVE_ARCH_WARN_ON
3932 +
3933 +#endif
3934 +
3935 +#include <asm-generic/bug.h>
3936 +
3937 +#endif /* _ASM_UBICOM32_BUG_H */
3938 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/bugs.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bugs.h
3939 --- linux-2.6.30.10/arch/ubicom32/include/asm/bugs.h 1970-01-01 02:00:00.000000000 +0200
3940 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/bugs.h 2009-12-11 11:45:11.000000000 +0200
3941 @@ -0,0 +1,44 @@
3942 +/*
3943 + * arch/ubicom32/include/asm/bugs.h
3944 + * Definition of check_bugs() for Ubicom32 architecture.
3945 + *
3946 + * (C) Copyright 2009, Ubicom, Inc.
3947 + * Copyright (C) 1994 Linus Torvalds
3948 + *
3949 + * This file is part of the Ubicom32 Linux Kernel Port.
3950 + *
3951 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3952 + * it and/or modify it under the terms of the GNU General Public License
3953 + * as published by the Free Software Foundation, either version 2 of the
3954 + * License, or (at your option) any later version.
3955 + *
3956 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
3957 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
3958 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
3959 + * the GNU General Public License for more details.
3960 + *
3961 + * You should have received a copy of the GNU General Public License
3962 + * along with the Ubicom32 Linux Kernel Port. If not,
3963 + * see <http://www.gnu.org/licenses/>.
3964 + *
3965 + * Ubicom32 implementation derived from (with many thanks):
3966 + * arch/m68knommu
3967 + * arch/blackfin
3968 + * arch/parisc
3969 + */
3970 +
3971 +/*
3972 + * This is included by init/main.c to check for architecture-dependent bugs.
3973 + *
3974 + * Needs:
3975 + * void check_bugs(void);
3976 + */
3977 +
3978 +#ifndef _ASM_UBICOM32_BUGS_H
3979 +#define _ASM_UBICOM32_BUGS_H
3980 +
3981 +static void check_bugs(void)
3982 +{
3983 +}
3984 +
3985 +#endif /* _ASM_UBICOM32_BUGS_H */
3986 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/byteorder.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/byteorder.h
3987 --- linux-2.6.30.10/arch/ubicom32/include/asm/byteorder.h 1970-01-01 02:00:00.000000000 +0200
3988 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/byteorder.h 2009-12-11 11:45:11.000000000 +0200
3989 @@ -0,0 +1,33 @@
3990 +/*
3991 + * arch/ubicom32/include/asm/byteorder.h
3992 + * Byte order swapping utility routines.
3993 + *
3994 + * (C) Copyright 2009, Ubicom, Inc.
3995 + *
3996 + * This file is part of the Ubicom32 Linux Kernel Port.
3997 + *
3998 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
3999 + * it and/or modify it under the terms of the GNU General Public License
4000 + * as published by the Free Software Foundation, either version 2 of the
4001 + * License, or (at your option) any later version.
4002 + *
4003 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4004 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4005 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4006 + * the GNU General Public License for more details.
4007 + *
4008 + * You should have received a copy of the GNU General Public License
4009 + * along with the Ubicom32 Linux Kernel Port. If not,
4010 + * see <http://www.gnu.org/licenses/>.
4011 + *
4012 + * Ubicom32 implementation derived from (with many thanks):
4013 + * arch/m68knommu
4014 + * arch/blackfin
4015 + * arch/parisc
4016 + */
4017 +#ifndef _ASM_UBICOM32_BYTEORDER_H
4018 +#define _ASM_UBICOM32_BYTEORDER_H
4019 +
4020 +#include <linux/byteorder/big_endian.h>
4021 +
4022 +#endif /* _ASM_UBICOM32_BYTEORDER_H */
4023 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/cachectl.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cachectl.h
4024 --- linux-2.6.30.10/arch/ubicom32/include/asm/cachectl.h 1970-01-01 02:00:00.000000000 +0200
4025 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cachectl.h 2009-12-11 11:45:11.000000000 +0200
4026 @@ -0,0 +1,39 @@
4027 +/*
4028 + * arch/ubicom32/include/asm/cachectl.h
4029 + * Ubicom32 cache control definitions.
4030 + *
4031 + * (C) Copyright 2009, Ubicom, Inc.
4032 + *
4033 + * This file is part of the Ubicom32 Linux Kernel Port.
4034 + *
4035 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4036 + * it and/or modify it under the terms of the GNU General Public License
4037 + * as published by the Free Software Foundation, either version 2 of the
4038 + * License, or (at your option) any later version.
4039 + *
4040 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4041 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4042 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4043 + * the GNU General Public License for more details.
4044 + *
4045 + * You should have received a copy of the GNU General Public License
4046 + * along with the Ubicom32 Linux Kernel Port. If not,
4047 + * see <http://www.gnu.org/licenses/>.
4048 + *
4049 + * Ubicom32 implementation derived from (with many thanks):
4050 + * arch/m68knommu
4051 + * arch/blackfin
4052 + * arch/parisc
4053 + */
4054 +#ifndef _ASM_UBICOM32_CACHECTL_H
4055 +#define _ASM_UBICOM32_CACHECTL_H
4056 +
4057 +#include <asm/ip5000.h>
4058 +
4059 +/*
4060 + * mem_cache_control()
4061 + * Special cache control operation
4062 + */
4063 +extern void mem_cache_control(unsigned long cc, unsigned long begin_addr, unsigned long end_addr, unsigned long op);
4064 +
4065 +#endif /* _ASM_UBICOM32_CACHECTL_H */
4066 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/cacheflush.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cacheflush.h
4067 --- linux-2.6.30.10/arch/ubicom32/include/asm/cacheflush.h 1970-01-01 02:00:00.000000000 +0200
4068 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cacheflush.h 2009-12-11 11:45:11.000000000 +0200
4069 @@ -0,0 +1,111 @@
4070 +/*
4071 + * arch/ubicom32/include/asm/cacheflush.h
4072 + * Cache flushing definitions for Ubicom32 architecture.
4073 + *
4074 + * (C) Copyright 2009, Ubicom, Inc.
4075 + *
4076 + * This file is part of the Ubicom32 Linux Kernel Port.
4077 + *
4078 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4079 + * it and/or modify it under the terms of the GNU General Public License
4080 + * as published by the Free Software Foundation, either version 2 of the
4081 + * License, or (at your option) any later version.
4082 + *
4083 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4084 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4085 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4086 + * the GNU General Public License for more details.
4087 + *
4088 + * You should have received a copy of the GNU General Public License
4089 + * along with the Ubicom32 Linux Kernel Port. If not,
4090 + * see <http://www.gnu.org/licenses/>.
4091 + *
4092 + * Ubicom32 implementation derived from (with many thanks):
4093 + * arch/m68knommu
4094 + * arch/blackfin
4095 + * arch/parisc
4096 + */
4097 +#ifndef _ASM_UBICOM32_CACHEFLUSH_H
4098 +#define _ASM_UBICOM32_CACHEFLUSH_H
4099 +
4100 +/*
4101 + * (C) Copyright 2000-2004, Greg Ungerer <gerg@snapgear.com>
4102 + */
4103 +#include <linux/mm.h>
4104 +#include <asm/cachectl.h>
4105 +#include <asm/ip5000.h>
4106 +
4107 +#define flush_cache_all() __flush_cache_all()
4108 +#define flush_cache_mm(mm) do { } while (0)
4109 +#define flush_cache_dup_mm(mm) do { } while (0)
4110 +#define flush_cache_range(vma, start, end) __flush_cache_all()
4111 +#define flush_cache_page(vma, vmaddr) do { } while (0)
4112 +#define flush_dcache_page(page) do { } while (0)
4113 +#define flush_dcache_mmap_lock(mapping) do { } while (0)
4114 +#define flush_dcache_mmap_unlock(mapping) do { } while (0)
4115 +
4116 +#define flush_dcache_range(start, end) \
4117 +do { \
4118 + /* Flush the data cache and invalidate the I cache. */ \
4119 + mem_cache_control(DCCR_BASE, start, end, CCR_CTRL_FLUSH_ADDR); \
4120 + mem_cache_control(ICCR_BASE, start, end, CCR_CTRL_INV_ADDR); \
4121 +} while (0)
4122 +
4123 +#define flush_icache_range(start, end) \
4124 +do { \
4125 + /* Flush the data cache and invalidate the I cache. */ \
4126 + mem_cache_control(DCCR_BASE, start, end, CCR_CTRL_FLUSH_ADDR); \
4127 + mem_cache_control(ICCR_BASE, start, end, CCR_CTRL_INV_ADDR); \
4128 +} while (0)
4129 +
4130 +#define flush_icache_page(vma,pg) do { } while (0)
4131 +#define flush_icache_user_range(vma,pg,adr,len) do { } while (0)
4132 +#define flush_cache_vmap(start, end) do { } while (0)
4133 +#define flush_cache_vunmap(start, end) do { } while (0)
4134 +
4135 +#define copy_to_user_page(vma, page, vaddr, dst, src, len) \
4136 + memcpy(dst, src, len)
4137 +#define copy_from_user_page(vma, page, vaddr, dst, src, len) \
4138 + memcpy(dst, src, len)
4139 +
4140 +/*
4141 + * Cache handling for IP5000
4142 + */
4143 +extern inline void mem_cache_invalidate_all(unsigned long cc)
4144 +{
4145 + if (cc == DCCR_BASE)
4146 + UBICOM32_LOCK(DCCR_LOCK_BIT);
4147 + else
4148 + UBICOM32_LOCK(ICCR_LOCK_BIT);
4149 +
4150 + asm volatile (
4151 + " bset "D(CCR_CTRL)"(%0), "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_RESET)" \n\t"
4152 + " nop \n\t"
4153 + " bclr "D(CCR_CTRL)"(%0), "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_RESET)" \n\t"
4154 + " pipe_flush 0 \n\t"
4155 + :
4156 + : "a"(cc)
4157 + : "cc"
4158 + );
4159 +
4160 + if (cc == DCCR_BASE)
4161 + UBICOM32_UNLOCK(DCCR_LOCK_BIT);
4162 + else
4163 + UBICOM32_UNLOCK(ICCR_LOCK_BIT);
4164 +
4165 +}
4166 +
4167 +static inline void __flush_cache_all(void)
4168 +{
4169 + /*
4170 + * Flush Icache
4171 + */
4172 + mem_cache_invalidate_all(ICCR_BASE);
4173 +
4174 + /*
4175 + * Flush Dcache
4176 + */
4177 + mem_cache_invalidate_all(DCCR_BASE);
4178 +}
4179 +
4180 +#endif /* _ASM_UBICOM32_CACHEFLUSH_H */
4181 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/cache.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cache.h
4182 --- linux-2.6.30.10/arch/ubicom32/include/asm/cache.h 1970-01-01 02:00:00.000000000 +0200
4183 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cache.h 2009-12-11 11:45:11.000000000 +0200
4184 @@ -0,0 +1,40 @@
4185 +/*
4186 + * arch/ubicom32/include/asm/cache.h
4187 + * Cache line definitions for Ubicom32 architecture.
4188 + *
4189 + * (C) Copyright 2009, Ubicom, Inc.
4190 + *
4191 + * This file is part of the Ubicom32 Linux Kernel Port.
4192 + *
4193 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4194 + * it and/or modify it under the terms of the GNU General Public License
4195 + * as published by the Free Software Foundation, either version 2 of the
4196 + * License, or (at your option) any later version.
4197 + *
4198 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4199 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4200 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4201 + * the GNU General Public License for more details.
4202 + *
4203 + * You should have received a copy of the GNU General Public License
4204 + * along with the Ubicom32 Linux Kernel Port. If not,
4205 + * see <http://www.gnu.org/licenses/>.
4206 + *
4207 + * Ubicom32 implementation derived from (with many thanks):
4208 + * arch/m68knommu
4209 + * arch/blackfin
4210 + * arch/parisc
4211 + */
4212 +#ifndef _ASM_UBICOM32_CACHE_H
4213 +#define _ASM_UBICOM32_CACHE_H
4214 +
4215 +/*
4216 + * bytes per L1 cache line
4217 + */
4218 +#define L1_CACHE_SHIFT 5
4219 +#define L1_CACHE_BYTES (1 << L1_CACHE_SHIFT)
4220 +
4221 +#define __cacheline_aligned
4222 +#define ____cacheline_aligned
4223 +
4224 +#endif /* _ASM_UBICOM32_CACHE_H */
4225 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/checksum.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/checksum.h
4226 --- linux-2.6.30.10/arch/ubicom32/include/asm/checksum.h 1970-01-01 02:00:00.000000000 +0200
4227 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/checksum.h 2009-12-11 11:45:11.000000000 +0200
4228 @@ -0,0 +1,149 @@
4229 +/*
4230 + * arch/ubicom32/include/asm/checksum.h
4231 + * Checksum utilities for Ubicom32 architecture.
4232 + *
4233 + * (C) Copyright 2009, Ubicom, Inc.
4234 + *
4235 + * This file is part of the Ubicom32 Linux Kernel Port.
4236 + *
4237 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4238 + * it and/or modify it under the terms of the GNU General Public License
4239 + * as published by the Free Software Foundation, either version 2 of the
4240 + * License, or (at your option) any later version.
4241 + *
4242 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4243 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4244 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4245 + * the GNU General Public License for more details.
4246 + *
4247 + * You should have received a copy of the GNU General Public License
4248 + * along with the Ubicom32 Linux Kernel Port. If not,
4249 + * see <http://www.gnu.org/licenses/>.
4250 + *
4251 + * Ubicom32 implementation derived from (with many thanks):
4252 + * arch/m68knommu
4253 + * arch/blackfin
4254 + * arch/parisc
4255 + */
4256 +#ifndef _ASM_UBICOM32_CHECKSUM_H
4257 +#define _ASM_UBICOM32_CHECKSUM_H
4258 +
4259 +#include <linux/in6.h>
4260 +
4261 +/*
4262 + * computes the checksum of a memory block at buff, length len,
4263 + * and adds in "sum" (32-bit)
4264 + *
4265 + * returns a 32-bit number suitable for feeding into itself
4266 + * or csum_tcpudp_magic
4267 + *
4268 + * this function must be called with even lengths, except
4269 + * for the last fragment, which may be odd
4270 + *
4271 + * it's best to have buff aligned on a 32-bit boundary
4272 + */
4273 +__wsum csum_partial(const void *buff, int len, __wsum sum);
4274 +
4275 +/*
4276 + * the same as csum_partial, but copies from src while it
4277 + * checksums
4278 + *
4279 + * here even more important to align src and dst on a 32-bit (or even
4280 + * better 64-bit) boundary
4281 + */
4282 +
4283 +__wsum csum_partial_copy_nocheck(const void *src, void *dst,
4284 + int len, __wsum sum);
4285 +
4286 +
4287 +/*
4288 + * the same as csum_partial_copy, but copies from user space.
4289 + *
4290 + * here even more important to align src and dst on a 32-bit (or even
4291 + * better 64-bit) boundary
4292 + */
4293 +
4294 +extern __wsum csum_partial_copy_from_user(const void __user *src,
4295 + void *dst, int len, __wsum sum, int *csum_err);
4296 +
4297 +__sum16 ip_fast_csum(const void *iph, unsigned int ihl);
4298 +
4299 +/*
4300 + * Fold a partial checksum
4301 + */
4302 +
4303 +static inline __sum16 csum_fold(__wsum sum)
4304 +{
4305 + asm volatile (
4306 + " lsr.4 d15, %0, #16 \n\t"
4307 + " bfextu %0, %0, #16 \n\t"
4308 + " add.4 %0, d15, %0 \n\t"
4309 + " lsr.4 d15, %0, #16 \n\t"
4310 + " bfextu %0, %0, #16 \n\t"
4311 + " add.4 %0, d15, %0 \n\t"
4312 + : "=&d" (sum)
4313 + : "0"(sum)
4314 + : "d15"
4315 + );
4316 + return (__force __sum16)~sum;
4317 +}
4318 +
4319 +
4320 +/*
4321 + * computes the checksum of the TCP/UDP pseudo-header
4322 + * returns a 16-bit checksum, already complemented
4323 + */
4324 +
4325 +static inline __wsum
4326 +csum_tcpudp_nofold(__be32 saddr, __be32 daddr, unsigned short len,
4327 + unsigned short proto, __wsum sum)
4328 +{
4329 + asm volatile (
4330 + " add.4 %0, %2, %0 \n\t"
4331 + " addc %0, %3, %0 \n\t"
4332 + " addc %0, %4, %0 \n\t"
4333 + " addc %0, %5, %0 \n\t"
4334 + " addc %0, #0, %0 \n\t"
4335 + : "=&d" (sum)
4336 + : "0"(sum), "r" (saddr), "r" (daddr), "r" (len), "r"(proto)
4337 + );
4338 + return sum;
4339 +}
4340 +
4341 +static inline __sum16
4342 +csum_tcpudp_magic(__be32 saddr, __be32 daddr, unsigned short len,
4343 + unsigned short proto, __wsum sum)
4344 +{
4345 + return csum_fold(csum_tcpudp_nofold(saddr,daddr,len,proto,sum));
4346 +}
4347 +
4348 +/*
4349 + * this routine is used for miscellaneous IP-like checksums, mainly
4350 + * in icmp.c
4351 + */
4352 +extern __sum16 ip_compute_csum(const void *buff, int len);
4353 +
4354 +#define _HAVE_ARCH_IPV6_CSUM
4355 +
4356 +static __inline__ __sum16
4357 +csum_ipv6_magic(const struct in6_addr *saddr, const struct in6_addr *daddr,
4358 + __u32 len, unsigned short proto, __wsum sum)
4359 +{
4360 + asm volatile (
4361 + " add.4 %0, 0(%2), %0 \n\t"
4362 + " addc %0, 4(%2), %0 \n\t"
4363 + " addc %0, 8(%2), %0 \n\t"
4364 + " addc %0, 12(%2), %0 \n\t"
4365 + " addc %0, 0(%3), %0 \n\t"
4366 + " addc %0, 4(%3), %0 \n\t"
4367 + " addc %0, 8(%3), %0 \n\t"
4368 + " addc %0, 12(%3), %0 \n\t"
4369 + " addc %0, %4, %0 \n\t"
4370 + " addc %0, #0, %0 \n\t"
4371 + : "=&d" (sum)
4372 + : "0" (sum), "a" (saddr), "a" (daddr), "d" (len + proto)
4373 + );
4374 + return csum_fold(sum);
4375 +}
4376 +
4377 +#endif /* _ASM_UBICOM32_CHECKSUM_H */
4378 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/cpu.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cpu.h
4379 --- linux-2.6.30.10/arch/ubicom32/include/asm/cpu.h 1970-01-01 02:00:00.000000000 +0200
4380 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cpu.h 2009-12-11 11:45:11.000000000 +0200
4381 @@ -0,0 +1,45 @@
4382 +/*
4383 + * arch/ubicom32/include/asm/cpu.h
4384 + * CPU definitions for Ubicom32 architecture.
4385 + *
4386 + * (C) Copyright 2009, Ubicom, Inc.
4387 + * Copyright (C) 2004-2005 ARM Ltd.
4388 + *
4389 + * This file is part of the Ubicom32 Linux Kernel Port.
4390 + *
4391 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4392 + * it and/or modify it under the terms of the GNU General Public License
4393 + * as published by the Free Software Foundation, either version 2 of the
4394 + * License, or (at your option) any later version.
4395 + *
4396 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4397 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4398 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4399 + * the GNU General Public License for more details.
4400 + *
4401 + * You should have received a copy of the GNU General Public License
4402 + * along with the Ubicom32 Linux Kernel Port. If not,
4403 + * see <http://www.gnu.org/licenses/>.
4404 + *
4405 + * Ubicom32 implementation derived from (with many thanks):
4406 + * arch/m68knommu
4407 + * arch/blackfin
4408 + * arch/parisc
4409 + */
4410 +#ifndef _ASM_UBICOM32_CPU_H
4411 +#define _ASM_UBICOM32_CPU_H
4412 +
4413 +#include <linux/percpu.h>
4414 +
4415 +struct cpuinfo_ubicom32 {
4416 + unsigned long tid; /* Hardware thread number */
4417 +
4418 +#ifdef CONFIG_SMP
4419 + volatile unsigned long ipi_pending; /* Bit map of operations to execute */
4420 + unsigned long ipi_count; /* Number of IPI(s) taken on this cpu */
4421 +#endif
4422 +};
4423 +
4424 +DECLARE_PER_CPU(struct cpuinfo_ubicom32, cpu_data);
4425 +
4426 +#endif /* _ASM_UBICOM32_CPU_H */
4427 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/cputime.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cputime.h
4428 --- linux-2.6.30.10/arch/ubicom32/include/asm/cputime.h 1970-01-01 02:00:00.000000000 +0200
4429 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/cputime.h 2009-12-11 11:45:11.000000000 +0200
4430 @@ -0,0 +1,33 @@
4431 +/*
4432 + * arch/ubicom32/include/asm/cputime.h
4433 + * Generic cputime.h for Ubicom32 architecture.
4434 + *
4435 + * (C) Copyright 2009, Ubicom, Inc.
4436 + *
4437 + * This file is part of the Ubicom32 Linux Kernel Port.
4438 + *
4439 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4440 + * it and/or modify it under the terms of the GNU General Public License
4441 + * as published by the Free Software Foundation, either version 2 of the
4442 + * License, or (at your option) any later version.
4443 + *
4444 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4445 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4446 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4447 + * the GNU General Public License for more details.
4448 + *
4449 + * You should have received a copy of the GNU General Public License
4450 + * along with the Ubicom32 Linux Kernel Port. If not,
4451 + * see <http://www.gnu.org/licenses/>.
4452 + *
4453 + * Ubicom32 implementation derived from (with many thanks):
4454 + * arch/m68knommu
4455 + * arch/blackfin
4456 + * arch/parisc
4457 + */
4458 +#ifndef _ASM_UBICOM32_CPUTIME_H
4459 +#define _ASM_UBICOM32_CPUTIME_H
4460 +
4461 +#include <asm-generic/cputime.h>
4462 +
4463 +#endif /* _ASM_UBICOM32_CPUTIME_H */
4464 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/current.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/current.h
4465 --- linux-2.6.30.10/arch/ubicom32/include/asm/current.h 1970-01-01 02:00:00.000000000 +0200
4466 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/current.h 2009-12-11 11:45:11.000000000 +0200
4467 @@ -0,0 +1,44 @@
4468 +/*
4469 + * arch/ubicom32/include/asm/current.h
4470 + * Definition of get_current() for Ubicom32 architecture.
4471 + *
4472 + * (C) Copyright 2009, Ubicom, Inc.
4473 + * (C) Copyright 2000, Lineo, David McCullough <davidm@uclinux.org>
4474 + * (C) Copyright 2002, Greg Ungerer (gerg@snapgear.com)
4475 + *
4476 + * This file is part of the Ubicom32 Linux Kernel Port.
4477 + *
4478 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4479 + * it and/or modify it under the terms of the GNU General Public License
4480 + * as published by the Free Software Foundation, either version 2 of the
4481 + * License, or (at your option) any later version.
4482 + *
4483 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4484 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4485 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4486 + * the GNU General Public License for more details.
4487 + *
4488 + * You should have received a copy of the GNU General Public License
4489 + * along with the Ubicom32 Linux Kernel Port. If not,
4490 + * see <http://www.gnu.org/licenses/>.
4491 + *
4492 + * Ubicom32 implementation derived from (with many thanks):
4493 + * arch/m68knommu
4494 + * arch/blackfin
4495 + * arch/parisc
4496 + */
4497 +#ifndef _ASM_UBICOM32_CURRENT_H
4498 +#define _ASM_UBICOM32_CURRENT_H
4499 +
4500 +#include <linux/thread_info.h>
4501 +
4502 +struct task_struct;
4503 +
4504 +static inline struct task_struct *get_current(void)
4505 +{
4506 + return(current_thread_info()->task);
4507 +}
4508 +
4509 +#define current get_current()
4510 +
4511 +#endif /* _ASM_UBICOM32_CURRENT_H */
4512 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/delay.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/delay.h
4513 --- linux-2.6.30.10/arch/ubicom32/include/asm/delay.h 1970-01-01 02:00:00.000000000 +0200
4514 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/delay.h 2009-12-11 11:45:11.000000000 +0200
4515 @@ -0,0 +1,75 @@
4516 +/*
4517 + * arch/ubicom32/include/asm/delay.h
4518 + * Definition of delay routines for Ubicom32 architecture.
4519 + *
4520 + * (C) Copyright 2009, Ubicom, Inc.
4521 + *
4522 + * This file is part of the Ubicom32 Linux Kernel Port.
4523 + *
4524 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4525 + * it and/or modify it under the terms of the GNU General Public License
4526 + * as published by the Free Software Foundation, either version 2 of the
4527 + * License, or (at your option) any later version.
4528 + *
4529 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4530 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4531 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4532 + * the GNU General Public License for more details.
4533 + *
4534 + * You should have received a copy of the GNU General Public License
4535 + * along with the Ubicom32 Linux Kernel Port. If not,
4536 + * see <http://www.gnu.org/licenses/>.
4537 + *
4538 + * Ubicom32 implementation derived from (with many thanks):
4539 + * arch/m68knommu
4540 + * arch/blackfin
4541 + * arch/parisc
4542 + */
4543 +#ifndef _ASM_UBICOM32_DELAY_H
4544 +#define _ASM_UBICOM32_DELAY_H
4545 +
4546 +#include <asm/param.h>
4547 +#include <asm/ip5000.h>
4548 +
4549 +static inline void __delay(unsigned long loops)
4550 +{
4551 + if (loops == 0) {
4552 + return;
4553 + }
4554 +
4555 + asm volatile (
4556 + "1: add.4 %0, #-1, %0 \n\t"
4557 + " jmpne.t 1b \n\t"
4558 + : "+d" (loops)
4559 + );
4560 +}
4561 +
4562 +/*
4563 + * Ubicom32 processor uses fixed 12MHz external OSC.
4564 + * So we use that as reference to count 12 cycles/us
4565 + */
4566 +
4567 +extern unsigned long loops_per_jiffy;
4568 +
4569 +static inline void _udelay(unsigned long usecs)
4570 +{
4571 +#if defined(CONFIG_UBICOM32_V4) || defined(CONFIG_UBICOM32_V3)
4572 + asm volatile (
4573 + " add.4 d15, 0(%0), %1 \n\t"
4574 + " sub.4 #0, 0(%0), d15 \n\t"
4575 + " jmpmi.w.f .-4 \n\t"
4576 + :
4577 + : "a"(TIMER_BASE + TIMER_MPTVAL), "d"(usecs * (12000000/1000000))
4578 + : "d15"
4579 + );
4580 +#else
4581 + BUG();
4582 +#endif
4583 +}
4584 +
4585 +/*
4586 + * Moved the udelay() function into library code, no longer inlined.
4587 + */
4588 +extern void udelay(unsigned long usecs);
4589 +
4590 +#endif /* _ASM_UBICOM32_DELAY_H */
4591 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/device.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/device.h
4592 --- linux-2.6.30.10/arch/ubicom32/include/asm/device.h 1970-01-01 02:00:00.000000000 +0200
4593 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/device.h 2009-12-11 11:45:11.000000000 +0200
4594 @@ -0,0 +1,35 @@
4595 +/*
4596 + * arch/ubicom32/include/asm/device.h
4597 + * Generic device.h for Ubicom32 architecture.
4598 + *
4599 + * Used for arch specific extensions to struct device
4600 + *
4601 + * (C) Copyright 2009, Ubicom, Inc.
4602 + *
4603 + * This file is part of the Ubicom32 Linux Kernel Port.
4604 + *
4605 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4606 + * it and/or modify it under the terms of the GNU General Public License
4607 + * as published by the Free Software Foundation, either version 2 of the
4608 + * License, or (at your option) any later version.
4609 + *
4610 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4611 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4612 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4613 + * the GNU General Public License for more details.
4614 + *
4615 + * You should have received a copy of the GNU General Public License
4616 + * along with the Ubicom32 Linux Kernel Port. If not,
4617 + * see <http://www.gnu.org/licenses/>.
4618 + *
4619 + * Ubicom32 implementation derived from (with many thanks):
4620 + * arch/m68knommu
4621 + * arch/blackfin
4622 + * arch/parisc
4623 + */
4624 +#ifndef _ASM_UBICOM32_DEVICE_H
4625 +#define _ASM_UBICOM32_DEVICE_H
4626 +
4627 +#include <asm-generic/device.h>
4628 +
4629 +#endif /* _ASM_UBICOM32_DEVICE_H */
4630 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/devtree.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/devtree.h
4631 --- linux-2.6.30.10/arch/ubicom32/include/asm/devtree.h 1970-01-01 02:00:00.000000000 +0200
4632 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/devtree.h 2009-12-11 11:45:11.000000000 +0200
4633 @@ -0,0 +1,52 @@
4634 +/*
4635 + * arch/ubicom32/include/asm/devtree.h
4636 + * Device Tree Header File (Shared between ultra and the Host OS)
4637 + *
4638 + * (C) Copyright 2009, Ubicom, Inc.
4639 + *
4640 + * This file is part of the Ubicom32 Linux Kernel Port.
4641 + *
4642 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4643 + * it and/or modify it under the terms of the GNU General Public License
4644 + * as published by the Free Software Foundation, either version 2 of the
4645 + * License, or (at your option) any later version.
4646 + *
4647 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4648 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4649 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4650 + * the GNU General Public License for more details.
4651 + *
4652 + * You should have received a copy of the GNU General Public License
4653 + * along with the Ubicom32 Linux Kernel Port. If not,
4654 + * see <http://www.gnu.org/licenses/>.
4655 + *
4656 + * Ubicom32 implementation derived from (with many thanks):
4657 + * arch/m68knommu
4658 + * arch/blackfin
4659 + * arch/parisc
4660 + */
4661 +
4662 +#ifndef _ASM_UBICOM32_DEVTREE_H
4663 +#define _ASM_UBICOM32_DEVTREE_H
4664 +
4665 +#define DEVTREE_MAX_NAME 32
4666 +#define DEVTREE_IRQ_NONE 0xff
4667 +#define DEVTREE_IRQ_DONTCARE 0xff
4668 +#define DEVTREE_NODE_MAGIC 0x10203040
4669 +
4670 +struct devtree_node {
4671 + struct devtree_node *next;
4672 + unsigned char sendirq;
4673 + unsigned char recvirq;
4674 + char name[DEVTREE_MAX_NAME];
4675 + unsigned int magic;
4676 +};
4677 +
4678 +extern struct devtree_node *devtree;
4679 +extern struct devtree_node *devtree_find_by_irq(uint8_t sendirq, uint8_t recvirq);
4680 +extern struct devtree_node *devtree_find_node(const char *str);
4681 +extern struct devtree_node *devtree_find_next(struct devtree_node **cur);
4682 +extern int devtree_irq(struct devtree_node *dn, unsigned char *sendirq, unsigned char *recvirq);
4683 +extern void devtree_print(void);
4684 +
4685 +#endif /* _ASM_UBICOM32_DEVTREE_H */
4686 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/div64.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/div64.h
4687 --- linux-2.6.30.10/arch/ubicom32/include/asm/div64.h 1970-01-01 02:00:00.000000000 +0200
4688 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/div64.h 2009-12-11 11:45:11.000000000 +0200
4689 @@ -0,0 +1,33 @@
4690 +/*
4691 + * arch/ubicom32/include/asm/div64.h
4692 + * Generic div64.h for Ubicom32 architecture.
4693 + *
4694 + * (C) Copyright 2009, Ubicom, Inc.
4695 + *
4696 + * This file is part of the Ubicom32 Linux Kernel Port.
4697 + *
4698 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4699 + * it and/or modify it under the terms of the GNU General Public License
4700 + * as published by the Free Software Foundation, either version 2 of the
4701 + * License, or (at your option) any later version.
4702 + *
4703 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4704 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4705 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4706 + * the GNU General Public License for more details.
4707 + *
4708 + * You should have received a copy of the GNU General Public License
4709 + * along with the Ubicom32 Linux Kernel Port. If not,
4710 + * see <http://www.gnu.org/licenses/>.
4711 + *
4712 + * Ubicom32 implementation derived from (with many thanks):
4713 + * arch/m68knommu
4714 + * arch/blackfin
4715 + * arch/parisc
4716 + */
4717 +#ifndef _ASM_UBICOM32_DIV64_H
4718 +#define _ASM_UBICOM32_DIV64_H
4719 +
4720 +#include <asm-generic/div64.h>
4721 +
4722 +#endif /* _ASM_UBICOM32_DIV64_H */
4723 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/dma.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/dma.h
4724 --- linux-2.6.30.10/arch/ubicom32/include/asm/dma.h 1970-01-01 02:00:00.000000000 +0200
4725 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/dma.h 2009-12-11 11:45:11.000000000 +0200
4726 @@ -0,0 +1,34 @@
4727 +/*
4728 + * arch/ubicom32/include/asm/dma.h
4729 + * DMA definitions for Ubicom32 architecture.
4730 + *
4731 + * (C) Copyright 2009, Ubicom, Inc.
4732 + *
4733 + * This file is part of the Ubicom32 Linux Kernel Port.
4734 + *
4735 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4736 + * it and/or modify it under the terms of the GNU General Public License
4737 + * as published by the Free Software Foundation, either version 2 of the
4738 + * License, or (at your option) any later version.
4739 + *
4740 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4741 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4742 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4743 + * the GNU General Public License for more details.
4744 + *
4745 + * You should have received a copy of the GNU General Public License
4746 + * along with the Ubicom32 Linux Kernel Port. If not,
4747 + * see <http://www.gnu.org/licenses/>.
4748 + *
4749 + * Ubicom32 implementation derived from (with many thanks):
4750 + * arch/m68knommu
4751 + * arch/blackfin
4752 + * arch/parisc
4753 + */
4754 +#ifndef _ASM_UBICOM32_DMA_H
4755 +#define _ASM_UBICOM32_DMA_H
4756 +
4757 +/* Nothing so far */
4758 +#define MAX_DMA_ADDRESS 0x00 /* This is quite suspicious */
4759 +
4760 +#endif /* _ASM_UBICOM32_DMA_H */
4761 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/dma-mapping.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/dma-mapping.h
4762 --- linux-2.6.30.10/arch/ubicom32/include/asm/dma-mapping.h 1970-01-01 02:00:00.000000000 +0200
4763 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/dma-mapping.h 2009-12-11 11:45:11.000000000 +0200
4764 @@ -0,0 +1,328 @@
4765 +/*
4766 + * arch/ubicom32/include/asm/dma-mapping.h
4767 + * Generic dma-mapping.h for Ubicom32 architecture.
4768 + *
4769 + * (C) Copyright 2009, Ubicom, Inc.
4770 + *
4771 + * This file is part of the Ubicom32 Linux Kernel Port.
4772 + *
4773 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
4774 + * it and/or modify it under the terms of the GNU General Public License
4775 + * as published by the Free Software Foundation, either version 2 of the
4776 + * License, or (at your option) any later version.
4777 + *
4778 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
4779 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
4780 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
4781 + * the GNU General Public License for more details.
4782 + *
4783 + * You should have received a copy of the GNU General Public License
4784 + * along with the Ubicom32 Linux Kernel Port. If not,
4785 + * see <http://www.gnu.org/licenses/>.
4786 + *
4787 + * Ubicom32 implementation derived from (with many thanks):
4788 + * arch/m68knommu
4789 + * arch/blackfin
4790 + * arch/parisc
4791 + */
4792 +#ifndef _ASM_UBICOM32_DMA_MAPPING_H
4793 +#define _ASM_UBICOM32_DMA_MAPPING_H
4794 +
4795 +#include <linux/scatterlist.h>
4796 +#ifdef CONFIG_PCI
4797 +
4798 +/* we implement the API below in terms of the existing PCI one,
4799 + * so include it */
4800 +#include <linux/pci.h>
4801 +/* need struct page definitions */
4802 +#include <linux/mm.h>
4803 +
4804 +static inline int
4805 +dma_supported(struct device *dev, u64 mask)
4806 +{
4807 + BUG_ON(dev->bus != &pci_bus_type);
4808 +
4809 + return pci_dma_supported(to_pci_dev(dev), mask);
4810 +}
4811 +
4812 +static inline int
4813 +dma_set_mask(struct device *dev, u64 dma_mask)
4814 +{
4815 + BUG_ON(dev->bus != &pci_bus_type);
4816 +
4817 + return pci_set_dma_mask(to_pci_dev(dev), dma_mask);
4818 +}
4819 +
4820 +static inline void *
4821 +dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
4822 + gfp_t flag)
4823 +{
4824 + BUG_ON(dev->bus != &pci_bus_type);
4825 +
4826 + return pci_alloc_consistent(to_pci_dev(dev), size, dma_handle);
4827 +}
4828 +
4829 +static inline void
4830 +dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
4831 + dma_addr_t dma_handle)
4832 +{
4833 + BUG_ON(dev->bus != &pci_bus_type);
4834 +
4835 + pci_free_consistent(to_pci_dev(dev), size, cpu_addr, dma_handle);
4836 +}
4837 +
4838 +static inline dma_addr_t
4839 +dma_map_single(struct device *dev, void *cpu_addr, size_t size,
4840 + enum dma_data_direction direction)
4841 +{
4842 + BUG_ON(dev->bus != &pci_bus_type);
4843 +
4844 + return pci_map_single(to_pci_dev(dev), cpu_addr, size, (int)direction);
4845 +}
4846 +
4847 +static inline void
4848 +dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
4849 + enum dma_data_direction direction)
4850 +{
4851 + BUG_ON(dev->bus != &pci_bus_type);
4852 +
4853 + pci_unmap_single(to_pci_dev(dev), dma_addr, size, (int)direction);
4854 +}
4855 +
4856 +static inline dma_addr_t
4857 +dma_map_page(struct device *dev, struct page *page,
4858 + unsigned long offset, size_t size,
4859 + enum dma_data_direction direction)
4860 +{
4861 + BUG_ON(dev->bus != &pci_bus_type);
4862 +
4863 + return pci_map_page(to_pci_dev(dev), page, offset, size, (int)direction);
4864 +}
4865 +
4866 +static inline void
4867 +dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
4868 + enum dma_data_direction direction)
4869 +{
4870 + BUG_ON(dev->bus != &pci_bus_type);
4871 +
4872 + pci_unmap_page(to_pci_dev(dev), dma_address, size, (int)direction);
4873 +}
4874 +
4875 +static inline int
4876 +dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
4877 + enum dma_data_direction direction)
4878 +{
4879 + BUG_ON(dev->bus != &pci_bus_type);
4880 +
4881 + return pci_map_sg(to_pci_dev(dev), sg, nents, (int)direction);
4882 +}
4883 +
4884 +static inline void
4885 +dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
4886 + enum dma_data_direction direction)
4887 +{
4888 + BUG_ON(dev->bus != &pci_bus_type);
4889 +
4890 + pci_unmap_sg(to_pci_dev(dev), sg, nhwentries, (int)direction);
4891 +}
4892 +
4893 +static inline void
4894 +dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
4895 + enum dma_data_direction direction)
4896 +{
4897 + BUG_ON(dev->bus != &pci_bus_type);
4898 +
4899 + pci_dma_sync_single_for_cpu(to_pci_dev(dev), dma_handle,
4900 + size, (int)direction);
4901 +}
4902 +
4903 +static inline void
4904 +dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
4905 + enum dma_data_direction direction)
4906 +{
4907 + BUG_ON(dev->bus != &pci_bus_type);
4908 +
4909 + pci_dma_sync_single_for_device(to_pci_dev(dev), dma_handle,
4910 + size, (int)direction);
4911 +}
4912 +
4913 +static inline void
4914 +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
4915 + enum dma_data_direction direction)
4916 +{
4917 + BUG_ON(dev->bus != &pci_bus_type);
4918 +
4919 + pci_dma_sync_sg_for_cpu(to_pci_dev(dev), sg, nelems, (int)direction);
4920 +}
4921 +
4922 +static inline void
4923 +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
4924 + enum dma_data_direction direction)
4925 +{
4926 + BUG_ON(dev->bus != &pci_bus_type);
4927 +
4928 + pci_dma_sync_sg_for_device(to_pci_dev(dev), sg, nelems, (int)direction);
4929 +}
4930 +
4931 +static inline int
4932 +dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
4933 +{
4934 + return pci_dma_mapping_error(to_pci_dev(dev), dma_addr);
4935 +}
4936 +
4937 +
4938 +#else
4939 +
4940 +static inline int
4941 +dma_supported(struct device *dev, u64 mask)
4942 +{
4943 + return 0;
4944 +}
4945 +
4946 +static inline int
4947 +dma_set_mask(struct device *dev, u64 dma_mask)
4948 +{
4949 + BUG();
4950 + return 0;
4951 +}
4952 +
4953 +static inline void *
4954 +dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
4955 + gfp_t flag)
4956 +{
4957 + BUG();
4958 + return NULL;
4959 +}
4960 +
4961 +static inline void
4962 +dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
4963 + dma_addr_t dma_handle)
4964 +{
4965 + BUG();
4966 +}
4967 +
4968 +static inline dma_addr_t
4969 +dma_map_single(struct device *dev, void *cpu_addr, size_t size,
4970 + enum dma_data_direction direction)
4971 +{
4972 + BUG();
4973 + return 0;
4974 +}
4975 +
4976 +static inline void
4977 +dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
4978 + enum dma_data_direction direction)
4979 +{
4980 + BUG();
4981 +}
4982 +
4983 +static inline dma_addr_t
4984 +dma_map_page(struct device *dev, struct page *page,
4985 + unsigned long offset, size_t size,
4986 + enum dma_data_direction direction)
4987 +{
4988 + BUG();
4989 + return 0;
4990 +}
4991 +
4992 +static inline void
4993 +dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
4994 + enum dma_data_direction direction)
4995 +{
4996 + BUG();
4997 +}
4998 +
4999 +static inline int
5000 +dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
5001 + enum dma_data_direction direction)
5002 +{
5003 + BUG();
5004 + return 0;
5005 +}
5006 +
5007 +static inline void
5008 +dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
5009 + enum dma_data_direction direction)
5010 +{
5011 + BUG();
5012 +}
5013 +
5014 +static inline void
5015 +dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
5016 + enum dma_data_direction direction)
5017 +{
5018 + BUG();
5019 +}
5020 +
5021 +static inline void
5022 +dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
5023 + enum dma_data_direction direction)
5024 +{
5025 + BUG();
5026 +}
5027 +
5028 +static inline void
5029 +dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
5030 + enum dma_data_direction direction)
5031 +{
5032 + BUG();
5033 +}
5034 +
5035 +static inline void
5036 +dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
5037 + enum dma_data_direction direction)
5038 +{
5039 + BUG();
5040 +}
5041 +
5042 +static inline int
5043 +dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
5044 +{
5045 + return 0;
5046 +}
5047 +
5048 +#endif
5049 +
5050 +/* Now for the API extensions over the pci_ one */
5051 +
5052 +#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
5053 +#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
5054 +#define dma_is_consistent(d, h) (1)
5055 +
5056 +static inline int
5057 +dma_get_cache_alignment(void)
5058 +{
5059 + /* no easy way to get cache size on all processors, so return
5060 + * the maximum possible, to be safe */
5061 + return (1 << INTERNODE_CACHE_SHIFT);
5062 +}
5063 +
5064 +static inline void
5065 +dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
5066 + unsigned long offset, size_t size,
5067 + enum dma_data_direction direction)
5068 +{
5069 + /* just sync everything, that's all the pci API can do */
5070 + dma_sync_single_for_cpu(dev, dma_handle, offset+size, direction);
5071 +}
5072 +
5073 +static inline void
5074 +dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
5075 + unsigned long offset, size_t size,
5076 + enum dma_data_direction direction)
5077 +{
5078 + /* just sync everything, that's all the pci API can do */
5079 + dma_sync_single_for_device(dev, dma_handle, offset+size, direction);
5080 +}
5081 +
5082 +static inline void
5083 +dma_cache_sync(struct device *dev, void *vaddr, size_t size,
5084 + enum dma_data_direction direction)
5085 +{
5086 + /* could define this in terms of the dma_cache ... operations,
5087 + * but if you get this on a platform, you should convert the platform
5088 + * to using the generic device DMA API */
5089 + BUG();
5090 +}
5091 +
5092 +#endif /* _ASM_UBICOM32_DMA_MAPPING_H */
5093 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/elf.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/elf.h
5094 --- linux-2.6.30.10/arch/ubicom32/include/asm/elf.h 1970-01-01 02:00:00.000000000 +0200
5095 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/elf.h 2009-12-11 11:45:11.000000000 +0200
5096 @@ -0,0 +1,173 @@
5097 +/*
5098 + * arch/ubicom32/include/asm/elf.h
5099 + * Definitions for elf executable format for Ubicom32 architecture.
5100 + *
5101 + * (C) Copyright 2009, Ubicom, Inc.
5102 + *
5103 + * This file is part of the Ubicom32 Linux Kernel Port.
5104 + *
5105 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5106 + * it and/or modify it under the terms of the GNU General Public License
5107 + * as published by the Free Software Foundation, either version 2 of the
5108 + * License, or (at your option) any later version.
5109 + *
5110 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5111 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5112 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5113 + * the GNU General Public License for more details.
5114 + *
5115 + * You should have received a copy of the GNU General Public License
5116 + * along with the Ubicom32 Linux Kernel Port. If not,
5117 + * see <http://www.gnu.org/licenses/>.
5118 + *
5119 + * Ubicom32 implementation derived from (with many thanks):
5120 + * arch/m68knommu
5121 + * arch/blackfin
5122 + * arch/parisc
5123 + */
5124 +#ifndef _ASM_UBICOM32_ELF_H
5125 +#define _ASM_UBICOM32_ELF_H
5126 +
5127 +/*
5128 + * ELF register definitions..
5129 + */
5130 +
5131 +#include <asm/ptrace.h>
5132 +#include <asm/user.h>
5133 +
5134 +/*
5135 + * Processor specific flags for the ELF header e_flags field.
5136 + */
5137 +#define EF_UBICOM32_V3 0x00000001 /* -fmarch=ubicom32v3 */
5138 +#define EF_UBICOM32_V4 0x00000002 /* -fmarch=ubicom32v4 */
5139 +#define EF_UBICOM32_PIC 0x80000000 /* -fpic */
5140 +#define EF_UBICOM32_FDPIC 0x40000000 /* -mfdpic */
5141 +
5142 +/*
5143 + * Ubicom32 ELF relocation types
5144 + */
5145 +#define R_UBICOM32_NONE 0
5146 +#define R_UBICOM32_16 1
5147 +#define R_UBICOM32_32 2
5148 +#define R_UBICOM32_LO16 3
5149 +#define R_UBICOM32_HI16 4
5150 +#define R_UBICOM32_21_PCREL 5
5151 +#define R_UBICOM32_24_PCREL 6
5152 +#define R_UBICOM32_HI24 7
5153 +#define R_UBICOM32_LO7_S 8
5154 +#define R_UBICOM32_LO7_2_S 9
5155 +#define R_UBICOM32_LO7_4_S 10
5156 +#define R_UBICOM32_LO7_D 11
5157 +#define R_UBICOM32_LO7_2_D 12
5158 +#define R_UBICOM32_LO7_4_D 13
5159 +#define R_UBICOM32_32_HARVARD 14
5160 +#define R_UBICOM32_LO7_CALLI 15
5161 +#define R_UBICOM32_LO16_CALLI 16
5162 +#define R_UBICOM32_GOT_HI24 17
5163 +#define R_UBICOM32_GOT_LO7_S 18
5164 +#define R_UBICOM32_GOT_LO7_2_S 19
5165 +#define R_UBICOM32_GOT_LO7_4_S 20
5166 +#define R_UBICOM32_GOT_LO7_D 21
5167 +#define R_UBICOM32_GOT_LO7_2_D 22
5168 +#define R_UBICOM32_GOT_LO7_4_D 23
5169 +#define R_UBICOM32_FUNCDESC_GOT_HI24 24
5170 +#define R_UBICOM32_FUNCDESC_GOT_LO7_S 25
5171 +#define R_UBICOM32_FUNCDESC_GOT_LO7_2_S 26
5172 +#define R_UBICOM32_FUNCDESC_GOT_LO7_4_S 27
5173 +#define R_UBICOM32_FUNCDESC_GOT_LO7_D 28
5174 +#define R_UBICOM32_FUNCDESC_GOT_LO7_2_D 29
5175 +#define R_UBICOM32_FUNCDESC_GOT_LO7_4_D 30
5176 +#define R_UBICOM32_GOT_LO7_CALLI 31
5177 +#define R_UBICOM32_FUNCDESC_GOT_LO7_CALLI 32
5178 +#define R_UBICOM32_FUNCDESC_VALUE 33
5179 +#define R_UBICOM32_FUNCDESC 34
5180 +#define R_UBICOM32_GOTOFFSET_LO 35
5181 +#define R_UBICOM32_GOTOFFSET_HI 36
5182 +#define R_UBICOM32_FUNCDESC_GOTOFFSET_LO 37
5183 +#define R_UBICOM32_FUNCDESC_GOTOFFSET_HI 38
5184 +#define R_UBICOM32_GNU_VTINHERIT 200
5185 +#define R_UBICOM32_GNU_VTENTRY 201
5186 +
5187 +typedef unsigned long elf_greg_t;
5188 +
5189 +#define ELF_NGREG (sizeof(struct pt_regs) / sizeof(elf_greg_t))
5190 +typedef elf_greg_t elf_gregset_t[ELF_NGREG];
5191 +
5192 +typedef struct user_ubicom32fp_struct elf_fpregset_t;
5193 +
5194 +/*
5195 + * This is used to ensure we don't load something for the wrong architecture.
5196 + */
5197 +#define elf_check_arch(x) ((x)->e_machine == EM_UBICOM32)
5198 +
5199 +#define elf_check_fdpic(x) ((x)->e_flags & EF_UBICOM32_FDPIC)
5200 +
5201 +#define elf_check_const_displacement(x) ((x)->e_flags & EF_UBICOM32_PIC)
5202 +
5203 +/*
5204 + * These are used to set parameters in the core dumps.
5205 + */
5206 +#define ELF_CLASS ELFCLASS32
5207 +#define ELF_DATA ELFDATA2MSB
5208 +#define ELF_ARCH EM_UBICOM32
5209 +
5210 +/* For SVR4/m68k the function pointer to be registered with `atexit' is
5211 + passed in %a1. Although my copy of the ABI has no such statement, it
5212 + is actually used on ASV. */
5213 +#define ELF_PLAT_INIT(_r, load_addr) _r->a1 = 0
5214 +
5215 +#define ELF_FDPIC_PLAT_INIT(_regs, _exec_map_addr, _interp_map_addr, \
5216 + _dynamic_addr) \
5217 + do { \
5218 + _regs->dn[1] = _exec_map_addr; \
5219 + _regs->dn[2] = _interp_map_addr; \
5220 + _regs->dn[3] = _dynamic_addr; \
5221 + _regs->an[1] = 0; /* dl_fini will be set by ldso */ \
5222 + } while (0)
5223 +
5224 +#define USE_ELF_CORE_DUMP
5225 +#define ELF_EXEC_PAGESIZE 4096
5226 +
5227 +#ifdef __KERNEL__
5228 +#ifdef CONFIG_UBICOM32_V4
5229 +#define ELF_FDPIC_CORE_EFLAGS (EF_UBICOM32_FDPIC | EF_UBICOM32_V4)
5230 +#elif defined CONFIG_UBICOM32_V3
5231 +#define ELF_FDPIC_CORE_EFLAGS (EF_UBICOM32_FDPIC | EF_UBICOM32_V3)
5232 +#else
5233 +#error Unknown/Unsupported ubicom32 architecture.
5234 +#endif
5235 +#endif
5236 +
5237 +/* This is the location that an ET_DYN program is loaded if exec'ed. Typical
5238 + use of this is to invoke "./ld.so someprog" to test out a new version of
5239 + the loader. We need to make sure that it is out of the way of the program
5240 + that it will "exec", and that there is sufficient room for the brk. */
5241 +
5242 +#define ELF_ET_DYN_BASE 0xD0000000UL
5243 +
5244 +/*
5245 + * For Ubicom32, the elf_gregset_t and struct pt_regs are the same size
5246 + * data structure so a copy is performed instead of providing the
5247 + * ELF_CORE_COPY_REGS macro.
5248 + */
5249 +
5250 +/*
5251 + * ELF_CORE_COPY_TASK_REGS is needed to dump register state from multi threaded user projects.
5252 + */
5253 +extern int dump_task_regs(struct task_struct *, elf_gregset_t *);
5254 +#define ELF_CORE_COPY_TASK_REGS(tsk, elf_regs) dump_task_regs(tsk, elf_regs)
5255 +
5256 +/* This yields a mask that user programs can use to figure out what
5257 + instruction set this cpu supports. */
5258 +
5259 +#define ELF_HWCAP (0)
5260 +
5261 +/* This yields a string that ld.so will use to load implementation
5262 + specific libraries for optimization. This is more specific in
5263 + intent than poking at uname or /proc/cpuinfo. */
5264 +
5265 +#define ELF_PLATFORM (NULL)
5266 +
5267 +#define SET_PERSONALITY(ex, ibcs2) set_personality((ibcs2)?PER_SVR4:PER_LINUX)
5268 +
5269 +#endif /* _ASM_UBICOM32_ELF_H */
5270 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/emergency-restart.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/emergency-restart.h
5271 --- linux-2.6.30.10/arch/ubicom32/include/asm/emergency-restart.h 1970-01-01 02:00:00.000000000 +0200
5272 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/emergency-restart.h 2009-12-11 11:45:11.000000000 +0200
5273 @@ -0,0 +1,33 @@
5274 +/*
5275 + * arch/ubicom32/include/asm/emergency-restart.h
5276 + * Generic emergency-restart.h for Ubicom32 architecture.
5277 + *
5278 + * (C) Copyright 2009, Ubicom, Inc.
5279 + *
5280 + * This file is part of the Ubicom32 Linux Kernel Port.
5281 + *
5282 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5283 + * it and/or modify it under the terms of the GNU General Public License
5284 + * as published by the Free Software Foundation, either version 2 of the
5285 + * License, or (at your option) any later version.
5286 + *
5287 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5288 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5289 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5290 + * the GNU General Public License for more details.
5291 + *
5292 + * You should have received a copy of the GNU General Public License
5293 + * along with the Ubicom32 Linux Kernel Port. If not,
5294 + * see <http://www.gnu.org/licenses/>.
5295 + *
5296 + * Ubicom32 implementation derived from (with many thanks):
5297 + * arch/m68knommu
5298 + * arch/blackfin
5299 + * arch/parisc
5300 + */
5301 +#ifndef _ASM_UBICOM32_EMERGENCY_RESTART_H
5302 +#define _ASM_UBICOM32_EMERGENCY_RESTART_H
5303 +
5304 +#include <asm-generic/emergency-restart.h>
5305 +
5306 +#endif /* _ASM_UBICOM32_EMERGENCY_RESTART_H */
5307 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/entry.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/entry.h
5308 --- linux-2.6.30.10/arch/ubicom32/include/asm/entry.h 1970-01-01 02:00:00.000000000 +0200
5309 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/entry.h 2009-12-11 11:45:11.000000000 +0200
5310 @@ -0,0 +1,34 @@
5311 +/*
5312 + * arch/ubicom32/include/asm/entry.h
5313 + * Entry register/stack definitions for Ubicom32 architecture.
5314 + *
5315 + * (C) Copyright 2009, Ubicom, Inc.
5316 + *
5317 + * This file is part of the Ubicom32 Linux Kernel Port.
5318 + *
5319 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5320 + * it and/or modify it under the terms of the GNU General Public License
5321 + * as published by the Free Software Foundation, either version 2 of the
5322 + * License, or (at your option) any later version.
5323 + *
5324 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5325 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5326 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5327 + * the GNU General Public License for more details.
5328 + *
5329 + * You should have received a copy of the GNU General Public License
5330 + * along with the Ubicom32 Linux Kernel Port. If not,
5331 + * see <http://www.gnu.org/licenses/>.
5332 + *
5333 + * Ubicom32 implementation derived from (with many thanks):
5334 + * arch/m68knommu
5335 + * arch/blackfin
5336 + * arch/parisc
5337 + */
5338 +#ifndef _ASM_UBICOM32_ENTRY_H
5339 +#define _ASM_UBICOM32_ENTRY_H
5340 +
5341 +#include <asm/setup.h>
5342 +#include <asm/page.h>
5343 +
5344 +#endif /* _ASM_UBICOM32_ENTRY_H */
5345 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/errno.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/errno.h
5346 --- linux-2.6.30.10/arch/ubicom32/include/asm/errno.h 1970-01-01 02:00:00.000000000 +0200
5347 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/errno.h 2009-12-11 11:45:11.000000000 +0200
5348 @@ -0,0 +1,33 @@
5349 +/*
5350 + * arch/ubicom32/include/asm/errno.h
5351 + * Generic errno.h for Ubicom32 architecture.
5352 + *
5353 + * (C) Copyright 2009, Ubicom, Inc.
5354 + *
5355 + * This file is part of the Ubicom32 Linux Kernel Port.
5356 + *
5357 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5358 + * it and/or modify it under the terms of the GNU General Public License
5359 + * as published by the Free Software Foundation, either version 2 of the
5360 + * License, or (at your option) any later version.
5361 + *
5362 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5363 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5364 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5365 + * the GNU General Public License for more details.
5366 + *
5367 + * You should have received a copy of the GNU General Public License
5368 + * along with the Ubicom32 Linux Kernel Port. If not,
5369 + * see <http://www.gnu.org/licenses/>.
5370 + *
5371 + * Ubicom32 implementation derived from (with many thanks):
5372 + * arch/m68knommu
5373 + * arch/blackfin
5374 + * arch/parisc
5375 + */
5376 +#ifndef _ASM_UBICOM32_ERRNO_H
5377 +#define _ASM_UBICOM32_ERRNO_H
5378 +
5379 +#include <asm-generic/errno.h>
5380 +
5381 +#endif /* _ASM_UBICOM32_ERRNO_H */
5382 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/fb.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fb.h
5383 --- linux-2.6.30.10/arch/ubicom32/include/asm/fb.h 1970-01-01 02:00:00.000000000 +0200
5384 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fb.h 2009-12-11 11:45:11.000000000 +0200
5385 @@ -0,0 +1,39 @@
5386 +/*
5387 + * arch/ubicom32/include/asm/fb.h
5388 + * Definition of fb_is_primary_device() for Ubicom32 architecture.
5389 + *
5390 + * (C) Copyright 2009, Ubicom, Inc.
5391 + *
5392 + * This file is part of the Ubicom32 Linux Kernel Port.
5393 + *
5394 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5395 + * it and/or modify it under the terms of the GNU General Public License
5396 + * as published by the Free Software Foundation, either version 2 of the
5397 + * License, or (at your option) any later version.
5398 + *
5399 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5400 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5401 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5402 + * the GNU General Public License for more details.
5403 + *
5404 + * You should have received a copy of the GNU General Public License
5405 + * along with the Ubicom32 Linux Kernel Port. If not,
5406 + * see <http://www.gnu.org/licenses/>.
5407 + *
5408 + * Ubicom32 implementation derived from (with many thanks):
5409 + * arch/m68knommu
5410 + * arch/blackfin
5411 + * arch/parisc
5412 + */
5413 +#ifndef _ASM_UBICOM32_FB_H
5414 +#define _ASM_UBICOM32_FB_H
5415 +#include <linux/fb.h>
5416 +
5417 +#define fb_pgprotect(...) do {} while (0)
5418 +
5419 +static inline int fb_is_primary_device(struct fb_info *info)
5420 +{
5421 + return 0;
5422 +}
5423 +
5424 +#endif /* _ASM_UBICOM32_FB_H */
5425 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/fcntl.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fcntl.h
5426 --- linux-2.6.30.10/arch/ubicom32/include/asm/fcntl.h 1970-01-01 02:00:00.000000000 +0200
5427 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fcntl.h 2009-12-11 11:45:11.000000000 +0200
5428 @@ -0,0 +1,38 @@
5429 +/*
5430 + * arch/ubicom32/include/asm/fcntl.h
5431 + * File control bit definitions for Ubicom32 architecture.
5432 + *
5433 + * (C) Copyright 2009, Ubicom, Inc.
5434 + *
5435 + * This file is part of the Ubicom32 Linux Kernel Port.
5436 + *
5437 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5438 + * it and/or modify it under the terms of the GNU General Public License
5439 + * as published by the Free Software Foundation, either version 2 of the
5440 + * License, or (at your option) any later version.
5441 + *
5442 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5443 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5444 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5445 + * the GNU General Public License for more details.
5446 + *
5447 + * You should have received a copy of the GNU General Public License
5448 + * along with the Ubicom32 Linux Kernel Port. If not,
5449 + * see <http://www.gnu.org/licenses/>.
5450 + *
5451 + * Ubicom32 implementation derived from (with many thanks):
5452 + * arch/m68knommu
5453 + * arch/blackfin
5454 + * arch/parisc
5455 + */
5456 +#ifndef _ASM_UBICOM32_FCNTL_H
5457 +#define _ASM_UBICOM32_FCNTL_H
5458 +
5459 +#define O_DIRECTORY 040000 /* must be a directory */
5460 +#define O_NOFOLLOW 0100000 /* don't follow links */
5461 +#define O_DIRECT 0200000 /* direct disk access hint - currently ignored */
5462 +#define O_LARGEFILE 0400000
5463 +
5464 +#include <asm-generic/fcntl.h>
5465 +
5466 +#endif /* _ASM_UBICOM32_FCNTL_H */
5467 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/flat.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/flat.h
5468 --- linux-2.6.30.10/arch/ubicom32/include/asm/flat.h 1970-01-01 02:00:00.000000000 +0200
5469 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/flat.h 2009-12-11 11:45:11.000000000 +0200
5470 @@ -0,0 +1,73 @@
5471 +/*
5472 + * arch/ubicom32/include/asm/flat.h
5473 + * Definitions to support flat-format executables.
5474 + *
5475 + * (C) Copyright 2009, Ubicom, Inc.
5476 + *
5477 + * This file is part of the Ubicom32 Linux Kernel Port.
5478 + *
5479 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5480 + * it and/or modify it under the terms of the GNU General Public License
5481 + * as published by the Free Software Foundation, either version 2 of the
5482 + * License, or (at your option) any later version.
5483 + *
5484 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5485 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5486 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5487 + * the GNU General Public License for more details.
5488 + *
5489 + * You should have received a copy of the GNU General Public License
5490 + * along with the Ubicom32 Linux Kernel Port. If not,
5491 + * see <http://www.gnu.org/licenses/>.
5492 + *
5493 + * Ubicom32 implementation derived from (with many thanks):
5494 + * arch/m68knommu
5495 + * arch/blackfin
5496 + * arch/parisc
5497 + */
5498 +
5499 +#ifndef _ASM_UBICOM32_FLAT_H
5500 +#define _ASM_UBICOM32_FLAT_H
5501 +
5502 +#define ARCH_FLAT_ALIGN 0x80
5503 +#define ARCH_FLAT_ALIGN_TEXT 1
5504 +
5505 +#define R_UBICOM32_32 2
5506 +#define R_UBICOM32_HI24 7
5507 +#define R_UBICOM32_LO7_S 8
5508 +#define R_UBICOM32_LO7_2_S 9
5509 +#define R_UBICOM32_LO7_4_S 10
5510 +#define R_UBICOM32_LO7_D 11
5511 +#define R_UBICOM32_LO7_2_D 12
5512 +#define R_UBICOM32_LO7_4_D 13
5513 +#define R_UBICOM32_LO7_CALLI 15
5514 +#define R_UBICOM32_LO16_CALLI 16
5515 +
5516 +extern void ubicom32_flat_put_addr_at_rp(unsigned long *rp, u32_t val, u32_t rval, unsigned long *p);
5517 +extern unsigned long ubicom32_flat_get_addr_from_rp(unsigned long *rp, u32_t relval, u32_t flags, unsigned long *p);
5518 +
5519 +#define flat_stack_align(sp) /* nothing needed */
5520 +#define flat_argvp_envp_on_stack() 1
5521 +#define flat_old_ram_flag(flags) (flags)
5522 +#define flat_reloc_valid(reloc, size) ((reloc) <= (size))
5523 +#define flat_get_addr_from_rp(rp, relval, flags, p) (ubicom32_flat_get_addr_from_rp(rp, relval,flags, p))
5524 +#define flat_put_addr_at_rp(rp, val, relval) do {ubicom32_flat_put_addr_at_rp(rp, val, relval, &persistent);} while(0)
5525 +#define flat_get_relocate_addr(rel) ((persistent) ? (persistent & 0x07ffffff) : (rel & 0x07ffffff))
5526 +
5527 +static inline int flat_set_persistent(unsigned int relval, unsigned long *p)
5528 +{
5529 + if (*p) {
5530 + return 0;
5531 + } else {
5532 + if ((relval >> 27) != R_UBICOM32_32) {
5533 + /*
5534 + * Something other than UBICOM32_32. The next entry has the relocation.
5535 + */
5536 + *p = relval;
5537 + return 1;
5538 + }
5539 + }
5540 + return 0;
5541 +}
5542 +
5543 +#endif /* _ASM_UBICOM32_FLAT_H */
5544 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/fpu.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fpu.h
5545 --- linux-2.6.30.10/arch/ubicom32/include/asm/fpu.h 1970-01-01 02:00:00.000000000 +0200
5546 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/fpu.h 2009-12-11 11:45:11.000000000 +0200
5547 @@ -0,0 +1,37 @@
5548 +/*
5549 + * arch/ubicom32/include/asm/fpu.h
5550 + * Floating point state definitions for Ubicom32 architecture.
5551 + *
5552 + * (C) Copyright 2009, Ubicom, Inc.
5553 + *
5554 + * This file is part of the Ubicom32 Linux Kernel Port.
5555 + *
5556 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5557 + * it and/or modify it under the terms of the GNU General Public License
5558 + * as published by the Free Software Foundation, either version 2 of the
5559 + * License, or (at your option) any later version.
5560 + *
5561 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5562 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5563 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5564 + * the GNU General Public License for more details.
5565 + *
5566 + * You should have received a copy of the GNU General Public License
5567 + * along with the Ubicom32 Linux Kernel Port. If not,
5568 + * see <http://www.gnu.org/licenses/>.
5569 + *
5570 + * Ubicom32 implementation derived from (with many thanks):
5571 + * arch/m68knommu
5572 + * arch/blackfin
5573 + * arch/parisc
5574 + */
5575 +#ifndef _ASM_UBICOM32_FPU_H
5576 +#define _ASM_UBICOM32_FPU_H
5577 +
5578 +/*
5579 + * MAX floating point unit state size (FSAVE/FRESTORE)
5580 + */
5581 +/* No FP unit present then... */
5582 +#define FPSTATESIZE (2) /* dummy size */
5583 +
5584 +#endif /* _ASM_UBICOM32_FPU_H */
5585 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ftrace.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ftrace.h
5586 --- linux-2.6.30.10/arch/ubicom32/include/asm/ftrace.h 1970-01-01 02:00:00.000000000 +0200
5587 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ftrace.h 2009-12-11 11:45:11.000000000 +0200
5588 @@ -0,0 +1 @@
5589 +/* empty */
5590 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/futex.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/futex.h
5591 --- linux-2.6.30.10/arch/ubicom32/include/asm/futex.h 1970-01-01 02:00:00.000000000 +0200
5592 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/futex.h 2009-12-11 11:45:11.000000000 +0200
5593 @@ -0,0 +1,33 @@
5594 +/*
5595 + * arch/ubicom32/include/asm/futex.h
5596 + * Generic futex.h for Ubicom32 architecture.
5597 + *
5598 + * (C) Copyright 2009, Ubicom, Inc.
5599 + *
5600 + * This file is part of the Ubicom32 Linux Kernel Port.
5601 + *
5602 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5603 + * it and/or modify it under the terms of the GNU General Public License
5604 + * as published by the Free Software Foundation, either version 2 of the
5605 + * License, or (at your option) any later version.
5606 + *
5607 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5608 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5609 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5610 + * the GNU General Public License for more details.
5611 + *
5612 + * You should have received a copy of the GNU General Public License
5613 + * along with the Ubicom32 Linux Kernel Port. If not,
5614 + * see <http://www.gnu.org/licenses/>.
5615 + *
5616 + * Ubicom32 implementation derived from (with many thanks):
5617 + * arch/m68knommu
5618 + * arch/blackfin
5619 + * arch/parisc
5620 + */
5621 +#ifndef _ASM_UBICOM32_FUTEX_H
5622 +#define _ASM_UBICOM32_FUTEX_H
5623 +
5624 +#include <asm-generic/futex.h>
5625 +
5626 +#endif /* _ASM_UBICOM32_FUTEX_H */
5627 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/.gitignore linux-2.6.30.10-ubi/arch/ubicom32/include/asm/.gitignore
5628 --- linux-2.6.30.10/arch/ubicom32/include/asm/.gitignore 1970-01-01 02:00:00.000000000 +0200
5629 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/.gitignore 2009-12-11 11:45:11.000000000 +0200
5630 @@ -0,0 +1 @@
5631 +/ocm_size.h
5632 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/gpio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/gpio.h
5633 --- linux-2.6.30.10/arch/ubicom32/include/asm/gpio.h 1970-01-01 02:00:00.000000000 +0200
5634 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/gpio.h 2009-12-11 11:45:11.000000000 +0200
5635 @@ -0,0 +1,453 @@
5636 +/*
5637 + * arch/ubicom32/include/asm/gpio.h
5638 + * Definitions for GPIO operations on Ubicom32 architecture.
5639 + *
5640 + * (C) Copyright 2009, Ubicom, Inc.
5641 + *
5642 + * This file is part of the Ubicom32 Linux Kernel Port.
5643 + *
5644 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
5645 + * it and/or modify it under the terms of the GNU General Public License
5646 + * as published by the Free Software Foundation, either version 2 of the
5647 + * License, or (at your option) any later version.
5648 + *
5649 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
5650 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
5651 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
5652 + * the GNU General Public License for more details.
5653 + *
5654 + * You should have received a copy of the GNU General Public License
5655 + * along with the Ubicom32 Linux Kernel Port. If not,
5656 + * see <http://www.gnu.org/licenses/>.
5657 + *
5658 + * Ubicom32 implementation derived from (with many thanks):
5659 + * arch/m68knommu
5660 + * arch/blackfin
5661 + * arch/parisc
5662 + */
5663 +#ifndef _ASM_UBICOM32_GPIO_H
5664 +#define _ASM_UBICOM32_GPIO_H
5665 +
5666 +#include <linux/compiler.h>
5667 +#include <asm/irq.h>
5668 +
5669 +#include <asm/ip5000.h>
5670 +
5671 +#define ARCH_NR_GPIOS 512
5672 +#define MAX_UBICOM_ONCHIP_GPIO (9 * 32)
5673 +
5674 +/*
5675 + * Macros for manipulating GPIO numbers
5676 + */
5677 +#define gpio_bit(gn) (1 << (gn & 0x1f))
5678 +#define gpio_bank(gn) (gn >> 5)
5679 +
5680 +#define gpio_pin_index(gn) (gn & 0x1f)
5681 +#define gpio_port_index(gn) (gn >> 5)
5682 +
5683 +#define GPIO_RA_0 ((32 * 0) + 0)
5684 +#define GPIO_RA_1 ((32 * 0) + 1)
5685 +#define GPIO_RA_2 ((32 * 0) + 2)
5686 +#define GPIO_RA_3 ((32 * 0) + 3)
5687 +#define GPIO_RA_4 ((32 * 0) + 4)
5688 +#define GPIO_RA_5 ((32 * 0) + 5)
5689 +#define GPIO_RA_6 ((32 * 0) + 6)
5690 +#define GPIO_RA_7 ((32 * 0) + 7)
5691 +
5692 +#define GPIO_RB_0 ((32 * 1) + 0)
5693 +#define GPIO_RB_1 ((32 * 1) + 1)
5694 +#define GPIO_RB_2 ((32 * 1) + 2)
5695 +#define GPIO_RB_3 ((32 * 1) + 3)
5696 +#define GPIO_RB_4 ((32 * 1) + 4)
5697 +#define GPIO_RB_5 ((32 * 1) + 5)
5698 +#define GPIO_RB_6 ((32 * 1) + 6)
5699 +#define GPIO_RB_7 ((32 * 1) + 7)
5700 +#define GPIO_RB_8 ((32 * 1) + 8)
5701 +#define GPIO_RB_9 ((32 * 1) + 9)
5702 +#define GPIO_RB_10 ((32 * 1) + 10)
5703 +#define GPIO_RB_11 ((32 * 1) + 11)
5704 +#define GPIO_RB_12 ((32 * 1) + 12)
5705 +#define GPIO_RB_13 ((32 * 1) + 13)
5706 +#define GPIO_RB_14 ((32 * 1) + 14)
5707 +#define GPIO_RB_15 ((32 * 1) + 15)
5708 +#define GPIO_RB_16 ((32 * 1) + 16)
5709 +#define GPIO_RB_17 ((32 * 1) + 17)
5710 +#define GPIO_RB_18 ((32 * 1) + 18)
5711 +#define GPIO_RB_19 ((32 * 1) + 19)
5712 +
5713 +#define GPIO_RC_0 ((32 * 2) + 0)
5714 +#define GPIO_RC_1 ((32 * 2) + 1)
5715 +#define GPIO_RC_2 ((32 * 2) + 2)
5716 +#define GPIO_RC_3 ((32 * 2) + 3)
5717 +#define GPIO_RC_4 ((32 * 2) + 4)
5718 +#define GPIO_RC_5 ((32 * 2) + 5)
5719 +#define GPIO_RC_6 ((32 * 2) + 6)
5720 +#define GPIO_RC_7 ((32 * 2) + 7)
5721 +#define GPIO_RC_8 ((32 * 2) + 8)
5722 +#define GPIO_RC_9 ((32 * 2) + 9)
5723 +#define GPIO_RC_10 ((32 * 2) + 10)
5724 +#define GPIO_RC_11 ((32 * 2) + 11)
5725 +#define GPIO_RC_12 ((32 * 2) + 12)
5726 +#define GPIO_RC_13 ((32 * 2) + 13)
5727 +#define GPIO_RC_14 ((32 * 2) + 14)
5728 +#define GPIO_RC_15 ((32 * 2) + 15)
5729 +#define GPIO_RC_16 ((32 * 2) + 16)
5730 +#define GPIO_RC_17 ((32 * 2) + 17)
5731 +#define GPIO_RC_18 ((32 * 2) + 18)
5732 +#define GPIO_RC_19 ((32 * 2) + 19)
5733 +#define GPIO_RC_20 ((32 * 2) + 20)
5734 +#define GPIO_RC_21 ((32 * 2) + 21)
5735 +#define GPIO_RC_22 ((32 * 2) + 22)
5736 +#define GPIO_RC_23 ((32 * 2) + 23)
5737 +#define GPIO_RC_24 ((32 * 2) + 24)
5738 +#define GPIO_RC_25 ((32 * 2) + 25)
5739 +#define GPIO_RC_26 ((32 * 2) + 26)
5740 +#define GPIO_RC_27 ((32 * 2) + 27)
5741 +#define GPIO_RC_28 ((32 * 2) + 28)
5742 +#define GPIO_RC_29 ((32 * 2) + 29)
5743 +#define GPIO_RC_30 ((32 * 2) + 30)
5744 +#define GPIO_RC_31 ((32 * 2) + 31)
5745 +
5746 +#define GPIO_RD_0 ((32 * 3) + 0)
5747 +#define GPIO_RD_1 ((32 * 3) + 1)
5748 +#define GPIO_RD_2 ((32 * 3) + 2)
5749 +#define GPIO_RD_3 ((32 * 3) + 3)
5750 +#define GPIO_RD_4 ((32 * 3) + 4)
5751 +#define GPIO_RD_5 ((32 * 3) + 5)
5752 +#define GPIO_RD_6 ((32 * 3) + 6)
5753 +#define GPIO_RD_7 ((32 * 3) + 7)
5754 +#define GPIO_RD_8 ((32 * 3) + 8)
5755 +#define GPIO_RD_9 ((32 * 3) + 9)
5756 +#define GPIO_RD_10 ((32 * 3) + 10)
5757 +#define GPIO_RD_11 ((32 * 3) + 11)
5758 +
5759 +#define GPIO_RE_0 ((32 * 4) + 0)
5760 +#define GPIO_RE_1 ((32 * 4) + 1)
5761 +#define GPIO_RE_2 ((32 * 4) + 2)
5762 +#define GPIO_RE_3 ((32 * 4) + 3)
5763 +#define GPIO_RE_4 ((32 * 4) + 4)
5764 +#define GPIO_RE_5 ((32 * 4) + 5)
5765 +#define GPIO_RE_6 ((32 * 4) + 6)
5766 +#define GPIO_RE_7 ((32 * 4) + 7)
5767 +
5768 +#define GPIO_RF_0 ((32 * 5) + 0)
5769 +#define GPIO_RF_1 ((32 * 5) + 1)
5770 +#define GPIO_RF_2 ((32 * 5) + 2)
5771 +#define GPIO_RF_3 ((32 * 5) + 3)
5772 +#define GPIO_RF_4 ((32 * 5) + 4)
5773 +#define GPIO_RF_5 ((32 * 5) + 5)
5774 +#define GPIO_RF_6 ((32 * 5) + 6)
5775 +#define GPIO_RF_7 ((32 * 5) + 7)
5776 +#define GPIO_RF_8 ((32 * 5) + 8)
5777 +#define GPIO_RF_9 ((32 * 5) + 9)
5778 +#define GPIO_RF_10 ((32 * 5) + 10)
5779 +#define GPIO_RF_11 ((32 * 5) + 11)
5780 +#define GPIO_RF_12 ((32 * 5) + 12)
5781 +#define GPIO_RF_13 ((32 * 5) + 13)
5782 +#define GPIO_RF_14 ((32 * 5) + 14)
5783 +#define GPIO_RF_15 ((32 * 5) + 15)
5784 +
5785 +#define GPIO_RG_0 ((32 * 6) + 0)
5786 +#define GPIO_RG_1 ((32 * 6) + 1)
5787 +#define GPIO_RG_2 ((32 * 6) + 2)
5788 +#define GPIO_RG_3 ((32 * 6) + 3)
5789 +#define GPIO_RG_4 ((32 * 6) + 4)
5790 +#define GPIO_RG_5 ((32 * 6) + 5)
5791 +#define GPIO_RG_6 ((32 * 6) + 6)
5792 +#define GPIO_RG_7 ((32 * 6) + 7)
5793 +#define GPIO_RG_8 ((32 * 6) + 8)
5794 +#define GPIO_RG_9 ((32 * 6) + 9)
5795 +#define GPIO_RG_10 ((32 * 6) + 10)
5796 +#define GPIO_RG_11 ((32 * 6) + 11)
5797 +#define GPIO_RG_12 ((32 * 6) + 12)
5798 +#define GPIO_RG_13 ((32 * 6) + 13)
5799 +#define GPIO_RG_14 ((32 * 6) + 14)
5800 +#define GPIO_RG_15 ((32 * 6) + 15)
5801 +#define GPIO_RG_16 ((32 * 6) + 16)
5802 +#define GPIO_RG_17 ((32 * 6) + 17)
5803 +#define GPIO_RG_18 ((32 * 6) + 18)
5804 +#define GPIO_RG_19 ((32 * 6) + 19)
5805 +#define GPIO_RG_20 ((32 * 6) + 20)
5806 +#define GPIO_RG_21 ((32 * 6) + 21)
5807 +#define GPIO_RG_22 ((32 * 6) + 22)
5808 +#define GPIO_RG_23 ((32 * 6) + 23)
5809 +#define GPIO_RG_24 ((32 * 6) + 24)
5810 +#define GPIO_RG_25 ((32 * 6) + 25)
5811 +#define GPIO_RG_26 ((32 * 6) + 26)
5812 +#define GPIO_RG_27 ((32 * 6) + 27)
5813 +#define GPIO_RG_28 ((32 * 6) + 28)
5814 +#define GPIO_RG_29 ((32 * 6) + 29)
5815 +#define GPIO_RG_30 ((32 * 6) + 30)
5816 +#define GPIO_RG_31 ((32 * 6) + 31)
5817 +
5818 +#define GPIO_RH_0 ((32 * 7) + 0)
5819 +#define GPIO_RH_1 ((32 * 7) + 1)
5820 +#define GPIO_RH_2 ((32 * 7) + 2)
5821 +#define GPIO_RH_3 ((32 * 7) + 3)
5822 +#define GPIO_RH_4 ((32 * 7) + 4)
5823 +#define GPIO_RH_5 ((32 * 7) + 5)
5824 +#define GPIO_RH_6 ((32 * 7) + 6)
5825 +#define GPIO_RH_7 ((32 * 7) + 7)
5826 +#define GPIO_RH_8 ((32 * 7) + 8)
5827 +#define GPIO_RH_9 ((32 * 7) + 9)
5828 +
5829 +#define GPIO_RI_0 ((32 * 8) + 0)
5830 +#define GPIO_RI_1 ((32 * 8) + 1)
5831 +#define GPIO_RI_2 ((32 * 8) + 2)
5832 +#define GPIO_RI_3 ((32 * 8) + 3)
5833 +#define GPIO_RI_4 ((32 * 8) + 4)
5834 +#define GPIO_RI_5 ((32 * 8) + 5)
5835 +#define GPIO_RI_6 ((32 * 8) + 6)
5836 +#define GPIO_RI_7 ((32 * 8) + 7)
5837 +#define GPIO_RI_8 ((32 * 8) + 8)
5838 +#define GPIO_RI_9 ((32 * 8) + 9)
5839 +#define GPIO_RI_10 ((32 * 8) + 10)
5840 +#define GPIO_RI_11 ((32 * 8) + 11)
5841 +#define GPIO_RI_12 ((32 * 8) + 12)
5842 +#define GPIO_RI_13 ((32 * 8) + 13)
5843 +#define GPIO_RI_14 ((32 * 8) + 14)
5844 +#define GPIO_RI_15 ((32 * 8) + 15)
5845 +
5846 +/*
5847 + * The following section defines extra GPIO available to some boards.
5848 + * These GPIO are generally external to the processor (i.e. SPI/I2C
5849 + * expander chips).
5850 + *
5851 + * Note that these defines show all possible GPIO available, however,
5852 + * depending on the actual board configuration, some GPIO are not
5853 + * available for use.
5854 + */
5855 +#ifdef CONFIG_IP7500MEDIA
5856 +/*
5857 + * U15
5858 + */
5859 +#define IP7500MEDIA_U15_BASE (32 * 10)
5860 +#define IP7500MEDIA_IO0 (IP7500MEDIA_U15_BASE + 0)
5861 +#define IP7500MEDIA_IO1 (IP7500MEDIA_U15_BASE + 1)
5862 +#define IP7500MEDIA_IO2 (IP7500MEDIA_U15_BASE + 2)
5863 +#define IP7500MEDIA_IO3 (IP7500MEDIA_U15_BASE + 3)
5864 +#define IP7500MEDIA_IO4 (IP7500MEDIA_U15_BASE + 4)
5865 +#define IP7500MEDIA_IO5 (IP7500MEDIA_U15_BASE + 5)
5866 +#define IP7500MEDIA_IO6 (IP7500MEDIA_U15_BASE + 6)
5867 +#define IP7500MEDIA_IO7 (IP7500MEDIA_U15_BASE + 7)
5868 +
5869 +/*
5870 + * U16
5871 + */
5872 +#define IP7500MEDIA_U16_BASE (32 * 11)
5873 +#define IP7500MEDIA_IO8 (IP7500MEDIA_U16_BASE + 0)
5874 +#define IP7500MEDIA_IO9 (IP7500MEDIA_U16_BASE + 1)
5875 +#define IP7500MEDIA_IO10 (IP7500MEDIA_U16_BASE + 2)
5876 +#define IP7500MEDIA_IO11 (IP7500MEDIA_U16_BASE + 3)
5877 +#define IP7500MEDIA_IO12 (IP7500MEDIA_U16_BASE + 4)
5878 +#define IP7500MEDIA_IO13 (IP7500MEDIA_U16_BASE + 5)
5879 +#define IP7500MEDIA_IO14 (IP7500MEDIA_U16_BASE + 6)
5880 +#define IP7500MEDIA_IO15 (IP7500MEDIA_U16_BASE + 7)
5881 +
5882 +/*
5883 + * U17
5884 + */
5885 +#define IP7500MEDIA_U17_BASE (32 * 12)
5886 +#define IP7500MEDIA_IO16 (IP7500MEDIA_U17_BASE + 0)
5887 +#define IP7500MEDIA_IO17 (IP7500MEDIA_U17_BASE + 1)
5888 +#define IP7500MEDIA_IO18 (IP7500MEDIA_U17_BASE + 2)
5889 +#define IP7500MEDIA_IO19 (IP7500MEDIA_U17_BASE + 3)
5890 +#define IP7500MEDIA_IO20 (IP7500MEDIA_U17_BASE + 4)
5891 +#define IP7500MEDIA_IO21 (IP7500MEDIA_U17_BASE + 5)
5892 +#define IP7500MEDIA_IO22 (IP7500MEDIA_U17_BASE + 6)
5893 +#define IP7500MEDIA_IO23 (IP7500MEDIA_U17_BASE + 7)
5894 +
5895 +/*
5896 + * U18
5897 + */
5898 +#define IP7500MEDIA_U18_BASE (32 * 13)
5899 +#define IP7500MEDIA_IO24 (IP7500MEDIA_U18_BASE + 0)
5900 +#define IP7500MEDIA_IO25 (IP7500MEDIA_U18_BASE + 1)
5901 +#define IP7500MEDIA_IO26 (IP7500MEDIA_U18_BASE + 2)
5902 +#define IP7500MEDIA_IO27 (IP7500MEDIA_U18_BASE + 3)
5903 +#define IP7500MEDIA_IO28 (IP7500MEDIA_U18_BASE + 4)
5904 +#define IP7500MEDIA_IO29 (IP7500MEDIA_U18_BASE + 5)
5905 +#define IP7500MEDIA_IO30 (IP7500MEDIA_U18_BASE + 6)
5906 +#define IP7500MEDIA_IO31 (IP7500MEDIA_U18_BASE + 7)
5907 +#endif
5908 +
5909 +#ifdef CONFIG_IP7145DPF
5910 +/*
5911 + * U48
5912 + */
5913 +#define IP7145DPF_U48_BASE (32 * 10)
5914 +#define IP7145DPF_IO0 (IP7145DPF_U48_BASE + 0)
5915 +#define IP7145DPF_IO1 (IP7145DPF_U48_BASE + 1)
5916 +#define IP7145DPF_IO2 (IP7145DPF_U48_BASE + 2)
5917 +#define IP7145DPF_IO3 (IP7145DPF_U48_BASE + 3)
5918 +#define IP7145DPF_IO4 (IP7145DPF_U48_BASE + 4)
5919 +#define IP7145DPF_IO5 (IP7145DPF_U48_BASE + 5)
5920 +#define IP7145DPF_IO6 (IP7145DPF_U48_BASE + 6)
5921 +#define IP7145DPF_IO7 (IP7145DPF_U48_BASE + 7)
5922 +
5923 +/*
5924 + * U72
5925 + */
5926 +#define IP7145DPF_U72_BASE (32 * 11)
5927 +#define IP7145DPF_IOB0 (IP7145DPF_U72_BASE + 0)
5928 +#define IP7145DPF_IOB1 (IP7145DPF_U72_BASE + 1)
5929 +#define IP7145DPF_IOB2 (IP7145DPF_U72_BASE + 2)
5930 +#define IP7145DPF_IOB3 (IP7145DPF_U72_BASE + 3)
5931 +#define IP7145DPF_IOB4 (IP7145DPF_U72_BASE + 4)
5932 +#define IP7145DPF_IOB5 (IP7145DPF_U72_BASE + 5)
5933 +#define IP7145DPF_IOB6 (IP7145DPF_U72_BASE + 6)
5934 +#define IP7145DPF_IOB7 (IP7145DPF_U72_BASE + 7)
5935 +#endif
5936 +
5937 +#include <asm-generic/gpio.h>
5938 +
5939 +/*
5940 + * The following macros bypass gpiolib to generate direct references
5941 + * to the port registers. These assume, minimally, that either
5942 + * gpio_direction_input() or gpio_direction_output() have already been
5943 + * called to setup the pin direction and to enable the pin function to
5944 + * be gpio. These macros generate the hardware port address based on
5945 + * the assumption that all ports are 32 bits wide (even though we know
5946 + * they are not). This is so we can efficiently turn pin numbers into
5947 + * port addresses without a lookup.
5948 + *
5949 + * These operations must be done in one instruction to prevent clobbering
5950 + * other thread's accesses to the same port.
5951 + */
5952 +#define UBICOM32_GPIO_ENABLE(pin) \
5953 + do { \
5954 + asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \
5955 + : \
5956 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_mask), \
5957 + [mask] "d" (gpio_bit(pin)) \
5958 + : "cc", "memory" \
5959 + ); \
5960 + } while (0);
5961 +
5962 +#define UBICOM32_GPIO_DISABLE(pin) \
5963 + do { \
5964 + asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \
5965 + : \
5966 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_mask), \
5967 + [mask] "d" (~gpio_bit(pin)) \
5968 + : "cc", "memory" \
5969 + ); \
5970 + } while (0);
5971 +
5972 +#define UBICOM32_GPIO_SET_PIN_INPUT(pin) \
5973 + do { \
5974 + asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \
5975 + : \
5976 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_ctl), \
5977 + [mask] "d" (~gpio_bit(pin)) \
5978 + : "cc", "memory" \
5979 + ); \
5980 + } while (0);
5981 +
5982 +#define UBICOM32_GPIO_SET_PIN_OUTPUT(pin) \
5983 + do { \
5984 + asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \
5985 + : \
5986 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_ctl), \
5987 + [mask] "d" (gpio_bit(pin)) \
5988 + : "cc", "memory" \
5989 + ); \
5990 + } while (0);
5991 +
5992 +#define UBICOM32_GPIO_SET_PIN_TOGGLE(pin) \
5993 + do { \
5994 + asm volatile ("xor.4 (%[port]), (%[port]), %[mask]\n\t" \
5995 + : \
5996 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \
5997 + [mask] "d" (gpio_bit(pin)) \
5998 + : "cc", "memory" \
5999 + ); \
6000 + } while (0);
6001 +
6002 +#define UBICOM32_GPIO_SET_PIN_HIGH(pin) \
6003 + do { \
6004 + asm volatile ("or.4 (%[port]), (%[port]), %[mask]\n\t" \
6005 + : \
6006 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \
6007 + [mask] "d" (gpio_bit(pin)) \
6008 + : "cc", "memory" \
6009 + ); \
6010 + } while (0);
6011 +
6012 +#define UBICOM32_GPIO_SET_PIN_LOW(pin) \
6013 + do { \
6014 + asm volatile ("and.4 (%[port]), (%[port]), %[mask]\n\t" \
6015 + : \
6016 + : [port] "a" (&UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_out), \
6017 + [mask] "d" (~gpio_bit(pin)) \
6018 + : "cc", "memory" \
6019 + ); \
6020 + } while (0);
6021 +
6022 +#define UBICOM32_GPIO_SET_PIN(pin, val) \
6023 + if ( val ) { \
6024 + UBICOM32_GPIO_SET_PIN_HIGH(pin); \
6025 + } else { \
6026 + UBICOM32_GPIO_SET_PIN_LOW(pin); \
6027 + }
6028 +
6029 +#define UBICOM32_GPIO_GET_PIN(pin) \
6030 + (0 != (UBICOM32_IO_PORT(IO_BASE + (gpio_bank(pin) << 12))->gpio_in \
6031 + & gpio_bit(pin)))
6032 +
6033 +
6034 +static inline int gpio_get_value(unsigned gpio)
6035 +{
6036 + if (gpio <= MAX_UBICOM_ONCHIP_GPIO)
6037 + return UBICOM32_GPIO_GET_PIN(gpio);
6038 + else
6039 + return __gpio_get_value(gpio);
6040 +}
6041 +
6042 +static inline void gpio_set_value(unsigned gpio, int value)
6043 +{
6044 + if (gpio <= MAX_UBICOM_ONCHIP_GPIO)
6045 + {
6046 + UBICOM32_GPIO_SET_PIN(gpio, value);
6047 + }
6048 + else
6049 + {
6050 + __gpio_set_value(gpio, value);
6051 + }
6052 +}
6053 +
6054 +static inline int gpio_cansleep(unsigned gpio)
6055 +{
6056 + return __gpio_cansleep(gpio);
6057 +}
6058 +
6059 +static inline int gpio_to_irq(unsigned gpio)
6060 +{
6061 +#if defined(IP5000) || defined(IP5000_REV2)
6062 + if ((gpio >= GPIO_RA_4) && (gpio <= GPIO_RA_6))
6063 + return 25;
6064 + else
6065 + return -ENXIO;
6066 +
6067 +#elif defined(IP7000) || defined(IP7000_REV2)
6068 + if ((gpio >= GPIO_RA_4) && (gpio <= GPIO_RA_6))
6069 + return 44 + (gpio - GPIO_RA_4);
6070 + else
6071 + return -ENXIO;
6072 +
6073 +#else
6074 + return -ENXIO;
6075 +
6076 +#endif
6077 +}
6078 +
6079 +static inline int irq_to_gpio(unsigned gpio)
6080 +{
6081 + return -ENXIO;
6082 +}
6083 +
6084 +extern struct ubicom32_io_port *ubi_gpio_get_port(unsigned gpio);
6085 +
6086 +extern int __init ubi_gpio_init(void);
6087 +
6088 +#endif /* _ASM_UBICOM32_GPIO_H */
6089 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/hardirq.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/hardirq.h
6090 --- linux-2.6.30.10/arch/ubicom32/include/asm/hardirq.h 1970-01-01 02:00:00.000000000 +0200
6091 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/hardirq.h 2009-12-11 11:45:11.000000000 +0200
6092 @@ -0,0 +1,55 @@
6093 +/*
6094 + * arch/ubicom32/include/asm/hardirq.h
6095 + * Definition of ack_bad_irq() for Ubicom32 architecture.
6096 + *
6097 + * (C) Copyright 2009, Ubicom, Inc.
6098 + * Copyright (C) 1997, 98, 99, 2000, 01, 05 Ralf Baechle (ralf@linux-mips.org)
6099 + * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
6100 + * Copyright (C) 2001 MIPS Technologies, Inc.
6101 + *
6102 + * This file is part of the Ubicom32 Linux Kernel Port.
6103 + *
6104 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6105 + * it and/or modify it under the terms of the GNU General Public License
6106 + * as published by the Free Software Foundation, either version 2 of the
6107 + * License, or (at your option) any later version.
6108 + *
6109 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6110 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6111 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6112 + * the GNU General Public License for more details.
6113 + *
6114 + * You should have received a copy of the GNU General Public License
6115 + * along with the Ubicom32 Linux Kernel Port. If not,
6116 + * see <http://www.gnu.org/licenses/>.
6117 + *
6118 + * Ubicom32 implementation derived from (with many thanks):
6119 + * arch/m68knommu
6120 + * arch/blackfin
6121 + * arch/parisc
6122 + */
6123 +#ifndef _ASM_UBICOM32_HARDIRQ_H
6124 +#define _ASM_UBICOM32_HARDIRQ_H
6125 +
6126 +#include <linux/threads.h>
6127 +#include <linux/irq.h>
6128 +
6129 +/*
6130 + * The hardirq mask has to be large enough to have space
6131 + * for potentially all IRQ sources in the system nesting
6132 + * on a single CPU. For Ubicom32, we have 64 IRQ sources.
6133 + */
6134 +#define HARDIRQ_BITS 6
6135 +#if (1 << HARDIRQ_BITS) < NR_IRQS
6136 +# error HARDIRQ_BITS is too low!
6137 +#endif
6138 +
6139 +typedef struct {
6140 + unsigned int __softirq_pending;
6141 +} ____cacheline_aligned irq_cpustat_t;
6142 +
6143 +#include <linux/irq_cpustat.h> /* Standard mappings for irq_cpustat_t above */
6144 +
6145 +extern void ack_bad_irq(unsigned int irq);
6146 +
6147 +#endif /* _ASM_UBICOM32_HARDIRQ_H */
6148 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/hw_irq.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/hw_irq.h
6149 --- linux-2.6.30.10/arch/ubicom32/include/asm/hw_irq.h 1970-01-01 02:00:00.000000000 +0200
6150 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/hw_irq.h 2009-12-11 11:45:11.000000000 +0200
6151 @@ -0,0 +1,31 @@
6152 +/*
6153 + * arch/ubicom32/include/asm/hw_irq.h
6154 + * Ubicom32 architecture APIC support.
6155 + *
6156 + * (C) Copyright 2009, Ubicom, Inc.
6157 + *
6158 + * This file is part of the Ubicom32 Linux Kernel Port.
6159 + *
6160 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6161 + * it and/or modify it under the terms of the GNU General Public License
6162 + * as published by the Free Software Foundation, either version 2 of the
6163 + * License, or (at your option) any later version.
6164 + *
6165 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6166 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6167 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6168 + * the GNU General Public License for more details.
6169 + *
6170 + * You should have received a copy of the GNU General Public License
6171 + * along with the Ubicom32 Linux Kernel Port. If not,
6172 + * see <http://www.gnu.org/licenses/>.
6173 + *
6174 + * Ubicom32 implementation derived from (with many thanks):
6175 + * arch/m68knommu
6176 + * arch/blackfin
6177 + * arch/parisc
6178 + */
6179 +#ifndef _ASM_UBICOM32_HW_IRQ_H
6180 +#define _ASM_UBICOM32_HW_IRQ_H
6181 +
6182 +#endif /* _ASM_UBICOM32_HW_IRQ_H */
6183 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ioctl.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ioctl.h
6184 --- linux-2.6.30.10/arch/ubicom32/include/asm/ioctl.h 1970-01-01 02:00:00.000000000 +0200
6185 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ioctl.h 2009-12-11 11:45:11.000000000 +0200
6186 @@ -0,0 +1,33 @@
6187 +/*
6188 + * arch/ubicom32/include/asm/ioctl.h
6189 + * Generic ioctl.h for Ubicom32 architecture.
6190 + *
6191 + * (C) Copyright 2009, Ubicom, Inc.
6192 + *
6193 + * This file is part of the Ubicom32 Linux Kernel Port.
6194 + *
6195 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6196 + * it and/or modify it under the terms of the GNU General Public License
6197 + * as published by the Free Software Foundation, either version 2 of the
6198 + * License, or (at your option) any later version.
6199 + *
6200 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6201 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6202 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6203 + * the GNU General Public License for more details.
6204 + *
6205 + * You should have received a copy of the GNU General Public License
6206 + * along with the Ubicom32 Linux Kernel Port. If not,
6207 + * see <http://www.gnu.org/licenses/>.
6208 + *
6209 + * Ubicom32 implementation derived from (with many thanks):
6210 + * arch/m68knommu
6211 + * arch/blackfin
6212 + * arch/parisc
6213 + */
6214 +#ifndef _ASM_UBICOM32_IOCTL_H
6215 +#define _ASM_UBICOM32_IOCTL_H
6216 +
6217 +#include <asm-generic/ioctl.h>
6218 +
6219 +#endif /* _ASM_UBICOM32_IOCTL_H */
6220 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ioctls.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ioctls.h
6221 --- linux-2.6.30.10/arch/ubicom32/include/asm/ioctls.h 1970-01-01 02:00:00.000000000 +0200
6222 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ioctls.h 2009-12-11 11:45:11.000000000 +0200
6223 @@ -0,0 +1,111 @@
6224 +/*
6225 + * arch/ubicom32/include/asm/ioctls.h
6226 + * Definitions of ioctls for Ubicom32 architecture.
6227 + *
6228 + * (C) Copyright 2009, Ubicom, Inc.
6229 + *
6230 + * This file is part of the Ubicom32 Linux Kernel Port.
6231 + *
6232 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6233 + * it and/or modify it under the terms of the GNU General Public License
6234 + * as published by the Free Software Foundation, either version 2 of the
6235 + * License, or (at your option) any later version.
6236 + *
6237 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6238 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6239 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6240 + * the GNU General Public License for more details.
6241 + *
6242 + * You should have received a copy of the GNU General Public License
6243 + * along with the Ubicom32 Linux Kernel Port. If not,
6244 + * see <http://www.gnu.org/licenses/>.
6245 + *
6246 + * Ubicom32 implementation derived from (with many thanks):
6247 + * arch/m68knommu
6248 + * arch/blackfin
6249 + * arch/parisc
6250 + */
6251 +#ifndef _ASM_UBICOM32_IOCTLS_H
6252 +#define _ASM_UBICOM32_IOCTLS_H
6253 +
6254 +#include <asm/ioctl.h>
6255 +
6256 +/* 0x54 is just a magic number to make these relatively unique ('T') */
6257 +
6258 +#define TCGETS 0x5401
6259 +#define TCSETS 0x5402
6260 +#define TCSETSW 0x5403
6261 +#define TCSETSF 0x5404
6262 +#define TCGETA 0x5405
6263 +#define TCSETA 0x5406
6264 +#define TCSETAW 0x5407
6265 +#define TCSETAF 0x5408
6266 +#define TCSBRK 0x5409
6267 +#define TCXONC 0x540A
6268 +#define TCFLSH 0x540B
6269 +#define TIOCEXCL 0x540C
6270 +#define TIOCNXCL 0x540D
6271 +#define TIOCSCTTY 0x540E
6272 +#define TIOCGPGRP 0x540F
6273 +#define TIOCSPGRP 0x5410
6274 +#define TIOCOUTQ 0x5411
6275 +#define TIOCSTI 0x5412
6276 +#define TIOCGWINSZ 0x5413
6277 +#define TIOCSWINSZ 0x5414
6278 +#define TIOCMGET 0x5415
6279 +#define TIOCMBIS 0x5416
6280 +#define TIOCMBIC 0x5417
6281 +#define TIOCMSET 0x5418
6282 +#define TIOCGSOFTCAR 0x5419
6283 +#define TIOCSSOFTCAR 0x541A
6284 +#define FIONREAD 0x541B
6285 +#define TIOCINQ FIONREAD
6286 +#define TIOCLINUX 0x541C
6287 +#define TIOCCONS 0x541D
6288 +#define TIOCGSERIAL 0x541E
6289 +#define TIOCSSERIAL 0x541F
6290 +#define TIOCPKT 0x5420
6291 +#define FIONBIO 0x5421
6292 +#define TIOCNOTTY 0x5422
6293 +#define TIOCSETD 0x5423
6294 +#define TIOCGETD 0x5424
6295 +#define TCSBRKP 0x5425 /* Needed for POSIX tcsendbreak() */
6296 +#define TIOCSBRK 0x5427 /* BSD compatibility */
6297 +#define TIOCCBRK 0x5428 /* BSD compatibility */
6298 +#define TIOCGSID 0x5429 /* Return the session ID of FD */
6299 +#define TCGETS2 _IOR('T',0x2A, struct termios2)
6300 +#define TCSETS2 _IOW('T',0x2B, struct termios2)
6301 +#define TCSETSW2 _IOW('T',0x2C, struct termios2)
6302 +#define TCSETSF2 _IOW('T',0x2D, struct termios2)
6303 +#define TIOCGPTN _IOR('T',0x30, unsigned int) /* Get Pty Number (of pty-mux device) */
6304 +#define TIOCSPTLCK _IOW('T',0x31, int) /* Lock/unlock Pty */
6305 +
6306 +#define FIONCLEX 0x5450 /* these numbers need to be adjusted. */
6307 +#define FIOCLEX 0x5451
6308 +#define FIOASYNC 0x5452
6309 +#define TIOCSERCONFIG 0x5453
6310 +#define TIOCSERGWILD 0x5454
6311 +#define TIOCSERSWILD 0x5455
6312 +#define TIOCGLCKTRMIOS 0x5456
6313 +#define TIOCSLCKTRMIOS 0x5457
6314 +#define TIOCSERGSTRUCT 0x5458 /* For debugging only */
6315 +#define TIOCSERGETLSR 0x5459 /* Get line status register */
6316 +#define TIOCSERGETMULTI 0x545A /* Get multiport config */
6317 +#define TIOCSERSETMULTI 0x545B /* Set multiport config */
6318 +
6319 +#define TIOCMIWAIT 0x545C /* wait for a change on serial input line(s) */
6320 +#define TIOCGICOUNT 0x545D /* read serial port inline interrupt counts */
6321 +#define FIOQSIZE 0x545E
6322 +
6323 +/* Used for packet mode */
6324 +#define TIOCPKT_DATA 0
6325 +#define TIOCPKT_FLUSHREAD 1
6326 +#define TIOCPKT_FLUSHWRITE 2
6327 +#define TIOCPKT_STOP 4
6328 +#define TIOCPKT_START 8
6329 +#define TIOCPKT_NOSTOP 16
6330 +#define TIOCPKT_DOSTOP 32
6331 +
6332 +#define TIOCSER_TEMT 0x01 /* Transmitter physically empty */
6333 +
6334 +#endif /* _ASM_UBICOM32_IOCTLS_H */
6335 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/io.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/io.h
6336 --- linux-2.6.30.10/arch/ubicom32/include/asm/io.h 1970-01-01 02:00:00.000000000 +0200
6337 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/io.h 2009-12-11 11:45:11.000000000 +0200
6338 @@ -0,0 +1,313 @@
6339 +/*
6340 + * arch/ubicom32/include/asm/io.h
6341 + * I/O memory accessor functions for Ubicom32 architecture.
6342 + *
6343 + * (C) Copyright 2009, Ubicom, Inc.
6344 + *
6345 + * This file is part of the Ubicom32 Linux Kernel Port.
6346 + *
6347 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6348 + * it and/or modify it under the terms of the GNU General Public License
6349 + * as published by the Free Software Foundation, either version 2 of the
6350 + * License, or (at your option) any later version.
6351 + *
6352 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6353 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6354 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6355 + * the GNU General Public License for more details.
6356 + *
6357 + * You should have received a copy of the GNU General Public License
6358 + * along with the Ubicom32 Linux Kernel Port. If not,
6359 + * see <http://www.gnu.org/licenses/>.
6360 + *
6361 + * Ubicom32 implementation derived from (with many thanks):
6362 + * arch/m68knommu
6363 + * arch/blackfin
6364 + * arch/parisc
6365 + */
6366 +#ifndef _ASM_UBICOM32_IO_H
6367 +#define _ASM_UBICOM32_IO_H
6368 +
6369 +#ifdef __KERNEL__
6370 +#include <linux/string.h>
6371 +#include <linux/compiler.h>
6372 +
6373 +static inline unsigned short _swapw(volatile unsigned short v)
6374 +{
6375 + return ((v << 8) | (v >> 8));
6376 +}
6377 +
6378 +static inline unsigned int _swapl(volatile unsigned long v)
6379 +{
6380 + return ((v << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | (v >> 24));
6381 +}
6382 +
6383 +#ifndef CONFIG_PCI
6384 +#define readb(addr) \
6385 + ({ unsigned char __v = (*(volatile unsigned char *) (addr)); __v; })
6386 +#define readw(addr) \
6387 + ({ unsigned short __v = (*(volatile unsigned short *) (addr)); __v; })
6388 +#define readl(addr) \
6389 + ({ unsigned int __v = (*(volatile unsigned int *) (addr)); __v; })
6390 +
6391 +#define writeb(b,addr) (void)((*(volatile unsigned char *) (addr)) = (b))
6392 +#define writew(b,addr) (void)((*(volatile unsigned short *) (addr)) = (b))
6393 +#define writel(b,addr) (void)((*(volatile unsigned int *) (addr)) = (b))
6394 +#else /*CONFIG_PCI */
6395 +
6396 +#define PCI_CPU_REG_BASE (0x00000000UL) /* taking lower 2GB space */
6397 +#define PCI_DEV_REG_BASE (0x80000000UL)
6398 +
6399 +#if PCI_CPU_REG_BASE > PCI_DEV_REG_BASE
6400 +#define IS_PCI_ADDRESS(x) (((unsigned int)(x)&(PCI_CPU_REG_BASE)) == 0)
6401 +#else
6402 +#define IS_PCI_ADDRESS(x) ((unsigned int)(x)&(PCI_DEV_REG_BASE))
6403 +#endif
6404 +
6405 +extern unsigned int ubi32_pci_read_u32(const volatile void __iomem *addr);
6406 +extern unsigned short ubi32_pci_read_u16(const volatile void __iomem *addr);
6407 +extern unsigned char ubi32_pci_read_u8(const volatile void __iomem *addr);
6408 +extern void ubi32_pci_write_u32(unsigned int val, const volatile void __iomem *addr);
6409 +extern void ubi32_pci_write_u16(unsigned short val, const volatile void __iomem *addr);
6410 +extern void ubi32_pci_write_u8(unsigned char val, const volatile void __iomem *addr);
6411 +
6412 +static inline unsigned char readb(const volatile void __iomem *addr)
6413 +{
6414 + if (IS_PCI_ADDRESS(addr))
6415 + return ubi32_pci_read_u8(addr);
6416 + else
6417 + return (unsigned char)(*(volatile unsigned char *)addr);
6418 +}
6419 +static inline unsigned short readw(const volatile void __iomem *addr)
6420 +{
6421 + if (IS_PCI_ADDRESS(addr))
6422 + return ubi32_pci_read_u16(addr);
6423 + else
6424 + return (unsigned short)(*(volatile unsigned short *)addr);
6425 +}
6426 +
6427 +static inline unsigned int readl(const volatile void __iomem *addr)
6428 +{
6429 + if (IS_PCI_ADDRESS(addr))
6430 + return ubi32_pci_read_u32(addr);
6431 + else
6432 + return (unsigned int)(*(volatile unsigned int *)addr);
6433 +}
6434 +
6435 +static inline void writel(unsigned int val, volatile void __iomem *addr)
6436 +{
6437 + if (IS_PCI_ADDRESS(addr))
6438 + ubi32_pci_write_u32(val, addr);
6439 + else
6440 + *(volatile unsigned int *)addr = val;
6441 +}
6442 +
6443 +static inline void writew(unsigned short val, volatile void __iomem *addr)
6444 +{
6445 + if (IS_PCI_ADDRESS(addr))
6446 + ubi32_pci_write_u16(val, addr);
6447 + else
6448 + *(volatile unsigned short *)addr = val;
6449 +}
6450 +
6451 +static inline void writeb(unsigned char val, volatile void __iomem *addr)
6452 +{
6453 + if (IS_PCI_ADDRESS(addr))
6454 + ubi32_pci_write_u8(val, addr);
6455 + else
6456 + *(volatile unsigned char *)addr = val;
6457 +}
6458 +#endif
6459 +
6460 +#define readb_relaxed(addr) readb(addr)
6461 +#define readw_relaxed(addr) readw(addr)
6462 +#define readl_relaxed(addr) readl(addr)
6463 +
6464 +
6465 +#define __raw_readb readb
6466 +#define __raw_readw readw
6467 +#define __raw_readl readl
6468 +#define __raw_writeb writeb
6469 +#define __raw_writew writew
6470 +#define __raw_writel writel
6471 +
6472 +static inline void io_outsb(unsigned int addr, const void *buf, int len)
6473 +{
6474 + volatile unsigned char *ap = (volatile unsigned char *) addr;
6475 + unsigned char *bp = (unsigned char *) buf;
6476 + while (len--)
6477 + *ap = *bp++;
6478 +}
6479 +
6480 +static inline void io_outsw(unsigned int addr, const void *buf, int len)
6481 +{
6482 + volatile unsigned short *ap = (volatile unsigned short *) addr;
6483 + unsigned short *bp = (unsigned short *) buf;
6484 + while (len--)
6485 + *ap = _swapw(*bp++);
6486 +}
6487 +
6488 +static inline void io_outsl(unsigned int addr, const void *buf, int len)
6489 +{
6490 + volatile unsigned int *ap = (volatile unsigned int *) addr;
6491 + unsigned int *bp = (unsigned int *) buf;
6492 + while (len--)
6493 + *ap = _swapl(*bp++);
6494 +}
6495 +
6496 +static inline void io_insb(unsigned int addr, void *buf, int len)
6497 +{
6498 + volatile unsigned char *ap = (volatile unsigned char *) addr;
6499 + unsigned char *bp = (unsigned char *) buf;
6500 + while (len--)
6501 + *bp++ = *ap;
6502 +}
6503 +
6504 +static inline void io_insw(unsigned int addr, void *buf, int len)
6505 +{
6506 + volatile unsigned short *ap = (volatile unsigned short *) addr;
6507 + unsigned short *bp = (unsigned short *) buf;
6508 + while (len--)
6509 + *bp++ = _swapw(*ap);
6510 +}
6511 +
6512 +static inline void io_insl(unsigned int addr, void *buf, int len)
6513 +{
6514 + volatile unsigned int *ap = (volatile unsigned int *) addr;
6515 + unsigned int *bp = (unsigned int *) buf;
6516 + while (len--)
6517 + *bp++ = _swapl(*ap);
6518 +}
6519 +
6520 +#define mmiowb()
6521 +
6522 +/*
6523 + * make the short names macros so specific devices
6524 + * can override them as required
6525 + */
6526 +#ifndef CONFIG_PCI
6527 +#define memset_io(a,b,c) memset((void *)(a),(b),(c))
6528 +#define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c))
6529 +#define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c))
6530 +#else
6531 +extern void memcpy_fromio(void *to, const volatile void __iomem *from, unsigned len);
6532 +extern void memcpy_toio(volatile void __iomem *to, const void *from, unsigned len);
6533 +extern void memset_io(volatile void __iomem *addr, int val, size_t count);
6534 +#endif
6535 +
6536 +#define inb(addr) readb(addr)
6537 +#define inw(addr) readw(addr)
6538 +#define inl(addr) readl(addr)
6539 +#define outb(x,addr) ((void) writeb(x,addr))
6540 +#define outw(x,addr) ((void) writew(x,addr))
6541 +#define outl(x,addr) ((void) writel(x,addr))
6542 +
6543 +#define inb_p(addr) inb(addr)
6544 +#define inw_p(addr) inw(addr)
6545 +#define inl_p(addr) inl(addr)
6546 +#define outb_p(x,addr) outb(x,addr)
6547 +#define outw_p(x,addr) outw(x,addr)
6548 +#define outl_p(x,addr) outl(x,addr)
6549 +
6550 +#define outsb(a,b,l) io_outsb(a,b,l)
6551 +#define outsw(a,b,l) io_outsw(a,b,l)
6552 +#define outsl(a,b,l) io_outsl(a,b,l)
6553 +
6554 +#define insb(a,b,l) io_insb(a,b,l)
6555 +#define insw(a,b,l) io_insw(a,b,l)
6556 +#define insl(a,b,l) io_insl(a,b,l)
6557 +
6558 +#ifndef CONFIG_PCI
6559 +#define ioread8_rep(a,d,c) insb(a,d,c)
6560 +#define ioread16_rep(a,d,c) insw(a,d,c)
6561 +#define ioread32_rep(a,d,c) insl(a,d,c)
6562 +#define iowrite8_rep(a,s,c) outsb(a,s,c)
6563 +#define iowrite16_rep(a,s,c) outsw(a,s,c)
6564 +#define iowrite32_rep(a,s,c) outsl(a,s,c)
6565 +#else
6566 +extern void ioread8_rep(void __iomem *port, void *buf, unsigned long count);
6567 +extern void ioread16_rep(void __iomem *port, void *buf, unsigned long count);
6568 +extern void ioread32_rep(void __iomem *port, void *buf, unsigned long count);
6569 +extern void iowrite8_rep(void __iomem *port, const void *buf, unsigned long count);
6570 +extern void iowrite16_rep(void __iomem *port, const void *buf, unsigned long count);
6571 +extern void iowrite32_rep(void __iomem *port, const void *buf, unsigned long count);
6572 +#endif
6573 +
6574 +
6575 +#ifndef CONFIG_PCI
6576 +#define ioread8(X) readb(X)
6577 +#define ioread16(X) readw(X)
6578 +#define ioread32(X) readl(X)
6579 +#define iowrite8(val,X) writeb(val,X)
6580 +#define iowrite16(val,X) writew(val,X)
6581 +#define iowrite32(val,X) writel(val,X)
6582 +#else /*CONFIG_PCI */
6583 +extern unsigned char ioread8(void __iomem *addr);
6584 +extern unsigned short ioread16(void __iomem *addr);
6585 +extern unsigned int ioread32(void __iomem *addr);
6586 +extern void iowrite8(unsigned char val, void __iomem *addr);
6587 +extern void iowrite16(unsigned short val, void __iomem *addr);
6588 +extern void iowrite32(unsigned int val, void __iomem *addr);
6589 +#endif /* CONFIG_PCI */
6590 +
6591 +#define IO_SPACE_LIMIT 0xffff
6592 +
6593 +/* Values for nocacheflag and cmode */
6594 +#define IOMAP_FULL_CACHING 0
6595 +#define IOMAP_NOCACHE_SER 1
6596 +#define IOMAP_NOCACHE_NONSER 2
6597 +#define IOMAP_WRITETHROUGH 3
6598 +
6599 +extern void *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag);
6600 +extern void __iounmap(void *addr, unsigned long size);
6601 +
6602 +static inline void *ioremap(unsigned long physaddr, unsigned long size)
6603 +{
6604 + return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
6605 +}
6606 +static inline void *ioremap_nocache(unsigned long physaddr, unsigned long size)
6607 +{
6608 + return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
6609 +}
6610 +static inline void *ioremap_writethrough(unsigned long physaddr, unsigned long size)
6611 +{
6612 + return __ioremap(physaddr, size, IOMAP_WRITETHROUGH);
6613 +}
6614 +static inline void *ioremap_fullcache(unsigned long physaddr, unsigned long size)
6615 +{
6616 + return __ioremap(physaddr, size, IOMAP_FULL_CACHING);
6617 +}
6618 +
6619 +extern void iounmap(void *addr);
6620 +
6621 +#define ioport_map(port, nr) ((void __iomem*)(port))
6622 +#define ioport_unmap(addr)
6623 +
6624 +
6625 +/* Pages to physical address... */
6626 +#define page_to_phys(page) ((page - mem_map) << PAGE_SHIFT)
6627 +#define page_to_bus(page) ((page - mem_map) << PAGE_SHIFT)
6628 +
6629 +/*
6630 + * Macros used for converting between virtual and physical mappings.
6631 + */
6632 +#define phys_to_virt(vaddr) ((void *) (vaddr))
6633 +#define virt_to_phys(vaddr) ((unsigned long) (vaddr))
6634 +
6635 +#define virt_to_bus virt_to_phys
6636 +#define bus_to_virt phys_to_virt
6637 +
6638 +/*
6639 + * Convert a physical pointer to a virtual kernel pointer for /dev/mem
6640 + * access
6641 + */
6642 +#define xlate_dev_mem_ptr(p) __va(p)
6643 +
6644 +/*
6645 + * Convert a virtual cached pointer to an uncached pointer
6646 + */
6647 +#define xlate_dev_kmem_ptr(p) p
6648 +
6649 +#endif /* __KERNEL__ */
6650 +
6651 +#endif /* _ASM_UBICOM32_IO_H */
6652 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ip5000-asm.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ip5000-asm.h
6653 --- linux-2.6.30.10/arch/ubicom32/include/asm/ip5000-asm.h 1970-01-01 02:00:00.000000000 +0200
6654 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ip5000-asm.h 2009-12-11 11:45:11.000000000 +0200
6655 @@ -0,0 +1,156 @@
6656 +/*
6657 + * arch/ubicom32/include/asm/ip5000-asm.h
6658 + * Instruction macros for the IP5000.
6659 + *
6660 + * (C) Copyright 2009, Ubicom, Inc.
6661 + *
6662 + * This file is part of the Ubicom32 Linux Kernel Port.
6663 + *
6664 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6665 + * it and/or modify it under the terms of the GNU General Public License
6666 + * as published by the Free Software Foundation, either version 2 of the
6667 + * License, or (at your option) any later version.
6668 + *
6669 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6670 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6671 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6672 + * the GNU General Public License for more details.
6673 + *
6674 + * You should have received a copy of the GNU General Public License
6675 + * along with the Ubicom32 Linux Kernel Port. If not,
6676 + * see <http://www.gnu.org/licenses/>.
6677 + *
6678 + * Ubicom32 implementation derived from (with many thanks):
6679 + * arch/m68knommu
6680 + * arch/blackfin
6681 + * arch/parisc
6682 + */
6683 +
6684 +#ifndef _ASM_UBICOM32_IP5000_ASM_H
6685 +#define _ASM_UBICOM32_IP5000_ASM_H
6686 +
6687 +#if !defined(__LINKER__)
6688 +
6689 +#if defined(__ASSEMBLY__)
6690 +.macro cycles quant
6691 +.if (\quant) == 1
6692 + nop
6693 +.else
6694 +.if (((\quant) + 3) / 8) > 0
6695 +.rept (((\quant) + 3) / 8)
6696 + jmpt.f .+4
6697 +.endr
6698 +.endif
6699 +.if ((((\quant) + 3) % 8) / 4) > 0
6700 + jmpt.t .+4
6701 +.endif
6702 +.endif
6703 +.endm
6704 +#else
6705 +/*
6706 + * Same macro as above just in C inline asm
6707 + */
6708 +asm (" \n\
6709 +.macro cycles quant \n\
6710 +.if (\\quant) == 1 \n\
6711 + nop \n\
6712 +.else \n\
6713 +.if (((\\quant) + 3) / 8) > 0 \n\
6714 +.rept (((\\quant) + 3) / 8) \n\
6715 + jmpt.f .+4 \n\
6716 +.endr \n\
6717 +.endif \n\
6718 +.if ((((\\quant) + 3) % 8) / 4) > 0 \n\
6719 + jmpt.t .+4 \n\
6720 +.endif \n\
6721 +.endif \n\
6722 +.endm \n\
6723 +");
6724 +#endif
6725 +
6726 +
6727 +#if defined(__ASSEMBLY__)
6728 +.macro pipe_flush cyc
6729 + cycles 11 - (\cyc)
6730 +.endm
6731 +#else
6732 +/*
6733 + * Same macro as above just in C inline asm
6734 + */
6735 +asm (" \n\
6736 +.macro pipe_flush cyc \n\
6737 + cycles 11 - (\\cyc) \n\
6738 +.endm \n\
6739 +");
6740 +
6741 +#endif
6742 +
6743 +#if defined(__ASSEMBLY__)
6744 +.macro setcsr_flush cyc
6745 + cycles 5 - (\cyc)
6746 +.endm
6747 +#else
6748 +/*
6749 + * Same macro as above just in C inline asm
6750 + */
6751 +asm (" \n\
6752 +.macro setcsr_flush cyc \n\
6753 + cycles 5 - (\\cyc) \n\
6754 +.endm \n\
6755 +");
6756 +#endif
6757 +
6758 +/*
6759 + * Macros for prefetch (using miss-aligned memory write)
6760 + */
6761 +#if defined(__ASSEMBLY__)
6762 +
6763 +.macro pre_fetch_macro thread_num, Ascratch, Aaddress length
6764 + bclr MT_TRAP_EN, MT_TRAP_EN, #(\thread_num)
6765 + bset \Ascratch, \Aaddress, #0 ; force a miss-aligned address
6766 + jmpt.t .+4 ; delay for both address setup and trap disable
6767 + move.4 (\Ascratch), #0
6768 + .if (\length > 32)
6769 + move.4 32(\Ascratch), #0
6770 + .endif
6771 + .if (\length > 64)
6772 + move.4 64(\Ascratch), #0
6773 + .endif
6774 + .if (\length > 96)
6775 + move.4 96(\Ascratch), #0
6776 + .endif
6777 + .if (\length > 128)
6778 + invalid_instruction ; maximum pre-fetch size is 4 cache lines
6779 + .endif
6780 + bset MT_TRAP_EN, MT_TRAP_EN, #(\thread_num)
6781 +.endm
6782 +
6783 +#else
6784 +/*
6785 + * Same macro as above just in C inline asm
6786 + */
6787 +asm (" \n\
6788 +.macro pre_fetch_macro thread_num, Ascratch, Aaddress length \n\
6789 + bclr MT_TRAP_EN, MT_TRAP_EN, #(\thread_num) \n\
6790 + bset \\Ascratch, \\Aaddress, #0 ; force a miss-aligned address \n\
6791 + jmpt.t .+4 ; delay for both address setup and trap disable \n\
6792 + move.4 (\\Ascratch), #0 \n\
6793 + .if (\\length > 32) \n\
6794 + move.4 32(\\Ascratch), #0 \n\
6795 + .endif \n\
6796 + .if (\\length > 64) \n\
6797 + move.4 64(\\Ascratch), #0 \n\
6798 + .endif \n\
6799 + .if (\\length > 96) \n\
6800 + move.4 96(\\Ascratch), #0 \n\
6801 + .endif \n\
6802 + .if (\\length > 128) \n\
6803 + invalid_instruction ; maximum pre-fetch size is 4 cache lines \n\
6804 + .endif \n\
6805 + bset MT_TRAP_EN, MT_TRAP_EN, #(\\thread_num) \n\
6806 +.endm \n\
6807 +");
6808 +#endif
6809 +
6810 +#endif /* !defined(__LINKER__) */
6811 +#endif /* defined _ASM_UBICOM32_IP5000_ASM_H */
6812 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ip5000.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ip5000.h
6813 --- linux-2.6.30.10/arch/ubicom32/include/asm/ip5000.h 1970-01-01 02:00:00.000000000 +0200
6814 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ip5000.h 2009-12-11 11:45:11.000000000 +0200
6815 @@ -0,0 +1,845 @@
6816 +/*
6817 + * arch/ubicom32/include/asm/ip5000.h
6818 + * Specific details for the Ubicom IP5000 processor.
6819 + *
6820 + * (C) Copyright 2009, Ubicom, Inc.
6821 + *
6822 + * This file is part of the Ubicom32 Linux Kernel Port.
6823 + *
6824 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
6825 + * it and/or modify it under the terms of the GNU General Public License
6826 + * as published by the Free Software Foundation, either version 2 of the
6827 + * License, or (at your option) any later version.
6828 + *
6829 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
6830 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
6831 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
6832 + * the GNU General Public License for more details.
6833 + *
6834 + * You should have received a copy of the GNU General Public License
6835 + * along with the Ubicom32 Linux Kernel Port. If not,
6836 + * see <http://www.gnu.org/licenses/>.
6837 + *
6838 + * Ubicom32 implementation derived from (with many thanks):
6839 + * arch/m68knommu
6840 + * arch/blackfin
6841 + * arch/parisc
6842 + */
6843 +
6844 +#ifndef _ASM_UBICOM32_IP5000_H
6845 +#define _ASM_UBICOM32_IP5000_H
6846 +
6847 +#include <asm/memory_map.h>
6848 +
6849 +/*
6850 + * Inline assembly define
6851 + */
6852 +#define S(arg) #arg
6853 +#define D(arg) S(arg)
6854 +
6855 +/*
6856 + * Assembler include file
6857 + */
6858 +#include <asm/ip5000-asm.h>
6859 +
6860 +/*
6861 + * Timing
6862 + */
6863 +#define JMPT_PENALTY 3
6864 +#define JMPF_PENALTY 7
6865 +#define RET_PENALTY 7
6866 +
6867 +/*
6868 + * Threads
6869 + */
6870 +#if defined(IP5000) || defined(IP5000_REV2)
6871 +#define THREAD_COUNT 10
6872 +#elif defined(IP7000) || defined(IP7000_REV2)
6873 +#define THREAD_COUNT 12
6874 +#else
6875 +#error "Unknown IP5K silicon"
6876 +#endif
6877 +
6878 +/*
6879 + * Arch
6880 + */
6881 +#if defined(IP5000) || defined(IP5000_REV2)
6882 +#define UBICOM32_ARCH_VERSION 3
6883 +#elif defined(IP7000) || defined(IP7000_REV2)
6884 +#define UBICOM32_ARCH_VERSION 4
6885 +#else
6886 +#error "Unknown IP5K silicon"
6887 +#endif
6888 +
6889 +
6890 +/*
6891 + * Registers
6892 + */
6893 +#define ROSR_INT (1 << 0)
6894 +
6895 +/* Interrupts */
6896 +#define INT_CHIP(reg, bit) (((reg) << 5) | (bit))
6897 +#define INT_REG(interrupt) (((interrupt) >> 5) * 4)
6898 +#define INT_SET(interrupt) 0x0114 + INT_REG(interrupt)
6899 +#define INT_CLR(interrupt) 0x0124 + INT_REG(interrupt)
6900 +#define INT_STAT(interrupt) 0x0104 + INT_REG(interrupt)
6901 +#define INT_MASK(interrupt) 0x00C0 + INT_REG(interrupt)
6902 +#define INT_BIT(interrupt) ((interrupt) & 0x1F)
6903 +#define INT_BIT_MASK(interrupt) (1 << INT_BIT(interrupt))
6904 +
6905 +/*
6906 + * The LOCK_INT and THREAD_INT are used to wake up corresponding thread. They are sharing
6907 + * the same set of SW interrupt resource.
6908 + *
6909 + * LOCK_INT(n): One SW INT per NRT thread that can participate lock operation.
6910 + * The threads that can participate lock are application threads and DSR thread.
6911 + * (Lock locks - numbers are hard-coded in lock.h)
6912 + * THREAD_INT(n): One SW INT per HRT thread for wake up trigger.
6913 + */
6914 +#define LOCK_INT(thread) INT_CHIP(0, (thread))
6915 +#define THREAD_INT(thread) INT_CHIP(0, (thread))
6916 +
6917 +/*
6918 + * The SYSTEM_INT and DSR_INT are sharing the same set of SW interrupt resource.
6919 + *
6920 + * SYSTEM_INT(n): One SW INT per NRT threads (application threads) as system queue interrupt,
6921 + * and for DSR as self-trigger interrupt.
6922 + * (The application threads include at least thread 0)
6923 + * DSR_INT(n): One SW INT per HRT thread to request DSR service.
6924 + */
6925 +#define SYSTEM_INT(thread) INT_CHIP(0, THREAD_COUNT + (thread))
6926 +#define DSR_INT(thread) INT_CHIP(0, THREAD_COUNT + (thread))
6927 +
6928 +/* GLOBAL_CTRL */
6929 +#define GLOBAL_CTRL_TRAP_RST_EN (1 << 9)
6930 +#define GLOBAL_CTRL_AERROR_RST_EN (1 << 8)
6931 +#define GLOBAL_CTRL_MT_MIN_DELAY(x) ((x) << 3)
6932 +#define GLOBAL_CTRL_HRT_BANK_SELECT (1 << 2)
6933 +#define GLOBAL_CTRL_INT_EN (1 << 0)
6934 +
6935 +/*
6936 + * HRT Tables
6937 + */
6938 +#define HRT_TABLE0_BASE 0x0800
6939 +#define HRT_TABLE1_BASE 0x0900
6940 +#define HRT_TABLE_SIZE 64
6941 +
6942 +/*
6943 + * Break Point Trap Register
6944 + */
6945 +#define ASYNCERROR_INT INT_CHIP(0, 31)
6946 +#define BREAKPOINT_INT INT_CHIP(1, 31)
6947 +
6948 +/*
6949 + * Port interrupts
6950 + * The non-existing FIFO INTs are mapped to INT2 for the ports.
6951 + */
6952 +#define IO_PORT_PTR_TO_NUM(port) (((port) & 0x0000ffff) >> 12)
6953 +#define RX_FIFO_INT(port) \
6954 + ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 25) : \
6955 + ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 26) : \
6956 + ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \
6957 + ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 24) : \
6958 + ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 27) : \
6959 + ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 16) : \
6960 + ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \
6961 + ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \
6962 + ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 21) : \
6963 + INT_CHIP(1, 15))))))))))
6964 +#define TX_FIFO_INT(port) \
6965 + ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 24) : \
6966 + ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 27) : \
6967 + ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \
6968 + ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 25) : \
6969 + ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 28) : \
6970 + ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 17) : \
6971 + ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \
6972 + ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \
6973 + ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 22) : \
6974 + INT_CHIP(1, 15))))))))))
6975 +#define PORT_OTHER_INT(port) \
6976 + ((IO_PORT_PTR_TO_NUM(port) == 0) ? INT_CHIP(0, 25) : \
6977 + ((IO_PORT_PTR_TO_NUM(port) == 1) ? INT_CHIP(0, 28) : \
6978 + ((IO_PORT_PTR_TO_NUM(port) == 2) ? INT_CHIP(0, 29) : \
6979 + ((IO_PORT_PTR_TO_NUM(port) == 3) ? INT_CHIP(1, 26) : \
6980 + ((IO_PORT_PTR_TO_NUM(port) == 4) ? INT_CHIP(1, 29) : \
6981 + ((IO_PORT_PTR_TO_NUM(port) == 5) ? INT_CHIP(1, 18) : \
6982 + ((IO_PORT_PTR_TO_NUM(port) == 6) ? INT_CHIP(1, 19) : \
6983 + ((IO_PORT_PTR_TO_NUM(port) == 7) ? INT_CHIP(1, 20) : \
6984 + ((IO_PORT_PTR_TO_NUM(port) == 8) ? INT_CHIP(1, 23) : \
6985 + INT_CHIP(1, 15))))))))))
6986 +
6987 +/*
6988 + * On Chip Peripherals Base.
6989 + */
6990 +#define OCP_BASE 0x01000000
6991 +#define OCP_GENERAL 0x000
6992 +#define OCP_TIMERS 0x100
6993 +#define OCP_TRNG 0x200 /* True Random Number Generator Control Reigsters */
6994 +#define OCP_DEBUG 0x300
6995 +#define OCP_SECURITY 0x400
6996 +#define OCP_ICCR 0x500 /* I-Cache Control Registers */
6997 +#define OCP_DCCR 0x600 /* D-Cache Control Registers */
6998 +#define OCP_OCMC 0x700 /* On Chip Memory Control Registers */
6999 +#define OCP_STATISTICS 0x800 /* Statistics Counters */
7000 +#define OCP_MTEST 0x900 /* Memory Test Registers */
7001 +#define OCP_MCFG 0xa00 /* Memory Configuration Registers -- IP7000 only */
7002 +#define OCP_DEBUG_INST 0x000 /* Up to 16M */
7003 +
7004 +/*
7005 + * General Configuration Registers (PLL)
7006 + */
7007 +#define GENERAL_CFG_BASE (OCP_BASE + OCP_GENERAL)
7008 +#define GEN_CLK_CORE_CFG 0x00
7009 +#define GEN_CLK_IO_CFG 0x04
7010 +#define GEN_CLK_DDR_CFG 0x08
7011 +#define GEN_CLK_DDRDS_CFG 0x0c
7012 +#define GEN_CLK_SLIP_CLR 0x10
7013 +#define GEN_CLK_SLIP_START 0x14
7014 +#define GEN_CLK_SERDES_SEL 0x18 /* IP7000 only */
7015 +#define GEN_CLK_DDR_CFG2 0x1c /* IP7000 only */
7016 +#define GEN_DDR_CAL_CTRL 0x30 /* IP5000 only */
7017 +#define GEN_DDR_CAL_STAT 0x34 /* IP5000 only */
7018 +#define GEN_USB_DFT_CTRL 0x38 /* IP5000 only */
7019 +#define GEN_USB_DFT_STAT 0x3c /* IP5000 only */
7020 +#define GEN_USB_PHY_CFG 0x40 /* IP7000 only */
7021 +#define GEN_USB_PHY_TEST 0x44 /* IP7000 only */
7022 +#define GEN_USB_PHY_STAT 0x48 /* IP7000 only */
7023 +#define GEN_SW_RESET 0x80
7024 +#define GEN_RESET_REASON 0x84
7025 +#define GEN_BOND_CFG 0x88
7026 +#define GEN_IO_PU_CFG 0x8c
7027 +#define GEN_MEM_RM_CFG 0x90
7028 +#define GEN_IO_CONFIG 0x94
7029 +
7030 +#define GEN_CLK_PLL_SECURITY_BIT_NO 31
7031 +#define GEN_CLK_PLL_SECURITY (1 << GEN_CLK_PLL_SECURITY_BIT_NO)
7032 +#define GEN_CLK_PLL_ENSAT (1 << 30)
7033 +#define GEN_CLK_PLL_FASTEN (1 << 29)
7034 +#define GEN_CLK_PLL_NR(v) (((v) - 1) << 23)
7035 +#define GEN_CLK_PLL_NF(v) (((v) - 1) << 11)
7036 +#define GEN_CLK_PLL_OD(v) (((v) - 1) << 8)
7037 +#define GEN_CLK_PLL_RESET (1 << 7)
7038 +#define GEN_CLK_PLL_BYPASS (1 << 6)
7039 +#define GEN_CLK_PLL_POWERDOWN (1 << 5)
7040 +#define GEN_CLK_PLL_SELECT (1 << 4)
7041 +
7042 +#define GEN_GET_CLK_PLL_NR(v) ((((v) >> 23) & 0x003f) + 1)
7043 +#define GEN_GET_CLK_PLL_NF(v) ((((v) >> 11) & 0x0fff) + 1)
7044 +#define GEN_GET_CLK_PLL_OD(v) ((((v) >> 8) & 0x7) + 1)
7045 +
7046 +
7047 +#define RESET_FLAG_DST_MEM_ERROR (1 << 18)
7048 +#define RESET_FLAG_SRC1_MEM_ERROR (1 << 17)
7049 +#define RESET_FLAG_WRITE_ADDR (1 << 16)
7050 +#define RESET_FLAG_DST_SYNC_ERROR (1 << 15)
7051 +#define RESET_FLAG_SRC1_SYNC_ERROR (1 << 14)
7052 +#define RESET_FLAG_DST_ALGN_ERROR (1 << 13)
7053 +#define RESET_FLAG_SRC1_ALGN_ERROR (1 << 12)
7054 +#define RESET_FLAG_DST_ADDR_ERROR (1 << 11)
7055 +#define RESET_FLAG_SRC1_ADDR_ERROR (1 << 10)
7056 +#define RESET_FLAG_ILLEGAL_INST (1 << 9)
7057 +#define RESET_FLAG_INST_SYNC_ERROR (1 << 8)
7058 +#define RESET_FLAG_INST_ADDR_ERROR (1 << 7)
7059 +#define RESET_FLAG_DATA_PORT_ERROR (1 << 6)
7060 +#define RESET_FLAG_INST_PORT_ERROR (1 << 5)
7061 +#define RESET_FLAG_SW_RESET (1 << 4)
7062 +#define RESET_FLAG_DEBUG (1 << 3)
7063 +#define RESET_FLAG_WATCHDOG (1 << 2)
7064 +#define RESET_FLAG_POWER_ON (1 << 1)
7065 +#define RESET_FLAG_EXTERNAL (1 << 0)
7066 +
7067 +/*
7068 + * Timer block
7069 + */
7070 +#define TIMER_BASE (OCP_BASE + OCP_TIMERS)
7071 +#define TIMER_MPTVAL 0x00
7072 +#define TIMER_RTCOM 0x04
7073 +#define TIMER_TKEY 0x08
7074 +#define TIMER_WDCOM 0x0c
7075 +#define TIMER_WDCFG 0x10
7076 +#define TIMER_SYSVAL 0x14
7077 +#define TIMER_SYSCOM(tmr) (0x18 + (tmr) * 4)
7078 +#define TIMER_TRN_CFG 0x100
7079 +#define TIMER_TRN 0x104
7080 +
7081 +#define TIMER_COUNT 10
7082 +#define TIMER_INT(tmr) INT_CHIP(1, (tmr))
7083 +#define TIMER_TKEYVAL 0xa1b2c3d4
7084 +#define TIMER_WATCHDOG_DISABLE 0x4d3c2b1a
7085 +#define TIMER_TRN_CFG_ENABLE_OSC 0x00000007
7086 +
7087 +#ifndef __ASSEMBLY__
7088 +/*
7089 + * ubicom32_io_timer
7090 + */
7091 +struct ubicom32_io_timer {
7092 + volatile u32_t mptval;
7093 + volatile u32_t rtcom;
7094 + volatile u32_t tkey;
7095 + volatile u32_t wdcom;
7096 + volatile u32_t wdcfg;
7097 + volatile u32_t sysval;
7098 + volatile u32_t syscom[TIMER_COUNT];
7099 + volatile u32_t reserved[64 - 6 - TIMER_COUNT]; // skip all the way to OCP-TRNG section
7100 + volatile u32_t rsgcfg;
7101 + volatile u32_t trn;
7102 +};
7103 +
7104 +#define UBICOM32_IO_TIMER ((struct ubicom32_io_timer *)TIMER_BASE)
7105 +#endif
7106 +
7107 +#define UBICOM32_VECTOR_TO_TIMER_INDEX(vector) (vector - TIMER_INT(0))
7108 +
7109 +/*
7110 + * OCP-Debug Module (Mailbox)
7111 + */
7112 +#define ISD_MAILBOX_BASE (OCP_BASE + OCP_DEBUG)
7113 +#define ISD_MAILBOX_IN 0x00
7114 +#define ISD_MAILBOX_OUT 0x04
7115 +#define ISD_MAILBOX_STATUS 0x08
7116 +
7117 +#define ISD_MAILBOX_INT INT_CHIP(1, 30)
7118 +
7119 +#define ISD_MAILBOX_STATUS_IN_FULL (1 << 31)
7120 +#define ISD_MAILBOX_STATUS_IN_EMPTY (1 << 30)
7121 +#define ISD_MAILBOX_STATUS_OUT_FULL (1 << 29)
7122 +#define ISD_MAILBOX_STATUS_OUT_EMPTY (1 << 28)
7123 +
7124 +/*
7125 + * OCP-Security
7126 + */
7127 +#define SECURITY_BASE (OCP_BASE + OCP_SECURITY)
7128 +#define SECURITY_BASE_EFFECTIVE_ADDRESS (SECURITY_BASE >> 7) // To load the base address in a single instruction
7129 +#define SECURITY_CTRL 0x00
7130 +#define SECURITY_CTRL_BYTE_OFFSET(x) ((x) << 16)
7131 +#define SECURITY_CTRL_KEY_SIZE(x) ((x) << 8)
7132 +#define SECURITY_CTRL_HASH_ALG_NONE (0 << 4)
7133 +#define SECURITY_CTRL_HASH_ALG_MD5 (1 << 4)
7134 +#define SECURITY_CTRL_HASH_ALG_SHA1 (2 << 4)
7135 +#define SECURITY_CTRL_CBC (1 << 3)
7136 +#define SECURITY_CTRL_CIPHER_ALG_AES (0 << 1)
7137 +#define SECURITY_CTRL_CIPHER_ALG_NONE (1 << 1)
7138 +#define SECURITY_CTRL_CIPHER_ALG_DES (2 << 1)
7139 +#define SECURITY_CTRL_CIPHER_ALG_3DES (3 << 1)
7140 +#define SECURITY_CTRL_ENCIPHER (1 << 0)
7141 +#define SECURITY_CTRL_DECIPHER (0 << 0)
7142 +#define SECURITY_STAT 0x04
7143 +#define SECURITY_STAT_BUSY (1 << 0)
7144 +#define SECURITY_KEY_VALUE(x) (0x10 + (x) * 4)
7145 +#define SECURITY_KEY_IN(x) (0x30 + (x) * 4)
7146 +#define SECURITY_KEY_OUT(x) (0x50 + (x) * 4)
7147 +#define SECURITY_KEY_HASH(x) (0x70 + (x) * 4)
7148 +
7149 +/*
7150 + * OCP-ICCR
7151 + */
7152 +#define ICCR_BASE (OCP_BASE + OCP_ICCR)
7153 +#define ICACHE_TOTAL_SIZE 16384 /* in bytes */
7154 +
7155 +/*
7156 + * OCP-DCCR
7157 + */
7158 +#define DCCR_BASE (OCP_BASE + OCP_DCCR)
7159 +#if defined(IP5000) || defined(IP5000_REV2)
7160 +#define DCACHE_TOTAL_SIZE 8192 /* in bytes */
7161 +#elif defined(IP7000) || defined(IP7000_REV2)
7162 +#define DCACHE_TOTAL_SIZE 16384 /* in bytes */
7163 +#endif
7164 +
7165 +#if defined(IP5000) || defined(IP5000_REV2) || defined(IP7000) || defined(IP7000_REV2)
7166 +#define DCACHE_WRITE_QUEUE_LENGTH 6
7167 +#else
7168 +#error "Unknown IP5K silicon"
7169 +#endif
7170 +
7171 +#define CACHE_LINE_SIZE 32 /* in bytes */
7172 +
7173 +#define CCR_ADDR 0x00
7174 +#define CCR_RDD 0x04
7175 +#define CCR_WRD 0x08
7176 +#define CCR_STAT 0x0c
7177 +#define CCR_CTRL 0x10
7178 +
7179 +#define CCR_STAT_MCBE 0
7180 +#define CCR_STAT_WIDEL 1 /* D-cache only */
7181 +
7182 +#define CCR_CTRL_DONE 0
7183 +#define CCR_CTRL_RESET 2
7184 +#define CCR_CTRL_VALID 3
7185 +#define CCR_CTRL_RD_DATA (1 << 4)
7186 +#define CCR_CTRL_RD_TAG (2 << 4)
7187 +#define CCR_CTRL_WR_DATA (3 << 4)
7188 +#define CCR_CTRL_WR_TAG (4 << 4)
7189 +#define CCR_CTRL_INV_INDEX (5 << 4)
7190 +#define CCR_CTRL_INV_ADDR (6 << 4)
7191 +#define CCR_CTRL_FLUSH_INDEX (7 << 4) /* D-cache only */
7192 +#define CCR_CTRL_FLUSH_INV_INDEX (8 << 4) /* D-cache only */
7193 +#define CCR_CTRL_FLUSH_ADDR (9 << 4) /* D-cache only */
7194 +#define CCR_CTRL_FLUSH_INV_ADDR (10 << 4) /* D-cache only */
7195 +
7196 +/*
7197 + * OCP-OCMC
7198 + */
7199 +#define OCMC_BASE (OCP_BASE + OCP_OCMC)
7200 +#define OCMC_BANK_MASK 0x00
7201 +#define OCMC_BIST_CNTL 0x04 /* IP5000 only */
7202 +#define OCMC_BIST_STAT 0x08 /* IP5000 only */
7203 +
7204 +#define OCMC_BANK_PROG(n) ((1<<(n))-1)
7205 +
7206 +#define OCMC_BIST_WRCK (1 << 7)
7207 +#define OCMC_BIST_RESET (1 << 5)
7208 +#define OCMC_BIST_SMART (1 << 4)
7209 +#define OCMC_BIST_RUN (1 << 3)
7210 +#define OCMC_BIST_REPAIR (1 << 2)
7211 +
7212 +#define OCMC_BIST_READY (1 << 3)
7213 +#define OCMC_BIST_FAIL (1 << 2)
7214 +
7215 +/*
7216 + * OCP-STATISTICS
7217 + */
7218 +#define STATISTICS_BASE (OCP_BASE + OCP_STATISTICS)
7219 +#define STAT_COUNTER_CTRL(n) ((n)*8)
7220 +#define STAT_COUNTER(n) ((n)*8 + 4)
7221 +
7222 +#define STAT_EVENT_MP_INST 0
7223 +#define STAT_EVENT_OCM_ACCESS 4
7224 +#define STAT_EVENT_OCM_REQ 5
7225 +#define STAT_EVENT_IC_REQ_INVAL 13
7226 +#define STAT_EVENT_IC_MISS_INVAL 14
7227 +#define STAT_EVENT_IC_REQ_INVAL_NACK 15
7228 +#define STAT_EVENT_IC_REQ_VAL 16
7229 +#define STAT_EVENT_IC_MISS_VAL 17
7230 +#define STAT_EVENT_IC_REQ_VAL_NACK 18
7231 +#define STAT_EVENT_IC_MISS_Q 19
7232 +#define STAT_EVENT_DC_RD_REQ 20
7233 +#define STAT_EVENT_DC_RD_MISS 21
7234 +#define STAT_EVENT_DC_WR_REQ 22
7235 +#define STAT_EVENT_DC_WR_MISS 23
7236 +#define STAT_EVENT_DC_MISS_Q 24
7237 +#define STAT_EVENT_DC_WB_FULL 25
7238 +#define STAT_EVENT_DC_REQ_NACK 26
7239 +#define STAT_EVENT_DC_CORE_REQ 27
7240 +#define STAT_EVENT_DC_MISS 28
7241 +#define STAT_EVENT_DC_EVICT 29
7242 +#define STAT_EVENT_TRUE 30
7243 +#define STAT_EVENT_FALSE 31
7244 +
7245 +/*
7246 + * OCP_MTEST
7247 + */
7248 +#define MTEST_BASE (OCP_BASE + OCP_MTEST)
7249 +#define MTEST_ADDR 0x00
7250 +#define MTEST_WR 0x04
7251 +#define MTEST_RD 0x08
7252 +#define MTEST_CTRL 0x0c
7253 +
7254 +/*
7255 + * OCP_MCFG (IP7000 only)
7256 + */
7257 +#define MCFG_BASE (OCP_BASE + OCP_MCFG)
7258 +#define MCFG_CTRL 0x00
7259 +#define MCFG_WCFG 0x04
7260 +#define MCFG_RCFG 0x08
7261 +
7262 +/*
7263 + * Port registers
7264 + */
7265 +#define IO_BASE 0x02000000
7266 +#define RA (IO_BASE + 0x00000000)
7267 +#define RB (IO_BASE + 0x00001000)
7268 +#define RC (IO_BASE + 0x00002000)
7269 +#define RD (IO_BASE + 0x00003000)
7270 +#define RE (IO_BASE + 0x00004000)
7271 +#define RF (IO_BASE + 0x00005000)
7272 +#define RG (IO_BASE + 0x00006000)
7273 +#define RH (IO_BASE + 0x00007000)
7274 +#define RI (IO_BASE + 0x00008000)
7275 +#define RJ (IO_BASE + 0x00009000)
7276 +#define RLATCH (IO_BASE + 0x00ff0000) // For latched output only
7277 +#define IO_PORT_BR_OFFSET 0x00000800
7278 +
7279 +/*
7280 + * General I/O Register Map (per port)
7281 + */
7282 +#define IO_FUNC 0x00
7283 +#define IO_GPIO_CTL 0x04
7284 +#define IO_GPIO_OUT 0x08
7285 +#define IO_GPIO_IN 0x0C
7286 +#define IO_INT_STATUS 0x10
7287 +#define IO_INT_MASK 0x14
7288 +#define IO_INT_SET 0x18
7289 +#define IO_INT_CLR 0x1C
7290 +#define IO_TX_FIFO 0x20
7291 +#define IO_TX_FIFO_HI 0x24
7292 +#define IO_RX_FIFO 0x28
7293 +#define IO_RX_FIFO_HI 0x2c
7294 +#define IO_CTL0 0x30
7295 +#define IO_CTL1 0x34
7296 +#define IO_CTL2 0x38
7297 +#define IO_STATUS0 0x3c
7298 +#define IO_STATUS1 0x40
7299 +#define IO_STATUS2 0x44
7300 +#define IO_FIFO_WATER 0x48
7301 +#define IO_FIFO_LEVEL 0x4c
7302 +#define IO_GPIO_MASK 0x50
7303 +
7304 +#define IO_FUNC_FUNCTION_RESET(func) ((1 << ((func) - 1)) << 4) /* Function 0 doesn't need reset */
7305 +#define IO_FUNC_RX_FIFO (1 << 3)
7306 +#define IO_FUNC_SELECT(func) ((func) << 0)
7307 +
7308 +/*
7309 + * External interrupt pins.
7310 + */
7311 +#define EXT_INT_IO_BIT(pin) ((pin) + 5) // Interrupt pin number -> I/O INT bit
7312 +#define EXT_INT_RISING_EDGE(pin) (0x2 << (2*(pin) + 7))
7313 +#define EXT_INT_FALLING_EDGE(pin) (0x1 << (2*(pin) + 7))
7314 +
7315 +/*
7316 + * Flash
7317 + */
7318 +#define IO_XFL_BASE RA
7319 +
7320 +#define IO_XFL_INT_START (1 << 16)
7321 +#define IO_XFL_INT_ERR (1 << 8)
7322 +#define IO_XFL_INT_DONE (1 << 0)
7323 +
7324 +#define IO_XFL_CTL0_MASK (0xffe07fff)
7325 +#define IO_XFL_CTL0_RD_CMD(cmd) (((cmd) & 0xff) << 24)
7326 +#define IO_XFL_CTL0_RD_DUMMY(n) (((n) & 0x7) << 21)
7327 +#define IO_XFL_CTL0_CLK_WIDTH(core_cycles) ((((core_cycles) + 1) & 0x7e) << 8) /* must be even number */
7328 +#define IO_XFL_CTL0_CE_WAIT(spi_cycles) (((spi_cycles) & 0x3f) << 2)
7329 +#define IO_XFL_CTL0_MCB_LOCK (1 << 1)
7330 +#define IO_XFL_CTL0_ENABLE (1 << 0)
7331 +#define IO_XFL_CTL0_FAST_VALUE(div, wait) (IO_XFL_CTL0_RD_CMD(0xb) | IO_XFL_CTL0_RD_DUMMY(1) | IO_XFL_CTL0_CLK_WIDTH(div) | IO_XFL_CTL0_CE_WAIT(wait) | IO_XFL_CTL0_ENABLE)
7332 +#define IO_XFL_CTL0_VALUE(div, wait) (IO_XFL_CTL0_RD_CMD(3) | IO_XFL_CTL0_CLK_WIDTH(div) | IO_XFL_CTL0_CE_WAIT(wait) | IO_XFL_CTL0_ENABLE)
7333 +
7334 +#define IO_XFL_CTL1_MASK (0xc0003fff)
7335 +#define IO_XFL_CTL1_FC_INST(inst) (((inst) & 0x3) << 30)
7336 +#define IO_XFL_CTL1_FC_DATA(n) (((n) & 0x3ff) << 4)
7337 +#define IO_XFL_CTL1_FC_DUMMY(n) (((n) & 0x7) << 1)
7338 +#define IO_XFL_CTL1_FC_ADDR (1 << 0)
7339 +
7340 +#define IO_XFL_CTL2_FC_CMD(cmd) (((cmd) & 0xff) << 24)
7341 +#define IO_XFL_CTL2_FC_ADDR(addr) ((addr) & 0x00ffffff) /* Only up to 24 bits */
7342 +
7343 +#define IO_XFL_STATUS0_MCB_ACTIVE (1 << 0)
7344 +#define IO_XFL_STATUS0_IOPCS_ACTIVE (1 << 1)
7345 +
7346 +/*
7347 + * SDRAM
7348 + */
7349 +#define IO_SDRAM_DATA_BASE RG
7350 +#define IO_SDRAM_CNTL_BASE RH
7351 +
7352 +#define IO_SDRAM_CTRL0_EN_REF (1 << 0)
7353 +
7354 +/*
7355 + * Port function code (common fucntion codes for all I/O ports)
7356 + */
7357 +#define IO_PORTX_FUNC_GPIO 0x00
7358 +#define IO_PORTX_FUNC_XFL 0x01
7359 +#define IO_PORTX_FUNC_PCI 0x01
7360 +#define IO_PORTX_FUNC_SERDES 0x01
7361 +#define IO_PORTX_FUNC_GMII 0x01
7362 +#define IO_PORTX_FUNC_DDR 0x01
7363 +#define IO_PORTX_FUNC_PCIX 0x01
7364 +#define IO_PORTX_FUNC_USB2_0 0x01
7365 +#define IO_PORTX_FUNC_GPIO_INT_CLK 0x02
7366 +#define IO_PORTX_FUNC_PLIO 0x02
7367 +#define IO_PORTX_FUNC_GPIO_INT 0x03
7368 +#define IO_PORTX_FUNC_MII 0x03
7369 +
7370 +/*
7371 + * Port 0
7372 + */
7373 +#define IO_PORT0_FUNC_GPIO IO_PORTX_FUNC_GPIO
7374 +#define IO_PORT0_FUNC_XFL_INT_CLK IO_PORTX_FUNC_XFL // Default mode after reset
7375 +#define IO_PORT0_FUNC_GPIO_INT_CLK IO_PORTX_FUNC_GPIO_INT_CLK
7376 +#define IO_PORT0_FUNC_GPIO_INT IO_PORTX_FUNC_GPIO_INT
7377 +
7378 +/*
7379 + * Port 1
7380 + */
7381 +#define IO_PORT1_FUNC_GPIO IO_PORTX_FUNC_GPIO
7382 +#define IO_PORT1_FUNC_PCI IO_PORTX_FUNC_PCI // PCI control
7383 +#define IO_PORT1_FUNC_MII IO_PORTX_FUNC_MII // port 4 MII extension
7384 +
7385 +/*
7386 + * Port 2
7387 + */
7388 +#define IO_PORT2_FUNC_GPIO IO_PORTX_FUNC_GPIO
7389 +#define IO_PORT2_FUNC_PCI IO_PORTX_FUNC_PCI // PCI data I/O
7390 +#define IO_PORT2_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM
7391 +
7392 +/*
7393 + * Port 3
7394 + */
7395 +#define IO_PORT3_FUNC_GPIO IO_PORTX_FUNC_GPIO
7396 +#define IO_PORT3_FUNC_SERDES IO_PORTX_FUNC_SERDES
7397 +#define IO_PORT3_FUNC_PLIO IO_PORTX_FUNC_PLIO
7398 +
7399 +/*
7400 + * Port 4
7401 + */
7402 +#define IO_PORT4_FUNC_GPIO IO_PORTX_FUNC_GPIO
7403 +#define IO_PORT4_FUNC_SERDES IO_PORTX_FUNC_SERDES
7404 +#define IO_PORT4_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM
7405 +#define IO_PORT4_FUNC_MII IO_PORTX_FUNC_MII
7406 +
7407 +/*
7408 + * Port 5
7409 + */
7410 +#define IO_PORT5_FUNC_GPIO IO_PORTX_FUNC_GPIO
7411 +#define IO_PORT5_FUNC_GMII IO_PORTX_FUNC_GMII
7412 +
7413 +/*
7414 + * Port 6
7415 + */
7416 +#define IO_PORT6_FUNC_GPIO IO_PORTX_FUNC_GPIO
7417 +#define IO_PORT6_FUNC_DDR IO_PORTX_FUNC_DDR
7418 +
7419 +/*
7420 + * Port 7
7421 + */
7422 +#define IO_PORT7_FUNC_GPIO IO_PORTX_FUNC_GPIO
7423 +#define IO_PORT7_FUNC_DDR IO_PORTX_FUNC_DDR
7424 +
7425 +/*
7426 + * Port 8
7427 + */
7428 +#define IO_PORT8_FUNC_GPIO IO_PORTX_FUNC_GPIO
7429 +#define IO_PORT8_FUNC_PCIX IO_PORTX_FUNC_PCIX
7430 +#define IO_PORT8_FUNC_PLIO IO_PORTX_FUNC_PLIO // Extended LM
7431 +#define IO_PORT8_FUNC_MII IO_PORTX_FUNC_MII // port 4 MII extension
7432 +
7433 +/*
7434 + * Port 9
7435 + */
7436 +#define IO_PORT9_FUNC_USB2_0 IO_PORTX_FUNC_USB2_0
7437 +
7438 +/*
7439 + * FIFO
7440 + */
7441 +#define IO_PORTX_INT_FIFO_TX_RESET (1 << 31)
7442 +#define IO_PORTX_INT_FIFO_RX_RESET (1 << 30)
7443 +#define IO_PORTX_INT_FIFO_TX_UF (1 << 15)
7444 +#define IO_PORTX_INT_FIFO_TX_WM (1 << 14)
7445 +#define IO_PORTX_INT_FIFO_RX_OF (1 << 13)
7446 +#define IO_PORTX_INT_FIFO_RX_WM (1 << 12)
7447 +
7448 +#define IO_PORTX_FUNC_FIFO_TX_WM(n) ((n) << 16)
7449 +#define IO_PORTX_FUNC_FIFO_RX_WM(n) ((n) << 0)
7450 +
7451 +/*
7452 + * MII
7453 + */
7454 +#define IO_PORTX_INT_MII_TX_ERR_SEND (1 << 18)
7455 +#define IO_PORTX_INT_MII_TX_HALT (1 << 17)
7456 +#define IO_PORTX_INT_MII_TX_START (1 << 16)
7457 +#define IO_PORTX_INT_MII_THRESHOLD (1 << 8)
7458 +#define IO_PORTX_INT_MII_RX_EOP (1 << 7)
7459 +#define IO_PORTX_INT_MII_RX_SFD (1 << 6)
7460 +#define IO_PORTX_INT_MII_RX_ERR (1 << 5)
7461 +#define IO_PORTX_INT_MII_TX_EOP (1 << 4)
7462 +#define IO_PORTX_INT_MII_COL (1 << 3)
7463 +#define IO_PORTX_INT_MII_CRS (1 << 2)
7464 +#define IO_PORTX_INT_MII_ODD_NIB_ERR (1 << 1)
7465 +#define IO_PORTX_INT_MII_FALSE_CARRIER (1 << 0)
7466 +
7467 +/*
7468 + * SerDes
7469 + */
7470 +#define IO_PORTX_INT_SERDES_TXBUF_VALID (1 << 16)
7471 +#define IO_PORTX_INT_SERDES_RXERR (1 << 7)
7472 +#define IO_PORTX_INT_SERDES_RXEOP (1 << 6)
7473 +#define IO_PORTX_INT_SERDES_SYND (1 << 5)
7474 +#define IO_PORTX_INT_SERDES_TXBE (1 << 4)
7475 +#define IO_PORTX_INT_SERDES_TXEOP (1 << 3)
7476 +#define IO_PORTX_INT_SERDES_SXLP (1 << 2)
7477 +#define IO_PORTX_INT_SERDES_RXBF (1 << 1)
7478 +#define IO_PORTX_INT_SERDES_RXCRS (1 << 0)
7479 +
7480 +#ifndef __ASSEMBLY__
7481 +struct ubicom32_io_port {
7482 + volatile u32_t function;
7483 + volatile u32_t gpio_ctl;
7484 + volatile u32_t gpio_out;
7485 + volatile u32_t gpio_in;
7486 + volatile u32_t int_status;
7487 + volatile u32_t int_mask;
7488 + volatile u32_t int_set;
7489 + volatile u32_t int_clr;
7490 + volatile u32_t tx_fifo;
7491 + volatile u32_t tx_fifo_hi;
7492 + volatile u32_t rx_fifo;
7493 + volatile u32_t rx_fifo_hi;
7494 + volatile u32_t ctl0;
7495 + volatile u32_t ctl1;
7496 + volatile u32_t ctl2;
7497 + volatile u32_t status0;
7498 + volatile u32_t status1;
7499 + volatile u32_t status2;
7500 + volatile u32_t fifo_watermark;
7501 + volatile u32_t fifo_level;
7502 + volatile u32_t gpio_mask;
7503 +};
7504 +
7505 +#define UBICOM32_IO_PORT(port) ((struct ubicom32_io_port *)((port)))
7506 +#endif
7507 +
7508 +#ifndef __ASSEMBLY__
7509 +/*
7510 + * ubicom32_set_interrupt()
7511 + */
7512 +extern inline void ubicom32_set_interrupt(u8_t interrupt)
7513 +{
7514 + u32_t ibit = INT_BIT_MASK(interrupt);
7515 +
7516 + if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) {
7517 + asm volatile (
7518 + "move.4 "D(INT_SET(INT_CHIP(0, 0)))", %0\n\t"
7519 + :
7520 + : "r" (ibit)
7521 + );
7522 +
7523 + return;
7524 + }
7525 +
7526 + asm volatile (
7527 + "move.4 "D(INT_SET(INT_CHIP(1, 0)))", %0\n\t"
7528 + :
7529 + : "r" (ibit)
7530 + );
7531 +}
7532 +
7533 +/*
7534 + * ubicom32_clear_interrupt()
7535 + */
7536 +extern inline void ubicom32_clear_interrupt(u8_t interrupt)
7537 +{
7538 + u32_t ibit = INT_BIT_MASK(interrupt);
7539 +
7540 + if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) {
7541 + asm volatile (
7542 + "move.4 "D(INT_CLR(INT_CHIP(0, 0)))", %0\n\t"
7543 + :
7544 + : "r" (ibit)
7545 + );
7546 +
7547 + return;
7548 + }
7549 +
7550 + asm volatile (
7551 + "move.4 "D(INT_CLR(INT_CHIP(1, 0)))", %0\n\t"
7552 + :
7553 + : "r" (ibit)
7554 + );
7555 +}
7556 +
7557 +/*
7558 + * ubicom32_enable_interrupt()
7559 + */
7560 +extern inline void ubicom32_enable_interrupt(u8_t interrupt)
7561 +{
7562 + u32_t ibit = INT_BIT_MASK(interrupt);
7563 +
7564 + if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) {
7565 + asm volatile (
7566 + "or.4 "D(INT_MASK(INT_CHIP(0, 0)))", "D(INT_MASK(INT_CHIP(0, 0)))", %0\n\t"
7567 + :
7568 + : "d" (ibit)
7569 + );
7570 +
7571 + return;
7572 + }
7573 +
7574 + asm volatile (
7575 + "or.4 "D(INT_MASK(INT_CHIP(1, 0)))", "D(INT_MASK(INT_CHIP(1, 0)))", %0\n\t"
7576 + :
7577 + : "d" (ibit)
7578 + );
7579 +}
7580 +
7581 +/*
7582 + * ubicom32_disable_interrupt()
7583 + */
7584 +extern inline void ubicom32_disable_interrupt(u8_t interrupt)
7585 +{
7586 + u32_t ibit = ~INT_BIT_MASK(interrupt);
7587 +
7588 + if (INT_REG(interrupt) == INT_REG(INT_CHIP(0, 0))) {
7589 + asm volatile (
7590 + "and.4 "D(INT_MASK(INT_CHIP(0, 0)))", "D(INT_MASK(INT_CHIP(0, 0)))", %0\n\t"
7591 + :
7592 + : "d" (ibit)
7593 + );
7594 +
7595 + return;
7596 + }
7597 +
7598 + asm volatile (
7599 + "and.4 "D(INT_MASK(INT_CHIP(1, 0)))", "D(INT_MASK(INT_CHIP(1, 0)))", %0\n\t"
7600 + :
7601 + : "d" (ibit)
7602 + );
7603 +}
7604 +
7605 +/*
7606 + * ubicom32_enable_global_interrupts()
7607 + */
7608 +extern inline void ubicom32_enable_global_interrupts(void)
7609 +{
7610 + asm volatile(
7611 + "bset GLOBAL_CTRL, GLOBAL_CTRL, #%bit("D(GLOBAL_CTRL_INT_EN)")"
7612 + );
7613 +}
7614 +
7615 +/*
7616 + * ubicom32_disable_global_interrupts()
7617 + */
7618 +extern inline void ubicom32_disable_global_interrupts(void)
7619 +{
7620 + asm volatile(
7621 + "bclr GLOBAL_CTRL, GLOBAL_CTRL, #%bit("D(GLOBAL_CTRL_INT_EN)")"
7622 + );
7623 +}
7624 +
7625 +/*
7626 + * ubicom32_get_reset_reason()
7627 + */
7628 +extern inline u32_t ubicom32_get_reset_reason(void)
7629 +{
7630 + return *(u32_t *)(GENERAL_CFG_BASE + GEN_RESET_REASON);
7631 +}
7632 +
7633 +/*
7634 + * ubicom32_read_reg()
7635 + */
7636 +extern inline u32_t ubicom32_read_reg(volatile void *reg)
7637 +{
7638 + u32_t v;
7639 + asm volatile (
7640 + "move.4 %[dest], %[src] \n\t"
7641 + : [dest] "=r" (v)
7642 + : [src] "m" (*(u32_t *)reg)
7643 + );
7644 + return v;
7645 +}
7646 +
7647 +/*
7648 + * ubicom32_write_reg()
7649 + */
7650 +extern inline void ubicom32_write_reg(volatile void *reg, u32_t v)
7651 +{
7652 + asm volatile (
7653 + "move.4 %[dest], %[src] \n\t"
7654 + :
7655 + : [src] "r" (v), [dest] "m" (*(u32_t *)reg)
7656 + );
7657 +}
7658 +
7659 +#endif /* __ASSEMBLY__ */
7660 +#endif /* _ASM_UBICOM32_IP5000_H */
7661 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ipcbuf.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ipcbuf.h
7662 --- linux-2.6.30.10/arch/ubicom32/include/asm/ipcbuf.h 1970-01-01 02:00:00.000000000 +0200
7663 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ipcbuf.h 2009-12-11 11:45:11.000000000 +0200
7664 @@ -0,0 +1,55 @@
7665 +/*
7666 + * arch/ubicom32/include/asm/ipcbuf.h
7667 + * Definition of ipc64_perm struct for Ubicom32 architecture.
7668 + *
7669 + * (C) Copyright 2009, Ubicom, Inc.
7670 + *
7671 + * This file is part of the Ubicom32 Linux Kernel Port.
7672 + *
7673 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7674 + * it and/or modify it under the terms of the GNU General Public License
7675 + * as published by the Free Software Foundation, either version 2 of the
7676 + * License, or (at your option) any later version.
7677 + *
7678 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7679 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7680 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7681 + * the GNU General Public License for more details.
7682 + *
7683 + * You should have received a copy of the GNU General Public License
7684 + * along with the Ubicom32 Linux Kernel Port. If not,
7685 + * see <http://www.gnu.org/licenses/>.
7686 + *
7687 + * Ubicom32 implementation derived from (with many thanks):
7688 + * arch/m68knommu
7689 + * arch/blackfin
7690 + * arch/parisc
7691 + */
7692 +#ifndef _ASM_UBICOM32_IPCBUF_H
7693 +#define _ASM_UBICOM32_IPCBUF_H
7694 +
7695 +/*
7696 + * The user_ipc_perm structure for m68k architecture.
7697 + * Note extra padding because this structure is passed back and forth
7698 + * between kernel and user space.
7699 + *
7700 + * Pad space is left for:
7701 + * - 32-bit mode_t and seq
7702 + * - 2 miscellaneous 32-bit values
7703 + */
7704 +struct ipc64_perm
7705 +{
7706 + __kernel_key_t key;
7707 + __kernel_uid32_t uid;
7708 + __kernel_gid32_t gid;
7709 + __kernel_uid32_t cuid;
7710 + __kernel_gid32_t cgid;
7711 + __kernel_mode_t mode;
7712 + unsigned short __pad1;
7713 + unsigned short seq;
7714 + unsigned short __pad2;
7715 + unsigned long __unused1;
7716 + unsigned long __unused2;
7717 +};
7718 +
7719 +#endif /* _ASM_UBICOM32_IPCBUF_H */
7720 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/irqflags.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irqflags.h
7721 --- linux-2.6.30.10/arch/ubicom32/include/asm/irqflags.h 1970-01-01 02:00:00.000000000 +0200
7722 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irqflags.h 2009-12-11 11:45:11.000000000 +0200
7723 @@ -0,0 +1,96 @@
7724 +/*
7725 + * arch/ubicom32/include/asm/irqflags.h
7726 + * Raw implementation of local IRQ functions.
7727 + *
7728 + * (C) Copyright 2009, Ubicom, Inc.
7729 + *
7730 + * This file is part of the Ubicom32 Linux Kernel Port.
7731 + *
7732 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7733 + * it and/or modify it under the terms of the GNU General Public License
7734 + * as published by the Free Software Foundation, either version 2 of the
7735 + * License, or (at your option) any later version.
7736 + *
7737 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7738 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7739 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7740 + * the GNU General Public License for more details.
7741 + *
7742 + * You should have received a copy of the GNU General Public License
7743 + * along with the Ubicom32 Linux Kernel Port. If not,
7744 + * see <http://www.gnu.org/licenses/>.
7745 + *
7746 + * Ubicom32 implementation derived from (with many thanks):
7747 + * arch/m68knommu
7748 + * arch/blackfin
7749 + * arch/parisc
7750 + */
7751 +#ifndef _ASM_UBICOM32_IRQFLAGS_H
7752 +#define _ASM_UBICOM32_IRQFLAGS_H
7753 +
7754 +#include <linux/thread_info.h>
7755 +#include <asm/ubicom32-common.h>
7756 +#if defined(CONFIG_SMP)
7757 +#include <asm/smp.h>
7758 +#endif
7759 +#include <asm/ldsr.h>
7760 +
7761 +#if defined(CONFIG_PREEMPT)
7762 +#error Not supported by Ubicom32 irq handling, yet!
7763 +#endif
7764 +
7765 +/*
7766 + * raw_local_irq_enable()
7767 + * Enable interrupts for this thread.
7768 + */
7769 +static inline void raw_local_irq_enable(void)
7770 +{
7771 + ldsr_local_irq_enable();
7772 +}
7773 +
7774 +/*
7775 + * raw_local_irq_disable()
7776 + * Disable interrupts for this thread.
7777 + */
7778 +static inline void raw_local_irq_disable(void)
7779 +{
7780 + ldsr_local_irq_disable();
7781 +}
7782 +
7783 +/*
7784 + * raw_local_save_flags()
7785 + * Get the current IRQ state.
7786 + */
7787 +#define raw_local_save_flags(flags) \
7788 +do { \
7789 + (flags) = ldsr_local_irq_is_disabled(); \
7790 +} while (0)
7791 +
7792 +/*
7793 + * raw_local_irq_save()
7794 + * Save the current interrupt state and disable interrupts.
7795 + */
7796 +#define raw_local_irq_save(flags) \
7797 +do { \
7798 + (flags) = ldsr_local_irq_save(); \
7799 +} while (0)
7800 +
7801 +/*
7802 + * raw_local_irq_restore()
7803 + * Restore the IRQ state back to flags.
7804 + */
7805 +static inline void raw_local_irq_restore(unsigned long flags)
7806 +{
7807 + ldsr_local_irq_restore(flags);
7808 +}
7809 +
7810 +/*
7811 + * raw_irqs_disabled_flags()
7812 + * Return true if the flags indicate that IRQ(s) are disabled.
7813 + */
7814 +static inline int raw_irqs_disabled_flags(unsigned long flags)
7815 +{
7816 + return (flags);
7817 +}
7818 +
7819 +#endif /* _ASM_UBICOM32_IRQFLAGS_H */
7820 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/irq.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irq.h
7821 --- linux-2.6.30.10/arch/ubicom32/include/asm/irq.h 1970-01-01 02:00:00.000000000 +0200
7822 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irq.h 2009-12-11 11:45:11.000000000 +0200
7823 @@ -0,0 +1,45 @@
7824 +/*
7825 + * arch/ubicom32/include/asm/irq.h
7826 + * IRQ definitions for Ubicom32 architecture.
7827 + *
7828 + * (C) Copyright 2009, Ubicom, Inc.
7829 + *
7830 + * This file is part of the Ubicom32 Linux Kernel Port.
7831 + *
7832 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7833 + * it and/or modify it under the terms of the GNU General Public License
7834 + * as published by the Free Software Foundation, either version 2 of the
7835 + * License, or (at your option) any later version.
7836 + *
7837 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7838 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7839 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7840 + * the GNU General Public License for more details.
7841 + *
7842 + * You should have received a copy of the GNU General Public License
7843 + * along with the Ubicom32 Linux Kernel Port. If not,
7844 + * see <http://www.gnu.org/licenses/>.
7845 + *
7846 + * Ubicom32 implementation derived from (with many thanks):
7847 + * arch/m68knommu
7848 + * arch/blackfin
7849 + * arch/parisc
7850 + */
7851 +#ifndef _ASM_UBICOM32_IRQ_H
7852 +#define _ASM_UBICOM32_IRQ_H
7853 +
7854 +#include <asm/irqflags.h>
7855 +
7856 +/*
7857 + * We setup the IRQS to cover the full range of interrupt registers in
7858 + * processor.
7859 + */
7860 +#define NR_IRQS 64
7861 +
7862 +#define irq_canonicalize(irq) (irq)
7863 +
7864 +extern int irq_soft_alloc(unsigned int *soft);
7865 +extern void ack_bad_irq(unsigned int irq);
7866 +extern void do_IRQ(int irq, struct pt_regs *fp);
7867 +
7868 +#endif /* _ASM_UBICOM32_IRQ_H */
7869 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/irq_regs.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irq_regs.h
7870 --- linux-2.6.30.10/arch/ubicom32/include/asm/irq_regs.h 1970-01-01 02:00:00.000000000 +0200
7871 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/irq_regs.h 2009-12-11 11:45:11.000000000 +0200
7872 @@ -0,0 +1,33 @@
7873 +/*
7874 + * arch/ubicom32/include/asm/irq_regs.h
7875 + * Generic irq_regs.h for Ubicom32 architecture.
7876 + *
7877 + * (C) Copyright 2009, Ubicom, Inc.
7878 + *
7879 + * This file is part of the Ubicom32 Linux Kernel Port.
7880 + *
7881 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7882 + * it and/or modify it under the terms of the GNU General Public License
7883 + * as published by the Free Software Foundation, either version 2 of the
7884 + * License, or (at your option) any later version.
7885 + *
7886 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7887 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7888 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7889 + * the GNU General Public License for more details.
7890 + *
7891 + * You should have received a copy of the GNU General Public License
7892 + * along with the Ubicom32 Linux Kernel Port. If not,
7893 + * see <http://www.gnu.org/licenses/>.
7894 + *
7895 + * Ubicom32 implementation derived from (with many thanks):
7896 + * arch/m68knommu
7897 + * arch/blackfin
7898 + * arch/parisc
7899 + */
7900 +#ifndef _ASM_UBICOM32_IRQ_REGS_H
7901 +#define _ASM_UBICOM32_IRQ_REGS_H
7902 +
7903 +#include <asm-generic/irq_regs.h>
7904 +
7905 +#endif /* _ASM_UBICOM32_IRQ_REGS_H */
7906 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/Kbuild linux-2.6.30.10-ubi/arch/ubicom32/include/asm/Kbuild
7907 --- linux-2.6.30.10/arch/ubicom32/include/asm/Kbuild 1970-01-01 02:00:00.000000000 +0200
7908 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/Kbuild 2009-12-11 11:45:11.000000000 +0200
7909 @@ -0,0 +1 @@
7910 +include include/asm-generic/Kbuild.asm
7911 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/kdebug.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/kdebug.h
7912 --- linux-2.6.30.10/arch/ubicom32/include/asm/kdebug.h 1970-01-01 02:00:00.000000000 +0200
7913 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/kdebug.h 2009-12-11 11:45:11.000000000 +0200
7914 @@ -0,0 +1,33 @@
7915 +/*
7916 + * arch/ubicom32/include/asm/kdebug.h
7917 + * Generic kdebug.h for Ubicom32 architecture.
7918 + *
7919 + * (C) Copyright 2009, Ubicom, Inc.
7920 + *
7921 + * This file is part of the Ubicom32 Linux Kernel Port.
7922 + *
7923 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7924 + * it and/or modify it under the terms of the GNU General Public License
7925 + * as published by the Free Software Foundation, either version 2 of the
7926 + * License, or (at your option) any later version.
7927 + *
7928 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7929 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7930 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7931 + * the GNU General Public License for more details.
7932 + *
7933 + * You should have received a copy of the GNU General Public License
7934 + * along with the Ubicom32 Linux Kernel Port. If not,
7935 + * see <http://www.gnu.org/licenses/>.
7936 + *
7937 + * Ubicom32 implementation derived from (with many thanks):
7938 + * arch/m68knommu
7939 + * arch/blackfin
7940 + * arch/parisc
7941 + */
7942 +#ifndef _ASM_UBICOM32_KDEBUG_H
7943 +#define _ASM_UBICOM32_KDEBUG_H
7944 +
7945 +#include <asm-generic/kdebug.h>
7946 +
7947 +#endif /* _ASM_UBICOM32_KDEBUG_H */
7948 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/kmap_types.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/kmap_types.h
7949 --- linux-2.6.30.10/arch/ubicom32/include/asm/kmap_types.h 1970-01-01 02:00:00.000000000 +0200
7950 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/kmap_types.h 2009-12-11 11:45:11.000000000 +0200
7951 @@ -0,0 +1,48 @@
7952 +/*
7953 + * arch/ubicom32/include/asm/kmap_types.h
7954 + * Definition of km_type's for Ubicom32 architecture.
7955 + *
7956 + * (C) Copyright 2009, Ubicom, Inc.
7957 + *
7958 + * This file is part of the Ubicom32 Linux Kernel Port.
7959 + *
7960 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
7961 + * it and/or modify it under the terms of the GNU General Public License
7962 + * as published by the Free Software Foundation, either version 2 of the
7963 + * License, or (at your option) any later version.
7964 + *
7965 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
7966 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
7967 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
7968 + * the GNU General Public License for more details.
7969 + *
7970 + * You should have received a copy of the GNU General Public License
7971 + * along with the Ubicom32 Linux Kernel Port. If not,
7972 + * see <http://www.gnu.org/licenses/>.
7973 + *
7974 + * Ubicom32 implementation derived from (with many thanks):
7975 + * arch/m68knommu
7976 + * arch/blackfin
7977 + * arch/parisc
7978 + */
7979 +#ifndef _ASM_UBICOM32_KMAP_TYPES_H
7980 +#define _ASM_UBICOM32_KMAP_TYPES_H
7981 +
7982 +enum km_type {
7983 + KM_BOUNCE_READ,
7984 + KM_SKB_SUNRPC_DATA,
7985 + KM_SKB_DATA_SOFTIRQ,
7986 + KM_USER0,
7987 + KM_USER1,
7988 + KM_BIO_SRC_IRQ,
7989 + KM_BIO_DST_IRQ,
7990 + KM_PTE0,
7991 + KM_PTE1,
7992 + KM_IRQ0,
7993 + KM_IRQ1,
7994 + KM_SOFTIRQ0,
7995 + KM_SOFTIRQ1,
7996 + KM_TYPE_NR
7997 +};
7998 +
7999 +#endif /* _ASM_UBICOM32_KMAP_TYPES_H */
8000 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ldsr.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ldsr.h
8001 --- linux-2.6.30.10/arch/ubicom32/include/asm/ldsr.h 1970-01-01 02:00:00.000000000 +0200
8002 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ldsr.h 2009-12-11 11:45:11.000000000 +0200
8003 @@ -0,0 +1,186 @@
8004 +/*
8005 + * arch/ubicom32/include/asm/ldsr.h
8006 + * Ubicom32 LDSR interface definitions.
8007 + *
8008 + * (C) Copyright 2009, Ubicom, Inc.
8009 + *
8010 + * This file is part of the Ubicom32 Linux Kernel Port.
8011 + *
8012 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8013 + * it and/or modify it under the terms of the GNU General Public License
8014 + * as published by the Free Software Foundation, either version 2 of the
8015 + * License, or (at your option) any later version.
8016 + *
8017 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8018 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8019 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8020 + * the GNU General Public License for more details.
8021 + *
8022 + * You should have received a copy of the GNU General Public License
8023 + * along with the Ubicom32 Linux Kernel Port. If not,
8024 + * see <http://www.gnu.org/licenses/>.
8025 + *
8026 + * Ubicom32 implementation derived from (with many thanks):
8027 + * arch/m68knommu
8028 + * arch/blackfin
8029 + * arch/parisc
8030 + */
8031 +#ifndef _ASM_UBICOM32_LDSR_H
8032 +#define _ASM_UBICOM32_LDSR_H
8033 +
8034 +#include <asm/ubicom32-common.h>
8035 +#include <asm/types.h>
8036 +#include <asm/thread.h>
8037 +
8038 +extern unsigned int ldsr_soft_irq_mask;
8039 +
8040 +/*
8041 + * ldsr_local_irq_is_disabled()
8042 + * Test if interrupts are disabled for this thread?
8043 + */
8044 +static inline int ldsr_local_irq_is_disabled(void)
8045 +{
8046 + int ret;
8047 + thread_t self = thread_get_self();
8048 + unsigned int mask = (1 << self);
8049 +
8050 + asm volatile (
8051 + " and.4 %0, scratchpad1, %1 \n\t"
8052 + : "=r" (ret)
8053 + : "d" (mask)
8054 + : "cc"
8055 + );
8056 +
8057 + /*
8058 + * We return a simple 1 == disabled, 0 == enabled
8059 + * losing which tid this is for, because Linux
8060 + * can restore interrupts on a different thread.
8061 + */
8062 + return ret >> self;
8063 +}
8064 +
8065 +/*
8066 + * ldsr_local_irq_save()
8067 + * Get the current interrupt state and disable interrupts.
8068 + */
8069 +static inline unsigned int ldsr_local_irq_save(void)
8070 +{
8071 + int ret;
8072 + thread_t self = thread_get_self();
8073 + unsigned int mask = (1 << self);
8074 +
8075 + /*
8076 + * Ensure the compiler can not optimize out the code
8077 + * (volatile) and that it does not "cache" values around
8078 + * the interrupt state change (memory). This ensures
8079 + * that interrupt changes are treated as a critical
8080 + * section.
8081 + */
8082 + asm volatile (
8083 + " and.4 %0, scratchpad1, %1 \n\t"
8084 + " or.4 scratchpad1, scratchpad1, %1 \n\t"
8085 + : "=&r" (ret)
8086 + : "d" (mask)
8087 + : "cc", "memory"
8088 + );
8089 +
8090 + /*
8091 + * We return a simple 1 == disabled, 0 == enabled
8092 + * losing which tid this is for, because Linux
8093 + * can restore interrupts on a different thread.
8094 + */
8095 + return ret >> self;
8096 +}
8097 +
8098 +/*
8099 + * ldsr_local_irq_restore()
8100 + * Restore this cpu's interrupt enable/disable state.
8101 + *
8102 + * Note: flags is either 0 or 1.
8103 + */
8104 +static inline void ldsr_local_irq_restore(unsigned int flags)
8105 +{
8106 + unsigned int temp;
8107 + thread_t self = thread_get_self();
8108 + unsigned int mask = (1 << self);
8109 + flags = (flags << self);
8110 +
8111 + /*
8112 + * Ensure the compiler can not optimize out the code
8113 + * (volatile) and that it does not "cache" values around
8114 + * the interrupt state change (memory). This ensures
8115 + * that interrupt changes are treated as a critical
8116 + * section.
8117 + *
8118 + * Atomic change to our bit in scratchpad1 without
8119 + * causing any temporary glitch in the value and
8120 + * without effecting other values. Also this uses
8121 + * no branches so no penalties.
8122 + */
8123 + asm volatile (
8124 + " xor.4 %0, scratchpad1, %1 \n\t"
8125 + " and.4 %0, %2, %0 \n\t"
8126 + " xor.4 scratchpad1, scratchpad1, %0 \n\t"
8127 + " move.4 int_set0, %3 \n\t"
8128 + : "=&d"(temp)
8129 + : "d"(flags), "r"(mask), "r"(ldsr_soft_irq_mask)
8130 + : "cc", "memory"
8131 + );
8132 +}
8133 +
8134 +/*
8135 + * ldsr_local_irq_disable_interrupt()
8136 + * Disable ints for this thread.
8137 + */
8138 +static inline void ldsr_local_irq_disable(void)
8139 +{
8140 + unsigned int mask = (1 << thread_get_self());
8141 +
8142 + /*
8143 + * Ensure the compiler can not optimize out the code
8144 + * (volatile) and that it does not "cache" values around
8145 + * the interrupt state change (memory). This ensures
8146 + * that interrupt changes are treated as a critical
8147 + * section.
8148 + */
8149 + asm volatile (
8150 + " or.4 scratchpad1, scratchpad1, %0 \n\t"
8151 + :
8152 + : "d" (mask)
8153 + : "cc", "memory"
8154 + );
8155 +}
8156 +
8157 +/*
8158 + * ldsr_local_irq_enable_interrupt
8159 + * Enable ints for this thread.
8160 + */
8161 +static inline void ldsr_local_irq_enable(void)
8162 +{
8163 + unsigned int mask = (1 << thread_get_self());
8164 +
8165 + /*
8166 + * Ensure the compiler can not optimize out the code
8167 + * (volatile) and that it does not "cache" values around
8168 + * the interrupt state change (memory). This ensures
8169 + * that interrupt changes are treated as a critical
8170 + * section.
8171 + */
8172 + asm volatile (
8173 + " and.4 scratchpad1, scratchpad1, %0 \n\t"
8174 + " move.4 int_set0, %1 \n\t"
8175 + :
8176 + : "d" (~mask), "r" (ldsr_soft_irq_mask)
8177 + : "cc", "memory"
8178 + );
8179 +}
8180 +
8181 +extern void ldsr_init(void);
8182 +extern void ldsr_set_trap_irq(unsigned int irq);
8183 +extern void ldsr_mask_vector(unsigned int vector);
8184 +extern void ldsr_unmask_vector(unsigned int vector);
8185 +extern void ldsr_enable_vector(unsigned int vector);
8186 +extern void ldsr_disable_vector(unsigned int vector);
8187 +extern thread_t ldsr_get_threadid(void);
8188 +
8189 +#endif /* _ASM_UBICOM32_LDSR_H */
8190 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/linkage.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/linkage.h
8191 --- linux-2.6.30.10/arch/ubicom32/include/asm/linkage.h 1970-01-01 02:00:00.000000000 +0200
8192 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/linkage.h 2009-12-11 11:45:11.000000000 +0200
8193 @@ -0,0 +1,34 @@
8194 +/*
8195 + * arch/ubicom32/include/asm/linkage.h
8196 + * Definition of Ubicom32 architecture specific linkage types.
8197 + *
8198 + * (C) Copyright 2009, Ubicom, Inc.
8199 + *
8200 + * This file is part of the Ubicom32 Linux Kernel Port.
8201 + *
8202 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8203 + * it and/or modify it under the terms of the GNU General Public License
8204 + * as published by the Free Software Foundation, either version 2 of the
8205 + * License, or (at your option) any later version.
8206 + *
8207 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8208 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8209 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8210 + * the GNU General Public License for more details.
8211 + *
8212 + * You should have received a copy of the GNU General Public License
8213 + * along with the Ubicom32 Linux Kernel Port. If not,
8214 + * see <http://www.gnu.org/licenses/>.
8215 + *
8216 + * Ubicom32 implementation derived from (with many thanks):
8217 + * arch/m68knommu
8218 + * arch/blackfin
8219 + * arch/parisc
8220 + */
8221 +#ifndef _ASM_UBICOM32_LINKAGE_H
8222 +#define _ASM_UBICOM32_LINKAGE_H
8223 +
8224 +#define __ocm_text __section(.ocm_text)
8225 +#define __ocm_data __section(.ocm_data)
8226 +
8227 +#endif /* _ASM_UBICOM32_LINKAGE_H */
8228 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/local.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/local.h
8229 --- linux-2.6.30.10/arch/ubicom32/include/asm/local.h 1970-01-01 02:00:00.000000000 +0200
8230 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/local.h 2009-12-11 11:45:11.000000000 +0200
8231 @@ -0,0 +1,33 @@
8232 +/*
8233 + * arch/ubicom32/include/asm/local.h
8234 + * Generic local.h for Ubicom32 architecture.
8235 + *
8236 + * (C) Copyright 2009, Ubicom, Inc.
8237 + *
8238 + * This file is part of the Ubicom32 Linux Kernel Port.
8239 + *
8240 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8241 + * it and/or modify it under the terms of the GNU General Public License
8242 + * as published by the Free Software Foundation, either version 2 of the
8243 + * License, or (at your option) any later version.
8244 + *
8245 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8246 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8247 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8248 + * the GNU General Public License for more details.
8249 + *
8250 + * You should have received a copy of the GNU General Public License
8251 + * along with the Ubicom32 Linux Kernel Port. If not,
8252 + * see <http://www.gnu.org/licenses/>.
8253 + *
8254 + * Ubicom32 implementation derived from (with many thanks):
8255 + * arch/m68knommu
8256 + * arch/blackfin
8257 + * arch/parisc
8258 + */
8259 +#ifndef _ASM_UBICOM32_LOCAL_H
8260 +#define _ASM_UBICOM32_LOCAL_H
8261 +
8262 +#include <asm-generic/local.h>
8263 +
8264 +#endif /* _ASM_UBICOM32_LOCAL_H */
8265 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/machdep.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/machdep.h
8266 --- linux-2.6.30.10/arch/ubicom32/include/asm/machdep.h 1970-01-01 02:00:00.000000000 +0200
8267 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/machdep.h 2009-12-11 11:45:11.000000000 +0200
8268 @@ -0,0 +1,43 @@
8269 +/*
8270 + * arch/ubicom32/include/asm/machdep.h
8271 + * Machine dependent utility routines.
8272 + *
8273 + * (C) Copyright 2009, Ubicom, Inc.
8274 + *
8275 + * This file is part of the Ubicom32 Linux Kernel Port.
8276 + *
8277 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8278 + * it and/or modify it under the terms of the GNU General Public License
8279 + * as published by the Free Software Foundation, either version 2 of the
8280 + * License, or (at your option) any later version.
8281 + *
8282 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8283 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8284 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8285 + * the GNU General Public License for more details.
8286 + *
8287 + * You should have received a copy of the GNU General Public License
8288 + * along with the Ubicom32 Linux Kernel Port. If not,
8289 + * see <http://www.gnu.org/licenses/>.
8290 + *
8291 + * Ubicom32 implementation derived from (with many thanks):
8292 + * arch/m68knommu
8293 + * arch/blackfin
8294 + * arch/parisc
8295 + */
8296 +#ifndef _ASM_UBICOM32_MACHDEP_H
8297 +#define _ASM_UBICOM32_MACHDEP_H
8298 +
8299 +#include <linux/interrupt.h>
8300 +
8301 +/* Hardware clock functions */
8302 +extern unsigned long hw_timer_offset(void);
8303 +
8304 +/* machine dependent power off functions */
8305 +extern void (*mach_reset)(void);
8306 +extern void (*mach_halt)(void);
8307 +extern void (*mach_power_off)(void);
8308 +
8309 +extern void config_BSP(char *command, int len);
8310 +
8311 +#endif /* _ASM_UBICOM32_MACHDEP_H */
8312 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/mc146818rtc.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mc146818rtc.h
8313 --- linux-2.6.30.10/arch/ubicom32/include/asm/mc146818rtc.h 1970-01-01 02:00:00.000000000 +0200
8314 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mc146818rtc.h 2009-12-11 11:45:11.000000000 +0200
8315 @@ -0,0 +1,36 @@
8316 +/*
8317 + * arch/ubicom32/include/asm/mc146818rtc.h
8318 + * Generic mc146818rtc.h for Ubicom32 architecture.
8319 + *
8320 + * (C) Copyright 2009, Ubicom, Inc.
8321 + *
8322 + * This file is part of the Ubicom32 Linux Kernel Port.
8323 + *
8324 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8325 + * it and/or modify it under the terms of the GNU General Public License
8326 + * as published by the Free Software Foundation, either version 2 of the
8327 + * License, or (at your option) any later version.
8328 + *
8329 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8330 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8331 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8332 + * the GNU General Public License for more details.
8333 + *
8334 + * You should have received a copy of the GNU General Public License
8335 + * along with the Ubicom32 Linux Kernel Port. If not,
8336 + * see <http://www.gnu.org/licenses/>.
8337 + *
8338 + * Ubicom32 implementation derived from (with many thanks):
8339 + * arch/m68knommu
8340 + * arch/blackfin
8341 + * arch/parisc
8342 + */
8343 +/*
8344 + * Machine dependent access functions for RTC registers.
8345 + */
8346 +#ifndef _ASM_UBICOM32_MC146818RTC_H
8347 +#define _ASM_UBICOM32_MC146818RTC_H
8348 +
8349 +/* empty include file to satisfy the include in genrtc.c/ide-geometry.c */
8350 +
8351 +#endif /* _ASM_UBICOM32_MC146818RTC_H */
8352 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/memory_map.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/memory_map.h
8353 --- linux-2.6.30.10/arch/ubicom32/include/asm/memory_map.h 1970-01-01 02:00:00.000000000 +0200
8354 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/memory_map.h 2009-12-11 11:45:11.000000000 +0200
8355 @@ -0,0 +1,66 @@
8356 +/*
8357 + * arch/ubicom32/include/asm/memory_map.h
8358 + * Machine memory maps/
8359 + *
8360 + * (C) Copyright 2009, Ubicom, Inc.
8361 + *
8362 + * This file is part of the Ubicom32 Linux Kernel Port.
8363 + *
8364 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8365 + * it and/or modify it under the terms of the GNU General Public License
8366 + * as published by the Free Software Foundation, either version 2 of the
8367 + * License, or (at your option) any later version.
8368 + *
8369 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8370 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8371 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8372 + * the GNU General Public License for more details.
8373 + *
8374 + * You should have received a copy of the GNU General Public License
8375 + * along with the Ubicom32 Linux Kernel Port. If not,
8376 + * see <http://www.gnu.org/licenses/>.
8377 + *
8378 + * Ubicom32 implementation derived from (with many thanks):
8379 + * arch/m68knommu
8380 + * arch/blackfin
8381 + * arch/parisc
8382 + */
8383 +#ifndef _ASM_UBICOM32_MEMORY_MAP_H
8384 +#define _ASM_UBICOM32_MEMORY_MAP_H
8385 +
8386 +/*
8387 + * Memory Size
8388 + */
8389 +#define OCM_SECTOR_SIZE 0x00008000 /* 32K */
8390 +
8391 +#if defined(CONFIG_UBICOM32_V3)
8392 +#define OCMSIZE 0x00030000 /* 192K on-chip RAM for both program and data */
8393 +#elif defined(CONFIG_UBICOM32_V4)
8394 +#define OCMSIZE 0x0003C000 /* 240K on-chip RAM for both program and data */
8395 +#else
8396 +#error "Unknown IP5K silicon"
8397 +#endif
8398 +
8399 +#define OCMSTART 0x3ffc0000 /* alias from 0x03000000 for easy
8400 + * jump to/from SDRAM */
8401 +#define OCMEND (OCMSTART + OCMSIZE)
8402 +
8403 +#define SDRAMSTART 0x40000000
8404 +
8405 +#define KERNELSTART (SDRAMSTART + 0x00400000)
8406 +
8407 +#define FLASHSTART 0x60000000
8408 +
8409 +/*
8410 + * CODELOADER / OS_SYSCALL OCM Reservations
8411 + * Don't change these unless you know what you are doing.
8412 + */
8413 +#define CODELOADER_SIZE 0x30
8414 +#define CODELOADER_BEGIN OCMSTART /* Must be OCM start for gdb to work. */
8415 +#define CODELOADER_END (CODELOADER_BEGIN + CODELOADER_SIZE)
8416 +
8417 +#define OS_SYSCALL_BEGIN CODELOADER_END /* system_call at this address */
8418 +#define OS_SYSCALL_SIZE (512 - CODELOADER_SIZE)
8419 +#define OS_SYSCALL_END (OS_SYSCALL_BEGIN + OS_SYSCALL_SIZE)
8420 +
8421 +#endif /* _ASM_UBICOM32_MEMORY_MAP_H */
8422 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/mman.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mman.h
8423 --- linux-2.6.30.10/arch/ubicom32/include/asm/mman.h 1970-01-01 02:00:00.000000000 +0200
8424 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mman.h 2009-12-11 11:45:11.000000000 +0200
8425 @@ -0,0 +1,44 @@
8426 +/*
8427 + * arch/ubicom32/include/asm/mman.h
8428 + * Memory mapping definitions for Ubicom32 architecture.
8429 + *
8430 + * (C) Copyright 2009, Ubicom, Inc.
8431 + *
8432 + * This file is part of the Ubicom32 Linux Kernel Port.
8433 + *
8434 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8435 + * it and/or modify it under the terms of the GNU General Public License
8436 + * as published by the Free Software Foundation, either version 2 of the
8437 + * License, or (at your option) any later version.
8438 + *
8439 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8440 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8441 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8442 + * the GNU General Public License for more details.
8443 + *
8444 + * You should have received a copy of the GNU General Public License
8445 + * along with the Ubicom32 Linux Kernel Port. If not,
8446 + * see <http://www.gnu.org/licenses/>.
8447 + *
8448 + * Ubicom32 implementation derived from (with many thanks):
8449 + * arch/m68knommu
8450 + * arch/blackfin
8451 + * arch/parisc
8452 + */
8453 +#ifndef _ASM_UBICOM32_MMAN_H
8454 +#define _ASM_UBICOM32_MMAN_H
8455 +
8456 +#include <asm-generic/mman.h>
8457 +
8458 +#define MAP_GROWSDOWN 0x0100 /* stack-like segment */
8459 +#define MAP_DENYWRITE 0x0800 /* ETXTBSY */
8460 +#define MAP_EXECUTABLE 0x1000 /* mark it as an executable */
8461 +#define MAP_LOCKED 0x2000 /* pages are locked */
8462 +#define MAP_NORESERVE 0x4000 /* don't check for reservations */
8463 +#define MAP_POPULATE 0x8000 /* populate (prefault) pagetables */
8464 +#define MAP_NONBLOCK 0x10000 /* do not block on IO */
8465 +
8466 +#define MCL_CURRENT 1 /* lock all current mappings */
8467 +#define MCL_FUTURE 2 /* lock all future mappings */
8468 +
8469 +#endif /* _ASM_UBICOM32_MMAN_H */
8470 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/mmu_context.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mmu_context.h
8471 --- linux-2.6.30.10/arch/ubicom32/include/asm/mmu_context.h 1970-01-01 02:00:00.000000000 +0200
8472 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mmu_context.h 2009-12-11 11:45:11.000000000 +0200
8473 @@ -0,0 +1,60 @@
8474 +/*
8475 + * arch/ubicom32/include/asm/mmu_context.h
8476 + * MMU context definitions for Ubicom32 architecture.
8477 + *
8478 + * (C) Copyright 2009, Ubicom, Inc.
8479 + * Copyright (C) 2004, Microtronix Datacom Ltd., All rights reserved.
8480 + *
8481 + * This file is part of the Ubicom32 Linux Kernel Port.
8482 + *
8483 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8484 + * it and/or modify it under the terms of the GNU General Public License
8485 + * as published by the Free Software Foundation, either version 2 of the
8486 + * License, or (at your option) any later version.
8487 + *
8488 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8489 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8490 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8491 + * the GNU General Public License for more details.
8492 + *
8493 + * You should have received a copy of the GNU General Public License
8494 + * along with the Ubicom32 Linux Kernel Port. If not,
8495 + * see <http://www.gnu.org/licenses/>.
8496 + *
8497 + * Ubicom32 implementation derived from (with many thanks):
8498 + * arch/m68knommu
8499 + * arch/blackfin
8500 + * arch/parisc
8501 + */
8502 +
8503 +#ifndef _ASM_UBICOM32_MMU_CONTEXT_H
8504 +#define _ASM_UBICOM32_MMU_CONTEXT_H
8505 +
8506 +#include <asm/setup.h>
8507 +#include <asm/page.h>
8508 +#include <asm/pgalloc.h>
8509 +
8510 +static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk)
8511 +{
8512 +}
8513 +
8514 +extern inline int
8515 +init_new_context(struct task_struct *tsk, struct mm_struct *mm)
8516 +{
8517 + // mm->context = virt_to_phys(mm->pgd);
8518 + return(0);
8519 +}
8520 +
8521 +#define destroy_context(mm) do { } while(0)
8522 +
8523 +static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk)
8524 +{
8525 +}
8526 +
8527 +#define deactivate_mm(tsk,mm) do { } while (0)
8528 +
8529 +extern inline void activate_mm(struct mm_struct *prev_mm, struct mm_struct *next_mm)
8530 +{
8531 +}
8532 +
8533 +#endif /* _ASM_UBICOM32_MMU_CONTEXT_H */
8534 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/mmu.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mmu.h
8535 --- linux-2.6.30.10/arch/ubicom32/include/asm/mmu.h 1970-01-01 02:00:00.000000000 +0200
8536 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mmu.h 2009-12-11 11:45:11.000000000 +0200
8537 @@ -0,0 +1,41 @@
8538 +/*
8539 + * arch/ubicom32/include/asm/mmu.h
8540 + * Definition of mm_context_t struct for Ubicom32 architecture.
8541 + *
8542 + * (C) Copyright 2009, Ubicom, Inc.
8543 + * Copyright (C) 2002, David McCullough <davidm@snapgear.com>
8544 + *
8545 + * This file is part of the Ubicom32 Linux Kernel Port.
8546 + *
8547 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8548 + * it and/or modify it under the terms of the GNU General Public License
8549 + * as published by the Free Software Foundation, either version 2 of the
8550 + * License, or (at your option) any later version.
8551 + *
8552 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8553 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8554 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8555 + * the GNU General Public License for more details.
8556 + *
8557 + * You should have received a copy of the GNU General Public License
8558 + * along with the Ubicom32 Linux Kernel Port. If not,
8559 + * see <http://www.gnu.org/licenses/>.
8560 + *
8561 + * Ubicom32 implementation derived from (with many thanks):
8562 + * arch/m68knommu
8563 + * arch/blackfin
8564 + * arch/parisc
8565 + */
8566 +#ifndef _ASM_UBICOM32_MMU_H
8567 +#define _ASM_UBICOM32_MMU_H
8568 +
8569 +typedef struct {
8570 + struct vm_list_struct *vmlist;
8571 + unsigned long end_brk;
8572 +#ifdef CONFIG_BINFMT_ELF_FDPIC
8573 + unsigned long exec_fdpic_loadmap;
8574 + unsigned long interp_fdpic_loadmap;
8575 +#endif
8576 +} mm_context_t;
8577 +
8578 +#endif /* _ASM_UBICOM32_MMU_H */
8579 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/module.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/module.h
8580 --- linux-2.6.30.10/arch/ubicom32/include/asm/module.h 1970-01-01 02:00:00.000000000 +0200
8581 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/module.h 2009-12-11 11:45:11.000000000 +0200
8582 @@ -0,0 +1,48 @@
8583 +/*
8584 + * arch/ubicom32/include/asm/module.h
8585 + * Ubicom32 architecture specific module definitions.
8586 + *
8587 + * (C) Copyright 2009, Ubicom, Inc.
8588 + *
8589 + * This file is part of the Ubicom32 Linux Kernel Port.
8590 + *
8591 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8592 + * it and/or modify it under the terms of the GNU General Public License
8593 + * as published by the Free Software Foundation, either version 2 of the
8594 + * License, or (at your option) any later version.
8595 + *
8596 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8597 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8598 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8599 + * the GNU General Public License for more details.
8600 + *
8601 + * You should have received a copy of the GNU General Public License
8602 + * along with the Ubicom32 Linux Kernel Port. If not,
8603 + * see <http://www.gnu.org/licenses/>.
8604 + *
8605 + * Ubicom32 implementation derived from (with many thanks):
8606 + * arch/m68knommu
8607 + * arch/blackfin
8608 + * arch/parisc
8609 + */
8610 +#ifndef _ASM_UBICOM32_MODULE_H
8611 +#define _ASM_UBICOM32_MODULE_H
8612 +
8613 +struct mod_arch_specific {
8614 + void *ocm_inst;
8615 + int ocm_inst_size;
8616 +};
8617 +
8618 +#define Elf_Shdr Elf32_Shdr
8619 +#define Elf_Sym Elf32_Sym
8620 +#define Elf_Ehdr Elf32_Ehdr
8621 +
8622 +#define ARCH_PROC_MODULES_EXTRA(m,mod) \
8623 + seq_printf(m, " OCM(%d bytes @ 0x%p)", \
8624 + (mod)->arch.ocm_inst_size, (mod)->arch.ocm_inst)
8625 +
8626 +#define ARCH_OOPS_MODULE_EXTRA(mod) \
8627 + printk(KERN_INFO "%p %u OCM(%p %u)\n", \
8628 + (mod)->module_core, (mod)->core_size, \
8629 + (mod)->arch.ocm_inst, (mod)->arch.ocm_inst_size)
8630 +#endif /* _ASM_UBICOM32_MODULE_H */
8631 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/msgbuf.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/msgbuf.h
8632 --- linux-2.6.30.10/arch/ubicom32/include/asm/msgbuf.h 1970-01-01 02:00:00.000000000 +0200
8633 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/msgbuf.h 2009-12-11 11:45:11.000000000 +0200
8634 @@ -0,0 +1,58 @@
8635 +/*
8636 + * arch/ubicom32/include/asm/msgbuf.h
8637 + * Definition of msqid64_ds struct for Ubicom32 architecture.
8638 + *
8639 + * (C) Copyright 2009, Ubicom, Inc.
8640 + *
8641 + * This file is part of the Ubicom32 Linux Kernel Port.
8642 + *
8643 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8644 + * it and/or modify it under the terms of the GNU General Public License
8645 + * as published by the Free Software Foundation, either version 2 of the
8646 + * License, or (at your option) any later version.
8647 + *
8648 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8649 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8650 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8651 + * the GNU General Public License for more details.
8652 + *
8653 + * You should have received a copy of the GNU General Public License
8654 + * along with the Ubicom32 Linux Kernel Port. If not,
8655 + * see <http://www.gnu.org/licenses/>.
8656 + *
8657 + * Ubicom32 implementation derived from (with many thanks):
8658 + * arch/m68knommu
8659 + * arch/blackfin
8660 + * arch/parisc
8661 + */
8662 +#ifndef _ASM_UBICOM32_MSGBUF_H
8663 +#define _ASM_UBICOM32_MSGBUF_H
8664 +
8665 +/*
8666 + * The msqid64_ds structure for ubicom32 architecture.
8667 + * Note extra padding because this structure is passed back and forth
8668 + * between kernel and user space.
8669 + *
8670 + * Pad space is left for:
8671 + * - 64-bit time_t to solve y2038 problem
8672 + * - 2 miscellaneous 32-bit values
8673 + */
8674 +
8675 +struct msqid64_ds {
8676 + struct ipc64_perm msg_perm;
8677 + __kernel_time_t msg_stime; /* last msgsnd time */
8678 + unsigned long __unused1;
8679 + __kernel_time_t msg_rtime; /* last msgrcv time */
8680 + unsigned long __unused2;
8681 + __kernel_time_t msg_ctime; /* last change time */
8682 + unsigned long __unused3;
8683 + unsigned long msg_cbytes; /* current number of bytes on queue */
8684 + unsigned long msg_qnum; /* number of messages in queue */
8685 + unsigned long msg_qbytes; /* max number of bytes on queue */
8686 + __kernel_pid_t msg_lspid; /* pid of last msgsnd */
8687 + __kernel_pid_t msg_lrpid; /* last receive pid */
8688 + unsigned long __unused4;
8689 + unsigned long __unused5;
8690 +};
8691 +
8692 +#endif /* _ASM_UBICOM32_MSGBUF_H */
8693 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/mutex.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mutex.h
8694 --- linux-2.6.30.10/arch/ubicom32/include/asm/mutex.h 1970-01-01 02:00:00.000000000 +0200
8695 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/mutex.h 2009-12-11 11:45:11.000000000 +0200
8696 @@ -0,0 +1,41 @@
8697 +/*
8698 + * arch/ubicom32/include/asm/mutex.h
8699 + * Generic mutex.h for Ubicom32 architecture.
8700 + *
8701 + * (C) Copyright 2009, Ubicom, Inc.
8702 + *
8703 + * This file is part of the Ubicom32 Linux Kernel Port.
8704 + *
8705 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8706 + * it and/or modify it under the terms of the GNU General Public License
8707 + * as published by the Free Software Foundation, either version 2 of the
8708 + * License, or (at your option) any later version.
8709 + *
8710 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8711 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8712 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8713 + * the GNU General Public License for more details.
8714 + *
8715 + * You should have received a copy of the GNU General Public License
8716 + * along with the Ubicom32 Linux Kernel Port. If not,
8717 + * see <http://www.gnu.org/licenses/>.
8718 + *
8719 + * Ubicom32 implementation derived from (with many thanks):
8720 + * arch/m68knommu
8721 + * arch/blackfin
8722 + * arch/parisc
8723 + */
8724 +/*
8725 + * Pull in the generic implementation for the mutex fastpath.
8726 + *
8727 + * TODO: implement optimized primitives instead, or leave the generic
8728 + * implementation in place, or pick the atomic_xchg() based generic
8729 + * implementation. (see asm-generic/mutex-xchg.h for details)
8730 + */
8731 +
8732 +#ifndef _ASM_UBICOM32_MUTEX_H
8733 +#define _ASM_UBICOM32_MUTEX_H
8734 +
8735 +#include <asm-generic/mutex-dec.h>
8736 +
8737 +#endif /* _ASM_UBICOM32_MUTEX_H */
8738 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/namei.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/namei.h
8739 --- linux-2.6.30.10/arch/ubicom32/include/asm/namei.h 1970-01-01 02:00:00.000000000 +0200
8740 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/namei.h 2009-12-11 11:45:11.000000000 +0200
8741 @@ -0,0 +1,38 @@
8742 +/*
8743 + * arch/ubicom32/include/asm/namei.h
8744 + * Definition of __emul_prefix() for Ubicom32 architecture.
8745 + *
8746 + * (C) Copyright 2009, Ubicom, Inc.
8747 + *
8748 + * This file is part of the Ubicom32 Linux Kernel Port.
8749 + *
8750 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8751 + * it and/or modify it under the terms of the GNU General Public License
8752 + * as published by the Free Software Foundation, either version 2 of the
8753 + * License, or (at your option) any later version.
8754 + *
8755 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8756 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8757 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8758 + * the GNU General Public License for more details.
8759 + *
8760 + * You should have received a copy of the GNU General Public License
8761 + * along with the Ubicom32 Linux Kernel Port. If not,
8762 + * see <http://www.gnu.org/licenses/>.
8763 + *
8764 + * Ubicom32 implementation derived from (with many thanks):
8765 + * arch/m68knommu
8766 + * arch/blackfin
8767 + * arch/parisc
8768 + */
8769 +#ifndef _ASM_UBICOM32_NAMEI_H
8770 +#define _ASM_UBICOM32_NAMEI_H
8771 +
8772 +/* This dummy routine maybe changed to something useful
8773 + * for /usr/gnemul/ emulation stuff.
8774 + * Look at asm-sparc/namei.h for details.
8775 + */
8776 +
8777 +#define __emul_prefix() NULL
8778 +
8779 +#endif /* _ASM_UBICOM32_NAMEI_H */
8780 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ocm-alloc.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm-alloc.h
8781 --- linux-2.6.30.10/arch/ubicom32/include/asm/ocm-alloc.h 1970-01-01 02:00:00.000000000 +0200
8782 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm-alloc.h 2009-12-11 11:45:11.000000000 +0200
8783 @@ -0,0 +1,36 @@
8784 +/*
8785 + * arch/ubicom32/include/asm/ocm-alloc.h
8786 + * Ubicom32 architecture specific ocm definitions.
8787 + *
8788 + * (C) Copyright 2009, Ubicom, Inc.
8789 + *
8790 + * This file is part of the Ubicom32 Linux Kernel Port.
8791 + *
8792 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8793 + * it and/or modify it under the terms of the GNU General Public License
8794 + * as published by the Free Software Foundation, either version 2 of the
8795 + * License, or (at your option) any later version.
8796 + *
8797 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8798 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8799 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8800 + * the GNU General Public License for more details.
8801 + *
8802 + * You should have received a copy of the GNU General Public License
8803 + * along with the Ubicom32 Linux Kernel Port. If not,
8804 + * see <http://www.gnu.org/licenses/>.
8805 + *
8806 + * Ubicom32 implementation derived from (with many thanks):
8807 + * arch/m68knommu
8808 + * arch/blackfin
8809 + * arch/parisc
8810 + */
8811 +#ifndef _ASM_UBICOM32_OCM_ALLOC_H
8812 +#define _ASM_UBICOM32_OCM_ALLOC_H
8813 +
8814 +
8815 +extern void *ocm_inst_alloc(size_t size, pid_t pid);
8816 +extern int ocm_free(const void *ptr);
8817 +extern int ocm_inst_free(const void *ptr);
8818 +
8819 +#endif /* _ASM_UBICOM32_OCM_ALLOC_H */
8820 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ocm_size.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm_size.h
8821 --- linux-2.6.30.10/arch/ubicom32/include/asm/ocm_size.h 1970-01-01 02:00:00.000000000 +0200
8822 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm_size.h 2009-12-14 14:30:27.000000000 +0200
8823 @@ -0,0 +1,3 @@
8824 +#define APP_OCM_CODE_SIZE (0x3ffc2e00-0x3ffc0000)
8825 +#define APP_OCM_DATA_SIZE (0x3ffd3500-0x3ffc8000)
8826 +
8827 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ocm_text.lds.inc linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm_text.lds.inc
8828 --- linux-2.6.30.10/arch/ubicom32/include/asm/ocm_text.lds.inc 1970-01-01 02:00:00.000000000 +0200
8829 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ocm_text.lds.inc 2009-12-11 11:45:11.000000000 +0200
8830 @@ -0,0 +1,175 @@
8831 +/*
8832 + * arch/ubicom32/include/asm/ocm_text.lds.inc
8833 + * <TODO: Replace with short file description>
8834 + *
8835 + * (C) Copyright 2009, Ubicom, Inc.
8836 + *
8837 + * This file is part of the Ubicom32 Linux Kernel Port.
8838 + *
8839 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
8840 + * it and/or modify it under the terms of the GNU General Public License
8841 + * as published by the Free Software Foundation, either version 2 of the
8842 + * License, or (at your option) any later version.
8843 + *
8844 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
8845 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
8846 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
8847 + * the GNU General Public License for more details.
8848 + *
8849 + * You should have received a copy of the GNU General Public License
8850 + * along with the Ubicom32 Linux Kernel Port. If not,
8851 + * see <http://www.gnu.org/licenses/>.
8852 + *
8853 + * Ubicom32 implementation derived from (with many thanks):
8854 + * arch/m68knommu
8855 + * arch/blackfin
8856 + * arch/parisc
8857 + */
8858 +*(.text.do_csum)
8859 +*(.text.tcp_packet)
8860 +*(.text.ipt_do_table)
8861 +*(.text.nf_conntrack_in)
8862 +*(.text.ip_forward)
8863 +*(.text.dev_queue_xmit)
8864 +*(.text.netif_receive_skb)
8865 +*(.text.ip_route_input)
8866 +*(.text.ip_finish_output)
8867 +*(.text.nf_iterate)
8868 +*(.text.__hash_conntrack)
8869 +*(.text.memset)
8870 +*(.text.memcpy)
8871 +*(.text.ip_rcv)
8872 +*(.text.__nf_conntrack_find)
8873 +*(.text.dev_hard_start_xmit)
8874 +*(.text.vlan_dev_hard_start_xmit)
8875 +*(.text.vlan_dev_hard_header)
8876 +*(.text.__nf_ct_refresh_acct)
8877 +*(.text.tcp_error)
8878 +*(.text.pfifo_fast_enqueue)
8879 +*(.text.ipv4_confirm)
8880 +*(.text.ip_output)
8881 +*(.text.neigh_connected_output)
8882 +*(.text.nf_hook_slow)
8883 +*(.text.nf_nat_packet)
8884 +*(.text.local_bh_enable)
8885 +*(.text.pfifo_fast_dequeue)
8886 +*(.text.ubi32_eth_receive)
8887 +*(.text.nf_nat_fn)
8888 +*(.text.skb_checksum)
8889 +*(.text.memmove)
8890 +*(.text.ubi32_eth_tx_done)
8891 +*(.text.eth_header)
8892 +*(.text.skb_release_data)
8893 +*(.text.nf_conntrack_find_get)
8894 +*(.text.process_backlog)
8895 +*(.text.vlan_skb_recv)
8896 +*(.text.ip_rcv_finish)
8897 +*(.text.__qdisc_run)
8898 +*(.text.skb_push)
8899 +*(.text.eth_type_trans)
8900 +*(.text.__alloc_skb)
8901 +*(.text.netif_rx)
8902 +*(.text.nf_ip_checksum)
8903 +*(.text.__skb_checksum_complete_head)
8904 +*(.text.ipv4_conntrack_defrag)
8905 +*(.text.tcp_pkt_to_tuple)
8906 +*(.text.kfree)
8907 +*(.text.tcp_manip_pkt)
8908 +*(.text.skb_put)
8909 +*(.text.nf_ct_get_tuple)
8910 +*(.text.__kmalloc)
8911 +*(.text.ubi32_eth_start_xmit)
8912 +*(.text.free_block)
8913 +*(.text.ipt_hook)
8914 +*(.text.kmem_cache_free)
8915 +*(.text.skb_pull_rcsum)
8916 +*(.text.cache_alloc_refill)
8917 +*(.text.skb_release_head_state)
8918 +*(.text.manip_pkt)
8919 +*(.text.ip_sabotage_in)
8920 +*(.text.ip_forward_finish)
8921 +*(.text.kmem_cache_alloc)
8922 +*(.text.local_bh_disable)
8923 +*(.text.ipv4_pkt_to_tuple)
8924 +*(.text.inet_proto_csum_replace4)
8925 +*(.text.__nf_ct_l4proto_find)
8926 +*(.text.csum_partial)
8927 +*(.text.neigh_resolve_output)
8928 +*(.text.__kfree_skb)
8929 +*(.text.kfree_skb)
8930 +*(.text.__find_vlan_dev)
8931 +*(.text.ldsr_ctxsw_thread)
8932 +*(.text.__do_IRQ)
8933 +*(.text.skb_pull)
8934 +*(.text.ipv4_invert_tuple)
8935 +*(.text.nf_ct_invert_tuplepr)
8936 +*(.text.skb_make_writable)
8937 +*(.text.ipv4_get_l4proto)
8938 +*(.text.handle_IRQ_event)
8939 +*(.text.net_rx_action)
8940 +*(.text.__do_softirq)
8941 +*(.text.nf_nat_in)
8942 +*(.text.note_interrupt)
8943 +*(.text.ipv4_conntrack_in)
8944 +*(.text.dst_release)
8945 +*(.text.tasklet_action)
8946 +*(.text.nf_nat_out)
8947 +*(.text.nf_ct_invert_tuple)
8948 +*(.text.do_IRQ)
8949 +*(.text.__tasklet_schedule)
8950 +*(.text.__skb_checksum_complete)
8951 +*(.text.ubi32_eth_interrupt)
8952 +*(.text.dev_kfree_skb_any)
8953 +*(.text.ret_from_interrupt_to_kernel)
8954 +*(.text.preemptive_context_save)
8955 +*(.text.irq_ack_vector)
8956 +*(.text.update_wall_time)
8957 +*(.text.ldsr_thread)
8958 +*(.text.irq_exit)
8959 +*(.text.ubi32_eth_do_tasklet)
8960 +*(.text.__napi_schedule)
8961 +*(.text.idle_cpu)
8962 +*(.text.run_timer_softirq)
8963 +*(.text.ldsr_mask_vector)
8964 +*(.text.irq_enter)
8965 +*(.text.ldsr_get_lsb)
8966 +*(.text.ldsr_unmask_vector)
8967 +*(.text.ip_fast_csum)
8968 +*(.text.hrtimer_run_queues)
8969 +*(.text.tcp_invert_tuple)
8970 +*(.text.T___705)
8971 +*(.text.run_posix_cpu_timers)
8972 +*(.text.free_hot_cold_page)
8973 +*(.text.lock_timer_base)
8974 +*(.text.calc_delta_mine)
8975 +*(.text.slab_destroy)
8976 +*(.text.rcu_pending)
8977 +*(.text.scheduler_tick)
8978 +*(.text.hrtimer_run_pending)
8979 +*(.text.do_softirq)
8980 +*(.text.del_timer)
8981 +*(.text.irq_end_vector)
8982 +*(.text.pci_read_u32)
8983 +*(.text.udivmodsi4)
8984 +*(.text.memcmp)
8985 +*(.text.memset)
8986 +*(.text.__slab_alloc)
8987 +*(.text.br_handle_frame)
8988 +*(.text.br_fdb_update)
8989 +*(.text.__br_fdb_get)
8990 +*(.text.br_forward)
8991 +*(.text.br_handle_frame_finish)
8992 +*(.text.pci_write_u32)
8993 +*(.text.kmem_freepages)
8994 +*(.text.br_dev_queue_push_xmit)
8995 +*(.text.ioread32)
8996 +*(.text.next_zones_zonelist)
8997 +*(.text.ubi32_pci_read_u32)
8998 +*(.text.zone_watermark_ok)
8999 +*(.text.__rmqueue_smallest)
9000 +*(.text.ubi32_eth_napi_poll)
9001 +*(.text.ubi32_pci_write_u32)
9002 +*(.text.ubi32_pci_read_u32)
9003 +*(.text._local_bh_enable)
9004 +*(.text._local_bh_disable)
9005 +*(.text.get_slab)
9006 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/page.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/page.h
9007 --- linux-2.6.30.10/arch/ubicom32/include/asm/page.h 1970-01-01 02:00:00.000000000 +0200
9008 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/page.h 2009-12-11 11:45:11.000000000 +0200
9009 @@ -0,0 +1,106 @@
9010 +/*
9011 + * arch/ubicom32/include/asm/page.h
9012 + * Memory page related operations and definitions.
9013 + *
9014 + * (C) Copyright 2009, Ubicom, Inc.
9015 + *
9016 + * This file is part of the Ubicom32 Linux Kernel Port.
9017 + *
9018 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9019 + * it and/or modify it under the terms of the GNU General Public License
9020 + * as published by the Free Software Foundation, either version 2 of the
9021 + * License, or (at your option) any later version.
9022 + *
9023 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9024 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9025 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9026 + * the GNU General Public License for more details.
9027 + *
9028 + * You should have received a copy of the GNU General Public License
9029 + * along with the Ubicom32 Linux Kernel Port. If not,
9030 + * see <http://www.gnu.org/licenses/>.
9031 + *
9032 + * Ubicom32 implementation derived from (with many thanks):
9033 + * arch/m68knommu
9034 + * arch/blackfin
9035 + * arch/parisc
9036 + */
9037 +#ifndef _ASM_UBICOM32_PAGE_H
9038 +#define _ASM_UBICOM32_PAGE_H
9039 +
9040 +/* PAGE_SHIFT determines the page size */
9041 +
9042 +#define PAGE_SHIFT 12
9043 +#define PAGE_SIZE (1 << PAGE_SHIFT)
9044 +#define PAGE_MASK (~(PAGE_SIZE-1))
9045 +
9046 +#include <asm/setup.h>
9047 +
9048 +#ifndef __ASSEMBLY__
9049 +
9050 +#define get_user_page(vaddr) __get_free_page(GFP_KERNEL)
9051 +#define free_user_page(page, addr) free_page(addr)
9052 +
9053 +#define clear_page(page) memset((page), 0, PAGE_SIZE)
9054 +#define copy_page(to,from) memcpy((to), (from), PAGE_SIZE)
9055 +
9056 +#define clear_user_page(page, vaddr, pg) clear_page(page)
9057 +#define copy_user_page(to, from, vaddr, pg) copy_page(to, from)
9058 +
9059 +#define __alloc_zeroed_user_highpage(movableflags, vma, vaddr) \
9060 + alloc_page_vma(GFP_HIGHUSER | __GFP_ZERO | movableflags, vma, vaddr)
9061 +#define __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE
9062 +
9063 +/*
9064 + * These are used to make use of C type-checking..
9065 + */
9066 +typedef struct { unsigned long pte; } pte_t;
9067 +typedef struct { unsigned long pmd[16]; } pmd_t;
9068 +typedef struct { unsigned long pgd; } pgd_t;
9069 +typedef struct { unsigned long pgprot; } pgprot_t;
9070 +typedef struct page *pgtable_t;
9071 +
9072 +#define pte_val(x) ((x).pte)
9073 +#define pmd_val(x) ((&x)->pmd[0])
9074 +#define pgd_val(x) ((x).pgd)
9075 +#define pgprot_val(x) ((x).pgprot)
9076 +
9077 +#define __pte(x) ((pte_t) { (x) } )
9078 +#define __pmd(x) ((pmd_t) { (x) } )
9079 +#define __pgd(x) ((pgd_t) { (x) } )
9080 +#define __pgprot(x) ((pgprot_t) { (x) } )
9081 +
9082 +extern unsigned long memory_start;
9083 +extern unsigned long memory_end;
9084 +
9085 +#endif /* !__ASSEMBLY__ */
9086 +
9087 +#include <asm/page_offset.h>
9088 +
9089 +#define PAGE_OFFSET (PAGE_OFFSET_RAW)
9090 +
9091 +#ifndef __ASSEMBLY__
9092 +
9093 +#define __pa(vaddr) virt_to_phys((void *)(vaddr))
9094 +#define __va(paddr) phys_to_virt((unsigned long)(paddr))
9095 +
9096 +#define virt_to_pfn(kaddr) (__pa(kaddr) >> PAGE_SHIFT)
9097 +#define pfn_to_virt(pfn) __va((pfn) << PAGE_SHIFT)
9098 +
9099 +#define virt_to_page(addr) (mem_map + (((unsigned long)(addr)-PAGE_OFFSET) >> PAGE_SHIFT))
9100 +#define page_to_virt(page) ((((page) - mem_map) << PAGE_SHIFT) + PAGE_OFFSET)
9101 +
9102 +#define pfn_to_page(pfn) virt_to_page(pfn_to_virt(pfn))
9103 +#define page_to_pfn(page) virt_to_pfn(page_to_virt(page))
9104 +#define pfn_valid(pfn) ((pfn) < max_mapnr)
9105 +
9106 +#define virt_addr_valid(kaddr) (((void *)(kaddr) >= (void *)PAGE_OFFSET) && \
9107 + ((void *)(kaddr) < (void *)memory_end))
9108 +
9109 +#endif /* __ASSEMBLY__ */
9110 +
9111 +#ifdef __KERNEL__
9112 +#include <asm-generic/page.h>
9113 +#endif
9114 +
9115 +#endif /* _ASM_UBICOM32_PAGE_H */
9116 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/page_offset.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/page_offset.h
9117 --- linux-2.6.30.10/arch/ubicom32/include/asm/page_offset.h 1970-01-01 02:00:00.000000000 +0200
9118 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/page_offset.h 2009-12-11 11:45:11.000000000 +0200
9119 @@ -0,0 +1,35 @@
9120 +/*
9121 + * arch/ubicom32/include/asm/page_offset.h
9122 + * Definition of PAGE_OFFSET_RAW for Ubicom32 architecture.
9123 + *
9124 + * (C) Copyright 2009, Ubicom, Inc.
9125 + *
9126 + * This file is part of the Ubicom32 Linux Kernel Port.
9127 + *
9128 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9129 + * it and/or modify it under the terms of the GNU General Public License
9130 + * as published by the Free Software Foundation, either version 2 of the
9131 + * License, or (at your option) any later version.
9132 + *
9133 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9134 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9135 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9136 + * the GNU General Public License for more details.
9137 + *
9138 + * You should have received a copy of the GNU General Public License
9139 + * along with the Ubicom32 Linux Kernel Port. If not,
9140 + * see <http://www.gnu.org/licenses/>.
9141 + *
9142 + * Ubicom32 implementation derived from (with many thanks):
9143 + * arch/m68knommu
9144 + * arch/blackfin
9145 + * arch/parisc
9146 + */
9147 +
9148 +#ifndef _ASM_UBICOM32_PAGE_OFFSET_H
9149 +#define _ASM_UBICOM32_PAGE_OFFSET_H
9150 +
9151 +/* This handles the memory map.. */
9152 +#define PAGE_OFFSET_RAW 0x3ffc0000
9153 +
9154 +#endif /* _ASM_UBICOM32_PAGE_OFFSET_H */
9155 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/param.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/param.h
9156 --- linux-2.6.30.10/arch/ubicom32/include/asm/param.h 1970-01-01 02:00:00.000000000 +0200
9157 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/param.h 2009-12-11 11:45:11.000000000 +0200
9158 @@ -0,0 +1,49 @@
9159 +/*
9160 + * arch/ubicom32/include/asm/param.h
9161 + * Definition of miscellaneous constants, including HZ.
9162 + *
9163 + * (C) Copyright 2009, Ubicom, Inc.
9164 + *
9165 + * This file is part of the Ubicom32 Linux Kernel Port.
9166 + *
9167 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9168 + * it and/or modify it under the terms of the GNU General Public License
9169 + * as published by the Free Software Foundation, either version 2 of the
9170 + * License, or (at your option) any later version.
9171 + *
9172 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9173 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9174 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9175 + * the GNU General Public License for more details.
9176 + *
9177 + * You should have received a copy of the GNU General Public License
9178 + * along with the Ubicom32 Linux Kernel Port. If not,
9179 + * see <http://www.gnu.org/licenses/>.
9180 + *
9181 + * Ubicom32 implementation derived from (with many thanks):
9182 + * arch/m68knommu
9183 + * arch/blackfin
9184 + * arch/parisc
9185 + */
9186 +#ifndef _ASM_UBICOM32_PARAM_H
9187 +#define _ASM_UBICOM32_PARAM_H
9188 +
9189 +#ifdef __KERNEL__
9190 +#define HZ CONFIG_HZ
9191 +#define USER_HZ HZ
9192 +#define CLOCKS_PER_SEC (USER_HZ)
9193 +#endif
9194 +
9195 +#ifndef HZ
9196 +#define HZ 100
9197 +#endif
9198 +
9199 +#define EXEC_PAGESIZE 4096
9200 +
9201 +#ifndef NOGROUP
9202 +#define NOGROUP (-1)
9203 +#endif
9204 +
9205 +#define MAXHOSTNAMELEN 64 /* max length of hostname */
9206 +
9207 +#endif /* _ASM_UBICOM32_PARAM_H */
9208 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/pci.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pci.h
9209 --- linux-2.6.30.10/arch/ubicom32/include/asm/pci.h 1970-01-01 02:00:00.000000000 +0200
9210 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pci.h 2009-12-11 11:45:11.000000000 +0200
9211 @@ -0,0 +1,210 @@
9212 +/*
9213 + * arch/ubicom32/include/asm/pci.h
9214 + * Definitions of PCI operations for Ubicom32 architecture.
9215 + *
9216 + * (C) Copyright 2009, Ubicom, Inc.
9217 + *
9218 + * This file is part of the Ubicom32 Linux Kernel Port.
9219 + *
9220 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9221 + * it and/or modify it under the terms of the GNU General Public License
9222 + * as published by the Free Software Foundation, either version 2 of the
9223 + * License, or (at your option) any later version.
9224 + *
9225 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9226 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9227 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9228 + * the GNU General Public License for more details.
9229 + *
9230 + * You should have received a copy of the GNU General Public License
9231 + * along with the Ubicom32 Linux Kernel Port. If not,
9232 + * see <http://www.gnu.org/licenses/>.
9233 + *
9234 + * Ubicom32 implementation derived from (with many thanks):
9235 + * arch/m68knommu
9236 + * arch/blackfin
9237 + * arch/parisc
9238 + */
9239 +#ifndef _ASM_UBICOM32_PCI_H
9240 +#define _ASM_UBICOM32_PCI_H
9241 +
9242 +#include <asm/io.h>
9243 +
9244 +/* The PCI address space does equal the physical memory
9245 + * address space. The networking and block device layers use
9246 + * this boolean for bounce buffer decisions.
9247 + */
9248 +#define PCI_DMA_BUS_IS_PHYS (1)
9249 +
9250 +
9251 +
9252 +/*
9253 + * Perform a master read/write to the PCI bus.
9254 + * These functions return a PCI_RESP_xxx code.
9255 + */
9256 +extern u8 pci_read_u32(u8 pci_cmd, u32 address, u32 *data);
9257 +extern u8 pci_write_u32(u8 pci_cmd, u32 address, u32 data);
9258 +extern u8 pci_read_u16(u8 pci_cmd, u32 address, u16 *data);
9259 +extern u8 pci_write_u16(u8 pci_cmd, u32 address, u16 data);
9260 +extern u8 pci_read_u8(u8 pci_cmd, u32 address, u8 *data);
9261 +extern u8 pci_write_u8(u8 pci_cmd, u32 address, u8 data);
9262 +
9263 +
9264 +#define PCIBIOS_MIN_IO 0x100
9265 +#define PCIBIOS_MIN_MEM 0x10000000
9266 +
9267 +#define pcibios_assign_all_busses() 0
9268 +#define pcibios_scan_all_fns(a, b) 0
9269 +extern void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
9270 + struct resource *res);
9271 +
9272 +extern void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
9273 + struct pci_bus_region *region);
9274 +
9275 +struct pci_sys_data;
9276 +struct pci_bus;
9277 +
9278 +struct hw_pci {
9279 + struct list_head buses;
9280 + int nr_controllers;
9281 + int (*setup)(int nr, struct pci_sys_data *);
9282 + struct pci_bus *(*scan)(int nr, struct pci_sys_data *);
9283 + void (*preinit)(void);
9284 + void (*postinit)(void);
9285 + u8 (*swizzle)(struct pci_dev *dev, u8 *pin);
9286 + int (*map_irq)(struct pci_dev *dev, u8 slot, u8 pin);
9287 +};
9288 +
9289 +/*
9290 + * Per-controller structure
9291 + */
9292 +struct pci_sys_data {
9293 + struct list_head node;
9294 + int busnr; /* primary bus number */
9295 + u64 mem_offset; /* bus->cpu memory mapping offset */
9296 + unsigned long io_offset; /* bus->cpu IO mapping offset */
9297 + struct pci_bus *bus; /* PCI bus */
9298 + struct resource *resource[3]; /* Primary PCI bus resources */
9299 + /* Bridge swizzling */
9300 + u8 (*swizzle)(struct pci_dev *, u8 *);
9301 + /* IRQ mapping */
9302 + int (*map_irq)(struct pci_dev *, u8, u8);
9303 + struct hw_pci *hw;
9304 +};
9305 +
9306 +static inline struct resource *
9307 +pcibios_select_root(struct pci_dev *pdev, struct resource *res)
9308 +{
9309 + struct resource *root = NULL;
9310 +
9311 + if (res->flags & IORESOURCE_IO)
9312 + root = &ioport_resource;
9313 + if (res->flags & IORESOURCE_MEM)
9314 + root = &iomem_resource;
9315 +
9316 + return root;
9317 +}
9318 +
9319 +static inline void pcibios_set_master(struct pci_dev *dev)
9320 +{
9321 + /* No special bus mastering setup handling */
9322 +}
9323 +#define HAVE_ARCH_PCI_SET_DMA_MAX_SEGMENT_SIZE 1
9324 +#define HAVE_ARCH_PCI_SET_DMA_SEGMENT_BOUNDARY 1
9325 +
9326 +#ifdef CONFIG_PCI
9327 +static inline void * pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
9328 + dma_addr_t *dma_handle)
9329 +{
9330 + void *vaddr = kmalloc(size, GFP_KERNEL);
9331 + if(vaddr != NULL) {
9332 + *dma_handle = virt_to_phys(vaddr);
9333 + }
9334 + return vaddr;
9335 +}
9336 +
9337 +static inline int pci_dma_supported(struct pci_dev *hwdev, dma_addr_t mask)
9338 +{
9339 + return 1;
9340 +}
9341 +
9342 +static inline void pci_free_consistent(struct pci_dev *hwdev, size_t size,
9343 + void *cpu_addr, dma_addr_t dma_handle)
9344 +{
9345 + kfree(cpu_addr);
9346 + return;
9347 +}
9348 +
9349 +static inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
9350 + size_t size, int direction)
9351 +{
9352 + return virt_to_phys(ptr);
9353 +}
9354 +
9355 +static inline void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
9356 + size_t size, int direction)
9357 +{
9358 + return;
9359 +}
9360 +
9361 +static inline dma_addr_t
9362 +pci_map_page(struct pci_dev *hwdev, struct page *page,
9363 + unsigned long offset, size_t size, int direction)
9364 +{
9365 + return pci_map_single(hwdev, page_address(page) + offset, size, (int)direction);
9366 +}
9367 +
9368 +static inline void
9369 +pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
9370 + size_t size, int direction)
9371 +{
9372 + pci_unmap_single(hwdev, dma_address, size, direction);
9373 +}
9374 +
9375 +static inline int
9376 +pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
9377 + int nents, int direction)
9378 +{
9379 + return nents;
9380 +}
9381 +
9382 +static inline void
9383 +pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
9384 + int nents, int direction)
9385 +{
9386 +}
9387 +
9388 +static inline void
9389 +pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
9390 + int nelems, int direction)
9391 +{
9392 +}
9393 +
9394 +static inline void
9395 +pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
9396 + int nelems, int direction)
9397 +{
9398 +}
9399 +
9400 +static inline void
9401 +pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
9402 + size_t size, int direction)
9403 +{
9404 +}
9405 +
9406 +static inline void
9407 +pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
9408 + size_t size, int direction)
9409 +{
9410 +}
9411 +
9412 +static inline int
9413 +pci_dma_mapping_error(struct pci_dev *hwdev, dma_addr_t dma_addr)
9414 +{
9415 + return dma_addr == 0;
9416 +}
9417 +extern void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
9418 +extern void pci_iounmap(struct pci_dev *dev, void __iomem *);
9419 +#endif
9420 +
9421 +#endif /* _ASM_UBICOM32_PCI_H */
9422 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/pcm_tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pcm_tio.h
9423 --- linux-2.6.30.10/arch/ubicom32/include/asm/pcm_tio.h 1970-01-01 02:00:00.000000000 +0200
9424 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pcm_tio.h 2009-12-11 11:45:11.000000000 +0200
9425 @@ -0,0 +1,84 @@
9426 +/*
9427 + * arch/ubicom32/include/asm/pcm_tio.h
9428 + * Ubicom32 architecture PCM TIO definitions.
9429 + *
9430 + * (C) Copyright 2009, Ubicom, Inc.
9431 + *
9432 + * This file is part of the Ubicom32 Linux Kernel Port.
9433 + *
9434 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9435 + * it and/or modify it under the terms of the GNU General Public License
9436 + * as published by the Free Software Foundation, either version 2 of the
9437 + * License, or (at your option) any later version.
9438 + *
9439 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9440 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9441 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9442 + * the GNU General Public License for more details.
9443 + *
9444 + * You should have received a copy of the GNU General Public License
9445 + * along with the Ubicom32 Linux Kernel Port. If not,
9446 + * see <http://www.gnu.org/licenses/>.
9447 + */
9448 +#ifndef _ASM_UBICOM32_PCM_TIO_H
9449 +#define _ASM_UBICOM32_PCM_TIO_H
9450 +
9451 +#include <asm/devtree.h>
9452 +
9453 +#define PCM_TIO_REGS_VERSION 2
9454 +struct pcm_tio_regs {
9455 + /*
9456 + * set this value to 1 to reload the parameters and restart the HRT
9457 + */
9458 + u32_t reload;
9459 +
9460 + /*
9461 + * Pointers to the input and output buffers
9462 + */
9463 + void *input_buf;
9464 + void *output_buf;
9465 +
9466 + /*
9467 + * Buffer size (see pcm_hrt.S for constraints)
9468 + */
9469 + u32_t buffer_size;
9470 +
9471 + /*
9472 + * Current cycle. This variable increases every time half the buffer
9473 + * is consumed.
9474 + */
9475 + u32_t cycle;
9476 +
9477 + /*
9478 + * Fields below this line are not accessed by the HRT. They are purely
9479 + * informational for the user of this TIO.
9480 + */
9481 +
9482 + /*
9483 + * Version of this structure
9484 + */
9485 + u32_t version;
9486 +
9487 + /*
9488 + * Number of channels supported
9489 + */
9490 + u32_t channels;
9491 +
9492 + /*
9493 + * Maximum buffer size
9494 + */
9495 + u32_t max_buffer_size;
9496 +};
9497 +
9498 +/*
9499 + * Our device node
9500 + */
9501 +#define PCM_TIO_NODE_VERSION 1
9502 +struct pcm_tio_node {
9503 + struct devtree_node dn;
9504 + u32_t version;
9505 + struct pcm_tio_regs *regs;
9506 +};
9507 +
9508 +#endif
9509 +
9510 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/percpu.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/percpu.h
9511 --- linux-2.6.30.10/arch/ubicom32/include/asm/percpu.h 1970-01-01 02:00:00.000000000 +0200
9512 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/percpu.h 2009-12-11 11:45:11.000000000 +0200
9513 @@ -0,0 +1,33 @@
9514 +/*
9515 + * arch/ubicom32/include/asm/percpu.h
9516 + * Generic percpu.h for the Ubicom32 architecture.
9517 + *
9518 + * (C) Copyright 2009, Ubicom, Inc.
9519 + *
9520 + * This file is part of the Ubicom32 Linux Kernel Port.
9521 + *
9522 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9523 + * it and/or modify it under the terms of the GNU General Public License
9524 + * as published by the Free Software Foundation, either version 2 of the
9525 + * License, or (at your option) any later version.
9526 + *
9527 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9528 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9529 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9530 + * the GNU General Public License for more details.
9531 + *
9532 + * You should have received a copy of the GNU General Public License
9533 + * along with the Ubicom32 Linux Kernel Port. If not,
9534 + * see <http://www.gnu.org/licenses/>.
9535 + *
9536 + * Ubicom32 implementation derived from (with many thanks):
9537 + * arch/m68knommu
9538 + * arch/blackfin
9539 + * arch/parisc
9540 + */
9541 +#ifndef _ASM_UBICOM32_PERCPU_H
9542 +#define _ASM_UBICOM32_PERCPU_H
9543 +
9544 +#include <asm-generic/percpu.h>
9545 +
9546 +#endif /* _ASM_UBICOM32_PERCPU_H */
9547 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/pgalloc.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pgalloc.h
9548 --- linux-2.6.30.10/arch/ubicom32/include/asm/pgalloc.h 1970-01-01 02:00:00.000000000 +0200
9549 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pgalloc.h 2009-12-11 11:45:11.000000000 +0200
9550 @@ -0,0 +1,36 @@
9551 +/*
9552 + * arch/ubicom32/include/asm/pgalloc.h
9553 + * Page table allocation definitions.
9554 + *
9555 + * (C) Copyright 2009, Ubicom, Inc.
9556 + *
9557 + * This file is part of the Ubicom32 Linux Kernel Port.
9558 + *
9559 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9560 + * it and/or modify it under the terms of the GNU General Public License
9561 + * as published by the Free Software Foundation, either version 2 of the
9562 + * License, or (at your option) any later version.
9563 + *
9564 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9565 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9566 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9567 + * the GNU General Public License for more details.
9568 + *
9569 + * You should have received a copy of the GNU General Public License
9570 + * along with the Ubicom32 Linux Kernel Port. If not,
9571 + * see <http://www.gnu.org/licenses/>.
9572 + *
9573 + * Ubicom32 implementation derived from (with many thanks):
9574 + * arch/m68knommu
9575 + * arch/blackfin
9576 + * arch/parisc
9577 + */
9578 +#ifndef _ASM_UBICOM32_PGALLOC_H
9579 +#define _ASM_UBICOM32_PGALLOC_H
9580 +
9581 +#include <linux/mm.h>
9582 +#include <asm/setup.h>
9583 +
9584 +#define check_pgt_cache() do { } while (0)
9585 +
9586 +#endif /* _ASM_UBICOM32_PGALLOC_H */
9587 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/pgtable.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pgtable.h
9588 --- linux-2.6.30.10/arch/ubicom32/include/asm/pgtable.h 1970-01-01 02:00:00.000000000 +0200
9589 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/pgtable.h 2009-12-11 11:45:11.000000000 +0200
9590 @@ -0,0 +1,124 @@
9591 +/*
9592 + * arch/ubicom32/include/asm/pgtable.h
9593 + * Ubicom32 pseudo page table definitions and operations.
9594 + *
9595 + * (C) Copyright 2009, Ubicom, Inc.
9596 + * Copyright (C) 2004 Microtronix Datacom Ltd
9597 + *
9598 + * This file is part of the Ubicom32 Linux Kernel Port.
9599 + *
9600 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
9601 + * it and/or modify it under the terms of the GNU General Public License
9602 + * as published by the Free Software Foundation, either version 2 of the
9603 + * License, or (at your option) any later version.
9604 + *
9605 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9606 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9607 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
9608 + * the GNU General Public License for more details.
9609 + *
9610 + * You should have received a copy of the GNU General Public License
9611 + * along with the Ubicom32 Linux Kernel Port. If not,
9612 + * see <http://www.gnu.org/licenses/>.
9613 + *
9614 + * Ubicom32 implementation derived from (with many thanks):
9615 + * arch/m68knommu
9616 + * arch/blackfin
9617 + * arch/parisc
9618 + * and various works, Alpha, ix86, M68K, Sparc, ...et al
9619 + */
9620 +#ifndef _ASM_UBICOM32_PGTABLE_H
9621 +#define _ASM_UBICOM32_PGTABLE_H
9622 +
9623 +#include <asm-generic/4level-fixup.h>
9624 +
9625 +//vic - this bit copied from m68knommu version
9626 +#include <asm/setup.h>
9627 +#include <asm/io.h>
9628 +#include <linux/sched.h>
9629 +
9630 +typedef pte_t *pte_addr_t;
9631 +
9632 +#define pgd_present(pgd) (1) /* pages are always present on NO_MM */
9633 +#define pgd_none(pgd) (0)
9634 +#define pgd_bad(pgd) (0)
9635 +#define pgd_clear(pgdp)
9636 +#define kern_addr_valid(addr) (1)
9637 +#define pmd_offset(a, b) ((void *)0)
9638 +
9639 +#define PAGE_NONE __pgprot(0) /* these mean nothing to NO_MM */
9640 +#define PAGE_SHARED __pgprot(0) /* these mean nothing to NO_MM */
9641 +#define PAGE_COPY __pgprot(0) /* these mean nothing to NO_MM */
9642 +#define PAGE_READONLY __pgprot(0) /* these mean nothing to NO_MM */
9643 +#define PAGE_KERNEL __pgprot(0) /* these mean nothing to NO_MM */
9644 +//vic - this bit copied from m68knommu version
9645 +
9646 +extern void paging_init(void);
9647 +#define swapper_pg_dir ((pgd_t *) 0)
9648 +
9649 +#define __swp_type(x) (0)
9650 +#define __swp_offset(x) (0)
9651 +#define __swp_entry(typ,off) ((swp_entry_t) { ((typ) | ((off) << 7)) })
9652 +#define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) })
9653 +#define __swp_entry_to_pte(x) ((pte_t) { (x).val })
9654 +
9655 +/*
9656 + * pgprot_noncached() is only for infiniband pci support, and a real
9657 + * implementation for RAM would be more complicated.
9658 + */
9659 +#define pgprot_noncached(prot) (prot)
9660 +
9661 +static inline int pte_file(pte_t pte) { return 0; }
9662 +
9663 +/*
9664 + * ZERO_PAGE is a global shared page that is always zero: used
9665 + * for zero-mapped memory areas etc..
9666 + */
9667 +#define ZERO_PAGE(vaddr) (virt_to_page(0))
9668 +
9669 +extern unsigned int kobjsize(const void *objp);
9670 +extern int is_in_rom(unsigned long);
9671 +
9672 +/*
9673 + * No page table caches to initialise
9674 + */
9675 +#define pgtable_cache_init() do { } while (0)
9676 +
9677 +#define io_remap_pfn_range(vma, vaddr, pfn, size, prot) \
9678 + remap_pfn_range(vma, vaddr, pfn, size, prot)
9679 +
9680 +extern inline void flush_cache_mm(struct mm_struct *mm)
9681 +{
9682 +}
9683 +
9684 +extern inline void flush_cache_range(struct mm_struct *mm,
9685 + unsigned long start,
9686 + unsigned long end)
9687 +{
9688 +}
9689 +
9690 +/* Push the page at kernel virtual address and clear the icache */
9691 +extern inline void flush_page_to_ram (unsigned long address)
9692 +{
9693 +}
9694 +
9695 +/* Push n pages at kernel virtual address and clear the icache */
9696 +extern inline void flush_pages_to_ram (unsigned long address, int n)
9697 +{
9698 +}
9699 +
9700 +/*
9701 + * All 32bit addresses are effectively valid for vmalloc...
9702 + * Sort of meaningless for non-VM targets.
9703 + */
9704 +#define VMALLOC_START 0
9705 +#define VMALLOC_END 0xffffffff
9706 +
9707 +#define arch_enter_lazy_mmu_mode() do {} while (0)
9708 +#define arch_leave_lazy_mmu_mode() do {} while (0)
9709 +#define arch_flush_lazy_mmu_mode() do {} while (0)
9710 +#define arch_enter_lazy_cpu_mode() do {} while (0)
9711 +#define arch_leave_lazy_cpu_mode() do {} while (0)
9712 +#define arch_flush_lazy_cpu_mode() do {} while (0)
9713 +
9714 +#endif /* _ASM_UBICOM32_PGTABLE_H */
9715 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/plio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/plio.h
9716 --- linux-2.6.30.10/arch/ubicom32/include/asm/plio.h 1970-01-01 02:00:00.000000000 +0200
9717 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/plio.h 2009-12-11 11:45:11.000000000 +0200
9718 @@ -0,0 +1,313 @@
9719 +/*
9720 + * plio.h
9721 + * PLIO defines.
9722 + *
9723 + * Copyright © 2009 Ubicom Inc. <www.ubicom.com>. All Rights Reserved.
9724 + *
9725 + * This file is part of the Ubicom32 Linux Kernel Port.
9726 + *
9727 + * The Ubicom32 Linux Kernel Port is free software: you can
9728 + * redistribute it and/or modify it under the terms of the GNU General
9729 + * Public License as published by the Free Software Foundation, either
9730 + * version 2 of the License, or (at your option) any later version.
9731 + *
9732 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
9733 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
9734 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
9735 + * See the GNU General Public License for more details.
9736 + *
9737 + * You should have received a copy of the GNU General Public License
9738 + * along with the Ubicom32 Linux Kernel Port. If not,
9739 + * see <http://www.gnu.org/licenses/>.
9740 + * This file contains confidential information of Ubicom, Inc. and your use of
9741 + * this file is subject to the Ubicom Software License Agreement distributed with
9742 + * this file. If you are uncertain whether you are an authorized user or to report
9743 + * any unauthorized use, please contact Ubicom, Inc. at +1-408-789-2200.
9744 + * Unauthorized reproduction or distribution of this file is subject to civil and
9745 + * criminal penalties.
9746 + */
9747 +
9748 +#ifndef __PLIO__H__
9749 +#define __PLIO__H__
9750 +
9751 +#include <asm/ip5000.h>
9752 +#include <asm/thread.h>
9753 +
9754 +#define PLIO_PORT RD
9755 +#define PLIO_EXT_PORT RI
9756 +
9757 +#define TRANSMIT_FIFO_WATERMARK 8
9758 +
9759 +/*
9760 + * PLIO non-blocking register definitions
9761 + */
9762 +#define PLIO_FN 2
9763 +
9764 +typedef struct {
9765 + unsigned : 10;
9766 + unsigned rxfifo_thread_enable: 1; /* allowed rxfifo thread enable */
9767 + unsigned : 1;
9768 + unsigned rxfifo_thread: 4; /* allowed rxfifo thread access */
9769 + unsigned : 4;
9770 + unsigned br_thread: 4; /* allowed blocking region thread access */
9771 + unsigned fn_reset: 4; /* function reset bit vector */
9772 + unsigned rxfifo_sel: 1; /* select between RXFIFO 0 and 1 */
9773 + unsigned fn_sel: 3; /* select port function */
9774 +} plio_io_function_t;
9775 +
9776 +typedef struct {
9777 + unsigned : 24;
9778 + unsigned pin:8;
9779 +} plio_gpio_t;
9780 +
9781 +typedef struct {
9782 + unsigned : 16;
9783 + unsigned txfifo_uf: 1; /* TXFIFO underflow */
9784 + unsigned txfifo_wm: 1; /* TXFIFO watermark */
9785 + unsigned rxfifo_of: 1; /* RXFIFO overflow */
9786 + unsigned rxfifo_wm: 1; /* RXFIFO watermark */
9787 + unsigned : 5;
9788 + unsigned lreg_int_addr_rd: 1; /* read from specified LREG address */
9789 + unsigned lreg_int_addr_wr: 1; /* write to specified LREG address */
9790 + unsigned extctl_int: 4; /* synchronized external interrupts */
9791 + unsigned pfsm_int: 1; /* state machine */
9792 +} plio_intstat_t;
9793 +
9794 +typedef struct {
9795 + unsigned txfifo_reset: 1; /* TXFIFO reset for int_set only */
9796 + unsigned rxfifo_reset: 1; /* RXFIFO reset for int_set only */
9797 + unsigned : 11;
9798 + unsigned idif_txfifo_flush: 1; /* flush TXFIFO and idif_txfifo */
9799 + unsigned idif_rxfifo_flush: 1; /* flush RXFIFO and idif_rxfifo */
9800 + unsigned pfsm_start: 1; /* input to fsm */
9801 + unsigned txfifo_uf: 1; /* TXFIFO underflow */
9802 + unsigned txfifo_wm: 1; /* TXFIFO watermark */
9803 + unsigned rxfifo_of: 1; /* RXFIFO overflow */
9804 + unsigned rxfifo_wm: 1; /* RXFIFO watermark */
9805 + unsigned : 5;
9806 + unsigned lreg_int_addr_rd: 1; /* read from specified LREG address */
9807 + unsigned lreg_int_addr_wr: 1; /* write to specified LREG address */
9808 + unsigned extctl_int: 4; /* synchronized external interrupts */
9809 + unsigned pfsm_int: 1; /* state machine */
9810 +} plio_intset_t;
9811 +
9812 +typedef enum {
9813 + PLIO_PORT_MODE_D,
9814 + PLIO_PORT_MODE_DE,
9815 + PLIO_PORT_MODE_DI,
9816 + PLIO_PORT_MODE_DEI,
9817 + PLIO_PORT_MODE_DC,
9818 +} plio_port_mode_t;
9819 +
9820 +typedef enum {
9821 + PLIO_CLK_CORE, /* CORE CLK */
9822 + PLIO_CLK_IO, /* IO CLK */
9823 + PLIO_CLK_EXT, /* EXT CLK */
9824 +} plio_clk_src_t;
9825 +typedef struct {
9826 + unsigned : 4;
9827 + unsigned edif_iaena_sel: 1; /* Input Address Enable Select */
9828 + unsigned edif_iaclk_sel: 1; /* Input Address Clock Select */
9829 + unsigned edif_iald_inv: 1; /* Input Address Strobe Invert */
9830 + unsigned edif_idclk_sel: 1; /* Input Data Clock Select */
9831 + unsigned edif_idld_inv: 1; /* Input Data Strobe Invert */
9832 + unsigned edif_ds: 3; /* specify IDR and ODR data shift */
9833 + unsigned edif_cmp_mode: 1; /* configure IDR comparator output */
9834 + unsigned edif_idena_sel: 1; /* Input Data Enable Select */
9835 + unsigned ecif_extclk_ena: 1; /* plio_extctl output select */
9836 + unsigned idif_tx_fifo_cmd_sel: 1; /* select pfsm_cmd data word position */
9837 + unsigned ptif_porti_cfg: 2; /* select port I pin configuration */
9838 + unsigned ptif_portd_cfg: 3; /* select port D pin configuration */
9839 + plio_port_mode_t ptif_port_mode: 3; /* select other plio ports */
9840 + unsigned icif_clk_plio_ext_inv: 1; /* invert external plio clock when set */
9841 + unsigned icif_rst_plio: 1; /* reset plio function and io fifos */
9842 + plio_clk_src_t icif_clk_src_sel: 2; /* select plio clock source */
9843 + unsigned pfsm_prog: 1; /* enable pfsm programming */
9844 + unsigned pfsm_cmd: 3; /* software input to pfsm */
9845 +} plio_fctl0_t;
9846 +
9847 +typedef struct {
9848 + unsigned : 2;
9849 + unsigned idif_byteswap_tx: 3; /* swap TXFIFO byte order */
9850 + unsigned idif_byteswap_rx: 3; /* swap RXFIFO byte order */
9851 + unsigned : 1;
9852 + unsigned lreg_ena: 1; /* enable local register map */
9853 + unsigned lreg_addr_fifo_cmp_ena: 1; /* enable a specific LREG address from/to TX/RX fifos */
9854 + unsigned lreg_addr_fifo_cmp: 5; /* LREG address routed from/to TX/RX fifos */
9855 + unsigned : 1;
9856 + unsigned dcod_iald_idld_sel: 2; /* select address/data strobes */
9857 + unsigned dcod_rw_src_sel: 1; /* select LREG strobe source */
9858 + unsigned dcod_rd_sel: 5; /* select read strobe source */
9859 + unsigned dcod_wr_sel: 5; /* select write strobe source */
9860 + unsigned dcod_rd_lvl: 1; /* select active level of read strobe */
9861 + unsigned dcod_wr_lvl: 1; /* select active level of read strobe */
9862 +} plio_fctl1_t;
9863 +
9864 +typedef struct {
9865 + unsigned icif_eclk_div: 16; /* external plio clock divider */
9866 + unsigned icif_iclk_div: 16; /* internal plio clock divider */
9867 +} plio_fctl2_t;
9868 +
9869 +typedef struct {
9870 + unsigned : 27;
9871 + unsigned pfsm_state: 5; /* current pfsm state */
9872 +} plio_stat_0_t;
9873 +
9874 +typedef struct {
9875 + unsigned : 3;
9876 + unsigned lreg_r_int_addr: 5;
9877 + unsigned : 11;
9878 + unsigned lreg_w_int_addr: 5;
9879 + unsigned lreg_w_int_data: 8;
9880 +} plio_stat_1_t;
9881 +
9882 +typedef struct {
9883 + unsigned : 32;
9884 +} plio_stat_2_t;
9885 +
9886 +typedef struct {
9887 + unsigned tx: 16;
9888 + unsigned rx: 16;
9889 +} plio_io_fifo_wm_t, plio_io_fifo_lvl_t;
9890 +
9891 +
9892 +/* plio blocking region register definitions
9893 + */
9894 +typedef struct {
9895 + unsigned ns1: 5;
9896 + unsigned ic1: 7;
9897 + unsigned ec1: 4;
9898 + unsigned ns0: 5;
9899 + unsigned ic0: 7;
9900 + unsigned ec0: 4;
9901 +} plio_sram_t;
9902 +
9903 +typedef struct {
9904 + unsigned : 2;
9905 + unsigned s9: 3;
9906 + unsigned s8: 3;
9907 + unsigned s7: 3;
9908 + unsigned s6: 3;
9909 + unsigned s5: 3;
9910 + unsigned s4: 3;
9911 + unsigned s3: 3;
9912 + unsigned s2: 3;
9913 + unsigned s1: 3;
9914 + unsigned s0: 3;
9915 +} plio_grpsel_t;
9916 +
9917 +typedef struct {
9918 + unsigned s7: 4;
9919 + unsigned s6: 4;
9920 + unsigned s5: 4;
9921 + unsigned s4: 4;
9922 + unsigned s3: 4;
9923 + unsigned s2: 4;
9924 + unsigned s1: 4;
9925 + unsigned s0: 4;
9926 +} plio_cs_lut_t;
9927 +
9928 +typedef struct {
9929 + unsigned lut3: 8;
9930 + unsigned lut2: 8;
9931 + unsigned lut1: 8;
9932 + unsigned lut0: 8;
9933 +} plio_extctl_t;
9934 +
9935 +typedef struct {
9936 + plio_grpsel_t grpsel[4];
9937 + u16_t cv[16];
9938 + plio_cs_lut_t cs_lut[4];
9939 + plio_extctl_t extctl_o_lut[8];
9940 +} plio_pfsm_t;
9941 +
9942 +typedef struct {
9943 + u32_t odr_oe_sel;
9944 + u32_t odr_oe;
9945 + u32_t cmp;
9946 + u32_t ncmp;
9947 + u32_t cmp_mask;
9948 +} plio_edif_t;
9949 +
9950 +typedef enum {
9951 + PLIO_ECIF_CLK_OUT = 9,
9952 + PLIO_ECIF_IALD = 9,
9953 + PLIO_ECIF_CLK_IN = 8,
9954 + PLIO_ECIF_IDLD = 8,
9955 + PLIO_ECIF_INT = 2,
9956 +} plio_ecif_output_t;
9957 +
9958 +typedef struct {
9959 + u32_t bypass_sync;
9960 + u32_t ift;
9961 + u32_t output_type;
9962 + u32_t output_ena;
9963 + u32_t output_lvl;
9964 +} plio_ecif_t;
9965 +
9966 +typedef struct {
9967 + u32_t idr_addr_pos_mask;
9968 + u32_t reserved;
9969 + u32_t lreg_bar;
9970 +} plio_dcod_t;
9971 +
9972 +typedef struct {
9973 + u32_t addr_rd_ena;
9974 + u32_t addr_wr_ena;
9975 + u32_t addr_rd_int_ena;
9976 + u32_t addr_wr_int_ena;
9977 +} plio_lcfg_t;
9978 +
9979 +
9980 +/*
9981 + * PLIO configuration
9982 + */
9983 +typedef struct {
9984 + plio_fctl0_t fctl0;
9985 + plio_fctl1_t fctl1;
9986 + plio_fctl2_t fctl2;
9987 +} plio_fctl_t;
9988 +
9989 +typedef struct {
9990 + plio_pfsm_t pfsm;
9991 + plio_edif_t edif;
9992 + plio_ecif_t ecif;
9993 + plio_dcod_t dcod;
9994 + plio_lcfg_t lcfg;
9995 +} plio_config_t;
9996 +
9997 +typedef struct {
9998 + plio_io_function_t function;
9999 + plio_gpio_t gpio_ctl;
10000 + plio_gpio_t gpio_out;
10001 + plio_gpio_t gpio_in;
10002 + plio_intstat_t intstat;
10003 + plio_intstat_t intmask;
10004 + plio_intset_t intset;
10005 + plio_intstat_t intclr;
10006 + unsigned tx_lo;
10007 + unsigned tx_hi;
10008 + unsigned rx_lo;
10009 + unsigned rx_hi;
10010 + plio_fctl0_t fctl0;
10011 + plio_fctl1_t fctl1;
10012 + plio_fctl2_t fctl2;
10013 + plio_stat_0_t stat0;
10014 + plio_stat_1_t stat1;
10015 + plio_stat_2_t stat2;
10016 + plio_io_fifo_wm_t fifo_wm;
10017 + plio_io_fifo_lvl_t fifo_lvl;
10018 +} plio_nbr_t;
10019 +
10020 +typedef struct {
10021 + u32_t pfsm_sram[256];
10022 + plio_config_t config;
10023 +} plio_br_t;
10024 +
10025 +#define PLIO_NBR ((plio_nbr_t *)(PLIO_PORT))
10026 +#define PLIO_BR ((plio_br_t *)((PLIO_PORT + IO_PORT_BR_OFFSET)))
10027 +#define PEXT_NBR ((plio_nbr_t *)(PLIO_EXT_PORT))
10028 +
10029 +extern void plio_init(const plio_fctl_t *plio_fctl, const plio_config_t *plio_config, const plio_sram_t plio_sram_cfg[], int sram_cfg_size);
10030 +
10031 +#endif // __PLIO__H__
10032 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/poll.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/poll.h
10033 --- linux-2.6.30.10/arch/ubicom32/include/asm/poll.h 1970-01-01 02:00:00.000000000 +0200
10034 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/poll.h 2009-12-11 11:45:11.000000000 +0200
10035 @@ -0,0 +1,36 @@
10036 +/*
10037 + * arch/ubicom32/include/asm/poll.h
10038 + * Ubicom32 specific poll() related flags definitions.
10039 + *
10040 + * (C) Copyright 2009, Ubicom, Inc.
10041 + *
10042 + * This file is part of the Ubicom32 Linux Kernel Port.
10043 + *
10044 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10045 + * it and/or modify it under the terms of the GNU General Public License
10046 + * as published by the Free Software Foundation, either version 2 of the
10047 + * License, or (at your option) any later version.
10048 + *
10049 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10050 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10051 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10052 + * the GNU General Public License for more details.
10053 + *
10054 + * You should have received a copy of the GNU General Public License
10055 + * along with the Ubicom32 Linux Kernel Port. If not,
10056 + * see <http://www.gnu.org/licenses/>.
10057 + *
10058 + * Ubicom32 implementation derived from (with many thanks):
10059 + * arch/m68knommu
10060 + * arch/blackfin
10061 + * arch/parisc
10062 + */
10063 +#ifndef _ASM_UBICOM32_POLL_H
10064 +#define _ASM_UBICOM32_POLL_H
10065 +
10066 +#define POLLWRNORM POLLOUT
10067 +#define POLLWRBAND 0x0100
10068 +
10069 +#include <asm-generic/poll.h>
10070 +
10071 +#endif /* _ASM_UBICOM32_POLL_H */
10072 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/posix_types.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/posix_types.h
10073 --- linux-2.6.30.10/arch/ubicom32/include/asm/posix_types.h 1970-01-01 02:00:00.000000000 +0200
10074 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/posix_types.h 2009-12-11 11:45:11.000000000 +0200
10075 @@ -0,0 +1,93 @@
10076 +/*
10077 + * arch/ubicom32/include/asm/posix_types.h
10078 + * Ubicom32 architecture posix types.
10079 + *
10080 + * (C) Copyright 2009, Ubicom, Inc.
10081 + * Copyright (C) 2004 Microtronix Datacom Ltd
10082 + *
10083 + * This file is part of the Ubicom32 Linux Kernel Port.
10084 + *
10085 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10086 + * it and/or modify it under the terms of the GNU General Public License
10087 + * as published by the Free Software Foundation, either version 2 of the
10088 + * License, or (at your option) any later version.
10089 + *
10090 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10091 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10092 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10093 + * the GNU General Public License for more details.
10094 + *
10095 + * You should have received a copy of the GNU General Public License
10096 + * along with the Ubicom32 Linux Kernel Port. If not,
10097 + * see <http://www.gnu.org/licenses/>.
10098 + *
10099 + * Ubicom32 implementation derived from (with many thanks):
10100 + * arch/m68knommu
10101 + * arch/blackfin
10102 + * arch/parisc
10103 + */
10104 +#ifndef __ARCH_UBICOM32_POSIX_TYPES_H
10105 +#define __ARCH_UBICOM32_POSIX_TYPES_H
10106 +
10107 +/*
10108 + * This file is generally used by user-level software, so you need to
10109 + * be a little careful about namespace pollution etc. Also, we cannot
10110 + * assume GCC is being used.
10111 + */
10112 +
10113 +typedef unsigned long __kernel_ino_t;
10114 +typedef unsigned short __kernel_mode_t;
10115 +typedef unsigned short __kernel_nlink_t;
10116 +typedef long __kernel_off_t;
10117 +typedef int __kernel_pid_t;
10118 +typedef unsigned short __kernel_ipc_pid_t;
10119 +typedef unsigned short __kernel_uid_t;
10120 +typedef unsigned short __kernel_gid_t;
10121 +typedef unsigned int __kernel_size_t;
10122 +typedef int __kernel_ssize_t;
10123 +typedef int __kernel_ptrdiff_t;
10124 +typedef long __kernel_time_t;
10125 +typedef long __kernel_suseconds_t;
10126 +typedef long __kernel_clock_t;
10127 +typedef int __kernel_timer_t;
10128 +typedef int __kernel_clockid_t;
10129 +typedef int __kernel_daddr_t;
10130 +typedef char * __kernel_caddr_t;
10131 +typedef unsigned short __kernel_uid16_t;
10132 +typedef unsigned short __kernel_gid16_t;
10133 +typedef unsigned int __kernel_uid32_t;
10134 +typedef unsigned int __kernel_gid32_t;
10135 +
10136 +typedef unsigned short __kernel_old_uid_t;
10137 +typedef unsigned short __kernel_old_gid_t;
10138 +typedef unsigned short __kernel_old_dev_t;
10139 +
10140 +#ifdef __GNUC__
10141 +typedef long long __kernel_loff_t;
10142 +#endif
10143 +
10144 +typedef struct {
10145 +#if defined(__KERNEL__) || defined(__USE_ALL)
10146 + int val[2];
10147 +#else /* !defined(__KERNEL__) && !defined(__USE_ALL) */
10148 + int __val[2];
10149 +#endif /* !defined(__KERNEL__) && !defined(__USE_ALL) */
10150 +} __kernel_fsid_t;
10151 +
10152 +#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2)
10153 +
10154 +#undef __FD_SET
10155 +#define __FD_SET(d, set) ((set)->fds_bits[__FDELT(d)] |= __FDMASK(d))
10156 +
10157 +#undef __FD_CLR
10158 +#define __FD_CLR(d, set) ((set)->fds_bits[__FDELT(d)] &= ~__FDMASK(d))
10159 +
10160 +#undef __FD_ISSET
10161 +#define __FD_ISSET(d, set) ((set)->fds_bits[__FDELT(d)] & __FDMASK(d))
10162 +
10163 +#undef __FD_ZERO
10164 +#define __FD_ZERO(fdsetp) (memset (fdsetp, 0, sizeof(*(fd_set *)fdsetp)))
10165 +
10166 +#endif /* defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) */
10167 +
10168 +#endif
10169 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/processor.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/processor.h
10170 --- linux-2.6.30.10/arch/ubicom32/include/asm/processor.h 1970-01-01 02:00:00.000000000 +0200
10171 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/processor.h 2009-12-11 11:45:11.000000000 +0200
10172 @@ -0,0 +1,163 @@
10173 +/*
10174 + * arch/ubicom32/include/asm/processor.h
10175 + * Thread related definitions for Ubicom32 architecture.
10176 + *
10177 + * (C) Copyright 2009, Ubicom, Inc.
10178 + * Copyright (C) 1995 Hamish Macdonald
10179 + *
10180 + * This file is part of the Ubicom32 Linux Kernel Port.
10181 + *
10182 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10183 + * it and/or modify it under the terms of the GNU General Public License
10184 + * as published by the Free Software Foundation, either version 2 of the
10185 + * License, or (at your option) any later version.
10186 + *
10187 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10188 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10189 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10190 + * the GNU General Public License for more details.
10191 + *
10192 + * You should have received a copy of the GNU General Public License
10193 + * along with the Ubicom32 Linux Kernel Port. If not,
10194 + * see <http://www.gnu.org/licenses/>.
10195 + *
10196 + * Ubicom32 implementation derived from (with many thanks):
10197 + * arch/m68knommu
10198 + * arch/blackfin
10199 + * arch/parisc
10200 + */
10201 +
10202 +#ifndef _ASM_UBICOM32_PROCESSOR_H
10203 +#define _ASM_UBICOM32_PROCESSOR_H
10204 +
10205 +/*
10206 + * Default implementation of macro that returns current
10207 + * instruction pointer ("program counter").
10208 + */
10209 +#define current_text_addr() ({ __label__ _l; _l: &&_l;})
10210 +
10211 +#include <linux/compiler.h>
10212 +#include <linux/threads.h>
10213 +#include <asm/types.h>
10214 +#include <asm/segment.h>
10215 +#include <asm/fpu.h>
10216 +#include <asm/ptrace.h>
10217 +#include <asm/current.h>
10218 +#include <asm/thread_info.h>
10219 +
10220 +#if defined(CONFIG_UBICOM32_V3)
10221 + #define CPU "IP5K"
10222 +#endif
10223 +#if defined(CONFIG_UBICOM32_V4)
10224 + #define CPU "IP7K"
10225 +#endif
10226 +#ifndef CPU
10227 + #define CPU "UNKNOWN"
10228 +#endif
10229 +
10230 +/*
10231 + * User space process size: 1st byte beyond user address space.
10232 + */
10233 +extern unsigned long memory_end;
10234 +#define TASK_SIZE (memory_end)
10235 +
10236 +/*
10237 + * This decides where the kernel will search for a free chunk of vm
10238 + * space during mmap's. We won't be using it
10239 + */
10240 +#define TASK_UNMAPPED_BASE 0
10241 +
10242 +/*
10243 + * This is the structure where we are going to save callee-saved registers.
10244 + * A5 is the return address, A7 is the stack pointer, A6 is the frame
10245 + * pointer. This is the frame that is created because of switch_to. This
10246 + * is not the frame due to interrupt preemption or because of syscall entry.
10247 + */
10248 +
10249 +struct thread_struct {
10250 + unsigned long d10; /* D10 */
10251 + unsigned long d11; /* D11 */
10252 + unsigned long d12; /* D12 */
10253 + unsigned long d13; /* D13 */
10254 + unsigned long a1; /* A1 */
10255 + unsigned long a2; /* A2 */
10256 + unsigned long a5; /* A5 return address. */
10257 + unsigned long a6; /* A6 */
10258 + unsigned long sp; /* A7 kernel stack pointer. */
10259 +};
10260 +
10261 +#define INIT_THREAD { \
10262 + 0, 0, 0, 0, 0, 0, 0, 0, \
10263 + sizeof(init_stack) + (unsigned long) init_stack - 8, \
10264 +}
10265 +
10266 +/*
10267 + * Do necessary setup to start up a newly executed thread.
10268 + *
10269 + * pass the data segment into user programs if it exists,
10270 + * it can't hurt anything as far as I can tell
10271 + */
10272 +/*
10273 + * Do necessary setup to start up a newly executed thread.
10274 + */
10275 +#define start_thread(regs, new_pc, new_sp) \
10276 + do { \
10277 + regs->pc = new_pc & ~3; \
10278 + regs->an[5] = new_pc & ~3; \
10279 + regs->an[7] = new_sp; \
10280 + regs->nesting_level = -1; \
10281 + regs->frame_type = UBICOM32_FRAME_TYPE_NEW_THREAD; \
10282 + regs->thread_type = NORMAL_THREAD; \
10283 + } while(0)
10284 +
10285 +/* Forward declaration, a strange C thing */
10286 +struct task_struct;
10287 +
10288 +/* Free all resources held by a thread. */
10289 +static inline void release_thread(struct task_struct *dead_task)
10290 +{
10291 +}
10292 +
10293 +/* Prepare to copy thread state - unlazy all lazy status */
10294 +#define prepare_to_copy(tsk) do { } while (0)
10295 +
10296 +extern int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
10297 +
10298 +/*
10299 + * Free current thread data structures etc..
10300 + */
10301 +static inline void exit_thread(void)
10302 +{
10303 +}
10304 +
10305 +unsigned long thread_saved_pc(struct task_struct *tsk);
10306 +unsigned long get_wchan(struct task_struct *p);
10307 +
10308 +#define KSTK_EIP(tsk) (tsk->thread.a5)
10309 +#define KSTK_ESP(tsk) (tsk->thread.sp)
10310 +
10311 +#define cpu_relax() barrier()
10312 +
10313 +extern void processor_init(void);
10314 +extern unsigned int processor_timers(void);
10315 +extern unsigned int processor_threads(void);
10316 +extern unsigned int processor_frequency(void);
10317 +extern int processor_interrupts(unsigned int *int0, unsigned int *int1);
10318 +extern void processor_ocm(unsigned long *socm, unsigned long *eocm);
10319 +extern void processor_dram(unsigned long *sdram, unsigned long *edram);
10320 +
10321 +#define THREAD_SIZE_LONGS (THREAD_SIZE/sizeof(unsigned long))
10322 +#define KSTK_TOP(info) \
10323 +({ \
10324 + unsigned long *__ptr = (unsigned long *)(info); \
10325 + (unsigned long)(&__ptr[THREAD_SIZE_LONGS]); \
10326 +})
10327 +
10328 +#define task_pt_regs(task) \
10329 +({ \
10330 + struct pt_regs *__regs__; \
10331 + __regs__ = (struct pt_regs *)(KSTK_TOP(task_stack_page(task))-8); \
10332 + __regs__ - 1; \
10333 +})
10334 +
10335 +#endif /* _ASM_UBICOM32_PROCESSOR_H */
10336 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/profilesample.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/profilesample.h
10337 --- linux-2.6.30.10/arch/ubicom32/include/asm/profilesample.h 1970-01-01 02:00:00.000000000 +0200
10338 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/profilesample.h 2009-12-11 11:45:11.000000000 +0200
10339 @@ -0,0 +1,44 @@
10340 +/*
10341 + * arch/ubicom32/mach-common/profile.h
10342 + * Private data for the profile module
10343 + *
10344 + * (C) Copyright 2009, Ubicom, Inc.
10345 + *
10346 + * This file is part of the Ubicom32 Linux Kernel Port.
10347 + *
10348 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10349 + * it and/or modify it under the terms of the GNU General Public License
10350 + * as published by the Free Software Foundation, either version 2 of the
10351 + * License, or (at your option) any later version.
10352 + *
10353 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10354 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10355 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10356 + * the GNU General Public License for more details.
10357 + *
10358 + * You should have received a copy of the GNU General Public License
10359 + * along with the Ubicom32 Linux Kernel Port. If not,
10360 + * see <http://www.gnu.org/licenses/>.
10361 + *
10362 + */
10363 +
10364 +
10365 +#ifndef _PROFILESAMPLE_H_
10366 +#define _PROFILESAMPLE_H_
10367 +
10368 +/*
10369 + * a sample taken by the ipProfile package for sending to the profilertool
10370 + */
10371 +struct profile_sample {
10372 + unsigned int pc; /* PC value */
10373 + unsigned int a5; /* a5 contents for parent of leaf function */
10374 + unsigned int parent; /* return address from stack, to find the caller */
10375 + unsigned int latency; /* CPU clocks since the last message dispatch in this thread (thread 0 ony for now) */
10376 + unsigned short active; /* which threads are active - for accurate counting */
10377 + unsigned short d_blocked; /* which threads are blocked due to D cache misses */
10378 + unsigned short i_blocked; /* which threads are blocked due to I cache misses */
10379 + unsigned char cond_codes; /* for branch prediction */
10380 + unsigned char thread; /* I-blocked, D-blocked, 4-bit thread number */
10381 +};
10382 +
10383 +#endif
10384 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ptrace.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ptrace.h
10385 --- linux-2.6.30.10/arch/ubicom32/include/asm/ptrace.h 1970-01-01 02:00:00.000000000 +0200
10386 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ptrace.h 2009-12-11 11:45:11.000000000 +0200
10387 @@ -0,0 +1,177 @@
10388 +/*
10389 + * arch/ubicom32/include/asm/ptrace.h
10390 + * Ubicom32 architecture ptrace support.
10391 + *
10392 + * (C) Copyright 2009, Ubicom, Inc.
10393 + *
10394 + * This file is part of the Ubicom32 Linux Kernel Port.
10395 + *
10396 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10397 + * it and/or modify it under the terms of the GNU General Public License
10398 + * as published by the Free Software Foundation, either version 2 of the
10399 + * License, or (at your option) any later version.
10400 + *
10401 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10402 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10403 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10404 + * the GNU General Public License for more details.
10405 + *
10406 + * You should have received a copy of the GNU General Public License
10407 + * along with the Ubicom32 Linux Kernel Port. If not,
10408 + * see <http://www.gnu.org/licenses/>.
10409 + *
10410 + * Ubicom32 implementation derived from (with many thanks):
10411 + * arch/m68knommu
10412 + * arch/blackfin
10413 + * arch/parisc
10414 + */
10415 +#ifndef _ASM_UBICOM32_PTRACE_H
10416 +#define _ASM_UBICOM32_PTRACE_H
10417 +
10418 +#ifndef __ASSEMBLY__
10419 +
10420 +/*
10421 + * We use hard coded constants because this is shared with user
10422 + * space and the values are NOT allowed to change. Only fields
10423 + * that are intended to be exposed get values.
10424 + */
10425 +#define PT_D0 0
10426 +#define PT_D1 4
10427 +#define PT_D2 8
10428 +#define PT_D3 12
10429 +#define PT_D4 16
10430 +#define PT_D5 20
10431 +#define PT_D6 24
10432 +#define PT_D7 28
10433 +#define PT_D8 32
10434 +#define PT_D9 36
10435 +#define PT_D10 40
10436 +#define PT_D11 44
10437 +#define PT_D12 48
10438 +#define PT_D13 52
10439 +#define PT_D14 56
10440 +#define PT_D15 60
10441 +#define PT_A0 64
10442 +#define PT_A1 68
10443 +#define PT_A2 72
10444 +#define PT_A3 76
10445 +#define PT_A4 80
10446 +#define PT_A5 84
10447 +#define PT_A6 88
10448 +#define PT_A7 92
10449 +#define PT_SP 92
10450 +#define PT_ACC0HI 96
10451 +#define PT_ACC0LO 100
10452 +#define PT_MAC_RC16 104
10453 +#define PT_ACC1HI 108
10454 +#define PT_ACC1LO 112
10455 +#define PT_SOURCE3 116
10456 +#define PT_INST_CNT 120
10457 +#define PT_CSR 124
10458 +#define PT_DUMMY_UNUSED 128
10459 +#define PT_INT_MASK0 132
10460 +#define PT_INT_MASK1 136
10461 +#define PT_TRAP_CAUSE 140
10462 +#define PT_PC 144
10463 +#define PT_ORIGINAL_D0 148
10464 +#define PT_FRAME_TYPE 152
10465 +
10466 +/*
10467 + * The following 'registers' are not registers at all but are used
10468 + * locate the relocated sections.
10469 + */
10470 +#define PT_TEXT_ADDR 200
10471 +#define PT_TEXT_END_ADDR 204
10472 +#define PT_DATA_ADDR 208
10473 +#define PT_EXEC_FDPIC_LOADMAP 212
10474 +#define PT_INTERP_FDPIC_LOADMAP 216
10475 +
10476 +/*
10477 + * This struct defines the way the registers are stored on the
10478 + * stack during a system call.
10479 + */
10480 +enum thread_type {
10481 + NORMAL_THREAD,
10482 + KERNEL_THREAD,
10483 +};
10484 +
10485 +#define UBICOM32_FRAME_TYPE_SYSCALL -1 /* System call frame */
10486 +#define UBICOM32_FRAME_TYPE_INVALID 0 /* Invalid frame, no longer in use */
10487 +#define UBICOM32_FRAME_TYPE_INTERRUPT 1 /* Interrupt frame */
10488 +#define UBICOM32_FRAME_TYPE_TRAP 2 /* Trap frame */
10489 +#define UBICOM32_FRAME_TYPE_SIGTRAMP 3 /* Signal trampoline frame. */
10490 +#define UBICOM32_FRAME_TYPE_NEW_THREAD 4 /* New Thread. */
10491 +
10492 +struct pt_regs {
10493 + /*
10494 + * Data Registers
10495 + */
10496 + unsigned long dn[16];
10497 +
10498 + /*
10499 + * Address Registers
10500 + */
10501 + unsigned long an[8];
10502 +
10503 + /*
10504 + * Per thread misc registers.
10505 + */
10506 + unsigned long acc0[2];
10507 + unsigned long mac_rc16;
10508 + unsigned long acc1[2];
10509 + unsigned long source3;
10510 + unsigned long inst_cnt;
10511 + unsigned long csr;
10512 + unsigned long dummy_unused;
10513 + unsigned long int_mask0;
10514 + unsigned long int_mask1;
10515 + unsigned long trap_cause;
10516 + unsigned long pc;
10517 + unsigned long original_dn_0;
10518 +
10519 + /*
10520 + * Frame type. Syscall frames are -1. For other types look above.
10521 + */
10522 + unsigned long frame_type;
10523 +
10524 + /*
10525 + * These fields are not exposed to ptrace.
10526 + */
10527 + unsigned long previous_pc;
10528 + long nesting_level; /* When the kernel in in user space this
10529 + * will be -1. */
10530 + unsigned long thread_type; /* This indicates if this is a kernel
10531 + * thread. */
10532 +};
10533 +
10534 +/*
10535 + * This is the extended stack used by signal handlers and the context
10536 + * switcher: it's pushed after the normal "struct pt_regs".
10537 + */
10538 +struct switch_stack {
10539 + unsigned long dummy;
10540 +};
10541 +
10542 +#ifdef __KERNEL__
10543 +
10544 +/* Arbitrarily choose the same ptrace numbers as used by the Sparc code. */
10545 +#define PTRACE_GETREGS 12
10546 +#define PTRACE_SETREGS 13
10547 +
10548 +#ifndef PS_S
10549 +#define PS_S (0x2000)
10550 +#define PS_M (0x1000)
10551 +#endif
10552 +
10553 +extern int __user_mode(unsigned long sp);
10554 +
10555 +#define user_mode(regs) (__user_mode((regs->an[7])))
10556 +#define user_stack(regs) ((regs)->an[7])
10557 +#define instruction_pointer(regs) ((regs)->pc)
10558 +#define profile_pc(regs) instruction_pointer(regs)
10559 +extern void show_regs(struct pt_regs *);
10560 +#endif /* __KERNEL__ */
10561 +
10562 +#endif /* __ASSEMBLY__ */
10563 +
10564 +#endif /* _ASM_UBICOM32_PTRACE_H */
10565 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/range-protect-asm.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/range-protect-asm.h
10566 --- linux-2.6.30.10/arch/ubicom32/include/asm/range-protect-asm.h 1970-01-01 02:00:00.000000000 +0200
10567 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/range-protect-asm.h 2009-12-11 11:45:11.000000000 +0200
10568 @@ -0,0 +1,91 @@
10569 +/*
10570 + * arch/ubicom32/include/asm/range-protect-asm.h
10571 + * Assembly macros for enabling memory protection.
10572 + *
10573 + * (C) Copyright 2009, Ubicom, Inc.
10574 + *
10575 + * This file is part of the Ubicom32 Linux Kernel Port.
10576 + *
10577 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10578 + * it and/or modify it under the terms of the GNU General Public License
10579 + * as published by the Free Software Foundation, either version 2 of the
10580 + * License, or (at your option) any later version.
10581 + *
10582 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10583 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10584 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10585 + * the GNU General Public License for more details.
10586 + *
10587 + * You should have received a copy of the GNU General Public License
10588 + * along with the Ubicom32 Linux Kernel Port. If not,
10589 + * see <http://www.gnu.org/licenses/>.
10590 + *
10591 + * Ubicom32 implementation derived from (with many thanks):
10592 + * arch/m68knommu
10593 + * arch/blackfin
10594 + * arch/parisc
10595 + */
10596 +
10597 +#ifndef _ASM_UBICOM32_RANGE_PROTECT_ASM_H
10598 +#define _ASM_UBICOM32_RANGE_PROTECT_ASM_H
10599 +
10600 +#if defined(__ASSEMBLY__)
10601 +
10602 +#include <asm/thread-asm.h>
10603 +
10604 +/*
10605 + * You should only use the enable/disable ranges when you have the atomic lock,
10606 + * if you do not there will be problems.
10607 + */
10608 +
10609 +/*
10610 + * enable_kernel_ranges
10611 + * Enable the kernel ranges (disabling protection) for thread,
10612 + * where thread == (1 << thread number)
10613 + */
10614 +.macro enable_kernel_ranges thread
10615 +#ifdef CONFIG_PROTECT_KERNEL
10616 + or.4 I_RANGE0_EN, I_RANGE0_EN, \thread /* Enable Range Register */
10617 + or.4 D_RANGE0_EN, D_RANGE0_EN, \thread
10618 + or.4 D_RANGE1_EN, D_RANGE1_EN, \thread
10619 +#endif
10620 +.endm
10621 +
10622 +/*
10623 + * enable_kernel_ranges_for_current
10624 + * Enable the kernel ranges (disabling protection) for this thread
10625 + */
10626 +.macro enable_kernel_ranges_for_current scratch_reg
10627 +#ifdef CONFIG_PROTECT_KERNEL
10628 + thread_get_self_mask \scratch_reg
10629 + enable_kernel_ranges \scratch_reg
10630 +#endif
10631 +.endm
10632 +
10633 +/*
10634 + * disable_kernel_ranges
10635 + * Disables the kernel ranges (enabling protection) for thread
10636 + * where thread == (1 << thread number)
10637 + */
10638 +.macro disable_kernel_ranges thread
10639 +#ifdef CONFIG_PROTECT_KERNEL
10640 + not.4 \thread, \thread
10641 + and.4 I_RANGE0_EN, I_RANGE0_EN, \thread /* Disable Range Register */
10642 + and.4 D_RANGE0_EN, D_RANGE0_EN, \thread
10643 + and.4 D_RANGE1_EN, D_RANGE1_EN, \thread
10644 +#endif
10645 +.endm
10646 +
10647 +/*
10648 + * disable_kernel_ranges_for_current
10649 + * Disable kernel ranges (enabling protection) for this thread
10650 + */
10651 +.macro disable_kernel_ranges_for_current scratch_reg
10652 +#ifdef CONFIG_PROTECT_KERNEL
10653 + thread_get_self_mask \scratch_reg
10654 + disable_kernel_ranges \scratch_reg
10655 +#endif
10656 +.endm
10657 +#endif
10658 +
10659 +#endif /* _ASM_UBICOM32_RANGE_PROTECT_ASM_H */
10660 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/range-protect.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/range-protect.h
10661 --- linux-2.6.30.10/arch/ubicom32/include/asm/range-protect.h 1970-01-01 02:00:00.000000000 +0200
10662 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/range-protect.h 2009-12-11 11:45:11.000000000 +0200
10663 @@ -0,0 +1,62 @@
10664 +/*
10665 + * arch/ubicom32/include/asm/range-protect.h
10666 + * Assembly macros declared in C for enabling memory protection.
10667 + *
10668 + * (C) Copyright 2009, Ubicom, Inc.
10669 + *
10670 + * This file is part of the Ubicom32 Linux Kernel Port.
10671 + *
10672 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10673 + * it and/or modify it under the terms of the GNU General Public License
10674 + * as published by the Free Software Foundation, either version 2 of the
10675 + * License, or (at your option) any later version.
10676 + *
10677 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10678 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10679 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10680 + * the GNU General Public License for more details.
10681 + *
10682 + * You should have received a copy of the GNU General Public License
10683 + * along with the Ubicom32 Linux Kernel Port. If not,
10684 + * see <http://www.gnu.org/licenses/>.
10685 + *
10686 + * Ubicom32 implementation derived from (with many thanks):
10687 + * arch/m68knommu
10688 + * arch/blackfin
10689 + * arch/parisc
10690 + */
10691 +
10692 +#ifndef _ASM_UBICOM32_RANGE_PROTECT_H
10693 +#define _ASM_UBICOM32_RANGE_PROTECT_H
10694 +
10695 +#if !defined(__ASSEMBLY__)
10696 +#include <asm/thread.h>
10697 +/*
10698 + * The following macros should be the identical to the ones in
10699 + * range-protect-asm.h
10700 + *
10701 + * You should only use the enable/disable ranges when you have the atomic lock,
10702 + * if you do not there will be problems.
10703 + */
10704 +
10705 +/*
10706 + * enable_kernel_ranges
10707 + * Enable the kernel ranges (disabling protection) for thread,
10708 + * where thread == (1 << thread number)
10709 + */
10710 +asm (
10711 + ".macro enable_kernel_ranges thread \n\t"
10712 +#ifdef CONFIG_PROTECT_KERNEL
10713 + " or.4 I_RANGE0_EN, I_RANGE0_EN, \\thread \n\t" /* Enable Range Register */
10714 + " or.4 D_RANGE0_EN, D_RANGE0_EN, \\thread \n\t"
10715 + " or.4 D_RANGE1_EN, D_RANGE1_EN, \\thread \n\t"
10716 +#endif
10717 + ".endm \n\t"
10718 +);
10719 +
10720 +#else /* __ASSEMBLY__ */
10721 +
10722 +#include <asm/range-protect-asm.h>
10723 +
10724 +#endif
10725 +#endif /* _ASM_UBICOM32_RANGE_PROTECT_H */
10726 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/resource.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/resource.h
10727 --- linux-2.6.30.10/arch/ubicom32/include/asm/resource.h 1970-01-01 02:00:00.000000000 +0200
10728 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/resource.h 2009-12-11 11:45:11.000000000 +0200
10729 @@ -0,0 +1,33 @@
10730 +/*
10731 + * arch/ubicom32/include/asm/resource.h
10732 + * Generic definitions for Ubicom32 architecture.
10733 + *
10734 + * (C) Copyright 2009, Ubicom, Inc.
10735 + *
10736 + * This file is part of the Ubicom32 Linux Kernel Port.
10737 + *
10738 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10739 + * it and/or modify it under the terms of the GNU General Public License
10740 + * as published by the Free Software Foundation, either version 2 of the
10741 + * License, or (at your option) any later version.
10742 + *
10743 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10744 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10745 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10746 + * the GNU General Public License for more details.
10747 + *
10748 + * You should have received a copy of the GNU General Public License
10749 + * along with the Ubicom32 Linux Kernel Port. If not,
10750 + * see <http://www.gnu.org/licenses/>.
10751 + *
10752 + * Ubicom32 implementation derived from (with many thanks):
10753 + * arch/m68knommu
10754 + * arch/blackfin
10755 + * arch/parisc
10756 + */
10757 +#ifndef _ASM_UBICOM32_RESOURCE_H
10758 +#define _ASM_UBICOM32_RESOURCE_H
10759 +
10760 +#include <asm-generic/resource.h>
10761 +
10762 +#endif /* _ASM_UBICOM32_RESOURCE_H */
10763 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ring_tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ring_tio.h
10764 --- linux-2.6.30.10/arch/ubicom32/include/asm/ring_tio.h 1970-01-01 02:00:00.000000000 +0200
10765 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ring_tio.h 2009-12-11 11:45:11.000000000 +0200
10766 @@ -0,0 +1,42 @@
10767 +/*
10768 + * arch/ubicom32/include/asm/ring_tio.h
10769 + * Ubicom32 architecture Ring TIO definitions.
10770 + *
10771 + * (C) Copyright 2009, Ubicom, Inc.
10772 + *
10773 + * This file is part of the Ubicom32 Linux Kernel Port.
10774 + *
10775 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10776 + * it and/or modify it under the terms of the GNU General Public License
10777 + * as published by the Free Software Foundation, either version 2 of the
10778 + * License, or (at your option) any later version.
10779 + *
10780 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10781 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10782 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10783 + * the GNU General Public License for more details.
10784 + *
10785 + * You should have received a copy of the GNU General Public License
10786 + * along with the Ubicom32 Linux Kernel Port. If not,
10787 + * see <http://www.gnu.org/licenses/>.
10788 + */
10789 +#ifndef _ASM_UBICOM32_RING_TIO_H
10790 +#define _ASM_UBICOM32_RING_TIO_H
10791 +
10792 +#include <asm/devtree.h>
10793 +
10794 +#define RING_TIO_NODE_VERSION 2
10795 +
10796 +/*
10797 + * Devtree node for ring
10798 + */
10799 +struct ring_tio_node {
10800 + struct devtree_node dn;
10801 +
10802 + u32_t version;
10803 + void *regs;
10804 +};
10805 +
10806 +extern void ring_tio_init(const char *node_name);
10807 +
10808 +#endif /* _ASM_UBICOM32_RING_TIO_H */
10809 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/scatterlist.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/scatterlist.h
10810 --- linux-2.6.30.10/arch/ubicom32/include/asm/scatterlist.h 1970-01-01 02:00:00.000000000 +0200
10811 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/scatterlist.h 2009-12-11 11:45:11.000000000 +0200
10812 @@ -0,0 +1,49 @@
10813 +/*
10814 + * arch/ubicom32/include/asm/scatterlist.h
10815 + * Definitions of struct scatterlist for Ubicom32 architecture.
10816 + *
10817 + * (C) Copyright 2009, Ubicom, Inc.
10818 + *
10819 + * This file is part of the Ubicom32 Linux Kernel Port.
10820 + *
10821 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10822 + * it and/or modify it under the terms of the GNU General Public License
10823 + * as published by the Free Software Foundation, either version 2 of the
10824 + * License, or (at your option) any later version.
10825 + *
10826 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10827 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10828 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10829 + * the GNU General Public License for more details.
10830 + *
10831 + * You should have received a copy of the GNU General Public License
10832 + * along with the Ubicom32 Linux Kernel Port. If not,
10833 + * see <http://www.gnu.org/licenses/>.
10834 + *
10835 + * Ubicom32 implementation derived from (with many thanks):
10836 + * arch/m68knommu
10837 + * arch/blackfin
10838 + * arch/parisc
10839 + */
10840 +#ifndef _ASM_UBICOM32_SCATTERLIST_H
10841 +#define _ASM_UBICOM32_SCATTERLIST_H
10842 +
10843 +#include <linux/mm.h>
10844 +#include <asm/types.h>
10845 +
10846 +struct scatterlist {
10847 +#ifdef CONFIG_DEBUG_SG
10848 + unsigned long sg_magic;
10849 +#endif
10850 + unsigned long page_link;
10851 + unsigned int offset;
10852 + dma_addr_t dma_address;
10853 + unsigned int length;
10854 +};
10855 +
10856 +#define sg_dma_address(sg) ((sg)->dma_address)
10857 +#define sg_dma_len(sg) ((sg)->length)
10858 +
10859 +#define ISA_DMA_THRESHOLD (0xffffffff)
10860 +
10861 +#endif /* _ASM_UBICOM32_SCATTERLIST_H */
10862 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/sd_tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sd_tio.h
10863 --- linux-2.6.30.10/arch/ubicom32/include/asm/sd_tio.h 1970-01-01 02:00:00.000000000 +0200
10864 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sd_tio.h 2009-12-11 11:45:11.000000000 +0200
10865 @@ -0,0 +1,36 @@
10866 +/*
10867 + * arch/ubicom32/include/asm/sd_tio.h
10868 + * SD TIO definitions
10869 + *
10870 + * (C) Copyright 2009, Ubicom, Inc.
10871 + *
10872 + * This file is part of the Ubicom32 Linux Kernel Port.
10873 + *
10874 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10875 + * it and/or modify it under the terms of the GNU General Public License
10876 + * as published by the Free Software Foundation, either version 2 of the
10877 + * License, or (at your option) any later version.
10878 + *
10879 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10880 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10881 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10882 + * the GNU General Public License for more details.
10883 + *
10884 + * You should have received a copy of the GNU General Public License
10885 + * along with the Ubicom32 Linux Kernel Port. If not,
10886 + * see <http://www.gnu.org/licenses/>.
10887 + */
10888 +#ifndef _ASM_UBICOM32_SD_TIO_H
10889 +#define _ASM_UBICOM32_SD_TIO_H
10890 +
10891 +#include <asm/devtree.h>
10892 +
10893 +/*
10894 + * Devtree node for SD
10895 + */
10896 +struct sd_tio_node {
10897 + struct devtree_node dn;
10898 + void *regs;
10899 +};
10900 +
10901 +#endif /* _ASM_UBICOM32_SD_TIO_H */
10902 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/sections.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sections.h
10903 --- linux-2.6.30.10/arch/ubicom32/include/asm/sections.h 1970-01-01 02:00:00.000000000 +0200
10904 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sections.h 2009-12-11 11:45:11.000000000 +0200
10905 @@ -0,0 +1,33 @@
10906 +/*
10907 + * arch/ubicom32/include/asm/sections.h
10908 + * Generic sections.h definitions for Ubicom32 architecture.
10909 + *
10910 + * (C) Copyright 2009, Ubicom, Inc.
10911 + *
10912 + * This file is part of the Ubicom32 Linux Kernel Port.
10913 + *
10914 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10915 + * it and/or modify it under the terms of the GNU General Public License
10916 + * as published by the Free Software Foundation, either version 2 of the
10917 + * License, or (at your option) any later version.
10918 + *
10919 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10920 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10921 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10922 + * the GNU General Public License for more details.
10923 + *
10924 + * You should have received a copy of the GNU General Public License
10925 + * along with the Ubicom32 Linux Kernel Port. If not,
10926 + * see <http://www.gnu.org/licenses/>.
10927 + *
10928 + * Ubicom32 implementation derived from (with many thanks):
10929 + * arch/m68knommu
10930 + * arch/blackfin
10931 + * arch/parisc
10932 + */
10933 +#ifndef _ASM_UBICOM32_SECTIONS_H
10934 +#define _ASM_UBICOM32_SECTIONS_H
10935 +
10936 +#include <asm-generic/sections.h>
10937 +
10938 +#endif /* _ASM_UBICOM32_SECTIONS_H */
10939 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/segment.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/segment.h
10940 --- linux-2.6.30.10/arch/ubicom32/include/asm/segment.h 1970-01-01 02:00:00.000000000 +0200
10941 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/segment.h 2009-12-11 11:45:11.000000000 +0200
10942 @@ -0,0 +1,78 @@
10943 +/*
10944 + * arch/ubicom32/include/asm/segment.h
10945 + * Memory segment definitions for Ubicom32 architecture.
10946 + *
10947 + * (C) Copyright 2009, Ubicom, Inc.
10948 + *
10949 + * This file is part of the Ubicom32 Linux Kernel Port.
10950 + *
10951 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
10952 + * it and/or modify it under the terms of the GNU General Public License
10953 + * as published by the Free Software Foundation, either version 2 of the
10954 + * License, or (at your option) any later version.
10955 + *
10956 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
10957 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
10958 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
10959 + * the GNU General Public License for more details.
10960 + *
10961 + * You should have received a copy of the GNU General Public License
10962 + * along with the Ubicom32 Linux Kernel Port. If not,
10963 + * see <http://www.gnu.org/licenses/>.
10964 + *
10965 + * Ubicom32 implementation derived from (with many thanks):
10966 + * arch/m68knommu
10967 + * arch/blackfin
10968 + * arch/parisc
10969 + */
10970 +#ifndef _ASM_UBICOM32_SEGMENT_H
10971 +#define _ASM_UBICOM32_SEGMENT_H
10972 +
10973 +/* define constants */
10974 +/* Address spaces (FC0-FC2) */
10975 +#define USER_DATA (1)
10976 +#ifndef __USER_DS
10977 +#define __USER_DS (USER_DATA)
10978 +#endif
10979 +#define USER_PROGRAM (2)
10980 +#define SUPER_DATA (5)
10981 +#ifndef __KERNEL_DS
10982 +#define __KERNEL_DS (SUPER_DATA)
10983 +#endif
10984 +#define SUPER_PROGRAM (6)
10985 +#define CPU_SPACE (7)
10986 +
10987 +#ifndef __ASSEMBLY__
10988 +
10989 +typedef struct {
10990 + unsigned long seg;
10991 +} mm_segment_t;
10992 +
10993 +#define MAKE_MM_SEG(s) ((mm_segment_t) { (s) })
10994 +#define USER_DS MAKE_MM_SEG(__USER_DS)
10995 +#define KERNEL_DS MAKE_MM_SEG(__KERNEL_DS)
10996 +
10997 +/*
10998 + * Get/set the SFC/DFC registers for MOVES instructions
10999 + */
11000 +
11001 +static inline mm_segment_t get_fs(void)
11002 +{
11003 + return USER_DS;
11004 +}
11005 +
11006 +static inline mm_segment_t get_ds(void)
11007 +{
11008 + /* return the supervisor data space code */
11009 + return KERNEL_DS;
11010 +}
11011 +
11012 +static inline void set_fs(mm_segment_t val)
11013 +{
11014 +}
11015 +
11016 +#define segment_eq(a,b) ((a).seg == (b).seg)
11017 +
11018 +#endif /* __ASSEMBLY__ */
11019 +
11020 +#endif /* _ASM_UBICOM32_SEGMENT_H */
11021 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/semaphore.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/semaphore.h
11022 --- linux-2.6.30.10/arch/ubicom32/include/asm/semaphore.h 1970-01-01 02:00:00.000000000 +0200
11023 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/semaphore.h 2009-12-11 11:45:11.000000000 +0200
11024 @@ -0,0 +1,140 @@
11025 +/*
11026 + * arch/ubicom32/include/asm/semaphore.h
11027 + * Interrupt-safe semaphores for Ubicom32 architecture.
11028 + *
11029 + * (C) Copyright 2009, Ubicom, Inc.
11030 + * (C) Copyright 1996 Linus Torvalds
11031 + * m68k version by Andreas Schwab
11032 + * Copyright (C) 2004 Microtronix Datacom Ltd
11033 + *
11034 + * This file is part of the Ubicom32 Linux Kernel Port.
11035 + *
11036 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11037 + * it and/or modify it under the terms of the GNU General Public License
11038 + * as published by the Free Software Foundation, either version 2 of the
11039 + * License, or (at your option) any later version.
11040 + *
11041 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11042 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11043 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11044 + * the GNU General Public License for more details.
11045 + *
11046 + * You should have received a copy of the GNU General Public License
11047 + * along with the Ubicom32 Linux Kernel Port. If not,
11048 + * see <http://www.gnu.org/licenses/>.
11049 + *
11050 + * Ubicom32 implementation derived from (with many thanks):
11051 + * arch/m68knommu
11052 + * arch/blackfin
11053 + * arch/parisc
11054 + */
11055 +#ifndef _ASM_UBICOM32_SEMAPHORE_H
11056 +#define _ASM_UBICOM32_SEMAPHORE_H
11057 +
11058 +#define RW_LOCK_BIAS 0x01000000
11059 +
11060 +#ifndef __ASSEMBLY__
11061 +
11062 +#include <linux/linkage.h>
11063 +#include <linux/wait.h>
11064 +#include <linux/spinlock.h>
11065 +#include <linux/rwsem.h>
11066 +
11067 +#include <asm/system.h>
11068 +#include <asm/atomic.h>
11069 +
11070 +struct semaphore {
11071 + atomic_t count;
11072 + atomic_t waking;
11073 + wait_queue_head_t wait;
11074 +};
11075 +
11076 +#define __SEMAPHORE_INITIALIZER(name, n) \
11077 +{ \
11078 + .count = ATOMIC_INIT(n), \
11079 + .waking = ATOMIC_INIT(0), \
11080 + .wait = __WAIT_QUEUE_HEAD_INITIALIZER((name).wait) \
11081 +}
11082 +
11083 +#define __DECLARE_SEMAPHORE_GENERIC(name,count) \
11084 + struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
11085 +
11086 +#define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
11087 +#define DECLARE_MUTEX_LOCKED(name) __DECLARE_SEMAPHORE_GENERIC(name,0)
11088 +
11089 +static inline void sema_init (struct semaphore *sem, int val)
11090 +{
11091 + *sem = (struct semaphore)__SEMAPHORE_INITIALIZER(*sem, val);
11092 +}
11093 +
11094 +static inline void init_MUTEX (struct semaphore *sem)
11095 +{
11096 + sema_init(sem, 1);
11097 +}
11098 +
11099 +static inline void init_MUTEX_LOCKED (struct semaphore *sem)
11100 +{
11101 + sema_init(sem, 0);
11102 +}
11103 +
11104 +asmlinkage void __down_failed(void /* special register calling convention */);
11105 +asmlinkage int __down_failed_interruptible(void /* params in registers */);
11106 +asmlinkage int __down_failed_trylock(void /* params in registers */);
11107 +asmlinkage void __up_wakeup(void /* special register calling convention */);
11108 +
11109 +asmlinkage void __down(struct semaphore * sem);
11110 +asmlinkage int __down_interruptible(struct semaphore * sem);
11111 +asmlinkage int __down_trylock(struct semaphore * sem);
11112 +asmlinkage void __up(struct semaphore * sem);
11113 +
11114 +extern spinlock_t semaphore_wake_lock;
11115 +
11116 +/*
11117 + * This is ugly, but we want the default case to fall through.
11118 + * "down_failed" is a special asm handler that calls the C
11119 + * routine that actually waits.
11120 + */
11121 +static inline void down(struct semaphore * sem)
11122 +{
11123 + might_sleep();
11124 +
11125 + if (atomic_dec_return(&sem->count) < 0)
11126 + __down(sem);
11127 +}
11128 +
11129 +static inline int down_interruptible(struct semaphore * sem)
11130 +{
11131 + int ret = 0;
11132 +
11133 +
11134 + might_sleep();
11135 +
11136 + if(atomic_dec_return(&sem->count) < 0)
11137 + ret = __down_interruptible(sem);
11138 + return ret;
11139 +}
11140 +
11141 +static inline int down_trylock(struct semaphore * sem)
11142 +{
11143 + int ret = 0;
11144 +
11145 + if (atomic_dec_return (&sem->count) < 0)
11146 + ret = __down_trylock(sem);
11147 + return ret;
11148 +}
11149 +
11150 +/*
11151 + * Note! This is subtle. We jump to wake people up only if
11152 + * the semaphore was negative (== somebody was waiting on it).
11153 + * The default case (no contention) will result in NO
11154 + * jumps for both down() and up().
11155 + */
11156 +static inline void up(struct semaphore * sem)
11157 +{
11158 + if (atomic_inc_return(&sem->count) <= 0)
11159 + __up(sem);
11160 +}
11161 +
11162 +#endif /* __ASSEMBLY__ */
11163 +
11164 +#endif /* _ASM_UBICOM32_SEMAPHORE_H */
11165 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/semaphore-helper.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/semaphore-helper.h
11166 --- linux-2.6.30.10/arch/ubicom32/include/asm/semaphore-helper.h 1970-01-01 02:00:00.000000000 +0200
11167 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/semaphore-helper.h 2009-12-11 11:45:11.000000000 +0200
11168 @@ -0,0 +1,109 @@
11169 +/*
11170 + * arch/ubicom32/include/asm/semaphore-helper.h
11171 + * Semaphore related definitions for Ubicom32 architecture.
11172 + *
11173 + * (C) Copyright 2009, Ubicom, Inc.
11174 + *
11175 + * This file is part of the Ubicom32 Linux Kernel Port.
11176 + *
11177 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11178 + * it and/or modify it under the terms of the GNU General Public License
11179 + * as published by the Free Software Foundation, either version 2 of the
11180 + * License, or (at your option) any later version.
11181 + *
11182 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11183 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11184 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11185 + * the GNU General Public License for more details.
11186 + *
11187 + * You should have received a copy of the GNU General Public License
11188 + * along with the Ubicom32 Linux Kernel Port. If not,
11189 + * see <http://www.gnu.org/licenses/>.
11190 + *
11191 + * Ubicom32 implementation derived from (with many thanks):
11192 + * arch/m68knommu
11193 + * arch/blackfin
11194 + * arch/parisc
11195 + */
11196 +#ifndef _ASM_UBICOM32_SEMAPHORE_HELPER_H
11197 +#define _ASM_UBICOM32_SEMAPHORE_HELPER_H
11198 +
11199 +/*
11200 + * SMP- and interrupt-safe semaphores helper functions.
11201 + *
11202 + * (C) Copyright 1996 Linus Torvalds
11203 + *
11204 + * m68k version by Andreas Schwab
11205 + */
11206 +
11207 +
11208 +/*
11209 + * These two _must_ execute atomically wrt each other.
11210 + */
11211 +static inline void wake_one_more(struct semaphore * sem)
11212 +{
11213 + atomic_inc(&sem->waking);
11214 +}
11215 +
11216 +static inline int waking_non_zero(struct semaphore *sem)
11217 +{
11218 + int ret;
11219 + unsigned long flags;
11220 +
11221 + spin_lock_irqsave(&semaphore_wake_lock, flags);
11222 + ret = 0;
11223 + if (atomic_read(&sem->waking) > 0) {
11224 + atomic_dec(&sem->waking);
11225 + ret = 1;
11226 + }
11227 + spin_unlock_irqrestore(&semaphore_wake_lock, flags);
11228 + return ret;
11229 +}
11230 +
11231 +/*
11232 + * waking_non_zero_interruptible:
11233 + * 1 got the lock
11234 + * 0 go to sleep
11235 + * -EINTR interrupted
11236 + */
11237 +static inline int waking_non_zero_interruptible(struct semaphore *sem,
11238 + struct task_struct *tsk)
11239 +{
11240 + int ret;
11241 + unsigned long flags;
11242 +
11243 + spin_lock_irqsave(&semaphore_wake_lock, flags);
11244 + ret = 0;
11245 + if (atomic_read(&sem->waking) > 0) {
11246 + atomic_dec(&sem->waking);
11247 + ret = 1;
11248 + } else if (signal_pending(tsk)) {
11249 + atomic_inc(&sem->count);
11250 + ret = -EINTR;
11251 + }
11252 + spin_unlock_irqrestore(&semaphore_wake_lock, flags);
11253 + return ret;
11254 +}
11255 +
11256 +/*
11257 + * waking_non_zero_trylock:
11258 + * 1 failed to lock
11259 + * 0 got the lock
11260 + */
11261 +static inline int waking_non_zero_trylock(struct semaphore *sem)
11262 +{
11263 + int ret;
11264 + unsigned long flags;
11265 +
11266 + spin_lock_irqsave(&semaphore_wake_lock, flags);
11267 + ret = 1;
11268 + if (atomic_read(&sem->waking) > 0) {
11269 + atomic_dec(&sem->waking);
11270 + ret = 0;
11271 + } else
11272 + atomic_inc(&sem->count);
11273 + spin_unlock_irqrestore(&semaphore_wake_lock, flags);
11274 + return ret;
11275 +}
11276 +
11277 +#endif /* _ASM_UBICOM32_SEMAPHORE_HELPER_H */
11278 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/sembuf.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sembuf.h
11279 --- linux-2.6.30.10/arch/ubicom32/include/asm/sembuf.h 1970-01-01 02:00:00.000000000 +0200
11280 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sembuf.h 2009-12-11 11:45:11.000000000 +0200
11281 @@ -0,0 +1,52 @@
11282 +/*
11283 + * arch/ubicom32/include/asm/sembuf.h
11284 + * The semid64_ds structure for Ubicom32 architecture.
11285 + *
11286 + * (C) Copyright 2009, Ubicom, Inc.
11287 + *
11288 + * This file is part of the Ubicom32 Linux Kernel Port.
11289 + *
11290 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11291 + * it and/or modify it under the terms of the GNU General Public License
11292 + * as published by the Free Software Foundation, either version 2 of the
11293 + * License, or (at your option) any later version.
11294 + *
11295 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11296 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11297 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11298 + * the GNU General Public License for more details.
11299 + *
11300 + * You should have received a copy of the GNU General Public License
11301 + * along with the Ubicom32 Linux Kernel Port. If not,
11302 + * see <http://www.gnu.org/licenses/>.
11303 + *
11304 + * Ubicom32 implementation derived from (with many thanks):
11305 + * arch/m68knommu
11306 + * arch/blackfin
11307 + * arch/parisc
11308 + */
11309 +#ifndef _ASM_UBICOM32_SEMBUF_H
11310 +#define _ASM_UBICOM32_SEMBUF_H
11311 +
11312 +/*
11313 + * The semid64_ds structure for ubicom32 architecture.
11314 + * Note extra padding because this structure is passed back and forth
11315 + * between kernel and user space.
11316 + *
11317 + * Pad space is left for:
11318 + * - 64-bit time_t to solve y2038 problem
11319 + * - 2 miscellaneous 32-bit values
11320 + */
11321 +
11322 +struct semid64_ds {
11323 + struct ipc64_perm sem_perm; /* permissions .. see ipc.h */
11324 + __kernel_time_t sem_otime; /* last semop time */
11325 + unsigned long __unused1;
11326 + __kernel_time_t sem_ctime; /* last change time */
11327 + unsigned long __unused2;
11328 + unsigned long sem_nsems; /* no. of semaphores in array */
11329 + unsigned long __unused3;
11330 + unsigned long __unused4;
11331 +};
11332 +
11333 +#endif /* _ASM_UBICOM32_SEMBUF_H */
11334 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/setup.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/setup.h
11335 --- linux-2.6.30.10/arch/ubicom32/include/asm/setup.h 1970-01-01 02:00:00.000000000 +0200
11336 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/setup.h 2009-12-11 11:45:11.000000000 +0200
11337 @@ -0,0 +1,35 @@
11338 +/*
11339 + * arch/ubicom32/include/asm/setup.h
11340 + * Kernel command line length definition.
11341 + *
11342 + * (C) Copyright 2009, Ubicom, Inc.
11343 + * Copyright (C) 2004, Microtronix Datacom Ltd., All rights reserved.
11344 + *
11345 + * This file is part of the Ubicom32 Linux Kernel Port.
11346 + *
11347 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11348 + * it and/or modify it under the terms of the GNU General Public License
11349 + * as published by the Free Software Foundation, either version 2 of the
11350 + * License, or (at your option) any later version.
11351 + *
11352 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11353 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11354 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11355 + * the GNU General Public License for more details.
11356 + *
11357 + * You should have received a copy of the GNU General Public License
11358 + * along with the Ubicom32 Linux Kernel Port. If not,
11359 + * see <http://www.gnu.org/licenses/>.
11360 + *
11361 + * Ubicom32 implementation derived from (with many thanks):
11362 + * arch/m68knommu
11363 + * arch/blackfin
11364 + * arch/parisc
11365 + */
11366 +
11367 +#ifndef _ASM_UBICOM32_SETUP_H
11368 +#define _ASM_UBICOM32_SETUP_H
11369 +
11370 +#define COMMAND_LINE_SIZE 512
11371 +
11372 +#endif /* _ASM_UBICOM32_SETUP_H */
11373 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/shmbuf.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/shmbuf.h
11374 --- linux-2.6.30.10/arch/ubicom32/include/asm/shmbuf.h 1970-01-01 02:00:00.000000000 +0200
11375 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/shmbuf.h 2009-12-11 11:45:11.000000000 +0200
11376 @@ -0,0 +1,69 @@
11377 +/*
11378 + * arch/ubicom32/include/asm/shmbuf.h
11379 + * The shmid64_ds structure for the Ubicom32 architecture.
11380 + *
11381 + * (C) Copyright 2009, Ubicom, Inc.
11382 + *
11383 + * This file is part of the Ubicom32 Linux Kernel Port.
11384 + *
11385 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11386 + * it and/or modify it under the terms of the GNU General Public License
11387 + * as published by the Free Software Foundation, either version 2 of the
11388 + * License, or (at your option) any later version.
11389 + *
11390 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11391 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11392 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11393 + * the GNU General Public License for more details.
11394 + *
11395 + * You should have received a copy of the GNU General Public License
11396 + * along with the Ubicom32 Linux Kernel Port. If not,
11397 + * see <http://www.gnu.org/licenses/>.
11398 + *
11399 + * Ubicom32 implementation derived from (with many thanks):
11400 + * arch/m68knommu
11401 + * arch/blackfin
11402 + * arch/parisc
11403 + */
11404 +#ifndef _ASM_UBICOM32_SHMBUF_H
11405 +#define _ASM_UBICOM32_SHMBUF_H
11406 +
11407 +/*
11408 + * The shmid64_ds structure for m68k architecture.
11409 + * Note extra padding because this structure is passed back and forth
11410 + * between kernel and user space.
11411 + *
11412 + * Pad space is left for:
11413 + * - 64-bit time_t to solve y2038 problem
11414 + * - 2 miscellaneous 32-bit values
11415 + */
11416 +
11417 +struct shmid64_ds {
11418 + struct ipc64_perm shm_perm; /* operation perms */
11419 + size_t shm_segsz; /* size of segment (bytes) */
11420 + __kernel_time_t shm_atime; /* last attach time */
11421 + unsigned long __unused1;
11422 + __kernel_time_t shm_dtime; /* last detach time */
11423 + unsigned long __unused2;
11424 + __kernel_time_t shm_ctime; /* last change time */
11425 + unsigned long __unused3;
11426 + __kernel_pid_t shm_cpid; /* pid of creator */
11427 + __kernel_pid_t shm_lpid; /* pid of last operator */
11428 + unsigned long shm_nattch; /* no. of current attaches */
11429 + unsigned long __unused4;
11430 + unsigned long __unused5;
11431 +};
11432 +
11433 +struct shminfo64 {
11434 + unsigned long shmmax;
11435 + unsigned long shmmin;
11436 + unsigned long shmmni;
11437 + unsigned long shmseg;
11438 + unsigned long shmall;
11439 + unsigned long __unused1;
11440 + unsigned long __unused2;
11441 + unsigned long __unused3;
11442 + unsigned long __unused4;
11443 +};
11444 +
11445 +#endif /* _ASM_UBICOM32_SHMBUF_H */
11446 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/shmparam.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/shmparam.h
11447 --- linux-2.6.30.10/arch/ubicom32/include/asm/shmparam.h 1970-01-01 02:00:00.000000000 +0200
11448 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/shmparam.h 2009-12-11 11:45:11.000000000 +0200
11449 @@ -0,0 +1,35 @@
11450 +/*
11451 + * arch/ubicom32/include/asm/shmparam.h
11452 + * Shared memory definitions for Ubicom32 architecture.
11453 + *
11454 + * (C) Copyright 2009, Ubicom, Inc.
11455 + * Copyright (C) 2004 Microtronix Datacom Ltd
11456 + *
11457 + * This file is part of the Ubicom32 Linux Kernel Port.
11458 + *
11459 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11460 + * it and/or modify it under the terms of the GNU General Public License
11461 + * as published by the Free Software Foundation, either version 2 of the
11462 + * License, or (at your option) any later version.
11463 + *
11464 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11465 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11466 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11467 + * the GNU General Public License for more details.
11468 + *
11469 + * You should have received a copy of the GNU General Public License
11470 + * along with the Ubicom32 Linux Kernel Port. If not,
11471 + * see <http://www.gnu.org/licenses/>.
11472 + *
11473 + * Ubicom32 implementation derived from (with many thanks):
11474 + * arch/m68knommu
11475 + * arch/blackfin
11476 + * arch/parisc
11477 + * Alpha, ix86, M68K, Sparc, ...et al
11478 + */
11479 +#ifndef _ASM_UBICOM32_SHMPARAM_H
11480 +#define _ASM_UBICOM32_SHMPARAM_H
11481 +
11482 +#define SHMLBA PAGE_SIZE /* attach addr a multiple of this */
11483 +
11484 +#endif /* _ASM_UBICOM32_SHMPARAM_H */
11485 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/sigcontext.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sigcontext.h
11486 --- linux-2.6.30.10/arch/ubicom32/include/asm/sigcontext.h 1970-01-01 02:00:00.000000000 +0200
11487 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sigcontext.h 2009-12-11 11:45:11.000000000 +0200
11488 @@ -0,0 +1,37 @@
11489 +/*
11490 + * arch/ubicom32/include/asm/sigcontext.h
11491 + * Definition of sigcontext struct for Ubicom32 architecture.
11492 + *
11493 + * (C) Copyright 2009, Ubicom, Inc.
11494 + *
11495 + * This file is part of the Ubicom32 Linux Kernel Port.
11496 + *
11497 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11498 + * it and/or modify it under the terms of the GNU General Public License
11499 + * as published by the Free Software Foundation, either version 2 of the
11500 + * License, or (at your option) any later version.
11501 + *
11502 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11503 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11504 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11505 + * the GNU General Public License for more details.
11506 + *
11507 + * You should have received a copy of the GNU General Public License
11508 + * along with the Ubicom32 Linux Kernel Port. If not,
11509 + * see <http://www.gnu.org/licenses/>.
11510 + *
11511 + * Ubicom32 implementation derived from (with many thanks):
11512 + * arch/m68knommu
11513 + * arch/blackfin
11514 + * arch/parisc
11515 + */
11516 +#ifndef _ASM_UBICOM32_SIGCONTEXT_H
11517 +#define _ASM_UBICOM32_SIGCONTEXT_H
11518 +
11519 +#include <asm/ptrace.h>
11520 +
11521 +struct sigcontext {
11522 + struct pt_regs sc_regs;
11523 +};
11524 +
11525 +#endif /* _ASM_UBICOM32_SIGCONTEXT_H */
11526 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/siginfo.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/siginfo.h
11527 --- linux-2.6.30.10/arch/ubicom32/include/asm/siginfo.h 1970-01-01 02:00:00.000000000 +0200
11528 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/siginfo.h 2009-12-11 11:45:11.000000000 +0200
11529 @@ -0,0 +1,33 @@
11530 +/*
11531 + * arch/ubicom32/include/asm/siginfo.h
11532 + * Generic siginfo.h definitions for Ubicom32 architecture.
11533 + *
11534 + * (C) Copyright 2009, Ubicom, Inc.
11535 + *
11536 + * This file is part of the Ubicom32 Linux Kernel Port.
11537 + *
11538 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11539 + * it and/or modify it under the terms of the GNU General Public License
11540 + * as published by the Free Software Foundation, either version 2 of the
11541 + * License, or (at your option) any later version.
11542 + *
11543 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11544 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11545 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11546 + * the GNU General Public License for more details.
11547 + *
11548 + * You should have received a copy of the GNU General Public License
11549 + * along with the Ubicom32 Linux Kernel Port. If not,
11550 + * see <http://www.gnu.org/licenses/>.
11551 + *
11552 + * Ubicom32 implementation derived from (with many thanks):
11553 + * arch/m68knommu
11554 + * arch/blackfin
11555 + * arch/parisc
11556 + */
11557 +#ifndef _ASM_UBICOM32_SIGINFO_H
11558 +#define _ASM_UBICOM32_SIGINFO_H
11559 +
11560 +#include <asm-generic/siginfo.h>
11561 +
11562 +#endif /* _ASM_UBICOM32_SIGINFO_H */
11563 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/signal.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/signal.h
11564 --- linux-2.6.30.10/arch/ubicom32/include/asm/signal.h 1970-01-01 02:00:00.000000000 +0200
11565 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/signal.h 2009-12-11 11:45:11.000000000 +0200
11566 @@ -0,0 +1,180 @@
11567 +/*
11568 + * arch/ubicom32/include/asm/signal.h
11569 + * Signal related definitions for Ubicom32 architecture.
11570 + *
11571 + * (C) Copyright 2009, Ubicom, Inc.
11572 + *
11573 + * This file is part of the Ubicom32 Linux Kernel Port.
11574 + *
11575 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11576 + * it and/or modify it under the terms of the GNU General Public License
11577 + * as published by the Free Software Foundation, either version 2 of the
11578 + * License, or (at your option) any later version.
11579 + *
11580 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11581 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11582 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11583 + * the GNU General Public License for more details.
11584 + *
11585 + * You should have received a copy of the GNU General Public License
11586 + * along with the Ubicom32 Linux Kernel Port. If not,
11587 + * see <http://www.gnu.org/licenses/>.
11588 + *
11589 + * Ubicom32 implementation derived from (with many thanks):
11590 + * arch/m68knommu
11591 + * arch/blackfin
11592 + * arch/parisc
11593 + */
11594 +#ifndef _ASM_UBICOM32_SIGNAL_H
11595 +#define _ASM_UBICOM32_SIGNAL_H
11596 +
11597 +#include <linux/types.h>
11598 +
11599 +/* Avoid too many header ordering problems. */
11600 +struct siginfo;
11601 +
11602 +#ifdef __KERNEL__
11603 +/* Most things should be clean enough to redefine this at will, if care
11604 + is taken to make libc match. */
11605 +
11606 +#define _NSIG 64
11607 +#define _NSIG_BPW 32
11608 +#define _NSIG_WORDS (_NSIG / _NSIG_BPW)
11609 +
11610 +typedef unsigned long old_sigset_t; /* at least 32 bits */
11611 +
11612 +typedef struct {
11613 + unsigned long sig[_NSIG_WORDS];
11614 +} sigset_t;
11615 +
11616 +#endif /* __KERNEL__ */
11617 +
11618 +#define SIGHUP 1
11619 +#define SIGINT 2
11620 +#define SIGQUIT 3
11621 +#define SIGILL 4
11622 +#define SIGTRAP 5
11623 +#define SIGABRT 6
11624 +#define SIGIOT 6
11625 +#define SIGBUS 7
11626 +#define SIGFPE 8
11627 +#define SIGKILL 9
11628 +#define SIGUSR1 10
11629 +#define SIGSEGV 11
11630 +#define SIGUSR2 12
11631 +#define SIGPIPE 13
11632 +#define SIGALRM 14
11633 +#define SIGTERM 15
11634 +#define SIGSTKFLT 16
11635 +#define SIGCHLD 17
11636 +#define SIGCONT 18
11637 +#define SIGSTOP 19
11638 +#define SIGTSTP 20
11639 +#define SIGTTIN 21
11640 +#define SIGTTOU 22
11641 +#define SIGURG 23
11642 +#define SIGXCPU 24
11643 +#define SIGXFSZ 25
11644 +#define SIGVTALRM 26
11645 +#define SIGPROF 27
11646 +#define SIGWINCH 28
11647 +#define SIGIO 29
11648 +#define SIGPOLL SIGIO
11649 +/*
11650 +#define SIGLOST 29
11651 +*/
11652 +#define SIGPWR 30
11653 +#define SIGSYS 31
11654 +#define SIGUNUSED 31
11655 +
11656 +/* These should not be considered constants from userland. */
11657 +#define SIGRTMIN 32
11658 +#define SIGRTMAX _NSIG
11659 +
11660 +/*
11661 + * SA_FLAGS values:
11662 + *
11663 + * SA_ONSTACK indicates that a registered stack_t will be used.
11664 + * SA_RESTART flag to get restarting signals (which were the default long ago)
11665 + * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
11666 + * SA_RESETHAND clears the handler when the signal is delivered.
11667 + * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
11668 + * SA_NODEFER prevents the current signal from being masked in the handler.
11669 + *
11670 + * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
11671 + * Unix names RESETHAND and NODEFER respectively.
11672 + */
11673 +#define SA_NOCLDSTOP 0x00000001
11674 +#define SA_NOCLDWAIT 0x00000002
11675 +#define SA_SIGINFO 0x00000004
11676 +#define SA_ONSTACK 0x08000000
11677 +#define SA_RESTART 0x10000000
11678 +#define SA_NODEFER 0x40000000
11679 +#define SA_RESETHAND 0x80000000
11680 +
11681 +#define SA_NOMASK SA_NODEFER
11682 +#define SA_ONESHOT SA_RESETHAND
11683 +
11684 +/*
11685 + * sigaltstack controls
11686 + */
11687 +#define SS_ONSTACK 1
11688 +#define SS_DISABLE 2
11689 +
11690 +#define MINSIGSTKSZ 2048
11691 +#define SIGSTKSZ 8192
11692 +
11693 +#include <asm-generic/signal.h>
11694 +
11695 +#ifdef __KERNEL__
11696 +struct old_sigaction {
11697 + __sighandler_t sa_handler;
11698 + old_sigset_t sa_mask;
11699 + unsigned long sa_flags;
11700 + void (*sa_restorer)(void);
11701 +};
11702 +
11703 +struct sigaction {
11704 + __sighandler_t sa_handler;
11705 + unsigned long sa_flags;
11706 + void (*sa_restorer)(void);
11707 + sigset_t sa_mask; /* mask last for extensibility */
11708 +};
11709 +
11710 +struct k_sigaction {
11711 + struct sigaction sa;
11712 +};
11713 +#else
11714 +/* Here we must cater to libcs that poke about in kernel headers. */
11715 +
11716 +struct sigaction {
11717 + union {
11718 + __sighandler_t _sa_handler;
11719 + void (*_sa_sigaction)(int, struct siginfo *, void *);
11720 + } _u;
11721 + sigset_t sa_mask;
11722 + unsigned long sa_flags;
11723 + void (*sa_restorer)(void);
11724 +};
11725 +
11726 +#define sa_handler _u._sa_handler
11727 +#define sa_sigaction _u._sa_sigaction
11728 +
11729 +#endif /* __KERNEL__ */
11730 +
11731 +typedef struct sigaltstack {
11732 + void *ss_sp;
11733 + int ss_flags;
11734 + size_t ss_size;
11735 +} stack_t;
11736 +
11737 +#ifdef __KERNEL__
11738 +
11739 +#include <asm/sigcontext.h>
11740 +#undef __HAVE_ARCH_SIG_BITOPS
11741 +
11742 +#define ptrace_signal_deliver(regs, cookie) do { } while (0)
11743 +
11744 +#endif /* __KERNEL__ */
11745 +
11746 +#endif /* _ASM_UBICOM32_SIGNAL_H */
11747 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/smp.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/smp.h
11748 --- linux-2.6.30.10/arch/ubicom32/include/asm/smp.h 1970-01-01 02:00:00.000000000 +0200
11749 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/smp.h 2009-12-11 11:45:11.000000000 +0200
11750 @@ -0,0 +1,87 @@
11751 +/*
11752 + * arch/ubicom32/include/asm/smp.h
11753 + * SMP definitions for Ubicom32 architecture.
11754 + *
11755 + * (C) Copyright 2009, Ubicom, Inc.
11756 + *
11757 + * This file is part of the Ubicom32 Linux Kernel Port.
11758 + *
11759 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11760 + * it and/or modify it under the terms of the GNU General Public License
11761 + * as published by the Free Software Foundation, either version 2 of the
11762 + * License, or (at your option) any later version.
11763 + *
11764 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11765 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11766 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11767 + * the GNU General Public License for more details.
11768 + *
11769 + * You should have received a copy of the GNU General Public License
11770 + * along with the Ubicom32 Linux Kernel Port. If not,
11771 + * see <http://www.gnu.org/licenses/>.
11772 + *
11773 + * Ubicom32 implementation derived from (with many thanks):
11774 + * arch/m68knommu
11775 + * arch/blackfin
11776 + * arch/parisc
11777 + */
11778 +#ifndef _ASM_UBICOM32_SMP_H
11779 +#define _ASM_UBICOM32_SMP_H
11780 +
11781 +#ifndef CONFIG_SMP
11782 +#error you should not include smp.h if smp is off
11783 +#endif
11784 +
11785 +#ifndef ASSEMBLY
11786 +#include <linux/bitops.h>
11787 +#include <linux/threads.h>
11788 +#include <linux/cpumask.h>
11789 +#include <asm/ip5000.h>
11790 +
11791 +typedef unsigned long address_t;
11792 +extern unsigned int smp_ipi_irq;
11793 +
11794 +/*
11795 + * This magic constant controls our willingness to transfer
11796 + * a process across CPUs.
11797 + *
11798 + * Such a transfer incurs cache and tlb
11799 + * misses. The current value is inherited from i386. Still needs
11800 + * to be tuned for parisc.
11801 + */
11802 +#define PROC_CHANGE_PENALTY 15 /* Schedule penalty */
11803 +#define NO_PROC_ID 0xFF /* No processor magic marker */
11804 +#define ANY_PROC_ID 0xFF /* Any processor magic marker */
11805 +
11806 +#ifdef CONFIG_SMP
11807 +#define raw_smp_processor_id() (current_thread_info()->cpu)
11808 +#endif /* CONFIG_SMP */
11809 +
11810 +static inline int __cpu_disable (void)
11811 +{
11812 + return 0;
11813 +}
11814 +
11815 +static inline void __cpu_die (unsigned int cpu)
11816 +{
11817 + while(1) {
11818 + };
11819 +}
11820 +
11821 +extern int __cpu_up(unsigned int cpu);
11822 +extern void smp_send_timer_all(void);
11823 +extern void smp_timer_broadcast(const struct cpumask *mask);
11824 +extern void smp_set_affinity(unsigned int irq, const struct cpumask *dest);
11825 +extern void arch_send_call_function_single_ipi(int cpu);
11826 +#define arch_send_call_function_ipi_mask arch_send_call_function_ipi_mask
11827 +extern void arch_send_call_function_ipi_mask(const struct cpumask *mask);
11828 +
11829 +/*
11830 + * TODO: Once these are fully tested, we should turn them into
11831 + * inline macros for performance.
11832 + */
11833 +extern unsigned long smp_get_affinity(unsigned int irq, int *all);
11834 +extern void smp_reset_ipi(unsigned long mask);
11835 +
11836 +#endif /* !ASSEMBLY */
11837 +#endif /* _ASM_UBICOM32_SMP_H */
11838 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/socket.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/socket.h
11839 --- linux-2.6.30.10/arch/ubicom32/include/asm/socket.h 1970-01-01 02:00:00.000000000 +0200
11840 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/socket.h 2009-12-11 11:45:11.000000000 +0200
11841 @@ -0,0 +1,87 @@
11842 +/*
11843 + * arch/ubicom32/include/asm/socket.h
11844 + * Socket options definitions for Ubicom32 architecture.
11845 + *
11846 + * (C) Copyright 2009, Ubicom, Inc.
11847 + *
11848 + * This file is part of the Ubicom32 Linux Kernel Port.
11849 + *
11850 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11851 + * it and/or modify it under the terms of the GNU General Public License
11852 + * as published by the Free Software Foundation, either version 2 of the
11853 + * License, or (at your option) any later version.
11854 + *
11855 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11856 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11857 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11858 + * the GNU General Public License for more details.
11859 + *
11860 + * You should have received a copy of the GNU General Public License
11861 + * along with the Ubicom32 Linux Kernel Port. If not,
11862 + * see <http://www.gnu.org/licenses/>.
11863 + *
11864 + * Ubicom32 implementation derived from (with many thanks):
11865 + * arch/m68knommu
11866 + * arch/blackfin
11867 + * arch/parisc
11868 + */
11869 +#ifndef _ASM_UBICOM32_SOCKET_H
11870 +#define _ASM_UBICOM32_SOCKET_H
11871 +
11872 +#include <asm/sockios.h>
11873 +
11874 +/* For setsockopt(2) */
11875 +#define SOL_SOCKET 1
11876 +
11877 +#define SO_DEBUG 1
11878 +#define SO_REUSEADDR 2
11879 +#define SO_TYPE 3
11880 +#define SO_ERROR 4
11881 +#define SO_DONTROUTE 5
11882 +#define SO_BROADCAST 6
11883 +#define SO_SNDBUF 7
11884 +#define SO_RCVBUF 8
11885 +#define SO_SNDBUFFORCE 32
11886 +#define SO_RCVBUFFORCE 33
11887 +#define SO_KEEPALIVE 9
11888 +#define SO_OOBINLINE 10
11889 +#define SO_NO_CHECK 11
11890 +#define SO_PRIORITY 12
11891 +#define SO_LINGER 13
11892 +#define SO_BSDCOMPAT 14
11893 +/* To add :#define SO_REUSEPORT 15 */
11894 +#define SO_PASSCRED 16
11895 +#define SO_PEERCRED 17
11896 +#define SO_RCVLOWAT 18
11897 +#define SO_SNDLOWAT 19
11898 +#define SO_RCVTIMEO 20
11899 +#define SO_SNDTIMEO 21
11900 +
11901 +/* Security levels - as per NRL IPv6 - don't actually do anything */
11902 +#define SO_SECURITY_AUTHENTICATION 22
11903 +#define SO_SECURITY_ENCRYPTION_TRANSPORT 23
11904 +#define SO_SECURITY_ENCRYPTION_NETWORK 24
11905 +
11906 +#define SO_BINDTODEVICE 25
11907 +
11908 +/* Socket filtering */
11909 +#define SO_ATTACH_FILTER 26
11910 +#define SO_DETACH_FILTER 27
11911 +
11912 +#define SO_PEERNAME 28
11913 +#define SO_TIMESTAMP 29
11914 +#define SCM_TIMESTAMP SO_TIMESTAMP
11915 +
11916 +#define SO_ACCEPTCONN 30
11917 +
11918 +#define SO_PEERSEC 31
11919 +#define SO_PASSSEC 34
11920 +#define SO_TIMESTAMPNS 35
11921 +#define SCM_TIMESTAMPNS SO_TIMESTAMPNS
11922 +
11923 +#define SO_MARK 36
11924 +
11925 +#define SO_TIMESTAMPING 37
11926 +#define SCM_TIMESTAMPING SO_TIMESTAMPING
11927 +
11928 +#endif /* _ASM_UBICOM32_SOCKET_H */
11929 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/sockios.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sockios.h
11930 --- linux-2.6.30.10/arch/ubicom32/include/asm/sockios.h 1970-01-01 02:00:00.000000000 +0200
11931 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/sockios.h 2009-12-11 11:45:11.000000000 +0200
11932 @@ -0,0 +1,40 @@
11933 +/*
11934 + * arch/ubicom32/include/asm/sockios.h
11935 + * Socket-level ioctl definitions for Ubicom32 architecture.
11936 + *
11937 + * (C) Copyright 2009, Ubicom, Inc.
11938 + *
11939 + * This file is part of the Ubicom32 Linux Kernel Port.
11940 + *
11941 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11942 + * it and/or modify it under the terms of the GNU General Public License
11943 + * as published by the Free Software Foundation, either version 2 of the
11944 + * License, or (at your option) any later version.
11945 + *
11946 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11947 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11948 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11949 + * the GNU General Public License for more details.
11950 + *
11951 + * You should have received a copy of the GNU General Public License
11952 + * along with the Ubicom32 Linux Kernel Port. If not,
11953 + * see <http://www.gnu.org/licenses/>.
11954 + *
11955 + * Ubicom32 implementation derived from (with many thanks):
11956 + * arch/m68knommu
11957 + * arch/blackfin
11958 + * arch/parisc
11959 + */
11960 +#ifndef _ASM_UBICOM32_SOCKIOS_H
11961 +#define _ASM_UBICOM32_SOCKIOS_H
11962 +
11963 +/* Socket-level I/O control calls. */
11964 +#define FIOSETOWN 0x8901
11965 +#define SIOCSPGRP 0x8902
11966 +#define FIOGETOWN 0x8903
11967 +#define SIOCGPGRP 0x8904
11968 +#define SIOCATMARK 0x8905
11969 +#define SIOCGSTAMP 0x8906 /* Get stamp (timeval) */
11970 +#define SIOCGSTAMPNS 0x8907 /* Get stamp (timespec) */
11971 +
11972 +#endif /* _ASM_UBICOM32_SOCKIOS_H */
11973 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/spinlock.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/spinlock.h
11974 --- linux-2.6.30.10/arch/ubicom32/include/asm/spinlock.h 1970-01-01 02:00:00.000000000 +0200
11975 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/spinlock.h 2009-12-11 11:45:11.000000000 +0200
11976 @@ -0,0 +1,296 @@
11977 +/*
11978 + * arch/ubicom32/include/asm/spinlock.h
11979 + * Spinlock related definitions for Ubicom32 architecture.
11980 + *
11981 + * (C) Copyright 2009, Ubicom, Inc.
11982 + *
11983 + * This file is part of the Ubicom32 Linux Kernel Port.
11984 + *
11985 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
11986 + * it and/or modify it under the terms of the GNU General Public License
11987 + * as published by the Free Software Foundation, either version 2 of the
11988 + * License, or (at your option) any later version.
11989 + *
11990 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
11991 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
11992 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
11993 + * the GNU General Public License for more details.
11994 + *
11995 + * You should have received a copy of the GNU General Public License
11996 + * along with the Ubicom32 Linux Kernel Port. If not,
11997 + * see <http://www.gnu.org/licenses/>.
11998 + *
11999 + * Ubicom32 implementation derived from (with many thanks):
12000 + * arch/m68knommu
12001 + * arch/blackfin
12002 + * arch/parisc
12003 + */
12004 +#ifndef _ASM_UBICOM32_SPINLOCK_H
12005 +#define _ASM_UBICOM32_SPINLOCK_H
12006 +
12007 +#include <asm/system.h>
12008 +#include <asm/processor.h>
12009 +#include <asm/spinlock_types.h>
12010 +
12011 +/*
12012 + * __raw_spin_lock()
12013 + * Lock the lock.
12014 + */
12015 +static inline void __raw_spin_lock(raw_spinlock_t *x)
12016 +{
12017 + asm volatile (
12018 + "1: bset %0, %0, #0 \n\t"
12019 + " jmpne.f 1b \n\t"
12020 + : "+U4" (x->lock)
12021 + :
12022 + : "memory", "cc"
12023 + );
12024 +}
12025 +
12026 +/*
12027 + * __raw_spin_unlock()
12028 + * Unlock the lock.
12029 + */
12030 +static inline void __raw_spin_unlock(raw_spinlock_t *x)
12031 +{
12032 + asm volatile (
12033 + " bclr %0, %0, #0 \n\t"
12034 + : "+U4" (x->lock)
12035 + :
12036 + : "memory", "cc"
12037 + );
12038 +}
12039 +
12040 +/*
12041 + * __raw_spin_is_locked()
12042 + * Test if the lock is locked.
12043 + */
12044 +static inline int __raw_spin_is_locked(raw_spinlock_t *x)
12045 +{
12046 + return x->lock;
12047 +}
12048 +
12049 +/*
12050 + * __raw_spin_unlock_wait()
12051 + * Wait for the lock to be unlocked.
12052 + *
12053 + * Note: the caller has not guarantee that the lock will not
12054 + * be acquired before they get to it.
12055 + */
12056 +static inline void __raw_spin_unlock_wait(raw_spinlock_t *x)
12057 +{
12058 + do {
12059 + cpu_relax();
12060 + } while (__raw_spin_is_locked(x));
12061 +}
12062 +
12063 +/*
12064 + * __raw_spin_trylock()
12065 + * Try the lock, return 0 on failure, 1 on success.
12066 + */
12067 +static inline int __raw_spin_trylock(raw_spinlock_t *x)
12068 +{
12069 + int ret = 0;
12070 +
12071 + asm volatile (
12072 + " bset %1, %1, #0 \n\t"
12073 + " jmpne.f 1f \n\t"
12074 + " move.4 %0, #1 \n\t"
12075 + "1: \n\t"
12076 + : "+r" (ret), "+U4" (x->lock)
12077 + :
12078 + : "memory", "cc"
12079 + );
12080 +
12081 + return ret;
12082 +}
12083 +
12084 +/*
12085 + * __raw_spin_lock_flags()
12086 + * Spin waiting for the lock (enabling IRQ(s))
12087 + */
12088 +static inline void __raw_spin_lock_flags(raw_spinlock_t *x, unsigned long flags)
12089 +{
12090 + mb();
12091 + while (!__raw_spin_trylock(x)) {
12092 + /*
12093 + * If the flags from the IRQ are set, interrupts are disabled and we
12094 + * need to re-enable them.
12095 + */
12096 + if (!flags) {
12097 + cpu_relax();
12098 + } else {
12099 + raw_local_irq_enable();
12100 + cpu_relax();
12101 + raw_local_irq_disable();
12102 + }
12103 + }
12104 + mb();
12105 +}
12106 +
12107 +/*
12108 + * Read-write spinlocks, allowing multiple readers but only one writer.
12109 + * Linux rwlocks are unfair to writers; they can be starved for an indefinite
12110 + * time by readers. With care, they can also be taken in interrupt context.
12111 + *
12112 + * In Ubicom32 architecture implementation, we have a spinlock and a counter.
12113 + * Readers use the lock to serialise their access to the counter (which
12114 + * records how many readers currently hold the lock).
12115 + * Writers hold the spinlock, preventing any readers or other writers from
12116 + * grabbing the rwlock.
12117 + */
12118 +
12119 +/*
12120 + * __raw_read_lock()
12121 + * Increment the counter in the rwlock.
12122 + *
12123 + * Note that we have to ensure interrupts are disabled in case we're
12124 + * interrupted by some other code that wants to grab the same read lock
12125 + */
12126 +static inline void __raw_read_lock(raw_rwlock_t *rw)
12127 +{
12128 + unsigned long flags;
12129 + raw_local_irq_save(flags);
12130 + __raw_spin_lock_flags(&rw->lock, flags);
12131 + rw->counter++;
12132 + __raw_spin_unlock(&rw->lock);
12133 + raw_local_irq_restore(flags);
12134 +}
12135 +
12136 +/*
12137 + * __raw_read_unlock()
12138 + * Decrement the counter.
12139 + *
12140 + * Note that we have to ensure interrupts are disabled in case we're
12141 + * interrupted by some other code that wants to grab the same read lock
12142 + */
12143 +static inline void __raw_read_unlock(raw_rwlock_t *rw)
12144 +{
12145 + unsigned long flags;
12146 + raw_local_irq_save(flags);
12147 + __raw_spin_lock_flags(&rw->lock, flags);
12148 + rw->counter--;
12149 + __raw_spin_unlock(&rw->lock);
12150 + raw_local_irq_restore(flags);
12151 +}
12152 +
12153 +/*
12154 + * __raw_read_trylock()
12155 + * Increment the counter if we can.
12156 + *
12157 + * Note that we have to ensure interrupts are disabled in case we're
12158 + * interrupted by some other code that wants to grab the same read lock
12159 + */
12160 +static inline int __raw_read_trylock(raw_rwlock_t *rw)
12161 +{
12162 + unsigned long flags;
12163 + retry:
12164 + raw_local_irq_save(flags);
12165 + if (__raw_spin_trylock(&rw->lock)) {
12166 + rw->counter++;
12167 + __raw_spin_unlock(&rw->lock);
12168 + raw_local_irq_restore(flags);
12169 + return 1;
12170 + }
12171 +
12172 + raw_local_irq_restore(flags);
12173 +
12174 + /*
12175 + * If write-locked, we fail to acquire the lock
12176 + */
12177 + if (rw->counter < 0) {
12178 + return 0;
12179 + }
12180 +
12181 + /*
12182 + * Wait until we have a realistic chance at the lock
12183 + */
12184 + while (__raw_spin_is_locked(&rw->lock) && rw->counter >= 0) {
12185 + cpu_relax();
12186 + }
12187 +
12188 + goto retry;
12189 +}
12190 +
12191 +/*
12192 + * __raw_write_lock()
12193 + *
12194 + * Note that we have to ensure interrupts are disabled in case we're
12195 + * interrupted by some other code that wants to read_trylock() this lock
12196 + */
12197 +static inline void __raw_write_lock(raw_rwlock_t *rw)
12198 +{
12199 + unsigned long flags;
12200 +retry:
12201 + raw_local_irq_save(flags);
12202 + __raw_spin_lock_flags(&rw->lock, flags);
12203 +
12204 + if (rw->counter != 0) {
12205 + __raw_spin_unlock(&rw->lock);
12206 + raw_local_irq_restore(flags);
12207 +
12208 + while (rw->counter != 0)
12209 + cpu_relax();
12210 +
12211 + goto retry;
12212 + }
12213 +
12214 + rw->counter = -1; /* mark as write-locked */
12215 + mb();
12216 + raw_local_irq_restore(flags);
12217 +}
12218 +
12219 +static inline void __raw_write_unlock(raw_rwlock_t *rw)
12220 +{
12221 + rw->counter = 0;
12222 + __raw_spin_unlock(&rw->lock);
12223 +}
12224 +
12225 +/* Note that we have to ensure interrupts are disabled in case we're
12226 + * interrupted by some other code that wants to read_trylock() this lock */
12227 +static inline int __raw_write_trylock(raw_rwlock_t *rw)
12228 +{
12229 + unsigned long flags;
12230 + int result = 0;
12231 +
12232 + raw_local_irq_save(flags);
12233 + if (__raw_spin_trylock(&rw->lock)) {
12234 + if (rw->counter == 0) {
12235 + rw->counter = -1;
12236 + result = 1;
12237 + } else {
12238 + /* Read-locked. Oh well. */
12239 + __raw_spin_unlock(&rw->lock);
12240 + }
12241 + }
12242 + raw_local_irq_restore(flags);
12243 +
12244 + return result;
12245 +}
12246 +
12247 +/*
12248 + * read_can_lock - would read_trylock() succeed?
12249 + * @lock: the rwlock in question.
12250 + */
12251 +static inline int __raw_read_can_lock(raw_rwlock_t *rw)
12252 +{
12253 + return rw->counter >= 0;
12254 +}
12255 +
12256 +/*
12257 + * write_can_lock - would write_trylock() succeed?
12258 + * @lock: the rwlock in question.
12259 + */
12260 +static inline int __raw_write_can_lock(raw_rwlock_t *rw)
12261 +{
12262 + return !rw->counter;
12263 +}
12264 +
12265 +#define __raw_read_lock_flags(lock, flags) __raw_read_lock(lock)
12266 +#define __raw_write_lock_flags(lock, flags) __raw_write_lock(lock)
12267 +
12268 +#define _raw_spin_relax(lock) cpu_relax()
12269 +#define _raw_read_relax(lock) cpu_relax()
12270 +#define _raw_write_relax(lock) cpu_relax()
12271 +
12272 +#endif /* _ASM_UBICOM32_SPINLOCK_H */
12273 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/spinlock_types.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/spinlock_types.h
12274 --- linux-2.6.30.10/arch/ubicom32/include/asm/spinlock_types.h 1970-01-01 02:00:00.000000000 +0200
12275 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/spinlock_types.h 2009-12-11 11:45:11.000000000 +0200
12276 @@ -0,0 +1,43 @@
12277 +/*
12278 + * arch/ubicom32/include/asm/spinlock_types.h
12279 + * Spinlock related structure definitions for Ubicom32 architecture.
12280 + *
12281 + * (C) Copyright 2009, Ubicom, Inc.
12282 + *
12283 + * This file is part of the Ubicom32 Linux Kernel Port.
12284 + *
12285 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12286 + * it and/or modify it under the terms of the GNU General Public License
12287 + * as published by the Free Software Foundation, either version 2 of the
12288 + * License, or (at your option) any later version.
12289 + *
12290 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12291 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12292 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12293 + * the GNU General Public License for more details.
12294 + *
12295 + * You should have received a copy of the GNU General Public License
12296 + * along with the Ubicom32 Linux Kernel Port. If not,
12297 + * see <http://www.gnu.org/licenses/>.
12298 + *
12299 + * Ubicom32 implementation derived from (with many thanks):
12300 + * arch/m68knommu
12301 + * arch/blackfin
12302 + * arch/parisc
12303 + */
12304 +#ifndef _ASM_UBICOM32_SPINLOCK_TYPES_H
12305 +#define _ASM_UBICOM32_SPINLOCK_TYPES_H
12306 +
12307 +typedef struct {
12308 + volatile unsigned int lock;
12309 +} raw_spinlock_t;
12310 +
12311 +typedef struct {
12312 + raw_spinlock_t lock;
12313 + volatile int counter;
12314 +} raw_rwlock_t;
12315 +
12316 +#define __RAW_SPIN_LOCK_UNLOCKED { 0 }
12317 +#define __RAW_RW_LOCK_UNLOCKED { __RAW_SPIN_LOCK_UNLOCKED, 0 }
12318 +
12319 +#endif /* _ASM_UBICOM32_SPINLOCK_TYPES_H */
12320 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/stacktrace.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/stacktrace.h
12321 --- linux-2.6.30.10/arch/ubicom32/include/asm/stacktrace.h 1970-01-01 02:00:00.000000000 +0200
12322 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/stacktrace.h 2009-12-11 11:45:11.000000000 +0200
12323 @@ -0,0 +1,72 @@
12324 +/*
12325 + * arch/ubicom32/include/asm/stacktrace.h
12326 + * Stacktrace functions for the Ubicom32 architecture.
12327 + *
12328 + * (C) Copyright 2009, Ubicom, Inc.
12329 + *
12330 + * This file is part of the Ubicom32 Linux Kernel Port.
12331 + *
12332 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12333 + * it and/or modify it under the terms of the GNU General Public License
12334 + * as published by the Free Software Foundation, either version 2 of the
12335 + * License, or (at your option) any later version.
12336 + *
12337 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12338 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12339 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12340 + * the GNU General Public License for more details.
12341 + *
12342 + * You should have received a copy of the GNU General Public License
12343 + * along with the Ubicom32 Linux Kernel Port. If not,
12344 + * see <http://www.gnu.org/licenses/>.
12345 + *
12346 + * Ubicom32 implementation derived from (with many thanks):
12347 + * arch/m68knommu
12348 + * arch/blackfin
12349 + * arch/parisc
12350 + */
12351 +#ifndef _ASM_UBICOM32_STACKTRACE_H
12352 +#define _ASM_UBICOM32_STACKTRACE_H
12353 +
12354 +#define between(a, b, c) (( \
12355 + ((unsigned long) a) >= ((unsigned long) b)) && \
12356 + (((unsigned long)a) <= ((unsigned long)c)))
12357 +
12358 +/*
12359 + * These symbols are filled in by the linker.
12360 + */
12361 +extern unsigned long _stext;
12362 +extern unsigned long _etext;
12363 +
12364 +/* OCM text goes from __ocm_text_run_begin to __data_begin */
12365 +extern unsigned long __ocm_text_run_begin;
12366 +extern unsigned long __data_begin;
12367 +
12368 +/* Account for OCM case - see stacktrace.c maybe combine(also trap.c) */
12369 +/*
12370 + * ubicom32_is_kernel()
12371 + *
12372 + * Check to see if the given address belongs to the kernel.
12373 + * NOMMU does not permit any other means.
12374 + */
12375 +static inline int ubicom32_is_kernel(unsigned long addr)
12376 +{
12377 + int is_kernel = between(addr, &_stext, &_etext) || \
12378 + between(addr, &__ocm_text_run_begin, &__data_begin);
12379 +
12380 +#ifdef CONFIG_MODULES
12381 + if (!is_kernel)
12382 + is_kernel = is_module_address(addr);
12383 +#endif
12384 + return is_kernel;
12385 +}
12386 +
12387 +extern unsigned long stacktrace_iterate(
12388 + unsigned long **trace,
12389 + unsigned long stext, unsigned long etext,
12390 + unsigned long ocm_stext, unsigned long ocm_etext,
12391 + unsigned long sstack, unsigned long estack);
12392 +#ifdef CONFIG_STACKTRACE
12393 +void stacktrace_save_entries(struct task_struct *tsk, struct stack_trace *trace, unsigned long sp);
12394 +#endif
12395 +#endif /* _ASM_UBICOM32_STACKTRACE_H */
12396 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/statfs.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/statfs.h
12397 --- linux-2.6.30.10/arch/ubicom32/include/asm/statfs.h 1970-01-01 02:00:00.000000000 +0200
12398 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/statfs.h 2009-12-11 11:45:11.000000000 +0200
12399 @@ -0,0 +1,33 @@
12400 +/*
12401 + * arch/ubicom32/include/asm/statfs.h
12402 + * Generic statfs.h definitions
12403 + *
12404 + * (C) Copyright 2009, Ubicom, Inc.
12405 + *
12406 + * This file is part of the Ubicom32 Linux Kernel Port.
12407 + *
12408 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12409 + * it and/or modify it under the terms of the GNU General Public License
12410 + * as published by the Free Software Foundation, either version 2 of the
12411 + * License, or (at your option) any later version.
12412 + *
12413 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12414 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12415 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12416 + * the GNU General Public License for more details.
12417 + *
12418 + * You should have received a copy of the GNU General Public License
12419 + * along with the Ubicom32 Linux Kernel Port. If not,
12420 + * see <http://www.gnu.org/licenses/>.
12421 + *
12422 + * Ubicom32 implementation derived from (with many thanks):
12423 + * arch/m68knommu
12424 + * arch/blackfin
12425 + * arch/parisc
12426 + */
12427 +#ifndef _ASM_UBICOM32_STATFS_H
12428 +#define _ASM_UBICOM32_STATFS_H
12429 +
12430 +#include <asm-generic/statfs.h>
12431 +
12432 +#endif /* _ASM_UBICOM32_STATFS_H */
12433 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/stat.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/stat.h
12434 --- linux-2.6.30.10/arch/ubicom32/include/asm/stat.h 1970-01-01 02:00:00.000000000 +0200
12435 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/stat.h 2009-12-11 11:45:11.000000000 +0200
12436 @@ -0,0 +1,104 @@
12437 +/*
12438 + * arch/ubicom32/include/asm/stat.h
12439 + * File status definitions for Ubicom32 architecture.
12440 + *
12441 + * (C) Copyright 2009, Ubicom, Inc.
12442 + *
12443 + * This file is part of the Ubicom32 Linux Kernel Port.
12444 + *
12445 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12446 + * it and/or modify it under the terms of the GNU General Public License
12447 + * as published by the Free Software Foundation, either version 2 of the
12448 + * License, or (at your option) any later version.
12449 + *
12450 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12451 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12452 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12453 + * the GNU General Public License for more details.
12454 + *
12455 + * You should have received a copy of the GNU General Public License
12456 + * along with the Ubicom32 Linux Kernel Port. If not,
12457 + * see <http://www.gnu.org/licenses/>.
12458 + *
12459 + * Ubicom32 implementation derived from (with many thanks):
12460 + * arch/m68knommu
12461 + * arch/blackfin
12462 + * arch/parisc
12463 + */
12464 +#ifndef _ASM_UBICOM32_STAT_H
12465 +#define _ASM_UBICOM32_STAT_H
12466 +
12467 +struct __old_kernel_stat {
12468 + unsigned short st_dev;
12469 + unsigned short st_ino;
12470 + unsigned short st_mode;
12471 + unsigned short st_nlink;
12472 + unsigned short st_uid;
12473 + unsigned short st_gid;
12474 + unsigned short st_rdev;
12475 + unsigned long st_size;
12476 + unsigned long st_atime;
12477 + unsigned long st_mtime;
12478 + unsigned long st_ctime;
12479 +};
12480 +
12481 +struct stat {
12482 + unsigned short st_dev;
12483 + unsigned short __pad1;
12484 + unsigned long st_ino;
12485 + unsigned short st_mode;
12486 + unsigned short st_nlink;
12487 + unsigned short st_uid;
12488 + unsigned short st_gid;
12489 + unsigned short st_rdev;
12490 + unsigned short __pad2;
12491 + unsigned long st_size;
12492 + unsigned long st_blksize;
12493 + unsigned long st_blocks;
12494 + unsigned long st_atime;
12495 + unsigned long __unused1;
12496 + unsigned long st_mtime;
12497 + unsigned long __unused2;
12498 + unsigned long st_ctime;
12499 + unsigned long __unused3;
12500 + unsigned long __unused4;
12501 + unsigned long __unused5;
12502 +};
12503 +
12504 +/* This matches struct stat64 in glibc2.1, hence the absolutely
12505 + * insane amounts of padding around dev_t's.
12506 + */
12507 +struct stat64 {
12508 + unsigned long long st_dev;
12509 + unsigned char __pad1[2];
12510 +
12511 +#define STAT64_HAS_BROKEN_ST_INO 1
12512 + unsigned long __st_ino;
12513 +
12514 + unsigned int st_mode;
12515 + unsigned int st_nlink;
12516 +
12517 + unsigned long st_uid;
12518 + unsigned long st_gid;
12519 +
12520 + unsigned long long st_rdev;
12521 + unsigned char __pad3[2];
12522 +
12523 + long long st_size;
12524 + unsigned long st_blksize;
12525 +
12526 + unsigned long long st_blocks; /* Number 512-byte blocks allocated. */
12527 +
12528 + unsigned long st_atime;
12529 + unsigned long st_atime_nsec;
12530 +
12531 + unsigned long st_mtime;
12532 + unsigned long st_mtime_nsec;
12533 +
12534 + unsigned long st_ctime;
12535 + unsigned long st_ctime_nsec;
12536 +
12537 + unsigned long long st_ino;
12538 +};
12539 +
12540 +#endif /* _ASM_UBICOM32_STAT_H */
12541 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/string.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/string.h
12542 --- linux-2.6.30.10/arch/ubicom32/include/asm/string.h 1970-01-01 02:00:00.000000000 +0200
12543 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/string.h 2009-12-11 11:45:11.000000000 +0200
12544 @@ -0,0 +1,40 @@
12545 +/*
12546 + * arch/ubicom32/include/asm/string.h
12547 + * String operation definitions for Ubicom32 architecture.
12548 + *
12549 + * (C) Copyright 2009, Ubicom, Inc.
12550 + *
12551 + * This file is part of the Ubicom32 Linux Kernel Port.
12552 + *
12553 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12554 + * it and/or modify it under the terms of the GNU General Public License
12555 + * as published by the Free Software Foundation, either version 2 of the
12556 + * License, or (at your option) any later version.
12557 + *
12558 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12559 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12560 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12561 + * the GNU General Public License for more details.
12562 + *
12563 + * You should have received a copy of the GNU General Public License
12564 + * along with the Ubicom32 Linux Kernel Port. If not,
12565 + * see <http://www.gnu.org/licenses/>.
12566 + *
12567 + * Ubicom32 implementation derived from (with many thanks):
12568 + * arch/m68knommu
12569 + * arch/blackfin
12570 + * arch/parisc
12571 + */
12572 +#ifndef _ASM_UBICOM32_STRING_H
12573 +#define _ASM_UBICOM32_STRING_H
12574 +
12575 +#define __HAVE_ARCH_MEMSET
12576 +extern void *memset(void *b, int c, size_t len);
12577 +
12578 +#define __HAVE_ARCH_MEMCPY
12579 +extern void *memcpy(void *to, const void *from, size_t len);
12580 +
12581 +#define __HAVE_ARCH_MEMMOVE
12582 +extern void * memmove(void *to, const void *from, size_t len);
12583 +
12584 +#endif /* _ASM_UBICOM32_STRING_H */
12585 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/swab.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/swab.h
12586 --- linux-2.6.30.10/arch/ubicom32/include/asm/swab.h 1970-01-01 02:00:00.000000000 +0200
12587 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/swab.h 2009-12-11 11:45:11.000000000 +0200
12588 @@ -0,0 +1,45 @@
12589 +/*
12590 + * arch/ubicom32/include/asm/byteorder.h
12591 + * Byte order swapping utility routines.
12592 + *
12593 + * (C) Copyright 2009, Ubicom, Inc.
12594 + *
12595 + * This file is part of the Ubicom32 Linux Kernel Port.
12596 + *
12597 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12598 + * it and/or modify it under the terms of the GNU General Public License
12599 + * as published by the Free Software Foundation, either version 2 of the
12600 + * License, or (at your option) any later version.
12601 + *
12602 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12603 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12604 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12605 + * the GNU General Public License for more details.
12606 + *
12607 + * You should have received a copy of the GNU General Public License
12608 + * along with the Ubicom32 Linux Kernel Port. If not,
12609 + * see <http://www.gnu.org/licenses/>.
12610 + *
12611 + * Ubicom32 implementation derived from (with many thanks):
12612 + * arch/m68knommu
12613 + * arch/blackfin
12614 + * arch/parisc
12615 + */
12616 +#ifndef _ASM_UBICOM32_BYTEORDER_H
12617 +#define _ASM_UBICOM32_BYTEORDER_H
12618 +
12619 +#include <linux/types.h>
12620 +
12621 +#if defined(__GNUC__) && !defined(__STRICT_ANSI__) || defined(__KERNEL__)
12622 +# define __BYTEORDER_HAS_U64__
12623 +# define __SWAB_64_THRU_32__
12624 +#endif
12625 +
12626 +#if defined(IP7000) || defined(IP7000_REV2)
12627 +
12628 +#define __arch__swab16 __builtin_ubicom32_swapb_2
12629 +#define __arch__swab32 __builtin_ubicom32_swapb_4
12630 +
12631 +#endif /* IP7000 */
12632 +
12633 +#endif /* _ASM_UBICOM32_BYTEORDER_H */
12634 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/switch-dev.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/switch-dev.h
12635 --- linux-2.6.30.10/arch/ubicom32/include/asm/switch-dev.h 1970-01-01 02:00:00.000000000 +0200
12636 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/switch-dev.h 2009-12-11 11:45:11.000000000 +0200
12637 @@ -0,0 +1,51 @@
12638 +/*
12639 + * arch/ubicom32/include/asm/switch-dev.h
12640 + * generic Ethernet switch platform data definitions for Ubicom32 architecture.
12641 + *
12642 + * (C) Copyright 2009, Ubicom, Inc.
12643 + *
12644 + * This file is part of the Ubicom32 Linux Kernel Port.
12645 + *
12646 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12647 + * it and/or modify it under the terms of the GNU General Public License
12648 + * as published by the Free Software Foundation, either version 2 of the
12649 + * License, or (at your option) any later version.
12650 + *
12651 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12652 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12653 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12654 + * the GNU General Public License for more details.
12655 + *
12656 + * You should have received a copy of the GNU General Public License
12657 + * along with the Ubicom32 Linux Kernel Port. If not,
12658 + * see <http://www.gnu.org/licenses/>.
12659 + *
12660 + * Ubicom32 implementation derived from (with many thanks):
12661 + * arch/m68knommu
12662 + * arch/blackfin
12663 + * arch/parisc
12664 + */
12665 +#ifndef _ASM_UBICOM32_SWITCH_DEV_H
12666 +#define _ASM_UBICOM32_SWITCH_DEV_H
12667 +
12668 +#define SWITCH_DEV_FLAG_HW_RESET 0x01
12669 +#define SWITCH_DEV_FLAG_SW_RESET 0x02
12670 +
12671 +struct switch_core_platform_data {
12672 + /*
12673 + * See flags above
12674 + */
12675 + u32_t flags;
12676 +
12677 + /*
12678 + * GPIO to use for nReset
12679 + */
12680 + int pin_reset;
12681 +
12682 + /*
12683 + * Name of this switch
12684 + */
12685 + const char *name;
12686 +};
12687 +
12688 +#endif /* _ASM_UBICOM32_SWITCH_DEV_H */
12689 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/system.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/system.h
12690 --- linux-2.6.30.10/arch/ubicom32/include/asm/system.h 1970-01-01 02:00:00.000000000 +0200
12691 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/system.h 2009-12-11 11:45:11.000000000 +0200
12692 @@ -0,0 +1,101 @@
12693 +/*
12694 + * arch/ubicom32/include/asm/system.h
12695 + * Low level switching definitions.
12696 + *
12697 + * (C) Copyright 2009, Ubicom, Inc.
12698 + *
12699 + * This file is part of the Ubicom32 Linux Kernel Port.
12700 + *
12701 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12702 + * it and/or modify it under the terms of the GNU General Public License
12703 + * as published by the Free Software Foundation, either version 2 of the
12704 + * License, or (at your option) any later version.
12705 + *
12706 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12707 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12708 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12709 + * the GNU General Public License for more details.
12710 + *
12711 + * You should have received a copy of the GNU General Public License
12712 + * along with the Ubicom32 Linux Kernel Port. If not,
12713 + * see <http://www.gnu.org/licenses/>.
12714 + *
12715 + * Ubicom32 implementation derived from (with many thanks):
12716 + * arch/m68knommu
12717 + * arch/blackfin
12718 + * arch/parisc
12719 + */
12720 +#ifndef _ASM_UBICOM32_SYSTEM_H
12721 +#define _ASM_UBICOM32_SYSTEM_H
12722 +
12723 +#include <linux/irqflags.h>
12724 +#include <linux/linkage.h>
12725 +#include <asm/segment.h>
12726 +#include <asm/entry.h>
12727 +#include <asm/ldsr.h>
12728 +#include <asm/irq.h>
12729 +#include <asm/percpu.h>
12730 +#include <asm/ubicom32-common.h>
12731 +#include <asm/processor.h>
12732 +
12733 +/*
12734 + * switch_to(n) should switch tasks to task ptr, first checking that
12735 + * ptr isn't the current task, in which case it does nothing.
12736 + */
12737 +asmlinkage void resume(void);
12738 +extern void *__switch_to(struct task_struct *prev,
12739 + struct thread_struct *prev_switch,
12740 + struct thread_struct *next_switch);
12741 +
12742 +/*
12743 + * We will need a per linux thread sw_ksp for the switch_to macro to
12744 + * track the kernel stack pointer for the current thread on that linux thread.
12745 + */
12746 +#define switch_to(prev,next,last) \
12747 +({ \
12748 + void *_last; \
12749 + _last = (void *) \
12750 + __switch_to(prev, &prev->thread, &next->thread); \
12751 + (last) = _last; \
12752 +})
12753 +
12754 +/*
12755 + * Force strict CPU ordering.
12756 + * Not really required on ubicom32...
12757 + */
12758 +#define nop() asm volatile ("nop"::)
12759 +#define mb() asm volatile ("" : : :"memory")
12760 +#define rmb() asm volatile ("" : : :"memory")
12761 +#define wmb() asm volatile ("" : : :"memory")
12762 +#define set_mb(var, value) ({ (var) = (value); wmb(); })
12763 +
12764 +#ifdef CONFIG_SMP
12765 +#define smp_mb() mb()
12766 +#define smp_rmb() rmb()
12767 +#define smp_wmb() wmb()
12768 +#define smp_read_barrier_depends() read_barrier_depends()
12769 +#else
12770 +#define smp_mb() mb()
12771 +#define smp_rmb() rmb()
12772 +#define smp_wmb() wmb()
12773 +#define smp_read_barrier_depends() do { } while(0)
12774 +#endif
12775 +
12776 +#define read_barrier_depends() ((void)0)
12777 +
12778 +/*
12779 + * The following defines change how the scheduler calls the switch_to()
12780 + * macro.
12781 + *
12782 + * 1) The first causes the runqueue to be unlocked on entry to
12783 + * switch_to(). Since our ctx code does not play with the runqueue
12784 + * we do not need it unlocked.
12785 + *
12786 + * 2) The later turns interrupts on during a ctxsw to reduce the latency of
12787 + * interrupts during ctx. At this point in the port, we believe that this
12788 + * latency is not a problem since we have very little code to perform a ctxsw.
12789 + */
12790 +// #define __ARCH_WANT_UNLOCKED_CTXSW
12791 +// #define __ARCH_WANT_INTERRUPTS_ON_CTXSW
12792 +
12793 +#endif /* _ASM_UBICOM32_SYSTEM_H */
12794 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/termbits.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/termbits.h
12795 --- linux-2.6.30.10/arch/ubicom32/include/asm/termbits.h 1970-01-01 02:00:00.000000000 +0200
12796 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/termbits.h 2009-12-11 11:45:11.000000000 +0200
12797 @@ -0,0 +1,227 @@
12798 +/*
12799 + * arch/ubicom32/include/asm/termbits.h
12800 + * Terminal/serial port definitions for Ubicom32 architecture.
12801 + *
12802 + * (C) Copyright 2009, Ubicom, Inc.
12803 + *
12804 + * This file is part of the Ubicom32 Linux Kernel Port.
12805 + *
12806 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
12807 + * it and/or modify it under the terms of the GNU General Public License
12808 + * as published by the Free Software Foundation, either version 2 of the
12809 + * License, or (at your option) any later version.
12810 + *
12811 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
12812 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
12813 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12814 + * the GNU General Public License for more details.
12815 + *
12816 + * You should have received a copy of the GNU General Public License
12817 + * along with the Ubicom32 Linux Kernel Port. If not,
12818 + * see <http://www.gnu.org/licenses/>.
12819 + *
12820 + * Ubicom32 implementation derived from (with many thanks):
12821 + * arch/m68knommu
12822 + * arch/blackfin
12823 + * arch/parisc
12824 + */
12825 +#ifndef _ASM_UBICOM32_TERMBITS_H
12826 +#define _ASM_UBICOM32_TERMBITS_H
12827 +
12828 +#include <linux/posix_types.h>
12829 +
12830 +typedef unsigned char cc_t;
12831 +typedef unsigned int speed_t;
12832 +typedef unsigned int tcflag_t;
12833 +
12834 +#define NCCS 19
12835 +struct termios {
12836 + tcflag_t c_iflag; /* input mode flags */
12837 + tcflag_t c_oflag; /* output mode flags */
12838 + tcflag_t c_cflag; /* control mode flags */
12839 + tcflag_t c_lflag; /* local mode flags */
12840 + cc_t c_line; /* line discipline */
12841 + cc_t c_cc[NCCS]; /* control characters */
12842 +};
12843 +
12844 +struct termios2 {
12845 + tcflag_t c_iflag; /* input mode flags */
12846 + tcflag_t c_oflag; /* output mode flags */
12847 + tcflag_t c_cflag; /* control mode flags */
12848 + tcflag_t c_lflag; /* local mode flags */
12849 + cc_t c_line; /* line discipline */
12850 + cc_t c_cc[NCCS]; /* control characters */
12851 + speed_t c_ispeed; /* input speed */
12852 + speed_t c_ospeed; /* output speed */
12853 +};
12854 +
12855 +struct ktermios {
12856 + tcflag_t c_iflag; /* input mode flags */
12857 + tcflag_t c_oflag; /* output mode flags */
12858 + tcflag_t c_cflag; /* control mode flags */
12859 + tcflag_t c_lflag; /* local mode flags */
12860 + cc_t c_line; /* line discipline */
12861 + cc_t c_cc[NCCS]; /* control characters */
12862 + speed_t c_ispeed; /* input speed */
12863 + speed_t c_ospeed; /* output speed */
12864 +};
12865 +
12866 +/* c_cc characters */
12867 +#define VINTR 0
12868 +#define VQUIT 1
12869 +#define VERASE 2
12870 +#define VKILL 3
12871 +#define VEOF 4
12872 +#define VTIME 5
12873 +#define VMIN 6
12874 +#define VSWTC 7
12875 +#define VSTART 8
12876 +#define VSTOP 9
12877 +#define VSUSP 10
12878 +#define VEOL 11
12879 +#define VREPRINT 12
12880 +#define VDISCARD 13
12881 +#define VWERASE 14
12882 +#define VLNEXT 15
12883 +#define VEOL2 16
12884 +
12885 +
12886 +/* c_iflag bits */
12887 +#define IGNBRK 0000001
12888 +#define BRKINT 0000002
12889 +#define IGNPAR 0000004
12890 +#define PARMRK 0000010
12891 +#define INPCK 0000020
12892 +#define ISTRIP 0000040
12893 +#define INLCR 0000100
12894 +#define IGNCR 0000200
12895 +#define ICRNL 0000400
12896 +#define IUCLC 0001000
12897 +#define IXON 0002000
12898 +#define IXANY 0004000
12899 +#define IXOFF 0010000
12900 +#define IMAXBEL 0020000
12901 +#define IUTF8 0040000
12902 +
12903 +/* c_oflag bits */
12904 +#define OPOST 0000001
12905 +#define OLCUC 0000002
12906 +#define ONLCR 0000004
12907 +#define OCRNL 0000010
12908 +#define ONOCR 0000020
12909 +#define ONLRET 0000040
12910 +#define OFILL 0000100
12911 +#define OFDEL 0000200
12912 +#define NLDLY 0000400
12913 +#define NL0 0000000
12914 +#define NL1 0000400
12915 +#define CRDLY 0003000
12916 +#define CR0 0000000
12917 +#define CR1 0001000
12918 +#define CR2 0002000
12919 +#define CR3 0003000
12920 +#define TABDLY 0014000
12921 +#define TAB0 0000000
12922 +#define TAB1 0004000
12923 +#define TAB2 0010000
12924 +#define TAB3 0014000
12925 +#define XTABS 0014000
12926 +#define BSDLY 0020000
12927 +#define BS0 0000000
12928 +#define BS1 0020000
12929 +#define VTDLY 0040000
12930 +#define VT0 0000000
12931 +#define VT1 0040000
12932 +#define FFDLY 0100000
12933 +#define FF0 0000000
12934 +#define FF1 0100000
12935 +
12936 +/* c_cflag bit meaning */
12937 +#define CBAUD 0010017
12938 +#define B0 0000000 /* hang up */
12939 +#define B50 0000001
12940 +#define B75 0000002
12941 +#define B110 0000003
12942 +#define B134 0000004
12943 +#define B150 0000005
12944 +#define B200 0000006
12945 +#define B300 0000007
12946 +#define B600 0000010
12947 +#define B1200 0000011
12948 +#define B1800 0000012
12949 +#define B2400 0000013
12950 +#define B4800 0000014
12951 +#define B9600 0000015
12952 +#define B19200 0000016
12953 +#define B38400 0000017
12954 +#define EXTA B19200
12955 +#define EXTB B38400
12956 +#define CSIZE 0000060
12957 +#define CS5 0000000
12958 +#define CS6 0000020
12959 +#define CS7 0000040
12960 +#define CS8 0000060
12961 +#define CSTOPB 0000100
12962 +#define CREAD 0000200
12963 +#define PARENB 0000400
12964 +#define PARODD 0001000
12965 +#define HUPCL 0002000
12966 +#define CLOCAL 0004000
12967 +#define CBAUDEX 0010000
12968 +#define BOTHER 0010000
12969 +#define B57600 0010001
12970 +#define B115200 0010002
12971 +#define B230400 0010003
12972 +#define B460800 0010004
12973 +#define B500000 0010005
12974 +#define B576000 0010006
12975 +#define B921600 0010007
12976 +#define B1000000 0010010
12977 +#define B1152000 0010011
12978 +#define B1500000 0010012
12979 +#define B2000000 0010013
12980 +#define B2500000 0010014
12981 +#define B3000000 0010015
12982 +#define B3500000 0010016
12983 +#define B4000000 0010017
12984 +#define CIBAUD 002003600000 /* input baud rate */
12985 +#define CMSPAR 010000000000 /* mark or space (stick) parity */
12986 +#define CRTSCTS 020000000000 /* flow control */
12987 +
12988 +#define IBSHIFT 16 /* Shift from CBAUD to CIBAUD */
12989 +
12990 +/* c_lflag bits */
12991 +#define ISIG 0000001
12992 +#define ICANON 0000002
12993 +#define XCASE 0000004
12994 +#define ECHO 0000010
12995 +#define ECHOE 0000020
12996 +#define ECHOK 0000040
12997 +#define ECHONL 0000100
12998 +#define NOFLSH 0000200
12999 +#define TOSTOP 0000400
13000 +#define ECHOCTL 0001000
13001 +#define ECHOPRT 0002000
13002 +#define ECHOKE 0004000
13003 +#define FLUSHO 0010000
13004 +#define PENDIN 0040000
13005 +#define IEXTEN 0100000
13006 +
13007 +
13008 +/* tcflow() and TCXONC use these */
13009 +#define TCOOFF 0
13010 +#define TCOON 1
13011 +#define TCIOFF 2
13012 +#define TCION 3
13013 +
13014 +/* tcflush() and TCFLSH use these */
13015 +#define TCIFLUSH 0
13016 +#define TCOFLUSH 1
13017 +#define TCIOFLUSH 2
13018 +
13019 +/* tcsetattr uses these */
13020 +#define TCSANOW 0
13021 +#define TCSADRAIN 1
13022 +#define TCSAFLUSH 2
13023 +
13024 +#endif /* _ASM_UBICOM32_TERMBITS_H */
13025 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/termios.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/termios.h
13026 --- linux-2.6.30.10/arch/ubicom32/include/asm/termios.h 1970-01-01 02:00:00.000000000 +0200
13027 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/termios.h 2009-12-11 11:45:11.000000000 +0200
13028 @@ -0,0 +1,119 @@
13029 +/*
13030 + * arch/ubicom32/include/asm/termios.h
13031 + * Ubicom32 termio definitions.
13032 + *
13033 + * (C) Copyright 2009, Ubicom, Inc.
13034 + *
13035 + * This file is part of the Ubicom32 Linux Kernel Port.
13036 + *
13037 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13038 + * it and/or modify it under the terms of the GNU General Public License
13039 + * as published by the Free Software Foundation, either version 2 of the
13040 + * License, or (at your option) any later version.
13041 + *
13042 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13043 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13044 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13045 + * the GNU General Public License for more details.
13046 + *
13047 + * You should have received a copy of the GNU General Public License
13048 + * along with the Ubicom32 Linux Kernel Port. If not,
13049 + * see <http://www.gnu.org/licenses/>.
13050 + *
13051 + * Ubicom32 implementation derived from (with many thanks):
13052 + * arch/m68knommu
13053 + * arch/blackfin
13054 + * arch/parisc
13055 + */
13056 +#ifndef _ASM_UBICOM32_TERMIOS_H
13057 +#define _ASM_UBICOM32_TERMIOS_H
13058 +
13059 +#include <asm/termbits.h>
13060 +#include <asm/ioctls.h>
13061 +
13062 +struct winsize {
13063 + unsigned short ws_row;
13064 + unsigned short ws_col;
13065 + unsigned short ws_xpixel;
13066 + unsigned short ws_ypixel;
13067 +};
13068 +
13069 +#define NCC 8
13070 +struct termio {
13071 + unsigned short c_iflag; /* input mode flags */
13072 + unsigned short c_oflag; /* output mode flags */
13073 + unsigned short c_cflag; /* control mode flags */
13074 + unsigned short c_lflag; /* local mode flags */
13075 + unsigned char c_line; /* line discipline */
13076 + unsigned char c_cc[NCC]; /* control characters */
13077 +};
13078 +
13079 +#ifdef __KERNEL__
13080 +/* intr=^C quit=^| erase=del kill=^U
13081 + eof=^D vtime=\0 vmin=\1 sxtc=\0
13082 + start=^Q stop=^S susp=^Z eol=\0
13083 + reprint=^R discard=^U werase=^W lnext=^V
13084 + eol2=\0
13085 +*/
13086 +#define INIT_C_CC "\003\034\177\025\004\0\1\0\021\023\032\0\022\017\027\026\0"
13087 +#endif
13088 +
13089 +/* modem lines */
13090 +#define TIOCM_LE 0x001
13091 +#define TIOCM_DTR 0x002
13092 +#define TIOCM_RTS 0x004
13093 +#define TIOCM_ST 0x008
13094 +#define TIOCM_SR 0x010
13095 +#define TIOCM_CTS 0x020
13096 +#define TIOCM_CAR 0x040
13097 +#define TIOCM_RNG 0x080
13098 +#define TIOCM_DSR 0x100
13099 +#define TIOCM_CD TIOCM_CAR
13100 +#define TIOCM_RI TIOCM_RNG
13101 +#define TIOCM_OUT1 0x2000
13102 +#define TIOCM_OUT2 0x4000
13103 +#define TIOCM_LOOP 0x8000
13104 +
13105 +/* ioctl (fd, TIOCSERGETLSR, &result) where result may be as below */
13106 +
13107 +#ifdef __KERNEL__
13108 +
13109 +/*
13110 + * Translate a "termio" structure into a "termios". Ugh.
13111 + */
13112 +#define user_termio_to_kernel_termios(termios, termio) \
13113 +({ \
13114 + unsigned short tmp; \
13115 + get_user(tmp, &(termio)->c_iflag); \
13116 + (termios)->c_iflag = (0xffff0000 & ((termios)->c_iflag)) | tmp; \
13117 + get_user(tmp, &(termio)->c_oflag); \
13118 + (termios)->c_oflag = (0xffff0000 & ((termios)->c_oflag)) | tmp; \
13119 + get_user(tmp, &(termio)->c_cflag); \
13120 + (termios)->c_cflag = (0xffff0000 & ((termios)->c_cflag)) | tmp; \
13121 + get_user(tmp, &(termio)->c_lflag); \
13122 + (termios)->c_lflag = (0xffff0000 & ((termios)->c_lflag)) | tmp; \
13123 + get_user((termios)->c_line, &(termio)->c_line); \
13124 + copy_from_user((termios)->c_cc, (termio)->c_cc, NCC); \
13125 +})
13126 +
13127 +/*
13128 + * Translate a "termios" structure into a "termio". Ugh.
13129 + */
13130 +#define kernel_termios_to_user_termio(termio, termios) \
13131 +({ \
13132 + put_user((termios)->c_iflag, &(termio)->c_iflag); \
13133 + put_user((termios)->c_oflag, &(termio)->c_oflag); \
13134 + put_user((termios)->c_cflag, &(termio)->c_cflag); \
13135 + put_user((termios)->c_lflag, &(termio)->c_lflag); \
13136 + put_user((termios)->c_line, &(termio)->c_line); \
13137 + copy_to_user((termio)->c_cc, (termios)->c_cc, NCC); \
13138 +})
13139 +
13140 +#define user_termios_to_kernel_termios(k, u) copy_from_user(k, u, sizeof(struct termios2))
13141 +#define kernel_termios_to_user_termios(u, k) copy_to_user(u, k, sizeof(struct termios2))
13142 +#define user_termios_to_kernel_termios_1(k, u) copy_from_user(k, u, sizeof(struct termios))
13143 +#define kernel_termios_to_user_termios_1(u, k) copy_to_user(u, k, sizeof(struct termios))
13144 +
13145 +#endif /* __KERNEL__ */
13146 +
13147 +#endif /* _ASM_UBICOM32_TERMIOS_H */
13148 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/thread-asm.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread-asm.h
13149 --- linux-2.6.30.10/arch/ubicom32/include/asm/thread-asm.h 1970-01-01 02:00:00.000000000 +0200
13150 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread-asm.h 2009-12-11 11:45:11.000000000 +0200
13151 @@ -0,0 +1,51 @@
13152 +/*
13153 + * arch/ubicom32/include/asm/thread-asm.h
13154 + * Ubicom32 architecture specific thread definitions.
13155 + *
13156 + * (C) Copyright 2009, Ubicom, Inc.
13157 + *
13158 + * This file is part of the Ubicom32 Linux Kernel Port.
13159 + *
13160 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13161 + * it and/or modify it under the terms of the GNU General Public License
13162 + * as published by the Free Software Foundation, either version 2 of the
13163 + * License, or (at your option) any later version.
13164 + *
13165 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13166 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13167 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13168 + * the GNU General Public License for more details.
13169 + *
13170 + * You should have received a copy of the GNU General Public License
13171 + * along with the Ubicom32 Linux Kernel Port. If not,
13172 + * see <http://www.gnu.org/licenses/>.
13173 + *
13174 + * Ubicom32 implementation derived from (with many thanks):
13175 + * arch/m68knommu
13176 + * arch/blackfin
13177 + * arch/parisc
13178 + */
13179 +#ifndef _ASM_UBICOM32_THREAD_ASM_H
13180 +#define _ASM_UBICOM32_THREAD_ASM_H
13181 +
13182 +/*
13183 + * thread_get_self
13184 + * Read and shift the current thread into reg
13185 + *
13186 + * Note that we don't need to mask the result as bits 6 through 31 of the
13187 + * ROSR are zeroes.
13188 + */
13189 +.macro thread_get_self reg
13190 + lsr.4 \reg, ROSR, #2
13191 +.endm
13192 +
13193 +/*
13194 + * thread_get_self_mask
13195 + * Read and shift the current thread mask into reg
13196 + */
13197 +.macro thread_get_self_mask reg
13198 + lsr.4 \reg, ROSR, #2
13199 + lsl.4 \reg, #1, \reg /* Thread bit */
13200 +.endm
13201 +
13202 +#endif /* _ASM_UBICOM32_THREAD_ASM_H */
13203 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/thread.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread.h
13204 --- linux-2.6.30.10/arch/ubicom32/include/asm/thread.h 1970-01-01 02:00:00.000000000 +0200
13205 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread.h 2009-12-11 11:45:11.000000000 +0200
13206 @@ -0,0 +1,320 @@
13207 +/*
13208 + * arch/ubicom32/include/asm/thread.h
13209 + * Ubicom32 architecture specific thread definitions.
13210 + *
13211 + * (C) Copyright 2009, Ubicom, Inc.
13212 + *
13213 + * This file is part of the Ubicom32 Linux Kernel Port.
13214 + *
13215 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13216 + * it and/or modify it under the terms of the GNU General Public License
13217 + * as published by the Free Software Foundation, either version 2 of the
13218 + * License, or (at your option) any later version.
13219 + *
13220 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13221 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13222 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13223 + * the GNU General Public License for more details.
13224 + *
13225 + * You should have received a copy of the GNU General Public License
13226 + * along with the Ubicom32 Linux Kernel Port. If not,
13227 + * see <http://www.gnu.org/licenses/>.
13228 + *
13229 + * Ubicom32 implementation derived from (with many thanks):
13230 + * arch/m68knommu
13231 + * arch/blackfin
13232 + * arch/parisc
13233 + */
13234 +#ifndef _ASM_UBICOM32_THREAD_H
13235 +#define _ASM_UBICOM32_THREAD_H
13236 +
13237 +#if !defined(__ASSEMBLY__)
13238 +
13239 +#include <asm/ptrace.h>
13240 +#include <asm/ubicom32-common.h>
13241 +
13242 +typedef int thread_t;
13243 +typedef unsigned char thread_type_t;
13244 +typedef void (*thread_exec_fn_t)(void *arg);
13245 +
13246 +#define THREAD_NULL 0x40
13247 +#define THREAD_TYPE_HRT (1 << 0)
13248 +#define THREAD_TYPE_SPECIAL 0
13249 +#define THREAD_TYPE_NORMAL 0
13250 +#define THREAD_TYPE_BACKGROUND (1 << 1)
13251 +
13252 +/*
13253 + * This is the upper bound on the maximum hardware threads that one will find
13254 + * on a Ubicom processor. It is used to size per hardware thread data structures.
13255 + */
13256 +#define THREAD_ARCHITECTURAL_MAX 16
13257 +
13258 +/*
13259 + * TODO: Rename this at some point to be thread_
13260 + */
13261 +extern unsigned int sw_ksp[THREAD_ARCHITECTURAL_MAX];
13262 +
13263 +
13264 +/*
13265 + * thread_get_self()
13266 + */
13267 +static inline thread_t thread_get_self(void)
13268 +{
13269 + thread_t result;
13270 +
13271 + /*
13272 + * Note that ROSR has zeroes in bits 6 through 31 and so we don't need
13273 + * to do any additional bit masking here.
13274 + */
13275 + asm (
13276 + "lsr.4 %0, ROSR, #2 \n\t"
13277 + : "=d" (result)
13278 + :
13279 + : "cc"
13280 + );
13281 +
13282 + return result;
13283 +}
13284 +
13285 +/*
13286 + * thread_suspend()
13287 + */
13288 +static inline void thread_suspend(void)
13289 +{
13290 + asm volatile (
13291 + "suspend\n\t"
13292 + :
13293 + :
13294 + );
13295 +}
13296 +
13297 +/*
13298 + * thread_resume()
13299 + */
13300 +static inline void thread_resume(thread_t thread)
13301 +{
13302 + asm volatile (
13303 + "move.4 MT_ACTIVE_SET, %0 \n\t"
13304 + "pipe_flush 0 \n\t"
13305 + "pipe_flush 0 \n\t"
13306 + :
13307 + : "d" (1 << thread)
13308 + );
13309 +}
13310 +
13311 +
13312 +
13313 +/*
13314 + * thread_enable_mask()
13315 + * Enable all threads in the mask.
13316 + *
13317 + * All writes to MT_EN must be protected by the MT_EN_LOCK bit
13318 + */
13319 +static inline void thread_enable_mask(unsigned int mask)
13320 +{
13321 + /*
13322 + * must flush the pipeline twice.
13323 + * first pipe_flush is to ensure write to MT_EN is completed
13324 + * second one is to ensure any new instructions from
13325 + * the targeted thread (the one being disabled), that
13326 + * are issued while the write to MT_EN is being executed,
13327 + * are completed.
13328 + */
13329 + UBICOM32_LOCK(MT_EN_LOCK_BIT);
13330 + asm volatile (
13331 + "or.4 MT_EN, MT_EN, %0 \n\t"
13332 + "pipe_flush 0 \n\t"
13333 + "pipe_flush 0 \n\t"
13334 + :
13335 + : "d" (mask)
13336 + : "cc"
13337 + );
13338 + UBICOM32_UNLOCK(MT_EN_LOCK_BIT);
13339 +}
13340 +
13341 +/*
13342 + * thread_enable()
13343 + */
13344 +static inline void thread_enable(thread_t thread)
13345 +{
13346 + thread_enable_mask(1 << thread);
13347 +}
13348 +
13349 +/*
13350 + * thread_disable_mask()
13351 + * Disable all threads in the mask.
13352 + *
13353 + * All writes to MT_EN must be protected by the MT_EN_LOCK bit
13354 + */
13355 +static inline void thread_disable_mask(unsigned int mask)
13356 +{
13357 + /*
13358 + * must flush the pipeline twice.
13359 + * first pipe_flush is to ensure write to MT_EN is completed
13360 + * second one is to ensure any new instructions from
13361 + * the targeted thread (the one being disabled), that
13362 + * are issued while the write to MT_EN is being executed,
13363 + * are completed.
13364 + */
13365 + UBICOM32_LOCK(MT_EN_LOCK_BIT);
13366 + asm volatile (
13367 + "and.4 MT_EN, MT_EN, %0 \n\t"
13368 + "pipe_flush 0 \n\t"
13369 + "pipe_flush 0 \n\t"
13370 + :
13371 + : "d" (~mask)
13372 + : "cc"
13373 + );
13374 + UBICOM32_UNLOCK(MT_EN_LOCK_BIT);
13375 +}
13376 +
13377 +/*
13378 + * thread_disable()
13379 + */
13380 +static inline void thread_disable(thread_t thread)
13381 +{
13382 + thread_disable_mask(1 << thread);
13383 +}
13384 +
13385 +/*
13386 + * thread_disable_others()
13387 + * Disable all other threads
13388 + */
13389 +static inline void thread_disable_others(void)
13390 +{
13391 + thread_t self = thread_get_self();
13392 + thread_disable_mask(~(1 << self));
13393 +}
13394 +
13395 +/*
13396 + * thread_is_trapped()
13397 + * Is the specified tid trapped?
13398 + */
13399 +static inline int thread_is_trapped(thread_t tid)
13400 +{
13401 + int thread_mask = (1 << tid);
13402 + int trap_thread;
13403 +
13404 + asm (
13405 + "move.4 %0, MT_TRAP \n\t"
13406 + : "=d" (trap_thread)
13407 + :
13408 + );
13409 + return (trap_thread & thread_mask);
13410 +}
13411 +
13412 +/*
13413 + * thread_is_enabled()
13414 + * Is the specified tid enabled?
13415 + */
13416 +static inline int thread_is_enabled(thread_t tid)
13417 +{
13418 + int thread_mask = (1 << tid);
13419 + int enabled_threads;
13420 +
13421 + asm (
13422 + "move.4 %0, MT_EN \n\t"
13423 + : "=d" (enabled_threads)
13424 + :
13425 + );
13426 + return (enabled_threads & thread_mask);
13427 +}
13428 +
13429 +/*
13430 + * thread_get_instruction_count()
13431 + */
13432 +static inline unsigned int thread_get_instruction_count(void)
13433 +{
13434 + unsigned int result;
13435 + asm (
13436 + "move.4 %0, INST_CNT \n\t"
13437 + : "=r" (result)
13438 + );
13439 + return result;
13440 +}
13441 +
13442 +/*
13443 + * thread_get_pc()
13444 + * pc could point to a speculative and cancelled instruction unless thread is disabled
13445 + */
13446 +static inline void *thread_get_pc(thread_t thread)
13447 +{
13448 + void *result;
13449 + asm (
13450 + "move.4 csr, %1 \n\t"
13451 + "setcsr_flush 0 \n\t"
13452 + "move.4 %0, pc \n\t"
13453 + "move.4 csr, #0 \n\t"
13454 + "setcsr_flush 0 \n\t"
13455 + : "=r" (result)
13456 + : "r" ((thread << 9) | (1 << 8))
13457 + );
13458 + return result;
13459 +}
13460 +
13461 +/*
13462 + * thread_get_trap_cause()
13463 + * This should be called only when the thread is not running
13464 + */
13465 +static inline unsigned int thread_get_trap_cause(thread_t thread)
13466 +{
13467 + unsigned int result;
13468 + asm (
13469 + "move.4 csr, %1 \n\t"
13470 + "setcsr_flush 0 \n\t"
13471 + "move.4 %0, trap_cause \n\t"
13472 + "move.4 csr, #0 \n\t"
13473 + "setcsr_flush 0 \n\t"
13474 + : "=r" (result)
13475 + : "r" ((thread << 9) | (1 << 8))
13476 + );
13477 + return result;
13478 +}
13479 +
13480 +/*
13481 + * THREAD_STALL macro.
13482 + */
13483 +#define THREAD_STALL \
13484 + asm volatile ( \
13485 + "move.4 mt_dbg_active_clr, #-1 \n\t" \
13486 + "pipe_flush 0 \n\t" \
13487 + : \
13488 + : \
13489 + )
13490 +
13491 +extern unsigned int thread_get_mainline(void);
13492 +extern void thread_set_mainline(thread_t tid);
13493 +extern thread_t thread_alloc(void);
13494 +extern thread_t thread_start(thread_t thread, thread_exec_fn_t exec, void *arg, unsigned int *sp_high, thread_type_t type);
13495 +
13496 +/*
13497 + * asm macros
13498 + */
13499 +asm (
13500 +/*
13501 + * thread_get_self
13502 + * Read and shift the current thread into reg
13503 + *
13504 + * Note that we don't need to mask the result as bits 6 through 31 of the
13505 + * ROSR are zeroes.
13506 + */
13507 +".macro thread_get_self reg \n\t"
13508 +" lsr.4 \\reg, ROSR, #2 \n\t"
13509 +".endm \n\t"
13510 +
13511 +/*
13512 + * thread_get_self_mask
13513 + * Read and shift the current thread mask into reg
13514 + */
13515 +".macro thread_get_self_mask reg \n\t"
13516 +" lsr.4 \\reg, ROSR, #2 \n\t"
13517 +" lsl.4 \\reg, #1, \\reg \n\t" /* Thread bit */
13518 +".endm \n\t"
13519 +);
13520 +
13521 +#else /* __ASSEMBLY__ */
13522 +
13523 +#include <asm/thread-asm.h>
13524 +
13525 +#endif /* __ASSEMBLY__ */
13526 +#endif /* _ASM_UBICOM32_THREAD_H */
13527 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/thread_info.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread_info.h
13528 --- linux-2.6.30.10/arch/ubicom32/include/asm/thread_info.h 1970-01-01 02:00:00.000000000 +0200
13529 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/thread_info.h 2009-12-11 11:45:11.000000000 +0200
13530 @@ -0,0 +1,134 @@
13531 +/*
13532 + * arch/ubicom32/include/asm/thread_info.h
13533 + * Ubicom32 architecture low-level thread information.
13534 + *
13535 + * (C) Copyright 2009, Ubicom, Inc.
13536 + * Adapted from the i386 and PPC versions by Greg Ungerer (gerg@snapgear.com)
13537 + * Copyright (C) 2002 David Howells (dhowells@redhat.com)
13538 + * - Incorporating suggestions made by Linus Torvalds and Dave Miller
13539 + *
13540 + * This file is part of the Ubicom32 Linux Kernel Port.
13541 + *
13542 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13543 + * it and/or modify it under the terms of the GNU General Public License
13544 + * as published by the Free Software Foundation, either version 2 of the
13545 + * License, or (at your option) any later version.
13546 + *
13547 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13548 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13549 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13550 + * the GNU General Public License for more details.
13551 + *
13552 + * You should have received a copy of the GNU General Public License
13553 + * along with the Ubicom32 Linux Kernel Port. If not,
13554 + * see <http://www.gnu.org/licenses/>.
13555 + *
13556 + * Ubicom32 implementation derived from (with many thanks):
13557 + * arch/m68knommu
13558 + * arch/blackfin
13559 + * arch/parisc
13560 + */
13561 +
13562 +#ifndef _ASM_UBICOM32_THREAD_INFO_H
13563 +#define _ASM_UBICOM32_THREAD_INFO_H
13564 +
13565 +#include <asm/page.h>
13566 +
13567 +/*
13568 + * Size of kernel stack for each process. This must be a power of 2...
13569 + */
13570 +#ifdef CONFIG_4KSTACKS
13571 +#define THREAD_SIZE_ORDER (0)
13572 +#else
13573 +#define THREAD_SIZE_ORDER (1)
13574 +#endif
13575 +
13576 +/*
13577 + * for asm files, THREAD_SIZE is now generated by asm-offsets.c
13578 + */
13579 +#define THREAD_SIZE (PAGE_SIZE<<THREAD_SIZE_ORDER)
13580 +
13581 +#ifdef __KERNEL__
13582 +
13583 +#ifndef __ASSEMBLY__
13584 +
13585 +/*
13586 + * low level task data.
13587 + */
13588 +struct thread_info {
13589 + struct task_struct *task; /* main task structure */
13590 + struct exec_domain *exec_domain; /* execution domain */
13591 + unsigned long flags; /* low level flags */
13592 + int cpu; /* cpu we're on */
13593 + int preempt_count; /* 0 => preemptable, <0 => BUG */
13594 + int interrupt_nesting; /* Interrupt nesting level. */
13595 + struct restart_block restart_block;
13596 +};
13597 +
13598 +/*
13599 + * macros/functions for gaining access to the thread information structure
13600 + */
13601 +#define INIT_THREAD_INFO(tsk) \
13602 +{ \
13603 + .task = &tsk, \
13604 + .exec_domain = &default_exec_domain, \
13605 + .flags = 0, \
13606 + .cpu = 0, \
13607 + .interrupt_nesting = 0, \
13608 + .restart_block = { \
13609 + .fn = do_no_restart_syscall, \
13610 + }, \
13611 +}
13612 +
13613 +#define init_thread_info (init_thread_union.thread_info)
13614 +#define init_stack (init_thread_union.stack)
13615 +
13616 +
13617 +/* how to get the thread information struct from C */
13618 +static inline struct thread_info *current_thread_info(void)
13619 +{
13620 + struct thread_info *ti;
13621 +
13622 + asm (
13623 + "and.4 %0, sp, %1\n\t"
13624 + : "=&r" (ti)
13625 + : "d" (~(THREAD_SIZE-1))
13626 + : "cc"
13627 + );
13628 +
13629 + return ti;
13630 +}
13631 +
13632 +#define STACK_WARN (THREAD_SIZE / 8)
13633 +
13634 +#define __HAVE_ARCH_THREAD_INFO_ALLOCATOR 1
13635 +
13636 +/* thread information allocation */
13637 +#define alloc_thread_info(tsk) ((struct thread_info *) \
13638 + __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER))
13639 +#define free_thread_info(ti) free_pages((unsigned long) (ti), THREAD_SIZE_ORDER)
13640 +#endif /* __ASSEMBLY__ */
13641 +
13642 +#define PREEMPT_ACTIVE 0x4000000
13643 +
13644 +/*
13645 + * thread information flag bit numbers
13646 + */
13647 +#define TIF_SYSCALL_TRACE 0 /* syscall trace active */
13648 +#define TIF_SIGPENDING 1 /* signal pending */
13649 +#define TIF_NEED_RESCHED 2 /* rescheduling necessary */
13650 +#define TIF_POLLING_NRFLAG 3 /* true if poll_idle() is polling
13651 + TIF_NEED_RESCHED */
13652 +#define TIF_MEMDIE 4
13653 +
13654 +/* as above, but as bit values */
13655 +#define _TIF_SYSCALL_TRACE (1<<TIF_SYSCALL_TRACE)
13656 +#define _TIF_SIGPENDING (1<<TIF_SIGPENDING)
13657 +#define _TIF_NEED_RESCHED (1<<TIF_NEED_RESCHED)
13658 +#define _TIF_POLLING_NRFLAG (1<<TIF_POLLING_NRFLAG)
13659 +
13660 +#define _TIF_WORK_MASK 0x0000FFFE /* work to do on interrupt/exception return */
13661 +
13662 +#endif /* __KERNEL__ */
13663 +
13664 +#endif /* _ASM_UBICOM32_THREAD_INFO_H */
13665 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/timex.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/timex.h
13666 --- linux-2.6.30.10/arch/ubicom32/include/asm/timex.h 1970-01-01 02:00:00.000000000 +0200
13667 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/timex.h 2009-12-11 11:45:11.000000000 +0200
13668 @@ -0,0 +1,56 @@
13669 +/*
13670 + * arch/ubicom32/include/asm/timex.h
13671 + * Ubicom32 architecture timex specifications.
13672 + *
13673 + * (C) Copyright 2009, Ubicom, Inc.
13674 + *
13675 + * This file is part of the Ubicom32 Linux Kernel Port.
13676 + *
13677 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13678 + * it and/or modify it under the terms of the GNU General Public License
13679 + * as published by the Free Software Foundation, either version 2 of the
13680 + * License, or (at your option) any later version.
13681 + *
13682 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13683 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13684 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13685 + * the GNU General Public License for more details.
13686 + *
13687 + * You should have received a copy of the GNU General Public License
13688 + * along with the Ubicom32 Linux Kernel Port. If not,
13689 + * see <http://www.gnu.org/licenses/>.
13690 + *
13691 + * Ubicom32 implementation derived from (with many thanks):
13692 + * arch/m68knommu
13693 + * arch/blackfin
13694 + * arch/parisc
13695 + */
13696 +#ifndef _ASM_UBICOM32_TIMEX_H
13697 +#define _ASM_UBICOM32_TIMEX_H
13698 +
13699 +#define CLOCK_TICK_RATE 266000000
13700 +
13701 +// #define ARCH_HAS_READ_CURRENT_TIMER
13702 +
13703 +typedef unsigned long cycles_t;
13704 +
13705 +static inline cycles_t get_cycles(void)
13706 +{
13707 + return 0;
13708 +}
13709 +
13710 +extern int timer_alloc(void);
13711 +extern void timer_set(int timervector, unsigned int cycles);
13712 +extern int timer_reset(int timervector, unsigned int cycles);
13713 +extern void timer_tick_init(void);
13714 +extern void timer_device_init(void);
13715 +
13716 +#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
13717 +extern void local_timer_interrupt(void);
13718 +#endif
13719 +
13720 +#if defined(CONFIG_LOCAL_TIMERS) || defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
13721 +extern int local_timer_setup(unsigned int cpu);
13722 +#endif
13723 +
13724 +#endif /* _ASM_UBICOM32_TIMEX_H */
13725 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/tlbflush.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/tlbflush.h
13726 --- linux-2.6.30.10/arch/ubicom32/include/asm/tlbflush.h 1970-01-01 02:00:00.000000000 +0200
13727 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/tlbflush.h 2009-12-11 11:45:11.000000000 +0200
13728 @@ -0,0 +1,79 @@
13729 +/*
13730 + * arch/ubicom32/include/asm/tlbflush.h
13731 + * TLB operations for Ubicom32 architecture.
13732 + *
13733 + * (C) Copyright 2009, Ubicom, Inc.
13734 + * Copyright (C) 2000 Lineo, David McCullough <davidm@uclinux.org>
13735 + * Copyright (C) 2000-2002, Greg Ungerer <gerg@snapgear.com>
13736 + *
13737 + * This file is part of the Ubicom32 Linux Kernel Port.
13738 + *
13739 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13740 + * it and/or modify it under the terms of the GNU General Public License
13741 + * as published by the Free Software Foundation, either version 2 of the
13742 + * License, or (at your option) any later version.
13743 + *
13744 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13745 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13746 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13747 + * the GNU General Public License for more details.
13748 + *
13749 + * You should have received a copy of the GNU General Public License
13750 + * along with the Ubicom32 Linux Kernel Port. If not,
13751 + * see <http://www.gnu.org/licenses/>.
13752 + *
13753 + * Ubicom32 implementation derived from (with many thanks):
13754 + * arch/m68knommu
13755 + * arch/blackfin
13756 + * arch/parisc
13757 + */
13758 +#ifndef _ASM_UBICOM32_TLB_FLUSH_H
13759 +#define _ASM_UBICOM32_TLB_FLUSH_H
13760 +
13761 +#include <asm/setup.h>
13762 +
13763 +/*
13764 + * flush all user-space atc entries.
13765 + */
13766 +static inline void __flush_tlb(void)
13767 +{
13768 + BUG();
13769 +}
13770 +
13771 +static inline void __flush_tlb_one(unsigned long addr)
13772 +{
13773 + BUG();
13774 +}
13775 +
13776 +#define flush_tlb() __flush_tlb()
13777 +
13778 +/*
13779 + * flush all atc entries (both kernel and user-space entries).
13780 + */
13781 +static inline void flush_tlb_all(void)
13782 +{
13783 + BUG();
13784 +}
13785 +
13786 +static inline void flush_tlb_mm(struct mm_struct *mm)
13787 +{
13788 + BUG();
13789 +}
13790 +
13791 +static inline void flush_tlb_page(struct vm_area_struct *vma, unsigned long addr)
13792 +{
13793 + BUG();
13794 +}
13795 +
13796 +static inline void flush_tlb_range(struct mm_struct *mm,
13797 + unsigned long start, unsigned long end)
13798 +{
13799 + BUG();
13800 +}
13801 +
13802 +static inline void flush_tlb_kernel_page(unsigned long addr)
13803 +{
13804 + BUG();
13805 +}
13806 +
13807 +#endif /* _ASM_UBICOM32_TLB_FLUSH_H */
13808 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/tlb.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/tlb.h
13809 --- linux-2.6.30.10/arch/ubicom32/include/asm/tlb.h 1970-01-01 02:00:00.000000000 +0200
13810 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/tlb.h 2009-12-11 11:45:11.000000000 +0200
13811 @@ -0,0 +1,47 @@
13812 +/*
13813 + * arch/ubicom32/include/asm/tlb.h
13814 + * Ubicom32 architecture TLB operations.
13815 + *
13816 + * (C) Copyright 2009, Ubicom, Inc.
13817 + *
13818 + * This file is part of the Ubicom32 Linux Kernel Port.
13819 + *
13820 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13821 + * it and/or modify it under the terms of the GNU General Public License
13822 + * as published by the Free Software Foundation, either version 2 of the
13823 + * License, or (at your option) any later version.
13824 + *
13825 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13826 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13827 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13828 + * the GNU General Public License for more details.
13829 + *
13830 + * You should have received a copy of the GNU General Public License
13831 + * along with the Ubicom32 Linux Kernel Port. If not,
13832 + * see <http://www.gnu.org/licenses/>.
13833 + *
13834 + * Ubicom32 implementation derived from (with many thanks):
13835 + * arch/m68knommu
13836 + * arch/blackfin
13837 + * arch/parisc
13838 + */
13839 +#ifndef _ASM_UBICOM32_TLB_H
13840 +#define _ASM_UBICOM32_TLB_H
13841 +
13842 +/*
13843 + * ubicom32 doesn't need any special per-pte or
13844 + * per-vma handling..
13845 + */
13846 +#define tlb_start_vma(tlb, vma) do { } while (0)
13847 +#define tlb_end_vma(tlb, vma) do { } while (0)
13848 +#define __tlb_remove_tlb_entry(tlb, ptep, address) do { } while (0)
13849 +
13850 +/*
13851 + * .. because we flush the whole mm when it
13852 + * fills up.
13853 + */
13854 +#define tlb_flush(tlb)
13855 +
13856 +#include <asm-generic/tlb.h>
13857 +
13858 +#endif /* _ASM_UBICOM32_TLB_H */
13859 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/topology.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/topology.h
13860 --- linux-2.6.30.10/arch/ubicom32/include/asm/topology.h 1970-01-01 02:00:00.000000000 +0200
13861 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/topology.h 2009-12-11 11:45:11.000000000 +0200
13862 @@ -0,0 +1,33 @@
13863 +/*
13864 + * arch/ubicom32/include/asm/topology.h
13865 + * Generic topology.h definitions for Ubicom32 architecture.
13866 + *
13867 + * (C) Copyright 2009, Ubicom, Inc.
13868 + *
13869 + * This file is part of the Ubicom32 Linux Kernel Port.
13870 + *
13871 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13872 + * it and/or modify it under the terms of the GNU General Public License
13873 + * as published by the Free Software Foundation, either version 2 of the
13874 + * License, or (at your option) any later version.
13875 + *
13876 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13877 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13878 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13879 + * the GNU General Public License for more details.
13880 + *
13881 + * You should have received a copy of the GNU General Public License
13882 + * along with the Ubicom32 Linux Kernel Port. If not,
13883 + * see <http://www.gnu.org/licenses/>.
13884 + *
13885 + * Ubicom32 implementation derived from (with many thanks):
13886 + * arch/m68knommu
13887 + * arch/blackfin
13888 + * arch/parisc
13889 + */
13890 +#ifndef _ASM_UBICOM32_TOPOLOGY_H
13891 +#define _ASM_UBICOM32_TOPOLOGY_H
13892 +
13893 +#include <asm-generic/topology.h>
13894 +
13895 +#endif /* _ASM_UBICOM32_TOPOLOGY_H */
13896 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/traps.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/traps.h
13897 --- linux-2.6.30.10/arch/ubicom32/include/asm/traps.h 1970-01-01 02:00:00.000000000 +0200
13898 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/traps.h 2009-12-11 11:45:11.000000000 +0200
13899 @@ -0,0 +1,55 @@
13900 +/*
13901 + * arch/ubicom32/include/asm/traps.h
13902 + * Trap related definitions for Ubicom32 architecture.
13903 + *
13904 + * (C) Copyright 2009, Ubicom, Inc.
13905 + *
13906 + * This file is part of the Ubicom32 Linux Kernel Port.
13907 + *
13908 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13909 + * it and/or modify it under the terms of the GNU General Public License
13910 + * as published by the Free Software Foundation, either version 2 of the
13911 + * License, or (at your option) any later version.
13912 + *
13913 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13914 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13915 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13916 + * the GNU General Public License for more details.
13917 + *
13918 + * You should have received a copy of the GNU General Public License
13919 + * along with the Ubicom32 Linux Kernel Port. If not,
13920 + * see <http://www.gnu.org/licenses/>.
13921 + *
13922 + * Ubicom32 implementation derived from (with many thanks):
13923 + * arch/m68knommu
13924 + * arch/blackfin
13925 + * arch/parisc
13926 + */
13927 +
13928 +#ifndef _ASM_UBICOM32_TRAPS_H
13929 +#define _ASM_UBICOM32_TRAPS_H
13930 +
13931 +/*
13932 + * Trap causes passed from ultra to Host OS
13933 + */
13934 +#define TRAP_CAUSE_TOTAL 13
13935 +#define TRAP_CAUSE_DST_RANGE_ERR 12
13936 +#define TRAP_CAUSE_SRC1_RANGE_ERR 11
13937 +#define TRAP_CAUSE_I_RANGE_ERR 10
13938 +#define TRAP_CAUSE_DCAPT 9
13939 +#define TRAP_CAUSE_DST_SERROR 8
13940 +#define TRAP_CAUSE_SRC1_SERROR 7
13941 +#define TRAP_CAUSE_DST_MISALIGNED 6
13942 +#define TRAP_CAUSE_SRC1_MISALIGNED 5
13943 +#define TRAP_CAUSE_DST_DECODE_ERR 4
13944 +#define TRAP_CAUSE_SRC1_DECODE_ERR 3
13945 +#define TRAP_CAUSE_ILLEGAL_INST 2
13946 +#define TRAP_CAUSE_I_SERROR 1
13947 +#define TRAP_CAUSE_I_DECODE_ERR 0
13948 +
13949 +extern void trap_handler(int irq, struct pt_regs *regs);
13950 +extern void trap_init_interrupt(void);
13951 +extern void unaligned_emulate(unsigned int thread);
13952 +extern int unaligned_only(unsigned int cause);
13953 +
13954 +#endif /* _ASM_UBICOM32_TRAPS_H */
13955 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/types.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/types.h
13956 --- linux-2.6.30.10/arch/ubicom32/include/asm/types.h 1970-01-01 02:00:00.000000000 +0200
13957 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/types.h 2009-12-11 11:45:11.000000000 +0200
13958 @@ -0,0 +1,75 @@
13959 +/*
13960 + * arch/ubicom32/include/asm/types.h
13961 + * Date type definitions for Ubicom32 architecture.
13962 + *
13963 + * (C) Copyright 2009, Ubicom, Inc.
13964 + *
13965 + * This file is part of the Ubicom32 Linux Kernel Port.
13966 + *
13967 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
13968 + * it and/or modify it under the terms of the GNU General Public License
13969 + * as published by the Free Software Foundation, either version 2 of the
13970 + * License, or (at your option) any later version.
13971 + *
13972 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
13973 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
13974 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13975 + * the GNU General Public License for more details.
13976 + *
13977 + * You should have received a copy of the GNU General Public License
13978 + * along with the Ubicom32 Linux Kernel Port. If not,
13979 + * see <http://www.gnu.org/licenses/>.
13980 + *
13981 + * Ubicom32 implementation derived from (with many thanks):
13982 + * arch/m68knommu
13983 + * arch/blackfin
13984 + * arch/parisc
13985 + */
13986 +#ifndef _ASM_UBICOM32_TYPES_H
13987 +#define _ASM_UBICOM32_TYPES_H
13988 +
13989 +/*
13990 + * This file is never included by application software unless
13991 + * explicitly requested (e.g., via linux/types.h) in which case the
13992 + * application is Linux specific so (user-) name space pollution is
13993 + * not a major issue. However, for interoperability, libraries still
13994 + * need to be careful to avoid a name clashes.
13995 + */
13996 +
13997 +#include <asm-generic/int-ll64.h>
13998 +
13999 +#ifndef __ASSEMBLY__
14000 +
14001 +typedef unsigned short umode_t;
14002 +
14003 +#endif /* __ASSEMBLY__ */
14004 +
14005 +/*
14006 + * These aren't exported outside the kernel to avoid name space clashes
14007 + */
14008 +#ifdef __KERNEL__
14009 +
14010 +#define BITS_PER_LONG 32
14011 +
14012 +#ifndef __ASSEMBLY__
14013 +
14014 +/* DMA addresses are always 32-bits wide */
14015 +
14016 +typedef u32 dma_addr_t;
14017 +typedef u32 dma64_addr_t;
14018 +
14019 +/*
14020 + * XXX These are "Ubicom style" typedefs. They should be removed in all files used by linux.
14021 + */
14022 +typedef u32 u32_t;
14023 +typedef s32 s32_t;
14024 +typedef u16 u16_t;
14025 +typedef s16 s16_t;
14026 +typedef u8 u8_t;
14027 +typedef s8 s8_t;
14028 +
14029 +#endif /* __ASSEMBLY__ */
14030 +
14031 +#endif /* __KERNEL__ */
14032 +
14033 +#endif /* _ASM_UBICOM32_TYPES_H */
14034 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/uaccess.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/uaccess.h
14035 --- linux-2.6.30.10/arch/ubicom32/include/asm/uaccess.h 1970-01-01 02:00:00.000000000 +0200
14036 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/uaccess.h 2009-12-11 11:45:11.000000000 +0200
14037 @@ -0,0 +1,347 @@
14038 +/*
14039 + * arch/ubicom32/include/asm/uaccess.h
14040 + * User space memory access functions for Ubicom32 architecture.
14041 + *
14042 + * (C) Copyright 2009, Ubicom, Inc.
14043 + *
14044 + * This file is part of the Ubicom32 Linux Kernel Port.
14045 + *
14046 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14047 + * it and/or modify it under the terms of the GNU General Public License
14048 + * as published by the Free Software Foundation, either version 2 of the
14049 + * License, or (at your option) any later version.
14050 + *
14051 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14052 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14053 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14054 + * the GNU General Public License for more details.
14055 + *
14056 + * You should have received a copy of the GNU General Public License
14057 + * along with the Ubicom32 Linux Kernel Port. If not,
14058 + * see <http://www.gnu.org/licenses/>.
14059 + *
14060 + * Ubicom32 implementation derived from (with many thanks):
14061 + * arch/m68knommu
14062 + * arch/blackfin
14063 + * arch/parisc
14064 + * arch/alpha
14065 + */
14066 +#ifndef _ASM_UBICOM32_UACCESS_H
14067 +#define _ASM_UBICOM32_UACCESS_H
14068 +
14069 +/*
14070 + * User space memory access functions
14071 + */
14072 +#include <linux/sched.h>
14073 +#include <linux/mm.h>
14074 +#include <linux/string.h>
14075 +
14076 +#include <asm/segment.h>
14077 +
14078 +#define VERIFY_READ 0
14079 +#define VERIFY_WRITE 1
14080 +
14081 +/*
14082 + * The exception table consists of pairs of addresses: the first is the
14083 + * address of an instruction that is allowed to fault, and the second is
14084 + * the address at which the program should continue. No registers are
14085 + * modified, so it is entirely up to the continuation code to figure out
14086 + * what to do.
14087 + *
14088 + * All the routines below use bits of fixup code that are out of line
14089 + * with the main instruction path. This means when everything is well,
14090 + * we don't even have to jump over them. Further, they do not intrude
14091 + * on our cache or tlb entries.
14092 + */
14093 +struct exception_table_entry
14094 +{
14095 + unsigned long insn, fixup;
14096 +};
14097 +
14098 +/*
14099 + * Ubicom32 does not currently support the exception table handling.
14100 + */
14101 +extern unsigned long search_exception_table(unsigned long);
14102 +
14103 +
14104 +#if defined(CONFIG_ACCESS_OK_CHECKS_ENABLED)
14105 +extern int __access_ok(unsigned long addr, unsigned long size);
14106 +#else
14107 +static inline int __access_ok(unsigned long addr, unsigned long size)
14108 +{
14109 + return 1;
14110 +}
14111 +#endif
14112 +#define access_ok(type, addr, size) \
14113 + likely(__access_ok((unsigned long)(addr), (size)))
14114 +
14115 +/*
14116 + * The following functions do not exist. They keep callers
14117 + * of put_user and get_user from passing unsupported argument
14118 + * types. They result in a link time error.
14119 + */
14120 +extern int __put_user_bad(void);
14121 +extern int __get_user_bad(void);
14122 +
14123 +/*
14124 + * __put_user_no_check()
14125 + * Put the requested data into the user space verifying the address
14126 + *
14127 + * Careful to not
14128 + * (a) re-use the arguments for side effects (sizeof/typeof is ok)
14129 + * (b) require any knowledge of processes at this stage
14130 + */
14131 +#define __put_user_no_check(x, ptr, size) \
14132 +({ \
14133 + int __pu_err = 0; \
14134 + __typeof__(*(ptr)) __user *__pu_addr = (ptr); \
14135 + switch (size) { \
14136 + case 1: \
14137 + case 2: \
14138 + case 4: \
14139 + case 8: \
14140 + *__pu_addr = (__typeof__(*(ptr)))x; \
14141 + break; \
14142 + default: \
14143 + __pu_err = __put_user_bad(); \
14144 + break; \
14145 + } \
14146 + __pu_err; \
14147 +})
14148 +
14149 +/*
14150 + * __put_user_check()
14151 + * Put the requested data into the user space verifying the address
14152 + *
14153 + * Careful to not
14154 + * (a) re-use the arguments for side effects (sizeof/typeof is ok)
14155 + * (b) require any knowledge of processes at this stage
14156 + *
14157 + * If requested, access_ok() will verify that ptr is a valid user
14158 + * pointer.
14159 + */
14160 +#define __put_user_check(x, ptr, size) \
14161 +({ \
14162 + int __pu_err = -EFAULT; \
14163 + __typeof__(*(ptr)) __user *__pu_addr = (ptr); \
14164 + if (access_ok(VERIFY_WRITE, __pu_addr, size)) { \
14165 + __pu_err = 0; \
14166 + switch (size) { \
14167 + case 1: \
14168 + case 2: \
14169 + case 4: \
14170 + case 8: \
14171 + *__pu_addr = (__typeof__(*(ptr)))x; \
14172 + break; \
14173 + default: \
14174 + __pu_err = __put_user_bad(); \
14175 + break; \
14176 + } \
14177 + } \
14178 + __pu_err; \
14179 +})
14180 +
14181 +/*
14182 + * __get_user_no_check()
14183 + * Read the value at ptr into x.
14184 + *
14185 + * If requested, access_ok() will verify that ptr is a valid user
14186 + * pointer. If the caller passes a modifying argument for ptr (e.g. x++)
14187 + * this macro will not work.
14188 + */
14189 +#define __get_user_no_check(x, ptr, size) \
14190 +({ \
14191 + int __gu_err = 0; \
14192 + __typeof__((x)) __gu_val = 0; \
14193 + const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \
14194 + switch (size) { \
14195 + case 1: \
14196 + case 2: \
14197 + case 4: \
14198 + case 8: \
14199 + __gu_val = (__typeof__((x)))*(__gu_addr); \
14200 + break; \
14201 + default: \
14202 + __gu_err = __get_user_bad(); \
14203 + (x) = 0; \
14204 + break; \
14205 + } \
14206 + (x) = __gu_val; \
14207 + __gu_err; \
14208 +})
14209 +
14210 +/*
14211 + * __get_user_check()
14212 + * Read the value at ptr into x.
14213 + *
14214 + * If requested, access_ok() will verify that ptr is a valid user
14215 + * pointer.
14216 + */
14217 +#define __get_user_check(x, ptr, size) \
14218 +({ \
14219 + int __gu_err = -EFAULT; \
14220 + __typeof__(x) __gu_val = 0; \
14221 + const __typeof__(*(ptr)) __user *__gu_addr = (ptr); \
14222 + if (access_ok(VERIFY_READ, __gu_addr, size)) { \
14223 + __gu_err = 0; \
14224 + switch (size) { \
14225 + case 1: \
14226 + case 2: \
14227 + case 4: \
14228 + case 8: \
14229 + __gu_val = (__typeof__((x)))*(__gu_addr); \
14230 + break; \
14231 + default: \
14232 + __gu_err = __get_user_bad(); \
14233 + (x) = 0; \
14234 + break; \
14235 + } \
14236 + } \
14237 + (x) = __gu_val; \
14238 + __gu_err; \
14239 +})
14240 +
14241 +/*
14242 + * The "xxx" versions are allowed to perform some amount of address
14243 + * space checking. See access_ok().
14244 + */
14245 +#define put_user(x,ptr) \
14246 + __put_user_check((__typeof__(*(ptr)))(x),(ptr), sizeof(*(ptr)))
14247 +#define get_user(x,ptr) \
14248 + __get_user_check((x), (ptr), sizeof(*(ptr)))
14249 +
14250 +/*
14251 + * The "__xxx" versions do not do address space checking, useful when
14252 + * doing multiple accesses to the same area (the programmer has to do the
14253 + * checks by hand with "access_ok()")
14254 + */
14255 +#define __put_user(x,ptr) \
14256 + __put_user_no_check((__typeof__(*(ptr)))(x),(ptr), sizeof(*(ptr)))
14257 +#define __get_user(x,ptr) \
14258 + __get_user_no_check((x), (ptr), sizeof(*(ptr)))
14259 +
14260 +/*
14261 + * __copy_tofrom_user_no_check()
14262 + * Copy the data either to or from user space.
14263 + *
14264 + * Return the number of bytes NOT copied.
14265 + */
14266 +static inline unsigned long
14267 +__copy_tofrom_user_no_check(void *to, const void *from, unsigned long n)
14268 +{
14269 + memcpy(to, from, n);
14270 + return 0;
14271 +}
14272 +
14273 +/*
14274 + * copy_to_user()
14275 + * Copy the kernel data to user space.
14276 + *
14277 + * Return the number of bytes that were copied.
14278 + */
14279 +static inline unsigned long
14280 +copy_to_user(void __user *to, const void *from, unsigned long n)
14281 +{
14282 + if (!access_ok(VERIFY_WRITE, to, n)) {
14283 + return n;
14284 + }
14285 + return __copy_tofrom_user_no_check((__force void *)to, from, n);
14286 +}
14287 +
14288 +/*
14289 + * copy_from_user()
14290 + * Copy the user data to kernel space.
14291 + *
14292 + * Return the number of bytes that were copied. On error, we zero
14293 + * out the destination.
14294 + */
14295 +static inline unsigned long
14296 +copy_from_user(void *to, const void __user *from, unsigned long n)
14297 +{
14298 + if (!access_ok(VERIFY_READ, from, n)) {
14299 + return n;
14300 + }
14301 + return __copy_tofrom_user_no_check(to, (__force void *)from, n);
14302 +}
14303 +
14304 +#define __copy_to_user(to, from, n) \
14305 + __copy_tofrom_user_no_check((__force void *)to, from, n)
14306 +#define __copy_from_user(to, from, n) \
14307 + __copy_tofrom_user_no_check(to, (__force void *)from, n)
14308 +#define __copy_to_user_inatomic(to, from, n) \
14309 + __copy_tofrom_user_no_check((__force void *)to, from, n)
14310 +#define __copy_from_user_inatomic(to, from, n) \
14311 + __copy_tofrom_user_no_check(to, (__force void *)from, n)
14312 +
14313 +#define copy_to_user_ret(to, from, n, retval) \
14314 + ({ if (copy_to_user(to, from, n)) return retval; })
14315 +
14316 +#define copy_from_user_ret(to, from, n, retval) \
14317 + ({ if (copy_from_user(to, from, n)) return retval; })
14318 +
14319 +/*
14320 + * strncpy_from_user()
14321 + * Copy a null terminated string from userspace.
14322 + *
14323 + * dst - Destination in kernel space. The buffer must be at least count.
14324 + * src - Address of string in user space.
14325 + * count - Maximum number of bytes to copy (including the trailing NULL).
14326 + *
14327 + * Returns the length of the string (not including the trailing NULL. If
14328 + * count is smaller than the length of the string, we copy count bytes
14329 + * and return count.
14330 + *
14331 + */
14332 +static inline long strncpy_from_user(char *dst, const __user char *src, long count)
14333 +{
14334 + char *tmp;
14335 + if (!access_ok(VERIFY_READ, src, 1)) {
14336 + return -EFAULT;
14337 + }
14338 +
14339 + strncpy(dst, src, count);
14340 + for (tmp = dst; *tmp && count > 0; tmp++, count--) {
14341 + ;
14342 + }
14343 + return(tmp - dst);
14344 +}
14345 +
14346 +/*
14347 + * strnlen_user()
14348 + * Return the size of a string (including the ending 0)
14349 + *
14350 + * Return -EFAULT on exception, a value greater than <n> if too long
14351 + */
14352 +static inline long strnlen_user(const __user char *src, long n)
14353 +{
14354 + if (!access_ok(VERIFY_READ, src, 1)) {
14355 + return -EFAULT;
14356 + }
14357 + return(strlen(src) + 1);
14358 +}
14359 +
14360 +#define strlen_user(str) strnlen_user(str, 32767)
14361 +
14362 +/*
14363 + * __clear_user()
14364 + * Zero Userspace
14365 + */
14366 +static inline unsigned long __clear_user(__user void *to, unsigned long n)
14367 +{
14368 + memset(to, 0, n);
14369 + return 0;
14370 +}
14371 +
14372 +/*
14373 + * clear_user()
14374 + * Zero user space (check for valid addresses)
14375 + */
14376 +static inline unsigned long clear_user(__user void *to, unsigned long n)
14377 +{
14378 + if (!access_ok(VERIFY_WRITE, to, n)) {
14379 + return -EFAULT;
14380 + }
14381 + return __clear_user(to, n);
14382 +}
14383 +
14384 +#endif /* _ASM_UBICOM32_UACCESS_H */
14385 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/uart_tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/uart_tio.h
14386 --- linux-2.6.30.10/arch/ubicom32/include/asm/uart_tio.h 1970-01-01 02:00:00.000000000 +0200
14387 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/uart_tio.h 2009-12-11 11:45:11.000000000 +0200
14388 @@ -0,0 +1,126 @@
14389 +/*
14390 + * arch/ubicom32/include/asm/uart_tio.h
14391 + * Ubicom32 architecture UART TIO definitions.
14392 + *
14393 + * (C) Copyright 2009, Ubicom, Inc.
14394 + *
14395 + * This file is part of the Ubicom32 Linux Kernel Port.
14396 + *
14397 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14398 + * it and/or modify it under the terms of the GNU General Public License
14399 + * as published by the Free Software Foundation, either version 2 of the
14400 + * License, or (at your option) any later version.
14401 + *
14402 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14403 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14404 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14405 + * the GNU General Public License for more details.
14406 + *
14407 + * You should have received a copy of the GNU General Public License
14408 + * along with the Ubicom32 Linux Kernel Port. If not,
14409 + * see <http://www.gnu.org/licenses/>.
14410 + */
14411 +#ifndef _ASM_UBICOM32_UART_TIO_H
14412 +#define _ASM_UBICOM32_UART_TIO_H
14413 +
14414 +#include <asm/devtree.h>
14415 +
14416 +#define UARTTIO_RX_FIFO_SIZE 16
14417 +#define UARTTIO_TX_FIFO_SIZE 16
14418 +
14419 +/*
14420 + * Interrupt flags
14421 + */
14422 +#define UARTTIO_UART_INT_RX 0x00000001 // set when a character has been recevied (TODO: add watermark)
14423 +#define UARTTIO_UART_INT_RXOVF 0x00000002 // set when the receive buffer has overflowed
14424 +#define UARTTIO_UART_INT_RXFRAME 0x00000004 // set when there has been a framing error
14425 +
14426 +#define UARTTIO_UART_INT_TX 0x00000100 // set every time a character is transmitted
14427 +#define UARTTIO_UART_INT_TXBE 0x00000200 // set when the transmit buffer is empty (TODO: add watermark)
14428 +
14429 +#define UARTTIO_UART_FLAG_ENABLED 0x80000000
14430 +#define UARTTIO_UART_FLAG_SET_RATE 0x00000001 // set to update baud rate
14431 +#define UARTTIO_UART_FLAG_RESET 0x00000002 // set to reset the port
14432 +struct uarttio_uart {
14433 + volatile u32_t flags;
14434 +
14435 + volatile u32_t baud_rate;
14436 + volatile u32_t current_baud_rate;
14437 + u32_t bit_time;
14438 +
14439 + /*
14440 + * Modem status register
14441 + */
14442 + volatile u32_t status;
14443 +
14444 + /*
14445 + * Interrupt registers
14446 + */
14447 + volatile u32_t int_mask;
14448 + volatile u32_t int_flags;
14449 +
14450 + /*
14451 + * Ports and pins
14452 + */
14453 + u32_t rx_port;
14454 + u32_t tx_port;
14455 +
14456 + u8_t rx_pin;
14457 + u8_t tx_pin;
14458 +
14459 + /*
14460 + * Configuration Data
14461 + */
14462 + u8_t rx_bits;
14463 + u8_t rx_stop_bits;
14464 + u8_t tx_bits;
14465 + u8_t tx_stop_bits;
14466 +
14467 + /*
14468 + * RX state machine data
14469 + */
14470 + u32_t rx_timer;
14471 + u32_t rx_bit_pos;
14472 + u32_t rx_byte;
14473 + u32_t rx_fifo_head;
14474 + u32_t rx_fifo_tail;
14475 + u32_t rx_fifo_size;
14476 +
14477 + /*
14478 + * TX state machine data
14479 + */
14480 + u32_t tx_timer;
14481 + u32_t tx_bit_pos;
14482 + u32_t tx_byte;
14483 + u32_t tx_fifo_head;
14484 + u32_t tx_fifo_tail;
14485 + u32_t tx_fifo_size;
14486 +
14487 + /*
14488 + * FIFOs
14489 + */
14490 + u8_t rx_fifo[UARTTIO_RX_FIFO_SIZE];
14491 + u8_t tx_fifo[UARTTIO_TX_FIFO_SIZE];
14492 +};
14493 +
14494 +#define UARTTIO_VP_VERSION 1
14495 +struct uarttio_regs {
14496 + u32_t version;
14497 +
14498 + u32_t thread;
14499 +
14500 + u32_t max_uarts;
14501 +
14502 + struct uarttio_uart uarts[0];
14503 +};
14504 +
14505 +#define UARTTIO_NODE_VERSION 1
14506 +struct uarttio_node {
14507 + struct devtree_node dn;
14508 +
14509 + u32_t version;
14510 + struct uarttio_regs *regs;
14511 + u32_t regs_sz;
14512 +};
14513 +
14514 +#endif /* _ASM_UBICOM32_UART_TIO_H */
14515 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubi32-cs4384.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubi32-cs4384.h
14516 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubi32-cs4384.h 1970-01-01 02:00:00.000000000 +0200
14517 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubi32-cs4384.h 2009-12-11 11:45:11.000000000 +0200
14518 @@ -0,0 +1,52 @@
14519 +/*
14520 + * arch/ubicom32/include/asm/ubi32-cs4384.h
14521 + * Ubicom32 architecture CS4384 driver platform data definitions.
14522 + *
14523 + * (C) Copyright 2009, Ubicom, Inc.
14524 + *
14525 + * This file is part of the Ubicom32 Linux Kernel Port.
14526 + *
14527 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14528 + * it and/or modify it under the terms of the GNU General Public License
14529 + * as published by the Free Software Foundation, either version 2 of the
14530 + * License, or (at your option) any later version.
14531 + *
14532 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14533 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14534 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14535 + * the GNU General Public License for more details.
14536 + *
14537 + * You should have received a copy of the GNU General Public License
14538 + * along with the Ubicom32 Linux Kernel Port. If not,
14539 + * see <http://www.gnu.org/licenses/>.
14540 + */
14541 +#ifndef _ASM_UBICOM32_UBI32_CS4384_H
14542 +#define _ASM_UBICOM32_UBI32_CS4384_H
14543 +
14544 +enum ubi32_cs4384_mclk_source {
14545 + UBI32_CS4384_MCLK_PWM_0,
14546 + UBI32_CS4384_MCLK_PWM_1,
14547 + UBI32_CS4384_MCLK_PWM_2,
14548 + UBI32_CS4384_MCLK_CLKDIV_1,
14549 + UBI32_CS4384_MCLK_OTHER,
14550 +};
14551 +
14552 +struct ubi32_cs4384_mclk_entry {
14553 + /*
14554 + * Rate, in Hz, of this entry
14555 + */
14556 + int rate;
14557 +
14558 + /*
14559 + * The divider to program to get the rate
14560 + */
14561 + int div;
14562 +};
14563 +
14564 +struct ubi32_cs4384_platform_data {
14565 + enum ubi32_cs4384_mclk_source mclk_src;
14566 +
14567 + int n_mclk;
14568 + struct ubi32_cs4384_mclk_entry *mclk_entries;
14569 +};
14570 +#endif /* _ASM_UBICOM32_UBI32_CS4384_H */
14571 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubi32-pcm.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubi32-pcm.h
14572 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubi32-pcm.h 1970-01-01 02:00:00.000000000 +0200
14573 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubi32-pcm.h 2009-12-11 11:45:11.000000000 +0200
14574 @@ -0,0 +1,54 @@
14575 +/*
14576 + * arch/ubicom32/include/asm/ubi32-pcm.h
14577 + * Ubicom32 architecture PCM driver platform data definitions.
14578 + *
14579 + * (C) Copyright 2009, Ubicom, Inc.
14580 + *
14581 + * This file is part of the Ubicom32 Linux Kernel Port.
14582 + *
14583 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14584 + * it and/or modify it under the terms of the GNU General Public License
14585 + * as published by the Free Software Foundation, either version 2 of the
14586 + * License, or (at your option) any later version.
14587 + *
14588 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14589 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14590 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14591 + * the GNU General Public License for more details.
14592 + *
14593 + * You should have received a copy of the GNU General Public License
14594 + * along with the Ubicom32 Linux Kernel Port. If not,
14595 + * see <http://www.gnu.org/licenses/>.
14596 + */
14597 +#ifndef _ASM_UBICOM32_UBI32_PCM_H
14598 +#define _ASM_UBICOM32_UBI32_PCM_H
14599 +
14600 +/*
14601 + * This function is called when the sample rate has changed
14602 + */
14603 +typedef int (*ubi32_pcm_set_rate_fn_t)(void *appdata, int rate);
14604 +
14605 +struct ubi32pcm_platform_data {
14606 + /*
14607 + * Name of the audio node/inst
14608 + */
14609 + const char *node_name;
14610 + const char *inst_name;
14611 + int inst_num;
14612 +
14613 + /*
14614 + * Application specific data provided when calling functions
14615 + */
14616 + void *appdata;
14617 +
14618 + /*
14619 + * Functions called when various things happen
14620 + */
14621 + ubi32_pcm_set_rate_fn_t set_rate;
14622 +
14623 + /*
14624 + * Pointer to optional upper layer data (i.e. DAC config, etc)
14625 + */
14626 + void *priv_data;
14627 +};
14628 +#endif /* _ASM_UBICOM32_UBI32_PCM_H */
14629 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32bl.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32bl.h
14630 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32bl.h 1970-01-01 02:00:00.000000000 +0200
14631 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32bl.h 2009-12-11 11:45:11.000000000 +0200
14632 @@ -0,0 +1,84 @@
14633 +/*
14634 + * arch/ubicom32/include/asm/ubicom32bl.h
14635 + * Ubicom32 architecture backlight driver platform data definitions.
14636 + *
14637 + * (C) Copyright 2009, Ubicom, Inc.
14638 + *
14639 + * This file is part of the Ubicom32 Linux Kernel Port.
14640 + *
14641 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14642 + * it and/or modify it under the terms of the GNU General Public License
14643 + * as published by the Free Software Foundation, either version 2 of the
14644 + * License, or (at your option) any later version.
14645 + *
14646 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14647 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14648 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14649 + * the GNU General Public License for more details.
14650 + *
14651 + * You should have received a copy of the GNU General Public License
14652 + * along with the Ubicom32 Linux Kernel Port. If not,
14653 + * see <http://www.gnu.org/licenses/>.
14654 + *
14655 + * Ubicom32 implementation derived from (with many thanks):
14656 + * arch/m68knommu
14657 + * arch/blackfin
14658 + * arch/parisc
14659 + */
14660 +#ifndef _ASM_UBICOM32_UBICOM32_BL_H
14661 +#define _ASM_UBICOM32_UBICOM32_BL_H
14662 +
14663 +/*
14664 + * Different backlight control mechanisms
14665 + */
14666 +enum ubicom32bl_pwm_types {
14667 + /*
14668 + * PWM controlled backlight
14669 + */
14670 + UBICOM32BL_TYPE_PWM,
14671 +
14672 + /*
14673 + * HRT based PWM backlight
14674 + */
14675 + UBICOM32BL_TYPE_PWM_HRT,
14676 +
14677 + /*
14678 + * No dimming, just on or off
14679 + */
14680 + UBICOM32BL_TYPE_BINARY,
14681 +};
14682 +
14683 +struct ubicom32bl_platform_data {
14684 + /*
14685 + * Default intensity of the backlight 0-255
14686 + */
14687 + u8_t default_intensity;
14688 +
14689 + /*
14690 + * TRUE if the backlight sense is active low. (inverted)
14691 + * FALSE if the backlight sense is active high.
14692 + */
14693 + bool invert;
14694 +
14695 + /*
14696 + * Type of the backlight
14697 + */
14698 + enum ubicom32bl_pwm_types type;
14699 +
14700 + /*
14701 + * GPIO of the backlight if UBICOM32BL_TYPE_PWM_HRT, UBICOM32BL_TYPE_BINARY
14702 + */
14703 + unsigned gpio;
14704 +
14705 + /*
14706 + * PWM channel and parameters of the backlight if UBICOM32BL_TYPE_PWM
14707 + * pre_scaler: sets the rate at which the PWM timer is clocked. (clk_core / 2^pre_scaler)
14708 + * period: sets the period of the timer in timer cycles
14709 + * The duty cycle will be directly proportional to the brightness setting.
14710 + */
14711 + u32_t pwm_channel;
14712 + u8_t pwm_prescale;
14713 + u16_t pwm_period;
14714 +};
14715 +
14716 +#endif /* _ASM_UBICOM32_UBICOM32_BL_H */
14717 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-common-asm.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-common-asm.h
14718 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-common-asm.h 1970-01-01 02:00:00.000000000 +0200
14719 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-common-asm.h 2009-12-11 11:45:11.000000000 +0200
14720 @@ -0,0 +1,49 @@
14721 +/*
14722 + * arch/ubicom32/include/asm/ubicom32-common-asm.h
14723 + * Ubicom32 atomic lock operations.
14724 + *
14725 + * (C) Copyright 2009, Ubicom, Inc.
14726 + *
14727 + * This file is part of the Ubicom32 Linux Kernel Port.
14728 + *
14729 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14730 + * it and/or modify it under the terms of the GNU General Public License
14731 + * as published by the Free Software Foundation, either version 2 of the
14732 + * License, or (at your option) any later version.
14733 + *
14734 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14735 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14736 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14737 + * the GNU General Public License for more details.
14738 + *
14739 + * You should have received a copy of the GNU General Public License
14740 + * along with the Ubicom32 Linux Kernel Port. If not,
14741 + * see <http://www.gnu.org/licenses/>.
14742 + *
14743 + * Ubicom32 implementation derived from (with many thanks):
14744 + * arch/m68knommu
14745 + * arch/blackfin
14746 + * arch/parisc
14747 + */
14748 +
14749 +#ifndef _ASM_UBICOM32_UBICOM32_COMMON_ASM_H
14750 +#define _ASM_UBICOM32_UBICOM32_COMMON_ASM_H
14751 +
14752 +/*
14753 + * atomic_lock_acquire macro
14754 + * Equivalent to __atomic_lock_acquire()
14755 + */
14756 +.macro atomic_lock_acquire
14757 + bset scratchpad1, scratchpad1, #ATOMIC_LOCK_BIT
14758 + jmpne.f .-4
14759 +.endm
14760 +
14761 +/*
14762 + * atomic_lock_release macro
14763 + * Equivalent to __atomic_lock_release()
14764 + */
14765 +.macro atomic_lock_release
14766 + bclr scratchpad1, scratchpad1, #ATOMIC_LOCK_BIT
14767 +.endm
14768 +
14769 +#endif /* _ASM_UBICOM32_UBICOM32_COMMON_ASM_H */
14770 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-common.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-common.h
14771 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-common.h 1970-01-01 02:00:00.000000000 +0200
14772 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-common.h 2009-12-11 11:45:11.000000000 +0200
14773 @@ -0,0 +1,128 @@
14774 +/*
14775 + * arch/ubicom32/include/asm/ubicom32-common.h
14776 + * Ubicom32 atomic lock operations.
14777 + *
14778 + * (C) Copyright 2009, Ubicom, Inc.
14779 + *
14780 + * This file is part of the Ubicom32 Linux Kernel Port.
14781 + *
14782 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14783 + * it and/or modify it under the terms of the GNU General Public License
14784 + * as published by the Free Software Foundation, either version 2 of the
14785 + * License, or (at your option) any later version.
14786 + *
14787 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14788 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14789 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14790 + * the GNU General Public License for more details.
14791 + *
14792 + * You should have received a copy of the GNU General Public License
14793 + * along with the Ubicom32 Linux Kernel Port. If not,
14794 + * see <http://www.gnu.org/licenses/>.
14795 + *
14796 + * Ubicom32 implementation derived from (with many thanks):
14797 + * arch/m68knommu
14798 + * arch/blackfin
14799 + * arch/parisc
14800 + */
14801 +
14802 +#ifndef _ASM_UBICOM32_UBICOM32_COMMON_H
14803 +#define _ASM_UBICOM32_UBICOM32_COMMON_H
14804 +
14805 +#define S(arg) #arg
14806 +#define D(arg) S(arg)
14807 +/*
14808 + * scratchpad1 is owned by the LDSR.
14809 + *
14810 + * The upper bits provide 16 global spinlocks. Acquiring one of these
14811 + * global spinlocks synchornizes across multiple threads and prevents
14812 + * the LDSR from delivering any interrupts while the lock is held.
14813 + * Use these locks only when absolutely required.
14814 + *
14815 + * The lower 16 bits of scratchpad1 are used as per thread interrupt
14816 + * enable/disable bits. These bits will prevent a thread from receiving
14817 + * any interrupts.
14818 + *
14819 + * Bit Usage:
14820 + * - MT_EN_LOCK_BIT - Protects writes to MT_EN, so code can read current value
14821 + * then write a new value atomically (profiler for example)
14822 + * - ATOMIC_LOCK_BIT - Used to provide general purpose atomic handling.
14823 + * - LDSR_LOCK_BIT - Used by the LDSR exclusively to provide protection.
14824 + * - DCCR_LOCK_BIT - Used to limit access to the DCCR cache control peripheral
14825 + * - ICCR_LOCK_BIT - Used to limit access to the ICCR cache control peripheral
14826 + * - LSB 16 bits - Used by the LDSR to represent thread enable/disable bits.
14827 + */
14828 +#define MT_EN_LOCK_BIT 31
14829 +#define ATOMIC_LOCK_BIT 30
14830 +#define LDSR_LOCK_BIT 29
14831 +#define PCI_LOCK_BIT 28
14832 +#define ICCR_LOCK_BIT 27
14833 +#define DCCR_LOCK_BIT 26
14834 +
14835 +#if !defined(__ASSEMBLY__)
14836 +
14837 +#define UBICOM32_TRYLOCK(bit) \
14838 + asm volatile ( \
14839 + " move.4 %0, #0 \n\t" \
14840 + " bset scratchpad1, scratchpad1, #"D(bit)" \n\t" \
14841 + " jmpne.f 1f \n\t" \
14842 + " move.4 %0, #1 \n\t" \
14843 + "1: \n\t" \
14844 + : "=r" (ret) \
14845 + : \
14846 + : "cc", "memory" \
14847 + ) \
14848 +
14849 +#define UBICOM32_UNLOCK(bit) \
14850 + asm volatile ( \
14851 + " bclr scratchpad1, scratchpad1, #"D(bit)" \n\t" \
14852 + : \
14853 + : \
14854 + : "cc", "memory" \
14855 + ) \
14856 +
14857 +#define UBICOM32_LOCK(bit) \
14858 + asm volatile ( \
14859 + "1: bset scratchpad1, scratchpad1, #"D(bit)" \n\t" \
14860 + " jmpne.f 1b \n\t" \
14861 + : \
14862 + : \
14863 + : "cc", "memory" \
14864 + ) \
14865 +
14866 +/*
14867 + * __atomic_lock_trylock()
14868 + * Attempt to acquire the lock, return TRUE if acquired.
14869 + */
14870 +static inline int __atomic_lock_trylock(void)
14871 +{
14872 + int ret;
14873 + UBICOM32_TRYLOCK(ATOMIC_LOCK_BIT);
14874 + return ret;
14875 +}
14876 +
14877 +/*
14878 + * __atomic_lock_release()
14879 + * Release the global atomic lock.
14880 + *
14881 + * Note: no one is suspended waiting since this lock is a spinning lock.
14882 + */
14883 +static inline void __atomic_lock_release(void)
14884 +{
14885 + UBICOM32_UNLOCK(ATOMIC_LOCK_BIT);
14886 +}
14887 +
14888 +/*
14889 + * __atomic_lock_acquire()
14890 + * Acquire the global atomic lock, spin if not available.
14891 + */
14892 +static inline void __atomic_lock_acquire(void)
14893 +{
14894 + UBICOM32_LOCK(ATOMIC_LOCK_BIT);
14895 +}
14896 +#else /* __ASSEMBLY__ */
14897 +
14898 +#include <asm/ubicom32-common-asm.h>
14899 +
14900 +#endif /* __ASSEMBLY__ */
14901 +#endif /* _ASM_UBICOM32_UBICOM32_COMMON_H */
14902 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32fb.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32fb.h
14903 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32fb.h 1970-01-01 02:00:00.000000000 +0200
14904 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32fb.h 2009-12-11 11:45:11.000000000 +0200
14905 @@ -0,0 +1,56 @@
14906 +/*
14907 + * arch/ubicom32/include/asm/ubicom32fb.h
14908 + * Ubicom32 architecture video frame buffer definitions.
14909 + *
14910 + * (C) Copyright 2009, Ubicom, Inc.
14911 + *
14912 + * This file is part of the Ubicom32 Linux Kernel Port.
14913 + *
14914 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14915 + * it and/or modify it under the terms of the GNU General Public License
14916 + * as published by the Free Software Foundation, either version 2 of the
14917 + * License, or (at your option) any later version.
14918 + *
14919 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14920 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14921 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14922 + * the GNU General Public License for more details.
14923 + *
14924 + * You should have received a copy of the GNU General Public License
14925 + * along with the Ubicom32 Linux Kernel Port. If not,
14926 + * see <http://www.gnu.org/licenses/>.
14927 + */
14928 +#ifndef _ASM_UBICOM32_UBICOM32FB_H
14929 +#define _ASM_UBICOM32_UBICOM32FB_H
14930 +
14931 +#include <linux/ioctl.h>
14932 +
14933 +/*
14934 + * Set next frame
14935 + */
14936 +#define UBICOM32FB_IOCTL_SET_NEXT_FRAME _IOW('r', 1, void *)
14937 +#define UBICOM32FB_IOCTL_SET_NEXT_FRAME_SYNC _IOW('r', 2, void *)
14938 +
14939 +/*
14940 + * Set Mode
14941 + */
14942 +#define UBICOM32FB_IOCTL_SET_MODE _IOW('r', 3, void *)
14943 +struct ubicom32fb_mode {
14944 + unsigned long width;
14945 + unsigned long height;
14946 + unsigned long flags;
14947 + void *next_frame;
14948 +};
14949 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_SCAN_ORDER (1 << 8)
14950 +
14951 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_BLOCK_ORDER (1 << 7)
14952 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV (1 << 6)
14953 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_VSUB (1 << 5)
14954 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_16_255 (1 << 4)
14955 +
14956 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_0_255 (1 << 3)
14957 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_2_1 (1 << 2)
14958 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_1_1 (1 << 1)
14959 +#define UBICOM32FB_IOCTL_SET_MODE_FLAG_SCALE_ENABLE (1 << 0)
14960 +
14961 +#endif /* _ASM_UBICOM32_UBICOM32FB_H */
14962 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32hid.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32hid.h
14963 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32hid.h 1970-01-01 02:00:00.000000000 +0200
14964 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32hid.h 2009-12-11 11:45:11.000000000 +0200
14965 @@ -0,0 +1,133 @@
14966 +/*
14967 + * arch/ubicom32/include/asm/ubicom32hid.h
14968 + * Ubicom32 architecture HID driver platform data definitions.
14969 + *
14970 + * (C) Copyright 2009, Ubicom, Inc.
14971 + *
14972 + * This file is part of the Ubicom32 Linux Kernel Port.
14973 + *
14974 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
14975 + * it and/or modify it under the terms of the GNU General Public License
14976 + * as published by the Free Software Foundation, either version 2 of the
14977 + * License, or (at your option) any later version.
14978 + *
14979 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
14980 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
14981 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14982 + * the GNU General Public License for more details.
14983 + *
14984 + * You should have received a copy of the GNU General Public License
14985 + * along with the Ubicom32 Linux Kernel Port. If not,
14986 + * see <http://www.gnu.org/licenses/>.
14987 + *
14988 + * Ubicom32 implementation derived from (with many thanks):
14989 + * arch/m68knommu
14990 + * arch/blackfin
14991 + * arch/parisc
14992 + */
14993 +#ifndef _ASM_UBICOM32_UBICOM32_HID_H
14994 +#define _ASM_UBICOM32_UBICOM32_HID_H
14995 +
14996 +enum ubicom32hid_bl_types {
14997 + /*
14998 + * On or off, using command SET_BL_EN, PB4
14999 + */
15000 + UBICOM32HID_BL_TYPE_BINARY,
15001 +
15002 + /*
15003 + * Dimmable, using command SET_PWM, PB3
15004 + */
15005 + UBICOM32HID_BL_TYPE_PWM,
15006 +};
15007 +
15008 +/*
15009 + * IR code mapping to event code.
15010 + * If there are no button mappings and no ir mappings
15011 + * then no input driver will be registered.
15012 + */
15013 +struct ubicom32hid_ir {
15014 + /*
15015 + * Input event code (KEY_*, SW_*, etc)
15016 + */
15017 + int code;
15018 +
15019 + /*
15020 + * Input event type (EV_KEY, EV_SW, etc)
15021 + */
15022 + int type;
15023 +
15024 + /*
15025 + * The IR code of this button.
15026 + */
15027 + uint32_t ir_code;
15028 +};
15029 +
15030 +/*
15031 + * Button mapping to event code.
15032 + * If there are no button mappings and no ir mappings
15033 + * then no input driver will be registered.
15034 + */
15035 +struct ubicom32hid_button {
15036 + /*
15037 + * Input event code (KEY_*, SW_*, etc)
15038 + */
15039 + int code;
15040 +
15041 + /*
15042 + * Input event type (EV_KEY, EV_SW, etc)
15043 + */
15044 + int type;
15045 +
15046 + /*
15047 + * Bit number of this button.
15048 + */
15049 + uint8_t bit;
15050 +};
15051 +
15052 +struct ubicom32hid_platform_data {
15053 + /*
15054 + * Default intensity of the backlight 0-255
15055 + */
15056 + u8_t default_intensity;
15057 +
15058 + /*
15059 + * GPIO number of the reset line and its polarity.
15060 + */
15061 + unsigned gpio_reset;
15062 + int gpio_reset_polarity;
15063 +
15064 + /*
15065 + * TRUE if the backlight sense is active low. (inverted)
15066 + * FALSE if the backlight sense is active high.
15067 + */
15068 + bool invert;
15069 +
15070 + /*
15071 + * Type of the backlight we are controlling
15072 + */
15073 + enum ubicom32hid_bl_types type;
15074 +
15075 + /*
15076 + * Optional polling rate for input, in ms, defaults to 100ms
15077 + */
15078 + int poll_interval;
15079 +
15080 + /*
15081 + * Optional name to register as input device
15082 + */
15083 + const char *input_name;
15084 +
15085 + /*
15086 + * Button mapping array
15087 + */
15088 + const struct ubicom32hid_button *buttons;
15089 + int nbuttons;
15090 +
15091 + /*
15092 + * IR mapping array
15093 + */
15094 + const struct ubicom32hid_ir *ircodes;
15095 + int nircodes;
15096 +};
15097 +
15098 +#endif /* _ASM_UBICOM32_UBICOM32_HID_H */
15099 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32input.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32input.h
15100 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32input.h 1970-01-01 02:00:00.000000000 +0200
15101 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32input.h 2009-12-11 11:45:11.000000000 +0200
15102 @@ -0,0 +1,76 @@
15103 +/*
15104 + * arch/ubicom32/include/asm/ubicom32input.h
15105 + * Ubicom32 Input driver, based on gpio-keys
15106 + *
15107 + * (C) Copyright 2009, Ubicom, Inc.
15108 + *
15109 + * This file is part of the Ubicom32 Linux Kernel Port.
15110 + *
15111 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15112 + * it and/or modify it under the terms of the GNU General Public License
15113 + * as published by the Free Software Foundation, either version 2 of the
15114 + * License, or (at your option) any later version.
15115 + *
15116 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15117 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15118 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15119 + * the GNU General Public License for more details.
15120 + *
15121 + * You should have received a copy of the GNU General Public License
15122 + * along with the Ubicom32 Linux Kernel Port. If not,
15123 + * see <http://www.gnu.org/licenses/>.
15124 + *
15125 + * Ubicom32 implementation derived from (with many thanks):
15126 + * arch/m68knommu
15127 + * arch/blackfin
15128 + * arch/parisc
15129 + *
15130 + * TODO: add groups for inputs which can be sampled together
15131 + */
15132 +
15133 +#ifndef _ASM_UBICOM32_UBICOM32_INPUT_H
15134 +#define _ASM_UBICOM32_UBICOM32_INPUT_H
15135 +
15136 +struct ubicom32input_button {
15137 + /*
15138 + * Input event code (KEY_*, SW_*, etc)
15139 + */
15140 + int code;
15141 +
15142 + /*
15143 + * Input event type (EV_KEY, EV_SW, etc)
15144 + */
15145 + int type;
15146 +
15147 + /*
15148 + * GPIO to poll
15149 + */
15150 + int gpio;
15151 +
15152 + /*
15153 + * 1 for active low, 0 for active high
15154 + */
15155 + int active_low;
15156 +
15157 + /*
15158 + * Description, used for reserving GPIOs
15159 + */
15160 + const char *desc;
15161 +};
15162 +
15163 +struct ubicom32input_platform_data {
15164 + struct ubicom32input_button *buttons;
15165 + int nbuttons;
15166 +
15167 + /*
15168 + * Optional poll interval, in ms, defaults to 50ms
15169 + */
15170 + int poll_interval;
15171 +
15172 + /*
15173 + * Option Name of this driver
15174 + */
15175 + const char *name;
15176 +};
15177 +
15178 +#endif /* _ASM_UBICOM32_UBICOM32_INPUT_H */
15179 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32input_i2c.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32input_i2c.h
15180 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32input_i2c.h 1970-01-01 02:00:00.000000000 +0200
15181 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32input_i2c.h 2009-12-11 11:45:11.000000000 +0200
15182 @@ -0,0 +1,71 @@
15183 +/*
15184 + * arch/ubicom32/include/asm/ubicom32input_i2c.h
15185 + * Ubicom32 architecture Input driver over I2C platform data definitions.
15186 + *
15187 + * (C) Copyright 2009, Ubicom, Inc.
15188 + *
15189 + * This file is part of the Ubicom32 Linux Kernel Port.
15190 + *
15191 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15192 + * it and/or modify it under the terms of the GNU General Public License
15193 + * as published by the Free Software Foundation, either version 2 of the
15194 + * License, or (at your option) any later version.
15195 + *
15196 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15197 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15198 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15199 + * the GNU General Public License for more details.
15200 + *
15201 + * You should have received a copy of the GNU General Public License
15202 + * along with the Ubicom32 Linux Kernel Port. If not,
15203 + * see <http://www.gnu.org/licenses/>.
15204 + *
15205 + * Ubicom32 implementation derived from (with many thanks):
15206 + * arch/m68knommu
15207 + * arch/blackfin
15208 + * arch/parisc
15209 + *
15210 + * TODO: add groups for inputs which can be sampled together
15211 + */
15212 +
15213 +#ifndef _ASM_UBICOM32_UBICOM32_INPUT_I2C_H
15214 +#define _ASM_UBICOM32_UBICOM32_INPUT_I2C_H
15215 +
15216 +struct ubicom32input_i2c_button {
15217 + /*
15218 + * Input event code (KEY_*, SW_*, etc)
15219 + */
15220 + int code;
15221 +
15222 + /*
15223 + * Input event type (EV_KEY, EV_SW, etc)
15224 + */
15225 + int type;
15226 +
15227 + /*
15228 + * Bit number of this button. (0 - ngpio)
15229 + */
15230 + int bit;
15231 +
15232 + /*
15233 + * 1 for active low, 0 for active high
15234 + */
15235 + int active_low;
15236 +};
15237 +
15238 +struct ubicom32input_i2c_platform_data {
15239 + struct ubicom32input_i2c_button *buttons;
15240 + int nbuttons;
15241 +
15242 + /*
15243 + * Optional poll interval, in ms, defaults to 100ms
15244 + */
15245 + int poll_interval;
15246 +
15247 + /*
15248 + * Option Name of this driver
15249 + */
15250 + const char *name;
15251 +};
15252 +
15253 +#endif /* _ASM_UBICOM32_UBICOM32_INPUT_I2C_H */
15254 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32lcd.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32lcd.h
15255 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32lcd.h 1970-01-01 02:00:00.000000000 +0200
15256 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32lcd.h 2009-12-11 11:45:11.000000000 +0200
15257 @@ -0,0 +1,38 @@
15258 +/*
15259 + * arch/ubicom32/include/asm/ubicom32lcd.h
15260 + * Ubicom32 architecture LCD driver platform data definitions.
15261 + *
15262 + * (C) Copyright 2009, Ubicom, Inc.
15263 + *
15264 + * This file is part of the Ubicom32 Linux Kernel Port.
15265 + *
15266 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15267 + * it and/or modify it under the terms of the GNU General Public License
15268 + * as published by the Free Software Foundation, either version 2 of the
15269 + * License, or (at your option) any later version.
15270 + *
15271 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15272 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15273 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15274 + * the GNU General Public License for more details.
15275 + *
15276 + * You should have received a copy of the GNU General Public License
15277 + * along with the Ubicom32 Linux Kernel Port. If not,
15278 + * see <http://www.gnu.org/licenses/>.
15279 + */
15280 +#ifndef _ASM_UBICOM32_UBICOM32_LCD_H
15281 +#define _ASM_UBICOM32_UBICOM32_LCD_H
15282 +
15283 +#include <asm/ip5000.h>
15284 +
15285 +struct ubicom32lcd_platform_data {
15286 + int pin_cs;
15287 + int pin_rs;
15288 + int pin_rd;
15289 + int pin_wr;
15290 + int pin_reset;
15291 + int data_shift;
15292 + struct ubicom32_io_port *port_data;
15293 +};
15294 +
15295 +#endif /* _ASM_UBICOM32_UBICOM32_LCD_H */
15296 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32lcdpower.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32lcdpower.h
15297 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32lcdpower.h 1970-01-01 02:00:00.000000000 +0200
15298 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32lcdpower.h 2009-12-11 11:45:11.000000000 +0200
15299 @@ -0,0 +1,39 @@
15300 +/*
15301 + * arch/ubicom32/include/asm/ubicom32lcdpower.h
15302 + * Ubicom32 architecture LCD driver platform data definitions.
15303 + *
15304 + * (C) Copyright 2009, Ubicom, Inc.
15305 + *
15306 + * This file is part of the Ubicom32 Linux Kernel Port.
15307 + *
15308 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15309 + * it and/or modify it under the terms of the GNU General Public License
15310 + * as published by the Free Software Foundation, either version 2 of the
15311 + * License, or (at your option) any later version.
15312 + *
15313 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15314 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15315 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15316 + * the GNU General Public License for more details.
15317 + *
15318 + * You should have received a copy of the GNU General Public License
15319 + * along with the Ubicom32 Linux Kernel Port. If not,
15320 + * see <http://www.gnu.org/licenses/>.
15321 + *
15322 + * Ubicom32 implementation derived from (with many thanks):
15323 + * arch/m68knommu
15324 + * arch/blackfin
15325 + * arch/parisc
15326 + */
15327 +#ifndef _ASM_UBICOM32_UBICOM32_LCDPOWER_H
15328 +#define _ASM_UBICOM32_UBICOM32_LCDPOWER_H
15329 +
15330 +struct ubicom32lcdpower_platform_data {
15331 + /*
15332 + * GPIO and polarity for VGH signal. A FALSE polarity is active low, TRUE is active high.
15333 + */
15334 + int vgh_gpio;
15335 + bool vgh_polarity;
15336 +};
15337 +
15338 +#endif /* _ASM_UBICOM32_UBICOM32_LCDPOWER_H */
15339 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32ring.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32ring.h
15340 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32ring.h 1970-01-01 02:00:00.000000000 +0200
15341 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32ring.h 2009-12-11 11:45:11.000000000 +0200
15342 @@ -0,0 +1,103 @@
15343 +/*
15344 + * arch/ubicom32/include/asm/ubicom32ring.h
15345 + * Userspace I/O platform driver for Ubicom32 ring buffers
15346 + *
15347 + * (C) Copyright 2009, Ubicom, Inc.
15348 + *
15349 + * This file is part of the Ubicom32 Linux Kernel Port.
15350 + *
15351 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15352 + * it and/or modify it under the terms of the GNU General Public License
15353 + * as published by the Free Software Foundation, either version 2 of the
15354 + * License, or (at your option) any later version.
15355 + *
15356 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15357 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15358 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15359 + * the GNU General Public License for more details.
15360 + *
15361 + * You should have received a copy of the GNU General Public License
15362 + * along with the Ubicom32 Linux Kernel Port. If not,
15363 + * see <http://www.gnu.org/licenses/>.
15364 + */
15365 +
15366 +#ifndef _ASM_UBICOM32_UBICOM32RING_H
15367 +#define _ASM_UBICOM32_UBICOM32RING_H
15368 +
15369 +#define UIO_UBICOM32RING_REG_VERSION 2
15370 +
15371 +struct uio_ubicom32ring_desc {
15372 + volatile unsigned int head;
15373 + volatile unsigned int tail;
15374 + unsigned int entries;
15375 + volatile unsigned int ring[0];
15376 +};
15377 +
15378 +struct uio_ubicom32ring_regs {
15379 + unsigned int version;
15380 +
15381 + /*
15382 + * Magic type used to identify the ring set. Each driver will
15383 + * have a different magic value.
15384 + */
15385 + unsigned int magic;
15386 +
15387 + /*
15388 + * Registers defined by the driver
15389 + */
15390 + unsigned int regs_size;
15391 + void *regs;
15392 +
15393 + /*
15394 + * The locations of the rings
15395 + *
15396 + * DO NOT ADD ANYTHING BELOW THIS LINE
15397 + */
15398 + unsigned int num_rings;
15399 + struct uio_ubicom32ring_desc *rings[0];
15400 +};
15401 +
15402 +/*
15403 + * ringtio_ring_flush
15404 + */
15405 +static inline void ringtio_ring_flush(struct uio_ubicom32ring_desc *rd)
15406 +{
15407 + rd->head = rd->tail = 0;
15408 +}
15409 +
15410 +/*
15411 + * ringtio_ring_get
15412 + */
15413 +static inline int ringtio_ring_get(struct uio_ubicom32ring_desc *rd, void **val)
15414 +{
15415 + if (rd->head == rd->tail) {
15416 + return 0;
15417 + }
15418 +
15419 + *val = (void *)rd->ring[rd->head++];
15420 + if (rd->head == rd->entries) {
15421 + rd->head = 0;
15422 + }
15423 + return 1;
15424 +}
15425 +
15426 +/*
15427 + * ringtio_ring_put
15428 + */
15429 +static inline int ringtio_ring_put(struct uio_ubicom32ring_desc *rd, void *val)
15430 +{
15431 + unsigned int newtail = rd->tail + 1;
15432 + if (newtail == rd->entries) {
15433 + newtail = 0;
15434 + }
15435 +
15436 + if (newtail == rd->head) {
15437 + return 0;
15438 + }
15439 +
15440 + rd->ring[rd->tail] = (unsigned int)val;
15441 + rd->tail = newtail;
15442 + return 1;
15443 +}
15444 +
15445 +#endif /* _ASM_UBICOM32_UBICOM32RING_H */
15446 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32sd.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32sd.h
15447 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32sd.h 1970-01-01 02:00:00.000000000 +0200
15448 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32sd.h 2009-12-11 11:45:11.000000000 +0200
15449 @@ -0,0 +1,45 @@
15450 +/*
15451 + * arch/ubicom32/include/asm/ubicom32sd.h
15452 + * Ubicom32SD public include file
15453 + *
15454 + * (C) Copyright 2009, Ubicom, Inc.
15455 + *
15456 + * This file is part of the Ubicom32 Linux Kernel Port.
15457 + *
15458 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15459 + * it and/or modify it under the terms of the GNU General Public License
15460 + * as published by the Free Software Foundation, either version 2 of the
15461 + * License, or (at your option) any later version.
15462 + *
15463 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15464 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15465 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15466 + * the GNU General Public License for more details.
15467 + *
15468 + * You should have received a copy of the GNU General Public License
15469 + * along with the Ubicom32 Linux Kernel Port. If not,
15470 + * see <http://www.gnu.org/licenses/>.
15471 + */
15472 +#ifndef _ASM_UBICOM32_UBICOM32_SD_H
15473 +#define _ASM_UBICOM32_UBICOM32_SD_H
15474 +
15475 +struct ubicom32sd_card {
15476 + /*
15477 + * GPIOs of PWR, WP and CD lines.
15478 + * Polarity is 1 for active high and 0 for active low
15479 + */
15480 + int pin_pwr;
15481 + bool pwr_polarity;
15482 + int pin_wp;
15483 + bool wp_polarity;
15484 + int pin_cd;
15485 + bool cd_polarity;
15486 +};
15487 +
15488 +struct ubicom32sd_platform_data {
15489 + int ncards;
15490 +
15491 + struct ubicom32sd_card *cards;
15492 +};
15493 +
15494 +#endif /* _ASM_UBICOM32_UBICOM32_SD_H */
15495 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-spi-gpio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-spi-gpio.h
15496 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-spi-gpio.h 1970-01-01 02:00:00.000000000 +0200
15497 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-spi-gpio.h 2009-12-11 11:45:11.000000000 +0200
15498 @@ -0,0 +1,62 @@
15499 +/*
15500 + * arch/ubicom32/include/asm/ubicom32-spi-gpio.h
15501 + * Platform driver data definitions for GPIO based SPI driver.
15502 + *
15503 + * (C) Copyright 2009, Ubicom, Inc.
15504 + *
15505 + * This file is part of the Ubicom32 Linux Kernel Port.
15506 + *
15507 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15508 + * it and/or modify it under the terms of the GNU General Public License
15509 + * as published by the Free Software Foundation, either version 2 of the
15510 + * License, or (at your option) any later version.
15511 + *
15512 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15513 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15514 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15515 + * the GNU General Public License for more details.
15516 + *
15517 + * You should have received a copy of the GNU General Public License
15518 + * along with the Ubicom32 Linux Kernel Port. If not,
15519 + * see <http://www.gnu.org/licenses/>.
15520 + *
15521 + * Ubicom32 implementation derived from (with many thanks):
15522 + * arch/m68knommu
15523 + * arch/blackfin
15524 + * arch/parisc
15525 + */
15526 +#ifndef _ASM_UBICOM32_UBICOM32_SPI_GPIO_H
15527 +#define _ASM_UBICOM32_UBICOM32_SPI_GPIO_H
15528 +
15529 +struct ubicom32_spi_gpio_platform_data {
15530 + /*
15531 + * GPIO to use for MOSI, MISO, CLK
15532 + */
15533 + int pin_mosi;
15534 + int pin_miso;
15535 + int pin_clk;
15536 +
15537 + /*
15538 + * Default state of CLK line
15539 + */
15540 + int clk_default;
15541 +
15542 + /*
15543 + * Number of chip selects on this bus
15544 + */
15545 + int num_chipselect;
15546 +
15547 + /*
15548 + * The bus number of this chip
15549 + */
15550 + int bus_num;
15551 +};
15552 +
15553 +struct ubicom32_spi_gpio_controller_data {
15554 + /*
15555 + * GPIO to use for chip select
15556 + */
15557 + int pin_cs;
15558 +};
15559 +
15560 +#endif /* _ASM_UBICOM32_UBICOM32_SPI_GPIO_H */
15561 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32suart.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32suart.h
15562 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32suart.h 1970-01-01 02:00:00.000000000 +0200
15563 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32suart.h 2009-12-11 11:45:11.000000000 +0200
15564 @@ -0,0 +1,36 @@
15565 +/*
15566 + * arch/ubicom32/include/asm/ubicom32suart.h
15567 + * <TODO: Replace with short file description>
15568 + *
15569 + * (C) Copyright 2009, Ubicom, Inc.
15570 + *
15571 + * This file is part of the Ubicom32 Linux Kernel Port.
15572 + *
15573 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15574 + * it and/or modify it under the terms of the GNU General Public License
15575 + * as published by the Free Software Foundation, either version 2 of the
15576 + * License, or (at your option) any later version.
15577 + *
15578 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15579 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15580 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15581 + * the GNU General Public License for more details.
15582 + *
15583 + * You should have received a copy of the GNU General Public License
15584 + * along with the Ubicom32 Linux Kernel Port. If not,
15585 + * see <http://www.gnu.org/licenses/>.
15586 + *
15587 + * Ubicom32 implementation derived from (with many thanks):
15588 + * arch/m68knommu
15589 + * arch/blackfin
15590 + * arch/parisc
15591 + */
15592 +#ifndef _ASM_UBICOM32_UBICOM32_SUART_H
15593 +#define _ASM_UBICOM32_UBICOM32_SUART_H
15594 +
15595 +/*
15596 + * Platform resource id for serdes uart clock parameter
15597 + */
15598 +#define UBICOM32_SUART_IORESOURCE_CLOCK (1)
15599 +
15600 +#endif /* _ASM_UBICOM32_UBICOM32_SUART_H */
15601 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-tio.h
15602 --- linux-2.6.30.10/arch/ubicom32/include/asm/ubicom32-tio.h 1970-01-01 02:00:00.000000000 +0200
15603 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ubicom32-tio.h 2009-12-11 11:45:11.000000000 +0200
15604 @@ -0,0 +1,42 @@
15605 +/*
15606 + * arch/ubicom32/include/asm/ubicom32-tio.h
15607 + * Threaded I/O interface definitions.
15608 + *
15609 + * (C) Copyright 2009, Ubicom, Inc.
15610 + *
15611 + * This file is part of the Ubicom32 Linux Kernel Port.
15612 + *
15613 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15614 + * it and/or modify it under the terms of the GNU General Public License
15615 + * as published by the Free Software Foundation, either version 2 of the
15616 + * License, or (at your option) any later version.
15617 + *
15618 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15619 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15620 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15621 + * the GNU General Public License for more details.
15622 + *
15623 + * You should have received a copy of the GNU General Public License
15624 + * along with the Ubicom32 Linux Kernel Port. If not,
15625 + * see <http://www.gnu.org/licenses/>.
15626 + *
15627 + * Ubicom32 implementation derived from (with many thanks):
15628 + * arch/m68knommu
15629 + * arch/blackfin
15630 + * arch/parisc
15631 + */
15632 +#ifndef _ASM_UBICOM32_UBICOM32_TIO_H
15633 +#define _ASM_UBICOM32_UBICOM32_TIO_H
15634 +
15635 +extern u8_t usb_tio_read_u16(u32_t address, u16_t *data);
15636 +extern u8_t usb_tio_read_u8(u32_t address, u8_t *data);
15637 +
15638 +extern u8_t usb_tio_write_u16(u32_t address, u16_t data);
15639 +extern u8_t usb_tio_write_u8(u32_t address, u8_t data);
15640 +
15641 +extern u8_t usb_tio_read_fifo(u32_t address, u32_t buffer, u32_t bytes);
15642 +extern u8_t usb_tio_write_fifo(u32_t address, u32_t buffer, u32_t bytes);
15643 +extern u8_t usb_tio_write_fifo_sync(u32_t address, u32_t buffer, u32_t bytes);
15644 +extern void usb_tio_read_int_status(u8_t *int_usb, u16_t *int_tx, u16_t *int_rx);
15645 +
15646 +#endif /* _ASM_UBICOM32_UBICOM32_TIO_H */
15647 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/ucontext.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ucontext.h
15648 --- linux-2.6.30.10/arch/ubicom32/include/asm/ucontext.h 1970-01-01 02:00:00.000000000 +0200
15649 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/ucontext.h 2009-12-11 11:45:11.000000000 +0200
15650 @@ -0,0 +1,39 @@
15651 +/*
15652 + * arch/ubicom32/include/asm/ucontext.h
15653 + * Definition of ucontext structure for Ubicom32 architecture.
15654 + *
15655 + * (C) Copyright 2009, Ubicom, Inc.
15656 + *
15657 + * This file is part of the Ubicom32 Linux Kernel Port.
15658 + *
15659 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15660 + * it and/or modify it under the terms of the GNU General Public License
15661 + * as published by the Free Software Foundation, either version 2 of the
15662 + * License, or (at your option) any later version.
15663 + *
15664 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15665 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15666 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15667 + * the GNU General Public License for more details.
15668 + *
15669 + * You should have received a copy of the GNU General Public License
15670 + * along with the Ubicom32 Linux Kernel Port. If not,
15671 + * see <http://www.gnu.org/licenses/>.
15672 + *
15673 + * Ubicom32 implementation derived from (with many thanks):
15674 + * arch/m68knommu
15675 + * arch/blackfin
15676 + * arch/parisc
15677 + */
15678 +#ifndef _ASM_UBICOM32_UCONTEXT_H
15679 +#define _ASM_UBICOM32_UCONTEXT_H
15680 +
15681 +struct ucontext {
15682 + unsigned long uc_flags;
15683 + struct ucontext *uc_link;
15684 + stack_t uc_stack;
15685 + struct sigcontext uc_mcontext;
15686 + sigset_t uc_sigmask; /* mask last for extensibility */
15687 +};
15688 +
15689 +#endif /* _ASM_UBICOM32_UCONTEXT_H */
15690 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/unaligned.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/unaligned.h
15691 --- linux-2.6.30.10/arch/ubicom32/include/asm/unaligned.h 1970-01-01 02:00:00.000000000 +0200
15692 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/unaligned.h 2009-12-11 11:45:11.000000000 +0200
15693 @@ -0,0 +1,44 @@
15694 +/*
15695 + * arch/ubicom32/include/asm/unaligned.h
15696 + * Ubicom32 architecture unaligned memory access definitions.
15697 + *
15698 + * (C) Copyright 2009, Ubicom, Inc.
15699 + *
15700 + * This file is part of the Ubicom32 Linux Kernel Port.
15701 + *
15702 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15703 + * it and/or modify it under the terms of the GNU General Public License
15704 + * as published by the Free Software Foundation, either version 2 of the
15705 + * License, or (at your option) any later version.
15706 + *
15707 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15708 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15709 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15710 + * the GNU General Public License for more details.
15711 + *
15712 + * You should have received a copy of the GNU General Public License
15713 + * along with the Ubicom32 Linux Kernel Port. If not,
15714 + * see <http://www.gnu.org/licenses/>.
15715 + *
15716 + * Ubicom32 implementation derived from (with many thanks):
15717 + * arch/m68knommu
15718 + * arch/blackfin
15719 + * arch/parisc
15720 + *
15721 + * TODO: This is a copy of arm unaligned handling that probably needs
15722 + * to be optimized for UBICOM32, but it works for now.
15723 + */
15724 +
15725 +#ifndef _ASM_UBICOM32_UNALIGNED_H
15726 +#define _ASM_UBICOM32_UNALIGNED_H
15727 +
15728 +#include <asm/types.h>
15729 +
15730 +#include <linux/unaligned/le_byteshift.h>
15731 +#include <linux/unaligned/be_byteshift.h>
15732 +#include <linux/unaligned/generic.h>
15733 +
15734 +#define get_unaligned __get_unaligned_be
15735 +#define put_unaligned __put_unaligned_be
15736 +
15737 +#endif /* _ASM_UBICOM32_UNALIGNED_H */
15738 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/unistd.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/unistd.h
15739 --- linux-2.6.30.10/arch/ubicom32/include/asm/unistd.h 1970-01-01 02:00:00.000000000 +0200
15740 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/unistd.h 2009-12-11 11:45:11.000000000 +0200
15741 @@ -0,0 +1,400 @@
15742 +/*
15743 + * arch/ubicom32/include/asm/unistd.h
15744 + * Ubicom32 architecture syscall definitions.
15745 + *
15746 + * (C) Copyright 2009, Ubicom, Inc.
15747 + *
15748 + * This file is part of the Ubicom32 Linux Kernel Port.
15749 + *
15750 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
15751 + * it and/or modify it under the terms of the GNU General Public License
15752 + * as published by the Free Software Foundation, either version 2 of the
15753 + * License, or (at your option) any later version.
15754 + *
15755 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
15756 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
15757 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15758 + * the GNU General Public License for more details.
15759 + *
15760 + * You should have received a copy of the GNU General Public License
15761 + * along with the Ubicom32 Linux Kernel Port. If not,
15762 + * see <http://www.gnu.org/licenses/>.
15763 + *
15764 + * Ubicom32 implementation derived from (with many thanks):
15765 + * arch/m68knommu
15766 + * arch/blackfin
15767 + * arch/parisc
15768 + */
15769 +#ifndef _ASM_UBICOM32_UNISTD_H
15770 +#define _ASM_UBICOM32_UNISTD_H
15771 +
15772 +/*
15773 + * This file contains the system call numbers.
15774 + */
15775 +
15776 +#define __NR_restart_syscall 0
15777 +#define __NR_exit 1
15778 +#define __NR_fork 2
15779 +#define __NR_read 3
15780 +#define __NR_write 4
15781 +#define __NR_open 5
15782 +#define __NR_close 6
15783 +#define __NR_waitpid 7
15784 +#define __NR_creat 8
15785 +#define __NR_link 9
15786 +#define __NR_unlink 10
15787 +#define __NR_execve 11
15788 +#define __NR_chdir 12
15789 +#define __NR_time 13
15790 +#define __NR_mknod 14
15791 +#define __NR_chmod 15
15792 +#define __NR_chown 16
15793 +#define __NR_break 17
15794 +#define __NR_oldstat 18
15795 +#define __NR_lseek 19
15796 +#define __NR_getpid 20
15797 +#define __NR_mount 21
15798 +#define __NR_umount 22
15799 +#define __NR_setuid 23
15800 +#define __NR_getuid 24
15801 +#define __NR_stime 25
15802 +#define __NR_ptrace 26
15803 +#define __NR_alarm 27
15804 +#define __NR_oldfstat 28
15805 +#define __NR_pause 29
15806 +#define __NR_utime 30
15807 +#define __NR_stty 31
15808 +#define __NR_gtty 32
15809 +#define __NR_access 33
15810 +#define __NR_nice 34
15811 +#define __NR_ftime 35
15812 +#define __NR_sync 36
15813 +#define __NR_kill 37
15814 +#define __NR_rename 38
15815 +#define __NR_mkdir 39
15816 +#define __NR_rmdir 40
15817 +#define __NR_dup 41
15818 +#define __NR_pipe 42
15819 +#define __NR_times 43
15820 +#define __NR_prof 44
15821 +#define __NR_brk 45
15822 +#define __NR_setgid 46
15823 +#define __NR_getgid 47
15824 +#define __NR_signal 48
15825 +#define __NR_geteuid 49
15826 +#define __NR_getegid 50
15827 +#define __NR_acct 51
15828 +#define __NR_umount2 52
15829 +#define __NR_lock 53
15830 +#define __NR_ioctl 54
15831 +#define __NR_fcntl 55
15832 +#define __NR_mpx 56
15833 +#define __NR_setpgid 57
15834 +#define __NR_ulimit 58
15835 +#define __NR_oldolduname 59
15836 +#define __NR_umask 60
15837 +#define __NR_chroot 61
15838 +#define __NR_ustat 62
15839 +#define __NR_dup2 63
15840 +#define __NR_getppid 64
15841 +#define __NR_getpgrp 65
15842 +#define __NR_setsid 66
15843 +#define __NR_sigaction 67
15844 +#define __NR_sgetmask 68
15845 +#define __NR_ssetmask 69
15846 +#define __NR_setreuid 70
15847 +#define __NR_setregid 71
15848 +#define __NR_sigsuspend 72
15849 +#define __NR_sigpending 73
15850 +#define __NR_sethostname 74
15851 +#define __NR_setrlimit 75
15852 +#define __NR_getrlimit 76
15853 +#define __NR_getrusage 77
15854 +#define __NR_gettimeofday 78
15855 +#define __NR_settimeofday 79
15856 +#define __NR_getgroups 80
15857 +#define __NR_setgroups 81
15858 +#define __NR_select 82
15859 +#define __NR_symlink 83
15860 +#define __NR_oldlstat 84
15861 +#define __NR_readlink 85
15862 +#define __NR_uselib 86
15863 +#define __NR_swapon 87
15864 +#define __NR_reboot 88
15865 +#define __NR_readdir 89
15866 +#define __NR_mmap 90
15867 +#define __NR_munmap 91
15868 +#define __NR_truncate 92
15869 +#define __NR_ftruncate 93
15870 +#define __NR_fchmod 94
15871 +#define __NR_fchown 95
15872 +#define __NR_getpriority 96
15873 +#define __NR_setpriority 97
15874 +#define __NR_profil 98
15875 +#define __NR_statfs 99
15876 +#define __NR_fstatfs 100
15877 +#define __NR_ioperm 101
15878 +#define __NR_socketcall 102
15879 +#define __NR_syslog 103
15880 +#define __NR_setitimer 104
15881 +#define __NR_getitimer 105
15882 +#define __NR_stat 106
15883 +#define __NR_lstat 107
15884 +#define __NR_fstat 108
15885 +#define __NR_olduname 109
15886 +#define __NR_iopl /* 110 */ not supported
15887 +#define __NR_vhangup 111
15888 +#define __NR_idle /* 112 */ Obsolete
15889 +#define __NR_vm86 /* 113 */ not supported
15890 +#define __NR_wait4 114
15891 +#define __NR_swapoff 115
15892 +#define __NR_sysinfo 116
15893 +#define __NR_ipc 117
15894 +#define __NR_fsync 118
15895 +#define __NR_sigreturn 119
15896 +#define __NR_clone 120
15897 +#define __NR_setdomainname 121
15898 +#define __NR_uname 122
15899 +#define __NR_cacheflush 123
15900 +#define __NR_adjtimex 124
15901 +#define __NR_mprotect 125
15902 +#define __NR_sigprocmask 126
15903 +#define __NR_create_module 127
15904 +#define __NR_init_module 128
15905 +#define __NR_delete_module 129
15906 +#define __NR_get_kernel_syms 130
15907 +#define __NR_quotactl 131
15908 +#define __NR_getpgid 132
15909 +#define __NR_fchdir 133
15910 +#define __NR_bdflush 134
15911 +#define __NR_sysfs 135
15912 +#define __NR_personality 136
15913 +#define __NR_afs_syscall 137 /* Syscall for Andrew File System */
15914 +#define __NR_setfsuid 138
15915 +#define __NR_setfsgid 139
15916 +#define __NR__llseek 140
15917 +#define __NR_getdents 141
15918 +#define __NR__newselect 142
15919 +#define __NR_flock 143
15920 +#define __NR_msync 144
15921 +#define __NR_readv 145
15922 +#define __NR_writev 146
15923 +#define __NR_getsid 147
15924 +#define __NR_fdatasync 148
15925 +#define __NR__sysctl 149
15926 +#define __NR_mlock 150
15927 +#define __NR_munlock 151
15928 +#define __NR_mlockall 152
15929 +#define __NR_munlockall 153
15930 +#define __NR_sched_setparam 154
15931 +#define __NR_sched_getparam 155
15932 +#define __NR_sched_setscheduler 156
15933 +#define __NR_sched_getscheduler 157
15934 +#define __NR_sched_yield 158
15935 +#define __NR_sched_get_priority_max 159
15936 +#define __NR_sched_get_priority_min 160
15937 +#define __NR_sched_rr_get_interval 161
15938 +#define __NR_nanosleep 162
15939 +#define __NR_mremap 163
15940 +#define __NR_setresuid 164
15941 +#define __NR_getresuid 165
15942 +#define __NR_getpagesize 166
15943 +#define __NR_query_module 167
15944 +#define __NR_poll 168
15945 +#define __NR_nfsservctl 169
15946 +#define __NR_setresgid 170
15947 +#define __NR_getresgid 171
15948 +#define __NR_prctl 172
15949 +#define __NR_rt_sigreturn 173
15950 +#define __NR_rt_sigaction 174
15951 +#define __NR_rt_sigprocmask 175
15952 +#define __NR_rt_sigpending 176
15953 +#define __NR_rt_sigtimedwait 177
15954 +#define __NR_rt_sigqueueinfo 178
15955 +#define __NR_rt_sigsuspend 179
15956 +#define __NR_pread64 180
15957 +#define __NR_pwrite64 181
15958 +#define __NR_lchown 182
15959 +#define __NR_getcwd 183
15960 +#define __NR_capget 184
15961 +#define __NR_capset 185
15962 +#define __NR_sigaltstack 186
15963 +#define __NR_sendfile 187
15964 +#define __NR_getpmsg 188 /* some people actually want streams */
15965 +#define __NR_putpmsg 189 /* some people actually want streams */
15966 +#define __NR_vfork 190
15967 +#define __NR_ugetrlimit 191
15968 +#define __NR_mmap2 192
15969 +#define __NR_truncate64 193
15970 +#define __NR_ftruncate64 194
15971 +#define __NR_stat64 195
15972 +#define __NR_lstat64 196
15973 +#define __NR_fstat64 197
15974 +#define __NR_chown32 198
15975 +#define __NR_getuid32 199
15976 +#define __NR_getgid32 200
15977 +#define __NR_geteuid32 201
15978 +#define __NR_getegid32 202
15979 +#define __NR_setreuid32 203
15980 +#define __NR_setregid32 204
15981 +#define __NR_getgroups32 205
15982 +#define __NR_setgroups32 206
15983 +#define __NR_fchown32 207
15984 +#define __NR_setresuid32 208
15985 +#define __NR_getresuid32 209
15986 +#define __NR_setresgid32 210
15987 +#define __NR_getresgid32 211
15988 +#define __NR_lchown32 212
15989 +#define __NR_setuid32 213
15990 +#define __NR_setgid32 214
15991 +#define __NR_setfsuid32 215
15992 +#define __NR_setfsgid32 216
15993 +#define __NR_pivot_root 217
15994 +#define __NR_getdents64 220
15995 +#define __NR_gettid 221
15996 +#define __NR_tkill 222
15997 +#define __NR_setxattr 223
15998 +#define __NR_lsetxattr 224
15999 +#define __NR_fsetxattr 225
16000 +#define __NR_getxattr 226
16001 +#define __NR_lgetxattr 227
16002 +#define __NR_fgetxattr 228
16003 +#define __NR_listxattr 229
16004 +#define __NR_llistxattr 230
16005 +#define __NR_flistxattr 231
16006 +#define __NR_removexattr 232
16007 +#define __NR_lremovexattr 233
16008 +#define __NR_fremovexattr 234
16009 +#define __NR_futex 235
16010 +#define __NR_sendfile64 236
16011 +#define __NR_mincore 237
16012 +#define __NR_madvise 238
16013 +#define __NR_fcntl64 239
16014 +#define __NR_readahead 240
16015 +#define __NR_io_setup 241
16016 +#define __NR_io_destroy 242
16017 +#define __NR_io_getevents 243
16018 +#define __NR_io_submit 244
16019 +#define __NR_io_cancel 245
16020 +#define __NR_fadvise64 246
16021 +#define __NR_exit_group 247
16022 +#define __NR_lookup_dcookie 248
16023 +#define __NR_epoll_create 249
16024 +#define __NR_epoll_ctl 250
16025 +#define __NR_epoll_wait 251
16026 +#define __NR_remap_file_pages 252
16027 +#define __NR_set_tid_address 253
16028 +#define __NR_timer_create 254
16029 +#define __NR_timer_settime 255
16030 +#define __NR_timer_gettime 256
16031 +#define __NR_timer_getoverrun 257
16032 +#define __NR_timer_delete 258
16033 +#define __NR_clock_settime 259
16034 +#define __NR_clock_gettime 260
16035 +#define __NR_clock_getres 261
16036 +#define __NR_clock_nanosleep 262
16037 +#define __NR_statfs64 263
16038 +#define __NR_fstatfs64 264
16039 +#define __NR_tgkill 265
16040 +#define __NR_utimes 266
16041 +#define __NR_fadvise64_64 267
16042 +#define __NR_mbind 268
16043 +#define __NR_get_mempolicy 269
16044 +#define __NR_set_mempolicy 270
16045 +#define __NR_mq_open 271
16046 +#define __NR_mq_unlink 272
16047 +#define __NR_mq_timedsend 273
16048 +#define __NR_mq_timedreceive 274
16049 +#define __NR_mq_notify 275
16050 +#define __NR_mq_getsetattr 276
16051 +#define __NR_waitid 277
16052 +#define __NR_vserver 278
16053 +#define __NR_add_key 279
16054 +#define __NR_request_key 280
16055 +#define __NR_keyctl 281
16056 +#define __NR_ioprio_set 282
16057 +#define __NR_ioprio_get 283
16058 +#define __NR_inotify_init 284
16059 +#define __NR_inotify_add_watch 285
16060 +#define __NR_inotify_rm_watch 286
16061 +#define __NR_migrate_pages 287
16062 +#define __NR_openat 288
16063 +#define __NR_mkdirat 289
16064 +#define __NR_mknodat 290
16065 +#define __NR_fchownat 291
16066 +#define __NR_futimesat 292
16067 +#define __NR_fstatat64 293
16068 +#define __NR_unlinkat 294
16069 +#define __NR_renameat 295
16070 +#define __NR_linkat 296
16071 +#define __NR_symlinkat 297
16072 +#define __NR_readlinkat 298
16073 +#define __NR_fchmodat 299
16074 +#define __NR_faccessat 300
16075 +#define __NR_pselect6 301
16076 +#define __NR_ppoll 302
16077 +#define __NR_unshare 303
16078 +#define __NR_set_robust_list 304
16079 +#define __NR_get_robust_list 305
16080 +#define __NR_splice 306
16081 +#define __NR_sync_file_range 307
16082 +#define __NR_tee 308
16083 +#define __NR_vmsplice 309
16084 +#define __NR_move_pages 310
16085 +#define __NR_sched_setaffinity 311
16086 +#define __NR_sched_getaffinity 312
16087 +#define __NR_kexec_load 313
16088 +#define __NR_getcpu 314
16089 +#define __NR_epoll_pwait 315
16090 +#define __NR_utimensat 316
16091 +#define __NR_signalfd 317
16092 +#define __NR_timerfd_create 318
16093 +#define __NR_eventfd 319
16094 +#define __NR_fallocate 320
16095 +#define __NR_timerfd_settime 321
16096 +#define __NR_timerfd_gettime 322
16097 +#define __NR_signalfd4 323
16098 +#define __NR_eventfd2 324
16099 +#define __NR_epoll_create1 325
16100 +#define __NR_dup3 326
16101 +#define __NR_pipe2 327
16102 +#define __NR_inotify_init1 328
16103 +
16104 +#ifdef __KERNEL__
16105 +
16106 +#define NR_syscalls 329
16107 +
16108 +#define __ARCH_WANT_IPC_PARSE_VERSION
16109 +#define __ARCH_WANT_OLD_READDIR
16110 +#define __ARCH_WANT_OLD_STAT
16111 +#define __ARCH_WANT_STAT64
16112 +#define __ARCH_WANT_SYS_ALARM
16113 +#define __ARCH_WANT_SYS_GETHOSTNAME
16114 +#define __ARCH_WANT_SYS_PAUSE
16115 +#define __ARCH_WANT_SYS_SGETMASK
16116 +#define __ARCH_WANT_SYS_SIGNAL
16117 +#define __ARCH_WANT_SYS_TIME
16118 +#define __ARCH_WANT_SYS_UTIME
16119 +#define __ARCH_WANT_SYS_WAITPID
16120 +#define __ARCH_WANT_SYS_SOCKETCALL
16121 +#define __ARCH_WANT_SYS_FADVISE64
16122 +#define __ARCH_WANT_SYS_GETPGRP
16123 +#define __ARCH_WANT_SYS_LLSEEK
16124 +#define __ARCH_WANT_SYS_NICE
16125 +#define __ARCH_WANT_SYS_OLD_GETRLIMIT
16126 +#define __ARCH_WANT_SYS_OLDUMOUNT
16127 +#define __ARCH_WANT_SYS_SIGPENDING
16128 +#define __ARCH_WANT_SYS_SIGPROCMASK
16129 +#define __ARCH_WANT_SYS_RT_SIGACTION
16130 +
16131 +/*
16132 + * "Conditional" syscalls
16133 + *
16134 + * What we want is __attribute__((weak,alias("sys_ni_syscall"))),
16135 + * but it doesn't work on all toolchains, so we just do it by hand
16136 + */
16137 +//#define cond_syscall(x) asm(".weak\t" #x "\n\t.set\t" #x ",sys_ni_syscall")
16138 +#define cond_syscall(x) long x(void) __attribute__((weak,alias("sys_ni_syscall")))
16139 +#endif /* __KERNEL__ */
16140 +
16141 +#endif /* _ASM_UBICOM32_UNISTD_H */
16142 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/user.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/user.h
16143 --- linux-2.6.30.10/arch/ubicom32/include/asm/user.h 1970-01-01 02:00:00.000000000 +0200
16144 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/user.h 2009-12-11 11:45:11.000000000 +0200
16145 @@ -0,0 +1,82 @@
16146 +/*
16147 + * arch/ubicom32/include/asm/user.h
16148 + * Ubicom32 architecture core file definitions.
16149 + *
16150 + * (C) Copyright 2009, Ubicom, Inc.
16151 + *
16152 + * This file is part of the Ubicom32 Linux Kernel Port.
16153 + *
16154 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
16155 + * it and/or modify it under the terms of the GNU General Public License
16156 + * as published by the Free Software Foundation, either version 2 of the
16157 + * License, or (at your option) any later version.
16158 + *
16159 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
16160 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16161 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16162 + * the GNU General Public License for more details.
16163 + *
16164 + * You should have received a copy of the GNU General Public License
16165 + * along with the Ubicom32 Linux Kernel Port. If not,
16166 + * see <http://www.gnu.org/licenses/>.
16167 + *
16168 + * Ubicom32 implementation derived from (with many thanks):
16169 + * arch/m68knommu
16170 + * arch/blackfin
16171 + * arch/parisc
16172 + */
16173 +#ifndef _ASM_UBICOM32_USER_H
16174 +#define _ASM_UBICOM32_USER_H
16175 +
16176 +#include <asm/ptrace.h>
16177 +#include <asm/page.h>
16178 +/*
16179 + * Adapted from <asm-powerpc/user.h>
16180 + *
16181 + * Core file format: The core file is written in such a way that gdb
16182 + * can understand it and provide useful information to the user (under
16183 + * linux we use the `trad-core' bfd, NOT the osf-core). The file contents
16184 + * are as follows:
16185 + *
16186 + * upage: 1 page consisting of a user struct that tells gdb
16187 + * what is present in the file. Directly after this is a
16188 + * copy of the task_struct, which is currently not used by gdb,
16189 + * but it may come in handy at some point. All of the registers
16190 + * are stored as part of the upage. The upage should always be
16191 + * only one page long.
16192 + * data: The data segment follows next. We use current->end_text to
16193 + * current->brk to pick up all of the user variables, plus any memory
16194 + * that may have been sbrk'ed. No attempt is made to determine if a
16195 + * page is demand-zero or if a page is totally unused, we just cover
16196 + * the entire range. All of the addresses are rounded in such a way
16197 + * that an integral number of pages is written.
16198 + * stack: We need the stack information in order to get a meaningful
16199 + * backtrace. We need to write the data from usp to
16200 + * current->start_stack, so we round each of these in order to be able
16201 + * to write an integer number of pages.
16202 + */
16203 +
16204 +struct user_ubicom32fp_struct {
16205 +};
16206 +
16207 +struct user {
16208 + struct pt_regs regs; /* entire machine state */
16209 + size_t u_tsize; /* text size (pages) */
16210 + size_t u_dsize; /* data size (pages) */
16211 + size_t u_ssize; /* stack size (pages) */
16212 + unsigned long start_code; /* text starting address */
16213 + unsigned long start_data; /* data starting address */
16214 + unsigned long start_stack; /* stack starting address */
16215 + long int signal; /* signal causing core dump */
16216 + unsigned long u_ar0; /* help gdb find registers */
16217 + unsigned long magic; /* identifies a core file */
16218 + char u_comm[32]; /* user command name */
16219 +};
16220 +
16221 +#define NBPG PAGE_SIZE
16222 +#define UPAGES 1
16223 +#define HOST_TEXT_START_ADDR (u.start_code)
16224 +#define HOST_DATA_START_ADDR (u.start_data)
16225 +#define HOST_STACK_END_ADDR (u.start_stack + u.u_ssize * NBPG)
16226 +
16227 +#endif /* _ASM_UBICOM32_USER_H */
16228 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/vdc_tio.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/vdc_tio.h
16229 --- linux-2.6.30.10/arch/ubicom32/include/asm/vdc_tio.h 1970-01-01 02:00:00.000000000 +0200
16230 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/vdc_tio.h 2009-12-11 11:45:11.000000000 +0200
16231 @@ -0,0 +1,129 @@
16232 +/*
16233 + * arch/ubicom32/include/asm/vdc_tio.h
16234 + * Ubicom32 architecture VDC TIO definitions.
16235 + *
16236 + * (C) Copyright 2009, Ubicom, Inc.
16237 + *
16238 + * This file is part of the Ubicom32 Linux Kernel Port.
16239 + *
16240 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
16241 + * it and/or modify it under the terms of the GNU General Public License
16242 + * as published by the Free Software Foundation, either version 2 of the
16243 + * License, or (at your option) any later version.
16244 + *
16245 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
16246 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16247 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16248 + * the GNU General Public License for more details.
16249 + *
16250 + * You should have received a copy of the GNU General Public License
16251 + * along with the Ubicom32 Linux Kernel Port. If not,
16252 + * see <http://www.gnu.org/licenses/>.
16253 + *
16254 + * Ubicom32 implementation derived from (with many thanks):
16255 + * arch/m68knommu
16256 + * arch/blackfin
16257 + * arch/parisc
16258 + */
16259 +#ifndef _ASM_UBICOM32_VDC_TIO_H
16260 +#define _ASM_UBICOM32_VDC_TIO_H
16261 +
16262 +#include <asm/devtree.h>
16263 +
16264 +#define VDCTIO_VP_VERSION 5
16265 +
16266 +#define VDCTIO_SCALE_FLAG_VSUB (1 << 9)
16267 +#define VDCTIO_SCALE_FLAG_YUV_SCAN_ORDER (1 << 8)
16268 +#define VDCTIO_SCALE_FLAG_YUV_BLOCK_ORDER (1 << 7)
16269 +#define VDCTIO_SCALE_FLAG_YUV (1 << 6)
16270 +#define VDCTIO_SCALE_FLAG_VRANGE_16_255 (1 << 5)
16271 +#define VDCTIO_SCALE_FLAG_VRANGE_0_255 (1 << 4)
16272 +#define VDCTIO_SCALE_FLAG_HSUB_2_1 (1 << 3)
16273 +#define VDCTIO_SCALE_FLAG_HSUB_1_1 (1 << 2)
16274 +#define VDCTIO_SCALE_FLAG_SET_FRAME_BUFFER (1 << 1)
16275 +#define VDCTIO_SCALE_FLAG_ENABLE (1 << 0)
16276 +
16277 +#define VDCTIO_NEXT_FRAME_FLAG_YUV_BIT 0
16278 +#define VDCTIO_NEXT_FRAME_FLAG_YUV (1 << (VDCTIO_NEXT_FRAME_FLAG_YUV_BIT))
16279 +
16280 +#define VDCTIO_CAPS_SUPPORTS_SCALING (1 << 0)
16281 +
16282 +#define VDCTIO_COMMAND_START (1 << 3)
16283 +#define VDCTIO_COMMAND_SET_COEFF (1 << 2)
16284 +#define VDCTIO_COMMAND_SET_LUT (1 << 1)
16285 +#define VDCTIO_COMMAND_SET_SCALE_MODE (1 << 0)
16286 +
16287 +/*
16288 + * Command / Data registers to access the VDC
16289 + */
16290 +struct vdc_tio_vp_regs {
16291 + /*
16292 + * Version of this TIO register map
16293 + */
16294 + u32_t version;
16295 +
16296 + volatile u32_t command;
16297 +
16298 + /*
16299 + * Next frame pointer, when the command VDCTIO_COMMAND_SET_FRAME_BUFFER is set,
16300 + * the vdc will take the pointer here and display it.
16301 + */
16302 + void *next_frame;
16303 + u32_t next_frame_flags;
16304 +
16305 + /*
16306 + * These map directly into the PIXP registers 0x20-0x80.
16307 + * DO NOT change the order of these three variables.
16308 + */
16309 + u32_t red_lut[6];
16310 + u32_t blue_lut[6];
16311 + u32_t green_lut[13];
16312 +
16313 + /*
16314 + * These map directly into the PIXP registers 0x04, 0x08
16315 + */
16316 + u32_t coeff0;
16317 + u32_t coeff1;
16318 +
16319 + /*
16320 + * There are used to set the scaling parameters
16321 + */
16322 + u32_t x_in;
16323 + u32_t x_out;
16324 + u32_t y_in;
16325 + u32_t y_out;
16326 + u32_t scale_flags;
16327 +
16328 + /*
16329 + * Current frame number, monotonically increasing number
16330 + */
16331 + u32_t frame_number;
16332 +
16333 + /*
16334 + * These variables tell the guest OS what the underlying hardware looks like
16335 + */
16336 + u32_t caps;
16337 + u32_t xres;
16338 + u32_t yres;
16339 + u32_t fb_align;
16340 + u8_t bpp;
16341 + u8_t rbits;
16342 + u8_t gbits;
16343 + u8_t bbits;
16344 + u8_t rshift;
16345 + u8_t gshift;
16346 + u8_t bshift;
16347 +};
16348 +
16349 +/*
16350 + * Devtree node for VDC
16351 + */
16352 +struct vdc_tio_node {
16353 + struct devtree_node dn;
16354 +
16355 + struct vdc_tio_vp_regs *regs;
16356 +};
16357 +
16358 +extern void vdc_tio_init(void);
16359 +
16360 +#endif /* _ASM_UBICOM32_VDC_TIO_H */
16361 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/vga.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/vga.h
16362 --- linux-2.6.30.10/arch/ubicom32/include/asm/vga.h 1970-01-01 02:00:00.000000000 +0200
16363 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/vga.h 2009-12-11 11:45:11.000000000 +0200
16364 @@ -0,0 +1,71 @@
16365 +/*
16366 + * arch/ubicom32/include/asm/vga.h
16367 + * Ubicom32 low level VGA/frame buffer definitions.
16368 + *
16369 + * (C) Copyright 2009, Ubicom, Inc.
16370 + * (c) 1998 Martin Mares <mj@ucw.cz>
16371 + *
16372 + * This file is part of the Ubicom32 Linux Kernel Port.
16373 + *
16374 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
16375 + * it and/or modify it under the terms of the GNU General Public License
16376 + * as published by the Free Software Foundation, either version 2 of the
16377 + * License, or (at your option) any later version.
16378 + *
16379 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
16380 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16381 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16382 + * the GNU General Public License for more details.
16383 + *
16384 + * You should have received a copy of the GNU General Public License
16385 + * along with the Ubicom32 Linux Kernel Port. If not,
16386 + * see <http://www.gnu.org/licenses/>.
16387 + *
16388 + * Ubicom32 implementation derived from (with many thanks):
16389 + * arch/m68knommu
16390 + * arch/blackfin
16391 + * arch/parisc
16392 + */
16393 +
16394 +#ifndef _ASM_UBICOM32_VGA_H
16395 +#define _ASM_UBICOM32_VGA_H
16396 +
16397 +#include <asm/byteorder.h>
16398 +
16399 +/*
16400 + * On the PC, we can just recalculate addresses and then
16401 + * access the videoram directly without any black magic.
16402 + */
16403 +
16404 +#define VGA_MAP_MEM(x, s) (0xb0000000L + (unsigned long)(x))
16405 +
16406 +#define vga_readb(x) (*(x))
16407 +#define vga_writeb(x, y) (*(y) = (x))
16408 +
16409 +#define VT_BUF_HAVE_RW
16410 +/*
16411 + * These are only needed for supporting VGA or MDA text mode, which use little
16412 + * endian byte ordering.
16413 + * In other cases, we can optimize by using native byte ordering and
16414 + * <linux/vt_buffer.h> has already done the right job for us.
16415 + */
16416 +
16417 +#undef scr_writew
16418 +#undef scr_readw
16419 +
16420 +static inline void scr_writew(u16 val, volatile u16 *addr)
16421 +{
16422 + *addr = cpu_to_le16(val);
16423 +}
16424 +
16425 +static inline u16 scr_readw(volatile const u16 *addr)
16426 +{
16427 + return le16_to_cpu(*addr);
16428 +}
16429 +
16430 +#define scr_memcpyw(d, s, c) memcpy(d, s, c)
16431 +#define scr_memmovew(d, s, c) memmove(d, s, c)
16432 +#define VT_BUF_HAVE_MEMCPYW
16433 +#define VT_BUF_HAVE_MEMMOVEW
16434 +
16435 +#endif /* _ASM_UBICOM32_VGA_H */
16436 diff -ruN linux-2.6.30.10/arch/ubicom32/include/asm/xor.h linux-2.6.30.10-ubi/arch/ubicom32/include/asm/xor.h
16437 --- linux-2.6.30.10/arch/ubicom32/include/asm/xor.h 1970-01-01 02:00:00.000000000 +0200
16438 +++ linux-2.6.30.10-ubi/arch/ubicom32/include/asm/xor.h 2009-12-11 11:45:11.000000000 +0200
16439 @@ -0,0 +1,33 @@
16440 +/*
16441 + * arch/ubicom32/include/asm/xor.h
16442 + * Generic xor.h definitions for Ubicom32 architecture.
16443 + *
16444 + * (C) Copyright 2009, Ubicom, Inc.
16445 + *
16446 + * This file is part of the Ubicom32 Linux Kernel Port.
16447 + *
16448 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
16449 + * it and/or modify it under the terms of the GNU General Public License
16450 + * as published by the Free Software Foundation, either version 2 of the
16451 + * License, or (at your option) any later version.
16452 + *
16453 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
16454 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
16455 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
16456 + * the GNU General Public License for more details.
16457 + *
16458 + * You should have received a copy of the GNU General Public License
16459 + * along with the Ubicom32 Linux Kernel Port. If not,
16460 + * see <http://www.gnu.org/licenses/>.
16461 + *
16462 + * Ubicom32 implementation derived from (with many thanks):
16463 + * arch/m68knommu
16464 + * arch/blackfin
16465 + * arch/parisc
16466 + */
16467 +#ifndef _ASM_UBICOM32_XOR_H
16468 +#define _ASM_UBICOM32_XOR_H
16469 +
16470 +#include <asm-generic/xor.h>
16471 +
16472 +#endif /* _ASM_UBICOM32_XOR_H */
16473 diff -ruN linux-2.6.30.10/arch/ubicom32/Kconfig linux-2.6.30.10-ubi/arch/ubicom32/Kconfig
16474 --- linux-2.6.30.10/arch/ubicom32/Kconfig 1970-01-01 02:00:00.000000000 +0200
16475 +++ linux-2.6.30.10-ubi/arch/ubicom32/Kconfig 2009-12-11 11:45:11.000000000 +0200
16476 @@ -0,0 +1,403 @@
16477 +#
16478 +# For a description of the syntax of this configuration file,
16479 +# see Documentation/kbuild/kconfig-language.txt.
16480 +#
16481 +
16482 +mainmenu "uClinux/ubicom32 (w/o MMU) Kernel Configuration"
16483 +
16484 +config UBICOM32
16485 + bool
16486 + select HAVE_OPROFILE
16487 + default y
16488 +
16489 +config RAMKERNEL
16490 + bool
16491 + default y
16492 +
16493 +config CPU_BIG_ENDIAN
16494 + bool
16495 + default y
16496 +
16497 +config FORCE_MAX_ZONEORDER
16498 + int
16499 + default "14"
16500 +
16501 +config HAVE_CLK
16502 + bool
16503 + default y
16504 +
16505 +config MMU
16506 + bool
16507 + default n
16508 +
16509 +config FPU
16510 + bool
16511 + default n
16512 +
16513 +config ZONE_DMA
16514 + bool
16515 + default y
16516 +
16517 +config RWSEM_GENERIC_SPINLOCK
16518 + bool
16519 + default y
16520 +
16521 +config RWSEM_XCHGADD_ALGORITHM
16522 + bool
16523 + default n
16524 +
16525 +config ARCH_HAS_ILOG2_U32
16526 + bool
16527 + default n
16528 +
16529 +config ARCH_HAS_ILOG2_U64
16530 + bool
16531 + default n
16532 +
16533 +config GENERIC_FIND_NEXT_BIT
16534 + bool
16535 + default y
16536 +
16537 +config GENERIC_GPIO
16538 + bool
16539 + default y
16540 +
16541 +config GPIOLIB
16542 + bool
16543 + default y
16544 +
16545 +config GENERIC_HWEIGHT
16546 + bool
16547 + default y
16548 +
16549 +config GENERIC_HARDIRQS
16550 + bool
16551 + default y
16552 +
16553 +config STACKTRACE_SUPPORT
16554 + bool
16555 + default y
16556 +
16557 +config LOCKDEP_SUPPORT
16558 + bool
16559 + default y
16560 +
16561 +config GENERIC_CALIBRATE_DELAY
16562 + bool
16563 + default y
16564 +
16565 +config GENERIC_TIME
16566 + bool
16567 + default y
16568 +
16569 +config TIME_LOW_RES
16570 + bool
16571 + default y
16572 +
16573 +config GENERIC_CLOCKEVENTS
16574 + bool
16575 + default y
16576 +
16577 +config GENERIC_CLOCKEVENTS_BROADCAST
16578 + bool
16579 + depends on GENERIC_CLOCKEVENTS
16580 + default y if SMP && !LOCAL_TIMERS
16581 +
16582 +config NO_IOPORT
16583 + def_bool y
16584 +
16585 +config ARCH_SUPPORTS_AOUT
16586 + def_bool y
16587 +
16588 +config IRQ_PER_CPU
16589 + bool
16590 + default y
16591 +
16592 +config SCHED_NO_NO_OMIT_FRAME_POINTER
16593 + bool
16594 + default y
16595 +
16596 +config UBICOM32_PLIO
16597 + bool
16598 + default n
16599 +
16600 +menu "Processor type and features"
16601 +
16602 +comment "Processor type will be selected by Board"
16603 +
16604 +config UBICOM32_V3
16605 + bool
16606 + help
16607 + Ubicom IP5xxx series processor support.
16608 +
16609 +config UBICOM32_V4
16610 + bool
16611 + help
16612 + Ubicom IP7xxx series processor support.
16613 +
16614 +comment "Board"
16615 +choice
16616 + prompt "Board type"
16617 + help
16618 + Select your board.
16619 +
16620 +config NOBOARD
16621 + bool "No board selected"
16622 + help
16623 + Default. Don't select any board specific config. Will not build unless you change!
16624 +
16625 +# Add your boards here
16626 +source "arch/ubicom32/mach-ip5k/Kconfig"
16627 +source "arch/ubicom32/mach-ip7k/Kconfig"
16628 +
16629 +endchoice
16630 +
16631 +comment "Kernel Options"
16632 +config SMP
16633 + bool "Symmetric multi-processing support"
16634 + select USE_GENERIC_SMP_HELPERS
16635 + default n
16636 + help
16637 + Enables multithreading support. Enabling SMP support increases
16638 + the size of system data structures. SMP support can have either
16639 + positive or negative impact on performance depending on workloads.
16640 +
16641 + If you do not know what to do here, say N.
16642 +config OLD_40400010_SYSTEM_CALL
16643 + bool "Provide old system call interface at 0x40400010"
16644 + default y
16645 + help
16646 + Provides the old system call interface, does not affect the
16647 + new system_call interface.
16648 +
16649 +config NR_CPUS
16650 + int "Number of configured CPUs"
16651 + range 2 32
16652 + default 2
16653 + depends on SMP
16654 + help
16655 + Upper bound on the number of CPUs. Space is reserved
16656 + at compile time for this many CPUs.
16657 +
16658 +config LOCAL_TIMERS
16659 + bool "Use local timer interrupts"
16660 + depends on SMP
16661 + default y
16662 + help
16663 + Enable support for local timers on SMP platforms, rather then the
16664 + legacy IPI broadcast method. Local timers allows the system
16665 + accounting to be spread across the timer interval, preventing a
16666 + "thundering herd" at every timer tick. A physical timer is allocated
16667 + per cpu.
16668 +
16669 +config TIMER_EXTRA_ALLOC
16670 + int "Number of additional physical timer events to create"
16671 + depends on GENERIC_CLOCKEVENTS
16672 + default 0
16673 + help
16674 + The Ubicom32 processor has a number of event timers that can be wrapped
16675 + in Linux clock event structures (assuming that the timers are not being
16676 + used for another purpose). Based on the value of LOCAL_TIMERS, either
16677 + 2 timers will be used or a timer will be used for every CPU. This value
16678 + allows the programmer to select additional timers over that amount.
16679 +
16680 +config IRQSTACKS
16681 + bool "Create separate stacks for interrupt handling"
16682 + default n
16683 + help
16684 + Selecting this causes interrupts to be created on a separate
16685 + stack instead of nesting the interrupts on the kernel stack.
16686 +
16687 +config IRQSTACKS_USEOCM
16688 + bool "Use OCM for interrupt stacks"
16689 + default n
16690 + depends on IRQSTACKS
16691 + help
16692 + Selecting this cause the interrupt stacks to be placed in OCM
16693 + reducing cache misses at the expense of using the OCM for servicing
16694 + interrupts.
16695 +
16696 +menu "OCM Instruction Heap"
16697 +
16698 +config OCM_MODULES_RESERVATION
16699 + int "OCM Instruction heap reservation. 0-192 kB"
16700 + range 0 192
16701 + default "0"
16702 + help
16703 + The minimum amount of OCM memory to reserve for kernel loadable module
16704 + code. If you are not using this memory it cannot be used for anything
16705 + else. Leave it as 0 if you have prebuilt modules that are compiled with
16706 + OCM support.
16707 +
16708 +config OCM_MODULES_MAY_CONSUME_REMAINING_CODESPACE
16709 + bool "Give all unused ocm code space to the ocm instruction heap."
16710 + default n
16711 + help
16712 + Allow the OCM instruction heap allocation to consume any remaining
16713 + unused OCM code space. The result of this is that you will not have
16714 + and deterministic results, but you will not have any waste either.
16715 +
16716 +config OCM_MODULES_FALLBACK_TO_DDR
16717 + bool "Loadable Modules requiring OCM may fallback to use DDR."
16718 + default n
16719 + help
16720 + If a module cannot get the OCM code it requires allow DDR to
16721 + be used instead.
16722 +endmenu
16723 +
16724 +config HZ
16725 + int "Frequency of 'jiffies' (for polling)"
16726 + default 1000
16727 + help
16728 + 100 is common for embedded systems, but 1000 allows
16729 + you to do more drivers without actually having
16730 + interrupts working properly.
16731 +
16732 +comment "RAM configuration"
16733 +
16734 +config MIN_RAMSIZE
16735 + hex "Minimum Size of RAM (in bytes)"
16736 + range 0x01000000 0x08000000
16737 + default "0x02000000"
16738 + help
16739 + Define the minimum acceptable size of the system
16740 + RAM. Must be at least 16MB (0x01000000)
16741 +
16742 +comment "Build options"
16743 +config LINKER_RELAXATION
16744 + bool "Linker Relaxation"
16745 + default y
16746 + help
16747 + Turns on linker relaxation that will produce smaller
16748 + faster code. Increases link time.
16749 +
16750 +comment "Driver options"
16751 +menu "PCI Bus"
16752 +config PCI
16753 + bool "PCI bus"
16754 + default true
16755 + help
16756 + Enable/Disable PCI bus
16757 + source "drivers/pci/Kconfig"
16758 +
16759 +
16760 +config PCI_DEV0_IDSEL
16761 + hex "slot 0 address"
16762 + depends on PCI
16763 + default "0x01000000"
16764 + help
16765 + Slot 0 address. This address should correspond to the address line
16766 + which the IDSEL bit for this slot is connected to.
16767 +
16768 +config PCI_DEV1_IDSEL
16769 + hex "slot 1 address"
16770 + depends on PCI
16771 + default "0x02000000"
16772 + help
16773 + Slot 1 address. This address should correspond to the address line
16774 + which the IDSEL bit for this slot is connected to.
16775 +endmenu
16776 +# End PCI
16777 +
16778 +menu "Input devices"
16779 +config UBICOM_INPUT
16780 + bool "Ubicom polled GPIO input driver"
16781 + select INPUT
16782 + select INPUT_POLLDEV
16783 + help
16784 + Polling input driver, much like the GPIO input driver, except that it doesn't
16785 + rely on interrupts. It will report events via the input subsystem.
16786 + default n
16787 +
16788 +config UBICOM_INPUT_I2C
16789 + bool "Ubicom polled GPIO input driver over I2C"
16790 + select INPUT
16791 + select INPUT_POLLDEV
16792 + help
16793 + Polling input driver, much like the PCA953x driver, it can support a variety of
16794 + different I2C I/O expanders. This device polls the I2C I/O expander for events
16795 + and reports them via the input subsystem.
16796 + default n
16797 +endmenu
16798 +# Input devices
16799 +
16800 +source "arch/ubicom32/mach-common/Kconfig.switch"
16801 +
16802 +menu "Misc devices"
16803 +config UBICOM_HID
16804 + bool "Ubicom HID driver"
16805 + select INPUT
16806 + select INPUT_POLLDEV
16807 + select LCD_CLASS_DEVICE
16808 + help
16809 + Driver for HID chip found on some Ubicom reference designs. This chip handles
16810 + PWM, button input, and IR remote control. It registers as an input device and
16811 + a backlight device.
16812 + default n
16813 +endmenu
16814 +# Misc devices
16815 +
16816 +config CMDLINE_BOOL
16817 + bool "Built-in kernel command line"
16818 + default n
16819 + help
16820 + Allow for specifying boot arguments to the kernel at
16821 + build time. On some systems (e.g. embedded ones), it is
16822 + necessary or convenient to provide some or all of the
16823 + kernel boot arguments with the kernel itself (that is,
16824 + to not rely on the boot loader to provide them.)
16825 +
16826 + To compile command line arguments into the kernel,
16827 + set this option to 'Y', then fill in the
16828 + the boot arguments in CONFIG_CMDLINE.
16829 +
16830 + Systems with fully functional boot loaders (i.e. non-embedded)
16831 + should leave this option set to 'N'.
16832 +
16833 +config CMDLINE
16834 + string "Built-in kernel command string"
16835 + depends on CMDLINE_BOOL
16836 + default ""
16837 + help
16838 + Enter arguments here that should be compiled into the kernel
16839 + image and used at boot time. If the boot loader provides a
16840 + command line at boot time, it is appended to this string to
16841 + form the full kernel command line, when the system boots.
16842 +
16843 + However, you can use the CONFIG_CMDLINE_OVERRIDE option to
16844 + change this behavior.
16845 +
16846 + In most cases, the command line (whether built-in or provided
16847 + by the boot loader) should specify the device for the root
16848 + file system.
16849 +
16850 +config CMDLINE_OVERRIDE
16851 + bool "Built-in command line overrides boot loader arguments"
16852 + default n
16853 + depends on CMDLINE_BOOL
16854 + help
16855 + Set this option to 'Y' to have the kernel ignore the boot loader
16856 + command line, and use ONLY the built-in command line.
16857 +
16858 + This is used to work around broken boot loaders. This should
16859 + be set to 'N' under normal conditions.
16860 +
16861 +endmenu
16862 +# End Processor type and features
16863 +
16864 +source "arch/ubicom32/Kconfig.debug"
16865 +
16866 +menu "Executable file formats"
16867 +source "fs/Kconfig.binfmt"
16868 +endmenu
16869 +
16870 +source "init/Kconfig"
16871 +source "kernel/Kconfig.preempt"
16872 +source "kernel/time/Kconfig"
16873 +source "mm/Kconfig"
16874 +source "net/Kconfig"
16875 +source "drivers/Kconfig"
16876 +source "fs/Kconfig"
16877 +source "security/Kconfig"
16878 +source "crypto/Kconfig"
16879 +source "lib/Kconfig"
16880 diff -ruN linux-2.6.30.10/arch/ubicom32/Kconfig.debug linux-2.6.30.10-ubi/arch/ubicom32/Kconfig.debug
16881 --- linux-2.6.30.10/arch/ubicom32/Kconfig.debug 1970-01-01 02:00:00.000000000 +0200
16882 +++ linux-2.6.30.10-ubi/arch/ubicom32/Kconfig.debug 2009-12-11 11:45:11.000000000 +0200
16883 @@ -0,0 +1,129 @@
16884 +menu "Kernel hacking"
16885 +
16886 +config TRACE_IRQFLAGS_SUPPORT
16887 + def_bool y
16888 +
16889 +config DEBUG_VERBOSE
16890 + bool "Verbose fault messages"
16891 + default y
16892 + select PRINTK
16893 + help
16894 + When a program crashes due to an exception, or the kernel detects
16895 + an internal error, the kernel can print a not so brief message
16896 + explaining what the problem was. This debugging information is
16897 + useful to developers and kernel hackers when tracking down problems,
16898 + but mostly meaningless to other people. This is always helpful for
16899 + debugging but serves no purpose on a production system.
16900 + Most people should say N here.
16901 +
16902 +config PROTECT_KERNEL
16903 + default y
16904 + bool 'Enable Kernel range register Protection'
16905 + help
16906 + Adds code to enable/disable range registers to protect static
16907 + kernel code/data from userspace. Currently the ranges covered
16908 + do no protect kernel loadable modules or dynamically allocated
16909 + kernel data.
16910 +
16911 +config NO_KERNEL_MSG
16912 + bool "Suppress Kernel BUG Messages"
16913 + help
16914 + Do not output any debug BUG messages within the kernel.
16915 +
16916 +config EARLY_PRINTK
16917 + bool "Use the driver that you selected as console also for early printk (to debug kernel bootup)."
16918 + default n
16919 + help
16920 + If you want to use the serdes driver (console=ttyUS0) for
16921 + early printk, you must also supply an additional kernel boot
16922 + parameter like this:
16923 +
16924 + serdes=ioportaddr,irq,clockrate,baud
16925 +
16926 + For an IP7160RGW eval board, you could use this:
16927 +
16928 + serdes=0x2004000,61,250000000,57600
16929 +
16930 + which will let you see early printk output at 57600 baud.
16931 +
16932 +config STOP_ON_TRAP
16933 + bool "Enable stopping at the LDSR for all traps"
16934 + default n
16935 + help
16936 + Cause the LDSR to stop all threads whenever a trap is about to be serviced
16937 +
16938 +config STOP_ON_BUG
16939 + bool "Enable stopping on failed BUG_ON()"
16940 + default n
16941 + help
16942 + Cause all BUG_ON failures to stop all threads
16943 +
16944 +config DEBUG_IRQMEASURE
16945 + bool "Enable IRQ handler measurements"
16946 + default n
16947 + help
16948 + When enabled each IRQ's min/avg/max times will be printed. If the handler
16949 + re-enables interrupt, the times will show the full time including to service
16950 + nested interrupts. See /proc/irq_measurements.
16951 +
16952 +config DEBUG_PCIMEASURE
16953 + bool "Enable PCI transaction measurements"
16954 + default n
16955 + help
16956 + When enabled the system will measure the min/avg/max timer for each PCI transactions.
16957 + See /proc/pci_measurements.
16958 +
16959 +config ACCESS_OK_CHECKS_ENABLED
16960 + bool "Enable user space access checks"
16961 + default n
16962 + help
16963 + Enabling this check causes the kernel to verify that addresses passed
16964 + to the kernel by the user space code are within the processes
16965 + address space. On a no-mmu system, this is done by examining the
16966 + processes memory data structures (adversly affecting performance) but
16967 + ensuring that a process does not ask the kernel to violate another
16968 + processes address space. Sadly, the kernel uses access_ok() for
16969 + address that are in the kernel which results in a large volume of
16970 + false positives.
16971 +
16972 +choice
16973 + prompt "Unaligned Access Support"
16974 + default UNALIGNED_ACCESS_ENABLED
16975 + help
16976 + Kernel / Userspace unaligned access handling.
16977 +
16978 +config UNALIGNED_ACCESS_ENABLED
16979 + bool "Kernel and Userspace"
16980 + help
16981 +
16982 +config UNALIGNED_ACCESS_USERSPACE_ONLY
16983 + bool "Userspace Only"
16984 + help
16985 +
16986 +config UNALIGNED_ACCESS_DISABLED
16987 + bool "Disabled"
16988 + help
16989 +
16990 +endchoice
16991 +
16992 +config DEBUG_STACKOVERFLOW
16993 + bool "Check for stack overflows"
16994 + default n
16995 + depends on DEBUG_KERNEL
16996 + help
16997 + This option will cause messages to be printed if free kernel stack space
16998 + drops below a certain limit (THREAD_SIZE /8).
16999 +
17000 +config DEBUG_STACK_USAGE
17001 + bool "Stack utilization instrumentation"
17002 + default n
17003 + depends on DEBUG_KERNEL
17004 + help
17005 + Enables the display of the minimum amount of free kernel stack which each
17006 + task has ever had available in the sysrq-T and sysrq-P debug output.
17007 +
17008 + This option will slow down process creation somewhat.
17009 +
17010 +source "lib/Kconfig.debug"
17011 +
17012 +endmenu
17013 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/asm-offsets.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/asm-offsets.c
17014 --- linux-2.6.30.10/arch/ubicom32/kernel/asm-offsets.c 1970-01-01 02:00:00.000000000 +0200
17015 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/asm-offsets.c 2009-12-11 11:45:11.000000000 +0200
17016 @@ -0,0 +1,161 @@
17017 +/*
17018 + * arch/ubicom32/kernel/asm-offsets.c
17019 + * Ubicom32 architecture definitions needed by assembly language modules.
17020 + *
17021 + * (C) Copyright 2009, Ubicom, Inc.
17022 + *
17023 + * This file is part of the Ubicom32 Linux Kernel Port.
17024 + *
17025 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17026 + * it and/or modify it under the terms of the GNU General Public License
17027 + * as published by the Free Software Foundation, either version 2 of the
17028 + * License, or (at your option) any later version.
17029 + *
17030 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17031 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17032 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17033 + * the GNU General Public License for more details.
17034 + *
17035 + * You should have received a copy of the GNU General Public License
17036 + * along with the Ubicom32 Linux Kernel Port. If not,
17037 + * see <http://www.gnu.org/licenses/>.
17038 + *
17039 + * Ubicom32 implementation derived from (with many thanks):
17040 + * arch/m68knommu
17041 + * arch/blackfin
17042 + * arch/parisc
17043 + */
17044 +/*
17045 + * This program is used to generate definitions needed by
17046 + * assembly language modules.
17047 + *
17048 + * We use the technique used in the OSF Mach kernel code:
17049 + * generate asm statements containing #defines,
17050 + * compile this file to assembler, and then extract the
17051 + * #defines from the assembly-language output.
17052 + */
17053 +
17054 +#include <linux/module.h>
17055 +#include <linux/stddef.h>
17056 +#include <linux/sched.h>
17057 +#include <linux/kernel_stat.h>
17058 +#include <linux/ptrace.h>
17059 +#include <linux/hardirq.h>
17060 +#include <asm/bootinfo.h>
17061 +#include <asm/irq.h>
17062 +#include <asm/thread_info.h>
17063 +
17064 +#define DEFINE(sym, val) \
17065 + asm volatile("\n->" #sym " %0 " #val : : "i" (val))
17066 +
17067 +#define BLANK() asm volatile("\n->" : : )
17068 +
17069 +int main(void)
17070 +{
17071 + /* offsets into the task struct */
17072 + DEFINE(TASK_STATE, offsetof(struct task_struct, state));
17073 + DEFINE(TASK_FLAGS, offsetof(struct task_struct, flags));
17074 + DEFINE(TASK_PTRACE, offsetof(struct task_struct, ptrace));
17075 + DEFINE(TASK_BLOCKED, offsetof(struct task_struct, blocked));
17076 + DEFINE(TASK_THREAD, offsetof(struct task_struct, thread));
17077 + DEFINE(TASK_THREAD_INFO, offsetof(struct task_struct, stack));
17078 + DEFINE(TASK_MM, offsetof(struct task_struct, mm));
17079 + DEFINE(TASK_ACTIVE_MM, offsetof(struct task_struct, active_mm));
17080 +
17081 + /* offsets into the kernel_stat struct */
17082 +// DEFINE(STAT_IRQ, offsetof(struct kernel_stat, irqs));
17083 +
17084 + /* offsets into the irq_cpustat_t struct */
17085 + DEFINE(CPUSTAT_SOFTIRQ_PENDING, offsetof(irq_cpustat_t, __softirq_pending));
17086 +
17087 + /* offsets into the thread struct */
17088 + DEFINE(THREAD_D10, offsetof(struct thread_struct, d10));
17089 + DEFINE(THREAD_D11, offsetof(struct thread_struct, d11));
17090 + DEFINE(THREAD_D12, offsetof(struct thread_struct, d12));
17091 + DEFINE(THREAD_D13, offsetof(struct thread_struct, d13));
17092 + DEFINE(THREAD_A1, offsetof(struct thread_struct, a1));
17093 + DEFINE(THREAD_A2, offsetof(struct thread_struct, a2));
17094 + DEFINE(THREAD_A5, offsetof(struct thread_struct, a5));
17095 + DEFINE(THREAD_A6, offsetof(struct thread_struct, a6));
17096 + DEFINE(THREAD_SP, offsetof(struct thread_struct, sp));
17097 +
17098 + /* offsets into the pt_regs */
17099 + DEFINE(PT_D0, offsetof(struct pt_regs, dn[0]));
17100 + DEFINE(PT_D1, offsetof(struct pt_regs, dn[1]));
17101 + DEFINE(PT_D2, offsetof(struct pt_regs, dn[2]));
17102 + DEFINE(PT_D3, offsetof(struct pt_regs, dn[3]));
17103 + DEFINE(PT_D4, offsetof(struct pt_regs, dn[4]));
17104 + DEFINE(PT_D5, offsetof(struct pt_regs, dn[5]));
17105 + DEFINE(PT_D6, offsetof(struct pt_regs, dn[6]));
17106 + DEFINE(PT_D7, offsetof(struct pt_regs, dn[7]));
17107 + DEFINE(PT_D8, offsetof(struct pt_regs, dn[8]));
17108 + DEFINE(PT_D9, offsetof(struct pt_regs, dn[9]));
17109 + DEFINE(PT_D10, offsetof(struct pt_regs, dn[10]));
17110 + DEFINE(PT_D11, offsetof(struct pt_regs, dn[11]));
17111 + DEFINE(PT_D12, offsetof(struct pt_regs, dn[12]));
17112 + DEFINE(PT_D13, offsetof(struct pt_regs, dn[13]));
17113 + DEFINE(PT_D14, offsetof(struct pt_regs, dn[14]));
17114 + DEFINE(PT_D15, offsetof(struct pt_regs, dn[15]));
17115 + DEFINE(PT_A0, offsetof(struct pt_regs, an[0]));
17116 + DEFINE(PT_A1, offsetof(struct pt_regs, an[1]));
17117 + DEFINE(PT_A2, offsetof(struct pt_regs, an[2]));
17118 + DEFINE(PT_A3, offsetof(struct pt_regs, an[3]));
17119 + DEFINE(PT_A4, offsetof(struct pt_regs, an[4]));
17120 + DEFINE(PT_A5, offsetof(struct pt_regs, an[5]));
17121 + DEFINE(PT_A6, offsetof(struct pt_regs, an[6]));
17122 + DEFINE(PT_A7, offsetof(struct pt_regs, an[7]));
17123 + DEFINE(PT_SP, offsetof(struct pt_regs, an[7]));
17124 +
17125 + DEFINE(PT_ACC0HI, offsetof(struct pt_regs, acc0[0]));
17126 + DEFINE(PT_ACC0LO, offsetof(struct pt_regs, acc0[1]));
17127 + DEFINE(PT_MAC_RC16, offsetof(struct pt_regs, mac_rc16));
17128 +
17129 + DEFINE(PT_ACC1HI, offsetof(struct pt_regs, acc1[0]));
17130 + DEFINE(PT_ACC1LO, offsetof(struct pt_regs, acc1[1]));
17131 +
17132 + DEFINE(PT_SOURCE3, offsetof(struct pt_regs, source3));
17133 + DEFINE(PT_INST_CNT, offsetof(struct pt_regs, inst_cnt));
17134 + DEFINE(PT_CSR, offsetof(struct pt_regs, csr));
17135 + DEFINE(PT_DUMMY_UNUSED, offsetof(struct pt_regs, dummy_unused));
17136 +
17137 + DEFINE(PT_INT_MASK0, offsetof(struct pt_regs, int_mask0));
17138 + DEFINE(PT_INT_MASK1, offsetof(struct pt_regs, int_mask1));
17139 +
17140 + DEFINE(PT_PC, offsetof(struct pt_regs, pc));
17141 +
17142 + DEFINE(PT_TRAP_CAUSE, offsetof(struct pt_regs, trap_cause));
17143 +
17144 + DEFINE(PT_SIZE, sizeof(struct pt_regs));
17145 +
17146 + DEFINE(PT_FRAME_TYPE, offsetof(struct pt_regs, frame_type));
17147 +
17148 + DEFINE(PT_ORIGINAL_D0, offsetof(struct pt_regs, original_dn_0));
17149 + DEFINE(PT_PREVIOUS_PC, offsetof(struct pt_regs, previous_pc));
17150 +
17151 + /* offsets into the kernel_stat struct */
17152 +// DEFINE(STAT_IRQ, offsetof(struct kernel_stat, irqs));
17153 +
17154 + /* signal defines */
17155 + DEFINE(SIGSEGV, SIGSEGV);
17156 + //DEFINE(SEGV_MAPERR, SEGV_MAPERR);
17157 + DEFINE(SIGTRAP, SIGTRAP);
17158 + //DEFINE(TRAP_TRACE, TRAP_TRACE);
17159 +
17160 + DEFINE(PT_PTRACED, PT_PTRACED);
17161 + DEFINE(PT_DTRACE, PT_DTRACE);
17162 +
17163 + DEFINE(ASM_THREAD_SIZE, THREAD_SIZE);
17164 +
17165 + /* Offsets in thread_info structure */
17166 + DEFINE(TI_TASK, offsetof(struct thread_info, task));
17167 + DEFINE(TI_EXECDOMAIN, offsetof(struct thread_info, exec_domain));
17168 + DEFINE(TI_FLAGS, offsetof(struct thread_info, flags));
17169 + DEFINE(TI_PREEMPTCOUNT, offsetof(struct thread_info, preempt_count));
17170 + DEFINE(TI_CPU, offsetof(struct thread_info, cpu));
17171 + DEFINE(TI_INTR_NESTING, offsetof(struct thread_info, interrupt_nesting));
17172 + DEFINE(ASM_TIF_NEED_RESCHED, TIF_NEED_RESCHED);
17173 + DEFINE(ASM_TIF_SYSCALL_TRACE, TIF_SYSCALL_TRACE);
17174 + DEFINE(ASM_TIF_SIGPENDING, TIF_SIGPENDING);
17175 +
17176 + return 0;
17177 +}
17178 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/devtree.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/devtree.c
17179 --- linux-2.6.30.10/arch/ubicom32/kernel/devtree.c 1970-01-01 02:00:00.000000000 +0200
17180 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/devtree.c 2009-12-11 11:45:11.000000000 +0200
17181 @@ -0,0 +1,173 @@
17182 +/*
17183 + * arch/ubicom32/kernel/devtree.c
17184 + * Ubicom32 architecture device tree implementation.
17185 + *
17186 + * (C) Copyright 2009, Ubicom, Inc.
17187 + *
17188 + * This file is part of the Ubicom32 Linux Kernel Port.
17189 + *
17190 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17191 + * it and/or modify it under the terms of the GNU General Public License
17192 + * as published by the Free Software Foundation, either version 2 of the
17193 + * License, or (at your option) any later version.
17194 + *
17195 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17196 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17197 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17198 + * the GNU General Public License for more details.
17199 + *
17200 + * You should have received a copy of the GNU General Public License
17201 + * along with the Ubicom32 Linux Kernel Port. If not,
17202 + * see <http://www.gnu.org/licenses/>.
17203 + *
17204 + * Ubicom32 implementation derived from (with many thanks):
17205 + * arch/m68knommu
17206 + * arch/blackfin
17207 + * arch/parisc
17208 + */
17209 +
17210 +#include <linux/module.h>
17211 +#include <linux/kernel.h>
17212 +#include <linux/string.h>
17213 +#include <linux/errno.h>
17214 +#include <asm/devtree.h>
17215 +
17216 +/*
17217 + * The device tree.
17218 + */
17219 +struct devtree_node *devtree;
17220 +
17221 +/*
17222 + * devtree_print()
17223 + * Print the device tree.
17224 + */
17225 +void devtree_print(void)
17226 +{
17227 + struct devtree_node *p = devtree;
17228 + printk(KERN_INFO "Device Tree:\n");
17229 + while (p) {
17230 + if (p->magic != DEVTREE_NODE_MAGIC) {
17231 + printk(KERN_EMERG
17232 + "device tree has improper node: %p\n", p);
17233 + return;
17234 + }
17235 + printk(KERN_INFO "\t%p: sendirq=%03d, recvirq=%03d, "
17236 + " name=%s\n", p, p->sendirq, p->recvirq, p->name);
17237 + p = p->next;
17238 + }
17239 +}
17240 +EXPORT_SYMBOL(devtree_print);
17241 +
17242 +/*
17243 + * devtree_irq()
17244 + * Return the IRQ(s) associated with devtree node.
17245 + */
17246 +int devtree_irq(struct devtree_node *dn,
17247 + unsigned char *sendirq,
17248 + unsigned char *recvirq)
17249 +{
17250 + if (dn->magic != DEVTREE_NODE_MAGIC) {
17251 + printk(KERN_EMERG "improper node: %p\n", dn);
17252 + if (sendirq) {
17253 + *sendirq = DEVTREE_IRQ_NONE;
17254 + }
17255 + if (recvirq) {
17256 + *recvirq = DEVTREE_IRQ_NONE;
17257 + }
17258 + return -EFAULT;
17259 + }
17260 +
17261 + /*
17262 + * Copy the devtree irq(s) to the output parameters.
17263 + */
17264 + if (sendirq) {
17265 + *sendirq = dn->sendirq;
17266 + }
17267 + if (recvirq) {
17268 + *recvirq = dn->recvirq;
17269 + }
17270 + return 0;
17271 +}
17272 +EXPORT_SYMBOL(devtree_irq);
17273 +
17274 +/*
17275 + * devtree_find_next()
17276 + * Provide an iterator for walking the device tree.
17277 + */
17278 +struct devtree_node *devtree_find_next(struct devtree_node **cur)
17279 +{
17280 + struct devtree_node *p = *cur;
17281 + if (!p) {
17282 + *cur = devtree;
17283 + return devtree;
17284 + }
17285 + p = p->next;
17286 + *cur = p;
17287 + return p;
17288 +}
17289 +
17290 +/*
17291 + * devtree_find_by_irq()
17292 + * Return the node associated with a given irq.
17293 + */
17294 +struct devtree_node *devtree_find_by_irq(uint8_t sendirq, uint8_t recvirq)
17295 +{
17296 + struct devtree_node *p = devtree;
17297 +
17298 + if (sendirq == recvirq) {
17299 + printk(KERN_EMERG "identical request makes no sense sendirq = "
17300 + "%d, recvirq= %d\n", sendirq, recvirq);
17301 + return NULL;
17302 + }
17303 +
17304 + while (p) {
17305 + if (p->magic != DEVTREE_NODE_MAGIC) {
17306 + printk(KERN_EMERG
17307 + "device tree has improper node: %p\n", p);
17308 + return NULL;
17309 + }
17310 +
17311 + /*
17312 + * See if we can find a match on the IRQ(s) specified.
17313 + */
17314 + if ((sendirq == p->sendirq) && (recvirq == p->recvirq)) {
17315 + return p;
17316 + }
17317 +
17318 + if ((sendirq == DEVTREE_IRQ_DONTCARE) &&
17319 + (p->recvirq == recvirq)) {
17320 + return p;
17321 + }
17322 +
17323 + if ((recvirq == DEVTREE_IRQ_DONTCARE) &&
17324 + (p->sendirq == sendirq)) {
17325 + return p;
17326 + }
17327 +
17328 + p = p->next;
17329 + }
17330 + return NULL;
17331 +}
17332 +EXPORT_SYMBOL(devtree_find_by_irq);
17333 +
17334 +/*
17335 + * devtree_find_node()
17336 + * Find a node in the device tree by name.
17337 + */
17338 +struct devtree_node *devtree_find_node(const char *str)
17339 +{
17340 + struct devtree_node *p = devtree;
17341 + while (p) {
17342 + if (p->magic != DEVTREE_NODE_MAGIC) {
17343 + printk(KERN_EMERG
17344 + "device tree has improper node: %p\n", p);
17345 + return NULL;
17346 + }
17347 + if (strcmp(p->name, str) == 0) {
17348 + return p;
17349 + }
17350 + p = p->next;
17351 + }
17352 + return NULL;
17353 +}
17354 +EXPORT_SYMBOL(devtree_find_node);
17355 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/dma.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/dma.c
17356 --- linux-2.6.30.10/arch/ubicom32/kernel/dma.c 1970-01-01 02:00:00.000000000 +0200
17357 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/dma.c 2009-12-11 11:45:11.000000000 +0200
17358 @@ -0,0 +1,60 @@
17359 +/*
17360 + * arch/ubicom32/kernel/dma.c
17361 + * Ubicom32 architecture dynamic DMA mapping support.
17362 + *
17363 + * (C) Copyright 2009, Ubicom, Inc.
17364 + *
17365 + * This file is part of the Ubicom32 Linux Kernel Port.
17366 + *
17367 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17368 + * it and/or modify it under the terms of the GNU General Public License
17369 + * as published by the Free Software Foundation, either version 2 of the
17370 + * License, or (at your option) any later version.
17371 + *
17372 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17373 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17374 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17375 + * the GNU General Public License for more details.
17376 + *
17377 + * You should have received a copy of the GNU General Public License
17378 + * along with the Ubicom32 Linux Kernel Port. If not,
17379 + * see <http://www.gnu.org/licenses/>.
17380 + *
17381 + * Ubicom32 implementation derived from (with many thanks):
17382 + * arch/m68knommu
17383 + * arch/blackfin
17384 + * arch/parisc
17385 + *
17386 + * We never have any address translations to worry about, so this
17387 + * is just alloc/free.
17388 + */
17389 +
17390 +#include <linux/types.h>
17391 +#include <linux/mm.h>
17392 +#include <linux/string.h>
17393 +#include <linux/device.h>
17394 +#include <linux/io.h>
17395 +
17396 +void *dma_alloc_coherent(struct device *dev, size_t size,
17397 + dma_addr_t *dma_handle, int gfp)
17398 +{
17399 + void *ret;
17400 + /* ignore region specifiers */
17401 + gfp &= ~(__GFP_DMA | __GFP_HIGHMEM);
17402 +
17403 + if (dev == NULL || (*dev->dma_mask < 0xffffffff))
17404 + gfp |= GFP_DMA;
17405 + ret = (void *)__get_free_pages(gfp, get_order(size));
17406 +
17407 + if (ret != NULL) {
17408 + memset(ret, 0, size);
17409 + *dma_handle = virt_to_phys(ret);
17410 + }
17411 + return ret;
17412 +}
17413 +
17414 +void dma_free_coherent(struct device *dev, size_t size,
17415 + void *vaddr, dma_addr_t dma_handle)
17416 +{
17417 + free_pages((unsigned long)vaddr, get_order(size));
17418 +}
17419 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/flat.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/flat.c
17420 --- linux-2.6.30.10/arch/ubicom32/kernel/flat.c 1970-01-01 02:00:00.000000000 +0200
17421 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/flat.c 2009-12-11 11:45:11.000000000 +0200
17422 @@ -0,0 +1,206 @@
17423 +/*
17424 + * arch/ubicom32/kernel/flat.c
17425 + * Ubicom32 architecture flat executable format support.
17426 + *
17427 + * (C) Copyright 2009, Ubicom, Inc.
17428 + *
17429 + * This file is part of the Ubicom32 Linux Kernel Port.
17430 + *
17431 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17432 + * it and/or modify it under the terms of the GNU General Public License
17433 + * as published by the Free Software Foundation, either version 2 of the
17434 + * License, or (at your option) any later version.
17435 + *
17436 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17437 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17438 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17439 + * the GNU General Public License for more details.
17440 + *
17441 + * You should have received a copy of the GNU General Public License
17442 + * along with the Ubicom32 Linux Kernel Port. If not,
17443 + * see <http://www.gnu.org/licenses/>.
17444 + *
17445 + * Ubicom32 implementation derived from (with many thanks):
17446 + * arch/m68knommu
17447 + * arch/blackfin
17448 + * arch/parisc
17449 + */
17450 +#include <linux/module.h>
17451 +#include <linux/types.h>
17452 +#include <linux/flat.h>
17453 +
17454 +unsigned long ubicom32_flat_get_addr_from_rp(unsigned long *rp,
17455 + u32_t relval,
17456 + u32_t flags,
17457 + unsigned long *persistent)
17458 +{
17459 + u32_t relval_reloc_type = relval >> 27;
17460 + u32_t insn = *rp;
17461 +
17462 + if (*persistent) {
17463 + /*
17464 + * relval holds the relocation that has to be adjusted.
17465 + */
17466 + if (relval == 0) {
17467 + *persistent = 0;
17468 + }
17469 +
17470 + return relval;
17471 + }
17472 +
17473 + if (relval_reloc_type == R_UBICOM32_32) {
17474 + /*
17475 + * insn holds the relocation
17476 + */
17477 + return insn;
17478 + }
17479 +
17480 + /*
17481 + * We don't know this one.
17482 + */
17483 + return 0;
17484 +}
17485 +
17486 +void ubicom32_flat_put_addr_at_rp(unsigned long *rp,
17487 + u32_t val,
17488 + u32_t relval,
17489 + unsigned long *persistent)
17490 +{
17491 + u32_t reloc_type = (relval >> 27) & 0x1f;
17492 + u32_t insn = *rp;
17493 +
17494 + /*
17495 + * If persistent is set then it contains the relocation type.
17496 + */
17497 + if (*persistent) {
17498 + /*
17499 + * If persistent is set then it contains the relocation type.
17500 + */
17501 + reloc_type = (*persistent >> 27) & 0x1f;
17502 + }
17503 +
17504 + switch (reloc_type) {
17505 + case R_UBICOM32_32:
17506 + /*
17507 + * Store the 32 bits as is.
17508 + */
17509 + *rp = val;
17510 + break;
17511 + case R_UBICOM32_HI24:
17512 + {
17513 + /*
17514 + * 24 bit relocation that is part of the MOVEAI
17515 + * instruction. The 24 bits come from bits 7 - 30 of the
17516 + * relocation. The 24 bits eventually get split into 2
17517 + * fields in the instruction encoding.
17518 + *
17519 + * - Bits 7 - 27 of the relocation are encoded into bits
17520 + * 0 - 20 of the instruction.
17521 + *
17522 + * - Bits 28 - 30 of the relocation are encoded into bit
17523 + * 24 - 26 of the instruction.
17524 + */
17525 + u32_t mask = 0x1fffff | (0x7 << 24);
17526 + u32_t valid24bits = (val >> 7) & 0xffffff;
17527 + u32_t bot_21 = valid24bits & 0x1fffff;
17528 + u32_t upper_3_bits = ((valid24bits & 0xe00000) << 3);
17529 + insn &= ~mask;
17530 +
17531 + insn |= bot_21;
17532 + insn |= upper_3_bits;
17533 + *rp = insn;
17534 + }
17535 + break;
17536 + case R_UBICOM32_LO7_S:
17537 + case R_UBICOM32_LO7_2_S:
17538 + case R_UBICOM32_LO7_4_S:
17539 + {
17540 + /*
17541 + * Bits 0 - 6 of the relocation are encoded into the
17542 + * 7bit unsigned immediate fields of the SOURCE-1 field
17543 + * of the instruction. The immediate value is left
17544 + * shifted by (0, 1, 2) based on the operand size.
17545 + */
17546 + u32_t mask = 0x1f | (0x3 << 8);
17547 + u32_t bottom, top;
17548 + val &= 0x7f;
17549 + if (reloc_type == R_UBICOM32_LO7_2_S) {
17550 + val >>= 1;
17551 + } else if (reloc_type == R_UBICOM32_LO7_4_S) {
17552 + val >>= 2;
17553 + }
17554 +
17555 + bottom = val & 0x1f;
17556 + top = val >> 5;
17557 + insn &= ~mask;
17558 + insn |= bottom;
17559 + insn |= (top << 8);
17560 + BUG_ON(*rp != insn);
17561 + *rp = insn;
17562 + break;
17563 + }
17564 + case R_UBICOM32_LO7_D:
17565 + case R_UBICOM32_LO7_2_D:
17566 + case R_UBICOM32_LO7_4_D:
17567 + {
17568 + /*
17569 + * Bits 0 - 6 of the relocation are encoded into the
17570 + * 7bit unsigned immediate fields of the DESTINATION
17571 + * field of the instruction. The immediate value is
17572 + * left shifted by (0, 1, 2) based on the operand size.
17573 + */
17574 + u32_t mask = (0x1f | (0x3 << 8)) << 16;
17575 + u32_t bottom, top;
17576 + val &= 0x7f;
17577 + if (reloc_type == R_UBICOM32_LO7_2_D) {
17578 + val >>= 1;
17579 + } else if (reloc_type == R_UBICOM32_LO7_4_D) {
17580 + val >>= 2;
17581 + }
17582 + bottom = (val & 0x1f) << 16;
17583 + top = (val >> 5) << 16;
17584 + insn &= ~mask;
17585 + insn |= bottom;
17586 + insn |= (top << 8);
17587 + BUG_ON(*rp != insn);
17588 + *rp = insn;
17589 + break;
17590 + }
17591 + case R_UBICOM32_LO7_CALLI:
17592 + case R_UBICOM32_LO16_CALLI:
17593 + {
17594 + /*
17595 + * Extract the offset for a CALLI instruction. The
17596 + * offsets can be either 7 bits or 18 bits. Since all
17597 + * instructions in ubicom32 architecture are at work
17598 + * aligned addresses the truncated offset is right
17599 + * shifted by 2 before being encoded in the instruction.
17600 + */
17601 + if (reloc_type == R_UBICOM32_LO7_CALLI) {
17602 + val &= 0x7f;
17603 + } else {
17604 + val &= 0x3ffff;
17605 + }
17606 +
17607 + val >>= 2;
17608 +
17609 + insn &= ~0x071f071f;
17610 + insn |= (val & 0x1f) << 0;
17611 + val >>= 5;
17612 + insn |= (val & 0x07) << 8;
17613 + val >>= 3;
17614 + insn |= (val & 0x1f) << 16;
17615 + val >>= 5;
17616 + insn |= (val & 0x07) << 24;
17617 + if (reloc_type == R_UBICOM32_LO7_CALLI) {
17618 + BUG_ON(*rp != insn);
17619 + }
17620 + *rp = insn;
17621 + }
17622 + break;
17623 + }
17624 +
17625 + if (*persistent) {
17626 + *persistent = 0;
17627 + }
17628 +}
17629 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/head.S linux-2.6.30.10-ubi/arch/ubicom32/kernel/head.S
17630 --- linux-2.6.30.10/arch/ubicom32/kernel/head.S 1970-01-01 02:00:00.000000000 +0200
17631 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/head.S 2009-12-11 11:45:11.000000000 +0200
17632 @@ -0,0 +1,273 @@
17633 +/*
17634 + * arch/ubicom32/kernel/head.S
17635 + * <TODO: Replace with short file description>
17636 + *
17637 + * (C) Copyright 2009, Ubicom, Inc.
17638 + *
17639 + * This file is part of the Ubicom32 Linux Kernel Port.
17640 + *
17641 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17642 + * it and/or modify it under the terms of the GNU General Public License
17643 + * as published by the Free Software Foundation, either version 2 of the
17644 + * License, or (at your option) any later version.
17645 + *
17646 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17647 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17648 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17649 + * the GNU General Public License for more details.
17650 + *
17651 + * You should have received a copy of the GNU General Public License
17652 + * along with the Ubicom32 Linux Kernel Port. If not,
17653 + * see <http://www.gnu.org/licenses/>.
17654 + *
17655 + * Ubicom32 implementation derived from (with many thanks):
17656 + * arch/m68knommu
17657 + * arch/blackfin
17658 + * arch/parisc
17659 + */
17660 +#include <linux/sys.h>
17661 +#include <linux/linkage.h>
17662 +#include <asm/asm-offsets.h>
17663 +#include <asm/page_offset.h>
17664 +#define __ASM__
17665 +#include <asm/ip5000.h>
17666 +
17667 +
17668 +#define SRC_AN A3
17669 +#define DST_AN A4
17670 +
17671 +#define PARAM_DN D0
17672 +#define TMP_DN D15
17673 +#define TMP2_DN D14
17674 +
17675 +/*
17676 + * The following code is placed at the start of the Linux section of memory.
17677 + * This is the primary entry point for Linux.
17678 + *
17679 + * However, we also want the syscall entry/exit code to be at a fixed address.
17680 + * So we take the primary entry point and reserve 16 bytes. That address is
17681 + * where the system_call entry point exists. This 16 bytes basically allows
17682 + * us to jump around the system_call entry point code to the actual startup
17683 + * code.
17684 + *
17685 + * Linux Memory Map (see vlinux.lds.S):
17686 + * 0x40400000 - Primary Entry Point for Linux (jump around code below).
17687 + * 0x40400010 - Old syscall Entry Point.
17688 + */
17689 +
17690 + .sect .skip_syscall, "ax", @progbits
17691 + .global __skip_syscall_section
17692 +__skip_syscall_section:
17693 + moveai A3, #%hi(_start)
17694 + lea.1 A3, %lo(_start)(A3)
17695 + ret A3
17696 +/*
17697 + * __os_node_offset contains the offset from KERNELBASE to the os_node, it is
17698 + * not intended to be used by anything except the boot code.
17699 + */
17700 +__os_node_offset:
17701 +.long (_os_node - KERNELSTART)
17702 +
17703 +.text
17704 +.global _start
17705 +
17706 +/*
17707 + * start()
17708 + * This is the start of the Linux kernel.
17709 + */
17710 +_start:
17711 + move.4 SCRATCHPAD1, #0
17712 +
17713 +
17714 +/*
17715 + * Setup the range registers... the loader has setup a few, but we will go ahead
17716 + * and correct them for our own limits. Note that once set these are never
17717 + * changed again. The ranges are as follows
17718 + *
17719 + * D_RANGE0 - io block (set up by loaded)
17720 + *
17721 + * I_RANGE0 and D_RANGE1 - kernel/ultra loader address space bottom of ocm-> top
17722 + * of ram typically 0x3ffc0000 - 0x440000000
17723 + * I_RANGE1 - kernel / userspace transition area (aka syscalls, context switches)
17724 + * typically 0x3FFC0030 - ~0x3FFC0200
17725 + * I_RANGE2 / D_RANGE2 - slab area
17726 + * typically 0x40A00000 - ~0x44000000
17727 + * I_RANGE3
17728 + * old system call interface if enabled.
17729 + *
17730 + * D_RANGE3, D_RANGE4 - unused.
17731 + */
17732 + moveai SRC_AN, #%hi(PAGE_OFFSET_RAW)
17733 + lea.4 SRC_AN, %lo(PAGE_OFFSET_RAW)(SRC_AN)
17734 + move.4 D_RANGE1_LO, SRC_AN
17735 + move.4 I_RANGE0_LO, SRC_AN
17736 +
17737 +; don't try to calculate I_RANGE_HI, see below
17738 +; moveai SRC_AN, #%hi(___init_end-4)
17739 +; lea.4 SRC_AN, %lo(___init_end-4)(SRC_AN)
17740 +; move.4 I_RANGE0_HI, SRC_AN
17741 +
17742 + moveai SRC_AN, #%hi(SDRAMSTART + CONFIG_MIN_RAMSIZE-4)
17743 + lea.4 SRC_AN, %lo(SDRAMSTART + CONFIG_MIN_RAMSIZE-4)(SRC_AN)
17744 + move.4 D_RANGE1_HI, SRC_AN
17745 +
17746 +; for now allow the whole ram to be executable as well so we don't run into problems
17747 +; once we load user more code.
17748 + move.4 I_RANGE0_HI, SRC_AN
17749 +
17750 +#ifdef CONFIG_PROTECT_KERNEL
17751 +; when kernel protection is enabled, we only open up syscall and non kernel text
17752 +; for userspace apps, for now only irange registers registers 1 and 2 are used for userspace.
17753 +
17754 + ;; syscall range
17755 + moveai SRC_AN, #%hi(__syscall_text_run_begin)
17756 + lea.4 SRC_AN, %lo(__syscall_text_run_begin)(SRC_AN)
17757 + move.4 I_RANGE1_LO, SRC_AN
17758 + moveai SRC_AN, #%hi(__syscall_text_run_end)
17759 + lea.4 SRC_AN, %lo(__syscall_text_run_end)(SRC_AN)
17760 + move.4 I_RANGE1_HI, SRC_AN
17761 +
17762 + ;; slab instructions
17763 + moveai SRC_AN, #%hi(_edata)
17764 + lea.4 SRC_AN, %lo(_edata)(SRC_AN)
17765 + move.4 I_RANGE2_LO, SRC_AN
17766 + ;; End of DDR is already in range0 hi so just copy it.
17767 + move.4 I_RANGE2_HI, I_RANGE0_HI
17768 +
17769 +#ifdef CONFIG_OLD_40400010_SYSTEM_CALL
17770 + ;; create a small hole for old syscall location
17771 + moveai SRC_AN, #%hi(0x40400000)
17772 + lea.4 I_RANGE3_LO, 0x10(SRC_AN)
17773 + lea.4 I_RANGE3_HI, 0x14(SRC_AN)
17774 +#endif
17775 + ;; slab data (same as slab instructions but starting a little earlier).
17776 + moveai SRC_AN, #%hi(_data_protection_end)
17777 + lea.4 SRC_AN, %lo(_data_protection_end)(SRC_AN)
17778 + move.4 D_RANGE2_LO, SRC_AN
17779 + move.4 D_RANGE2_HI, I_RANGE0_HI
17780 +
17781 +;; enable ranges
17782 + ;; skip I_RANGE0_EN
17783 + move.4 I_RANGE1_EN, #-1
17784 + move.4 I_RANGE2_EN, #-1
17785 +#ifdef CONFIG_OLD_40400010_SYSTEM_CALL
17786 + move.4 I_RANGE3_EN, #-1
17787 +#else
17788 + move.4 I_RANGE3_EN, #0
17789 +#endif
17790 + ;; skip D_RANGE0_EN or D_RANGE1_EN
17791 + move.4 D_RANGE2_EN, #-1
17792 + move.4 D_RANGE3_EN, #0
17793 + move.4 D_RANGE4_EN, #0
17794 +#endif
17795 +
17796 +;
17797 +; If __ocm_free_begin is smaller than __ocm_free_end the
17798 +; setup OCM text and data ram banks properly
17799 +;
17800 + moveai DST_AN, #%hi(__ocm_free_begin)
17801 + lea.4 TMP_DN, %lo(__ocm_free_begin)(DST_AN)
17802 + moveai DST_AN, #%hi(__ocm_free_end)
17803 + lea.4 TMP2_DN, %lo(__ocm_free_end)(DST_AN)
17804 + sub.4 #0, TMP2_DN, TMP_DN
17805 + jmple.f 2f
17806 + moveai DST_AN, #%hi(__data_begin)
17807 + lea.4 TMP_DN, %lo(__data_begin)(DST_AN)
17808 + moveai DST_AN, #%hi(OCMSTART)
17809 + lea.4 TMP2_DN, %lo(OCMSTART)(DST_AN)
17810 + sub.4 TMP_DN, TMP_DN, TMP2_DN
17811 + lsr.4 TMP_DN, TMP_DN, #15
17812 + lsl.4 TMP_DN, #1, TMP_DN
17813 + moveai DST_AN, #%hi(OCMC_BASE)
17814 + add.4 OCMC_BANK_MASK(DST_AN), #-1, TMP_DN
17815 + pipe_flush 0
17816 +2:
17817 +;
17818 +; Load .ocm_text
17819 +;
17820 + moveai DST_AN, #%hi(__ocm_text_run_end)
17821 + lea.4 TMP_DN, %lo(__ocm_text_run_end)(DST_AN)
17822 + moveai DST_AN, #%hi(__ocm_text_run_begin)
17823 + lea.4 DST_AN, %lo(__ocm_text_run_begin)(DST_AN)
17824 + moveai SRC_AN, #%hi(__ocm_text_load_begin)
17825 + lea.4 SRC_AN, %lo(__ocm_text_load_begin)(SRC_AN)
17826 + jmpt.t 2f
17827 +
17828 +1: move.4 (DST_AN)4++, (SRC_AN)4++
17829 +
17830 +2: sub.4 #0, DST_AN, TMP_DN
17831 + jmpne.t 1b
17832 +;
17833 +; Load .syscall_text
17834 +;
17835 + moveai DST_AN, #%hi(__syscall_text_run_end)
17836 + lea.4 TMP_DN, %lo(__syscall_text_run_end)(DST_AN)
17837 + moveai DST_AN, #%hi(__syscall_text_run_begin)
17838 + lea.4 DST_AN, %lo(__syscall_text_run_begin)(DST_AN)
17839 + moveai SRC_AN, #%hi(__syscall_text_load_begin)
17840 + lea.4 SRC_AN, %lo(__syscall_text_load_begin)(SRC_AN)
17841 + jmpt.t 2f
17842 +
17843 +1: move.4 (DST_AN)4++, (SRC_AN)4++
17844 +
17845 +2: sub.4 #0, DST_AN, TMP_DN
17846 + jmpne.t 1b
17847 +
17848 +;
17849 +; Load .ocm_data
17850 +;
17851 + moveai DST_AN, #%hi(__ocm_data_run_end)
17852 + lea.4 TMP_DN, %lo(__ocm_data_run_end)(DST_AN)
17853 + moveai DST_AN, #%hi(__ocm_data_run_begin)
17854 + lea.4 DST_AN, %lo(__ocm_data_run_begin)(DST_AN)
17855 + moveai SRC_AN, #%hi(__ocm_data_load_begin)
17856 + lea.4 SRC_AN, %lo(__ocm_data_load_begin)(SRC_AN)
17857 + jmpt.t 2f
17858 +
17859 +1: move.4 (DST_AN)4++, (SRC_AN)4++
17860 +
17861 +2: sub.4 #0, DST_AN, TMP_DN
17862 + jmpne.t 1b
17863 +
17864 +; Clear .bss
17865 +;
17866 + moveai SRC_AN, #%hi(_ebss)
17867 + lea.4 TMP_DN, %lo(_ebss)(SRC_AN)
17868 + moveai DST_AN, #%hi(_sbss)
17869 + lea.4 DST_AN, %lo(_sbss)(DST_AN)
17870 + jmpt.t 2f
17871 +
17872 +1: move.4 (DST_AN)4++, #0
17873 +
17874 +2: sub.4 #0, DST_AN, TMP_DN
17875 + jmpne.t 1b
17876 +
17877 +; save our parameter to devtree (after clearing .bss)
17878 + moveai DST_AN, #%hi(devtree)
17879 + lea.4 DST_AN, %lo(devtree)(DST_AN)
17880 + move.4 (DST_AN), PARAM_DN
17881 +
17882 + moveai sp, #%hi(init_thread_union)
17883 + lea.4 sp, %lo(init_thread_union)(sp)
17884 + movei TMP_DN, #ASM_THREAD_SIZE
17885 + add.4 sp, sp, TMP_DN
17886 + move.4 -4(sp)++, #0 ; nesting level = 0
17887 + move.4 -4(sp)++, #1 ; KERNEL_THREAD
17888 +
17889 +;; ip3k-elf-gdb backend now sets scratchpad3 to 1 when either continue
17890 +;; or single step commands are issued. scratchpad3 is set to 0 when the
17891 +;; debugger detaches from the board.
17892 + move.4 TMP_DN, scratchpad3
17893 + lsl.4 TMP_DN, TMP_DN, #0x0
17894 + jmpeq.f _jump_to_start_kernel
17895 +_ok_to_set_break_points_in_linux:
17896 +;; THREAD_STALL
17897 + move.4 mt_dbg_active_clr,#-1
17898 +;; stalling the threads isn't instantaneous.. need to flush the pipe.
17899 + pipe_flush 0
17900 + pipe_flush 0
17901 +
17902 +_jump_to_start_kernel:
17903 + moveai SRC_AN, #%hi(start_kernel)
17904 + lea.4 SRC_AN, %lo(start_kernel)(SRC_AN)
17905 + ret SRC_AN
17906 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/init_task.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/init_task.c
17907 --- linux-2.6.30.10/arch/ubicom32/kernel/init_task.c 1970-01-01 02:00:00.000000000 +0200
17908 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/init_task.c 2009-12-11 11:45:11.000000000 +0200
17909 @@ -0,0 +1,62 @@
17910 +/*
17911 + * arch/ubicom32/kernel/init_task.c
17912 + * Ubicom32 architecture task initialization implementation.
17913 + *
17914 + * (C) Copyright 2009, Ubicom, Inc.
17915 + *
17916 + * This file is part of the Ubicom32 Linux Kernel Port.
17917 + *
17918 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17919 + * it and/or modify it under the terms of the GNU General Public License
17920 + * as published by the Free Software Foundation, either version 2 of the
17921 + * License, or (at your option) any later version.
17922 + *
17923 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17924 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17925 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17926 + * the GNU General Public License for more details.
17927 + *
17928 + * You should have received a copy of the GNU General Public License
17929 + * along with the Ubicom32 Linux Kernel Port. If not,
17930 + * see <http://www.gnu.org/licenses/>.
17931 + *
17932 + * Ubicom32 implementation derived from (with many thanks):
17933 + * arch/m68knommu
17934 + * arch/blackfin
17935 + * arch/parisc
17936 + */
17937 +#include <linux/mm.h>
17938 +#include <linux/module.h>
17939 +#include <linux/sched.h>
17940 +#include <linux/init.h>
17941 +#include <linux/init_task.h>
17942 +#include <linux/fs.h>
17943 +#include <linux/mqueue.h>
17944 +#include <linux/uaccess.h>
17945 +#include <asm/pgtable.h>
17946 +
17947 +///static struct fs_struct init_fs = INIT_FS;
17948 +static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
17949 +static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
17950 +struct mm_struct init_mm = INIT_MM(init_mm);
17951 +EXPORT_SYMBOL(init_mm);
17952 +
17953 +/*
17954 + * Initial task structure.
17955 + *
17956 + * All other task structs will be allocated on slabs in fork.c
17957 + */
17958 +struct task_struct init_task = INIT_TASK(init_task);
17959 +
17960 +EXPORT_SYMBOL(init_task);
17961 +
17962 +/*
17963 + * Initial thread structure.
17964 + *
17965 + * We need to make sure that this is 8192-byte aligned due to the
17966 + * way process stacks are handled. This is done by having a special
17967 + * "init_task" linker map entry..
17968 + */
17969 +union thread_union init_thread_union
17970 + __attribute__((__section__(".data.init_task"))) =
17971 + { INIT_THREAD_INFO(init_task) };
17972 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/irq.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/irq.c
17973 --- linux-2.6.30.10/arch/ubicom32/kernel/irq.c 1970-01-01 02:00:00.000000000 +0200
17974 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/irq.c 2009-12-11 11:45:11.000000000 +0200
17975 @@ -0,0 +1,597 @@
17976 +/*
17977 + * arch/ubicom32/kernel/irq.c
17978 + * Ubicom32 architecture IRQ support.
17979 + *
17980 + * (C) Copyright 2009, Ubicom, Inc.
17981 + * (C) Copyright 2007, Greg Ungerer <gerg@snapgear.com>
17982 + *
17983 + * This file is part of the Ubicom32 Linux Kernel Port.
17984 + *
17985 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
17986 + * it and/or modify it under the terms of the GNU General Public License
17987 + * as published by the Free Software Foundation, either version 2 of the
17988 + * License, or (at your option) any later version.
17989 + *
17990 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
17991 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
17992 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17993 + * the GNU General Public License for more details.
17994 + *
17995 + * You should have received a copy of the GNU General Public License
17996 + * along with the Ubicom32 Linux Kernel Port. If not,
17997 + * see <http://www.gnu.org/licenses/>.
17998 + *
17999 + * Ubicom32 implementation derived from (with many thanks):
18000 + * arch/m68knommu
18001 + * arch/blackfin
18002 + * arch/parisc
18003 + */
18004 +
18005 +#include <linux/types.h>
18006 +#include <linux/irq.h>
18007 +#include <linux/init.h>
18008 +#include <linux/kernel.h>
18009 +#include <linux/kernel_stat.h>
18010 +#include <linux/module.h>
18011 +#include <linux/seq_file.h>
18012 +#include <linux/proc_fs.h>
18013 +#include <asm/system.h>
18014 +#include <asm/traps.h>
18015 +#include <asm/ldsr.h>
18016 +#include <asm/ip5000.h>
18017 +#include <asm/machdep.h>
18018 +#include <asm/asm-offsets.h>
18019 +#include <asm/thread.h>
18020 +#include <asm/devtree.h>
18021 +
18022 +unsigned int irq_soft_avail;
18023 +static struct irqaction ubicom32_reserve_action[NR_IRQS];
18024 +
18025 +#if !defined(CONFIG_DEBUG_IRQMEASURE)
18026 +#define IRQ_DECLARE_MEASUREMENT
18027 +#define IRQ_MEASUREMENT_START()
18028 +#define IRQ_MEASUREMENT_END(irq)
18029 +#else
18030 +#define IRQ_DECLARE_MEASUREMENT \
18031 + int __diff; \
18032 + unsigned int __tstart;
18033 +
18034 +#define IRQ_MEASUREMENT_START() \
18035 + __tstart = UBICOM32_IO_TIMER->sysval;
18036 +
18037 +#define IRQ_MEASUREMENT_END(irq) \
18038 + __diff = (int)UBICOM32_IO_TIMER->sysval - (int)__tstart; \
18039 + irq_measurement_update((irq), __diff);
18040 +
18041 +/*
18042 + * We keep track of the time spent in both irq_enter()
18043 + * and irq_exit().
18044 + */
18045 +#define IRQ_WEIGHT 32
18046 +
18047 +struct irq_measurement {
18048 + volatile unsigned int min;
18049 + volatile unsigned int avg;
18050 + volatile unsigned int max;
18051 +};
18052 +
18053 +static DEFINE_SPINLOCK(irq_measurement_lock);
18054 +
18055 +/*
18056 + * Add 1 in for softirq (irq_exit());
18057 + */
18058 +static struct irq_measurement irq_measurements[NR_IRQS + 1];
18059 +
18060 +/*
18061 + * irq_measurement_update()
18062 + * Update an entry in the measurement array for this irq.
18063 + */
18064 +static void irq_measurement_update(int irq, int sample)
18065 +{
18066 + struct irq_measurement *im = &irq_measurements[irq];
18067 + spin_lock(&irq_measurement_lock);
18068 + if ((im->min == 0) || (im->min > sample)) {
18069 + im->min = sample;
18070 + }
18071 + if (im->max < sample) {
18072 + im->max = sample;
18073 + }
18074 + im->avg = ((im->avg * (IRQ_WEIGHT - 1)) + sample) / IRQ_WEIGHT;
18075 + spin_unlock(&irq_measurement_lock);
18076 +}
18077 +#endif
18078 +
18079 +/*
18080 + * irq_kernel_stack_check()
18081 + * See if the kernel stack is within STACK_WARN of the end.
18082 + */
18083 +static void irq_kernel_stack_check(int irq, struct pt_regs *regs)
18084 +{
18085 +#ifdef CONFIG_DEBUG_STACKOVERFLOW
18086 + unsigned long sp;
18087 +
18088 + /*
18089 + * Make sure that we are not close to the top of the stack and thus
18090 + * can not really service this interrupt.
18091 + */
18092 + asm volatile (
18093 + "and.4 %0, SP, %1 \n\t"
18094 + : "=d" (sp)
18095 + : "d" (THREAD_SIZE - 1)
18096 + : "cc"
18097 + );
18098 +
18099 + if (sp < (sizeof(struct thread_info) + STACK_WARN)) {
18100 + printk(KERN_WARNING
18101 + "cpu[%d]: possible overflow detected sp remain: %p, "
18102 + "irq: %d, regs: %p\n",
18103 + thread_get_self(), (void *)sp, irq, regs);
18104 + dump_stack();
18105 + }
18106 +
18107 + if (sp < (sizeof(struct thread_info) + 16)) {
18108 + THREAD_STALL;
18109 + }
18110 +#endif
18111 +}
18112 +
18113 +/*
18114 + * irq_get_lsb()
18115 + * Get the LSB set in value
18116 + */
18117 +static int irq_get_lsb(unsigned int value)
18118 +{
18119 + static unsigned char irq_bits[8] = {
18120 + 3, 0, 1, 0, 2, 0, 1, 0
18121 + };
18122 + u32_t nextbit = 0;
18123 +
18124 + value = (value >> nextbit) | (value << ((sizeof(value) * 8) - nextbit));
18125 +
18126 + /*
18127 + * It's unlikely that we find that we execute the body of this while
18128 + * loop. 50% of the time we won't take this at all and then of the
18129 + * cases where we do about 50% of those we only execute once.
18130 + */
18131 + if (!(value & 0xffff)) {
18132 + nextbit += 0x10;
18133 + value >>= 16;
18134 + }
18135 +
18136 + if (!(value & 0xff)) {
18137 + nextbit += 0x08;
18138 + value >>= 8;
18139 + }
18140 +
18141 + if (!(value & 0xf)) {
18142 + nextbit += 0x04;
18143 + value >>= 4;
18144 + }
18145 +
18146 + nextbit += irq_bits[value & 0x7];
18147 + if (nextbit > 63) {
18148 + panic("nextbit out of range: %d\n", nextbit);
18149 + }
18150 + return nextbit;
18151 +}
18152 +
18153 +/*
18154 + * ubicom32_reserve_handler()
18155 + * Bogus handler associated with pre-reserved IRQ(s).
18156 + */
18157 +static irqreturn_t ubicom32_reserve_handler(int irq, void *dev_id)
18158 +{
18159 + BUG();
18160 + return IRQ_HANDLED;
18161 +}
18162 +
18163 +/*
18164 + * __irq_disable_vector()
18165 + * Disable the interrupt by clearing the appropriate bit in the
18166 + * LDSR Mask Register.
18167 + */
18168 +static void __irq_disable_vector(unsigned int irq)
18169 +{
18170 + ldsr_disable_vector(irq);
18171 +}
18172 +
18173 +/*
18174 + * __irq_ack_vector()
18175 + * Acknowledge the specific interrupt by clearing the associate bit in
18176 + * hardware
18177 + */
18178 +static void __irq_ack_vector(unsigned int irq)
18179 +{
18180 + if (irq < 32) {
18181 + asm volatile ("move.4 INT_CLR0, %0" : : "d" (1 << irq));
18182 + } else {
18183 + asm volatile ("move.4 INT_CLR1, %0" : : "d" (1 << (irq - 32)));
18184 + }
18185 +}
18186 +
18187 +/*
18188 + * __irq_enable_vector()
18189 + * Clean and then enable the interrupt by setting the appropriate bit in
18190 + * the LDSR Mask Register.
18191 + */
18192 +static void __irq_enable_vector(unsigned int irq)
18193 +{
18194 + /*
18195 + * Acknowledge, really clear the vector.
18196 + */
18197 + __irq_ack_vector(irq);
18198 + ldsr_enable_vector(irq);
18199 +}
18200 +
18201 +/*
18202 + * __irq_mask_vector()
18203 + */
18204 +static void __irq_mask_vector(unsigned int irq)
18205 +{
18206 + ldsr_mask_vector(irq);
18207 +}
18208 +
18209 +/*
18210 + * __irq_unmask_vector()
18211 + */
18212 +static void __irq_unmask_vector(unsigned int irq)
18213 +{
18214 + ldsr_unmask_vector(irq);
18215 +}
18216 +
18217 +/*
18218 + * __irq_end_vector()
18219 + * Called once an interrupt is completed (reset the LDSR mask).
18220 + */
18221 +static void __irq_end_vector(unsigned int irq)
18222 +{
18223 + ldsr_unmask_vector(irq);
18224 +}
18225 +
18226 +#if defined(CONFIG_SMP)
18227 +/*
18228 + * __irq_set_affinity()
18229 + * Set the cpu affinity for this interrupt.
18230 + * affinity container allocated at boot
18231 + */
18232 +static void __irq_set_affinity(unsigned int irq, const struct cpumask *dest)
18233 +{
18234 + smp_set_affinity(irq, dest);
18235 + cpumask_copy(irq_desc[irq].affinity, dest);
18236 +}
18237 +#endif
18238 +
18239 +/*
18240 + * On-Chip Generic Interrupt function handling.
18241 + */
18242 +static struct irq_chip ubicom32_irq_chip = {
18243 + .name = "Ubicom32",
18244 + .startup = NULL,
18245 + .shutdown = NULL,
18246 + .enable = __irq_enable_vector,
18247 + .disable = __irq_disable_vector,
18248 + .ack = __irq_ack_vector,
18249 + .mask = __irq_mask_vector,
18250 + .unmask = __irq_unmask_vector,
18251 + .end = __irq_end_vector,
18252 +#if defined(CONFIG_SMP)
18253 + .set_affinity = __irq_set_affinity,
18254 +#endif
18255 +};
18256 +
18257 +/*
18258 + * do_IRQ()
18259 + * Primary interface for handling IRQ() requests.
18260 + */
18261 +asmlinkage void do_IRQ(int irq, struct pt_regs *regs)
18262 +{
18263 + struct pt_regs *oldregs;
18264 + struct thread_info *ti = current_thread_info();
18265 +
18266 + IRQ_DECLARE_MEASUREMENT;
18267 +
18268 + /*
18269 + * Mark that we are inside of an interrupt and
18270 + * that interrupts are disabled.
18271 + */
18272 + oldregs = set_irq_regs(regs);
18273 + ti->interrupt_nesting++;
18274 + trace_hardirqs_off();
18275 + irq_kernel_stack_check(irq, regs);
18276 +
18277 + /*
18278 + * Start the interrupt sequence
18279 + */
18280 + irq_enter();
18281 +
18282 + /*
18283 + * Execute the IRQ handler and any pending SoftIRQ requests.
18284 + */
18285 + BUG_ON(!irqs_disabled());
18286 + IRQ_MEASUREMENT_START();
18287 + __do_IRQ(irq);
18288 + IRQ_MEASUREMENT_END(irq);
18289 + BUG_ON(!irqs_disabled());
18290 +
18291 + /*
18292 + * TODO: Since IRQ's are disabled when calling irq_exit()
18293 + * modify Kconfig to set __ARCH_IRQ_EXIT_IRQS_DISABLED flag.
18294 + * This will slightly improve performance by enabling
18295 + * softirq handling to avoid disabling/disabled interrupts.
18296 + */
18297 + IRQ_MEASUREMENT_START();
18298 + irq_exit();
18299 + IRQ_MEASUREMENT_END(NR_IRQS);
18300 + BUG_ON(!irqs_disabled());
18301 +
18302 + /*
18303 + * Outside of an interrupt (or nested exit).
18304 + */
18305 + set_irq_regs(oldregs);
18306 + trace_hardirqs_on();
18307 + ti->interrupt_nesting--;
18308 +}
18309 +
18310 +/*
18311 + * irq_soft_alloc()
18312 + * Allocate a soft IRQ.
18313 + */
18314 +int irq_soft_alloc(unsigned int *soft)
18315 +{
18316 + if (irq_soft_avail == 0) {
18317 + printk(KERN_NOTICE "no soft irqs to allocate\n");
18318 + return -EFAULT;
18319 + }
18320 +
18321 + *soft = irq_get_lsb(irq_soft_avail);
18322 + irq_soft_avail &= ~(1 << *soft);
18323 + return 0;
18324 +}
18325 +
18326 +/*
18327 + * ack_bad_irq()
18328 + * Called to handle an bad irq request.
18329 + */
18330 +void ack_bad_irq(unsigned int irq)
18331 +{
18332 + printk(KERN_ERR "IRQ: unexpected irq=%d\n", irq);
18333 + __irq_end_vector(irq);
18334 +}
18335 +
18336 +/*
18337 + * show_interrupts()
18338 + * Return a string that displays the state of each of the interrupts.
18339 + */
18340 +int show_interrupts(struct seq_file *p, void *v)
18341 +{
18342 + struct irqaction *ap;
18343 + int irq = *((loff_t *) v);
18344 + int j;
18345 +
18346 + if (irq >= NR_IRQS) {
18347 + return 0;
18348 + }
18349 +
18350 + if (irq == 0) {
18351 + seq_puts(p, " ");
18352 + for_each_online_cpu(j) {
18353 + seq_printf(p, "CPU%d ", j);
18354 + }
18355 + seq_putc(p, '\n');
18356 + }
18357 +
18358 + ap = irq_desc[irq].action;
18359 + if (ap) {
18360 + seq_printf(p, "%3d: ", irq);
18361 + for_each_online_cpu(j) {
18362 + seq_printf(p, "%10u ", kstat_irqs_cpu(irq, j));
18363 + }
18364 + seq_printf(p, "%14s ", irq_desc[irq].chip->name);
18365 + seq_printf(p, "%s", ap->name);
18366 + for (ap = ap->next; ap; ap = ap->next) {
18367 + seq_printf(p, ", %s", ap->name);
18368 + }
18369 + seq_putc(p, '\n');
18370 + }
18371 + return 0;
18372 +}
18373 +
18374 +#if defined(CONFIG_DEBUG_IRQMEASURE)
18375 +static unsigned int irq_cycles_to_micro(unsigned int cycles, unsigned int frequency)
18376 +{
18377 + unsigned int micro = (cycles / (frequency / 1000000));
18378 + return micro;
18379 +}
18380 +
18381 +/*
18382 + * irq_measurement_show()
18383 + * Print out the min, avg, max values for each IRQ
18384 + *
18385 + * By request, the max value is reset after each dump.
18386 + */
18387 +static int irq_measurement_show(struct seq_file *p, void *v)
18388 +{
18389 + struct irqaction *ap;
18390 + unsigned int freq = processor_frequency();
18391 + int irq = *((loff_t *) v);
18392 +
18393 +
18394 + if (irq == 0) {
18395 + seq_puts(p, "\tmin\tavg\tmax\t(micro-seconds)\n");
18396 + }
18397 +
18398 + if (irq > NR_IRQS) {
18399 + return 0;
18400 + }
18401 +
18402 + if (irq == NR_IRQS) {
18403 + unsigned int min, avg, max;
18404 + spin_lock(&irq_measurement_lock);
18405 + min = irq_cycles_to_micro(irq_measurements[irq].min, freq);
18406 + avg = irq_cycles_to_micro(irq_measurements[irq].avg, freq);
18407 + max = irq_cycles_to_micro(irq_measurements[irq].max, freq);
18408 + irq_measurements[irq].max = 0;
18409 + spin_unlock(&irq_measurement_lock);
18410 + seq_printf(p, " \t%u\t%u\t%u\tsoftirq\n", min, avg, max);
18411 + return 0;
18412 + }
18413 +
18414 + ap = irq_desc[irq].action;
18415 + if (ap) {
18416 + unsigned int min, avg, max;
18417 + spin_lock(&irq_measurement_lock);
18418 + min = irq_cycles_to_micro(irq_measurements[irq].min, freq);
18419 + avg = irq_cycles_to_micro(irq_measurements[irq].avg, freq);
18420 + max = irq_cycles_to_micro(irq_measurements[irq].max, freq);
18421 + irq_measurements[irq].max = 0;
18422 + spin_unlock(&irq_measurement_lock);
18423 + seq_printf(p, "%2u:\t%u\t%u\t%u\t%s\n", irq, min, avg, max, ap->name);
18424 + }
18425 + return 0;
18426 +}
18427 +
18428 +static void *irq_measurement_start(struct seq_file *f, loff_t *pos)
18429 +{
18430 + return (*pos <= NR_IRQS) ? pos : NULL;
18431 +}
18432 +
18433 +static void *irq_measurement_next(struct seq_file *f, void *v, loff_t *pos)
18434 +{
18435 + (*pos)++;
18436 + if (*pos > NR_IRQS)
18437 + return NULL;
18438 + return pos;
18439 +}
18440 +
18441 +static void irq_measurement_stop(struct seq_file *f, void *v)
18442 +{
18443 + /* Nothing to do */
18444 +}
18445 +
18446 +static const struct seq_operations irq_measurement_seq_ops = {
18447 + .start = irq_measurement_start,
18448 + .next = irq_measurement_next,
18449 + .stop = irq_measurement_stop,
18450 + .show = irq_measurement_show,
18451 +};
18452 +
18453 +static int irq_measurement_open(struct inode *inode, struct file *filp)
18454 +{
18455 + return seq_open(filp, &irq_measurement_seq_ops);
18456 +}
18457 +
18458 +static const struct file_operations irq_measurement_fops = {
18459 + .open = irq_measurement_open,
18460 + .read = seq_read,
18461 + .llseek = seq_lseek,
18462 + .release = seq_release,
18463 +};
18464 +
18465 +static int __init irq_measurement_init(void)
18466 +{
18467 + proc_create("irq_measurements", 0, NULL, &irq_measurement_fops);
18468 + return 0;
18469 +}
18470 +module_init(irq_measurement_init);
18471 +#endif
18472 +
18473 +/*
18474 + * init_IRQ(void)
18475 + * Initialize the on-chip IRQ subsystem.
18476 + */
18477 +void __init init_IRQ(void)
18478 +{
18479 + int irq;
18480 + struct devtree_node *p = NULL;
18481 + struct devtree_node *iter = NULL;
18482 + unsigned int mask = 0;
18483 + unsigned int reserved = 0;
18484 +
18485 + /*
18486 + * Pull out the list of software interrupts that are avialable to
18487 + * Linux and provide an allocation function for them. The first
18488 + * 24 interrupts of INT0 are software interrupts.
18489 + */
18490 + irq_soft_avail = 0;
18491 + if (processor_interrupts(&irq_soft_avail, NULL) < 0) {
18492 + printk(KERN_WARNING "No Soft IRQ(s) available\n");
18493 + }
18494 + irq_soft_avail &= ((1 << 24) - 1);
18495 +
18496 + /*
18497 + * Initialize all of the on-chip interrupt handling
18498 + * to use a common set of interrupt functions.
18499 + */
18500 + for (irq = 0; irq < NR_IRQS; irq++) {
18501 + irq_desc[irq].status = IRQ_DISABLED;
18502 + irq_desc[irq].action = NULL;
18503 + irq_desc[irq].depth = 1;
18504 + set_irq_chip(irq, &ubicom32_irq_chip);
18505 + }
18506 +
18507 + /*
18508 + * The sendirq of a devnode is not registered within Linux but instead
18509 + * is used by the software I/O thread. These interrupts are reserved.
18510 + * The recvirq is used by Linux and registered by a device driver, these
18511 + * are not reserved.
18512 + *
18513 + * recvirq(s) that are in the software interrupt range are not supposed
18514 + * to be marked as reserved. We track this while we scan the device
18515 + * nodes.
18516 + */
18517 + p = devtree_find_next(&iter);
18518 + while (p) {
18519 + unsigned char sendirq, recvirq;
18520 + devtree_irq(p, &sendirq, &recvirq);
18521 +
18522 + /*
18523 + * If the sendirq is valid, mark that irq as taken by the
18524 + * devtree node.
18525 + */
18526 + if (sendirq < NR_IRQS) {
18527 + ubicom32_reserve_action[sendirq].handler =
18528 + ubicom32_reserve_handler;
18529 + ubicom32_reserve_action[sendirq].name = p->name;
18530 + irq_desc[sendirq].action =
18531 + &ubicom32_reserve_action[sendirq];
18532 + mask |= (1 << sendirq);
18533 + }
18534 +
18535 + /*
18536 + * Track the relevant recieve IRQ(s)
18537 + */
18538 + if (recvirq < 24) {
18539 + mask |= (1 << recvirq);
18540 + }
18541 +
18542 + /*
18543 + * Move to the next node.
18544 + */
18545 + p = devtree_find_next(&iter);
18546 + }
18547 +
18548 + /*
18549 + * Remove these bits from the irq_soft_avail list and then use the
18550 + * result as the list of pre-reserved IRQ(s).
18551 + */
18552 + reserved = ~irq_soft_avail & ~mask;
18553 + for (irq = 0; irq < 24; irq++) {
18554 + if ((reserved & (1 << irq))) {
18555 + ubicom32_reserve_action[irq].handler =
18556 + ubicom32_reserve_handler;
18557 + ubicom32_reserve_action[irq].name = "reserved";
18558 + irq_desc[irq].action = &ubicom32_reserve_action[irq];
18559 + }
18560 + }
18561 +
18562 + /*
18563 + * Initialize the LDSR which is the Ubicom32 programmable
18564 + * interrupt controller.
18565 + */
18566 + ldsr_init();
18567 +
18568 + /*
18569 + * The Ubicom trap code needs a 2nd init after IRQ(s) are setup.
18570 + */
18571 + trap_init_interrupt();
18572 +}
18573 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/ldsr.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/ldsr.c
18574 --- linux-2.6.30.10/arch/ubicom32/kernel/ldsr.c 1970-01-01 02:00:00.000000000 +0200
18575 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/ldsr.c 2009-12-11 11:45:11.000000000 +0200
18576 @@ -0,0 +1,1185 @@
18577 +/*
18578 + * arch/ubicom32/kernel/ldsr.c
18579 + * Ubicom32 architecture Linux Device Services Driver Interface
18580 + *
18581 + * (C) Copyright 2009, Ubicom, Inc.
18582 + *
18583 + * This file is part of the Ubicom32 Linux Kernel Port.
18584 + *
18585 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
18586 + * it and/or modify it under the terms of the GNU General Public License
18587 + * as published by the Free Software Foundation, either version 2 of the
18588 + * License, or (at your option) any later version.
18589 + *
18590 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
18591 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
18592 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18593 + * the GNU General Public License for more details.
18594 + *
18595 + * You should have received a copy of the GNU General Public License
18596 + * along with the Ubicom32 Linux Kernel Port. If not,
18597 + * see <http://www.gnu.org/licenses/>.
18598 + *
18599 + * Ubicom32 implementation derived from (with many thanks):
18600 + * arch/m68knommu
18601 + * arch/blackfin
18602 + * arch/parisc
18603 + *
18604 + * NOTES:
18605 + *
18606 + * The LDSR is a programmable interrupt controller that is written in software.
18607 + * It emulates the behavior of an pic by fielding the interrupts, choosing a
18608 + * victim thread to take the interrupt and forcing that thread to take a context
18609 + * switch to the appropriate interrupt handler.
18610 + *
18611 + * Because traps are treated as just a special class of interrupts, the LDSR
18612 + * also handles the processing of traps.
18613 + *
18614 + * Because we compile Linux both UP and SMP, we need the LDSR to use
18615 + * architectural locking that is not "compiled out" when compiling UP. For now,
18616 + * we use the single atomic bit lock.
18617 + */
18618 +#include <linux/kernel.h>
18619 +#include <linux/init.h>
18620 +#include <linux/sched.h>
18621 +#include <linux/interrupt.h>
18622 +#include <linux/irq.h>
18623 +#include <linux/profile.h>
18624 +#include <linux/clocksource.h>
18625 +#include <linux/types.h>
18626 +#include <linux/module.h>
18627 +#include <linux/cpumask.h>
18628 +#include <linux/bug.h>
18629 +#include <linux/delay.h>
18630 +#include <asm/ip5000.h>
18631 +#include <asm/atomic.h>
18632 +#include <asm/machdep.h>
18633 +#include <asm/asm-offsets.h>
18634 +#include <asm/traps.h>
18635 +#include <asm/thread.h>
18636 +#include <asm/range-protect.h>
18637 +
18638 +/*
18639 + * One can not print from the LDSR so the best we can do is
18640 + * check a condition and stall all of the threads.
18641 + */
18642 +
18643 +// #define DEBUG_LDSR 1
18644 +#if defined(DEBUG_LDSR)
18645 +#define DEBUG_ASSERT(cond) \
18646 + if (!(cond)) { \
18647 + THREAD_STALL; \
18648 + }
18649 +#else
18650 +#define DEBUG_ASSERT(cond)
18651 +#endif
18652 +
18653 +/*
18654 + * Make global so that we can use it in the RFI code in assembly.
18655 + */
18656 +unsigned int ldsr_soft_irq_mask;
18657 +EXPORT_SYMBOL(ldsr_soft_irq_mask);
18658 +
18659 +static unsigned int ldsr_suspend_mask;
18660 +static unsigned int ldsr_soft_irq;
18661 +static unsigned int ldsr_stack_space[1024];
18662 +
18663 +static struct ldsr_register_bank {
18664 + volatile unsigned int enabled0;
18665 + volatile unsigned int enabled1;
18666 + volatile unsigned int mask0;
18667 + volatile unsigned int mask1;
18668 + unsigned int total;
18669 + unsigned int retry;
18670 + unsigned int backout;
18671 +} ldsr_interrupt;
18672 +
18673 +/*
18674 + * Which thread/cpu are we?
18675 + */
18676 +static int ldsr_tid = -1;
18677 +
18678 +#if defined(CONFIG_IRQSTACKS)
18679 +/*
18680 + * per-CPU IRQ stacks (thread information and stack)
18681 + *
18682 + * NOTE: Do not use DEFINE_PER_CPU() as it makes it harder
18683 + * to find the location of ctx from assembly language.
18684 + */
18685 +union irq_ctx {
18686 + struct thread_info tinfo;
18687 + u32 stack[THREAD_SIZE/sizeof(u32)];
18688 +};
18689 +static union irq_ctx *percpu_irq_ctxs[NR_CPUS];
18690 +
18691 +/*
18692 + * Storage for the interrupt stack.
18693 + */
18694 +#if !defined(CONFIG_IRQSTACKS_USEOCM)
18695 +static char percpu_irq_stacks[(NR_CPUS * THREAD_SIZE) + (THREAD_SIZE - 1)];
18696 +#else
18697 +/*
18698 + * For OCM, the linker will ensure that space is allocated for the stack
18699 + * see (vmlinux.lds.S)
18700 + */
18701 +static char percpu_irq_stacks[];
18702 +#endif
18703 +
18704 +#endif
18705 +
18706 +/*
18707 + * Save trap IRQ because we need to un-suspend if it gets set.
18708 + */
18709 +static unsigned int ldsr_trap_irq_mask;
18710 +static unsigned int ldsr_trap_irq;
18711 +
18712 +/*
18713 + * ret_from_interrupt_to_kernel
18714 + * Just restore the context and do nothing else.
18715 + */
18716 +asmlinkage void ret_from_interrupt_to_kernel(void)__attribute__((naked));
18717 +
18718 +/*
18719 + * ret_from_interrupt_to_user
18720 + * Call scheduler if needed. Just restore the context.
18721 + */
18722 +asmlinkage void ret_from_interrupt_to_user(void)__attribute__((naked));
18723 +
18724 +#ifdef DEBUG_LDSR
18725 +u32_t old_sp, old_pc, old_a0, old_a5, old_a3;
18726 +struct pt_regs copy_regs, *copy_save_area;
18727 +#endif
18728 +
18729 +int __user_mode(unsigned long sp)
18730 +{
18731 +
18732 + u32_t saved_stack_base = sp & ~(ASM_THREAD_SIZE - 1);
18733 +#if defined(CONFIG_IRQSTACKS_USEOCM)
18734 + if ((union irq_ctx *)saved_stack_base == percpu_irq_ctxs[smp_processor_id()]) {
18735 + /*
18736 + * On the interrupt stack.
18737 + */
18738 + return 0;
18739 + }
18740 +#endif
18741 +
18742 + if (!(u32_t)current) {
18743 + return 0;
18744 + }
18745 + return saved_stack_base != ((u32_t)current->stack);
18746 +}
18747 +
18748 +/*
18749 + * ldsr_lock_release()
18750 + * Release the LDSR lock.
18751 + */
18752 +static void ldsr_lock_release(void)
18753 +{
18754 + UBICOM32_UNLOCK(LDSR_LOCK_BIT);
18755 +}
18756 +
18757 +/*
18758 + * ldsr_lock_acquire()
18759 + * Acquire the LDSR lock, spin if not available.
18760 + */
18761 +static void ldsr_lock_acquire(void)
18762 +{
18763 + UBICOM32_LOCK(LDSR_LOCK_BIT);
18764 +}
18765 +
18766 +/*
18767 + * ldsr_thread_irq_disable()
18768 + * Disable interrupts for the specified thread.
18769 + */
18770 +static void ldsr_thread_irq_disable(unsigned int tid)
18771 +{
18772 + unsigned int mask = (1 << tid);
18773 +
18774 + asm volatile (
18775 + " or.4 scratchpad1, scratchpad1, %0 \n\t"
18776 + :
18777 + : "d"(mask)
18778 + : "cc"
18779 + );
18780 +}
18781 +
18782 +/*
18783 + * ldsr_thread_get_interrupts()
18784 + * Get the interrupt state for all threads.
18785 + */
18786 +static unsigned long ldsr_thread_get_interrupts(void)
18787 +{
18788 + unsigned long ret = 0;
18789 + asm volatile (
18790 + " move.4 %0, scratchpad1 \n\t"
18791 + : "=r" (ret)
18792 + :
18793 + );
18794 + return ret;
18795 +}
18796 +
18797 +/*
18798 + * ldsr_emulate_and_run()
18799 + * Emulate the instruction and then set the thread to run.
18800 + */
18801 +static void ldsr_emulate_and_run(unsigned int tid)
18802 +{
18803 + unsigned int thread_mask = (1 << tid);
18804 + u32_t write_csr = (tid << 15) | (1 << 14);
18805 +
18806 + /*
18807 + * Emulate the unaligned access.
18808 + */
18809 + unaligned_emulate(tid);
18810 +
18811 + /*
18812 + * Get the thread back in a running state.
18813 + */
18814 + asm volatile (
18815 + " setcsr %0 \n\t"
18816 + " setcsr_flush 0 \n\t"
18817 + " move.4 trap_cause, #0 \n\t" /* Clear the trap cause
18818 + * register */
18819 + " setcsr #0 \n\t"
18820 + " setcsr_flush 0 \n\t"
18821 + " move.4 mt_dbg_active_set, %1 \n\t" /* Activate thread even if
18822 + * in dbg/fault state */
18823 + " move.4 mt_active_set, %1 \n\t" /* Restart target
18824 + * thread. */
18825 + :
18826 + : "r" (write_csr), "d" (thread_mask)
18827 + : "cc"
18828 + );
18829 + thread_enable_mask(thread_mask);
18830 +}
18831 +
18832 +/*
18833 + * ldsr_preemptive_context_save()
18834 + * save thread context from another hardware thread. The other thread must
18835 + * be stalled.
18836 + */
18837 +static inline void ldsr_preemptive_context_save(u32_t thread,
18838 + struct pt_regs *regs)
18839 +{
18840 + /*
18841 + * Save the current state of the specified thread
18842 + */
18843 + asm volatile (
18844 + " move.4 a3, %0 \n\t"
18845 +
18846 + /* set src1 from the target thread */
18847 + " move.4 csr, %1 \n\t"
18848 + " setcsr_flush 0 \n\t"
18849 + " setcsr_flush 0 \n\t"
18850 +
18851 + /* copy state from the other thread */
18852 + " move.4 "D(PT_D0)"(a3), d0 \n\t"
18853 + " move.4 "D(PT_D1)"(a3), d1 \n\t"
18854 + " move.4 "D(PT_D2)"(a3), d2 \n\t"
18855 + " move.4 "D(PT_D3)"(a3), d3 \n\t"
18856 + " move.4 "D(PT_D4)"(a3), d4 \n\t"
18857 + " move.4 "D(PT_D5)"(a3), d5 \n\t"
18858 + " move.4 "D(PT_D6)"(a3), d6 \n\t"
18859 + " move.4 "D(PT_D7)"(a3), d7 \n\t"
18860 + " move.4 "D(PT_D8)"(a3), d8 \n\t"
18861 + " move.4 "D(PT_D9)"(a3), d9 \n\t"
18862 + " move.4 "D(PT_D10)"(a3), d10 \n\t"
18863 + " move.4 "D(PT_D11)"(a3), d11 \n\t"
18864 + " move.4 "D(PT_D12)"(a3), d12 \n\t"
18865 + " move.4 "D(PT_D13)"(a3), d13 \n\t"
18866 + " move.4 "D(PT_D14)"(a3), d14 \n\t"
18867 + " move.4 "D(PT_D15)"(a3), d15 \n\t"
18868 + " move.4 "D(PT_A0)"(a3), a0 \n\t"
18869 + " move.4 "D(PT_A1)"(a3), a1 \n\t"
18870 + " move.4 "D(PT_A2)"(a3), a2 \n\t"
18871 + " move.4 "D(PT_A3)"(a3), a3 \n\t"
18872 + " move.4 "D(PT_A4)"(a3), a4 \n\t"
18873 + " move.4 "D(PT_A5)"(a3), a5 \n\t"
18874 + " move.4 "D(PT_A6)"(a3), a6 \n\t"
18875 + " move.4 "D(PT_SP)"(a3), a7 \n\t"
18876 + " move.4 "D(PT_ACC0HI)"(a3), acc0_hi \n\t"
18877 + " move.4 "D(PT_ACC0LO)"(a3), acc0_lo \n\t"
18878 + " move.4 "D(PT_MAC_RC16)"(a3), mac_rc16 \n\t"
18879 + " move.4 "D(PT_ACC1HI)"(a3), acc1_hi \n\t"
18880 + " move.4 "D(PT_ACC1LO)"(a3), acc1_lo \n\t"
18881 + " move.4 "D(PT_SOURCE3)"(a3), source3 \n\t"
18882 + " move.4 "D(PT_INST_CNT)"(a3), inst_cnt \n\t"
18883 + " move.4 "D(PT_CSR)"(a3), csr \n\t"
18884 + " move.4 "D(PT_DUMMY_UNUSED)"(a3), #0 \n\t"
18885 + " move.4 "D(PT_INT_MASK0)"(a3), int_mask0 \n\t"
18886 + " move.4 "D(PT_INT_MASK1)"(a3), int_mask1 \n\t"
18887 + " move.4 "D(PT_TRAP_CAUSE)"(a3), trap_cause \n\t"
18888 + " move.4 "D(PT_PC)"(a3), pc \n\t"
18889 + " move.4 "D(PT_PREVIOUS_PC)"(a3), previous_pc \n\t"
18890 + /* disable csr thread select */
18891 + " movei csr, #0 \n\t"
18892 + " setcsr_flush 0 \n\t"
18893 + :
18894 + : "r" (regs->dn), "d" ((thread << 9) | (1 << 8))
18895 + : "a3"
18896 + );
18897 +}
18898 +
18899 +/*
18900 + * ldsr_rotate_threads()
18901 + * Simple round robin algorithm for choosing the next cpu
18902 + */
18903 +static int ldsr_rotate_threads(unsigned long cpus)
18904 +{
18905 + static unsigned char ldsr_bits[8] = {
18906 + 3, 0, 1, 0, 2, 0, 1, 0
18907 + };
18908 +
18909 + static int nextbit;
18910 + int thisbit;
18911 +
18912 + /*
18913 + * Move the interrupts down so that we consider interrupts from where
18914 + * we left off, then take the interrupts we would lose and move them
18915 + * to the top half of the interrupts value.
18916 + */
18917 + cpus = (cpus >> nextbit) | (cpus << ((sizeof(cpus) * 8) - nextbit));
18918 +
18919 + /*
18920 + * 50% of the time we won't take this at all and then of the cases where
18921 + * we do about 50% of those we only execute once.
18922 + */
18923 + if (!(cpus & 0xffff)) {
18924 + nextbit += 16;
18925 + cpus >>= 16;
18926 + }
18927 +
18928 + if (!(cpus & 0xff)) {
18929 + nextbit += 8;
18930 + cpus >>= 8;
18931 + }
18932 +
18933 + if (!(cpus & 0xf)) {
18934 + nextbit += 4;
18935 + cpus >>= 4;
18936 + }
18937 +
18938 + nextbit += ldsr_bits[cpus & 0x7];
18939 + thisbit = (nextbit & ((sizeof(cpus) * 8) - 1));
18940 + nextbit = (thisbit + 1) & ((sizeof(cpus) * 8) - 1);
18941 + DEBUG_ASSERT(thisbit < THREAD_ARCHITECTURAL_MAX);
18942 + return thisbit;
18943 +}
18944 +
18945 +/*
18946 + * ldsr_rotate_interrupts()
18947 + * Get rotating next set bit value.
18948 + */
18949 +static int ldsr_rotate_interrupts(unsigned long long interrupts)
18950 +{
18951 + static unsigned char ldsr_bits[8] = {
18952 + 3, 0, 1, 0, 2, 0, 1, 0
18953 + };
18954 +
18955 + static int nextbit;
18956 + int thisbit;
18957 +
18958 + /*
18959 + * Move the interrupts down so that we consider interrupts from where
18960 + * we left off, then take the interrupts we would lose and move them
18961 + * to the top half of the interrupts value.
18962 + */
18963 + interrupts = (interrupts >> nextbit) |
18964 + (interrupts << ((sizeof(interrupts) * 8) - nextbit));
18965 +
18966 + /*
18967 + * 50% of the time we won't take this at all and then of the cases where
18968 + * we do about 50% of those we only execute once.
18969 + */
18970 + if (!(interrupts & 0xffffffff)) {
18971 + nextbit += 32;
18972 + interrupts >>= 32;
18973 + }
18974 +
18975 + if (!(interrupts & 0xffff)) {
18976 + nextbit += 16;
18977 + interrupts >>= 16;
18978 + }
18979 +
18980 + if (!(interrupts & 0xff)) {
18981 + nextbit += 8;
18982 + interrupts >>= 8;
18983 + }
18984 +
18985 + if (!(interrupts & 0xf)) {
18986 + nextbit += 4;
18987 + interrupts >>= 4;
18988 + }
18989 +
18990 + nextbit += ldsr_bits[interrupts & 0x7];
18991 + thisbit = (nextbit & ((sizeof(interrupts) * 8) - 1));
18992 + nextbit = (thisbit + 1) & ((sizeof(interrupts) * 8) - 1);
18993 +
18994 + DEBUG_ASSERT(thisbit < (sizeof(interrupts) * 8));
18995 + return thisbit;
18996 +}
18997 +
18998 +/*
18999 + * ldsr_backout_or_irq()
19000 + *
19001 + * One way or the other this interrupt is not being
19002 + * processed, make sure that it is reset. We are
19003 + * not going to call irq_end_vector() so unmask the
19004 + * interrupt.
19005 + */
19006 +static void ldsr_backout_of_irq(int vector, unsigned long tid_mask)
19007 +{
19008 +#if defined(CONFIG_SMP)
19009 + if (unlikely(vector == smp_ipi_irq)) {
19010 + smp_reset_ipi(tid_mask);
19011 + }
19012 +#endif
19013 + ldsr_unmask_vector(vector);
19014 + ldsr_interrupt.backout++;
19015 +}
19016 +
19017 +#if defined(CONFIG_IRQSTACKS)
19018 +/*
19019 + * ldsr_choose_savearea_and_returnvec()
19020 + * Test our current state (user, kernel, interrupt) and set things up.
19021 + *
19022 + * This version of the function uses 3 stacks and nests interrupts
19023 + * on the interrupt stack.
19024 + */
19025 +static struct pt_regs *ldsr_choose_savearea_and_returnvec(thread_t tid, u32_t linux_sp, u32_t *pvec)
19026 +{
19027 + struct pt_regs *save_area;
19028 + u32_t masked_linux_sp = linux_sp & ~(THREAD_SIZE - 1);
19029 + struct thread_info * ti= (struct thread_info *)sw_ksp[tid];
19030 +
19031 +#if defined(CONFIG_SMP)
19032 + union irq_ctx *icp = percpu_irq_ctxs[tid];
19033 +#else
19034 + union irq_ctx *icp = percpu_irq_ctxs[0];
19035 +#endif
19036 +
19037 + if (masked_linux_sp == (u32_t)icp) {
19038 + /*
19039 + * Fault/Interrupt occurred while on the interrupt stack.
19040 + */
19041 + save_area = (struct pt_regs *)((char *)linux_sp - sizeof(struct pt_regs) - 8);
19042 + *pvec = (u32_t)(&ret_from_interrupt_to_kernel);
19043 + } else {
19044 + /*
19045 + * Fault/Interrupt occurred while on user/kernel stack. This is a new
19046 + * first use of the interrupt stack.
19047 + */
19048 + save_area = (struct pt_regs *) ((char *)icp + sizeof(icp->stack) - sizeof(struct pt_regs) - 8);
19049 + if (masked_linux_sp == (u32_t)ti) {
19050 + *pvec = (u32_t)(&ret_from_interrupt_to_kernel);
19051 + } else {
19052 + *pvec = (u32_t)(&ret_from_interrupt_to_user);
19053 + }
19054 +
19055 + /*
19056 + * Because the softirq code will execute on the "interrupt" stack, we
19057 + * need to maintain the knowledge of what "task" was executing on the
19058 + * cpu. This is done by copying the thread_info->task from the cpu
19059 + * we are about to context switch into the interrupt contexts thread_info
19060 + * structure.
19061 + */
19062 + icp->tinfo.task = ti->task;
19063 + icp->tinfo.preempt_count =
19064 + (icp->tinfo.preempt_count & ~SOFTIRQ_MASK) |
19065 + (ti->preempt_count & SOFTIRQ_MASK);
19066 + icp->tinfo.interrupt_nesting = 0;
19067 + }
19068 + save_area->nesting_level = icp->tinfo.interrupt_nesting;
19069 + return save_area;
19070 +}
19071 +
19072 +#else
19073 +/*
19074 + * ldsr_choose_savearea_and_returnvec()
19075 + * Test our current state (user, kernel, interrupt) and set things up.
19076 + *
19077 + * The version of the function uses just the user & kernel stack and
19078 + * nests interrupts on the existing kernel stack.
19079 + */
19080 +static struct pt_regs *ldsr_choose_savearea_and_returnvec(thread_t tid, u32_t linux_sp, u32_t *pvec)
19081 +{
19082 + struct pt_regs *save_area;
19083 + u32_t masked_linux_sp = linux_sp & ~(THREAD_SIZE - 1);
19084 + struct thread_info *ti = (struct thread_info *)sw_ksp[tid];
19085 +
19086 + if (masked_linux_sp == (u32_t)ti) {
19087 + /*
19088 + * Fault/Interrupt occurred while on the kernel stack.
19089 + */
19090 + save_area = (struct pt_regs *)((char *)linux_sp - sizeof(struct pt_regs) - 8);
19091 + *pvec = (u32_t) (&ret_from_interrupt_to_kernel);
19092 + } else {
19093 + /*
19094 + * Fault/Interrupt occurred while on user stack.
19095 + */
19096 + ti->interrupt_nesting = 0;
19097 + save_area = (struct pt_regs *)((u32_t)ti + THREAD_SIZE - sizeof(struct pt_regs) - 8);
19098 + *pvec = (u32_t) (&ret_from_interrupt_to_user);
19099 + }
19100 + save_area->nesting_level = ti->interrupt_nesting;
19101 + return save_area;
19102 +}
19103 +#endif
19104 +
19105 +/*
19106 + * ldsr_ctxsw_thread()
19107 + * Context switch a mainline thread to execute do_IRQ() for the specified
19108 + * vector.
19109 + */
19110 +static void ldsr_ctxsw_thread(int vector, thread_t tid)
19111 +{
19112 + u32_t linux_sp;
19113 + u32_t return_vector;
19114 + struct pt_regs *save_area, *regs;
19115 + u32_t thread_mask = (1 << tid);
19116 + u32_t read_csr = ((tid << 9) | (1 << 8));
19117 + u32_t write_csr = (tid << 15) | (1 << 14);
19118 + u32_t interrupt_vector = (u32_t)(&do_IRQ);
19119 +
19120 + unsigned int frame_type = UBICOM32_FRAME_TYPE_INTERRUPT;
19121 +
19122 +
19123 + DEBUG_ASSERT(!thread_is_enabled(tid));
19124 +
19125 + /*
19126 + * Acquire the necessary global and per thread locks for tid.
19127 + * As a side effect, we ensure that the thread has not trapped
19128 + * and return true if it has.
19129 + */
19130 + if (unlikely(thread_is_trapped(tid))) {
19131 + /*
19132 + * Read the trap cause, the sp and clear the MT_TRAP bits.
19133 + */
19134 + unsigned int cause;
19135 + asm volatile (
19136 + " setcsr %3 \n\t"
19137 + " setcsr_flush 0 \n\t"
19138 + " setcsr_flush 0 \n\t"
19139 + " move.4 %0, TRAP_CAUSE \n\t"
19140 + " move.4 %1, SP \n\t"
19141 + " setcsr #0 \n\t"
19142 + " setcsr_flush 0 \n\t"
19143 + " move.4 MT_BREAK_CLR, %2\n\t"
19144 + " move.4 MT_TRAP_CLR, %2 \n\t"
19145 + : "=&r" (cause), "=&r" (linux_sp)
19146 + : "r" (thread_mask), "m" (read_csr)
19147 + );
19148 +
19149 + ldsr_backout_of_irq(vector, (1 << tid));
19150 +
19151 +#if !defined(CONFIG_UNALIGNED_ACCESS_DISABLED)
19152 + /*
19153 + * See if the unaligned trap handler can deal with this.
19154 + * If so, emulate the instruction and then just restart
19155 + * the thread.
19156 + */
19157 + if (unaligned_only(cause)) {
19158 +#if defined(CONFIG_UNALIGNED_ACCESS_USERSPACE_ONLY)
19159 + /*
19160 + * Check if this is a kernel stack if so we will not
19161 + * handle the trap
19162 + */
19163 + u32_t masked_linux_sp = linux_sp & ~(THREAD_SIZE - 1);
19164 + if ((masked_linux_sp != (u32_t)sw_ksp[tid]) &&
19165 + unaligned_only(cause)) {
19166 + ldsr_emulate_and_run(tid);
19167 + return;
19168 + }
19169 +#else
19170 + ldsr_emulate_and_run(tid);
19171 + return;
19172 +#endif
19173 +
19174 + }
19175 +#endif
19176 +
19177 + interrupt_vector = (u32_t)(&trap_handler);
19178 + frame_type = UBICOM32_FRAME_TYPE_TRAP;
19179 + } else {
19180 + /*
19181 + * Read the target thread's SP
19182 + */
19183 + asm volatile (
19184 + " setcsr %1 \n\t"
19185 + " setcsr_flush 0 \n\t"
19186 + " setcsr_flush 0 \n\t"
19187 + " move.4 %0, SP \n\t"
19188 + " setcsr #0 \n\t"
19189 + " setcsr_flush 0 \n\t"
19190 + : "=m" (linux_sp)
19191 + : "m" (read_csr)
19192 + );
19193 + }
19194 +
19195 + /*
19196 + * We are delivering an interrupt, count it.
19197 + */
19198 + ldsr_interrupt.total++;
19199 +
19200 + /*
19201 + * At this point, we will definitely force this thread to
19202 + * a new context, show its interrupts as disabled.
19203 + */
19204 + ldsr_thread_irq_disable(tid);
19205 +
19206 + /*
19207 + * Test our current state (user, kernel, interrupt). Save the
19208 + * appropriate data and setup for the return.
19209 + */
19210 + save_area = ldsr_choose_savearea_and_returnvec(tid, linux_sp, &return_vector);
19211 +
19212 + /*
19213 + * The pt_regs (save_area) contains the type of thread that we are dealing
19214 + * with (KERNEL/NORMAL) and is copied into each pt_regs area. We get this
19215 + * from the current tasks kernel pt_regs area that always exists at the
19216 + * top of the kernel stack.
19217 + */
19218 + regs = (struct pt_regs *)((u32_t)sw_ksp[tid] + THREAD_SIZE - sizeof(struct pt_regs) - 8);
19219 + save_area->thread_type = regs->thread_type;
19220 +
19221 + /*
19222 + * Preserve the context of the Linux thread.
19223 + */
19224 + ldsr_preemptive_context_save(tid, save_area);
19225 +
19226 + /*
19227 + * Load the fram_type into the save_area.
19228 + */
19229 + save_area->frame_type = frame_type;
19230 +
19231 +#ifdef CONFIG_STOP_ON_TRAP
19232 + /*
19233 + * Before we get backtrace and showing stacks working well, it sometimes
19234 + * helps to enter the debugger when a trap occurs before we change the
19235 + * thread to handle the fault. This optional code causes all threads to
19236 + * stop on every trap frame. One assumes that GDB connected via the
19237 + * mailbox interface will be used to recover from this state.
19238 + */
19239 + if (frame_type == UBICOM32_FRAME_TYPE_TRAP) {
19240 + THREAD_STALL;
19241 + }
19242 +#endif
19243 +
19244 +#ifdef DEBUG_LDSR
19245 + copy_regs = *save_area;
19246 + copy_save_area = save_area;
19247 +
19248 + old_a0 = save_area->an[0];
19249 + old_a3 = save_area->an[3];
19250 + old_sp = save_area->an[7];
19251 + old_a5 = save_area->an[5];
19252 + old_pc = save_area->pc;
19253 +#endif
19254 +
19255 + /*
19256 + * Now we have to switch the kernel thread to run do_IRQ function.
19257 + * Set pc to do_IRQ
19258 + * Set d0 to vector
19259 + * Set d1 to save_area.
19260 + * Set a5 to the proper return vector.
19261 + */
19262 + asm volatile (
19263 + " setcsr %0 \n\t"
19264 + " setcsr_flush 0 \n\t"
19265 + " move.4 d0, %5 \n\t" /* d0 = 0 vector # */
19266 + " move.4 d1, %1 \n\t" /* d1 = save_area */
19267 + " move.4 sp, %1 \n\t" /* sp = save_area */
19268 + " move.4 a5, %2 \n\t" /* a5 = return_vector */
19269 + " move.4 pc, %3 \n\t" /* pc = do_IRQ routine. */
19270 + " move.4 trap_cause, #0 \n\t" /* Clear the trap cause
19271 + * register */
19272 + " setcsr #0 \n\t"
19273 + " setcsr_flush 0 \n\t"
19274 + " enable_kernel_ranges %4 \n\t"
19275 + " move.4 mt_dbg_active_set, %4 \n\t" /* Activate thread even if
19276 + * in dbg/fault state */
19277 + " move.4 mt_active_set, %4 \n\t" /* Restart target
19278 + * thread. */
19279 + :
19280 + : "r" (write_csr), "r" (save_area),
19281 + "r" (return_vector), "r" (interrupt_vector),
19282 + "d" (thread_mask), "r" (vector)
19283 + : "cc"
19284 + );
19285 + thread_enable_mask(thread_mask);
19286 +}
19287 +
19288 +/*
19289 + * ldsr_deliver_interrupt()
19290 + * Deliver the interrupt to one of the threads or all of the threads.
19291 + */
19292 +static void ldsr_deliver_interrupt(int vector,
19293 + unsigned long deliver_to,
19294 + int all)
19295 +{
19296 + unsigned long disabled_threads;
19297 + unsigned long possible_threads;
19298 + unsigned long trapped_threads;
19299 + unsigned long global_locks;
19300 +
19301 + /*
19302 + * Disable all of the threads that we might want to send
19303 + * this interrupt to.
19304 + */
19305 +retry:
19306 + DEBUG_ASSERT(deliver_to);
19307 + thread_disable_mask(deliver_to);
19308 +
19309 + /*
19310 + * If any threads are in the trap state, we have to service the
19311 + * trap for those threads first.
19312 + */
19313 + asm volatile (
19314 + "move.4 %0, MT_TRAP \n\t"
19315 + : "=r" (trapped_threads)
19316 + :
19317 + );
19318 +
19319 + trapped_threads &= deliver_to;
19320 + if (unlikely(trapped_threads)) {
19321 + /*
19322 + * all traps will be handled, so clear the trap bit before restarting any threads
19323 + */
19324 + ubicom32_clear_interrupt(ldsr_trap_irq);
19325 +
19326 + /*
19327 + * Let the remaining untrapped threads, continue.
19328 + */
19329 + deliver_to &= ~trapped_threads;
19330 + if (deliver_to) {
19331 + thread_enable_mask(deliver_to);
19332 + }
19333 +
19334 + /*
19335 + * For the trapped threads force them to handle
19336 + * a trap.
19337 + */
19338 + while (trapped_threads) {
19339 + unsigned long which = ffz(~trapped_threads);
19340 + trapped_threads &= ~(1 << which);
19341 + ldsr_ctxsw_thread(vector, which);
19342 + }
19343 + return;
19344 + }
19345 +
19346 + /*
19347 + * Can we deliver an interrupt to any of the threads?
19348 + */
19349 + disabled_threads = ldsr_thread_get_interrupts();
19350 + possible_threads = deliver_to & ~disabled_threads;
19351 + if (unlikely(!possible_threads)) {
19352 +#if defined(CONFIG_SMP)
19353 + /*
19354 + * In the SMP case, we can not wait because 1 cpu might be
19355 + * sending an IPI to another cpu which is currently blocked.
19356 + * The only way to ensure IPI delivery is to backout and
19357 + * keep trying. For SMP, we don't sleep until the interrupts
19358 + * are delivered.
19359 + */
19360 + thread_enable_mask(deliver_to);
19361 + ldsr_backout_of_irq(vector, deliver_to);
19362 + return;
19363 +#else
19364 + /*
19365 + * In the UP case, we have nothing to do so we should wait.
19366 + *
19367 + * Since the INT_MASK0 and INT_MASK1 are "re-loaded" before we
19368 + * suspend in the outer loop, we do not need to save them here.
19369 + *
19370 + * We test that we were awakened for our specific interrupts
19371 + * because the ldsr mask/unmask operations will force the ldsr
19372 + * awake even if the interrupt on the mainline thread is not
19373 + * completed.
19374 + */
19375 + unsigned int scratch = 0;
19376 + thread_enable_mask(deliver_to);
19377 + asm volatile (
19378 + " move.4 INT_MASK0, %1 \n\t"
19379 + " move.4 INT_MASK1, #0 \n\t"
19380 +
19381 + "1: suspend \n\t"
19382 + " move.4 %0, INT_STAT0 \n\t"
19383 + " and.4 %0, %0, %1 \n\t"
19384 + " jmpeq.f 1b \n\t"
19385 +
19386 + " move.4 INT_CLR0, %2 \n\t"
19387 + : "+r" (scratch)
19388 + : "d" (ldsr_suspend_mask), "r" (ldsr_soft_irq_mask)
19389 + : "cc"
19390 + );
19391 +
19392 + /*
19393 + * This delay is sized to coincide with the time it takes a
19394 + * thread to complete the exit (see return_from_interrupt).
19395 + */
19396 + ldsr_interrupt.retry++;
19397 + __delay(10);
19398 + goto retry;
19399 +#endif
19400 + }
19401 +
19402 + /*
19403 + * If any of the global locks are held, we can not deliver any
19404 + * interrupts, we spin delay(10) and then try again. If our
19405 + * spinning becomes a bottle neck, we will need to suspend but for
19406 + * now lets just spin.
19407 + */
19408 + asm volatile (
19409 + "move.4 %0, scratchpad1 \n\t"
19410 + : "=r" (global_locks)
19411 + :
19412 + );
19413 + if (unlikely(global_locks & 0xffff0000)) {
19414 + thread_enable_mask(deliver_to);
19415 +
19416 + /*
19417 + * This delay is sized to coincide with the average time it
19418 + * takes a thread to release a global lock.
19419 + */
19420 + ldsr_interrupt.retry++;
19421 + __delay(10);
19422 + goto retry;
19423 + }
19424 +
19425 + /*
19426 + * Deliver to one cpu.
19427 + */
19428 + if (!all) {
19429 + /*
19430 + * Find our victim and then enable everyone else.
19431 + */
19432 + unsigned long victim = ldsr_rotate_threads(possible_threads);
19433 + DEBUG_ASSERT((deliver_to & (1 << victim)));
19434 + DEBUG_ASSERT((possible_threads & (1 << victim)));
19435 +
19436 + deliver_to &= ~(1 << victim);
19437 + if (deliver_to) {
19438 + thread_enable_mask(deliver_to);
19439 + }
19440 + ldsr_ctxsw_thread(vector, victim);
19441 + return;
19442 + }
19443 +
19444 + /*
19445 + * If we can't deliver to some threads, wake them
19446 + * back up and reset things to deliver to them.
19447 + */
19448 + deliver_to &= ~possible_threads;
19449 + if (unlikely(deliver_to)) {
19450 + thread_enable_mask(deliver_to);
19451 + ldsr_backout_of_irq(vector, deliver_to);
19452 + }
19453 +
19454 + /*
19455 + * Deliver to all possible threads(s).
19456 + */
19457 + while (possible_threads) {
19458 + unsigned long victim = ffz(~possible_threads);
19459 + possible_threads &= ~(1 << victim);
19460 + ldsr_ctxsw_thread(vector, victim);
19461 + }
19462 +}
19463 +
19464 +/*
19465 + * ldsr_thread()
19466 + * This thread acts as the interrupt controller for Linux.
19467 + */
19468 +static void ldsr_thread(void *arg)
19469 +{
19470 + int stat0;
19471 + int stat1;
19472 + int interrupt0;
19473 + int interrupt1;
19474 + long long interrupts;
19475 + unsigned long cpus;
19476 +
19477 +#if !defined(CONFIG_SMP)
19478 + /*
19479 + * In a non-smp configuration, we can not use the cpu(s) arrays because
19480 + * there is not a 1-1 correspondence between cpus(s) and our threads.
19481 + * Thus we must get a local idea of the mainline threads and use the
19482 + * one and only 1 set as the victim. We do this once before the ldsr
19483 + * loop.
19484 + *
19485 + * In the SMP case, we will use the cpu(s) map to determine which cpu(s)
19486 + * are valid to send interrupts to.
19487 + */
19488 + int victim = 0;
19489 + unsigned int mainline = thread_get_mainline();
19490 + if (mainline == 0) {
19491 + panic("no mainline Linux threads to interrupt");
19492 + return;
19493 + }
19494 + victim = ffz(~mainline);
19495 + cpus = (1 << victim);
19496 +#endif
19497 +
19498 + while (1) {
19499 + /*
19500 + * If one changes this code not to reload the INT_MASK(s), you
19501 + * need to know that code in the lock waiting above does not
19502 + * reset the MASK registers back; so that code will need to be
19503 + * changed.
19504 + */
19505 + ldsr_lock_acquire();
19506 + asm volatile (
19507 + " move.4 INT_MASK0, %0 \n\t"
19508 + " move.4 INT_MASK1, %1 \n\t"
19509 + :
19510 + : "U4" (ldsr_interrupt.mask0), "U4" (ldsr_interrupt.mask1)
19511 + );
19512 + ldsr_lock_release();
19513 + thread_suspend();
19514 +
19515 + /*
19516 + * Read the interrupt status registers
19517 + */
19518 + asm volatile (
19519 + "move.4 %0, INT_STAT0 \n\t"
19520 + "move.4 %1, INT_STAT1 \n\t"
19521 + : "=r" (stat0), "=r" (stat1)
19522 + :
19523 + );
19524 +
19525 + /*
19526 + * We only care about interrupts that we have been told to care
19527 + * about. The interrupt must be enabled, unmasked, and have
19528 + * occurred in the hardware.
19529 + */
19530 + ldsr_lock_acquire();
19531 + interrupt0 = ldsr_interrupt.enabled0 &
19532 + ldsr_interrupt.mask0 & stat0;
19533 + interrupt1 = ldsr_interrupt.enabled1 &
19534 + ldsr_interrupt.mask1 & stat1;
19535 + ldsr_lock_release();
19536 +
19537 + /*
19538 + * For each interrupt in the "snapshot" we will mask the
19539 + * interrupt handle the interrupt (typically calling do_IRQ()).
19540 + *
19541 + * The interrupt is unmasked by desc->chip->end() function in
19542 + * the per chip generic interrupt handling code
19543 + * (arch/ubicom32/kernel/irq.c).8
19544 + */
19545 + interrupts = ((unsigned long long)interrupt1 << 32) |
19546 + interrupt0;
19547 + while (interrupts) {
19548 + int all = 0;
19549 + int vector = ldsr_rotate_interrupts(interrupts);
19550 + interrupts &= ~((unsigned long long)1 << vector);
19551 +
19552 + /*
19553 + * Now mask off this vector so that the LDSR ignores
19554 + * it until it is acknowledged.
19555 + */
19556 + ldsr_mask_vector(vector);
19557 +#if !defined(CONFIG_SMP)
19558 + ldsr_deliver_interrupt(vector, cpus, all);
19559 +#else
19560 + cpus = smp_get_affinity(vector, &all);
19561 + if (!cpus) {
19562 + /*
19563 + * No CPU to deliver to so just leave
19564 + * the interrupt unmasked and increase
19565 + * the backout count. We will eventually
19566 + * return and deliver it again.
19567 + */
19568 + ldsr_unmask_vector(vector);
19569 + ldsr_interrupt.backout++;
19570 + continue;
19571 + }
19572 + ldsr_deliver_interrupt(vector, cpus, all);
19573 +#endif
19574 + }
19575 + }
19576 +
19577 + /* NOTREACHED */
19578 +}
19579 +
19580 +/*
19581 + * ldsr_mask_vector()
19582 + * Temporarily mask the interrupt vector, turn off the bit in the mask
19583 + * register.
19584 + */
19585 +void ldsr_mask_vector(unsigned int vector)
19586 +{
19587 + unsigned int mask;
19588 + if (vector < 32) {
19589 + mask = ~(1 << vector);
19590 + ldsr_lock_acquire();
19591 + ldsr_interrupt.mask0 &= mask;
19592 + ldsr_lock_release();
19593 + thread_resume(ldsr_tid);
19594 + return;
19595 + }
19596 +
19597 + mask = ~(1 << (vector - 32));
19598 + ldsr_lock_acquire();
19599 + ldsr_interrupt.mask1 &= mask;
19600 + ldsr_lock_release();
19601 + thread_resume(ldsr_tid);
19602 +}
19603 +
19604 +/*
19605 + * ldsr_unmask_vector()
19606 + * Unmask the interrupt vector so that it can be used, turn on the bit in
19607 + * the mask register.
19608 + *
19609 + * Because it is legal for the interrupt path to disable an interrupt,
19610 + * the unmasking code must ensure that disabled interrupts are not
19611 + * unmasked.
19612 + */
19613 +void ldsr_unmask_vector(unsigned int vector)
19614 +{
19615 + unsigned int mask;
19616 + if (vector < 32) {
19617 + mask = (1 << vector);
19618 + ldsr_lock_acquire();
19619 + ldsr_interrupt.mask0 |= (mask & ldsr_interrupt.enabled0);
19620 + ldsr_lock_release();
19621 + thread_resume(ldsr_tid);
19622 + return;
19623 + }
19624 +
19625 + mask = (1 << (vector - 32));
19626 + ldsr_lock_acquire();
19627 + ldsr_interrupt.mask1 |= (mask & ldsr_interrupt.enabled1);
19628 + ldsr_lock_release();
19629 + thread_resume(ldsr_tid);
19630 +}
19631 +
19632 +/*
19633 + * ldsr_enable_vector()
19634 + * The LDSR implements an interrupt controller and has a local (to the
19635 + * LDSR) copy of its interrupt mask.
19636 + */
19637 +void ldsr_enable_vector(unsigned int vector)
19638 +{
19639 + unsigned int mask;
19640 + if (vector < 32) {
19641 + mask = (1 << vector);
19642 + ldsr_lock_acquire();
19643 + ldsr_interrupt.enabled0 |= mask;
19644 + ldsr_interrupt.mask0 |= mask;
19645 + ldsr_lock_release();
19646 + thread_resume(ldsr_tid);
19647 + return;
19648 + }
19649 +
19650 + mask = (1 << (vector - 32));
19651 + ldsr_lock_acquire();
19652 + ldsr_interrupt.enabled1 |= mask;
19653 + ldsr_interrupt.mask1 |= mask;
19654 + ldsr_lock_release();
19655 + thread_resume(ldsr_tid);
19656 +}
19657 +
19658 +/*
19659 + * ldsr_disable_vector()
19660 + * The LDSR implements an interrupt controller and has a local (to the
19661 + * LDSR) copy of its interrupt mask.
19662 + */
19663 +void ldsr_disable_vector(unsigned int vector)
19664 +{
19665 + unsigned int mask;
19666 +
19667 + if (vector < 32) {
19668 + mask = ~(1 << vector);
19669 + ldsr_lock_acquire();
19670 + ldsr_interrupt.enabled0 &= mask;
19671 + ldsr_interrupt.mask0 &= mask;
19672 + ldsr_lock_release();
19673 + thread_resume(ldsr_tid);
19674 + return;
19675 + }
19676 +
19677 + mask = ~(1 << (vector - 32));
19678 + ldsr_lock_acquire();
19679 + ldsr_interrupt.enabled1 &= mask;
19680 + ldsr_interrupt.mask1 &= mask;
19681 + ldsr_lock_release();
19682 + thread_resume(ldsr_tid);
19683 +}
19684 +
19685 +/*
19686 + * ldsr_get_threadid()
19687 + * Return the threadid of the LDSR thread.
19688 + */
19689 +thread_t ldsr_get_threadid(void)
19690 +{
19691 + return ldsr_tid;
19692 +}
19693 +
19694 +/*
19695 + * ldsr_set_trap_irq()
19696 + * Save away the trap Soft IRQ
19697 + *
19698 + * See the per thread lock suspend code above for an explination.
19699 + */
19700 +void ldsr_set_trap_irq(unsigned int irq)
19701 +{
19702 + ldsr_trap_irq = irq;
19703 + ldsr_trap_irq_mask = (1 << irq);
19704 + ldsr_suspend_mask |= ldsr_trap_irq_mask;
19705 +}
19706 +
19707 +/*
19708 + * ldsr_init()
19709 + * Initialize the LDSR (Interrupt Controller)
19710 + */
19711 +void ldsr_init(void)
19712 +{
19713 +#if defined(CONFIG_IRQSTACKS)
19714 + int i;
19715 + union irq_ctx *icp;
19716 +#endif
19717 +
19718 + void *stack_high = (void *)ldsr_stack_space;
19719 + stack_high += sizeof(ldsr_stack_space);
19720 + stack_high -= 8;
19721 +
19722 +
19723 + /*
19724 + * Obtain a soft IRQ to use
19725 + */
19726 + if (irq_soft_alloc(&ldsr_soft_irq) < 0) {
19727 + panic("no software IRQ is available\n");
19728 + return;
19729 + }
19730 + ldsr_soft_irq_mask |= (1 << ldsr_soft_irq);
19731 + ldsr_suspend_mask |= ldsr_soft_irq_mask;
19732 +
19733 + /*
19734 + * Now allocate and start the LDSR thread.
19735 + */
19736 + ldsr_tid = thread_alloc();
19737 + if (ldsr_tid < 0) {
19738 + panic("no thread available to run LDSR");
19739 + return;
19740 + }
19741 +
19742 +#if defined(CONFIG_IRQSTACKS)
19743 + /*
19744 + * Initialize the per-cpu irq thread_info structure that
19745 + * is at the top of each per-cpu irq stack.
19746 + */
19747 + icp = (union irq_ctx *)
19748 + (((unsigned long)percpu_irq_stacks + (THREAD_SIZE - 1)) & ~(THREAD_SIZE - 1));
19749 + for (i = 0; i < NR_CPUS; i++) {
19750 + struct thread_info *ti = &(icp->tinfo);
19751 + ti->task = NULL;
19752 + ti->exec_domain = NULL;
19753 + ti->cpu = i;
19754 + ti->preempt_count = 0;
19755 + ti->interrupt_nesting = 0;
19756 + percpu_irq_ctxs[i] = icp++;
19757 + }
19758 +#endif
19759 + thread_start(ldsr_tid, ldsr_thread, NULL,
19760 + stack_high, THREAD_TYPE_NORMAL);
19761 +}
19762 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/Makefile linux-2.6.30.10-ubi/arch/ubicom32/kernel/Makefile
19763 --- linux-2.6.30.10/arch/ubicom32/kernel/Makefile 1970-01-01 02:00:00.000000000 +0200
19764 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/Makefile 2009-12-11 11:45:11.000000000 +0200
19765 @@ -0,0 +1,64 @@
19766 +#
19767 +# arch/ubicom32/kernel/Makefile
19768 +# Main Makefile for the Ubicom32 arch directory.
19769 +#
19770 +# (C) Copyright 2009, Ubicom, Inc.
19771 +#
19772 +# This file is part of the Ubicom32 Linux Kernel Port.
19773 +#
19774 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
19775 +# it and/or modify it under the terms of the GNU General Public License
19776 +# as published by the Free Software Foundation, either version 2 of the
19777 +# License, or (at your option) any later version.
19778 +#
19779 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
19780 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
19781 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
19782 +# the GNU General Public License for more details.
19783 +#
19784 +# You should have received a copy of the GNU General Public License
19785 +# along with the Ubicom32 Linux Kernel Port. If not,
19786 +# see <http://www.gnu.org/licenses/>.
19787 +#
19788 +# Ubicom32 implementation derived from (with many thanks):
19789 +# arch/m68knommu
19790 +# arch/blackfin
19791 +# arch/parisc
19792 +#
19793 +
19794 +extra-y := head.o vmlinux.lds
19795 +
19796 +obj-y += \
19797 + devtree.o \
19798 + dma.o \
19799 + flat.o \
19800 + init_task.o \
19801 + irq.o \
19802 + ldsr.o \
19803 + os_node.o \
19804 + process.o \
19805 + processor.o \
19806 + ptrace.o \
19807 + setup.o \
19808 + signal.o \
19809 + stacktrace.o \
19810 + sys_ubicom32.o \
19811 + syscalltable.o \
19812 + thread.o \
19813 + time.o \
19814 + traps.o \
19815 + ubicom32_context_switch.o \
19816 + ubicom32_ksyms.o \
19817 + ubicom32_syscall.o \
19818 + unaligned_trap.o
19819 +
19820 +obj-$(CONFIG_MODULES) += module.o
19821 +obj-$(CONFIG_COMEMPCI) += comempci.o
19822 +obj-$(CONFIG_SMP) += smp.o topology.o
19823 +obj-$(CONFIG_ACCESS_OK_CHECKS_ENABLED) += uaccess.o
19824 +obj-$(CONFIG_GENERIC_CLOCKEVENTS) += timer_device.o
19825 +obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST) += timer_broadcast.o
19826 +
19827 +ifndef CONFIG_GENERIC_CLOCKEVENTS
19828 +obj-y += timer_tick.o
19829 +endif
19830 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/module.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/module.c
19831 --- linux-2.6.30.10/arch/ubicom32/kernel/module.c 1970-01-01 02:00:00.000000000 +0200
19832 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/module.c 2009-12-11 11:45:11.000000000 +0200
19833 @@ -0,0 +1,463 @@
19834 +/*
19835 + * arch/ubicom32/kernel/module.c
19836 + * Ubicom32 architecture loadable module support.
19837 + *
19838 + * (C) Copyright 2009, Ubicom, Inc.
19839 + *
19840 + * This file is part of the Ubicom32 Linux Kernel Port.
19841 + *
19842 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
19843 + * it and/or modify it under the terms of the GNU General Public License
19844 + * as published by the Free Software Foundation, either version 2 of the
19845 + * License, or (at your option) any later version.
19846 + *
19847 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
19848 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
19849 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
19850 + * the GNU General Public License for more details.
19851 + *
19852 + * You should have received a copy of the GNU General Public License
19853 + * along with the Ubicom32 Linux Kernel Port. If not,
19854 + * see <http://www.gnu.org/licenses/>.
19855 + *
19856 + * Ubicom32 implementation derived from (with many thanks):
19857 + * arch/m68knommu
19858 + * arch/blackfin
19859 + * arch/parisc
19860 + */
19861 +#include <linux/moduleloader.h>
19862 +#include <linux/bug.h>
19863 +#include <linux/elf.h>
19864 +#include <linux/vmalloc.h>
19865 +#include <linux/fs.h>
19866 +#include <linux/string.h>
19867 +#include <linux/kernel.h>
19868 +#include <asm/ocm-alloc.h>
19869 +
19870 +#if 0
19871 +#define DEBUGP printk
19872 +#else
19873 +#define DEBUGP(fmt...)
19874 +#endif
19875 +
19876 +static void _module_free_ocm(struct module *mod)
19877 +{
19878 + printk(KERN_INFO "module arch cleanup %s: OCM instruction memory free "
19879 + " of %d @%p\n", mod->name, mod->arch.ocm_inst_size,
19880 + mod->arch.ocm_inst);
19881 +
19882 + if (mod->arch.ocm_inst) {
19883 + ocm_inst_free(mod->arch.ocm_inst);
19884 + mod->arch.ocm_inst = 0;
19885 + mod->arch.ocm_inst_size = 0;
19886 + }
19887 +}
19888 +
19889 +void *module_alloc(unsigned long size)
19890 +{
19891 + if (size == 0)
19892 + return NULL;
19893 + return vmalloc(size);
19894 +}
19895 +
19896 +
19897 +/* Free memory returned from module_alloc */
19898 +void module_free(struct module *mod, void *module_region)
19899 +{
19900 + vfree(module_region);
19901 + /* FIXME: If module_region == mod->init_region, trim exception
19902 + table entries. */
19903 +
19904 + /*
19905 + * This is expected to be final module free, use this to prune the
19906 + * ocm
19907 + */
19908 + if (module_region && module_region == mod->module_core)
19909 + _module_free_ocm(mod);
19910 +
19911 +}
19912 +
19913 +/*
19914 + * module_frob_arch_sections()
19915 + * Called from kernel/module.c allowing arch specific handling of
19916 + * sections/headers.
19917 + */
19918 +int module_frob_arch_sections(Elf_Ehdr *hdr,
19919 + Elf_Shdr *sechdrs,
19920 + char *secstrings,
19921 + struct module *mod)
19922 +{
19923 + Elf_Shdr *s, *sechdrs_end;
19924 + void *ocm_inst = NULL;
19925 + int ocm_inst_size = 0;
19926 +
19927 + /*
19928 + * Ubicom32 v3 and v4 are almost binary compatible but not completely.
19929 + * To be safe check that the module was compiled with the correct -march
19930 + * which is flags.
19931 + */
19932 +#ifdef CONFIG_UBICOM32_V4
19933 + if ((hdr->e_flags & 0xFFFF) != EF_UBICOM32_V4) {
19934 + printk(KERN_WARNING "Module %s was not compiled for "
19935 + "ubicom32v4, elf_flags:%x,\n",
19936 + mod->name, hdr->e_flags);
19937 + return -ENOEXEC;
19938 + }
19939 +#elif defined CONFIG_UBICOM32_V3
19940 + if ((hdr->e_flags & 0xFFFF) != EF_UBICOM32_V3) {
19941 + printk(KERN_WARNING "Module %s was not compiled for "
19942 + "ubicom32v3, elf_flags:%x\n",
19943 + mod->name, hdr->e_flags);
19944 + return -ENOEXEC;
19945 + }
19946 +#else
19947 +#error Unknown/Unsupported ubicom32 architecture.
19948 +#endif
19949 +
19950 + /*
19951 + * XXX: sechdrs are vmalloced in kernel/module.c
19952 + * and would be vfreed just after module is loaded,
19953 + * so we hack to keep the only information we needed
19954 + * in mod->arch to correctly free L1 I/D sram later.
19955 + * NOTE: this breaks the semantic of mod->arch structure.
19956 + */
19957 + sechdrs_end = sechdrs + hdr->e_shnum;
19958 + for (s = sechdrs; s < sechdrs_end; ++s) {
19959 + if (strncmp(".ocm_text", secstrings + s->sh_name, 9) == 0)
19960 + ocm_inst_size += s->sh_size;
19961 + }
19962 +
19963 + if (!ocm_inst_size)
19964 + return 0;
19965 +
19966 + ocm_inst = ocm_inst_alloc(ocm_inst_size, 0 /* internal */);
19967 + if (ocm_inst == NULL) {
19968 +#ifdef CONFIG_OCM_MODULES_FALLBACK_TO_DDR
19969 + printk(KERN_WARNING
19970 + "module %s: OCM instruction memory allocation of %d"
19971 + "failed, fallback to DDR\n", mod->name, ocm_inst_size);
19972 + return 0;
19973 +#else
19974 + printk(KERN_ERR
19975 + "module %s: OCM instruction memory allocation of %d"
19976 + "failed.\n", mod->name, ocm_inst_size);
19977 + return -ENOMEM;
19978 +#endif
19979 + }
19980 +
19981 + mod->arch.ocm_inst = ocm_inst;
19982 + mod->arch.ocm_inst_size = ocm_inst_size;
19983 +
19984 + printk(KERN_INFO
19985 + "module %s: OCM instruction memory allocation of %d @%p\n",
19986 + mod->name, mod->arch.ocm_inst_size, mod->arch.ocm_inst);
19987 +
19988 + for (s = sechdrs; s < sechdrs_end; ++s) {
19989 + if (strncmp(".ocm_text", secstrings + s->sh_name, 9) == 0) {
19990 + memcpy(ocm_inst, (void *)s->sh_addr, s->sh_size);
19991 + s->sh_flags &= ~SHF_ALLOC;
19992 + s->sh_addr = (unsigned long)ocm_inst;
19993 + ocm_inst += s->sh_size;
19994 + }
19995 + }
19996 +
19997 + return 0;
19998 +}
19999 +
20000 +int apply_relocate(Elf32_Shdr *sechdrs,
20001 + const char *strtab,
20002 + unsigned int symindex,
20003 + unsigned int relsec,
20004 + struct module *me)
20005 +{
20006 + DEBUGP("Invalid Applying relocate section %u to %u\n", relsec,
20007 + sechdrs[relsec].sh_info);
20008 + return -EINVAL;
20009 +}
20010 +
20011 +int apply_relocate_add(Elf32_Shdr *sechdrs,
20012 + const char *strtab,
20013 + unsigned int symindex,
20014 + unsigned int relsec,
20015 + struct module *me)
20016 +{
20017 + unsigned int i;
20018 + Elf32_Rela *rel = (void *)sechdrs[relsec].sh_addr;
20019 + Elf32_Sym *sym;
20020 + uint32_t *location;
20021 + uint32_t insn;
20022 +
20023 + DEBUGP("Applying relocate_add section %u to %u\n", relsec,
20024 + sechdrs[relsec].sh_info);
20025 + for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
20026 + uint32_t v;
20027 + const int elf32_rtype = ELF32_R_TYPE(rel[i].r_info);
20028 +
20029 + /* This is where to make the change */
20030 + location = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
20031 + + rel[i].r_offset;
20032 + /* This is the symbol it is referring to. Note that all
20033 + undefined symbols have been resolved. */
20034 + sym = (Elf32_Sym *)sechdrs[symindex].sh_addr
20035 + + ELF32_R_SYM(rel[i].r_info);
20036 +
20037 + v = rel[i].r_addend + sym->st_value;
20038 +
20039 +
20040 + switch (elf32_rtype) {
20041 + case R_UBICOM32_32:
20042 + {
20043 + /*
20044 + * Store the 32 bit relocation as is.
20045 + */
20046 + *location = v;
20047 + break;
20048 + }
20049 + case R_UBICOM32_HI24:
20050 + {
20051 + /*
20052 + * 24 bit relocation that is part of the MOVEAI
20053 + * instruction. The 24 bits come from bits 7 - 30 of the
20054 + * relocation. Theses bits eventually get split into 2
20055 + * fields in the instruction encoding.
20056 + *
20057 + * - Bits 7 - 27 of the relocation are encoded into bits
20058 + * 0 - 20 of the instruction.
20059 + *
20060 + * - Bits 28 - 30 of the relocation are encoded into
20061 + * bit 24 - 26 of the instruction.
20062 + */
20063 + uint32_t valid24 = (v >> 7) & 0xffffff;
20064 + insn = *location;
20065 +
20066 + insn &= ~(0x1fffff | (0x7 << 24));
20067 + insn |= (valid24 & 0x1fffff);
20068 + insn |= ((valid24 & 0xe00000) << 3);
20069 + *location = insn;
20070 + }
20071 + break;
20072 + case R_UBICOM32_LO7_S:
20073 + case R_UBICOM32_LO7_2_S:
20074 + case R_UBICOM32_LO7_4_S:
20075 + {
20076 + /*
20077 + * Bits 0 - 6 of the relocation are encoded into the
20078 + * 7bit unsigned immediate fields of the SOURCE-1 field
20079 + * of the instruction. The immediate value is left
20080 + * shifted by (0, 1, 2) based on the operand size.
20081 + */
20082 + uint32_t valid7 = v & 0x7f;
20083 + insn = *location;
20084 +
20085 + if (elf32_rtype == R_UBICOM32_LO7_2_S) {
20086 + valid7 >>= 1;
20087 + } else if (elf32_rtype == R_UBICOM32_LO7_4_S) {
20088 + valid7 >>= 2;
20089 + }
20090 +
20091 + insn &= ~(0x1f | (0x3 << 8));
20092 + insn |= (valid7 & 0x1f);
20093 + insn |= ((valid7 & 0x60) << 3);
20094 + *location = insn;
20095 + }
20096 + break;
20097 + case R_UBICOM32_LO7_D:
20098 + case R_UBICOM32_LO7_2_D:
20099 + case R_UBICOM32_LO7_4_D:
20100 + {
20101 + /*
20102 + * Bits 0 - 6 of the relocation are encoded into the
20103 + * 7bit unsigned immediate fields of the DESTINATION
20104 + * field of the instruction. The immediate value is
20105 + * left shifted by (0, 1, 2) based on the operand size.
20106 + */
20107 + uint32_t valid7 = v & 0x7f;
20108 + insn = *location;
20109 +
20110 + if (elf32_rtype == R_UBICOM32_LO7_2_D) {
20111 + valid7 >>= 1;
20112 + } else if (elf32_rtype == R_UBICOM32_LO7_4_D) {
20113 + valid7 >>= 2;
20114 + }
20115 +
20116 + insn &= ~((0x1f | (0x3 << 8)) << 16);
20117 + insn |= ((valid7 & 0x1f) << 16);
20118 + insn |= ((valid7 & 0x60) << 19);
20119 + *location = insn;
20120 + }
20121 + break;
20122 + case R_UBICOM32_LO7_CALLI:
20123 + case R_UBICOM32_LO16_CALLI:
20124 + {
20125 + /*
20126 + * Extract the offset for a CALLI instruction. The
20127 + * offsets can be either 7 bits or 18 bits. Since all
20128 + * instructions in ubicom32 architecture are at work
20129 + * aligned addresses the truncated offset is right
20130 + * shifted by 2 before being encoded in the instruction.
20131 + */
20132 + uint32_t val;
20133 + if (elf32_rtype == R_UBICOM32_LO7_CALLI) {
20134 + val = v & 0x7f;
20135 + } else {
20136 + val = v & 0x3ffff;
20137 + }
20138 +
20139 + val >>= 2;
20140 +
20141 + insn = *location;
20142 +
20143 + insn &= ~0x071f071f;
20144 + insn |= (val & 0x1f) << 0;
20145 + val >>= 5;
20146 + insn |= (val & 0x07) << 8;
20147 + val >>= 3;
20148 + insn |= (val & 0x1f) << 16;
20149 + val >>= 5;
20150 + insn |= (val & 0x07) << 24;
20151 + *location = insn;
20152 + }
20153 + break;
20154 + case R_UBICOM32_24_PCREL:
20155 + {
20156 + /*
20157 + * Extract 26 bit signed PC relative offset for CALL
20158 + * instructions. Since instruction addresses are word
20159 + * aligned the offset is right shited by 2 before
20160 + * encoding into instruction.
20161 + */
20162 + int32_t val = v - (int32_t)location;
20163 +
20164 + /*
20165 + * Check that the top 7 bits are all equal to the sign
20166 + * bit (26), i.e all 0's or all 1's. If they are not then
20167 + * the absolute difference is greater than 25 bits.
20168 + */
20169 + if (((uint32_t)val & 0xFE000000) != 0xFE000000 &&
20170 + ((uint32_t)val & 0xFE000000) != 0x0) {
20171 + /*
20172 + * The relocation is beyond our addressable
20173 + * range with a 26 bit call.
20174 + */
20175 + printk(KERN_ERR "module %s: PC Relative "
20176 + "relocation out of range: "
20177 + "%u (%x->%x, %x)\n",
20178 + me->name, elf32_rtype,
20179 + v, (uint32_t) location, val);
20180 + return -ENOEXEC;
20181 + }
20182 +
20183 + val = (val & 0x3ffffff) >> 2;
20184 + insn = *location;
20185 + insn = insn & 0xf8e00000;
20186 +
20187 + insn |= (val >> 21) << 24;
20188 + insn |= (val & 0x1fffff);
20189 + *location = insn;
20190 + }
20191 + break;
20192 + case R_UBICOM32_LO16:
20193 + case R_UBICOM32_HI16:
20194 + {
20195 + /*
20196 + * 16 bit immediate value that is encoded into bit 0 -
20197 + * 15 of the instruction.
20198 + */
20199 + uint32_t val;
20200 +
20201 + if (elf32_rtype == R_UBICOM32_LO16) {
20202 + val = v & 0xffff;
20203 + } else {
20204 + val = (v >> 16) & 0xffff;
20205 + }
20206 +
20207 + insn = *location;
20208 + insn &= 0xffff0000;
20209 +
20210 + insn |= val;
20211 + *location = insn;
20212 + }
20213 + break;
20214 + case R_UBICOM32_21_PCREL:
20215 + {
20216 + /*
20217 + * Extract 23 bit signed PC relative offset for JMP<cc>
20218 + * instructions. Since instruction addresses are word
20219 + * aligned the offset is right shited by 2 before
20220 + * encoding into instruction.
20221 + */
20222 + int32_t val = v - (int32_t)location;
20223 +
20224 + val = (val & 0x7fffff) >> 2;
20225 + insn = *location;
20226 + insn = insn & 0xffe00000;
20227 +
20228 + insn |= (val >> 21) << 24;
20229 + insn |= val;
20230 + *location = insn;
20231 + }
20232 + break;
20233 + default:
20234 + BUG();
20235 + printk(KERN_ERR "module %s: Unknown relocation: %u\n",
20236 + me->name, elf32_rtype);
20237 + return -ENOEXEC;
20238 + }
20239 + }
20240 + return 0;
20241 +}
20242 +
20243 +int module_finalize(const Elf_Ehdr *hdr,
20244 + const Elf_Shdr *sechdrs,
20245 + struct module *mod)
20246 +{
20247 + unsigned int i, strindex = 0, symindex = 0;
20248 + char *secstrings;
20249 + int err;
20250 +
20251 + err = module_bug_finalize(hdr, sechdrs, mod);
20252 + if (err)
20253 + return err;
20254 +
20255 + if (!mod->arch.ocm_inst) {
20256 + /*
20257 + * No OCM code, so nothing more to do.
20258 + */
20259 + return 0;
20260 + }
20261 +
20262 + secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
20263 +
20264 + for (i = 1; i < hdr->e_shnum; i++) {
20265 + /* Internal symbols and strings. */
20266 + if (sechdrs[i].sh_type == SHT_SYMTAB) {
20267 + symindex = i;
20268 + strindex = sechdrs[i].sh_link;
20269 + }
20270 + }
20271 +
20272 + for (i = 1; i < hdr->e_shnum; i++) {
20273 + const char *strtab = (char *)sechdrs[strindex].sh_addr;
20274 + unsigned int info = sechdrs[i].sh_info;
20275 +
20276 + /* Not a valid relocation section? */
20277 + if (info >= hdr->e_shnum)
20278 + continue;
20279 +
20280 + if ((sechdrs[i].sh_type == SHT_RELA) &&
20281 + (strncmp(".rela.ocm_text",
20282 + secstrings + sechdrs[i].sh_name, 5 + 9) == 0)) {
20283 + err = apply_relocate_add((Elf_Shdr *) sechdrs, strtab,
20284 + symindex, i, mod);
20285 + if (err)
20286 + return err;
20287 + }
20288 + }
20289 +
20290 + return 0;
20291 +}
20292 +
20293 +void module_arch_cleanup(struct module *mod)
20294 +{
20295 + module_bug_cleanup(mod);
20296 +}
20297 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/os_node.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/os_node.c
20298 --- linux-2.6.30.10/arch/ubicom32/kernel/os_node.c 1970-01-01 02:00:00.000000000 +0200
20299 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/os_node.c 2009-12-11 11:45:11.000000000 +0200
20300 @@ -0,0 +1,88 @@
20301 +/*
20302 + * arch/ubicom32/kernel/os_node.c
20303 + * <TODO: Replace with short file description>
20304 + *
20305 + * (C) Copyright 2009, Ubicom, Inc.
20306 + *
20307 + * This file is part of the Ubicom32 Linux Kernel Port.
20308 + *
20309 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
20310 + * it and/or modify it under the terms of the GNU General Public License
20311 + * as published by the Free Software Foundation, either version 2 of the
20312 + * License, or (at your option) any later version.
20313 + *
20314 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
20315 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
20316 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
20317 + * the GNU General Public License for more details.
20318 + *
20319 + * You should have received a copy of the GNU General Public License
20320 + * along with the Ubicom32 Linux Kernel Port. If not,
20321 + * see <http://www.gnu.org/licenses/>.
20322 + *
20323 + */
20324 +#include "linux/types.h"
20325 +#include "linux/linkage.h"
20326 +#include "linux/uts.h"
20327 +#include "linux/utsrelease.h"
20328 +#include "linux/version.h"
20329 +#include <asm/ocm_size.h>
20330 +#include <asm/devtree.h>
20331 +#include <asm/ip5000.h>
20332 +
20333 +extern asmlinkage void *_start;
20334 +
20335 +/*
20336 + * This file provides static information to the boot code allowing it to decide
20337 + * if the os is compatible. Thus hopefully enabling the boot code to prevent
20338 + * accidentally booting a kernel that has no hope of running.
20339 + */
20340 +struct os_node {
20341 + struct devtree_node node;
20342 + unsigned long version; /* Always 1 */
20343 + unsigned long entry_point;
20344 + const char os_name[32]; /* For diagnostic purposes only */
20345 + const char os_version_str[32];
20346 + unsigned long os_version_num;
20347 + unsigned long expected_ocm_code_start;/* OS Code */
20348 + unsigned long expected_ocm_data_end; /* OS Data */
20349 + unsigned long expected_ram_start;
20350 + unsigned long expected_ram_end;
20351 + unsigned long arch_version;
20352 + unsigned long expected_os_syscall_begin;
20353 + unsigned long expected_os_syscall_end;
20354 +};
20355 +
20356 +
20357 +extern void __os_syscall_begin;
20358 +extern void __os_syscall_end;
20359 +/*
20360 + * The os_node is only referenced by head.S and should never be modified at
20361 + * run-time.
20362 + */
20363 +asmlinkage const struct os_node _os_node = {
20364 + .node = {
20365 + .next = NULL,
20366 + .name = { "OS" },
20367 + .magic = 0x10203040,
20368 + },
20369 + .version = 0x10002,
20370 + .entry_point = (unsigned long)&_start,
20371 +#if APP_OCM_CODE_SIZE || APP_OCM_DATA_SIZE
20372 + .expected_ocm_code_start = OCMSTART + APP_OCM_CODE_SIZE,
20373 + .expected_ocm_data_end = OCMEND - APP_OCM_DATA_SIZE,
20374 +#else
20375 + .expected_ocm_code_start = OCMEND,
20376 + .expected_ocm_data_end = OCMEND,
20377 +#endif
20378 + .os_name = { UTS_SYSNAME },
20379 + .os_version_str = { UTS_RELEASE },
20380 + .os_version_num = LINUX_VERSION_CODE,
20381 + .expected_ram_start = KERNELSTART,
20382 + .expected_ram_end = SDRAMSTART + CONFIG_MIN_RAMSIZE,
20383 + .arch_version = UBICOM32_ARCH_VERSION,
20384 + .expected_os_syscall_begin = (unsigned long)&__os_syscall_begin,
20385 + .expected_os_syscall_end = (unsigned long)&__os_syscall_end,
20386 +
20387 +
20388 +};
20389 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/process.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/process.c
20390 --- linux-2.6.30.10/arch/ubicom32/kernel/process.c 1970-01-01 02:00:00.000000000 +0200
20391 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/process.c 2009-12-11 11:45:11.000000000 +0200
20392 @@ -0,0 +1,634 @@
20393 +/*
20394 + * arch/ubicom32/kernel/process.c
20395 + * Ubicom32 architecture-dependent process handling.
20396 + *
20397 + * (C) Copyright 2009, Ubicom, Inc.
20398 + * Copyright (C) 1995 Hamish Macdonald
20399 + *
20400 + * 68060 fixes by Jesper Skov
20401 + *
20402 + * uClinux changes
20403 + * Copyright (C) 2000-2002, David McCullough <davidm@snapgear.com>
20404 + *
20405 + * This file is part of the Ubicom32 Linux Kernel Port.
20406 + *
20407 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
20408 + * it and/or modify it under the terms of the GNU General Public License
20409 + * as published by the Free Software Foundation, either version 2 of the
20410 + * License, or (at your option) any later version.
20411 + *
20412 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
20413 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
20414 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
20415 + * the GNU General Public License for more details.
20416 + *
20417 + * You should have received a copy of the GNU General Public License
20418 + * along with the Ubicom32 Linux Kernel Port. If not,
20419 + * see <http://www.gnu.org/licenses/>.
20420 + *
20421 + * Ubicom32 implementation derived from (with many thanks):
20422 + * arch/m68knommu
20423 + * arch/blackfin
20424 + * arch/parisc
20425 + */
20426 +
20427 +/*
20428 + * This file handles the architecture-dependent parts of process handling..
20429 + */
20430 +
20431 +#include <linux/module.h>
20432 +#include <linux/errno.h>
20433 +#include <linux/sched.h>
20434 +#include <linux/kernel.h>
20435 +#include <linux/mm.h>
20436 +#include <linux/smp.h>
20437 +#include <linux/smp_lock.h>
20438 +#include <linux/stddef.h>
20439 +#include <linux/unistd.h>
20440 +#include <linux/ptrace.h>
20441 +#include <linux/slab.h>
20442 +#include <linux/user.h>
20443 +#include <linux/a.out.h>
20444 +#include <linux/interrupt.h>
20445 +#include <linux/reboot.h>
20446 +#include <linux/fs.h>
20447 +#include <linux/pm.h>
20448 +
20449 +#include <linux/uaccess.h>
20450 +#include <asm/system.h>
20451 +#include <asm/traps.h>
20452 +#include <asm/machdep.h>
20453 +#include <asm/setup.h>
20454 +#include <asm/pgtable.h>
20455 +#include <asm/ip5000.h>
20456 +#include <asm/range-protect.h>
20457 +
20458 +#define DUMP_RANGE_REGISTER(REG, IDX) asm volatile ( \
20459 + " move.4 %0, "REG"_RANGE"IDX"_EN \n\t" \
20460 + " move.4 %1, "REG"_RANGE"IDX"_LO \n\t" \
20461 + " move.4 %2, "REG"_RANGE"IDX"_HI \n\t" \
20462 + : "=d"(en), "=d"(lo), "=d"(hi) \
20463 + ); \
20464 + printk(KERN_NOTICE REG"Range"IDX": en:%08x, range: %08x-%08x\n", \
20465 + (unsigned int)en, \
20466 + (unsigned int)lo, \
20467 + (unsigned int)hi)
20468 +
20469 +asmlinkage void ret_from_fork(void);
20470 +
20471 +void (*pm_power_off)(void) = machine_power_off;
20472 +EXPORT_SYMBOL(pm_power_off);
20473 +
20474 +/* machine-dependent / hardware-specific power functions */
20475 +void (*mach_reset)(void);
20476 +void (*mach_halt)(void);
20477 +void (*mach_power_off)(void);
20478 +
20479 +/*
20480 + * cpu_idle()
20481 + * The idle thread.
20482 + *
20483 + * Our idle loop suspends and is woken up by a timer interrupt.
20484 + */
20485 +void cpu_idle(void)
20486 +{
20487 + while (1) {
20488 + local_irq_disable();
20489 + while (!need_resched()) {
20490 + local_irq_enable();
20491 + thread_suspend();
20492 + local_irq_disable();
20493 + }
20494 + local_irq_enable();
20495 + preempt_enable_no_resched();
20496 + schedule();
20497 + preempt_disable();
20498 + }
20499 +}
20500 +
20501 +/*
20502 + * dump_fpu()
20503 + *
20504 + * Fill in the fpu structure for a core dump. (just a stub as we don't have
20505 + * an fpu)
20506 + */
20507 +int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpregs)
20508 +{
20509 + return 1;
20510 +}
20511 +
20512 +/*
20513 + * machine_restart()
20514 + * Resets the system.
20515 + */
20516 +void machine_restart(char *__unused)
20517 +{
20518 + /*
20519 + * Disable all threads except myself. We can do this
20520 + * directly without needing to call smp_send_stop
20521 + * because we have a unique architecture where
20522 + * one thread can disable one or more other threads.
20523 + */
20524 + thread_disable_others();
20525 +
20526 + /*
20527 + * Call the hardware-specific machine reset function.
20528 + */
20529 + if (mach_reset) {
20530 + mach_reset();
20531 + }
20532 +
20533 + printk(KERN_EMERG "System Restarting\n");
20534 +
20535 + /*
20536 + * Set watchdog to trigger (after 1ms delay) (12 Mhz is the fixed OSC)
20537 + */
20538 + UBICOM32_IO_TIMER->tkey = TIMER_TKEYVAL;
20539 + UBICOM32_IO_TIMER->wdcom = UBICOM32_IO_TIMER->mptval +
20540 + (12000000 / 1000);
20541 + UBICOM32_IO_TIMER->wdcfg = 0;
20542 + UBICOM32_IO_TIMER->tkey = 0;
20543 +
20544 + /*
20545 + * Wait for watchdog
20546 + */
20547 + asm volatile (
20548 + " move.4 MT_EN, #0 \n\t"
20549 + " pipe_flush 0 \n\t"
20550 + );
20551 +
20552 + local_irq_disable();
20553 + for (;;) {
20554 + thread_suspend();
20555 + }
20556 +}
20557 +
20558 +/*
20559 + * machine_halt()
20560 + * Halt the machine.
20561 + *
20562 + * Similar to machine_power_off, but don't shut off power. Add code
20563 + * here to freeze the system for e.g. post-mortem debug purpose when
20564 + * possible. This halt has nothing to do with the idle halt.
20565 + */
20566 +void machine_halt(void)
20567 +{
20568 + /*
20569 + * Disable all threads except myself. We can do this
20570 + * directly without needing to call smp_send_stop
20571 + * because we have a unique architecture where
20572 + * one thread can disable one or more other threads.
20573 + */
20574 + thread_disable_others();
20575 +
20576 + /*
20577 + * Call the hardware-specific machine halt function.
20578 + */
20579 + if (mach_halt) {
20580 + mach_halt();
20581 + }
20582 +
20583 + printk(KERN_EMERG "System Halted, OK to turn off power\n");
20584 + local_irq_disable();
20585 + for (;;) {
20586 + thread_suspend();
20587 + }
20588 +}
20589 +
20590 +/*
20591 + * machine_power_off()
20592 + * Turn the power off, if a power off handler is defined, otherwise, spin
20593 + * endlessly.
20594 + */
20595 +void machine_power_off(void)
20596 +{
20597 + /*
20598 + * Disable all threads except myself. We can do this
20599 + * directly without needing to call smp_send_stop
20600 + * because we have a unique architecture where
20601 + * one thread can disable one or more other threads.
20602 + */
20603 + thread_disable_others();
20604 +
20605 + /*
20606 + * Call the hardware-specific machine power off function.
20607 + */
20608 + if (mach_power_off) {
20609 + mach_power_off();
20610 + }
20611 +
20612 + printk(KERN_EMERG "System Halted, OK to turn off power\n");
20613 + local_irq_disable();
20614 + for (;;) {
20615 + thread_suspend();
20616 + }
20617 +}
20618 +
20619 +/*
20620 + * address_is_valid()
20621 + * check if an address is valid -- (for read access)
20622 + */
20623 +static bool address_is_valid(const void *address)
20624 +{
20625 + int addr = (int)address;
20626 + unsigned long socm, eocm, sdram, edram;
20627 +
20628 + if (addr & 3)
20629 + return false;
20630 +
20631 + processor_ocm(&socm, &eocm);
20632 + processor_dram(&sdram, &edram);
20633 + if (addr >= socm && addr < eocm)
20634 + return true;
20635 +
20636 + if (addr >= sdram && addr < edram)
20637 + return true;
20638 +
20639 + return false;
20640 +}
20641 +
20642 +/*
20643 + * vma_path_name_is_valid()
20644 + * check if path_name of a vma is a valid string
20645 + */
20646 +static bool vma_path_name_is_valid(const char *str)
20647 +{
20648 +#define MAX_NAME_LEN 256
20649 + int i = 0;
20650 + if (!address_is_valid(str))
20651 + return false;
20652 +
20653 + for (; i < MAX_NAME_LEN; i++, str++) {
20654 + if (*str == '\0')
20655 + return true;
20656 + }
20657 +
20658 + return false;
20659 +}
20660 +
20661 +/*
20662 + * show_vmas()
20663 + * show vma info of a process
20664 + */
20665 +void show_vmas(struct task_struct *task)
20666 +{
20667 +#ifdef CONFIG_DEBUG_VERBOSE
20668 +#define UBICOM32_MAX_VMA_COUNT 1024
20669 +
20670 + struct vm_area_struct *vma;
20671 + struct file *file;
20672 + char *name = "";
20673 + int flags, loop = 0;
20674 +
20675 + printk(KERN_NOTICE "Start of vma list\n");
20676 +
20677 + if (!address_is_valid(task) || !address_is_valid(task->mm))
20678 + goto error;
20679 +
20680 + vma = task->mm->mmap;
20681 + while (vma) {
20682 + if (!address_is_valid(vma))
20683 + goto error;
20684 +
20685 + flags = vma->vm_flags;
20686 + file = vma->vm_file;
20687 +
20688 + if (file) {
20689 + /* seems better to use dentry op here, but sanity check is easier this way */
20690 + if (!address_is_valid(file) || !address_is_valid(file->f_path.dentry) || !vma_path_name_is_valid(file->f_path.dentry->d_name.name))
20691 + goto error;
20692 +
20693 + name = (char *)file->f_path.dentry->d_name.name;
20694 + }
20695 +
20696 + /* Similar to /proc/pid/maps format */
20697 + printk(KERN_NOTICE "%08lx-%08lx %c%c%c%c %08lx %s\n",
20698 + vma->vm_start,
20699 + vma->vm_end,
20700 + flags & VM_READ ? 'r' : '-',
20701 + flags & VM_WRITE ? 'w' : '-',
20702 + flags & VM_EXEC ? 'x' : '-',
20703 + flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p',
20704 + vma->vm_pgoff << PAGE_SHIFT,
20705 + name);
20706 +
20707 + vma = vma->vm_next;
20708 +
20709 + if (loop++ > UBICOM32_MAX_VMA_COUNT)
20710 + goto error;
20711 + }
20712 +
20713 + printk(KERN_NOTICE "End of vma list\n");
20714 + return;
20715 +
20716 +error:
20717 + printk(KERN_NOTICE "\nCorrupted vma list, abort!\n");
20718 +#endif
20719 +}
20720 +
20721 +/*
20722 + * show_regs()
20723 + * Print out all of the registers.
20724 + */
20725 +void show_regs(struct pt_regs *regs)
20726 +{
20727 + unsigned int i;
20728 + unsigned int en, lo, hi;
20729 +
20730 + printk(KERN_NOTICE "regs: %p, tid: %d\n",
20731 + (void *)regs,
20732 + thread_get_self());
20733 +
20734 + printk(KERN_NOTICE "pc: %08x, previous_pc: %08x\n\n",
20735 + (unsigned int)regs->pc,
20736 + (unsigned int)regs->previous_pc);
20737 +
20738 + printk(KERN_NOTICE "Data registers\n");
20739 + for (i = 0; i < 16; i++) {
20740 + printk("D%02d: %08x, ", i, (unsigned int)regs->dn[i]);
20741 + if ((i % 4) == 3) {
20742 + printk("\n");
20743 + }
20744 + }
20745 + printk("\n");
20746 +
20747 + printk(KERN_NOTICE "Address registers\n");
20748 + for (i = 0; i < 8; i++) {
20749 + printk("A%02d: %08x, ", i, (unsigned int)regs->an[i]);
20750 + if ((i % 4) == 3) {
20751 + printk("\n");
20752 + }
20753 + }
20754 + printk("\n");
20755 +
20756 + printk(KERN_NOTICE "acc0: %08x-%08x, acc1: %08x-%08x\n",
20757 + (unsigned int)regs->acc0[1],
20758 + (unsigned int)regs->acc0[0],
20759 + (unsigned int)regs->acc1[1],
20760 + (unsigned int)regs->acc1[0]);
20761 +
20762 + printk(KERN_NOTICE "mac_rc16: %08x, source3: %08x\n",
20763 + (unsigned int)regs->mac_rc16,
20764 + (unsigned int)regs->source3);
20765 +
20766 + printk(KERN_NOTICE "inst_cnt: %08x, csr: %08x\n",
20767 + (unsigned int)regs->inst_cnt,
20768 + (unsigned int)regs->csr);
20769 +
20770 + printk(KERN_NOTICE "int_mask0: %08x, int_mask1: %08x\n",
20771 + (unsigned int)regs->int_mask0,
20772 + (unsigned int)regs->int_mask1);
20773 +
20774 + /*
20775 + * Dump range registers
20776 + */
20777 + DUMP_RANGE_REGISTER("I", "0");
20778 + DUMP_RANGE_REGISTER("I", "1");
20779 + DUMP_RANGE_REGISTER("I", "2");
20780 + DUMP_RANGE_REGISTER("I", "3");
20781 + DUMP_RANGE_REGISTER("D", "0");
20782 + DUMP_RANGE_REGISTER("D", "1");
20783 + DUMP_RANGE_REGISTER("D", "2");
20784 + DUMP_RANGE_REGISTER("D", "3");
20785 + DUMP_RANGE_REGISTER("D", "4");
20786 +
20787 + printk(KERN_NOTICE "frame_type: %d, nesting_level: %d, thread_type %d\n\n",
20788 + (int)regs->frame_type,
20789 + (int)regs->nesting_level,
20790 + (int)regs->thread_type);
20791 +}
20792 +
20793 +/*
20794 + * kernel_thread_helper()
20795 + * On execution d0 will be 0, d1 will be the argument to be passed to the
20796 + * kernel function. d2 contains the kernel function that needs to get
20797 + * called. d3 will contain address to do_exit which need to get moved
20798 + * into a5. On return from fork the child thread d0 will be 0. We call
20799 + * this dummy function which in turn loads the argument
20800 + */
20801 +asmlinkage void kernel_thread_helper(void);
20802 +
20803 +/*
20804 + * kernel_thread()
20805 + * Create a kernel thread
20806 + */
20807 +int kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
20808 +{
20809 + struct pt_regs regs;
20810 +
20811 + memset(&regs, 0, sizeof(regs));
20812 +
20813 + regs.dn[1] = (unsigned long)arg;
20814 + regs.dn[2] = (unsigned long)fn;
20815 + regs.dn[3] = (unsigned long)do_exit;
20816 + regs.an[5] = (unsigned long)kernel_thread_helper;
20817 + regs.pc = (unsigned long)kernel_thread_helper;
20818 + regs.nesting_level = 0;
20819 + regs.thread_type = KERNEL_THREAD;
20820 +
20821 + return do_fork(flags | CLONE_VM | CLONE_UNTRACED,
20822 + 0, &regs, 0, NULL, NULL);
20823 +}
20824 +EXPORT_SYMBOL(kernel_thread);
20825 +
20826 +/*
20827 + * flush_thread()
20828 + * XXX todo
20829 + */
20830 +void flush_thread(void)
20831 +{
20832 + /* XXX todo */
20833 +}
20834 +
20835 +/*
20836 + * sys_fork()
20837 + * Not implemented on no-mmu.
20838 + */
20839 +asmlinkage int sys_fork(struct pt_regs *regs)
20840 +{
20841 + /* fork almost works, enough to trick you into looking elsewhere :-( */
20842 + return -EINVAL;
20843 +}
20844 +
20845 +/*
20846 + * sys_vfork()
20847 + * By the time we get here, the non-volatile registers have also been saved
20848 + * on the stack. We do some ugly pointer stuff here.. (see also copy_thread
20849 + * which does context copy).
20850 + */
20851 +asmlinkage int sys_vfork(struct pt_regs *regs)
20852 +{
20853 + unsigned long old_sp = regs->an[7];
20854 + unsigned long old_a5 = regs->an[5];
20855 + unsigned long old_return_address;
20856 + long do_fork_return;
20857 +
20858 + /*
20859 + * Read the old retrun address from the stack.
20860 + */
20861 + if (copy_from_user(&old_return_address,
20862 + (void *)old_sp, sizeof(unsigned long))) {
20863 + force_sig(SIGSEGV, current);
20864 + return 0;
20865 + }
20866 +
20867 + /*
20868 + * Pop the vfork call frame by setting a5 and pc to the old_return
20869 + * address and incrementing the stack pointer by 4.
20870 + */
20871 + regs->an[5] = old_return_address;
20872 + regs->pc = old_return_address;
20873 + regs->an[7] += 4;
20874 +
20875 + do_fork_return = do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD,
20876 + regs->an[7], regs, 0, NULL, NULL);
20877 +
20878 + /*
20879 + * Now we have to test if the return code is an error. If it is an error
20880 + * then restore the frame and we will execute error processing in user
20881 + * space. Other wise the child and the parent will return to the correct
20882 + * places.
20883 + */
20884 + if ((unsigned long)(do_fork_return) >= (unsigned long)(-125)) {
20885 + /*
20886 + * Error case. We need to restore the frame.
20887 + */
20888 + regs->an[5] = old_a5;
20889 + regs->pc = old_a5;
20890 + regs->an[7] = old_sp;
20891 + }
20892 +
20893 + return do_fork_return;
20894 +}
20895 +
20896 +/*
20897 + * sys_clone()
20898 + * creates a child thread.
20899 + */
20900 +asmlinkage int sys_clone(unsigned long clone_flags,
20901 + unsigned long newsp,
20902 + struct pt_regs *regs)
20903 +{
20904 + if (!newsp)
20905 + newsp = regs->an[7];
20906 + return do_fork(clone_flags, newsp, regs, 0,
20907 + NULL, NULL);
20908 +}
20909 +
20910 +/*
20911 + * copy_thread()
20912 + * low level thread copy, only used by do_fork in kernel/fork.c
20913 + */
20914 +int copy_thread(unsigned long clone_flags,
20915 + unsigned long usp, unsigned long topstk,
20916 + struct task_struct *p, struct pt_regs *regs)
20917 +
20918 +{
20919 + struct pt_regs *childregs;
20920 +
20921 + childregs = (struct pt_regs *)
20922 + (task_stack_page(p) + THREAD_SIZE - 8) - 1;
20923 +
20924 + *childregs = *regs;
20925 +
20926 + /*
20927 + * Set return value for child to be 0.
20928 + */
20929 + childregs->dn[0] = 0;
20930 +
20931 + if (usp)
20932 + childregs->an[7] = usp;
20933 + else
20934 + childregs->an[7] = (unsigned long)task_stack_page(p) +
20935 + THREAD_SIZE - 8;
20936 +
20937 + /*
20938 + * Set up the switch_to frame to return to "ret_from_fork"
20939 + */
20940 + p->thread.a5 = (unsigned long)ret_from_fork;
20941 + p->thread.sp = (unsigned long)childregs;
20942 +
20943 + return 0;
20944 +}
20945 +
20946 +/*
20947 + * sys_execve()
20948 + * executes a new program.
20949 + */
20950 +asmlinkage int sys_execve(char *name, char **argv,
20951 + char **envp, struct pt_regs *regs)
20952 +{
20953 + int error;
20954 + char *filename;
20955 +
20956 + lock_kernel();
20957 + filename = getname(name);
20958 + error = PTR_ERR(filename);
20959 + if (IS_ERR(filename))
20960 + goto out;
20961 + error = do_execve(filename, argv, envp, regs);
20962 + putname(filename);
20963 + asm (" .global sys_execve_complete\n"
20964 + " sys_execve_complete:");
20965 +out:
20966 + unlock_kernel();
20967 + return error;
20968 +}
20969 +
20970 +/*
20971 + * Return saved PC of a blocked thread.
20972 + */
20973 +unsigned long thread_saved_pc(struct task_struct *tsk)
20974 +{
20975 + return tsk->thread.a5;
20976 +}
20977 +
20978 +
20979 +unsigned long get_wchan(struct task_struct *p)
20980 +{
20981 + unsigned long pc;
20982 +
20983 + /*
20984 + * If we don't have a process, or it is not the current
20985 + * one or not RUNNING, it makes no sense to ask for a
20986 + * wchan.
20987 + */
20988 + if (!p || p == current || p->state == TASK_RUNNING)
20989 + return 0;
20990 +
20991 + /*
20992 + * TODO: If the process is in the middle of schedule, we
20993 + * are supposed to do something different but for now we
20994 + * will return the same thing in both situations.
20995 + */
20996 + pc = thread_saved_pc(p);
20997 + if (in_sched_functions(pc))
20998 + return pc;
20999 + return pc;
21000 +}
21001 +
21002 +
21003 +/*
21004 + * Infrequently used interface to dump task registers to core files.
21005 + */
21006 +int dump_task_regs(struct task_struct *task, elf_gregset_t *elfregs)
21007 +{
21008 + struct pt_regs *regs = task_pt_regs(task);
21009 + *(struct pt_regs *)elfregs = *regs;
21010 +
21011 + return 1;
21012 +}
21013 +
21014 +/*
21015 + * __switch_to is the function that implements the contex save and
21016 + * switch within the kernel. Since this is a function call very few
21017 + * registers have to be saved to pull this off. d0 holds prev and we
21018 + * want to preserve it. prev_switch is a pointer to task->thread
21019 + * structure. This is where we will save the register state. next_switch
21020 + * is pointer to the next task's thread structure that holds the
21021 + * registers.
21022 + */
21023 +asmlinkage void *__switch_to(struct task_struct *prev,
21024 + struct thread_struct *prev_switch,
21025 + struct thread_struct *next_switch)
21026 + __attribute__((naked));
21027 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/processor.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/processor.c
21028 --- linux-2.6.30.10/arch/ubicom32/kernel/processor.c 1970-01-01 02:00:00.000000000 +0200
21029 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/processor.c 2009-12-11 11:45:11.000000000 +0200
21030 @@ -0,0 +1,348 @@
21031 +/*
21032 + * arch/ubicom32/kernel/processor.c
21033 + * Ubicom32 architecture processor info implementation.
21034 + *
21035 + * (C) Copyright 2009, Ubicom, Inc.
21036 + *
21037 + * This file is part of the Ubicom32 Linux Kernel Port.
21038 + *
21039 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
21040 + * it and/or modify it under the terms of the GNU General Public License
21041 + * as published by the Free Software Foundation, either version 2 of the
21042 + * License, or (at your option) any later version.
21043 + *
21044 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
21045 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21046 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
21047 + * the GNU General Public License for more details.
21048 + *
21049 + * You should have received a copy of the GNU General Public License
21050 + * along with the Ubicom32 Linux Kernel Port. If not,
21051 + * see <http://www.gnu.org/licenses/>.
21052 + *
21053 + * Ubicom32 implementation derived from (with many thanks):
21054 + * arch/m68knommu
21055 + * arch/blackfin
21056 + * arch/parisc
21057 + */
21058 +#include <linux/module.h>
21059 +#include <linux/kernel.h>
21060 +#include <linux/init.h>
21061 +#include <linux/sched.h>
21062 +#include <linux/interrupt.h>
21063 +#include <linux/irq.h>
21064 +#include <linux/profile.h>
21065 +#include <linux/clocksource.h>
21066 +#include <linux/types.h>
21067 +#include <linux/seq_file.h>
21068 +#include <linux/delay.h>
21069 +#include <linux/cpu.h>
21070 +#include <asm/devtree.h>
21071 +#include <asm/processor.h>
21072 +#include <asm/cpu.h>
21073 +#include <asm/ocm_size.h>
21074 +
21075 +struct procnode {
21076 + struct devtree_node dn;
21077 + unsigned int threads;
21078 + unsigned int timers;
21079 + unsigned int frequency;
21080 + unsigned int ddr_frequency;
21081 + unsigned int interrupt0;
21082 + unsigned int interrupt1;
21083 + void *socm;
21084 + void *eocm;
21085 + void *sdram;
21086 + void *edram;
21087 + unsigned int arch_version;
21088 + void *os_syscall_begin;
21089 + void *os_syscall_end;
21090 +};
21091 +
21092 +struct procnode *pn;
21093 +
21094 +/*
21095 + * show_processorinfo()
21096 + * Print the actual processor information.
21097 + */
21098 +static void show_processorinfo(struct seq_file *m)
21099 +{
21100 + char *cpu, *mmu, *fpu;
21101 + unsigned int clockfreq;
21102 + unsigned int chipid;
21103 +
21104 + cpu = CPU;
21105 + mmu = "none";
21106 + fpu = "none";
21107 +
21108 + asm volatile (
21109 + "move.4 %0, CHIP_ID \n\t"
21110 + : "=r" (chipid)
21111 + );
21112 +
21113 + /*
21114 + * General Processor Information.
21115 + */
21116 + seq_printf(m, "Vendor:\t\t%s\n", "Ubicom");
21117 + seq_printf(m, "CPU:\t\t%s\n", cpu);
21118 + seq_printf(m, "MMU:\t\t%s\n", mmu);
21119 + seq_printf(m, "FPU:\t\t%s\n", fpu);
21120 + seq_printf(m, "Arch:\t\t%hx\n", chipid >> 16);
21121 + seq_printf(m, "Rev:\t\t%hx\n", (chipid & 0xffff));
21122 +
21123 + /*
21124 + * Now compute the clock frequency in Mhz.
21125 + */
21126 + clockfreq = processor_frequency();
21127 + seq_printf(m, "Clock Freq:\t%u.0 MHz\n",
21128 + clockfreq / 1000000);
21129 + seq_printf(m, "DDR Freq:\t%u.0 MHz\n",
21130 + pn ? pn->ddr_frequency / 1000000 : 0);
21131 + seq_printf(m, "BogoMips:\t%lu.%02lu\n",
21132 + (loops_per_jiffy * HZ) / 500000,
21133 + ((loops_per_jiffy * HZ) / 5000) % 100);
21134 + seq_printf(m, "Calibration:\t%lu loops\n", (loops_per_jiffy * HZ));
21135 +}
21136 +
21137 +/*
21138 + * show_cpuinfo()
21139 + * Get CPU information for use by the procfs.
21140 + */
21141 +static int show_cpuinfo(struct seq_file *m, void *v)
21142 +{
21143 + unsigned long n = (unsigned long)v - 1;
21144 +
21145 +#if defined(CONFIG_SMP)
21146 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, n);
21147 +#endif
21148 +
21149 + /*
21150 + * Print the general processor information on the first
21151 + * call.
21152 + */
21153 + if (n == 0) {
21154 + show_processorinfo(m);
21155 + }
21156 +
21157 +#if defined(CONFIG_SMP)
21158 + /*
21159 + * For each hwthread, print if this hwthread is running Linux
21160 + * or is an I/O thread.
21161 + */
21162 + if (cpu_isset(n, cpu_online_map)) {
21163 + seq_printf(m, "cpu[%02lu]:\tthread id - %lu\n", n, p->tid);
21164 + } else {
21165 + seq_printf(m, "cpu[%02lu]:\toff-line\n", n);
21166 + }
21167 +#endif
21168 + return 0;
21169 +
21170 +}
21171 +
21172 +static void *c_start(struct seq_file *m, loff_t *pos)
21173 +{
21174 + unsigned long i = *pos;
21175 +
21176 + return i < NR_CPUS ? (void *)(i + 1) : NULL;
21177 +}
21178 +
21179 +static void *c_next(struct seq_file *m, void *v, loff_t *pos)
21180 +{
21181 + ++*pos;
21182 + return c_start(m, pos);
21183 +}
21184 +
21185 +static void c_stop(struct seq_file *m, void *v)
21186 +{
21187 +}
21188 +
21189 +const struct seq_operations cpuinfo_op = {
21190 + .start = c_start,
21191 + .next = c_next,
21192 + .stop = c_stop,
21193 + .show = show_cpuinfo,
21194 +};
21195 +
21196 +/*
21197 + * processor_timers()
21198 + * Returns the timers available to Linux.
21199 + */
21200 +unsigned int processor_timers(void)
21201 +{
21202 + if (!pn) {
21203 + return 0;
21204 + }
21205 + return pn->timers;
21206 +}
21207 +
21208 +/*
21209 + * processor_threads()
21210 + * Returns the threads available to Linux.
21211 + */
21212 +unsigned int processor_threads(void)
21213 +{
21214 + if (!pn) {
21215 + return 0;
21216 + }
21217 + return pn->threads;
21218 +}
21219 +
21220 +/*
21221 + * processor_frequency()
21222 + * Returns the frequency of the system clock.
21223 + */
21224 +unsigned int processor_frequency(void)
21225 +{
21226 + if (!pn) {
21227 + return 0;
21228 + }
21229 + return pn->frequency;
21230 +}
21231 +EXPORT_SYMBOL(processor_frequency);
21232 +
21233 +/*
21234 + * processor_interrupts()
21235 + * Return the interrupts that are setup at boot time.
21236 + */
21237 +int processor_interrupts(unsigned int *int0, unsigned int *int1)
21238 +{
21239 + if (!pn) {
21240 + return -EFAULT;
21241 + }
21242 +
21243 + if (int0) {
21244 + *int0 = pn->interrupt0;
21245 + }
21246 +
21247 + if (int1) {
21248 + *int1 = pn->interrupt1;
21249 + }
21250 + return 0;
21251 +}
21252 +
21253 +/*
21254 + * processor_ocm()
21255 + * Returns the start and end of OCM available to Linux.
21256 + */
21257 +void processor_ocm(unsigned long *socm, unsigned long *eocm)
21258 +{
21259 + *socm = (unsigned long)pn->socm;
21260 + *eocm = (unsigned long)pn->eocm;
21261 +}
21262 +
21263 +/*
21264 + * processor_dram()
21265 + * Returns the start and end of dram available to Linux.
21266 + */
21267 +void processor_dram(unsigned long *sdram, unsigned long *edram)
21268 +{
21269 + *sdram = (unsigned long)pn->sdram;
21270 + *edram = (unsigned long)pn->edram;
21271 +}
21272 +
21273 +/*
21274 + * processor_validate_failed()
21275 + * Returns the dram available to Linux.
21276 + */
21277 +static noinline void processor_validate_failed(void)
21278 +{
21279 + while (1)
21280 + THREAD_STALL;
21281 +}
21282 +
21283 +/*
21284 + * processor_validate()
21285 + * Validates the procnode against limitations of this link/built.
21286 + */
21287 +static void processor_validate(void)
21288 +{
21289 + void *dram_start = (void *)(KERNELSTART);
21290 + void *dram_end = (void *)(SDRAMSTART + CONFIG_MIN_RAMSIZE);
21291 +#if APP_OCM_CODE_SIZE || APP_OCM_DATA_SIZE
21292 + void *ocm_code_start = (void *)(OCMSTART + APP_OCM_CODE_SIZE);
21293 + void *ocm_data_end = (void *)(OCMEND - APP_OCM_DATA_SIZE);
21294 +#endif
21295 + extern void __os_syscall_begin;
21296 + extern void __os_syscall_end;
21297 + int proc_node_valid = 1;
21298 +
21299 + if (!pn) {
21300 + printk(KERN_ERR "ERROR: processor node not found\n");
21301 + goto error;
21302 + }
21303 +
21304 +
21305 + if (dram_start < pn->sdram || dram_end > pn->edram) {
21306 + printk(KERN_ERR "ERROR: processor dram mismatch %p-%p "
21307 + "available but we are expecting %p-%p\n",
21308 + pn->sdram, pn->edram, dram_start, dram_end);
21309 + proc_node_valid = 0;
21310 + } else {
21311 + printk(KERN_ERR "processor dram %p-%p, expecting %p-%p\n",
21312 + pn->sdram, pn->edram, dram_start, dram_end);
21313 + }
21314 + if (&__os_syscall_begin < pn->os_syscall_begin ||
21315 + &__os_syscall_end > pn->os_syscall_end) {
21316 + printk(KERN_ERR "ERROR: processor syscall area mismatch "
21317 + "%p-%p available but we are expecting %p-%p\n",
21318 + pn->os_syscall_begin, pn->os_syscall_end,
21319 + &__os_syscall_begin, &__os_syscall_end);
21320 + proc_node_valid = 0;
21321 + } else {
21322 + printk(KERN_ERR "processor dram %p-%p, expecting %p-%p\n",
21323 + pn->sdram, pn->edram, dram_start, dram_end);
21324 + }
21325 +#if APP_OCM_CODE_SIZE || APP_OCM_DATA_SIZE
21326 + if (ocm_code_start < pn->socm || ocm_data_end > pn->eocm) {
21327 + printk(KERN_ERR "ERROR: processor ocm mismatch %p-%p "
21328 + "available but we are expecting %p-%p\n",
21329 + pn->socm, pn->eocm, ocm_code_start, ocm_data_end);
21330 + proc_node_valid = 0;
21331 + } else {
21332 + printk(KERN_INFO "processor ocm %p-%p, expecting %p-%p\n",
21333 + pn->socm, pn->eocm, ocm_code_start, ocm_data_end);
21334 +
21335 + }
21336 +#endif
21337 +
21338 + if (UBICOM32_ARCH_VERSION != pn->arch_version) {
21339 + printk(KERN_ERR "ERROR: processor arch mismatch, kernel"
21340 + "compiled for %d found %d\n",
21341 + UBICOM32_ARCH_VERSION, pn->arch_version);
21342 + proc_node_valid = 0;
21343 + }
21344 +
21345 + if (proc_node_valid)
21346 + return;
21347 +error:
21348 + processor_validate_failed();
21349 +}
21350 +
21351 +void __init processor_init(void)
21352 +{
21353 + /*
21354 + * If we do not have a trap node in the device tree, we leave the fault
21355 + * handling to the underlying hardware.
21356 + */
21357 + pn = (struct procnode *)devtree_find_node("processor");
21358 +
21359 + processor_validate();
21360 +
21361 + /*
21362 + * If necessary correct the initial range registers to cover the
21363 + * complete physical space
21364 + */
21365 + if (pn->edram > (void *)(SDRAMSTART + CONFIG_MIN_RAMSIZE)) {
21366 + printk(KERN_INFO "updating range registers for expanded dram\n");
21367 + asm volatile (
21368 + " move.4 D_RANGE1_HI, %0 \t\n"
21369 + " move.4 I_RANGE0_HI, %0 \t\n"
21370 +#ifdef CONFIG_PROTECT_KERNEL
21371 + " move.4 D_RANGE2_HI, %0 \t\n"
21372 + " move.4 I_RANGE2_HI, %0 \t\n"
21373 +#endif
21374 + : : "a"((unsigned long)pn->edram - 4)
21375 + );
21376 + }
21377 +
21378 +}
21379 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/ptrace.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/ptrace.c
21380 --- linux-2.6.30.10/arch/ubicom32/kernel/ptrace.c 1970-01-01 02:00:00.000000000 +0200
21381 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/ptrace.c 2009-12-11 11:45:11.000000000 +0200
21382 @@ -0,0 +1,275 @@
21383 +/*
21384 + * arch/ubicom32/kernel/ptrace.c
21385 + * Ubicom32 architecture ptrace implementation.
21386 + *
21387 + * (C) Copyright 2009, Ubicom, Inc.
21388 + * (C) 1994 by Hamish Macdonald
21389 + * Taken from linux/kernel/ptrace.c and modified for M680x0.
21390 + * linux/kernel/ptrace.c is by Ross Biro 1/23/92, edited by Linus Torvalds
21391 + *
21392 + * This file is part of the Ubicom32 Linux Kernel Port.
21393 + *
21394 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
21395 + * it and/or modify it under the terms of the GNU General Public License
21396 + * as published by the Free Software Foundation, either version 2 of the
21397 + * License, or (at your option) any later version.
21398 + *
21399 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
21400 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21401 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
21402 + * the GNU General Public License for more details.
21403 + *
21404 + * You should have received a copy of the GNU General Public License
21405 + * along with the Ubicom32 Linux Kernel Port. If not,
21406 + * see <http://www.gnu.org/licenses/>.
21407 + *
21408 + * Ubicom32 implementation derived from (with many thanks):
21409 + * arch/m68knommu
21410 + * arch/blackfin
21411 + * arch/parisc
21412 + */
21413 +
21414 +#include <linux/module.h>
21415 +#include <linux/kernel.h>
21416 +#include <linux/sched.h>
21417 +#include <linux/mm.h>
21418 +#include <linux/smp.h>
21419 +#include <linux/errno.h>
21420 +#include <linux/ptrace.h>
21421 +#include <linux/user.h>
21422 +#include <linux/signal.h>
21423 +#include <linux/uaccess.h>
21424 +
21425 +#include <asm/page.h>
21426 +#include <asm/pgtable.h>
21427 +#include <asm/system.h>
21428 +#include <asm/cacheflush.h>
21429 +#include <asm/processor.h>
21430 +
21431 +/*
21432 + * ptrace_getregs()
21433 + *
21434 + * Get all user integer registers.
21435 + */
21436 +static inline int ptrace_getregs(struct task_struct *task, void __user *uregs)
21437 +{
21438 + struct pt_regs *regs = task_pt_regs(task);
21439 + return copy_to_user(uregs, regs, sizeof(struct pt_regs)) ? -EFAULT : 0;
21440 +}
21441 +
21442 +/*
21443 + * ptrace_get_reg()
21444 + *
21445 + * Get contents of register REGNO in task TASK.
21446 + */
21447 +static unsigned long ptrace_get_reg(struct task_struct *task, int regno)
21448 +{
21449 + if (regno < sizeof(struct pt_regs)) {
21450 + struct pt_regs *pt_regs = task_pt_regs(task);
21451 + return *(unsigned long *)((long) pt_regs + regno);
21452 + }
21453 +
21454 + return -EIO;
21455 +}
21456 +
21457 +/*
21458 + * ptrace_put_reg()
21459 + * Write contents of register REGNO in task TASK.
21460 + */
21461 +static int ptrace_put_reg(struct task_struct *task, int regno,
21462 + unsigned long data)
21463 +{
21464 + if (regno <= sizeof(struct pt_regs) && regno != PT_FRAME_TYPE) {
21465 + struct pt_regs *pt_regs = task_pt_regs(task);
21466 + *(unsigned long *)((long) pt_regs + regno) = data;
21467 + return 0;
21468 + }
21469 + return -EIO;
21470 +}
21471 +
21472 +/*
21473 + * ptrace_disable_single_step()
21474 + * Disable Single Step
21475 + */
21476 +static int ptrace_disable_single_step(struct task_struct *task)
21477 +{
21478 + /*
21479 + * Single Step not yet implemented, so must always be disabled
21480 + */
21481 + return 0;
21482 +}
21483 +
21484 +/*
21485 + * ptrace_disable()
21486 + * Make sure the single step bit is not set.
21487 + * Called by kernel/ptrace.c when detaching..
21488 + */
21489 +void ptrace_disable(struct task_struct *child)
21490 +{
21491 + ptrace_disable_single_step(child);
21492 +}
21493 +
21494 +/*
21495 + * arch_ptrace()
21496 + * architecture specific ptrace routine.
21497 + */
21498 +long arch_ptrace(struct task_struct *child, long request, long addr, long data)
21499 +{
21500 + int ret;
21501 + switch (request) {
21502 + /* when I and D space are separate, these will need to be fixed. */
21503 + case PTRACE_PEEKTEXT: /* read word at location addr. */
21504 + case PTRACE_PEEKDATA:
21505 + ret = generic_ptrace_peekdata(child, addr, data);
21506 + break;
21507 +
21508 + /* read the word at location addr in the USER area. */
21509 + case PTRACE_PEEKUSR: {
21510 + unsigned long tmp;
21511 +
21512 + ret = -EIO;
21513 + if (((unsigned long) addr > PT_INTERP_FDPIC_LOADMAP)
21514 + || (addr & 3))
21515 + break;
21516 +
21517 + tmp = 0; /* Default return condition */
21518 +
21519 + ret = -EIO;
21520 + if (addr < sizeof(struct pt_regs)) {
21521 + tmp = ptrace_get_reg(child, addr);
21522 + } else if (addr == PT_TEXT_ADDR) {
21523 + tmp = child->mm->start_code;
21524 + } else if (addr == PT_TEXT_END_ADDR) {
21525 + tmp = child->mm->end_code;
21526 + } else if (addr == PT_DATA_ADDR) {
21527 + tmp = child->mm->start_data;
21528 + } else if (addr == PT_EXEC_FDPIC_LOADMAP) {
21529 +#ifdef CONFIG_BINFMT_ELF_FDPIC
21530 + tmp = child->mm->context.exec_fdpic_loadmap;
21531 +#endif
21532 + } else if (addr == PT_INTERP_FDPIC_LOADMAP) {
21533 +#ifdef CONFIG_BINFMT_ELF_FDPIC
21534 + tmp = child->mm->context.interp_fdpic_loadmap;
21535 +#endif
21536 + } else {
21537 + break;
21538 + }
21539 +
21540 + ret = put_user(tmp, (unsigned long *)data);
21541 + break;
21542 + }
21543 +
21544 + case PTRACE_POKETEXT: /* write the word at location addr. */
21545 + case PTRACE_POKEDATA:
21546 + ret = generic_ptrace_pokedata(child, addr, data);
21547 +
21548 + /*
21549 + * If we just changed some code so we need to
21550 + * correct the caches
21551 + */
21552 + if (request == PTRACE_POKETEXT && ret == 0) {
21553 + flush_icache_range(addr, addr + 4);
21554 + }
21555 + break;
21556 +
21557 + case PTRACE_POKEUSR: /* write the word at location addr
21558 + * in the USER area */
21559 + ret = -EIO;
21560 +
21561 + if (((unsigned long) addr > PT_DATA_ADDR) || (addr & 3))
21562 + break;
21563 +
21564 + if (addr < sizeof(struct pt_regs)) {
21565 + ret = ptrace_put_reg(child, addr, data);
21566 + }
21567 + break;
21568 +
21569 + case PTRACE_SYSCALL: /* continue and stop at next (return from)
21570 + * syscall */
21571 + case PTRACE_CONT: { /* restart after signal. */
21572 +
21573 + ret = -EIO;
21574 + if (!valid_signal(data))
21575 + break;
21576 + if (request == PTRACE_SYSCALL)
21577 + set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
21578 + else
21579 + clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
21580 + child->exit_code = data;
21581 + /* make sure the single step bit is not set. */
21582 + ptrace_disable_single_step(child);
21583 + wake_up_process(child);
21584 + ret = 0;
21585 + break;
21586 + }
21587 +
21588 + /*
21589 + * make the child exit. Best I can do is send it a sigkill.
21590 + * perhaps it should be put in the status that it wants to exit.
21591 + */
21592 + case PTRACE_KILL: {
21593 + ret = 0;
21594 + if (child->exit_state == EXIT_ZOMBIE) /* already dead */
21595 + break;
21596 + child->exit_code = SIGKILL;
21597 + /* make sure the single step bit is not set. */
21598 + ptrace_disable_single_step(child);
21599 + wake_up_process(child);
21600 + break;
21601 + }
21602 +
21603 + case PTRACE_DETACH: /* detach a process that was attached. */
21604 + ret = ptrace_detach(child, data);
21605 + break;
21606 +
21607 + case PTRACE_GETREGS: /* Get all gp regs from the child. */
21608 + ptrace_getregs(child, (unsigned long *)data);
21609 + ret = 0;
21610 + break;
21611 +
21612 + case PTRACE_SETREGS: { /* Set all gp regs in the child. */
21613 + int i;
21614 + unsigned long tmp;
21615 + int count = sizeof(struct pt_regs) / sizeof(unsigned long);
21616 + for (i = 0; i < count; i++) {
21617 + if (get_user(tmp, (unsigned long *) data)) {
21618 + ret = -EFAULT;
21619 + break;
21620 + }
21621 + ptrace_put_reg(child, sizeof(unsigned long) * i, tmp);
21622 + data += sizeof(long);
21623 + }
21624 + ret = 0;
21625 + break;
21626 + }
21627 +
21628 + default:
21629 + return ptrace_request(child, request, addr, data);
21630 + break;
21631 + }
21632 + return ret;
21633 +}
21634 +/*
21635 + * syscall_trace
21636 + *
21637 + * called by syscall enter/exit when the TIF_SYSCALL_TRACE bit is set.
21638 + */
21639 +asmlinkage void syscall_trace(void)
21640 +{
21641 + struct task_struct *cur = current;
21642 + if (!test_thread_flag(TIF_SYSCALL_TRACE))
21643 + return;
21644 + if (!(cur->ptrace & PT_PTRACED))
21645 + return;
21646 + ptrace_notify(SIGTRAP | ((cur->ptrace & PT_TRACESYSGOOD)
21647 + ? 0x80 : 0));
21648 + /*
21649 + * this isn't the same as continuing with a signal, but it will do
21650 + * for normal use. strace only continues with a signal if the
21651 + * stopping signal is not SIGTRAP. -brl
21652 + */
21653 + if (cur->exit_code) {
21654 + send_sig(cur->exit_code, current, 1);
21655 + current->exit_code = 0;
21656 + }
21657 +}
21658 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/semaphore.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/semaphore.c
21659 --- linux-2.6.30.10/arch/ubicom32/kernel/semaphore.c 1970-01-01 02:00:00.000000000 +0200
21660 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/semaphore.c 2009-12-11 11:45:11.000000000 +0200
21661 @@ -0,0 +1,159 @@
21662 +/*
21663 + * arch/ubicom32/kernel/semaphore.c
21664 + * Ubicom32 architecture semaphore implementation.
21665 + *
21666 + * (C) Copyright 2009, Ubicom, Inc.
21667 + *
21668 + * This file is part of the Ubicom32 Linux Kernel Port.
21669 + *
21670 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
21671 + * it and/or modify it under the terms of the GNU General Public License
21672 + * as published by the Free Software Foundation, either version 2 of the
21673 + * License, or (at your option) any later version.
21674 + *
21675 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
21676 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21677 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
21678 + * the GNU General Public License for more details.
21679 + *
21680 + * You should have received a copy of the GNU General Public License
21681 + * along with the Ubicom32 Linux Kernel Port. If not,
21682 + * see <http://www.gnu.org/licenses/>.
21683 + *
21684 + * Ubicom32 implementation derived from (with many thanks):
21685 + * arch/m68knommu
21686 + * arch/blackfin
21687 + * arch/parisc
21688 + */
21689 +/*
21690 + * Generic semaphore code. Buyer beware. Do your own
21691 + * specific changes in <asm/semaphore-helper.h>
21692 + */
21693 +
21694 +#include <linux/sched.h>
21695 +#include <linux/err.h>
21696 +#include <linux/init.h>
21697 +#include <asm/semaphore-helper.h>
21698 +
21699 +#ifndef CONFIG_RMW_INSNS
21700 +spinlock_t semaphore_wake_lock;
21701 +#endif
21702 +
21703 +/*
21704 + * Semaphores are implemented using a two-way counter:
21705 + * The "count" variable is decremented for each process
21706 + * that tries to sleep, while the "waking" variable is
21707 + * incremented when the "up()" code goes to wake up waiting
21708 + * processes.
21709 + *
21710 + * Notably, the inline "up()" and "down()" functions can
21711 + * efficiently test if they need to do any extra work (up
21712 + * needs to do something only if count was negative before
21713 + * the increment operation.
21714 + *
21715 + * waking_non_zero() (from asm/semaphore.h) must execute
21716 + * atomically.
21717 + *
21718 + * When __up() is called, the count was negative before
21719 + * incrementing it, and we need to wake up somebody.
21720 + *
21721 + * This routine adds one to the count of processes that need to
21722 + * wake up and exit. ALL waiting processes actually wake up but
21723 + * only the one that gets to the "waking" field first will gate
21724 + * through and acquire the semaphore. The others will go back
21725 + * to sleep.
21726 + *
21727 + * Note that these functions are only called when there is
21728 + * contention on the lock, and as such all this is the
21729 + * "non-critical" part of the whole semaphore business. The
21730 + * critical part is the inline stuff in <asm/semaphore.h>
21731 + * where we want to avoid any extra jumps and calls.
21732 + */
21733 +void __up(struct semaphore *sem)
21734 +{
21735 + wake_one_more(sem);
21736 + wake_up(&sem->wait);
21737 +}
21738 +
21739 +/*
21740 + * Perform the "down" function. Return zero for semaphore acquired,
21741 + * return negative for signalled out of the function.
21742 + *
21743 + * If called from __down, the return is ignored and the wait loop is
21744 + * not interruptible. This means that a task waiting on a semaphore
21745 + * using "down()" cannot be killed until someone does an "up()" on
21746 + * the semaphore.
21747 + *
21748 + * If called from __down_interruptible, the return value gets checked
21749 + * upon return. If the return value is negative then the task continues
21750 + * with the negative value in the return register (it can be tested by
21751 + * the caller).
21752 + *
21753 + * Either form may be used in conjunction with "up()".
21754 + *
21755 + */
21756 +
21757 +
21758 +#define DOWN_HEAD(task_state) \
21759 + \
21760 + \
21761 + current->state = (task_state); \
21762 + add_wait_queue(&sem->wait, &wait); \
21763 + \
21764 + /* \
21765 + * Ok, we're set up. sem->count is known to be less than zero \
21766 + * so we must wait. \
21767 + * \
21768 + * We can let go the lock for purposes of waiting. \
21769 + * We re-acquire it after awaking so as to protect \
21770 + * all semaphore operations. \
21771 + * \
21772 + * If "up()" is called before we call waking_non_zero() then \
21773 + * we will catch it right away. If it is called later then \
21774 + * we will have to go through a wakeup cycle to catch it. \
21775 + * \
21776 + * Multiple waiters contend for the semaphore lock to see \
21777 + * who gets to gate through and who has to wait some more. \
21778 + */ \
21779 + for (;;) {
21780 +
21781 +#define DOWN_TAIL(task_state) \
21782 + current->state = (task_state); \
21783 + } \
21784 + current->state = TASK_RUNNING; \
21785 + remove_wait_queue(&sem->wait, &wait);
21786 +
21787 +void __sched __down(struct semaphore *sem)
21788 +{
21789 + DECLARE_WAITQUEUE(wait, current);
21790 +
21791 + DOWN_HEAD(TASK_UNINTERRUPTIBLE)
21792 + if (waking_non_zero(sem))
21793 + break;
21794 + schedule();
21795 + DOWN_TAIL(TASK_UNINTERRUPTIBLE)
21796 +}
21797 +
21798 +int __sched __down_interruptible(struct semaphore *sem)
21799 +{
21800 + DECLARE_WAITQUEUE(wait, current);
21801 + int ret = 0;
21802 +
21803 + DOWN_HEAD(TASK_INTERRUPTIBLE)
21804 +
21805 + ret = waking_non_zero_interruptible(sem, current);
21806 + if (ret) {
21807 + if (ret == 1)
21808 + /* ret != 0 only if we get interrupted -arca */
21809 + ret = 0;
21810 + break;
21811 + }
21812 + schedule();
21813 + DOWN_TAIL(TASK_INTERRUPTIBLE)
21814 + return ret;
21815 +}
21816 +
21817 +int __down_trylock(struct semaphore *sem)
21818 +{
21819 + return waking_non_zero_trylock(sem);
21820 +}
21821 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/setup.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/setup.c
21822 --- linux-2.6.30.10/arch/ubicom32/kernel/setup.c 1970-01-01 02:00:00.000000000 +0200
21823 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/setup.c 2009-12-11 11:45:11.000000000 +0200
21824 @@ -0,0 +1,194 @@
21825 +/*
21826 + * arch/ubicom32/kernel/setup.c
21827 + * Ubicom32 architecture-dependent parts of system setup.
21828 + *
21829 + * (C) Copyright 2009, Ubicom, Inc.
21830 + * Copyright (C) 1999-2007 Greg Ungerer (gerg@snapgear.com)
21831 + * Copyright (C) 1998,1999 D. Jeff Dionne <jeff@uClinux.org>
21832 + * Copyleft ()) 2000 James D. Schettine {james@telos-systems.com}
21833 + * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>
21834 + * Copyright (C) 1995 Hamish Macdonald
21835 + * Copyright (C) 2000 Lineo Inc. (www.lineo.com)
21836 + * Copyright (C) 2001 Lineo, Inc. <www.lineo.com>
21837 + * 68VZ328 Fixes/support Evan Stawnyczy <e@lineo.ca>
21838 + *
21839 + * This file is part of the Ubicom32 Linux Kernel Port.
21840 + *
21841 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
21842 + * it and/or modify it under the terms of the GNU General Public License
21843 + * as published by the Free Software Foundation, either version 2 of the
21844 + * License, or (at your option) any later version.
21845 + *
21846 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
21847 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
21848 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
21849 + * the GNU General Public License for more details.
21850 + *
21851 + * You should have received a copy of the GNU General Public License
21852 + * along with the Ubicom32 Linux Kernel Port. If not,
21853 + * see <http://www.gnu.org/licenses/>.
21854 + *
21855 + * Ubicom32 implementation derived from (with many thanks):
21856 + * arch/m68knommu
21857 + * arch/blackfin
21858 + * arch/parisc
21859 + */
21860 +
21861 +#include <linux/kernel.h>
21862 +#include <linux/sched.h>
21863 +#include <linux/delay.h>
21864 +#include <linux/interrupt.h>
21865 +#include <linux/fb.h>
21866 +#include <linux/module.h>
21867 +#include <linux/console.h>
21868 +#include <linux/errno.h>
21869 +#include <linux/string.h>
21870 +#include <linux/bootmem.h>
21871 +#include <linux/seq_file.h>
21872 +#include <linux/init.h>
21873 +
21874 +#include <asm/devtree.h>
21875 +#include <asm/setup.h>
21876 +#include <asm/irq.h>
21877 +#include <asm/machdep.h>
21878 +#include <asm/pgtable.h>
21879 +#include <asm/pgalloc.h>
21880 +#include <asm/ubicom32-common.h>
21881 +#include <asm/processor.h>
21882 +#include <asm/bootargs.h>
21883 +#include <asm/thread.h>
21884 +
21885 +unsigned long memory_start;
21886 +EXPORT_SYMBOL(memory_start);
21887 +
21888 +unsigned long memory_end;
21889 +EXPORT_SYMBOL(memory_end);
21890 +
21891 +static char __initdata command_line[COMMAND_LINE_SIZE];
21892 +#ifdef CONFIG_CMDLINE_BOOL
21893 +static char __initdata builtin_cmdline[COMMAND_LINE_SIZE] = CONFIG_CMDLINE;
21894 +#endif
21895 +
21896 +extern int _stext, _etext, _sdata, _edata, _sbss, _ebss, _end;
21897 +
21898 +/*
21899 + * setup_arch()
21900 + * Setup the architecture dependent portions of the system.
21901 + */
21902 +void __init setup_arch(char **cmdline_p)
21903 +{
21904 + int bootmap_size;
21905 + unsigned long ram_start;
21906 +
21907 + processor_init();
21908 + bootargs_init();
21909 +
21910 + /*
21911 + * Use the link for memory_start from the link and the processor
21912 + * node for memory_end.
21913 + */
21914 + memory_start = PAGE_ALIGN(((unsigned long)&_end));
21915 + processor_dram(&ram_start, &memory_end);
21916 +
21917 + init_mm.start_code = (unsigned long) &_stext;
21918 + init_mm.end_code = (unsigned long) &_etext;
21919 + init_mm.end_data = (unsigned long) &_edata;
21920 + init_mm.brk = (unsigned long) 0;
21921 +
21922 + /*
21923 + * bootexec copies the original default command line to end of memory.
21924 + * u-boot can modify it there (i.e. to enable network boot) and the
21925 + * kernel picks up the modified version.
21926 + *
21927 + * mainexec creates a `new default' command_line which is in the
21928 + * bootargs devnode. It is updated on every firmware update but
21929 + * not used at the moment.
21930 + */
21931 + strlcpy(boot_command_line, (char *)(memory_end - COMMAND_LINE_SIZE), COMMAND_LINE_SIZE);
21932 +
21933 +#ifdef CONFIG_CMDLINE_BOOL
21934 +#ifdef CONFIG_CMDLINE_OVERRIDE
21935 + strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
21936 +#else
21937 + if (builtin_cmdline[0]) {
21938 + /* append boot loader cmdline to builtin */
21939 + strlcat(builtin_cmdline, " ", COMMAND_LINE_SIZE);
21940 + strlcat(builtin_cmdline, boot_command_line, COMMAND_LINE_SIZE);
21941 + strlcpy(boot_command_line, builtin_cmdline, COMMAND_LINE_SIZE);
21942 + }
21943 +#endif
21944 +#endif
21945 +
21946 + strlcpy(command_line, boot_command_line, COMMAND_LINE_SIZE);
21947 + *cmdline_p = command_line;
21948 +
21949 + parse_early_param();
21950 +
21951 + printk(KERN_INFO "%s Processor, Ubicom, Inc. <www.ubicom.com>\n", CPU);
21952 +
21953 +#if defined(DEBUG)
21954 + printk(KERN_DEBUG "KERNEL -> TEXT=0x%06x-0x%06x DATA=0x%06x-0x%06x "
21955 + "BSS=0x%06x-0x%06x\n", (int) &_stext, (int) &_etext,
21956 + (int) &_sdata, (int) &_edata,
21957 + (int) &_sbss, (int) &_ebss);
21958 + printk(KERN_DEBUG "MEMORY -> ROMFS=0x%06x-0x%06x MEM=0x%06x-0x%06x\n ",
21959 + (int) &_ebss, (int) memory_start,
21960 + (int) memory_start, (int) memory_end);
21961 +#endif
21962 +
21963 +#ifdef DEBUG
21964 + if (strlen(*cmdline_p))
21965 + printk(KERN_DEBUG "Command line: '%s'\n", *cmdline_p);
21966 +#endif
21967 +
21968 +#if defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_DUMMY_CONSOLE)
21969 + conswitchp = &dummy_con;
21970 +#endif
21971 +
21972 + /*
21973 + * If we have a device tree, see if we have the nodes we need.
21974 + */
21975 + if (devtree) {
21976 + devtree_print();
21977 + }
21978 +
21979 + /*
21980 + * From the arm initialization comment:
21981 + *
21982 + * This doesn't seem to be used by the Linux memory manager any
21983 + * more, but is used by ll_rw_block. If we can get rid of it, we
21984 + * also get rid of some of the stuff above as well.
21985 + *
21986 + * Note: max_low_pfn and max_pfn reflect the number of _pages_ in
21987 + * the system, not the maximum PFN.
21988 + */
21989 + max_pfn = max_low_pfn = (memory_end - PAGE_OFFSET) >> PAGE_SHIFT;
21990 +
21991 + /*
21992 + * Give all the memory to the bootmap allocator, tell it to put the
21993 + * boot mem_map at the start of memory.
21994 + */
21995 + bootmap_size = init_bootmem_node(
21996 + NODE_DATA(0),
21997 + memory_start >> PAGE_SHIFT, /* map goes here */
21998 + PAGE_OFFSET >> PAGE_SHIFT, /* 0 on coldfire */
21999 + memory_end >> PAGE_SHIFT);
22000 + /*
22001 + * Free the usable memory, we have to make sure we do not free
22002 + * the bootmem bitmap so we then reserve it after freeing it :-)
22003 + */
22004 + free_bootmem(memory_start, memory_end - memory_start);
22005 + reserve_bootmem(memory_start, bootmap_size, BOOTMEM_DEFAULT);
22006 +
22007 + /*
22008 + * Get kmalloc into gear.
22009 + */
22010 + paging_init();
22011 +
22012 + /*
22013 + * Fix up the thread_info structure, indicate this is a mainline Linux
22014 + * thread and setup the sw_ksp().
22015 + */
22016 + sw_ksp[thread_get_self()] = (unsigned int) current_thread_info();
22017 + thread_set_mainline(thread_get_self());
22018 +}
22019 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/signal.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/signal.c
22020 --- linux-2.6.30.10/arch/ubicom32/kernel/signal.c 1970-01-01 02:00:00.000000000 +0200
22021 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/signal.c 2009-12-11 11:45:11.000000000 +0200
22022 @@ -0,0 +1,458 @@
22023 +/*
22024 + * arch/ubicom32/kernel/signal.c
22025 + * Ubicom32 architecture signal handling implementation.
22026 + *
22027 + * (C) Copyright 2009, Ubicom, Inc.
22028 + * Copyright (C) 1991, 1992 Linus Torvalds
22029 + * Linux/m68k support by Hamish Macdonald
22030 + * 68060 fixes by Jesper Skov
22031 + * 1997-12-01 Modified for POSIX.1b signals by Andreas Schwab
22032 + * mathemu support by Roman Zippel
22033 + * ++roman (07/09/96): implemented signal stacks
22034 + *
22035 + * This file is part of the Ubicom32 Linux Kernel Port.
22036 + *
22037 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
22038 + * it and/or modify it under the terms of the GNU General Public License
22039 + * as published by the Free Software Foundation, either version 2 of the
22040 + * License, or (at your option) any later version.
22041 + *
22042 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
22043 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
22044 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
22045 + * the GNU General Public License for more details.
22046 + *
22047 + * You should have received a copy of the GNU General Public License
22048 + * along with the Ubicom32 Linux Kernel Port. If not,
22049 + * see <http://www.gnu.org/licenses/>.
22050 + *
22051 + * Ubicom32 implementation derived from (with many thanks):
22052 + * arch/m68knommu
22053 + * arch/blackfin
22054 + * arch/parisc
22055 + *
22056 + * mathemu support by Roman Zippel
22057 + * (Note: fpstate in the signal context is completely ignored for the emulator
22058 + * and the internal floating point format is put on stack)
22059 + *
22060 + * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
22061 + * Atari :-) Current limitation: Only one sigstack can be active at one time.
22062 + * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
22063 + * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
22064 + * signal handlers!
22065 + */
22066 +
22067 +#include <linux/module.h>
22068 +#include <linux/sched.h>
22069 +#include <linux/mm.h>
22070 +#include <linux/kernel.h>
22071 +#include <linux/signal.h>
22072 +#include <linux/syscalls.h>
22073 +#include <linux/errno.h>
22074 +#include <linux/wait.h>
22075 +#include <linux/ptrace.h>
22076 +#include <linux/unistd.h>
22077 +#include <linux/stddef.h>
22078 +#include <linux/highuid.h>
22079 +#include <linux/tty.h>
22080 +#include <linux/personality.h>
22081 +#include <linux/binfmts.h>
22082 +
22083 +#include <asm/setup.h>
22084 +#include <asm/uaccess.h>
22085 +#include <asm/pgtable.h>
22086 +#include <asm/traps.h>
22087 +#include <asm/ucontext.h>
22088 +
22089 +#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
22090 +
22091 +/*
22092 + * asm signal return handlers.
22093 + */
22094 +void ret_from_user_signal(void);
22095 +void ret_from_user_rt_signal(void);
22096 +asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
22097 +
22098 +/*
22099 + * Common signal suspend implementation
22100 + */
22101 +static int signal_suspend(sigset_t *saveset, struct pt_regs *regs)
22102 +{
22103 + regs->dn[0] = -EINTR;
22104 + while (1) {
22105 + current->state = TASK_INTERRUPTIBLE;
22106 + schedule();
22107 + if (!do_signal(saveset, regs)) {
22108 + continue;
22109 + }
22110 + /*
22111 + * If the current frame type is a signal trampoline we are
22112 + * actually going to call the signal handler so we return the
22113 + * desired d0 as the return value.
22114 + */
22115 + if (regs->frame_type == UBICOM32_FRAME_TYPE_SIGTRAMP) {
22116 + return regs->dn[0];
22117 + }
22118 + return -EINTR;
22119 + }
22120 + /*
22121 + * Should never get here
22122 + */
22123 + BUG();
22124 + return 0;
22125 +}
22126 +
22127 +/*
22128 + * Atomically swap in the new signal mask, and wait for a signal.
22129 + */
22130 +asmlinkage int do_sigsuspend(struct pt_regs *regs)
22131 +{
22132 + old_sigset_t mask = regs->dn[0];
22133 + sigset_t saveset;
22134 +
22135 + mask &= _BLOCKABLE;
22136 + spin_lock_irq(&current->sighand->siglock);
22137 + saveset = current->blocked;
22138 + siginitset(&current->blocked, mask);
22139 + recalc_sigpending();
22140 + spin_unlock_irq(&current->sighand->siglock);
22141 +
22142 + /*
22143 + * Call common handler
22144 + */
22145 + return signal_suspend(&saveset, regs);
22146 +}
22147 +
22148 +asmlinkage int
22149 +do_rt_sigsuspend(struct pt_regs *regs)
22150 +{
22151 + sigset_t *unewset = (sigset_t *)regs->dn[0];
22152 + size_t sigsetsize = (size_t)regs->dn[1];
22153 + sigset_t saveset, newset;
22154 +
22155 + /* XXX: Don't preclude handling different sized sigset_t's. */
22156 + if (sigsetsize != sizeof(sigset_t))
22157 + return -EINVAL;
22158 +
22159 + if (copy_from_user(&newset, unewset, sizeof(newset)))
22160 + return -EFAULT;
22161 + sigdelsetmask(&newset, ~_BLOCKABLE);
22162 +
22163 + spin_lock_irq(&current->sighand->siglock);
22164 + saveset = current->blocked;
22165 + current->blocked = newset;
22166 + recalc_sigpending();
22167 + spin_unlock_irq(&current->sighand->siglock);
22168 +
22169 + /*
22170 + * Call common handler
22171 + */
22172 + return signal_suspend(&saveset, regs);
22173 +}
22174 +
22175 +asmlinkage int
22176 +sys_sigaction(int sig, const struct old_sigaction *act,
22177 + struct old_sigaction *oact)
22178 +{
22179 + struct k_sigaction new_ka, old_ka;
22180 + int ret;
22181 +
22182 + if (act) {
22183 + old_sigset_t mask;
22184 + if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
22185 + __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
22186 + __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
22187 + return -EFAULT;
22188 + __get_user(new_ka.sa.sa_flags, &act->sa_flags);
22189 + __get_user(mask, &act->sa_mask);
22190 + siginitset(&new_ka.sa.sa_mask, mask);
22191 + }
22192 +
22193 + ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
22194 +
22195 + if (!ret && oact) {
22196 + if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
22197 + __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
22198 + __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
22199 + return -EFAULT;
22200 + __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
22201 + __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
22202 + }
22203 +
22204 + return ret;
22205 +}
22206 +
22207 +asmlinkage int
22208 +do_sys_sigaltstack(struct pt_regs *regs)
22209 +{
22210 + const stack_t *uss = (stack_t *) regs->dn[0];
22211 + stack_t *uoss = (stack_t *)regs->dn[1];
22212 + return do_sigaltstack(uss, uoss, regs->an[7]);
22213 +}
22214 +
22215 +/*
22216 + * fdpic_func_descriptor describes sa_handler when the application is FDPIC
22217 + */
22218 +struct fdpic_func_descriptor {
22219 + unsigned long text;
22220 + unsigned long GOT;
22221 +};
22222 +
22223 +/*
22224 + * rt_sigframe is stored on the user stack immediately before (above)
22225 + * the signal handlers stack.
22226 + */
22227 +struct rt_sigframe
22228 +{
22229 + unsigned long syscall_number; /* This holds __NR_rt_sigreturn. */
22230 + unsigned long restore_all_regs; /* This field gets set to 1 if the frame
22231 + * type is TRAP or INTERRUPT. */
22232 + siginfo_t *info;
22233 + struct ucontext uc;
22234 + int sig;
22235 + void *pretcode;
22236 +};
22237 +
22238 +/*
22239 + * Do a signal return; undo the signal stack.
22240 + */
22241 +asmlinkage int do_sigreturn(unsigned long __unused)
22242 +{
22243 + BUG();
22244 + return 0;
22245 +}
22246 +
22247 +asmlinkage int do_rt_sigreturn(struct pt_regs *regs)
22248 +{
22249 + unsigned long usp = regs->an[7];
22250 + struct rt_sigframe *frame = (struct rt_sigframe *)(usp);
22251 + sigset_t set;
22252 +
22253 + if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
22254 + goto badframe;
22255 + if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
22256 + goto badframe;
22257 +
22258 + sigdelsetmask(&set, ~_BLOCKABLE);
22259 + spin_lock_irq(&current->sighand->siglock);
22260 + current->blocked = set;
22261 + recalc_sigpending();
22262 + spin_unlock_irq(&current->sighand->siglock);
22263 +
22264 + if (copy_from_user(regs, &frame->uc.uc_mcontext, sizeof(struct pt_regs)))
22265 + goto badframe;
22266 + return regs->dn[0];
22267 +
22268 +badframe:
22269 + force_sig(SIGSEGV, current);
22270 + return 0;
22271 +}
22272 +
22273 +static inline void *
22274 +get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
22275 +{
22276 + unsigned long usp;
22277 +
22278 + /* Default to using normal stack. */
22279 + usp = regs->an[7];
22280 +
22281 + /* This is the X/Open sanctioned signal stack switching. */
22282 + if (ka->sa.sa_flags & SA_ONSTACK) {
22283 + if (!sas_ss_flags(usp))
22284 + usp = current->sas_ss_sp + current->sas_ss_size;
22285 + }
22286 + return (void *)((usp - frame_size) & ~0x3);
22287 +}
22288 +
22289 +/*
22290 + * signal_trampoline: Defined in ubicom32_syscall.S
22291 + */
22292 +asmlinkage void signal_trampoline(void)__attribute__((naked));
22293 +
22294 +static void setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
22295 + sigset_t *set, struct pt_regs *regs)
22296 +{
22297 + struct rt_sigframe *frame;
22298 + int err = 0;
22299 +
22300 + frame = (struct rt_sigframe *) get_sigframe(ka, regs, sizeof(*frame));
22301 +
22302 + /*
22303 + * The 'err |=' have been may criticized as bad code style, but I
22304 + * strongly suspect that we want this code to be fast. So for
22305 + * now it stays as is.
22306 + */
22307 + err |= __put_user( ( (current_thread_info()->exec_domain)
22308 + && (current_thread_info()->exec_domain->signal_invmap)
22309 + && (sig < 32) )
22310 + ? current_thread_info()->exec_domain->signal_invmap[sig]
22311 + : sig, &frame->sig);
22312 + err |= __put_user(info, &frame->info);
22313 +
22314 + /* Create the ucontext. */
22315 + err |= __put_user(0, &frame->uc.uc_flags);
22316 + err |= __put_user(0, &frame->uc.uc_link);
22317 + err |= __put_user((void *)current->sas_ss_sp,
22318 + &frame->uc.uc_stack.ss_sp);
22319 + err |= __put_user(sas_ss_flags(regs->an[7]),
22320 + &frame->uc.uc_stack.ss_flags);
22321 + err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
22322 + err |= __put_user(__NR_rt_sigreturn, &frame->syscall_number);
22323 + if ((regs->frame_type == UBICOM32_FRAME_TYPE_TRAP) ||
22324 + (regs->frame_type == UBICOM32_FRAME_TYPE_INTERRUPT)) {
22325 + err |= __put_user(1, &frame->restore_all_regs);
22326 + } else {
22327 + err |= __put_user(0, &frame->restore_all_regs);
22328 + }
22329 + err |= copy_to_user (&frame->uc.uc_mcontext.sc_regs, regs, sizeof(struct pt_regs));
22330 + err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
22331 +
22332 + if (err)
22333 + goto give_sigsegv;
22334 +
22335 + /*
22336 + * Set up registers for signal handler NOTE: Do not modify dn[14], it
22337 + * contains the userspace tls pointer, so it important that it carries
22338 + * over to the signal handler.
22339 + */
22340 + regs->an[7] = (unsigned long)frame;
22341 + regs->pc = (unsigned long) signal_trampoline;
22342 + regs->an[5] = (unsigned long) signal_trampoline;
22343 + regs->dn[0] = sig;
22344 + regs->dn[1] = (unsigned long) frame->info;
22345 + regs->dn[2] = (unsigned int) &frame->uc;
22346 +
22347 + /*
22348 + * If this is FDPIC then the signal handler is actually a function
22349 + * descriptor.
22350 + */
22351 + if (current->personality & FDPIC_FUNCPTRS) {
22352 + struct fdpic_func_descriptor __user *funcptr =
22353 + (struct fdpic_func_descriptor *) ka->sa.sa_handler;
22354 + err |= __get_user(regs->dn[3], &funcptr->text);
22355 + err |= __get_user(regs->an[0], &funcptr->GOT);
22356 + if (err)
22357 + goto give_sigsegv;
22358 +
22359 + /*
22360 + * The funcdesc must be in a3 as this is required for the lazy
22361 + * resolver in ld.so, if the application is not FDPIC a3 is not
22362 + * used.
22363 + */
22364 + regs->an[3] = (unsigned long) funcptr;
22365 +
22366 + } else {
22367 + regs->dn[3] = (unsigned long)ka->sa.sa_handler;
22368 + regs->an[0] = 0;
22369 + }
22370 +
22371 + regs->frame_type = UBICOM32_FRAME_TYPE_SIGTRAMP;
22372 +
22373 + return;
22374 +
22375 +give_sigsegv:
22376 + /* user space exception */
22377 + force_sigsegv(sig, current);
22378 +}
22379 +
22380 +static inline void
22381 +handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
22382 +{
22383 + switch (regs->dn[0]) {
22384 + case -ERESTARTNOHAND:
22385 + if (!has_handler)
22386 + goto do_restart;
22387 + regs->dn[0] = -EINTR;
22388 + break;
22389 +
22390 + case -ERESTARTSYS:
22391 + if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
22392 + regs->dn[0] = -EINTR;
22393 + break;
22394 + }
22395 + /* fallthrough */
22396 + case -ERESTARTNOINTR:
22397 + do_restart:
22398 + regs->dn[0] = regs->original_dn_0;
22399 + regs->pc -= 8;
22400 + regs->an[5] -= 8;
22401 + break;
22402 + }
22403 +}
22404 +
22405 +/*
22406 + * OK, we're invoking a handler
22407 + */
22408 +static void
22409 +handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
22410 + sigset_t *oldset, struct pt_regs *regs)
22411 +{
22412 + /* are we from a system call? */
22413 + if (regs->frame_type == -1)
22414 + /* If so, check system call restarting.. */
22415 + handle_restart(regs, ka, 1);
22416 +
22417 + /* set up the stack frame */
22418 + setup_rt_frame(sig, ka, info, oldset, regs);
22419 +
22420 + if (ka->sa.sa_flags & SA_ONESHOT)
22421 + ka->sa.sa_handler = SIG_DFL;
22422 +
22423 + spin_lock_irq(&current->sighand->siglock);
22424 + sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
22425 + if (!(ka->sa.sa_flags & SA_NODEFER))
22426 + sigaddset(&current->blocked,sig);
22427 + recalc_sigpending();
22428 + spin_unlock_irq(&current->sighand->siglock);
22429 +}
22430 +
22431 +/*
22432 + * Note that 'init' is a special process: it doesn't get signals it doesn't
22433 + * want to handle. Thus you cannot kill init even with a SIGKILL even by
22434 + * mistake.
22435 + */
22436 +asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
22437 +{
22438 + struct k_sigaction ka;
22439 + siginfo_t info;
22440 + int signr;
22441 +
22442 + /*
22443 + * We want the common case to go fast, which
22444 + * is why we may in certain cases get here from
22445 + * kernel mode. Just return without doing anything
22446 + * if so.
22447 + */
22448 + if (!user_mode(regs))
22449 + return 1;
22450 +
22451 + if (!oldset)
22452 + oldset = &current->blocked;
22453 +
22454 + signr = get_signal_to_deliver(&info, &ka, regs, NULL);
22455 + if (signr > 0) {
22456 + /* Whee! Actually deliver the signal. */
22457 + handle_signal(signr, &ka, &info, oldset, regs);
22458 + return 1;
22459 + }
22460 +
22461 + /* Did we come from a system call? */
22462 + if (regs->frame_type == -1) {
22463 + /* Restart the system call - no handlers present */
22464 + handle_restart(regs, NULL, 0);
22465 + }
22466 +
22467 + return 0;
22468 +}
22469 +
22470 +/*
22471 + * sys_sigreturn()
22472 + * Return handler for signal clean-up.
22473 + *
22474 + * NOTE: Ubicom32 does not use this syscall. Instead we rely
22475 + * on do_rt_sigreturn().
22476 + */
22477 +asmlinkage long sys_sigreturn(void)
22478 +{
22479 + return -ENOSYS;
22480 +}
22481 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/smp.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/smp.c
22482 --- linux-2.6.30.10/arch/ubicom32/kernel/smp.c 1970-01-01 02:00:00.000000000 +0200
22483 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/smp.c 2009-12-11 11:45:11.000000000 +0200
22484 @@ -0,0 +1,806 @@
22485 +/*
22486 + * arch/ubicom32/kernel/smp.c
22487 + * SMP implementation for Ubicom32 processors.
22488 + *
22489 + * (C) Copyright 2009, Ubicom, Inc.
22490 + * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
22491 + * Copyright (C) 1999 David Mosberger-Tang <davidm@hpl.hp.com>
22492 + * Copyright (C) 2001,2004 Grant Grundler <grundler@parisc-linux.org>
22493 + *
22494 + * This file is part of the Ubicom32 Linux Kernel Port.
22495 + *
22496 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
22497 + * it and/or modify it under the terms of the GNU General Public License
22498 + * as published by the Free Software Foundation, either version 2 of the
22499 + * License, or (at your option) any later version.
22500 + *
22501 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
22502 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
22503 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
22504 + * the GNU General Public License for more details.
22505 + *
22506 + * You should have received a copy of the GNU General Public License
22507 + * along with the Ubicom32 Linux Kernel Port. If not,
22508 + * see <http://www.gnu.org/licenses/>.
22509 + *
22510 + * Ubicom32 implementation derived from (with many thanks):
22511 + * arch/m68knommu
22512 + * arch/blackfin
22513 + * arch/parisc
22514 + */
22515 +
22516 +#include <linux/types.h>
22517 +#include <linux/spinlock.h>
22518 +#include <linux/slab.h>
22519 +
22520 +#include <linux/kernel.h>
22521 +#include <linux/bootmem.h>
22522 +#include <linux/module.h>
22523 +#include <linux/sched.h>
22524 +#include <linux/init.h>
22525 +#include <linux/interrupt.h>
22526 +#include <linux/smp.h>
22527 +#include <linux/kernel_stat.h>
22528 +#include <linux/mm.h>
22529 +#include <linux/err.h>
22530 +#include <linux/delay.h>
22531 +#include <linux/bitops.h>
22532 +#include <linux/cpu.h>
22533 +#include <linux/profile.h>
22534 +#include <linux/delay.h>
22535 +#include <linux/io.h>
22536 +#include <linux/ptrace.h>
22537 +#include <linux/unistd.h>
22538 +#include <linux/irq.h>
22539 +
22540 +#include <asm/system.h>
22541 +#include <asm/atomic.h>
22542 +#include <asm/current.h>
22543 +#include <asm/tlbflush.h>
22544 +#include <asm/timex.h>
22545 +#include <asm/cpu.h>
22546 +#include <asm/irq.h>
22547 +#include <asm/processor.h>
22548 +#include <asm/thread.h>
22549 +#include <asm/sections.h>
22550 +#include <asm/ip5000.h>
22551 +
22552 +/*
22553 + * Mask the debug printout for IPI because they are too verbose
22554 + * for regular debugging.
22555 + */
22556 +
22557 +// #define DEBUG_SMP 1
22558 +#if !defined(DEBUG_SMP)
22559 +#define smp_debug(lvl, ...)
22560 +#else
22561 +static unsigned int smp_debug_lvl = 50;
22562 +#define smp_debug(lvl, printargs...) \
22563 + if (lvl >= smp_debug_lvl) { \
22564 + printk(printargs); \
22565 + }
22566 +#endif
22567 +
22568 +#if !defined(DEBUG_SMP)
22569 +#define DEBUG_ASSERT(cond)
22570 +#else
22571 +#define DEBUG_ASSERT(cond) \
22572 + if (!(cond)) { \
22573 + THREAD_STALL; \
22574 + }
22575 +#endif
22576 +
22577 +/*
22578 + * List of IPI Commands (more than one can be set at a time).
22579 + */
22580 +enum ipi_message_type {
22581 + IPI_NOP,
22582 + IPI_RESCHEDULE,
22583 + IPI_CALL_FUNC,
22584 + IPI_CALL_FUNC_SINGLE,
22585 + IPI_CPU_STOP,
22586 + IPI_CPU_TIMER,
22587 +};
22588 +
22589 +/*
22590 + * We maintain a hardware thread oriented view of online threads
22591 + * and those involved or needing IPI.
22592 + */
22593 +static volatile unsigned long smp_online_threads = 0;
22594 +static volatile unsigned long smp_needs_ipi = 0;
22595 +static volatile unsigned long smp_inside_ipi = 0;
22596 +static unsigned long smp_irq_affinity[NR_IRQS];
22597 +
22598 +/*
22599 + * What do we need to track on a per cpu/thread basis?
22600 + */
22601 +DEFINE_PER_CPU(struct cpuinfo_ubicom32, cpu_data);
22602 +
22603 +/*
22604 + * Each thread cpuinfo IPI information is guarded by a lock
22605 + * that is kept local to this file.
22606 + */
22607 +DEFINE_PER_CPU(spinlock_t, ipi_lock) = SPIN_LOCK_UNLOCKED;
22608 +
22609 +/*
22610 + * The IPI(s) are based on a software IRQ through the LDSR.
22611 + */
22612 +unsigned int smp_ipi_irq;
22613 +
22614 +/*
22615 + * Define a spinlock so that only one cpu is able to modify the
22616 + * smp_needs_ipi and to set/clear the IRQ at a time.
22617 + */
22618 +DEFINE_SPINLOCK(smp_ipi_lock);
22619 +
22620 +/*
22621 + * smp_halt_processor()
22622 + * Halt this hardware thread.
22623 + */
22624 +static void smp_halt_processor(void)
22625 +{
22626 + int cpuid = thread_get_self();
22627 + cpu_clear(smp_processor_id(), cpu_online_map);
22628 + local_irq_disable();
22629 + printk(KERN_EMERG "cpu[%d] has halted. It is not OK to turn off power \
22630 + until all cpu's are off.\n", cpuid);
22631 + for (;;) {
22632 + thread_suspend();
22633 + }
22634 +}
22635 +
22636 +/*
22637 + * ipi_interrupt()
22638 + * Handle an Interprocessor Interrupt.
22639 + */
22640 +static irqreturn_t ipi_interrupt(int irq, void *dev_id)
22641 +{
22642 + int cpuid = smp_processor_id();
22643 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, cpuid);
22644 + unsigned long ops;
22645 +
22646 + /*
22647 + * Count this now; we may make a call that never returns.
22648 + */
22649 + p->ipi_count++;
22650 +
22651 + /*
22652 + * We are about to process all ops. If another cpu has stated
22653 + * that we need an IPI, we will have already processed it. By
22654 + * clearing our smp_needs_ipi, and processing all ops,
22655 + * we reduce the number of IPI interrupts. However, this introduces
22656 + * the possibility that smp_needs_ipi will be clear and the soft irq
22657 + * will have gone off; so we need to make the get_affinity() path
22658 + * tolerant of spurious interrupts.
22659 + */
22660 + spin_lock(&smp_ipi_lock);
22661 + smp_needs_ipi &= ~(1 << p->tid);
22662 + spin_unlock(&smp_ipi_lock);
22663 +
22664 + for (;;) {
22665 + /*
22666 + * Read the set of IPI commands we should handle.
22667 + */
22668 + spinlock_t *lock = &per_cpu(ipi_lock, cpuid);
22669 + spin_lock(lock);
22670 + ops = p->ipi_pending;
22671 + p->ipi_pending = 0;
22672 + spin_unlock(lock);
22673 +
22674 + /*
22675 + * If we have no IPI commands to execute, break out.
22676 + */
22677 + if (!ops) {
22678 + break;
22679 + }
22680 +
22681 + /*
22682 + * Execute the set of commands in the ops word, one command
22683 + * at a time in no particular order. Strip of each command
22684 + * as we execute it.
22685 + */
22686 + while (ops) {
22687 + unsigned long which = ffz(~ops);
22688 + ops &= ~(1 << which);
22689 +
22690 + BUG_ON(!irqs_disabled());
22691 + switch (which) {
22692 + case IPI_NOP:
22693 + smp_debug(100, KERN_INFO "cpu[%d]: "
22694 + "IPI_NOP\n", cpuid);
22695 + break;
22696 +
22697 + case IPI_RESCHEDULE:
22698 + /*
22699 + * Reschedule callback. Everything to be
22700 + * done is done by the interrupt return path.
22701 + */
22702 + smp_debug(200, KERN_INFO "cpu[%d]: "
22703 + "IPI_RESCHEDULE\n", cpuid);
22704 + break;
22705 +
22706 + case IPI_CALL_FUNC:
22707 + smp_debug(100, KERN_INFO "cpu[%d]: "
22708 + "IPI_CALL_FUNC\n", cpuid);
22709 + generic_smp_call_function_interrupt();
22710 + break;
22711 +
22712 + case IPI_CALL_FUNC_SINGLE:
22713 + smp_debug(100, KERN_INFO "cpu[%d]: "
22714 + "IPI_CALL_FUNC_SINGLE\n", cpuid);
22715 + generic_smp_call_function_single_interrupt();
22716 + break;
22717 +
22718 + case IPI_CPU_STOP:
22719 + smp_debug(100, KERN_INFO "cpu[%d]: "
22720 + "IPI_CPU_STOP\n", cpuid);
22721 + smp_halt_processor();
22722 + break;
22723 +
22724 +#if !defined(CONFIG_LOCAL_TIMERS)
22725 + case IPI_CPU_TIMER:
22726 + smp_debug(100, KERN_INFO "cpu[%d]: "
22727 + "IPI_CPU_TIMER\n", cpuid);
22728 +#if defined(CONFIG_GENERIC_CLOCKEVENTS)
22729 + local_timer_interrupt();
22730 +#else
22731 + update_process_times(user_mode(get_irq_regs()));
22732 + profile_tick(CPU_PROFILING);
22733 +#endif
22734 +#endif
22735 + break;
22736 +
22737 + default:
22738 + printk(KERN_CRIT "cpu[%d]: "
22739 + "Unknown IPI: %lu\n", cpuid, which);
22740 +
22741 + return IRQ_NONE;
22742 + }
22743 +
22744 + /*
22745 + * Let in any pending interrupts
22746 + */
22747 + BUG_ON(!irqs_disabled());
22748 + local_irq_enable();
22749 + local_irq_disable();
22750 + }
22751 + }
22752 + return IRQ_HANDLED;
22753 +}
22754 +
22755 +/*
22756 + * ipi_send()
22757 + * Send an Interprocessor Interrupt.
22758 + */
22759 +static void ipi_send(int cpu, enum ipi_message_type op)
22760 +{
22761 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, cpu);
22762 + spinlock_t *lock = &per_cpu(ipi_lock, cpu);
22763 + unsigned long flags;
22764 +
22765 + /*
22766 + * We protect the setting of the ipi_pending field and ensure
22767 + * that the ipi delivery mechanism and interrupt are atomically
22768 + * handled.
22769 + */
22770 + spin_lock_irqsave(lock, flags);
22771 + p->ipi_pending |= 1 << op;
22772 + spin_unlock_irqrestore(lock, flags);
22773 +
22774 + spin_lock_irqsave(&smp_ipi_lock, flags);
22775 + smp_needs_ipi |= (1 << p->tid);
22776 + ubicom32_set_interrupt(smp_ipi_irq);
22777 + spin_unlock_irqrestore(&smp_ipi_lock, flags);
22778 + smp_debug(100, KERN_INFO "cpu[%d]: send: %d\n", cpu, op);
22779 +}
22780 +
22781 +/*
22782 + * ipi_send_mask
22783 + * Send an IPI to each cpu in mask.
22784 + */
22785 +static inline void ipi_send_mask(unsigned int op, const struct cpumask mask)
22786 +{
22787 + int cpu;
22788 + for_each_cpu_mask(cpu, mask) {
22789 + ipi_send(cpu, op);
22790 + }
22791 +}
22792 +
22793 +/*
22794 + * ipi_send_allbutself()
22795 + * Send an IPI to all threads but ourselves.
22796 + */
22797 +static inline void ipi_send_allbutself(unsigned int op)
22798 +{
22799 + int self = smp_processor_id();
22800 + struct cpumask result;
22801 + cpumask_copy(&result, &cpu_online_map);
22802 + cpu_clear(self, result);
22803 + ipi_send_mask(op, result);
22804 +}
22805 +
22806 +/*
22807 + * smp_enable_vector()
22808 + */
22809 +static void smp_enable_vector(unsigned int irq)
22810 +{
22811 + ubicom32_clear_interrupt(smp_ipi_irq);
22812 + ldsr_enable_vector(irq);
22813 +}
22814 +
22815 +/*
22816 + * smp_disable_vector()
22817 + * Disable the interrupt by clearing the appropriate bit in the
22818 + * LDSR Mask Register.
22819 + */
22820 +static void smp_disable_vector(unsigned int irq)
22821 +{
22822 + ldsr_disable_vector(irq);
22823 +}
22824 +
22825 +/*
22826 + * smp_mask_vector()
22827 + */
22828 +static void smp_mask_vector(unsigned int irq)
22829 +{
22830 + ldsr_mask_vector(irq);
22831 +}
22832 +
22833 +/*
22834 + * smp_unmask_vector()
22835 + */
22836 +static void smp_unmask_vector(unsigned int irq)
22837 +{
22838 + ldsr_unmask_vector(irq);
22839 +}
22840 +
22841 +/*
22842 + * smp_end_vector()
22843 + * Called once an interrupt is completed (reset the LDSR mask).
22844 + */
22845 +static void smp_end_vector(unsigned int irq)
22846 +{
22847 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, smp_processor_id());
22848 + spin_lock(&smp_ipi_lock);
22849 + smp_inside_ipi &= ~(1 << p->tid);
22850 + if (smp_inside_ipi) {
22851 + spin_unlock(&smp_ipi_lock);
22852 + return;
22853 + }
22854 + spin_unlock(&smp_ipi_lock);
22855 + ldsr_unmask_vector(irq);
22856 + smp_debug(100, KERN_INFO "cpu[%d]: unamesk vector\n", smp_processor_id());
22857 +}
22858 +
22859 +/*
22860 + * Special hanlder functions for SMP.
22861 + */
22862 +static struct irq_chip ubicom32_smp_chip = {
22863 + .name = "UbicoIPI",
22864 + .startup = NULL,
22865 + .shutdown = NULL,
22866 + .enable = smp_enable_vector,
22867 + .disable = smp_disable_vector,
22868 + .ack = NULL,
22869 + .mask = smp_mask_vector,
22870 + .unmask = smp_unmask_vector,
22871 + .end = smp_end_vector,
22872 +};
22873 +
22874 +/*
22875 + * smp_reset_ipi()
22876 + * None of these cpu(s) got their IPI, turn it back on.
22877 + *
22878 + * Note: This is called by the LDSR which is not a full
22879 + * Linux cpu. Thus you must use the raw form of locks
22880 + * because lock debugging will not work on the partial
22881 + * cpu nature of the LDSR.
22882 + */
22883 +void smp_reset_ipi(unsigned long mask)
22884 +{
22885 + __raw_spin_lock(&smp_ipi_lock.raw_lock);
22886 + smp_needs_ipi |= mask;
22887 + smp_inside_ipi &= ~mask;
22888 + ubicom32_set_interrupt(smp_ipi_irq);
22889 + __raw_spin_unlock(&smp_ipi_lock.raw_lock);
22890 + smp_debug(100, KERN_INFO "smp: reset IPIs for: 0x%x\n", mask);
22891 +}
22892 +
22893 +/*
22894 + * smp_get_affinity()
22895 + * Choose the thread affinity for this interrupt.
22896 + *
22897 + * Note: This is called by the LDSR which is not a full
22898 + * Linux cpu. Thus you must use the raw form of locks
22899 + * because lock debugging will not work on the partial
22900 + * cpu nature of the LDSR.
22901 + */
22902 +unsigned long smp_get_affinity(unsigned int irq, int *all)
22903 +{
22904 + unsigned long mask = 0;
22905 +
22906 + /*
22907 + * Most IRQ(s) are delivered in a round robin fashion.
22908 + */
22909 + if (irq != smp_ipi_irq) {
22910 + unsigned long result = smp_irq_affinity[irq] & smp_online_threads;
22911 + DEBUG_ASSERT(result);
22912 + *all = 0;
22913 + return result;
22914 + }
22915 +
22916 + /*
22917 + * This is an IPI request. Return all cpu(s) scheduled for an IPI.
22918 + * We also track those cpu(s) that are going to be "receiving" IPI this
22919 + * round. When all CPU(s) have called smp_end_vector(),
22920 + * we will unmask the IPI interrupt.
22921 + */
22922 + __raw_spin_lock(&smp_ipi_lock.raw_lock);
22923 + ubicom32_clear_interrupt(smp_ipi_irq);
22924 + if (smp_needs_ipi) {
22925 + mask = smp_needs_ipi;
22926 + smp_inside_ipi |= smp_needs_ipi;
22927 + smp_needs_ipi = 0;
22928 + }
22929 + __raw_spin_unlock(&smp_ipi_lock.raw_lock);
22930 + *all = 1;
22931 + return mask;
22932 +}
22933 +
22934 +/*
22935 + * smp_set_affinity()
22936 + * Set the affinity for this irq but store the value in tid(s).
22937 + */
22938 +void smp_set_affinity(unsigned int irq, const struct cpumask *dest)
22939 +{
22940 + int cpuid;
22941 + unsigned long *paffinity = &smp_irq_affinity[irq];
22942 +
22943 + /*
22944 + * If none specified, all cpus are allowed.
22945 + */
22946 + if (cpus_empty(*dest)) {
22947 + *paffinity = 0xffffffff;
22948 + return;
22949 + }
22950 +
22951 + /*
22952 + * Make sure to clear the old value before setting up the
22953 + * list.
22954 + */
22955 + *paffinity = 0;
22956 + for_each_cpu_mask(cpuid, *dest) {
22957 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, cpuid);
22958 + *paffinity |= (1 << p->tid);
22959 + }
22960 +}
22961 +
22962 +/*
22963 + * smp_send_stop()
22964 + * Send a stop request to all CPU but this one.
22965 + */
22966 +void smp_send_stop(void)
22967 +{
22968 + ipi_send_allbutself(IPI_CPU_STOP);
22969 +}
22970 +
22971 +/*
22972 + * smp_send_timer_all()
22973 + * Send all cpu(s) but this one, a request to update times.
22974 + */
22975 +void smp_send_timer_all(void)
22976 +{
22977 + ipi_send_allbutself(IPI_CPU_TIMER);
22978 +}
22979 +
22980 +/*
22981 + * smp_timer_broadcast()
22982 + * Use an IPI to broadcast a timer message
22983 + */
22984 +void smp_timer_broadcast(const struct cpumask *mask)
22985 +{
22986 + ipi_send_mask(IPI_CPU_TIMER, *mask);
22987 +}
22988 +
22989 +/*
22990 + * smp_send_reschedule()
22991 + * Send a reschedule request to the specified cpu.
22992 + */
22993 +void smp_send_reschedule(int cpu)
22994 +{
22995 + ipi_send(cpu, IPI_RESCHEDULE);
22996 +}
22997 +
22998 +/*
22999 + * arch_send_call_function_ipi()
23000 + * Cause each cpu in the mask to call the generic function handler.
23001 + */
23002 +void arch_send_call_function_ipi_mask(const struct cpumask *mask)
23003 +{
23004 + int cpu;
23005 + for_each_cpu_mask(cpu, *mask) {
23006 + ipi_send(cpu, IPI_CALL_FUNC);
23007 + }
23008 +}
23009 +
23010 +/*
23011 + * arch_send_call_function_single_ipi()
23012 + * Cause the specified cpu to call the generic function handler.
23013 + */
23014 +void arch_send_call_function_single_ipi(int cpu)
23015 +{
23016 + ipi_send(cpu, IPI_CALL_FUNC_SINGLE);
23017 +}
23018 +
23019 +/*
23020 + * setup_profiling_timer()
23021 + * Dummy function created to keep Oprofile happy in the SMP case.
23022 + */
23023 +int setup_profiling_timer(unsigned int multiplier)
23024 +{
23025 + return 0;
23026 +}
23027 +
23028 +/*
23029 + * smp_mainline_start()
23030 + * Start a slave thread executing a mainline Linux context.
23031 + */
23032 +static void __init smp_mainline_start(void *arg)
23033 +{
23034 + int cpuid = smp_processor_id();
23035 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, cpuid);
23036 +
23037 + BUG_ON(p->tid != thread_get_self());
23038 +
23039 + /*
23040 + * Well, support 2.4 linux scheme as well.
23041 + */
23042 + if (cpu_test_and_set(cpuid, cpu_online_map)) {
23043 + printk(KERN_CRIT "cpu[%d]: already initialized!\n", cpuid);
23044 + smp_halt_processor();
23045 + return;
23046 + }
23047 +
23048 + /*
23049 + * Initialise the idle task for this CPU
23050 + */
23051 + atomic_inc(&init_mm.mm_count);
23052 + current->active_mm = &init_mm;
23053 + if (current->mm) {
23054 + printk(KERN_CRIT "cpu[%d]: idle task already has memory "
23055 + "management\n", cpuid);
23056 + smp_halt_processor();
23057 + return;
23058 + }
23059 +
23060 + /*
23061 + * TODO: X86 does this prior to calling notify, try to understand why?
23062 + */
23063 + preempt_disable();
23064 +
23065 +#if defined(CONFIG_GENERIC_CLOCKEVENTS)
23066 + /*
23067 + * Setup a local timer event so that this cpu will get timer interrupts
23068 + */
23069 + if (local_timer_setup(cpuid) == -1) {
23070 + printk(KERN_CRIT "cpu[%d]: timer alloc failed\n", cpuid);
23071 + smp_halt_processor();
23072 + return;
23073 + }
23074 +#endif
23075 +
23076 + /*
23077 + * Notify those interested that we are up and alive. This must
23078 + * be done before interrupts are enabled. It must also be completed
23079 + * before the bootstrap cpu returns from __cpu_up() (see comment
23080 + * above cpu_set() of the cpu_online_map).
23081 + */
23082 + notify_cpu_starting(cpuid);
23083 +
23084 + /*
23085 + * Indicate that this thread is now online and present. Setting
23086 + * cpu_online_map has the side effect of allowing the bootstrap
23087 + * cpu to continue along; so anything that MUST be done prior to the
23088 + * bootstrap cpu returning from __cpu_up() needs to go above here.
23089 + */
23090 + cpu_set(cpuid, cpu_online_map);
23091 + cpu_set(cpuid, cpu_present_map);
23092 +
23093 + /*
23094 + * Maintain a thread mapping in addition to the cpu mapping.
23095 + */
23096 + smp_online_threads |= (1 << p->tid);
23097 +
23098 + /*
23099 + * Enable interrupts for this thread.
23100 + */
23101 + local_irq_enable();
23102 +
23103 + /*
23104 + * Enter the idle loop and wait for a timer to schedule some work.
23105 + */
23106 + printk(KERN_INFO "cpu[%d]: entering cpu_idle()\n", cpuid);
23107 + cpu_idle();
23108 +
23109 + /* Not Reached */
23110 +}
23111 +
23112 +/*
23113 + * smp_cpus_done()
23114 + * Called once the kernel_init() has brought up all cpu(s).
23115 + */
23116 +void smp_cpus_done(unsigned int cpu_max)
23117 +{
23118 + /* Do Nothing */
23119 +}
23120 +
23121 +/*
23122 + * __cpu_up()
23123 + * Called to startup a sepcific cpu.
23124 + */
23125 +int __cpuinit __cpu_up(unsigned int cpu)
23126 +{
23127 + struct task_struct *idle;
23128 + unsigned int *stack;
23129 + long timeout;
23130 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, cpu);
23131 +
23132 + /*
23133 + * Create an idle task for this CPU.
23134 + */
23135 + idle = fork_idle(cpu);
23136 + if (IS_ERR(idle)) {
23137 + panic("cpu[%d]: fork failed\n", cpu);
23138 + return -ENOSYS;
23139 + }
23140 + task_thread_info(idle)->cpu = cpu;
23141 +
23142 + /*
23143 + * Setup the sw_ksp[] to point to this new task.
23144 + */
23145 + sw_ksp[p->tid] = (unsigned int)idle->stack;
23146 + stack = (unsigned int *)(sw_ksp[p->tid] + PAGE_SIZE - 8);
23147 +
23148 + /*
23149 + * Cause the specified thread to execute our smp_mainline_start
23150 + * function as a TYPE_NORMAL thread.
23151 + */
23152 + printk(KERN_INFO "cpu[%d]: launching mainline Linux thread\n", cpu);
23153 + if (thread_start(p->tid, smp_mainline_start, (void *)NULL, stack,
23154 + THREAD_TYPE_NORMAL) == -1) {
23155 + printk(KERN_WARNING "cpu[%d]: failed thread_start\n", cpu);
23156 + return -ENOSYS;
23157 + }
23158 +
23159 + /*
23160 + * Wait for the thread to start up. The thread will set
23161 + * the online bit when it is running. Our caller execpts the
23162 + * cpu to be online if we return 0.
23163 + */
23164 + for (timeout = 0; timeout < 10000; timeout++) {
23165 + if (cpu_online(cpu)) {
23166 + break;
23167 + }
23168 +
23169 + udelay(100);
23170 + barrier();
23171 + continue;
23172 + }
23173 +
23174 + if (!cpu_online(cpu)) {
23175 + printk(KERN_CRIT "cpu[%d]: failed to live after %ld us\n",
23176 + cpu, timeout * 100);
23177 + return -ENOSYS;
23178 + }
23179 +
23180 + printk(KERN_INFO "cpu[%d]: came alive after %ld us\n",
23181 + cpu, timeout * 100);
23182 + return 0;
23183 +}
23184 +
23185 +/*
23186 + * Data used by setup_irq for the IPI.
23187 + */
23188 +static struct irqaction ipi_irq = {
23189 + .name = "ipi",
23190 + .flags = IRQF_DISABLED | IRQF_PERCPU,
23191 + .handler = ipi_interrupt,
23192 +};
23193 +
23194 +/*
23195 + * smp_prepare_cpus()
23196 + * Mark threads that are available to Linux as possible cpus(s).
23197 + */
23198 +void __init smp_prepare_cpus(unsigned int max_cpus)
23199 +{
23200 + int i;
23201 +
23202 + /*
23203 + * We will need a software IRQ to send IPI(s). We will use
23204 + * a single software IRQ for all IPI(s).
23205 + */
23206 + if (irq_soft_alloc(&smp_ipi_irq) < 0) {
23207 + panic("no software IRQ is available\n");
23208 + return;
23209 + }
23210 +
23211 + /*
23212 + * For the IPI interrupt, we want to use our own chip definition.
23213 + * This allows us to define what happens in SMP IPI without affecting
23214 + * the performance of the other interrupts.
23215 + *
23216 + * Next, Register the IPI interrupt function against the soft IRQ.
23217 + */
23218 + set_irq_chip(smp_ipi_irq, &ubicom32_smp_chip);
23219 + setup_irq(smp_ipi_irq, &ipi_irq);
23220 +
23221 + /*
23222 + * We use the device tree node to determine how many
23223 + * free cpus we will have (up to NR_CPUS) and we indicate
23224 + * that those cpus are present.
23225 + *
23226 + * We need to do this very early in the SMP case
23227 + * because the Linux init code uses the cpu_present_map.
23228 + */
23229 + for_each_possible_cpu(i) {
23230 + thread_t tid;
23231 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, i);
23232 +
23233 + /*
23234 + * Skip the bootstrap cpu
23235 + */
23236 + if (i == 0) {
23237 + continue;
23238 + }
23239 +
23240 + /*
23241 + * If we have a free thread left in the mask,
23242 + * indicate that the cpu is present.
23243 + */
23244 + tid = thread_alloc();
23245 + if (tid == (thread_t)-1) {
23246 + break;
23247 + }
23248 +
23249 + /*
23250 + * Save the hardware thread id for this cpu.
23251 + */
23252 + p->tid = tid;
23253 + cpu_set(i, cpu_present_map);
23254 + printk(KERN_INFO "cpu[%d]: added to cpu_present_map - tid: %d\n", i, tid);
23255 + }
23256 +}
23257 +
23258 +/*
23259 + * smp_prepare_boot_cpu()
23260 + * Copy the per_cpu data into the appropriate spot for the bootstrap cpu.
23261 + *
23262 + * The code in boot_cpu_init() has already set the boot cpu's
23263 + * state in the possible, present, and online maps.
23264 + */
23265 +void __devinit smp_prepare_boot_cpu(void)
23266 +{
23267 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, 0);
23268 +
23269 + smp_online_threads |= (1 << p->tid);
23270 + printk(KERN_INFO "cpu[%d]: bootstrap CPU online - tid: %ld\n",
23271 + current_thread_info()->cpu, p->tid);
23272 +}
23273 +
23274 +/*
23275 + * smp_setup_processor_id()
23276 + * Set the current_thread_info() structure cpu value.
23277 + *
23278 + * We set the value to the true hardware thread value that we are running on.
23279 + * NOTE: this function overrides the weak alias function in main.c
23280 + */
23281 +void __init smp_setup_processor_id(void)
23282 +{
23283 + struct cpuinfo_ubicom32 *p = &per_cpu(cpu_data, 0);
23284 + int i;
23285 + for_each_cpu_mask(i, CPU_MASK_ALL)
23286 + set_cpu_possible(i, true);
23287 +
23288 + current_thread_info()->cpu = 0;
23289 + p->tid = thread_get_self();
23290 +}
23291 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/stacktrace.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/stacktrace.c
23292 --- linux-2.6.30.10/arch/ubicom32/kernel/stacktrace.c 1970-01-01 02:00:00.000000000 +0200
23293 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/stacktrace.c 2009-12-11 11:45:11.000000000 +0200
23294 @@ -0,0 +1,244 @@
23295 +/*
23296 + * arch/ubicom32/kernel/stacktrace.c
23297 + * Ubicom32 architecture stack back trace implementation.
23298 + *
23299 + * (C) Copyright 2009, Ubicom, Inc.
23300 + *
23301 + * This file is part of the Ubicom32 Linux Kernel Port.
23302 + *
23303 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
23304 + * it and/or modify it under the terms of the GNU General Public License
23305 + * as published by the Free Software Foundation, either version 2 of the
23306 + * License, or (at your option) any later version.
23307 + *
23308 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
23309 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
23310 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
23311 + * the GNU General Public License for more details.
23312 + *
23313 + * You should have received a copy of the GNU General Public License
23314 + * along with the Ubicom32 Linux Kernel Port. If not,
23315 + * see <http://www.gnu.org/licenses/>.
23316 + *
23317 + * Ubicom32 implementation derived from (with many thanks):
23318 + * arch/m68knommu
23319 + * arch/blackfin
23320 + * arch/parisc
23321 + */
23322 +#include <linux/sched.h>
23323 +#include <linux/stacktrace.h>
23324 +#include <linux/module.h>
23325 +#include <asm/stacktrace.h>
23326 +#include <asm/thread.h>
23327 +#include <asm/ip5000.h>
23328 +
23329 +/*
23330 + * These symbols are filled in by the linker.
23331 + */
23332 +extern unsigned long _stext;
23333 +extern unsigned long _etext;
23334 +
23335 +extern unsigned long __ocm_text_run_begin;
23336 +extern unsigned long __data_begin;
23337 +
23338 +/*
23339 + * stacktrace_iterate()
23340 + * Walk the stack looking for call and calli instructions on an aligned
23341 + * boundary.
23342 + *
23343 + * Trace must point to the top of the current stack frame.
23344 + */
23345 +unsigned long stacktrace_iterate(unsigned long **trace,
23346 + unsigned long stext,
23347 + unsigned long etext,
23348 + unsigned long ocm_stext,
23349 + unsigned long ocm_etext,
23350 + unsigned long sstack,
23351 + unsigned long estack)
23352 +{
23353 + unsigned int thread_trap_en, instruction;
23354 + unsigned long address;
23355 + unsigned int limit = 0;
23356 + unsigned long result = 0;
23357 + unsigned long *sp = *trace;
23358 +
23359 + /*
23360 + * Exclude the current thread from being monitored for traps.
23361 + */
23362 + asm volatile(
23363 + " thread_get_self_mask d15 \n\t"
23364 + /* save current trap status */
23365 + " and.4 %0, MT_TRAP_EN, d15 \n\t"
23366 + " not.4 d15, d15 \n\t"
23367 + /* disable trap */
23368 + " and.4 MT_TRAP_EN, MT_TRAP_EN, d15 \n\t"
23369 + " pipe_flush 0 \n\t"
23370 + : "=r" (thread_trap_en)
23371 + :
23372 + : "d15", "cc"
23373 + );
23374 +
23375 + while (limit++ < 256) {
23376 + /*
23377 + * See if we have a valid stack.
23378 + */
23379 + if (!between((unsigned long)sp, sstack, estack)) {
23380 +#ifdef TRAP_DEBUG_STACK_TRACE
23381 + printk(KERN_EMERG "stack address is out of range - "
23382 + "sp: %x, sstack: %x, estack: %x\n",
23383 + (unsigned int)sp, (unsigned int)sstack,
23384 + (unsigned int)estack);
23385 +#endif
23386 + result = 0;
23387 + *trace = 0;
23388 + break;
23389 + }
23390 +
23391 + /*
23392 + * Get the value off the stack and back up 4 bytes to what
23393 + * should be the address of a call or calli.
23394 + */
23395 + address = (*sp++) - 4;
23396 +
23397 + /*
23398 + * If the address is not within the text segment, skip this
23399 + * value.
23400 + */
23401 + if (!between(address, stext, etext) &&
23402 + !between(address, ocm_stext, ocm_etext)) {
23403 +#ifdef TRAP_DEBUG_STACK_TRACE
23404 + printk(KERN_EMERG "not a text address - "
23405 + "address: %08x, stext: %08x, etext: %08x\n"
23406 + "ocm_stext: %08x, ocm_etext: %08x\n",
23407 + (unsigned int)address,
23408 + (unsigned int)stext,
23409 + (unsigned int)etext,
23410 + (unsigned int)ocm_stext,
23411 + (unsigned int)ocm_etext);
23412 +#endif
23413 + continue;
23414 +
23415 + }
23416 +
23417 + /*
23418 + * If the address is not on an aligned boundary it can not be a
23419 + * return address.
23420 + */
23421 + if (address & 0x3) {
23422 + continue;
23423 + }
23424 +
23425 + /*
23426 + * Read the probable instruction.
23427 + */
23428 + instruction = *(unsigned int *)address;
23429 +
23430 + /*
23431 + * Is this a call instruction?
23432 + */
23433 + if ((instruction & 0xF8000000) == (u32_t)(0x1B << 27)) {
23434 +#ifdef TRAP_DEBUG_STACK_TRACE
23435 + printk(KERN_EMERG "call inst. result: %x, "
23436 + "test: %x\n", (unsigned int)address,
23437 + (unsigned int)instruction);
23438 +#endif
23439 + *trace = sp;
23440 + result = address;
23441 + break;
23442 + }
23443 +
23444 + /*
23445 + * Is this a calli instruction?
23446 + */
23447 + if ((instruction & 0xF8000000) == (u32_t)(0x1E << 27)) {
23448 +#ifdef TRAP_DEBUG_STACK_TRACE
23449 + printk(KERN_EMERG "calli inst. result: %x, "
23450 + "test: %x\n", (unsigned int)address,
23451 + (unsigned int)instruction);
23452 +#endif
23453 + *trace = sp;
23454 + result = address;
23455 + break;
23456 + }
23457 + }
23458 +
23459 + /*
23460 + * Restore the current thread to be monitored for traps.
23461 + */
23462 + if (thread_trap_en) {
23463 + asm volatile(
23464 + " thread_get_self_mask d15 \n\t"
23465 + " or.4 MT_TRAP_EN, MT_TRAP_EN, d15 \n\t"
23466 + :
23467 + :
23468 + : "d15", "cc"
23469 + );
23470 + }
23471 + return result;
23472 +}
23473 +
23474 +#ifdef CONFIG_STACKTRACE
23475 +/*
23476 + * stacktrace_save_entries()
23477 + * Save stack back trace information into the provided trace structure.
23478 + */
23479 +void stacktrace_save_entries(struct task_struct *tsk,
23480 + struct stack_trace *trace,
23481 + unsigned long sp)
23482 +{
23483 + unsigned long code_start = (unsigned long)&_stext;
23484 + unsigned long code_end = (unsigned long)&_etext;
23485 + unsigned long ocm_code_start = (unsigned long)&__ocm_text_run_begin;
23486 + unsigned long ocm_code_end = (unsigned long)&__data_begin;
23487 + unsigned long stack_end = (unsigned long)(tsk->stack + THREAD_SIZE - 8);
23488 + unsigned long stack = (unsigned long)sp;
23489 + unsigned int idx = 0;
23490 + unsigned long *handle;
23491 + int skip = trace->skip;
23492 +
23493 + handle = (unsigned long *)stack;
23494 + while (idx < trace->max_entries) {
23495 + if (skip) {
23496 + skip--;
23497 + continue;
23498 + }
23499 + trace->entries[idx] = stacktrace_iterate(&handle,
23500 + code_start, code_end,
23501 + ocm_code_start, ocm_code_end,
23502 + (unsigned long)stack, stack_end);
23503 + if (trace->entries[idx] == 0) {
23504 + break;
23505 + }
23506 + idx++;
23507 + }
23508 +}
23509 +
23510 +/*
23511 + * save_stack_trace()
23512 + * Save the specified amount of the kernel stack trace information
23513 + * for the current task.
23514 + */
23515 +void save_stack_trace(struct stack_trace *trace)
23516 +{
23517 + unsigned long sp = 0;
23518 + asm volatile (
23519 + " move.4 %0, SP \n\t"
23520 + : "=r" (sp)
23521 + );
23522 + stacktrace_save_entries(current, trace, sp);
23523 +}
23524 +EXPORT_SYMBOL_GPL(save_stack_trace);
23525 +
23526 +/*
23527 + * save_stack_trace_tsk()
23528 + * Save the specified amount of the kernel stack trace information
23529 + * for the specified task.
23530 + *
23531 + * Note: We assume the specified task is not currently running.
23532 + */
23533 +void save_stack_trace_tsk(struct task_struct *tsk, struct stack_trace *trace)
23534 +{
23535 + stacktrace_save_entries(tsk, trace, tsk->thread.sp);
23536 +}
23537 +EXPORT_SYMBOL_GPL(save_stack_trace_tsk);
23538 +#endif /* CONFIG_STACKTRACE */
23539 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/syscalltable.S linux-2.6.30.10-ubi/arch/ubicom32/kernel/syscalltable.S
23540 --- linux-2.6.30.10/arch/ubicom32/kernel/syscalltable.S 1970-01-01 02:00:00.000000000 +0200
23541 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/syscalltable.S 2009-12-11 11:45:11.000000000 +0200
23542 @@ -0,0 +1,376 @@
23543 +/*
23544 + * arch/ubicom32/kernel/syscalltable.S
23545 + * <TODO: Replace with short file description>
23546 + *
23547 + * (C) Copyright 2009, Ubicom, Inc.
23548 + *
23549 + * This file is part of the Ubicom32 Linux Kernel Port.
23550 + *
23551 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
23552 + * it and/or modify it under the terms of the GNU General Public License
23553 + * as published by the Free Software Foundation, either version 2 of the
23554 + * License, or (at your option) any later version.
23555 + *
23556 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
23557 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
23558 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
23559 + * the GNU General Public License for more details.
23560 + *
23561 + * You should have received a copy of the GNU General Public License
23562 + * along with the Ubicom32 Linux Kernel Port. If not,
23563 + * see <http://www.gnu.org/licenses/>.
23564 + *
23565 + * Ubicom32 implementation derived from (with many thanks):
23566 + * arch/m68knommu
23567 + * arch/blackfin
23568 + * arch/parisc
23569 + */
23570 +/*
23571 + *
23572 + * Copyright (C) 2002, Greg Ungerer (gerg@snapgear.com)
23573 + * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>, Kenneth Albanowski <kjahds@kjahds.com>,
23574 + * Copyright (C) 2000 Lineo Inc. (www.lineo.com)
23575 + * Copyright (C) 1991, 1992 Linus Torvalds
23576 + */
23577 +
23578 +#include <linux/sys.h>
23579 +#include <linux/linkage.h>
23580 +#include <asm/unistd.h>
23581 +
23582 +.text
23583 +ALIGN
23584 + .global sys_call_table
23585 +sys_call_table:
23586 + .long sys_ni_syscall /* 0 - old "setup()" system call*/
23587 + .long sys_exit
23588 + .long sys_fork
23589 + .long sys_read
23590 + .long sys_write
23591 + .long sys_open /* 5 */
23592 + .long sys_close
23593 + .long sys_waitpid
23594 + .long sys_creat
23595 + .long sys_link
23596 + .long sys_unlink /* 10 */
23597 + .long execve_intercept
23598 + .long sys_chdir
23599 + .long sys_time
23600 + .long sys_mknod
23601 + .long sys_chmod /* 15 */
23602 + .long sys_chown16
23603 + .long sys_ni_syscall /* old break syscall holder */
23604 + .long sys_stat
23605 + .long sys_lseek
23606 + .long sys_getpid /* 20 */
23607 + .long sys_mount
23608 + .long sys_oldumount
23609 + .long sys_setuid16
23610 + .long sys_getuid16
23611 + .long sys_stime /* 25 */
23612 + .long sys_ptrace
23613 + .long sys_alarm
23614 + .long sys_fstat
23615 + .long sys_pause
23616 + .long sys_utime /* 30 */
23617 + .long sys_ni_syscall /* old stty syscall holder */
23618 + .long sys_ni_syscall /* old gtty syscall holder */
23619 + .long sys_access
23620 + .long sys_nice
23621 + .long sys_ni_syscall /* 35 */ /* old ftime syscall holder */
23622 + .long sys_sync
23623 + .long sys_kill
23624 + .long sys_rename
23625 + .long sys_mkdir
23626 + .long sys_rmdir /* 40 */
23627 + .long sys_dup
23628 + .long sys_pipe
23629 + .long sys_times
23630 + .long sys_ni_syscall /* old prof syscall holder */
23631 + .long sys_brk /* 45 */
23632 + .long sys_setgid16
23633 + .long sys_getgid16
23634 + .long sys_signal
23635 + .long sys_geteuid16
23636 + .long sys_getegid16 /* 50 */
23637 + .long sys_acct
23638 + .long sys_umount /* recycled never used phys() */
23639 + .long sys_ni_syscall /* old lock syscall holder */
23640 + .long sys_ioctl
23641 + .long sys_fcntl /* 55 */
23642 + .long sys_ni_syscall /* old mpx syscall holder */
23643 + .long sys_setpgid
23644 + .long sys_ni_syscall /* old ulimit syscall holder */
23645 + .long sys_ni_syscall
23646 + .long sys_umask /* 60 */
23647 + .long sys_chroot
23648 + .long sys_ustat
23649 + .long sys_dup2
23650 + .long sys_getppid
23651 + .long sys_getpgrp /* 65 */
23652 + .long sys_setsid
23653 + .long sys_sigaction
23654 + .long sys_sgetmask
23655 + .long sys_ssetmask
23656 + .long sys_setreuid16 /* 70 */
23657 + .long sys_setregid16
23658 + .long sys_sigsuspend
23659 + .long sys_sigpending
23660 + .long sys_sethostname
23661 + .long sys_setrlimit /* 75 */
23662 + .long sys_old_getrlimit
23663 + .long sys_getrusage
23664 + .long sys_gettimeofday
23665 + .long sys_settimeofday
23666 + .long sys_getgroups16 /* 80 */
23667 + .long sys_setgroups16
23668 + .long old_select
23669 + .long sys_symlink
23670 + .long sys_lstat
23671 + .long sys_readlink /* 85 */
23672 + .long sys_uselib
23673 + .long sys_ni_syscall /* _sys_swapon */
23674 + .long sys_reboot
23675 + .long sys_old_readdir
23676 + .long old_mmap /* 90 */
23677 + .long sys_munmap
23678 + .long sys_truncate
23679 + .long sys_ftruncate
23680 + .long sys_fchmod
23681 + .long sys_fchown16 /* 95 */
23682 + .long sys_getpriority
23683 + .long sys_setpriority
23684 + .long sys_ni_syscall /* old profil syscall holder */
23685 + .long sys_statfs
23686 + .long sys_fstatfs /* 100 */
23687 + .long sys_ni_syscall /* ioperm for i386 */
23688 + .long sys_socketcall
23689 + .long sys_syslog
23690 + .long sys_setitimer
23691 + .long sys_getitimer /* 105 */
23692 + .long sys_newstat
23693 + .long sys_newlstat
23694 + .long sys_newfstat
23695 + .long sys_ni_syscall
23696 + .long sys_ni_syscall /* iopl for i386 */ /* 110 */
23697 + .long sys_vhangup
23698 + .long sys_ni_syscall /* obsolete idle() syscall */
23699 + .long sys_ni_syscall /* vm86old for i386 */
23700 + .long sys_wait4
23701 + .long sys_ni_syscall /* 115 */ /* _sys_swapoff */
23702 + .long sys_sysinfo
23703 + .long sys_ipc
23704 + .long sys_fsync
23705 + .long sys_sigreturn
23706 + .long clone_intercept /* 120 */
23707 + .long sys_setdomainname
23708 + .long sys_newuname
23709 + .long sys_cacheflush /* modify_ldt for i386 */
23710 + .long sys_adjtimex
23711 + .long sys_ni_syscall /* 125 */ /* _sys_mprotect */
23712 + .long sys_sigprocmask
23713 + .long sys_ni_syscall /* old "creat_module" */
23714 + .long sys_init_module
23715 + .long sys_delete_module
23716 + .long sys_ni_syscall /* 130: old "get_kernel_syms" */
23717 + .long sys_quotactl
23718 + .long sys_getpgid
23719 + .long sys_fchdir
23720 + .long sys_bdflush
23721 + .long sys_sysfs /* 135 */
23722 + .long sys_personality
23723 + .long sys_ni_syscall /* for afs_syscall */
23724 + .long sys_setfsuid16
23725 + .long sys_setfsgid16
23726 + .long sys_llseek /* 140 */
23727 + .long sys_getdents
23728 + .long sys_select
23729 + .long sys_flock
23730 + .long sys_ni_syscall /* _sys_msync */
23731 + .long sys_readv /* 145 */
23732 + .long sys_writev
23733 + .long sys_getsid
23734 + .long sys_fdatasync
23735 + .long sys_sysctl
23736 + .long sys_ni_syscall /* 150 */ /* _sys_mlock */
23737 + .long sys_ni_syscall /* _sys_munlock */
23738 + .long sys_ni_syscall /* _sys_mlockall */
23739 + .long sys_ni_syscall /* _sys_munlockall */
23740 + .long sys_sched_setparam
23741 + .long sys_sched_getparam /* 155 */
23742 + .long sys_sched_setscheduler
23743 + .long sys_sched_getscheduler
23744 + .long sys_sched_yield
23745 + .long sys_sched_get_priority_max
23746 + .long sys_sched_get_priority_min /* 160 */
23747 + .long sys_sched_rr_get_interval
23748 + .long sys_nanosleep
23749 + .long sys_ni_syscall /* _sys_mremap */
23750 + .long sys_setresuid16
23751 + .long sys_getresuid16 /* 165 */
23752 + .long sys_getpagesize /* _sys_getpagesize */
23753 + .long sys_ni_syscall /* old "query_module" */
23754 + .long sys_poll
23755 + .long sys_ni_syscall /* _sys_nfsservctl */
23756 + .long sys_setresgid16 /* 170 */
23757 + .long sys_getresgid16
23758 + .long sys_prctl
23759 + .long sys_rt_sigreturn
23760 + .long sys_rt_sigaction
23761 + .long sys_rt_sigprocmask /* 175 */
23762 + .long sys_rt_sigpending
23763 + .long sys_rt_sigtimedwait
23764 + .long sys_rt_sigqueueinfo
23765 + .long sys_rt_sigsuspend
23766 + .long sys_pread64 /* 180 */
23767 + .long sys_pwrite64
23768 + .long sys_lchown16
23769 + .long sys_getcwd
23770 + .long sys_capget
23771 + .long sys_capset /* 185 */
23772 + .long sys_sigaltstack
23773 + .long sys_sendfile
23774 + .long sys_ni_syscall /* streams1 */
23775 + .long sys_ni_syscall /* streams2 */
23776 + .long vfork_intercept /* 190 */
23777 + .long sys_getrlimit
23778 + .long sys_mmap2
23779 + .long sys_truncate64
23780 + .long sys_ftruncate64
23781 + .long sys_stat64 /* 195 */
23782 + .long sys_lstat64
23783 + .long sys_fstat64
23784 + .long sys_chown
23785 + .long sys_getuid
23786 + .long sys_getgid /* 200 */
23787 + .long sys_geteuid
23788 + .long sys_getegid
23789 + .long sys_setreuid
23790 + .long sys_setregid
23791 + .long sys_getgroups /* 205 */
23792 + .long sys_setgroups
23793 + .long sys_fchown
23794 + .long sys_setresuid
23795 + .long sys_getresuid
23796 + .long sys_setresgid /* 210 */
23797 + .long sys_getresgid
23798 + .long sys_lchown
23799 + .long sys_setuid
23800 + .long sys_setgid
23801 + .long sys_setfsuid /* 215 */
23802 + .long sys_setfsgid
23803 + .long sys_pivot_root
23804 + .long sys_ni_syscall
23805 + .long sys_ni_syscall
23806 + .long sys_getdents64 /* 220 */
23807 + .long sys_gettid
23808 + .long sys_tkill
23809 + .long sys_setxattr
23810 + .long sys_lsetxattr
23811 + .long sys_fsetxattr /* 225 */
23812 + .long sys_getxattr
23813 + .long sys_lgetxattr
23814 + .long sys_fgetxattr
23815 + .long sys_listxattr
23816 + .long sys_llistxattr /* 230 */
23817 + .long sys_flistxattr
23818 + .long sys_removexattr
23819 + .long sys_lremovexattr
23820 + .long sys_fremovexattr
23821 + .long sys_futex /* 235 */
23822 + .long sys_sendfile64
23823 + .long sys_ni_syscall /* _sys_mincore */
23824 + .long sys_ni_syscall /* _sys_madvise */
23825 + .long sys_fcntl64
23826 + .long sys_readahead /* 240 */
23827 + .long sys_io_setup
23828 + .long sys_io_destroy
23829 + .long sys_io_getevents
23830 + .long sys_io_submit
23831 + .long sys_io_cancel /* 245 */
23832 + .long sys_fadvise64
23833 + .long sys_exit_group
23834 + .long sys_lookup_dcookie
23835 + .long sys_epoll_create
23836 + .long sys_epoll_ctl /* 250 */
23837 + .long sys_epoll_wait
23838 + .long sys_ni_syscall /* _sys_remap_file_pages */
23839 + .long sys_set_tid_address
23840 + .long sys_timer_create
23841 + .long sys_timer_settime /* 255 */
23842 + .long sys_timer_gettime
23843 + .long sys_timer_getoverrun
23844 + .long sys_timer_delete
23845 + .long sys_clock_settime
23846 + .long sys_clock_gettime /* 260 */
23847 + .long sys_clock_getres
23848 + .long sys_clock_nanosleep
23849 + .long sys_statfs64
23850 + .long sys_fstatfs64
23851 + .long sys_tgkill /* 265 */
23852 + .long sys_utimes
23853 + .long sys_fadvise64_64
23854 + .long sys_mbind
23855 + .long sys_get_mempolicy
23856 + .long sys_set_mempolicy /* 270 */
23857 + .long sys_mq_open
23858 + .long sys_mq_unlink
23859 + .long sys_mq_timedsend
23860 + .long sys_mq_timedreceive
23861 + .long sys_mq_notify /* 275 */
23862 + .long sys_mq_getsetattr
23863 + .long sys_waitid
23864 + .long sys_ni_syscall /* for _sys_vserver */
23865 + .long sys_add_key
23866 + .long sys_request_key /* 280 */
23867 + .long sys_keyctl
23868 + .long sys_ioprio_set
23869 + .long sys_ioprio_get
23870 + .long sys_inotify_init
23871 + .long sys_inotify_add_watch /* 285 */
23872 + .long sys_inotify_rm_watch
23873 + .long sys_migrate_pages
23874 + .long sys_openat
23875 + .long sys_mkdirat
23876 + .long sys_mknodat /* 290 */
23877 + .long sys_fchownat
23878 + .long sys_futimesat
23879 + .long sys_fstatat64
23880 + .long sys_unlinkat
23881 + .long sys_renameat /* 295 */
23882 + .long sys_linkat
23883 + .long sys_symlinkat
23884 + .long sys_readlinkat
23885 + .long sys_fchmodat
23886 + .long sys_faccessat /* 300 */
23887 + .long sys_ni_syscall /* Reserved for pselect6 */
23888 + .long sys_ni_syscall /* Reserved for ppoll */
23889 + .long sys_unshare
23890 + .long sys_set_robust_list
23891 + .long sys_get_robust_list /* 305 */
23892 + .long sys_splice
23893 + .long sys_sync_file_range
23894 + .long sys_tee
23895 + .long sys_vmsplice
23896 + .long sys_move_pages /* 310 */
23897 + .long sys_sched_setaffinity
23898 + .long sys_sched_getaffinity
23899 + .long sys_kexec_load
23900 + .long sys_getcpu
23901 + .long sys_epoll_pwait /* 315 */
23902 + .long sys_utimensat
23903 + .long sys_signalfd
23904 + .long sys_timerfd_create
23905 + .long sys_eventfd
23906 + .long sys_fallocate /* 320 */
23907 + .long sys_timerfd_settime
23908 + .long sys_timerfd_gettime
23909 + .long sys_ni_syscall /* sys_signalfd4 */
23910 + .long sys_ni_syscall /* sys_eventfd2 */
23911 + .long sys_ni_syscall /* sys_epoll_create1 */
23912 + /* 325 */
23913 + .long sys_ni_syscall /* sys_dup3 */
23914 + .long sys_ni_syscall /* sys_pipe2 */
23915 + .long sys_ni_syscall /* sys_inotify_init1 */
23916 + .rept NR_syscalls-(.-sys_call_table)/4
23917 + .long sys_ni_syscall
23918 + .endr
23919 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/sys_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/sys_ubicom32.c
23920 --- linux-2.6.30.10/arch/ubicom32/kernel/sys_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
23921 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/sys_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
23922 @@ -0,0 +1,237 @@
23923 +/*
23924 + * arch/ubicom32/kernel/sys_ubicom32.c
23925 + * Ubicom32 architecture system call support implementation.
23926 + *
23927 + * (C) Copyright 2009, Ubicom, Inc.
23928 + *
23929 + * This file is part of the Ubicom32 Linux Kernel Port.
23930 + *
23931 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
23932 + * it and/or modify it under the terms of the GNU General Public License
23933 + * as published by the Free Software Foundation, either version 2 of the
23934 + * License, or (at your option) any later version.
23935 + *
23936 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
23937 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
23938 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
23939 + * the GNU General Public License for more details.
23940 + *
23941 + * You should have received a copy of the GNU General Public License
23942 + * along with the Ubicom32 Linux Kernel Port. If not,
23943 + * see <http://www.gnu.org/licenses/>.
23944 + *
23945 + * Ubicom32 implementation derived from (with many thanks):
23946 + * arch/m68knommu
23947 + * arch/blackfin
23948 + * arch/parisc
23949 + *
23950 + * This file contains various random system calls that
23951 + * have a non-standard calling sequence on the Linux/ubicom32
23952 + * platform.
23953 + */
23954 +
23955 +#include <linux/module.h>
23956 +#include <linux/errno.h>
23957 +#include <linux/sched.h>
23958 +#include <linux/mm.h>
23959 +#include <linux/smp.h>
23960 +#include <linux/sem.h>
23961 +#include <linux/msg.h>
23962 +#include <linux/shm.h>
23963 +#include <linux/stat.h>
23964 +#include <linux/syscalls.h>
23965 +#include <linux/mman.h>
23966 +#include <linux/file.h>
23967 +#include <linux/utsname.h>
23968 +#include <linux/ipc.h>
23969 +#include <linux/fs.h>
23970 +#include <linux/uaccess.h>
23971 +#include <linux/unistd.h>
23972 +
23973 +#include <asm/setup.h>
23974 +#include <asm/traps.h>
23975 +#include <asm/cacheflush.h>
23976 +
23977 +/* common code for old and new mmaps */
23978 +static inline long do_mmap2(
23979 + unsigned long addr, unsigned long len,
23980 + unsigned long prot, unsigned long flags,
23981 + unsigned long fd, unsigned long pgoff)
23982 +{
23983 + int error = -EBADF;
23984 + struct file *file = NULL;
23985 +
23986 + flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
23987 + if (!(flags & MAP_ANONYMOUS)) {
23988 + file = fget(fd);
23989 + if (!file)
23990 + goto out;
23991 + }
23992 +
23993 + down_write(&current->mm->mmap_sem);
23994 + error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
23995 + up_write(&current->mm->mmap_sem);
23996 +
23997 + if (file)
23998 + fput(file);
23999 +out:
24000 + return error;
24001 +}
24002 +
24003 +asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
24004 + unsigned long prot, unsigned long flags,
24005 + unsigned long fd, unsigned long pgoff)
24006 +{
24007 + return do_mmap2(addr, len, prot, flags, fd, pgoff);
24008 +}
24009 +
24010 +/*
24011 + * Perform the select(nd, in, out, ex, tv) and mmap() system
24012 + * calls. Linux/m68k cloned Linux/i386, which didn't use to be able to
24013 + * handle more than 4 system call parameters, so these system calls
24014 + * used a memory block for parameter passing..
24015 + */
24016 +
24017 +struct mmap_arg_struct {
24018 + unsigned long addr;
24019 + unsigned long len;
24020 + unsigned long prot;
24021 + unsigned long flags;
24022 + unsigned long fd;
24023 + unsigned long offset;
24024 +};
24025 +
24026 +asmlinkage int old_mmap(struct mmap_arg_struct *arg)
24027 +{
24028 + struct mmap_arg_struct a;
24029 + int error = -EFAULT;
24030 +
24031 + if (copy_from_user(&a, arg, sizeof(a)))
24032 + goto out;
24033 +
24034 + error = -EINVAL;
24035 + if (a.offset & ~PAGE_MASK)
24036 + goto out;
24037 +
24038 + a.flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
24039 +
24040 + error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd,
24041 + a.offset >> PAGE_SHIFT);
24042 +out:
24043 + return error;
24044 +}
24045 +
24046 +struct sel_arg_struct {
24047 + unsigned long n;
24048 + fd_set *inp, *outp, *exp;
24049 + struct timeval *tvp;
24050 +};
24051 +
24052 +asmlinkage int old_select(struct sel_arg_struct *arg)
24053 +{
24054 + struct sel_arg_struct a;
24055 +
24056 + if (copy_from_user(&a, arg, sizeof(a)))
24057 + return -EFAULT;
24058 + /* sys_select() does the appropriate kernel locking */
24059 + return sys_select(a.n, a.inp, a.outp, a.exp, a.tvp);
24060 +}
24061 +
24062 +/*
24063 + * sys_ipc() is the de-multiplexer for the SysV IPC calls..
24064 + *
24065 + * This is really horribly ugly.
24066 + */
24067 +asmlinkage int sys_ipc(uint call, int first, int second,
24068 + int third, void *ptr, long fifth)
24069 +{
24070 + int version, ret;
24071 +
24072 + version = call >> 16; /* hack for backward compatibility */
24073 + call &= 0xffff;
24074 +
24075 + if (call <= SEMCTL)
24076 + switch (call) {
24077 + case SEMOP:
24078 + return sys_semop(first, (struct sembuf *)ptr, second);
24079 + case SEMGET:
24080 + return sys_semget(first, second, third);
24081 + case SEMCTL: {
24082 + union semun fourth;
24083 + if (!ptr)
24084 + return -EINVAL;
24085 + if (get_user(fourth.__pad, (void **) ptr))
24086 + return -EFAULT;
24087 + return sys_semctl(first, second, third, fourth);
24088 + }
24089 + default:
24090 + return -EINVAL;
24091 + }
24092 + if (call <= MSGCTL)
24093 + switch (call) {
24094 + case MSGSND:
24095 + return sys_msgsnd(first, (struct msgbuf *) ptr,
24096 + second, third);
24097 + case MSGRCV:
24098 + switch (version) {
24099 + case 0: {
24100 + struct ipc_kludge tmp;
24101 + if (!ptr)
24102 + return -EINVAL;
24103 + if (copy_from_user(&tmp,
24104 + (struct ipc_kludge *)ptr,
24105 + sizeof(tmp)))
24106 + return -EFAULT;
24107 + return sys_msgrcv(first, tmp.msgp, second,
24108 + tmp.msgtyp, third);
24109 + }
24110 + default:
24111 + return sys_msgrcv(first,
24112 + (struct msgbuf *) ptr,
24113 + second, fifth, third);
24114 + }
24115 + case MSGGET:
24116 + return sys_msgget((key_t) first, second);
24117 + case MSGCTL:
24118 + return sys_msgctl(first, second,
24119 + (struct msqid_ds *) ptr);
24120 + default:
24121 + return -EINVAL;
24122 + }
24123 + if (call <= SHMCTL)
24124 + switch (call) {
24125 + case SHMAT:
24126 + switch (version) {
24127 + default: {
24128 + ulong raddr;
24129 + ret = do_shmat(first, ptr, second, &raddr);
24130 + if (ret)
24131 + return ret;
24132 + return put_user(raddr, (ulong __user *) third);
24133 + }
24134 + }
24135 + case SHMDT:
24136 + return sys_shmdt(ptr);
24137 + case SHMGET:
24138 + return sys_shmget(first, second, third);
24139 + case SHMCTL:
24140 + return sys_shmctl(first, second, ptr);
24141 + default:
24142 + return -ENOSYS;
24143 + }
24144 +
24145 + return -EINVAL;
24146 +}
24147 +
24148 +/* sys_cacheflush -- flush (part of) the processor cache. */
24149 +asmlinkage int
24150 +sys_cacheflush(unsigned long addr, int scope, int cache, unsigned long len)
24151 +{
24152 + flush_cache_all();
24153 + return 0;
24154 +}
24155 +
24156 +asmlinkage int sys_getpagesize(void)
24157 +{
24158 + return PAGE_SIZE;
24159 +}
24160 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/thread.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/thread.c
24161 --- linux-2.6.30.10/arch/ubicom32/kernel/thread.c 1970-01-01 02:00:00.000000000 +0200
24162 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/thread.c 2009-12-11 11:45:11.000000000 +0200
24163 @@ -0,0 +1,228 @@
24164 +/*
24165 + * arch/ubicom32/kernel/thread.c
24166 + * Ubicom32 architecture hardware thread support.
24167 + *
24168 + * (C) Copyright 2009, Ubicom, Inc.
24169 + *
24170 + * This file is part of the Ubicom32 Linux Kernel Port.
24171 + *
24172 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
24173 + * it and/or modify it under the terms of the GNU General Public License
24174 + * as published by the Free Software Foundation, either version 2 of the
24175 + * License, or (at your option) any later version.
24176 + *
24177 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
24178 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
24179 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
24180 + * the GNU General Public License for more details.
24181 + *
24182 + * You should have received a copy of the GNU General Public License
24183 + * along with the Ubicom32 Linux Kernel Port. If not,
24184 + * see <http://www.gnu.org/licenses/>.
24185 + *
24186 + * Ubicom32 implementation derived from (with many thanks):
24187 + * arch/m68knommu
24188 + * arch/blackfin
24189 + * arch/parisc
24190 + */
24191 +
24192 +#include <linux/module.h>
24193 +#include <linux/kernel.h>
24194 +#include <linux/init.h>
24195 +#include <linux/sched.h>
24196 +#include <linux/interrupt.h>
24197 +#include <linux/irq.h>
24198 +#include <linux/profile.h>
24199 +#include <linux/clocksource.h>
24200 +#include <linux/types.h>
24201 +#include <asm/ip5000.h>
24202 +#include <asm/machdep.h>
24203 +#include <asm/asm-offsets.h>
24204 +#include <asm/thread.h>
24205 +
24206 +/*
24207 + * TODO: At some point change the name here to be thread_ksp
24208 + */
24209 +unsigned int sw_ksp[THREAD_ARCHITECTURAL_MAX];
24210 +
24211 +static unsigned int thread_mask = -1;
24212 +static unsigned int thread_mainline_mask;
24213 +
24214 +/*
24215 + * thread_entry()
24216 + * Returning from the called function will disable the thread.
24217 + *
24218 + * This could be a naked call to allow for hwthreads that do not have stacks.
24219 + * However, with -O0, the code still writes to thex stack, and this was
24220 + * corrupting memory just after the callers stack.
24221 + */
24222 +static void thread_entry(void *arg, thread_exec_fn_t exec)
24223 +{
24224 + /*
24225 + * Call thread function
24226 + */
24227 + exec(arg);
24228 +
24229 + /*
24230 + * Complete => Disable self
24231 + */
24232 + thread_disable(thread_get_self());
24233 +}
24234 +
24235 +/*
24236 + * thread_start()
24237 + * Start the specified function on the specified hardware thread.
24238 + */
24239 +thread_t thread_start(thread_t thread,
24240 + thread_exec_fn_t exec,
24241 + void *arg,
24242 + unsigned int *sp_high,
24243 + thread_type_t type)
24244 +{
24245 + /*
24246 + * Sanity check
24247 + */
24248 + unsigned int enabled, mask, csr;
24249 + asm volatile (
24250 + "move.4 %0, MT_EN\n\t"
24251 + : "=m" (enabled)
24252 + );
24253 +
24254 + mask = 1 << thread;
24255 + if (enabled & mask) {
24256 + printk(KERN_WARNING "request to enable a previously enabled thread\n");
24257 + return (thread_t)-1;
24258 + }
24259 +
24260 + /*
24261 + * Update thread state
24262 + */
24263 + csr = (thread << 15) | (1 << 14);
24264 + asm volatile (
24265 + "setcsr %0 \n\t"
24266 + "setcsr_flush 0 \n\t"
24267 +
24268 + "move.4 A0, #0 \n\t"
24269 + "move.4 A1, #0 \n\t"
24270 + "move.4 A2, #0 \n\t"
24271 + "move.4 A3, #0 \n\t"
24272 + "move.4 A4, #0 \n\t"
24273 + "move.4 A5, #0 \n\t"
24274 + "move.4 A6, #0 \n\t"
24275 + "move.4 SP, %4 \n\t" /* A7 is SP */
24276 +
24277 + "move.4 D0, %3 \n\t"
24278 + "move.4 D1, %2 \n\t"
24279 + "move.4 D2, #0 \n\t"
24280 + "move.4 D3, #0 \n\t"
24281 + "move.4 D4, #0 \n\t"
24282 + "move.4 D5, #0 \n\t"
24283 + "move.4 D6, #0 \n\t"
24284 + "move.4 D7, #0 \n\t"
24285 + "move.4 D8, #0 \n\t"
24286 + "move.4 D9, #0 \n\t"
24287 + "move.4 D10, #0 \n\t"
24288 + "move.4 D11, #0 \n\t"
24289 + "move.4 D12, #0 \n\t"
24290 + "move.4 D13, #0 \n\t"
24291 + "move.4 D14, #0 \n\t"
24292 + "move.4 D15, #0 \n\t"
24293 +
24294 + "move.4 INT_MASK0, #0 \n\t"
24295 + "move.4 INT_MASK1, #0 \n\t"
24296 + "move.4 PC, %1 \n\t"
24297 + "setcsr #0 \n\t"
24298 + "setcsr_flush 0 \n\t"
24299 + :
24300 + : "r" (csr), "r" (thread_entry), "r" (exec),
24301 + "r" (arg), "r" (sp_high)
24302 + );
24303 +
24304 + /*
24305 + * Apply HRT state
24306 + */
24307 + if (type & THREAD_TYPE_HRT) {
24308 + asm volatile (
24309 + "or.4 MT_HRT, MT_HRT, %0\n\t"
24310 + :
24311 + : "d" (mask)
24312 + : "cc"
24313 + );
24314 + } else {
24315 + asm volatile (
24316 + "and.4 MT_HRT, MT_HRT, %0\n\t"
24317 + :
24318 + : "d" (~mask)
24319 + : "cc"
24320 + );
24321 + }
24322 +
24323 + /*
24324 + * Set priority
24325 + */
24326 + asm volatile (
24327 + "or.4 MT_HPRI, MT_HPRI, %0\n\t"
24328 + :
24329 + : "d" (mask)
24330 + : "cc"
24331 + );
24332 +
24333 + /*
24334 + * Enable thread
24335 + */
24336 + asm volatile (
24337 + "move.4 MT_ACTIVE_SET, %0 \n\t"
24338 + :
24339 + : "d" (mask)
24340 + );
24341 + thread_enable_mask(mask);
24342 + return thread;
24343 +}
24344 +
24345 +/*
24346 + * thread_get_mainline()
24347 + * Return a mask of those threads that are Linux mainline threads.
24348 + */
24349 +unsigned int thread_get_mainline(void)
24350 +{
24351 + return thread_mainline_mask;
24352 +}
24353 +
24354 +/*
24355 + * thread_set_mainline()
24356 + * Indicate that the specified thread is a Linux mainline thread.
24357 + */
24358 +void thread_set_mainline(thread_t tid)
24359 +{
24360 + thread_mainline_mask |= (1 << tid);
24361 +}
24362 +
24363 +/*
24364 + * thread_alloc()
24365 + * Allocate an unused hardware thread.
24366 + */
24367 +thread_t thread_alloc(void)
24368 +{
24369 + thread_t tid;
24370 +
24371 + /*
24372 + * If this is the first time we are here get the list of unused
24373 + * threads from the processor device tree node.
24374 + */
24375 + if (thread_mask == -1) {
24376 + thread_mask = processor_threads();
24377 + }
24378 +
24379 + if (!thread_mask) {
24380 + return (thread_t)-1;
24381 + }
24382 +
24383 + tid = ffs(thread_mask);
24384 + if (tid != 0) {
24385 + tid--;
24386 + thread_mask &= ~(1 << tid);
24387 + return tid;
24388 + }
24389 +
24390 + return (thread_t)-1;
24391 +}
24392 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/time.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/time.c
24393 --- linux-2.6.30.10/arch/ubicom32/kernel/time.c 1970-01-01 02:00:00.000000000 +0200
24394 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/time.c 2009-12-11 11:45:11.000000000 +0200
24395 @@ -0,0 +1,212 @@
24396 +/*
24397 + * arch/ubicom32/kernel/time.c
24398 + * Initialize the timer list and start the appropriate timers.
24399 + *
24400 + * (C) Copyright 2009, Ubicom, Inc.
24401 + * Copyright (C) 1991, 1992, 1995 Linus Torvalds
24402 + *
24403 + * This file is part of the Ubicom32 Linux Kernel Port.
24404 + *
24405 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
24406 + * it and/or modify it under the terms of the GNU General Public License
24407 + * as published by the Free Software Foundation, either version 2 of the
24408 + * License, or (at your option) any later version.
24409 + *
24410 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
24411 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
24412 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
24413 + * the GNU General Public License for more details.
24414 + *
24415 + * You should have received a copy of the GNU General Public License
24416 + * along with the Ubicom32 Linux Kernel Port. If not,
24417 + * see <http://www.gnu.org/licenses/>.
24418 + *
24419 + * Ubicom32 implementation derived from (with many thanks):
24420 + * arch/m68knommu
24421 + * arch/blackfin
24422 + * arch/parisc
24423 + */
24424 +
24425 +#include <linux/profile.h>
24426 +#include <linux/smp.h>
24427 +#include <asm/ip5000.h>
24428 +#include <asm/machdep.h>
24429 +
24430 +/*
24431 + * A bitmap of the timers on the processor indicates
24432 + * that the timer is free or in-use.
24433 + */
24434 +static unsigned int timers;
24435 +
24436 +/*
24437 + * timer_set()
24438 + * Init the specified compare register to go off <n> cycles from now.
24439 + */
24440 +void timer_set(int timervector, unsigned int cycles)
24441 +{
24442 + int idx = UBICOM32_VECTOR_TO_TIMER_INDEX(timervector);
24443 + UBICOM32_IO_TIMER->syscom[idx] =
24444 + UBICOM32_IO_TIMER->sysval + cycles;
24445 + ldsr_enable_vector(timervector);
24446 +}
24447 +
24448 +/*
24449 + * timer_reset()
24450 + * Set/reset the timer to go off again.
24451 + *
24452 + * Because sysval is a continuous timer, this function is able
24453 + * to ensure that we do not have clock sku by using the previous
24454 + * value in syscom to set the next value for syscom.
24455 + *
24456 + * Returns the number of ticks that transpired since the last event.
24457 + */
24458 +int timer_reset(int timervector, unsigned int cycles)
24459 +{
24460 + /*
24461 + * Reset the timer in the LDSR thread to go off appropriately.
24462 + *
24463 + * Use the previous value of the timer to calculate the new stop
24464 + * time. This allows us to account for it taking an
24465 + * indeterminate amount of time to get here.
24466 + */
24467 + const int timer_index = UBICOM32_VECTOR_TO_TIMER_INDEX(timervector);
24468 + unsigned int prev = UBICOM32_IO_TIMER->syscom[timer_index];
24469 + unsigned int next = prev + cycles;
24470 + int scratchpad3;
24471 + int diff;
24472 + int ticks = 1;
24473 +
24474 + /*
24475 + * If the difference is negative, we have missed at least one
24476 + * timer tick.
24477 + *
24478 + * TODO: Decide if we want to "ignore" time (as done below) or
24479 + * if we want to process time (unevenly) by calling timer_tick()
24480 + * lost_ticks times.
24481 + */
24482 + while (1) {
24483 + /*
24484 + * Set our future time first.
24485 + */
24486 + UBICOM32_IO_TIMER->syscom[timer_index] = next;
24487 +
24488 + /*
24489 + * Then check if we are really set time in the futrue.
24490 + */
24491 + diff = (int)next - (int)UBICOM32_IO_TIMER->sysval;
24492 + if (diff >= 0) {
24493 + break;
24494 + }
24495 +
24496 + /*
24497 + * Oops, we are too slow. Playing catch up.
24498 + *
24499 + * If the debugger is connected the there is a good
24500 + * chance that we lost time because we were in a
24501 + * break-point, so in this case we do not print out
24502 + * diagnostics.
24503 + */
24504 + asm volatile ("move.4 %0, scratchpad3"
24505 + : "=r" (scratchpad3));
24506 + if ((scratchpad3 & 0x1) == 0) {
24507 + /*
24508 + * No debugger attached, print to the console
24509 + */
24510 + printk(KERN_EMERG "diff: %d, timer has lost %u "
24511 + "ticks [rounded up]\n",
24512 + -diff,
24513 + (unsigned int)((-diff + cycles - 1) / cycles));
24514 + }
24515 +
24516 + do {
24517 + next += cycles;
24518 + diff = (int)next - (int)UBICOM32_IO_TIMER->sysval;
24519 + ticks++;
24520 + } while (diff < 0);
24521 + }
24522 + return ticks;
24523 +}
24524 +
24525 +/*
24526 + * sched_clock()
24527 + * Returns current time in nano-second units.
24528 + *
24529 + * Notes:
24530 + * 1) This is an override for the weak alias in
24531 + * kernel/sched_clock.c.
24532 + * 2) Do not use xtime_lock as this function is
24533 + * sometimes called with xtime_lock held.
24534 + * 3) We use a retry algorithm to ensure that
24535 + * we get a consistent value.
24536 + * 4) sched_clock must be overwritten if IRQ tracing
24537 + * is enabled because the default implementation uses
24538 + * the xtime_lock sequence while holding xtime_lock.
24539 + */
24540 +unsigned long long sched_clock(void)
24541 +{
24542 + unsigned long long my_jiffies;
24543 + unsigned long jiffies_top;
24544 + unsigned long jiffies_bottom;
24545 +
24546 + do {
24547 + jiffies_top = jiffies_64 >> 32;
24548 + jiffies_bottom = jiffies_64 & 0xffffffff;
24549 + } while (unlikely(jiffies_top != (unsigned long)(jiffies_64 >> 32)));
24550 +
24551 + my_jiffies = ((unsigned long long)jiffies_top << 32) | (jiffies_bottom);
24552 + return (my_jiffies - INITIAL_JIFFIES) * (NSEC_PER_SEC / HZ);
24553 +}
24554 +
24555 +/*
24556 + * timer_free()
24557 + * Free a hardware timer.
24558 + */
24559 +void timer_free(int interrupt)
24560 +{
24561 + unsigned int bit = interrupt - TIMER_INT(0);
24562 +
24563 + /*
24564 + * The timer had not been allocated.
24565 + */
24566 + BUG_ON(timers & (1 << bit));
24567 + timers |= (1 << bit);
24568 +}
24569 +
24570 +/*
24571 + * timer_alloc()
24572 + * Allocate a hardware timer.
24573 + */
24574 +int timer_alloc(void)
24575 +{
24576 + unsigned int bit = find_first_bit((unsigned long *)&timers, 32);
24577 + if (!bit) {
24578 + printk(KERN_WARNING "no more free timers\n");
24579 + return -1;
24580 + }
24581 +
24582 + timers &= ~(1 << bit);
24583 + return bit + TIMER_INT(0);
24584 +}
24585 +
24586 +/*
24587 + * time_init()
24588 + * Time init function.
24589 + */
24590 +void time_init(void)
24591 +{
24592 + /*
24593 + * Find the processor node and determine what timers are
24594 + * available for us.
24595 + */
24596 + timers = processor_timers();
24597 + if (timers == 0) {
24598 + printk(KERN_WARNING "no timers are available for Linux\n");
24599 + return;
24600 + }
24601 +
24602 +#ifdef CONFIG_GENERIC_CLOCKEVENTS
24603 + timer_device_init();
24604 +#else
24605 + timer_tick_init();
24606 +#endif
24607 +}
24608 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/timer_broadcast.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_broadcast.c
24609 --- linux-2.6.30.10/arch/ubicom32/kernel/timer_broadcast.c 1970-01-01 02:00:00.000000000 +0200
24610 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_broadcast.c 2009-12-11 11:45:11.000000000 +0200
24611 @@ -0,0 +1,102 @@
24612 +/*
24613 + * arch/ubicom32/kernel/timer_broadcast.c
24614 + * Implements a dummy clock event for each cpu.
24615 + *
24616 + * Copyright (C) 2008 Paul Mundt
24617 + * (C) Copyright 2009, Ubicom, Inc.
24618 + *
24619 + * This file is part of the Ubicom32 Linux Kernel Port.
24620 + *
24621 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
24622 + * it and/or modify it under the terms of the GNU General Public License
24623 + * as published by the Free Software Foundation, either version 2 of the
24624 + * License, or (at your option) any later version.
24625 + *
24626 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
24627 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
24628 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
24629 + * the GNU General Public License for more details.
24630 + *
24631 + * You should have received a copy of the GNU General Public License
24632 + * along with the Ubicom32 Linux Kernel Port. If not,
24633 + * see <http://www.gnu.org/licenses/>.
24634 + *
24635 + * Ubicom32 implementation derived from (with many thanks):
24636 + * arch/m68knommu
24637 + * arch/blackfin
24638 + * arch/parisc
24639 + * arch/arm
24640 + * arch/sh
24641 + */
24642 +#include <linux/init.h>
24643 +#include <linux/kernel.h>
24644 +#include <linux/delay.h>
24645 +#include <linux/device.h>
24646 +#include <linux/smp.h>
24647 +#include <linux/jiffies.h>
24648 +#include <linux/percpu.h>
24649 +#include <linux/clockchips.h>
24650 +#include <linux/irq.h>
24651 +
24652 +static DEFINE_PER_CPU(struct clock_event_device, local_clockevent);
24653 +
24654 +/*
24655 + * The broadcast trick only works when the timer will be used in a periodic mode.
24656 + * If the user has configured either NO_HZ or HIGH_RES_TIMERS they must have
24657 + * a per cpu timer.
24658 + */
24659 +#if defined(CONFIG_NO_HZ) || defined(CONFIG_HIGH_RES_TIMERS)
24660 +#error "Tickless and High Resolution Timers require per-CPU local timers: CONFIG_LOCAL_TIMERS"
24661 +#endif
24662 +
24663 +/*
24664 + * local_timer_interrupt()
24665 + * Used on SMP for local timer interrupt sent via an IPI.
24666 + */
24667 +void local_timer_interrupt(void)
24668 +{
24669 + struct clock_event_device *dev = &__get_cpu_var(local_clockevent);
24670 +
24671 + dev->event_handler(dev);
24672 +}
24673 +
24674 +/*
24675 + * dummy_timer_set_next_event()
24676 + * Cause the timer to go off "cycles" from now.
24677 + */
24678 +static int dummy_timer_set_next_event(unsigned long cycles, struct clock_event_device *dev)
24679 +{
24680 + return 0;
24681 +}
24682 +
24683 +/*
24684 + * dummy_timer_set_mode()
24685 + * Do Nothing.
24686 + */
24687 +static void dummy_timer_set_mode(enum clock_event_mode mode,
24688 + struct clock_event_device *clk)
24689 +{
24690 +}
24691 +
24692 +/*
24693 + * local_timer_setup()
24694 + * Adds a clock event for the specified cpu.
24695 + */
24696 +int __cpuinit local_timer_setup(unsigned int cpu)
24697 +{
24698 + struct clock_event_device *dev = &per_cpu(local_clockevent, cpu);
24699 +
24700 + dev->name = "timer-dummy";
24701 + dev->features = CLOCK_EVT_FEAT_DUMMY;
24702 + dev->rating = 200;
24703 + dev->mult = 1;
24704 + dev->set_mode = dummy_timer_set_mode;
24705 + dev->set_next_event = dummy_timer_set_next_event;
24706 + dev->broadcast = smp_timer_broadcast;
24707 + dev->cpumask = cpumask_of_cpu(cpu);
24708 + dev->irq = -1;
24709 + printk(KERN_NOTICE "timer[%d]: %s - created\n", dev->irq, dev->name);
24710 +
24711 + clockevents_register_device(dev);
24712 + return 0;
24713 +}
24714 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/timer_device.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_device.c
24715 --- linux-2.6.30.10/arch/ubicom32/kernel/timer_device.c 1970-01-01 02:00:00.000000000 +0200
24716 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_device.c 2009-12-11 11:45:11.000000000 +0200
24717 @@ -0,0 +1,301 @@
24718 +/*
24719 + * arch/ubicom32/kernel/timer_device.c
24720 + * Implements a Ubicom32 clock device and event devices.
24721 + *
24722 + * (C) Copyright 2009, Ubicom, Inc.
24723 + *
24724 + * This file is part of the Ubicom32 Linux Kernel Port.
24725 + *
24726 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
24727 + * it and/or modify it under the terms of the GNU General Public License
24728 + * as published by the Free Software Foundation, either version 2 of the
24729 + * License, or (at your option) any later version.
24730 + *
24731 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
24732 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
24733 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
24734 + * the GNU General Public License for more details.
24735 + *
24736 + * You should have received a copy of the GNU General Public License
24737 + * along with the Ubicom32 Linux Kernel Port. If not,
24738 + * see <http://www.gnu.org/licenses/>.
24739 + *
24740 + * Ubicom32 implementation derived from (with many thanks):
24741 + * arch/m68knommu
24742 + * arch/blackfin
24743 + * arch/parisc
24744 + */
24745 +#include <linux/types.h>
24746 +#include <linux/clockchips.h>
24747 +#include <linux/clocksource.h>
24748 +#include <linux/spinlock.h>
24749 +#include <asm/ip5000.h>
24750 +#include <asm/machdep.h>
24751 +
24752 +#if defined(CONFIG_SMP)
24753 +#include <asm/smp.h>
24754 +#endif
24755 +
24756 +#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
24757 +#define MAX_TIMERS (2 + CONFIG_TIMER_EXTRA_ALLOC)
24758 +#else
24759 +#define MAX_TIMERS (NR_CPUS + CONFIG_TIMER_EXTRA_ALLOC)
24760 +#endif
24761 +
24762 +#if (MAX_TIMERS > 10)
24763 +#error "Ubicom32 only has 10 timers"
24764 +#endif
24765 +
24766 +static unsigned int frequency;
24767 +static struct clock_event_device timer_device_devs[MAX_TIMERS];
24768 +static struct irqaction timer_device_irqs[MAX_TIMERS];
24769 +static int timer_device_next_timer = 0;
24770 +
24771 +DEFINE_SPINLOCK(timer_device_lock);
24772 +
24773 +/*
24774 + * timer_device_set_next_event()
24775 + * Cause the timer to go off "cycles" from now.
24776 + */
24777 +static int timer_device_set_next_event(unsigned long cycles, struct clock_event_device *dev)
24778 +{
24779 + timer_set(dev->irq, cycles);
24780 + return 0;
24781 +}
24782 +
24783 +/*
24784 + * timer_device_set_mode()
24785 + * Handle the mode switch for a clock event device.
24786 + */
24787 +static void timer_device_set_mode(enum clock_event_mode mode, struct clock_event_device *dev)
24788 +{
24789 + switch (mode) {
24790 + case CLOCK_EVT_MODE_SHUTDOWN:
24791 + /*
24792 + * Make sure the vector is disabled
24793 + * until the next event is set.
24794 + */
24795 + printk(KERN_NOTICE "timer[%d]: shutdown\n", dev->irq);
24796 + ldsr_disable_vector(dev->irq);
24797 + break;
24798 +
24799 + case CLOCK_EVT_MODE_ONESHOT:
24800 + /*
24801 + * Make sure the vector is disabled
24802 + * until the next event is set.
24803 + */
24804 + printk(KERN_NOTICE "timer[%d]: oneshot\n", dev->irq);
24805 + ldsr_disable_vector(dev->irq);
24806 + break;
24807 +
24808 + case CLOCK_EVT_MODE_PERIODIC:
24809 + /*
24810 + * The periodic request is 1 per jiffies
24811 + */
24812 + printk(KERN_NOTICE "timer[%d]: periodic: %d cycles\n",
24813 + dev->irq, frequency / CONFIG_HZ);
24814 + timer_set(dev->irq, frequency / CONFIG_HZ);
24815 + break;
24816 +
24817 + case CLOCK_EVT_MODE_UNUSED:
24818 + case CLOCK_EVT_MODE_RESUME:
24819 + printk(KERN_WARNING "timer[%d]: unimplemented mode: %d\n",
24820 + dev->irq, mode);
24821 + break;
24822 + };
24823 +}
24824 +
24825 +/*
24826 + * timer_device_event()
24827 + * Call the device's event handler.
24828 + *
24829 + * The pointer is initialized by the generic Linux code
24830 + * to the function to be called.
24831 + */
24832 +static irqreturn_t timer_device_event(int irq, void *dev_id)
24833 +{
24834 + struct clock_event_device *dev = (struct clock_event_device *)dev_id;
24835 +
24836 + if (dev->mode == CLOCK_EVT_MODE_PERIODIC) {
24837 + /*
24838 + * The periodic request is 1 per jiffies
24839 + */
24840 + timer_reset(dev->irq, frequency / CONFIG_HZ);
24841 + } else {
24842 + /*
24843 + * The timer will go off again at the rollover
24844 + * point. We must disable the IRQ to prevent
24845 + * getting a spurious interrupt.
24846 + */
24847 + ldsr_disable_vector(dev->irq);
24848 + }
24849 +
24850 + if (!dev->event_handler) {
24851 + printk(KERN_CRIT "no registered event handler\n");
24852 + return IRQ_HANDLED;
24853 + }
24854 +
24855 + dev->event_handler(dev);
24856 + return IRQ_HANDLED;
24857 +}
24858 +
24859 +/*
24860 + * timer_device_clockbase_read()
24861 + * Provide a primary clocksource around the sysval timer.
24862 + */
24863 +static cycle_t timer_device_clockbase_read(void)
24864 +{
24865 + return (cycle_t)UBICOM32_IO_TIMER->sysval;
24866 +}
24867 +
24868 +/*
24869 + * Primary Clock Source Description
24870 + *
24871 + * We use 24 for the shift factor because we want
24872 + * to ensure there are less than 2^24 clocks
24873 + * in a jiffie of 10 ms.
24874 + */
24875 +static struct clocksource timer_device_clockbase = {
24876 + .name = "sysval",
24877 + .rating = 400,
24878 + .flags = CLOCK_SOURCE_IS_CONTINUOUS,
24879 + .mask = CLOCKSOURCE_MASK(32),
24880 + .shift = 24,
24881 + .mult = 0,
24882 + .read = timer_device_clockbase_read,
24883 +};
24884 +
24885 +/*
24886 + * timer_device_alloc_event()
24887 + * Allocate a timer device event.
24888 + */
24889 +static int timer_device_alloc_event(const char *name, int cpuid, const cpumask_t *mask)
24890 +{
24891 + struct clock_event_device *dev;
24892 + struct irqaction *action;
24893 +
24894 + /*
24895 + * Are we out of configured timers?
24896 + */
24897 + spin_lock(&timer_device_lock);
24898 + if (timer_device_next_timer >= MAX_TIMERS) {
24899 + spin_unlock(&timer_device_lock);
24900 + printk(KERN_WARNING "out of timer event entries\n");
24901 + return -1;
24902 + }
24903 + dev = &timer_device_devs[timer_device_next_timer];
24904 + action = &timer_device_irqs[timer_device_next_timer];
24905 + timer_device_next_timer++;
24906 + spin_unlock(&timer_device_lock);
24907 +
24908 + /*
24909 + * Now allocate a timer to ourselves.
24910 + */
24911 + dev->irq = timer_alloc();
24912 + if (dev->irq == -1) {
24913 + spin_lock(&timer_device_lock);
24914 + timer_device_next_timer--;
24915 + spin_unlock(&timer_device_lock);
24916 + printk(KERN_WARNING "out of hardware timers\n");
24917 + return -1;
24918 + }
24919 +
24920 + /*
24921 + * Init the IRQ action structure. Make sure
24922 + * this in place before you register the clock
24923 + * event device.
24924 + */
24925 + action->name = name;
24926 + action->flags = IRQF_DISABLED | IRQF_TIMER;
24927 + action->handler = timer_device_event;
24928 + cpumask_copy(&action->mask, mask);
24929 + action->dev_id = dev;
24930 + setup_irq(dev->irq, action);
24931 + irq_set_affinity(dev->irq, mask);
24932 + ldsr_disable_vector(dev->irq);
24933 +
24934 + /*
24935 + * init clock dev structure.
24936 + *
24937 + * The min_delta_ns is chosen to ensure that setting next
24938 + * event will never be requested with too small of value.
24939 + */
24940 + dev->name = name;
24941 + dev->rating = timer_device_clockbase.rating;
24942 + dev->shift = timer_device_clockbase.shift;
24943 + dev->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;
24944 + dev->set_mode = timer_device_set_mode;
24945 + dev->set_next_event = timer_device_set_next_event;
24946 + dev->mult = div_sc(frequency, NSEC_PER_SEC, dev->shift);
24947 + dev->max_delta_ns = clockevent_delta2ns(0xffffffff, dev);
24948 + dev->min_delta_ns = clockevent_delta2ns(100, dev);
24949 + dev->cpumask = mask;
24950 + printk(KERN_NOTICE "timer[%d]: %s - created\n", dev->irq, dev->name);
24951 +
24952 + /*
24953 + * Now register the device.
24954 + */
24955 + clockevents_register_device(dev);
24956 + return dev->irq;
24957 +}
24958 +
24959 +#if defined(CONFIG_LOCAL_TIMERS)
24960 +/*
24961 + * local_timer_setup()
24962 + * Allocation function for creating a per cpu local timer.
24963 + */
24964 +int __cpuinit local_timer_setup(unsigned int cpu)
24965 +{
24966 + return timer_device_alloc_event("timer-cpu", cpu, cpumask_of(cpu));
24967 +}
24968 +#endif
24969 +
24970 +/*
24971 + * timer_device_init()
24972 + * Create and init a generic clock driver for Ubicom32.
24973 + */
24974 +void timer_device_init(void)
24975 +{
24976 + int i;
24977 +
24978 + /*
24979 + * Get the frequency from the processor device tree node or use
24980 + * the default if not available. We will store this as the frequency
24981 + * of the timer to avoid future calculations.
24982 + */
24983 + frequency = processor_frequency();
24984 + if (frequency == 0) {
24985 + frequency = CLOCK_TICK_RATE;
24986 + }
24987 +
24988 + /*
24989 + * Setup the primary clock source around sysval. Linux does not
24990 + * supply a Mhz multiplier so convert down to khz.
24991 + */
24992 + timer_device_clockbase.mult =
24993 + clocksource_khz2mult(frequency / 1000,
24994 + timer_device_clockbase.shift);
24995 + if (clocksource_register(&timer_device_clockbase)) {
24996 + printk(KERN_ERR "timer: clocksource failed to register\n");
24997 + return;
24998 + }
24999 +
25000 + /*
25001 + * Always allocate a primary timer.
25002 + */
25003 + timer_device_alloc_event("timer-primary", -1, CPU_MASK_ALL_PTR);
25004 +
25005 +#if defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
25006 + /*
25007 + * If BROADCAST is selected we need to add a broadcast timer.
25008 + */
25009 + timer_device_alloc_event("timer-broadcast", -1, CPU_MASK_ALL_PTR);
25010 +#endif
25011 +
25012 + /*
25013 + * Allocate extra timers that are requested.
25014 + */
25015 + for (i = 0; i < CONFIG_TIMER_EXTRA_ALLOC; i++) {
25016 + timer_device_alloc_event("timer-extra", -1, CPU_MASK_ALL_PTR);
25017 + }
25018 +}
25019 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/timer_tick.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_tick.c
25020 --- linux-2.6.30.10/arch/ubicom32/kernel/timer_tick.c 1970-01-01 02:00:00.000000000 +0200
25021 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/timer_tick.c 2009-12-11 11:45:11.000000000 +0200
25022 @@ -0,0 +1,109 @@
25023 +/*
25024 + * arch/ubicom32/kernel/timer_tick.c
25025 + * Impelemets a perodic timer.
25026 + *
25027 + * (C) Copyright 2009, Ubicom, Inc.
25028 + * Copyright (C) 1991, 1992, 1995 Linus Torvalds
25029 + *
25030 + * This file is part of the Ubicom32 Linux Kernel Port.
25031 + *
25032 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
25033 + * it and/or modify it under the terms of the GNU General Public License
25034 + * as published by the Free Software Foundation, either version 2 of the
25035 + * License, or (at your option) any later version.
25036 + *
25037 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
25038 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
25039 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
25040 + * the GNU General Public License for more details.
25041 + *
25042 + * You should have received a copy of the GNU General Public License
25043 + * along with the Ubicom32 Linux Kernel Port. If not,
25044 + * see <http://www.gnu.org/licenses/>.
25045 + *
25046 + * Ubicom32 implementation derived from (with many thanks):
25047 + * arch/m68knommu
25048 + * arch/blackfin
25049 + * arch/parisc
25050 + */
25051 +
25052 +#include <linux/profile.h>
25053 +
25054 +#include <asm/ip5000.h>
25055 +#include <asm/machdep.h>
25056 +#if defined(CONFIG_SMP)
25057 +#include <asm/smp.h>
25058 +#endif
25059 +
25060 +static unsigned int timervector;
25061 +static unsigned int frequency;
25062 +
25063 +/*
25064 + * timer_tick()
25065 + * Kernel system timer support. Needs to keep up the real-time clock,
25066 + * as well as call the "do_timer()" routine every clocktick.
25067 + */
25068 +static irqreturn_t timer_tick(int irq, void *dummy)
25069 +{
25070 + int ticks;
25071 +
25072 + BUG_ON(!irqs_disabled());
25073 + ticks = timer_reset(timervector, frequency);
25074 +
25075 + write_seqlock(&xtime_lock);
25076 + do_timer(ticks);
25077 + write_sequnlock(&xtime_lock);
25078 +
25079 + update_process_times(user_mode(get_irq_regs()));
25080 + profile_tick(CPU_PROFILING);
25081 +
25082 +#if defined(CONFIG_SMP)
25083 + smp_send_timer_all();
25084 +#endif
25085 + return(IRQ_HANDLED);
25086 +}
25087 +
25088 +/*
25089 + * Data used by setup_irq for the timer.
25090 + */
25091 +static struct irqaction timer_irq = {
25092 + .name = "timer",
25093 + .flags = IRQF_DISABLED | IRQF_TIMER,
25094 + .handler = timer_tick,
25095 +};
25096 +
25097 +/*
25098 + * timer_tick_init()
25099 + * Implements a periodic timer
25100 + *
25101 + * This implementation directly calls the timer_tick() and move
25102 + * the Linux kernel forward. This is used when the user has not
25103 + * selected GENERIC_CLOCKEVENTS.
25104 + */
25105 +void timer_tick_init(void)
25106 +{
25107 + /*
25108 + * Now allocate a timer to ourselves.
25109 + */
25110 + timervector = timer_alloc();
25111 + if (timervector == -1) {
25112 + printk(KERN_WARNING "where did the timer go?\n");
25113 + return;
25114 + }
25115 +
25116 + setup_irq(timervector, &timer_irq);
25117 +
25118 + /*
25119 + * Get the frequency from the processor device tree node or use
25120 + * the default if not available. We will store this as the frequency
25121 + * of the timer to avoid future calculations.
25122 + */
25123 + frequency = processor_frequency();
25124 + if (frequency == 0) {
25125 + frequency = CLOCK_TICK_RATE;
25126 + }
25127 + frequency /= CONFIG_HZ;
25128 +
25129 + printk(KERN_NOTICE "timer will interrupt every: %d cycles\n", frequency);
25130 + timer_set(timervector, frequency);
25131 +}
25132 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/topology.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/topology.c
25133 --- linux-2.6.30.10/arch/ubicom32/kernel/topology.c 1970-01-01 02:00:00.000000000 +0200
25134 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/topology.c 2009-12-11 11:45:11.000000000 +0200
25135 @@ -0,0 +1,47 @@
25136 +/*
25137 + * arch/ubicom32/kernel/topology.c
25138 + * Ubicom32 architecture sysfs topology information.
25139 + *
25140 + * (C) Copyright 2009, Ubicom, Inc.
25141 + *
25142 + * This file is part of the Ubicom32 Linux Kernel Port.
25143 + *
25144 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
25145 + * it and/or modify it under the terms of the GNU General Public License
25146 + * as published by the Free Software Foundation, either version 2 of the
25147 + * License, or (at your option) any later version.
25148 + *
25149 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
25150 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
25151 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
25152 + * the GNU General Public License for more details.
25153 + *
25154 + * You should have received a copy of the GNU General Public License
25155 + * along with the Ubicom32 Linux Kernel Port. If not,
25156 + * see <http://www.gnu.org/licenses/>.
25157 + *
25158 + * Ubicom32 implementation derived from (with many thanks):
25159 + * arch/m68knommu
25160 + * arch/blackfin
25161 + * arch/parisc
25162 + */
25163 +
25164 +#include <linux/init.h>
25165 +#include <linux/smp.h>
25166 +#include <linux/cpu.h>
25167 +#include <linux/cache.h>
25168 +
25169 +static struct cpu cpu_devices[NR_CPUS] __read_mostly;
25170 +
25171 +static int __init topology_init(void)
25172 +{
25173 + int num;
25174 +
25175 + for_each_present_cpu(num) {
25176 + cpu_devices[num].hotpluggable = 0;
25177 + register_cpu(&cpu_devices[num], num);
25178 + }
25179 + return 0;
25180 +}
25181 +
25182 +subsys_initcall(topology_init);
25183 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/traps.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/traps.c
25184 --- linux-2.6.30.10/arch/ubicom32/kernel/traps.c 1970-01-01 02:00:00.000000000 +0200
25185 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/traps.c 2009-12-11 11:45:11.000000000 +0200
25186 @@ -0,0 +1,514 @@
25187 +/*
25188 + * arch/ubicom32/kernel/traps.c
25189 + * Ubicom32 architecture trap handling support.
25190 + *
25191 + * (C) Copyright 2009, Ubicom, Inc.
25192 + *
25193 + * This file is part of the Ubicom32 Linux Kernel Port.
25194 + *
25195 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
25196 + * it and/or modify it under the terms of the GNU General Public License
25197 + * as published by the Free Software Foundation, either version 2 of the
25198 + * License, or (at your option) any later version.
25199 + *
25200 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
25201 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
25202 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
25203 + * the GNU General Public License for more details.
25204 + *
25205 + * You should have received a copy of the GNU General Public License
25206 + * along with the Ubicom32 Linux Kernel Port. If not,
25207 + * see <http://www.gnu.org/licenses/>.
25208 + *
25209 + * Ubicom32 implementation derived from (with many thanks):
25210 + * arch/m68knommu
25211 + * arch/blackfin
25212 + * arch/parisc
25213 + */
25214 +
25215 +/*
25216 + * Sets up all exception vectors
25217 + */
25218 +#include <linux/sched.h>
25219 +#include <linux/signal.h>
25220 +#include <linux/kernel.h>
25221 +#include <linux/mm.h>
25222 +#include <linux/module.h>
25223 +#include <linux/types.h>
25224 +#include <linux/a.out.h>
25225 +#include <linux/user.h>
25226 +#include <linux/string.h>
25227 +#include <linux/linkage.h>
25228 +#include <linux/init.h>
25229 +#include <linux/ptrace.h>
25230 +#include <linux/kallsyms.h>
25231 +#include <linux/compiler.h>
25232 +#include <linux/stacktrace.h>
25233 +#include <linux/personality.h>
25234 +
25235 +#include <asm/uaccess.h>
25236 +#include <asm/stacktrace.h>
25237 +#include <asm/devtree.h>
25238 +#include <asm/setup.h>
25239 +#include <asm/fpu.h>
25240 +#include <asm/system.h>
25241 +#include <asm/traps.h>
25242 +#include <asm/pgtable.h>
25243 +#include <asm/processor.h>
25244 +#include <asm/machdep.h>
25245 +#include <asm/siginfo.h>
25246 +#include <asm/ip5000.h>
25247 +#include <asm/thread.h>
25248 +
25249 +#define TRAP_MAX_STACK_DEPTH 20
25250 +
25251 +/*
25252 + * These symbols are filled in by the linker.
25253 + */
25254 +extern unsigned long _stext;
25255 +extern unsigned long _etext;
25256 +
25257 +extern unsigned long __ocm_text_run_begin;
25258 +extern unsigned long __data_begin;
25259 +
25260 +extern void show_vmas(struct task_struct *task);
25261 +
25262 +const char *trap_cause_strings[] = {
25263 + /*0*/ "inst address decode error",
25264 + /*1*/ "inst sync error",
25265 + /*2*/ "inst illegal",
25266 + /*3*/ "src1 address decode error",
25267 + /*4*/ "dst address decode error",
25268 + /*5*/ "src1 alignment error",
25269 + /*6*/ "dst alignment error",
25270 + /*7*/ "src1 sync error",
25271 + /*8*/ "dst sync error",
25272 + /*9*/ "DCAPT error",
25273 + /*10*/ "inst range error",
25274 + /*11*/ "src1 range error",
25275 + /*12*/ "dst range error",
25276 +};
25277 +
25278 +/*
25279 + * The device tree trap node definition.
25280 + */
25281 +struct trapnode {
25282 + struct devtree_node dn;
25283 + unsigned int intthread;
25284 +};
25285 +
25286 +static struct trapnode *tn;;
25287 +
25288 +/*
25289 + * trap_interrupt_handler()
25290 + * Software Interrupt to ensure that a trap is serviced.
25291 + */
25292 +static irqreturn_t trap_interrupt_handler(int irq, void *dummy)
25293 +{
25294 + /* Do Nothing */
25295 + return IRQ_HANDLED;
25296 +}
25297 +
25298 +/*
25299 + * Data used by setup_irq for the timer.
25300 + */
25301 +static struct irqaction trap_irq = {
25302 + .name = "trap",
25303 + .flags = IRQF_DISABLED,
25304 + .handler = trap_interrupt_handler,
25305 +};
25306 +
25307 +/*
25308 + * trap_cause_to_str()
25309 + * Convert a trap_cause into a series of printk
25310 + */
25311 +static void trap_cause_to_str(long status)
25312 +{
25313 + int bit;
25314 +
25315 + if ((status & ((1 << TRAP_CAUSE_TOTAL) - 1)) == 0) {
25316 + printk(KERN_NOTICE "decode: UNKNOWN CAUSES\n");
25317 + return;
25318 + }
25319 +
25320 + for (bit = 0; bit < TRAP_CAUSE_TOTAL; bit++) {
25321 + if (status & (1 << bit)) {
25322 + printk(KERN_NOTICE "\tdecode: %08x %s\n",
25323 + 1 << bit, trap_cause_strings[bit]);
25324 + }
25325 + }
25326 +}
25327 +
25328 +/*
25329 + * trap_print_information()
25330 + * Print the cause of the trap and additional info.
25331 + */
25332 +static void trap_print_information(const char *str, struct pt_regs *regs)
25333 +{
25334 + printk(KERN_WARNING "\n");
25335 +
25336 + if (current) {
25337 + printk(KERN_WARNING "Process %s (pid: %d)\n",
25338 + current->comm, current->pid);
25339 + }
25340 +
25341 + if (current && current->mm) {
25342 + printk(KERN_NOTICE "text = 0x%p-0x%p data = 0x%p-0x%p\n"
25343 + KERN_NOTICE "bss = 0x%p-0x%p user-stack = 0x%p\n"
25344 + KERN_NOTICE "\n",
25345 + (void *)current->mm->start_code,
25346 + (void *)current->mm->end_code,
25347 + (void *)current->mm->start_data,
25348 + (void *)current->mm->end_data,
25349 + (void *)current->mm->end_data,
25350 + (void *)current->mm->brk,
25351 + (void *)current->mm->start_stack);
25352 + }
25353 +
25354 + printk(KERN_WARNING "%s: Causes: 0x%08x\n", str,
25355 + (unsigned int)regs->trap_cause);
25356 + trap_cause_to_str(regs->trap_cause);
25357 + show_regs(regs);
25358 + show_stack(NULL, (unsigned long *)regs->an[7]);
25359 + printk(KERN_NOTICE "--- End Trap --- \n");
25360 +}
25361 +
25362 +/*
25363 + * dump_stack()
25364 + * Dump the stack of the current task.
25365 + */
25366 +void dump_stack(void)
25367 +{
25368 + show_stack(NULL, NULL);
25369 +}
25370 +EXPORT_SYMBOL(dump_stack);
25371 +
25372 +/*
25373 + * show_stack()
25374 + * Print out information from the current stack.
25375 + */
25376 +void show_stack(struct task_struct *task, unsigned long *sp)
25377 +{
25378 + /*
25379 + * Allocate just enough entries on the stack.
25380 + */
25381 + unsigned int calls[TRAP_MAX_STACK_DEPTH];
25382 + unsigned long code_start;
25383 + unsigned long code_end;
25384 + unsigned long ocm_code_start = (unsigned long)&__ocm_text_run_begin;
25385 + unsigned long ocm_code_end = (unsigned long)&__data_begin;
25386 + unsigned long stack_end = (unsigned long)(current->stack + THREAD_SIZE - 8);
25387 + unsigned long stack = (unsigned long)sp;
25388 + int kernel_stack = 1;
25389 +
25390 + processor_dram(&code_start, &code_end);
25391 +
25392 + /*
25393 + * Which task are we talking about.
25394 + */
25395 + if (!task) {
25396 + task = current;
25397 + }
25398 +
25399 + /*
25400 + * Find the stack for the task if one was not specified. Otherwise
25401 + * use the specified stack.
25402 + */
25403 + if (!stack) {
25404 + if (task != current) {
25405 + stack = task->thread.sp;
25406 + stack_end = (unsigned long)task->stack + THREAD_SIZE - 8;
25407 + } else {
25408 + asm volatile (
25409 + "move.4 %0, SP \n\t"
25410 + : "=r" (stack)
25411 + );
25412 + }
25413 + }
25414 +
25415 + printk(KERN_NOTICE "Starting backtrace: PID %d '%s'\n",
25416 + task->pid, task->comm);
25417 +
25418 + /*
25419 + * We do 2 passes the first pass is Kernel stack is the second
25420 + * User stack.
25421 + */
25422 + while (kernel_stack) {
25423 + unsigned long *handle;
25424 + unsigned int i, idx = 0;
25425 + struct pt_regs *pt = task_pt_regs(task);
25426 +
25427 + /*
25428 + * If the task is in user mode, reset the start
25429 + * and end values for text.
25430 + */
25431 + if (__user_mode(stack)) {
25432 + if (!(task->personality & FDPIC_FUNCPTRS)) {
25433 + printk(KERN_NOTICE " User Stack:\n");
25434 + code_start = task->mm->start_code;
25435 + code_end = task->mm->end_code;
25436 + } else {
25437 + printk(KERN_NOTICE " User Stack (fdpic):\n");
25438 + show_vmas(task);
25439 + }
25440 + stack_end = task->mm->start_stack;
25441 + ocm_code_end = ocm_code_start = 0;
25442 + kernel_stack = 0;
25443 + } else {
25444 + printk(KERN_NOTICE " Kernel Stack:\n");
25445 + }
25446 +
25447 + /*
25448 + * Collect the stack back trace information.
25449 + */
25450 + printk(" code[0x%lx-0x%lx]", code_start, code_end);
25451 + if (ocm_code_start) {
25452 + printk(" ocm_code[0x%lx-0x%lx]",
25453 + ocm_code_start, ocm_code_end);
25454 + }
25455 + printk("\n stack[0x%lx-0x%lx]\n", stack, stack_end);
25456 +
25457 + handle = (unsigned long*)stack;
25458 + while (idx < TRAP_MAX_STACK_DEPTH) {
25459 + calls[idx] = stacktrace_iterate(&handle,
25460 + code_start, code_end,
25461 + ocm_code_start, ocm_code_end,
25462 + (unsigned long)stack, stack_end);
25463 + if (calls[idx] == 0) {
25464 + break;
25465 + }
25466 + idx++;
25467 + }
25468 +
25469 + /*
25470 + * Now print out the data.
25471 + */
25472 + printk(KERN_NOTICE " CALL && CALLI on stack:");
25473 + for (i = 0; i < idx; i++) {
25474 + printk("%s0x%x, ", (i & 0x3) == 0 ? "\n " : "",
25475 + calls[i]);
25476 + }
25477 + printk(idx == TRAP_MAX_STACK_DEPTH ? "...\n" : "\n");
25478 +
25479 + /*
25480 + * If we are doing user stack we are done
25481 + */
25482 + if (!kernel_stack) {
25483 + break;
25484 + }
25485 +
25486 + /*
25487 + * Does this kernel stack have a mm (i.e. is it user)
25488 + */
25489 + if (!task->mm) {
25490 + printk("No mm for userspace stack.\n");
25491 + break;
25492 + }
25493 + /*
25494 + * Get the user-mode stack (if any)
25495 + */
25496 + stack = pt->an[7];
25497 + printk(KERN_NOTICE "Userspace stack at 0x%lx frame type %d\n",
25498 + stack, (int)pt->frame_type);
25499 + if (!__user_mode(stack)) {
25500 + break;
25501 + }
25502 + }
25503 +}
25504 +
25505 +/*
25506 + * die_if_kernel()
25507 + * Determine if we are in kernel mode and if so print stuff out and die.
25508 + */
25509 +void die_if_kernel(char *str, struct pt_regs *regs, long trap_cause)
25510 +{
25511 + unsigned int s3value;
25512 +
25513 + if (user_mode(regs)) {
25514 + return;
25515 + }
25516 +
25517 + console_verbose();
25518 + trap_print_information(str, regs);
25519 +
25520 + /*
25521 + * If the debugger is attached via the hardware mailbox protocol,
25522 + * go into an infinite loop and the debugger will figure things out.
25523 + */
25524 + asm volatile (
25525 + "move.4 %0, scratchpad3"
25526 + : "=r" (s3value)
25527 + );
25528 + if (s3value) {
25529 + asm volatile("1: jmpt.t 1b");
25530 + }
25531 +
25532 + /*
25533 + * Set the debug taint value.
25534 + */
25535 + add_taint(TAINT_DIE);
25536 + do_exit(SIGSEGV);
25537 +}
25538 +
25539 +/*
25540 + * trap_handler()
25541 + * Handle traps.
25542 + *
25543 + * Traps are treated as interrupts and registered with the LDSR. When
25544 + * the LDSR takes the interrupt, it will determine if a trap has occurred
25545 + * and service the trap prior to servicing the interrupt.
25546 + *
25547 + * This function is directly called by the LDSR.
25548 + */
25549 +void trap_handler(int irq, struct pt_regs *regs)
25550 +{
25551 + int sig = SIGSEGV;
25552 + siginfo_t info;
25553 + unsigned int trap_cause = regs->trap_cause;
25554 +
25555 + BUG_ON(!irqs_disabled());
25556 +
25557 + /*
25558 + * test if in kernel and die.
25559 + */
25560 + die_if_kernel("Kernel Trap", regs, trap_cause);
25561 +
25562 + /*
25563 + * User process problem, setup a signal for this process
25564 + */
25565 + if ((trap_cause & (1 << TRAP_CAUSE_DST_RANGE_ERR)) ||
25566 + (trap_cause & (1 << TRAP_CAUSE_SRC1_RANGE_ERR)) ||
25567 + (trap_cause & (1 << TRAP_CAUSE_I_RANGE_ERR))) {
25568 + sig = SIGSEGV;
25569 + info.si_code = SEGV_MAPERR;
25570 + } else if ((trap_cause & (1 << TRAP_CAUSE_DST_MISALIGNED)) ||
25571 + (trap_cause & (1 << TRAP_CAUSE_SRC1_MISALIGNED))) {
25572 + sig = SIGBUS;
25573 + info.si_code = BUS_ADRALN;
25574 + } else if ((trap_cause & (1 << TRAP_CAUSE_DST_DECODE_ERR)) ||
25575 + (trap_cause & (1 << TRAP_CAUSE_SRC1_DECODE_ERR))) {
25576 + sig = SIGILL;
25577 + info.si_code = ILL_ILLOPN;
25578 + } else if ((trap_cause & (1 << TRAP_CAUSE_ILLEGAL_INST))) {
25579 + /*
25580 + * Check for software break point and if found signal trap
25581 + * not illegal instruction.
25582 + */
25583 + unsigned long instruction;
25584 + if (between(regs->pc, KERNELSTART, memory_end) &&
25585 + (regs->pc & 3) == 0 &&
25586 + get_user(instruction, (unsigned long *)regs->pc) == 0) {
25587 +
25588 + /*
25589 + * This used to be 0xaabbccdd but it turns out
25590 + * that is now valid in ubicom32v4 isa so we
25591 + * have switched to 0xfabbccdd
25592 + */
25593 + if ((instruction == 0xfabbccdd) ||
25594 + (instruction == 0xaabbccdd)) {
25595 + sig = SIGTRAP;
25596 + info.si_code = TRAP_BRKPT;
25597 + goto send_signal;
25598 + }
25599 + }
25600 + sig = SIGILL;
25601 + info.si_code = ILL_ILLOPC;
25602 + } else if ((trap_cause & (1 << TRAP_CAUSE_I_DECODE_ERR))) {
25603 + sig = SIGILL;
25604 + info.si_code = ILL_ILLOPC;
25605 + } else if ((trap_cause & (1 << TRAP_CAUSE_DCAPT))) {
25606 + sig = SIGTRAP;
25607 + info.si_code = TRAP_TRACE;
25608 + }
25609 +
25610 + /*
25611 + * Print a trap information block to the console, do not
25612 + * print this above the case because we don't want it
25613 + * printed for software break points.
25614 + */
25615 + trap_print_information("User Trap", regs);
25616 +
25617 +send_signal:
25618 +
25619 + force_sig_info(sig, &info, current);
25620 +
25621 + /*
25622 + * Interrupts are disabled, re-enable them now.
25623 + */
25624 + if (!irqs_disabled()) {
25625 + printk(KERN_EMERG "interrupts enabled on exit, irq=%d, regs=%p",
25626 + irq, regs);
25627 + BUG();
25628 + }
25629 +}
25630 +
25631 +/*
25632 + * trap_init_interrupt()
25633 + * We need a 2nd trap handling init that will occur after init_IRQ().
25634 + */
25635 +void __init trap_init_interrupt(void)
25636 +{
25637 + int err;
25638 + unsigned char tirq;
25639 + struct devtree_node *dn = (struct devtree_node *)tn;
25640 +
25641 + /*
25642 + * Now setup the Software IRQ so that if a trap occurs the LDSR
25643 + * is started. The irq is there just to "force" the LDSR to run.
25644 + */
25645 + if (!tn) {
25646 + printk(KERN_WARNING "trap_init_interrupt skipped.\n");
25647 + return;
25648 + }
25649 +
25650 + err = devtree_irq(dn, NULL, &tirq);
25651 + if (err) {
25652 + printk(KERN_WARNING "error obtaining trap irq value: %d\n",
25653 + err);
25654 + return;
25655 + }
25656 +
25657 + if (tirq == DEVTREE_IRQ_NONE) {
25658 + printk(KERN_WARNING "trap irq not available: %d\n", tirq);
25659 + return;
25660 + }
25661 +
25662 + err = setup_irq(tirq, &trap_irq);
25663 + if (err) {
25664 + printk(KERN_WARNING "trap irq setup failed: %d\n", err);
25665 + return;
25666 + }
25667 +
25668 + /*
25669 + * Let ultra know which thread is handling the traps and
25670 + * what the interrupt to use is.
25671 + */
25672 + tn->intthread = ldsr_get_threadid();
25673 +
25674 + /*
25675 + * Tell the LDSR about our IRQ so that it will unsuspend
25676 + * if one occurs while waiting for the per thread lock.
25677 + */
25678 + ldsr_set_trap_irq(tirq);
25679 +}
25680 +
25681 +/*
25682 + * trap_init()
25683 + * init trap handling
25684 + *
25685 + * Trap handling is done through the ldsr. Every time an interrupt
25686 + * occurs, the LDSR looks for threads that are listed in the TRAP
25687 + * register and forces a call to the trap handler.
25688 + */
25689 +void __init trap_init(void)
25690 +{
25691 + /*
25692 + * If we do not have a trap node in the device tree, we leave the fault
25693 + * handling to the underlying hardware.
25694 + */
25695 + tn = (struct trapnode *)devtree_find_node("traps");
25696 + if (!tn) {
25697 + printk(KERN_WARNING "traps are not handled by linux\n");
25698 + return;
25699 + }
25700 +}
25701 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/uaccess.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/uaccess.c
25702 --- linux-2.6.30.10/arch/ubicom32/kernel/uaccess.c 1970-01-01 02:00:00.000000000 +0200
25703 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/uaccess.c 2009-12-11 11:45:11.000000000 +0200
25704 @@ -0,0 +1,109 @@
25705 +/*
25706 + * arch/ubicom32/include/asm/uaccess.c
25707 + * User space memory access functions for Ubicom32 architecture.
25708 + *
25709 + * (C) Copyright 2009, Ubicom, Inc.
25710 + *
25711 + * This file is part of the Ubicom32 Linux Kernel Port.
25712 + *
25713 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
25714 + * it and/or modify it under the terms of the GNU General Public License
25715 + * as published by the Free Software Foundation, either version 2 of the
25716 + * License, or (at your option) any later version.
25717 + *
25718 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
25719 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
25720 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
25721 + * the GNU General Public License for more details.
25722 + *
25723 + * You should have received a copy of the GNU General Public License
25724 + * along with the Ubicom32 Linux Kernel Port. If not,
25725 + * see <http://www.gnu.org/licenses/>.
25726 + *
25727 + * Ubicom32 implementation derived from (with many thanks):
25728 + * arch/m68knommu
25729 + * arch/blackfin
25730 + * arch/parisc
25731 + */
25732 +
25733 +#include <linux/sched.h>
25734 +#include <linux/mm.h>
25735 +#include <linux/string.h>
25736 +#include <linux/module.h>
25737 +
25738 +#include <asm/segment.h>
25739 +#include <asm/uaccess.h>
25740 +
25741 +extern int _stext, _etext, _sdata, _edata, _sbss, _ebss, _end;
25742 +
25743 +/*
25744 + * __access_ok()
25745 + * Check that the address is in the current processes.
25746 + *
25747 + * NOTE: The kernel uses "pretend" user addresses that wind
25748 + * up calling access_ok() so this approach has only marginal
25749 + * value because you wind up with lots of false positives.
25750 + */
25751 +int __access_ok(unsigned long addr, unsigned long size)
25752 +{
25753 + // struct vm_area_struct *vma;
25754 +
25755 + /*
25756 + * Don't do anything if we are not a running system yet.
25757 + */
25758 + if (system_state != SYSTEM_RUNNING) {
25759 + return 1;
25760 + }
25761 +
25762 + /*
25763 + * It appears that Linux will call this function even when we are not
25764 + * in the context of a user space application that has a VM address
25765 + * space. So we must check that current and mm are valid before
25766 + * performing the check.
25767 + */
25768 + if ((!current) || (!current->mm)) {
25769 + return 1;
25770 + }
25771 +
25772 + /*
25773 + * We perform some basic checks on the address to ensure that it
25774 + * is at least within the range of DRAM.
25775 + */
25776 + if ((addr < (int)&_etext) || (addr > memory_end)) {
25777 + printk(KERN_WARNING "pid=%d[%s]: range [%lx - %lx] not in memory area: [%lx - %lx]\n",
25778 + current->pid, current->comm,
25779 + addr, addr + size,
25780 + memory_start, memory_end);
25781 + return 0;
25782 + }
25783 +
25784 + /*
25785 + * For nommu Linux we can check this by looking at the allowed
25786 + * memory map for the process.
25787 + *
25788 + * TODO: Since the kernel passes addresses in it's own space as though
25789 + * they were user address, we can not validate the addresses this way.
25790 + */
25791 +#if 0
25792 + if (!down_read_trylock(&current->mm->mmap_sem)) {
25793 + return 1;
25794 + }
25795 + vma = find_vma(current->mm, addr);
25796 + if (!vma) {
25797 + up_read(&current->mm->mmap_sem);
25798 + printk(KERN_WARNING "pid=%d[%s]: possible invalid acesss on range: [%lx - %lx]\n",
25799 + current->pid, current->comm, addr, addr + size);
25800 + return 1;
25801 + }
25802 + if ((addr + size) > vma->vm_end) {
25803 + up_read(&current->mm->mmap_sem);
25804 + printk(KERN_WARNING "pid=%d[%s]: possible invalid length on range: [%lx - %lx]\n",
25805 + current->pid, current->comm, addr, addr + size);
25806 + return 1;
25807 + }
25808 + up_read(&current->mm->mmap_sem);
25809 +#endif
25810 + return 1;
25811 +}
25812 +
25813 +EXPORT_SYMBOL(__access_ok);
25814 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_context_switch.S linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_context_switch.S
25815 --- linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_context_switch.S 1970-01-01 02:00:00.000000000 +0200
25816 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_context_switch.S 2009-12-11 11:45:11.000000000 +0200
25817 @@ -0,0 +1,359 @@
25818 +/*
25819 + * arch/ubicom32/kernel/ubicom32_context_switch.S
25820 + * Implements context switch and return functions.
25821 + *
25822 + * (C) Copyright 2009, Ubicom, Inc.
25823 + *
25824 + * This file is part of the Ubicom32 Linux Kernel Port.
25825 + *
25826 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
25827 + * it and/or modify it under the terms of the GNU General Public License
25828 + * as published by the Free Software Foundation, either version 2 of the
25829 + * License, or (at your option) any later version.
25830 + *
25831 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
25832 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
25833 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
25834 + * the GNU General Public License for more details.
25835 + *
25836 + * You should have received a copy of the GNU General Public License
25837 + * along with the Ubicom32 Linux Kernel Port. If not,
25838 + * see <http://www.gnu.org/licenses/>.
25839 + *
25840 + * Ubicom32 implementation derived from (with many thanks):
25841 + * arch/m68knommu
25842 + * arch/blackfin
25843 + * arch/parisc
25844 + */
25845 +#include <linux/sys.h>
25846 +#include <linux/linkage.h>
25847 +#include <asm/asm-offsets.h>
25848 +#include <asm/ubicom32-common.h>
25849 +#include <asm/ip5000.h>
25850 +#include <asm/range-protect.h>
25851 +
25852 +/*
25853 + * begin_restore_context()
25854 + * Restore most of the context from sp (struct pt_reg *)
25855 + *
25856 + * This *can* be called without the global atomic lock. (because sp is
25857 + * not restored!) Only d15 and a3 are allowed to be used after this
25858 + * before calling complete_restore_context
25859 + */
25860 +.macro begin_restore_context
25861 + move.4 d0, PT_D0(sp)
25862 + move.4 d1, PT_D1(sp)
25863 + move.4 d2, PT_D2(sp)
25864 + move.4 d3, PT_D3(sp)
25865 + move.4 d4, PT_D4(sp)
25866 + move.4 d5, PT_D5(sp)
25867 + move.4 d6, PT_D6(sp)
25868 + move.4 d7, PT_D7(sp)
25869 + move.4 d8, PT_D8(sp)
25870 + move.4 d9, PT_D9(sp)
25871 + move.4 d10, PT_D10(sp)
25872 + move.4 d11, PT_D11(sp)
25873 + move.4 d12, PT_D12(sp)
25874 + move.4 d13, PT_D13(sp)
25875 + move.4 d14, PT_D14(sp)
25876 +;; move.4 d15, PT_D15(sp)
25877 + move.4 a0, PT_A0(sp)
25878 + move.4 a1, PT_A1(sp)
25879 + move.4 a2, PT_A2(sp)
25880 +;; move.4 a3, PT_A3(sp)
25881 + move.4 a4, PT_A4(sp)
25882 + move.4 a5, PT_A5(sp)
25883 + move.4 a6, PT_A6(sp)
25884 + move.4 acc0_hi, PT_ACC0HI(sp)
25885 + move.4 acc0_lo, PT_ACC0LO(sp)
25886 + move.4 mac_rc16, PT_MAC_RC16(sp)
25887 + move.4 acc1_hi, PT_ACC1HI(sp)
25888 + move.4 acc1_lo, PT_ACC1LO(sp)
25889 + move.4 source3, PT_SOURCE3(sp)
25890 + move.4 int_mask0, PT_INT_MASK0(sp)
25891 + move.4 int_mask1, PT_INT_MASK1(sp)
25892 +.endm
25893 +
25894 +/*
25895 + * complete_restore_context()
25896 + * Completely restore the context from sp (struct pt_reg *)
25897 + *
25898 + * Note: Recovered PC and CSR are saved on the stack and are to be
25899 + * popped off before returning.
25900 + */
25901 +.macro complete_restore_context
25902 + move.4 a3, sp
25903 + move.4 d15, PT_D15(sp)
25904 + move.4 sp, PT_SP(a3) ; Recover Stack pointer from save area
25905 + move.4 -4(sp)++, PT_PC(a3) ; Recover saved PC and save to stack
25906 + move.4 -4(sp)++, PT_CSR(a3) ; Recover saved csr and save to stack
25907 + move.4 a3, PT_A3(a3)
25908 +.endm
25909 +
25910 +/*
25911 + * old restore_context macro
25912 + */
25913 +.macro restore_context
25914 + begin_restore_context
25915 + complete_restore_context
25916 +.endm
25917 +
25918 +/*
25919 + * ldsr_thread_enable_interrupts()
25920 + * An assembly version of the enable interrupts function.
25921 + *
25922 + * The stack is fair game but all registers MUST be preserved.
25923 + *
25924 + */
25925 +.macro ldsr_thread_enable_interrupts
25926 + move.4 -4(sp)++, d3 ; Push d3
25927 + move.4 -4(sp)++, a3 ; Push a3
25928 +
25929 + /*
25930 + * Read the ROSR and obtain ~(1 << tid)
25931 + */
25932 + lsr.4 d3, rosr, #0x2 ; Move the thread portion of ROSR into d3
25933 + lsl.4 d3, #1, d3 ; perform a (1 << tid)
25934 + not.4 d3, d3 ; Negate the value of d3 == ~(1 << threadid)
25935 +
25936 + /*
25937 + * Get the value of the ldsr_soft_irq_mask
25938 + */
25939 + moveai a3, #%hi(ldsr_soft_irq_mask)
25940 + move.4 a3, %lo(ldsr_soft_irq_mask)(a3)
25941 +
25942 + /*
25943 + * Now re-enable interrupts for this thread and then
25944 + * wakeup the LDSR.
25945 + */
25946 + and.4 scratchpad1, scratchpad1, d3
25947 + move.4 int_set0, a3
25948 +
25949 + /*
25950 + * Restore the registers.
25951 + */
25952 + move.4 a3, (sp)4++
25953 + move.4 d3, (sp)4++
25954 +.endm
25955 +
25956 +/*
25957 + * ret_from_interrupt_to_kernel()
25958 + * RFI function that is where do_IRQ() returns to if the thread was
25959 + * in kernel space.
25960 + */
25961 + .section .text.ret_from_interrupt_to_kernel, "ax", @progbits
25962 + .global ret_from_interrupt_to_kernel
25963 +ret_from_interrupt_to_kernel:
25964 + begin_restore_context ; Restore the thread context
25965 + atomic_lock_acquire ; Enter critical section
25966 + complete_restore_context ; Restore the thread context
25967 + atomic_lock_release ; Leave critical section
25968 + ldsr_thread_enable_interrupts ; enable the threads interrupts
25969 + move.4 csr, (sp)4++ ; Restore csr from the stack
25970 + ret (sp)4++
25971 +
25972 +/*
25973 + * ret_from_interrupt_to_user()
25974 + * RFI function that is where do_IRQ() returns to if the thread was
25975 + * in user space.
25976 + *
25977 + * TODO: Do we really need the critical section handling in this code?
25978 + *
25979 + */
25980 + .section .text.ret_from_interrupt_to_user, "ax", @progbits
25981 + .global ret_from_interrupt_to_user
25982 +ret_from_interrupt_to_user:
25983 + ldsr_thread_enable_interrupts ; enable the threads interrupts
25984 + /*
25985 + * Set a1 to the thread info pointer, no need to save it as we are
25986 + * restoring userspace and will never return
25987 + */
25988 + movei d0, #(~(ASM_THREAD_SIZE-1))
25989 + and.4 a1, sp, d0
25990 +
25991 + /*
25992 + * Test if the scheduler needs to be called.
25993 + */
25994 + btst TI_FLAGS(a1), #ASM_TIF_NEED_RESCHED
25995 + jmpeq.t 2f
25996 + call a5, schedule ; Call the scheduler. I will come back here.
25997 +
25998 + /*
25999 + * See if we have pending signals and call do_signal
26000 + * if needed.
26001 + */
26002 +2:
26003 + btst TI_FLAGS(a1), #ASM_TIF_SIGPENDING ; Any signals needed?
26004 + jmpeq.t 1f
26005 +
26006 + /*
26007 + * Now call do_signal()
26008 + */
26009 + move.4 d0, #0 ; oldset pointer is NULL
26010 + move.4 d1, sp ; d1 is the regs pointer
26011 + call a5, do_signal ; Call do_signal()
26012 +
26013 + /*
26014 + * Back from do_signal(), re-enter critical section.
26015 + */
26016 +1:
26017 + begin_restore_context ; Restore the thread context
26018 + atomic_lock_acquire ; Enter critical section
26019 + call a3, __complete_and_return_to_userspace ; jump to unprotected section
26020 +
26021 +/*
26022 + * restore_all_registers()
26023 + *
26024 + * restore_all_registers will be the alternate exit route for
26025 + * preempted processes that have called a signal handler
26026 + * and are returning back to user space.
26027 + */
26028 + .section .text.restore_all_registers, "ax", @progbits
26029 + .global restore_all_registers
26030 +restore_all_registers:
26031 + begin_restore_context ; Restore the thread context
26032 + atomic_lock_acquire ; Enter critical section
26033 + call a3, __complete_and_return_to_userspace
26034 +
26035 +/*
26036 + * __complete_and_return_to_userspace
26037 + *
26038 + * restores the second half of the context and returns
26039 + * You must have the atomic lock when you call this function
26040 + */
26041 + .section .kernel_unprotected, "ax", @progbits
26042 +__complete_and_return_to_userspace:
26043 + disable_kernel_ranges_for_current d15 ; disable kernel ranges
26044 + complete_restore_context ; restore previous context
26045 + atomic_lock_release ; Leave critical section
26046 + move.4 csr, (sp)4++ ; Restore csr from the stack
26047 + ret (sp)4++
26048 +
26049 +/*
26050 + * ret_from_fork()
26051 + * Called on the child's return from fork system call.
26052 + */
26053 + .section .text.ret_from_fork, "ax", @progbits
26054 + .global ret_from_fork
26055 +ret_from_fork:
26056 + ;;; d0 contains the arg for schedule_tail
26057 + ;;; the others we don't care about as they are in PT_REGS (sp)
26058 + call a5, schedule_tail
26059 +
26060 + atomic_lock_acquire ; Enter critical section
26061 +
26062 + move.4 a3, sp
26063 + move.4 d0, PT_D0(a3) ; Restore D0
26064 + move.4 d1, PT_D1(a3) ; Restore D1
26065 + move.4 d2, PT_D2(a3) ; Restore D2
26066 + move.4 d3, PT_D3(a3) ; Restore D3
26067 + move.4 d10, PT_D10(a3) ; Restore D10
26068 + move.4 d11, PT_D11(a3) ; Restore D11
26069 + move.4 d12, PT_D12(a3) ; Restore D12
26070 + move.4 d13, PT_D13(a3) ; Restore D13
26071 + move.4 a1, PT_A1(a3) ; Restore A1
26072 + move.4 a2, PT_A2(a3) ; Restore A2
26073 + move.4 a5, PT_A5(a3) ; Restore A5
26074 + move.4 a6, PT_A6(a3) ; Restore A6
26075 + ;; I think atomic_lock_acquire could be moved here..
26076 + move.4 sp, PT_SP(a3) ; Restore sp
26077 + move.4 a4, PT_PC(a3) ; Restore pc in register a4
26078 + move.4 PT_FRAME_TYPE(a3), #0 ; Clear frame_type to indicate it is invalid.
26079 +
26080 +#ifdef CONFIG_PROTECT_KERNEL
26081 + call a3, __ret_from_fork_bottom_half
26082 + .section .kernel_unprotected, "ax", @progbits
26083 +__ret_from_fork_bottom_half:
26084 + disable_kernel_ranges_for_current d15
26085 +#endif
26086 + atomic_lock_release ; Leave critical section
26087 + calli a4, 0(a4) ; Return.
26088 +
26089 +/*
26090 + * __switch_to()
26091 + *
26092 + * Call with:
26093 + * void *__switch_to(struct task_struct *prev, struct thread_struct *prev_switch,
26094 + * struct thread_struct *next_switch)
26095 + */
26096 + .section .text.__switch_to, "ax", @progbits
26097 + .global __switch_to
26098 +__switch_to:
26099 +
26100 + /*
26101 + * Set up register a3 to point to save area.
26102 + */
26103 + movea a3, d1 ; a3 now holds prev_switch
26104 + move.4 (a3)4++, d10
26105 + move.4 (a3)4++, d11
26106 + move.4 (a3)4++, d12
26107 + move.4 (a3)4++, d13
26108 + move.4 (a3)4++, a1
26109 + move.4 (a3)4++, a2
26110 + move.4 (a3)4++, a5
26111 + move.4 (a3)4++, a6
26112 + move.4 (a3)4++, a7
26113 +
26114 + /*
26115 + * Set up register a3 to point to restore area.
26116 + */
26117 + movea a3, d2 ; a3 now holds next_switch
26118 + move.4 d10 , (a3)4++
26119 + move.4 d11 , (a3)4++
26120 + move.4 d12 , (a3)4++
26121 + move.4 d13 , (a3)4++
26122 + move.4 a1 , (a3)4++
26123 + move.4 a2 , (a3)4++
26124 + move.4 a5 , (a3)4++
26125 + move.4 a6 , (a3)4++
26126 + move.4 a7 , (a3)4++
26127 +
26128 + /*
26129 + * Load the sw_ksp with the proper thread_info pointer.
26130 + */
26131 + movei d15, #(~(ASM_THREAD_SIZE-1))
26132 + and.4 a3, sp, d15 ; a3 now has the thread info pointer
26133 + moveai a4, #%hi(sw_ksp)
26134 + lea.1 a4, %lo(sw_ksp)(a4) ; a4 now has the base address of sw_ksp array
26135 + lsr.4 d15, ROSR, #2 ; Thread number - bit's 6 through 31 are zeroes anyway.
26136 + move.4 (a4, d15), a3 ; Load the thread info pointer into the hw_ksp array..
26137 +
26138 + /*
26139 + * We are done with context switch. Time to return..
26140 + */
26141 + calli a5, 0(a5)
26142 + .size __switch_to, . - __switch_to
26143 +
26144 +/*
26145 + * ubicom32_emulate_insn()
26146 + * Emulates the instruction.
26147 + *
26148 + * Call with:
26149 + * unsigned int ubicom32_emulate_insn(int source1, int source2, int source3, int *save_acc, int *save_csr);
26150 + */
26151 + .section .text.ubicom32_emulate_insn, "ax", @progbits
26152 + .global ubicom32_emulate_insn
26153 + .global trap_emulate
26154 +ubicom32_emulate_insn:
26155 + movea a3, d3 ; a3 holds save_acc pointer
26156 + movea a4, d4 ; a4 hods save_csr pointer
26157 + move.4 source3, d2
26158 + move.4 acc0_lo, (a3)
26159 + move.4 acc0_hi, 4(a3)
26160 + move.4 acc1_lo, 8(a3)
26161 + move.4 acc1_hi, 12(a3)
26162 + move.4 mac_rc16, 16(a3)
26163 + move.4 CSR, (a4)
26164 + setcsr_flush 0
26165 +
26166 +trap_emulate:
26167 + move.4 d0, d1
26168 + setcsr_flush 0
26169 + move.4 (a4), CSR ; Save csr
26170 + move.4 (a3), acc0_lo
26171 + move.4 4(a3), acc0_hi
26172 + move.4 8(a3), acc1_lo
26173 + move.4 12(a3), acc1_hi
26174 + move.4 16(a3), mac_rc16
26175 + ret a5
26176 + .size ubicom32_emulate_insn, . - ubicom32_emulate_insn
26177 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_ksyms.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_ksyms.c
26178 --- linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_ksyms.c 1970-01-01 02:00:00.000000000 +0200
26179 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_ksyms.c 2009-12-11 11:45:11.000000000 +0200
26180 @@ -0,0 +1,98 @@
26181 +/*
26182 + * arch/ubicom32/kernel/ubicom32_ksyms.c
26183 + * Ubicom32 architecture compiler support and misc symbols.
26184 + *
26185 + * (C) Copyright 2009, Ubicom, Inc.
26186 + *
26187 + * This file is part of the Ubicom32 Linux Kernel Port.
26188 + *
26189 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
26190 + * it and/or modify it under the terms of the GNU General Public License
26191 + * as published by the Free Software Foundation, either version 2 of the
26192 + * License, or (at your option) any later version.
26193 + *
26194 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
26195 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
26196 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
26197 + * the GNU General Public License for more details.
26198 + *
26199 + * You should have received a copy of the GNU General Public License
26200 + * along with the Ubicom32 Linux Kernel Port. If not,
26201 + * see <http://www.gnu.org/licenses/>.
26202 + *
26203 + * Ubicom32 implementation derived from (with many thanks):
26204 + * arch/m68knommu
26205 + * arch/blackfin
26206 + * arch/parisc
26207 + */
26208 +#include <linux/module.h>
26209 +#include <linux/linkage.h>
26210 +#include <linux/sched.h>
26211 +#include <linux/string.h>
26212 +#include <linux/mm.h>
26213 +#include <linux/user.h>
26214 +#include <linux/elfcore.h>
26215 +#include <linux/in6.h>
26216 +#include <linux/interrupt.h>
26217 +#include <linux/io.h>
26218 +#include <linux/semaphore.h>
26219 +
26220 +#include <asm/setup.h>
26221 +#include <asm/machdep.h>
26222 +#include <asm/pgalloc.h>
26223 +#include <asm/irq.h>
26224 +#include <asm/checksum.h>
26225 +#include <asm/current.h>
26226 +
26227 +/* platform dependent support */
26228 +
26229 +EXPORT_SYMBOL(__ioremap);
26230 +EXPORT_SYMBOL(iounmap);
26231 +
26232 +EXPORT_SYMBOL(ip_fast_csum);
26233 +
26234 +
26235 +/* Networking helper routines. */
26236 +EXPORT_SYMBOL(csum_partial_copy_nocheck);
26237 +
26238 +/* The following are special because they're not called
26239 + explicitly (the C compiler generates them). Fortunately,
26240 + their interface isn't gonna change any time soon now, so
26241 + it's OK to leave it out of version control. */
26242 +EXPORT_SYMBOL(memcpy);
26243 +EXPORT_SYMBOL(memset);
26244 +EXPORT_SYMBOL(memmove);
26245 +
26246 +#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 4) || __GNUC__ > 4
26247 +/*
26248 + * libgcc functions - functions that are used internally by the
26249 + * compiler... (prototypes are not correct though, but that
26250 + * doesn't really matter since they're not versioned).
26251 + */
26252 +extern void __ashldi3(void);
26253 +extern void __ashrdi3(void);
26254 +extern void __divsi3(void);
26255 +extern void __divdi3(void);
26256 +extern void __lshrdi3(void);
26257 +extern void __modsi3(void);
26258 +extern void __muldi3(void);
26259 +extern void __udivsi3(void);
26260 +extern void __umodsi3(void);
26261 +
26262 +/* gcc lib functions */
26263 +EXPORT_SYMBOL(__ashldi3);
26264 +EXPORT_SYMBOL(__ashrdi3);
26265 +EXPORT_SYMBOL(__divsi3);
26266 +EXPORT_SYMBOL(__divdi3);
26267 +EXPORT_SYMBOL(__lshrdi3);
26268 +EXPORT_SYMBOL(__modsi3);
26269 +EXPORT_SYMBOL(__muldi3);
26270 +EXPORT_SYMBOL(__udivsi3);
26271 +EXPORT_SYMBOL(__umodsi3);
26272 +#else
26273 +extern void __libgcc_udivmodsi(void);
26274 +extern void __libgcc_divmodsi(void);
26275 +
26276 +EXPORT_SYMBOL(__libgcc_udivmodsi);
26277 +EXPORT_SYMBOL(__libgcc_divmodsi);
26278 +#endif
26279 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_syscall.S linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_syscall.S
26280 --- linux-2.6.30.10/arch/ubicom32/kernel/ubicom32_syscall.S 1970-01-01 02:00:00.000000000 +0200
26281 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/ubicom32_syscall.S 2009-12-11 11:45:11.000000000 +0200
26282 @@ -0,0 +1,694 @@
26283 +/*
26284 + * arch/ubicom32/kernel/ubicom32_syscall.S
26285 + * <TODO: Replace with short file description>
26286 + *
26287 + * (C) Copyright 2009, Ubicom, Inc.
26288 + *
26289 + * This file is part of the Ubicom32 Linux Kernel Port.
26290 + *
26291 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
26292 + * it and/or modify it under the terms of the GNU General Public License
26293 + * as published by the Free Software Foundation, either version 2 of the
26294 + * License, or (at your option) any later version.
26295 + *
26296 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
26297 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
26298 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
26299 + * the GNU General Public License for more details.
26300 + *
26301 + * You should have received a copy of the GNU General Public License
26302 + * along with the Ubicom32 Linux Kernel Port. If not,
26303 + * see <http://www.gnu.org/licenses/>.
26304 + *
26305 + * Ubicom32 implementation derived from (with many thanks):
26306 + * arch/m68knommu
26307 + * arch/blackfin
26308 + * arch/parisc
26309 + */
26310 +#include <linux/sys.h>
26311 +#include <linux/linkage.h>
26312 +#include <linux/unistd.h>
26313 +
26314 +#include <asm/ubicom32-common.h>
26315 +#include <asm/thread_info.h>
26316 +#include <asm/asm-offsets.h>
26317 +#include <asm/range-protect.h>
26318 +
26319 +/*
26320 + * __old_system_call()
26321 + */
26322 + .section .old_syscall_entry.text, "ax", @progbits
26323 +#ifdef CONFIG_OLD_40400010_SYSTEM_CALL
26324 +__old_system_call:
26325 + call a3, system_call
26326 + .size __old_system_call, . - __old_system_call ;
26327 +#else
26328 + /*
26329 + * something that will crash the userspace application, but
26330 + * should not take down the kernel, if protection is enabled
26331 + * this will never even get executed.
26332 + */
26333 + .long 0xFABBCCDE ; illegal instruction
26334 + bkpt #-1 ; we will never get here
26335 +#endif
26336 +
26337 +/*
26338 + * system_call()
26339 + */
26340 + .section .syscall_entry.text, "ax", @progbits
26341 + .global system_call
26342 +system_call:
26343 + /*
26344 + * Regular ABI rules for function calls apply for syscall. d8 holds
26345 + * the syscall number. We will use that to index into the syscall table.
26346 + * d0 - d5 hold the parameters.
26347 + *
26348 + * First we get the current thread_info and swap to the kernel stack.
26349 + * This is done by reading the current thread and looking up the ksp
26350 + * from the sw_ksp array and storing it in a3.
26351 + *
26352 + * Then we reserve space for the syscall context a struct pt_regs and
26353 + * save it using a4 initially and later as sp.
26354 + * Once sp is set to the kernel sp we can leave the critical section.
26355 + *
26356 + * For the user case the kernel stack will have the following layout.
26357 + *
26358 + * a3 ksp[0] +-----------------------+
26359 + * | Thread info area |
26360 + * | struct thread_info |
26361 + * +-----------------------+
26362 + * : :
26363 + * | Kernel Stack Area |
26364 + * | |
26365 + * a4 / sp >>> +-----------------------+
26366 + * | Context save area |
26367 + * | struct pt_reg |
26368 + * ksp[THREAD_SIZE-8] +-----------------------+
26369 + * | 8 Byte Buffer Zone |
26370 + * ksp[THREAD_SIZE] +-----------------------+
26371 +
26372 + *
26373 + * For kernel syscalls the layout is as follows.
26374 + *
26375 + * a3 ksp[0] +-----------------------+
26376 + * | Thread info area |
26377 + * | struct thread_info |
26378 + * +-----------------------+
26379 + * : :
26380 + * | Kernel Stack Area |
26381 + * | |
26382 + * a4 / sp >>> +-----------------------+
26383 + * | Context save area |
26384 + * | struct pt_reg |
26385 + * sp at syscall entry +-----------------------+
26386 + * | Callers Kernel Stack |
26387 + * : :
26388 + *
26389 + * Once the context is saved we optionally call syscall_trace and setup
26390 + * the exit routine and jump to the syscall.
26391 + */
26392 +
26393 + /*
26394 + * load the base address for sw_ksp into a3
26395 + * Note.. we cannot access it just yet as protection is still on.
26396 + */
26397 + moveai a3, #%hi(sw_ksp)
26398 + lea.1 a3, %lo(sw_ksp)(a3)
26399 +
26400 + /*
26401 + * Enter critical section .
26402 + *
26403 + * The 'critical' aspects here are the switching the to the ksp and
26404 + * changing the protection registers, these both use per thread
26405 + * information so we need to protect from a context switch. For now this
26406 + * is done using the global atomic lock.
26407 + */
26408 + atomic_lock_acquire
26409 +
26410 + thread_get_self d15 ; Load current thread number
26411 +#ifdef CONFIG_PROTECT_KERNEL
26412 + lsl.4 d9, #1, d15 ; Convert to thread bit
26413 + enable_kernel_ranges d9
26414 +#endif
26415 + /*
26416 + * in order to reduce the size of code in the syscall section we get
26417 + * out of it right now
26418 + */
26419 + call a4, __system_call_bottom_half
26420 + .size system_call, . - system_call
26421 +
26422 + .section .text.__system_call_bottom_half, "ax", @progbits
26423 +__system_call_bottom_half:
26424 +
26425 + /*
26426 + * We need to Determine if this is a kernel syscall or user syscall.
26427 + * Start by loading the pointer for the thread_info structure for the
26428 + * current process in to a3.
26429 + */
26430 + move.4 a3, (a3, d15) ; a3 = sw_ksp[d15]
26431 +
26432 + /*
26433 + * Now if this is a kernel thread the same value can be a acheived by
26434 + * masking off the lower bits on the current stack pointer.
26435 + */
26436 + movei d9, #(~(ASM_THREAD_SIZE-1)) ; load mask
26437 + and.4 d9, sp, d9 ; apply mask
26438 +
26439 + /*
26440 + * d9 now has the masked version of the sp. If this is identical to
26441 + * what is in a3 then don't switch to ksp as we are already in the
26442 + * kernel.
26443 + */
26444 + sub.4 #0, a3, d9
26445 +
26446 + /*
26447 + * if d9 and a3 are not equal. We are usespace and have to shift to
26448 + * ksp.
26449 + */
26450 + jmpne.t 1f
26451 +
26452 + /*
26453 + * Kernel Syscall.
26454 + *
26455 + * The kernel has called this routine. We have to pdec space for pt_regs
26456 + * from sp.
26457 + */
26458 + pdec a4, PT_SIZE(sp) ; a4 = ksp - PT_SIZE
26459 + jmpt.t 2f
26460 +
26461 + /*
26462 + * Userspace Syscall.
26463 + *
26464 + * Add THREAD_SIZE and subtract PT_SIZE to create the proper ksp
26465 + */
26466 +1: movei d15, #(ASM_THREAD_SIZE - 8 - PT_SIZE)
26467 + lea.1 a4, (a3, d15) ; a4 = ksp + d15
26468 +
26469 + /*
26470 + * Replace user stack pointer with kernel stack pointer (a4)
26471 + * Load -1 into frame_type in save area to indicate this is system call
26472 + * frame.
26473 + */
26474 +2: move.4 PT_A7(a4), a7 ; Save old sp/A7 on kernel stack
26475 + move.4 PT_FRAME_TYPE(a4), #-1 ; Set the frame type.
26476 + move.4 sp, a4 ; Change to ksp.
26477 + /*
26478 + * We are now officially back in the kernel!
26479 + */
26480 +
26481 + /*
26482 + * Now that we are on the ksp we can leave the critical section
26483 + */
26484 + atomic_lock_release
26485 +
26486 + /*
26487 + * We need to save a0 because we need to be able to restore it in
26488 + * the event that we need to handle a signal. It's not generally
26489 + * a callee-saved register but is the GOT pointer.
26490 + */
26491 + move.4 PT_A0(sp), a0 ; Save A0 on kernel stack
26492 +
26493 + /*
26494 + * We still need to save d10-d13, a1, a2, a5, a6 in the kernel frame
26495 + * for this process, we also save the system call params in the case of
26496 + * syscall restart. (note a7 was saved above)
26497 + */
26498 + move.4 PT_A1(sp), a1 ; Save A1 on kernel stack
26499 + move.4 PT_A2(sp), a2 ; Save A2 on kernel stack
26500 + move.4 PT_A5(sp), a5 ; Save A5 on kernel stack
26501 + move.4 PT_A6(sp), a6 ; Save A6 on kernel stack
26502 + move.4 PT_PC(sp), a5 ; Save A5 at the PC location
26503 + move.4 PT_D10(sp), d10 ; Save D10 on kernel stack
26504 + move.4 PT_D11(sp), d11 ; Save D11 on kernel stack
26505 + move.4 PT_D12(sp), d12 ; Save D12 on kernel stack
26506 + move.4 PT_D13(sp), d13 ; Save D13 on kernel stack
26507 +
26508 + /*
26509 + * Now save the syscall parameters
26510 + */
26511 + move.4 PT_D0(sp), d0 ; Save d0 on kernel stack
26512 + move.4 PT_ORIGINAL_D0(sp), d0 ; Save d0 on kernel stack
26513 + move.4 PT_D1(sp), d1 ; Save d1 on kernel stack
26514 + move.4 PT_D2(sp), d2 ; Save d2 on kernel stack
26515 + move.4 PT_D3(sp), d3 ; Save d3 on kernel stack
26516 + move.4 PT_D4(sp), d4 ; Save d4 on kernel stack
26517 + move.4 PT_D5(sp), d5 ; Save d5 on kernel stack
26518 + move.4 PT_D8(sp), d8 ; Save d8 on kernel stack
26519 +
26520 + /*
26521 + * Test if syscalls are being traced and if they are jump to syscall
26522 + * trace (it will comeback here)
26523 + */
26524 + btst TI_FLAGS(a3), #ASM_TIF_SYSCALL_TRACE
26525 + jmpne.f .Lsystem_call__trace
26526 +.Lsystem_call__trace_complete:
26527 + /*
26528 + * Check for a valid call number [ 0 <= syscall_number < NR_syscalls ]
26529 + */
26530 + cmpi d8, #0
26531 + jmplt.f 3f
26532 + cmpi d8, #NR_syscalls
26533 + jmplt.t 4f
26534 +
26535 + /*
26536 + * They have passed an invalid number. Call sys_ni_syscall staring by
26537 + * load a4 with the base address of sys_ni_syscall
26538 + */
26539 +3: moveai a4, #%hi(sys_ni_syscall)
26540 + lea.1 a4, %lo(sys_ni_syscall)(a4)
26541 + jmpt.t 5f ; Jump to regular processing
26542 +
26543 + /*
26544 + * Validated syscall, load the syscall table base address into a3 and
26545 + * read the syscall ptr out.
26546 + */
26547 +4: moveai a3, #%hi(sys_call_table)
26548 + lea.1 a3, %lo(sys_call_table)(a3) ; a3 = sys_call_table
26549 + move.4 a4, (a3, d8) ; a4 = sys_call_table[d8]
26550 +
26551 + /*
26552 + * Before calling the syscall, setup a5 so that syscall_exit is called
26553 + * on return from syscall
26554 + */
26555 +5: moveai a5, #%hi(syscall_exit) ; Setup return address
26556 + lea.1 a5, %lo(syscall_exit)(a5) ; from system call
26557 +
26558 + /*
26559 + * If the syscall is __NR_rt_rigreturn then we have to test d1 to
26560 + * figure out if we have to change change the return routine to restore
26561 + * all registers.
26562 + */
26563 + cmpi d8, #__NR_rt_sigreturn
26564 + jmpeq.f 6f
26565 +
26566 + /*
26567 + * Launch system call (it will return through a5 - syscall_exit)
26568 + */
26569 + calli a3, 0(a4)
26570 +
26571 + /*
26572 + * System call is rt_sigreturn. Test d1. If it is 1 we have to
26573 + * change the return address to restore_all_registers
26574 + */
26575 +6: cmpi d1, #1
26576 + jmpne.t 7f
26577 +
26578 + moveai a5, #%hi(restore_all_registers) ; Setup return address
26579 + lea.1 a5, %lo(restore_all_registers)(a5) ; to restore_all_registers.
26580 +
26581 + /*
26582 + * Launch system call (it will return through a5)
26583 + */
26584 +7: calli a3, 0(a4) ; Launch system call
26585 +
26586 +.Lsystem_call__trace:
26587 + /*
26588 + * Syscalls are being traced.
26589 + * Call syscall_trace, (return here)
26590 + */
26591 + call a5, syscall_trace
26592 +
26593 + /*
26594 + * Restore syscall state (it would have been discarded during the
26595 + * syscall trace)
26596 + */
26597 + move.4 d0, PT_D0(sp) ; Restore d0 from kernel stack
26598 + move.4 d1, PT_D1(sp) ; Restore d1 from kernel stack
26599 + move.4 d2, PT_D2(sp) ; Restore d2 from kernel stack
26600 + move.4 d3, PT_D3(sp) ; Restore d3 from kernel stack
26601 + move.4 d4, PT_D4(sp) ; Restore d4 from kernel stack
26602 + move.4 d5, PT_D5(sp) ; Restore d5 from kernel stack
26603 + /* add this back if we ever have a syscall with 7 args */
26604 + move.4 d8, PT_D8(sp) ; Restore d8 from kernel stack
26605 +
26606 + /*
26607 + * return to syscall
26608 + */
26609 + jmpt.t .Lsystem_call__trace_complete
26610 + .size __system_call_bottom_half, . - __system_call_bottom_half
26611 +
26612 +/*
26613 + * syscall_exit()
26614 + */
26615 + .section .text.syscall_exit
26616 + .global syscall_exit
26617 +syscall_exit:
26618 + /*
26619 + * d0 contains the return value. We should move that into the kernel
26620 + * stack d0 location. We will be transitioning from kernel to user
26621 + * mode. Test the flags and see if we have to call schedule. If we are
26622 + * going to truly exit then all that has to be done is that from the
26623 + * kernel stack we have to restore d0, a0, a1, a2, a5, a6 and sp (a7)bb
26624 + * and then return via a5.
26625 + */
26626 +
26627 + /*
26628 + * Save d0 to pt_regs
26629 + */
26630 + move.4 PT_D0(sp), d0 ; Save d0 into the kernel stack
26631 +
26632 + /*
26633 + * load the thread_info structure by masking off the THREAD_SIZE
26634 + * bits.
26635 + *
26636 + * Note: we used to push a1, but now we don't as we are going
26637 + * to eventually restore it to the userspace a1.
26638 + */
26639 + movei d9, #(~(ASM_THREAD_SIZE-1))
26640 + and.4 a1, sp, d9
26641 +
26642 + /*
26643 + * Are any interesting bits set on TI flags, if there are jump
26644 + * aside to post_processing.
26645 + */
26646 + move.4 d9, #(_TIF_SYSCALL_TRACE | _TIF_NEED_RESCHED | _TIF_SIGPENDING)
26647 + and.4 #0, TI_FLAGS(a1), d9
26648 + jmpne.f .Lsyscall_exit__post_processing ; jump to handler
26649 +.Lsyscall_exit__post_processing_complete:
26650 +
26651 + move.4 d0, PT_D0(sp) ; Restore D0 from kernel stack
26652 + move.4 d1, PT_D1(sp) ; Restore d1 from kernel stack
26653 + move.4 d2, PT_D2(sp) ; Restore d2 from kernel stack
26654 + move.4 d3, PT_D3(sp) ; Restore d3 from kernel stack
26655 + move.4 d4, PT_D4(sp) ; Restore d4 from kernel stack
26656 + move.4 d5, PT_D5(sp) ; Restore d5 from kernel stack
26657 + move.4 d8, PT_D8(sp) ; Restore d8 from kernel stack
26658 + move.4 d10, PT_D10(sp) ; Restore d10 from kernel stack
26659 + move.4 d11, PT_D11(sp) ; Restore d11 from kernel stack
26660 + move.4 d12, PT_D12(sp) ; Restore d12 from kernel stack
26661 + move.4 d13, PT_D13(sp) ; Restore d13 from kernel stack
26662 + move.4 a1, PT_A1(sp) ; Restore A1 from kernel stack
26663 + move.4 a2, PT_A2(sp) ; Restore A2 from kernel stack
26664 + move.4 a5, PT_A5(sp) ; Restore A5 from kernel stack
26665 + move.4 a6, PT_A6(sp) ; Restore A6 from kernel stack
26666 + move.4 a0, PT_A0(sp) ; Restore A6 from kernel stack
26667 +
26668 + /*
26669 + * this is only for debug, and could be removed for production builds
26670 + */
26671 + move.4 PT_FRAME_TYPE(sp), #0 ; invalidate frame_type
26672 +
26673 +#ifdef CONFIG_PROTECT_KERNEL
26674 +
26675 + call a4, __syscall_exit_bottom_half
26676 +
26677 + .section .kernel_unprotected, "ax", @progbits
26678 +__syscall_exit_bottom_half:
26679 + /*
26680 + * Enter critical section
26681 + */
26682 + atomic_lock_acquire
26683 + disable_kernel_ranges_for_current d15
26684 +#endif
26685 + /*
26686 + * Lastly restore userspace stack ptr
26687 + *
26688 + * Note: that when protection is on we need to hold the lock around the
26689 + * stack swap as well because otherwise the protection could get
26690 + * inadvertently disabled again at the end of a context switch.
26691 + */
26692 + move.4 a7, PT_A7(sp) ; Restore A7 from kernel stack
26693 +
26694 + /*
26695 + * We are now officially back in userspace!
26696 + */
26697 +
26698 +#ifdef CONFIG_PROTECT_KERNEL
26699 + /*
26700 + * Leave critical section and return to user space.
26701 + */
26702 + atomic_lock_release
26703 +#endif
26704 + calli a5, 0(a5) ; Back to userspace code.
26705 +
26706 + bkpt #-1 ; we will never get here
26707 +
26708 + /*
26709 + * Post syscall processing. (unlikely part of syscall_exit)
26710 + *
26711 + * Are we tracing syscalls. If TIF_SYSCALL_TRACE is set, call
26712 + * syscall_trace routine and return here.
26713 + */
26714 + .section .text.syscall_exit, "ax", @progbits
26715 +.Lsyscall_exit__post_processing:
26716 + btst TI_FLAGS(a1), #ASM_TIF_SYSCALL_TRACE
26717 + jmpeq.t 1f
26718 + call a5, syscall_trace
26719 +
26720 + /*
26721 + * Do we need to resched ie call schedule. If TIF_NEED_RESCHED is set,
26722 + * call the scheduler, it will come back here.
26723 + */
26724 +1: btst TI_FLAGS(a1), #ASM_TIF_NEED_RESCHED
26725 + jmpeq.t 2f
26726 + call a5, schedule
26727 +
26728 + /*
26729 + * Do we need to post a signal, if TIF_SIGPENDING is set call the
26730 + * do_signal.
26731 + */
26732 +2: btst TI_FLAGS(a1), #ASM_TIF_SIGPENDING
26733 + jmpeq.t .Lsyscall_exit__post_processing_complete
26734 +
26735 + /*
26736 + * setup the do signal call
26737 + */
26738 + move.4 d0, #0 ; oldset pointer is NULL
26739 + lea.1 d1, (sp) ; d1 is the regs pointer.
26740 + call a5, do_signal
26741 +
26742 + jmpt.t .Lsyscall_exit__post_processing_complete
26743 +
26744 +/* .size syscall_exit, . - syscall_exit */
26745 +
26746 +/*
26747 + * kernel_execve()
26748 + * kernel_execv is called when we the kernel is starting a
26749 + * userspace application.
26750 + */
26751 + .section .kernel_unprotected, "ax", @progbits
26752 + .global kernel_execve
26753 +kernel_execve:
26754 + move.4 -4(sp)++, a5 ; Save return address
26755 + /*
26756 + * Call execve
26757 + */
26758 + movei d8, #__NR_execve ; call execve
26759 + call a5, system_call
26760 + move.4 a5, (sp)4++
26761 +
26762 + /*
26763 + * protection was enabled again at syscall exit, but we want
26764 + * to return to kernel so we enable it again.
26765 + */
26766 +#ifdef CONFIG_PROTECT_KERNEL
26767 + /*
26768 + * We are entering the kernel so we need to disable the protection.
26769 + * Enter critical section, disable ranges and leave critical section.
26770 + */
26771 + call a3, __enable_kernel_ranges ; and jump back to kernel
26772 +#else
26773 + ret a5 ; jump back to the kernel
26774 +#endif
26775 +
26776 + .size kernel_execve, . - kernel_execve
26777 +
26778 +/*
26779 + * signal_trampoline()
26780 + *
26781 + * Deals with transitioning from to userspace signal handlers and returning
26782 + * to userspace, only called from the kernel.
26783 + *
26784 + */
26785 + .section .kernel_unprotected, "ax", @progbits
26786 + .global signal_trampoline
26787 +signal_trampoline:
26788 + /*
26789 + * signal_trampoline is called when we are jumping from the kernel to
26790 + * the userspace signal handler.
26791 + *
26792 + * The following registers are relevant. (set setup_rt_frame)
26793 + * sp is the user space stack not the kernel stack
26794 + * d0 = signal number
26795 + * d1 = siginfo_t *
26796 + * d2 = ucontext *
26797 + * d3 = the user space signal handler
26798 + * a0 is set to the GOT if userspace application is FDPIC, otherwise 0
26799 + * a3 is set to the FD for the signal if userspace application is FDPIC
26800 + */
26801 +#ifdef CONFIG_PROTECT_KERNEL
26802 + /*
26803 + * We are leaving the kernel so we need to enable the protection.
26804 + * Enter critical section, disable ranges and leave critical section.
26805 + */
26806 + atomic_lock_acquire ; Enter critical section
26807 + disable_kernel_ranges_for_current d15 ; disable kernel ranges
26808 + atomic_lock_release ; Leave critical section
26809 +#endif
26810 + /*
26811 + * The signal handler pointer is in register d3 so tranfer it to a4 and
26812 + * call it
26813 + */
26814 + movea a4, d3 ; signal handler
26815 + calli a5, 0(a4)
26816 +
26817 + /*
26818 + * Return to userspace through rt_syscall which is stored on top of the
26819 + * stack d1 contains ret_via_interrupt status.
26820 + */
26821 + move.4 d8, (sp) ; d8 (syscall #) = rt_syscall
26822 + move.4 d1, 4(sp) ; d1 = ret_via_interrupt
26823 + call a5, system_call ; as we are 'in' the kernel
26824 + ; we can call kernel_syscall
26825 +
26826 + bkpt #-1 ; will never get here.
26827 + .size signal_trampoline, . - signal_trampoline
26828 +
26829 +/*
26830 + * kernel_thread_helper()
26831 + *
26832 + * Entry point for kernel threads (only referenced by kernel_thread()).
26833 + *
26834 + * On execution d0 will be 0, d1 will be the argument to be passed to the
26835 + * kernel function.
26836 + * d2 contains the kernel function that needs to get called.
26837 + * d3 will contain address to do_exit which needs to get moved into a5.
26838 + *
26839 + * On return from fork the child thread d0 will be 0. We call this dummy
26840 + * function which in turn loads the argument
26841 + */
26842 + .section .kernel_unprotected, "ax", @progbits
26843 + .global kernel_thread_helper
26844 +kernel_thread_helper:
26845 + /*
26846 + * Create a kernel thread. This is called from ret_from_vfork (a
26847 + * userspace return routine) so we need to put it in an unprotected
26848 + * section and re-enable protection before calling the vector in d2.
26849 + */
26850 +
26851 +#ifdef CONFIG_PROTECT_KERNEL
26852 + /*
26853 + * We are entering the kernel so we need to disable the protection.
26854 + * Enter critical section, disable ranges and leave critical section.
26855 + */
26856 + call a5, __enable_kernel_ranges
26857 +#endif
26858 + /*
26859 + * Move argument for kernel function into d0, and set a5 return address
26860 + * (a5) to do_exit and return through a2
26861 + */
26862 + move.4 d0, d1 ; d0 = arg
26863 + move.4 a5, d3 ; a5 = do_exit
26864 + ret d2 ; call function ptr in d2
26865 + .size kernel_thread_helper, . - kernel_thread_helper
26866 +
26867 +#ifdef CONFIG_PROTECT_KERNEL
26868 + .section .kernel_unprotected, "ax", @progbits
26869 +__enable_kernel_ranges:
26870 + atomic_lock_acquire ; Enter critical section
26871 + enable_kernel_ranges_for_current d15
26872 + atomic_lock_release ; Leave critical section
26873 + calli a5, 0(a5)
26874 + .size __enable_kernel_ranges, . - __enable_kernel_ranges
26875 +
26876 +#endif
26877 +
26878 +/*
26879 + * The following system call intercept functions where we setup the
26880 + * input to the real system call. In all cases these are just taking
26881 + * the current sp which is pointing to pt_regs and pushing it into the
26882 + * last arg of the system call.
26883 + *
26884 + * i.e. the public definition of sys_execv is
26885 + * sys_execve( char *name,
26886 + * char **argv,
26887 + * char **envp )
26888 + * but process.c defines it as
26889 + * sys_execve( char *name,
26890 + * char **argv,
26891 + * char **envp,
26892 + * struct pt_regs *regs )
26893 + *
26894 + * so execve_intercept needs to populate the 4th arg with pt_regs*,
26895 + * which is the stack pointer as we know we must be coming out of
26896 + * system_call
26897 + *
26898 + * The intercept vectors are referenced by syscalltable.S
26899 + */
26900 +
26901 +/*
26902 + * execve_intercept()
26903 + */
26904 + .section .text.execve_intercept, "ax", @progbits
26905 + .global execve_intercept
26906 +execve_intercept:
26907 + move.4 d3, sp ; Save pt_regs address
26908 + call a3, sys_execve
26909 +
26910 + .size execve_intercept, . - execve_intercept
26911 +
26912 +/*
26913 + * vfork_intercept()
26914 + */
26915 + .section .text.vfork_intercept, "ax", @progbits
26916 + .global vfork_intercept
26917 +vfork_intercept:
26918 + move.4 d0, sp ; Save pt_regs address
26919 + call a3, sys_vfork
26920 +
26921 + .size vfork_intercept, . - vfork_intercept
26922 +
26923 +/*
26924 + * clone_intercept()
26925 + */
26926 + .section .text.clone_intercept, "ax", @progbits
26927 + .global clone_intercept
26928 +clone_intercept:
26929 + move.4 d2, sp ; Save pt_regs address
26930 + call a3, sys_clone
26931 +
26932 + .size clone_intercept, . - clone_intercept
26933 +
26934 +/*
26935 + * sys_sigsuspend()
26936 + */
26937 + .section .text.sigclone_intercept, "ax", @progbits
26938 + .global sys_sigsuspend
26939 +sys_sigsuspend:
26940 + move.4 d0, sp ; Pass pointer to pt_regs in d0
26941 + call a3, do_sigsuspend
26942 +
26943 + .size sys_sigsuspend, . - sys_sigsuspend
26944 +
26945 +/*
26946 + * sys_rt_sigsuspend()
26947 + */
26948 + .section .text.sys_rt_sigsuspend, "ax", @progbits
26949 + .global sys_rt_sigsuspend
26950 +sys_rt_sigsuspend:
26951 + move.4 d0, sp ; Pass pointer to pt_regs in d0
26952 + call a3, do_rt_sigsuspend
26953 +
26954 + .size sys_rt_sigsuspend, . - sys_rt_sigsuspend
26955 +
26956 +/*
26957 + * sys_rt_sigreturn()
26958 + */
26959 + .section .text.sys_rt_sigreturn, "ax", @progbits
26960 + .global sys_rt_sigreturn
26961 +sys_rt_sigreturn:
26962 + move.4 d0, sp ; Pass pointer to pt_regs in d0
26963 + call a3, do_rt_sigreturn
26964 +
26965 + .size sys_rt_sigreturn, . - sys_rt_sigreturn
26966 +
26967 +/*
26968 + * sys_sigaltstack()
26969 + */
26970 + .section .text.sys_sigaltstack, "ax", @progbits
26971 + .global sys_sigaltstack
26972 +sys_sigaltstack:
26973 + move.4 d0, sp ; Pass pointer to pt_regs in d0
26974 + call a3, do_sys_sigaltstack
26975 +
26976 + .size sys_sigaltstack, . - sys_sigaltstack
26977 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/unaligned_trap.c linux-2.6.30.10-ubi/arch/ubicom32/kernel/unaligned_trap.c
26978 --- linux-2.6.30.10/arch/ubicom32/kernel/unaligned_trap.c 1970-01-01 02:00:00.000000000 +0200
26979 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/unaligned_trap.c 2009-12-11 11:45:11.000000000 +0200
26980 @@ -0,0 +1,698 @@
26981 +/*
26982 + * arch/ubicom32/kernel/unaligned_trap.c
26983 + * Handle unaligned traps in both user or kernel space.
26984 + *
26985 + * (C) Copyright 2009, Ubicom, Inc.
26986 + *
26987 + * This file is part of the Ubicom32 Linux Kernel Port.
26988 + *
26989 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
26990 + * it and/or modify it under the terms of the GNU General Public License
26991 + * as published by the Free Software Foundation, either version 2 of the
26992 + * License, or (at your option) any later version.
26993 + *
26994 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
26995 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
26996 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
26997 + * the GNU General Public License for more details.
26998 + *
26999 + * You should have received a copy of the GNU General Public License
27000 + * along with the Ubicom32 Linux Kernel Port. If not,
27001 + * see <http://www.gnu.org/licenses/>.
27002 + *
27003 + * Ubicom32 implementation derived from (with many thanks):
27004 + * arch/m68knommu
27005 + * arch/blackfin
27006 + * arch/parisc
27007 + */
27008 +
27009 +#include <linux/types.h>
27010 +#include <linux/kernel.h>
27011 +#include <asm/cacheflush.h>
27012 +#include <asm/traps.h>
27013 +
27014 +#define FALSE 0
27015 +#define TRUE 1
27016 +
27017 +/* no possible trap */
27018 +#define UNUSED 0
27019 +/* possible source operand trap */
27020 +#define SRC 1
27021 +#define SRC_2 2
27022 +/* possible destination operand trap */
27023 +#define DEST 3
27024 +#define DEST_2 4
27025 +/* can be either source or destination or both */
27026 +#define TWO_OP 5
27027 +#define TWO_OP_2 6
27028 +
27029 +/* TODO: What is the real value here, put something in to make it compile for
27030 + * now */
27031 +#define MOVE_2 0x0d
27032 +#define LSL_2 0x11
27033 +#define LSR_2 0x13
27034 +#define MOVEI 0x19
27035 +#define CMPI 0x18
27036 +
27037 +static int op_format[32] =
27038 +{
27039 + TWO_OP, /* 0x00 */
27040 + UNUSED,
27041 + SRC,
27042 + UNUSED,
27043 + TWO_OP, /* 0x04 */
27044 + TWO_OP,
27045 + SRC,
27046 + UNUSED,
27047 + TWO_OP_2, /* 0x08 */
27048 + TWO_OP,
27049 + TWO_OP_2,
27050 + TWO_OP,
27051 + TWO_OP_2, /* 0x0C */
27052 + TWO_OP,
27053 + TWO_OP_2,
27054 + TWO_OP,
27055 + TWO_OP, /* 0x10 */
27056 + TWO_OP_2,
27057 + TWO_OP,
27058 + TWO_OP,
27059 + UNUSED, /* 0x14 */
27060 + UNUSED,
27061 + UNUSED,
27062 + UNUSED,
27063 + SRC_2, /* 0x18 */
27064 + DEST_2,
27065 + UNUSED,
27066 + UNUSED,
27067 + UNUSED, /* 0x1C */
27068 + UNUSED,
27069 + UNUSED, /* unaligned CALLI will not be fixed. */
27070 + UNUSED
27071 +};
27072 +
27073 +static int op_0_format[32] =
27074 +{
27075 + UNUSED, /* 0x00 */
27076 + UNUSED,
27077 + UNUSED,
27078 + UNUSED,
27079 + UNUSED, /* 0x04 - ret don't fix - bad ret is always wrong */
27080 + UNUSED,
27081 + UNUSED,
27082 + UNUSED,
27083 + UNUSED, /* 0x08 */
27084 + UNUSED,
27085 + TWO_OP,
27086 + TWO_OP_2,
27087 + TWO_OP, /* 0x0c */
27088 + TWO_OP_2,
27089 + TWO_OP,
27090 + UNUSED, /* .1 can't trap */
27091 + UNUSED, /* 0x10 */
27092 + UNUSED,
27093 + SRC,
27094 + UNUSED,
27095 + UNUSED, /* 0x14 */
27096 + TWO_OP_2,
27097 + UNUSED,
27098 + UNUSED,
27099 + UNUSED, /* 0x18 */
27100 + UNUSED,
27101 + UNUSED,
27102 + UNUSED,
27103 + DEST, /* 0x1c */
27104 + DEST,
27105 + DEST,
27106 + DEST, /* all lea have 32-bit destination */
27107 +};
27108 +
27109 +static int op_2_format[32] =
27110 +{
27111 + UNUSED, /* 0x00 */
27112 + UNUSED,
27113 + UNUSED,
27114 + UNUSED,
27115 + UNUSED, /* 0x04 */
27116 + UNUSED,
27117 + SRC,
27118 + UNUSED,
27119 + UNUSED, /* 0x08 crcgen is .1 */
27120 + UNUSED,
27121 + UNUSED,
27122 + UNUSED,
27123 + UNUSED, /* 0x0c */
27124 + UNUSED,
27125 + UNUSED,
27126 + UNUSED,
27127 + SRC, /* 0x10 */
27128 + SRC_2,
27129 + SRC,
27130 + SRC_2,
27131 + SRC, /* 0x14 */
27132 + SRC_2,
27133 + SRC,
27134 + UNUSED,
27135 + UNUSED, /* 0x18 */
27136 + UNUSED,
27137 + SRC,
27138 + UNUSED,
27139 + SRC, /* 0x1c */
27140 + UNUSED,
27141 + SRC_2,
27142 + UNUSED,
27143 +};
27144 +
27145 +static int op_6_format[32] =
27146 +{
27147 + SRC_2, /* 0x00 */
27148 + SRC_2,
27149 + SRC_2,
27150 + SRC_2,
27151 + SRC_2, /* 0x04 */
27152 + SRC_2,
27153 + UNUSED,
27154 + SRC_2,
27155 + SRC, /* 0x08 MULS.4 */
27156 + SRC_2,
27157 + SRC,
27158 + UNUSED,
27159 + UNUSED, /* 0x0c */
27160 + UNUSED,
27161 + UNUSED,
27162 + UNUSED,
27163 + SRC, /* 0x10 */
27164 + SRC_2,
27165 + SRC,
27166 + SRC_2,
27167 + UNUSED, /* 0x14 */
27168 + UNUSED,
27169 + UNUSED,
27170 + UNUSED,
27171 + UNUSED, /* 0x18 */
27172 + UNUSED,
27173 + UNUSED,
27174 + UNUSED,
27175 + UNUSED, /* 0x1c */
27176 + UNUSED,
27177 + UNUSED,
27178 + UNUSED,
27179 +};
27180 +
27181 +/*
27182 + * unaligned_get_address()
27183 + * get an address using save_an and save_dn registers, and updates save_an
27184 + * with side effects
27185 + */
27186 +unsigned char *unaligned_get_address(int thread, int specifier, int four_byte,
27187 + unsigned int save_an[],
27188 + unsigned int save_dn[], int *write_back_an)
27189 +{
27190 + unsigned char *address;
27191 +
27192 + int areg = (specifier >> 5) & 7;
27193 + if ((specifier >> 8) == 2) {
27194 + int offset = specifier & 0xf;
27195 + offset = ((offset << 28) >> 28);
27196 + if (likely(four_byte)) {
27197 + offset <<= 2;
27198 + } else {
27199 + offset <<= 1;
27200 + }
27201 + if (specifier & 0x10) {
27202 + address = (unsigned char *)(save_an[areg] + offset);
27203 + } else {
27204 + address = (unsigned char *)save_an[areg];
27205 + }
27206 + save_an[areg] = save_an[areg] + offset;
27207 +
27208 + /*
27209 + * Let caller know An registers have been modified.
27210 + */
27211 + *write_back_an = 1;
27212 + } else if ((specifier >> 8) == 3) {
27213 + int dreg = specifier & 0xf;
27214 + if (likely(four_byte)) {
27215 + address = (unsigned char *)(save_an[areg] +
27216 + (save_dn[dreg] << 2));
27217 + } else {
27218 + address = (unsigned char *)(save_an[areg] +
27219 + (save_dn[dreg] << 1));
27220 + }
27221 + } else {
27222 + int offset = ((specifier >> 3) & 0x60) | (specifier & 0x1f);
27223 + if (likely(four_byte)) {
27224 + address = (unsigned char *)(save_an[areg] +
27225 + (offset << 2));
27226 + } else {
27227 + address = (unsigned char *)(save_an[areg] +
27228 + (offset << 1));
27229 + }
27230 + }
27231 +
27232 + return address;
27233 +}
27234 +
27235 +static int save_dn[16];
27236 +static int save_an[8];
27237 +static int save_acc[5];
27238 +
27239 +/*
27240 + * unaligned_emulate()
27241 + * emulate the instruction at thread's pc that has taken an unaligned data
27242 + * trap.
27243 + *
27244 + * source or destination or both might be unaligned
27245 + * the instruction must have a memory source or destination or both
27246 + * the emulated instruction is copied and executed in this thread
27247 + *
27248 + * TODO: Protection is handled outside of this function
27249 + * TODO: handling simultaneous unaligned and memory protection traps
27250 + *
27251 + * Get thread state
27252 + * the PC and instruction (and local copy, emulate_inst), and An
27253 + * and Dn registers
27254 + * All implicit soruce state (source3, CSR, accumulators)
27255 +
27256 + * if the instruction has a memory source
27257 + * Use the instruction, An and Dn registers to form src_address
27258 + * get unaligned source data from src_address (usually sign
27259 + * extended)
27260 + * (2 bytes, with or without sign extension, or 4 bytes)
27261 + * modify emulate_inst to use d0 as source
27262 + * else
27263 + * get the soure operand from one of thread's registers
27264 + * if instruction has a memory destination
27265 + * Use the instruction, An and Dn registers to form dest_address
27266 + * modify emulate_inst to use d0 as destination
27267 + * if there was a memory source
27268 + * put the source data in thread's d0
27269 + * get the source-2 Dn operand and source 3 operand from thread
27270 + * execute modified inst
27271 + * (save it, flush caches, set up local values for implicit
27272 + * sources, execute, save explicit and implicit results)
27273 + * if inst has destination address
27274 + * copy result to dest_address, possibly unaligned, 1, 2, or 4
27275 + * bytes
27276 + * restore thread's implicit results (modified address registers, CSR,
27277 + * accumulators) add 4 to thread's pc
27278 + */
27279 +void unaligned_emulate(unsigned int thread)
27280 +{
27281 + unsigned int pc;
27282 + unsigned int inst;
27283 + unsigned int op;
27284 + unsigned int subop;
27285 + int format;
27286 + unsigned int emulate_inst;
27287 + int four_byte;
27288 + int src_operand, dest_operand;
27289 + int save_csr;
27290 + int source3;
27291 + unsigned int source1;
27292 + unsigned int source_data;
27293 + unsigned char *dest_address = NULL;
27294 + int source2 = 0;
27295 + unsigned int result;
27296 + unsigned int write_back_an = 0;
27297 + unsigned int chip_id_copy;
27298 +
27299 + extern unsigned int trap_emulate;
27300 + extern unsigned int ubicom32_emulate_insn(int source1, int source2,
27301 + int source3, int *save_acc,
27302 + int *save_csr);
27303 +
27304 + /*
27305 + * get the chip_id
27306 + */
27307 + asm volatile (
27308 + " move.4 %0, chip_id \n\t" /* get chip_id. */
27309 + : "=r"(chip_id_copy)
27310 + :
27311 + );
27312 +
27313 + /*
27314 + * get the pc
27315 + */
27316 + asm volatile (
27317 + " move.4 CSR, %1 \n\t" /* set source thread in
27318 + * CSR */
27319 + " setcsr_flush 0 \n\t"
27320 + " move.4 %0, pc \n\t"
27321 + " move.4 CSR, #0 \n\t" /* restore CSR */
27322 + " setcsr_flush 0 \n\t"
27323 + : "=a"(pc)
27324 + : "d" ((1 << 8) | (thread << 9))
27325 + : "cc"
27326 + );
27327 +
27328 + inst = *((unsigned int *)pc);
27329 + op = inst >> 27;
27330 + if (unlikely(op == 2 || op == 6)) {
27331 + subop = (inst >> 21) & 0x1f;
27332 + } else {
27333 + subop = (inst >> 11) & 0x1f;
27334 + }
27335 + format = op_format[op];
27336 + emulate_inst = inst;
27337 +
27338 + if (op == 0) {
27339 + format = op_0_format[subop];
27340 + } else if (op == 2) {
27341 + format = op_2_format[subop];
27342 + } else if (op == 6) {
27343 + format = op_6_format[subop];
27344 + }
27345 +
27346 + if (unlikely(format == UNUSED)) {
27347 + /*
27348 + * We are not going to emulate this. Bump PC by 4 and move on.
27349 + */
27350 + asm volatile (
27351 + " move.4 CSR, %0 \n\t"
27352 + " setcsr_flush 0 \n\t"
27353 + " move.4 pc, %1 \n\t"
27354 + " setcsr #0 \n\t"
27355 + " setcsr_flush 0 \n\t"
27356 + :
27357 + : "d"((1 << 14) | (thread << 15)), "d"(pc + 4)
27358 + : "cc"
27359 + );
27360 + return;
27361 + }
27362 +
27363 + four_byte = (format == TWO_OP || format == DEST || format == SRC);
27364 +
27365 + /*
27366 + * source or destination memory operand needs emulation
27367 + */
27368 + src_operand = (format == SRC ||
27369 + format == SRC_2 ||
27370 + format == TWO_OP ||
27371 + format == TWO_OP_2) &&
27372 + ((inst >> 8) & 7) > 1;
27373 +
27374 + dest_operand = (format == DEST ||
27375 + format == DEST_2 ||
27376 + format == TWO_OP ||
27377 + format == TWO_OP_2) &&
27378 + ((inst >> 24) & 7) > 1;
27379 +
27380 + /*
27381 + * get thread's implicit sources (not covered by source context select).
27382 + * data and address registers and CSR (for flag bits) and src3 and
27383 + * accumulators
27384 + */
27385 + asm volatile (
27386 + " move.4 CSR, %2 \n\t" /* set source thread in
27387 + * CSR */
27388 + " setcsr_flush 0 \n\t"
27389 + " move.4 (%3), d0 \n\t" /* get dn registers */
27390 + " move.4 4(%3), d1 \n\t"
27391 + " move.4 8(%3), d2 \n\t"
27392 + " move.4 12(%3), d3 \n\t"
27393 + " move.4 16(%3), d4 \n\t"
27394 + " move.4 20(%3), d5 \n\t"
27395 + " move.4 24(%3), d6 \n\t"
27396 + " move.4 28(%3), d7 \n\t"
27397 + " move.4 32(%3), d8 \n\t"
27398 + " move.4 36(%3), d9 \n\t"
27399 + " move.4 40(%3), d10 \n\t"
27400 + " move.4 44(%3), d11 \n\t"
27401 + " move.4 48(%3), d12 \n\t"
27402 + " move.4 52(%3), d13 \n\t"
27403 + " move.4 56(%3), d14 \n\t"
27404 + " move.4 60(%3), d15 \n\t"
27405 + " move.4 (%4), a0 \n\t" /* get an registers */
27406 + " move.4 4(%4), a1 \n\t"
27407 + " move.4 8(%4), a2 \n\t"
27408 + " move.4 12(%4), a3 \n\t"
27409 + " move.4 16(%4), a4 \n\t"
27410 + " move.4 20(%4), a5 \n\t"
27411 + " move.4 24(%4), a6 \n\t"
27412 + " move.4 28(%4), a7 \n\t"
27413 + " move.4 %0, CSR \n\t" /* get csr and source3
27414 + * implicit operands */
27415 + " move.4 %1, source3 \n\t"
27416 + " move.4 (%5), acc0_lo \n\t" /* get accumulators */
27417 + " move.4 4(%5), acc0_hi \n\t"
27418 + " move.4 8(%5), acc1_lo \n\t"
27419 + " move.4 12(%5), acc1_hi \n\t"
27420 + " move.4 16(%5), mac_rc16 \n\t"
27421 + " move.4 CSR, #0 \n\t" /* restore CSR */
27422 + " setcsr_flush 0 \n\t"
27423 + : "=m"(save_csr), "=m"(source3)
27424 + : "d"((1 << 8) | (thread << 9)),
27425 + "a"(save_dn), "a"(save_an), "a"(save_acc)
27426 + : "cc"
27427 + );
27428 +
27429 + /*
27430 + * turn off thread select bits if they were on
27431 + */
27432 + BUG_ON((save_csr & 0x04100) != 0);
27433 + if (unlikely(save_csr & 0x04100)) {
27434 + /*
27435 + * Things are in funny state as thread select bits are on in
27436 + * csr. PANIC.
27437 + */
27438 + panic("In unaligned trap handler. Trap thread CSR has thread "
27439 + "select bits on.\n");
27440 + }
27441 +
27442 + save_csr = save_csr & 0x1000ff;
27443 +
27444 + /*
27445 + * get the source1 operand
27446 + */
27447 + source1 = 0;
27448 + if (src_operand) {
27449 + unsigned char *src_address;
27450 +
27451 + /*
27452 + * source1 comes from memory
27453 + */
27454 + BUG_ON(!(format == TWO_OP || format == TWO_OP_2 ||
27455 + format == SRC || format == SRC_2));
27456 + src_address = unaligned_get_address(thread, inst & 0x7ff,
27457 + four_byte, save_an,
27458 + save_dn, &write_back_an);
27459 +
27460 + /*
27461 + * get data (possibly unaligned)
27462 + */
27463 + if (likely(four_byte)) {
27464 + source_data = (*src_address << 24) |
27465 + (*(src_address + 1) << 16) |
27466 + (*(src_address + 2) << 8) |
27467 + *(src_address + 3);
27468 + source1 = source_data;
27469 + } else {
27470 + source1 = *src_address << 8 |
27471 + *(src_address + 1);
27472 +
27473 + /*
27474 + * Source is not extended if the instrution is MOVE.2 or
27475 + * if the cpu CHIP_ID >= 0x30000 and the instruction is
27476 + * either LSL.2 or LSR.2. All other cases have to be
27477 + * sign extended.
27478 + */
27479 + if ((!(op == 2 && subop == MOVE_2)) &&
27480 + (!((chip_id_copy >= 0x30000) &&
27481 + (subop == LSL_2 || subop == LSR_2)))) {
27482 + /*
27483 + * Have to sign extend the .2 entry.
27484 + */
27485 + source1 = ((unsigned int)
27486 + ((signed int)
27487 + ((signed short) source1)));
27488 + }
27489 + }
27490 + } else if (likely(op != MOVEI)) {
27491 + /*
27492 + * source1 comes from a register, using move.4 d0, src1
27493 + * unaligned_emulate_get_source is pointer to code to insert remulated instruction
27494 + */
27495 + extern unsigned int unaligned_emulate_get_src;
27496 + *((int *)&unaligned_emulate_get_src) &= ~(0x7ff);
27497 + *((int *)&unaligned_emulate_get_src) |= (inst & 0x7ff);
27498 + flush_dcache_range((unsigned long)(&unaligned_emulate_get_src),
27499 + (unsigned long)(&unaligned_emulate_get_src) + 4);
27500 +
27501 + asm volatile (
27502 + /* source1 uses thread's registers */
27503 + " move.4 CSR, %1 \n\t"
27504 + " setcsr_flush 0 \n\t"
27505 + "unaligned_emulate_get_src: \n\t"
27506 + " move.4 %0, #0 \n\t"
27507 + " setcsr #0 \n\t"
27508 + " setcsr_flush 0 \n\t"
27509 + : "=d" (source1)
27510 + : "d" ((1 << 8) | (thread << 9))
27511 + : "cc"
27512 + );
27513 + }
27514 +
27515 + /*
27516 + * get the destination address
27517 + */
27518 + if (dest_operand) {
27519 + BUG_ON(!(format == TWO_OP || format == TWO_OP_2 ||
27520 + format == DEST || format == DEST_2));
27521 + dest_address = unaligned_get_address(thread,
27522 + ((inst >> 16) & 0x7ff),
27523 + four_byte, save_an,
27524 + save_dn, &write_back_an);
27525 + }
27526 +
27527 + if (write_back_an) {
27528 + /*
27529 + * restore any modified An registers
27530 + */
27531 + asm volatile (
27532 + " move.4 CSR, %0 \n\t"
27533 + " setcsr_flush 0 \n\t"
27534 + " move.4 a0, (%1) \n\t"
27535 + " move.4 a1, 4(%1) \n\t"
27536 + " move.4 a2, 8(%1) \n\t"
27537 + " move.4 a3, 12(%1) \n\t"
27538 + " move.4 a4, 16(%1) \n\t"
27539 + " move.4 a5, 20(%1) \n\t"
27540 + " move.4 a6, 24(%1) \n\t"
27541 + " move.4 a7, 28(%1) \n\t"
27542 + " setcsr #0 \n\t"
27543 + " setcsr_flush 0 \n\t"
27544 + :
27545 + : "d" ((1 << 14) | (thread << 15)), "a" (save_an)
27546 + : "cc"
27547 + );
27548 + }
27549 +
27550 + /*
27551 + * get source 2 register if needed, and modify inst to use d1 for
27552 + * source-2 source-2 will come from this thread, not the trapping thread
27553 + */
27554 + source2 = 0;
27555 + if ((op >= 8 && op <= 0x17) ||
27556 + ((op == 2 || op == 6) && (inst & 0x4000000))) {
27557 + int src_dn = (inst >> 11) & 0xf;
27558 + source2 = save_dn[src_dn];
27559 + /*
27560 + * force the emulated instruction to use d1 for source2 operand
27561 + */
27562 + emulate_inst = (emulate_inst & 0xffff07ff) | 0x800;
27563 + }
27564 +
27565 + if (likely(op != MOVEI)) {
27566 + /*
27567 + * change emulated instruction source1 to d0
27568 + */
27569 + emulate_inst &= ~0x7ff;
27570 + emulate_inst |= 1 << 8;
27571 + }
27572 +
27573 + if (unlikely(op == 6 || op == 2)) {
27574 + /*
27575 + * Set destination to d0
27576 + */
27577 + emulate_inst &= ~(0xf << 16);
27578 + } else if (likely(op != CMPI)) {
27579 + /*
27580 + * Set general destination field to d0.
27581 + */
27582 + emulate_inst &= ~(0x7ff << 16);
27583 + emulate_inst |= 1 << 24;
27584 + }
27585 +
27586 + /*
27587 + * execute emulated instruction d0, to d0, no memory access
27588 + * source2 if needed will be in d1
27589 + * source3, CSR, and accumulators are set up before execution
27590 + */
27591 + *((unsigned int *)&trap_emulate) = emulate_inst;
27592 + flush_dcache_range((unsigned long)(&trap_emulate),
27593 + (unsigned long)(&trap_emulate) + 4);
27594 +
27595 + result = ubicom32_emulate_insn(source1, source2, source3,
27596 + save_acc, &save_csr);
27597 +
27598 + /*
27599 + * set the result value
27600 + */
27601 + if (dest_operand) {
27602 + /*
27603 + * copy result to memory
27604 + */
27605 + if (four_byte) {
27606 + *dest_address++ =
27607 + (unsigned char)((result >> 24) & 0xff);
27608 + *dest_address++ =
27609 + (unsigned char)((result >> 16) & 0xff);
27610 + }
27611 + *dest_address++ = (unsigned char)((result >> 8) & 0xff);
27612 + *dest_address = (unsigned char)(result & 0xff);
27613 + } else if (likely(op != CMPI)) {
27614 + /*
27615 + * copy result to a register, using move.4 dest, result
27616 + */
27617 + extern unsigned int unaligned_trap_set_result;
27618 + *((unsigned int *)&unaligned_trap_set_result) &= ~0x7ff0000;
27619 +
27620 + if (op == 2 || op == 6) {
27621 + *((unsigned int *)&unaligned_trap_set_result) |=
27622 + ((inst & 0x000f0000) | 0x01000000);
27623 + } else {
27624 + *((unsigned int *)&unaligned_trap_set_result) |=
27625 + (inst & 0x7ff0000);
27626 + }
27627 + flush_dcache_range((unsigned long)&unaligned_trap_set_result,
27628 + ((unsigned long)(&unaligned_trap_set_result) + 4));
27629 +
27630 + asm volatile (
27631 + /* result uses thread's registers */
27632 + " move.4 CSR, %1 \n\t"
27633 + " setcsr_flush 0 \n\t"
27634 + "unaligned_trap_set_result: \n\t"
27635 + " move.4 #0, %0 \n\t"
27636 + " setcsr #0 \n\t"
27637 + " setcsr_flush 0 \n\t"
27638 + :
27639 + : "d"(result), "d" ((1 << 14) | (thread << 15))
27640 + : "cc"
27641 + );
27642 + }
27643 +
27644 + /*
27645 + * bump PC in thread and restore implicit register changes
27646 + */
27647 + asm volatile (
27648 + " move.4 CSR, %0 \n\t"
27649 + " setcsr_flush 0 \n\t"
27650 + " move.4 pc, %1 \n\t"
27651 + " move.4 acc0_lo, (%3) \n\t"
27652 + " move.4 acc0_hi, 4(%3) \n\t"
27653 + " move.4 acc1_lo, 8(%3) \n\t"
27654 + " move.4 acc1_hi, 12(%3) \n\t"
27655 + " move.4 mac_rc16, 16(%3) \n\t"
27656 + " move.4 CSR, %2 \n\t"
27657 + " setcsr #0 \n\t"
27658 + " setcsr_flush 0 \n\t"
27659 + :
27660 + : "d"((1 << 14) | (thread << 15)),
27661 + "d"(pc + 4), "d"(save_csr), "a"(save_acc)
27662 + : "cc"
27663 + );
27664 +}
27665 +
27666 +/*
27667 + * unaligned_only()
27668 + * Return true if either of the unaligned causes are set (and no others).
27669 + */
27670 +int unaligned_only(unsigned int cause)
27671 +{
27672 + unsigned int unaligned_cause_mask =
27673 + (1 << TRAP_CAUSE_DST_MISALIGNED) |
27674 + (1 << TRAP_CAUSE_SRC1_MISALIGNED);
27675 +
27676 + BUG_ON(cause == 0);
27677 + return (cause & unaligned_cause_mask) == cause;
27678 +}
27679 diff -ruN linux-2.6.30.10/arch/ubicom32/kernel/vmlinux.lds.S linux-2.6.30.10-ubi/arch/ubicom32/kernel/vmlinux.lds.S
27680 --- linux-2.6.30.10/arch/ubicom32/kernel/vmlinux.lds.S 1970-01-01 02:00:00.000000000 +0200
27681 +++ linux-2.6.30.10-ubi/arch/ubicom32/kernel/vmlinux.lds.S 2009-12-11 11:45:11.000000000 +0200
27682 @@ -0,0 +1,370 @@
27683 +/*
27684 + * arch/ubicom32/kernel/vmlinux.lds.S
27685 + * vmlinux primary linker script
27686 + *
27687 + * (C) Copyright 2009, Ubicom, Inc.
27688 + *
27689 + * This file is part of the Ubicom32 Linux Kernel Port.
27690 + *
27691 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
27692 + * it and/or modify it under the terms of the GNU General Public License
27693 + * as published by the Free Software Foundation, either version 2 of the
27694 + * License, or (at your option) any later version.
27695 + *
27696 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
27697 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
27698 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
27699 + * the GNU General Public License for more details.
27700 + *
27701 + * You should have received a copy of the GNU General Public License
27702 + * along with the Ubicom32 Linux Kernel Port. If not,
27703 + * see <http://www.gnu.org/licenses/>.
27704 + *
27705 + * Ubicom32 implementation derived from (with many thanks):
27706 + * arch/m68knommu
27707 + * arch/blackfin
27708 + * arch/parisc
27709 + */
27710 +#include <asm-generic/vmlinux.lds.h>
27711 +#include <asm/ocm_size.h>
27712 +#include <asm/memory_map.h>
27713 +#include <asm/thread_info.h>
27714 +#include <linux/threads.h>
27715 +
27716 +/*
27717 + * Sanity checks to prevent errors later on that are much harder to understand
27718 + */
27719 +#if !defined APP_OCM_CODE_SIZE
27720 +#error APP_OCM_CODE_SIZE has not been defined in ocm_size.h
27721 +#endif
27722 +
27723 +#if !defined APP_OCM_DATA_SIZE
27724 +#error APP_OCM_DATA_SIZE has not been defined in ocm_size.h
27725 +#endif
27726 +
27727 +/*
27728 + * The `free' ocm area that ultra does not use.
27729 + */
27730 +#if APP_OCM_CODE_SIZE || APP_OCM_DATA_SIZE
27731 +#define OCM_FREE_START (OCMSTART + APP_OCM_CODE_SIZE)
27732 +#define OCM_FREE_LENGTH (OCMSIZE - APP_OCM_CODE_SIZE - APP_OCM_DATA_SIZE)
27733 +#else
27734 +#define OCM_FREE_START OCMEND
27735 +#define OCM_FREE_LENGTH 0
27736 +#endif
27737 +
27738 +/*
27739 + * If you want to limit OCM use for text/data or completely disable it
27740 + * you can change these values.
27741 + */
27742 +#define OCM_TEXT_LENGTH OCM_FREE_LENGTH
27743 +#define OCM_DATA_LENGTH OCM_FREE_LENGTH
27744 +
27745 +#define RAM_START KERNELSTART
27746 +#define RAM_LENGTH ((SDRAMSTART + CONFIG_MIN_RAMSIZE) - RAM_START)
27747 +#define TEXT ram
27748 +#define DATA ram
27749 +#define INIT ram
27750 +#define BSS ram
27751 +
27752 +#ifndef DATA_ADDR
27753 +#define DATA_ADDR
27754 +#endif
27755 +
27756 +#include <asm-generic/vmlinux.lds.h>
27757 +
27758 +OUTPUT_ARCH(ubicom32)
27759 +ENTRY(_start)
27760 +
27761 +MEMORY {
27762 + ram : ORIGIN = RAM_START, LENGTH = RAM_LENGTH
27763 + syscall : ORIGIN = OS_SYSCALL_BEGIN, LENGTH = (OS_SYSCALL_END - OS_SYSCALL_BEGIN)
27764 + ocm : ORIGIN = OCM_FREE_START, LENGTH = OCM_FREE_LENGTH
27765 +}
27766 +
27767 +jiffies = jiffies_64 + 4;
27768 +
27769 +/*
27770 + * Fixed locations required by gdb coredumps.
27771 + *
27772 + * Note that the names are what gdb is expecting so renaming will break
27773 + * the toolchain.
27774 + */
27775 +__ocm_begin = OCMSTART;
27776 +__ocm_limit = __ocm_begin + OCMSIZE;
27777 +__sdram_begin = SDRAMSTART;
27778 +__sdram_limit = __sdram_begin + CONFIG_MIN_RAMSIZE;
27779 +__filemedia_begin_addr = FLASHSTART;
27780 +__filemedia_end_addr = __filemedia_begin_addr + 0x00800000;
27781 +
27782 +/*
27783 + * For internal diagnostics
27784 + */
27785 +__os_syscall_begin = OS_SYSCALL_BEGIN;
27786 +__os_syscall_end = OS_SYSCALL_END;
27787 +
27788 +SECTIONS {
27789 +
27790 + .fixed_text : {
27791 + _begin = .;
27792 + *(.skip_syscall)
27793 + *(.old_syscall_entry.text)
27794 + __fixed_text_end = .;
27795 + } > TEXT
27796 + . = _begin + SIZEOF(.fixed_text) ;
27797 +
27798 + /*
27799 + * System call text in lower ocm (fixed location, can never change)
27800 + */
27801 + __syscall_text_load_begin = .;
27802 + __syscall_text_run_begin = OS_SYSCALL_BEGIN;
27803 +
27804 + .syscall_text __syscall_text_run_begin : AT(__syscall_text_load_begin) {
27805 + *(.syscall_entry.text) /* Must be at OS_SYSCALL_BEGIN 0x3ffc0040 */
27806 + *(.kernel_unprotected)
27807 + . = ALIGN(4);
27808 + __syscall_text_run_end = .;
27809 + } > syscall /* .syscall_text */
27810 + . = __syscall_text_load_begin + __syscall_text_run_end - __syscall_text_run_begin ;
27811 + __ocm_text_load_begin = .;
27812 + __ocm_text_run_begin = OCM_FREE_START ;
27813 + .ocm_text __ocm_text_run_begin : AT(__ocm_text_load_begin) {
27814 +#if OCM_TEXT_LENGTH
27815 + *(.ocm_text)
27816 + *(.sched.text)
27817 + *(.spinlock.text)
27818 +#include <asm/ocm_text.lds.inc>
27819 + . = ALIGN(4);
27820 +#endif
27821 + __ocm_text_run_end = .;
27822 + __data_begin = ALIGN(OCM_SECTOR_SIZE);
27823 + } > ocm /* .ocm_text */
27824 +
27825 + .ocm_module_text __ocm_text_run_end (NOLOAD) : AT(__ocm_text_run_end) {
27826 + __ocm_inst_heap_begin = .;
27827 + /* Reserve the min requested */
27828 + . += (CONFIG_OCM_MODULES_RESERVATION) * 1024;
27829 +#ifdef CONFIG_OCM_MODULES_MAY_CONSUME_REMAINING_CODESPACE
27830 + /* Round up to OCM sector size (we cannot use it for data) */
27831 + . = ALIGN(OCM_SECTOR_SIZE);
27832 +#endif
27833 + __ocm_inst_heap_end = .;
27834 + /* update __data_begin */
27835 + __data_begin = ALIGN(OCM_SECTOR_SIZE);
27836 + } > ocm /* .ocm_module_text */
27837 +
27838 + . = __ocm_text_load_begin + __ocm_text_run_end - __ocm_text_run_begin ;
27839 + __ocm_text_load_end = .;
27840 +
27841 + __ocm_data_load_begin = .;
27842 + __ocm_data_run_begin = __data_begin ;
27843 +#if OCM_DATA_LENGTH
27844 + .ocm_data __ocm_data_run_begin : AT(__ocm_data_load_begin) {
27845 +#if defined(CONFIG_IRQSTACKS_USEOCM)
27846 + percpu_irq_stacks = .;
27847 + . += NR_CPUS * THREAD_SIZE;
27848 +#endif
27849 + *(.ocm_data)
27850 + . = ALIGN(4) ;
27851 + __ocm_data_run_end = .;
27852 + } > ocm
27853 + . = __ocm_data_load_begin + __ocm_data_run_end - __ocm_data_run_begin ;
27854 +#else
27855 + __ocm_data_run_end = __ocm_data_run_begin;
27856 +#endif
27857 + __ocm_data_load_end = .;
27858 +
27859 + __ocm_free_begin = __ocm_data_run_end;
27860 + __ocm_free_end = OCM_FREE_START + OCM_FREE_LENGTH;
27861 +
27862 + .text __ocm_data_load_end : AT(__ocm_data_load_end) {
27863 + . = ALIGN(4);
27864 + _stext = .;
27865 + _text = .;
27866 + TEXT_TEXT
27867 + SCHED_TEXT
27868 + LOCK_TEXT
27869 + *(.text.lock)
27870 + *(.text.__libgcc_udivmodsi)
27871 + *(.text.__libgcc_divmodsi)
27872 + *(.text.__libgcc_muldi3)
27873 + *(.text.__libgcc_udivmoddi)
27874 + *(.text.__libgcc_divmoddi)
27875 + *(.text.*)
27876 +#if OCM_TEXT_LENGTH == 0
27877 + *(.ocm_text)
27878 + *(.sched.text)
27879 + *(.spinlock.text)
27880 +#endif
27881 + . = ALIGN(16); /* Exception table */
27882 + __start___ex_table = .;
27883 + *(__ex_table)
27884 + __stop___ex_table = .;
27885 +
27886 + *(.rodata) *(.rodata.*)
27887 + *(__vermagic) /* Kernel version magic */
27888 + *(__markers_strings)
27889 + *(.rodata1)
27890 + *(.rodata.str1.1)
27891 + *(__tracepoints_strings)
27892 +
27893 + /* PCI quirks */
27894 + __start_pci_fixups_early = . ;
27895 + *(.pci_fixup_early)
27896 + __end_pci_fixups_early = . ;
27897 + __start_pci_fixups_header = . ;
27898 + *(.pci_fixup_header)
27899 + __end_pci_fixups_header = . ;
27900 + __start_pci_fixups_final = . ;
27901 + *(.pci_fixup_final)
27902 + __end_pci_fixups_final = . ;
27903 + __start_pci_fixups_enable = . ;
27904 + *(.pci_fixup_enable)
27905 + __end_pci_fixups_enable = . ;
27906 + __start_pci_fixups_resume = . ;
27907 + *(.pci_fixup_resume)
27908 + __end_pci_fixups_resume = . ;
27909 + __start_pci_fixups_resume_early = . ;
27910 + *(.pci_fixup_resume_early)
27911 + __end_pci_fixups_resume_early = . ;
27912 + __start_pci_fixups_suspend = . ;
27913 + *(.pci_fixup_suspend)
27914 + __end_pci_fixups_suspend = . ;
27915 +
27916 + __start_builtin_fw = . ;
27917 + *(.builtin_fw)
27918 + __end_builtin_fw = . ;
27919 +
27920 +
27921 + /* Kernel symbol table: Normal symbols */
27922 + . = ALIGN(4);
27923 + __start___ksymtab = .;
27924 + *(__ksymtab)
27925 + __stop___ksymtab = .;
27926 +
27927 + /* Kernel symbol table: GPL-only symbols */
27928 + __start___ksymtab_gpl = .;
27929 + *(__ksymtab_gpl)
27930 + __stop___ksymtab_gpl = .;
27931 +
27932 + /* Kernel symbol table: Normal unused symbols */
27933 + __start___ksymtab_unused = .;
27934 + *(__ksymtab_unused)
27935 + __stop___ksymtab_unused = .;
27936 +
27937 + /* Kernel symbol table: GPL-only unused symbols */
27938 + __start___ksymtab_unused_gpl = .;
27939 + *(__ksymtab_unused_gpl)
27940 + __stop___ksymtab_unused_gpl = .;
27941 +
27942 + /* Kernel symbol table: GPL-future symbols */
27943 + __start___ksymtab_gpl_future = .;
27944 + *(__ksymtab_gpl_future)
27945 + __stop___ksymtab_gpl_future = .;
27946 +
27947 + /* Kernel symbol table: Normal symbols */
27948 + __start___kcrctab = .;
27949 + *(__kcrctab)
27950 + __stop___kcrctab = .;
27951 +
27952 + /* Kernel symbol table: GPL-only symbols */
27953 + __start___kcrctab_gpl = .;
27954 + *(__kcrctab_gpl)
27955 + __stop___kcrctab_gpl = .;
27956 +
27957 + /* Kernel symbol table: GPL-future symbols */
27958 + __start___kcrctab_gpl_future = .;
27959 + *(__kcrctab_gpl_future)
27960 + __stop___kcrctab_gpl_future = .;
27961 +
27962 + /* Kernel symbol table: strings */
27963 + *(__ksymtab_strings)
27964 +
27965 + /* Built-in module parameters */
27966 + . = ALIGN(4) ;
27967 + __start___param = .;
27968 + *(__param)
27969 + __stop___param = .;
27970 +
27971 + . = ALIGN(4) ;
27972 + _etext = . ;
27973 + } > TEXT
27974 +
27975 + .data DATA_ADDR : {
27976 + . = ALIGN(4);
27977 + _sdata = . ;
27978 + DATA_DATA
27979 +#if OCM_DATA_LENGTH == 0
27980 + *(.ocm_data)
27981 +#endif
27982 + . = ALIGN(8192) ;
27983 + _data_protection_end = .;
27984 + *(.data.init_task)
27985 + . = ALIGN(4);
27986 + _edata = . ;
27987 + } > DATA
27988 +
27989 + .init : {
27990 + . = ALIGN(4096);
27991 + __init_begin = .;
27992 + _sinittext = .;
27993 + INIT_TEXT
27994 + _einittext = .;
27995 + *(.init.rodata)
27996 + INIT_DATA
27997 + . = ALIGN(16);
27998 + __setup_start = .;
27999 + *(.init.setup)
28000 + __setup_end = .;
28001 + __initcall_start = .;
28002 + INITCALLS
28003 + __initcall_end = .;
28004 + __con_initcall_start = .;
28005 + *(.con_initcall.init)
28006 + __con_initcall_end = .;
28007 + ___security_initcall_start = .;
28008 + *(.security_initcall.init)
28009 + ___security_initcall_end = .;
28010 +#ifdef CONFIG_BLK_DEV_INITRD
28011 + . = ALIGN(4);
28012 + __initramfs_start = .;
28013 + *(.init.ramfs)
28014 + __initramfs_end = .;
28015 +#endif
28016 + . = ALIGN(4096);
28017 + __per_cpu_start = .;
28018 + *(.data.percpu)
28019 + *(.data.percpu.shared_aligned)
28020 + __per_cpu_end = .;
28021 +
28022 + . = ALIGN(4096);
28023 + __init_end = .;
28024 + } > INIT
28025 +
28026 + .eh_frame :
28027 + {
28028 + PROVIDE (___eh_frame_begin = .);
28029 + *(.eh_frame)
28030 + LONG (0);
28031 + PROVIDE (___eh_frame_end = .);
28032 + } > INIT
28033 +
28034 + /DISCARD/ : {
28035 + EXIT_TEXT
28036 + EXIT_DATA
28037 + *(.exitcall.exit)
28038 + }
28039 +
28040 + .bss : {
28041 + . = ALIGN(4);
28042 + _sbss = . ;
28043 + *(.bss)
28044 + *(COMMON)
28045 + . = ALIGN(4) ;
28046 + _ebss = . ;
28047 + _end = . ;
28048 + } > BSS
28049 +
28050 + NOTES > BSS
28051 +
28052 +}
28053 diff -ruN linux-2.6.30.10/arch/ubicom32/lib/checksum.c linux-2.6.30.10-ubi/arch/ubicom32/lib/checksum.c
28054 --- linux-2.6.30.10/arch/ubicom32/lib/checksum.c 1970-01-01 02:00:00.000000000 +0200
28055 +++ linux-2.6.30.10-ubi/arch/ubicom32/lib/checksum.c 2009-12-11 11:45:11.000000000 +0200
28056 @@ -0,0 +1,250 @@
28057 +/*
28058 + * arch/ubicom32/lib/checksum.c
28059 + * Optimized checksum utilities for IP.
28060 + *
28061 + * (C) Copyright 2009, Ubicom, Inc.
28062 + *
28063 + * This file is part of the Ubicom32 Linux Kernel Port.
28064 + *
28065 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28066 + * it and/or modify it under the terms of the GNU General Public License
28067 + * as published by the Free Software Foundation, either version 2 of the
28068 + * License, or (at your option) any later version.
28069 + *
28070 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28071 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28072 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28073 + * the GNU General Public License for more details.
28074 + *
28075 + * You should have received a copy of the GNU General Public License
28076 + * along with the Ubicom32 Linux Kernel Port. If not,
28077 + * see <http://www.gnu.org/licenses/>.
28078 + *
28079 + * Ubicom32 implementation derived from (with many thanks):
28080 + * arch/m68knommu
28081 + * arch/blackfin
28082 + * arch/parisc
28083 + */
28084 +/*
28085 + * INET An implementation of the TCP/IP protocol suite for the LINUX
28086 + * operating system. INET is implemented using the BSD Socket
28087 + * interface as the means of communication with the user level.
28088 + *
28089 + * IP/TCP/UDP checksumming routines
28090 + *
28091 + * Authors: Jorge Cwik, <jorge@laser.satlink.net>
28092 + * Arnt Gulbrandsen, <agulbra@nvg.unit.no>
28093 + * Tom May, <ftom@netcom.com>
28094 + * Andreas Schwab, <schwab@issan.informatik.uni-dortmund.de>
28095 + * Lots of code moved from tcp.c and ip.c; see those files
28096 + * for more names.
28097 + *
28098 + * 03/02/96 Jes Sorensen, Andreas Schwab, Roman Hodek:
28099 + * Fixed some nasty bugs, causing some horrible crashes.
28100 + * A: At some points, the sum (%0) was used as
28101 + * length-counter instead of the length counter
28102 + * (%1). Thanks to Roman Hodek for pointing this out.
28103 + * B: GCC seems to mess up if one uses too many
28104 + * data-registers to hold input values and one tries to
28105 + * specify d0 and d1 as scratch registers. Letting gcc choose these
28106 + * registers itself solves the problem.
28107 + *
28108 + * This program is free software; you can redistribute it and/or
28109 + * modify it under the terms of the GNU General Public License
28110 + * as published by the Free Software Foundation; either version
28111 + * 2 of the License, or (at your option) any later version.
28112 + */
28113 +
28114 +/* Revised by Kenneth Albanowski for m68knommu. Basic problem: unaligned access kills, so most
28115 + of the assembly has to go. */
28116 +
28117 +#include <linux/module.h>
28118 +#include <net/checksum.h>
28119 +
28120 +static unsigned long do_csum(const unsigned char * buff, int len)
28121 +{
28122 + int count;
28123 + unsigned long result = 0;
28124 +
28125 + /*
28126 + * The following optimized assembly code cannot handle data length less than 7 bytes!
28127 + */
28128 + if (likely(len >= 7)) {
28129 + len -= (4 - (int)buff) & 3;
28130 + count = len >> 2;
28131 + asm (
28132 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28133 + " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
28134 +
28135 + " bfextu d14, %0, #2 \n\t" // test 2 LSB of buff
28136 + " jmpne.w.f 100f \n\t"
28137 + " add.4 %1, #0, %1 \n\t" // clear C
28138 + " moveai a3, #%%hi(1f) \n\t" // table jump
28139 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28140 + " lea.4 a3, (a3,d15) \n\t"
28141 + " calli a3, 0(a3) \n\t"
28142 +
28143 + "100: sub.4 %0, %0, d14 \n\t"
28144 + " sub.4 d14, #4, d14 \n\t"
28145 + " lsl.4 d14, d14, #3 \n\t"
28146 + " add.4 %1, #0, %1 \n\t" // clear C
28147 + " moveai a3, #%%hi(1f) \n\t" // table jump
28148 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28149 + " lea.4 a3, (a3,d15) \n\t"
28150 + " bfextu %1, (%0)4++, d14 \n\t" // read first partial word
28151 + " calli a3, 0(a3) \n\t"
28152 +#if 1
28153 + "200: lsl.4 %3, %3, #3 \n\t"
28154 + " bfrvrs d15, (%0), #0 \n\t" // read last word (partial)
28155 + " bfextu d15, d15, %3 \n\t"
28156 + " bfrvrs d15, d15, #0 \n\t"
28157 + " add.4 %1, d15, %1 \n\t"
28158 + " addc %1, #0, %1 \n\t" // sample C again
28159 + " jmpt.w.t 2f \n\t"
28160 +#else
28161 + "200: move.1 d15, 0(%0) \n\t"
28162 + " lsl.4 d15, d15, #8 \n\t"
28163 + " add.4 %1, d15, %1 \n\t"
28164 + " addc %1, #0, %1 \n\t" // sample C again
28165 + " add.4 %3, #-1, %3 \n\t"
28166 + " jmpeq.w.t 2f \n\t"
28167 +
28168 + " move.1 d15, 1(%0) \n\t"
28169 + " add.4 %1, d15, %1 \n\t"
28170 + " addc %1, #0, %1 \n\t" // sample C again
28171 + " add.4 %3, #-1, %3 \n\t"
28172 + " jmpeq.w.t 2f \n\t"
28173 +
28174 + " move.1 d15, 2(%0) \n\t"
28175 + " lsl.4 d15, d15, #8 \n\t"
28176 + " add.4 %1, d15, %1 \n\t"
28177 + " addc %1, #0, %1 \n\t" // sample C again
28178 + " jmpt.w.t 2f \n\t"
28179 +#endif
28180 +#if defined(IP7000) || defined(IP7000_REV2)
28181 + "300: swapb.2 %1, %1 \n\t"
28182 +#else
28183 + "300: shmrg.2 %1, %1, %1 \n\t"
28184 + " lsr.4 %1, %1, #8 \n\t"
28185 + " bfextu %1, %1, #16 \n\t"
28186 +#endif
28187 + " jmpt.w.t 3f \n\t"
28188 +
28189 + "1: add.4 %1, (%0)4++, %1 \n\t" // first add without C
28190 + " .rept 31 \n\t"
28191 + " addc %1, (%0)4++, %1 \n\t"
28192 + " .endr \n\t"
28193 + " addc %1, #0, %1 \n\t" // sample C again
28194 + " add.4 %2, #-32, %2 \n\t"
28195 + " jmpgt.w.t 1b \n\t"
28196 +
28197 + " and.4 %3, #3, %3 \n\t" // check n
28198 + " jmpne.w.f 200b \n\t"
28199 +
28200 + "2: .rept 2 \n\t"
28201 + " lsr.4 d15, %1, #16 \n\t"
28202 + " bfextu %1, %1, #16 \n\t"
28203 + " add.4 %1, d15, %1 \n\t"
28204 + " .endr \n\t"
28205 + " btst d14, #3 \n\t" // start from odd address (<< 3)?
28206 + " jmpne.w.f 300b \n\t"
28207 + "3: \n\t"
28208 +
28209 + : "+a"(buff), "+d"(result), "+d"(count), "+d"(len)
28210 + :
28211 + : "d15", "d14", "a3", "cc"
28212 + );
28213 +
28214 + return result;
28215 + }
28216 +
28217 + /*
28218 + * handle a few bytes and fold result into 16-bit
28219 + */
28220 + while (len-- > 0) {
28221 + result += (*buff++ << 8);
28222 + if (len) {
28223 + result += *buff++;
28224 + len--;
28225 + }
28226 + }
28227 + asm (
28228 + " .rept 2 \n\t"
28229 + " lsr.4 d15, %0, #16 \n\t"
28230 + " bfextu %0, %0, #16 \n\t"
28231 + " add.4 %0, d15, %0 \n\t"
28232 + " .endr \n\t"
28233 + : "+d" (result)
28234 + :
28235 + : "d15", "cc"
28236 + );
28237 +
28238 + return result;
28239 +}
28240 +
28241 +/*
28242 + * This is a version of ip_compute_csum() optimized for IP headers,
28243 + * which always checksum on 4 octet boundaries.
28244 + */
28245 +__sum16 ip_fast_csum(const void *iph, unsigned int ihl)
28246 +{
28247 + return (__force __sum16)~do_csum(iph,ihl*4);
28248 +}
28249 +
28250 +/*
28251 + * computes the checksum of a memory block at buff, length len,
28252 + * and adds in "sum" (32-bit)
28253 + *
28254 + * returns a 32-bit number suitable for feeding into itself
28255 + * or csum_tcpudp_magic
28256 + *
28257 + * this function must be called with even lengths, except
28258 + * for the last fragment, which may be odd
28259 + *
28260 + * it's best to have buff aligned on a 32-bit boundary
28261 + */
28262 +__wsum csum_partial(const void *buff, int len, __wsum sum)
28263 +{
28264 + unsigned int result = do_csum(buff, len);
28265 +
28266 + /* add in old sum, and carry.. */
28267 + result += (__force u32)sum;
28268 + if ((__force u32)sum > result)
28269 + result += 1;
28270 + return (__force __wsum)result;
28271 +}
28272 +
28273 +EXPORT_SYMBOL(csum_partial);
28274 +
28275 +/*
28276 + * this routine is used for miscellaneous IP-like checksums, mainly
28277 + * in icmp.c
28278 + */
28279 +__sum16 ip_compute_csum(const void *buff, int len)
28280 +{
28281 + return (__force __sum16)~do_csum(buff,len);
28282 +}
28283 +
28284 +/*
28285 + * copy from fs while checksumming, otherwise like csum_partial
28286 + */
28287 +
28288 +__wsum
28289 +csum_partial_copy_from_user(const void __user *src, void *dst,
28290 + int len, __wsum sum, int *csum_err)
28291 +{
28292 + if (csum_err) *csum_err = 0;
28293 + memcpy(dst, (__force const void *)src, len);
28294 + return csum_partial(dst, len, sum);
28295 +}
28296 +
28297 +/*
28298 + * copy from ds while checksumming, otherwise like csum_partial
28299 + */
28300 +
28301 +__wsum
28302 +csum_partial_copy_nocheck(const void *src, void *dst, int len, __wsum sum)
28303 +{
28304 + memcpy(dst, src, len);
28305 + return csum_partial(dst, len, sum);
28306 +}
28307 diff -ruN linux-2.6.30.10/arch/ubicom32/lib/delay.c linux-2.6.30.10-ubi/arch/ubicom32/lib/delay.c
28308 --- linux-2.6.30.10/arch/ubicom32/lib/delay.c 1970-01-01 02:00:00.000000000 +0200
28309 +++ linux-2.6.30.10-ubi/arch/ubicom32/lib/delay.c 2009-12-11 11:45:11.000000000 +0200
28310 @@ -0,0 +1,49 @@
28311 +/*
28312 + * arch/ubicom32/lib/delay.c
28313 + * Ubicom32 implementation of udelay()
28314 + *
28315 + * (C) Copyright 2009, Ubicom, Inc.
28316 + *
28317 + * This file is part of the Ubicom32 Linux Kernel Port.
28318 + *
28319 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28320 + * it and/or modify it under the terms of the GNU General Public License
28321 + * as published by the Free Software Foundation, either version 2 of the
28322 + * License, or (at your option) any later version.
28323 + *
28324 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28325 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28326 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28327 + * the GNU General Public License for more details.
28328 + *
28329 + * You should have received a copy of the GNU General Public License
28330 + * along with the Ubicom32 Linux Kernel Port. If not,
28331 + * see <http://www.gnu.org/licenses/>.
28332 + *
28333 + * Ubicom32 implementation derived from (with many thanks):
28334 + * arch/m68knommu
28335 + * arch/blackfin
28336 + * arch/parisc
28337 + */
28338 +
28339 +#include <linux/module.h>
28340 +#include <asm/param.h>
28341 +#include <asm/delay.h>
28342 +#include <asm/ip5000.h>
28343 +
28344 +/*
28345 + * read_current_timer()
28346 + * Return the current value of sysval.
28347 + */
28348 +int __devinit read_current_timer(unsigned long *timer_val)
28349 +{
28350 + *timer_val = (long)(UBICOM32_IO_TIMER->sysval);
28351 + return 0;
28352 +}
28353 +
28354 +
28355 +void udelay(unsigned long usecs)
28356 +{
28357 + _udelay(usecs);
28358 +}
28359 +EXPORT_SYMBOL(udelay);
28360 diff -ruN linux-2.6.30.10/arch/ubicom32/lib/Makefile linux-2.6.30.10-ubi/arch/ubicom32/lib/Makefile
28361 --- linux-2.6.30.10/arch/ubicom32/lib/Makefile 1970-01-01 02:00:00.000000000 +0200
28362 +++ linux-2.6.30.10-ubi/arch/ubicom32/lib/Makefile 2009-12-11 11:45:11.000000000 +0200
28363 @@ -0,0 +1,32 @@
28364 +#
28365 +# arch/ubicom32/lib/Makefile
28366 +# <TODO: Replace with short file description>
28367 +#
28368 +# (C) Copyright 2009, Ubicom, Inc.
28369 +#
28370 +# This file is part of the Ubicom32 Linux Kernel Port.
28371 +#
28372 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
28373 +# it and/or modify it under the terms of the GNU General Public License
28374 +# as published by the Free Software Foundation, either version 2 of the
28375 +# License, or (at your option) any later version.
28376 +#
28377 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
28378 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
28379 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28380 +# the GNU General Public License for more details.
28381 +#
28382 +# You should have received a copy of the GNU General Public License
28383 +# along with the Ubicom32 Linux Kernel Port. If not,
28384 +# see <http://www.gnu.org/licenses/>.
28385 +#
28386 +# Ubicom32 implementation derived from (with many thanks):
28387 +# arch/m68knommu
28388 +# arch/blackfin
28389 +# arch/parisc
28390 +#
28391 +#
28392 +# Makefile for m68knommu specific library files..
28393 +#
28394 +
28395 +lib-y := checksum.o delay.o mem_ubicom32.o
28396 diff -ruN linux-2.6.30.10/arch/ubicom32/lib/mem_ubicom32.c linux-2.6.30.10-ubi/arch/ubicom32/lib/mem_ubicom32.c
28397 --- linux-2.6.30.10/arch/ubicom32/lib/mem_ubicom32.c 1970-01-01 02:00:00.000000000 +0200
28398 +++ linux-2.6.30.10-ubi/arch/ubicom32/lib/mem_ubicom32.c 2009-12-11 11:45:11.000000000 +0200
28399 @@ -0,0 +1,343 @@
28400 +/*
28401 + * arch/ubicom32/lib/mem_ubicom32.c
28402 + * String functions.
28403 + *
28404 + * (C) Copyright 2009, Ubicom, Inc.
28405 + *
28406 + * This file is part of the Ubicom32 Linux Kernel Port.
28407 + *
28408 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28409 + * it and/or modify it under the terms of the GNU General Public License
28410 + * as published by the Free Software Foundation, either version 2 of the
28411 + * License, or (at your option) any later version.
28412 + *
28413 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28414 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28415 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28416 + * the GNU General Public License for more details.
28417 + *
28418 + * You should have received a copy of the GNU General Public License
28419 + * along with the Ubicom32 Linux Kernel Port. If not,
28420 + * see <http://www.gnu.org/licenses/>.
28421 + *
28422 + * Ubicom32 implementation derived from (with many thanks):
28423 + * arch/m68knommu
28424 + * arch/blackfin
28425 + * arch/parisc
28426 + */
28427 +
28428 +#include <linux/module.h>
28429 +#include <linux/types.h>
28430 +#include <linux/compiler.h>
28431 +
28432 +#define LIKELY likely
28433 +#define UNLIKELY unlikely
28434 +
28435 +typedef u32_t addr_t;
28436 +
28437 +/*
28438 + * memcpy()
28439 + */
28440 +void *memcpy(void *dest, const void *src, size_t n)
28441 +{
28442 + void *dest_ret = dest;
28443 +
28444 + if (LIKELY((((addr_t)dest ^ (addr_t)src) & 3) == 0) && LIKELY(n > 6)) {
28445 + size_t m;
28446 + n -= (4 - (addr_t)dest) & 0x03;
28447 + m = n >> 2;
28448 + asm volatile (
28449 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28450 + " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
28451 + " moveai a3, #%%hi(1f) \n\t"
28452 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28453 + " lea.4 a3, (a3,d15) \n\t"
28454 +
28455 + " bfextu d15, %0, #2 \n\t" // d15 = (dest & 3)
28456 + " jmpne.w.f 100f \n\t"
28457 + " calli a3, 0(a3) \n\t" // 4-byte alignment
28458 +
28459 + "100: cmpi d15, #2 \n\t"
28460 + " jmpne.s.f 101f \n\t"
28461 + " move.2 (%0)2++, (%1)2++ \n\t"
28462 + " calli a3, 0(a3) \n\t" // 2-byte alignment
28463 +
28464 + "101: move.1 (%0)1++, (%1)1++ \n\t"
28465 + " jmpgt.s.f 102f \n\t" // 3-byte alignment
28466 + " move.2 (%0)2++, (%1)2++ \n\t" // 1-byte alignment
28467 + "102: calli a3, 0(a3) \n\t"
28468 +
28469 + "200: cmpi %3, #2 \n\t"
28470 + " jmplt.s.f 201f \n\t"
28471 + " move.2 (%0)2++, (%1)2++ \n\t"
28472 + " jmpeq.s.t 2f \n\t"
28473 + "201: move.1 (%0)1++, (%1)1++ \n\t"
28474 + " jmpt.w.t 2f \n\t"
28475 +
28476 + "1: .rept 25 \n\t"
28477 + " movea (%0)4++, (%1)4++ \n\t"
28478 + " .endr \n\t"
28479 + " .rept 7 \n\t"
28480 + " move.4 (%0)4++, (%1)4++ \n\t"
28481 + " .endr \n\t"
28482 + " add.4 %2, #-32, %2 \n\t"
28483 + " jmpgt.w.f 1b \n\t"
28484 +
28485 + " and.4 %3, #3, %3 \n\t" // check n
28486 + " jmpne.w.f 200b \n\t"
28487 + "2: \n\t"
28488 + : "+a" (dest), "+a" (src), "+d" (m), "+d" (n)
28489 + :
28490 + : "d15", "a3", "memory", "cc"
28491 + );
28492 +
28493 + return dest_ret;
28494 + }
28495 +
28496 + if (LIKELY((((addr_t)dest ^ (addr_t)src) & 1) == 0) && LIKELY(n > 2)) {
28497 + size_t m;
28498 + n -= (addr_t)dest & 0x01;
28499 + m = n >> 1;
28500 + asm volatile (
28501 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28502 + " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
28503 + " moveai a3, #%%hi(1f) \n\t"
28504 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28505 + " lea.4 a3, (a3,d15) \n\t"
28506 +
28507 + " btst %0, #0 \n\t" // check bit 0
28508 + " jmpne.w.f 100f \n\t"
28509 + " calli a3, 0(a3) \n\t" // 4-byte alignment
28510 +
28511 + "100: move.1 (%0)1++, (%1)1++ \n\t"
28512 + " calli a3, 0(a3) \n\t"
28513 +
28514 + "200: move.1 (%0)1++, (%1)1++ \n\t"
28515 + " jmpt.w.t 2f \n\t"
28516 +
28517 + "1: .rept 32 \n\t"
28518 + " move.2 (%0)2++, (%1)2++ \n\t"
28519 + " .endr \n\t"
28520 + " add.4 %2, #-32, %2 \n\t"
28521 + " jmpgt.w.f 1b \n\t"
28522 +
28523 + " and.4 %3, #1, %3 \n\t" // check n
28524 + " jmpne.w.f 200b \n\t"
28525 + "2: \n\t"
28526 +
28527 + : "+a" (dest), "+a" (src), "+d" (m), "+d" (n)
28528 + :
28529 + : "d15", "a3", "memory", "cc"
28530 + );
28531 +
28532 + return dest_ret;
28533 + }
28534 +
28535 + asm volatile (
28536 + " sub.4 d15, #0, %2 \n\t"
28537 + " jmpeq.w.f 2f \n\t"
28538 + " and.4 d15, #(16-1), d15 \n\t" // d15 = (-n) & (16 - 1)
28539 + " moveai a3, #%%hi(1f) \n\t"
28540 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28541 + " lea.4 a3, (a3,d15) \n\t"
28542 + " calli a3, 0(a3) \n\t"
28543 +
28544 + "1: .rept 16 \n\t"
28545 + " move.1 (%0)1++, (%1)1++ \n\t"
28546 + " .endr \n\t"
28547 + " add.4 %2, #-16, %2 \n\t"
28548 + " jmpgt.w.f 1b \n\t"
28549 + "2: \n\t"
28550 +
28551 + : "+a" (dest), "+a" (src), "+d" (n)
28552 + :
28553 + : "d15", "a3", "memory", "cc"
28554 + );
28555 +
28556 + return dest_ret;
28557 +}
28558 +
28559 +/*
28560 + * memset()
28561 + */
28562 +void *memset(void *s, int c, size_t n)
28563 +{
28564 + void *s_ret = s;
28565 +
28566 + if (LIKELY(n > 6)) {
28567 + size_t m;
28568 + n -= (4 - (addr_t)s) & 0x03;
28569 + m = n >> 2;
28570 + asm volatile (
28571 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28572 + " and.4 d15, #(32-1), d15 \n\t" // d15 = (-m) & (32 - 1)
28573 + " shmrg.1 %1, %1, %1 \n\t"
28574 + " shmrg.2 %1, %1, %1 \n\t" // %1 = (c<<24)|(c<<16)|(c<<8)|c
28575 + " moveai a3, #%%hi(1f) \n\t"
28576 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28577 + " lea.4 a3, (a3,d15) \n\t"
28578 +
28579 + " bfextu d15, %0, #2 \n\t" // d15 = (s & 3)
28580 + " jmpne.w.f 100f \n\t"
28581 + " calli a3, 0(a3) \n\t" // 4-byte alignment
28582 +
28583 + "100: cmpi d15, #2 \n\t"
28584 + " jmpne.s.f 101f \n\t"
28585 + " move.2 (%0)2++, %1 \n\t"
28586 + " calli a3, 0(a3) \n\t" // 2-byte alignment
28587 +
28588 + "101: move.1 (%0)1++, %1 \n\t"
28589 + " jmpgt.s.f 102f \n\t" // 3-byte alignment
28590 + " move.2 (%0)2++, %1 \n\t" // 1-byte alignment
28591 + "102: calli a3, 0(a3) \n\t"
28592 +
28593 + "200: cmpi %3, #2 \n\t"
28594 + " jmplt.s.f 201f \n\t"
28595 + " move.2 (%0)2++, %1 \n\t"
28596 + " jmpeq.s.t 2f \n\t"
28597 + "201: move.1 (%0)1++, %1 \n\t"
28598 + " jmpt.w.t 2f \n\t"
28599 +
28600 + "1: .rept 25 \n\t"
28601 + " movea (%0)4++, %1 \n\t"
28602 + " .endr \n\t"
28603 + " .rept 7 \n\t"
28604 + " move.4 (%0)4++, %1 \n\t"
28605 + " .endr \n\t"
28606 + " add.4 %2, #-32, %2 \n\t"
28607 + " jmpgt.w.f 1b \n\t"
28608 +
28609 + " and.4 %3, #3, %3 \n\t" // test bit 1 of n
28610 + " jmpne.w.f 200b \n\t"
28611 + "2: \n\t"
28612 +
28613 + : "+a" (s), "+d" (c), "+d" (m), "+d" (n)
28614 + :
28615 + : "d15", "a3", "memory", "cc"
28616 + );
28617 +
28618 + return s_ret;
28619 + }
28620 +
28621 + asm volatile (
28622 + " sub.4 d15, #0, %2 \n\t"
28623 + " jmpeq.w.f 2f \n\t"
28624 + " and.4 d15, #(8-1), d15 \n\t" // d15 = (-%2) & (16 - 1)
28625 + " moveai a3, #%%hi(1f) \n\t"
28626 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28627 + " lea.4 a3, (a3,d15) \n\t"
28628 + " calli a3, 0(a3) \n\t"
28629 +
28630 + "1: .rept 8 \n\t"
28631 + " move.1 (%0)1++, %1 \n\t"
28632 + " .endr \n\t"
28633 + "2: \n\t"
28634 +
28635 + : "+a" (s), "+d" (c), "+d" (n)
28636 + :
28637 + : "d15", "a3", "memory", "cc"
28638 + );
28639 +
28640 + return s_ret;
28641 +}
28642 +
28643 +void *memmove(void *dest, const void *src, size_t n)
28644 +{
28645 + char *tmp;
28646 + const char *s;
28647 +
28648 + if (n == 0)
28649 + return dest;
28650 +
28651 + tmp = dest;
28652 + s = src;
28653 +
28654 + /*
28655 + * Will perform 16-bit move if possible
28656 + */
28657 + if (likely((((u32)dest | (u32)src | n) & 1) == 0)) {
28658 + if (dest <= src) {
28659 + asm volatile (
28660 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28661 + " and.4 d15, #(32-2), d15 \n\t" // d15 = (- count) & (32 - 2)
28662 + " moveai a3, #%%hi(1f) \n\t"
28663 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28664 + " lea.2 a3, (a3,d15) \n\t"
28665 + " calli a3, 0(a3) \n\t"
28666 +
28667 + "1: .rept 16 \n\t"
28668 + " move.2 (%0)2++, (%1)2++ \n\t"
28669 + " .endr \n\t"
28670 + " add.4 %2, #-32, %2 \n\t"
28671 + " jmpgt.w.f 1b \n\t"
28672 +
28673 + : "+a" (tmp), "+a" (s), "+d" (n)
28674 + :
28675 + : "d15", "a3", "memory", "cc"
28676 + );
28677 + } else {
28678 + tmp += n;
28679 + s += n;
28680 + asm volatile (
28681 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28682 + " and.4 d15, #(32-2), d15 \n\t" // d15 = (- count) & (32 - 2)
28683 + " moveai a3, #%%hi(1f) \n\t"
28684 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28685 + " lea.2 a3, (a3,d15) \n\t"
28686 + " calli a3, 0(a3) \n\t"
28687 +
28688 + "1: .rept 16 \n\t"
28689 + " move.2 -2(%0)++, -2(%1)++ \n\t"
28690 + " .endr \n\t"
28691 + " add.4 %2, #-32, %2 \n\t"
28692 + " jmpgt.w.f 1b \n\t"
28693 +
28694 + : "+a" (tmp), "+a" (s), "+d" (n)
28695 + :
28696 + : "d15", "a3", "memory", "cc"
28697 + );
28698 + }
28699 + return dest;
28700 + }
28701 +
28702 + if (dest <= src) {
28703 + asm volatile (
28704 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28705 + " and.4 d15, #(16-1), d15 \n\t" // d15 = (- count) & (16 - 1)
28706 + " moveai a3, #%%hi(1f) \n\t"
28707 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28708 + " lea.4 a3, (a3,d15) \n\t"
28709 + " calli a3, 0(a3) \n\t"
28710 +
28711 + "1: .rept 16 \n\t"
28712 + " move.1 (%0)1++, (%1)1++ \n\t"
28713 + " .endr \n\t"
28714 + " add.4 %2, #-16, %2 \n\t"
28715 + " jmpgt.w.f 1b \n\t"
28716 + : "+a" (tmp), "+a" (s), "+d" (n)
28717 + :
28718 + : "d15", "a3", "memory", "cc"
28719 + );
28720 + } else {
28721 + tmp += n;
28722 + s += n;
28723 + asm volatile (
28724 + " sub.4 d15, #0, %2 \n\t" // set up for jump table
28725 + " and.4 d15, #(16-1), d15 \n\t" // d15 = (- count) & (16 - 1)
28726 + " moveai a3, #%%hi(1f) \n\t"
28727 + " lea.1 a3, %%lo(1f)(a3) \n\t"
28728 + " lea.4 a3, (a3,d15) \n\t"
28729 + " calli a3, 0(a3) \n\t"
28730 +
28731 + "1: .rept 16 \n\t"
28732 + " move.1 -1(%0)++, -1(%1)++ \n\t"
28733 + " .endr \n\t"
28734 + " add.4 %2, #-16, %2 \n\t"
28735 + " jmpgt.w.f 1b \n\t"
28736 + : "+a" (tmp), "+a" (s), "+d" (n)
28737 + :
28738 + : "d15", "a3", "memory", "cc"
28739 + );
28740 + }
28741 + return dest;
28742 +}
28743 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/audio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/audio.c
28744 --- linux-2.6.30.10/arch/ubicom32/mach-common/audio.c 1970-01-01 02:00:00.000000000 +0200
28745 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/audio.c 2009-12-11 11:45:11.000000000 +0200
28746 @@ -0,0 +1,134 @@
28747 +/*
28748 + * arch/ubicom32/mach-common/audio.c
28749 + * Generic initialization for Ubicom32 Audio
28750 + *
28751 + * (C) Copyright 2009, Ubicom, Inc.
28752 + *
28753 + * This file is part of the Ubicom32 Linux Kernel Port.
28754 + *
28755 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28756 + * it and/or modify it under the terms of the GNU General Public License
28757 + * as published by the Free Software Foundation, either version 2 of the
28758 + * License, or (at your option) any later version.
28759 + *
28760 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28761 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28762 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28763 + * the GNU General Public License for more details.
28764 + *
28765 + * You should have received a copy of the GNU General Public License
28766 + * along with the Ubicom32 Linux Kernel Port. If not,
28767 + * see <http://www.gnu.org/licenses/>.
28768 + */
28769 +
28770 +#include <linux/platform_device.h>
28771 +#include <linux/types.h>
28772 +
28773 +#include <asm/devtree.h>
28774 +#include <asm/audio.h>
28775 +#include <asm/ubi32-pcm.h>
28776 +
28777 +/*
28778 + * The number of audio devices currently allocated, used for .id
28779 + */
28780 +static int __initdata audio_device_count;
28781 +
28782 +/*
28783 + * The maximum number of resources (cards) that the audio will have.
28784 + * Currently 3, a register space, and up to 2 interrupts.
28785 + */
28786 +#define AUDIO_MAX_RESOURCES 3
28787 +
28788 +/*
28789 + * audio_device_alloc
28790 + * Checks the device tree and allocates a platform_device if found
28791 + */
28792 +struct platform_device * __init audio_device_alloc(const char *driver_name,
28793 + const char *node_name, const char *inst_name, int priv_bytes)
28794 +{
28795 + struct platform_device *pdev;
28796 + struct resource *res;
28797 + struct audio_node *audio_node;
28798 + struct ubi32pcm_platform_data *pdata;
28799 + struct audio_dev_regs *adr;
28800 + int idx;
28801 +
28802 + /*
28803 + * Check the device tree for the audio node
28804 + */
28805 + audio_node = (struct audio_node *)devtree_find_node(node_name);
28806 + if (!audio_node) {
28807 + printk(KERN_WARNING "audio device '%s' not found\n", node_name);
28808 + return NULL;
28809 + }
28810 +
28811 + if (audio_node->version != AUDIONODE_VERSION) {
28812 + printk(KERN_WARNING "audio node not compatible\n");
28813 + return NULL;
28814 + }
28815 +
28816 + /*
28817 + * Find the instance in this node
28818 + */
28819 + adr = audio_node->regs->adr;
28820 + for (idx = 0; idx < audio_node->regs->max_devs; idx++) {
28821 + if ((adr->version == AUDIO_DEV_REGS_VERSION) &&
28822 + (strcmp(adr->name, inst_name) == 0)) {
28823 + break;
28824 + }
28825 + adr++;
28826 + }
28827 + if (idx == audio_node->regs->max_devs) {
28828 + printk(KERN_WARNING "audio inst '%s' not found in device '%s'\n", inst_name, node_name);
28829 + return NULL;
28830 + }
28831 +
28832 + /*
28833 + * Dynamically create the platform_device structure and resources
28834 + */
28835 + pdev = kzalloc(sizeof(struct platform_device) +
28836 + sizeof(struct ubi32pcm_platform_data) +
28837 + priv_bytes , GFP_KERNEL);
28838 + if (!pdev) {
28839 + printk(KERN_WARNING "audio could not alloc pdev\n");
28840 + return NULL;
28841 + }
28842 +
28843 + res = kzalloc(sizeof(struct resource) * AUDIO_MAX_RESOURCES,
28844 + GFP_KERNEL);
28845 + if (!res) {
28846 + kfree(pdev);
28847 + printk(KERN_WARNING "audio could not alloc res\n");
28848 + return NULL;
28849 + }
28850 +
28851 + pdev->name = driver_name;
28852 + pdev->id = audio_device_count++;
28853 + pdev->resource = res;
28854 +
28855 + /*
28856 + * Fill in the resources and platform data from devtree information
28857 + */
28858 + res[0].start = (u32_t)(audio_node->regs);
28859 + res[0].end = (u32_t)(audio_node->regs);
28860 + res[0].flags = IORESOURCE_MEM;
28861 + res[1 + AUDIO_TX_IRQ_RESOURCE].start = audio_node->dn.sendirq;
28862 + res[1 + AUDIO_TX_IRQ_RESOURCE].flags = IORESOURCE_IRQ;
28863 + res[1 + AUDIO_RX_IRQ_RESOURCE].start = audio_node->dn.recvirq;
28864 + res[1 + AUDIO_RX_IRQ_RESOURCE].flags = IORESOURCE_IRQ;
28865 + pdev->num_resources = 3;
28866 +
28867 + printk(KERN_INFO "Audio.%d '%s':'%s' found irq=%d/%d.%d regs=%p pdev=%p/%p\n",
28868 + pdev->id, node_name, inst_name, audio_node->dn.sendirq,
28869 + audio_node->dn.recvirq, idx, audio_node->regs, pdev, res);
28870 + pdata = (struct ubi32pcm_platform_data *)(pdev + 1);
28871 + pdev->dev.platform_data = pdata;
28872 + pdata->node_name = node_name;
28873 + pdata->inst_name = inst_name;
28874 + pdata->inst_num = idx;
28875 + if (priv_bytes) {
28876 + pdata->priv_data = pdata + 1;
28877 + }
28878 +
28879 + return pdev;
28880 +}
28881 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/board.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/board.c
28882 --- linux-2.6.30.10/arch/ubicom32/mach-common/board.c 1970-01-01 02:00:00.000000000 +0200
28883 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/board.c 2009-12-11 11:45:11.000000000 +0200
28884 @@ -0,0 +1,63 @@
28885 +/*
28886 + * arch/ubicom32/mach-common/board.c
28887 + * Board init and support code.
28888 + *
28889 + * (C) Copyright 2009, Ubicom, Inc.
28890 + *
28891 + * This file is part of the Ubicom32 Linux Kernel Port.
28892 + *
28893 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28894 + * it and/or modify it under the terms of the GNU General Public License
28895 + * as published by the Free Software Foundation, either version 2 of the
28896 + * License, or (at your option) any later version.
28897 + *
28898 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28899 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28900 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28901 + * the GNU General Public License for more details.
28902 + *
28903 + * You should have received a copy of the GNU General Public License
28904 + * along with the Ubicom32 Linux Kernel Port. If not,
28905 + * see <http://www.gnu.org/licenses/>.
28906 + *
28907 + * Ubicom32 implementation derived from (with many thanks):
28908 + * arch/m68knommu
28909 + * arch/blackfin
28910 + * arch/parisc
28911 + */
28912 +#include <linux/module.h>
28913 +#include <linux/types.h>
28914 +#include <linux/cpu.h>
28915 +#include <asm/devtree.h>
28916 +
28917 +struct boardnode {
28918 + struct devtree_node dn;
28919 + const char *revision;
28920 +};
28921 +
28922 +static const struct boardnode *bn;
28923 +
28924 +/*
28925 + * board_get_revision()
28926 + * Returns revision string of the board.
28927 + */
28928 +const char *board_get_revision(void)
28929 +{
28930 + if (!bn) {
28931 + return "NULL";
28932 + }
28933 +
28934 + return bn->revision;
28935 +}
28936 +
28937 +/*
28938 + * board_init
28939 + */
28940 +void __init board_init(void)
28941 +{
28942 + bn = (struct boardnode *)devtree_find_node("board");
28943 + if (!bn) {
28944 + printk(KERN_WARNING "board node not found\n");
28945 + return;
28946 + }
28947 +}
28948 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/bootargs.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/bootargs.c
28949 --- linux-2.6.30.10/arch/ubicom32/mach-common/bootargs.c 1970-01-01 02:00:00.000000000 +0200
28950 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/bootargs.c 2009-12-11 11:45:11.000000000 +0200
28951 @@ -0,0 +1,63 @@
28952 +/*
28953 + * arch/ubicom32/mach-common/bootargs.c
28954 + * Board init and support code.
28955 + *
28956 + * (C) Copyright 2009, Ubicom, Inc.
28957 + *
28958 + * This file is part of the Ubicom32 Linux Kernel Port.
28959 + *
28960 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
28961 + * it and/or modify it under the terms of the GNU General Public License
28962 + * as published by the Free Software Foundation, either version 2 of the
28963 + * License, or (at your option) any later version.
28964 + *
28965 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
28966 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
28967 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
28968 + * the GNU General Public License for more details.
28969 + *
28970 + * You should have received a copy of the GNU General Public License
28971 + * along with the Ubicom32 Linux Kernel Port. If not,
28972 + * see <http://www.gnu.org/licenses/>.
28973 + *
28974 + * Ubicom32 implementation derived from (with many thanks):
28975 + * arch/m68knommu
28976 + * arch/blackfin
28977 + * arch/parisc
28978 + */
28979 +#include <linux/module.h>
28980 +#include <linux/types.h>
28981 +#include <linux/cpu.h>
28982 +#include <asm/devtree.h>
28983 +
28984 +struct bootargsnode {
28985 + struct devtree_node dn;
28986 + const char cmdline[512];
28987 +};
28988 +
28989 +static const struct bootargsnode *ban;
28990 +
28991 +/*
28992 + * bootargs_get_cmdline()
28993 + * Returns kernel boot arguments set by the bootloader.
28994 + */
28995 +const char *bootargs_get_cmdline(void)
28996 +{
28997 + if (!ban) {
28998 + return "";
28999 + }
29000 +
29001 + return ban->cmdline;
29002 +}
29003 +
29004 +/*
29005 + * bootargs_init
29006 + */
29007 +void __init bootargs_init(void)
29008 +{
29009 + ban = (struct bootargsnode *)devtree_find_node("bootargs");
29010 + if (!ban) {
29011 + printk(KERN_WARNING "bootargs node not found\n");
29012 + return;
29013 + }
29014 +}
29015 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/cachectl.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/cachectl.c
29016 --- linux-2.6.30.10/arch/ubicom32/mach-common/cachectl.c 1970-01-01 02:00:00.000000000 +0200
29017 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/cachectl.c 2009-12-11 11:45:11.000000000 +0200
29018 @@ -0,0 +1,136 @@
29019 +/*
29020 + * arch/ubicom32/mach-common/cachectl.c
29021 + * Architecture cache control support
29022 + *
29023 + * (C) Copyright 2009, Ubicom, Inc.
29024 + *
29025 + * This file is part of the Ubicom32 Linux Kernel Port.
29026 + *
29027 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
29028 + * it and/or modify it under the terms of the GNU General Public License
29029 + * as published by the Free Software Foundation, either version 2 of the
29030 + * License, or (at your option) any later version.
29031 + *
29032 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
29033 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
29034 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
29035 + * the GNU General Public License for more details.
29036 + *
29037 + * You should have received a copy of the GNU General Public License
29038 + * along with the Ubicom32 Linux Kernel Port. If not,
29039 + * see <http://www.gnu.org/licenses/>.
29040 + *
29041 + * Ubicom32 implementation derived from (with many thanks):
29042 + * arch/m68knommu
29043 + * arch/blackfin
29044 + * arch/parisc
29045 + */
29046 +
29047 +#include <linux/types.h>
29048 +#include <linux/module.h>
29049 +#include <asm/cachectl.h>
29050 +
29051 +/*
29052 + * The write queue flush procedure in mem_cache_control needs to make
29053 + * DCACHE_WRITE_QUEUE_LENGTH writes to DDR (not OCM). Here we reserve some
29054 + * memory for this operation.
29055 + * Allocate array of cache lines of least DCACHE_WRITE_QUEUE_LENGTH + 1 words in
29056 + * length rounded up to the nearest cache line.
29057 + */
29058 +#define CACHE_WRITE_QUEUE_FLUSH_AREA_SIZE \
29059 + ALIGN(sizeof(int) * (DCACHE_WRITE_QUEUE_LENGTH + 1), CACHE_LINE_SIZE)
29060 +
29061 +static char cache_write_queue_flush_area[CACHE_WRITE_QUEUE_FLUSH_AREA_SIZE]
29062 + __attribute__((aligned(CACHE_LINE_SIZE)));
29063 +
29064 +/*
29065 + * ONE_CCR_ADDR_OP is a helper macro that executes a single CCR operation.
29066 + */
29067 +#define ONE_CCR_ADDR_OP(cc, op_addr, op) \
29068 + do { \
29069 + asm volatile ( \
29070 + " btst "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_VALID)" \n\t" \
29071 + " jmpne.f .-4 \n\t" \
29072 + " move.4 "D(CCR_ADDR)"(%0), %1 \n\t" \
29073 + " move.1 "D(CCR_CTRL+3)"(%0), %2 \n\t" \
29074 + " bset "D(CCR_CTRL)"(%0), "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_VALID)" \n\t" \
29075 + " cycles 2 \n\t" \
29076 + " btst "D(CCR_CTRL)"(%0), #"D(CCR_CTRL_DONE)" \n\t" \
29077 + " jmpeq.f .-4 \n\t" \
29078 + : \
29079 + : "a"(cc), "r"(op_addr), "r"(op & 0xff) \
29080 + : "cc" \
29081 + ); \
29082 + } while (0)
29083 +
29084 +/*
29085 + * mem_cache_control()
29086 + * Special cache control operation
29087 + */
29088 +void mem_cache_control(unsigned long cc, unsigned long begin_addr,
29089 + unsigned long end_addr, unsigned long op)
29090 +{
29091 + unsigned long op_addr;
29092 + int dccr = cc == DCCR_BASE;
29093 + if (dccr && op == CCR_CTRL_FLUSH_ADDR) {
29094 + /*
29095 + * We ensure all previous writes have left the data cache write
29096 + * queue by sending DCACHE_WRITE_QUEUE_LENGTH writes (to
29097 + * different words) down the queue. If this is not done it's
29098 + * possible that the data we are trying to flush hasn't even
29099 + * entered the data cache.
29100 + * The +1 ensure that the final 'flush' is actually a flush.
29101 + */
29102 + int *flush_area = (int *)cache_write_queue_flush_area;
29103 + asm volatile(
29104 + " .rept "D(DCACHE_WRITE_QUEUE_LENGTH + 1)" \n\t"
29105 + " move.4 (%0)4++, d0 \n\t"
29106 + " .endr \n\t"
29107 + : "+a"(flush_area)
29108 + );
29109 + }
29110 +
29111 + if (dccr)
29112 + UBICOM32_LOCK(DCCR_LOCK_BIT);
29113 + else
29114 + UBICOM32_LOCK(ICCR_LOCK_BIT);
29115 +
29116 + /*
29117 + * Calculate the cache lines we need to operate on that include
29118 + * begin_addr though end_addr.
29119 + */
29120 + begin_addr = begin_addr & ~(CACHE_LINE_SIZE - 1);
29121 + end_addr = (end_addr + CACHE_LINE_SIZE - 1) & ~(CACHE_LINE_SIZE - 1);
29122 + op_addr = begin_addr;
29123 +
29124 + do {
29125 + ONE_CCR_ADDR_OP(cc, op_addr, op);
29126 + op_addr += CACHE_LINE_SIZE;
29127 + } while (likely(op_addr < end_addr));
29128 +
29129 + if (dccr && op == CCR_CTRL_FLUSH_ADDR) {
29130 + /*
29131 + * It turns out that when flushing the data cache the last flush
29132 + * isn't actually complete at this point. This is because there
29133 + * is another write buffer on the DDR side of the cache that is
29134 + * arbitrated with the I-Cache.
29135 + *
29136 + * The only foolproof method that ensures that the last data
29137 + * cache flush *actually* completed is to do another flush on a
29138 + * dirty cache line. This flush will block until the DDR write
29139 + * buffer is empty.
29140 + *
29141 + * Rather than creating a another dirty cache line, we use the
29142 + * flush_area above as we know that it is dirty from previous
29143 + * writes.
29144 + */
29145 + ONE_CCR_ADDR_OP(cc, cache_write_queue_flush_area, op);
29146 + }
29147 +
29148 + if (dccr)
29149 + UBICOM32_UNLOCK(DCCR_LOCK_BIT);
29150 + else
29151 + UBICOM32_UNLOCK(ICCR_LOCK_BIT);
29152 +
29153 +}
29154 +EXPORT_SYMBOL(mem_cache_control);
29155 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/common.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/common.c
29156 --- linux-2.6.30.10/arch/ubicom32/mach-common/common.c 1970-01-01 02:00:00.000000000 +0200
29157 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/common.c 2009-12-11 11:45:11.000000000 +0200
29158 @@ -0,0 +1,64 @@
29159 +/*
29160 + * arch/ubicom32/mach-common/common.c
29161 + * Common platform support.
29162 + *
29163 + * (C) Copyright 2009, Ubicom, Inc.
29164 + *
29165 + * This file is part of the Ubicom32 Linux Kernel Port.
29166 + *
29167 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
29168 + * it and/or modify it under the terms of the GNU General Public License
29169 + * as published by the Free Software Foundation, either version 2 of the
29170 + * License, or (at your option) any later version.
29171 + *
29172 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
29173 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
29174 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
29175 + * the GNU General Public License for more details.
29176 + *
29177 + * You should have received a copy of the GNU General Public License
29178 + * along with the Ubicom32 Linux Kernel Port. If not,
29179 + * see <http://www.gnu.org/licenses/>.
29180 + *
29181 + * Ubicom32 implementation derived from (with many thanks):
29182 + * arch/m68knommu
29183 + * arch/blackfin
29184 + * arch/parisc
29185 + */
29186 +#include <linux/version.h>
29187 +#include <linux/kernel.h>
29188 +#include <linux/init.h>
29189 +#include <linux/module.h>
29190 +#include <linux/list.h>
29191 +#include <linux/errno.h>
29192 +#include <linux/err.h>
29193 +#include <linux/string.h>
29194 +#include <linux/clk.h>
29195 +#include <linux/mutex.h>
29196 +#include <linux/platform_device.h>
29197 +
29198 +
29199 +/* Minimum CLK support */
29200 +
29201 +struct clk *clk_get(struct device *dev, const char *id)
29202 +{
29203 + return ERR_PTR(-ENOENT);
29204 +}
29205 +EXPORT_SYMBOL(clk_get);
29206 +
29207 +void clk_put(struct clk *clk)
29208 +{
29209 +}
29210 +EXPORT_SYMBOL(clk_put);
29211 +
29212 +int clk_enable(struct clk *clk)
29213 +{
29214 + return 0;
29215 +}
29216 +EXPORT_SYMBOL(clk_enable);
29217 +
29218 +
29219 +void clk_disable(struct clk *clk)
29220 +{
29221 +}
29222 +EXPORT_SYMBOL(clk_disable);
29223 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/io.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/io.c
29224 --- linux-2.6.30.10/arch/ubicom32/mach-common/io.c 1970-01-01 02:00:00.000000000 +0200
29225 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/io.c 2009-12-11 11:45:11.000000000 +0200
29226 @@ -0,0 +1,250 @@
29227 +/*
29228 + * arch/ubicom32/mach-common/io.c
29229 + * PCI I/O memory read/write support functions.
29230 + *
29231 + * (C) Copyright 2009, Ubicom, Inc.
29232 + *
29233 + * This file is part of the Ubicom32 Linux Kernel Port.
29234 + *
29235 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
29236 + * it and/or modify it under the terms of the GNU General Public License
29237 + * as published by the Free Software Foundation, either version 2 of the
29238 + * License, or (at your option) any later version.
29239 + *
29240 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
29241 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
29242 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
29243 + * the GNU General Public License for more details.
29244 + *
29245 + * You should have received a copy of the GNU General Public License
29246 + * along with the Ubicom32 Linux Kernel Port. If not,
29247 + * see <http://www.gnu.org/licenses/>.
29248 + *
29249 + * Ubicom32 implementation derived from (with many thanks):
29250 + * arch/m68knommu
29251 + * arch/blackfin
29252 + * arch/parisc
29253 + */
29254 +#include <linux/module.h>
29255 +#include <linux/kernel.h>
29256 +#include <linux/io.h>
29257 +
29258 +#ifdef CONFIG_PCI
29259 +unsigned char ioread8(void __iomem *addr)
29260 +{
29261 + if (IS_PCI_ADDRESS(addr))
29262 + return ubi32_pci_read_u8(addr);
29263 + else
29264 + return (unsigned char)(*(volatile unsigned char *)addr);
29265 +}
29266 +EXPORT_SYMBOL(ioread8);
29267 +
29268 +unsigned short ioread16(void __iomem *addr)
29269 +{
29270 + if (IS_PCI_ADDRESS(addr))
29271 + return ubi32_pci_read_u16(addr);
29272 + else
29273 + return (unsigned short)(*(volatile unsigned short *)addr);
29274 +}
29275 +EXPORT_SYMBOL(ioread16);
29276 +
29277 +unsigned int ioread32(void __iomem *addr)
29278 +{
29279 + if (IS_PCI_ADDRESS(addr))
29280 + return ubi32_pci_read_u32(addr);
29281 + else
29282 + return (unsigned int)(*(volatile unsigned int *)addr);
29283 +}
29284 +EXPORT_SYMBOL(ioread32);
29285 +
29286 +void iowrite32(unsigned int val, void __iomem *addr)
29287 +{
29288 + if (IS_PCI_ADDRESS(addr))
29289 + ubi32_pci_write_u32(val, addr);
29290 + else
29291 + *(volatile unsigned int *)addr = val;
29292 +}
29293 +EXPORT_SYMBOL(iowrite32);
29294 +
29295 +void iowrite16(unsigned short val, void __iomem *addr)
29296 +{
29297 + if (IS_PCI_ADDRESS(addr))
29298 + ubi32_pci_write_u16(val, addr);
29299 + else
29300 + *(volatile unsigned short *)addr = val;
29301 +}
29302 +EXPORT_SYMBOL(iowrite16);
29303 +
29304 +void iowrite8(unsigned char val, void __iomem *addr)
29305 +{
29306 + if (IS_PCI_ADDRESS(addr))
29307 + ubi32_pci_write_u8(val, addr);
29308 + else
29309 + *(volatile unsigned char *)addr = val;
29310 +}
29311 +EXPORT_SYMBOL(iowrite8);
29312 +
29313 +void memcpy_fromio(void *to, const volatile void __iomem *from, unsigned len)
29314 +{
29315 + if (IS_PCI_ADDRESS(from)) {
29316 + if ((((u32_t)from & 0x3) == 0) && (((u32_t)to & 0x3) == 0)) {
29317 + while ((int)len >= 4) {
29318 + *(u32_t *)to = ubi32_pci_read_u32(from);
29319 + to += 4;
29320 + from += 4;
29321 + len -= 4;
29322 + }
29323 + } else if ((((u32_t)from & 0x1) == 0) &&
29324 + (((u32_t)to & 0x1) == 0)) {
29325 + while ((int)len >= 2) {
29326 + *(u16_t *)to = ubi32_pci_read_u16(from);
29327 + to += 2;
29328 + from += 2;
29329 + len -= 2;
29330 + }
29331 + }
29332 +
29333 + while (len) {
29334 + *(u8_t *)to = ubi32_pci_read_u8(from);
29335 + to++;
29336 + from++;
29337 + len--;
29338 + }
29339 + } else
29340 + memcpy(to, (void *)from, len);
29341 +}
29342 +EXPORT_SYMBOL(memcpy_fromio);
29343 +
29344 +void memcpy_toio(volatile void __iomem *to, const void *from, unsigned len)
29345 +{
29346 + if (IS_PCI_ADDRESS(to)) {
29347 + if ((((u32_t)from & 0x3) == 0) && (((u32_t)to & 0x3) == 0)) {
29348 + while ((int)len >= 4) {
29349 + ubi32_pci_write_u32(*(u32_t *)from, to);
29350 + to += 4;
29351 + from += 4;
29352 + len -= 4;
29353 + }
29354 + } else if ((((u32_t)from & 0x1) == 0) &&
29355 + (((u32_t)to & 0x1) == 0)) {
29356 + while ((int)len >= 2) {
29357 + ubi32_pci_write_u16(*(u16_t *)from, to);
29358 + to += 2;
29359 + from += 2;
29360 + len -= 2;
29361 + }
29362 + }
29363 +
29364 + while (len) {
29365 + ubi32_pci_write_u8(*(u8_t *)from, to);
29366 + from++;
29367 + to++;
29368 + len--;
29369 + }
29370 + } else
29371 + memcpy((void *)to, from, len);
29372 +
29373 +}
29374 +EXPORT_SYMBOL(memcpy_toio);
29375 +
29376 +void memset_io(volatile void __iomem *addr, int val, size_t len)
29377 +{
29378 + if (IS_PCI_ADDRESS(addr)) {
29379 + while (len) {
29380 + ubi32_pci_write_u8((unsigned char)val, addr);
29381 + addr++;
29382 + len--;
29383 + }
29384 + } else
29385 + memset((void *)addr, val, len);
29386 +
29387 +}
29388 +EXPORT_SYMBOL(memset_io);
29389 +
29390 +void ioread8_rep(void __iomem *port, void *buf, unsigned long count)
29391 +{
29392 + if (IS_PCI_ADDRESS(port)) {
29393 + while (count) {
29394 + *(u8_t *)buf = ioread8(port);
29395 + buf++;
29396 + count--;
29397 + }
29398 + } else {
29399 + insb((unsigned int)port, buf, count);
29400 + }
29401 +
29402 +}
29403 +EXPORT_SYMBOL(ioread8_rep);
29404 +
29405 +void ioread16_rep(void __iomem *port, void *buf, unsigned long count)
29406 +{
29407 + if (IS_PCI_ADDRESS(port)) {
29408 + while (count) {
29409 + *(u16_t *)buf = ioread16(port);
29410 + buf += 2;
29411 + count--;
29412 + }
29413 + } else {
29414 + insw((unsigned int)port, buf, count);
29415 + }
29416 +}
29417 +EXPORT_SYMBOL(ioread16_rep);
29418 +
29419 +void ioread32_rep(void __iomem *port, void *buf, unsigned long count)
29420 +{
29421 + if (IS_PCI_ADDRESS(port)) {
29422 + while (count) {
29423 + *(u32_t *)buf = ioread32(port);
29424 + buf += 4;
29425 + count--;
29426 + }
29427 + } else {
29428 + insl((unsigned int)port, buf, count);
29429 + }
29430 +}
29431 +EXPORT_SYMBOL(ioread32_rep);
29432 +
29433 +void iowrite8_rep(void __iomem *port, const void *buf, unsigned long count)
29434 +{
29435 + if (IS_PCI_ADDRESS(port)) {
29436 + while (count) {
29437 + iowrite8(*(u8_t *)buf, port);
29438 + buf++;
29439 + count--;
29440 + }
29441 + } else {
29442 + outsb((unsigned int)port, buf, count);
29443 + }
29444 +
29445 +}
29446 +EXPORT_SYMBOL(iowrite8_rep);
29447 +
29448 +void iowrite16_rep(void __iomem *port, const void *buf, unsigned long count)
29449 +{
29450 + if (IS_PCI_ADDRESS(port)) {
29451 + while (count) {
29452 + iowrite16(*(u16_t *)buf, port);
29453 + buf += 2;
29454 + count--;
29455 + }
29456 + } else {
29457 + outsw((unsigned int)port, buf, count);
29458 + }
29459 +}
29460 +EXPORT_SYMBOL(iowrite16_rep);
29461 +
29462 +void iowrite32_rep(void __iomem *port, const void *buf, unsigned long count)
29463 +{
29464 + if (IS_PCI_ADDRESS(port)) {
29465 + while (count) {
29466 + iowrite32(*(u32_t *)buf, port);
29467 + buf += 4;
29468 + count--;
29469 + }
29470 + } else {
29471 + outsl((unsigned int)port, buf, count);
29472 + }
29473 +}
29474 +EXPORT_SYMBOL(iowrite32_rep);
29475 +
29476 +#endif /* CONFIG_PCI */
29477 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/Kconfig.switch linux-2.6.30.10-ubi/arch/ubicom32/mach-common/Kconfig.switch
29478 --- linux-2.6.30.10/arch/ubicom32/mach-common/Kconfig.switch 1970-01-01 02:00:00.000000000 +0200
29479 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/Kconfig.switch 2009-12-11 11:45:11.000000000 +0200
29480 @@ -0,0 +1,12 @@
29481 +menuconfig UBICOM_SWITCH
29482 + tristate "Switch devices"
29483 + help
29484 + This option provides Ethernet switch management options via proc fs
29485 +
29486 +if UBICOM_SWITCH
29487 +config UBICOM_SWITCH_BCM539X
29488 + tristate "Broadcom BCM539X series (SPI)"
29489 + depends on SPI_MASTER
29490 + help
29491 + Supports Broadcom BCM539X Gigabit Ethernet Switches over SPI
29492 +endif
29493 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/Makefile linux-2.6.30.10-ubi/arch/ubicom32/mach-common/Makefile
29494 --- linux-2.6.30.10/arch/ubicom32/mach-common/Makefile 1970-01-01 02:00:00.000000000 +0200
29495 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/Makefile 2009-12-11 11:45:11.000000000 +0200
29496 @@ -0,0 +1,41 @@
29497 +#
29498 +# arch/ubicom32/mach-common/Makefile
29499 +# Makefile for Ubicom32 generic drivers/code.
29500 +#
29501 +# (C) Copyright 2009, Ubicom, Inc.
29502 +#
29503 +# This file is part of the Ubicom32 Linux Kernel Port.
29504 +#
29505 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
29506 +# it and/or modify it under the terms of the GNU General Public License
29507 +# as published by the Free Software Foundation, either version 2 of the
29508 +# License, or (at your option) any later version.
29509 +#
29510 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
29511 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
29512 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
29513 +# the GNU General Public License for more details.
29514 +#
29515 +# You should have received a copy of the GNU General Public License
29516 +# along with the Ubicom32 Linux Kernel Port. If not,
29517 +# see <http://www.gnu.org/licenses/>.
29518 +#
29519 +# Ubicom32 implementation derived from (with many thanks):
29520 +# arch/m68knommu
29521 +# arch/blackfin
29522 +# arch/parisc
29523 +#
29524 +
29525 +obj-y += cachectl.o common.o usb_tio.o usb.o ubi32-gpio.o board.o bootargs.o profile.o
29526 +obj-$(CONFIG_PCI) += pci.o io.o
29527 +
29528 +obj-$(CONFIG_FB_UBICOM32) += vdc_tio.o
29529 +obj-$(CONFIG_UBICOM_HID) += ubicom32hid.o
29530 +obj-$(CONFIG_UBICOM_INPUT) += ubicom32input.o
29531 +obj-$(CONFIG_UBICOM_INPUT_I2C) += ubicom32input_i2c.o
29532 +obj-$(CONFIG_UBICOM_SWITCH) += switch-core.o
29533 +obj-$(CONFIG_UBICOM_SWITCH_BCM539X) += switch-bcm539x.o
29534 +obj-$(CONFIG_UIO_UBICOM32RING) += ring_tio.o
29535 +obj-$(CONFIG_SND_UBI32) += audio.o
29536 +obj-$(CONFIG_UBICOM32_PLIO) += plio.o
29537 +
29538 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/pci.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/pci.c
29539 --- linux-2.6.30.10/arch/ubicom32/mach-common/pci.c 1970-01-01 02:00:00.000000000 +0200
29540 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/pci.c 2009-12-11 11:45:11.000000000 +0200
29541 @@ -0,0 +1,1157 @@
29542 +/*
29543 + * arch/ubicom32/mach-common/pci.c
29544 + * PCI interface management.
29545 + *
29546 + * (C) Copyright 2009, Ubicom, Inc.
29547 + *
29548 + * This file is part of the Ubicom32 Linux Kernel Port.
29549 + *
29550 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
29551 + * it and/or modify it under the terms of the GNU General Public License
29552 + * as published by the Free Software Foundation, either version 2 of the
29553 + * License, or (at your option) any later version.
29554 + *
29555 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
29556 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
29557 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
29558 + * the GNU General Public License for more details.
29559 + *
29560 + * You should have received a copy of the GNU General Public License
29561 + * along with the Ubicom32 Linux Kernel Port. If not,
29562 + * see <http://www.gnu.org/licenses/>.
29563 + *
29564 + * Ubicom32 implementation derived from (with many thanks):
29565 + * arch/m68knommu
29566 + * arch/blackfin
29567 + * arch/parisc
29568 + */
29569 +
29570 +#include <linux/module.h>
29571 +#include <linux/kernel.h>
29572 +#include <linux/pci.h>
29573 +#include <linux/slab.h>
29574 +#include <linux/init.h>
29575 +#include <linux/io.h>
29576 +#include <linux/seq_file.h>
29577 +#include <linux/proc_fs.h>
29578 +
29579 +#include <asm/devtree.h>
29580 +#include <asm/ip5000.h>
29581 +#include <asm/ubicom32-common.h>
29582 +
29583 +static int debug_pci = 1 ;
29584 +
29585 +/* #define PCI_USE_INTERNAL_LOCK 1 */
29586 +
29587 +#ifdef PCI_USE_INTERNAL_LOCK
29588 +#define PCI_LOCK(lock, irqflag) pci_lock_acquire(irqflag)
29589 +#define PCI_UNLOCK(lock, irqflag) pci_lock_release(irqflag)
29590 +#elif defined(CONFIG_SMP)
29591 +static DEFINE_SPINLOCK(pci_master_lock);
29592 +#define PCI_LOCK(lock, irqflag) spin_lock_irqsave(lock, irqflag)
29593 +#define PCI_UNLOCK(lock, irqflag) spin_unlock_irqrestore(lock, irqflag)
29594 +#else
29595 +#define PCI_LOCK(lock, irqflag) local_irq_save(irqflag)
29596 +#define PCI_UNLOCK(lock, irqflag) local_irq_restore(irqflag)
29597 +#endif
29598 +
29599 +#define PCI_DEV0_IDSEL CONFIG_PCI_DEV0_IDSEL
29600 +#define PCI_DEV1_IDSEL CONFIG_PCI_DEV1_IDSEL
29601 +
29602 +/*
29603 + * PCI commands
29604 + */
29605 +#define PCI_CMD_INT_ACK 0x00 /* not supported */
29606 +#define PCI_CMD_SPECIAL 0x01 /* not supported */
29607 +#define PCI_CMD_IO_READ 0x02
29608 +#define PCI_CMD_IO_WRITE 0x03
29609 +#define PCI_CMD_MEM_READ 0x06
29610 +#define PCI_CMD_MEM_WRITE 0x07
29611 +#define PCI_CMD_CFG_READ 0x0a
29612 +#define PCI_CMD_CFG_WRITE 0x0b
29613 +#define PCI_CMD_MEM_READ_MULT 0x0c /* not supported */
29614 +#define PCI_CMD_DUAL_ADDR 0x0d /* not supported */
29615 +#define PCI_CMD_MEM_READ_LINE 0x0e /* not supported */
29616 +#define PCI_CMD_MEM_WRITE_INVAL 0x0f /* not supported */
29617 +/*
29618 + * Status codes, returned by pci_read_u32() and pci_write_u32()
29619 + */
29620 +#define PCI_RESP_IN_PROGRESS 0xff /* request still in queue */
29621 +#define PCI_RESP_OK 0
29622 +/*
29623 + * The following codes indicate that the request has completed
29624 + */
29625 +#define PCI_RESP_NO_DEVSEL 1 /* timeout before target asserted
29626 + * DEVSEL! */
29627 +#define PCI_RESP_LOST_DEVSEL 2 /* had DEVSEL, but went away before
29628 + * transfer completed! */
29629 +#define PCI_RESP_BAD_TRDY 3 /* target asserted TRDY without
29630 + * DEVSEL! */
29631 +#define PCI_RESP_NO_TRDY 4 /* timeout before target asserted
29632 + * TRDY! */
29633 +#define PCI_RESP_BAD_STOP 5 /* target asserted STOP and TRDY
29634 + * without DEVSEL! */
29635 +#define PCI_RESP_TARGET_ABORT 6
29636 +#define PCI_RESP_TARGET_RETRY 7
29637 +#define PCI_RESP_TARGET_DISCONNECT 8
29638 +#define PCI_RESP_MISMATCH 9 /* data read back doesn't match data
29639 + * written - debug only, the core PCI
29640 + * routines never return this */
29641 +#define PCI_RESP_DET_SERR 10
29642 +#define PCI_RESP_DET_PERR 11
29643 +#define PCI_RESP_MALFORMED_REQ 12 /* Could be due to misaligned
29644 + * requests or invalid address */
29645 +#define PCI_RESP_NO_RESOURCE 13 /* Could be memory or other resourse
29646 + * like queue space */
29647 +#define PCI_RESP_ERROR 14 /* All emcompassing error */
29648 +
29649 +/* registers in PCI config space */
29650 +#define PCI_DEVICE_VENDOR_ID_REG 0x00
29651 +#define PCI_STATUS_COMMAND_REG 0x04
29652 +#define PCI_CLASS_REVISION_REG 0x08
29653 +#define PCI_BHLC_REG 0x0c /* BIST, Header type, Latency
29654 + * timer, Cache line size */
29655 +#define PCI_BASE_ADDR_REG 0x10
29656 +#define PCI_BASE_REG_COUNT 6
29657 +#define CARDBUS_CIS_PTR_REG 0x28
29658 +#define PCI_SUB_SYSTEM_ID_REG 0x2c
29659 +#define PCI_EXP_ROM_ADDR_REG 0x30
29660 +#define PCI_CAP_PTR_REG 0x34
29661 +#define PCI_LGPL_REG 0x3C /* max Latency, min Gnt, interrupt
29662 + * Pin, interrupt Line */
29663 +
29664 +struct pci_master_request {
29665 + volatile u32_t pci_address; /* must be 4-byte aligned */
29666 + volatile u32_t data; /* must be 4-byte aligned */
29667 + volatile u8_t cmd;
29668 + volatile u8_t byte_valid;
29669 + volatile u8_t status;
29670 +};
29671 +
29672 +struct pci_devnode {
29673 + struct devtree_node dn;
29674 + u32_t pci_idsel_0;
29675 + u32_t pci_idsel_1;
29676 + u32_t pci_cpu_address;
29677 + struct pci_master_request volatile *volatile req;
29678 +};
29679 +
29680 +static struct pci_master_request req; /* globally used for faster master write
29681 + * (discarding result when possible) */
29682 +static struct pci_devnode *pci_node;
29683 +
29684 +#if !defined(CONFIG_DEBUG_PCIMEASURE)
29685 +#define PCI_DECLARE_MEASUREMENT
29686 +#define PCI_MEASUREMENT_START()
29687 +#define PCI_MEASUREMENT_END(idx)
29688 +#else
29689 +#define PCI_DECLARE_MEASUREMENT \
29690 + int __diff; \
29691 + unsigned int __tstart;
29692 +
29693 +#define PCI_MEASUREMENT_START() \
29694 + __tstart = UBICOM32_IO_TIMER->sysval;
29695 +
29696 +#define PCI_MEASUREMENT_END(idx) \
29697 + __diff = (int)UBICOM32_IO_TIMER->sysval - (int)__tstart; \
29698 + pci_measurement_update((idx), __diff);
29699 +
29700 +#define PCI_WEIGHT 32
29701 +
29702 +struct pci_measurement {
29703 + volatile unsigned int min;
29704 + volatile unsigned int avg;
29705 + volatile unsigned int max;
29706 +};
29707 +
29708 +enum pci_measurement_list {
29709 + PCI_MEASUREMENT_READ32,
29710 + PCI_MEASUREMENT_WRITE32,
29711 + PCI_MEASUREMENT_READ16,
29712 + PCI_MEASUREMENT_WRITE16,
29713 + PCI_MEASUREMENT_READ8,
29714 + PCI_MEASUREMENT_WRITE8,
29715 + PCI_MEASUREMENT_LAST,
29716 +};
29717 +
29718 +static const char *pci_measurement_name_list[PCI_MEASUREMENT_LAST] = {
29719 + "READ32",
29720 + "WRITE32",
29721 + "READ16",
29722 + "WRITE16",
29723 + "READ8",
29724 + "WRITE8"
29725 +};
29726 +static struct pci_measurement pci_measurements[PCI_MEASUREMENT_LAST];
29727 +
29728 +/*
29729 + * pci_measurement_update()
29730 + * Update an entry in the measurement array for this idx.
29731 + */
29732 +static void pci_measurement_update(int idx, int sample)
29733 +{
29734 + struct pci_measurement *pm = &pci_measurements[idx];
29735 + if ((pm->min == 0) || (pm->min > sample)) {
29736 + pm->min = sample;
29737 + }
29738 + if (pm->max < sample) {
29739 + pm->max = sample;
29740 + }
29741 + pm->avg = ((pm->avg * (PCI_WEIGHT - 1)) + sample) / PCI_WEIGHT;
29742 +}
29743 +#endif
29744 +
29745 +#if defined(PCI_USE_INTERNAL_LOCK)
29746 +/*
29747 + * pci_lock_release()
29748 + * Release the PCI lock.
29749 + */
29750 +static void pci_lock_release(unsigned long irqflag)
29751 +{
29752 + UBICOM32_UNLOCK(PCI_LOCK_BIT);
29753 +}
29754 +
29755 +/*
29756 + * pci_lock_acquire()
29757 + * Acquire the PCI lock, spin if not available.
29758 + */
29759 +static void pci_lock_acquire(unsigned long irqflag)
29760 +{
29761 + UBICOM32_LOCK(PCI_LOCK_BIT);
29762 +}
29763 +#endif
29764 +
29765 +/*
29766 + * pci_set_hrt_interrupt()
29767 + */
29768 +static inline void pci_set_hrt_interrupt(struct pci_devnode *pci_node)
29769 +{
29770 + ubicom32_set_interrupt(pci_node->dn.sendirq);
29771 +}
29772 +
29773 +/*
29774 + * pci_read_u32()
29775 + * Synchronously read 32 bits from PCI space.
29776 + */
29777 +u8 pci_read_u32(u8 pci_cmd, u32 address, u32 *data)
29778 +{
29779 + u8 status;
29780 + unsigned long irqflag;
29781 +
29782 +
29783 + /*
29784 + * Fill in the request.
29785 + */
29786 + volatile struct pci_master_request lreq;
29787 + PCI_DECLARE_MEASUREMENT;
29788 +
29789 + lreq.pci_address = address;
29790 + lreq.cmd = pci_cmd;
29791 + lreq.byte_valid = 0xf; /* enable all bytes */
29792 +
29793 + /*
29794 + * Wait for any previous request to complete and then make this request.
29795 + */
29796 + PCI_MEASUREMENT_START();
29797 + PCI_LOCK(&pci_master_lock, irqflag);
29798 + while (unlikely(pci_node->req == &req))
29799 + ;
29800 + pci_node->req = &lreq;
29801 + pci_set_hrt_interrupt(pci_node);
29802 + PCI_UNLOCK(&pci_master_lock, irqflag);
29803 +
29804 + /*
29805 + * Wait for the result to show up.
29806 + */
29807 + while (unlikely(pci_node->req == &lreq))
29808 + ;
29809 + status = lreq.status;
29810 + if (likely(status == PCI_RESP_OK))
29811 + *data = le32_to_cpu(lreq.data);
29812 + else
29813 + *data = 0;
29814 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_READ32);
29815 + return status;
29816 +}
29817 +
29818 +/*
29819 + * pci_write_u32()
29820 + * Asyncrhnously or synchronously write 32 bits to PCI master space.
29821 + */
29822 +u8 pci_write_u32(u8 pci_cmd, u32 address, u32 data)
29823 +{
29824 + unsigned long irqflag;
29825 + PCI_DECLARE_MEASUREMENT;
29826 +
29827 + /*
29828 + * Wait for any previous write or pending read to complete.
29829 + *
29830 + * We use a global data block because once we write the request
29831 + * we do not wait for it to complete before exiting.
29832 + */
29833 + PCI_MEASUREMENT_START();
29834 + PCI_LOCK(&pci_master_lock, irqflag);
29835 + while (unlikely(pci_node->req == &req))
29836 + ;
29837 + req.pci_address = address;
29838 + req.data = cpu_to_le32(data);
29839 + req.cmd = pci_cmd;
29840 + req.byte_valid = 0xf; /* enable all bytes */
29841 + pci_node->req = &req;
29842 + pci_set_hrt_interrupt(pci_node);
29843 + PCI_UNLOCK(&pci_master_lock, irqflag);
29844 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_WRITE32);
29845 + return PCI_RESP_OK;
29846 +}
29847 +
29848 +/*
29849 + * pci_read_u16()
29850 + * Synchronously read 16 bits from PCI space.
29851 + */
29852 +u8 pci_read_u16(u8 pci_cmd, u32 address, u16 *data)
29853 +{
29854 + u8 status;
29855 + unsigned long irqflag;
29856 +
29857 + /*
29858 + * Fill in the request.
29859 + */
29860 + volatile struct pci_master_request lreq;
29861 + PCI_DECLARE_MEASUREMENT;
29862 +
29863 + lreq.pci_address = address & ~2;
29864 + lreq.cmd = pci_cmd;
29865 + lreq.byte_valid = (address & 2) ? 0xc : 0x3;
29866 +
29867 + /*
29868 + * Wait for any previous request to complete and then make this request.
29869 + */
29870 + PCI_MEASUREMENT_START();
29871 + PCI_LOCK(&pci_master_lock, irqflag);
29872 + while (unlikely(pci_node->req == &req))
29873 + ;
29874 + pci_node->req = &lreq;
29875 + pci_set_hrt_interrupt(pci_node);
29876 + PCI_UNLOCK(&pci_master_lock, irqflag);
29877 +
29878 + /*
29879 + * Wait for the result to show up.
29880 + */
29881 + while (unlikely(pci_node->req == &lreq))
29882 + ;
29883 + status = lreq.status;
29884 + if (likely(status == PCI_RESP_OK)) {
29885 + lreq.data = le32_to_cpu(lreq.data);
29886 + *data = (u16)((address & 2) ? (lreq.data >> 16) : lreq.data);
29887 + } else
29888 + *data = 0;
29889 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_READ16);
29890 + return status;
29891 +}
29892 +
29893 +/*
29894 + * pci_write_u16()
29895 + * Asyncrhnously or synchronously write 16 bits to PCI master space.
29896 + */
29897 +u8 pci_write_u16(u8 pci_cmd, u32 address, u16 data)
29898 +{
29899 + unsigned long irqflag;
29900 + PCI_DECLARE_MEASUREMENT;
29901 +
29902 + /*
29903 + * Wait for any previous write or pending read to complete.
29904 + *
29905 + * We use a global data block because once we write the request
29906 + * we do not wait for it to complete before exiting.
29907 + */
29908 + PCI_MEASUREMENT_START();
29909 + PCI_LOCK(&pci_master_lock, irqflag);
29910 + while (unlikely(pci_node->req == &req))
29911 + ;
29912 + req.pci_address = address & ~2;
29913 + req.data = (u32)data;
29914 + req.data = cpu_to_le32((address & 2) ? (req.data << 16) : req.data);
29915 + req.cmd = pci_cmd;
29916 + req.byte_valid = (address & 2) ? 0xc : 0x3;
29917 + pci_node->req = &req;
29918 + pci_set_hrt_interrupt(pci_node);
29919 + PCI_UNLOCK(&pci_master_lock, irqflag);
29920 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_WRITE16);
29921 + return PCI_RESP_OK;
29922 +}
29923 +
29924 +/*
29925 + * pci_read_u8()
29926 + * Synchronously read 8 bits from PCI space.
29927 + */
29928 +u8 pci_read_u8(u8 pci_cmd, u32 address, u8 *data)
29929 +{
29930 + u8 status;
29931 + unsigned long irqflag;
29932 +
29933 + /*
29934 + * Fill in the request.
29935 + */
29936 + volatile struct pci_master_request lreq;
29937 + PCI_DECLARE_MEASUREMENT;
29938 +
29939 + lreq.pci_address = address & ~3;
29940 + lreq.cmd = pci_cmd;
29941 + lreq.byte_valid = 1 << (address & 0x3);
29942 +
29943 + /*
29944 + * Wait for any previous request to complete and then make this request.
29945 + */
29946 + PCI_MEASUREMENT_START();
29947 + PCI_LOCK(&pci_master_lock, irqflag);
29948 + while (unlikely(pci_node->req == &req))
29949 + ;
29950 + pci_node->req = &lreq;
29951 + pci_set_hrt_interrupt(pci_node);
29952 + PCI_UNLOCK(&pci_master_lock, irqflag);
29953 +
29954 + /*
29955 + * Wait for the result to show up.
29956 + */
29957 + while (unlikely(pci_node->req == &lreq))
29958 + ;
29959 + status = lreq.status;
29960 + if (likely(status == PCI_RESP_OK)) {
29961 + *data = (u8)(lreq.data >> (24 - ((address & 0x3) << 3)));
29962 + } else
29963 + *data = 0;
29964 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_READ8);
29965 + return status;
29966 +}
29967 +
29968 +/*
29969 + * pci_write_u8()
29970 + * Asyncrhnously or synchronously write 8 bits to PCI master space.
29971 + */
29972 +u8 pci_write_u8(u8 pci_cmd, u32 address, u8 data)
29973 +{
29974 + unsigned long irqflag;
29975 + PCI_DECLARE_MEASUREMENT;
29976 +
29977 + /*
29978 + * Wait for any previous write or pending read to complete.
29979 + *
29980 + * We use a global data block because once we write the request
29981 + * we do not wait for it to complete before exiting.
29982 + */
29983 + PCI_MEASUREMENT_START();
29984 + PCI_LOCK(&pci_master_lock, irqflag);
29985 + while (unlikely(pci_node->req == &req))
29986 + ;
29987 + req.pci_address = address & ~3;
29988 + req.data = ((u32)data << (24 - ((address & 0x3) << 3)));
29989 + req.cmd = pci_cmd;
29990 + req.byte_valid = 1 << (address & 0x3);
29991 + pci_node->req = &req;
29992 + pci_set_hrt_interrupt(pci_node);
29993 + PCI_UNLOCK(&pci_master_lock, irqflag);
29994 + PCI_MEASUREMENT_END(PCI_MEASUREMENT_WRITE8);
29995 + return PCI_RESP_OK;
29996 +}
29997 +
29998 +unsigned int ubi32_pci_read_u32(const volatile void __iomem *addr)
29999 +{
30000 + unsigned int data;
30001 + pci_read_u32(PCI_CMD_MEM_READ, (u32)addr, &data);
30002 + return data;
30003 +}
30004 +EXPORT_SYMBOL(ubi32_pci_read_u32);
30005 +
30006 +unsigned short ubi32_pci_read_u16(const volatile void __iomem *addr)
30007 +{
30008 + unsigned short data;
30009 + pci_read_u16(PCI_CMD_MEM_READ, (u32)addr, &data);
30010 + return data;
30011 +}
30012 +EXPORT_SYMBOL(ubi32_pci_read_u16);
30013 +
30014 +unsigned char ubi32_pci_read_u8(const volatile void __iomem *addr)
30015 +{
30016 + unsigned char data;
30017 + pci_read_u8(PCI_CMD_MEM_READ, (u32)addr, &data);
30018 + return data;
30019 +}
30020 +EXPORT_SYMBOL(ubi32_pci_read_u8);
30021 +
30022 +void ubi32_pci_write_u32(unsigned int val, const volatile void __iomem *addr)
30023 +{
30024 + pci_write_u32(PCI_CMD_MEM_WRITE, (u32)addr, val);
30025 +}
30026 +EXPORT_SYMBOL(ubi32_pci_write_u32);
30027 +
30028 +void ubi32_pci_write_u16(unsigned short val, const volatile void __iomem *addr)
30029 +{
30030 + pci_write_u16(PCI_CMD_MEM_WRITE, (u32)addr, val);
30031 +}
30032 +EXPORT_SYMBOL(ubi32_pci_write_u16);
30033 +
30034 +void ubi32_pci_write_u8(unsigned char val, const void volatile __iomem *addr)
30035 +{
30036 + pci_write_u8(PCI_CMD_MEM_WRITE, (u32)addr, val);
30037 +}
30038 +EXPORT_SYMBOL(ubi32_pci_write_u8);
30039 +
30040 +#if defined(CONFIG_DEBUG_PCIMEASURE)
30041 +static unsigned int pci_cycles_to_nano(unsigned int cycles, unsigned int frequency)
30042 +{
30043 + unsigned int nano = ((cycles * 1000) / (frequency / 1000000));
30044 + return nano;
30045 +}
30046 +
30047 +/*
30048 + * pci_measurement_show()
30049 + * Print out the min, avg, max values for each PCI transaction type.
30050 + *
30051 + * By request, the max value is reset after each dump.
30052 + */
30053 +static int pci_measurement_show(struct seq_file *p, void *v)
30054 +{
30055 + unsigned int min, avg, max;
30056 + unsigned int freq = processor_frequency();
30057 + int trans = *((loff_t *) v);
30058 +
30059 + if (trans == 0) {
30060 + seq_puts(p, "min\tavg\tmax\t(nano-seconds)\n");
30061 + }
30062 +
30063 + if (trans >= PCI_MEASUREMENT_LAST) {
30064 + return 0;
30065 + }
30066 +
30067 + min = pci_cycles_to_nano(pci_measurements[trans].min, freq);
30068 + avg = pci_cycles_to_nano(pci_measurements[trans].avg, freq);
30069 + max = pci_cycles_to_nano(pci_measurements[trans].max, freq);
30070 + pci_measurements[trans].max = 0;
30071 + seq_printf(p, "%u\t%u\t%u\t%s\n", min, avg, max, pci_measurement_name_list[trans]);
30072 + return 0;
30073 +}
30074 +
30075 +static void *pci_measurement_start(struct seq_file *f, loff_t *pos)
30076 +{
30077 + return (*pos < PCI_MEASUREMENT_LAST) ? pos : NULL;
30078 +}
30079 +
30080 +static void *pci_measurement_next(struct seq_file *f, void *v, loff_t *pos)
30081 +{
30082 + (*pos)++;
30083 + if (*pos >= PCI_MEASUREMENT_LAST)
30084 + return NULL;
30085 + return pos;
30086 +}
30087 +
30088 +static void pci_measurement_stop(struct seq_file *f, void *v)
30089 +{
30090 + /* Nothing to do */
30091 +}
30092 +
30093 +static const struct seq_operations pci_measurement_seq_ops = {
30094 + .start = pci_measurement_start,
30095 + .next = pci_measurement_next,
30096 + .stop = pci_measurement_stop,
30097 + .show = pci_measurement_show,
30098 +};
30099 +
30100 +static int pci_measurement_open(struct inode *inode, struct file *filp)
30101 +{
30102 + return seq_open(filp, &pci_measurement_seq_ops);
30103 +}
30104 +
30105 +static const struct file_operations pci_measurement_fops = {
30106 + .open = pci_measurement_open,
30107 + .read = seq_read,
30108 + .llseek = seq_lseek,
30109 + .release = seq_release,
30110 +};
30111 +
30112 +static int __init pci_measurement_init(void)
30113 +{
30114 + proc_create("pci_measurements", 0, NULL, &pci_measurement_fops);
30115 + return 0;
30116 +}
30117 +module_init(pci_measurement_init);
30118 +#endif
30119 +
30120 +static int ubi32_pci_read_config(struct pci_bus *bus, unsigned int devfn,
30121 + int where, int size, u32 *value)
30122 +{
30123 + u8 cmd;
30124 + u32 addr;
30125 + u8 data8;
30126 + u16 data16;
30127 +
30128 + u8 slot = PCI_SLOT(devfn);
30129 + u8 fn = PCI_FUNC(devfn);
30130 +
30131 + if (slot > 1) {
30132 + return PCIBIOS_DEVICE_NOT_FOUND;
30133 + } else if (slot == 0) {
30134 + addr = PCI_DEV0_IDSEL + where;
30135 + } else {
30136 + addr = PCI_DEV1_IDSEL + where;
30137 + }
30138 +
30139 + addr += (fn << 8);
30140 +
30141 + cmd = PCI_CMD_CFG_READ;
30142 + if (size == 1) {
30143 + pci_read_u8(cmd, addr, &data8);
30144 + *value = (u32)data8;
30145 + } else if (size == 2) {
30146 + pci_read_u16(cmd, addr, &data16);
30147 + *value = (u32)data16;
30148 + } else {
30149 + pci_read_u32(cmd, addr, value);
30150 + }
30151 +
30152 + return PCIBIOS_SUCCESSFUL;
30153 +}
30154 +
30155 +static int ubi32_pci_write_config(struct pci_bus *bus, unsigned int devfn,
30156 + int where, int size, u32 value)
30157 +{
30158 + u8 cmd;
30159 + u32 addr;
30160 + u8 slot = PCI_SLOT(devfn);
30161 + u8 fn = PCI_FUNC(devfn);
30162 +
30163 + if (slot > 1) {
30164 + return PCIBIOS_DEVICE_NOT_FOUND;
30165 + } else if (slot == 0) {
30166 + addr = PCI_DEV0_IDSEL + where;
30167 + } else {
30168 + addr = PCI_DEV1_IDSEL + where;
30169 + }
30170 +
30171 + addr += (fn << 8);
30172 +
30173 + cmd = PCI_CMD_CFG_WRITE;
30174 + if (size == 1) {
30175 + pci_write_u8(cmd, addr, (u8)value);
30176 + } else if (size == 2) {
30177 + pci_write_u16(cmd, addr, (u16)value);
30178 + } else {
30179 + pci_write_u32(cmd, addr, value);
30180 + }
30181 +
30182 + return PCIBIOS_SUCCESSFUL;
30183 +}
30184 +
30185 +int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size)
30186 +{
30187 + return -EIO;
30188 +}
30189 +EXPORT_SYMBOL(pci_set_dma_max_seg_size);
30190 +
30191 +int pci_set_dma_seg_boundary(struct pci_dev *dev, unsigned long mask)
30192 +{
30193 + return -EIO;
30194 +}
30195 +EXPORT_SYMBOL(pci_set_dma_seg_boundary);
30196 +
30197 +void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
30198 +{
30199 + resource_size_t start = pci_resource_start(dev, bar);
30200 + resource_size_t len = pci_resource_len(dev, bar);
30201 + unsigned long flags = pci_resource_flags(dev, bar);
30202 +
30203 + if (!len || !start) {
30204 + return NULL;
30205 + }
30206 +
30207 + if (maxlen && len > maxlen) {
30208 + len = maxlen;
30209 + }
30210 +
30211 + if (flags & IORESOURCE_IO) {
30212 + return ioport_map(start, len);
30213 + }
30214 +
30215 + if (flags & IORESOURCE_MEM) {
30216 + if (flags & IORESOURCE_CACHEABLE) {
30217 + return ioremap(start, len);
30218 + }
30219 + return ioremap_nocache(start, len);
30220 + }
30221 + return NULL;
30222 +}
30223 +EXPORT_SYMBOL(pci_iomap);
30224 +
30225 +void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
30226 +{
30227 + if ((unsigned long)addr >= VMALLOC_START &&
30228 + (unsigned long)addr < VMALLOC_END) {
30229 + iounmap(addr);
30230 + }
30231 +}
30232 +EXPORT_SYMBOL(pci_iounmap);
30233 +
30234 +/*
30235 + * From arch/arm/kernel/bios32.c
30236 + *
30237 + * PCI bios-type initialisation for PCI machines
30238 + *
30239 + * Bits taken from various places.
30240 + */
30241 +static void __init pcibios_init_hw(struct hw_pci *hw)
30242 +{
30243 + struct pci_sys_data *sys = NULL;
30244 + int ret;
30245 + int nr, busnr;
30246 +
30247 + for (nr = busnr = 0; nr < hw->nr_controllers; nr++) {
30248 + sys = kzalloc(sizeof(struct pci_sys_data), GFP_KERNEL);
30249 + if (!sys)
30250 + panic("PCI: unable to allocate sys data!");
30251 +
30252 + sys->hw = hw;
30253 + sys->busnr = busnr;
30254 + sys->map_irq = hw->map_irq;
30255 + sys->resource[0] = &ioport_resource;
30256 + sys->resource[1] = &iomem_resource;
30257 +
30258 + ret = hw->setup(nr, sys);
30259 +
30260 + if (ret > 0) {
30261 + sys->bus = hw->scan(nr, sys);
30262 +
30263 + if (!sys->bus)
30264 + panic("PCI: unable to scan bus!");
30265 +
30266 + busnr = sys->bus->subordinate + 1;
30267 +
30268 + list_add(&sys->node, &hw->buses);
30269 + } else {
30270 + kfree(sys);
30271 + if (ret < 0)
30272 + break;
30273 + }
30274 + }
30275 +}
30276 +
30277 +/*
30278 + * Swizzle the device pin each time we cross a bridge.
30279 + * This might update pin and returns the slot number.
30280 + */
30281 +static u8 __devinit pcibios_swizzle(struct pci_dev *dev, u8 *pin)
30282 +{
30283 + struct pci_sys_data *sys = dev->sysdata;
30284 + int slot = 0, oldpin = *pin;
30285 +
30286 + if (sys->swizzle)
30287 + slot = sys->swizzle(dev, pin);
30288 +
30289 + if (debug_pci)
30290 + printk("PCI: %s swizzling pin %d => pin %d slot %d\n",
30291 + pci_name(dev), oldpin, *pin, slot);
30292 + return slot;
30293 +}
30294 +
30295 +/*
30296 + * Map a slot/pin to an IRQ.
30297 + */
30298 +static int pcibios_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
30299 +{
30300 + struct pci_sys_data *sys = dev->sysdata;
30301 + int irq = -1;
30302 +
30303 + if (sys->map_irq)
30304 + irq = sys->map_irq(dev, slot, pin);
30305 +
30306 + if (debug_pci)
30307 + printk("PCI: %s mapping slot %d pin %d => irq %d\n",
30308 + pci_name(dev), slot, pin, irq);
30309 +
30310 + return irq;
30311 +}
30312 +
30313 +void __init pci_common_init(struct hw_pci *hw)
30314 +{
30315 + struct pci_sys_data *sys;
30316 +
30317 + INIT_LIST_HEAD(&hw->buses);
30318 +
30319 + if (hw->preinit)
30320 + hw->preinit();
30321 + pcibios_init_hw(hw);
30322 + if (hw->postinit)
30323 + hw->postinit();
30324 +
30325 + pci_fixup_irqs(pcibios_swizzle, pcibios_map_irq);
30326 + list_for_each_entry(sys, &hw->buses, node) {
30327 + struct pci_bus *bus = sys->bus;
30328 + /*
30329 + * Size the bridge windows.
30330 + */
30331 + pci_bus_size_bridges(bus);
30332 + /*
30333 + * Assign resources.
30334 + */
30335 + pci_bus_assign_resources(bus);
30336 +
30337 + /*
30338 + * Tell drivers about devices found.
30339 + */
30340 + pci_bus_add_devices(bus);
30341 + }
30342 +}
30343 +
30344 +char * __init pcibios_setup(char *str)
30345 +{
30346 + if (!strcmp(str, "debug")) {
30347 + debug_pci = 1;
30348 + return NULL;
30349 + }
30350 + return str;
30351 +}
30352 +
30353 +/*
30354 + * From arch/i386/kernel/pci-i386.c:
30355 + *
30356 + * We need to avoid collisions with `mirrored' VGA ports
30357 + * and other strange ISA hardware, so we always want the
30358 + * addresses to be allocated in the 0x000-0x0ff region
30359 + * modulo 0x400.
30360 + *
30361 + * Why? Because some silly external IO cards only decode
30362 + * the low 10 bits of the IO address. The 0x00-0xff region
30363 + * is reserved for motherboard devices that decode all 16
30364 + * bits, so it's ok to allocate at, say, 0x2800-0x28ff,
30365 + * but we want to try to avoid allocating at 0x2900-0x2bff
30366 + * which might be mirrored at 0x0100-0x03ff..
30367 + */
30368 +void pcibios_align_resource(void *data, struct resource *res,
30369 + resource_size_t size, resource_size_t align)
30370 +{
30371 + resource_size_t start = res->start;
30372 +
30373 + if (res->flags & IORESOURCE_IO && start & 0x300)
30374 + start = (start + 0x3ff) & ~0x3ff;
30375 +
30376 + res->start = (start + align - 1) & ~(align - 1);
30377 +}
30378 +
30379 +
30380 +void __devinit pcibios_update_irq(struct pci_dev *dev, int irq)
30381 +{
30382 + if (debug_pci)
30383 + printk("PCI: Assigning IRQ %02d to %s\n", irq, pci_name(dev));
30384 + pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
30385 +}
30386 +
30387 +/*
30388 + * If the bus contains any of these devices, then we must not turn on
30389 + * parity checking of any kind. Currently this is CyberPro 20x0 only.
30390 + */
30391 +static inline int pdev_bad_for_parity(struct pci_dev *dev)
30392 +{
30393 + return (dev->vendor == PCI_VENDOR_ID_INTERG &&
30394 + (dev->device == PCI_DEVICE_ID_INTERG_2000 ||
30395 + dev->device == PCI_DEVICE_ID_INTERG_2010)) ||
30396 + (dev->vendor == PCI_VENDOR_ID_ITE &&
30397 + dev->device == PCI_DEVICE_ID_ITE_8152);
30398 +
30399 +}
30400 +
30401 +/*
30402 + * Adjust the device resources from bus-centric to Linux-centric.
30403 + */
30404 +static void __devinit
30405 +pdev_fixup_device_resources(struct pci_sys_data *root, struct pci_dev *dev)
30406 +{
30407 + resource_size_t offset;
30408 + int i;
30409 +
30410 + for (i = 0; i < PCI_NUM_RESOURCES; i++) {
30411 + if (dev->resource[i].start == 0)
30412 + continue;
30413 + if (dev->resource[i].flags & IORESOURCE_MEM)
30414 + offset = root->mem_offset;
30415 + else
30416 + offset = root->io_offset;
30417 +
30418 + dev->resource[i].start += offset;
30419 + dev->resource[i].end += offset;
30420 + }
30421 +}
30422 +
30423 +static void __devinit
30424 +pbus_assign_bus_resources(struct pci_bus *bus, struct pci_sys_data *root)
30425 +{
30426 + struct pci_dev *dev = bus->self;
30427 + int i;
30428 +
30429 + if (!dev) {
30430 + /*
30431 + * Assign root bus resources.
30432 + */
30433 + for (i = 0; i < 3; i++)
30434 + bus->resource[i] = root->resource[i];
30435 + }
30436 +}
30437 +
30438 +/*
30439 + * pcibios_fixup_bus - Called after each bus is probed,
30440 + * but before its children are examined.
30441 + */
30442 +void pcibios_fixup_bus(struct pci_bus *bus)
30443 +{
30444 + struct pci_sys_data *root = bus->sysdata;
30445 + struct pci_dev *dev;
30446 + u16 features = PCI_COMMAND_SERR | PCI_COMMAND_PARITY |
30447 + PCI_COMMAND_FAST_BACK;
30448 +
30449 + pbus_assign_bus_resources(bus, root);
30450 +
30451 + /*
30452 + * Walk the devices on this bus, working out what we can
30453 + * and can't support.
30454 + */
30455 + list_for_each_entry(dev, &bus->devices, bus_list) {
30456 + u16 status;
30457 +
30458 + pdev_fixup_device_resources(root, dev);
30459 +
30460 + pci_read_config_word(dev, PCI_STATUS, &status);
30461 +
30462 + /*
30463 + * If any device on this bus does not support fast back
30464 + * to back transfers, then the bus as a whole is not able
30465 + * to support them. Having fast back to back transfers
30466 + * on saves us one PCI cycle per transaction.
30467 + */
30468 + if (!(status & PCI_STATUS_FAST_BACK))
30469 + features &= ~PCI_COMMAND_FAST_BACK;
30470 +
30471 + if (pdev_bad_for_parity(dev))
30472 + features &= ~(PCI_COMMAND_SERR | PCI_COMMAND_PARITY);
30473 +
30474 + switch (dev->class >> 8) {
30475 + case PCI_CLASS_BRIDGE_PCI:
30476 + pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &status);
30477 + status |= PCI_BRIDGE_CTL_PARITY |
30478 + PCI_BRIDGE_CTL_MASTER_ABORT;
30479 + status &= ~(PCI_BRIDGE_CTL_BUS_RESET |
30480 + PCI_BRIDGE_CTL_FAST_BACK);
30481 + pci_write_config_word(dev, PCI_BRIDGE_CONTROL, status);
30482 + break;
30483 +
30484 + case PCI_CLASS_BRIDGE_CARDBUS:
30485 + pci_read_config_word(dev, PCI_CB_BRIDGE_CONTROL,
30486 + &status);
30487 + status |= PCI_CB_BRIDGE_CTL_PARITY |
30488 + PCI_CB_BRIDGE_CTL_MASTER_ABORT;
30489 + pci_write_config_word(dev, PCI_CB_BRIDGE_CONTROL,
30490 + status);
30491 + break;
30492 + }
30493 + }
30494 +
30495 + /*
30496 + * Now walk the devices again, this time setting them up.
30497 + */
30498 + list_for_each_entry(dev, &bus->devices, bus_list) {
30499 + u16 cmd;
30500 +
30501 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
30502 + cmd |= features;
30503 + pci_write_config_word(dev, PCI_COMMAND, cmd);
30504 +
30505 + pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE,
30506 + L1_CACHE_BYTES >> 2);
30507 + }
30508 +
30509 + /*
30510 + * Propagate the flags to the PCI bridge.
30511 + */
30512 + if (bus->self && bus->self->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
30513 + if (features & PCI_COMMAND_FAST_BACK)
30514 + bus->bridge_ctl |= PCI_BRIDGE_CTL_FAST_BACK;
30515 + if (features & PCI_COMMAND_PARITY)
30516 + bus->bridge_ctl |= PCI_BRIDGE_CTL_PARITY;
30517 + }
30518 +
30519 + /*
30520 + * Report what we did for this bus
30521 + */
30522 + printk(KERN_INFO "PCI: bus%d: Fast back to back transfers %sabled\n",
30523 + bus->number, (features & PCI_COMMAND_FAST_BACK) ? "en" : "dis");
30524 +}
30525 +/*
30526 + * Convert from Linux-centric to bus-centric addresses for bridge devices.
30527 + */
30528 +void
30529 +pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
30530 + struct resource *res)
30531 +{
30532 + struct pci_sys_data *root = dev->sysdata;
30533 + unsigned long offset = 0;
30534 +
30535 + if (res->flags & IORESOURCE_IO)
30536 + offset = root->io_offset;
30537 + if (res->flags & IORESOURCE_MEM)
30538 + offset = root->mem_offset;
30539 +
30540 + region->start = res->start - offset;
30541 + region->end = res->end - offset;
30542 +}
30543 +
30544 +void __devinit
30545 +pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
30546 + struct pci_bus_region *region)
30547 +{
30548 + struct pci_sys_data *root = dev->sysdata;
30549 + unsigned long offset = 0;
30550 +
30551 + if (res->flags & IORESOURCE_IO)
30552 + offset = root->io_offset;
30553 + if (res->flags & IORESOURCE_MEM)
30554 + offset = root->mem_offset;
30555 +
30556 + res->start = region->start + offset;
30557 + res->end = region->end + offset;
30558 +}
30559 +
30560 +#ifdef CONFIG_HOTPLUG
30561 +EXPORT_SYMBOL(pcibios_fixup_bus);
30562 +EXPORT_SYMBOL(pcibios_resource_to_bus);
30563 +EXPORT_SYMBOL(pcibios_bus_to_resource);
30564 +#endif
30565 +
30566 +/**
30567 + * pcibios_enable_device - Enable I/O and memory.
30568 + * @dev: PCI device to be enabled
30569 + */
30570 +int pcibios_enable_device(struct pci_dev *dev, int mask)
30571 +{
30572 + u16 cmd, old_cmd;
30573 + int idx;
30574 + struct resource *r;
30575 +
30576 + pci_read_config_word(dev, PCI_COMMAND, &cmd);
30577 + old_cmd = cmd;
30578 + for (idx = 0; idx < 6; idx++) {
30579 + /* Only set up the requested stuff */
30580 + if (!(mask & (1 << idx)))
30581 + continue;
30582 +
30583 + r = dev->resource + idx;
30584 + if (!r->start && r->end) {
30585 + printk(KERN_ERR "PCI: Device %s not available because"
30586 + " of resource collisions\n", pci_name(dev));
30587 + return -EINVAL;
30588 + }
30589 + if (r->flags & IORESOURCE_IO)
30590 + cmd |= PCI_COMMAND_IO;
30591 + if (r->flags & IORESOURCE_MEM)
30592 + cmd |= PCI_COMMAND_MEMORY;
30593 + }
30594 +
30595 + /*
30596 + * Bridges (eg, cardbus bridges) need to be fully enabled
30597 + */
30598 + if ((dev->class >> 16) == PCI_BASE_CLASS_BRIDGE)
30599 + cmd |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
30600 +
30601 + if (cmd != old_cmd) {
30602 + printk("PCI: enabling device %s (%04x -> %04x)\n",
30603 + pci_name(dev), old_cmd, cmd);
30604 + pci_write_config_word(dev, PCI_COMMAND, cmd);
30605 + }
30606 + return 0;
30607 +}
30608 +
30609 +
30610 +struct pci_ops ubi32_pci_ops = {
30611 + .read = ubi32_pci_read_config,
30612 + .write = ubi32_pci_write_config,
30613 +};
30614 +
30615 +static struct pci_bus *ubi32_pci_scan_bus(int nr, struct pci_sys_data *sys)
30616 +{
30617 + return pci_scan_bus(sys->busnr, &ubi32_pci_ops, sys);
30618 +}
30619 +
30620 +#define UBI32_PCI_MEM_BASE PCI_DEV_REG_BASE
30621 +#define UBI32_PCI_MEM_LEN 0x80000000
30622 +
30623 +#define UBI32_PCI_IO_BASE 0x0
30624 +#define UBI32_PCI_IO_END 0x0
30625 +
30626 +static struct resource ubi32_pci_mem = {
30627 + .name = "PCI memory space",
30628 + .start = UBI32_PCI_MEM_BASE,
30629 + .end = UBI32_PCI_MEM_BASE + UBI32_PCI_MEM_LEN - 1,
30630 + .flags = IORESOURCE_MEM,
30631 +};
30632 +
30633 +static struct resource ubi32_pci_io = {
30634 + .name = "PCI IO space",
30635 + .start = UBI32_PCI_IO_BASE,
30636 + .end = UBI32_PCI_IO_END,
30637 + .flags = IORESOURCE_IO,
30638 +};
30639 +
30640 +static int __init ubi32_pci_setup(int nr, struct pci_sys_data *sys)
30641 +{
30642 + if (nr > 0)
30643 + return 0;
30644 +
30645 + request_resource(&iomem_resource, &ubi32_pci_mem);
30646 + request_resource(&ioport_resource, &ubi32_pci_io);
30647 +
30648 + sys->resource[0] = &ubi32_pci_io;
30649 + sys->resource[1] = &ubi32_pci_mem;
30650 + sys->resource[2] = NULL;
30651 +
30652 + return 1;
30653 +}
30654 +
30655 +static void __init ubi32_pci_preinit(void)
30656 +{
30657 +}
30658 +
30659 +static int __init ubi32_pci_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
30660 +{
30661 + return pci_node->dn.recvirq;
30662 +}
30663 +
30664 +struct hw_pci ubi32_pci __initdata = {
30665 + .nr_controllers = 1,
30666 + .preinit = ubi32_pci_preinit,
30667 + .setup = ubi32_pci_setup,
30668 + .scan = ubi32_pci_scan_bus,
30669 + .map_irq = ubi32_pci_map_irq,
30670 +};
30671 +
30672 +static int __init ubi32_pci_init(void)
30673 +{
30674 + pci_node = (struct pci_devnode *)devtree_find_node("pci");
30675 + if (pci_node == NULL) {
30676 + printk(KERN_WARNING "PCI init failed\n");
30677 + return -ENOSYS;
30678 + }
30679 + pci_common_init(&ubi32_pci);
30680 + return 0;
30681 +}
30682 +
30683 +subsys_initcall(ubi32_pci_init);
30684 +
30685 +/*
30686 + * workaround for dual PCI card interrupt
30687 + */
30688 +#define PCI_COMMON_INT_BIT (1 << 19)
30689 +void ubi32_pci_int_wr(void)
30690 +{
30691 + volatile unsigned int pci_int_line;
30692 + pci_int_line = UBICOM32_IO_PORT(RB)->gpio_in;
30693 + if (!(pci_int_line & PCI_COMMON_INT_BIT))
30694 + {
30695 + ubicom32_set_interrupt(pci_node->dn.recvirq);
30696 + }
30697 +}
30698 +EXPORT_SYMBOL(ubi32_pci_int_wr);
30699 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/plio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/plio.c
30700 --- linux-2.6.30.10/arch/ubicom32/mach-common/plio.c 1970-01-01 02:00:00.000000000 +0200
30701 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/plio.c 2009-12-11 11:45:11.000000000 +0200
30702 @@ -0,0 +1,92 @@
30703 +/*
30704 + * plio.c
30705 + * PLIO state machine support functions
30706 + *
30707 + * Copyright © 2009 Ubicom Inc. <www.ubicom.com>. All rights reserved.
30708 + *
30709 + * This file is part of the Ubicom32 Linux Kernel Port.
30710 + *
30711 + * The Ubicom32 Linux Kernel Port is free software: you can
30712 + * redistribute it and/or modify it under the terms of the GNU General
30713 + * Public License as published by the Free Software Foundation, either
30714 + * version 2 of the License, or (at your option) any later version.
30715 + *
30716 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
30717 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
30718 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
30719 + * See the GNU General Public License for more details.
30720 + *
30721 + * You should have received a copy of the GNU General Public License
30722 + * along with the Ubicom32 Linux Kernel Port. If not,
30723 + * see <http://www.gnu.org/licenses/>.
30724 + */
30725 +
30726 +#include <linux/types.h>
30727 +#include <linux/string.h>
30728 +#include <linux/delay.h>
30729 +#include <asm/plio.h>
30730 +
30731 +/*
30732 + * plio_reset
30733 + * Select and reset PLIO function
30734 + */
30735 +static void plio_reset(const plio_fctl_t *plio_fctl) {
30736 + plio_io_function_t plio_function = {
30737 + .fn_sel = PLIO_FN,
30738 + .fn_reset = 1,
30739 + };
30740 +
30741 + /*
30742 + * enable extension port
30743 + */
30744 + PEXT_NBR->function = plio_function;
30745 +
30746 + /*
30747 + * program clock dividers
30748 + */
30749 + PLIO_NBR->fctl2 = plio_fctl->fctl2;
30750 +
30751 + /*
30752 + * select plio function and assert function reset
30753 + */
30754 + plio_function.br_thread = thread_get_self();
30755 + plio_function.fn_reset = 1;
30756 + PLIO_NBR->function = plio_function;
30757 +
30758 + /*
30759 + * program plio controls
30760 + */
30761 + PLIO_NBR->fctl0 = plio_fctl->fctl0;
30762 + PLIO_NBR->fctl1 = plio_fctl->fctl1;
30763 +
30764 + /*
30765 + * deassert function reset
30766 + */
30767 + plio_function.fn_reset = 0;
30768 + PLIO_NBR->function = plio_function;
30769 +}
30770 +
30771 +/*
30772 + * plio_init
30773 + * configure and initialize PLIO.
30774 + */
30775 +void plio_init(const plio_fctl_t *plio_fctl, const plio_config_t *plio_config, const plio_sram_t plio_sram_cfg[], int sram_cfg_size){
30776 + /*
30777 + * first reset to start plio clock
30778 + */
30779 + plio_reset(plio_fctl);
30780 +
30781 + udelay(1);
30782 +
30783 + /*
30784 + * configure pfsm
30785 + */
30786 + PLIO_NBR->fctl0.pfsm_prog = 1;
30787 + memcpy(PLIO_BR->pfsm_sram, plio_sram_cfg, sram_cfg_size);
30788 + PLIO_NBR->fctl0.pfsm_prog = 0;
30789 +
30790 + /*
30791 + * program rest of plio
30792 + */
30793 + memcpy(&PLIO_BR->config, plio_config, sizeof(plio_config_t));
30794 +}
30795 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/profile.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profile.c
30796 --- linux-2.6.30.10/arch/ubicom32/mach-common/profile.c 1970-01-01 02:00:00.000000000 +0200
30797 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profile.c 2009-12-11 11:45:11.000000000 +0200
30798 @@ -0,0 +1,549 @@
30799 +/*
30800 + * arch/ubicom32/mach-common/profile.c
30801 + * Implementation for Ubicom32 Profiler
30802 + *
30803 + * (C) Copyright 2009, Ubicom, Inc.
30804 + *
30805 + * This file is part of the Ubicom32 Linux Kernel Port.
30806 + *
30807 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
30808 + * it and/or modify it under the terms of the GNU General Public License
30809 + * as published by the Free Software Foundation, either version 2 of the
30810 + * License, or (at your option) any later version.
30811 + *
30812 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
30813 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
30814 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
30815 + * the GNU General Public License for more details.
30816 + *
30817 + * You should have received a copy of the GNU General Public License
30818 + * along with the Ubicom32 Linux Kernel Port. If not,
30819 + * see <http://www.gnu.org/licenses/>.
30820 + */
30821 +
30822 +#include <linux/platform_device.h>
30823 +#include "profile.h"
30824 +#include <linux/seq_file.h>
30825 +#include <linux/proc_fs.h>
30826 +#include <linux/mm.h>
30827 +#include <linux/mmzone.h>
30828 +#include <linux/fs.h>
30829 +#include <linux/page-flags.h>
30830 +#include <asm/uaccess.h>
30831 +#include <asm/devtree.h>
30832 +#include <asm/profilesample.h>
30833 +#include <asm/memory_map.h>
30834 +#include <asm/page.h>
30835 +#include <asm/ip5000.h>
30836 +
30837 +/*
30838 + * spacs for all memory blocks so we can hold locks for short time when walking tables
30839 + */
30840 +#define PROFILE_NUM_MAPS 5000
30841 +static struct profile_map profile_pm[PROFILE_NUM_MAPS];
30842 +
30843 +static struct profilenode *node = NULL;
30844 +static int profile_first_packet = 1;
30845 +
30846 +static int profile_open(struct inode *inode, struct file *filp)
30847 +{
30848 + if (!node) {
30849 + return -ENOENT;
30850 + }
30851 + node->busy = 1;
30852 + if (!node->enabled) {
30853 + node->enabled = 1;
30854 + node->busy = 0;
30855 + profile_first_packet = 1;
30856 + return 0;
30857 + }
30858 + node->busy = 0;
30859 + return -EBUSY;
30860 +}
30861 +
30862 +static int profile_sequence_num;
30863 +
30864 +/*
30865 + * make a packet full of sample data
30866 + */
30867 +static int profile_make_data_packet(char *buf, int count)
30868 +{
30869 + int samples; /* number of samples requested */
30870 + int i;
30871 + struct profile_header ph;
30872 + char *ptr;
30873 +
30874 + if (count < sizeof(struct profile_header) + sizeof(struct profile_sample)) {
30875 + return -EINVAL;
30876 + }
30877 +
30878 + /*
30879 + * fill in the packet header
30880 + */
30881 + memset(&ph, 0, sizeof(struct profile_header));
30882 + ph.magic = PROF_MAGIC + PROFILE_VERSION;
30883 + ph.header_size = sizeof(struct profile_header);
30884 + ph.clocks = node->clocks;
30885 + for (i = 0; i < PROFILE_MAX_THREADS; ++i) {
30886 + ph.instruction_count[i] = node->inst_count[i];
30887 + }
30888 + ph.profile_instructions = 0;
30889 + ph.enabled = node->enabled_threads;
30890 + ph.hrt = node->hrt;
30891 + ph.high = 0;
30892 + ph.profiler_thread = node->profiler_thread;
30893 + ph.clock_freq = node->clock_freq;
30894 + ph.seq_num = profile_sequence_num++;
30895 + ph.cpu_id = node->cpu_id;
30896 + ph.perf_counters[0] = node->stats[0];
30897 + ph.perf_counters[1] = node->stats[1];
30898 + ph.perf_counters[2] = node->stats[2];
30899 + ph.perf_counters[3] = node->stats[3];
30900 + ph.ddr_freq = node->ddr_freq;
30901 +
30902 + ptr = buf + sizeof(struct profile_header);
30903 +
30904 + samples = (count - sizeof(struct profile_header)) / sizeof(struct profile_sample);
30905 + for (i = 0; i < samples && node->count; ++i) {
30906 + if (copy_to_user(ptr, &node->samples[node->tail], sizeof(struct profile_sample)) != 0) {
30907 + return -EFAULT;
30908 + }
30909 + node->count--;
30910 + node->tail++;
30911 + if (node->tail >= node->max_samples) {
30912 + node->tail = 0;
30913 + }
30914 + ptr += sizeof(struct profile_sample);
30915 + }
30916 + ph.sample_count = i;
30917 + if (copy_to_user(buf, &ph, sizeof(struct profile_header)) != 0) {
30918 + return -EFAULT;
30919 + }
30920 + if (ph.sample_count == 0)
30921 + return 0;
30922 + else
30923 + return sizeof(struct profile_header) + ph.sample_count * sizeof(struct profile_sample);
30924 +}
30925 +
30926 +static void profile_get_memory_stats(unsigned int *total_free, unsigned int *max_free)
30927 +{
30928 + struct list_head *p;
30929 + struct zone *zone;
30930 + unsigned int size;
30931 +
30932 + *total_free = 0;
30933 + *max_free = 0;
30934 +
30935 + /*
30936 + * get all the free regions. In each zone, the array of free_area lists contains the first page of each frame of size 1 << order
30937 + */
30938 + for_each_zone(zone) {
30939 + unsigned long order, flags, i;
30940 +
30941 + if (!populated_zone(zone))
30942 + continue;
30943 +
30944 + if (!is_normal(zone))
30945 + continue;
30946 +
30947 + spin_lock_irqsave(&zone->lock, flags);
30948 + for_each_migratetype_order(order, i) {
30949 + size = ((1 << order) << PAGE_SHIFT) >> 10;
30950 + list_for_each(p, &(zone->free_area[order].free_list[i])) {
30951 + if (size > *max_free) {
30952 + *max_free = size;
30953 + }
30954 + *total_free += size;
30955 + }
30956 + }
30957 + spin_unlock_irqrestore(&zone->lock, flags);
30958 + }
30959 +}
30960 +
30961 +struct profile_counter_pkt profile_builtin_stats[] =
30962 +{
30963 + {
30964 + "Free memory(KB)", 0
30965 + },
30966 + {
30967 + "Max free Block(KB)", 0
30968 + }
30969 +};
30970 +
30971 +/*
30972 + * make a packet full of performance counters
30973 + */
30974 +static char prof_pkt[PROFILE_MAX_PACKET_SIZE];
30975 +static int profile_make_stats_packet(char *buf, int count)
30976 +{
30977 + char *ptr = prof_pkt;
30978 + struct profile_header_counters hdr;
30979 + int stat_count = 0;
30980 + int i;
30981 + unsigned int total_free, max_free;
30982 + int builtin_count = sizeof(profile_builtin_stats) / sizeof(struct profile_counter_pkt);
30983 +
30984 + if (count > PROFILE_MAX_PACKET_SIZE) {
30985 + count = PROFILE_MAX_PACKET_SIZE;
30986 + }
30987 + stat_count = (count - sizeof(struct profile_header_counters)) / sizeof (struct profile_counter_pkt);
30988 + stat_count -= builtin_count;
30989 +
30990 + if (stat_count <= 0) {
30991 + return 0;
30992 + }
30993 +
30994 + if (stat_count > node->num_counters) {
30995 + stat_count = node->num_counters;
30996 + }
30997 +
30998 + hdr.magic = PROF_MAGIC_COUNTERS;
30999 + hdr.ultra_sample_time = node->clocks;
31000 + hdr.ultra_count = stat_count;
31001 + hdr.linux_sample_time = UBICOM32_IO_TIMER->sysval;
31002 + hdr.linux_count = builtin_count;
31003 + memcpy(ptr, (void *)&hdr, sizeof(struct profile_header_counters));
31004 + ptr += sizeof(struct profile_header_counters);
31005 +
31006 +
31007 + for (i = 0; i < stat_count; ++i) {
31008 + memcpy(ptr, (void *)(&(node->counters[i])), sizeof(struct profile_counter));
31009 + ptr += sizeof(struct profile_counter);
31010 + }
31011 +
31012 + /*
31013 + * built in statistics
31014 + */
31015 + profile_get_memory_stats(&total_free, &max_free);
31016 + profile_builtin_stats[0].value = total_free;
31017 + profile_builtin_stats[1].value = max_free;
31018 + memcpy(ptr, (void *)profile_builtin_stats, sizeof(profile_builtin_stats));
31019 + ptr += sizeof(profile_builtin_stats);
31020 +
31021 + if (copy_to_user(buf, prof_pkt, ptr - prof_pkt) != 0) {
31022 + return -EFAULT;
31023 + }
31024 + return ptr - prof_pkt;
31025 +}
31026 +
31027 +/*
31028 + * return a udp packet ready to send to the profiler tool
31029 + * when there are no packets left to make, return 0
31030 + */
31031 +static int profile_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
31032 +{
31033 + int result = 0;
31034 + if (!node) {
31035 + return -ENOENT;
31036 + }
31037 + node->busy = 1;
31038 + if (!node->enabled) {
31039 + node->busy = 0;
31040 + return -EPERM;
31041 + }
31042 + if (!node->samples) {
31043 + node->busy = 0;
31044 + return -ENOMEM;
31045 + }
31046 +
31047 + if (profile_first_packet) {
31048 + result = profile_make_stats_packet(buf, count);
31049 + profile_first_packet = 0;
31050 + }
31051 + if (result == 0) {
31052 + result = profile_make_data_packet(buf, count);
31053 + if (result == 0) {
31054 + profile_first_packet = 1;
31055 + }
31056 + }
31057 + node->busy = 0;
31058 + return result;
31059 +
31060 +}
31061 +
31062 +static int profile_release(struct inode *inode, struct file *filp)
31063 +{
31064 + if (!node) {
31065 + return -ENOENT;
31066 + }
31067 + node->busy = 1;
31068 + if (node->enabled) {
31069 + node->enabled = 0;
31070 + node->count = 0;
31071 + node->tail = node->head;
31072 + node->busy = 0;
31073 + return 0;
31074 + }
31075 + node->busy = 0;
31076 + profile_first_packet = 1;
31077 + return -EBADF;
31078 +}
31079 +
31080 +static const struct file_operations profile_fops = {
31081 + .open = profile_open,
31082 + .read = profile_read,
31083 + .release = profile_release,
31084 +};
31085 +
31086 +static int page_aligned(void *x)
31087 +{
31088 + return !((unsigned int)x & ((1 << PAGE_SHIFT) - 1));
31089 +}
31090 +
31091 +static int profile_maps_open(struct inode *inode, struct file *filp)
31092 +{
31093 + struct rb_node *rb;
31094 + int num = 0;
31095 + int slab_start;
31096 + struct vm_area_struct *vma;
31097 + int type = PROFILE_MAP_TYPE_UNKNOWN;
31098 + int flags, i;
31099 + struct list_head *p;
31100 + struct zone *zone;
31101 +
31102 + /*
31103 + * get the slab data (first so dups will show up as vmas)
31104 + */
31105 + slab_start = num;
31106 + num += kmem_cache_block_info("size-512", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31107 + num += kmem_cache_block_info("size-1024", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31108 + num += kmem_cache_block_info("size-2048", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31109 + num += kmem_cache_block_info("size-4096", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31110 + num += kmem_cache_block_info("size-8192", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31111 +
31112 + for (i = slab_start; i < num; ++i) {
31113 + profile_pm[i].type_size |= PROFILE_MAP_TYPE_SMALL << PROFILE_MAP_TYPE_SHIFT;
31114 + }
31115 +
31116 + slab_start = num;
31117 + num += kmem_cache_block_info("dentry", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31118 + num += kmem_cache_block_info("inode_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31119 + num += kmem_cache_block_info("sysfs_dir_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31120 + num += kmem_cache_block_info("proc_inode_cache", (struct kmem_cache_size_info *)&profile_pm[num], PROFILE_NUM_MAPS - num);
31121 +
31122 + for (i = slab_start; i < num; ++i) {
31123 + profile_pm[i].type_size |= PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT;
31124 + }
31125 +
31126 + /*
31127 + * get all the vma regions (allocated by mmap, most likely
31128 + */
31129 +#if 0
31130 + down_read(&nommu_vma_sem);
31131 + for (rb = rb_first(&nommu_vma_tree); rb && num < PROFILE_NUM_MAPS; rb = rb_next(rb)) {
31132 + vma = rb_entry(rb, struct vm_area_struct, vm_rb);
31133 + profile_pm[num].start = (vma->vm_start - SDRAMSTART) >> PAGE_SHIFT;
31134 + profile_pm[num].type_size = (vma->vm_end - vma->vm_start + (1 << PAGE_SHIFT) - 1) >> PAGE_SHIFT;
31135 + flags = vma->vm_flags & 0xf;
31136 + if (flags == (VM_READ | VM_EXEC)) {
31137 + type = PROFILE_MAP_TYPE_TEXT;
31138 + } else if (flags == (VM_READ | VM_WRITE | VM_EXEC)) {
31139 + type = PROFILE_MAP_TYPE_STACK;
31140 + } else if (flags == (VM_READ | VM_WRITE)) {
31141 + type = PROFILE_MAP_TYPE_APP_DATA;
31142 + }
31143 + profile_pm[num].type_size |= type << PROFILE_MAP_TYPE_SHIFT;
31144 + num++;
31145 + }
31146 + up_read(&nommu_vma_sem);
31147 + if (rb) {
31148 + return -ENOMEM;
31149 + }
31150 +#endif
31151 +
31152 + /*
31153 + * get all the free regions. In each zone, the array of free_area lists contains the first page of each frame of size 1 << order
31154 + */
31155 + for_each_zone(zone) {
31156 + unsigned long order, flags, i;
31157 + struct page *page;
31158 +
31159 + if (!populated_zone(zone))
31160 + continue;
31161 +
31162 + if (!is_normal(zone))
31163 + continue;
31164 +
31165 + spin_lock_irqsave(&zone->lock, flags);
31166 + for_each_migratetype_order(order, i) {
31167 + list_for_each(p, &(zone->free_area[order].free_list[i])) {
31168 + page = list_entry(p, struct page, lru);
31169 + profile_pm[num].start = ((page_to_phys(page) - SDRAMSTART) >> PAGE_SHIFT) - 0x40;
31170 + profile_pm[num].type_size = (PROFILE_MAP_TYPE_FREE << PROFILE_MAP_TYPE_SHIFT) | order;
31171 + num++;
31172 + if (num >= PROFILE_NUM_MAPS) {
31173 + spin_unlock_irqrestore(&zone->lock, flags);
31174 + return -ENOMEM;
31175 + }
31176 + }
31177 + }
31178 + spin_unlock_irqrestore(&zone->lock, flags);
31179 + }
31180 +
31181 + /*
31182 + * get the filesystem inodes
31183 + */
31184 + list_for_each(p, &(super_blocks)) {
31185 + struct super_block *sb;
31186 + struct list_head *q;
31187 + if (num >= PROFILE_NUM_MAPS)
31188 + break;
31189 + sb = list_entry(p, struct super_block, s_list);
31190 + if (page_aligned(sb)) {
31191 + profile_pm[num].start = ((unsigned int)sb - SDRAMSTART) >> PAGE_SHIFT;
31192 + profile_pm[num].type_size = (PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT);
31193 + num++;
31194 + }
31195 + list_for_each(q, &(sb->s_inodes)) {
31196 + struct inode *in;
31197 + if (num >= PROFILE_NUM_MAPS)
31198 + break;
31199 + in = list_entry(q, struct inode, i_sb_list);
31200 + if (page_aligned(in)) {
31201 + profile_pm[num].start = ((unsigned int)in - SDRAMSTART) >> PAGE_SHIFT;
31202 + profile_pm[num].type_size = (PROFILE_MAP_TYPE_FS << PROFILE_MAP_TYPE_SHIFT);
31203 + num++;
31204 + }
31205 + }
31206 + }
31207 +
31208 + /*
31209 + * get the buffer cache pages
31210 + */
31211 + for (i = 0; i < num_physpages && num < PROFILE_NUM_MAPS; ++i) {
31212 + if ((mem_map + i)->flags & (1 << PG_lru)) {
31213 + int start = i;
31214 + while ((mem_map + i)->flags & (1 << PG_lru) && i < num_physpages)
31215 + i++;
31216 + profile_pm[num].start = start;
31217 + profile_pm[num].type_size = (i - start) | (PROFILE_MAP_TYPE_CACHE << PROFILE_MAP_TYPE_SHIFT);
31218 + num++;
31219 + }
31220 + }
31221 +
31222 + filp->private_data = (void *)num;
31223 + return 0;
31224 +}
31225 +
31226 +/*
31227 + * return one packet of map data, or 0 if all maps have been returned already
31228 + */
31229 +static int profile_maps_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
31230 +{
31231 + struct profile_header_maps header;
31232 + char *p = buf + sizeof(header);
31233 + int total = (int)filp->private_data;
31234 +
31235 + header.count = (count - sizeof(header)) / sizeof(struct profile_map);
31236 + if (header.count > PROFILE_MAX_MAPS) {
31237 + header.count = PROFILE_MAX_MAPS;;
31238 + }
31239 + if (header.count > total - *f_pos) {
31240 + header.count = total - *f_pos;
31241 + }
31242 +
31243 + if (header.count == 0) {
31244 + return 0;
31245 + }
31246 +
31247 + header.magic = PROF_MAGIC_MAPS;
31248 + header.page_shift = PAGE_SHIFT;
31249 +
31250 + if (copy_to_user(buf, &header, sizeof(header)) != 0) {
31251 + return -EFAULT;
31252 + }
31253 + if (copy_to_user(p, (void *)&profile_pm[*f_pos], sizeof(struct profile_map) * header.count) != 0) {
31254 + return -EFAULT;
31255 + }
31256 + *f_pos += header.count;
31257 +
31258 + return sizeof(header) + sizeof(struct profile_map) * header.count;
31259 +}
31260 +
31261 +static int profile_maps_release(struct inode *inode, struct file *filp)
31262 +{
31263 + return 0;
31264 +}
31265 +
31266 +static const struct file_operations profile_maps_fops = {
31267 + .open = profile_maps_open,
31268 + .read = profile_maps_read,
31269 + .release = profile_maps_release,
31270 +};
31271 +
31272 +static int profile_rate_show(struct seq_file *m, void *v)
31273 +{
31274 + if (node) {
31275 + seq_printf(m, "%d samples per second. %d virtual counters.\n", node->rate, node->num_counters);
31276 + } else {
31277 + seq_printf(m, "Profiler is not initialized.\n");
31278 + }
31279 + return 0;
31280 +}
31281 +
31282 +static int profile_rate_open(struct inode *inode, struct file *filp)
31283 +{
31284 + return single_open(filp, profile_rate_show, NULL);
31285 +}
31286 +
31287 +static int profile_rate_write(struct file *filp, const char *buf, size_t len, loff_t *off)
31288 +{
31289 + *off = 0;
31290 + return 0;
31291 +}
31292 +
31293 +static const struct file_operations profile_rate_fops = {
31294 + .open = profile_rate_open,
31295 + .read = seq_read,
31296 + .llseek = seq_lseek,
31297 + .release = single_release,
31298 + .write = profile_rate_write,
31299 +};
31300 +
31301 +int ubi32_profile_init_module(void)
31302 +{
31303 + struct proc_dir_entry *pdir;
31304 +
31305 + /*
31306 + * find the device
31307 + */
31308 + node = (struct profilenode *)devtree_find_node("profiler");
31309 + if (!node) {
31310 + printk(KERN_INFO "Profiler does not exist.\n");
31311 + return -ENODEV;
31312 + }
31313 +
31314 + /*
31315 + * allocate the sample buffer
31316 + */
31317 + node->max_samples = PROFILE_MAX_SAMPLES;
31318 + node->samples = kmalloc(node->max_samples * sizeof(struct profile_sample), GFP_KERNEL);
31319 + if (!node->samples) {
31320 + printk(KERN_INFO "Profiler sample buffer kmalloc failed.\n");
31321 + return -ENOMEM;
31322 + }
31323 +
31324 + /*
31325 + * connect to the file system
31326 + */
31327 + pdir = proc_mkdir("profile", NULL);
31328 + if (!pdir) {
31329 + return -ENOMEM;
31330 + }
31331 + if (!proc_create("data", 0, pdir, &profile_fops)) {
31332 + return -ENOMEM;
31333 + }
31334 + if (!proc_create("rate", 0, pdir, &profile_rate_fops)) {
31335 + return -ENOMEM;
31336 + }
31337 + if (!proc_create("maps", 0, pdir, &profile_maps_fops)) {
31338 + return -ENOMEM;
31339 + }
31340 + return 0;
31341 +}
31342 +
31343 +
31344 +module_init(ubi32_profile_init_module);
31345 +
31346 +MODULE_AUTHOR("David Fotland");
31347 +MODULE_LICENSE("GPL");
31348 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/profile.h linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profile.h
31349 --- linux-2.6.30.10/arch/ubicom32/mach-common/profile.h 1970-01-01 02:00:00.000000000 +0200
31350 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profile.h 2009-12-11 11:45:11.000000000 +0200
31351 @@ -0,0 +1,82 @@
31352 +/*
31353 + * arch/ubicom32/mach-common/profile.h
31354 + * Private data for the profile module
31355 + *
31356 + * (C) Copyright 2009, Ubicom, Inc.
31357 + *
31358 + * This file is part of the Ubicom32 Linux Kernel Port.
31359 + *
31360 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
31361 + * it and/or modify it under the terms of the GNU General Public License
31362 + * as published by the Free Software Foundation, either version 2 of the
31363 + * License, or (at your option) any later version.
31364 + *
31365 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
31366 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
31367 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
31368 + * the GNU General Public License for more details.
31369 + *
31370 + * You should have received a copy of the GNU General Public License
31371 + * along with the Ubicom32 Linux Kernel Port. If not,
31372 + * see <http://www.gnu.org/licenses/>.
31373 + *
31374 + * Ubicom32 implementation derived from (with many thanks):
31375 + * arch/m68knommu
31376 + * arch/blackfin
31377 + * arch/parisc
31378 + */
31379 +
31380 +#include <linux/types.h>
31381 +#include <asm/devtree.h>
31382 +#include "profpkt.h"
31383 +
31384 +#ifndef _PROFILE_H_
31385 +#define _PROFILE_H_
31386 +
31387 +#define PROFILE_MAX_THREADS 16
31388 +#define PROFILE_MAX_SAMPLES 1024
31389 +
31390 +struct profile_sample;
31391 +struct oprofile_sample;
31392 +
31393 +/*
31394 + * values chosen so all counter values fit in a single UDP packet
31395 + */
31396 +#define PROFILE_NODE_MAX_COUNTERS 32
31397 +
31398 +struct profile_counter {
31399 + char name[PROFILE_COUNTER_NAME_LENGTH];
31400 + unsigned int value;
31401 +};
31402 +
31403 +struct profilenode {
31404 + struct devtree_node dn;
31405 + volatile u32_t enabled; /* Is the profiler enabled to take samples? */
31406 + volatile u32_t busy; /* set when the samples are being read by the driver */
31407 + volatile u32_t rate; /* What is the sampling rate? */
31408 + volatile u32_t enabled_threads; /* which threads were enabled at the last sample time */
31409 + volatile u32_t hrt; /* HRT threads */
31410 + volatile u32_t profiler_thread; /* thread running the profile sampler */
31411 + volatile u32_t clocks; /* system clock timer at last sample */
31412 + volatile u32_t clock_freq; /* clock frequency in Hz */
31413 + volatile u32_t ddr_freq; /* memory frequency */
31414 + volatile u32_t cpu_id; /* chip_id register */
31415 + volatile u32_t inst_count[PROFILE_MAX_THREADS]; /* sampled instruction counts at most recent sample */
31416 + volatile u32_t stats[4]; /* contents of the cache statistics counters */
31417 + volatile u16_t head; /* sample taker puts samples here */
31418 + volatile u16_t tail; /* packet filler takes samples here */
31419 + volatile u16_t count; /* number of valid samples */
31420 + volatile u16_t max_samples; /* how many samples can be in the samples array */
31421 + struct profile_sample *samples; /* samples array allocated by the linux driver */
31422 + volatile u32_t num_counters; /* how many registered performance counters */
31423 + volatile struct profile_counter counters[PROFILE_NODE_MAX_COUNTERS];
31424 +
31425 + /* unimplemented interface for future oprofile work */
31426 + volatile u16_t oprofile_head; /* sample taker puts samples here */
31427 + volatile u16_t oprofile_tail; /* packet filler takes samples here */
31428 + volatile u16_t oprofile_count; /* how many oprofile sampels are are in use */
31429 + volatile u16_t oprofile_max_samples; /* samples array size for oprofile samples */
31430 + struct oprofile_sample *oprofile_samples; /* oprofile sample buffer */
31431 +};
31432 +
31433 +#endif
31434 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/profpkt.h linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profpkt.h
31435 --- linux-2.6.30.10/arch/ubicom32/mach-common/profpkt.h 1970-01-01 02:00:00.000000000 +0200
31436 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/profpkt.h 2009-12-11 11:45:11.000000000 +0200
31437 @@ -0,0 +1,158 @@
31438 +
31439 +/*
31440 + * arch/ubicom32/mach-common/profpkt.c
31441 + * Ubicom32 Profiler packet formats for communication between the linux proc driver and the profiler display tool
31442 + *
31443 + * (C) Copyright 2009, Ubicom, Inc.
31444 + *
31445 + * This file is part of the Ubicom32 Linux Kernel Port.
31446 + *
31447 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
31448 + * it and/or modify it under the terms of the GNU General Public License
31449 + * as published by the Free Software Foundation, either version 2 of the
31450 + * License, or (at your option) any later version.
31451 + *
31452 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
31453 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
31454 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
31455 + * the GNU General Public License for more details.
31456 + *
31457 + * You should have received a copy of the GNU General Public License
31458 + * along with the Ubicom32 Linux Kernel Port. If not,
31459 + * see <http://www.gnu.org/licenses/>.
31460 + */
31461 +
31462 +#define PROFILE_PORT 51080
31463 +#define PROFILE_POSIX_NAME_LENGTH 32
31464 +
31465 +/*
31466 + * profile UDP packet format for communicating between ip3k and host
31467 + *
31468 + * every packet starts with a header, followed by samples.
31469 + * samples are only taken for non-hrt threads that are
31470 + * active
31471 + */
31472 +#define PROF_MAGIC 0x3ea0
31473 +#define PROF_MAGIC_COUNTERS 0x9ea0
31474 +#define PROF_MAGIC_MAPS 0xaea0
31475 +
31476 +/*
31477 + * Versions (31 max):
31478 + * 1 to 4 were before 6.0 release, development versions
31479 + * 5 was forward compatible version, shipped with 6.0 and 6.1
31480 + * 6 adds heap packets, and clock_freq to header, shipped with 6.2
31481 + * 7 adds a sequence numbers to check for dropped packets, shipped with 6.3.5
31482 + * 8 adds mqueue timing information, shipped with 6.3.5
31483 + * 9 adds sdram heap size information, shipped with 6.4
31484 + * 10 adds heapmem heap callers and long latency stack traces. shipped with 6.4
31485 + * 11 adds support for Mars (IP5K). shipped with 6.10
31486 + * 12 adds more support for Mars. Shipped with 7.0
31487 + * 13 adds per sample latency measurement. Shipped with 7.2
31488 + * 14 changes the heap format and adds a string packet. Shipped with 7.4
31489 + * 15 adds dsr stats and posix. shipped with 7.6
31490 + * 16 corrects maximum packet count for Ares. ships with 7.9
31491 + * 17 adds a5 register value to sample
31492 + */
31493 +
31494 +#define PROFILE_VERSION 17
31495 +#define PROFILE_MAX_PACKET_SIZE 1440
31496 +
31497 +#define PROFILE_MAX_THREADS 16
31498 +
31499 +/*
31500 + * each packet starts with a profile_header, then sample_count samples
31501 + * samples are gprof samples of pc, the return address, condition codes, and
31502 + * active threads
31503 + */
31504 +struct profile_header {
31505 + u16_t magic; /* magic number and version */
31506 + u8_t header_size; /* number of bytes in profile header */
31507 + u8_t sample_count; /* number of samples in the packet */
31508 + u32_t clocks; /* clock counter value */
31509 + u32_t instruction_count[PROFILE_MAX_THREADS];
31510 + /* instructions executed per thread */
31511 + u32_t profile_instructions; /* instructions executed by profiler mainline */
31512 + u16_t enabled; /* which threads are enabled */
31513 + u16_t hrt; /* which threads are hrt */
31514 + u16_t high; /* which threads are high priority */
31515 + u16_t profiler_thread; /* which thread runs the profiler */
31516 + u32_t heap_free; /* current free on-cihp heap space in bytes */
31517 + u32_t heap_low_water; /* on-chip heap low water mark */
31518 + u32_t netpage_free; /* number of free on-chip net pages */
31519 + u32_t netpage_low_water; /* low water mark on free on-chip netpages */
31520 + u32_t min_sp[PROFILE_MAX_THREADS];
31521 + /* stack pointer values per thread */
31522 + u32_t clock_freq; /* clock frequency (Hz) of system being analyzed */
31523 + u32_t seq_num; /* to detect dropped profiler packets */
31524 + u32_t timing_sequence; /* sample number since boot */
31525 + u32_t timing_interval; /* second per sample timing interval */
31526 + u32_t timing_worst_time; /* duration of longest finction called, in core clocks */
31527 + u32_t timing_function; /* address of longest function */
31528 + u32_t timing_average; /* average time of all functions in last interval */
31529 + u32_t timing_count; /* number of functions called in last interval */
31530 + u32_t extheap_free; /* current free extmem heap space in bytes */
31531 + u32_t extheap_low_water; /* extmem heap low water mark */
31532 + u32_t cpu_id; /* CHIP_ID register contents */
31533 + u32_t perf_counters[4]; /* contents of the CPU performance counters */
31534 + u8_t perf_config[4]; /* what is being counted */
31535 + u32_t ddr_freq; /* DDR clock frequency */
31536 + u32_t extnetpage_free; /* number of free off chip net pages */
31537 + u32_t extnetpage_low_water; /* low water mark on off-chip free netpages */
31538 + u32_t dsr_max_latency; /* max time to process a dsr interrupt, in clocks, since last packet */
31539 + u32_t dsr_ave_latency; /* average dsr latency over last DSR_STATS_RECENT_COUNT interrupts */
31540 + u32_t dsr_count; /* number of dsr interrupts since last packet */
31541 +};
31542 +
31543 +struct profile_header_counters {
31544 + u16_t magic;
31545 + u16_t ultra_count; /* how many ultra counters follow this */
31546 + u32_t ultra_sample_time; /* in chip clocks */
31547 + u32_t linux_count; /* how many linux counters follow this */
31548 + u32_t linux_sample_time;
31549 +};
31550 +
31551 +/*
31552 + * values chosen so all counter values fit in a single 1400 byte UDP packet
31553 + */
31554 +#define PROFILE_COUNTER_NAME_LENGTH 20
31555 +#define PROFILE_MAX_COUNTERS ((PROFILE_MAX_PACKET_SIZE - sizeof(struct profile_header_counters)) / (PROFILE_COUNTER_NAME_LENGTH + 4))
31556 +
31557 +struct profile_counter_pkt {
31558 + char name[PROFILE_COUNTER_NAME_LENGTH];
31559 + unsigned int value;
31560 +};
31561 +
31562 +/*
31563 + * send memory maps from linux to profiler tool
31564 + */
31565 +
31566 +struct profile_header_maps {
31567 + u16_t magic;
31568 + u16_t count;
31569 + u32_t page_shift;
31570 +};
31571 +
31572 +#define PROFILE_MAP_NUM_TYPES 32
31573 +
31574 +/* types 0-15: size field is order. True size is 2^order */
31575 +#define PROFILE_MAP_TYPE_UNKNOWN 0
31576 +#define PROFILE_MAP_TYPE_FREE 1
31577 +#define PROFILE_MAP_TYPE_SMALL 2
31578 +#define PROFILE_MAP_TYPE_FS 3
31579 +/* types 16-31: size field is pages. True size is (1 << PAGE_SHIFT) * size */
31580 +#define PROFILE_MAP_SIZE_TYPE 16
31581 +#define PROFILE_MAP_TYPE_TEXT 16
31582 +#define PROFILE_MAP_TYPE_STACK 17
31583 +#define PROFILE_MAP_TYPE_APP_DATA 18
31584 +#define PROFILE_MAP_TYPE_CACHE 19
31585 +#define PROFILE_MAP_RESERVED 24
31586 +
31587 +#define PROFILE_MAP_TYPE_SHIFT 11
31588 +#define PROFILE_MAP_SIZE_MASK 0x7ff
31589 +
31590 +struct profile_map {
31591 + u16_t start; /* start page number of segment, relative to start of DRAM */
31592 + u16_t type_size; /* type (4 bits) of the segment and size in pages (12 bits) */
31593 +};
31594 +
31595 +#define PROFILE_MAX_MAPS (PROFILE_MAX_PACKET_SIZE - sizeof(struct profile_header_maps)) / sizeof(struct profile_map)
31596 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/ring_tio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ring_tio.c
31597 --- linux-2.6.30.10/arch/ubicom32/mach-common/ring_tio.c 1970-01-01 02:00:00.000000000 +0200
31598 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ring_tio.c 2009-12-11 11:45:11.000000000 +0200
31599 @@ -0,0 +1,123 @@
31600 +/*
31601 + * arch/ubicom32/mach-common/ring_tio.c
31602 + * Generic initialization for UIO Ubicom32 Ring
31603 + *
31604 + * (C) Copyright 2009, Ubicom, Inc.
31605 + *
31606 + * This file is part of the Ubicom32 Linux Kernel Port.
31607 + *
31608 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
31609 + * it and/or modify it under the terms of the GNU General Public License
31610 + * as published by the Free Software Foundation, either version 2 of the
31611 + * License, or (at your option) any later version.
31612 + *
31613 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
31614 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
31615 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
31616 + * the GNU General Public License for more details.
31617 + *
31618 + * You should have received a copy of the GNU General Public License
31619 + * along with the Ubicom32 Linux Kernel Port. If not,
31620 + * see <http://www.gnu.org/licenses/>.
31621 + */
31622 +
31623 +#include <linux/platform_device.h>
31624 +#include <linux/types.h>
31625 +
31626 +#include <asm/devtree.h>
31627 +#include <asm/ring_tio.h>
31628 +
31629 +static const char *ring_tio_driver_name = "uio_ubicom32ring";
31630 +
31631 +/*
31632 + * The number of ring_tio's currently allocated, used for .id
31633 + */
31634 +static int __initdata ring_tio_count;
31635 +
31636 +/*
31637 + * The maximum number of resources that the ring_tio will have.
31638 + * Currently 3, a register space, and up to 2 interrupts.
31639 + */
31640 +#define RING_TIO_MAX_RESOURCES 3
31641 +
31642 +/*
31643 + * ring_tio_init
31644 + * Checks the device tree and instantiates the driver if found
31645 + */
31646 +void __init ring_tio_init(const char *node_name)
31647 +{
31648 + struct platform_device *pdev;
31649 + struct resource *res;
31650 + int resource_idx = 0;
31651 + struct ring_tio_node *ring_node;
31652 +
31653 + /*
31654 + * Check the device tree for the ring_tio
31655 + */
31656 + ring_node = (struct ring_tio_node *)devtree_find_node(node_name);
31657 + if (!ring_node) {
31658 + printk(KERN_WARNING "Ring TIO '%s' not found\n", node_name);
31659 + return;
31660 + }
31661 +
31662 + if (ring_node->version != RING_TIO_NODE_VERSION) {
31663 + printk(KERN_WARNING "ring_tio not compatible\n");
31664 + return;
31665 + }
31666 +
31667 + /*
31668 + * Dynamically create the platform_device structure and resources
31669 + */
31670 + pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
31671 + if (!pdev) {
31672 + printk(KERN_WARNING "ring_tio could not alloc pdev\n");
31673 + return;
31674 + }
31675 +
31676 + res = kzalloc(sizeof(struct resource) * RING_TIO_MAX_RESOURCES,
31677 + GFP_KERNEL);
31678 + if (!res) {
31679 + kfree(pdev);
31680 + printk(KERN_WARNING "ring_tio could not alloc res\n");
31681 + return;
31682 + }
31683 +
31684 + pdev->name = ring_tio_driver_name;
31685 + pdev->id = ring_tio_count++;
31686 + pdev->resource = res;
31687 +
31688 + /*
31689 + * Fill in the resources and platform data from devtree information
31690 + */
31691 + res[resource_idx].start = (u32_t)(ring_node->regs);
31692 + res[resource_idx].end = (u32_t)(ring_node->regs);
31693 + res[resource_idx].flags = IORESOURCE_MEM;
31694 + resource_idx++;
31695 +
31696 + if (ring_node->dn.sendirq != 0xFF) {
31697 + res[resource_idx].start = ring_node->dn.sendirq;
31698 + res[resource_idx].flags = IORESOURCE_IRQ;
31699 + resource_idx++;
31700 + }
31701 +
31702 + if (ring_node->dn.recvirq != 0xFF) {
31703 + res[resource_idx].start = ring_node->dn.recvirq;
31704 + res[resource_idx].flags = IORESOURCE_IRQ;
31705 + resource_idx++;
31706 + }
31707 + pdev->num_resources = resource_idx;
31708 +
31709 + printk(KERN_INFO "RingTIO.%d '%s' found irq=%d/%d regs=%p pdev=%p/%p\n",
31710 + ring_tio_count - 1, node_name, ring_node->dn.sendirq,
31711 + ring_node->dn.recvirq, ring_node->regs, pdev, res);
31712 +
31713 + /*
31714 + * Try to get the device registered
31715 + */
31716 + pdev->dev.platform_data = (void *)node_name;
31717 + if (platform_device_register(pdev) < 0) {
31718 + printk(KERN_WARNING "Ring failed to register\n");
31719 + kfree(pdev);
31720 + kfree(res);
31721 + }
31722 +}
31723 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/switch-bcm539x.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-bcm539x.c
31724 --- linux-2.6.30.10/arch/ubicom32/mach-common/switch-bcm539x.c 1970-01-01 02:00:00.000000000 +0200
31725 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-bcm539x.c 2009-12-11 11:45:11.000000000 +0200
31726 @@ -0,0 +1,1195 @@
31727 +/*
31728 + * arch/ubicom32/mach-common/switch-bcm539x.c
31729 + * BCM539X switch driver, SPI mode
31730 + *
31731 + * (C) Copyright 2009, Ubicom, Inc.
31732 + *
31733 + * This file is part of the Ubicom32 Linux Kernel Port.
31734 + *
31735 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
31736 + * it and/or modify it under the terms of the GNU General Public License
31737 + * as published by the Free Software Foundation, either version 2 of the
31738 + * License, or (at your option) any later version.
31739 + *
31740 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
31741 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
31742 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
31743 + * the GNU General Public License for more details.
31744 + *
31745 + * You should have received a copy of the GNU General Public License
31746 + * along with the Ubicom32 Linux Kernel Port. If not,
31747 + * see <http://www.gnu.org/licenses/>.
31748 + *
31749 + * Ubicom32 implementation derived from (with many thanks):
31750 + * arch/m68knommu
31751 + * arch/blackfin
31752 + * arch/parisc
31753 + */
31754 +
31755 +#include <linux/platform_device.h>
31756 +#include <linux/spi/spi.h>
31757 +#include <linux/gpio.h>
31758 +#include <linux/delay.h>
31759 +#include <linux/mii.h>
31760 +
31761 +#include <asm/switch-dev.h>
31762 +#include <asm/ubicom32-spi-gpio.h>
31763 +#include "switch-core.h"
31764 +#include "switch-bcm539x-reg.h"
31765 +
31766 +#define DRIVER_NAME "bcm539x-spi"
31767 +#define DRIVER_VERSION "1.0"
31768 +
31769 +#undef BCM539X_DEBUG
31770 +#define BCM539X_SPI_RETRIES 100
31771 +
31772 +struct bcm539x_data {
31773 + struct switch_device *switch_dev;
31774 +
31775 + /*
31776 + * Our private data
31777 + */
31778 + struct spi_device *spi;
31779 + struct switch_core_platform_data *pdata;
31780 +
31781 + /*
31782 + * Last page we accessed
31783 + */
31784 + u8_t last_page;
31785 +
31786 + /*
31787 + * 539x Device ID
31788 + */
31789 + u8_t device_id;
31790 +};
31791 +
31792 +/*
31793 + * bcm539x_wait_status
31794 + * Waits for the specified bit in the status register to be set/cleared.
31795 + */
31796 +static int bcm539x_wait_status(struct bcm539x_data *bd, u8_t mask, int set)
31797 +{
31798 + u8_t txbuf[2];
31799 + u8_t rxbuf;
31800 + int i;
31801 + int ret;
31802 +
31803 + txbuf[0] = BCM539X_CMD_READ;
31804 + txbuf[1] = BCM539X_GLOBAL_SPI_STATUS;
31805 + for (i = 0; i < BCM539X_SPI_RETRIES; i++) {
31806 + ret = spi_write_then_read(bd->spi, txbuf, 2, &rxbuf, 1);
31807 + rxbuf &= mask;
31808 + if ((set && rxbuf) || (!set && !rxbuf)) {
31809 + return 0;
31810 + }
31811 + udelay(1);
31812 + }
31813 +
31814 + return -EIO;
31815 +}
31816 +
31817 +/*
31818 + * bcm539x_set_page
31819 + * Sets the register page for access (only if necessary)
31820 + */
31821 +static int bcm539x_set_page(struct bcm539x_data *bd, u8_t page)
31822 +{
31823 + u8_t txbuf[3];
31824 +
31825 + if (page == bd->last_page) {
31826 + return 0;
31827 + }
31828 +
31829 + bd->last_page = page;
31830 +
31831 + txbuf[0] = BCM539X_CMD_WRITE;
31832 + txbuf[1] = BCM539X_GLOBAL_PAGE;
31833 + txbuf[2] = page;
31834 +
31835 + return spi_write(bd->spi, txbuf, 3);
31836 +}
31837 +
31838 +/*
31839 + * bcm539x_write_bytes
31840 + * Writes a number of bytes to a given page and register
31841 + */
31842 +static int bcm539x_write_bytes(struct bcm539x_data *bd, u8_t page,
31843 + u8_t reg, void *buf, u8_t len)
31844 +{
31845 + int ret;
31846 + u8_t *txbuf;
31847 +
31848 + txbuf = kmalloc(2 + len, GFP_KERNEL);
31849 + if (!txbuf) {
31850 + return -ENOMEM;
31851 + }
31852 +
31853 + /*
31854 + * Make sure the chip has finished processing our previous request
31855 + */
31856 + ret = bcm539x_wait_status(bd, BCM539X_GLOBAL_SPI_ST_SPIF, 0);
31857 + if (ret) {
31858 + goto done;
31859 + }
31860 +
31861 + /*
31862 + * Set the page
31863 + */
31864 + ret = bcm539x_set_page(bd, page);
31865 + if (ret) {
31866 + goto done;
31867 + }
31868 +
31869 + /*
31870 + * Read the data
31871 + */
31872 + txbuf[0] = BCM539X_CMD_WRITE;
31873 + txbuf[1] = reg;
31874 + memcpy(&txbuf[2], buf, len);
31875 +
31876 +#ifdef BCM539X_DEBUG
31877 + {
31878 + int i;
31879 + printk("write page %02x reg %02x len=%d buf=", page, reg, len);
31880 + for (i = 0; i < len + 2; i++) {
31881 + printk("%02x ", txbuf[i]);
31882 + }
31883 + printk("\n");
31884 + }
31885 +#endif
31886 +
31887 + ret = spi_write(bd->spi, txbuf, 2 + len);
31888 +
31889 +done:
31890 + kfree(txbuf);
31891 + return ret;
31892 +}
31893 +
31894 +/*
31895 + * bcm539x_write_32
31896 + * Writes 32 bits of data to the given page and register
31897 + */
31898 +static inline int bcm539x_write_32(struct bcm539x_data *bd, u8_t page,
31899 + u8_t reg, u32_t data)
31900 +{
31901 + data = cpu_to_le32(data);
31902 + return bcm539x_write_bytes(bd, page, reg, &data, 4);
31903 +}
31904 +
31905 +/*
31906 + * bcm539x_write_16
31907 + * Writes 16 bits of data to the given page and register
31908 + */
31909 +static inline int bcm539x_write_16(struct bcm539x_data *bd, u8_t page,
31910 + u8_t reg, u16_t data)
31911 +{
31912 + data = cpu_to_le16(data);
31913 + return bcm539x_write_bytes(bd, page, reg, &data, 2);
31914 +}
31915 +
31916 +/*
31917 + * bcm539x_write_8
31918 + * Writes 8 bits of data to the given page and register
31919 + */
31920 +static inline int bcm539x_write_8(struct bcm539x_data *bd, u8_t page,
31921 + u8_t reg, u8_t data)
31922 +{
31923 + return bcm539x_write_bytes(bd, page, reg, &data, 1);
31924 +}
31925 +
31926 +/*
31927 + * bcm539x_read_bytes
31928 + * Reads a number of bytes from a given page and register
31929 + */
31930 +static int bcm539x_read_bytes(struct bcm539x_data *bd, u8_t page,
31931 + u8_t reg, void *buf, u8_t len)
31932 +{
31933 + u8_t txbuf[2];
31934 + int ret;
31935 +
31936 + /*
31937 + * (1) Make sure the chip has finished processing our previous request
31938 + */
31939 + ret = bcm539x_wait_status(bd, BCM539X_GLOBAL_SPI_ST_SPIF, 0);
31940 + if (ret) {
31941 + return ret;
31942 + }
31943 +
31944 + /*
31945 + * (2) Set the page
31946 + */
31947 + ret = bcm539x_set_page(bd, page);
31948 + if (ret) {
31949 + return ret;
31950 + }
31951 +
31952 + /*
31953 + * (3) Kick off the register read
31954 + */
31955 + txbuf[0] = BCM539X_CMD_READ;
31956 + txbuf[1] = reg;
31957 + ret = spi_write_then_read(bd->spi, txbuf, 2, txbuf, 1);
31958 + if (ret) {
31959 + return ret;
31960 + }
31961 +
31962 + /*
31963 + * (4) Wait for RACK
31964 + */
31965 + ret = bcm539x_wait_status(bd, BCM539X_GLOBAL_SPI_ST_RACK, 1);
31966 + if (ret) {
31967 + return ret;
31968 + }
31969 +
31970 + /*
31971 + * (5) Read the data
31972 + */
31973 + txbuf[0] = BCM539X_CMD_READ;
31974 + txbuf[1] = BCM539X_GLOBAL_SPI_DATA0;
31975 +
31976 + ret = spi_write_then_read(bd->spi, txbuf, 2, buf, len);
31977 +
31978 +#ifdef BCM539X_DEBUG
31979 + {
31980 + int i;
31981 + printk("read page %02x reg %02x len=%d rxbuf=",
31982 + page, reg, len);
31983 + for (i = 0; i < len; i++) {
31984 + printk("%02x ", ((u8_t *)buf)[i]);
31985 + }
31986 + printk("\n");
31987 + }
31988 +#endif
31989 +
31990 + return ret;
31991 +}
31992 +
31993 +/*
31994 + * bcm539x_read_32
31995 + * Reads an 32 bit number from a given page and register
31996 + */
31997 +static int bcm539x_read_32(struct bcm539x_data *bd, u8_t page,
31998 + u8_t reg, u32_t *buf)
31999 +{
32000 + int ret = bcm539x_read_bytes(bd, page, reg, buf, 4);
32001 + *buf = le32_to_cpu(*buf);
32002 + return ret;
32003 +}
32004 +
32005 +/*
32006 + * bcm539x_read_16
32007 + * Reads an 16 bit number from a given page and register
32008 + */
32009 +static int bcm539x_read_16(struct bcm539x_data *bd, u8_t page,
32010 + u8_t reg, u16_t *buf)
32011 +{
32012 + int ret = bcm539x_read_bytes(bd, page, reg, buf, 2);
32013 + *buf = le16_to_cpu(*buf);
32014 + return ret;
32015 +}
32016 +
32017 +/*
32018 + * bcm539x_read_8
32019 + * Reads an 8 bit number from a given page and register
32020 + */
32021 +static int bcm539x_read_8(struct bcm539x_data *bd, u8_t page,
32022 + u8_t reg, u8_t *buf)
32023 +{
32024 + return bcm539x_read_bytes(bd, page, reg, buf, 1);
32025 +}
32026 +
32027 +/*
32028 + * bcm539x_set_mode
32029 + */
32030 +static int bcm539x_set_mode(struct bcm539x_data *bd, int state)
32031 +{
32032 + u8_t buf;
32033 + int ret;
32034 +
32035 + ret = bcm539x_read_8(bd, PAGE_PORT_TC, REG_CTRL_MODE, &buf);
32036 + if (ret) {
32037 + return ret;
32038 + }
32039 +
32040 + buf &= ~(1 << 1);
32041 + buf |= state ? (1 << 1) : 0;
32042 +
32043 + ret = bcm539x_write_8(bd, PAGE_PORT_TC, REG_CTRL_MODE, buf);
32044 + return ret;
32045 +}
32046 +
32047 +/*
32048 + * bcm539x_handle_reset
32049 + */
32050 +static int bcm539x_handle_reset(struct switch_device *dev, char *buf, int inst)
32051 +{
32052 + struct bcm539x_data *bd =
32053 + (struct bcm539x_data *)switch_get_drvdata(dev);
32054 + int ret;
32055 +
32056 + ret = bcm539x_write_8(bd, PAGE_PORT_TC, REG_CTRL_SRST,
32057 + (1 << 7) | (1 << 4));
32058 + if (ret) {
32059 + return ret;
32060 + }
32061 +
32062 + udelay(20);
32063 +
32064 + ret = bcm539x_write_8(bd, PAGE_PORT_TC, REG_CTRL_SRST, 0);
32065 + return ret;
32066 +}
32067 +
32068 +/*
32069 + * bcm539x_handle_vlan_ports_read
32070 + */
32071 +static int bcm539x_handle_vlan_ports_read(struct switch_device *dev,
32072 + char *buf, int inst)
32073 +{
32074 + struct bcm539x_data *bd =
32075 + (struct bcm539x_data *)switch_get_drvdata(dev);
32076 + int j;
32077 + int len = 0;
32078 + u8_t rxbuf8;
32079 + u32_t rxbuf32;
32080 + int ret;
32081 +
32082 + ret = bcm539x_write_16(bd, PAGE_VTBL, REG_VTBL_INDX_5395, inst);
32083 + if (ret) {
32084 + return ret;
32085 + }
32086 +
32087 + ret = bcm539x_write_8(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395,
32088 + (1 << 7) | 1);
32089 + if (ret) {
32090 + return ret;
32091 + }
32092 +
32093 + /*
32094 + * Wait for completion
32095 + */
32096 + for (j = 0; j < BCM539X_SPI_RETRIES; j++) {
32097 + ret = bcm539x_read_8(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395,
32098 + &rxbuf8);
32099 + if (ret) {
32100 + return ret;
32101 + }
32102 + if (!(rxbuf8 & (1 << 7))) {
32103 + break;
32104 + }
32105 + }
32106 +
32107 + if (j == BCM539X_SPI_RETRIES) {
32108 + return -EIO;
32109 + }
32110 +
32111 + /*
32112 + * Read the table entry
32113 + */
32114 + ret = bcm539x_read_32(bd, PAGE_VTBL, REG_VTBL_ENTRY_5395, &rxbuf32);
32115 + if (ret) {
32116 + return ret;
32117 + }
32118 +
32119 + for (j = 0; j < 9; j++) {
32120 + if (rxbuf32 & (1 << j)) {
32121 + u16_t rxbuf16;
32122 + len += sprintf(buf + len, "%d", j);
32123 + if (rxbuf32 & (1 << (j + 9))) {
32124 + buf[len++] = 'u';
32125 + } else {
32126 + buf[len++] = 't';
32127 + }
32128 + ret = bcm539x_read_16(bd, PAGE_VLAN,
32129 + REG_VLAN_PTAG0 + (j << 1),
32130 + &rxbuf16);
32131 + if (ret) {
32132 + return ret;
32133 + }
32134 + if (rxbuf16 == inst) {
32135 + buf[len++] = '*';
32136 + }
32137 + buf[len++] = '\t';
32138 + }
32139 + }
32140 +
32141 + len += sprintf(buf + len, "\n");
32142 + buf[len] = '\0';
32143 +
32144 + return len;
32145 +}
32146 +
32147 +/*
32148 + * bcm539x_handle_vlan_ports_write
32149 + */
32150 +static int bcm539x_handle_vlan_ports_write(struct switch_device *dev,
32151 + char *buf, int inst)
32152 +{
32153 + struct bcm539x_data *bd =
32154 + (struct bcm539x_data *)switch_get_drvdata(dev);
32155 + int j;
32156 + u32_t untag;
32157 + u32_t ports;
32158 + u32_t def;
32159 +
32160 + u8_t rxbuf8;
32161 + u16_t rxbuf16;
32162 + int ret;
32163 +
32164 + switch_parse_vlan_ports(dev, buf, &untag, &ports, &def);
32165 +
32166 +#ifdef BCM539X_DEBUG
32167 + printk(KERN_DEBUG "'%s' inst=%d untag=%08x ports=%08x def=%08x\n",
32168 + buf, inst, untag, ports, def);
32169 +#endif
32170 +
32171 + if (!ports) {
32172 + return 0;
32173 + }
32174 +
32175 + /*
32176 + * Change default vlan tag
32177 + */
32178 + for (j = 0; j < 9; j++) {
32179 + if ((untag | def) & (1 << j)) {
32180 + ret = bcm539x_write_16(bd, PAGE_VLAN,
32181 + REG_VLAN_PTAG0 + (j << 1),
32182 + inst);
32183 + if (ret) {
32184 + return ret;
32185 + }
32186 + continue;
32187 + }
32188 +
32189 + if (!(dev->port_mask[0] & (1 << j))) {
32190 + continue;
32191 + }
32192 +
32193 + /*
32194 + * Remove any ports which are not listed anymore as members of
32195 + * this vlan
32196 + */
32197 + ret = bcm539x_read_16(bd, PAGE_VLAN,
32198 + REG_VLAN_PTAG0 + (j << 1), &rxbuf16);
32199 + if (ret) {
32200 + return ret;
32201 + }
32202 + if (rxbuf16 == inst) {
32203 + ret = bcm539x_write_16(bd, PAGE_VLAN,
32204 + REG_VLAN_PTAG0 + (j << 1), 0);
32205 + if (ret) {
32206 + return ret;
32207 + }
32208 + }
32209 + }
32210 +
32211 + /*
32212 + * Write the VLAN table
32213 + */
32214 + ret = bcm539x_write_16(bd, PAGE_VTBL, REG_VTBL_INDX_5395, inst);
32215 + if (ret) {
32216 + return ret;
32217 + }
32218 +
32219 + ret = bcm539x_write_32(bd, PAGE_VTBL, REG_VTBL_ENTRY_5395,
32220 + (untag << 9) | ports);
32221 + if (ret) {
32222 + return ret;
32223 + }
32224 +
32225 + ret = bcm539x_write_8(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395,
32226 + (1 << 7) | 0);
32227 + if (ret) {
32228 + return ret;
32229 + }
32230 +
32231 + /*
32232 + * Wait for completion
32233 + */
32234 + for (j = 0; j < BCM539X_SPI_RETRIES; j++) {
32235 + ret = bcm539x_read_bytes(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395,
32236 + &rxbuf8, 1);
32237 + if (ret) {
32238 + return ret;
32239 + }
32240 + if (!(rxbuf8 & (1 << 7))) {
32241 + break;
32242 + }
32243 + }
32244 +
32245 + return (j < BCM539X_SPI_RETRIES) ? 0 : -EIO;
32246 +}
32247 +
32248 +/*
32249 + * Handlers for <this_driver>/vlan/<vlan_id>
32250 + */
32251 +static const struct switch_handler bcm539x_switch_handlers_vlan_dir[] = {
32252 + {
32253 + .name = "ports",
32254 + .read = bcm539x_handle_vlan_ports_read,
32255 + .write = bcm539x_handle_vlan_ports_write,
32256 + },
32257 + {
32258 + },
32259 +};
32260 +
32261 +/*
32262 + * bcm539x_handle_vlan_delete_write
32263 + */
32264 +static int bcm539x_handle_vlan_delete_write(struct switch_device *dev,
32265 + char *buf, int inst)
32266 +{
32267 + struct bcm539x_data *bd =
32268 + (struct bcm539x_data *)switch_get_drvdata(dev);
32269 + int vid;
32270 + u8_t rxbuf8;
32271 + u32_t txbuf;
32272 + int j;
32273 + int ret;
32274 +
32275 + vid = simple_strtoul(buf, NULL, 0);
32276 + if (!vid) {
32277 + return -EINVAL;
32278 + }
32279 +
32280 + /*
32281 + * Disable this VLAN
32282 + *
32283 + * Go through the port-based vlan registers and clear the appropriate
32284 + * ones out
32285 + */
32286 + for (j = 0; j < 9; j++) {
32287 + u16_t rxbuf16;
32288 + ret = bcm539x_read_16(bd, PAGE_VLAN, REG_VLAN_PTAG0 + (j << 1),
32289 + &rxbuf16);
32290 + if (ret) {
32291 + return ret;
32292 + }
32293 + if (rxbuf16 == vid) {
32294 + txbuf = 0;
32295 + ret = bcm539x_write_16(bd, PAGE_VLAN,
32296 + REG_VLAN_PTAG0 + (j << 1),
32297 + txbuf);
32298 + if (ret) {
32299 + return ret;
32300 + }
32301 + }
32302 + }
32303 +
32304 + /*
32305 + * Write the VLAN table
32306 + */
32307 + txbuf = vid;
32308 + ret = bcm539x_write_16(bd, PAGE_VTBL, REG_VTBL_INDX_5395, txbuf);
32309 + if (ret) {
32310 + return ret;
32311 + }
32312 +
32313 + txbuf = 0;
32314 + ret = bcm539x_write_32(bd, PAGE_VTBL, REG_VTBL_ENTRY_5395, txbuf);
32315 + if (ret) {
32316 + return ret;
32317 + }
32318 +
32319 + txbuf = (1 << 7) | (0);
32320 + ret = bcm539x_write_8(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395, txbuf);
32321 + if (ret) {
32322 + return ret;
32323 + }
32324 +
32325 + /*
32326 + * Wait for completion
32327 + */
32328 + for (j = 0; j < BCM539X_SPI_RETRIES; j++) {
32329 + ret = bcm539x_read_bytes(bd, PAGE_VTBL, REG_VTBL_ACCESS_5395,
32330 + &rxbuf8, 1);
32331 + if (ret) {
32332 + return ret;
32333 + }
32334 + if (!(rxbuf8 & (1 << 7))) {
32335 + break;
32336 + }
32337 + }
32338 +
32339 + if (j == BCM539X_SPI_RETRIES) {
32340 + return -EIO;
32341 + }
32342 +
32343 + return switch_remove_vlan_dir(dev, vid);
32344 +}
32345 +
32346 +/*
32347 + * bcm539x_handle_vlan_create_write
32348 + */
32349 +static int bcm539x_handle_vlan_create_write(struct switch_device *dev,
32350 + char *buf, int inst)
32351 +{
32352 + int vid;
32353 +
32354 + vid = simple_strtoul(buf, NULL, 0);
32355 + if (!vid) {
32356 + return -EINVAL;
32357 + }
32358 +
32359 + return switch_create_vlan_dir(dev, vid,
32360 + bcm539x_switch_handlers_vlan_dir);
32361 +}
32362 +
32363 +/*
32364 + * bcm539x_handle_enable_read
32365 + */
32366 +static int bcm539x_handle_enable_read(struct switch_device *dev,
32367 + char *buf, int inst)
32368 +{
32369 + struct bcm539x_data *bd =
32370 + (struct bcm539x_data *)switch_get_drvdata(dev);
32371 + u8_t rxbuf;
32372 + int ret;
32373 +
32374 + ret = bcm539x_read_8(bd, PAGE_PORT_TC, REG_CTRL_MODE, &rxbuf);
32375 + if (ret) {
32376 + return ret;
32377 + }
32378 + rxbuf = (rxbuf & (1 << 1)) ? 1 : 0;
32379 +
32380 + return sprintf(buf, "%d\n", rxbuf);
32381 +}
32382 +
32383 +/*
32384 + * bcm539x_handle_enable_write
32385 + */
32386 +static int bcm539x_handle_enable_write(struct switch_device *dev,
32387 + char *buf, int inst)
32388 +{
32389 + struct bcm539x_data *bd =
32390 + (struct bcm539x_data *)switch_get_drvdata(dev);
32391 +
32392 + return bcm539x_set_mode(bd, buf[0] == '1');
32393 +}
32394 +
32395 +/*
32396 + * bcm539x_handle_enable_vlan_read
32397 + */
32398 +static int bcm539x_handle_enable_vlan_read(struct switch_device *dev,
32399 + char *buf, int inst)
32400 +{
32401 + struct bcm539x_data *bd =
32402 + (struct bcm539x_data *)switch_get_drvdata(dev);
32403 + u8_t rxbuf;
32404 + int ret;
32405 +
32406 + ret = bcm539x_read_8(bd, PAGE_VLAN, REG_VLAN_CTRL0, &rxbuf);
32407 + if (ret) {
32408 + return ret;
32409 + }
32410 + rxbuf = (rxbuf & (1 << 7)) ? 1 : 0;
32411 +
32412 + return sprintf(buf, "%d\n", rxbuf);
32413 +}
32414 +
32415 +/*
32416 + * bcm539x_handle_enable_vlan_write
32417 + */
32418 +static int bcm539x_handle_enable_vlan_write(struct switch_device *dev,
32419 + char *buf, int inst)
32420 +{
32421 + struct bcm539x_data *bd =
32422 + (struct bcm539x_data *)switch_get_drvdata(dev);
32423 + int ret;
32424 +
32425 + /*
32426 + * disable 802.1Q VLANs
32427 + */
32428 + if (buf[0] != '1') {
32429 + ret = bcm539x_write_8(bd, PAGE_VLAN, REG_VLAN_CTRL0, 0);
32430 + return ret;
32431 + }
32432 +
32433 + /*
32434 + * enable 802.1Q VLANs
32435 + *
32436 + * Enable 802.1Q | IVL learning
32437 + */
32438 + ret = bcm539x_write_8(bd, PAGE_VLAN, REG_VLAN_CTRL0,
32439 + (1 << 7) | (3 << 5));
32440 + if (ret) {
32441 + return ret;
32442 + }
32443 +
32444 + /*
32445 + * RSV multicast fwd | RSV multicast chk
32446 + */
32447 + ret = bcm539x_write_8(bd, PAGE_VLAN, REG_VLAN_CTRL1,
32448 + (1 << 2) | (1 << 3));
32449 + if (ret) {
32450 + return ret;
32451 + }
32452 +#if 0
32453 + /*
32454 + * Drop invalid VID
32455 + */
32456 + ret = bcm539x_write_16(bd, PAGE_VLAN, REG_VLAN_CTRL3, 0x00FF);
32457 + if (ret) {
32458 + return ret;
32459 + }
32460 +#endif
32461 + return 0;
32462 +}
32463 +
32464 +/*
32465 + * bcm539x_handle_port_enable_read
32466 + */
32467 +static int bcm539x_handle_port_enable_read(struct switch_device *dev,
32468 + char *buf, int inst)
32469 +{
32470 + return sprintf(buf, "%d\n", 1);
32471 +}
32472 +
32473 +/*
32474 + * bcm539x_handle_port_enable_write
32475 + */
32476 +static int bcm539x_handle_port_enable_write(struct switch_device *dev,
32477 + char *buf, int inst)
32478 +{
32479 + /*
32480 + * validate port
32481 + */
32482 + if (!(dev->port_mask[0] & (1 << inst))) {
32483 + return -EIO;
32484 + }
32485 +
32486 + if (buf[0] != '1') {
32487 + printk(KERN_WARNING "switch port[%d] disabling is not supported\n", inst);
32488 + }
32489 + return 0;
32490 +}
32491 +
32492 +/*
32493 + * bcm539x_handle_port_state_read
32494 + */
32495 +static int bcm539x_handle_port_state_read(struct switch_device *dev,
32496 + char *buf, int inst)
32497 +{
32498 + struct bcm539x_data *bd =
32499 + (struct bcm539x_data *)switch_get_drvdata(dev);
32500 + int ret;
32501 + u16_t link;
32502 +
32503 + /*
32504 + * validate port
32505 + */
32506 + if (!(dev->port_mask[0] & (1 << inst))) {
32507 + return -EIO;
32508 + }
32509 +
32510 + /*
32511 + * check PHY link state - CPU port (port 8) is always up
32512 + */
32513 + ret = bcm539x_read_16(bd, PAGE_STATUS, REG_LINK_STATUS, &link);
32514 + if (ret) {
32515 + return ret;
32516 + }
32517 + link |= (1 << 8);
32518 +
32519 + return sprintf(buf, "%d\n", (link & (1 << inst)) ? 1 : 0);
32520 +}
32521 +
32522 +/*
32523 + * bcm539x_handle_port_media_read
32524 + */
32525 +static int bcm539x_handle_port_media_read(struct switch_device *dev,
32526 + char *buf, int inst)
32527 +{
32528 + struct bcm539x_data *bd =
32529 + (struct bcm539x_data *)switch_get_drvdata(dev);
32530 + int ret;
32531 + u16_t link, duplex;
32532 + u32_t speed;
32533 +
32534 + /*
32535 + * validate port
32536 + */
32537 + if (!(dev->port_mask[0] & (1 << inst))) {
32538 + return -EIO;
32539 + }
32540 +
32541 + /*
32542 + * check PHY link state first - CPU port (port 8) is always up
32543 + */
32544 + ret = bcm539x_read_16(bd, PAGE_STATUS, REG_LINK_STATUS, &link);
32545 + if (ret) {
32546 + return ret;
32547 + }
32548 + link |= (1 << 8);
32549 +
32550 + if (!(link & (1 << inst))) {
32551 + return sprintf(buf, "UNKNOWN\n");
32552 + }
32553 +
32554 + /*
32555 + * get link speeda dn duplex - CPU port (port 8) is 1000/full
32556 + */
32557 + ret = bcm539x_read_32(bd, PAGE_STATUS, 4, &speed);
32558 + if (ret) {
32559 + return ret;
32560 + }
32561 + speed |= (2 << 16);
32562 + speed = (speed >> (2 * inst)) & 3;
32563 +
32564 + ret = bcm539x_read_16(bd, PAGE_STATUS, 8, &duplex);
32565 + if (ret) {
32566 + return ret;
32567 + }
32568 + duplex |= (1 << 8);
32569 + duplex = (duplex >> inst) & 1;
32570 +
32571 + return sprintf(buf, "%d%cD\n",
32572 + (speed == 0) ? 10 : ((speed == 1) ? 100 : 1000),
32573 + duplex ? 'F' : 'H');
32574 +}
32575 +
32576 +/*
32577 + * bcm539x_handle_port_meida_write
32578 + */
32579 +static int bcm539x_handle_port_meida_write(struct switch_device *dev,
32580 + char *buf, int inst)
32581 +{
32582 + struct bcm539x_data *bd =
32583 + (struct bcm539x_data *)switch_get_drvdata(dev);
32584 + int ret;
32585 + u16_t ctrl_word, local_cap, local_giga_cap;
32586 +
32587 + /*
32588 + * validate port (not for CPU port)
32589 + */
32590 + if (!(dev->port_mask[0] & (1 << inst) & ~(1 << 8))) {
32591 + return -EIO;
32592 + }
32593 +
32594 + /*
32595 + * Get the maximum capability from status
32596 + * SPI reg[0x00] = PHY[0x0] --- MII control
32597 + * SPI reg[0x08] = PHY[0x4] --- MII local capability
32598 + * SPI reg[0x12] = PHY[0x9] --- GMII control
32599 + */
32600 + ret = bcm539x_read_16(bd, REG_MII_PAGE + inst, (MII_ADVERTISE << 1), &local_cap);
32601 + if (ret) {
32602 + return ret;
32603 + }
32604 + ret = bcm539x_read_16(bd, REG_MII_PAGE + inst, (MII_CTRL1000 << 1), &local_giga_cap);
32605 + if (ret) {
32606 + return ret;
32607 + }
32608 +
32609 + /* Configure to the requested speed */
32610 + if (strncmp(buf, "1000FD", 6) == 0) {
32611 + /* speed */
32612 + local_cap &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL);
32613 + local_cap &= ~(ADVERTISE_100HALF | ADVERTISE_100FULL);
32614 + local_giga_cap |= (ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32615 + /* duplex */
32616 + } else if (strncmp(buf, "100FD", 5) == 0) {
32617 + /* speed */
32618 + local_cap &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL);
32619 + local_cap |= (ADVERTISE_100HALF | ADVERTISE_100FULL);
32620 + local_giga_cap &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32621 + /* duplex */
32622 + local_cap &= ~(ADVERTISE_100HALF);
32623 + } else if (strncmp(buf, "100HD", 5) == 0) {
32624 + /* speed */
32625 + local_cap &= ~(ADVERTISE_10HALF | ADVERTISE_10FULL);
32626 + local_cap |= (ADVERTISE_100HALF | ADVERTISE_100FULL);
32627 + local_giga_cap &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32628 + /* duplex */
32629 + local_cap &= ~(ADVERTISE_100FULL);
32630 + } else if (strncmp(buf, "10FD", 4) == 0) {
32631 + /* speed */
32632 + local_cap |= (ADVERTISE_10HALF | ADVERTISE_10FULL);
32633 + local_cap &= ~(ADVERTISE_100HALF | ADVERTISE_100FULL);
32634 + local_giga_cap &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32635 + /* duplex */
32636 + local_cap &= ~(ADVERTISE_10HALF);
32637 + } else if (strncmp(buf, "10HD", 4) == 0) {
32638 + /* speed */
32639 + local_cap |= (ADVERTISE_10HALF | ADVERTISE_10FULL);
32640 + local_cap &= ~(ADVERTISE_100HALF | ADVERTISE_100FULL);
32641 + local_giga_cap &= ~(ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32642 + /* duplex */
32643 + local_cap &= ~(ADVERTISE_10FULL);
32644 + } else if (strncmp(buf, "AUTO", 4) == 0) {
32645 + /* speed */
32646 + local_cap |= (ADVERTISE_10HALF | ADVERTISE_10FULL);
32647 + local_cap |= (ADVERTISE_100HALF | ADVERTISE_100FULL);
32648 + local_giga_cap |= (ADVERTISE_1000HALF | ADVERTISE_1000FULL);
32649 + } else {
32650 + return -EINVAL;
32651 + }
32652 +
32653 + /* Active PHY with the requested speed for auto-negotiation */
32654 + ret = bcm539x_write_16(bd, REG_MII_PAGE + inst, (MII_ADVERTISE << 1), local_cap);
32655 + if (ret) {
32656 + return ret;
32657 + }
32658 + ret = bcm539x_write_16(bd, REG_MII_PAGE + inst, (MII_CTRL1000 << 1), local_giga_cap);
32659 + if (ret) {
32660 + return ret;
32661 + }
32662 +
32663 + ret = bcm539x_read_16(bd, REG_MII_PAGE + inst, (MII_BMCR << 1), &ctrl_word);
32664 + if (ret) {
32665 + return ret;
32666 + }
32667 + ctrl_word |= (BMCR_ANENABLE | BMCR_ANRESTART);
32668 + ret = bcm539x_write_16(bd, REG_MII_PAGE + inst, (MII_BMCR << 1), ctrl_word);
32669 + if (ret) {
32670 + return ret;
32671 + }
32672 +
32673 + return 0;
32674 +}
32675 +
32676 +/*
32677 + * proc_fs entries for this switch
32678 + */
32679 +static const struct switch_handler bcm539x_switch_handlers[] = {
32680 + {
32681 + .name = "enable",
32682 + .read = bcm539x_handle_enable_read,
32683 + .write = bcm539x_handle_enable_write,
32684 + },
32685 + {
32686 + .name = "enable_vlan",
32687 + .read = bcm539x_handle_enable_vlan_read,
32688 + .write = bcm539x_handle_enable_vlan_write,
32689 + },
32690 + {
32691 + .name = "reset",
32692 + .write = bcm539x_handle_reset,
32693 + },
32694 + {
32695 + },
32696 +};
32697 +
32698 +/*
32699 + * Handlers for <this_driver>/vlan
32700 + */
32701 +static const struct switch_handler bcm539x_switch_handlers_vlan[] = {
32702 + {
32703 + .name = "delete",
32704 + .write = bcm539x_handle_vlan_delete_write,
32705 + },
32706 + {
32707 + .name = "create",
32708 + .write = bcm539x_handle_vlan_create_write,
32709 + },
32710 + {
32711 + },
32712 +};
32713 +
32714 +/*
32715 + * Handlers for <this_driver>/port/<port number>
32716 + */
32717 +static const struct switch_handler bcm539x_switch_handlers_port[] = {
32718 + {
32719 + .name = "enable",
32720 + .read = bcm539x_handle_port_enable_read,
32721 + .write = bcm539x_handle_port_enable_write,
32722 + },
32723 + {
32724 + .name = "state",
32725 + .read = bcm539x_handle_port_state_read,
32726 + },
32727 + {
32728 + .name = "media",
32729 + .read = bcm539x_handle_port_media_read,
32730 + .write = bcm539x_handle_port_meida_write,
32731 + },
32732 + {
32733 + },
32734 +};
32735 +
32736 +/*
32737 + * bcm539x_probe
32738 + */
32739 +static int __devinit bcm539x_probe(struct spi_device *spi)
32740 +{
32741 + struct bcm539x_data *bd;
32742 + struct switch_core_platform_data *pdata;
32743 + struct switch_device *switch_dev = NULL;
32744 + int i, ret;
32745 + u8_t txbuf[2];
32746 +
32747 + pdata = spi->dev.platform_data;
32748 + if (!pdata) {
32749 + return -EINVAL;
32750 + }
32751 +
32752 + ret = spi_setup(spi);
32753 + if (ret < 0) {
32754 + return ret;
32755 + }
32756 +
32757 + /*
32758 + * Reset the chip if requested
32759 + */
32760 + if (pdata->flags & SWITCH_DEV_FLAG_HW_RESET) {
32761 + ret = gpio_request(pdata->pin_reset, "switch-bcm539x-reset");
32762 + if (ret) {
32763 + printk(KERN_WARNING "Could not request reset\n");
32764 + return -EINVAL;
32765 + }
32766 +
32767 + gpio_direction_output(pdata->pin_reset, 0);
32768 + udelay(10);
32769 + gpio_set_value(pdata->pin_reset, 1);
32770 + udelay(20);
32771 + }
32772 +
32773 + /*
32774 + * Allocate our private data structure
32775 + */
32776 + bd = kzalloc(sizeof(struct bcm539x_data), GFP_KERNEL);
32777 + if (!bd) {
32778 + return -ENOMEM;
32779 + }
32780 +
32781 + dev_set_drvdata(&spi->dev, bd);
32782 + bd->pdata = pdata;
32783 + bd->spi = spi;
32784 + bd->last_page = 0xFF;
32785 +
32786 + /*
32787 + * First perform SW reset if needed
32788 + */
32789 + if (pdata->flags & SWITCH_DEV_FLAG_SW_RESET) {
32790 + txbuf[0] = (1 << 7) | (1 << 4);
32791 + ret = bcm539x_write_bytes(bd, PAGE_PORT_TC,
32792 + REG_CTRL_SRST, txbuf, 1);
32793 + if (ret) {
32794 + goto fail;
32795 + }
32796 +
32797 + udelay(20);
32798 +
32799 + txbuf[0] = 0;
32800 + ret = bcm539x_write_bytes(bd, PAGE_PORT_TC,
32801 + REG_CTRL_SRST, txbuf, 1);
32802 + if (ret) {
32803 + goto fail;
32804 + }
32805 + }
32806 +
32807 + /*
32808 + * See if we can see the chip
32809 + */
32810 + for (i = 0; i < 10; i++) {
32811 + ret = bcm539x_read_bytes(bd, PAGE_MMR, REG_DEVICE_ID,
32812 + &bd->device_id, 1);
32813 + if (!ret) {
32814 + break;
32815 + }
32816 + }
32817 + if (ret) {
32818 + goto fail;
32819 + }
32820 +
32821 + /*
32822 + * We only support 5395, 5397, 5398
32823 + */
32824 + if ((bd->device_id != 0x95) && (bd->device_id != 0x97) &&
32825 + (bd->device_id != 0x98)) {
32826 + ret = -ENODEV;
32827 + goto fail;
32828 + }
32829 +
32830 + /*
32831 + * Override CPU port config: fixed link @1000 with flow control
32832 + */
32833 + ret = bcm539x_read_8(bd, PAGE_PORT_TC, REG_CTRL_MIIPO, txbuf);
32834 + bcm539x_write_8(bd, PAGE_PORT_TC, REG_CTRL_MIIPO, 0xbb); // Override IMP port config
32835 + printk("Broadcom SW CPU port setting: 0x%x -> 0xbb\n", txbuf[0]);
32836 +
32837 + /*
32838 + * Setup the switch driver structure
32839 + */
32840 + switch_dev = switch_alloc();
32841 + if (!switch_dev) {
32842 + ret = -ENOMEM;
32843 + goto fail;
32844 + }
32845 + switch_dev->name = pdata->name;
32846 +
32847 + switch_dev->ports = (bd->device_id == 0x98) ? 9 : 6;
32848 + switch_dev->port_mask[0] = (bd->device_id == 0x98) ? 0x1FF : 0x11F;
32849 + switch_dev->driver_handlers = bcm539x_switch_handlers;
32850 + switch_dev->reg_handlers = NULL;
32851 + switch_dev->vlan_handlers = bcm539x_switch_handlers_vlan;
32852 + switch_dev->port_handlers = bcm539x_switch_handlers_port;
32853 +
32854 + bd->switch_dev = switch_dev;
32855 + switch_set_drvdata(switch_dev, (void *)bd);
32856 +
32857 + ret = switch_register(bd->switch_dev);
32858 + if (ret < 0) {
32859 + goto fail;
32860 + }
32861 +
32862 + printk(KERN_INFO "bcm53%02x switch chip initialized\n", bd->device_id);
32863 +
32864 + return ret;
32865 +
32866 +fail:
32867 + if (switch_dev) {
32868 + switch_release(switch_dev);
32869 + }
32870 + dev_set_drvdata(&spi->dev, NULL);
32871 + kfree(bd);
32872 + return ret;
32873 +}
32874 +
32875 +static int __attribute__((unused)) bcm539x_remove(struct spi_device *spi)
32876 +{
32877 + struct bcm539x_data *bd;
32878 +
32879 + bd = dev_get_drvdata(&spi->dev);
32880 +
32881 + if (bd->pdata->flags & SWITCH_DEV_FLAG_HW_RESET) {
32882 + gpio_free(bd->pdata->pin_reset);
32883 + }
32884 +
32885 + if (bd->switch_dev) {
32886 + switch_unregister(bd->switch_dev);
32887 + switch_release(bd->switch_dev);
32888 + }
32889 +
32890 + dev_set_drvdata(&spi->dev, NULL);
32891 +
32892 + kfree(bd);
32893 +
32894 + return 0;
32895 +}
32896 +
32897 +static struct spi_driver bcm539x_driver = {
32898 + .driver = {
32899 + .name = DRIVER_NAME,
32900 + .owner = THIS_MODULE,
32901 + },
32902 + .probe = bcm539x_probe,
32903 + .remove = __devexit_p(bcm539x_remove),
32904 +};
32905 +
32906 +static int __init bcm539x_init(void)
32907 +{
32908 + return spi_register_driver(&bcm539x_driver);
32909 +}
32910 +
32911 +module_init(bcm539x_init);
32912 +
32913 +static void __exit bcm539x_exit(void)
32914 +{
32915 + spi_unregister_driver(&bcm539x_driver);
32916 +}
32917 +module_exit(bcm539x_exit);
32918 +
32919 +MODULE_AUTHOR("Pat Tjin");
32920 +MODULE_LICENSE("GPL v2");
32921 +MODULE_DESCRIPTION("bcm539x SPI switch chip driver");
32922 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/switch-bcm539x-reg.h linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-bcm539x-reg.h
32923 --- linux-2.6.30.10/arch/ubicom32/mach-common/switch-bcm539x-reg.h 1970-01-01 02:00:00.000000000 +0200
32924 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-bcm539x-reg.h 2009-12-11 11:45:11.000000000 +0200
32925 @@ -0,0 +1,221 @@
32926 +/*
32927 + * arch/ubicom32/mach-common/switch-bcm539x-reg.h
32928 + * Broadcom switch definitions for Ubicom32 architecture.
32929 + *
32930 + * (C) Copyright 2009, Ubicom, Inc.
32931 + *
32932 + * This file is part of the Ubicom32 Linux Kernel Port.
32933 + *
32934 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
32935 + * it and/or modify it under the terms of the GNU General Public License
32936 + * as published by the Free Software Foundation, either version 2 of the
32937 + * License, or (at your option) any later version.
32938 + *
32939 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
32940 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
32941 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
32942 + * the GNU General Public License for more details.
32943 + *
32944 + * You should have received a copy of the GNU General Public License
32945 + * along with the Ubicom32 Linux Kernel Port. If not,
32946 + * see <http://www.gnu.org/licenses/>.
32947 + *
32948 + * Ubicom32 implementation derived from (with many thanks):
32949 + * arch/m68knommu
32950 + * arch/blackfin
32951 + * arch/parisc
32952 + */
32953 +
32954 +/*
32955 + * Broadcom 53xx RoboSwitch device driver.
32956 + *
32957 + * Copyright 2007, Broadcom Corporation
32958 + * All Rights Reserved.
32959 + *
32960 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
32961 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
32962 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
32963 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
32964 + *
32965 + * $Id$
32966 + */
32967 +
32968 +#ifndef _SWITCH_BCM539X_REG_H_
32969 +#define _SWITCH_BCM539X_REG_H_
32970 +
32971 +#define BCM539X_CMD_READ 0x60
32972 +#define BCM539X_CMD_WRITE 0x61
32973 +
32974 +#define BCM539X_GLOBAL_SPI_DATA0 0xf0
32975 +
32976 +#define BCM539X_GLOBAL_SPI_STATUS 0xfe
32977 +#define BCM539X_GLOBAL_SPI_ST_SPIF (1<<7)
32978 +#define BCM539X_GLOBAL_SPI_ST_RACK (1<<5)
32979 +
32980 +#define BCM539X_GLOBAL_PAGE 0xff
32981 +
32982 +#define PAGE_PORT_TC 0x00 // Port Traffic Control Register
32983 +
32984 +#define PAGE_QOS_CTL 0x30 // QoS Global Control Register
32985 +#define PAGE_QOS_TAG 0x34 // Default IEEE 802.1Q TAG Register
32986 +
32987 +#define PAGE_MII_CTL_PORT0 0x10 // Internal PHY MII Register
32988 +#define PAGE_MII_CTL_PORT1 0x11
32989 +#define PAGE_MII_CTL_PORT2 0x12
32990 +#define PAGE_MII_CTL_PORT3 0x13
32991 +#define PAGE_MII_CTL_PORT4 0x14
32992 +
32993 +#define PAGE_STATUS 0x01 // Status Register Page
32994 +#define PAGE_RATE_CONTROL 0x41 // Broadcast Storm Suppression Register
32995 +
32996 +#define REG_GRATE_CONTROL 0x00
32997 +
32998 +#define REG_LED_POWER 0x12
32999 +
33000 +// Ingress Rate Control
33001 +#define REG_IRATE_CONTROLP0 0x10
33002 +#define REG_IRATE_CONTROLP1 0x14
33003 +#define REG_IRATE_CONTROLP2 0x18
33004 +#define REG_IRATE_CONTROLP3 0x1C
33005 +#define REG_IRATE_CONTROLP4 0x20
33006 +#define REG_IRATE_CONTROLP7 0x2C
33007 +#define REG_IRATE_CONTROLPI 0x30
33008 +
33009 +// Egress Rate Control
33010 +#define REG_ERATE_CONTROLP0 0x80
33011 +#define REG_ERATE_CONTROLP1 0x82
33012 +#define REG_ERATE_CONTROLP2 0x84
33013 +#define REG_ERATE_CONTROLP3 0x86
33014 +#define REG_ERATE_CONTROLP4 0x88
33015 +#define REG_ERATE_CONTROLP5 0x8A
33016 +#define REG_ERATE_CONTROLP6 0x8C
33017 +#define REG_ERATE_CONTROLP7 0x8E
33018 +#define REG_ERATE_CONTROLPI 0x90
33019 +
33020 +#define REG_LINK_STATUS 0x00
33021 +
33022 +#define REG_TC_PORT0 0x00
33023 +#define REG_TC_PORT1 0x01
33024 +#define REG_TC_PORT2 0x02
33025 +#define REG_TC_PORT3 0x03
33026 +#define REG_TC_PORT4 0x04
33027 +#define REG_TC_PORT5 0x05
33028 +
33029 +#define REG_SPEED_CTL 0x00
33030 +#define REG_SPEED_ADV100 0x08
33031 +#define REG_SPEED_ADV1000 0x12
33032 +
33033 +#define REG_QOS_EN 0x00
33034 +#define REG_QOS_TAG_PORT1 0x12 // Default IEEE 802.1Q TAG, PORT 1
33035 +#define REG_QOS_TAG_PORT2 0x14 // Default IEEE 802.1Q TAG, PORT 2
33036 +#define REG_QOS_TAG_PORT3 0x16 // Default IEEE 802.1Q TAG, PORT 3
33037 +#define REG_QOS_TAG_PORT4 0x18 // Default IEEE 802.1Q TAG, PORT 4
33038 +#define REG_QOS_PID_PORT1 0x52 // Ingress Port Priority ID MAP, PORT 1
33039 +#define REG_QOS_PID_PORT2 0x54 // Ingress Port Priority ID MAP, PORT 2
33040 +#define REG_QOS_PID_PORT3 0x56 // Ingress Port Priority ID MAP, PORT 3
33041 +#define REG_QOS_PID_PORT4 0x58 // Ingress Port Priority ID MAP, PORT 4
33042 +#define REG_QOS_TXQ_CTL 0x80 // Tx Queue Control Register
33043 +#define REG_QOS_TXQ_WHTQ0 0x81 // Tx Queue Weight Register Queue 0
33044 +#define REG_QOS_TXQ_WHTQ1 0x82 // Tx Queue Weight Register Queue 1
33045 +#define REG_QOS_TXQ_WHTQ2 0x83 // Tx Queue Weight Register Queue 2
33046 +#define REG_QOS_TXQ_WHTQ3 0x84 // Tx Queue Weight Register Queue 3
33047 +
33048 +#define REG_CTRL_PPSEL 0x24 /* 5397: Protected port select register */
33049 +
33050 +#define RATE_CONTROL_ENABLED (1 << 22)
33051 +#define RATE_CONTROL_BSIZE ((1 << 10) | (1 << 9) | (1 << 8))
33052 +
33053 +#define RATE_CONTROL_HIGH ((1 << 7) | (1 << 6) | (1 << 5) | (1 << 4))
33054 +#define RATE_CONTROL_HIGH_N ~((1 << 3) | (1 << 2) | (1 << 1) | (1 << 0))
33055 +
33056 +#define RATE_CONTROL_MEDIUM ((1 << 6) | (1 << 5) | (1 << 4) | (1 << 3) | (1 << 2) | (1 << 1) | (1 << 0))
33057 +#define RATE_CONTROL_MEDIUM_N ~((1 << 7))
33058 +
33059 +#define RATE_CONTROL_NORMAL ((1 << 5) | (1 << 2) | (1 << 0))
33060 +#define RATE_CONTROL_NORMAL_N ~((1 << 7) | (1 << 6) | (1 << 4) | (1 << 3) | (1 << 1))
33061 +
33062 +#define RATE_CONTROL_LOW ((1 << 4) | (1 << 3) | (1 << 0))
33063 +#define RATE_CONTROL_LOW_N ~((1 << 7) | (1 << 6) | (1 << 5) | (1 << 2) | (1 << 1))
33064 +
33065 +// --- Gemtek, Configure the switch to support Ethernet Port QoS
33066 +
33067 +/* MII access registers */
33068 +#define PSEUDO_PHYAD 0x1E /* MII Pseudo PHY address */
33069 +#define REG_MII_PAGE 0x10 /* MII Page register */
33070 +#define REG_MII_ADDR 0x11 /* MII Address register */
33071 +#define REG_MII_DATA0 0x18 /* MII Data register 0 */
33072 +#define REG_MII_DATA1 0x19 /* MII Data register 1 */
33073 +#define REG_MII_DATA2 0x1a /* MII Data register 2 */
33074 +#define REG_MII_DATA3 0x1b /* MII Data register 3 */
33075 +
33076 +/* Page numbers */
33077 +#define PAGE_CTRL 0x00 /* Control page */
33078 +#define PAGE_MMR 0x02 /* 5397 Management/Mirroring page */
33079 +#define PAGE_VTBL 0x05 /* ARL/VLAN Table access page */
33080 +#define PAGE_VLAN 0x34 /* VLAN page */
33081 +
33082 +/* Control page registers */
33083 +#define REG_CTRL_PORT0 0x00 /* Port 0 traffic control register */
33084 +#define REG_CTRL_PORT1 0x01 /* Port 1 traffic control register */
33085 +#define REG_CTRL_PORT2 0x02 /* Port 2 traffic control register */
33086 +#define REG_CTRL_PORT3 0x03 /* Port 3 traffic control register */
33087 +#define REG_CTRL_PORT4 0x04 /* Port 4 traffic control register */
33088 +#define REG_CTRL_PORT5 0x05 /* Port 5 traffic control register */
33089 +#define REG_CTRL_PORT6 0x06 /* Port 6 traffic control register */
33090 +#define REG_CTRL_PORT7 0x07 /* Port 7 traffic control register */
33091 +#define REG_CTRL_MODE 0x0B /* Switch Mode register */
33092 +#define REG_CTRL_MIIPO 0x0E /* 5325: MII Port Override register */
33093 +#define REG_CTRL_SRST 0x79 /* Software reset control register */
33094 +
33095 +#define REG_DEVICE_ID 0x30 /* 539x Device id: */
33096 +#define DEVID5395 0x95 /* 5395 */
33097 +#define DEVID5397 0x97 /* 5397 */
33098 +#define DEVID5398 0x98 /* 5398 */
33099 +#define REG_REVISION_ID 0x40 /* 539x Revision id: */
33100 +
33101 +/* VLAN page registers */
33102 +#define REG_VLAN_CTRL0 0x00 /* VLAN Control 0 register */
33103 +#define REG_VLAN_CTRL1 0x01 /* VLAN Control 1 register */
33104 +#define REG_VLAN_CTRL2 0x02 /* VLAN Control 2 register */
33105 +#define REG_VLAN_CTRL3 0x03 /* VLAN Control 3 register */
33106 +#define REG_VLAN_CTRL4 0x04 /* VLAN Control 4 register */
33107 +#define REG_VLAN_CTRL5 0x05 /* VLAN Control 5 register */
33108 +#define REG_VLAN_ACCESS 0x06 /* VLAN Table Access register */
33109 +#define REG_VLAN_WRITE 0x08 /* VLAN Write register */
33110 +#define REG_VLAN_READ 0x0C /* VLAN Read register */
33111 +#define REG_VLAN_PTAG0 0x10 /* VLAN Default Port Tag register - port 0 */
33112 +#define REG_VLAN_PTAG1 0x12 /* VLAN Default Port Tag register - port 1 */
33113 +#define REG_VLAN_PTAG2 0x14 /* VLAN Default Port Tag register - port 2 */
33114 +#define REG_VLAN_PTAG3 0x16 /* VLAN Default Port Tag register - port 3 */
33115 +#define REG_VLAN_PTAG4 0x18 /* VLAN Default Port Tag register - port 4 */
33116 +#define REG_VLAN_PTAG5 0x1a /* VLAN Default Port Tag register - port 5 */
33117 +#define REG_VLAN_PTAG6 0x1c /* VLAN Default Port Tag register - port 6 */
33118 +#define REG_VLAN_PTAG7 0x1e /* VLAN Default Port Tag register - port 7 */
33119 +#define REG_VLAN_PTAG8 0x20 /* 539x: VLAN Default Port Tag register - IMP port */
33120 +#define REG_VLAN_PMAP 0x20 /* 5325: VLAN Priority Re-map register */
33121 +
33122 +/* ARL/VLAN Table Access page registers */
33123 +#define REG_VTBL_CTRL 0x00 /* ARL Read/Write Control */
33124 +#define REG_VTBL_MINDX 0x02 /* MAC Address Index */
33125 +#define REG_VTBL_VINDX 0x08 /* VID Table Index */
33126 +#define REG_VTBL_ARL_E0 0x10 /* ARL Entry 0 */
33127 +#define REG_VTBL_ARL_E1 0x18 /* ARL Entry 1 */
33128 +#define REG_VTBL_DAT_E0 0x18 /* ARL Table Data Entry 0 */
33129 +#define REG_VTBL_SCTRL 0x20 /* ARL Search Control */
33130 +#define REG_VTBL_SADDR 0x22 /* ARL Search Address */
33131 +#define REG_VTBL_SRES 0x24 /* ARL Search Result */
33132 +#define REG_VTBL_SREXT 0x2c /* ARL Search Result */
33133 +#define REG_VTBL_VID_E0 0x30 /* VID Entry 0 */
33134 +#define REG_VTBL_VID_E1 0x32 /* VID Entry 1 */
33135 +#define REG_VTBL_PREG 0xFF /* Page Register */
33136 +#define REG_VTBL_ACCESS 0x60 /* VLAN table access register */
33137 +#define REG_VTBL_INDX 0x61 /* VLAN table address index register */
33138 +#define REG_VTBL_ENTRY 0x63 /* VLAN table entry register */
33139 +#define REG_VTBL_ACCESS_5395 0x80 /* VLAN table access register */
33140 +#define REG_VTBL_INDX_5395 0x81 /* VLAN table address index register */
33141 +#define REG_VTBL_ENTRY_5395 0x83 /* VLAN table entry register */
33142 +
33143 +/* SPI registers */
33144 +#define REG_SPI_PAGE 0xff /* SPI Page register */
33145 +
33146 +#endif
33147 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/switch-core.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-core.c
33148 --- linux-2.6.30.10/arch/ubicom32/mach-common/switch-core.c 1970-01-01 02:00:00.000000000 +0200
33149 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-core.c 2009-12-11 11:45:11.000000000 +0200
33150 @@ -0,0 +1,737 @@
33151 +/*
33152 + * arch/ubicom32/mach-common/switch-core.c
33153 + * Ubicom32 architecture switch and /proc/switch/... implementation.
33154 + *
33155 + * (C) Copyright 2009, Ubicom, Inc.
33156 + * Copyright (C) 2005 Felix Fietkau <openwrt@nbd.name>
33157 + *
33158 + * This file is part of the Ubicom32 Linux Kernel Port.
33159 + *
33160 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
33161 + * it and/or modify it under the terms of the GNU General Public License
33162 + * as published by the Free Software Foundation, either version 2 of the
33163 + * License, or (at your option) any later version.
33164 + *
33165 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
33166 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
33167 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
33168 + * the GNU General Public License for more details.
33169 + *
33170 + * You should have received a copy of the GNU General Public License
33171 + * along with the Ubicom32 Linux Kernel Port. If not,
33172 + * see <http://www.gnu.org/licenses/>.
33173 + *
33174 + * Ubicom32 implementation derived from (with many thanks):
33175 + * arch/m68knommu
33176 + * arch/blackfin
33177 + * arch/parisc
33178 + *
33179 + * Basic doc of driver's /proc interface:
33180 + * /proc/switch/<interface>/
33181 + * registers: read-only
33182 + * counters: read-only
33183 + * reset: write causes hardware reset
33184 + * enable: "0", "1"
33185 + * enable_vlan: "0", "1"
33186 + * port/<port-number>/
33187 + * enabled: "0", "1"
33188 + * link state: read-only
33189 + * media: "AUTO", "1000FD", "100FD", "100HD", "10FD", "10HD"
33190 + * vlan/<port-number>/
33191 + * ports: same syntax as for nvram's vlan*ports (eg. "1 2 3 4 5*")
33192 + */
33193 +
33194 +#include <linux/module.h>
33195 +#include <linux/init.h>
33196 +#include <linux/uaccess.h>
33197 +#include <linux/ctype.h>
33198 +#include <linux/proc_fs.h>
33199 +#include <linux/list.h>
33200 +#include <linux/rwsem.h>
33201 +#include <linux/device.h>
33202 +
33203 +#include "switch-core.h"
33204 +
33205 +/*
33206 + * Pointer to the root of our filesystem
33207 + */
33208 +static struct proc_dir_entry *switch_root;
33209 +
33210 +/*
33211 + * Lock used to manage access to the switch list
33212 + */
33213 +DECLARE_RWSEM(switch_list_lock);
33214 +EXPORT_SYMBOL_GPL(switch_list_lock);
33215 +
33216 +/*
33217 + * List of switches we are managing
33218 + */
33219 +LIST_HEAD(switch_list);
33220 +EXPORT_SYMBOL_GPL(switch_list);
33221 +
33222 +/*
33223 + * List of handlers we have
33224 + */
33225 +LIST_HEAD(switch_handler_list);
33226 +EXPORT_SYMBOL_GPL(switch_handler_list);
33227 +
33228 +/*
33229 + * Keep track of all the handlers we added
33230 + */
33231 +struct switch_handler_entry {
33232 + struct list_head node;
33233 + struct proc_dir_entry *parent;
33234 + struct switch_device *dev;
33235 + const struct switch_handler *handler;
33236 + int inst;
33237 +};
33238 +
33239 +/*
33240 + * Keep track of all VLAN dirs we created
33241 + */
33242 +struct switch_vlan_entry {
33243 + struct list_head node;
33244 + struct proc_dir_entry *pde;
33245 + int vlan_id;
33246 + const struct switch_handler *handlers;
33247 +};
33248 +
33249 +/*
33250 + * switch_parse_vlan_ports
33251 + * Parse the vlan properties written to <driver>/vlan/<vlan_id>/ports
33252 + */
33253 +void switch_parse_vlan_ports(struct switch_device *switch_dev,
33254 + char *buf, u32_t *untag,
33255 + u32_t *ports, u32_t *def)
33256 +{
33257 + u32_t tag = 0;
33258 + *untag = 0;
33259 + *ports = 0;
33260 + *def = 0;
33261 +
33262 +
33263 + /*
33264 + * Skip any leading spaces
33265 + */
33266 + while (isspace(*buf)) {
33267 + buf++;
33268 + }
33269 +
33270 + /*
33271 + * Parse out the string
33272 + */
33273 + while (*buf) {
33274 + u32_t port = simple_strtoul(buf, &buf, 10);
33275 + u32_t mask = (1 << port);
33276 +
33277 + /*
33278 + * Parse out any flags
33279 + */
33280 + while (*buf && !isspace(*buf)) {
33281 + switch (*buf++) {
33282 + case 't':
33283 + tag |= mask;
33284 + break;
33285 + case '*':
33286 + *def |= mask;
33287 + break;
33288 + }
33289 + }
33290 + *ports |= mask;
33291 +
33292 + /*
33293 + * Skip any spaces
33294 + */
33295 + while (isspace(*buf)) {
33296 + buf++;
33297 + }
33298 + }
33299 +
33300 + *untag = ~tag & *ports;
33301 +}
33302 +
33303 +/*
33304 + * switch_proc_read
33305 + * Handle reads from the procfs, dispatches the driver specific handler
33306 + */
33307 +static ssize_t switch_proc_read(struct file *file, char *buf, size_t count,
33308 + loff_t *ppos)
33309 +{
33310 + struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
33311 + char *page;
33312 + int len = 0;
33313 +
33314 + page = kmalloc(SWITCH_MAX_BUFSZ, GFP_KERNEL);
33315 + if (!page) {
33316 + return -ENOBUFS;
33317 + }
33318 +
33319 + if (pde->data != NULL) {
33320 + struct switch_handler_entry *she =
33321 + (struct switch_handler_entry *)pde->data;
33322 + if (she->handler->read) {
33323 + len += she->handler->read(she->dev, page + len,
33324 + she->inst);
33325 + }
33326 + }
33327 + len += 1;
33328 +
33329 + if (*ppos < len) {
33330 + len = min_t(int, len - *ppos, count);
33331 + if (copy_to_user(buf, (page + *ppos), len)) {
33332 + kfree(page);
33333 + return -EFAULT;
33334 + }
33335 + *ppos += len;
33336 + } else {
33337 + len = 0;
33338 + }
33339 +
33340 + kfree(page);
33341 +
33342 + return len;
33343 +}
33344 +
33345 +/*
33346 + * switch_proc_write
33347 + * Handle writes from the procfs, dispatches the driver specific handler
33348 + */
33349 +static ssize_t switch_proc_write(struct file *file, const char *buf,
33350 + size_t count, loff_t *data)
33351 +{
33352 + struct proc_dir_entry *pde = PDE(file->f_dentry->d_inode);
33353 + char *page;
33354 + int ret = -EINVAL;
33355 +
33356 + page = kmalloc(count + 1, GFP_KERNEL);
33357 + if (page == NULL)
33358 + return -ENOBUFS;
33359 +
33360 + if (copy_from_user(page, buf, count)) {
33361 + kfree(page);
33362 + return -EINVAL;
33363 + }
33364 + page[count] = 0;
33365 +
33366 + if (pde->data != NULL) {
33367 + struct switch_handler_entry *she =
33368 + (struct switch_handler_entry *)pde->data;
33369 + if (she->handler->write) {
33370 + ret = she->handler->write(she->dev, page, she->inst);
33371 + if (ret >= 0) {
33372 + ret = count;
33373 + }
33374 + }
33375 + }
33376 +
33377 + kfree(page);
33378 + return ret;
33379 +}
33380 +
33381 +/*
33382 + * File operations for the proc_fs, we must cast here since proc_fs' definitions
33383 + * differ from file_operations definitions.
33384 + */
33385 +static struct file_operations switch_proc_fops = {
33386 + .read = (ssize_t (*) (struct file *, char __user *,
33387 + size_t, loff_t *))switch_proc_read,
33388 + .write = (ssize_t (*) (struct file *, const char __user *,
33389 + size_t, loff_t *))switch_proc_write,
33390 +};
33391 +
33392 +/*
33393 + * switch_add_handler
33394 + */
33395 +static int switch_add_handler(struct switch_device *switch_dev,
33396 + struct proc_dir_entry *parent,
33397 + const struct switch_handler *handler,
33398 + int inst)
33399 +{
33400 + struct switch_handler_entry *she;
33401 + struct proc_dir_entry *pde;
33402 + int mode;
33403 +
33404 + she = (struct switch_handler_entry *)
33405 + kzalloc(sizeof(struct switch_handler_entry), GFP_KERNEL);
33406 + if (!she) {
33407 + return -ENOMEM;
33408 + }
33409 +
33410 + INIT_LIST_HEAD(&she->node);
33411 + she->parent = parent;
33412 + she->dev = switch_dev;
33413 + she->inst = inst;
33414 + she->handler = handler;
33415 + list_add(&she->node, &switch_dev->handlers);
33416 +
33417 + mode = 0;
33418 + if (handler->read != NULL) {
33419 + mode |= S_IRUSR;
33420 + }
33421 + if (handler->write != NULL) {
33422 + mode |= S_IWUSR;
33423 + }
33424 +
33425 + pde = create_proc_entry(handler->name, mode, parent);
33426 + if (!pde) {
33427 + kfree(she);
33428 + printk("Failed to create node '%s' in parent %p\n",
33429 + handler->name, parent);
33430 + return -ENOMEM;
33431 + }
33432 + pde->data = (void *)she;
33433 + pde->proc_fops = &switch_proc_fops;
33434 +
33435 + return 0;
33436 +}
33437 +
33438 +/*
33439 + * switch_add_handlers
33440 + */
33441 +static int switch_add_handlers(struct switch_device *switch_dev,
33442 + struct proc_dir_entry *parent,
33443 + const struct switch_handler *handlers,
33444 + int inst)
33445 +{
33446 + while (handlers->name) {
33447 + int ret = switch_add_handler(switch_dev,
33448 + parent, handlers, inst);
33449 + if (ret) {
33450 + return ret;
33451 + }
33452 + handlers++;
33453 + }
33454 +
33455 + return 0;
33456 +}
33457 +
33458 +/*
33459 + * switch_remove_vlan_dirs
33460 + * Removes all vlan directories
33461 + *
33462 + * Assumes all vlan directories are empty, should be called after
33463 + * switch_remove_handlers
33464 + */
33465 +static void switch_remove_vlan_dirs(struct switch_device *switch_dev)
33466 +{
33467 + struct list_head *pos;
33468 + struct list_head *tmp;
33469 + struct switch_vlan_entry *sve;
33470 +
33471 + list_for_each_safe(pos, tmp, &switch_dev->vlan_dirs) {
33472 + sve = list_entry(pos, struct switch_vlan_entry, node);
33473 + list_del(pos);
33474 + remove_proc_entry(sve->pde->name, switch_dev->vlan_dir);
33475 + kfree(sve);
33476 + }
33477 +}
33478 +
33479 +/*
33480 + * switch_remove_handlers
33481 + * Removes all handlers registered to the given switch_device
33482 + */
33483 +static void switch_remove_handlers(struct switch_device *switch_dev)
33484 +{
33485 + struct list_head *pos;
33486 + struct list_head *tmp;
33487 + struct switch_handler_entry *she;
33488 +
33489 + list_for_each_safe(pos, tmp, &switch_dev->handlers) {
33490 + she = list_entry(pos, struct switch_handler_entry, node);
33491 + list_del(pos);
33492 + remove_proc_entry(she->handler->name, she->parent);
33493 + kfree(she);
33494 + }
33495 +}
33496 +
33497 +/*
33498 + * switch_unregister_proc_nodes
33499 + * Unregisters all proc nodes related to switch_dev
33500 + */
33501 +void switch_unregister_proc_nodes(struct switch_device *switch_dev)
33502 +{
33503 + switch_remove_handlers(switch_dev);
33504 +
33505 + if (switch_dev->port_dirs) {
33506 + int i;
33507 +
33508 + for (i = 0; i < switch_dev->ports; i++) {
33509 + if (switch_dev->port_dirs[i]) {
33510 + remove_proc_entry(
33511 + switch_dev->port_dirs[i]->name,
33512 + switch_dev->port_dir);
33513 + }
33514 + }
33515 + }
33516 +
33517 + if (switch_dev->port_dir) {
33518 + remove_proc_entry("port", switch_dev->driver_dir);
33519 + switch_dev->port_dir = NULL;
33520 + }
33521 +
33522 + if (switch_dev->reg_dir) {
33523 + remove_proc_entry("reg", switch_dev->reg_dir);
33524 + switch_dev->reg_dir = NULL;
33525 + }
33526 +
33527 + if (switch_dev->vlan_dir) {
33528 + switch_remove_vlan_dirs(switch_dev);
33529 + remove_proc_entry("vlan", switch_dev->driver_dir);
33530 + switch_dev->vlan_dir = NULL;
33531 + }
33532 +
33533 + if (switch_dev->driver_dir) {
33534 + remove_proc_entry(switch_dev->name, switch_root);
33535 + switch_dev->driver_dir = NULL;
33536 + }
33537 +}
33538 +
33539 +/*
33540 + * switch_remove_vlan_dir
33541 + * Removes vlan dir in switch/<switch_driver>/vlan/<vlan_id>
33542 + */
33543 +int switch_remove_vlan_dir(struct switch_device *switch_dev, int vlan_id)
33544 +{
33545 + struct list_head *pos;
33546 + struct switch_vlan_entry *sve = NULL;
33547 +
33548 + list_for_each(pos, &switch_dev->vlan_dirs) {
33549 + struct switch_vlan_entry *tmp =
33550 + list_entry(pos, struct switch_vlan_entry, node);
33551 + if (tmp->vlan_id == vlan_id) {
33552 + sve = tmp;
33553 + break;
33554 + }
33555 + }
33556 +
33557 + if (!sve) {
33558 + return -ENOENT;
33559 + }
33560 +
33561 + /*
33562 + * Remove it from the list
33563 + */
33564 + list_del(pos);
33565 +
33566 + /*
33567 + * Remove the handlers
33568 + */
33569 + while (sve->handlers->name) {
33570 + remove_proc_entry(sve->handlers->name, sve->pde);
33571 + sve->handlers++;
33572 + }
33573 +
33574 + /*
33575 + * Remove the proc entry for the <vlan_id> dir
33576 + */
33577 + remove_proc_entry(sve->pde->name, switch_dev->vlan_dir);
33578 +
33579 + kfree(sve);
33580 +
33581 + return 0;
33582 +}
33583 +
33584 +/*
33585 + * switch_create_vlan_dir
33586 + * Creates vlan dir in switch/<switch_driver>/vlan/<vlan_id>
33587 + */
33588 +int switch_create_vlan_dir(struct switch_device *switch_dev,
33589 + int vlan_id, const struct switch_handler *handlers)
33590 +{
33591 + char s[14];
33592 + struct proc_dir_entry *pde = NULL;
33593 + struct switch_vlan_entry *sve = NULL;
33594 + int ret;
33595 + struct list_head *pos;
33596 +
33597 + /*
33598 + * Check to see if it exists already
33599 + */
33600 + list_for_each(pos, &switch_dev->vlan_dirs) {
33601 + sve = list_entry(pos, struct switch_vlan_entry, node);
33602 + if (sve->vlan_id == vlan_id) {
33603 + return -EEXIST;
33604 + }
33605 + }
33606 + sve = NULL;
33607 +
33608 + /*
33609 + * Create the vlan directory if we didn't have it before
33610 + */
33611 + if (!switch_dev->vlan_dir) {
33612 + switch_dev->vlan_dir = proc_mkdir("vlan",
33613 + switch_dev->driver_dir);
33614 + if (!switch_dev->vlan_dir) {
33615 + goto fail;
33616 + }
33617 + if (switch_dev->vlan_handlers) {
33618 + ret = switch_add_handlers(switch_dev,
33619 + switch_dev->vlan_dir,
33620 + switch_dev->vlan_handlers, 0);
33621 + if (ret) {
33622 + goto fail;
33623 + }
33624 + }
33625 + }
33626 +
33627 + /*
33628 + * Create the vlan_id directory
33629 + */
33630 + snprintf(s, 14, "%d", vlan_id);
33631 + pde = proc_mkdir(s, switch_dev->vlan_dir);
33632 + if (!pde) {
33633 + goto fail;
33634 + }
33635 +
33636 + /*
33637 + * Create the handlers for this vlan
33638 + */
33639 + if (handlers) {
33640 + ret = switch_add_handlers(switch_dev, pde, handlers, vlan_id);
33641 + if (ret) {
33642 + goto fail;
33643 + }
33644 + }
33645 +
33646 + /*
33647 + * Keep track of all the switch vlan entries created
33648 + */
33649 + sve = (struct switch_vlan_entry *)
33650 + kzalloc(sizeof(struct switch_vlan_entry), GFP_KERNEL);
33651 + if (!sve) {
33652 + goto fail;
33653 + }
33654 + INIT_LIST_HEAD(&sve->node);
33655 + sve->handlers = handlers;
33656 + sve->vlan_id = vlan_id;
33657 + sve->pde = pde;
33658 + list_add(&sve->node, &switch_dev->vlan_dirs);
33659 +
33660 + return 0;
33661 +
33662 +fail:
33663 + if (sve) {
33664 + kfree(sve);
33665 + }
33666 +
33667 + if (pde) {
33668 + /*
33669 + * Remove any proc entries we might have created
33670 + */
33671 + while (handlers->name) {
33672 + remove_proc_entry(handlers->name, pde);
33673 + handlers++;
33674 + }
33675 +
33676 + remove_proc_entry(s, switch_dev->driver_dir);
33677 + }
33678 +
33679 + return -ENOMEM;
33680 +}
33681 +
33682 +/*
33683 + * switch_register_proc_nodes
33684 + */
33685 +int switch_register_proc_nodes(struct switch_device *switch_dev)
33686 +{
33687 + int i;
33688 + int n;
33689 +
33690 + switch_dev->port_dirs = kzalloc(switch_dev->ports *
33691 + sizeof(struct proc_dir_entry *),
33692 + GFP_KERNEL);
33693 + if (!switch_dev->port_dirs) {
33694 + return -ENOMEM;
33695 + }
33696 +
33697 + /*
33698 + * Create a new proc entry for this switch
33699 + */
33700 + switch_dev->driver_dir = proc_mkdir(switch_dev->name, switch_root);
33701 + if (!switch_dev->driver_dir) {
33702 + goto fail;
33703 + }
33704 + if (switch_dev->driver_handlers) {
33705 + switch_add_handlers(switch_dev,
33706 + switch_dev->driver_dir,
33707 + switch_dev->driver_handlers,
33708 + 0);
33709 + }
33710 +
33711 + /*
33712 + * Create the ports
33713 + */
33714 + switch_dev->port_dir = proc_mkdir("port", switch_dev->driver_dir);
33715 + if (!switch_dev->port_dir) {
33716 + goto fail;
33717 + }
33718 + for (n = 0, i = 0; i < (SWITCH_PORT_MASK_SIZE * 32); i++) {
33719 + if (switch_dev->port_mask[i / 32] & (1 << i % 32)) {
33720 + char s[14];
33721 +
33722 + snprintf(s, 14, "%d", i);
33723 + switch_dev->port_dirs[n] =
33724 + proc_mkdir(s, switch_dev->port_dir);
33725 + if (!switch_dev->port_dirs[n]) {
33726 + goto fail;
33727 + }
33728 + if (switch_dev->port_handlers) {
33729 + switch_add_handlers(switch_dev,
33730 + switch_dev->port_dirs[n],
33731 + switch_dev->port_handlers,
33732 + i);
33733 + }
33734 + n++;
33735 + }
33736 + }
33737 +
33738 + /*
33739 + * Create the register directory for switch register access.
33740 + */
33741 + if (switch_dev->reg_handlers) {
33742 + switch_dev->reg_dir = proc_mkdir("reg", switch_dev->driver_dir);
33743 + if (!switch_dev->reg_dir) {
33744 + goto fail;
33745 + }
33746 +
33747 + switch_add_handlers(switch_dev,
33748 + switch_dev->reg_dir,
33749 + switch_dev->reg_handlers,
33750 + 0);
33751 + }
33752 +
33753 + /*
33754 + * Create the vlan directory
33755 + */
33756 + if (switch_dev->vlan_handlers) {
33757 + switch_dev->vlan_dir = proc_mkdir("vlan",
33758 + switch_dev->driver_dir);
33759 + if (!switch_dev->vlan_dir) {
33760 + goto fail;
33761 + }
33762 + if (switch_dev->vlan_handlers) {
33763 + switch_add_handlers(switch_dev,
33764 + switch_dev->vlan_dir,
33765 + switch_dev->vlan_handlers,
33766 + 0);
33767 + }
33768 + }
33769 +
33770 + return 0;
33771 +
33772 +fail:
33773 + switch_unregister_proc_nodes(switch_dev);
33774 + return -ENOMEM;
33775 +}
33776 +
33777 +/*
33778 + * switch_release
33779 + */
33780 +void switch_release(struct switch_device *switch_dev)
33781 +{
33782 + kfree(switch_dev);
33783 +}
33784 +
33785 +/*
33786 + * switch_alloc
33787 + */
33788 +struct switch_device *switch_alloc(void)
33789 +{
33790 + struct switch_device *switch_dev =
33791 + kzalloc(sizeof(struct switch_device),
33792 + GFP_KERNEL);
33793 + INIT_LIST_HEAD(&switch_dev->node);
33794 + INIT_LIST_HEAD(&switch_dev->vlan_dirs);
33795 + INIT_LIST_HEAD(&switch_dev->handlers);
33796 + return switch_dev;
33797 +}
33798 +
33799 +/*
33800 + * switch_register
33801 + */
33802 +int switch_register(struct switch_device *switch_dev)
33803 +{
33804 + int ret;
33805 + int i;
33806 +
33807 + /*
33808 + * Make sure that the number of ports and the port mask make sense
33809 + */
33810 + for (ret = 0, i = 0; i < (SWITCH_PORT_MASK_SIZE * 32); i++) {
33811 + if (switch_dev->port_mask[i / 32] & (1 << i % 32)) {
33812 + ret++;
33813 + }
33814 + }
33815 + if (ret > switch_dev->ports) {
33816 + return -EINVAL;
33817 + }
33818 +
33819 + /*
33820 + * Create the /proc entries
33821 + */
33822 + ret = switch_register_proc_nodes(switch_dev);
33823 + if (ret) {
33824 + return ret;
33825 + }
33826 +
33827 + /*
33828 + * Add it to the list of switches
33829 + */
33830 + down_write(&switch_list_lock);
33831 + list_add_tail(&switch_dev->node, &switch_list);
33832 + up_write(&switch_list_lock);
33833 +
33834 + printk(KERN_INFO "Registered switch device: %s\n", switch_dev->name);
33835 +
33836 + return 0;
33837 +}
33838 +EXPORT_SYMBOL_GPL(switch_register);
33839 +
33840 +/*
33841 + * switch_unregister
33842 + * Unregisters a previously registered switch_device object
33843 + */
33844 +void switch_unregister(struct switch_device *switch_dev)
33845 +{
33846 + /*
33847 + * remove the proc entries
33848 + */
33849 + switch_unregister_proc_nodes(switch_dev);
33850 +
33851 + /*
33852 + * Remove it from the list of switches
33853 + */
33854 + down_write(&switch_list_lock);
33855 + list_del(&switch_dev->node);
33856 + up_write(&switch_list_lock);
33857 +
33858 + printk(KERN_INFO "Unregistered switch device: %s\n", switch_dev->name);
33859 +}
33860 +EXPORT_SYMBOL_GPL(switch_unregister);
33861 +
33862 +/*
33863 + * switch_init
33864 + */
33865 +static int __init switch_init(void)
33866 +{
33867 + switch_root = proc_mkdir("switch", NULL);
33868 + if (!switch_root) {
33869 + printk(KERN_WARNING "Failed to make root switch node\n");
33870 + return -ENODEV;
33871 + }
33872 + return 0;
33873 +}
33874 +module_init(switch_init);
33875 +
33876 +/*
33877 + * switch_exit
33878 + */
33879 +static void __exit switch_exit(void)
33880 +{
33881 + remove_proc_entry("switch", NULL);
33882 +}
33883 +module_exit(switch_exit);
33884 +
33885 +MODULE_AUTHOR("Patrick Tjin");
33886 +MODULE_LICENSE("GPL");
33887 +MODULE_DESCRIPTION("Ethernet Switch Class Interface");
33888 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/switch-core.h linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-core.h
33889 --- linux-2.6.30.10/arch/ubicom32/mach-common/switch-core.h 1970-01-01 02:00:00.000000000 +0200
33890 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/switch-core.h 2009-12-11 11:45:11.000000000 +0200
33891 @@ -0,0 +1,92 @@
33892 +/*
33893 + * arch/ubicom32/mach-common/switch-core.h
33894 + * Private data for the switch module
33895 + *
33896 + * (C) Copyright 2009, Ubicom, Inc.
33897 + *
33898 + * This file is part of the Ubicom32 Linux Kernel Port.
33899 + *
33900 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
33901 + * it and/or modify it under the terms of the GNU General Public License
33902 + * as published by the Free Software Foundation, either version 2 of the
33903 + * License, or (at your option) any later version.
33904 + *
33905 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
33906 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
33907 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
33908 + * the GNU General Public License for more details.
33909 + *
33910 + * You should have received a copy of the GNU General Public License
33911 + * along with the Ubicom32 Linux Kernel Port. If not,
33912 + * see <http://www.gnu.org/licenses/>.
33913 + *
33914 + * Ubicom32 implementation derived from (with many thanks):
33915 + * arch/m68knommu
33916 + * arch/blackfin
33917 + * arch/parisc
33918 + */
33919 +#ifndef _SWITCH_CORE_H_
33920 +#define _SWITCH_CORE_H_
33921 +
33922 +struct switch_handler_entry;
33923 +struct switch_vlan_entry;
33924 +
33925 +#define SWITCH_PORT_MASK_SIZE 2
33926 +
33927 +struct switch_device {
33928 + struct list_head node;
33929 +
33930 + const char *name;
33931 + void *drvdata;
33932 +
33933 + u8_t ports;
33934 +
33935 + struct proc_dir_entry *driver_dir;
33936 + const struct switch_handler *driver_handlers;
33937 +
33938 + struct proc_dir_entry *port_dir;
33939 + struct proc_dir_entry **port_dirs;
33940 + const struct switch_handler *port_handlers;
33941 +
33942 + struct proc_dir_entry *reg_dir;
33943 + const struct switch_handler *reg_handlers;
33944 +
33945 + struct proc_dir_entry *vlan_dir;
33946 + const struct switch_handler *vlan_handlers;
33947 + struct list_head vlan_dirs;
33948 +
33949 + struct list_head handlers;
33950 +
33951 + u32_t port_mask[SWITCH_PORT_MASK_SIZE];
33952 +};
33953 +
33954 +typedef int (*switch_handler_fn)(struct switch_device *, char *buf, int nr);
33955 +struct switch_handler {
33956 + const char *name;
33957 +
33958 + switch_handler_fn read;
33959 + switch_handler_fn write;
33960 +};
33961 +
33962 +#define SWITCH_MAX_BUFSZ 4096
33963 +
33964 +static inline void switch_set_drvdata(struct switch_device *switch_dev, void *drvdata)
33965 +{
33966 + switch_dev->drvdata = drvdata;
33967 +}
33968 +
33969 +static inline void *switch_get_drvdata(struct switch_device *switch_dev)
33970 +{
33971 + return switch_dev->drvdata;
33972 +}
33973 +
33974 +extern int switch_create_vlan_dir(struct switch_device *switch_dev, int vlan_id, const struct switch_handler *handlers);
33975 +extern int switch_remove_vlan_dir(struct switch_device *switch_dev, int vlan_id);
33976 +extern void switch_parse_vlan_ports(struct switch_device *switch_dev, char *buf, u32_t *untag, u32_t *ports, u32_t *def);
33977 +
33978 +extern void switch_release(struct switch_device *switch_dev);
33979 +extern struct switch_device *switch_alloc(void);
33980 +extern int switch_register(struct switch_device *switch_dev);
33981 +extern void switch_unregister(struct switch_device *switch_dev);
33982 +
33983 +#endif
33984 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/ubi32-gpio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubi32-gpio.c
33985 --- linux-2.6.30.10/arch/ubicom32/mach-common/ubi32-gpio.c 1970-01-01 02:00:00.000000000 +0200
33986 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubi32-gpio.c 2009-12-11 11:45:11.000000000 +0200
33987 @@ -0,0 +1,411 @@
33988 +/*
33989 + * arch/ubicom32/mach-common/ubi32-gpio.c
33990 + * Ubicom gpio driver
33991 + *
33992 + * (C) Copyright 2009, Ubicom, Inc.
33993 + *
33994 + * This file is part of the Ubicom32 Linux Kernel Port.
33995 + *
33996 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
33997 + * it and/or modify it under the terms of the GNU General Public License
33998 + * as published by the Free Software Foundation, either version 2 of the
33999 + * License, or (at your option) any later version.
34000 + *
34001 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
34002 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
34003 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
34004 + * the GNU General Public License for more details.
34005 + *
34006 + * You should have received a copy of the GNU General Public License
34007 + * along with the Ubicom32 Linux Kernel Port. If not,
34008 + * see <http://www.gnu.org/licenses/>.
34009 + *
34010 + * Ubicom32 implementation derived from (with many thanks):
34011 + * arch/m68knommu
34012 + * arch/blackfin
34013 + * arch/parisc
34014 + */
34015 +
34016 +#include <linux/module.h>
34017 +#include <linux/init.h>
34018 +#include <linux/errno.h>
34019 +#include <linux/kernel.h>
34020 +#include <linux/io.h>
34021 +#include <linux/gpio.h>
34022 +#include <linux/irq.h>
34023 +#include <linux/version.h>
34024 +
34025 +#if defined(CONFIG_PROC_FS)
34026 +#include <linux/proc_fs.h>
34027 +#endif
34028 +
34029 +#include <linux/io.h>
34030 +#include <asm/ip5000.h>
34031 +#include <linux/gpio.h>
34032 +
34033 +#define UBI_GPIO_CHECK_RANGE 0 /* !0 enables range checking */
34034 +
34035 +
34036 +/*
34037 + * Each I/O port can be configured to operate in one of several
34038 + * functional modes. One of these modes is GPIO, which causes the
34039 + * entire port to function as a GPIO port. Since the various port
34040 + * registers serve the system with other important functions, such as
34041 + * ethernet, serial, USB, etc., it isn't advantageous to set any of
34042 + * the ports to be entirely dedicated for GPIO use. The processor
34043 + * alternatively allows individual bits of a port to be assigned to be
34044 + * used as GPIO independently from the overall port function. This
34045 + * bit-by-bit assignment is selected by setting the corresponding bit
34046 + * in the port's gpio_mask register. When set, the selected bit is
34047 + * then enabled as a GPIO. If the corresponding bit is set in the
34048 + * gpio_ctl register of the port, the bit is configured as a GPIO
34049 + * output. Otherwise, it is an input.
34050 + *
34051 + * NOTE: This driver uses the bit-by-bit GPIO function assignment
34052 + * exclusively and *never* sets the port function registers to the
34053 + * GPIO function.
34054 + *
34055 + * GPIO is not the main function of any of the I/O ports. The port
34056 + * bit widths are variable from one port to the next, determined by
34057 + * the more common I/O functions of the ports. For simplicity, this
34058 + * driver assumes all the ports are 32 bits wide regardless of the
34059 + * real bit width of the port. GPIO bits are numbered from zero to
34060 + * MAX_UBICOM_GPIOS. Within a port, the least significant bit is
34061 + * numbered bit zero, the most significant is bit 31. Since the ports
34062 + * are considered logically contiguous, GPIO #32 is the zeroth bit in
34063 + * port #1, and so on. Due to the hardware definition, there are
34064 + * large gaps in the GPIO numbers representing real pins.
34065 + *
34066 + * NOTE: It is up to the programmer to refer to the processor data
34067 + * sheet to determine which bits in which ports can be accessed and
34068 + * used for GPIO.
34069 + *
34070 + */
34071 +
34072 +
34073 +/* There are 9 ports, A through I. Not all 32 bits in each
34074 + * port can be a GPIO, but we pretend they are. Its up to the
34075 + * programmer to refer to the processor data sheet.
34076 + */
34077 +#define MAX_UBICOM_GPIOS (9 * 32) /* ARCH_NR_GPIOS */
34078 +#define NUM_GPIO_PORTS (gpio_bank(MAX_UBICOM_GPIOS))
34079 +
34080 +
34081 +/* GPIO reservation bit map array */
34082 +static int reserved_gpio_map[NUM_GPIO_PORTS];
34083 +
34084 +
34085 +/* Array of hardware io_port addresses */
34086 +static struct ubicom32_io_port *gpio_bank_addr[NUM_GPIO_PORTS] =
34087 +{
34088 + UBICOM32_IO_PORT(RA),
34089 + UBICOM32_IO_PORT(RB),
34090 + UBICOM32_IO_PORT(RC),
34091 + UBICOM32_IO_PORT(RD),
34092 + UBICOM32_IO_PORT(RE),
34093 + UBICOM32_IO_PORT(RF),
34094 + UBICOM32_IO_PORT(RG),
34095 + UBICOM32_IO_PORT(RH),
34096 + UBICOM32_IO_PORT(RI)
34097 +};
34098 +
34099 +
34100 +struct ubi_gpio_chip {
34101 + /*
34102 + * Right now, nothing else lives here.
34103 + */
34104 + struct gpio_chip gpio_chip;
34105 +};
34106 +
34107 +
34108 +#if UBI_GPIO_CHECK_RANGE
34109 +inline int check_gpio(unsigned gpio)
34110 +{
34111 + if (gpio >= MAX_UBICOM_GPIOS)
34112 + return -EINVAL;
34113 + return 0;
34114 +}
34115 +#else
34116 +#define check_gpio(n) (0)
34117 +#endif
34118 +
34119 +/*
34120 + * ubi_gpio_get_port
34121 + * Get the IO port associated with a certain gpio
34122 + */
34123 +struct ubicom32_io_port *ubi_gpio_get_port(unsigned gpio)
34124 +{
34125 + if (gpio_bank(gpio) > NUM_GPIO_PORTS) {
34126 + return NULL;
34127 + }
34128 + return gpio_bank_addr[gpio_bank(gpio)];
34129 +}
34130 +
34131 +/*
34132 + * ubi_gpio_error()
34133 + */
34134 +static void ubi_gpio_error(unsigned gpio)
34135 +{
34136 + printk(KERN_ERR "ubicom-gpio: GPIO %d wasn't requested!\n", gpio);
34137 +}
34138 +
34139 +/*
34140 + * ubi_port_setup()
34141 + */
34142 +static void ubi_port_setup(unsigned gpio, unsigned short usage)
34143 +{
34144 + if (!check_gpio(gpio)) {
34145 + if (usage) {
34146 + UBICOM32_GPIO_ENABLE(gpio);
34147 + } else {
34148 + UBICOM32_GPIO_DISABLE(gpio);
34149 + }
34150 + }
34151 +}
34152 +
34153 +/*
34154 + * ubi_gpio_request()
34155 + */
34156 +static int ubi_gpio_request(struct gpio_chip *chip, unsigned gpio)
34157 +{
34158 + unsigned long flags;
34159 +
34160 + if (check_gpio(gpio) < 0)
34161 + return -EINVAL;
34162 +
34163 + local_irq_save(flags);
34164 +
34165 + if (unlikely(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
34166 + printk(KERN_ERR "ubi-gpio: GPIO %d is already reserved!\n",
34167 + gpio);
34168 + local_irq_restore(flags);
34169 + return -EBUSY;
34170 + }
34171 +
34172 + reserved_gpio_map[gpio_bank(gpio)] |= gpio_bit(gpio);
34173 +
34174 + ubi_port_setup(gpio, 1);
34175 +
34176 + local_irq_restore(flags);
34177 +
34178 + return 0;
34179 +}
34180 +
34181 +/*
34182 + * ubi_gpio_free()
34183 + */
34184 +static void ubi_gpio_free(struct gpio_chip *chip, unsigned gpio)
34185 +{
34186 + unsigned long flags;
34187 +
34188 + if (check_gpio(gpio) < 0)
34189 + return;
34190 +
34191 + local_irq_save(flags);
34192 +
34193 + if (unlikely(!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio)))) {
34194 + ubi_gpio_error(gpio);
34195 + local_irq_restore(flags);
34196 + return;
34197 + }
34198 +
34199 + /* Assert the pin is no longer claimed */
34200 + reserved_gpio_map[gpio_bank(gpio)] &= ~gpio_bit(gpio);
34201 +
34202 + /* Revert port bit to use specified by port->function */
34203 + ubi_port_setup(gpio, 0);
34204 +
34205 + local_irq_restore(flags);
34206 +}
34207 +
34208 +/*
34209 + * ubi_gpio_direction_input()
34210 + */
34211 +static int ubi_gpio_direction_input(struct gpio_chip *chip, unsigned gpio)
34212 +{
34213 + unsigned long flags;
34214 +
34215 + if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
34216 + ubi_gpio_error(gpio);
34217 + return -EINVAL;
34218 + }
34219 +
34220 + local_irq_save(flags);
34221 +
34222 + /* Configure pin as gpio */
34223 + ubi_port_setup(gpio, 1);
34224 +
34225 + /* Assert pin is an input */
34226 + UBICOM32_GPIO_SET_PIN_INPUT(gpio);
34227 +
34228 + local_irq_restore(flags);
34229 +
34230 + return 0;
34231 +}
34232 +
34233 +
34234 +/*
34235 + * ubi_gpio_direction_output()
34236 + */
34237 +static int ubi_gpio_direction_output(struct gpio_chip *chip,
34238 + unsigned gpio, int value)
34239 +{
34240 + unsigned long flags;
34241 +
34242 + if (!(reserved_gpio_map[gpio_bank(gpio)] & gpio_bit(gpio))) {
34243 + ubi_gpio_error(gpio);
34244 + return -EINVAL;
34245 + }
34246 +
34247 + local_irq_save(flags);
34248 +
34249 + /* Configure pin as gpio and set initial value in gpio_out register
34250 + * so that when we enable it as an output, it will have the correct
34251 + * initial value.
34252 + */
34253 + ubi_port_setup(gpio, 1);
34254 + if (value) {
34255 + UBICOM32_GPIO_SET_PIN_HIGH(gpio);
34256 + } else {
34257 + UBICOM32_GPIO_SET_PIN_LOW(gpio);
34258 + }
34259 +
34260 + /* Enable the pin as an output */
34261 + UBICOM32_GPIO_SET_PIN_OUTPUT(gpio);
34262 +
34263 + local_irq_restore(flags);
34264 +
34265 + return 0;
34266 +}
34267 +
34268 +
34269 +/*
34270 + * ubi_gpio_get_value()
34271 + */
34272 +static int ubi_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
34273 +{
34274 + return 0 != (gpio_bank_addr[gpio_bank(gpio)]->gpio_in & gpio_bit(gpio));
34275 +}
34276 +
34277 +
34278 +/*
34279 + * ubi_gpio_set_value()
34280 + */
34281 +static void ubi_gpio_set_value(struct gpio_chip *chip, unsigned gpio,
34282 + int arg)
34283 +{
34284 + unsigned long flags;
34285 + local_irq_save(flags);
34286 +
34287 + if (arg) {
34288 + UBICOM32_GPIO_SET_PIN_HIGH(gpio);
34289 + } else {
34290 + UBICOM32_GPIO_SET_PIN_LOW(gpio);
34291 + }
34292 +
34293 + local_irq_restore(flags);
34294 +}
34295 +
34296 +
34297 +/*
34298 + * ubi_gpio_to_irq()
34299 + */
34300 +static int ubi_gpio_to_irq(struct gpio_chip *chip, unsigned gpio)
34301 +{
34302 + return gpio_to_irq(gpio);
34303 +}
34304 +
34305 +
34306 +/*
34307 + * ubi_gpio_init()
34308 + */
34309 +int __init ubi_gpio_init(void)
34310 +{
34311 + int k;
34312 + int status;
34313 + struct ubi_gpio_chip *chip;
34314 + struct gpio_chip *gc;
34315 +
34316 + printk(KERN_INFO "Ubicom GPIO Controller\n");
34317 +
34318 + chip = kzalloc(sizeof(struct ubi_gpio_chip), GFP_KERNEL);
34319 + if (chip == NULL)
34320 + return -ENOMEM;
34321 +
34322 + gc = &chip->gpio_chip;
34323 + gc->request = ubi_gpio_request;
34324 + gc->free = ubi_gpio_free;
34325 + gc->to_irq = ubi_gpio_to_irq;
34326 + gc->direction_input = ubi_gpio_direction_input;
34327 + gc->direction_output = ubi_gpio_direction_output;
34328 + gc->get = ubi_gpio_get_value;
34329 + gc->set = ubi_gpio_set_value;
34330 + gc->can_sleep = 0;
34331 + gc->base = 0;
34332 + gc->ngpio = MAX_UBICOM_GPIOS; /* ARCH_NR_GPIOS - 1 */
34333 + gc->label = "ubi_gpio";
34334 +
34335 + status = gpiochip_add(gc);
34336 + if (status != 0) {
34337 + kfree(chip);
34338 + return status;
34339 + }
34340 +
34341 + /* Assert all pins are free */
34342 + for (k = 0; k < NUM_GPIO_PORTS; k++) {
34343 + reserved_gpio_map[k] = 0;
34344 + }
34345 +
34346 + return 0;
34347 +}
34348 +
34349 +#if defined(CONFIG_PROC_FS)
34350 +/*
34351 + * ubi_get_gpio_dir()
34352 + */
34353 +static int ubi_get_gpio_dir(unsigned gpio)
34354 +{
34355 + if (gpio_bank_addr[gpio_bank(gpio)]->gpio_ctl & gpio_bit(gpio))
34356 + return 1;
34357 + else
34358 + return 0;
34359 +}
34360 +
34361 +/*
34362 + * gpio_proc_read()
34363 + */
34364 +static int ubi_gpio_proc_read(char *buf, char **start, off_t offset,
34365 + int len, int *unused_i, void *unused_v)
34366 +{
34367 + int c, outlen = 0;
34368 +
34369 + for (c = 0; c < MAX_UBICOM_GPIOS; c++) {
34370 + if (!check_gpio(c) &&
34371 + (reserved_gpio_map[gpio_bank(c)] & gpio_bit(c))) {
34372 + len = sprintf(buf, "GPIO_%d:\t\tGPIO %s\n", c,
34373 + ubi_get_gpio_dir(c) ? "OUTPUT" : "INPUT");
34374 + } else {
34375 + continue;
34376 + }
34377 +
34378 + buf += len;
34379 + outlen += len;
34380 + }
34381 + return outlen;
34382 +}
34383 +
34384 +/*
34385 + * ubi_gpio_register_proc()
34386 + */
34387 +static __init int ubi_gpio_register_proc(void)
34388 +{
34389 + struct proc_dir_entry *proc_gpio;
34390 +
34391 + proc_gpio = create_proc_entry("gpio", S_IRUGO, NULL);
34392 + if (proc_gpio)
34393 + proc_gpio->read_proc = ubi_gpio_proc_read;
34394 +
34395 + return proc_gpio != NULL;
34396 +}
34397 +device_initcall(ubi_gpio_register_proc);
34398 +#endif
34399 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32hid.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32hid.c
34400 --- linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32hid.c 1970-01-01 02:00:00.000000000 +0200
34401 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32hid.c 2009-12-11 11:45:11.000000000 +0200
34402 @@ -0,0 +1,557 @@
34403 +/*
34404 + * arch/ubicom32/mach-common/ubicom32hid.c
34405 + * I2C driver for HID coprocessor found on some DPF implementations.
34406 + *
34407 + * (C) Copyright 2009, Ubicom, Inc.
34408 + *
34409 + * This file is part of the Ubicom32 Linux Kernel Port.
34410 + *
34411 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
34412 + * it and/or modify it under the terms of the GNU General Public License
34413 + * as published by the Free Software Foundation, either version 2 of the
34414 + * License, or (at your option) any later version.
34415 + *
34416 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
34417 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
34418 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
34419 + * the GNU General Public License for more details.
34420 + *
34421 + * You should have received a copy of the GNU General Public License
34422 + * along with the Ubicom32 Linux Kernel Port. If not,
34423 + * see <http://www.gnu.org/licenses/>.
34424 + *
34425 + * Ubicom32 implementation derived from (with many thanks):
34426 + * arch/m68knommu
34427 + * arch/blackfin
34428 + * arch/parisc
34429 + */
34430 +
34431 +#include <linux/module.h>
34432 +#include <linux/init.h>
34433 +#include <linux/gpio.h>
34434 +#include <linux/delay.h>
34435 +#include <linux/platform_device.h>
34436 +#include <linux/i2c.h>
34437 +#include <linux/backlight.h>
34438 +#include <linux/fb.h>
34439 +#include <linux/input.h>
34440 +#include <linux/input-polldev.h>
34441 +
34442 +#include <asm/ubicom32hid.h>
34443 +
34444 +#define DRIVER_NAME "ubicom32hid"
34445 +
34446 +#ifdef DEBUG
34447 +static int ubicom32hid_debug;
34448 +#endif
34449 +
34450 +static const struct i2c_device_id ubicom32hid_id[] = {
34451 + { DRIVER_NAME, },
34452 + { }
34453 +};
34454 +MODULE_DEVICE_TABLE(i2c, ubicom32hid_id);
34455 +
34456 +/*
34457 + * Define this to make IR checking strict, in general, it's not needed
34458 + */
34459 +#undef UBICOM32HID_STRICT_IR_CHECK
34460 +
34461 +#define UBICOM32HID_CMD_SET_PWM 0x01
34462 +#define UBICOM32HID_CMD_SET_BL_EN 0x02
34463 +#define UBICOM32HID_BL_EN_LOW 0x00
34464 +#define UBICOM32HID_BL_EN_HIZ 0x01
34465 +#define UBICOM32HID_BL_EN_HI 0x02
34466 +#define UBICOM32HID_CMD_FLUSH 0x99
34467 +#define UBICOM32HID_CMD_RESET 0x99
34468 +#define UBICOM32HID_CMD_GET_IR_SWITCH 0xC0
34469 +#define UBICOM32HID_CMD_GET_REVISION 0xfd
34470 +#define UBICOM32HID_CMD_GET_DEVICE_ID 0xfe
34471 +#define UBICOM32HID_CMD_GET_VERSION 0xff
34472 +#define UBICOM32HID_DEVICE_ID 0x49
34473 +
34474 +#define UBICOM32HID_MAX_BRIGHTNESS_PWM 255
34475 +
34476 +/*
34477 + * Data structure returned by the HID device
34478 + */
34479 +struct ubicom32hid_input_data {
34480 + uint32_t ircmd;
34481 + uint8_t sw_state;
34482 + uint8_t sw_changed;
34483 +};
34484 +
34485 +/*
34486 + * Our private data
34487 + */
34488 +struct ubicom32hid_data {
34489 + /*
34490 + * Pointer to the platform data structure, we need the settings.
34491 + */
34492 + const struct ubicom32hid_platform_data *pdata;
34493 +
34494 + /*
34495 + * Backlight device
34496 + */
34497 + struct backlight_device *bldev;
34498 +
34499 + /*
34500 + * I2C client, for sending messages to the HID device
34501 + */
34502 + struct i2c_client *client;
34503 +
34504 + /*
34505 + * Current intensity, used for get_intensity.
34506 + */
34507 + int cur_intensity;
34508 +
34509 + /*
34510 + * Input subsystem
34511 + * We won't register an input subsystem if there are no mappings.
34512 + */
34513 + struct input_polled_dev *poll_dev;
34514 +};
34515 +
34516 +
34517 +/*
34518 + * ubicom32hid_set_intensity
34519 + */
34520 +static int ubicom32hid_set_intensity(struct backlight_device *bd)
34521 +{
34522 + struct ubicom32hid_data *ud =
34523 + (struct ubicom32hid_data *)bl_get_data(bd);
34524 + int intensity = bd->props.brightness;
34525 + int reg;
34526 + u8_t val;
34527 + int ret;
34528 +
34529 + /*
34530 + * If we're blanked the the intensity doesn't matter.
34531 + */
34532 + if ((bd->props.power != FB_BLANK_UNBLANK) ||
34533 + (bd->props.fb_blank != FB_BLANK_UNBLANK)) {
34534 + intensity = 0;
34535 + }
34536 +
34537 + /*
34538 + * Set the brightness based on the type of backlight
34539 + */
34540 + if (ud->pdata->type == UBICOM32HID_BL_TYPE_BINARY) {
34541 + reg = UBICOM32HID_CMD_SET_BL_EN;
34542 + if (intensity) {
34543 + val = ud->pdata->invert
34544 + ? UBICOM32HID_BL_EN_LOW : UBICOM32HID_BL_EN_HI;
34545 + } else {
34546 + val = ud->pdata->invert
34547 + ? UBICOM32HID_BL_EN_HI : UBICOM32HID_BL_EN_LOW;
34548 + }
34549 + } else {
34550 + reg = UBICOM32HID_CMD_SET_PWM;
34551 + val = ud->pdata->invert
34552 + ? (UBICOM32HID_MAX_BRIGHTNESS_PWM - intensity) :
34553 + intensity;
34554 + }
34555 +
34556 + /*
34557 + * Send the command
34558 + */
34559 + ret = i2c_smbus_write_byte_data(ud->client, reg, val);
34560 + if (ret < 0) {
34561 + dev_warn(&ud->client->dev, "Unable to write backlight err=%d\n",
34562 + ret);
34563 + return ret;
34564 + }
34565 +
34566 + ud->cur_intensity = intensity;
34567 +
34568 + return 0;
34569 +}
34570 +
34571 +/*
34572 + * ubicom32hid_get_intensity
34573 + * Return the current intensity of the backlight.
34574 + */
34575 +static int ubicom32hid_get_intensity(struct backlight_device *bd)
34576 +{
34577 + struct ubicom32hid_data *ud =
34578 + (struct ubicom32hid_data *)bl_get_data(bd);
34579 +
34580 + return ud->cur_intensity;
34581 +}
34582 +
34583 +/*
34584 + * ubicom32hid_verify_data
34585 + * Verify the data to see if there is any action to be taken
34586 + *
34587 + * Returns 0 if no action is to be taken, non-zero otherwise
34588 + */
34589 +static int ubicom32hid_verify_data(struct ubicom32hid_data *ud,
34590 + struct ubicom32hid_input_data *data)
34591 +{
34592 + uint8_t *ircmd = (uint8_t *)&(data->ircmd);
34593 +
34594 + /*
34595 + * ircmd == DEADBEEF means ir queue is empty. Since this is a
34596 + * meaningful code, that means the rest of the message is most likely
34597 + * correct, so only process the data if the switch state has changed.
34598 + */
34599 + if (data->ircmd == 0xDEADBEEF) {
34600 + return data->sw_changed != 0;
34601 + }
34602 +
34603 + /*
34604 + * We have an ircmd which is not empty:
34605 + * Data[1] should be the complement of Data[0]
34606 + */
34607 + if (ircmd[0] != (u8_t)~ircmd[1]) {
34608 + return 0;
34609 + }
34610 +
34611 +#ifdef UBICOM32HID_STRICT_IR_CHECK
34612 + /*
34613 + * It seems that some remote controls don't follow the NEC protocol
34614 + * properly, so only do this check if the remote does indeed follow the
34615 + * spec. Data[3] should be the complement of Data[2]
34616 + */
34617 + if (ircmd[2] == (u8_t)~ircmd[3]) {
34618 + return 1;
34619 + }
34620 +
34621 + /*
34622 + * For non-compliant remotes, check the system code according to what
34623 + * they send.
34624 + */
34625 + if ((ircmd[2] != UBICOM32HID_IR_SYSTEM_CODE_CHECK) ||
34626 + (ircmd[3] != UBICOM32HID_IR_SYSTEM_CODE)) {
34627 + return 0;
34628 + }
34629 +#endif
34630 +
34631 + /*
34632 + * Data checks out, process
34633 + */
34634 + return 1;
34635 +}
34636 +
34637 +/*
34638 + * ubicom32hid_poll_input
34639 + * Poll the input from the HID device.
34640 + */
34641 +static void ubicom32hid_poll_input(struct input_polled_dev *dev)
34642 +{
34643 + struct ubicom32hid_data *ud = (struct ubicom32hid_data *)dev->private;
34644 + const struct ubicom32hid_platform_data *pdata = ud->pdata;
34645 + struct ubicom32hid_input_data data;
34646 + struct input_dev *id = dev->input;
34647 + int i;
34648 + int sync_needed = 0;
34649 + uint8_t cmd;
34650 + int ret;
34651 +
34652 + /*
34653 + * Flush the queue
34654 + */
34655 + cmd = UBICOM32HID_CMD_FLUSH;
34656 + ret = i2c_master_send(ud->client, &cmd, 1);
34657 + if (ret < 0) {
34658 + return;
34659 + }
34660 +
34661 + ret = i2c_smbus_read_i2c_block_data(
34662 + ud->client, UBICOM32HID_CMD_GET_IR_SWITCH, 6, (void *)&data);
34663 + if (ret < 0) {
34664 + return;
34665 + }
34666 +
34667 + /*
34668 + * Verify the data to see if there is any action to be taken
34669 + */
34670 + if (!ubicom32hid_verify_data(ud, &data)) {
34671 + return;
34672 + }
34673 +
34674 +#ifdef DEBUG
34675 + if (ubicom32hid_debug) {
34676 + printk("Polled ircmd=%8x swstate=%2x swchanged=%2x\n",
34677 + data.ircmd, data.sw_state, data.sw_changed);
34678 + }
34679 +#endif
34680 +
34681 + /*
34682 + * Process changed switches
34683 + */
34684 + if (data.sw_changed) {
34685 + const struct ubicom32hid_button *ub = pdata->buttons;
34686 + for (i = 0; i < pdata->nbuttons; i++, ub++) {
34687 + uint8_t mask = (1 << ub->bit);
34688 + if (!(data.sw_changed & mask)) {
34689 + continue;
34690 + }
34691 +
34692 + sync_needed = 1;
34693 + input_event(id, ub->type, ub->code,
34694 + (data.sw_state & mask) ? 1 : 0);
34695 + }
34696 + }
34697 + if (sync_needed) {
34698 + input_sync(id);
34699 + }
34700 +
34701 + /*
34702 + * Process ir codes
34703 + */
34704 + if (data.ircmd != 0xDEADBEEF) {
34705 + const struct ubicom32hid_ir *ui = pdata->ircodes;
34706 + for (i = 0; i < pdata->nircodes; i++, ui++) {
34707 + if (ui->ir_code == data.ircmd) {
34708 + /*
34709 + * Simulate a up/down event
34710 + */
34711 + input_event(id, ui->type, ui->code, 1);
34712 + input_sync(id);
34713 + input_event(id, ui->type, ui->code, 0);
34714 + input_sync(id);
34715 + }
34716 + }
34717 + }
34718 +}
34719 +
34720 +
34721 +/*
34722 + * Backlight ops
34723 + */
34724 +static struct backlight_ops ubicom32hid_blops = {
34725 + .get_brightness = ubicom32hid_get_intensity,
34726 + .update_status = ubicom32hid_set_intensity,
34727 +};
34728 +
34729 +/*
34730 + * ubicom32hid_probe
34731 + */
34732 +static int ubicom32hid_probe(struct i2c_client *client,
34733 + const struct i2c_device_id *id)
34734 +{
34735 + struct ubicom32hid_platform_data *pdata;
34736 + struct ubicom32hid_data *ud;
34737 + int ret;
34738 + int i;
34739 + u8 version[2];
34740 + char buf[1];
34741 +
34742 + pdata = client->dev.platform_data;
34743 + if (pdata == NULL) {
34744 + return -ENODEV;
34745 + }
34746 +
34747 + /*
34748 + * See if we even have a device available before allocating memory.
34749 + *
34750 + * Hard reset the device
34751 + */
34752 + ret = gpio_request(pdata->gpio_reset, "ubicom32hid-reset");
34753 + if (ret < 0) {
34754 + return ret;
34755 + }
34756 + gpio_direction_output(pdata->gpio_reset, pdata->gpio_reset_polarity);
34757 + udelay(100);
34758 + gpio_set_value(pdata->gpio_reset, !pdata->gpio_reset_polarity);
34759 + udelay(100);
34760 +
34761 + /*
34762 + * soft reset the device. It sometimes takes a while to do this.
34763 + */
34764 + for (i = 0; i < 50; i++) {
34765 + buf[0] = UBICOM32HID_CMD_RESET;
34766 + ret = i2c_master_send(client, buf, 1);
34767 + if (ret > 0) {
34768 + break;
34769 + }
34770 + udelay(10000);
34771 + }
34772 + if (i == 50) {
34773 + dev_warn(&client->dev, "Unable to reset device\n");
34774 + goto fail;
34775 + }
34776 +
34777 + ret = i2c_smbus_read_byte_data(client, UBICOM32HID_CMD_GET_DEVICE_ID);
34778 + if (ret != UBICOM32HID_DEVICE_ID) {
34779 + dev_warn(&client->dev, "Incorrect device id %02x\n", buf[0]);
34780 + ret = -ENODEV;
34781 + goto fail;
34782 + }
34783 +
34784 + ret = i2c_smbus_read_byte_data(client, UBICOM32HID_CMD_GET_VERSION);
34785 + if (ret < 0) {
34786 + dev_warn(&client->dev, "Unable to get version\n");
34787 + goto fail;
34788 + }
34789 + version[0] = ret;
34790 +
34791 + ret = i2c_smbus_read_byte_data(client, UBICOM32HID_CMD_GET_REVISION);
34792 + if (ret < 0) {
34793 + dev_warn(&client->dev, "Unable to get revision\n");
34794 + goto fail;
34795 + }
34796 + version[1] = ret;
34797 +
34798 + /*
34799 + * Allocate our private data
34800 + */
34801 + ud = kzalloc(sizeof(struct ubicom32hid_data), GFP_KERNEL);
34802 + if (!ud) {
34803 + ret = -ENOMEM;
34804 + goto fail;
34805 + }
34806 + ud->pdata = pdata;
34807 + ud->client = client;
34808 +
34809 + /*
34810 + * Register our backlight device
34811 + */
34812 + ud->bldev = backlight_device_register(DRIVER_NAME, &client->dev,
34813 + ud, &ubicom32hid_blops);
34814 + if (IS_ERR(ud->bldev)) {
34815 + ret = PTR_ERR(ud->bldev);
34816 + goto fail2;
34817 + }
34818 + platform_set_drvdata(client, ud);
34819 +
34820 + /*
34821 + * Start up the backlight with the requested intensity
34822 + */
34823 + ud->bldev->props.power = FB_BLANK_UNBLANK;
34824 + ud->bldev->props.max_brightness =
34825 + (pdata->type == UBICOM32HID_BL_TYPE_PWM) ?
34826 + UBICOM32HID_MAX_BRIGHTNESS_PWM : 1;
34827 + if (pdata->default_intensity < ud->bldev->props.max_brightness) {
34828 + ud->bldev->props.brightness = pdata->default_intensity;
34829 + } else {
34830 + dev_warn(&client->dev, "Default brightness out of range, "
34831 + "setting to max\n");
34832 + ud->bldev->props.brightness = ud->bldev->props.max_brightness;
34833 + }
34834 +
34835 + ubicom32hid_set_intensity(ud->bldev);
34836 +
34837 + /*
34838 + * Check to see if we have any inputs
34839 + */
34840 + if (!pdata->nbuttons && !pdata->nircodes) {
34841 + goto done;
34842 + }
34843 +
34844 + /*
34845 + * We have buttons or codes, we must register an input device
34846 + */
34847 + ud->poll_dev = input_allocate_polled_device();
34848 + if (!ud->poll_dev) {
34849 + ret = -ENOMEM;
34850 + goto fail3;
34851 + }
34852 +
34853 + /*
34854 + * Setup the polling to default to 100ms
34855 + */
34856 + ud->poll_dev->poll = ubicom32hid_poll_input;
34857 + ud->poll_dev->poll_interval =
34858 + pdata->poll_interval ? pdata->poll_interval : 100;
34859 + ud->poll_dev->private = ud;
34860 +
34861 + ud->poll_dev->input->name =
34862 + pdata->input_name ? pdata->input_name : "Ubicom32HID";
34863 + ud->poll_dev->input->phys = "ubicom32hid/input0";
34864 + ud->poll_dev->input->dev.parent = &client->dev;
34865 + ud->poll_dev->input->id.bustype = BUS_I2C;
34866 +
34867 + /*
34868 + * Set the capabilities by running through the buttons and ir codes
34869 + */
34870 + for (i = 0; i < pdata->nbuttons; i++) {
34871 + const struct ubicom32hid_button *ub = &pdata->buttons[i];
34872 +
34873 + input_set_capability(ud->poll_dev->input,
34874 + ub->type ? ub->type : EV_KEY, ub->code);
34875 + }
34876 +
34877 + for (i = 0; i < pdata->nircodes; i++) {
34878 + const struct ubicom32hid_ir *ui = &pdata->ircodes[i];
34879 +
34880 + input_set_capability(ud->poll_dev->input,
34881 + ui->type ? ui->type : EV_KEY, ui->code);
34882 + }
34883 +
34884 + ret = input_register_polled_device(ud->poll_dev);
34885 + if (ret) {
34886 + goto fail3;
34887 + }
34888 +
34889 +done:
34890 + printk(KERN_INFO DRIVER_NAME ": enabled, version=%02x.%02x\n",
34891 + version[0], version[1]);
34892 +
34893 + return 0;
34894 +
34895 +fail3:
34896 + gpio_free(ud->pdata->gpio_reset);
34897 + backlight_device_unregister(ud->bldev);
34898 +fail2:
34899 + kfree(ud);
34900 +fail:
34901 + gpio_free(pdata->gpio_reset);
34902 + return ret;
34903 +}
34904 +
34905 +/*
34906 + * ubicom32hid_remove
34907 + */
34908 +static int ubicom32hid_remove(struct i2c_client *client)
34909 +{
34910 + struct ubicom32hid_data *ud =
34911 + (struct ubicom32hid_data *)platform_get_drvdata(client);
34912 +
34913 + gpio_free(ud->pdata->gpio_reset);
34914 +
34915 + backlight_device_unregister(ud->bldev);
34916 +
34917 + if (ud->poll_dev) {
34918 + input_unregister_polled_device(ud->poll_dev);
34919 + input_free_polled_device(ud->poll_dev);
34920 + }
34921 +
34922 + platform_set_drvdata(client, NULL);
34923 +
34924 + kfree(ud);
34925 +
34926 + return 0;
34927 +}
34928 +
34929 +static struct i2c_driver ubicom32hid_driver = {
34930 + .driver = {
34931 + .name = DRIVER_NAME,
34932 + .owner = THIS_MODULE,
34933 + },
34934 + .probe = ubicom32hid_probe,
34935 + .remove = __exit_p(ubicom32hid_remove),
34936 + .id_table = ubicom32hid_id,
34937 +};
34938 +
34939 +/*
34940 + * ubicom32hid_init
34941 + */
34942 +static int __init ubicom32hid_init(void)
34943 +{
34944 + return i2c_add_driver(&ubicom32hid_driver);
34945 +}
34946 +module_init(ubicom32hid_init);
34947 +
34948 +/*
34949 + * ubicom32hid_exit
34950 + */
34951 +static void __exit ubicom32hid_exit(void)
34952 +{
34953 + i2c_del_driver(&ubicom32hid_driver);
34954 +}
34955 +module_exit(ubicom32hid_exit);
34956 +
34957 +MODULE_AUTHOR("Pat Tjin <@ubicom.com>")
34958 +MODULE_DESCRIPTION("Ubicom HID driver");
34959 +MODULE_LICENSE("GPL");
34960 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32input.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32input.c
34961 --- linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32input.c 1970-01-01 02:00:00.000000000 +0200
34962 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32input.c 2009-12-11 11:45:11.000000000 +0200
34963 @@ -0,0 +1,265 @@
34964 +/*
34965 + * arch/ubicom32/mach-common/ubicom32input.c
34966 + * Ubicom32 Input driver
34967 + *
34968 + * based on gpio-keys
34969 + *
34970 + * (C) Copyright 2009, Ubicom, Inc.
34971 + *
34972 + * This file is part of the Ubicom32 Linux Kernel Port.
34973 + *
34974 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
34975 + * it and/or modify it under the terms of the GNU General Public License
34976 + * as published by the Free Software Foundation, either version 2 of the
34977 + * License, or (at your option) any later version.
34978 + *
34979 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
34980 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
34981 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
34982 + * the GNU General Public License for more details.
34983 + *
34984 + * You should have received a copy of the GNU General Public License
34985 + * along with the Ubicom32 Linux Kernel Port. If not,
34986 + * see <http://www.gnu.org/licenses/>.
34987 + *
34988 + * Ubicom32 implementation derived from (with many thanks):
34989 + * arch/m68knommu
34990 + * arch/blackfin
34991 + * arch/parisc
34992 + *
34993 + *
34994 + * TODO: add groups for inputs which can be sampled together (i.e. I2C)
34995 + */
34996 +
34997 +#include <linux/kernel.h>
34998 +#include <linux/module.h>
34999 +#include <linux/platform_device.h>
35000 +#include <linux/input.h>
35001 +#include <linux/input-polldev.h>
35002 +#include <linux/delay.h>
35003 +#include <linux/gpio.h>
35004 +
35005 +#include <asm/ubicom32input.h>
35006 +
35007 +struct ubicom32input_data {
35008 + struct ubicom32input_platform_data *pdata;
35009 +
35010 + struct input_polled_dev *poll_dev;
35011 +
35012 + /*
35013 + * collection of previous states for buttons
35014 + */
35015 + u8 prev_state[0];
35016 +};
35017 +
35018 +/*
35019 + * ubicom32input_poll
35020 + */
35021 +static void ubicom32input_poll(struct input_polled_dev *dev)
35022 +{
35023 + struct ubicom32input_data *ud =
35024 + (struct ubicom32input_data *)dev->private;
35025 + struct ubicom32input_platform_data *pdata = ud->pdata;
35026 + struct input_dev *id = dev->input;
35027 + int i;
35028 + int sync_needed = 0;
35029 +
35030 + for (i = 0; i < pdata->nbuttons; i++) {
35031 + const struct ubicom32input_button *ub = &pdata->buttons[i];
35032 + int state = 0;
35033 +
35034 + int val = gpio_get_value(ub->gpio);
35035 +
35036 + /*
35037 + * Check to see if the state changed from the last time we
35038 + * looked
35039 + */
35040 + if (val == ud->prev_state[i]) {
35041 + continue;
35042 + }
35043 +
35044 + /*
35045 + * The state has changed, determine if we are "up" or "down"
35046 + */
35047 + ud->prev_state[i] = val;
35048 +
35049 + if ((!val && ub->active_low) || (val && !ub->active_low)) {
35050 + state = 1;
35051 + }
35052 +
35053 + input_event(id, ub->type, ub->code, state);
35054 + sync_needed = 1;
35055 + }
35056 +
35057 + if (sync_needed) {
35058 + input_sync(id);
35059 + }
35060 +}
35061 +
35062 +/*
35063 + * ubicom32input_probe
35064 + */
35065 +static int __devinit ubicom32input_probe(struct platform_device *pdev)
35066 +{
35067 + int i;
35068 + struct ubicom32input_data *ud;
35069 + struct input_polled_dev *poll_dev;
35070 + struct input_dev *input_dev;
35071 + struct ubicom32input_platform_data *pdata;
35072 + int ret;
35073 +
35074 + pdata = pdev->dev.platform_data;
35075 + if (!pdata) {
35076 + return -EINVAL;
35077 + }
35078 +
35079 + ud = kzalloc(sizeof(struct ubicom32input_data) +
35080 + pdata->nbuttons, GFP_KERNEL);
35081 + if (!ud) {
35082 + return -ENOMEM;
35083 + }
35084 + ud->pdata = pdata;
35085 +
35086 + poll_dev = input_allocate_polled_device();
35087 + if (!poll_dev) {
35088 + ret = -ENOMEM;
35089 + goto fail;
35090 + }
35091 +
35092 + platform_set_drvdata(pdev, ud);
35093 +
35094 + ud->poll_dev = poll_dev;
35095 + poll_dev->private = ud;
35096 + poll_dev->poll = ubicom32input_poll;
35097 +
35098 + /*
35099 + * Set the poll interval requested, default to 50 msec
35100 + */
35101 + if (pdata->poll_interval) {
35102 + poll_dev->poll_interval = pdata->poll_interval;
35103 + } else {
35104 + poll_dev->poll_interval = 50;
35105 + }
35106 +
35107 + /*
35108 + * Setup the input device
35109 + */
35110 + input_dev = poll_dev->input;
35111 + input_dev->name = pdata->name ? pdata->name : "Ubicom32 Input";
35112 + input_dev->phys = "ubicom32input/input0";
35113 + input_dev->dev.parent = &pdev->dev;
35114 + input_dev->id.bustype = BUS_HOST;
35115 +
35116 + /*
35117 + * Reserve the GPIOs
35118 + */
35119 + for (i = 0; i < pdata->nbuttons; i++) {
35120 + const struct ubicom32input_button *ub = &pdata->buttons[i];
35121 +
35122 + ret = gpio_request(ub->gpio,
35123 + ub->desc ? ub->desc : "ubicom32input");
35124 + if (ret < 0) {
35125 + pr_err("ubicom32input: failed to request "
35126 + "GPIO %d ret=%d\n", ub->gpio, ret);
35127 + goto fail2;
35128 + }
35129 +
35130 + ret = gpio_direction_input(ub->gpio);
35131 + if (ret < 0) {
35132 + pr_err("ubicom32input: failed to set "
35133 + "GPIO %d to input ret=%d\n", ub->gpio, ret);
35134 + goto fail2;
35135 + }
35136 +
35137 + /*
35138 + * Set the previous state to the non-active stae
35139 + */
35140 + ud->prev_state[i] = ub->active_low;
35141 +
35142 + input_set_capability(input_dev,
35143 + ub->type ? ub->type : EV_KEY, ub->code);
35144 + }
35145 +
35146 + /*
35147 + * Register
35148 + */
35149 + ret = input_register_polled_device(ud->poll_dev);
35150 + if (ret) {
35151 + goto fail2;
35152 + }
35153 +
35154 + return 0;
35155 +
35156 +fail2:
35157 + /*
35158 + * release the GPIOs we have already requested.
35159 + */
35160 + while (--i >= 0) {
35161 + gpio_free(pdata->buttons[i].gpio);
35162 + }
35163 +
35164 +fail:
35165 + printk(KERN_ERR "Ubicom32Input: Failed to register driver %d", ret);
35166 + platform_set_drvdata(pdev, NULL);
35167 + input_free_polled_device(poll_dev);
35168 + kfree(ud);
35169 + return ret;
35170 +}
35171 +
35172 +/*
35173 + * ubicom32input_remove
35174 + */
35175 +static int __devexit ubicom32input_remove(struct platform_device *dev)
35176 +{
35177 + struct ubicom32input_data *ud =
35178 + (struct ubicom32input_data *)platform_get_drvdata(dev);
35179 + int i;
35180 +
35181 + /*
35182 + * Free the GPIOs
35183 + */
35184 + for (i = 0; i < ud->pdata->nbuttons; i++) {
35185 + gpio_free(ud->pdata->buttons[i].gpio);
35186 + }
35187 +
35188 + platform_set_drvdata(dev, NULL);
35189 + input_unregister_polled_device(ud->poll_dev);
35190 + input_free_polled_device(ud->poll_dev);
35191 +
35192 + kfree(ud);
35193 +
35194 + return 0;
35195 +}
35196 +
35197 +static struct platform_driver ubicom32input_driver = {
35198 + .driver = {
35199 + .name = "ubicom32input",
35200 + .owner = THIS_MODULE,
35201 + },
35202 + .probe = ubicom32input_probe,
35203 + .remove = __devexit_p(ubicom32input_remove),
35204 +};
35205 +
35206 +/*
35207 + * ubicom32input_init
35208 + */
35209 +static int __devinit ubicom32input_init(void)
35210 +{
35211 + return platform_driver_register(&ubicom32input_driver);
35212 +}
35213 +
35214 +/*
35215 + * ubicom32input_exit
35216 + */
35217 +static void __exit ubicom32input_exit(void)
35218 +{
35219 + platform_driver_unregister(&ubicom32input_driver);
35220 +}
35221 +
35222 +module_init(ubicom32input_init);
35223 +module_exit(ubicom32input_exit);
35224 +
35225 +MODULE_AUTHOR("Pat Tjin <pattjin@ubicom.com>");
35226 +MODULE_DESCRIPTION("Ubicom32 Input Driver");
35227 +MODULE_LICENSE("GPL");
35228 +MODULE_ALIAS("platform:ubicom32-input");
35229 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32input_i2c.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32input_i2c.c
35230 --- linux-2.6.30.10/arch/ubicom32/mach-common/ubicom32input_i2c.c 1970-01-01 02:00:00.000000000 +0200
35231 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/ubicom32input_i2c.c 2009-12-11 11:45:11.000000000 +0200
35232 @@ -0,0 +1,325 @@
35233 +/*
35234 + * arch/ubicom32/mach-common/ubicom32input_i2c.c
35235 + * Ubicom32 Input driver for I2C
35236 + * Supports PCA953x and family
35237 + *
35238 + * We hog the I2C device, turning it all to input.
35239 + *
35240 + * Based on gpio-keys, pca953x
35241 + *
35242 + * (C) Copyright 2009, Ubicom, Inc.
35243 + *
35244 + * This file is part of the Ubicom32 Linux Kernel Port.
35245 + *
35246 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
35247 + * it and/or modify it under the terms of the GNU General Public License
35248 + * as published by the Free Software Foundation, either version 2 of the
35249 + * License, or (at your option) any later version.
35250 + *
35251 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
35252 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
35253 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
35254 + * the GNU General Public License for more details.
35255 + *
35256 + * You should have received a copy of the GNU General Public License
35257 + * along with the Ubicom32 Linux Kernel Port. If not,
35258 + * see <http://www.gnu.org/licenses/>.
35259 + *
35260 + * Ubicom32 implementation derived from (with many thanks):
35261 + * arch/m68knommu
35262 + * arch/blackfin
35263 + * arch/parisc
35264 + */
35265 +#include <linux/kernel.h>
35266 +#include <linux/module.h>
35267 +#include <linux/platform_device.h>
35268 +#include <linux/input.h>
35269 +#include <linux/input-polldev.h>
35270 +#include <linux/i2c.h>
35271 +
35272 +#include <asm/ubicom32input_i2c.h>
35273 +
35274 +#define UBICOM32INPUT_I2C_REG_INPUT 0
35275 +#define UBICOM32INPUT_I2C_REG_OUTPUT 1
35276 +#define UBICOM32INPUT_I2C_REG_INVERT 2
35277 +#define UBICOM32INPUT_I2C_REG_DIRECTION 3
35278 +
35279 +static const struct i2c_device_id ubicom32input_i2c_id[] = {
35280 + { "ubicom32in_pca9534", 8, },
35281 + { "ubicom32in_pca9535", 16, },
35282 + { "ubicom32in_pca9536", 4, },
35283 + { "ubicom32in_pca9537", 4, },
35284 + { "ubicom32in_pca9538", 8, },
35285 + { "ubicom32in_pca9539", 16, },
35286 + { "ubicom32in_pca9554", 8, },
35287 + { "ubicom32in_pca9555", 16, },
35288 + { "ubicom32in_pca9557", 8, },
35289 + { "ubicom32in_max7310", 8, },
35290 + { }
35291 +};
35292 +MODULE_DEVICE_TABLE(i2c, ubicom32input_i2c_id);
35293 +
35294 +struct ubicom32input_i2c_data {
35295 + struct ubicom32input_i2c_platform_data *pdata;
35296 +
35297 + struct i2c_client *client;
35298 +
35299 + struct input_polled_dev *poll_dev;
35300 +
35301 + /*
35302 + * collection of previous states for buttons
35303 + */
35304 + uint16_t prev_state;
35305 +
35306 + uint8_t ngpios;
35307 +};
35308 +
35309 +/*
35310 + * ubicom32input_i2c_write_reg
35311 + * writes a register to the I2C device.
35312 + */
35313 +static int ubicom32input_i2c_write_reg(struct ubicom32input_i2c_data *ud,
35314 + int reg, uint16_t val)
35315 +{
35316 + int ret;
35317 +
35318 + if (ud->ngpios <= 8) {
35319 + ret = i2c_smbus_write_byte_data(ud->client, reg, val);
35320 + } else {
35321 + ret = i2c_smbus_write_word_data(ud->client, reg << 1, val);
35322 + }
35323 +
35324 + if (ret < 0) {
35325 + return ret;
35326 + }
35327 +
35328 + return 0;
35329 +}
35330 +
35331 +/*
35332 + * ubicom32input_i2c_read_reg
35333 + * reads a register from the I2C device.
35334 + */
35335 +static int ubicom32input_i2c_read_reg(struct ubicom32input_i2c_data *ud,
35336 + int reg, uint16_t *val)
35337 +{
35338 + int ret;
35339 +
35340 + if (ud->ngpios <= 8) {
35341 + ret = i2c_smbus_read_byte_data(ud->client, reg);
35342 + } else {
35343 + ret = i2c_smbus_read_word_data(ud->client, reg);
35344 + }
35345 +
35346 + if (ret < 0) {
35347 + return ret;
35348 + }
35349 +
35350 + *val = (uint16_t)ret;
35351 +
35352 + return 0;
35353 +}
35354 +
35355 +/*
35356 + * ubicom32input_i2c_poll
35357 + */
35358 +static void ubicom32input_i2c_poll(struct input_polled_dev *dev)
35359 +{
35360 + struct ubicom32input_i2c_data *ud =
35361 + (struct ubicom32input_i2c_data *)dev->private;
35362 + struct ubicom32input_i2c_platform_data *pdata = ud->pdata;
35363 + struct input_dev *id = dev->input;
35364 + int i;
35365 + int sync_needed = 0;
35366 + uint16_t val;
35367 + uint16_t change_mask;
35368 +
35369 + /*
35370 + * Try to get the input status, if we fail, bail out, maybe we can do it
35371 + * next time.
35372 + */
35373 + if (ubicom32input_i2c_read_reg(ud, UBICOM32INPUT_I2C_REG_INPUT, &val)) {
35374 + return;
35375 + }
35376 +
35377 + /*
35378 + * see if anything changed by using XOR
35379 + */
35380 + change_mask = ud->prev_state ^ val;
35381 + ud->prev_state = val;
35382 +
35383 + for (i = 0; i < pdata->nbuttons; i++) {
35384 + const struct ubicom32input_i2c_button *ub = &pdata->buttons[i];
35385 + uint16_t mask = 1 << ub->bit;
35386 + int state = val & mask;
35387 +
35388 + /*
35389 + * Check to see if the state changed from the last time we
35390 + * looked
35391 + */
35392 + if (!(change_mask & mask)) {
35393 + continue;
35394 + }
35395 + input_event(id, ub->type, ub->code, state);
35396 + sync_needed = 1;
35397 + }
35398 +
35399 + if (sync_needed) {
35400 + input_sync(id);
35401 + }
35402 +}
35403 +
35404 +/*
35405 + * ubicom32input_i2c_probe
35406 + */
35407 +static int __devinit ubicom32input_i2c_probe(struct i2c_client *client,
35408 + const struct i2c_device_id *id)
35409 +{
35410 + int i;
35411 + struct ubicom32input_i2c_data *ud;
35412 + struct input_polled_dev *poll_dev;
35413 + struct input_dev *input_dev;
35414 + struct ubicom32input_i2c_platform_data *pdata;
35415 + int ret;
35416 + uint16_t invert_mask = 0;
35417 +
35418 + pdata = client->dev.platform_data;
35419 + if (!pdata) {
35420 + return -EINVAL;
35421 + }
35422 +
35423 + ud = kzalloc(sizeof(struct ubicom32input_i2c_data), GFP_KERNEL);
35424 + if (!ud) {
35425 + return -ENOMEM;
35426 + }
35427 + ud->pdata = pdata;
35428 + ud->client = client;
35429 + ud->ngpios = id->driver_data;
35430 +
35431 + poll_dev = input_allocate_polled_device();
35432 + if (!poll_dev) {
35433 + ret = -ENOMEM;
35434 + goto fail;
35435 + }
35436 +
35437 + ud->poll_dev = poll_dev;
35438 + poll_dev->private = ud;
35439 + poll_dev->poll = ubicom32input_i2c_poll;
35440 +
35441 + /*
35442 + * Set the poll interval requested, default to 100 msec
35443 + */
35444 + if (pdata->poll_interval) {
35445 + poll_dev->poll_interval = pdata->poll_interval;
35446 + } else {
35447 + poll_dev->poll_interval = 100;
35448 + }
35449 +
35450 + /*
35451 + * Setup the input device
35452 + */
35453 + input_dev = poll_dev->input;
35454 + input_dev->name = pdata->name ? pdata->name : "Ubicom32 Input I2C";
35455 + input_dev->phys = "ubicom32input_i2c/input0";
35456 + input_dev->dev.parent = &client->dev;
35457 + input_dev->id.bustype = BUS_I2C;
35458 +
35459 + /*
35460 + * Set the capabilities
35461 + */
35462 + for (i = 0; i < pdata->nbuttons; i++) {
35463 + const struct ubicom32input_i2c_button *ub = &pdata->buttons[i];
35464 +
35465 + if (ub->active_low) {
35466 + invert_mask |= (1 << ub->bit);
35467 + }
35468 +
35469 + input_set_capability(input_dev,
35470 + ub->type ? ub->type : EV_KEY, ub->code);
35471 + }
35472 +
35473 + /*
35474 + * Setup the device (all inputs)
35475 + */
35476 + ret = ubicom32input_i2c_write_reg(ud, UBICOM32INPUT_I2C_REG_DIRECTION,
35477 + 0xFFFF);
35478 + if (ret < 0) {
35479 + goto fail;
35480 + }
35481 +
35482 + ret = ubicom32input_i2c_write_reg(ud, UBICOM32INPUT_I2C_REG_INVERT,
35483 + invert_mask);
35484 + if (ret < 0) {
35485 + goto fail;
35486 + }
35487 +
35488 + /*
35489 + * Register
35490 + */
35491 + ret = input_register_polled_device(ud->poll_dev);
35492 + if (ret) {
35493 + goto fail;
35494 + }
35495 +
35496 + i2c_set_clientdata(client, ud);
35497 +
35498 + return 0;
35499 +
35500 +fail:
35501 + printk(KERN_ERR "ubicom32input_i2c: Failed to register driver %d\n",
35502 + ret);
35503 + input_free_polled_device(poll_dev);
35504 + kfree(ud);
35505 + return ret;
35506 +}
35507 +
35508 +/*
35509 + * ubicom32input_i2c_remove
35510 + */
35511 +static int __devexit ubicom32input_i2c_remove(struct i2c_client *client)
35512 +{
35513 + struct ubicom32input_i2c_data *ud =
35514 + (struct ubicom32input_i2c_data *)i2c_get_clientdata(client);
35515 +
35516 + i2c_set_clientdata(client, NULL);
35517 + input_unregister_polled_device(ud->poll_dev);
35518 + input_free_polled_device(ud->poll_dev);
35519 +
35520 + kfree(ud);
35521 +
35522 + return 0;
35523 +}
35524 +
35525 +static struct i2c_driver ubicom32input_i2c_driver = {
35526 + .driver = {
35527 + .name = "ubicom32input_i2c",
35528 + .owner = THIS_MODULE,
35529 + },
35530 + .remove = __devexit_p(ubicom32input_i2c_remove),
35531 + .id_table = ubicom32input_i2c_id,
35532 + .probe = ubicom32input_i2c_probe,
35533 +};
35534 +
35535 +/*
35536 + * ubicom32input_i2c_init
35537 + */
35538 +static int __devinit ubicom32input_i2c_init(void)
35539 +{
35540 + return i2c_add_driver(&ubicom32input_i2c_driver);
35541 +}
35542 +
35543 +/*
35544 + * ubicom32input_i2c_exit
35545 + */
35546 +static void __exit ubicom32input_i2c_exit(void)
35547 +{
35548 + i2c_del_driver(&ubicom32input_i2c_driver);
35549 +}
35550 +
35551 +module_init(ubicom32input_i2c_init);
35552 +module_exit(ubicom32input_i2c_exit);
35553 +
35554 +MODULE_AUTHOR("Pat Tjin <pattjin@ubicom.com>");
35555 +MODULE_DESCRIPTION("Ubicom32 Input Driver I2C");
35556 +MODULE_LICENSE("GPL");
35557 +MODULE_ALIAS("platform:ubicom32-input");
35558 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/usb.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb.c
35559 --- linux-2.6.30.10/arch/ubicom32/mach-common/usb.c 1970-01-01 02:00:00.000000000 +0200
35560 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb.c 2009-12-11 11:45:11.000000000 +0200
35561 @@ -0,0 +1,132 @@
35562 +/*
35563 + * arch/ubicom32/mach-common/ip5k_usb.c
35564 + * Ubicom32 architecture usb support.
35565 + *
35566 + * (C) Copyright 2009, Ubicom, Inc.
35567 + * Copyright (C) 2007 MontaVista Software, Inc. <source@mvista.com>
35568 + * Author: Kevin Hilman
35569 + *
35570 + * This file is part of the Ubicom32 Linux Kernel Port.
35571 + *
35572 + * The Ubicom32 Linux Kernel Port is free software: you can
35573 + * redistribute it and/or modify it under the terms of the GNU General
35574 + * Public License as published by the Free Software Foundation, either
35575 + * version 2 of the License, or (at your option) any later version.
35576 + *
35577 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
35578 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
35579 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
35580 + * See the GNU General Public License for more details.
35581 + *
35582 + * You should have received a copy of the GNU General Public License
35583 + * along with the Ubicom32 Linux Kernel Port. If not,
35584 + * see <http://www.gnu.org/licenses/>.
35585 + *
35586 + * Ubicom32 implementation derived from (with many thanks):
35587 + * arch/m68knommu
35588 + * arch/blackfin
35589 + * arch/parisc
35590 + */
35591 +
35592 +#include <linux/types.h>
35593 +#include <linux/errno.h>
35594 +#include <linux/delay.h>
35595 +#include <linux/platform_device.h>
35596 +#include <linux/dma-mapping.h>
35597 +#include <linux/usb/musb.h>
35598 +#include <asm/devtree.h>
35599 +#include <asm/ip5000.h>
35600 +#include "usb_tio.h"
35601 +
35602 +struct usbtionode *unode = NULL;
35603 +
35604 +static struct resource usb_resources[] = {
35605 + [0] = {
35606 + .start = RJ + 0x800,
35607 + .end = RJ + 0x1000,
35608 + .flags = IORESOURCE_MEM,
35609 + },
35610 + [1] = { /* general IRQ */
35611 + .start = 1, /* this is a dummy value, the real irq number is passed from kernel_setup_param */
35612 + .flags = IORESOURCE_IRQ,
35613 + },
35614 +};
35615 +
35616 +
35617 +static struct musb_hdrc_eps_bits musb_eps[] = {
35618 + { "ep1_tx", 4, },
35619 + { "ep1_rx", 4, },
35620 + { "ep2_tx", 10, },
35621 + { "ep2_rx", 10, },
35622 + { "ep3_tx", 9, },
35623 + { "ep3_rx", 9, },
35624 + { "ep4_tx", 9, },
35625 + { "ep4_rx", 9, },
35626 + { "ep5_tx", 6, },
35627 + { "ep5_rx", 6, },
35628 +};
35629 +
35630 +static struct musb_hdrc_config musb_config = {
35631 + .multipoint = true,
35632 + .dyn_fifo = false,
35633 + .soft_con = true,
35634 + .dma = false,
35635 +
35636 + .num_eps = 6,
35637 + .dma_channels = 0,
35638 + .ram_bits = 0,
35639 + .eps_bits = musb_eps,
35640 +};
35641 +
35642 +static struct musb_hdrc_platform_data usb_data = {
35643 +#ifdef CONFIG_USB_MUSB_OTG
35644 + .mode = MUSB_OTG,
35645 +#else
35646 +#ifdef CONFIG_USB_MUSB_HDRC_HCD
35647 + .mode = MUSB_HOST,
35648 +#else
35649 +#ifdef CONFIG_USB_GADGET_MUSB_HDRC
35650 + .mode = MUSB_PERIPHERAL,
35651 +#endif
35652 +#endif
35653 +#endif
35654 + .clock = NULL,
35655 + .set_clock = NULL,
35656 + .config = &musb_config,
35657 +};
35658 +
35659 +static struct platform_device musb_device = {
35660 + .name = "musb_hdrc",
35661 + .id = 0,
35662 + .dev = {
35663 + .platform_data = &usb_data,
35664 + .dma_mask = NULL,
35665 + .coherent_dma_mask = 0,
35666 + },
35667 + .resource = usb_resources,
35668 + .num_resources = ARRAY_SIZE(usb_resources),
35669 +};
35670 +
35671 +struct usbtio_node *usb_node = NULL;
35672 +void ubi32_usb_init(void)
35673 +{
35674 + /*
35675 + * See if the usbtio is in the device tree.
35676 + */
35677 + usb_node = (struct usbtio_node *)devtree_find_node("usbtio");
35678 + if (!usb_node) {
35679 + printk(KERN_WARNING "usb init failed\n");
35680 + return;
35681 + }
35682 +
35683 + usb_resources[1].start = usb_node->dn.recvirq;
35684 + if (platform_device_register(&musb_device) < 0) {
35685 + printk(KERN_ERR "Unable to register HS-USB (MUSB) device\n");
35686 + return;
35687 + }
35688 +}
35689 +
35690 +void ubi32_usb_int_clr(void)
35691 +{
35692 + UBICOM32_IO_PORT(RJ)->int_clr = (1 << 3);
35693 +}
35694 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/usb_tio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb_tio.c
35695 --- linux-2.6.30.10/arch/ubicom32/mach-common/usb_tio.c 1970-01-01 02:00:00.000000000 +0200
35696 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb_tio.c 2009-12-11 11:45:11.000000000 +0200
35697 @@ -0,0 +1,356 @@
35698 +/*
35699 + * arch/ubicom32/mach-common/usb_tio.c
35700 + * Linux side Ubicom USB TIO driver
35701 + *
35702 + * (C) Copyright 2009, Ubicom, Inc.
35703 + *
35704 + * This file is part of the Ubicom32 Linux Kernel Port.
35705 + *
35706 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
35707 + * it and/or modify it under the terms of the GNU General Public License
35708 + * as published by the Free Software Foundation, either version 2 of the
35709 + * License, or (at your option) any later version.
35710 + *
35711 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
35712 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
35713 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
35714 + * the GNU General Public License for more details.
35715 + *
35716 + * You should have received a copy of the GNU General Public License
35717 + * along with the Ubicom32 Linux Kernel Port. If not,
35718 + * see <http://www.gnu.org/licenses/>.
35719 + *
35720 + * Ubicom32 implementation derived from (with many thanks):
35721 + * arch/m68knommu
35722 + * arch/blackfin
35723 + * arch/parisc
35724 + */
35725 +#include <linux/module.h>
35726 +#include <linux/spinlock.h>
35727 +#include <linux/slab.h>
35728 +#include <asm/devtree.h>
35729 +#include "usb_tio.h"
35730 +
35731 +#ifdef CONFIG_SMP
35732 +static DEFINE_SPINLOCK(tio_lock);
35733 +#define USB_TIO_LOCK(lock, flag) spin_lock_irqsave(lock, flag)
35734 +#define USB_TIO_UNLOCK(lock, flag) spin_unlock_irqrestore(lock, flag)
35735 +#define USB_TIO_LOCK_ISLOCKED(lock) spin_try_lock(lock)
35736 +#else
35737 +#define USB_TIO_LOCK(lock, flag) local_irq_save(flag)
35738 +#define USB_TIO_UNLOCK(lock, flag) local_irq_restore(flag)
35739 +#endif
35740 +
35741 +spinlock_t usb_tio_lock;
35742 +
35743 +/*
35744 + * usb_tio_set_hrt_interrupt()
35745 + */
35746 +static inline void usb_tio_set_hrt_interrupt(void)
35747 +{
35748 + ubicom32_set_interrupt(usb_node->dn.sendirq);
35749 +}
35750 +
35751 +static inline void usb_tio_wait_hrt(void)
35752 +{
35753 + while (unlikely(usb_node->pdesc));
35754 +}
35755 +
35756 +#if defined(USB_TIO_DEBUG)
35757 +static void usb_tio_request_verify_magic(volatile struct usb_tio_request *req)
35758 +{
35759 + BUG_ON(req->magic != USB_TIO_REQUEST_MAGIC2);
35760 +}
35761 +
35762 +static void usb_tio_request_clear_magic(volatile struct usb_tio_request *req)
35763 +{
35764 + req->magic = 0;
35765 +}
35766 +#endif
35767 +
35768 +static void usb_tio_request_set_magic(volatile struct usb_tio_request *req)
35769 +{
35770 + req->magic = USB_TIO_REQUEST_MAGIC1;
35771 +}
35772 +
35773 +/*
35774 + * usb_tio_commit_request()
35775 + */
35776 +static inline void usb_tio_commit_request(volatile struct usb_tio_request *request)
35777 +{
35778 + wmb();
35779 + usb_node->pdesc = request;
35780 +
35781 + /*
35782 + * next thing to do is alway checking if (usb_node->pdesc == NULL)
35783 + * to see if the request is done, so add a mb() here
35784 + */
35785 + mb();
35786 + usb_tio_set_hrt_interrupt();
35787 +}
35788 +
35789 +/*
35790 + * usb_tio_read_u16()
35791 + * Synchronously read 16 bits.
35792 + */
35793 +u8_t usb_tio_read_u16(u32_t address, u16_t *data)
35794 +{
35795 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35796 + unsigned long flag;
35797 +
35798 + /*
35799 + * Wait for any previous request to complete and then make this request.
35800 + */
35801 + USB_TIO_LOCK(&tio_lock, flag);
35802 + usb_tio_wait_hrt();
35803 +
35804 + /*
35805 + * Fill in the request.
35806 + */
35807 + tio_req->address = address;
35808 + tio_req->cmd = USB_TIO_READ16_SYNC;
35809 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35810 + usb_tio_commit_request(tio_req);
35811 +
35812 + /*
35813 + * Wait for the result to show up.
35814 + */
35815 + usb_tio_wait_hrt();
35816 + USB_TIO_REQUEST_VERIFY_MAGIC(tio_req);
35817 + *data = (u16_t)tio_req->data;
35818 + USB_TIO_REQUEST_CLEAR_MAGIC(tio_req);
35819 + USB_TIO_UNLOCK(&tio_lock, flag);
35820 + return USB_TIO_OK;
35821 +}
35822 +
35823 +/*
35824 + * usb_tio_read_u8()
35825 + * Synchronously read 16 bits.
35826 + */
35827 +u8_t usb_tio_read_u8(u32_t address, u8_t *data)
35828 +{
35829 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35830 + unsigned long flag;
35831 +
35832 + /*
35833 + * Wait for any previous request to complete and then make this request.
35834 + */
35835 + USB_TIO_LOCK(&tio_lock, flag);
35836 + usb_tio_wait_hrt();
35837 +
35838 + /*
35839 + * Fill in the request.
35840 + */
35841 + tio_req->address = address;
35842 + tio_req->cmd = USB_TIO_READ8_SYNC;
35843 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35844 +
35845 + /*
35846 + * commit the request
35847 + */
35848 + usb_tio_commit_request(tio_req);
35849 +
35850 + /*
35851 + * Wait for the result to show up.
35852 + */
35853 + usb_tio_wait_hrt();
35854 + USB_TIO_REQUEST_VERIFY_MAGIC(tio_req);
35855 + *data = (u8_t)tio_req->data;
35856 + USB_TIO_REQUEST_CLEAR_MAGIC(tio_req);
35857 + USB_TIO_UNLOCK(&tio_lock, flag);
35858 + return USB_TIO_OK;
35859 +}
35860 +
35861 +/*
35862 + * usb_tio_write_u16()
35863 + * Asynchronously write 16 bits.
35864 + */
35865 +u8_t usb_tio_write_u16(u32_t address, u16_t data)
35866 +{
35867 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35868 + unsigned long flag;
35869 +
35870 + /*
35871 + * Wait for any previous write or pending read to complete.
35872 + */
35873 + USB_TIO_LOCK(&tio_lock, flag);
35874 + usb_tio_wait_hrt();
35875 +
35876 + tio_req->address = address;
35877 + tio_req->data = data;
35878 + tio_req->cmd = USB_TIO_WRITE16_ASYNC;
35879 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35880 +
35881 + /*
35882 + * commit the request
35883 + */
35884 + usb_tio_commit_request(tio_req);
35885 + USB_TIO_UNLOCK(&tio_lock, flag);
35886 + return USB_TIO_OK;
35887 +}
35888 +
35889 +/*
35890 + * usb_tio_write_u8()
35891 + * Asynchronously write 8 bits.
35892 + */
35893 +u8_t usb_tio_write_u8(u32_t address, u8_t data)
35894 +{
35895 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35896 + unsigned long flag;
35897 +
35898 + /*
35899 + * Wait for any previous write or pending read to complete.
35900 + */
35901 + USB_TIO_LOCK(&tio_lock, flag);
35902 + usb_tio_wait_hrt();
35903 +
35904 + tio_req->address = address;
35905 + tio_req->data = data;
35906 + tio_req->cmd = USB_TIO_WRITE8_ASYNC;
35907 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35908 +
35909 + /*
35910 + * commit the request
35911 + */
35912 + usb_tio_commit_request(tio_req);
35913 + USB_TIO_UNLOCK(&tio_lock, flag);
35914 + return USB_TIO_OK;
35915 +}
35916 +
35917 +/*
35918 + * usb_tio_read_fifo()
35919 + * Synchronously read FIFO.
35920 + */
35921 +u8_t usb_tio_read_fifo(u32_t address, u32_t buffer, u32_t bytes)
35922 +{
35923 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35924 + unsigned long flag;
35925 +
35926 + /*
35927 + * Wait for any previous request to complete and then make this request.
35928 + */
35929 + USB_TIO_LOCK(&tio_lock, flag);
35930 + usb_tio_wait_hrt();
35931 +
35932 + /*
35933 + * Fill in the request.
35934 + */
35935 + tio_req->address = address;
35936 + tio_req->cmd = USB_TIO_READ_FIFO_SYNC;
35937 + tio_req->buffer = buffer;
35938 + tio_req->transfer_length = bytes;
35939 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35940 +
35941 + /*
35942 + * commit the request
35943 + */
35944 + usb_tio_commit_request(tio_req);
35945 +
35946 + /*
35947 + * Wait for the result to show up.
35948 + */
35949 + usb_tio_wait_hrt();
35950 + USB_TIO_REQUEST_VERIFY_MAGIC(tio_req);
35951 + USB_TIO_REQUEST_CLEAR_MAGIC(tio_req);
35952 + USB_TIO_UNLOCK(&tio_lock, flag);
35953 + return USB_TIO_OK;
35954 +}
35955 +
35956 +/*
35957 + * usb_tio_write_fifo()
35958 + * Synchronously write 32 bits.
35959 + */
35960 +u8_t usb_tio_write_fifo(u32_t address, u32_t buffer, u32_t bytes)
35961 +{
35962 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35963 + unsigned long flag;
35964 +
35965 + USB_TIO_LOCK(&tio_lock, flag);
35966 + usb_tio_wait_hrt();
35967 +
35968 + tio_req->address = address;
35969 + tio_req->buffer = buffer;
35970 + tio_req->cmd = USB_TIO_WRITE_FIFO_SYNC;
35971 + tio_req->transfer_length = bytes;
35972 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
35973 + /*
35974 + * commit the request
35975 + */
35976 + usb_tio_commit_request(tio_req);
35977 +
35978 + /*
35979 + * Wait for the result to show up.
35980 + */
35981 + usb_tio_wait_hrt();
35982 + USB_TIO_REQUEST_VERIFY_MAGIC(tio_req);
35983 + USB_TIO_REQUEST_CLEAR_MAGIC(tio_req);
35984 + USB_TIO_UNLOCK(&tio_lock, flag);
35985 + return USB_TIO_OK;
35986 +}
35987 +
35988 +/*
35989 + * usb_tio_write_fifo_async()
35990 + * Asynchronously write 32 bits.
35991 + */
35992 +u8_t usb_tio_write_fifo_async(u32_t address, u32_t buffer, u32_t bytes)
35993 +{
35994 + volatile struct usb_tio_request *tio_req = &usb_node->request;
35995 + unsigned long flag;
35996 +
35997 + USB_TIO_LOCK(&tio_lock, flag);
35998 + usb_tio_wait_hrt();
35999 +
36000 + tio_req->address = address;
36001 +
36002 + /*
36003 + * Is it necessary to make a local copy of the buffer? Any chance the URB is aborted before TIO finished the FIFO write?
36004 + */
36005 + tio_req->buffer = buffer;
36006 + tio_req->cmd = USB_TIO_WRITE_FIFO_SYNC;
36007 + tio_req->transfer_length = bytes;
36008 + USB_TIO_REQUEST_SET_MAGIC(tio_req);
36009 + /*
36010 + * commit the request
36011 + */
36012 + usb_tio_commit_request(tio_req);
36013 + USB_TIO_UNLOCK(&tio_lock, flag);
36014 + return USB_TIO_OK;
36015 +}
36016 +
36017 +/*
36018 + * usb_tio_read_int_status()
36019 + * read and clear the interrupt status registers
36020 + */
36021 +void usb_tio_read_int_status(u8_t *int_usb, u16_t *int_tx, u16_t *int_rx)
36022 +{
36023 +
36024 + /*
36025 + * clear the interrupt must be syncronized with the TIO thread to prevent the racing condiiton
36026 + * that TIO thread try to set it at same time
36027 + */
36028 + asm volatile (
36029 + "1: bset (%0), (%0), #0 \n\t" \
36030 + " jmpne.f 1b \n\t" \
36031 + :
36032 + : "a" (&usb_node->usb_vp_control)
36033 + : "memory", "cc"
36034 + );
36035 +
36036 + *int_usb = usb_node->usb_vp_hw_int_usb;
36037 + *int_tx = cpu_to_le16(usb_node->usb_vp_hw_int_tx);
36038 + *int_rx = cpu_to_le16(usb_node->usb_vp_hw_int_rx);
36039 +
36040 + //printk(KERN_INFO "int read %x, %x, %x\n", *int_usb, *int_tx, *int_rx);
36041 +
36042 + /*
36043 + * The interrupt status register is read-clean, so clear it now
36044 + */
36045 + usb_node->usb_vp_hw_int_usb = 0;
36046 + usb_node->usb_vp_hw_int_tx = 0;
36047 + usb_node->usb_vp_hw_int_rx = 0;
36048 +
36049 + /*
36050 + * release the lock bit
36051 + */
36052 + usb_node->usb_vp_control &= 0xfffe;
36053 +}
36054 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/usb_tio.h linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb_tio.h
36055 --- linux-2.6.30.10/arch/ubicom32/mach-common/usb_tio.h 1970-01-01 02:00:00.000000000 +0200
36056 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/usb_tio.h 2009-12-11 11:45:11.000000000 +0200
36057 @@ -0,0 +1,111 @@
36058 +/*
36059 + * arch/ubicom32/mach-common/usb_tio.h
36060 + * Definitions for usb_tio.c
36061 + *
36062 + * (C) Copyright 2009, Ubicom, Inc.
36063 + *
36064 + * This file is part of the Ubicom32 Linux Kernel Port.
36065 + *
36066 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36067 + * it and/or modify it under the terms of the GNU General Public License
36068 + * as published by the Free Software Foundation, either version 2 of the
36069 + * License, or (at your option) any later version.
36070 + *
36071 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36072 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36073 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36074 + * the GNU General Public License for more details.
36075 + *
36076 + * You should have received a copy of the GNU General Public License
36077 + * along with the Ubicom32 Linux Kernel Port. If not,
36078 + * see <http://www.gnu.org/licenses/>.
36079 + *
36080 + * Ubicom32 implementation derived from (with many thanks):
36081 + * arch/m68knommu
36082 + * arch/blackfin
36083 + * arch/parisc
36084 + */
36085 +
36086 +#include <linux/version.h>
36087 +#include <linux/kernel.h>
36088 +#include <linux/types.h>
36089 +#include <linux/errno.h>
36090 +#include <linux/err.h>
36091 +#include <asm/devtree.h>
36092 +#include <asm/ip5000.h>
36093 +
36094 +#ifndef _USB_TIO_H
36095 +#define _USB_TIO_H
36096 +
36097 +#undef USB_TIO_DEBUG
36098 +
36099 +#define USB_TIO_REQUEST_MAGIC1 0x2307
36100 +#define USB_TIO_REQUEST_MAGIC2 0x0789
36101 +#if defined(USB_TIO_DEBUG)
36102 +#define USB_TIO_REQUEST_VERIFY_MAGIC(req) usb_tio_request_verify_magic(req)
36103 +#define USB_TIO_REQUEST_SET_MAGIC(req) usb_tio_request_set_magic(req)
36104 +#define USB_TIO_REQUEST_CLEAR_MAGIC(req) usb_tio_request_clear_magic(req)
36105 +#else
36106 +#define USB_TIO_REQUEST_VERIFY_MAGIC(req)
36107 +#define USB_TIO_REQUEST_SET_MAGIC(req) usb_tio_request_set_magic(req)
36108 +#define USB_TIO_REQUEST_CLEAR_MAGIC(req)
36109 +#endif
36110 +
36111 +enum USB_TIO_status {
36112 + USB_TIO_OK,
36113 + USB_TIO_ERROR,
36114 + USB_TIO_ERROR_COMMIT,
36115 +};
36116 +
36117 +enum USB_TIO_cmds {
36118 + USB_TIO_READ16_SYNC,
36119 + USB_TIO_READ8_SYNC,
36120 + USB_TIO_READ_FIFO_SYNC,
36121 +
36122 + USB_TIO_WRITE16_ASYNC,
36123 + USB_TIO_WRITE8_ASYNC,
36124 + USB_TIO_WRITE_FIFO_ASYNC,
36125 +
36126 + USB_TIO_WRITE16_SYNC,
36127 + USB_TIO_WRITE8_SYNC,
36128 + USB_TIO_WRITE_FIFO_SYNC,
36129 +
36130 +};
36131 +
36132 +enum USB_TIO_state {
36133 + USB_TIO_NORMAL,
36134 + USB_TIO_DMA_SETUP,
36135 +};
36136 +
36137 +struct usb_tio_request {
36138 + volatile u32_t address;
36139 + union {
36140 + volatile u32_t data;
36141 + volatile u32_t buffer;
36142 + };
36143 + volatile u16_t cmd;
36144 + const volatile u16_t status;
36145 + volatile u32_t transfer_length;
36146 + volatile u32_t thread_mask;
36147 + volatile u16_t magic;
36148 +};
36149 +
36150 +struct usbtio_node {
36151 + struct devtree_node dn;
36152 + volatile struct usb_tio_request * volatile pdesc;
36153 + struct usb_tio_request request;
36154 + volatile u32_t usb_vp_config;
36155 + volatile u32_t usb_vp_control;
36156 + const volatile u32_t usb_vp_status;
36157 + volatile u16_t usb_vp_hw_int_tx;
36158 + volatile u16_t usb_vp_hw_int_rx;
36159 + volatile u8_t usb_vp_hw_int_usb;
36160 + volatile u8_t usb_vp_hw_int_mask_usb;
36161 + volatile u16_t usb_vp_hw_int_mask_tx;
36162 + volatile u16_t usb_vp_hw_int_mask_rx;
36163 +
36164 +};
36165 +
36166 +extern struct usbtio_node *usb_node;
36167 +extern void ubi32_usb_init(void);
36168 +#endif
36169 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-common/vdc_tio.c linux-2.6.30.10-ubi/arch/ubicom32/mach-common/vdc_tio.c
36170 --- linux-2.6.30.10/arch/ubicom32/mach-common/vdc_tio.c 1970-01-01 02:00:00.000000000 +0200
36171 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-common/vdc_tio.c 2009-12-11 11:45:11.000000000 +0200
36172 @@ -0,0 +1,111 @@
36173 +/*
36174 + * arch/ubicom32/mach-common/vdc_tio.c
36175 + * Generic initialization for VDC
36176 + *
36177 + * (C) Copyright 2009, Ubicom, Inc.
36178 + *
36179 + * This file is part of the Ubicom32 Linux Kernel Port.
36180 + *
36181 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36182 + * it and/or modify it under the terms of the GNU General Public License
36183 + * as published by the Free Software Foundation, either version 2 of the
36184 + * License, or (at your option) any later version.
36185 + *
36186 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36187 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36188 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36189 + * the GNU General Public License for more details.
36190 + *
36191 + * You should have received a copy of the GNU General Public License
36192 + * along with the Ubicom32 Linux Kernel Port. If not,
36193 + * see <http://www.gnu.org/licenses/>.
36194 + *
36195 + * Ubicom32 implementation derived from (with many thanks):
36196 + * arch/m68knommu
36197 + * arch/blackfin
36198 + * arch/parisc
36199 + */
36200 +
36201 +#include <linux/platform_device.h>
36202 +#include <linux/types.h>
36203 +
36204 +#include <asm/devtree.h>
36205 +#include <asm/vdc_tio.h>
36206 +
36207 +/*
36208 + * Resources that this driver uses
36209 + */
36210 +static struct resource vdc_tio_resources[] = {
36211 + /*
36212 + * Send IRQ
36213 + */
36214 + [0] = {
36215 + /*
36216 + * The init routine will query the devtree and fill this in
36217 + */
36218 + .flags = IORESOURCE_IRQ,
36219 + },
36220 +
36221 + /*
36222 + * Receive IRQ (optional)
36223 + */
36224 + [1] = {
36225 + /*
36226 + * The init routine will query the devtree and fill this in
36227 + */
36228 + .flags = IORESOURCE_IRQ,
36229 + },
36230 +
36231 + /*
36232 + * Memory Mapped Registers
36233 + */
36234 + [2] = {
36235 + /*
36236 + * The init routine will query the devtree and fill this in
36237 + */
36238 + .flags = IORESOURCE_MEM,
36239 + },
36240 +};
36241 +
36242 +/*
36243 + * The platform_device structure which is passed to the driver
36244 + */
36245 +static struct platform_device vdc_tio_platform_device = {
36246 + .name = "ubicom32fb",
36247 + .id = -1,
36248 + .resource = vdc_tio_resources,
36249 + .num_resources = ARRAY_SIZE(vdc_tio_resources),
36250 +};
36251 +
36252 +/*
36253 + * vdc_tio_init
36254 + * Checks the device tree and instantiates the driver if found
36255 + */
36256 +void __init vdc_tio_init(void)
36257 +{
36258 + /*
36259 + * Check the device tree for the vdc_tio
36260 + */
36261 + struct vdc_tio_node *vdc_node =
36262 + (struct vdc_tio_node *)devtree_find_node("vdctio");
36263 + if (!vdc_node) {
36264 + printk(KERN_WARNING "No vdc_tio found\n");
36265 + return;
36266 + }
36267 +
36268 + /*
36269 + * Fill in the resources and platform data from devtree information
36270 + */
36271 + vdc_tio_resources[0].start = vdc_node->dn.sendirq;
36272 + vdc_tio_resources[1].start = vdc_node->dn.recvirq;
36273 + vdc_tio_resources[2].start = (u32_t)vdc_node->regs;
36274 + vdc_tio_resources[2].end = (u32_t)vdc_node->regs +
36275 + sizeof(struct vdc_tio_vp_regs);
36276 +
36277 + /*
36278 + * Try to get the device registered
36279 + */
36280 + if (platform_device_register(&vdc_tio_platform_device) < 0) {
36281 + printk(KERN_WARNING "VDC failed to register\n");
36282 + }
36283 +}
36284 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5160dev.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5160dev.c
36285 --- linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5160dev.c 1970-01-01 02:00:00.000000000 +0200
36286 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5160dev.c 2009-12-11 11:45:11.000000000 +0200
36287 @@ -0,0 +1,109 @@
36288 +/*
36289 + * arch/ubicom32/mach-ip5k/board-ip5160dev.c
36290 + * Platform initialization for ip5160dev board.
36291 + *
36292 + * (C) Copyright 2009, Ubicom, Inc.
36293 + *
36294 + * This file is part of the Ubicom32 Linux Kernel Port.
36295 + *
36296 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36297 + * it and/or modify it under the terms of the GNU General Public License
36298 + * as published by the Free Software Foundation, either version 2 of the
36299 + * License, or (at your option) any later version.
36300 + *
36301 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36302 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36303 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36304 + * the GNU General Public License for more details.
36305 + *
36306 + * You should have received a copy of the GNU General Public License
36307 + * along with the Ubicom32 Linux Kernel Port. If not,
36308 + * see <http://www.gnu.org/licenses/>.
36309 + *
36310 + * Ubicom32 implementation derived from (with many thanks):
36311 + * arch/m68knommu
36312 + * arch/blackfin
36313 + * arch/parisc
36314 + */
36315 +#include <linux/device.h>
36316 +#include <linux/platform_device.h>
36317 +#include <linux/gpio.h>
36318 +
36319 +#include <asm/board.h>
36320 +#include <asm/machdep.h>
36321 +#ifdef CONFIG_SERIAL_UBI32_SERDES
36322 +#include <asm/ubicom32suart.h>
36323 +#endif
36324 +
36325 +/*
36326 + * Factory Default Button on the board at PXn
36327 + * TODO: This is just a placeholder and it needs to include proper header files
36328 + */
36329 +struct ubicom32fdb_platform_data {
36330 + int fdb_gpio;
36331 + bool fdb_polarity;
36332 +};
36333 +
36334 +static struct ubicom32fdb_platform_data ip5160dev_fdb_data = {
36335 + .fdb_gpio = 0,
36336 + .fdb_polarity = true,
36337 +};
36338 +
36339 +static struct platform_device ip5160dev_fdb_device = {
36340 + .name = "ubicom32fdb",
36341 + .id = -1,
36342 + .dev = {
36343 + .platform_data = &ip5160dev_fdb_data,
36344 + },
36345 +};
36346 +
36347 +#ifdef CONFIG_SERIAL_UBI32_SERDES
36348 +static struct resource ip5160dev_ubicom32_suart_resources[] = {
36349 + {
36350 + .start = RD,
36351 + .end = RD,
36352 + .flags = IORESOURCE_MEM,
36353 + },
36354 + {
36355 + .start = PORT_OTHER_INT(RD),
36356 + .end = PORT_OTHER_INT(RD),
36357 + .flags = IORESOURCE_IRQ,
36358 + },
36359 + {
36360 + .start = 240000000,
36361 + .end = 240000000,
36362 + .flags = UBICOM32_SUART_IORESOURCE_CLOCK,
36363 + },
36364 +};
36365 +
36366 +static struct platform_device ip5160dev_ubicom32_suart_device = {
36367 + .name = "ubicom32suart",
36368 + .id = -1,
36369 + .num_resources = ARRAY_SIZE(ip5160dev_ubicom32_suart_resources),
36370 + .resource = ip5160dev_ubicom32_suart_resources,
36371 +};
36372 +#endif
36373 +
36374 +/*
36375 + * List of all devices in our system
36376 + */
36377 +static struct platform_device *ip5160dev_devices[] __initdata = {
36378 +#ifdef CONFIG_SERIAL_UBI32_SERDES
36379 + &ip5160dev_ubicom32_suart_device,
36380 +#endif
36381 + &ip5160dev_fdb_device,
36382 +};
36383 +
36384 +/*
36385 + * ip5160dev_init
36386 + * Called to add the devices which we have on this board
36387 + */
36388 +static int __init ip5160dev_init(void)
36389 +{
36390 + ubi_gpio_init();
36391 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
36392 + platform_add_devices(ip5160dev_devices, ARRAY_SIZE(ip5160dev_devices));
36393 + return 0;
36394 +}
36395 +
36396 +arch_initcall(ip5160dev_init);
36397 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5160rgw.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5160rgw.c
36398 --- linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5160rgw.c 1970-01-01 02:00:00.000000000 +0200
36399 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5160rgw.c 2009-12-11 11:45:11.000000000 +0200
36400 @@ -0,0 +1,75 @@
36401 +/*
36402 + * arch/ubicom32/mach-ip5k/board-ip5160rgw.c
36403 + * Platform initialization for ip5160rgw board.
36404 + *
36405 + * (C) Copyright 2009, Ubicom, Inc.
36406 + *
36407 + * This file is part of the Ubicom32 Linux Kernel Port.
36408 + *
36409 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36410 + * it and/or modify it under the terms of the GNU General Public License
36411 + * as published by the Free Software Foundation, either version 2 of the
36412 + * License, or (at your option) any later version.
36413 + *
36414 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36415 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36416 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36417 + * the GNU General Public License for more details.
36418 + *
36419 + * You should have received a copy of the GNU General Public License
36420 + * along with the Ubicom32 Linux Kernel Port. If not,
36421 + * see <http://www.gnu.org/licenses/>.
36422 + *
36423 + * Ubicom32 implementation derived from (with many thanks):
36424 + * arch/m68knommu
36425 + * arch/blackfin
36426 + * arch/parisc
36427 + */
36428 +#include <linux/device.h>
36429 +#include <linux/platform_device.h>
36430 +#include <linux/gpio.h>
36431 +#include <asm/board.h>
36432 +#include <asm/machdep.h>
36433 +
36434 +/*
36435 + * Factory Default Button on the board at PXn
36436 + * TODO: This is just a placeholder and it needs to include proper header files
36437 + */
36438 +struct ubicom32fdb_platform_data {
36439 + int fdb_gpio;
36440 + bool fdb_polarity;
36441 +};
36442 +
36443 +static struct ubicom32fdb_platform_data ip5160rgw_fdb_data = {
36444 + .fdb_gpio = 0,
36445 + .fdb_polarity = true,
36446 +};
36447 +
36448 +static struct platform_device ip5160rgw_fdb_device = {
36449 + .name = "ubicom32fdb",
36450 + .id = -1,
36451 + .dev = {
36452 + .platform_data = &ip5160rgw_fdb_data,
36453 + },
36454 +};
36455 +
36456 +/*
36457 + * List of all devices in our system
36458 + */
36459 +static struct platform_device *ip5160rgw_devices[] __initdata = {
36460 + &ip5160rgw_fdb_device,
36461 +};
36462 +
36463 +/*
36464 + * ip5160rgw_init
36465 + * Called to add the devices which we have on this board
36466 + */
36467 +static int __init ip5160rgw_init(void)
36468 +{
36469 + ubi_gpio_init();
36470 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
36471 + platform_add_devices(ip5160rgw_devices, ARRAY_SIZE(ip5160rgw_devices));
36472 + return 0;
36473 +}
36474 +
36475 +arch_initcall(ip5160rgw_init);
36476 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5170dpf.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5170dpf.c
36477 --- linux-2.6.30.10/arch/ubicom32/mach-ip5k/board-ip5170dpf.c 1970-01-01 02:00:00.000000000 +0200
36478 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/board-ip5170dpf.c 2009-12-11 11:45:11.000000000 +0200
36479 @@ -0,0 +1,279 @@
36480 +/*
36481 + * arch/ubicom32/mach-ip5k/board-ip5170dpf.c
36482 + * Platform initialization for ip5160dpf board.
36483 + *
36484 + * (C) Copyright 2009, Ubicom, Inc.
36485 + *
36486 + * This file is part of the Ubicom32 Linux Kernel Port.
36487 + *
36488 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36489 + * it and/or modify it under the terms of the GNU General Public License
36490 + * as published by the Free Software Foundation, either version 2 of the
36491 + * License, or (at your option) any later version.
36492 + *
36493 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36494 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36495 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36496 + * the GNU General Public License for more details.
36497 + *
36498 + * You should have received a copy of the GNU General Public License
36499 + * along with the Ubicom32 Linux Kernel Port. If not,
36500 + * see <http://www.gnu.org/licenses/>.
36501 + *
36502 + * Ubicom32 implementation derived from (with many thanks):
36503 + * arch/m68knommu
36504 + * arch/blackfin
36505 + * arch/parisc
36506 + */
36507 +#include <linux/device.h>
36508 +#include <linux/platform_device.h>
36509 +#include <linux/gpio.h>
36510 +#include <linux/leds.h>
36511 +
36512 +#include <linux/i2c.h>
36513 +#include <linux/i2c-gpio.h>
36514 +
36515 +#include <linux/input.h>
36516 +#include <asm/board.h>
36517 +#include <asm/machdep.h>
36518 +#include <asm/ubicom32hid.h>
36519 +#include <asm/vdc_tio.h>
36520 +
36521 +/*
36522 + * LEDs
36523 + *
36524 + * WLAN PD9 (Note this is shared with MISO, but we don't use it)
36525 + * WPS PD8
36526 + *
36527 + * TODO: check triggers, are they generic?
36528 + */
36529 +static struct gpio_led ip5170dpf_gpio_leds[] = {
36530 + {
36531 + .name = "d31:green:WLAN1",
36532 + .default_trigger = "WLAN1",
36533 + .gpio = GPIO_RD_9,
36534 + .active_low = 1,
36535 + },
36536 + {
36537 + .name = "d30:green:WPS",
36538 + .default_trigger = "WPS",
36539 + .gpio = GPIO_RD_8,
36540 + .active_low = 1,
36541 + },
36542 +};
36543 +
36544 +static struct gpio_led_platform_data ip5170dpf_gpio_led_platform_data = {
36545 + .num_leds = 2,
36546 + .leds = ip5170dpf_gpio_leds,
36547 +};
36548 +
36549 +static struct platform_device ip5170dpf_gpio_leds_device = {
36550 + .name = "leds-gpio",
36551 + .id = -1,
36552 + .dev = {
36553 + .platform_data = &ip5170dpf_gpio_led_platform_data,
36554 + },
36555 +};
36556 +
36557 +/*
36558 + * Backlight on the board PD0, hardware PWM
36559 + */
36560 +static const struct ubicom32hid_button ip5170dpf_ubicom32hid_buttons[] = {
36561 + {
36562 + .type = EV_KEY,
36563 + .code = KEY_UP,
36564 + .bit = 0,
36565 + },
36566 + {
36567 + .type = EV_KEY,
36568 + .code = KEY_LEFT,
36569 + .bit = 1,
36570 + },
36571 + {
36572 + .type = EV_KEY,
36573 + .code = KEY_RIGHT,
36574 + .bit = 2,
36575 + },
36576 + {
36577 + .type = EV_KEY,
36578 + .code = KEY_DOWN,
36579 + .bit = 3,
36580 + },
36581 + {
36582 + .type = EV_KEY,
36583 + .code = KEY_ENTER,
36584 + .bit = 4,
36585 + },
36586 + {
36587 + .type = EV_KEY,
36588 + .code = KEY_MENU,
36589 + .bit = 5,
36590 + },
36591 + {
36592 + .type = EV_KEY,
36593 + .code = KEY_ESC,
36594 + .bit = 7,
36595 + },
36596 +};
36597 +
36598 +static const struct ubicom32hid_ir ip5170dpf_ubicom32hid_ircodes[] = {
36599 + {
36600 + .type = EV_KEY,
36601 + .code = KEY_UP,
36602 + .ir_code = 0xF807916E
36603 + },
36604 + {
36605 + .type = EV_KEY,
36606 + .code = KEY_DOWN,
36607 + .ir_code = 0xF20D916E
36608 + },
36609 + {
36610 + .type = EV_KEY,
36611 + .code = KEY_LEFT,
36612 + .ir_code = 0xF609916E
36613 + },
36614 + {
36615 + .type = EV_KEY,
36616 + .code = KEY_RIGHT,
36617 + .ir_code = 0xF40B916E
36618 + },
36619 + {
36620 + .type = EV_KEY,
36621 + .code = KEY_ENTER,
36622 + .ir_code = 0xF50A916E
36623 + },
36624 + { /* rotate */
36625 + .type = EV_KEY,
36626 + .code = KEY_FN_F1,
36627 + .ir_code = 0xF906916E
36628 + },
36629 + {
36630 + .type = EV_KEY,
36631 + .code = KEY_MENU,
36632 + .ir_code = 0xF708916E
36633 + },
36634 + { /* font size */
36635 + .type = EV_KEY,
36636 + .code = KEY_FN_F2,
36637 + .ir_code = 0xF30C916E
36638 + },
36639 + {
36640 + .type = EV_KEY,
36641 + .code = KEY_ESC,
36642 + .ir_code = 0xF10E916E
36643 + },
36644 + {
36645 + .type = EV_KEY,
36646 + .code = KEY_VOLUMEUP,
36647 + .ir_code = 0xF00F916E
36648 + },
36649 + {
36650 + .type = EV_KEY,
36651 + .code = KEY_VOLUMEDOWN,
36652 + .ir_code = 0xED12916E
36653 + },
36654 + {
36655 + .type = EV_KEY,
36656 + .code = KEY_MUTE,
36657 + .ir_code = 0xEA15916E
36658 + },
36659 + {
36660 + .type = EV_KEY,
36661 + .code = KEY_INFO,
36662 + .ir_code = 0xEF10916E
36663 + },
36664 + { /* Like */
36665 + .type = EV_KEY,
36666 + .code = KEY_FN_F3,
36667 + .ir_code = 0xEE11916E
36668 + },
36669 + { /* Dislike */
36670 + .type = EV_KEY,
36671 + .code = KEY_FN_F4,
36672 + .ir_code = 0xEB14916E
36673 + },
36674 + {
36675 + .type = EV_KEY,
36676 + .code = KEY_POWER,
36677 + .ir_code = 0xFD02916E
36678 + },
36679 +};
36680 +
36681 +static struct ubicom32hid_platform_data ip5170dpf_ubicom32hid_platform_data = {
36682 + .gpio_reset = GPIO_RA_4,
36683 + .gpio_reset_polarity = 0,
36684 + .type = UBICOM32HID_BL_TYPE_BINARY,
36685 + .invert = 0,
36686 + .default_intensity = 1,
36687 + .buttons = ip5170dpf_ubicom32hid_buttons,
36688 + .nbuttons = ARRAY_SIZE(ip5170dpf_ubicom32hid_buttons),
36689 + .ircodes = ip5170dpf_ubicom32hid_ircodes,
36690 + .nircodes = ARRAY_SIZE(ip5170dpf_ubicom32hid_ircodes),
36691 +};
36692 +
36693 +/*
36694 + * Devices on the I2C bus
36695 + */
36696 +static struct i2c_board_info __initdata ip5170dpf_i2c_board_info[] = {
36697 + /*
36698 + * U24, ubicom32hid
36699 + */
36700 + {
36701 + .type = "ubicom32hid",
36702 + .addr = 0x08,
36703 + .platform_data = &ip5170dpf_ubicom32hid_platform_data,
36704 + },
36705 +
36706 + /*
36707 + * U14, CS4350 DAC, address 0x4B
36708 + */
36709 +};
36710 +
36711 +/*
36712 + * I2C bus on the board, SDA PF13, SCL PF14
36713 + */
36714 +static struct i2c_gpio_platform_data ip5170dpf_i2c_data = {
36715 + .sda_pin = GPIO_RF_13,
36716 + .scl_pin = GPIO_RF_14,
36717 + .sda_is_open_drain = 0,
36718 + .scl_is_open_drain = 0,
36719 + .scl_is_output_only = 1,
36720 + .udelay = 5,
36721 +};
36722 +
36723 +static struct platform_device ip5170dpf_i2c_device = {
36724 + .name = "i2c-gpio",
36725 + .id = 0,
36726 + .dev = {
36727 + .platform_data = &ip5170dpf_i2c_data,
36728 + },
36729 +};
36730 +
36731 +/*
36732 + * List of all devices in our system
36733 + */
36734 +static struct platform_device *ip5170dpf_devices[] __initdata = {
36735 + &ip5170dpf_i2c_device,
36736 + &ip5170dpf_gpio_leds_device,
36737 +};
36738 +
36739 +/*
36740 + * ip5170dpf_init
36741 + * Called to add the devices which we have on this board
36742 + */
36743 +static int __init ip5170dpf_init(void)
36744 +{
36745 + ubi_gpio_init();
36746 +
36747 + vdc_tio_init();
36748 +
36749 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
36750 + platform_add_devices(ip5170dpf_devices, ARRAY_SIZE(ip5170dpf_devices));
36751 +
36752 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
36753 + i2c_register_board_info(0, ip5170dpf_i2c_board_info, ARRAY_SIZE(ip5170dpf_i2c_board_info));
36754 +
36755 + return 0;
36756 +}
36757 +
36758 +arch_initcall(ip5170dpf_init);
36759 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip5k/Kconfig linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/Kconfig
36760 --- linux-2.6.30.10/arch/ubicom32/mach-ip5k/Kconfig 1970-01-01 02:00:00.000000000 +0200
36761 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/Kconfig 2009-12-11 11:45:11.000000000 +0200
36762 @@ -0,0 +1,28 @@
36763 +
36764 +config IP5170DPF
36765 + bool "IP5170DPF"
36766 + select UBICOM32_V3
36767 + select I2C
36768 + select I2C_GPIO
36769 + select FB
36770 + select FB_UBICOM32
36771 + select BACKLIGHT_LCD_SUPPORT
36772 + select BACKLIGHT_CLASS_DEVICE
36773 + select UBICOM_HID
36774 + select NEW_LEDS
36775 + select LEDS_CLASS
36776 + select LEDS_GPIO
36777 + help
36778 + IP5170 Digital Picture Frame board, 8005-1113, IP5K-BEV-0011-13 v1.3
36779 +
36780 +config IP5160DEV
36781 + bool "IP5160Dev_Ver1Dot1"
36782 + select UBICOM32_V3
36783 + help
36784 + Ubicom StreamEngine 5000 Development Board, IP5K-BDV-0004-11 v1.1
36785 +
36786 +config IP5160EVAL
36787 + bool "IP5160RGWEval_Ver2Rev2"
36788 + select UBICOM32_V3
36789 + help
36790 + Ubicom StreamEngine 5000 RGW Evaluation Board, IP5K-RGW-0004-11 v2.2
36791 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip5k/Makefile linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/Makefile
36792 --- linux-2.6.30.10/arch/ubicom32/mach-ip5k/Makefile 1970-01-01 02:00:00.000000000 +0200
36793 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip5k/Makefile 2009-12-11 11:45:11.000000000 +0200
36794 @@ -0,0 +1,31 @@
36795 +#
36796 +# arch/ubicom32/mach-ip5k/Makefile
36797 +# Makefile for boards which have an ip5k on them.
36798 +#
36799 +# (C) Copyright 2009, Ubicom, Inc.
36800 +#
36801 +# This file is part of the Ubicom32 Linux Kernel Port.
36802 +#
36803 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
36804 +# it and/or modify it under the terms of the GNU General Public License
36805 +# as published by the Free Software Foundation, either version 2 of the
36806 +# License, or (at your option) any later version.
36807 +#
36808 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
36809 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
36810 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36811 +# the GNU General Public License for more details.
36812 +#
36813 +# You should have received a copy of the GNU General Public License
36814 +# along with the Ubicom32 Linux Kernel Port. If not,
36815 +# see <http://www.gnu.org/licenses/>.
36816 +#
36817 +# Ubicom32 implementation derived from (with many thanks):
36818 +# arch/m68knommu
36819 +# arch/blackfin
36820 +# arch/parisc
36821 +#
36822 +
36823 +obj-$(CONFIG_IP5170DPF) += board-ip5170dpf.o
36824 +obj-$(CONFIG_IP5160DEV) += board-ip5160dev.o
36825 +obj-$(CONFIG_IP5160EVAL) += board-ip5160rgw.o
36826 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7145dpf.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7145dpf.c
36827 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7145dpf.c 1970-01-01 02:00:00.000000000 +0200
36828 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7145dpf.c 2009-12-11 11:45:11.000000000 +0200
36829 @@ -0,0 +1,715 @@
36830 +/*
36831 + * arch/ubicom32/mach-ip7k/board-ip7145dpf.c
36832 + * Board file for IP7145DPF, rev 1.0, P/N 8007-0410
36833 + *
36834 + * (C) Copyright 2009, Ubicom, Inc.
36835 + *
36836 + * This file is part of the Ubicom32 Linux Kernel Port.
36837 + *
36838 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
36839 + * it and/or modify it under the terms of the GNU General Public License
36840 + * as published by the Free Software Foundation, either version 2 of the
36841 + * License, or (at your option) any later version.
36842 + *
36843 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
36844 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
36845 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
36846 + * the GNU General Public License for more details.
36847 + *
36848 + * You should have received a copy of the GNU General Public License
36849 + * along with the Ubicom32 Linux Kernel Port. If not,
36850 + * see <http://www.gnu.org/licenses/>.
36851 + *
36852 + * Ubicom32 implementation derived from (with many thanks):
36853 + * arch/m68knommu
36854 + * arch/blackfin
36855 + * arch/parisc
36856 + */
36857 +#include <linux/device.h>
36858 +#include <linux/platform_device.h>
36859 +#include <linux/gpio.h>
36860 +
36861 +#include <linux/input.h>
36862 +
36863 +#include <linux/i2c.h>
36864 +#include <linux/i2c-gpio.h>
36865 +#include <linux/i2c/pca953x.h>
36866 +
36867 +#include <asm/board.h>
36868 +#include <asm/machdep.h>
36869 +#include <asm/ubicom32input.h>
36870 +#include <asm/ubicom32input_i2c.h>
36871 +#include <asm/ubicom32bl.h>
36872 +#include <asm/ubicom32lcdpower.h>
36873 +#include <asm/vdc_tio.h>
36874 +
36875 +#include <asm/ubicom32sd.h>
36876 +#include <asm/sd_tio.h>
36877 +#include <asm/devtree.h>
36878 +#include <asm/audio.h>
36879 +
36880 +#include <asm/ring_tio.h>
36881 +
36882 +/******************************************************************************
36883 + * SD/IO Port F (Slot 1) platform data
36884 + */
36885 +static struct resource ip7145dpf_portf_sd_resources[] = {
36886 + /*
36887 + * Send IRQ
36888 + */
36889 + [0] = {
36890 + /*
36891 + * The init routine will query the devtree and fill this in
36892 + */
36893 + .flags = IORESOURCE_IRQ,
36894 + },
36895 +
36896 + /*
36897 + * Receive IRQ
36898 + */
36899 + [1] = {
36900 + /*
36901 + * The init routine will query the devtree and fill this in
36902 + */
36903 + .flags = IORESOURCE_IRQ,
36904 + },
36905 +
36906 + /*
36907 + * Memory Mapped Registers
36908 + */
36909 + [2] = {
36910 + /*
36911 + * The init routine will query the devtree and fill this in
36912 + */
36913 + .flags = IORESOURCE_MEM,
36914 + },
36915 +};
36916 +
36917 +static struct ubicom32sd_card ip7145dpf_portf_sd_cards[] = {
36918 + [0] = {
36919 + .pin_wp = IP7145DPF_IOB0,
36920 + .wp_polarity = 1,
36921 + .pin_pwr = IP7145DPF_IOB4,
36922 + .pin_cd = GPIO_RA_4,
36923 + },
36924 + [1] = {
36925 + .pin_wp = IP7145DPF_IOB1,
36926 + .wp_polarity = 1,
36927 + .pin_pwr = IP7145DPF_IOB5,
36928 + .pin_cd = GPIO_RA_6,
36929 + },
36930 +};
36931 +
36932 +static struct ubicom32sd_platform_data ip7145dpf_portf_sd_platform_data = {
36933 + .ncards = 2,
36934 + .cards = ip7145dpf_portf_sd_cards,
36935 +};
36936 +
36937 +static struct platform_device ip7145dpf_portf_sd_device = {
36938 + .name = "ubicom32sd",
36939 + .id = 0,
36940 + .resource = ip7145dpf_portf_sd_resources,
36941 + .num_resources = ARRAY_SIZE(ip7145dpf_portf_sd_resources),
36942 + .dev = {
36943 + .platform_data = &ip7145dpf_portf_sd_platform_data,
36944 + },
36945 +
36946 +};
36947 +
36948 +/*
36949 + * ip7145dpf_portf_sd_init
36950 + */
36951 +static void ip7145dpf_portf_sd_init(void)
36952 +{
36953 + /*
36954 + * Check the device tree for the sd_tio
36955 + */
36956 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portf_sd");
36957 + if (!sd_node) {
36958 + printk(KERN_INFO "PortF SDTIO not found\n");
36959 + return;
36960 + }
36961 +
36962 + /*
36963 + * Fill in the resources and platform data from devtree information
36964 + */
36965 + ip7145dpf_portf_sd_resources[0].start = sd_node->dn.sendirq;
36966 + ip7145dpf_portf_sd_resources[1].start = sd_node->dn.recvirq;
36967 + ip7145dpf_portf_sd_resources[2].start = (u32_t)&(sd_node->regs);
36968 + ip7145dpf_portf_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
36969 +
36970 + platform_device_register(&ip7145dpf_portf_sd_device);
36971 +}
36972 +
36973 +/******************************************************************************
36974 + * SD/IO Port B (Slot 2) platform data
36975 + */
36976 +static struct resource ip7145dpf_portb_sd_resources[] = {
36977 + /*
36978 + * Send IRQ
36979 + */
36980 + [0] = {
36981 + /*
36982 + * The init routine will query the devtree and fill this in
36983 + */
36984 + .flags = IORESOURCE_IRQ,
36985 + },
36986 +
36987 + /*
36988 + * Receive IRQ
36989 + */
36990 + [1] = {
36991 + /*
36992 + * The init routine will query the devtree and fill this in
36993 + */
36994 + .flags = IORESOURCE_IRQ,
36995 + },
36996 +
36997 + /*
36998 + * Memory Mapped Registers
36999 + */
37000 + [2] = {
37001 + /*
37002 + * The init routine will query the devtree and fill this in
37003 + */
37004 + .flags = IORESOURCE_MEM,
37005 + },
37006 +};
37007 +
37008 +static struct ubicom32sd_card ip7145dpf_portb_sd_cards[] = {
37009 + [0] = {
37010 + .pin_wp = IP7145DPF_IOB2,
37011 + .wp_polarity = 1,
37012 + .pin_pwr = IP7145DPF_IOB6,
37013 + .pin_cd = IP7145DPF_IOB3,
37014 + },
37015 +};
37016 +
37017 +static struct ubicom32sd_platform_data ip7145dpf_portb_sd_platform_data = {
37018 + .ncards = 1,
37019 + .cards = ip7145dpf_portb_sd_cards,
37020 +};
37021 +
37022 +static struct platform_device ip7145dpf_portb_sd_device = {
37023 + .name = "ubicom32sd",
37024 + .id = 1,
37025 + .resource = ip7145dpf_portb_sd_resources,
37026 + .num_resources = ARRAY_SIZE(ip7145dpf_portb_sd_resources),
37027 + .dev = {
37028 + .platform_data = &ip7145dpf_portb_sd_platform_data,
37029 + },
37030 +
37031 +};
37032 +
37033 +/*
37034 + * ip7145dpf_portb_sd_init
37035 + */
37036 +static void ip7145dpf_portb_sd_init(void)
37037 +{
37038 + /*
37039 + * Check the device tree for the sd_tio
37040 + */
37041 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portb_sd");
37042 + if (!sd_node) {
37043 + printk(KERN_INFO "PortB SDTIO not found\n");
37044 + return;
37045 + }
37046 +
37047 + /*
37048 + * Fill in the resources and platform data from devtree information
37049 + */
37050 + ip7145dpf_portb_sd_resources[0].start = sd_node->dn.sendirq;
37051 + ip7145dpf_portb_sd_resources[1].start = sd_node->dn.recvirq;
37052 + ip7145dpf_portb_sd_resources[2].start = (u32_t)&(sd_node->regs);
37053 + ip7145dpf_portb_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
37054 +
37055 + platform_device_register(&ip7145dpf_portb_sd_device);
37056 +}
37057 +
37058 +
37059 +#ifdef IP7145DPF_USE_MMC_SPI
37060 +/******************************************************************************
37061 + * SPI over GPIO (MMC_SPI)
37062 + */
37063 +#include <linux/spi/spi.h>
37064 +#include <linux/spi/mmc_spi.h>
37065 +#include <linux/mmc/host.h>
37066 +#include <asm/ubicom32-spi-gpio.h>
37067 +
37068 +#define MMC_CS GPIO_RF_5 // PF5 D3
37069 +#define MMC_CD GPIO_RA_4 // PA4 CD
37070 +#define MMC_WP IP7145DPF_IOB0 // IOB0 WP
37071 +#define MMC_PWR IP7145DPF_IOB4 // IOB4 PWR
37072 +
37073 +/*
37074 + * SPI bus over GPIO (for SD card)
37075 + */
37076 +static struct ubicom32_spi_gpio_platform_data ip7145dpf_spi_gpio_data = {
37077 + .pin_mosi = GPIO_RF_0, // PF0 CMD
37078 + .pin_miso = GPIO_RF_2, // PF2 D0
37079 + .pin_clk = GPIO_RF_1, // PF1 CLK
37080 + .bus_num = 0, // We'll call this SPI bus 0
37081 + .num_chipselect = 1, // only one device on this SPI bus
37082 +};
37083 +
37084 +static struct platform_device ip7145dpf_spi_gpio_device = {
37085 + .name = "ubicom32-spi-gpio",
37086 + .id = 0,
37087 + .dev = {
37088 + .platform_data = &ip7145dpf_spi_gpio_data,
37089 + },
37090 +};
37091 +
37092 +/*
37093 + * ip7145dpf_mmc_spi_setpower_slot_a
37094 + * Set the power state for slot A
37095 + */
37096 +static void ip7145dpf_mmc_spi_setpower_slot_a(struct device *dev, unsigned int vdd)
37097 +{
37098 + struct mmc_spi_platform_data *pd = dev->platform_data;
37099 +
37100 + /*
37101 + * Power is inverted, we could tell the IOB to do it, but it's cleaner this way.
37102 + */
37103 + if ((1 << vdd) & pd->ocr_mask) {
37104 + gpio_set_value(MMC_PWR, 0);
37105 + return;
37106 + }
37107 + gpio_set_value(MMC_PWR, 1);
37108 +}
37109 +
37110 +/*
37111 + * ip7145dpf_mmc_spi_get_cd_slot_a
37112 + * Get the CD bit for slot A
37113 + */
37114 +static int ip7145dpf_mmc_spi_get_cd_slot_a(struct device *dev)
37115 +{
37116 + /*
37117 + * Note that the sense of the GPIO is inverted
37118 + */
37119 + return !gpio_get_value(MMC_CD);
37120 +}
37121 +
37122 +/*
37123 + * ip7145dpf_mmc_spi_get_ro_slot_a
37124 + * Get the WP bit for slot A
37125 + */
37126 +static int ip7145dpf_mmc_spi_get_ro_slot_a(struct device *dev)
37127 +{
37128 + /*
37129 + * Note that the sense of the GPIO is inverted, we could tell the IOB to do it, but
37130 + * it's clearer this way.
37131 + */
37132 + return !gpio_get_value(MMC_WP);
37133 +}
37134 +
37135 +/*
37136 + * ip7145dpf_mmc_spi_exit_slot_a
37137 + * Free the appropriate GPIOs for slot A SD slot.
37138 + */
37139 +static void ip7145dpf_mmc_spi_exit_slot_a(struct device *dev, void *appdata)
37140 +{
37141 + gpio_free(MMC_CD);
37142 + gpio_free(MMC_CS);
37143 + gpio_free(MMC_WP);
37144 + gpio_free(MMC_PWR);
37145 + platform_device_unregister(&ip7145dpf_spi_gpio_device);
37146 +}
37147 +
37148 +/*
37149 + * ip7145dpf_mmc_spi_init_slot_a
37150 + * Allocate the appropriate GPIOs for slot A SD slot.
37151 + * WP is on IOB0, CD is PA4, CS is on PF5
37152 + * TODO: make CD an interrupt
37153 + */
37154 +static int ip7145dpf_mmc_spi_init_slot_a(void)
37155 +{
37156 + int ret = gpio_request(MMC_CD, "mmc-a-cd");
37157 + if (ret) {
37158 + printk(KERN_ERR "%s: could not request mmc-a-cd pin\n", __FUNCTION__);
37159 + return -ENOSYS;
37160 + }
37161 + gpio_direction_input(MMC_CD);
37162 +
37163 + ret = gpio_request(MMC_CS, "mmc-a-cs");
37164 + if (ret) {
37165 + printk(KERN_ERR "%s: could not request mmc-a-cs pin\n", __FUNCTION__);
37166 + goto no_cs;
37167 + }
37168 + gpio_direction_output(MMC_CS, 0);
37169 +
37170 + ret = gpio_request(MMC_WP, "mmc-a-wp");
37171 + if (ret) {
37172 + printk(KERN_ERR "%s: could not request mmc-a-wp pin\n", __FUNCTION__);
37173 + goto no_wp;
37174 + }
37175 + gpio_direction_input(MMC_WP);
37176 +
37177 + /*
37178 + * Start off with power off
37179 + */
37180 + ret = gpio_request(MMC_PWR, "mmc-a-pwr");
37181 + if (ret) {
37182 + printk(KERN_ERR "%s: could not request mmc-a-pwr pin\n", __FUNCTION__);
37183 + goto no_pwr;
37184 + }
37185 + ret = gpio_direction_output(MMC_PWR, 1);
37186 +
37187 + return 0;
37188 +
37189 +no_pwr:
37190 + gpio_free(MMC_WP);
37191 +
37192 +no_wp:
37193 + gpio_free(MMC_CS);
37194 +
37195 +no_cs:
37196 + gpio_free(MMC_CD);
37197 + return -ENOSYS;
37198 +}
37199 +
37200 +/*
37201 + * MMC_SPI driver (currently bitbang)
37202 + */
37203 +static struct mmc_spi_platform_data ip7145dpf_mmc_platform_data = {
37204 + .ocr_mask = MMC_VDD_33_34,
37205 + .exit = ip7145dpf_mmc_spi_exit_slot_a,
37206 + .get_ro = ip7145dpf_mmc_spi_get_ro_slot_a,
37207 + .get_cd = ip7145dpf_mmc_spi_get_cd_slot_a,
37208 +
37209 + .setpower = ip7145dpf_mmc_spi_setpower_slot_a,
37210 + .powerup_msecs = 500,
37211 +
37212 + .detect_delay = 100,
37213 +
37214 + .caps = MMC_CAP_NEEDS_POLL,
37215 +};
37216 +
37217 +static struct ubicom32_spi_gpio_controller_data ip7145dpf_mmc_controller_data = {
37218 + .pin_cs = MMC_CS,
37219 +};
37220 +
37221 +static struct spi_board_info ip7145dpf_spi_board_info[] = {
37222 + {
37223 + .modalias = "mmc_spi",
37224 + .bus_num = 0,
37225 + .chip_select = 0,
37226 + .max_speed_hz = 2000000,
37227 + .platform_data = &ip7145dpf_mmc_platform_data,
37228 + .controller_data = &ip7145dpf_mmc_controller_data,
37229 + }
37230 +};
37231 +#endif /* IP7145DPF_USE_MMC_SPI */
37232 +
37233 +/*
37234 + * ip7145dpf_u72_setup
37235 + * Called by I2C to tell us that u72 is setup.
37236 + *
37237 + * This function is called by I2C to tell us that u72 has been setup. All
37238 + * devices which rely on this chip being initialized (or even present) need to
37239 + * be initialized in this function otherwise they may get initialized too early.
37240 + *
37241 + * Currently the only device depending on u72 is the SPI
37242 + */
37243 +static int __init ip7145dpf_u72_setup(struct i2c_client *client, unsigned gpio, unsigned ngpio, void *context)
37244 +{
37245 +#ifdef IP7145DPF_USE_MMC_SPI
37246 + if (ip7145dpf_mmc_spi_init_slot_a()) {
37247 + printk(KERN_ERR "%s: could not request mmc resources\n", __FUNCTION__);
37248 + } else {
37249 + printk(KERN_INFO "%s: registering SPI resources\n", __FUNCTION__);
37250 + spi_register_board_info(ip7145dpf_spi_board_info, ARRAY_SIZE(ip7145dpf_spi_board_info));
37251 + platform_device_register(&ip7145dpf_spi_gpio_device);
37252 + }
37253 +#else
37254 + /*
37255 + * Initialize the Port F/Port B SD slots
37256 + */
37257 + ip7145dpf_portf_sd_init();
37258 + ip7145dpf_portb_sd_init();
37259 +#endif
37260 + return 0;
37261 +}
37262 +
37263 +/******************************************************************************
37264 + * LCD VGH on the board at PE6
37265 + */
37266 +static struct ubicom32lcdpower_platform_data ip7145dpf_lcdpower_data = {
37267 + .vgh_gpio = GPIO_RE_6,
37268 + .vgh_polarity = true,
37269 +};
37270 +
37271 +static struct platform_device ip7145dpf_lcdpower_device = {
37272 + .name = "ubicom32lcdpower",
37273 + .id = -1,
37274 + .dev = {
37275 + .platform_data = &ip7145dpf_lcdpower_data,
37276 + },
37277 +};
37278 +
37279 +/******************************************************************************
37280 + * Backlight on the board PD0, hardware PWM
37281 + */
37282 +static struct ubicom32bl_platform_data ip7145dpf_backlight_data = {
37283 + .type = UBICOM32BL_TYPE_PWM,
37284 + .pwm_channel = 2,
37285 + .pwm_prescale = 15,
37286 + .pwm_period = 60,
37287 + .default_intensity = 0x80,
37288 +};
37289 +
37290 +static struct platform_device ip7145dpf_backlight_device = {
37291 + .name = "ubicom32bl",
37292 + .id = -1,
37293 + .dev = {
37294 + .platform_data = &ip7145dpf_backlight_data,
37295 + },
37296 +};
37297 +
37298 +/******************************************************************************
37299 + * Ubicom32Input on I2C, U48 MAX7310, address 0x18, 8 bits
37300 + */
37301 +static struct ubicom32input_i2c_button ip7145dpf_ubicom32input_i2c_u48_buttons[] = {
37302 + {
37303 + .type = EV_KEY,
37304 + .code = KEY_UP,
37305 + .bit = 0,
37306 + .active_low = 1,
37307 + },
37308 + {
37309 + .type = EV_KEY,
37310 + .code = KEY_LEFT,
37311 + .bit = 1,
37312 + .active_low = 1,
37313 + },
37314 + {
37315 + .type = EV_KEY,
37316 + .code = KEY_RIGHT,
37317 + .bit = 2,
37318 + .active_low = 1,
37319 + },
37320 + {
37321 + .type = EV_KEY,
37322 + .code = KEY_DOWN,
37323 + .bit = 3,
37324 + .active_low = 1,
37325 + },
37326 + {
37327 + .type = EV_KEY,
37328 + .code = KEY_ENTER,
37329 + .bit = 4,
37330 + .active_low = 1,
37331 + },
37332 + {
37333 + .type = EV_KEY,
37334 + .code = KEY_MENU,
37335 + .bit = 5,
37336 + .active_low = 1,
37337 + },
37338 + {
37339 + .type = EV_KEY,
37340 + .code = KEY_ESC,
37341 + .bit = 6,
37342 + .active_low = 1,
37343 + },
37344 +};
37345 +
37346 +static struct ubicom32input_i2c_platform_data ip7145dpf_ubicom32input_i2c_u48_platform_data = {
37347 + .buttons = ip7145dpf_ubicom32input_i2c_u48_buttons,
37348 + .nbuttons = ARRAY_SIZE(ip7145dpf_ubicom32input_i2c_u48_buttons),
37349 + .name = "Ubicom32 Input I2C U48",
37350 +};
37351 +
37352 +/******************************************************************************
37353 + * Additional GPIO chips
37354 + */
37355 +static struct pca953x_platform_data ip7145dpf_gpio_u72_platform_data = {
37356 + .gpio_base = IP7145DPF_U72_BASE,
37357 + .setup = ip7145dpf_u72_setup,
37358 +};
37359 +
37360 +/******************************************************************************
37361 + * Devices on the I2C bus
37362 + */
37363 +static struct i2c_board_info __initdata ip7145dpf_i2c_board_info[] = {
37364 + /*
37365 + * U51, S35390A RTC, address 0x30
37366 + */
37367 + {
37368 + .type = "s35390a",
37369 + .addr = 0x30,
37370 + },
37371 +
37372 + /*
37373 + * U48, MAX7310 IO expander, 8 bits, address 0x18
37374 + */
37375 + {
37376 + .type = "ubicom32in_max7310",
37377 + .addr = 0x18,
37378 + .platform_data = &ip7145dpf_ubicom32input_i2c_u48_platform_data,
37379 + },
37380 +
37381 + /*
37382 + * U72, MAX7310 IOB expander, 8 bits, address 0x19
37383 + */
37384 + {
37385 + .type = "max7310",
37386 + .addr = 0x19,
37387 + .platform_data = &ip7145dpf_gpio_u72_platform_data,
37388 + },
37389 +};
37390 +
37391 +/*
37392 + * I2C bus on the board, SDA PE1, SCL PE2
37393 + */
37394 +static struct i2c_gpio_platform_data ip7145dpf_i2c_data = {
37395 + .sda_pin = GPIO_RE_1,
37396 + .scl_pin = GPIO_RE_2,
37397 + .sda_is_open_drain = 0,
37398 + .scl_is_open_drain = 0,
37399 +};
37400 +
37401 +static struct platform_device ip7145dpf_i2c_device = {
37402 + .name = "i2c-gpio",
37403 + .id = 0,
37404 + .dev = {
37405 + .platform_data = &ip7145dpf_i2c_data,
37406 + },
37407 +};
37408 +
37409 +/******************************************************************************
37410 + * Use ubicom32input driver to monitor the various pushbuttons on this board.
37411 + *
37412 + * WPS PF12
37413 + * FACT_DEFAULT PF13
37414 + * POWER PE4
37415 + *
37416 + * Not sutable for the keypad buttons since those run on I2C GPIO. The polling
37417 + * of ubicom32input would seem to be excessive for this.
37418 + *
37419 + * TODO: pick some ubicom understood EV_xxx define for WPS and Fact Default
37420 + */
37421 +static struct ubicom32input_button ip7145dpf_ubicom32input_buttons[] = {
37422 + {
37423 + .type = EV_KEY,
37424 + .code = KEY_FN_F1,
37425 + .gpio = GPIO_RF_12,
37426 + .desc = "WPS",
37427 + .active_low = 1,
37428 + },
37429 + {
37430 + .type = EV_KEY,
37431 + .code = KEY_FN_F2,
37432 + .gpio = GPIO_RF_13,
37433 + .desc = "Factory Default",
37434 + .active_low = 1,
37435 + },
37436 + {
37437 + .type = EV_KEY,
37438 + .code = KEY_POWER,
37439 + .gpio = GPIO_RE_4,
37440 + .desc = "Power",
37441 + .active_low = 1,
37442 + },
37443 +};
37444 +
37445 +static struct ubicom32input_platform_data ip7145dpf_ubicom32input_data = {
37446 + .buttons = ip7145dpf_ubicom32input_buttons,
37447 + .nbuttons = ARRAY_SIZE(ip7145dpf_ubicom32input_buttons),
37448 +};
37449 +
37450 +static struct platform_device ip7145dpf_ubicom32input_device = {
37451 + .name = "ubicom32input",
37452 + .id = -1,
37453 + .dev = {
37454 + .platform_data = &ip7145dpf_ubicom32input_data,
37455 + },
37456 +};
37457 +
37458 +/*
37459 + * List of all devices in our system
37460 + */
37461 +static struct platform_device *ip7145dpf_devices[] __initdata = {
37462 + &ip7145dpf_i2c_device,
37463 + &ip7145dpf_lcdpower_device,
37464 + &ip7145dpf_backlight_device,
37465 + &ip7145dpf_ubicom32input_device,
37466 +};
37467 +
37468 +/*
37469 + * ip7145dpf_power_off
37470 + * Called to turn the power off for this board
37471 + */
37472 +static void ip7145dpf_power_off(void)
37473 +{
37474 + gpio_set_value(GPIO_RE_5, 0);
37475 +}
37476 +
37477 +/*
37478 + * ip7145dpf_init
37479 + * Called to add the devices which we have on this board
37480 + */
37481 +static int __init ip7145dpf_init(void)
37482 +{
37483 + int ret;
37484 + struct platform_device *audio_dev;
37485 +
37486 + ubi_gpio_init();
37487 +
37488 +#ifdef CONFIG_UIO_UBICOM32RING
37489 + ring_tio_init("decoder_ring");
37490 +#endif
37491 +
37492 + /*
37493 + * Start up the video driver first
37494 + */
37495 + vdc_tio_init();
37496 +
37497 + /*
37498 + * Take over holding of the power from the system
37499 + */
37500 + ret = gpio_request(GPIO_RE_5, "power_hold");
37501 + if (ret) {
37502 + printk(KERN_ERR "%s: could not request power hold GPIO\n", __FUNCTION__);
37503 + }
37504 + gpio_direction_output(GPIO_RE_5, 1);
37505 + mach_power_off = ip7145dpf_power_off;
37506 +
37507 + /*
37508 + * USB SEL_HOST_USB line
37509 + */
37510 + ret = gpio_request(GPIO_RF_11, "SEL_HOST_USB");
37511 + if (ret) {
37512 + printk(KERN_ERR "%s: could not request SEL_HOST_USB GPIO\n", __FUNCTION__);
37513 + }
37514 + gpio_direction_output(GPIO_RF_11, 0);
37515 +
37516 + /*
37517 + * Setup audio
37518 + */
37519 + audio_dev = audio_device_alloc("snd-ubi32-generic", "audio", "audio-i2sout", 0);
37520 + if (audio_dev) {
37521 + platform_device_register(audio_dev);
37522 + }
37523 +
37524 + /*
37525 + * Register all of the devices we have on this board
37526 + */
37527 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
37528 + platform_add_devices(ip7145dpf_devices, ARRAY_SIZE(ip7145dpf_devices));
37529 +
37530 + /*
37531 + * Register all of the devices which sit on the I2C bus
37532 + */
37533 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
37534 + i2c_register_board_info(0, ip7145dpf_i2c_board_info, ARRAY_SIZE(ip7145dpf_i2c_board_info));
37535 +
37536 + /*
37537 + * We have to initialize the SPI after the I2C IOB gets setup. SPI is initialized in
37538 + * ip7145dpf_u72_setup
37539 + */
37540 +
37541 + return 0;
37542 +}
37543 +
37544 +arch_initcall(ip7145dpf_init);
37545 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160bringup.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160bringup.c
37546 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160bringup.c 1970-01-01 02:00:00.000000000 +0200
37547 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160bringup.c 2009-12-11 11:45:11.000000000 +0200
37548 @@ -0,0 +1,134 @@
37549 +/*
37550 + * arch/ubicom32/mach-ip7k/board-ip7160bringup.c
37551 + * Support for the IP7160 bringup board.
37552 + *
37553 + * (C) Copyright 2009, Ubicom, Inc.
37554 + *
37555 + * This file is part of the Ubicom32 Linux Kernel Port.
37556 + *
37557 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
37558 + * it and/or modify it under the terms of the GNU General Public License
37559 + * as published by the Free Software Foundation, either version 2 of the
37560 + * License, or (at your option) any later version.
37561 + *
37562 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
37563 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
37564 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
37565 + * the GNU General Public License for more details.
37566 + *
37567 + * You should have received a copy of the GNU General Public License
37568 + * along with the Ubicom32 Linux Kernel Port. If not,
37569 + * see <http://www.gnu.org/licenses/>.
37570 + *
37571 + * Ubicom32 implementation derived from (with many thanks):
37572 + * arch/m68knommu
37573 + * arch/blackfin
37574 + * arch/parisc
37575 + */
37576 +#include <linux/device.h>
37577 +#include <linux/platform_device.h>
37578 +#include <linux/gpio.h>
37579 +#include <linux/leds.h>
37580 +#include <linux/delay.h>
37581 +#include <linux/input.h>
37582 +
37583 +#include <asm/board.h>
37584 +#include <asm/machdep.h>
37585 +#include <asm/ubicom32input.h>
37586 +
37587 +#ifdef CONFIG_SERIAL_UBI32_SERDES
37588 +#include <asm/ubicom32suart.h>
37589 +#endif
37590 +
37591 +/*
37592 + * Use ubicom32input driver to monitor the various pushbuttons on this board.
37593 + *
37594 + * WPS PD5
37595 + * FACT_DEFAULT PD6
37596 + *
37597 + * TODO: pick some ubicom understood EV_xxx define for WPS and Fact Default
37598 + */
37599 +static struct ubicom32input_button ip7160bringup_ubicom32input_buttons[] = {
37600 + {
37601 + .type = EV_KEY,
37602 + .code = KEY_FN_F1,
37603 + .gpio = GPIO_RD_5,
37604 + .desc = "WPS",
37605 + .active_low = 1,
37606 + },
37607 + {
37608 + .type = EV_KEY,
37609 + .code = KEY_FN_F2,
37610 + .gpio = GPIO_RD_6,
37611 + .desc = "Factory Default",
37612 + .active_low = 1,
37613 + },
37614 +};
37615 +
37616 +static struct ubicom32input_platform_data ip7160bringup_ubicom32input_data = {
37617 + .buttons = ip7160bringup_ubicom32input_buttons,
37618 + .nbuttons = ARRAY_SIZE(ip7160bringup_ubicom32input_buttons),
37619 +};
37620 +
37621 +static struct platform_device ip7160bringup_ubicom32input_device = {
37622 + .name = "ubicom32input",
37623 + .id = -1,
37624 + .dev = {
37625 + .platform_data = &ip7160bringup_ubicom32input_data,
37626 + },
37627 +};
37628 +
37629 +#ifdef CONFIG_SERIAL_UBI32_SERDES
37630 +static struct resource ip7160bringup_ubicom32_suart_resources[] = {
37631 + {
37632 + .start = RE,
37633 + .end = RE,
37634 + .flags = IORESOURCE_MEM,
37635 + },
37636 + {
37637 + .start = PORT_OTHER_INT(RE),
37638 + .end = PORT_OTHER_INT(RE),
37639 + .flags = IORESOURCE_IRQ,
37640 + },
37641 + {
37642 + .start = 250000000,
37643 + .end = 250000000,
37644 + .flags = UBICOM32_SUART_IORESOURCE_CLOCK,
37645 + },
37646 +};
37647 +
37648 +static struct platform_device ip7160bringup_ubicom32_suart_device = {
37649 + .name = "ubicom32suart",
37650 + .id = -1,
37651 + .num_resources = ARRAY_SIZE(ip7160bringup_ubicom32_suart_resources),
37652 + .resource = ip7160bringup_ubicom32_suart_resources,
37653 +};
37654 +#endif
37655 +
37656 +/*
37657 + * List of all devices in our system
37658 + */
37659 +static struct platform_device *ip7160bringup_devices[] __initdata = {
37660 +#ifdef CONFIG_SERIAL_UBI32_SERDES
37661 + &ip7160bringup_ubicom32_suart_device,
37662 +#endif
37663 + &ip7160bringup_ubicom32input_device,
37664 +};
37665 +
37666 +/*
37667 + * ip7160bringup_init
37668 + * Called to add the devices which we have on this board
37669 + */
37670 +static int __init ip7160bringup_init(void)
37671 +{
37672 + board_init();
37673 +
37674 + ubi_gpio_init();
37675 +
37676 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
37677 + platform_add_devices(ip7160bringup_devices, ARRAY_SIZE(ip7160bringup_devices));
37678 +
37679 + return 0;
37680 +}
37681 +
37682 +arch_initcall(ip7160bringup_init);
37683 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160dpf.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160dpf.c
37684 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160dpf.c 1970-01-01 02:00:00.000000000 +0200
37685 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160dpf.c 2009-12-11 11:45:11.000000000 +0200
37686 @@ -0,0 +1,326 @@
37687 +/*
37688 + * arch/ubicom32/mach-ip7k/board-ip7160dpf.c
37689 + * Platform initialization for ip7160dpf board.
37690 + *
37691 + * (C) Copyright 2009, Ubicom, Inc.
37692 + *
37693 + * This file is part of the Ubicom32 Linux Kernel Port.
37694 + *
37695 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
37696 + * it and/or modify it under the terms of the GNU General Public License
37697 + * as published by the Free Software Foundation, either version 2 of the
37698 + * License, or (at your option) any later version.
37699 + *
37700 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
37701 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
37702 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
37703 + * the GNU General Public License for more details.
37704 + *
37705 + * You should have received a copy of the GNU General Public License
37706 + * along with the Ubicom32 Linux Kernel Port. If not,
37707 + * see <http://www.gnu.org/licenses/>.
37708 + *
37709 + * Ubicom32 implementation derived from (with many thanks):
37710 + * arch/m68knommu
37711 + * arch/blackfin
37712 + * arch/parisc
37713 + */
37714 +#include <linux/device.h>
37715 +#include <linux/platform_device.h>
37716 +#include <linux/delay.h>
37717 +#include <linux/gpio.h>
37718 +
37719 +#include <linux/i2c.h>
37720 +#include <linux/i2c-gpio.h>
37721 +
37722 +#include <linux/input.h>
37723 +
37724 +#include <asm/board.h>
37725 +#include <asm/machdep.h>
37726 +#include <asm/ubicom32hid.h>
37727 +#include <asm/vdc_tio.h>
37728 +#include <asm/audio.h>
37729 +
37730 +/*
37731 + * Backlight on the board PD0, hardware PWM
37732 + */
37733 +static const struct ubicom32hid_button ip7160dpf_ubicom32hid_buttons[] = {
37734 + {
37735 + .type = EV_KEY,
37736 + .code = KEY_UP,
37737 + .bit = 0,
37738 + },
37739 + {
37740 + .type = EV_KEY,
37741 + .code = KEY_LEFT,
37742 + .bit = 1,
37743 + },
37744 + {
37745 + .type = EV_KEY,
37746 + .code = KEY_RIGHT,
37747 + .bit = 2,
37748 + },
37749 + {
37750 + .type = EV_KEY,
37751 + .code = KEY_DOWN,
37752 + .bit = 3,
37753 + },
37754 + {
37755 + .type = EV_KEY,
37756 + .code = KEY_ENTER,
37757 + .bit = 4,
37758 + },
37759 + {
37760 + .type = EV_KEY,
37761 + .code = KEY_MENU,
37762 + .bit = 5,
37763 + },
37764 + {
37765 + .type = EV_KEY,
37766 + .code = KEY_ESC,
37767 + .bit = 7,
37768 + },
37769 +};
37770 +
37771 +static const struct ubicom32hid_ir ip7160dpf_ubicom32hid_ircodes[] = {
37772 + {
37773 + .type = EV_KEY,
37774 + .code = KEY_UP,
37775 + .ir_code = 0xF807916E
37776 + },
37777 + {
37778 + .type = EV_KEY,
37779 + .code = KEY_DOWN,
37780 + .ir_code = 0xF20D916E
37781 + },
37782 + {
37783 + .type = EV_KEY,
37784 + .code = KEY_LEFT,
37785 + .ir_code = 0xF609916E
37786 + },
37787 + {
37788 + .type = EV_KEY,
37789 + .code = KEY_RIGHT,
37790 + .ir_code = 0xF40B916E
37791 + },
37792 + {
37793 + .type = EV_KEY,
37794 + .code = KEY_ENTER,
37795 + .ir_code = 0xF50A916E
37796 + },
37797 + { /* rotate */
37798 + .type = EV_KEY,
37799 + .code = KEY_FN_F1,
37800 + .ir_code = 0xF906916E
37801 + },
37802 + {
37803 + .type = EV_KEY,
37804 + .code = KEY_MENU,
37805 + .ir_code = 0xF708916E
37806 + },
37807 + { /* font size */
37808 + .type = EV_KEY,
37809 + .code = KEY_FN_F2,
37810 + .ir_code = 0xF30C916E
37811 + },
37812 + {
37813 + .type = EV_KEY,
37814 + .code = KEY_ESC,
37815 + .ir_code = 0xF10E916E
37816 + },
37817 + {
37818 + .type = EV_KEY,
37819 + .code = KEY_VOLUMEUP,
37820 + .ir_code = 0xF00F916E
37821 + },
37822 + {
37823 + .type = EV_KEY,
37824 + .code = KEY_VOLUMEDOWN,
37825 + .ir_code = 0xED12916E
37826 + },
37827 + {
37828 + .type = EV_KEY,
37829 + .code = KEY_MUTE,
37830 + .ir_code = 0xEA15916E
37831 + },
37832 + {
37833 + .type = EV_KEY,
37834 + .code = KEY_INFO,
37835 + .ir_code = 0xEF10916E
37836 + },
37837 + { /* Like */
37838 + .type = EV_KEY,
37839 + .code = KEY_FN_F3,
37840 + .ir_code = 0xEE11916E
37841 + },
37842 + { /* Dislike */
37843 + .type = EV_KEY,
37844 + .code = KEY_FN_F4,
37845 + .ir_code = 0xEB14916E
37846 + },
37847 + {
37848 + .type = EV_KEY,
37849 + .code = KEY_POWER,
37850 + .ir_code = 0xFD02916E
37851 + },
37852 +};
37853 +
37854 +static struct ubicom32hid_platform_data ip7160dpf_ubicom32hid_platform_data = {
37855 + .gpio_reset = GPIO_RI_5,
37856 + .gpio_reset_polarity = 0,
37857 + .type = UBICOM32HID_BL_TYPE_PWM,
37858 + .invert = 0,
37859 + .default_intensity = 128,
37860 + .buttons = ip7160dpf_ubicom32hid_buttons,
37861 + .nbuttons = ARRAY_SIZE(ip7160dpf_ubicom32hid_buttons),
37862 + .ircodes = ip7160dpf_ubicom32hid_ircodes,
37863 + .nircodes = ARRAY_SIZE(ip7160dpf_ubicom32hid_ircodes),
37864 +};
37865 +
37866 +/*
37867 + * Devices on the I2C bus
37868 + * This board has a "bus 2" which is isolated from the main bus by U47
37869 + * and pin RI0. It should be safe to always enable bus 2 by setting
37870 + * RI0 to low, however, it should be noted that on all existing configurations
37871 + * of this board, U49 and U51 are not populated.
37872 + */
37873 +static struct i2c_board_info __initdata ip7160dpf_i2c_board_info[] = {
37874 + /*
37875 + * U37, CS4350 DAC, address 0x4B, bus 2
37876 + * THIS ENTRY MUST BE FIRST
37877 + */
37878 + {
37879 + .type = "cs4350",
37880 + .addr = 0x4B,
37881 + }
37882 +
37883 + /*
37884 + * U24, ubicom32hid
37885 + */
37886 + {
37887 + .type = "ubicom32hid",
37888 + .addr = 0x08,
37889 + .platform_data = &ip7160dpf_ubicom32hid_platform_data,
37890 + },
37891 +
37892 + /*
37893 + * U49, ISL29001 Ambient Light Sensor, address 0x44, bus 2 (may not be stuffed)
37894 + */
37895 +
37896 + /*
37897 + * U51, S35390A RTC, address 0x30, bus 2 (may not be stuffed)
37898 + */
37899 +#ifdef CONFIG_RTC_DRV_S35390A
37900 + {
37901 + .type = "s35390a",
37902 + .addr = 0x30,
37903 + },
37904 +#endif
37905 +};
37906 +
37907 +/*
37908 + * I2C bus on the board, SDA PI1, SCL PI2
37909 + */
37910 +static struct i2c_gpio_platform_data ip7160dpf_i2c_data = {
37911 + .sda_pin = GPIO_RI_1,
37912 + .scl_pin = GPIO_RI_2,
37913 + .sda_is_open_drain = 0,
37914 + .scl_is_open_drain = 0,
37915 + .scl_is_output_only = 1,
37916 + .udelay = 6,
37917 +};
37918 +
37919 +static struct platform_device ip7160dpf_i2c_device = {
37920 + .name = "i2c-gpio",
37921 + .id = 0,
37922 + .dev = {
37923 + .platform_data = &ip7160dpf_i2c_data,
37924 + },
37925 +};
37926 +
37927 +/*
37928 + * List of all devices in our system
37929 + */
37930 +static struct platform_device *ip7160dpf_devices[] __initdata = {
37931 + &ip7160dpf_i2c_device,
37932 +};
37933 +
37934 +/*
37935 + * ip7160dpf_power_off
37936 + * Called to turn the power off for this board
37937 + */
37938 +static void ip7160dpf_power_off(void)
37939 +{
37940 + gpio_set_value(GPIO_RF_14, 0);
37941 +}
37942 +
37943 +/*
37944 + * ip7160dpf_init
37945 + * Called to add the devices which we have on this board
37946 + */
37947 +static int __init ip7160dpf_init(void)
37948 +{
37949 + int ret;
37950 + struct platform_device *audio_dev;
37951 +
37952 + ubi_gpio_init();
37953 +
37954 + /*
37955 + * Hold the POWER_HOLD line
37956 + */
37957 + ret = gpio_request(GPIO_RF_14, "POWER_HOLD");
37958 + if (ret) {
37959 + printk(KERN_ERR "%s: could not request POWER_HOLD GPIO\n", __FUNCTION__);
37960 + }
37961 + gpio_direction_output(GPIO_RF_14, 1);
37962 + mach_power_off = ip7160dpf_power_off;
37963 +
37964 + /*
37965 + * USB SEL_HOST_USB line
37966 + */
37967 + ret = gpio_request(GPIO_RI_13, "SEL_HOST_USB");
37968 + if (ret) {
37969 + printk(KERN_ERR "%s: could not request SEL_HOST_USB GPIO\n", __FUNCTION__);
37970 + }
37971 + gpio_direction_output(GPIO_RI_13, 0);
37972 +
37973 + /*
37974 + * USB/DAC nRESET line
37975 + */
37976 + ret = gpio_request(GPIO_RI_3, "USB_DAC_nRESET");
37977 + if (ret) {
37978 + printk(KERN_ERR "%s: could not request USB_DAC_nRESET GPIO\n", __FUNCTION__);
37979 + }
37980 + gpio_direction_output(GPIO_RI_3, 0);
37981 + udelay(1);
37982 + gpio_direction_output(GPIO_RI_3, 1);
37983 +
37984 + /*
37985 + * I2C BUS2 Disable line
37986 + */
37987 + ret = gpio_request(GPIO_RI_0, "DISABLE_BUS2");
37988 + if (ret) {
37989 + printk(KERN_ERR "%s: could not request DISABLE_BUS2 GPIO\n", __FUNCTION__);
37990 + }
37991 + gpio_direction_output(GPIO_RI_0, 0);
37992 +
37993 + vdc_tio_init();
37994 +
37995 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
37996 + platform_add_devices(ip7160dpf_devices, ARRAY_SIZE(ip7160dpf_devices));
37997 +
37998 + /*
37999 + * Allocate the audio driver if we can
38000 + */
38001 + audio_dev = audio_device_alloc("snd-ubi32-cs4350", "audio-i2sout", 0);
38002 + if (audio_dev) {
38003 + ip7160dpf_i2c_board_info[0].platform_data = audio_dev;
38004 + }
38005 +
38006 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
38007 + i2c_register_board_info(0, ip7160dpf_i2c_board_info, ARRAY_SIZE(ip7160dpf_i2c_board_info));
38008 +
38009 + return 0;
38010 +}
38011 +
38012 +arch_initcall(ip7160dpf_init);
38013 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160rgw.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160rgw.c
38014 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7160rgw.c 1970-01-01 02:00:00.000000000 +0200
38015 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7160rgw.c 2009-12-11 11:45:11.000000000 +0200
38016 @@ -0,0 +1,355 @@
38017 +/*
38018 + * arch/ubicom32/mach-ip7k/board-ip7160rgw.c
38019 + * Platform initialization for ip7160rgw board.
38020 + *
38021 + * (C) Copyright 2009, Ubicom, Inc.
38022 + *
38023 + * This file is part of the Ubicom32 Linux Kernel Port.
38024 + *
38025 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
38026 + * it and/or modify it under the terms of the GNU General Public License
38027 + * as published by the Free Software Foundation, either version 2 of the
38028 + * License, or (at your option) any later version.
38029 + *
38030 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
38031 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
38032 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
38033 + * the GNU General Public License for more details.
38034 + *
38035 + * You should have received a copy of the GNU General Public License
38036 + * along with the Ubicom32 Linux Kernel Port. If not,
38037 + * see <http://www.gnu.org/licenses/>.
38038 + *
38039 + * Ubicom32 implementation derived from (with many thanks):
38040 + * arch/m68knommu
38041 + * arch/blackfin
38042 + * arch/parisc
38043 + */
38044 +#include <linux/device.h>
38045 +#include <linux/platform_device.h>
38046 +#include <linux/gpio.h>
38047 +#include <linux/leds.h>
38048 +#include <linux/delay.h>
38049 +#include <linux/input.h>
38050 +#include <linux/spi/spi.h>
38051 +
38052 +#include <asm/board.h>
38053 +#include <asm/machdep.h>
38054 +#include <asm/ubicom32input.h>
38055 +
38056 +#ifdef CONFIG_SERIAL_UBI32_SERDES
38057 +#include <asm/ubicom32suart.h>
38058 +#endif
38059 +
38060 +#include <asm/ubicom32-spi-gpio.h>
38061 +#include <asm/switch-dev.h>
38062 +
38063 +#ifdef CONFIG_IP7160RGWLCD
38064 +#include <linux/i2c.h>
38065 +#include <linux/i2c-gpio.h>
38066 +/*
38067 + * LCD Adapter board 8007-092x support
38068 + *
38069 + * Touch controller
38070 + *
38071 + * Connected via I2C bus, interrupt on PA6
38072 + */
38073 +#include <linux/i2c/tsc2007.h>
38074 +
38075 +/*
38076 + * ip7160rgwlcd_tsc2007_exit_platform_hw
38077 + */
38078 +static void ip7160rgwlcd_tsc2007_exit_platform_hw(void)
38079 +{
38080 + UBICOM32_IO_PORT(RA)->ctl0 &= ~(0x03 << 17);
38081 + gpio_free(GPIO_RA_5);
38082 +}
38083 +
38084 +/*
38085 + * ip7160rgwlcd_tsc2007_init_platform_hw
38086 + */
38087 +static int ip7160rgwlcd_tsc2007_init_platform_hw(void)
38088 +{
38089 + int res = gpio_request(GPIO_RA_5, "TSC2007_IRQ");
38090 + if (res) {
38091 + return res;
38092 + }
38093 +
38094 + UBICOM32_IO_PORT(RA)->ctl0 &= ~(0x03 << 17);
38095 + UBICOM32_IO_PORT(RA)->ctl0 |= (0x02 << 17);
38096 + return 0;
38097 +}
38098 +
38099 +/*
38100 + * ip7160rgwlcd_tsc2007_get_pendown_state
38101 + */
38102 +static int ip7160rgwlcd_tsc2007_get_pendown_state(void)
38103 +{
38104 + return !gpio_get_value(GPIO_RA_5);
38105 +}
38106 +
38107 +static struct tsc2007_platform_data ip7160rgwlcd_tsc2007_data = {
38108 + .model = 2007,
38109 + .x_plate_ohms = 350,
38110 + .get_pendown_state = ip7160rgwlcd_tsc2007_get_pendown_state,
38111 + .init_platform_hw = ip7160rgwlcd_tsc2007_init_platform_hw,
38112 + .exit_platform_hw = ip7160rgwlcd_tsc2007_exit_platform_hw,
38113 +};
38114 +
38115 +/******************************************************************************
38116 + * I2C bus on the board, SDA PI14, SCL PI13
38117 + */
38118 +static struct i2c_gpio_platform_data ip7160rgwlcd_i2c_data = {
38119 + .sda_pin = GPIO_RI_14,
38120 + .scl_pin = GPIO_RI_13,
38121 + .sda_is_open_drain = 0,
38122 + .scl_is_open_drain = 0,
38123 + .udelay = 50,
38124 +};
38125 +
38126 +static struct platform_device ip7160rgwlcd_i2c_device = {
38127 + .name = "i2c-gpio",
38128 + .id = 0,
38129 + .dev = {
38130 + .platform_data = &ip7160rgwlcd_i2c_data,
38131 + },
38132 +};
38133 +
38134 +static struct i2c_board_info __initdata ip7160rgwlcd_i2c_board_info[] = {
38135 + {
38136 + .type = "tsc2007",
38137 + .addr = 0x48,
38138 + .irq = 45, // RA5
38139 + .platform_data = &ip7160rgwlcd_tsc2007_data,
38140 + },
38141 +};
38142 +
38143 +#endif
38144 +
38145 +/*
38146 + * SPI bus over GPIO for Gigabit Ethernet Switch
38147 + * U58:
38148 + * MOSI PE0
38149 + * MISO PE1
38150 + * CLK PE3
38151 + * CS PE2
38152 + */
38153 +static struct ubicom32_spi_gpio_platform_data ip7160rgw_spi_gpio_data = {
38154 + .pin_mosi = GPIO_RE_0,
38155 + .pin_miso = GPIO_RE_1,
38156 + .pin_clk = GPIO_RE_3,
38157 + .bus_num = 0, // We'll call this SPI bus 0
38158 + .num_chipselect = 1, // only one device on this SPI bus
38159 + .clk_default = 1,
38160 +};
38161 +
38162 +static struct platform_device ip7160rgw_spi_gpio_device = {
38163 + .name = "ubicom32-spi-gpio",
38164 + .id = 0,
38165 + .dev = {
38166 + .platform_data = &ip7160rgw_spi_gpio_data,
38167 + },
38168 +};
38169 +
38170 +static struct ubicom32_spi_gpio_controller_data ip7160rgw_bcm539x_controller_data = {
38171 + .pin_cs = GPIO_RE_2,
38172 +};
38173 +
38174 +static struct switch_core_platform_data ip7160rgw_bcm539x_platform_data = {
38175 + .flags = SWITCH_DEV_FLAG_HW_RESET,
38176 + .pin_reset = GPIO_RE_4,
38177 + .name = "bcm539x",
38178 +};
38179 +
38180 +static struct spi_board_info ip7160rgw_spi_board_info[] = {
38181 + {
38182 + .modalias = "bcm539x-spi",
38183 + .bus_num = 0,
38184 + .chip_select = 0,
38185 + .max_speed_hz = 2000000,
38186 + .platform_data = &ip7160rgw_bcm539x_platform_data,
38187 + .controller_data = &ip7160rgw_bcm539x_controller_data,
38188 + .mode = SPI_MODE_3,
38189 + }
38190 +};
38191 +
38192 +/*
38193 + * LEDs
38194 + *
38195 + * WLAN1 PD0 (PWM capable)
38196 + * WLAN2 PD1
38197 + * USB2.0 PD2
38198 + * Status PD3
38199 + * WPS PD4
38200 + *
38201 + * TODO: check triggers, are they generic?
38202 + */
38203 +static struct gpio_led ip7160rgw_gpio_leds[] = {
38204 + {
38205 + .name = "d53:green:WLAN1",
38206 + .default_trigger = "WLAN1",
38207 + .gpio = GPIO_RD_0,
38208 + .active_low = 1,
38209 + },
38210 + {
38211 + .name = "d54:green:WLAN2",
38212 + .default_trigger = "WLAN2",
38213 + .gpio = GPIO_RD_1,
38214 + .active_low = 1,
38215 + },
38216 + {
38217 + .name = "d55:green:USB",
38218 + .default_trigger = "USB",
38219 + .gpio = GPIO_RD_2,
38220 + .active_low = 1,
38221 + },
38222 + {
38223 + .name = "d56:green:Status",
38224 + .default_trigger = "Status",
38225 + .gpio = GPIO_RD_3,
38226 + .active_low = 1,
38227 + },
38228 + {
38229 + .name = "d57:green:WPS",
38230 + .default_trigger = "WPS",
38231 + .gpio = GPIO_RD_4,
38232 + .active_low = 1,
38233 + },
38234 +};
38235 +
38236 +static struct gpio_led_platform_data ip7160rgw_gpio_led_platform_data = {
38237 + .num_leds = 5,
38238 + .leds = ip7160rgw_gpio_leds,
38239 +};
38240 +
38241 +static struct platform_device ip7160rgw_gpio_leds_device = {
38242 + .name = "leds-gpio",
38243 + .id = -1,
38244 + .dev = {
38245 + .platform_data = &ip7160rgw_gpio_led_platform_data,
38246 + },
38247 +};
38248 +
38249 +/*
38250 + * Use ubicom32input driver to monitor the various pushbuttons on this board.
38251 + *
38252 + * WPS PD5
38253 + * FACT_DEFAULT PD6
38254 + *
38255 + * TODO: pick some ubicom understood EV_xxx define for WPS and Fact Default
38256 + */
38257 +static struct ubicom32input_button ip7160rgw_ubicom32input_buttons[] = {
38258 + {
38259 + .type = EV_KEY,
38260 + .code = KEY_FN_F1,
38261 + .gpio = GPIO_RD_5,
38262 + .desc = "WPS",
38263 + .active_low = 1,
38264 + },
38265 + {
38266 + .type = EV_KEY,
38267 + .code = KEY_FN_F2,
38268 + .gpio = GPIO_RD_6,
38269 + .desc = "Factory Default",
38270 + .active_low = 1,
38271 + },
38272 +};
38273 +
38274 +static struct ubicom32input_platform_data ip7160rgw_ubicom32input_data = {
38275 + .buttons = ip7160rgw_ubicom32input_buttons,
38276 + .nbuttons = ARRAY_SIZE(ip7160rgw_ubicom32input_buttons),
38277 +};
38278 +
38279 +static struct platform_device ip7160rgw_ubicom32input_device = {
38280 + .name = "ubicom32input",
38281 + .id = -1,
38282 + .dev = {
38283 + .platform_data = &ip7160rgw_ubicom32input_data,
38284 + },
38285 +};
38286 +
38287 +#ifdef CONFIG_SERIAL_UBI32_SERDES
38288 +static struct resource ip7160rgw_ubicom32_suart_resources[] = {
38289 + {
38290 + .start = RE,
38291 + .end = RE,
38292 + .flags = IORESOURCE_MEM,
38293 + },
38294 + {
38295 + .start = PORT_OTHER_INT(RE),
38296 + .end = PORT_OTHER_INT(RE),
38297 + .flags = IORESOURCE_IRQ,
38298 + },
38299 + {
38300 + .start = 250000000,
38301 + .end = 250000000,
38302 + .flags = UBICOM32_SUART_IORESOURCE_CLOCK,
38303 + },
38304 +};
38305 +
38306 +static struct platform_device ip7160rgw_ubicom32_suart_device = {
38307 + .name = "ubicom32suart",
38308 + .id = -1,
38309 + .num_resources = ARRAY_SIZE(ip7160rgw_ubicom32_suart_resources),
38310 + .resource = ip7160rgw_ubicom32_suart_resources,
38311 +};
38312 +#endif
38313 +
38314 +/*
38315 + * List of all devices in our system
38316 + */
38317 +static struct platform_device *ip7160rgw_devices[] __initdata = {
38318 +#ifdef CONFIG_SERIAL_UBI32_SERDES
38319 + &ip7160rgw_ubicom32_suart_device,
38320 +#endif
38321 + &ip7160rgw_ubicom32input_device,
38322 + &ip7160rgw_gpio_leds_device,
38323 + &ip7160rgw_spi_gpio_device,
38324 +#ifdef CONFIG_IP7160RGWLCD
38325 + &ip7160rgwlcd_i2c_device,
38326 +#endif
38327 +};
38328 +
38329 +/*
38330 + * ip7160rgw_init
38331 + * Called to add the devices which we have on this board
38332 + */
38333 +static int __init ip7160rgw_init(void)
38334 +{
38335 + board_init();
38336 +
38337 + /*
38338 + * Rev 1.2 boards have spi in a different place than 1.1/1.0
38339 + */
38340 + if (strcmp(board_get_revision(), "1.2") == 0) {
38341 + ip7160rgw_spi_gpio_data.pin_mosi = GPIO_RD_7;
38342 + }
38343 +
38344 + ubi_gpio_init();
38345 +
38346 + /*
38347 + * Reserve switch SPI CS on behalf on switch driver
38348 + */
38349 + if (gpio_request(ip7160rgw_bcm539x_controller_data.pin_cs, "switch-bcm539x-cs")) {
38350 + printk(KERN_WARNING "Could not request cs of switch SPI I/F\n");
38351 + return -EIO;
38352 + }
38353 + gpio_direction_output(ip7160rgw_bcm539x_controller_data.pin_cs, 1);
38354 +
38355 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
38356 + platform_add_devices(ip7160rgw_devices, ARRAY_SIZE(ip7160rgw_devices));
38357 +
38358 + printk(KERN_INFO "%s: registering SPI resources\n", __FUNCTION__);
38359 + spi_register_board_info(ip7160rgw_spi_board_info, ARRAY_SIZE(ip7160rgw_spi_board_info));
38360 +
38361 +#ifdef CONFIG_IP7160RGWLCD
38362 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
38363 + i2c_register_board_info(0, ip7160rgwlcd_i2c_board_info, ARRAY_SIZE(ip7160rgwlcd_i2c_board_info));
38364 + printk(KERN_INFO "IP7160 RGW + LCD\n");
38365 +#else
38366 + printk(KERN_INFO "IP7160 RGW\n");
38367 +#endif
38368 + return 0;
38369 +}
38370 +
38371 +arch_initcall(ip7160rgw_init);
38372 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500av.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500av.c
38373 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500av.c 1970-01-01 02:00:00.000000000 +0200
38374 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500av.c 2009-12-11 11:45:11.000000000 +0200
38375 @@ -0,0 +1,273 @@
38376 +/*
38377 + * arch/ubicom32/mach-ip7k/board-ip7500av.c
38378 + * Support for IP7500 Audio Video Board + CPU module board.
38379 + *
38380 + * This file supports the IP7500 Audio Video Board:
38381 + * 8007-0810 Rev 1.0
38382 + * with one of the following CPU module boards:
38383 + * 8007-0510 Rev 1.0
38384 + * 8007-0510A Rev 1.0 (with ethernet)
38385 + *
38386 + * DIP Switch SW2 configuration: (*) default
38387 + * POS 1: on(*) = PCI enabled, off = PCI disabled
38388 + * POS 2: on(*) = TTYX => PA6, off = TTYX => PF12
38389 + * POS 3: on(*) = TTYY => PA7, off = TTYY => PF15
38390 + * POS 4: unused
38391 + *
38392 + * (C) Copyright 2009, Ubicom, Inc.
38393 + *
38394 + * This file is part of the Ubicom32 Linux Kernel Port.
38395 + *
38396 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
38397 + * it and/or modify it under the terms of the GNU General Public License
38398 + * as published by the Free Software Foundation, either version 2 of the
38399 + * License, or (at your option) any later version.
38400 + *
38401 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
38402 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
38403 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
38404 + * the GNU General Public License for more details.
38405 + *
38406 + * You should have received a copy of the GNU General Public License
38407 + * along with the Ubicom32 Linux Kernel Port. If not,
38408 + * see <http://www.gnu.org/licenses/>.
38409 + */
38410 +
38411 +#include <linux/platform_device.h>
38412 +#include <linux/device.h>
38413 +#include <linux/gpio.h>
38414 +#include <linux/i2c.h>
38415 +#include <linux/i2c-gpio.h>
38416 +#include <linux/delay.h>
38417 +#include <asm/board.h>
38418 +#include <asm/machdep.h>
38419 +#include <asm/ring_tio.h>
38420 +#include <asm/vdc_tio.h>
38421 +#include <asm/audio.h>
38422 +#include <asm/ubi32-pcm.h>
38423 +#include <asm/ubi32-cs4384.h>
38424 +
38425 +/******************************************************************************
38426 + * Devices on the I2C bus
38427 + *
38428 + * BEWARE of changing the order of things in this array as we depend on
38429 + * certain things to be in certain places.
38430 + */
38431 +static struct i2c_board_info __initdata ip7500av_i2c_board_info[] = {
38432 + /*
38433 + * U6, CS4384 DAC, address 0x19
38434 + */
38435 + {
38436 + .type = "cs4384",
38437 + .addr = 0x19,
38438 + },
38439 +};
38440 +
38441 +/*
38442 + * I2C bus on the board, SDA PD1, SCL PD2
38443 + */
38444 +static struct i2c_gpio_platform_data ip7500av_i2c_data = {
38445 + .sda_pin = GPIO_RD_6,
38446 + .scl_pin = GPIO_RD_3,
38447 + .sda_is_open_drain = 0,
38448 + .scl_is_open_drain = 0,
38449 + .udelay = 50,
38450 +};
38451 +
38452 +static struct platform_device ip7500av_i2c_device = {
38453 + .name = "i2c-gpio",
38454 + .id = 0,
38455 + .dev = {
38456 + .platform_data = &ip7500av_i2c_data,
38457 + },
38458 +};
38459 +
38460 +/*
38461 + * List of possible mclks we can generate. This depends on the CPU frequency.
38462 + */
38463 +static struct ubi32_cs4384_mclk_entry ip7500av_cs4384_mclk_entries[] = {
38464 + {
38465 + .rate = 12288000,
38466 + .div = 44,
38467 + },
38468 + {
38469 + .rate = 11289600,
38470 + .div = 48,
38471 + },
38472 +};
38473 +
38474 +/*
38475 + * List of all devices in our system
38476 + */
38477 +static struct platform_device *ip7500av_devices[] __initdata = {
38478 + &ip7500av_i2c_device,
38479 +};
38480 +
38481 +/*
38482 + * ip7500av_vdac_write
38483 + */
38484 +static int __init ip7500av_vdac_write(int reg, int val)
38485 +{
38486 + struct i2c_adapter *adap;
38487 + struct i2c_msg msg[1];
38488 + unsigned char data[2];
38489 + int err;
38490 +
38491 + adap = i2c_get_adapter(0);
38492 + if (!adap) {
38493 + printk(KERN_WARNING "%s: failed to get i2c adapter\n", __FUNCTION__);
38494 + return -ENODEV;
38495 + }
38496 + msg->addr = 0x2B;
38497 + msg->flags = 0;
38498 + msg->len = 2;
38499 + msg->buf = data;
38500 + data[0] = reg;
38501 + data[1] = val;
38502 + err = i2c_transfer(adap, msg, 1);
38503 + i2c_put_adapter(adap);
38504 + if (err >= 0) {
38505 + return 0;
38506 + }
38507 + return err;
38508 +}
38509 +
38510 +/*
38511 + * ip7500av_vdac_init
38512 + * Initializes the video DAC via I2C
38513 + *
38514 + * Equivalent mode line: 720x480p = 27 Mhz, 720 736 800 858 480 484 492 525
38515 + */
38516 +static int __init ip7500av_vdac_init(void)
38517 +{
38518 + int err;
38519 +
38520 + printk(KERN_INFO "Initializing ADV7393 DAC\n");
38521 +
38522 + /*
38523 + * Reset the VDAC
38524 + */
38525 + if (gpio_request(GPIO_RF_6, "VDAC Reset")) {
38526 + printk(KERN_WARNING "%s: failed to allocate VDAC Reset\n", __FUNCTION__);
38527 + return -EBUSY;
38528 + }
38529 + gpio_direction_output(GPIO_RF_6, 0);
38530 + udelay(1);
38531 + gpio_set_value(GPIO_RF_6, 1);
38532 +
38533 + /*
38534 + * See table 100 of ADV7393 data sheet: 16-bit 525p YCrCb In, YPbPr Out
38535 + */
38536 + err = ip7500av_vdac_write(0x17, 0x02);
38537 + if (err) {
38538 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38539 + return err;
38540 + }
38541 + err = ip7500av_vdac_write(0x00, 0x1c);
38542 + if (err) {
38543 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38544 + return err;
38545 + }
38546 + err = ip7500av_vdac_write(0x01, 0x10);
38547 + if (err) {
38548 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38549 + return err;
38550 + }
38551 + err = ip7500av_vdac_write(0x31, 0x01);
38552 + if (err) {
38553 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38554 + return err;
38555 + }
38556 +#ifdef IP7500AV_VDAC_SWAP_PBPR
38557 + err = ip7500av_vdac_write(0x35, 0x08);
38558 + if (err) {
38559 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38560 + return err;
38561 + }
38562 +#endif
38563 +#ifdef IP7500AV_VDAC_FULL_RANGE
38564 + err = ip7500av_vdac_write(0x30, 0x02);
38565 + if (err) {
38566 + printk(KERN_WARNING "%s: failed to write VDAC\n", __FUNCTION__);
38567 + return err;
38568 + }
38569 +#endif
38570 + return 0;
38571 +}
38572 +late_initcall(ip7500av_vdac_init);
38573 +
38574 +/*
38575 + * ip7500av_init
38576 + * Called to add the devices which we have on this board
38577 + */
38578 +static int __init ip7500av_init(void)
38579 +{
38580 + struct platform_device *audio_dev;
38581 + struct platform_device *audio_dev2;
38582 + struct ubi32_cs4384_platform_data *cs4384_pd;
38583 +
38584 + board_init();
38585 +
38586 + ubi_gpio_init();
38587 +
38588 + vdc_tio_init();
38589 +
38590 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
38591 + platform_add_devices(ip7500av_devices, ARRAY_SIZE(ip7500av_devices));
38592 +
38593 + /*
38594 + * CS4384 DAC
38595 + */
38596 + audio_dev = audio_device_alloc("snd-ubi32-cs4384", "audio", "audio-i2sout",
38597 + sizeof(struct ubi32_cs4384_platform_data));
38598 + if (audio_dev) {
38599 + /*
38600 + * Attempt to figure out a good divisor. This will only work
38601 + * assuming the core frequency is compatible.
38602 + */
38603 + int i;
38604 + unsigned int freq = processor_frequency();
38605 + for (i = 0; i < ARRAY_SIZE(ip7500av_cs4384_mclk_entries); i++) {
38606 + unsigned int div;
38607 + unsigned int rate = ip7500av_cs4384_mclk_entries[i].rate / 1000;
38608 + div = ((freq / rate) + 500) / 1000;
38609 + ip7500av_cs4384_mclk_entries[i].div = div;
38610 + printk("CS4384 mclk %d rate %u000Hz div %u act %u\n", i, rate, div, freq / div);
38611 + }
38612 +
38613 + cs4384_pd = audio_device_priv(audio_dev);
38614 + cs4384_pd->mclk_src = UBI32_CS4384_MCLK_PWM_0;
38615 + cs4384_pd->n_mclk = ARRAY_SIZE(ip7500av_cs4384_mclk_entries);
38616 + cs4384_pd->mclk_entries = ip7500av_cs4384_mclk_entries;
38617 + ip7500av_i2c_board_info[0].platform_data = audio_dev;
38618 +
38619 + /*
38620 + * Reset the DAC
38621 + */
38622 + if (gpio_request(GPIO_RF_4, "DAC Reset") == 0) {
38623 + gpio_direction_output(GPIO_RF_4, 0);
38624 + udelay(1);
38625 + gpio_direction_output(GPIO_RF_4, 1);
38626 + } else {
38627 + printk("Unable to request DAC reset GPIO\n");
38628 + }
38629 + }
38630 +
38631 + /*
38632 + * SPDIF port
38633 + */
38634 + audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0);
38635 + if (audio_dev2) {
38636 + platform_device_register(audio_dev2);
38637 + }
38638 +
38639 + /*
38640 + * Register all of the devices which sit on the I2C bus
38641 + */
38642 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
38643 + i2c_register_board_info(0, ip7500av_i2c_board_info, ARRAY_SIZE(ip7500av_i2c_board_info));
38644 +
38645 + printk(KERN_INFO "IP7500 Audio/Video Board\n");
38646 + return 0;
38647 +}
38648 +arch_initcall(ip7500av_init);
38649 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500iap.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500iap.c
38650 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500iap.c 1970-01-01 02:00:00.000000000 +0200
38651 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500iap.c 2009-12-11 11:45:11.000000000 +0200
38652 @@ -0,0 +1,414 @@
38653 +/*
38654 + * arch/ubicom32/mach-ip7k/board-ip7500iap.c
38655 + * Support for IP7500 Internet Audio Player
38656 + *
38657 + * This file supports the IP7500 Internet Audio Player:
38658 + * 8007-1110 Rev 1.0
38659 + *
38660 + * (C) Copyright 2009, Ubicom, Inc.
38661 + *
38662 + * This file is part of the Ubicom32 Linux Kernel Port.
38663 + *
38664 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
38665 + * it and/or modify it under the terms of the GNU General Public License
38666 + * as published by the Free Software Foundation, either version 2 of the
38667 + * License, or (at your option) any later version.
38668 + *
38669 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
38670 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
38671 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
38672 + * the GNU General Public License for more details.
38673 + *
38674 + * You should have received a copy of the GNU General Public License
38675 + * along with the Ubicom32 Linux Kernel Port. If not,
38676 + * see <http://www.gnu.org/licenses/>.
38677 + */
38678 +#include <linux/device.h>
38679 +#include <linux/gpio.h>
38680 +#include <asm/board.h>
38681 +
38682 +#include <linux/delay.h>
38683 +
38684 +#include <linux/platform_device.h>
38685 +#include <asm/audio.h>
38686 +#include <linux/i2c.h>
38687 +#include <linux/i2c-gpio.h>
38688 +
38689 +#include <asm/ubicom32sd.h>
38690 +#include <asm/sd_tio.h>
38691 +
38692 +#include <asm/ubicom32bl.h>
38693 +
38694 +#include <asm/machdep.h>
38695 +
38696 +/******************************************************************************
38697 + * SD/IO Port F (Slot 1) platform data
38698 + */
38699 +static struct resource ip7500iap_portf_sd_resources[] = {
38700 + /*
38701 + * Send IRQ
38702 + */
38703 + [0] = {
38704 + /*
38705 + * The init routine will query the devtree and fill this in
38706 + */
38707 + .flags = IORESOURCE_IRQ,
38708 + },
38709 +
38710 + /*
38711 + * Receive IRQ
38712 + */
38713 + [1] = {
38714 + /*
38715 + * The init routine will query the devtree and fill this in
38716 + */
38717 + .flags = IORESOURCE_IRQ,
38718 + },
38719 +
38720 + /*
38721 + * Memory Mapped Registers
38722 + */
38723 + [2] = {
38724 + /*
38725 + * The init routine will query the devtree and fill this in
38726 + */
38727 + .flags = IORESOURCE_MEM,
38728 + },
38729 +};
38730 +
38731 +static struct ubicom32sd_card ip7500iap_portf_sd_cards[] = {
38732 + [0] = {
38733 + .pin_wp = GPIO_RF_7,
38734 + .wp_polarity = 1,
38735 + .pin_pwr = GPIO_RF_8,
38736 + .pin_cd = GPIO_RF_6,
38737 + },
38738 +};
38739 +
38740 +static struct ubicom32sd_platform_data ip7500iap_portf_sd_platform_data = {
38741 + .ncards = 1,
38742 + .cards = ip7500iap_portf_sd_cards,
38743 +};
38744 +
38745 +static struct platform_device ip7500iap_portf_sd_device = {
38746 + .name = "ubicom32sd",
38747 + .id = 0,
38748 + .resource = ip7500iap_portf_sd_resources,
38749 + .num_resources = ARRAY_SIZE(ip7500iap_portf_sd_resources),
38750 + .dev = {
38751 + .platform_data = &ip7500iap_portf_sd_platform_data,
38752 + },
38753 +
38754 +};
38755 +
38756 +/*
38757 + * ip7500iap_portf_sd_init
38758 + */
38759 +static void ip7500iap_portf_sd_init(void)
38760 +{
38761 + /*
38762 + * Check the device tree for the sd_tio
38763 + */
38764 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portf_sd");
38765 + if (!sd_node) {
38766 + printk(KERN_INFO "PortF SDTIO not found\n");
38767 + return;
38768 + }
38769 +
38770 + /*
38771 + * Fill in the resources and platform data from devtree information
38772 + */
38773 + ip7500iap_portf_sd_resources[0].start = sd_node->dn.sendirq;
38774 + ip7500iap_portf_sd_resources[1].start = sd_node->dn.recvirq;
38775 + ip7500iap_portf_sd_resources[2].start = (u32_t)&(sd_node->regs);
38776 + ip7500iap_portf_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
38777 +
38778 + platform_device_register(&ip7500iap_portf_sd_device);
38779 +}
38780 +
38781 +/******************************************************************************
38782 + * SD/IO Port B (Slot 2) platform data
38783 + */
38784 +static struct resource ip7500iap_portb_sd_resources[] = {
38785 + /*
38786 + * Send IRQ
38787 + */
38788 + [0] = {
38789 + /*
38790 + * The init routine will query the devtree and fill this in
38791 + */
38792 + .flags = IORESOURCE_IRQ,
38793 + },
38794 +
38795 + /*
38796 + * Receive IRQ
38797 + */
38798 + [1] = {
38799 + /*
38800 + * The init routine will query the devtree and fill this in
38801 + */
38802 + .flags = IORESOURCE_IRQ,
38803 + },
38804 +
38805 + /*
38806 + * Memory Mapped Registers
38807 + */
38808 + [2] = {
38809 + /*
38810 + * The init routine will query the devtree and fill this in
38811 + */
38812 + .flags = IORESOURCE_MEM,
38813 + },
38814 +};
38815 +
38816 +static struct ubicom32sd_card ip7500iap_portb_sd_cards[] = {
38817 + [0] = {
38818 + .pin_wp = GPIO_RB_13,
38819 + .wp_polarity = 1,
38820 + .pin_pwr = GPIO_RB_11,
38821 + .pin_cd = GPIO_RB_12,
38822 + },
38823 +};
38824 +
38825 +static struct ubicom32sd_platform_data ip7500iap_portb_sd_platform_data = {
38826 + .ncards = 1,
38827 + .cards = ip7500iap_portb_sd_cards,
38828 +};
38829 +
38830 +static struct platform_device ip7500iap_portb_sd_device = {
38831 + .name = "ubicom32sd",
38832 + .id = 1,
38833 + .resource = ip7500iap_portb_sd_resources,
38834 + .num_resources = ARRAY_SIZE(ip7500iap_portb_sd_resources),
38835 + .dev = {
38836 + .platform_data = &ip7500iap_portb_sd_platform_data,
38837 + },
38838 +
38839 +};
38840 +
38841 +/*
38842 + * ip7500iap_portb_sd_init
38843 + */
38844 +static void ip7500iap_portb_sd_init(void)
38845 +{
38846 + /*
38847 + * Check the device tree for the sd_tio
38848 + */
38849 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portb_sd");
38850 + if (!sd_node) {
38851 + printk(KERN_INFO "PortB SDTIO not found\n");
38852 + return;
38853 + }
38854 +
38855 + /*
38856 + * Fill in the resources and platform data from devtree information
38857 + */
38858 + ip7500iap_portb_sd_resources[0].start = sd_node->dn.sendirq;
38859 + ip7500iap_portb_sd_resources[1].start = sd_node->dn.recvirq;
38860 + ip7500iap_portb_sd_resources[2].start = (u32_t)&(sd_node->regs);
38861 + ip7500iap_portb_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
38862 +
38863 + platform_device_register(&ip7500iap_portb_sd_device);
38864 +}
38865 +
38866 +/******************************************************************************
38867 + * Touch controller
38868 + *
38869 + * Connected via I2C bus, interrupt on PA6
38870 + */
38871 +#include <linux/i2c/tsc2007.h>
38872 +
38873 +/*
38874 + * ip7500iap_tsc2007_exit_platform_hw
38875 + */
38876 +static void ip7500iap_tsc2007_exit_platform_hw(void)
38877 +{
38878 + UBICOM32_IO_PORT(RA)->ctl0 &= ~(0x03 << 19);
38879 + gpio_free(GPIO_RA_6);
38880 +}
38881 +
38882 +/*
38883 + * ip7500iap_tsc2007_init_platform_hw
38884 + */
38885 +static int ip7500iap_tsc2007_init_platform_hw(void)
38886 +{
38887 + int res = gpio_request(GPIO_RA_6, "TSC2007_IRQ");
38888 + if (res) {
38889 + return res;
38890 + }
38891 +
38892 + UBICOM32_IO_PORT(RA)->ctl0 &= ~(0x03 << 19);
38893 + UBICOM32_IO_PORT(RA)->ctl0 |= (0x02 << 19);
38894 + return 0;
38895 +}
38896 +
38897 +/*
38898 + * ip7500iap_tsc2007_get_pendown_state
38899 + */
38900 +static int ip7500iap_tsc2007_get_pendown_state(void)
38901 +{
38902 + return !gpio_get_value(GPIO_RA_6);
38903 +}
38904 +
38905 +static struct tsc2007_platform_data ip7500iap_tsc2007_data = {
38906 + .model = 2007,
38907 + .x_plate_ohms = 350,
38908 + .get_pendown_state = ip7500iap_tsc2007_get_pendown_state,
38909 + .init_platform_hw = ip7500iap_tsc2007_init_platform_hw,
38910 + .exit_platform_hw = ip7500iap_tsc2007_exit_platform_hw,
38911 +};
38912 +
38913 +/******************************************************************************
38914 + * i2c devices
38915 + *
38916 + * DO NOT CHANGE THE ORDER HERE unless you know how this works. There
38917 + * are hardcoded indicies which refer to the order of drivers listed here.
38918 + */
38919 +static struct i2c_board_info __initdata ip7500iap_i2c_board_info[] = {
38920 + /*
38921 + * U6, CS4350 DAC, address 0x4B
38922 + */
38923 + {
38924 + .type = "cs4350",
38925 + .addr = 0x4B,
38926 + },
38927 +
38928 + /*
38929 + * U20, S35390A RTC, address 0x30
38930 + */
38931 + {
38932 + .type = "s35390a",
38933 + .addr = 0x30,
38934 + },
38935 +
38936 + /*
38937 + * U9, TSC2007 Touch screen controller, address 0x49, irq RA6
38938 + */
38939 + {
38940 + .type = "tsc2007",
38941 + .addr = 0x49,
38942 + .irq = 46,
38943 + .platform_data = &ip7500iap_tsc2007_data,
38944 + },
38945 +};
38946 +
38947 +/*
38948 + * I2C bus on the board, SDA PE4, SCL PE5
38949 + */
38950 +static struct i2c_gpio_platform_data ip7500iap_i2c_data = {
38951 + .sda_pin = GPIO_RF_14,
38952 + .scl_pin = GPIO_RF_13,
38953 + .sda_is_open_drain = 0,
38954 + .scl_is_open_drain = 0,
38955 + .udelay = 50,
38956 +};
38957 +
38958 +static struct platform_device ip7500iap_i2c_device = {
38959 + .name = "i2c-gpio",
38960 + .id = 0,
38961 + .dev = {
38962 + .platform_data = &ip7500iap_i2c_data,
38963 + },
38964 +};
38965 +
38966 +/******************************************************************************
38967 + * Backlight on the board PD0, hardware PWM
38968 + */
38969 +static struct ubicom32bl_platform_data ip7500iap_backlight_data = {
38970 + .type = UBICOM32BL_TYPE_PWM,
38971 + .pwm_channel = 2,
38972 + .pwm_prescale = 15,
38973 + .pwm_period = 60,
38974 + .default_intensity = 0x80,
38975 +};
38976 +
38977 +static struct platform_device ip7500iap_backlight_device = {
38978 + .name = "ubicom32bl",
38979 + .id = -1,
38980 + .dev = {
38981 + .platform_data = &ip7500iap_backlight_data,
38982 + },
38983 +};
38984 +
38985 +/******************************************************************************
38986 + * Devices on this board
38987 + */
38988 +static struct platform_device *ip7500iap_devices[] __initdata = {
38989 + &ip7500iap_i2c_device,
38990 + &ip7500iap_backlight_device,
38991 +};
38992 +
38993 +/*
38994 + * ip7500iap_power_off
38995 + * Called to turn the power off for this board
38996 + */
38997 +static void ip7500iap_power_off(void)
38998 +{
38999 + gpio_set_value(GPIO_RF_11, 0);
39000 +}
39001 +
39002 +/*
39003 + * ip7500iap_init
39004 + * Called to add the devices which we have on this board
39005 + */
39006 +static int __init ip7500iap_init(void)
39007 +{
39008 + struct platform_device *audio_dev;
39009 + struct platform_device *audio_dev2;
39010 + int ret;
39011 +
39012 + board_init();
39013 +
39014 + ubi_gpio_init();
39015 +
39016 + /*
39017 + * Hold the POWER_HOLD line
39018 + */
39019 + ret = gpio_request(GPIO_RF_11, "POWER_HOLD");
39020 + if (ret) {
39021 + printk(KERN_ERR "%s: could not request POWER_HOLD GPIO\n", __FUNCTION__);
39022 + }
39023 + gpio_direction_output(GPIO_RF_11, 1);
39024 + mach_power_off = ip7500iap_power_off;
39025 +
39026 + /*
39027 + * DAC nRESET line
39028 + */
39029 + ret = gpio_request(GPIO_RE_7, "DAC_nRESET");
39030 + if (ret) {
39031 + printk(KERN_ERR "%s: could not request DAC_nRESET GPIO\n", __FUNCTION__);
39032 + }
39033 + gpio_direction_output(GPIO_RE_7, 0);
39034 + udelay(1);
39035 + gpio_set_value(GPIO_RE_7, 1);
39036 +
39037 + /*
39038 + * Bring up any SDIO slots
39039 + */
39040 + ip7500iap_portb_sd_init();
39041 + ip7500iap_portf_sd_init();
39042 +
39043 + /*
39044 + * Bring up audio devices
39045 + */
39046 + platform_add_devices(ip7500iap_devices, ARRAY_SIZE(ip7500iap_devices));
39047 +
39048 + audio_dev = audio_device_alloc("snd-ubi32-cs4350", "audio", "audio-i2sout", 0);
39049 + if (audio_dev) {
39050 + ip7500iap_i2c_board_info[0].platform_data = audio_dev;
39051 + }
39052 +
39053 + audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0);
39054 + if (audio_dev2) {
39055 + platform_device_register(audio_dev2);
39056 + }
39057 +
39058 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
39059 + i2c_register_board_info(0, ip7500iap_i2c_board_info, ARRAY_SIZE(ip7500iap_i2c_board_info));
39060 +
39061 + printk(KERN_INFO "IP7500 Internet Audio Player\n");
39062 +
39063 + return 0;
39064 +}
39065 +
39066 +arch_initcall(ip7500iap_init);
39067 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500media.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500media.c
39068 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500media.c 1970-01-01 02:00:00.000000000 +0200
39069 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500media.c 2009-12-11 11:45:11.000000000 +0200
39070 @@ -0,0 +1,732 @@
39071 +/*
39072 + * arch/ubicom32/mach-ip7k/board-ip7500media.c
39073 + * Board file for IP7500 media board.
39074 + *
39075 + * Supports the following configuration
39076 + * CPU Module:
39077 + * P/N 8007-0510 rev 1.0 NOPHY
39078 + * P/N 8007-0511 rev 1.1 NOPHY
39079 + * DIP Switch SW2 configuration:
39080 + * POS 1: on = PCI enabled
39081 + * POS 2: off = TTYX => PF12
39082 + * POS 3: off = TTYY => PF15
39083 + * POS 4: unused
39084 + * Media Board:
39085 + * P/N 8007-0610 rev 1.0
39086 + *
39087 + * LCD Adapter Board: (optional)
39088 + * P/N 8007-0920 rev 2.0
39089 + * P/N 8007-0921 rev 2.1
39090 + *
39091 + * (C) Copyright 2009, Ubicom, Inc.
39092 + *
39093 + * This file is part of the Ubicom32 Linux Kernel Port.
39094 + *
39095 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
39096 + * it and/or modify it under the terms of the GNU General Public License
39097 + * as published by the Free Software Foundation, either version 2 of the
39098 + * License, or (at your option) any later version.
39099 + *
39100 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
39101 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
39102 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
39103 + * the GNU General Public License for more details.
39104 + *
39105 + * You should have received a copy of the GNU General Public License
39106 + * along with the Ubicom32 Linux Kernel Port. If not,
39107 + * see <http://www.gnu.org/licenses/>.
39108 + *
39109 + * Ubicom32 implementation derived from (with many thanks):
39110 + * arch/m68knommu
39111 + * arch/blackfin
39112 + * arch/parisc
39113 + */
39114 +#include <linux/device.h>
39115 +#include <linux/platform_device.h>
39116 +#include <linux/gpio.h>
39117 +
39118 +#include <linux/input.h>
39119 +
39120 +#include <linux/i2c.h>
39121 +#include <linux/i2c-gpio.h>
39122 +#include <linux/i2c/pca953x.h>
39123 +
39124 +#include <asm/board.h>
39125 +#include <asm/machdep.h>
39126 +#include <asm/ubicom32input_i2c.h>
39127 +#include <asm/ubicom32bl.h>
39128 +#include <asm/ubicom32lcdpower.h>
39129 +#include <asm/vdc_tio.h>
39130 +
39131 +#include <asm/ubicom32sd.h>
39132 +#include <asm/sd_tio.h>
39133 +#include <asm/devtree.h>
39134 +#include <asm/audio.h>
39135 +
39136 +#include <asm/ring_tio.h>
39137 +
39138 +/******************************************************************************
39139 + * SD/IO Port F (Slot 1) platform data
39140 + */
39141 +static struct resource ip7500media_portf_sd_resources[] = {
39142 + /*
39143 + * Send IRQ
39144 + */
39145 + [0] = {
39146 + /*
39147 + * The init routine will query the devtree and fill this in
39148 + */
39149 + .flags = IORESOURCE_IRQ,
39150 + },
39151 +
39152 + /*
39153 + * Receive IRQ
39154 + */
39155 + [1] = {
39156 + /*
39157 + * The init routine will query the devtree and fill this in
39158 + */
39159 + .flags = IORESOURCE_IRQ,
39160 + },
39161 +
39162 + /*
39163 + * Memory Mapped Registers
39164 + */
39165 + [2] = {
39166 + /*
39167 + * The init routine will query the devtree and fill this in
39168 + */
39169 + .flags = IORESOURCE_MEM,
39170 + },
39171 +};
39172 +
39173 +static struct ubicom32sd_card ip7500media_portf_sd_cards[] = {
39174 + [0] = {
39175 + .pin_wp = IP7500MEDIA_IO16,
39176 + .wp_polarity = 1,
39177 + .pin_pwr = IP7500MEDIA_IO20,
39178 + .pin_cd = IP7500MEDIA_IO23,
39179 + },
39180 + [1] = {
39181 + .pin_wp = IP7500MEDIA_IO17,
39182 + .wp_polarity = 1,
39183 + .pin_pwr = IP7500MEDIA_IO21,
39184 + .pin_cd = IP7500MEDIA_IO24,
39185 + },
39186 +};
39187 +
39188 +static struct ubicom32sd_platform_data ip7500media_portf_sd_platform_data = {
39189 + .ncards = 2,
39190 + .cards = ip7500media_portf_sd_cards,
39191 +};
39192 +
39193 +static struct platform_device ip7500media_portf_sd_device = {
39194 + .name = "ubicom32sd",
39195 + .id = 0,
39196 + .resource = ip7500media_portf_sd_resources,
39197 + .num_resources = ARRAY_SIZE(ip7500media_portf_sd_resources),
39198 + .dev = {
39199 + .platform_data = &ip7500media_portf_sd_platform_data,
39200 + },
39201 +
39202 +};
39203 +
39204 +/*
39205 + * ip7500media_portf_sd_init
39206 + */
39207 +static void ip7500media_portf_sd_init(void)
39208 +{
39209 + /*
39210 + * Check the device tree for the sd_tio
39211 + */
39212 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portf_sd");
39213 + if (!sd_node) {
39214 + printk(KERN_INFO "PortF SDTIO not found\n");
39215 + return;
39216 + }
39217 +
39218 + /*
39219 + * Fill in the resources and platform data from devtree information
39220 + */
39221 + ip7500media_portf_sd_resources[0].start = sd_node->dn.sendirq;
39222 + ip7500media_portf_sd_resources[1].start = sd_node->dn.recvirq;
39223 + ip7500media_portf_sd_resources[2].start = (u32_t)&(sd_node->regs);
39224 + ip7500media_portf_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
39225 +
39226 + platform_device_register(&ip7500media_portf_sd_device);
39227 +}
39228 +
39229 +/******************************************************************************
39230 + * SD/IO Port B (Slot 2) platform data
39231 + */
39232 +static struct resource ip7500media_portb_sd_resources[] = {
39233 + /*
39234 + * Send IRQ
39235 + */
39236 + [0] = {
39237 + /*
39238 + * The init routine will query the devtree and fill this in
39239 + */
39240 + .flags = IORESOURCE_IRQ,
39241 + },
39242 +
39243 + /*
39244 + * Receive IRQ
39245 + */
39246 + [1] = {
39247 + /*
39248 + * The init routine will query the devtree and fill this in
39249 + */
39250 + .flags = IORESOURCE_IRQ,
39251 + },
39252 +
39253 + /*
39254 + * Memory Mapped Registers
39255 + */
39256 + [2] = {
39257 + /*
39258 + * The init routine will query the devtree and fill this in
39259 + */
39260 + .flags = IORESOURCE_MEM,
39261 + },
39262 +};
39263 +
39264 +static struct ubicom32sd_card ip7500media_portb_sd_cards[] = {
39265 + [0] = {
39266 + .pin_wp = IP7500MEDIA_IO19,
39267 + .wp_polarity = 1,
39268 + .pin_pwr = IP7500MEDIA_IO22,
39269 + .pin_cd = IP7500MEDIA_IO18,
39270 + },
39271 +};
39272 +
39273 +static struct ubicom32sd_platform_data ip7500media_portb_sd_platform_data = {
39274 + .ncards = 1,
39275 + .cards = ip7500media_portb_sd_cards,
39276 +};
39277 +
39278 +static struct platform_device ip7500media_portb_sd_device = {
39279 + .name = "ubicom32sd",
39280 + .id = 1,
39281 + .resource = ip7500media_portb_sd_resources,
39282 + .num_resources = ARRAY_SIZE(ip7500media_portb_sd_resources),
39283 + .dev = {
39284 + .platform_data = &ip7500media_portb_sd_platform_data,
39285 + },
39286 +
39287 +};
39288 +
39289 +/*
39290 + * ip7500media_portb_sd_init
39291 + */
39292 +static void ip7500media_portb_sd_init(void)
39293 +{
39294 + /*
39295 + * Check the device tree for the sd_tio
39296 + */
39297 + struct sd_tio_node *sd_node = (struct sd_tio_node *)devtree_find_node("portb_sd");
39298 + if (!sd_node) {
39299 + printk(KERN_INFO "PortB SDTIO not found\n");
39300 + return;
39301 + }
39302 +
39303 + /*
39304 + * Fill in the resources and platform data from devtree information
39305 + */
39306 + ip7500media_portb_sd_resources[0].start = sd_node->dn.sendirq;
39307 + ip7500media_portb_sd_resources[1].start = sd_node->dn.recvirq;
39308 + ip7500media_portb_sd_resources[2].start = (u32_t)&(sd_node->regs);
39309 + ip7500media_portb_sd_resources[2].end = (u32_t)&(sd_node->regs) + sizeof(sd_node->regs);
39310 +
39311 + platform_device_register(&ip7500media_portb_sd_device);
39312 +}
39313 +
39314 +/*
39315 + * ip7500media_u17_setup
39316 + * Called by I2C to tell us that u17 is setup.
39317 + *
39318 + * This function is called by I2C to tell us that u17 has been setup. All
39319 + * devices which rely on this chip being initialized (or even present) need to
39320 + * be initialized in this function otherwise they may get initialized too early.
39321 + *
39322 + * Currently the only device depending on u17 is the SDIO
39323 + */
39324 +static int __init ip7500media_u17_setup(struct i2c_client *client, unsigned gpio, unsigned ngpio, void *context)
39325 +{
39326 + /*
39327 + * Initialize the Port F/Port B SD slots (only the enabled ports will init)
39328 + */
39329 + ip7500media_portf_sd_init();
39330 + ip7500media_portb_sd_init();
39331 +
39332 + return 0;
39333 +}
39334 +
39335 +/******************************************************************************
39336 + * LCD VGH on the board at PE6
39337 + */
39338 +static struct ubicom32lcdpower_platform_data ip7500media_lcdpower_data = {
39339 + .vgh_gpio = GPIO_RE_7,
39340 + .vgh_polarity = true,
39341 +};
39342 +
39343 +static struct platform_device ip7500media_lcdpower_device = {
39344 + .name = "ubicom32lcdpower",
39345 + .id = -1,
39346 + .dev = {
39347 + .platform_data = &ip7500media_lcdpower_data,
39348 + },
39349 +};
39350 +
39351 +/******************************************************************************
39352 + * Backlight on the board PD0, hardware PWM
39353 + */
39354 +static struct ubicom32bl_platform_data ip7500media_backlight_data = {
39355 + .type = UBICOM32BL_TYPE_PWM,
39356 + .pwm_channel = 2,
39357 + .pwm_prescale = 15,
39358 + .pwm_period = 60,
39359 + .default_intensity = 0x80,
39360 +};
39361 +
39362 +static struct platform_device ip7500media_backlight_device = {
39363 + .name = "ubicom32bl",
39364 + .id = -1,
39365 + .dev = {
39366 + .platform_data = &ip7500media_backlight_data,
39367 + },
39368 +};
39369 +
39370 +/******************************************************************************
39371 + * Ubicom32Input on I2C, U15 MAX7310, address 0x18, 8 bits
39372 + */
39373 +static struct ubicom32input_i2c_button ip7500media_ubicom32input_i2c_u15_buttons[] = {
39374 + {
39375 + .type = EV_KEY,
39376 + .code = KEY_LEFT,
39377 + .bit = 0,
39378 + .active_low = 1,
39379 + },
39380 + {
39381 + .type = EV_KEY,
39382 + .code = KEY_RIGHT,
39383 + .bit = 1,
39384 + .active_low = 1,
39385 + },
39386 + {
39387 + .type = EV_KEY,
39388 + .code = KEY_UP,
39389 + .bit = 2,
39390 + .active_low = 1,
39391 + },
39392 + {
39393 + .type = EV_KEY,
39394 + .code = KEY_DOWN,
39395 + .bit = 3,
39396 + .active_low = 1,
39397 + },
39398 + {
39399 + .type = EV_KEY,
39400 + .code = KEY_ENTER,
39401 + .bit = 4,
39402 + .active_low = 1,
39403 + },
39404 + {
39405 + .type = EV_KEY,
39406 + .code = KEY_MENU,
39407 + .bit = 5,
39408 + .active_low = 1,
39409 + },
39410 + {
39411 + .type = EV_KEY,
39412 + .code = KEY_ESC,
39413 + .bit = 6,
39414 + .active_low = 1,
39415 + },
39416 +};
39417 +
39418 +static struct ubicom32input_i2c_platform_data ip7500media_ubicom32input_i2c_u15_platform_data = {
39419 + .buttons = ip7500media_ubicom32input_i2c_u15_buttons,
39420 + .nbuttons = ARRAY_SIZE(ip7500media_ubicom32input_i2c_u15_buttons),
39421 + .name = "Ubicom32 Input I2C U15",
39422 +};
39423 +
39424 +/******************************************************************************
39425 + * Additional GPIO chips
39426 + */
39427 +static struct pca953x_platform_data ip7500media_gpio_u16_platform_data = {
39428 + .gpio_base = IP7500MEDIA_U16_BASE,
39429 +};
39430 +
39431 +static struct pca953x_platform_data ip7500media_gpio_u17_platform_data = {
39432 + .gpio_base = IP7500MEDIA_U17_BASE,
39433 + .setup = ip7500media_u17_setup,
39434 +};
39435 +
39436 +static struct pca953x_platform_data ip7500media_gpio_u18_platform_data = {
39437 + .gpio_base = IP7500MEDIA_U18_BASE,
39438 +};
39439 +
39440 +
39441 +/******************************************************************************
39442 + * Touch controller present on LCD Adapter board
39443 + *
39444 + * Connected via I2C bus, interrupt on PD1
39445 + */
39446 +#include <linux/i2c/tsc2007.h>
39447 +
39448 +/*
39449 + * ip7500media_tsc2007_exit_platform_hw
39450 + */
39451 +static void ip7500media_tsc2007_exit_platform_hw(void)
39452 +{
39453 + UBICOM32_IO_PORT(RD)->int_mask &= ~(1 << 11);
39454 + UBICOM32_IO_PORT(RD)->ctl2 &= ~(0x03 << 16);
39455 + gpio_free(GPIO_RD_1);
39456 +}
39457 +
39458 +/*
39459 + * ip7500media_tsc2007_init_platform_hw
39460 + */
39461 +static int ip7500media_tsc2007_init_platform_hw(void)
39462 +{
39463 + int res = gpio_request(GPIO_RD_1, "TSC2007_IRQ");
39464 + if (res) {
39465 + return res;
39466 + }
39467 + UBICOM32_IO_PORT(RD)->function = 0;
39468 + UBICOM32_IO_PORT(RD)->int_mask = (1 << 11);
39469 + UBICOM32_IO_PORT(RD)->ctl2 &= ~(0x03 << 16);
39470 + UBICOM32_IO_PORT(RD)->ctl2 |= (0x02 << 16);
39471 +
39472 + return 0;
39473 +}
39474 +
39475 +/*
39476 + * ip7500media_tsc2007_clear_penirq
39477 + */
39478 +static void ip7500media_tsc2007_clear_penirq(void)
39479 +{
39480 + UBICOM32_IO_PORT(RD)->int_clr = (1 << 11);
39481 +}
39482 +
39483 +/*
39484 + * ip7500media_tsc2007_get_pendown_state
39485 + */
39486 +static int ip7500media_tsc2007_get_pendown_state(void)
39487 +{
39488 + return !gpio_get_value(GPIO_RD_1);
39489 +}
39490 +
39491 +static struct tsc2007_platform_data ip7500media_tsc2007_data = {
39492 + .model = 2007,
39493 + .x_plate_ohms = 350,
39494 + .get_pendown_state = ip7500media_tsc2007_get_pendown_state,
39495 + .init_platform_hw = ip7500media_tsc2007_init_platform_hw,
39496 + .exit_platform_hw = ip7500media_tsc2007_exit_platform_hw,
39497 + .clear_penirq = ip7500media_tsc2007_clear_penirq,
39498 +};
39499 +
39500 +/******************************************************************************
39501 + * Devices on the I2C bus
39502 + *
39503 + * BEWARE of changing the order of things in this array as we depend on
39504 + * certain things to be in certain places.
39505 + */
39506 +static struct i2c_board_info __initdata ip7500media_i2c_board_info[] = {
39507 + /*
39508 + * U6, CS4350 DAC, address 0x4B
39509 + */
39510 + {
39511 + .type = "cs4350",
39512 + .addr = 0x4B,
39513 + },
39514 +
39515 + /*
39516 + * U14, S35390A RTC, address 0x30
39517 + */
39518 + {
39519 + .type = "s35390a",
39520 + .addr = 0x30,
39521 + },
39522 +
39523 + /*
39524 + * U15, MAX7310 IO expander, 8 bits, address 0x18
39525 + * IO0: User I/O (J16-1) (Left) IO4: User I/O (J16-5) (Enter)
39526 + * IO1: User I/O (J16-2) (Right) IO5: User I/O (J16-6) (Menu)
39527 + * IO2: User I/O (J16-3) (Up) IO6: User I/O (J16-7) (Back)
39528 + * IO3: User I/O (J16-4) (Down) IO7: User I/O (J16-8)
39529 + */
39530 + {
39531 + .type = "ubicom32in_max7310",
39532 + .addr = 0x18,
39533 + .platform_data = &ip7500media_ubicom32input_i2c_u15_platform_data,
39534 + },
39535 +
39536 + /*
39537 + * U16, MAX7310 IO expander, 8 bits, address 0x1C
39538 + * IO8 : User I/O (J16-9) IO12: User I/O (J16-17)
39539 + * IO9 : User I/O (J16-10) IO13: User I/O (J16-18)
39540 + * IO10: User I/O (J16-15) IO14: User I/O (J16-19)
39541 + * IO11: User I/O (J16-16) IO15: User I/O (J16-20)
39542 + */
39543 + {
39544 + .type = "max7310",
39545 + .addr = 0x1C,
39546 + .platform_data = &ip7500media_gpio_u16_platform_data,
39547 + },
39548 +
39549 + /*
39550 + * U17, MAX7310 IO expander, 8 bits, address 0x1A
39551 + * IO16: SDIO1A_WP IO20: SD1A_PWREN
39552 + * IO17: SDIO1B_WP IO21: SD1B_PWREN
39553 + * IO18: SDIO2_CD IO22: SD2_PWREN
39554 + * IO19: SDIO2_WP IO23: SDIO1A_CD
39555 + *
39556 + */
39557 + {
39558 + .type = "max7310",
39559 + .addr = 0x1A,
39560 + .platform_data = &ip7500media_gpio_u17_platform_data,
39561 + },
39562 +
39563 + /*
39564 + * U18, MAX7310 IOB expander, 8 bits, address 0x1E
39565 + * IO24: SDIO1B_CD IO28: User I/O TP6
39566 + * IO25: User I/O TP9 IO29: User I/O TP5
39567 + * IO26: User I/O TP8 IO30: User I/O TP4
39568 + * IO27: User I/O TP7 IO31: User I/O TP3
39569 + */
39570 + {
39571 + .type = "max7310",
39572 + .addr = 0x1E,
39573 + .platform_data = &ip7500media_gpio_u18_platform_data,
39574 + },
39575 +};
39576 +
39577 +/*
39578 + * Additional I2C devices to add when a LCD adapter board is present
39579 + */
39580 +static struct i2c_board_info __initdata ip7500media_lcd_adapter_i2c_board_info[] = {
39581 + {
39582 + I2C_BOARD_INFO("tsc2007", 0x48),
39583 + .irq = PORT_OTHER_INT(RD),
39584 + .platform_data = &ip7500media_tsc2007_data,
39585 + },
39586 +};
39587 +
39588 +/*
39589 + * I2C bus on the board, SDA PE4, SCL PE5
39590 + */
39591 +static struct i2c_gpio_platform_data ip7500media_i2c_data = {
39592 + .sda_pin = GPIO_RE_4,
39593 + .scl_pin = GPIO_RE_5,
39594 + .sda_is_open_drain = 0,
39595 + .scl_is_open_drain = 0,
39596 + .udelay = 50,
39597 +};
39598 +
39599 +static struct platform_device ip7500media_i2c_device = {
39600 + .name = "i2c-gpio",
39601 + .id = 0,
39602 + .dev = {
39603 + .platform_data = &ip7500media_i2c_data,
39604 + },
39605 +};
39606 +
39607 +/*
39608 + * Virtual Frame Buffer device for use with LCD Adapter
39609 + */
39610 +static struct platform_device ip7500media_vfb_device = {
39611 + .name = "ubicom32vfb",
39612 + .id = -1,
39613 +};
39614 +
39615 +/*
39616 + * vdc_override:
39617 + * 0: no override (auto-detect)
39618 + * 1: force vdc usage
39619 + * 2: force lcd adapter usage
39620 + */
39621 +static int __initdata vdc_override = 0;
39622 +
39623 +/*
39624 + * ip7500media_set_forcevdc
39625 + * Called when forcevdc is present on the kernel boot line
39626 + */
39627 +static int __init ip7500media_set_forcevdc(char *str)
39628 +{
39629 + if (str[0] == '1') {
39630 + vdc_override = 1;
39631 + } else {
39632 + vdc_override = 2;
39633 + }
39634 + return 1;
39635 +}
39636 +
39637 +/*
39638 + * ip7500media_video_init
39639 + * Called late to determine what kind of video we have on this board
39640 + */
39641 +static int __init ip7500media_video_init(void)
39642 +{
39643 + struct i2c_adapter *adap;
39644 + struct i2c_msg msg[1];
39645 + unsigned char *data;
39646 + unsigned char checksum;
39647 + int err;
39648 + int i;
39649 +
39650 + if (vdc_override == 1) {
39651 + printk(KERN_INFO "Force VDCTIO mode\n");
39652 + goto no_adapter;
39653 + }
39654 + if (vdc_override == 2) {
39655 + printk(KERN_INFO "Force LCD Adapter Board mode\n");
39656 + return 0;
39657 + }
39658 +
39659 + /*
39660 + * Check to see if there is an EEPROM out there. If we see an
39661 + * EEPROM then we will assume a LCD Adapter Board (8007-092x)
39662 + * exists.
39663 + */
39664 + data = kmalloc(256, GFP_KERNEL);
39665 + if (!data) {
39666 + printk(KERN_WARNING "%s: Failed to allocate memory\n", __FUNCTION__);
39667 + return -ENOMEM;
39668 + }
39669 +
39670 + adap = i2c_get_adapter(0);
39671 + if (!adap) {
39672 + printk(KERN_WARNING "%s: Failed to get i2c adapter\n", __FUNCTION__);
39673 + kfree(data);
39674 + return -ENODEV;
39675 + }
39676 + data[0] = 0;
39677 + msg->addr = 0x50;
39678 + msg->flags = 0;
39679 + msg->len = 1;
39680 + msg->buf = data;
39681 + err = i2c_transfer(adap, msg, 1);
39682 + if (err < 0) {
39683 + goto no_adapter;
39684 + }
39685 +
39686 + msg->addr = 0x50;
39687 + msg->flags = I2C_M_RD;
39688 + msg->len = 256;
39689 + msg->buf = data;
39690 + err = i2c_transfer(adap, msg, 1);
39691 + if (err < 0) {
39692 + goto no_adapter;
39693 + }
39694 +
39695 + i2c_put_adapter(adap);
39696 +
39697 + /*
39698 + * Verify the checksum
39699 + */
39700 + checksum = 0xff;
39701 + for (i = 0; i < 255; i++) {
39702 + checksum ^= data[i];
39703 + }
39704 + if (checksum != data[255]) {
39705 + printk(KERN_WARNING "%s: Checksum mismatch\n", __FUNCTION__);
39706 + }
39707 +
39708 + kfree(data);
39709 +
39710 + /*
39711 + * Bring up VFB
39712 + */
39713 + platform_device_register(&ip7500media_vfb_device);
39714 +
39715 + /*
39716 + * Add the i2c devices on the LCD Adapter board. (We have to use i2c_new_device
39717 + * since it's late in the boot process.)
39718 + */
39719 + printk(KERN_INFO "%s: registering LCD Adapter board i2c resources\n", __FUNCTION__);
39720 + for (i = 0; i < ARRAY_SIZE(ip7500media_lcd_adapter_i2c_board_info); i++) {
39721 + i2c_new_device(adap, &ip7500media_lcd_adapter_i2c_board_info[i]);
39722 + }
39723 +
39724 + i2c_put_adapter(adap);
39725 +
39726 + return 0;
39727 +
39728 + /*
39729 + * No LCD Adapter board, bring up VDC
39730 + */
39731 +no_adapter:
39732 + vdc_tio_init();
39733 + return 0;
39734 +}
39735 +late_initcall(ip7500media_video_init);
39736 +__setup("forcevdc=", ip7500media_set_forcevdc);
39737 +
39738 +/*
39739 + * ip7500media_init
39740 + * Called to add the devices which we have on this board
39741 + */
39742 +static int __init ip7500media_init(void)
39743 +{
39744 + struct platform_device *audio_dev;
39745 + int have_ethernet = (devtree_find_node("eth_lan") != 0);
39746 +
39747 + board_init();
39748 +
39749 + ubi_gpio_init();
39750 +
39751 +#ifdef CONFIG_UIO_UBICOM32RING
39752 + ring_tio_init("decoder_ring");
39753 +#endif
39754 +
39755 + /*
39756 + * Register all of the devices we have on this board
39757 + */
39758 + printk(KERN_INFO "%s: registering device resources\n", __FUNCTION__);
39759 + platform_device_register(&ip7500media_i2c_device);
39760 + platform_device_register(&ip7500media_backlight_device);
39761 +
39762 + /*
39763 + * If ethernet doesn't exist then we can init the lcdpower
39764 + */
39765 + if (!have_ethernet) {
39766 + platform_device_register(&ip7500media_lcdpower_device);
39767 + }
39768 +
39769 + /*
39770 + * Allocate the audio drivers. SPDIF not supported on boards with ethernet.
39771 + */
39772 + audio_dev = audio_device_alloc("snd-ubi32-cs4350", "audio", "audio-i2sout", 0);
39773 + if (audio_dev) {
39774 + ip7500media_i2c_board_info[0].platform_data = audio_dev;
39775 + }
39776 +
39777 + if (!have_ethernet) {
39778 + struct platform_device *audio_dev2;
39779 +
39780 + audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0);
39781 + if (audio_dev2) {
39782 + platform_device_register(audio_dev2);
39783 + }
39784 + }
39785 +
39786 + /*
39787 + * Register all of the devices which sit on the I2C bus
39788 + */
39789 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
39790 + i2c_register_board_info(0, ip7500media_i2c_board_info, ARRAY_SIZE(ip7500media_i2c_board_info));
39791 +
39792 + /*
39793 + * We have to initialize the SDIO after the I2C IOB gets setup. SDIO is initialized in
39794 + * ip7500media_u17_setup
39795 + */
39796 +
39797 + printk("IP7500 Media Board\n");
39798 +
39799 + return 0;
39800 +}
39801 +
39802 +arch_initcall(ip7500media_init);
39803 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500module.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500module.c
39804 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500module.c 1970-01-01 02:00:00.000000000 +0200
39805 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500module.c 2009-12-11 11:45:11.000000000 +0200
39806 @@ -0,0 +1,55 @@
39807 +/*
39808 + * arch/ubicom32/mach-ip7k/board-ip7500module.c
39809 + * Support for IP7500 CPU module board.
39810 + *
39811 + * This file supports the IP7500 CPU module board:
39812 + * 8007-0510 Rev 1.0
39813 + * 8007-0510A Rev 1.0 (with ethernet)
39814 + *
39815 + * DIP Switch SW2 configuration: (*) default
39816 + * POS 1: on(*) = PCI enabled, off = PCI disabled
39817 + * POS 2: on(*) = TTYX => PA6, off = TTYX => PF12
39818 + * POS 3: on(*) = TTYY => PA7, off = TTYY => PF15
39819 + * POS 4: unused
39820 + *
39821 + * (C) Copyright 2009, Ubicom, Inc.
39822 + *
39823 + * This file is part of the Ubicom32 Linux Kernel Port.
39824 + *
39825 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
39826 + * it and/or modify it under the terms of the GNU General Public License
39827 + * as published by the Free Software Foundation, either version 2 of the
39828 + * License, or (at your option) any later version.
39829 + *
39830 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
39831 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
39832 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
39833 + * the GNU General Public License for more details.
39834 + *
39835 + * You should have received a copy of the GNU General Public License
39836 + * along with the Ubicom32 Linux Kernel Port. If not,
39837 + * see <http://www.gnu.org/licenses/>.
39838 + *
39839 + * Ubicom32 implementation derived from (with many thanks):
39840 + * arch/m68knommu
39841 + * arch/blackfin
39842 + * arch/parisc
39843 + */
39844 +#include <linux/device.h>
39845 +#include <linux/gpio.h>
39846 +#include <asm/board.h>
39847 +
39848 +/*
39849 + * ip7500module_init
39850 + * Called to add the devices which we have on this board
39851 + */
39852 +static int __init ip7500module_init(void)
39853 +{
39854 + board_init();
39855 +
39856 + ubi_gpio_init();
39857 +
39858 + return 0;
39859 +}
39860 +
39861 +arch_initcall(ip7500module_init);
39862 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500wspkr.c linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500wspkr.c
39863 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/board-ip7500wspkr.c 1970-01-01 02:00:00.000000000 +0200
39864 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/board-ip7500wspkr.c 2009-12-11 11:45:11.000000000 +0200
39865 @@ -0,0 +1,101 @@
39866 +/*
39867 + * arch/ubicom32/mach-ip7k/board-ip7500wspkr.c
39868 + * Support for IP7500 Wireless Speaker board.
39869 + *
39870 + * This file supports the IP7500 Wireless Speaker board:
39871 + * 8007-1210 Rev 1.0
39872 + *
39873 + * (C) Copyright 2009, Ubicom, Inc.
39874 + *
39875 + * This file is part of the Ubicom32 Linux Kernel Port.
39876 + *
39877 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
39878 + * it and/or modify it under the terms of the GNU General Public License
39879 + * as published by the Free Software Foundation, either version 2 of the
39880 + * License, or (at your option) any later version.
39881 + *
39882 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
39883 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
39884 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
39885 + * the GNU General Public License for more details.
39886 + *
39887 + * You should have received a copy of the GNU General Public License
39888 + * along with the Ubicom32 Linux Kernel Port. If not,
39889 + * see <http://www.gnu.org/licenses/>.
39890 + */
39891 +#include <linux/device.h>
39892 +#include <linux/gpio.h>
39893 +#include <asm/board.h>
39894 +
39895 +#include <linux/platform_device.h>
39896 +#include <asm/audio.h>
39897 +#include <linux/i2c.h>
39898 +#include <linux/i2c-gpio.h>
39899 +
39900 +static struct i2c_board_info __initdata ip7500wspkr_i2c_board_info[] = {
39901 + /*
39902 + * U6, CS4350 DAC, address 0x4B
39903 + */
39904 + {
39905 + .type = "cs4350",
39906 + .addr = 0x4B,
39907 + },
39908 +};
39909 +
39910 +/*
39911 + * I2C bus on the board, SDA PE4, SCL PE5
39912 + */
39913 +static struct i2c_gpio_platform_data ip7500wspkr_i2c_data = {
39914 + .sda_pin = GPIO_RD_5,
39915 + .scl_pin = GPIO_RD_6,
39916 + .sda_is_open_drain = 0,
39917 + .scl_is_open_drain = 0,
39918 + .udelay = 50,
39919 +};
39920 +
39921 +static struct platform_device ip7500wspkr_i2c_device = {
39922 + .name = "i2c-gpio",
39923 + .id = 0,
39924 + .dev = {
39925 + .platform_data = &ip7500wspkr_i2c_data,
39926 + },
39927 +};
39928 +
39929 +static struct platform_device *ip7500wspkr_devices[] __initdata = {
39930 + &ip7500wspkr_i2c_device,
39931 +};
39932 +
39933 +/*
39934 + * ip7500wspkr_init
39935 + * Called to add the devices which we have on this board
39936 + */
39937 +static int __init ip7500wspkr_init(void)
39938 +{
39939 + struct platform_device *audio_dev;
39940 + struct platform_device *audio_dev2;
39941 +
39942 + board_init();
39943 +
39944 + ubi_gpio_init();
39945 +
39946 + platform_add_devices(ip7500wspkr_devices, ARRAY_SIZE(ip7500wspkr_devices));
39947 +
39948 + audio_dev = audio_device_alloc("snd-ubi32-cs4350", "audio", "audio-i2sout", 0);
39949 + if (audio_dev) {
39950 + ip7500wspkr_i2c_board_info[0].platform_data = audio_dev;
39951 + }
39952 +
39953 + audio_dev2 = audio_device_alloc("snd-ubi32-generic", "audio", "audio-spdifout", 0);
39954 + if (audio_dev2) {
39955 + platform_device_register(audio_dev2);
39956 + }
39957 +
39958 + printk(KERN_INFO "%s: registering i2c resources\n", __FUNCTION__);
39959 + i2c_register_board_info(0, ip7500wspkr_i2c_board_info, ARRAY_SIZE(ip7500wspkr_i2c_board_info));
39960 +
39961 + printk(KERN_INFO "IP7500 Wireless Speaker Board\n");
39962 +
39963 + return 0;
39964 +}
39965 +
39966 +arch_initcall(ip7500wspkr_init);
39967 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/Kconfig linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/Kconfig
39968 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/Kconfig 1970-01-01 02:00:00.000000000 +0200
39969 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/Kconfig 2009-12-11 11:45:11.000000000 +0200
39970 @@ -0,0 +1,205 @@
39971 +config IP7145DPF
39972 + bool "IP7145DPF"
39973 + select UBICOM32_V4
39974 + select UBICOM_INPUT
39975 + select UBICOM_INPUT_I2C
39976 + select RTC_CLASS
39977 + select RTC_DRV_S35390A
39978 + select I2C
39979 + select I2C_GPIO
39980 + select GPIO_PCA953X
39981 + select FB
39982 + select FB_UBICOM32
39983 + select LCD_CLASS_DEVICE
39984 + select LCD_UBICOM32POWER
39985 + select BACKLIGHT_LCD_SUPPORT
39986 + select BACKLIGHT_CLASS_DEVICE
39987 + select BACKLIGHT_UBICOM32
39988 + select SND_UBI32
39989 + select MMC_UBICOM32
39990 + select MMC
39991 + select MMC_BLOCK
39992 + help
39993 + IP7145 Digital Picture Frame reference design, supports:
39994 + 8007-0410 v1.0
39995 +
39996 +config IP7160RGW
39997 + bool "IP7160RGW"
39998 + select UBICOM32_V4
39999 + select UBICOM_INPUT
40000 + select NEW_LEDS
40001 + select LEDS_CLASS
40002 + select LEDS_GPIO
40003 + select SPI
40004 + select SPI_UBICOM32_GPIO
40005 + select VLAN_8021Q
40006 + select UBICOM_SWITCH
40007 + select UBICOM_SWITCH_BCM539X
40008 + help
40009 + Ubicom IP7160 RGW Eval, supports:
40010 + 8007-0110 v1.0
40011 + 8007-0111 v1.1
40012 + 8007-0112 v1.2
40013 +
40014 +config IP7160RGWLCD
40015 + bool "IP7160RGWLCD"
40016 + select UBICOM32_V4
40017 + select UBICOM_INPUT
40018 + select NEW_LEDS
40019 + select LEDS_CLASS
40020 + select LEDS_GPIO
40021 + select SPI
40022 + select SPI_UBICOM32_GPIO
40023 + select VLAN_8021Q
40024 + select UBICOM_SWITCH
40025 + select UBICOM_SWITCH_BCM539X
40026 + select INPUT_TOUCHSCREEN
40027 + select TOUCHSCREEN_TSC2007
40028 + select FB
40029 + select FB_UBICOM32_VIRTUAL
40030 + select I2C
40031 + select I2C_GPIO
40032 + help
40033 + Ubicom IP7160 RGW Eval, supports:
40034 + 8007-0112 v1.2 + 8007-1410 v1.0
40035 +
40036 + With Ubicom LCD Adapter
40037 + 8007-0920 v2.0
40038 + 8007-0921 v2.1
40039 +
40040 +
40041 +config IP7160BRINGUP
40042 + bool "IP7160BRINGUP"
40043 + select UBICOM32_V4
40044 + select NEW_LEDS
40045 + select LEDS_CLASS
40046 + select LEDS_GPIO
40047 + help
40048 + Ubicom IP7160 Bringup, supports:
40049 + 8007-0010 v1.0
40050 +
40051 +config IP7160DPF
40052 + bool "IP7160DPF"
40053 + select UBICOM32_V4
40054 + select I2C
40055 + select I2C_GPIO
40056 + select FB
40057 + select FB_UBICOM32
40058 + select BACKLIGHT_LCD_SUPPORT
40059 + select BACKLIGHT_CLASS_DEVICE
40060 + select SND_UBI32
40061 + select SND_UBI32_AUDIO_CS4350
40062 + select UBICOM_HID
40063 + help
40064 + IP7160 Digital Picture Frame board, supports:
40065 + 8007-0211 Rev 1.1
40066 +
40067 +config IP7500MODULE
40068 + bool "IP7500MODULE"
40069 + select UBICOM32_V4
40070 + help
40071 + Ubicom IP7500 CPU Module board, supports:
40072 + 8007-0510 v1.0
40073 + 8007-0510A v1.0
40074 +
40075 + Please see ip7500module.c for more details.
40076 +
40077 +config IP7500AV
40078 + bool "IP7500AV"
40079 + select UBICOM32_V4
40080 + select I2C
40081 + select I2C_GPIO
40082 + select SND_UBI32
40083 + select SND_UBI32_AUDIO_CS4384
40084 + select FB
40085 + select FB_UBICOM32
40086 + help
40087 + Ubicom IP7500 Audio Video board, supports:
40088 + 8007-0810 v1.0
40089 +
40090 + With Ubicom IP7500 CPU Module board:
40091 + 8007-0510 v1.0 -or-
40092 + 8007-0510A v1.0
40093 +
40094 + Please see ip7500av.c for more details.
40095 +
40096 +config IP7500MEDIA
40097 + bool "IP7500MEDIA"
40098 + select UBICOM32_V4
40099 + select UBICOM_INPUT_I2C
40100 + select RTC_CLASS
40101 + select RTC_DRV_S35390A
40102 + select I2C
40103 + select I2C_GPIO
40104 + select GPIO_PCA953X
40105 + select FB
40106 + select FB_UBICOM32
40107 + select FB_UBICOM32_VIRTUAL
40108 + select FB_UBICOM32_VIRTUAL_NOAUTO
40109 + select LCD_CLASS_DEVICE
40110 + select LCD_UBICOM32POWER
40111 + select BACKLIGHT_LCD_SUPPORT
40112 + select BACKLIGHT_CLASS_DEVICE
40113 + select BACKLIGHT_UBICOM32
40114 + select INPUT_TOUCHSCREEN
40115 + select TOUCHSCREEN_TSC2007
40116 + select SOUND
40117 + select SND
40118 + select SND_UBI32
40119 + select SND_UBI32_AUDIO_CS4350
40120 + select MMC_UBICOM32
40121 + select MMC
40122 + select MMC_BLOCK
40123 + help
40124 + IP7500 Media Board w/ IP7500 CPU Module board, supports:
40125 + 8007-0610 v1.0 w/ 8007-0510 v1.0
40126 + 8007-0610 v1.0 w/ 8007-0510 v1.0 NOPHY
40127 + 8007-0610 v1.0 w/ 8007-0511 v1.1 NOPHY
40128 +
40129 + Also supports optional LCD Adapter board:
40130 + 8006-0920 v2.0
40131 + 8006-0921 v2.1
40132 +
40133 + Please see ip7500media.c for more details.
40134 +
40135 +config IP7500WSPKR
40136 + bool "IP7500WSPKR"
40137 + select UBICOM32_V4
40138 + select I2C
40139 + select I2C_GPIO
40140 + select SOUND
40141 + select SND
40142 + select SND_UBI32
40143 + select SND_UBI32_AUDIO_CS4350
40144 + help
40145 + IP7500 Wireless Speaker Board, supports:
40146 + 8007-1210 v1.0
40147 +
40148 + Please see ip7500wspkr.c for more details.
40149 +
40150 +config IP7500IAP
40151 + bool "IP7500IAP"
40152 + select UBICOM32_V4
40153 + select I2C
40154 + select I2C_GPIO
40155 + select FB
40156 + select FB_UBICOM32_VIRTUAL
40157 + select SOUND
40158 + select SND
40159 + select SND_UBI32
40160 + select SND_UBI32_AUDIO_CS4350
40161 + select RTC_CLASS
40162 + select RTC_DRV_S35390A
40163 + select INPUT_TOUCHSCREEN
40164 + select TOUCHSCREEN_TSC2007
40165 + select BACKLIGHT_LCD_SUPPORT
40166 + select BACKLIGHT_CLASS_DEVICE
40167 + select BACKLIGHT_UBICOM32
40168 + help
40169 + IP7500 Internet Audio Player, supports:
40170 + 8007-1110 v1.0
40171 +
40172 + Please see ip7500iap.c for more details.
40173 +
40174 +
40175 + Please see ip7500media.c for more details.
40176 diff -ruN linux-2.6.30.10/arch/ubicom32/mach-ip7k/Makefile linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/Makefile
40177 --- linux-2.6.30.10/arch/ubicom32/mach-ip7k/Makefile 1970-01-01 02:00:00.000000000 +0200
40178 +++ linux-2.6.30.10-ubi/arch/ubicom32/mach-ip7k/Makefile 2009-12-11 11:45:11.000000000 +0200
40179 @@ -0,0 +1,38 @@
40180 +#
40181 +# arch/ubicom32/mach-ip7k/Makefile
40182 +# Makefile for ip7k based boards.
40183 +#
40184 +# (C) Copyright 2009, Ubicom, Inc.
40185 +#
40186 +# This file is part of the Ubicom32 Linux Kernel Port.
40187 +#
40188 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
40189 +# it and/or modify it under the terms of the GNU General Public License
40190 +# as published by the Free Software Foundation, either version 2 of the
40191 +# License, or (at your option) any later version.
40192 +#
40193 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
40194 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
40195 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40196 +# the GNU General Public License for more details.
40197 +#
40198 +# You should have received a copy of the GNU General Public License
40199 +# along with the Ubicom32 Linux Kernel Port. If not,
40200 +# see <http://www.gnu.org/licenses/>.
40201 +#
40202 +# Ubicom32 implementation derived from (with many thanks):
40203 +# arch/m68knommu
40204 +# arch/blackfin
40205 +# arch/parisc
40206 +#
40207 +
40208 +obj-$(CONFIG_IP7145DPF) += board-ip7145dpf.o
40209 +obj-$(CONFIG_IP7160RGW) += board-ip7160rgw.o
40210 +obj-$(CONFIG_IP7160RGWLCD) += board-ip7160rgw.o
40211 +obj-$(CONFIG_IP7160BRINGUP) += board-ip7160bringup.o
40212 +obj-$(CONFIG_IP7160DPF) += board-ip7160dpf.o
40213 +obj-$(CONFIG_IP7500MODULE) += board-ip7500module.o
40214 +obj-$(CONFIG_IP7500MEDIA) += board-ip7500media.o
40215 +obj-$(CONFIG_IP7500AV) += board-ip7500av.o
40216 +obj-$(CONFIG_IP7500WSPKR) += board-ip7500wspkr.o
40217 +obj-$(CONFIG_IP7500IAP) += board-ip7500iap.o
40218 diff -ruN linux-2.6.30.10/arch/ubicom32/Makefile linux-2.6.30.10-ubi/arch/ubicom32/Makefile
40219 --- linux-2.6.30.10/arch/ubicom32/Makefile 1970-01-01 02:00:00.000000000 +0200
40220 +++ linux-2.6.30.10-ubi/arch/ubicom32/Makefile 2009-12-11 11:45:11.000000000 +0200
40221 @@ -0,0 +1,104 @@
40222 +#
40223 +# arch/ubicom32/Makefile
40224 +# <TODO: Replace with short file description>
40225 +#
40226 +# (C) Copyright 2009, Ubicom, Inc.
40227 +#
40228 +# This file is part of the Ubicom32 Linux Kernel Port.
40229 +#
40230 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
40231 +# it and/or modify it under the terms of the GNU General Public License
40232 +# as published by the Free Software Foundation, either version 2 of the
40233 +# License, or (at your option) any later version.
40234 +#
40235 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
40236 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
40237 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40238 +# the GNU General Public License for more details.
40239 +#
40240 +# You should have received a copy of the GNU General Public License
40241 +# along with the Ubicom32 Linux Kernel Port. If not,
40242 +# see <http://www.gnu.org/licenses/>.
40243 +#
40244 +# Ubicom32 implementation derived from (with many thanks):
40245 +# arch/m68knommu
40246 +# arch/blackfin
40247 +# arch/parisc
40248 +#
40249 +
40250 +KBUILD_DEFCONFIG :=
40251 +
40252 +# setup the machine name and machine dependent settings
40253 +machine-$(CONFIG_UBICOM32_V3) := ip5k
40254 +machine-$(CONFIG_UBICOM32_V4) := ip7k
40255 +MACHINE := $(machine-y)
40256 +export MACHINE
40257 +
40258 +model-$(CONFIG_RAMKERNEL) := ram
40259 +model-$(CONFIG_ROMKERNEL) := rom
40260 +MODEL := $(model-y)
40261 +export MODEL
40262 +
40263 +CPUCLASS := $(cpuclass-y)
40264 +
40265 +export CPUCLASS
40266 +
40267 +#
40268 +# We want the core kernel built using the fastcall ABI but modules need
40269 +# to be built using the slower calling convention because they could be
40270 +# loaded out of range for fast calls.
40271 +#
40272 +CFLAGS_KERNEL += -mfastcall
40273 +CFLAGS_MODULE += -mno-fastcall
40274 +
40275 +#
40276 +# Some CFLAG additions based on specific CPU type.
40277 +#
40278 +cflags-$(CONFIG_UBICOM32_V3) := -march=ubicom32v3 -DIP5000
40279 +cflags-$(CONFIG_UBICOM32_V4) := -march=ubicom32v4 -DIP7000
40280 +
40281 +ldflags-$(CONFIG_LINKER_RELAXATION) := --relax
40282 +LDFLAGS_vmlinux := $(ldflags-y)
40283 +
40284 +GCCLIBDIR := $(dir $(shell $(CC) $(cflags-y) -print-libgcc-file-name))
40285 +GCC_LIBS := $(GCCLIBDIR)/libgcc.a
40286 +
40287 +KBUILD_CFLAGS += $(cflags-y) -ffunction-sections
40288 +KBUILD_AFLAGS += $(cflags-y)
40289 +
40290 +KBUILD_CFLAGS += -D__linux__ -Dlinux
40291 +KBUILD_CFLAGS += -DUTS_SYSNAME=\"uClinux\"
40292 +
40293 +# include any machine specific directory
40294 +ifneq ($(machine-y),)
40295 +core-y += arch/$(ARCH)/mach-$(MACHINE)/
40296 +endif
40297 +
40298 +head-y := arch/$(ARCH)/kernel/head.o
40299 +
40300 +core-y += arch/$(ARCH)/kernel/ \
40301 + arch/$(ARCH)/mm/ \
40302 + arch/$(ARCH)/crypto/ \
40303 + arch/$(ARCH)/mach-common/
40304 +
40305 +drivers-$(CONFIG_OPROFILE) += arch/ubicom32/oprofile/
40306 +
40307 +libs-y += arch/$(ARCH)/lib/
40308 +libs-y += $(GCC_LIBS)
40309 +
40310 +archclean:
40311 +
40312 +# make sure developer has selected a valid board
40313 +ifeq ($(CONFIG_NOBOARD),y)
40314 +# $(error have to select a valid board file $(CONFIG_NOBOARD), please run kernel config again)
40315 +_all: config_board_error
40316 +endif
40317 +
40318 +config_board_error:
40319 + @echo "*************************************************"
40320 + @echo "You have not selected a proper board."
40321 + @echo "Please run menuconfig (or config) against your"
40322 + @echo "kernel and choose your board under Processor"
40323 + @echo "options"
40324 + @echo "*************************************************"
40325 + @exit 1
40326 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/fault.c linux-2.6.30.10-ubi/arch/ubicom32/mm/fault.c
40327 --- linux-2.6.30.10/arch/ubicom32/mm/fault.c 1970-01-01 02:00:00.000000000 +0200
40328 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/fault.c 2009-12-11 11:45:11.000000000 +0200
40329 @@ -0,0 +1,80 @@
40330 +/*
40331 + * arch/ubicom32/mm/fault.c
40332 + * Ubicom32 architecture page fault implementation.
40333 + *
40334 + * (C) Copyright 2009, Ubicom, Inc.
40335 + * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>,
40336 + * Copyright (C) 2000 Lineo, Inc. (www.lineo.com)
40337 + *
40338 + * Based on:
40339 + *
40340 + * linux/arch/m68k/mm/fault.c
40341 + *
40342 + * Copyright (C) 1995 Hamish Macdonald
40343 + *
40344 + * This file is part of the Ubicom32 Linux Kernel Port.
40345 + *
40346 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
40347 + * it and/or modify it under the terms of the GNU General Public License
40348 + * as published by the Free Software Foundation, either version 2 of the
40349 + * License, or (at your option) any later version.
40350 + *
40351 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
40352 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
40353 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40354 + * the GNU General Public License for more details.
40355 + *
40356 + * You should have received a copy of the GNU General Public License
40357 + * along with the Ubicom32 Linux Kernel Port. If not,
40358 + * see <http://www.gnu.org/licenses/>.
40359 + *
40360 + * Ubicom32 implementation derived from (with many thanks):
40361 + * arch/m68knommu
40362 + * arch/blackfin
40363 + * arch/parisc
40364 + */
40365 +
40366 +#include <linux/module.h>
40367 +#include <linux/mman.h>
40368 +#include <linux/mm.h>
40369 +#include <linux/kernel.h>
40370 +#include <linux/ptrace.h>
40371 +
40372 +#include <asm/system.h>
40373 +#include <asm/pgtable.h>
40374 +
40375 +extern void die_if_kernel(char *, struct pt_regs *, long);
40376 +
40377 +/*
40378 + * This routine handles page faults. It determines the problem, and
40379 + * then passes it off to one of the appropriate routines.
40380 + *
40381 + * error_code:
40382 + * bit 0 == 0 means no page found, 1 means protection fault
40383 + * bit 1 == 0 means read, 1 means write
40384 + *
40385 + * If this routine detects a bad access, it returns 1, otherwise it
40386 + * returns 0.
40387 + */
40388 +asmlinkage int do_page_fault(struct pt_regs *regs, unsigned long address,
40389 + unsigned long error_code)
40390 +{
40391 +#ifdef DEBUG
40392 + printk (KERN_DEBUG "regs->sr=%#x, regs->pc=%#lx, address=%#lx, %ld\n",
40393 + regs->sr, regs->pc, address, error_code);
40394 +#endif
40395 +
40396 + /*
40397 + * Oops. The kernel tried to access some bad page. We'll have to
40398 + * terminate things with extreme prejudice.
40399 + */
40400 + if ((unsigned long) address < PAGE_SIZE) {
40401 + printk(KERN_ALERT "Unable to handle kernel NULL pointer dereference");
40402 + } else
40403 + printk(KERN_ALERT "Unable to handle kernel access");
40404 + printk(KERN_ALERT " at virtual address %08lx\n",address);
40405 + die_if_kernel("Oops", regs, error_code);
40406 + do_exit(SIGKILL);
40407 +
40408 + return 1;
40409 +}
40410 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/init.c linux-2.6.30.10-ubi/arch/ubicom32/mm/init.c
40411 --- linux-2.6.30.10/arch/ubicom32/mm/init.c 1970-01-01 02:00:00.000000000 +0200
40412 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/init.c 2009-12-11 11:45:11.000000000 +0200
40413 @@ -0,0 +1,262 @@
40414 +/*
40415 + * arch/ubicom32/mm/init.c
40416 + * Ubicom32 architecture virtual memory initialization.
40417 + *
40418 + * (C) Copyright 2009, Ubicom, Inc.
40419 + * Copyright (C) 1998 D. Jeff Dionne <jeff@lineo.ca>,
40420 + * Kenneth Albanowski <kjahds@kjahds.com>,
40421 + * Copyright (C) 2000 Lineo, Inc. (www.lineo.com)
40422 + *
40423 + * Based on:
40424 + *
40425 + * linux/arch/m68k/mm/init.c
40426 + *
40427 + * Copyright (C) 1995 Hamish Macdonald
40428 + *
40429 + * JAN/1999 -- hacked to support ColdFire (gerg@snapgear.com)
40430 + * DEC/2000 -- linux 2.4 support <davidm@snapgear.com>
40431 + *
40432 + * This file is part of the Ubicom32 Linux Kernel Port.
40433 + *
40434 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
40435 + * it and/or modify it under the terms of the GNU General Public License
40436 + * as published by the Free Software Foundation, either version 2 of the
40437 + * License, or (at your option) any later version.
40438 + *
40439 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
40440 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
40441 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40442 + * the GNU General Public License for more details.
40443 + *
40444 + * You should have received a copy of the GNU General Public License
40445 + * along with the Ubicom32 Linux Kernel Port. If not,
40446 + * see <http://www.gnu.org/licenses/>.
40447 + *
40448 + * Ubicom32 implementation derived from (with many thanks):
40449 + * arch/m68knommu
40450 + * arch/blackfin
40451 + * arch/parisc
40452 + */
40453 +
40454 +#include <linux/signal.h>
40455 +#include <linux/sched.h>
40456 +#include <linux/kernel.h>
40457 +#include <linux/errno.h>
40458 +#include <linux/string.h>
40459 +#include <linux/types.h>
40460 +#include <linux/ptrace.h>
40461 +#include <linux/mman.h>
40462 +#include <linux/mm.h>
40463 +#include <linux/swap.h>
40464 +#include <linux/init.h>
40465 +#include <linux/highmem.h>
40466 +#include <linux/pagemap.h>
40467 +#include <linux/bootmem.h>
40468 +#include <linux/slab.h>
40469 +
40470 +#include <asm/setup.h>
40471 +#include <asm/segment.h>
40472 +#include <asm/page.h>
40473 +#include <asm/pgtable.h>
40474 +#include <asm/system.h>
40475 +#include <asm/machdep.h>
40476 +#include <asm/ocm-alloc.h>
40477 +#include <asm/processor.h>
40478 +
40479 +#undef DEBUG
40480 +
40481 +extern void die_if_kernel(char *,struct pt_regs *,long);
40482 +extern void free_initmem(void);
40483 +
40484 +/*
40485 + * BAD_PAGE is the page that is used for page faults when linux
40486 + * is out-of-memory. Older versions of linux just did a
40487 + * do_exit(), but using this instead means there is less risk
40488 + * for a process dying in kernel mode, possibly leaving a inode
40489 + * unused etc..
40490 + *
40491 + * BAD_PAGETABLE is the accompanying page-table: it is initialized
40492 + * to point to BAD_PAGE entries.
40493 + *
40494 + * ZERO_PAGE is a special page that is used for zero-initialized
40495 + * data and COW.
40496 + */
40497 +static unsigned long empty_bad_page_table;
40498 +
40499 +static unsigned long empty_bad_page;
40500 +
40501 +unsigned long empty_zero_page;
40502 +
40503 +void show_mem(void)
40504 +{
40505 + unsigned long i;
40506 + int free = 0, total = 0, reserved = 0, shared = 0;
40507 + int cached = 0;
40508 +
40509 + printk(KERN_INFO "\nMem-info:\n");
40510 + show_free_areas();
40511 + i = max_mapnr;
40512 + while (i-- > 0) {
40513 + total++;
40514 + if (PageReserved(mem_map+i))
40515 + reserved++;
40516 + else if (PageSwapCache(mem_map+i))
40517 + cached++;
40518 + else if (!page_count(mem_map+i))
40519 + free++;
40520 + else
40521 + shared += page_count(mem_map+i) - 1;
40522 + }
40523 + printk(KERN_INFO "%d pages of RAM\n",total);
40524 + printk(KERN_INFO "%d free pages\n",free);
40525 + printk(KERN_INFO "%d reserved pages\n",reserved);
40526 + printk(KERN_INFO "%d pages shared\n",shared);
40527 + printk(KERN_INFO "%d pages swap cached\n",cached);
40528 +}
40529 +
40530 +extern unsigned long memory_start;
40531 +extern unsigned long memory_end;
40532 +extern char __ocm_free_begin;
40533 +extern char __ocm_free_end;
40534 +
40535 +/*
40536 + * paging_init() continues the virtual memory environment setup which
40537 + * was begun by the code in arch/head.S.
40538 + * The parameters are pointers to where to stick the starting and ending
40539 + * addresses of available kernel virtual memory.
40540 + */
40541 +void __init paging_init(void)
40542 +{
40543 + /*
40544 + * Make sure start_mem is page aligned, otherwise bootmem and
40545 + * page_alloc get different views of the world.
40546 + */
40547 +#ifdef DEBUG
40548 + unsigned long start_mem = PAGE_ALIGN(memory_start);
40549 +#endif
40550 + unsigned long end_mem = memory_end & PAGE_MASK;
40551 +
40552 +#ifdef DEBUG
40553 + printk (KERN_DEBUG "start_mem is %#lx\nvirtual_end is %#lx\n",
40554 + start_mem, end_mem);
40555 +#endif
40556 +
40557 + /*
40558 + * Initialize the bad page table and bad page to point
40559 + * to a couple of allocated pages.
40560 + */
40561 + empty_bad_page_table = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
40562 + empty_bad_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
40563 + empty_zero_page = (unsigned long)alloc_bootmem_pages(PAGE_SIZE);
40564 + memset((void *)empty_zero_page, 0, PAGE_SIZE);
40565 +
40566 + /*
40567 + * TODO: enable setting up for user memory management interface.
40568 + */
40569 +
40570 +#ifdef DEBUG
40571 + printk (KERN_DEBUG "before free_area_init\n");
40572 +
40573 + printk (KERN_DEBUG "free_area_init -> start_mem is %#lx\nvirtual_end is %#lx\n",
40574 + start_mem, end_mem);
40575 +#endif
40576 +
40577 + {
40578 + unsigned long zones_size[MAX_NR_ZONES] = {0, };
40579 +#ifdef CONFIG_ZONE_DMA
40580 + zones_size[ZONE_DMA] = OCMSIZE >> PAGE_SHIFT;
40581 +#endif
40582 + zones_size[ZONE_NORMAL] = (end_mem - PAGE_OFFSET) >> PAGE_SHIFT;
40583 +#ifdef CONFIG_HIGHMEM
40584 + zones_size[ZONE_HIGHMEM] = 0;
40585 +#endif
40586 + free_area_init(zones_size);
40587 + }
40588 +}
40589 +
40590 +void __init mem_init(void)
40591 +{
40592 + int codek = 0, datak = 0, initk = 0;
40593 + unsigned long tmp, ram_start, ram_end, len;
40594 + extern char _etext, _stext, _sdata, _ebss, __init_begin, __init_end;
40595 +
40596 + unsigned long start_mem = memory_start; /* DAVIDM - these must start at end of kernel */
40597 + unsigned long end_mem = memory_end; /* DAVIDM - this must not include kernel stack at top */
40598 + processor_dram(&ram_start, &ram_end);
40599 + len = (ram_end - ram_start) + OCMSIZE;
40600 +#ifdef DEBUG
40601 + printk(KERN_DEBUG "Mem_init: start=%lx, end=%lx\n", start_mem, end_mem);
40602 +#endif
40603 +
40604 + end_mem &= PAGE_MASK;
40605 + high_memory = (void *) end_mem;
40606 +
40607 + start_mem = PAGE_ALIGN(start_mem);
40608 + max_mapnr = num_physpages = (((unsigned long) high_memory) - PAGE_OFFSET) >> PAGE_SHIFT;
40609 +
40610 + /* this will put all memory onto the freelists */
40611 +#ifdef CONFIG_ZONE_DMA
40612 + {
40613 + unsigned long ocm_free_begin = (unsigned long)&__ocm_free_begin;
40614 + unsigned long ocm_free_end = (unsigned long)&__ocm_free_end;
40615 + unsigned long zone_dma_begin = (ocm_free_begin + PAGE_SIZE - 1) & PAGE_MASK;
40616 + unsigned long zone_dma_end = ocm_free_end & PAGE_MASK;
40617 + if (zone_dma_end > zone_dma_begin)
40618 + free_bootmem(zone_dma_begin, zone_dma_end-zone_dma_begin);
40619 + }
40620 +#endif
40621 + totalram_pages = free_all_bootmem();
40622 +
40623 + codek = (&_etext - &_stext) >> 10;
40624 + datak = (&_ebss - &_sdata) >> 10;
40625 + initk = (&__init_begin - &__init_end) >> 10;
40626 +
40627 + tmp = nr_free_pages() << PAGE_SHIFT;
40628 + printk(KERN_INFO "Memory available: %luk/%luk RAM, (%dk kernel code, %dk data)\n",
40629 + tmp >> 10,
40630 + len >> 10,
40631 + codek,
40632 + datak
40633 + );
40634 +
40635 +}
40636 +
40637 +#ifdef CONFIG_BLK_DEV_INITRD
40638 +void free_initrd_mem(unsigned long start, unsigned long end)
40639 +{
40640 + int pages = 0;
40641 + for (; start < end; start += PAGE_SIZE) {
40642 + ClearPageReserved(virt_to_page(start));
40643 + init_page_count(virt_to_page(start));
40644 + free_page(start);
40645 + totalram_pages++;
40646 + pages++;
40647 + }
40648 + printk (KERN_NOTICE "Freeing initrd memory: %dk freed\n", pages);
40649 +}
40650 +#endif
40651 +
40652 +void
40653 +free_initmem()
40654 +{
40655 +#ifdef CONFIG_RAMKERNEL
40656 + unsigned long addr;
40657 + extern char __init_begin, __init_end;
40658 + /*
40659 + * The following code should be cool even if these sections
40660 + * are not page aligned.
40661 + */
40662 + addr = PAGE_ALIGN((unsigned long)(&__init_begin));
40663 + /* next to check that the page we free is not a partial page */
40664 + for (; addr + PAGE_SIZE < (unsigned long)(&__init_end); addr +=PAGE_SIZE) {
40665 + ClearPageReserved(virt_to_page(addr));
40666 + init_page_count(virt_to_page(addr));
40667 + free_page(addr);
40668 + totalram_pages++;
40669 + }
40670 + printk(KERN_NOTICE "Freeing unused kernel memory: %ldk freed (0x%x - 0x%x)\n",
40671 + (addr - PAGE_ALIGN((long) &__init_begin)) >> 10,
40672 + (int)(PAGE_ALIGN((unsigned long)(&__init_begin))),
40673 + (int)(addr - PAGE_SIZE));
40674 +#endif
40675 +}
40676 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/kmap.c linux-2.6.30.10-ubi/arch/ubicom32/mm/kmap.c
40677 --- linux-2.6.30.10/arch/ubicom32/mm/kmap.c 1970-01-01 02:00:00.000000000 +0200
40678 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/kmap.c 2009-12-11 11:45:11.000000000 +0200
40679 @@ -0,0 +1,79 @@
40680 +/*
40681 + * arch/ubicom32/mm/kmap.c
40682 + * Ubicom32 architecture non-mmu ioremap and friends implementation.
40683 + *
40684 + * (C) Copyright 2009, Ubicom, Inc.
40685 + * Copyright (C) 2000 Lineo, <davidm@snapgear.com>
40686 + * Copyright (C) 2000-2002 David McCullough <davidm@snapgear.com>
40687 + *
40688 + * This file is part of the Ubicom32 Linux Kernel Port.
40689 + *
40690 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
40691 + * it and/or modify it under the terms of the GNU General Public License
40692 + * as published by the Free Software Foundation, either version 2 of the
40693 + * License, or (at your option) any later version.
40694 + *
40695 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
40696 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
40697 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40698 + * the GNU General Public License for more details.
40699 + *
40700 + * You should have received a copy of the GNU General Public License
40701 + * along with the Ubicom32 Linux Kernel Port. If not,
40702 + * see <http://www.gnu.org/licenses/>.
40703 + *
40704 + * Ubicom32 implementation derived from (with many thanks):
40705 + * arch/m68knommu
40706 + * arch/blackfin
40707 + * arch/parisc
40708 + */
40709 +
40710 +#include <linux/module.h>
40711 +#include <linux/mm.h>
40712 +#include <linux/kernel.h>
40713 +#include <linux/string.h>
40714 +#include <linux/types.h>
40715 +#include <linux/slab.h>
40716 +#include <linux/vmalloc.h>
40717 +
40718 +#include <asm/setup.h>
40719 +#include <asm/segment.h>
40720 +#include <asm/page.h>
40721 +#include <asm/pgalloc.h>
40722 +#include <asm/io.h>
40723 +#include <asm/system.h>
40724 +
40725 +#undef DEBUG
40726 +
40727 +/*
40728 + * Map some physical address range into the kernel address space.
40729 + */
40730 +void *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag)
40731 +{
40732 + return (void *)physaddr;
40733 +}
40734 +
40735 +/*
40736 + * Unmap a ioremap()ed region again.
40737 + */
40738 +void iounmap(void *addr)
40739 +{
40740 +}
40741 +
40742 +/*
40743 + * __iounmap unmaps nearly everything, so be careful
40744 + * it doesn't free currently pointer/page tables anymore but it
40745 + * wans't used anyway and might be added later.
40746 + */
40747 +void __iounmap(void *addr, unsigned long size)
40748 +{
40749 +}
40750 +
40751 +/*
40752 + * Set new cache mode for some kernel address space.
40753 + * The caller must push data for that range itself, if such data may already
40754 + * be in the cache.
40755 + */
40756 +void kernel_set_cachemode(void *addr, unsigned long size, int cmode)
40757 +{
40758 +}
40759 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/Makefile linux-2.6.30.10-ubi/arch/ubicom32/mm/Makefile
40760 --- linux-2.6.30.10/arch/ubicom32/mm/Makefile 1970-01-01 02:00:00.000000000 +0200
40761 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/Makefile 2009-12-11 11:45:11.000000000 +0200
40762 @@ -0,0 +1,32 @@
40763 +#
40764 +# arch/ubicom32/mm/Makefile
40765 +# <TODO: Replace with short file description>
40766 +#
40767 +# (C) Copyright 2009, Ubicom, Inc.
40768 +#
40769 +# This file is part of the Ubicom32 Linux Kernel Port.
40770 +#
40771 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
40772 +# it and/or modify it under the terms of the GNU General Public License
40773 +# as published by the Free Software Foundation, either version 2 of the
40774 +# License, or (at your option) any later version.
40775 +#
40776 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
40777 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
40778 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40779 +# the GNU General Public License for more details.
40780 +#
40781 +# You should have received a copy of the GNU General Public License
40782 +# along with the Ubicom32 Linux Kernel Port. If not,
40783 +# see <http://www.gnu.org/licenses/>.
40784 +#
40785 +# Ubicom32 implementation derived from (with many thanks):
40786 +# arch/m68knommu
40787 +# arch/blackfin
40788 +# arch/parisc
40789 +#
40790 +#
40791 +# Makefile for the linux m68knommu specific parts of the memory manager.
40792 +#
40793 +
40794 +obj-y += init.o fault.o memory.o kmap.o ocm-alloc.o
40795 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/memory.c linux-2.6.30.10-ubi/arch/ubicom32/mm/memory.c
40796 --- linux-2.6.30.10/arch/ubicom32/mm/memory.c 1970-01-01 02:00:00.000000000 +0200
40797 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/memory.c 2009-12-11 11:45:11.000000000 +0200
40798 @@ -0,0 +1,58 @@
40799 +/*
40800 + * arch/ubicom32/mm/memory.c
40801 + * Ubicom32 architecture kernel_map() implementation.
40802 + *
40803 + * (C) Copyright 2009, Ubicom, Inc.
40804 + * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
40805 + * Copyright (C) 1999-2002, Greg Ungerer (gerg@snapgear.com)
40806 + *
40807 + * Based on:
40808 + *
40809 + * linux/arch/m68k/mm/memory.c
40810 + *
40811 + * Copyright (C) 1995 Hamish Macdonald
40812 + *
40813 + * This file is part of the Ubicom32 Linux Kernel Port.
40814 + *
40815 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
40816 + * it and/or modify it under the terms of the GNU General Public License
40817 + * as published by the Free Software Foundation, either version 2 of the
40818 + * License, or (at your option) any later version.
40819 + *
40820 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
40821 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
40822 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40823 + * the GNU General Public License for more details.
40824 + *
40825 + * You should have received a copy of the GNU General Public License
40826 + * along with the Ubicom32 Linux Kernel Port. If not,
40827 + * see <http://www.gnu.org/licenses/>.
40828 + *
40829 + * Ubicom32 implementation derived from (with many thanks):
40830 + * arch/m68knommu
40831 + * arch/blackfin
40832 + * arch/parisc
40833 + */
40834 +
40835 +#include <linux/module.h>
40836 +#include <linux/mm.h>
40837 +#include <linux/kernel.h>
40838 +#include <linux/string.h>
40839 +#include <linux/types.h>
40840 +#include <linux/slab.h>
40841 +
40842 +#include <asm/segment.h>
40843 +#include <asm/page.h>
40844 +#include <asm/pgtable.h>
40845 +#include <asm/system.h>
40846 +
40847 +/*
40848 + * Map some physical address range into the kernel address space.
40849 + * The code is copied and adapted from map_chunk().
40850 + */
40851 +
40852 +unsigned long kernel_map(unsigned long paddr, unsigned long size,
40853 + int nocacheflag, unsigned long *memavailp )
40854 +{
40855 + return paddr;
40856 +}
40857 diff -ruN linux-2.6.30.10/arch/ubicom32/mm/ocm-alloc.c linux-2.6.30.10-ubi/arch/ubicom32/mm/ocm-alloc.c
40858 --- linux-2.6.30.10/arch/ubicom32/mm/ocm-alloc.c 1970-01-01 02:00:00.000000000 +0200
40859 +++ linux-2.6.30.10-ubi/arch/ubicom32/mm/ocm-alloc.c 2009-12-11 11:45:11.000000000 +0200
40860 @@ -0,0 +1,487 @@
40861 +/*
40862 + * arch/ubicom32/mm/ocm-alloc.c
40863 + * OCM allocator for Uibcom32 On-Chip memory
40864 + *
40865 + * (C) Copyright 2009, Ubicom, Inc.
40866 + * Copyright 2004-2008 Analog Devices Inc.
40867 + *
40868 + * Based on:
40869 + *
40870 + * arch/blackfin/mm/sram-alloc.c
40871 + *
40872 + *
40873 + * This file is part of the Ubicom32 Linux Kernel Port.
40874 + *
40875 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
40876 + * it and/or modify it under the terms of the GNU General Public License
40877 + * as published by the Free Software Foundation, either version 2 of the
40878 + * License, or (at your option) any later version.
40879 + *
40880 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
40881 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
40882 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
40883 + * the GNU General Public License for more details.
40884 + *
40885 + * You should have received a copy of the GNU General Public License
40886 + * along with the Ubicom32 Linux Kernel Port. If not,
40887 + * see <http://www.gnu.org/licenses/>.
40888 + *
40889 + * Ubicom32 implementation derived from (with many thanks):
40890 + * arch/m68knommu
40891 + * arch/blackfin
40892 + * arch/parisc
40893 + */
40894 +
40895 +#include <linux/module.h>
40896 +#include <linux/kernel.h>
40897 +#include <linux/types.h>
40898 +#include <linux/miscdevice.h>
40899 +#include <linux/ioport.h>
40900 +#include <linux/fcntl.h>
40901 +#include <linux/init.h>
40902 +#include <linux/poll.h>
40903 +#include <linux/proc_fs.h>
40904 +#include <linux/mutex.h>
40905 +#include <linux/rtc.h>
40906 +#include <asm/ocm-alloc.h>
40907 +
40908 +#if 0
40909 +#define DEBUGP printk
40910 +#else
40911 +#define DEBUGP(fmt, a...)
40912 +#endif
40913 +/*
40914 + * the data structure for OCM heap pieces
40915 + */
40916 +struct ocm_piece {
40917 + void *paddr;
40918 + int size;
40919 + pid_t pid;
40920 + struct ocm_piece *next;
40921 +};
40922 +
40923 +/*
40924 + * struct ocm_heap
40925 + */
40926 +struct ocm_heap {
40927 + struct ocm_piece free_head;
40928 + struct ocm_piece used_head;
40929 + struct mutex lock;
40930 +};
40931 +
40932 +static struct ocm_heap ocm_inst_heap;
40933 +int ubi32_ocm_skbuf_max = 21, ubi32_ocm_skbuf, ubi32_ddr_skbuf;
40934 +
40935 +/*
40936 + * OCM area for storing code
40937 + */
40938 +extern asmlinkage void *__ocm_free_begin;
40939 +extern asmlinkage void *__ocm_free_end;
40940 +extern asmlinkage void *__ocm_inst_heap_begin;
40941 +extern asmlinkage void *__ocm_inst_heap_end;
40942 +#define OCM_INST_HEAP_BEGIN ((unsigned int)&__ocm_inst_heap_begin)
40943 +#define OCM_INST_HEAP_END ((unsigned int)&__ocm_inst_heap_end)
40944 +#define OCM_INST_HEAP_LENGTH (OCM_INST_HEAP_END - OCM_INST_HEAP_BEGIN)
40945 +
40946 +static struct kmem_cache *ocm_piece_cache;
40947 +
40948 +/*
40949 + * _ocm_heap_init()
40950 + */
40951 +static int __init _ocm_heap_init(struct ocm_heap *ocmh,
40952 + unsigned int start,
40953 + unsigned int size)
40954 +{
40955 + ocmh->free_head.next = kmem_cache_alloc(ocm_piece_cache, GFP_KERNEL);
40956 +
40957 + if (!ocmh->free_head.next)
40958 + return -1;
40959 +
40960 + ocmh->free_head.next->paddr = (void *)start;
40961 + ocmh->free_head.next->size = size;
40962 + ocmh->free_head.next->pid = 0;
40963 + ocmh->free_head.next->next = 0;
40964 +
40965 + ocmh->used_head.next = NULL;
40966 +
40967 + /* mutex initialize */
40968 + mutex_init(&ocmh->lock);
40969 +
40970 + return 0;
40971 +}
40972 +
40973 +/*
40974 + * _ocm_alloc_init()
40975 + *
40976 + * starts the ocm heap(s)
40977 + */
40978 +static int __init _ocm_alloc_init(void)
40979 +{
40980 + if (OCM_INST_HEAP_LENGTH) {
40981 + ocm_piece_cache = kmem_cache_create("ocm_piece_cache",
40982 + sizeof(struct ocm_piece),
40983 + 0, SLAB_PANIC, NULL);
40984 +
40985 + if (_ocm_heap_init(&ocm_inst_heap,
40986 + OCM_INST_HEAP_BEGIN,
40987 + OCM_INST_HEAP_LENGTH) == 0)
40988 + printk(KERN_INFO "OCM Instruction Heap %d KB\n",
40989 + OCM_INST_HEAP_LENGTH >> 10);
40990 + else
40991 + printk(KERN_INFO "Failed to initialize OCM "
40992 + "Instruction Heap\n");
40993 +
40994 + } else
40995 + printk(KERN_INFO "No space available for OCM "
40996 + "Instruction Heap\n");
40997 +
40998 + return 0;
40999 +}
41000 +pure_initcall(_ocm_alloc_init);
41001 +
41002 +/*
41003 + * _ocm_alloc()
41004 + * generic alloc a block in the ocm heap, if successful
41005 + * returns the pointer.
41006 + */
41007 +static void *_ocm_alloc(size_t size, pid_t pid, struct ocm_heap *ocmheap)
41008 +{
41009 + struct ocm_piece *pslot, *plast, *pavail;
41010 + struct ocm_piece *pfree_head = &ocmheap->free_head;
41011 + struct ocm_piece *pused_head = &ocmheap->used_head;
41012 +
41013 + if (size <= 0 || !pfree_head || !pused_head)
41014 + return NULL;
41015 +
41016 + /* Align the size */
41017 + size = (size + 3) & ~3;
41018 +
41019 + pslot = pfree_head->next;
41020 + plast = pfree_head;
41021 +
41022 + /*
41023 + * search an available piece slot
41024 + */
41025 + while (pslot != NULL && size > pslot->size) {
41026 + plast = pslot;
41027 + pslot = pslot->next;
41028 + }
41029 +
41030 + if (!pslot)
41031 + return NULL;
41032 +
41033 + if (pslot->size == size) {
41034 + /*
41035 + * Unlink this block from the list
41036 + */
41037 + plast->next = pslot->next;
41038 + pavail = pslot;
41039 + } else {
41040 + /*
41041 + * Split this block in two.
41042 + */
41043 + pavail = kmem_cache_alloc(ocm_piece_cache, GFP_KERNEL);
41044 +
41045 + if (!pavail)
41046 + return NULL;
41047 +
41048 + pavail->paddr = pslot->paddr;
41049 + pavail->size = size;
41050 + pslot->paddr += size;
41051 + pslot->size -= size;
41052 + }
41053 +
41054 + pavail->pid = pid;
41055 +
41056 + pslot = pused_head->next;
41057 + plast = pused_head;
41058 +
41059 + /*
41060 + * insert new piece into used piece list !!!
41061 + */
41062 + while (pslot != NULL && pavail->paddr < pslot->paddr) {
41063 + plast = pslot;
41064 + pslot = pslot->next;
41065 + }
41066 +
41067 + pavail->next = pslot;
41068 + plast->next = pavail;
41069 +
41070 + DEBUGP("_ocm_alloc %d bytes at %p from in %p",
41071 + size, pavail->paddr, ocmheap);
41072 +
41073 + return pavail->paddr;
41074 +}
41075 +
41076 +#if 0
41077 +/* Allocate the largest available block. */
41078 +static void *_ocm_alloc_max(struct ocm_heap *ocmheap,
41079 + unsigned long *psize)
41080 +{
41081 + struct ocm_piece *pfree_head = &ocmheap->free_head;
41082 + struct ocm_piece *pslot, *pmax;
41083 +
41084 + pmax = pslot = pfree_head->next;
41085 +
41086 + /* search an available piece slot */
41087 + while (pslot != NULL) {
41088 + if (pslot->size > pmax->size)
41089 + pmax = pslot;
41090 + pslot = pslot->next;
41091 + }
41092 +
41093 + if (!pmax)
41094 + return NULL;
41095 +
41096 + *psize = pmax->size;
41097 +
41098 + return _ocm_alloc(*psize, ocmheap);
41099 +}
41100 +#endif
41101 +
41102 +/*
41103 + * _ocm_free()
41104 + * generic free a block in the ocm heap, if successful
41105 + */
41106 +static int _ocm_free(const void *addr,
41107 + struct ocm_heap *ocmheap)
41108 +{
41109 + struct ocm_piece *pslot, *plast, *pavail;
41110 + struct ocm_piece *pfree_head = &ocmheap->free_head;
41111 + struct ocm_piece *pused_head = &ocmheap->used_head;
41112 +
41113 + /* search the relevant memory slot */
41114 + pslot = pused_head->next;
41115 + plast = pused_head;
41116 +
41117 + /* search an available piece slot */
41118 + while (pslot != NULL && pslot->paddr != addr) {
41119 + plast = pslot;
41120 + pslot = pslot->next;
41121 + }
41122 +
41123 + if (!pslot) {
41124 + DEBUGP("_ocm_free %p not found in %p", addr, ocmheap);
41125 + return -1;
41126 + }
41127 + DEBUGP("_ocm_free %p from in %p", addr, ocmheap);
41128 +
41129 + plast->next = pslot->next;
41130 + pavail = pslot;
41131 + pavail->pid = 0;
41132 +
41133 + /* insert free pieces back to the free list */
41134 + pslot = pfree_head->next;
41135 + plast = pfree_head;
41136 +
41137 + while (pslot != NULL && addr > pslot->paddr) {
41138 + plast = pslot;
41139 + pslot = pslot->next;
41140 + }
41141 +
41142 + if (plast != pfree_head &&
41143 + plast->paddr + plast->size == pavail->paddr) {
41144 + plast->size += pavail->size;
41145 + kmem_cache_free(ocm_piece_cache, pavail);
41146 + } else {
41147 + pavail->next = plast->next;
41148 + plast->next = pavail;
41149 + plast = pavail;
41150 + }
41151 +
41152 + if (pslot && plast->paddr + plast->size == pslot->paddr) {
41153 + plast->size += pslot->size;
41154 + plast->next = pslot->next;
41155 + kmem_cache_free(ocm_piece_cache, pslot);
41156 + }
41157 +
41158 + return 0;
41159 +}
41160 +
41161 +/*
41162 + * ocm_inst_alloc()
41163 + *
41164 + * allocates a block of size in the ocm instrction heap, if
41165 + * successful returns address allocated.
41166 + */
41167 +void *ocm_inst_alloc(size_t size, pid_t pid)
41168 +{
41169 + void *addr;
41170 +
41171 + if (!OCM_INST_HEAP_LENGTH)
41172 + return NULL;
41173 +
41174 +
41175 + mutex_lock(&ocm_inst_heap.lock);
41176 +
41177 + addr = _ocm_alloc(size, pid, &ocm_inst_heap);
41178 +
41179 + mutex_unlock(&ocm_inst_heap.lock);
41180 +
41181 + return addr;
41182 +}
41183 +EXPORT_SYMBOL(ocm_inst_alloc);
41184 +
41185 +/*
41186 + * ocm_inst_free()
41187 + * free a block in the ocm instrction heap, returns 0 if successful.
41188 + */
41189 +int ocm_inst_free(const void *addr)
41190 +{
41191 + int ret;
41192 +
41193 + if (!OCM_INST_HEAP_LENGTH)
41194 + return -1;
41195 +
41196 + mutex_lock(&ocm_inst_heap.lock);
41197 +
41198 + ret = _ocm_free(addr, &ocm_inst_heap);
41199 +
41200 + mutex_unlock(&ocm_inst_heap.lock);
41201 +
41202 + return ret;
41203 +}
41204 +EXPORT_SYMBOL(ocm_inst_free);
41205 +
41206 +/*
41207 + * ocm_free()
41208 + * free a block in one of the ocm heaps, returns 0 if successful.
41209 + */
41210 +int ocm_free(const void *addr)
41211 +{
41212 + if (addr >= (void *)OCM_INST_HEAP_BEGIN
41213 + && addr < (void *)(OCM_INST_HEAP_END))
41214 + return ocm_inst_free(addr);
41215 + else
41216 + return -1;
41217 +}
41218 +EXPORT_SYMBOL(ocm_free);
41219 +
41220 +
41221 +#ifdef CONFIG_PROC_FS
41222 +/* Need to keep line of output the same. Currently, that is 46 bytes
41223 + * (including newline).
41224 + */
41225 +static int _ocm_proc_read(char *buf, int *len, int count, const char *desc,
41226 + struct ocm_heap *ocmheap)
41227 +{
41228 + struct ocm_piece *pslot;
41229 + struct ocm_piece *pfree_head = &ocmheap->free_head;
41230 + struct ocm_piece *pused_head = &ocmheap->used_head;
41231 +
41232 + /* The format is the following
41233 + * --- OCM 123456789012345 Size PID State \n
41234 + * 12345678-12345678 1234567890 12345 1234567890\n
41235 + */
41236 + int l;
41237 + l = sprintf(&buf[*len], "--- OCM %-15s Size PID State \n",
41238 + desc);
41239 +
41240 + *len += l;
41241 + count -= l;
41242 +
41243 + mutex_lock(&ocm_inst_heap.lock);
41244 +
41245 + /*
41246 + * search the relevant memory slot
41247 + */
41248 + pslot = pused_head->next;
41249 +
41250 + while (pslot != NULL && count > 46) {
41251 + l = sprintf(&buf[*len], "%p-%p %10i %5i %-10s\n",
41252 + pslot->paddr, pslot->paddr + pslot->size,
41253 + pslot->size, pslot->pid, "ALLOCATED");
41254 +
41255 + *len += l;
41256 + count -= l;
41257 + pslot = pslot->next;
41258 + }
41259 +
41260 + pslot = pfree_head->next;
41261 +
41262 + while (pslot != NULL && count > 46) {
41263 + l = sprintf(&buf[*len], "%p-%p %10i %5i %-10s\n",
41264 + pslot->paddr, pslot->paddr + pslot->size,
41265 + pslot->size, pslot->pid, "FREE");
41266 +
41267 + *len += l;
41268 + count -= l;
41269 + pslot = pslot->next;
41270 + }
41271 +
41272 + mutex_unlock(&ocm_inst_heap.lock);
41273 +
41274 + return 0;
41275 +}
41276 +
41277 +static int ocm_proc_read(char *buf, char **start, off_t offset, int count,
41278 + int *eof, void *data)
41279 +{
41280 + int len = 0;
41281 +
41282 + len = sprintf(&buf[len], "--- OCM SKB usage (max RX buf %d)\n"
41283 + "(SKB in OCM) %d - (SKB in DDR) %d\n",
41284 + ubi32_ocm_skbuf_max,
41285 + ubi32_ocm_skbuf,
41286 + ubi32_ddr_skbuf);
41287 +
41288 + len += sprintf(&buf[len], "--- OCM Data Heap Size\n"
41289 + "%p-%p %10i\n",
41290 + ((void *)&__ocm_free_begin),
41291 + ((void *)&__ocm_free_end),
41292 + ((unsigned int)&__ocm_free_end) -
41293 + ((unsigned int)&__ocm_free_begin));
41294 +
41295 + if (_ocm_proc_read(buf, &len, count - len, "Inst Heap",
41296 + &ocm_inst_heap))
41297 + goto not_done;
41298 + *eof = 1;
41299 + not_done:
41300 + return len;
41301 +}
41302 +
41303 +static int ocm_proc_write(struct file *file, const char __user *buffer,
41304 + unsigned long count, void *data)
41305 +{
41306 + int n, v;
41307 + char in[8];
41308 +
41309 + if (count > sizeof(in))
41310 + return -EINVAL;
41311 +
41312 + if (copy_from_user(in, buffer, count))
41313 + return -EFAULT;
41314 + in[count-1] = 0;
41315 +
41316 + printk(KERN_INFO "OCM skb alloc max = %s\n", in);
41317 +
41318 + n = 0;
41319 + v = 0;
41320 + while ((in[n] >= '0') && (in[n] <= '9')) {
41321 + v = v * 10 + (int)(in[n] - '0');
41322 + n++;
41323 + }
41324 +
41325 + if (v == 0)
41326 + return -EINVAL;
41327 +
41328 + ubi32_ocm_skbuf_max = v;
41329 + ubi32_ocm_skbuf = ubi32_ddr_skbuf = 0;
41330 +
41331 + return count;
41332 +}
41333 +
41334 +static int __init sram_proc_init(void)
41335 +{
41336 + struct proc_dir_entry *ptr;
41337 + ptr = create_proc_entry("ocm", S_IFREG | S_IRUGO, NULL);
41338 + if (!ptr) {
41339 + printk(KERN_WARNING "unable to create /proc/ocm\n");
41340 + return -1;
41341 + }
41342 + ptr->read_proc = ocm_proc_read;
41343 + ptr->write_proc = ocm_proc_write;
41344 + return 0;
41345 +}
41346 +late_initcall(sram_proc_init);
41347 +#endif
41348 diff -ruN linux-2.6.30.10/arch/ubicom32/oprofile/ipProf.h linux-2.6.30.10-ubi/arch/ubicom32/oprofile/ipProf.h
41349 --- linux-2.6.30.10/arch/ubicom32/oprofile/ipProf.h 1970-01-01 02:00:00.000000000 +0200
41350 +++ linux-2.6.30.10-ubi/arch/ubicom32/oprofile/ipProf.h 2009-12-11 11:45:11.000000000 +0200
41351 @@ -0,0 +1,39 @@
41352 +#ifndef __IP_PROF_H__
41353 +#define __IP_PROF_H__
41354 +
41355 +/* This number MUST match what is used in the ultra configuration! */
41356 +#define IPPROFILETIO_MAX_SAMPLES 600
41357 +
41358 +/* Move to .h file used in both; avoid special types */
41359 +struct profile_sample {
41360 + unsigned int pc; /* PC value */
41361 + unsigned int parent; /* a5 contents, to find the caller */
41362 + unsigned char cond_codes; /* for branch prediction */
41363 + unsigned char thread; /* I-blocked, D-blocked,
41364 + 4-bit thread number */
41365 + unsigned short active; /* which threads are active -
41366 + for accurate counting */
41367 + unsigned short blocked; /* which threads are blocked due to
41368 + I or D cache misses */
41369 + unsigned int latency; /* CPU clocks since the last message
41370 + dispatch in this thread
41371 + (thread 0 only for now) */
41372 +};
41373 +
41374 +
41375 +struct profilenode {
41376 + struct devtree_node dn;
41377 + volatile unsigned char enabled; /* Is the tio enabled to
41378 + take samples? */
41379 + volatile unsigned char busy; /* set when the samples
41380 + are being read */
41381 + volatile unsigned int mask; /* Threads that change the MT_EN flag */
41382 + volatile unsigned short rate; /* What is the sampling rate? */
41383 + volatile unsigned short head; /* sample taker puts samples here */
41384 + volatile unsigned short tail; /* packet filler takes samples here */
41385 + volatile unsigned short count; /* number of valid samples */
41386 + volatile unsigned short total; /* Total samples */
41387 + struct profile_sample samples[IPPROFILETIO_MAX_SAMPLES];
41388 +};
41389 +
41390 +#endif
41391 diff -ruN linux-2.6.30.10/arch/ubicom32/oprofile/Makefile linux-2.6.30.10-ubi/arch/ubicom32/oprofile/Makefile
41392 --- linux-2.6.30.10/arch/ubicom32/oprofile/Makefile 1970-01-01 02:00:00.000000000 +0200
41393 +++ linux-2.6.30.10-ubi/arch/ubicom32/oprofile/Makefile 2009-12-11 11:45:11.000000000 +0200
41394 @@ -0,0 +1,37 @@
41395 +#
41396 +# arch/ubicom32/Makefile
41397 +# Makefile for Oprofile support on Ubicom32
41398 +#
41399 +# (C) Copyright 2009, Ubicom, Inc.
41400 +#
41401 +# This file is part of the Ubicom32 Linux Kernel Port.
41402 +#
41403 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
41404 +# it and/or modify it under the terms of the GNU General Public License
41405 +# as published by the Free Software Foundation, either version 2 of the
41406 +# License, or (at your option) any later version.
41407 +#
41408 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
41409 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
41410 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
41411 +# the GNU General Public License for more details.
41412 +#
41413 +# You should have received a copy of the GNU General Public License
41414 +# along with the Ubicom32 Linux Kernel Port. If not,
41415 +# see <http://www.gnu.org/licenses/>.
41416 +#
41417 +# Ubicom32 implementation derived from (with many thanks):
41418 +# arch/m68knommu
41419 +# arch/blackfin
41420 +# arch/parisc
41421 +#
41422 +
41423 +obj-$(CONFIG_OPROFILE) += oprofile.o
41424 +
41425 +DRIVER_OBJS = $(addprefix ../../../drivers/oprofile/, \
41426 + oprof.o cpu_buffer.o buffer_sync.o \
41427 + event_buffer.o oprofile_files.o \
41428 + oprofilefs.o oprofile_stats.o \
41429 + timer_int.o )
41430 +
41431 +oprofile-y := $(DRIVER_OBJS) profile.o
41432 diff -ruN linux-2.6.30.10/arch/ubicom32/oprofile/profile.c linux-2.6.30.10-ubi/arch/ubicom32/oprofile/profile.c
41433 --- linux-2.6.30.10/arch/ubicom32/oprofile/profile.c 1970-01-01 02:00:00.000000000 +0200
41434 +++ linux-2.6.30.10-ubi/arch/ubicom32/oprofile/profile.c 2009-12-11 11:45:11.000000000 +0200
41435 @@ -0,0 +1,221 @@
41436 +/*
41437 + * arch/ubicom32/oprofile/profile.c
41438 + * Oprofile support for arch Ubicom32
41439 + *
41440 + * (C) Copyright 2009, Ubicom, Inc.
41441 + *
41442 + * This file is part of the Ubicom32 Linux Kernel Port.
41443 + *
41444 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
41445 + * it and/or modify it under the terms of the GNU General Public License
41446 + * as published by the Free Software Foundation, either version 2 of the
41447 + * License, or (at your option)
41448 + * any later version.
41449 + *
41450 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it will
41451 + * be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
41452 + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41453 + * General Public License for more details.
41454 + *
41455 + * You should have received a copy of the GNU General Public License
41456 + * along with the Ubicom32 Linux Kernel Port. If not, see
41457 + * <http://www.gnu.org/licenses/>.
41458 + *
41459 + * Ubicom32 implementation derived from (with many thanks):
41460 + * arch/m68knommu
41461 + * arch/blackfin
41462 + * arch/parisc
41463 + */
41464 +
41465 +/**
41466 + * @file profile.c
41467 + *
41468 + * @remark Copyright 2002 OProfile authors
41469 + * @remark Read the file COPYING
41470 + *
41471 + * @author Hunyue Yau <hy@hy-research.com>
41472 + */
41473 +
41474 +#include <linux/oprofile.h>
41475 +#include <linux/init.h>
41476 +#include <linux/errno.h>
41477 +#include <linux/interrupt.h>
41478 +#include <linux/module.h>
41479 +#include <linux/kernel.h>
41480 +
41481 +#include <asm/devtree.h>
41482 +#include <asm/thread.h>
41483 +
41484 +/* For identifying userland vs kernel address */
41485 +#include <asm/stacktrace.h>
41486 +#include "ipProf.h"
41487 +
41488 +/* For communications with the backend */
41489 +static struct profilenode *profile_node;
41490 +
41491 +/* Bitmask containing all Linux threads - as seen by the ROSR reg */
41492 +static unsigned long th_all_mask;
41493 +
41494 +/* Lookup table to translate a hardware thread into a CPU identifier
41495 + * Table is indexed by the ROSR value which is assumed to be
41496 + * relatively small (0...15).
41497 + */
41498 +unsigned int cpu_map[THREAD_ARCHITECTURAL_MAX];
41499 +
41500 +static struct pt_regs regs;
41501 +
41502 +/*
41503 + * For each sample returned, checked to see if they are relevant to
41504 + * us. This is necessary as the ubicom32 architecture has other software
41505 + * running outside of Linux. Only then, put the sample into the relevant
41506 + * cpu bins.
41507 + *
41508 + * To minimize overhead, a global mask with all possible threads of in
41509 + * interest to us is used as a first check. Then a second mask identifying
41510 + * the thread is used to obtain an identifier for that "CPU".
41511 + */
41512 +
41513 +/*
41514 + * ubicom32_build_cpu_th_mask()
41515 + *
41516 + * Build a lookup table for translation between hardware thread
41517 + * "ROSR" values and Linux CPU ids
41518 + *
41519 + * *** This gets executed on all CPUs at once! ***
41520 + */
41521 +static void ubicom32_build_cpu_th_mask(void *mask)
41522 +{
41523 + thread_t self = thread_get_self();
41524 + unsigned long *th_m = mask;
41525 +
41526 + BUG_ON(self <= 0 || self >= THREAD_ARCHITECTURAL_MAX);
41527 + cpu_map[self] = smp_processor_id();
41528 +
41529 + set_bit(self, th_m);
41530 +}
41531 +
41532 +/*
41533 + * profile_interrupt()
41534 + *
41535 + * Process samples returned from the profiler backend. The backend
41536 + * may return samples that are irrelevant to us or may even return
41537 + * multiple samples for the same CPU. Note that the sames may be
41538 + * for ANY cpu. At this time, this is unique and to support this requires
41539 + * Oprofile to expose an interface to accept the CPU that the same came
41540 + * frome.
41541 + */
41542 +static irqreturn_t profile_interrupt(int irq, void *arg)
41543 +{
41544 + int i, buf_entry;
41545 + int is_kernel;
41546 + unsigned int bit_th;
41547 + unsigned int th;
41548 +
41549 + if (!(profile_node->enabled) || profile_node->count < 0) {
41550 + printk(KERN_WARNING
41551 + "Unexpected interrupt, no samples or not enabled!\n");
41552 + return IRQ_HANDLED;
41553 + }
41554 +
41555 + profile_node->busy = 1; /* Keep backend out */
41556 +
41557 + for (i = 0; i < profile_node->count; i++) {
41558 + buf_entry = profile_node->tail;
41559 + profile_node->tail++;
41560 + profile_node->tail %= IPPROFILETIO_MAX_SAMPLES;
41561 +
41562 + /* Note - the "thread" ID is only the lower 4 bits */
41563 + th = (0x0f & profile_node->samples[buf_entry].thread);
41564 + bit_th = (1 << th);
41565 +
41566 + if ((bit_th & th_all_mask) == 0)
41567 + continue;
41568 +
41569 + regs.pc = profile_node->samples[buf_entry].pc;
41570 +
41571 + is_kernel = ubicom32_is_kernel(regs.pc);
41572 +
41573 + oprofile_add_ext_sample_cpu(regs.pc, &regs, 0, is_kernel,
41574 + cpu_map[th]);
41575 + }
41576 + profile_node->count = 0;
41577 + profile_node->busy = 0;
41578 +
41579 + return IRQ_HANDLED;
41580 +}
41581 +
41582 +/*
41583 + * profile_start()
41584 + *
41585 + * Notification from oprofile to start the profiler
41586 + */
41587 +static int profile_start(void)
41588 +{
41589 + if (!profile_node)
41590 + return -1;
41591 +
41592 + profile_node->enabled = 1;
41593 +
41594 + return 0;
41595 +}
41596 +
41597 +/*
41598 + * profile_stop()
41599 + *
41600 + * Notification from oprofile to stop the profiler
41601 + */
41602 +static void profile_stop(void)
41603 +{
41604 + if (profile_node)
41605 + profile_node->enabled = 0;
41606 +}
41607 +
41608 +/*
41609 + * oprofile_arch_init()
41610 + *
41611 + * Attach to Oprofile after qualify the availability of the backend
41612 + * profiler support.
41613 + */
41614 +int __init oprofile_arch_init(struct oprofile_operations *ops)
41615 +{
41616 + int r = -ENODEV;
41617 +
41618 + profile_node = (struct profilenode *)devtree_find_node("profiler");
41619 +
41620 + if (profile_node == NULL) {
41621 + printk(KERN_WARNING "Cannot find profiler node\n");
41622 + return r;
41623 + }
41624 +
41625 + r = request_irq(profile_node->dn.recvirq, profile_interrupt,
41626 + IRQF_DISABLED, "profiler", NULL);
41627 +
41628 + if (r < 0) {
41629 + profile_node = NULL;
41630 + printk(KERN_WARNING "Cannot get profiler IRQ\n");
41631 + return r;
41632 + }
41633 +
41634 + ops->start = profile_start;
41635 + ops->stop = profile_stop;
41636 + ops->cpu_type = "timer";
41637 +
41638 + memset(cpu_map, 0, sizeof(cpu_map));
41639 +
41640 + on_each_cpu(ubicom32_build_cpu_th_mask, &th_all_mask, 1);
41641 +
41642 + memset(&regs, 0, sizeof(regs));
41643 +
41644 + return r;
41645 +}
41646 +
41647 +/*
41648 + * oprofile_arch_exit()
41649 + *
41650 + * External call to take outselves out.
41651 + * Make sure backend is not running.
41652 + */
41653 +void oprofile_arch_exit(void)
41654 +{
41655 + BUG_ON(profile_node->enabled);
41656 +}
41657 diff -ruN linux-2.6.30.10/drivers/char/hw_random/Kconfig linux-2.6.30.10-ubi/drivers/char/hw_random/Kconfig
41658 --- linux-2.6.30.10/drivers/char/hw_random/Kconfig 2009-12-04 08:00:07.000000000 +0200
41659 +++ linux-2.6.30.10-ubi/drivers/char/hw_random/Kconfig 2009-12-11 11:45:13.000000000 +0200
41660 @@ -148,3 +148,16 @@
41661
41662 To compile this driver as a module, choose M here: the
41663 module will be called virtio-rng. If unsure, say N.
41664 +
41665 +config HW_RANDOM_UBICOM32
41666 + tristate "Ubicom32 HW Random Number Generator support"
41667 + depends on HW_RANDOM && UBICOM32
41668 + default HW_RANDOM
41669 + ---help---
41670 + This driver provides kernel-side support for the Random Number
41671 + Generator hardware found on Ubicom32 processors.
41672 +
41673 + To compile this driver as a module, choose M here: the
41674 + module will be called pasemi-rng.
41675 +
41676 + If unsure, say Y.
41677 diff -ruN linux-2.6.30.10/drivers/char/hw_random/Makefile linux-2.6.30.10-ubi/drivers/char/hw_random/Makefile
41678 --- linux-2.6.30.10/drivers/char/hw_random/Makefile 2009-12-04 08:00:07.000000000 +0200
41679 +++ linux-2.6.30.10-ubi/drivers/char/hw_random/Makefile 2009-12-11 11:45:13.000000000 +0200
41680 @@ -15,3 +15,4 @@
41681 obj-$(CONFIG_HW_RANDOM_OMAP) += omap-rng.o
41682 obj-$(CONFIG_HW_RANDOM_PASEMI) += pasemi-rng.o
41683 obj-$(CONFIG_HW_RANDOM_VIRTIO) += virtio-rng.o
41684 +obj-$(CONFIG_HW_RANDOM_UBICOM32) += ubicom32-rng.o
41685 diff -ruN linux-2.6.30.10/drivers/char/hw_random/ubicom32-rng.c linux-2.6.30.10-ubi/drivers/char/hw_random/ubicom32-rng.c
41686 --- linux-2.6.30.10/drivers/char/hw_random/ubicom32-rng.c 1970-01-01 02:00:00.000000000 +0200
41687 +++ linux-2.6.30.10-ubi/drivers/char/hw_random/ubicom32-rng.c 2009-12-11 11:45:13.000000000 +0200
41688 @@ -0,0 +1,105 @@
41689 +/*
41690 + * drivers/net/ubi32-eth.c
41691 + * Ubicom32 hardware random number generator driver.
41692 + *
41693 + * (C) Copyright 2009, Ubicom, Inc.
41694 + *
41695 + * This file is part of the Ubicom32 Linux Kernel Port.
41696 + *
41697 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
41698 + * it and/or modify it under the terms of the GNU General Public License
41699 + * as published by the Free Software Foundation, either version 2 of the
41700 + * License, or (at your option) any later version.
41701 + *
41702 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
41703 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
41704 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
41705 + * the GNU General Public License for more details.
41706 + *
41707 + * You should have received a copy of the GNU General Public License
41708 + * along with the Ubicom32 Linux Kernel Port. If not,
41709 + * see <http://www.gnu.org/licenses/>.
41710 + *
41711 + * Ubicom32 implementation derived from (with many thanks):
41712 + * arch/m68knommu
41713 + * arch/blackfin
41714 + * arch/parisc
41715 + */
41716 +
41717 +#include <linux/kernel.h>
41718 +#include <linux/module.h>
41719 +#include <linux/hw_random.h>
41720 +#include <linux/delay.h>
41721 +#include <asm/io.h>
41722 +#include <asm/ip5000.h>
41723 +
41724 +#define MODULE_NAME "ubicom32_rng"
41725 +
41726 +static int ubicom32_rng_data_present(struct hwrng *rng, int wait)
41727 +{
41728 + int data, i;
41729 +
41730 + for (i = 0; i < 20; i++) {
41731 + data = *(int *)(TIMER_BASE + TIMER_TRN);
41732 + if (data || !wait)
41733 + break;
41734 + udelay(10);
41735 + }
41736 + return data;
41737 +}
41738 +
41739 +static int ubicom32_rng_data_read(struct hwrng *rng, u32 *data)
41740 +{
41741 + *data = *(int *)(TIMER_BASE + TIMER_TRN);
41742 + return 4;
41743 +}
41744 +
41745 +static int ubicom32_rng_init(struct hwrng *rng)
41746 +{
41747 + printk(KERN_INFO "ubicom32 rng init\n");
41748 + *(int *)(TIMER_BASE + TIMER_TRN_CFG) = TIMER_TRN_CFG_ENABLE_OSC;
41749 + return 0;
41750 +}
41751 +
41752 +static void ubicom32_rng_cleanup(struct hwrng *rng)
41753 +{
41754 + printk(KERN_INFO "ubicom32 rng cleanup\n");
41755 + *(int *)(TIMER_BASE + TIMER_TRN_CFG) = 0;
41756 +}
41757 +
41758 +static struct hwrng ubicom32_rng = {
41759 + .name = MODULE_NAME,
41760 + .init = ubicom32_rng_init,
41761 + .cleanup = ubicom32_rng_cleanup,
41762 + .data_present = ubicom32_rng_data_present,
41763 + .data_read = ubicom32_rng_data_read,
41764 + .priv = 0,
41765 +};
41766 +
41767 +static int __init mod_init(void)
41768 +{
41769 + int err;
41770 +
41771 + printk(KERN_INFO "ubicom32 rng started\n");
41772 + err = hwrng_register(&ubicom32_rng);
41773 + if (err) {
41774 + printk(KERN_ERR "ubicom32 rng register failed (%d)\n",
41775 + err);
41776 + }
41777 +
41778 + return err;
41779 +}
41780 +
41781 +static void __exit mod_exit(void)
41782 +{
41783 + printk(KERN_INFO "ubicom32 rng stopped\n");
41784 + hwrng_unregister(&ubicom32_rng);
41785 +}
41786 +
41787 +module_init(mod_init);
41788 +module_exit(mod_exit);
41789 +
41790 +MODULE_LICENSE("GPL");
41791 +MODULE_AUTHOR("Ubicom, Inc.");
41792 +MODULE_DESCRIPTION("H/W rng driver for ubicom32 processor");
41793 +MODULE_VERSION("1:1.0.a");
41794 diff -ruN linux-2.6.30.10/drivers/crypto/Kconfig linux-2.6.30.10-ubi/drivers/crypto/Kconfig
41795 --- linux-2.6.30.10/drivers/crypto/Kconfig 2009-12-04 08:00:07.000000000 +0200
41796 +++ linux-2.6.30.10-ubi/drivers/crypto/Kconfig 2009-12-11 11:45:13.000000000 +0200
41797 @@ -61,6 +61,40 @@
41798 To compile this driver as a module, choose M here: the module
41799 will be called geode-aes.
41800
41801 +config CRYPTO_UBICOM32
41802 + bool "Ubicom32 Security Module"
41803 + depends on UBICOM32
41804 + help
41805 + This is the ubicom32 hardware acceleration common code.
41806 +
41807 +config CRYPTO_AES_UBICOM32
41808 + tristate "Ubicom32 AES implementation"
41809 + depends on CRYPTO_UBICOM32
41810 + select CRYPTO_ALGAPI
41811 + help
41812 + This is the ubicom32 hardware AES implementation.
41813 +
41814 +config CRYPTO_DES_UBICOM32
41815 + tristate "Ubicom32 DES implementation"
41816 + depends on CRYPTO_UBICOM32
41817 + select CRYPTO_ALGAPI
41818 + help
41819 + This is the ubicom32 hardware DES and 3DES implementation.
41820 +
41821 +config CRYPTO_SHA1_UBICOM32
41822 + tristate "Ubicom32 SHA1 implementation"
41823 + depends on CRYPTO_UBICOM32
41824 + select CRYPTO_ALGAPI
41825 + help
41826 + This is the ubicom32 hardware SHA1 implementation.
41827 +
41828 +config CRYPTO_MD5_UBICOM32
41829 + tristate "Ubicom32 MD5 implementation"
41830 + depends on CRYPTO_UBICOM32
41831 + select CRYPTO_ALGAPI
41832 + help
41833 + This is the ubicom32 hardware MD5 implementation.
41834 +
41835 config ZCRYPT
41836 tristate "Support for PCI-attached cryptographic adapters"
41837 depends on S390
41838 diff -ruN linux-2.6.30.10/drivers/mmc/host/Kconfig linux-2.6.30.10-ubi/drivers/mmc/host/Kconfig
41839 --- linux-2.6.30.10/drivers/mmc/host/Kconfig 2009-12-14 11:15:33.000000000 +0200
41840 +++ linux-2.6.30.10-ubi/drivers/mmc/host/Kconfig 2009-12-14 11:15:31.000000000 +0200
41841 @@ -266,3 +266,10 @@
41842 help
41843 This option automatically enables configfs support for gpiommc
41844 if configfs is available.
41845 +
41846 +config MMC_UBICOM32
41847 + tristate "Ubicom32 MMC/SD host controller"
41848 + depends on UBICOM32
41849 + help
41850 + This provides support for the SD/MMC hardware found on Ubicom32
41851 + IP7K processors
41852 diff -ruN linux-2.6.30.10/drivers/mmc/host/Makefile linux-2.6.30.10-ubi/drivers/mmc/host/Makefile
41853 --- linux-2.6.30.10/drivers/mmc/host/Makefile 2009-12-14 11:37:36.000000000 +0200
41854 +++ linux-2.6.30.10-ubi/drivers/mmc/host/Makefile 2009-12-14 11:37:35.000000000 +0200
41855 @@ -30,4 +30,5 @@
41856 obj-$(CONFIG_MMC_SDRICOH_CS) += sdricoh_cs.o
41857 obj-$(CONFIG_MMC_TMIO) += tmio_mmc.o
41858 obj-$(CONFIG_GPIOMMC) += gpiommc.o
41859 +obj-$(CONFIG_MMC_UBICOM32) += ubicom32sd.o
41860
41861 diff -ruN linux-2.6.30.10/drivers/mmc/host/ubicom32sd.c linux-2.6.30.10-ubi/drivers/mmc/host/ubicom32sd.c
41862 --- linux-2.6.30.10/drivers/mmc/host/ubicom32sd.c 1970-01-01 02:00:00.000000000 +0200
41863 +++ linux-2.6.30.10-ubi/drivers/mmc/host/ubicom32sd.c 2009-12-11 11:45:16.000000000 +0200
41864 @@ -0,0 +1,773 @@
41865 +/*
41866 + * drivers/mmc/host/ubicom32sd.c
41867 + * Ubicom32 Secure Digital Host Controller Interface driver
41868 + *
41869 + * (C) Copyright 2009, Ubicom, Inc.
41870 + *
41871 + * This file is part of the Ubicom32 Linux Kernel Port.
41872 + *
41873 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
41874 + * it and/or modify it under the terms of the GNU General Public License
41875 + * as published by the Free Software Foundation, either version 2 of the
41876 + * License, or (at your option) any later version.
41877 + *
41878 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
41879 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
41880 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
41881 + * the GNU General Public License for more details.
41882 + *
41883 + * You should have received a copy of the GNU General Public License
41884 + * along with the Ubicom32 Linux Kernel Port. If not,
41885 + * see <http://www.gnu.org/licenses/>.
41886 + */
41887 +
41888 +#include <linux/module.h>
41889 +#include <linux/platform_device.h>
41890 +#include <linux/delay.h>
41891 +#include <linux/scatterlist.h>
41892 +#include <linux/leds.h>
41893 +#include <linux/gpio.h>
41894 +#include <linux/mmc/host.h>
41895 +
41896 +#include <asm/ubicom32sd.h>
41897 +
41898 +#define DRIVER_NAME "ubicom32sd"
41899 +
41900 +#define sd_printk(...)
41901 +//#define sd_printk printk
41902 +
41903 +#define SDTIO_VP_VERSION 3
41904 +
41905 +#define SDTIO_MAX_SG_BLOCKS 16
41906 +
41907 +enum sdtio_commands {
41908 + SDTIO_COMMAND_NOP,
41909 + SDTIO_COMMAND_SETUP,
41910 + SDTIO_COMMAND_SETUP_SDIO,
41911 + SDTIO_COMMAND_EXECUTE,
41912 + SDTIO_COMMAND_RESET,
41913 +};
41914 +
41915 +#define SDTIO_COMMAND_SHIFT 24
41916 +#define SDTIO_COMMAND_FLAG_STOP_RSP_CRC (1 << 10)
41917 +#define SDTIO_COMMAND_FLAG_STOP_RSP_136 (1 << 9)
41918 +#define SDTIO_COMMAND_FLAG_STOP_RSP (1 << 8)
41919 +#define SDTIO_COMMAND_FLAG_STOP_CMD (1 << 7)
41920 +#define SDTIO_COMMAND_FLAG_DATA_STREAM (1 << 6)
41921 +#define SDTIO_COMMAND_FLAG_DATA_RD (1 << 5)
41922 +#define SDTIO_COMMAND_FLAG_DATA_WR (1 << 4)
41923 +#define SDTIO_COMMAND_FLAG_CMD_RSP_CRC (1 << 3)
41924 +#define SDTIO_COMMAND_FLAG_CMD_RSP_136 (1 << 2)
41925 +#define SDTIO_COMMAND_FLAG_CMD_RSP (1 << 1)
41926 +#define SDTIO_COMMAND_FLAG_CMD (1 << 0)
41927 +
41928 +/*
41929 + * SDTIO_COMMAND_SETUP_SDIO
41930 + */
41931 +#define SDTIO_COMMAND_FLAG_SDIO_INT_EN (1 << 0)
41932 +
41933 +/*
41934 + * SDTIO_COMMAND_SETUP
41935 + * clock speed in arg
41936 + */
41937 +#define SDTIO_COMMAND_FLAG_4BIT (1 << 3)
41938 +#define SDTIO_COMMAND_FLAG_1BIT (1 << 2)
41939 +#define SDTIO_COMMAND_FLAG_SET_CLOCK (1 << 1)
41940 +#define SDTIO_COMMAND_FLAG_SET_WIDTH (1 << 0)
41941 +
41942 +#define SDTIO_COMMAND_FLAG_CMD_RSP_MASK (SDTIO_COMMAND_FLAG_CMD_RSP | SDTIO_COMMAND_FLAG_CMD_RSP_136)
41943 +#define SDTIO_COMMAND_FLAG_STOP_RSP_MASK (SDTIO_COMMAND_FLAG_STOP_RSP | SDTIO_COMMAND_FLAG_STOP_RSP_136)
41944 +#define SDTIO_COMMAND_FLAG_RSP_MASK (SDTIO_COMMAND_FLAG_CMD_RSP_MASK | SDTIO_COMMAND_FLAG_STOP_RSP_MASK)
41945 +
41946 +struct sdtio_vp_sg {
41947 + volatile void *addr;
41948 + volatile u32_t len;
41949 +};
41950 +
41951 +#define SDTIO_VP_INT_STATUS_DONE (1 << 31)
41952 +#define SDTIO_VP_INT_STATUS_SDIO_INT (1 << 10)
41953 +#define SDTIO_VP_INT_STATUS_DATA_CRC_ERR (1 << 9)
41954 +#define SDTIO_VP_INT_STATUS_DATA_PROG_ERR (1 << 8)
41955 +#define SDTIO_VP_INT_STATUS_DATA_TIMEOUT (1 << 7)
41956 +#define SDTIO_VP_INT_STATUS_STOP_RSP_CRC (1 << 6)
41957 +#define SDTIO_VP_INT_STATUS_STOP_RSP_TIMEOUT (1 << 5)
41958 +#define SDTIO_VP_INT_STATUS_CMD_RSP_CRC (1 << 4)
41959 +#define SDTIO_VP_INT_STATUS_CMD_RSP_TIMEOUT (1 << 3)
41960 +#define SDTIO_VP_INT_STATUS_CMD_TIMEOUT (1 << 2)
41961 +#define SDTIO_VP_INT_STATUS_CARD1_INSERT (1 << 1)
41962 +#define SDTIO_VP_INT_STATUS_CARD0_INSERT (1 << 0)
41963 +
41964 +struct sdtio_vp_regs {
41965 + u32_t version;
41966 + u32_t f_max;
41967 + u32_t f_min;
41968 +
41969 + volatile u32_t int_status;
41970 +
41971 + volatile u32_t command;
41972 + volatile u32_t arg;
41973 +
41974 + volatile u32_t cmd_opcode;
41975 + volatile u32_t cmd_arg;
41976 + volatile u32_t cmd_rsp0;
41977 + volatile u32_t cmd_rsp1;
41978 + volatile u32_t cmd_rsp2;
41979 + volatile u32_t cmd_rsp3;
41980 +
41981 + volatile u32_t stop_opcode;
41982 + volatile u32_t stop_arg;
41983 + volatile u32_t stop_rsp0;
41984 + volatile u32_t stop_rsp1;
41985 + volatile u32_t stop_rsp2;
41986 + volatile u32_t stop_rsp3;
41987 +
41988 + volatile u32_t data_timeout_ns;
41989 + volatile u16_t data_blksz;
41990 + volatile u16_t data_blkct;
41991 + volatile u32_t data_bytes_transferred;
41992 + volatile u32_t sg_len;
41993 + struct sdtio_vp_sg sg[SDTIO_MAX_SG_BLOCKS];
41994 +};
41995 +
41996 +struct ubicom32sd_data {
41997 + const struct ubicom32sd_platform_data *pdata;
41998 +
41999 + struct mmc_host *mmc;
42000 +
42001 + /*
42002 + * Lock used to protect the data structure
42003 + spinlock_t lock;
42004 + */
42005 + int int_en;
42006 + int int_pend;
42007 +
42008 + /*
42009 + * Receive and transmit interrupts used for communicating
42010 + * with hardware
42011 + */
42012 + int irq_tx;
42013 + int irq_rx;
42014 +
42015 + /*
42016 + * Current outstanding mmc request
42017 + */
42018 + struct mmc_request *mrq;
42019 +
42020 + /*
42021 + * Hardware registers
42022 + */
42023 + struct sdtio_vp_regs *regs;
42024 +};
42025 +
42026 +/*****************************************************************************\
42027 + * *
42028 + * Suspend/resume *
42029 + * *
42030 +\*****************************************************************************/
42031 +
42032 +#if 0//def CONFIG_PM
42033 +
42034 +int ubicom32sd_suspend_host(struct ubicom32sd_host *host, pm_message_t state)
42035 +{
42036 + int ret;
42037 +
42038 + ret = mmc_suspend_host(host->mmc, state);
42039 + if (ret)
42040 + return ret;
42041 +
42042 + free_irq(host->irq, host);
42043 +
42044 + return 0;
42045 +}
42046 +
42047 +EXPORT_SYMBOL_GPL(ubicom32sd_suspend_host);
42048 +
42049 +int ubicom32sd_resume_host(struct ubicom32sd_host *host)
42050 +{
42051 + int ret;
42052 +
42053 + if (host->flags & UBICOM32SD_USE_DMA) {
42054 + if (host->ops->enable_dma)
42055 + host->ops->enable_dma(host);
42056 + }
42057 +
42058 + ret = request_irq(host->irq, ubicom32sd_irq, IRQF_SHARED,
42059 + mmc_hostname(host->mmc), host);
42060 + if (ret)
42061 + return ret;
42062 +
42063 + ubicom32sd_init(host);
42064 + mmiowb();
42065 +
42066 + ret = mmc_resume_host(host->mmc);
42067 + if (ret)
42068 + return ret;
42069 +
42070 + return 0;
42071 +}
42072 +
42073 +EXPORT_SYMBOL_GPL(ubicom32sd_resume_host);
42074 +
42075 +#endif /* CONFIG_PM */
42076 +
42077 +/*
42078 + * ubicom32sd_send_command_sync
42079 + */
42080 +static void ubicom32sd_send_command_sync(struct ubicom32sd_data *ud, u32_t command, u32_t arg)
42081 +{
42082 + ud->regs->command = command;
42083 + ud->regs->arg = arg;
42084 + ubicom32_set_interrupt(ud->irq_tx);
42085 + while (ud->regs->command) {
42086 + ndelay(100);
42087 + }
42088 +}
42089 +
42090 +/*
42091 + * ubicom32sd_send_command
42092 + */
42093 +static void ubicom32sd_send_command(struct ubicom32sd_data *ud, u32_t command, u32_t arg)
42094 +{
42095 + ud->regs->command = command;
42096 + ud->regs->arg = arg;
42097 + ubicom32_set_interrupt(ud->irq_tx);
42098 +}
42099 +
42100 +/*
42101 + * ubicom32sd_reset
42102 + */
42103 +static void ubicom32sd_reset(struct ubicom32sd_data *ud)
42104 +{
42105 + ubicom32sd_send_command_sync(ud, SDTIO_COMMAND_RESET << SDTIO_COMMAND_SHIFT, 0);
42106 + ud->regs->int_status = 0;
42107 +}
42108 +
42109 +/*
42110 + * ubicom32sd_mmc_request
42111 + */
42112 +static void ubicom32sd_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
42113 +{
42114 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42115 + u32_t command = SDTIO_COMMAND_EXECUTE << SDTIO_COMMAND_SHIFT;
42116 + int ret = 0;
42117 +
42118 + WARN(ud->mrq != NULL, "ud->mrq still set to %p\n", ud->mrq);
42119 + //pr_debug("send cmd %08x arg %08x flags %08x\n", cmd->opcode, cmd->arg, cmd->flags);
42120 +
42121 + if (mrq->cmd) {
42122 + struct mmc_command *cmd = mrq->cmd;
42123 +
42124 + sd_printk("%s:\t\t\tsetup cmd %02d arg %08x flags %08x\n", mmc_hostname(mmc), cmd->opcode, cmd->arg, cmd->flags);
42125 +
42126 + ud->regs->cmd_opcode = cmd->opcode;
42127 + ud->regs->cmd_arg = cmd->arg;
42128 +
42129 + command |= SDTIO_COMMAND_FLAG_CMD;
42130 +
42131 + if (cmd->flags & MMC_RSP_PRESENT) {
42132 + command |= SDTIO_COMMAND_FLAG_CMD_RSP;
42133 + }
42134 +
42135 + if (cmd->flags & MMC_RSP_136) {
42136 + command |= SDTIO_COMMAND_FLAG_CMD_RSP_136;
42137 + }
42138 +
42139 + if (cmd->flags & MMC_RSP_CRC) {
42140 + command |= SDTIO_COMMAND_FLAG_CMD_RSP_CRC;
42141 + }
42142 + }
42143 +
42144 + if (mrq->data) {
42145 + struct mmc_data *data = mrq->data;
42146 + struct scatterlist *sg = data->sg;
42147 + int i;
42148 +
42149 +printk("%s:\t\t\tsetup data blksz %d num %d sglen=%d fl=%08x Tns=%u\n", mmc_hostname(mmc), data->blksz, data->blocks, data->sg_len, data->flags, data->timeout_ns);
42150 +
42151 + sd_printk("%s:\t\t\tsetup data blksz %d num %d sglen=%d fl=%08x Tns=%u\n",
42152 + mmc_hostname(mmc), data->blksz, data->blocks, data->sg_len,
42153 + data->flags, data->timeout_ns);
42154 +
42155 + if (data->sg_len > SDTIO_MAX_SG_BLOCKS) {
42156 + ret = -EINVAL;
42157 + data->error = -EINVAL;
42158 + goto fail;
42159 + }
42160 +
42161 + ud->regs->data_timeout_ns = data->timeout_ns;
42162 + ud->regs->data_blksz = data->blksz;
42163 + ud->regs->data_blkct = data->blocks;
42164 + ud->regs->sg_len = data->sg_len;
42165 +
42166 + /*
42167 + * Load all of our sg list into the driver sg buffer
42168 + */
42169 + for (i = 0; i < data->sg_len; i++) {
42170 + sd_printk("%s: sg %d = %p %d\n", mmc_hostname(mmc), i, sg_virt(sg), sg->length);
42171 + ud->regs->sg[i].addr = sg_virt(sg);
42172 + ud->regs->sg[i].len = sg->length;
42173 + if (((u32_t)ud->regs->sg[i].addr & 0x03) || (sg->length & 0x03)) {
42174 + sd_printk("%s: Need aligned buffers\n", mmc_hostname(mmc));
42175 + ret = -EINVAL;
42176 + data->error = -EINVAL;
42177 + goto fail;
42178 + }
42179 + sg++;
42180 + }
42181 + if (data->flags & MMC_DATA_READ) {
42182 + command |= SDTIO_COMMAND_FLAG_DATA_RD;
42183 + } else if (data->flags & MMC_DATA_WRITE) {
42184 + command |= SDTIO_COMMAND_FLAG_DATA_WR;
42185 + } else if (data->flags & MMC_DATA_STREAM) {
42186 + command |= SDTIO_COMMAND_FLAG_DATA_STREAM;
42187 + }
42188 + }
42189 +
42190 + if (mrq->stop) {
42191 + struct mmc_command *stop = mrq->stop;
42192 + sd_printk("%s: \t\t\tsetup stop %02d arg %08x flags %08x\n", mmc_hostname(mmc), stop->opcode, stop->arg, stop->flags);
42193 +
42194 + ud->regs->stop_opcode = stop->opcode;
42195 + ud->regs->stop_arg = stop->arg;
42196 +
42197 + command |= SDTIO_COMMAND_FLAG_STOP_CMD;
42198 +
42199 + if (stop->flags & MMC_RSP_PRESENT) {
42200 + command |= SDTIO_COMMAND_FLAG_STOP_RSP;
42201 + }
42202 +
42203 + if (stop->flags & MMC_RSP_136) {
42204 + command |= SDTIO_COMMAND_FLAG_STOP_RSP_136;
42205 + }
42206 +
42207 + if (stop->flags & MMC_RSP_CRC) {
42208 + command |= SDTIO_COMMAND_FLAG_STOP_RSP_CRC;
42209 + }
42210 + }
42211 +
42212 + ud->mrq = mrq;
42213 +
42214 + sd_printk("%s: Sending command %08x\n", mmc_hostname(mmc), command);
42215 +
42216 + ubicom32sd_send_command(ud, command, 0);
42217 +
42218 + return;
42219 +fail:
42220 + sd_printk("%s: mmcreq ret = %d\n", mmc_hostname(mmc), ret);
42221 + mrq->cmd->error = ret;
42222 + mmc_request_done(mmc, mrq);
42223 +}
42224 +
42225 +/*
42226 + * ubicom32sd_mmc_set_ios
42227 + */
42228 +static void ubicom32sd_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
42229 +{
42230 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42231 + u32_t command = SDTIO_COMMAND_SETUP << SDTIO_COMMAND_SHIFT;
42232 + u32_t arg = 0;
42233 + sd_printk("%s: ios call bw:%u pm:%u clk:%u\n", mmc_hostname(mmc), 1 << ios->bus_width, ios->power_mode, ios->clock);
42234 +
42235 + switch (ios->bus_width) {
42236 + case MMC_BUS_WIDTH_1:
42237 + command |= SDTIO_COMMAND_FLAG_SET_WIDTH | SDTIO_COMMAND_FLAG_1BIT;
42238 + break;
42239 +
42240 + case MMC_BUS_WIDTH_4:
42241 + command |= SDTIO_COMMAND_FLAG_SET_WIDTH | SDTIO_COMMAND_FLAG_4BIT;
42242 + break;
42243 + }
42244 +
42245 + if (ios->clock) {
42246 + arg = ios->clock;
42247 + command |= SDTIO_COMMAND_FLAG_SET_CLOCK;
42248 + }
42249 +
42250 + switch (ios->power_mode) {
42251 +
42252 + /*
42253 + * Turn off the SD bus (power + clock)
42254 + */
42255 + case MMC_POWER_OFF:
42256 + gpio_set_value(ud->pdata->cards[0].pin_pwr, !ud->pdata->cards[0].pwr_polarity);
42257 + command |= SDTIO_COMMAND_FLAG_SET_CLOCK;
42258 + break;
42259 +
42260 + /*
42261 + * Turn on the power to the SD bus
42262 + */
42263 + case MMC_POWER_ON:
42264 + gpio_set_value(ud->pdata->cards[0].pin_pwr, ud->pdata->cards[0].pwr_polarity);
42265 + break;
42266 +
42267 + /*
42268 + * Turn on the clock to the SD bus
42269 + */
42270 + case MMC_POWER_UP:
42271 + /*
42272 + * Done above
42273 + */
42274 + break;
42275 + }
42276 +
42277 + ubicom32sd_send_command_sync(ud, command, arg);
42278 +
42279 + /*
42280 + * Let the power settle down
42281 + */
42282 + udelay(500);
42283 +}
42284 +
42285 +/*
42286 + * ubicom32sd_mmc_get_cd
42287 + */
42288 +static int ubicom32sd_mmc_get_cd(struct mmc_host *mmc)
42289 +{
42290 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42291 + sd_printk("%s: get cd %u %u\n", mmc_hostname(mmc), ud->pdata->cards[0].pin_cd, gpio_get_value(ud->pdata->cards[0].pin_cd));
42292 +
42293 + return gpio_get_value(ud->pdata->cards[0].pin_cd) ?
42294 + ud->pdata->cards[0].cd_polarity :
42295 + !ud->pdata->cards[0].cd_polarity;
42296 +}
42297 +
42298 +/*
42299 + * ubicom32sd_mmc_get_ro
42300 + */
42301 +static int ubicom32sd_mmc_get_ro(struct mmc_host *mmc)
42302 +{
42303 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42304 + sd_printk("%s: get ro %u %u\n", mmc_hostname(mmc), ud->pdata->cards[0].pin_wp, gpio_get_value(ud->pdata->cards[0].pin_wp));
42305 +
42306 + return gpio_get_value(ud->pdata->cards[0].pin_wp) ?
42307 + ud->pdata->cards[0].wp_polarity :
42308 + !ud->pdata->cards[0].wp_polarity;
42309 +}
42310 +
42311 +/*
42312 + * ubicom32sd_mmc_enable_sdio_irq
42313 + */
42314 +static void ubicom32sd_mmc_enable_sdio_irq(struct mmc_host *mmc, int enable)
42315 +{
42316 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42317 +
42318 + ud->int_en = enable;
42319 + if (enable && ud->int_pend) {
42320 + ud->int_pend = 0;
42321 + mmc_signal_sdio_irq(mmc);
42322 + }
42323 +}
42324 +
42325 +/*
42326 + * ubicom32sd_interrupt
42327 + */
42328 +static irqreturn_t ubicom32sd_interrupt(int irq, void *dev)
42329 +{
42330 + struct mmc_host *mmc = (struct mmc_host *)dev;
42331 + struct mmc_request *mrq;
42332 + struct ubicom32sd_data *ud;
42333 + u32_t int_status;
42334 +
42335 + if (!mmc) {
42336 + return IRQ_HANDLED;
42337 + }
42338 +
42339 + ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42340 + if (!ud) {
42341 + return IRQ_HANDLED;
42342 + }
42343 +
42344 + int_status = ud->regs->int_status;
42345 + ud->regs->int_status &= ~int_status;
42346 +
42347 + if (int_status & SDTIO_VP_INT_STATUS_SDIO_INT) {
42348 + if (ud->int_en) {
42349 + ud->int_pend = 0;
42350 + mmc_signal_sdio_irq(mmc);
42351 + } else {
42352 + ud->int_pend++;
42353 + }
42354 + }
42355 +
42356 + if (!(int_status & SDTIO_VP_INT_STATUS_DONE)) {
42357 + return IRQ_HANDLED;
42358 + }
42359 +
42360 + mrq = ud->mrq;
42361 + if (!mrq) {
42362 + sd_printk("%s: Spurious interrupt", mmc_hostname(mmc));
42363 + return IRQ_HANDLED;
42364 + }
42365 + ud->mrq = NULL;
42366 +
42367 + /*
42368 + * SDTIO_VP_INT_DONE
42369 + */
42370 + if (mrq->cmd->flags & MMC_RSP_PRESENT) {
42371 + struct mmc_command *cmd = mrq->cmd;
42372 + cmd->error = 0;
42373 +
42374 + if ((cmd->flags & MMC_RSP_CRC) && (int_status & SDTIO_VP_INT_STATUS_CMD_RSP_CRC)) {
42375 + cmd->error = -EILSEQ;
42376 + } else if (int_status & SDTIO_VP_INT_STATUS_CMD_RSP_TIMEOUT) {
42377 + cmd->error = -ETIMEDOUT;
42378 + goto done;
42379 + } else if (cmd->flags & MMC_RSP_136) {
42380 + cmd->resp[0] = ud->regs->cmd_rsp0;
42381 + cmd->resp[1] = ud->regs->cmd_rsp1;
42382 + cmd->resp[2] = ud->regs->cmd_rsp2;
42383 + cmd->resp[3] = ud->regs->cmd_rsp3;
42384 + } else {
42385 + cmd->resp[0] = ud->regs->cmd_rsp0;
42386 + }
42387 + sd_printk("%s:\t\t\tResponse %08x %08x %08x %08x err=%d\n", mmc_hostname(mmc), cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3], cmd->error);
42388 + }
42389 +
42390 + if (mrq->data) {
42391 + struct mmc_data *data = mrq->data;
42392 +
42393 + if (int_status & SDTIO_VP_INT_STATUS_DATA_TIMEOUT) {
42394 + data->error = -ETIMEDOUT;
42395 + sd_printk("%s:\t\t\tData Timeout\n", mmc_hostname(mmc));
42396 + goto done;
42397 + } else if (int_status & SDTIO_VP_INT_STATUS_DATA_CRC_ERR) {
42398 + data->error = -EILSEQ;
42399 + sd_printk("%s:\t\t\tData CRC\n", mmc_hostname(mmc));
42400 + goto done;
42401 + } else if (int_status & SDTIO_VP_INT_STATUS_DATA_PROG_ERR) {
42402 + data->error = -EILSEQ;
42403 + sd_printk("%s:\t\t\tData Program Error\n", mmc_hostname(mmc));
42404 + goto done;
42405 + } else {
42406 + data->error = 0;
42407 + data->bytes_xfered = ud->regs->data_bytes_transferred;
42408 + }
42409 + }
42410 +
42411 + if (mrq->stop && (mrq->stop->flags & MMC_RSP_PRESENT)) {
42412 + struct mmc_command *stop = mrq->stop;
42413 + stop->error = 0;
42414 +
42415 + if ((stop->flags & MMC_RSP_CRC) && (int_status & SDTIO_VP_INT_STATUS_STOP_RSP_CRC)) {
42416 + stop->error = -EILSEQ;
42417 + } else if (int_status & SDTIO_VP_INT_STATUS_STOP_RSP_TIMEOUT) {
42418 + stop->error = -ETIMEDOUT;
42419 + goto done;
42420 + } else if (stop->flags & MMC_RSP_136) {
42421 + stop->resp[0] = ud->regs->stop_rsp0;
42422 + stop->resp[1] = ud->regs->stop_rsp1;
42423 + stop->resp[2] = ud->regs->stop_rsp2;
42424 + stop->resp[3] = ud->regs->stop_rsp3;
42425 + } else {
42426 + stop->resp[0] = ud->regs->stop_rsp0;
42427 + }
42428 + sd_printk("%s:\t\t\tStop Response %08x %08x %08x %08x err=%d\n", mmc_hostname(mmc), stop->resp[0], stop->resp[1], stop->resp[2], stop->resp[3], stop->error);
42429 + }
42430 +
42431 +done:
42432 + mmc_request_done(mmc, mrq);
42433 +
42434 + return IRQ_HANDLED;
42435 +}
42436 +
42437 +static struct mmc_host_ops ubicom32sd_ops = {
42438 + .request = ubicom32sd_mmc_request,
42439 + .set_ios = ubicom32sd_mmc_set_ios,
42440 + .get_ro = ubicom32sd_mmc_get_ro,
42441 + .get_cd = ubicom32sd_mmc_get_cd,
42442 + .enable_sdio_irq = ubicom32sd_mmc_enable_sdio_irq,
42443 +};
42444 +
42445 +/*
42446 + * ubicom32sd_probe
42447 + */
42448 +static int __devinit ubicom32sd_probe(struct platform_device *pdev)
42449 +{
42450 + struct ubicom32sd_platform_data *pdata = (struct ubicom32sd_platform_data *)pdev->dev.platform_data;
42451 + struct mmc_host *mmc;
42452 + struct ubicom32sd_data *ud;
42453 + struct resource *res_regs;
42454 + struct resource *res_irq_tx;
42455 + struct resource *res_irq_rx;
42456 + int ret;
42457 +
42458 + /*
42459 + * Get our resources, regs is the hardware driver base address
42460 + * and the tx and rx irqs are used to communicate with the
42461 + * hardware driver.
42462 + */
42463 + res_regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
42464 + res_irq_tx = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
42465 + res_irq_rx = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
42466 + if (!res_regs || !res_irq_tx || !res_irq_rx) {
42467 + ret = -EINVAL;
42468 + goto fail;
42469 + }
42470 +
42471 + /*
42472 + * Reserve any gpios we need
42473 + */
42474 + ret = gpio_request(pdata->cards[0].pin_wp, "sd-wp");
42475 + if (ret) {
42476 + goto fail;
42477 + }
42478 + gpio_direction_input(pdata->cards[0].pin_wp);
42479 +
42480 + ret = gpio_request(pdata->cards[0].pin_cd, "sd-cd");
42481 + if (ret) {
42482 + goto fail_cd;
42483 + }
42484 + gpio_direction_input(pdata->cards[0].pin_cd);
42485 +
42486 + /*
42487 + * HACK: for the dual port controller on port F, we don't support the second port right now
42488 + */
42489 + if (pdata->ncards > 1) {
42490 + ret = gpio_request(pdata->cards[1].pin_pwr, "sd-pwr");
42491 + gpio_direction_output(pdata->cards[1].pin_pwr, !pdata->cards[1].pwr_polarity);
42492 + gpio_direction_output(pdata->cards[1].pin_pwr, pdata->cards[1].pwr_polarity);
42493 + }
42494 +
42495 + ret = gpio_request(pdata->cards[0].pin_pwr, "sd-pwr");
42496 + if (ret) {
42497 + goto fail_pwr;
42498 + }
42499 + gpio_direction_output(pdata->cards[0].pin_pwr, !pdata->cards[0].pwr_polarity);
42500 +
42501 + /*
42502 + * Allocate the MMC driver, it includes memory for our data.
42503 + */
42504 + mmc = mmc_alloc_host(sizeof(struct ubicom32sd_data), &pdev->dev);
42505 + if (!mmc) {
42506 + ret = -ENOMEM;
42507 + goto fail_mmc;
42508 + }
42509 + ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42510 + ud->mmc = mmc;
42511 + ud->pdata = pdata;
42512 + ud->regs = (struct sdtio_vp_regs *)res_regs->start;
42513 + ud->irq_tx = res_irq_tx->start;
42514 + ud->irq_rx = res_irq_rx->start;
42515 + platform_set_drvdata(pdev, mmc);
42516 +
42517 + ret = request_irq(ud->irq_rx, ubicom32sd_interrupt, IRQF_DISABLED, mmc_hostname(mmc), mmc);
42518 + if (ret) {
42519 + goto fail_mmc;
42520 + }
42521 +
42522 + /*
42523 + * Fill in the mmc structure
42524 + */
42525 + mmc->ops = &ubicom32sd_ops;
42526 + mmc->caps = MMC_CAP_4_BIT_DATA | MMC_CAP_NEEDS_POLL | MMC_CAP_SDIO_IRQ |
42527 + MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED;
42528 +
42529 + mmc->f_min = ud->regs->f_min;
42530 + mmc->f_max = ud->regs->f_max;
42531 + mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
42532 +
42533 + /*
42534 + * Setup some restrictions on transfers
42535 + *
42536 + * We allow up to SDTIO_MAX_SG_BLOCKS of data to DMA into, there are
42537 + * not really any "max_seg_size", "max_req_size", or "max_blk_count"
42538 + * restrictions (must be less than U32_MAX though), pick
42539 + * something large?!...
42540 + *
42541 + * The hardware can do up to 4095 bytes per block, since the spec
42542 + * only requires 2048, we'll set it to that and not worry about
42543 + * potential weird blk lengths.
42544 + */
42545 + mmc->max_hw_segs = SDTIO_MAX_SG_BLOCKS;
42546 + mmc->max_phys_segs = SDTIO_MAX_SG_BLOCKS;
42547 + mmc->max_seg_size = 1024 * 1024;
42548 + mmc->max_req_size = 1024 * 1024;
42549 + mmc->max_blk_count = 1024;
42550 +
42551 + mmc->max_blk_size = 2048;
42552 +
42553 + ubicom32sd_reset(ud);
42554 +
42555 + /*
42556 + * enable interrupts
42557 + */
42558 + ud->int_en = 0;
42559 + ubicom32sd_send_command_sync(ud, SDTIO_COMMAND_SETUP_SDIO << SDTIO_COMMAND_SHIFT | SDTIO_COMMAND_FLAG_SDIO_INT_EN, 0);
42560 +
42561 + mmc_add_host(mmc);
42562 +
42563 + printk(KERN_INFO "%s at %p, irq %d/%d\n", mmc_hostname(mmc),
42564 + ud->regs, ud->irq_tx, ud->irq_rx);
42565 + return 0;
42566 +
42567 +fail_mmc:
42568 + gpio_free(pdata->cards[0].pin_pwr);
42569 +fail_pwr:
42570 + gpio_free(pdata->cards[0].pin_cd);
42571 +fail_cd:
42572 + gpio_free(pdata->cards[0].pin_wp);
42573 +fail:
42574 + return ret;
42575 +}
42576 +
42577 +/*
42578 + * ubicom32sd_remove
42579 + */
42580 +static int __devexit ubicom32sd_remove(struct platform_device *pdev)
42581 +{
42582 + struct mmc_host *mmc = platform_get_drvdata(pdev);
42583 +
42584 + platform_set_drvdata(pdev, NULL);
42585 +
42586 + if (mmc) {
42587 + struct ubicom32sd_data *ud = (struct ubicom32sd_data *)mmc_priv(mmc);
42588 +
42589 + gpio_free(ud->pdata->cards[0].pin_pwr);
42590 + gpio_free(ud->pdata->cards[0].pin_cd);
42591 + gpio_free(ud->pdata->cards[0].pin_wp);
42592 +
42593 + mmc_remove_host(mmc);
42594 + mmc_free_host(mmc);
42595 + }
42596 +
42597 + /*
42598 + * Note that our data is allocated as part of the mmc structure
42599 + * so we don't need to free it.
42600 + */
42601 + return 0;
42602 +}
42603 +
42604 +static struct platform_driver ubicom32sd_driver = {
42605 + .driver = {
42606 + .name = DRIVER_NAME,
42607 + .owner = THIS_MODULE,
42608 + },
42609 + .probe = ubicom32sd_probe,
42610 + .remove = __devexit_p(ubicom32sd_remove),
42611 +#if 0
42612 + .suspend = ubicom32sd_suspend,
42613 + .resume = ubicom32sd_resume,
42614 +#endif
42615 +};
42616 +
42617 +/*
42618 + * ubicom32sd_init
42619 + */
42620 +static int __init ubicom32sd_init(void)
42621 +{
42622 + return platform_driver_register(&ubicom32sd_driver);
42623 +}
42624 +module_init(ubicom32sd_init);
42625 +
42626 +/*
42627 + * ubicom32sd_exit
42628 + */
42629 +static void __exit ubicom32sd_exit(void)
42630 +{
42631 + platform_driver_unregister(&ubicom32sd_driver);
42632 +}
42633 +module_exit(ubicom32sd_exit);
42634 +
42635 +MODULE_AUTHOR("Patrick Tjin");
42636 +MODULE_DESCRIPTION("Ubicom32 Secure Digital Host Controller Interface driver");
42637 +MODULE_LICENSE("GPL");
42638 diff -ruN linux-2.6.30.10/drivers/mtd/devices/Kconfig linux-2.6.30.10-ubi/drivers/mtd/devices/Kconfig
42639 --- linux-2.6.30.10/drivers/mtd/devices/Kconfig 2009-12-04 08:00:07.000000000 +0200
42640 +++ linux-2.6.30.10-ubi/drivers/mtd/devices/Kconfig 2009-12-11 11:45:16.000000000 +0200
42641 @@ -104,6 +104,31 @@
42642 help
42643 This option enables FAST_READ access supported by ST M25Pxx.
42644
42645 +config MTD_UBI32_NAND_SPI_ER
42646 + tristate "UBI32_NAND SPI-ER support"
42647 + help
42648 + This driver supports the Micron MT29F1G01 SPI-ER NAND flash chip
42649 + using the built in flash controller on the Ubicom32 architecture.
42650 + Partial page writes are not supported by this driver.
42651 +
42652 +config MTD_NAND_SPI_ER
42653 + tristate "NAND SPI-ER support"
42654 + help
42655 + This driver supports the Micron MT29F1G01 SPI-ER NAND flash chip
42656 + using a generic SPI bus. Partial page writes are supported
42657 + by this driver.
42658 +
42659 +config MTD_UBI32_M25P80
42660 + tristate "Ubicom processor support for most SPI Flash chips (AT26DF, M25P, W25X, ...)"
42661 + depends on UBICOM32
42662 + default y
42663 + help
42664 + This enables access to most modern SPI flash chips, used for
42665 + program and data storage. Series supported include Atmel AT26DF,
42666 + Spansion S25SL, SST 25VF, ST M25P, and Winbond W25X. Other chips
42667 + are supported as well. See the driver source for the current list,
42668 + or to add other chips.
42669 +
42670 config MTD_SLRAM
42671 tristate "Uncached system RAM"
42672 help
42673 diff -ruN linux-2.6.30.10/drivers/mtd/devices/Makefile linux-2.6.30.10-ubi/drivers/mtd/devices/Makefile
42674 --- linux-2.6.30.10/drivers/mtd/devices/Makefile 2009-12-04 08:00:07.000000000 +0200
42675 +++ linux-2.6.30.10-ubi/drivers/mtd/devices/Makefile 2009-12-11 11:45:16.000000000 +0200
42676 @@ -16,3 +16,6 @@
42677 obj-$(CONFIG_MTD_BLOCK2MTD) += block2mtd.o
42678 obj-$(CONFIG_MTD_DATAFLASH) += mtd_dataflash.o
42679 obj-$(CONFIG_MTD_M25P80) += m25p80.o
42680 +obj-$(CONFIG_MTD_UBI32_M25P80) += ubi32-m25p80.o
42681 +obj-$(CONFIG_MTD_NAND_SPI_ER) += nand-spi-er.o
42682 +obj-$(CONFIG_MTD_UBI32_NAND_SPI_ER) += ubi32-nand-spi-er.o
42683 diff -ruN linux-2.6.30.10/drivers/mtd/devices/nand-spi-er.c linux-2.6.30.10-ubi/drivers/mtd/devices/nand-spi-er.c
42684 --- linux-2.6.30.10/drivers/mtd/devices/nand-spi-er.c 1970-01-01 02:00:00.000000000 +0200
42685 +++ linux-2.6.30.10-ubi/drivers/mtd/devices/nand-spi-er.c 2009-12-11 11:45:16.000000000 +0200
42686 @@ -0,0 +1,1017 @@
42687 +/*
42688 + * Micron SPI-ER NAND Flash Memory
42689 + *
42690 + * (C) Copyright 2009, Ubicom, Inc.
42691 + *
42692 + * This file is part of the Ubicom32 Linux Kernel Port.
42693 + *
42694 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
42695 + * it and/or modify it under the terms of the GNU General Public License
42696 + * as published by the Free Software Foundation, either version 2 of the
42697 + * License, or (at your option) any later version.
42698 + *
42699 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
42700 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
42701 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
42702 + * the GNU General Public License for more details.
42703 + *
42704 + * You should have received a copy of the GNU General Public License
42705 + * along with the Ubicom32 Linux Kernel Port. If not,
42706 + * see <http://www.gnu.org/licenses/>.
42707 +*/
42708 +#include <linux/module.h>
42709 +#include <linux/init.h>
42710 +#include <linux/slab.h>
42711 +#include <linux/delay.h>
42712 +#include <linux/device.h>
42713 +#include <linux/mutex.h>
42714 +#include <linux/err.h>
42715 +
42716 +#include <linux/spi/spi.h>
42717 +#include <linux/spi/flash.h>
42718 +
42719 +#include <linux/mtd/mtd.h>
42720 +#include <linux/mtd/partitions.h>
42721 +
42722 +#define NAND_SPI_ER_BLOCK_FROM_ROW(row) (row >> 6)
42723 +
42724 +#define NAND_SPI_ER_STATUS_P_FAIL (1 << 3)
42725 +#define NAND_SPI_ER_STATUS_E_FAIL (1 << 2)
42726 +#define NAND_SPI_ER_STATUS_OIP (1 << 0)
42727 +
42728 +#define NAND_SPI_ER_LAST_ROW_INVALID 0xFFFFFFFF
42729 +#define NAND_SPI_ER_BAD_BLOCK_MARK_OFFSET 0x08
42730 +
42731 +struct nand_spi_er_device {
42732 + const char *name;
42733 +
42734 + uint8_t id0;
42735 + uint8_t id1;
42736 +
42737 + unsigned int blocks;
42738 + unsigned int pages_per_block;
42739 + unsigned int page_size;
42740 + unsigned int write_size;
42741 + unsigned int erase_size;
42742 +};
42743 +
42744 +struct nand_spi_er {
42745 + char name[24];
42746 +
42747 + const struct nand_spi_er_device *device;
42748 +
42749 + struct mutex lock;
42750 + struct spi_device *spi;
42751 +
42752 + struct mtd_info mtd;
42753 +
42754 + unsigned int last_row; /* the last row we fetched */
42755 +
42756 + /*
42757 + * Bad block table (MUST be last in strcuture)
42758 + */
42759 + unsigned long nbb;
42760 + unsigned long bbt[0];
42761 +};
42762 +
42763 +const struct nand_spi_er_device nand_spi_er_devices[] = {
42764 + {
42765 + name: "MT29F1G01ZDC",
42766 + id0: 0x2C,
42767 + id1: 0x12,
42768 + blocks: 1024,
42769 + pages_per_block: 64,
42770 + page_size: 2048,
42771 + write_size: 512,
42772 + erase_size: 64 * 2048,
42773 + },
42774 + {
42775 + name: "MT29F1G01ZDC",
42776 + id0: 0x2C,
42777 + id1: 0x13,
42778 + blocks: 1024,
42779 + pages_per_block: 64,
42780 + page_size: 2048,
42781 + write_size: 512,
42782 + erase_size: 64 * 2048,
42783 + },
42784 +};
42785 +
42786 +static int read_only = 0;
42787 +module_param(read_only, int, 0);
42788 +MODULE_PARM_DESC(read_only, "Leave device locked");
42789 +
42790 +/*
42791 + * nand_spi_er_get_feature
42792 + * Get Feature register
42793 + */
42794 +static int nand_spi_er_get_feature(struct nand_spi_er *chip, int reg, uint8_t *data)
42795 +{
42796 + uint8_t txbuf[2];
42797 + uint8_t rxbuf[1];
42798 + int res;
42799 +
42800 + txbuf[0] = 0x0F;
42801 + txbuf[1] = reg;
42802 + res = spi_write_then_read(chip->spi, txbuf, 2, rxbuf, 1);
42803 + if (res) {
42804 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed get feature res=%d\n", chip->name, res);
42805 + return res;
42806 + }
42807 + *data = rxbuf[0];
42808 + return 0;
42809 +}
42810 +
42811 +/*
42812 + * nand_spi_er_busywait
42813 + * Wait until the chip is not busy
42814 + */
42815 +static int nand_spi_er_busywait(struct nand_spi_er *chip, uint8_t *data)
42816 +{
42817 + int i;
42818 +
42819 + for (i = 0; i < 100; i++) {
42820 + int res = nand_spi_er_get_feature(chip, 0xC0, data);
42821 + if (res) {
42822 + return res;
42823 + }
42824 + if (!(*data & NAND_SPI_ER_STATUS_OIP)) {
42825 + break;
42826 + }
42827 + }
42828 +
42829 + return 0;
42830 +}
42831 +
42832 +/*
42833 + * nand_spi_er_erase
42834 + * Erase a block, parameters must be block aligned
42835 + */
42836 +static int nand_spi_er_erase(struct mtd_info *mtd, struct erase_info *instr)
42837 +{
42838 + struct nand_spi_er *chip = mtd->priv;
42839 + struct spi_device *spi = chip->spi;
42840 + uint8_t txbuf[4];
42841 + int res;
42842 +
42843 + DEBUG(MTD_DEBUG_LEVEL3, "%s: erase addr:%x len:%x\n", chip->name, instr->addr, instr->len);
42844 +
42845 + if ((instr->addr + instr->len) > mtd->size) {
42846 + return -EINVAL;
42847 + }
42848 +
42849 + if (instr->addr & (chip->device->erase_size - 1)) {
42850 + DEBUG(MTD_DEBUG_LEVEL1, "%s: erase address is not aligned %x\n", chip->name, instr->addr);
42851 + return -EINVAL;
42852 + }
42853 +
42854 + if (instr->len & (chip->device->erase_size - 1)) {
42855 + DEBUG(MTD_DEBUG_LEVEL1, "%s: erase len is not aligned %x\n", chip->name, instr->len);
42856 + return -EINVAL;
42857 + }
42858 +
42859 + mutex_lock(&chip->lock);
42860 + chip->last_row = NAND_SPI_ER_LAST_ROW_INVALID;
42861 +
42862 + while (instr->len) {
42863 + uint32_t block = instr->addr >> 17;
42864 + uint32_t row = block << 6;
42865 + uint8_t stat;
42866 + DEBUG(MTD_DEBUG_LEVEL3, "%s: block erase row:%x block:%x addr:%x rem:%x\n", chip->name, row, block, instr->addr, instr->len);
42867 +
42868 + /*
42869 + * Write enable
42870 + */
42871 + txbuf[0] = 0x06;
42872 + res = spi_write(spi, txbuf, 1);
42873 + if (res) {
42874 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write enable res=%d\n", chip->name, res);
42875 + mutex_unlock(&chip->lock);
42876 + return res;
42877 + }
42878 +
42879 + /*
42880 + * Test for bad block
42881 + */
42882 + if (test_bit(block, chip->bbt)) {
42883 + instr->fail_addr = block << 17;
42884 + instr->state = MTD_ERASE_FAILED;
42885 + res = -EBADMSG;
42886 + goto done;
42887 + }
42888 +
42889 + /*
42890 + * Block erase
42891 + */
42892 + txbuf[0] = 0xD8;
42893 + txbuf[1] = 0x00;
42894 + txbuf[2] = row >> 8;
42895 + txbuf[3] = row & 0xFF;
42896 + res = spi_write(spi, txbuf, 4);
42897 + if (res) {
42898 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed block erase res=%d\n", chip->name, res);
42899 + instr->fail_addr = block << 17;
42900 + instr->state = MTD_ERASE_FAILED;
42901 + goto done;
42902 + }
42903 +
42904 + /*
42905 + * Wait
42906 + */
42907 + res = nand_spi_er_busywait(chip, &stat);
42908 + if (res || (stat & NAND_SPI_ER_STATUS_OIP)) {
42909 + instr->fail_addr = block << 17;
42910 + instr->state = MTD_ERASE_FAILED;
42911 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive res=%d stat=%02x\n", chip->name, res, stat);
42912 + if (res) {
42913 + goto done;
42914 + }
42915 +
42916 + /*
42917 + * Chip is stuck?
42918 + */
42919 + res = -EIO;
42920 + goto done;
42921 + }
42922 +
42923 + /*
42924 + * Check the status register
42925 + */
42926 + if (stat & NAND_SPI_ER_STATUS_E_FAIL) {
42927 + DEBUG(MTD_DEBUG_LEVEL1, "%s: E_FAIL signalled (%02x)\n", chip->name, stat);
42928 + instr->fail_addr = block << 17;
42929 + instr->state = MTD_ERASE_FAILED;
42930 + goto done;
42931 + }
42932 +
42933 + /*
42934 + * Next
42935 + */
42936 + block++;
42937 + instr->len -= chip->device->erase_size;
42938 + instr->addr += chip->device->erase_size;
42939 + }
42940 +
42941 + instr->state = MTD_ERASE_DONE;
42942 +
42943 + mutex_unlock(&chip->lock);
42944 + return 0;
42945 +
42946 +done:
42947 + /*
42948 + * Write disable
42949 + */
42950 + txbuf[0] = 0x04;
42951 + res = spi_write(spi, txbuf, 1);
42952 + if (res) {
42953 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write disable res=%d\n", chip->name, res);
42954 + }
42955 +
42956 + mutex_unlock(&chip->lock);
42957 +
42958 + mtd_erase_callback(instr);
42959 + return 0;
42960 +}
42961 +
42962 +/*
42963 + * nand_spi_er_read
42964 + *
42965 + * return -EUCLEAN: ecc error recovered
42966 + * return -EBADMSG: ecc error not recovered
42967 +*/
42968 +static int nand_spi_er_read(struct mtd_info *mtd, loff_t from, size_t len,
42969 + size_t *retlen, u_char *buf)
42970 +{
42971 + struct nand_spi_er *chip = mtd->priv;
42972 + struct spi_device *spi = chip->spi;
42973 +
42974 + uint32_t row;
42975 + uint32_t column;
42976 + int retval = 0;
42977 +
42978 + *retlen = 0;
42979 + DEBUG(MTD_DEBUG_LEVEL2, "%s: read block from %llx len %d into %p\n", chip->name, from, len, buf);
42980 +
42981 + /*
42982 + * Zero length reads, nothing to do
42983 + */
42984 + if (len == 0) {
42985 + return 0;
42986 + }
42987 +
42988 + /*
42989 + * Reject reads which go over the end of the flash
42990 + */
42991 + if ((from + len) > mtd->size) {
42992 + return -EINVAL;
42993 + }
42994 +
42995 + /*
42996 + * Get the row and column address to start at
42997 + */
42998 + row = from >> 11;
42999 + column = from & 0x7FF;
43000 + DEBUG(MTD_DEBUG_LEVEL3, "%s: row=%x %d column=%x %d last_row=%x %d\n", chip->name, row, row, column, column, chip->last_row, chip->last_row);
43001 +
43002 + /*
43003 + * Read the data from the chip
43004 + */
43005 + mutex_lock(&chip->lock);
43006 + while (len) {
43007 + uint8_t stat;
43008 + uint8_t txbuf[4];
43009 + struct spi_message message;
43010 + struct spi_transfer x[2];
43011 + int res;
43012 + size_t toread;
43013 +
43014 + /*
43015 + * Figure out how much to read
43016 + *
43017 + * If we are reading from the middle of a page then the most we
43018 + * can read is to the end of the page
43019 + */
43020 + toread = len;
43021 + if (toread > (chip->device->page_size - column)) {
43022 + toread = chip->device->page_size - column;
43023 + }
43024 +
43025 + DEBUG(MTD_DEBUG_LEVEL3, "%s: buf=%p toread=%x row=%x column=%x last_row=%x\n", chip->name, buf, toread, row, column, chip->last_row);
43026 +
43027 + if (chip->last_row != row) {
43028 + /*
43029 + * Check if the block is bad
43030 + */
43031 + if (test_bit(NAND_SPI_ER_BLOCK_FROM_ROW(row), chip->bbt)) {
43032 + mutex_unlock(&chip->lock);
43033 + return -EBADMSG;
43034 + }
43035 +
43036 + /*
43037 + * Load the appropriate page
43038 + */
43039 + txbuf[0] = 0x13;
43040 + txbuf[1] = 0x00;
43041 + txbuf[2] = row >> 8;
43042 + txbuf[3] = row & 0xFF;
43043 + res = spi_write(spi, txbuf, 4);
43044 + if (res) {
43045 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed page load res=%d\n", chip->name, res);
43046 + mutex_unlock(&chip->lock);
43047 + return res;
43048 + }
43049 +
43050 + /*
43051 + * Wait
43052 + */
43053 + res = nand_spi_er_busywait(chip, &stat);
43054 + if (res || (stat & NAND_SPI_ER_STATUS_OIP)) {
43055 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive res=%d stat=%02x\n", chip->name, res, stat);
43056 + if (res) {
43057 + mutex_unlock(&chip->lock);
43058 + return res;
43059 + }
43060 +
43061 + /*
43062 + * Chip is stuck?
43063 + */
43064 + mutex_unlock(&chip->lock);
43065 + return -EIO;
43066 + }
43067 +
43068 + /*
43069 + * Check the ECC bits
43070 + */
43071 + stat >>= 4;
43072 + if (stat == 1) {
43073 + DEBUG(MTD_DEBUG_LEVEL1, "%s: ECC recovered, row=%x\n", chip->name, row);
43074 + retval = -EUCLEAN;
43075 + }
43076 + if (stat == 2) {
43077 + DEBUG(MTD_DEBUG_LEVEL0, "%s: failed ECC, row=%x\n", chip->name, row);
43078 + chip->last_row = NAND_SPI_ER_LAST_ROW_INVALID;
43079 + mutex_unlock(&chip->lock);
43080 + return -EBADMSG;
43081 + }
43082 +
43083 + }
43084 +
43085 + chip->last_row = row;
43086 +
43087 + /*
43088 + * Read out the data
43089 + */
43090 + spi_message_init(&message);
43091 + memset(x, 0, sizeof(x));
43092 +
43093 + txbuf[0] = 0x03;
43094 + txbuf[1] = column >> 8;
43095 + txbuf[2] = column & 0xFF;
43096 + txbuf[3] = 0;
43097 + x[0].tx_buf = txbuf;
43098 + x[0].len = 4;
43099 + spi_message_add_tail(&x[0], &message);
43100 +
43101 + x[1].rx_buf = buf;
43102 + x[1].len = toread;
43103 + spi_message_add_tail(&x[1], &message);
43104 +
43105 + res = spi_sync(spi, &message);
43106 + if (res) {
43107 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed data read res=%d\n", chip->name, res);
43108 + mutex_unlock(&chip->lock);
43109 + return res;
43110 + }
43111 + buf += toread;
43112 + len -= toread;
43113 + *retlen += toread;
43114 +
43115 + /*
43116 + * For the next page, increment the row and always start at column 0
43117 + */
43118 + column = 0;
43119 + row++;
43120 + }
43121 +
43122 + mutex_unlock(&chip->lock);
43123 + return retval;
43124 +}
43125 +
43126 +/*
43127 + * nand_spi_er_write
43128 + */
43129 +#define NOT_ALIGNED(x) ((x & (device->write_size - 1)) != 0)
43130 +static int nand_spi_er_write(struct mtd_info *mtd, loff_t to, size_t len,
43131 + size_t *retlen, const u_char *buf)
43132 +{
43133 + struct nand_spi_er *chip = mtd->priv;
43134 + struct spi_device *spi = chip->spi;
43135 + const struct nand_spi_er_device *device = chip->device;
43136 + uint32_t row;
43137 + uint32_t col;
43138 + uint8_t txbuf[4];
43139 + int res;
43140 + size_t towrite;
43141 +
43142 + DEBUG(MTD_DEBUG_LEVEL2, "%s: write block to %llx len %d from %p\n", chip->name, to, len, buf);
43143 +
43144 + *retlen = 0;
43145 +
43146 + /*
43147 + * nothing to write
43148 + */
43149 + if (!len) {
43150 + return 0;
43151 + }
43152 +
43153 + /*
43154 + * Reject writes which go over the end of the flash
43155 + */
43156 + if ((to + len) > mtd->size) {
43157 + return -EINVAL;
43158 + }
43159 +
43160 + /*
43161 + * Check to see if everything is page aligned
43162 + */
43163 + if (NOT_ALIGNED(to) || NOT_ALIGNED(len)) {
43164 + printk(KERN_NOTICE "nand_spi_er_write: Attempt to write non page aligned data\n");
43165 + return -EINVAL;
43166 + }
43167 +
43168 + mutex_lock(&chip->lock);
43169 + chip->last_row = NAND_SPI_ER_LAST_ROW_INVALID;
43170 +
43171 + /*
43172 + * If the first write is a partial write then write at most the number of
43173 + * bytes to get us page aligned and then the remainder will be
43174 + * page aligned. The last bit may be a partial page as well.
43175 + */
43176 + col = to & (device->page_size - 1);
43177 + towrite = device->page_size - col;
43178 + if (towrite > len) {
43179 + towrite = len;
43180 + }
43181 +
43182 + /*
43183 + * Write the data
43184 + */
43185 + row = to >> 11;
43186 + while (len) {
43187 + struct spi_message message;
43188 + struct spi_transfer x[2];
43189 + uint8_t stat;
43190 +
43191 + DEBUG(MTD_DEBUG_LEVEL3, "%s: write %p to row:%x col:%x len:%x rem:%x\n", chip->name, buf, row, col, towrite, len);
43192 +
43193 + /*
43194 + * Write enable
43195 + */
43196 + txbuf[0] = 0x06;
43197 + res = spi_write(spi, txbuf, 1);
43198 + if (res) {
43199 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write enable res=%d\n", chip->name, res);
43200 + mutex_unlock(&chip->lock);
43201 + return res;
43202 + }
43203 +
43204 + /*
43205 + * Write the data into the cache
43206 + */
43207 + spi_message_init(&message);
43208 + memset(x, 0, sizeof(x));
43209 + txbuf[0] = 0x02;
43210 + txbuf[1] = col >> 8;
43211 + txbuf[2] = col & 0xFF;
43212 + x[0].tx_buf = txbuf;
43213 + x[0].len = 3;
43214 + spi_message_add_tail(&x[0], &message);
43215 + x[1].tx_buf = buf;
43216 + x[1].len = towrite;
43217 + spi_message_add_tail(&x[1], &message);
43218 + res = spi_sync(spi, &message);
43219 + if (res) {
43220 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed cache write res=%d\n", chip->name, res);
43221 + goto done;
43222 + }
43223 +
43224 + /*
43225 + * Program execute
43226 + */
43227 + txbuf[0] = 0x10;
43228 + txbuf[1] = 0x00;
43229 + txbuf[2] = row >> 8;
43230 + txbuf[3] = row & 0xFF;
43231 + res = spi_write(spi, txbuf, 4);
43232 + if (res) {
43233 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed prog execute res=%d\n", chip->name, res);
43234 + goto done;
43235 + }
43236 +
43237 + /*
43238 + * Wait
43239 + */
43240 + res = nand_spi_er_busywait(chip, &stat);
43241 + if (res || (stat & NAND_SPI_ER_STATUS_OIP)) {
43242 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive res=%d stat=%02x\n", chip->name, res, stat);
43243 + if (res) {
43244 + goto done;
43245 + }
43246 +
43247 + /*
43248 + * Chip is stuck?
43249 + */
43250 + res = -EIO;
43251 + goto done;
43252 + }
43253 +
43254 + if (stat & (1 << 3)) {
43255 + res = -EBADMSG;
43256 + goto done;
43257 + }
43258 +
43259 + row++;
43260 + buf += towrite;
43261 + len -= towrite;
43262 + *retlen += towrite;
43263 +
43264 + /*
43265 + * At this point, we are always page aligned so start at column 0.
43266 + * Note we may not have a full page to write at the end, hence the
43267 + * check if towrite > len.
43268 + */
43269 + col = 0;
43270 + towrite = device->page_size;
43271 + if (towrite > len) {
43272 + towrite = len;
43273 + }
43274 + }
43275 +
43276 + mutex_unlock(&chip->lock);
43277 + return res;
43278 +
43279 +done:
43280 + /*
43281 + * Write disable
43282 + */
43283 + txbuf[0] = 0x04;
43284 + res = spi_write(spi, txbuf, 1);
43285 + if (res) {
43286 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write disable res=%d\n", chip->name, res);
43287 + }
43288 +
43289 + mutex_unlock(&chip->lock);
43290 +
43291 + return res;
43292 +}
43293 +
43294 +/*
43295 + * nand_spi_er_isbad
43296 + */
43297 +static int nand_spi_er_isbad(struct mtd_info *mtd, loff_t ofs)
43298 +{
43299 + struct nand_spi_er *chip = mtd->priv;
43300 + uint32_t block;
43301 +
43302 + if (ofs & (chip->device->erase_size - 1)) {
43303 + DEBUG(MTD_DEBUG_LEVEL1, "%s: address not aligned %llx\n", chip->name, ofs);
43304 + return -EINVAL;
43305 + }
43306 +
43307 + block = ofs >> 17;
43308 +
43309 + return test_bit(block, chip->bbt);
43310 +}
43311 +
43312 +/*
43313 + * nand_spi_er_markbad
43314 + */
43315 +static int nand_spi_er_markbad(struct mtd_info *mtd, loff_t ofs)
43316 +{
43317 + struct nand_spi_er *chip = mtd->priv;
43318 + struct spi_device *spi = chip->spi;
43319 + uint32_t block;
43320 + uint32_t row;
43321 + uint8_t txbuf[7];
43322 + int res;
43323 + uint8_t stat;
43324 +
43325 + if (ofs & (chip->device->erase_size - 1)) {
43326 + DEBUG(MTD_DEBUG_LEVEL1, "%s: address not aligned %llx\n", chip->name, ofs);
43327 + return -EINVAL;
43328 + }
43329 +
43330 + block = ofs >> 17;
43331 +
43332 + /*
43333 + * If it's already marked bad, no need to mark it
43334 + */
43335 + if (test_bit(block, chip->bbt)) {
43336 + return 0;
43337 + }
43338 +
43339 + /*
43340 + * Mark it in our cache
43341 + */
43342 + __set_bit(block, chip->bbt);
43343 +
43344 + /*
43345 + * Write the user bad block mark. If it fails, then we really
43346 + * can't do anything about it.
43347 + */
43348 + mutex_lock(&chip->lock);
43349 + chip->last_row = NAND_SPI_ER_LAST_ROW_INVALID;
43350 +
43351 + /*
43352 + * Write enable
43353 + */
43354 + txbuf[0] = 0x06;
43355 + res = spi_write(spi, txbuf, 1);
43356 + if (res) {
43357 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write enable res=%d\n", chip->name, res);
43358 + mutex_unlock(&chip->lock);
43359 + return res;
43360 + }
43361 +
43362 + /*
43363 + * Write the mark
43364 + */
43365 + txbuf[0] = 0x84;
43366 + txbuf[1] = 0x08;
43367 + txbuf[2] = NAND_SPI_ER_BAD_BLOCK_MARK_OFFSET;
43368 + txbuf[3] = 0xde;
43369 + txbuf[4] = 0xad;
43370 + txbuf[5] = 0xbe;
43371 + txbuf[6] = 0xef;
43372 + res = spi_write(spi, txbuf, 7);
43373 + if (res) {
43374 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write mark res=%d\n", chip->name, res);
43375 + goto done;
43376 + }
43377 +
43378 + /*
43379 + * Program execute
43380 + */
43381 + row = ofs >> 11;
43382 + txbuf[0] = 0x10;
43383 + txbuf[1] = 0x00;
43384 + txbuf[2] = row >> 8;
43385 + txbuf[3] = row & 0xFF;
43386 + res = spi_write(spi, txbuf, 4);
43387 + if (res) {
43388 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed program execute res=%d\n", chip->name, res);
43389 + goto done;
43390 + }
43391 +
43392 + /*
43393 + * Wait
43394 + */
43395 + res = nand_spi_er_busywait(chip, &stat);
43396 + if (res || (stat & NAND_SPI_ER_STATUS_OIP)) {
43397 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive res=%d stat=%02x\n", chip->name, res, stat);
43398 + if (res) {
43399 + goto done;
43400 + }
43401 +
43402 + /*
43403 + * Chip is stuck?
43404 + */
43405 + res = -EIO;
43406 + goto done;
43407 + }
43408 +
43409 + if (stat & (1 << 3)) {
43410 + res = -EBADMSG;
43411 + }
43412 +
43413 +done:
43414 + /*
43415 + * Write disable
43416 + */
43417 + txbuf[0] = 0x04;
43418 + res = spi_write(spi, txbuf, 1);
43419 + if (res) {
43420 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed write disable res=%d\n", chip->name, res);
43421 + }
43422 +
43423 + mutex_unlock(&chip->lock);
43424 +
43425 + return res;
43426 +}
43427 +
43428 +/*
43429 + * nand_spi_er_read_bbt
43430 + */
43431 +static int nand_spi_er_read_bbt(struct nand_spi_er *chip)
43432 +{
43433 + int j;
43434 + for (j = 0; j < chip->device->blocks; j++) {
43435 + uint8_t txbuf[4];
43436 + uint8_t rxbuf[16];
43437 + uint32_t bbmark;
43438 + int res;
43439 + unsigned short row = j << 6;
43440 + uint8_t stat;
43441 +
43442 + /*
43443 + * Read Page
43444 + */
43445 + txbuf[0] = 0x13;
43446 + txbuf[1] = 0x00;
43447 + txbuf[2] = row >> 8;
43448 + txbuf[3] = row & 0xFF;
43449 + res = spi_write(chip->spi, txbuf, 4);
43450 + if (res) {
43451 + return res;
43452 + }
43453 +
43454 + /*
43455 + * Wait
43456 + */
43457 + res = nand_spi_er_busywait(chip, &stat);
43458 + if (res || (stat & NAND_SPI_ER_STATUS_OIP)) {
43459 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive res=%d stat=%02x\n", chip->name, res, stat);
43460 + if (res) {
43461 + return res;
43462 + }
43463 +
43464 + /*
43465 + * Chip is stuck?
43466 + */
43467 + return -EIO;
43468 + }
43469 +
43470 + /*
43471 + * Check factory bad block mark
43472 + */
43473 + txbuf[0] = 0x03;
43474 + txbuf[1] = 0x08;
43475 + txbuf[2] = 0x00;
43476 + txbuf[3] = 0x00;
43477 + res = spi_write_then_read(chip->spi, txbuf, 4, rxbuf, 16);
43478 + if (res) {
43479 + return res;
43480 + }
43481 + if (rxbuf[0] != 0xFF) {
43482 + chip->nbb++;
43483 + __set_bit(j, chip->bbt);
43484 + continue;
43485 + }
43486 +
43487 + memcpy(&bbmark, &rxbuf[8], 4);
43488 + if (bbmark == 0xdeadbeef) {
43489 + chip->nbb++;
43490 + __set_bit(j, chip->bbt);
43491 + }
43492 + }
43493 +
43494 +#if defined(CONFIG_MTD_DEBUG) && (MTD_DEBUG_LEVEL3 <= CONFIG_MTD_DEBUG_VERBOSE)
43495 + printk("%s: Bad Block Table:", chip->name);
43496 + for (j = 0; j < chip->device->blocks; j++) {
43497 + if ((j % 64) == 0) {
43498 + printk("\n%s: block %03x: ", chip->name, j);
43499 + }
43500 + printk("%c", test_bit(j, chip->bbt) ? 'X' : '.');
43501 + }
43502 + printk("\n%s: Bad Block Numbers: ", chip->name);
43503 + for (j = 0; j < chip->device->blocks; j++) {
43504 + if (test_bit(j, chip->bbt)) {
43505 + printk("%x ", j);
43506 + }
43507 + }
43508 + printk("\n");
43509 +#endif
43510 +
43511 + return 0;
43512 +}
43513 +
43514 +#ifndef MODULE
43515 +/*
43516 + * Called at boot time:
43517 + *
43518 + * nand_spi_er=read_only
43519 + * if read_only specified then do not unlock device
43520 + */
43521 +static int __init nand_spi_er_setup(char *str)
43522 +{
43523 + if (str && (strncasecmp(str, "read_only", 9) == 0)) {
43524 + read_only = 1;
43525 + }
43526 + return 0;
43527 +}
43528 +
43529 +__setup("nand_spi_er=", nand_spi_er_setup);
43530 +#endif
43531 +
43532 +/*
43533 + * nand_spi_er_probe
43534 + * Detect and initialize nand_spi_er device.
43535 + */
43536 +static int __devinit nand_spi_er_probe(struct spi_device *spi)
43537 +{
43538 + uint8_t txbuf[3];
43539 + uint8_t rxbuf[2];
43540 + int i;
43541 + int res;
43542 + size_t bbt_bytes;
43543 + struct nand_spi_er *chip;
43544 + const struct nand_spi_er_device *device;
43545 +
43546 + res = spi_setup(spi);
43547 + if (res) {
43548 + return res;
43549 + }
43550 +
43551 + /*
43552 + * Reset
43553 + */
43554 + for (i = 0; i < 2; i++) {
43555 + txbuf[0] = 0xFF;
43556 + res = spi_write(spi, txbuf, 1);
43557 + if (res) {
43558 + return res;
43559 + }
43560 + udelay(250);
43561 + }
43562 + udelay(1000);
43563 +
43564 + /*
43565 + * Read ID
43566 + */
43567 + txbuf[0] = 0x9F;
43568 + txbuf[1] = 0x00;
43569 + res = spi_write_then_read(spi, txbuf, 2, rxbuf, 2);
43570 + if (res) {
43571 + return res;
43572 + }
43573 +
43574 + device = nand_spi_er_devices;
43575 + for (i = 0; i < ARRAY_SIZE(nand_spi_er_devices); i++) {
43576 + if ((device->id0 == rxbuf[0]) && (device->id1 == rxbuf[1])) {
43577 + break;
43578 + }
43579 + device++;
43580 + }
43581 + if (i == ARRAY_SIZE(nand_spi_er_devices)) {
43582 + return -ENODEV;
43583 + }
43584 +
43585 + /*
43586 + * Initialize our chip structure
43587 + */
43588 + bbt_bytes = DIV_ROUND_UP(device->blocks, BITS_PER_BYTE);
43589 + chip = kzalloc(sizeof(struct nand_spi_er) + bbt_bytes, GFP_KERNEL);
43590 + if (!chip) {
43591 + return -ENOMEM;
43592 + }
43593 + snprintf(chip->name, sizeof(chip->name), "%s.%d.%d", device->name, spi->master->bus_num, spi->chip_select);
43594 +
43595 + chip->spi = spi;
43596 + chip->device = device;
43597 + chip->last_row = NAND_SPI_ER_LAST_ROW_INVALID;
43598 +
43599 + mutex_init(&chip->lock);
43600 +
43601 + chip->mtd.type = MTD_NANDFLASH;
43602 + chip->mtd.flags = MTD_WRITEABLE;
43603 +
43604 + /*
43605 + * #blocks * block size * n blocks
43606 + */
43607 + chip->mtd.size = device->blocks * device->pages_per_block * device->page_size;
43608 + chip->mtd.erasesize = device->erase_size;
43609 +
43610 + /*
43611 + * 1 page, optionally we can support partial write (512)
43612 + */
43613 + chip->mtd.writesize = device->write_size;
43614 + chip->mtd.name = device->name;
43615 + chip->mtd.erase = nand_spi_er_erase;
43616 + chip->mtd.read = nand_spi_er_read;
43617 + chip->mtd.write = nand_spi_er_write;
43618 + chip->mtd.block_isbad = nand_spi_er_isbad;
43619 + chip->mtd.block_markbad = nand_spi_er_markbad;
43620 + chip->mtd.priv = chip;
43621 +
43622 + /*
43623 + * Cache the bad block table
43624 + */
43625 + res = nand_spi_er_read_bbt(chip);
43626 + if (res) {
43627 + kfree(chip);
43628 + return res;
43629 + }
43630 +
43631 + /*
43632 + * Un/lock the chip
43633 + */
43634 + txbuf[0] = 0x1F;
43635 + txbuf[1] = 0xA0;
43636 + if (read_only) {
43637 + txbuf[2] = 0x38;
43638 + } else {
43639 + txbuf[2] = 0x00;
43640 + }
43641 + res = spi_write(spi, txbuf, 3);
43642 + if (res) {
43643 + DEBUG(MTD_DEBUG_LEVEL1, "%s: failed lock operation res=%d\n", chip->name, res);
43644 + mutex_unlock(&chip->lock);
43645 + return res;
43646 + }
43647 +
43648 + spi_set_drvdata(spi, chip);
43649 +
43650 + printk(KERN_INFO "%s: added device %s size: %u KBytes %u bad blocks %s\n", spi->dev.bus_id, chip->mtd.name, DIV_ROUND_UP(chip->mtd.size, 1024), chip->nbb, read_only ? "[read only]" : "");
43651 + return add_mtd_device(&chip->mtd);
43652 +}
43653 +
43654 +/*
43655 + * nand_spi_er_remove
43656 + */
43657 +static int __devexit nand_spi_er_remove(struct spi_device *spi)
43658 +{
43659 + struct nand_spi_er *chip = spi_get_drvdata(spi);
43660 + int status = 0;
43661 +
43662 + DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", spi->dev.bus_id);
43663 + status = del_mtd_device(&chip->mtd);
43664 + if (status == 0)
43665 + kfree(chip);
43666 + return status;
43667 +}
43668 +
43669 +static struct spi_driver nand_spi_er_driver = {
43670 + .driver = {
43671 + .name = "nand-spi-er",
43672 + .bus = &spi_bus_type,
43673 + .owner = THIS_MODULE,
43674 + },
43675 +
43676 + .probe = nand_spi_er_probe,
43677 + .remove = __devexit_p(nand_spi_er_remove),
43678 +
43679 + /* FIXME: investigate suspend and resume... */
43680 +};
43681 +
43682 +/*
43683 + * nand_spi_er_init
43684 + */
43685 +static int __init nand_spi_er_init(void)
43686 +{
43687 + return spi_register_driver(&nand_spi_er_driver);
43688 +}
43689 +module_init(nand_spi_er_init);
43690 +
43691 +/*
43692 + * nand_spi_er_exit
43693 + */
43694 +static void __exit nand_spi_er_exit(void)
43695 +{
43696 + spi_unregister_driver(&nand_spi_er_driver);
43697 +}
43698 +module_exit(nand_spi_er_exit);
43699 +
43700 +
43701 +MODULE_LICENSE("GPL");
43702 +MODULE_AUTHOR("Patrick Tjin");
43703 +MODULE_DESCRIPTION("MTD nand_spi_er driver");
43704 diff -ruN linux-2.6.30.10/drivers/mtd/devices/ubi32-m25p80.c linux-2.6.30.10-ubi/drivers/mtd/devices/ubi32-m25p80.c
43705 --- linux-2.6.30.10/drivers/mtd/devices/ubi32-m25p80.c 1970-01-01 02:00:00.000000000 +0200
43706 +++ linux-2.6.30.10-ubi/drivers/mtd/devices/ubi32-m25p80.c 2009-12-11 11:45:16.000000000 +0200
43707 @@ -0,0 +1,1066 @@
43708 +/*
43709 + * drivers/mtd/devices/ubi32-m25p80.c
43710 + * NOR flash driver, Ubicom processor internal SPI flash interface.
43711 + *
43712 + * This code instantiates the serial flash that contains the
43713 + * original bootcode. The serial flash start at address 0x60000000
43714 + * in both Ubicom32V3 and Ubicom32V4 ISAs.
43715 + *
43716 + * This piece of flash is made to appear as a Memory Technology
43717 + * Device (MTD) with this driver to allow Read/Write/Erase operations.
43718 + *
43719 + * (C) Copyright 2009, Ubicom, Inc.
43720 + *
43721 + * This file is part of the Ubicom32 Linux Kernel Port.
43722 + *
43723 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
43724 + * it and/or modify it under the terms of the GNU General Public License
43725 + * as published by the Free Software Foundation, either version 2 of the
43726 + * License, or (at your option) any later version.
43727 + *
43728 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
43729 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
43730 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
43731 + * the GNU General Public License for more details.
43732 + *
43733 + * You should have received a copy of the GNU General Public License
43734 + * along with the Ubicom32 Linux Kernel Port. If not,
43735 + * see <http://www.gnu.org/licenses/>.
43736 + *
43737 + * Ubicom32 implementation derived from (with many thanks):
43738 + * arch/m68knommu
43739 + * arch/blackfin
43740 + * arch/parisc
43741 + */
43742 +#include <linux/types.h>
43743 +#include <linux/device.h>
43744 +#include <linux/platform_device.h>
43745 +#include <linux/mtd/mtd.h>
43746 +#include <linux/mtd/partitions.h>
43747 +#include <linux/mtd/physmap.h>
43748 +#include <linux/spi/spi.h>
43749 +#include <linux/spi/flash.h>
43750 +
43751 +#include <linux/init.h>
43752 +#include <linux/module.h>
43753 +#include <linux/interrupt.h>
43754 +#include <linux/mutex.h>
43755 +
43756 +#include <asm/ip5000.h>
43757 +#include <asm/devtree.h>
43758 +
43759 +#define UBICOM32_FLASH_BASE 0x60000000
43760 +#define UBICOM32_FLASH_MAX_SIZE 0x01000000
43761 +#define UBICOM32_FLASH_START 0x00000000
43762 +#define UBICOM32_KERNEL_OFFSET 0x00010000 /* The kernel starts after Ubicom
43763 + * .protect section. */
43764 +
43765 +static struct mtd_partition ubicom32_flash_partitions[] = {
43766 + {
43767 + .name = "Bootloader", /* Protected Section
43768 + * Partition */
43769 + .size = 0x10000,
43770 + .offset = UBICOM32_FLASH_START,
43771 +// .mask_flags = MTD_WRITEABLE /* Mark Read-only */
43772 + },
43773 + {
43774 + .name = "Kernel", /* Kernel Partition. */
43775 + .size = 0, /* this will be set up during
43776 + * probe stage. At that time we
43777 + * will know end of linux image
43778 + * in flash. */
43779 + .offset = MTDPART_OFS_APPEND, /* Starts right after Protected
43780 + * section. */
43781 +// .mask_flags = MTD_WRITEABLE /* Mark Read-only */
43782 + },
43783 + {
43784 + .name = "Rest", /* Rest of the flash. */
43785 + .size = 0x200000, /* Use up what remains in the
43786 + * flash. */
43787 + .offset = MTDPART_OFS_NXTBLK, /* Starts right after Protected
43788 + * section. */
43789 + }
43790 +};
43791 +
43792 +static struct flash_platform_data ubicom32_flash_data = {
43793 + .name = "ubicom32_boot_flash",
43794 + .parts = ubicom32_flash_partitions,
43795 + .nr_parts = ARRAY_SIZE(ubicom32_flash_partitions),
43796 +};
43797 +
43798 +static struct resource ubicom32_flash_resource[] = {
43799 + {
43800 + .start = UBICOM32_FLASH_BASE,
43801 + .end = UBICOM32_FLASH_BASE +
43802 + UBICOM32_FLASH_MAX_SIZE - 1,
43803 + .flags = IORESOURCE_MEM,
43804 + },
43805 +};
43806 +
43807 +static struct platform_device ubicom32_flash_device = {
43808 + .name = "ubicom32flashdriver",
43809 + .id = 0, /* Bus number */
43810 + .num_resources = ARRAY_SIZE(ubicom32_flash_resource),
43811 + .resource = ubicom32_flash_resource,
43812 + .dev = {
43813 + .platform_data = &ubicom32_flash_data,
43814 + },
43815 +};
43816 +
43817 +static struct platform_device *ubicom32_flash_devices[] = {
43818 + &ubicom32_flash_device,
43819 +};
43820 +
43821 +static int __init ubicom32_flash_init(void)
43822 +{
43823 + printk(KERN_INFO "%s(): registering device resources\n",
43824 + __FUNCTION__);
43825 + platform_add_devices(ubicom32_flash_devices,
43826 + ARRAY_SIZE(ubicom32_flash_devices));
43827 + return 0;
43828 +}
43829 +
43830 +arch_initcall(ubicom32_flash_init);
43831 +
43832 +/*
43833 + * MTD SPI driver for ST M25Pxx (and similar) serial flash chips through
43834 + * Ubicom32 SPI controller.
43835 + *
43836 + * Author: Mike Lavender, mike@steroidmicros.com
43837 + *
43838 + * Copyright (c) 2005, Intec Automation Inc.
43839 + *
43840 + * Some parts are based on lart.c by Abraham Van Der Merwe
43841 + *
43842 + * Cleaned up and generalized based on mtd_dataflash.c
43843 + *
43844 + * This code is free software; you can redistribute it and/or modify
43845 + * it under the terms of the GNU General Public License version 2 as
43846 + * published by the Free Software Foundation.
43847 + *
43848 + */
43849 +
43850 +#define FLASH_PAGESIZE 256
43851 +
43852 +/* Flash opcodes. */
43853 +#define OPCODE_WREN 0x06 /* Write enable */
43854 +#define OPCODE_RDSR 0x05 /* Read status register */
43855 +#define OPCODE_READ 0x03 /* Read data bytes (low frequency) */
43856 +#define OPCODE_FAST_READ 0x0b /* Read data bytes (high frequency) */
43857 +#define OPCODE_PP 0x02 /* Page program (up to 256 bytes) */
43858 +#define OPCODE_BE_4K 0x20 /* Erase 4KiB block */
43859 +#define OPCODE_BE_32K 0x52 /* Erase 32KiB block */
43860 +#define OPCODE_SE 0xd8 /* Sector erase (usually 64KiB) */
43861 +#define OPCODE_RDID 0x9f /* Read JEDEC ID */
43862 +
43863 +/* Status Register bits. */
43864 +#define SR_WIP 1 /* Write in progress */
43865 +#define SR_WEL 2 /* Write enable latch */
43866 +/* meaning of other SR_* bits may differ between vendors */
43867 +#define SR_BP0 4 /* Block protect 0 */
43868 +#define SR_BP1 8 /* Block protect 1 */
43869 +#define SR_BP2 0x10 /* Block protect 2 */
43870 +#define SR_SRWD 0x80 /* SR write protect */
43871 +
43872 +/* Define max times to check status register before we give up. */
43873 +#define MAX_READY_WAIT_COUNT 100000
43874 +
43875 +
43876 +#ifdef CONFIG_MTD_PARTITIONS
43877 +#define mtd_has_partitions() (1)
43878 +#else
43879 +#define mtd_has_partitions() (0)
43880 +#endif
43881 +
43882 +/*
43883 + * Ubicom32 FLASH Command Set
43884 + */
43885 +#define FLASH_FC_INST_CMD 0x00 /* for SPI command only transaction */
43886 +#define FLASH_FC_INST_WR 0x01 /* for SPI write transaction */
43887 +#define FLASH_FC_INST_RD 0x02 /* for SPI read transaction */
43888 +
43889 +#define ALIGN_DOWN(v, a) ((v) & ~((a) - 1))
43890 +#define ALIGN_UP(v, a) (((v) + ((a) - 1)) & ~((a) - 1))
43891 +
43892 +#define FLASH_COMMAND_KICK_OFF(io) \
43893 + asm volatile( \
43894 + " bset "D(IO_INT_CLR)"(%0), #0, #%%bit("D(IO_XFL_INT_DONE)") \n\t" \
43895 + " jmpt.t .+4 \n\t" \
43896 + " bset "D(IO_INT_SET)"(%0), #0, #%%bit("D(IO_XFL_INT_START)") \n\t" \
43897 + : \
43898 + : "a" (io) \
43899 + : "memory", "cc" \
43900 + );
43901 +
43902 +#define FLASH_COMMAND_WAIT_FOR_COMPLETION(io) \
43903 + asm volatile( \
43904 + " btst "D(IO_INT_STATUS)"(%0), #%%bit("D(IO_XFL_INT_DONE)") \n\t" \
43905 + " jmpeq.f .-4 \n\t" \
43906 + : \
43907 + : "a" (io) \
43908 + : "memory", "cc" \
43909 + );
43910 +
43911 +#define FLASH_COMMAND_EXEC(io) \
43912 + FLASH_COMMAND_KICK_OFF(io) \
43913 + FLASH_COMMAND_WAIT_FOR_COMPLETION(io)
43914 +
43915 +
43916 +#define OSC1_FREQ 12000000
43917 +#define TEN_MICRO_SECONDS (OSC1_FREQ * 10 / 1000000)
43918 +
43919 +/*
43920 + * We will have to eventually replace this null definition with the real thing.
43921 + */
43922 +#define WATCHDOG_RESET()
43923 +
43924 +#define EXTFLASH_WRITE_FIFO_SIZE 32
43925 +#define EXTFLASH_WRITE_BLOCK_SIZE EXTFLASH_WRITE_FIFO_SIZE /* limit the size to
43926 + * FIFO capacity, so
43927 + * the thread can be
43928 + * suspended. */
43929 +
43930 +#define JFFS2_FILESYSTEM_SIZE 0x100000
43931 +
43932 +/****************************************************************************/
43933 +
43934 +struct m25p {
43935 + struct platform_device *plt_dev;
43936 + struct mutex lock;
43937 + struct mtd_info mtd;
43938 + unsigned partitioned:1;
43939 + u8 erase_opcode;
43940 + u8 command[4];
43941 +};
43942 +
43943 +static inline struct m25p *mtd_to_m25p(struct mtd_info *mtd)
43944 +{
43945 + return container_of(mtd, struct m25p, mtd);
43946 +}
43947 +
43948 +/****************************************************************************/
43949 +
43950 +/*
43951 + * Internal helper functions
43952 + */
43953 +
43954 +/*
43955 + * Read the status register, returning its value in the location
43956 + * Return the status register value.
43957 + * Returns negative if error occurred.
43958 + */
43959 +static int read_sr(struct m25p *flash)
43960 +{
43961 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
43962 +
43963 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
43964 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) |
43965 + IO_XFL_CTL1_FC_DATA(1);
43966 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_RDSR);
43967 + FLASH_COMMAND_EXEC(io);
43968 +
43969 + return io->status1 & 0xff;
43970 +}
43971 +
43972 +/*
43973 + * mem_flash_io_read_u32()
43974 + */
43975 +static u32 mem_flash_io_read_u32(u32 addr)
43976 +{
43977 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
43978 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
43979 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) |
43980 + IO_XFL_CTL1_FC_DATA(4) | IO_XFL_CTL1_FC_DUMMY(1) |
43981 + IO_XFL_CTL1_FC_ADDR;
43982 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_FAST_READ) |
43983 + IO_XFL_CTL2_FC_ADDR(addr);
43984 + FLASH_COMMAND_EXEC(io);
43985 + return io->status1;
43986 +}
43987 +
43988 +/*
43989 + * mem_flash_read_u8()
43990 + */
43991 +static u8 mem_flash_read_u8(u32 addr)
43992 +{
43993 + u32 tmp_addr = ALIGN_DOWN(addr, 4);
43994 + u32 tmp_data = mem_flash_io_read_u32(tmp_addr);
43995 + u8 *ptr = (u8 *)&tmp_data;
43996 + return ptr[addr & 0x3];
43997 +}
43998 +
43999 +/*
44000 + * mem_flash_read()
44001 + * No need to lock as read is implemented with ireads (same as normal flash
44002 + * execution).
44003 + */
44004 +static void mem_flash_read(u32 addr, void *dst, size_t length)
44005 +{
44006 + /*
44007 + * Range check
44008 + */
44009 + /*
44010 + * Fix source alignment.
44011 + */
44012 + while (addr & 0x03) {
44013 + if (length == 0) {
44014 + return;
44015 + }
44016 + *((u8 *)dst) = mem_flash_read_u8(addr++);
44017 + dst++;
44018 + length--;
44019 + }
44020 +
44021 + while (length >= 4) {
44022 + u32 tmp_data = mem_flash_io_read_u32(addr);
44023 + addr += 4;
44024 + length -= 4;
44025 +
44026 + /*
44027 + * Send the data to the destination.
44028 + */
44029 + memcpy((void *)dst, (void *)&tmp_data, 4);
44030 + dst += 4;
44031 + }
44032 +
44033 + while (length--) {
44034 + *((u8 *)dst) = mem_flash_read_u8(addr++);
44035 + dst++;
44036 + }
44037 +}
44038 +
44039 +/*
44040 + * mem_flash_wait_until_complete()
44041 + */
44042 +static void mem_flash_wait_until_complete(void)
44043 +{
44044 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
44045 +
44046 + do {
44047 + /*
44048 + * Put a delay here to deal with flash programming problem.
44049 + */
44050 + u32 mptval = UBICOM32_IO_TIMER->mptval + TEN_MICRO_SECONDS;
44051 + while (UBICOM32_IO_TIMER->mptval < mptval)
44052 + ;
44053 +
44054 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44055 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) |
44056 + IO_XFL_CTL1_FC_DATA(1);
44057 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_RDSR);
44058 + FLASH_COMMAND_EXEC(io);
44059 + } while (io->status1 & SR_WIP);
44060 +}
44061 +
44062 +/*
44063 + * mem_flash_write_next()
44064 + */
44065 +static size_t mem_flash_write_next(u32 addr, u8 *buf, size_t length)
44066 +{
44067 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
44068 + u32 data_start = addr;
44069 + u32 data_end = addr + length;
44070 + size_t count;
44071 + u32 i, j;
44072 +
44073 + /*
44074 + * Top limit address.
44075 + */
44076 + u32 block_start = ALIGN_DOWN(data_start, 4);
44077 + u32 block_end = block_start + EXTFLASH_WRITE_BLOCK_SIZE;
44078 +
44079 + union {
44080 + u8 byte[EXTFLASH_WRITE_BLOCK_SIZE];
44081 + u32 word[EXTFLASH_WRITE_BLOCK_SIZE / 4];
44082 + } write_buf;
44083 +
44084 + u32 *flash_addr = (u32 *)block_start;
44085 +
44086 + /*
44087 + * The write block must be limited by FLASH internal buffer.
44088 + */
44089 + u32 block_end_align = ALIGN_DOWN(block_end, 256);
44090 + bool write_needed;
44091 +
44092 + block_end = (block_end_align > block_start)
44093 + ? block_end_align : block_end;
44094 + data_end = (data_end <= block_end) ? data_end : block_end;
44095 + block_end = ALIGN_UP(data_end, 4);
44096 + count = data_end - data_start;
44097 +
44098 + /*
44099 + * Transfer data to a buffer.
44100 + */
44101 + for (i = 0; i < (block_end - block_start) / 4; i++) {
44102 + /*
44103 + * The FLASH read can hold D-cache for a long time.
44104 + * Use I/O operation to read FLASH to avoid starving other
44105 + * threads, especially HRT. (Do this for application only)
44106 + */
44107 + write_buf.word[i] = mem_flash_io_read_u32(
44108 + (u32)(&flash_addr[i]));
44109 + }
44110 +
44111 + write_needed = false;
44112 + for (i = 0, j = (data_start - block_start);
44113 + i < (data_end - data_start); i++, j++) {
44114 + write_needed = write_needed || (write_buf.byte[j] != buf[i]);
44115 + write_buf.byte[j] &= buf[i];
44116 + }
44117 +
44118 +
44119 + /*
44120 + * If the data in FLASH is identical to what to be written. Then skip
44121 + * it.
44122 + */
44123 + if (write_needed) {
44124 + /*
44125 + * Write to flash.
44126 + */
44127 + void *tmp __attribute__((unused));
44128 + s32 extra_words;
44129 +
44130 + asm volatile(
44131 + " move.4 %0, %2 \n\t"
44132 + " bset "D(IO_INT_SET)"(%1), #0, #%%bit("D(IO_PORTX_INT_FIFO_TX_RESET)") \n\t"
44133 + " pipe_flush 0 \n\t"
44134 + " .rept "D(EXTFLASH_WRITE_FIFO_SIZE / 4)" \n\t"
44135 + " move.4 "D(IO_TX_FIFO)"(%1), (%0)4++ \n\t"
44136 + " .endr \n\t"
44137 + : "=&a" (tmp)
44138 + : "a" (io), "r" (&write_buf.word[0])
44139 + : "memory", "cc"
44140 + );
44141 +
44142 + /* Lock FLASH for write access. */
44143 + io->ctl0 |= IO_XFL_CTL0_MCB_LOCK;
44144 +
44145 + /* Command: WREN */
44146 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44147 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD);
44148 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_WREN);
44149 + FLASH_COMMAND_EXEC(io);
44150 +
44151 + /* Command: BYTE PROGRAM */
44152 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44153 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_WR) |
44154 + IO_XFL_CTL1_FC_DATA(block_end - block_start) |
44155 + IO_XFL_CTL1_FC_ADDR;
44156 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_PP) |
44157 + IO_XFL_CTL2_FC_ADDR(block_start);
44158 + FLASH_COMMAND_KICK_OFF(io);
44159 +
44160 + extra_words = (s32)(block_end - block_start -
44161 + EXTFLASH_WRITE_FIFO_SIZE) / 4;
44162 + if (extra_words > 0) {
44163 + asm volatile(
44164 + " move.4 %0, %3 \n\t"
44165 + "1: cmpi "D(IO_FIFO_LEVEL)"(%1), #4 \n\t"
44166 + " jmpgt.s.t 1b \n\t"
44167 + " move.4 "D(IO_TX_FIFO)"(%1), (%0)4++ \n\t"
44168 + " add.4 %2, #-1, %2 \n\t"
44169 + " jmpgt.t 1b \n\t"
44170 + : "=&a" (tmp)
44171 + : "a" (io), "d" (extra_words),
44172 + "r" (&write_buf.word[EXTFLASH_WRITE_FIFO_SIZE / 4])
44173 + : "memory", "cc"
44174 + );
44175 + }
44176 + FLASH_COMMAND_WAIT_FOR_COMPLETION(io);
44177 +
44178 + mem_flash_wait_until_complete();
44179 +
44180 +
44181 + /* Unlock FLASH for cache access. */
44182 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
44183 + }
44184 +
44185 + /*
44186 + * Complete.
44187 + */
44188 + return count;
44189 +}
44190 +
44191 +/*
44192 + * mem_flash_write()
44193 + */
44194 +static void mem_flash_write(u32 addr, const void *src, size_t length)
44195 +{
44196 + /*
44197 + * Write data
44198 + */
44199 + u8_t *ptr = (u8_t *)src;
44200 + while (length) {
44201 + size_t count = mem_flash_write_next(addr, ptr, length);
44202 + addr += count;
44203 + ptr += count;
44204 + length -= count;
44205 + }
44206 +}
44207 +
44208 +/*
44209 + * Service routine to read status register until ready, or timeout occurs.
44210 + * Returns non-zero if error.
44211 + */
44212 +static int wait_till_ready(struct m25p *flash)
44213 +{
44214 + int count;
44215 + int sr;
44216 +
44217 + /* one chip guarantees max 5 msec wait here after page writes,
44218 + * but potentially three seconds (!) after page erase.
44219 + */
44220 + for (count = 0; count < MAX_READY_WAIT_COUNT; count++) {
44221 + u32 mptval;
44222 + sr = read_sr(flash);
44223 + if (sr < 0)
44224 + break;
44225 + else if (!(sr & SR_WIP))
44226 + return 0;
44227 +
44228 + /*
44229 + * Put a 10us delay here to deal with flash programming problem.
44230 + */
44231 + mptval = UBICOM32_IO_TIMER->mptval + TEN_MICRO_SECONDS;
44232 + while ((s32)(mptval - UBICOM32_IO_TIMER->mptval) > 0) {
44233 + WATCHDOG_RESET();
44234 + }
44235 + /* REVISIT sometimes sleeping would be best */
44236 + }
44237 +
44238 + return 1;
44239 +}
44240 +
44241 +/*
44242 + * mem_flash_erase_page()
44243 + */
44244 +static void mem_flash_erase_page(u32 addr)
44245 +{
44246 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
44247 +
44248 + /* Lock FLASH for write access. */
44249 + io->ctl0 |= IO_XFL_CTL0_MCB_LOCK;
44250 +
44251 + /* Command: WREN */
44252 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44253 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD);
44254 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_WREN);
44255 + FLASH_COMMAND_EXEC(io);
44256 +
44257 + /* Command: ERASE */
44258 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44259 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD) |
44260 + IO_XFL_CTL1_FC_ADDR;
44261 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_SE) |
44262 + IO_XFL_CTL2_FC_ADDR(addr);
44263 + FLASH_COMMAND_EXEC(io);
44264 +
44265 + mem_flash_wait_until_complete();
44266 +
44267 + /* Unlock FLASH for cache access. */
44268 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
44269 +}
44270 +
44271 +/*
44272 + * mem_flash_erase()
44273 + */
44274 +static u32 mem_flash_erase(u32 addr, u32 length)
44275 +{
44276 + /*
44277 + * Calculate the endaddress to be the first address of the page
44278 + * just beyond this erase section of pages.
44279 + */
44280 + u32 endaddr = addr + length;
44281 +
44282 + /*
44283 + * Erase.
44284 + */
44285 + while (addr < endaddr) {
44286 + u32 test_addr = addr;
44287 + mem_flash_erase_page(addr);
44288 +
44289 + /*
44290 + * Test how much was erased as actual flash page at this address
44291 + * may be smaller than the expected page size.
44292 + */
44293 + while (test_addr < endaddr) {
44294 + /*
44295 + * The FLASH read can hold D-cache for a long time. Use
44296 + * I/O operation to read FLASH to avoid starving other
44297 + * threads, especially HRT. (Do this for application
44298 + * only)
44299 + */
44300 + if (mem_flash_io_read_u32(test_addr) != 0xFFFFFFFF) {
44301 + break;
44302 + }
44303 + test_addr += 4;
44304 + }
44305 + if (test_addr == addr) {
44306 + printk("erase failed at address 0x%x, skipping",
44307 + test_addr);
44308 + test_addr += 4;
44309 + return 1;
44310 + }
44311 + addr = test_addr;
44312 + }
44313 + return 0;
44314 +}
44315 +
44316 +
44317 +/****************************************************************************/
44318 +
44319 +/*
44320 + * MTD implementation
44321 + */
44322 +
44323 +/*
44324 + * Erase an address range on the flash chip. The address range may extend
44325 + * one or more erase sectors. Return an error is there is a problem erasing.
44326 + */
44327 +static int ubicom32_flash_driver_erase(struct mtd_info *mtd,
44328 + struct erase_info *instr)
44329 +{
44330 + struct m25p *flash = mtd_to_m25p(mtd);
44331 + u32 addr, len;
44332 +
44333 + DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %lld\n",
44334 + dev_name(&flash->plt_dev->dev), __FUNCTION__, "at",
44335 + (u32)instr->addr, instr->len);
44336 +
44337 + /* sanity checks */
44338 + if (instr->addr + instr->len > flash->mtd.size)
44339 + return -EINVAL;
44340 + if ((instr->addr % mtd->erasesize) != 0
44341 + || (instr->len % mtd->erasesize) != 0) {
44342 + return -EINVAL;
44343 + }
44344 +
44345 + addr = instr->addr + UBICOM32_FLASH_BASE;
44346 + len = instr->len;
44347 +
44348 + mutex_lock(&flash->lock);
44349 +
44350 + /* REVISIT in some cases we could speed up erasing large regions
44351 + * by using OPCODE_SE instead of OPCODE_BE_4K
44352 + */
44353 +
44354 + /* now erase those sectors */
44355 + if (mem_flash_erase(addr, len)) {
44356 + instr->state = MTD_ERASE_FAILED;
44357 + mutex_unlock(&flash->lock);
44358 + return -EIO;
44359 + }
44360 +
44361 + mutex_unlock(&flash->lock);
44362 + instr->state = MTD_ERASE_DONE;
44363 + mtd_erase_callback(instr);
44364 + return 0;
44365 +}
44366 +
44367 +/*
44368 + * Read an address range from the flash chip. The address range
44369 + * may be any size provided it is within the physical boundaries.
44370 + */
44371 +static int ubicom32_flash_driver_read(struct mtd_info *mtd, loff_t from,
44372 + size_t len, size_t *retlen, u_char *buf)
44373 +{
44374 + struct m25p *flash = mtd_to_m25p(mtd);
44375 + u32 base_addr = UBICOM32_FLASH_BASE + from;
44376 +
44377 + DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %d\n",
44378 + dev_name(&flash->plt_dev->dev), __FUNCTION__, "from",
44379 + (u32)from, len);
44380 +
44381 + /* sanity checks */
44382 + if (!len)
44383 + return 0;
44384 +
44385 + if (from + len > flash->mtd.size)
44386 + return -EINVAL;
44387 +
44388 + /* Byte count starts at zero. */
44389 + if (retlen)
44390 + *retlen = 0;
44391 +
44392 + mutex_lock(&flash->lock);
44393 +
44394 + /* Wait till previous write/erase is done. */
44395 + if (wait_till_ready(flash)) {
44396 + /* REVISIT status return?? */
44397 + mutex_unlock(&flash->lock);
44398 + return 1;
44399 + }
44400 +
44401 + mem_flash_read(base_addr, (void *)buf, len);
44402 +
44403 + if (retlen)
44404 + *retlen = len;
44405 +
44406 + mutex_unlock(&flash->lock);
44407 +
44408 + return 0;
44409 +}
44410 +
44411 +/*
44412 + * Write an address range to the flash chip. Data must be written in
44413 + * FLASH_PAGESIZE chunks. The address range may be any size provided
44414 + * it is within the physical boundaries.
44415 + */
44416 +static int ubicom32_flash_driver_write(struct mtd_info *mtd, loff_t to,
44417 + size_t len, size_t *retlen,
44418 + const u_char *buf)
44419 +{
44420 + struct m25p *flash = mtd_to_m25p(mtd);
44421 + u32 base_addr = UBICOM32_FLASH_BASE + to;
44422 + DEBUG(MTD_DEBUG_LEVEL2, "%s: %s %s 0x%08x, len %d\n",
44423 + dev_name(&flash->plt_dev->dev), __FUNCTION__, "to",
44424 + (u32)to, len);
44425 +
44426 + if (retlen)
44427 + *retlen = 0;
44428 +
44429 + /* sanity checks */
44430 + if (!len)
44431 + return 0;
44432 +
44433 + if (to + len > flash->mtd.size)
44434 + return -EINVAL;
44435 +
44436 + mutex_lock(&flash->lock);
44437 +
44438 + mem_flash_write(base_addr, (void *) buf, len);
44439 +
44440 + /* Wait until finished previous write command. */
44441 + if (wait_till_ready(flash)) {
44442 + mutex_unlock(&flash->lock);
44443 + return 1;
44444 + }
44445 +
44446 + if (retlen)
44447 + *retlen = len;
44448 +
44449 + mutex_unlock(&flash->lock);
44450 + return 0;
44451 +}
44452 +
44453 +
44454 +/****************************************************************************/
44455 +
44456 +/*
44457 + * SPI device driver setup and teardown
44458 + */
44459 +
44460 +struct flash_info {
44461 + char *name;
44462 +
44463 + /* JEDEC id zero means "no ID" (most older chips); otherwise it has
44464 + * a high byte of zero plus three data bytes: the manufacturer id,
44465 + * then a two byte device id.
44466 + */
44467 + u32 jedec_id;
44468 +
44469 + /* The size listed here is what works with OPCODE_SE, which isn't
44470 + * necessarily called a "sector" by the vendor.
44471 + */
44472 + unsigned sector_size;
44473 + u16 n_sectors;
44474 +
44475 + u16 flags;
44476 +#define SECT_4K 0x01 /* OPCODE_BE_4K works uniformly */
44477 +};
44478 +
44479 +
44480 +/* NOTE: double check command sets and memory organization when you add
44481 + * more flash chips. This current list focusses on newer chips, which
44482 + * have been converging on command sets which including JEDEC ID.
44483 + */
44484 +static struct flash_info __devinitdata m25p_data[] = {
44485 +
44486 + /* Atmel -- some are (confusingly) marketed as "DataFlash" */
44487 + { "at25fs010", 0x1f6601, 32 * 1024, 4, SECT_4K, },
44488 + { "at25fs040", 0x1f6604, 64 * 1024, 8, SECT_4K, },
44489 +
44490 + { "at25df041a", 0x1f4401, 64 * 1024, 8, SECT_4K, },
44491 +
44492 + { "at26f004", 0x1f0400, 64 * 1024, 8, SECT_4K, },
44493 + { "at26df081a", 0x1f4501, 64 * 1024, 16, SECT_4K, },
44494 + { "at26df161a", 0x1f4601, 64 * 1024, 32, SECT_4K, },
44495 + { "at26df321", 0x1f4701, 64 * 1024, 64, SECT_4K, },
44496 +
44497 + /* Spansion -- single (large) sector size only, at least
44498 + * for the chips listed here (without boot sectors).
44499 + */
44500 + { "s25sl004a", 0x010212, 64 * 1024, 8, },
44501 + { "s25sl008a", 0x010213, 64 * 1024, 16, },
44502 + { "s25sl016a", 0x010214, 64 * 1024, 32, },
44503 + { "s25sl032a", 0x010215, 64 * 1024, 64, },
44504 + { "s25sl064a", 0x010216, 64 * 1024, 128, },
44505 +
44506 + /* SST -- large erase sizes are "overlays", "sectors" are 4K */
44507 + { "sst25vf040b", 0xbf258d, 64 * 1024, 8, SECT_4K, },
44508 + { "sst25vf080b", 0xbf258e, 64 * 1024, 16, SECT_4K, },
44509 + { "sst25vf016b", 0xbf2541, 64 * 1024, 32, SECT_4K, },
44510 + { "sst25vf032b", 0xbf254a, 64 * 1024, 64, SECT_4K, },
44511 +
44512 + /* ST Microelectronics -- newer production may have feature updates */
44513 + { "m25p05", 0x202010, 32 * 1024, 2, },
44514 + { "m25p10", 0x202011, 32 * 1024, 4, },
44515 + { "m25p20", 0x202012, 64 * 1024, 4, },
44516 + { "m25p40", 0x202013, 64 * 1024, 8, },
44517 + { "m25p80", 0, 64 * 1024, 16, },
44518 + { "m25p16", 0x202015, 64 * 1024, 32, },
44519 + { "m25p32", 0x202016, 64 * 1024, 64, },
44520 + { "m25p64", 0x202017, 64 * 1024, 128, },
44521 + { "m25p128", 0x202018, 256 * 1024, 64, },
44522 +
44523 + { "m45pe80", 0x204014, 64 * 1024, 16, },
44524 + { "m45pe16", 0x204015, 64 * 1024, 32, },
44525 +
44526 + { "m25pe80", 0x208014, 64 * 1024, 16, },
44527 + { "m25pe16", 0x208015, 64 * 1024, 32, SECT_4K, },
44528 +
44529 + /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
44530 + { "w25x10", 0xef3011, 64 * 1024, 2, SECT_4K, },
44531 + { "w25x20", 0xef3012, 64 * 1024, 4, SECT_4K, },
44532 + { "w25x40", 0xef3013, 64 * 1024, 8, SECT_4K, },
44533 + { "w25x80", 0xef3014, 64 * 1024, 16, SECT_4K, },
44534 + { "w25x16", 0xef3015, 64 * 1024, 32, SECT_4K, },
44535 + { "w25x32", 0xef3016, 64 * 1024, 64, SECT_4K, },
44536 + { "w25x64", 0xef3017, 64 * 1024, 128, SECT_4K, },
44537 +
44538 + /* Macronix -- mx25lxxx */
44539 + { "mx25l32", 0xc22016, 64 * 1024, 64, },
44540 + { "mx25l64", 0xc22017, 64 * 1024, 128, },
44541 + { "mx25l128", 0xc22018, 64 * 1024, 256, },
44542 +
44543 +};
44544 +
44545 +struct flash_info *__devinit jedec_probe(struct platform_device *spi)
44546 +{
44547 + int tmp;
44548 + u32 jedec;
44549 + struct flash_info *info;
44550 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)RA;
44551 +
44552 + /*
44553 + * Setup and run RDID command on the flash.
44554 + */
44555 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44556 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) |
44557 + IO_XFL_CTL1_FC_DATA(3);
44558 + io->ctl2 = IO_XFL_CTL2_FC_CMD(OPCODE_RDID);
44559 + FLASH_COMMAND_EXEC(io);
44560 +
44561 + jedec = io->status1 & 0x00ffffff;
44562 +
44563 + for (tmp = 0, info = m25p_data;
44564 + tmp < ARRAY_SIZE(m25p_data);
44565 + tmp++, info++) {
44566 + if (info->jedec_id == jedec)
44567 + return info;
44568 + }
44569 + dev_err(&spi->dev, "unrecognized JEDEC id %06x\n", jedec);
44570 + return NULL;
44571 +}
44572 +
44573 +
44574 +/*
44575 + * board specific setup should have ensured the SPI clock used here
44576 + * matches what the READ command supports, at least until this driver
44577 + * understands FAST_READ (for clocks over 25 MHz).
44578 + */
44579 +static int __devinit ubicom32_flash_probe(struct platform_device *spi)
44580 +{
44581 + struct flash_platform_data *data;
44582 + struct m25p *flash;
44583 + struct flash_info *info;
44584 + unsigned i;
44585 +
44586 + /* Platform data helps sort out which chip type we have, as
44587 + * well as how this board partitions it. If we don't have
44588 + * a chip ID, try the JEDEC id commands; they'll work for most
44589 + * newer chips, even if we don't recognize the particular chip.
44590 + */
44591 + data = spi->dev.platform_data;
44592 + if (data && data->type) {
44593 + for (i = 0, info = m25p_data;
44594 + i < ARRAY_SIZE(m25p_data);
44595 + i++, info++) {
44596 + if (strcmp(data->type, info->name) == 0)
44597 + break;
44598 + }
44599 +
44600 + /* unrecognized chip? */
44601 + if (i == ARRAY_SIZE(m25p_data)) {
44602 + DEBUG(MTD_DEBUG_LEVEL0, "%s: unrecognized id %s\n",
44603 + dev_name(&spi->dev), data->type);
44604 + info = NULL;
44605 +
44606 + /* recognized; is that chip really what's there? */
44607 + } else if (info->jedec_id) {
44608 + struct flash_info *chip = jedec_probe(spi);
44609 +
44610 + if (!chip || chip != info) {
44611 + dev_warn(&spi->dev, "found %s, expected %s\n",
44612 + chip ? chip->name : "UNKNOWN",
44613 + info->name);
44614 + info = NULL;
44615 + }
44616 + }
44617 + } else
44618 + info = jedec_probe(spi);
44619 +
44620 + if (!info)
44621 + return -ENODEV;
44622 +
44623 + flash = kzalloc(sizeof *flash, GFP_KERNEL);
44624 + if (!flash)
44625 + return -ENOMEM;
44626 +
44627 + flash->plt_dev = spi;
44628 + mutex_init(&flash->lock);
44629 + dev_set_drvdata(&spi->dev, flash);
44630 +
44631 + if (data && data->name)
44632 + flash->mtd.name = data->name;
44633 + else
44634 + flash->mtd.name = dev_name(&spi->dev);
44635 +
44636 + flash->mtd.type = MTD_NORFLASH;
44637 + flash->mtd.writesize = 1;
44638 + flash->mtd.flags = MTD_CAP_NORFLASH;
44639 + flash->mtd.size = info->sector_size * info->n_sectors;
44640 + flash->mtd.erase = ubicom32_flash_driver_erase;
44641 + flash->mtd.read = ubicom32_flash_driver_read;
44642 + flash->mtd.write = ubicom32_flash_driver_write;
44643 +
44644 + /* prefer "small sector" erase if possible */
44645 + /*
44646 + * The Ubicom erase code does not use the opcode for smaller sectors,
44647 + * so disable that functionality and keep erasesize == sector_size
44648 + * so that the test in ubicom32_flash_driver_erase works properly.
44649 + *
44650 + * This was: `if (info->flags & SECT_4K) {' instead of `if (0) {'
44651 + */
44652 + if (0) {
44653 + flash->erase_opcode = OPCODE_BE_4K;
44654 + flash->mtd.erasesize = 4096;
44655 + } else {
44656 + flash->erase_opcode = OPCODE_SE;
44657 + flash->mtd.erasesize = info->sector_size;
44658 + }
44659 +
44660 + dev_info(&spi->dev, "%s (%lld Kbytes)\n", info->name,
44661 + flash->mtd.size / 1024);
44662 +
44663 + DEBUG(MTD_DEBUG_LEVEL2,
44664 + "mtd .name = %s, .size = 0x%.8llx (%lluMiB) "
44665 + ".erasesize = 0x%.8x (%uKiB) .numeraseregions = %d\n",
44666 + flash->mtd.name,
44667 + flash->mtd.size, flash->mtd.size / (1024*1024),
44668 + flash->mtd.erasesize, flash->mtd.erasesize / 1024,
44669 + flash->mtd.numeraseregions);
44670 +
44671 + if (flash->mtd.numeraseregions)
44672 + for (i = 0; i < flash->mtd.numeraseregions; i++)
44673 + DEBUG(MTD_DEBUG_LEVEL2,
44674 + "mtd.eraseregions[%d] = { .offset = 0x%.8llx, "
44675 + ".erasesize = 0x%.8x (%uKiB), "
44676 + ".numblocks = %d }\n",
44677 + i, flash->mtd.eraseregions[i].offset,
44678 + flash->mtd.eraseregions[i].erasesize,
44679 + flash->mtd.eraseregions[i].erasesize / 1024,
44680 + flash->mtd.eraseregions[i].numblocks);
44681 +
44682 +
44683 + /* partitions should match sector boundaries; and it may be good to
44684 + * use readonly partitions for writeprotected sectors (BP2..BP0).
44685 + */
44686 + if (mtd_has_partitions()) {
44687 + struct mtd_partition *parts = NULL;
44688 + int nr_parts = 0;
44689 +
44690 +#ifdef CONFIG_MTD_CMDLINE_PARTS
44691 + static const char *part_probes[] = { "cmdlinepart", NULL, };
44692 +
44693 + nr_parts = parse_mtd_partitions(&flash->mtd,
44694 + part_probes, &parts, 0);
44695 +#endif
44696 +
44697 + if (nr_parts <= 0 && data && data->parts) {
44698 + parts = data->parts;
44699 + nr_parts = data->nr_parts;
44700 + if (nr_parts >= 2) {
44701 + /*
44702 + * Set last partition size to be 1M.
44703 + */
44704 + parts[1].size = flash->mtd.size -
44705 + parts[0].size - JFFS2_FILESYSTEM_SIZE;
44706 + parts[2].size = JFFS2_FILESYSTEM_SIZE;
44707 + }
44708 + }
44709 +
44710 + if (nr_parts > 0) {
44711 + for (i = 0; i < nr_parts; i++) {
44712 + DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
44713 + "{.name = %s, .offset = 0x%.8llx, "
44714 + ".size = 0x%.8llx (%lluKiB) }\n",
44715 + i, parts[i].name,
44716 + parts[i].offset,
44717 + parts[i].size,
44718 + parts[i].size / 1024);
44719 + }
44720 + flash->partitioned = 1;
44721 + return add_mtd_partitions(&flash->mtd, parts, nr_parts);
44722 + }
44723 + } else if (data->nr_parts)
44724 + dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
44725 + data->nr_parts, data->name);
44726 +
44727 + return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
44728 +}
44729 +
44730 +
44731 +static int __devexit ubicom32_flash_remove(struct spi_device *spi)
44732 +{
44733 + struct m25p *flash = dev_get_drvdata(&spi->dev);
44734 + int status;
44735 +
44736 + /* Clean up MTD stuff. */
44737 + if (mtd_has_partitions() && flash->partitioned)
44738 + status = del_mtd_partitions(&flash->mtd);
44739 + else
44740 + status = del_mtd_device(&flash->mtd);
44741 + if (status == 0)
44742 + kfree(flash);
44743 + return 0;
44744 +}
44745 +
44746 +static struct platform_driver ubicom32_flash_driver = {
44747 + .driver = {
44748 + .name = "ubicom32flashdriver",
44749 + .bus = &platform_bus_type,
44750 + .owner = THIS_MODULE,
44751 + },
44752 + .probe = ubicom32_flash_probe,
44753 + .remove = NULL,
44754 +};
44755 +
44756 +static int ubicom32_flash_driver_init(void)
44757 +{
44758 + return platform_driver_register(&ubicom32_flash_driver);
44759 +}
44760 +
44761 +
44762 +static void ubicom32_flash_driver_exit(void)
44763 +{
44764 + platform_driver_unregister(&ubicom32_flash_driver);
44765 +}
44766 +
44767 +
44768 +module_init(ubicom32_flash_driver_init);
44769 +module_exit(ubicom32_flash_driver_exit);
44770 +
44771 +MODULE_LICENSE("GPL");
44772 +MODULE_AUTHOR("Mike Lavender");
44773 +MODULE_DESCRIPTION("Ubicom32 MTD SPI driver for ST M25Pxx flash chips");
44774 diff -ruN linux-2.6.30.10/drivers/mtd/devices/ubi32-nand-spi-er.c linux-2.6.30.10-ubi/drivers/mtd/devices/ubi32-nand-spi-er.c
44775 --- linux-2.6.30.10/drivers/mtd/devices/ubi32-nand-spi-er.c 1970-01-01 02:00:00.000000000 +0200
44776 +++ linux-2.6.30.10-ubi/drivers/mtd/devices/ubi32-nand-spi-er.c 2009-12-11 11:45:16.000000000 +0200
44777 @@ -0,0 +1,1188 @@
44778 +/*
44779 + * Micron SPI-ER NAND Flash Memory
44780 + * This code uses the built in Ubicom flash controller
44781 + *
44782 + * (C) Copyright 2009, Ubicom, Inc.
44783 + *
44784 + * This file is part of the Ubicom32 Linux Kernel Port.
44785 + *
44786 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
44787 + * it and/or modify it under the terms of the GNU General Public License
44788 + * as published by the Free Software Foundation, either version 2 of the
44789 + * License, or (at your option) any later version.
44790 + *
44791 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
44792 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
44793 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
44794 + * the GNU General Public License for more details.
44795 + *
44796 + * You should have received a copy of the GNU General Public License
44797 + * along with the Ubicom32 Linux Kernel Port. If not,
44798 + * see <http://www.gnu.org/licenses/>.
44799 +*/
44800 +#include <linux/module.h>
44801 +#include <linux/init.h>
44802 +#include <linux/slab.h>
44803 +#include <linux/delay.h>
44804 +#include <linux/device.h>
44805 +#include <linux/platform_device.h>
44806 +#include <linux/mutex.h>
44807 +#include <linux/err.h>
44808 +
44809 +#include <linux/mtd/mtd.h>
44810 +#include <linux/mtd/partitions.h>
44811 +
44812 +#define DRIVER_NAME "ubi32-nand-spi-er"
44813 +#define UBI32_NAND_SPI_ER_BLOCK_FROM_ROW(row) (row >> 6)
44814 +
44815 +#define UBI32_NAND_SPI_ER_STATUS_P_FAIL (1 << 3)
44816 +#define UBI32_NAND_SPI_ER_STATUS_E_FAIL (1 << 2)
44817 +#define UBI32_NAND_SPI_ER_STATUS_OIP (1 << 0)
44818 +
44819 +#define UBI32_NAND_SPI_ER_LAST_ROW_INVALID 0xFFFFFFFF
44820 +#define UBI32_NAND_SPI_ER_BAD_BLOCK_MARK_OFFSET 0x08
44821 +
44822 +struct ubi32_nand_spi_er_device {
44823 + const char *name;
44824 +
44825 + uint16_t id;
44826 +
44827 + unsigned int blocks;
44828 + unsigned int pages_per_block;
44829 + unsigned int page_size;
44830 + unsigned int write_size;
44831 + unsigned int erase_size;
44832 +};
44833 +
44834 +struct ubi32_nand_spi_er {
44835 + char name[24];
44836 +
44837 + const struct ubi32_nand_spi_er_device *device;
44838 +
44839 + struct mutex lock;
44840 + struct platform_device *pdev;
44841 +
44842 + struct mtd_info mtd;
44843 +
44844 + unsigned int last_row; /* the last row we fetched */
44845 +
44846 + /*
44847 + * Bad block table (MUST be last in strcuture)
44848 + */
44849 + unsigned long nbb;
44850 + unsigned long bbt[0];
44851 +};
44852 +
44853 +/*
44854 + * Chip supports a write_size of 512, but we cannot do partial
44855 + * page with command 0x84.
44856 + *
44857 + * We need to use command 0x84 because we cannot fill the FIFO fast
44858 + * enough to transfer the whole 512 bytes at a time. (maybe through
44859 + * OCM?)
44860 + */
44861 +const struct ubi32_nand_spi_er_device ubi32_nand_spi_er_devices[] = {
44862 + {
44863 + name: "MT29F1G01ZDC",
44864 + id: 0x2C12,
44865 + blocks: 1024,
44866 + pages_per_block: 64,
44867 + page_size: 2048,
44868 + write_size: 2048,
44869 + erase_size: 64 * 2048,
44870 + },
44871 + {
44872 + name: "MT29F1G01ZDC",
44873 + id: 0x2C13,
44874 + blocks: 1024,
44875 + pages_per_block: 64,
44876 + page_size: 2048,
44877 + write_size: 2048,
44878 + erase_size: 64 * 2048,
44879 + },
44880 +};
44881 +
44882 +static int read_only = 0;
44883 +module_param(read_only, int, 0);
44884 +MODULE_PARM_DESC(read_only, "Leave device locked");
44885 +
44886 +/*
44887 + * Ubicom32 FLASH Command Set
44888 + */
44889 +#define FLASH_PORT RA
44890 +
44891 +#define FLASH_FC_INST_CMD 0x00 /* for SPI command only transaction */
44892 +#define FLASH_FC_INST_WR 0x01 /* for SPI write transaction */
44893 +#define FLASH_FC_INST_RD 0x02 /* for SPI read transaction */
44894 +
44895 +#define FLASH_COMMAND_KICK_OFF(io) \
44896 + asm volatile( \
44897 + " bset "D(IO_INT_CLR)"(%0), #0, #%%bit("D(IO_XFL_INT_DONE)") \n\t" \
44898 + " jmpt.t .+4 \n\t" \
44899 + " bset "D(IO_INT_SET)"(%0), #0, #%%bit("D(IO_XFL_INT_START)") \n\t" \
44900 + : \
44901 + : "a" (io) \
44902 + : "cc" \
44903 + );
44904 +
44905 +#define FLASH_COMMAND_WAIT_FOR_COMPLETION(io) \
44906 + asm volatile( \
44907 + " btst "D(IO_INT_STATUS)"(%0), #%%bit("D(IO_XFL_INT_DONE)") \n\t" \
44908 + " jmpeq.f .-4 \n\t" \
44909 + : \
44910 + : "a" (io) \
44911 + : "cc" \
44912 + );
44913 +
44914 +#define FLASH_COMMAND_EXEC(io) \
44915 + FLASH_COMMAND_KICK_OFF(io) \
44916 + FLASH_COMMAND_WAIT_FOR_COMPLETION(io)
44917 +
44918 +/*
44919 + * ubi32_nand_spi_er_get_feature
44920 + * Get Feature register
44921 + */
44922 +static uint8_t ubi32_nand_spi_er_get_feature(uint32_t reg)
44923 +{
44924 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
44925 +
44926 + /*
44927 + * Note that this will produce the sequence:
44928 + * SI [0F][REG][00][00]
44929 + * SO ---------[SR][SR][SR]
44930 + * Since the flash controller can only output 24 bits of address, this is
44931 + * ok for this command since the data will just repeat as long as the CS
44932 + * is asserted and the clock is running.
44933 + */
44934 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44935 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) | IO_XFL_CTL1_FC_DATA(1) |
44936 + IO_XFL_CTL1_FC_ADDR;
44937 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x0F) | IO_XFL_CTL2_FC_ADDR(reg << 16);
44938 + FLASH_COMMAND_EXEC(io);
44939 +
44940 + return io->status1 & 0xFF;
44941 +}
44942 +
44943 +/*
44944 + * ubi32_nand_spi_er_write_buf
44945 + * writes a buffer to the bus
44946 + *
44947 + * Writes 511 + 1 bytes to the bus, we have to stuff one data byte into the address.
44948 + */
44949 +static void ubi32_nand_spi_er_write_buf(const uint8_t *buf, uint32_t col)
44950 +{
44951 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
44952 + uint32_t tmp;
44953 +
44954 + asm volatile (
44955 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_PORTX_INT_FIFO_TX_RESET)") \n\t"
44956 + " pipe_flush 0 \n\t"
44957 + :
44958 + : [port] "a" (FLASH_PORT)
44959 + : "cc"
44960 + );
44961 +
44962 + /*
44963 + * Write the data into the cache
44964 + */
44965 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
44966 +#ifdef SUPPORT_512_FIFO
44967 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_WR) | IO_XFL_CTL1_FC_DATA(511) |
44968 +#endif
44969 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_WR) | IO_XFL_CTL1_FC_DATA(31) |
44970 + IO_XFL_CTL1_FC_ADDR;
44971 +
44972 + /*
44973 + * Construct the address with the first byte of data
44974 + */
44975 + tmp = (col << 8) | *buf++;
44976 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x84) | IO_XFL_CTL2_FC_ADDR(tmp);
44977 +
44978 + asm volatile (
44979 +
44980 + /*
44981 + * Move 32 bytes
44982 + *
44983 + * The first word needs to be [11][22][33][33] to work around a flash
44984 + * controller bug.
44985 + */
44986 + " move.2 %[tmp], (%[data])2++ \n\t"
44987 + " shmrg.1 %[tmp], (%[data]), %[tmp] \n\t"
44988 + " shmrg.1 %[tmp], (%[data])1++, %[tmp] \n\t"
44989 + " move.4 "D(IO_TX_FIFO)"(%[port]), %[tmp] \n\t"
44990 +
44991 + /*
44992 + * We're aligned again!
44993 + */
44994 + " .rept 7 \n\t"
44995 + " move.4 "D(IO_TX_FIFO)"(%[port]), (%[data])4++ \n\t"
44996 + " .endr \n\t"
44997 +
44998 + /*
44999 + * Kick off the flash command
45000 + */
45001 + " bset "D(IO_INT_CLR)"(%[port]), #0, #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45002 + " jmpt.t .+4 \n\t"
45003 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_XFL_INT_START)") \n\t"
45004 +
45005 +#ifdef SUPPORT_512_FIFO
45006 + /*
45007 + * Fill the remaining 120 words as space becomes available
45008 + */
45009 + "1: \n\t"
45010 + " cmpi "D(IO_FIFO_LEVEL)"(%[port]), #4 \n\t"
45011 + " jmpgt.s.t 1b \n\t"
45012 + " move.4 "D(IO_TX_FIFO)"(%[port]), (%[data])4++ \n\t"
45013 + " move.4 "D(IO_TX_FIFO)"(%[port]), (%[data])4++ \n\t"
45014 + " move.4 "D(IO_TX_FIFO)"(%[port]), (%[data])4++ \n\t"
45015 + " move.4 "D(IO_TX_FIFO)"(%[port]), (%[data])4++ \n\t"
45016 + " add.4 %[cnt], #-4, %[cnt] \n\t"
45017 + " jmpgt.t 1b \n\t"
45018 +#endif
45019 + /*
45020 + * Wait for the transaction to finish
45021 + */
45022 + " btst "D(IO_INT_STATUS)"(%[port]), #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45023 + " jmpeq.f .-4 \n\t"
45024 +
45025 + : [tmp] "=&d" (tmp),
45026 + [data] "+&a" (buf)
45027 + : [column] "d" (col),
45028 + [port] "a" (FLASH_PORT),
45029 + [cnt] "d" (120) // see above comment
45030 + : "cc"
45031 + );
45032 +}
45033 +
45034 +/*
45035 + * ubi32_nand_spi_er_send_rd_addr
45036 + * perform FC_RD: CMD + address
45037 + */
45038 +static void ubi32_nand_spi_er_send_rd_addr(uint8_t command, uint32_t address)
45039 +{
45040 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45041 +
45042 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45043 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) | IO_XFL_CTL1_FC_DATA(4) |
45044 + IO_XFL_CTL1_FC_ADDR;
45045 + io->ctl2 = IO_XFL_CTL2_FC_CMD(command) | IO_XFL_CTL2_FC_ADDR(address);
45046 + FLASH_COMMAND_EXEC(io);
45047 +}
45048 +
45049 +/*
45050 + * ubi32_nand_spi_er_send_cmd_addr
45051 + * perform FC_(xxx): CMD + address
45052 + */
45053 +static void ubi32_nand_spi_er_send_cmd_addr(uint8_t command, uint32_t address)
45054 +{
45055 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45056 +
45057 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45058 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD) | IO_XFL_CTL1_FC_ADDR;
45059 + io->ctl2 = IO_XFL_CTL2_FC_CMD(command) | IO_XFL_CTL2_FC_ADDR(address);
45060 + FLASH_COMMAND_EXEC(io);
45061 +}
45062 +
45063 +/*
45064 + * ubi32_nand_spi_er_write_disable
45065 + * clear the write enable bit
45066 + */
45067 +static void ubi32_nand_spi_er_write_disable(void)
45068 +{
45069 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45070 +
45071 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45072 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD);
45073 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x04);
45074 + FLASH_COMMAND_EXEC(io);
45075 +}
45076 +
45077 +/*
45078 + * ubi32_nand_spi_er_write_enable
45079 + * set the write enable bit
45080 + */
45081 +static void ubi32_nand_spi_er_write_enable(void)
45082 +{
45083 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45084 +
45085 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45086 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD);
45087 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x06);
45088 + FLASH_COMMAND_EXEC(io);
45089 +}
45090 +
45091 +/*
45092 + * ubi32_nand_spi_er_busywait
45093 + * Wait until the chip is not busy
45094 + */
45095 +static uint8_t ubi32_nand_spi_er_busywait(void)
45096 +{
45097 + int i;
45098 + uint8_t data;
45099 +
45100 + /*
45101 + * tRD is 100us, so don't delay too long, however, tERS is
45102 + * 10ms so you'd better loop enough.
45103 + */
45104 + for (i = 0; i < 200; i++) {
45105 + data = ubi32_nand_spi_er_get_feature(0xC0);
45106 + if (!(data & UBI32_NAND_SPI_ER_STATUS_OIP)) {
45107 + break;
45108 + }
45109 +
45110 + udelay(50);
45111 + }
45112 +
45113 + return data;
45114 +}
45115 +
45116 +/*
45117 + * ubi32_nand_spi_er_erase
45118 + * Erase a block, parameters must be block aligned
45119 + */
45120 +static int ubi32_nand_spi_er_erase(struct mtd_info *mtd, struct erase_info *instr)
45121 +{
45122 + struct ubi32_nand_spi_er *chip = mtd->priv;
45123 + int res;
45124 +
45125 + DEBUG(MTD_DEBUG_LEVEL3, "%s: erase addr:%x len:%x\n", chip->name, instr->addr, instr->len);
45126 +
45127 + if ((instr->addr + instr->len) > mtd->size) {
45128 + return -EINVAL;
45129 + }
45130 +
45131 + if (instr->addr & (chip->device->erase_size - 1)) {
45132 + DEBUG(MTD_DEBUG_LEVEL1, "%s: erase address is not aligned %x\n", chip->name, instr->addr);
45133 + return -EINVAL;
45134 + }
45135 +
45136 + if (instr->len & (chip->device->erase_size - 1)) {
45137 + DEBUG(MTD_DEBUG_LEVEL1, "%s: erase len is not aligned %x\n", chip->name, instr->len);
45138 + return -EINVAL;
45139 + }
45140 +
45141 + mutex_lock(&chip->lock);
45142 + chip->last_row = UBI32_NAND_SPI_ER_LAST_ROW_INVALID;
45143 +
45144 + while (instr->len) {
45145 + uint32_t block = instr->addr >> 17;
45146 + uint32_t row = block << 6;
45147 + uint8_t stat;
45148 + DEBUG(MTD_DEBUG_LEVEL3, "%s: block erase row:%x block:%x addr:%x rem:%x\n", chip->name, row, block, instr->addr, instr->len);
45149 +
45150 + /*
45151 + * Test for bad block
45152 + */
45153 + if (test_bit(block, chip->bbt)) {
45154 + instr->fail_addr = block << 17;
45155 + instr->state = MTD_ERASE_FAILED;
45156 + res = -EBADMSG;
45157 + goto done;
45158 + }
45159 +
45160 + ubi32_nand_spi_er_write_enable();
45161 +
45162 + /*
45163 + * Block erase
45164 + */
45165 + ubi32_nand_spi_er_send_cmd_addr(0xD8, row);
45166 +
45167 + /*
45168 + * Wait
45169 + */
45170 + stat = ubi32_nand_spi_er_busywait();
45171 + if (stat & UBI32_NAND_SPI_ER_STATUS_OIP) {
45172 + instr->fail_addr = block << 17;
45173 + instr->state = MTD_ERASE_FAILED;
45174 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive stat=%02x\n", chip->name, stat);
45175 +
45176 + /*
45177 + * Chip is stuck?
45178 + */
45179 + res = -EIO;
45180 + goto done;
45181 + }
45182 +
45183 + /*
45184 + * Check the status register
45185 + */
45186 + if (stat & UBI32_NAND_SPI_ER_STATUS_E_FAIL) {
45187 + DEBUG(MTD_DEBUG_LEVEL1, "%s: E_FAIL signalled (%02x)\n", chip->name, stat);
45188 + instr->fail_addr = block << 17;
45189 + instr->state = MTD_ERASE_FAILED;
45190 + goto done;
45191 + }
45192 +
45193 + /*
45194 + * Next
45195 + */
45196 + block++;
45197 + instr->len -= chip->device->erase_size;
45198 + instr->addr += chip->device->erase_size;
45199 + }
45200 +
45201 + instr->state = MTD_ERASE_DONE;
45202 +
45203 + mutex_unlock(&chip->lock);
45204 + return 0;
45205 +
45206 +done:
45207 + ubi32_nand_spi_er_write_disable();
45208 +
45209 + mutex_unlock(&chip->lock);
45210 +
45211 + mtd_erase_callback(instr);
45212 + return 0;
45213 +}
45214 +
45215 +/*
45216 + * ubi32_nand_spi_er_read
45217 + *
45218 + * return -EUCLEAN: ecc error recovered
45219 + * return -EBADMSG: ecc error not recovered
45220 +*/
45221 +static int ubi32_nand_spi_er_read(struct mtd_info *mtd, loff_t from, size_t len,
45222 + size_t *retlen, u_char *buf)
45223 +{
45224 + struct ubi32_nand_spi_er *chip = mtd->priv;
45225 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45226 +
45227 + uint32_t row;
45228 + uint32_t column;
45229 + int retval = 0;
45230 + uint32_t *pbuf = (uint32_t *)buf;
45231 +
45232 + *retlen = 0;
45233 + DEBUG(MTD_DEBUG_LEVEL2, "%s: read block from %llx len %d into %p\n", chip->name, from, len, buf);
45234 +
45235 + /*
45236 + * buf should be aligned
45237 + */
45238 + if ((uint32_t)buf & 0x03) {
45239 + return -EINVAL;
45240 + }
45241 +
45242 + /*
45243 + * Zero length reads, nothing to do
45244 + */
45245 + if (len == 0) {
45246 + return 0;
45247 + }
45248 +
45249 + /*
45250 + * Reject reads which go over the end of the flash
45251 + */
45252 + if ((from + len) > mtd->size) {
45253 + return -EINVAL;
45254 + }
45255 +
45256 + /*
45257 + * Get the row and column address to start at
45258 + */
45259 + row = from >> 11;
45260 + column = from & 0x7FF;
45261 + DEBUG(MTD_DEBUG_LEVEL3, "%s: row=%x %d column=%x %d last_row=%x %d\n", chip->name, row, row, column, column, chip->last_row, chip->last_row);
45262 +
45263 + /*
45264 + * Read the data from the chip
45265 + */
45266 + mutex_lock(&chip->lock);
45267 + while (len) {
45268 + uint8_t stat;
45269 + size_t toread;
45270 + int i;
45271 + int tmp;
45272 +
45273 + /*
45274 + * Figure out how much to read
45275 + *
45276 + * If we are reading from the middle of a page then the most we
45277 + * can read is to the end of the page
45278 + */
45279 + toread = len;
45280 + if (toread > (chip->device->page_size - column)) {
45281 + toread = chip->device->page_size - column;
45282 + }
45283 +
45284 + DEBUG(MTD_DEBUG_LEVEL3, "%s: buf=%p toread=%x row=%x column=%x last_row=%x\n", chip->name, pbuf, toread, row, column, chip->last_row);
45285 +
45286 + if (chip->last_row != row) {
45287 + /*
45288 + * Check if the block is bad
45289 + */
45290 + if (test_bit(UBI32_NAND_SPI_ER_BLOCK_FROM_ROW(row), chip->bbt)) {
45291 + mutex_unlock(&chip->lock);
45292 + return -EBADMSG;
45293 + }
45294 +
45295 + /*
45296 + * Load the appropriate page
45297 + */
45298 + ubi32_nand_spi_er_send_cmd_addr(0x13, row);
45299 +
45300 + /*
45301 + * Wait
45302 + */
45303 + stat = ubi32_nand_spi_er_busywait();
45304 + if (stat & UBI32_NAND_SPI_ER_STATUS_OIP) {
45305 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive stat=%02x\n", chip->name, stat);
45306 +
45307 + /*
45308 + * Chip is stuck?
45309 + */
45310 + mutex_unlock(&chip->lock);
45311 + return -EIO;
45312 + }
45313 +
45314 + /*
45315 + * Check the ECC bits
45316 + */
45317 + stat >>= 4;
45318 + if (stat == 1) {
45319 + DEBUG(MTD_DEBUG_LEVEL1, "%s: ECC recovered, row=%x\n", chip->name, row);
45320 + retval = -EUCLEAN;
45321 + }
45322 + if (stat == 2) {
45323 + DEBUG(MTD_DEBUG_LEVEL0, "%s: failed ECC, row=%x\n", chip->name, row);
45324 + chip->last_row = UBI32_NAND_SPI_ER_LAST_ROW_INVALID;
45325 + mutex_unlock(&chip->lock);
45326 + return -EBADMSG;
45327 + }
45328 +
45329 + }
45330 +
45331 + chip->last_row = row;
45332 +
45333 + /*
45334 + * Read out the data:
45335 + * We can always read a little too much since there is the
45336 + * OOB after byte addr 2047. The most we'll overread is 3 bytes.
45337 + */
45338 + if (((uint32_t)pbuf & 0x03) == 0) {
45339 + /*
45340 + * Aligned read
45341 + */
45342 + tmp = toread & (~0x03);
45343 + for (i = 0; i < tmp; i += 4) {
45344 + ubi32_nand_spi_er_send_rd_addr(0x03, column << 8);
45345 + *pbuf++ = io->status1;
45346 + column += 4;
45347 + }
45348 + } else {
45349 + /*
45350 + * Unaligned read
45351 + */
45352 + tmp = toread & (~0x03);
45353 + for (i = 0; i < tmp; i += 4) {
45354 + ubi32_nand_spi_er_send_rd_addr(0x03, column << 8);
45355 + memcpy(pbuf, &io->status1, 4);
45356 + column += 4;
45357 + }
45358 + }
45359 +
45360 + /*
45361 + * Fill in any single bytes
45362 + */
45363 + tmp = toread & 0x03;
45364 + if (tmp) {
45365 + uint8_t *bbuf = pbuf;
45366 + uint32_t val;
45367 + ubi32_nand_spi_er_send_rd_addr(0x03, column << 8);
45368 + val = io->status1;
45369 + for (i = 0; i < tmp; i++) {
45370 + *bbuf++ = val >> 24;
45371 + val <<= 8;
45372 + }
45373 + }
45374 +
45375 + len -= toread;
45376 + *retlen += toread;
45377 +
45378 + /*
45379 + * For the next page, increment the row and always start at column 0
45380 + */
45381 + column = 0;
45382 + row++;
45383 + }
45384 +
45385 + mutex_unlock(&chip->lock);
45386 + return retval;
45387 +}
45388 +
45389 +/*
45390 + * ubi32_nand_spi_er_write
45391 + */
45392 +#define WRITE_NOT_ALIGNED(x) ((x & (device->write_size - 1)) != 0)
45393 +static int ubi32_nand_spi_er_write(struct mtd_info *mtd, loff_t to, size_t len,
45394 + size_t *retlen, const u_char *buf)
45395 +{
45396 + struct ubi32_nand_spi_er *chip = mtd->priv;
45397 + const struct ubi32_nand_spi_er_device *device = chip->device;
45398 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45399 + uint32_t row;
45400 + uint32_t col;
45401 + int res = 0;
45402 + size_t towrite;
45403 +
45404 + DEBUG(MTD_DEBUG_LEVEL2, "%s: write block to %llx len %d from %p\n", chip->name, to, len, buf);
45405 +
45406 + *retlen = 0;
45407 +
45408 + /*
45409 + * nothing to write
45410 + */
45411 + if (!len) {
45412 + return 0;
45413 + }
45414 +
45415 + /*
45416 + * Reject writes which go over the end of the flash
45417 + */
45418 + if ((to + len) > mtd->size) {
45419 + return -EINVAL;
45420 + }
45421 +
45422 + /*
45423 + * buf should be aligned to 16 bits
45424 + */
45425 + if ((uint32_t)buf & 0x01) {
45426 + return -EINVAL;
45427 + }
45428 +
45429 + /*
45430 + * Check to see if everything is page aligned
45431 + */
45432 + if (WRITE_NOT_ALIGNED(to) || WRITE_NOT_ALIGNED(len)) {
45433 + printk(KERN_NOTICE "ubi32_nand_spi_er_write: Attempt to write non page aligned data\n");
45434 + return -EINVAL;
45435 + }
45436 +
45437 + mutex_lock(&chip->lock);
45438 +
45439 + io->ctl0 |= IO_XFL_CTL0_MCB_LOCK;
45440 +
45441 + chip->last_row = UBI32_NAND_SPI_ER_LAST_ROW_INVALID;
45442 +
45443 + /*
45444 + * If the first write is a partial write then write at most the number of
45445 + * bytes to get us page aligned and then the remainder will be
45446 + * page aligned. The last bit may be a partial page as well.
45447 + */
45448 + col = to & (device->page_size - 1);
45449 + towrite = device->page_size - col;
45450 + if (towrite > len) {
45451 + towrite = len;
45452 + }
45453 +
45454 + /*
45455 + * Write the data
45456 + */
45457 + row = to >> 11;
45458 + while (len) {
45459 + uint8_t stat;
45460 + uint32_t my_towrite;
45461 +
45462 + DEBUG(MTD_DEBUG_LEVEL3, "%s: write %p to row:%x col:%x len:%x rem:%x\n", chip->name, buf, row, col, towrite, len);
45463 +
45464 + ubi32_nand_spi_er_write_enable();
45465 +
45466 + /*
45467 + * Move the data into the cache
45468 + */
45469 + my_towrite = towrite;
45470 + while (my_towrite) {
45471 + uint32_t len = my_towrite;
45472 + if (len > 32) {
45473 + len = 32;
45474 + }
45475 +
45476 + ubi32_nand_spi_er_write_buf(buf, col);
45477 + buf += len;
45478 + col += len;
45479 + my_towrite -= len;
45480 + }
45481 +
45482 + /*
45483 + * Program execute
45484 + */
45485 + ubi32_nand_spi_er_send_cmd_addr(0x10, row);
45486 +
45487 + /*
45488 + * Wait
45489 + */
45490 + stat = ubi32_nand_spi_er_busywait();
45491 + if (stat & UBI32_NAND_SPI_ER_STATUS_OIP) {
45492 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive stat=%02x\n", chip->name, stat);
45493 +
45494 + /*
45495 + * Chip is stuck?
45496 + */
45497 + res = -EIO;
45498 + goto done;
45499 + }
45500 +
45501 + if (stat & (1 << 3)) {
45502 + res = -EBADMSG;
45503 + goto done;
45504 + }
45505 +
45506 + row++;
45507 + len -= towrite;
45508 + *retlen += towrite;
45509 +
45510 + /*
45511 + * At this point, we are always page aligned so start at column 0.
45512 + * Note we may not have a full page to write at the end, hence the
45513 + * check if towrite > len.
45514 + */
45515 + col = 0;
45516 + towrite = device->page_size;
45517 + if (towrite > len) {
45518 + towrite = len;
45519 + }
45520 + }
45521 +
45522 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
45523 +
45524 + mutex_unlock(&chip->lock);
45525 + return res;
45526 +
45527 +done:
45528 + ubi32_nand_spi_er_write_disable();
45529 +
45530 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
45531 +
45532 + mutex_unlock(&chip->lock);
45533 +
45534 + return res;
45535 +}
45536 +
45537 +/*
45538 + * ubi32_nand_spi_er_isbad
45539 + */
45540 +static int ubi32_nand_spi_er_isbad(struct mtd_info *mtd, loff_t ofs)
45541 +{
45542 + struct ubi32_nand_spi_er *chip = mtd->priv;
45543 + uint32_t block;
45544 +
45545 + if (ofs & (chip->device->erase_size - 1)) {
45546 + DEBUG(MTD_DEBUG_LEVEL1, "%s: address not aligned %llx\n", chip->name, ofs);
45547 + return -EINVAL;
45548 + }
45549 +
45550 + block = ofs >> 17;
45551 +
45552 + return test_bit(block, chip->bbt);
45553 +}
45554 +
45555 +/*
45556 + * ubi32_nand_spi_er_markbad
45557 + */
45558 +static int ubi32_nand_spi_er_markbad(struct mtd_info *mtd, loff_t ofs)
45559 +{
45560 + struct ubi32_nand_spi_er *chip = mtd->priv;
45561 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45562 + uint32_t block;
45563 + uint32_t row;
45564 + int res = 0;
45565 + uint8_t stat;
45566 +
45567 + if (ofs & (chip->device->erase_size - 1)) {
45568 + DEBUG(MTD_DEBUG_LEVEL1, "%s: address not aligned %llx\n", chip->name, ofs);
45569 + return -EINVAL;
45570 + }
45571 +
45572 + block = ofs >> 17;
45573 +
45574 + /*
45575 + * If it's already marked bad, no need to mark it
45576 + */
45577 + if (test_bit(block, chip->bbt)) {
45578 + return 0;
45579 + }
45580 +
45581 + /*
45582 + * Mark it in our cache
45583 + */
45584 + __set_bit(block, chip->bbt);
45585 +
45586 + /*
45587 + * Write the user bad block mark. If it fails, then we really
45588 + * can't do anything about it.
45589 + */
45590 + mutex_lock(&chip->lock);
45591 + chip->last_row = UBI32_NAND_SPI_ER_LAST_ROW_INVALID;
45592 +
45593 + ubi32_nand_spi_er_write_enable();
45594 +
45595 + /*
45596 + * Write the mark
45597 + */
45598 + io->ctl0 |= IO_XFL_CTL0_MCB_LOCK;
45599 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45600 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_WR) | IO_XFL_CTL1_FC_DATA(6);
45601 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x84);
45602 +
45603 + asm volatile (
45604 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_PORTX_INT_FIFO_TX_RESET)") \n\t"
45605 + " pipe_flush 0 \n\t"
45606 +
45607 + /*
45608 + * Move the data into the FIFO
45609 + */
45610 + " move.4 "D(IO_TX_FIFO)"(%[port]), %[word1] \n\t"
45611 + " move.4 "D(IO_TX_FIFO)"(%[port]), %[word2] \n\t"
45612 +
45613 + /*
45614 + * Kick off the flash command
45615 + */
45616 + " bset "D(IO_INT_CLR)"(%[port]), #0, #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45617 + " jmpt.t .+4 \n\t"
45618 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_XFL_INT_START)") \n\t"
45619 +
45620 + /*
45621 + * Wait for the transaction to finish
45622 + */
45623 + " btst "D(IO_INT_STATUS)"(%[port]), #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45624 + " jmpeq.f .-4 \n\t"
45625 +
45626 + :
45627 + : [word1] "d" (0x0800dead | (UBI32_NAND_SPI_ER_BAD_BLOCK_MARK_OFFSET << 16)),
45628 + [word2] "d" (0xbeef0000),
45629 + [port] "a" (FLASH_PORT)
45630 + : "cc"
45631 + );
45632 +
45633 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
45634 +
45635 + /*
45636 + * Program execute
45637 + */
45638 + row = block << 6;
45639 + ubi32_nand_spi_er_send_cmd_addr(0x10, row);
45640 +
45641 + /*
45642 + * Wait
45643 + */
45644 + stat = ubi32_nand_spi_er_busywait();
45645 + if (stat & UBI32_NAND_SPI_ER_STATUS_OIP) {
45646 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive stat=%02x\n", chip->name, stat);
45647 +
45648 + /*
45649 + * Chip is stuck?
45650 + */
45651 + res = -EIO;
45652 + goto done;
45653 + }
45654 +
45655 + if (stat & (1 << 3)) {
45656 + res = -EBADMSG;
45657 + }
45658 +
45659 +done:
45660 + ubi32_nand_spi_er_write_disable();
45661 +
45662 + mutex_unlock(&chip->lock);
45663 +
45664 + return res;
45665 +}
45666 +
45667 +/*
45668 + * ubi32_nand_spi_er_read_bbt
45669 + */
45670 +static int ubi32_nand_spi_er_read_bbt(struct ubi32_nand_spi_er *chip)
45671 +{
45672 + int j;
45673 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45674 +
45675 + for (j = 0; j < chip->device->blocks; j++) {
45676 + unsigned short row = j << 6;
45677 + uint8_t stat;
45678 +
45679 + /*
45680 + * Read Page
45681 + */
45682 + ubi32_nand_spi_er_send_cmd_addr(0x13, row);
45683 +
45684 + /*
45685 + * Wait
45686 + */
45687 + stat = ubi32_nand_spi_er_busywait();
45688 + if (stat & UBI32_NAND_SPI_ER_STATUS_OIP) {
45689 + DEBUG(MTD_DEBUG_LEVEL1, "%s: chip is busy or nonresponsive stat=%02x\n", chip->name, stat);
45690 +
45691 + /*
45692 + * Chip is stuck?
45693 + */
45694 + return -EIO;
45695 + }
45696 +
45697 + /*
45698 + * Check factory bad block mark
45699 + */
45700 + ubi32_nand_spi_er_send_rd_addr(0x03, 0x080000);
45701 +
45702 + if ((io->status1 >> 24) != 0xFF) {
45703 + chip->nbb++;
45704 + __set_bit(j, chip->bbt);
45705 + continue;
45706 + }
45707 +
45708 + ubi32_nand_spi_er_send_rd_addr(0x03, 0x080000 | (UBI32_NAND_SPI_ER_BAD_BLOCK_MARK_OFFSET << 8));
45709 + if (io->status1 == 0xdeadbeef) {
45710 + chip->nbb++;
45711 + __set_bit(j, chip->bbt);
45712 + }
45713 + }
45714 +
45715 +#if defined(CONFIG_MTD_DEBUG) && (MTD_DEBUG_LEVEL3 <= CONFIG_MTD_DEBUG_VERBOSE)
45716 + printk("%s: Bad Block Table:", chip->name);
45717 + for (j = 0; j < chip->device->blocks; j++) {
45718 + if ((j % 64) == 0) {
45719 + printk("\n%s: block %03x: ", chip->name, j);
45720 + }
45721 + printk("%c", test_bit(j, chip->bbt) ? 'X' : '.');
45722 + }
45723 + printk("\n%s: Bad Block Numbers: ", chip->name);
45724 + for (j = 0; j < chip->device->blocks; j++) {
45725 + if (test_bit(j, chip->bbt)) {
45726 + printk("%x ", j);
45727 + }
45728 + }
45729 + printk("\n");
45730 +#endif
45731 +
45732 + return 0;
45733 +}
45734 +
45735 +#ifndef MODULE
45736 +/*
45737 + * Called at boot time:
45738 + *
45739 + * ubi32_nand_spi_er=read_only
45740 + * if read_only specified then do not unlock device
45741 + */
45742 +static int __init ubi32_nand_spi_er_setup(char *str)
45743 +{
45744 + if (str && (strncasecmp(str, "read_only", 9) == 0)) {
45745 + read_only = 1;
45746 + }
45747 + return 0;
45748 +}
45749 +
45750 +__setup("ubi32_nand_spi_er=", ubi32_nand_spi_er_setup);
45751 +#endif
45752 +
45753 +/*
45754 + * ubi32_nand_spi_er_probe
45755 + * Detect and initialize ubi32_nand_spi_er device.
45756 + */
45757 +static int __devinit ubi32_nand_spi_er_probe(struct platform_device *pdev)
45758 +{
45759 + uint32_t i;
45760 + uint32_t id;
45761 + int res;
45762 + size_t bbt_bytes;
45763 + struct ubi32_nand_spi_er *chip;
45764 + const struct ubi32_nand_spi_er_device *device;
45765 + struct ubicom32_io_port *io = (struct ubicom32_io_port *)FLASH_PORT;
45766 +
45767 + /*
45768 + * Reset
45769 + */
45770 + for (i = 0; i < 2; i++) {
45771 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45772 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_CMD);
45773 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0xFF);
45774 + FLASH_COMMAND_EXEC(io);
45775 + udelay(250);
45776 + }
45777 + udelay(1000);
45778 +
45779 + /*
45780 + * Read out ID
45781 + */
45782 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45783 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_RD) | IO_XFL_CTL1_FC_DATA(2) |
45784 + IO_XFL_CTL1_FC_ADDR;
45785 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x9F);
45786 + FLASH_COMMAND_EXEC(io);
45787 +
45788 + id = io->status1 >> 16;
45789 + device = ubi32_nand_spi_er_devices;
45790 + for (i = 0; i < ARRAY_SIZE(ubi32_nand_spi_er_devices); i++) {
45791 + if (device->id == id) {
45792 + break;
45793 + }
45794 + device++;
45795 + }
45796 + if (i == ARRAY_SIZE(ubi32_nand_spi_er_devices)) {
45797 + return -ENODEV;
45798 + }
45799 +
45800 + /*
45801 + * Initialize our chip structure
45802 + */
45803 + bbt_bytes = DIV_ROUND_UP(device->blocks, BITS_PER_BYTE);
45804 + chip = kzalloc(sizeof(struct ubi32_nand_spi_er) + bbt_bytes, GFP_KERNEL);
45805 + if (!chip) {
45806 + return -ENOMEM;
45807 + }
45808 + snprintf(chip->name, sizeof(chip->name), "%s", device->name);
45809 +
45810 + chip->device = device;
45811 + chip->last_row = UBI32_NAND_SPI_ER_LAST_ROW_INVALID;
45812 +
45813 + mutex_init(&chip->lock);
45814 +
45815 + chip->mtd.type = MTD_NANDFLASH;
45816 + chip->mtd.flags = MTD_WRITEABLE;
45817 +
45818 + /*
45819 + * #blocks * block size * n blocks
45820 + */
45821 + chip->mtd.size = device->blocks * device->pages_per_block * device->page_size;
45822 + chip->mtd.erasesize = device->erase_size;
45823 +
45824 + /*
45825 + * 1 page, optionally we can support partial write (512)
45826 + */
45827 + chip->mtd.writesize = device->write_size;
45828 + chip->mtd.name = device->name;
45829 + chip->mtd.erase = ubi32_nand_spi_er_erase;
45830 + chip->mtd.read = ubi32_nand_spi_er_read;
45831 + chip->mtd.write = ubi32_nand_spi_er_write;
45832 + chip->mtd.block_isbad = ubi32_nand_spi_er_isbad;
45833 + chip->mtd.block_markbad = ubi32_nand_spi_er_markbad;
45834 + chip->mtd.priv = chip;
45835 +
45836 + /*
45837 + * Cache the bad block table
45838 + */
45839 + res = ubi32_nand_spi_er_read_bbt(chip);
45840 + if (res) {
45841 + kfree(chip);
45842 + return res;
45843 + }
45844 +
45845 + /*
45846 + * Un/lock the chip
45847 + */
45848 + io->ctl0 |= IO_XFL_CTL0_MCB_LOCK;
45849 + io->ctl1 &= ~IO_XFL_CTL1_MASK;
45850 + io->ctl1 |= IO_XFL_CTL1_FC_INST(FLASH_FC_INST_WR) | IO_XFL_CTL1_FC_DATA(2);
45851 + io->ctl2 = IO_XFL_CTL2_FC_CMD(0x1F);
45852 +
45853 + if (read_only) {
45854 + i = 0xa0380000;
45855 + } else {
45856 + i = 0xa0000000;
45857 + }
45858 + asm volatile (
45859 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_PORTX_INT_FIFO_TX_RESET)") \n\t"
45860 + " pipe_flush 0 \n\t"
45861 +
45862 + /*
45863 + * Move the data into the FIFO
45864 + */
45865 + " move.4 "D(IO_TX_FIFO)"(%[port]), %[word1] \n\t"
45866 +
45867 + /*
45868 + * Kick off the flash command
45869 + */
45870 + " bset "D(IO_INT_CLR)"(%[port]), #0, #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45871 + " jmpt.t .+4 \n\t"
45872 + " bset "D(IO_INT_SET)"(%[port]), #0, #%%bit("D(IO_XFL_INT_START)") \n\t"
45873 +
45874 + /*
45875 + * Wait for the transaction to finish
45876 + */
45877 + " btst "D(IO_INT_STATUS)"(%[port]), #%%bit("D(IO_XFL_INT_DONE)") \n\t"
45878 + " jmpeq.f .-4 \n\t"
45879 +
45880 + :
45881 + : [word1] "d" (i),
45882 + [port] "a" (FLASH_PORT)
45883 + : "cc"
45884 + );
45885 + io->ctl0 &= ~IO_XFL_CTL0_MCB_LOCK;
45886 +
45887 + dev_set_drvdata(&pdev->dev, chip);
45888 +
45889 + printk(KERN_INFO "%s: added device size: %u KBytes %lu bad blocks %s\n", chip->mtd.name, DIV_ROUND_UP(chip->mtd.size, 1024), chip->nbb, read_only ? "[read only]" : "");
45890 + return add_mtd_device(&chip->mtd);
45891 +}
45892 +
45893 +/*
45894 + * ubi32_nand_spi_er_remove
45895 + */
45896 +static int __devexit ubi32_nand_spi_er_remove(struct platform_device *pdev)
45897 +{
45898 + struct ubi32_nand_spi_er *chip = dev_get_drvdata(&pdev->dev);
45899 + int status;
45900 +
45901 + DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", chip->name);
45902 +
45903 + status = del_mtd_device(&chip->mtd);
45904 + if (status == 0) {
45905 + kfree(chip);
45906 + }
45907 +
45908 + dev_set_drvdata(&pdev->dev, NULL);
45909 + return status;
45910 +}
45911 +
45912 +static struct platform_device *ubi32_nand_spi_er_device;
45913 +
45914 +static struct platform_driver ubi32_nand_spi_er_driver = {
45915 + .driver = {
45916 + .name = DRIVER_NAME,
45917 + .owner = THIS_MODULE,
45918 + },
45919 +
45920 + .probe = ubi32_nand_spi_er_probe,
45921 + .remove = ubi32_nand_spi_er_remove,
45922 +};
45923 +
45924 +/*
45925 + * ubi32_nand_spi_er_init
45926 + */
45927 +static int __init ubi32_nand_spi_er_init(void)
45928 +{
45929 + int ret;
45930 +
45931 + ret = platform_driver_register(&ubi32_nand_spi_er_driver);
45932 +
45933 + if (ret) {
45934 + return ret;
45935 + }
45936 +
45937 + ubi32_nand_spi_er_device = platform_device_alloc(DRIVER_NAME, 0);
45938 + if (!ubi32_nand_spi_er_device) {
45939 + return -ENOMEM;
45940 + }
45941 +
45942 + ret = platform_device_add(ubi32_nand_spi_er_device);
45943 + if (ret) {
45944 + platform_device_put(ubi32_nand_spi_er_device);
45945 + platform_driver_unregister(&ubi32_nand_spi_er_driver);
45946 + }
45947 +
45948 + return ret;
45949 +}
45950 +module_init(ubi32_nand_spi_er_init);
45951 +
45952 +/*
45953 + * ubi32_nand_spi_er_exit
45954 + */
45955 +static void __exit ubi32_nand_spi_er_exit(void)
45956 +{
45957 + platform_device_unregister(ubi32_nand_spi_er_device);
45958 + platform_driver_unregister(&ubi32_nand_spi_er_driver);
45959 +}
45960 +module_exit(ubi32_nand_spi_er_exit);
45961 +
45962 +
45963 +MODULE_LICENSE("GPL");
45964 +MODULE_AUTHOR("Patrick Tjin");
45965 +MODULE_DESCRIPTION("MTD ubi32_nand_spi_er driver for ubicom32 SPI flash controller.");
45966 diff -ruN linux-2.6.30.10/drivers/net/Kconfig linux-2.6.30.10-ubi/drivers/net/Kconfig
45967 --- linux-2.6.30.10/drivers/net/Kconfig 2009-12-14 11:47:19.000000000 +0200
45968 +++ linux-2.6.30.10-ubi/drivers/net/Kconfig 2009-12-14 11:47:17.000000000 +0200
45969 @@ -2540,6 +2540,19 @@
45970 To compile this driver as a module, choose M here. The module
45971 will be called jme.
45972
45973 +config UBICOM32_GMAC
45974 + tristate "Ubicom Gigabit Ethernet support"
45975 + depends on UBICOM32
45976 + help
45977 + Gigabit Ethernet support for ubicom32 processors
45978 +
45979 +config UBICOM32_OCM_FOR_SKB
45980 + bool "USE OCM for SKB (EXPERIMENTAL)"
45981 + depends on UBICOM32_GMAC
45982 + default n
45983 + help
45984 + Allocate skb from OCM for Ethernet Receive when possible
45985 +
45986 endif # NETDEV_1000
45987
45988 #
45989 diff -ruN linux-2.6.30.10/drivers/net/Makefile linux-2.6.30.10-ubi/drivers/net/Makefile
45990 --- linux-2.6.30.10/drivers/net/Makefile 2009-12-14 11:48:38.000000000 +0200
45991 +++ linux-2.6.30.10-ubi/drivers/net/Makefile 2009-12-14 11:48:40.000000000 +0200
45992 @@ -272,3 +272,5 @@
45993 obj-$(CONFIG_SFC) += sfc/
45994
45995 obj-$(CONFIG_WIMAX) += wimax/
45996 +
45997 +obj-$(CONFIG_UBICOM32_GMAC) += ubi32-eth.o
45998 diff -ruN linux-2.6.30.10/drivers/net/ubi32-eth.c linux-2.6.30.10-ubi/drivers/net/ubi32-eth.c
45999 --- linux-2.6.30.10/drivers/net/ubi32-eth.c 1970-01-01 02:00:00.000000000 +0200
46000 +++ linux-2.6.30.10-ubi/drivers/net/ubi32-eth.c 2009-12-11 11:45:18.000000000 +0200
46001 @@ -0,0 +1,760 @@
46002 +/*
46003 + * drivers/net/ubi32-eth.c
46004 + * Ubicom32 ethernet TIO interface driver.
46005 + *
46006 + * (C) Copyright 2009, Ubicom, Inc.
46007 + *
46008 + * This file is part of the Ubicom32 Linux Kernel Port.
46009 + *
46010 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
46011 + * it and/or modify it under the terms of the GNU General Public License
46012 + * as published by the Free Software Foundation, either version 2 of the
46013 + * License, or (at your option) any later version.
46014 + *
46015 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
46016 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
46017 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
46018 + * the GNU General Public License for more details.
46019 + *
46020 + * You should have received a copy of the GNU General Public License
46021 + * along with the Ubicom32 Linux Kernel Port. If not,
46022 + * see <http://www.gnu.org/licenses/>.
46023 + *
46024 + * Ubicom32 implementation derived from (with many thanks):
46025 + * arch/m68knommu
46026 + * arch/blackfin
46027 + * arch/parisc
46028 + */
46029 +/*
46030 + * ubi32_eth.c
46031 + * Ethernet driver for Ip5k/Ip7K
46032 + */
46033 +
46034 +#include <linux/module.h>
46035 +#include <linux/init.h>
46036 +#include <linux/moduleparam.h>
46037 +
46038 +#include <linux/sched.h>
46039 +#include <linux/kernel.h>
46040 +#include <linux/errno.h>
46041 +#include <linux/types.h>
46042 +#include <linux/interrupt.h>
46043 +
46044 +#include <linux/in.h>
46045 +#include <linux/netdevice.h>
46046 +#include <linux/etherdevice.h>
46047 +#include <linux/mii.h>
46048 +#include <linux/if_vlan.h>
46049 +#include <linux/ip.h>
46050 +#include <linux/tcp.h>
46051 +#include <linux/skbuff.h>
46052 +#include <asm/checksum.h>
46053 +#include <asm/ip5000.h>
46054 +#include <asm/devtree.h>
46055 +#include <asm/system.h>
46056 +
46057 +#define UBICOM32_USE_NAPI /* define this to use NAPI instead of tasklet */
46058 +//#define UBICOM32_USE_POLLING /* define this to use polling instead of interrupt */
46059 +#include "ubi32-eth.h"
46060 +
46061 +/*
46062 + * TODO:
46063 + * mac address from flash
46064 + * multicast filter
46065 + * ethtool support
46066 + * sysfs support
46067 + * skb->nrfrag support
46068 + * ioctl
46069 + * monitor phy status
46070 + */
46071 +
46072 +extern int ubi32_ocm_skbuf_max, ubi32_ocm_skbuf, ubi32_ddr_skbuf;
46073 +static const char *eth_if_name[UBI32_ETH_NUM_OF_DEVICES] =
46074 + {"eth_lan", "eth_wan"};
46075 +static struct net_device *ubi32_eth_devices[UBI32_ETH_NUM_OF_DEVICES] =
46076 + {NULL, NULL};
46077 +static u8_t mac_addr[UBI32_ETH_NUM_OF_DEVICES][ETH_ALEN] = {
46078 + {0x00, 0x03, 0x64, 'l', 'a', 'n'},
46079 + {0x00, 0x03, 0x64, 'w', 'a', 'n'}};
46080 +
46081 +#if (defined(CONFIG_ZONE_DMA) && defined(CONFIG_UBICOM32_OCM_FOR_SKB))
46082 +static inline struct sk_buff *ubi32_alloc_skb_ocm(struct net_device *dev, unsigned int length)
46083 +{
46084 + return __dev_alloc_skb(length, GFP_ATOMIC | __GFP_NOWARN | __GFP_NORETRY | GFP_DMA);
46085 +}
46086 +#endif
46087 +
46088 +static inline struct sk_buff *ubi32_alloc_skb(struct net_device *dev, unsigned int length)
46089 +{
46090 + return __dev_alloc_skb(length, GFP_ATOMIC | __GFP_NOWARN);
46091 +}
46092 +
46093 +static void ubi32_eth_vp_rxtx_enable(struct net_device *dev)
46094 +{
46095 + struct ubi32_eth_private *priv = netdev_priv(dev);
46096 + priv->regs->command = UBI32_ETH_VP_CMD_RX_ENABLE | UBI32_ETH_VP_CMD_TX_ENABLE;
46097 + priv->regs->int_mask = (UBI32_ETH_VP_INT_RX | UBI32_ETH_VP_INT_TX);
46098 + ubicom32_set_interrupt(priv->vp_int_bit);
46099 +}
46100 +
46101 +static void ubi32_eth_vp_rxtx_stop(struct net_device *dev)
46102 +{
46103 + struct ubi32_eth_private *priv = netdev_priv(dev);
46104 + priv->regs->command = 0;
46105 + priv->regs->int_mask = 0;
46106 + ubicom32_set_interrupt(priv->vp_int_bit);
46107 +
46108 + /* Wait for graceful shutdown */
46109 + while (priv->regs->status & (UBI32_ETH_VP_STATUS_RX_STATE | UBI32_ETH_VP_STATUS_TX_STATE));
46110 +}
46111 +
46112 +/*
46113 + * ubi32_eth_tx_done()
46114 + */
46115 +static int ubi32_eth_tx_done(struct net_device *dev)
46116 +{
46117 + struct ubi32_eth_private *priv;
46118 + struct sk_buff *skb;
46119 + volatile void *pdata;
46120 + struct ubi32_eth_dma_desc *desc;
46121 + u32_t count = 0;
46122 +
46123 + priv = netdev_priv(dev);
46124 +
46125 + priv->regs->int_status &= ~UBI32_ETH_VP_INT_TX;
46126 + while (priv->tx_tail != priv->regs->tx_out) {
46127 + pdata = priv->regs->tx_dma_ring[priv->tx_tail];
46128 + BUG_ON(pdata == NULL);
46129 +
46130 + skb = container_of((void *)pdata, struct sk_buff, cb);
46131 + desc = (struct ubi32_eth_dma_desc *)pdata;
46132 + if (unlikely(!(desc->status & UBI32_ETH_VP_TX_OK))) {
46133 + dev->stats.tx_errors++;
46134 + } else {
46135 + dev->stats.tx_packets++;
46136 + dev->stats.tx_bytes += skb->len;
46137 + }
46138 + dev_kfree_skb_any(skb);
46139 + priv->regs->tx_dma_ring[priv->tx_tail] = NULL;
46140 + priv->tx_tail = (priv->tx_tail + 1) & TX_DMA_RING_MASK;
46141 + count++;
46142 + }
46143 +
46144 + if (unlikely(priv->regs->status & UBI32_ETH_VP_STATUS_TX_Q_FULL)) {
46145 + spin_lock(&priv->lock);
46146 + if (priv->regs->status & UBI32_ETH_VP_STATUS_TX_Q_FULL) {
46147 + priv->regs->status &= ~UBI32_ETH_VP_STATUS_TX_Q_FULL;
46148 + netif_wake_queue(dev);
46149 + }
46150 + spin_unlock(&priv->lock);
46151 + }
46152 + return count;
46153 +}
46154 +
46155 +/*
46156 + * ubi32_eth_receive()
46157 + * To avoid locking overhead, this is called only
46158 + * by tasklet when not using NAPI, or
46159 + * by NAPI poll when using NAPI.
46160 + * return number of frames processed
46161 + */
46162 +static int ubi32_eth_receive(struct net_device *dev, int quota)
46163 +{
46164 + struct ubi32_eth_private *priv = netdev_priv(dev);
46165 + unsigned short rx_in = priv->regs->rx_in;
46166 + struct sk_buff *skb;
46167 + struct ubi32_eth_dma_desc *desc = NULL;
46168 + volatile void *pdata;
46169 +
46170 + int extra_reserve_adj;
46171 + int extra_alloc = UBI32_ETH_RESERVE_SPACE + UBI32_ETH_TRASHED_MEMORY;
46172 + int replenish_cnt, count = 0;
46173 + int replenish_max = RX_DMA_MAX_QUEUE_SIZE;
46174 +#if (defined(CONFIG_ZONE_DMA) && defined(CONFIG_UBICOM32_OCM_FOR_SKB))
46175 + if (likely(dev == ubi32_eth_devices[0]))
46176 + replenish_max = min(ubi32_ocm_skbuf_max, RX_DMA_MAX_QUEUE_SIZE);;
46177 +#endif
46178 +
46179 + if (unlikely(rx_in == priv->regs->rx_out))
46180 + priv->vp_stats.rx_q_full_cnt++;
46181 +
46182 + priv->regs->int_status &= ~UBI32_ETH_VP_INT_RX;
46183 + while (priv->rx_tail != priv->regs->rx_out) {
46184 + if (unlikely(count == quota)) {
46185 + /* There is still frame pending to be processed */
46186 + priv->vp_stats.rx_throttle++;
46187 + break;
46188 + }
46189 +
46190 + pdata = priv->regs->rx_dma_ring[priv->rx_tail];
46191 + BUG_ON(pdata == NULL);
46192 +
46193 + desc = (struct ubi32_eth_dma_desc *)pdata;
46194 + skb = container_of((void *)pdata, struct sk_buff, cb);
46195 + count++;
46196 + priv->regs->rx_dma_ring[priv->rx_tail] = NULL;
46197 + priv->rx_tail = ((priv->rx_tail + 1) & RX_DMA_RING_MASK);
46198 +
46199 + /*
46200 + * Check only RX_OK bit here.
46201 + * The rest of status word is used as timestamp
46202 + */
46203 + if (unlikely(!(desc->status & UBI32_ETH_VP_RX_OK))) {
46204 + dev->stats.rx_errors++;
46205 + dev_kfree_skb_any(skb);
46206 + continue;
46207 + }
46208 +
46209 + skb_put(skb, desc->data_len);
46210 + skb->dev = dev;
46211 + skb->protocol = eth_type_trans(skb, dev);
46212 + skb->ip_summed = CHECKSUM_NONE;
46213 + dev->stats.rx_bytes += skb->len;
46214 + dev->stats.rx_packets++;
46215 +#ifndef UBICOM32_USE_NAPI
46216 + netif_rx(skb);
46217 +#else
46218 + netif_receive_skb(skb);
46219 +#endif
46220 + }
46221 +
46222 + /* fill in more descripor for VP*/
46223 + replenish_cnt = replenish_max -
46224 + ((RX_DMA_RING_SIZE + rx_in - priv->rx_tail) & RX_DMA_RING_MASK);
46225 + if (replenish_cnt > 0) {
46226 +#if (defined(CONFIG_ZONE_DMA) && defined(CONFIG_UBICOM32_OCM_FOR_SKB))
46227 + /*
46228 + * black magic for perforamnce:
46229 + * Try to allocate skb from OCM only for first Ethernet I/F.
46230 + * Also limit number of RX buffers to 21 due to limited OCM.
46231 + */
46232 + if (likely(dev == ubi32_eth_devices[0])) {
46233 + do {
46234 + skb = ubi32_alloc_skb_ocm(dev, RX_BUF_SIZE + extra_alloc);
46235 + if (!skb) {
46236 + break;
46237 + }
46238 + /* set up dma descriptor */
46239 + ubi32_ocm_skbuf++;
46240 + desc = (struct ubi32_eth_dma_desc *)skb->cb;
46241 + extra_reserve_adj =
46242 + ((u32)skb->data + UBI32_ETH_RESERVE_SPACE + ETH_HLEN) &
46243 + (CACHE_LINE_SIZE - 1);
46244 + skb_reserve(skb, UBI32_ETH_RESERVE_SPACE - extra_reserve_adj);
46245 + desc->data_pointer = skb->data;
46246 + desc->buffer_len = RX_BUF_SIZE + UBI32_ETH_TRASHED_MEMORY;
46247 + desc->data_len = 0;
46248 + desc->status = 0;
46249 + priv->regs->rx_dma_ring[rx_in] = desc;
46250 + rx_in = (rx_in + 1) & RX_DMA_RING_MASK;
46251 + } while (--replenish_cnt > 0);
46252 + }
46253 +#endif
46254 +
46255 + while (replenish_cnt-- > 0) {
46256 + skb = ubi32_alloc_skb(dev, RX_BUF_SIZE + extra_alloc);
46257 + if (!skb) {
46258 + priv->vp_stats.rx_alloc_err++;
46259 + break;
46260 + }
46261 + /* set up dma descriptor */
46262 + ubi32_ddr_skbuf++;
46263 + desc = (struct ubi32_eth_dma_desc *)skb->cb;
46264 + extra_reserve_adj =
46265 + ((u32)skb->data + UBI32_ETH_RESERVE_SPACE + ETH_HLEN) &
46266 + (CACHE_LINE_SIZE - 1);
46267 + skb_reserve(skb, UBI32_ETH_RESERVE_SPACE - extra_reserve_adj);
46268 + desc->data_pointer = skb->data;
46269 + desc->buffer_len = RX_BUF_SIZE + UBI32_ETH_TRASHED_MEMORY;
46270 + desc->data_len = 0;
46271 + desc->status = 0;
46272 + priv->regs->rx_dma_ring[rx_in] = desc;
46273 + rx_in = (rx_in + 1) & RX_DMA_RING_MASK;
46274 + }
46275 +
46276 + wmb();
46277 + priv->regs->rx_in = rx_in;
46278 + ubicom32_set_interrupt(priv->vp_int_bit);
46279 + }
46280 +
46281 + if (likely(count > 0)) {
46282 + dev->last_rx = jiffies;
46283 + }
46284 + return count;
46285 +}
46286 +
46287 +#ifdef UBICOM32_USE_NAPI
46288 +static int ubi32_eth_napi_poll(struct napi_struct *napi, int budget)
46289 +{
46290 + struct ubi32_eth_private *priv = container_of(napi, struct ubi32_eth_private, napi);
46291 + struct net_device *dev = priv->dev;
46292 + u32_t count;
46293 +
46294 + if (priv->tx_tail != priv->regs->tx_out) {
46295 + ubi32_eth_tx_done(dev);
46296 + }
46297 +
46298 + count = ubi32_eth_receive(dev, budget);
46299 +
46300 + if (count < budget) {
46301 + napi_complete(napi);
46302 + priv->regs->int_mask |= (UBI32_ETH_VP_INT_RX | UBI32_ETH_VP_INT_TX);
46303 + if ((priv->rx_tail != priv->regs->rx_out) || (priv->tx_tail != priv->regs->tx_out)) {
46304 + if (napi_reschedule(napi)) {
46305 + priv->regs->int_mask = 0;
46306 + }
46307 + }
46308 + }
46309 + return count;
46310 +}
46311 +
46312 +#else
46313 +static void ubi32_eth_do_tasklet(unsigned long arg)
46314 +{
46315 + struct net_device *dev = (struct net_device *)arg;
46316 + struct ubi32_eth_private *priv = netdev_priv(dev);
46317 +
46318 + if (priv->tx_tail != priv->regs->tx_out) {
46319 + ubi32_eth_tx_done(dev);
46320 + }
46321 +
46322 + /* always call receive to process new RX frame as well as replenish RX buffers */
46323 + ubi32_eth_receive(dev, UBI32_RX_BOUND);
46324 +
46325 + priv->regs->int_mask |= (UBI32_ETH_VP_INT_RX | UBI32_ETH_VP_INT_TX);
46326 + if ((priv->rx_tail != priv->regs->rx_out) || (priv->tx_tail != priv->regs->tx_out)) {
46327 + priv->regs->int_mask = 0;
46328 + tasklet_schedule(&priv->tsk);
46329 + }
46330 +}
46331 +#endif
46332 +
46333 +#if defined(UBICOM32_USE_POLLING)
46334 +static struct timer_list eth_poll_timer;
46335 +
46336 +static void ubi32_eth_poll(unsigned long arg)
46337 +{
46338 + struct net_device *dev;
46339 + struct ubi32_eth_private *priv;
46340 + int i;
46341 +
46342 + for (i = 0; i < UBI32_ETH_NUM_OF_DEVICES; i++) {
46343 + dev = ubi32_eth_devices[i];
46344 + if (dev && (dev->flags & IFF_UP)) {
46345 + priv = netdev_priv(dev);
46346 +#ifdef UBICOM32_USE_NAPI
46347 + napi_schedule(&priv->napi);
46348 +#else
46349 + tasklet_schedule(&priv->tsk);
46350 +#endif
46351 + }
46352 + }
46353 +
46354 + eth_poll_timer.expires = jiffies + 2;
46355 + add_timer(&eth_poll_timer);
46356 +}
46357 +
46358 +#else
46359 +static irqreturn_t ubi32_eth_interrupt(int irq, void *dev_id)
46360 +{
46361 + struct ubi32_eth_private *priv;
46362 +
46363 + struct net_device *dev = (struct net_device *)dev_id;
46364 + BUG_ON(irq != dev->irq);
46365 +
46366 + priv = netdev_priv(dev);
46367 + if (unlikely(!(priv->regs->int_status & priv->regs->int_mask))) {
46368 + return IRQ_NONE;
46369 + }
46370 +
46371 + /*
46372 + * Disable port interrupt
46373 + */
46374 +#ifdef UBICOM32_USE_NAPI
46375 + if (napi_schedule_prep(&priv->napi)) {
46376 + priv->regs->int_mask = 0;
46377 + __napi_schedule(&priv->napi);
46378 + }
46379 +#else
46380 + priv->regs->int_mask = 0;
46381 + tasklet_schedule(&priv->tsk);
46382 +#endif
46383 + return IRQ_HANDLED;
46384 +}
46385 +#endif
46386 +
46387 +/*
46388 + * ubi32_eth_open
46389 + */
46390 +static int ubi32_eth_open(struct net_device *dev)
46391 +{
46392 + struct ubi32_eth_private *priv = netdev_priv(dev);
46393 + int err;
46394 +
46395 + printk(KERN_INFO "eth open %s\n",dev->name);
46396 +#ifndef UBICOM32_USE_POLLING
46397 + /* request_region() */
46398 + err = request_irq(dev->irq, ubi32_eth_interrupt, IRQF_DISABLED, dev->name, dev);
46399 + if (err) {
46400 + printk(KERN_WARNING "fail to request_irq %d\n",err);
46401 + return -ENODEV;
46402 + }
46403 +#endif
46404 +#ifdef UBICOM32_USE_NAPI
46405 + napi_enable(&priv->napi);
46406 +#else
46407 + tasklet_init(&priv->tsk, ubi32_eth_do_tasklet, (unsigned long)dev);
46408 +#endif
46409 +
46410 + /* call receive to supply RX buffers */
46411 + ubi32_eth_receive(dev, RX_DMA_MAX_QUEUE_SIZE);
46412 +
46413 + /* check phy status and call netif_carrier_on */
46414 + ubi32_eth_vp_rxtx_enable(dev);
46415 + netif_start_queue(dev);
46416 + return 0;
46417 +}
46418 +
46419 +static int ubi32_eth_close(struct net_device *dev)
46420 +{
46421 + struct ubi32_eth_private *priv = netdev_priv(dev);
46422 + volatile void *pdata;
46423 + struct sk_buff *skb;
46424 +
46425 +#ifndef UBICOM32_USE_POLLING
46426 + free_irq(dev->irq, dev);
46427 +#endif
46428 + netif_stop_queue(dev); /* can't transmit any more */
46429 +#ifdef UBICOM32_USE_NAPI
46430 + napi_disable(&priv->napi);
46431 +#else
46432 + tasklet_kill(&priv->tsk);
46433 +#endif
46434 + ubi32_eth_vp_rxtx_stop(dev);
46435 +
46436 + /*
46437 + * RX clean up
46438 + */
46439 + while (priv->rx_tail != priv->regs->rx_in) {
46440 + pdata = priv->regs->rx_dma_ring[priv->rx_tail];
46441 + skb = container_of((void *)pdata, struct sk_buff, cb);
46442 + priv->regs->rx_dma_ring[priv->rx_tail] = NULL;
46443 + dev_kfree_skb_any(skb);
46444 + priv->rx_tail = ((priv->rx_tail + 1) & RX_DMA_RING_MASK);
46445 + }
46446 + priv->regs->rx_in = 0;
46447 + priv->regs->rx_out = priv->regs->rx_in;
46448 + priv->rx_tail = priv->regs->rx_in;
46449 +
46450 + /*
46451 + * TX clean up
46452 + */
46453 + BUG_ON(priv->regs->tx_out != priv->regs->tx_in);
46454 + ubi32_eth_tx_done(dev);
46455 + BUG_ON(priv->tx_tail != priv->regs->tx_in);
46456 + priv->regs->tx_in = 0;
46457 + priv->regs->tx_out = priv->regs->tx_in;
46458 + priv->tx_tail = priv->regs->tx_in;
46459 +
46460 + return 0;
46461 +}
46462 +
46463 +/*
46464 + * ubi32_eth_set_config
46465 + */
46466 +static int ubi32_eth_set_config(struct net_device *dev, struct ifmap *map)
46467 +{
46468 + /* if must to down to config it */
46469 + printk(KERN_INFO "set_config %x\n", dev->flags);
46470 + if (dev->flags & IFF_UP)
46471 + return -EBUSY;
46472 +
46473 + /* I/O and IRQ can not be changed */
46474 + if (map->base_addr != dev->base_addr) {
46475 + printk(KERN_WARNING "%s: Can't change I/O address\n", dev->name);
46476 + return -EOPNOTSUPP;
46477 + }
46478 +
46479 +#ifndef UBICOM32_USE_POLLING
46480 + if (map->irq != dev->irq) {
46481 + printk(KERN_WARNING "%s: Can't change IRQ\n", dev->name);
46482 + return -EOPNOTSUPP;
46483 + }
46484 +#endif
46485 +
46486 + /* ignore other fields */
46487 + return 0;
46488 +}
46489 +
46490 +static int ubi32_eth_start_xmit(struct sk_buff *skb, struct net_device *dev)
46491 +{
46492 + struct ubi32_eth_private *priv = netdev_priv(dev);
46493 + struct ubi32_eth_dma_desc *desc = NULL;
46494 + unsigned short space, tx_in;
46495 +
46496 + tx_in = priv->regs->tx_in;
46497 +
46498 + dev->trans_start = jiffies; /* save the timestamp */
46499 + space = TX_DMA_RING_MASK - ((TX_DMA_RING_SIZE + tx_in - priv->tx_tail) & TX_DMA_RING_MASK);
46500 +
46501 + if (unlikely(space == 0)) {
46502 + if (!(priv->regs->status & UBI32_ETH_VP_STATUS_TX_Q_FULL)) {
46503 + spin_lock(&priv->lock);
46504 + if (!(priv->regs->status & UBI32_ETH_VP_STATUS_TX_Q_FULL)) {
46505 + priv->regs->status |= UBI32_ETH_VP_STATUS_TX_Q_FULL;
46506 + priv->vp_stats.tx_q_full_cnt++;
46507 + netif_stop_queue(dev);
46508 + }
46509 + spin_unlock(&priv->lock);
46510 + }
46511 +
46512 + /* give both HW and this driver an extra trigger */
46513 + priv->regs->int_mask |= UBI32_ETH_VP_INT_TX;
46514 +#ifndef UBICOM32_USE_POLLING
46515 + ubicom32_set_interrupt(dev->irq);
46516 +#endif
46517 + ubicom32_set_interrupt(priv->vp_int_bit);
46518 +
46519 + return NETDEV_TX_BUSY;
46520 + }
46521 +
46522 + /*still have room */
46523 + desc = (struct ubi32_eth_dma_desc *)skb->cb;
46524 + desc->data_pointer = skb->data;
46525 + desc->data_len = skb->len;
46526 + priv->regs->tx_dma_ring[tx_in] = desc;
46527 + tx_in = ((tx_in + 1) & TX_DMA_RING_MASK);
46528 + wmb();
46529 + priv->regs->tx_in = tx_in;
46530 + /* kick the HRT */
46531 + ubicom32_set_interrupt(priv->vp_int_bit);
46532 +
46533 + return NETDEV_TX_OK;
46534 +}
46535 +
46536 +/*
46537 + * Deal with a transmit timeout.
46538 + */
46539 +static void ubi32_eth_tx_timeout (struct net_device *dev)
46540 +{
46541 + struct ubi32_eth_private *priv = netdev_priv(dev);
46542 + dev->stats.tx_errors++;
46543 + priv->regs->int_mask |= UBI32_ETH_VP_INT_TX;
46544 +#ifndef UBICOM32_USE_POLLING
46545 + ubicom32_set_interrupt(dev->irq);
46546 +#endif
46547 + ubicom32_set_interrupt(priv->vp_int_bit);
46548 +}
46549 +
46550 +static int ubi32_eth_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
46551 +{
46552 + struct ubi32_eth_private *priv = netdev_priv(dev);
46553 + struct mii_ioctl_data *data = if_mii(rq);
46554 +
46555 + printk(KERN_INFO "ioctl %s, %d\n", dev->name, cmd);
46556 + switch (cmd) {
46557 + case SIOCGMIIPHY:
46558 + data->phy_id = 0;
46559 + break;
46560 +
46561 + case SIOCGMIIREG:
46562 + if ((data->reg_num & 0x1F) == MII_BMCR) {
46563 + /* Make up MII control register value from what we know */
46564 + data->val_out = 0x0000
46565 + | ((priv->regs->status & UBI32_ETH_VP_STATUS_DUPLEX)
46566 + ? BMCR_FULLDPLX : 0)
46567 + | ((priv->regs->status & UBI32_ETH_VP_STATUS_SPEED100)
46568 + ? BMCR_SPEED100 : 0)
46569 + | ((priv->regs->status & UBI32_ETH_VP_STATUS_SPEED1000)
46570 + ? BMCR_SPEED1000 : 0);
46571 + } else if ((data->reg_num & 0x1F) == MII_BMSR) {
46572 + /* Make up MII status register value from what we know */
46573 + data->val_out =
46574 + (BMSR_100FULL|BMSR_100HALF|BMSR_10FULL|BMSR_10HALF)
46575 + | ((priv->regs->status & UBI32_ETH_VP_STATUS_LINK)
46576 + ? BMSR_LSTATUS : 0);
46577 + } else {
46578 + return -EIO;
46579 + }
46580 + break;
46581 +
46582 + case SIOCSMIIREG:
46583 + return -EOPNOTSUPP;
46584 + break;
46585 +
46586 + default:
46587 + return -EOPNOTSUPP;
46588 + }
46589 +
46590 + return 0;
46591 +}
46592 +
46593 +/*
46594 + * Return statistics to the caller
46595 + */
46596 +static struct net_device_stats *ubi32_eth_get_stats(struct net_device *dev)
46597 +{
46598 + return &dev->stats;
46599 +}
46600 +
46601 +
46602 +static int ubi32_eth_change_mtu(struct net_device *dev, int new_mtu)
46603 +{
46604 + struct ubi32_eth_private *priv = netdev_priv(dev);
46605 + unsigned long flags;
46606 +
46607 + if ((new_mtu < 68) || (new_mtu > 1500))
46608 + return -EINVAL;
46609 +
46610 + spin_lock_irqsave(&priv->lock, flags);
46611 + dev->mtu = new_mtu;
46612 + spin_unlock_irqrestore(&priv->lock, flags);
46613 + printk(KERN_INFO "set mtu to %d", new_mtu);
46614 + return 0;
46615 +}
46616 +
46617 +/*
46618 + * ubi32_eth_cleanup: unload the module
46619 + */
46620 +void ubi32_eth_cleanup(void)
46621 +{
46622 + struct ubi32_eth_private *priv;
46623 + struct net_device *dev;
46624 + int i;
46625 +
46626 + for (i = 0; i < UBI32_ETH_NUM_OF_DEVICES; i++) {
46627 + dev = ubi32_eth_devices[i];
46628 + if (dev) {
46629 + priv = netdev_priv(dev);
46630 + kfree(priv->regs->tx_dma_ring);
46631 + unregister_netdev(dev);
46632 + free_netdev(dev);
46633 + ubi32_eth_devices[i] = NULL;
46634 + }
46635 + }
46636 +}
46637 +
46638 +int ubi32_eth_init_module(void)
46639 +{
46640 + struct ethtionode *eth_node;
46641 + struct net_device *dev;
46642 + struct ubi32_eth_private *priv;
46643 + int i, err;
46644 +
46645 + /*
46646 + * Device allocation.
46647 + */
46648 + err = 0;
46649 + for (i = 0; i < UBI32_ETH_NUM_OF_DEVICES; i++) {
46650 + /*
46651 + * See if the eth_vp is in the device tree.
46652 + */
46653 + eth_node = (struct ethtionode *)devtree_find_node(eth_if_name[i]);
46654 + if (!eth_node) {
46655 + printk(KERN_INFO "%s does not exist\n", eth_if_name[i]);
46656 + continue;
46657 + }
46658 +
46659 + eth_node->tx_dma_ring = (struct ubi32_eth_dma_desc **)kmalloc(
46660 + sizeof(struct ubi32_eth_dma_desc *) *
46661 + (TX_DMA_RING_SIZE + RX_DMA_RING_SIZE),
46662 + GFP_ATOMIC | __GFP_NOWARN | __GFP_NORETRY | GFP_DMA);
46663 +
46664 + if (eth_node->tx_dma_ring == NULL) {
46665 + eth_node->tx_dma_ring = (struct ubi32_eth_dma_desc **)kmalloc(
46666 + sizeof(struct ubi32_eth_dma_desc *) *
46667 + (TX_DMA_RING_SIZE + RX_DMA_RING_SIZE), GFP_KERNEL);
46668 + printk(KERN_INFO "fail to allocate from OCM\n");
46669 + }
46670 +
46671 + if (!eth_node->tx_dma_ring) {
46672 + err = -ENOMEM;
46673 + break;
46674 + }
46675 + eth_node->rx_dma_ring = eth_node->tx_dma_ring + TX_DMA_RING_SIZE;
46676 + eth_node->tx_sz = TX_DMA_RING_SIZE - 1;
46677 + eth_node->rx_sz = RX_DMA_RING_SIZE - 1;
46678 +
46679 + dev = alloc_etherdev(sizeof(struct ubi32_eth_private));
46680 + if (!dev) {
46681 + kfree(eth_node->tx_dma_ring);
46682 + err = -ENOMEM;
46683 + break;
46684 + }
46685 + priv = netdev_priv(dev);
46686 + priv->dev = dev;
46687 +
46688 + /*
46689 + * This just fill in some default Ubicom MAC address
46690 + */
46691 + memcpy(dev->dev_addr, mac_addr[i], ETH_ALEN);
46692 + memset(dev->broadcast, 0xff, ETH_ALEN);
46693 +
46694 + priv->regs = eth_node;
46695 + priv->regs->command = 0;
46696 + priv->regs->int_mask = 0;
46697 + priv->regs->int_status = 0;
46698 + priv->regs->tx_out = 0;
46699 + priv->regs->rx_out = 0;
46700 + priv->regs->tx_in = 0;
46701 + priv->regs->rx_in = 0;
46702 + priv->rx_tail = 0;
46703 + priv->tx_tail = 0;
46704 +
46705 + priv->vp_int_bit = eth_node->dn.sendirq;
46706 + dev->irq = eth_node->dn.recvirq;
46707 +
46708 + spin_lock_init(&priv->lock);
46709 +
46710 + dev->open = ubi32_eth_open;
46711 + dev->stop = ubi32_eth_close;
46712 + dev->hard_start_xmit = ubi32_eth_start_xmit;
46713 + dev->tx_timeout = ubi32_eth_tx_timeout;
46714 + dev->watchdog_timeo = UBI32_ETH_VP_TX_TIMEOUT;
46715 +
46716 + dev->set_config = ubi32_eth_set_config;
46717 + dev->do_ioctl = ubi32_eth_ioctl;
46718 + dev->get_stats = ubi32_eth_get_stats;
46719 + dev->change_mtu = ubi32_eth_change_mtu;
46720 +#ifdef UBICOM32_USE_NAPI
46721 + netif_napi_add(dev, &priv->napi, ubi32_eth_napi_poll, UBI32_ETH_NAPI_WEIGHT);
46722 +#endif
46723 + err = register_netdev(dev);
46724 + if (err) {
46725 + printk(KERN_WARNING "Failed to register netdev %s\n", eth_if_name[i]);
46726 + //release_region();
46727 + free_netdev(dev);
46728 + kfree(eth_node->tx_dma_ring);
46729 + break;
46730 + }
46731 +
46732 + ubi32_eth_devices[i] = dev;
46733 + printk(KERN_INFO "%s vp_base:0x%p, tio_int:%d irq:%d feature:0x%lx\n",
46734 + dev->name, priv->regs, eth_node->dn.sendirq, dev->irq, dev->features);
46735 + }
46736 +
46737 + if (err) {
46738 + ubi32_eth_cleanup();
46739 + return err;
46740 + }
46741 +
46742 + if (!ubi32_eth_devices[0] && !ubi32_eth_devices[1]) {
46743 + return -ENODEV;
46744 + }
46745 +
46746 +#if defined(UBICOM32_USE_POLLING)
46747 + init_timer(&eth_poll_timer);
46748 + eth_poll_timer.function = ubi32_eth_poll;
46749 + eth_poll_timer.data = (unsigned long)0;
46750 + eth_poll_timer.expires = jiffies + 2;
46751 + add_timer(&eth_poll_timer);
46752 +#endif
46753 +
46754 + return 0;
46755 +}
46756 +
46757 +module_init(ubi32_eth_init_module);
46758 +module_exit(ubi32_eth_cleanup);
46759 +
46760 +MODULE_AUTHOR("Kan Yan, Greg Ren");
46761 +MODULE_LICENSE("GPL");
46762 diff -ruN linux-2.6.30.10/drivers/net/ubi32-eth.h linux-2.6.30.10-ubi/drivers/net/ubi32-eth.h
46763 --- linux-2.6.30.10/drivers/net/ubi32-eth.h 1970-01-01 02:00:00.000000000 +0200
46764 +++ linux-2.6.30.10-ubi/drivers/net/ubi32-eth.h 2009-12-11 11:45:18.000000000 +0200
46765 @@ -0,0 +1,132 @@
46766 +/*
46767 + * drivers/net/ubi32-eth.h
46768 + * Ubicom32 ethernet TIO interface driver definitions.
46769 + *
46770 + * (C) Copyright 2009, Ubicom, Inc.
46771 + *
46772 + * This file is part of the Ubicom32 Linux Kernel Port.
46773 + *
46774 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
46775 + * it and/or modify it under the terms of the GNU General Public License
46776 + * as published by the Free Software Foundation, either version 2 of the
46777 + * License, or (at your option) any later version.
46778 + *
46779 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
46780 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
46781 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
46782 + * the GNU General Public License for more details.
46783 + *
46784 + * You should have received a copy of the GNU General Public License
46785 + * along with the Ubicom32 Linux Kernel Port. If not,
46786 + * see <http://www.gnu.org/licenses/>.
46787 + *
46788 + * Ubicom32 implementation derived from (with many thanks):
46789 + * arch/m68knommu
46790 + * arch/blackfin
46791 + * arch/parisc
46792 + */
46793 +#ifndef _UBI32_ETH_H
46794 +#define _UBI32_ETH_H
46795 +
46796 +#include <asm/devtree.h>
46797 +
46798 +#define UBI32_ETH_NUM_OF_DEVICES 2
46799 +
46800 +/*
46801 + * Number of bytes trashed beyond the packet data.
46802 + */
46803 +#define UBI32_ETH_TRASHED_MEMORY (CACHE_LINE_SIZE + ETH_HLEN - 1)
46804 +
46805 +/*
46806 + * Linux already reserves NET_SKB_PAD bytes of headroom in each sk_buff.
46807 + * We want to be able to reserve at least one cache line to align Ethernet
46808 + * and IP header to cache line.
46809 + * Note that the TIO expects a CACHE_LINE_SIZE - ETH_HLEN aligned Ethernet
46810 + * header, while satisfies NET_IP_ALIGN (= 2) automatically.
46811 + * (NET_SKB_PAD is 16, NET_IP_ALIGN is 2, CACHE_LINE_SIZE is 32).
46812 + * You can add more space by making UBI32_ETH_RESERVE_EXTRA != 0.
46813 + */
46814 +#define UBI32_ETH_RESERVE_EXTRA (1 * CACHE_LINE_SIZE)
46815 +#define UBI32_ETH_RESERVE_SPACE (UBI32_ETH_RESERVE_EXTRA + CACHE_LINE_SIZE)
46816 +
46817 +struct ubi32_eth_dma_desc {
46818 + volatile void *data_pointer; /* pointer to the buffer */
46819 + volatile u16 buffer_len; /* the buffer size */
46820 + volatile u16 data_len; /* actual frame length */
46821 + volatile u32 status; /* bit0: status to be update by VP; bit[31:1] time stamp */
46822 +};
46823 +
46824 +#define TX_DMA_RING_SIZE (1<<8)
46825 +#define TX_DMA_RING_MASK (TX_DMA_RING_SIZE - 1)
46826 +#define RX_DMA_RING_SIZE (1<<8)
46827 +#define RX_DMA_RING_MASK (RX_DMA_RING_SIZE - 1)
46828 +
46829 +#define RX_DMA_MAX_QUEUE_SIZE (RX_DMA_RING_SIZE - 1) /* no more than (RX_DMA_RING_SIZE - 1) */
46830 +#define RX_MAX_PKT_SIZE (ETH_DATA_LEN + ETH_HLEN + VLAN_HLEN)
46831 +#define RX_MIN_PKT_SIZE ETH_ZLEN
46832 +#define RX_BUF_SIZE (RX_MAX_PKT_SIZE + VLAN_HLEN) /* allow double VLAN tag */
46833 +
46834 +#define UBI32_ETH_VP_TX_TIMEOUT (10*HZ)
46835 +
46836 +struct ubi32_eth_vp_stats {
46837 + u32 rx_alloc_err;
46838 + u32 tx_q_full_cnt;
46839 + u32 rx_q_full_cnt;
46840 + u32 rx_throttle;
46841 +};
46842 +
46843 +struct ubi32_eth_private {
46844 + struct net_device *dev;
46845 + struct ubi32_eth_vp_stats vp_stats;
46846 + spinlock_t lock;
46847 +#ifdef UBICOM32_USE_NAPI
46848 + struct napi_struct napi;
46849 +#else
46850 + struct tasklet_struct tsk;
46851 +#endif
46852 + struct ethtionode *regs;
46853 + u16 rx_tail;
46854 + u16 tx_tail;
46855 + u32 vp_int_bit;
46856 +};
46857 +
46858 +struct ethtionode {
46859 + struct devtree_node dn;
46860 + volatile u16 command;
46861 + volatile u16 status;
46862 + volatile u16 int_mask; /* interrupt mask */
46863 + volatile u16 int_status; /* interrupt mask */
46864 + volatile u16 tx_in; /* owned by driver */
46865 + volatile u16 tx_out; /* owned by vp */
46866 + volatile u16 rx_in; /* owned by driver */
46867 + volatile u16 rx_out; /* owned by vp */
46868 + u16 tx_sz; /* owned by driver */
46869 + u16 rx_sz; /* owned by driver */
46870 + struct ubi32_eth_dma_desc **tx_dma_ring;
46871 + struct ubi32_eth_dma_desc **rx_dma_ring;
46872 +};
46873 +
46874 +#define UBI32_ETH_VP_STATUS_LINK (1<<0)
46875 +#define UBI32_ETH_VP_STATUS_SPEED100 (0x1<<1)
46876 +#define UBI32_ETH_VP_STATUS_SPEED1000 (0x1<<2)
46877 +#define UBI32_ETH_VP_STATUS_DUPLEX (0x1<<3)
46878 +#define UBI32_ETH_VP_STATUS_FLOW_CTRL (0x1<<4)
46879 +
46880 +#define UBI32_ETH_VP_STATUS_RX_STATE (0x1<<5)
46881 +#define UBI32_ETH_VP_STATUS_TX_STATE (0x1<<6)
46882 +
46883 +#define UBI32_ETH_VP_STATUS_TX_Q_FULL (1<<8)
46884 +
46885 +#define UBI32_ETH_VP_INT_RX (1<<0)
46886 +#define UBI32_ETH_VP_INT_TX (1<<1)
46887 +
46888 +#define UBI32_ETH_VP_CMD_RX_ENABLE (1<<0)
46889 +#define UBI32_ETH_VP_CMD_TX_ENABLE (1<<1)
46890 +
46891 +#define UBI32_ETH_VP_RX_OK (1<<0)
46892 +#define UBI32_ETH_VP_TX_OK (1<<1)
46893 +
46894 +#define UBI32_TX_BOUND TX_DMA_RING_SIZE
46895 +#define UBI32_RX_BOUND 64
46896 +#define UBI32_ETH_NAPI_WEIGHT 64 /* for GigE */
46897 +#endif
46898 diff -ruN linux-2.6.30.10/drivers/net/usb/asix.c linux-2.6.30.10-ubi/drivers/net/usb/asix.c
46899 --- linux-2.6.30.10/drivers/net/usb/asix.c 2009-12-04 08:00:07.000000000 +0200
46900 +++ linux-2.6.30.10-ubi/drivers/net/usb/asix.c 2009-12-11 11:45:18.000000000 +0200
46901 @@ -319,14 +319,33 @@
46902 /* get the packet length */
46903 size = (u16) (header & 0x0000ffff);
46904
46905 - if ((skb->len) - ((size + 1) & 0xfffe) == 0)
46906 + if ((skb->len) - ((size + 1) & 0xfffe) == 0) {
46907 +#ifndef HAVE_EFFICIENT_UNALIGNED_ACCESS
46908 + if (((u32)packet & 0x02) == 0) {
46909 + memmove(packet - 2, packet, size);
46910 + skb->data -= 2;
46911 + skb->tail -= 2;
46912 + }
46913 +#endif
46914 return 2;
46915 + }
46916 +
46917 if (size > ETH_FRAME_LEN) {
46918 deverr(dev,"asix_rx_fixup() Bad RX Length %d", size);
46919 return 0;
46920 }
46921 ax_skb = skb_clone(skb, GFP_ATOMIC);
46922 if (ax_skb) {
46923 +#ifndef HAVE_EFFICIENT_UNALIGNED_ACCESS
46924 + if (((u32)packet & 0x02) == 0) {
46925 + memmove(packet - 2, packet, size);
46926 + ax_skb->data = packet - 2;
46927 + } else {
46928 + ax_skb->data = packet;
46929 + }
46930 +#else
46931 + ax_skb->data = packet;
46932 +#endif
46933 ax_skb->len = size;
46934 ax_skb->data = packet;
46935 skb_set_tail_pointer(ax_skb, size);
46936 @@ -1125,13 +1144,19 @@
46937 mode = AX88178_MEDIUM_DEFAULT;
46938
46939 if (ecmd.speed == SPEED_1000)
46940 +#ifdef HAVE_EFFICIENT_UNALIGNED_ACCESS
46941 mode |= AX_MEDIUM_GM;
46942 +#else
46943 + mode |= AX_MEDIUM_GM | AX_MEDIUM_ENCK;
46944 +#endif
46945 else if (ecmd.speed == SPEED_100)
46946 mode |= AX_MEDIUM_PS;
46947 else
46948 mode &= ~(AX_MEDIUM_PS | AX_MEDIUM_GM);
46949
46950 +#ifdef HAVE_EFFICIENT_UNALIGNED_ACCESS
46951 mode |= AX_MEDIUM_ENCK;
46952 +#endif
46953
46954 if (ecmd.duplex == DUPLEX_FULL)
46955 mode |= AX_MEDIUM_FD;
46956 diff -ruN linux-2.6.30.10/drivers/oprofile/cpu_buffer.c linux-2.6.30.10-ubi/drivers/oprofile/cpu_buffer.c
46957 --- linux-2.6.30.10/drivers/oprofile/cpu_buffer.c 2009-12-04 08:00:07.000000000 +0200
46958 +++ linux-2.6.30.10-ubi/drivers/oprofile/cpu_buffer.c 2009-12-11 11:45:18.000000000 +0200
46959 @@ -328,10 +328,10 @@
46960 }
46961
46962 static inline void
46963 -__oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
46964 - unsigned long event, int is_kernel)
46965 +__oprofile_add_ext_sample_cpu(unsigned long pc, struct pt_regs * const regs,
46966 + unsigned long event, int is_kernel, int cpu)
46967 {
46968 - struct oprofile_cpu_buffer *cpu_buf = &__get_cpu_var(cpu_buffer);
46969 + struct oprofile_cpu_buffer *cpu_buf = &per_cpu(cpu_buffer, cpu);
46970 unsigned long backtrace = oprofile_backtrace_depth;
46971
46972 /*
46973 @@ -353,7 +353,8 @@
46974 void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
46975 unsigned long event, int is_kernel)
46976 {
46977 - __oprofile_add_ext_sample(pc, regs, event, is_kernel);
46978 + __oprofile_add_ext_sample_cpu(pc, regs, event,
46979 + is_kernel, smp_processor_id());
46980 }
46981
46982 void oprofile_add_sample(struct pt_regs * const regs, unsigned long event)
46983 @@ -361,7 +362,8 @@
46984 int is_kernel = !user_mode(regs);
46985 unsigned long pc = profile_pc(regs);
46986
46987 - __oprofile_add_ext_sample(pc, regs, event, is_kernel);
46988 + __oprofile_add_ext_sample_cpu(pc, regs, event,
46989 + is_kernel, smp_processor_id());
46990 }
46991
46992 /*
46993 diff -ruN linux-2.6.30.10/drivers/pci/Makefile linux-2.6.30.10-ubi/drivers/pci/Makefile
46994 --- linux-2.6.30.10/drivers/pci/Makefile 2009-12-04 08:00:07.000000000 +0200
46995 +++ linux-2.6.30.10-ubi/drivers/pci/Makefile 2009-12-11 11:45:18.000000000 +0200
46996 @@ -44,8 +44,8 @@
46997 obj-$(CONFIG_MIPS) += setup-bus.o setup-irq.o
46998 obj-$(CONFIG_X86_VISWS) += setup-irq.o
46999 obj-$(CONFIG_MN10300) += setup-bus.o
47000 +obj-$(CONFIG_UBICOM32) += setup-bus.o setup-irq.o
47001
47002 -#
47003 # ACPI Related PCI FW Functions
47004 #
47005 obj-$(CONFIG_ACPI) += pci-acpi.o
47006 diff -ruN linux-2.6.30.10/drivers/serial/Kconfig linux-2.6.30.10-ubi/drivers/serial/Kconfig
47007 --- linux-2.6.30.10/drivers/serial/Kconfig 2009-12-04 08:00:07.000000000 +0200
47008 +++ linux-2.6.30.10-ubi/drivers/serial/Kconfig 2009-12-11 11:45:19.000000000 +0200
47009 @@ -871,6 +871,57 @@
47010 console (the system console is the device which receives all kernel
47011 messages and warnings and which allows logins in single user mode).
47012
47013 +config SERIAL_UBI32_UARTTIO
47014 + tristate "Ubicom UARTTIO support"
47015 + depends on UBICOM32=y
47016 + select SERIAL_CORE
47017 + default y
47018 + help
47019 + Add support for the Ubicom virtual peripherial serial interface.
47020 +
47021 +config SERIAL_UBI32_UARTTIO_NR_UARTS
47022 + int "Maximum number of UARTTIO virtual serial ports"
47023 + depends on SERIAL_UBI32_UARTTIO
47024 + default "4"
47025 + help
47026 + Set this to the maximum number of serial ports you want the driver to support.
47027 +
47028 +config SERIAL_UBI32_UARTTIO_CONSOLE
47029 + tristate "Ubicom UARTTIO console support"
47030 + depends on SERIAL_UBI32_UARTTIO=y
47031 + select SERIAL_CORE_CONSOLE
47032 + default y
47033 + help
47034 + Add support for console on the Ubicom virtual peripherial serial interface.
47035 +
47036 +config SERIAL_UBI32_SERDES
47037 + bool "Ubicom serial port support"
47038 + depends on UBICOM32=y
47039 + select SERIAL_CORE
47040 + default y
47041 + help
47042 + Add support for the Ubicom serial interface.
47043 +
47044 +config SERIAL_UBI32_SERDES_CONSOLE
47045 + bool "Ubicom serial console support"
47046 + depends on SERIAL_UBI32_SERDES=y
47047 + select SERIAL_CORE_CONSOLE
47048 + default y
47049 +
47050 +config SERIAL_UBI32_MAILBOX
47051 + bool "Ubicom mailbox support"
47052 + depends on UBICOM32=y
47053 + select SERIAL_CORE
47054 + default n
47055 + help
47056 + Add support for the Ubicom mailbox interface.
47057 +
47058 +config SERIAL_UBI32_MAILBOX_CONSOLE
47059 + bool "Ubicom mailbox console support"
47060 + depends on SERIAL_UBI32_MAILBOX=y
47061 + select SERIAL_CORE_CONSOLE
47062 + default y
47063 +
47064 config SERIAL_SUNCORE
47065 bool
47066 depends on SPARC
47067 diff -ruN linux-2.6.30.10/drivers/serial/Makefile linux-2.6.30.10-ubi/drivers/serial/Makefile
47068 --- linux-2.6.30.10/drivers/serial/Makefile 2009-12-04 08:00:07.000000000 +0200
47069 +++ linux-2.6.30.10-ubi/drivers/serial/Makefile 2009-12-11 11:45:19.000000000 +0200
47070 @@ -77,3 +77,6 @@
47071 obj-$(CONFIG_SERIAL_KS8695) += serial_ks8695.o
47072 obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o
47073 obj-$(CONFIG_SERIAL_QE) += ucc_uart.o
47074 +obj-$(CONFIG_SERIAL_UBI32_SERDES) += ubi32_serdes.o
47075 +obj-$(CONFIG_SERIAL_UBI32_UARTTIO) += ubi32_uarttio.o
47076 +obj-$(CONFIG_SERIAL_UBI32_MAILBOX) += ubi32_mailbox.o
47077 diff -ruN linux-2.6.30.10/drivers/serial/ubi32_mailbox.c linux-2.6.30.10-ubi/drivers/serial/ubi32_mailbox.c
47078 --- linux-2.6.30.10/drivers/serial/ubi32_mailbox.c 1970-01-01 02:00:00.000000000 +0200
47079 +++ linux-2.6.30.10-ubi/drivers/serial/ubi32_mailbox.c 2009-12-11 11:45:19.000000000 +0200
47080 @@ -0,0 +1,928 @@
47081 +/*
47082 + * drivers/serial/ubi32_mailbox.c
47083 + * Ubicom32 On-Chip Mailbox Driver
47084 + *
47085 + * (C) Copyright 2009, Ubicom, Inc.
47086 + *
47087 + * This file is part of the Ubicom32 Linux Kernel Port.
47088 + *
47089 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
47090 + * it and/or modify it under the terms of the GNU General Public License
47091 + * as published by the Free Software Foundation, either version 2 of the
47092 + * License, or (at your option) any later version.
47093 + *
47094 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
47095 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
47096 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
47097 + * the GNU General Public License for more details.
47098 + *
47099 + * You should have received a copy of the GNU General Public License
47100 + * along with the Ubicom32 Linux Kernel Port. If not,
47101 + * see <http://www.gnu.org/licenses/>.
47102 + *
47103 + * Ubicom32 implementation derived from (with many thanks):
47104 + * arch/m68knommu
47105 + * arch/blackfin
47106 + * arch/parisc
47107 + */
47108 +#include <linux/module.h>
47109 +#include <linux/ioport.h>
47110 +#include <linux/init.h>
47111 +#include <linux/console.h>
47112 +#include <linux/sysrq.h>
47113 +#include <linux/platform_device.h>
47114 +#include <linux/tty.h>
47115 +#include <linux/tty_flip.h>
47116 +#include <linux/serial_core.h>
47117 +
47118 +#include <asm/ip5000.h>
47119 +
47120 +#define SERIAL_UBICOM_BAUDRATE 115200
47121 +#define SERIAL_UBICOM_DATA_BIT 8 /* Fixed parameter - do not change */
47122 +#define SERIAL_UBICOM_PAR_BIT 0 /* Fixed parameter - do not change */
47123 +#define SERIAL_UBICOM_STOP_BIT 1 /* Fixed parameter - do not change */
47124 +
47125 +/* UART name and device definitions */
47126 +#define UBI32_MAILBOX_NAME "ttyUM" // XXX
47127 +#define UBI32_MAILBOX_MAJOR 207 // XXX
47128 +#define UBI32_MAILBOX_MINOR 64
47129 +
47130 +#define PORT_UBI32_MAILBOX 1235
47131 +#define NR_PORTS 1
47132 +
47133 +#define get_sclk() 0
47134 +
47135 +struct ubi32_mailbox_port {
47136 + struct uart_port port;
47137 + /*
47138 + * NOTE (rkeller):
47139 + * the uart port is wrapped in another structure in case we need to hold more state than
47140 + * what we can hold in the uart_port.
47141 + * Not sure if we need this, I took over the concept from the blackfin driver.
47142 + */
47143 +} ubi32_mailbox_ports[NR_PORTS];
47144 +
47145 +struct ubi32_mailbox_resource {
47146 + int uart_base_addr;
47147 + int uart_irq;
47148 +} ubi32_mailbox_resource[NR_PORTS] = {
47149 + /*
47150 + * uart_base_addr has to be non-NULL because it is put in the uart_port membase.
47151 + * If membase if null the kernel skips the configuration and our port_type never gets set.
47152 + */
47153 + {ISD_MAILBOX_BASE, ISD_MAILBOX_INT}
47154 +};
47155 +
47156 +static volatile struct ubicom32_isd_mailbox {
47157 + volatile u32_t in;
47158 + volatile u32_t out;
47159 + volatile u32_t status;
47160 +} *ubi32_mailbox = (struct ubicom32_isd_mailbox *)ISD_MAILBOX_BASE;
47161 +
47162 +static void ubi32_mailbox_tx_chars(struct ubi32_mailbox_port *uart);
47163 +
47164 +static void ubi32_mailbox_mctrl_check(struct ubi32_mailbox_port *uart);
47165 +
47166 +#define TRUE 1
47167 +#define FALSE 0
47168 +
47169 +static int mailbox_console_flg = TRUE;
47170 +static int num_timeouts = 0;
47171 +
47172 +/*
47173 + * dummy functions and defined to be able to compile the Blackfin code
47174 + */
47175 +#define UART_GET_LSR(port) (1)
47176 +#define UART_PUT_LSR(port, bits)
47177 +#define UART_CLEAR_LSR(port) (1)
47178 +#define TEMT 1
47179 +#define TFI 1
47180 +#define BI 1
47181 +#define PE 1
47182 +#define OE 1
47183 +#define FE 1
47184 +#define THRE 1
47185 +#define DR 1
47186 +#define UART_GET_LCR(port) (1)
47187 +#define UART_PUT_LCR(port, bits)
47188 +#define SB 1
47189 +#define STB 1
47190 +#define PEN 1
47191 +#define EPS 1
47192 +#define STP 1
47193 +#define WLS(n) 0
47194 +#define UART_GET_IER(port) (1)
47195 +#define UART_SET_IER(port, bits)
47196 +#define UART_CLEAR_IER(port, bits)
47197 +#define ETBEI 0
47198 +#define ERBFI 0
47199 +#define UART_GET_CHAR(port) ubi32_mailbox_get_char()
47200 +#define UART_PUT_CHAR(port, ch) ubi32_mailbox_put_char(ch)
47201 +#define SSYNC()
47202 +#define UART_GET_DLL(port) 0
47203 +#define UART_PUT_DLL(port, ch)
47204 +#define UART_GET_DLH(port) 0
47205 +#define UART_PUT_DLH(port, ch)
47206 +#define UART_GET_GCTL(port) (0)
47207 +#define UART_PUT_GCTL(port, ch)
47208 +#define UCEN 1
47209 +
47210 +/*
47211 + * ubi32_mailbox_get_char_avail()
47212 + */
47213 +static int ubi32_mailbox_get_char_avail(void)
47214 +{
47215 + return !(ubi32_mailbox->status & ISD_MAILBOX_STATUS_IN_EMPTY);
47216 +}
47217 +
47218 +/*
47219 + * ubi32_mailbox_get_char()
47220 + */
47221 +static u32_t ubi32_mailbox_get_char(void)
47222 +{
47223 + if (mailbox_console_flg == TRUE) {
47224 + /*
47225 + * Mailbox console is connected.
47226 + */
47227 + while (ubi32_mailbox->status & ISD_MAILBOX_STATUS_IN_EMPTY);
47228 + return ubi32_mailbox->in & 0xff;
47229 + }
47230 +
47231 + /*
47232 + * Mailbox console was not connected.
47233 + */
47234 + if (ubi32_mailbox->status & ISD_MAILBOX_STATUS_IN_EMPTY) {
47235 + return 0xff;
47236 + }
47237 +
47238 + /*
47239 + * Mailbox console is connecting.
47240 + */
47241 + mailbox_console_flg = TRUE;
47242 + num_timeouts = 0;
47243 + return ubi32_mailbox->in & 0xff;
47244 +}
47245 +
47246 +#define MAILBOX_MAX_ATTEMPTS 1000000
47247 +#define MAILBOX_MAX_TIMEOUTS 5
47248 +/*
47249 + * ubi32_mailbox_put_char()
47250 + */
47251 +static void ubi32_mailbox_put_char(u32_t v)
47252 +{
47253 + /*
47254 + * Wait to be able to output.
47255 + */
47256 + u32_t num_attempts = 0;
47257 +
47258 + if(mailbox_console_flg == TRUE) {
47259 + while(num_attempts++ < MAILBOX_MAX_ATTEMPTS) {
47260 + if(ubi32_mailbox->status & ISD_MAILBOX_STATUS_OUT_EMPTY) {
47261 + break;
47262 + }
47263 + }
47264 +
47265 + /*
47266 + * If timed out more than 5 times on send, mailbox console is disconnected now.
47267 + */
47268 + if (num_attempts > MAILBOX_MAX_ATTEMPTS) {
47269 + if (num_timeouts++ > MAILBOX_MAX_TIMEOUTS) {
47270 + mailbox_console_flg = FALSE;
47271 + }
47272 + }
47273 + }
47274 +
47275 + asm volatile(
47276 + "pipe_flush 0 \n\t"
47277 + "pipe_flush 0 \n\t"
47278 + "pipe_flush 0 \n\t"
47279 + "pipe_flush 0 \n\t"
47280 + "pipe_flush 0 \n\t"
47281 + "pipe_flush 0 \n\t"
47282 + "pipe_flush 0 \n\t"
47283 + );
47284 +
47285 + ubi32_mailbox->out = v & 0xff;
47286 +}
47287 +
47288 +static void ubi32_mailbox_hw_init(struct ubi32_mailbox_port *uart)
47289 +{
47290 +// NOTE: It does not do any good to do these here because we are running on the linux hardware thread,
47291 +// and these have to be called on the ldsr thread.
47292 +// ubicom32_clear_interrupt(ISD_MAILBOX_INT);
47293 +// ubicom32_enable_interrupt(ISD_MAILBOX_INT);
47294 +}
47295 +
47296 +/*
47297 + * interrupts are disabled on entry
47298 + */
47299 +static void ubi32_mailbox_stop_tx(struct uart_port *port)
47300 +{
47301 +// struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47302 +// struct circ_buf *xmit = &uart->port.info->xmit;
47303 +
47304 + while (!(UART_GET_LSR(uart) & TEMT))
47305 + cpu_relax();
47306 +
47307 + /* Clear TFI bit */
47308 + UART_PUT_LSR(uart, TFI);
47309 + UART_CLEAR_IER(uart, ETBEI);
47310 +}
47311 +
47312 +/*
47313 + * port is locked and interrupts are disabled
47314 + */
47315 +static void ubi32_mailbox_start_tx(struct uart_port *port)
47316 +{
47317 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47318 +
47319 + UART_SET_IER(uart, ETBEI);
47320 +
47321 + ubi32_mailbox_tx_chars(uart);
47322 +}
47323 +
47324 +/*
47325 + * Interrupts are enabled
47326 + */
47327 +static void ubi32_mailbox_stop_rx(struct uart_port *port)
47328 +{
47329 +// struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47330 + UART_CLEAR_IER(uart, ERBFI);
47331 +}
47332 +
47333 +/*
47334 + * Set the modem control timer to fire immediately.
47335 + */
47336 +static void ubi32_mailbox_enable_ms(struct uart_port *port)
47337 +{
47338 +}
47339 +
47340 +static void ubi32_mailbox_rx_chars(struct ubi32_mailbox_port *uart)
47341 +{
47342 + struct uart_info *info = uart->port.info;
47343 + struct tty_struct *tty = info->port.tty;
47344 + unsigned int status, ch, flg;
47345 +
47346 + status = 0; // XXX? UART_GET_LSR(uart);
47347 + UART_CLEAR_LSR(uart);
47348 +
47349 + ch = UART_GET_CHAR(uart);
47350 +
47351 + if(ch == 0xff)
47352 + return;
47353 +
47354 + uart->port.icount.rx++;
47355 +
47356 + if (status & BI) {
47357 + uart->port.icount.brk++;
47358 + if (uart_handle_break(&uart->port))
47359 + goto ignore_char;
47360 + status &= ~(PE | FE);
47361 + }
47362 + if (status & PE)
47363 + uart->port.icount.parity++;
47364 + if (status & OE)
47365 + uart->port.icount.overrun++;
47366 + if (status & FE)
47367 + uart->port.icount.frame++;
47368 +
47369 + status &= uart->port.read_status_mask;
47370 +
47371 + if (status & BI)
47372 + flg = TTY_BREAK;
47373 + else if (status & PE)
47374 + flg = TTY_PARITY;
47375 + else if (status & FE)
47376 + flg = TTY_FRAME;
47377 + else
47378 + flg = TTY_NORMAL;
47379 +
47380 + if (uart_handle_sysrq_char(&uart->port, ch))
47381 + goto ignore_char;
47382 +
47383 + uart_insert_char(&uart->port, status, OE, ch, flg);
47384 +
47385 + ignore_char:
47386 + tty_flip_buffer_push(tty);
47387 +}
47388 +
47389 +static void ubi32_mailbox_tx_chars(struct ubi32_mailbox_port *uart)
47390 +{
47391 + struct circ_buf *xmit = &uart->port.info->xmit;
47392 +
47393 + if (uart->port.x_char) {
47394 + UART_PUT_CHAR(uart, uart->port.x_char);
47395 + uart->port.icount.tx++;
47396 + uart->port.x_char = 0;
47397 + }
47398 + /*
47399 + * Check the modem control lines before
47400 + * transmitting anything.
47401 + */
47402 + ubi32_mailbox_mctrl_check(uart);
47403 +
47404 + if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
47405 + ubi32_mailbox_stop_tx(&uart->port);
47406 + return;
47407 + }
47408 +
47409 + while ((UART_GET_LSR(uart) & THRE) && xmit->tail != xmit->head) {
47410 + UART_PUT_CHAR(uart, xmit->buf[xmit->tail]);
47411 + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
47412 + uart->port.icount.tx++;
47413 + SSYNC();
47414 + }
47415 +
47416 + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
47417 + uart_write_wakeup(&uart->port);
47418 +
47419 + if (uart_circ_empty(xmit))
47420 + ubi32_mailbox_stop_tx(&uart->port);
47421 +}
47422 +
47423 +static irqreturn_t ubi32_mailbox_isr(int irq, void *dev_id)
47424 +{
47425 + struct ubi32_mailbox_port *uart = dev_id;
47426 +
47427 + spin_lock(&uart->port.lock);
47428 +
47429 + //XXX?while (UART_GET_LSR(uart) & DR)
47430 +
47431 + /*
47432 + * RX process
47433 + */
47434 + while (ubi32_mailbox_get_char_avail()) {
47435 + ubi32_mailbox_rx_chars(uart);
47436 + }
47437 +
47438 +#if 0
47439 + /*
47440 + * TX process
47441 + */
47442 + if (this_uart.tx_in == this_uart.tx_out) {
47443 + UBICOM32_IO_PORT(SERIAL_UBICOM_PORT)->int_mask &= ~IO_PORTX_INT_SERDES_TXBE;
47444 + } else if (UBICOM32_IO_PORT(SERIAL_UBICOM_PORT)->int_status & IO_PORTX_INT_SERDES_TXBE) {
47445 + uart_ubicom32_send(this_uart.tx_buf[this_uart.tx_out & (SERIAL_UBICOM_BUF_SIZE - 1)]);
47446 + this_uart.tx_out++;
47447 + UBICOM32_IO_PORT(SERIAL_UBICOM_PORT)->int_mask |= IO_PORTX_INT_SERDES_TXBE;
47448 + }
47449 +#endif
47450 +
47451 + spin_unlock(&uart->port.lock);
47452 +
47453 + return IRQ_HANDLED;
47454 +}
47455 +#if 0
47456 +static irqreturn_t ubi32_mailbox_tx_int(int irq, void *dev_id)
47457 +{
47458 + struct ubi32_mailbox_port *uart = dev_id;
47459 +
47460 + spin_lock(&uart->port.lock);
47461 + if (UART_GET_LSR(uart) & THRE)
47462 + ubi32_mailbox_tx_chars(uart);
47463 + spin_unlock(&uart->port.lock);
47464 +
47465 + return IRQ_HANDLED;
47466 +}
47467 +#endif
47468 +
47469 +/*
47470 + * Return TIOCSER_TEMT when transmitter is not busy.
47471 + */
47472 +static unsigned int ubi32_mailbox_tx_empty(struct uart_port *port)
47473 +{
47474 +// struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47475 + unsigned short lsr;
47476 +
47477 + lsr = UART_GET_LSR(uart);
47478 + if (lsr & TEMT)
47479 + return TIOCSER_TEMT;
47480 + else
47481 + return 0;
47482 +}
47483 +
47484 +static unsigned int ubi32_mailbox_get_mctrl(struct uart_port *port)
47485 +{
47486 + return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
47487 +}
47488 +
47489 +static void ubi32_mailbox_set_mctrl(struct uart_port *port, unsigned int mctrl)
47490 +{
47491 +}
47492 +
47493 +/*
47494 + * Handle any change of modem status signal since we were last called.
47495 + */
47496 +static void ubi32_mailbox_mctrl_check(struct ubi32_mailbox_port *uart)
47497 +{
47498 +}
47499 +
47500 +/*
47501 + * Interrupts are always disabled.
47502 + */
47503 +static void ubi32_mailbox_break_ctl(struct uart_port *port, int break_state)
47504 +{
47505 +// struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47506 + u16 lcr = UART_GET_LCR(uart);
47507 + if (break_state)
47508 + lcr |= SB;
47509 + else
47510 + lcr &= ~SB;
47511 + UART_PUT_LCR(uart, lcr);
47512 + SSYNC();
47513 +}
47514 +
47515 +static int ubi32_mailbox_startup(struct uart_port *port)
47516 +{
47517 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47518 +
47519 + if (request_irq(uart->port.irq, ubi32_mailbox_isr, IRQF_DISABLED,
47520 + "UBI32_MAILBOX", uart)) {
47521 + printk(KERN_NOTICE "Unable to attach Ubicom32 SERDES interrupt\n");
47522 + return -EBUSY;
47523 + }
47524 +
47525 + UART_SET_IER(uart, ERBFI);
47526 + return 0;
47527 +}
47528 +
47529 +static void ubi32_mailbox_shutdown(struct uart_port *port)
47530 +{
47531 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47532 +
47533 + free_irq(uart->port.irq, uart);
47534 +}
47535 +
47536 +static void
47537 +ubi32_mailbox_set_termios(struct uart_port *port, struct ktermios *termios,
47538 + struct ktermios *old)
47539 +{
47540 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47541 + unsigned long flags;
47542 + unsigned int baud, quot;
47543 + unsigned short val, ier, lsr, lcr = 0;
47544 +
47545 + switch (termios->c_cflag & CSIZE) {
47546 + case CS8:
47547 + lcr = WLS(8);
47548 + break;
47549 + case CS7:
47550 + lcr = WLS(7);
47551 + break;
47552 + case CS6:
47553 + lcr = WLS(6);
47554 + break;
47555 + case CS5:
47556 + lcr = WLS(5);
47557 + break;
47558 + default:
47559 + printk(KERN_ERR "%s: word lengh not supported\n",
47560 + __FUNCTION__);
47561 + }
47562 +
47563 + if (termios->c_cflag & CSTOPB)
47564 + lcr |= STB;
47565 + if (termios->c_cflag & PARENB)
47566 + lcr |= PEN;
47567 + if (!(termios->c_cflag & PARODD))
47568 + lcr |= EPS;
47569 + if (termios->c_cflag & CMSPAR)
47570 + lcr |= STP;
47571 +
47572 + port->read_status_mask = OE;
47573 + if (termios->c_iflag & INPCK)
47574 + port->read_status_mask |= (FE | PE);
47575 + if (termios->c_iflag & (BRKINT | PARMRK))
47576 + port->read_status_mask |= BI;
47577 +
47578 + /*
47579 + * Characters to ignore
47580 + */
47581 + port->ignore_status_mask = 0;
47582 + if (termios->c_iflag & IGNPAR)
47583 + port->ignore_status_mask |= FE | PE;
47584 + if (termios->c_iflag & IGNBRK) {
47585 + port->ignore_status_mask |= BI;
47586 + /*
47587 + * If we're ignoring parity and break indicators,
47588 + * ignore overruns too (for real raw support).
47589 + */
47590 + if (termios->c_iflag & IGNPAR)
47591 + port->ignore_status_mask |= OE;
47592 + }
47593 +
47594 + baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
47595 + quot = uart_get_divisor(port, baud);
47596 + spin_lock_irqsave(&uart->port.lock, flags);
47597 +
47598 + do {
47599 + lsr = UART_GET_LSR(uart);
47600 + } while (!(lsr & TEMT));
47601 +
47602 + /* Disable UART */
47603 + ier = UART_GET_IER(uart);
47604 + UART_CLEAR_IER(uart, 0xF);
47605 +
47606 + UART_PUT_DLL(uart, quot & 0xFF);
47607 + SSYNC();
47608 + UART_PUT_DLH(uart, (quot >> 8) & 0xFF);
47609 + SSYNC();
47610 +
47611 + UART_PUT_LCR(uart, lcr);
47612 +
47613 + /* Enable UART */
47614 + UART_SET_IER(uart, ier);
47615 +
47616 + val = UART_GET_GCTL(uart);
47617 + val |= UCEN;
47618 + UART_PUT_GCTL(uart, val);
47619 +
47620 + spin_unlock_irqrestore(&uart->port.lock, flags);
47621 +}
47622 +
47623 +static const char *ubi32_mailbox_type(struct uart_port *port)
47624 +{
47625 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47626 +
47627 + return uart->port.type == PORT_UBI32_MAILBOX ? "UBI32_MAILBOX" : NULL;
47628 +}
47629 +
47630 +/*
47631 + * Release the memory region(s) being used by 'port'.
47632 + */
47633 +static void ubi32_mailbox_release_port(struct uart_port *port)
47634 +{
47635 +}
47636 +
47637 +/*
47638 + * Request the memory region(s) being used by 'port'.
47639 + */
47640 +static int ubi32_mailbox_request_port(struct uart_port *port)
47641 +{
47642 + return 0;
47643 +}
47644 +
47645 +/*
47646 + * Configure/autoconfigure the port.
47647 + */
47648 +static void ubi32_mailbox_config_port(struct uart_port *port, int flags)
47649 +{
47650 + struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47651 +
47652 + if (flags & UART_CONFIG_TYPE && ubi32_mailbox_request_port(&uart->port) == 0)
47653 + uart->port.type = PORT_UBI32_MAILBOX;
47654 +}
47655 +
47656 +/*
47657 + * Verify the new serial_struct (for TIOCSSERIAL).
47658 + * The only change we allow are to the flags and type, and
47659 + * even then only between PORT_UBI32_MAILBOX and PORT_UNKNOWN
47660 + */
47661 +static int
47662 +ubi32_mailbox_verify_port(struct uart_port *port, struct serial_struct *ser)
47663 +{
47664 + return 0;
47665 +}
47666 +
47667 +static struct uart_ops ubi32_mailbox_pops = {
47668 + .tx_empty = ubi32_mailbox_tx_empty,
47669 + .set_mctrl = ubi32_mailbox_set_mctrl,
47670 + .get_mctrl = ubi32_mailbox_get_mctrl,
47671 + .stop_tx = ubi32_mailbox_stop_tx,
47672 + .start_tx = ubi32_mailbox_start_tx,
47673 + .stop_rx = ubi32_mailbox_stop_rx,
47674 + .enable_ms = ubi32_mailbox_enable_ms,
47675 + .break_ctl = ubi32_mailbox_break_ctl,
47676 + .startup = ubi32_mailbox_startup,
47677 + .shutdown = ubi32_mailbox_shutdown,
47678 + .set_termios = ubi32_mailbox_set_termios,
47679 + .type = ubi32_mailbox_type,
47680 + .release_port = ubi32_mailbox_release_port,
47681 + .request_port = ubi32_mailbox_request_port,
47682 + .config_port = ubi32_mailbox_config_port,
47683 + .verify_port = ubi32_mailbox_verify_port,
47684 +};
47685 +
47686 +static void __init ubi32_mailbox_init_ports(void)
47687 +{
47688 + static int first = 1;
47689 + int i;
47690 +
47691 + if (!first)
47692 + return;
47693 + first = 0;
47694 +
47695 + for (i = 0; i < NR_PORTS; i++) {
47696 + ubi32_mailbox_ports[i].port.uartclk = get_sclk();
47697 + ubi32_mailbox_ports[i].port.ops = &ubi32_mailbox_pops;
47698 + ubi32_mailbox_ports[i].port.line = i;
47699 + ubi32_mailbox_ports[i].port.iotype = UPIO_MEM;
47700 + ubi32_mailbox_ports[i].port.membase =
47701 + (void __iomem *)ubi32_mailbox_resource[i].uart_base_addr;
47702 + ubi32_mailbox_ports[i].port.mapbase =
47703 + ubi32_mailbox_resource[i].uart_base_addr;
47704 + ubi32_mailbox_ports[i].port.irq =
47705 + ubi32_mailbox_resource[i].uart_irq;
47706 + ubi32_mailbox_ports[i].port.flags = UPF_BOOT_AUTOCONF;
47707 + spin_lock_init(&ubi32_mailbox_ports[i].port.lock);
47708 +
47709 + ubi32_mailbox_hw_init(&ubi32_mailbox_ports[i]);
47710 + }
47711 +
47712 +}
47713 +
47714 +#ifdef CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE
47715 +/*
47716 + * If the port was already initialised (eg, by a boot loader),
47717 + * try to determine the current setup.
47718 + */
47719 +static void __init
47720 +ubi32_mailbox_console_get_options(struct ubi32_mailbox_port *uart, int *baud,
47721 + int *parity, int *bits)
47722 +{
47723 + unsigned short status;
47724 +
47725 + status = UART_GET_IER(uart) & (ERBFI | ETBEI);
47726 + if (status == (ERBFI | ETBEI)) {
47727 + /* ok, the port was enabled */
47728 + unsigned short lcr;
47729 + unsigned short dlh, dll;
47730 +
47731 + lcr = UART_GET_LCR(uart);
47732 +
47733 + *parity = 'n';
47734 + if (lcr & PEN) {
47735 + if (lcr & EPS)
47736 + *parity = 'e';
47737 + else
47738 + *parity = 'o';
47739 + }
47740 + switch (lcr & 0x03) {
47741 + case 0: *bits = 5; break;
47742 + case 1: *bits = 6; break;
47743 + case 2: *bits = 7; break;
47744 + case 3: *bits = 8; break;
47745 + }
47746 +
47747 + dll = UART_GET_DLL(uart);
47748 + dlh = UART_GET_DLH(uart);
47749 +
47750 + *baud = get_sclk() / (16*(dll | dlh << 8));
47751 + }
47752 + pr_debug("%s:baud = %d, parity = %c, bits= %d\n", __FUNCTION__, *baud, *parity, *bits);
47753 +}
47754 +#endif
47755 +
47756 +#if defined(CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
47757 +static struct uart_driver ubi32_mailbox_reg;
47758 +
47759 +static int __init
47760 +ubi32_mailbox_console_setup(struct console *co, char *options)
47761 +{
47762 + struct ubi32_mailbox_port *uart;
47763 +# ifdef CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE
47764 + int baud = SERIAL_UBICOM_BAUDRATE;
47765 + int bits = 8;
47766 + int parity = 'n';
47767 + int flow = 'n';
47768 +# endif
47769 +
47770 + /*
47771 + * Check whether an invalid uart number has been specified, and
47772 + * if so, search for the first available port that does have
47773 + * console support.
47774 + */
47775 + if (co->index == -1 || co->index >= NR_PORTS)
47776 + co->index = 0;
47777 + uart = &ubi32_mailbox_ports[co->index];
47778 +
47779 +# ifdef CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE
47780 + if (options)
47781 + uart_parse_options(options, &baud, &parity, &bits, &flow);
47782 + else
47783 + ubi32_mailbox_console_get_options(uart, &baud, &parity, &bits);
47784 +
47785 + //JB return uart_set_options(&uart->port, co, baud, parity, bits, flow);
47786 + return 0;
47787 +# else
47788 + return 0;
47789 +# endif
47790 +}
47791 +#endif /* defined (CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE) ||
47792 + defined (CONFIG_EARLY_PRINTK) */
47793 +
47794 +#ifdef CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE
47795 +static void ubi32_mailbox_console_putchar(struct uart_port *port, int ch)
47796 +{
47797 +// struct ubi32_mailbox_port *uart = (struct ubi32_mailbox_port *)port;
47798 + while (!(UART_GET_LSR(uart) & THRE))
47799 + barrier();
47800 + UART_PUT_CHAR(uart, ch);
47801 + SSYNC();
47802 +}
47803 +
47804 +/*
47805 + * Interrupts are disabled on entering
47806 + */
47807 +static void
47808 +ubi32_mailbox_console_write(struct console *co, const char *s, unsigned int count)
47809 +{
47810 + struct ubi32_mailbox_port *uart = &ubi32_mailbox_ports[co->index];
47811 + unsigned long flags = 0;
47812 +
47813 + spin_lock_irqsave(&uart->port.lock, flags);
47814 + uart_console_write(&uart->port, s, count, ubi32_mailbox_console_putchar);
47815 + spin_unlock_irqrestore(&uart->port.lock, flags);
47816 +
47817 +}
47818 +
47819 +static struct console ubi32_mailbox_console = {
47820 + .name = UBI32_MAILBOX_NAME,
47821 + .write = ubi32_mailbox_console_write,
47822 + .device = uart_console_device,
47823 + .setup = ubi32_mailbox_console_setup,
47824 + .flags = CON_PRINTBUFFER,
47825 + .index = -1,
47826 + .data = &ubi32_mailbox_reg,
47827 +};
47828 +
47829 +static int __init ubi32_mailbox_console_init(void)
47830 +{
47831 + ubi32_mailbox_init_ports();
47832 + register_console(&ubi32_mailbox_console);
47833 + return 0;
47834 +}
47835 +console_initcall(ubi32_mailbox_console_init);
47836 +
47837 +#define UBI32_MAILBOX_CONSOLE &ubi32_mailbox_console
47838 +#else
47839 +#define UBI32_MAILBOX_CONSOLE NULL
47840 +#endif /* CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE */
47841 +
47842 +
47843 +#ifdef CONFIG_EARLY_PRINTK
47844 +static __init void ubi32_mailbox_early_putc(struct uart_port *port, int ch)
47845 +{
47846 + UART_PUT_CHAR(uart, ch);
47847 +}
47848 +
47849 +static __init void ubi32_mailbox_early_write(struct console *con, const char *s,
47850 + unsigned int n)
47851 +{
47852 + struct ubi32_mailbox_port *uart = &ubi32_mailbox_ports[con->index];
47853 + unsigned int i;
47854 +
47855 + for (i = 0; i < n; i++, s++) {
47856 + if (*s == '\n')
47857 + ubi32_mailbox_early_putc(&uart->port, '\r');
47858 + ubi32_mailbox_early_putc(&uart->port, *s);
47859 + }
47860 +}
47861 +
47862 +static struct __init console ubi32_mailbox_early_console = {
47863 + .name = "early_UM",
47864 + .write = ubi32_mailbox_early_write,
47865 + .device = uart_console_device,
47866 + .flags = CON_PRINTBUFFER,
47867 + .setup = ubi32_mailbox_console_setup,
47868 + .index = -1,
47869 + .data = &ubi32_mailbox_reg,
47870 +};
47871 +
47872 +/*
47873 + * XXX Unused in our driver. Need to find out what the termios initialization is good/needed for.
47874 + */
47875 +struct console __init *ubi32_mailbox_early_init(unsigned int port,
47876 + unsigned int cflag)
47877 +{
47878 + struct ubi32_mailbox_port *uart;
47879 + struct ktermios t;
47880 +
47881 + if (port == -1 || port >= NR_PORTS)
47882 + port = 0;
47883 + ubi32_mailbox_init_ports();
47884 + ubi32_mailbox_early_console.index = port;
47885 + uart = &ubi32_mailbox_ports[port];
47886 + t.c_cflag = cflag;
47887 + t.c_iflag = 0;
47888 + t.c_oflag = 0;
47889 + t.c_lflag = ICANON;
47890 + t.c_line = port;
47891 + ubi32_mailbox_set_termios(&uart->port, &t, &t);
47892 + return &ubi32_mailbox_early_console;
47893 +}
47894 +
47895 +#endif /* CONFIG_SERIAL_UBI32_MAILBOX_CONSOLE */
47896 +
47897 +static struct uart_driver ubi32_mailbox_reg = {
47898 + .owner = THIS_MODULE,
47899 + .driver_name = "ubi32_mailbox",
47900 + .dev_name = UBI32_MAILBOX_NAME,
47901 + .major = UBI32_MAILBOX_MAJOR,
47902 + .minor = UBI32_MAILBOX_MINOR,
47903 + .nr = NR_PORTS,
47904 + .cons = UBI32_MAILBOX_CONSOLE,
47905 +};
47906 +
47907 +static int ubi32_mailbox_suspend(struct platform_device *dev, pm_message_t state)
47908 +{
47909 + struct ubi32_mailbox_port *uart = platform_get_drvdata(dev);
47910 +
47911 + if (uart)
47912 + uart_suspend_port(&ubi32_mailbox_reg, &uart->port);
47913 +
47914 + return 0;
47915 +}
47916 +
47917 +static int ubi32_mailbox_resume(struct platform_device *dev)
47918 +{
47919 + struct ubi32_mailbox_port *uart = platform_get_drvdata(dev);
47920 +
47921 + if (uart)
47922 + uart_resume_port(&ubi32_mailbox_reg, &uart->port);
47923 +
47924 + return 0;
47925 +}
47926 +
47927 +static int ubi32_mailbox_probe(struct platform_device *dev)
47928 +{
47929 + struct resource *res = dev->resource;
47930 + int i;
47931 +
47932 + for (i = 0; i < dev->num_resources; i++, res++)
47933 + if (res->flags & IORESOURCE_MEM)
47934 + break;
47935 +
47936 + if (i < dev->num_resources) {
47937 + for (i = 0; i < NR_PORTS; i++, res++) {
47938 + if (ubi32_mailbox_ports[i].port.mapbase != res->start)
47939 + continue;
47940 + ubi32_mailbox_ports[i].port.dev = &dev->dev;
47941 + uart_add_one_port(&ubi32_mailbox_reg, &ubi32_mailbox_ports[i].port);
47942 + platform_set_drvdata(dev, &ubi32_mailbox_ports[i]);
47943 + }
47944 + }
47945 +
47946 + return 0;
47947 +}
47948 +
47949 +static int ubi32_mailbox_remove(struct platform_device *pdev)
47950 +{
47951 + struct ubi32_mailbox_port *uart = platform_get_drvdata(pdev);
47952 +
47953 + platform_set_drvdata(pdev, NULL);
47954 +
47955 + if (uart)
47956 + uart_remove_one_port(&ubi32_mailbox_reg, &uart->port);
47957 +
47958 + return 0;
47959 +}
47960 +
47961 +static struct platform_driver ubi32_mailbox_driver = {
47962 + .probe = ubi32_mailbox_probe,
47963 + .remove = ubi32_mailbox_remove,
47964 + .suspend = ubi32_mailbox_suspend,
47965 + .resume = ubi32_mailbox_resume,
47966 + .driver = {
47967 + .name = "ubi32-mbox",
47968 + .owner = THIS_MODULE,
47969 + },
47970 +};
47971 +
47972 +static int __init ubi32_mailbox_init(void)
47973 +{
47974 + int ret;
47975 +
47976 + pr_info("Serial: Ubicom32 mailbox serial driver.\n");
47977 +
47978 + mailbox_console_flg = TRUE;
47979 + num_timeouts = 0;
47980 + ubi32_mailbox_init_ports();
47981 +
47982 + ret = uart_register_driver(&ubi32_mailbox_reg);
47983 + if (ret == 0) {
47984 + ret = platform_driver_register(&ubi32_mailbox_driver);
47985 + if (ret) {
47986 + pr_debug("uart register failed\n");
47987 + uart_unregister_driver(&ubi32_mailbox_reg);
47988 + }
47989 + }
47990 +
47991 + /*
47992 + * XXX HACK: currently probe does not get called, but the port needs to be added to work.
47993 + */
47994 + uart_add_one_port(&ubi32_mailbox_reg, &ubi32_mailbox_ports[0].port);
47995 + return ret;
47996 +}
47997 +
47998 +static void __exit ubi32_mailbox_exit(void)
47999 +{
48000 + platform_driver_unregister(&ubi32_mailbox_driver);
48001 + uart_unregister_driver(&ubi32_mailbox_reg);
48002 +}
48003 +
48004 +module_init(ubi32_mailbox_init);
48005 +module_exit(ubi32_mailbox_exit);
48006 +
48007 +MODULE_ALIAS_CHARDEV_MAJOR(UBI32_MAILBOX_MAJOR);
48008 +MODULE_ALIAS("platform:ubi32_mailbox");
48009 diff -ruN linux-2.6.30.10/drivers/serial/ubi32_serdes.c linux-2.6.30.10-ubi/drivers/serial/ubi32_serdes.c
48010 --- linux-2.6.30.10/drivers/serial/ubi32_serdes.c 1970-01-01 02:00:00.000000000 +0200
48011 +++ linux-2.6.30.10-ubi/drivers/serial/ubi32_serdes.c 2009-12-11 11:45:19.000000000 +0200
48012 @@ -0,0 +1,817 @@
48013 +/*
48014 + * drivers/serial/ubi32_serdes.c
48015 + * Ubicom32 On-Chip Serial Driver
48016 + *
48017 + * (C) Copyright 2009, Ubicom, Inc.
48018 + *
48019 + * This file is part of the Ubicom32 Linux Kernel Port.
48020 + *
48021 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
48022 + * it and/or modify it under the terms of the GNU General Public License
48023 + * as published by the Free Software Foundation, either version 2 of the
48024 + * License, or (at your option) any later version.
48025 + *
48026 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
48027 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
48028 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
48029 + * the GNU General Public License for more details.
48030 + *
48031 + * You should have received a copy of the GNU General Public License
48032 + * along with the Ubicom32 Linux Kernel Port. If not,
48033 + * see <http://www.gnu.org/licenses/>.
48034 + *
48035 + * Ubicom32 implementation derived from (with many thanks):
48036 + * arch/m68knommu
48037 + * arch/blackfin
48038 + * arch/parisc
48039 + */
48040 +#include <linux/module.h>
48041 +#include <linux/ioport.h>
48042 +#include <linux/init.h>
48043 +#include <linux/console.h>
48044 +#include <linux/sysrq.h>
48045 +#include <linux/platform_device.h>
48046 +#include <linux/tty.h>
48047 +#include <linux/tty_flip.h>
48048 +#include <linux/serial_core.h>
48049 +
48050 +#include <asm/ip5000.h>
48051 +#include <asm/ubicom32suart.h>
48052 +
48053 +
48054 +#define SERIAL_UBICOM_PIN_RXD (1 << 0)
48055 +#define SERIAL_UBICOM_PIN_TXD (1 << 6)
48056 +#define SERIAL_UBICOM_CTL0 0x8b300000
48057 +#define SERIAL_UBICOM_CTL1 0x00000009
48058 +
48059 +#define SERIAL_UBICOM_DATA_BIT 8 /* Fixed parameter - do not change */
48060 +#define SERIAL_UBICOM_PAR_BIT 0 /* Fixed parameter - do not change */
48061 +#define SERIAL_UBICOM_STOP_BIT 1 /* Fixed parameter - do not change */
48062 +
48063 +/* UART name and device definitions */
48064 +#define UBI32_SERDES_NAME "ttyUS" // XXX
48065 +#define UBI32_SERDES_MAJOR 206 // XXX
48066 +#define UBI32_SERDES_MINOR 64 // XXX
48067 +
48068 +#define PORT_UBI32_SERDES 1234
48069 +#define NR_PORTS 1
48070 +
48071 +struct uart_port ubi32_serdes_ports[NR_PORTS];
48072 +
48073 +struct ubi32_serdes_resource {
48074 + void *uart_base_addr;
48075 + int uart_irq;
48076 + int uart_clock;
48077 +} ubi32_serdes_resource[NR_PORTS] = {
48078 + /*
48079 + * Get params from kernel command line (required for early printk)
48080 + * or from platform resources.
48081 + */
48082 + {0, 0, 0}
48083 +};
48084 +
48085 +/*
48086 + * Can get overridden by 'serdes=' kernel command line.
48087 + */
48088 +static int ubi32_serdes_default_baud_rate = 115200;
48089 +
48090 +
48091 +#define IO_PORT(port) ((struct ubicom32_io_port *)port->membase)
48092 +#define IO_PORT_INT_STATUS(port) (IO_PORT(port)->int_status)
48093 +#define IO_PORT_INT_MASK(port) (IO_PORT(port)->int_mask)
48094 +#define IO_PORT_INT_CLR(port) (IO_PORT(port)->int_clr)
48095 +
48096 +
48097 +/*
48098 + * ubi32_serdes_get_char()
48099 + */
48100 +static u8_t ubi32_serdes_get_char(struct ubicom32_io_port *io_port)
48101 +{
48102 + /*
48103 + * Read from hardware (forced 32-bit atomic read).
48104 + */
48105 + u32_t data = 0;
48106 +
48107 + if ( io_port ) {
48108 + io_port->int_clr = IO_PORTX_INT_SERDES_RXBF;
48109 + asm volatile (
48110 + "move.4 %0, %1 \n\t"
48111 + : "=r" (data)
48112 + : "m" (*(u32_t *)&(io_port->rx_fifo))
48113 + );
48114 + }
48115 +
48116 + return (u8_t)(data & 0x000000ff);
48117 +}
48118 +
48119 +/*
48120 + * ubi32_serdes_put_char()
48121 + */
48122 +static void ubi32_serdes_put_char(struct ubicom32_io_port *io_port, u8_t c)
48123 +{
48124 + u32_t data = 0x0000fe00 | (c << 1);
48125 +
48126 + if ( io_port ) {
48127 + /*
48128 + * Fixed data format:
48129 + * [LSB]1 start bit - 8 data bits - no parity - 1 stop bit[MSB]
48130 + */
48131 + io_port->int_clr = IO_PORTX_INT_SERDES_TXBE;
48132 + io_port->ctl2 = data;
48133 + io_port->int_set = IO_PORTX_INT_SERDES_TXBUF_VALID;
48134 + }
48135 +}
48136 +
48137 +static void ubi32_serdes_hw_init(struct uart_port *port, int baud)
48138 +{
48139 + struct ubicom32_io_port *io_port = IO_PORT(port);
48140 +
48141 + if ( io_port ) {
48142 + /*
48143 + * Put port functions 1-4 into reset state.
48144 + * Function 0 (GPIO) does not need or have a reset bit.
48145 + *
48146 + * Select SERDES function for restart below.
48147 + */
48148 + io_port->function =
48149 + IO_FUNC_FUNCTION_RESET(1) | IO_FUNC_FUNCTION_RESET(2) |
48150 + IO_FUNC_FUNCTION_RESET(3) | IO_FUNC_FUNCTION_RESET(4) |
48151 + IO_PORTX_FUNC_SERDES;
48152 +
48153 + /*
48154 + * Configure SERDES baudrate
48155 + */
48156 + if ( baud == 0 ) {
48157 + baud = ubi32_serdes_default_baud_rate;
48158 + }
48159 +
48160 + io_port->ctl0 =
48161 + SERIAL_UBICOM_CTL0 |
48162 + ((port->uartclk / (16 * baud)) - 1);
48163 +
48164 + io_port->ctl1 =
48165 + SERIAL_UBICOM_CTL1;
48166 +
48167 + /*
48168 + * don't interrupt until startup and start_tx
48169 + */
48170 + io_port->int_mask = 0;
48171 +
48172 + /*
48173 + * Set TXD pin output, RXD input and prevent GPIO
48174 + * override on the TXD & RXD pins
48175 + */
48176 + io_port->gpio_ctl &= ~SERIAL_UBICOM_PIN_RXD;
48177 + io_port->gpio_ctl |= SERIAL_UBICOM_PIN_TXD;
48178 + io_port->gpio_mask &= ~(SERIAL_UBICOM_PIN_RXD | SERIAL_UBICOM_PIN_TXD);
48179 +
48180 + /*
48181 + * Restart (un-reset) the port's SERDES function.
48182 + */
48183 + io_port->function &= ~(IO_FUNC_FUNCTION_RESET(IO_PORTX_FUNC_SERDES));
48184 + }
48185 +}
48186 +
48187 +#define ULITE_STATUS_RXVALID IO_PORTX_INT_SERDES_RXBF
48188 +#define ULITE_STATUS_OVERRUN 0
48189 +#define ULITE_STATUS_FRAME 0
48190 +#define ULITE_STATUS_PARITY 0
48191 +#define ULITE_STATUS_TXEMPTY IO_PORTX_INT_SERDES_TXBE
48192 +#define ULITE_STATUS_TXFULL 0
48193 +
48194 +static int ubi32_serdes_receive(struct uart_port *port, int stat)
48195 +{
48196 + struct tty_struct *tty = port->info->port.tty;
48197 + unsigned char ch = 0;
48198 + char flag = TTY_NORMAL;
48199 +
48200 + if ((stat & (ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
48201 + | ULITE_STATUS_FRAME)) == 0)
48202 + return 0;
48203 +
48204 + /* stats */
48205 + if (stat & ULITE_STATUS_RXVALID) {
48206 + port->icount.rx++;
48207 + ch = ubi32_serdes_get_char((struct ubicom32_io_port *)port->membase);
48208 +
48209 + if (stat & ULITE_STATUS_PARITY)
48210 + port->icount.parity++;
48211 + }
48212 +
48213 + if (stat & ULITE_STATUS_OVERRUN)
48214 + port->icount.overrun++;
48215 +
48216 + if (stat & ULITE_STATUS_FRAME)
48217 + port->icount.frame++;
48218 +
48219 +
48220 + /* drop byte with parity error if IGNPAR specificed */
48221 + if (stat & port->ignore_status_mask & ULITE_STATUS_PARITY)
48222 + stat &= ~ULITE_STATUS_RXVALID;
48223 +
48224 + stat &= port->read_status_mask;
48225 +
48226 + if (stat & ULITE_STATUS_PARITY)
48227 + flag = TTY_PARITY;
48228 +
48229 + stat &= ~port->ignore_status_mask;
48230 +
48231 + if (stat & ULITE_STATUS_RXVALID)
48232 + tty_insert_flip_char(tty, ch, flag);
48233 +
48234 + if (stat & ULITE_STATUS_FRAME)
48235 + tty_insert_flip_char(tty, 0, TTY_FRAME);
48236 +
48237 + if (stat & ULITE_STATUS_OVERRUN)
48238 + tty_insert_flip_char(tty, 0, TTY_OVERRUN);
48239 +
48240 + return 1;
48241 +}
48242 +
48243 +/*
48244 + * interrupts are disabled on entry
48245 + */
48246 +static void ubi32_serdes_stop_tx(struct uart_port *port)
48247 +{
48248 + IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) & ~IO_PORTX_INT_SERDES_TXBE;
48249 +}
48250 +
48251 +static int ubi32_serdes_transmit(struct uart_port *port, int stat)
48252 +{
48253 + struct circ_buf *xmit = &port->info->xmit;
48254 +
48255 + if (!(stat & IO_PORTX_INT_SERDES_TXBE))
48256 + return 0;
48257 +
48258 + if (port->x_char) {
48259 + ubi32_serdes_put_char(IO_PORT(port), port->x_char);
48260 + port->x_char = 0;
48261 + port->icount.tx++;
48262 + return 1;
48263 + }
48264 +
48265 + if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
48266 + ubi32_serdes_stop_tx(port);
48267 + return 0;
48268 + }
48269 +
48270 + ubi32_serdes_put_char(IO_PORT(port), xmit->buf[xmit->tail]);
48271 + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE-1);
48272 + port->icount.tx++;
48273 +
48274 + /* wake up */
48275 + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
48276 + uart_write_wakeup(port);
48277 +
48278 + if (uart_circ_empty(xmit))
48279 + ubi32_serdes_stop_tx(port);
48280 +
48281 + return 1;
48282 +}
48283 +
48284 +/*
48285 + * port is locked and interrupts are disabled
48286 + */
48287 +static void ubi32_serdes_start_tx(struct uart_port *port)
48288 +{
48289 + IO_PORT_INT_MASK(port) = IO_PORT_INT_MASK(port) | IO_PORTX_INT_SERDES_TXBE;
48290 + ubi32_serdes_transmit(port, IO_PORT_INT_STATUS(port));
48291 +}
48292 +
48293 +/*
48294 + * Interrupts are enabled
48295 + */
48296 +static void ubi32_serdes_stop_rx(struct uart_port *port)
48297 +{
48298 + /* don't forward any more data (like !CREAD) */
48299 + port->ignore_status_mask = IO_PORTX_INT_SERDES_RXBF;
48300 +}
48301 +
48302 +/*
48303 + * Set the modem control timer to fire immediately.
48304 + */
48305 +static void ubi32_serdes_enable_ms(struct uart_port *port)
48306 +{
48307 + /* N/A */
48308 +}
48309 +
48310 +static irqreturn_t ubi32_serdes_isr(int irq, void *dev_id)
48311 +{
48312 + struct uart_port *port = dev_id;
48313 + int busy;
48314 +
48315 + spin_lock(&port->lock);
48316 +
48317 + do {
48318 + int stat = IO_PORT_INT_STATUS(port);
48319 + busy = ubi32_serdes_receive(port, stat);
48320 + busy |= ubi32_serdes_transmit(port, stat);
48321 + } while (busy);
48322 +
48323 + tty_flip_buffer_push(port->info->port.tty);
48324 +
48325 + spin_unlock(&port->lock);
48326 +
48327 + return IRQ_HANDLED;
48328 +}
48329 +
48330 +/*
48331 + * Return TIOCSER_TEMT when transmitter is not busy.
48332 + */
48333 +static unsigned int ubi32_serdes_tx_empty(struct uart_port *port)
48334 +{
48335 + unsigned long flags;
48336 + unsigned int ret;
48337 +
48338 + spin_lock_irqsave(&port->lock, flags);
48339 + ret = IO_PORT_INT_STATUS(port);
48340 + spin_unlock_irqrestore(&port->lock, flags);
48341 +
48342 + return ret & ULITE_STATUS_TXEMPTY ? TIOCSER_TEMT : 0;
48343 +}
48344 +
48345 +static unsigned int ubi32_serdes_get_mctrl(struct uart_port *port)
48346 +{
48347 + return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
48348 +}
48349 +
48350 +static void ubi32_serdes_set_mctrl(struct uart_port *port, unsigned int mctrl)
48351 +{
48352 + /* N/A */
48353 +}
48354 +
48355 +/*
48356 + * Interrupts are always disabled.
48357 + */
48358 +static void ubi32_serdes_break_ctl(struct uart_port *port, int break_state)
48359 +{
48360 + /* N/A */
48361 +}
48362 +
48363 +static int ubi32_serdes_startup(struct uart_port *port)
48364 +{
48365 + if (request_irq(port->irq, ubi32_serdes_isr, IRQF_DISABLED,
48366 + "UBI32_SERDES", port)) {
48367 + printk(KERN_NOTICE "Unable to attach port interrupt\n");
48368 + return -EBUSY;
48369 + }
48370 +
48371 + IO_PORT_INT_CLR(port) = IO_PORTX_INT_SERDES_RXBF;
48372 + IO_PORT_INT_MASK(port) = IO_PORTX_INT_SERDES_RXBF;
48373 + return 0;
48374 +}
48375 +
48376 +static void ubi32_serdes_shutdown(struct uart_port *port)
48377 +{
48378 + struct ubi32_serdes_port *uart = (struct ubi32_serdes_port *)port;
48379 +
48380 + IO_PORT_INT_MASK(port) = 0;
48381 + free_irq(port->irq, uart);
48382 +}
48383 +
48384 +static void
48385 +ubi32_serdes_set_termios(struct uart_port *port, struct ktermios *termios,
48386 + struct ktermios *old)
48387 +{
48388 + unsigned long flags;
48389 + unsigned int baud;
48390 +
48391 + spin_lock_irqsave(&port->lock, flags);
48392 +
48393 + port->read_status_mask = ULITE_STATUS_RXVALID | ULITE_STATUS_OVERRUN
48394 + | ULITE_STATUS_TXFULL;
48395 +
48396 + if (termios->c_iflag & INPCK)
48397 + port->read_status_mask |=
48398 + ULITE_STATUS_PARITY | ULITE_STATUS_FRAME;
48399 +
48400 + port->ignore_status_mask = 0;
48401 + if (termios->c_iflag & IGNPAR)
48402 + port->ignore_status_mask |= ULITE_STATUS_PARITY
48403 + | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;
48404 +
48405 + /* ignore all characters if CREAD is not set */
48406 + if ((termios->c_cflag & CREAD) == 0)
48407 + port->ignore_status_mask |=
48408 + ULITE_STATUS_RXVALID | ULITE_STATUS_PARITY
48409 + | ULITE_STATUS_FRAME | ULITE_STATUS_OVERRUN;
48410 +
48411 + /* update timeout */
48412 + baud = uart_get_baud_rate(port, termios, old, 0, 460800);
48413 + uart_update_timeout(port, termios->c_cflag, baud);
48414 +
48415 + IO_PORT(port)->ctl0 = SERIAL_UBICOM_CTL0 |
48416 + ((port->uartclk / (16 * baud)) - 1);
48417 +
48418 + spin_unlock_irqrestore(&port->lock, flags);
48419 +}
48420 +
48421 +static const char *ubi32_serdes_type(struct uart_port *port)
48422 +{
48423 + return port->type == PORT_UBI32_SERDES ? "UBI32_SERDES" : NULL;
48424 +}
48425 +
48426 +/*
48427 + * Release the memory region(s) being used by 'port'.
48428 + */
48429 +static void ubi32_serdes_release_port(struct uart_port *port)
48430 +{
48431 +}
48432 +
48433 +/*
48434 + * Request the memory region(s) being used by 'port'.
48435 + */
48436 +static int ubi32_serdes_request_port(struct uart_port *port)
48437 +{
48438 + return 0;
48439 +}
48440 +
48441 +/*
48442 + * Configure/autoconfigure the port.
48443 + */
48444 +static void ubi32_serdes_config_port(struct uart_port *port, int flags)
48445 +{
48446 + if (flags & UART_CONFIG_TYPE &&
48447 + ubi32_serdes_request_port(port) == 0)
48448 + port->type = PORT_UBI32_SERDES;
48449 +}
48450 +
48451 +/*
48452 + * Verify the new serial_struct (for TIOCSSERIAL).
48453 + * The only change we allow are to the flags and type, and
48454 + * even then only between PORT_UBI32_SERDES and PORT_UNKNOWN
48455 + */
48456 +static int
48457 +ubi32_serdes_verify_port(struct uart_port *port, struct serial_struct *ser)
48458 +{
48459 + return 0;
48460 +}
48461 +
48462 +static struct uart_ops ubi32_serdes_pops = {
48463 + .tx_empty = ubi32_serdes_tx_empty,
48464 + .set_mctrl = ubi32_serdes_set_mctrl,
48465 + .get_mctrl = ubi32_serdes_get_mctrl,
48466 + .stop_tx = ubi32_serdes_stop_tx,
48467 + .start_tx = ubi32_serdes_start_tx,
48468 + .stop_rx = ubi32_serdes_stop_rx,
48469 + .enable_ms = ubi32_serdes_enable_ms,
48470 + .break_ctl = ubi32_serdes_break_ctl,
48471 + .startup = ubi32_serdes_startup,
48472 + .shutdown = ubi32_serdes_shutdown,
48473 + .set_termios = ubi32_serdes_set_termios,
48474 + .type = ubi32_serdes_type,
48475 + .release_port = ubi32_serdes_release_port,
48476 + .request_port = ubi32_serdes_request_port,
48477 + .config_port = ubi32_serdes_config_port,
48478 + .verify_port = ubi32_serdes_verify_port,
48479 +};
48480 +
48481 +static void __init ubi32_serdes_init_ports(void)
48482 +{
48483 + int i;
48484 +
48485 + for (i = 0; i < NR_PORTS; i++) {
48486 + ubi32_serdes_ports[i].uartclk = ubi32_serdes_resource[i].uart_clock;
48487 + ubi32_serdes_ports[i].ops = &ubi32_serdes_pops;
48488 + ubi32_serdes_ports[i].line = i;
48489 + ubi32_serdes_ports[i].iotype = UPIO_MEM;
48490 + ubi32_serdes_ports[i].membase =
48491 + (void __iomem *)ubi32_serdes_resource[i].uart_base_addr;
48492 + ubi32_serdes_ports[i].mapbase =
48493 + (resource_size_t)ubi32_serdes_resource[i].uart_base_addr;
48494 + ubi32_serdes_ports[i].irq =
48495 + ubi32_serdes_resource[i].uart_irq;
48496 + ubi32_serdes_ports[i].flags = UPF_BOOT_AUTOCONF;
48497 +
48498 + ubi32_serdes_hw_init(&ubi32_serdes_ports[i], 0);
48499 + }
48500 +
48501 +}
48502 +
48503 +#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
48504 +/*
48505 + * If the port was already initialised (eg, by a boot loader),
48506 + * try to determine the current setup.
48507 + */
48508 +static void __init
48509 +ubi32_serdes_console_get_options(struct uart_port *port, int *baud)
48510 +{
48511 + u32 round_to = 1200;
48512 + u32 real_baud;
48513 +
48514 + /*
48515 + * We might get called before platform init and with no
48516 + * kernel command line options, so port might be NULL.
48517 + */
48518 + *baud = ubi32_serdes_default_baud_rate;;
48519 + if ( IO_PORT(port) == 0 )
48520 + return;
48521 +
48522 + real_baud = port->uartclk
48523 + / (16 * ((IO_PORT(port)->ctl0 & ~SERIAL_UBICOM_CTL0) + 1));
48524 +
48525 + *baud = ((real_baud + round_to - 1) / round_to) * round_to;
48526 +
48527 + pr_debug("%s:baud = %d, real_baud = %d\n", __FUNCTION__, *baud, real_baud);
48528 +}
48529 +#endif
48530 +
48531 +#if defined(CONFIG_SERIAL_UBI32_SERDES_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
48532 +static struct uart_driver ubi32_serdes_reg;
48533 +
48534 +static int __init
48535 +ubi32_serdes_console_setup(struct console *co, char *options)
48536 +{
48537 + struct uart_port *port;
48538 +#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
48539 + int baud = ubi32_serdes_default_baud_rate;
48540 + int bits = 8;
48541 + int parity = 'n';
48542 + int flow = 'n';
48543 +#endif
48544 +
48545 + /*
48546 + * Check whether an invalid uart number has been specified, and
48547 + * if so, search for the first available port that does have
48548 + * console support.
48549 + */
48550 + if (co->index == -1 || co->index >= NR_PORTS)
48551 + co->index = 0;
48552 + port = &ubi32_serdes_ports[co->index];
48553 +
48554 +#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
48555 + if (options) {
48556 + uart_parse_options(options, &baud, &parity, &bits, &flow);
48557 + ubi32_serdes_hw_init(port, baud);
48558 + }
48559 + else
48560 + ubi32_serdes_console_get_options(port, &baud);
48561 +
48562 + return uart_set_options(port, co, baud, parity, bits, flow);
48563 +#else
48564 + return 0;
48565 +#endif
48566 +}
48567 +#endif /* defined (CONFIG_SERIAL_UBI32_SERDES_CONSOLE) ||
48568 + defined (CONFIG_EARLY_PRINTK) */
48569 +
48570 +#ifdef CONFIG_SERIAL_UBI32_SERDES_CONSOLE
48571 +static void
48572 +ubi32_serdes_console_putchar(struct uart_port *port, int ch)
48573 +{
48574 + if ( IO_PORT(port) ) {
48575 + while (!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE))
48576 + barrier();
48577 + ubi32_serdes_put_char(IO_PORT(port), ch);
48578 + }
48579 +}
48580 +
48581 +/*
48582 + * Interrupts are disabled on entering
48583 + */
48584 +static void
48585 +ubi32_serdes_console_write(struct console *co, const char *s, unsigned int count)
48586 +{
48587 + struct uart_port *port = &ubi32_serdes_ports[co->index];
48588 + unsigned long flags = 0;
48589 +
48590 + spin_lock_irqsave(&port->lock, flags);
48591 + uart_console_write(port, s, count, ubi32_serdes_console_putchar);
48592 + spin_unlock_irqrestore(&port->lock, flags);
48593 +
48594 +}
48595 +
48596 +static struct console ubi32_serdes_console = {
48597 + .name = UBI32_SERDES_NAME,
48598 + .write = ubi32_serdes_console_write,
48599 + .device = uart_console_device,
48600 + .setup = ubi32_serdes_console_setup,
48601 + .flags = CON_PRINTBUFFER,
48602 + .index = -1,
48603 + .data = &ubi32_serdes_reg,
48604 +};
48605 +
48606 +static int __init ubi32_serdes_console_init(void)
48607 +{
48608 + ubi32_serdes_init_ports();
48609 + register_console(&ubi32_serdes_console);
48610 + return 0;
48611 +}
48612 +console_initcall(ubi32_serdes_console_init);
48613 +
48614 +#define UBI32_SERDES_CONSOLE &ubi32_serdes_console
48615 +#else
48616 +#define UBI32_SERDES_CONSOLE NULL
48617 +#endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */
48618 +
48619 +
48620 +#ifdef CONFIG_EARLY_PRINTK
48621 +static __init void ubi32_serdes_early_putc(struct uart_port *port, int ch)
48622 +{
48623 + unsigned timeout = 0xffff;
48624 +
48625 + while ((!(IO_PORT_INT_STATUS(port) & IO_PORTX_INT_SERDES_TXBE)) && --timeout)
48626 + cpu_relax();
48627 + ubi32_serdes_put_char(IO_PORT(port), ch);
48628 +}
48629 +
48630 +static __init void ubi32_serdes_early_write(struct console *con, const char *s,
48631 + unsigned int n)
48632 +{
48633 + struct uart_port *port = &ubi32_serdes_ports[con->index];
48634 + unsigned int i;
48635 +
48636 + for (i = 0; i < n; i++, s++) {
48637 + if (*s == '\n')
48638 + ubi32_serdes_early_putc(port, '\r');
48639 + ubi32_serdes_early_putc(port, *s);
48640 + }
48641 +}
48642 +
48643 +static struct __init console ubi32_serdes_early_console = {
48644 + .name = "early_US",
48645 + .write = ubi32_serdes_early_write,
48646 + .device = uart_console_device,
48647 + .flags = CON_PRINTBUFFER,
48648 + .setup = ubi32_serdes_console_setup,
48649 + .index = -1,
48650 + .data = &ubi32_serdes_reg,
48651 +};
48652 +
48653 +/*
48654 + * XXX Unused in our driver. Need to find out what the termios initialization is good/needed for.
48655 + */
48656 +struct console __init *ubi32_serdes_early_init(unsigned int port_index,
48657 + unsigned int cflag)
48658 +{
48659 + struct uart_port *uart;
48660 + struct ktermios t;
48661 +
48662 + if (port_index == -1 || port_index >= NR_PORTS)
48663 + port_index = 0;
48664 + ubi32_serdes_init_ports();
48665 + ubi32_serdes_early_console.index = port_index;
48666 + uart = &ubi32_serdes_ports[port_index];
48667 + t.c_cflag = cflag;
48668 + t.c_iflag = 0;
48669 + t.c_oflag = 0;
48670 + t.c_lflag = ICANON;
48671 + t.c_line = port_index;
48672 + ubi32_serdes_set_termios(uart, &t, &t);
48673 + return &ubi32_serdes_early_console;
48674 +}
48675 +
48676 +#endif /* CONFIG_SERIAL_UBI32_SERDES_CONSOLE */
48677 +
48678 +static struct uart_driver ubi32_serdes_reg = {
48679 + .owner = THIS_MODULE,
48680 + .driver_name = "ubi32_serdes",
48681 + .dev_name = UBI32_SERDES_NAME,
48682 + .major = UBI32_SERDES_MAJOR,
48683 + .minor = UBI32_SERDES_MINOR,
48684 + .nr = NR_PORTS,
48685 + .cons = UBI32_SERDES_CONSOLE,
48686 +};
48687 +
48688 +static int ubi32_serdes_suspend(struct platform_device *dev, pm_message_t state)
48689 +{
48690 + struct uart_port *port = platform_get_drvdata(dev);
48691 +
48692 + if (port)
48693 + uart_suspend_port(&ubi32_serdes_reg, port);
48694 +
48695 + return 0;
48696 +}
48697 +
48698 +static int ubi32_serdes_resume(struct platform_device *dev)
48699 +{
48700 + struct uart_port *port = platform_get_drvdata(dev);
48701 +
48702 + if (port)
48703 + uart_resume_port(&ubi32_serdes_reg, port);
48704 +
48705 + return 0;
48706 +}
48707 +
48708 +static int ubi32_serdes_probe(struct platform_device *dev)
48709 +{
48710 + struct resource *res = dev->resource;
48711 + int i;
48712 +
48713 + for (i = 0; i < dev->num_resources; i++, res++) {
48714 + if (res->flags & IORESOURCE_MEM) {
48715 + ubi32_serdes_resource[0].uart_base_addr = (void *) res->start;
48716 + }
48717 + else if (res->flags & IORESOURCE_IRQ) {
48718 + ubi32_serdes_resource[0].uart_irq = res->start;
48719 + }
48720 + else if (res->flags & UBICOM32_SUART_IORESOURCE_CLOCK) {
48721 + ubi32_serdes_resource[0].uart_clock = res->start;
48722 + }
48723 + }
48724 +
48725 + ubi32_serdes_init_ports();
48726 +
48727 + return 0;
48728 +}
48729 +
48730 +static int ubi32_serdes_remove(struct platform_device *pdev)
48731 +{
48732 + struct uart_port *port = platform_get_drvdata(pdev);
48733 +
48734 + platform_set_drvdata(pdev, NULL);
48735 +
48736 + if (port)
48737 + uart_remove_one_port(&ubi32_serdes_reg, port);
48738 +
48739 + return 0;
48740 +}
48741 +
48742 +static struct platform_driver ubi32_serdes_driver = {
48743 + .remove = ubi32_serdes_remove,
48744 + .suspend = ubi32_serdes_suspend,
48745 + .resume = ubi32_serdes_resume,
48746 + .driver = {
48747 + .name = "ubicom32suart",
48748 + .owner = THIS_MODULE,
48749 + },
48750 +};
48751 +
48752 +
48753 +#ifndef MODULE
48754 +/*
48755 + * Called at boot time.
48756 + *
48757 + * You can specify IO base, IRQ, and clock for the serdes serial port
48758 + * using kernel command line "serdes=0xiobase,irq,clock". Values
48759 + * specified will be overwritten by platform device data, if present.
48760 + */
48761 +static int __init ubi32_serdes_setup(char *str)
48762 +{
48763 +#define N_PARMS (4+1)
48764 + int ints[N_PARMS];
48765 + int i;
48766 +
48767 + str = get_options(str, ARRAY_SIZE(ints), ints);
48768 +
48769 + for (i = 0; i < N_PARMS; i++) {
48770 + if (i < ints[0]) {
48771 + if (i == 0) {
48772 + ubi32_serdes_resource[0].uart_base_addr = (void *) ints[i+1];
48773 + }
48774 + else if (i == 1) {
48775 + ubi32_serdes_resource[0].uart_irq = ints[i+1];
48776 + }
48777 + else if (i == 2) {
48778 + ubi32_serdes_resource[0].uart_clock = ints[i+1];
48779 + }
48780 + else if (i == 3) {
48781 + ubi32_serdes_default_baud_rate = ints[i+1];
48782 + }
48783 + }
48784 + }
48785 + return 1;
48786 +}
48787 +
48788 +__setup("serdes=", ubi32_serdes_setup);
48789 +#endif
48790 +
48791 +static int __init ubi32_serdes_init(void)
48792 +{
48793 + int ret;
48794 +
48795 + pr_info("Serial: Ubicom32 serdes uart serial driver\n");
48796 +
48797 + ret = platform_driver_probe(&ubi32_serdes_driver, ubi32_serdes_probe);
48798 + if (ret != 0) {
48799 + printk(KERN_INFO "serdes platform_driver_probe() failed: %d\n", ret);
48800 + return ret;
48801 + }
48802 +
48803 + ubi32_serdes_init_ports();
48804 +
48805 + ret = uart_register_driver(&ubi32_serdes_reg);
48806 + if ( ret == 0 ) {
48807 + ret = uart_add_one_port(&ubi32_serdes_reg, &ubi32_serdes_ports[0]);
48808 + if ( ret != 0 ) {
48809 + uart_unregister_driver(&ubi32_serdes_reg);
48810 + }
48811 + }
48812 +
48813 + return ret;
48814 +}
48815 +
48816 +static void __exit ubi32_serdes_exit(void)
48817 +{
48818 + platform_driver_unregister(&ubi32_serdes_driver);
48819 + uart_unregister_driver(&ubi32_serdes_reg);
48820 +}
48821 +
48822 +module_init(ubi32_serdes_init);
48823 +module_exit(ubi32_serdes_exit);
48824 +
48825 +MODULE_AUTHOR("Rainer Keller <rkeller@ubicom.com>");
48826 +MODULE_DESCRIPTION("Ubicom generic serial port driver");
48827 +MODULE_LICENSE("GPL");
48828 +MODULE_ALIAS_CHARDEV_MAJOR(UBI32_SERDES_MAJOR);
48829 +MODULE_ALIAS("platform:ubi32_serdes");
48830 diff -ruN linux-2.6.30.10/drivers/serial/ubi32_uarttio.c linux-2.6.30.10-ubi/drivers/serial/ubi32_uarttio.c
48831 --- linux-2.6.30.10/drivers/serial/ubi32_uarttio.c 1970-01-01 02:00:00.000000000 +0200
48832 +++ linux-2.6.30.10-ubi/drivers/serial/ubi32_uarttio.c 2009-12-11 11:45:19.000000000 +0200
48833 @@ -0,0 +1,1172 @@
48834 +/*
48835 + * drivers/serial/ubi32_uarttio.c
48836 + * Ubicom32 Serial Virtual Peripherial Driver
48837 + *
48838 + * (C) Copyright 2009, Ubicom, Inc.
48839 + *
48840 + * This file is part of the Ubicom32 Linux Kernel Port.
48841 + *
48842 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
48843 + * it and/or modify it under the terms of the GNU General Public License
48844 + * as published by the Free Software Foundation, either version 2 of the
48845 + * License, or (at your option) any later version.
48846 + *
48847 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
48848 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
48849 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
48850 + * the GNU General Public License for more details.
48851 + *
48852 + * You should have received a copy of the GNU General Public License
48853 + * along with the Ubicom32 Linux Kernel Port. If not,
48854 + * see <http://www.gnu.org/licenses/>.
48855 + */
48856 +
48857 +#include <linux/module.h>
48858 +#include <linux/ioport.h>
48859 +#include <linux/init.h>
48860 +#include <linux/console.h>
48861 +#include <linux/sysrq.h>
48862 +#include <linux/platform_device.h>
48863 +#include <linux/tty.h>
48864 +#include <linux/tty_flip.h>
48865 +#include <linux/serial_core.h>
48866 +
48867 +#include <asm/ip5000.h>
48868 +#include <asm/gpio.h>
48869 +#include <asm/thread.h>
48870 +#include <asm/uart_tio.h>
48871 +
48872 +#define DRIVER_NAME "ubi32_uarttio"
48873 +
48874 +/*
48875 + * For storing the module parameters.
48876 + */
48877 +#define UBI32_UARTTIO_MAX_PARAM_LEN 80
48878 +static char utio_ports_param[UBI32_UARTTIO_MAX_PARAM_LEN];
48879 +
48880 +/*
48881 + * UART name and device definitions
48882 + */
48883 +#define UBI32_UARTTIO_NAME "ttyUV" // XXX
48884 +#define UBI32_UARTTIO_MAJOR 206 // XXX
48885 +#define UBI32_UARTTIO_MINOR 64 // XXX
48886 +
48887 +/*
48888 + * The following structures are allocated statically because the
48889 + * memory allocation subsystem is not initialized this early on
48890 + */
48891 +
48892 +/*
48893 + * Per port structure
48894 + */
48895 +struct ubi32_uarttio_port {
48896 + struct uarttio_uart *uart;
48897 + unsigned int tx_pin;
48898 + unsigned int rx_pin;
48899 +
48900 + struct uart_port port;
48901 +
48902 + u8_t added;
48903 +
48904 + /*
48905 + * If this value is set, the port has had its direction set already
48906 + */
48907 + u8_t port_init;
48908 +};
48909 +static struct ubi32_uarttio_port uarttio_ports[CONFIG_SERIAL_UBI32_UARTTIO_NR_UARTS];
48910 +
48911 +/*
48912 + * Number of ports currently initialized
48913 + */
48914 +static int uarttio_nports;
48915 +
48916 +/*
48917 + * Per device structure
48918 + */
48919 +struct ubi32_uarttio_instance {
48920 + struct uarttio_regs *regs;
48921 + struct ubi32_uarttio_port *ports;
48922 +
48923 + u8_t irq_requested;
48924 + u8_t driver_registered;
48925 + u8_t irq;
48926 +};
48927 +static struct ubi32_uarttio_instance uarttio_inst;
48928 +
48929 +#ifdef CONFIG_SERIAL_UBI32_UARTTIO_CONSOLE
48930 +static struct console ubi32_uarttio_console;
48931 +#define UBI32_UARTTIO_CONSOLE &ubi32_uarttio_console
48932 +#else
48933 +#define UBI32_UARTTIO_CONSOLE NULL
48934 +#endif
48935 +
48936 +static struct uart_driver ubi32_uarttio_uart_driver = {
48937 + .owner = THIS_MODULE,
48938 + .driver_name = DRIVER_NAME,
48939 + .dev_name = UBI32_UARTTIO_NAME,
48940 + .major = UBI32_UARTTIO_MAJOR,
48941 + .minor = UBI32_UARTTIO_MINOR,
48942 + .cons = UBI32_UARTTIO_CONSOLE,
48943 +};
48944 +
48945 +#ifdef UBI32_UARTTIO_UNUSED
48946 +/*
48947 + * ubi32_uarttio_get_send_space
48948 + */
48949 +static int ubi32_uarttio_get_send_space(struct uarttio_uart *uart)
48950 +{
48951 + int count = uart->tx_fifo_head - uart->tx_fifo_tail;
48952 + if (count < 0) {
48953 + count += uart->tx_fifo_size;
48954 + }
48955 + return uart->tx_fifo_size - count;
48956 +}
48957 +#endif
48958 +
48959 +/*
48960 + * ubi32_uarttio_get_recv_ready
48961 + */
48962 +static int ubi32_uarttio_get_recv_ready(struct uarttio_uart *uart)
48963 +{
48964 + int count = uart->rx_fifo_head - uart->rx_fifo_tail;
48965 + if (count < 0) {
48966 + count += uart->rx_fifo_size;
48967 + }
48968 + return count;
48969 +}
48970 +
48971 +/*
48972 + * ubi32_uarttio_get_char()
48973 + */
48974 +static u8_t ubi32_uarttio_get_char(struct uarttio_uart *uart)
48975 +{
48976 + /*
48977 + * Retrieve byte
48978 + */
48979 + u32_t tail = uart->rx_fifo_tail;
48980 + u8_t data = uart->rx_fifo[tail];
48981 +
48982 + if (++tail == uart->rx_fifo_size) {
48983 + tail = 0;
48984 + }
48985 + uart->rx_fifo_tail = tail;
48986 +
48987 + return data;
48988 +}
48989 +
48990 +/*
48991 + * ubi32_uarttio_put_char()
48992 + */
48993 +static int ubi32_uarttio_put_char(struct uarttio_uart *uart, u8_t c)
48994 +{
48995 + u32_t head = uart->tx_fifo_head;
48996 + u32_t prev = head;
48997 +
48998 + /*
48999 + * Wrap
49000 + */
49001 + if (++head == uart->tx_fifo_size) {
49002 + head = 0;
49003 + }
49004 +
49005 + /*
49006 + * If there isn't any space, return EBUSY
49007 + */
49008 + if (head == uart->tx_fifo_tail) {
49009 + return -EBUSY;
49010 + }
49011 +
49012 + /*
49013 + * Put the character in the queue
49014 + */
49015 + uart->tx_fifo[prev] = c;
49016 + uart->tx_fifo_head = head;
49017 +
49018 + return 0;
49019 +}
49020 +
49021 +/*
49022 + * ubi32_uarttio_set_baud
49023 + */
49024 +static int ubi32_uarttio_set_baud(struct ubi32_uarttio_port *uup, unsigned int baud)
49025 +{
49026 + if (uup->uart->current_baud_rate == baud) {
49027 + return 0;
49028 + }
49029 +
49030 + uup->uart->baud_rate = baud;
49031 + uup->uart->flags |= UARTTIO_UART_FLAG_SET_RATE;
49032 + while (uup->uart->flags & UARTTIO_UART_FLAG_SET_RATE) {
49033 + cpu_relax();
49034 + }
49035 +
49036 + if (uup->uart->current_baud_rate != baud) {
49037 + /*
49038 + * Failed to set baud rate
49039 + */
49040 + printk(KERN_WARNING "Invalid baud rate %u, running at %u\n", baud, uup->uart->current_baud_rate);
49041 + return -EINVAL;
49042 + }
49043 +
49044 + return 0;
49045 +}
49046 +
49047 +/*
49048 + * ubi32_uarttio_handle_receive
49049 + */
49050 +static void ubi32_uarttio_handle_receive(struct ubi32_uarttio_port *uup, int stat)
49051 +{
49052 + struct uarttio_uart *uart = uup->uart;
49053 + struct uart_port *port = &uup->port;
49054 + struct tty_struct *tty = port->info->port.tty;
49055 + unsigned char ch = 0;
49056 + char flag = TTY_NORMAL;
49057 + int count;
49058 +
49059 + if ((stat & (UARTTIO_UART_INT_RX | UARTTIO_UART_INT_RXFRAME | UARTTIO_UART_INT_RXOVF)) == 0) {
49060 + return;
49061 + }
49062 +
49063 + if (stat & UARTTIO_UART_INT_RX) {
49064 + count = ubi32_uarttio_get_recv_ready(uart);
49065 + port->icount.rx += count;
49066 + }
49067 +
49068 + if (stat & UARTTIO_UART_INT_RXOVF) {
49069 + port->icount.overrun++;
49070 + }
49071 +
49072 + if (stat & UARTTIO_UART_INT_RXFRAME) {
49073 + port->icount.frame++;
49074 + }
49075 +
49076 + stat &= ~port->ignore_status_mask;
49077 +
49078 + if (stat & UARTTIO_UART_INT_RX) {
49079 + int i;
49080 + for (i = 0; i < count; i++) {
49081 + ch = ubi32_uarttio_get_char(uart);
49082 + tty_insert_flip_char(tty, ch, flag);
49083 + }
49084 + }
49085 +
49086 + if (stat & UARTTIO_UART_INT_RXFRAME) {
49087 + tty_insert_flip_char(tty, 0, TTY_FRAME);
49088 + }
49089 +
49090 + if (stat & UARTTIO_UART_INT_RXOVF) {
49091 + tty_insert_flip_char(tty, 0, TTY_OVERRUN);
49092 + }
49093 +}
49094 +
49095 +/*
49096 + * ubi32_uarttio_stop_tx
49097 + * interrupts are disabled on entry
49098 + */
49099 +static void ubi32_uarttio_stop_tx(struct uart_port *port)
49100 +{
49101 + struct ubi32_uarttio_port *uup = port->private_data;
49102 +
49103 + uup->uart->int_mask &= ~UARTTIO_UART_INT_TXBE;
49104 +}
49105 +
49106 +/*
49107 + * ubi32_uarttio_handle_transmit
49108 + */
49109 +static void ubi32_uarttio_handle_transmit(struct ubi32_uarttio_port *uup, int stat)
49110 +{
49111 + struct uarttio_uart *uart = uup->uart;
49112 + struct uart_port *port = &uup->port;
49113 + struct circ_buf *xmit = &port->info->xmit;
49114 +
49115 + if (!(stat & UARTTIO_UART_INT_TXBE)) {
49116 + return;
49117 + }
49118 +
49119 + if (port->x_char) {
49120 + if (ubi32_uarttio_put_char(uart, port->x_char)) {
49121 + return;
49122 + }
49123 + port->x_char = 0;
49124 + port->icount.tx++;
49125 + return;
49126 + }
49127 +
49128 + if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
49129 + ubi32_uarttio_stop_tx(port);
49130 + return;
49131 + }
49132 +
49133 + /*
49134 + * Send as many characters as we can
49135 + */
49136 + while (ubi32_uarttio_put_char(uart, xmit->buf[xmit->tail]) == 0) {
49137 + xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
49138 + port->icount.tx++;
49139 + if (uart_circ_empty(xmit)) {
49140 + break;
49141 + }
49142 + }
49143 +
49144 + /* wake up */
49145 + if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) {
49146 + uart_write_wakeup(port);
49147 + }
49148 +
49149 + if (uart_circ_empty(xmit)) {
49150 + ubi32_uarttio_stop_tx(port);
49151 + }
49152 +}
49153 +
49154 +/*
49155 + * ubi32_uarttio_start_tx
49156 + * port is locked and interrupts are disabled
49157 + */
49158 +static void ubi32_uarttio_start_tx(struct uart_port *port)
49159 +{
49160 + struct ubi32_uarttio_port *uup = port->private_data;
49161 + struct uarttio_uart *uart = uup->uart;
49162 +
49163 + uart->int_mask |= UARTTIO_UART_INT_TXBE;
49164 +}
49165 +
49166 +/*
49167 + * ubi32_uarttio_stop_rx
49168 + * Interrupts are enabled
49169 + */
49170 +static void ubi32_uarttio_stop_rx(struct uart_port *port)
49171 +{
49172 + struct ubi32_uarttio_port *uup = port->private_data;
49173 + struct uarttio_uart *uart = uup->uart;
49174 +
49175 + /*
49176 + * don't forward any more data (like !CREAD)
49177 + */
49178 + uart->int_mask &= ~UARTTIO_UART_INT_RX;
49179 + port->ignore_status_mask = UARTTIO_UART_INT_RX;
49180 +}
49181 +
49182 +/*
49183 + * ubi32_uarttio_enable_ms
49184 + * Set the modem control timer to fire immediately.
49185 + */
49186 +static void ubi32_uarttio_enable_ms(struct uart_port *port)
49187 +{
49188 + /* N/A */
49189 +}
49190 +
49191 +/*
49192 + * ubi32_uarttio_isr
49193 + */
49194 +static irqreturn_t ubi32_uarttio_isr(int irq, void *appdata)
49195 +{
49196 + struct ubi32_uarttio_port *uup = uarttio_ports;
49197 + int i;
49198 +
49199 + /*
49200 + * Service all of the ports
49201 + */
49202 + for (i = 0; i < uarttio_nports; i++) {
49203 + unsigned int flags;
49204 +
49205 + if (!(uup->uart->flags & UARTTIO_UART_FLAG_ENABLED)) {
49206 + uup++;
49207 + continue;
49208 + }
49209 +
49210 + spin_lock(&uup->port.lock);
49211 +
49212 + flags = uup->uart->int_flags;
49213 +
49214 + uup->uart->int_flags = 0;
49215 +
49216 + ubi32_uarttio_handle_receive(uup, flags);
49217 + ubi32_uarttio_handle_transmit(uup, flags);
49218 +
49219 + tty_flip_buffer_push(uup->port.info->port.tty);
49220 +
49221 + spin_unlock(&uup->port.lock);
49222 +
49223 + uup++;
49224 + }
49225 +
49226 + return IRQ_HANDLED;
49227 +}
49228 +
49229 +/*
49230 + * ubi32_uarttio_tx_empty
49231 + * Return TIOCSER_TEMT when transmitter is not busy.
49232 + */
49233 +static unsigned int ubi32_uarttio_tx_empty(struct uart_port *port)
49234 +{
49235 + struct ubi32_uarttio_port *uup = port->private_data;
49236 +
49237 + if (uup->uart->tx_fifo_head == uup->uart->tx_fifo_tail) {
49238 + return TIOCSER_TEMT;
49239 + }
49240 +
49241 + return 0;
49242 +}
49243 +
49244 +/*
49245 + * ubi32_uarttio_get_mctrl
49246 + */
49247 +static unsigned int ubi32_uarttio_get_mctrl(struct uart_port *port)
49248 +{
49249 + return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
49250 +}
49251 +
49252 +/*
49253 + * ubi32_uarttio_set_mctrl
49254 + */
49255 +static void ubi32_uarttio_set_mctrl(struct uart_port *port, unsigned int mctrl)
49256 +{
49257 + /* N/A */
49258 +}
49259 +
49260 +/*
49261 + * ubi32_uarttio_break_ctl
49262 + */
49263 +static void ubi32_uarttio_break_ctl(struct uart_port *port, int break_state)
49264 +{
49265 + /* N/A */
49266 +}
49267 +
49268 +/*
49269 + * ubi32_uarttio_startup
49270 + */
49271 +static int ubi32_uarttio_startup(struct uart_port *port)
49272 +{
49273 + struct ubi32_uarttio_port *uup = port->private_data;
49274 + struct uarttio_uart *uart = uup->uart;
49275 +
49276 + uart->flags |= UARTTIO_UART_FLAG_ENABLED;
49277 +
49278 + uart->int_mask |= UARTTIO_UART_INT_TXBE | UARTTIO_UART_INT_RX;
49279 +
49280 + return 0;
49281 +}
49282 +
49283 +/*
49284 + * ubi32_uarttio_shutdown
49285 + */
49286 +static void ubi32_uarttio_shutdown(struct uart_port *port)
49287 +{
49288 + struct ubi32_uarttio_port *uup = port->private_data;
49289 + struct uarttio_uart *uart = uup->uart;
49290 +
49291 + uart->int_mask = 0;
49292 + uart->flags &= ~UARTTIO_UART_FLAG_ENABLED;
49293 +}
49294 +
49295 +/*
49296 + * ubi32_uarttio_set_termios
49297 + */
49298 +static void ubi32_uarttio_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old)
49299 +{
49300 + struct ubi32_uarttio_port *uup = port->private_data;
49301 + unsigned long flags;
49302 + unsigned int baud;
49303 +
49304 + spin_lock_irqsave(&port->lock, flags);
49305 +
49306 +#if 0
49307 + port->read_status_mask = UBI32_UARTTIO_RX | UBI32_UARTTIO_RXOVF | UBI32_UARTTIO_TXOVF;
49308 +
49309 + if (termios->c_iflag & INPCK) {
49310 + port->read_status_mask |= UBI32_UARTTIO_RXFRAME;
49311 + }
49312 +#endif
49313 +
49314 + port->ignore_status_mask = 0;
49315 + if (termios->c_iflag & IGNPAR) {
49316 + port->ignore_status_mask |= UARTTIO_UART_INT_RXFRAME |
49317 + UARTTIO_UART_INT_RXOVF;
49318 + }
49319 +
49320 + /*
49321 + * ignore all characters if CREAD is not set
49322 + */
49323 + if ((termios->c_cflag & CREAD) == 0) {
49324 + port->ignore_status_mask |= UARTTIO_UART_INT_RX |
49325 + UARTTIO_UART_INT_RXFRAME |
49326 + UARTTIO_UART_INT_RXOVF;
49327 + }
49328 +
49329 + /* update timeout */
49330 + baud = uart_get_baud_rate(port, termios, old, 0, 460800);
49331 + uart_update_timeout(port, termios->c_cflag, baud);
49332 +
49333 + ubi32_uarttio_set_baud(uup, baud);
49334 + spin_unlock_irqrestore(&port->lock, flags);
49335 +}
49336 +
49337 +/*
49338 + * ubi32_uarttio_type
49339 + */
49340 +static const char *ubi32_uarttio_type(struct uart_port *port)
49341 +{
49342 + return (port->type == PORT_UBI32_UARTTIO) ? "UBI32_UARTTIO" : NULL;
49343 +}
49344 +
49345 +/*
49346 + * ubi32_uarttio_release_port
49347 + * Release the memory region(s) being used by 'port'.
49348 + */
49349 +static void ubi32_uarttio_release_port(struct uart_port *port)
49350 +{
49351 +}
49352 +
49353 +/*
49354 + * ubi32_uarttio_request_port
49355 + * Request the memory region(s) being used by 'port'.
49356 + */
49357 +static int ubi32_uarttio_request_port(struct uart_port *port)
49358 +{
49359 + return 0;
49360 +}
49361 +
49362 +/*
49363 + * ubi32_uarttio_config_port
49364 + * Configure/autoconfigure the port.
49365 + */
49366 +static void ubi32_uarttio_config_port(struct uart_port *port, int flags)
49367 +{
49368 + if ((flags & UART_CONFIG_TYPE) && (ubi32_uarttio_request_port(port) == 0)) {
49369 + port->type = PORT_UBI32_UARTTIO;
49370 + }
49371 +}
49372 +
49373 +/*
49374 + * ubi32_uarttio_verify_port
49375 + * Verify the new serial_struct (for TIOCSSERIAL).
49376 + *
49377 + * The only change we allow are to the flags and type, and
49378 + * even then only between PORT_UBI32_UARTTIO and PORT_UNKNOWN
49379 + */
49380 +static int ubi32_uarttio_verify_port(struct uart_port *port, struct serial_struct *ser)
49381 +{
49382 + return 0;
49383 +}
49384 +
49385 +static struct uart_ops ubi32_uarttio_pops = {
49386 + .tx_empty = ubi32_uarttio_tx_empty,
49387 + .set_mctrl = ubi32_uarttio_set_mctrl,
49388 + .get_mctrl = ubi32_uarttio_get_mctrl,
49389 + .stop_tx = ubi32_uarttio_stop_tx,
49390 + .start_tx = ubi32_uarttio_start_tx,
49391 + .stop_rx = ubi32_uarttio_stop_rx,
49392 + .enable_ms = ubi32_uarttio_enable_ms,
49393 + .break_ctl = ubi32_uarttio_break_ctl,
49394 + .startup = ubi32_uarttio_startup,
49395 + .shutdown = ubi32_uarttio_shutdown,
49396 + .set_termios = ubi32_uarttio_set_termios,
49397 + .type = ubi32_uarttio_type,
49398 + .release_port = ubi32_uarttio_release_port,
49399 + .request_port = ubi32_uarttio_request_port,
49400 + .config_port = ubi32_uarttio_config_port,
49401 + .verify_port = ubi32_uarttio_verify_port,
49402 +};
49403 +
49404 +/*
49405 + * ubi32_uarttio_add_ports
49406 + */
49407 +static int __init ubi32_uarttio_add_ports(void)
49408 +{
49409 + int res = 0;
49410 + struct ubi32_uarttio_port *uup = uarttio_ports;
49411 + int i = 0;
49412 +
49413 + for (i = 0; i < uarttio_nports; i++) {
49414 + /*
49415 + * Setup the GPIOs
49416 + */
49417 + res = gpio_request(uup->tx_pin, "ubi32_uarttio_tx");
49418 + if (res) {
49419 + printk(KERN_WARNING "Failed to request GPIO %d\n", uup->tx_pin);
49420 + res = -EBUSY;
49421 + goto next;
49422 + }
49423 +
49424 + res = gpio_request(uup->rx_pin, "ubi32_uarttio_rx");
49425 + if (res) {
49426 + gpio_free(uup->tx_pin);
49427 + printk(KERN_WARNING "Failed to request GPIO %d\n", uup->rx_pin);
49428 + res = -EBUSY;
49429 + goto next;
49430 + }
49431 +
49432 + res = uart_add_one_port(&ubi32_uarttio_uart_driver, &uup->port);
49433 + if (res) {
49434 + gpio_free(uup->rx_pin);
49435 + gpio_free(uup->tx_pin);
49436 + res = -ENODEV;
49437 + printk(KERN_WARNING "Failed to add port %d,%d\n", uup->tx_pin, uup->rx_pin);
49438 + goto next;
49439 + }
49440 + uup->added = 1;
49441 +
49442 + /*
49443 + * Set the direction of the ports now, after we're sure that everything is ok
49444 + */
49445 + if (!uup->port_init) {
49446 + gpio_direction_output(uup->tx_pin, 1);
49447 + gpio_direction_input(uup->rx_pin);
49448 + }
49449 +
49450 +next:
49451 + uup++;
49452 + }
49453 + return res;
49454 +}
49455 +
49456 +/*
49457 + * ubi32_uarttio_cleanup
49458 + */
49459 +static void ubi32_uarttio_cleanup(void)
49460 +{
49461 + struct ubi32_uarttio_port *uup;
49462 + int i;
49463 +
49464 + /*
49465 + * Stop the hardware thread
49466 + */
49467 + if (uarttio_inst.regs) {
49468 + thread_disable(uarttio_inst.regs->thread);
49469 + }
49470 + if (uarttio_inst.irq_requested) {
49471 + free_irq(uarttio_inst.irq, NULL);
49472 + }
49473 +
49474 + /*
49475 + * Get rid of the ports
49476 + */
49477 + uup = uarttio_inst.ports;
49478 + for (i = 0; i < uarttio_nports; i++) {
49479 + gpio_free(uup->tx_pin);
49480 + gpio_free(uup->rx_pin);
49481 + if (uup->added) {
49482 + uart_remove_one_port(&ubi32_uarttio_uart_driver, &uup->port);
49483 + }
49484 + uup++;
49485 + }
49486 +
49487 + if (uarttio_inst.driver_registered) {
49488 + uart_unregister_driver(&ubi32_uarttio_uart_driver);
49489 + }
49490 +}
49491 +
49492 +/*
49493 + * ubi32_uarttio_setup_port
49494 + * Setup a port in the TIO registers
49495 + */
49496 +static int ubi32_uarttio_setup_port(int index,
49497 + struct uarttio_uart *uart,
49498 + unsigned int baud, unsigned int tx_pin,
49499 + unsigned int rx_pin)
49500 +{
49501 + struct ubi32_uarttio_port *uup = &uarttio_ports[index];
49502 + void *tx_port = ubi_gpio_get_port(tx_pin);
49503 + void *rx_port = ubi_gpio_get_port(rx_pin);
49504 +
49505 + /*
49506 + * Verify the ports are on chip
49507 + */
49508 + if (!tx_port || !rx_port) {
49509 + printk(KERN_WARNING "Invalid port(s) specified: %u or %u\n", tx_pin, rx_pin);
49510 + return -EINVAL;
49511 + }
49512 +
49513 + uup->tx_pin = tx_pin;
49514 + uup->rx_pin = rx_pin;
49515 + uup->uart = uart;
49516 +
49517 + /*
49518 + * Setup the port structure
49519 + */
49520 + uup->port.ops = &ubi32_uarttio_pops;
49521 + uup->port.line = index;
49522 + uup->port.iotype = UPIO_MEM;
49523 + uup->port.flags = UPF_BOOT_AUTOCONF;
49524 + uup->port.fifosize = uup->uart->tx_fifo_size;
49525 + uup->port.private_data = uup;
49526 +
49527 + /*
49528 + * We share this IRQ across all ports
49529 + */
49530 + uup->port.irq = uarttio_inst.irq;
49531 +
49532 + /*
49533 + * We really don't have a mem/map base but without these variables
49534 + * set, the serial_core won't startup.
49535 + */
49536 + uup->port.membase = (void __iomem *)uup;
49537 + uup->port.mapbase = (resource_size_t)uup;
49538 + spin_lock_init(&uup->port.lock);
49539 +
49540 + /*
49541 + * Set up the hardware
49542 + */
49543 + uart->flags = UARTTIO_UART_FLAG_SET_RATE | UARTTIO_UART_FLAG_RESET;
49544 +
49545 + uart->tx_port = (unsigned int)tx_port;
49546 + uart->tx_pin = gpio_pin_index(tx_pin);
49547 + uart->tx_bits = 8;
49548 + uart->tx_stop_bits = 1;
49549 +
49550 + uart->rx_port = (unsigned int)rx_port;
49551 + uart->rx_pin = gpio_pin_index(rx_pin);
49552 + uart->rx_bits = 8;
49553 + uart->rx_stop_bits = 1;
49554 +
49555 + uart->baud_rate = baud;
49556 +
49557 + return 0;
49558 +}
49559 +
49560 +enum ubi32_uarttio_parse_states {
49561 + UBI32_UARTTIO_PARSE_STATE_BAUD,
49562 + UBI32_UARTTIO_PARSE_STATE_TX_PIN,
49563 + UBI32_UARTTIO_PARSE_STATE_RX_PIN,
49564 + UBI32_UARTTIO_PARSE_STATE_HS,
49565 + UBI32_UARTTIO_PARSE_STATE_CTS_PIN,
49566 + UBI32_UARTTIO_PARSE_STATE_RTS_PIN,
49567 +};
49568 +
49569 +/*
49570 + * ubi32_uarttio_parse_param
49571 + */
49572 +static int ubi32_uarttio_parse_param(char *str)
49573 +{
49574 + int res;
49575 + int i;
49576 + int baud = 0;
49577 + int tx_pin = 0;
49578 + int rx_pin = 0;
49579 + int hs = 0;
49580 + int cts_pin = 0;
49581 + int rts_pin = 0;
49582 + int nfound = 0;
49583 + enum ubi32_uarttio_parse_states state = UBI32_UARTTIO_PARSE_STATE_BAUD;
49584 + struct uarttio_uart *uart = uarttio_inst.regs->uarts;
49585 +
49586 + /*
49587 + * Run though the options and generate the proper structures
49588 + */
49589 + res = get_option(&str, &i);
49590 + while ((res == 2) || (res == 1)) {
49591 + switch (state) {
49592 + case UBI32_UARTTIO_PARSE_STATE_BAUD:
49593 + /*
49594 + * If we are here and nfound > 0 then create the port
49595 + * based on the previous input
49596 + */
49597 + if (nfound) {
49598 + /*
49599 + * Create the port
49600 + */
49601 + if (ubi32_uarttio_setup_port(nfound - 1, uart, baud, tx_pin, rx_pin)) {
49602 + /*
49603 + * Port was invalid
49604 + */
49605 + goto fail;
49606 + } else {
49607 + printk(KERN_INFO "Serial port %d: tx=%d:rx=%d @ %d\n", nfound, tx_pin, rx_pin, baud);
49608 + uart++;
49609 + }
49610 + }
49611 +
49612 + /*
49613 + * Reset the variables and go to the next state
49614 + */
49615 + hs = 0;
49616 + baud = i;
49617 + state = UBI32_UARTTIO_PARSE_STATE_TX_PIN;
49618 + break;
49619 +
49620 + case UBI32_UARTTIO_PARSE_STATE_TX_PIN:
49621 + tx_pin = i;
49622 + state = UBI32_UARTTIO_PARSE_STATE_RX_PIN;
49623 + break;
49624 +
49625 + case UBI32_UARTTIO_PARSE_STATE_RX_PIN:
49626 + rx_pin = i;
49627 + state = UBI32_UARTTIO_PARSE_STATE_HS;
49628 + break;
49629 +
49630 + case UBI32_UARTTIO_PARSE_STATE_HS:
49631 + hs = i;
49632 + if (hs) {
49633 + state = UBI32_UARTTIO_PARSE_STATE_CTS_PIN;
49634 + break;
49635 + }
49636 +
49637 + if (nfound == uarttio_inst.regs->max_uarts) {
49638 + printk(KERN_WARNING "Maximum number of serial ports reached\n");
49639 + goto done;
49640 + }
49641 + nfound++;
49642 + state = UBI32_UARTTIO_PARSE_STATE_BAUD;
49643 + break;
49644 +
49645 + case UBI32_UARTTIO_PARSE_STATE_CTS_PIN:
49646 + cts_pin = i;
49647 + state = UBI32_UARTTIO_PARSE_STATE_RTS_PIN;
49648 + break;
49649 +
49650 + case UBI32_UARTTIO_PARSE_STATE_RTS_PIN:
49651 + rts_pin = i;
49652 +
49653 + if (nfound == uarttio_inst.regs->max_uarts) {
49654 + printk(KERN_WARNING "Maximum number of serial ports reached\n");
49655 + goto done;
49656 + }
49657 + nfound++;
49658 + state = UBI32_UARTTIO_PARSE_STATE_BAUD;
49659 + break;
49660 + }
49661 + res = get_option(&str, &i);
49662 + }
49663 +
49664 + if ((res > 2) || state != UBI32_UARTTIO_PARSE_STATE_BAUD) {
49665 + printk(KERN_WARNING "Parameter syntax error.\n");
49666 + res = -EINVAL;
49667 + goto fail;
49668 + }
49669 +
49670 + /*
49671 + * Create the final port
49672 + */
49673 + if (ubi32_uarttio_setup_port(nfound - 1, uart, baud, tx_pin, rx_pin)) {
49674 + goto fail;
49675 + }
49676 + printk(KERN_INFO "Serial port %d: tx=%d:rx=%d @ %d\n", nfound, tx_pin, rx_pin, baud);
49677 +
49678 +done:
49679 + uarttio_nports = nfound;
49680 +
49681 + return nfound ? 0 : -ENODEV;
49682 +
49683 +fail:
49684 + /*
49685 + * Reset the ports
49686 + */
49687 + uart = uarttio_inst.regs->uarts;
49688 + for (i = 0; i < uarttio_inst.regs->max_uarts; i++) {
49689 + uart->flags = 0;
49690 + uart++;
49691 + }
49692 +
49693 + return res;
49694 +}
49695 +
49696 +/*
49697 + * ubi32_uarttio_probe
49698 + */
49699 +static int ubi32_uarttio_probe(void)
49700 +{
49701 + int ret;
49702 + struct uarttio_node *uart_node;
49703 + char *str = utio_ports_param;
49704 + static int probed;
49705 + static int probe_result;
49706 +
49707 + /*
49708 + * We only want to be probed once, we could be probed twice
49709 + * for example if we are used as a console
49710 + */
49711 + if (probed) {
49712 + return probe_result;
49713 + }
49714 + probed = 1;
49715 +
49716 + /*
49717 + * Extract the TIO name from the setup string
49718 + */
49719 + while (*str) {
49720 + if (*str == ',') {
49721 + *str++ = 0;
49722 + break;
49723 + }
49724 + str++;
49725 + }
49726 +
49727 + if (!*str) {
49728 + probe_result = -EINVAL;
49729 + return -EINVAL;
49730 + }
49731 +
49732 + uart_node = (struct uarttio_node *)devtree_find_node(utio_ports_param);
49733 + if (!uart_node) {
49734 + probe_result = -ENODEV;
49735 + return -ENODEV;
49736 + }
49737 +
49738 + uarttio_inst.irq = uart_node->dn.recvirq;
49739 + uarttio_inst.regs = uart_node->regs;
49740 +
49741 + /*
49742 + * Parse module parameters.
49743 + */
49744 + ret = ubi32_uarttio_parse_param(str);
49745 + if (ret != 0) {
49746 + ubi32_uarttio_cleanup();
49747 + probe_result = ret;
49748 + return ret;
49749 + }
49750 +
49751 + ubi32_uarttio_uart_driver.nr = uarttio_nports;
49752 +
49753 + return 0;
49754 +}
49755 +
49756 +#if defined(CONFIG_SERIAL_UBI32_UARTTIO_CONSOLE)
49757 +/*
49758 + * ubi32_uarttio_console_setup
49759 + */
49760 +static int __init ubi32_uarttio_console_setup(struct console *co, char *options)
49761 +{
49762 + int baud;
49763 + int bits = 8;
49764 + int parity = 'n';
49765 + int flow = 'n';
49766 + struct ubi32_uarttio_port *uup;
49767 +
49768 + /*
49769 + * Check whether an invalid uart number has been specified, and
49770 + * if so, search for the first available port that does have
49771 + * console support.
49772 + */
49773 + if (co->index == -1 || co->index >= uarttio_nports) {
49774 + co->index = 0;
49775 + }
49776 + uup = &uarttio_ports[co->index];
49777 + baud = uup->uart->baud_rate;
49778 + uup->uart->flags |= UARTTIO_UART_FLAG_ENABLED;
49779 +
49780 + /*
49781 + * Setup the GPIOs
49782 + * We have to use the direct interface because the gpio
49783 + * subsystem is not available at this point.
49784 + */
49785 + uup->port_init = 1;
49786 + UBICOM32_GPIO_SET_PIN_HIGH(uup->tx_pin);
49787 + UBICOM32_GPIO_SET_PIN_OUTPUT(uup->tx_pin);
49788 + UBICOM32_GPIO_SET_PIN_INPUT(uup->rx_pin);
49789 +
49790 + /*
49791 + * Start the thread
49792 + */
49793 + thread_enable(uarttio_inst.regs->thread);
49794 +
49795 + /*
49796 + * Process options
49797 + */
49798 + if (options) {
49799 + uart_parse_options(options, &baud, &parity, &bits, &flow);
49800 + if (ubi32_uarttio_set_baud(uup, baud)) {
49801 + baud = uup->uart->current_baud_rate;
49802 + }
49803 + }
49804 +
49805 + return uart_set_options(&uup->port, co, baud, 'n', 8, 'n');
49806 +}
49807 +
49808 +/*
49809 + * ubi32_uarttio_console_putchar
49810 + */
49811 +static void ubi32_uarttio_console_putchar(struct uart_port *port, int ch)
49812 +{
49813 + struct ubi32_uarttio_port *uup = port->private_data;
49814 +
49815 + while (ubi32_uarttio_put_char(uup->uart, ch)) {
49816 + cpu_relax();
49817 + }
49818 +}
49819 +
49820 +/*
49821 + * ubi32_uarttio_console_write
49822 + * Interrupts are disabled on entering
49823 + */
49824 +static void ubi32_uarttio_console_write(struct console *co, const char *s, unsigned int count)
49825 +{
49826 + struct uart_port *port = &(uarttio_ports[co->index].port);
49827 + unsigned long flags = 0;
49828 +
49829 + spin_lock_irqsave(&port->lock, flags);
49830 + uart_console_write(port, s, count, ubi32_uarttio_console_putchar);
49831 + spin_unlock_irqrestore(&port->lock, flags);
49832 +}
49833 +
49834 +static struct console ubi32_uarttio_console = {
49835 + .name = UBI32_UARTTIO_NAME,
49836 + .write = ubi32_uarttio_console_write,
49837 + .device = uart_console_device,
49838 + .setup = ubi32_uarttio_console_setup,
49839 + .flags = CON_PRINTBUFFER,
49840 + .index = -1,
49841 + .data = &ubi32_uarttio_uart_driver,
49842 +};
49843 +
49844 +static int __init ubi32_uarttio_console_init(void)
49845 +{
49846 + int res;
49847 +
49848 + res = ubi32_uarttio_probe();
49849 + if (res) {
49850 + return res;
49851 + }
49852 +
49853 + register_console(&ubi32_uarttio_console);
49854 + return 0;
49855 +}
49856 +console_initcall(ubi32_uarttio_console_init);
49857 +#endif /* CONFIG_SERIAL_UBI32_UARTTIO_CONSOLE */
49858 +
49859 +/*
49860 + * ubi32_serial_suspend
49861 + */
49862 +static int ubi32_uarttio_suspend(struct platform_device *pdev, pm_message_t state)
49863 +{
49864 + int i;
49865 + for (i = 0; i < uarttio_nports; i++) {
49866 + uart_suspend_port(&ubi32_uarttio_uart_driver, &uarttio_ports[i].port);
49867 + }
49868 +
49869 + return 0;
49870 +}
49871 +
49872 +/*
49873 + * ubi32_serial_resume
49874 + */
49875 +static int ubi32_uarttio_resume(struct platform_device *pdev)
49876 +{
49877 + int i;
49878 + for (i = 0; i < uarttio_nports; i++) {
49879 + uart_resume_port(&ubi32_uarttio_uart_driver, &uarttio_ports[i].port);
49880 + }
49881 +
49882 + return 0;
49883 +}
49884 +
49885 +/*
49886 + * ubi32_uarttio_remove
49887 + */
49888 +static int __devexit ubi32_uarttio_remove(struct platform_device *pdev)
49889 +{
49890 + ubi32_uarttio_cleanup();
49891 +
49892 + uart_unregister_driver(&ubi32_uarttio_uart_driver);
49893 +
49894 + return 0;
49895 +}
49896 +
49897 +static struct platform_driver ubi32_uarttio_platform_driver = {
49898 + .remove = __devexit_p(ubi32_uarttio_remove),
49899 + .suspend = ubi32_uarttio_suspend,
49900 + .resume = ubi32_uarttio_resume,
49901 + .driver = {
49902 + .name = DRIVER_NAME,
49903 + .owner = THIS_MODULE,
49904 + },
49905 +};
49906 +
49907 +#ifndef MODULE
49908 +/*
49909 + * Called at boot time.
49910 + *
49911 + * uarttio=TIONAME,(baud,tx_pin,rx_pin,handshake[,cts_pin,rts_pin],...)
49912 + * TIONAME is the name of the devtree node which describes the UARTTIO
49913 + * pin is the index of the pin, i.e. PA4 is 5 [(port * 32) + pin]
49914 + * handshake = 1 to enable handshaking, provide cts_pin, rts_pin (UNSUPPORTED)
49915 + * handshake = 0 to disable handshaking, do not provide cts_pin, rts_pin
49916 + * Ex: uarttio=UARTTIO,57600,7,6,0,9600,8,9,0
49917 + */
49918 +static int __init ubi32_uarttio_setup(char *str)
49919 +{
49920 + strncpy(utio_ports_param, str, UBI32_UARTTIO_MAX_PARAM_LEN);
49921 + utio_ports_param[UBI32_UARTTIO_MAX_PARAM_LEN - 1] = 0;
49922 + return 1;
49923 +}
49924 +__setup("uarttio=", ubi32_uarttio_setup);
49925 +#endif
49926 +
49927 +/*
49928 + * ubi32_uarttio_init
49929 + */
49930 +static int __init ubi32_uarttio_init(void)
49931 +{
49932 + int ret;
49933 + int i;
49934 +
49935 + ret = ubi32_uarttio_probe();
49936 + if (ret) {
49937 + return ret;
49938 + }
49939 +
49940 + /*
49941 + * Request the IRQ (do it here since many ports share the same IRQ)
49942 + */
49943 + ret = request_irq(uarttio_inst.irq, ubi32_uarttio_isr, IRQF_DISABLED, DRIVER_NAME, NULL);
49944 + if (ret != 0) {
49945 + printk(KERN_WARNING "Could not request IRQ %d\n", uarttio_inst.irq);
49946 + goto fail;
49947 + }
49948 + uarttio_inst.irq_requested = 1;
49949 +
49950 + /*
49951 + * Register the UART driver and add the ports
49952 + */
49953 + ret = uart_register_driver(&ubi32_uarttio_uart_driver);
49954 + if (ret != 0) {
49955 + goto fail;
49956 + }
49957 + uarttio_inst.driver_registered = 1;
49958 +
49959 + ret = ubi32_uarttio_add_ports();
49960 + if (ret != 0) {
49961 + ubi32_uarttio_cleanup();
49962 + return ret;
49963 + }
49964 +
49965 + /*
49966 + * Start the thread
49967 + */
49968 + thread_enable(uarttio_inst.regs->thread);
49969 +
49970 + for (i = 0; i < uarttio_nports; i++) {
49971 + pr_info("Serial: Ubicom32 uarttio #%d: tx:%d rx:%d baud:%d\n",
49972 + i, uarttio_ports[i].tx_pin, uarttio_ports[i].rx_pin,
49973 + uarttio_ports[i].uart->current_baud_rate);
49974 + }
49975 + pr_info("Serial: Ubicom32 uarttio started on thread:%d irq:%d\n", uarttio_inst.regs->thread, uarttio_inst.irq);
49976 +
49977 + return ret;
49978 +
49979 +fail:
49980 + ubi32_uarttio_cleanup();
49981 + return ret;
49982 +}
49983 +module_init(ubi32_uarttio_init);
49984 +
49985 +/*
49986 + * ubi32_uarttio_exit
49987 + */
49988 +static void __exit ubi32_uarttio_exit(void)
49989 +{
49990 + platform_driver_unregister(&ubi32_uarttio_platform_driver);
49991 +}
49992 +module_exit(ubi32_uarttio_exit);
49993 +
49994 +module_param_string(ports, utio_ports_param, sizeof(utio_ports_param), 0444);
49995 +MODULE_PARM_DESC(ports, "Sets the ports to allocate: ports=TIONAME,(baud,txpin,rxpin,handshake[,ctspin,rtspin],...)\n"
49996 + " TIONAME is the name of the devtree node which describes the UARTTIO\n"
49997 + " pin is the index of the pin, i.e. PA4 is 5 [(port * 32) + pin]\n"
49998 + " handshake = 1 to enable handshaking, provide ctspin, rtspin (UNSUPPORTED)\n"
49999 + " handshake = 0 to disable handshaking, do not provide ctspin, rtspin\n"
50000 + " Ex: ports=UARTTIO,57600,7,6,0,9600,8,9,0\n");
50001 +MODULE_AUTHOR("Patrick Tjin <pat.tjin@ubicom.com>");
50002 +MODULE_DESCRIPTION("Ubicom serial virtual peripherial driver");
50003 +MODULE_LICENSE("GPL");
50004 +MODULE_ALIAS_CHARDEV_MAJOR(UBI32_UARTTIO_MAJOR);
50005 +MODULE_ALIAS("platform:" DRIVER_NAME);
50006 diff -ruN linux-2.6.30.10/drivers/spi/Kconfig linux-2.6.30.10-ubi/drivers/spi/Kconfig
50007 --- linux-2.6.30.10/drivers/spi/Kconfig 2009-12-14 11:54:29.000000000 +0200
50008 +++ linux-2.6.30.10-ubi/drivers/spi/Kconfig 2009-12-14 11:54:27.000000000 +0200
50009 @@ -196,6 +196,15 @@
50010 help
50011 SPI driver for Samsung S3C24XX series ARM SoCs
50012
50013 +config SPI_UBICOM32_GPIO
50014 + tristate "Ubicom32 SPI over GPIO"
50015 + depends on SPI_MASTER && UBICOM32 && EXPERIMENTAL
50016 + select SPI_BITBANG
50017 + select HAS_DMA
50018 + help
50019 + SPI driver for the Ubicom32 architecture using
50020 + GPIO lines to provide the SPI bus.
50021 +
50022 config SPI_S3C24XX_GPIO
50023 tristate "Samsung S3C24XX series SPI by GPIO"
50024 depends on ARCH_S3C2410 && EXPERIMENTAL
50025 diff -ruN linux-2.6.30.10/drivers/spi/Makefile linux-2.6.30.10-ubi/drivers/spi/Makefile
50026 --- linux-2.6.30.10/drivers/spi/Makefile 2009-12-14 11:55:29.000000000 +0200
50027 +++ linux-2.6.30.10-ubi/drivers/spi/Makefile 2009-12-14 11:55:25.000000000 +0200
50028 @@ -27,6 +27,7 @@
50029 obj-$(CONFIG_SPI_MPC52xx_PSC) += mpc52xx_psc_spi.o
50030 obj-$(CONFIG_SPI_MPC83xx) += spi_mpc83xx.o
50031 obj-$(CONFIG_SPI_S3C24XX_GPIO) += spi_s3c24xx_gpio.o
50032 +obj-$(CONFIG_SPI_UBICOM32_GPIO) += spi_ubicom32_gpio.o
50033 obj-$(CONFIG_SPI_S3C24XX) += spi_s3c24xx.o
50034 obj-$(CONFIG_SPI_TXX9) += spi_txx9.o
50035 obj-$(CONFIG_SPI_XILINX) += xilinx_spi.o
50036 diff -ruN linux-2.6.30.10/drivers/spi/spi_ubicom32_gpio.c linux-2.6.30.10-ubi/drivers/spi/spi_ubicom32_gpio.c
50037 --- linux-2.6.30.10/drivers/spi/spi_ubicom32_gpio.c 1970-01-01 02:00:00.000000000 +0200
50038 +++ linux-2.6.30.10-ubi/drivers/spi/spi_ubicom32_gpio.c 2009-12-11 11:45:19.000000000 +0200
50039 @@ -0,0 +1,267 @@
50040 +/*
50041 + * drivers/spi_spi_ubicom32_gpio.c
50042 + * Ubicom32 GPIO based SPI driver
50043 + *
50044 + * (C) Copyright 2009, Ubicom, Inc.
50045 + *
50046 + * This file is part of the Ubicom32 Linux Kernel Port.
50047 + *
50048 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
50049 + * it and/or modify it under the terms of the GNU General Public License
50050 + * as published by the Free Software Foundation, either version 2 of the
50051 + * License, or (at your option) any later version.
50052 + *
50053 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
50054 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
50055 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
50056 + * the GNU General Public License for more details.
50057 + *
50058 + * You should have received a copy of the GNU General Public License
50059 + * along with the Ubicom32 Linux Kernel Port. If not,
50060 + * see <http://www.gnu.org/licenses/>.
50061 + *
50062 + * Ubicom32 implementation derived from (with many thanks):
50063 + * arch/m68knommu
50064 + * arch/blackfin
50065 + * arch/parisc
50066 + */
50067 +#include <linux/kernel.h>
50068 +#include <linux/init.h>
50069 +#include <linux/delay.h>
50070 +#include <linux/spinlock.h>
50071 +#include <linux/workqueue.h>
50072 +#include <linux/platform_device.h>
50073 +
50074 +#include <linux/spi/spi.h>
50075 +#include <linux/spi/spi_bitbang.h>
50076 +
50077 +#include <linux/gpio.h>
50078 +
50079 +#include <asm/ubicom32-spi-gpio.h>
50080 +
50081 +#define DRIVER_NAME "ubicom32-spi-gpio"
50082 +
50083 +struct ubicom32_spi_gpio {
50084 + struct spi_bitbang bitbang;
50085 +
50086 + struct ubicom32_spi_gpio_platform_data *pdata;
50087 +
50088 + struct platform_device *dev;
50089 +};
50090 +
50091 +/*
50092 + * The following 4 functions are used by EXPAND_BITBANG_TXRX to bitbang the data out.
50093 + */
50094 +static inline void setsck(struct spi_device *dev, int on)
50095 +{
50096 + struct ubicom32_spi_gpio *usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(dev->master);
50097 + gpio_set_value(usg->pdata->pin_clk, on ? 1 : 0);
50098 +}
50099 +
50100 +static inline void setmosi(struct spi_device *dev, int on)
50101 +{
50102 + struct ubicom32_spi_gpio *usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(dev->master);
50103 + gpio_set_value(usg->pdata->pin_mosi, on ? 1 : 0);
50104 +}
50105 +
50106 +static inline u32 getmiso(struct spi_device *dev)
50107 +{
50108 + struct ubicom32_spi_gpio *usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(dev->master);
50109 + return gpio_get_value(usg->pdata->pin_miso) ? 1 : 0;
50110 +}
50111 +
50112 +#define spidelay(x) ndelay(x)
50113 +
50114 +#define EXPAND_BITBANG_TXRX
50115 +#include <linux/spi/spi_bitbang.h>
50116 +
50117 +/*
50118 + * ubicom32_spi_gpio_txrx_mode0
50119 + */
50120 +static u32 ubicom32_spi_gpio_txrx_mode0(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits)
50121 +{
50122 + return bitbang_txrx_be_cpha0(spi, nsecs, 0, word, bits);
50123 +}
50124 +
50125 +/*
50126 + * ubicom32_spi_gpio_txrx_mode1
50127 + */
50128 +static u32 ubicom32_spi_gpio_txrx_mode1(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits)
50129 +{
50130 + return bitbang_txrx_be_cpha1(spi, nsecs, 0, word, bits);
50131 +}
50132 +
50133 +/*
50134 + * ubicom32_spi_gpio_txrx_mode2
50135 + */
50136 +static u32 ubicom32_spi_gpio_txrx_mode2(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits)
50137 +{
50138 + return bitbang_txrx_be_cpha0(spi, nsecs, 1, word, bits);
50139 +}
50140 +
50141 +/*
50142 + * ubicom32_spi_gpio_txrx_mode3
50143 + */
50144 +static u32 ubicom32_spi_gpio_txrx_mode3(struct spi_device *spi, unsigned nsecs, u32 word, u8 bits)
50145 +{
50146 + return bitbang_txrx_be_cpha1(spi, nsecs, 1, word, bits);
50147 +}
50148 +
50149 +/*
50150 + * ubicom32_spi_gpio_chipselect
50151 + */
50152 +static void ubicom32_spi_gpio_chipselect(struct spi_device *dev, int value)
50153 +{
50154 + struct ubicom32_spi_gpio_controller_data *cd = (struct ubicom32_spi_gpio_controller_data *)dev->controller_data;
50155 + unsigned int cs_polarity = dev->mode & SPI_CS_HIGH ? 1 : 0;
50156 +
50157 + if (value == BITBANG_CS_ACTIVE) {
50158 + gpio_set_value(cd->pin_cs, cs_polarity);
50159 + return;
50160 + }
50161 + gpio_set_value(cd->pin_cs, !cs_polarity);
50162 +}
50163 +
50164 +/*
50165 + * ubicom32_spi_gpio_probe
50166 + */
50167 +static int ubicom32_spi_gpio_probe(struct platform_device *dev)
50168 +{
50169 + struct ubicom32_spi_gpio_platform_data *pdata;
50170 + struct spi_master *master;
50171 + struct ubicom32_spi_gpio *usg;
50172 + int ret;
50173 +
50174 + master = spi_alloc_master(&dev->dev, sizeof(struct ubicom32_spi_gpio));
50175 + if (master == NULL) {
50176 + dev_err(&dev->dev, "failed to allocate spi master\n");
50177 + ret = -ENOMEM;
50178 + goto err;
50179 + }
50180 +
50181 + usg = (struct ubicom32_spi_gpio *)spi_master_get_devdata(master);
50182 +
50183 + platform_set_drvdata(dev, usg);
50184 +
50185 + /*
50186 + * Copy in the platform data
50187 + */
50188 + pdata = dev->dev.platform_data;
50189 + usg->pdata = dev->dev.platform_data;
50190 +
50191 + /*
50192 + * Request the GPIO lines
50193 + */
50194 + ret = gpio_request(pdata->pin_mosi, "spi-mosi");
50195 + if (ret) {
50196 + dev_err(&dev->dev, "Failed to allocate spi-mosi GPIO\n");
50197 + goto err;
50198 + }
50199 +
50200 + ret = gpio_request(pdata->pin_miso, "spi-miso");
50201 + if (ret) {
50202 + dev_err(&dev->dev, "Failed to allocate spi-miso GPIO\n");
50203 + goto err_nomiso;
50204 + }
50205 +
50206 + ret = gpio_request(pdata->pin_clk, "spi-clk");
50207 + if (ret) {
50208 + dev_err(&dev->dev, "Failed to allocate spi-clk GPIO\n");
50209 + goto err_noclk;
50210 + }
50211 +
50212 + /*
50213 + * Setup spi-bitbang adaptor
50214 + */
50215 + usg->bitbang.flags |= SPI_CS_HIGH;
50216 + usg->bitbang.master = spi_master_get(master);
50217 + usg->bitbang.master->bus_num = pdata->bus_num;
50218 + usg->bitbang.master->num_chipselect = pdata->num_chipselect;
50219 + usg->bitbang.chipselect = ubicom32_spi_gpio_chipselect;
50220 +
50221 + usg->bitbang.txrx_word[SPI_MODE_0] = ubicom32_spi_gpio_txrx_mode0;
50222 + usg->bitbang.txrx_word[SPI_MODE_1] = ubicom32_spi_gpio_txrx_mode1;
50223 + usg->bitbang.txrx_word[SPI_MODE_2] = ubicom32_spi_gpio_txrx_mode2;
50224 + usg->bitbang.txrx_word[SPI_MODE_3] = ubicom32_spi_gpio_txrx_mode3;
50225 +
50226 + /*
50227 + * Setup the GPIO pins
50228 + */
50229 + gpio_direction_output(pdata->pin_clk, pdata->clk_default);
50230 + gpio_direction_output(pdata->pin_mosi, 0);
50231 + gpio_direction_input(pdata->pin_miso);
50232 +
50233 + /*
50234 + * Ready to go
50235 + */
50236 + ret = spi_bitbang_start(&usg->bitbang);
50237 + if (ret) {
50238 + goto err_no_bitbang;
50239 + }
50240 +
50241 + return 0;
50242 +
50243 +err_no_bitbang:
50244 + spi_master_put(usg->bitbang.master);
50245 +
50246 + gpio_free(pdata->pin_clk);
50247 +
50248 +err_noclk:
50249 + gpio_free(pdata->pin_miso);
50250 +
50251 +err_nomiso:
50252 + gpio_free(pdata->pin_mosi);
50253 +
50254 +err:
50255 + return ret;
50256 +}
50257 +
50258 +/*
50259 + * ubicom32_spi_gpio_remove
50260 + */
50261 +static int ubicom32_spi_gpio_remove(struct platform_device *dev)
50262 +{
50263 + struct ubicom32_spi_gpio *sp = platform_get_drvdata(dev);
50264 +
50265 + spi_bitbang_stop(&sp->bitbang);
50266 + spi_master_put(sp->bitbang.master);
50267 +
50268 + return 0;
50269 +}
50270 +
50271 +/*
50272 + * Work with hotplug and coldplug
50273 + */
50274 +MODULE_ALIAS("platform:ubicom32_spi_gpio");
50275 +
50276 +static struct platform_driver ubicom32_spi_gpio_drv = {
50277 + .probe = ubicom32_spi_gpio_probe,
50278 + .remove = ubicom32_spi_gpio_remove,
50279 + .driver = {
50280 + .name = DRIVER_NAME,
50281 + .owner = THIS_MODULE,
50282 + },
50283 +};
50284 +
50285 +/*
50286 + * ubicom32_spi_gpio_init
50287 + */
50288 +static int __init ubicom32_spi_gpio_init(void)
50289 +{
50290 + return platform_driver_register(&ubicom32_spi_gpio_drv);
50291 +}
50292 +
50293 +/*
50294 + * ubicom32_spi_gpio_exit
50295 + */
50296 +static void __exit ubicom32_spi_gpio_exit(void)
50297 +{
50298 + platform_driver_unregister(&ubicom32_spi_gpio_drv);
50299 +}
50300 +
50301 +module_init(ubicom32_spi_gpio_init);
50302 +module_exit(ubicom32_spi_gpio_exit);
50303 +
50304 +MODULE_DESCRIPTION("Ubicom32 SPI-GPIO Driver");
50305 +MODULE_AUTHOR("Pat Tjin, <@ubicom.com>");
50306 +MODULE_LICENSE("GPL");
50307 diff -ruN linux-2.6.30.10/drivers/uio/Kconfig linux-2.6.30.10-ubi/drivers/uio/Kconfig
50308 --- linux-2.6.30.10/drivers/uio/Kconfig 2009-12-04 08:00:07.000000000 +0200
50309 +++ linux-2.6.30.10-ubi/drivers/uio/Kconfig 2009-12-11 11:45:20.000000000 +0200
50310 @@ -89,4 +89,12 @@
50311
50312 If you compile this as a module, it will be called uio_sercos3.
50313
50314 +config UIO_UBICOM32RING
50315 + tristate "Ubicom32 Ring Buffer driver"
50316 + default n
50317 + help
50318 + Userspace I/O interface for a Ubicom32 Ring Buffer.
50319 +
50320 + If you compile this as a module, it will be called uio_ubicom32ring
50321 +
50322 endif
50323 diff -ruN linux-2.6.30.10/drivers/uio/Makefile linux-2.6.30.10-ubi/drivers/uio/Makefile
50324 --- linux-2.6.30.10/drivers/uio/Makefile 2009-12-04 08:00:07.000000000 +0200
50325 +++ linux-2.6.30.10-ubi/drivers/uio/Makefile 2009-12-11 11:45:20.000000000 +0200
50326 @@ -5,3 +5,4 @@
50327 obj-$(CONFIG_UIO_SMX) += uio_smx.o
50328 obj-$(CONFIG_UIO_AEC) += uio_aec.o
50329 obj-$(CONFIG_UIO_SERCOS3) += uio_sercos3.o
50330 +obj-$(CONFIG_UIO_UBICOM32RING) += uio_ubicom32ring.o
50331 diff -ruN linux-2.6.30.10/drivers/uio/uio_ubicom32ring.c linux-2.6.30.10-ubi/drivers/uio/uio_ubicom32ring.c
50332 --- linux-2.6.30.10/drivers/uio/uio_ubicom32ring.c 1970-01-01 02:00:00.000000000 +0200
50333 +++ linux-2.6.30.10-ubi/drivers/uio/uio_ubicom32ring.c 2009-12-11 11:45:20.000000000 +0200
50334 @@ -0,0 +1,288 @@
50335 +/*
50336 + * drivers/uio/uio_ubicom32ring.c
50337 + *
50338 + * Userspace I/O platform driver for Ubicom32 ring buffers
50339 + *
50340 + * (C) Copyright 2009, Ubicom, Inc.
50341 + *
50342 + * This file is part of the Ubicom32 Linux Kernel Port.
50343 + *
50344 + * Based on uio_ubicom32ring.c by Magnus Damm
50345 + *
50346 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
50347 + * it and/or modify it under the terms of the GNU General Public License
50348 + * as published by the Free Software Foundation, either version 2 of the
50349 + * License, or (at your option) any later version.
50350 + *
50351 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
50352 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
50353 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
50354 + * the GNU General Public License for more details.
50355 + *
50356 + * You should have received a copy of the GNU General Public License
50357 + * along with the Ubicom32 Linux Kernel Port. If not,
50358 + * see <http://www.gnu.org/licenses/>.
50359 + */
50360 +
50361 +#include <linux/platform_device.h>
50362 +#include <linux/uio_driver.h>
50363 +#include <linux/spinlock.h>
50364 +#include <linux/bitops.h>
50365 +#include <linux/interrupt.h>
50366 +#include <linux/stringify.h>
50367 +
50368 +#include <asm/ip5000.h>
50369 +#include <asm/ubicom32ring.h>
50370 +
50371 +#define DRIVER_NAME "uio_ubicom32ring"
50372 +
50373 +struct uio_ubicom32ring_data {
50374 + struct uio_info *uioinfo;
50375 +
50376 + struct uio_ubicom32ring_regs *regs;
50377 +
50378 + /*
50379 + * IRQ used to kick the ring buffer
50380 + */
50381 + int irq_tx;
50382 + int irq_rx;
50383 +
50384 + spinlock_t lock;
50385 +
50386 + unsigned long flags;
50387 +
50388 + char name[0];
50389 +};
50390 +
50391 +static irqreturn_t uio_ubicom32ring_handler(int irq, struct uio_info *dev_info)
50392 +{
50393 + struct uio_ubicom32ring_data *priv = dev_info->priv;
50394 +
50395 + /* Just disable the interrupt in the interrupt controller, and
50396 + * remember the state so we can allow user space to enable it later.
50397 + */
50398 +
50399 + if (!test_and_set_bit(0, &priv->flags))
50400 + disable_irq_nosync(irq);
50401 +
50402 + return IRQ_HANDLED;
50403 +}
50404 +
50405 +static int uio_ubicom32ring_irqcontrol(struct uio_info *dev_info, s32 irq_on)
50406 +{
50407 + struct uio_ubicom32ring_data *priv = dev_info->priv;
50408 + unsigned long flags;
50409 +
50410 + /* Allow user space to enable and disable the interrupt
50411 + * in the interrupt controller, but keep track of the
50412 + * state to prevent per-irq depth damage.
50413 + *
50414 + * Serialize this operation to support multiple tasks.
50415 + */
50416 +
50417 + spin_lock_irqsave(&priv->lock, flags);
50418 +
50419 + if (irq_on & 2) {
50420 + /*
50421 + * Kick the ring buffer (if we can)
50422 + */
50423 + if (priv->irq_tx != 0xFF) {
50424 + ubicom32_set_interrupt(priv->irq_tx);
50425 + }
50426 + }
50427 +
50428 + if (priv->irq_rx != 0xFF) {
50429 + if (irq_on & 1) {
50430 + if (test_and_clear_bit(0, &priv->flags))
50431 + enable_irq(dev_info->irq);
50432 + } else {
50433 + if (!test_and_set_bit(0, &priv->flags))
50434 + disable_irq(dev_info->irq);
50435 + }
50436 + }
50437 +
50438 + spin_unlock_irqrestore(&priv->lock, flags);
50439 +
50440 + return 0;
50441 +}
50442 +
50443 +static int uio_ubicom32ring_probe(struct platform_device *pdev)
50444 +{
50445 + struct uio_info *uioinfo;
50446 + struct uio_mem *uiomem;
50447 + struct uio_ubicom32ring_data *priv;
50448 + struct uio_ubicom32ring_regs *regs;
50449 + struct resource *mem_resource;
50450 + struct resource *irqtx_resource;
50451 + struct resource *irqrx_resource;
50452 + int ret = -EINVAL;
50453 + int i;
50454 +
50455 + uioinfo = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
50456 + if (!uioinfo) {
50457 + dev_err(&pdev->dev, "unable to kmalloc\n");
50458 + return -ENOMEM;
50459 + }
50460 +
50461 + /*
50462 + * Allocate private data with some string space after
50463 + */
50464 + i = sizeof(DRIVER_NAME) + 1;
50465 + i += pdev->dev.platform_data ? strlen(pdev->dev.platform_data) : 0;
50466 + priv = kzalloc(sizeof(struct uio_ubicom32ring_data) + i, GFP_KERNEL);
50467 + if (!priv) {
50468 + dev_err(&pdev->dev, "unable to kmalloc\n");
50469 + kfree(uioinfo);
50470 + return -ENOMEM;
50471 + }
50472 +
50473 + strcpy(priv->name, DRIVER_NAME ":");
50474 + if (pdev->dev.platform_data) {
50475 + strcat(priv->name, pdev->dev.platform_data);
50476 + }
50477 + uioinfo->priv = priv;
50478 + uioinfo->name = priv->name;
50479 + uioinfo->version = "0.1";
50480 +
50481 + priv->uioinfo = uioinfo;
50482 + spin_lock_init(&priv->lock);
50483 + priv->flags = 0; /* interrupt is enabled to begin with */
50484 +
50485 + /*
50486 + * Get our resources, the IRQ_TX and IRQ_RX are optional.
50487 + */
50488 + priv->irq_tx = 0xFF;
50489 + irqtx_resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
50490 + if (irqtx_resource) {
50491 + priv->irq_tx = irqtx_resource->start;
50492 + }
50493 +
50494 + uioinfo->irq = -1;
50495 + priv->irq_rx = 0xFF;
50496 + irqrx_resource = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
50497 + if (irqrx_resource) {
50498 + priv->irq_rx = irqrx_resource->start;
50499 + uioinfo->irq = priv->irq_rx;
50500 + uioinfo->handler = uio_ubicom32ring_handler;
50501 + }
50502 +
50503 + mem_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
50504 + if (!mem_resource || !mem_resource->start) {
50505 + dev_err(&pdev->dev, "No valid memory resource found\n");
50506 + ret = -ENODEV;
50507 + goto fail;
50508 + }
50509 + regs = (struct uio_ubicom32ring_regs *)mem_resource->start;
50510 + priv->regs = regs;
50511 +
50512 + if (regs->version != UIO_UBICOM32RING_REG_VERSION) {
50513 + dev_err(&pdev->dev, "version %d not supported\n", regs->version);
50514 + ret = -ENODEV;
50515 + goto fail;
50516 + }
50517 +
50518 + /*
50519 + * First range is the shared register space, if we have any
50520 + */
50521 + uiomem = &uioinfo->mem[0];
50522 + if (regs->regs_size) {
50523 + uiomem->memtype = UIO_MEM_PHYS;
50524 + uiomem->addr = (u32_t)regs->regs;
50525 + uiomem->size = regs->regs_size;
50526 + ++uiomem;
50527 + dev_info(&pdev->dev, "regs:%p (%u) / rings: %d found\n", regs->regs, regs->regs_size, regs->num_rings);
50528 + } else {
50529 + dev_info(&pdev->dev, "rings: %d found\n", regs->num_rings);
50530 + }
50531 +
50532 + /*
50533 + * The rest of the range correspond to the rings
50534 + */
50535 + for (i = 0; i < regs->num_rings; i++) {
50536 + dev_info(&pdev->dev, "\t%d: entries:%d ring:%p\n",
50537 + i, regs->rings[i]->entries, &(regs->rings[i]->ring));
50538 + if (uiomem >= &uioinfo->mem[MAX_UIO_MAPS]) {
50539 + dev_warn(&pdev->dev, "device has more than "
50540 + __stringify(MAX_UIO_MAPS)
50541 + " I/O memory resources.\n");
50542 + break;
50543 + }
50544 +
50545 + uiomem->memtype = UIO_MEM_PHYS;
50546 + uiomem->addr = (u32_t)&(regs->rings[i]->head);
50547 + uiomem->size = (regs->rings[i]->entries * sizeof(u32_t)) +
50548 + sizeof(struct uio_ubicom32ring_desc);
50549 + ++uiomem;
50550 + }
50551 +
50552 + while (uiomem < &uioinfo->mem[MAX_UIO_MAPS]) {
50553 + uiomem->size = 0;
50554 + ++uiomem;
50555 + }
50556 +
50557 + /* This driver requires no hardware specific kernel code to handle
50558 + * interrupts. Instead, the interrupt handler simply disables the
50559 + * interrupt in the interrupt controller. User space is responsible
50560 + * for performing hardware specific acknowledge and re-enabling of
50561 + * the interrupt in the interrupt controller.
50562 + *
50563 + * Interrupt sharing is not supported.
50564 + */
50565 + uioinfo->irq_flags = IRQF_DISABLED;
50566 + uioinfo->irqcontrol = uio_ubicom32ring_irqcontrol;
50567 +
50568 + ret = uio_register_device(&pdev->dev, priv->uioinfo);
50569 + if (ret) {
50570 + dev_err(&pdev->dev, "unable to register uio device\n");
50571 + goto fail;
50572 + }
50573 +
50574 + platform_set_drvdata(pdev, priv);
50575 +
50576 + dev_info(&pdev->dev, "'%s' using irq: rx %d tx %d, regs %p\n",
50577 + priv->name, priv->irq_rx, priv->irq_tx, priv->regs);
50578 +
50579 + return 0;
50580 +
50581 +fail:
50582 + kfree(uioinfo);
50583 + kfree(priv);
50584 + return ret;
50585 +}
50586 +
50587 +static int uio_ubicom32ring_remove(struct platform_device *pdev)
50588 +{
50589 + struct uio_ubicom32ring_data *priv = platform_get_drvdata(pdev);
50590 +
50591 + uio_unregister_device(priv->uioinfo);
50592 + kfree(priv->uioinfo);
50593 + kfree(priv);
50594 + return 0;
50595 +}
50596 +
50597 +static struct platform_driver uio_ubicom32ring = {
50598 + .probe = uio_ubicom32ring_probe,
50599 + .remove = uio_ubicom32ring_remove,
50600 + .driver = {
50601 + .name = DRIVER_NAME,
50602 + .owner = THIS_MODULE,
50603 + },
50604 +};
50605 +
50606 +static int __init uio_ubicom32ring_init(void)
50607 +{
50608 + return platform_driver_register(&uio_ubicom32ring);
50609 +}
50610 +
50611 +static void __exit uio_ubicom32ring_exit(void)
50612 +{
50613 + platform_driver_unregister(&uio_ubicom32ring);
50614 +}
50615 +
50616 +module_init(uio_ubicom32ring_init);
50617 +module_exit(uio_ubicom32ring_exit);
50618 +
50619 +MODULE_AUTHOR("Patrick Tjin");
50620 +MODULE_DESCRIPTION("Userspace I/O driver for Ubicom32 ring buffers");
50621 +MODULE_LICENSE("GPL v2");
50622 +MODULE_ALIAS("platform:" DRIVER_NAME);
50623 diff -ruN linux-2.6.30.10/drivers/usb/gadget/epautoconf.c linux-2.6.30.10-ubi/drivers/usb/gadget/epautoconf.c
50624 --- linux-2.6.30.10/drivers/usb/gadget/epautoconf.c 2009-12-04 08:00:07.000000000 +0200
50625 +++ linux-2.6.30.10-ubi/drivers/usb/gadget/epautoconf.c 2009-12-11 11:45:20.000000000 +0200
50626 @@ -154,6 +154,10 @@
50627 /* configure your hardware with enough buffering!! */
50628 }
50629 break;
50630 +
50631 + case USB_ENDPOINT_XFER_BULK:
50632 + if ((gadget->is_dualspeed) && (ep->maxpacket < 512))
50633 + return 0;
50634 }
50635
50636 /* MATCH!! */
50637 diff -ruN linux-2.6.30.10/drivers/usb/Kconfig linux-2.6.30.10-ubi/drivers/usb/Kconfig
50638 --- linux-2.6.30.10/drivers/usb/Kconfig 2009-12-04 08:00:07.000000000 +0200
50639 +++ linux-2.6.30.10-ubi/drivers/usb/Kconfig 2009-12-11 11:45:20.000000000 +0200
50640 @@ -22,6 +22,7 @@
50641 default y if PCMCIA && !M32R # sl811_cs
50642 default y if ARM # SL-811
50643 default y if SUPERH # r8a66597-hcd
50644 + default y if UBICOM32 # Ubicom's onchip USB Duial role controller
50645 default PCI
50646
50647 # many non-PCI SOC chips embed OHCI
50648 diff -ruN linux-2.6.30.10/drivers/usb/musb/Kconfig linux-2.6.30.10-ubi/drivers/usb/musb/Kconfig
50649 --- linux-2.6.30.10/drivers/usb/musb/Kconfig 2009-12-04 08:00:07.000000000 +0200
50650 +++ linux-2.6.30.10-ubi/drivers/usb/musb/Kconfig 2009-12-11 11:45:20.000000000 +0200
50651 @@ -12,7 +12,7 @@
50652 depends on !SUPERH
50653 select TWL4030_USB if MACH_OMAP_3430SDP
50654 select USB_OTG_UTILS
50655 - tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, ...)'
50656 + tristate 'Inventra Highspeed Dual Role Controller (TI, ADI, Ubicom, ...)'
50657 help
50658 Say Y here if your system has a dual role high speed USB
50659 controller based on the Mentor Graphics silicon IP. Then
50660 diff -ruN linux-2.6.30.10/drivers/usb/musb/Makefile linux-2.6.30.10-ubi/drivers/usb/musb/Makefile
50661 --- linux-2.6.30.10/drivers/usb/musb/Makefile 2009-12-04 08:00:07.000000000 +0200
50662 +++ linux-2.6.30.10-ubi/drivers/usb/musb/Makefile 2009-12-11 11:45:20.000000000 +0200
50663 @@ -30,6 +30,10 @@
50664 musb_hdrc-objs += blackfin.o
50665 endif
50666
50667 +ifeq ($(CONFIG_UBICOM32), y)
50668 + musb_hdrc-objs += ubi32_usb.o
50669 +endif
50670 +
50671 ifeq ($(CONFIG_USB_GADGET_MUSB_HDRC),y)
50672 musb_hdrc-objs += musb_gadget_ep0.o musb_gadget.o
50673 endif
50674 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_core.c linux-2.6.30.10-ubi/drivers/usb/musb/musb_core.c
50675 --- linux-2.6.30.10/drivers/usb/musb/musb_core.c 2009-12-04 08:00:07.000000000 +0200
50676 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_core.c 2009-12-11 11:45:20.000000000 +0200
50677 @@ -105,6 +105,13 @@
50678 #include <asm/mach-types.h>
50679 #endif
50680
50681 +#ifdef CONFIG_UBICOM32
50682 +#include <asm/ip5000.h>
50683 +#include <asm/ubicom32-tio.h>
50684 +extern void ubi32_usb_init(void);
50685 +extern void ubi32_usb_int_clr(void);
50686 +#endif
50687 +
50688 #include "musb_core.h"
50689
50690
50691 @@ -147,8 +154,37 @@
50692 }
50693
50694 /*-------------------------------------------------------------------------*/
50695 +#if defined(CONFIG_UBICOM32)
50696 +
50697 +/*
50698 + * Load an endpoint's FIFO
50699 + */
50700 +void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 wCount, const u8 *pSource)
50701 +{
50702 + void __iomem *fifo = hw_ep->fifo;
50703 +
50704 + prefetch((u8 *)pSource);
50705 +
50706 + DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
50707 + 'T', hw_ep->epnum, fifo, wCount, pSource);
50708 +
50709 + usb_tio_write_fifo((u32)fifo, (u32)pSource, wCount);
50710 +
50711 +}
50712 +
50713 +/*
50714 + * Unload an endpoint's FIFO
50715 + */
50716 +void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 wCount, u8 *pDest)
50717 +{
50718 +
50719 + void __iomem *fifo = hw_ep->fifo;
50720 + DBG(4, "%cX ep%d fifo %p count %d buf %p\n",
50721 + 'R', hw_ep->epnum, fifo, wCount, pDest);
50722 + usb_tio_read_fifo((u32)fifo, (u32)pDest, wCount);
50723 +}
50724
50725 -#if !defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_BLACKFIN)
50726 +#elif !defined(CONFIG_USB_TUSB6010) && !defined(CONFIG_BLACKFIN)
50727
50728 /*
50729 * Load an endpoint's FIFO
50730 @@ -227,8 +263,7 @@
50731 readsb(fifo, dst, len);
50732 }
50733 }
50734 -
50735 -#endif /* normal PIO */
50736 +#endif /* !T6010 && !BLACKFIN */
50737
50738
50739 /*-------------------------------------------------------------------------*/
50740 @@ -874,12 +909,19 @@
50741 musb_writeb(regs, MUSB_TESTMODE, 0);
50742
50743 /* put into basic highspeed mode and start session */
50744 +#ifndef CONFIG_UBICOM32
50745 musb_writeb(regs, MUSB_POWER, MUSB_POWER_ISOUPDATE
50746 | MUSB_POWER_SOFTCONN
50747 | MUSB_POWER_HSENAB
50748 /* ENSUSPEND wedges tusb */
50749 /* | MUSB_POWER_ENSUSPEND */
50750 );
50751 +#else
50752 + musb_writeb(regs, MUSB_POWER, MUSB_POWER_HSENAB
50753 + /* ENSUSPEND wedges tusb */
50754 + /* | MUSB_POWER_ENSUSPEND */
50755 + );
50756 +#endif
50757
50758 musb->is_active = 0;
50759 devctl = musb_readb(regs, MUSB_DEVCTL);
50760 @@ -1081,6 +1123,7 @@
50761 };
50762
50763
50764 +#ifndef CONFIG_UBICOM32
50765 /*
50766 * configure a fifo; for non-shared endpoints, this may be called
50767 * once for a tx fifo and once for an rx fifo.
50768 @@ -1240,7 +1283,7 @@
50769
50770 return 0;
50771 }
50772 -
50773 +#endif /* CONFIG_UBICOM32 */
50774
50775 /*
50776 * ep_config_from_hw - when MUSB_C_DYNFIFO_DEF is false
50777 @@ -1256,6 +1299,11 @@
50778 DBG(2, "<== static silicon ep config\n");
50779
50780 /* FIXME pick up ep0 maxpacket size */
50781 +#ifdef CONFIG_UBICOM32
50782 + /* set ep0 to shared_fifo, otherwise urb will be put to out_qh but ep0_irq try to get the urb from in_qh*/
50783 + hw_ep = musb->endpoints;
50784 + hw_ep->is_shared_fifo = true;
50785 +#endif
50786
50787 for (epnum = 1; epnum < musb->config->num_eps; epnum++) {
50788 musb_ep_select(mbase, epnum);
50789 @@ -1276,14 +1324,27 @@
50790 /* REVISIT: this algorithm is lazy, we should at least
50791 * try to pick a double buffered endpoint.
50792 */
50793 +#ifndef CONFIG_UBICOM32
50794 if (musb->bulk_ep)
50795 continue;
50796 musb->bulk_ep = hw_ep;
50797 +#else
50798 + if ((musb->bulk_ep_in) && (musb->bulk_ep_out))
50799 + continue;
50800 + /* Save theEP with 1024 Bytes FIFO for ISO */
50801 + if(hw_ep->max_packet_sz_tx == 512) {
50802 + if (!musb->bulk_ep_in) {
50803 + musb->bulk_ep_in = hw_ep;
50804 + } else if (!musb->bulk_ep_out) {
50805 + musb->bulk_ep_out = hw_ep;
50806 + }
50807 + }
50808 +#endif /* CONFIG_UBICOM32 */
50809 #endif
50810 }
50811
50812 #ifdef CONFIG_USB_MUSB_HDRC_HCD
50813 - if (!musb->bulk_ep) {
50814 + if ((!musb->bulk_ep_in) || (!musb->bulk_ep_out)) {
50815 pr_debug("%s: missing bulk\n", musb_driver_name);
50816 return -EINVAL;
50817 }
50818 @@ -1393,12 +1454,16 @@
50819 musb->epmask = 1;
50820
50821 if (reg & MUSB_CONFIGDATA_DYNFIFO) {
50822 +#ifndef CONFIG_UBICOM32
50823 if (musb->config->dyn_fifo)
50824 status = ep_config_from_table(musb);
50825 - else {
50826 + else
50827 +#endif
50828 + {
50829 ERR("reconfigure software for Dynamic FIFOs\n");
50830 status = -ENODEV;
50831 }
50832 +
50833 } else {
50834 if (!musb->config->dyn_fifo)
50835 status = ep_config_from_hw(musb);
50836 @@ -1462,8 +1527,8 @@
50837
50838 /*-------------------------------------------------------------------------*/
50839
50840 -#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430)
50841 -
50842 +#if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3430) || defined(CONFIG_UBICOM32)
50843 +static u32_t musb_int_count = 0;
50844 static irqreturn_t generic_interrupt(int irq, void *__hci)
50845 {
50846 unsigned long flags;
50847 @@ -1472,10 +1537,17 @@
50848
50849 spin_lock_irqsave(&musb->lock, flags);
50850
50851 +#ifndef CONFIG_UBICOM32
50852 musb->int_usb = musb_readb(musb->mregs, MUSB_INTRUSB);
50853 musb->int_tx = musb_readw(musb->mregs, MUSB_INTRTX);
50854 musb->int_rx = musb_readw(musb->mregs, MUSB_INTRRX);
50855 +#else
50856 + musb_read_int_status(&musb->int_usb, &musb->int_tx, &musb->int_rx);
50857 + //ubi32_usb_int_clr();
50858 + musb_int_count++;
50859 +#endif
50860
50861 + DBG(4, "usb %x, tx %x, rx %x", musb->int_usb, musb->int_tx, musb->int_rx);
50862 if (musb->int_usb || musb->int_tx || musb->int_rx)
50863 retval = musb_interrupt(musb);
50864
50865 @@ -2210,6 +2282,10 @@
50866
50867 static int __init musb_init(void)
50868 {
50869 +#ifdef CONFIG_UBICOM32
50870 + ubi32_usb_init();
50871 +#endif
50872 +
50873 #ifdef CONFIG_USB_MUSB_HDRC_HCD
50874 if (usb_disabled())
50875 return 0;
50876 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_core.h linux-2.6.30.10-ubi/drivers/usb/musb/musb_core.h
50877 --- linux-2.6.30.10/drivers/usb/musb/musb_core.h 2009-12-04 08:00:07.000000000 +0200
50878 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_core.h 2009-12-11 11:45:20.000000000 +0200
50879 @@ -326,7 +326,12 @@
50880 * queue until it completes or NAKs too much; then we try the next
50881 * endpoint.
50882 */
50883 +#ifdef CONFIG_UBICOM32
50884 + struct musb_hw_ep *bulk_ep_in;
50885 + struct musb_hw_ep *bulk_ep_out;
50886 +#else
50887 struct musb_hw_ep *bulk_ep;
50888 +#endif
50889
50890 struct list_head control; /* of musb_qh */
50891 struct list_head in_bulk; /* of musb_qh */
50892 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_gadget.c linux-2.6.30.10-ubi/drivers/usb/musb/musb_gadget.c
50893 --- linux-2.6.30.10/drivers/usb/musb/musb_gadget.c 2009-12-04 08:00:07.000000000 +0200
50894 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_gadget.c 2009-12-11 11:45:20.000000000 +0200
50895 @@ -432,7 +432,7 @@
50896 * probably rates reporting as a host error
50897 */
50898 if (csr & MUSB_TXCSR_P_SENTSTALL) {
50899 - csr |= MUSB_TXCSR_P_WZC_BITS;
50900 + csr &= ~(MUSB_TXCSR_P_WZC_BITS);
50901 csr &= ~MUSB_TXCSR_P_SENTSTALL;
50902 musb_writew(epio, MUSB_TXCSR, csr);
50903 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
50904 @@ -448,7 +448,7 @@
50905
50906 if (csr & MUSB_TXCSR_P_UNDERRUN) {
50907 /* we NAKed, no big deal ... little reason to care */
50908 - csr |= MUSB_TXCSR_P_WZC_BITS;
50909 + csr &= ~(MUSB_TXCSR_P_WZC_BITS);
50910 csr &= ~(MUSB_TXCSR_P_UNDERRUN
50911 | MUSB_TXCSR_TXPKTRDY);
50912 musb_writew(epio, MUSB_TXCSR, csr);
50913 @@ -584,10 +584,16 @@
50914 u16 csr = 0;
50915 const u8 epnum = req->epnum;
50916 struct usb_request *request = &req->request;
50917 - struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out;
50918 + struct musb_ep *musb_ep = NULL;
50919 void __iomem *epio = musb->endpoints[epnum].regs;
50920 - unsigned fifo_count = 0;
50921 - u16 len = musb_ep->packet_sz;
50922 + u16 fifo_count = 0;
50923 + u16 len = 0;
50924 +
50925 + if (musb->endpoints[epnum].is_shared_fifo)
50926 + musb_ep = &musb->endpoints[epnum].ep_in;
50927 + else
50928 + musb_ep = &musb->endpoints[epnum].ep_out;
50929 + len = musb_ep->packet_sz;
50930
50931 csr = musb_readw(epio, MUSB_RXCSR);
50932
50933 @@ -726,7 +732,7 @@
50934 */
50935
50936 /* ack the read! */
50937 - csr |= MUSB_RXCSR_P_WZC_BITS;
50938 + csr &= ~MUSB_RXCSR_P_WZC_BITS;
50939 csr &= ~MUSB_RXCSR_RXPKTRDY;
50940 musb_writew(epio, MUSB_RXCSR, csr);
50941 }
50942 @@ -745,10 +751,15 @@
50943 u16 csr;
50944 struct usb_request *request;
50945 void __iomem *mbase = musb->mregs;
50946 - struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out;
50947 + struct musb_ep *musb_ep = NULL;
50948 void __iomem *epio = musb->endpoints[epnum].regs;
50949 struct dma_channel *dma;
50950
50951 + if (musb->endpoints[epnum].is_shared_fifo)
50952 + musb_ep = &musb->endpoints[epnum].ep_in;
50953 + else
50954 + musb_ep = &musb->endpoints[epnum].ep_out;
50955 +
50956 musb_ep_select(mbase, epnum);
50957
50958 request = next_request(musb_ep);
50959 @@ -1769,7 +1780,9 @@
50960 }
50961 }
50962 }
50963 -
50964 +#ifndef CONFIG_USB_MUSB_OTG
50965 + musb_pullup(musb, 1);
50966 +#endif
50967 return retval;
50968 }
50969 EXPORT_SYMBOL(usb_gadget_register_driver);
50970 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_gadget_ep0.c linux-2.6.30.10-ubi/drivers/usb/musb/musb_gadget_ep0.c
50971 --- linux-2.6.30.10/drivers/usb/musb/musb_gadget_ep0.c 2009-12-04 08:00:07.000000000 +0200
50972 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_gadget_ep0.c 2009-12-11 11:45:20.000000000 +0200
50973 @@ -240,14 +240,14 @@
50974 case USB_REQ_SET_ADDRESS:
50975 /* change it after the status stage */
50976 musb->set_address = true;
50977 - musb->address = (u8) (ctrlrequest->wValue & 0x7f);
50978 + musb->address = (u8) (le16_to_cpu(ctrlrequest->wValue) & 0x7f);
50979 handled = 1;
50980 break;
50981
50982 case USB_REQ_CLEAR_FEATURE:
50983 switch (recip) {
50984 case USB_RECIP_DEVICE:
50985 - if (ctrlrequest->wValue
50986 + if (le16_to_cpu(ctrlrequest->wValue)
50987 != USB_DEVICE_REMOTE_WAKEUP)
50988 break;
50989 musb->may_wakeup = 0;
50990 @@ -261,8 +261,8 @@
50991
50992 if (num == 0
50993 || num >= MUSB_C_NUM_EPS
50994 - || ctrlrequest->wValue
50995 - != USB_ENDPOINT_HALT)
50996 + || le16_to_cpu(ctrlrequest->wValue
50997 + != USB_ENDPOINT_HALT))
50998 break;
50999
51000 if (ctrlrequest->wIndex & USB_DIR_IN)
51001 @@ -292,7 +292,7 @@
51002 switch (recip) {
51003 case USB_RECIP_DEVICE:
51004 handled = 1;
51005 - switch (ctrlrequest->wValue) {
51006 + switch (le16_to_cpu(ctrlrequest->wValue)) {
51007 case USB_DEVICE_REMOTE_WAKEUP:
51008 musb->may_wakeup = 1;
51009 break;
51010 @@ -374,8 +374,8 @@
51011
51012 if (epnum == 0
51013 || epnum >= MUSB_C_NUM_EPS
51014 - || ctrlrequest->wValue
51015 - != USB_ENDPOINT_HALT)
51016 + || le16_to_cpu(ctrlrequest->wValue
51017 + != USB_ENDPOINT_HALT))
51018 break;
51019
51020 ep = musb->endpoints + epnum;
51021 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_host.c linux-2.6.30.10-ubi/drivers/usb/musb/musb_host.c
51022 --- linux-2.6.30.10/drivers/usb/musb/musb_host.c 2009-12-04 08:00:07.000000000 +0200
51023 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_host.c 2009-12-11 11:45:20.000000000 +0200
51024 @@ -160,7 +160,11 @@
51025 /* NOTE: no locks here; caller should lock and select EP */
51026 if (ep->epnum) {
51027 txcsr = musb_readw(ep->regs, MUSB_TXCSR);
51028 +#ifndef CONFIG_UBICOM32
51029 txcsr |= MUSB_TXCSR_TXPKTRDY | MUSB_TXCSR_H_WZC_BITS;
51030 +#else
51031 + txcsr |= (MUSB_TXCSR_TXPKTRDY & (~MUSB_TXCSR_H_WZC_BITS));
51032 +#endif
51033 musb_writew(ep->regs, MUSB_TXCSR, txcsr);
51034 } else {
51035 txcsr = MUSB_CSR0_H_SETUPPKT | MUSB_CSR0_TXPKTRDY;
51036 @@ -223,6 +227,8 @@
51037 break;
51038 default: /* bulk, interrupt */
51039 /* actual_length may be nonzero on retry paths */
51040 + if (urb->actual_length)
51041 + DBG(3 ,"musb_start_urb: URB %p retried, len: %d\n", urb, urb->actual_length);
51042 buf = urb->transfer_buffer + urb->actual_length;
51043 len = urb->transfer_buffer_length - urb->actual_length;
51044 }
51045 @@ -342,13 +348,13 @@
51046 if (!is_in) {
51047 csr = musb_readw(epio, MUSB_TXCSR);
51048 usb_settoggle(udev, qh->epnum, 1,
51049 - (csr & MUSB_TXCSR_H_DATATOGGLE)
51050 - ? 1 : 0);
51051 + ((csr & MUSB_TXCSR_H_DATATOGGLE)
51052 + ? 1 : 0));
51053 } else {
51054 csr = musb_readw(epio, MUSB_RXCSR);
51055 usb_settoggle(udev, qh->epnum, 0,
51056 - (csr & MUSB_RXCSR_H_DATATOGGLE)
51057 - ? 1 : 0);
51058 + ((csr & MUSB_RXCSR_H_DATATOGGLE)
51059 + ? 1 : 0));
51060 }
51061 }
51062
51063 @@ -556,7 +562,11 @@
51064 musb_read_fifo(hw_ep, length, buf);
51065
51066 csr = musb_readw(epio, MUSB_RXCSR);
51067 +#ifndef CONFIG_UBICOM32
51068 csr |= MUSB_RXCSR_H_WZC_BITS;
51069 +#else
51070 + csr &= ~MUSB_RXCSR_H_WZC_BITS;
51071 +#endif
51072 if (unlikely(do_flush))
51073 musb_h_flush_rxfifo(hw_ep, csr);
51074 else {
51075 @@ -590,6 +600,7 @@
51076
51077 /* if programmed for Tx, put it in RX mode */
51078 if (ep->is_shared_fifo) {
51079 +#ifndef CONFIG_UBICOM32
51080 csr = musb_readw(ep->regs, MUSB_TXCSR);
51081 if (csr & MUSB_TXCSR_MODE) {
51082 musb_h_tx_flush_fifo(ep);
51083 @@ -604,7 +615,18 @@
51084 */
51085 if (csr & MUSB_TXCSR_DMAMODE)
51086 musb_writew(ep->regs, MUSB_TXCSR, MUSB_TXCSR_DMAMODE);
51087 +
51088 +#else
51089 + /* clear mode (and everything else) to enable Rx */
51090 musb_writew(ep->regs, MUSB_TXCSR, 0);
51091 + /* scrub all previous state, clearing toggle */
51092 + csr = musb_readw(ep->regs, MUSB_RXCSR);
51093 + if (csr & MUSB_RXCSR_RXPKTRDY)
51094 + WARNING("rx%d, packet/%d ready?\n", ep->epnum,
51095 + musb_readw(ep->regs, MUSB_RXCOUNT));
51096 +
51097 + musb_h_flush_rxfifo(ep, MUSB_RXCSR_CLRDATATOG);
51098 +#endif
51099
51100 /* scrub all previous state, clearing toggle */
51101 } else {
51102 @@ -1138,8 +1160,18 @@
51103 void __iomem *mbase = musb->mregs;
51104 struct dma_channel *dma;
51105
51106 +#ifdef CONFIG_UBICOM32
51107 + if (hw_ep->is_shared_fifo) {
51108 + qh = hw_ep->in_qh;
51109 + }
51110 +#ifdef CONFIG_USB_SERIAL_SIERRAWIRELESS
51111 + printk(KERN_DEBUG "OUT/TX%d end, csr %04x%s\n", epnum, tx_csr,
51112 + dma ? ", dma" : "");
51113 +#endif
51114 +#endif
51115 urb = next_urb(qh);
51116
51117 +
51118 musb_ep_select(mbase, epnum);
51119 tx_csr = musb_readw(epio, MUSB_TXCSR);
51120
51121 @@ -1180,9 +1212,14 @@
51122 * we have a candidate... NAKing is *NOT* an error
51123 */
51124 musb_ep_select(mbase, epnum);
51125 +#ifndef CONFIG_UBICOM32
51126 musb_writew(epio, MUSB_TXCSR,
51127 MUSB_TXCSR_H_WZC_BITS
51128 | MUSB_TXCSR_TXPKTRDY);
51129 +#else
51130 + musb_writew(epio, MUSB_TXCSR,
51131 + MUSB_TXCSR_TXPKTRDY);
51132 +#endif
51133 return;
51134 }
51135
51136 @@ -1353,8 +1390,14 @@
51137 qh->segsize = length;
51138
51139 musb_ep_select(mbase, epnum);
51140 +#ifndef CONFIG_UBICOM32
51141 + musb_writew(epio, MUSB_TXCSR,
51142 + MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY);
51143 +#else
51144 musb_writew(epio, MUSB_TXCSR,
51145 - MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY);
51146 + MUSB_TXCSR_MODE | MUSB_TXCSR_TXPKTRDY);
51147 +#endif
51148 +
51149 }
51150
51151
51152 @@ -1414,7 +1457,11 @@
51153
51154 /* clear nak timeout bit */
51155 rx_csr = musb_readw(epio, MUSB_RXCSR);
51156 +#ifndef CONFIG_UBICOM32
51157 rx_csr |= MUSB_RXCSR_H_WZC_BITS;
51158 +#else
51159 + rx_csr &= ~MUSB_RXCSR_H_WZC_BITS;
51160 +#endif
51161 rx_csr &= ~MUSB_RXCSR_DATAERROR;
51162 musb_writew(epio, MUSB_RXCSR, rx_csr);
51163
51164 @@ -1483,6 +1530,13 @@
51165
51166 pipe = urb->pipe;
51167
51168 +#ifdef CONFIG_UBICOM32
51169 +#ifdef CONFIG_USB_SERIAL_SIERRAWIRELESS
51170 + printk(KERN_DEBUG "RXCSR%d %04x, reqpkt, len %zu%s\n", epnum, rx_csr,
51171 + xfer_len, dma ? ", dma" : "");
51172 +#endif
51173 +#endif
51174 +
51175 DBG(5, "<== hw %d rxcsr %04x, urb actual %d (+dma %zu)\n",
51176 epnum, rx_csr, urb->actual_length,
51177 dma ? dma->actual_len : 0);
51178 @@ -1521,8 +1575,15 @@
51179 return;
51180 }
51181 musb_ep_select(mbase, epnum);
51182 +#ifndef CONFIG_UBICOM32
51183 rx_csr |= MUSB_RXCSR_H_WZC_BITS;
51184 rx_csr &= ~MUSB_RXCSR_DATAERROR;
51185 +#else
51186 + /* NEED TO EVALUATE CHANGE */
51187 + rx_csr &= ~MUSB_RXCSR_H_WZC_BITS;
51188 + rx_csr &= ~MUSB_RXCSR_DATAERROR;
51189 +// musb_writew(epio, MUSB_RXCSR, (~(MUSB_RXCSR_H_WZC_BITS))| MUSB_RXCSR_H_REQPKT);
51190 +#endif
51191 musb_writew(epio, MUSB_RXCSR, rx_csr);
51192
51193 goto finish;
51194 @@ -1579,8 +1640,13 @@
51195 rx_csr &= ~MUSB_RXCSR_H_REQPKT;
51196
51197 musb_ep_select(mbase, epnum);
51198 +#ifndef CONFIG_UBICOM32
51199 musb_writew(epio, MUSB_RXCSR,
51200 MUSB_RXCSR_H_WZC_BITS | rx_csr);
51201 +#else
51202 + musb_writew(epio, MUSB_RXCSR,
51203 + (~MUSB_RXCSR_H_WZC_BITS) & rx_csr);
51204 +#endif
51205 }
51206 #endif
51207 if (dma && (rx_csr & MUSB_RXCSR_DMAENAB)) {
51208 @@ -1610,7 +1676,7 @@
51209 else
51210 done = false;
51211
51212 - } else {
51213 + } else {
51214 /* done if urb buffer is full or short packet is recd */
51215 done = (urb->actual_length + xfer_len >=
51216 urb->transfer_buffer_length
51217 @@ -1823,7 +1889,11 @@
51218 } else if (hw_ep->out_qh != NULL)
51219 continue;
51220
51221 +#ifndef CONFIG_UBICOM32
51222 if (hw_ep == musb->bulk_ep)
51223 +#else
51224 + if ((hw_ep == musb->bulk_ep_in) || (hw_ep == musb->bulk_ep_out)) /* Ubicom */
51225 +#endif
51226 continue;
51227
51228 if (is_in)
51229 @@ -1836,7 +1906,14 @@
51230 best_end = epnum;
51231 }
51232 }
51233 +
51234 +#ifdef CONFIG_UBICOM32
51235 + if (((best_diff >= qh->maxpacket)) && ((qh->type == USB_ENDPOINT_XFER_BULK) && (!is_in)))
51236 + best_end = -1;
51237 +#endif
51238 +
51239 /* use bulk reserved ep1 if no other ep is free */
51240 +#ifndef CONFIG_UBICOM32
51241 if (best_end < 0 && qh->type == USB_ENDPOINT_XFER_BULK) {
51242 hw_ep = musb->bulk_ep;
51243 if (is_in)
51244 @@ -1858,6 +1935,22 @@
51245 } else if (best_end < 0) {
51246 return -ENOSPC;
51247 }
51248 +#else
51249 + if (best_end < 0 && qh->type == USB_ENDPOINT_XFER_BULK) {
51250 + /* hw_ep = musb->bulk_ep; */
51251 + if (is_in) {
51252 + head = &musb->in_bulk;
51253 + hw_ep = musb->bulk_ep_in; /* UBICOM */
51254 + }
51255 + else {
51256 + head = &musb->out_bulk;
51257 + hw_ep = musb->bulk_ep_out; /* UBICOM */
51258 + }
51259 + goto success;
51260 + } else if (best_end < 0) {
51261 + return -ENOSPC;
51262 + }
51263 +#endif
51264
51265 idle = 1;
51266 qh->mux = 0;
51267 @@ -1869,6 +1962,13 @@
51268 list_add_tail(&qh->ring, head);
51269 qh->mux = 1;
51270 }
51271 + /*
51272 + * It's not make sense to set NAK timeout when qh->mux = 0,
51273 + * There is nothing else to schedule
51274 + */
51275 + if ((qh->type == USB_ENDPOINT_XFER_BULK) && (qh->mux == 0))
51276 + qh->intv_reg = 0;
51277 +
51278 qh->hw_ep = hw_ep;
51279 qh->hep->hcpriv = qh;
51280 if (idle)
51281 @@ -1975,6 +2075,15 @@
51282 /* ISO always uses logarithmic encoding */
51283 interval = min_t(u8, epd->bInterval, 16);
51284 break;
51285 +#ifdef COMFIG_UBICOM32
51286 + case USB_ENDPOINT_XFER_BULK:
51287 + if (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
51288 + interval = (USB_SPEED_HIGH == urb->dev->speed) ? 16: 2;
51289 + else
51290 + interval = 0;
51291 + break;
51292 +#endif
51293 +
51294 default:
51295 /* REVISIT we actually want to use NAK limits, hinting to the
51296 * transfer scheduling logic to try some other qh, e.g. try
51297 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_io.h linux-2.6.30.10-ubi/drivers/usb/musb/musb_io.h
51298 --- linux-2.6.30.10/drivers/usb/musb/musb_io.h 2009-12-04 08:00:07.000000000 +0200
51299 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_io.h 2009-12-11 11:45:20.000000000 +0200
51300 @@ -58,6 +58,7 @@
51301
51302 #ifndef CONFIG_BLACKFIN
51303
51304 +#ifndef CONFIG_UBICOM32
51305 /* NOTE: these offsets are all in bytes */
51306
51307 static inline u16 musb_readw(const void __iomem *addr, unsigned offset)
51308 @@ -72,7 +73,37 @@
51309
51310 static inline void musb_writel(void __iomem *addr, unsigned offset, u32 data)
51311 { __raw_writel(data, addr + offset); }
51312 +#else
51313 +#include <asm/ubicom32-tio.h>
51314 +static inline u16 musb_readw(const void __iomem *addr, unsigned offset)
51315 +{
51316 + u16 data;
51317 + usb_tio_read_u16((u32)(addr + offset), &data);
51318 + return data;
51319 +}
51320
51321 +static inline u8 musb_readb(const void __iomem *addr, unsigned offset)
51322 +{
51323 + u8 data;
51324 + usb_tio_read_u8((u32)(addr + offset), &data);
51325 + return data;
51326 +}
51327 +
51328 +static inline void musb_writew(void __iomem *addr, unsigned offset, u16 data)
51329 +{
51330 + usb_tio_write_u16((u32)(addr + offset), data);
51331 +}
51332 +
51333 +static inline void musb_writeb(void __iomem *addr, unsigned offset, u8 data)
51334 +{
51335 + usb_tio_write_u8((u32)(addr + offset), data);
51336 +}
51337 +
51338 +static inline void musb_read_int_status(u8_t *int_usb, u16_t *int_tx, u16_t *int_rx)
51339 +{
51340 + return usb_tio_read_int_status(int_usb, int_tx, int_rx);
51341 +}
51342 +#endif /* CONFIG_UBICOM32 */
51343
51344 #ifdef CONFIG_USB_TUSB6010
51345
51346 @@ -106,7 +137,7 @@
51347 __raw_writew(tmp, addr + (offset & ~1));
51348 }
51349
51350 -#else
51351 +#elif !defined(CONFIG_UBICOM32)
51352
51353 static inline u8 musb_readb(const void __iomem *addr, unsigned offset)
51354 { return __raw_readb(addr + offset); }
51355 diff -ruN linux-2.6.30.10/drivers/usb/musb/musb_regs.h linux-2.6.30.10-ubi/drivers/usb/musb/musb_regs.h
51356 --- linux-2.6.30.10/drivers/usb/musb/musb_regs.h 2009-12-04 08:00:07.000000000 +0200
51357 +++ linux-2.6.30.10-ubi/drivers/usb/musb/musb_regs.h 2009-12-11 11:45:20.000000000 +0200
51358 @@ -167,6 +167,7 @@
51359 (MUSB_TXCSR_H_NAKTIMEOUT | MUSB_TXCSR_H_RXSTALL \
51360 | MUSB_TXCSR_H_ERROR | MUSB_TXCSR_FIFONOTEMPTY)
51361
51362 +
51363 /* RXCSR in Peripheral and Host mode */
51364 #define MUSB_RXCSR_AUTOCLEAR 0x8000
51365 #define MUSB_RXCSR_DMAENAB 0x2000
51366 diff -ruN linux-2.6.30.10/drivers/usb/musb/ubi32_usb.c linux-2.6.30.10-ubi/drivers/usb/musb/ubi32_usb.c
51367 --- linux-2.6.30.10/drivers/usb/musb/ubi32_usb.c 1970-01-01 02:00:00.000000000 +0200
51368 +++ linux-2.6.30.10-ubi/drivers/usb/musb/ubi32_usb.c 2009-12-11 11:45:20.000000000 +0200
51369 @@ -0,0 +1,156 @@
51370 +/*
51371 + * drivers/usb/musb/ubi32_usb.c
51372 + * Ubicom32 usb controller driver.
51373 + *
51374 + * (C) Copyright 2009, Ubicom, Inc.
51375 + * Copyright (C) 2005-2006 by Texas Instruments
51376 + *
51377 + * Derived from the Texas Instruments Inventra Controller Driver for Linux.
51378 + *
51379 + * This file is part of the Ubicom32 Linux Kernel Port.
51380 + *
51381 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
51382 + * it and/or modify it under the terms of the GNU General Public License
51383 + * as published by the Free Software Foundation, either version 2 of the
51384 + * License, or (at your option) any later version.
51385 + *
51386 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
51387 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
51388 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
51389 + * the GNU General Public License for more details.
51390 + *
51391 + * You should have received a copy of the GNU General Public License
51392 + * along with the Ubicom32 Linux Kernel Port. If not,
51393 + * see <http://www.gnu.org/licenses/>.
51394 + *
51395 + * Ubicom32 implementation derived from (with many thanks):
51396 + * arch/m68knommu
51397 + * arch/blackfin
51398 + * arch/parisc
51399 + */
51400 +#include <linux/module.h>
51401 +#include <linux/kernel.h>
51402 +#include <linux/sched.h>
51403 +#include <linux/slab.h>
51404 +#include <linux/init.h>
51405 +#include <linux/list.h>
51406 +#include <linux/clk.h>
51407 +#include <linux/io.h>
51408 +
51409 +#include <asm/io.h>
51410 +#include <asm/ip5000.h>
51411 +#include "musb_core.h"
51412 +
51413 +void musb_platform_enable(struct musb *musb)
51414 +{
51415 +}
51416 +void musb_platform_disable(struct musb *musb)
51417 +{
51418 +}
51419 +
51420 +int musb_platform_set_mode(struct musb *musb, u8 musb_mode) {
51421 + return 0;
51422 +}
51423 +
51424 +static void ip5k_usb_hcd_vbus_power(struct musb *musb, int is_on, int sleeping)
51425 +{
51426 +}
51427 +
51428 +static void ip5k_usb_hcd_set_vbus(struct musb *musb, int is_on)
51429 +{
51430 + u8 devctl;
51431 + /* HDRC controls CPEN, but beware current surges during device
51432 + * connect. They can trigger transient overcurrent conditions
51433 + * that must be ignored.
51434 + */
51435 +
51436 + devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
51437 +
51438 + if (is_on) {
51439 + musb->is_active = 1;
51440 + musb->xceiv.default_a = 1;
51441 + musb->xceiv.state = OTG_STATE_A_WAIT_VRISE;
51442 + devctl |= MUSB_DEVCTL_SESSION;
51443 +
51444 + MUSB_HST_MODE(musb);
51445 + } else {
51446 + musb->is_active = 0;
51447 +
51448 + /* NOTE: we're skipping A_WAIT_VFALL -> A_IDLE and
51449 + * jumping right to B_IDLE...
51450 + */
51451 +
51452 + musb->xceiv.default_a = 0;
51453 + musb->xceiv.state = OTG_STATE_B_IDLE;
51454 + devctl &= ~MUSB_DEVCTL_SESSION;
51455 +
51456 + MUSB_DEV_MODE(musb);
51457 + }
51458 + musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
51459 +
51460 + DBG(1, "VBUS %s, devctl %02x "
51461 + /* otg %3x conf %08x prcm %08x */ "\n",
51462 + otg_state_string(musb),
51463 + musb_readb(musb->mregs, MUSB_DEVCTL));
51464 +}
51465 +static int ip5k_usb_hcd_set_power(struct otg_transceiver *x, unsigned mA)
51466 +{
51467 + return 0;
51468 +}
51469 +
51470 +static int musb_platform_resume(struct musb *musb);
51471 +
51472 +int __init musb_platform_init(struct musb *musb)
51473 +{
51474 +
51475 +#ifdef CONFIG_UBICOM32_V4
51476 + u32_t chip_id;
51477 + asm volatile (
51478 + "move.4 %0, CHIP_ID \n\t"
51479 + : "=r" (chip_id)
51480 + );
51481 + if (chip_id == 0x30001) {
51482 + *((u32_t *)(GENERAL_CFG_BASE + GEN_USB_PHY_TEST)) &= ~(1 << 30);
51483 + udelay(1);
51484 + *((u32_t *)(GENERAL_CFG_BASE + GEN_USB_PHY_TEST)) &= ~(1 << 31);
51485 + } else {
51486 + *((u32_t *)(GENERAL_CFG_BASE + GEN_USB_PHY_TEST)) &= ~(1 << 17);
51487 + udelay(1);
51488 + *((u32_t *)(GENERAL_CFG_BASE + GEN_USB_PHY_TEST)) &= ~(1 << 14);
51489 + }
51490 +#endif
51491 +
51492 + *((u32_t *)(GENERAL_CFG_BASE + GEN_USB_PHY_CFG)) |= ((1 << 14) | (1 <<15));
51493 +
51494 + /* The i-clk is AUTO gated. Hence there is no need
51495 + * to disable it until the driver is shutdown */
51496 +
51497 + clk_enable(musb->clock);
51498 + musb_platform_resume(musb);
51499 +
51500 + ip5k_usb_hcd_vbus_power(musb, musb->board_mode == MUSB_HOST, 1);
51501 +
51502 + if (is_host_enabled(musb))
51503 + musb->board_set_vbus = ip5k_usb_hcd_set_vbus;
51504 + if (is_peripheral_enabled(musb))
51505 + musb->xceiv.set_power = ip5k_usb_hcd_set_power;
51506 +
51507 + return 0;
51508 +}
51509 +
51510 +
51511 +int musb_platform_suspend(struct musb *musb)
51512 +{
51513 + return 0;
51514 +}
51515 +int musb_platform_resume(struct musb *musb)
51516 +{
51517 + return 0;
51518 +}
51519 +
51520 +int musb_platform_exit(struct musb *musb)
51521 +{
51522 + ip5k_usb_hcd_vbus_power(musb, 0 /*off*/, 1);
51523 + musb_platform_suspend(musb);
51524 + return 0;
51525 +}
51526 diff -ruN linux-2.6.30.10/drivers/video/backlight/Kconfig linux-2.6.30.10-ubi/drivers/video/backlight/Kconfig
51527 --- linux-2.6.30.10/drivers/video/backlight/Kconfig 2009-12-04 08:00:07.000000000 +0200
51528 +++ linux-2.6.30.10-ubi/drivers/video/backlight/Kconfig 2009-12-11 11:45:20.000000000 +0200
51529 @@ -93,6 +93,63 @@
51530 If you have an HP Jornada 700 series handheld (710/720/728)
51531 say Y to enable LCD control driver.
51532
51533 +config LCD_UBICOM32POWER
51534 + tristate "Ubicom LCD power Driver"
51535 + depends on LCD_CLASS_DEVICE && UBICOM32
51536 + default n
51537 + help
51538 + If you have a Ubicom32 based system with an LCD panel that requires
51539 + power control, say Y to enable the power control driver for it.
51540 +
51541 +config LCD_UBICOM32
51542 + tristate "Ubicom Backlight Driver"
51543 + depends on LCD_CLASS_DEVICE && UBICOM32
51544 + default n
51545 + help
51546 + This driver takes care of initialization of LCD panels with
51547 + built in controllers.
51548 +
51549 +menu "Ubicom32 LCD Panel Support"
51550 + depends on UBICOM32 && LCD_UBICOM32
51551 +
51552 +config LCD_UBICOM32_TFT2N0369E_P
51553 + bool "TFT2N0369E (Portrait)"
51554 + default n
51555 + help
51556 + Support for TFT2N0369 in portrait mode
51557 +
51558 +config LCD_UBICOM32_TFT2N0369E_L
51559 + bool "TFT2N0369E (Landscape)"
51560 + default n
51561 + help
51562 + Support for TFT2N0369 in landscape mode
51563 +
51564 +config LCD_UBICOM32_CFAF240320KTTS
51565 + bool "CFAF240320KTTS"
51566 + default n
51567 + help
51568 + Support for CFAF240320KTTS
51569 +
51570 +config LCD_UBICOM32_CFAF240320KTTS_180
51571 + bool "CFAF240320KTTS (180 rotation)"
51572 + default n
51573 + help
51574 + Support for CFAF240320KTTS rotated 180 degrees
51575 +
51576 +config LCD_UBICOM32_CFAF240320D
51577 + bool "CFAF240320D"
51578 + default n
51579 + help
51580 + Support for CFAF240320D
51581 +
51582 +config LCD_UBICOM32_CFAF320240F
51583 + bool "CFAF320240F"
51584 + default n
51585 + help
51586 + Support for CFAF320240F
51587 +
51588 +endmenu
51589 +
51590 #
51591 # Backlight
51592 #
51593 @@ -229,3 +286,11 @@
51594 help
51595 If you have a Tabletkiosk Sahara Touch-iT, say y to enable the
51596 backlight driver.
51597 +
51598 +config BACKLIGHT_UBICOM32
51599 + tristate "Ubicom Backlight Driver"
51600 + depends on BACKLIGHT_CLASS_DEVICE && UBICOM32
51601 + default n
51602 + help
51603 + If you have a Ubicom32 based system with a backlight say Y to enable the
51604 + backlight driver.
51605 diff -ruN linux-2.6.30.10/drivers/video/backlight/Makefile linux-2.6.30.10-ubi/drivers/video/backlight/Makefile
51606 --- linux-2.6.30.10/drivers/video/backlight/Makefile 2009-12-04 08:00:07.000000000 +0200
51607 +++ linux-2.6.30.10-ubi/drivers/video/backlight/Makefile 2009-12-11 11:45:20.000000000 +0200
51608 @@ -9,6 +9,9 @@
51609 obj-$(CONFIG_LCD_VGG2432A4) += vgg2432a4.o
51610 obj-$(CONFIG_LCD_TDO24M) += tdo24m.o
51611 obj-$(CONFIG_LCD_TOSA) += tosa_lcd.o
51612 +obj-$(CONFIG_LCD_LTV350QV) += ltv350qv.o
51613 +obj-$(CONFIG_LCD_UBICOM32POWER) += ubicom32lcdpower.o
51614 +obj-$(CONFIG_LCD_UBICOM32) += ubicom32lcd.o
51615
51616 obj-$(CONFIG_BACKLIGHT_CLASS_DEVICE) += backlight.o
51617 obj-$(CONFIG_BACKLIGHT_ATMEL_PWM) += atmel-pwm-bl.o
51618 @@ -24,4 +27,4 @@
51619 obj-$(CONFIG_BACKLIGHT_MBP_NVIDIA) += mbp_nvidia_bl.o
51620 obj-$(CONFIG_BACKLIGHT_TOSA) += tosa_bl.o
51621 obj-$(CONFIG_BACKLIGHT_SAHARA) += kb3886_bl.o
51622 -
51623 +obj-$(CONFIG_BACKLIGHT_UBICOM32) += ubicom32bl.o
51624 diff -ruN linux-2.6.30.10/drivers/video/backlight/ubicom32bl.c linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32bl.c
51625 --- linux-2.6.30.10/drivers/video/backlight/ubicom32bl.c 1970-01-01 02:00:00.000000000 +0200
51626 +++ linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32bl.c 2009-12-11 11:45:20.000000000 +0200
51627 @@ -0,0 +1,399 @@
51628 +/*
51629 + * drivers/video/backlight/ubicom32bl.c
51630 + * Backlight driver for the Ubicom32 platform
51631 + *
51632 + * (C) Copyright 2009, Ubicom, Inc.
51633 + *
51634 + * This file is part of the Ubicom32 Linux Kernel Port.
51635 + *
51636 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
51637 + * it and/or modify it under the terms of the GNU General Public License
51638 + * as published by the Free Software Foundation, either version 2 of the
51639 + * License, or (at your option) any later version.
51640 + *
51641 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
51642 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
51643 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
51644 + * the GNU General Public License for more details.
51645 + *
51646 + * You should have received a copy of the GNU General Public License
51647 + * along with the Ubicom32 Linux Kernel Port. If not,
51648 + * see <http://www.gnu.org/licenses/>.
51649 + *
51650 + * Ubicom32 implementation derived from (with many thanks):
51651 + * arch/m68knommu
51652 + * arch/blackfin
51653 + * arch/parisc
51654 + */
51655 +#include <linux/init.h>
51656 +#include <linux/kernel.h>
51657 +#include <linux/module.h>
51658 +#include <linux/platform_device.h>
51659 +#include <linux/backlight.h>
51660 +#include <linux/fb.h>
51661 +
51662 +#include <asm/ubicom32bl.h>
51663 +#include <asm/ip5000.h>
51664 +
51665 +#define DRIVER_NAME "ubicom32bl"
51666 +#define UBICOM32BL_MAX_BRIGHTNESS 255
51667 +
51668 +struct ubicom32bl_data {
51669 + /*
51670 + * Pointer to the platform data structure. Keep this around since we need values
51671 + * from it to set the backlight intensity.
51672 + */
51673 + const struct ubicom32bl_platform_data *pdata;
51674 +
51675 + /*
51676 + * Backlight device, we have to save this for use when we remove ourselves.
51677 + */
51678 + struct backlight_device *bldev;
51679 +
51680 + /*
51681 + * Current intensity, used for get_intensity.
51682 + */
51683 + int cur_intensity;
51684 +
51685 + /*
51686 + * Init function for PWM
51687 + */
51688 + int (*init_fn)(struct ubicom32bl_data *);
51689 +
51690 + /*
51691 + * Set intensity function depending on the backlight type
51692 + */
51693 + int (*set_intensity_fn)(struct ubicom32bl_data *, int);
51694 +};
51695 +
51696 +/*
51697 + * ubicom32bl_set_intensity_gpio
51698 + */
51699 +static int ubicom32bl_set_intensity_gpio(struct ubicom32bl_data *ud, int intensity)
51700 +{
51701 + ud->cur_intensity = intensity ? 255 : 0;
51702 +
51703 + if (intensity) {
51704 + // set gpio
51705 + return 0;
51706 + }
51707 +
51708 + // clear gpio
51709 + return 0;
51710 +}
51711 +
51712 +/*
51713 + * ubicom32bl_set_intensity_hw
51714 + */
51715 +static int ubicom32bl_set_intensity_hw(struct ubicom32bl_data *ud, int intensity)
51716 +{
51717 + u16_t period = ud->pdata->pwm_period;
51718 + u16_t duty;
51719 +
51720 + /*
51721 + * Calculate the new duty cycle
51722 + */
51723 + duty = (period * intensity) / (UBICOM32BL_MAX_BRIGHTNESS + 1);
51724 +
51725 + /*
51726 + * Set the new duty cycle
51727 + */
51728 + switch (ud->pdata->pwm_channel) {
51729 + case 0:
51730 + /*
51731 + * Channel 0 is in the lower half of PORT C ctl0 and ctl1
51732 + */
51733 + UBICOM32_IO_PORT(RC)->ctl1 = (ud->pdata->pwm_period << 16) | duty;
51734 + break;
51735 +
51736 + case 1:
51737 + /*
51738 + * Channel 1 is in the upper half of PORT C ctl0 and ctl2
51739 + */
51740 + UBICOM32_IO_PORT(RC)->ctl2 = (ud->pdata->pwm_period << 16) | duty;
51741 + break;
51742 +
51743 + case 2:
51744 + /*
51745 + * Channel 2 is in PORT H ctl0 and ctl1
51746 + */
51747 + UBICOM32_IO_PORT(RH)->ctl1 = (ud->pdata->pwm_period << 16) | duty;
51748 + break;
51749 + }
51750 +
51751 + ud->cur_intensity = intensity;
51752 +
51753 + return 0;
51754 +}
51755 +
51756 +/*
51757 + * ubicom32bl_set_intensity
51758 + */
51759 +static int ubicom32bl_set_intensity(struct backlight_device *bd)
51760 +{
51761 + struct ubicom32bl_data *ud = (struct ubicom32bl_data *)bl_get_data(bd);
51762 + int intensity = bd->props.brightness;
51763 +
51764 + /*
51765 + * If we're blanked the the intensity doesn't matter.
51766 + */
51767 + if ((bd->props.power != FB_BLANK_UNBLANK) || (bd->props.fb_blank != FB_BLANK_UNBLANK)) {
51768 + intensity = 0;
51769 + }
51770 +
51771 + /*
51772 + * Check for inverted backlight.
51773 + */
51774 + if (ud->pdata->invert) {
51775 + intensity = UBICOM32BL_MAX_BRIGHTNESS - intensity;
51776 + }
51777 +
51778 + if (ud->set_intensity_fn) {
51779 + return ud->set_intensity_fn(ud, intensity);
51780 + }
51781 +
51782 + return -ENXIO;
51783 +}
51784 +
51785 +/*
51786 + * ubicom32bl_get_intensity
51787 + * Return the current intensity of the backlight.
51788 + */
51789 +static int ubicom32bl_get_intensity(struct backlight_device *bd)
51790 +{
51791 + struct ubicom32bl_data *ud = (struct ubicom32bl_data *)bl_get_data(bd);
51792 +
51793 + return ud->cur_intensity;
51794 +}
51795 +
51796 +/*
51797 + * ubicom32bl_init_hw_pwm
51798 + * Set the appropriate PWM registers
51799 + */
51800 +static int ubicom32bl_init_hw_pwm(struct ubicom32bl_data *ud)
51801 +{
51802 + /*
51803 + * bit 13: enable
51804 + */
51805 + u16_t pwm_cfg = (1 << 13) | (ud->pdata->pwm_prescale << 8) ;
51806 +
51807 + switch (ud->pdata->pwm_channel) {
51808 + case 0:
51809 + /*
51810 + * Channel 0 is in the lower half of PORT C ctl0 and ctl1 (PA5)
51811 + */
51812 + UBICOM32_IO_PORT(RC)->ctl0 &= ~0xFFFF;
51813 + UBICOM32_IO_PORT(RC)->ctl0 |= pwm_cfg;
51814 + UBICOM32_IO_PORT(RC)->ctl1 = ud->pdata->pwm_period << 16;
51815 +
51816 + /*
51817 + * If the port function is not set, set it to GPIO/PWM
51818 + */
51819 + if (!UBICOM32_IO_PORT(RA)->function) {
51820 + UBICOM32_IO_PORT(RA)->function = 3;
51821 + }
51822 + break;
51823 +
51824 + case 1:
51825 + /*
51826 + * Channel 1 is in the upper half of PORT C ctl0 and ctl2 (PE4)
51827 + */
51828 + UBICOM32_IO_PORT(RC)->ctl0 &= ~0xFFFF0000;
51829 + UBICOM32_IO_PORT(RC)->ctl0 |= (pwm_cfg << 16);
51830 + UBICOM32_IO_PORT(RC)->ctl2 = ud->pdata->pwm_period << 16;
51831 +
51832 + /*
51833 + * If the port function is not set, set it to GPIO/ExtIOInt
51834 + */
51835 + if (!UBICOM32_IO_PORT(RE)->function) {
51836 + UBICOM32_IO_PORT(RE)->function = 3;
51837 + }
51838 + break;
51839 +
51840 + case 2:
51841 + /*
51842 + * Channel 2 is in PORT H ctl0 and ctl1 (PD0)
51843 + */
51844 + UBICOM32_IO_PORT(RH)->ctl0 &= ~0xFFFF0000;
51845 + UBICOM32_IO_PORT(RH)->ctl0 = pwm_cfg;
51846 + UBICOM32_IO_PORT(RH)->ctl1 = ud->pdata->pwm_period << 16;
51847 +
51848 + /*
51849 + * If the port function is not set, set it to GPIO
51850 + */
51851 + if (!UBICOM32_IO_PORT(RD)->function) {
51852 + UBICOM32_IO_PORT(RD)->function = 3;
51853 + }
51854 + break;
51855 + }
51856 +
51857 + return 0;
51858 +}
51859 +
51860 +/*
51861 + * ubicom32bl_init_gpio
51862 + * Allocate the appropriate GPIO
51863 + */
51864 +static int ubicom32bl_init_gpio(struct ubicom32bl_data *ud)
51865 +{
51866 + return 0;
51867 +}
51868 +
51869 +static struct backlight_ops ubicom32bl_ops = {
51870 + .get_brightness = ubicom32bl_get_intensity,
51871 + .update_status = ubicom32bl_set_intensity,
51872 +};
51873 +
51874 +/*
51875 + * ubicom32bl_probe
51876 + */
51877 +static int ubicom32bl_probe(struct platform_device *pdev)
51878 +{
51879 + const struct ubicom32bl_platform_data *pdata = pdev->dev.platform_data;
51880 + struct ubicom32bl_data *ud;
51881 + struct backlight_device *bldev;
51882 + int retval;
51883 +
51884 + /*
51885 + * Check to see if we have any platform data, if we don't then the backlight is not
51886 + * configured on this device.
51887 + */
51888 + if (!pdata) {
51889 + return -ENODEV;
51890 + }
51891 +
51892 + /*
51893 + * Allocate our private data
51894 + */
51895 + ud = kzalloc(sizeof(struct ubicom32bl_data), GFP_KERNEL);
51896 + if (!ud) {
51897 + return -ENOMEM;
51898 + }
51899 +
51900 + ud->pdata = pdata;
51901 +
51902 + /*
51903 + * Check to see that the platform data is valid for this driver
51904 + */
51905 + switch (pdata->type) {
51906 + case UBICOM32BL_TYPE_PWM:
51907 + {
51908 + /*
51909 + * Make sure we have a PWM peripheral
51910 + */
51911 + u32_t chipid;
51912 + asm volatile (
51913 + "move.4 %0, CHIP_ID \n\t"
51914 + : "=r" (chipid)
51915 + );
51916 + if (chipid != 0x00030001) {
51917 + retval = -ENODEV;
51918 + goto fail;
51919 + }
51920 +
51921 + if (pdata->pwm_channel > 3) {
51922 + retval = -ENODEV;
51923 + goto fail;
51924 + }
51925 + if (pdata->pwm_prescale > 16) {
51926 + retval = -EINVAL;
51927 + goto fail;
51928 + }
51929 +
51930 + ud->init_fn = ubicom32bl_init_hw_pwm;
51931 + ud->set_intensity_fn = ubicom32bl_set_intensity_hw;
51932 + break;
51933 + }
51934 +
51935 + case UBICOM32BL_TYPE_PWM_HRT:
51936 + // For now, PWM HRT devices are treated as binary lights.
51937 +
51938 + case UBICOM32BL_TYPE_BINARY:
51939 + ud->init_fn = ubicom32bl_init_gpio;
51940 + ud->set_intensity_fn = ubicom32bl_set_intensity_gpio;
51941 + break;
51942 + }
51943 +
51944 + /*
51945 + * Register our backlight device
51946 + */
51947 + bldev = backlight_device_register(DRIVER_NAME, &pdev->dev, ud, &ubicom32bl_ops);
51948 + if (IS_ERR(bldev)) {
51949 + retval = PTR_ERR(bldev);
51950 + goto fail;
51951 + }
51952 +
51953 + ud->bldev = bldev;
51954 + ud->cur_intensity = pdata->default_intensity;
51955 + platform_set_drvdata(pdev, ud);
51956 +
51957 + /*
51958 + * Start up the backlight at the prescribed default intensity
51959 + */
51960 + bldev->props.power = FB_BLANK_UNBLANK;
51961 + bldev->props.max_brightness = UBICOM32BL_MAX_BRIGHTNESS;
51962 + bldev->props.brightness = pdata->default_intensity;
51963 +
51964 + if (ud->init_fn) {
51965 + if (ud->init_fn(ud) != 0) {
51966 + retval = -ENODEV;
51967 + backlight_device_unregister(ud->bldev);
51968 + goto fail;
51969 + }
51970 + }
51971 + ubicom32bl_set_intensity(bldev);
51972 +
51973 + printk(KERN_INFO DRIVER_NAME ": Backlight driver started\n");
51974 +
51975 + return 0;
51976 +
51977 +fail:
51978 + platform_set_drvdata(pdev, NULL);
51979 + kfree(ud);
51980 + return retval;
51981 +}
51982 +
51983 +/*
51984 + * ubicom32bl_remove
51985 + */
51986 +static int __exit ubicom32bl_remove(struct platform_device *pdev)
51987 +{
51988 + struct ubicom32bl_data *ud = platform_get_drvdata(pdev);
51989 +
51990 + backlight_device_unregister(ud->bldev);
51991 + platform_set_drvdata(pdev, NULL);
51992 + kfree(ud);
51993 +
51994 + return 0;
51995 +}
51996 +
51997 +static struct platform_driver ubicom32bl_driver = {
51998 + .driver = {
51999 + .name = DRIVER_NAME,
52000 + .owner = THIS_MODULE,
52001 + },
52002 +
52003 + .remove = __exit_p(ubicom32bl_remove),
52004 +};
52005 +
52006 +/*
52007 + * ubicom32bl_init
52008 + */
52009 +static int __init ubicom32bl_init(void)
52010 +{
52011 + return platform_driver_probe(&ubicom32bl_driver, ubicom32bl_probe);
52012 +}
52013 +module_init(ubicom32bl_init);
52014 +
52015 +/*
52016 + * ubicom32bl_exit
52017 + */
52018 +static void __exit ubicom32bl_exit(void)
52019 +{
52020 + platform_driver_unregister(&ubicom32bl_driver);
52021 +}
52022 +module_exit(ubicom32bl_exit);
52023 +
52024 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
52025 +MODULE_DESCRIPTION("Ubicom32 backlight driver");
52026 +MODULE_LICENSE("GPL");
52027 diff -ruN linux-2.6.30.10/drivers/video/backlight/ubicom32lcd.c linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcd.c
52028 --- linux-2.6.30.10/drivers/video/backlight/ubicom32lcd.c 1970-01-01 02:00:00.000000000 +0200
52029 +++ linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcd.c 2009-12-11 11:45:20.000000000 +0200
52030 @@ -0,0 +1,372 @@
52031 +/*
52032 + * drivers/video/ubicom32lcd.c
52033 + * LCD initilization code
52034 + *
52035 + * (C) Copyright 2009, Ubicom, Inc.
52036 + *
52037 + * This file is part of the Ubicom32 Linux Kernel Port.
52038 + *
52039 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
52040 + * it and/or modify it under the terms of the GNU General Public License
52041 + * as published by the Free Software Foundation, either version 2 of the
52042 + * License, or (at your option) any later version.
52043 + *
52044 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
52045 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
52046 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
52047 + * the GNU General Public License for more details.
52048 + *
52049 + * You should have received a copy of the GNU General Public License
52050 + * along with the Ubicom32 Linux Kernel Port. If not,
52051 + * see <http://www.gnu.org/licenses/>.
52052 + */
52053 +#include <linux/init.h>
52054 +#include <linux/kernel.h>
52055 +#include <linux/module.h>
52056 +#include <linux/platform_device.h>
52057 +#include <linux/delay.h>
52058 +
52059 +#include <asm/ip5000.h>
52060 +#include <asm/gpio.h>
52061 +#include <asm/ubicom32lcd.h>
52062 +
52063 +#include "ubicom32lcd.h"
52064 +
52065 +#define DRIVER_NAME "ubicom32lcd"
52066 +
52067 +struct ubicom32lcd_data {
52068 + const struct ubicom32lcd_panel *panel;
52069 +
52070 + int pin_cs;
52071 + int pin_rd;
52072 + int pin_rs;
52073 + int pin_wr;
52074 + int pin_reset;
52075 + struct ubicom32_io_port *port_data;
52076 + int data_shift;
52077 +};
52078 +
52079 +/*
52080 + * ubicom32lcd_write
52081 + * Performs a write cycle on the bus (assumes CS asserted, RD & WR set)
52082 + */
52083 +static void ubicom32lcd_write(struct ubicom32lcd_data *ud, int command, u16 data)
52084 +{
52085 + if (command) {
52086 + UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rs);
52087 + } else {
52088 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
52089 + }
52090 +
52091 + asm volatile (
52092 + "or.4 4(%[port]), 4(%[port]), %[mask] \n\t"
52093 + "not.4 %[mask], %[mask] \n\t"
52094 + "and.4 8(%[port]), 8(%[port]), %[mask] \n\t"
52095 + "or.4 8(%[port]), 8(%[port]), %[cmd] \n\t"
52096 + :
52097 + : [port] "a" (ud->port_data),
52098 + [mask] "d" (0xFFFF << ud->data_shift),
52099 + [cmd] "d" (data << ud->data_shift)
52100 + : "cc"
52101 + );
52102 +
52103 + UBICOM32_GPIO_SET_PIN_LOW(ud->pin_wr);
52104 +
52105 + //ndelay(50);
52106 + udelay(1);
52107 +
52108 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
52109 +
52110 + udelay(1);
52111 + //ndelay(50);
52112 +}
52113 +
52114 +/*
52115 + * ubicom32lcd_read_data
52116 + * Performs a read cycle on the bus (assumes CS asserted, RD & WR set)
52117 + */
52118 +static u16 ubicom32lcd_read_data(struct ubicom32lcd_data *ud)
52119 +{
52120 + u32_t data;
52121 +
52122 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
52123 +
52124 + asm volatile (
52125 + "and.4 4(%[port]), 4(%[port]), %[mask]\n\t"
52126 + :
52127 + : [port] "a" (ud->port_data),
52128 + [mask] "d" (~(0xFFFF << ud->data_shift))
52129 + : "cc"
52130 + );
52131 +
52132 + UBICOM32_GPIO_SET_PIN_LOW(ud->pin_rd);
52133 +
52134 + ndelay(300);
52135 +
52136 + asm volatile (
52137 + "lsr.4 %[data], 12(%[port]), %[shamt] \n\t"
52138 + "and.4 %[data], %[data], %[mask] \n\t"
52139 + : [data] "=d" (data)
52140 + : [port] "a" (ud->port_data),
52141 + [mask] "d" (0xFFFF),
52142 + [shamt] "d" (ud->data_shift)
52143 + : "cc"
52144 + );
52145 +
52146 + ndelay(200);
52147 +
52148 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
52149 +
52150 + ndelay(500);
52151 +
52152 + return data;
52153 +}
52154 +
52155 +/*
52156 + * ubicom32lcd_execute
52157 + * Executes a script for performing operations on the LCD (assumes CS set)
52158 + */
52159 +static void ubicom32lcd_execute(struct ubicom32lcd_data *ud, const struct ubicom32lcd_step *script)
52160 +{
52161 + while (1) {
52162 + switch (script->op) {
52163 + case LCD_STEP_CMD:
52164 + ubicom32lcd_write(ud, 1, script->cmd);
52165 + break;
52166 +
52167 + case LCD_STEP_DATA:
52168 + ubicom32lcd_write(ud, 0, script->data);
52169 + break;
52170 +
52171 + case LCD_STEP_CMD_DATA:
52172 + ubicom32lcd_write(ud, 1, script->cmd);
52173 + ubicom32lcd_write(ud, 0, script->data);
52174 + break;
52175 +
52176 + case LCD_STEP_SLEEP:
52177 + udelay(script->data);
52178 + break;
52179 +
52180 + case LCD_STEP_DONE:
52181 + return;
52182 + }
52183 + script++;
52184 + }
52185 +}
52186 +
52187 +/*
52188 + * ubicom32lcd_goto
52189 + * Places the gram pointer at a specific X, Y address
52190 + */
52191 +static void ubicom32lcd_goto(struct ubicom32lcd_data *ud, int x, int y)
52192 +{
52193 + ubicom32lcd_write(ud, 1, ud->panel->horz_reg);
52194 + ubicom32lcd_write(ud, 0, x);
52195 + ubicom32lcd_write(ud, 1, ud->panel->vert_reg);
52196 + ubicom32lcd_write(ud, 0, y);
52197 + ubicom32lcd_write(ud, 1, ud->panel->gram_reg);
52198 +}
52199 +
52200 +/*
52201 + * ubicom32lcd_panel_init
52202 + * Initializes the lcd panel.
52203 + */
52204 +static int ubicom32lcd_panel_init(struct ubicom32lcd_data *ud)
52205 +{
52206 + u16 id;
52207 +
52208 + UBICOM32_GPIO_SET_PIN_LOW(ud->pin_reset);
52209 + UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_reset);
52210 + UBICOM32_GPIO_ENABLE(ud->pin_reset);
52211 +
52212 + asm volatile (
52213 + "or.4 0x50(%[port]), 0x50(%[port]), %[mask] \n\t"
52214 + "not.4 %[mask], %[mask] \n\t"
52215 + "and.4 0x04(%[port]), 0x04(%[port]), %[mask] \n\t"
52216 + :
52217 + : [port] "a" (ud->port_data),
52218 + [mask] "d" (0xFFFF << ud->data_shift)
52219 + : "cc"
52220 + );
52221 +
52222 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
52223 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
52224 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
52225 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
52226 +
52227 + UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rs);
52228 + UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_rd);
52229 + UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_wr);
52230 + UBICOM32_GPIO_SET_PIN_OUTPUT(ud->pin_cs);
52231 +
52232 + UBICOM32_GPIO_ENABLE(ud->pin_rs);
52233 + UBICOM32_GPIO_ENABLE(ud->pin_rd);
52234 + UBICOM32_GPIO_ENABLE(ud->pin_wr);
52235 + UBICOM32_GPIO_ENABLE(ud->pin_cs);
52236 +
52237 + udelay(20);
52238 +
52239 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_reset);
52240 +
52241 + udelay(20);
52242 +
52243 + UBICOM32_GPIO_SET_PIN_LOW(ud->pin_cs);
52244 +
52245 + id = ubicom32lcd_read_data(ud);
52246 +
52247 + /*
52248 + * We will try to figure out what kind of panel we have if we were not told.
52249 + */
52250 + if (!ud->panel) {
52251 + const struct ubicom32lcd_panel **p = ubicom32lcd_panels;
52252 + while (*p) {
52253 + if ((*p)->id && ((*p)->id == id)) {
52254 + break;
52255 + }
52256 + p++;
52257 + }
52258 + if (!*p) {
52259 + printk(KERN_WARNING DRIVER_NAME ":Could not find compatible panel, id=%x\n", id);
52260 + return -ENODEV;
52261 + }
52262 + ud->panel = *p;
52263 + }
52264 +
52265 + /*
52266 + * Make sure panel ID matches if we were supplied a panel type
52267 + */
52268 + if (ud->panel->id && (ud->panel->id != id)) {
52269 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
52270 +
52271 + return -ENODEV;
52272 + }
52273 +
52274 + ubicom32lcd_execute(ud, ud->panel->init_seq);
52275 +
52276 + ubicom32lcd_goto(ud, 0, 0);
52277 +
52278 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_cs);
52279 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rd);
52280 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_wr);
52281 + UBICOM32_GPIO_SET_PIN_HIGH(ud->pin_rs);
52282 +
52283 + printk(KERN_INFO DRIVER_NAME ": Initialized panel %s\n", ud->panel->desc);
52284 +
52285 + return 0;
52286 +}
52287 +
52288 +/*
52289 + * ubicom32lcd_probe
52290 + */
52291 +static int ubicom32lcd_probe(struct platform_device *pdev)
52292 +{
52293 + const struct ubicom32lcd_platform_data *pdata = pdev->dev.platform_data;
52294 + struct ubicom32lcd_data *ud;
52295 + int retval;
52296 +
52297 + /*
52298 + * Allocate our private data
52299 + */
52300 + ud = kzalloc(sizeof(struct ubicom32lcd_data), GFP_KERNEL);
52301 + if (!ud) {
52302 + return -ENOMEM;
52303 + }
52304 +
52305 + if (pdata) {
52306 + ud->pin_cs = pdata->pin_cs;
52307 + ud->pin_rd = pdata->pin_rd;
52308 + ud->pin_wr = pdata->pin_wr;
52309 + ud->pin_rs = pdata->pin_rs;
52310 + ud->pin_reset = pdata->pin_reset;
52311 + ud->port_data = pdata->port_data;
52312 + ud->data_shift = pdata->data_shift;
52313 + } else {
52314 + /*
52315 + * Defaults
52316 + */
52317 + ud->pin_cs = GPIO_RD_4;
52318 + ud->pin_rd = GPIO_RD_5;
52319 + ud->pin_rs = GPIO_RD_3;
52320 + ud->pin_wr = GPIO_RD_2;
52321 + ud->pin_reset = GPIO_RD_7;
52322 + ud->port_data = (struct ubicom32_io_port *)RI;
52323 + ud->data_shift = 0;
52324 + }
52325 +
52326 + /*
52327 + * Initialize the display
52328 + */
52329 + retval = ubicom32lcd_panel_init(ud);
52330 + if (retval) {
52331 + kfree(ud);
52332 + return retval;
52333 + }
52334 +
52335 + printk(KERN_INFO DRIVER_NAME ": LCD initialized\n");
52336 +
52337 + return 0;
52338 +}
52339 +
52340 +/*
52341 + * ubicom32lcd_remove
52342 + */
52343 +static int __exit ubicom32lcd_remove(struct platform_device *pdev)
52344 +{
52345 + struct ubicom32lcd_data *ud = platform_get_drvdata(pdev);
52346 +
52347 + kfree(ud);
52348 +
52349 + return 0;
52350 +}
52351 +
52352 +static struct platform_driver ubicom32lcd_driver = {
52353 + .probe = ubicom32lcd_probe,
52354 + .remove = ubicom32lcd_remove,
52355 +
52356 + .driver = {
52357 + .name = DRIVER_NAME,
52358 + .owner = THIS_MODULE,
52359 + },
52360 +
52361 + .remove = __exit_p(ubicom32lcd_remove),
52362 +};
52363 +
52364 +static struct platform_device *ubicom32lcd_device;
52365 +
52366 +/*
52367 + * ubicom32lcd_init
52368 + */
52369 +static int __init ubicom32lcd_init(void)
52370 +{
52371 + int res;
52372 +
52373 + res = platform_driver_register(&ubicom32lcd_driver);
52374 + if (res == 0) {
52375 + ubicom32lcd_device = platform_device_alloc(DRIVER_NAME, 0);
52376 + if (ubicom32lcd_device) {
52377 + res = platform_device_add(ubicom32lcd_device);
52378 + } else {
52379 + res = -ENOMEM;
52380 + }
52381 + if (res) {
52382 + platform_device_put(ubicom32lcd_device);
52383 + platform_driver_unregister(&ubicom32lcd_driver);
52384 + }
52385 + }
52386 + return res;
52387 +}
52388 +module_init(ubicom32lcd_init);
52389 +
52390 +/*
52391 + * ubicom32lcd_exit
52392 + */
52393 +static void __exit ubicom32lcd_exit(void)
52394 +{
52395 + platform_device_unregister(ubicom32lcd_device);
52396 + platform_driver_unregister(&ubicom32lcd_driver);
52397 +}
52398 +module_exit(ubicom32lcd_exit);
52399 +
52400 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
52401 +MODULE_DESCRIPTION("Ubicom32 LCD driver");
52402 +MODULE_LICENSE("GPL");
52403 diff -ruN linux-2.6.30.10/drivers/video/backlight/ubicom32lcd.h linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcd.h
52404 --- linux-2.6.30.10/drivers/video/backlight/ubicom32lcd.h 1970-01-01 02:00:00.000000000 +0200
52405 +++ linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcd.h 2009-12-11 11:45:20.000000000 +0200
52406 @@ -0,0 +1,546 @@
52407 +/*
52408 + * ubicom32lcd.h
52409 + * Ubicom32 lcd panel drivers
52410 + *
52411 + * (C) Copyright 2009, Ubicom, Inc.
52412 + *
52413 + * This file is part of the Ubicom32 Linux Kernel Port.
52414 + *
52415 + * This Ubicom32 library is free software: you can redistribute
52416 + * it and/or modify it under the terms of the GNU General Public License
52417 + * as published by the Free Software Foundation, either version 2 of the
52418 + * License, or (at your option) any later version.
52419 + *
52420 + * This Ubicom32 library is distributed in the hope that it
52421 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
52422 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
52423 + * the GNU General Public License for more details.
52424 + *
52425 + * You should have received a copy of the GNU General Public License
52426 + * along with the Ubicom32 Linux Kernel Port. If not,
52427 + * see <http://www.gnu.org/licenses/>.
52428 + */
52429 +
52430 +#ifndef _UBICOM32LCD_H_
52431 +#define _UBICOM32LCD_H_
52432 +
52433 +enum ubicom32lcd_op {
52434 + /*
52435 + * Sleep for (data) ms
52436 + */
52437 + LCD_STEP_SLEEP,
52438 +
52439 + /*
52440 + * Execute write of command
52441 + */
52442 + LCD_STEP_CMD,
52443 +
52444 + /*
52445 + * Execute write of data
52446 + */
52447 + LCD_STEP_DATA,
52448 +
52449 + /*
52450 + * Execute write of command/data
52451 + */
52452 + LCD_STEP_CMD_DATA,
52453 +
52454 + /*
52455 + * Script done
52456 + */
52457 + LCD_STEP_DONE,
52458 +};
52459 +
52460 +struct ubicom32lcd_step {
52461 + enum ubicom32lcd_op op;
52462 + u16 cmd;
52463 + u16 data;
52464 +};
52465 +
52466 +struct ubicom32lcd_panel {
52467 + const struct ubicom32lcd_step *init_seq;
52468 + const char *desc;
52469 +
52470 + u32 xres;
52471 + u32 yres;
52472 + u32 stride;
52473 + u32 flags;
52474 +
52475 + u16 id;
52476 + u16 horz_reg;
52477 + u16 vert_reg;
52478 + u16 gram_reg;
52479 +};
52480 +
52481 +#ifdef CONFIG_LCD_UBICOM32_CFAF240320KTTS
52482 +static const struct ubicom32lcd_step cfaf240320ktts_init_0[] = {
52483 + {LCD_STEP_CMD_DATA, 0x0001, 0x0000,}, // Driver Output Control Register (R01h) Page 14, SPFD5408B Datasheet
52484 + {LCD_STEP_CMD_DATA, 0x0002, 0x0700,}, // LCD Driving Waveform Control (R02h) Page 15, SPFD5408B Datasheet
52485 + {LCD_STEP_CMD_DATA, 0x0003, 0x50A0,}, // Entry Mode (R03h) 0 degrees
52486 + {LCD_STEP_CMD_DATA, 0x0004, 0x0000,}, // Scaling Control register (R04h) Page 16, SPFD5408B Datasheet
52487 + {LCD_STEP_CMD_DATA, 0x0008, 0x0207,}, // Display Control 2 (R08h) Page 17, SPFD5408B Datasheet
52488 + {LCD_STEP_CMD_DATA, 0x0009, 0x0000,}, // Display Control 3 (R09h) Page 18, SPFD5408B Datasheet
52489 + {LCD_STEP_CMD_DATA, 0x000A, 0x0000,}, // Frame Cycle Control (R0Ah) Page 19, SPFD5408B Datasheet
52490 + {LCD_STEP_CMD_DATA, 0x000C, 0x0000,}, // External Display Interface Control 1 (R0Ch) Page 20, SPFD5408B Datasheet
52491 + {LCD_STEP_CMD_DATA, 0x000D, 0x0000,}, // Frame Maker Position (R0Dh) Page 21, SPFD5408B Datasheet
52492 + {LCD_STEP_CMD_DATA, 0x000F, 0x0000,}, // External Display Interface Control 2 (R0Fh) Page 21, SPFD5408B Datasheet
52493 + {LCD_STEP_CMD_DATA, 0x0010, 0x0000,}, // Power Control 1 (R10h) Page 22, SPFD5408B Datasheet
52494 + {LCD_STEP_CMD_DATA, 0x0011, 0x0007,}, // Power Control 2 (R11h) Page 23, SPFD5408B Datasheet
52495 + {LCD_STEP_CMD_DATA, 0x0012, 0x0000,}, // Power Control 3 (R12h) Page 24, SPFD5408B Datasheet
52496 + {LCD_STEP_CMD_DATA, 0x0013, 0x0000,}, // Power Control 4 (R13h) Page 25, SPFD5408B Datasheet
52497 + {LCD_STEP_SLEEP, 0, 200},
52498 + {LCD_STEP_CMD_DATA, 0x0007, 0x0101,}, // Display Control (R07h) Page 16, SPFD5408B Datasheet
52499 + {LCD_STEP_CMD_DATA, 0x0010, 0x12B0,}, // Power Control 1 (R10h) Page 22, SPFD5408B Datasheet
52500 + {LCD_STEP_CMD_DATA, 0x0011, 0x0007,}, // Power Control 2 (R11h) Page 23, SPFD5408B Datasheet
52501 + {LCD_STEP_CMD_DATA, 0x0012, 0x01BB,}, // Power Control 3 (R12h) Page 24, SPFD5408B Datasheet
52502 + {LCD_STEP_SLEEP, 0, 50},
52503 + {LCD_STEP_CMD_DATA, 0x0013, 0x1300,}, // Power Control 4 (R13h) Page 25, SPFD5408B Datasheet
52504 + {LCD_STEP_CMD_DATA, 0x0029, 0x0010,}, // NVM read data 2 (R29h) Page 30, SPFD5408B Datasheet
52505 + {LCD_STEP_SLEEP, 0, 50},
52506 + {LCD_STEP_CMD_DATA, 0x0030, 0x000A,}, // Gamma Control 1 Page 32, SPFD5408B Datasheet
52507 + {LCD_STEP_CMD_DATA, 0x0031, 0x1326,}, // Gamma Control 2 Page 32, SPFD5408B Datasheet
52508 + {LCD_STEP_CMD_DATA, 0x0032, 0x0A29,}, // Gamma Control 3 Page 32, SPFD5408B Datasheet
52509 + {LCD_STEP_CMD_DATA, 0x0033, 0x290A,}, // Gamma Control 4 Page 32, SPFD5408B Datasheet
52510 + {LCD_STEP_CMD_DATA, 0x0034, 0x2613,}, // Gamma Control 5 Page 32, SPFD5408B Datasheet
52511 + {LCD_STEP_CMD_DATA, 0x0035, 0x0A0A,}, // Gamma Control 6 Page 32, SPFD5408B Datasheet
52512 + {LCD_STEP_CMD_DATA, 0x0036, 0x1E03,}, // Gamma Control 7 Page 32, SPFD5408B Datasheet
52513 + {LCD_STEP_CMD_DATA, 0x0037, 0x031E,}, // Gamma Control 8 Page 32, SPFD5408B Datasheet
52514 + {LCD_STEP_CMD_DATA, 0x0038, 0x0706,}, // Gamma Control 9 Page 32, SPFD5408B Datasheet
52515 + {LCD_STEP_CMD_DATA, 0x0039, 0x0303,}, // Gamma Control 10 Page 32, SPFD5408B Datasheet
52516 + {LCD_STEP_CMD_DATA, 0x003A, 0x0E04,}, // Gamma Control 11 Page 32, SPFD5408B Datasheet
52517 + {LCD_STEP_CMD_DATA, 0x003B, 0x0E01,}, // Gamma Control 12 Page 32, SPFD5408B Datasheet
52518 + {LCD_STEP_CMD_DATA, 0x003C, 0x010E,}, // Gamma Control 13 Page 32, SPFD5408B Datasheet
52519 + {LCD_STEP_CMD_DATA, 0x003D, 0x040E,}, // Gamma Control 14 Page 32, SPFD5408B Datasheet
52520 + {LCD_STEP_CMD_DATA, 0x003E, 0x0303,}, // Gamma Control 15 Page 32, SPFD5408B Datasheet
52521 + {LCD_STEP_CMD_DATA, 0x003F, 0x0607,}, // Gamma Control 16 Page 32, SPFD5408B Datasheet
52522 + {LCD_STEP_CMD_DATA, 0x0050, 0x0000,}, // Window Horizontal RAM Address Start (R50h) Page 32, SPFD5408B Datasheet
52523 + {LCD_STEP_CMD_DATA, 0x0051, 0x00EF,}, // Window Horizontal RAM Address End (R51h) Page 32, SPFD5408B Datasheet
52524 + {LCD_STEP_CMD_DATA, 0x0052, 0x0000,}, // Window Vertical RAM Address Start (R52h) Page 33, SPFD5408B Datasheet
52525 + {LCD_STEP_CMD_DATA, 0x0053, 0x013F,}, // Window Vertical RAM Address End (R53h) Page 33, SPFD5408B Datasheet
52526 + {LCD_STEP_CMD_DATA, 0x0060, 0x2700,}, // Driver Output Control (R60h) Page 33, SPFD5408B Datasheet
52527 + {LCD_STEP_CMD_DATA, 0x0061, 0x0001,}, // Driver Output Control (R61h) Page 35, SPFD5408B Datasheet
52528 + {LCD_STEP_CMD_DATA, 0x006A, 0x0000,}, // Vertical Scroll Control (R6Ah) Page 35, SPFD5408B Datasheet
52529 + {LCD_STEP_CMD_DATA, 0x0080, 0x0000,}, // Display Position - Partial Display 1 (R80h) Page 35, SPFD5408B Datasheet
52530 + {LCD_STEP_CMD_DATA, 0x0081, 0x0000,}, // RAM Address Start - Partial Display 1 (R81h) Page 35, SPFD5408B Datasheet
52531 + {LCD_STEP_CMD_DATA, 0x0082, 0x0000,}, // RAM Address End - Partial Display 1 (R82h) Page 36, SPFD5408B Datasheet
52532 + {LCD_STEP_CMD_DATA, 0x0083, 0x0000,}, // Display Position - Partial Display 2 (R83h) Page 36, SPFD5408B Datasheet
52533 + {LCD_STEP_CMD_DATA, 0x0084, 0x0000,}, // RAM Address Start - Partial Display 2 (R84h) Page 36, SPFD5408B Datasheet
52534 + {LCD_STEP_CMD_DATA, 0x0085, 0x0000,}, // RAM Address End - Partial Display 2 (R85h) Page 36, SPFD5408B Datasheet
52535 + {LCD_STEP_CMD_DATA, 0x0090, 0x0010,}, // Panel Interface Control 1 (R90h) Page 36, SPFD5408B Datasheet
52536 + {LCD_STEP_CMD_DATA, 0x0092, 0x0000,}, // Panel Interface Control 2 (R92h) Page 37, SPFD5408B Datasheet
52537 + {LCD_STEP_CMD_DATA, 0x0093, 0x0103,}, // Panel Interface control 3 (R93h) Page 38, SPFD5408B Datasheet
52538 + {LCD_STEP_CMD_DATA, 0x0095, 0x0210,}, // Panel Interface control 4 (R95h) Page 38, SPFD5408B Datasheet
52539 + {LCD_STEP_CMD_DATA, 0x0097, 0x0000,}, // Panel Interface Control 5 (R97h) Page 40, SPFD5408B Datasheet
52540 + {LCD_STEP_CMD_DATA, 0x0098, 0x0000,}, // Panel Interface Control 6 (R98h) Page 41, SPFD5408B Datasheet
52541 + {LCD_STEP_CMD_DATA, 0x0007, 0x0173,}, // Display Control (R07h) Page 16, SPFD5408B Datasheet
52542 + {LCD_STEP_DONE, 0, 0},
52543 +};
52544 +
52545 +const struct ubicom32lcd_panel cfaf240320ktts_0 = {
52546 + .desc = "CFAF240320KTTS",
52547 + .init_seq = cfaf240320ktts_init_0,
52548 + .horz_reg = 0x20,
52549 + .vert_reg = 0x21,
52550 + .gram_reg = 0x22,
52551 + .xres = 240,
52552 + .yres = 320,
52553 + .stride = 240,
52554 + .id = 0x5408,
52555 +};
52556 +#endif
52557 +
52558 +#ifdef CONFIG_LCD_UBICOM32_CFAF240320KTTS_180
52559 +static const struct ubicom32lcd_step cfaf240320ktts_init_180[] = {
52560 + {LCD_STEP_CMD_DATA, 0x0001, 0x0000,}, // Driver Output Control Register (R01h) Page 14, SPFD5408B Datasheet
52561 + {LCD_STEP_CMD_DATA, 0x0002, 0x0700,}, // LCD Driving Waveform Control (R02h) Page 15, SPFD5408B Datasheet
52562 + {LCD_STEP_CMD_DATA, 0x0003, 0x5000,}, // Entry Mode (R03h) 180 degrees
52563 + {LCD_STEP_CMD_DATA, 0x0004, 0x0000,}, // Scaling Control register (R04h) Page 16, SPFD5408B Datasheet
52564 + {LCD_STEP_CMD_DATA, 0x0008, 0x0207,}, // Display Control 2 (R08h) Page 17, SPFD5408B Datasheet
52565 + {LCD_STEP_CMD_DATA, 0x0009, 0x0000,}, // Display Control 3 (R09h) Page 18, SPFD5408B Datasheet
52566 + {LCD_STEP_CMD_DATA, 0x000A, 0x0000,}, // Frame Cycle Control (R0Ah) Page 19, SPFD5408B Datasheet
52567 + {LCD_STEP_CMD_DATA, 0x000C, 0x0000,}, // External Display Interface Control 1 (R0Ch) Page 20, SPFD5408B Datasheet
52568 + {LCD_STEP_CMD_DATA, 0x000D, 0x0000,}, // Frame Maker Position (R0Dh) Page 21, SPFD5408B Datasheet
52569 + {LCD_STEP_CMD_DATA, 0x000F, 0x0000,}, // External Display Interface Control 2 (R0Fh) Page 21, SPFD5408B Datasheet
52570 + {LCD_STEP_CMD_DATA, 0x0010, 0x0000,}, // Power Control 1 (R10h) Page 22, SPFD5408B Datasheet
52571 + {LCD_STEP_CMD_DATA, 0x0011, 0x0007,}, // Power Control 2 (R11h) Page 23, SPFD5408B Datasheet
52572 + {LCD_STEP_CMD_DATA, 0x0012, 0x0000,}, // Power Control 3 (R12h) Page 24, SPFD5408B Datasheet
52573 + {LCD_STEP_CMD_DATA, 0x0013, 0x0000,}, // Power Control 4 (R13h) Page 25, SPFD5408B Datasheet
52574 + {LCD_STEP_SLEEP, 0, 200},
52575 + {LCD_STEP_CMD_DATA, 0x0007, 0x0101,}, // Display Control (R07h) Page 16, SPFD5408B Datasheet
52576 + {LCD_STEP_CMD_DATA, 0x0010, 0x12B0,}, // Power Control 1 (R10h) Page 22, SPFD5408B Datasheet
52577 + {LCD_STEP_CMD_DATA, 0x0011, 0x0007,}, // Power Control 2 (R11h) Page 23, SPFD5408B Datasheet
52578 + {LCD_STEP_CMD_DATA, 0x0012, 0x01BB,}, // Power Control 3 (R12h) Page 24, SPFD5408B Datasheet
52579 + {LCD_STEP_SLEEP, 0, 50},
52580 + {LCD_STEP_CMD_DATA, 0x0013, 0x1300,}, // Power Control 4 (R13h) Page 25, SPFD5408B Datasheet
52581 + {LCD_STEP_CMD_DATA, 0x0029, 0x0010,}, // NVM read data 2 (R29h) Page 30, SPFD5408B Datasheet
52582 + {LCD_STEP_SLEEP, 0, 50},
52583 + {LCD_STEP_CMD_DATA, 0x0030, 0x000A,}, // Gamma Control 1 Page 32, SPFD5408B Datasheet
52584 + {LCD_STEP_CMD_DATA, 0x0031, 0x1326,}, // Gamma Control 2 Page 32, SPFD5408B Datasheet
52585 + {LCD_STEP_CMD_DATA, 0x0032, 0x0A29,}, // Gamma Control 3 Page 32, SPFD5408B Datasheet
52586 + {LCD_STEP_CMD_DATA, 0x0033, 0x290A,}, // Gamma Control 4 Page 32, SPFD5408B Datasheet
52587 + {LCD_STEP_CMD_DATA, 0x0034, 0x2613,}, // Gamma Control 5 Page 32, SPFD5408B Datasheet
52588 + {LCD_STEP_CMD_DATA, 0x0035, 0x0A0A,}, // Gamma Control 6 Page 32, SPFD5408B Datasheet
52589 + {LCD_STEP_CMD_DATA, 0x0036, 0x1E03,}, // Gamma Control 7 Page 32, SPFD5408B Datasheet
52590 + {LCD_STEP_CMD_DATA, 0x0037, 0x031E,}, // Gamma Control 8 Page 32, SPFD5408B Datasheet
52591 + {LCD_STEP_CMD_DATA, 0x0038, 0x0706,}, // Gamma Control 9 Page 32, SPFD5408B Datasheet
52592 + {LCD_STEP_CMD_DATA, 0x0039, 0x0303,}, // Gamma Control 10 Page 32, SPFD5408B Datasheet
52593 + {LCD_STEP_CMD_DATA, 0x003A, 0x0E04,}, // Gamma Control 11 Page 32, SPFD5408B Datasheet
52594 + {LCD_STEP_CMD_DATA, 0x003B, 0x0E01,}, // Gamma Control 12 Page 32, SPFD5408B Datasheet
52595 + {LCD_STEP_CMD_DATA, 0x003C, 0x010E,}, // Gamma Control 13 Page 32, SPFD5408B Datasheet
52596 + {LCD_STEP_CMD_DATA, 0x003D, 0x040E,}, // Gamma Control 14 Page 32, SPFD5408B Datasheet
52597 + {LCD_STEP_CMD_DATA, 0x003E, 0x0303,}, // Gamma Control 15 Page 32, SPFD5408B Datasheet
52598 + {LCD_STEP_CMD_DATA, 0x003F, 0x0607,}, // Gamma Control 16 Page 32, SPFD5408B Datasheet
52599 + {LCD_STEP_CMD_DATA, 0x0050, 0x0000,}, // Window Horizontal RAM Address Start (R50h) Page 32, SPFD5408B Datasheet
52600 + {LCD_STEP_CMD_DATA, 0x0051, 0x00EF,}, // Window Horizontal RAM Address End (R51h) Page 32, SPFD5408B Datasheet
52601 + {LCD_STEP_CMD_DATA, 0x0052, 0x0000,}, // Window Vertical RAM Address Start (R52h) Page 33, SPFD5408B Datasheet
52602 + {LCD_STEP_CMD_DATA, 0x0053, 0x013F,}, // Window Vertical RAM Address End (R53h) Page 33, SPFD5408B Datasheet
52603 + {LCD_STEP_CMD_DATA, 0x0060, 0x2700,}, // Driver Output Control (R60h) Page 33, SPFD5408B Datasheet
52604 + {LCD_STEP_CMD_DATA, 0x0061, 0x0001,}, // Driver Output Control (R61h) Page 35, SPFD5408B Datasheet
52605 + {LCD_STEP_CMD_DATA, 0x006A, 0x0000,}, // Vertical Scroll Control (R6Ah) Page 35, SPFD5408B Datasheet
52606 + {LCD_STEP_CMD_DATA, 0x0080, 0x0000,}, // Display Position - Partial Display 1 (R80h) Page 35, SPFD5408B Datasheet
52607 + {LCD_STEP_CMD_DATA, 0x0081, 0x0000,}, // RAM Address Start - Partial Display 1 (R81h) Page 35, SPFD5408B Datasheet
52608 + {LCD_STEP_CMD_DATA, 0x0082, 0x0000,}, // RAM Address End - Partial Display 1 (R82h) Page 36, SPFD5408B Datasheet
52609 + {LCD_STEP_CMD_DATA, 0x0083, 0x0000,}, // Display Position - Partial Display 2 (R83h) Page 36, SPFD5408B Datasheet
52610 + {LCD_STEP_CMD_DATA, 0x0084, 0x0000,}, // RAM Address Start - Partial Display 2 (R84h) Page 36, SPFD5408B Datasheet
52611 + {LCD_STEP_CMD_DATA, 0x0085, 0x0000,}, // RAM Address End - Partial Display 2 (R85h) Page 36, SPFD5408B Datasheet
52612 + {LCD_STEP_CMD_DATA, 0x0090, 0x0010,}, // Panel Interface Control 1 (R90h) Page 36, SPFD5408B Datasheet
52613 + {LCD_STEP_CMD_DATA, 0x0092, 0x0000,}, // Panel Interface Control 2 (R92h) Page 37, SPFD5408B Datasheet
52614 + {LCD_STEP_CMD_DATA, 0x0093, 0x0103,}, // Panel Interface control 3 (R93h) Page 38, SPFD5408B Datasheet
52615 + {LCD_STEP_CMD_DATA, 0x0095, 0x0210,}, // Panel Interface control 4 (R95h) Page 38, SPFD5408B Datasheet
52616 + {LCD_STEP_CMD_DATA, 0x0097, 0x0000,}, // Panel Interface Control 5 (R97h) Page 40, SPFD5408B Datasheet
52617 + {LCD_STEP_CMD_DATA, 0x0098, 0x0000,}, // Panel Interface Control 6 (R98h) Page 41, SPFD5408B Datasheet
52618 + {LCD_STEP_CMD_DATA, 0x0007, 0x0173,}, // Display Control (R07h) Page 16, SPFD5408B Datasheet
52619 + {LCD_STEP_DONE, 0, 0},
52620 +};
52621 +
52622 +const struct ubicom32lcd_panel cfaf240320ktts_180 = {
52623 + .desc = "CFAF240320KTTS 180",
52624 + .init_seq = cfaf240320ktts_init_180,
52625 + .horz_reg = 0x20,
52626 + .vert_reg = 0x21,
52627 + .gram_reg = 0x22,
52628 + .xres = 240,
52629 + .yres = 320,
52630 + .stride = 240,
52631 + .id = 0x5408,
52632 +};
52633 +#endif
52634 +
52635 +#ifdef CONFIG_LCD_UBICOM32_TFT2N0369E_P
52636 +static const struct ubicom32lcd_step tft2n0369ep_init[] = {
52637 + {LCD_STEP_CMD_DATA, 0x0028, 0x0006},
52638 + {LCD_STEP_CMD_DATA, 0x0000, 0x0001},
52639 + {LCD_STEP_SLEEP, 0, 15},
52640 + {LCD_STEP_CMD_DATA, 0x002B, 0x9532},
52641 + {LCD_STEP_CMD_DATA, 0x0003, 0xAAAC},
52642 + {LCD_STEP_CMD_DATA, 0x000C, 0x0002},
52643 + {LCD_STEP_CMD_DATA, 0x000D, 0x000A},
52644 + {LCD_STEP_CMD_DATA, 0x000E, 0x2C00},
52645 + {LCD_STEP_CMD_DATA, 0x001E, 0x00AA},
52646 + {LCD_STEP_CMD_DATA, 0x0025, 0x8000},
52647 + {LCD_STEP_SLEEP, 0, 15},
52648 + {LCD_STEP_CMD_DATA, 0x0001, 0x2B3F},
52649 + {LCD_STEP_CMD_DATA, 0x0002, 0x0600},
52650 + {LCD_STEP_CMD_DATA, 0x0010, 0x0000},
52651 + {LCD_STEP_CMD_DATA, 0x0011, 0x6030},
52652 + {LCD_STEP_SLEEP, 0, 20},
52653 + {LCD_STEP_CMD_DATA, 0x0005, 0x0000},
52654 + {LCD_STEP_CMD_DATA, 0x0006, 0x0000},
52655 + {LCD_STEP_CMD_DATA, 0x0016, 0xEF1C},
52656 + {LCD_STEP_CMD_DATA, 0x0017, 0x0003},
52657 + {LCD_STEP_CMD_DATA, 0x0007, 0x0233},
52658 + {LCD_STEP_CMD_DATA, 0x000B, 0x5312},
52659 + {LCD_STEP_CMD_DATA, 0x000F, 0x0000},
52660 + {LCD_STEP_SLEEP, 0, 20},
52661 + {LCD_STEP_CMD_DATA, 0x0041, 0x0000},
52662 + {LCD_STEP_CMD_DATA, 0x0042, 0x0000},
52663 + {LCD_STEP_CMD_DATA, 0x0048, 0x0000},
52664 + {LCD_STEP_CMD_DATA, 0x0049, 0x013F},
52665 + {LCD_STEP_CMD_DATA, 0x0044, 0xEF00},
52666 + {LCD_STEP_CMD_DATA, 0x0045, 0x0000},
52667 + {LCD_STEP_CMD_DATA, 0x0046, 0x013F},
52668 + {LCD_STEP_CMD_DATA, 0x004A, 0x0000},
52669 + {LCD_STEP_CMD_DATA, 0x004B, 0x0000},
52670 + {LCD_STEP_SLEEP, 0, 20},
52671 + {LCD_STEP_CMD_DATA, 0x0030, 0x0707},
52672 + {LCD_STEP_CMD_DATA, 0x0031, 0x0704},
52673 + {LCD_STEP_CMD_DATA, 0x0032, 0x0204},
52674 + {LCD_STEP_CMD_DATA, 0x0033, 0x0201},
52675 + {LCD_STEP_CMD_DATA, 0x0034, 0x0203},
52676 + {LCD_STEP_CMD_DATA, 0x0035, 0x0204},
52677 + {LCD_STEP_CMD_DATA, 0x0036, 0x0204},
52678 + {LCD_STEP_CMD_DATA, 0x0037, 0x0502},
52679 + {LCD_STEP_CMD_DATA, 0x003A, 0x0302},
52680 + {LCD_STEP_CMD_DATA, 0x003B, 0x0500},
52681 + {LCD_STEP_SLEEP, 0, 20},
52682 + {LCD_STEP_CMD_DATA, 0x0044, 239 << 8 | 0},
52683 + {LCD_STEP_CMD_DATA, 0x0045, 0x0000},
52684 + {LCD_STEP_CMD_DATA, 0x0046, 319},
52685 + {LCD_STEP_DONE, 0, 0},
52686 +};
52687 +
52688 +const struct ubicom32lcd_panel tft2n0369ep = {
52689 + .desc = "TFT2N0369E-Portrait",
52690 + .init_seq = tft2n0369ep_init,
52691 + .horz_reg = 0x4e,
52692 + .vert_reg = 0x4f,
52693 + .gram_reg = 0x22,
52694 + .xres = 240,
52695 + .yres = 320,
52696 + .stride = 240,
52697 + .id = 0x8989,
52698 +};
52699 +#endif
52700 +
52701 +#ifdef CONFIG_LCD_UBICOM32_TFT2N0369E_L
52702 +static const struct ubicom32lcd_step tft2n0369e_init[] = {
52703 + {LCD_STEP_CMD_DATA, 0x0028, 0x0006},
52704 + {LCD_STEP_CMD_DATA, 0x0000, 0x0001},
52705 + {LCD_STEP_SLEEP, 0, 15},
52706 + {LCD_STEP_CMD_DATA, 0x002B, 0x9532},
52707 + {LCD_STEP_CMD_DATA, 0x0003, 0xAAAC},
52708 + {LCD_STEP_CMD_DATA, 0x000C, 0x0002},
52709 + {LCD_STEP_CMD_DATA, 0x000D, 0x000A},
52710 + {LCD_STEP_CMD_DATA, 0x000E, 0x2C00},
52711 + {LCD_STEP_CMD_DATA, 0x001E, 0x00AA},
52712 + {LCD_STEP_CMD_DATA, 0x0025, 0x8000},
52713 + {LCD_STEP_SLEEP, 0, 15},
52714 + {LCD_STEP_CMD_DATA, 0x0001, 0x2B3F},
52715 + {LCD_STEP_CMD_DATA, 0x0002, 0x0600},
52716 + {LCD_STEP_CMD_DATA, 0x0010, 0x0000},
52717 + {LCD_STEP_CMD_DATA, 0x0011, 0x60A8},
52718 + {LCD_STEP_SLEEP, 0, 20},
52719 + {LCD_STEP_CMD_DATA, 0x0005, 0x0000},
52720 + {LCD_STEP_CMD_DATA, 0x0006, 0x0000},
52721 + {LCD_STEP_CMD_DATA, 0x0016, 0xEF1C},
52722 + {LCD_STEP_CMD_DATA, 0x0017, 0x0003},
52723 + {LCD_STEP_CMD_DATA, 0x0007, 0x0233},
52724 + {LCD_STEP_CMD_DATA, 0x000B, 0x5312},
52725 + {LCD_STEP_CMD_DATA, 0x000F, 0x0000},
52726 + {LCD_STEP_SLEEP, 0, 20},
52727 + {LCD_STEP_CMD_DATA, 0x0041, 0x0000},
52728 + {LCD_STEP_CMD_DATA, 0x0042, 0x0000},
52729 + {LCD_STEP_CMD_DATA, 0x0048, 0x0000},
52730 + {LCD_STEP_CMD_DATA, 0x0049, 0x013F},
52731 + {LCD_STEP_CMD_DATA, 0x0044, 0xEF00},
52732 + {LCD_STEP_CMD_DATA, 0x0045, 0x0000},
52733 + {LCD_STEP_CMD_DATA, 0x0046, 0x013F},
52734 + {LCD_STEP_CMD_DATA, 0x004A, 0x0000},
52735 + {LCD_STEP_CMD_DATA, 0x004B, 0x0000},
52736 + {LCD_STEP_SLEEP, 0, 20},
52737 + {LCD_STEP_CMD_DATA, 0x0030, 0x0707},
52738 + {LCD_STEP_CMD_DATA, 0x0031, 0x0704},
52739 + {LCD_STEP_CMD_DATA, 0x0032, 0x0204},
52740 + {LCD_STEP_CMD_DATA, 0x0033, 0x0201},
52741 + {LCD_STEP_CMD_DATA, 0x0034, 0x0203},
52742 + {LCD_STEP_CMD_DATA, 0x0035, 0x0204},
52743 + {LCD_STEP_CMD_DATA, 0x0036, 0x0204},
52744 + {LCD_STEP_CMD_DATA, 0x0037, 0x0502},
52745 + {LCD_STEP_CMD_DATA, 0x003A, 0x0302},
52746 + {LCD_STEP_CMD_DATA, 0x003B, 0x0500},
52747 + {LCD_STEP_SLEEP, 0, 20},
52748 + {LCD_STEP_CMD_DATA, 0x0044, 239 << 8 | 0},
52749 + {LCD_STEP_CMD_DATA, 0x0045, 0x0000},
52750 + {LCD_STEP_CMD_DATA, 0x0046, 319},
52751 + {LCD_STEP_DONE, 0, 0},
52752 +};
52753 +
52754 +const struct ubicom32lcd_panel tft2n0369e = {
52755 + .desc = "TFT2N0369E-Landscape",
52756 + .init_seq = tft2n0369e_init,
52757 + .horz_reg = 0x4e,
52758 + .vert_reg = 0x4f,
52759 + .gram_reg = 0x22,
52760 + .xres = 320,
52761 + .yres = 240,
52762 + .stride = 320,
52763 + .id = 0x8989,
52764 +};
52765 +#endif
52766 +
52767 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400D
52768 +static const struct ubicom32lcd_step cfaf240400d_init[] = {
52769 + {LCD_STEP_CMD_DATA, 0x0606, 0x0000}, // Pin Control (R606h) // Page 41 of SPFD5420A Datasheet
52770 + {LCD_STEP_SLEEP, 0, 50},
52771 + {LCD_STEP_CMD_DATA, 0x0007, 0x0001}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52772 + {LCD_STEP_SLEEP, 0, 50},
52773 + {LCD_STEP_CMD_DATA, 0x0110, 0x0001}, // Power Control 6(R110h) // Page 30 of SPFD5420A Datasheet
52774 + {LCD_STEP_SLEEP, 0, 50},
52775 + {LCD_STEP_CMD_DATA, 0x0100, 0x17B0}, // Power Control 1 (R100h) // Page 26 of SPFD5420A Datasheet
52776 + {LCD_STEP_CMD_DATA, 0x0101, 0x0147}, // Power Control 2 (R101h) // Page 27 of SPFD5420A Datasheet
52777 + {LCD_STEP_CMD_DATA, 0x0102, 0x019D}, // Power Control 3 (R102h) // Page 28 of SPFD5420A Datasheet
52778 + {LCD_STEP_CMD_DATA, 0x0103, 0x3600}, // Power Control 4 (R103h) // Page 29 of SPFD5420A Datasheet
52779 + {LCD_STEP_CMD_DATA, 0x0281, 0x0010}, // NVM read data 2 (R281h) // Page 34 of SPFD5420A Datasheet
52780 + {LCD_STEP_SLEEP, 0, 50},
52781 + {LCD_STEP_CMD_DATA, 0x0102, 0x01BD}, // Power Control 3 (R102h) // Page 28 of SPFD5420A Datasheet
52782 + {LCD_STEP_SLEEP, 0, 50},
52783 +
52784 + //--------------- Power control 1~6 ---------------//
52785 + {LCD_STEP_CMD_DATA, 0x0100, 0x16B0}, // Power Control 1 (R100h) // Page 26 of SPFD5420A Datasheet
52786 + {LCD_STEP_CMD_DATA, 0x0101, 0x0147}, // Power Control 2 (R101h) // Page 27 of SPFD5420A Datasheet
52787 + {LCD_STEP_CMD_DATA, 0x0102, 0x01BD}, // Power Control 3 (R102h) // Page 28 of SPFD5420A Datasheet
52788 + {LCD_STEP_CMD_DATA, 0x0103, 0x2d00}, // Power Control 4 (R103h) // Page 29 of SPFD5420A Datasheet
52789 + {LCD_STEP_CMD_DATA, 0x0107, 0x0000}, // Power Control 5 (R107h) // Page 30 of SPFD5420A Datasheet
52790 + {LCD_STEP_CMD_DATA, 0x0110, 0x0001}, // Power Control 6(R110h) // Page 30 of SPFD5420A Datasheet
52791 + {LCD_STEP_CMD_DATA, 0x0280, 0x0000}, // NVM read data 1 (R280h) // Page 33 of SPFD5420A Datasheet
52792 + {LCD_STEP_CMD_DATA, 0x0281, 0x0006}, // NVM read data 2 (R281h) // Page 34 of SPFD5420A Datasheet
52793 + {LCD_STEP_CMD_DATA, 0x0282, 0x0000}, // NVM read data 3 (R282h) // Page 34 of SPFD5420A Datasheet
52794 +
52795 + //------- Gamma 2.2 control (R300h to R30Fh) ------//
52796 + {LCD_STEP_CMD_DATA, 0x0300, 0x0101},
52797 + {LCD_STEP_CMD_DATA, 0x0301, 0x0b27},
52798 + {LCD_STEP_CMD_DATA, 0x0302, 0x132a},
52799 + {LCD_STEP_CMD_DATA, 0x0303, 0x2a13},
52800 + {LCD_STEP_CMD_DATA, 0x0304, 0x270b},
52801 + {LCD_STEP_CMD_DATA, 0x0305, 0x0101},
52802 + {LCD_STEP_CMD_DATA, 0x0306, 0x1205},
52803 + {LCD_STEP_CMD_DATA, 0x0307, 0x0512},
52804 + {LCD_STEP_CMD_DATA, 0x0308, 0x0005},
52805 + {LCD_STEP_CMD_DATA, 0x0309, 0x0003},
52806 + {LCD_STEP_CMD_DATA, 0x030A, 0x0f04},
52807 + {LCD_STEP_CMD_DATA, 0x030B, 0x0f00},
52808 + {LCD_STEP_CMD_DATA, 0x030C, 0x000f},
52809 + {LCD_STEP_CMD_DATA, 0x030D, 0x040f},
52810 + {LCD_STEP_CMD_DATA, 0x030E, 0x0300},
52811 + {LCD_STEP_CMD_DATA, 0x030F, 0x0500},
52812 +
52813 + {LCD_STEP_CMD_DATA, 0x0400, 0x3500}, // Base Image Number of Line (R400h) // Page 36 of SPFD5420A Datasheet
52814 + {LCD_STEP_CMD_DATA, 0x0401, 0x0001}, // Base Image Display Control (R401h) // Page 39 of SPFD5420A Datasheet
52815 + {LCD_STEP_CMD_DATA, 0x0404, 0x0000}, // Based Image Vertical Scroll Control (R404h) // Page 40 of SPFD5420A Datasheet
52816 +
52817 + //--------------- Normal set ---------------//
52818 + {LCD_STEP_CMD_DATA, 0x0000, 0x0000}, // ID Read Register (R000h) // Page 13 of SPFD5420A Datasheet
52819 + {LCD_STEP_CMD_DATA, 0x0001, 0x0100}, // Driver Output Control Register (R001h) // Page 14 of SPFD5420A Datasheet
52820 + {LCD_STEP_CMD_DATA, 0x0002, 0x0100}, // LCD Driving Waveform Control (R002h) // Page 14 of SPFD5420A Datasheet
52821 + {LCD_STEP_CMD_DATA, 0x0003, 0x1030}, // Entry Mode (R003h) // Page 15 of SPFD5420A Datasheet
52822 + {LCD_STEP_CMD_DATA, 0x0006, 0x0000}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52823 + {LCD_STEP_CMD_DATA, 0x0008, 0x0808}, // Display Control 2 (R008h) // Page 17 of SPFD5420A Datasheet
52824 + {LCD_STEP_CMD_DATA, 0x0009, 0x0001}, // Display Control 3 (R009h) // Page 18 of SPFD5420A Datasheet
52825 + {LCD_STEP_CMD_DATA, 0x000B, 0x0010}, // Low Power Control (R00Bh) // Page 19 of SPFD5420A Datasheet
52826 + {LCD_STEP_CMD_DATA, 0x000C, 0x0000}, // External Display Interface Control 1 (R00Ch) // Page 19 of SPFD5420A Datasheet
52827 + {LCD_STEP_CMD_DATA, 0x000F, 0x0000}, // External Display Interface Control 2 (R00Fh) // Page 20 of SPFD5420A Datasheet
52828 + {LCD_STEP_CMD_DATA, 0x0007, 0x0001}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52829 +
52830 + //--------------- Panel interface control 1~6 ---------------//
52831 + {LCD_STEP_CMD_DATA, 0x0010, 0x0012}, // Panel Interface Control 1 (R010h) // Page 20 of SPFD5420A Datasheet
52832 + {LCD_STEP_CMD_DATA, 0x0011, 0x0202}, // Panel Interface Control 2 (R011h) // Page 21 of SPFD5420A Datasheet
52833 + {LCD_STEP_CMD_DATA, 0x0012, 0x0300}, // Panel Interface control 3 (R012h) // Page 22 of SPFD5420A Datasheet
52834 + {LCD_STEP_CMD_DATA, 0x0020, 0x021E}, // Panel Interface control 4 (R020h) // Page 22 of SPFD5420A Datasheet
52835 + {LCD_STEP_CMD_DATA, 0x0021, 0x0202}, // Panel Interface Control 5 (021Rh) // Page 24 of SPFD5420A Datasheet
52836 + {LCD_STEP_CMD_DATA, 0x0022, 0x0100}, // Panel Interface Control 6 (R022h) // Page 25 of SPFD5420A Datasheet
52837 + {LCD_STEP_CMD_DATA, 0x0090, 0x8000}, // Frame Marker Control (R090h) // Page 25 of SPFD5420A Datasheet
52838 +
52839 + //--------------- Partial display ---------------//
52840 + {LCD_STEP_CMD_DATA, 0x0210, 0x0000}, // Window Horizontal RAM Address Start (R210h) // Page 35 of SPFD5420A Datasheet
52841 + {LCD_STEP_CMD_DATA, 0x0211, 0x00EF}, // Window Horziontal RAM Address End (R211h) // Page 35 of SPFD5420A Datasheet
52842 + {LCD_STEP_CMD_DATA, 0x0212, 0x0000}, // Window Vertical RAM Address Start (R212h) // Page 35 of SPFD5420A Datasheet
52843 + {LCD_STEP_CMD_DATA, 0x0213, 0x018F}, // Window Vertical RAM Address End (R213h) // Page 35 of SPFD5420A Datasheet
52844 + {LCD_STEP_CMD_DATA, 0x0500, 0x0000}, // Display Position - Partial Display 1 (R500h) // Page 40 of SPFD5420A Datasheet
52845 + {LCD_STEP_CMD_DATA, 0x0501, 0x0000}, // RAM Address Start - Partial Display 1 (R501h)// Page 40 of SPFD5420A Datasheet
52846 + {LCD_STEP_CMD_DATA, 0x0502, 0x0000}, // RAM Address End - Partail Display 1 (R502h) // Page 40 of SPFD5420A Datasheet
52847 + {LCD_STEP_CMD_DATA, 0x0503, 0x0000}, // Display Position - Partial Display 2 (R503h) // Page 40 of SPFD5420A Datasheet
52848 + {LCD_STEP_CMD_DATA, 0x0504, 0x0000}, // RAM Address Start . Partial Display 2 (R504h)// Page 41 of SPFD5420A Datasheet
52849 + {LCD_STEP_CMD_DATA, 0x0505, 0x0000}, // RAM Address End . Partial Display 2 (R505h) // Page 41 of SPFD5420A Datasheet
52850 + {LCD_STEP_CMD_DATA, 0x0606, 0x0000}, // Pin Control (R606h) // Page 41 of SPFD5420A Datasheet
52851 + {LCD_STEP_CMD_DATA, 0x06F0, 0x0000}, // NVM Access Control (R6F0h) // Page 41 of SPFD5420A Datasheet
52852 + {LCD_STEP_CMD_DATA, 0x0007, 0x0173}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52853 + {LCD_STEP_SLEEP, 0, 50},
52854 + {LCD_STEP_CMD_DATA, 0x0007, 0x0171}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52855 + {LCD_STEP_SLEEP, 0, 10},
52856 + {LCD_STEP_CMD_DATA, 0x0007, 0x0173}, // Display Control 1 (R007h) // Page 16 of SPFD5420A Datasheet
52857 + {LCD_STEP_DONE, 0, 0},
52858 +};
52859 +
52860 +const struct ubicom32lcd_panel cfaf240400d = {
52861 + .desc = "CFAF240400D",
52862 + .init_seq = cfaf240400d_init,
52863 + .horz_reg = 0x0200,
52864 + .vert_reg = 0x0201,
52865 + .gram_reg = 0x0202,
52866 + .xres = 240,
52867 + .yres = 400,
52868 + .stride = 240,
52869 + .id = 0x5420,
52870 +};
52871 +#endif
52872 +
52873 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400F
52874 +static const struct ubicom32lcd_step cfaf320240f_init[] = {
52875 + {LCD_STEP_CMD_DATA, 0x0028, 0x0006}, // VCOM OTP Page 55-56 of SSD2119 datasheet
52876 + {LCD_STEP_CMD_DATA, 0x0000, 0x0001}, // start Oscillator Page 36 of SSD2119 datasheet
52877 + {LCD_STEP_CMD_DATA, 0x0010, 0x0000}, // Sleep mode Page 49 of SSD2119 datasheet
52878 + {LCD_STEP_CMD_DATA, 0x0001, 0x32EF}, // Driver Output Control Page 36-39 of SSD2119 datasheet
52879 + {LCD_STEP_CMD_DATA, 0x0002, 0x0600}, // LCD Driving Waveform Control Page 40-42 of SSD2119 datasheet
52880 + {LCD_STEP_CMD_DATA, 0x0003, 0x6A38}, // Power Control 1 Page 43-44 of SSD2119 datasheet
52881 + {LCD_STEP_CMD_DATA, 0x0011, 0x6870}, // Entry Mode Page 50-52 of SSD2119 datasheet
52882 + {LCD_STEP_CMD_DATA, 0X000F, 0x0000}, // Gate Scan Position Page 49 of SSD2119 datasheet
52883 + {LCD_STEP_CMD_DATA, 0X000B, 0x5308}, // Frame Cycle Control Page 45 of SSD2119 datasheet
52884 + {LCD_STEP_CMD_DATA, 0x000C, 0x0003}, // Power Control 2 Page 47 of SSD2119 datasheet
52885 + {LCD_STEP_CMD_DATA, 0x000D, 0x000A}, // Power Control 3 Page 48 of SSD2119 datasheet
52886 + {LCD_STEP_CMD_DATA, 0x000E, 0x2E00}, // Power Control 4 Page 48 of SSD2119 datasheet
52887 + {LCD_STEP_CMD_DATA, 0x001E, 0x00BE}, // Power Control 5 Page 53 of SSD2119 datasheet
52888 + {LCD_STEP_CMD_DATA, 0x0025, 0x8000}, // Frame Frequency Control Page 53 of SSD2119 datasheet
52889 + {LCD_STEP_CMD_DATA, 0x0026, 0x7800}, // Analog setting Page 54 of SSD2119 datasheet
52890 + {LCD_STEP_CMD_DATA, 0x004E, 0x0000}, // Ram Address Set Page 58 of SSD2119 datasheet
52891 + {LCD_STEP_CMD_DATA, 0x004F, 0x0000}, // Ram Address Set Page 58 of SSD2119 datasheet
52892 + {LCD_STEP_CMD_DATA, 0x0012, 0x08D9}, // Sleep mode Page 49 of SSD2119 datasheet
52893 +
52894 + // Gamma Control (R30h to R3Bh) -- Page 56 of SSD2119 datasheet
52895 + {LCD_STEP_CMD_DATA, 0x0030, 0x0000},
52896 + {LCD_STEP_CMD_DATA, 0x0031, 0x0104},
52897 + {LCD_STEP_CMD_DATA, 0x0032, 0x0100},
52898 + {LCD_STEP_CMD_DATA, 0x0033, 0x0305},
52899 + {LCD_STEP_CMD_DATA, 0x0034, 0x0505},
52900 + {LCD_STEP_CMD_DATA, 0x0035, 0x0305},
52901 + {LCD_STEP_CMD_DATA, 0x0036, 0x0707},
52902 + {LCD_STEP_CMD_DATA, 0x0037, 0x0300},
52903 + {LCD_STEP_CMD_DATA, 0x003A, 0x1200},
52904 + {LCD_STEP_CMD_DATA, 0x003B, 0x0800},
52905 +
52906 + {LCD_STEP_CMD_DATA, 0x0007, 0x0033}, // Display Control Page 45 of SSD2119 datasheet
52907 +
52908 + {LCD_STEP_CMD_DATA, 0x0044, 0xEF00}, // Vertical RAM address position Page 57 of SSD2119 datasheet
52909 + {LCD_STEP_CMD_DATA, 0x0045, 0x0000}, // Horizontal RAM address position Page 57 of SSD2119 datasheet
52910 + {LCD_STEP_CMD_DATA, 0x0046, 0x013F}, // Horizontal RAM address position Page 57 of SSD2119 datasheet
52911 +
52912 + {LCD_STEP_SLEEP, 0, 150},
52913 +
52914 + {LCD_STEP_DONE, 0, 0},
52915 +};
52916 +
52917 +const struct ubicom32lcd_panel cfaf320240f = {
52918 + .desc = "CFAF320240F",
52919 + .init_seq = cfaf320240f_init,
52920 + .horz_reg = 0x4e,
52921 + .vert_reg = 0x4f,
52922 + .gram_reg = 0x22,
52923 + .xres = 320,
52924 + .yres = 240,
52925 + .stride = 320,
52926 + .id = 0x9919,
52927 +};
52928 +#endif
52929 +
52930 +const struct ubicom32lcd_panel *ubicom32lcd_panels[] = {
52931 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400KTTS_180
52932 + &cfaf240320ktts_180,
52933 +#endif
52934 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400KTTS
52935 + &cfaf240320ktts_0,
52936 +#endif
52937 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400D
52938 + &cfaf240400d,
52939 +#endif
52940 +#ifdef CONFIG_LCD_UBICOM32_TFT2N0369E_P
52941 + &tft2n0369ep,
52942 +#endif
52943 +#ifdef CONFIG_LCD_UBICOM32_TFT2N0369E_L
52944 + &tft2n0369e,
52945 +#endif
52946 +#ifdef CONFIG_LCD_UBICOM32_CFAF240400F
52947 + &cfaf320240f,
52948 +#endif
52949 + NULL,
52950 +};
52951 +
52952 +#endif
52953 diff -ruN linux-2.6.30.10/drivers/video/backlight/ubicom32lcdpower.c linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcdpower.c
52954 --- linux-2.6.30.10/drivers/video/backlight/ubicom32lcdpower.c 1970-01-01 02:00:00.000000000 +0200
52955 +++ linux-2.6.30.10-ubi/drivers/video/backlight/ubicom32lcdpower.c 2009-12-11 11:45:20.000000000 +0200
52956 @@ -0,0 +1,194 @@
52957 +/*
52958 + * drivers/video/backlight/ubicom32lcdpowerpower.c
52959 + * LCD power driver for the Ubicom32 platform
52960 + *
52961 + * (C) Copyright 2009, Ubicom, Inc.
52962 + *
52963 + * This file is part of the Ubicom32 Linux Kernel Port.
52964 + *
52965 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
52966 + * it and/or modify it under the terms of the GNU General Public License
52967 + * as published by the Free Software Foundation, either version 2 of the
52968 + * License, or (at your option) any later version.
52969 + *
52970 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
52971 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
52972 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
52973 + * the GNU General Public License for more details.
52974 + *
52975 + * You should have received a copy of the GNU General Public License
52976 + * along with the Ubicom32 Linux Kernel Port. If not,
52977 + * see <http://www.gnu.org/licenses/>.
52978 + *
52979 + * Ubicom32 implementation derived from (with many thanks):
52980 + * arch/m68knommu
52981 + * arch/blackfin
52982 + * arch/parisc
52983 + */
52984 +#include <linux/init.h>
52985 +#include <linux/kernel.h>
52986 +#include <linux/module.h>
52987 +#include <linux/platform_device.h>
52988 +#include <linux/lcd.h>
52989 +#include <linux/fb.h>
52990 +#include <linux/gpio.h>
52991 +
52992 +#include <asm/ubicom32lcdpower.h>
52993 +#include <asm/ip5000.h>
52994 +
52995 +#define DRIVER_NAME "ubicom32lcdpower"
52996 +
52997 +struct ubicom32lcdpower_data {
52998 + /*
52999 + * Pointer to the platform data structure. Keep this around since we need values
53000 + * from it to set the backlight intensity.
53001 + */
53002 + const struct ubicom32lcdpower_platform_data *pdata;
53003 +
53004 + /*
53005 + * LCD device, we have to save this for use when we remove ourselves.
53006 + */
53007 + struct lcd_device *lcddev;
53008 +};
53009 +
53010 +/*
53011 + * ubicom32lcdpower_set_power
53012 + */
53013 +static int ubicom32lcdpower_set_power(struct lcd_device *ld, int power)
53014 +{
53015 + struct ubicom32lcdpower_data *ud = (struct ubicom32lcdpower_data *)lcd_get_data(ld);
53016 + if (power == FB_BLANK_UNBLANK) {
53017 + gpio_direction_output(ud->pdata->vgh_gpio, ud->pdata->vgh_polarity);
53018 + return 0;
53019 + }
53020 +
53021 + gpio_direction_output(ud->pdata->vgh_gpio, !ud->pdata->vgh_polarity);
53022 + return 0;
53023 +}
53024 +
53025 +/*
53026 + * ubicom32lcdpower_get_power
53027 + */
53028 +static int ubicom32lcdpower_get_power(struct lcd_device *ld)
53029 +{
53030 + struct ubicom32lcdpower_data *ud = (struct ubicom32lcdpower_data *)lcd_get_data(ld);
53031 + int vgh = gpio_get_value(ud->pdata->vgh_gpio);
53032 + if ((vgh && ud->pdata->vgh_polarity) || (!vgh && !ud->pdata->vgh_polarity)) {
53033 + return 1;
53034 + }
53035 +
53036 + return 0;
53037 +}
53038 +
53039 +static struct lcd_ops ubicom32lcdpower_ops = {
53040 + .get_power = ubicom32lcdpower_get_power,
53041 + .set_power = ubicom32lcdpower_set_power,
53042 +};
53043 +
53044 +/*
53045 + * ubicom32lcdpower_probe
53046 + */
53047 +static int ubicom32lcdpower_probe(struct platform_device *pdev)
53048 +{
53049 + const struct ubicom32lcdpower_platform_data *pdata = pdev->dev.platform_data;
53050 + struct ubicom32lcdpower_data *ud;
53051 + struct lcd_device *lcddev;
53052 + int retval;
53053 +
53054 + /*
53055 + * Check to see if we have any platform data, if we don't have a LCD to control
53056 + */
53057 + if (!pdata) {
53058 + return -ENODEV;
53059 + }
53060 +
53061 + /*
53062 + * Allocate our private data
53063 + */
53064 + ud = kzalloc(sizeof(struct ubicom32lcdpower_data), GFP_KERNEL);
53065 + if (!ud) {
53066 + return -ENOMEM;
53067 + }
53068 +
53069 + ud->pdata = pdata;
53070 +
53071 + /*
53072 + * Request our GPIOs
53073 + */
53074 + retval = gpio_request(pdata->vgh_gpio, "vgh");
53075 + if (retval) {
53076 + dev_err(&pdev->dev, "Failed to allocate vgh GPIO\n");
53077 + goto fail_gpio;
53078 + }
53079 +
53080 + /*
53081 + * Register our lcd device
53082 + */
53083 + lcddev = lcd_device_register(DRIVER_NAME, &pdev->dev, ud, &ubicom32lcdpower_ops);
53084 + if (IS_ERR(lcddev)) {
53085 + retval = PTR_ERR(lcddev);
53086 + goto fail;
53087 + }
53088 +
53089 + ud->lcddev = lcddev;
53090 + platform_set_drvdata(pdev, ud);
53091 +
53092 + ubicom32lcdpower_set_power(lcddev, FB_BLANK_UNBLANK);
53093 +
53094 + printk(KERN_INFO DRIVER_NAME ": LCD driver started\n");
53095 +
53096 + return 0;
53097 +
53098 +fail:
53099 + gpio_free(pdata->vgh_gpio);
53100 +
53101 +fail_gpio:
53102 + platform_set_drvdata(pdev, NULL);
53103 + kfree(ud);
53104 + return retval;
53105 +}
53106 +
53107 +/*
53108 + * ubicom32lcdpower_remove
53109 + */
53110 +static int __exit ubicom32lcdpower_remove(struct platform_device *pdev)
53111 +{
53112 + struct ubicom32lcdpower_data *ud = platform_get_drvdata(pdev);
53113 +
53114 + lcd_device_unregister(ud->lcddev);
53115 + platform_set_drvdata(pdev, NULL);
53116 + kfree(ud);
53117 +
53118 + return 0;
53119 +}
53120 +
53121 +static struct platform_driver ubicom32lcdpower_driver = {
53122 + .driver = {
53123 + .name = DRIVER_NAME,
53124 + .owner = THIS_MODULE,
53125 + },
53126 +
53127 + .remove = __exit_p(ubicom32lcdpower_remove),
53128 +};
53129 +
53130 +/*
53131 + * ubicom32lcdpower_init
53132 + */
53133 +static int __init ubicom32lcdpower_init(void)
53134 +{
53135 + return platform_driver_probe(&ubicom32lcdpower_driver, ubicom32lcdpower_probe);
53136 +}
53137 +module_init(ubicom32lcdpower_init);
53138 +
53139 +/*
53140 + * ubicom32lcdpower_exit
53141 + */
53142 +static void __exit ubicom32lcdpower_exit(void)
53143 +{
53144 + platform_driver_unregister(&ubicom32lcdpower_driver);
53145 +}
53146 +module_exit(ubicom32lcdpower_exit);
53147 +
53148 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
53149 +MODULE_DESCRIPTION("Ubicom32 lcd power driver");
53150 +MODULE_LICENSE("GPL");
53151 diff -ruN linux-2.6.30.10/drivers/video/Kconfig linux-2.6.30.10-ubi/drivers/video/Kconfig
53152 --- linux-2.6.30.10/drivers/video/Kconfig 2009-12-04 08:00:07.000000000 +0200
53153 +++ linux-2.6.30.10-ubi/drivers/video/Kconfig 2009-12-11 11:45:20.000000000 +0200
53154 @@ -609,6 +609,50 @@
53155 This display is a QVGA 320x240 24-bit RGB display interfaced by an 8-bit wide PPI
53156 It uses PPI[0..7] PPI_FS1, PPI_FS2 and PPI_CLK.
53157
53158 +config FB_UBICOM32
53159 + tristate "Ubicom32 Frame Buffer driver"
53160 + depends on FB && UBICOM32
53161 + select FB_CFB_FILLRECT
53162 + select FB_CFB_COPYAREA
53163 + select FB_CFB_IMAGEBLIT
53164 + select FONT_6x11 if FRAMEBUFFER_CONSOLE
53165 + help
53166 + This is the framebuffer device driver for the Ubicom32 architecture.
53167 + You can configure video memory by using kernel command line parameters, for example:
53168 + video=ubicomfb:vram_size=512,init_value=0xffff
53169 +
53170 +config FB_UBICOM32_PLIO80
53171 + tristate "Ubicom32 80 Bus PLIO Frame Buffer driver"
53172 + depends on FB && UBICOM32
53173 + select FB_CFB_FILLRECT
53174 + select FB_CFB_COPYAREA
53175 + select FB_CFB_IMAGEBLIT
53176 + select FONT_6x11 if FRAMEBUFFER_CONSOLE
53177 + select UBICOM32_PLIO
53178 + help
53179 + This is a framebuffer device driver for the Ubicom32 architecture.
53180 + You can configure the xres, yres and vram size (in kilobytes) by using
53181 + kernel command line parameters, for example:
53182 + video=ubicom32vfb:xres=320,yres=240,vram_size=512
53183 +
53184 +config FB_UBICOM32_VIRTUAL
53185 + tristate "Ubicom32 Virtual Frame Buffer driver"
53186 + depends on FB && UBICOM32
53187 + select FB_CFB_FILLRECT
53188 + select FB_CFB_COPYAREA
53189 + select FB_CFB_IMAGEBLIT
53190 + select FONT_6x11 if FRAMEBUFFER_CONSOLE
53191 + help
53192 + This is a virtual framebuffer device driver for the Ubicom32 architecture.
53193 + You can configure the xres, yres and vram size (in kilobytes) by using
53194 + kernel command line parameters, for example:
53195 + video=ubicom32vfb:xres=320,yres=240,vram_size=512
53196 +
53197 +config FB_UBICOM32_VIRTUAL_NOAUTO
53198 + bool "Do not automatically load"
53199 + depends on FB_UBICOM32_VIRTUAL
53200 + help
53201 + Select this option to prevent the VFB from automatically loading at boot.
53202
53203 config FB_STI
53204 tristate "HP STI frame buffer device support"
53205 diff -ruN linux-2.6.30.10/drivers/video/Makefile linux-2.6.30.10-ubi/drivers/video/Makefile
53206 --- linux-2.6.30.10/drivers/video/Makefile 2009-12-04 08:00:07.000000000 +0200
53207 +++ linux-2.6.30.10-ubi/drivers/video/Makefile 2009-12-11 11:45:20.000000000 +0200
53208 @@ -136,6 +136,10 @@
53209 obj-$(CONFIG_FB_BFIN_T350MCQB) += bfin-t350mcqb-fb.o
53210 obj-$(CONFIG_FB_MX3) += mx3fb.o
53211
53212 +obj-$(CONFIG_FB_UBICOM32) += ubicom32fb.o
53213 +obj-$(CONFIG_FB_UBICOM32_PLIO80) += ubicom32plio80.o
53214 +obj-$(CONFIG_FB_UBICOM32_VIRTUAL) += ubicom32vfb.o
53215 +
53216 # the test framebuffer is last
53217 obj-$(CONFIG_FB_VIRTUAL) += vfb.o
53218
53219 diff -ruN linux-2.6.30.10/drivers/video/ubicom32fb.c linux-2.6.30.10-ubi/drivers/video/ubicom32fb.c
53220 --- linux-2.6.30.10/drivers/video/ubicom32fb.c 1970-01-01 02:00:00.000000000 +0200
53221 +++ linux-2.6.30.10-ubi/drivers/video/ubicom32fb.c 2009-12-11 11:45:21.000000000 +0200
53222 @@ -0,0 +1,779 @@
53223 +/*
53224 + * drivers/video/ubicom32fb.c
53225 + * Ubicom32 frame buffer driver
53226 + *
53227 + * (C) Copyright 2009, Ubicom, Inc.
53228 + *
53229 + * This file is part of the Ubicom32 Linux Kernel Port.
53230 + *
53231 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
53232 + * it and/or modify it under the terms of the GNU General Public License
53233 + * as published by the Free Software Foundation, either version 2 of the
53234 + * License, or (at your option) any later version.
53235 + *
53236 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
53237 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
53238 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
53239 + * the GNU General Public License for more details.
53240 + *
53241 + * You should have received a copy of the GNU General Public License
53242 + * along with the Ubicom32 Linux Kernel Port. If not,
53243 + * see <http://www.gnu.org/licenses/>.
53244 + *
53245 + * Ubicom32 implementation derived from (with many thanks):
53246 + * arch/m68knommu
53247 + * arch/blackfin
53248 + * arch/parisc
53249 + */
53250 +
53251 +/*
53252 + * This driver was based on skeletonfb.c, Skeleton for a frame buffer device by
53253 + * Geert Uytterhoeven.
53254 + */
53255 +
53256 +#include <linux/device.h>
53257 +#include <linux/module.h>
53258 +#include <linux/kernel.h>
53259 +#include <linux/version.h>
53260 +#include <linux/errno.h>
53261 +#include <linux/string.h>
53262 +#include <linux/mm.h>
53263 +#include <linux/fb.h>
53264 +#include <linux/init.h>
53265 +#include <linux/dma-mapping.h>
53266 +#include <linux/platform_device.h>
53267 +#include <linux/device.h>
53268 +#include <linux/uaccess.h>
53269 +#include <linux/interrupt.h>
53270 +
53271 +#include <asm/io.h>
53272 +#include <asm/ip5000.h>
53273 +#include <asm/vdc_tio.h>
53274 +#include <asm/ubicom32fb.h>
53275 +
53276 +#define DRIVER_NAME "ubicom32fb"
53277 +#define DRIVER_DESCRIPTION "Ubicom32 frame buffer driver"
53278 +
53279 +#define PALETTE_ENTRIES_NO 16
53280 +
53281 +/*
53282 + * Option variables
53283 + *
53284 + * vram_size: VRAM size in kilobytes, subject to alignment
53285 + */
53286 +static int vram_size = 0;
53287 +module_param(vram_size, int, 0);
53288 +MODULE_PARM_DESC(vram, "VRAM size, in kilobytes to allocate, should be at least the size of one screen, subject to alignment");
53289 +static int init_value = 0;
53290 +module_param(init_value, int, 0);
53291 +MODULE_PARM_DESC(init, "Initial value of the framebuffer (16-bit number).");
53292 +
53293 +/*
53294 + * fb_fix_screeninfo defines the non-changeable properties of the VDC, depending on what mode it is in.
53295 + */
53296 +static struct fb_fix_screeninfo ubicom32fb_fix = {
53297 + .id = "Ubicom32",
53298 + .type = FB_TYPE_PACKED_PIXELS,
53299 + .visual = FB_VISUAL_TRUECOLOR,
53300 + .accel = FB_ACCEL_UBICOM32,
53301 +};
53302 +
53303 +/*
53304 + * Filled in at probe time when we find out what the hardware supports
53305 + */
53306 +static struct fb_var_screeninfo ubicom32fb_var;
53307 +
53308 +/*
53309 + * Private data structure
53310 + */
53311 +struct ubicom32fb_drvdata {
53312 + struct fb_info *fbinfo;
53313 + bool cmap_alloc;
53314 +
53315 + /*
53316 + * The address of the framebuffer in memory
53317 + */
53318 + void *fb;
53319 + void *fb_aligned;
53320 +
53321 + /*
53322 + * Total size of vram including alignment allowance
53323 + */
53324 + u32 total_vram_size;
53325 +
53326 + /*
53327 + * Interrupt to set when changing registers
53328 + */
53329 + u32 vp_int;
53330 +
53331 + /*
53332 + * Optional: Interrupt used by TIO to signal us
53333 + */
53334 + u32 rx_int;
53335 +
53336 + /*
53337 + * Base address of the regs for VDC_TIO
53338 + */
53339 + volatile struct vdc_tio_vp_regs *regs;
53340 +
53341 + /*
53342 + * non-zero if we are in yuv mode
53343 + */
53344 + u8_t is_yuv;
53345 +
53346 + /*
53347 + * Fake palette of 16 colors
53348 + */
53349 + u32 pseudo_palette[PALETTE_ENTRIES_NO];
53350 +
53351 + /*
53352 + * Wait queue and lock used to block when we need to wait
53353 + * for something to happen.
53354 + */
53355 + wait_queue_head_t waitq;
53356 + struct mutex lock;
53357 +
53358 +};
53359 +
53360 +/*
53361 + * ubicom32fb_set_next_frame
53362 + * Sets the next frame buffer to display
53363 + *
53364 + * if sync is TRUE then this function will block until the hardware
53365 + * acknowledges the change
53366 + */
53367 +static inline void ubicom32fb_set_next_frame(struct ubicom32fb_drvdata *ud, void *fb, u8_t sync)
53368 +{
53369 + ud->regs->next_frame_flags = ud->is_yuv ? VDCTIO_NEXT_FRAME_FLAG_YUV : 0;
53370 + ud->regs->next_frame = (void *)((u32_t)fb | 1);
53371 +
53372 + /*
53373 + * If we have interrupts, then we can wait on it
53374 + */
53375 + if (ud->rx_int != -1) {
53376 + DEFINE_WAIT(wait);
53377 + unsigned long flags;
53378 +
53379 + spin_lock_irqsave(&ud->lock, flags);
53380 + prepare_to_wait(&ud->waitq, &wait, TASK_INTERRUPTIBLE);
53381 + spin_unlock_irqrestore(&ud->lock, flags);
53382 + schedule();
53383 + finish_wait(&ud->waitq, &wait);
53384 + return;
53385 + }
53386 +
53387 + /*
53388 + * No interrupt, we will just spin here
53389 + */
53390 + while (sync && ((u32_t)ud->regs->next_frame & 1));
53391 +}
53392 +
53393 +/*
53394 + * ubicom32fb_send_command
53395 + * Sends a command/data pair to the VDC
53396 + */
53397 +static inline void ubicom32fb_send_command(struct ubicom32fb_drvdata *ud, u16 command, u8_t block)
53398 +{
53399 + ud->regs->command = command;
53400 + ubicom32_set_interrupt(ud->vp_int);
53401 + while (block && ud->regs->command);
53402 +}
53403 +
53404 +/*
53405 + * ubicom32fb_ioctl
53406 + * Handles any ioctls sent to us
53407 + */
53408 +static int ubicom32fb_ioctl(struct fb_info *fbi, unsigned int cmd,
53409 + unsigned long arg)
53410 +{
53411 + struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)fbi->par;
53412 + void __user *argp = (void __user *)arg;
53413 + int retval = -EFAULT;
53414 +
53415 + switch (cmd) {
53416 + case UBICOM32FB_IOCTL_SET_NEXT_FRAME_SYNC:
53417 + // check alignment, return -EINVAL if necessary
53418 + ubicom32fb_set_next_frame(ud, argp, 1);
53419 + retval = 0;
53420 + break;
53421 +
53422 + case UBICOM32FB_IOCTL_SET_NEXT_FRAME:
53423 + // check alignment, return -EINVAL if necessary
53424 + ubicom32fb_set_next_frame(ud, argp, 0);
53425 + retval = 0;
53426 + break;
53427 +
53428 + case UBICOM32FB_IOCTL_SET_MODE:
53429 + if (!(ud->regs->caps & VDCTIO_CAPS_SUPPORTS_SCALING)) {
53430 + break;
53431 + } else {
53432 + struct ubicom32fb_mode mode;
53433 + volatile struct vdc_tio_vp_regs *regs = ud->regs;
53434 + u32_t flags = 0;
53435 +
53436 + if (copy_from_user(&mode, argp, sizeof(mode))) {
53437 + break;
53438 + }
53439 +
53440 + regs->x_in = mode.width;
53441 + regs->y_in = mode.height;
53442 + regs->x_out = regs->xres;
53443 + regs->y_out = regs->yres;
53444 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_SCAN_ORDER) {
53445 + flags |= VDCTIO_SCALE_FLAG_YUV_SCAN_ORDER;
53446 + }
53447 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV_BLOCK_ORDER) {
53448 + flags |= VDCTIO_SCALE_FLAG_YUV_BLOCK_ORDER;
53449 + }
53450 + ud->is_yuv = mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_YUV;
53451 + if (ud->is_yuv) {
53452 + flags |= VDCTIO_SCALE_FLAG_YUV;
53453 + }
53454 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_16_255) {
53455 + flags |= VDCTIO_SCALE_FLAG_VRANGE_16_255;
53456 + }
53457 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VRANGE_0_255) {
53458 + flags |= VDCTIO_SCALE_FLAG_VRANGE_0_255;
53459 + }
53460 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_VSUB) {
53461 + flags |= VDCTIO_SCALE_FLAG_VSUB;
53462 + }
53463 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_2_1) {
53464 + flags |= VDCTIO_SCALE_FLAG_HSUB_2_1;
53465 + }
53466 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_HSUB_1_1) {
53467 + flags |= VDCTIO_SCALE_FLAG_HSUB_1_1;
53468 + }
53469 + if (mode.flags & UBICOM32FB_IOCTL_SET_MODE_FLAG_SCALE_ENABLE) {
53470 + flags |= VDCTIO_SCALE_FLAG_ENABLE;
53471 + }
53472 + if (mode.next_frame) {
53473 + flags |= VDCTIO_SCALE_FLAG_SET_FRAME_BUFFER;
53474 + regs->next_frame = mode.next_frame;
53475 + }
53476 +
53477 + regs->scale_flags = flags;
53478 + ubicom32fb_send_command(ud, VDCTIO_COMMAND_SET_SCALE_MODE, 1);
53479 + retval = 0;
53480 + break;
53481 + }
53482 +
53483 + default:
53484 + retval = -ENOIOCTLCMD;
53485 + break;
53486 + }
53487 +
53488 + return retval;
53489 +}
53490 +
53491 +/*
53492 + * ubicom32fb_interrupt
53493 + * Called by the OS when the TIO has set the rx_int
53494 + */
53495 +static irqreturn_t ubicom32fb_interrupt(int vec, void *appdata)
53496 +{
53497 + struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)appdata;
53498 +
53499 + spin_lock(&ud->lock);
53500 + if (waitqueue_active(&ud->waitq)) {
53501 + wake_up(&ud->waitq);
53502 + }
53503 + spin_unlock(&ud->lock);
53504 +
53505 + return IRQ_HANDLED;
53506 +}
53507 +
53508 +/*
53509 + * ubicom32fb_pan_display
53510 + * Pans the display to a given location. Supports only y direction panning.
53511 + */
53512 +static int ubicom32fb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
53513 +{
53514 + struct ubicom32fb_drvdata *ud = (struct ubicom32fb_drvdata *)fbi->par;
53515 + void *new_addr;
53516 +
53517 + /*
53518 + * Get the last y line that would be displayed. Since we don't support YWRAP,
53519 + * it must be less than our virtual y size.
53520 + */
53521 + u32 lasty = var->yoffset + var->yres;
53522 + if (lasty > fbi->var.yres_virtual) {
53523 + /*
53524 + * We would fall off the end of our frame buffer if we panned here.
53525 + */
53526 + return -EINVAL;
53527 + }
53528 +
53529 + if (var->xoffset) {
53530 + /*
53531 + * We don't support panning in the x direction
53532 + */
53533 + return -EINVAL;
53534 + }
53535 +
53536 + /*
53537 + * Everything looks sane, go ahead and pan
53538 + *
53539 + * We have to calculate a new address for the VDC to look at
53540 + */
53541 + new_addr = ud->fb_aligned + (var->yoffset * fbi->fix.line_length);
53542 +
53543 + /*
53544 + * Send down the command. The buffer will switch at the next vertical blank
53545 + */
53546 + ubicom32fb_set_next_frame(ud, (void *)new_addr, 0);
53547 +
53548 + return 0;
53549 +}
53550 +
53551 +/*
53552 + * ubicom32fb_setcolreg
53553 + * Sets a color in our virtual palette
53554 + */
53555 +static int ubicom32fb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
53556 +{
53557 + u32 *palette = fbi->pseudo_palette;
53558 +
53559 + if (regno >= PALETTE_ENTRIES_NO) {
53560 + return -EINVAL;
53561 + }
53562 +
53563 + /*
53564 + * We only use 8 bits from each color
53565 + */
53566 + red >>= 8;
53567 + green >>= 8;
53568 + blue >>= 8;
53569 +
53570 + /*
53571 + * Convert any grayscale values
53572 + */
53573 + if (fbi->var.grayscale) {
53574 + u16 gray = red + green + blue;
53575 + gray += (gray >> 2) + (gray >> 3) - (gray >> 7);
53576 + gray >>= 2;
53577 + if (gray > 255) {
53578 + gray = 255;
53579 + }
53580 + red = gray;
53581 + blue = gray;
53582 + green = gray;
53583 + }
53584 +
53585 + palette[regno] = (red << fbi->var.red.offset) | (green << fbi->var.green.offset) |
53586 + (blue << fbi->var.blue.offset);
53587 +
53588 + return 0;
53589 +}
53590 +
53591 +/*
53592 + * ubicom32fb_mmap
53593 + */
53594 +static int ubicom32fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
53595 +{
53596 + struct ubicom32fb_drvdata *drvdata = (struct ubicom32fb_drvdata *)info->par;
53597 +
53598 + vma->vm_start = (unsigned long)(drvdata->fb_aligned);
53599 +
53600 + vma->vm_end = vma->vm_start + info->fix.smem_len;
53601 +
53602 + /* For those who don't understand how mmap works, go read
53603 + * Documentation/nommu-mmap.txt.
53604 + * For those that do, you will know that the VM_MAYSHARE flag
53605 + * must be set in the vma->vm_flags structure on noMMU
53606 + * Other flags can be set, and are documented in
53607 + * include/linux/mm.h
53608 + */
53609 +
53610 + vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
53611 +
53612 + return 0;
53613 +}
53614 +
53615 +/*
53616 + * ubicom32fb_blank
53617 + */
53618 +static int ubicom32fb_blank(int blank_mode, struct fb_info *fbi)
53619 +{
53620 + return 0;
53621 +#if 0
53622 + struct ubicom32fb_drvdata *drvdata = to_ubicom32fb_drvdata(fbi);
53623 +
53624 + switch (blank_mode) {
53625 + case FB_BLANK_UNBLANK:
53626 + /* turn on panel */
53627 + ubicom32fb_out_be32(drvdata, REG_CTRL, drvdata->reg_ctrl_default);
53628 + break;
53629 +
53630 + case FB_BLANK_NORMAL:
53631 + case FB_BLANK_VSYNC_SUSPEND:
53632 + case FB_BLANK_HSYNC_SUSPEND:
53633 + case FB_BLANK_POWERDOWN:
53634 + /* turn off panel */
53635 + ubicom32fb_out_be32(drvdata, REG_CTRL, 0);
53636 + default:
53637 + break;
53638 +
53639 + }
53640 + return 0; /* success */
53641 +#endif
53642 +}
53643 +
53644 +static struct fb_ops ubicom32fb_ops =
53645 +{
53646 + .owner = THIS_MODULE,
53647 + .fb_pan_display = ubicom32fb_pan_display,
53648 + .fb_setcolreg = ubicom32fb_setcolreg,
53649 + .fb_blank = ubicom32fb_blank,
53650 + .fb_mmap = ubicom32fb_mmap,
53651 + .fb_ioctl = ubicom32fb_ioctl,
53652 + .fb_fillrect = cfb_fillrect,
53653 + .fb_copyarea = cfb_copyarea,
53654 + .fb_imageblit = cfb_imageblit,
53655 +};
53656 +
53657 +/*
53658 + * ubicom32fb_release
53659 + */
53660 +static int ubicom32fb_release(struct device *dev)
53661 +{
53662 + struct ubicom32fb_drvdata *ud = dev_get_drvdata(dev);
53663 +
53664 +#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
53665 + //ubicom32fb_blank(VESA_POWERDOWN, &drvdata->info);
53666 +#endif
53667 +
53668 + unregister_framebuffer(ud->fbinfo);
53669 +
53670 + if (ud->cmap_alloc) {
53671 + fb_dealloc_cmap(&ud->fbinfo->cmap);
53672 + }
53673 +
53674 + if (ud->fb) {
53675 + kfree(ud->fb);
53676 + }
53677 +
53678 + if (ud->rx_int != -1) {
53679 + free_irq(ud->rx_int, ud);
53680 + }
53681 +
53682 + /*
53683 + * Turn off the display
53684 + */
53685 + //ubicom32fb_out_be32(drvdata, REG_CTRL, 0);
53686 + //iounmap(drvdata->regs);
53687 +
53688 + framebuffer_release(ud->fbinfo);
53689 + dev_set_drvdata(dev, NULL);
53690 +
53691 + return 0;
53692 +}
53693 +
53694 +/*
53695 + * ubicom32fb_platform_probe
53696 + */
53697 +static int __init ubicom32fb_platform_probe(struct platform_device *pdev)
53698 +{
53699 + struct ubicom32fb_drvdata *ud;
53700 + struct resource *irq_resource_rx;
53701 + struct resource *irq_resource_tx;
53702 + struct resource *mem_resource;
53703 + struct fb_info *fbinfo;
53704 + int rc;
53705 + size_t fbsize;
53706 + struct device *dev = &pdev->dev;
53707 + int offset;
53708 + struct vdc_tio_vp_regs *regs;
53709 +
53710 + /*
53711 + * Get our resources
53712 + */
53713 + irq_resource_tx = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
53714 + if (!irq_resource_tx) {
53715 + dev_err(dev, "No tx IRQ resource assigned\n");
53716 + return -ENODEV;
53717 + }
53718 +
53719 + irq_resource_rx = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
53720 + if (!irq_resource_rx) {
53721 + dev_err(dev, "No rx IRQ resource assigned\n");
53722 + return -ENODEV;
53723 + }
53724 +
53725 + mem_resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
53726 + if (!mem_resource || !mem_resource->start) {
53727 + dev_err(dev, "No mem resource assigned\n");
53728 + return -ENODEV;
53729 + }
53730 + regs = (struct vdc_tio_vp_regs *)mem_resource->start;
53731 + if (regs->version != VDCTIO_VP_VERSION) {
53732 + dev_err(dev, "VDCTIO is not compatible with this driver tio:%x drv:%x\n",
53733 + regs->version, VDCTIO_VP_VERSION);
53734 + return -ENODEV;
53735 + }
53736 +
53737 + /*
53738 + * This is the minimum VRAM size
53739 + */
53740 + fbsize = regs->xres * regs->yres * (regs->bpp / 8);
53741 + if (!vram_size) {
53742 + vram_size = (fbsize + 1023) / 1024;
53743 + } else {
53744 + if (fbsize > (vram_size * 1024)) {
53745 + dev_err(dev, "Not enough VRAM for display, need >= %u bytes\n", fbsize);
53746 + return -ENOMEM; // should be ebadparam?
53747 + }
53748 + }
53749 +
53750 + /*
53751 + * Allocate the framebuffer instance + our private data
53752 + */
53753 + fbinfo = framebuffer_alloc(sizeof(struct ubicom32fb_drvdata), &pdev->dev);
53754 + if (!fbinfo) {
53755 + dev_err(dev, "Not enough memory to allocate instance.\n");
53756 + return -ENOMEM;
53757 + }
53758 +
53759 + /*
53760 + * Fill in our private data.
53761 + */
53762 + ud = (struct ubicom32fb_drvdata *)fbinfo->par;
53763 + ud->fbinfo = fbinfo;
53764 + ud->regs = (struct vdc_tio_vp_regs *)(mem_resource->start);
53765 + dev_set_drvdata(dev, ud);
53766 +
53767 + ud->vp_int = irq_resource_tx->start;
53768 +
53769 + /*
53770 + * If we were provided an rx_irq then we need to init the appropriate
53771 + * queues, locks, and functions.
53772 + */
53773 + ud->rx_int = -1;
53774 + if (irq_resource_rx->start != DEVTREE_IRQ_NONE) {
53775 + init_waitqueue_head(&ud->waitq);
53776 + mutex_init(&ud->lock);
53777 + if (request_irq(ud->rx_int, ubicom32fb_interrupt, IRQF_SHARED, "ubicom32fb_rx", ud)) {
53778 + dev_err(dev, "Couldn't request rx IRQ\n");
53779 + rc = -ENOMEM;
53780 + goto fail;
53781 + }
53782 + ud->rx_int = irq_resource_rx->start;
53783 + }
53784 +
53785 + /*
53786 + * Allocate and align the requested amount of VRAM
53787 + */
53788 + ud->total_vram_size = (vram_size * 1024) + regs->fb_align;
53789 + ud->fb = kmalloc(ud->total_vram_size, GFP_KERNEL);
53790 + if (ud->fb == NULL) {
53791 + dev_err(dev, "Couldn't allocate VRAM\n");
53792 + rc = -ENOMEM;
53793 + goto fail;
53794 + }
53795 +
53796 + offset = (u32_t)ud->fb & (regs->fb_align - 1);
53797 + if (!offset) {
53798 + ud->fb_aligned = ud->fb;
53799 + } else {
53800 + offset = regs->fb_align - offset;
53801 + ud->fb_aligned = ud->fb + offset;
53802 + }
53803 +
53804 + /*
53805 + * Clear the entire frame buffer
53806 + */
53807 + if (!init_value) {
53808 + memset(ud->fb_aligned, 0, vram_size * 1024);
53809 + } else {
53810 + unsigned short *p = ud->fb_aligned;
53811 + int i;
53812 + for (i = 0; i < ((vram_size * 1024) / sizeof(u16_t)); i++) {
53813 + *p++ = init_value;
53814 + }
53815 + }
53816 +
53817 + /*
53818 + * Fill in the fb_var_screeninfo structure
53819 + */
53820 + memset(&ubicom32fb_var, 0, sizeof(ubicom32fb_var));
53821 + ubicom32fb_var.bits_per_pixel = regs->bpp;
53822 + ubicom32fb_var.red.offset = regs->rshift;
53823 + ubicom32fb_var.green.offset = regs->gshift;
53824 + ubicom32fb_var.blue.offset = regs->bshift;
53825 + ubicom32fb_var.red.length = regs->rbits;
53826 + ubicom32fb_var.green.length = regs->gbits;
53827 + ubicom32fb_var.blue.length = regs->bbits;
53828 + ubicom32fb_var.activate = FB_ACTIVATE_NOW;
53829 +
53830 +#if 0
53831 + /*
53832 + * Turn on the display
53833 + */
53834 + ud->reg_ctrl_default = REG_CTRL_ENABLE;
53835 + if (regs->rotate_screen)
53836 + ud->reg_ctrl_default |= REG_CTRL_ROTATE;
53837 + ubicom32fb_out_be32(ud, REG_CTRL, ud->reg_ctrl_default);
53838 +#endif
53839 +
53840 + /*
53841 + * Fill in the fb_info structure
53842 + */
53843 + ud->fbinfo->device = dev;
53844 + ud->fbinfo->screen_base = (void *)ud->fb_aligned;
53845 + ud->fbinfo->fbops = &ubicom32fb_ops;
53846 + ud->fbinfo->fix = ubicom32fb_fix;
53847 + ud->fbinfo->fix.smem_start = (u32)ud->fb_aligned;
53848 + ud->fbinfo->fix.smem_len = vram_size * 1024;
53849 + ud->fbinfo->fix.line_length = regs->xres * (regs->bpp / 8);
53850 + ud->fbinfo->fix.mmio_start = (u32)regs;
53851 + ud->fbinfo->fix.mmio_len = sizeof(struct vdc_tio_vp_regs);
53852 +
53853 + /*
53854 + * We support panning in the y direction only
53855 + */
53856 + ud->fbinfo->fix.xpanstep = 0;
53857 + ud->fbinfo->fix.ypanstep = 1;
53858 +
53859 + ud->fbinfo->pseudo_palette = ud->pseudo_palette;
53860 + ud->fbinfo->flags = FBINFO_DEFAULT;
53861 + ud->fbinfo->var = ubicom32fb_var;
53862 + ud->fbinfo->var.xres = regs->xres;
53863 + ud->fbinfo->var.yres = regs->yres;
53864 +
53865 + /*
53866 + * We cannot pan in the X direction, so xres_virtual is regs->xres
53867 + * We can pan in the Y direction, so yres_virtual is vram_size / ud->fbinfo->fix.line_length
53868 + */
53869 + ud->fbinfo->var.xres_virtual = regs->xres;
53870 + ud->fbinfo->var.yres_virtual = (vram_size * 1024) / ud->fbinfo->fix.line_length;
53871 +
53872 + //ud->fbinfo->var.height = regs->height_mm;
53873 + //ud->fbinfo->var.width = regs->width_mm;
53874 +
53875 + /*
53876 + * Allocate a color map
53877 + */
53878 + rc = fb_alloc_cmap(&ud->fbinfo->cmap, PALETTE_ENTRIES_NO, 0);
53879 + if (rc) {
53880 + dev_err(dev, "Fail to allocate colormap (%d entries)\n",
53881 + PALETTE_ENTRIES_NO);
53882 + goto fail;
53883 + }
53884 + ud->cmap_alloc = true;
53885 +
53886 + /*
53887 + * Register new frame buffer
53888 + */
53889 + rc = register_framebuffer(ud->fbinfo);
53890 + if (rc) {
53891 + dev_err(dev, "Could not register frame buffer\n");
53892 + goto fail;
53893 + }
53894 +
53895 + /*
53896 + * Start up the VDC
53897 + */
53898 + ud->regs->next_frame = ud->fb;
53899 + ubicom32fb_send_command(ud, VDCTIO_COMMAND_START, 0);
53900 +
53901 + /*
53902 + * Tell the log we are here
53903 + */
53904 + dev_info(dev, "fbaddr=%p align=%p, size=%uKB screen(%ux%u) virt(%ux%u), regs=%p irqtx=%u irqrx=%u\n",
53905 + ud->fb, ud->fb_aligned, vram_size, ud->fbinfo->var.xres, ud->fbinfo->var.yres,
53906 + ud->fbinfo->var.xres_virtual, ud->fbinfo->var.yres_virtual, ud->regs,
53907 + irq_resource_tx->start, irq_resource_rx->start);
53908 +
53909 + /*
53910 + * Success
53911 + */
53912 + return 0;
53913 +
53914 +fail:
53915 + ubicom32fb_release(dev);
53916 + return rc;
53917 +}
53918 +
53919 +/*
53920 + * ubicom32fb_platform_remove
53921 + */
53922 +static int ubicom32fb_platform_remove(struct platform_device *pdev)
53923 +{
53924 + dev_info(&(pdev->dev), "Ubicom32 FB Driver Remove\n");
53925 + return ubicom32fb_release(&pdev->dev);
53926 +}
53927 +
53928 +static struct platform_driver ubicom32fb_platform_driver = {
53929 + .probe = ubicom32fb_platform_probe,
53930 + .remove = ubicom32fb_platform_remove,
53931 + .driver = {
53932 + .name = DRIVER_NAME,
53933 + .owner = THIS_MODULE,
53934 + },
53935 +};
53936 +
53937 +#ifndef MODULE
53938 +/*
53939 + * ubicom32fb_setup
53940 + * Process kernel boot options
53941 + */
53942 +static int __init ubicom32fb_setup(char *options)
53943 +{
53944 + char *this_opt;
53945 +
53946 + if (!options || !*options) {
53947 + return 0;
53948 + }
53949 +
53950 + while ((this_opt = strsep(&options, ",")) != NULL) {
53951 + if (!*this_opt) {
53952 + continue;
53953 + }
53954 +
53955 + if (!strncmp(this_opt, "init_value=", 10)) {
53956 + init_value = simple_strtoul(this_opt + 11, NULL, 0);
53957 + continue;
53958 + }
53959 +
53960 + if (!strncmp(this_opt, "vram_size=", 10)) {
53961 + vram_size = simple_strtoul(this_opt + 10, NULL, 0);
53962 + continue;
53963 + }
53964 + }
53965 + return 0;
53966 +}
53967 +#endif /* MODULE */
53968 +
53969 +/*
53970 + * ubicom32fb_init
53971 + */
53972 +static int __devinit ubicom32fb_init(void)
53973 +{
53974 +#ifndef MODULE
53975 + /*
53976 + * Get kernel boot options (in 'video=ubicom32fb:<options>')
53977 + */
53978 + char *option = NULL;
53979 +
53980 + if (fb_get_options(DRIVER_NAME, &option)) {
53981 + return -ENODEV;
53982 + }
53983 + ubicom32fb_setup(option);
53984 +#endif /* MODULE */
53985 +
53986 + return platform_driver_register(&ubicom32fb_platform_driver);
53987 +}
53988 +module_init(ubicom32fb_init);
53989 +
53990 +/*
53991 + * ubicom32fb_exit
53992 + */
53993 +static void __exit ubicom32fb_exit(void)
53994 +{
53995 + platform_driver_unregister(&ubicom32fb_platform_driver);
53996 +}
53997 +module_exit(ubicom32fb_exit);
53998 +
53999 +MODULE_LICENSE("GPL");
54000 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
54001 +MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
54002 diff -ruN linux-2.6.30.10/drivers/video/ubicom32plio80.c linux-2.6.30.10-ubi/drivers/video/ubicom32plio80.c
54003 --- linux-2.6.30.10/drivers/video/ubicom32plio80.c 1970-01-01 02:00:00.000000000 +0200
54004 +++ linux-2.6.30.10-ubi/drivers/video/ubicom32plio80.c 2009-12-11 11:45:21.000000000 +0200
54005 @@ -0,0 +1,780 @@
54006 +/*
54007 + * drivers/video/ubicom32plio80.c
54008 + * Ubicom32 80 bus PLIO buffer driver
54009 + *
54010 + * (C) Copyright 2009, Ubicom, Inc.
54011 + *
54012 + * This file is part of the Ubicom32 Linux Kernel Port.
54013 + *
54014 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
54015 + * it and/or modify it under the terms of the GNU General Public License
54016 + * as published by the Free Software Foundation, either version 2 of the
54017 + * License, or (at your option) any later version.
54018 + *
54019 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
54020 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
54021 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
54022 + * the GNU General Public License for more details.
54023 + *
54024 + * You should have received a copy of the GNU General Public License
54025 + * along with the Ubicom32 Linux Kernel Port. If not,
54026 + * see <http://www.gnu.org/licenses/>.
54027 + */
54028 +
54029 +/*
54030 + * This driver was based on skeletonfb.c, Skeleton for a frame buffer device by
54031 + * Geert Uytterhoeven.
54032 + */
54033 +
54034 +#include <linux/device.h>
54035 +#include <linux/module.h>
54036 +#include <linux/kernel.h>
54037 +#include <linux/version.h>
54038 +#include <linux/errno.h>
54039 +#include <linux/string.h>
54040 +#include <linux/mm.h>
54041 +#include <linux/fb.h>
54042 +#include <linux/init.h>
54043 +#include <linux/interrupt.h>
54044 +#include <linux/dma-mapping.h>
54045 +#include <linux/platform_device.h>
54046 +#include <linux/device.h>
54047 +#include <linux/uaccess.h>
54048 +#include <asm/plio.h>
54049 +
54050 +#define DRIVER_NAME "ubicom32plio80"
54051 +#define DRIVER_DESCRIPTION "Ubicom32 80 bus PLIO frame buffer driver"
54052 +
54053 +#define PALETTE_ENTRIES_NO 16
54054 +
54055 +/*
54056 + * Option variables
54057 + *
54058 + * vram_size: VRAM size in kilobytes, subject to alignment
54059 + */
54060 +static int vram_size = 0;
54061 +module_param(vram_size, int, 0);
54062 +MODULE_PARM_DESC(vram_size, "VRAM size, in kilobytes to allocate, should be at least the size of one screen, subject to alignment");
54063 +
54064 +static int xres = 240;
54065 +module_param(xres, int, 0);
54066 +MODULE_PARM_DESC(xres, "x (horizontal) resolution");
54067 +
54068 +static int yres = 320;
54069 +module_param(yres, int, 0);
54070 +MODULE_PARM_DESC(yres, "y (vertical) resolution");
54071 +
54072 +static int bgr = 0;
54073 +module_param(bgr, int, 0);
54074 +MODULE_PARM_DESC(bgr, "display is BGR (Blue is MSB)");
54075 +
54076 +#define BITS_PER_PIXEL 16
54077 +
54078 +/*
54079 + * Buffer alignment, must not be 0
54080 + */
54081 +#define UBICOM32PLIO80_ALIGNMENT 4
54082 +
54083 +/*
54084 + * PLIO FSM
54085 + * 16-bit data bus on port I
54086 + * CS on EXTCTL[6]
54087 + * WR on EXTCTL[4]
54088 + */
54089 +static const plio_fctl_t plio_fctl = {
54090 + .fctl0 = {
54091 + .ptif_port_mode = PLIO_PORT_MODE_DI,
54092 + .ptif_portd_cfg = 0,
54093 + .ptif_porti_cfg = 3,
54094 + .edif_ds = 6,
54095 + .edif_cmp_mode = 1,
54096 + .ecif_extclk_ena = 0, // enable clock output on PD7 table 2.65/p111 says extctl[0]?
54097 + .icif_clk_src_sel = PLIO_CLK_IO,
54098 + },
54099 + .fctl2 = {
54100 + .icif_eclk_div = 10,
54101 + .icif_iclk_div = 10,
54102 + },
54103 +
54104 + };
54105 +
54106 + static const plio_config_t plio_config = {
54107 + .pfsm = {
54108 + /*
54109 + * Table 12.63
54110 + */
54111 + .grpsel[0] = {1,1,1,1,1,1,1,1,1,1},
54112 +
54113 + /*
54114 + * Table 12.66 Counter load value
54115 + */
54116 + .cs_lut[0] = {0,0,0,0,0,0,0,0},
54117 +
54118 + /*
54119 + * Table 2.75 PLIO PFSM Configuration Registers
54120 + */
54121 + // 3 2 1 0
54122 + .extctl_o_lut[0] = {0x3f, 0x2f, 0x3f, 0x3f},
54123 + // 7 6 5 4
54124 + .extctl_o_lut[1] = {0x3f, 0x3f, 0x3f, 0x2f},
54125 + },
54126 + .edif = {
54127 + .odr_oe = 0xffff,
54128 + },
54129 + .ecif = {
54130 + .output_ena = (1 << 6) | (1 << 4),
54131 + },
54132 +};
54133 +
54134 +static const u32_t ubicom32plio80_plio_fsm[] = {
54135 + // 0-F
54136 + 0x00070007, 0x00070007,
54137 + 0x00070007, 0x00070007,
54138 + 0x00070007, 0x00070007,
54139 + 0x00070007, 0x00070007,
54140 +
54141 + 0x16260806, 0x16260806,
54142 + 0x16260806, 0x16260806,
54143 + 0x16260806, 0x16260806,
54144 + 0x16260806, 0x16260806,
54145 +
54146 + // 10 - 1f
54147 + 0x22061806, 0x22061806,
54148 + 0x22061806, 0x22061806,
54149 + 0x22061806, 0x22061806,
54150 + 0x22061806, 0x22061806,
54151 +
54152 + 0x22061806, 0x22061806,
54153 + 0x22061806, 0x22061806,
54154 + 0x22061806, 0x22061806,
54155 + 0x22061806, 0x22061806,
54156 +
54157 + // 20 - 2f
54158 + 0x00070806, 0x00070806,
54159 + 0x00070806, 0x00070806,
54160 + 0x00070806, 0x00070806,
54161 + 0x00070806, 0x00070806,
54162 +
54163 + 0x00070806, 0x00070806,
54164 + 0x00070806, 0x00070806,
54165 + 0x00070806, 0x00070806,
54166 + 0x00070806, 0x00070806,
54167 +};
54168 +
54169 +/*
54170 + * fb_fix_screeninfo defines the non-changeable properties of the VDC, depending on what mode it is in.
54171 + */
54172 +static struct fb_fix_screeninfo ubicom32plio80_fix = {
54173 + .id = "Ubicom32",
54174 + .type = FB_TYPE_PACKED_PIXELS,
54175 + .visual = FB_VISUAL_TRUECOLOR,
54176 + .accel = FB_ACCEL_UBICOM32_PLIO80,
54177 +};
54178 +
54179 +/*
54180 + * Filled in at probe time when we find out what the hardware supports
54181 + */
54182 +static struct fb_var_screeninfo ubicom32plio80_var;
54183 +
54184 +/*
54185 + * Private data structure
54186 + */
54187 +struct ubicom32plio80_drvdata {
54188 + struct fb_info *fbinfo;
54189 + bool cmap_alloc;
54190 +
54191 + /*
54192 + * The address of the framebuffer in memory
54193 + */
54194 + void *fb;
54195 + void *fb_aligned;
54196 +
54197 + /*
54198 + * Total size of vram including alignment allowance
54199 + */
54200 + u32 total_vram_size;
54201 +
54202 + /*
54203 + * Fake palette of 16 colors
54204 + */
54205 + u32 pseudo_palette[PALETTE_ENTRIES_NO];
54206 +
54207 + int irq_req;
54208 +
54209 + /*
54210 + * Current pointer and bytes left to transfer with the PLIO
54211 + */
54212 + void *xfer_ptr;
54213 + u32 bytes_to_xfer;
54214 + u32 busy;
54215 +};
54216 +
54217 +static struct platform_device *ubicom32plio80_platform_device;
54218 +
54219 +/*
54220 + * ubicom32plio80_isr
54221 + */
54222 +static int ubicom32plio80_isr(int irq, void *appdata)
54223 +{
54224 + struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)appdata;
54225 +
54226 + if (!ud->bytes_to_xfer) {
54227 + ubicom32_disable_interrupt(TX_FIFO_INT(PLIO_PORT));
54228 + PLIO_NBR->intmask.txfifo_wm = 0;
54229 + ud->busy = 0;
54230 + return IRQ_HANDLED;
54231 + }
54232 +
54233 + asm volatile (
54234 + ".rept 8 \n\t"
54235 + "move.4 (%[fifo]), (%[data])4++ \n\t"
54236 + ".endr \n\t"
54237 + : [data] "+a" (ud->xfer_ptr)
54238 + : [fifo] "a" (&PLIO_NBR->tx_lo)
54239 + );
54240 +
54241 + ud->bytes_to_xfer -= 32;
54242 +
54243 + return IRQ_HANDLED;
54244 +}
54245 +
54246 +/*
54247 + * ubicom32plio80_update
54248 + */
54249 +static void ubicom32plio80_update(struct ubicom32plio80_drvdata *ud, u32 *fb)
54250 +{
54251 + struct ubicom32_io_port *ri = (struct ubicom32_io_port *)RI;
54252 + struct ubicom32_io_port *rd = (struct ubicom32_io_port *)RD;
54253 +
54254 + ud->xfer_ptr = fb;
54255 + ud->bytes_to_xfer = (xres * yres * 2) - 64;
54256 + ud->busy = 1;
54257 +
54258 + ri->gpio_mask = 0;
54259 + rd->gpio_mask &= ~((1 << 4) | (1 << 2));
54260 +
54261 + *(u32 *)(&PLIO_NBR->intclr) = ~0;
54262 + PLIO_NBR->intmask.txfifo_wm = 1;
54263 + PLIO_NBR->fifo_wm.tx = 8;
54264 + ubicom32_enable_interrupt(TX_FIFO_INT(PLIO_PORT));
54265 +
54266 + asm volatile (
54267 + ".rept 16 \n\t"
54268 + "move.4 (%[fifo]), (%[data])4++ \n\t"
54269 + ".endr \n\t"
54270 + : [data] "+a" (ud->xfer_ptr)
54271 + : [fifo] "a" (&PLIO_NBR->tx_lo)
54272 + );
54273 +}
54274 +
54275 +/*
54276 + * ubicom32plio80_pan_display
54277 + * Pans the display to a given location. Supports only y direction panning.
54278 + */
54279 +static int ubicom32plio80_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
54280 +{
54281 + struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)fbi->par;
54282 + void *new_addr;
54283 +
54284 + /*
54285 + * Get the last y line that would be displayed. Since we don't support YWRAP,
54286 + * it must be less than our virtual y size.
54287 + */
54288 + u32 lasty = var->yoffset + var->yres;
54289 + if (lasty > fbi->var.yres_virtual) {
54290 + /*
54291 + * We would fall off the end of our frame buffer if we panned here.
54292 + */
54293 + return -EINVAL;
54294 + }
54295 +
54296 + if (var->xoffset) {
54297 + /*
54298 + * We don't support panning in the x direction
54299 + */
54300 + return -EINVAL;
54301 + }
54302 +
54303 + /*
54304 + * Everything looks sane, go ahead and pan
54305 + *
54306 + * We have to calculate a new address for the VDC to look at
54307 + */
54308 + new_addr = ud->fb_aligned + (var->yoffset * fbi->fix.line_length);
54309 +
54310 + return 0;
54311 +}
54312 +
54313 +/*
54314 + * ubicom32plio80_setcolreg
54315 + * Sets a color in our virtual palette
54316 + */
54317 +static int ubicom32plio80_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
54318 +{
54319 + u32 *palette = fbi->pseudo_palette;
54320 +
54321 + if (regno >= PALETTE_ENTRIES_NO) {
54322 + return -EINVAL;
54323 + }
54324 +
54325 + /*
54326 + * We only use 8 bits from each color
54327 + */
54328 + red >>= 8;
54329 + green >>= 8;
54330 + blue >>= 8;
54331 +
54332 + /*
54333 + * Convert any grayscale values
54334 + */
54335 + if (fbi->var.grayscale) {
54336 + u16 gray = red + green + blue;
54337 + gray += (gray >> 2) + (gray >> 3) - (gray >> 7);
54338 + gray >>= 2;
54339 + if (gray > 255) {
54340 + gray = 255;
54341 + }
54342 + red = gray;
54343 + blue = gray;
54344 + green = gray;
54345 + }
54346 +
54347 + palette[regno] = (red << fbi->var.red.offset) | (green << fbi->var.green.offset) |
54348 + (blue << fbi->var.blue.offset);
54349 +
54350 + return 0;
54351 +}
54352 +
54353 +/*
54354 + * ubicom32plio80_mmap
54355 + */
54356 +static int ubicom32plio80_mmap(struct fb_info *info, struct vm_area_struct *vma)
54357 +{
54358 + struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)info->par;
54359 +
54360 + vma->vm_start = (unsigned long)(ud->fb_aligned);
54361 +
54362 + vma->vm_end = vma->vm_start + info->fix.smem_len;
54363 +
54364 + /* For those who don't understand how mmap works, go read
54365 + * Documentation/nommu-mmap.txt.
54366 + * For those that do, you will know that the VM_MAYSHARE flag
54367 + * must be set in the vma->vm_flags structure on noMMU
54368 + * Other flags can be set, and are documented in
54369 + * include/linux/mm.h
54370 + */
54371 +
54372 + vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
54373 +
54374 + return 0;
54375 +}
54376 +
54377 +/*
54378 + * ubicom32plio80_check_var
54379 + * Check the var, tweak it but don't change operational parameters.
54380 + */
54381 +static int ubicom32plio80_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
54382 +{
54383 + struct ubicom32plio80_drvdata *ud = (struct ubicom32plio80_drvdata *)info->par;
54384 + u32 line_size = var->xres * (BITS_PER_PIXEL / 8);
54385 +
54386 + /*
54387 + * See if we can handle this bpp
54388 + */
54389 + if (var->bits_per_pixel > BITS_PER_PIXEL) {
54390 + return -EINVAL;
54391 + }
54392 + var->bits_per_pixel = BITS_PER_PIXEL;
54393 +
54394 + /*
54395 + * See if we have enough memory to handle this resolution
54396 + */
54397 + if ((line_size * var->yres * BITS_PER_PIXEL / 8) > ud->total_vram_size) {
54398 + return -EINVAL;
54399 + }
54400 +
54401 + var->xres_virtual = var->xres;
54402 + var->yres_virtual = ud->total_vram_size / line_size;
54403 +
54404 + var->red.length = 5;
54405 + var->green.length = 6;
54406 + var->green.offset = 5;
54407 + var->blue.length = 5;
54408 + var->transp.offset = var->transp.length = 0;
54409 +
54410 + if (bgr) {
54411 + var->red.offset = 0;
54412 + var->blue.offset = 11;
54413 + } else {
54414 + var->red.offset = 11;
54415 + var->blue.offset = 0;
54416 + }
54417 +
54418 + var->nonstd = 0;
54419 + var->height = -1;
54420 + var->width = -1;
54421 + var->vmode = FB_VMODE_NONINTERLACED;
54422 + var->sync = 0;
54423 +
54424 + return 0;
54425 +}
54426 +
54427 +/*
54428 + * ubicom32plio80_set_par
54429 + * Set the video mode according to info->var
54430 + */
54431 +static int ubicom32plio80_set_par(struct fb_info *info)
54432 +{
54433 + /*
54434 + * Anything changed?
54435 + */
54436 + if ((xres == info->var.xres) && (yres == info->var.yres)) {
54437 + return 0;
54438 + }
54439 +
54440 + /*
54441 + * Implement changes
54442 + */
54443 + xres = info->var.xres;
54444 + yres = info->var.yres;
54445 + info->fix.visual = FB_VISUAL_TRUECOLOR;
54446 + info->fix.xpanstep = 0;
54447 + info->fix.ypanstep = 1;
54448 + info->fix.line_length = xres * (BITS_PER_PIXEL / 8);
54449 +
54450 + return 0;
54451 +}
54452 +
54453 +/*
54454 + * ubicom32plio80_ops
54455 + * List of supported operations
54456 + */
54457 +static struct fb_ops ubicom32plio80_ops =
54458 +{
54459 + .owner = THIS_MODULE,
54460 + .fb_pan_display = ubicom32plio80_pan_display,
54461 + .fb_setcolreg = ubicom32plio80_setcolreg,
54462 + .fb_mmap = ubicom32plio80_mmap,
54463 + .fb_check_var = ubicom32plio80_check_var,
54464 + .fb_set_par = ubicom32plio80_set_par,
54465 + .fb_fillrect = cfb_fillrect,
54466 + .fb_copyarea = cfb_copyarea,
54467 + .fb_imageblit = cfb_imageblit,
54468 +};
54469 +
54470 +/*
54471 + * ubicom32plio80_release
54472 + */
54473 +static int ubicom32plio80_release(struct device *dev)
54474 +{
54475 + struct ubicom32plio80_drvdata *ud = dev_get_drvdata(dev);
54476 +
54477 + unregister_framebuffer(ud->fbinfo);
54478 +
54479 + if (ud->irq_req) {
54480 + free_irq(TX_FIFO_INT(PLIO_PORT), ud);
54481 + }
54482 + if (ud->cmap_alloc) {
54483 + fb_dealloc_cmap(&ud->fbinfo->cmap);
54484 + }
54485 +
54486 + if (ud->fb) {
54487 + kfree(ud->fb);
54488 + }
54489 +
54490 + framebuffer_release(ud->fbinfo);
54491 + dev_set_drvdata(dev, NULL);
54492 +
54493 + return 0;
54494 +}
54495 +
54496 +/*
54497 + * ubicom32plio80_platform_probe
54498 + */
54499 +static int __init ubicom32plio80_platform_probe(struct platform_device *pdev)
54500 +{
54501 + struct ubicom32plio80_drvdata *ud;
54502 + struct fb_info *fbinfo;
54503 + int rc;
54504 + size_t fbsize;
54505 + struct device *dev = &pdev->dev;
54506 + int offset;
54507 +
54508 + /*
54509 + * This is the minimum VRAM size
54510 + */
54511 + fbsize = xres * yres * 2;
54512 + if (!vram_size) {
54513 + vram_size = (fbsize + 1023) / 1024;
54514 + } else {
54515 + if (fbsize > (vram_size * 1024)) {
54516 + dev_err(dev, "Not enough VRAM for display, need >= %u bytes\n", fbsize);
54517 + return -ENOMEM; // should be ebadparam?
54518 + }
54519 + }
54520 +
54521 + /*
54522 + * Allocate the framebuffer instance + our private data
54523 + */
54524 + fbinfo = framebuffer_alloc(sizeof(struct ubicom32plio80_drvdata), &pdev->dev);
54525 + if (!fbinfo) {
54526 + dev_err(dev, "Not enough memory to allocate instance.\n");
54527 + return -ENOMEM;
54528 + }
54529 +
54530 + /*
54531 + * Fill in our private data.
54532 + */
54533 + ud = (struct ubicom32plio80_drvdata *)fbinfo->par;
54534 + ud->fbinfo = fbinfo;
54535 + dev_set_drvdata(dev, ud);
54536 +
54537 + /*
54538 + * Allocate and align the requested amount of VRAM
54539 + */
54540 + ud->total_vram_size = (vram_size * 1024) + UBICOM32PLIO80_ALIGNMENT;
54541 + ud->fb = kmalloc(ud->total_vram_size, GFP_KERNEL);
54542 + if (ud->fb == NULL) {
54543 + dev_err(dev, "Couldn't allocate VRAM\n");
54544 + rc = -ENOMEM;
54545 + goto fail;
54546 + }
54547 +
54548 + offset = (u32_t)ud->fb & (UBICOM32PLIO80_ALIGNMENT - 1);
54549 + if (!offset) {
54550 + ud->fb_aligned = ud->fb;
54551 + } else {
54552 + offset = UBICOM32PLIO80_ALIGNMENT - offset;
54553 + ud->fb_aligned = ud->fb + offset;
54554 + }
54555 +
54556 + /*
54557 + * Clear the entire frame buffer
54558 + */
54559 + memset(ud->fb_aligned, 0, vram_size * 1024);
54560 +
54561 + /*
54562 + * Fill in the fb_var_screeninfo structure
54563 + */
54564 + memset(&ubicom32plio80_var, 0, sizeof(ubicom32plio80_var));
54565 + ubicom32plio80_var.bits_per_pixel = BITS_PER_PIXEL;
54566 + ubicom32plio80_var.red.length = 5;
54567 + ubicom32plio80_var.green.length = 6;
54568 + ubicom32plio80_var.green.offset = 5;
54569 + ubicom32plio80_var.blue.length = 5;
54570 + ubicom32plio80_var.activate = FB_ACTIVATE_NOW;
54571 +
54572 + if (bgr) {
54573 + ubicom32plio80_var.red.offset = 0;
54574 + ubicom32plio80_var.blue.offset = 11;
54575 + } else {
54576 + ubicom32plio80_var.red.offset = 11;
54577 + ubicom32plio80_var.blue.offset = 0;
54578 + }
54579 +
54580 + /*
54581 + * Fill in the fb_info structure
54582 + */
54583 + ud->fbinfo->device = dev;
54584 + ud->fbinfo->screen_base = (void *)ud->fb_aligned;
54585 + ud->fbinfo->fbops = &ubicom32plio80_ops;
54586 + ud->fbinfo->fix = ubicom32plio80_fix;
54587 + ud->fbinfo->fix.smem_start = (u32)ud->fb_aligned;
54588 + ud->fbinfo->fix.smem_len = vram_size * 1024;
54589 + ud->fbinfo->fix.line_length = xres * 2;
54590 + ud->fbinfo->fix.mmio_start = (u32)ud;
54591 + ud->fbinfo->fix.mmio_len = sizeof(struct ubicom32plio80_drvdata);
54592 +
54593 + /*
54594 + * We support panning in the y direction only
54595 + */
54596 + ud->fbinfo->fix.xpanstep = 0;
54597 + ud->fbinfo->fix.ypanstep = 1;
54598 +
54599 + ud->fbinfo->pseudo_palette = ud->pseudo_palette;
54600 + ud->fbinfo->flags = FBINFO_DEFAULT;
54601 + ud->fbinfo->var = ubicom32plio80_var;
54602 + ud->fbinfo->var.xres = xres;
54603 + ud->fbinfo->var.yres = yres;
54604 +
54605 + /*
54606 + * We cannot pan in the X direction, so xres_virtual is xres
54607 + * We can pan in the Y direction, so yres_virtual is vram_size / ud->fbinfo->fix.line_length
54608 + */
54609 + ud->fbinfo->var.xres_virtual = xres;
54610 + ud->fbinfo->var.yres_virtual = (vram_size * 1024) / ud->fbinfo->fix.line_length;
54611 +
54612 + /*
54613 + * Allocate a color map
54614 + */
54615 + rc = fb_alloc_cmap(&ud->fbinfo->cmap, PALETTE_ENTRIES_NO, 0);
54616 + if (rc) {
54617 + dev_err(dev, "Fail to allocate colormap (%d entries)\n",
54618 + PALETTE_ENTRIES_NO);
54619 + goto fail;
54620 + }
54621 + ud->cmap_alloc = true;
54622 +
54623 + /*
54624 + * Register new frame buffer
54625 + */
54626 + rc = register_framebuffer(ud->fbinfo);
54627 + if (rc) {
54628 + dev_err(dev, "Could not register frame buffer\n");
54629 + goto fail;
54630 + }
54631 +
54632 + /*
54633 + * request the PLIO IRQ
54634 + */
54635 + rc = request_irq(TX_FIFO_INT(PLIO_PORT), ubicom32plio80_isr, IRQF_DISABLED, "ubicom32plio80", ud);
54636 + if (rc) {
54637 + dev_err(dev, "Could not request IRQ\n");
54638 + goto fail;
54639 + }
54640 + ud->irq_req = 1;
54641 +
54642 + /*
54643 + * Clear any garbage out of the TX FIFOs (idif_txfifo_flush)
54644 + *
54645 + * cast through ubicom32_io_port to make sure the compiler does a word write
54646 + */
54647 + ((struct ubicom32_io_port *)PLIO_NBR)->int_set = (1 << 18);
54648 +
54649 + /*
54650 + * Start up the state machine
54651 + */
54652 + plio_init(&plio_fctl, &plio_config, (plio_sram_t *)ubicom32plio80_plio_fsm, sizeof(ubicom32plio80_plio_fsm));
54653 + PLIO_NBR->fctl0.pfsm_cmd = 0;
54654 +
54655 + ubicom32plio80_update(ud, ud->fb_aligned);
54656 +
54657 + /*
54658 + * Tell the log we are here
54659 + */
54660 + dev_info(dev, "fbaddr=%p align=%p, size=%uKB screen(%ux%u) virt(%ux%u)\n",
54661 + ud->fb, ud->fb_aligned, vram_size, ud->fbinfo->var.xres, ud->fbinfo->var.yres,
54662 + ud->fbinfo->var.xres_virtual, ud->fbinfo->var.yres_virtual);
54663 +
54664 + /*
54665 + * Success
54666 + */
54667 + return 0;
54668 +
54669 +fail:
54670 + ubicom32plio80_release(dev);
54671 + return rc;
54672 +}
54673 +
54674 +/*
54675 + * ubicom32plio80_platform_remove
54676 + */
54677 +static int ubicom32plio80_platform_remove(struct platform_device *pdev)
54678 +{
54679 + dev_info(&(pdev->dev), "Ubicom32 FB Driver Remove\n");
54680 + return ubicom32plio80_release(&pdev->dev);
54681 +}
54682 +
54683 +static struct platform_driver ubicom32plio80_platform_driver = {
54684 + .probe = ubicom32plio80_platform_probe,
54685 + .remove = ubicom32plio80_platform_remove,
54686 + .driver = {
54687 + .name = DRIVER_NAME,
54688 + .owner = THIS_MODULE,
54689 + },
54690 +};
54691 +
54692 +#ifndef MODULE
54693 +/*
54694 + * ubicom32plio80_setup
54695 + * Process kernel boot options
54696 + */
54697 +static int __init ubicom32plio80_setup(char *options)
54698 +{
54699 + char *this_opt;
54700 +
54701 + if (!options || !*options) {
54702 + return 0;
54703 + }
54704 +
54705 + while ((this_opt = strsep(&options, ",")) != NULL) {
54706 + if (!*this_opt) {
54707 + continue;
54708 + }
54709 +
54710 + if (!strncmp(this_opt, "vram_size=", 10)) {
54711 + vram_size = simple_strtoul(this_opt + 10, NULL, 0);
54712 + continue;
54713 + }
54714 +
54715 + if (!strncmp(this_opt, "bgr=", 4)) {
54716 + bgr = simple_strtoul(this_opt + 4, NULL, 0);
54717 + continue;
54718 + }
54719 +
54720 + if (!strncmp(this_opt, "xres=", 5)) {
54721 + xres = simple_strtoul(this_opt + 5, NULL, 0);
54722 + continue;
54723 + }
54724 +
54725 + if (!strncmp(this_opt, "yres=", 5)) {
54726 + yres = simple_strtoul(this_opt + 5, NULL, 0);
54727 + continue;
54728 + }
54729 + }
54730 + return 0;
54731 +}
54732 +#endif /* MODULE */
54733 +
54734 +/*
54735 + * ubicom32plio80_init
54736 + */
54737 +static int __devinit ubicom32plio80_init(void)
54738 +{
54739 + int ret;
54740 +
54741 +#ifndef MODULE
54742 + /*
54743 + * Get kernel boot options (in 'video=ubicom32plio80:<options>')
54744 + */
54745 + char *option = NULL;
54746 +
54747 + if (fb_get_options(DRIVER_NAME, &option)) {
54748 + return -ENODEV;
54749 + }
54750 + ubicom32plio80_setup(option);
54751 +#endif /* MODULE */
54752 +
54753 + ret = platform_driver_register(&ubicom32plio80_platform_driver);
54754 +
54755 + if (!ret) {
54756 + ubicom32plio80_platform_device = platform_device_alloc(DRIVER_NAME, 0);
54757 +
54758 + if (ubicom32plio80_platform_device)
54759 + ret = platform_device_add(ubicom32plio80_platform_device);
54760 + else
54761 + ret = -ENOMEM;
54762 +
54763 + if (ret) {
54764 + platform_device_put(ubicom32plio80_platform_device);
54765 + platform_driver_unregister(&ubicom32plio80_platform_driver);
54766 + }
54767 + }
54768 +
54769 + return ret;
54770 +}
54771 +module_init(ubicom32plio80_init);
54772 +
54773 +/*
54774 + * ubicom32plio80_exit
54775 + */
54776 +static void __exit ubicom32plio80_exit(void)
54777 +{
54778 + platform_device_unregister(ubicom32plio80_platform_device);
54779 + platform_driver_unregister(&ubicom32plio80_platform_driver);
54780 +}
54781 +module_exit(ubicom32plio80_exit);
54782 +
54783 +MODULE_LICENSE("GPL");
54784 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
54785 +MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
54786 diff -ruN linux-2.6.30.10/drivers/video/ubicom32vfb.c linux-2.6.30.10-ubi/drivers/video/ubicom32vfb.c
54787 --- linux-2.6.30.10/drivers/video/ubicom32vfb.c 1970-01-01 02:00:00.000000000 +0200
54788 +++ linux-2.6.30.10-ubi/drivers/video/ubicom32vfb.c 2009-12-11 11:45:21.000000000 +0200
54789 @@ -0,0 +1,603 @@
54790 +/*
54791 + * drivers/video/ubicom32vfb.c
54792 + * Ubicom32 virtual frame buffer driver
54793 + *
54794 + * (C) Copyright 2009, Ubicom, Inc.
54795 + *
54796 + * This file is part of the Ubicom32 Linux Kernel Port.
54797 + *
54798 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
54799 + * it and/or modify it under the terms of the GNU General Public License
54800 + * as published by the Free Software Foundation, either version 2 of the
54801 + * License, or (at your option) any later version.
54802 + *
54803 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
54804 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
54805 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
54806 + * the GNU General Public License for more details.
54807 + *
54808 + * You should have received a copy of the GNU General Public License
54809 + * along with the Ubicom32 Linux Kernel Port. If not,
54810 + * see <http://www.gnu.org/licenses/>.
54811 + */
54812 +
54813 +/*
54814 + * This driver was based on skeletonfb.c, Skeleton for a frame buffer device by
54815 + * Geert Uytterhoeven.
54816 + */
54817 +
54818 +#include <linux/device.h>
54819 +#include <linux/module.h>
54820 +#include <linux/kernel.h>
54821 +#include <linux/version.h>
54822 +#include <linux/errno.h>
54823 +#include <linux/string.h>
54824 +#include <linux/mm.h>
54825 +#include <linux/fb.h>
54826 +#include <linux/init.h>
54827 +#include <linux/dma-mapping.h>
54828 +#include <linux/platform_device.h>
54829 +#include <linux/device.h>
54830 +#include <linux/uaccess.h>
54831 +
54832 +#define DRIVER_NAME "ubicom32vfb"
54833 +#define DRIVER_DESCRIPTION "Ubicom32 virtual frame buffer driver"
54834 +
54835 +#define PALETTE_ENTRIES_NO 16
54836 +
54837 +/*
54838 + * Option variables
54839 + *
54840 + * vram_size: VRAM size in kilobytes, subject to alignment
54841 + */
54842 +static int vram_size = 0;
54843 +module_param(vram_size, int, 0);
54844 +MODULE_PARM_DESC(vram_size, "VRAM size, in kilobytes to allocate, should be at least the size of one screen, subject to alignment");
54845 +
54846 +static int xres = 320;
54847 +module_param(xres, int, 0);
54848 +MODULE_PARM_DESC(xres, "x (horizontal) resolution");
54849 +
54850 +static int yres = 240;
54851 +module_param(yres, int, 0);
54852 +MODULE_PARM_DESC(yres, "y (vertical) resolution");
54853 +
54854 +static int bgr = 0;
54855 +module_param(bgr, int, 0);
54856 +MODULE_PARM_DESC(bgr, "display is BGR (Blue is MSB)");
54857 +
54858 +#define BITS_PER_PIXEL 16
54859 +
54860 +/*
54861 + * Buffer alignment, must not be 0
54862 + */
54863 +#define UBICOM32VFB_ALIGNMENT 4
54864 +
54865 +/*
54866 + * fb_fix_screeninfo defines the non-changeable properties of the VDC, depending on what mode it is in.
54867 + */
54868 +static struct fb_fix_screeninfo ubicom32vfb_fix = {
54869 + .id = "Ubicom32",
54870 + .type = FB_TYPE_PACKED_PIXELS,
54871 + .visual = FB_VISUAL_TRUECOLOR,
54872 + .accel = FB_ACCEL_UBICOM32_VFB,
54873 +};
54874 +
54875 +/*
54876 + * Filled in at probe time when we find out what the hardware supports
54877 + */
54878 +static struct fb_var_screeninfo ubicom32vfb_var;
54879 +
54880 +/*
54881 + * Private data structure
54882 + */
54883 +struct ubicom32vfb_drvdata {
54884 + struct fb_info *fbinfo;
54885 + bool cmap_alloc;
54886 +
54887 + /*
54888 + * The address of the framebuffer in memory
54889 + */
54890 + void *fb;
54891 + void *fb_aligned;
54892 +
54893 + /*
54894 + * Total size of vram including alignment allowance
54895 + */
54896 + u32 total_vram_size;
54897 +
54898 + /*
54899 + * Fake palette of 16 colors
54900 + */
54901 + u32 pseudo_palette[PALETTE_ENTRIES_NO];
54902 +};
54903 +
54904 +static struct platform_device *ubicom32vfb_platform_device;
54905 +
54906 +/*
54907 + * ubicom32vfb_pan_display
54908 + * Pans the display to a given location. Supports only y direction panning.
54909 + */
54910 +static int ubicom32vfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *fbi)
54911 +{
54912 + struct ubicom32vfb_drvdata *ud = (struct ubicom32vfb_drvdata *)fbi->par;
54913 + void *new_addr;
54914 +
54915 + /*
54916 + * Get the last y line that would be displayed. Since we don't support YWRAP,
54917 + * it must be less than our virtual y size.
54918 + */
54919 + u32 lasty = var->yoffset + var->yres;
54920 + if (lasty > fbi->var.yres_virtual) {
54921 + /*
54922 + * We would fall off the end of our frame buffer if we panned here.
54923 + */
54924 + return -EINVAL;
54925 + }
54926 +
54927 + if (var->xoffset) {
54928 + /*
54929 + * We don't support panning in the x direction
54930 + */
54931 + return -EINVAL;
54932 + }
54933 +
54934 + /*
54935 + * Everything looks sane, go ahead and pan
54936 + *
54937 + * We have to calculate a new address for the VDC to look at
54938 + */
54939 + new_addr = ud->fb_aligned + (var->yoffset * fbi->fix.line_length);
54940 +
54941 + return 0;
54942 +}
54943 +
54944 +/*
54945 + * ubicom32vfb_setcolreg
54946 + * Sets a color in our virtual palette
54947 + */
54948 +static int ubicom32vfb_setcolreg(unsigned regno, unsigned red, unsigned green, unsigned blue, unsigned transp, struct fb_info *fbi)
54949 +{
54950 + u32 *palette = fbi->pseudo_palette;
54951 +
54952 + if (regno >= PALETTE_ENTRIES_NO) {
54953 + return -EINVAL;
54954 + }
54955 +
54956 + /*
54957 + * We only use 8 bits from each color
54958 + */
54959 + red >>= 8;
54960 + green >>= 8;
54961 + blue >>= 8;
54962 +
54963 + /*
54964 + * Convert any grayscale values
54965 + */
54966 + if (fbi->var.grayscale) {
54967 + u16 gray = red + green + blue;
54968 + gray += (gray >> 2) + (gray >> 3) - (gray >> 7);
54969 + gray >>= 2;
54970 + if (gray > 255) {
54971 + gray = 255;
54972 + }
54973 + red = gray;
54974 + blue = gray;
54975 + green = gray;
54976 + }
54977 +
54978 + palette[regno] = (red << fbi->var.red.offset) | (green << fbi->var.green.offset) |
54979 + (blue << fbi->var.blue.offset);
54980 +
54981 + return 0;
54982 +}
54983 +
54984 +/*
54985 + * ubicom32vfb_mmap
54986 + */
54987 +static int ubicom32vfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
54988 +{
54989 + struct ubicom32vfb_drvdata *ud = (struct ubicom32vfb_drvdata *)info->par;
54990 +
54991 + vma->vm_start = (unsigned long)(ud->fb_aligned);
54992 +
54993 + vma->vm_end = vma->vm_start + info->fix.smem_len;
54994 +
54995 + /* For those who don't understand how mmap works, go read
54996 + * Documentation/nommu-mmap.txt.
54997 + * For those that do, you will know that the VM_MAYSHARE flag
54998 + * must be set in the vma->vm_flags structure on noMMU
54999 + * Other flags can be set, and are documented in
55000 + * include/linux/mm.h
55001 + */
55002 +
55003 + vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
55004 +
55005 + return 0;
55006 +}
55007 +
55008 +/*
55009 + * ubicom32vfb_check_var
55010 + * Check the var, tweak it but don't change operational parameters.
55011 + */
55012 +static int ubicom32vfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
55013 +{
55014 + struct ubicom32vfb_drvdata *ud = (struct ubicom32vfb_drvdata *)info->par;
55015 + u32 line_size = var->xres * (BITS_PER_PIXEL / 8);
55016 +
55017 + /*
55018 + * See if we can handle this bpp
55019 + */
55020 + if (var->bits_per_pixel > BITS_PER_PIXEL) {
55021 + return -EINVAL;
55022 + }
55023 + var->bits_per_pixel = BITS_PER_PIXEL;
55024 +
55025 + /*
55026 + * See if we have enough memory to handle this resolution
55027 + */
55028 + if ((line_size * var->yres * BITS_PER_PIXEL / 8) > ud->total_vram_size) {
55029 + return -EINVAL;
55030 + }
55031 +
55032 + var->xres_virtual = var->xres;
55033 + var->yres_virtual = ud->total_vram_size / line_size;
55034 +
55035 + var->red.length = 5;
55036 + var->green.length = 6;
55037 + var->green.offset = 5;
55038 + var->blue.length = 5;
55039 + var->transp.offset = var->transp.length = 0;
55040 +
55041 + if (bgr) {
55042 + var->red.offset = 0;
55043 + var->blue.offset = 11;
55044 + } else {
55045 + var->red.offset = 11;
55046 + var->blue.offset = 0;
55047 + }
55048 +
55049 + var->nonstd = 0;
55050 + var->height = -1;
55051 + var->width = -1;
55052 + var->vmode = FB_VMODE_NONINTERLACED;
55053 + var->sync = 0;
55054 +
55055 + return 0;
55056 +}
55057 +
55058 +/*
55059 + * ubicom32vfb_set_par
55060 + * Set the video mode according to info->var
55061 + */
55062 +static int ubicom32vfb_set_par(struct fb_info *info)
55063 +{
55064 + /*
55065 + * Anything changed?
55066 + */
55067 + if ((xres == info->var.xres) && (yres == info->var.yres)) {
55068 + return 0;
55069 + }
55070 +
55071 + /*
55072 + * Implement changes
55073 + */
55074 + xres = info->var.xres;
55075 + yres = info->var.yres;
55076 + info->fix.visual = FB_VISUAL_TRUECOLOR;
55077 + info->fix.xpanstep = 0;
55078 + info->fix.ypanstep = 1;
55079 + info->fix.line_length = xres * (BITS_PER_PIXEL / 8);
55080 +
55081 + return 0;
55082 +}
55083 +
55084 +/*
55085 + * ubicom32vfb_ops
55086 + * List of supported operations
55087 + */
55088 +static struct fb_ops ubicom32vfb_ops =
55089 +{
55090 + .owner = THIS_MODULE,
55091 + .fb_pan_display = ubicom32vfb_pan_display,
55092 + .fb_setcolreg = ubicom32vfb_setcolreg,
55093 + .fb_mmap = ubicom32vfb_mmap,
55094 + .fb_check_var = ubicom32vfb_check_var,
55095 + .fb_set_par = ubicom32vfb_set_par,
55096 + .fb_fillrect = cfb_fillrect,
55097 + .fb_copyarea = cfb_copyarea,
55098 + .fb_imageblit = cfb_imageblit,
55099 +};
55100 +
55101 +/*
55102 + * ubicom32vfb_release
55103 + */
55104 +static int ubicom32vfb_release(struct device *dev)
55105 +{
55106 + struct ubicom32vfb_drvdata *ud = dev_get_drvdata(dev);
55107 +
55108 + unregister_framebuffer(ud->fbinfo);
55109 +
55110 + if (ud->cmap_alloc) {
55111 + fb_dealloc_cmap(&ud->fbinfo->cmap);
55112 + }
55113 +
55114 + if (ud->fb) {
55115 + kfree(ud->fb);
55116 + }
55117 +
55118 + framebuffer_release(ud->fbinfo);
55119 + dev_set_drvdata(dev, NULL);
55120 +
55121 + return 0;
55122 +}
55123 +
55124 +/*
55125 + * ubicom32vfb_platform_probe
55126 + */
55127 +static int __init ubicom32vfb_platform_probe(struct platform_device *pdev)
55128 +{
55129 + struct ubicom32vfb_drvdata *ud;
55130 + struct fb_info *fbinfo;
55131 + int rc;
55132 + size_t fbsize;
55133 + struct device *dev = &pdev->dev;
55134 + int offset;
55135 +
55136 + /*
55137 + * This is the minimum VRAM size
55138 + */
55139 + fbsize = xres * yres * 2;
55140 + if (!vram_size) {
55141 + vram_size = (fbsize + 1023) / 1024;
55142 + } else {
55143 + if (fbsize > (vram_size * 1024)) {
55144 + dev_err(dev, "Not enough VRAM for display, need >= %u bytes\n", fbsize);
55145 + return -ENOMEM; // should be ebadparam?
55146 + }
55147 + }
55148 +
55149 + /*
55150 + * Allocate the framebuffer instance + our private data
55151 + */
55152 + fbinfo = framebuffer_alloc(sizeof(struct ubicom32vfb_drvdata), &pdev->dev);
55153 + if (!fbinfo) {
55154 + dev_err(dev, "Not enough memory to allocate instance.\n");
55155 + return -ENOMEM;
55156 + }
55157 +
55158 + /*
55159 + * Fill in our private data.
55160 + */
55161 + ud = (struct ubicom32vfb_drvdata *)fbinfo->par;
55162 + ud->fbinfo = fbinfo;
55163 + dev_set_drvdata(dev, ud);
55164 +
55165 + /*
55166 + * Allocate and align the requested amount of VRAM
55167 + */
55168 + ud->total_vram_size = (vram_size * 1024) + UBICOM32VFB_ALIGNMENT;
55169 + ud->fb = kmalloc(ud->total_vram_size, GFP_KERNEL);
55170 + if (ud->fb == NULL) {
55171 + dev_err(dev, "Couldn't allocate VRAM\n");
55172 + rc = -ENOMEM;
55173 + goto fail;
55174 + }
55175 +
55176 + offset = (u32_t)ud->fb & (UBICOM32VFB_ALIGNMENT - 1);
55177 + if (!offset) {
55178 + ud->fb_aligned = ud->fb;
55179 + } else {
55180 + offset = UBICOM32VFB_ALIGNMENT - offset;
55181 + ud->fb_aligned = ud->fb + offset;
55182 + }
55183 +
55184 + /*
55185 + * Clear the entire frame buffer
55186 + */
55187 + memset(ud->fb_aligned, 0, vram_size * 1024);
55188 +
55189 + /*
55190 + * Fill in the fb_var_screeninfo structure
55191 + */
55192 + memset(&ubicom32vfb_var, 0, sizeof(ubicom32vfb_var));
55193 + ubicom32vfb_var.bits_per_pixel = BITS_PER_PIXEL;
55194 + ubicom32vfb_var.red.length = 5;
55195 + ubicom32vfb_var.green.length = 6;
55196 + ubicom32vfb_var.green.offset = 5;
55197 + ubicom32vfb_var.blue.length = 5;
55198 + ubicom32vfb_var.activate = FB_ACTIVATE_NOW;
55199 +
55200 + if (bgr) {
55201 + ubicom32vfb_var.red.offset = 0;
55202 + ubicom32vfb_var.blue.offset = 11;
55203 + } else {
55204 + ubicom32vfb_var.red.offset = 11;
55205 + ubicom32vfb_var.blue.offset = 0;
55206 + }
55207 +
55208 + /*
55209 + * Fill in the fb_info structure
55210 + */
55211 + ud->fbinfo->device = dev;
55212 + ud->fbinfo->screen_base = (void *)ud->fb_aligned;
55213 + ud->fbinfo->fbops = &ubicom32vfb_ops;
55214 + ud->fbinfo->fix = ubicom32vfb_fix;
55215 + ud->fbinfo->fix.smem_start = (u32)ud->fb_aligned;
55216 + ud->fbinfo->fix.smem_len = vram_size * 1024;
55217 + ud->fbinfo->fix.line_length = xres * 2;
55218 + ud->fbinfo->fix.mmio_start = (u32)ud;
55219 + ud->fbinfo->fix.mmio_len = sizeof(struct ubicom32vfb_drvdata);
55220 +
55221 + /*
55222 + * We support panning in the y direction only
55223 + */
55224 + ud->fbinfo->fix.xpanstep = 0;
55225 + ud->fbinfo->fix.ypanstep = 1;
55226 +
55227 + ud->fbinfo->pseudo_palette = ud->pseudo_palette;
55228 + ud->fbinfo->flags = FBINFO_DEFAULT;
55229 + ud->fbinfo->var = ubicom32vfb_var;
55230 + ud->fbinfo->var.xres = xres;
55231 + ud->fbinfo->var.yres = yres;
55232 +
55233 + /*
55234 + * We cannot pan in the X direction, so xres_virtual is xres
55235 + * We can pan in the Y direction, so yres_virtual is vram_size / ud->fbinfo->fix.line_length
55236 + */
55237 + ud->fbinfo->var.xres_virtual = xres;
55238 + ud->fbinfo->var.yres_virtual = (vram_size * 1024) / ud->fbinfo->fix.line_length;
55239 +
55240 + /*
55241 + * Allocate a color map
55242 + */
55243 + rc = fb_alloc_cmap(&ud->fbinfo->cmap, PALETTE_ENTRIES_NO, 0);
55244 + if (rc) {
55245 + dev_err(dev, "Fail to allocate colormap (%d entries)\n",
55246 + PALETTE_ENTRIES_NO);
55247 + goto fail;
55248 + }
55249 + ud->cmap_alloc = true;
55250 +
55251 + /*
55252 + * Register new frame buffer
55253 + */
55254 + rc = register_framebuffer(ud->fbinfo);
55255 + if (rc) {
55256 + dev_err(dev, "Could not register frame buffer\n");
55257 + goto fail;
55258 + }
55259 +
55260 + /*
55261 + * Tell the log we are here
55262 + */
55263 + dev_info(dev, "fbaddr=%p align=%p, size=%uKB screen(%ux%u) virt(%ux%u)\n",
55264 + ud->fb, ud->fb_aligned, vram_size, ud->fbinfo->var.xres, ud->fbinfo->var.yres,
55265 + ud->fbinfo->var.xres_virtual, ud->fbinfo->var.yres_virtual);
55266 +
55267 + /*
55268 + * Success
55269 + */
55270 + return 0;
55271 +
55272 +fail:
55273 + ubicom32vfb_release(dev);
55274 + return rc;
55275 +}
55276 +
55277 +/*
55278 + * ubicom32vfb_platform_remove
55279 + */
55280 +static int ubicom32vfb_platform_remove(struct platform_device *pdev)
55281 +{
55282 + dev_info(&(pdev->dev), "Ubicom32 FB Driver Remove\n");
55283 + return ubicom32vfb_release(&pdev->dev);
55284 +}
55285 +
55286 +static struct platform_driver ubicom32vfb_platform_driver = {
55287 + .probe = ubicom32vfb_platform_probe,
55288 + .remove = ubicom32vfb_platform_remove,
55289 + .driver = {
55290 + .name = DRIVER_NAME,
55291 + .owner = THIS_MODULE,
55292 + },
55293 +};
55294 +
55295 +#ifndef MODULE
55296 +/*
55297 + * ubicom32vfb_setup
55298 + * Process kernel boot options
55299 + */
55300 +static int __init ubicom32vfb_setup(char *options)
55301 +{
55302 + char *this_opt;
55303 +
55304 + if (!options || !*options) {
55305 + return 0;
55306 + }
55307 +
55308 + while ((this_opt = strsep(&options, ",")) != NULL) {
55309 + if (!*this_opt) {
55310 + continue;
55311 + }
55312 +
55313 + if (!strncmp(this_opt, "vram_size=", 10)) {
55314 + vram_size = simple_strtoul(this_opt + 10, NULL, 0);
55315 + continue;
55316 + }
55317 +
55318 + if (!strncmp(this_opt, "bgr=", 4)) {
55319 + bgr = simple_strtoul(this_opt + 4, NULL, 0);
55320 + continue;
55321 + }
55322 +
55323 + if (!strncmp(this_opt, "xres=", 5)) {
55324 + xres = simple_strtoul(this_opt + 5, NULL, 0);
55325 + continue;
55326 + }
55327 +
55328 + if (!strncmp(this_opt, "yres=", 5)) {
55329 + yres = simple_strtoul(this_opt + 5, NULL, 0);
55330 + continue;
55331 + }
55332 + }
55333 + return 0;
55334 +}
55335 +#endif /* MODULE */
55336 +
55337 +/*
55338 + * ubicom32vfb_init
55339 + */
55340 +static int __devinit ubicom32vfb_init(void)
55341 +{
55342 + int ret;
55343 +
55344 +#ifndef MODULE
55345 + /*
55346 + * Get kernel boot options (in 'video=ubicom32vfb:<options>')
55347 + */
55348 + char *option = NULL;
55349 +
55350 + if (fb_get_options(DRIVER_NAME, &option)) {
55351 + return -ENODEV;
55352 + }
55353 + ubicom32vfb_setup(option);
55354 +#endif /* MODULE */
55355 +
55356 + ret = platform_driver_register(&ubicom32vfb_platform_driver);
55357 +
55358 +#ifdef CONFIG_FB_UBICOM32_VIRTUAL_NOAUTO
55359 + return ret;
55360 +#else
55361 + if (!ret) {
55362 + ubicom32vfb_platform_device = platform_device_alloc(DRIVER_NAME, 0);
55363 +
55364 + if (ubicom32vfb_platform_device)
55365 + ret = platform_device_add(ubicom32vfb_platform_device);
55366 + else
55367 + ret = -ENOMEM;
55368 +
55369 + if (ret) {
55370 + platform_device_put(ubicom32vfb_platform_device);
55371 + platform_driver_unregister(&ubicom32vfb_platform_driver);
55372 + }
55373 + }
55374 +
55375 + return ret;
55376 +#endif
55377 +}
55378 +module_init(ubicom32vfb_init);
55379 +
55380 +/*
55381 + * ubicom32vfb_exit
55382 + */
55383 +static void __exit ubicom32vfb_exit(void)
55384 +{
55385 + platform_device_unregister(ubicom32vfb_platform_device);
55386 + platform_driver_unregister(&ubicom32vfb_platform_driver);
55387 +}
55388 +module_exit(ubicom32vfb_exit);
55389 +
55390 +MODULE_LICENSE("GPL");
55391 +MODULE_AUTHOR("Patrick Tjin <@ubicom.com>");
55392 +MODULE_DESCRIPTION(DRIVER_DESCRIPTION);
55393 diff -ruN linux-2.6.30.10/drivers/watchdog/Kconfig linux-2.6.30.10-ubi/drivers/watchdog/Kconfig
55394 --- linux-2.6.30.10/drivers/watchdog/Kconfig 2009-12-04 08:00:07.000000000 +0200
55395 +++ linux-2.6.30.10-ubi/drivers/watchdog/Kconfig 2009-12-11 11:45:21.000000000 +0200
55396 @@ -887,6 +887,19 @@
55397 machines. The watchdog timeout period is normally one minute but
55398 can be changed with a boot-time parameter.
55399
55400 +# Ubicom32
55401 +
55402 +config UBI32_WDT
55403 + tristate "Ubicom32 Hardware Watchdog support"
55404 + depends on UBICOM32
55405 + ---help---
55406 + If you say yes here you will get support for the Ubicom32 On-Chip
55407 + Watchdog Timer. If you have one of these processors and wish to
55408 + have watchdog support enabled, say Y, otherwise say N.
55409 +
55410 + To compile this driver as a module, choose M here: the
55411 + module will be called ubi32_wdt.
55412 +
55413 # XTENSA Architecture
55414
55415 #
55416 diff -ruN linux-2.6.30.10/drivers/watchdog/Makefile linux-2.6.30.10-ubi/drivers/watchdog/Makefile
55417 --- linux-2.6.30.10/drivers/watchdog/Makefile 2009-12-04 08:00:07.000000000 +0200
55418 +++ linux-2.6.30.10-ubi/drivers/watchdog/Makefile 2009-12-11 11:45:21.000000000 +0200
55419 @@ -131,6 +131,9 @@
55420 obj-$(CONFIG_WATCHDOG_RIO) += riowd.o
55421 obj-$(CONFIG_WATCHDOG_CP1XXX) += cpwd.o
55422
55423 +# Ubicom32 Architecture
55424 +obj-$(CONFIG_UBI32_WDT) += ubi32_wdt.o
55425 +
55426 # XTENSA Architecture
55427
55428 # Architecture Independant
55429 diff -ruN linux-2.6.30.10/drivers/watchdog/ubi32_wdt.c linux-2.6.30.10-ubi/drivers/watchdog/ubi32_wdt.c
55430 --- linux-2.6.30.10/drivers/watchdog/ubi32_wdt.c 1970-01-01 02:00:00.000000000 +0200
55431 +++ linux-2.6.30.10-ubi/drivers/watchdog/ubi32_wdt.c 2009-12-11 11:45:21.000000000 +0200
55432 @@ -0,0 +1,630 @@
55433 +/*
55434 + * drivers/watchdog/ubi32_wdt.c
55435 + * Ubicom32 Watchdog Driver
55436 + *
55437 + * Originally based on softdog.c
55438 + * Copyright 2006-2007 Analog Devices Inc.
55439 + * Copyright 2006-2007 Michele d'Amico
55440 + * Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>
55441 + * (C) Copyright 2009, Ubicom, Inc.
55442 + *
55443 + * This file is part of the Ubicom32 Linux Kernel Port.
55444 + *
55445 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
55446 + * it and/or modify it under the terms of the GNU General Public License
55447 + * as published by the Free Software Foundation, either version 2 of the
55448 + * License, or (at your option) any later version.
55449 + *
55450 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
55451 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
55452 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
55453 + * the GNU General Public License for more details.
55454 + *
55455 + * You should have received a copy of the GNU General Public License
55456 + * along with the Ubicom32 Linux Kernel Port. If not,
55457 + * see <http://www.gnu.org/licenses/>.
55458 + *
55459 + * Ubicom32 implementation derived from (with many thanks):
55460 + * arch/m68knommu
55461 + * arch/blackfin
55462 + * arch/parisc
55463 + */
55464 +#include <linux/platform_device.h>
55465 +#include <linux/module.h>
55466 +#include <linux/moduleparam.h>
55467 +#include <linux/types.h>
55468 +#include <linux/timer.h>
55469 +#include <linux/miscdevice.h>
55470 +#include <linux/watchdog.h>
55471 +#include <linux/fs.h>
55472 +#include <linux/notifier.h>
55473 +#include <linux/reboot.h>
55474 +#include <linux/init.h>
55475 +#include <linux/interrupt.h>
55476 +#include <linux/uaccess.h>
55477 +#include <asm/ip5000.h>
55478 +
55479 +#define WATCHDOG_NAME "ubi32-wdt"
55480 +#define PFX WATCHDOG_NAME ": "
55481 +
55482 +#define OSC1_FREQ 12000000
55483 +#define WATCHDOG_SEC_TO_CYC(x) (OSC1_FREQ * (x))
55484 +#define WATCHDOG_MAX_SEC (0xffffffff / OSC1_FREQ)
55485 +
55486 +#define MIN_PROCESSOR_ADDRESS 0x03000000
55487 +
55488 +static DEFINE_SPINLOCK(ubi32_wdt_spinlock);
55489 +
55490 +#define WATCHDOG_TIMEOUT 20
55491 +
55492 +#if defined(CONFIG_WATCHDOG_NOWAYOUT)
55493 +#define WATCHDOG_NOWAYOUT 1
55494 +#else
55495 +#define WATCHDOG_NOWAYOUT 0
55496 +#endif
55497 +
55498 +static unsigned int timeout = WATCHDOG_TIMEOUT;
55499 +static int nowayout = WATCHDOG_NOWAYOUT;
55500 +static struct watchdog_info ubi32_wdt_info;
55501 +static unsigned long open_check;
55502 +static char expect_close;
55503 +
55504 +#if !defined(CONFIG_SMP)
55505 +#define UBI32_WDT_LOCK(lock, flags) local_irq_save(flags)
55506 +#define UBI32_WDT_UNLOCK(lock, flags) local_irq_restore(flags)
55507 +#define UBI32_WDT_LOCK_CHECK()
55508 +#else
55509 +#define UBI32_WDT_LOCK(lock, flags) spin_lock_irqsave((lock), (flags));
55510 +#define UBI32_WDT_UNLOCK(lock, flags) spin_unlock_irqrestore((lock), (flags));
55511 +#define UBI32_WDT_LOCK_CHECK() BUG_ON(!spin_is_locked(&ubi32_wdt_spinlock));
55512 +#endif
55513 +
55514 +/*
55515 + * ubi32_wdt_remaining()
55516 + * Return the approximate number of seconds remaining
55517 + */
55518 +static int ubi32_wdt_remaining(void)
55519 +{
55520 + int compare;
55521 + int curr;
55522 +
55523 + UBI32_WDT_LOCK_CHECK();
55524 +
55525 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, TIMER_TKEYVAL);
55526 + compare = ubicom32_read_reg(&UBICOM32_IO_TIMER->wdcom);
55527 + curr = ubicom32_read_reg(&UBICOM32_IO_TIMER->mptval);
55528 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, 0);
55529 + return (compare - curr) / OSC1_FREQ;
55530 +
55531 +}
55532 +
55533 +/*
55534 + * ubi32_wdt_keepalive()
55535 + * Keep the Userspace Watchdog Alive
55536 + *
55537 + * The Userspace watchdog got a KeepAlive: schedule the next timeout.
55538 + */
55539 +static int ubi32_wdt_keepalive(void)
55540 +{
55541 + UBI32_WDT_LOCK_CHECK();
55542 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, TIMER_TKEYVAL);
55543 + ubicom32_write_reg(&UBICOM32_IO_TIMER->wdcom,
55544 + ubicom32_read_reg(&UBICOM32_IO_TIMER->mptval)
55545 + + WATCHDOG_SEC_TO_CYC(timeout));
55546 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, 0);
55547 + return 0;
55548 +}
55549 +
55550 +/*
55551 + * ubi32_wdt_stop()
55552 + * Stop the on-chip Watchdog
55553 + */
55554 +static int ubi32_wdt_stop(void)
55555 +{
55556 + UBI32_WDT_LOCK_CHECK();
55557 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, TIMER_TKEYVAL);
55558 + ubicom32_write_reg(&UBICOM32_IO_TIMER->wdcfg, TIMER_WATCHDOG_DISABLE);
55559 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, 0);
55560 + return 0;
55561 +}
55562 +
55563 +/*
55564 + * ubi32_wdt_start()
55565 + * Start the on-chip Watchdog
55566 + */
55567 +static int ubi32_wdt_start(void)
55568 +{
55569 + UBI32_WDT_LOCK_CHECK();
55570 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, TIMER_TKEYVAL);
55571 + ubicom32_write_reg(&UBICOM32_IO_TIMER->wdcom,
55572 + ubicom32_read_reg(&UBICOM32_IO_TIMER->mptval)
55573 + + WATCHDOG_SEC_TO_CYC(timeout));
55574 + ubicom32_write_reg(&UBICOM32_IO_TIMER->wdcfg, ~TIMER_WATCHDOG_DISABLE);
55575 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, 0);
55576 + return 0;
55577 +}
55578 +
55579 +/*
55580 + * ubi32_wdt_running()
55581 + * Return true if the watchdog is configured
55582 + */
55583 +static int ubi32_wdt_running(void)
55584 +{
55585 + int enabled;
55586 +
55587 + UBI32_WDT_LOCK_CHECK();
55588 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, TIMER_TKEYVAL);
55589 + enabled = ubicom32_read_reg(&UBICOM32_IO_TIMER->wdcfg) == ~TIMER_WATCHDOG_DISABLE;
55590 + ubicom32_write_reg(&UBICOM32_IO_TIMER->tkey, 0);
55591 + return enabled;
55592 +}
55593 +
55594 +/*
55595 + * ubi32_wdt_set_timeout()
55596 + * Set the Userspace Watchdog timeout
55597 + *
55598 + * - @t: new timeout value (in seconds)
55599 + */
55600 +static int ubi32_wdt_set_timeout(unsigned long t)
55601 +{
55602 + UBI32_WDT_LOCK_CHECK();
55603 +
55604 + if (t > WATCHDOG_MAX_SEC) {
55605 + printk(KERN_WARNING PFX "request to large: %ld [1-%d] sec)\n", t, WATCHDOG_MAX_SEC);
55606 + return -EINVAL;
55607 + }
55608 +
55609 + /*
55610 + * If we are running, then reset the time value so
55611 + * that the new value has an immediate effect.
55612 + */
55613 + timeout = t;
55614 + if (ubi32_wdt_running()) {
55615 + ubi32_wdt_keepalive();
55616 + }
55617 + return 0;
55618 +}
55619 +
55620 +/*
55621 + * ubi32_wdt_open()
55622 + * Open the Device
55623 + */
55624 +static int ubi32_wdt_open(struct inode *inode, struct file *file)
55625 +{
55626 + unsigned long flags;
55627 +
55628 + if (test_and_set_bit(0, &open_check))
55629 + return -EBUSY;
55630 +
55631 + if (nowayout)
55632 + __module_get(THIS_MODULE);
55633 +
55634 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55635 + ubi32_wdt_start();
55636 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55637 +
55638 + return nonseekable_open(inode, file);
55639 +}
55640 +
55641 +/*
55642 + * ubi32_wdt_close()
55643 + * Close the Device
55644 + */
55645 +static int ubi32_wdt_release(struct inode *inode, struct file *file)
55646 +{
55647 + unsigned long flags;
55648 +
55649 + /*
55650 + * If we don't expect a close, then the watchdog continues
55651 + * even though the device is closed. The caller will have
55652 + * a full timeout value to reopen the device and continue
55653 + * stroking it.
55654 + */
55655 + if (expect_close != 42) {
55656 + printk(KERN_CRIT PFX
55657 + "Unexpected close, not stopping watchdog!\n");
55658 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55659 + ubi32_wdt_keepalive();
55660 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55661 + } else {
55662 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55663 + ubi32_wdt_stop();
55664 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55665 + }
55666 +
55667 + expect_close = 0;
55668 + clear_bit(0, &open_check);
55669 + return 0;
55670 +}
55671 +
55672 +/*
55673 + * ubi32_wdt_write()
55674 + * Write to Device
55675 + *
55676 + * If the user writes nothing, nothing happens.
55677 + * If the user writes a V, then we expect a close and allow a release.
55678 + * If the user writes anything else, it is ignored.
55679 + */
55680 +static ssize_t ubi32_wdt_write(struct file *file, const char __user *data,
55681 + size_t len, loff_t *ppos)
55682 +{
55683 + size_t i;
55684 + unsigned long flags;
55685 +
55686 + /*
55687 + * Every write resets the expect_close. The last write
55688 + * must be a V to allow shutdown on close.
55689 + */
55690 + expect_close = 0;
55691 +
55692 + /*
55693 + * Empty writes still ping.
55694 + */
55695 + if (!len) {
55696 + goto ping;
55697 + }
55698 +
55699 + /*
55700 + * If nowayout is set, it does not matter if the caller
55701 + * is trying to send the magic 'V' we will not allow a
55702 + * close to stop us.
55703 + */
55704 + if (nowayout) {
55705 + goto ping;
55706 + }
55707 +
55708 + /*
55709 + * See if the program wrote a 'V' and if so disable
55710 + * the watchdog on release.
55711 + */
55712 + for (i = 0; i < len; i++) {
55713 + char c;
55714 + if (get_user(c, data + i)) {
55715 + return -EFAULT;
55716 + }
55717 +
55718 + if (c == 'V') {
55719 + expect_close = 42;
55720 + }
55721 + }
55722 +
55723 +ping:
55724 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55725 + ubi32_wdt_keepalive();
55726 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55727 + return len;
55728 +}
55729 +
55730 +/*
55731 + * ubi32_wdt_ioctl()
55732 + * Query the watchdog device.
55733 + *
55734 + * Query basic information from the device or ping it, as outlined by the
55735 + * watchdog API.
55736 + */
55737 +static long ubi32_wdt_ioctl(struct file *file,
55738 + unsigned int cmd, unsigned long arg)
55739 +{
55740 + void __user *argp = (void __user *)arg;
55741 + int __user *p = argp;
55742 +
55743 + switch (cmd) {
55744 + case WDIOC_GETSUPPORT:
55745 + if (copy_to_user(argp, &ubi32_wdt_info, sizeof(ubi32_wdt_info))) {
55746 + return -EFAULT;
55747 + }
55748 + return 0;
55749 +
55750 + case WDIOC_GETSTATUS: {
55751 + unsigned long flags;
55752 + int running;
55753 +
55754 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55755 + running = ubi32_wdt_running();
55756 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55757 + return running;
55758 + }
55759 +
55760 + case WDIOC_GETBOOTSTATUS:
55761 + return ubicom32_get_reset_reason();
55762 +
55763 + case WDIOC_SETOPTIONS: {
55764 + unsigned long flags;
55765 + int options, ret = -EINVAL;
55766 +
55767 + /*
55768 + * The sample application does not pass a pointer
55769 + * but directly passes a value of 1 or 2; however
55770 + * all of the implementations (and thus probably
55771 + * the real applications) pass a pointer to a value.
55772 + *
55773 + * It should be noted that WDIOC_SETOPTIONS is defined as
55774 + * _IOR(WATCHDOG_IOCTL_BASE, 4, int), which means
55775 + * that it should be an int and NOT a pointer.
55776 + *
55777 + * TODO: Examine this code for future chips.
55778 + * TODO: Report the sample code defect.
55779 + */
55780 + if ((int)p < MIN_PROCESSOR_ADDRESS) {
55781 + options = (int)p;
55782 + } else {
55783 + if (get_user(options, p))
55784 + return -EFAULT;
55785 + }
55786 +
55787 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55788 + if (options & WDIOS_DISABLECARD) {
55789 + ubi32_wdt_stop();
55790 + ret = 0;
55791 + }
55792 + if (options & WDIOS_ENABLECARD) {
55793 + ubi32_wdt_start();
55794 + ret = 0;
55795 + }
55796 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55797 + return ret;
55798 + }
55799 +
55800 + case WDIOC_KEEPALIVE: {
55801 + unsigned long flags;
55802 +
55803 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55804 + ubi32_wdt_keepalive();
55805 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55806 + return 0;
55807 + }
55808 +
55809 + case WDIOC_SETTIMEOUT: {
55810 + int new_timeout;
55811 + unsigned long flags;
55812 + int ret = 0;
55813 +
55814 + if (get_user(new_timeout, p))
55815 + return -EFAULT;
55816 +
55817 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55818 + ret = ubi32_wdt_set_timeout(new_timeout);
55819 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55820 + return ret;
55821 +
55822 + }
55823 +
55824 + case WDIOC_GETTIMEOUT:
55825 + return put_user(timeout, p);
55826 +
55827 + case WDIOC_GETTIMELEFT: {
55828 + unsigned long flags;
55829 + int remaining = 0;
55830 +
55831 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55832 + remaining = ubi32_wdt_remaining();
55833 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55834 + return put_user(remaining, p);
55835 + }
55836 +
55837 + default:
55838 + return -ENOTTY;
55839 + }
55840 +}
55841 +
55842 +/*
55843 + * ubi32_wdt_notify_sys()
55844 + * Notification callback function for system events.
55845 + *
55846 + * Turn off the watchdog during a SYS_DOWN or SYS_HALT.
55847 + */
55848 +static int ubi32_wdt_notify_sys(struct notifier_block *this,
55849 + unsigned long code, void *unused)
55850 +{
55851 + if (code == SYS_DOWN || code == SYS_HALT) {
55852 + unsigned long flags;
55853 +
55854 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55855 + ubi32_wdt_stop();
55856 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55857 + }
55858 +
55859 + return NOTIFY_DONE;
55860 +}
55861 +
55862 +#ifdef CONFIG_PM
55863 +static int state_before_suspend;
55864 +
55865 +/*
55866 + * ubi32_wdt_suspend()
55867 + * suspend the watchdog
55868 + *
55869 + * Remember if the watchdog was running and stop it.
55870 + */
55871 +static int ubi32_wdt_suspend(struct platform_device *pdev, pm_message_t state)
55872 +{
55873 + unsigned long flags;
55874 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55875 + state_before_suspend = ubi32_wdt_running();
55876 + ubi32_wdt_stop();
55877 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55878 +
55879 + return 0;
55880 +}
55881 +
55882 +/*
55883 + * ubi32_wdt_resume()
55884 + * Resume the watchdog
55885 + *
55886 + * If the watchdog was running, turn it back on.
55887 + */
55888 +static int ubi32_wdt_resume(struct platform_device *pdev)
55889 +{
55890 + if (state_before_suspend) {
55891 + unsigned long flags;
55892 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
55893 + ubi32_wdt_set_timeout(timeout);
55894 + ubi32_wdt_start();
55895 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
55896 + }
55897 +
55898 + return 0;
55899 +}
55900 +#else
55901 +# define ubi32_wdt_suspend NULL
55902 +# define ubi32_wdt_resume NULL
55903 +#endif
55904 +
55905 +static const struct file_operations ubi32_wdt_fops = {
55906 + .owner = THIS_MODULE,
55907 + .llseek = no_llseek,
55908 + .write = ubi32_wdt_write,
55909 + .unlocked_ioctl = ubi32_wdt_ioctl,
55910 + .open = ubi32_wdt_open,
55911 + .release = ubi32_wdt_release,
55912 +};
55913 +
55914 +static struct miscdevice ubi32_wdt_miscdev = {
55915 + .minor = WATCHDOG_MINOR,
55916 + .name = "watchdog",
55917 + .fops = &ubi32_wdt_fops,
55918 +};
55919 +
55920 +static struct watchdog_info ubi32_wdt_info = {
55921 + .identity = "Ubicom32 Watchdog",
55922 + .options = WDIOF_SETTIMEOUT |
55923 + WDIOF_KEEPALIVEPING |
55924 + WDIOF_MAGICCLOSE,
55925 +};
55926 +
55927 +static struct notifier_block ubi32_wdt_notifier = {
55928 + .notifier_call = ubi32_wdt_notify_sys,
55929 +};
55930 +
55931 +/*
55932 + * ubi32_wdt_probe()
55933 + * Probe/register the watchdog module
55934 + *
55935 + * Registers the misc device and notifier handler. Actual device
55936 + * initialization is handled by ubi32_wdt_open().
55937 + */
55938 +static int __devinit ubi32_wdt_probe(struct platform_device *pdev)
55939 +{
55940 + int ret;
55941 +
55942 + ret = register_reboot_notifier(&ubi32_wdt_notifier);
55943 + if (ret) {
55944 + printk(KERN_ERR PFX
55945 + "cannot register reboot notifier (err=%d)\n", ret);
55946 + return ret;
55947 + }
55948 +
55949 + ret = misc_register(&ubi32_wdt_miscdev);
55950 + if (ret) {
55951 + printk(KERN_ERR PFX
55952 + "cannot register miscdev on minor=%d (err=%d)\n",
55953 + WATCHDOG_MINOR, ret);
55954 + unregister_reboot_notifier(&ubi32_wdt_notifier);
55955 + return ret;
55956 + }
55957 +
55958 + printk(KERN_INFO PFX "initialized: timeout=%d sec (nowayout=%d)\n",
55959 + timeout, nowayout);
55960 +
55961 + return 0;
55962 +}
55963 +
55964 +/*
55965 + * ubi32_wdt_remove()
55966 + * Uninstall the module
55967 + *
55968 + * Unregisters the misc device and notifier handler. Actual device
55969 + * deinitialization is handled by ubi32_wdt_close().
55970 + */
55971 +static int __devexit ubi32_wdt_remove(struct platform_device *pdev)
55972 +{
55973 + misc_deregister(&ubi32_wdt_miscdev);
55974 + unregister_reboot_notifier(&ubi32_wdt_notifier);
55975 + return 0;
55976 +}
55977 +
55978 +static struct platform_device *ubi32_wdt_device;
55979 +
55980 +static struct platform_driver ubi32_wdt_driver = {
55981 + .probe = ubi32_wdt_probe,
55982 + .remove = __devexit_p(ubi32_wdt_remove),
55983 + .suspend = ubi32_wdt_suspend,
55984 + .resume = ubi32_wdt_resume,
55985 + .driver = {
55986 + .name = WATCHDOG_NAME,
55987 + .owner = THIS_MODULE,
55988 + },
55989 +};
55990 +
55991 +/*
55992 + * ubi32_wdt_init()
55993 + * Initialize the watchdog.
55994 + *
55995 + * Checks the module params and registers the platform device & driver.
55996 + * Real work is in the platform probe function.
55997 + */
55998 +static int __init ubi32_wdt_init(void)
55999 +{
56000 + unsigned long flags;
56001 + int ret;
56002 +
56003 + /*
56004 + * Check that the timeout value is within range
56005 + */
56006 + spin_lock_irqsave(&ubi32_wdt_spinlock, flags);
56007 + ret = ubi32_wdt_set_timeout(timeout);
56008 + spin_unlock_irqrestore(&ubi32_wdt_spinlock, flags);
56009 + if (ret) {
56010 + return ret;
56011 + }
56012 +
56013 + /*
56014 + * Since this is an on-chip device and needs no board-specific
56015 + * resources, we'll handle all the platform device stuff here.
56016 + */
56017 + ret = platform_driver_register(&ubi32_wdt_driver);
56018 + if (ret) {
56019 + printk(KERN_ERR PFX "unable to register driver\n");
56020 + return ret;
56021 + }
56022 +
56023 + ubi32_wdt_device = platform_device_register_simple(WATCHDOG_NAME, -1, NULL, 0);
56024 + if (IS_ERR(ubi32_wdt_device)) {
56025 + printk(KERN_ERR PFX "unable to register device\n");
56026 + platform_driver_unregister(&ubi32_wdt_driver);
56027 + return PTR_ERR(ubi32_wdt_device);
56028 + }
56029 +
56030 + return 0;
56031 +}
56032 +
56033 +/*
56034 + * ubi32_wdt_exit()
56035 + * Deinitialize module
56036 + *
56037 + * Back out the platform device & driver steps. Real work is in the
56038 + * platform remove function.
56039 + */
56040 +static void __exit ubi32_wdt_exit(void)
56041 +{
56042 + platform_device_unregister(ubi32_wdt_device);
56043 + platform_driver_unregister(&ubi32_wdt_driver);
56044 +}
56045 +
56046 +module_init(ubi32_wdt_init);
56047 +module_exit(ubi32_wdt_exit);
56048 +
56049 +MODULE_AUTHOR("Sol Kavy<sol@ubicom.com>");
56050 +MODULE_DESCRIPTION("Ubicom32 Watchdog Device Driver");
56051 +MODULE_LICENSE("GPL");
56052 +MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
56053 +
56054 +module_param(timeout, uint, 0);
56055 +MODULE_PARM_DESC(timeout,
56056 + "Watchdog timeout in seconds. (1<=timeout<=((2^32)/SCLK), default="
56057 + __MODULE_STRING(WATCHDOG_TIMEOUT) ")");
56058 +
56059 +module_param(nowayout, int, 0);
56060 +MODULE_PARM_DESC(nowayout,
56061 + "Watchdog cannot be stopped once started (default="
56062 + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
56063 diff -ruN linux-2.6.30.10/fs/binfmt_flat.c linux-2.6.30.10-ubi/fs/binfmt_flat.c
56064 --- linux-2.6.30.10/fs/binfmt_flat.c 2009-12-04 08:00:07.000000000 +0200
56065 +++ linux-2.6.30.10-ubi/fs/binfmt_flat.c 2009-12-11 11:45:21.000000000 +0200
56066 @@ -67,6 +67,11 @@
56067 #define FLAT_DATA_ALIGN (sizeof(void *))
56068 #endif
56069
56070 +#ifndef ARCH_FLAT_ALIGN
56071 +#undef FLAT_DATA_ALIGN
56072 +#define FLAT_DATA_ALIGN ARCH_FLAT_ALIGN
56073 +#endif
56074 +
56075 #define RELOC_FAILED 0xff00ff01 /* Relocation incorrect somewhere */
56076 #define UNLOADED_LIB 0x7ff000ff /* Placeholder for unused library */
56077
56078 @@ -436,6 +441,7 @@
56079 loff_t fpos;
56080 unsigned long start_code, end_code;
56081 int ret;
56082 + int flush_happened = 0;
56083
56084 hdr = ((struct flat_hdr *) bprm->buf); /* exec-header */
56085 inode = bprm->file->f_path.dentry->d_inode;
56086 @@ -521,6 +527,7 @@
56087
56088 /* OK, This is the point of no return */
56089 set_personality(PER_LINUX_32BIT);
56090 + flush_happened = 1;
56091 }
56092
56093 /*
56094 @@ -535,6 +542,12 @@
56095 * it all together.
56096 */
56097 if ((flags & (FLAT_FLAG_RAM|FLAT_FLAG_GZIP)) == 0) {
56098 +
56099 +#ifdef ARCH_FLAT_ALIGN_TEXT
56100 + printk("Unable to mmap rom with ARCH alignment requirements\n");
56101 + ret = -ENOEXEC;
56102 + goto err;
56103 +#endif
56104 /*
56105 * this should give us a ROM ptr, but if it doesn't we don't
56106 * really care
56107 @@ -553,7 +566,7 @@
56108 goto err;
56109 }
56110
56111 - len = data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long);
56112 + len = data_len + extra + ALIGN(MAX_SHARED_LIBS * sizeof(unsigned long), FLAT_DATA_ALIGN);
56113 len = PAGE_ALIGN(len);
56114 down_write(&current->mm->mmap_sem);
56115 realdatastart = do_mmap(0, 0, len,
56116 @@ -572,6 +585,7 @@
56117 datapos = ALIGN(realdatastart +
56118 MAX_SHARED_LIBS * sizeof(unsigned long),
56119 FLAT_DATA_ALIGN);
56120 + //datapos = realdatastart + ALIGN(MAX_SHARED_LIBS * sizeof(unsigned long), ARCH_FLAT_ALIGN);
56121
56122 DBG_FLT("BINFMT_FLAT: Allocated data+bss+stack (%d bytes): %x\n",
56123 (int)(data_len + bss_len + stack_len), (int)datapos);
56124 @@ -600,7 +614,11 @@
56125 memp_size = len;
56126 } else {
56127
56128 - len = text_len + data_len + extra + MAX_SHARED_LIBS * sizeof(unsigned long);
56129 + len = text_len + data_len + extra + ALIGN(MAX_SHARED_LIBS * sizeof(unsigned long), FLAT_DATA_ALIGN);
56130 +#ifdef ARCH_FLAT_ALIGN_TEXT
56131 + /* Reserve space for the text alignment. */
56132 + len += FLAT_DATA_ALIGN;
56133 +#endif
56134 len = PAGE_ALIGN(len);
56135 down_write(&current->mm->mmap_sem);
56136 textpos = do_mmap(0, 0, len,
56137 @@ -616,10 +634,17 @@
56138 goto err;
56139 }
56140
56141 + memp = textpos;
56142 +#ifdef ARCH_FLAT_ALIGN_TEXT
56143 + textpos = ALIGN(textpos + sizeof(struct flat_hdr), FLAT_DATA_ALIGN) - sizeof(struct flat_hdr);
56144 +#endif
56145 realdatastart = textpos + ntohl(hdr->data_start);
56146 datapos = ALIGN(realdatastart +
56147 MAX_SHARED_LIBS * sizeof(unsigned long),
56148 FLAT_DATA_ALIGN);
56149 +// datapos = realdatastart + ALIGN(MAX_SHARED_LIBS * sizeof(unsigned long), ARCH_FLAT_ALIGN);
56150 +// reloc = (unsigned long *) (textpos + ntohl(hdr->reloc_start) +
56151 +// ALIGN(MAX_SHARED_LIBS * sizeof(unsigned long), ARCH_FLAT_ALIGN));
56152
56153 reloc = (unsigned long *)
56154 (datapos + (ntohl(hdr->reloc_start) - text_len));
56155 @@ -659,7 +684,7 @@
56156 }
56157 if (result >= (unsigned long)-4096) {
56158 printk("Unable to read code+data+bss, errno %d\n",(int)-result);
56159 - do_munmap(current->mm, textpos, text_len + data_len + extra +
56160 + do_munmap(current->mm, memp, text_len + data_len + extra +
56161 MAX_SHARED_LIBS * sizeof(unsigned long));
56162 ret = result;
56163 goto err;
56164 @@ -672,6 +697,9 @@
56165
56166 /* The main program needs a little extra setup in the task structure */
56167 start_code = textpos + sizeof (struct flat_hdr);
56168 +#ifdef ARCH_FLAT_ALIGN_TEXT
56169 + BUG_ON(ALIGN(start_code, FLAT_DATA_ALIGN) != start_code);
56170 +#endif
56171 end_code = textpos + text_len;
56172 if (id == 0) {
56173 current->mm->start_code = start_code;
56174 @@ -800,6 +828,13 @@
56175
56176 return 0;
56177 err:
56178 + if (flush_happened) {
56179 + /*
56180 + * The parent process has already started running. We cannot allow the child to return back to user space
56181 + * as this child is still uning the parent stack and 2 will clobber each other. We are going to kill this child.
56182 + */
56183 + do_exit(SIGTERM);
56184 + }
56185 return ret;
56186 }
56187
56188 diff -ruN linux-2.6.30.10/fs/Kconfig.binfmt linux-2.6.30.10-ubi/fs/Kconfig.binfmt
56189 --- linux-2.6.30.10/fs/Kconfig.binfmt 2009-12-04 08:00:07.000000000 +0200
56190 +++ linux-2.6.30.10-ubi/fs/Kconfig.binfmt 2009-12-11 11:45:21.000000000 +0200
56191 @@ -30,7 +30,7 @@
56192 config BINFMT_ELF_FDPIC
56193 bool "Kernel support for FDPIC ELF binaries"
56194 default y
56195 - depends on (FRV || BLACKFIN || (SUPERH32 && !MMU))
56196 + depends on (FRV || BLACKFIN || (SUPERH32 && !MMU) || UBICOM32)
56197 help
56198 ELF FDPIC binaries are based on ELF, but allow the individual load
56199 segments of a binary to be located in memory independently of each
56200 diff -ruN linux-2.6.30.10/include/asm-generic/resource.h linux-2.6.30.10-ubi/include/asm-generic/resource.h
56201 --- linux-2.6.30.10/include/asm-generic/resource.h 2009-12-04 08:00:07.000000000 +0200
56202 +++ linux-2.6.30.10-ubi/include/asm-generic/resource.h 2009-12-11 11:45:23.000000000 +0200
56203 @@ -69,13 +69,16 @@
56204 /*
56205 * boot-time rlimit defaults for the init task:
56206 */
56207 +#ifndef CONFIG_ELF_CORE
56208 +#define CONFIG_USER_ELF_CORE_SIZE 0
56209 +#endif
56210 #define INIT_RLIMITS \
56211 { \
56212 [RLIMIT_CPU] = { RLIM_INFINITY, RLIM_INFINITY }, \
56213 [RLIMIT_FSIZE] = { RLIM_INFINITY, RLIM_INFINITY }, \
56214 [RLIMIT_DATA] = { RLIM_INFINITY, RLIM_INFINITY }, \
56215 [RLIMIT_STACK] = { _STK_LIM, _STK_LIM_MAX }, \
56216 - [RLIMIT_CORE] = { 0, RLIM_INFINITY }, \
56217 + [RLIMIT_CORE] = { CONFIG_USER_ELF_CORE_SIZE, RLIM_INFINITY }, \
56218 [RLIMIT_RSS] = { RLIM_INFINITY, RLIM_INFINITY }, \
56219 [RLIMIT_NPROC] = { 0, 0 }, \
56220 [RLIMIT_NOFILE] = { INR_OPEN, INR_OPEN }, \
56221 diff -ruN linux-2.6.30.10/include/linux/elf-em.h linux-2.6.30.10-ubi/include/linux/elf-em.h
56222 --- linux-2.6.30.10/include/linux/elf-em.h 2009-12-04 08:00:07.000000000 +0200
56223 +++ linux-2.6.30.10-ubi/include/linux/elf-em.h 2009-12-11 11:45:23.000000000 +0200
56224 @@ -41,6 +41,7 @@
56225 * up with a final number.
56226 */
56227 #define EM_ALPHA 0x9026
56228 +#define EM_UBICOM32 0xde3d /* Ubicom32; no ABI */
56229
56230 /* Bogus old v850 magic number, used by old tools. */
56231 #define EM_CYGNUS_V850 0x9080
56232 diff -ruN linux-2.6.30.10/include/linux/fb.h linux-2.6.30.10-ubi/include/linux/fb.h
56233 --- linux-2.6.30.10/include/linux/fb.h 2009-12-14 12:16:53.000000000 +0200
56234 +++ linux-2.6.30.10-ubi/include/linux/fb.h 2009-12-14 12:16:56.000000000 +0200
56235 @@ -151,6 +151,10 @@
56236 #define FB_ACCEL_PROSAVAGE_DDR 0x8d /* S3 ProSavage DDR */
56237 #define FB_ACCEL_PROSAVAGE_DDRK 0x8e /* S3 ProSavage DDR-K */
56238
56239 +#define FB_ACCEL_UBICOM32 0x0100 /* Ubicom32 */
56240 +#define FB_ACCEL_UBICOM32_VFB 0x0101 /* Ubicom32 VFB */
56241 +#define FB_ACCEL_UBICOM32_PLIO80 0x0102 /* Ubicom32 PLIO80 */
56242 +
56243 struct fb_fix_screeninfo {
56244 char id[16]; /* identification string eg "TT Builtin" */
56245 unsigned long smem_start; /* Start of frame buffer mem */
56246 diff -ruN linux-2.6.30.10/include/linux/if_ppp.h linux-2.6.30.10-ubi/include/linux/if_ppp.h
56247 --- linux-2.6.30.10/include/linux/if_ppp.h 2009-12-04 08:00:07.000000000 +0200
56248 +++ linux-2.6.30.10-ubi/include/linux/if_ppp.h 2009-12-11 11:45:23.000000000 +0200
56249 @@ -114,14 +114,14 @@
56250 __u16 tunnel_id; /* redundant */
56251 __u16 session_id; /* if zero, get tunnel stats */
56252 __u32 using_ipsec:1; /* valid only for session_id == 0 */
56253 - aligned_u64 tx_packets;
56254 - aligned_u64 tx_bytes;
56255 - aligned_u64 tx_errors;
56256 - aligned_u64 rx_packets;
56257 - aligned_u64 rx_bytes;
56258 - aligned_u64 rx_seq_discards;
56259 - aligned_u64 rx_oos_packets;
56260 - aligned_u64 rx_errors;
56261 + __u64 tx_packets;
56262 + __u64 tx_bytes;
56263 + __u64 tx_errors;
56264 + __u64 rx_packets;
56265 + __u64 rx_bytes;
56266 + __u64 rx_seq_discards;
56267 + __u64 rx_oos_packets;
56268 + __u64 rx_errors;
56269 };
56270
56271 #define ifr__name b.ifr_ifrn.ifrn_name
56272 diff -ruN linux-2.6.30.10/include/linux/oprofile.h linux-2.6.30.10-ubi/include/linux/oprofile.h
56273 --- linux-2.6.30.10/include/linux/oprofile.h 2009-12-04 08:00:07.000000000 +0200
56274 +++ linux-2.6.30.10-ubi/include/linux/oprofile.h 2009-12-11 11:45:23.000000000 +0200
56275 @@ -99,6 +99,8 @@
56276 */
56277 void oprofile_add_ext_sample(unsigned long pc, struct pt_regs * const regs,
56278 unsigned long event, int is_kernel);
56279 +void oprofile_add_ext_sample_cpu(unsigned long pc, struct pt_regs * const regs,
56280 + unsigned long event, int is_kernel, int cpu);
56281
56282 /* Use this instead when the PC value is not from the regs. Doesn't
56283 * backtrace. */
56284 diff -ruN linux-2.6.30.10/include/linux/serial_core.h linux-2.6.30.10-ubi/include/linux/serial_core.h
56285 --- linux-2.6.30.10/include/linux/serial_core.h 2009-12-04 08:00:07.000000000 +0200
56286 +++ linux-2.6.30.10-ubi/include/linux/serial_core.h 2009-12-11 11:45:23.000000000 +0200
56287 @@ -167,6 +167,9 @@
56288 /* MAX3100 */
56289 #define PORT_MAX3100 86
56290
56291 +/* Ubicom32 */
56292 +#define PORT_UBI32_UARTTIO 87
56293 +
56294 #ifdef __KERNEL__
56295
56296 #include <linux/compiler.h>
56297 diff -ruN linux-2.6.30.10/include/linux/slab.h linux-2.6.30.10-ubi/include/linux/slab.h
56298 --- linux-2.6.30.10/include/linux/slab.h 2009-12-04 08:00:07.000000000 +0200
56299 +++ linux-2.6.30.10-ubi/include/linux/slab.h 2009-12-11 11:45:23.000000000 +0200
56300 @@ -317,4 +317,14 @@
56301 return kmalloc_node(size, flags | __GFP_ZERO, node);
56302 }
56303
56304 +struct kmem_cache_size_info {
56305 + unsigned short page;
56306 + unsigned short order;
56307 +};
56308 +
56309 +/*
56310 + * get info on all the memory allocated by slab for this named cache
56311 + */
56312 +extern int kmem_cache_block_info(char *name, struct kmem_cache_size_info *data, int max_data);
56313 +
56314 #endif /* _LINUX_SLAB_H */
56315 diff -ruN linux-2.6.30.10/init/Kconfig linux-2.6.30.10-ubi/init/Kconfig
56316 --- linux-2.6.30.10/init/Kconfig 2009-12-14 13:00:08.000000000 +0200
56317 +++ linux-2.6.30.10-ubi/init/Kconfig 2009-12-14 13:00:11.000000000 +0200
56318 @@ -865,6 +865,12 @@
56319 help
56320 Enable support for generating core dumps. Disabling saves about 4k.
56321
56322 +config USER_ELF_CORE_SIZE
56323 + int "user core dump size (10MB to 32MB)"
56324 + range 10485760 33554432
56325 + default 16777216
56326 + depends on ELF_CORE
56327 +
56328 config PCSPKR_PLATFORM
56329 bool "Enable PC-Speaker support" if EMBEDDED
56330 depends on ALPHA || X86 || MIPS || PPC_PREP || PPC_CHRP || PPC_PSERIES
56331 diff -ruN linux-2.6.30.10/kernel/module.c linux-2.6.30.10-ubi/kernel/module.c
56332 --- linux-2.6.30.10/kernel/module.c 2009-12-04 08:00:07.000000000 +0200
56333 +++ linux-2.6.30.10-ubi/kernel/module.c 2009-12-11 11:45:24.000000000 +0200
56334 @@ -2688,6 +2688,9 @@
56335 /* Used by oprofile and other similar tools. */
56336 seq_printf(m, " 0x%p", mod->module_core);
56337
56338 +#ifdef ARCH_PROC_MODULES_EXTRA
56339 + ARCH_PROC_MODULES_EXTRA(m, mod);
56340 +#endif
56341 /* Taints info */
56342 if (mod->taints)
56343 seq_printf(m, " %s", module_flags(mod, buf));
56344 @@ -2840,8 +2843,12 @@
56345 printk("Modules linked in:");
56346 /* Most callers should already have preempt disabled, but make sure */
56347 preempt_disable();
56348 - list_for_each_entry_rcu(mod, &modules, list)
56349 + list_for_each_entry_rcu(mod, &modules, list) {
56350 printk(" %s%s", mod->name, module_flags(mod, buf));
56351 +#ifdef ARCH_OOPS_MODULE_EXTRA
56352 + ARCH_OOPS_MODULE_EXTRA(mod);
56353 +#endif
56354 + }
56355 preempt_enable();
56356 if (last_unloaded_module[0])
56357 printk(" [last unloaded: %s]", last_unloaded_module);
56358 diff -ruN linux-2.6.30.10/kernel/sched_clock.c linux-2.6.30.10-ubi/kernel/sched_clock.c
56359 --- linux-2.6.30.10/kernel/sched_clock.c 2009-12-04 08:00:07.000000000 +0200
56360 +++ linux-2.6.30.10-ubi/kernel/sched_clock.c 2009-12-11 11:45:24.000000000 +0200
56361 @@ -38,8 +38,7 @@
56362 */
56363 unsigned long long __attribute__((weak)) sched_clock(void)
56364 {
56365 - return (unsigned long long)(jiffies - INITIAL_JIFFIES)
56366 - * (NSEC_PER_SEC / HZ);
56367 + return (get_jiffies_64() - INITIAL_JIFFIES) * (NSEC_PER_SEC / HZ);
56368 }
56369
56370 static __read_mostly int sched_clock_running;
56371 diff -ruN linux-2.6.30.10/lib/Kconfig.debug linux-2.6.30.10-ubi/lib/Kconfig.debug
56372 --- linux-2.6.30.10/lib/Kconfig.debug 2009-12-04 08:00:07.000000000 +0200
56373 +++ linux-2.6.30.10-ubi/lib/Kconfig.debug 2009-12-11 11:45:24.000000000 +0200
56374 @@ -621,7 +621,7 @@
56375 bool "Compile the kernel with frame pointers"
56376 depends on DEBUG_KERNEL && \
56377 (CRIS || M68K || M68KNOMMU || FRV || UML || \
56378 - AVR32 || SUPERH || BLACKFIN || MN10300) || \
56379 + AVR32 || SUPERH || BLACKFIN || MN10300 || UBICOM32) || \
56380 ARCH_WANT_FRAME_POINTERS
56381 default y if (DEBUG_INFO && UML) || ARCH_WANT_FRAME_POINTERS
56382 help
56383 diff -ruN linux-2.6.30.10/mm/Makefile linux-2.6.30.10-ubi/mm/Makefile
56384 --- linux-2.6.30.10/mm/Makefile 2009-12-04 08:00:07.000000000 +0200
56385 +++ linux-2.6.30.10-ubi/mm/Makefile 2009-12-11 11:45:24.000000000 +0200
56386 @@ -38,3 +38,5 @@
56387 endif
56388 obj-$(CONFIG_QUICKLIST) += quicklist.o
56389 obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o
56390 +
56391 +CFLAGS_slab.o := $(PROFILING) -O2
56392 diff -ruN linux-2.6.30.10/mm/slab.c linux-2.6.30.10-ubi/mm/slab.c
56393 --- linux-2.6.30.10/mm/slab.c 2009-12-04 08:00:07.000000000 +0200
56394 +++ linux-2.6.30.10-ubi/mm/slab.c 2009-12-11 11:45:24.000000000 +0200
56395 @@ -4100,6 +4100,68 @@
56396
56397 #ifdef CONFIG_SLABINFO
56398
56399 +
56400 +/*
56401 + * get info on all the memory allocated by slab for this named cache
56402 + */
56403 +int kmem_cache_block_info(char *name, struct kmem_cache_size_info *data, int max_data)
56404 +{
56405 + int res = 0;
56406 + int found = 0;
56407 + int node;
56408 + struct kmem_cache *cachep;
56409 + struct kmem_list3 *l3;
56410 + struct slab *slabp;
56411 +
56412 + /* Find the cache in the chain of caches. */
56413 + mutex_lock(&cache_chain_mutex);
56414 + list_for_each_entry(cachep, &cache_chain, next) {
56415 + if (strcmp(cachep->name, name) == 0) {
56416 + found = 1;
56417 + break;
56418 + }
56419 + }
56420 + mutex_unlock(&cache_chain_mutex);
56421 + if (!found) {
56422 + return 0;
56423 + }
56424 + for_each_online_node(node) {
56425 + l3 = cachep->nodelists[node];
56426 + if (!l3)
56427 + continue;
56428 + if (res >= max_data)
56429 + break;
56430 + check_irq_on();
56431 + spin_lock_irq(&l3->list_lock);
56432 +
56433 + list_for_each_entry(slabp, &l3->slabs_full, list) {
56434 + if (res >= max_data)
56435 + break;
56436 + data[res].page = ((unsigned int)slabp->s_mem >> PAGE_SHIFT) & 0xffff;
56437 + data[res].order = cachep->gfporder;
56438 + res++;
56439 + }
56440 + list_for_each_entry(slabp, &l3->slabs_partial, list) {
56441 + if (res >= max_data)
56442 + break;
56443 + data[res].page = ((unsigned int)slabp->s_mem >> PAGE_SHIFT) & 0xffff;
56444 + data[res].order = cachep->gfporder;
56445 + res++;
56446 + }
56447 + list_for_each_entry(slabp, &l3->slabs_free, list) {
56448 + if (res >= max_data)
56449 + break;
56450 + data[res].page = ((unsigned int)slabp->s_mem >> PAGE_SHIFT) & 0xffff;
56451 + data[res].order = cachep->gfporder;
56452 + res++;
56453 + }
56454 +
56455 + spin_unlock_irq(&l3->list_lock);
56456 + }
56457 +
56458 + return res;
56459 +}
56460 +
56461 static void print_slabinfo_header(struct seq_file *m)
56462 {
56463 /*
56464 diff -ruN linux-2.6.30.10/scripts/mod/file2alias.c linux-2.6.30.10-ubi/scripts/mod/file2alias.c
56465 --- linux-2.6.30.10/scripts/mod/file2alias.c 2009-12-04 08:00:07.000000000 +0200
56466 +++ linux-2.6.30.10-ubi/scripts/mod/file2alias.c 2009-12-11 11:45:24.000000000 +0200
56467 @@ -774,6 +774,15 @@
56468 + sym->st_value;
56469 }
56470
56471 + /*
56472 + * somehow our gcc is not generating st_size correctly and set 0 for some symbols.
56473 + * and 0 size will break do_table since it adjust size to (size - id_size)
56474 + * this is to make sure st_size fall in range.
56475 + */
56476 + if (sym->st_size == 0 || sym->st_size > info->sechdrs[sym->st_shndx].sh_size) {
56477 + sym->st_size = info->sechdrs[sym->st_shndx].sh_size;
56478 + }
56479 +
56480 if (sym_is(symname, "__mod_pci_device_table"))
56481 do_table(symval, sym->st_size,
56482 sizeof(struct pci_device_id), "pci",
56483 diff -ruN linux-2.6.30.10/sound/Kconfig linux-2.6.30.10-ubi/sound/Kconfig
56484 --- linux-2.6.30.10/sound/Kconfig 2009-12-04 08:00:07.000000000 +0200
56485 +++ linux-2.6.30.10-ubi/sound/Kconfig 2009-12-11 11:45:24.000000000 +0200
56486 @@ -82,6 +82,8 @@
56487
56488 source "sound/soc/Kconfig"
56489
56490 +source "sound/ubicom32/Kconfig"
56491 +
56492 endif # SND
56493
56494 menuconfig SOUND_PRIME
56495 diff -ruN linux-2.6.30.10/sound/Makefile linux-2.6.30.10-ubi/sound/Makefile
56496 --- linux-2.6.30.10/sound/Makefile 2009-12-04 08:00:07.000000000 +0200
56497 +++ linux-2.6.30.10-ubi/sound/Makefile 2009-12-11 11:45:24.000000000 +0200
56498 @@ -6,7 +6,7 @@
56499 obj-$(CONFIG_SOUND_PRIME) += oss/
56500 obj-$(CONFIG_DMASOUND) += oss/
56501 obj-$(CONFIG_SND) += core/ i2c/ drivers/ isa/ pci/ ppc/ arm/ sh/ synth/ usb/ \
56502 - sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/
56503 + sparc/ spi/ parisc/ pcmcia/ mips/ soc/ atmel/ ubicom32/
56504 obj-$(CONFIG_SND_AOA) += aoa/
56505
56506 # This one must be compilable even if sound is configured out
56507 diff -ruN linux-2.6.30.10/sound/ubicom32/Kconfig linux-2.6.30.10-ubi/sound/ubicom32/Kconfig
56508 --- linux-2.6.30.10/sound/ubicom32/Kconfig 1970-01-01 02:00:00.000000000 +0200
56509 +++ linux-2.6.30.10-ubi/sound/ubicom32/Kconfig 2009-12-11 11:45:25.000000000 +0200
56510 @@ -0,0 +1,42 @@
56511 +# ALSA Ubicom32 drivers
56512 +
56513 +menuconfig SND_UBI32
56514 + tristate "Ubicom32 sound devices"
56515 + select SND_PCM
56516 + default n
56517 + help
56518 + Say Y here to include support for audio on the Ubicom32 platform.
56519 + To compile this driver as a module, say M here: the module will be
56520 + called snd_ubi32.
56521 +
56522 +if SND_UBI32
56523 +
56524 +config SND_UBI32_AUDIO_GENERIC_CAPTURE
56525 + bool "Generic Capture Support"
56526 + default n
56527 + help
56528 + Use this option to support ADCs which don't require special drivers.
56529 +
56530 +config SND_UBI32_AUDIO_GENERIC
56531 + bool "Generic Playback Support"
56532 + default n
56533 + help
56534 + Use this option to support DACs which don't require special drivers.
56535 +
56536 +comment "I2C Based Codecs"
56537 +
56538 +config SND_UBI32_AUDIO_CS4350
56539 + bool "Cirrus Logic CS4350 DAC"
56540 + depends on I2C
56541 + default n
56542 + help
56543 + Support for the Cirrus Logic CS4350 DAC.
56544 +
56545 +config SND_UBI32_AUDIO_CS4384
56546 + bool "Cirrus Logic CS4384 DAC"
56547 + depends on I2C
56548 + default n
56549 + help
56550 + Support for the Cirrus Logic CS4384 DAC.
56551 +
56552 +endif #SND_UBI32
56553 diff -ruN linux-2.6.30.10/sound/ubicom32/Makefile linux-2.6.30.10-ubi/sound/ubicom32/Makefile
56554 --- linux-2.6.30.10/sound/ubicom32/Makefile 1970-01-01 02:00:00.000000000 +0200
56555 +++ linux-2.6.30.10-ubi/sound/ubicom32/Makefile 2009-12-11 11:45:25.000000000 +0200
56556 @@ -0,0 +1,41 @@
56557 +#
56558 +# sound/ubicom32/Makefile
56559 +# Makefile for ALSA
56560 +#
56561 +# (C) Copyright 2009, Ubicom, Inc.
56562 +#
56563 +# This file is part of the Ubicom32 Linux Kernel Port.
56564 +#
56565 +# The Ubicom32 Linux Kernel Port is free software: you can redistribute
56566 +# it and/or modify it under the terms of the GNU General Public License
56567 +# as published by the Free Software Foundation, either version 2 of the
56568 +# License, or (at your option) any later version.
56569 +#
56570 +# The Ubicom32 Linux Kernel Port is distributed in the hope that it
56571 +# will be useful, but WITHOUT ANY WARRANTY; without even the implied
56572 +# warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
56573 +# the GNU General Public License for more details.
56574 +#
56575 +# You should have received a copy of the GNU General Public License
56576 +# along with the Ubicom32 Linux Kernel Port. If not,
56577 +# see <http://www.gnu.org/licenses/>.
56578 +#
56579 +# Ubicom32 implementation derived from (with many thanks):
56580 +# arch/m68knommu
56581 +# arch/blackfin
56582 +# arch/parisc
56583 +#
56584 +
56585 +CFLAGS_ubi32.o += -O2
56586 +snd-ubi32-pcm-objs := ubi32-pcm.o
56587 +snd-ubi32-generic-objs := ubi32-generic.o
56588 +snd-ubi32-generic-capture-objs := ubi32-generic-capture.o
56589 +snd-ubi32-cs4350-objs := ubi32-cs4350.o
56590 +snd-ubi32-cs4384-objs := ubi32-cs4384.o
56591 +
56592 +# Toplevel Module Dependency
56593 +obj-$(CONFIG_SND_UBI32) += snd-ubi32-pcm.o
56594 +obj-$(CONFIG_SND_UBI32_AUDIO_GENERIC) += snd-ubi32-generic.o
56595 +obj-$(CONFIG_SND_UBI32_AUDIO_GENERIC_CAPTURE) += snd-ubi32-generic-capture.o
56596 +obj-$(CONFIG_SND_UBI32_AUDIO_CS4350) += snd-ubi32-cs4350.o
56597 +obj-$(CONFIG_SND_UBI32_AUDIO_CS4384) += snd-ubi32-cs4384.o
56598 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32-cs4350.c linux-2.6.30.10-ubi/sound/ubicom32/ubi32-cs4350.c
56599 --- linux-2.6.30.10/sound/ubicom32/ubi32-cs4350.c 1970-01-01 02:00:00.000000000 +0200
56600 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32-cs4350.c 2009-12-11 11:45:25.000000000 +0200
56601 @@ -0,0 +1,583 @@
56602 +/*
56603 + * sound/ubicom32/ubi32-cs4350.c
56604 + * Interface to ubicom32 virtual audio peripheral - using CS4350 DAC
56605 + *
56606 + * (C) Copyright 2009, Ubicom, Inc.
56607 + *
56608 + * This file is part of the Ubicom32 Linux Kernel Port.
56609 + *
56610 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
56611 + * it and/or modify it under the terms of the GNU General Public License
56612 + * as published by the Free Software Foundation, either version 2 of the
56613 + * License, or (at your option) any later version.
56614 + *
56615 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
56616 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
56617 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
56618 + * the GNU General Public License for more details.
56619 + *
56620 + * You should have received a copy of the GNU General Public License
56621 + * along with the Ubicom32 Linux Kernel Port. If not,
56622 + * see <http://www.gnu.org/licenses/>.
56623 + */
56624 +
56625 +#include <linux/i2c.h>
56626 +#include <linux/module.h>
56627 +#include <linux/moduleparam.h>
56628 +#include <sound/core.h>
56629 +#include <sound/tlv.h>
56630 +#include <sound/control.h>
56631 +#include <sound/pcm.h>
56632 +#include <sound/initval.h>
56633 +#include "ubi32.h"
56634 +
56635 +#define DRIVER_NAME "snd-ubi32-cs4350"
56636 +
56637 +/*
56638 + * Module properties
56639 + */
56640 +static const struct i2c_device_id snd_ubi32_cs4350_id[] = {
56641 + {"cs4350", 0 },
56642 + { }
56643 +};
56644 +MODULE_DEVICE_TABLE(i2c, ubicom32audio_id);
56645 +
56646 +static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
56647 +
56648 +/*
56649 + * The dB scale for the Cirrus Logic cs4350. The output range is from
56650 + * -127.5 dB to 0 dB.
56651 + */
56652 +static const DECLARE_TLV_DB_SCALE(snd_ubi32_cs4350_db, -12750, 50, 0);
56653 +
56654 +#define ubi32_cs4350_mute_info snd_ctl_boolean_stereo_info
56655 +
56656 +/*
56657 + * Private data for cs4350 chip
56658 + */
56659 +struct ubi32_cs4350_priv {
56660 + /*
56661 + * The current volume settings
56662 + */
56663 + uint8_t volume[2];
56664 +
56665 + /*
56666 + * Bitmask of mutes MSB (unused, ..., unused, right_ch, left_ch) LSB
56667 + */
56668 + uint8_t mute;
56669 +
56670 + /*
56671 + * Lock to protect this struct because callbacks are not atomic.
56672 + */
56673 + spinlock_t lock;
56674 +};
56675 +
56676 +/*
56677 + * The info for the cs4350. The volume currently has one channel,
56678 + * and 255 possible settings.
56679 + */
56680 +static int ubi32_cs4350_volume_info(struct snd_kcontrol *kcontrol,
56681 + struct snd_ctl_elem_info *uinfo)
56682 +{
56683 + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
56684 + uinfo->count = 2;
56685 + uinfo->value.integer.min = 0;
56686 + uinfo->value.integer.max = 255; // 8 bits in cirrus logic cs4350 volume register
56687 + return 0;
56688 +}
56689 +
56690 +static int ubi32_cs4350_volume_get(struct snd_kcontrol *kcontrol,
56691 + struct snd_ctl_elem_value *ucontrol)
56692 +{
56693 + struct ubi32_snd_priv *ubi32_priv = snd_kcontrol_chip(kcontrol);
56694 + struct ubi32_cs4350_priv *cs4350_priv;
56695 + unsigned long flags;
56696 +
56697 + cs4350_priv = snd_ubi32_priv_get_drv(ubi32_priv);
56698 +
56699 + spin_lock_irqsave(&cs4350_priv->lock, flags);
56700 +
56701 + ucontrol->value.integer.value[0] = cs4350_priv->volume[0];
56702 + ucontrol->value.integer.value[1] = cs4350_priv->volume[1];
56703 +
56704 + spin_unlock_irqrestore(&cs4350_priv->lock, flags);
56705 +
56706 + return 0;
56707 +}
56708 +
56709 +static int ubi32_cs4350_volume_put(struct snd_kcontrol *kcontrol,
56710 + struct snd_ctl_elem_value *ucontrol)
56711 +{
56712 + struct ubi32_snd_priv *ubi32_priv = snd_kcontrol_chip(kcontrol);
56713 + struct i2c_client *client = (struct i2c_client *)ubi32_priv->client;
56714 + struct ubi32_cs4350_priv *cs4350_priv;
56715 + unsigned long flags;
56716 + int ret, changed;
56717 + char send[2];
56718 + uint8_t volume_reg_value_left, volume_reg_value_right;
56719 +
56720 + changed = 0;
56721 +
56722 + cs4350_priv = snd_ubi32_priv_get_drv(ubi32_priv);
56723 + volume_reg_value_left = 255 - (ucontrol->value.integer.value[0] & 0xFF);
56724 + volume_reg_value_right = 255 - (ucontrol->value.integer.value[1] & 0xFF);
56725 +
56726 +#if SND_UBI32_DEBUG
56727 + snd_printk(KERN_INFO "Setting volume: writing %d,%d to CS4350 volume registers\n", volume_reg_value_left, volume_reg_value_right);
56728 +#endif
56729 + spin_lock_irqsave(&cs4350_priv->lock, flags);
56730 +
56731 + if (cs4350_priv->volume[0] != ucontrol->value.integer.value[0]) {
56732 + send[0] = 0x05; // left channel
56733 + send[1] = volume_reg_value_left;
56734 + ret = i2c_master_send(client, send, 2);
56735 + if (ret != 2) {
56736 + snd_printk(KERN_ERR "Failed to set channel A volume on CS4350\n");
56737 + return changed;
56738 + }
56739 + cs4350_priv->volume[0] = ucontrol->value.integer.value[0];
56740 + changed = 1;
56741 + }
56742 +
56743 + if (cs4350_priv->volume[1] != ucontrol->value.integer.value[1]) {
56744 + send[0] = 0x06; // right channel
56745 + send[1] = volume_reg_value_right;
56746 + ret = i2c_master_send(client, send, 2);
56747 + if (ret != 2) {
56748 + snd_printk(KERN_ERR "Failed to set channel B volume on CS4350\n");
56749 + return changed;
56750 + }
56751 + cs4350_priv->volume[1] = ucontrol->value.integer.value[1];
56752 + changed = 1;
56753 + }
56754 +
56755 + spin_unlock_irqrestore(&cs4350_priv->lock, flags);
56756 +
56757 + return changed;
56758 +}
56759 +
56760 +static struct snd_kcontrol_new ubi32_cs4350_volume __devinitdata = {
56761 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
56762 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
56763 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
56764 + .name = "PCM Playback Volume",
56765 + .info = ubi32_cs4350_volume_info,
56766 + .get = ubi32_cs4350_volume_get,
56767 + .put = ubi32_cs4350_volume_put,
56768 + .tlv.p = snd_ubi32_cs4350_db,
56769 +};
56770 +
56771 +static int ubi32_cs4350_mute_get(struct snd_kcontrol *kcontrol,
56772 + struct snd_ctl_elem_value *ucontrol)
56773 +{
56774 + struct ubi32_snd_priv *ubi32_priv = snd_kcontrol_chip(kcontrol);
56775 + struct ubi32_cs4350_priv *cs4350_priv;
56776 + unsigned long flags;
56777 +
56778 + cs4350_priv = snd_ubi32_priv_get_drv(ubi32_priv);
56779 +
56780 + spin_lock_irqsave(&cs4350_priv->lock, flags);
56781 +
56782 + ucontrol->value.integer.value[0] = cs4350_priv->mute & 1;
56783 + ucontrol->value.integer.value[1] = (cs4350_priv->mute & (1 << 1)) ? 1 : 0;
56784 +
56785 + spin_unlock_irqrestore(&cs4350_priv->lock, flags);
56786 +
56787 + return 0;
56788 +}
56789 +
56790 +static int ubi32_cs4350_mute_put(struct snd_kcontrol *kcontrol,
56791 + struct snd_ctl_elem_value *ucontrol)
56792 +{
56793 + struct ubi32_snd_priv *ubi32_priv = snd_kcontrol_chip(kcontrol);
56794 + struct i2c_client *client = (struct i2c_client *)ubi32_priv->client;
56795 + struct ubi32_cs4350_priv *cs4350_priv;
56796 + unsigned long flags;
56797 + int ret, changed;
56798 + char send[2];
56799 + char recv[1];
56800 + uint8_t mute;
56801 +
56802 + changed = 0;
56803 +
56804 + cs4350_priv = snd_ubi32_priv_get_drv(ubi32_priv);
56805 +
56806 + spin_lock_irqsave(&cs4350_priv->lock, flags);
56807 +
56808 + if ((cs4350_priv->mute & 1) != ucontrol->value.integer.value[0]) {
56809 + send[0] = 0x04;
56810 + ret = i2c_master_send(client, send, 1);
56811 + if (ret != 1) {
56812 + snd_printk(KERN_ERR "Failed to write to mute register: channel 0\n");
56813 + return changed;
56814 + }
56815 +
56816 + ret = i2c_master_recv(client, recv, 1);
56817 + if (ret != 1) {
56818 + snd_printk(KERN_ERR "Failed to read mute register: channel 0\n");
56819 + return changed;
56820 + }
56821 +
56822 + mute = recv[0];
56823 +
56824 + if (ucontrol->value.integer.value[0]) {
56825 + cs4350_priv->mute |= 1;
56826 + mute &= ~(1 << 4);
56827 +#if SND_UBI32_DEBUG
56828 + snd_printk(KERN_INFO "Unmuted channel A\n");
56829 +#endif
56830 + } else {
56831 + cs4350_priv->mute &= ~1;
56832 + mute |= (1 << 4);
56833 +#if SND_UBI32_DEBUG
56834 + snd_printk(KERN_INFO "Muted channel A\n");
56835 +#endif
56836 + }
56837 +
56838 + send[0] = 0x04;
56839 + send[1] = mute;
56840 + ret = i2c_master_send(client, send, 2);
56841 + if (ret != 2) {
56842 + snd_printk(KERN_ERR "Failed to set channel A mute on CS4350\n");
56843 + return changed;
56844 + }
56845 + changed = 1;
56846 + }
56847 +
56848 + if (((cs4350_priv->mute & 2) >> 1) != ucontrol->value.integer.value[1]) {
56849 + send[0] = 0x04;
56850 + ret = i2c_master_send(client, send, 1);
56851 + if (ret != 1) {
56852 + snd_printk(KERN_ERR "Failed to write to mute register: channel 1\n");
56853 + return changed;
56854 + }
56855 +
56856 + ret = i2c_master_recv(client, recv, 1);
56857 + if (ret != 1) {
56858 + snd_printk(KERN_ERR "Failed to read mute register: channel 1\n");
56859 + return changed;
56860 + }
56861 +
56862 + mute = recv[0];
56863 +
56864 + if (ucontrol->value.integer.value[1]) {
56865 + cs4350_priv->mute |= (1 << 1);
56866 + mute &= ~(1 << 3);
56867 +#if SND_UBI32_DEBUG
56868 + snd_printk(KERN_INFO "Unmuted channel B\n");
56869 +#endif
56870 + } else {
56871 + cs4350_priv->mute &= ~(1 << 1);
56872 + mute |= (1 << 3);
56873 +#if SND_UBI32_DEBUG
56874 + snd_printk(KERN_INFO "Muted channel B\n");
56875 +#endif
56876 + }
56877 +
56878 + send[0] = 0x04;
56879 + send[1] = mute;
56880 + ret = i2c_master_send(client, send, 2);
56881 + if (ret != 2) {
56882 + snd_printk(KERN_ERR "Failed to set channel A mute on CS4350\n");
56883 + return changed;
56884 + }
56885 + changed = 1;
56886 + }
56887 +
56888 + spin_unlock_irqrestore(&cs4350_priv->lock, flags);
56889 +
56890 + return changed;
56891 +}
56892 +
56893 +static struct snd_kcontrol_new ubi32_cs4350_mute __devinitdata = {
56894 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
56895 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
56896 + .name = "PCM Playback Switch",
56897 + .info = ubi32_cs4350_mute_info,
56898 + .get = ubi32_cs4350_mute_get,
56899 + .put = ubi32_cs4350_mute_put,
56900 +};
56901 +
56902 +/*
56903 + * snd_ubi32_cs4350_free
56904 + * Card private data free function
56905 + */
56906 +void snd_ubi32_cs4350_free(struct snd_card *card)
56907 +{
56908 + struct ubi32_snd_priv *ubi32_priv;
56909 + struct ubi32_cs4350_priv *cs4350_priv;
56910 +
56911 + ubi32_priv = card->private_data;
56912 + cs4350_priv = snd_ubi32_priv_get_drv(ubi32_priv);
56913 + if (cs4350_priv) {
56914 + kfree(cs4350_priv);
56915 + }
56916 +}
56917 +
56918 +/*
56919 + * snd_ubi32_cs4350_dac_init
56920 + */
56921 +static int snd_ubi32_cs4350_dac_init(struct i2c_client *client, const struct i2c_device_id *id)
56922 +{
56923 + int ret;
56924 + char send[2];
56925 + char recv[8];
56926 +
56927 + /*
56928 + * Initialize the CS4350 DAC over the I2C interface
56929 + */
56930 + snd_printk(KERN_INFO "Initializing CS4350 DAC\n");
56931 +
56932 + /*
56933 + * Register 0x01: device/revid
56934 + */
56935 + send[0] = 0x01;
56936 + ret = i2c_master_send(client, send, 1);
56937 + if (ret != 1) {
56938 + snd_printk(KERN_ERR "Failed 1st attempt to write to CS4350 register 0x01\n");
56939 + goto fail;
56940 + }
56941 + ret = i2c_master_recv(client, recv, 1);
56942 + if (ret != 1) {
56943 + snd_printk(KERN_ERR "Failed initial read of CS4350 registers\n");
56944 + goto fail;
56945 + }
56946 + snd_printk(KERN_INFO "CS4350 DAC Device/Rev: %08x\n", recv[0]);
56947 +
56948 + /*
56949 + * Register 0x02: Mode control
56950 + * I2S DIF[2:0] = 001, no De-Emphasis, Auto speed mode
56951 + */
56952 + send[0] = 0x02;
56953 + send[1] = 0x10;
56954 + ret = i2c_master_send(client, send, 2);
56955 + if (ret != 2) {
56956 + snd_printk(KERN_ERR "Failed to set CS4350 to I2S mode\n");
56957 + goto fail;
56958 + }
56959 +
56960 + /*
56961 + * Register 0x05/0x06: Volume control
56962 + * Channel A volume set to 0 dB
56963 + * Channel B volume set to 0 dB
56964 + */
56965 + send[0] = 0x05;
56966 + send[1] = 0x00;
56967 + ret = i2c_master_send(client, send, 2);
56968 + if (ret != 2) {
56969 + snd_printk(KERN_ERR "Failed to set channel A volume on CS4350\n");
56970 + goto fail;
56971 + }
56972 +
56973 + send[0] = 0x06;
56974 + send[1] = 0x00;
56975 + ret = i2c_master_send(client, send, 2);
56976 + if (ret != 2) {
56977 + snd_printk(KERN_ERR "Failed to set channel A volume on CS4350\n");
56978 + goto fail;
56979 + }
56980 +
56981 + /*
56982 + * Make sure the changes took place, this helps verify we are talking to
56983 + * the correct chip.
56984 + */
56985 + send[0] = 0x81;
56986 + ret = i2c_master_send(client, send, 1);
56987 + if (ret != 1) {
56988 + snd_printk(KERN_ERR "Failed to initiate readback\n");
56989 + goto fail;
56990 + }
56991 +
56992 + ret = i2c_master_recv(client, recv, 8);
56993 + if (ret != 8) {
56994 + snd_printk(KERN_ERR "Failed second read of CS4350 registers\n");
56995 + goto fail;
56996 + }
56997 +
56998 + if ((recv[1] != 0x10) || (recv[4] != 0x00) || (recv[5] != 0x00)) {
56999 + snd_printk(KERN_ERR "Failed to initialize CS4350 DAC\n");
57000 + goto fail;
57001 + }
57002 +
57003 + snd_printk(KERN_INFO "CS4350 DAC Initialized\n");
57004 + return 0;
57005 +
57006 +fail:
57007 + return -ENODEV;
57008 +}
57009 +
57010 +/*
57011 + * snd_ubi32_cs4350_i2c_probe
57012 + */
57013 +static int snd_ubi32_cs4350_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
57014 +{
57015 + struct snd_card *card;
57016 + struct ubi32_snd_priv *ubi32_priv;
57017 + struct ubi32_cs4350_priv *cs4350_priv;
57018 + int err, ret;
57019 + struct platform_device *pdev;
57020 +
57021 + pdev = client->dev.platform_data;
57022 + if (!pdev) {
57023 + return -ENODEV;
57024 + }
57025 +
57026 + /*
57027 + * Initialize the CS4350 DAC
57028 + */
57029 + ret = snd_ubi32_cs4350_dac_init(client, id);
57030 + if (ret < 0) {
57031 + /*
57032 + * Initialization failed. Propagate the error.
57033 + */
57034 + return ret;
57035 + }
57036 +
57037 + /*
57038 + * Create a snd_card structure
57039 + */
57040 + card = snd_card_new(index, "Ubi32-CS4350", THIS_MODULE, sizeof(struct ubi32_snd_priv));
57041 + if (card == NULL) {
57042 + return -ENOMEM;
57043 + }
57044 +
57045 + card->private_free = snd_ubi32_cs4350_free; /* Not sure if correct */
57046 + ubi32_priv = card->private_data;
57047 +
57048 + /*
57049 + * CS4350 DAC has a minimum sample rate of 30khz and an
57050 + * upper limit of 216khz for it's auto-detect.
57051 + */
57052 + ubi32_priv->min_sample_rate = 30000;
57053 + ubi32_priv->max_sample_rate = 216000;
57054 +
57055 + /*
57056 + * Initialize the snd_card's private data structure
57057 + */
57058 + ubi32_priv->card = card;
57059 + ubi32_priv->client = client;
57060 +
57061 + /*
57062 + * Create our private data structure
57063 + */
57064 + cs4350_priv = kzalloc(sizeof(struct ubi32_cs4350_priv), GFP_KERNEL);
57065 + if (!cs4350_priv) {
57066 + snd_card_free(card);
57067 + return -ENOMEM;
57068 + }
57069 + snd_ubi32_priv_set_drv(ubi32_priv, cs4350_priv);
57070 + spin_lock_init(&cs4350_priv->lock);
57071 +
57072 + /*
57073 + * Initial volume is set to max by probe function
57074 + */
57075 + cs4350_priv->volume[0] = 0xFF;
57076 + cs4350_priv->volume[1] = 0xFF;
57077 +
57078 + /*
57079 + * The CS4350 starts off unmuted (bit set = not muted)
57080 + */
57081 + cs4350_priv->mute = 3;
57082 +
57083 + /*
57084 + * Create the new PCM instance
57085 + */
57086 + err = snd_ubi32_pcm_probe(ubi32_priv, pdev);
57087 + if (err < 0) {
57088 + snd_card_free(card);
57089 + return err; /* What is err? Need to include correct file */
57090 + }
57091 +
57092 + strcpy(card->driver, "Ubi32-CS4350");
57093 + strcpy(card->shortname, "Ubi32-CS4350");
57094 + snprintf(card->longname, sizeof(card->longname),
57095 + "%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
57096 + card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
57097 + ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
57098 +
57099 + snd_card_set_dev(card, &client->dev);
57100 +
57101 + /*
57102 + * Set up the mixer components
57103 + */
57104 + err = snd_ctl_add(card, snd_ctl_new1(&ubi32_cs4350_volume, ubi32_priv));
57105 + if (err) {
57106 + snd_printk(KERN_WARNING "Failed to add volume mixer control\n");
57107 + }
57108 + err = snd_ctl_add(card, snd_ctl_new1(&ubi32_cs4350_mute, ubi32_priv));
57109 + if (err) {
57110 + snd_printk(KERN_WARNING "Failed to add mute mixer control\n");
57111 + }
57112 +
57113 + /*
57114 + * Register the sound card
57115 + */
57116 + if ((err = snd_card_register(card)) != 0) {
57117 + snd_printk(KERN_WARNING "snd_card_register error\n");
57118 + }
57119 +
57120 + /*
57121 + * Store card for access from other methods
57122 + */
57123 + i2c_set_clientdata(client, card);
57124 +
57125 + return 0;
57126 +}
57127 +
57128 +/*
57129 + * snd_ubi32_cs4350_i2c_remove
57130 + */
57131 +static int __devexit snd_ubi32_cs4350_i2c_remove(struct i2c_client *client)
57132 +{
57133 + struct snd_card *card;
57134 + struct ubi32_snd_priv *ubi32_priv;
57135 +
57136 + card = i2c_get_clientdata(client);
57137 +
57138 + ubi32_priv = card->private_data;
57139 + snd_ubi32_pcm_remove(ubi32_priv);
57140 +
57141 + snd_card_free(i2c_get_clientdata(client));
57142 + i2c_set_clientdata(client, NULL);
57143 +
57144 + return 0;
57145 +}
57146 +
57147 +/*
57148 + * I2C driver description
57149 + */
57150 +static struct i2c_driver snd_ubi32_cs4350_driver = {
57151 + .driver = {
57152 + .name = DRIVER_NAME,
57153 + .owner = THIS_MODULE,
57154 + },
57155 + .id_table = snd_ubi32_cs4350_id,
57156 + .probe = snd_ubi32_cs4350_i2c_probe,
57157 + .remove = __devexit_p(snd_ubi32_cs4350_i2c_remove),
57158 +};
57159 +
57160 +/*
57161 + * Driver init
57162 + */
57163 +static int __init snd_ubi32_cs4350_init(void)
57164 +{
57165 + return i2c_add_driver(&snd_ubi32_cs4350_driver);
57166 +}
57167 +module_init(snd_ubi32_cs4350_init);
57168 +
57169 +/*
57170 + * snd_ubi32_cs4350_exit
57171 + */
57172 +static void __exit snd_ubi32_cs4350_exit(void)
57173 +{
57174 + i2c_del_driver(&snd_ubi32_cs4350_driver);
57175 +}
57176 +module_exit(snd_ubi32_cs4350_exit);
57177 +
57178 +/*
57179 + * Module properties
57180 + */
57181 +MODULE_ALIAS("i2c:" DRIVER_NAME);
57182 +MODULE_AUTHOR("Patrick Tjin");
57183 +MODULE_DESCRIPTION("Driver for Ubicom32 audio devices CS4350");
57184 +MODULE_LICENSE("GPL");
57185 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32-cs4384.c linux-2.6.30.10-ubi/sound/ubicom32/ubi32-cs4384.c
57186 --- linux-2.6.30.10/sound/ubicom32/ubi32-cs4384.c 1970-01-01 02:00:00.000000000 +0200
57187 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32-cs4384.c 2009-12-11 11:45:25.000000000 +0200
57188 @@ -0,0 +1,996 @@
57189 +/*
57190 + * sound/ubicom32/ubi32-cs4384.c
57191 + * Interface to ubicom32 virtual audio peripheral - using CS4384 DAC
57192 + *
57193 + * (C) Copyright 2009, Ubicom, Inc.
57194 + *
57195 + * This file is part of the Ubicom32 Linux Kernel Port.
57196 + *
57197 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
57198 + * it and/or modify it under the terms of the GNU General Public License
57199 + * as published by the Free Software Foundation, either version 2 of the
57200 + * License, or (at your option) any later version.
57201 + *
57202 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
57203 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
57204 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
57205 + * the GNU General Public License for more details.
57206 + *
57207 + * You should have received a copy of the GNU General Public License
57208 + * along with the Ubicom32 Linux Kernel Port. If not,
57209 + * see <http://www.gnu.org/licenses/>.
57210 + */
57211 +
57212 +#include <linux/i2c.h>
57213 +#include <linux/module.h>
57214 +#include <linux/moduleparam.h>
57215 +#include <linux/delay.h>
57216 +#include <sound/core.h>
57217 +#include <sound/tlv.h>
57218 +#include <sound/control.h>
57219 +#include <sound/pcm.h>
57220 +#include <sound/initval.h>
57221 +#include <asm/ip5000.h>
57222 +#include <asm/gpio.h>
57223 +#include <asm/audio.h>
57224 +#include <asm/ubi32-cs4384.h>
57225 +#include "ubi32.h"
57226 +
57227 +#define DRIVER_NAME "snd-ubi32-cs4384"
57228 +
57229 +/*
57230 + * Module properties
57231 + */
57232 +static const struct i2c_device_id snd_ubi32_cs4384_id[] = {
57233 + {"cs4384", 0 },
57234 + { }
57235 +};
57236 +MODULE_DEVICE_TABLE(i2c, ubicom32audio_id);
57237 +
57238 +static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
57239 +
57240 +/*
57241 + * Mixer properties
57242 + */
57243 +enum {
57244 + /*
57245 + * Be careful of changing the order of these IDs, they
57246 + * are used to index the volume array.
57247 + */
57248 + SND_UBI32_CS4384_FRONT_ID,
57249 + SND_UBI32_CS4384_SURROUND_ID,
57250 + SND_UBI32_CS4384_CENTER_ID,
57251 + SND_UBI32_CS4384_LFE_ID,
57252 + SND_UBI32_CS4384_REAR_ID,
57253 +
57254 + /*
57255 + * This should be the last ID
57256 + */
57257 + SND_UBI32_CS4384_LAST_ID,
57258 +};
57259 +static const u8_t snd_ubi32_cs4384_ch_ofs[] = {0, 2, 4, 5, 6};
57260 +
57261 +static const DECLARE_TLV_DB_SCALE(snd_ubi32_cs4384_db, -12750, 50, 0);
57262 +
57263 +#define snd_ubi32_cs4384_info_mute snd_ctl_boolean_stereo_info
57264 +#define snd_ubi32_cs4384_info_mute_mono snd_ctl_boolean_mono_info
57265 +
57266 +/*
57267 + * Mixer controls
57268 + */
57269 +static int snd_ubi32_cs4384_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo);
57270 +static int snd_ubi32_cs4384_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
57271 +static int snd_ubi32_cs4384_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
57272 +static int snd_ubi32_cs4384_get_mute(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
57273 +static int snd_ubi32_cs4384_put_mute(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol);
57274 +
57275 +/*
57276 + * Make sure to update these if the structure below is changed
57277 + */
57278 +#define SND_UBI32_MUTE_CTL_START 5
57279 +#define SND_UBI32_MUTE_CTL_END 9
57280 +static struct snd_kcontrol_new snd_ubi32_cs4384_controls[] __devinitdata = {
57281 + {
57282 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57283 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57284 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57285 + .name = "Front Playback Volume",
57286 + .info = snd_ubi32_cs4384_info_volume,
57287 + .get = snd_ubi32_cs4384_get_volume,
57288 + .put = snd_ubi32_cs4384_put_volume,
57289 + .private_value = SND_UBI32_CS4384_FRONT_ID,
57290 + .tlv = {
57291 + .p = snd_ubi32_cs4384_db,
57292 + },
57293 + },
57294 + {
57295 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57296 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57297 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57298 + .name = "Surround Playback Volume",
57299 + .info = snd_ubi32_cs4384_info_volume,
57300 + .get = snd_ubi32_cs4384_get_volume,
57301 + .put = snd_ubi32_cs4384_put_volume,
57302 + .private_value = SND_UBI32_CS4384_SURROUND_ID,
57303 + .tlv = {
57304 + .p = snd_ubi32_cs4384_db,
57305 + },
57306 + },
57307 + {
57308 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57309 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57310 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57311 + .name = "Center Playback Volume",
57312 + .info = snd_ubi32_cs4384_info_volume,
57313 + .get = snd_ubi32_cs4384_get_volume,
57314 + .put = snd_ubi32_cs4384_put_volume,
57315 + .private_value = SND_UBI32_CS4384_CENTER_ID,
57316 + .tlv = {
57317 + .p = snd_ubi32_cs4384_db,
57318 + },
57319 + },
57320 + {
57321 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57322 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57323 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57324 + .name = "LFE Playback Volume",
57325 + .info = snd_ubi32_cs4384_info_volume,
57326 + .get = snd_ubi32_cs4384_get_volume,
57327 + .put = snd_ubi32_cs4384_put_volume,
57328 + .private_value = SND_UBI32_CS4384_LFE_ID,
57329 + .tlv = {
57330 + .p = snd_ubi32_cs4384_db,
57331 + },
57332 + },
57333 + {
57334 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57335 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57336 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57337 + .name = "Rear Playback Volume",
57338 + .info = snd_ubi32_cs4384_info_volume,
57339 + .get = snd_ubi32_cs4384_get_volume,
57340 + .put = snd_ubi32_cs4384_put_volume,
57341 + .private_value = SND_UBI32_CS4384_REAR_ID,
57342 + .tlv = {
57343 + .p = snd_ubi32_cs4384_db,
57344 + },
57345 + },
57346 + {
57347 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57348 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57349 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57350 + .name = "Front Playback Switch",
57351 + .info = snd_ubi32_cs4384_info_mute,
57352 + .get = snd_ubi32_cs4384_get_mute,
57353 + .put = snd_ubi32_cs4384_put_mute,
57354 + .private_value = SND_UBI32_CS4384_FRONT_ID,
57355 + },
57356 + {
57357 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57358 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57359 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57360 + .name = "Surround Playback Switch",
57361 + .info = snd_ubi32_cs4384_info_mute,
57362 + .get = snd_ubi32_cs4384_get_mute,
57363 + .put = snd_ubi32_cs4384_put_mute,
57364 + .private_value = SND_UBI32_CS4384_SURROUND_ID,
57365 + },
57366 + {
57367 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57368 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57369 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57370 + .name = "Center Playback Switch",
57371 + .info = snd_ubi32_cs4384_info_mute_mono,
57372 + .get = snd_ubi32_cs4384_get_mute,
57373 + .put = snd_ubi32_cs4384_put_mute,
57374 + .private_value = SND_UBI32_CS4384_CENTER_ID,
57375 + },
57376 + {
57377 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57378 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57379 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57380 + .name = "LFE Playback Switch",
57381 + .info = snd_ubi32_cs4384_info_mute_mono,
57382 + .get = snd_ubi32_cs4384_get_mute,
57383 + .put = snd_ubi32_cs4384_put_mute,
57384 + .private_value = SND_UBI32_CS4384_LFE_ID,
57385 + },
57386 + {
57387 + .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
57388 + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
57389 + SNDRV_CTL_ELEM_ACCESS_TLV_READ,
57390 + .name = "Rear Playback Switch",
57391 + .info = snd_ubi32_cs4384_info_mute,
57392 + .get = snd_ubi32_cs4384_get_mute,
57393 + .put = snd_ubi32_cs4384_put_mute,
57394 + .private_value = SND_UBI32_CS4384_REAR_ID,
57395 + },
57396 +};
57397 +
57398 +/*
57399 + * Our private data
57400 + */
57401 +struct snd_ubi32_cs4384_priv {
57402 + /*
57403 + * Array of current volumes
57404 + * (L, R, SL, SR, C, LFE, RL, RR)
57405 + */
57406 + uint8_t volume[8];
57407 +
57408 + /*
57409 + * Bitmask of mutes
57410 + * MSB (RR, RL, LFE, C, SR, SL, R, L) LSB
57411 + */
57412 + uint8_t mute;
57413 +
57414 + /*
57415 + * Array of controls
57416 + */
57417 + struct snd_kcontrol *kctls[ARRAY_SIZE(snd_ubi32_cs4384_controls)];
57418 +
57419 + /*
57420 + * Lock to protect our card
57421 + */
57422 + spinlock_t lock;
57423 +};
57424 +
57425 +/*
57426 + * snd_ubi32_cs4384_info_volume
57427 + */
57428 +static int snd_ubi32_cs4384_info_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
57429 +{
57430 + unsigned int id = (unsigned int)kcontrol->private_value;
57431 +
57432 + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
57433 + uinfo->count = 1;
57434 + if ((id != SND_UBI32_CS4384_LFE_ID) &&
57435 + (id != SND_UBI32_CS4384_CENTER_ID)) {
57436 + uinfo->count = 2;
57437 + }
57438 + uinfo->value.integer.min = 0;
57439 + uinfo->value.integer.max = 255;
57440 + return 0;
57441 +}
57442 +
57443 +/*
57444 + * snd_ubi32_cs4384_get_volume
57445 + */
57446 +static int snd_ubi32_cs4384_get_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
57447 +{
57448 + struct ubi32_snd_priv *priv = snd_kcontrol_chip(kcontrol);
57449 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57450 + unsigned int id = (unsigned int)kcontrol->private_value;
57451 + int ch = snd_ubi32_cs4384_ch_ofs[id];
57452 + unsigned long flags;
57453 +
57454 + if (id >= SND_UBI32_CS4384_LAST_ID) {
57455 + return -EINVAL;
57456 + }
57457 +
57458 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57459 +
57460 + spin_lock_irqsave(&cs4384_priv->lock, flags);
57461 +
57462 + ucontrol->value.integer.value[0] = cs4384_priv->volume[ch];
57463 + if ((id != SND_UBI32_CS4384_LFE_ID) &&
57464 + (id != SND_UBI32_CS4384_CENTER_ID)) {
57465 + ch++;
57466 + ucontrol->value.integer.value[1] = cs4384_priv->volume[ch];
57467 + }
57468 +
57469 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57470 +
57471 + return 0;
57472 +}
57473 +
57474 +/*
57475 + * snd_ubi32_cs4384_put_volume
57476 + */
57477 +static int snd_ubi32_cs4384_put_volume(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
57478 +{
57479 + struct ubi32_snd_priv *priv = snd_kcontrol_chip(kcontrol);
57480 + struct i2c_client *client = (struct i2c_client *)priv->client;
57481 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57482 + unsigned int id = (unsigned int)kcontrol->private_value;
57483 + int ch = snd_ubi32_cs4384_ch_ofs[id];
57484 + unsigned long flags;
57485 + unsigned char send[3];
57486 + int nch;
57487 + int ret = -EINVAL;
57488 +
57489 + if (id >= SND_UBI32_CS4384_LAST_ID) {
57490 + return -EINVAL;
57491 + }
57492 +
57493 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57494 +
57495 + spin_lock_irqsave(&cs4384_priv->lock, flags);
57496 +
57497 + send[0] = 0;
57498 + switch (id) {
57499 + case SND_UBI32_CS4384_REAR_ID:
57500 + send[0] = 0x06;
57501 +
57502 + /*
57503 + * Fall through
57504 + */
57505 +
57506 + case SND_UBI32_CS4384_SURROUND_ID:
57507 + send[0] += 0x03;
57508 +
57509 + /*
57510 + * Fall through
57511 + */
57512 +
57513 + case SND_UBI32_CS4384_FRONT_ID:
57514 + send[0] += 0x8B;
57515 + nch = 2;
57516 + send[1] = 255 - (ucontrol->value.integer.value[0] & 0xFF);
57517 + send[2] = 255 - (ucontrol->value.integer.value[1] & 0xFF);
57518 + cs4384_priv->volume[ch++] = send[1];
57519 + cs4384_priv->volume[ch] = send[2];
57520 + break;
57521 +
57522 + case SND_UBI32_CS4384_LFE_ID:
57523 + send[0] = 0x81;
57524 +
57525 + /*
57526 + * Fall through
57527 + */
57528 +
57529 + case SND_UBI32_CS4384_CENTER_ID:
57530 + send[0] += 0x11;
57531 + nch = 1;
57532 + send[1] = 255 - (ucontrol->value.integer.value[0] & 0xFF);
57533 + cs4384_priv->volume[ch] = send[1];
57534 + break;
57535 +
57536 + default:
57537 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57538 + goto done;
57539 +
57540 + }
57541 +
57542 + /*
57543 + * Send the volume to the chip
57544 + */
57545 + nch++;
57546 + ret = i2c_master_send(client, send, nch);
57547 + if (ret != nch) {
57548 + snd_printk(KERN_ERR "Failed to set volume on CS4384\n");
57549 + }
57550 +
57551 +done:
57552 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57553 +
57554 + return ret;
57555 +}
57556 +
57557 +/*
57558 + * snd_ubi32_cs4384_get_mute
57559 + */
57560 +static int snd_ubi32_cs4384_get_mute(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
57561 +{
57562 + struct ubi32_snd_priv *priv = snd_kcontrol_chip(kcontrol);
57563 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57564 + unsigned int id = (unsigned int)kcontrol->private_value;
57565 + int ch = snd_ubi32_cs4384_ch_ofs[id];
57566 + unsigned long flags;
57567 +
57568 + if (id >= SND_UBI32_CS4384_LAST_ID) {
57569 + return -EINVAL;
57570 + }
57571 +
57572 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57573 +
57574 + spin_lock_irqsave(&cs4384_priv->lock, flags);
57575 +
57576 + ucontrol->value.integer.value[0] = !(cs4384_priv->mute & (1 << ch));
57577 +
57578 + if ((id != SND_UBI32_CS4384_LFE_ID) &&
57579 + (id != SND_UBI32_CS4384_CENTER_ID)) {
57580 + ch++;
57581 + ucontrol->value.integer.value[1] = !(cs4384_priv->mute & (1 << ch));
57582 + }
57583 +
57584 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57585 +
57586 + return 0;
57587 +}
57588 +
57589 +/*
57590 + * snd_ubi32_cs4384_put_mute
57591 + */
57592 +static int snd_ubi32_cs4384_put_mute(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
57593 +{
57594 + struct ubi32_snd_priv *priv = snd_kcontrol_chip(kcontrol);
57595 + struct i2c_client *client = (struct i2c_client *)priv->client;
57596 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57597 + unsigned int id = (unsigned int)kcontrol->private_value;
57598 + int ch = snd_ubi32_cs4384_ch_ofs[id];
57599 + unsigned long flags;
57600 + unsigned char send[2];
57601 + int ret = -EINVAL;
57602 +
57603 + if (id >= SND_UBI32_CS4384_LAST_ID) {
57604 + return -EINVAL;
57605 + }
57606 +
57607 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57608 +
57609 + spin_lock_irqsave(&cs4384_priv->lock, flags);
57610 +
57611 + if (ucontrol->value.integer.value[0]) {
57612 + cs4384_priv->mute &= ~(1 << ch);
57613 + } else {
57614 + cs4384_priv->mute |= (1 << ch);
57615 + }
57616 +
57617 + if ((id != SND_UBI32_CS4384_LFE_ID) && (id != SND_UBI32_CS4384_CENTER_ID)) {
57618 + ch++;
57619 + if (ucontrol->value.integer.value[1]) {
57620 + cs4384_priv->mute &= ~(1 << ch);
57621 + } else {
57622 + cs4384_priv->mute |= (1 << ch);
57623 + }
57624 + }
57625 +
57626 + /*
57627 + * Update the chip's mute reigster
57628 + */
57629 + send[0] = 0x09;
57630 + send[1] = cs4384_priv->mute;
57631 + ret = i2c_master_send(client, send, 2);
57632 + if (ret != 2) {
57633 + snd_printk(KERN_ERR "Failed to set mute on CS4384\n");
57634 + }
57635 +
57636 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57637 +
57638 + return ret;
57639 +}
57640 +
57641 +/*
57642 + * snd_ubi32_cs4384_mixer
57643 + * Setup the mixer controls
57644 + */
57645 +static int __devinit snd_ubi32_cs4384_mixer(struct ubi32_snd_priv *priv)
57646 +{
57647 + struct snd_card *card = priv->card;
57648 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57649 + int i;
57650 +
57651 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57652 + for (i = 0; i < ARRAY_SIZE(snd_ubi32_cs4384_controls); i++) {
57653 + int err;
57654 +
57655 + cs4384_priv->kctls[i] = snd_ctl_new1(&snd_ubi32_cs4384_controls[i], priv);
57656 + err = snd_ctl_add(card, cs4384_priv->kctls[i]);
57657 + if (err) {
57658 + snd_printk(KERN_WARNING "Failed to add control %d\n", i);
57659 + return err;
57660 + }
57661 + }
57662 + return 0;
57663 +}
57664 +
57665 +/*
57666 + * snd_ubi32_cs4384_free
57667 + * Card private data free function
57668 + */
57669 +void snd_ubi32_cs4384_free(struct snd_card *card)
57670 +{
57671 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57672 + struct ubi32_snd_priv *ubi32_priv;
57673 +
57674 + ubi32_priv = card->private_data;
57675 + cs4384_priv = snd_ubi32_priv_get_drv(ubi32_priv);
57676 + if (cs4384_priv) {
57677 + kfree(cs4384_priv);
57678 + }
57679 +}
57680 +
57681 +/*
57682 + * snd_ubi32_cs4384_setup_mclk
57683 + */
57684 +static int snd_ubi32_cs4384_setup_mclk(struct ubi32_cs4384_platform_data *pdata)
57685 +{
57686 + struct ubicom32_io_port *ioa = (struct ubicom32_io_port *)RA;
57687 + struct ubicom32_io_port *ioc = (struct ubicom32_io_port *)RC;
57688 + struct ubicom32_io_port *iod = (struct ubicom32_io_port *)RD;
57689 + struct ubicom32_io_port *ioe = (struct ubicom32_io_port *)RE;
57690 + struct ubicom32_io_port *ioh = (struct ubicom32_io_port *)RH;
57691 + unsigned int ctl0;
57692 + unsigned int ctlx;
57693 + unsigned int div;
57694 +
57695 + div = pdata->mclk_entries[0].div;
57696 +
57697 + ctl0 = (1 << 13);
57698 + ctlx = ((div - 1) << 16) | (div / 2);
57699 +
57700 + switch (pdata->mclk_src) {
57701 + case UBI32_CS4384_MCLK_PWM_0:
57702 + ioc->function |= 2;
57703 + ioc->ctl0 |= ctl0;
57704 + ioc->ctl1 = ctlx;
57705 + if (!ioa->function) {
57706 + ioa->function = 3;
57707 + }
57708 + return 0;
57709 +
57710 + case UBI32_CS4384_MCLK_PWM_1:
57711 + ioc->function |= 2;
57712 + ioc->ctl0 |= ctl0 << 16;
57713 + ioc->ctl2 = ctlx;
57714 + if (!ioe->function) {
57715 + ioe->function = 3;
57716 + }
57717 + return 0;
57718 +
57719 + case UBI32_CS4384_MCLK_PWM_2:
57720 + ioh->ctl0 |= ctl0;
57721 + ioh->ctl1 = ctlx;
57722 + if (!iod->function) {
57723 + iod->function = 3;
57724 + }
57725 + return 0;
57726 +
57727 + case UBI32_CS4384_MCLK_CLKDIV_1:
57728 + ioa->gpio_mask &= (1 << 7);
57729 + ioa->ctl1 &= ~(0x7F << 14);
57730 + ioa->ctl1 |= ((div - 1) << 14);
57731 + return 0;
57732 +
57733 + case UBI32_CS4384_MCLK_OTHER:
57734 + return 0;
57735 + }
57736 +
57737 + return 1;
57738 +}
57739 +
57740 +/*
57741 + * snd_ubi32_cs4384_set_rate
57742 + */
57743 +static int snd_ubi32_cs4384_set_rate(struct ubi32_snd_priv *priv, int rate)
57744 +{
57745 + struct ubi32_cs4384_platform_data *cpd = priv->pdata->priv_data;
57746 + struct ubicom32_io_port *ioa = (struct ubicom32_io_port *)RA;
57747 + struct ubicom32_io_port *ioc = (struct ubicom32_io_port *)RC;
57748 + struct ubicom32_io_port *ioh = (struct ubicom32_io_port *)RH;
57749 + unsigned int ctl;
57750 + unsigned int div = 0;
57751 + const u16_t mult[] = {64, 96, 128, 192, 256, 384, 512, 768, 1024};
57752 + int i;
57753 + int j;
57754 +
57755 +
57756 + for (i = 0; i < sizeof(mult) / sizeof(u16_t); i++) {
57757 + for (j = 0; j < cpd->n_mclk; j++) {
57758 + if (((unsigned int)rate * (unsigned int)mult[i]) ==
57759 + cpd->mclk_entries[j].rate) {
57760 + div = cpd->mclk_entries[j].div;
57761 + break;
57762 + }
57763 + }
57764 + }
57765 +
57766 + ctl = ((div - 1) << 16) | (div / 2);
57767 +
57768 + switch (cpd->mclk_src) {
57769 + case UBI32_CS4384_MCLK_PWM_0:
57770 + ioc->ctl1 = ctl;
57771 + return 0;
57772 +
57773 + case UBI32_CS4384_MCLK_PWM_1:
57774 + ioc->ctl2 = ctl;
57775 + return 0;
57776 +
57777 + case UBI32_CS4384_MCLK_PWM_2:
57778 + ioh->ctl1 = ctl;
57779 + return 0;
57780 +
57781 + case UBI32_CS4384_MCLK_CLKDIV_1:
57782 + ioa->ctl1 &= ~(0x7F << 14);
57783 + ioa->ctl1 |= ((div - 1) << 14);
57784 + return 0;
57785 +
57786 + case UBI32_CS4384_MCLK_OTHER:
57787 + return 0;
57788 + }
57789 +
57790 + return 1;
57791 +}
57792 +
57793 +/*
57794 + * snd_ubi32_cs4384_set_channels
57795 + * Mute unused channels
57796 + */
57797 +static int snd_ubi32_cs4384_set_channels(struct ubi32_snd_priv *priv, int channels)
57798 +{
57799 + struct i2c_client *client = (struct i2c_client *)priv->client;
57800 + struct snd_ubi32_cs4384_priv *cs4384_priv;
57801 + unsigned char send[2];
57802 + int ret;
57803 + int i;
57804 + unsigned long flags;
57805 +
57806 + /*
57807 + * Only support 0, 2, 4, 6, 8 channels
57808 + */
57809 + if ((channels > 8) || (channels & 1)) {
57810 + return -EINVAL;
57811 + }
57812 +
57813 + cs4384_priv = snd_ubi32_priv_get_drv(priv);
57814 + spin_lock_irqsave(&cs4384_priv->lock, flags);
57815 +
57816 + /*
57817 + * Address 09h, Mute control
57818 + */
57819 + send[0] = 0x09;
57820 + send[1] = (unsigned char)(0xFF << channels);
57821 +
57822 + ret = i2c_master_send(client, send, 2);
57823 +
57824 + spin_unlock_irqrestore(&cs4384_priv->lock, flags);
57825 +
57826 + /*
57827 + * Notify the system that we changed the mutes
57828 + */
57829 + cs4384_priv->mute = (unsigned char)(0xFF << channels);
57830 +
57831 + for (i = SND_UBI32_MUTE_CTL_START; i < SND_UBI32_MUTE_CTL_END; i++) {
57832 + snd_ctl_notify(priv->card, SNDRV_CTL_EVENT_MASK_VALUE,
57833 + &cs4384_priv->kctls[i]->id);
57834 + }
57835 +
57836 + if (ret != 2) {
57837 + return -ENXIO;
57838 + }
57839 +
57840 + return 0;
57841 +}
57842 +
57843 +/*
57844 + * snd_ubi32_cs4384_dac_init
57845 + */
57846 +static int snd_ubi32_cs4384_dac_init(struct i2c_client *client, const struct i2c_device_id *id)
57847 +{
57848 + int ret;
57849 + unsigned char send[2];
57850 + unsigned char recv[2];
57851 +
57852 + /*
57853 + * Initialize the CS4384 DAC over the I2C interface
57854 + */
57855 + snd_printk(KERN_INFO "Initializing CS4384 DAC\n");
57856 +
57857 + /*
57858 + * Register 0x01: device/revid
57859 + */
57860 + send[0] = 0x01;
57861 + ret = i2c_master_send(client, send, 1);
57862 + if (ret != 1) {
57863 + snd_printk(KERN_ERR "Failed 1st attempt to write to CS4384 register 0x01\n");
57864 + goto fail;
57865 + }
57866 + ret = i2c_master_recv(client, recv, 1);
57867 + if (ret != 1) {
57868 + snd_printk(KERN_ERR "Failed initial read of CS4384 registers\n");
57869 + goto fail;
57870 + }
57871 + snd_printk(KERN_INFO "CS4384 DAC Device/Rev: %08x\n", recv[0]);
57872 +
57873 + /*
57874 + * Register 0x02: Mode Control 1
57875 + * Control Port Enable, PCM, All DACs enabled, Power Down
57876 + */
57877 + send[0] = 0x02;
57878 + send[1] = 0x81;
57879 + ret = i2c_master_send(client, send, 2);
57880 + if (ret != 2) {
57881 + snd_printk(KERN_ERR "Failed to set CPEN CS4384\n");
57882 + goto fail;
57883 + }
57884 +
57885 + /*
57886 + * Register 0x08: Ramp and Mute
57887 + * RMP_UP, RMP_DN, PAMUTE, DAMUTE
57888 + */
57889 + send[0] = 0x08;
57890 + send[1] = 0xBC;
57891 + ret = i2c_master_send(client, send, 2);
57892 + if (ret != 2) {
57893 + snd_printk(KERN_ERR "Failed to set CPEN CS4384\n");
57894 + goto fail;
57895 + }
57896 +
57897 + /*
57898 + * Register 0x03: PCM Control
57899 + * I2S DIF[3:0] = 0001, no De-Emphasis, Auto speed mode
57900 + */
57901 + send[0] = 0x03;
57902 + send[1] = 0x13;
57903 + ret = i2c_master_send(client, send, 2);
57904 + if (ret != 2) {
57905 + snd_printk(KERN_ERR "Failed to set CS4384 to I2S mode\n");
57906 + goto fail;
57907 + }
57908 +
57909 + /*
57910 + * Register 0x0B/0x0C: Volume control A1/B1
57911 + * Register 0x0E/0x0F: Volume control A2/B2
57912 + * Register 0x11/0x12: Volume control A3/B3
57913 + * Register 0x14/0x15: Volume control A4/B4
57914 + */
57915 + send[0] = 0x80 | 0x0B;
57916 + send[1] = 0x00;
57917 + send[2] = 0x00;
57918 + ret = i2c_master_send(client, send, 3);
57919 + if (ret != 3) {
57920 + snd_printk(KERN_ERR "Failed to set ch1 volume on CS4384\n");
57921 + goto fail;
57922 + }
57923 +
57924 + send[0] = 0x80 | 0x0E;
57925 + send[1] = 0x00;
57926 + send[2] = 0x00;
57927 + ret = i2c_master_send(client, send, 3);
57928 + if (ret != 3) {
57929 + snd_printk(KERN_ERR "Failed to set ch2 volume on CS4384\n");
57930 + goto fail;
57931 + }
57932 +
57933 + send[0] = 0x80 | 0x11;
57934 + send[1] = 0x00;
57935 + send[2] = 0x00;
57936 + ret = i2c_master_send(client, send, 3);
57937 + if (ret != 3) {
57938 + snd_printk(KERN_ERR "Failed to set ch3 volume on CS4384\n");
57939 + goto fail;
57940 + }
57941 +
57942 + send[0] = 0x80 | 0x14;
57943 + send[1] = 0x00;
57944 + send[2] = 0x00;
57945 + ret = i2c_master_send(client, send, 3);
57946 + if (ret != 3) {
57947 + snd_printk(KERN_ERR "Failed to set ch4 volume on CS4384\n");
57948 + goto fail;
57949 + }
57950 +
57951 + /*
57952 + * Register 09h: Mute control
57953 + * Mute all (we will unmute channels as needed)
57954 + */
57955 + send[0] = 0x09;
57956 + send[1] = 0xFF;
57957 + ret = i2c_master_send(client, send, 2);
57958 + if (ret != 2) {
57959 + snd_printk(KERN_ERR "Failed to power up CS4384\n");
57960 + goto fail;
57961 + }
57962 +
57963 + /*
57964 + * Register 0x02: Mode Control 1
57965 + * Control Port Enable, PCM, All DACs enabled, Power Up
57966 + */
57967 + send[0] = 0x02;
57968 + send[1] = 0x80;
57969 + ret = i2c_master_send(client, send, 2);
57970 + if (ret != 2) {
57971 + snd_printk(KERN_ERR "Failed to power up CS4384\n");
57972 + goto fail;
57973 + }
57974 +
57975 + /*
57976 + * Make sure the changes took place, this helps verify we are talking to
57977 + * the correct chip.
57978 + */
57979 + send[0] = 0x80 | 0x03;
57980 + ret = i2c_master_send(client, send, 1);
57981 + if (ret != 1) {
57982 + snd_printk(KERN_ERR "Failed to initiate readback\n");
57983 + goto fail;
57984 + }
57985 +
57986 + ret = i2c_master_recv(client, recv, 1);
57987 + if (ret != 1) {
57988 + snd_printk(KERN_ERR "Failed second read of CS4384 registers\n");
57989 + goto fail;
57990 + }
57991 +
57992 + if (recv[0] != 0x13) {
57993 + snd_printk(KERN_ERR "Failed to initialize CS4384 DAC\n");
57994 + goto fail;
57995 + }
57996 +
57997 + snd_printk(KERN_INFO "CS4384 DAC Initialized\n");
57998 + return 0;
57999 +
58000 +fail:
58001 + return -ENODEV;
58002 +}
58003 +
58004 +/*
58005 + * snd_ubi32_cs4384_i2c_probe
58006 + */
58007 +static int snd_ubi32_cs4384_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
58008 +{
58009 + struct snd_card *card;
58010 + struct ubi32_snd_priv *ubi32_priv;
58011 + int err, ret;
58012 + struct platform_device *pdev;
58013 + struct ubi32_cs4384_platform_data *pdata;
58014 + struct snd_ubi32_cs4384_priv *cs4384_priv;
58015 +
58016 + /*
58017 + * pdev is audio device
58018 + */
58019 + pdev = client->dev.platform_data;
58020 + if (!pdev) {
58021 + return -ENODEV;
58022 + }
58023 +
58024 + /*
58025 + * pdev->dev.platform_data is ubi32-pcm platform_data
58026 + */
58027 + pdata = audio_device_priv(pdev);
58028 + if (!pdata) {
58029 + return -ENODEV;
58030 + }
58031 +
58032 + /*
58033 + * Initialize the CS4384 DAC
58034 + */
58035 + ret = snd_ubi32_cs4384_dac_init(client, id);
58036 + if (ret < 0) {
58037 + /*
58038 + * Initialization failed. Propagate the error.
58039 + */
58040 + return ret;
58041 + }
58042 +
58043 + if (snd_ubi32_cs4384_setup_mclk(pdata)) {
58044 + return -EINVAL;
58045 + }
58046 +
58047 + /*
58048 + * Create a snd_card structure
58049 + */
58050 + card = snd_card_new(index, "Ubi32-CS4384", THIS_MODULE, sizeof(struct ubi32_snd_priv));
58051 + if (card == NULL) {
58052 + return -ENOMEM;
58053 + }
58054 +
58055 + card->private_free = snd_ubi32_cs4384_free;
58056 + ubi32_priv = card->private_data;
58057 +
58058 + /*
58059 + * Initialize the snd_card's private data structure
58060 + */
58061 + ubi32_priv->card = card;
58062 + ubi32_priv->client = client;
58063 + ubi32_priv->set_channels = snd_ubi32_cs4384_set_channels;
58064 + ubi32_priv->set_rate = snd_ubi32_cs4384_set_rate;
58065 +
58066 + /*
58067 + * CS4384 DAC has a minimum sample rate of 4khz and an
58068 + * upper limit of 216khz for it's auto-detect.
58069 + */
58070 + ubi32_priv->min_sample_rate = 4000;
58071 + ubi32_priv->max_sample_rate = 216000;
58072 +
58073 + /*
58074 + * Create our private data (to manage volume, etc)
58075 + */
58076 + cs4384_priv = kzalloc(sizeof(struct snd_ubi32_cs4384_priv), GFP_KERNEL);
58077 + if (!cs4384_priv) {
58078 + snd_card_free(card);
58079 + return -ENOMEM;
58080 + }
58081 + snd_ubi32_priv_set_drv(ubi32_priv, cs4384_priv);
58082 + spin_lock_init(&cs4384_priv->lock);
58083 +
58084 + /*
58085 + * We start off all muted and max volume
58086 + */
58087 + cs4384_priv->mute = 0xFF;
58088 + memset(cs4384_priv->volume, 0xFF, 8);
58089 +
58090 + /*
58091 + * Create the new PCM instance
58092 + */
58093 + err = snd_ubi32_pcm_probe(ubi32_priv, pdev);
58094 + if (err < 0) {
58095 + snd_card_free(card);
58096 + return err; /* What is err? Need to include correct file */
58097 + }
58098 +
58099 + strcpy(card->driver, "Ubi32-CS4384");
58100 + strcpy(card->shortname, "Ubi32-CS4384");
58101 + snprintf(card->longname, sizeof(card->longname),
58102 + "%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
58103 + card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
58104 + ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
58105 +
58106 + snd_card_set_dev(card, &client->dev);
58107 +
58108 + /*
58109 + * Set up the mixer
58110 + */
58111 + snd_ubi32_cs4384_mixer(ubi32_priv);
58112 +
58113 + /*
58114 + * Register the sound card
58115 + */
58116 + if ((err = snd_card_register(card)) != 0) {
58117 + snd_printk(KERN_INFO "snd_card_register error\n");
58118 + }
58119 +
58120 + /*
58121 + * Store card for access from other methods
58122 + */
58123 + i2c_set_clientdata(client, card);
58124 +
58125 + return 0;
58126 +}
58127 +
58128 +/*
58129 + * snd_ubi32_cs4384_i2c_remove
58130 + */
58131 +static int __devexit snd_ubi32_cs4384_i2c_remove(struct i2c_client *client)
58132 +{
58133 + struct snd_card *card;
58134 + struct ubi32_snd_priv *ubi32_priv;
58135 +
58136 + card = i2c_get_clientdata(client);
58137 +
58138 + ubi32_priv = card->private_data;
58139 + snd_ubi32_pcm_remove(ubi32_priv);
58140 +
58141 + snd_card_free(i2c_get_clientdata(client));
58142 + i2c_set_clientdata(client, NULL);
58143 +
58144 + return 0;
58145 +}
58146 +
58147 +/*
58148 + * I2C driver description
58149 + */
58150 +static struct i2c_driver snd_ubi32_cs4384_driver = {
58151 + .driver = {
58152 + .name = DRIVER_NAME,
58153 + .owner = THIS_MODULE,
58154 + },
58155 + .id_table = snd_ubi32_cs4384_id,
58156 + .probe = snd_ubi32_cs4384_i2c_probe,
58157 + .remove = __devexit_p(snd_ubi32_cs4384_i2c_remove),
58158 +};
58159 +
58160 +/*
58161 + * Driver init
58162 + */
58163 +static int __init snd_ubi32_cs4384_init(void)
58164 +{
58165 + return i2c_add_driver(&snd_ubi32_cs4384_driver);
58166 +}
58167 +module_init(snd_ubi32_cs4384_init);
58168 +
58169 +/*
58170 + * snd_ubi32_cs4384_exit
58171 + */
58172 +static void __exit snd_ubi32_cs4384_exit(void)
58173 +{
58174 + i2c_del_driver(&snd_ubi32_cs4384_driver);
58175 +}
58176 +module_exit(snd_ubi32_cs4384_exit);
58177 +
58178 +/*
58179 + * Module properties
58180 + */
58181 +MODULE_ALIAS("i2c:" DRIVER_NAME);
58182 +MODULE_AUTHOR("Patrick Tjin");
58183 +MODULE_DESCRIPTION("Driver for Ubicom32 audio devices CS4384");
58184 +MODULE_LICENSE("GPL");
58185 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32-generic.c linux-2.6.30.10-ubi/sound/ubicom32/ubi32-generic.c
58186 --- linux-2.6.30.10/sound/ubicom32/ubi32-generic.c 1970-01-01 02:00:00.000000000 +0200
58187 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32-generic.c 2009-12-11 11:45:25.000000000 +0200
58188 @@ -0,0 +1,166 @@
58189 +/*
58190 + * sound/ubicom32/ubi32-generic.c
58191 + * Interface to ubicom32 virtual audio peripheral
58192 + *
58193 + * (C) Copyright 2009, Ubicom, Inc.
58194 + *
58195 + * This file is part of the Ubicom32 Linux Kernel Port.
58196 + *
58197 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
58198 + * it and/or modify it under the terms of the GNU General Public License
58199 + * as published by the Free Software Foundation, either version 2 of the
58200 + * License, or (at your option) any later version.
58201 + *
58202 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
58203 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
58204 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
58205 + * the GNU General Public License for more details.
58206 + *
58207 + * You should have received a copy of the GNU General Public License
58208 + * along with the Ubicom32 Linux Kernel Port. If not,
58209 + * see <http://www.gnu.org/licenses/>.
58210 + *
58211 + * Ubicom32 implementation derived from (with many thanks):
58212 + * arch/m68knommu
58213 + * arch/blackfin
58214 + * arch/parisc
58215 + */
58216 +
58217 +#include <linux/platform_device.h>
58218 +#include <linux/module.h>
58219 +#include <linux/moduleparam.h>
58220 +#include <sound/core.h>
58221 +#include <sound/pcm.h>
58222 +#include <sound/initval.h>
58223 +#include "ubi32.h"
58224 +
58225 +#define DRIVER_NAME "snd-ubi32-generic"
58226 +
58227 +/*
58228 + * Module properties
58229 + */
58230 +static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
58231 +
58232 +/*
58233 + * Card private data free function
58234 + */
58235 +void snd_ubi32_generic_free(struct snd_card *card)
58236 +{
58237 + /*
58238 + * Free all the fields in the snd_ubi32_priv struct
58239 + */
58240 + // Nothing to free at this time because ubi32_priv just maintains pointers
58241 +}
58242 +
58243 +/*
58244 + * Ubicom audio driver probe() method. Args change depending on whether we use
58245 + * platform_device or i2c_device.
58246 + */
58247 +static int snd_ubi32_generic_probe(struct platform_device *dev)
58248 +{
58249 + struct snd_card *card;
58250 + struct ubi32_snd_priv *ubi32_priv;
58251 + int err;
58252 +
58253 + /*
58254 + * Create a snd_card structure
58255 + */
58256 + card = snd_card_new(index, "Ubi32-Generic", THIS_MODULE, sizeof(struct ubi32_snd_priv));
58257 +
58258 + if (card == NULL) {
58259 + return -ENOMEM;
58260 + }
58261 +
58262 + card->private_free = snd_ubi32_generic_free; /* Not sure if correct */
58263 + ubi32_priv = card->private_data;
58264 +
58265 + /*
58266 + * Initialize the snd_card's private data structure
58267 + */
58268 + ubi32_priv->card = card;
58269 +
58270 + /*
58271 + * Create the new PCM instance
58272 + */
58273 + err = snd_ubi32_pcm_probe(ubi32_priv, dev);
58274 + if (err < 0) {
58275 + snd_card_free(card);
58276 + return err;
58277 + }
58278 +
58279 + strcpy(card->driver, "Ubi32-Generic");
58280 + strcpy(card->shortname, "Ubi32-Generic");
58281 + snprintf(card->longname, sizeof(card->longname),
58282 + "%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
58283 + card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
58284 + ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
58285 +
58286 + snd_card_set_dev(card, &dev->dev);
58287 +
58288 + /* Register the sound card */
58289 + if ((err = snd_card_register(card)) != 0) {
58290 + snd_printk(KERN_INFO "snd_card_register error\n");
58291 + }
58292 +
58293 + /* Store card for access from other methods */
58294 + platform_set_drvdata(dev, card);
58295 +
58296 + return 0;
58297 +}
58298 +
58299 +/*
58300 + * Ubicom audio driver remove() method
58301 + */
58302 +static int __devexit snd_ubi32_generic_remove(struct platform_device *dev)
58303 +{
58304 + struct snd_card *card;
58305 + struct ubi32_snd_priv *ubi32_priv;
58306 +
58307 + card = platform_get_drvdata(dev);
58308 + ubi32_priv = card->private_data;
58309 + snd_ubi32_pcm_remove(ubi32_priv);
58310 +
58311 + snd_card_free(platform_get_drvdata(dev));
58312 + platform_set_drvdata(dev, NULL);
58313 + return 0;
58314 +}
58315 +
58316 +/*
58317 + * Platform driver definition
58318 + */
58319 +static struct platform_driver snd_ubi32_generic_driver = {
58320 + .driver = {
58321 + .name = DRIVER_NAME,
58322 + .owner = THIS_MODULE,
58323 + },
58324 + .probe = snd_ubi32_generic_probe,
58325 + .remove = __devexit_p(snd_ubi32_generic_remove),
58326 +};
58327 +
58328 +/*
58329 + * snd_ubi32_generic_init
58330 + */
58331 +static int __init snd_ubi32_generic_init(void)
58332 +{
58333 + return platform_driver_register(&snd_ubi32_generic_driver);
58334 +}
58335 +module_init(snd_ubi32_generic_init);
58336 +
58337 +/*
58338 + * snd_ubi32_generic_exit
58339 + */
58340 +static void __exit snd_ubi32_generic_exit(void)
58341 +{
58342 + platform_driver_unregister(&snd_ubi32_generic_driver);
58343 +}
58344 +module_exit(snd_ubi32_generic_exit);
58345 +
58346 +/*
58347 + * Module properties
58348 + */
58349 +//#if defined(CONFIG_SND_UBI32_AUDIO_I2C)
58350 +//MODULE_ALIAS("i2c:snd-ubi32");
58351 +//#endif
58352 +MODULE_AUTHOR("Aaron Jow, Patrick Tjin");
58353 +MODULE_DESCRIPTION("Driver for Ubicom32 audio devices");
58354 +MODULE_LICENSE("GPL");
58355 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32-generic-capture.c linux-2.6.30.10-ubi/sound/ubicom32/ubi32-generic-capture.c
58356 --- linux-2.6.30.10/sound/ubicom32/ubi32-generic-capture.c 1970-01-01 02:00:00.000000000 +0200
58357 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32-generic-capture.c 2009-12-11 11:45:25.000000000 +0200
58358 @@ -0,0 +1,167 @@
58359 +/*
58360 + * sound/ubicom32/ubi32-generic-capture.c
58361 + * Interface to ubicom32 virtual audio peripheral
58362 + *
58363 + * (C) Copyright 2009, Ubicom, Inc.
58364 + *
58365 + * This file is part of the Ubicom32 Linux Kernel Port.
58366 + *
58367 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
58368 + * it and/or modify it under the terms of the GNU General Public License
58369 + * as published by the Free Software Foundation, either version 2 of the
58370 + * License, or (at your option) any later version.
58371 + *
58372 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
58373 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
58374 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
58375 + * the GNU General Public License for more details.
58376 + *
58377 + * You should have received a copy of the GNU General Public License
58378 + * along with the Ubicom32 Linux Kernel Port. If not,
58379 + * see <http://www.gnu.org/licenses/>.
58380 + *
58381 + * Ubicom32 implementation derived from (with many thanks):
58382 + * arch/m68knommu
58383 + * arch/blackfin
58384 + * arch/parisc
58385 + */
58386 +
58387 +#include <linux/platform_device.h>
58388 +#include <linux/module.h>
58389 +#include <linux/moduleparam.h>
58390 +#include <sound/core.h>
58391 +#include <sound/pcm.h>
58392 +#include <sound/initval.h>
58393 +#include "ubi32.h"
58394 +
58395 +#define DRIVER_NAME "snd-ubi32-generic-capture"
58396 +
58397 +/*
58398 + * Module properties
58399 + */
58400 +static int index = SNDRV_DEFAULT_IDX1; /* Index 0-MAX */
58401 +
58402 +/*
58403 + * Card private data free function
58404 + */
58405 +void snd_ubi32_generic_capture_free(struct snd_card *card)
58406 +{
58407 + /*
58408 + * Free all the fields in the snd_ubi32_priv struct
58409 + */
58410 + // Nothing to free at this time because ubi32_priv just maintains pointers
58411 +}
58412 +
58413 +/*
58414 + * Ubicom audio driver probe() method. Args change depending on whether we use
58415 + * platform_device or i2c_device.
58416 + */
58417 +static int snd_ubi32_generic_capture_probe(struct platform_device *dev)
58418 +{
58419 + struct snd_card *card;
58420 + struct ubi32_snd_priv *ubi32_priv;
58421 + int err;
58422 +
58423 + /*
58424 + * Create a snd_card structure
58425 + */
58426 + card = snd_card_new(index, "Ubi32-Generic-C", THIS_MODULE, sizeof(struct ubi32_snd_priv));
58427 +
58428 + if (card == NULL) {
58429 + return -ENOMEM;
58430 + }
58431 +
58432 + card->private_free = snd_ubi32_generic_capture_free; /* Not sure if correct */
58433 + ubi32_priv = card->private_data;
58434 +
58435 + /*
58436 + * Initialize the snd_card's private data structure
58437 + */
58438 + ubi32_priv->card = card;
58439 + ubi32_priv->is_capture = 1;
58440 +
58441 + /*
58442 + * Create the new PCM instance
58443 + */
58444 + err = snd_ubi32_pcm_probe(ubi32_priv, dev);
58445 + if (err < 0) {
58446 + snd_card_free(card);
58447 + return err;
58448 + }
58449 +
58450 + strcpy(card->driver, "Ubi32-Generic-C");
58451 + strcpy(card->shortname, "Ubi32-Generic-C");
58452 + snprintf(card->longname, sizeof(card->longname),
58453 + "%s at sendirq=%d.%d recvirq=%d.%d regs=%p",
58454 + card->shortname, ubi32_priv->tx_irq, ubi32_priv->irq_idx,
58455 + ubi32_priv->rx_irq, ubi32_priv->irq_idx, ubi32_priv->adr);
58456 +
58457 + snd_card_set_dev(card, &dev->dev);
58458 +
58459 + /* Register the sound card */
58460 + if ((err = snd_card_register(card)) != 0) {
58461 + snd_printk(KERN_INFO "snd_card_register error\n");
58462 + }
58463 +
58464 + /* Store card for access from other methods */
58465 + platform_set_drvdata(dev, card);
58466 +
58467 + return 0;
58468 +}
58469 +
58470 +/*
58471 + * Ubicom audio driver remove() method
58472 + */
58473 +static int __devexit snd_ubi32_generic_capture_remove(struct platform_device *dev)
58474 +{
58475 + struct snd_card *card;
58476 + struct ubi32_snd_priv *ubi32_priv;
58477 +
58478 + card = platform_get_drvdata(dev);
58479 + ubi32_priv = card->private_data;
58480 + snd_ubi32_pcm_remove(ubi32_priv);
58481 +
58482 + snd_card_free(platform_get_drvdata(dev));
58483 + platform_set_drvdata(dev, NULL);
58484 + return 0;
58485 +}
58486 +
58487 +/*
58488 + * Platform driver definition
58489 + */
58490 +static struct platform_driver snd_ubi32_generic_capture_driver = {
58491 + .driver = {
58492 + .name = DRIVER_NAME,
58493 + .owner = THIS_MODULE,
58494 + },
58495 + .probe = snd_ubi32_generic_capture_probe,
58496 + .remove = __devexit_p(snd_ubi32_generic_capture_remove),
58497 +};
58498 +
58499 +/*
58500 + * snd_ubi32_generic_capture_init
58501 + */
58502 +static int __init snd_ubi32_generic_capture_init(void)
58503 +{
58504 + return platform_driver_register(&snd_ubi32_generic_capture_driver);
58505 +}
58506 +module_init(snd_ubi32_generic_capture_init);
58507 +
58508 +/*
58509 + * snd_ubi32_generic_capture_exit
58510 + */
58511 +static void __exit snd_ubi32_generic_capture_exit(void)
58512 +{
58513 + platform_driver_unregister(&snd_ubi32_generic_capture_driver);
58514 +}
58515 +module_exit(snd_ubi32_generic_capture_exit);
58516 +
58517 +/*
58518 + * Module properties
58519 + */
58520 +//#if defined(CONFIG_SND_UBI32_AUDIO_I2C)
58521 +//MODULE_ALIAS("i2c:snd-ubi32");
58522 +//#endif
58523 +MODULE_AUTHOR("Patrick Tjin");
58524 +MODULE_DESCRIPTION("Driver for Ubicom32 audio devices");
58525 +MODULE_LICENSE("GPL");
58526 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32.h linux-2.6.30.10-ubi/sound/ubicom32/ubi32.h
58527 --- linux-2.6.30.10/sound/ubicom32/ubi32.h 1970-01-01 02:00:00.000000000 +0200
58528 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32.h 2009-12-11 11:45:25.000000000 +0200
58529 @@ -0,0 +1,102 @@
58530 +/*
58531 + * sound/ubicom32/ubi32.h
58532 + * Common header file for all ubi32- sound drivers
58533 + *
58534 + * (C) Copyright 2009, Ubicom, Inc.
58535 + *
58536 + * This file is part of the Ubicom32 Linux Kernel Port.
58537 + *
58538 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
58539 + * it and/or modify it under the terms of the GNU General Public License
58540 + * as published by the Free Software Foundation, either version 2 of the
58541 + * License, or (at your option) any later version.
58542 + *
58543 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
58544 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
58545 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
58546 + * the GNU General Public License for more details.
58547 + *
58548 + * You should have received a copy of the GNU General Public License
58549 + * along with the Ubicom32 Linux Kernel Port. If not,
58550 + * see <http://www.gnu.org/licenses/>.
58551 + */
58552 +
58553 +#ifndef _UBI32_H
58554 +#define _UBI32_H
58555 +
58556 +#define SND_UBI32_DEBUG 0 // Debug flag
58557 +
58558 +#include <linux/platform_device.h>
58559 +#include <asm/devtree.h>
58560 +#include <asm/audio.h>
58561 +#include <asm/ubi32-pcm.h>
58562 +
58563 +struct ubi32_snd_priv;
58564 +
58565 +typedef int (*set_channels_t)(struct ubi32_snd_priv *priv, int channels);
58566 +typedef int (*set_rate_t)(struct ubi32_snd_priv *priv, int rate);
58567 +
58568 +struct ubi32_snd_priv {
58569 + /*
58570 + * Any variables that are needed locally here but NOT in
58571 + * the VP itself should go in here.
58572 + */
58573 + struct snd_card *card;
58574 + struct snd_pcm *pcm;
58575 +
58576 + /*
58577 + * capture (1) or playback (0)
58578 + */
58579 + int is_capture;
58580 + /*
58581 + * DAC parameters. These are the parameters for the specific
58582 + * DAC we are driving. The I2S component can run at a range
58583 + * of frequencies, but the DAC may be limited. We may want
58584 + * to make this an array of some sort in the future?
58585 + *
58586 + * min/max_sample_rate if set to 0 are ignored.
58587 + */
58588 + int max_sample_rate;
58589 + int min_sample_rate;
58590 +
58591 + /*
58592 + * The size a period (group) of audio samples. The VP does
58593 + * not need to know this; each DMA transfer is made to be
58594 + * one period.
58595 + */
58596 + u32_t period_size;
58597 +
58598 + spinlock_t ubi32_lock;
58599 +
58600 + struct audio_regs *ar;
58601 + struct audio_dev_regs *adr;
58602 + u32 irq_idx;
58603 + u8 tx_irq;
58604 + u8 rx_irq;
58605 +
58606 + void *client;
58607 +
58608 + /*
58609 + * Operations which the base DAC driver can implement
58610 + */
58611 + set_channels_t set_channels;
58612 + set_rate_t set_rate;
58613 +
58614 + /*
58615 + * platform data
58616 + */
58617 + struct ubi32pcm_platform_data *pdata;
58618 +
58619 + /*
58620 + * Private driver data (used for DAC driver control, etc)
58621 + */
58622 + void *drvdata;
58623 +};
58624 +
58625 +#define snd_ubi32_priv_get_drv(priv) ((priv)->drvdata)
58626 +#define snd_ubi32_priv_set_drv(priv, data) (((priv)->drvdata) = (void *)(data))
58627 +
58628 +extern int snd_ubi32_pcm_probe(struct ubi32_snd_priv *ubi32_priv, struct platform_device *pdev);
58629 +extern void snd_ubi32_pcm_remove(struct ubi32_snd_priv *ubi32_priv);
58630 +
58631 +#endif
58632 diff -ruN linux-2.6.30.10/sound/ubicom32/ubi32-pcm.c linux-2.6.30.10-ubi/sound/ubicom32/ubi32-pcm.c
58633 --- linux-2.6.30.10/sound/ubicom32/ubi32-pcm.c 1970-01-01 02:00:00.000000000 +0200
58634 +++ linux-2.6.30.10-ubi/sound/ubicom32/ubi32-pcm.c 2009-12-11 11:45:25.000000000 +0200
58635 @@ -0,0 +1,711 @@
58636 +/*
58637 + * sound/ubicom32/ubi32-pcm.c
58638 + * Interface to ubicom32 virtual audio peripheral
58639 + *
58640 + * (C) Copyright 2009, Ubicom, Inc.
58641 + *
58642 + * This file is part of the Ubicom32 Linux Kernel Port.
58643 + *
58644 + * The Ubicom32 Linux Kernel Port is free software: you can redistribute
58645 + * it and/or modify it under the terms of the GNU General Public License
58646 + * as published by the Free Software Foundation, either version 2 of the
58647 + * License, or (at your option) any later version.
58648 + *
58649 + * The Ubicom32 Linux Kernel Port is distributed in the hope that it
58650 + * will be useful, but WITHOUT ANY WARRANTY; without even the implied
58651 + * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
58652 + * the GNU General Public License for more details.
58653 + *
58654 + * You should have received a copy of the GNU General Public License
58655 + * along with the Ubicom32 Linux Kernel Port. If not,
58656 + * see <http://www.gnu.org/licenses/>.
58657 + *
58658 + * Ubicom32 implementation derived from (with many thanks):
58659 + * arch/m68knommu
58660 + * arch/blackfin
58661 + * arch/parisc
58662 + */
58663 +
58664 +#include <linux/interrupt.h>
58665 +#include <sound/core.h>
58666 +#include <sound/pcm.h>
58667 +#include <sound/pcm_params.h>
58668 +#include <asm/ip5000.h>
58669 +#include <asm/ubi32-pcm.h>
58670 +#include <linux/dma-mapping.h>
58671 +#include <linux/delay.h>
58672 +#include "ubi32.h"
58673 +
58674 +struct ubi32_snd_runtime_data {
58675 + dma_addr_t dma_buffer; /* Physical address of DMA buffer */
58676 + dma_addr_t dma_buffer_end; /* First address beyond end of DMA buffer */
58677 + size_t period_size;
58678 + dma_addr_t period_ptr; /* Physical address of next period */
58679 + unsigned int flags;
58680 +};
58681 +
58682 +static void snd_ubi32_vp_int_set(struct snd_pcm *pcm)
58683 +{
58684 + struct ubi32_snd_priv *ubi32_priv = pcm->private_data;
58685 + ubi32_priv->ar->int_req |= (1 << ubi32_priv->irq_idx);
58686 + ubicom32_set_interrupt(ubi32_priv->tx_irq);
58687 +}
58688 +
58689 +static snd_pcm_uframes_t snd_ubi32_pcm_pointer(struct snd_pcm_substream *substream)
58690 +{
58691 +
58692 + struct ubi32_snd_priv *ubi32_priv = snd_pcm_substream_chip(substream);
58693 + struct audio_dev_regs *adr = ubi32_priv->adr;
58694 + struct snd_pcm_runtime *runtime = substream->runtime;
58695 + struct ubi32_snd_runtime_data *ubi32_rd = substream->runtime->private_data;
58696 +
58697 + dma_addr_t read_pos;
58698 +
58699 + snd_pcm_uframes_t frames;
58700 + if (!adr->primary_os_buffer_ptr) {
58701 + /*
58702 + * If primary_os_buffer_ptr is NULL (e.g. right after the HW is started or
58703 + * when the HW is stopped), then handle this case separately.
58704 + */
58705 + return 0;
58706 + }
58707 +
58708 + read_pos = (dma_addr_t)adr->primary_os_buffer_ptr;
58709 + frames = bytes_to_frames(runtime, read_pos - ubi32_rd->dma_buffer);
58710 + if (frames == runtime->buffer_size) {
58711 + frames = 0;
58712 + }
58713 + return frames;
58714 +}
58715 +
58716 +/*
58717 + * Audio trigger
58718 + */
58719 +static int snd_ubi32_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
58720 +{
58721 + struct ubi32_snd_priv *ubi32_priv = substream->pcm->private_data;
58722 + struct audio_dev_regs *adr = ubi32_priv->adr;
58723 + struct ubi32_snd_runtime_data *ubi32_rd = substream->runtime->private_data;
58724 + int ret = 0;
58725 +
58726 +#ifdef CONFIG_SND_DEBUG
58727 + snd_printk(KERN_INFO "snd_ubi32_pcm_trigger cmd=%d=", cmd);
58728 +#endif
58729 +
58730 + if (adr->command != AUDIO_CMD_NONE) {
58731 + snd_printk(KERN_WARNING "Can't send command to audio device at this time\n");
58732 + // Set a timer to call this function back later. How to do this?
58733 + return 0;
58734 + }
58735 +
58736 + /*
58737 + * Set interrupt flag to indicate that we interrupted audio device
58738 + * to send a command
58739 + */
58740 +
58741 + switch (cmd) {
58742 + case SNDRV_PCM_TRIGGER_START:
58743 +
58744 +#ifdef CONFIG_SND_DEBUG
58745 + snd_printk(KERN_INFO "START\n");
58746 +#endif
58747 + /*
58748 + * Ready the DMA transfer
58749 + */
58750 + ubi32_rd->period_ptr = ubi32_rd->dma_buffer;
58751 +
58752 +#ifdef CONFIG_SND_DEBUG
58753 + snd_printk(KERN_INFO "trigger period_ptr=%lx\n", (unsigned long)ubi32_rd->period_ptr);
58754 +#endif
58755 + adr->dma_xfer_requests[0].ptr = (void *)ubi32_rd->period_ptr;
58756 + adr->dma_xfer_requests[0].ctr = ubi32_rd->period_size;
58757 + adr->dma_xfer_requests[0].active = 1;
58758 +
58759 +#ifdef CONFIG_SND_DEBUG
58760 + snd_printk(KERN_INFO "xfer_request 0 ptr=0x%x ctr=%u\n", ubi32_rd->period_ptr, ubi32_rd->period_size);
58761 +#endif
58762 +
58763 + ubi32_rd->period_ptr += ubi32_rd->period_size;
58764 + adr->dma_xfer_requests[1].ptr = (void *)ubi32_rd->period_ptr;
58765 + adr->dma_xfer_requests[1].ctr = ubi32_rd->period_size;
58766 + adr->dma_xfer_requests[1].active = 1;
58767 +
58768 +#ifdef CONFIG_SND_DEBUG
58769 + snd_printk(KERN_INFO "xfer_request 1 ptr=0x%x ctr=%u\n", ubi32_rd->period_ptr, ubi32_rd->period_size);
58770 +#endif
58771 +
58772 + /*
58773 + * Tell the VP that we want to begin playback by filling in the
58774 + * command field and then interrupting the audio VP
58775 + */
58776 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58777 + adr->command = AUDIO_CMD_START;
58778 + snd_ubi32_vp_int_set(substream->pcm);
58779 + break;
58780 +
58781 + case SNDRV_PCM_TRIGGER_STOP:
58782 +
58783 +#ifdef CONFIG_SND_DEBUG
58784 + snd_printk(KERN_INFO "STOP\n");
58785 +#endif
58786 +
58787 + /*
58788 + * Tell the VP that we want to stop playback by filling in the
58789 + * command field and then interrupting the audio VP
58790 + */
58791 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58792 + adr->command = AUDIO_CMD_STOP;
58793 + snd_ubi32_vp_int_set(substream->pcm);
58794 + break;
58795 +
58796 + case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
58797 +
58798 +#ifdef CONFIG_SND_DEBUG
58799 + snd_printk(KERN_INFO "PAUSE_PUSH\n");
58800 +#endif
58801 +
58802 + /*
58803 + * Tell the VP that we want to pause playback by filling in the
58804 + * command field and then interrupting the audio VP
58805 + */
58806 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58807 + adr->command = AUDIO_CMD_PAUSE;
58808 + snd_ubi32_vp_int_set(substream->pcm);
58809 + break;
58810 +
58811 + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
58812 +
58813 +#ifdef CONFIG_SND_DEBUG
58814 + snd_printk(KERN_INFO "PAUSE_RELEASE\n");
58815 +#endif
58816 + /*
58817 + * Tell the VP that we want to resume paused playback by filling
58818 + * in the command field and then interrupting the audio VP
58819 + */
58820 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58821 + adr->command = AUDIO_CMD_RESUME;
58822 + snd_ubi32_vp_int_set(substream->pcm);
58823 + break;
58824 +
58825 + default:
58826 + snd_printk(KERN_WARNING "Unhandled trigger\n");
58827 + ret = -EINVAL;
58828 + break;
58829 + }
58830 +
58831 + return ret;
58832 +}
58833 +
58834 +/*
58835 + * Prepare to transfer an audio stream to the codec
58836 + */
58837 +static int snd_ubi32_pcm_prepare(struct snd_pcm_substream *substream)
58838 +{
58839 + /*
58840 + * Configure registers and setup the runtime instance for DMA transfers
58841 + */
58842 + struct ubi32_snd_priv *ubi32_priv = substream->pcm->private_data;
58843 + struct audio_dev_regs *adr = ubi32_priv->adr;
58844 +
58845 +#ifdef CONFIG_SND_DEBUG
58846 + snd_printk(KERN_INFO "snd_ubi32_pcm_prepare: sending STOP command to audio device\n");
58847 +#endif
58848 +
58849 + /*
58850 + * Make sure the audio device is stopped
58851 + */
58852 +
58853 + /*
58854 + * Set interrupt flag to indicate that we interrupted audio device
58855 + * to send a command
58856 + */
58857 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58858 + adr->command = AUDIO_CMD_STOP;
58859 + snd_ubi32_vp_int_set(substream->pcm);
58860 +
58861 + return 0;
58862 +}
58863 +
58864 +/*
58865 + * Allocate DMA buffers from preallocated memory.
58866 + * Preallocation was done in snd_ubi32_pcm_new()
58867 + */
58868 +static int snd_ubi32_pcm_hw_params(struct snd_pcm_substream *substream,
58869 + struct snd_pcm_hw_params *hw_params)
58870 +{
58871 + struct snd_pcm_runtime *runtime = substream->runtime;
58872 + struct ubi32_snd_priv *ubi32_priv = substream->pcm->private_data;
58873 + struct audio_dev_regs *adr = ubi32_priv->adr;
58874 + struct ubi32_snd_runtime_data *ubi32_rd = substream->runtime->private_data;
58875 +
58876 + /*
58877 + * Use pre-allocated memory from ubi32_snd_pcm_new() to satisfy
58878 + * this memory request.
58879 + */
58880 + int ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
58881 + if (ret < 0) {
58882 + return ret;
58883 + }
58884 +
58885 +#ifdef CONFIG_SND_DEBUG
58886 + snd_printk(KERN_INFO "snd_ubi32_pcm_hw_params\n");
58887 +#endif
58888 +
58889 + if (!(adr->channel_mask & (1 << params_channels(hw_params)))) {
58890 + snd_printk(KERN_INFO "snd_ubi32_pcm_hw_params unsupported number of channels %d mask %08x\n", params_channels(hw_params), adr->channel_mask);
58891 + return -EINVAL;
58892 + }
58893 +
58894 + if (ubi32_priv->set_channels) {
58895 + int ret = ubi32_priv->set_channels(ubi32_priv, params_channels(hw_params));
58896 + if (ret) {
58897 + snd_printk(KERN_WARNING "Unable to set channels to %d, ret=%d\n", params_channels(hw_params), ret);
58898 + return ret;
58899 + }
58900 + }
58901 +
58902 + if (ubi32_priv->set_rate) {
58903 + int ret = ubi32_priv->set_rate(ubi32_priv, params_rate(hw_params));
58904 + if (ret) {
58905 + snd_printk(KERN_WARNING "Unable to set rate to %d, ret=%d\n", params_rate(hw_params), ret);
58906 + return ret;
58907 + }
58908 + }
58909 +
58910 + if (ubi32_priv->pdata->set_rate) {
58911 + int ret = ubi32_priv->pdata->set_rate(ubi32_priv->pdata->appdata, params_rate(hw_params));
58912 + if (ret) {
58913 + snd_printk(KERN_WARNING "Unable to set rate to %d, ret=%d\n", params_rate(hw_params), ret);
58914 + return ret;
58915 + }
58916 + }
58917 +
58918 + if (adr->command != AUDIO_CMD_NONE) {
58919 + snd_printk(KERN_WARNING "snd_ubi32_pcm_hw_params: tio busy\n");
58920 + return -EAGAIN;
58921 + }
58922 +
58923 + if (params_format(hw_params) == SNDRV_PCM_FORMAT_S16_LE) {
58924 + adr->flags |= CMD_START_FLAG_LE;
58925 + } else {
58926 + adr->flags &= ~CMD_START_FLAG_LE;
58927 + }
58928 + adr->channels = params_channels(hw_params);
58929 + adr->sample_rate = params_rate(hw_params);
58930 + adr->command = AUDIO_CMD_SETUP;
58931 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
58932 + snd_ubi32_vp_int_set(substream->pcm);
58933 +
58934 + /*
58935 + * Wait for the command to complete
58936 + */
58937 + while (adr->command != AUDIO_CMD_NONE) {
58938 + udelay(1);
58939 + }
58940 +
58941 + /*
58942 + * Put the DMA info into the DMA descriptor that we will
58943 + * use to do transfers to our audio VP "hardware"
58944 + */
58945 +
58946 + /*
58947 + * Mark both DMA transfers as not ready/inactive
58948 + */
58949 + adr->dma_xfer_requests[0].active = 0;
58950 + adr->dma_xfer_requests[1].active = 0;
58951 +
58952 + /*
58953 + * Put the location of the buffer into the runtime data instance
58954 + */
58955 + ubi32_rd->dma_buffer = (dma_addr_t)runtime->dma_area;
58956 + ubi32_rd->dma_buffer_end = (dma_addr_t)(runtime->dma_area + runtime->dma_bytes);
58957 +
58958 + /*
58959 + * Get the period size
58960 + */
58961 + ubi32_rd->period_size = params_period_bytes(hw_params);
58962 +
58963 +#ifdef CONFIG_SND_DEBUG
58964 + snd_printk(KERN_INFO "DMA for ubi32 audio initialized dma_area=0x%x dma_bytes=%d, period_size=%d\n", (unsigned int)runtime->dma_area, (unsigned int)runtime->dma_bytes, ubi32_rd->period_size);
58965 + snd_printk(KERN_INFO "Private buffer ubi32_rd: dma_buffer=0x%x dma_buffer_end=0x%x ret=%d\n", ubi32_rd->dma_buffer, ubi32_rd->dma_buffer_end, ret);
58966 +#endif
58967 +
58968 + return ret;
58969 +}
58970 +
58971 +/*
58972 + * This is the reverse of snd_ubi32_pcm_hw_params
58973 + */
58974 +static int snd_ubi32_pcm_hw_free(struct snd_pcm_substream *substream)
58975 +{
58976 +#ifdef CONFIG_SND_DEBUG
58977 + snd_printk(KERN_INFO "snd_ubi32_pcm_hw_free\n");
58978 +#endif
58979 + return snd_pcm_lib_free_pages(substream);
58980 +}
58981 +
58982 +/*
58983 + * Audio virtual peripheral capabilities (capture and playback are identical)
58984 + */
58985 +static struct snd_pcm_hardware snd_ubi32_pcm_hw =
58986 +{
58987 + .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
58988 + SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME),
58989 + .buffer_bytes_max = (64*1024),
58990 + .period_bytes_min = 64,
58991 + .period_bytes_max = 8184,//8184,//8176,
58992 + .periods_min = 2,
58993 + .periods_max = 255,
58994 + .fifo_size = 0, // THIS IS IGNORED BY ALSA
58995 +};
58996 +
58997 +/*
58998 + * We fill this in later
58999 + */
59000 +static struct snd_pcm_hw_constraint_list ubi32_pcm_rates;
59001 +
59002 +/*
59003 + * snd_ubi32_pcm_close
59004 + */
59005 +static int snd_ubi32_pcm_close(struct snd_pcm_substream *substream)
59006 +{
59007 + /* Disable codec, stop DMA, free private data structures */
59008 + //struct ubi32_snd_priv *ubi32_priv = snd_pcm_substream_chip(substream);
59009 + struct ubi32_snd_runtime_data *ubi32_rd = substream->runtime->private_data;
59010 +
59011 +#ifdef CONFIG_SND_DEBUG
59012 + snd_printk(KERN_INFO "snd_ubi32_pcm_close\n");
59013 +#endif
59014 +
59015 + substream->runtime->private_data = NULL;
59016 +
59017 + kfree(ubi32_rd);
59018 +
59019 + return 0;
59020 +}
59021 +
59022 +/*
59023 + * snd_ubi32_pcm_open
59024 + */
59025 +static int snd_ubi32_pcm_open(struct snd_pcm_substream *substream)
59026 +{
59027 + struct snd_pcm_runtime *runtime = substream->runtime;
59028 + struct ubi32_snd_runtime_data *ubi32_rd;
59029 + int ret = 0;
59030 +
59031 +#ifdef CONFIG_SND_DEBUG
59032 + snd_printk(KERN_INFO "ubi32 pcm open\n");
59033 +#endif
59034 +
59035 + /* Associate capabilities with component */
59036 + runtime->hw = snd_ubi32_pcm_hw;
59037 +
59038 + /*
59039 + * Inform ALSA about constraints of the audio device
59040 + */
59041 + ret = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, &ubi32_pcm_rates);
59042 + if (ret < 0) {
59043 + snd_printk(KERN_INFO "invalid rate\n");
59044 + goto out;
59045 + }
59046 +
59047 + /* Force the buffer size to be an integer multiple of period size */
59048 + ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
59049 + if (ret < 0) {
59050 + snd_printk(KERN_INFO "invalid period\n");
59051 + goto out;
59052 + }
59053 + /* Initialize structures/registers */
59054 + ubi32_rd = kzalloc(sizeof(struct ubi32_snd_runtime_data), GFP_KERNEL);
59055 + if (ubi32_rd == NULL) {
59056 + ret = -ENOMEM;
59057 + goto out;
59058 + }
59059 +
59060 + runtime->private_data = ubi32_rd;
59061 +
59062 +#ifdef CONFIG_SND_DEBUG
59063 + snd_printk(KERN_INFO "snd_ubi32_pcm_open returned 0\n");
59064 +#endif
59065 +
59066 + return 0;
59067 +out:
59068 +#ifdef CONFIG_SND_DEBUG
59069 + snd_printk(KERN_INFO "snd_ubi32_pcm_open returned %d\n", ret);
59070 +#endif
59071 +
59072 + return ret;
59073 +}
59074 +
59075 +static struct snd_pcm_ops snd_ubi32_pcm_ops = {
59076 + .open = snd_ubi32_pcm_open, /* Open */
59077 + .close = snd_ubi32_pcm_close, /* Close */
59078 + .ioctl = snd_pcm_lib_ioctl, /* Generic IOCTL handler */
59079 + .hw_params = snd_ubi32_pcm_hw_params, /* Hardware parameters/capabilities */
59080 + .hw_free = snd_ubi32_pcm_hw_free, /* Free function for hw_params */
59081 + .prepare = snd_ubi32_pcm_prepare,
59082 + .trigger = snd_ubi32_pcm_trigger,
59083 + .pointer = snd_ubi32_pcm_pointer,
59084 +};
59085 +
59086 +/*
59087 + * Interrupt handler that gets called when the audio device
59088 + * interrupts Linux
59089 + */
59090 +static irqreturn_t snd_ubi32_pcm_interrupt(int irq, void *appdata)
59091 +{
59092 + struct snd_pcm *pcm = (struct snd_pcm *)appdata;
59093 + struct ubi32_snd_priv *ubi32_priv = pcm->private_data;
59094 + struct audio_dev_regs *adr = ubi32_priv->adr;
59095 + struct snd_pcm_substream *substream;
59096 + struct ubi32_snd_runtime_data *ubi32_rd;
59097 + int dma_to_fill = 0;
59098 +
59099 + /*
59100 + * Check to see if the interrupt is for us
59101 + */
59102 + if (!(ubi32_priv->ar->int_status & (1 << ubi32_priv->irq_idx))) {
59103 + return IRQ_NONE;
59104 + }
59105 +
59106 + /*
59107 + * Clear the interrupt
59108 + */
59109 + ubi32_priv->ar->int_status &= ~(1 << ubi32_priv->irq_idx);
59110 +
59111 + /*
59112 + * We only have one stream since we don't mix. Therefore
59113 + * we don't need to search through substreams.
59114 + */
59115 + if (ubi32_priv->is_capture) {
59116 + substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
59117 + } else {
59118 + substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
59119 + }
59120 +
59121 + if (!substream->runtime) {
59122 + snd_printk(KERN_WARNING "No runtime data\n");
59123 + return IRQ_NONE;
59124 + }
59125 +
59126 + ubi32_rd = substream->runtime->private_data;
59127 +
59128 +#ifdef CONFIG_SND_DEBUG
59129 + snd_printk(KERN_INFO "Ubi32 ALSA interrupt\n");
59130 +#endif
59131 +
59132 + if (ubi32_rd == NULL) {
59133 + snd_printk(KERN_WARNING "No private data\n");
59134 + return IRQ_NONE;
59135 + }
59136 +
59137 + // Check interrupt cause
59138 + if (0) {
59139 + // Handle the underflow case
59140 + } else if ((adr->status & AUDIO_STATUS_PLAY_DMA0_REQUEST) ||
59141 + (adr->status & AUDIO_STATUS_PLAY_DMA1_REQUEST)) {
59142 + if (adr->status & AUDIO_STATUS_PLAY_DMA0_REQUEST) {
59143 + dma_to_fill = 0;
59144 + adr->status &= ~AUDIO_STATUS_PLAY_DMA0_REQUEST;
59145 + } else if (adr->status & AUDIO_STATUS_PLAY_DMA1_REQUEST) {
59146 + dma_to_fill = 1;
59147 + adr->status &= ~AUDIO_STATUS_PLAY_DMA1_REQUEST;
59148 + }
59149 + ubi32_rd->period_ptr += ubi32_rd->period_size;
59150 + if (ubi32_rd->period_ptr >= ubi32_rd->dma_buffer_end) {
59151 + ubi32_rd->period_ptr = ubi32_rd->dma_buffer;
59152 + }
59153 + adr->dma_xfer_requests[dma_to_fill].ptr = (void *)ubi32_rd->period_ptr;
59154 + adr->dma_xfer_requests[dma_to_fill].ctr = ubi32_rd->period_size;
59155 + adr->dma_xfer_requests[dma_to_fill].active = 1;
59156 +#ifdef CONFIG_SND_DEBUG
59157 + snd_printk(KERN_INFO "xfer_request %d ptr=0x%x ctr=%u\n", dma_to_fill, ubi32_rd->period_ptr, ubi32_rd->period_size);
59158 +#endif
59159 + adr->int_flags |= AUDIO_INT_FLAG_MORE_SAMPLES;
59160 + snd_ubi32_vp_int_set(substream->pcm);
59161 + }
59162 + // If we are interrupted by the VP, that means we completed
59163 + // processing one period of audio. We need to inform the upper
59164 + // layers of ALSA of this.
59165 + snd_pcm_period_elapsed(substream);
59166 +
59167 + return IRQ_HANDLED;
59168 +}
59169 +
59170 +void __devexit snd_ubi32_pcm_remove(struct ubi32_snd_priv *ubi32_priv)
59171 +{
59172 + struct snd_pcm *pcm = ubi32_priv->pcm;
59173 + free_irq(ubi32_priv->rx_irq, pcm);
59174 +}
59175 +
59176 +#if SNDRV_PCM_RATE_5512 != 1 << 0 || SNDRV_PCM_RATE_192000 != 1 << 12
59177 +#error "Change this table to match pcm.h"
59178 +#endif
59179 +static unsigned int rates[] __initdata = {5512, 8000, 11025, 16000, 22050,
59180 + 32000, 44100, 48000, 64000, 88200,
59181 + 96000, 176400, 192000};
59182 +
59183 +/*
59184 + * snd_ubi32_pcm_probe
59185 + */
59186 +int __devinit snd_ubi32_pcm_probe(struct ubi32_snd_priv *ubi32_priv, struct platform_device *pdev)
59187 +{
59188 + struct snd_pcm *pcm;
59189 + int ret, err;
59190 + int i;
59191 + int j;
59192 + int nrates;
59193 + unsigned int rate_max = 0;
59194 + unsigned int rate_min = 0xFFFFFFFF;
59195 + unsigned int rate_mask = 0;
59196 + struct audio_dev_regs *adr;
59197 + struct resource *res_adr;
59198 + struct resource *res_irq_tx;
59199 + struct resource *res_irq_rx;
59200 + struct ubi32pcm_platform_data *pdata;
59201 +
59202 + pdata = pdev->dev.platform_data;
59203 + if (!pdata) {
59204 + return -ENODEV;
59205 + }
59206 +
59207 + /*
59208 + * Get our resources, adr is the hardware driver base address
59209 + * and the tx and rx irqs are used to communicate with the
59210 + * hardware driver.
59211 + */
59212 + res_adr = platform_get_resource(pdev, IORESOURCE_MEM, AUDIO_MEM_RESOURCE);
59213 + res_irq_tx = platform_get_resource(pdev, IORESOURCE_IRQ, AUDIO_TX_IRQ_RESOURCE);
59214 + res_irq_rx = platform_get_resource(pdev, IORESOURCE_IRQ, AUDIO_RX_IRQ_RESOURCE);
59215 + if (!res_adr || !res_irq_tx || !res_irq_rx) {
59216 + snd_printk(KERN_WARNING "Could not get resources");
59217 + return -ENODEV;
59218 + }
59219 +
59220 + ubi32_priv->ar = (struct audio_regs *)res_adr->start;
59221 + ubi32_priv->tx_irq = res_irq_tx->start;
59222 + ubi32_priv->rx_irq = res_irq_rx->start;
59223 + ubi32_priv->irq_idx = pdata->inst_num;
59224 + ubi32_priv->adr = &(ubi32_priv->ar->adr[pdata->inst_num]);
59225 +
59226 + /*
59227 + * Check the version
59228 + */
59229 + adr = ubi32_priv->adr;
59230 + if (adr->version != AUDIO_DEV_REGS_VERSION) {
59231 + snd_printk(KERN_WARNING "This audio_dev_reg is not compatible with this driver\n");
59232 + return -ENODEV;
59233 + }
59234 +
59235 + /*
59236 + * Find out the standard rates, also find max and min rates
59237 + */
59238 + for (i = 0; i < ARRAY_SIZE(rates); i++) {
59239 + int found = 0;
59240 + for (j = 0; j < adr->n_sample_rates; j++) {
59241 + if (rates[i] == adr->sample_rates[j]) {
59242 + /*
59243 + * Check to see if it is supported by the dac
59244 + */
59245 + if ((rates[i] >= ubi32_priv->min_sample_rate) &&
59246 + (!ubi32_priv->max_sample_rate ||
59247 + (ubi32_priv->max_sample_rate && (rates[i] <= ubi32_priv->max_sample_rate)))) {
59248 + found = 1;
59249 + rate_mask |= (1 << i);
59250 + nrates++;
59251 + if (rates[i] < rate_min) {
59252 + rate_min = rates[i];
59253 + }
59254 + if (rates[i] > rate_max) {
59255 + rate_max = rates[i];
59256 + }
59257 + break;
59258 + }
59259 + }
59260 + }
59261 + if (!found) {
59262 + rate_mask |= SNDRV_PCM_RATE_KNOT;
59263 + }
59264 + }
59265 +
59266 + snd_ubi32_pcm_hw.rates = rate_mask;
59267 + snd_ubi32_pcm_hw.rate_min = rate_min;
59268 + snd_ubi32_pcm_hw.rate_max = rate_max;
59269 + ubi32_pcm_rates.count = adr->n_sample_rates;
59270 + ubi32_pcm_rates.list = (unsigned int *)adr->sample_rates;
59271 + ubi32_pcm_rates.mask = 0;
59272 +
59273 + for (i = 0; i < 32; i++) {
59274 + if (adr->channel_mask & (1 << i)) {
59275 + if (!snd_ubi32_pcm_hw.channels_min) {
59276 + snd_ubi32_pcm_hw.channels_min = i;
59277 + }
59278 + snd_ubi32_pcm_hw.channels_max = i;
59279 + }
59280 + }
59281 + snd_printk(KERN_INFO "Ubi32PCM: channels_min:%u channels_max:%u\n",
59282 + snd_ubi32_pcm_hw.channels_min,
59283 + snd_ubi32_pcm_hw.channels_max);
59284 +
59285 + if (adr->caps & AUDIONODE_CAP_BE) {
59286 + snd_ubi32_pcm_hw.formats |= SNDRV_PCM_FMTBIT_S16_BE;
59287 + }
59288 + if (adr->caps & AUDIONODE_CAP_LE) {
59289 + snd_ubi32_pcm_hw.formats |= SNDRV_PCM_FMTBIT_S16_LE;
59290 + }
59291 +
59292 + snd_printk(KERN_INFO "Ubi32PCM: rates:%08x min:%u max:%u count:%d fmts:%016llx (%s)\n",
59293 + snd_ubi32_pcm_hw.rates,
59294 + snd_ubi32_pcm_hw.rate_min,
59295 + snd_ubi32_pcm_hw.rate_max,
59296 + ubi32_pcm_rates.count,
59297 + snd_ubi32_pcm_hw.formats,
59298 + ubi32_priv->is_capture ? "capture" : "playback");
59299 +
59300 + if (ubi32_priv->is_capture) {
59301 + ret = snd_pcm_new(ubi32_priv->card, "Ubi32 PCM", 0, 0, 1, &pcm);
59302 + } else {
59303 + ret = snd_pcm_new(ubi32_priv->card, "Ubi32 PCM", 0, 1, 0, &pcm);
59304 + }
59305 +
59306 + if (ret < 0) {
59307 + return ret;
59308 + }
59309 +
59310 + pcm->private_data = ubi32_priv;
59311 + ubi32_priv->pcm = pcm;
59312 + ubi32_priv->pdata = pdata;
59313 +
59314 + pcm->info_flags = 0;
59315 +
59316 + strcpy(pcm->name, "Ubi32-PCM");
59317 +
59318 + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
59319 + snd_dma_continuous_data(GFP_KERNEL),
59320 + 45*1024, 64*1024);
59321 +
59322 + if (ubi32_priv->is_capture) {
59323 + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ubi32_pcm_ops);
59324 + } else {
59325 + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ubi32_pcm_ops);
59326 + }
59327 +
59328 + /*
59329 + * Start up the audio device
59330 + */
59331 + adr->int_flags |= AUDIO_INT_FLAG_COMMAND;
59332 + adr->command = AUDIO_CMD_ENABLE;
59333 + snd_ubi32_vp_int_set(pcm);
59334 +
59335 + /*
59336 + * Request IRQ
59337 + */
59338 + err = request_irq(ubi32_priv->rx_irq, snd_ubi32_pcm_interrupt, IRQF_SHARED | IRQF_DISABLED, pcm->name, pcm);
59339 + if (err) {
59340 + snd_printk(KERN_WARNING "request_irq failed: irq=%d err=%d\n", ubi32_priv->rx_irq, err);
59341 + return -ENODEV;
59342 + }
59343 +
59344 + return ret;
59345 +
59346 +}
Personal OpenWRT clone
This page took 2.901247 seconds and 5 git commands to generate.