?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2.2.0-final
[davej-history.git] / net / irda / irlpt / irlpt_cli.c
blobc98985cfbfe081efd7a9b8744506d029c137a645
1 /*********************************************************************
2 *
3 * Filename: irlpt.c
4 * Version:
5 * Description:
6 * Status: Experimental.
7 * Author: Thomas Davis, <ratbert@radiks.net>
8 * Created at: Sat Feb 21 18:54:38 1998
9 * Modified at: Sun Mar 8 23:44:19 1998
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 * Sources: irlan.c
12 *
13 * Copyright (c) 1998, Thomas Davis, <ratbert@radiks.net>,
14 * Copyright (c) 1998, Dag Brattli, <dagb@cs.uit.no>
15 * All Rights Reserved.
16 *
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License as
19 * published by the Free Software Foundation; either version 2 of
20 * the License, or (at your option) any later version.
21 *
22 * I, Thomas Davis, provide no warranty for any of this software.
23 * This material is provided "AS-IS" and at no charge.
24 *
25 ********************************************************************/
26
27 #include <net/irda/irlap.h>
28 #include <net/irda/irttp.h>
29 #include <net/irda/irlmp.h>
30 #include <net/irda/irias_object.h>
31 #include <net/irda/iriap.h>
32 #include <net/irda/irlpt_common.h>
33 #include <net/irda/irlpt_cli.h>
34 #include <net/irda/irlpt_cli_fsm.h>
35 #include <net/irda/timer.h>
36 #include <net/irda/irda.h>
37
38 #include <linux/config.h>
39 #include <linux/init.h>
40 #include <linux/module.h>
41
42 #include <asm/uaccess.h>
43 #include <linux/miscdevice.h>
44 #include <linux/proc_fs.h>
45
46 int irlpt_client_init(void);
47 static void irlpt_client_cleanup(void);
48 static void irlpt_client_close(struct irlpt_cb *self);
49
50 static void irlpt_client_discovery_indication( DISCOVERY *);
51
52 static void irlpt_client_connect_confirm( void *instance, void *sap,
53 struct qos_info *qos,
54 int max_seg_size,
55 struct sk_buff *skb);
56 static void irlpt_client_disconnect_indication( void *instance, void *sap,
57 LM_REASON reason,
58 struct sk_buff *userdata);
59
60 #if 0
61 static char *rcsid = "$Id: irlpt_client.c,v 1.10 1998/11/10 22:50:57 dagb Exp $";
62 #endif
63 static char *version = "IrLPT, $Revision: 1.10 $/$Date: 1998/11/10 22:50:57 $ (Thomas Davis)";
64
65 struct file_operations client_fops = {
66 irlpt_seek, /* seek */
67 NULL, /* read_irlpt (server) */
68 irlpt_write, /* write */
69 NULL, /* readdir */
70 NULL, /* poll */
71 NULL, /* ioctl */
72 NULL, /* mmap */
73 irlpt_open, /* open */
74 NULL, /* flush */
75 irlpt_close, /* release */
76 NULL, /* fsync */
77 NULL, /* fasync */
78 NULL, /* check_media_change */
79 NULL, /* revalidate */
80 NULL, /* lock */
81 };
82
83 int irlpt_client_debug = 4;
84
85 extern char *irlptstate[];
86
87 #ifdef CONFIG_PROC_FS
88
89 /*
90 * Function client_proc_read (buf, start, offset, len, unused)
91 *
92 */
93 static int irlpt_client_proc_read( char *buf, char **start, off_t offset,
94 int len, int unused)
95 {
96 struct irlpt_cb *self;
97 int index;
98
99 len = sprintf(buf, "%s\n\n", version);
100
101 self = (struct irlpt_cb *) hashbin_get_first( irlpt_clients);
102 while( self) {
103 ASSERT( self != NULL, return len;);
104 ASSERT( self->magic == IRLPT_MAGIC, return len;);
105
106 len += sprintf(buf+len, "ifname: %s\n", self->ifname);
107 len += sprintf(buf+len, "minor: %d\n", self->ir_dev.minor);
108
109 switch ( self->servicetype) {
110 case IRLPT_UNKNOWN:
111 index = 0;
112 break;
113 case IRLPT_THREE_WIRE_RAW:
114 index = 1;
115 break;
116 case IRLPT_THREE_WIRE:
117 index = 2;
118 break;
119 case IRLPT_NINE_WIRE:
120 index = 3;
121 break;
122 case IRLPT_CENTRONICS:
123 index = 4;
124 break;
125 case IRLPT_SERVER_MODE:
126 index = 5;
127 break;
128 default:
129 index = 0;
130 break;
131 }
132
133 len += sprintf(buf+len, "service_type: %s\n",
134 irlpt_service_type[index]);
135 len += sprintf(buf+len, "port_type: %s\n",
136 irlpt_port_type[ self->porttype]);
137 len += sprintf(buf+len, "daddr: 0x%08x\n", self->daddr);
138 len += sprintf(buf+len, "fsm_state: %s\n",
139 irlpt_client_fsm_state[self->state]);
140 len += sprintf(buf+len, "retries: %d\n", self->open_retries);
141 len += sprintf(buf+len, "dlsap: %d\n", self->dlsap_sel);
142
143 len += sprintf(buf+len, "count: %d\n", self->count);
144 len += sprintf(buf+len, "rx_queue: %d\n",
145 skb_queue_len(&self->rx_queue));
146 len += sprintf(buf+len, "\n\n");
147
148 self = (struct irlpt_cb *) hashbin_get_next( irlpt_clients);
149 }
150
151 return len;
152 }
153
154 struct proc_dir_entry proc_irlpt_client = {
155 0, 12, "irlpt_client",
156 S_IFREG | S_IRUGO, 1, 0, 0,
157 0, NULL /* ops -- default to array */,
158 &irlpt_client_proc_read /* get_info */,
159 };
160
161 extern struct proc_dir_entry proc_irda;
162
163 #endif /* CONFIG_PROC_FS */
164
165 /*
166 * Function irlpt_init (dev)
167 *
168 * Initializes the irlpt control structure
169 *
170 */
171 __initfunc(int irlpt_client_init(void))
172 {
173 DEBUG( irlpt_client_debug, "--> "__FUNCTION__ "\n");
174
175 printk( KERN_INFO "%s\n", version);
176
177 irlpt_clients = hashbin_new( HB_LOCAL);
178 if ( irlpt_clients == NULL) {
179 printk( KERN_WARNING "IrLPT: Can't allocate hashbin!\n");
180 return -ENOMEM;
181 }
182
183 irlmp_register_layer( S_PRINTER, CLIENT, TRUE,
184 irlpt_client_discovery_indication);
185
186 #ifdef CONFIG_PROC_FS
187 proc_register( &proc_irda, &proc_irlpt_client);
188 #endif /* CONFIG_PROC_FS */
189
190 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
191
192 return 0;
193 }
194
195
196 #ifdef MODULE
197 /*
198 * Function irlpt_cleanup (void)
199 *
200 *
201 *
202 */
203 static void irlpt_client_cleanup(void)
204 {
205 DEBUG( irlpt_client_debug, "--> "__FUNCTION__ "\n");
206
207 irlmp_unregister_layer( S_PRINTER, CLIENT);
208
209 /*
210 * Delete hashbin and close all irlan client instances in it
211 */
212 hashbin_delete( irlpt_clients, (FREE_FUNC) irlpt_client_close);
213
214 #ifdef CONFIG_PROC_FS
215 proc_unregister( &proc_irda, proc_irlpt_client.low_ino);
216 #endif
217
218 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
219 }
220 #endif /* MODULE */
221
222
223 /*
224 * Function irlpt_open (void)
225 *
226 * This is the entry-point which starts all the fun! Currently this
227 *
228 */
229 static struct irlpt_cb *irlpt_client_open( __u32 daddr)
230 {
231 struct irlpt_cb *self;
232
233 DEBUG( irlpt_client_debug, "--> "__FUNCTION__ "\n");
234
235 self = kmalloc(sizeof(struct irlpt_cb), GFP_ATOMIC);
236 if (self == NULL)
237 return NULL;
238
239 memset(self, 0, sizeof(struct irlpt_cb));
240
241 ASSERT( self != NULL, return NULL;);
242
243 sprintf(self->ifname, "irlpt%d", hashbin_get_size(irlpt_clients));
244 self->ir_dev.minor = MISC_DYNAMIC_MINOR;
245 self->ir_dev.name = self->ifname;
246 self->ir_dev.fops = &client_fops;
247
248 misc_register(&self->ir_dev);
249
250 self->magic = IRLPT_MAGIC;
251 self->in_use = TRUE;
252 self->servicetype = IRLPT_THREE_WIRE_RAW;
253 self->porttype = IRLPT_SERIAL;
254
255 skb_queue_head_init(&self->rx_queue);
256
257 irlpt_client_next_state( self, IRLPT_CLIENT_IDLE);
258
259 hashbin_insert( irlpt_clients, (QUEUE *) self, daddr, NULL);
260
261 /* MOD_INC_USE_COUNT; */
262
263 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
264
265 return self;
266 }
267
268 /*
269 * Function irlpt_client_close (self)
270 *
271 * This function closes and marks the IrLPT instance as not in use.
272 */
273 static void irlpt_client_close( struct irlpt_cb *self)
274 {
275 struct sk_buff *skb;
276
277 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
278
279 ASSERT( self != NULL, return;);
280 ASSERT( self->magic == IRLPT_MAGIC, return;);
281
282 while (( skb = skb_dequeue(&self->rx_queue)) != NULL) {
283 DEBUG(3, "irlpt_client_close: freeing SKB\n");
284 dev_kfree_skb( skb);
285 }
286
287 misc_deregister(&self->ir_dev);
288
289 self->magic = ~IRLPT_MAGIC;
290
291 kfree( self);
292
293 /* MOD_DEC_USE_COUNT; */
294
295 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
296 }
297
298 /*
299 * Function irlpt_discovery_indication (daddr)
300 *
301 * Remote device discovered, try query the remote IAS to see which
302 * device it is, and which services it has.
303 *
304 */
305 static void irlpt_client_discovery_indication( DISCOVERY *discovery)
306 {
307 struct irlpt_info info;
308 struct irlpt_cb *self;
309 __u32 daddr;
310
311 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
312
313 ASSERT( irlpt_clients != NULL, return;);
314 ASSERT( discovery != NULL, return;);
315
316 daddr = discovery->daddr;
317
318 /*
319 * Check if an instance is already dealing with this device
320 * (daddr)
321 */
322 self = (struct irlpt_cb *) hashbin_find( irlpt_clients, daddr, NULL);
323 if ( self != NULL) {
324 ASSERT( self->magic == IRLPT_MAGIC, return;);
325 if ( self->state == IRLPT_CLIENT_IDLE) {
326 irlpt_client_do_event( self,
327 IRLPT_DISCOVERY_INDICATION,
328 NULL, &info);
329 }
330 return;
331 }
332
333
334 /*
335 * We have no instance for daddr, so time to start a new instance.
336 * First we must find a free entry in master array
337 */
338 if (( self = irlpt_client_open( daddr)) == NULL) {
339 DEBUG(irlpt_client_debug, __FUNCTION__
340 ":irlpt_client_open failed!\n");
341 }
342
343 ASSERT(self != NULL, return;);
344 ASSERT(self->magic == IRLPT_MAGIC, return;);
345
346 self->daddr = info.daddr = daddr;
347
348 if (self->state == IRLPT_CLIENT_IDLE) {
349 irlpt_client_do_event( self, IRLPT_DISCOVERY_INDICATION,
350 NULL, &info);
351 }
352
353 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
354 }
355
356 /*
357 * Function irlpt_disconnect_indication (handle)
358 *
359 */
360 static void irlpt_client_disconnect_indication( void *instance, void *sap,
361 LM_REASON reason,
362 struct sk_buff *skb)
363 {
364 struct irlpt_info info;
365 struct irlpt_cb *self;
366
367 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
368
369 self = ( struct irlpt_cb *) instance;
370
371 ASSERT( self != NULL, return;);
372 ASSERT( self->magic == IRLPT_MAGIC, return;);
373
374 info.daddr = self->daddr;
375
376 DEBUG( irlpt_client_debug, __FUNCTION__
377 ": reason=%d (%s), peersap=%d\n",
378 reason, irlpt_reasons[reason], self->dlsap_sel);
379
380 self->connected = IRLPT_DISCONNECTED;
381 self->eof = reason;
382
383 wake_up_interruptible( &self->write_wait);
384
385 irlpt_client_do_event( self, LMP_DISCONNECT, NULL, NULL);
386
387 if (skb) {
388 dev_kfree_skb( skb);
389 }
390
391 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
392 }
393
394 /*
395 * Function irlpt_connect_confirm (handle, qos, skb)
396 *
397 * LSAP connection confirmed!
398 */
399 static void irlpt_client_connect_confirm( void *instance, void *sap,
400 struct qos_info *qos,
401 int max_sdu_size,
402 struct sk_buff *skb)
403 {
404 struct irlpt_info info;
405 struct irlpt_cb *self;
406
407 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
408
409 self = ( struct irlpt_cb *) instance;
410
411 ASSERT( self != NULL, return;);
412 ASSERT( self->magic == IRLPT_MAGIC, return;);
413
414 info.daddr = self->daddr;
415
416 /*
417 * Check if we have got some QoS parameters back! This should be the
418 * negotiated QoS for the link.
419 */
420 if ( qos) {
421 DEBUG( irlpt_client_debug, __FUNCTION__ ": Frame Size: %d\n",
422 qos->data_size.value);
423 }
424
425 self->irlap_data_size = (qos->data_size.value - IRLPT_MAX_HEADER);
426 self->connected = TRUE;
427
428 irlpt_client_do_event( self, LMP_CONNECT, NULL, NULL);
429
430 if (skb) {
431 dev_kfree_skb( skb);
432 }
433
434 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
435 }
436
437 /*
438 * Function client_data_indication (handle, skb)
439 *
440 * This function gets the data that is received on the data channel
441 *
442 */
443 static void irlpt_client_data_indication( void *instance, void *sap,
444 struct sk_buff *skb)
445 {
446 struct irlpt_cb *self;
447
448 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
449
450 ASSERT( skb != NULL, return;);
451 DEBUG( irlpt_client_debug, __FUNCTION__ ": len=%d\n", (int) skb->len);
452
453 self = ( struct irlpt_cb *) instance;
454
455 ASSERT( self != NULL, return;);
456 ASSERT( self->magic == IRLPT_MAGIC, return;);
457 #if 1
458 {
459 int i;
460
461 for(i=0;i<skb->len;i++)
462 if (skb->data[i] > 31 && skb->data[i] < 128) {
463 printk("%c", skb->data[i]);
464 } else {
465 if (skb->data[i] == 0x0d) {
466 printk("\n");
467 } else {
468 printk(".");
469 }
470 }
471
472 printk("\n");
473 }
474 #endif
475
476 skb_queue_tail(&self->rx_queue, skb);
477 wake_up_interruptible(&self->read_wait);
478
479 /* if (skb) { */
480 /* dev_kfree_skb( skb); */
481 /* } */
482
483 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
484 }
485
486 /*
487 * Function irlpt_get_value_confirm (obj_id, type, value_int, value_char, priv)
488 *
489 * Fixed to match changes in iriap.h, DB.
490 *
491 */
492
493 void irlpt_client_get_value_confirm(__u16 obj_id, struct ias_value *value,
494 void *priv)
495 {
496 struct irlpt_info info;
497 struct irlpt_cb *self;
498
499 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
500
501 ASSERT( priv != NULL, return;);
502
503 self = (struct irlpt_cb *) priv;
504
505 ASSERT( self != NULL, return;);
506 ASSERT( self->magic == IRLPT_MAGIC, return;);
507
508 /* can't stop here.. if we get a bad obj, must tell the state
509 machine that!
510 ASSERT( type == IAS_INTEGER, return;);
511 */
512
513 if ( value->type == IAS_INTEGER && value->t.integer != -1) {
514 info.dlsap_sel = value->t.integer;
515 self->dlsap_sel = value->t.integer;
516
517 DEBUG( irlpt_client_debug, __FUNCTION__
518 ": obj_id = %d, value = %d\n",
519 obj_id, value->t.integer);
520
521 irlpt_client_do_event( self, IAS_PROVIDER_AVAIL,
522 NULL, &info);
523 } else
524 irlpt_client_do_event( self, IAS_PROVIDER_NOT_AVAIL,
525 NULL, &info);
526
527 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
528 }
529
530 void irlpt_client_connect_request( struct irlpt_cb *self)
531 {
532 struct notify_t lpt_notify;
533
534 DEBUG( irlpt_client_debug, "--> " __FUNCTION__ "\n");
535
536 ASSERT( self != NULL, return;);
537 ASSERT( self->magic == IRLPT_MAGIC, return;);
538
539 lpt_notify.connect_confirm = irlpt_client_connect_confirm;
540 lpt_notify.disconnect_indication = irlpt_client_disconnect_indication;
541 lpt_notify.data_indication = irlpt_client_data_indication;
542 lpt_notify.instance = self;
543
544 self->lsap = irlmp_open_lsap( LSAP_ANY, &lpt_notify);
545 DEBUG( irlpt_client_debug, __FUNCTION__ ": Dest LSAP sel= %d\n",
546 self->dlsap_sel);
547
548 if (self->servicetype == IRLPT_THREE_WIRE_RAW) {
549 DEBUG( irlpt_client_debug, __FUNCTION__
550 ": issue THREE_WIRE_RAW connect\n");
551 irlmp_connect_request( self->lsap, self->dlsap_sel,
552 self->daddr, NULL, NULL);
553 }
554
555 DEBUG( irlpt_client_debug, __FUNCTION__ " -->\n");
556 }
557
558
559 #ifdef MODULE
560
561 MODULE_AUTHOR("Thomas Davis <ratbert@radiks.net>");
562 MODULE_DESCRIPTION("The Linux IrDA/IrLPT protocol");
563
564 /*
565 * Function init_module (void)
566 *
567 * Initialize the IrLPT client module, this function is called by the
568 * modprobe(1) program.
569 */
570 int init_module(void)
571 {
572
573 DEBUG( irlpt_client_debug, "--> irlpt client: init_module\n");
574
575 irlpt_client_init();
576
577 DEBUG( irlpt_client_debug, "irlpt client: init_module -->\n");
578
579 return 0;
580 }
581
582 /*
583 * Function cleanup_module (void)
584 *
585 * Remove the IrLPT server module, this function is called by the rmmod(1)
586 * program
587 */
588 void cleanup_module(void)
589 {
590 DEBUG( irlpt_client_debug, "--> irlpt client: cleanup_module\n");
591 /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
592
593 /* Free some memory */
594 irlpt_client_cleanup();
595
596 DEBUG( irlpt_client_debug, "irlpt client: cleanup_module -->\n");
597 }
598
599 #endif /* MODULE */
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux