?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
RT-AC56 3.0.0.4.374.37 core
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / staging / cxt1e1 / linux.c
blob60dac321903d93eee47df5780c4e827d7752dea9
1 /* Copyright (C) 2007-2008 One Stop Systems
2 * Copyright (C) 2003-2006 SBE, Inc.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 */
14
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17 #include <linux/types.h>
18 #include <linux/netdevice.h>
19 #include <linux/hdlc.h>
20 #include <linux/if_arp.h>
21 #include <linux/init.h>
22 #include <asm/uaccess.h>
23 #include <linux/rtnetlink.h>
24 #include <linux/skbuff.h>
25 #include "pmcc4_sysdep.h"
26 #include "sbecom_inline_linux.h"
27 #include "libsbew.h"
28 #include "pmcc4.h"
29 #include "pmcc4_ioctls.h"
30 #include "pmcc4_private.h"
31 #include "sbeproc.h"
32
33 /*****************************************************************************************
34 * Error out early if we have compiler trouble.
35 *
36 * (This section is included from the kernel's init/main.c as a friendly
37 * spiderman recommendation...)
38 *
39 * Versions of gcc older than that listed below may actually compile and link
40 * okay, but the end product can have subtle run time bugs. To avoid associated
41 * bogus bug reports, we flatly refuse to compile with a gcc that is known to be
42 * too old from the very beginning.
43 */
44 #if (__GNUC__ < 3) || (__GNUC__ == 3 && __GNUC_MINOR__ < 2)
45 #error Sorry, your GCC is too old. It builds incorrect kernels.
46 #endif
47
48 #if __GNUC__ == 4 && __GNUC_MINOR__ == __GNUC_PATCHLEVEL__ == 0
49 #warning gcc-4.1.0 is known to miscompile the kernel. A different compiler version is recommended.
50 #endif
51
52 /*****************************************************************************************/
53
54 #ifdef SBE_INCLUDE_SYMBOLS
55 #define STATIC
56 #else
57 #define STATIC static
58 #endif
59
60 #define CHANNAME "hdlc"
61
62 /*******************************************************************/
63 /* forward references */
64 status_t c4_chan_work_init (mpi_t *, mch_t *);
65 void musycc_wq_chan_restart (void *);
66 status_t __init c4_init (ci_t *, u_char *, u_char *);
67 status_t __init c4_init2 (ci_t *);
68 ci_t *__init c4_new (void *);
69 int __init c4hw_attach_all (void);
70 void __init hdw_sn_get (hdw_info_t *, int);
71
72 #ifdef CONFIG_SBE_PMCC4_NCOMM
73 irqreturn_t c4_ebus_intr_th_handler (void *);
74
75 #endif
76 int c4_frame_rw (ci_t *, struct sbecom_port_param *);
77 status_t c4_get_port (ci_t *, int);
78 int c4_loop_port (ci_t *, int, u_int8_t);
79 int c4_musycc_rw (ci_t *, struct c4_musycc_param *);
80 int c4_new_chan (ci_t *, int, int, void *);
81 status_t c4_set_port (ci_t *, int);
82 int c4_pld_rw (ci_t *, struct sbecom_port_param *);
83 void cleanup_devs (void);
84 void cleanup_ioremap (void);
85 status_t musycc_chan_down (ci_t *, int);
86 irqreturn_t musycc_intr_th_handler (void *);
87 int musycc_start_xmit (ci_t *, int, void *);
88
89 extern char pmcc4_OSSI_release[];
90 extern ci_t *CI;
91 extern struct s_hdw_info hdw_info[];
92
93 #if defined(CONFIG_SBE_HDLC_V7) || defined(CONFIG_SBE_WAN256T3_HDLC_V7) || \
94 defined(CONFIG_SBE_HDLC_V7_MODULE) || defined(CONFIG_SBE_WAN256T3_HDLC_V7_MODULE)
95 #define _v7_hdlc_ 1
96 #else
97 #define _v7_hdlc_ 0
98 #endif
99
100 #if _v7_hdlc_
101 #define V7(x) (x ## _v7)
102 extern int hdlc_netif_rx_v7 (hdlc_device *, struct sk_buff *);
103 extern int register_hdlc_device_v7 (hdlc_device *);
104 extern int unregister_hdlc_device_v7 (hdlc_device *);
105
106 #else
107 #define V7(x) x
108 #endif
109
110 int error_flag; /* module load error reporting */
111 int log_level = LOG_ERROR;
112 int log_level_default = LOG_ERROR;
113 module_param(log_level, int, 0444);
114
115 int max_mru = MUSYCC_MRU;
116 int max_mru_default = MUSYCC_MRU;
117 module_param(max_mru, int, 0444);
118
119 int max_mtu = MUSYCC_MTU;
120 int max_mtu_default = MUSYCC_MTU;
121 module_param(max_mtu, int, 0444);
122
123 int max_txdesc_used = MUSYCC_TXDESC_MIN;
124 int max_txdesc_default = MUSYCC_TXDESC_MIN;
125 module_param(max_txdesc_used, int, 0444);
126
127 int max_rxdesc_used = MUSYCC_RXDESC_MIN;
128 int max_rxdesc_default = MUSYCC_RXDESC_MIN;
129 module_param(max_rxdesc_used, int, 0444);
130
131 /****************************************************************************/
132 /****************************************************************************/
133 /****************************************************************************/
134
135 void *
136 getuserbychan (int channum)
137 {
138 mch_t *ch;
139
140 ch = c4_find_chan (channum);
141 return ch ? ch->user : 0;
142 }
143
144
145 char *
146 get_hdlc_name (hdlc_device * hdlc)
147 {
148 struct c4_priv *priv = hdlc->priv;
149 struct net_device *dev = getuserbychan (priv->channum);
150
151 return dev->name;
152 }
153
154
155 static status_t
156 mkret (int bsd)
157 {
158 if (bsd > 0)
159 return -bsd;
160 else
161 return bsd;
162 }
163
164 /***************************************************************************/
165 #include <linux/workqueue.h>
166
167 /***
168 * One workqueue (wq) per port (since musycc allows simultaneous group
169 * commands), with individual data for each channel:
170 *
171 * mpi_t -> struct workqueue_struct *wq_port; (dynamically allocated using
172 * create_workqueue())
173 *
174 * With work structure (work) statically allocated for each channel:
175 *
176 * mch_t -> struct work_struct ch_work; (statically allocated using ???)
177 *
178 ***/
179
180
181 /*
182 * Called by the start transmit routine when a channel TX_ENABLE is to be
183 * issued. This queues the transmission start request among other channels
184 * within a port's group.
185 */
186 void
187 c4_wk_chan_restart (mch_t * ch)
188 {
189 mpi_t *pi = ch->up;
190
191 #ifdef RLD_RESTART_DEBUG
192 pr_info(">> %s: queueing Port %d Chan %d, mch_t @ %p\n",
193 __func__, pi->portnum, ch->channum, ch);
194 #endif
195
196 /* create new entry w/in workqueue for this channel and let'er rip */
197
198 /** queue_work (struct workqueue_struct *queue,
199 ** struct work_struct *work);
200 **/
201 queue_work (pi->wq_port, &ch->ch_work);
202 }
203
204 status_t
205 c4_wk_chan_init (mpi_t * pi, mch_t * ch)
206 {
207 /*
208 * this will be used to restart a stopped channel
209 */
210
211 /** INIT_WORK (struct work_struct *work,
212 ** void (*function)(void *),
213 ** void *data);
214 **/
215 INIT_WORK(&ch->ch_work, (void *)musycc_wq_chan_restart);
216 return 0; /* success */
217 }
218
219 status_t
220 c4_wq_port_init (mpi_t * pi)
221 {
222
223 char name[16], *np; /* NOTE: name of the queue limited by system
224 * to 10 characters */
225
226 if (pi->wq_port)
227 return 0; /* already initialized */
228
229 np = name;
230 memset (name, 0, 16);
231 sprintf (np, "%s%d", pi->up->devname, pi->portnum); /* IE pmcc4-01) */
232
233 #ifdef RLD_RESTART_DEBUG
234 pr_info(">> %s: creating workqueue <%s> for Port %d.\n",
235 __func__, name, pi->portnum); /* RLD DEBUG */
236 #endif
237 if (!(pi->wq_port = create_singlethread_workqueue (name)))
238 return ENOMEM;
239 return 0; /* success */
240 }
241
242 void
243 c4_wq_port_cleanup (mpi_t * pi)
244 {
245 /*
246 * PORT POINT: cannot call this if WQ is statically allocated w/in
247 * structure since it calls kfree(wq);
248 */
249 if (pi->wq_port)
250 {
251 destroy_workqueue (pi->wq_port); /* this also calls
252 * flush_workqueue() */
253 pi->wq_port = 0;
254 }
255 }
256
257 /***************************************************************************/
258
259 irqreturn_t
260 c4_linux_interrupt (int irq, void *dev_instance)
261 {
262 struct net_device *ndev = dev_instance;
263
264 return musycc_intr_th_handler(netdev_priv(ndev));
265 }
266
267
268 #ifdef CONFIG_SBE_PMCC4_NCOMM
269 irqreturn_t
270 c4_ebus_interrupt (int irq, void *dev_instance)
271 {
272 struct net_device *ndev = dev_instance;
273
274 return c4_ebus_intr_th_handler(netdev_priv(ndev));
275 }
276 #endif
277
278
279 static int
280 void_open (struct net_device * ndev)
281 {
282 pr_info("%s: trying to open master device !\n", ndev->name);
283 return -1;
284 }
285
286
287 STATIC int
288 chan_open (struct net_device * ndev)
289 {
290 hdlc_device *hdlc = dev_to_hdlc (ndev);
291 const struct c4_priv *priv = hdlc->priv;
292 int ret;
293
294 if ((ret = hdlc_open (ndev)))
295 {
296 pr_info("hdlc_open failure, err %d.\n", ret);
297 return ret;
298 }
299 if ((ret = c4_chan_up (priv->ci, priv->channum)))
300 return -ret;
301 try_module_get (THIS_MODULE);
302 netif_start_queue (ndev);
303 return 0; /* no error = success */
304 }
305
306
307 STATIC int
308 chan_close (struct net_device * ndev)
309 {
310 hdlc_device *hdlc = dev_to_hdlc (ndev);
311 const struct c4_priv *priv = hdlc->priv;
312
313 netif_stop_queue (ndev);
314 musycc_chan_down ((ci_t *) 0, priv->channum);
315 hdlc_close (ndev);
316 module_put (THIS_MODULE);
317 return 0;
318 }
319
320
321 STATIC int
322 chan_dev_ioctl (struct net_device * dev, struct ifreq * ifr, int cmd)
323 {
324 return hdlc_ioctl (dev, ifr, cmd);
325 }
326
327
328 STATIC int
329 chan_attach_noop (struct net_device * ndev, unsigned short foo_1, unsigned short foo_2)
330 {
331 return 0; /* our driver has nothing to do here, show's
332 * over, go home */
333 }
334
335
336 STATIC struct net_device_stats *
337 chan_get_stats (struct net_device * ndev)
338 {
339 mch_t *ch;
340 struct net_device_stats *nstats;
341 struct sbecom_chan_stats *stats;
342 int channum;
343
344 {
345 struct c4_priv *priv;
346
347 priv = (struct c4_priv *) dev_to_hdlc (ndev)->priv;
348 channum = priv->channum;
349 }
350
351 ch = c4_find_chan (channum);
352 if (ch == NULL)
353 return NULL;
354
355 nstats = &ndev->stats;
356 stats = &ch->s;
357
358 memset (nstats, 0, sizeof (struct net_device_stats));
359 nstats->rx_packets = stats->rx_packets;
360 nstats->tx_packets = stats->tx_packets;
361 nstats->rx_bytes = stats->rx_bytes;
362 nstats->tx_bytes = stats->tx_bytes;
363 nstats->rx_errors = stats->rx_length_errors +
364 stats->rx_over_errors +
365 stats->rx_crc_errors +
366 stats->rx_frame_errors +
367 stats->rx_fifo_errors +
368 stats->rx_missed_errors;
369 nstats->tx_errors = stats->tx_dropped +
370 stats->tx_aborted_errors +
371 stats->tx_fifo_errors;
372 nstats->rx_dropped = stats->rx_dropped;
373 nstats->tx_dropped = stats->tx_dropped;
374
375 nstats->rx_length_errors = stats->rx_length_errors;
376 nstats->rx_over_errors = stats->rx_over_errors;
377 nstats->rx_crc_errors = stats->rx_crc_errors;
378 nstats->rx_frame_errors = stats->rx_frame_errors;
379 nstats->rx_fifo_errors = stats->rx_fifo_errors;
380 nstats->rx_missed_errors = stats->rx_missed_errors;
381
382 nstats->tx_aborted_errors = stats->tx_aborted_errors;
383 nstats->tx_fifo_errors = stats->tx_fifo_errors;
384
385 return nstats;
386 }
387
388
389 static ci_t *
390 get_ci_by_dev (struct net_device * ndev)
391 {
392 return (ci_t *)(netdev_priv(ndev));
393 }
394
395
396 STATIC int
397 c4_linux_xmit (struct sk_buff * skb, struct net_device * ndev)
398 {
399 const struct c4_priv *priv;
400 int rval;
401
402 hdlc_device *hdlc = dev_to_hdlc (ndev);
403
404 priv = hdlc->priv;
405
406 rval = musycc_start_xmit (priv->ci, priv->channum, skb);
407 return -rval;
408 }
409
410 static const struct net_device_ops chan_ops = {
411 .ndo_open = chan_open,
412 .ndo_stop = chan_close,
413 .ndo_start_xmit = c4_linux_xmit,
414 .ndo_do_ioctl = chan_dev_ioctl,
415 .ndo_get_stats = chan_get_stats,
416 };
417
418 STATIC struct net_device *
419 create_chan (struct net_device * ndev, ci_t * ci,
420 struct sbecom_chan_param * cp)
421 {
422 hdlc_device *hdlc;
423 struct net_device *dev;
424 hdw_info_t *hi;
425 int ret;
426
427 if (c4_find_chan (cp->channum))
428 return 0; /* channel already exists */
429
430 {
431 struct c4_priv *priv;
432
433 /* allocate then fill in private data structure */
434 priv = OS_kmalloc (sizeof (struct c4_priv));
435 if (!priv)
436 {
437 pr_warning("%s: no memory for net_device !\n", ci->devname);
438 return 0;
439 }
440 dev = alloc_hdlcdev (priv);
441 if (!dev)
442 {
443 pr_warning("%s: no memory for hdlc_device !\n", ci->devname);
444 OS_kfree (priv);
445 return 0;
446 }
447 priv->ci = ci;
448 priv->channum = cp->channum;
449 }
450
451 hdlc = dev_to_hdlc (dev);
452
453 dev->base_addr = 0; /* not I/O mapped */
454 dev->irq = ndev->irq;
455 dev->type = ARPHRD_RAWHDLC;
456 *dev->name = 0; /* default ifconfig name = "hdlc" */
457
458 hi = (hdw_info_t *) ci->hdw_info;
459 if (hi->mfg_info_sts == EEPROM_OK)
460 {
461 switch (hi->promfmt)
462 {
463 case PROM_FORMAT_TYPE1:
464 memcpy (dev->dev_addr, (FLD_TYPE1 *) (hi->mfg_info.pft1.Serial), 6);
465 break;
466 case PROM_FORMAT_TYPE2:
467 memcpy (dev->dev_addr, (FLD_TYPE2 *) (hi->mfg_info.pft2.Serial), 6);
468 break;
469 default:
470 memset (dev->dev_addr, 0, 6);
471 break;
472 }
473 } else
474 {
475 memset (dev->dev_addr, 0, 6);
476 }
477
478 hdlc->xmit = c4_linux_xmit;
479
480 dev->netdev_ops = &chan_ops;
481 /*
482 * The native hdlc stack calls this 'attach' routine during
483 * hdlc_raw_ioctl(), passing parameters for line encoding and parity.
484 * Since hdlc_raw_ioctl() stack does not interrogate whether an 'attach'
485 * routine is actually registered or not, we supply a dummy routine which
486 * does nothing (since encoding and parity are setup for our driver via a
487 * special configuration application).
488 */
489
490 hdlc->attach = chan_attach_noop;
491
492 rtnl_unlock (); /* needed due to Ioctl calling sequence */
493 ret = register_hdlc_device (dev);
494 /* NOTE: <stats> setting must occur AFTER registration in order to "take" */
495 dev->tx_queue_len = MAX_DEFAULT_IFQLEN;
496
497 rtnl_lock (); /* needed due to Ioctl calling sequence */
498 if (ret)
499 {
500 if (log_level >= LOG_WARN)
501 pr_info("%s: create_chan[%d] registration error = %d.\n",
502 ci->devname, cp->channum, ret);
503 free_netdev (dev); /* cleanup */
504 return 0; /* failed to register */
505 }
506 return dev;
507 }
508
509
510 /* the idea here is to get port information and pass it back (using pointer) */
511 STATIC status_t
512 do_get_port (struct net_device * ndev, void *data)
513 {
514 int ret;
515 ci_t *ci; /* ci stands for card information */
516 struct sbecom_port_param pp;/* copy data to kernel land */
517
518 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
519 return -EFAULT;
520 if (pp.portnum >= MUSYCC_NPORTS)
521 return -EFAULT;
522 ci = get_ci_by_dev (ndev);
523 if (!ci)
524 return -EINVAL; /* get card info */
525
526 ret = mkret (c4_get_port (ci, pp.portnum));
527 if (ret)
528 return ret;
529 if (copy_to_user (data, &ci->port[pp.portnum].p,
530 sizeof (struct sbecom_port_param)))
531 return -EFAULT;
532 return 0;
533 }
534
535 /* this function copys the user data and then calls the real action function */
536 STATIC status_t
537 do_set_port (struct net_device * ndev, void *data)
538 {
539 ci_t *ci; /* ci stands for card information */
540 struct sbecom_port_param pp;/* copy data to kernel land */
541
542 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
543 return -EFAULT;
544 if (pp.portnum >= MUSYCC_NPORTS)
545 return -EFAULT;
546 ci = get_ci_by_dev (ndev);
547 if (!ci)
548 return -EINVAL; /* get card info */
549
550 if (pp.portnum >= ci->max_port) /* sanity check */
551 return ENXIO;
552
553 memcpy (&ci->port[pp.portnum].p, &pp, sizeof (struct sbecom_port_param));
554 return mkret (c4_set_port (ci, pp.portnum));
555 }
556
557 /* work the port loopback mode as per directed */
558 STATIC status_t
559 do_port_loop (struct net_device * ndev, void *data)
560 {
561 struct sbecom_port_param pp;
562 ci_t *ci;
563
564 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
565 return -EFAULT;
566 ci = get_ci_by_dev (ndev);
567 if (!ci)
568 return -EINVAL;
569 return mkret (c4_loop_port (ci, pp.portnum, pp.port_mode));
570 }
571
572 /* set the specified register with the given value / or just read it */
573 STATIC status_t
574 do_framer_rw (struct net_device * ndev, void *data)
575 {
576 struct sbecom_port_param pp;
577 ci_t *ci;
578 int ret;
579
580 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
581 return -EFAULT;
582 ci = get_ci_by_dev (ndev);
583 if (!ci)
584 return -EINVAL;
585 ret = mkret (c4_frame_rw (ci, &pp));
586 if (ret)
587 return ret;
588 if (copy_to_user (data, &pp, sizeof (struct sbecom_port_param)))
589 return -EFAULT;
590 return 0;
591 }
592
593 /* set the specified register with the given value / or just read it */
594 STATIC status_t
595 do_pld_rw (struct net_device * ndev, void *data)
596 {
597 struct sbecom_port_param pp;
598 ci_t *ci;
599 int ret;
600
601 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
602 return -EFAULT;
603 ci = get_ci_by_dev (ndev);
604 if (!ci)
605 return -EINVAL;
606 ret = mkret (c4_pld_rw (ci, &pp));
607 if (ret)
608 return ret;
609 if (copy_to_user (data, &pp, sizeof (struct sbecom_port_param)))
610 return -EFAULT;
611 return 0;
612 }
613
614 /* set the specified register with the given value / or just read it */
615 STATIC status_t
616 do_musycc_rw (struct net_device * ndev, void *data)
617 {
618 struct c4_musycc_param mp;
619 ci_t *ci;
620 int ret;
621
622 if (copy_from_user (&mp, data, sizeof (struct c4_musycc_param)))
623 return -EFAULT;
624 ci = get_ci_by_dev (ndev);
625 if (!ci)
626 return -EINVAL;
627 ret = mkret (c4_musycc_rw (ci, &mp));
628 if (ret)
629 return ret;
630 if (copy_to_user (data, &mp, sizeof (struct c4_musycc_param)))
631 return -EFAULT;
632 return 0;
633 }
634
635 STATIC status_t
636 do_get_chan (struct net_device * ndev, void *data)
637 {
638 struct sbecom_chan_param cp;
639 int ret;
640
641 if (copy_from_user (&cp, data,
642 sizeof (struct sbecom_chan_param)))
643 return -EFAULT;
644
645 if ((ret = mkret (c4_get_chan (cp.channum, &cp))))
646 return ret;
647
648 if (copy_to_user (data, &cp, sizeof (struct sbecom_chan_param)))
649 return -EFAULT;
650 return 0;
651 }
652
653 STATIC status_t
654 do_set_chan (struct net_device * ndev, void *data)
655 {
656 struct sbecom_chan_param cp;
657 int ret;
658 ci_t *ci;
659
660 if (copy_from_user (&cp, data, sizeof (struct sbecom_chan_param)))
661 return -EFAULT;
662 ci = get_ci_by_dev (ndev);
663 if (!ci)
664 return -EINVAL;
665 switch (ret = mkret (c4_set_chan (cp.channum, &cp)))
666 {
667 case 0:
668 return 0;
669 default:
670 return ret;
671 }
672 }
673
674 STATIC status_t
675 do_create_chan (struct net_device * ndev, void *data)
676 {
677 ci_t *ci;
678 struct net_device *dev;
679 struct sbecom_chan_param cp;
680 int ret;
681
682 if (copy_from_user (&cp, data, sizeof (struct sbecom_chan_param)))
683 return -EFAULT;
684 ci = get_ci_by_dev (ndev);
685 if (!ci)
686 return -EINVAL;
687 dev = create_chan (ndev, ci, &cp);
688 if (!dev)
689 return -EBUSY;
690 ret = mkret (c4_new_chan (ci, cp.port, cp.channum, dev));
691 if (ret)
692 {
693 rtnl_unlock (); /* needed due to Ioctl calling sequence */
694 unregister_hdlc_device (dev);
695 rtnl_lock (); /* needed due to Ioctl calling sequence */
696 free_netdev (dev);
697 }
698 return ret;
699 }
700
701 STATIC status_t
702 do_get_chan_stats (struct net_device * ndev, void *data)
703 {
704 struct c4_chan_stats_wrap ccs;
705 int ret;
706
707 if (copy_from_user (&ccs, data,
708 sizeof (struct c4_chan_stats_wrap)))
709 return -EFAULT;
710 switch (ret = mkret (c4_get_chan_stats (ccs.channum, &ccs.stats)))
711 {
712 case 0:
713 break;
714 default:
715 return ret;
716 }
717 if (copy_to_user (data, &ccs,
718 sizeof (struct c4_chan_stats_wrap)))
719 return -EFAULT;
720 return 0;
721 }
722 STATIC status_t
723 do_set_loglevel (struct net_device * ndev, void *data)
724 {
725 unsigned int log_level;
726
727 if (copy_from_user (&log_level, data, sizeof (int)))
728 return -EFAULT;
729 sbecom_set_loglevel (log_level);
730 return 0;
731 }
732
733 STATIC status_t
734 do_deluser (struct net_device * ndev, int lockit)
735 {
736 if (ndev->flags & IFF_UP)
737 return -EBUSY;
738
739 {
740 ci_t *ci;
741 mch_t *ch;
742 const struct c4_priv *priv;
743 int channum;
744
745 priv = (struct c4_priv *) dev_to_hdlc (ndev)->priv;
746 ci = priv->ci;
747 channum = priv->channum;
748
749 ch = c4_find_chan (channum);
750 if (ch == NULL)
751 return -ENOENT;
752 ch->user = 0; /* will be freed, below */
753 }
754
755 if (lockit)
756 rtnl_unlock (); /* needed if Ioctl calling sequence */
757 unregister_hdlc_device (ndev);
758 if (lockit)
759 rtnl_lock (); /* needed if Ioctl calling sequence */
760 free_netdev (ndev);
761 return 0;
762 }
763
764 int
765 do_del_chan (struct net_device * musycc_dev, void *data)
766 {
767 struct sbecom_chan_param cp;
768 char buf[sizeof (CHANNAME) + 3];
769 struct net_device *dev;
770 int ret;
771
772 if (copy_from_user (&cp, data,
773 sizeof (struct sbecom_chan_param)))
774 return -EFAULT;
775 sprintf (buf, CHANNAME "%d", cp.channum);
776 if (!(dev = dev_get_by_name (&init_net, buf)))
777 return -ENOENT;
778 dev_put (dev);
779 ret = do_deluser (dev, 1);
780 if (ret)
781 return ret;
782 return c4_del_chan (cp.channum);
783 }
784 int c4_reset_board (void *);
785
786 int
787 do_reset (struct net_device * musycc_dev, void *data)
788 {
789 const struct c4_priv *priv;
790 int i;
791
792 for (i = 0; i < 128; i++)
793 {
794 struct net_device *ndev;
795 char buf[sizeof (CHANNAME) + 3];
796
797 sprintf (buf, CHANNAME "%d", i);
798 if (!(ndev = dev_get_by_name(&init_net, buf)))
799 continue;
800 priv = dev_to_hdlc (ndev)->priv;
801
802 if ((unsigned long) (priv->ci) ==
803 (unsigned long) (netdev_priv(musycc_dev)))
804 {
805 ndev->flags &= ~IFF_UP;
806 dev_put (ndev);
807 netif_stop_queue (ndev);
808 do_deluser (ndev, 1);
809 } else
810 dev_put (ndev);
811 }
812 return 0;
813 }
814
815 int
816 do_reset_chan_stats (struct net_device * musycc_dev, void *data)
817 {
818 struct sbecom_chan_param cp;
819
820 if (copy_from_user (&cp, data,
821 sizeof (struct sbecom_chan_param)))
822 return -EFAULT;
823 return mkret (c4_del_chan_stats (cp.channum));
824 }
825
826 STATIC status_t
827 c4_ioctl (struct net_device * ndev, struct ifreq * ifr, int cmd)
828 {
829 ci_t *ci;
830 void *data;
831 int iocmd, iolen;
832 status_t ret;
833 static struct data
834 {
835 union
836 {
837 u_int8_t c;
838 u_int32_t i;
839 struct sbe_brd_info bip;
840 struct sbe_drv_info dip;
841 struct sbe_iid_info iip;
842 struct sbe_brd_addr bap;
843 struct sbecom_chan_stats stats;
844 struct sbecom_chan_param param;
845 struct temux_card_stats cards;
846 struct sbecom_card_param cardp;
847 struct sbecom_framer_param frp;
848 } u;
849 } arg;
850
851
852 if (!capable (CAP_SYS_ADMIN))
853 return -EPERM;
854 if (cmd != SIOCDEVPRIVATE + 15)
855 return -EINVAL;
856 if (!(ci = get_ci_by_dev (ndev)))
857 return -EINVAL;
858 if (ci->state != C_RUNNING)
859 return -ENODEV;
860 if (copy_from_user (&iocmd, ifr->ifr_data, sizeof (iocmd)))
861 return -EFAULT;
862
863 iolen = _IOC_SIZE (iocmd);
864 data = ifr->ifr_data + sizeof (iocmd);
865 if (copy_from_user (&arg, data, iolen))
866 return -EFAULT;
867
868 ret = 0;
869 switch (iocmd)
870 {
871 case SBE_IOC_PORT_GET:
872 //pr_info(">> SBE_IOC_PORT_GET Ioctl...\n");
873 ret = do_get_port (ndev, data);
874 break;
875 case SBE_IOC_PORT_SET:
876 //pr_info(">> SBE_IOC_PORT_SET Ioctl...\n");
877 ret = do_set_port (ndev, data);
878 break;
879 case SBE_IOC_CHAN_GET:
880 //pr_info(">> SBE_IOC_CHAN_GET Ioctl...\n");
881 ret = do_get_chan (ndev, data);
882 break;
883 case SBE_IOC_CHAN_SET:
884 //pr_info(">> SBE_IOC_CHAN_SET Ioctl...\n");
885 ret = do_set_chan (ndev, data);
886 break;
887 case C4_DEL_CHAN:
888 //pr_info(">> C4_DEL_CHAN Ioctl...\n");
889 ret = do_del_chan (ndev, data);
890 break;
891 case SBE_IOC_CHAN_NEW:
892 ret = do_create_chan (ndev, data);
893 break;
894 case SBE_IOC_CHAN_GET_STAT:
895 ret = do_get_chan_stats (ndev, data);
896 break;
897 case SBE_IOC_LOGLEVEL:
898 ret = do_set_loglevel (ndev, data);
899 break;
900 case SBE_IOC_RESET_DEV:
901 ret = do_reset (ndev, data);
902 break;
903 case SBE_IOC_CHAN_DEL_STAT:
904 ret = do_reset_chan_stats (ndev, data);
905 break;
906 case C4_LOOP_PORT:
907 ret = do_port_loop (ndev, data);
908 break;
909 case C4_RW_FRMR:
910 ret = do_framer_rw (ndev, data);
911 break;
912 case C4_RW_MSYC:
913 ret = do_musycc_rw (ndev, data);
914 break;
915 case C4_RW_PLD:
916 ret = do_pld_rw (ndev, data);
917 break;
918 case SBE_IOC_IID_GET:
919 ret = (iolen == sizeof (struct sbe_iid_info)) ? c4_get_iidinfo (ci, &arg.u.iip) : -EFAULT;
920 if (ret == 0) /* no error, copy data */
921 if (copy_to_user (data, &arg, iolen))
922 return -EFAULT;
923 break;
924 default:
925 //pr_info(">> c4_ioctl: EINVAL - unknown iocmd <%x>\n", iocmd);
926 ret = -EINVAL;
927 break;
928 }
929 return mkret (ret);
930 }
931
932 static const struct net_device_ops c4_ops = {
933 .ndo_open = void_open,
934 .ndo_start_xmit = c4_linux_xmit,
935 .ndo_do_ioctl = c4_ioctl,
936 };
937
938 static void c4_setup(struct net_device *dev)
939 {
940 dev->type = ARPHRD_VOID;
941 dev->netdev_ops = &c4_ops;
942 }
943
944 struct net_device *__init
945 c4_add_dev (hdw_info_t * hi, int brdno, unsigned long f0, unsigned long f1,
946 int irq0, int irq1)
947 {
948 struct net_device *ndev;
949 ci_t *ci;
950
951 ndev = alloc_netdev(sizeof(ci_t), SBE_IFACETMPL, c4_setup);
952 if (!ndev)
953 {
954 pr_warning("%s: no memory for struct net_device !\n", hi->devname);
955 error_flag = ENOMEM;
956 return 0;
957 }
958 ci = (ci_t *)(netdev_priv(ndev));
959 ndev->irq = irq0;
960
961 ci->hdw_info = hi;
962 ci->state = C_INIT; /* mark as hardware not available */
963 ci->next = c4_list;
964 c4_list = ci;
965 ci->brdno = ci->next ? ci->next->brdno + 1 : 0;
966
967 if (CI == 0)
968 CI = ci; /* DEBUG, only board 0 usage */
969
970 strcpy (ci->devname, hi->devname);
971 ci->release = &pmcc4_OSSI_release[0];
972
973 /* tasklet */
974 #if defined(SBE_ISR_TASKLET)
975 tasklet_init (&ci->ci_musycc_isr_tasklet,
976 (void (*) (unsigned long)) musycc_intr_bh_tasklet,
977 (unsigned long) ci);
978
979 if (atomic_read (&ci->ci_musycc_isr_tasklet.count) == 0)
980 tasklet_disable_nosync (&ci->ci_musycc_isr_tasklet);
981 #elif defined(SBE_ISR_IMMEDIATE)
982 ci->ci_musycc_isr_tq.routine = (void *) (unsigned long) musycc_intr_bh_tasklet;
983 ci->ci_musycc_isr_tq.data = ci;
984 #endif
985
986
987 if (register_netdev (ndev) ||
988 (c4_init (ci, (u_char *) f0, (u_char *) f1) != SBE_DRVR_SUCCESS))
989 {
990 OS_kfree (netdev_priv(ndev));
991 OS_kfree (ndev);
992 error_flag = ENODEV;
993 return 0;
994 }
995 /*************************************************************
996 * int request_irq(unsigned int irq,
997 * void (*handler)(int, void *, struct pt_regs *),
998 * unsigned long flags, const char *dev_name, void *dev_id);
999 * wherein:
1000 * irq -> The interrupt number that is being requested.
1001 * handler -> Pointer to handling function being installed.
1002 * flags -> A bit mask of options related to interrupt management.
1003 * dev_name -> String used in /proc/interrupts to show owner of interrupt.
1004 * dev_id -> Pointer (for shared interrupt lines) to point to its own
1005 * private data area (to identify which device is interrupting).
1006 *
1007 * extern void free_irq(unsigned int irq, void *dev_id);
1008 **************************************************************/
1009
1010 if (request_irq (irq0, &c4_linux_interrupt,
1011 #if defined(SBE_ISR_TASKLET)
1012 IRQF_DISABLED | IRQF_SHARED,
1013 #elif defined(SBE_ISR_IMMEDIATE)
1014 IRQF_DISABLED | IRQF_SHARED,
1015 #elif defined(SBE_ISR_INLINE)
1016 IRQF_SHARED,
1017 #endif
1018 ndev->name, ndev))
1019 {
1020 pr_warning("%s: MUSYCC could not get irq: %d\n", ndev->name, irq0);
1021 unregister_netdev (ndev);
1022 OS_kfree (netdev_priv(ndev));
1023 OS_kfree (ndev);
1024 error_flag = EIO;
1025 return 0;
1026 }
1027 #ifdef CONFIG_SBE_PMCC4_NCOMM
1028 if (request_irq (irq1, &c4_ebus_interrupt, IRQF_SHARED, ndev->name, ndev))
1029 {
1030 pr_warning("%s: EBUS could not get irq: %d\n", hi->devname, irq1);
1031 unregister_netdev (ndev);
1032 free_irq (irq0, ndev);
1033 OS_kfree (netdev_priv(ndev));
1034 OS_kfree (ndev);
1035 error_flag = EIO;
1036 return 0;
1037 }
1038 #endif
1039
1040 /* setup board identification information */
1041
1042 {
1043 u_int32_t tmp;
1044
1045 hdw_sn_get (hi, brdno); /* also sets PROM format type (promfmt)
1046 * for later usage */
1047
1048 switch (hi->promfmt)
1049 {
1050 case PROM_FORMAT_TYPE1:
1051 memcpy (ndev->dev_addr, (FLD_TYPE1 *) (hi->mfg_info.pft1.Serial), 6);
1052 memcpy (&tmp, (FLD_TYPE1 *) (hi->mfg_info.pft1.Id), 4); /* unaligned data
1053 * acquisition */
1054 ci->brd_id = cpu_to_be32 (tmp);
1055 break;
1056 case PROM_FORMAT_TYPE2:
1057 memcpy (ndev->dev_addr, (FLD_TYPE2 *) (hi->mfg_info.pft2.Serial), 6);
1058 memcpy (&tmp, (FLD_TYPE2 *) (hi->mfg_info.pft2.Id), 4); /* unaligned data
1059 * acquisition */
1060 ci->brd_id = cpu_to_be32 (tmp);
1061 break;
1062 default:
1063 ci->brd_id = 0;
1064 memset (ndev->dev_addr, 0, 6);
1065 break;
1066 }
1067
1068 sbeid_set_hdwbid (ci); /* requires bid to be preset */
1069
1070 }
1071
1072 #ifdef CONFIG_PROC_FS
1073 sbecom_proc_brd_init (ci);
1074 #endif
1075 #if defined(SBE_ISR_TASKLET)
1076 tasklet_enable (&ci->ci_musycc_isr_tasklet);
1077 #endif
1078
1079
1080 if ((error_flag = c4_init2 (ci)) != SBE_DRVR_SUCCESS)
1081 {
1082 #ifdef CONFIG_PROC_FS
1083 sbecom_proc_brd_cleanup (ci);
1084 #endif
1085 unregister_netdev (ndev);
1086 free_irq (irq1, ndev);
1087 free_irq (irq0, ndev);
1088 OS_kfree (netdev_priv(ndev));
1089 OS_kfree (ndev);
1090 return 0; /* failure, error_flag is set */
1091 }
1092 return ndev;
1093 }
1094
1095 STATIC int __init
1096 c4_mod_init (void)
1097 {
1098 int rtn;
1099
1100 pr_warning("%s\n", pmcc4_OSSI_release);
1101 if ((rtn = c4hw_attach_all ()))
1102 return -rtn; /* installation failure - see system log */
1103
1104 /* housekeeping notifications */
1105 if (log_level != log_level_default)
1106 pr_info("NOTE: driver parameter <log_level> changed from default %d to %d.\n",
1107 log_level_default, log_level);
1108 if (max_mru != max_mru_default)
1109 pr_info("NOTE: driver parameter <max_mru> changed from default %d to %d.\n",
1110 max_mru_default, max_mru);
1111 if (max_mtu != max_mtu_default)
1112 pr_info("NOTE: driver parameter <max_mtu> changed from default %d to %d.\n",
1113 max_mtu_default, max_mtu);
1114 if (max_rxdesc_used != max_rxdesc_default)
1115 {
1116 if (max_rxdesc_used > 2000)
1117 max_rxdesc_used = 2000; /* out-of-bounds reset */
1118 pr_info("NOTE: driver parameter <max_rxdesc_used> changed from default %d to %d.\n",
1119 max_rxdesc_default, max_rxdesc_used);
1120 }
1121 if (max_txdesc_used != max_txdesc_default)
1122 {
1123 if (max_txdesc_used > 1000)
1124 max_txdesc_used = 1000; /* out-of-bounds reset */
1125 pr_info("NOTE: driver parameter <max_txdesc_used> changed from default %d to %d.\n",
1126 max_txdesc_default, max_txdesc_used);
1127 }
1128 return 0; /* installation success */
1129 }
1130
1131
1132 /*
1133 * find any still allocated hdlc registrations and unregister via call to
1134 * do_deluser()
1135 */
1136
1137 STATIC void __exit
1138 cleanup_hdlc (void)
1139 {
1140 hdw_info_t *hi;
1141 ci_t *ci;
1142 struct net_device *ndev;
1143 int i, j, k;
1144
1145 for (i = 0, hi = hdw_info; i < MAX_BOARDS; i++, hi++)
1146 {
1147 if (hi->ndev) /* a board has been attached */
1148 {
1149 ci = (ci_t *)(netdev_priv(hi->ndev));
1150 for (j = 0; j < ci->max_port; j++)
1151 for (k = 0; k < MUSYCC_NCHANS; k++)
1152 if ((ndev = ci->port[j].chan[k]->user))
1153 {
1154 do_deluser (ndev, 0);
1155 }
1156 }
1157 }
1158 }
1159
1160
1161 STATIC void __exit
1162 c4_mod_remove (void)
1163 {
1164 cleanup_hdlc (); /* delete any missed channels */
1165 cleanup_devs ();
1166 c4_cleanup ();
1167 cleanup_ioremap ();
1168 pr_info("SBE - driver removed.\n");
1169 }
1170
1171 module_init (c4_mod_init);
1172 module_exit (c4_mod_remove);
1173
1174 MODULE_AUTHOR ("SBE Technical Services <support@sbei.com>");
1175 MODULE_DESCRIPTION ("wanPCI-CxT1E1 Generic HDLC WAN Driver module");
1176 #ifdef MODULE_LICENSE
1177 MODULE_LICENSE ("GPL");
1178 #endif
1179
1180 /*** End-of-File ***/
Tomato firmware and modifications.