1 /*********************************************************************
2 *
3 * Filename: ircomm_param.c
4 * Version: 1.0
5 * Description: Parameter handling for the IrCOMM protocol
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Mon Jun 7 10:25:11 1999
9 * Modified at: Sun Jan 30 14:32:03 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License as
16 * published by the Free Software Foundation; either version 2 of
17 * the License, or (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 *
27 ********************************************************************/
28
29 #include <linux/gfp.h>
30 #include <linux/workqueue.h>
31 #include <linux/interrupt.h>
32
33 #include <net/irda/irda.h>
34 #include <net/irda/parameters.h>
35
36 #include <net/irda/ircomm_core.h>
37 #include <net/irda/ircomm_tty_attach.h>
38 #include <net/irda/ircomm_tty.h>
39
40 #include <net/irda/ircomm_param.h>
41
42 static int ircomm_param_service_type(void *instance, irda_param_t *param,
43 int get);
44 static int ircomm_param_port_type(void *instance, irda_param_t *param,
45 int get);
46 static int ircomm_param_port_name(void *instance, irda_param_t *param,
47 int get);
48 static int ircomm_param_service_type(void *instance, irda_param_t *param,
49 int get);
50 static int ircomm_param_data_rate(void *instance, irda_param_t *param,
51 int get);
52 static int ircomm_param_data_format(void *instance, irda_param_t *param,
53 int get);
54 static int ircomm_param_flow_control(void *instance, irda_param_t *param,
55 int get);
56 static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get);
57 static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get);
58 static int ircomm_param_line_status(void *instance, irda_param_t *param,
59 int get);
60 static int ircomm_param_dte(void *instance, irda_param_t *param, int get);
61 static int ircomm_param_dce(void *instance, irda_param_t *param, int get);
62 static int ircomm_param_poll(void *instance, irda_param_t *param, int get);
63
64 static const pi_minor_info_t pi_minor_call_table_common[] = {
65 { ircomm_param_service_type, PV_INT_8_BITS },
66 { ircomm_param_port_type, PV_INT_8_BITS },
67 { ircomm_param_port_name, PV_STRING }
68 };
69 static const pi_minor_info_t pi_minor_call_table_non_raw[] = {
70 { ircomm_param_data_rate, PV_INT_32_BITS | PV_BIG_ENDIAN },
71 { ircomm_param_data_format, PV_INT_8_BITS },
72 { ircomm_param_flow_control, PV_INT_8_BITS },
73 { ircomm_param_xon_xoff, PV_INT_16_BITS },
74 { ircomm_param_enq_ack, PV_INT_16_BITS },
75 { ircomm_param_line_status, PV_INT_8_BITS }
76 };
77 static const pi_minor_info_t pi_minor_call_table_9_wire[] = {
78 { ircomm_param_dte, PV_INT_8_BITS },
79 { ircomm_param_dce, PV_INT_8_BITS },
80 { ircomm_param_poll, PV_NO_VALUE },
81 };
82
83 static const pi_major_info_t pi_major_call_table[] = {
84 { pi_minor_call_table_common, 3 },
85 { pi_minor_call_table_non_raw, 6 },
86 { pi_minor_call_table_9_wire, 3 }
87 /* { pi_minor_call_table_centronics } */
88 };
89
90 pi_param_info_t ircomm_param_info = { pi_major_call_table, 3, 0x0f, 4 };
91
92 /*
93 * Function ircomm_param_request (self, pi, flush)
94 *
95 * Queue a parameter for the control channel
96 *
97 */
ircomm_param_request(struct ircomm_tty_cb * self,__u8 pi,int flush)98 int ircomm_param_request(struct ircomm_tty_cb *self, __u8 pi, int flush)
99 {
100 unsigned long flags;
101 struct sk_buff *skb;
102 int count;
103
104 IRDA_ASSERT(self != NULL, return -1;);
105 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
106
107 /* Make sure we don't send parameters for raw mode */
108 if (self->service_type == IRCOMM_3_WIRE_RAW)
109 return 0;
110
111 spin_lock_irqsave(&self->spinlock, flags);
112
113 skb = self->ctrl_skb;
114 if (!skb) {
115 skb = alloc_skb(256, GFP_ATOMIC);
116 if (!skb) {
117 spin_unlock_irqrestore(&self->spinlock, flags);
118 return -ENOMEM;
119 }
120
121 skb_reserve(skb, self->max_header_size);
122 self->ctrl_skb = skb;
123 }
124 /*
125 * Inserting is a little bit tricky since we don't know how much
126 * room we will need. But this should hopefully work OK
127 */
128 count = irda_param_insert(self, pi, skb_tail_pointer(skb),
129 skb_tailroom(skb), &ircomm_param_info);
130 if (count < 0) {
131 net_warn_ratelimited("%s(), no room for parameter!\n",
132 __func__);
133 spin_unlock_irqrestore(&self->spinlock, flags);
134 return -1;
135 }
136 skb_put(skb, count);
137
138 spin_unlock_irqrestore(&self->spinlock, flags);
139
140 pr_debug("%s(), skb->len=%d\n", __func__ , skb->len);
141
142 if (flush) {
143 /* ircomm_tty_do_softint will take care of the rest */
144 schedule_work(&self->tqueue);
145 }
146
147 return count;
148 }
149
150 /*
151 * Function ircomm_param_service_type (self, buf, len)
152 *
153 * Handle service type, this function will both be called after the LM-IAS
154 * query and then the remote device sends its initial parameters
155 *
156 */
ircomm_param_service_type(void * instance,irda_param_t * param,int get)157 static int ircomm_param_service_type(void *instance, irda_param_t *param,
158 int get)
159 {
160 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
161 __u8 service_type = (__u8) param->pv.i;
162
163 IRDA_ASSERT(self != NULL, return -1;);
164 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
165
166 if (get) {
167 param->pv.i = self->settings.service_type;
168 return 0;
169 }
170
171 /* Find all common service types */
172 service_type &= self->service_type;
173 if (!service_type) {
174 pr_debug("%s(), No common service type to use!\n", __func__);
175 return -1;
176 }
177 pr_debug("%s(), services in common=%02x\n", __func__ ,
178 service_type);
179
180 /*
181 * Now choose a preferred service type of those available
182 */
183 if (service_type & IRCOMM_CENTRONICS)
184 self->settings.service_type = IRCOMM_CENTRONICS;
185 else if (service_type & IRCOMM_9_WIRE)
186 self->settings.service_type = IRCOMM_9_WIRE;
187 else if (service_type & IRCOMM_3_WIRE)
188 self->settings.service_type = IRCOMM_3_WIRE;
189 else if (service_type & IRCOMM_3_WIRE_RAW)
190 self->settings.service_type = IRCOMM_3_WIRE_RAW;
191
192 pr_debug("%s(), resulting service type=0x%02x\n", __func__ ,
193 self->settings.service_type);
194
195 /*
196 * Now the line is ready for some communication. Check if we are a
197 * server, and send over some initial parameters.
198 * Client do it in ircomm_tty_state_setup().
199 * Note : we may get called from ircomm_tty_getvalue_confirm(),
200 * therefore before we even have open any socket. And self->client
201 * is initialised to TRUE only later. So, we check if the link is
202 * really initialised. - Jean II
203 */
204 if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) &&
205 (!self->client) &&
206 (self->settings.service_type != IRCOMM_3_WIRE_RAW))
207 {
208 /* Init connection */
209 ircomm_tty_send_initial_parameters(self);
210 ircomm_tty_link_established(self);
211 }
212
213 return 0;
214 }
215
216 /*
217 * Function ircomm_param_port_type (self, param)
218 *
219 * The port type parameter tells if the devices are serial or parallel.
220 * Since we only advertise serial service, this parameter should only
221 * be equal to IRCOMM_SERIAL.
222 */
ircomm_param_port_type(void * instance,irda_param_t * param,int get)223 static int ircomm_param_port_type(void *instance, irda_param_t *param, int get)
224 {
225 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
226
227 IRDA_ASSERT(self != NULL, return -1;);
228 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
229
230 if (get)
231 param->pv.i = IRCOMM_SERIAL;
232 else {
233 self->settings.port_type = (__u8) param->pv.i;
234
235 pr_debug("%s(), port type=%d\n", __func__ ,
236 self->settings.port_type);
237 }
238 return 0;
239 }
240
241 /*
242 * Function ircomm_param_port_name (self, param)
243 *
244 * Exchange port name
245 *
246 */
ircomm_param_port_name(void * instance,irda_param_t * param,int get)247 static int ircomm_param_port_name(void *instance, irda_param_t *param, int get)
248 {
249 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
250
251 IRDA_ASSERT(self != NULL, return -1;);
252 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
253
254 if (get) {
255 pr_debug("%s(), not imp!\n", __func__);
256 } else {
257 pr_debug("%s(), port-name=%s\n", __func__ , param->pv.c);
258 strncpy(self->settings.port_name, param->pv.c, 32);
259 }
260
261 return 0;
262 }
263
264 /*
265 * Function ircomm_param_data_rate (self, param)
266 *
267 * Exchange data rate to be used in this settings
268 *
269 */
ircomm_param_data_rate(void * instance,irda_param_t * param,int get)270 static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get)
271 {
272 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
273
274 IRDA_ASSERT(self != NULL, return -1;);
275 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
276
277 if (get)
278 param->pv.i = self->settings.data_rate;
279 else
280 self->settings.data_rate = param->pv.i;
281
282 pr_debug("%s(), data rate = %d\n", __func__ , param->pv.i);
283
284 return 0;
285 }
286
287 /*
288 * Function ircomm_param_data_format (self, param)
289 *
290 * Exchange data format to be used in this settings
291 *
292 */
ircomm_param_data_format(void * instance,irda_param_t * param,int get)293 static int ircomm_param_data_format(void *instance, irda_param_t *param,
294 int get)
295 {
296 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
297
298 IRDA_ASSERT(self != NULL, return -1;);
299 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
300
301 if (get)
302 param->pv.i = self->settings.data_format;
303 else
304 self->settings.data_format = (__u8) param->pv.i;
305
306 return 0;
307 }
308
309 /*
310 * Function ircomm_param_flow_control (self, param)
311 *
312 * Exchange flow control settings to be used in this settings
313 *
314 */
ircomm_param_flow_control(void * instance,irda_param_t * param,int get)315 static int ircomm_param_flow_control(void *instance, irda_param_t *param,
316 int get)
317 {
318 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
319
320 IRDA_ASSERT(self != NULL, return -1;);
321 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
322
323 if (get)
324 param->pv.i = self->settings.flow_control;
325 else
326 self->settings.flow_control = (__u8) param->pv.i;
327
328 pr_debug("%s(), flow control = 0x%02x\n", __func__ , (__u8)param->pv.i);
329
330 return 0;
331 }
332
333 /*
334 * Function ircomm_param_xon_xoff (self, param)
335 *
336 * Exchange XON/XOFF characters
337 *
338 */
ircomm_param_xon_xoff(void * instance,irda_param_t * param,int get)339 static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get)
340 {
341 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
342
343 IRDA_ASSERT(self != NULL, return -1;);
344 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
345
346 if (get) {
347 param->pv.i = self->settings.xonxoff[0];
348 param->pv.i |= self->settings.xonxoff[1] << 8;
349 } else {
350 self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
351 self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
352 }
353
354 pr_debug("%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__ ,
355 param->pv.i & 0xff, param->pv.i >> 8);
356
357 return 0;
358 }
359
360 /*
361 * Function ircomm_param_enq_ack (self, param)
362 *
363 * Exchange ENQ/ACK characters
364 *
365 */
ircomm_param_enq_ack(void * instance,irda_param_t * param,int get)366 static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get)
367 {
368 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
369
370 IRDA_ASSERT(self != NULL, return -1;);
371 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
372
373 if (get) {
374 param->pv.i = self->settings.enqack[0];
375 param->pv.i |= self->settings.enqack[1] << 8;
376 } else {
377 self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
378 self->settings.enqack[1] = (__u16) param->pv.i >> 8;
379 }
380
381 pr_debug("%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__ ,
382 param->pv.i & 0xff, param->pv.i >> 8);
383
384 return 0;
385 }
386
387 /*
388 * Function ircomm_param_line_status (self, param)
389 *
390 *
391 *
392 */
ircomm_param_line_status(void * instance,irda_param_t * param,int get)393 static int ircomm_param_line_status(void *instance, irda_param_t *param,
394 int get)
395 {
396 pr_debug("%s(), not impl.\n", __func__);
397
398 return 0;
399 }
400
401 /*
402 * Function ircomm_param_dte (instance, param)
403 *
404 * If we get here, there must be some sort of null-modem connection, and
405 * we are probably working in server mode as well.
406 */
ircomm_param_dte(void * instance,irda_param_t * param,int get)407 static int ircomm_param_dte(void *instance, irda_param_t *param, int get)
408 {
409 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
410 __u8 dte;
411
412 IRDA_ASSERT(self != NULL, return -1;);
413 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
414
415 if (get)
416 param->pv.i = self->settings.dte;
417 else {
418 dte = (__u8) param->pv.i;
419
420 self->settings.dce = 0;
421
422 if (dte & IRCOMM_DELTA_DTR)
423 self->settings.dce |= (IRCOMM_DELTA_DSR|
424 IRCOMM_DELTA_RI |
425 IRCOMM_DELTA_CD);
426 if (dte & IRCOMM_DTR)
427 self->settings.dce |= (IRCOMM_DSR|
428 IRCOMM_RI |
429 IRCOMM_CD);
430
431 if (dte & IRCOMM_DELTA_RTS)
432 self->settings.dce |= IRCOMM_DELTA_CTS;
433 if (dte & IRCOMM_RTS)
434 self->settings.dce |= IRCOMM_CTS;
435
436 /* Take appropriate actions */
437 ircomm_tty_check_modem_status(self);
438
439 /* Null modem cable emulator */
440 self->settings.null_modem = TRUE;
441 }
442
443 return 0;
444 }
445
446 /*
447 * Function ircomm_param_dce (instance, param)
448 *
449 *
450 *
451 */
ircomm_param_dce(void * instance,irda_param_t * param,int get)452 static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
453 {
454 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
455 __u8 dce;
456
457 pr_debug("%s(), dce = 0x%02x\n", __func__ , (__u8)param->pv.i);
458
459 dce = (__u8) param->pv.i;
460
461 IRDA_ASSERT(self != NULL, return -1;);
462 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
463
464 self->settings.dce = dce;
465
466 /* Check if any of the settings have changed */
467 if (dce & 0x0f) {
468 if (dce & IRCOMM_DELTA_CTS) {
469 pr_debug("%s(), CTS\n", __func__);
470 }
471 }
472
473 ircomm_tty_check_modem_status(self);
474
475 return 0;
476 }
477
478 /*
479 * Function ircomm_param_poll (instance, param)
480 *
481 * Called when the peer device is polling for the line settings
482 *
483 */
ircomm_param_poll(void * instance,irda_param_t * param,int get)484 static int ircomm_param_poll(void *instance, irda_param_t *param, int get)
485 {
486 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
487
488 IRDA_ASSERT(self != NULL, return -1;);
489 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
490
491 /* Poll parameters are always of length 0 (just a signal) */
492 if (!get) {
493 /* Respond with DTE line settings */
494 ircomm_param_request(self, IRCOMM_DTE, TRUE);
495 }
496 return 0;
497 }
498
499
500
501
502
503