Loading...
Note: File does not exist in v5.9.
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
42static int ircomm_param_service_type(void *instance, irda_param_t *param,
43 int get);
44static int ircomm_param_port_type(void *instance, irda_param_t *param,
45 int get);
46static int ircomm_param_port_name(void *instance, irda_param_t *param,
47 int get);
48static int ircomm_param_service_type(void *instance, irda_param_t *param,
49 int get);
50static int ircomm_param_data_rate(void *instance, irda_param_t *param,
51 int get);
52static int ircomm_param_data_format(void *instance, irda_param_t *param,
53 int get);
54static int ircomm_param_flow_control(void *instance, irda_param_t *param,
55 int get);
56static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get);
57static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get);
58static int ircomm_param_line_status(void *instance, irda_param_t *param,
59 int get);
60static int ircomm_param_dte(void *instance, irda_param_t *param, int get);
61static int ircomm_param_dce(void *instance, irda_param_t *param, int get);
62static int ircomm_param_poll(void *instance, irda_param_t *param, int get);
63
64static 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};
69static 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};
77static 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
83static 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
90pi_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 */
98int 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 pr_debug("%s(), skb->len=%d\n", __func__, skb->len);
138
139 spin_unlock_irqrestore(&self->spinlock, flags);
140
141 if (flush) {
142 /* ircomm_tty_do_softint will take care of the rest */
143 schedule_work(&self->tqueue);
144 }
145
146 return count;
147}
148
149/*
150 * Function ircomm_param_service_type (self, buf, len)
151 *
152 * Handle service type, this function will both be called after the LM-IAS
153 * query and then the remote device sends its initial parameters
154 *
155 */
156static int ircomm_param_service_type(void *instance, irda_param_t *param,
157 int get)
158{
159 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
160 __u8 service_type = (__u8) param->pv.i;
161
162 IRDA_ASSERT(self != NULL, return -1;);
163 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
164
165 if (get) {
166 param->pv.i = self->settings.service_type;
167 return 0;
168 }
169
170 /* Find all common service types */
171 service_type &= self->service_type;
172 if (!service_type) {
173 pr_debug("%s(), No common service type to use!\n", __func__);
174 return -1;
175 }
176 pr_debug("%s(), services in common=%02x\n", __func__ ,
177 service_type);
178
179 /*
180 * Now choose a preferred service type of those available
181 */
182 if (service_type & IRCOMM_CENTRONICS)
183 self->settings.service_type = IRCOMM_CENTRONICS;
184 else if (service_type & IRCOMM_9_WIRE)
185 self->settings.service_type = IRCOMM_9_WIRE;
186 else if (service_type & IRCOMM_3_WIRE)
187 self->settings.service_type = IRCOMM_3_WIRE;
188 else if (service_type & IRCOMM_3_WIRE_RAW)
189 self->settings.service_type = IRCOMM_3_WIRE_RAW;
190
191 pr_debug("%s(), resulting service type=0x%02x\n", __func__ ,
192 self->settings.service_type);
193
194 /*
195 * Now the line is ready for some communication. Check if we are a
196 * server, and send over some initial parameters.
197 * Client do it in ircomm_tty_state_setup().
198 * Note : we may get called from ircomm_tty_getvalue_confirm(),
199 * therefore before we even have open any socket. And self->client
200 * is initialised to TRUE only later. So, we check if the link is
201 * really initialised. - Jean II
202 */
203 if ((self->max_header_size != IRCOMM_TTY_HDR_UNINITIALISED) &&
204 (!self->client) &&
205 (self->settings.service_type != IRCOMM_3_WIRE_RAW))
206 {
207 /* Init connection */
208 ircomm_tty_send_initial_parameters(self);
209 ircomm_tty_link_established(self);
210 }
211
212 return 0;
213}
214
215/*
216 * Function ircomm_param_port_type (self, param)
217 *
218 * The port type parameter tells if the devices are serial or parallel.
219 * Since we only advertise serial service, this parameter should only
220 * be equal to IRCOMM_SERIAL.
221 */
222static int ircomm_param_port_type(void *instance, irda_param_t *param, int get)
223{
224 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
225
226 IRDA_ASSERT(self != NULL, return -1;);
227 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
228
229 if (get)
230 param->pv.i = IRCOMM_SERIAL;
231 else {
232 self->settings.port_type = (__u8) param->pv.i;
233
234 pr_debug("%s(), port type=%d\n", __func__ ,
235 self->settings.port_type);
236 }
237 return 0;
238}
239
240/*
241 * Function ircomm_param_port_name (self, param)
242 *
243 * Exchange port name
244 *
245 */
246static int ircomm_param_port_name(void *instance, irda_param_t *param, int get)
247{
248 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
249
250 IRDA_ASSERT(self != NULL, return -1;);
251 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
252
253 if (get) {
254 pr_debug("%s(), not imp!\n", __func__);
255 } else {
256 pr_debug("%s(), port-name=%s\n", __func__ , param->pv.c);
257 strncpy(self->settings.port_name, param->pv.c, 32);
258 }
259
260 return 0;
261}
262
263/*
264 * Function ircomm_param_data_rate (self, param)
265 *
266 * Exchange data rate to be used in this settings
267 *
268 */
269static int ircomm_param_data_rate(void *instance, irda_param_t *param, int get)
270{
271 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
272
273 IRDA_ASSERT(self != NULL, return -1;);
274 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
275
276 if (get)
277 param->pv.i = self->settings.data_rate;
278 else
279 self->settings.data_rate = param->pv.i;
280
281 pr_debug("%s(), data rate = %d\n", __func__ , param->pv.i);
282
283 return 0;
284}
285
286/*
287 * Function ircomm_param_data_format (self, param)
288 *
289 * Exchange data format to be used in this settings
290 *
291 */
292static int ircomm_param_data_format(void *instance, irda_param_t *param,
293 int get)
294{
295 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
296
297 IRDA_ASSERT(self != NULL, return -1;);
298 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
299
300 if (get)
301 param->pv.i = self->settings.data_format;
302 else
303 self->settings.data_format = (__u8) param->pv.i;
304
305 return 0;
306}
307
308/*
309 * Function ircomm_param_flow_control (self, param)
310 *
311 * Exchange flow control settings to be used in this settings
312 *
313 */
314static int ircomm_param_flow_control(void *instance, irda_param_t *param,
315 int get)
316{
317 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
318
319 IRDA_ASSERT(self != NULL, return -1;);
320 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
321
322 if (get)
323 param->pv.i = self->settings.flow_control;
324 else
325 self->settings.flow_control = (__u8) param->pv.i;
326
327 pr_debug("%s(), flow control = 0x%02x\n", __func__ , (__u8)param->pv.i);
328
329 return 0;
330}
331
332/*
333 * Function ircomm_param_xon_xoff (self, param)
334 *
335 * Exchange XON/XOFF characters
336 *
337 */
338static int ircomm_param_xon_xoff(void *instance, irda_param_t *param, int get)
339{
340 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
341
342 IRDA_ASSERT(self != NULL, return -1;);
343 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
344
345 if (get) {
346 param->pv.i = self->settings.xonxoff[0];
347 param->pv.i |= self->settings.xonxoff[1] << 8;
348 } else {
349 self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
350 self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
351 }
352
353 pr_debug("%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__ ,
354 param->pv.i & 0xff, param->pv.i >> 8);
355
356 return 0;
357}
358
359/*
360 * Function ircomm_param_enq_ack (self, param)
361 *
362 * Exchange ENQ/ACK characters
363 *
364 */
365static int ircomm_param_enq_ack(void *instance, irda_param_t *param, int get)
366{
367 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
368
369 IRDA_ASSERT(self != NULL, return -1;);
370 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
371
372 if (get) {
373 param->pv.i = self->settings.enqack[0];
374 param->pv.i |= self->settings.enqack[1] << 8;
375 } else {
376 self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
377 self->settings.enqack[1] = (__u16) param->pv.i >> 8;
378 }
379
380 pr_debug("%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__ ,
381 param->pv.i & 0xff, param->pv.i >> 8);
382
383 return 0;
384}
385
386/*
387 * Function ircomm_param_line_status (self, param)
388 *
389 *
390 *
391 */
392static int ircomm_param_line_status(void *instance, irda_param_t *param,
393 int get)
394{
395 pr_debug("%s(), not impl.\n", __func__);
396
397 return 0;
398}
399
400/*
401 * Function ircomm_param_dte (instance, param)
402 *
403 * If we get here, there must be some sort of null-modem connection, and
404 * we are probably working in server mode as well.
405 */
406static int ircomm_param_dte(void *instance, irda_param_t *param, int get)
407{
408 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
409 __u8 dte;
410
411 IRDA_ASSERT(self != NULL, return -1;);
412 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
413
414 if (get)
415 param->pv.i = self->settings.dte;
416 else {
417 dte = (__u8) param->pv.i;
418
419 self->settings.dce = 0;
420
421 if (dte & IRCOMM_DELTA_DTR)
422 self->settings.dce |= (IRCOMM_DELTA_DSR|
423 IRCOMM_DELTA_RI |
424 IRCOMM_DELTA_CD);
425 if (dte & IRCOMM_DTR)
426 self->settings.dce |= (IRCOMM_DSR|
427 IRCOMM_RI |
428 IRCOMM_CD);
429
430 if (dte & IRCOMM_DELTA_RTS)
431 self->settings.dce |= IRCOMM_DELTA_CTS;
432 if (dte & IRCOMM_RTS)
433 self->settings.dce |= IRCOMM_CTS;
434
435 /* Take appropriate actions */
436 ircomm_tty_check_modem_status(self);
437
438 /* Null modem cable emulator */
439 self->settings.null_modem = TRUE;
440 }
441
442 return 0;
443}
444
445/*
446 * Function ircomm_param_dce (instance, param)
447 *
448 *
449 *
450 */
451static int ircomm_param_dce(void *instance, irda_param_t *param, int get)
452{
453 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
454 __u8 dce;
455
456 pr_debug("%s(), dce = 0x%02x\n", __func__ , (__u8)param->pv.i);
457
458 dce = (__u8) param->pv.i;
459
460 IRDA_ASSERT(self != NULL, return -1;);
461 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
462
463 self->settings.dce = dce;
464
465 /* Check if any of the settings have changed */
466 if (dce & 0x0f) {
467 if (dce & IRCOMM_DELTA_CTS) {
468 pr_debug("%s(), CTS\n", __func__);
469 }
470 }
471
472 ircomm_tty_check_modem_status(self);
473
474 return 0;
475}
476
477/*
478 * Function ircomm_param_poll (instance, param)
479 *
480 * Called when the peer device is polling for the line settings
481 *
482 */
483static int ircomm_param_poll(void *instance, irda_param_t *param, int get)
484{
485 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
486
487 IRDA_ASSERT(self != NULL, return -1;);
488 IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
489
490 /* Poll parameters are always of length 0 (just a signal) */
491 if (!get) {
492 /* Respond with DTE line settings */
493 ircomm_param_request(self, IRCOMM_DTE, TRUE);
494 }
495 return 0;
496}
497
498
499
500
501