Rev 1056 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
432 | giacomo | 1 | |
2 | #include <ll/i386/hw-instr.h> |
||
436 | giacomo | 3 | #include <ll/i386/cons.h> |
500 | giacomo | 4 | #include <ll/sys/ll/time.h> |
432 | giacomo | 5 | |
6 | #include <linuxcomp.h> |
||
7 | |||
8 | #include <linux/time.h> |
||
9 | #include <linux/sched.h> |
||
436 | giacomo | 10 | #include <linux/ioport.h> |
437 | giacomo | 11 | #include <linux/errno.h> |
436 | giacomo | 12 | #include <asm/io.h> |
437 | giacomo | 13 | #include <linux/ctype.h> |
14 | #include <linux/device.h> |
||
462 | giacomo | 15 | #include <linux/completion.h> |
468 | giacomo | 16 | #include <linux/tty.h> |
17 | #include <asm/setup.h> |
||
432 | giacomo | 18 | |
537 | giacomo | 19 | #define memory_barrier __asm__("" ::: "memory") |
20 | |||
500 | giacomo | 21 | extern unsigned long intr_count; |
22 | extern int activeInt; |
||
23 | |||
437 | giacomo | 24 | unsigned char _ctype[] = { |
25 | _C,_C,_C,_C,_C,_C,_C,_C, /* 0-7 */ |
||
26 | _C,_C|_S,_C|_S,_C|_S,_C|_S,_C|_S,_C,_C, /* 8-15 */ |
||
27 | _C,_C,_C,_C,_C,_C,_C,_C, /* 16-23 */ |
||
28 | _C,_C,_C,_C,_C,_C,_C,_C, /* 24-31 */ |
||
29 | _S|_SP,_P,_P,_P,_P,_P,_P,_P, /* 32-39 */ |
||
30 | _P,_P,_P,_P,_P,_P,_P,_P, /* 40-47 */ |
||
31 | _D,_D,_D,_D,_D,_D,_D,_D, /* 48-55 */ |
||
32 | _D,_D,_P,_P,_P,_P,_P,_P, /* 56-63 */ |
||
33 | _P,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U|_X,_U, /* 64-71 */ |
||
34 | _U,_U,_U,_U,_U,_U,_U,_U, /* 72-79 */ |
||
35 | _U,_U,_U,_U,_U,_U,_U,_U, /* 80-87 */ |
||
36 | _U,_U,_U,_P,_P,_P,_P,_P, /* 88-95 */ |
||
37 | _P,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L|_X,_L, /* 96-103 */ |
||
38 | _L,_L,_L,_L,_L,_L,_L,_L, /* 104-111 */ |
||
39 | _L,_L,_L,_L,_L,_L,_L,_L, /* 112-119 */ |
||
40 | _L,_L,_L,_P,_P,_P,_P,_C, /* 120-127 */ |
||
41 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 128-143 */ |
||
42 | 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 144-159 */ |
||
43 | _S|_SP,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 160-175 */ |
||
44 | _P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P,_P, /* 176-191 */ |
||
45 | _U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U,_U, /* 192-207 */ |
||
46 | _U,_U,_U,_U,_U,_U,_U,_P,_U,_U,_U,_U,_U,_U,_U,_L, /* 208-223 */ |
||
47 | _L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L,_L, /* 224-239 */ |
||
48 | _L,_L,_L,_L,_L,_L,_L,_P,_L,_L,_L,_L,_L,_L,_L,_L}; /* 240-255 */ |
||
1047 | mauro | 49 | |
455 | giacomo | 50 | __kernel_size_t strnlen(const char *s, __kernel_size_t count) |
51 | { |
||
1047 | mauro | 52 | const char *sc; |
53 | |||
54 | for (sc = s; count-- && *sc != '\0'; ++sc) |
||
455 | giacomo | 55 | /* nothing */; |
1047 | mauro | 56 | return sc - s; |
455 | giacomo | 57 | } |
437 | giacomo | 58 | |
432 | giacomo | 59 | int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); |
60 | |||
436 | giacomo | 61 | struct resource ioport_resource = { |
1047 | mauro | 62 | .name = "PCI IO", |
63 | .start = 0x0000, |
||
64 | .end = IO_SPACE_LIMIT, |
||
65 | .flags = IORESOURCE_IO, |
||
436 | giacomo | 66 | }; |
67 | |||
68 | struct resource iomem_resource = { |
||
1047 | mauro | 69 | .name = "PCI mem", |
70 | .start = 0UL, |
||
71 | .end = ~0UL, |
||
72 | .flags = IORESOURCE_MEM, |
||
436 | giacomo | 73 | }; |
74 | |||
437 | giacomo | 75 | /* Return the conflict entry if you can't request it */ |
76 | static struct resource * __request_resource(struct resource *root, struct resource *new) |
||
77 | { |
||
78 | unsigned long start = new->start; |
||
79 | unsigned long end = new->end; |
||
80 | struct resource *tmp, **p; |
||
436 | giacomo | 81 | |
437 | giacomo | 82 | if (end < start) |
83 | return root; |
||
84 | if (start < root->start) |
||
85 | return root; |
||
86 | if (end > root->end) |
||
87 | return root; |
||
88 | p = &root->child; |
||
89 | for (;;) { |
||
90 | tmp = *p; |
||
91 | if (!tmp || tmp->start > end) { |
||
92 | new->sibling = tmp; |
||
93 | *p = new; |
||
94 | new->parent = root; |
||
95 | return NULL; |
||
96 | } |
||
97 | p = &tmp->sibling; |
||
98 | if (tmp->end < start) |
||
99 | continue; |
||
100 | return tmp; |
||
101 | } |
||
436 | giacomo | 102 | } |
103 | |||
437 | giacomo | 104 | static int __release_resource(struct resource *old) |
105 | { |
||
106 | struct resource *tmp, **p; |
||
107 | |||
108 | p = &old->parent->child; |
||
109 | for (;;) { |
||
110 | tmp = *p; |
||
111 | if (!tmp) |
||
112 | break; |
||
113 | if (tmp == old) { |
||
114 | *p = tmp->sibling; |
||
115 | old->parent = NULL; |
||
116 | return 0; |
||
117 | } |
||
118 | p = &tmp->sibling; |
||
119 | } |
||
120 | return -EINVAL; |
||
121 | } |
||
122 | |||
123 | int release_resource(struct resource *old) |
||
124 | { |
||
125 | int retval; |
||
126 | |||
127 | retval = __release_resource(old); |
||
128 | |||
129 | return retval; |
||
130 | } |
||
131 | |||
132 | int request_resource(struct resource *root, struct resource *new) |
||
133 | { |
||
134 | struct resource *conflict; |
||
135 | |||
136 | conflict = __request_resource(root, new); |
||
137 | |||
138 | return conflict ? -EBUSY : 0; |
||
139 | } |
||
140 | |||
141 | |||
142 | |||
143 | struct resource * __request_region(struct resource *parent, unsigned long start, unsigned long n, const char *name) |
||
144 | { |
||
475 | giacomo | 145 | return (void *)(0xFFFFFFFF); |
437 | giacomo | 146 | } |
147 | |||
148 | void __release_region(struct resource *parent, unsigned long start, unsigned long n) |
||
149 | { |
||
150 | |||
151 | } |
||
152 | |||
153 | static int find_resource(struct resource *root, struct resource *new, |
||
154 | unsigned long size, |
||
155 | unsigned long min, unsigned long max, |
||
156 | unsigned long align, |
||
157 | void (*alignf)(void *, struct resource *, |
||
158 | unsigned long, unsigned long), |
||
159 | void *alignf_data) |
||
160 | { |
||
161 | struct resource *this = root->child; |
||
162 | |||
163 | new->start = root->start; |
||
164 | /* |
||
165 | * Skip past an allocated resource that starts at 0, since the assignment |
||
166 | * of this->start - 1 to new->end below would cause an underflow. |
||
167 | */ |
||
168 | if (this && this->start == 0) { |
||
169 | new->start = this->end + 1; |
||
170 | this = this->sibling; |
||
171 | } |
||
172 | for(;;) { |
||
173 | if (this) |
||
174 | new->end = this->start - 1; |
||
175 | else |
||
176 | new->end = root->end; |
||
177 | if (new->start < min) |
||
178 | new->start = min; |
||
179 | if (new->end > max) |
||
180 | new->end = max; |
||
181 | new->start = (new->start + align - 1) & ~(align - 1); |
||
182 | if (alignf) |
||
183 | alignf(alignf_data, new, size, align); |
||
184 | if (new->start < new->end && new->end - new->start + 1 >= size) { |
||
185 | new->end = new->start + size - 1; |
||
186 | return 0; |
||
187 | } |
||
188 | if (!this) |
||
189 | break; |
||
190 | new->start = this->end + 1; |
||
191 | this = this->sibling; |
||
192 | } |
||
193 | return -EBUSY; |
||
194 | } |
||
195 | |||
196 | int allocate_resource(struct resource *root, struct resource *new, |
||
197 | unsigned long size, |
||
198 | unsigned long min, unsigned long max, |
||
199 | unsigned long align, |
||
200 | void (*alignf)(void *, struct resource *, |
||
201 | unsigned long, unsigned long), |
||
202 | void *alignf_data) |
||
203 | { |
||
204 | int err; |
||
205 | |||
206 | err = find_resource(root, new, size, min, max, align, alignf, alignf_data); |
||
207 | if (err >= 0 && __request_resource(root, new)) |
||
208 | err = -EBUSY; |
||
209 | |||
210 | return err; |
||
211 | } |
||
212 | |||
213 | int remap_page_range(struct vm_area_struct *vma, unsigned long from, unsigned long phys_addr, unsigned long size, pgprot_t prot) |
||
1047 | mauro | 214 | { |
215 | return 0; |
||
216 | } |
||
437 | giacomo | 217 | |
1047 | mauro | 218 | void dump_stack(void) |
219 | { |
||
436 | giacomo | 220 | |
1047 | mauro | 221 | } |
436 | giacomo | 222 | |
1047 | mauro | 223 | void panic(const char * fmt, ...) |
224 | { |
||
225 | cprintf((char *)(fmt)); |
||
436 | giacomo | 226 | } |
227 | |||
228 | extern void * malloc(size_t size); |
||
229 | |||
1047 | mauro | 230 | void *__kmalloc(size_t size, int flags) |
231 | { |
||
232 | return malloc(size); |
||
436 | giacomo | 233 | } |
234 | |||
235 | extern void free(void *); |
||
236 | |||
1047 | mauro | 237 | void kfree(const void *ptr) |
238 | { |
||
239 | free((void *)(ptr)); |
||
436 | giacomo | 240 | } |
241 | |||
242 | unsigned long pci_mem_start = 0x10000000; |
||
243 | |||
1056 | tullio | 244 | // added __attribute__ for gcc4 compatibility |
245 | __attribute__((regparm(3))) signed long schedule_timeout(signed long timeout) |
||
1047 | mauro | 246 | { |
247 | struct timespec t,s,e; |
||
432 | giacomo | 248 | |
1047 | mauro | 249 | jiffies_to_timespec(timeout, &t); |
432 | giacomo | 250 | |
1047 | mauro | 251 | if (!activeInt && !intr_count) { |
252 | nanosleep(&t,NULL); |
||
253 | } else { |
||
254 | ll_gettime(TIME_NEW,&s); |
||
255 | ADDTIMESPEC(&t,&s,&e); |
||
432 | giacomo | 256 | |
1047 | mauro | 257 | memory_barrier; |
432 | giacomo | 258 | |
1047 | mauro | 259 | while(TIMESPEC_A_LT_B(&s,&e)) { |
260 | memory_barrier; |
||
261 | ll_gettime(TIME_NEW,&s); |
||
262 | } |
||
263 | } |
||
264 | |||
265 | return 0; |
||
432 | giacomo | 266 | } |
436 | giacomo | 267 | |
1047 | mauro | 268 | void __const_udelay(unsigned long usecs) |
269 | { |
||
270 | struct timespec t,s,e; |
||
436 | giacomo | 271 | |
1047 | mauro | 272 | if (!activeInt && !intr_count) { |
273 | t.tv_sec = 0; |
||
274 | t.tv_nsec = usecs * 1000; |
||
500 | giacomo | 275 | |
1047 | mauro | 276 | nanosleep(&t,NULL); |
277 | } else { |
||
278 | ll_gettime(TIME_NEW,&e); |
||
279 | ADDUSEC2TIMESPEC(usecs,&e); |
||
436 | giacomo | 280 | |
1047 | mauro | 281 | memory_barrier; |
500 | giacomo | 282 | |
1047 | mauro | 283 | ll_gettime(TIME_NEW,&s); |
284 | while(TIMESPEC_A_LT_B(&s,&e)) { |
||
285 | memory_barrier; |
||
286 | ll_gettime(TIME_NEW,&s); |
||
287 | } |
||
288 | } |
||
464 | giacomo | 289 | } |
290 | |||
537 | giacomo | 291 | void * vmalloc_32(size_t size); |
292 | |||
1047 | mauro | 293 | void *dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle, int gfp) |
516 | giacomo | 294 | { |
1047 | mauro | 295 | void *ret; |
296 | /* ignore region specifiers */ |
||
297 | gfp &= ~(__GFP_DMA | __GFP_HIGHMEM); |
||
298 | |||
299 | if (dev == NULL || (*dev->dma_mask < 0xffffffff)) |
||
300 | gfp |= GFP_DMA; |
||
301 | ret = (void *)vmalloc_32(size); |
||
302 | |||
303 | if (ret != NULL) { |
||
304 | memset(ret, 0, size); |
||
305 | *dma_handle = (dma_addr_t)ret; |
||
306 | } |
||
307 | return ret; |
||
516 | giacomo | 308 | } |
1047 | mauro | 309 | |
310 | void *dma_alloc_coherent_usb(struct device *dev, size_t size, dma_addr_t *dma_handle, int gfp) |
||
516 | giacomo | 311 | { |
1047 | mauro | 312 | void *ret; |
313 | /* ignore region specifiers */ |
||
314 | gfp &= ~(__GFP_DMA | __GFP_HIGHMEM); |
||
315 | |||
316 | if (dev == NULL || (*dev->dma_mask < 0xffffffff)) |
||
317 | gfp |= GFP_DMA; |
||
318 | ret = (void *)vmalloc_32_usb(size); |
||
319 | |||
320 | if (ret != NULL) { |
||
321 | memset(ret, 0, size); |
||
322 | *dma_handle = (dma_addr_t)ret; |
||
323 | } |
||
324 | return ret; |
||
325 | } |
||
326 | |||
327 | void dma_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle) |
||
328 | { |
||
611 | giacomo | 329 | vfree((void *)dma_handle); |
516 | giacomo | 330 | } |
331 | |||
847 | giacomo | 332 | extern void __wake_up_common(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, int sync); |
333 | |||
516 | giacomo | 334 | void init_completion(struct completion *x) { |
847 | giacomo | 335 | x->done = 0; |
336 | init_waitqueue_head(&x->wait); |
||
516 | giacomo | 337 | } |
338 | |||
1056 | tullio | 339 | // added __attribute__ for gcc4 compatibility |
340 | __attribute__((regparm(3))) void complete(struct completion *x) |
||
847 | giacomo | 341 | { |
342 | x->done++; |
||
343 | __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, 0); |
||
462 | giacomo | 344 | } |
345 | |||
1056 | tullio | 346 | // added __attribute__ for gcc4 compatibility |
347 | __attribute__((regparm(3))) void wait_for_completion(struct completion *x) |
||
1047 | mauro | 348 | { |
847 | giacomo | 349 | spin_lock_irq(&x->wait.lock); |
350 | if (!x->done) { |
||
351 | DECLARE_WAITQUEUE(wait, current); |
||
352 | |||
353 | wait.flags |= WQ_FLAG_EXCLUSIVE; |
||
354 | __add_wait_queue_tail(&x->wait, &wait); |
||
355 | do { |
||
356 | __set_current_state(TASK_UNINTERRUPTIBLE); |
||
357 | spin_unlock_irq(&x->wait.lock); |
||
358 | schedule(); |
||
359 | spin_lock_irq(&x->wait.lock); |
||
360 | } while (!x->done); |
||
361 | __remove_wait_queue(&x->wait, &wait); |
||
362 | } |
||
363 | x->done--; |
||
364 | spin_unlock_irq(&x->wait.lock); |
||
462 | giacomo | 365 | } |
366 | |||
367 | struct device legacy_bus = { |
||
368 | .bus_id = "legacy", |
||
369 | }; |
||
370 | |||
1047 | mauro | 371 | int register_chrdev(unsigned int a, const char *b, struct file_operations *c) |
372 | { |
||
462 | giacomo | 373 | return 0; |
374 | } |
||
375 | |||
1047 | mauro | 376 | int unregister_chrdev(unsigned int a, const char *b) |
377 | { |
||
462 | giacomo | 378 | return 0; |
379 | } |
||
468 | giacomo | 380 | |
1047 | mauro | 381 | void * __ioremap(unsigned long offset, unsigned long size, unsigned long flags) |
382 | { |
||
383 | return (void *)offset; |
||
384 | } |
||
468 | giacomo | 385 | |
1047 | mauro | 386 | void iounmap(void *addr) |
387 | { |
||
468 | giacomo | 388 | |
389 | } |
||
390 | |||
1047 | mauro | 391 | loff_t no_llseek(struct file *file, loff_t offset, int origin) |
392 | { |
||
393 | return 0; |
||
394 | } |
||
468 | giacomo | 395 | |
1047 | mauro | 396 | void *vmalloc(unsigned long size) |
397 | { |
||
398 | return malloc(size); |
||
468 | giacomo | 399 | } |
400 | |||
1047 | mauro | 401 | void *kern_alloc_aligned(size_t size, DWORD flags, int align_bits, DWORD align_ofs); |
540 | giacomo | 402 | |
1047 | mauro | 403 | void * vmalloc_32(size_t size) |
404 | { |
||
405 | void *mem; |
||
406 | unsigned long diff; |
||
540 | giacomo | 407 | |
1047 | mauro | 408 | mem = malloc(size+12); |
540 | giacomo | 409 | |
1047 | mauro | 410 | diff = (unsigned long)((((unsigned long)mem/4)+1)*4-(unsigned long)mem); |
468 | giacomo | 411 | |
1047 | mauro | 412 | *(unsigned long *)(mem+diff) = (diff | 0x80000000); |
468 | giacomo | 413 | |
1047 | mauro | 414 | return (mem+diff+4); |
468 | giacomo | 415 | } |
416 | |||
1047 | mauro | 417 | void vfree(void *addr) |
537 | giacomo | 418 | { |
1047 | mauro | 419 | if (addr == NULL || *(unsigned long *)(addr-4) == 0) |
420 | return; |
||
421 | |||
422 | if ((*(unsigned long *)(addr-4) & 0x80000000) == 0x80000000) { |
||
423 | free(addr-(*(unsigned long *)(addr-4) & 0x7FFFFFFF)-4); |
||
424 | *(unsigned long *)(addr-4) = 0; |
||
425 | return; |
||
426 | } |
||
427 | |||
428 | free(addr); |
||
429 | |||
430 | return; |
||
537 | giacomo | 431 | } |
468 | giacomo | 432 | |
1047 | mauro | 433 | void * vmalloc_32_usb(size_t size) |
434 | { |
||
435 | void* mem; |
||
436 | unsigned long diff; |
||
468 | giacomo | 437 | |
1047 | mauro | 438 | mem = malloc( size + 2 * 4096 ); |
468 | giacomo | 439 | |
1047 | mauro | 440 | if (! mem) |
441 | return NULL; |
||
442 | |||
443 | diff = 4096 - (((unsigned long) mem) % 4096); |
||
444 | *(unsigned long *)(mem+diff) = (diff | 0x80000000); |
||
445 | |||
446 | return (void*)(mem + diff + 4096); |
||
468 | giacomo | 447 | } |
448 | |||
1047 | mauro | 449 | /* TODO */ |
450 | char * strsep(char **a,const char *b) |
||
451 | { |
||
452 | return NULL; |
||
453 | } |
||
454 | |||
468 | giacomo | 455 | struct screen_info screen_info; |
456 | |||
1047 | mauro | 457 | int linuxcomp_setfd(struct inode *i, int i_rdev) |
458 | { |
||
459 | i->i_rdev = i_rdev; |
||
469 | giacomo | 460 | |
1047 | mauro | 461 | return 0; |
462 | } |
||
469 | giacomo | 463 | |
1047 | mauro | 464 | int linuxcomp_init(void) |
465 | { |
||
469 | giacomo | 466 | return 0; |
467 | } |
||
468 | |||
1047 | mauro | 469 | struct page *mem_map = 0x0000; |
468 | giacomo | 470 | |
1056 | tullio | 471 | // added __attribute__ for gcc4 compatibility |
472 | __attribute__((regparm(3))) int schedule_work(struct work_struct *work) |
||
1047 | mauro | 473 | { |
474 | return 0; |
||
475 | } |
||
468 | giacomo | 476 | |
1047 | mauro | 477 | int allow_signal(int sig) |
478 | { |
||
479 | return 0; |
||
468 | giacomo | 480 | } |
847 | giacomo | 481 | |
482 | void flush_scheduled_work(void) { } |
||
483 | void daemonize(const char *name, ...) { } |
||
484 | void yield(void) { } |
||
485 | |||
486 | void do_exit(long code) { } |
||
1047 | mauro | 487 | |
847 | giacomo | 488 | void complete_and_exit(struct completion *comp, long code) |
489 | { |
||
490 | if (comp) |
||
491 | complete(comp); |
||
492 | |||
493 | do_exit(code); |
||
494 | } |
||
495 | |||
496 | inline void * ioremap_nocache(unsigned long offset, unsigned long size) |
||
497 | { |
||
498 | return __ioremap(offset, size, 0); |
||
499 | } |
||
500 | |||
501 | #define NULL_TIMESPEC(t) ((t)->tv_sec = (t)->tv_nsec = 0) |
||
502 | |||
503 | int wait_ms26(unsigned long msec) |
||
504 | { |
||
505 | struct timespec t1, t2; |
||
506 | int nsec; |
||
507 | |||
508 | t1.tv_sec = msec/1000; |
||
509 | nsec = (msec % 1000) * 1000000; |
||
510 | t1.tv_nsec = nsec; |
||
511 | NULL_TIMESPEC(&t2); |
||
512 | nanosleep(&t1, &t2); |
||
513 | |||
514 | return 0; |
||
515 | } |