?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: strip: delete the driver
[linux/fpc-iii.git] / drivers / staging / cxt1e1 / linux.c
blob134e7568024b86b97ac1b0e3088d8bd96f3e608d
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__ == 1 && __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 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
146 #define DEV_TO_PRIV(dev) ( * (struct c4_priv **) ((hdlc_device*)(dev)+1))
147 #else
148
149 char *
150 get_hdlc_name (hdlc_device * hdlc)
151 {
152 struct c4_priv *priv = hdlc->priv;
153 struct net_device *dev = getuserbychan (priv->channum);
154
155 return dev->name;
156 }
157 #endif
158
159
160 static status_t
161 mkret (int bsd)
162 {
163 if (bsd > 0)
164 return -bsd;
165 else
166 return bsd;
167 }
168
169 /***************************************************************************/
170 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,41)
171 #include <linux/workqueue.h>
172
173 /***
174 * One workqueue (wq) per port (since musycc allows simultaneous group
175 * commands), with individual data for each channel:
176 *
177 * mpi_t -> struct workqueue_struct *wq_port; (dynamically allocated using
178 * create_workqueue())
179 *
180 * With work structure (work) statically allocated for each channel:
181 *
182 * mch_t -> struct work_struct ch_work; (statically allocated using ???)
183 *
184 ***/
185
186
187 /*
188 * Called by the start transmit routine when a channel TX_ENABLE is to be
189 * issued. This queues the transmission start request among other channels
190 * within a port's group.
191 */
192 void
193 c4_wk_chan_restart (mch_t * ch)
194 {
195 mpi_t *pi = ch->up;
196
197 #ifdef RLD_RESTART_DEBUG
198 pr_info(">> %s: queueing Port %d Chan %d, mch_t @ %p\n",
199 __func__, pi->portnum, ch->channum, ch);
200 #endif
201
202 /* create new entry w/in workqueue for this channel and let'er rip */
203
204 /** queue_work (struct workqueue_struct *queue,
205 ** struct work_struct *work);
206 **/
207 queue_work (pi->wq_port, &ch->ch_work);
208 }
209
210 status_t
211 c4_wk_chan_init (mpi_t * pi, mch_t * ch)
212 {
213 /*
214 * this will be used to restart a stopped channel
215 */
216
217 /** INIT_WORK (struct work_struct *work,
218 ** void (*function)(void *),
219 ** void *data);
220 **/
221 INIT_WORK(&ch->ch_work, (void *)musycc_wq_chan_restart);
222 return 0; /* success */
223 }
224
225 status_t
226 c4_wq_port_init (mpi_t * pi)
227 {
228
229 char name[16], *np; /* NOTE: name of the queue limited by system
230 * to 10 characters */
231
232 if (pi->wq_port)
233 return 0; /* already initialized */
234
235 np = name;
236 memset (name, 0, 16);
237 sprintf (np, "%s%d", pi->up->devname, pi->portnum); /* IE pmcc4-01) */
238
239 #ifdef RLD_RESTART_DEBUG
240 pr_info(">> %s: creating workqueue <%s> for Port %d.\n",
241 __func__, name, pi->portnum); /* RLD DEBUG */
242 #endif
243 if (!(pi->wq_port = create_singlethread_workqueue (name)))
244 return ENOMEM;
245 return 0; /* success */
246 }
247
248 void
249 c4_wq_port_cleanup (mpi_t * pi)
250 {
251 /*
252 * PORT POINT: cannot call this if WQ is statically allocated w/in
253 * structure since it calls kfree(wq);
254 */
255 if (pi->wq_port)
256 {
257 destroy_workqueue (pi->wq_port); /* this also calls
258 * flush_workqueue() */
259 pi->wq_port = 0;
260 }
261 }
262 #endif
263
264 /***************************************************************************/
265
266 irqreturn_t
267 c4_linux_interrupt (int irq, void *dev_instance)
268 {
269 struct net_device *ndev = dev_instance;
270
271 return musycc_intr_th_handler(netdev_priv(ndev));
272 }
273
274
275 #ifdef CONFIG_SBE_PMCC4_NCOMM
276 irqreturn_t
277 c4_ebus_interrupt (int irq, void *dev_instance)
278 {
279 struct net_device *ndev = dev_instance;
280
281 return c4_ebus_intr_th_handler(netdev_priv(ndev));
282 }
283 #endif
284
285
286 static int
287 void_open (struct net_device * ndev)
288 {
289 pr_info("%s: trying to open master device !\n", ndev->name);
290 return -1;
291 }
292
293
294 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
295 #if !defined(GENERIC_HDLC_VERSION) || (GENERIC_HDLC_VERSION < 4)
296
297 /** Linux 2.4.18-19 **/
298 STATIC int
299 chan_open (hdlc_device * hdlc)
300 {
301 status_t ret;
302
303 if ((ret = c4_chan_up (DEV_TO_PRIV (hdlc)->ci, DEV_TO_PRIV (hdlc)->channum)))
304 return -ret;
305 MOD_INC_USE_COUNT;
306 netif_start_queue (hdlc_to_dev (hdlc));
307 return 0; /* no error = success */
308 }
309
310 #else
311
312 /** Linux 2.4.20 and higher **/
313 STATIC int
314 chan_open (struct net_device * ndev)
315 {
316 hdlc_device *hdlc = dev_to_hdlc (ndev);
317 status_t ret;
318
319 hdlc->proto = IF_PROTO_HDLC;
320 if ((ret = hdlc_open (hdlc)))
321 {
322 pr_info("hdlc_open failure, err %d.\n", ret);
323 return ret;
324 }
325 if ((ret = c4_chan_up (DEV_TO_PRIV (hdlc)->ci, DEV_TO_PRIV (hdlc)->channum)))
326 return -ret;
327 MOD_INC_USE_COUNT;
328 netif_start_queue (hdlc_to_dev (hdlc));
329 return 0; /* no error = success */
330 }
331 #endif
332
333 #else
334
335 /** Linux 2.6 **/
336 STATIC int
337 chan_open (struct net_device * ndev)
338 {
339 hdlc_device *hdlc = dev_to_hdlc (ndev);
340 const struct c4_priv *priv = hdlc->priv;
341 int ret;
342
343 if ((ret = hdlc_open (ndev)))
344 {
345 pr_info("hdlc_open failure, err %d.\n", ret);
346 return ret;
347 }
348 if ((ret = c4_chan_up (priv->ci, priv->channum)))
349 return -ret;
350 try_module_get (THIS_MODULE);
351 netif_start_queue (ndev);
352 return 0; /* no error = success */
353 }
354 #endif
355
356
357 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
358 #if !defined(GENERIC_HDLC_VERSION) || (GENERIC_HDLC_VERSION < 4)
359
360 /** Linux 2.4.18-19 **/
361 STATIC void
362 chan_close (hdlc_device * hdlc)
363 {
364 netif_stop_queue (hdlc_to_dev (hdlc));
365 musycc_chan_down ((ci_t *) 0, DEV_TO_PRIV (hdlc)->channum);
366 MOD_DEC_USE_COUNT;
367 }
368 #else
369
370 /** Linux 2.4.20 and higher **/
371 STATIC int
372 chan_close (struct net_device * ndev)
373 {
374 hdlc_device *hdlc = dev_to_hdlc (ndev);
375
376 netif_stop_queue (hdlc_to_dev (hdlc));
377 musycc_chan_down ((ci_t *) 0, DEV_TO_PRIV (hdlc)->channum);
378 hdlc_close (hdlc);
379 MOD_DEC_USE_COUNT;
380 return 0;
381 }
382 #endif
383
384 #else
385
386 /** Linux 2.6 **/
387 STATIC int
388 chan_close (struct net_device * ndev)
389 {
390 hdlc_device *hdlc = dev_to_hdlc (ndev);
391 const struct c4_priv *priv = hdlc->priv;
392
393 netif_stop_queue (ndev);
394 musycc_chan_down ((ci_t *) 0, priv->channum);
395 hdlc_close (ndev);
396 module_put (THIS_MODULE);
397 return 0;
398 }
399 #endif
400
401
402 #if !defined(GENERIC_HDLC_VERSION) || (GENERIC_HDLC_VERSION < 4)
403
404 /** Linux 2.4.18-19 **/
405 STATIC int
406 chan_ioctl (hdlc_device * hdlc, struct ifreq * ifr, int cmd)
407 {
408 if (cmd == HDLCSCLOCK)
409 {
410 ifr->ifr_ifru.ifru_ivalue = LINE_DEFAULT;
411 return 0;
412 }
413 return -EINVAL;
414 }
415 #endif
416
417
418 #if !defined(GENERIC_HDLC_VERSION) || (GENERIC_HDLC_VERSION < 4)
419 STATIC int
420 chan_dev_ioctl (struct net_device * hdlc, struct ifreq * ifr, int cmd)
421 {
422 if (cmd == HDLCSCLOCK)
423 {
424 ifr->ifr_ifru.ifru_ivalue = LINE_DEFAULT;
425 return 0;
426 }
427 return -EINVAL;
428 }
429 #else
430 STATIC int
431 chan_dev_ioctl (struct net_device * dev, struct ifreq * ifr, int cmd)
432 {
433 return hdlc_ioctl (dev, ifr, cmd);
434 }
435
436
437 STATIC int
438 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
439 chan_attach_noop (hdlc_device * hdlc, unsigned short foo_1, unsigned short foo_2)
440 #else
441 chan_attach_noop (struct net_device * ndev, unsigned short foo_1, unsigned short foo_2)
442 #endif
443 {
444 return 0; /* our driver has nothing to do here, show's
445 * over, go home */
446 }
447 #endif
448
449
450 STATIC struct net_device_stats *
451 chan_get_stats (struct net_device * ndev)
452 {
453 mch_t *ch;
454 struct net_device_stats *nstats;
455 struct sbecom_chan_stats *stats;
456 int channum;
457
458 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
459 channum = DEV_TO_PRIV (ndev)->channum;
460 #else
461 {
462 struct c4_priv *priv;
463
464 priv = (struct c4_priv *) dev_to_hdlc (ndev)->priv;
465 channum = priv->channum;
466 }
467 #endif
468
469 ch = c4_find_chan (channum);
470 if (ch == NULL)
471 return NULL;
472
473 nstats = &ndev->stats;
474 stats = &ch->s;
475
476 memset (nstats, 0, sizeof (struct net_device_stats));
477 nstats->rx_packets = stats->rx_packets;
478 nstats->tx_packets = stats->tx_packets;
479 nstats->rx_bytes = stats->rx_bytes;
480 nstats->tx_bytes = stats->tx_bytes;
481 nstats->rx_errors = stats->rx_length_errors +
482 stats->rx_over_errors +
483 stats->rx_crc_errors +
484 stats->rx_frame_errors +
485 stats->rx_fifo_errors +
486 stats->rx_missed_errors;
487 nstats->tx_errors = stats->tx_dropped +
488 stats->tx_aborted_errors +
489 stats->tx_fifo_errors;
490 nstats->rx_dropped = stats->rx_dropped;
491 nstats->tx_dropped = stats->tx_dropped;
492
493 nstats->rx_length_errors = stats->rx_length_errors;
494 nstats->rx_over_errors = stats->rx_over_errors;
495 nstats->rx_crc_errors = stats->rx_crc_errors;
496 nstats->rx_frame_errors = stats->rx_frame_errors;
497 nstats->rx_fifo_errors = stats->rx_fifo_errors;
498 nstats->rx_missed_errors = stats->rx_missed_errors;
499
500 nstats->tx_aborted_errors = stats->tx_aborted_errors;
501 nstats->tx_fifo_errors = stats->tx_fifo_errors;
502
503 return nstats;
504 }
505
506
507 static ci_t *
508 get_ci_by_dev (struct net_device * ndev)
509 {
510 return (ci_t *)(netdev_priv(ndev));
511 }
512
513
514 #if !defined(GENERIC_HDLC_VERSION) || (GENERIC_HDLC_VERSION < 4)
515 STATIC int
516 c4_linux_xmit (hdlc_device * hdlc, struct sk_buff * skb)
517 {
518 int rval;
519
520 rval = musycc_start_xmit (DEV_TO_PRIV (hdlc)->ci, DEV_TO_PRIV (hdlc)->channum, skb);
521 return -rval;
522 }
523 #else /* new */
524 STATIC int
525 c4_linux_xmit (struct sk_buff * skb, struct net_device * ndev)
526 {
527 const struct c4_priv *priv;
528 int rval;
529
530 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
531 priv = DEV_TO_PRIV (ndev);
532 #else
533 hdlc_device *hdlc = dev_to_hdlc (ndev);
534
535 priv = hdlc->priv;
536 #endif
537
538 rval = musycc_start_xmit (priv->ci, priv->channum, skb);
539 return -rval;
540 }
541 #endif /* GENERIC_HDLC_VERSION */
542
543 static const struct net_device_ops chan_ops = {
544 .ndo_open = chan_open,
545 .ndo_stop = chan_close,
546 .ndo_start_xmit = c4_linux_xmit,
547 .ndo_do_ioctl = chan_dev_ioctl,
548 .ndo_get_stats = chan_get_stats,
549 };
550
551 STATIC struct net_device *
552 create_chan (struct net_device * ndev, ci_t * ci,
553 struct sbecom_chan_param * cp)
554 {
555 hdlc_device *hdlc;
556 struct net_device *dev;
557 hdw_info_t *hi;
558 int ret;
559
560 if (c4_find_chan (cp->channum))
561 return 0; /* channel already exists */
562
563 {
564 struct c4_priv *priv;
565
566 /* allocate then fill in private data structure */
567 priv = OS_kmalloc (sizeof (struct c4_priv));
568 if (!priv)
569 {
570 pr_warning("%s: no memory for net_device !\n", ci->devname);
571 return 0;
572 }
573 dev = alloc_hdlcdev (priv);
574 if (!dev)
575 {
576 pr_warning("%s: no memory for hdlc_device !\n", ci->devname);
577 OS_kfree (priv);
578 return 0;
579 }
580 priv->ci = ci;
581 priv->channum = cp->channum;
582 }
583
584 hdlc = dev_to_hdlc (dev);
585
586 dev->base_addr = 0; /* not I/O mapped */
587 dev->irq = ndev->irq;
588 dev->type = ARPHRD_RAWHDLC;
589 *dev->name = 0; /* default ifconfig name = "hdlc" */
590
591 hi = (hdw_info_t *) ci->hdw_info;
592 if (hi->mfg_info_sts == EEPROM_OK)
593 {
594 switch (hi->promfmt)
595 {
596 case PROM_FORMAT_TYPE1:
597 memcpy (dev->dev_addr, (FLD_TYPE1 *) (hi->mfg_info.pft1.Serial), 6);
598 break;
599 case PROM_FORMAT_TYPE2:
600 memcpy (dev->dev_addr, (FLD_TYPE2 *) (hi->mfg_info.pft2.Serial), 6);
601 break;
602 default:
603 memset (dev->dev_addr, 0, 6);
604 break;
605 }
606 } else
607 {
608 memset (dev->dev_addr, 0, 6);
609 }
610
611 hdlc->xmit = c4_linux_xmit;
612
613 dev->netdev_ops = &chan_ops;
614 /*
615 * The native hdlc stack calls this 'attach' routine during
616 * hdlc_raw_ioctl(), passing parameters for line encoding and parity.
617 * Since hdlc_raw_ioctl() stack does not interrogate whether an 'attach'
618 * routine is actually registered or not, we supply a dummy routine which
619 * does nothing (since encoding and parity are setup for our driver via a
620 * special configuration application).
621 */
622
623 hdlc->attach = chan_attach_noop;
624
625 rtnl_unlock (); /* needed due to Ioctl calling sequence */
626 ret = register_hdlc_device (dev);
627 /* NOTE: <stats> setting must occur AFTER registration in order to "take" */
628 dev->tx_queue_len = MAX_DEFAULT_IFQLEN;
629
630 rtnl_lock (); /* needed due to Ioctl calling sequence */
631 if (ret)
632 {
633 if (log_level >= LOG_WARN)
634 pr_info("%s: create_chan[%d] registration error = %d.\n",
635 ci->devname, cp->channum, ret);
636 free_netdev (dev); /* cleanup */
637 return 0; /* failed to register */
638 }
639 return dev;
640 }
641
642
643 /* the idea here is to get port information and pass it back (using pointer) */
644 STATIC status_t
645 do_get_port (struct net_device * ndev, void *data)
646 {
647 int ret;
648 ci_t *ci; /* ci stands for card information */
649 struct sbecom_port_param pp;/* copy data to kernel land */
650
651 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
652 return -EFAULT;
653 if (pp.portnum >= MUSYCC_NPORTS)
654 return -EFAULT;
655 ci = get_ci_by_dev (ndev);
656 if (!ci)
657 return -EINVAL; /* get card info */
658
659 ret = mkret (c4_get_port (ci, pp.portnum));
660 if (ret)
661 return ret;
662 if (copy_to_user (data, &ci->port[pp.portnum].p,
663 sizeof (struct sbecom_port_param)))
664 return -EFAULT;
665 return 0;
666 }
667
668 /* this function copys the user data and then calls the real action function */
669 STATIC status_t
670 do_set_port (struct net_device * ndev, void *data)
671 {
672 ci_t *ci; /* ci stands for card information */
673 struct sbecom_port_param pp;/* copy data to kernel land */
674
675 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
676 return -EFAULT;
677 if (pp.portnum >= MUSYCC_NPORTS)
678 return -EFAULT;
679 ci = get_ci_by_dev (ndev);
680 if (!ci)
681 return -EINVAL; /* get card info */
682
683 if (pp.portnum >= ci->max_port) /* sanity check */
684 return ENXIO;
685
686 memcpy (&ci->port[pp.portnum].p, &pp, sizeof (struct sbecom_port_param));
687 return mkret (c4_set_port (ci, pp.portnum));
688 }
689
690 /* work the port loopback mode as per directed */
691 STATIC status_t
692 do_port_loop (struct net_device * ndev, void *data)
693 {
694 struct sbecom_port_param pp;
695 ci_t *ci;
696
697 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
698 return -EFAULT;
699 ci = get_ci_by_dev (ndev);
700 if (!ci)
701 return -EINVAL;
702 return mkret (c4_loop_port (ci, pp.portnum, pp.port_mode));
703 }
704
705 /* set the specified register with the given value / or just read it */
706 STATIC status_t
707 do_framer_rw (struct net_device * ndev, void *data)
708 {
709 struct sbecom_port_param pp;
710 ci_t *ci;
711 int ret;
712
713 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
714 return -EFAULT;
715 ci = get_ci_by_dev (ndev);
716 if (!ci)
717 return -EINVAL;
718 ret = mkret (c4_frame_rw (ci, &pp));
719 if (ret)
720 return ret;
721 if (copy_to_user (data, &pp, sizeof (struct sbecom_port_param)))
722 return -EFAULT;
723 return 0;
724 }
725
726 /* set the specified register with the given value / or just read it */
727 STATIC status_t
728 do_pld_rw (struct net_device * ndev, void *data)
729 {
730 struct sbecom_port_param pp;
731 ci_t *ci;
732 int ret;
733
734 if (copy_from_user (&pp, data, sizeof (struct sbecom_port_param)))
735 return -EFAULT;
736 ci = get_ci_by_dev (ndev);
737 if (!ci)
738 return -EINVAL;
739 ret = mkret (c4_pld_rw (ci, &pp));
740 if (ret)
741 return ret;
742 if (copy_to_user (data, &pp, sizeof (struct sbecom_port_param)))
743 return -EFAULT;
744 return 0;
745 }
746
747 /* set the specified register with the given value / or just read it */
748 STATIC status_t
749 do_musycc_rw (struct net_device * ndev, void *data)
750 {
751 struct c4_musycc_param mp;
752 ci_t *ci;
753 int ret;
754
755 if (copy_from_user (&mp, data, sizeof (struct c4_musycc_param)))
756 return -EFAULT;
757 ci = get_ci_by_dev (ndev);
758 if (!ci)
759 return -EINVAL;
760 ret = mkret (c4_musycc_rw (ci, &mp));
761 if (ret)
762 return ret;
763 if (copy_to_user (data, &mp, sizeof (struct c4_musycc_param)))
764 return -EFAULT;
765 return 0;
766 }
767
768 STATIC status_t
769 do_get_chan (struct net_device * ndev, void *data)
770 {
771 struct sbecom_chan_param cp;
772 int ret;
773
774 if (copy_from_user (&cp, data,
775 sizeof (struct sbecom_chan_param)))
776 return -EFAULT;
777
778 if ((ret = mkret (c4_get_chan (cp.channum, &cp))))
779 return ret;
780
781 if (copy_to_user (data, &cp, sizeof (struct sbecom_chan_param)))
782 return -EFAULT;
783 return 0;
784 }
785
786 STATIC status_t
787 do_set_chan (struct net_device * ndev, void *data)
788 {
789 struct sbecom_chan_param cp;
790 int ret;
791 ci_t *ci;
792
793 if (copy_from_user (&cp, data, sizeof (struct sbecom_chan_param)))
794 return -EFAULT;
795 ci = get_ci_by_dev (ndev);
796 if (!ci)
797 return -EINVAL;
798 switch (ret = mkret (c4_set_chan (cp.channum, &cp)))
799 {
800 case 0:
801 return 0;
802 default:
803 return ret;
804 }
805 }
806
807 STATIC status_t
808 do_create_chan (struct net_device * ndev, void *data)
809 {
810 ci_t *ci;
811 struct net_device *dev;
812 struct sbecom_chan_param cp;
813 int ret;
814
815 if (copy_from_user (&cp, data, sizeof (struct sbecom_chan_param)))
816 return -EFAULT;
817 ci = get_ci_by_dev (ndev);
818 if (!ci)
819 return -EINVAL;
820 dev = create_chan (ndev, ci, &cp);
821 if (!dev)
822 return -EBUSY;
823 ret = mkret (c4_new_chan (ci, cp.port, cp.channum, dev));
824 if (ret)
825 {
826 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
827 rtnl_unlock (); /* needed due to Ioctl calling sequence */
828 V7 (unregister_hdlc_device) (dev_to_hdlc (dev));
829 rtnl_lock (); /* needed due to Ioctl calling sequence */
830 OS_kfree (DEV_TO_PRIV (dev));
831 OS_kfree (dev);
832 #else
833 rtnl_unlock (); /* needed due to Ioctl calling sequence */
834 unregister_hdlc_device (dev);
835 rtnl_lock (); /* needed due to Ioctl calling sequence */
836 free_netdev (dev);
837 #endif
838 }
839 return ret;
840 }
841
842 STATIC status_t
843 do_get_chan_stats (struct net_device * ndev, void *data)
844 {
845 struct c4_chan_stats_wrap ccs;
846 int ret;
847
848 if (copy_from_user (&ccs, data,
849 sizeof (struct c4_chan_stats_wrap)))
850 return -EFAULT;
851 switch (ret = mkret (c4_get_chan_stats (ccs.channum, &ccs.stats)))
852 {
853 case 0:
854 break;
855 default:
856 return ret;
857 }
858 if (copy_to_user (data, &ccs,
859 sizeof (struct c4_chan_stats_wrap)))
860 return -EFAULT;
861 return 0;
862 }
863 STATIC status_t
864 do_set_loglevel (struct net_device * ndev, void *data)
865 {
866 unsigned int log_level;
867
868 if (copy_from_user (&log_level, data, sizeof (int)))
869 return -EFAULT;
870 sbecom_set_loglevel (log_level);
871 return 0;
872 }
873
874 STATIC status_t
875 do_deluser (struct net_device * ndev, int lockit)
876 {
877 if (ndev->flags & IFF_UP)
878 return -EBUSY;
879
880 {
881 ci_t *ci;
882 mch_t *ch;
883 const struct c4_priv *priv;
884 int channum;
885
886 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
887 priv = DEV_TO_PRIV (ndev);
888 #else
889 priv = (struct c4_priv *) dev_to_hdlc (ndev)->priv;
890 #endif
891 ci = priv->ci;
892 channum = priv->channum;
893
894 ch = c4_find_chan (channum);
895 if (ch == NULL)
896 return -ENOENT;
897 ch->user = 0; /* will be freed, below */
898 }
899
900 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
901 if (lockit)
902 rtnl_unlock (); /* needed if Ioctl calling sequence */
903 V7 (unregister_hdlc_device) (dev_to_hdlc (ndev));
904 if (lockit)
905 rtnl_lock (); /* needed if Ioctl calling sequence */
906 OS_kfree (DEV_TO_PRIV (ndev));
907 OS_kfree (ndev);
908 #else
909 if (lockit)
910 rtnl_unlock (); /* needed if Ioctl calling sequence */
911 unregister_hdlc_device (ndev);
912 if (lockit)
913 rtnl_lock (); /* needed if Ioctl calling sequence */
914 free_netdev (ndev);
915 #endif
916 return 0;
917 }
918
919 int
920 do_del_chan (struct net_device * musycc_dev, void *data)
921 {
922 struct sbecom_chan_param cp;
923 char buf[sizeof (CHANNAME) + 3];
924 struct net_device *dev;
925 int ret;
926
927 if (copy_from_user (&cp, data,
928 sizeof (struct sbecom_chan_param)))
929 return -EFAULT;
930 sprintf (buf, CHANNAME "%d", cp.channum);
931 if (!(dev = dev_get_by_name (&init_net, buf)))
932 return -ENOENT;
933 dev_put (dev);
934 ret = do_deluser (dev, 1);
935 if (ret)
936 return ret;
937 return c4_del_chan (cp.channum);
938 }
939 int c4_reset_board (void *);
940
941 int
942 do_reset (struct net_device * musycc_dev, void *data)
943 {
944 const struct c4_priv *priv;
945 int i;
946
947 for (i = 0; i < 128; i++)
948 {
949 struct net_device *ndev;
950 char buf[sizeof (CHANNAME) + 3];
951
952 sprintf (buf, CHANNAME "%d", i);
953 if (!(ndev = dev_get_by_name(&init_net, buf)))
954 continue;
955 priv = dev_to_hdlc (ndev)->priv;
956
957 if ((unsigned long) (priv->ci) ==
958 (unsigned long) (netdev_priv(musycc_dev)))
959 {
960 ndev->flags &= ~IFF_UP;
961 dev_put (ndev);
962 netif_stop_queue (ndev);
963 do_deluser (ndev, 1);
964 } else
965 dev_put (ndev);
966 }
967 return 0;
968 }
969
970 int
971 do_reset_chan_stats (struct net_device * musycc_dev, void *data)
972 {
973 struct sbecom_chan_param cp;
974
975 if (copy_from_user (&cp, data,
976 sizeof (struct sbecom_chan_param)))
977 return -EFAULT;
978 return mkret (c4_del_chan_stats (cp.channum));
979 }
980
981 STATIC status_t
982 c4_ioctl (struct net_device * ndev, struct ifreq * ifr, int cmd)
983 {
984 ci_t *ci;
985 void *data;
986 int iocmd, iolen;
987 status_t ret;
988 static struct data
989 {
990 union
991 {
992 u_int8_t c;
993 u_int32_t i;
994 struct sbe_brd_info bip;
995 struct sbe_drv_info dip;
996 struct sbe_iid_info iip;
997 struct sbe_brd_addr bap;
998 struct sbecom_chan_stats stats;
999 struct sbecom_chan_param param;
1000 struct temux_card_stats cards;
1001 struct sbecom_card_param cardp;
1002 struct sbecom_framer_param frp;
1003 } u;
1004 } arg;
1005
1006
1007 if (!capable (CAP_SYS_ADMIN))
1008 return -EPERM;
1009 if (cmd != SIOCDEVPRIVATE + 15)
1010 return -EINVAL;
1011 if (!(ci = get_ci_by_dev (ndev)))
1012 return -EINVAL;
1013 if (ci->state != C_RUNNING)
1014 return -ENODEV;
1015 if (copy_from_user (&iocmd, ifr->ifr_data, sizeof (iocmd)))
1016 return -EFAULT;
1017 #if 0
1018 if (copy_from_user (&len, ifr->ifr_data + sizeof (iocmd), sizeof (len)))
1019 return -EFAULT;
1020 #endif
1021
1022 #if 0
1023 pr_info("c4_ioctl: iocmd %x, dir %x type %x nr %x iolen %d.\n", iocmd,
1024 _IOC_DIR (iocmd), _IOC_TYPE (iocmd), _IOC_NR (iocmd),
1025 _IOC_SIZE (iocmd));
1026 #endif
1027 iolen = _IOC_SIZE (iocmd);
1028 data = ifr->ifr_data + sizeof (iocmd);
1029 if (copy_from_user (&arg, data, iolen))
1030 return -EFAULT;
1031
1032 ret = 0;
1033 switch (iocmd)
1034 {
1035 case SBE_IOC_PORT_GET:
1036 //pr_info(">> SBE_IOC_PORT_GET Ioctl...\n");
1037 ret = do_get_port (ndev, data);
1038 break;
1039 case SBE_IOC_PORT_SET:
1040 //pr_info(">> SBE_IOC_PORT_SET Ioctl...\n");
1041 ret = do_set_port (ndev, data);
1042 break;
1043 case SBE_IOC_CHAN_GET:
1044 //pr_info(">> SBE_IOC_CHAN_GET Ioctl...\n");
1045 ret = do_get_chan (ndev, data);
1046 break;
1047 case SBE_IOC_CHAN_SET:
1048 //pr_info(">> SBE_IOC_CHAN_SET Ioctl...\n");
1049 ret = do_set_chan (ndev, data);
1050 break;
1051 case C4_DEL_CHAN:
1052 //pr_info(">> C4_DEL_CHAN Ioctl...\n");
1053 ret = do_del_chan (ndev, data);
1054 break;
1055 case SBE_IOC_CHAN_NEW:
1056 ret = do_create_chan (ndev, data);
1057 break;
1058 case SBE_IOC_CHAN_GET_STAT:
1059 ret = do_get_chan_stats (ndev, data);
1060 break;
1061 case SBE_IOC_LOGLEVEL:
1062 ret = do_set_loglevel (ndev, data);
1063 break;
1064 case SBE_IOC_RESET_DEV:
1065 ret = do_reset (ndev, data);
1066 break;
1067 case SBE_IOC_CHAN_DEL_STAT:
1068 ret = do_reset_chan_stats (ndev, data);
1069 break;
1070 case C4_LOOP_PORT:
1071 ret = do_port_loop (ndev, data);
1072 break;
1073 case C4_RW_FRMR:
1074 ret = do_framer_rw (ndev, data);
1075 break;
1076 case C4_RW_MSYC:
1077 ret = do_musycc_rw (ndev, data);
1078 break;
1079 case C4_RW_PLD:
1080 ret = do_pld_rw (ndev, data);
1081 break;
1082 case SBE_IOC_IID_GET:
1083 ret = (iolen == sizeof (struct sbe_iid_info)) ? c4_get_iidinfo (ci, &arg.u.iip) : -EFAULT;
1084 if (ret == 0) /* no error, copy data */
1085 if (copy_to_user (data, &arg, iolen))
1086 return -EFAULT;
1087 break;
1088 default:
1089 //pr_info(">> c4_ioctl: EINVAL - unknown iocmd <%x>\n", iocmd);
1090 ret = -EINVAL;
1091 break;
1092 }
1093 return mkret (ret);
1094 }
1095
1096 static const struct net_device_ops c4_ops = {
1097 .ndo_open = void_open,
1098 .ndo_start_xmit = c4_linux_xmit,
1099 .ndo_do_ioctl = c4_ioctl,
1100 };
1101
1102 static void c4_setup(struct net_device *dev)
1103 {
1104 dev->type = ARPHRD_VOID;
1105 dev->netdev_ops = &c4_ops;
1106 }
1107
1108 struct net_device *__init
1109 c4_add_dev (hdw_info_t * hi, int brdno, unsigned long f0, unsigned long f1,
1110 int irq0, int irq1)
1111 {
1112 struct net_device *ndev;
1113 ci_t *ci;
1114
1115 ndev = alloc_netdev(sizeof(ci_t), SBE_IFACETMPL, c4_setup);
1116 if (!ndev)
1117 {
1118 pr_warning("%s: no memory for struct net_device !\n", hi->devname);
1119 error_flag = ENOMEM;
1120 return 0;
1121 }
1122 ci = (ci_t *)(netdev_priv(ndev));
1123 ndev->irq = irq0;
1124
1125 ci->hdw_info = hi;
1126 ci->state = C_INIT; /* mark as hardware not available */
1127 ci->next = c4_list;
1128 c4_list = ci;
1129 ci->brdno = ci->next ? ci->next->brdno + 1 : 0;
1130
1131 if (CI == 0)
1132 CI = ci; /* DEBUG, only board 0 usage */
1133
1134 strcpy (ci->devname, hi->devname);
1135 ci->release = &pmcc4_OSSI_release[0];
1136
1137 /* tasklet */
1138 #if defined(SBE_ISR_TASKLET)
1139 tasklet_init (&ci->ci_musycc_isr_tasklet,
1140 (void (*) (unsigned long)) musycc_intr_bh_tasklet,
1141 (unsigned long) ci);
1142
1143 if (atomic_read (&ci->ci_musycc_isr_tasklet.count) == 0)
1144 tasklet_disable_nosync (&ci->ci_musycc_isr_tasklet);
1145 #elif defined(SBE_ISR_IMMEDIATE)
1146 ci->ci_musycc_isr_tq.routine = (void *) (unsigned long) musycc_intr_bh_tasklet;
1147 ci->ci_musycc_isr_tq.data = ci;
1148 #endif
1149
1150
1151 if (register_netdev (ndev) ||
1152 (c4_init (ci, (u_char *) f0, (u_char *) f1) != SBE_DRVR_SUCCESS))
1153 {
1154 OS_kfree (netdev_priv(ndev));
1155 OS_kfree (ndev);
1156 error_flag = ENODEV;
1157 return 0;
1158 }
1159 /*************************************************************
1160 * int request_irq(unsigned int irq,
1161 * void (*handler)(int, void *, struct pt_regs *),
1162 * unsigned long flags, const char *dev_name, void *dev_id);
1163 * wherein:
1164 * irq -> The interrupt number that is being requested.
1165 * handler -> Pointer to handling function being installed.
1166 * flags -> A bit mask of options related to interrupt management.
1167 * dev_name -> String used in /proc/interrupts to show owner of interrupt.
1168 * dev_id -> Pointer (for shared interrupt lines) to point to its own
1169 * private data area (to identify which device is interrupting).
1170 *
1171 * extern void free_irq(unsigned int irq, void *dev_id);
1172 **************************************************************/
1173
1174 if (request_irq (irq0, &c4_linux_interrupt,
1175 #if defined(SBE_ISR_TASKLET)
1176 IRQF_DISABLED | IRQF_SHARED,
1177 #elif defined(SBE_ISR_IMMEDIATE)
1178 IRQF_DISABLED | IRQF_SHARED,
1179 #elif defined(SBE_ISR_INLINE)
1180 IRQF_SHARED,
1181 #endif
1182 ndev->name, ndev))
1183 {
1184 pr_warning("%s: MUSYCC could not get irq: %d\n", ndev->name, irq0);
1185 unregister_netdev (ndev);
1186 OS_kfree (netdev_priv(ndev));
1187 OS_kfree (ndev);
1188 error_flag = EIO;
1189 return 0;
1190 }
1191 #ifdef CONFIG_SBE_PMCC4_NCOMM
1192 if (request_irq (irq1, &c4_ebus_interrupt, IRQF_SHARED, ndev->name, ndev))
1193 {
1194 pr_warning("%s: EBUS could not get irq: %d\n", hi->devname, irq1);
1195 unregister_netdev (ndev);
1196 free_irq (irq0, ndev);
1197 OS_kfree (netdev_priv(ndev));
1198 OS_kfree (ndev);
1199 error_flag = EIO;
1200 return 0;
1201 }
1202 #endif
1203
1204 /* setup board identification information */
1205
1206 {
1207 u_int32_t tmp;
1208
1209 hdw_sn_get (hi, brdno); /* also sets PROM format type (promfmt)
1210 * for later usage */
1211
1212 switch (hi->promfmt)
1213 {
1214 case PROM_FORMAT_TYPE1:
1215 memcpy (ndev->dev_addr, (FLD_TYPE1 *) (hi->mfg_info.pft1.Serial), 6);
1216 memcpy (&tmp, (FLD_TYPE1 *) (hi->mfg_info.pft1.Id), 4); /* unaligned data
1217 * acquisition */
1218 ci->brd_id = cpu_to_be32 (tmp);
1219 break;
1220 case PROM_FORMAT_TYPE2:
1221 memcpy (ndev->dev_addr, (FLD_TYPE2 *) (hi->mfg_info.pft2.Serial), 6);
1222 memcpy (&tmp, (FLD_TYPE2 *) (hi->mfg_info.pft2.Id), 4); /* unaligned data
1223 * acquisition */
1224 ci->brd_id = cpu_to_be32 (tmp);
1225 break;
1226 default:
1227 ci->brd_id = 0;
1228 memset (ndev->dev_addr, 0, 6);
1229 break;
1230 }
1231
1232 #if 1
1233 sbeid_set_hdwbid (ci); /* requires bid to be preset */
1234 #else
1235 sbeid_set_bdtype (ci); /* requires hdw_bid to be preset */
1236 #endif
1237
1238 }
1239
1240 #ifdef CONFIG_PROC_FS
1241 sbecom_proc_brd_init (ci);
1242 #endif
1243 #if defined(SBE_ISR_TASKLET)
1244 tasklet_enable (&ci->ci_musycc_isr_tasklet);
1245 #endif
1246
1247
1248 if ((error_flag = c4_init2 (ci)) != SBE_DRVR_SUCCESS)
1249 {
1250 #ifdef CONFIG_PROC_FS
1251 sbecom_proc_brd_cleanup (ci);
1252 #endif
1253 unregister_netdev (ndev);
1254 free_irq (irq1, ndev);
1255 free_irq (irq0, ndev);
1256 OS_kfree (netdev_priv(ndev));
1257 OS_kfree (ndev);
1258 return 0; /* failure, error_flag is set */
1259 }
1260 return ndev;
1261 }
1262
1263 STATIC int __init
1264 c4_mod_init (void)
1265 {
1266 int rtn;
1267
1268 pr_warning("%s\n", pmcc4_OSSI_release);
1269 if ((rtn = c4hw_attach_all ()))
1270 return -rtn; /* installation failure - see system log */
1271
1272 /* housekeeping notifications */
1273 if (log_level != log_level_default)
1274 pr_info("NOTE: driver parameter <log_level> changed from default %d to %d.\n",
1275 log_level_default, log_level);
1276 if (max_mru != max_mru_default)
1277 pr_info("NOTE: driver parameter <max_mru> changed from default %d to %d.\n",
1278 max_mru_default, max_mru);
1279 if (max_mtu != max_mtu_default)
1280 pr_info("NOTE: driver parameter <max_mtu> changed from default %d to %d.\n",
1281 max_mtu_default, max_mtu);
1282 if (max_rxdesc_used != max_rxdesc_default)
1283 {
1284 if (max_rxdesc_used > 2000)
1285 max_rxdesc_used = 2000; /* out-of-bounds reset */
1286 pr_info("NOTE: driver parameter <max_rxdesc_used> changed from default %d to %d.\n",
1287 max_rxdesc_default, max_rxdesc_used);
1288 }
1289 if (max_txdesc_used != max_txdesc_default)
1290 {
1291 if (max_txdesc_used > 1000)
1292 max_txdesc_used = 1000; /* out-of-bounds reset */
1293 pr_info("NOTE: driver parameter <max_txdesc_used> changed from default %d to %d.\n",
1294 max_txdesc_default, max_txdesc_used);
1295 }
1296 return 0; /* installation success */
1297 }
1298
1299
1300 /*
1301 * find any still allocated hdlc registrations and unregister via call to
1302 * do_deluser()
1303 */
1304
1305 STATIC void __exit
1306 cleanup_hdlc (void)
1307 {
1308 hdw_info_t *hi;
1309 ci_t *ci;
1310 struct net_device *ndev;
1311 int i, j, k;
1312
1313 for (i = 0, hi = hdw_info; i < MAX_BOARDS; i++, hi++)
1314 {
1315 if (hi->ndev) /* a board has been attached */
1316 {
1317 ci = (ci_t *)(netdev_priv(hi->ndev));
1318 for (j = 0; j < ci->max_port; j++)
1319 for (k = 0; k < MUSYCC_NCHANS; k++)
1320 if ((ndev = ci->port[j].chan[k]->user))
1321 {
1322 do_deluser (ndev, 0);
1323 }
1324 }
1325 }
1326 }
1327
1328
1329 STATIC void __exit
1330 c4_mod_remove (void)
1331 {
1332 cleanup_hdlc (); /* delete any missed channels */
1333 cleanup_devs ();
1334 c4_cleanup ();
1335 cleanup_ioremap ();
1336 pr_info("SBE - driver removed.\n");
1337 }
1338
1339 module_init (c4_mod_init);
1340 module_exit (c4_mod_remove);
1341
1342 #ifndef SBE_INCLUDE_SYMBOLS
1343 #ifndef CONFIG_SBE_WANC24_NCOMM
1344 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1345 EXPORT_NO_SYMBOLS;
1346 #endif
1347 #endif
1348 #endif
1349
1350 MODULE_AUTHOR ("SBE Technical Services <support@sbei.com>");
1351 MODULE_DESCRIPTION ("wanPCI-CxT1E1 Generic HDLC WAN Driver module");
1352 #ifdef MODULE_LICENSE
1353 MODULE_LICENSE ("GPL");
1354 #endif
1355
1356 /*** End-of-File ***/
Linux with added FPC-III support