Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux

net: remove sb1000 cable modem driver

This one is hilariously outdated, it provided a faster downlink over
TV cable for users of analog modems in the 1990s, through an ISA card.

The web page for the userspace tools has been broken for 25 years, and
the driver has only ever seen mechanical updates.

Link: http://web.archive.org/web/20000611165545/http://home.adelphia.net:80/~siglercm/sb1000.html
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Reviewed-by: Simon Horman <horms@kernel.org>
Link: https://patch.msgid.link/20250312085236.2531870-1-arnd@kernel.org
Signed-off-by: Paolo Abeni <pabeni@redhat.com>

authored by

Arnd Bergmann and committed by
Paolo Abeni
3fed9fda 6f13bec5

-1471
-18
Documentation/networking/device_drivers/cable/index.rst
··· 1 - .. SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 - 3 - Cable Modem Device Drivers 4 - ========================== 5 - 6 - Contents: 7 - 8 - .. toctree:: 9 - :maxdepth: 2 10 - 11 - sb1000 12 - 13 - .. only:: subproject and html 14 - 15 - Indices 16 - ======= 17 - 18 - * :ref:`genindex`
-222
Documentation/networking/device_drivers/cable/sb1000.rst
··· 1 - .. SPDX-License-Identifier: GPL-2.0 2 - 3 - =================== 4 - SB100 device driver 5 - =================== 6 - 7 - sb1000 is a module network device driver for the General Instrument (also known 8 - as NextLevel) SURFboard1000 internal cable modem board. This is an ISA card 9 - which is used by a number of cable TV companies to provide cable modem access. 10 - It's a one-way downstream-only cable modem, meaning that your upstream net link 11 - is provided by your regular phone modem. 12 - 13 - This driver was written by Franco Venturi <fventuri@mediaone.net>. He deserves 14 - a great deal of thanks for this wonderful piece of code! 15 - 16 - Needed tools 17 - ============ 18 - 19 - Support for this device is now a part of the standard Linux kernel. The 20 - driver source code file is drivers/net/sb1000.c. In addition to this 21 - you will need: 22 - 23 - 1. The "cmconfig" program. This is a utility which supplements "ifconfig" 24 - to configure the cable modem and network interface (usually called "cm0"); 25 - 26 - 2. Several PPP scripts which live in /etc/ppp to make connecting via your 27 - cable modem easy. 28 - 29 - These utilities can be obtained from: 30 - 31 - http://www.jacksonville.net/~fventuri/ 32 - 33 - in Franco's original source code distribution .tar.gz file. Support for 34 - the sb1000 driver can be found at: 35 - 36 - - http://web.archive.org/web/%2E/http://home.adelphia.net/~siglercm/sb1000.html 37 - - http://web.archive.org/web/%2E/http://linuxpower.cx/~cable/ 38 - 39 - along with these utilities. 40 - 41 - 3. The standard isapnp tools. These are necessary to configure your SB1000 42 - card at boot time (or afterwards by hand) since it's a PnP card. 43 - 44 - If you don't have these installed as a standard part of your Linux 45 - distribution, you can find them at: 46 - 47 - http://www.roestock.demon.co.uk/isapnptools/ 48 - 49 - or check your Linux distribution binary CD or their web site. For help with 50 - isapnp, pnpdump, or /etc/isapnp.conf, go to: 51 - 52 - http://www.roestock.demon.co.uk/isapnptools/isapnpfaq.html 53 - 54 - Using the driver 55 - ================ 56 - 57 - To make the SB1000 card work, follow these steps: 58 - 59 - 1. Run ``make config``, or ``make menuconfig``, or ``make xconfig``, whichever 60 - you prefer, in the top kernel tree directory to set up your kernel 61 - configuration. Make sure to say "Y" to "Prompt for development drivers" 62 - and to say "M" to the sb1000 driver. Also say "Y" or "M" to all the standard 63 - networking questions to get TCP/IP and PPP networking support. 64 - 65 - 2. **BEFORE** you build the kernel, edit drivers/net/sb1000.c. Make sure 66 - to redefine the value of READ_DATA_PORT to match the I/O address used 67 - by isapnp to access your PnP cards. This is the value of READPORT in 68 - /etc/isapnp.conf or given by the output of pnpdump. 69 - 70 - 3. Build and install the kernel and modules as usual. 71 - 72 - 4. Boot your new kernel following the usual procedures. 73 - 74 - 5. Set up to configure the new SB1000 PnP card by capturing the output 75 - of "pnpdump" to a file and editing this file to set the correct I/O ports, 76 - IRQ, and DMA settings for all your PnP cards. Make sure none of the settings 77 - conflict with one another. Then test this configuration by running the 78 - "isapnp" command with your new config file as the input. Check for 79 - errors and fix as necessary. (As an aside, I use I/O ports 0x110 and 80 - 0x310 and IRQ 11 for my SB1000 card and these work well for me. YMMV.) 81 - Then save the finished config file as /etc/isapnp.conf for proper 82 - configuration on subsequent reboots. 83 - 84 - 6. Download the original file sb1000-1.1.2.tar.gz from Franco's site or one of 85 - the others referenced above. As root, unpack it into a temporary directory 86 - and do a ``make cmconfig`` and then ``install -c cmconfig /usr/local/sbin``. 87 - Don't do ``make install`` because it expects to find all the utilities built 88 - and ready for installation, not just cmconfig. 89 - 90 - 7. As root, copy all the files under the ppp/ subdirectory in Franco's 91 - tar file into /etc/ppp, being careful not to overwrite any files that are 92 - already in there. Then modify ppp@gi-on to set the correct login name, 93 - phone number, and frequency for the cable modem. Also edit pap-secrets 94 - to specify your login name and password and any site-specific information 95 - you need. 96 - 97 - 8. Be sure to modify /etc/ppp/firewall to use ipchains instead of 98 - the older ipfwadm commands from the 2.0.x kernels. There's a neat utility to 99 - convert ipfwadm commands to ipchains commands: 100 - 101 - http://users.dhp.com/~whisper/ipfwadm2ipchains/ 102 - 103 - You may also wish to modify the firewall script to implement a different 104 - firewalling scheme. 105 - 106 - 9. Start the PPP connection via the script /etc/ppp/ppp@gi-on. You must be 107 - root to do this. It's better to use a utility like sudo to execute 108 - frequently used commands like this with root permissions if possible. If you 109 - connect successfully the cable modem interface will come up and you'll see a 110 - driver message like this at the console:: 111 - 112 - cm0: sb1000 at (0x110,0x310), csn 1, S/N 0x2a0d16d8, IRQ 11. 113 - sb1000.c:v1.1.2 6/01/98 (fventuri@mediaone.net) 114 - 115 - The "ifconfig" command should show two new interfaces, ppp0 and cm0. 116 - 117 - The command "cmconfig cm0" will give you information about the cable modem 118 - interface. 119 - 120 - 10. Try pinging a site via ``ping -c 5 www.yahoo.com``, for example. You should 121 - see packets received. 122 - 123 - 11. If you can't get site names (like www.yahoo.com) to resolve into 124 - IP addresses (like 204.71.200.67), be sure your /etc/resolv.conf file 125 - has no syntax errors and has the right nameserver IP addresses in it. 126 - If this doesn't help, try something like ``ping -c 5 204.71.200.67`` to 127 - see if the networking is running but the DNS resolution is where the 128 - problem lies. 129 - 130 - 12. If you still have problems, go to the support web sites mentioned above 131 - and read the information and documentation there. 132 - 133 - Common problems 134 - =============== 135 - 136 - 1. Packets go out on the ppp0 interface but don't come back on the cm0 137 - interface. It looks like I'm connected but I can't even ping any 138 - numerical IP addresses. (This happens predominantly on Debian systems due 139 - to a default boot-time configuration script.) 140 - 141 - Solution 142 - As root ``echo 0 > /proc/sys/net/ipv4/conf/cm0/rp_filter`` so it 143 - can share the same IP address as the ppp0 interface. Note that this 144 - command should probably be added to the /etc/ppp/cablemodem script 145 - *right*between* the "/sbin/ifconfig" and "/sbin/cmconfig" commands. 146 - You may need to do this to /proc/sys/net/ipv4/conf/ppp0/rp_filter as well. 147 - If you do this to /proc/sys/net/ipv4/conf/default/rp_filter on each reboot 148 - (in rc.local or some such) then any interfaces can share the same IP 149 - addresses. 150 - 151 - 2. I get "unresolved symbol" error messages on executing ``insmod sb1000.o``. 152 - 153 - Solution 154 - You probably have a non-matching kernel source tree and 155 - /usr/include/linux and /usr/include/asm header files. Make sure you 156 - install the correct versions of the header files in these two directories. 157 - Then rebuild and reinstall the kernel. 158 - 159 - 3. When isapnp runs it reports an error, and my SB1000 card isn't working. 160 - 161 - Solution 162 - There's a problem with later versions of isapnp using the "(CHECK)" 163 - option in the lines that allocate the two I/O addresses for the SB1000 card. 164 - This first popped up on RH 6.0. Delete "(CHECK)" for the SB1000 I/O addresses. 165 - Make sure they don't conflict with any other pieces of hardware first! Then 166 - rerun isapnp and go from there. 167 - 168 - 4. I can't execute the /etc/ppp/ppp@gi-on file. 169 - 170 - Solution 171 - As root do ``chmod ug+x /etc/ppp/ppp@gi-on``. 172 - 173 - 5. The firewall script isn't working (with 2.2.x and higher kernels). 174 - 175 - Solution 176 - Use the ipfwadm2ipchains script referenced above to convert the 177 - /etc/ppp/firewall script from the deprecated ipfwadm commands to ipchains. 178 - 179 - 6. I'm getting *tons* of firewall deny messages in the /var/kern.log, 180 - /var/messages, and/or /var/syslog files, and they're filling up my /var 181 - partition!!! 182 - 183 - Solution 184 - First, tell your ISP that you're receiving DoS (Denial of Service) 185 - and/or portscanning (UDP connection attempts) attacks! Look over the deny 186 - messages to figure out what the attack is and where it's coming from. Next, 187 - edit /etc/ppp/cablemodem and make sure the ",nobroadcast" option is turned on 188 - to the "cmconfig" command (uncomment that line). If you're not receiving these 189 - denied packets on your broadcast interface (IP address xxx.yyy.zzz.255 190 - typically), then someone is attacking your machine in particular. Be careful 191 - out there.... 192 - 193 - 7. Everything seems to work fine but my computer locks up after a while 194 - (and typically during a lengthy download through the cable modem)! 195 - 196 - Solution 197 - You may need to add a short delay in the driver to 'slow down' the 198 - SURFboard because your PC might not be able to keep up with the transfer rate 199 - of the SB1000. To do this, it's probably best to download Franco's 200 - sb1000-1.1.2.tar.gz archive and build and install sb1000.o manually. You'll 201 - want to edit the 'Makefile' and look for the 'SB1000_DELAY' 202 - define. Uncomment those 'CFLAGS' lines (and comment out the default ones) 203 - and try setting the delay to something like 60 microseconds with: 204 - '-DSB1000_DELAY=60'. Then do ``make`` and as root ``make install`` and try 205 - it out. If it still doesn't work or you like playing with the driver, you may 206 - try other numbers. Remember though that the higher the delay, the slower the 207 - driver (which slows down the rest of the PC too when it is actively 208 - used). Thanks to Ed Daiga for this tip! 209 - 210 - Credits 211 - ======= 212 - 213 - This README came from Franco Venturi's original README file which is 214 - still supplied with his driver .tar.gz archive. I and all other sb1000 users 215 - owe Franco a tremendous "Thank you!" Additional thanks goes to Carl Patten 216 - and Ralph Bonnell who are now managing the Linux SB1000 web site, and to 217 - the SB1000 users who reported and helped debug the common problems listed 218 - above. 219 - 220 - 221 - Clemmitt Sigler 222 - csigler@vt.edu
-1
Documentation/networking/device_drivers/index.rst
··· 9 9 :maxdepth: 2 10 10 11 11 atm/index 12 - cable/index 13 12 can/index 14 13 cellular/index 15 14 ethernet/index
-1
arch/powerpc/configs/ppc6xx_defconfig
··· 485 485 CONFIG_PCMCIA_XIRC2PS=m 486 486 CONFIG_FDDI=y 487 487 CONFIG_SKFP=m 488 - CONFIG_NET_SB1000=m 489 488 CONFIG_BROADCOM_PHY=m 490 489 CONFIG_CICADA_PHY=m 491 490 CONFIG_DAVICOM_PHY=m
-2
drivers/acpi/acpi_pnp.c
··· 120 120 {"IBM0071"}, 121 121 /* smsc-ircc2 */ 122 122 {"SMCf010"}, 123 - /* sb1000 */ 124 - {"GIC1000"}, 125 123 /* parport_pc */ 126 124 {"PNP0400"}, /* Standard LPT Printer Port */ 127 125 {"PNP0401"}, /* ECP Printer Port */
-24
drivers/net/Kconfig
··· 518 518 519 519 source "drivers/net/ipa/Kconfig" 520 520 521 - config NET_SB1000 522 - tristate "General Instruments Surfboard 1000" 523 - depends on ISA && PNP 524 - help 525 - This is a driver for the General Instrument (also known as 526 - NextLevel) SURFboard 1000 internal 527 - cable modem. This is an ISA card which is used by a number of cable 528 - TV companies to provide cable modem access. It's a one-way 529 - downstream-only cable modem, meaning that your upstream net link is 530 - provided by your regular phone modem. 531 - 532 - At present this driver only compiles as a module, so say M here if 533 - you have this card. The module will be called sb1000. Then read 534 - <file:Documentation/networking/device_drivers/cable/sb1000.rst> for 535 - information on how to use this module, as it needs special ppp 536 - scripts for establishing a connection. Further documentation 537 - and the necessary scripts can be found at: 538 - 539 - <http://www.jacksonville.net/~fventuri/> 540 - <http://home.adelphia.net/~siglercm/sb1000.html> 541 - <http://linuxpower.cx/~cable/> 542 - 543 - If you don't have this card, of course say N. 544 - 545 521 source "drivers/net/phy/Kconfig" 546 522 547 523 source "drivers/net/pse-pd/Kconfig"
-1
drivers/net/Makefile
··· 69 69 obj-$(CONFIG_PPTP) += ppp/ 70 70 obj-$(CONFIG_SLIP) += slip/ 71 71 obj-$(CONFIG_SLHC) += slip/ 72 - obj-$(CONFIG_NET_SB1000) += sb1000.o 73 72 obj-$(CONFIG_SUNGEM_PHY) += sungem_phy.o 74 73 obj-$(CONFIG_WAN) += wan/ 75 74 obj-$(CONFIG_WLAN) += wireless/
-1179
drivers/net/sb1000.c
··· 1 - // SPDX-License-Identifier: GPL-2.0-or-later 2 - /* sb1000.c: A General Instruments SB1000 driver for linux. */ 3 - /* 4 - Written 1998 by Franco Venturi. 5 - 6 - Copyright 1998 by Franco Venturi. 7 - Copyright 1994,1995 by Donald Becker. 8 - Copyright 1993 United States Government as represented by the 9 - Director, National Security Agency. 10 - 11 - This driver is for the General Instruments SB1000 (internal SURFboard) 12 - 13 - The author may be reached as fventuri@mediaone.net 14 - 15 - 16 - Changes: 17 - 18 - 981115 Steven Hirsch <shirsch@adelphia.net> 19 - 20 - Linus changed the timer interface. Should work on all recent 21 - development kernels. 22 - 23 - 980608 Steven Hirsch <shirsch@adelphia.net> 24 - 25 - Small changes to make it work with 2.1.x kernels. Hopefully, 26 - nothing major will change before official release of Linux 2.2. 27 - 28 - Merged with 2.2 - Alan Cox 29 - */ 30 - 31 - static char version[] = "sb1000.c:v1.1.2 6/01/98 (fventuri@mediaone.net)\n"; 32 - 33 - #include <linux/module.h> 34 - #include <linux/kernel.h> 35 - #include <linux/sched.h> 36 - #include <linux/string.h> 37 - #include <linux/interrupt.h> 38 - #include <linux/errno.h> 39 - #include <linux/if_cablemodem.h> /* for SIOGCM/SIOSCM stuff */ 40 - #include <linux/in.h> 41 - #include <linux/ioport.h> 42 - #include <linux/netdevice.h> 43 - #include <linux/if_arp.h> 44 - #include <linux/skbuff.h> 45 - #include <linux/delay.h> /* for udelay() */ 46 - #include <linux/etherdevice.h> 47 - #include <linux/pnp.h> 48 - #include <linux/init.h> 49 - #include <linux/bitops.h> 50 - #include <linux/gfp.h> 51 - 52 - #include <asm/io.h> 53 - #include <asm/processor.h> 54 - #include <linux/uaccess.h> 55 - 56 - #ifdef SB1000_DEBUG 57 - static int sb1000_debug = SB1000_DEBUG; 58 - #else 59 - static const int sb1000_debug = 1; 60 - #endif 61 - 62 - static const int SB1000_IO_EXTENT = 8; 63 - /* SB1000 Maximum Receive Unit */ 64 - static const int SB1000_MRU = 1500; /* octects */ 65 - 66 - #define NPIDS 4 67 - struct sb1000_private { 68 - struct sk_buff *rx_skb[NPIDS]; 69 - short rx_dlen[NPIDS]; 70 - unsigned int rx_frames; 71 - short rx_error_count; 72 - short rx_error_dpc_count; 73 - unsigned char rx_session_id[NPIDS]; 74 - unsigned char rx_frame_id[NPIDS]; 75 - unsigned char rx_pkt_type[NPIDS]; 76 - }; 77 - 78 - /* prototypes for Linux interface */ 79 - extern int sb1000_probe(struct net_device *dev); 80 - static int sb1000_open(struct net_device *dev); 81 - static int sb1000_siocdevprivate(struct net_device *dev, struct ifreq *ifr, 82 - void __user *data, int cmd); 83 - static netdev_tx_t sb1000_start_xmit(struct sk_buff *skb, 84 - struct net_device *dev); 85 - static irqreturn_t sb1000_interrupt(int irq, void *dev_id); 86 - static int sb1000_close(struct net_device *dev); 87 - 88 - 89 - /* SB1000 hardware routines to be used during open/configuration phases */ 90 - static int card_wait_for_busy_clear(const int ioaddr[], 91 - const char* name); 92 - static int card_wait_for_ready(const int ioaddr[], const char* name, 93 - unsigned char in[]); 94 - static int card_send_command(const int ioaddr[], const char* name, 95 - const unsigned char out[], unsigned char in[]); 96 - 97 - /* SB1000 hardware routines to be used during frame rx interrupt */ 98 - static int sb1000_wait_for_ready(const int ioaddr[], const char* name); 99 - static int sb1000_wait_for_ready_clear(const int ioaddr[], 100 - const char* name); 101 - static void sb1000_send_command(const int ioaddr[], const char* name, 102 - const unsigned char out[]); 103 - static void sb1000_read_status(const int ioaddr[], unsigned char in[]); 104 - static void sb1000_issue_read_command(const int ioaddr[], 105 - const char* name); 106 - 107 - /* SB1000 commands for open/configuration */ 108 - static int sb1000_reset(const int ioaddr[], const char* name); 109 - static int sb1000_check_CRC(const int ioaddr[], const char* name); 110 - static inline int sb1000_start_get_set_command(const int ioaddr[], 111 - const char* name); 112 - static int sb1000_end_get_set_command(const int ioaddr[], 113 - const char* name); 114 - static int sb1000_activate(const int ioaddr[], const char* name); 115 - static int sb1000_get_firmware_version(const int ioaddr[], 116 - const char* name, unsigned char version[], int do_end); 117 - static int sb1000_get_frequency(const int ioaddr[], const char* name, 118 - int* frequency); 119 - static int sb1000_set_frequency(const int ioaddr[], const char* name, 120 - int frequency); 121 - static int sb1000_get_PIDs(const int ioaddr[], const char* name, 122 - short PID[]); 123 - static int sb1000_set_PIDs(const int ioaddr[], const char* name, 124 - const short PID[]); 125 - 126 - /* SB1000 commands for frame rx interrupt */ 127 - static int sb1000_rx(struct net_device *dev); 128 - static void sb1000_error_dpc(struct net_device *dev); 129 - 130 - static const struct pnp_device_id sb1000_pnp_ids[] = { 131 - { "GIC1000", 0 }, 132 - { "", 0 } 133 - }; 134 - MODULE_DEVICE_TABLE(pnp, sb1000_pnp_ids); 135 - 136 - static const struct net_device_ops sb1000_netdev_ops = { 137 - .ndo_open = sb1000_open, 138 - .ndo_start_xmit = sb1000_start_xmit, 139 - .ndo_siocdevprivate = sb1000_siocdevprivate, 140 - .ndo_stop = sb1000_close, 141 - .ndo_set_mac_address = eth_mac_addr, 142 - .ndo_validate_addr = eth_validate_addr, 143 - }; 144 - 145 - static int 146 - sb1000_probe_one(struct pnp_dev *pdev, const struct pnp_device_id *id) 147 - { 148 - struct net_device *dev; 149 - unsigned short ioaddr[2], irq; 150 - unsigned int serial_number; 151 - int error = -ENODEV; 152 - u8 addr[ETH_ALEN]; 153 - 154 - if (pnp_device_attach(pdev) < 0) 155 - return -ENODEV; 156 - if (pnp_activate_dev(pdev) < 0) 157 - goto out_detach; 158 - 159 - if (!pnp_port_valid(pdev, 0) || !pnp_port_valid(pdev, 1)) 160 - goto out_disable; 161 - if (!pnp_irq_valid(pdev, 0)) 162 - goto out_disable; 163 - 164 - serial_number = pdev->card->serial; 165 - 166 - ioaddr[0] = pnp_port_start(pdev, 0); 167 - ioaddr[1] = pnp_port_start(pdev, 0); 168 - 169 - irq = pnp_irq(pdev, 0); 170 - 171 - if (!request_region(ioaddr[0], 16, "sb1000")) 172 - goto out_disable; 173 - if (!request_region(ioaddr[1], 16, "sb1000")) 174 - goto out_release_region0; 175 - 176 - dev = alloc_etherdev(sizeof(struct sb1000_private)); 177 - if (!dev) { 178 - error = -ENOMEM; 179 - goto out_release_regions; 180 - } 181 - 182 - 183 - dev->base_addr = ioaddr[0]; 184 - /* mem_start holds the second I/O address */ 185 - dev->mem_start = ioaddr[1]; 186 - dev->irq = irq; 187 - 188 - if (sb1000_debug > 0) 189 - printk(KERN_NOTICE "%s: sb1000 at (%#3.3lx,%#3.3lx), " 190 - "S/N %#8.8x, IRQ %d.\n", dev->name, dev->base_addr, 191 - dev->mem_start, serial_number, dev->irq); 192 - 193 - /* 194 - * The SB1000 is an rx-only cable modem device. The uplink is a modem 195 - * and we do not want to arp on it. 196 - */ 197 - dev->flags = IFF_POINTOPOINT|IFF_NOARP; 198 - 199 - SET_NETDEV_DEV(dev, &pdev->dev); 200 - 201 - if (sb1000_debug > 0) 202 - printk(KERN_NOTICE "%s", version); 203 - 204 - dev->netdev_ops = &sb1000_netdev_ops; 205 - 206 - /* hardware address is 0:0:serial_number */ 207 - addr[0] = 0; 208 - addr[1] = 0; 209 - addr[2] = serial_number >> 24 & 0xff; 210 - addr[3] = serial_number >> 16 & 0xff; 211 - addr[4] = serial_number >> 8 & 0xff; 212 - addr[5] = serial_number >> 0 & 0xff; 213 - eth_hw_addr_set(dev, addr); 214 - 215 - pnp_set_drvdata(pdev, dev); 216 - 217 - error = register_netdev(dev); 218 - if (error) 219 - goto out_free_netdev; 220 - return 0; 221 - 222 - out_free_netdev: 223 - free_netdev(dev); 224 - out_release_regions: 225 - release_region(ioaddr[1], 16); 226 - out_release_region0: 227 - release_region(ioaddr[0], 16); 228 - out_disable: 229 - pnp_disable_dev(pdev); 230 - out_detach: 231 - pnp_device_detach(pdev); 232 - return error; 233 - } 234 - 235 - static void 236 - sb1000_remove_one(struct pnp_dev *pdev) 237 - { 238 - struct net_device *dev = pnp_get_drvdata(pdev); 239 - 240 - unregister_netdev(dev); 241 - release_region(dev->base_addr, 16); 242 - release_region(dev->mem_start, 16); 243 - free_netdev(dev); 244 - } 245 - 246 - static struct pnp_driver sb1000_driver = { 247 - .name = "sb1000", 248 - .id_table = sb1000_pnp_ids, 249 - .probe = sb1000_probe_one, 250 - .remove = sb1000_remove_one, 251 - }; 252 - 253 - 254 - /* 255 - * SB1000 hardware routines to be used during open/configuration phases 256 - */ 257 - 258 - static const int TimeOutJiffies = (875 * HZ) / 100; 259 - 260 - /* Card Wait For Busy Clear (cannot be used during an interrupt) */ 261 - static int 262 - card_wait_for_busy_clear(const int ioaddr[], const char* name) 263 - { 264 - unsigned char a; 265 - unsigned long timeout; 266 - 267 - a = inb(ioaddr[0] + 7); 268 - timeout = jiffies + TimeOutJiffies; 269 - while (a & 0x80 || a & 0x40) { 270 - /* a little sleep */ 271 - yield(); 272 - 273 - a = inb(ioaddr[0] + 7); 274 - if (time_after_eq(jiffies, timeout)) { 275 - printk(KERN_WARNING "%s: card_wait_for_busy_clear timeout\n", 276 - name); 277 - return -ETIME; 278 - } 279 - } 280 - 281 - return 0; 282 - } 283 - 284 - /* Card Wait For Ready (cannot be used during an interrupt) */ 285 - static int 286 - card_wait_for_ready(const int ioaddr[], const char* name, unsigned char in[]) 287 - { 288 - unsigned char a; 289 - unsigned long timeout; 290 - 291 - a = inb(ioaddr[1] + 6); 292 - timeout = jiffies + TimeOutJiffies; 293 - while (a & 0x80 || !(a & 0x40)) { 294 - /* a little sleep */ 295 - yield(); 296 - 297 - a = inb(ioaddr[1] + 6); 298 - if (time_after_eq(jiffies, timeout)) { 299 - printk(KERN_WARNING "%s: card_wait_for_ready timeout\n", 300 - name); 301 - return -ETIME; 302 - } 303 - } 304 - 305 - in[1] = inb(ioaddr[0] + 1); 306 - in[2] = inb(ioaddr[0] + 2); 307 - in[3] = inb(ioaddr[0] + 3); 308 - in[4] = inb(ioaddr[0] + 4); 309 - in[0] = inb(ioaddr[0] + 5); 310 - in[6] = inb(ioaddr[0] + 6); 311 - in[5] = inb(ioaddr[1] + 6); 312 - return 0; 313 - } 314 - 315 - /* Card Send Command (cannot be used during an interrupt) */ 316 - static int 317 - card_send_command(const int ioaddr[], const char* name, 318 - const unsigned char out[], unsigned char in[]) 319 - { 320 - int status; 321 - 322 - if ((status = card_wait_for_busy_clear(ioaddr, name))) 323 - return status; 324 - outb(0xa0, ioaddr[0] + 6); 325 - outb(out[2], ioaddr[0] + 1); 326 - outb(out[3], ioaddr[0] + 2); 327 - outb(out[4], ioaddr[0] + 3); 328 - outb(out[5], ioaddr[0] + 4); 329 - outb(out[1], ioaddr[0] + 5); 330 - outb(0xa0, ioaddr[0] + 6); 331 - outb(out[0], ioaddr[0] + 7); 332 - if (out[0] != 0x20 && out[0] != 0x30) { 333 - if ((status = card_wait_for_ready(ioaddr, name, in))) 334 - return status; 335 - inb(ioaddr[0] + 7); 336 - if (sb1000_debug > 3) 337 - printk(KERN_DEBUG "%s: card_send_command " 338 - "out: %02x%02x%02x%02x%02x%02x " 339 - "in: %02x%02x%02x%02x%02x%02x%02x\n", name, 340 - out[0], out[1], out[2], out[3], out[4], out[5], 341 - in[0], in[1], in[2], in[3], in[4], in[5], in[6]); 342 - } else { 343 - if (sb1000_debug > 3) 344 - printk(KERN_DEBUG "%s: card_send_command " 345 - "out: %02x%02x%02x%02x%02x%02x\n", name, 346 - out[0], out[1], out[2], out[3], out[4], out[5]); 347 - } 348 - 349 - if (out[1] != 0x1b) { 350 - if (out[0] >= 0x80 && in[0] != (out[1] | 0x80)) 351 - return -EIO; 352 - } 353 - return 0; 354 - } 355 - 356 - 357 - /* 358 - * SB1000 hardware routines to be used during frame rx interrupt 359 - */ 360 - static const int Sb1000TimeOutJiffies = 7 * HZ; 361 - 362 - /* Card Wait For Ready (to be used during frame rx) */ 363 - static int 364 - sb1000_wait_for_ready(const int ioaddr[], const char* name) 365 - { 366 - unsigned long timeout; 367 - 368 - timeout = jiffies + Sb1000TimeOutJiffies; 369 - while (inb(ioaddr[1] + 6) & 0x80) { 370 - if (time_after_eq(jiffies, timeout)) { 371 - printk(KERN_WARNING "%s: sb1000_wait_for_ready timeout\n", 372 - name); 373 - return -ETIME; 374 - } 375 - } 376 - timeout = jiffies + Sb1000TimeOutJiffies; 377 - while (!(inb(ioaddr[1] + 6) & 0x40)) { 378 - if (time_after_eq(jiffies, timeout)) { 379 - printk(KERN_WARNING "%s: sb1000_wait_for_ready timeout\n", 380 - name); 381 - return -ETIME; 382 - } 383 - } 384 - inb(ioaddr[0] + 7); 385 - return 0; 386 - } 387 - 388 - /* Card Wait For Ready Clear (to be used during frame rx) */ 389 - static int 390 - sb1000_wait_for_ready_clear(const int ioaddr[], const char* name) 391 - { 392 - unsigned long timeout; 393 - 394 - timeout = jiffies + Sb1000TimeOutJiffies; 395 - while (inb(ioaddr[1] + 6) & 0x80) { 396 - if (time_after_eq(jiffies, timeout)) { 397 - printk(KERN_WARNING "%s: sb1000_wait_for_ready_clear timeout\n", 398 - name); 399 - return -ETIME; 400 - } 401 - } 402 - timeout = jiffies + Sb1000TimeOutJiffies; 403 - while (inb(ioaddr[1] + 6) & 0x40) { 404 - if (time_after_eq(jiffies, timeout)) { 405 - printk(KERN_WARNING "%s: sb1000_wait_for_ready_clear timeout\n", 406 - name); 407 - return -ETIME; 408 - } 409 - } 410 - return 0; 411 - } 412 - 413 - /* Card Send Command (to be used during frame rx) */ 414 - static void 415 - sb1000_send_command(const int ioaddr[], const char* name, 416 - const unsigned char out[]) 417 - { 418 - outb(out[2], ioaddr[0] + 1); 419 - outb(out[3], ioaddr[0] + 2); 420 - outb(out[4], ioaddr[0] + 3); 421 - outb(out[5], ioaddr[0] + 4); 422 - outb(out[1], ioaddr[0] + 5); 423 - outb(out[0], ioaddr[0] + 7); 424 - if (sb1000_debug > 3) 425 - printk(KERN_DEBUG "%s: sb1000_send_command out: %02x%02x%02x%02x" 426 - "%02x%02x\n", name, out[0], out[1], out[2], out[3], out[4], out[5]); 427 - } 428 - 429 - /* Card Read Status (to be used during frame rx) */ 430 - static void 431 - sb1000_read_status(const int ioaddr[], unsigned char in[]) 432 - { 433 - in[1] = inb(ioaddr[0] + 1); 434 - in[2] = inb(ioaddr[0] + 2); 435 - in[3] = inb(ioaddr[0] + 3); 436 - in[4] = inb(ioaddr[0] + 4); 437 - in[0] = inb(ioaddr[0] + 5); 438 - } 439 - 440 - /* Issue Read Command (to be used during frame rx) */ 441 - static void 442 - sb1000_issue_read_command(const int ioaddr[], const char* name) 443 - { 444 - static const unsigned char Command0[6] = {0x20, 0x00, 0x00, 0x01, 0x00, 0x00}; 445 - 446 - sb1000_wait_for_ready_clear(ioaddr, name); 447 - outb(0xa0, ioaddr[0] + 6); 448 - sb1000_send_command(ioaddr, name, Command0); 449 - } 450 - 451 - 452 - /* 453 - * SB1000 commands for open/configuration 454 - */ 455 - /* reset SB1000 card */ 456 - static int 457 - sb1000_reset(const int ioaddr[], const char* name) 458 - { 459 - static const unsigned char Command0[6] = {0x80, 0x16, 0x00, 0x00, 0x00, 0x00}; 460 - 461 - unsigned char st[7]; 462 - int port, status; 463 - 464 - port = ioaddr[1] + 6; 465 - outb(0x4, port); 466 - inb(port); 467 - udelay(1000); 468 - outb(0x0, port); 469 - inb(port); 470 - ssleep(1); 471 - outb(0x4, port); 472 - inb(port); 473 - udelay(1000); 474 - outb(0x0, port); 475 - inb(port); 476 - udelay(0); 477 - 478 - if ((status = card_send_command(ioaddr, name, Command0, st))) 479 - return status; 480 - if (st[3] != 0xf0) 481 - return -EIO; 482 - return 0; 483 - } 484 - 485 - /* check SB1000 firmware CRC */ 486 - static int 487 - sb1000_check_CRC(const int ioaddr[], const char* name) 488 - { 489 - static const unsigned char Command0[6] = {0x80, 0x1f, 0x00, 0x00, 0x00, 0x00}; 490 - 491 - unsigned char st[7]; 492 - int status; 493 - 494 - /* check CRC */ 495 - if ((status = card_send_command(ioaddr, name, Command0, st))) 496 - return status; 497 - if (st[1] != st[3] || st[2] != st[4]) 498 - return -EIO; 499 - return 0; 500 - } 501 - 502 - static inline int 503 - sb1000_start_get_set_command(const int ioaddr[], const char* name) 504 - { 505 - static const unsigned char Command0[6] = {0x80, 0x1b, 0x00, 0x00, 0x00, 0x00}; 506 - 507 - unsigned char st[7]; 508 - 509 - return card_send_command(ioaddr, name, Command0, st); 510 - } 511 - 512 - static int 513 - sb1000_end_get_set_command(const int ioaddr[], const char* name) 514 - { 515 - static const unsigned char Command0[6] = {0x80, 0x1b, 0x02, 0x00, 0x00, 0x00}; 516 - static const unsigned char Command1[6] = {0x20, 0x00, 0x00, 0x00, 0x00, 0x00}; 517 - 518 - unsigned char st[7]; 519 - int status; 520 - 521 - if ((status = card_send_command(ioaddr, name, Command0, st))) 522 - return status; 523 - return card_send_command(ioaddr, name, Command1, st); 524 - } 525 - 526 - static int 527 - sb1000_activate(const int ioaddr[], const char* name) 528 - { 529 - static const unsigned char Command0[6] = {0x80, 0x11, 0x00, 0x00, 0x00, 0x00}; 530 - static const unsigned char Command1[6] = {0x80, 0x16, 0x00, 0x00, 0x00, 0x00}; 531 - 532 - unsigned char st[7]; 533 - int status; 534 - 535 - ssleep(1); 536 - status = card_send_command(ioaddr, name, Command0, st); 537 - if (status) 538 - return status; 539 - status = card_send_command(ioaddr, name, Command1, st); 540 - if (status) 541 - return status; 542 - if (st[3] != 0xf1) { 543 - status = sb1000_start_get_set_command(ioaddr, name); 544 - if (status) 545 - return status; 546 - return -EIO; 547 - } 548 - udelay(1000); 549 - return sb1000_start_get_set_command(ioaddr, name); 550 - } 551 - 552 - /* get SB1000 firmware version */ 553 - static int 554 - sb1000_get_firmware_version(const int ioaddr[], const char* name, 555 - unsigned char version[], int do_end) 556 - { 557 - static const unsigned char Command0[6] = {0x80, 0x23, 0x00, 0x00, 0x00, 0x00}; 558 - 559 - unsigned char st[7]; 560 - int status; 561 - 562 - if ((status = sb1000_start_get_set_command(ioaddr, name))) 563 - return status; 564 - if ((status = card_send_command(ioaddr, name, Command0, st))) 565 - return status; 566 - if (st[0] != 0xa3) 567 - return -EIO; 568 - version[0] = st[1]; 569 - version[1] = st[2]; 570 - if (do_end) 571 - return sb1000_end_get_set_command(ioaddr, name); 572 - else 573 - return 0; 574 - } 575 - 576 - /* get SB1000 frequency */ 577 - static int 578 - sb1000_get_frequency(const int ioaddr[], const char* name, int* frequency) 579 - { 580 - static const unsigned char Command0[6] = {0x80, 0x44, 0x00, 0x00, 0x00, 0x00}; 581 - 582 - unsigned char st[7]; 583 - int status; 584 - 585 - udelay(1000); 586 - if ((status = sb1000_start_get_set_command(ioaddr, name))) 587 - return status; 588 - if ((status = card_send_command(ioaddr, name, Command0, st))) 589 - return status; 590 - *frequency = ((st[1] << 8 | st[2]) << 8 | st[3]) << 8 | st[4]; 591 - return sb1000_end_get_set_command(ioaddr, name); 592 - } 593 - 594 - /* set SB1000 frequency */ 595 - static int 596 - sb1000_set_frequency(const int ioaddr[], const char* name, int frequency) 597 - { 598 - unsigned char st[7]; 599 - int status; 600 - unsigned char Command0[6] = {0x80, 0x29, 0x00, 0x00, 0x00, 0x00}; 601 - 602 - const int FrequencyLowerLimit = 57000; 603 - const int FrequencyUpperLimit = 804000; 604 - 605 - if (frequency < FrequencyLowerLimit || frequency > FrequencyUpperLimit) { 606 - printk(KERN_ERR "%s: frequency chosen (%d kHz) is not in the range " 607 - "[%d,%d] kHz\n", name, frequency, FrequencyLowerLimit, 608 - FrequencyUpperLimit); 609 - return -EINVAL; 610 - } 611 - udelay(1000); 612 - if ((status = sb1000_start_get_set_command(ioaddr, name))) 613 - return status; 614 - Command0[5] = frequency & 0xff; 615 - frequency >>= 8; 616 - Command0[4] = frequency & 0xff; 617 - frequency >>= 8; 618 - Command0[3] = frequency & 0xff; 619 - frequency >>= 8; 620 - Command0[2] = frequency & 0xff; 621 - return card_send_command(ioaddr, name, Command0, st); 622 - } 623 - 624 - /* get SB1000 PIDs */ 625 - static int 626 - sb1000_get_PIDs(const int ioaddr[], const char* name, short PID[]) 627 - { 628 - static const unsigned char Command0[6] = {0x80, 0x40, 0x00, 0x00, 0x00, 0x00}; 629 - static const unsigned char Command1[6] = {0x80, 0x41, 0x00, 0x00, 0x00, 0x00}; 630 - static const unsigned char Command2[6] = {0x80, 0x42, 0x00, 0x00, 0x00, 0x00}; 631 - static const unsigned char Command3[6] = {0x80, 0x43, 0x00, 0x00, 0x00, 0x00}; 632 - 633 - unsigned char st[7]; 634 - int status; 635 - 636 - udelay(1000); 637 - if ((status = sb1000_start_get_set_command(ioaddr, name))) 638 - return status; 639 - 640 - if ((status = card_send_command(ioaddr, name, Command0, st))) 641 - return status; 642 - PID[0] = st[1] << 8 | st[2]; 643 - 644 - if ((status = card_send_command(ioaddr, name, Command1, st))) 645 - return status; 646 - PID[1] = st[1] << 8 | st[2]; 647 - 648 - if ((status = card_send_command(ioaddr, name, Command2, st))) 649 - return status; 650 - PID[2] = st[1] << 8 | st[2]; 651 - 652 - if ((status = card_send_command(ioaddr, name, Command3, st))) 653 - return status; 654 - PID[3] = st[1] << 8 | st[2]; 655 - 656 - return sb1000_end_get_set_command(ioaddr, name); 657 - } 658 - 659 - /* set SB1000 PIDs */ 660 - static int 661 - sb1000_set_PIDs(const int ioaddr[], const char* name, const short PID[]) 662 - { 663 - static const unsigned char Command4[6] = {0x80, 0x2e, 0x00, 0x00, 0x00, 0x00}; 664 - 665 - unsigned char st[7]; 666 - short p; 667 - int status; 668 - unsigned char Command0[6] = {0x80, 0x31, 0x00, 0x00, 0x00, 0x00}; 669 - unsigned char Command1[6] = {0x80, 0x32, 0x00, 0x00, 0x00, 0x00}; 670 - unsigned char Command2[6] = {0x80, 0x33, 0x00, 0x00, 0x00, 0x00}; 671 - unsigned char Command3[6] = {0x80, 0x34, 0x00, 0x00, 0x00, 0x00}; 672 - 673 - udelay(1000); 674 - if ((status = sb1000_start_get_set_command(ioaddr, name))) 675 - return status; 676 - 677 - p = PID[0]; 678 - Command0[3] = p & 0xff; 679 - p >>= 8; 680 - Command0[2] = p & 0xff; 681 - if ((status = card_send_command(ioaddr, name, Command0, st))) 682 - return status; 683 - 684 - p = PID[1]; 685 - Command1[3] = p & 0xff; 686 - p >>= 8; 687 - Command1[2] = p & 0xff; 688 - if ((status = card_send_command(ioaddr, name, Command1, st))) 689 - return status; 690 - 691 - p = PID[2]; 692 - Command2[3] = p & 0xff; 693 - p >>= 8; 694 - Command2[2] = p & 0xff; 695 - if ((status = card_send_command(ioaddr, name, Command2, st))) 696 - return status; 697 - 698 - p = PID[3]; 699 - Command3[3] = p & 0xff; 700 - p >>= 8; 701 - Command3[2] = p & 0xff; 702 - if ((status = card_send_command(ioaddr, name, Command3, st))) 703 - return status; 704 - 705 - if ((status = card_send_command(ioaddr, name, Command4, st))) 706 - return status; 707 - return sb1000_end_get_set_command(ioaddr, name); 708 - } 709 - 710 - 711 - static void 712 - sb1000_print_status_buffer(const char* name, unsigned char st[], 713 - unsigned char buffer[], int size) 714 - { 715 - int i, j, k; 716 - 717 - printk(KERN_DEBUG "%s: status: %02x %02x\n", name, st[0], st[1]); 718 - if (buffer[24] == 0x08 && buffer[25] == 0x00 && buffer[26] == 0x45) { 719 - printk(KERN_DEBUG "%s: length: %d protocol: %d from: %d.%d.%d.%d:%d " 720 - "to %d.%d.%d.%d:%d\n", name, buffer[28] << 8 | buffer[29], 721 - buffer[35], buffer[38], buffer[39], buffer[40], buffer[41], 722 - buffer[46] << 8 | buffer[47], 723 - buffer[42], buffer[43], buffer[44], buffer[45], 724 - buffer[48] << 8 | buffer[49]); 725 - } else { 726 - for (i = 0, k = 0; i < (size + 7) / 8; i++) { 727 - printk(KERN_DEBUG "%s: %s", name, i ? " " : "buffer:"); 728 - for (j = 0; j < 8 && k < size; j++, k++) 729 - printk(" %02x", buffer[k]); 730 - printk("\n"); 731 - } 732 - } 733 - } 734 - 735 - /* 736 - * SB1000 commands for frame rx interrupt 737 - */ 738 - /* receive a single frame and assemble datagram 739 - * (this is the heart of the interrupt routine) 740 - */ 741 - static int 742 - sb1000_rx(struct net_device *dev) 743 - { 744 - 745 - #define FRAMESIZE 184 746 - unsigned char st[2], buffer[FRAMESIZE], session_id, frame_id; 747 - short dlen; 748 - int ioaddr, ns; 749 - unsigned int skbsize; 750 - struct sk_buff *skb; 751 - struct sb1000_private *lp = netdev_priv(dev); 752 - struct net_device_stats *stats = &dev->stats; 753 - 754 - /* SB1000 frame constants */ 755 - const int FrameSize = FRAMESIZE; 756 - const int NewDatagramHeaderSkip = 8; 757 - const int NewDatagramHeaderSize = NewDatagramHeaderSkip + 18; 758 - const int NewDatagramDataSize = FrameSize - NewDatagramHeaderSize; 759 - const int ContDatagramHeaderSkip = 7; 760 - const int ContDatagramHeaderSize = ContDatagramHeaderSkip + 1; 761 - const int ContDatagramDataSize = FrameSize - ContDatagramHeaderSize; 762 - const int TrailerSize = 4; 763 - 764 - ioaddr = dev->base_addr; 765 - 766 - insw(ioaddr, (unsigned short*) st, 1); 767 - #ifdef XXXDEBUG 768 - printk("cm0: received: %02x %02x\n", st[0], st[1]); 769 - #endif /* XXXDEBUG */ 770 - lp->rx_frames++; 771 - 772 - /* decide if it is a good or bad frame */ 773 - for (ns = 0; ns < NPIDS; ns++) { 774 - session_id = lp->rx_session_id[ns]; 775 - frame_id = lp->rx_frame_id[ns]; 776 - if (st[0] == session_id) { 777 - if (st[1] == frame_id || (!frame_id && (st[1] & 0xf0) == 0x30)) { 778 - goto good_frame; 779 - } else if ((st[1] & 0xf0) == 0x30 && (st[0] & 0x40)) { 780 - goto skipped_frame; 781 - } else { 782 - goto bad_frame; 783 - } 784 - } else if (st[0] == (session_id | 0x40)) { 785 - if ((st[1] & 0xf0) == 0x30) { 786 - goto skipped_frame; 787 - } else { 788 - goto bad_frame; 789 - } 790 - } 791 - } 792 - goto bad_frame; 793 - 794 - skipped_frame: 795 - stats->rx_frame_errors++; 796 - skb = lp->rx_skb[ns]; 797 - if (sb1000_debug > 1) 798 - printk(KERN_WARNING "%s: missing frame(s): got %02x %02x " 799 - "expecting %02x %02x\n", dev->name, st[0], st[1], 800 - skb ? session_id : session_id | 0x40, frame_id); 801 - if (skb) { 802 - dev_kfree_skb(skb); 803 - skb = NULL; 804 - } 805 - 806 - good_frame: 807 - lp->rx_frame_id[ns] = 0x30 | ((st[1] + 1) & 0x0f); 808 - /* new datagram */ 809 - if (st[0] & 0x40) { 810 - /* get data length */ 811 - insw(ioaddr, buffer, NewDatagramHeaderSize / 2); 812 - #ifdef XXXDEBUG 813 - printk("cm0: IP identification: %02x%02x fragment offset: %02x%02x\n", buffer[30], buffer[31], buffer[32], buffer[33]); 814 - #endif /* XXXDEBUG */ 815 - if (buffer[0] != NewDatagramHeaderSkip) { 816 - if (sb1000_debug > 1) 817 - printk(KERN_WARNING "%s: new datagram header skip error: " 818 - "got %02x expecting %02x\n", dev->name, buffer[0], 819 - NewDatagramHeaderSkip); 820 - stats->rx_length_errors++; 821 - insw(ioaddr, buffer, NewDatagramDataSize / 2); 822 - goto bad_frame_next; 823 - } 824 - dlen = ((buffer[NewDatagramHeaderSkip + 3] & 0x0f) << 8 | 825 - buffer[NewDatagramHeaderSkip + 4]) - 17; 826 - if (dlen > SB1000_MRU) { 827 - if (sb1000_debug > 1) 828 - printk(KERN_WARNING "%s: datagram length (%d) greater " 829 - "than MRU (%d)\n", dev->name, dlen, SB1000_MRU); 830 - stats->rx_length_errors++; 831 - insw(ioaddr, buffer, NewDatagramDataSize / 2); 832 - goto bad_frame_next; 833 - } 834 - lp->rx_dlen[ns] = dlen; 835 - /* compute size to allocate for datagram */ 836 - skbsize = dlen + FrameSize; 837 - if ((skb = alloc_skb(skbsize, GFP_ATOMIC)) == NULL) { 838 - if (sb1000_debug > 1) 839 - printk(KERN_WARNING "%s: can't allocate %d bytes long " 840 - "skbuff\n", dev->name, skbsize); 841 - stats->rx_dropped++; 842 - insw(ioaddr, buffer, NewDatagramDataSize / 2); 843 - goto dropped_frame; 844 - } 845 - skb->dev = dev; 846 - skb_reset_mac_header(skb); 847 - skb->protocol = (unsigned short) buffer[NewDatagramHeaderSkip + 16]; 848 - insw(ioaddr, skb_put(skb, NewDatagramDataSize), 849 - NewDatagramDataSize / 2); 850 - lp->rx_skb[ns] = skb; 851 - } else { 852 - /* continuation of previous datagram */ 853 - insw(ioaddr, buffer, ContDatagramHeaderSize / 2); 854 - if (buffer[0] != ContDatagramHeaderSkip) { 855 - if (sb1000_debug > 1) 856 - printk(KERN_WARNING "%s: cont datagram header skip error: " 857 - "got %02x expecting %02x\n", dev->name, buffer[0], 858 - ContDatagramHeaderSkip); 859 - stats->rx_length_errors++; 860 - insw(ioaddr, buffer, ContDatagramDataSize / 2); 861 - goto bad_frame_next; 862 - } 863 - skb = lp->rx_skb[ns]; 864 - insw(ioaddr, skb_put(skb, ContDatagramDataSize), 865 - ContDatagramDataSize / 2); 866 - dlen = lp->rx_dlen[ns]; 867 - } 868 - if (skb->len < dlen + TrailerSize) { 869 - lp->rx_session_id[ns] &= ~0x40; 870 - return 0; 871 - } 872 - 873 - /* datagram completed: send to upper level */ 874 - skb_trim(skb, dlen); 875 - __netif_rx(skb); 876 - stats->rx_bytes+=dlen; 877 - stats->rx_packets++; 878 - lp->rx_skb[ns] = NULL; 879 - lp->rx_session_id[ns] |= 0x40; 880 - return 0; 881 - 882 - bad_frame: 883 - insw(ioaddr, buffer, FrameSize / 2); 884 - if (sb1000_debug > 1) 885 - printk(KERN_WARNING "%s: frame error: got %02x %02x\n", 886 - dev->name, st[0], st[1]); 887 - stats->rx_frame_errors++; 888 - bad_frame_next: 889 - if (sb1000_debug > 2) 890 - sb1000_print_status_buffer(dev->name, st, buffer, FrameSize); 891 - dropped_frame: 892 - stats->rx_errors++; 893 - if (ns < NPIDS) { 894 - if ((skb = lp->rx_skb[ns])) { 895 - dev_kfree_skb(skb); 896 - lp->rx_skb[ns] = NULL; 897 - } 898 - lp->rx_session_id[ns] |= 0x40; 899 - } 900 - return -1; 901 - } 902 - 903 - static void 904 - sb1000_error_dpc(struct net_device *dev) 905 - { 906 - static const unsigned char Command0[6] = {0x80, 0x26, 0x00, 0x00, 0x00, 0x00}; 907 - 908 - char *name; 909 - unsigned char st[5]; 910 - int ioaddr[2]; 911 - struct sb1000_private *lp = netdev_priv(dev); 912 - const int ErrorDpcCounterInitialize = 200; 913 - 914 - ioaddr[0] = dev->base_addr; 915 - /* mem_start holds the second I/O address */ 916 - ioaddr[1] = dev->mem_start; 917 - name = dev->name; 918 - 919 - sb1000_wait_for_ready_clear(ioaddr, name); 920 - sb1000_send_command(ioaddr, name, Command0); 921 - sb1000_wait_for_ready(ioaddr, name); 922 - sb1000_read_status(ioaddr, st); 923 - if (st[1] & 0x10) 924 - lp->rx_error_dpc_count = ErrorDpcCounterInitialize; 925 - } 926 - 927 - 928 - /* 929 - * Linux interface functions 930 - */ 931 - static int 932 - sb1000_open(struct net_device *dev) 933 - { 934 - char *name; 935 - int ioaddr[2], status; 936 - struct sb1000_private *lp = netdev_priv(dev); 937 - const unsigned short FirmwareVersion[] = {0x01, 0x01}; 938 - 939 - ioaddr[0] = dev->base_addr; 940 - /* mem_start holds the second I/O address */ 941 - ioaddr[1] = dev->mem_start; 942 - name = dev->name; 943 - 944 - /* initialize sb1000 */ 945 - if ((status = sb1000_reset(ioaddr, name))) 946 - return status; 947 - ssleep(1); 948 - if ((status = sb1000_check_CRC(ioaddr, name))) 949 - return status; 950 - 951 - /* initialize private data before board can catch interrupts */ 952 - lp->rx_skb[0] = NULL; 953 - lp->rx_skb[1] = NULL; 954 - lp->rx_skb[2] = NULL; 955 - lp->rx_skb[3] = NULL; 956 - lp->rx_dlen[0] = 0; 957 - lp->rx_dlen[1] = 0; 958 - lp->rx_dlen[2] = 0; 959 - lp->rx_dlen[3] = 0; 960 - lp->rx_frames = 0; 961 - lp->rx_error_count = 0; 962 - lp->rx_error_dpc_count = 0; 963 - lp->rx_session_id[0] = 0x50; 964 - lp->rx_session_id[1] = 0x48; 965 - lp->rx_session_id[2] = 0x44; 966 - lp->rx_session_id[3] = 0x42; 967 - lp->rx_frame_id[0] = 0; 968 - lp->rx_frame_id[1] = 0; 969 - lp->rx_frame_id[2] = 0; 970 - lp->rx_frame_id[3] = 0; 971 - if (request_irq(dev->irq, sb1000_interrupt, 0, "sb1000", dev)) { 972 - return -EAGAIN; 973 - } 974 - 975 - if (sb1000_debug > 2) 976 - printk(KERN_DEBUG "%s: Opening, IRQ %d\n", name, dev->irq); 977 - 978 - /* Activate board and check firmware version */ 979 - udelay(1000); 980 - if ((status = sb1000_activate(ioaddr, name))) 981 - return status; 982 - udelay(0); 983 - if ((status = sb1000_get_firmware_version(ioaddr, name, version, 0))) 984 - return status; 985 - if (version[0] != FirmwareVersion[0] || version[1] != FirmwareVersion[1]) 986 - printk(KERN_WARNING "%s: found firmware version %x.%02x " 987 - "(should be %x.%02x)\n", name, version[0], version[1], 988 - FirmwareVersion[0], FirmwareVersion[1]); 989 - 990 - 991 - netif_start_queue(dev); 992 - return 0; /* Always succeed */ 993 - } 994 - 995 - static int sb1000_siocdevprivate(struct net_device *dev, struct ifreq *ifr, 996 - void __user *data, int cmd) 997 - { 998 - char* name; 999 - unsigned char version[2]; 1000 - short PID[4]; 1001 - int ioaddr[2], status, frequency; 1002 - unsigned int stats[5]; 1003 - struct sb1000_private *lp = netdev_priv(dev); 1004 - 1005 - if (!(dev && dev->flags & IFF_UP)) 1006 - return -ENODEV; 1007 - 1008 - ioaddr[0] = dev->base_addr; 1009 - /* mem_start holds the second I/O address */ 1010 - ioaddr[1] = dev->mem_start; 1011 - name = dev->name; 1012 - 1013 - switch (cmd) { 1014 - case SIOCGCMSTATS: /* get statistics */ 1015 - stats[0] = dev->stats.rx_bytes; 1016 - stats[1] = lp->rx_frames; 1017 - stats[2] = dev->stats.rx_packets; 1018 - stats[3] = dev->stats.rx_errors; 1019 - stats[4] = dev->stats.rx_dropped; 1020 - if (copy_to_user(data, stats, sizeof(stats))) 1021 - return -EFAULT; 1022 - status = 0; 1023 - break; 1024 - 1025 - case SIOCGCMFIRMWARE: /* get firmware version */ 1026 - if ((status = sb1000_get_firmware_version(ioaddr, name, version, 1))) 1027 - return status; 1028 - if (copy_to_user(data, version, sizeof(version))) 1029 - return -EFAULT; 1030 - break; 1031 - 1032 - case SIOCGCMFREQUENCY: /* get frequency */ 1033 - if ((status = sb1000_get_frequency(ioaddr, name, &frequency))) 1034 - return status; 1035 - if (put_user(frequency, (int __user *)data)) 1036 - return -EFAULT; 1037 - break; 1038 - 1039 - case SIOCSCMFREQUENCY: /* set frequency */ 1040 - if (!capable(CAP_NET_ADMIN)) 1041 - return -EPERM; 1042 - if (get_user(frequency, (int __user *)data)) 1043 - return -EFAULT; 1044 - if ((status = sb1000_set_frequency(ioaddr, name, frequency))) 1045 - return status; 1046 - break; 1047 - 1048 - case SIOCGCMPIDS: /* get PIDs */ 1049 - if ((status = sb1000_get_PIDs(ioaddr, name, PID))) 1050 - return status; 1051 - if (copy_to_user(data, PID, sizeof(PID))) 1052 - return -EFAULT; 1053 - break; 1054 - 1055 - case SIOCSCMPIDS: /* set PIDs */ 1056 - if (!capable(CAP_NET_ADMIN)) 1057 - return -EPERM; 1058 - if (copy_from_user(PID, data, sizeof(PID))) 1059 - return -EFAULT; 1060 - if ((status = sb1000_set_PIDs(ioaddr, name, PID))) 1061 - return status; 1062 - /* set session_id, frame_id and pkt_type too */ 1063 - lp->rx_session_id[0] = 0x50 | (PID[0] & 0x0f); 1064 - lp->rx_session_id[1] = 0x48; 1065 - lp->rx_session_id[2] = 0x44; 1066 - lp->rx_session_id[3] = 0x42; 1067 - lp->rx_frame_id[0] = 0; 1068 - lp->rx_frame_id[1] = 0; 1069 - lp->rx_frame_id[2] = 0; 1070 - lp->rx_frame_id[3] = 0; 1071 - break; 1072 - 1073 - default: 1074 - status = -EINVAL; 1075 - break; 1076 - } 1077 - return status; 1078 - } 1079 - 1080 - /* transmit function: do nothing since SB1000 can't send anything out */ 1081 - static netdev_tx_t 1082 - sb1000_start_xmit(struct sk_buff *skb, struct net_device *dev) 1083 - { 1084 - printk(KERN_WARNING "%s: trying to transmit!!!\n", dev->name); 1085 - /* sb1000 can't xmit datagrams */ 1086 - dev_kfree_skb(skb); 1087 - return NETDEV_TX_OK; 1088 - } 1089 - 1090 - /* SB1000 interrupt handler. */ 1091 - static irqreturn_t sb1000_interrupt(int irq, void *dev_id) 1092 - { 1093 - static const unsigned char Command0[6] = {0x80, 0x2c, 0x00, 0x00, 0x00, 0x00}; 1094 - static const unsigned char Command1[6] = {0x80, 0x2e, 0x00, 0x00, 0x00, 0x00}; 1095 - 1096 - char *name; 1097 - unsigned char st; 1098 - int ioaddr[2]; 1099 - struct net_device *dev = dev_id; 1100 - struct sb1000_private *lp = netdev_priv(dev); 1101 - 1102 - const int MaxRxErrorCount = 6; 1103 - 1104 - ioaddr[0] = dev->base_addr; 1105 - /* mem_start holds the second I/O address */ 1106 - ioaddr[1] = dev->mem_start; 1107 - name = dev->name; 1108 - 1109 - /* is it a good interrupt? */ 1110 - st = inb(ioaddr[1] + 6); 1111 - if (!(st & 0x08 && st & 0x20)) { 1112 - return IRQ_NONE; 1113 - } 1114 - 1115 - if (sb1000_debug > 3) 1116 - printk(KERN_DEBUG "%s: entering interrupt\n", dev->name); 1117 - 1118 - st = inb(ioaddr[0] + 7); 1119 - if (sb1000_rx(dev)) 1120 - lp->rx_error_count++; 1121 - #ifdef SB1000_DELAY 1122 - udelay(SB1000_DELAY); 1123 - #endif /* SB1000_DELAY */ 1124 - sb1000_issue_read_command(ioaddr, name); 1125 - if (st & 0x01) { 1126 - sb1000_error_dpc(dev); 1127 - sb1000_issue_read_command(ioaddr, name); 1128 - } 1129 - if (lp->rx_error_dpc_count && !(--lp->rx_error_dpc_count)) { 1130 - sb1000_wait_for_ready_clear(ioaddr, name); 1131 - sb1000_send_command(ioaddr, name, Command0); 1132 - sb1000_wait_for_ready(ioaddr, name); 1133 - sb1000_issue_read_command(ioaddr, name); 1134 - } 1135 - if (lp->rx_error_count >= MaxRxErrorCount) { 1136 - sb1000_wait_for_ready_clear(ioaddr, name); 1137 - sb1000_send_command(ioaddr, name, Command1); 1138 - sb1000_wait_for_ready(ioaddr, name); 1139 - sb1000_issue_read_command(ioaddr, name); 1140 - lp->rx_error_count = 0; 1141 - } 1142 - 1143 - return IRQ_HANDLED; 1144 - } 1145 - 1146 - static int sb1000_close(struct net_device *dev) 1147 - { 1148 - int i; 1149 - int ioaddr[2]; 1150 - struct sb1000_private *lp = netdev_priv(dev); 1151 - 1152 - if (sb1000_debug > 2) 1153 - printk(KERN_DEBUG "%s: Shutting down sb1000.\n", dev->name); 1154 - 1155 - netif_stop_queue(dev); 1156 - 1157 - ioaddr[0] = dev->base_addr; 1158 - /* mem_start holds the second I/O address */ 1159 - ioaddr[1] = dev->mem_start; 1160 - 1161 - free_irq(dev->irq, dev); 1162 - /* If we don't do this, we can't re-insmod it later. */ 1163 - release_region(ioaddr[1], SB1000_IO_EXTENT); 1164 - release_region(ioaddr[0], SB1000_IO_EXTENT); 1165 - 1166 - /* free rx_skb's if needed */ 1167 - for (i=0; i<4; i++) { 1168 - if (lp->rx_skb[i]) { 1169 - dev_kfree_skb(lp->rx_skb[i]); 1170 - } 1171 - } 1172 - return 0; 1173 - } 1174 - 1175 - MODULE_AUTHOR("Franco Venturi <fventuri@mediaone.net>"); 1176 - MODULE_DESCRIPTION("General Instruments SB1000 driver"); 1177 - MODULE_LICENSE("GPL"); 1178 - 1179 - module_pnp_driver(sb1000_driver);
-23
include/uapi/linux/if_cablemodem.h
··· 1 - /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ 2 - #ifndef _LINUX_CABLEMODEM_H_ 3 - #define _LINUX_CABLEMODEM_H_ 4 - /* 5 - * Author: Franco Venturi <fventuri@mediaone.net> 6 - * Copyright 1998 Franco Venturi 7 - * 8 - * This program is free software; you can redistribute it 9 - * and/or modify it under the terms of the GNU General 10 - * Public License as published by the Free Software 11 - * Foundation; either version 2 of the License, or (at 12 - * your option) any later version. 13 - */ 14 - 15 - /* some useful defines for sb1000.c e cmconfig.c - fv */ 16 - #define SIOCGCMSTATS (SIOCDEVPRIVATE+0) /* get cable modem stats */ 17 - #define SIOCGCMFIRMWARE (SIOCDEVPRIVATE+1) /* get cm firmware version */ 18 - #define SIOCGCMFREQUENCY (SIOCDEVPRIVATE+2) /* get cable modem frequency */ 19 - #define SIOCSCMFREQUENCY (SIOCDEVPRIVATE+3) /* set cable modem frequency */ 20 - #define SIOCGCMPIDS (SIOCDEVPRIVATE+4) /* get cable modem PIDs */ 21 - #define SIOCSCMPIDS (SIOCDEVPRIVATE+5) /* set cable modem PIDs */ 22 - 23 - #endif