]>
Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /********************************************************************* |
6819bc2e | 2 | * |
1da177e4 LT |
3 | * Filename: ircomm_lmp.c |
4 | * Version: 1.0 | |
5 | * Description: Interface between IrCOMM and IrLMP | |
6 | * Status: Stable | |
7 | * Author: Dag Brattli <dagb@cs.uit.no> | |
8 | * Created at: Sun Jun 6 20:48:27 1999 | |
9 | * Modified at: Sun Dec 12 13:44:17 1999 | |
10 | * Modified by: Dag Brattli <dagb@cs.uit.no> | |
11 | * Sources: Previous IrLPT work by Thomas Davis | |
6819bc2e | 12 | * |
1da177e4 LT |
13 | * Copyright (c) 1999 Dag Brattli, All Rights Reserved. |
14 | * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> | |
6819bc2e YH |
15 | * |
16 | * This program is free software; you can redistribute it and/or | |
17 | * modify it under the terms of the GNU General Public License as | |
18 | * published by the Free Software Foundation; either version 2 of | |
1da177e4 | 19 | * the License, or (at your option) any later version. |
6819bc2e | 20 | * |
1da177e4 LT |
21 | * This program is distributed in the hope that it will be useful, |
22 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
23 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
24 | * GNU General Public License for more details. | |
6819bc2e YH |
25 | * |
26 | * You should have received a copy of the GNU General Public License | |
27 | * along with this program; if not, write to the Free Software | |
28 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
1da177e4 | 29 | * MA 02111-1307 USA |
6819bc2e | 30 | * |
1da177e4 LT |
31 | ********************************************************************/ |
32 | ||
1da177e4 | 33 | #include <linux/init.h> |
5a0e3ad6 | 34 | #include <linux/gfp.h> |
1da177e4 LT |
35 | |
36 | #include <net/irda/irda.h> | |
37 | #include <net/irda/irlmp.h> | |
38 | #include <net/irda/iriap.h> | |
39 | #include <net/irda/irda_device.h> /* struct irda_skb_cb */ | |
40 | ||
41 | #include <net/irda/ircomm_event.h> | |
42 | #include <net/irda/ircomm_lmp.h> | |
43 | ||
44 | ||
45 | /* | |
46 | * Function ircomm_lmp_connect_request (self, userdata) | |
47 | * | |
6819bc2e | 48 | * |
1da177e4 LT |
49 | * |
50 | */ | |
6819bc2e YH |
51 | static int ircomm_lmp_connect_request(struct ircomm_cb *self, |
52 | struct sk_buff *userdata, | |
1da177e4 LT |
53 | struct ircomm_info *info) |
54 | { | |
55 | int ret = 0; | |
56 | ||
0dc47877 | 57 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 LT |
58 | |
59 | /* Don't forget to refcount it - should be NULL anyway */ | |
60 | if(userdata) | |
61 | skb_get(userdata); | |
62 | ||
63 | ret = irlmp_connect_request(self->lsap, info->dlsap_sel, | |
6819bc2e | 64 | info->saddr, info->daddr, NULL, userdata); |
1da177e4 | 65 | return ret; |
6819bc2e | 66 | } |
1da177e4 LT |
67 | |
68 | /* | |
69 | * Function ircomm_lmp_connect_response (self, skb) | |
70 | * | |
6819bc2e | 71 | * |
1da177e4 LT |
72 | * |
73 | */ | |
74 | static int ircomm_lmp_connect_response(struct ircomm_cb *self, | |
75 | struct sk_buff *userdata) | |
76 | { | |
77 | struct sk_buff *tx_skb; | |
78 | int ret; | |
79 | ||
0dc47877 | 80 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
6819bc2e | 81 | |
1da177e4 LT |
82 | /* Any userdata supplied? */ |
83 | if (userdata == NULL) { | |
1b0fee7d | 84 | tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC); |
1da177e4 LT |
85 | if (!tx_skb) |
86 | return -ENOMEM; | |
87 | ||
88 | /* Reserve space for MUX and LAP header */ | |
89 | skb_reserve(tx_skb, LMP_MAX_HEADER); | |
90 | } else { | |
6819bc2e YH |
91 | /* |
92 | * Check that the client has reserved enough space for | |
1da177e4 LT |
93 | * headers |
94 | */ | |
95 | IRDA_ASSERT(skb_headroom(userdata) >= LMP_MAX_HEADER, | |
96 | return -1;); | |
97 | ||
98 | /* Don't forget to refcount it - should be NULL anyway */ | |
99 | skb_get(userdata); | |
100 | tx_skb = userdata; | |
101 | } | |
102 | ||
103 | ret = irlmp_connect_response(self->lsap, tx_skb); | |
104 | ||
105 | return 0; | |
106 | } | |
107 | ||
6819bc2e YH |
108 | static int ircomm_lmp_disconnect_request(struct ircomm_cb *self, |
109 | struct sk_buff *userdata, | |
1da177e4 LT |
110 | struct ircomm_info *info) |
111 | { | |
6819bc2e | 112 | struct sk_buff *tx_skb; |
1da177e4 LT |
113 | int ret; |
114 | ||
0dc47877 | 115 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 | 116 | |
6819bc2e | 117 | if (!userdata) { |
1b0fee7d | 118 | tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC); |
1da177e4 LT |
119 | if (!tx_skb) |
120 | return -ENOMEM; | |
6819bc2e | 121 | |
1da177e4 | 122 | /* Reserve space for MUX and LAP header */ |
6819bc2e | 123 | skb_reserve(tx_skb, LMP_MAX_HEADER); |
1da177e4 LT |
124 | userdata = tx_skb; |
125 | } else { | |
126 | /* Don't forget to refcount it - should be NULL anyway */ | |
127 | skb_get(userdata); | |
128 | } | |
129 | ||
130 | ret = irlmp_disconnect_request(self->lsap, userdata); | |
131 | ||
132 | return ret; | |
133 | } | |
134 | ||
135 | /* | |
136 | * Function ircomm_lmp_flow_control (skb) | |
137 | * | |
138 | * This function is called when a data frame we have sent to IrLAP has | |
6819bc2e | 139 | * been deallocated. We do this to make sure we don't flood IrLAP with |
1da177e4 LT |
140 | * frames, since we are not using the IrTTP flow control mechanism |
141 | */ | |
142 | static void ircomm_lmp_flow_control(struct sk_buff *skb) | |
143 | { | |
144 | struct irda_skb_cb *cb; | |
145 | struct ircomm_cb *self; | |
146 | int line; | |
147 | ||
148 | IRDA_ASSERT(skb != NULL, return;); | |
149 | ||
150 | cb = (struct irda_skb_cb *) skb->cb; | |
151 | ||
0dc47877 | 152 | IRDA_DEBUG(2, "%s()\n", __func__ ); |
6819bc2e YH |
153 | |
154 | line = cb->line; | |
1da177e4 LT |
155 | |
156 | self = (struct ircomm_cb *) hashbin_lock_find(ircomm, line, NULL); | |
6819bc2e | 157 | if (!self) { |
0dc47877 | 158 | IRDA_DEBUG(2, "%s(), didn't find myself\n", __func__ ); |
6819bc2e | 159 | return; |
1da177e4 LT |
160 | } |
161 | ||
6819bc2e | 162 | IRDA_ASSERT(self != NULL, return;); |
1da177e4 LT |
163 | IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); |
164 | ||
165 | self->pkt_count--; | |
166 | ||
6819bc2e | 167 | if ((self->pkt_count < 2) && (self->flow_status == FLOW_STOP)) { |
0dc47877 | 168 | IRDA_DEBUG(2, "%s(), asking TTY to start again!\n", __func__ ); |
6819bc2e YH |
169 | self->flow_status = FLOW_START; |
170 | if (self->notify.flow_indication) | |
171 | self->notify.flow_indication(self->notify.instance, | |
1da177e4 | 172 | self, FLOW_START); |
6819bc2e | 173 | } |
1da177e4 | 174 | } |
6819bc2e | 175 | |
1da177e4 LT |
176 | /* |
177 | * Function ircomm_lmp_data_request (self, userdata) | |
178 | * | |
179 | * Send data frame to peer device | |
180 | * | |
181 | */ | |
182 | static int ircomm_lmp_data_request(struct ircomm_cb *self, | |
6819bc2e | 183 | struct sk_buff *skb, |
1da177e4 LT |
184 | int not_used) |
185 | { | |
186 | struct irda_skb_cb *cb; | |
187 | int ret; | |
188 | ||
189 | IRDA_ASSERT(skb != NULL, return -1;); | |
190 | ||
191 | cb = (struct irda_skb_cb *) skb->cb; | |
6819bc2e YH |
192 | |
193 | cb->line = self->line; | |
1da177e4 | 194 | |
0dc47877 | 195 | IRDA_DEBUG(4, "%s(), sending frame\n", __func__ ); |
1da177e4 LT |
196 | |
197 | /* Don't forget to refcount it - see ircomm_tty_do_softint() */ | |
198 | skb_get(skb); | |
199 | ||
d55d87fd | 200 | skb_orphan(skb); |
1da177e4 LT |
201 | skb->destructor = ircomm_lmp_flow_control; |
202 | ||
6819bc2e | 203 | if ((self->pkt_count++ > 7) && (self->flow_status == FLOW_START)) { |
0dc47877 | 204 | IRDA_DEBUG(2, "%s(), asking TTY to slow down!\n", __func__ ); |
6819bc2e YH |
205 | self->flow_status = FLOW_STOP; |
206 | if (self->notify.flow_indication) | |
207 | self->notify.flow_indication(self->notify.instance, | |
208 | self, FLOW_STOP); | |
209 | } | |
1da177e4 LT |
210 | ret = irlmp_data_request(self->lsap, skb); |
211 | if (ret) { | |
0dc47877 | 212 | IRDA_ERROR("%s(), failed\n", __func__); |
1da177e4 LT |
213 | /* irlmp_data_request already free the packet */ |
214 | } | |
215 | ||
216 | return ret; | |
217 | } | |
218 | ||
219 | /* | |
220 | * Function ircomm_lmp_data_indication (instance, sap, skb) | |
221 | * | |
222 | * Incoming data which we must deliver to the state machine, to check | |
223 | * we are still connected. | |
224 | */ | |
225 | static int ircomm_lmp_data_indication(void *instance, void *sap, | |
226 | struct sk_buff *skb) | |
227 | { | |
228 | struct ircomm_cb *self = (struct ircomm_cb *) instance; | |
229 | ||
0dc47877 | 230 | IRDA_DEBUG(4, "%s()\n", __func__ ); |
6819bc2e | 231 | |
1da177e4 LT |
232 | IRDA_ASSERT(self != NULL, return -1;); |
233 | IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return -1;); | |
234 | IRDA_ASSERT(skb != NULL, return -1;); | |
6819bc2e | 235 | |
1da177e4 LT |
236 | ircomm_do_event(self, IRCOMM_LMP_DATA_INDICATION, skb, NULL); |
237 | ||
238 | /* Drop reference count - see ircomm_tty_data_indication(). */ | |
239 | dev_kfree_skb(skb); | |
240 | ||
241 | return 0; | |
242 | } | |
243 | ||
244 | /* | |
6819bc2e | 245 | * Function ircomm_lmp_connect_confirm (instance, sap, qos, max_sdu_size, |
1da177e4 LT |
246 | * max_header_size, skb) |
247 | * | |
248 | * Connection has been confirmed by peer device | |
249 | * | |
250 | */ | |
251 | static void ircomm_lmp_connect_confirm(void *instance, void *sap, | |
6819bc2e YH |
252 | struct qos_info *qos, |
253 | __u32 max_seg_size, | |
1da177e4 LT |
254 | __u8 max_header_size, |
255 | struct sk_buff *skb) | |
256 | { | |
257 | struct ircomm_cb *self = (struct ircomm_cb *) instance; | |
258 | struct ircomm_info info; | |
259 | ||
0dc47877 | 260 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 LT |
261 | |
262 | IRDA_ASSERT(self != NULL, return;); | |
263 | IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); | |
264 | IRDA_ASSERT(skb != NULL, return;); | |
265 | IRDA_ASSERT(qos != NULL, return;); | |
266 | ||
267 | info.max_data_size = max_seg_size; | |
268 | info.max_header_size = max_header_size; | |
269 | info.qos = qos; | |
270 | ||
271 | ircomm_do_event(self, IRCOMM_LMP_CONNECT_CONFIRM, skb, &info); | |
272 | ||
273 | /* Drop reference count - see ircomm_tty_connect_confirm(). */ | |
274 | dev_kfree_skb(skb); | |
275 | } | |
276 | ||
277 | /* | |
278 | * Function ircomm_lmp_connect_indication (instance, sap, qos, max_sdu_size, | |
279 | * max_header_size, skb) | |
280 | * | |
281 | * Peer device wants to make a connection with us | |
282 | * | |
283 | */ | |
284 | static void ircomm_lmp_connect_indication(void *instance, void *sap, | |
285 | struct qos_info *qos, | |
286 | __u32 max_seg_size, | |
287 | __u8 max_header_size, | |
288 | struct sk_buff *skb) | |
289 | { | |
290 | struct ircomm_cb *self = (struct ircomm_cb *)instance; | |
291 | struct ircomm_info info; | |
292 | ||
0dc47877 | 293 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 LT |
294 | |
295 | IRDA_ASSERT(self != NULL, return;); | |
296 | IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); | |
297 | IRDA_ASSERT(skb != NULL, return;); | |
298 | IRDA_ASSERT(qos != NULL, return;); | |
299 | ||
300 | info.max_data_size = max_seg_size; | |
301 | info.max_header_size = max_header_size; | |
302 | info.qos = qos; | |
303 | ||
304 | ircomm_do_event(self, IRCOMM_LMP_CONNECT_INDICATION, skb, &info); | |
305 | ||
306 | /* Drop reference count - see ircomm_tty_connect_indication(). */ | |
307 | dev_kfree_skb(skb); | |
308 | } | |
309 | ||
310 | /* | |
311 | * Function ircomm_lmp_disconnect_indication (instance, sap, reason, skb) | |
312 | * | |
313 | * Peer device has closed the connection, or the link went down for some | |
314 | * other reason | |
315 | */ | |
6819bc2e | 316 | static void ircomm_lmp_disconnect_indication(void *instance, void *sap, |
1da177e4 LT |
317 | LM_REASON reason, |
318 | struct sk_buff *skb) | |
319 | { | |
320 | struct ircomm_cb *self = (struct ircomm_cb *) instance; | |
321 | struct ircomm_info info; | |
322 | ||
0dc47877 | 323 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 LT |
324 | |
325 | IRDA_ASSERT(self != NULL, return;); | |
326 | IRDA_ASSERT(self->magic == IRCOMM_MAGIC, return;); | |
327 | ||
328 | info.reason = reason; | |
329 | ||
330 | ircomm_do_event(self, IRCOMM_LMP_DISCONNECT_INDICATION, skb, &info); | |
331 | ||
332 | /* Drop reference count - see ircomm_tty_disconnect_indication(). */ | |
333 | if(skb) | |
334 | dev_kfree_skb(skb); | |
335 | } | |
336 | /* | |
337 | * Function ircomm_open_lsap (self) | |
338 | * | |
339 | * Open LSAP. This function will only be used when using "raw" services | |
340 | * | |
341 | */ | |
342 | int ircomm_open_lsap(struct ircomm_cb *self) | |
343 | { | |
344 | notify_t notify; | |
345 | ||
0dc47877 | 346 | IRDA_DEBUG(0, "%s()\n", __func__ ); |
1da177e4 LT |
347 | |
348 | /* Register callbacks */ | |
349 | irda_notify_init(¬ify); | |
350 | notify.data_indication = ircomm_lmp_data_indication; | |
351 | notify.connect_confirm = ircomm_lmp_connect_confirm; | |
352 | notify.connect_indication = ircomm_lmp_connect_indication; | |
353 | notify.disconnect_indication = ircomm_lmp_disconnect_indication; | |
354 | notify.instance = self; | |
355 | strlcpy(notify.name, "IrCOMM", sizeof(notify.name)); | |
356 | ||
357 | self->lsap = irlmp_open_lsap(LSAP_ANY, ¬ify, 0); | |
358 | if (!self->lsap) { | |
0dc47877 | 359 | IRDA_DEBUG(0,"%sfailed to allocate tsap\n", __func__ ); |
1da177e4 LT |
360 | return -1; |
361 | } | |
362 | self->slsap_sel = self->lsap->slsap_sel; | |
363 | ||
364 | /* | |
365 | * Initialize the call-table for issuing commands | |
366 | */ | |
367 | self->issue.data_request = ircomm_lmp_data_request; | |
368 | self->issue.connect_request = ircomm_lmp_connect_request; | |
369 | self->issue.connect_response = ircomm_lmp_connect_response; | |
370 | self->issue.disconnect_request = ircomm_lmp_disconnect_request; | |
371 | ||
372 | return 0; | |
373 | } |