drivers/atm/adummy.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * adummy.c: a dummy ATM driver
0004  */
0005
0006 #include <linux/module.h>
0007 #include <linux/kernel.h>
0008 #include <linux/skbuff.h>
0009 #include <linux/errno.h>
0010 #include <linux/types.h>
0011 #include <linux/string.h>
0012 #include <linux/delay.h>
0013 #include <linux/init.h>
0014 #include <linux/mm.h>
0015 #include <linux/timer.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/slab.h>
0018 #include <asm/io.h>
0019 #include <asm/byteorder.h>
0020 #include <linux/uaccess.h>
0021
0022 #include <linux/atmdev.h>
0023 #include <linux/atm.h>
0024 #include <linux/sonet.h>
0025
0026 /* version definition */
0027
0028 #define DRV_VERSION "1.0"
0029
0030 #define DEV_LABEL "adummy"
0031
0032 #define ADUMMY_DEV(dev) ((struct adummy_dev *) (dev)->dev_data)
0033
0034 struct adummy_dev {
0035     struct atm_dev *atm_dev;
0036
0037     struct list_head entry;
0038 };
0039
0040 /* globals */
0041
0042 static LIST_HEAD(adummy_devs);
0043
0044 static ssize_t __set_signal(struct device *dev,
0045         struct device_attribute *attr,
0046         const char *buf, size_t len)
0047 {
0048     struct atm_dev *atm_dev = container_of(dev, struct atm_dev, class_dev);
0049     int signal;
0050
0051     if (sscanf(buf, "%d", &signal) == 1) {
0052
0053         if (signal < ATM_PHY_SIG_LOST || signal > ATM_PHY_SIG_FOUND)
0054             signal = ATM_PHY_SIG_UNKNOWN;
0055
0056         atm_dev_signal_change(atm_dev, signal);
0057         return 1;
0058     }
0059     return -EINVAL;
0060 }
0061
0062 static ssize_t __show_signal(struct device *dev,
0063     struct device_attribute *attr, char *buf)
0064 {
0065     struct atm_dev *atm_dev = container_of(dev, struct atm_dev, class_dev);
0066     return sprintf(buf, "%d\n", atm_dev->signal);
0067 }
0068 static DEVICE_ATTR(signal, 0644, __show_signal, __set_signal);
0069
0070 static struct attribute *adummy_attrs[] = {
0071     &dev_attr_signal.attr,
0072     NULL
0073 };
0074
0075 static const struct attribute_group adummy_group_attrs = {
0076     .name = NULL, /* We want them in dev's root folder */
0077     .attrs = adummy_attrs
0078 };
0079
0080 static int __init
0081 adummy_start(struct atm_dev *dev)
0082 {
0083     dev->ci_range.vpi_bits = 4;
0084     dev->ci_range.vci_bits = 12;
0085
0086     return 0;
0087 }
0088
0089 static int
0090 adummy_open(struct atm_vcc *vcc)
0091 {
0092     short vpi = vcc->vpi;
0093     int vci = vcc->vci;
0094
0095     if (vci == ATM_VCI_UNSPEC || vpi == ATM_VPI_UNSPEC)
0096         return 0;
0097
0098     set_bit(ATM_VF_ADDR, &vcc->flags);
0099     set_bit(ATM_VF_READY, &vcc->flags);
0100
0101     return 0;
0102 }
0103
0104 static void
0105 adummy_close(struct atm_vcc *vcc)
0106 {
0107     clear_bit(ATM_VF_READY, &vcc->flags);
0108     clear_bit(ATM_VF_ADDR, &vcc->flags);
0109 }
0110
0111 static int
0112 adummy_send(struct atm_vcc *vcc, struct sk_buff *skb)
0113 {
0114     if (vcc->pop)
0115         vcc->pop(vcc, skb);
0116     else
0117         dev_kfree_skb_any(skb);
0118     atomic_inc(&vcc->stats->tx);
0119
0120     return 0;
0121 }
0122
0123 static int
0124 adummy_proc_read(struct atm_dev *dev, loff_t *pos, char *page)
0125 {
0126     int left = *pos;
0127
0128     if (!left--)
0129         return sprintf(page, "version %s\n", DRV_VERSION);
0130
0131     return 0;
0132 }
0133
0134 static const struct atmdev_ops adummy_ops =
0135 {
0136     .open =     adummy_open,
0137     .close =    adummy_close,
0138     .send =     adummy_send,
0139     .proc_read =    adummy_proc_read,
0140     .owner =    THIS_MODULE
0141 };
0142
0143 static int __init adummy_init(void)
0144 {
0145     struct atm_dev *atm_dev;
0146     struct adummy_dev *adummy_dev;
0147     int err = 0;
0148
0149     printk(KERN_ERR "adummy: version %s\n", DRV_VERSION);
0150
0151     adummy_dev = kzalloc(sizeof(struct adummy_dev),
0152                            GFP_KERNEL);
0153     if (!adummy_dev) {
0154         printk(KERN_ERR DEV_LABEL ": kzalloc() failed\n");
0155         err = -ENOMEM;
0156         goto out;
0157     }
0158     atm_dev = atm_dev_register(DEV_LABEL, NULL, &adummy_ops, -1, NULL);
0159     if (!atm_dev) {
0160         printk(KERN_ERR DEV_LABEL ": atm_dev_register() failed\n");
0161         err = -ENODEV;
0162         goto out_kfree;
0163     }
0164
0165     adummy_dev->atm_dev = atm_dev;
0166     atm_dev->dev_data = adummy_dev;
0167
0168     if (sysfs_create_group(&atm_dev->class_dev.kobj, &adummy_group_attrs))
0169         dev_err(&atm_dev->class_dev, "Could not register attrs for adummy\n");
0170
0171     if (adummy_start(atm_dev)) {
0172         printk(KERN_ERR DEV_LABEL ": adummy_start() failed\n");
0173         err = -ENODEV;
0174         goto out_unregister;
0175     }
0176
0177     list_add(&adummy_dev->entry, &adummy_devs);
0178 out:
0179     return err;
0180
0181 out_unregister:
0182     atm_dev_deregister(atm_dev);
0183 out_kfree:
0184     kfree(adummy_dev);
0185     goto out;
0186 }
0187
0188 static void __exit adummy_cleanup(void)
0189 {
0190     struct adummy_dev *adummy_dev, *next;
0191
0192     list_for_each_entry_safe(adummy_dev, next, &adummy_devs, entry) {
0193         atm_dev_deregister(adummy_dev->atm_dev);
0194         kfree(adummy_dev);
0195     }
0196 }
0197
0198 module_init(adummy_init);
0199 module_exit(adummy_cleanup);
0200
0201 MODULE_AUTHOR("chas williams <chas@cmf.nrl.navy.mil>");
0202 MODULE_DESCRIPTION("dummy ATM driver");
0203 MODULE_LICENSE("GPL");