]>
Commit | Line | Data |
---|---|---|
e01402b1 RB |
1 | /* |
2 | * Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved. | |
a84c96e2 | 3 | * Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org) |
e01402b1 RB |
4 | * |
5 | * This program is free software; you can distribute it and/or modify it | |
6 | * under the terms of the GNU General Public License (Version 2) as | |
7 | * published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope it will be useful, but WITHOUT | |
10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 | * for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License along | |
15 | * with this program; if not, write to the Free Software Foundation, Inc., | |
16 | * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA. | |
17 | * | |
18 | */ | |
19 | ||
20 | #include <linux/kernel.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/fs.h> | |
23 | #include <linux/init.h> | |
2600990e RB |
24 | #include <asm/uaccess.h> |
25 | #include <linux/slab.h> | |
26 | #include <linux/list.h> | |
27 | #include <linux/vmalloc.h> | |
28 | #include <linux/elf.h> | |
29 | #include <linux/seq_file.h> | |
30 | #include <linux/syscalls.h> | |
31 | #include <linux/moduleloader.h> | |
a84c96e2 | 32 | #include <linux/interrupt.h> |
e01402b1 RB |
33 | #include <linux/poll.h> |
34 | #include <linux/sched.h> | |
35 | #include <linux/wait.h> | |
36 | #include <asm/mipsmtregs.h> | |
2600990e RB |
37 | #include <asm/cacheflush.h> |
38 | #include <asm/atomic.h> | |
e01402b1 RB |
39 | #include <asm/cpu.h> |
40 | #include <asm/processor.h> | |
2600990e RB |
41 | #include <asm/system.h> |
42 | #include <asm/vpe.h> | |
e01402b1 RB |
43 | #include <asm/rtlx.h> |
44 | ||
e01402b1 RB |
45 | #define RTLX_TARG_VPE 1 |
46 | ||
afc4841d | 47 | static struct rtlx_info *rtlx; |
e01402b1 RB |
48 | static int major; |
49 | static char module_name[] = "rtlx"; | |
e01402b1 RB |
50 | |
51 | static struct chan_waitqueues { | |
52 | wait_queue_head_t rt_queue; | |
53 | wait_queue_head_t lx_queue; | |
2600990e | 54 | int in_open; |
e01402b1 RB |
55 | } channel_wqs[RTLX_CHANNELS]; |
56 | ||
2600990e RB |
57 | static struct irqaction irq; |
58 | static int irq_num; | |
59 | static struct vpe_notifications notify; | |
60 | static int sp_stopping = 0; | |
61 | ||
e01402b1 RB |
62 | extern void *vpe_get_shared(int index); |
63 | ||
64 | static void rtlx_dispatch(struct pt_regs *regs) | |
65 | { | |
66 | do_IRQ(MIPSCPU_INT_BASE + MIPS_CPU_RTLX_IRQ, regs); | |
67 | } | |
68 | ||
2600990e RB |
69 | |
70 | /* Interrupt handler may be called before rtlx_init has otherwise had | |
71 | a chance to run. | |
72 | */ | |
afc4841d | 73 | static irqreturn_t rtlx_interrupt(int irq, void *dev_id, struct pt_regs *regs) |
e01402b1 | 74 | { |
e01402b1 RB |
75 | int i; |
76 | ||
77 | for (i = 0; i < RTLX_CHANNELS; i++) { | |
2600990e RB |
78 | wake_up(&channel_wqs[i].lx_queue); |
79 | wake_up(&channel_wqs[i].rt_queue); | |
e01402b1 RB |
80 | } |
81 | ||
afc4841d | 82 | return IRQ_HANDLED; |
e01402b1 RB |
83 | } |
84 | ||
2600990e | 85 | static __attribute_used__ void dump_rtlx(void) |
e01402b1 RB |
86 | { |
87 | int i; | |
88 | ||
2600990e | 89 | printk("id 0x%lx state %d\n", rtlx->id, rtlx->state); |
e01402b1 | 90 | |
e01402b1 | 91 | for (i = 0; i < RTLX_CHANNELS; i++) { |
2600990e | 92 | struct rtlx_channel *chan = &rtlx->channel[i]; |
e01402b1 | 93 | |
2600990e RB |
94 | printk(" rt_state %d lx_state %d buffer_size %d\n", |
95 | chan->rt_state, chan->lx_state, chan->buffer_size); | |
e01402b1 | 96 | |
2600990e RB |
97 | printk(" rt_read %d rt_write %d\n", |
98 | chan->rt_read, chan->rt_write); | |
e01402b1 | 99 | |
2600990e RB |
100 | printk(" lx_read %d lx_write %d\n", |
101 | chan->lx_read, chan->lx_write); | |
102 | ||
103 | printk(" rt_buffer <%s>\n", chan->rt_buffer); | |
104 | printk(" lx_buffer <%s>\n", chan->lx_buffer); | |
105 | } | |
106 | } | |
107 | ||
108 | /* call when we have the address of the shared structure from the SP side. */ | |
109 | static int rtlx_init(struct rtlx_info *rtlxi) | |
110 | { | |
111 | if (rtlxi->id != RTLX_ID) { | |
112 | printk(KERN_ERR "no valid RTLX id at 0x%p 0x%x\n", rtlxi, rtlxi->id); | |
113 | return -ENOEXEC; | |
114 | } | |
e01402b1 RB |
115 | |
116 | rtlx = rtlxi; | |
afc4841d RB |
117 | |
118 | return 0; | |
e01402b1 RB |
119 | } |
120 | ||
2600990e RB |
121 | /* notifications */ |
122 | static void starting(int vpe) | |
e01402b1 | 123 | { |
2600990e RB |
124 | int i; |
125 | sp_stopping = 0; | |
126 | ||
127 | /* force a reload of rtlx */ | |
128 | rtlx=NULL; | |
129 | ||
130 | /* wake up any sleeping rtlx_open's */ | |
131 | for (i = 0; i < RTLX_CHANNELS; i++) | |
132 | wake_up_interruptible(&channel_wqs[i].lx_queue); | |
133 | } | |
134 | ||
135 | static void stopping(int vpe) | |
136 | { | |
137 | int i; | |
138 | ||
139 | sp_stopping = 1; | |
140 | for (i = 0; i < RTLX_CHANNELS; i++) | |
141 | wake_up_interruptible(&channel_wqs[i].lx_queue); | |
142 | } | |
143 | ||
144 | ||
145 | int rtlx_open(int index, int can_sleep) | |
146 | { | |
147 | int ret; | |
e01402b1 | 148 | struct rtlx_channel *chan; |
2600990e | 149 | volatile struct rtlx_info **p; |
e01402b1 | 150 | |
2600990e RB |
151 | if (index >= RTLX_CHANNELS) { |
152 | printk(KERN_DEBUG "rtlx_open index out of range\n"); | |
153 | return -ENOSYS; | |
154 | } | |
155 | ||
156 | if (channel_wqs[index].in_open) { | |
157 | printk(KERN_DEBUG "rtlx_open channel %d already opened\n", index); | |
158 | return -EBUSY; | |
159 | } | |
160 | ||
161 | channel_wqs[index].in_open++; | |
e01402b1 RB |
162 | |
163 | if (rtlx == NULL) { | |
e01402b1 | 164 | if( (p = vpe_get_shared(RTLX_TARG_VPE)) == NULL) { |
2600990e RB |
165 | if (can_sleep) { |
166 | DECLARE_WAITQUEUE(wait, current); | |
167 | ||
168 | /* go to sleep */ | |
169 | add_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
170 | ||
171 | set_current_state(TASK_INTERRUPTIBLE); | |
172 | while ((p = vpe_get_shared(RTLX_TARG_VPE)) == NULL) { | |
173 | schedule(); | |
174 | set_current_state(TASK_INTERRUPTIBLE); | |
175 | } | |
176 | ||
177 | set_current_state(TASK_RUNNING); | |
178 | remove_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
179 | ||
180 | /* back running */ | |
181 | } else { | |
182 | printk( KERN_DEBUG "No SP program loaded, and device " | |
183 | "opened with O_NONBLOCK\n"); | |
184 | channel_wqs[index].in_open = 0; | |
185 | return -ENOSYS; | |
186 | } | |
e01402b1 RB |
187 | } |
188 | ||
189 | if (*p == NULL) { | |
2600990e RB |
190 | if (can_sleep) { |
191 | DECLARE_WAITQUEUE(wait, current); | |
192 | ||
193 | /* go to sleep */ | |
194 | add_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
195 | ||
196 | set_current_state(TASK_INTERRUPTIBLE); | |
197 | while (*p == NULL) { | |
198 | schedule(); | |
199 | ||
200 | /* reset task state to interruptable otherwise | |
201 | we'll whizz round here like a very fast loopy | |
202 | thing. schedule() appears to return with state | |
203 | set to TASK_RUNNING. | |
204 | ||
205 | If the loaded SP program, for whatever reason, | |
206 | doesn't set up the shared structure *p will never | |
207 | become true. So whoever connected to either /dev/rt? | |
208 | or if it was kspd, will then take up rather a lot of | |
209 | processor cycles. | |
210 | */ | |
211 | ||
212 | set_current_state(TASK_INTERRUPTIBLE); | |
213 | } | |
214 | ||
215 | set_current_state(TASK_RUNNING); | |
216 | remove_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
217 | ||
218 | /* back running */ | |
219 | } | |
220 | else { | |
221 | printk(" *vpe_get_shared is NULL. " | |
222 | "Has an SP program been loaded?\n"); | |
223 | channel_wqs[index].in_open = 0; | |
224 | return -ENOSYS; | |
225 | } | |
226 | } | |
227 | ||
228 | if ((unsigned int)*p < KSEG0) { | |
229 | printk(KERN_WARNING "vpe_get_shared returned an invalid pointer " | |
230 | "maybe an error code %d\n", (int)*p); | |
231 | channel_wqs[index].in_open = 0; | |
232 | return -ENOSYS; | |
e01402b1 RB |
233 | } |
234 | ||
2600990e RB |
235 | if ((ret = rtlx_init(*p)) < 0) { |
236 | channel_wqs[index].in_open = 0; | |
237 | return ret; | |
238 | } | |
e01402b1 RB |
239 | } |
240 | ||
2600990e | 241 | chan = &rtlx->channel[index]; |
e01402b1 | 242 | |
2600990e RB |
243 | if (chan->lx_state == RTLX_STATE_OPENED) { |
244 | channel_wqs[index].in_open = 0; | |
245 | return -EBUSY; | |
246 | } | |
e01402b1 | 247 | |
2600990e RB |
248 | chan->lx_state = RTLX_STATE_OPENED; |
249 | channel_wqs[index].in_open = 0; | |
afc4841d | 250 | return 0; |
e01402b1 RB |
251 | } |
252 | ||
2600990e | 253 | int rtlx_release(int index) |
e01402b1 | 254 | { |
2600990e | 255 | rtlx->channel[index].lx_state = RTLX_STATE_UNUSED; |
afc4841d | 256 | return 0; |
e01402b1 RB |
257 | } |
258 | ||
2600990e | 259 | unsigned int rtlx_read_poll(int index, int can_sleep) |
e01402b1 | 260 | { |
2600990e | 261 | struct rtlx_channel *chan; |
e01402b1 | 262 | |
2600990e RB |
263 | if (rtlx == NULL) |
264 | return 0; | |
e01402b1 | 265 | |
2600990e | 266 | chan = &rtlx->channel[index]; |
e01402b1 RB |
267 | |
268 | /* data available to read? */ | |
2600990e RB |
269 | if (chan->lx_read == chan->lx_write) { |
270 | if (can_sleep) { | |
271 | DECLARE_WAITQUEUE(wait, current); | |
e01402b1 | 272 | |
2600990e RB |
273 | /* go to sleep */ |
274 | add_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
e01402b1 | 275 | |
2600990e RB |
276 | set_current_state(TASK_INTERRUPTIBLE); |
277 | while (chan->lx_read == chan->lx_write) { | |
278 | schedule(); | |
279 | ||
280 | set_current_state(TASK_INTERRUPTIBLE); | |
281 | ||
282 | if (sp_stopping) { | |
283 | set_current_state(TASK_RUNNING); | |
284 | remove_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
285 | return 0; | |
286 | } | |
287 | } | |
288 | ||
289 | set_current_state(TASK_RUNNING); | |
290 | remove_wait_queue(&channel_wqs[index].lx_queue, &wait); | |
291 | ||
292 | /* back running */ | |
293 | } | |
294 | else | |
295 | return 0; | |
296 | } | |
297 | ||
298 | return (chan->lx_write + chan->buffer_size - chan->lx_read) | |
299 | % chan->buffer_size; | |
e01402b1 RB |
300 | } |
301 | ||
2600990e | 302 | static inline int write_spacefree(int read, int write, int size) |
e01402b1 | 303 | { |
2600990e RB |
304 | if (read == write) { |
305 | /* | |
306 | * Never fill the buffer completely, so indexes are always | |
307 | * equal if empty and only empty, or !equal if data available | |
308 | */ | |
309 | return size - 1; | |
310 | } | |
e01402b1 | 311 | |
2600990e RB |
312 | return ((read + size - write) % size) - 1; |
313 | } | |
e01402b1 | 314 | |
2600990e RB |
315 | unsigned int rtlx_write_poll(int index) |
316 | { | |
317 | struct rtlx_channel *chan = &rtlx->channel[index]; | |
318 | return write_spacefree(chan->rt_read, chan->rt_write, chan->buffer_size); | |
319 | } | |
e01402b1 | 320 | |
2600990e RB |
321 | static inline void copy_to(void *dst, void *src, size_t count, int user) |
322 | { | |
323 | if (user) | |
324 | copy_to_user(dst, src, count); | |
325 | else | |
326 | memcpy(dst, src, count); | |
327 | } | |
e01402b1 | 328 | |
2600990e RB |
329 | static inline void copy_from(void *dst, void *src, size_t count, int user) |
330 | { | |
331 | if (user) | |
332 | copy_from_user(dst, src, count); | |
333 | else | |
334 | memcpy(dst, src, count); | |
335 | } | |
e01402b1 | 336 | |
2600990e RB |
337 | ssize_t rtlx_read(int index, void *buff, size_t count, int user) |
338 | { | |
339 | size_t fl = 0L; | |
340 | struct rtlx_channel *lx; | |
e01402b1 | 341 | |
2600990e RB |
342 | if (rtlx == NULL) |
343 | return -ENOSYS; | |
344 | ||
345 | lx = &rtlx->channel[index]; | |
e01402b1 RB |
346 | |
347 | /* find out how much in total */ | |
afc4841d | 348 | count = min(count, |
2600990e RB |
349 | (size_t)(lx->lx_write + lx->buffer_size - lx->lx_read) |
350 | % lx->buffer_size); | |
e01402b1 RB |
351 | |
352 | /* then how much from the read pointer onwards */ | |
2600990e | 353 | fl = min( count, (size_t)lx->buffer_size - lx->lx_read); |
e01402b1 | 354 | |
2600990e | 355 | copy_to(buff, &lx->lx_buffer[lx->lx_read], fl, user); |
e01402b1 RB |
356 | |
357 | /* and if there is anything left at the beginning of the buffer */ | |
2600990e RB |
358 | if ( count - fl ) |
359 | copy_to (buff + fl, lx->lx_buffer, count - fl, user); | |
e01402b1 RB |
360 | |
361 | /* update the index */ | |
362 | lx->lx_read += count; | |
363 | lx->lx_read %= lx->buffer_size; | |
364 | ||
afc4841d | 365 | return count; |
e01402b1 RB |
366 | } |
367 | ||
2600990e RB |
368 | ssize_t rtlx_write(int index, void *buffer, size_t count, int user) |
369 | { | |
370 | struct rtlx_channel *rt; | |
371 | size_t fl; | |
372 | ||
373 | if (rtlx == NULL) | |
374 | return(-ENOSYS); | |
375 | ||
376 | rt = &rtlx->channel[index]; | |
377 | ||
378 | /* total number of bytes to copy */ | |
379 | count = min(count, | |
380 | (size_t)write_spacefree(rt->rt_read, rt->rt_write, | |
381 | rt->buffer_size)); | |
382 | ||
383 | /* first bit from write pointer to the end of the buffer, or count */ | |
384 | fl = min(count, (size_t) rt->buffer_size - rt->rt_write); | |
385 | ||
386 | copy_from (&rt->rt_buffer[rt->rt_write], buffer, fl, user); | |
387 | ||
388 | /* if there's any left copy to the beginning of the buffer */ | |
389 | if( count - fl ) | |
390 | copy_from (rt->rt_buffer, buffer + fl, count - fl, user); | |
391 | ||
392 | rt->rt_write += count; | |
393 | rt->rt_write %= rt->buffer_size; | |
394 | ||
395 | return(count); | |
396 | } | |
397 | ||
398 | ||
399 | static int file_open(struct inode *inode, struct file *filp) | |
400 | { | |
401 | int minor = MINOR(inode->i_rdev); | |
402 | ||
403 | return rtlx_open(minor, (filp->f_flags & O_NONBLOCK) ? 0 : 1); | |
404 | } | |
405 | ||
406 | static int file_release(struct inode *inode, struct file *filp) | |
407 | { | |
408 | int minor; | |
409 | minor = MINOR(inode->i_rdev); | |
410 | ||
411 | return rtlx_release(minor); | |
412 | } | |
413 | ||
414 | static unsigned int file_poll(struct file *file, poll_table * wait) | |
415 | { | |
416 | int minor; | |
417 | unsigned int mask = 0; | |
418 | ||
419 | minor = MINOR(file->f_dentry->d_inode->i_rdev); | |
420 | ||
421 | poll_wait(file, &channel_wqs[minor].rt_queue, wait); | |
422 | poll_wait(file, &channel_wqs[minor].lx_queue, wait); | |
423 | ||
424 | if (rtlx == NULL) | |
425 | return 0; | |
426 | ||
427 | /* data available to read? */ | |
428 | if (rtlx_read_poll(minor, 0)) | |
429 | mask |= POLLIN | POLLRDNORM; | |
430 | ||
431 | /* space to write */ | |
432 | if (rtlx_write_poll(minor)) | |
433 | mask |= POLLOUT | POLLWRNORM; | |
434 | ||
435 | return mask; | |
436 | } | |
437 | ||
438 | static ssize_t file_read(struct file *file, char __user * buffer, size_t count, | |
439 | loff_t * ppos) | |
440 | { | |
441 | int minor = MINOR(file->f_dentry->d_inode->i_rdev); | |
442 | ||
443 | /* data available? */ | |
444 | if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) { | |
445 | return 0; // -EAGAIN makes cat whinge | |
446 | } | |
447 | ||
448 | return rtlx_read(minor, buffer, count, 1); | |
449 | } | |
450 | ||
451 | static ssize_t file_write(struct file *file, const char __user * buffer, | |
e01402b1 RB |
452 | size_t count, loff_t * ppos) |
453 | { | |
454 | int minor; | |
455 | struct rtlx_channel *rt; | |
e01402b1 RB |
456 | DECLARE_WAITQUEUE(wait, current); |
457 | ||
458 | minor = MINOR(file->f_dentry->d_inode->i_rdev); | |
459 | rt = &rtlx->channel[minor]; | |
460 | ||
461 | /* any space left... */ | |
2600990e | 462 | if (!rtlx_write_poll(minor)) { |
e01402b1 RB |
463 | |
464 | if (file->f_flags & O_NONBLOCK) | |
afc4841d | 465 | return -EAGAIN; |
e01402b1 RB |
466 | |
467 | add_wait_queue(&channel_wqs[minor].rt_queue, &wait); | |
468 | set_current_state(TASK_INTERRUPTIBLE); | |
469 | ||
2600990e | 470 | while (!rtlx_write_poll(minor)) |
e01402b1 RB |
471 | schedule(); |
472 | ||
473 | set_current_state(TASK_RUNNING); | |
474 | remove_wait_queue(&channel_wqs[minor].rt_queue, &wait); | |
475 | } | |
476 | ||
2600990e | 477 | return rtlx_write(minor, (void *)buffer, count, 1); |
e01402b1 RB |
478 | } |
479 | ||
480 | static struct file_operations rtlx_fops = { | |
2600990e RB |
481 | .owner = THIS_MODULE, |
482 | .open = file_open, | |
483 | .release = file_release, | |
484 | .write = file_write, | |
485 | .read = file_read, | |
486 | .poll = file_poll | |
e01402b1 RB |
487 | }; |
488 | ||
2600990e RB |
489 | static struct irqaction rtlx_irq = { |
490 | .handler = rtlx_interrupt, | |
491 | .flags = SA_INTERRUPT, | |
492 | .name = "RTLX", | |
493 | }; | |
494 | ||
495 | static int rtlx_irq_num = MIPSCPU_INT_BASE + MIPS_CPU_RTLX_IRQ; | |
496 | ||
afc4841d RB |
497 | static char register_chrdev_failed[] __initdata = |
498 | KERN_ERR "rtlx_module_init: unable to register device\n"; | |
499 | ||
2600990e | 500 | static int rtlx_module_init(void) |
e01402b1 | 501 | { |
2600990e RB |
502 | int i; |
503 | ||
afc4841d RB |
504 | major = register_chrdev(0, module_name, &rtlx_fops); |
505 | if (major < 0) { | |
506 | printk(register_chrdev_failed); | |
507 | return major; | |
e01402b1 RB |
508 | } |
509 | ||
2600990e RB |
510 | /* initialise the wait queues */ |
511 | for (i = 0; i < RTLX_CHANNELS; i++) { | |
512 | init_waitqueue_head(&channel_wqs[i].rt_queue); | |
513 | init_waitqueue_head(&channel_wqs[i].lx_queue); | |
514 | channel_wqs[i].in_open = 0; | |
515 | } | |
516 | ||
517 | /* set up notifiers */ | |
518 | notify.start = starting; | |
519 | notify.stop = stopping; | |
520 | vpe_notify(RTLX_TARG_VPE, ¬ify); | |
521 | ||
522 | if (cpu_has_vint) | |
523 | set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch); | |
524 | ||
525 | rtlx_irq.dev_id = rtlx; | |
526 | setup_irq(rtlx_irq_num, &rtlx_irq); | |
527 | ||
afc4841d | 528 | return 0; |
e01402b1 RB |
529 | } |
530 | ||
afc4841d | 531 | static void __exit rtlx_module_exit(void) |
e01402b1 RB |
532 | { |
533 | unregister_chrdev(major, module_name); | |
534 | } | |
535 | ||
536 | module_init(rtlx_module_init); | |
537 | module_exit(rtlx_module_exit); | |
afc4841d | 538 | |
e01402b1 | 539 | MODULE_DESCRIPTION("MIPS RTLX"); |
2600990e | 540 | MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc."); |
e01402b1 | 541 | MODULE_LICENSE("GPL"); |