1 /*********************************************************************
2 *
3 * sir_kthread.c: dedicated thread to process scheduled
4 * sir device setup requests
5 *
6 * Copyright (c) 2002 Martin Diehl
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
12 *
13 ********************************************************************/
14
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/version.h>
18 #include <linux/init.h>
19 #include <linux/smp_lock.h>
20 #include <linux/completion.h>
21 #include <linux/delay.h>
22
23 #include <net/irda/irda.h>
24
25 #include "sir-dev.h"
26
27 /**************************************************************************
28 *
29 * kIrDAd kernel thread and config state machine
30 *
31 */
32
33 struct irda_request_queue {
34 struct list_head request_list;
35 spinlock_t lock;
36 task_t *thread;
37 struct completion exit;
38 wait_queue_head_t kick, done;
39 atomic_t num_pending;
40 };
41
42 static struct irda_request_queue irda_rq_queue;
43
44 static int irda_queue_request(struct irda_request *rq)
45 {
46 int ret = 0;
47 unsigned long flags;
48
49 if (!test_and_set_bit(0, &rq->pending)) {
50 spin_lock_irqsave(&irda_rq_queue.lock, flags);
51 list_add_tail(&rq->lh_request, &irda_rq_queue.request_list);
52 wake_up(&irda_rq_queue.kick);
53 atomic_inc(&irda_rq_queue.num_pending);
54 spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
55 ret = 1;
56 }
57 return ret;
58 }
59
60 static void irda_request_timer(unsigned long data)
61 {
62 struct irda_request *rq = (struct irda_request *)data;
63 unsigned long flags;
64
65 spin_lock_irqsave(&irda_rq_queue.lock, flags);
66 list_add_tail(&rq->lh_request, &irda_rq_queue.request_list);
67 wake_up(&irda_rq_queue.kick);
68 spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
69 }
70
71 static int irda_queue_delayed_request(struct irda_request *rq, unsigned long delay)
72 {
73 int ret = 0;
74 struct timer_list *timer = &rq->timer;
75
76 if (!test_and_set_bit(0, &rq->pending)) {
77 timer->expires = jiffies + delay;
78 timer->function = irda_request_timer;
79 timer->data = (unsigned long)rq;
80 atomic_inc(&irda_rq_queue.num_pending);
81 add_timer(timer);
82 ret = 1;
83 }
84 return ret;
85 }
86
87 static void run_irda_queue(void)
88 {
89 unsigned long flags;
90 struct list_head *entry, *tmp;
91 struct irda_request *rq;
92
93 spin_lock_irqsave(&irda_rq_queue.lock, flags);
94 list_for_each_safe(entry, tmp, &irda_rq_queue.request_list) {
95 rq = list_entry(entry, struct irda_request, lh_request);
96 list_del_init(entry);
97 spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
98
99 clear_bit(0, &rq->pending);
100 rq->func(rq->data);
101
102 if (atomic_dec_and_test(&irda_rq_queue.num_pending))
103 wake_up(&irda_rq_queue.done);
104
105 spin_lock_irqsave(&irda_rq_queue.lock, flags);
106 }
107 spin_unlock_irqrestore(&irda_rq_queue.lock, flags);
108 }
109
110 static int irda_thread(void *startup)
111 {
112 DECLARE_WAITQUEUE(wait, current);
113
114 daemonize("kIrDAd");
115
116 irda_rq_queue.thread = current;
117
118 complete((struct completion *)startup);
119
120 while (irda_rq_queue.thread != NULL) {
121
122 /* We use TASK_INTERRUPTIBLE, rather than
123 * TASK_UNINTERRUPTIBLE. Andrew Morton made this
124 * change ; he told me that it is safe, because "signal
125 * blocking is now handled in daemonize()", he added
126 * that the problem is that "uninterruptible sleep
127 * contributes to load average", making user worry.
128 * Jean II */
129 set_task_state(current, TASK_INTERRUPTIBLE);
130 add_wait_queue(&irda_rq_queue.kick, &wait);
131 if (list_empty(&irda_rq_queue.request_list))
132 schedule();
133 else
134 __set_task_state(current, TASK_RUNNING);
135 remove_wait_queue(&irda_rq_queue.kick, &wait);
136
137 /* make swsusp happy with our thread */
138 if (current->flags & PF_FREEZE)
139 refrigerator(PF_FREEZE);
140
141 run_irda_queue();
142 }
143
144 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,35)
145 reparent_to_init();
146 #endif
147 complete_and_exit(&irda_rq_queue.exit, 0);
148 /* never reached */
149 return 0;
150 }
151
152
153 static void flush_irda_queue(void)
154 {
155 if (atomic_read(&irda_rq_queue.num_pending)) {
156
157 DECLARE_WAITQUEUE(wait, current);
158
159 if (!list_empty(&irda_rq_queue.request_list))
160 run_irda_queue();
161
162 set_task_state(current, TASK_UNINTERRUPTIBLE);
163 add_wait_queue(&irda_rq_queue.done, &wait);
164 if (atomic_read(&irda_rq_queue.num_pending))
165 schedule();
166 else
167 __set_task_state(current, TASK_RUNNING);
168 remove_wait_queue(&irda_rq_queue.done, &wait);
169 }
170 }
171
172 /* substate handler of the config-fsm to handle the cases where we want
173 * to wait for transmit completion before changing the port configuration
174 */
175
176 static int irda_tx_complete_fsm(struct sir_dev *dev)
177 {
178 struct sir_fsm *fsm = &dev->fsm;
179 unsigned next_state, delay;
180 unsigned bytes_left;
181
182 do {
183 next_state = fsm->substate; /* default: stay in current substate */
184 delay = 0;
185
186 switch(fsm->substate) {
187
188 case SIRDEV_STATE_WAIT_XMIT:
189 if (dev->drv->chars_in_buffer)
190 bytes_left = dev->drv->chars_in_buffer(dev);
191 else
192 bytes_left = 0;
193 if (!bytes_left) {
194 next_state = SIRDEV_STATE_WAIT_UNTIL_SENT;
195 break;
196 }
197
198 if (dev->speed > 115200)
199 delay = (bytes_left*8*10000) / (dev->speed/100);
200 else if (dev->speed > 0)
201 delay = (bytes_left*10*10000) / (dev->speed/100);
202 else
203 delay = 0;
204 /* expected delay (usec) until remaining bytes are sent */
205 if (delay < 100) {
206 udelay(delay);
207 delay = 0;
208 break;
209 }
210 /* sleep some longer delay (msec) */
211 delay = (delay+999) / 1000;
212 break;
213
214 case SIRDEV_STATE_WAIT_UNTIL_SENT:
215 /* block until underlaying hardware buffer are empty */
216 if (dev->drv->wait_until_sent)
217 dev->drv->wait_until_sent(dev);
218 next_state = SIRDEV_STATE_TX_DONE;
219 break;
220
221 case SIRDEV_STATE_TX_DONE:
222 return 0;
223
224 default:
225 ERROR("%s - undefined state\n", __FUNCTION__);
226 return -EINVAL;
227 }
228 fsm->substate = next_state;
229 } while (delay == 0);
230 return delay;
231 }
232
233 /*
234 * Function irda_config_fsm
235 *
236 * State machine to handle the configuration of the device (and attached dongle, if any).
237 * This handler is scheduled for execution in kIrDAd context, so we can sleep.
238 * however, kIrDAd is shared by all sir_dev devices so we better don't sleep there too
239 * long. Instead, for longer delays we start a timer to reschedule us later.
240 * On entry, fsm->sem is always locked and the netdev xmit queue stopped.
241 * Both must be unlocked/restarted on completion - but only on final exit.
242 */
243
244 static void irda_config_fsm(void *data)
245 {
246 struct sir_dev *dev = data;
247 struct sir_fsm *fsm = &dev->fsm;
248 int next_state;
249 int ret = -1;
250 unsigned delay;
251
252 IRDA_DEBUG(2, "%s(), <%ld>\n", __FUNCTION__, jiffies);
253
254 do {
255 IRDA_DEBUG(3, "%s - state=0x%04x / substate=0x%04x\n",
256 __FUNCTION__, fsm->state, fsm->substate);
257
258 next_state = fsm->state;
259 delay = 0;
260
261 switch(fsm->state) {
262
263 case SIRDEV_STATE_DONGLE_OPEN:
264 if (dev->dongle_drv != NULL) {
265 ret = sirdev_put_dongle(dev);
266 if (ret) {
267 fsm->result = -EINVAL;
268 next_state = SIRDEV_STATE_ERROR;
269 break;
270 }
271 }
272
273 /* Initialize dongle */
274 ret = sirdev_get_dongle(dev, fsm->param);
275 if (ret) {
276 fsm->result = ret;
277 next_state = SIRDEV_STATE_ERROR;
278 break;
279 }
280
281 /* Dongles are powered through the modem control lines which
282 * were just set during open. Before resetting, let's wait for
283 * the power to stabilize. This is what some dongle drivers did
284 * in open before, while others didn't - should be safe anyway.
285 */
286
287 delay = 50;
288 fsm->substate = SIRDEV_STATE_DONGLE_RESET;
289 next_state = SIRDEV_STATE_DONGLE_RESET;
290
291 fsm->param = 9600;
292
293 break;
294
295 case SIRDEV_STATE_DONGLE_CLOSE:
296 /* shouldn't we just treat this as success=? */
297 if (dev->dongle_drv == NULL) {
298 fsm->result = -EINVAL;
299 next_state = SIRDEV_STATE_ERROR;
300 break;
301 }
302
303 ret = sirdev_put_dongle(dev);
304 if (ret) {
305 fsm->result = ret;
306 next_state = SIRDEV_STATE_ERROR;
307 break;
308 }
309 next_state = SIRDEV_STATE_DONE;
310 break;
311
312 case SIRDEV_STATE_SET_DTR_RTS:
313 ret = sirdev_set_dtr_rts(dev,
314 (fsm->param&0x02) ? TRUE : FALSE,
315 (fsm->param&0x01) ? TRUE : FALSE);
316 next_state = SIRDEV_STATE_DONE;
317 break;
318
319 case SIRDEV_STATE_SET_SPEED:
320 fsm->substate = SIRDEV_STATE_WAIT_XMIT;
321 next_state = SIRDEV_STATE_DONGLE_CHECK;
322 break;
323
324 case SIRDEV_STATE_DONGLE_CHECK:
325 ret = irda_tx_complete_fsm(dev);
326 if (ret < 0) {
327 fsm->result = ret;
328 next_state = SIRDEV_STATE_ERROR;
329 break;
330 }
331 if ((delay=ret) != 0)
332 break;
333
334 if (dev->dongle_drv) {
335 fsm->substate = SIRDEV_STATE_DONGLE_RESET;
336 next_state = SIRDEV_STATE_DONGLE_RESET;
337 }
338 else {
339 dev->speed = fsm->param;
340 next_state = SIRDEV_STATE_PORT_SPEED;
341 }
342 break;
343
344 case SIRDEV_STATE_DONGLE_RESET:
345 if (dev->dongle_drv->reset) {
346 ret = dev->dongle_drv->reset(dev);
347 if (ret < 0) {
348 fsm->result = ret;
349 next_state = SIRDEV_STATE_ERROR;
350 break;
351 }
352 }
353 else
354 ret = 0;
355 if ((delay=ret) == 0) {
356 /* set serial port according to dongle default speed */
357 if (dev->drv->set_speed)
358 dev->drv->set_speed(dev, dev->speed);
359 fsm->substate = SIRDEV_STATE_DONGLE_SPEED;
360 next_state = SIRDEV_STATE_DONGLE_SPEED;
361 }
362 break;
363
364 case SIRDEV_STATE_DONGLE_SPEED:
365 if (dev->dongle_drv->reset) {
366 ret = dev->dongle_drv->set_speed(dev, fsm->param);
367 if (ret < 0) {
368 fsm->result = ret;
369 next_state = SIRDEV_STATE_ERROR;
370 break;
371 }
372 }
373 else
374 ret = 0;
375 if ((delay=ret) == 0)
376 next_state = SIRDEV_STATE_PORT_SPEED;
377 break;
378
379 case SIRDEV_STATE_PORT_SPEED:
380 /* Finally we are ready to change the serial port speed */
381 if (dev->drv->set_speed)
382 dev->drv->set_speed(dev, dev->speed);
383 dev->new_speed = 0;
384 next_state = SIRDEV_STATE_DONE;
385 break;
386
387 case SIRDEV_STATE_DONE:
388 /* Signal network layer so it can send more frames */
389 netif_wake_queue(dev->netdev);
390 next_state = SIRDEV_STATE_COMPLETE;
391 break;
392
393 default:
394 ERROR("%s - undefined state\n", __FUNCTION__);
395 fsm->result = -EINVAL;
396 /* fall thru */
397
398 case SIRDEV_STATE_ERROR:
399 ERROR("%s - error: %d\n", __FUNCTION__, fsm->result);
400
401 #if 0 /* don't enable this before we have netdev->tx_timeout to recover */
402 netif_stop_queue(dev->netdev);
403 #else
404 netif_wake_queue(dev->netdev);
405 #endif
406 /* fall thru */
407
408 case SIRDEV_STATE_COMPLETE:
409 /* config change finished, so we are not busy any longer */
410 sirdev_enable_rx(dev);
411 up(&fsm->sem);
412 return;
413 }
414 fsm->state = next_state;
415 } while(!delay);
416
417 irda_queue_delayed_request(&fsm->rq, msecs_to_jiffies(delay));
418 }
419
420 /* schedule some device configuration task for execution by kIrDAd
421 * on behalf of the above state machine.
422 * can be called from process or interrupt/tasklet context.
423 */
424
425 int sirdev_schedule_request(struct sir_dev *dev, int initial_state, unsigned param)
426 {
427 struct sir_fsm *fsm = &dev->fsm;
428 int xmit_was_down;
429
430 IRDA_DEBUG(2, "%s - state=0x%04x / param=%u\n", __FUNCTION__, initial_state, param);
431
432 if (down_trylock(&fsm->sem)) {
433 if (in_interrupt() || in_atomic() || irqs_disabled()) {
434 IRDA_DEBUG(1, "%s(), state machine busy!\n", __FUNCTION__);
435 return -EWOULDBLOCK;
436 } else
437 down(&fsm->sem);
438 }
439
440 if (fsm->state == SIRDEV_STATE_DEAD) {
441 /* race with sirdev_close should never happen */
442 ERROR("%s(), instance staled!\n", __FUNCTION__);
443 up(&fsm->sem);
444 return -ESTALE; /* or better EPIPE? */
445 }
446
447 xmit_was_down = netif_queue_stopped(dev->netdev);
448 netif_stop_queue(dev->netdev);
449 atomic_set(&dev->enable_rx, 0);
450
451 fsm->state = initial_state;
452 fsm->param = param;
453 fsm->result = 0;
454
455 INIT_LIST_HEAD(&fsm->rq.lh_request);
456 fsm->rq.pending = 0;
457 fsm->rq.func = irda_config_fsm;
458 fsm->rq.data = dev;
459
460 if (!irda_queue_request(&fsm->rq)) { /* returns 0 on error! */
461 atomic_set(&dev->enable_rx, 1);
462 if (!xmit_was_down)
463 netif_wake_queue(dev->netdev);
464 up(&fsm->sem);
465 return -EAGAIN;
466 }
467 return 0;
468 }
469
470 int __init irda_thread_create(void)
471 {
472 struct completion startup;
473 int pid;
474
475 spin_lock_init(&irda_rq_queue.lock);
476 irda_rq_queue.thread = NULL;
477 INIT_LIST_HEAD(&irda_rq_queue.request_list);
478 init_waitqueue_head(&irda_rq_queue.kick);
479 init_waitqueue_head(&irda_rq_queue.done);
480 atomic_set(&irda_rq_queue.num_pending, 0);
481
482 init_completion(&startup);
483 pid = kernel_thread(irda_thread, &startup, CLONE_FS|CLONE_FILES);
484 if (pid <= 0)
485 return -EAGAIN;
486 else
487 wait_for_completion(&startup);
488
489 return 0;
490 }
491
492 void __exit irda_thread_join(void)
493 {
494 if (irda_rq_queue.thread) {
495 flush_irda_queue();
496 init_completion(&irda_rq_queue.exit);
497 irda_rq_queue.thread = NULL;
498 wake_up(&irda_rq_queue.kick);
499 wait_for_completion(&irda_rq_queue.exit);
500 }
501 }
502
503
|
This page was automatically generated by the
LXR engine.
|