1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18#include <linux/interrupt.h>
19#include <linux/kernel.h>
20#include <linux/mutex.h>
21#include <linux/netdevice.h>
22#include <linux/ppp_channel.h>
23#include <linux/ppp_defs.h>
24#include <linux/if_ppp.h>
25#include <linux/skbuff.h>
26
27#include "network.h"
28#include "hardware.h"
29#include "main.h"
30#include "tty.h"
31
32#define MAX_ASSOCIATED_TTYS 2
33
34#define SC_RCV_BITS (SC_RCV_B7_1|SC_RCV_B7_0|SC_RCV_ODDP|SC_RCV_EVNP)
35
36struct ipw_network {
37
38 struct ipw_hardware *hardware;
39
40 struct ppp_channel *ppp_channel;
41
42 struct ipw_tty *associated_ttys[NO_OF_IPW_CHANNELS][MAX_ASSOCIATED_TTYS];
43
44 int ppp_blocked;
45
46 int outgoing_packets_queued;
47
48 spinlock_t lock;
49 struct mutex close_lock;
50
51
52 unsigned int flags;
53 unsigned int rbits;
54 u32 xaccm[8];
55 u32 raccm;
56 int mru;
57
58 int shutting_down;
59 unsigned int ras_control_lines;
60
61 struct work_struct work_go_online;
62 struct work_struct work_go_offline;
63};
64
65static void notify_packet_sent(void *callback_data, unsigned int packet_length)
66{
67 struct ipw_network *network = callback_data;
68 unsigned long flags;
69
70 spin_lock_irqsave(&network->lock, flags);
71 network->outgoing_packets_queued--;
72 if (network->ppp_channel != NULL) {
73 if (network->ppp_blocked) {
74 network->ppp_blocked = 0;
75 spin_unlock_irqrestore(&network->lock, flags);
76 ppp_output_wakeup(network->ppp_channel);
77 if (ipwireless_debug)
78 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
79 ": ppp unblocked\n");
80 } else
81 spin_unlock_irqrestore(&network->lock, flags);
82 } else
83 spin_unlock_irqrestore(&network->lock, flags);
84}
85
86
87
88
89static int ipwireless_ppp_start_xmit(struct ppp_channel *ppp_channel,
90 struct sk_buff *skb)
91{
92 struct ipw_network *network = ppp_channel->private;
93 unsigned long flags;
94
95 spin_lock_irqsave(&network->lock, flags);
96 if (network->outgoing_packets_queued < ipwireless_out_queue) {
97 unsigned char *buf;
98 static unsigned char header[] = {
99 PPP_ALLSTATIONS,
100 PPP_UI,
101 };
102 int ret;
103
104 network->outgoing_packets_queued++;
105 spin_unlock_irqrestore(&network->lock, flags);
106
107
108
109
110
111 if (skb_headroom(skb) >= 2) {
112 memcpy(skb_push(skb, 2), header, 2);
113 ret = ipwireless_send_packet(network->hardware,
114 IPW_CHANNEL_RAS, skb->data,
115 skb->len,
116 notify_packet_sent,
117 network);
118 if (ret == -1) {
119 skb_pull(skb, 2);
120 return 0;
121 }
122 } else {
123
124 buf = kmalloc(skb->len + 2, GFP_ATOMIC);
125 if (!buf)
126 return 0;
127 memcpy(buf + 2, skb->data, skb->len);
128 memcpy(buf, header, 2);
129 ret = ipwireless_send_packet(network->hardware,
130 IPW_CHANNEL_RAS, buf,
131 skb->len + 2,
132 notify_packet_sent,
133 network);
134 kfree(buf);
135 if (ret == -1)
136 return 0;
137 }
138 kfree_skb(skb);
139 return 1;
140 } else {
141
142
143
144
145 network->ppp_blocked = 1;
146 spin_unlock_irqrestore(&network->lock, flags);
147 if (ipwireless_debug)
148 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME ": ppp blocked\n");
149 return 0;
150 }
151}
152
153
154static int ipwireless_ppp_ioctl(struct ppp_channel *ppp_channel,
155 unsigned int cmd, unsigned long arg)
156{
157 struct ipw_network *network = ppp_channel->private;
158 int err, val;
159 u32 accm[8];
160 int __user *user_arg = (int __user *) arg;
161
162 err = -EFAULT;
163 switch (cmd) {
164 case PPPIOCGFLAGS:
165 val = network->flags | network->rbits;
166 if (put_user(val, user_arg))
167 break;
168 err = 0;
169 break;
170
171 case PPPIOCSFLAGS:
172 if (get_user(val, user_arg))
173 break;
174 network->flags = val & ~SC_RCV_BITS;
175 network->rbits = val & SC_RCV_BITS;
176 err = 0;
177 break;
178
179 case PPPIOCGASYNCMAP:
180 if (put_user(network->xaccm[0], user_arg))
181 break;
182 err = 0;
183 break;
184
185 case PPPIOCSASYNCMAP:
186 if (get_user(network->xaccm[0], user_arg))
187 break;
188 err = 0;
189 break;
190
191 case PPPIOCGRASYNCMAP:
192 if (put_user(network->raccm, user_arg))
193 break;
194 err = 0;
195 break;
196
197 case PPPIOCSRASYNCMAP:
198 if (get_user(network->raccm, user_arg))
199 break;
200 err = 0;
201 break;
202
203 case PPPIOCGXASYNCMAP:
204 if (copy_to_user((void __user *) arg, network->xaccm,
205 sizeof(network->xaccm)))
206 break;
207 err = 0;
208 break;
209
210 case PPPIOCSXASYNCMAP:
211 if (copy_from_user(accm, (void __user *) arg, sizeof(accm)))
212 break;
213 accm[2] &= ~0x40000000U;
214 accm[3] |= 0x60000000U;
215 memcpy(network->xaccm, accm, sizeof(network->xaccm));
216 err = 0;
217 break;
218
219 case PPPIOCGMRU:
220 if (put_user(network->mru, user_arg))
221 break;
222 err = 0;
223 break;
224
225 case PPPIOCSMRU:
226 if (get_user(val, user_arg))
227 break;
228 if (val < PPP_MRU)
229 val = PPP_MRU;
230 network->mru = val;
231 err = 0;
232 break;
233
234 default:
235 err = -ENOTTY;
236 }
237
238 return err;
239}
240
241static struct ppp_channel_ops ipwireless_ppp_channel_ops = {
242 .start_xmit = ipwireless_ppp_start_xmit,
243 .ioctl = ipwireless_ppp_ioctl
244};
245
246static void do_go_online(struct work_struct *work_go_online)
247{
248 struct ipw_network *network =
249 container_of(work_go_online, struct ipw_network,
250 work_go_online);
251 unsigned long flags;
252
253 spin_lock_irqsave(&network->lock, flags);
254 if (!network->ppp_channel) {
255 struct ppp_channel *channel;
256
257 spin_unlock_irqrestore(&network->lock, flags);
258 channel = kzalloc(sizeof(struct ppp_channel), GFP_KERNEL);
259 if (!channel) {
260 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
261 ": unable to allocate PPP channel\n");
262 return;
263 }
264 channel->private = network;
265 channel->mtu = 16384;
266 channel->hdrlen = 2;
267 channel->ops = &ipwireless_ppp_channel_ops;
268
269 network->flags = 0;
270 network->rbits = 0;
271 network->mru = PPP_MRU;
272 memset(network->xaccm, 0, sizeof(network->xaccm));
273 network->xaccm[0] = ~0U;
274 network->xaccm[3] = 0x60000000U;
275 network->raccm = ~0U;
276 ppp_register_channel(channel);
277 spin_lock_irqsave(&network->lock, flags);
278 network->ppp_channel = channel;
279 }
280 spin_unlock_irqrestore(&network->lock, flags);
281}
282
283static void do_go_offline(struct work_struct *work_go_offline)
284{
285 struct ipw_network *network =
286 container_of(work_go_offline, struct ipw_network,
287 work_go_offline);
288 unsigned long flags;
289
290 mutex_lock(&network->close_lock);
291 spin_lock_irqsave(&network->lock, flags);
292 if (network->ppp_channel != NULL) {
293 struct ppp_channel *channel = network->ppp_channel;
294
295 network->ppp_channel = NULL;
296 spin_unlock_irqrestore(&network->lock, flags);
297 mutex_unlock(&network->close_lock);
298 ppp_unregister_channel(channel);
299 } else {
300 spin_unlock_irqrestore(&network->lock, flags);
301 mutex_unlock(&network->close_lock);
302 }
303}
304
305void ipwireless_network_notify_control_line_change(struct ipw_network *network,
306 unsigned int channel_idx,
307 unsigned int control_lines,
308 unsigned int changed_mask)
309{
310 int i;
311
312 if (channel_idx == IPW_CHANNEL_RAS)
313 network->ras_control_lines = control_lines;
314
315 for (i = 0; i < MAX_ASSOCIATED_TTYS; i++) {
316 struct ipw_tty *tty =
317 network->associated_ttys[channel_idx][i];
318
319
320
321
322
323
324
325 if (tty)
326 ipwireless_tty_notify_control_line_change(tty,
327 channel_idx,
328 control_lines,
329 changed_mask);
330 }
331}
332
333
334
335
336
337
338static struct sk_buff *ipw_packet_received_skb(unsigned char *data,
339 unsigned int length)
340{
341 struct sk_buff *skb;
342
343 if (length > 2 && data[0] == PPP_ALLSTATIONS && data[1] == PPP_UI) {
344 length -= 2;
345 data += 2;
346 }
347
348 skb = dev_alloc_skb(length + 4);
349 skb_reserve(skb, 2);
350 memcpy(skb_put(skb, length), data, length);
351
352 return skb;
353}
354
355void ipwireless_network_packet_received(struct ipw_network *network,
356 unsigned int channel_idx,
357 unsigned char *data,
358 unsigned int length)
359{
360 int i;
361 unsigned long flags;
362
363 for (i = 0; i < MAX_ASSOCIATED_TTYS; i++) {
364 struct ipw_tty *tty = network->associated_ttys[channel_idx][i];
365
366 if (!tty)
367 continue;
368
369
370
371
372
373
374
375 if (channel_idx == IPW_CHANNEL_RAS
376 && (network->ras_control_lines &
377 IPW_CONTROL_LINE_DCD) != 0
378 && ipwireless_tty_is_modem(tty)) {
379
380
381
382
383
384 mutex_lock(&network->close_lock);
385 spin_lock_irqsave(&network->lock, flags);
386 if (network->ppp_channel != NULL) {
387 struct sk_buff *skb;
388
389 spin_unlock_irqrestore(&network->lock,
390 flags);
391
392
393 skb = ipw_packet_received_skb(data, length);
394 ppp_input(network->ppp_channel, skb);
395 } else
396 spin_unlock_irqrestore(&network->lock,
397 flags);
398 mutex_unlock(&network->close_lock);
399 }
400
401 else
402 ipwireless_tty_received(tty, data, length);
403 }
404}
405
406struct ipw_network *ipwireless_network_create(struct ipw_hardware *hw)
407{
408 struct ipw_network *network =
409 kzalloc(sizeof(struct ipw_network), GFP_ATOMIC);
410
411 if (!network)
412 return NULL;
413
414 spin_lock_init(&network->lock);
415 mutex_init(&network->close_lock);
416
417 network->hardware = hw;
418
419 INIT_WORK(&network->work_go_online, do_go_online);
420 INIT_WORK(&network->work_go_offline, do_go_offline);
421
422 ipwireless_associate_network(hw, network);
423
424 return network;
425}
426
427void ipwireless_network_free(struct ipw_network *network)
428{
429 network->shutting_down = 1;
430
431 ipwireless_ppp_close(network);
432 flush_scheduled_work();
433
434 ipwireless_stop_interrupts(network->hardware);
435 ipwireless_associate_network(network->hardware, NULL);
436
437 kfree(network);
438}
439
440void ipwireless_associate_network_tty(struct ipw_network *network,
441 unsigned int channel_idx,
442 struct ipw_tty *tty)
443{
444 int i;
445
446 for (i = 0; i < MAX_ASSOCIATED_TTYS; i++)
447 if (network->associated_ttys[channel_idx][i] == NULL) {
448 network->associated_ttys[channel_idx][i] = tty;
449 break;
450 }
451}
452
453void ipwireless_disassociate_network_ttys(struct ipw_network *network,
454 unsigned int channel_idx)
455{
456 int i;
457
458 for (i = 0; i < MAX_ASSOCIATED_TTYS; i++)
459 network->associated_ttys[channel_idx][i] = NULL;
460}
461
462void ipwireless_ppp_open(struct ipw_network *network)
463{
464 if (ipwireless_debug)
465 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME ": online\n");
466 schedule_work(&network->work_go_online);
467}
468
469void ipwireless_ppp_close(struct ipw_network *network)
470{
471
472 if (ipwireless_debug)
473 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME ": offline\n");
474 schedule_work(&network->work_go_offline);
475}
476
477int ipwireless_ppp_channel_index(struct ipw_network *network)
478{
479 int ret = -1;
480 unsigned long flags;
481
482 spin_lock_irqsave(&network->lock, flags);
483 if (network->ppp_channel != NULL)
484 ret = ppp_channel_index(network->ppp_channel);
485 spin_unlock_irqrestore(&network->lock, flags);
486
487 return ret;
488}
489
490int ipwireless_ppp_unit_number(struct ipw_network *network)
491{
492 int ret = -1;
493 unsigned long flags;
494
495 spin_lock_irqsave(&network->lock, flags);
496 if (network->ppp_channel != NULL)
497 ret = ppp_unit_number(network->ppp_channel);
498 spin_unlock_irqrestore(&network->lock, flags);
499
500 return ret;
501}
502
503int ipwireless_ppp_mru(const struct ipw_network *network)
504{
505 return network->mru;
506}
507