1 /*********************************************************************
3 * Filename: ircomm_param.c
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>
12 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
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.
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.
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/>.
27 ********************************************************************/
29 #include <linux/gfp.h>
30 #include <linux/workqueue.h>
31 #include <linux/interrupt.h>
33 #include <net/irda/irda.h>
34 #include <net/irda/parameters.h>
36 #include <net/irda/ircomm_core.h>
37 #include <net/irda/ircomm_tty_attach.h>
38 #include <net/irda/ircomm_tty.h>
40 #include <net/irda/ircomm_param.h>
42 static int ircomm_param_service_type(void *instance
, irda_param_t
*param
,
44 static int ircomm_param_port_type(void *instance
, irda_param_t
*param
,
46 static int ircomm_param_port_name(void *instance
, irda_param_t
*param
,
48 static int ircomm_param_service_type(void *instance
, irda_param_t
*param
,
50 static int ircomm_param_data_rate(void *instance
, irda_param_t
*param
,
52 static int ircomm_param_data_format(void *instance
, irda_param_t
*param
,
54 static int ircomm_param_flow_control(void *instance
, irda_param_t
*param
,
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
,
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
);
64 static 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
}
69 static 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
}
77 static 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
},
83 static 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 } */
90 pi_param_info_t ircomm_param_info
= { pi_major_call_table
, 3, 0x0f, 4 };
93 * Function ircomm_param_request (self, pi, flush)
95 * Queue a parameter for the control channel
98 int ircomm_param_request(struct ircomm_tty_cb
*self
, __u8 pi
, int flush
)
104 IRDA_DEBUG(2, "%s()\n", __func__
);
106 IRDA_ASSERT(self
!= NULL
, return -1;);
107 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
109 /* Make sure we don't send parameters for raw mode */
110 if (self
->service_type
== IRCOMM_3_WIRE_RAW
)
113 spin_lock_irqsave(&self
->spinlock
, flags
);
115 skb
= self
->ctrl_skb
;
117 skb
= alloc_skb(256, GFP_ATOMIC
);
119 spin_unlock_irqrestore(&self
->spinlock
, flags
);
123 skb_reserve(skb
, self
->max_header_size
);
124 self
->ctrl_skb
= skb
;
127 * Inserting is a little bit tricky since we don't know how much
128 * room we will need. But this should hopefully work OK
130 count
= irda_param_insert(self
, pi
, skb_tail_pointer(skb
),
131 skb_tailroom(skb
), &ircomm_param_info
);
133 net_warn_ratelimited("%s(), no room for parameter!\n",
135 spin_unlock_irqrestore(&self
->spinlock
, flags
);
140 spin_unlock_irqrestore(&self
->spinlock
, flags
);
142 IRDA_DEBUG(2, "%s(), skb->len=%d\n", __func__
, skb
->len
);
145 /* ircomm_tty_do_softint will take care of the rest */
146 schedule_work(&self
->tqueue
);
153 * Function ircomm_param_service_type (self, buf, len)
155 * Handle service type, this function will both be called after the LM-IAS
156 * query and then the remote device sends its initial parameters
159 static int ircomm_param_service_type(void *instance
, irda_param_t
*param
,
162 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
163 __u8 service_type
= (__u8
) param
->pv
.i
;
165 IRDA_ASSERT(self
!= NULL
, return -1;);
166 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
169 param
->pv
.i
= self
->settings
.service_type
;
173 /* Find all common service types */
174 service_type
&= self
->service_type
;
177 "%s(), No common service type to use!\n", __func__
);
180 IRDA_DEBUG(0, "%s(), services in common=%02x\n", __func__
,
184 * Now choose a preferred service type of those available
186 if (service_type
& IRCOMM_CENTRONICS
)
187 self
->settings
.service_type
= IRCOMM_CENTRONICS
;
188 else if (service_type
& IRCOMM_9_WIRE
)
189 self
->settings
.service_type
= IRCOMM_9_WIRE
;
190 else if (service_type
& IRCOMM_3_WIRE
)
191 self
->settings
.service_type
= IRCOMM_3_WIRE
;
192 else if (service_type
& IRCOMM_3_WIRE_RAW
)
193 self
->settings
.service_type
= IRCOMM_3_WIRE_RAW
;
195 IRDA_DEBUG(0, "%s(), resulting service type=0x%02x\n", __func__
,
196 self
->settings
.service_type
);
199 * Now the line is ready for some communication. Check if we are a
200 * server, and send over some initial parameters.
201 * Client do it in ircomm_tty_state_setup().
202 * Note : we may get called from ircomm_tty_getvalue_confirm(),
203 * therefore before we even have open any socket. And self->client
204 * is initialised to TRUE only later. So, we check if the link is
205 * really initialised. - Jean II
207 if ((self
->max_header_size
!= IRCOMM_TTY_HDR_UNINITIALISED
) &&
209 (self
->settings
.service_type
!= IRCOMM_3_WIRE_RAW
))
211 /* Init connection */
212 ircomm_tty_send_initial_parameters(self
);
213 ircomm_tty_link_established(self
);
220 * Function ircomm_param_port_type (self, param)
222 * The port type parameter tells if the devices are serial or parallel.
223 * Since we only advertise serial service, this parameter should only
224 * be equal to IRCOMM_SERIAL.
226 static int ircomm_param_port_type(void *instance
, irda_param_t
*param
, int get
)
228 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
230 IRDA_ASSERT(self
!= NULL
, return -1;);
231 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
234 param
->pv
.i
= IRCOMM_SERIAL
;
236 self
->settings
.port_type
= (__u8
) param
->pv
.i
;
238 IRDA_DEBUG(0, "%s(), port type=%d\n", __func__
,
239 self
->settings
.port_type
);
245 * Function ircomm_param_port_name (self, param)
250 static int ircomm_param_port_name(void *instance
, irda_param_t
*param
, int get
)
252 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
254 IRDA_ASSERT(self
!= NULL
, return -1;);
255 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
258 IRDA_DEBUG(0, "%s(), not imp!\n", __func__
);
260 IRDA_DEBUG(0, "%s(), port-name=%s\n", __func__
, param
->pv
.c
);
261 strncpy(self
->settings
.port_name
, param
->pv
.c
, 32);
268 * Function ircomm_param_data_rate (self, param)
270 * Exchange data rate to be used in this settings
273 static int ircomm_param_data_rate(void *instance
, irda_param_t
*param
, int get
)
275 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
277 IRDA_ASSERT(self
!= NULL
, return -1;);
278 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
281 param
->pv
.i
= self
->settings
.data_rate
;
283 self
->settings
.data_rate
= param
->pv
.i
;
285 IRDA_DEBUG(2, "%s(), data rate = %d\n", __func__
, param
->pv
.i
);
291 * Function ircomm_param_data_format (self, param)
293 * Exchange data format to be used in this settings
296 static int ircomm_param_data_format(void *instance
, irda_param_t
*param
,
299 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
301 IRDA_ASSERT(self
!= NULL
, return -1;);
302 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
305 param
->pv
.i
= self
->settings
.data_format
;
307 self
->settings
.data_format
= (__u8
) param
->pv
.i
;
313 * Function ircomm_param_flow_control (self, param)
315 * Exchange flow control settings to be used in this settings
318 static int ircomm_param_flow_control(void *instance
, irda_param_t
*param
,
321 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
323 IRDA_ASSERT(self
!= NULL
, return -1;);
324 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
327 param
->pv
.i
= self
->settings
.flow_control
;
329 self
->settings
.flow_control
= (__u8
) param
->pv
.i
;
331 IRDA_DEBUG(1, "%s(), flow control = 0x%02x\n", __func__
, (__u8
) param
->pv
.i
);
337 * Function ircomm_param_xon_xoff (self, param)
339 * Exchange XON/XOFF characters
342 static int ircomm_param_xon_xoff(void *instance
, irda_param_t
*param
, int get
)
344 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
346 IRDA_ASSERT(self
!= NULL
, return -1;);
347 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
350 param
->pv
.i
= self
->settings
.xonxoff
[0];
351 param
->pv
.i
|= self
->settings
.xonxoff
[1] << 8;
353 self
->settings
.xonxoff
[0] = (__u16
) param
->pv
.i
& 0xff;
354 self
->settings
.xonxoff
[1] = (__u16
) param
->pv
.i
>> 8;
357 IRDA_DEBUG(0, "%s(), XON/XOFF = 0x%02x,0x%02x\n", __func__
,
358 param
->pv
.i
& 0xff, param
->pv
.i
>> 8);
364 * Function ircomm_param_enq_ack (self, param)
366 * Exchange ENQ/ACK characters
369 static int ircomm_param_enq_ack(void *instance
, irda_param_t
*param
, int get
)
371 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
373 IRDA_ASSERT(self
!= NULL
, return -1;);
374 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
377 param
->pv
.i
= self
->settings
.enqack
[0];
378 param
->pv
.i
|= self
->settings
.enqack
[1] << 8;
380 self
->settings
.enqack
[0] = (__u16
) param
->pv
.i
& 0xff;
381 self
->settings
.enqack
[1] = (__u16
) param
->pv
.i
>> 8;
384 IRDA_DEBUG(0, "%s(), ENQ/ACK = 0x%02x,0x%02x\n", __func__
,
385 param
->pv
.i
& 0xff, param
->pv
.i
>> 8);
391 * Function ircomm_param_line_status (self, param)
396 static int ircomm_param_line_status(void *instance
, irda_param_t
*param
,
399 IRDA_DEBUG(2, "%s(), not impl.\n", __func__
);
405 * Function ircomm_param_dte (instance, param)
407 * If we get here, there must be some sort of null-modem connection, and
408 * we are probably working in server mode as well.
410 static int ircomm_param_dte(void *instance
, irda_param_t
*param
, int get
)
412 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
415 IRDA_ASSERT(self
!= NULL
, return -1;);
416 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
419 param
->pv
.i
= self
->settings
.dte
;
421 dte
= (__u8
) param
->pv
.i
;
423 self
->settings
.dce
= 0;
425 if (dte
& IRCOMM_DELTA_DTR
)
426 self
->settings
.dce
|= (IRCOMM_DELTA_DSR
|
429 if (dte
& IRCOMM_DTR
)
430 self
->settings
.dce
|= (IRCOMM_DSR
|
434 if (dte
& IRCOMM_DELTA_RTS
)
435 self
->settings
.dce
|= IRCOMM_DELTA_CTS
;
436 if (dte
& IRCOMM_RTS
)
437 self
->settings
.dce
|= IRCOMM_CTS
;
439 /* Take appropriate actions */
440 ircomm_tty_check_modem_status(self
);
442 /* Null modem cable emulator */
443 self
->settings
.null_modem
= TRUE
;
450 * Function ircomm_param_dce (instance, param)
455 static int ircomm_param_dce(void *instance
, irda_param_t
*param
, int get
)
457 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
460 IRDA_DEBUG(1, "%s(), dce = 0x%02x\n", __func__
, (__u8
) param
->pv
.i
);
462 dce
= (__u8
) param
->pv
.i
;
464 IRDA_ASSERT(self
!= NULL
, return -1;);
465 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
467 self
->settings
.dce
= dce
;
469 /* Check if any of the settings have changed */
471 if (dce
& IRCOMM_DELTA_CTS
) {
472 IRDA_DEBUG(2, "%s(), CTS\n", __func__
);
476 ircomm_tty_check_modem_status(self
);
482 * Function ircomm_param_poll (instance, param)
484 * Called when the peer device is polling for the line settings
487 static int ircomm_param_poll(void *instance
, irda_param_t
*param
, int get
)
489 struct ircomm_tty_cb
*self
= (struct ircomm_tty_cb
*) instance
;
491 IRDA_ASSERT(self
!= NULL
, return -1;);
492 IRDA_ASSERT(self
->magic
== IRCOMM_TTY_MAGIC
, return -1;);
494 /* Poll parameters are always of length 0 (just a signal) */
496 /* Respond with DTE line settings */
497 ircomm_param_request(self
, IRCOMM_DTE
, TRUE
);