USB Devices

diff -Nru a/Documentation/00-INDEX b/Documentation/00-INDEX --- a/Documentation/00-INDEX Tue Mar 4 19:30:05 2003 +++ b/Documentation/00-INDEX Tue Mar 4 19:30:05 2003 @@ -56,6 +56,8 @@ - info on Computone Intelliport II/Plus Multiport Serial Driver cpqarray.txt - info on using Compaq's SMART2 Intelligent Disk Array Controllers. +cpufreq/ + - info on CPU frequency and voltage scaling cris/ - directory with info about Linux on CRIS architecture. devices.txt diff -Nru a/Documentation/DocBook/Makefile b/Documentation/DocBook/Makefile --- a/Documentation/DocBook/Makefile Tue Mar 4 19:30:08 2003 +++ b/Documentation/DocBook/Makefile Tue Mar 4 19:30:08 2003 @@ -11,7 +11,7 @@ kernel-locking.sgml via-audio.sgml mousedrivers.sgml \ deviceiobook.sgml procfs-guide.sgml tulip-user.sgml \ writing_usb_driver.sgml scsidrivers.sgml sis900.sgml \ - kernel-api.sgml journal-api.sgml lsm.sgml + kernel-api.sgml journal-api.sgml lsm.sgml usb.sgml ### # The build process is as follows (targets): diff -Nru a/Documentation/DocBook/deviceiobook.tmpl b/Documentation/DocBook/deviceiobook.tmpl --- a/Documentation/DocBook/deviceiobook.tmpl Tue Mar 4 19:30:08 2003 +++ b/Documentation/DocBook/deviceiobook.tmpl Tue Mar 4 19:30:08 2003 @@ -152,7 +152,7 @@ While the basic functions are defined to be synchronous with respect to each other and ordered with respect to each other the busses the - devices sit on may themselves have asynchronocity. In paticular many + devices sit on may themselves have asynchronicity. In particular many authors are burned by the fact that PCI bus writes are posted asynchronously. A driver author must issue a read from the same device to ensure that writes have occurred in the specific cases the diff -Nru a/Documentation/DocBook/kernel-api.tmpl b/Documentation/DocBook/kernel-api.tmpl --- a/Documentation/DocBook/kernel-api.tmpl Tue Mar 4 19:30:03 2003 +++ b/Documentation/DocBook/kernel-api.tmpl Tue Mar 4 19:30:03 2003 @@ -228,102 +228,6 @@ --> - - USB Devices - - Drivers for USB devices talk to the "usbcore" APIs, and are - exposed through driver frameworks such as block, character, - or network devices. - There are two types of public "usbcore" APIs: those intended for - general driver use, and those which are only public to drivers that - are part of the core. - The drivers that are part of the core are involved in managing a USB bus. - They include the "hub" driver, which manages trees of USB devices, and - several different kinds of "host controller" driver (HCD), which control - individual busses. - - - The device model seen by USB drivers is relatively complex. - - - - - USB supports four kinds of data transfer - (control, bulk, interrupt, and isochronous). Two transfer - types use bandwidth as it's available (control and bulk), - while the other two types of transfer (interrupt and isochronous) - are scheduled to provide guaranteed bandwidth. - - - The device description model includes one or more - "configurations" per device, only one of which is active at a time. - - - Configurations have one or more "interface", each - of which may have "alternate settings". Interfaces may be - standardized by USB "Class" specifications, or may be specific to - a vendor or device. - - USB device drivers actually bind to interfaces, not devices. - Think of them as "interface drivers", though you - may not see many devices where the distinction is important. - Most USB devices are simple, with only one configuration, - one interface, and one alternate setting. - - - Interfaces have one or more "endpoints", each of - which supports one type and direction of data transfer such as - "bulk out" or "interrupt in". The entire configuration may have - up to sixteen endpoints in each direction, allocated as needed - among all the interfaces. - - - Data transfer on USB is packetized; each endpoint - has a maximum packet size. - Drivers must often be aware of conventions such as flagging the end - of bulk transfers using "short" (including zero length) packets. - - - The Linux USB API supports synchronous calls for - control and bulk messaging. - It also supports asynchnous calls for all kinds of data transfer, - using request structures called "URBs" (USB Request Blocks). - - - - - Accordingly, the USB Core API exposed to device drivers - covers quite a lot of territory. You'll probably need to consult - the USB 2.0 specification, available online from www.usb.org at - no cost, as well as class or device specifications. - - - Data Types and Macros -!Iinclude/linux/usb.h - - - USB Core APIs -!Edrivers/usb/core/urb.c - -!Edrivers/usb/core/message.c -!Edrivers/usb/core/file.c -!Edrivers/usb/core/usb.c - - - Host Controller APIs - These APIs are only for use by host controller drivers, - most of which implement standard register interfaces such as - EHCI, OHCI, or UHCI. - -!Edrivers/usb/core/hcd.c -!Edrivers/usb/core/hcd-pci.c -!Edrivers/usb/core/buffer.c - - - - 16x50 UART Driver !Edrivers/serial/core.c diff -Nru a/Documentation/DocBook/parportbook.tmpl b/Documentation/DocBook/parportbook.tmpl --- a/Documentation/DocBook/parportbook.tmpl Tue Mar 4 19:30:04 2003 +++ b/Documentation/DocBook/parportbook.tmpl Tue Mar 4 19:30:04 2003 @@ -1149,7 +1149,7 @@ peripheral what transfer mode it would like to use, and the peripheral either accepts that mode or rejects it; if the mode is rejected, the host can try again with a different mode. This is - the negotation phase. Once the peripheral has accepted a + the negotiation phase. Once the peripheral has accepted a particular transfer mode, data transfer can begin that mode. diff -Nru a/Documentation/DocBook/usb.tmpl b/Documentation/DocBook/usb.tmpl --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/DocBook/usb.tmpl Tue Mar 4 19:30:14 2003 @@ -0,0 +1,294 @@ + + + + The Linux-USB Host Side API + + + + This documentation is free software; you can redistribute + it and/or modify it under the terms of the GNU General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later + version. + + + + This program is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + See the GNU General Public License for more details. + + + + You should have received a copy of the GNU General Public + License along with this program; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, + MA 02111-1307 USA + + + + For more details see the file COPYING in the source + distribution of Linux. + + + + + + + + Introduction to USB on Linux + + A Universal Serial Bus (USB) is used to connect a host, + such as a PC or workstation, to a number of peripheral + devices. USB uses a tree structure, with the host at the + root (the system's master), hubs as interior nodes, and + peripheral devices as leaves (and slaves). + Modern PCs support several such trees of USB devices, usually + one USB 2.0 tree (480 Mbit/sec each) with + a few USB 1.1 trees (12 Mbit/sec each) that are used when you + connect a USB 1.1 device directly to the machine's "root hub". + + + That master/slave asymmetry was designed in part for + ease of use. It is not physically possible to assemble + (legal) USB cables incorrectly: all upstream "to-the-host" + connectors are the rectangular type, matching the sockets on + root hubs, and the downstream type are the squarish type + (or they are built in to the peripheral). + Software doesn't need to deal with distributed autoconfiguration + since the pre-designated master node manages all that. + At the electrical level, bus protocol overhead is reduced by + eliminating arbitration and moving scheduling into host software. + + + USB 1.0 was announced in January 1996, and was revised + as USB 1.1 (with improvements in hub specification and + support for interrupt-out transfers) in September 1998. + USB 2.0 was released in April 2000, including high speed + transfers and transaction translating hubs (used for USB 1.1 + and 1.0 backward compatibility). + + + USB support was added to Linux early in the 2.2 kernel series + shortly before the 2.3 development forked off. Updates + from 2.3 were regularly folded back into 2.2 releases, bringing + new features such as /sbin/hotplug support, + more drivers, and more robustness. + The 2.5 kernel series continued such improvements, and also + worked on USB 2.0 support, + higher performance, + better consistency between host controller drivers, + API simplification (to make bugs less likely), + and providing internal "kerneldoc" documentation. + + + Linux can run inside USB devices as well as on + the hosts that control the devices. + Because the Linux 2.x USB support evolved to support mass market + platforms such as Apple Macintosh or PC-compatible systems, + it didn't address design concerns for those types of USB systems. + So it can't be used inside mass-market PDAs, or other peripherals. + USB device drivers running inside those Linux peripherals + don't do the same things as the ones running inside hosts, + and so they've been given a different name: + they're called gadget drivers. + This document does not present gadget drivers. + + + + + + USB Host-Side API Model + + Host-side drivers for USB devices talk to the "usbcore" APIs. + There are two types of public "usbcore" APIs, targetted at two different + layers of USB driver. Those are + general purpose drivers, exposed through + driver frameworks such as block, character, or network devices; + and drivers that are part of the core, + which are involved in managing a USB bus. + Such core drivers include the hub driver, + which manages trees of USB devices, and several different kinds + of host controller driver (HCD), + which control individual busses. + + + The device model seen by USB drivers is relatively complex. + + + + + USB supports four kinds of data transfer + (control, bulk, interrupt, and isochronous). Two transfer + types use bandwidth as it's available (control and bulk), + while the other two types of transfer (interrupt and isochronous) + are scheduled to provide guaranteed bandwidth. + + + The device description model includes one or more + "configurations" per device, only one of which is active at a time. + Devices that are capable of high speed operation must also support + full speed configurations, along with a way to ask about the + "other speed" configurations that might be used. + + + Configurations have one or more "interface", each + of which may have "alternate settings". Interfaces may be + standardized by USB "Class" specifications, or may be specific to + a vendor or device. + + USB device drivers actually bind to interfaces, not devices. + Think of them as "interface drivers", though you + may not see many devices where the distinction is important. + Most USB devices are simple, with only one configuration, + one interface, and one alternate setting. + + + Interfaces have one or more "endpoints", each of + which supports one type and direction of data transfer such as + "bulk out" or "interrupt in". The entire configuration may have + up to sixteen endpoints in each direction, allocated as needed + among all the interfaces. + + + Data transfer on USB is packetized; each endpoint + has a maximum packet size. + Drivers must often be aware of conventions such as flagging the end + of bulk transfers using "short" (including zero length) packets. + + + The Linux USB API supports synchronous calls for + control and bulk messaging. + It also supports asynchnous calls for all kinds of data transfer, + using request structures called "URBs" (USB Request Blocks). + + + + + Accordingly, the USB Core API exposed to device drivers + covers quite a lot of territory. You'll probably need to consult + the USB 2.0 specification, available online from www.usb.org at + no cost, as well as class or device specifications. + + + The only host-side drivers that actually touch hardware + (reading/writing registers, handling IRQs, and so on) are the HCDs. + In theory, all HCDs provide the same functionality through the same + API. In practice, that's becoming more true on the 2.5 kernels, + but there are still differences that crop up especially with + fault handling. Different controllers don't necessarily report + the same aspects of failures, and recovery from faults (including + software-induced ones like unlinking an URB) isn't yet fully + consistent. + Device driver authors should make a point of doing disconnect + testing (while the device is active) with each different host + controller driver, to make sure drivers don't have bugs of + their own as well as to make sure they aren't relying on some + HCD-specific behavior. + (You will need external USB 1.1 and/or + USB 2.0 hubs to perform all those tests.) + + + + +USB-Standard Types + + In <linux/usb_ch9.h> you will find + the USB data types defined in chapter 9 of the USB specification. + These data types are used throughout USB, and in APIs including + this host side API, gadget APIs, and usbfs. + + +!Iinclude/linux/usb_ch9.h + + + +Host-Side Data Types and Macros + + The host side API exposes several layers to drivers, some of + which are more necessary than others. + These support lifecycle models for host side drivers + and devices, and support passing buffers through usbcore to + some HCD that performs the I/O for the device driver. + + + +!Iinclude/linux/usb.h + + + + USB Core APIs + + There are two basic I/O models in the USB API. + The most elemental one is asynchronous: drivers submit requests + in the form of an URB, and the URB's completion callback + handle the next step. + All USB transfer types support that model, although there + are special cases for control URBs (which always have setup + and status stages, but may not have a data stage) and + isochronous URBs (which allow large packets and include + per-packet fault reports). + Built on top of that is synchronous API support, where a + driver calls a routine that allocates one or more URBs, + submits them, and waits until they complete. + There are synchronous wrappers for single-buffer control + and bulk transfers (which are awkward to use in some + driver disconnect scenarios), and for scatterlist based + streaming i/o (bulk or interrupt). + + + USB drivers need to provide buffers that can be + used for DMA, although they don't necessarily need to + provide the DMA mapping themselves. + There are APIs to use used when allocating DMA buffers, + which can prevent use of bounce buffers on some systems. + In some cases, drivers may be able to rely on 64bit DMA + to eliminate another kind of bounce buffer. + + +!Edrivers/usb/core/urb.c +!Edrivers/usb/core/message.c +!Edrivers/usb/core/file.c +!Edrivers/usb/core/usb.c + + + Host Controller APIs + + These APIs are only for use by host controller drivers, + most of which implement standard register interfaces such as + EHCI, OHCI, or UHCI. + UHCI was one of the first interfaces, designed by Intel and + also used by VIA; it doesn't do much in hardware. + OHCI was designed later, to have the hardware do more work + (bigger transfers, tracking protocol state, and so on). + EHCI was designed with USB 2.0; its design has features that + resemble OHCI (hardware does much more work) as well as + UHCI (some parts of ISO support, TD list processing). + + + There are host controllers other than the "big three", + although most PCI based controllers (and a few non-PCI based + ones) use one of those interfaces. + Not all host controllers use DMA; some use PIO, and there + is also a simulator. + + + The same basic APIs are available to drivers for all + those controllers. + For historical reasons they are in two layers: + struct usb_bus is a rather thin + layer that became available in the 2.2 kernels, while + struct usb_hcd is a more featureful + layer (available in later 2.4 kernels and in 2.5) that + lets HCDs share common code, to shrink driver size + and significantly reduce hcd-specific behaviors. + + +!Edrivers/usb/core/hcd.c +!Edrivers/usb/core/hcd-pci.c +!Edrivers/usb/core/buffer.c + + + + diff -Nru a/Documentation/arm/XScale/IOP310/IQ80310 b/Documentation/arm/XScale/IOP310/IQ80310 --- a/Documentation/arm/XScale/IOP310/IQ80310 Tue Mar 4 19:30:13 2003 +++ /dev/null Wed Dec 31 16:00:00 1969 @@ -1,295 +0,0 @@ - -Board Overview ------------------------------ - -The Cyclone IQ80310 board is an evaluation platform for Intel's 80200 Xscale -CPU and 80312 Intelligent I/O chipset (collectively called IOP310 chipset). - -The 80312 contains dual PCI hoses (called the ATUs), a PCI-to-PCI bridge, -three DMA channels (1 on secondary PCI, one on primary PCI ), I2C, I2O -messaging unit, XOR unit for RAID operations, a bus performance monitoring -unit, and a memory controller with ECC features. - -For more information on the board, see http://developer.intel.com/iio - -Port Status ------------------------------ - -Supported: - -- MTD/JFFS/JFFS2 -- NFS root -- RAMDISK root -- 2ndary PCI slots -- Onboard ethernet -- Serial ports (ttyS0/S1) -- Cache/TLB locking on 80200 CPU -- Performance monitoring unit on 80200 CPU -- 80200 Performance Monitoring Unit -- Acting as a system controller on Cyclone 80303BP PCI backplane -- DMA engines (EXPERIMENTAL) -- 80312 Bus Performance Monitor (EXPERIMENTAL) -- Application Accelerator Unit (XOR engine for RAID) (EXPERIMENTAL) -- Messaging Unit (EXPERIMENTAL) - -TODO: -- I2C - -Building the Kernel ------------------------------ -make iq80310_config -make oldconfig -make dep -make zImage - -This will build an image setup for BOOTP/NFS root support. To change this, -just run make menuconfig and disable nfs root or add a "root=" option. - -Preparing the Hardware ------------------------------ - -This document assumes you're using a Rev D or newer board running -Redboot as the bootloader. - -The as-supplied RedBoot image appears to leave the first page of RAM -in a corrupt state such that certain words in that page are unwritable -and contain random data. The value of the data, and the location within -the first page changes with each boot, but is generally in the range -0xa0000150 to 0xa0000fff. - -You can grab the source from the ECOS CVS or you can get a prebuilt image -from: - - ftp://source.mvista.com/pub/xscale/iop310/IQ80310/redboot.bin - -which is: - - # strings redboot.bin | grep bootstrap - RedBoot(tm) bootstrap and debug environment, version UNKNOWN - built 14:58:21, Aug 15 2001 - -md5sum of this version: - - bcb96edbc6f8e55b16c165930b6e4439 redboot.bin - -You have two options to program it: - -1. Using the FRU program (see the instructions in the user manual). - -2. Using a Linux host, with MTD support built into the host kernel: - - ensure that the RedBoot image is not locked (issue the following - command under the existing RedBoot image): - RedBoot> fis unlock -f 0 -l 0x40000 - - switch S3-1 and S3-2 on. - - reboot the host - - login as root - - identify the 80310 card: - # lspci - ... - 00:0c.1 Memory controller: Intel Corporation 80310 IOP [IO Processor] (rev 01) - - in this example, bus 0, slot 0c, function 1. - - insert the MTD modules, and the PCI map module: - # insmod drivers/mtd/maps/pci.o - - locate the MTD device (using the bus, slot, function) - # cat /proc/mtd - dev: size erasesize name - mtd0: 00800000 00020000 "00:0c.1" - - in this example, it is mtd device 0. Yours will be different. - Check carefully. - - program the flash - # cat redboot.bin > /dev/mtdblock0 - - check the kernel message log for errors (some cat commands don't - error on failure) - # dmesg - - switch S3-1 and S3-2 off - - reboot host - -In any case, make sure you do an 'fis init' command once you boot with the new -RedBoot image. - - - -Downloading Linux ------------------------------ - -Assuming you have your development system setup to act as a bootp/dhcp -server and running tftp: - - RedBoot> load -r -b 0xa1008000 /tftpboot/zImage.xs - Raw file loaded 0xa1008000-0xa1094bd8 - -If you're not using dhcp/tftp, you can use y-modem instead: - - RedBoot> load -r -b 0xa1008000 -m y - -Note that on Rev D. of the board, tftp does not work due to intermittent -interrupt issues, so you need to download using ymodem. - -Once the download is completed: - - RedBoot> go 0xa1008000 - -Root Devices ------------------------------ - -A kernel is not useful without a root filesystem, and you have several -choices with this board: NFS root, RAMDISK, or JFFS/JFFS2. For development -purposes, it is suggested that you use NFS root for easy access to various -tools. Once you're ready to deploy, probably want to utilize JFFS/JFFS2 on -the flash device. - -MTD on the IQ80310 ------------------------------ - -Linux on the IQ80310 supports RedBoot FIS paritioning if it is enabled. -Out of the box, once you've done 'fis init' on RedBoot, you will get -the following partitioning scheme: - - root@192.168.0.14:~# cat /proc/mtd - dev: size erasesize name - mtd0: 00040000 00020000 "RedBoot" - mtd1: 00040000 00020000 "RedBoot[backup]" - mtd2: 0075f000 00020000 "unallocated space" - mtd3: 00001000 00020000 "RedBoot config" - mtd4: 00020000 00020000 "FIS directory" - -To create an FIS directory, you need to use the fis command in RedBoot. -As an example, you can burn the kernel into the flash once it's downloaded: - - RedBoot> fis create -b 0xa1008000 -l 0x8CBAC -r 0xa1008000 -f 0x80000 kernel - ... Erase from 0x00080000-0x00120000: ..... - ... Program from 0xa1008000-0xa1094bac at 0x00080000: ..... - ... Unlock from 0x007e0000-0x00800000: . - ... Erase from 0x007e0000-0x00800000: . - ... Program from 0xa1fdf000-0xa1fff000 at 0x007e0000: . - ... Lock from 0x007e0000-0x00800000: . - - RedBoot> fis list - Name FLASH addr Mem addr Length Entry point - RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 - RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 - RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 - FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 - kernel 0x00080000 0xA1008000 0x000A0000 0x00000000 - -This leads to the following Linux MTD setup: - - mtroot@192.168.0.14:~# cat /proc/mtd - dev: size erasesize name - mtd0: 00040000 00020000 "RedBoot" - mtd1: 00040000 00020000 "RedBoot[backup]" - mtd2: 000a0000 00020000 "kernel" - mtd3: 006bf000 00020000 "unallocated space" - mtd4: 00001000 00020000 "RedBoot config" - mtd5: 00020000 00020000 "FIS directory" - -Note that there is not a 1:1 mapping to the number of RedBoot paritions to -MTD partitions as unused space also gets allocated into MTD partitions. - -As an aside, the -r option when creating the Kernel entry allows you to -simply do an 'fis load kernel' to copy the image from flash into memory. -You can then do an 'fis go 0xa1008000' to start Linux. - -If you choose to use static partitioning instead of the RedBoot partioning: - - /dev/mtd0 0x00000000 - 0x0007ffff: Boot Monitor (512k) - /dev/mtd1 0x00080000 - 0x0011ffff: Kernel Image (640K) - /dev/mtd2 0x00120000 - 0x0071ffff: File System (6M) - /dev/mtd3 0x00720000 - 0x00800000: RedBoot Reserved (896K) - -To use a JFFS1/2 root FS, you need to donwload the JFFS image using either -tftp or ymodem, and then copy it to flash: - - RedBoot> load -r -b 0xa1000000 /tftpboot/jffs.img - Raw file loaded 0xa1000000-0xa1600000 - RedBoot> fis create -b 0xa1000000 -l 0x600000 -f 0x120000 jffs - ... Erase from 0x00120000-0x00720000: .................................. - ... Program from 0xa1000000-0xa1600000 at 0x00120000: .................. - ...................... - ... Unlock from 0x007e0000-0x00800000: . - ... Erase from 0x007e0000-0x00800000: . - ... Program from 0xa1fdf000-0xa1fff000 at 0x007e0000: . - ... Lock from 0x007e0000-0x00800000: . - RedBoot> fis list - Name FLASH addr Mem addr Length Entry point - RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 - RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 - RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 - FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 - kernel 0x00080000 0xA1008000 0x000A0000 0xA1008000 - jffs 0x00120000 0x00120000 0x00600000 0x00000000 - -This looks like this in Linux: - - root@192.168.0.14:~# cat /proc/mtd - dev: size erasesize name - mtd0: 00040000 00020000 "RedBoot" - mtd1: 00040000 00020000 "RedBoot[backup]" - mtd2: 000a0000 00020000 "kernel" - mtd3: 00600000 00020000 "jffs" - mtd4: 000bf000 00020000 "unallocated space" - mtd5: 00001000 00020000 "RedBoot config" - mtd6: 00020000 00020000 "FIS directory" - -You need to boot the kernel once and watch the boot messages to see how the -JFFS RedBoot partition mapped into the MTD partition scheme. - -You can grab a pre-built JFFS image to use as a root file system at: - - ftp://source.mvista.com/pub/xscale/iop310/IQ80310/jffs.img - -For detailed info on using MTD and creating a JFFS image go to: - - http://www.linux-mtd.infradead.org. - -For details on using RedBoot's FIS commands, type 'fis help' or consult -your RedBoot manual. - -Contributors ------------------------------ - -Thanks to Intel Corporation for providing the hardware. - -John Clark - Initial discovery of RedBoot issues -Dave Jiang - IRQ demux fixes, AAU, DMA, MU -Nicolas Pitre - Initial port, cleanup, debugging -Matt Porter - PCI subsystem development, debugging -Tim Sanders - Initial PCI code -Mark Salter - RedBoot fixes -Deepak Saxena - Cleanup, debug, cache lock, PMU - ------------------------------ -Enjoy. - -If you have any problems please contact Deepak Saxena - -A few notes from rmk ------------------------------ - -These are notes of my initial experience getting the IQ80310 Rev D up and -running. In total, it has taken many hours to work out what's going on... -The version of redboot used is: - - RedBoot(tm) bootstrap and debug environment, version UNKNOWN - built 14:58:21, Aug 15 2001 - - -1. I've had a corrupted download of the redboot.bin file from Montavista's - FTP site. It would be a good idea if there were md5sums, sum or gpg - signatures available to ensure the integrity of the downloaded files. - The result of this was an apparantly 100% dead card. - -2. RedBoot Intel EtherExpress Pro 100 driver seems to be very unstable - - I've had it take out the whole of a 100mbit network for several minutes. - The Hub indiates ZERO activity, despite machines attempting to communicate. - Further to this, while tftping the kernel, the transfer will stall regularly, - and might even drop the link LED. - -3. There appears to be a bug in the Intel Documentation Pack that comes with - the IQ80310 board. Serial port 1, which is the socket next to the LEDs - is address 0xfe810000, not 0xfe800000. - - Note that RedBoot uses either serial port 1 OR serial port 2, so if you - have your console connected to the wrong port, you'll see redboot messages - but not kernel boot messages. - -4. Trying to use fconfig to setup a boot script fails - it hangs when trying - to erase the flash. diff -Nru a/Documentation/arm/XScale/IOP3XX/IQ80310 b/Documentation/arm/XScale/IOP3XX/IQ80310 --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/IQ80310 Tue Mar 4 19:30:13 2003 @@ -0,0 +1,248 @@ + +Board Overview +----------------------------- + +The Cyclone IQ80310 board is an evaluation platform for Intel's 80200 Xscale +CPU and 80312 Intelligent I/O chipset (collectively called IOP310 chipset). + +The 80312 contains dual PCI hoses (called the ATUs), a PCI-to-PCI bridge, +three DMA channels (1 on secondary PCI, one on primary PCI ), I2C, I2O +messaging unit, XOR unit for RAID operations, a bus performance monitoring +unit, and a memory controller with ECC features. + +For more information on the board, see http://developer.intel.com/iio + +Port Status +----------------------------- + +Supported: + +- MTD/JFFS/JFFS2 +- NFS root +- RAMDISK root +- 2ndary PCI slots +- Onboard ethernet +- Serial ports (ttyS0/S1) +- Cache/TLB locking on 80200 CPU +- Performance monitoring unit on 80200 CPU +- 80200 Performance Monitoring Unit +- Acting as a system controller on Cyclone 80303BP PCI backplane +- DMA engines (EXPERIMENTAL) +- 80312 Bus Performance Monitor (EXPERIMENTAL) +- Application Accelerator Unit (XOR engine for RAID) (EXPERIMENTAL) +- Messaging Unit (EXPERIMENTAL) + +TODO: +- I2C + +Building the Kernel +----------------------------- +make iq80310_config +make oldconfig +make dep +make zImage + +This will build an image setup for BOOTP/NFS root support. To change this, +just run make menuconfig and disable nfs root or add a "root=" option. + +Preparing the Hardware +----------------------------- + +This document assumes you're using a Rev D or newer board running +Redboot as the bootloader. Note that the version of RedBoot provided +with the boards has a major issue and you need to replace it with the +latest RedBoot. You can grab the source from the ECOS CVS or you can +get a prebuilt image and burn it in using FRU at: + + ftp://source.mvista.com/pub/xscale/iq80310/redboot.bin + +Make sure you do an 'fis init' command once you boot with the new +RedBoot image. + + + +Downloading Linux +----------------------------- + +Assuming you have your development system setup to act as a bootp/dhcp +server and running tftp: + + RedBoot> load -r -b 0xa1008000 /tftpboot/zImage.xs + Raw file loaded 0xa1008000-0xa1094bd8 + +If you're not using dhcp/tftp, you can use y-modem instead: + + RedBoot> load -r -b 0xa1008000 -m y + +Note that on Rev D. of the board, tftp does not work due to intermittent +interrupt issues, so you need to download using ymodem. + +Once the download is completed: + + RedBoot> go 0xa1008000 + +Root Devices +----------------------------- + +A kernel is not useful without a root filesystem, and you have several +choices with this board: NFS root, RAMDISK, or JFFS/JFFS2. For development +purposes, it is suggested that you use NFS root for easy access to various +tools. Once you're ready to deploy, probably want to utilize JFFS/JFFS2 on +the flash device. + +MTD on the IQ80310 +----------------------------- + +Linux on the IQ80310 supports RedBoot FIS paritioning if it is enabled. +Out of the box, once you've done 'fis init' on RedBoot, you will get +the following partitioning scheme: + + root@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 0075f000 00020000 "unallocated space" + mtd3: 00001000 00020000 "RedBoot config" + mtd4: 00020000 00020000 "FIS directory" + +To create an FIS directory, you need to use the fis command in RedBoot. +As an example, you can burn the kernel into the flash once it's downloaded: + + RedBoot> fis create -b 0xa1008000 -l 0x8CBAC -r 0xa1008000 -f 0x80000 kernel + ... Erase from 0x00080000-0x00120000: ..... + ... Program from 0xa1008000-0xa1094bac at 0x00080000: ..... + ... Unlock from 0x007e0000-0x00800000: . + ... Erase from 0x007e0000-0x00800000: . + ... Program from 0xa1fdf000-0xa1fff000 at 0x007e0000: . + ... Lock from 0x007e0000-0x00800000: . + + RedBoot> fis list + Name FLASH addr Mem addr Length Entry point + RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 + RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 + RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 + FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 + kernel 0x00080000 0xA1008000 0x000A0000 0x00000000 + +This leads to the following Linux MTD setup: + + mtroot@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 000a0000 00020000 "kernel" + mtd3: 006bf000 00020000 "unallocated space" + mtd4: 00001000 00020000 "RedBoot config" + mtd5: 00020000 00020000 "FIS directory" + +Note that there is not a 1:1 mapping to the number of RedBoot paritions to +MTD partitions as unused space also gets allocated into MTD partitions. + +As an aside, the -r option when creating the Kernel entry allows you to +simply do an 'fis load kernel' to copy the image from flash into memory. +You can then do an 'fis go 0xa1008000' to start Linux. + +If you choose to use static partitioning instead of the RedBoot partioning: + + /dev/mtd0 0x00000000 - 0x0007ffff: Boot Monitor (512k) + /dev/mtd1 0x00080000 - 0x0011ffff: Kernel Image (640K) + /dev/mtd2 0x00120000 - 0x0071ffff: File System (6M) + /dev/mtd3 0x00720000 - 0x00800000: RedBoot Reserved (896K) + +To use a JFFS1/2 root FS, you need to donwload the JFFS image using either +tftp or ymodem, and then copy it to flash: + + RedBoot> load -r -b 0xa1000000 /tftpboot/jffs.img + Raw file loaded 0xa1000000-0xa1600000 + RedBoot> fis create -b 0xa1000000 -l 0x600000 -f 0x120000 jffs + ... Erase from 0x00120000-0x00720000: .................................. + ... Program from 0xa1000000-0xa1600000 at 0x00120000: .................. + ...................... + ... Unlock from 0x007e0000-0x00800000: . + ... Erase from 0x007e0000-0x00800000: . + ... Program from 0xa1fdf000-0xa1fff000 at 0x007e0000: . + ... Lock from 0x007e0000-0x00800000: . + RedBoot> fis list + Name FLASH addr Mem addr Length Entry point + RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 + RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 + RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 + FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 + kernel 0x00080000 0xA1008000 0x000A0000 0xA1008000 + jffs 0x00120000 0x00120000 0x00600000 0x00000000 + +This looks like this in Linux: + + root@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 000a0000 00020000 "kernel" + mtd3: 00600000 00020000 "jffs" + mtd4: 000bf000 00020000 "unallocated space" + mtd5: 00001000 00020000 "RedBoot config" + mtd6: 00020000 00020000 "FIS directory" + +You need to boot the kernel once and watch the boot messages to see how the +JFFS RedBoot partition mapped into the MTD partition scheme. + +You can grab a pre-built JFFS image to use as a root file system at: + + ftp://source.mvista.com/pub/xscale/iq80310/jffs.img + +For detailed info on using MTD and creating a JFFS image go to: + + http://www.linux-mtd.infradead.org. + +For details on using RedBoot's FIS commands, type 'fis help' or consult +your RedBoot manual. + +Contributors +----------------------------- + +Thanks to Intel Corporation for providing the hardware. + +John Clark - Initial discovery of RedBoot issues +Dave Jiang - IRQ demux fixes, AAU, DMA, MU +Nicolas Pitre - Initial port, cleanup, debugging +Matt Porter - PCI subsystem development, debugging +Tim Sanders - Initial PCI code +Mark Salter - RedBoot fixes +Deepak Saxena - Cleanup, debug, cache lock, PMU + +----------------------------- +Enjoy. + +If you have any problems please contact Deepak Saxena + +A few notes from rmk +----------------------------- + +These are notes of my initial experience getting the IQ80310 Rev D up and +running. In total, it has taken many hours to work out what's going on... +The version of redboot used is: + + RedBoot(tm) bootstrap and debug environment, version UNKNOWN - built 14:58:21, Aug 15 2001 + + +1. I've had a corrupted download of the redboot.bin file from Montavista's + FTP site. It would be a good idea if there were md5sums, sum or gpg + signatures available to ensure the integrity of the downloaded files. + The result of this was an apparantly 100% dead card. + +2. RedBoot Intel EtherExpress Pro 100 driver seems to be very unstable - + I've had it take out the whole of a 100mbit network for several minutes. + The Hub indiates ZERO activity, despite machines attempting to communicate. + Further to this, while tftping the kernel, the transfer will stall regularly, + and might even drop the link LED. + +3. There appears to be a bug in the Intel Documentation Pack that comes with + the IQ80310 board. Serial port 1, which is the socket next to the LEDs + is address 0xfe810000, not 0xfe800000. + + Note that RedBoot uses either serial port 1 OR serial port 2, so if you + have your console connected to the wrong port, you'll see redboot messages + but not kernel boot messages. + +4. Trying to use fconfig to setup a boot script fails - it hangs when trying + to erase the flash. diff -Nru a/Documentation/arm/XScale/IOP3XX/IQ80321 b/Documentation/arm/XScale/IOP3XX/IQ80321 --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/IQ80321 Tue Mar 4 19:30:14 2003 @@ -0,0 +1,216 @@ + +Board Overview +----------------------------- + +The Worcester IQ80321 board is an evaluation platform for Intel's 80321 Xscale +CPU (sometimes called IOP321 chipset). + +The 80321 contains a single PCI hose (called the ATUs), a PCI-to-PCI bridge, +two DMA channels, I2C, I2O messaging unit, XOR unit for RAID operations, +a bus performance monitoring unit, and a memory controller with ECC features. + +For more information on the board, see http://developer.intel.com/iio + +Port Status +----------------------------- + +Supported: + +- MTD/JFFS/JFFS2 root +- NFS root +- RAMDISK root +- Serial port (ttyS0) +- Cache/TLB locking on 80321 CPU +- Performance monitoring unit on 80321 CPU + +TODO: + +- DMA engines +- I2C +- 80321 Bus Performance Monitor +- Application Accelerator Unit (XOR engine for RAID) +- I2O Messaging Unit +- I2C unit +- SSP + +Building the Kernel +----------------------------- +make iq80321_config +make oldconfig +make dep +make zImage + +This will build an image setup for BOOTP/NFS root support. To change this, +just run make menuconfig and disable nfs root or add a "root=" option. + +Preparing the Hardware +----------------------------- + +Make sure you do an 'fis init' command once you boot with the new +RedBoot image. + +Downloading Linux +----------------------------- + +Assuming you have your development system setup to act as a bootp/dhcp +server and running tftp: + +NOTE: The 80321 board uses a different default memory map than the 80310. + + RedBoot> load -r -b 0x01008000 -m y + +Once the download is completed: + + RedBoot> go 0x01008000 + +There is a version of RedBoot floating around that has DHCP support, but +I've never been able to cleanly transfer a kernel image and have it run. + +Root Devices +----------------------------- + +A kernel is not useful without a root filesystem, and you have several +choices with this board: NFS root, RAMDISK, or JFFS/JFFS2. For development +purposes, it is suggested that you use NFS root for easy access to various +tools. Once you're ready to deploy, probably want to utilize JFFS/JFFS2 on +the flash device. + +MTD on the IQ80321 +----------------------------- + +Linux on the IQ80321 supports RedBoot FIS paritioning if it is enabled. +Out of the box, once you've done 'fis init' on RedBoot, you will get +the following partitioning scheme: + + root@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 0075f000 00020000 "unallocated space" + mtd3: 00001000 00020000 "RedBoot config" + mtd4: 00020000 00020000 "FIS directory" + +To create an FIS directory, you need to use the fis command in RedBoot. +As an example, you can burn the kernel into the flash once it's downloaded: + + RedBoot> fis create -b 0x01008000 -l 0x8CBAC -r 0x01008000 -f 0x80000 kernel + ... Erase from 0x00080000-0x00120000: ..... + ... Program from 0x01008000-0x01094bac at 0x00080000: ..... + ... Unlock from 0x007e0000-0x00800000: . + ... Erase from 0x007e0000-0x00800000: . + ... Program from 0x01fdf000-0x01fff000 at 0x007e0000: . + ... Lock from 0x007e0000-0x00800000: . + + RedBoot> fis list + Name FLASH addr Mem addr Length Entry point + RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 + RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 + RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 + FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 + kernel 0x00080000 0x01008000 0x000A0000 0x00000000 + +This leads to the following Linux MTD setup: + + mtroot@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 000a0000 00020000 "kernel" + mtd3: 006bf000 00020000 "unallocated space" + mtd4: 00001000 00020000 "RedBoot config" + mtd5: 00020000 00020000 "FIS directory" + +Note that there is not a 1:1 mapping to the number of RedBoot paritions to +MTD partitions as unused space also gets allocated into MTD partitions. + +As an aside, the -r option when creating the Kernel entry allows you to +simply do an 'fis load kernel' to copy the image from flash into memory. +You can then do an 'fis go 0x01008000' to start Linux. + +If you choose to use static partitioning instead of the RedBoot partioning: + + /dev/mtd0 0x00000000 - 0x0007ffff: Boot Monitor (512k) + /dev/mtd1 0x00080000 - 0x0011ffff: Kernel Image (640K) + /dev/mtd2 0x00120000 - 0x0071ffff: File System (6M) + /dev/mtd3 0x00720000 - 0x00800000: RedBoot Reserved (896K) + +To use a JFFS1/2 root FS, you need to donwload the JFFS image using either +tftp or ymodem, and then copy it to flash: + + RedBoot> load -r -b 0x01000000 /tftpboot/jffs.img + Raw file loaded 0x01000000-0x01600000 + RedBoot> fis create -b 0x01000000 -l 0x600000 -f 0x120000 jffs + ... Erase from 0x00120000-0x00720000: .................................. + ... Program from 0x01000000-0x01600000 at 0x00120000: .................. + ...................... + ... Unlock from 0x007e0000-0x00800000: . + ... Erase from 0x007e0000-0x00800000: . + ... Program from 0x01fdf000-0x01fff000 at 0x007e0000: . + ... Lock from 0x007e0000-0x00800000: . + RedBoot> fis list + Name FLASH addr Mem addr Length Entry point + RedBoot 0x00000000 0x00000000 0x00040000 0x00000000 + RedBoot[backup] 0x00040000 0x00040000 0x00040000 0x00000000 + RedBoot config 0x007DF000 0x007DF000 0x00001000 0x00000000 + FIS directory 0x007E0000 0x007E0000 0x00020000 0x00000000 + kernel 0x00080000 0x01008000 0x000A0000 0x01008000 + jffs 0x00120000 0x00120000 0x00600000 0x00000000 + +This looks like this in Linux: + + root@192.168.0.14:~# cat /proc/mtd + dev: size erasesize name + mtd0: 00040000 00020000 "RedBoot" + mtd1: 00040000 00020000 "RedBoot[backup]" + mtd2: 000a0000 00020000 "kernel" + mtd3: 00600000 00020000 "jffs" + mtd4: 000bf000 00020000 "unallocated space" + mtd5: 00001000 00020000 "RedBoot config" + mtd6: 00020000 00020000 "FIS directory" + +You need to boot the kernel once and watch the boot messages to see how the +JFFS RedBoot partition mapped into the MTD partition scheme. + +You can grab a pre-built JFFS image to use as a root file system at: + + ftp://source.mvista.com/pub/xscale/iq80310/jffs.img + +For detailed info on using MTD and creating a JFFS image go to: + + http://www.linux-mtd.infradead.org. + +For details on using RedBoot's FIS commands, type 'fis help' or consult +your RedBoot manual. + +BUGS and ISSUES +----------------------------- + +* As shipped from Intel, pre-production boards have two issues: + +- The on board ethernet is disabled S8E1-2 is off. You will need to turn it on. + +- The PCIXCAPs are configured for a 100Mhz clock, but the clock selected is + actually only 66Mhz. This causes the wrong PPL multiplier to be used and the + board only runs at 400Mhz instead of 600Mhz. The way to observe this is to + use a independent clock to time a "sleep 10" command from the prompt. If it + takes 15 seconds instead of 10, you are running at 400Mhz. + +- The experimental IOP310 drivers for the AAU, DMA, etc. are not supported yet. + +Contributors +----------------------------- +The port to the IQ80321 was performed by: + +Rory Bolt - Initial port, debugging. + +This port was based on the IQ80310 port with the following contributors: + +Nicolas Pitre - Initial port, cleanup, debugging +Matt Porter - PCI subsystem development, debugging +Tim Sanders - Initial PCI code +Deepak Saxena - Cleanup, debug, cache lock, PMU + +The port is currently maintained by Deepak Saxena + +----------------------------- +Enjoy. diff -Nru a/Documentation/arm/XScale/IOP3XX/aau.txt b/Documentation/arm/XScale/IOP3XX/aau.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/aau.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,178 @@ +Support functions for the Intel 80310 AAU +=========================================== + +Dave Jiang +Last updated: 09/18/2001 + +The Intel 80312 companion chip in the 80310 chipset contains an AAU. The +AAU is capable of processing up to 8 data block sources and perform XOR +operations on them. This unit is typically used to accelerated XOR +operations utilized by RAID storage device drivers such as RAID 5. This +API is designed to provide a set of functions to take adventage of the +AAU. The AAU can also be used to transfer data blocks and used as a memory +copier. The AAU transfer the memory faster than the operation performed by +using CPU copy therefore it is recommended to use the AAU for memory copy. + +------------------ +int aau_request(u32 *aau_context, const char *device_id); +This function allows the user the acquire the control of the the AAU. The +function will return a context of AAU to the user and allocate +an interrupt for the AAU. The user must pass the context as a parameter to +various AAU API calls. + +int aau_queue_buffer(u32 aau_context, aau_head_t *listhead); +This function starts the AAU operation. The user must create a SGL +header with a SGL attached. The format is presented below. The SGL is +built from kernel memory. + +/* hardware descriptor */ +typedef struct _aau_desc +{ + u32 NDA; /* next descriptor address [READONLY] */ + u32 SAR[AAU_SAR_GROUP]; /* src addrs */ + u32 DAR; /* destination addr */ + u32 BC; /* byte count */ + u32 DC; /* descriptor control */ + u32 SARE[AAU_SAR_GROUP]; /* extended src addrs */ +} aau_desc_t; + +/* user SGL format */ +typedef struct _aau_sgl +{ + aau_desc_t aau_desc; /* AAU HW Desc */ + u32 status; /* status of SGL [READONLY] */ + struct _aau_sgl *next; /* pointer to next SG [READONLY] */ + void *dest; /* destination addr */ + void *src[AAU_SAR_GROUP]; /* source addr[4] */ + void *ext_src[AAU_SAR_GROUP]; /* ext src addr[4] */ + u32 total_src; /* total number of source */ +} aau_sgl_t; + +/* header for user SGL */ +typedef struct _aau_head +{ + u32 total; /* total descriptors allocated */ + u32 status; /* SGL status */ + aau_sgl_t *list; /* ptr to head of list */ + aau_callback_t callback; /* callback func ptr */ +} aau_head_t; + + +The function will call aau_start() and start the AAU after it queues +the SGL to the processing queue. When the function will either +a. Sleep on the wait queue aau->wait_q if no callback has been provided, or +b. Continue and then call the provided callback function when DMA interrupt + has been triggered. + +int aau_suspend(u32 aau_context); +Stops/Suspends the AAU operation + +int aau_free(u32 aau_context); +Frees the ownership of AAU. Called when no longer need AAU service. + +aau_sgl_t * aau_get_buffer(u32 aau_context, int num_buf); +This function obtains an AAU SGL for the user. User must specify the number +of descriptors to be allocated in the chain that is returned. + +void aau_return_buffer(u32 aau_context, aau_sgl_t *list); +This function returns all SGL back to the API after user is done. + +int aau_memcpy(void *dest, void *src, u32 size); +This function is a short cut for user to do memory copy utilizing the AAU for +better large block memory copy vs using the CPU. This is similar to using +typical memcpy() call. + +* User is responsible for the source address(es) and the destination address. + The source and destination should all be cached memory. + + + +void aau_test() +{ + u32 aau; + char dev_id[] = "AAU"; + int size = 2; + int err = 0; + aau_head_t *head; + aau_sgl_t *list; + u32 i; + u32 result = 0; + void *src, *dest; + + printk("Starting AAU test\n"); + if((err = aau_request(&aau, dev_id))<0) + { + printk("test - AAU request failed: %d\n", err); + return; + } + else + { + printk("test - AAU request successful\n"); + } + + head = kmalloc(sizeof(aau_head_t), GFP_KERNEL); + head->total = size; + head->status = 0; + head->callback = NULL; + + list = aau_get_buffer(aau, size); + if(!list) + { + printk("Can't get buffers\n"); + return; + } + head->list = list; + + src = kmalloc(1024, GFP_KERNEL); + dest = kmalloc(1024, GFP_KERNEL); + + while(list) + { + list->status = 0; + list->aau_desc->SAR[0] = (u32)src; + list->aau_desc->DAR = (u32)dest; + list->aau_desc->BC = 1024; + + /* see iop310-aau.h for more DCR commands */ + list->aau_desc->DC = AAU_DCR_WRITE | AAU_DCR_BLKCTRL_1_DF; + if(!list->next) + { + list->aau_desc->DC = AAU_DCR_IE; + break; + } + list = list->next; + } + + printk("test- Queueing buffer for AAU operation\n"); + err = aau_queue_buffer(aau, head); + if(err >= 0) + { + printk("AAU Queue Buffer is done...\n"); + } + else + { + printk("AAU Queue Buffer failed...: %d\n", err); + } + + + +#if 1 + printk("freeing the AAU\n"); + aau_return_buffer(aau, head->list); + aau_free(aau); + kfree(src); + kfree(dest); + kfree((void *)head); +#endif +} + +All Disclaimers apply. Use this at your own discretion. Neither Intel nor I +will be responsible if anything goes wrong. =) + + +TODO +____ +* Testing +* Do zero-size AAU transfer/channel at init + so all we have to do is chainining + diff -Nru a/Documentation/arm/XScale/IOP3XX/dma.txt b/Documentation/arm/XScale/IOP3XX/dma.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/dma.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,214 @@ +Support functions forthe Intel 80310 DMA channels +================================================== + +Dave Jiang +Last updated: 09/18/2001 + +The Intel 80310 XScale chipset provides 3 DMA channels via the 80312 I/O +companion chip. Two of them resides on the primary PCI bus and one on the +secondary PCI bus. + +The DMA API provided is not compatible with the generic interface in the +ARM tree unfortunately due to how the 80312 DMACs work. Hopefully some time +in the near future a software interface can be done to bridge the differences. +The DMA API has been modeled after Nicholas Pitre's SA11x0 DMA API therefore +they will look somewhat similar. + + +80310 DMA API +------------- + +int dma_request(dmach_t channel, const char *device_id); + +This function will attempt to allocate the channel depending on what the +user requests: + +IOP310_DMA_P0: PCI Primary 1 +IOP310_DMA_P1: PCI Primary 2 +IOP310_DMA_S0: PCI Secondary 1 +/*EOF*/ + +Once the user allocates the DMA channel it is owned until released. Although +other users can also use the same DMA channel, but no new resources will be +allocated. The function will return the allocated channel number if successful. + +int dma_queue_buffer(dmach_t channel, dma_sghead_t *listhead); + +The user will construct a SGL in the form of below: +/* + * Scattered Gather DMA List for user + */ +typedef struct _dma_desc +{ + u32 NDAR; /* next descriptor adress [READONLY] */ + u32 PDAR; /* PCI address */ + u32 PUADR; /* upper PCI address */ + u32 LADR; /* local address */ + u32 BC; /* byte count */ + u32 DC; /* descriptor control */ +} dma_desc_t; + +typedef struct _dma_sgl +{ + dma_desc_t dma_desc; /* DMA descriptor */ + u32 status; /* descriptor status [READONLY] */ + u32 data; /* user defined data */ + struct _dma_sgl *next; /* next descriptor [READONLY] */ +} dma_sgl_t; + +/* dma sgl head */ +typedef struct _dma_head +{ + u32 total; /* total elements in SGL */ + u32 status; /* status of sgl */ + u32 mode; /* read or write mode */ + dma_sgl_t *list; /* pointer to list */ + dma_callback_t callback; /* callback function */ +} dma_head_t; + + +The user shall allocate user SGL elements by calling the function: +dma_get_buffer(). This function will give the user an SGL element. The user +is responsible for creating the SGL head however. The user is also +responsible for allocating the memory for DMA data. The following code segment +shows how a DMA operation can be performed: + +#include + +void dma_test(void) +{ + char dev_id[] = "Primary 0"; + dma_head_t *sgl_head = NULL; + dma_sgl_t *sgl = NULL; + int err = 0; + int channel = -1; + u32 *test_ptr = 0; + DECLARE_WAIT_QUEUE_HEAD(wait_q); + + + *(IOP310_ATUCR) = (IOP310_ATUCR_PRIM_OUT_ENAB | + IOP310_ATUCR_DIR_ADDR_ENAB); + + channel = dma_request(IOP310_DMA_P0, dev_id); + + sgl_head = (dma_head_t *)kmalloc(sizeof(dma_head_t), GFP_KERNEL); + sgl_head->callback = NULL; /* no callback created */ + sgl_head->total = 2; /* allocating 2 DMA descriptors */ + sgl_head->mode = (DMA_MOD_WRITE); + sgl_head->status = 0; + + /* now we get the two descriptors */ + sgl = dma_get_buffer(channel, 2); + + /* we set the header to point to the list we allocated */ + sgl_head->list = sgl; + + /* allocate 1k of DMA data */ + sgl->data = (u32)kmalloc(1024, GFP_KERNEL); + + /* Local address is physical */ + sgl->dma_desc.LADR = (u32)virt_to_phys(sgl->data); + + /* write to arbitrary location over the PCI bus */ + sgl->dma_desc.PDAR = 0x00600000; + sgl->dma_desc.PUADR = 0; + sgl->dma_desc.BC = 1024; + + /* set write & invalidate PCI command */ + sgl->dma_desc.DC = DMA_DCR_PCI_MWI; + sgl->status = 0; + + /* set a pattern */ + memset(sgl->data, 0xFF, 1024); + + /* User's responsibility to keep buffers cached coherent */ + cpu_dcache_clean(sgl->data, sgl->data + 1024); + + sgl = sgl->next; + + sgl->data = (u32)kmalloc(1024, GFP_KERNEL); + sgl->dma_desc.LADR = (u32)virt_to_phys(sgl->data); + sgl->dma_desc.PDAR = 0x00610000; + sgl->dma_desc.PUADR = 0; + sgl->dma_desc.BC = 1024; + + /* second descriptor has interrupt flag enabled */ + sgl->dma_desc.DC = (DMA_DCR_PCI_MWI | DMA_DCR_IE); + + /* must set end of chain flag */ + sgl->status = DMA_END_CHAIN; /* DO NOT FORGET THIS!!!! */ + + memset(sgl->data, 0x0f, 1024); + /* User's responsibility to keep buffers cached coherent */ + cpu_dcache_clean(sgl->data, sgl->data + 1024); + + /* queing the buffer, this function will sleep since no callback */ + err = dma_queue_buffer(channel, sgl_head); + + /* now we are woken from DMA complete */ + + /* do data operations here */ + + /* free DMA data if necessary */ + + /* return the descriptors */ + dma_return_buffer(channel, sgl_head->list); + + /* free the DMA */ + dma_free(channel); + + kfree((void *)sgl_head); +} + + +dma_sgl_t * dma_get_buffer(dmach_t channel, int buf_num); + +This call allocates DMA descriptors for the user. + + +void dma_return_buffer(dmach_t channel, dma_sgl_t *list); + +This call returns the allocated descriptors back to the API. + + +int dma_suspend(dmach_t channel); + +This call suspends any DMA transfer on the given channel. + + + +int dma_resume(dmach_t channel); + +This call resumes a DMA transfer which would have been stopped through +dma_suspend(). + + +int dma_flush_all(dmach_t channel); + +This completely flushes all queued buffers and on-going DMA transfers on a +given channel. This is called when DMA channel errors have occured. + + +void dma_free(dmach_t channel); + +This clears all activities on a given DMA channel and releases it for future +requests. + + + +Buffer Allocation +----------------- +It is the user's responsibility to allocate, free, and keep track of the +allocated DMA data memory. Upon calling dma_queue_buffer() the user must +relinquish the control of the buffers to the kernel and not change the +state of the buffers that it has passed to the kernel. The user will regain +the control of the buffers when it has been woken up by the bottom half of +the DMA interrupt handler. The user can allocate cached buffers or non-cached +via pci_alloc_consistent(). It is the user's responsibility to ensure that +the data is cache coherent. + +*Reminder* +The user is responsble to ensure the ATU is setup properly for DMA transfers. + +All Disclaimers apply. Use this at your own discretion. Neither Intel nor I +will be responsible ifanything goes wrong. diff -Nru a/Documentation/arm/XScale/IOP3XX/message.txt b/Documentation/arm/XScale/IOP3XX/message.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/message.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,110 @@ +Support functions for the Intel 80310 MU +=========================================== + +Dave Jiang +Last updated: 10/11/2001 + +The messaging unit of the IOP310 contains 4 components and is utilized for +passing messages between the PCI agents on the primary bus and the Intel(R) +80200 CPU. The four components are: +Messaging Component +Doorbell Component +Circular Queues Component +Index Registers Component + +Messaging Component: +Contains 4 32bit registers, 2 in and 2 out. Writing to the registers assert +interrupt on the PCI bus or to the 80200 depend on incoming or outgoing. + +int mu_msg_request(u32 *mu_context); +Request the usage of Messaging Component. mu_context is written back by the +API. The MU context is passed to other Messaging calls as a parameter. + +int mu_msg_set_callback(u32 mu_context, u8 reg, mu_msg_cb_t func); +Setup the callback function for incoming messages. Callback can be setup for +outbound 0, 1, or both outbound registers. + +int mu_msg_post(u32 mu_context, u32 val, u8 reg); +Posting a message in the val parameter. The reg parameter denotes whether +to use register 0, 1. + +int mu_msg_free(u32 mu_context, u8 mode); +Free the usage of messaging component. mode can be specified soft or hard. In +hardmode all resources are unallocated. + +Doorbell Component: +The doorbell registers contains 1 inbound and 1 outbound. Depending on the bits +being set different interrupts are asserted. + +int mu_db_request(u32 *mu_context); +Request the usage of the doorbell register. + +int mu_db_set_callback(u32 mu_context, mu_db_cb_t func); +Setting up the inbound callback. + +void mu_db_ring(u32 mu_context, u32 mask); +Write to the outbound db register with mask. + +int mu_db_free(u32 mu_context); +Free the usage of doorbell component. + +Circular Queues Component: +The circular queue component has 4 circular queues. Inbound post, inbound free, +outbound post, outbound free. These queues are used to pass messages. + +int mu_cq_request(u32 *mu_context, u32 q_size); +Request the usage of the queue. See code comment header for q_size. It tells +the API how big of queues to setup. + +int mu_cq_inbound_init(u32 mu_context, mfa_list_t *list, u32 size, + mu_cq_cb_t func); +Init inbound queues. The user must provide a list of free message frames to +be put in inbound free queue and the callback function to handle the inbound +messages. + +int mu_cq_enable(u32 mu_context); +Enables the circular queues mechanism. Called once all the setup functions +are called. + +u32 mu_cq_get_frame(u32 mu_context); +Obtain the address of an outbound free frame for the user. + +int mu_cq_post_frame(u32 mu_context, u32 mfa); +The user can post the frame once getting the frame and put information in the +frame. + +int mu_cq_free(u32 mu_context); +Free the usage of circular queues mechanism. + +Index Registers Component: +The index register provides the mechanism to receive inbound messages. + +int mu_ir_request(u32 *mu_context); +Request of Index Register component usage. + +int mu_ir_set_callback(u32 mu_context, mu_ir_cb_t callback); +Setting up callback for inbound messages. The callback will receive the +value of the register that IAR offsets to. + +int mu_ir_free(u32 mu_context); +Free the usage of Index Registers component. + +void mu_set_irq_threshold(u32 mu_context, int thresh); +Setup the IRQ threshold before relinquish processing in IRQ space. Default +is set at 10 loops. + + +*NOTE: Example of host driver that utilize the MU can be found in the Linux I2O +driver. Specifically i2o_pci and some functions of i2o_core. The I2O driver +only utilize the circular queues mechanism. The other 3 components are simple +enough that they can be easily setup. The MU API provides no flow control for +the messaging mechanism. Flow control of the messaging needs to be established +by a higher layer of software on the IOP or the host driver. + +All Disclaimers apply. Use this at your own discretion. Neither Intel nor I +will be responsible if anything goes wrong. =) + + +TODO +____ + diff -Nru a/Documentation/arm/XScale/IOP3XX/pmon.txt b/Documentation/arm/XScale/IOP3XX/pmon.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/IOP3XX/pmon.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,71 @@ + +Intel's XScale Microarchitecture 80312 companion processor provides a +Performance Monitoring Unit (PMON) that can be utilized to provide +information that can be useful for fine tuning of code. This text +file describes the API that's been developed for use by Linux kernel +programmers. Note that to get the most usage out of the PMON, +I highly reccomend getting the XScale reference manual from Intel[1] +and looking at chapter 12. + +To use the PMON, you must #include in your +source file. + +Since there's only one PMON, only one user can currently use the PMON +at a given time. To claim the PMON for usage, call iop310_pmon_claim() which +returns an identifier. When you are done using the PMON, call +iop310_pmon_release() with the id you were given earlier. + +The PMON consists of 14 registers that can be used for performance measurements. +By combining different statistics, you can derive complex performance metrics. + +To start the PMON, just call iop310_pmon_start(mode). Mode tells the PMON what +statistics to capture and can each be one of: + + IOP310_PMU_MODE0 + Performance Monitoring Disabled + + IOP310_PMU_MODE1 + Primary PCI bus and internal agents (bridge, dma Ch0, dam Ch1, patu) + + IOP310_PMU_MODE2 + Secondary PCI bus and internal agents (bridge, dma Ch0, dam Ch1, patu) + + IOP310_PMU_MODE3 + Secondary PCI bus and internal agents (external masters 0..2 and Intel + 80312 I/O companion chip) + + IOP310_PMU_MODE4 + Secondary PCI bus and internal agents (external masters 3..5 and Intel + 80312 I/O companion chip) + + IOP310_PMU_MODE5 + Intel 80312 I/O companion chip internal bus, DMA Channels and Application + Accelerator + + IOP310_PMU_MODE6 + Intel 80312 I/O companion chip internal bus, PATU, SATU and Intel 80200 + processor + + IOP310_PMU_MODE7 + Intel 80312 I/O companion chip internal bus, Primary PCI bus, Secondary + PCI bus and Secondary PCI agents (external masters 0..5 & Intel 80312 I/O + companion chip) + +To get the results back, call iop310_pmon_stop(&results) where results is +defined as follows: + +typedef struct _iop310_pmon_result +{ + u32 timestamp; /* Global Time Stamp Register */ + u32 timestamp_overflow; /* Time Stamp overflow count */ + u32 event_count[14]; /* Programmable Event Counter + Registers 1-14 */ + u32 event_overflow[14]; /* Overflow counter for PECR1-14 */ +} iop310_pmon_res_t; + + +-- +This code is still under development, so please feel free to send patches, +questions, comments, etc to me. + +Deepak Saxena diff -Nru a/Documentation/arm/XScale/cache-lock.txt b/Documentation/arm/XScale/cache-lock.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/cache-lock.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,123 @@ + +Intel's XScale Microarchitecture provides support for locking of data +and instructions into the appropriate caches. This file provides +an overview of the API that has been developed to take advantage of this +feature from kernel space. Note that there is NO support for user space +cache locking. + +For example usage of this code, grab: + + ftp://source.mvista.com/pub/xscale/cache-test.c + +If you have any questions, comments, patches, etc, please contact me. + +Deepak Saxena + +API DESCRIPTION + + +I. Header File + + #include + +II. Cache Capability Discovery + + SYNOPSIS + + int cache_query(u8 cache_type, + struct cache_capabilities *pcache); + + struct cache_capabilities + { + u32 flags; /* Flags defining capabilities */ + u32 cache_size; /* Cache size in K (1024 bytes) */ + u32 max_lock; /* Maximum lockable region in K */ + } + + /* + * Flags + */ + + /* + * Bit 0: Cache lockability + * Bits 1-31: Reserved for future use + */ + #define CACHE_LOCKABLE 0x00000001 /* Cache can be locked */ + + /* + * Cache Types + */ + #define ICACHE 0x00 + #define DCACHE 0x01 + + DESCRIPTION + + This function fills out the pcache capability identifier for the + requested cache. cache_type is either DCACHE or ICACHE. This + function is not very useful at the moment as all XScale CPU's + have the same size Cache, but is is provided for future XScale + based processors that may have larger cache sizes. + + RETURN VALUE + + This function returns 0 if no error occurs, otherwise it returns + a negative, errno compatible value. + + -EIO Unknown hardware error + +III. Cache Locking + + SYNOPSIS + + int cache_lock(void *addr, u32 len, u8 cache_type, const char *desc); + + DESCRIPTION + + This function locks a physically contigous portion of memory starting + at the virtual address pointed to by addr into the cache referenced + by cache_type. + + The address of the data/instruction that is to be locked must be + aligned on a cache line boundary (L1_CACHE_ALIGNEMENT). + + The desc parameter is an optional (pass NULL if not used) human readable + descriptor of the locked memory region that is used by the cache + management code to build the /proc/cache_locks table. + + Note that this function does not check whether the address is valid + or not before locking it into the cache. That duty is up to the + caller. Also, it does not check for duplicate or overlaping + entries. + + RETURN VALUE + + If the function is successful in locking the entry into cache, a + zero is returned. + + If an error occurs, an appropriate error value is returned. + + -EINVAL The memory address provided was not cache line aligned + -ENOMEM Could not allocate memory to complete operation + -ENOSPC Not enough space left on cache to lock in requested region + -EIO Unknown error + +III. Cache Unlocking + + SYNOPSIS + + int cache_unlock(void *addr) + + DESCRIPTION + + This function unlocks a portion of memory that was previously locked + into either the I or D cache. + + RETURN VALUE + + If the entry is cleanly unlocked from the cache, a 0 is returned. + In the case of an error, an appropriate error is returned. + + -ENOENT No entry with given address associated with this cache + -EIO Unknown error + + diff -Nru a/Documentation/arm/XScale/pmu.txt b/Documentation/arm/XScale/pmu.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/pmu.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,168 @@ + +Intel's XScale Microarchitecture processors provide a Performance +Monitoring Unit (PMU) that can be utilized to provide information +that can be useful for fine tuning of code. This text file describes +the API that's been developed for use by Linux kernel programmers. +When I have some extra time on my hand, I will extend the code to +provide support for user mode performance monitoring (which is +probably much more useful). Note that to get the most usage out +of the PMU, I highly reccomend getting the XScale reference manual +from Intel and looking at chapter 12. + +To use the PMU, you must #include in your source file. + +Since there's only one PMU, only one user can currently use the PMU +at a given time. To claim the PMU for usage, call pmu_claim() which +returns an identifier. When you are done using the PMU, call +pmu_release() with the identifier that you were given by pmu_claim. + +In addition, the PMU can only be used on XScale based systems that +provide an external timer. Systems that the PMU is currently supported +on are: + + - Cyclone IQ80310 + +Before delving into how to use the PMU code, let's do a quick overview +of the PMU itself. The PMU consists of three registers that can be +used for performance measurements. The first is the CCNT register with +provides the number of clock cycles elapsed since the PMU was started. +The next two register, PMN0 and PMN1, are eace user programmable to +provide 1 of 20 different performance statistics. By combining different +statistics, you can derive complex performance metrics. + +To start the PMU, just call pmu_start(pm0, pmn1). pmn0 and pmn1 tell +the PMU what statistics to capture and can each be one of: + +EVT_ICACHE_MISS + Instruction fetches requiring access to external memory + +EVT_ICACHE_NO_DELIVER + Instruction cache could not deliver an instruction. Either an + ICACHE miss or an instruction TLB miss. + +EVT_ICACHE_DATA_STALL + Stall in execution due to a data dependency. This counter is + incremented each cycle in which the condition is present. + +EVT_ITLB_MISS + Instruction TLB miss + +EVT_DTLB_MISS + Data TLB miss + +EVT_BRANCH + A branch instruction was executed and it may or may not have + changed program flow + +EVT_BRANCH_MISS + A branch (B or BL instructions only) was mispredicted + +EVT_INSTRUCTION + An instruction was executed + +EVT_DCACHE_FULL_STALL + Stall because data cache buffers are full. Incremented on every + cycle in which condition is present. + +EVT_DCACHE_FULL_STALL_CONTIG + Stall because data cache buffers are full. Incremented on every + cycle in which condition is contigous. + +EVT_DCACHE_ACCESS + Data cache access (data fetch) + +EVT_DCACHE_MISS + Data cache miss + +EVT_DCACHE_WRITE_BACK + Data cache write back. This counter is incremented for every + 1/2 line (four words) that are written back. + +EVT_PC_CHANGED + Software changed the PC. This is incremented only when the + software changes the PC and there is no mode change. For example, + a MOV instruction that targets the PC would increment the counter. + An SWI would not as it triggers a mode change. + +EVT_BCU_REQUEST + The Bus Control Unit(BCU) received a request from the core + +EVT_BCU_FULL + The BCU request queue if full. A high value for this event means + that the BCU is often waiting for to complete on the external bus. + +EVT_BCU_DRAIN + The BCU queues were drained due to either a Drain Write Buffer + command or an I/O transaction for a page that was marked as + uncacheable and unbufferable. + +EVT_BCU_ECC_NO_ELOG + The BCU detected an ECC error on the memory bus but noe ELOG + register was available to to log the errors. + +EVT_BCU_1_BIT_ERR + The BCU detected a 1-bit error while reading from the bus. + +EVT_RMW + An RMW cycle occurred due to narrow write on ECC protected memory. + +To get the results back, call pmu_stop(&results) where results is defined +as a struct pmu_results: + + struct pmu_results + { + u32 ccnt; /* Clock Counter Register */ + u32 ccnt_of; / + u32 pmn0; /* Performance Counter Register 0 */ + u32 pmn0_of; + u32 pmn1; /* Performance Counter Register 1 */ + u32 pmn1_of; + }; + +Pretty simple huh? Following are some examples of how to get some commonly +wanted numbers out of the PMU data. Note that since you will be dividing +things, this isn't super useful from the kernel and you need to printk the +data out to syslog. See [1] for more examples. + +Instruction Cache Efficiency + + pmu_start(EVT_INSTRUCTION, EVT_ICACHE_MISS); + ... + pmu_stop(&results); + + icache_miss_rage = results.pmn1 / results.pmn0; + cycles_per_instruction = results.ccnt / results.pmn0; + +Data Cache Efficiency + + pmu_start(EVT_DCACHE_ACCESS, EVT_DCACHE_MISS); + ... + pmu_stop(&results); + + dcache_miss_rage = results.pmn1 / results.pmn0; + +Instruction Fetch Latency + + pmu_start(EVT_ICACHE_NO_DELIVER, EVT_ICACHE_MISS); + ... + pmu_stop(&results); + + average_stall_waiting_for_instruction_fetch = + results.pmn0 / results.pmn1; + + percent_stall_cycles_due_to_instruction_fetch = + results.pmn0 / results.ccnt; + + +ToDo: + +- Add support for usermode PMU usage. This might require hooking into + the scheduler so that we pause the PMU when the task that requested + statistics is scheduled out. + +-- +This code is still under development, so please feel free to send patches, +questions, comments, etc to me. + +Deepak Saxena + diff -Nru a/Documentation/arm/XScale/tlb-lock.txt b/Documentation/arm/XScale/tlb-lock.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/arm/XScale/tlb-lock.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,64 @@ + +Intel's XScale Microarchitecture provides support for locking of TLB +entries in both the instruction and data TLBs. This file provides +an overview of the API that has been developed to take advantage of this +feature from kernel space. Note that there is NO support for user space. + +In general, this feature should be used in conjunction with locking +data or instructions into the appropriate caches. See the file +cache-lock.txt in this directory. + +If you have any questions, comments, patches, etc, please contact me. + +Deepak Saxena + + +API DESCRIPTION + +I. Header file + + #include + +II. Locking an entry into the TLB + + SYNOPSIS + + xscale_tlb_lock(u8 tlb_type, u32 addr); + + /* + * TLB types + */ + #define ITLB 0x0 + #define DTLB 0x1 + + DESCRIPTION + + This function locks the virtual to physical mapping for virtual + address addr into the requested TLB. + + RETURN VALUE + + If the entry is properly locked into the TLB, a 0 is returned. + In case of an error, an appropriate error is returned. + + -ENOSPC No more entries left in the TLB + -EIO Unknown error + +III. Unlocking an entry from a TLB + + SYNOPSIS + + xscale_tlb_unlock(u8 tlb_type, u32 addr); + + DESCRIPTION + + This function unlocks the entry for virtual address addr from the + specified cache. + + RETURN VALUE + + If the TLB entry is properly unlocked, a 0 is returned. + In case of an error, an appropriate error is returned. + + -ENOENT No entry for given address in specified TLB + diff -Nru a/Documentation/block/biodoc.txt b/Documentation/block/biodoc.txt --- a/Documentation/block/biodoc.txt Tue Mar 4 19:30:12 2003 +++ b/Documentation/block/biodoc.txt Tue Mar 4 19:30:12 2003 @@ -1038,7 +1038,7 @@ in fact all queues get unplugged as a side-effect. Aside: - This is kind of controversial territory, as its not clear if plugging is + This is kind of controversial territory, as it's not clear if plugging is always the right thing to do. Devices typically have their own queues, and allowing a big queue to build up in software, while letting the device be idle for a while may not always make sense. The trick is to handle the fine diff -Nru a/Documentation/cpu-freq/core.txt b/Documentation/cpu-freq/core.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/cpu-freq/core.txt Tue Mar 4 19:30:12 2003 @@ -0,0 +1,90 @@ + CPU frequency and voltage scaling code in the Linux(TM) kernel + + + L i n u x C P U F r e q + + C P U F r e q C o r e + + + Dominik Brodowski + David Kimdon + + + + Clock scaling allows you to change the clock speed of the CPUs on the + fly. This is a nice method to save battery power, because the lower + the clock speed, the less power the CPU consumes. + + +Contents: +--------- +1. CPUFreq core and interfaces +2. CPUFreq notifiers + +1. General Information +======================= + +The CPUFreq core code is located in linux/kernel/cpufreq.c. This +cpufreq code offers a standardized interface for the CPUFreq +architecture drivers (those pieces of code that do actual +frequency transitions), as well as to "notifiers". These are device +drivers or other part of the kernel that need to be informed of +policy changes (ex. thermal modules like ACPI) or of all +frequency changes (ex. timing code) or even need to force certain +speed limits (like LCD drivers on ARM architecture). Additionally, the +kernel "constant" loops_per_jiffy is updated on frequency changes +here. + + +2. CPUFreq notifiers +==================== + +CPUFreq notifiers conform to the standard kernel notifier interface. +See linux/include/linux/notifier.h for details on notifiers. + +There are two different CPUFreq notifiers - policy notifiers and +transition notifiers. + + +2.1 CPUFreq policy notifiers +---------------------------- + +These are notified when a new policy is intended to be set. Each +CPUFreq policy notifier is called three times for a policy transition: + +1.) During CPUFREQ_ADJUST all CPUFreq notifiers may change the limit if + they see a need for this - may it be thermal considerations or + hardware limitations. + +2.) During CPUFREQ_INCOMPATIBLE only changes may be done in order to avoid + hardware failure. + +3.) And during CPUFREQ_NOTIFY all notifiers are informed of the new policy + - if two hardware drivers failed to agree on a new policy before this + stage, the incompatible hardware shall be shut down, and the user + informed of this. + +The phase is specified in the second argument to the notifier. + +The third argument, a void *pointer, points to a struct cpufreq_policy +consisting of five values: cpu, min, max, policy and max_cpu_freq. min +and max are the lower and upper frequencies (in kHz) of the new +policy, policy the new policy, cpu the number of the affected CPU or +CPUFREQ_ALL_CPUS for all CPUs; and max_cpu_freq the maximum supported +CPU frequency. This value is given for informational purposes only. + + +2.2 CPUFreq transition notifiers +-------------------------------- + +These are notified twice when the CPUfreq driver switches the CPU core +frequency and this change has any external implications. + +The second argument specifies the phase - CPUFREQ_PRECHANGE or +CPUFREQ_POSTCHANGE. + +The third argument is a struct cpufreq_freqs with the following +values: +cpu - number of the affected CPU or CPUFREQ_ALL_CPUS +old - old frequency +new - new frequency diff -Nru a/Documentation/cpu-freq/cpu-drivers.txt b/Documentation/cpu-freq/cpu-drivers.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/cpu-freq/cpu-drivers.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,207 @@ + CPU frequency and voltage scaling code in the Linux(TM) kernel + + + L i n u x C P U F r e q + + C P U D r i v e r s + + - information for developers - + + + Dominik Brodowski + + + + Clock scaling allows you to change the clock speed of the CPUs on the + fly. This is a nice method to save battery power, because the lower + the clock speed, the less power the CPU consumes. + + +Contents: +--------- +1. What To Do? +1.1 Initialization +1.2 Per-CPU Initialization +1.3 verify +1.4 target or setpolicy? +1.5 target +1.6 setpolicy +2. Frequency Table Helpers + + + +1. What To Do? +============== + +So, you just got a brand-new CPU / chipset with datasheets and want to +add cpufreq support for this CPU / chipset? Great. Here are some hints +on what is neccessary: + + +1.1 Initialization +------------------ + +First of all, in an __initcall level 7 or later (preferrably +module_init() so that your driver is modularized) function check +whether this kernel runs on the right CPU and the right chipset. If +so, register a struct cpufreq_driver with the CPUfreq core using +cpufreq_register_driver() + +What shall this struct cpufreq_driver contain? + +cpufreq_driver.name - The name of this driver. + +cpufreq_driver.init - A pointer to the per-CPU initialization + function. + +cpufreq_driver.verify - A pointer to a "verfication" funciton. + +cpufreq_driver.setpolicy _or_ +cpufreq_driver.target - See below on the differences. + +And optionally + +cpufreq_driver.exit - A pointer to a per-CPU cleanup function. + + + +1.2 Per-CPU Initialization +-------------------------- + +Whenever a new CPU is registered with the device model, or after the +cpufreq driver registers itself, the per-CPU initialization fucntion +cpufreq_driver.init is called. It takes a struct cpufreq_policy +*policy as argument. What to do now? + +If necessary, activate the CPUfreq support on your CPU (unlock that +register etc.). + +Then, the driver must fill in the following values: + +policy->cpuinfo.min_freq _and_ +policy->cpuinfo.max_freq - the minimum and maximum frequency + (in kHz) which is supported by + this CPU +policy->cpuinfo.transition_latency the time it takes on this CPU to + switch between two frequencies (if + appropriate, else specify + CPUFREQ_ETERNAL) + +policy->cur The current operating frequency of + this CPU (if appropriate) +policy->min, +policy->max, +policy->policy and, if neccessary, +policy->governor must contain the "default policy" for + this CPU. A few moments later, + cpufreq_driver.verify and either + cpufreq_driver.setpolicy or + cpufreq_driver.target is called with + these values. + +For setting some of these values, the frequency table helpers might be +helpful. See the section 2 for more information on them. + + +1.3 verify +------------ + +When the user decides a new policy (consisting of +"policy,governor,min,max") shall be set, this policy must be validated +so that incompatible values can be corrected. For verifying these +values, a frequency table helper and/or the +cpufreq_verify_within_limits(struct cpufreq_policy *policy, unsigned +int min_freq, unsigned int max_freq) function might be helpful. See +section 2 for details on frequency table helpers. + +You need to make sure that at least one valid frequency (or operating +range) is within policy->min and policy->max. If necessary, increase +policy->max fist, and only if this is no solution, decreas policy->min. + + +1.4 target or setpolicy? +---------------------------- + +Most cpufreq drivers or even most cpu frequency scaling algorithms +only allow the CPU to be set to one frequency. For these, you use the +->target call. + +Some cpufreq-capable processors switch the frequency between certain +limits on their own. These shall use the ->setpolicy call + + +1.4. target +------------- + +The target call has three arguments: struct cpufreq_policy *policy, +unsigned int target_frequency, unsigned int relation. + +The CPUfreq driver must set the new frequency when called here. The +actual frequency must be determined using the following rules: + +- keep close to "target_freq" +- policy->min <= new_freq <= policy->max (THIS MUST BE VALID!!!) +- if relation==CPUFREQ_REL_L, try to select a new_freq higher than or equal + target_freq. ("L for lowest, but no lower than") +- if relation==CPUFREQ_REL_H, try to select a new_freq lower than or equal + target_freq. ("H for highest, but no higher than") + +Here again the frequency table helper might assist you - see section 3 +for details. + + +1.5 setpolicy +--------------- + +The setpolicy call only takes a struct cpufreq_policy *policy as +argument. You need to set the lower limit of the in-processor or +in-chipset dynamic frequency switching to policy->min, the upper limit +to policy->max, and -if supported- select a performance-oriented +setting when policy->policy is CPUFREQ_POLICY_PERFORMANCE, and a +powersaving-oriented setting when CPUFREQ_POLICY_POWERSAVE. Also check +the reference implementation in arch/i386/kernel/cpu/cpufreq/longrun.c + + + +2. Frequency Table Helpers +========================== + +As most cpufreq processors only allow for being set to a few specific +frequencies, a "frequency table" with some functions might assist in +some work of the processor driver. Such a "frequency table" consists +of an array of struct cpufreq_freq_table entries, with any value in +"index" you want to use, and the corresponding frequency in +"frequency". At the end of the table, you need to add a +cpufreq_freq_table entry with frequency set to CPUFREQ_TABLE_END. And +if you want to skip one entry in the table, set the frequency to +CPUFREQ_ENTRY_INVALID. The entries don't need to be in ascending +order. + +By calling cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy, + struct cpufreq_frequency_table *table); +the cpuinfo.min_freq and cpuinfo.max_freq values are detected, and +policy->min and policy->max are set to the same values. This is +helpful for the per-CPU initialization stage. + +int cpufreq_frequency_table_verify(struct cpufreq_policy *policy, + struct cpufreq_frequency_table *table); +assures that at least one valid frequency is within policy->min and +policy->max, and all other criteria are met. This is helpful for the +->verify call. + +int cpufreq_frequency_table_target(struct cpufreq_policy *policy, + struct cpufreq_frequency_table *table, + unsigned int target_freq, + unsigned int relation, + unsigned int *index); + +is the corresponding frequency table helper for the ->target +stage. Just pass the values to this function, and the unsigned int +index returns the number of the frequency table entry which contains +the frequency the CPU shall be set to. PLEASE NOTE: This is not the +"index" which is in this cpufreq_table_entry.index, but instead +cpufreq_table[index]. So, the new frequency is +cpufreq_table[index].frequency, and the value you stored into the +frequency table "index" field is +cpufreq_table[index].index. + diff -Nru a/Documentation/cpu-freq/governors.txt b/Documentation/cpu-freq/governors.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/cpu-freq/governors.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,155 @@ + CPU frequency and voltage scaling code in the Linux(TM) kernel + + + L i n u x C P U F r e q + + C P U F r e q G o v e r n o r s + + - information for users and developers - + + + Dominik Brodowski + + + + Clock scaling allows you to change the clock speed of the CPUs on the + fly. This is a nice method to save battery power, because the lower + the clock speed, the less power the CPU consumes. + + +Contents: +--------- +1. What is a CPUFreq Governor? + +2. Governors In the Linux Kernel +2.1 Performance +2.2 Powersave +2.3 Userspace + +3. The Governor Interface in the CPUfreq Core + + + +1. What Is A CPUFreq Governor? +============================== + +Most cpufreq drivers (in fact, all except one, longrun) or even most +cpu frequency scaling algorithms only offer the CPU to be set to one +frequency. In order to offer dynamic frequency scaling, the cpufreq +core must be able to tell these drivers of a "target frequency". So +these specific drivers will be transformed to offer a "->target" +call instead of the existing "->setpolicy" call. For "longrun", all +stays the same, though. + +How to decide what frequency within the CPUfreq policy should be used? +That's done using "cpufreq governors". Two are already in this patch +-- they're the already existing "powersave" and "performance" which +set the frequency statically to the lowest or highest frequency, +respectively. At least two more such governors will be ready for +addition in the near future, but likely many more as there are various +different theories and models about dynamic frequency scaling +around. Using such a generic interface as cpufreq offers to scaling +governors, these can be tested extensively, and the best one can be +selected for each specific use. + +Basically, it's the following flow graph: + +CPU can be set to switch independetly | CPU can only be set + within specific "limits" | to specific frequencies + + "CPUfreq policy" + consists of frequency limits (policy->{min,max}) + and CPUfreq governor to be used + / \ + / \ + / the cpufreq governor decides + / (dynamically or statically) + / what target_freq to set within + / the limits of policy->{min,max} + / \ + / \ + Using the ->setpolicy call, Using the ->target call, + the limits and the the frequency closest + "policy" is set. to target_freq is set. + It is assured that it + is within policy->{min,max} + + +2. Governors In the Linux Kernel +================================ + +2.1 Performance +--------------- + +The CPUfreq governor "performance" sets the CPU statically to the +highest frequency within the borders of scaling_min_freq and +scaling_max_freq. + + +2.1 Powersave +------------- + +The CPUfreq governor "powersave" sets the CPU statically to the +lowest frequency within the borders of scaling_min_freq and +scaling_max_freq. + + +2.2 Userspace +------------- + +The CPUfreq governor "userspace" allows the user, or any userspace +program running with UID "root", to set the CPU to a specifc frequency +by making a sysfs file "scaling_setspeed" available in the CPU-device +directory. + + + +3. The Governor Interface in the CPUfreq Core +============================================= + +A new governor must register itself with the CPUfreq core using +"cpufreq_register_governor". The struct cpufreq_governor, which has to +be passed to that function, must contain the following values: + +governor->name - A unique name for this governor +governor->governor - The governor callback function +governor->owner - .THIS_MODULE for the governor module (if + appropriate) + +The governor->governor callback is called with the current (or to-be-set) +cpufreq_policy struct for that CPU, and an unsigned int event. The +following events are currently defined: + +CPUFREQ_GOV_START: This governor shall start its duty for the CPU + policy->cpu +CPUFREQ_GOV_STOP: This governor shall end its duty for the CPU + policy->cpu +CPUFREQ_GOV_LIMITS: The limits for CPU policy->cpu have changed to + policy->min and policy->max. + +If you need other "events" externally of your driver, _only_ use the +cpufreq_governor_l(unsigned int cpu, unsigned int event) call to the +CPUfreq core to ensure proper locking. + + +The CPUfreq governor may call the CPU processor driver using one of +these two functions: + +inline int cpufreq_driver_target(struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation); + +inline int cpufreq_driver_target_l(struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation); + +target_freq must be within policy->min and policy->max, of course. +What's the difference between these two functions? When your governor +still is in a direct code path of a call to governor->governor, the +cpufreq_driver_sem lock is still held in the cpufreq core, and there's +no need to lock it again (in fact, this would cause a deadlock). So +use cpufreq_driver_target only in these cases. In all other cases (for +example, when there's a "daemonized" function that wakes up every +second), use cpufreq_driver_target_l to lock the cpufreq_driver_sem +before the command is passed to the cpufreq processor driver. + diff -Nru a/Documentation/cpu-freq/index.txt b/Documentation/cpu-freq/index.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/cpu-freq/index.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,56 @@ + CPU frequency and voltage scaling code in the Linux(TM) kernel + + + L i n u x C P U F r e q + + + + + Dominik Brodowski + + + + Clock scaling allows you to change the clock speed of the CPUs on the + fly. This is a nice method to save battery power, because the lower + the clock speed, the less power the CPU consumes. + + + +Documents in this directory: +---------------------------- +core.txt - General description of the CPUFreq core and + of CPUFreq notifiers + +cpu-drivers.txt - How to implement a new cpufreq processor driver + +governors.txt - What are cpufreq governors and how to + implement them? + +index.txt - File index, Mailing list and Links (this document) + +user-guide.txt - User Guide to CPUFreq + + +Mailing List +------------ +There is a CPU frequency changing CVS commit and general list where +you can report bugs, problems or submit patches. To post a message, +send an email to cpufreq@www.linux.org.uk, to subscribe go to +http://www.linux.org.uk/mailman/listinfo/cpufreq. Previous post to the +mailing list are available to subscribers at +http://www.linux.org.uk/mailman/private/cpufreq/. + + +Links +----- +the FTP archives: +* ftp://ftp.linux.org.uk/pub/linux/cpufreq/ + +how to access the CVS repository: +* http://cvs.arm.linux.org.uk/ + +the CPUFreq Mailing list: +* http://www.linux.org.uk/mailman/listinfo/cpufreq + +Clock and voltage scaling for the SA-1100: +* http://www.lart.tudelft.nl/projects/scaling diff -Nru a/Documentation/cpu-freq/user-guide.txt b/Documentation/cpu-freq/user-guide.txt --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/Documentation/cpu-freq/user-guide.txt Tue Mar 4 19:30:14 2003 @@ -0,0 +1,166 @@ + CPU frequency and voltage scaling code in the Linux(TM) kernel + + + L i n u x C P U F r e q + + U S E R G U I D E + + + Dominik Brodowski + + + + Clock scaling allows you to change the clock speed of the CPUs on the + fly. This is a nice method to save battery power, because the lower + the clock speed, the less power the CPU consumes. + + +Contents: +--------- +1. Supported Architectures and Processors +1.1 ARM +1.2 x86 +1.3 sparc64 + +2. "Policy" / "Governor"? +2.1 Policy +2.2 Governor + +3. How to change the CPU cpufreq policy and/or speed +3.1 Preferred interface: sysfs +3.2 Deprecated interfaces + + + +1. Supported Architectures and Processors +========================================= + +1.1 ARM +------- + +The following ARM processors are supported by cpufreq: + +ARM Integrator +ARM-SA1100 +ARM-SA1110 + + +1.2 x86 +------- + +The following processors for the x86 architecture are supported by cpufreq: + +AMD Elan - SC400, SC410 +AMD mobile K6-2+ +AMD mobile K6-3+ +Cyrix Media GXm +Intel mobile PIII [*] and Intel mobile PIII-M on certain chipsets +Intel Pentium 4, Intel Xeon +National Semiconductors Geode GX +Transmeta Crusoe +varios processors on some ACPI 2.0-compatible systems [**] + +[*] only certain Intel mobile PIII processors are supported. If you +know that you own a speedstep-capable processor, pass the option +"speedstep_coppermine=1" to the module speedstep.o + +[**] Only if "ACPI Processor Performance States" are available +to the ACPI<->BIOS interface. + + +1.3 sparc64 +----------- + +The following processors for the sparc64 architecture are supported by +cpufreq: + +UltraSPARC-III + + + +2. "Policy" / "Governor" ? +========================== + +Some CPU frequency scaling-capable processor switch between varios +frequencies and operating voltages "on the fly" without any kernel or +user involvement. This guarantuees very fast switching to a frequency +which is high enough to serve the user's needs, but low enough to save +power. + + +2.1 Policy +---------- + +On these systems, all you can do is select the lower and upper +frequency limit as well as whether you want more aggressive +power-saving or more instantly avaialble processing power. + + +2.2 Governor +------------ + +On all other cpufreq implementations, these boundaries still need to +be set. Then, a "governor" must be selected. Such a "governor" decides +what speed the processor shall run within the boundaries. One such +"governor" is the "userspace" governor. This one allows the user - or +a yet-to-implement userspace program - to decide what specific speed +the processor shall run at. + + +3. How to change the CPU cpufreq policy and/or speed +==================================================== + +3.1 Preferred Interface: sysfs +------------------------------ + +The preferred interface is located in the sysfs filesystem. If you +mounted it at /sys, the cpufreq interface is located in the +cpu-device directory (e.g. /sys/devices/sys/cpu0/ for the first +CPU). + +cpuinfo_min_freq : this file shows the minimum operating + frequency the processor can run at(in kHz) +cpuinfo_max_freq : this file shows the maximum operating + frequency the processor can run at(in kHz) +scaling_driver : this file shows what cpufreq driver is + used to set the frequency on this CPU + +available_scaling_governors : this file shows the CPUfreq governors + available in this kernel. You can see the + currently activated governor in + +scaling_governor, and by "echoing" the name of another + governor you can change it. Please note + that some governors won't load - they only + work on some specific architectures or + processors. +scaling_min_freq and +scaling_max_freq show the current "policy limits" (in + kHz). By echoing new values into these + files, you can change these limits. + + +If you have selected the "userspace" governor which allows you to +set the CPU operating frequency to a specific value, you can read out +the current frequency in + +scaling_setspeed. By "echoing" a new frequency into this + you can change the speed of the CPU, + but only within the limits of + scaling_min_freq and scaling_max_freq. + + +3.2 Deprecated Interfaces +------------------------- + +Depending on your kernel configuration, you might find the following +cpufreq-related files: +/proc/cpufreq +/proc/sys/cpu/*/speed +/proc/sys/cpu/*/speed-min +/proc/sys/cpu/*/speed-max + +These are files for deprecated interfaces to cpufreq, which offer far +less functionality. Because of this, these interfaces aren't described +here. + diff -Nru a/Documentation/cpufreq b/Documentation/cpufreq --- a/Documentation/cpufreq Tue Mar 4 19:30:12 2003 +++ /dev/null Wed Dec 31 16:00:00 1969 @@ -1,364 +0,0 @@ - CPU frequency and voltage scaling code in the Linux(TM) kernel - - - L i n u x C P U F r e q - - - - - Dominik Brodowski - David Kimdon - - - - Clock scaling allows you to change the clock speed of the CPUs on the - fly. This is a nice method to save battery power, because the lower - the clock speed, the less power the CPU consumes. - - - -Contents: ---------- -1. Supported architectures -2. User interface -2.1 /proc/cpufreq interface [2.6] -2.2. /proc/sys/cpu/ interface [2.4] -3. CPUFreq core and interfaces -3.1 General information -3.2 CPUFreq notifiers -3.3 CPUFreq architecture drivers -4. Mailing list and Links - - - -1. Supported architectures -========================== - -ARM: - ARM Integrator, SA 1100, SA1110 --------------------------------- - This driver will be ported to new CPUFreq core soon, so - far it will not work. - - -AMD Elan: - SC400, SC410 --------------------------------- - You need to specify the highest allowed CPU frequency as - a module parameter ("max_freq") or as boot parameter - ("elanfreq="). Else the available speed range will be - limited to the speed at which the CPU runs while this - module is loaded. - - -VIA Cyrix Longhaul: - VIA Samuel/CyrixIII, VIA Cyrix Samuel/C3, - VIA Cyrix Ezra, VIA Cyrix Ezra-T --------------------------------- - If you do not want to scale the Front Side Bus or voltage, - pass the module parameter "dont_scale_fsb 1" or - "dont_scale_voltage 1". Additionally, it is advised that - you pass the current Front Side Bus speed (in MHz) to - this module as module parameter "current_fsb", e.g. - "current_fsb 133" for a Front Side Bus speed of 133 MHz. - - -Intel SpeedStep: - certain mobile Intel Pentium III (Coppermine), and all mobile - Intel Pentium III-M (Tualatin) and mobile Intel Pentium 4 P4-Ms. --------------------------------- - Unfortunately only modern Intel ICH2-M and ICH3-M chipsets are - supported. - - -P4 CPU Clock Modulation: - Intel Pentium 4 Xeon processors ---------------------------------- - Note that you can only switch the speed of two logical CPUs at - once - but each phyiscal CPU may have different throttling levels. - - -PowerNow! K6: - mobile AMD K6-2+ / mobile K6-3+: --------------------------------- - No known issues. - - -Transmeta Crusoe Longrun: - Transmeta Crusoe processors: --------------------------------- - It is recommended to use the 2.6. /proc/cpufreq interface when - using this driver - - - -2. User Interface -================= - -2.1 /proc/cpufreq interface [2.6] -*********************************** - -Starting in the patches for kernel 2.5.33, CPUFreq uses a "policy" -interface /proc/cpufreq. - -When you "cat" this file, you'll find something like: - --- - minimum CPU frequency - maximum CPU frequency - policy -CPU 0 1200000 ( 75%) - 1600000 (100%) - performance --- - -This means the current policy allows this CPU to be run anywhere -between 1.2 GHz (the value is in kHz) and 1.6 GHz with an eye towards -performance. - -To change the policy, "echo" the desired new policy into -/proc/cpufreq. Use one of the following formats: - -cpu_nr:min_freq:max_freq:policy -cpu_nr%min_freq%max_freq%policy -min_freq:max_freq:policy -min_freq%max_freq%policy - -with cpu_nr being the CPU which shall be affected, min_freq and -max_freq the lower and upper limit of the CPU core frequency in kHz, -and policy either "performance" or "powersave". -A few examples: - -root@notebook:#echo -n "0:0:0:powersave" > /proc/cpufreq - sets the CPU #0 to the lowest supported frequency. - -root@notebook:#echo -n "1%100%100%performance" > /proc/cpufreq - sets the CPU #1 to the highest supported frequency. - -root@notebook:#echo -n "1000000:2000000:performance" > /proc/cpufreq - to set the frequency of all CPUs between 1 GHz and 2 GHz and to - the policy "performance". - -Please note that the values you "echo" into /proc/cpufreq are -validated first, and may be limited by hardware or thermal -considerations. Because of this, a read from /proc/cpufreq might -differ from what was written into it. - - -When you read /proc/cpufreq for the first time after a CPUFreq driver -has been initialized, you'll see the "default policy" for this -driver. If this does not suit your needs, you can pass a boot -parameter to the cpufreq core. Use the following syntax for this: - "cpufreq=min_freq:max_freq:policy", i.e. you may not chose a -specific CPU and you need to specify the limits in kHz and not in -per cent. - - -2.2 /proc/cpufreq interface [2.4] -*********************************** - -Previsiously (and still available as a config option), CPUFreq used -a "sysctl" interface which is located in - /proc/sys/cpu/0/ - /proc/sys/cpu/1/ ... (SMP only) - -In these directories, you will find three files of importance for -CPUFreq: speed-max, speed-min and speed: - -speed shows the current CPU frequency in kHz, -speed-min the minimum supported CPU frequency, and -speed-max the maximum supported CPU frequency. - - -To change the CPU frequency, "echo" the desired CPU frequency (in kHz) -to speed. For example, to set the CPU speed to the lowest/highest -allowed frequency do: - -root@notebook:# cat /proc/sys/cpu/0/speed-min > /proc/sys/cpu/0/speed -root@notebook:# cat /proc/sys/cpu/0/speed-max > /proc/sys/cpu/0/speed - - - -3. CPUFreq core and interfaces -=============================== - -3.1 General information -************************* - -The CPUFreq core code is located in linux/kernel/cpufreq.c. This -cpufreq code offers a standardized interface for the CPUFreq -architecture drivers (those pieces of code that do actual -frequency transitions), as well as to "notifiers". These are device -drivers or other part of the kernel that need to be informed of -policy changes (like thermal modules like ACPI) or of all -frequency changes (like timing code) or even need to force certain -speed limits (like LCD drivers on ARM architecture). Additionally, the -kernel "constant" loops_per_jiffy is updated on frequency changes -here. - - -3.2 CPUFreq notifiers -*********************** - -CPUFreq notifiers conform to the standard kernel notifier interface. -See linux/include/linux/notifier.h for details on notifiers. - -There are two different CPUFreq notifiers - policy notifiers and -transition notifiers. - - -3.2.1 CPUFreq policy notifiers -****************************** - -These are notified when a new policy is intended to be set. Each -CPUFreq policy notifier is called three times for a policy transition: - -1.) During CPUFREQ_ADJUST all CPUFreq notifiers may change the limit if - they see a need for this - may it be thermal considerations or - hardware limitations. - -2.) During CPUFREQ_INCOMPATIBLE only changes may be done in order to avoid - hardware failure. - -3.) And during CPUFREQ_NOTIFY all notifiers are informed of the new policy - - if two hardware drivers failed to agree on a new policy before this - stage, the incompatible hardware shall be shut down, and the user - informed of this. - -The phase is specified in the second argument to the notifier. - -The third argument, a void *pointer, points to a struct cpufreq_policy -consisting of five values: cpu, min, max, policy and max_cpu_freq. Min -and max are the lower and upper frequencies (in kHz) of the new -policy, policy the new policy, cpu the number of the affected CPU or -CPUFREQ_ALL_CPUS for all CPUs; and max_cpu_freq the maximum supported -CPU frequency. This value is given for informational purposes only. - - -3.2.2 CPUFreq transition notifiers -********************************** - -These are notified twice when the CPUfreq driver switches the CPU core -frequency and this change has any external implications. - -The second argument specifies the phase - CPUFREQ_PRECHANGE or -CPUFREQ_POSTCHANGE. - -The third argument is a struct cpufreq_freqs with the following -values: -cpu - number of the affected CPU or CPUFREQ_ALL_CPUS -old - old frequency -new - new frequency - - -3.3 CPUFreq architecture drivers -********************************** - -CPUFreq architecture drivers are the pieces of kernel code that -actually perform CPU frequency transitions. These need to be -initialized separately (separate initcalls), and may be -modularized. They interact with the CPUFreq core in the following way: - -cpufreq_register() ------------------- -cpufreq_register registers an arch driver to the CPUFreq core. Please -note that only one arch driver may be registered at any time. -EBUSY -is returned when an arch driver is already registered. The argument to -cpufreq_register, struct cpufreq_driver *driver, is described later. - -cpufreq_unregister() --------------------- -cpufreq_unregister unregisters an arch driver, e.g. on module -unloading. Please note that there is no check done that this is called -from the driver which actually registered itself to the core, so -please only call this function when you are sure the arch driver got -registered correctly before. - -cpufreq_notify_transition() ---------------------------- -On "dumb" hardware where only fixed frequency can be set, the driver -must call cpufreq_notify_transition() once before, and once after the -actual transition. - -struct cpufreq_driver ---------------------- -On initialization, the arch driver is supposed to pass a pointer -to a struct cpufreq_driver *cpufreq_driver consisting of the following -entries: - -cpufreq_verify_t verify: This is a pointer to a function with the - following definition: - int verify_function (struct cpufreq_policy *policy). - This function must verify the new policy is within the limits - supported by the CPU, and at least one supported CPU is within - this range. It may be useful to use cpufreq.h / - cpufreq_verify_within_limits for this. If this is called with - CPUFREQ_ALL_CPUS, and there is no common subset of frequencies - for all CPUs, exit with an error. - -cpufreq_setpolicy_t setpolicy: This is a pointer to a function with - the following definition: - int setpolicy_function (struct cpufreq_policy *policy). - This function must set the CPU to the new policy. If it is a - "dumb" CPU which only allows fixed frequencies to be set, it - shall set it to the lowest within the limit for - CPUFREQ_POLICY_POWERSAVE, and to the highest for - CPUFREQ_POLICY_PERFORMANCE. Once CONFIG_CPU_FREQ_DYNAMIC is - implemented, it can use a dynamic method to adjust the speed - between the lower and upper limit. - -struct cpufreq_policy *policy: This is an array of NR_CPUS struct - cpufreq_policies, containing the current policies set for these - CPUs. Note that policy[cpu].max_cpu_freq must contain the - absolute maximum CPU frequency supported by the specified cpu. - -In case the driver is expected to run with the 2.4.-style API -(/proc/sys/cpu/.../), two more values must be passed -#ifdef CONFIG_CPU_FREQ_24_API - unsigned int cpu_min_freq[NR_CPUS]; - unsigned int cpu_cur_freq[NR_CPUS]; -#endif - with cpu_min_freq[cpu] being the minimum CPU frequency - supported by the CPU; and the entries in cpu_cur_freq - reflecting the current speed of the appropriate CPU. - -Some Requirements to CPUFreq architecture drivers -------------------------------------------------- -* Only call cpufreq_register() when the ability to switch CPU - frequencies is _verified_ or can't be missing. Also, all - other initialization must be done beofre this call, as - cpfureq_register calls the driver's verify and setpolicy code for - each CPU. -* cpufreq_unregister() may only be called if cpufreq_register() has - been successfully(!) called before. -* kfree() the struct cpufreq_driver only after the call to - cpufreq_unregister(), unless cpufreq_register() failed. - - - -4. Mailing list and Links -************************* - - -Mailing List ------------- -There is a CPU frequency changing CVS commit and general list where -you can report bugs, problems or submit patches. To post a message, -send an email to cpufreq@www.linux.org.uk, to subscribe go to -http://www.linux.org.uk/mailman/listinfo/cpufreq. Previous post to the -mailing list are available to subscribers at -http://www.linux.org.uk/mailman/private/cpufreq/. - - -Links ------ -the FTP archives: -* ftp://ftp.linux.org.uk/pub/linux/cpufreq/ - -how to access the CVS repository: -* http://cvs.arm.linux.org.uk/ - -the CPUFreq Mailing list: -* http://www.linux.org.uk/mailman/listinfo/cpufreq - -Clock and voltage scaling for the SA-1100: -* http://www.lart.tudelft.nl/projects/scaling - -CPUFreq project homepage -* http://www.brodo.de/cpufreq/ diff -Nru a/Documentation/fb/sstfb.txt b/Documentation/fb/sstfb.txt --- a/Documentation/fb/sstfb.txt Tue Mar 4 19:30:05 2003 +++ b/Documentation/fb/sstfb.txt Tue Mar 4 19:30:05 2003 @@ -138,7 +138,7 @@ - The driver is not your_favorite_toy-safe. this includes SMP... [Actually from inspection it seems to be safe - Alan] - when using XFree86 FBdev (X over fbdev) you may see strange color - patterns at the border of your windows (the pixels loose the lowest + patterns at the border of your windows (the pixels lose the lowest byte -> basicaly the blue component nd some of the green) . I'm unable to reproduce this with XFree86-3.3, but one of the testers has this problem with XFree86-4. apparently recent Xfree86-4.x solve this diff -Nru a/Documentation/filesystems/hpfs.txt b/Documentation/filesystems/hpfs.txt --- a/Documentation/filesystems/hpfs.txt Tue Mar 4 19:30:07 2003 +++ b/Documentation/filesystems/hpfs.txt Tue Mar 4 19:30:07 2003 @@ -109,7 +109,7 @@ Once I booted English OS/2 working in cp 850 and I created a file on my 852 partition. It marked file name codepage as 850 - good. But when I again booted Czech OS/2, the file was completely inaccessible under any name. It seems that -OS/2 uppercases the search pattern with it's system code page (852) and file +OS/2 uppercases the search pattern with its system code page (852) and file name it's comparing to with its code page (850). These could never match. Is it really what IBM developers wanted? But problems continued. When I created in Czech OS/2 another file in that directory, that file was inaccessible too. OS/2 diff -Nru a/Documentation/filesystems/vfs.txt b/Documentation/filesystems/vfs.txt --- a/Documentation/filesystems/vfs.txt Tue Mar 4 19:30:11 2003 +++ b/Documentation/filesystems/vfs.txt Tue Mar 4 19:30:11 2003 @@ -439,7 +439,7 @@ d_release: called when a dentry is really deallocated - d_iput: called when a dentry looses its inode (just prior to its + d_iput: called when a dentry loses its inode (just prior to its being deallocated). The default when this is NULL is that the VFS calls iput(). If you define this method, you must call iput() yourself diff -Nru a/Documentation/input/joystick-api.txt b/Documentation/input/joystick-api.txt --- a/Documentation/input/joystick-api.txt Tue Mar 4 19:30:08 2003 +++ b/Documentation/input/joystick-api.txt Tue Mar 4 19:30:08 2003 @@ -168,7 +168,7 @@ and too many events to store in the queue get generated. Note that high system load may contribute to space those reads even more. -If time between reads is enough to fill the queue and loose an event, +If time between reads is enough to fill the queue and lose an event, the driver will switch to startup mode and next time you read it, synthetic events (JS_EVENT_INIT) will be generated to inform you of the actual state of the joystick. diff -Nru a/Documentation/ioctl-number.txt b/Documentation/ioctl-number.txt --- a/Documentation/ioctl-number.txt Tue Mar 4 19:30:13 2003 +++ b/Documentation/ioctl-number.txt Tue Mar 4 19:30:13 2003 @@ -72,6 +72,7 @@ linux/blkpg.h 0x20 all drivers/cdrom/cm206.h 0x22 all scsi/sg.h +'#' 00-3F IEEE 1394 Subsystem Block for the entire subsystem '1' 00-1F PPS kit from Ulrich Windl '6' 00-10 Intel IA32 microcode update driver diff -Nru a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt --- a/Documentation/kernel-parameters.txt Tue Mar 4 19:30:14 2003 +++ b/Documentation/kernel-parameters.txt Tue Mar 4 19:30:14 2003 @@ -516,6 +516,14 @@ [KNL,BOOT] Force usage of a specific region of memory Region of memory to be used, from ss to ss+nn. + mem=nn[KMG]#ss[KMG] + [KNL,BOOT,ACPI] Mark specific memory as ACPI data. + Region of memory to be used, from ss to ss+nn. + + mem=nn[KMG]$ss[KMG] + [KNL,BOOT,ACPI] Mark specific memory as reserved. + Region of memory to be used, from ss to ss+nn. + mem=nopentium [BUGS=IA-32] Disable usage of 4MB pages for kernel memory. diff -Nru a/Documentation/networking/decnet.txt b/Documentation/networking/decnet.txt --- a/Documentation/networking/decnet.txt Tue Mar 4 19:30:04 2003 +++ b/Documentation/networking/decnet.txt Tue Mar 4 19:30:04 2003 @@ -42,7 +42,7 @@ 3) Command line options You can set a DECnet address on the kernel command line for compatibility -with the 2.4 configuration procedure, but in general its not needed any more. +with the 2.4 configuration procedure, but in general it's not needed any more. If you do st a DECnet address on the command line, it has only one purpose which is that its added to the addresses on the loopback device. diff -Nru a/Documentation/networking/ifenslave.c b/Documentation/networking/ifenslave.c --- a/Documentation/networking/ifenslave.c Tue Mar 4 19:30:05 2003 +++ b/Documentation/networking/ifenslave.c Tue Mar 4 19:30:05 2003 @@ -299,7 +299,7 @@ else { /* attach a slave interface to the master */ /* two possibilities : - if hwaddr_notset, do nothing. The bond will assign the - hwaddr from it's first slave. + hwaddr from its first slave. - if !hwaddr_notset, assign the master's hwaddr to each slave */ diff -Nru a/Documentation/networking/netdevices.txt b/Documentation/networking/netdevices.txt --- a/Documentation/networking/netdevices.txt Tue Mar 4 19:30:05 2003 +++ b/Documentation/networking/netdevices.txt Tue Mar 4 19:30:05 2003 @@ -18,7 +18,8 @@ dev->stop: Synchronization: rtnl_lock() semaphore. Context: process - Notes: netif_running() is guaranteed false when this is called + Note1: netif_running() is guaranteed false + Note2: dev->poll() is guaranteed to be stopped dev->do_ioctl: Synchronization: rtnl_lock() semaphore. @@ -31,10 +32,12 @@ dev->hard_start_xmit: Synchronization: dev->xmit_lock spinlock. Context: BHs disabled + Notes: netif_queue_stopped() is guaranteed false dev->tx_timeout: Synchronization: dev->xmit_lock spinlock. Context: BHs disabled + Notes: netif_queue_stopped() is guaranteed true dev->set_multicast_list: Synchronization: dev->xmit_lock spinlock. diff -Nru a/Documentation/networking/sk98lin.txt b/Documentation/networking/sk98lin.txt --- a/Documentation/networking/sk98lin.txt Tue Mar 4 19:30:11 2003 +++ b/Documentation/networking/sk98lin.txt Tue Mar 4 19:30:11 2003 @@ -187,7 +187,7 @@ this port is not "Sense". If autonegotiation is "On", all three values are possible. If it is "Off", only "Full" and "Half" are allowed. - It is usefull if your link partner does not support all + It is useful if your link partner does not support all possible combinations. - Flow Control diff -Nru a/Documentation/s390/TAPE b/Documentation/s390/TAPE --- a/Documentation/s390/TAPE Tue Mar 4 19:30:13 2003 +++ b/Documentation/s390/TAPE Tue Mar 4 19:30:13 2003 @@ -91,7 +91,7 @@ TODO List - - Driver has to be stabelized still + - Driver has to be stabilized still BUGS diff -Nru a/Documentation/s390/s390dbf.txt b/Documentation/s390/s390dbf.txt --- a/Documentation/s390/s390dbf.txt Tue Mar 4 19:30:11 2003 +++ b/Documentation/s390/s390dbf.txt Tue Mar 4 19:30:11 2003 @@ -14,7 +14,7 @@ If the system still runs but only a subcomponent which uses dbf failes, it is possible to look at the debug logs on a live system via the Linux proc filesystem. -The debug feature may also very usefull for kernel and driver development. +The debug feature may also very useful for kernel and driver development. Design: ------- diff -Nru a/Documentation/scsi/ibmmca.txt b/Documentation/scsi/ibmmca.txt --- a/Documentation/scsi/ibmmca.txt Tue Mar 4 19:30:11 2003 +++ b/Documentation/scsi/ibmmca.txt Tue Mar 4 19:30:11 2003 @@ -254,7 +254,7 @@ device to be existant, but it has no ldn assigned, it gets a ldn out of 7 to 14. The numbers are assigned in cyclic order. Therefore it takes 8 dynamical reassignments on the SCSI-devices, until a certain device - looses its ldn again. This assures, that dynamical remapping is avoided + loses its ldn again. This assures, that dynamical remapping is avoided during intense I/O between up to 15 SCSI-devices (means pun,lun combinations). A further advantage of this method is, that people who build their kernel without probing on all luns will get what they expect, diff -Nru a/Documentation/sound/oss/Wavefront b/Documentation/sound/oss/Wavefront --- a/Documentation/sound/oss/Wavefront Tue Mar 4 19:30:04 2003 +++ b/Documentation/sound/oss/Wavefront Tue Mar 4 19:30:04 2003 @@ -81,7 +81,7 @@ 2) Why does line XXX of the code look like this .... ? ********************************************************************** -Either because its not finished yet, or because you're a better coder +Either because it's not finished yet, or because you're a better coder than I am, or because you don't understand some aspect of how the card or the code works. diff -Nru a/Documentation/sx.txt b/Documentation/sx.txt --- a/Documentation/sx.txt Tue Mar 4 19:30:08 2003 +++ b/Documentation/sx.txt Tue Mar 4 19:30:08 2003 @@ -265,7 +265,7 @@ -- Done (Ugly: not the way I want it. Copied from serial.c). - write buffer isn't flushed at close. - -- Done. I still seem to loose a few chars at close. + -- Done. I still seem to lose a few chars at close. Sorry. I think that this is a firmware issue. (-> Specialix) - drain hardware before changing termios diff -Nru a/Documentation/video4linux/bttv/Sound-FAQ b/Documentation/video4linux/bttv/Sound-FAQ --- a/Documentation/video4linux/bttv/Sound-FAQ Tue Mar 4 19:30:14 2003 +++ b/Documentation/video4linux/bttv/Sound-FAQ Tue Mar 4 19:30:14 2003 @@ -120,7 +120,7 @@ video_inputs - # of video inputs the card has audio_inputs - historical cruft, not used any more. tuner - which input is the tuner -svhs - which input is svhs (all others are labled composite) +svhs - which input is svhs (all others are labeled composite) muxsel - video mux, input->registervalue mapping pll - same as pll= insmod option tuner_type - same as tuner= insmod option diff -Nru a/Documentation/vm/hugetlbpage.txt b/Documentation/vm/hugetlbpage.txt --- a/Documentation/vm/hugetlbpage.txt Tue Mar 4 19:30:04 2003 +++ b/Documentation/vm/hugetlbpage.txt Tue Mar 4 19:30:04 2003 @@ -1,4 +1,3 @@ -2002 Rohit Seth The intent of this file is to give a brief summary of hugetlbpage support in the Linux kernel. This support is built on top of multiple page size support @@ -11,75 +10,194 @@ now as bigger and bigger physical memories (several GBs) are more readily available. -The current support is provided in kernel using the following two system calls: +Users can use the huge page support in Linux kernel by either using the mmap +system call or standard SYSv shared memory system calls (shmget, shmat). -1) sys_alloc_hugepages(int key, unsigned long addr, size_t len, int prot, int flag) +First the Linux kernel needs to be built with CONFIG_HUGETLB_PAGE (present +under Processor types and feature) and CONFIG_HUGETLBFS (present under file +system option on config menu) config options. -2) sys_free_hugepages(unsigned long addr) +The kernel built with hugepage support should show the number of configured +hugepages in the system by running the "cat /proc/meminfo" command. -Arguments to these system calls are defined as follows: - -key: If a user application wants to share hugepages with other - processes then this input argument needs to be greater than 0. - Different applications can use the same key to map the same physical - memory (mapped by hugeTLBs) in their address space. When a process - forks, then children share the same physical memory with their parent. - - For the cases when an application wishes to keep the huge - pages private, the key value of 0 is defined. In this case - kernel allocates hugetlb pages to the process that are not - shareable across different processes. These segments are marked - private for the process. These segments are not copied to - children's address space on forks - the child will have no - mapping for these virtual addresses. - - The key manangement (and assignment) part is left to user - applications. - -addr: This is an address hint. The kernel will perform a sanity check - on this address (alignment etc.) before using it. It is possible that - kernel will allocates a different address (on success). - -len: Length of the required segment. Applications are expected to give - HPAGE_SIZE aligned length. (Else EINVAL is returned.) - -prot: The prot parameter specifies the desired memory protection on the - requested hugepages. The possible values are PROT_EXEC, PROT_READ, - PROT_WRITE. - -flag: This parameter can only take the value IPC_CREAT for the cases - when "key" value greater than zero (shared hugepage cases). It is - ignored for values of "key" that are <= 0. - - This parameter indicates that the kernel should create a new huge - page segment (corresponding to "key"), if none already exists. If this - flag is not set, then sys_allochugepages() will return ENOENT if there - is no segment associated with corresponding "key". - -In case of success, sys_alloc_hugepages() return the allocated virtual address. - -sys_free_hugepages() frees the hugetlb resources from the calling process's -address space. The input argument "addr" specifies the segment that needs to -be freed. It is important to note that for the shared hugepage cases, the -underlying hugepages are freed onlyafter all the users of those pages have -either freed those hugepages or have exited. - -/proc/sys/vm_nr_hugepages indicates the current number of configured hugetlb -pages in the kernel. Super user privileges are required for modification of -this value. The allocation of hugetlb pages is possible only if there are -enough physically contiguous free pages in system OR if there are enough -hugetlb pages free that can be transfered back to regular memory pool. - -/proc/meminfo also gives the information about the total number of hugetlb +/proc/meminfo also provides information about the total number of hugetlb pages configured in the kernel. It also displays information about the number of free hugetlb pages at any time. It also displays information about -the configured hugepage size - this is needed for generting the proper +the configured hugepage size - this is needed for generating the proper alignment and size of the arguments to the above system calls. -Pages that are used as hugetlb pages are marked reserved inside the kernel. -This allows hugetlb pages to be always locked in memory. The user either -needs to be super user to use these pages or one of supplementary group -should include root. In future there will be support to check RLIMIT_MLOCK -for limited (number of hugetlb pages) usage to unprivileged applications. +The output of "cat /proc/meminfo" will have output like: -If the kernel does not support hugepages these system calls will return ENOSYS. +..... +HugePages_Total: xxx +HugePages_Free: yyy +Hugepagesize: zzz KB + +/proc/filesystems should also show a filesystem of type "hugetlbfs" configured +in the kernel. + +/proc/sys/vm/nr_hugepages indicates the current number of configured hugetlb +pages in the kernel. Super user can dynamically request more (or free some +pre-configured) hugepages. +The allocation( or deallocation) of hugetlb pages is posible only if there are +enough physically contiguous free pages in system (freeing of hugepages is +possible only if there are enough hugetlb pages free that can be transfered +back to regular memory pool). + +Pages that are used as hugetlb pages are reserved inside the kernel and can +not be used for other purposes. + +Once the kernel with Hugetlb page support is built and running, a user can +use either the mmap system call or shared memory system calls to start using +the huge pages. It is required that the system administrator preallocate +enough memory for huge page purposes. + +Use the following command to dynamically allocate/deallocate hugepages: + + echo 20 > /proc/sys/vm/nr_hugepages + +This command will try to configure 20 hugepages in the system. The success +or failure of allocation depends on the amount of physically contiguous +memory that is preset in system at this time. System administrators may want +to put this command in one of the local rc init file. This will enable the +kernel to request huge pages early in the boot process (when the possibility +of getting physical contiguous pages is still very high). + +If the user applications are going to request hugepages using mmap system +call, then it is required that system administrator mount a file system of +type hugetlbfs: + + mount none /mnt/huge -t hugetlbfs + +This commands mounts a (psuedo) filesystem of type hugetlbfs on the directory +/mnt/huge. Any files created on /mnt/huge uses hugepages. An example is +given at the end of this document. + +read and write system calls are not supported on files that reside on hugetlb +file systems. + +Also, it is important to note that no such mount command is required if the +applications are going to use only shmat/shmget system calls. It is possible +for same or different applications to use any combination of mmaps and shm* +calls. Though the mount of filesystem will be required for using mmaps. + +/* Example of using hugepage in user application using Sys V shared memory + * system calls. In this example, app is requesting memory of size 256MB that + * is backed by huge pages. Application uses the flag SHM_HUGETLB in shmget + * system call to informt the kernel that it is requesting hugepages. For + * IA-64 architecture, Linux kernel reserves Region number 4 for hugepages. + * That means the addresses starting with 0x800000....will need to be + * specified. + */ +#include +#include +#include +#include + +extern int errno; +#define SHM_HUGETLB 04000 +#define LPAGE_SIZE (256UL*1024UL*1024UL) +#define dprintf(x) printf(x) +#define ADDR (0x8000000000000000UL) +main() +{ + int shmid; + int i, j, k; + volatile char *shmaddr; + + if ((shmid =shmget(2, LPAGE_SIZE, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W )) +< 0) { + perror("Failure:"); + exit(1); + } + printf("shmid: 0x%x\n", shmid); + shmaddr = shmat(shmid, (void *)ADDR, SHM_RND) ; + if (errno != 0) { + perror("Shared Memory Attach Failure:"); + exit(2); + } + printf("shmaddr: %p\n", shmaddr); + + dprintf("Starting the writes:\n"); + for (i=0;i +#include +#include +#include + +#define FILE_NAME "/mnt/hugepagefile" +#define LENGTH (256*1024*1024) +#define PROTECTION (PROT_READ | PROT_WRITE) +#define FLAGS MAP_SHARED |MAP_FIXED +#define ADDRESS (char *)(0x60000000UL + 0x8000000000000000UL) + +extern errno; + +check_bytes(char *addr) +{ + printf("First hex is %x\n", *((unsigned int *)addr)); +} + +write_bytes(char *addr) +{ + int i; + for (i=0;i .tmp_version - mv -f .tmp_version .version - $(Q)$(MAKE) $(build)=init + set -e; \ + $(if $(filter .tmp_kallsyms%,$^),, \ + echo ' GEN .version'; \ + . $(srctree)/scripts/mkversion > .tmp_version; \ + mv -f .tmp_version .version; \ + $(MAKE) $(build)=init; \ ) - $(call cmd,vmlinux__) + $(call cmd,vmlinux__); \ echo 'cmd_$@ := $(cmd_vmlinux__)' > $(@D)/.$(@F).cmd endef -define rule_vmlinux_no_percpu - $(rule_vmlinux__) - $(NM) $@ | grep -v '$compiled$\|$\.o$$$\|$ [aUw] $\|$\.\.ng$$$\|$LASH[RL]DI$' | sort > System.map -endef - ifdef CONFIG_SMP +# Final awk script makes sure per-cpu vars are in per-cpu section, as +# old gcc (eg egcs 2.92.11) ignores section attribute if uninitialized. + +check_per_cpu = $(AWK) -f $(srctree)/scripts/per-cpu-check.awk < System.map +endif + define rule_vmlinux - $(rule_vmlinux_no_percpu) - $(AWK) -f $(srctree)/scripts/per-cpu-check.awk < System.map -endef -else -define rule_vmlinux - $(rule_vmlinux_no_percpu) + $(rule_vmlinux__) + $(NM) $@ | grep -v '$compiled$\|$\.o$$$\|$ [aUw] $\|$\.\.ng$$$\|$LASH[RL]DI$' | sort > System.map + $(check_per_cpu) endef -endif LDFLAGS_vmlinux += -T arch/$(ARCH)/vmlinux.lds.s @@ -377,7 +373,7 @@ $(call cmd,kallsyms) .tmp_vmlinux1: $(vmlinux-objs) arch/$(ARCH)/vmlinux.lds.s FORCE - $(call if_changed_rule,vmlinux__) + +$(call if_changed_rule,vmlinux__) .tmp_vmlinux2: $(vmlinux-objs) .tmp_kallsyms1.o arch/$(ARCH)/vmlinux.lds.s FORCE $(call if_changed_rule,vmlinux__) @@ -457,14 +453,14 @@ # Split autoconf.h into include/linux/config/* include/config/MARKER: scripts/split-include include/linux/autoconf.h - @echo ' SPLIT include/linux/autoconf.h -> include/config/*' + @echo ' SPLIT include/linux/autoconf.h -> include/config/*' @scripts/split-include include/linux/autoconf.h include/config @touch $@ # if .config is newer than include/linux/autoconf.h, someone tinkered # with it and forgot to run make oldconfig -include/linux/autoconf.h: .config +include/linux/autoconf.h: .config scripts/fixdep $(Q)$(MAKE) $(build)=scripts/kconfig scripts/kconfig/conf ./scripts/kconfig/conf -s arch/$(ARCH)/Kconfig @@ -481,7 +477,7 @@ echo '"$(KERNELRELEASE)" exceeds $(uts_len) characters' >&2; \ exit 1; \ fi; - @echo -n ' Generating $@' + @echo -n ' GEN $@' @(echo \#define UTS_RELEASE \"$(KERNELRELEASE)\"; \ echo \#define LINUX_VERSION_CODE `expr $(VERSION) \\* 65536 + $(PATCHLEVEL) \\* 256 + $(SUBLEVEL)`; \ echo '#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))'; \ @@ -506,7 +502,7 @@ # Build modules .PHONY: modules -modules: $(SUBDIRS) $(if $(CONFIG_MODVERSIONS),vmlinux) +modules: $(SUBDIRS) $(if $(KBUILD_BUILTIN),vmlinux) @echo ' Building modules, stage 2.'; $(Q)$(MAKE) -rR -f scripts/Makefile.modpost @@ -571,33 +567,6 @@ echo "#endif" ) endef -# RPM target -# --------------------------------------------------------------------------- - -# If you do a make spec before packing the tarball you can rpm -ta it - -spec: - . scripts/mkspec >kernel.spec - -# Build a tar ball, generate an rpm from it and pack the result -# There arw two bits of magic here -# 1) The use of /. to avoid tar packing just the symlink -# 2) Removing the .dep files as they have source paths in them that -# will become invalid - -rpm: clean spec - find . $(RCS_FIND_IGNORE) \ - $ -size 0 -o -name .depend -o -name .hdepend$ \ - -type f -print | xargs rm -f - set -e; \ - cd $(TOPDIR)/.. ; \ - ln -sf $(TOPDIR) $(KERNELPATH) ; \ - tar -cvz $(RCS_TAR_IGNORE) -f $(KERNELPATH).tar.gz $(KERNELPATH)/. ; \ - rm $(KERNELPATH) ; \ - cd $(TOPDIR) ; \ - $(CONFIG_SHELL) $(srctree)/scripts/mkversion > .version ; \ - rpm -ta $(TOPDIR)/../$(KERNELPATH).tar.gz ; \ - rm $(TOPDIR)/../$(KERNELPATH).tar.gz else # ifdef include_config @@ -630,7 +599,7 @@ # --------------------------------------------------------------------------- .PHONY: oldconfig xconfig menuconfig config \ - make_with_config + make_with_config rpm scripts/kconfig/conf scripts/kconfig/mconf scripts/kconfig/qconf: scripts/fixdep FORCE $(Q)$(MAKE) $(build)=scripts/kconfig $@ @@ -763,6 +732,36 @@ tags: FORCE $(call cmd,tags) +# RPM target +# --------------------------------------------------------------------------- + +# If you do a make spec before packing the tarball you can rpm -ta it + +spec: + . $(srctree)/scripts/mkspec >kernel.spec + +# Build a tar ball, generate an rpm from it and pack the result +# There are two bits of magic here +# 1) The use of /. to avoid tar packing just the symlink +# 2) Removing the .dep files as they have source paths in them that +# will become invalid + +rpm: clean spec + find . $(RCS_FIND_IGNORE) \ + $ -size 0 -o -name .depend -o -name .hdepend $ \ + -type f -print | xargs rm -f + set -e; \ + cd $(TOPDIR)/.. ; \ + ln -sf $(TOPDIR) $(KERNELPATH) ; \ + tar -cvz $(RCS_TAR_IGNORE) -f $(KERNELPATH).tar.gz $(KERNELPATH)/. ; \ + rm $(KERNELPATH) ; \ + cd $(TOPDIR) ; \ + $(CONFIG_SHELL) $(srctree)/scripts/mkversion > .version ; \ + RPM=`which rpmbuild`; \ + if [ -z "$$RPM" ]; then RPM=rpm; fi; \ + $$RPM -ta $(TOPDIR)/../$(KERNELPATH).tar.gz ; \ + rm $(TOPDIR)/../$(KERNELPATH).tar.gz + # Brief documentation of the typical targets used # --------------------------------------------------------------------------- @@ -782,7 +781,6 @@ @echo '' @echo 'Other generic targets:' @echo ' all - Build all targets marked with [*]' - @echo ' dep - Create module version information' @echo '* vmlinux - Build the bare kernel' @echo '* modules - Build all modules' @echo ' dir/file.[ois]- Build specified target only' @@ -802,7 +800,7 @@ # Documentation targets # --------------------------------------------------------------------------- -sgmldocs psdocs pdfdocs htmldocs: scripts +sgmldocs psdocs pdfdocs htmldocs: scripts/docproc FORCE $(Q)$(MAKE) $(build)=Documentation/DocBook $@ # Scripts to check various things for consistency @@ -812,11 +810,6 @@ find * $(RCS_FIND_IGNORE) \ -name '*.[hcS]' -type f -print | sort \ | xargs $(PERL) -w scripts/checkconfig.pl - -checkhelp: - find * $(RCS_FIND_IGNORE) \ - -name [cC]onfig.in -print | sort \ - | xargs $(PERL) -w scripts/checkhelp.pl checkincludes: find * $(RCS_FIND_IGNORE) \ diff -Nru a/arch/alpha/boot/tools/objstrip.c b/arch/alpha/boot/tools/objstrip.c --- a/arch/alpha/boot/tools/objstrip.c Tue Mar 4 19:30:14 2003 +++ b/arch/alpha/boot/tools/objstrip.c Tue Mar 4 19:30:14 2003 @@ -7,7 +7,7 @@ */ /* * Converts an ECOFF or ELF object file into a bootable file. The - * object file must be a OMAGIC file (i.e., data and bss follow immediatly + * object file must be a OMAGIC file (i.e., data and bss follow immediately * behind the text). See DEC "Assembly Language Programmer's Guide" * documentation for details. The SRM boot process is documented in * the Alpha AXP Architecture Reference Manual, Second Edition by diff -Nru a/arch/alpha/kernel/entry.S b/arch/alpha/kernel/entry.S --- a/arch/alpha/kernel/entry.S Tue Mar 4 19:30:03 2003 +++ b/arch/alpha/kernel/entry.S Tue Mar 4 19:30:03 2003 @@ -591,7 +591,6 @@ */ .globl ret_from_fork -#if CONFIG_SMP || CONFIG_PREEMPT .align 4 .ent ret_from_fork ret_from_fork: @@ -599,9 +598,6 @@ mov $17, $16 jmp $31, schedule_tail .end ret_from_fork -#else -ret_from_fork = ret_from_sys_call -#endif /* * kernel_thread(fn, arg, clone_flags) diff -Nru a/arch/alpha/kernel/pci-noop.c b/arch/alpha/kernel/pci-noop.c --- a/arch/alpha/kernel/pci-noop.c Tue Mar 4 19:30:08 2003 +++ b/arch/alpha/kernel/pci-noop.c Tue Mar 4 19:30:08 2003 @@ -48,7 +48,6 @@ sys_pciconfig_iobase(long which, unsigned long bus, unsigned long dfn) { struct pci_controller *hose; - struct pci_dev *dev; /* from hose or from bus.devfn */ if (which & IOBASE_FROM_HOSE) { @@ -106,6 +105,7 @@ void * pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp) { + return NULL; } void pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr, @@ -116,6 +116,7 @@ pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, int direction) { + return (dma_addr_t) 0; } void pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size, diff -Nru a/arch/alpha/kernel/pci.c b/arch/alpha/kernel/pci.c --- a/arch/alpha/kernel/pci.c Tue Mar 4 19:30:04 2003 +++ b/arch/alpha/kernel/pci.c Tue Mar 4 19:30:04 2003 @@ -63,17 +63,6 @@ } static void __init -quirk_ali_ide_ports(struct pci_dev *dev) -{ - if (dev->resource[0].end == 0xffff) - dev->resource[0].end = dev->resource[0].start + 7; - if (dev->resource[2].end == 0xffff) - dev->resource[2].end = dev->resource[2].start + 7; - if (dev->resource[3].end == 0xffff) - dev->resource[3].end = dev->resource[3].start + 7; -} - -static void __init quirk_cypress(struct pci_dev *dev) { /* The Notorious Cy82C693 chip. */ @@ -121,8 +110,6 @@ struct pci_fixup pcibios_fixups[] __initdata = { { PCI_FIXUP_HEADER, PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82378, quirk_isa_bridge }, - { PCI_FIXUP_HEADER, PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5229, - quirk_ali_ide_ports }, { PCI_FIXUP_HEADER, PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, quirk_cypress }, { PCI_FIXUP_FINAL, PCI_ANY_ID, PCI_ANY_ID, diff -Nru a/arch/alpha/kernel/pci_iommu.c b/arch/alpha/kernel/pci_iommu.c --- a/arch/alpha/kernel/pci_iommu.c Tue Mar 4 19:30:14 2003 +++ b/arch/alpha/kernel/pci_iommu.c Tue Mar 4 19:30:14 2003 @@ -318,7 +318,7 @@ /* Unmap a single streaming mode DMA translation. The DMA_ADDR and SIZE must match what was provided for in a previous pci_map_single call. All other usages are undefined. After this call, reads by - the cpu to the buffer are guarenteed to see whatever the device + the cpu to the buffer are guaranteed to see whatever the device wrote there. */ void diff -Nru a/arch/alpha/kernel/process.c b/arch/alpha/kernel/process.c --- a/arch/alpha/kernel/process.c Tue Mar 4 19:30:13 2003 +++ b/arch/alpha/kernel/process.c Tue Mar 4 19:30:13 2003 @@ -155,10 +155,7 @@ struct halt_info args; args.mode = mode; args.restart_cmd = restart_cmd; -#ifdef CONFIG_SMP - smp_call_function(common_shutdown_1, &args, 1, 0); -#endif - common_shutdown_1(&args); + on_each_cpu(common_shutdown_1, &args, 1, 0); } void diff -Nru a/arch/alpha/kernel/smp.c b/arch/alpha/kernel/smp.c --- a/arch/alpha/kernel/smp.c Tue Mar 4 19:30:05 2003 +++ b/arch/alpha/kernel/smp.c Tue Mar 4 19:30:05 2003 @@ -899,10 +899,8 @@ smp_imb(void) { /* Must wait other processors to flush their icache before continue. */ - if (smp_call_function(ipi_imb, NULL, 1, 1)) + if (on_each_cpu(ipi_imb, NULL, 1, 1)) printk(KERN_CRIT "smp_imb: timed out\n"); - - imb(); } static void @@ -916,11 +914,9 @@ { /* Although we don't have any data to pass, we do want to synchronize with the other processors. */ - if (smp_call_function(ipi_flush_tlb_all, NULL, 1, 1)) { + if (on_each_cpu(ipi_flush_tlb_all, NULL, 1, 1)) { printk(KERN_CRIT "flush_tlb_all: timed out\n"); } - - tbia(); } #define asn_locked() (cpu_data[smp_processor_id()].asn_lock) @@ -938,6 +934,8 @@ void flush_tlb_mm(struct mm_struct *mm) { + preempt_disable(); + if (mm == current->active_mm) { flush_tlb_current(mm); if (atomic_read(&mm->mm_users) <= 1) { @@ -948,6 +946,7 @@ if (mm->context[cpu]) mm->context[cpu] = 0; } + preempt_enable(); return; } } @@ -955,6 +954,8 @@ if (smp_call_function(ipi_flush_tlb_mm, mm, 1, 1)) { printk(KERN_CRIT "flush_tlb_mm: timed out\n"); } + + preempt_enable(); } struct flush_tlb_page_struct { @@ -981,6 +982,8 @@ struct flush_tlb_page_struct data; struct mm_struct *mm = vma->vm_mm; + preempt_disable(); + if (mm == current->active_mm) { flush_tlb_current_page(mm, vma, addr); if (atomic_read(&mm->mm_users) <= 1) { @@ -991,6 +994,7 @@ if (mm->context[cpu]) mm->context[cpu] = 0; } + preempt_enable(); return; } } @@ -1002,6 +1006,8 @@ if (smp_call_function(ipi_flush_tlb_page, &data, 1, 1)) { printk(KERN_CRIT "flush_tlb_page: timed out\n"); } + + preempt_enable(); } void @@ -1030,6 +1036,8 @@ if ((vma->vm_flags & VM_EXEC) == 0) return; + preempt_disable(); + if (mm == current->active_mm) { __load_new_mm_context(mm); if (atomic_read(&mm->mm_users) <= 1) { @@ -1040,6 +1048,7 @@ if (mm->context[cpu]) mm->context[cpu] = 0; } + preempt_enable(); return; } } @@ -1047,6 +1056,8 @@ if (smp_call_function(ipi_flush_icache_page, mm, 1, 1)) { printk(KERN_CRIT "flush_icache_page: timed out\n"); } + + preempt_enable(); } #ifdef CONFIG_DEBUG_SPINLOCK diff -Nru a/arch/alpha/kernel/sys_marvel.c b/arch/alpha/kernel/sys_marvel.c --- a/arch/alpha/kernel/sys_marvel.c Tue Mar 4 19:30:12 2003 +++ b/arch/alpha/kernel/sys_marvel.c Tue Mar 4 19:30:12 2003 @@ -440,7 +440,7 @@ return; /* - * There is a local IO7 - redirect all of it's interrupts here. + * There is a local IO7 - redirect all of its interrupts here. */ printk("Redirecting IO7 interrupts to local CPU at PE %u\n", cpuid); diff -Nru a/arch/alpha/kernel/time.c b/arch/alpha/kernel/time.c --- a/arch/alpha/kernel/time.c Tue Mar 4 19:30:09 2003 +++ b/arch/alpha/kernel/time.c Tue Mar 4 19:30:09 2003 @@ -50,7 +50,7 @@ #include "proto.h" #include "irq_impl.h" -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; extern unsigned long wall_jiffies; /* kernel/timer.c */ diff -Nru a/arch/alpha/kernel/traps.c b/arch/alpha/kernel/traps.c --- a/arch/alpha/kernel/traps.c Tue Mar 4 19:30:13 2003 +++ b/arch/alpha/kernel/traps.c Tue Mar 4 19:30:13 2003 @@ -411,7 +411,7 @@ } /* There is an ifdef in the PALcode in MILO that enables a - "kernel debugging entry point" as an unpriviledged call_pal. + "kernel debugging entry point" as an unprivileged call_pal. We don't want to have anything to do with it, but unfortunately several versions of MILO included in distributions have it enabled, diff -Nru a/arch/alpha/lib/checksum.c b/arch/alpha/lib/checksum.c --- a/arch/alpha/lib/checksum.c Tue Mar 4 19:30:09 2003 +++ b/arch/alpha/lib/checksum.c Tue Mar 4 19:30:09 2003 @@ -63,7 +63,7 @@ ((unsigned long) ntohs(len) << 16) + ((unsigned long) proto << 8)); - /* Fold down to 32-bits so we don't loose in the typedef-less + /* Fold down to 32-bits so we don't lose in the typedef-less network stack. */ /* 64 to 33 */ result = (result & 0xffffffff) + (result >> 32); diff -Nru a/arch/arm/common/sa1111.c b/arch/arm/common/sa1111.c --- a/arch/arm/common/sa1111.c Tue Mar 4 19:30:13 2003 +++ b/arch/arm/common/sa1111.c Tue Mar 4 19:30:13 2003 @@ -418,6 +418,7 @@ spin_lock_irqsave(&sachip->lock, flags); +#if CONFIG_ARCH_SA1100 /* * First, set up the 3.6864MHz clock on GPIO 27 for the SA-1111: * (SA-1110 Developer's Manual, section 9.1.2.1) @@ -425,6 +426,11 @@ GAFR |= GPIO_32_768kHz; GPDR |= GPIO_32_768kHz; TUCR = TUCR_3_6864MHz; +#elif CONFIG_ARCH_PXA + pxa_gpio_mode(GPIO11_3_6MHz_MD); +#else +#error missing clock setup +#endif /* * Turn VCO on, and disable PLL Bypass. @@ -461,6 +467,8 @@ spin_unlock_irqrestore(&sachip->lock, flags); } +#ifdef CONFIG_ARCH_SA1100 + /* * Configure the SA1111 shared memory controller. */ @@ -476,6 +484,8 @@ sa1111_writel(smcr, sachip->base + SA1111_SMCR); } +#endif + static void sa1111_init_one_child(struct sa1111 *sachip, struct sa1111_dev *sadev, unsigned int offset) { @@ -569,6 +579,7 @@ */ sa1111_wake(sachip); +#ifdef CONFIG_ARCH_SA1100 /* * The SDRAM configuration of the SA1110 and the SA1111 must * match. This is very important to ensure that SA1111 accesses @@ -592,6 +603,7 @@ * Enable the SA1110 memory bus request and grant signals. */ sa1110_mb_enable(); +#endif /* * The interrupt controller must be initialised before any diff -Nru a/arch/arm/kernel/entry-armo.S b/arch/arm/kernel/entry-armo.S --- a/arch/arm/kernel/entry-armo.S Tue Mar 4 19:30:05 2003 +++ b/arch/arm/kernel/entry-armo.S Tue Mar 4 19:30:05 2003 @@ -426,7 +426,7 @@ mov r2, #0 tst r4, #1 << 20 @ Check to see if it is a write instruction orreq r2, r2, #FAULT_CODE_WRITE @ Indicate write instruction - mov r1, r4, lsr #22 @ Now branch to the relevent processing routine + mov r1, r4, lsr #22 @ Now branch to the relevant processing routine and r1, r1, #15 << 2 add pc, pc, r1 movs pc, lr diff -Nru a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S --- a/arch/arm/kernel/entry-armv.S Tue Mar 4 19:30:05 2003 +++ b/arch/arm/kernel/entry-armv.S Tue Mar 4 19:30:05 2003 @@ -1026,7 +1026,7 @@ mrs lr, spsr str lr, [r13, #4] @ save spsr_IRQ @ - @ now branch to the relevent MODE handling routine + @ now branch to the relevant MODE handling routine @ mov r13, #PSR_I_BIT | MODE_SVC msr spsr_c, r13 @ switch to SVC_32 mode @@ -1067,7 +1067,7 @@ mrs lr, spsr str lr, [r13, #4] @ - @ now branch to the relevent MODE handling routine + @ now branch to the relevant MODE handling routine @ mov r13, #PSR_I_BIT | MODE_SVC msr spsr_c, r13 @ switch to SVC_32 mode @@ -1109,7 +1109,7 @@ mrs lr, spsr str lr, [r13, #4] @ save spsr_ABT @ - @ now branch to the relevent MODE handling routine + @ now branch to the relevant MODE handling routine @ mov r13, #PSR_I_BIT | MODE_SVC msr spsr_c, r13 @ switch to SVC_32 mode @@ -1150,7 +1150,7 @@ mrs lr, spsr str lr, [r13, #4] @ save spsr_UND @ - @ now branch to the relevent MODE handling routine + @ now branch to the relevant MODE handling routine @ mov r13, #PSR_I_BIT | MODE_SVC msr spsr_c, r13 @ switch to SVC_32 mode diff -Nru a/arch/arm/kernel/head.S b/arch/arm/kernel/head.S --- a/arch/arm/kernel/head.S Tue Mar 4 19:30:03 2003 +++ b/arch/arm/kernel/head.S Tue Mar 4 19:30:03 2003 @@ -37,7 +37,7 @@ .globl swapper_pg_dir .equ swapper_pg_dir, TEXTADDR - 0x4000 - .macro pgtbl, reg, rambase + .macro pgtbl, reg adr \reg, stext sub \reg, \reg, #0x4000 .endm @@ -47,7 +47,7 @@ * can convert the page table base address to the base address of the section * containing both. */ - .macro krnladr, rd, pgtable, rambase + .macro krnladr, rd, pgtable bic \rd, \pgtable, #0x000ff000 .endm @@ -164,7 +164,7 @@ * r8 = page table flags */ __create_page_tables: - pgtbl r4, r5 @ page table address + pgtbl r4 @ page table address /* * Clear the 16K level 1 swapper page table @@ -184,7 +184,7 @@ * cater for the MMU enable. This identity mapping * will be removed by paging_init() */ - krnladr r2, r4, r5 @ start of kernel + krnladr r2, r4 @ start of kernel add r3, r8, r2 @ flags + kernel base str r3, [r4, r2, lsr #18] @ identity mapping diff -Nru a/arch/arm/kernel/ptrace.c b/arch/arm/kernel/ptrace.c --- a/arch/arm/kernel/ptrace.c Tue Mar 4 19:30:04 2003 +++ b/arch/arm/kernel/ptrace.c Tue Mar 4 19:30:04 2003 @@ -435,7 +435,7 @@ * be receiving a prefetch abort shortly. * * If we don't set this breakpoint here, then we can - * loose control of the thread during single stepping. + * lose control of the thread during single stepping. */ if (!alt || predicate(insn) != PREDICATE_ALWAYS) add_breakpoint(child, dbg, pc + 4); diff -Nru a/arch/arm/kernel/time.c b/arch/arm/kernel/time.c --- a/arch/arm/kernel/time.c Tue Mar 4 19:30:11 2003 +++ b/arch/arm/kernel/time.c Tue Mar 4 19:30:11 2003 @@ -32,7 +32,7 @@ #include #include -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; extern unsigned long wall_jiffies; diff -Nru a/arch/arm/mach-iop310/iop310-pci.c b/arch/arm/mach-iop310/iop310-pci.c --- a/arch/arm/mach-iop310/iop310-pci.c Tue Mar 4 19:30:07 2003 +++ b/arch/arm/mach-iop310/iop310-pci.c Tue Mar 4 19:30:07 2003 @@ -296,7 +296,7 @@ * within 3 instructions." * * This does not appear to be the case. With 8 NOPs after the load, we - * see the imprecise abort occuring on the STM of iop310_sec_pci_status() + * see the imprecise abort occurring on the STM of iop310_sec_pci_status() * which is about 10 instructions away. * * Always trust reality! diff -Nru a/arch/arm/mach-iop310/mm.c b/arch/arm/mach-iop310/mm.c --- a/arch/arm/mach-iop310/mm.c Tue Mar 4 19:30:05 2003 +++ b/arch/arm/mach-iop310/mm.c Tue Mar 4 19:30:05 2003 @@ -1,7 +1,7 @@ /* * linux/arch/arm/mach-iop310/mm.c * - * Low level memory intialization for IOP310 based systems + * Low level memory initialization for IOP310 based systems * * Author: Nicolas Pitre * diff -Nru a/arch/arm/mach-pxa/Makefile b/arch/arm/mach-pxa/Makefile --- a/arch/arm/mach-pxa/Makefile Tue Mar 4 19:30:09 2003 +++ b/arch/arm/mach-pxa/Makefile Tue Mar 4 19:30:09 2003 @@ -4,18 +4,17 @@ # Common support (must be linked before board specific support) obj-y += generic.o irq.o dma.o -obj-$(CONFIG_SA1111) += sa1111.o # Specific board support obj-$(CONFIG_ARCH_LUBBOCK) += lubbock.o obj-$(CONFIG_ARCH_PXA_IDP) += idp.o # Support for blinky lights -leds-y := leds.o -leds-$(CONFIG_ARCH_LUBBOCK) += leds-lubbock.o -leds-$(CONFIG_ARCH_PXA_IDP) += leds-idp.o +led-y := leds.o +led-$(CONFIG_ARCH_LUBBOCK) += leds-lubbock.o +led-$(CONFIG_ARCH_PXA_IDP) += leds-idp.o -obj-$(CONFIG_LEDS) += $(leds-y) +obj-$(CONFIG_LEDS) += $(led-y) # Misc features obj-$(CONFIG_PM) += pm.o sleep.o diff -Nru a/arch/arm/mach-pxa/generic.c b/arch/arm/mach-pxa/generic.c --- a/arch/arm/mach-pxa/generic.c Tue Mar 4 19:30:05 2003 +++ b/arch/arm/mach-pxa/generic.c Tue Mar 4 19:30:05 2003 @@ -38,7 +38,7 @@ static unsigned char L_clk_mult[32] = { 0, 27, 32, 36, 40, 45, 0, }; /* Memory Frequency to Run Mode Frequency Multiplier (M) */ -static unsigned char M_clk_mult[4] = { 0, 1, 2, 0 }; +static unsigned char M_clk_mult[4] = { 0, 1, 2, 4 }; /* Run Mode Frequency to Turbo Mode Frequency Multiplier (N) */ /* Note: we store the value N * 2 here. */ @@ -47,11 +47,12 @@ /* Crystal clock */ #define BASE_CLK 3686400 - /* - * Display what we were booted with. + * Get the clock frequency as reflected by CCCR and the turbo flag. + * We assume these values have been applied via a fcs. + * If info is not 0 we also display the current settings. */ -static int __init pxa_display_clocks(void) +unsigned int get_clk_frequency_khz(int info) { unsigned long cccr, turbo; unsigned int l, L, m, M, n2, N; @@ -67,20 +68,24 @@ M = m * L; N = n2 * M / 2; - L += 5000; - printk( KERN_INFO "Memory clock: %d.%02dMHz (*%d)\n", - L / 1000000, (L % 1000000) / 10000, l ); - M += 5000; - printk( KERN_INFO "Run Mode clock: %d.%02dMHz (*%d)\n", - M / 1000000, (M % 1000000) / 10000, m ); - N += 5000; - printk( KERN_INFO "Turbo Mode clock: %d.%02dMHz (*%d.%d, %sactive)\n", - N / 1000000, (N % 1000000) / 10000, n2 / 2, (n2 % 2) * 5, - (turbo & 1) ? "" : "in" ); + if(info) + { + L += 5000; + printk( KERN_INFO "Memory clock: %d.%02dMHz (*%d)\n", + L / 1000000, (L % 1000000) / 10000, l ); + M += 5000; + printk( KERN_INFO "Run Mode clock: %d.%02dMHz (*%d)\n", + M / 1000000, (M % 1000000) / 10000, m ); + N += 5000; + printk( KERN_INFO "Turbo Mode clock: %d.%02dMHz (*%d.%d, %sactive)\n", + N / 1000000, (N % 1000000) / 10000, n2 / 2, (n2 % 2) * 5, + (turbo & 1) ? "" : "in" ); + } - return 0; + return (turbo & 1) ? (N/1000) : (M/1000); } +EXPORT_SYMBOL(get_clk_frequency_khz); /* * Return the current lclk requency in units of 10kHz @@ -132,5 +137,5 @@ void __init pxa_map_io(void) { iotable_init(standard_io_desc, ARRAY_SIZE(standard_io_desc)); - pxa_display_clocks(); + get_clk_frequency_khz(1); } diff -Nru a/arch/arm/mach-pxa/irq.c b/arch/arm/mach-pxa/irq.c --- a/arch/arm/mach-pxa/irq.c Tue Mar 4 19:30:13 2003 +++ b/arch/arm/mach-pxa/irq.c Tue Mar 4 19:30:13 2003 @@ -86,7 +86,7 @@ } /* - * GPIO IRQs must be acknoledged. This is for GPIO 0 and 1. + * GPIO IRQs must be acknowledged. This is for GPIO 0 and 1. */ static void pxa_ack_low_gpio(unsigned int irq) @@ -241,10 +241,4 @@ /* Install handler for GPIO 2-80 edge detect interrupts */ set_irq_chip(IRQ_GPIO_2_80, &pxa_internal_chip); set_irq_chained_handler(IRQ_GPIO_2_80, pxa_gpio_demux_handler); - - /* - * We generally don't want the LCD IRQ being - * enabled as soon as we request it. - */ - set_irq_flags(IRQ_LCD, IRQF_VALID | IRQF_NOAUTOEN); } diff -Nru a/arch/arm/mach-pxa/leds.c b/arch/arm/mach-pxa/leds.c --- a/arch/arm/mach-pxa/leds.c Tue Mar 4 19:30:14 2003 +++ b/arch/arm/mach-pxa/leds.c Tue Mar 4 19:30:14 2003 @@ -27,4 +27,4 @@ return 0; } -__initcall(pxa_leds_init); +core_initcall(pxa_leds_init); diff -Nru a/arch/arm/mach-pxa/lubbock.c b/arch/arm/mach-pxa/lubbock.c --- a/arch/arm/mach-pxa/lubbock.c Tue Mar 4 19:30:07 2003 +++ b/arch/arm/mach-pxa/lubbock.c Tue Mar 4 19:30:07 2003 @@ -13,6 +13,7 @@ */ #include #include +#include #include #include #include @@ -31,7 +32,6 @@ #include #include "generic.h" -#include "sa1111.h" static void lubbock_ack_irq(unsigned int irq) { @@ -106,24 +106,16 @@ static int __init lubbock_init(void) { - int ret; - - ret = sa1111_probe(LUBBOCK_SA1111_BASE); - if (ret) - return ret; - sa1111_wake(); - sa1111_init_irq(LUBBOCK_SA1111_IRQ); - return 0; + return sa1111_init(0x10000000, LUBBOCK_SA1111_IRQ); } -__initcall(lubbock_init); +subsys_initcall(lubbock_init); static struct map_desc lubbock_io_desc[] __initdata = { /* virtual physical length type */ { 0xf0000000, 0x08000000, 0x00100000, MT_DEVICE }, /* CPLD */ { 0xf1000000, 0x0c000000, 0x00100000, MT_DEVICE }, /* LAN91C96 IO */ { 0xf1100000, 0x0e000000, 0x00100000, MT_DEVICE }, /* LAN91C96 Attr */ - { 0xf4000000, 0x10000000, 0x00400000, MT_DEVICE } /* SA1111 */ }; static void __init lubbock_map_io(void) diff -Nru a/arch/arm/mach-sa1100/irq.c b/arch/arm/mach-sa1100/irq.c --- a/arch/arm/mach-sa1100/irq.c Tue Mar 4 19:30:14 2003 +++ b/arch/arm/mach-sa1100/irq.c Tue Mar 4 19:30:14 2003 @@ -68,7 +68,7 @@ } /* - * GPIO IRQs must be acknoledged. This is for IRQs from 0 to 10. + * GPIO IRQs must be acknowledged. This is for IRQs from 0 to 10. */ static void sa1100_low_gpio_ack(unsigned int irq) { diff -Nru a/arch/arm/mm/proc-arm6_7.S b/arch/arm/mm/proc-arm6_7.S --- a/arch/arm/mm/proc-arm6_7.S Tue Mar 4 19:30:12 2003 +++ b/arch/arm/mm/proc-arm6_7.S Tue Mar 4 19:30:12 2003 @@ -97,7 +97,7 @@ tst r4, r4, lsr #21 @ C = bit 20 sbc r1, r1, r1 @ r1 = C - 1 and r2, r4, #15 << 24 - add pc, pc, r2, lsr #22 @ Now branch to the relevent processing routine + add pc, pc, r2, lsr #22 @ Now branch to the relevant processing routine movs pc, lr b Ldata_unknown diff -Nru a/arch/cris/boot/rescue/head.S b/arch/cris/boot/rescue/head.S --- a/arch/cris/boot/rescue/head.S Tue Mar 4 19:30:12 2003 +++ b/arch/cris/boot/rescue/head.S Tue Mar 4 19:30:12 2003 @@ -130,7 +130,7 @@ ;; first put a jump test to give a possibility of upgrading the rescue code ;; without erasing/reflashing the sector. we put a longword of -1 here and if - ;; its not -1, we jump using the value as jump target. since we can always + ;; it is not -1, we jump using the value as jump target. since we can always ;; change 1's to 0's without erasing the sector, it is possible to add new ;; code after this and altering the jumptarget in an upgrade. diff -Nru a/arch/cris/drivers/eeprom.c b/arch/cris/drivers/eeprom.c --- a/arch/cris/drivers/eeprom.c Tue Mar 4 19:30:07 2003 +++ b/arch/cris/drivers/eeprom.c Tue Mar 4 19:30:07 2003 @@ -815,7 +815,7 @@ i2c_outbyte( eeprom.select_cmd | 1 ); } - if(i2c_getack()); + if(i2c_getack()) { break; } diff -Nru a/arch/cris/drivers/ethernet.c b/arch/cris/drivers/ethernet.c --- a/arch/cris/drivers/ethernet.c Tue Mar 4 19:30:08 2003 +++ b/arch/cris/drivers/ethernet.c Tue Mar 4 19:30:08 2003 @@ -236,7 +236,7 @@ /* Network speed indication. */ static struct timer_list speed_timer = TIMER_INITIALIZER(NULL, 0, 0); static struct timer_list clear_led_timer = TIMER_INITIALIZER(NULL, 0, 0); -static int current_speed; /* Speed read from tranceiver */ +static int current_speed; /* Speed read from transceiver */ static int current_speed_selection; /* Speed selected by user */ static int led_next_time; static int led_active; @@ -276,7 +276,7 @@ static void e100_send_mdio_cmd(unsigned short cmd, int write_cmd); static void e100_send_mdio_bit(unsigned char bit); static unsigned char e100_receive_mdio_bit(void); -static void e100_reset_tranceiver(void); +static void e100_reset_transceiver(void); static void e100_clear_network_leds(unsigned long dummy); static void e100_set_network_leds(int active); @@ -786,7 +786,7 @@ } static void -e100_reset_tranceiver(void) +e100_reset_transceiver(void) { unsigned short cmd; unsigned short data; @@ -826,9 +826,9 @@ RESET_DMA(NETWORK_TX_DMA_NBR); WAIT_DMA(NETWORK_TX_DMA_NBR); - /* Reset the tranceiver. */ + /* Reset the transceiver. */ - e100_reset_tranceiver(); + e100_reset_transceiver(); /* and get rid of the packet that never got an interrupt */ diff -Nru a/arch/cris/drivers/lpslave/e100lpslavenet.c b/arch/cris/drivers/lpslave/e100lpslavenet.c --- a/arch/cris/drivers/lpslave/e100lpslavenet.c Tue Mar 4 19:30:07 2003 +++ b/arch/cris/drivers/lpslave/e100lpslavenet.c Tue Mar 4 19:30:07 2003 @@ -129,7 +129,7 @@ static void e100_hardware_send_packet(unsigned long hostcmd, char *buf, int length); static void update_rx_stats(struct net_device_stats *); static void update_tx_stats(struct net_device_stats *); -static void e100_reset_tranceiver(void); +static void e100_reset_transceiver(void); static void boot_slave(unsigned char *code); @@ -528,7 +528,7 @@ } static void -e100_reset_tranceiver(void) +e100_reset_transceiver(void) { /* To do: Reboot and setup slave Etrax */ } @@ -554,9 +554,9 @@ RESET_DMA(4); WAIT_DMA(4); - /* Reset the tranceiver. */ + /* Reset the transceiver. */ - e100_reset_tranceiver(); + e100_reset_transceiver(); /* and get rid of the packet that never got an interrupt */ diff -Nru a/arch/cris/drivers/serial.c b/arch/cris/drivers/serial.c --- a/arch/cris/drivers/serial.c Tue Mar 4 19:30:11 2003 +++ b/arch/cris/drivers/serial.c Tue Mar 4 19:30:11 2003 @@ -132,7 +132,7 @@ * Items worth noticing: * * No Etrax100 port 1 workarounds (does only compile on 2.4 anyway now) - * RS485 is not ported (why cant it be done in userspace as on x86 ?) + * RS485 is not ported (why can't it be done in userspace as on x86 ?) * Statistics done through async_icount - if any more stats are needed, * that's the place to put them or in an arch-dep version of it. * timeout_interrupt and the other fast timeout stuff not ported yet @@ -1766,7 +1766,7 @@ B= Break character (0x00) with framing error. E= Error byte with parity error received after B characters. -F= "Faked" valid byte received immediatly after B characters. +F= "Faked" valid byte received immediately after B characters. V= Valid byte 1. @@ -2802,7 +2802,7 @@ info->tx_ctrl |= (0x80 | 0x40); /* Set bit 7 (txd) and 6 (tr_enable) */ info->port[REG_TR_CTRL] = info->tx_ctrl; - /* the DMA gets awfully confused if we toggle the tranceiver like this + /* the DMA gets awfully confused if we toggle the transceiver like this * so we need to reset it */ *info->ocmdadr = 4; diff -Nru a/arch/cris/kernel/kgdb.c b/arch/cris/kernel/kgdb.c --- a/arch/cris/kernel/kgdb.c Tue Mar 4 19:30:13 2003 +++ b/arch/cris/kernel/kgdb.c Tue Mar 4 19:30:13 2003 @@ -152,7 +152,7 @@ * (IPL too high, disabled, ...) * * - The gdb stub is currently not reentrant, i.e. errors that happen therein - * (e.g. accesing invalid memory) may not be caught correctly. This could + * (e.g. accessing invalid memory) may not be caught correctly. This could * be removed in future by introducing a stack of struct registers. * */ @@ -1486,7 +1486,7 @@ move.d $r0,[reg+0x62] ; Save the return address in BRP move $usp,[reg+0x66] ; USP -;; get the serial character (from debugport.c) and check if its a ctrl-c +;; get the serial character (from debugport.c) and check if it is a ctrl-c jsr getDebugChar cmp.b 3, $r10 diff -Nru a/arch/cris/kernel/process.c b/arch/cris/kernel/process.c --- a/arch/cris/kernel/process.c Tue Mar 4 19:30:10 2003 +++ b/arch/cris/kernel/process.c Tue Mar 4 19:30:10 2003 @@ -154,7 +154,7 @@ #if defined(CONFIG_ETRAX_WATCHDOG) && !defined(CONFIG_SVINTO_SIM) cause_of_death = 0xbedead; #else - /* Since we dont plan to keep on reseting the watchdog, + /* Since we don't plan to keep on reseting the watchdog, the key can be arbitrary hence three */ *R_WATCHDOG = IO_FIELD(R_WATCHDOG, key, 3) | IO_STATE(R_WATCHDOG, enable, start); @@ -226,7 +226,7 @@ swstack = ((struct switch_stack *)childregs) - 1; - swstack->r9 = 0; /* parameter to ret_from_sys_call, 0 == dont restart the syscall */ + swstack->r9 = 0; /* parameter to ret_from_sys_call, 0 == don't restart the syscall */ /* we want to return into ret_from_sys_call after the _resume */ diff -Nru a/arch/cris/kernel/setup.c b/arch/cris/kernel/setup.c --- a/arch/cris/kernel/setup.c Tue Mar 4 19:30:13 2003 +++ b/arch/cris/kernel/setup.c Tue Mar 4 19:30:13 2003 @@ -164,7 +164,7 @@ paging_init(); - /* We dont use a command line yet, so just re-initialize it without + /* We don't use a command line yet, so just re-initialize it without saving anything that might be there. */ *cmdline_p = command_line; diff -Nru a/arch/cris/kernel/signal.c b/arch/cris/kernel/signal.c --- a/arch/cris/kernel/signal.c Tue Mar 4 19:30:04 2003 +++ b/arch/cris/kernel/signal.c Tue Mar 4 19:30:04 2003 @@ -494,7 +494,7 @@ case -ERESTARTNOHAND: /* ERESTARTNOHAND means that the syscall should only be restarted if there was no handler for the signal, and since - we only get here if there is a handler, we dont restart */ + we only get here if there is a handler, we don't restart */ regs->r10 = -EINTR; break; diff -Nru a/arch/cris/kernel/time.c b/arch/cris/kernel/time.c --- a/arch/cris/kernel/time.c Tue Mar 4 19:30:09 2003 +++ b/arch/cris/kernel/time.c Tue Mar 4 19:30:09 2003 @@ -45,7 +45,7 @@ #include -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static int have_rtc; /* used to remember if we have an RTC or not */ diff -Nru a/arch/cris/mm/fault.c b/arch/cris/mm/fault.c --- a/arch/cris/mm/fault.c Tue Mar 4 19:30:13 2003 +++ b/arch/cris/mm/fault.c Tue Mar 4 19:30:13 2003 @@ -170,7 +170,7 @@ if (miss) { /* see if the pte exists at all - * refer through current_pgd, dont use mm->pgd + * refer through current_pgd, don't use mm->pgd */ pmd = (pmd_t *)(current_pgd + pgd_index(address)); diff -Nru a/arch/cris/mm/tlb.c b/arch/cris/mm/tlb.c --- a/arch/cris/mm/tlb.c Tue Mar 4 19:30:04 2003 +++ b/arch/cris/mm/tlb.c Tue Mar 4 19:30:04 2003 @@ -58,7 +58,7 @@ int i; unsigned long flags; - /* the vpn of i & 0xf is so we dont write similar TLB entries + /* the vpn of i & 0xf is so we don't write similar TLB entries * in the same 4-way entry group. details.. */ diff -Nru a/arch/i386/Kconfig b/arch/i386/Kconfig --- a/arch/i386/Kconfig Tue Mar 4 19:30:04 2003 +++ b/arch/i386/Kconfig Tue Mar 4 19:30:04 2003 @@ -19,8 +19,13 @@ default y config SWAP - bool + bool "Support for paging of anonymous memory" default y + help + This option allows you to choose whether you want to have support + for socalled swap devices or swap files in your kernel that are + used to provide more virtual memory than the actual RAM present + in your computer. If unusre say Y. config SBUS bool @@ -75,6 +80,11 @@ If you don't have one of these computers, you should say N here. +config ACPI_SRAT + bool + default y + depends on NUMA && X86_SUMMIT + config X86_BIGSMP bool "Support for other sub-arch SMP systems with more than 8 CPUs" help @@ -337,11 +347,6 @@ depends on MWINCHIP3D || MWINCHIP2 || MWINCHIPC6 || MCYRIXIII || MELAN || MK6 || M586MMX || M586TSC || M586 || M486 || MVIAC3_2 default y -config X86_TSC - bool - depends on MWINCHIP3D || MWINCHIP2 || MCRUSOE || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2 - default y - config X86_GOOD_APIC bool depends on MK7 || MPENTIUM4 || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || MK8 @@ -483,7 +488,7 @@ # Common NUMA Features config NUMA bool "Numa Memory Allocation Support" - depends on X86_NUMAQ + depends on (HIGHMEM64G && (X86_NUMAQ || (X86_SUMMIT && ACPI && !ACPI_HT_ONLY))) config DISCONTIGMEM bool @@ -495,6 +500,11 @@ depends on NUMA default y +config X86_TSC + bool + depends on (MWINCHIP3D || MWINCHIP2 || MCRUSOE || MCYRIXIII || MK7 || MK6 || MPENTIUM4 || MPENTIUMIII || MPENTIUMII || M686 || M586MMX || M586TSC || MK8 || MVIAC3_2) && !X86_NUMAQ + default y + config X86_MCE bool "Machine Check Exception" ---help--- @@ -750,6 +760,13 @@ config HAVE_DEC_LOCK bool depends on (SMP || PREEMPT) && X86_CMPXCHG + default y + +# turning this on wastes a bunch of space. +# Summit needs it only when NUMA is on +config BOOT_IOREMAP + bool + depends on (X86_SUMMIT && NUMA) default y endmenu diff -Nru a/arch/i386/boot/bootsect.S b/arch/i386/boot/bootsect.S --- a/arch/i386/boot/bootsect.S Tue Mar 4 19:30:09 2003 +++ b/arch/i386/boot/bootsect.S Tue Mar 4 19:30:09 2003 @@ -405,7 +405,7 @@ ret sectors: .word 0 -disksizes: .byte 36, 18, 15, 9 +disksizes: .byte 36, 21, 18, 15, 9 msg1: .byte 13, 10 .ascii "Loading" diff -Nru a/arch/i386/kernel/Makefile b/arch/i386/kernel/Makefile --- a/arch/i386/kernel/Makefile Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/Makefile Tue Mar 4 19:30:05 2003 @@ -28,6 +28,7 @@ obj-$(CONFIG_EDD) += edd.o obj-$(CONFIG_MODULES) += module.o obj-y += sysenter.o +obj-$(CONFIG_ACPI_SRAT) += srat.o EXTRA_AFLAGS := -traditional diff -Nru a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c --- a/arch/i386/kernel/acpi/boot.c Tue Mar 4 19:30:13 2003 +++ b/arch/i386/kernel/acpi/boot.c Tue Mar 4 19:30:13 2003 @@ -24,6 +24,7 @@ */ #include +#include #include #include #include diff -Nru a/arch/i386/kernel/acpi/sleep.c b/arch/i386/kernel/acpi/sleep.c --- a/arch/i386/kernel/acpi/sleep.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/kernel/acpi/sleep.c Tue Mar 4 19:30:08 2003 @@ -2,6 +2,7 @@ * sleep.c - x86-specific ACPI sleep support. * * Copyright (C) 2001-2003 Patrick Mochel + * Copyright (C) 2001-2003 Pavel Machek */ #include @@ -34,10 +35,8 @@ */ int acpi_save_state_mem (void) { -#if CONFIG_X86_PAE - panic("S3 and PAE do not like each other for now."); - return 1; -#endif + if (!acpi_wakeup_address) + return 1; init_low_mapping(swapper_pg_dir, USER_PTRS_PER_PGD); memcpy((void *) acpi_wakeup_address, &wakeup_start, &wakeup_end - &wakeup_start); acpi_copy_wakeup_routine(acpi_wakeup_address); @@ -65,17 +64,24 @@ /** * acpi_reserve_bootmem - do _very_ early ACPI initialisation * - * We allocate a page in low memory for the wakeup + * We allocate a page from the first 1MB of memory for the wakeup * routine for when we come back from a sleep state. The - * runtime allocator allows specification of <16M pages, but not - * <1M pages. + * runtime allocator allows specification of <16MB pages, but not + * <1MB pages. */ void __init acpi_reserve_bootmem(void) { + if ((&wakeup_end - &wakeup_start) > PAGE_SIZE) { + printk(KERN_ERR "ACPI: Wakeup code way too big, S3 disabled.\n"); + return; + } +#if CONFIG_X86_PAE + printk(KERN_ERR "ACPI: S3 and PAE do not like each other for now, S3 disabled.\n"); + return; +#endif acpi_wakeup_address = (unsigned long)alloc_bootmem_low(PAGE_SIZE); - if ((&wakeup_end - &wakeup_start) > PAGE_SIZE) - printk(KERN_CRIT "ACPI: Wakeup code way too big, will crash on attempt to suspend\n"); - printk(KERN_DEBUG "ACPI: have wakeup address 0x%8.8lx\n", acpi_wakeup_address); + if (!acpi_wakeup_address) + printk(KERN_ERR "ACPI: Cannot allocate lowmem, S3 disabled.\n"); } static int __init acpi_sleep_setup(char *str) diff -Nru a/arch/i386/kernel/acpi/wakeup.S b/arch/i386/kernel/acpi/wakeup.S --- a/arch/i386/kernel/acpi/wakeup.S Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/acpi/wakeup.S Tue Mar 4 19:30:05 2003 @@ -44,6 +44,9 @@ testl $1, video_flags - wakeup_code jz 1f lcall $0xc000,$3 + movw %cs, %ax + movw %ax, %ds # Bios might have played with that + movw %ax, %ss 1: testl $2, video_flags - wakeup_code @@ -314,6 +317,31 @@ movl saved_context_edi, %edi call restore_processor_state pushl saved_context_eflags ; popfl + ret + +ENTRY(do_suspend_lowlevel_s4bios) + cmpl $0,4(%esp) + jne ret_point + call save_processor_state + + movl %esp, saved_context_esp + movl %eax, saved_context_eax + movl %ebx, saved_context_ebx + movl %ecx, saved_context_ecx + movl %edx, saved_context_edx + movl %ebp, saved_context_ebp + movl %esi, saved_context_esi + movl %edi, saved_context_edi + pushfl ; popl saved_context_eflags + + movl $ret_point,saved_eip + movl %esp,saved_esp + movl %ebp,saved_ebp + movl %ebx,saved_ebx + movl %edi,saved_edi + movl %esi,saved_esi + + call acpi_enter_sleep_state_s4bios ret ALIGN diff -Nru a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c --- a/arch/i386/kernel/apic.c Tue Mar 4 19:30:14 2003 +++ b/arch/i386/kernel/apic.c Tue Mar 4 19:30:14 2003 @@ -665,7 +665,6 @@ } set_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability); mp_lapic_addr = APIC_DEFAULT_PHYS_BASE; - boot_cpu_physical_apicid = 0; if (nmi_watchdog != NMI_NONE) nmi_watchdog = NMI_LOCAL_APIC; @@ -1154,8 +1153,7 @@ connect_bsp_APIC(); - phys_cpu_present_map = 1; - apic_write_around(APIC_ID, boot_cpu_physical_apicid); + phys_cpu_present_map = 1 << boot_cpu_physical_apicid; apic_pm_init2(); diff -Nru a/arch/i386/kernel/apm.c b/arch/i386/kernel/apm.c --- a/arch/i386/kernel/apm.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/apm.c Tue Mar 4 19:30:04 2003 @@ -1096,7 +1096,7 @@ * @blank: on/off * * Attempt to blank the console, firstly by blanking just video device - * zero, and if that fails (some BIOSes dont support it) then it blanks + * zero, and if that fails (some BIOSes don't support it) then it blanks * all video devices. Typically the BIOS will do laptop backlight and * monitor powerdown for us. */ diff -Nru a/arch/i386/kernel/cpu/amd.c b/arch/i386/kernel/cpu/amd.c --- a/arch/i386/kernel/cpu/amd.c Tue Mar 4 19:30:14 2003 +++ b/arch/i386/kernel/cpu/amd.c Tue Mar 4 19:30:14 2003 @@ -151,11 +151,10 @@ case 6: /* An Athlon/Duron */ /* Bit 15 of Athlon specific MSR 15, needs to be 0 - * to enable SSE on Palomino/Morgan CPU's. - * If the BIOS didn't enable it already, enable it - * here. + * to enable SSE on Palomino/Morgan/Barton CPU's. + * If the BIOS didn't enable it already, enable it here. */ - if (c->x86_model == 6 || c->x86_model == 7) { + if (c->x86_model >= 6 && c->x86_model <= 10) { if (!cpu_has(c, X86_FEATURE_XMM)) { printk(KERN_INFO "Enabling disabled K7/SSE Support.\n"); rdmsr(MSR_K7_HWCR, l, h); diff -Nru a/arch/i386/kernel/cpu/centaur.c b/arch/i386/kernel/cpu/centaur.c --- a/arch/i386/kernel/cpu/centaur.c Tue Mar 4 19:30:10 2003 +++ b/arch/i386/kernel/cpu/centaur.c Tue Mar 4 19:30:10 2003 @@ -412,8 +412,9 @@ size >>= 8; /* VIA also screwed up Nehemiah stepping 1, and made - it return '65KB' instead of '64KB' */ - if ((c->x86==6) && (c->x86_model==9) && (c->x86_mask==1)) + it return '65KB' instead of '64KB' + - Note, it seems this may only be in engineering samples. */ + if ((c->x86==6) && (c->x86_model==9) && (c->x86_mask==1) && (size==65)) size -=1; return size; diff -Nru a/arch/i386/kernel/cpu/cpufreq/Kconfig b/arch/i386/kernel/cpu/cpufreq/Kconfig --- a/arch/i386/kernel/cpu/cpufreq/Kconfig Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/cpu/cpufreq/Kconfig Tue Mar 4 19:30:05 2003 @@ -18,20 +18,6 @@ source "drivers/cpufreq/Kconfig" -config CPU_FREQ_24_API - bool "/proc/sys/cpu/ interface (2.4. / OLD)" - depends on CPU_FREQ - help - This enables the /proc/sys/cpu/ sysctl interface for controlling - CPUFreq, as known from the 2.4.-kernel patches for CPUFreq. 2.5 - uses a sysfs interface instead. Please note that some drivers do - not work well with the 2.4. /proc/sys/cpu sysctl interface, - so if in doubt, say N here. - - For details, take a look at linux/Documentation/cpufreq. - - If in doubt, say N. - config CPU_FREQ_TABLE tristate "CPU frequency table helpers" depends on CPU_FREQ @@ -56,6 +42,16 @@ If in doubt, say N. +config X86_ACPI_CPUFREQ_PROC_INTF + bool "/proc/acpi/processor/../performance interface (deprecated)" + depends on X86_ACPI_CPUFREQ && PROC_FS + help + This enables the deprecated /proc/acpi/processor/../performance + interface. While it is helpful for debugging, the generic, + cross-architecture cpufreq interfaces should be used. + + If in doubt, say N. + config ELAN_CPUFREQ tristate "AMD Elan" depends on CPU_FREQ_TABLE && MELAN @@ -139,7 +135,7 @@ config X86_LONGHAUL tristate "VIA Cyrix III Longhaul" - depends on CPU_FREQ + depends on CPU_FREQ_TABLE help This adds the CPUFreq driver for VIA Samuel/CyrixIII, VIA Cyrix Samuel/C3, VIA Cyrix Ezra and VIA Cyrix Ezra-T diff -Nru a/arch/i386/kernel/cpu/cpufreq/acpi.c b/arch/i386/kernel/cpu/cpufreq/acpi.c --- a/arch/i386/kernel/cpu/cpufreq/acpi.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/cpu/cpufreq/acpi.c Tue Mar 4 19:30:04 2003 @@ -1,5 +1,5 @@ /* - * acpi_processor_perf.c - ACPI Processor P-States Driver ($Revision: 71 $) + * acpi_processor_perf.c - ACPI Processor P-States Driver ($Revision: 1.3 $) * * Copyright (C) 2001, 2002 Andy Grover * Copyright (C) 2001, 2002 Paul Diefenbaugh @@ -50,23 +50,12 @@ MODULE_LICENSE("GPL"); -/* Performance Management */ - static struct acpi_processor_performance *performance; -static struct cpufreq_driver acpi_cpufreq_driver; - -static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file); -static struct file_operations acpi_processor_perf_fops = { - .open = acpi_processor_perf_open_fs, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; static int acpi_processor_get_performance_control ( - struct acpi_processor *pr) + struct acpi_processor_performance *perf) { int result = 0; acpi_status status = 0; @@ -77,7 +66,7 @@ ACPI_FUNCTION_TRACE("acpi_processor_get_performance_control"); - status = acpi_evaluate_object(pr->handle, "_PCT", NULL, &buffer); + status = acpi_evaluate_object(perf->pr->handle, "_PCT", NULL, &buffer); if(ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PCT\n")); return_VALUE(-ENODEV); @@ -116,7 +105,7 @@ goto end; } - pr->performance->control_register = (u16) reg->address; + perf->control_register = (u16) reg->address; /* * status_register @@ -143,12 +132,12 @@ goto end; } - pr->performance->status_register = (u16) reg->address; + perf->status_register = (u16) reg->address; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "control_register[0x%04x] status_register[0x%04x]\n", - pr->performance->control_register, - pr->performance->status_register)); + perf->control_register, + perf->status_register)); end: acpi_os_free(buffer.pointer); @@ -159,7 +148,7 @@ static int acpi_processor_get_performance_states ( - struct acpi_processor* pr) + struct acpi_processor_performance * perf) { int result = 0; acpi_status status = AE_OK; @@ -171,7 +160,7 @@ ACPI_FUNCTION_TRACE("acpi_processor_get_performance_states"); - status = acpi_evaluate_object(pr->handle, "_PSS", NULL, &buffer); + status = acpi_evaluate_object(perf->pr->handle, "_PSS", NULL, &buffer); if(ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PSS\n")); return_VALUE(-ENODEV); @@ -188,20 +177,20 @@ pss->package.count)); if (pss->package.count > ACPI_PROCESSOR_MAX_PERFORMANCE) { - pr->performance->state_count = ACPI_PROCESSOR_MAX_PERFORMANCE; + perf->state_count = ACPI_PROCESSOR_MAX_PERFORMANCE; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Limiting number of states to max (%d)\n", ACPI_PROCESSOR_MAX_PERFORMANCE)); } else - pr->performance->state_count = pss->package.count; + perf->state_count = pss->package.count; - if (pr->performance->state_count > 1) - pr->flags.performance = 1; + if (perf->state_count > 1) + perf->pr->flags.performance = 1; - for (i = 0; i < pr->performance->state_count; i++) { + for (i = 0; i < perf->state_count; i++) { - struct acpi_processor_px *px = &(pr->performance->states[i]); + struct acpi_processor_px *px = &(perf->states[i]); state.length = sizeof(struct acpi_processor_px); state.pointer = px; @@ -236,7 +225,7 @@ static int acpi_processor_set_performance ( - struct acpi_processor *pr, + struct acpi_processor_performance *perf, int state) { u16 port = 0; @@ -246,38 +235,38 @@ ACPI_FUNCTION_TRACE("acpi_processor_set_performance"); - if (!pr) + if (!perf || !perf->pr) return_VALUE(-EINVAL); - if (!pr->flags.performance) + if (!perf->pr->flags.performance) return_VALUE(-ENODEV); - if (state >= pr->performance->state_count) { + if (state >= perf->state_count) { ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Invalid target state (P%d)\n", state)); return_VALUE(-ENODEV); } - if (state < pr->performance_platform_limit) { + if (state < perf->pr->performance_platform_limit) { ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Platform limit (P%d) overrides target state (P%d)\n", - pr->performance->platform_limit, state)); + perf->pr->performance_platform_limit, state)); return_VALUE(-ENODEV); } - if (state == pr->performance->state) { + if (state == perf->state) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Already at target state (P%d)\n", state)); return_VALUE(0); } ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Transitioning from P%d to P%d\n", - pr->performance->state, state)); + perf->state, state)); /* cpufreq frequency struct */ - cpufreq_freqs.cpu = pr->id; - cpufreq_freqs.old = pr->performance->states[pr->performance->state].core_frequency; - cpufreq_freqs.new = pr->performance->states[state].core_frequency; + cpufreq_freqs.cpu = perf->pr->id; + cpufreq_freqs.old = perf->states[perf->state].core_frequency; + cpufreq_freqs.new = perf->states[state].core_frequency; /* notify cpufreq */ cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_PRECHANGE); @@ -287,8 +276,8 @@ * control_register. */ - port = pr->performance->control_register; - value = (u16) pr->performance->states[state].control; + port = perf->control_register; + value = (u16) perf->states[state].control; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Writing 0x%02x to port 0x%04x\n", value, port)); @@ -302,15 +291,15 @@ * giving up. */ - port = pr->performance->status_register; + port = perf->status_register; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Looking for 0x%02x from port 0x%04x\n", - (u8) pr->performance->states[state].status, port)); + (u8) perf->states[state].status, port)); for (i=0; i<100; i++) { value = inb(port); - if (value == (u8) pr->performance->states[state].status) + if (value == (u8) perf->states[state].status) break; udelay(10); } @@ -318,7 +307,7 @@ /* notify cpufreq */ cpufreq_notify_transition(&cpufreq_freqs, CPUFREQ_POSTCHANGE); - if (value != pr->performance->states[state].status) { + if (value != perf->states[state].status) { unsigned int tmp = cpufreq_freqs.new; cpufreq_freqs.new = cpufreq_freqs.old; cpufreq_freqs.old = tmp; @@ -332,11 +321,23 @@ "Transition successful after %d microseconds\n", i * 10)); - pr->performance->state = state; + perf->state = state; return_VALUE(0); } + +#ifdef CONFIG_X86_ACPI_CPUFREQ_PROC_INTF +/* /proc/acpi/processor/../performance interface (DEPRECATED) */ + +static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file); +static struct file_operations acpi_processor_perf_fops = { + .open = acpi_processor_perf_open_fs, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + static int acpi_processor_perf_seq_show(struct seq_file *seq, void *offset) { struct acpi_processor *pr = (struct acpi_processor *)seq->private; @@ -347,7 +348,7 @@ if (!pr) goto end; - if (!pr->flags.performance) { + if (!pr->flags.performance || !pr->performance) { seq_puts(seq, "\n"); goto end; } @@ -379,8 +380,8 @@ acpi_processor_write_performance ( struct file *file, const char *buffer, - unsigned long count, - void *data) + size_t count, + loff_t *data) { int result = 0; struct acpi_processor *pr = (struct acpi_processor *) data; @@ -411,24 +412,78 @@ return_VALUE(count); } +static void +acpi_cpufreq_add_file ( + struct acpi_processor *pr) +{ + struct proc_dir_entry *entry = NULL; + struct acpi_device *device = NULL; + + ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile"); + + if (acpi_bus_get_device(pr->handle, &device)) + return_VOID; + + /* add file 'performance' [R/W] */ + entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE, + S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device)); + if (!entry) + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "Unable to create '%s' fs entry\n", + ACPI_PROCESSOR_FILE_PERFORMANCE)); + else { + entry->proc_fops = &acpi_processor_perf_fops; + entry->proc_fops->write = acpi_processor_write_performance; + entry->data = acpi_driver_data(device); + } + return_VOID; +} + +static void +acpi_cpufreq_remove_file ( + struct acpi_processor *pr) +{ + struct acpi_device *device = NULL; + + ACPI_FUNCTION_TRACE("acpi_cpufreq_addfile"); + + if (acpi_bus_get_device(pr->handle, &device)) + return_VOID; + + /* remove file 'performance' */ + remove_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE, + acpi_device_dir(device)); + + return_VOID; +} + +#else +static void acpi_cpufreq_add_file (struct acpi_processor *pr) { return; } +static void acpi_cpufreq_remove_file (struct acpi_processor *pr) { return; } +#endif /* CONFIG_X86_ACPI_CPUFREQ_PROC_INTF */ + static int -acpi_cpufreq_setpolicy ( - struct cpufreq_policy *policy) +acpi_cpufreq_target ( + struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { - struct acpi_processor *pr = performance[policy->cpu].pr; + struct acpi_processor_performance *perf = &performance[policy->cpu]; unsigned int next_state = 0; unsigned int result = 0; ACPI_FUNCTION_TRACE("acpi_cpufreq_setpolicy"); - result = cpufreq_frequency_table_setpolicy(policy, - &performance[policy->cpu].freq_table[pr->limit.state.px], + result = cpufreq_frequency_table_target(policy, + &perf->freq_table[perf->pr->limit.state.px], + target_freq, + relation, &next_state); if (result) return_VALUE(result); - result = acpi_processor_set_performance (pr, next_state); + result = acpi_processor_set_performance (perf, next_state); return_VALUE(result); } @@ -439,18 +494,17 @@ struct cpufreq_policy *policy) { unsigned int result = 0; - unsigned int cpu = policy->cpu; - struct acpi_processor *pr = performance[policy->cpu].pr; + struct acpi_processor_performance *perf = &performance[policy->cpu]; ACPI_FUNCTION_TRACE("acpi_cpufreq_verify"); result = cpufreq_frequency_table_verify(policy, - &performance[cpu].freq_table[pr->limit.state.px]); + &perf->freq_table[perf->pr->limit.state.px]); cpufreq_verify_within_limits( policy, - performance[cpu].states[performance[cpu].state_count - 1].core_frequency * 1000, - performance[cpu].states[pr->limit.state.px].core_frequency * 1000); + perf->states[perf->state_count - 1].core_frequency * 1000, + perf->states[perf->pr->limit.state.px].core_frequency * 1000); return_VALUE(result); } @@ -458,7 +512,7 @@ static int acpi_processor_get_performance_info ( - struct acpi_processor *pr) + struct acpi_processor_performance *perf) { int result = 0; acpi_status status = AE_OK; @@ -466,31 +520,32 @@ ACPI_FUNCTION_TRACE("acpi_processor_get_performance_info"); - if (!pr) + if (!perf || !perf->pr || !perf->pr->handle) return_VALUE(-EINVAL); - status = acpi_get_handle(pr->handle, "_PCT", &handle); + status = acpi_get_handle(perf->pr->handle, "_PCT", &handle); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "ACPI-based processor performance control unavailable\n")); return_VALUE(-ENODEV); } - result = acpi_processor_get_performance_control(pr); + result = acpi_processor_get_performance_control(perf); if (result) return_VALUE(result); - result = acpi_processor_get_performance_states(pr); + result = acpi_processor_get_performance_states(perf); if (result) return_VALUE(result); - result = acpi_processor_get_platform_limit(pr); + result = acpi_processor_get_platform_limit(perf->pr); if (result) return_VALUE(result); return_VALUE(0); } + static int acpi_cpufreq_cpu_init ( struct cpufreq_policy *policy) @@ -498,22 +553,18 @@ unsigned int i; unsigned int cpu = policy->cpu; struct acpi_processor *pr = NULL; + struct acpi_processor_performance *perf = &performance[policy->cpu]; unsigned int result = 0; - struct proc_dir_entry *entry = NULL; - struct acpi_device *device = NULL; ACPI_FUNCTION_TRACE("acpi_cpufreq_cpu_init"); - acpi_processor_register_performance(&performance[cpu], &pr, cpu); + acpi_processor_register_performance(perf, &pr, cpu); pr = performance[cpu].pr; if (!pr) return_VALUE(-ENODEV); - if (acpi_bus_get_device(pr->handle, &device)) - return_VALUE(-ENODEV); - - result = acpi_processor_get_performance_info(performance[cpu].pr); + result = acpi_processor_get_performance_info(perf); if (result) return_VALUE(-ENODEV); @@ -523,52 +574,62 @@ /* detect transition latency */ policy->cpuinfo.transition_latency = 0; - for (i=0;i policy->cpuinfo.transition_latency) - policy->cpuinfo.transition_latency = performance[cpu].states[i].transition_latency; + for (i=0;istate_count;i++) { + if (perf->states[i].transition_latency > policy->cpuinfo.transition_latency) + policy->cpuinfo.transition_latency = perf->states[i].transition_latency; } policy->policy = CPUFREQ_POLICY_PERFORMANCE; + policy->cur = perf->states[pr->limit.state.px].core_frequency * 1000; /* table init */ - for (i=0; i<=performance[cpu].state_count; i++) + for (i=0; i<=perf->state_count; i++) { - performance[cpu].freq_table[i].index = i; - if (ifreq_table[i].index = i; + if (istate_count) + perf->freq_table[i].frequency = perf->states[i].core_frequency * 1000; else - performance[cpu].freq_table[i].frequency = CPUFREQ_TABLE_END; + perf->freq_table[i].frequency = CPUFREQ_TABLE_END; } -#ifdef CONFIG_CPU_FREQ_24_API - acpi_cpufreq_driver.cpu_cur_freq[policy->cpu] = performance[cpu].states[pr->limit.state.px].core_frequency * 1000; -#endif + result = cpufreq_frequency_table_cpuinfo(policy, &perf->freq_table[0]); - result = cpufreq_frequency_table_cpuinfo(policy, &performance[cpu].freq_table[0]); - - /* add file 'performance' [R/W] */ - entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE, - S_IFREG|S_IRUGO|S_IWUSR, acpi_device_dir(device)); - if (!entry) - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, - "Unable to create '%s' fs entry\n", - ACPI_PROCESSOR_FILE_PERFORMANCE)); - else { - entry->proc_fops = &acpi_processor_perf_fops; - entry->write_proc = acpi_processor_write_performance; - entry->data = acpi_driver_data(device); - } + acpi_cpufreq_add_file(pr); return_VALUE(result); } +static int +acpi_cpufreq_cpu_exit ( + struct cpufreq_policy *policy) +{ + struct acpi_processor *pr = performance[policy->cpu].pr; + + ACPI_FUNCTION_TRACE("acpi_cpufreq_cpu_exit"); + + acpi_cpufreq_remove_file(pr); + + return_VALUE(0); +} + + +static struct cpufreq_driver acpi_cpufreq_driver = { + .verify = acpi_cpufreq_verify, + .target = acpi_cpufreq_target, + .init = acpi_cpufreq_cpu_init, + .exit = acpi_cpufreq_cpu_exit, + .name = "acpi-cpufreq", +}; + + static int __init acpi_cpufreq_init (void) { int result = 0; int current_state = 0; int i = 0; - struct acpi_processor *pr; + struct acpi_processor *pr = NULL; + struct acpi_processor_performance *perf = NULL; ACPI_FUNCTION_TRACE("acpi_cpufreq_init"); @@ -579,10 +640,9 @@ performance = kmalloc(NR_CPUS * sizeof(struct acpi_processor_performance), GFP_KERNEL); if (!performance) return_VALUE(-ENOMEM); - memset(performance, 0, NR_CPUS * sizeof(struct acpi_processor_performance)); - /* register struct acpi_performance performance */ + /* register struct acpi_processor_performance performance */ for (i=0; iflags.performance) goto found_capable_cpu; @@ -604,10 +666,11 @@ goto err; found_capable_cpu: - current_state = pr->performance->state; + perf = pr->performance; + current_state = perf->state; if (current_state == pr->limit.state.px) { - result = acpi_processor_set_performance(pr, (pr->performance->state_count - 1)); + result = acpi_processor_set_performance(perf, (perf->state_count - 1)); if (result) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Disabled P-States due to failure while switching.\n")); result = -ENODEV; @@ -615,7 +678,7 @@ } } - result = acpi_processor_set_performance(pr, pr->limit.state.px); + result = acpi_processor_set_performance(perf, pr->limit.state.px); if (result) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Disabled P-States due to failure while switching.\n")); result = -ENODEV; @@ -623,7 +686,7 @@ } if (current_state != 0) { - result = acpi_processor_set_performance(pr, current_state); + result = acpi_processor_set_performance(perf, current_state); if (result) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Disabled P-States due to failure while switching.\n")); result = -ENODEV; @@ -639,7 +702,7 @@ /* error handling */ err: - /* unregister struct acpi_performance performance */ + /* unregister struct acpi_processor_performance performance */ for (i=0; iflags.performance = 0; @@ -647,9 +710,7 @@ performance[i].pr = NULL; } } - kfree(performance); - return_VALUE(result); } @@ -668,7 +729,7 @@ cpufreq_unregister_driver(&acpi_cpufreq_driver); - /* unregister struct acpi_performance performance */ + /* unregister struct acpi_processor_performance performance */ for (i=0; iflags.performance = 0; @@ -681,15 +742,6 @@ return_VOID; } - -static struct cpufreq_driver acpi_cpufreq_driver = { - .verify = acpi_cpufreq_verify, - .setpolicy = acpi_cpufreq_setpolicy, - .init = acpi_cpufreq_cpu_init, - .exit = NULL, - .policy = NULL, - .name = "acpi-cpufreq", -}; late_initcall(acpi_cpufreq_init); diff -Nru a/arch/i386/kernel/cpu/cpufreq/elanfreq.c b/arch/i386/kernel/cpu/cpufreq/elanfreq.c --- a/arch/i386/kernel/cpu/cpufreq/elanfreq.c Tue Mar 4 19:30:07 2003 +++ b/arch/i386/kernel/cpu/cpufreq/elanfreq.c Tue Mar 4 19:30:07 2003 @@ -31,15 +31,9 @@ #define REG_CSCIR 0x22 /* Chip Setup and Control Index Register */ #define REG_CSCDR 0x23 /* Chip Setup and Control Data Register */ -static struct cpufreq_driver *elanfreq_driver; - /* Module parameter */ static int max_freq; -MODULE_LICENSE("GPL"); -MODULE_AUTHOR("Robert Schwebel , Sven Geggus "); -MODULE_DESCRIPTION("cpufreq driver for AMD's Elan CPUs"); - struct s_elan_multiplier { int clock; /* frequency in kHz */ int val40h; /* PMU Force Mode register */ @@ -127,11 +121,6 @@ struct cpufreq_freqs freqs; - if (!elanfreq_driver) { - printk(KERN_ERR "cpufreq: initialization problem or invalid target frequency\n"); - return; - } - freqs.old = elanfreq_get_cpu_frequency(); freqs.new = elan_multiplier[state].clock; freqs.cpu = 0; /* elanfreq.c is UP only driver */ @@ -187,11 +176,13 @@ return cpufreq_frequency_table_verify(policy, &elanfreq_table[0]); } -static int elanfreq_setpolicy (struct cpufreq_policy *policy) +static int elanfreq_target (struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { unsigned int newstate = 0; - if (cpufreq_frequency_table_setpolicy(policy, &elanfreq_table[0], &newstate)) + if (cpufreq_frequency_table_target(policy, &elanfreq_table[0], target_freq, relation, &newstate)) return -EINVAL; elanfreq_set_cpu_state(newstate); @@ -204,6 +195,35 @@ * Module init and exit code */ +static int elanfreq_cpu_init(struct cpufreq_policy *policy) +{ + struct cpuinfo_x86 *c = cpu_data; + unsigned int i; + + /* capability check */ + if ((c->x86_vendor != X86_VENDOR_AMD) || + (c->x86 != 4) || (c->x86_model!=10)) + return -ENODEV; + + /* max freq */ + if (!max_freq) + max_freq = elanfreq_get_cpu_frequency(); + + /* table init */ + for (i=0; (elanfreq_table[i].frequency != CPUFREQ_TABLE_END); i++) { + if (elanfreq_table[i].frequency > max_freq) + elanfreq_table[i].frequency = CPUFREQ_ENTRY_INVALID; + } + + /* cpuinfo and default policy values */ + policy->policy = CPUFREQ_POLICY_PERFORMANCE; + policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; + policy->cur = elanfreq_get_cpu_frequency(); + + return cpufreq_frequency_table_cpuinfo(policy, &elanfreq_table[0]);; +} + + #ifndef MODULE /** * elanfreq_setup - elanfreq command line parameter parsing @@ -224,11 +244,18 @@ __setup("elanfreq=", elanfreq_setup); #endif + +static struct cpufreq_driver elanfreq_driver = { + .verify = elanfreq_verify, + .target = elanfreq_target, + .init = elanfreq_cpu_init, + .name = "elanfreq", +}; + + static int __init elanfreq_init(void) { struct cpuinfo_x86 *c = cpu_data; - struct cpufreq_driver *driver; - int ret, i; /* Test if we have the right hardware */ if ((c->x86_vendor != X86_VENDOR_AMD) || @@ -238,63 +265,22 @@ return -ENODEV; } - driver = kmalloc(sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy), GFP_KERNEL); - if (!driver) - return -ENOMEM; - memset(driver, 0, sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy)); - - driver->policy = (struct cpufreq_policy *) (driver + 1); - - if (!max_freq) - max_freq = elanfreq_get_cpu_frequency(); - - /* table init */ - for (i=0; (elanfreq_table[i].frequency != CPUFREQ_TABLE_END); i++) { - if (elanfreq_table[i].frequency > max_freq) - elanfreq_table[i].frequency = CPUFREQ_ENTRY_INVALID; - } - -#ifdef CONFIG_CPU_FREQ_24_API - driver->cpu_cur_freq[0] = elanfreq_get_cpu_frequency(); -#endif - - driver->verify = &elanfreq_verify; - driver->setpolicy = &elanfreq_setpolicy; - strncpy(driver->name, "elanfreq", CPUFREQ_NAME_LEN); - - driver->policy[0].cpu = 0; - ret = cpufreq_frequency_table_cpuinfo(&driver->policy[0], &elanfreq_table[0]); - if (ret) { - kfree(driver); - return ret; - } - driver->policy[0].policy = CPUFREQ_POLICY_PERFORMANCE; - driver->policy[0].cpuinfo.transition_latency = CPUFREQ_ETERNAL; - - elanfreq_driver = driver; - - ret = cpufreq_register(driver); - if (ret) { - elanfreq_driver = NULL; - kfree(driver); - } - - return ret; + return cpufreq_register_driver(&elanfreq_driver); } static void __exit elanfreq_exit(void) { - if (elanfreq_driver) { - cpufreq_unregister(); - kfree(elanfreq_driver); - } + cpufreq_unregister_driver(&elanfreq_driver); } -module_init(elanfreq_init); -module_exit(elanfreq_exit); MODULE_PARM (max_freq, "i"); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("Robert Schwebel , Sven Geggus "); +MODULE_DESCRIPTION("cpufreq driver for AMD's Elan CPUs"); + +module_init(elanfreq_init); +module_exit(elanfreq_exit); diff -Nru a/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c b/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c --- a/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/kernel/cpu/cpufreq/gx-suspmod.c Tue Mar 4 19:30:08 2003 @@ -116,7 +116,6 @@ struct pci_dev *cs55x0; }; -static struct cpufreq_driver *gx_driver; static struct gxfreq_params *gx_params; static int stock_freq; @@ -345,7 +344,7 @@ unsigned int tmp_freq = 0; u8 tmp1, tmp2; - if (!gx_driver || !stock_freq || !policy) + if (!stock_freq || !policy) return -EINVAL; policy->cpu = 0; @@ -375,33 +374,71 @@ } /* - * cpufreq_gx_setpolicy: + * cpufreq_gx_target: * */ -static int cpufreq_gx_setpolicy(struct cpufreq_policy *policy) +static int cpufreq_gx_target(struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { + u8 tmp1, tmp2; + unsigned int tmp_freq; - if (!gx_driver || !stock_freq || !policy) + if (!stock_freq || !policy) return -EINVAL; policy->cpu = 0; - if (policy->policy == CPUFREQ_POLICY_POWERSAVE) { - /* here we need to make sure that we don't set the - * frequency below policy->min (see comment in - * cpufreq_gx_verify() - guarantee of processing - * capacity. - */ - u8 tmp1, tmp2; - unsigned int tmp_freq = gx_validate_speed(policy->min, &tmp1, &tmp2); - while (tmp_freq < policy->min) { - tmp_freq += stock_freq / max_duration; - tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2); - } - gx_set_cpuspeed(tmp_freq); + tmp_freq = gx_validate_speed(target_freq, &tmp1, &tmp2); + while (tmp_freq < policy->min) { + tmp_freq += stock_freq / max_duration; + tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2); + } + while (tmp_freq > policy->max) { + tmp_freq -= stock_freq / max_duration; + tmp_freq = gx_validate_speed(tmp_freq, &tmp1, &tmp2); + } + + gx_set_cpuspeed(tmp_freq); + + return 0; +} + +static int cpufreq_gx_cpu_init(struct cpufreq_policy *policy) +{ + int maxfreq, curfreq; + + if (!policy || policy->cpu != 0) + return -ENODEV; + + /* determine maximum frequency */ + if (pci_busclk) { + maxfreq = pci_busclk * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f]; + } else if (cpu_khz) { + maxfreq = cpu_khz; } else { - gx_set_cpuspeed(policy->max); + maxfreq = 30000 * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f]; } + stock_freq = maxfreq; + curfreq = gx_get_cpuspeed(); + + dprintk("cpu max frequency is %d.\n", maxfreq); + dprintk("cpu current frequency is %dkHz.\n",curfreq); + + /* setup basic struct for cpufreq API */ + policy->cpu = 0; + + if (max_duration < POLICY_MIN_DIV) + policy->min = maxfreq / max_duration; + else + policy->min = maxfreq / POLICY_MIN_DIV; + policy->max = maxfreq; + policy->cur = curfreq; + policy->policy = CPUFREQ_POLICY_PERFORMANCE; + policy->cpuinfo.min_freq = maxfreq / max_duration; + policy->cpuinfo.max_freq = maxfreq; + policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; + return 0; } @@ -409,11 +446,16 @@ * cpufreq_gx_init: * MediaGX/Geode GX initilize cpufreq driver */ +static struct cpufreq_driver gx_suspmod_driver = { + .verify = cpufreq_gx_verify, + .target = cpufreq_gx_target, + .init = cpufreq_gx_cpu_init, + .name = "gx-suspmod", +}; static int __init cpufreq_gx_init(void) { - int maxfreq,ret,curfreq; - struct cpufreq_driver *driver; + int ret; struct gxfreq_params *params; struct pci_dev *gx_pci; u32 class_rev; @@ -428,21 +470,13 @@ dprintk("geode suspend modulation available.\n"); - driver = kmalloc(sizeof(struct cpufreq_driver) + NR_CPUS * sizeof(struct cpufreq_policy), GFP_KERNEL); - if (driver == NULL) - return -ENOMEM; - memset(driver, 0, sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy)); - params = kmalloc(sizeof(struct gxfreq_params), GFP_KERNEL); - if (params == NULL) { - kfree(driver); + if (params == NULL) return -ENOMEM; - } memset(params, 0, sizeof(struct gxfreq_params)); - driver->policy = (struct cpufreq_policy *)(driver + 1); params->cs55x0 = gx_pci; + gx_params = params; /* keep cs55x0 configurations */ pci_read_config_byte(params->cs55x0, PCI_SUSCFG, &(params->pci_suscfg)); @@ -453,45 +487,7 @@ pci_read_config_dword(params->cs55x0, PCI_CLASS_REVISION, &class_rev); params->pci_rev = class_rev && 0xff; - gx_params = params; - - /* determine maximum frequency */ - if (pci_busclk) { - maxfreq = pci_busclk * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f]; - } else if (cpu_khz) { - maxfreq = cpu_khz; - } else { - maxfreq = 30000 * gx_freq_mult[getCx86(CX86_DIR1) & 0x0f]; - } - stock_freq = maxfreq; - curfreq = gx_get_cpuspeed(); - - dprintk("cpu max frequency is %d.\n", maxfreq); - dprintk("cpu current frequency is %dkHz.\n",curfreq); - - /* setup basic struct for cpufreq API */ -#ifdef CONFIG_CPU_FREQ_24_API - driver->cpu_cur_freq[0] = curfreq; -#endif - driver->policy[0].cpu = 0; - - if (max_duration < POLICY_MIN_DIV) - driver->policy[0].min = maxfreq / max_duration; - else - driver->policy[0].min = maxfreq / POLICY_MIN_DIV; - driver->policy[0].max = maxfreq; - driver->policy[0].policy = CPUFREQ_POLICY_PERFORMANCE; - driver->policy[0].cpuinfo.min_freq = maxfreq / max_duration; - driver->policy[0].cpuinfo.max_freq = maxfreq; - driver->policy[0].cpuinfo.transition_latency = CPUFREQ_ETERNAL; - driver->verify = &cpufreq_gx_verify; - driver->setpolicy = &cpufreq_gx_setpolicy; - strncpy(driver->name, "gx-suspmod", CPUFREQ_NAME_LEN); - - gx_driver = driver; - - if ((ret = cpufreq_register(driver))) { - kfree(driver); + if ((ret = cpufreq_register_driver(&gx_suspmod_driver))) { kfree(params); return ret; /* register error! */ } @@ -501,13 +497,8 @@ static void __exit cpufreq_gx_exit(void) { - if (gx_driver) { - /* disable throttling */ - gx_set_cpuspeed(stock_freq); - cpufreq_unregister(); - kfree(gx_driver); - kfree(gx_params); - } + cpufreq_unregister_driver(&gx_suspmod_driver); + kfree(gx_params); } MODULE_AUTHOR ("Hiroshi Miura "); diff -Nru a/arch/i386/kernel/cpu/cpufreq/longhaul.c b/arch/i386/kernel/cpu/cpufreq/longhaul.c --- a/arch/i386/kernel/cpu/cpufreq/longhaul.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/cpu/cpufreq/longhaul.c Tue Mar 4 19:30:04 2003 @@ -1,5 +1,5 @@ /* - * $Id: longhaul.c,v 1.77 2002/10/31 21:17:40 db Exp $ + * $Id: longhaul.c,v 1.87 2003/02/22 10:23:46 db Exp $ * * (C) 2001 Dave Jones. * (C) 2002 Padraig Brady. @@ -48,6 +48,7 @@ /* Module parameters */ +static int prefer_slow_fsb; static int dont_scale_voltage; static int dont_scale_fsb; static int current_fsb; @@ -237,7 +238,6 @@ /* fsb values to favour high fsb speed (for e.g. if lowering CPU freq because of heat, but want to maintain highest performance possible) */ static unsigned int perf_fsb_table[] = { 133, 100, 66, -1 }; -static unsigned int *fsb_search_table; /* Voltage scales. Div by 1000 to get actual voltage. */ static int __initdata vrm85scales[32] = { @@ -260,7 +260,7 @@ static int voltage_table[32]; static int highest_speed, lowest_speed; /* kHz */ static int longhaul; /* version. */ -static struct cpufreq_driver *longhaul_driver; +static struct cpufreq_frequency_table *longhaul_table; static int longhaul_get_cpu_fsb (void) @@ -428,7 +428,7 @@ } -static void __init longhaul_get_ranges (void) +static int __init longhaul_get_ranges (void) { unsigned long lo, hi, invalue; unsigned int minmult=0, maxmult=0, minfsb=0, maxfsb=0; @@ -436,6 +436,9 @@ 50,30,40,100,55,35,45,95,90,70,80,60,120,75,85,65, -1,110,120,-1,135,115,125,105,130,150,160,140,-1,155,-1,145 }; unsigned int fsb_table[4] = { 133, 100, -1, 66 }; + unsigned int fsbcount = 1; + unsigned int i, j, k = 0; + static unsigned int *fsb_search_table; switch (longhaul) { case 1: @@ -472,6 +475,11 @@ dprintk (KERN_INFO "longhaul: Min FSB=%d Max FSB=%d\n", minfsb, maxfsb); + fsbcount = 0; + for (i=0;i<4;i++) { + if((fsb_table[i] >= minfsb) && (fsb_table[i] <= maxfsb)) + fsbcount++; + } } else { minfsb = maxfsb = current_fsb; } @@ -480,11 +488,37 @@ highest_speed = maxmult * maxfsb * 100; lowest_speed = minmult * minfsb * 100; - dprintk (KERN_INFO "longhaul: MinMult(x10)=%d MaxMult(x10)=%d\n", - minmult, maxmult); + minmult, maxmult); dprintk (KERN_INFO "longhaul: Lowestspeed=%d Highestspeed=%d\n", - lowest_speed, highest_speed); + lowest_speed, highest_speed); + + longhaul_table = kmalloc((numscales * fsbcount + 1) * sizeof(struct cpufreq_frequency_table), GFP_KERNEL); + if(!longhaul_table) + return -ENOMEM; + + if (prefer_slow_fsb) + fsb_search_table = perf_fsb_table; // yep, this is right: the last entry is preferred by cpufreq_frequency_table_* ... + else + fsb_search_table = power_fsb_table; + + for (i=0; (i<4); i++) { + if ((fsb_search_table[i] > maxfsb) || (fsb_search_table[i] < minfsb) || (fsb_search_table[i] == -1)) + continue; + for (j=0; (j maxmult) || (clock_ratio[j] < minmult) || (clock_ratio[j] == -1)) + continue; + longhaul_table[k].frequency= clock_ratio[j] * fsb_search_table[i] * 100; + longhaul_table[k].index = (j << 8) | (i); + k++; + } + } + + longhaul_table[k].frequency = CPUFREQ_TABLE_END; + if (!k) + return -EINVAL; + + return 0; } @@ -523,182 +557,34 @@ } -static inline unsigned int longhaul_statecount_fsb(struct cpufreq_policy *policy, unsigned int fsb) { - unsigned int i, count = 0; - - for(i=0; imax) && - ((clock_ratio[i] * fsb * 100) >= policy->min)) - count++; - } - - return count; -} - - static int longhaul_verify(struct cpufreq_policy *policy) { - unsigned int number_states = 0; - unsigned int i; - unsigned int fsb_index = 0; - unsigned int tmpfreq = 0; - unsigned int newmax = -1; - - if (!policy || !longhaul_driver) - return -EINVAL; - - policy->cpu = 0; - cpufreq_verify_within_limits(policy, lowest_speed, highest_speed); - - if (can_scale_fsb==1) { - for (fsb_index=0; fsb_search_table[fsb_index]!=-1; fsb_index++) - number_states += longhaul_statecount_fsb(policy, fsb_search_table[fsb_index]); - } else - number_states = longhaul_statecount_fsb(policy, current_fsb); - - if (number_states) - return 0; - - /* get frequency closest above current policy->max */ - if (can_scale_fsb==1) { - for (fsb_index=0; fsb_search_table[fsb_index] != -1; fsb_index++) - for(i=0; i policy->max) && - (tmpfreq < newmax)) - newmax = tmpfreq; - } - } else { - for(i=0; i policy->max) && - (tmpfreq < newmax)) - newmax = tmpfreq; - } - } - - policy->max = newmax; - - cpufreq_verify_within_limits(policy, lowest_speed, highest_speed); - - return 0; -} - - -static int longhaul_get_best_freq_for_fsb(struct cpufreq_policy *policy, - unsigned int min_mult, - unsigned int max_mult, - unsigned int fsb, - unsigned int *new_mult) -{ - unsigned int optimal = 0; - unsigned int found_optimal = 0; - unsigned int i; - - switch(policy->policy) { - case CPUFREQ_POLICY_POWERSAVE: - optimal = max_mult; - break; - case CPUFREQ_POLICY_PERFORMANCE: - optimal = min_mult; - } - - for(i=0; i policy->max) || - (freq < policy->min)) - continue; - switch(policy->policy) { - case CPUFREQ_POLICY_POWERSAVE: - if (clock_ratio[i] < clock_ratio[optimal]) { - found_optimal = 1; - optimal = i; - } - break; - case CPUFREQ_POLICY_PERFORMANCE: - if (clock_ratio[i] > clock_ratio[optimal]) { - found_optimal = 1; - optimal = i; - } - break; - } - } - - if (found_optimal) { - *new_mult = optimal; - return 1; - } - return 0; + return cpufreq_frequency_table_verify(policy, longhaul_table); } -static int longhaul_setpolicy (struct cpufreq_policy *policy) +static int longhaul_target (struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { - unsigned int i; - unsigned int fsb_index = 0; - unsigned int new_fsb = 0; - unsigned int new_clock_ratio = 0; - unsigned int min_mult = 0; - unsigned int max_mult = 0; - + unsigned int table_index = 0; + unsigned int new_fsb = 0; + unsigned int new_clock_ratio = 0; - if (!longhaul_driver) + if (cpufreq_frequency_table_target(policy, longhaul_table, target_freq, relation, &table_index)) return -EINVAL; - if (policy->policy==CPUFREQ_POLICY_PERFORMANCE) - fsb_search_table = perf_fsb_table; - else - fsb_search_table = power_fsb_table; - - for(i=0;i clock_ratio[i]) - min_mult = i; - } - - if (can_scale_fsb==1) { - unsigned int found = 0; - for (fsb_index=0; fsb_search_table[fsb_index]!=-1; fsb_index++) - { - if (longhaul_get_best_freq_for_fsb(policy, - min_mult, max_mult, - fsb_search_table[fsb_index], - &new_clock_ratio)) { - new_fsb = fsb_search_table[fsb_index]; - break; - } - } - if (!found) - return -EINVAL; - } else { - new_fsb = current_fsb; - if (!longhaul_get_best_freq_for_fsb(policy, min_mult, - max_mult, new_fsb, &new_clock_ratio)) - return -EINVAL; - } - + new_clock_ratio = longhaul_table[table_index].index & 0xFF; + new_fsb = power_fsb_table[(longhaul_table[table_index].index & 0xFF00) >> 8]; + longhaul_setstate(new_clock_ratio, new_fsb); return 0; } - -static int __init longhaul_init (void) +static int longhaul_cpu_init (struct cpufreq_policy *policy) { struct cpuinfo_x86 *c = cpu_data; - unsigned int currentspeed; - static int currentmult; - unsigned long lo, hi; - int ret; - struct cpufreq_driver *driver; if ((c->x86_vendor != X86_VENDOR_CENTAUR) || (c->x86 !=6) ) return -ENODEV; @@ -733,21 +619,12 @@ memcpy (eblcr_table, c5m_eblcr, sizeof(c5m_eblcr)); break; - default: - printk (KERN_INFO "longhaul: Unknown VIA CPU. Contact davej@suse.de\n"); - return -ENODEV; } printk (KERN_INFO "longhaul: VIA CPU detected. Longhaul version %d supported\n", longhaul); - current_fsb = longhaul_get_cpu_fsb(); - currentmult = longhaul_get_cpu_mult(); - currentspeed = currentmult * current_fsb * 100; - - dprintk (KERN_INFO "longhaul: CPU currently at %dMHz (%d x %d.%d)\n", - (currentspeed/1000), current_fsb, currentmult/10, currentmult%10); - if (longhaul==2 || longhaul==3) { + unsigned long lo, hi; rdmsr (MSR_VIA_LONGHAUL, lo, hi); if ((lo & (1<<0)) && (dont_scale_voltage==0)) longhaul_setup_voltagescaling (lo, hi); @@ -756,57 +633,53 @@ can_scale_fsb = 1; } - longhaul_get_ranges(); - - driver = kmalloc(sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy), GFP_KERNEL); - if (!driver) + if (longhaul_get_ranges()) return -ENOMEM; - memset(driver, 0, sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy)); - driver->policy = (struct cpufreq_policy *) (driver + 1); + policy->policy = CPUFREQ_POLICY_PERFORMANCE; + policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; -#ifdef CONFIG_CPU_FREQ_24_API - driver->cpu_cur_freq[0] = currentspeed; -#endif + policy->cur = (unsigned int) (longhaul_get_cpu_fsb() * longhaul_get_cpu_mult() * 100); + + return cpufreq_frequency_table_cpuinfo(policy, longhaul_table); +} + +static struct cpufreq_driver longhaul_driver = { + .verify = longhaul_verify, + .target = longhaul_target, + .init = longhaul_cpu_init, + .name = "longhaul", +}; - driver->verify = &longhaul_verify; - driver->setpolicy = &longhaul_setpolicy; +static int __init longhaul_init (void) +{ + struct cpuinfo_x86 *c = cpu_data; - strncpy(driver->name, "longhaul", CPUFREQ_NAME_LEN); + if ((c->x86_vendor != X86_VENDOR_CENTAUR) || (c->x86 !=6) ) + return -ENODEV; - driver->policy[0].cpu = 0; - driver->policy[0].min = (unsigned int) lowest_speed; - driver->policy[0].max = (unsigned int) highest_speed; - driver->policy[0].policy = CPUFREQ_POLICY_PERFORMANCE; - driver->policy[0].cpuinfo.min_freq = (unsigned int) lowest_speed; - driver->policy[0].cpuinfo.max_freq = (unsigned int) highest_speed; - driver->policy[0].cpuinfo.transition_latency = CPUFREQ_ETERNAL; - - longhaul_driver = driver; - - ret = cpufreq_register(driver); - if (ret) { - longhaul_driver = NULL; - kfree(driver); + switch (c->x86_model) { + case 6 ... 7: + return cpufreq_register_driver(&longhaul_driver); + case 8: + return -ENODEV; + default: + printk (KERN_INFO "longhaul: Unknown VIA CPU. Contact davej@suse.de\n"); } - return ret; + return -ENODEV; } - static void __exit longhaul_exit (void) { - if (longhaul_driver) { - cpufreq_unregister(); - kfree(longhaul_driver); - } + cpufreq_unregister_driver(&longhaul_driver); + kfree(longhaul_table); } MODULE_PARM (dont_scale_fsb, "i"); MODULE_PARM (dont_scale_voltage, "i"); MODULE_PARM (current_fsb, "i"); +MODULE_PARM (prefer_slow_fsb, "i"); MODULE_AUTHOR ("Dave Jones "); MODULE_DESCRIPTION ("Longhaul driver for VIA Cyrix processors."); diff -Nru a/arch/i386/kernel/cpu/cpufreq/longrun.c b/arch/i386/kernel/cpu/cpufreq/longrun.c --- a/arch/i386/kernel/cpu/cpufreq/longrun.c Tue Mar 4 19:30:11 2003 +++ b/arch/i386/kernel/cpu/cpufreq/longrun.c Tue Mar 4 19:30:11 2003 @@ -1,5 +1,5 @@ /* - * $Id: longrun.c,v 1.22 2003/02/10 17:31:50 db Exp $ + * $Id: longrun.c,v 1.25 2003/02/28 16:03:50 db Exp $ * * (C) 2002 - 2003 Dominik Brodowski * @@ -133,7 +133,7 @@ * longrun_determine_freqs - determines the lowest and highest possible core frequency * * Determines the lowest and highest possible core frequencies on this CPU. - * This is neccessary to calculate the performance percentage according to + * This is necessary to calculate the performance percentage according to * TMTA rules: * performance_pctg = (target_freq - low_freq)/(high_freq - low_freq) */ @@ -244,10 +244,6 @@ policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; longrun_get_policy(policy); -#ifdef CONFIG_CPU_FREQ_24_API - longrun_driver.cpu_cur_freq[policy->cpu] = longrun_low_freq; /* dummy value */ -#endif - return 0; } diff -Nru a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c --- a/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c Tue Mar 4 19:30:13 2003 +++ b/arch/i386/kernel/cpu/cpufreq/p4-clockmod.c Tue Mar 4 19:30:13 2003 @@ -49,8 +49,6 @@ static int has_N44_O17_errata[NR_CPUS]; static int stock_freq; -static struct cpufreq_driver p4clockmod_driver; - static int cpufreq_p4_setdc(unsigned int cpu, unsigned int newstate) { @@ -220,9 +218,7 @@ /* cpuinfo and default policy values */ policy->policy = CPUFREQ_POLICY_PERFORMANCE; policy->cpuinfo.transition_latency = 1000; -#ifdef CONFIG_CPU_FREQ_24_API - p4clockmod_driver.cpu_cur_freq[policy->cpu] = stock_freq; -#endif + policy->cur = stock_freq; return cpufreq_frequency_table_cpuinfo(policy, &p4clockmod_table[0]); } diff -Nru a/arch/i386/kernel/cpu/cpufreq/powernow-k6.c b/arch/i386/kernel/cpu/cpufreq/powernow-k6.c --- a/arch/i386/kernel/cpu/cpufreq/powernow-k6.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/cpu/cpufreq/powernow-k6.c Tue Mar 4 19:30:04 2003 @@ -1,9 +1,9 @@ /* - * $Id: powernow-k6.c,v 1.36 2002/10/31 21:17:40 db Exp $ + * $Id: powernow-k6.c,v 1.48 2003/02/22 10:23:46 db Exp $ * This file was part of Powertweak Linux (http://powertweak.sf.net) * and is shared with the Linux Kernel module. * - * (C) 2000-2002 Dave Jones, Arjan van de Ven, Janne P�nk�l�, Dominik Brodowski. + * (C) 2000-2003 Dave Jones, Arjan van de Ven, Janne P�nk�l�, Dominik Brodowski. * * Licensed under the terms of the GNU GPL License version 2. * @@ -25,7 +25,6 @@ #define POWERNOW_IOPORT 0xfff0 /* it doesn't matter where, as long as it is unused */ -static struct cpufreq_driver *powernow_driver; static unsigned int busfreq; /* FSB, in 10 kHz */ static unsigned int max_multiplier; @@ -77,8 +76,8 @@ unsigned long msrval; struct cpufreq_freqs freqs; - if (!powernow_driver) { - printk(KERN_ERR "cpufreq: initialization problem or invalid target frequency\n"); + if (clock_ratio[best_i].index > max_multiplier) { + printk(KERN_ERR "cpufreq: invalid target frequency\n"); return; } @@ -126,11 +125,13 @@ * * sets a new CPUFreq policy */ -static int powernow_k6_setpolicy (struct cpufreq_policy *policy) +static int powernow_k6_target (struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { unsigned int newstate = 0; - if (cpufreq_frequency_table_setpolicy(policy, &clock_ratio[0], &newstate)) + if (cpufreq_frequency_table_target(policy, &clock_ratio[0], target_freq, relation, &newstate)) return -EINVAL; powernow_k6_set_state(newstate); @@ -139,6 +140,59 @@ } +static int powernow_k6_cpu_init(struct cpufreq_policy *policy) +{ + struct cpuinfo_x86 *c = cpu_data; + unsigned int i; + + /* capability check */ + if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 5) || + ((c->x86_model != 12) && (c->x86_model != 13))) + return -ENODEV; + if (policy->cpu != 0) + return -ENODEV; + + /* get frequencies */ + max_multiplier = powernow_k6_get_cpu_multiplier(); + busfreq = cpu_khz / max_multiplier; + + /* table init */ + for (i=0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) { + if (clock_ratio[i].index > max_multiplier) + clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID; + else + clock_ratio[i].frequency = busfreq * clock_ratio[i].index; + } + + /* cpuinfo and default policy values */ + policy->policy = CPUFREQ_POLICY_PERFORMANCE; + policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; + policy->cur = busfreq * max_multiplier; + + return cpufreq_frequency_table_cpuinfo(policy, &clock_ratio[0]); +} + + +static int powernow_k6_cpu_exit(struct cpufreq_policy *policy) +{ + unsigned int i; + for (i=0; i<8; i++) { + if (i==max_multiplier) + powernow_k6_set_state(i); + } + return 0; +} + + +static struct cpufreq_driver powernow_k6_driver = { + .verify = powernow_k6_verify, + .target = powernow_k6_target, + .init = powernow_k6_cpu_init, + .exit = powernow_k6_cpu_exit, + .name = "powernow-k6", +}; + + /** * powernow_k6_init - initializes the k6 PowerNow! CPUFreq driver * @@ -149,68 +203,22 @@ static int __init powernow_k6_init(void) { struct cpuinfo_x86 *c = cpu_data; - struct cpufreq_driver *driver; - unsigned int result; - unsigned int i; if ((c->x86_vendor != X86_VENDOR_AMD) || (c->x86 != 5) || ((c->x86_model != 12) && (c->x86_model != 13))) return -ENODEV; - max_multiplier = powernow_k6_get_cpu_multiplier(); - busfreq = cpu_khz / max_multiplier; - if (!request_region(POWERNOW_IOPORT, 16, "PowerNow!")) { printk("cpufreq: PowerNow IOPORT region already used.\n"); return -EIO; } - /* initialization of main "cpufreq" code*/ - driver = kmalloc(sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy), GFP_KERNEL); - if (!driver) { + if (cpufreq_register_driver(&powernow_k6_driver)) { release_region (POWERNOW_IOPORT, 16); - return -ENOMEM; - } - memset(driver, 0, sizeof(struct cpufreq_driver) + - NR_CPUS * sizeof(struct cpufreq_policy)); - driver->policy = (struct cpufreq_policy *) (driver + 1); - - /* table init */ - for (i=0; (clock_ratio[i].frequency != CPUFREQ_TABLE_END); i++) { - if (clock_ratio[i].index > max_multiplier) - clock_ratio[i].frequency = CPUFREQ_ENTRY_INVALID; - else - clock_ratio[i].frequency = busfreq * clock_ratio[i].index; - } - - driver->verify = &powernow_k6_verify; - driver->setpolicy = &powernow_k6_setpolicy; - strncpy(driver->name, "powernow-k6", CPUFREQ_NAME_LEN); - - /* cpuinfo and default policy values */ - driver->policy[0].cpu = 0; - driver->policy[0].cpuinfo.transition_latency = CPUFREQ_ETERNAL; - driver->policy[0].policy = CPUFREQ_POLICY_PERFORMANCE; -#ifdef CONFIG_CPU_FREQ_24_API - driver->cpu_cur_freq[0] = busfreq * max_multiplier; -#endif - result = cpufreq_frequency_table_cpuinfo(&driver->policy[0], &clock_ratio[0]); - if (result) { - kfree(driver); - return result; - } - - powernow_driver = driver; - - result = cpufreq_register(driver); - if (result) { - release_region (POWERNOW_IOPORT, 16); - powernow_driver = NULL; - kfree(driver); + return -EINVAL; } - return result; + return 0; } @@ -221,20 +229,14 @@ */ static void __exit powernow_k6_exit(void) { - unsigned int i; - - if (powernow_driver) { - for (i=0;i<8;i++) - if (clock_ratio[i].index == max_multiplier) - powernow_k6_set_state(i); - cpufreq_unregister(); - kfree(powernow_driver); - } + cpufreq_unregister_driver(&powernow_k6_driver); + release_region (POWERNOW_IOPORT, 16); } MODULE_AUTHOR ("Arjan van de Ven , Dave Jones , Dominik Brodowski "); MODULE_DESCRIPTION ("PowerNow! driver for AMD K6-2+ / K6-3+ processors."); MODULE_LICENSE ("GPL"); + module_init(powernow_k6_init); module_exit(powernow_k6_exit); diff -Nru a/arch/i386/kernel/cpu/cpufreq/powernow-k7.c b/arch/i386/kernel/cpu/cpufreq/powernow-k7.c --- a/arch/i386/kernel/cpu/cpufreq/powernow-k7.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/cpu/cpufreq/powernow-k7.c Tue Mar 4 19:30:04 2003 @@ -1,5 +1,5 @@ /* - * $Id: powernow-k7.c,v 1.31 2003/02/12 21:16:35 davej Exp $ + * $Id: powernow-k7.c,v 1.34 2003/02/22 10:23:46 db Exp $ * * (C) 2003 Dave Jones * @@ -72,8 +72,6 @@ 150, 225, 160, 165, 170, 180, -1, -1, }; -static struct cpufreq_driver powernow_driver; - static struct cpufreq_frequency_table *powernow_table; static unsigned int can_scale_bus; @@ -369,13 +367,18 @@ policy->policy = CPUFREQ_POLICY_PERFORMANCE; policy->cpuinfo.transition_latency = latency; -#ifdef CONFIG_CPU_FREQ_24_API - powernow_driver.cpu_cur_freq[policy->cpu] = maximum_speed; -#endif + policy->cur = maximum_speed; return cpufreq_frequency_table_cpuinfo(policy, powernow_table); } +static struct cpufreq_driver powernow_driver = { + .verify = powernow_verify, + .target = powernow_target, + .init = powernow_cpu_init, + .name = "powernow-k7", +}; + static int __init powernow_init (void) { if (check_powernow()==0) @@ -390,14 +393,6 @@ if (powernow_table) kfree(powernow_table); } - -static struct cpufreq_driver powernow_driver = { - .verify = powernow_verify, - .target = powernow_target, - .init = powernow_cpu_init, - .name = "powernow-k7", -}; - MODULE_AUTHOR ("Dave Jones "); MODULE_DESCRIPTION ("Powernow driver for AMD K7 processors."); diff -Nru a/arch/i386/kernel/cpu/cpufreq/speedstep.c b/arch/i386/kernel/cpu/cpufreq/speedstep.c --- a/arch/i386/kernel/cpu/cpufreq/speedstep.c Tue Mar 4 19:30:03 2003 +++ b/arch/i386/kernel/cpu/cpufreq/speedstep.c Tue Mar 4 19:30:03 2003 @@ -1,5 +1,5 @@ /* - * $Id: speedstep.c,v 1.68 2003/01/20 17:31:47 db Exp $ + * $Id: speedstep.c,v 1.70 2003/02/22 10:23:46 db Exp $ * * (C) 2001 Dave Jones, Arjan van de ven. * (C) 2002 - 2003 Dominik Brodowski @@ -30,8 +30,6 @@ #include -static struct cpufreq_driver speedstep_driver; - /* speedstep_chipset: * It is necessary to know which chipset is used. As accesses to * this device occur at various places in this module, we need a @@ -629,9 +627,7 @@ policy->policy = (speed == speedstep_low_freq) ? CPUFREQ_POLICY_POWERSAVE : CPUFREQ_POLICY_PERFORMANCE; policy->cpuinfo.transition_latency = CPUFREQ_ETERNAL; -#ifdef CONFIG_CPU_FREQ_24_API - speedstep_driver.cpu_cur_freq[policy->cpu] = speed; -#endif + policy->cur = speed; return cpufreq_frequency_table_cpuinfo(policy, &speedstep_freqs[0]); } @@ -686,7 +682,7 @@ return -ENODEV; } - dprintk(KERN_INFO "cpufreq: Intel(R) SpeedStep(TM) support $Revision: 1.68 $\n"); + dprintk(KERN_INFO "cpufreq: Intel(R) SpeedStep(TM) support $Revision: 1.70 $\n"); /* activate speedstep support */ if (speedstep_activate()) diff -Nru a/arch/i386/kernel/cpu/cyrix.c b/arch/i386/kernel/cpu/cyrix.c --- a/arch/i386/kernel/cpu/cyrix.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/cpu/cyrix.c Tue Mar 4 19:30:05 2003 @@ -49,7 +49,7 @@ * Cx86_dir0_msb is a HACK needed by check_cx686_cpuid/slop in bugs.h in * order to identify the Cyrix CPU model after we're out of setup.c * - * Actually since bugs.h doesnt even reference this perhaps someone should + * Actually since bugs.h doesn't even reference this perhaps someone should * fix the documentation ??? */ static unsigned char Cx86_dir0_msb __initdata = 0; @@ -77,7 +77,7 @@ * BIOSes for compatibility with DOS games. This makes the udelay loop * work correctly, and improves performance. * - * FIXME: our newer udelay uses the tsc. We dont need to frob with SLOP + * FIXME: our newer udelay uses the tsc. We don't need to frob with SLOP */ extern void calibrate_delay(void) __init; diff -Nru a/arch/i386/kernel/cpu/intel.c b/arch/i386/kernel/cpu/intel.c --- a/arch/i386/kernel/cpu/intel.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/cpu/intel.c Tue Mar 4 19:30:05 2003 @@ -151,7 +151,7 @@ #ifdef CONFIG_X86_F00F_BUG /* * All current models of Pentium and Pentium with MMX technology CPUs - * have the F0 0F bug, which lets nonpriviledged users lock up the system. + * have the F0 0F bug, which lets nonprivileged users lock up the system. * Note that the workaround only should be initialized once... */ c->f00f_bug = 0; diff -Nru a/arch/i386/kernel/cpu/mcheck/non-fatal.c b/arch/i386/kernel/cpu/mcheck/non-fatal.c --- a/arch/i386/kernel/cpu/mcheck/non-fatal.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/cpu/mcheck/non-fatal.c Tue Mar 4 19:30:04 2003 @@ -33,7 +33,7 @@ rdmsr (MSR_IA32_MC0_STATUS+i*4, low, high); if (high & (1<<31)) { - printk (KERN_EMERG "MCE: The hardware reports a non fatal, correctable incident occured on CPU %d.\n", + printk (KERN_EMERG "MCE: The hardware reports a non fatal, correctable incident occurred on CPU %d.\n", smp_processor_id()); printk (KERN_EMERG "Bank %d: %08x%08x\n", i, high, low); diff -Nru a/arch/i386/kernel/dmi_scan.c b/arch/i386/kernel/dmi_scan.c --- a/arch/i386/kernel/dmi_scan.c Tue Mar 4 19:30:07 2003 +++ b/arch/i386/kernel/dmi_scan.c Tue Mar 4 19:30:07 2003 @@ -440,7 +440,7 @@ { printk(KERN_INFO " *** Possibly defective BIOS detected (irqtable)\n"); printk(KERN_INFO " *** Many BIOSes matching this signature have incorrect IRQ routing tables.\n"); - printk(KERN_INFO " *** If you see IRQ problems, in paticular SCSI resets and hangs at boot\n"); + printk(KERN_INFO " *** If you see IRQ problems, in particular SCSI resets and hangs at boot\n"); printk(KERN_INFO " *** contact your hardware vendor and ask about updates.\n"); printk(KERN_INFO " *** Building an SMP kernel may evade the bug some of the time.\n"); #ifdef CONFIG_X86_IO_APIC @@ -455,7 +455,7 @@ static __init int broken_toshiba_keyboard(struct dmi_blacklist *d) { - printk(KERN_WARNING "Toshiba with broken keyboard detected. If your keyboard sometimes generates 3 keypresses instead of one, contact pavel@ucw.cz\n"); + printk(KERN_WARNING "Toshiba with broken keyboard detected. If your keyboard sometimes generates 3 keypresses instead of one, see http://davyd.ucc.asn.au/projects/toshiba/README\n"); return 0; } @@ -470,6 +470,23 @@ return 0; } +#ifdef CONFIG_ACPI_SLEEP +static __init int reset_videomode_after_s3(struct dmi_blacklist *d) +{ + /* See acpi_wakeup.S */ + extern long acpi_video_flags; + acpi_video_flags |= 2; + return 0; +} + +static __init int reset_videobios_after_s3(struct dmi_blacklist *d) +{ + extern long acpi_video_flags; + acpi_video_flags |= 1; + return 0; +} +#endif + /* * Some Bioses enable the PS/2 mouse (touchpad) at resume, even if it was * disabled before the suspend. Linux used to get terribly confused by that. @@ -743,6 +760,12 @@ MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"), NO_MATCH, NO_MATCH, NO_MATCH } }, +#ifdef CONFIG_ACPI_SLEEP + { reset_videomode_after_s3, "Toshiba Satellite 4030cdt", { /* Reset video mode after returning from ACPI S3 sleep */ + MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"), + NO_MATCH, NO_MATCH, NO_MATCH + } }, +#endif { print_if_true, KERN_WARNING "IBM T23 - BIOS 1.03b+ and controller firmware 1.02+ may be needed for Linux APM.", { MATCH(DMI_SYS_VENDOR, "IBM"), diff -Nru a/arch/i386/kernel/entry.S b/arch/i386/kernel/entry.S --- a/arch/i386/kernel/entry.S Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/entry.S Tue Mar 4 19:30:05 2003 @@ -228,7 +228,6 @@ #define SYSENTER_RETURN 0xffffe010 # sysenter call handler stub - ALIGN ENTRY(sysenter_entry) sti pushl $(__USER_DS) @@ -271,7 +270,6 @@ # system call handler stub - ALIGN ENTRY(system_call) pushl %eax # save orig_eax SAVE_ALL diff -Nru a/arch/i386/kernel/i386_ksyms.c b/arch/i386/kernel/i386_ksyms.c --- a/arch/i386/kernel/i386_ksyms.c Tue Mar 4 19:30:14 2003 +++ b/arch/i386/kernel/i386_ksyms.c Tue Mar 4 19:30:14 2003 @@ -68,7 +68,6 @@ EXPORT_SYMBOL(MCA_bus); #ifdef CONFIG_DISCONTIGMEM EXPORT_SYMBOL(node_data); -EXPORT_SYMBOL(pfn_to_nid); #endif #ifdef CONFIG_X86_NUMAQ EXPORT_SYMBOL(xquad_portio); diff -Nru a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c --- a/arch/i386/kernel/io_apic.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/io_apic.c Tue Mar 4 19:30:05 2003 @@ -46,7 +46,7 @@ /* * Is the SiS APIC rmw bug present ? - * -1 = dont know, 0 = no, 1 = yes + * -1 = don't know, 0 = no, 1 = yes */ int sis_apic_bug = -1; @@ -223,7 +223,7 @@ extern unsigned long irq_affinity [NR_IRQS]; int __cacheline_aligned pending_irq_balance_apicid [NR_IRQS]; -static int irqbalance_disabled __initdata = 0; +static int irqbalance_disabled = NO_BALANCE_IRQ; static int physical_balance = 0; struct irq_cpu_info { @@ -492,7 +492,7 @@ unsigned long allowed_mask; unsigned int new_cpu; - if (no_balance_irq) + if (irqbalance_disabled) return; allowed_mask = cpu_online_map & irq_affinity[irq]; @@ -1376,8 +1376,7 @@ void print_all_local_APICs (void) { - smp_call_function(print_local_APIC, NULL, 1, 1); - print_local_APIC(NULL); + on_each_cpu(print_local_APIC, NULL, 1, 1); } void /*__init*/ print_PIC(void) @@ -1843,8 +1842,7 @@ */ printk(KERN_INFO "activating NMI Watchdog ..."); - smp_call_function(enable_NMI_through_LVT0, NULL, 1, 1); - enable_NMI_through_LVT0(NULL); + on_each_cpu(enable_NMI_through_LVT0, NULL, 1, 1); printk(" done.\n"); } diff -Nru a/arch/i386/kernel/irq.c b/arch/i386/kernel/irq.c --- a/arch/i386/kernel/irq.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/irq.c Tue Mar 4 19:30:04 2003 @@ -87,7 +87,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ #if CONFIG_X86 diff -Nru a/arch/i386/kernel/ldt.c b/arch/i386/kernel/ldt.c --- a/arch/i386/kernel/ldt.c Tue Mar 4 19:30:11 2003 +++ b/arch/i386/kernel/ldt.c Tue Mar 4 19:30:11 2003 @@ -55,12 +55,14 @@ wmb(); if (reload) { - load_LDT(pc); #ifdef CONFIG_SMP preempt_disable(); + load_LDT(pc); if (current->mm->cpu_vm_mask != (1 << smp_processor_id())) smp_call_function(flush_ldt, 0, 1, 1); preempt_enable(); +#else + load_LDT(pc); #endif } if (oldsize) { diff -Nru a/arch/i386/kernel/microcode.c b/arch/i386/kernel/microcode.c --- a/arch/i386/kernel/microcode.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/kernel/microcode.c Tue Mar 4 19:30:05 2003 @@ -183,11 +183,10 @@ int i, error = 0, err; struct microcode *m; - if (smp_call_function(do_update_one, NULL, 1, 1) != 0) { + if (on_each_cpu(do_update_one, NULL, 1, 1) != 0) { printk(KERN_ERR "microcode: IPI timeout, giving up\n"); return -EIO; } - do_update_one(NULL); for (i=0; impc_cpuflag & CPU_ENABLED)) return; - apicid = mpc_apic_id(m, translation_table[mpc_record]->trans_quad); + apicid = mpc_apic_id(m, translation_table[mpc_record]); if (m->mpc_featureflag&(1<<0)) Dprintk(" Floating point unit present.\n"); @@ -631,7 +631,7 @@ else if (acpi_lapic) printk(KERN_INFO "Using ACPI for processor (LAPIC) configuration information\n"); - printk("KERN_INFO Intel MultiProcessor Specification v1.%d\n", mpf->mpf_specification); + printk(KERN_INFO "Intel MultiProcessor Specification v1.%d\n", mpf->mpf_specification); if (mpf->mpf_feature2 & (1<<7)) { printk(KERN_INFO " IMCR and PIC compatibility mode.\n"); pic_mode = 1; diff -Nru a/arch/i386/kernel/nmi.c b/arch/i386/kernel/nmi.c --- a/arch/i386/kernel/nmi.c Tue Mar 4 19:30:09 2003 +++ b/arch/i386/kernel/nmi.c Tue Mar 4 19:30:09 2003 @@ -325,7 +325,7 @@ * as these watchdog NMI IRQs are generated on every CPU, we only * have to check the current processor. * - * since NMIs dont listen to _any_ locks, we have to be extremely + * since NMIs don't listen to _any_ locks, we have to be extremely * careful not to rely on unsafe variables. The printk might lock * up though, so we have to break up any console locks first ... * [when there will be more tty-related locks, break them up diff -Nru a/arch/i386/kernel/numaq.c b/arch/i386/kernel/numaq.c --- a/arch/i386/kernel/numaq.c Tue Mar 4 19:30:11 2003 +++ b/arch/i386/kernel/numaq.c Tue Mar 4 19:30:11 2003 @@ -27,6 +27,7 @@ #include #include #include +#include #include /* These are needed before the pgdat's are created */ @@ -82,19 +83,7 @@ * physnode_map[8- ] = -1; */ int physnode_map[MAX_ELEMENTS] = { [0 ... (MAX_ELEMENTS - 1)] = -1}; - -#define PFN_TO_ELEMENT(pfn) (pfn / PAGES_PER_ELEMENT) -#define PA_TO_ELEMENT(pa) (PFN_TO_ELEMENT(pa >> PAGE_SHIFT)) - -int pfn_to_nid(unsigned long pfn) -{ - int nid = physnode_map[PFN_TO_ELEMENT(pfn)]; - - if (nid == -1) - BUG(); /* address is not present */ - - return nid; -} +EXPORT_SYMBOL(physnode_map); /* * for each node mark the regions diff -Nru a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c --- a/arch/i386/kernel/setup.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/kernel/setup.c Tue Mar 4 19:30:08 2003 @@ -14,6 +14,9 @@ * Moved CPU detection code to cpu/${cpu}.c * Patrick Mochel , March 2002 * + * Provisions for empty E820 memory regions (reported by certain BIOSes). + * Alex Achenbach , December 2002. + * */ /* @@ -279,7 +282,7 @@ int chgidx, still_changing; int overlap_entries; int new_bios_entry; - int old_nr, new_nr; + int old_nr, new_nr, chg_nr; int i; /* @@ -333,20 +336,24 @@ for (i=0; i < 2*old_nr; i++) change_point[i] = &change_point_list[i]; - /* record all known change-points (starting and ending addresses) */ + /* record all known change-points (starting and ending addresses), + omitting those that are for empty memory regions */ chgidx = 0; for (i=0; i < old_nr; i++) { - change_point[chgidx]->addr = biosmap[i].addr; - change_point[chgidx++]->pbios = &biosmap[i]; - change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size; - change_point[chgidx++]->pbios = &biosmap[i]; + if (biosmap[i].size != 0) { + change_point[chgidx]->addr = biosmap[i].addr; + change_point[chgidx++]->pbios = &biosmap[i]; + change_point[chgidx]->addr = biosmap[i].addr + biosmap[i].size; + change_point[chgidx++]->pbios = &biosmap[i]; + } } + chg_nr = chgidx; /* true number of change-points */ /* sort change-point list by memory addresses (low -> high) */ still_changing = 1; while (still_changing) { still_changing = 0; - for (i=1; i < 2*old_nr; i++) { + for (i=1; i < chg_nr; i++) { /* if > , swap */ /* or, if current= & last=, swap */ if ((change_point[i]->addr < change_point[i-1]->addr) || @@ -369,7 +376,7 @@ last_type = 0; /* start with undefined memory type */ last_addr = 0; /* start with 0 as last starting address */ /* loop through change-points, determining affect on the new bios map */ - for (chgidx=0; chgidx < 2*old_nr; chgidx++) + for (chgidx=0; chgidx < chg_nr; chgidx++) { /* keep track of all overlapping bios entries */ if (change_point[chgidx]->addr == change_point[chgidx]->pbios->addr) @@ -545,6 +552,12 @@ if (*from == '@') { start_at = memparse(from+1, &from); add_memory_region(start_at, mem_size, E820_RAM); + } else if (*from == '#') { + start_at = memparse(from+1, &from); + add_memory_region(start_at, mem_size, E820_ACPI); + } else if (*from == '$') { + start_at = memparse(from+1, &from); + add_memory_region(start_at, mem_size, E820_RESERVED); } else { limit_regions(mem_size); userdef=1; @@ -818,7 +831,7 @@ request_resource(&iomem_resource, res); if (e820.map[i].type == E820_RAM) { /* - * We dont't know which RAM region contains kernel data, + * We don't know which RAM region contains kernel data, * so we try it repeatedly and let the resource manager * test it. */ diff -Nru a/arch/i386/kernel/smp.c b/arch/i386/kernel/smp.c --- a/arch/i386/kernel/smp.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/kernel/smp.c Tue Mar 4 19:30:04 2003 @@ -436,7 +436,7 @@ preempt_enable(); } -static inline void do_flush_tlb_all_local(void) +static void do_flush_tlb_all(void* info) { unsigned long cpu = smp_processor_id(); @@ -445,18 +445,9 @@ leave_mm(cpu); } -static void flush_tlb_all_ipi(void* info) -{ - do_flush_tlb_all_local(); -} - void flush_tlb_all(void) { - preempt_disable(); - smp_call_function (flush_tlb_all_ipi,0,1,1); - - do_flush_tlb_all_local(); - preempt_enable(); + on_each_cpu(do_flush_tlb_all, 0, 1, 1); } /* diff -Nru a/arch/i386/kernel/smpboot.c b/arch/i386/kernel/smpboot.c --- a/arch/i386/kernel/smpboot.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/kernel/smpboot.c Tue Mar 4 19:30:08 2003 @@ -170,7 +170,7 @@ /* * TSC synchronization. * - * We first check wether all CPUs have their TSC's synchronized, + * We first check whether all CPUs have their TSC's synchronized, * then we print a warning if not, and always resync. */ @@ -956,7 +956,7 @@ smp_tune_scheduling(); /* - * If we couldnt find an SMP configuration at boot time, + * If we couldn't find an SMP configuration at boot time, * get out of here now! */ if (!smp_found_config) { diff -Nru a/arch/i386/kernel/srat.c b/arch/i386/kernel/srat.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/arch/i386/kernel/srat.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,448 @@ +/* + * Some of the code in this file has been gleaned from the 64 bit + * discontigmem support code base. + * + * Copyright (C) 2002, IBM Corp. + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or + * NON INFRINGEMENT. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Send feedback to Pat Gaughen + */ +#include +#include +#include +#include +#include +#include + +/* + * proximity macros and definitions + */ +#define NODE_ARRAY_INDEX(x) ((x) / 8) /* 8 bits/char */ +#define NODE_ARRAY_OFFSET(x) ((x) % 8) /* 8 bits/char */ +#define BMAP_SET(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] |= 1 << NODE_ARRAY_OFFSET(bit)) +#define BMAP_TEST(bmap, bit) ((bmap)[NODE_ARRAY_INDEX(bit)] & (1 << NODE_ARRAY_OFFSET(bit))) +#define MAX_PXM_DOMAINS 256 /* 1 byte and no promises about values */ +/* bitmap length; _PXM is at most 255 */ +#define PXM_BITMAP_LEN (MAX_PXM_DOMAINS / 8) +static u8 pxm_bitmap[PXM_BITMAP_LEN]; /* bitmap of proximity domains */ + +#define MAX_CHUNKS_PER_NODE 4 +#define MAXCHUNKS (MAX_CHUNKS_PER_NODE * MAX_NUMNODES) +struct node_memory_chunk_s { + unsigned long start_pfn; + unsigned long end_pfn; + u8 pxm; // proximity domain of node + u8 nid; // which cnode contains this chunk? + u8 bank; // which mem bank on this node +}; +static struct node_memory_chunk_s node_memory_chunk[MAXCHUNKS]; + +static int num_memory_chunks; /* total number of memory chunks */ +static int zholes_size_init; +static unsigned long zholes_size[MAX_NUMNODES * MAX_NR_ZONES]; + +unsigned long node_start_pfn[MAX_NUMNODES]; +unsigned long node_end_pfn[MAX_NUMNODES]; + +extern void * boot_ioremap(unsigned long, unsigned long); + +/* Identify CPU proximity domains */ +static void __init parse_cpu_affinity_structure(char *p) +{ + struct acpi_table_processor_affinity *cpu_affinity = + (struct acpi_table_processor_affinity *) p; + + if (!cpu_affinity->flags.enabled) + return; /* empty entry */ + + /* mark this node as "seen" in node bitmap */ + BMAP_SET(pxm_bitmap, cpu_affinity->proximity_domain); + + printk("CPU 0x%02X in proximity domain 0x%02X\n", + cpu_affinity->apic_id, cpu_affinity->proximity_domain); +} + +/* + * Identify memory proximity domains and hot-remove capabilities. + * Fill node memory chunk list structure. + */ +static void __init parse_memory_affinity_structure (char *sratp) +{ + unsigned long long paddr, size; + unsigned long start_pfn, end_pfn; + u8 pxm; + struct node_memory_chunk_s *p, *q, *pend; + struct acpi_table_memory_affinity *memory_affinity = + (struct acpi_table_memory_affinity *) sratp; + + if (!memory_affinity->flags.enabled) + return; /* empty entry */ + + /* mark this node as "seen" in node bitmap */ + BMAP_SET(pxm_bitmap, memory_affinity->proximity_domain); + + /* calculate info for memory chunk structure */ + paddr = memory_affinity->base_addr_hi; + paddr = (paddr << 32) | memory_affinity->base_addr_lo; + size = memory_affinity->length_hi; + size = (size << 32) | memory_affinity->length_lo; + + start_pfn = paddr >> PAGE_SHIFT; + end_pfn = (paddr + size) >> PAGE_SHIFT; + + pxm = memory_affinity->proximity_domain; + + if (num_memory_chunks >= MAXCHUNKS) { + printk("Too many mem chunks in SRAT. Ignoring %lld MBytes at %llx\n", + size/(1024*1024), paddr); + return; + } + + /* Insertion sort based on base address */ + pend = &node_memory_chunk[num_memory_chunks]; + for (p = &node_memory_chunk[0]; p < pend; p++) { + if (start_pfn < p->start_pfn) + break; + } + if (p < pend) { + for (q = pend; q >= p; q--) + *(q + 1) = *q; + } + p->start_pfn = start_pfn; + p->end_pfn = end_pfn; + p->pxm = pxm; + + num_memory_chunks++; + + printk("Memory range 0x%lX to 0x%lX (type 0x%X) in proximity domain 0x%02X %s\n", + start_pfn, end_pfn, + memory_affinity->memory_type, + memory_affinity->proximity_domain, + (memory_affinity->flags.hot_pluggable ? + "enabled and removable" : "enabled" ) ); +} + +#if MAX_NR_ZONES != 3 +#error "MAX_NR_ZONES != 3, chunk_to_zone requires review" +#endif +/* Take a chunk of pages from page frame cstart to cend and count the number + * of pages in each zone, returned via zones[]. + */ +static __init void chunk_to_zones(unsigned long cstart, unsigned long cend, + unsigned long *zones) +{ + unsigned long max_dma; + extern unsigned long max_low_pfn; + + int z; + unsigned long rend; + + /* FIXME: MAX_DMA_ADDRESS and max_low_pfn are trying to provide + * similarly scoped information and should be handled in a consistant + * manner. + */ + max_dma = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT; + + /* Split the hole into the zones in which it falls. Repeatedly + * take the segment in which the remaining hole starts, round it + * to the end of that zone. + */ + memset(zones, 0, MAX_NR_ZONES * sizeof(long)); + while (cstart < cend) { + if (cstart < max_dma) { + z = ZONE_DMA; + rend = (cend < max_dma)? cend : max_dma; + + } else if (cstart < max_low_pfn) { + z = ZONE_NORMAL; + rend = (cend < max_low_pfn)? cend : max_low_pfn; + + } else { + z = ZONE_HIGHMEM; + rend = cend; + } + zones[z] += rend - cstart; + cstart = rend; + } +} + +/* + * physnode_map keeps track of the physical memory layout of the + * numaq nodes on a 256Mb break (each element of the array will + * represent 256Mb of memory and will be marked by the node id. so, + * if the first gig is on node 0, and the second gig is on node 1 + * physnode_map will contain: + * physnode_map[0-3] = 0; + * physnode_map[4-7] = 1; + * physnode_map[8- ] = -1; + */ +int pfnnode_map[MAX_ELEMENTS] = { [0 ... (MAX_ELEMENTS - 1)] = -1}; +EXPORT_SYMBOL(pfnnode_map); + +static void __init initialize_pfnnode_map(void) +{ + unsigned long topofchunk, cur = 0; + int i; + + for (i = 0; i < num_memory_chunks; i++) { + cur = node_memory_chunk[i].start_pfn; + topofchunk = node_memory_chunk[i].end_pfn; + while (cur < topofchunk) { + pfnnode_map[PFN_TO_ELEMENT(cur)] = node_memory_chunk[i].nid; + cur ++; + } + } +} + +/* Parse the ACPI Static Resource Affinity Table */ +static int __init acpi20_parse_srat(struct acpi_table_srat *sratp) +{ + u8 *start, *end, *p; + int i, j, nid; + u8 pxm_to_nid_map[MAX_PXM_DOMAINS];/* _PXM to logical node ID map */ + u8 nid_to_pxm_map[MAX_NUMNODES];/* logical node ID to _PXM map */ + + start = (u8 *)(&(sratp->reserved) + 1); /* skip header */ + p = start; + end = (u8 *)sratp + sratp->header.length; + + memset(pxm_bitmap, 0, sizeof(pxm_bitmap)); /* init proximity domain bitmap */ + memset(node_memory_chunk, 0, sizeof(node_memory_chunk)); + memset(zholes_size, 0, sizeof(zholes_size)); + + /* -1 in these maps means not available */ + memset(pxm_to_nid_map, -1, sizeof(pxm_to_nid_map)); + memset(nid_to_pxm_map, -1, sizeof(nid_to_pxm_map)); + + num_memory_chunks = 0; + while (p < end) { + switch (*p) { + case ACPI_SRAT_PROCESSOR_AFFINITY: + parse_cpu_affinity_structure(p); + break; + case ACPI_SRAT_MEMORY_AFFINITY: + parse_memory_affinity_structure(p); + break; + default: + printk("ACPI 2.0 SRAT: unknown entry skipped: type=0x%02X, len=%d\n", p[0], p[1]); + break; + } + p += p[1]; + if (p[1] == 0) { + printk("acpi20_parse_srat: Entry length value is zero;" + " can't parse any further!\n"); + break; + } + } + + /* Calculate total number of nodes in system from PXM bitmap and create + * a set of sequential node IDs starting at zero. (ACPI doesn't seem + * to specify the range of _PXM values.) + */ + numnodes = 0; /* init total nodes in system */ + for (i = 0; i < MAX_PXM_DOMAINS; i++) { + if (BMAP_TEST(pxm_bitmap, i)) { + pxm_to_nid_map[i] = numnodes; + nid_to_pxm_map[numnodes] = i; + node_set_online(numnodes); + ++numnodes; + } + } + + if (numnodes == 0) + BUG(); + + /* set cnode id in memory chunk structure */ + for (i = 0; i < num_memory_chunks; i++) + node_memory_chunk[i].nid = pxm_to_nid_map[node_memory_chunk[i].pxm]; + + initialize_pfnnode_map(); + + printk("pxm bitmap: "); + for (i = 0; i < sizeof(pxm_bitmap); i++) { + printk("%02X ", pxm_bitmap[i]); + } + printk("\n"); + printk("Number of logical nodes in system = %d\n", numnodes); + printk("Number of memory chunks in system = %d\n", num_memory_chunks); + + for (j = 0; j < num_memory_chunks; j++){ + printk("chunk %d nid %d start_pfn %08lx end_pfn %08lx\n", + j, node_memory_chunk[j].nid, + node_memory_chunk[j].start_pfn, + node_memory_chunk[j].end_pfn); + } + + /*calculate node_start_pfn/node_end_pfn arrays*/ + for (nid = 0; nid < numnodes; nid++) { + int been_here_before = 0; + + for (j = 0; j < num_memory_chunks; j++){ + if (node_memory_chunk[j].nid == nid) { + if (been_here_before == 0) { + node_start_pfn[nid] = node_memory_chunk[j].start_pfn; + node_end_pfn[nid] = node_memory_chunk[j].end_pfn; + been_here_before = 1; + } else { /* We've found another chunk of memory for the node */ + if (node_start_pfn[nid] < node_memory_chunk[j].start_pfn) { + node_end_pfn[nid] = node_memory_chunk[j].end_pfn; + } + } + } + } + } + return 0; +} + +void __init get_memcfg_from_srat(void) +{ + struct acpi_table_header *header = NULL; + struct acpi_table_rsdp *rsdp = NULL; + struct acpi_table_rsdt *rsdt = NULL; + struct acpi_pointer *rsdp_address = NULL; + struct acpi_table_rsdt saved_rsdt; + int tables = 0; + int i = 0; + + acpi_find_root_pointer(ACPI_PHYSICAL_ADDRESSING, rsdp_address); + + if (rsdp_address->pointer_type == ACPI_PHYSICAL_POINTER) { + printk("%s: assigning address to rsdp\n", __FUNCTION__); + rsdp = (struct acpi_table_rsdp *)rsdp_address->pointer.physical; + } else { + printk("%s: rsdp_address is not a physical pointer\n", __FUNCTION__); + return; + } + if (!rsdp) { + printk("%s: Didn't find ACPI root!\n", __FUNCTION__); + return; + } + + printk(KERN_INFO "%.8s v%d [%.6s]\n", rsdp->signature, rsdp->revision, + rsdp->oem_id); + + if (strncmp(rsdp->signature, RSDP_SIG,strlen(RSDP_SIG))) { + printk(KERN_WARNING "%s: RSDP table signature incorrect\n", __FUNCTION__); + return; + } + + rsdt = (struct acpi_table_rsdt *) + boot_ioremap(rsdp->rsdt_address, sizeof(struct acpi_table_rsdt)); + + if (!rsdt) { + printk(KERN_WARNING + "%s: ACPI: Invalid root system description tables (RSDT)\n", + __FUNCTION__); + return; + } + + header = & rsdt->header; + + if (strncmp(header->signature, RSDT_SIG, strlen(RSDT_SIG))) { + printk(KERN_WARNING "ACPI: RSDT signature incorrect\n"); + return; + } + + /* + * The number of tables is computed by taking the + * size of all entries (header size minus total + * size of RSDT) divided by the size of each entry + * (4-byte table pointers). + */ + tables = (header->length - sizeof(struct acpi_table_header)) / 4; + + memcpy(&saved_rsdt, rsdt, sizeof(saved_rsdt)); + + if (saved_rsdt.header.length > sizeof(saved_rsdt)) { + printk(KERN_WARNING "ACPI: Too big length in RSDT: %d\n", + saved_rsdt.header.length); + return; + } + +printk("Begin table scan....\n"); + + for (i = 0; i < tables; i++) { + /* Map in header, then map in full table length. */ + header = (struct acpi_table_header *) + boot_ioremap(saved_rsdt.entry[i], sizeof(struct acpi_table_header)); + if (!header) + break; + header = (struct acpi_table_header *) + boot_ioremap(saved_rsdt.entry[i], header->length); + if (!header) + break; + + if (strncmp((char *) &header->signature, "SRAT", 4)) + continue; + acpi20_parse_srat((struct acpi_table_srat *)header); + /* we've found the srat table. don't need to look at any more tables */ + break; + } +} + +/* For each node run the memory list to determine whether there are + * any memory holes. For each hole determine which ZONE they fall + * into. + * + * NOTE#1: this requires knowledge of the zone boundries and so + * _cannot_ be performed before those are calculated in setup_memory. + * + * NOTE#2: we rely on the fact that the memory chunks are ordered by + * start pfn number during setup. + */ +static void __init get_zholes_init(void) +{ + int nid; + int c; + int first; + unsigned long end = 0; + + for (nid = 0; nid < numnodes; nid++) { + first = 1; + for (c = 0; c < num_memory_chunks; c++){ + if (node_memory_chunk[c].nid == nid) { + if (first) { + end = node_memory_chunk[c].end_pfn; + first = 0; + + } else { + /* Record any gap between this chunk + * and the previous chunk on this node + * against the zones it spans. + */ + chunk_to_zones(end, + node_memory_chunk[c].start_pfn, + &zholes_size[nid * MAX_NR_ZONES]); + } + } + } + } +} + +unsigned long * __init get_zholes_size(int nid) +{ + if (!zholes_size_init) { + zholes_size_init++; + get_zholes_init(); + } + if((nid >= numnodes) | (nid >= MAX_NUMNODES)) + printk("%s: nid = %d is invalid. numnodes = %d", + __FUNCTION__, nid, numnodes); + return &zholes_size[nid * MAX_NR_ZONES]; +} diff -Nru a/arch/i386/kernel/suspend.c b/arch/i386/kernel/suspend.c --- a/arch/i386/kernel/suspend.c Tue Mar 4 19:30:12 2003 +++ b/arch/i386/kernel/suspend.c Tue Mar 4 19:30:12 2003 @@ -113,7 +113,7 @@ int cpu = smp_processor_id(); struct tss_struct * t = init_tss + cpu; - set_tss_desc(cpu,t); /* This just modifies memory; should not be neccessary. But... This is neccessary, because 386 hardware has concept of busy TSS or some similar stupidity. */ + set_tss_desc(cpu,t); /* This just modifies memory; should not be necessary. But... This is necessary, because 386 hardware has concept of busy TSS or some similar stupidity. */ cpu_gdt_table[cpu][GDT_ENTRY_TSS].b &= 0xfffffdff; load_TR_desc(); /* This does ltr */ diff -Nru a/arch/i386/kernel/sysenter.c b/arch/i386/kernel/sysenter.c --- a/arch/i386/kernel/sysenter.c Tue Mar 4 19:30:14 2003 +++ b/arch/i386/kernel/sysenter.c Tue Mar 4 19:30:14 2003 @@ -95,8 +95,7 @@ return 0; memcpy((void *) page, sysent, sizeof(sysent)); - enable_sep_cpu(NULL); - smp_call_function(enable_sep_cpu, NULL, 1, 1); + on_each_cpu(enable_sep_cpu, NULL, 1, 1); return 0; } diff -Nru a/arch/i386/kernel/time.c b/arch/i386/kernel/time.c --- a/arch/i386/kernel/time.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/kernel/time.c Tue Mar 4 19:30:08 2003 @@ -66,7 +66,7 @@ #include "do_timer.h" -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; unsigned long cpu_khz; /* Detected as we calibrate the TSC */ diff -Nru a/arch/i386/kernel/timers/timer_tsc.c b/arch/i386/kernel/timers/timer_tsc.c --- a/arch/i386/kernel/timers/timer_tsc.c Tue Mar 4 19:30:11 2003 +++ b/arch/i386/kernel/timers/timer_tsc.c Tue Mar 4 19:30:11 2003 @@ -264,7 +264,7 @@ * the ident/bugs checks so we must run this hook as it * may turn off the TSC flag. * - * NOTE: this doesnt yet handle SMP 486 machines where only + * NOTE: this doesn't yet handle SMP 486 machines where only * some CPU's have a TSC. Thats never worked and nobody has * moaned if you have the only one in the world - you fix it! */ @@ -299,6 +299,7 @@ return -ENODEV; } +#ifndef CONFIG_X86_TSC /* disable flag for tsc. Takes effect by clearing the TSC cpu flag * in cpu/common.c */ static int __init tsc_setup(char *str) @@ -306,7 +307,14 @@ tsc_disable = 1; return 1; } - +#else +static int __init tsc_setup(char *str) +{ + printk(KERN_WARNING "notsc: Kernel compiled with CONFIG_X86_TSC, " + "cannot disable TSC.\n"); + return 1; +} +#endif __setup("notsc", tsc_setup); diff -Nru a/arch/i386/lib/mmx.c b/arch/i386/lib/mmx.c --- a/arch/i386/lib/mmx.c Tue Mar 4 19:30:09 2003 +++ b/arch/i386/lib/mmx.c Tue Mar 4 19:30:09 2003 @@ -15,7 +15,7 @@ * (reported so on K6-III) * We should use a better code neutral filler for the short jump * leal ebx. [ebx] is apparently best for K6-2, but Cyrix ?? - * We also want to clobber the filler register so we dont get any + * We also want to clobber the filler register so we don't get any * register forwarding stalls on the filler. * * Add *user handling. Checksums are not a win with MMX on any CPU diff -Nru a/arch/i386/mach-visws/visws_apic.c b/arch/i386/mach-visws/visws_apic.c --- a/arch/i386/mach-visws/visws_apic.c Tue Mar 4 19:30:04 2003 +++ b/arch/i386/mach-visws/visws_apic.c Tue Mar 4 19:30:04 2003 @@ -190,7 +190,7 @@ * the 'master' interrupt source: CO_IRQ_8259. * * When the 8259 interrupts its handler figures out which of these - * devices is interrupting and dispatches to it's handler. + * devices is interrupting and dispatches to its handler. * * CAREFUL: devices see the 'virtual' interrupt only. Thus disable/ * enable_irq gets the right irq. This 'master' irq is never directly diff -Nru a/arch/i386/mach-voyager/voyager_smp.c b/arch/i386/mach-voyager/voyager_smp.c --- a/arch/i386/mach-voyager/voyager_smp.c Tue Mar 4 19:30:07 2003 +++ b/arch/i386/mach-voyager/voyager_smp.c Tue Mar 4 19:30:07 2003 @@ -1209,8 +1209,8 @@ smp_call_function_interrupt(); } -static inline void -do_flush_tlb_all_local(void) +static void +do_flush_tlb_all(void* info) { unsigned long cpu = smp_processor_id(); @@ -1220,19 +1220,11 @@ } -static void -flush_tlb_all_function(void* info) -{ - do_flush_tlb_all_local(); -} - /* flush the TLB of every active CPU in the system */ void flush_tlb_all(void) { - smp_call_function (flush_tlb_all_function, 0, 1, 1); - - do_flush_tlb_all_local(); + on_each_cpu(do_flush_tlb_all, 0, 1, 1); } /* used to set up the trampoline for other CPUs when the memory manager @@ -1453,7 +1445,7 @@ } /* send a CPI at level cpi to a set of cpus in cpuset (set 1 bit per - * processor to recieve CPI */ + * processor to receive CPI */ static void send_CPI(__u32 cpuset, __u8 cpi) { @@ -1481,7 +1473,7 @@ outb((__u8)cpuset, VIC_CPI_Registers[VIC_CPI_LEVEL0]); } -/* Acknowlege receipt of CPI in the QIC, clear in QIC hardware and +/* Acknowledge receipt of CPI in the QIC, clear in QIC hardware and * set the cache line to shared by reading it. * * DON'T make this inline otherwise the cache line read will be diff -Nru a/arch/i386/mm/Makefile b/arch/i386/mm/Makefile --- a/arch/i386/mm/Makefile Tue Mar 4 19:30:05 2003 +++ b/arch/i386/mm/Makefile Tue Mar 4 19:30:05 2003 @@ -2,8 +2,9 @@ # Makefile for the linux i386-specific parts of the memory manager. # -obj-y := init.o pgtable.o fault.o ioremap.o extable.o pageattr.o +obj-y := init.o pgtable.o fault.o ioremap.o extable.o pageattr.o obj-$(CONFIG_DISCONTIGMEM) += discontig.o obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o obj-$(CONFIG_HIGHMEM) += highmem.o +obj-$(CONFIG_BOOT_IOREMAP) += boot_ioremap.o diff -Nru a/arch/i386/mm/boot_ioremap.c b/arch/i386/mm/boot_ioremap.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/arch/i386/mm/boot_ioremap.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,94 @@ +/* + * arch/i386/mm/boot_ioremap.c + * + * Re-map functions for early boot-time before paging_init() when the + * boot-time pagetables are still in use + * + * Written by Dave Hansen + */ + + +/* + * We need to use the 2-level pagetable functions, but CONFIG_X86_PAE + * keeps that from happenning. If anyone has a better way, I'm listening. + * + * boot_pte_t is defined only if this all works correctly + */ + +#include +#undef CONFIG_X86_PAE +#include +#include +#include +#include + +/* + * I'm cheating here. It is known that the two boot PTE pages are + * allocated next to each other. I'm pretending that they're just + * one big array. + */ + +#define BOOT_PTE_PTRS (PTRS_PER_PTE*2) +#define boot_pte_index(address) \ + (((address) >> PAGE_SHIFT) & (BOOT_PTE_PTRS - 1)) + +static inline boot_pte_t* boot_vaddr_to_pte(void *address) +{ + boot_pte_t* boot_pg = (boot_pte_t*)pg0; + return &boot_pg[boot_pte_index((unsigned long)address)]; +} + +/* + * This is only for a caller who is clever enough to page-align + * phys_addr and virtual_source, and who also has a preference + * about which virtual address from which to steal ptes + */ +static void __boot_ioremap(unsigned long phys_addr, unsigned long nrpages, + void* virtual_source) +{ + boot_pte_t* pte; + int i; + + pte = boot_vaddr_to_pte(virtual_source); + for (i=0; i < nrpages; i++, phys_addr += PAGE_SIZE, pte++) { + set_pte(pte, pfn_pte(phys_addr>>PAGE_SHIFT, PAGE_KERNEL)); + } +} + +/* the virtual space we're going to remap comes from this array */ +#define BOOT_IOREMAP_PAGES 4 +#define BOOT_IOREMAP_SIZE (BOOT_IOREMAP_PAGES*PAGE_SIZE) +__initdata char boot_ioremap_space[BOOT_IOREMAP_SIZE] + __attribute__ ((aligned (PAGE_SIZE))); + +/* + * This only applies to things which need to ioremap before paging_init() + * bt_ioremap() and plain ioremap() are both useless at this point. + * + * When used, we're still using the boot-time pagetables, which only + * have 2 PTE pages mapping the first 8MB + * + * There is no unmap. The boot-time PTE pages aren't used after boot. + * If you really want the space back, just remap it yourself. + * boot_ioremap(&ioremap_space-PAGE_OFFSET, BOOT_IOREMAP_SIZE) + */ +__init void* boot_ioremap(unsigned long phys_addr, unsigned long size) +{ + unsigned long last_addr, offset; + unsigned int nrpages; + + last_addr = phys_addr + size - 1; + + /* page align the requested address */ + offset = phys_addr & ~PAGE_MASK; + phys_addr &= PAGE_MASK; + size = PAGE_ALIGN(last_addr) - phys_addr; + + nrpages = size >> PAGE_SHIFT; + if (nrpages > BOOT_IOREMAP_PAGES) + return NULL; + + __boot_ioremap(phys_addr, nrpages, boot_ioremap_space); + + return &boot_ioremap_space[offset]; +} diff -Nru a/arch/i386/mm/discontig.c b/arch/i386/mm/discontig.c --- a/arch/i386/mm/discontig.c Tue Mar 4 19:30:09 2003 +++ b/arch/i386/mm/discontig.c Tue Mar 4 19:30:09 2003 @@ -48,6 +48,14 @@ extern unsigned long totalram_pages; extern unsigned long totalhigh_pages; +#define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE) + +unsigned long node_remap_start_pfn[MAX_NUMNODES]; +unsigned long node_remap_size[MAX_NUMNODES]; +unsigned long node_remap_offset[MAX_NUMNODES]; +void *node_remap_start_vaddr[MAX_NUMNODES]; +void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags); + /* * Find the highest page frame number we have available for the node */ @@ -65,12 +73,13 @@ */ static void __init allocate_pgdat(int nid) { - unsigned long node_datasz; - - node_datasz = PFN_UP(sizeof(struct pglist_data)); - NODE_DATA(nid) = (pg_data_t *)(__va(min_low_pfn << PAGE_SHIFT)); - min_low_pfn += node_datasz; - memset(NODE_DATA(nid), 0, sizeof(struct pglist_data)); + if (nid) + NODE_DATA(nid) = (pg_data_t *)node_remap_start_vaddr[nid]; + else { + NODE_DATA(nid) = (pg_data_t *)(__va(min_low_pfn << PAGE_SHIFT)); + min_low_pfn += PFN_UP(sizeof(pg_data_t)); + memset(NODE_DATA(nid), 0, sizeof(pg_data_t)); + } } /* @@ -113,14 +122,6 @@ } } -#define LARGE_PAGE_BYTES (PTRS_PER_PTE * PAGE_SIZE) - -unsigned long node_remap_start_pfn[MAX_NUMNODES]; -unsigned long node_remap_size[MAX_NUMNODES]; -unsigned long node_remap_offset[MAX_NUMNODES]; -void *node_remap_start_vaddr[MAX_NUMNODES]; -extern void set_pmd_pfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags); - void __init remap_numa_kva(void) { void *vaddr; @@ -145,7 +146,7 @@ for (nid = 1; nid < numnodes; nid++) { /* calculate the size of the mem_map needed in bytes */ size = (node_end_pfn[nid] - node_start_pfn[nid] + 1) - * sizeof(struct page); + * sizeof(struct page) + sizeof(pg_data_t); /* convert size to large (pmd size) pages, rounding up */ size = (size + LARGE_PAGE_BYTES - 1) / LARGE_PAGE_BYTES; /* now the roundup is correct, convert to PAGE_SIZE pages */ @@ -195,9 +196,9 @@ printk("Low memory ends at vaddr %08lx\n", (ulong) pfn_to_kaddr(max_low_pfn)); for (nid = 0; nid < numnodes; nid++) { - allocate_pgdat(nid); node_remap_start_vaddr[nid] = pfn_to_kaddr( highstart_pfn - node_remap_offset[nid]); + allocate_pgdat(nid); printk ("node %d will remap to vaddr %08lx - %08lx\n", nid, (ulong) node_remap_start_vaddr[nid], (ulong) pfn_to_kaddr(highstart_pfn @@ -251,13 +252,6 @@ */ find_smp_config(); - /*insert other nodes into pgdat_list*/ - for (nid = 1; nid < numnodes; nid++){ - NODE_DATA(nid)->pgdat_next = pgdat_list; - pgdat_list = NODE_DATA(nid); - } - - #ifdef CONFIG_BLK_DEV_INITRD if (LOADER_TYPE && INITRD_START) { if (INITRD_START + INITRD_SIZE <= (system_max_low_pfn << PAGE_SHIFT)) { @@ -282,8 +276,21 @@ { int nid; + /* + * Insert nodes into pgdat_list backward so they appear in order. + * Clobber node 0's links and NULL out pgdat_list before starting. + */ + pgdat_list = NULL; + for (nid = numnodes - 1; nid >= 0; nid--) { + if (nid) + memset(NODE_DATA(nid), 0, sizeof(pg_data_t)); + NODE_DATA(nid)->pgdat_next = pgdat_list; + pgdat_list = NODE_DATA(nid); + } + for (nid = 0; nid < numnodes; nid++) { unsigned long zones_size[MAX_NR_ZONES] = {0, 0, 0}; + unsigned long *zholes_size; unsigned int max_dma; unsigned long low = max_low_pfn; @@ -307,18 +314,24 @@ #endif } } + zholes_size = get_zholes_size(nid); /* * We let the lmem_map for node 0 be allocated from the * normal bootmem allocator, but other nodes come from the * remapped KVA area - mbligh */ - if (nid) - free_area_init_node(nid, NODE_DATA(nid), - node_remap_start_vaddr[nid], zones_size, - start, 0); - else + if (!nid) free_area_init_node(nid, NODE_DATA(nid), 0, - zones_size, start, 0); + zones_size, start, zholes_size); + else { + unsigned long lmem_map; + lmem_map = (unsigned long)node_remap_start_vaddr[nid]; + lmem_map += sizeof(pg_data_t) + PAGE_SIZE - 1; + lmem_map &= PAGE_MASK; + free_area_init_node(nid, NODE_DATA(nid), + (struct page *)lmem_map, zones_size, + start, zholes_size); + } } return; } diff -Nru a/arch/i386/mm/hugetlbpage.c b/arch/i386/mm/hugetlbpage.c --- a/arch/i386/mm/hugetlbpage.c Tue Mar 4 19:30:13 2003 +++ b/arch/i386/mm/hugetlbpage.c Tue Mar 4 19:30:13 2003 @@ -29,6 +29,8 @@ static LIST_HEAD(htlbpage_freelist); static spinlock_t htlbpage_lock = SPIN_LOCK_UNLOCKED; +void free_huge_page(struct page *page); + static struct page *alloc_hugetlb_page(void) { int i; @@ -45,7 +47,7 @@ htlbpagemem--; spin_unlock(&htlbpage_lock); set_page_count(page, 1); - page->lru.prev = (void *)huge_page_release; + page->lru.prev = (void *)free_huge_page; for (i = 0; i < (HPAGE_SIZE/PAGE_SIZE); ++i) clear_highpage(&page[i]); return page; diff -Nru a/arch/i386/mm/ioremap.c b/arch/i386/mm/ioremap.c --- a/arch/i386/mm/ioremap.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/mm/ioremap.c Tue Mar 4 19:30:05 2003 @@ -205,6 +205,7 @@ iounmap(p); p = NULL; } + global_flush_tlb(); } return p; @@ -226,6 +227,7 @@ change_page_attr(virt_to_page(__va(p->phys_addr)), p->size >> PAGE_SHIFT, PAGE_KERNEL); + global_flush_tlb(); } kfree(p); } diff -Nru a/arch/i386/mm/pageattr.c b/arch/i386/mm/pageattr.c --- a/arch/i386/mm/pageattr.c Tue Mar 4 19:30:08 2003 +++ b/arch/i386/mm/pageattr.c Tue Mar 4 19:30:08 2003 @@ -130,11 +130,8 @@ } static inline void flush_map(void) -{ -#ifdef CONFIG_SMP - smp_call_function(flush_kernel_map, NULL, 1, 1); -#endif - flush_kernel_map(NULL); +{ + on_each_cpu(flush_kernel_map, NULL, 1, 1); } struct deferred_page { diff -Nru a/arch/i386/mm/pgtable.c b/arch/i386/mm/pgtable.c --- a/arch/i386/mm/pgtable.c Tue Mar 4 19:30:14 2003 +++ b/arch/i386/mm/pgtable.c Tue Mar 4 19:30:14 2003 @@ -11,6 +11,7 @@ #include #include #include +#include #include #include diff -Nru a/arch/i386/oprofile/nmi_int.c b/arch/i386/oprofile/nmi_int.c --- a/arch/i386/oprofile/nmi_int.c Tue Mar 4 19:30:13 2003 +++ b/arch/i386/oprofile/nmi_int.c Tue Mar 4 19:30:13 2003 @@ -95,8 +95,7 @@ * without actually triggering any NMIs as this will * break the core code horrifically. */ - smp_call_function(nmi_cpu_setup, NULL, 0, 1); - nmi_cpu_setup(0); + on_each_cpu(nmi_cpu_setup, NULL, 0, 1); set_nmi_callback(nmi_callback); oprofile_pmdev = set_nmi_pm_callback(oprofile_pm_callback); return 0; @@ -148,8 +147,7 @@ { unset_nmi_pm_callback(oprofile_pmdev); unset_nmi_callback(); - smp_call_function(nmi_cpu_shutdown, NULL, 0, 1); - nmi_cpu_shutdown(0); + on_each_cpu(nmi_cpu_shutdown, NULL, 0, 1); } @@ -162,8 +160,7 @@ static int nmi_start(void) { - smp_call_function(nmi_cpu_start, NULL, 0, 1); - nmi_cpu_start(0); + on_each_cpu(nmi_cpu_start, NULL, 0, 1); return 0; } @@ -177,8 +174,7 @@ static void nmi_stop(void) { - smp_call_function(nmi_cpu_stop, NULL, 0, 1); - nmi_cpu_stop(0); + on_each_cpu(nmi_cpu_stop, NULL, 0, 1); } diff -Nru a/arch/i386/pci/numa.c b/arch/i386/pci/numa.c --- a/arch/i386/pci/numa.c Tue Mar 4 19:30:05 2003 +++ b/arch/i386/pci/numa.c Tue Mar 4 19:30:05 2003 @@ -17,7 +17,7 @@ { unsigned long flags; - if (!value || (bus > 255) || (dev > 31) || (fn > 7) || (reg > 255)) + if (!value || (bus > MAX_MP_BUSSES) || (dev > 31) || (fn > 7) || (reg > 255)) return -EINVAL; spin_lock_irqsave(&pci_config_lock, flags); @@ -45,7 +45,7 @@ { unsigned long flags; - if ((bus > 255) || (dev > 31) || (fn > 7) || (reg > 255)) + if ((bus > MAX_MP_BUSSES) || (dev > 31) || (fn > 7) || (reg > 255)) return -EINVAL; spin_lock_irqsave(&pci_config_lock, flags); diff -Nru a/arch/i386/pci/visws.c b/arch/i386/pci/visws.c --- a/arch/i386/pci/visws.c Tue Mar 4 19:30:12 2003 +++ b/arch/i386/pci/visws.c Tue Mar 4 19:30:12 2003 @@ -52,7 +52,7 @@ pin--; - /* Nothing usefull at PIIX4 pin 1 */ + /* Nothing useful at PIIX4 pin 1 */ if (bus == pci_bus0 && slot == 4 && pin == 0) return -1; diff -Nru a/arch/ia64/ia32/ia32_signal.c b/arch/ia64/ia32/ia32_signal.c --- a/arch/ia64/ia32/ia32_signal.c Tue Mar 4 19:30:04 2003 +++ b/arch/ia64/ia32/ia32_signal.c Tue Mar 4 19:30:04 2003 @@ -338,7 +338,7 @@ /* * Updating fsr, fcr, fir, fdr. * Just a bit more complicated than save. - * - Need to make sure that we dont write any value other than the + * - Need to make sure that we don't write any value other than the * specific fpstate info * - Need to make sure that the untouched part of frs, fdr, fir, fcr * should remain same while writing. diff -Nru a/arch/ia64/kernel/irq.c b/arch/ia64/kernel/irq.c --- a/arch/ia64/kernel/irq.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/kernel/irq.c Tue Mar 4 19:30:13 2003 @@ -104,7 +104,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ #if CONFIG_X86 diff -Nru a/arch/ia64/kernel/minstate.h b/arch/ia64/kernel/minstate.h --- a/arch/ia64/kernel/minstate.h Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/kernel/minstate.h Tue Mar 4 19:30:13 2003 @@ -26,7 +26,7 @@ */ /* - * For ivt.s we want to access the stack virtually so we dont have to disable translation + * For ivt.s we want to access the stack virtually so we don't have to disable translation * on interrupts. */ #define MINSTATE_START_SAVE_MIN_VIRT \ @@ -52,7 +52,7 @@ /* * For mca_asm.S we want to access the stack physically since the state is saved before we - * go virtual and dont want to destroy the iip or ipsr. + * go virtual and don't want to destroy the iip or ipsr. */ #define MINSTATE_START_SAVE_MIN_PHYS \ (pKStk) movl sp=ia64_init_stack+IA64_STK_OFFSET-IA64_PT_REGS_SIZE; \ diff -Nru a/arch/ia64/kernel/perfmon.c b/arch/ia64/kernel/perfmon.c --- a/arch/ia64/kernel/perfmon.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/kernel/perfmon.c Tue Mar 4 19:30:13 2003 @@ -718,7 +718,7 @@ /* * counts the number of PMDS to save per entry. - * This code is generic enough to accomodate more than 64 PMDS when they become available + * This code is generic enough to accommodate more than 64 PMDS when they become available */ static unsigned long pfm_smpl_entry_size(unsigned long *which, unsigned long size) diff -Nru a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c --- a/arch/ia64/kernel/smp.c Tue Mar 4 19:30:14 2003 +++ b/arch/ia64/kernel/smp.c Tue Mar 4 19:30:14 2003 @@ -206,18 +206,18 @@ void smp_flush_tlb_all (void) { - smp_call_function((void (*)(void *))local_flush_tlb_all, 0, 1, 1); - local_flush_tlb_all(); + on_each_cpu((void (*)(void *))local_flush_tlb_all, 0, 1, 1); } void smp_flush_tlb_mm (struct mm_struct *mm) { - local_finish_flush_tlb_mm(mm); - /* this happens for the common case of a single-threaded fork(): */ if (likely(mm == current->active_mm && atomic_read(&mm->mm_users) == 1)) + { + local_finish_flush_tlb_mm(mm); return; + } /* * We could optimize this further by using mm->cpu_vm_mask to track which CPUs @@ -226,7 +226,7 @@ * anyhow, and once a CPU is interrupted, the cost of local_flush_tlb_all() is * rather trivial. */ - smp_call_function((void (*)(void *))local_finish_flush_tlb_mm, mm, 1, 1); + on_each_cpu((void (*)(void *))local_finish_flush_tlb_mm, mm, 1, 1); } /* diff -Nru a/arch/ia64/kernel/time.c b/arch/ia64/kernel/time.c --- a/arch/ia64/kernel/time.c Tue Mar 4 19:30:05 2003 +++ b/arch/ia64/kernel/time.c Tue Mar 4 19:30:05 2003 @@ -27,7 +27,7 @@ extern unsigned long wall_jiffies; extern unsigned long last_time_offset; -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; #ifdef CONFIG_IA64_DEBUG_IRQ diff -Nru a/arch/ia64/lib/checksum.c b/arch/ia64/lib/checksum.c --- a/arch/ia64/lib/checksum.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/lib/checksum.c Tue Mar 4 19:30:13 2003 @@ -50,7 +50,7 @@ ((unsigned long) ntohs(len) << 16) + ((unsigned long) proto << 8)); - /* Fold down to 32-bits so we don't loose in the typedef-less network stack. */ + /* Fold down to 32-bits so we don't lose in the typedef-less network stack. */ /* 64 to 33 */ result = (result & 0xffffffff) + (result >> 32); /* 33 to 32 */ diff -Nru a/arch/ia64/lib/do_csum.S b/arch/ia64/lib/do_csum.S --- a/arch/ia64/lib/do_csum.S Tue Mar 4 19:30:04 2003 +++ b/arch/ia64/lib/do_csum.S Tue Mar 4 19:30:04 2003 @@ -41,7 +41,7 @@ // into one 8 byte word. In this case we have only one entry in the pipeline. // // We use a (LOAD_LATENCY+2)-stage pipeline in the loop to account for -// possible load latency and also to accomodate for head and tail. +// possible load latency and also to accommodate for head and tail. // // The end of the function deals with folding the checksum from 64bits // down to 16bits taking care of the carry. diff -Nru a/arch/ia64/lib/swiotlb.c b/arch/ia64/lib/swiotlb.c --- a/arch/ia64/lib/swiotlb.c Tue Mar 4 19:30:11 2003 +++ b/arch/ia64/lib/swiotlb.c Tue Mar 4 19:30:11 2003 @@ -359,7 +359,7 @@ * was provided for in a previous swiotlb_map_single call. All other usages are * undefined. * - * After this call, reads by the cpu to the buffer are guarenteed to see whatever the + * After this call, reads by the cpu to the buffer are guaranteed to see whatever the * device wrote there. */ void diff -Nru a/arch/ia64/mm/discontig.c b/arch/ia64/mm/discontig.c --- a/arch/ia64/mm/discontig.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/mm/discontig.c Tue Mar 4 19:30:13 2003 @@ -241,7 +241,7 @@ * - build the nodedir for the node. This contains pointers to * the per-bank mem_map entries. * - fix the page struct "virtual" pointers. These are bank specific - * values that the paging system doesnt understand. + * values that the paging system doesn't understand. * - replicate the nodedir structure to other nodes */ diff -Nru a/arch/ia64/mm/hugetlbpage.c b/arch/ia64/mm/hugetlbpage.c --- a/arch/ia64/mm/hugetlbpage.c Tue Mar 4 19:30:09 2003 +++ b/arch/ia64/mm/hugetlbpage.c Tue Mar 4 19:30:09 2003 @@ -26,6 +26,8 @@ static LIST_HEAD(htlbpage_freelist); static spinlock_t htlbpage_lock = SPIN_LOCK_UNLOCKED; +void free_huge_page(struct page *page); + static struct page *alloc_hugetlb_page(void) { int i; @@ -42,6 +44,7 @@ htlbpagemem--; spin_unlock(&htlbpage_lock); set_page_count(page, 1); + page->lru.prev = (void *)free_huge_page; for (i = 0; i < (HPAGE_SIZE/PAGE_SIZE); ++i) clear_highpage(&page[i]); return page; diff -Nru a/arch/ia64/sn/fakeprom/fpmem.c b/arch/ia64/sn/fakeprom/fpmem.c --- a/arch/ia64/sn/fakeprom/fpmem.c Tue Mar 4 19:30:07 2003 +++ b/arch/ia64/sn/fakeprom/fpmem.c Tue Mar 4 19:30:07 2003 @@ -218,7 +218,7 @@ } /* - * Check for the node 0 hole. Since banks cant + * Check for the node 0 hole. Since banks can't * span the hole, we only need to check if the end of * the range is the end of the hole. */ @@ -226,7 +226,7 @@ numbytes -= NODE0_HOLE_SIZE; /* * UGLY hack - we must skip overr the kernel and - * PROM runtime services but we dont exactly where it is. + * PROM runtime services but we don't exactly where it is. * So lets just reserve: * node 0 * 0-1MB for PAL diff -Nru a/arch/ia64/sn/fakeprom/fw-emu.c b/arch/ia64/sn/fakeprom/fw-emu.c --- a/arch/ia64/sn/fakeprom/fw-emu.c Tue Mar 4 19:30:12 2003 +++ b/arch/ia64/sn/fakeprom/fw-emu.c Tue Mar 4 19:30:12 2003 @@ -757,7 +757,7 @@ sal_systab->checksum = -checksum; /* If the checksum is correct, the kernel tries to use the - * table. We dont build enough table & the kernel aborts. + * table. We don't build enough table & the kernel aborts. * Note that the PROM hasd thhhe same problem!! */ diff -Nru a/arch/ia64/sn/io/hcl.c b/arch/ia64/sn/io/hcl.c --- a/arch/ia64/sn/io/hcl.c Tue Mar 4 19:30:12 2003 +++ b/arch/ia64/sn/io/hcl.c Tue Mar 4 19:30:12 2003 @@ -467,7 +467,7 @@ /* * We need to clean up! */ - printk(KERN_WARNING "HCL: Unable to set the connect point to it's parent 0x%p\n", + printk(KERN_WARNING "HCL: Unable to set the connect point to its parent 0x%p\n", (void *)new_devfs_handle); } diff -Nru a/arch/ia64/sn/io/l1.c b/arch/ia64/sn/io/l1.c --- a/arch/ia64/sn/io/l1.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/sn/io/l1.c Tue Mar 4 19:30:13 2003 @@ -2602,7 +2602,7 @@ { sc_cq_t *q; /* receive queue */ int before_wrap, /* packet may be split into two different */ - after_wrap; /* pieces to acommodate queue wraparound */ + after_wrap; /* pieces to accommodate queue wraparound */ /* pull message off the receive queue */ q = subch->iqp; diff -Nru a/arch/ia64/sn/io/sn1/pcibr.c b/arch/ia64/sn/io/sn1/pcibr.c --- a/arch/ia64/sn/io/sn1/pcibr.c Tue Mar 4 19:30:11 2003 +++ b/arch/ia64/sn/io/sn1/pcibr.c Tue Mar 4 19:30:11 2003 @@ -2647,7 +2647,7 @@ /* * The Adaptec 1160 FC Controller WAR #767995: * The part incorrectly ignores the upper 32 bits of a 64 bit - * address when decoding references to it's registers so to + * address when decoding references to its registers so to * keep it from responding to a bus cycle that it shouldn't * we only use I/O space to get at it's registers. Don't * enable memory space accesses on that PCI device. @@ -5113,7 +5113,7 @@ /* Bridge Hardware Bug WAR #484930: * Bridge can't handle updating External ATEs - * while DMA is occuring that uses External ATEs, + * while DMA is occurring that uses External ATEs, * even if the particular ATEs involved are disjoint. */ @@ -6844,7 +6844,7 @@ * * This is the pcibr interrupt "wrapper" function that is called, * in interrupt context, to initiate the interrupt handler(s) registered - * (via pcibr_intr_alloc/connect) for the occuring interrupt. Non-threaded + * (via pcibr_intr_alloc/connect) for the occurring interrupt. Non-threaded * handlers will be called directly, and threaded handlers will have their * thread woken up. */ diff -Nru a/arch/ia64/sn/io/sn2/pcibr/pcibr_ate.c b/arch/ia64/sn/io/sn2/pcibr/pcibr_ate.c --- a/arch/ia64/sn/io/sn2/pcibr/pcibr_ate.c Tue Mar 4 19:30:04 2003 +++ b/arch/ia64/sn/io/sn2/pcibr/pcibr_ate.c Tue Mar 4 19:30:04 2003 @@ -362,7 +362,7 @@ /* Bridge Hardware Bug WAR #484930: * Bridge can't handle updating External ATEs - * while DMA is occuring that uses External ATEs, + * while DMA is occurring that uses External ATEs, * even if the particular ATEs involved are disjoint. */ diff -Nru a/arch/ia64/sn/io/sn2/pcibr/pcibr_dvr.c b/arch/ia64/sn/io/sn2/pcibr/pcibr_dvr.c --- a/arch/ia64/sn/io/sn2/pcibr/pcibr_dvr.c Tue Mar 4 19:30:14 2003 +++ b/arch/ia64/sn/io/sn2/pcibr/pcibr_dvr.c Tue Mar 4 19:30:14 2003 @@ -849,7 +849,7 @@ * will set the c_slot (which is suppose to represent the external * slot (i.e the slot number silk screened on the back of the I/O * brick)). So for PIC we need to adjust this "internal slot" num - * passed into us, into it's external representation. See comment + * passed into us, into its external representation. See comment * for the PCIBR_DEVICE_TO_SLOT macro for more information. */ NEW(pcibr_info); @@ -1527,7 +1527,7 @@ /* enable parity checking on PICs internal RAM */ pic_ctrl_reg |= PIC_CTRL_PAR_EN_RESP; pic_ctrl_reg |= PIC_CTRL_PAR_EN_ATE; - /* PIC BRINGUP WAR (PV# 862253): dont enable write request + /* PIC BRINGUP WAR (PV# 862253): don't enable write request * parity checking. */ if (!PCIBR_WAR_ENABLED(PV862253, pcibr_soft)) { diff -Nru a/arch/ia64/sn/io/sn2/pcibr/pcibr_error.c b/arch/ia64/sn/io/sn2/pcibr/pcibr_error.c --- a/arch/ia64/sn/io/sn2/pcibr/pcibr_error.c Tue Mar 4 19:30:04 2003 +++ b/arch/ia64/sn/io/sn2/pcibr/pcibr_error.c Tue Mar 4 19:30:04 2003 @@ -1806,7 +1806,7 @@ * * CAUTION: Resetting bit BRIDGE_IRR_PCI_GRP_CLR, acknowledges * a group of interrupts. If while handling this error, - * some other error has occured, that would be + * some other error has occurred, that would be * implicitly cleared by this write. * Need a way to ensure we don't inadvertently clear some * other errors. diff -Nru a/arch/ia64/sn/io/sn2/pcibr/pcibr_intr.c b/arch/ia64/sn/io/sn2/pcibr/pcibr_intr.c --- a/arch/ia64/sn/io/sn2/pcibr/pcibr_intr.c Tue Mar 4 19:30:12 2003 +++ b/arch/ia64/sn/io/sn2/pcibr/pcibr_intr.c Tue Mar 4 19:30:12 2003 @@ -842,7 +842,7 @@ * * This is the pcibr interrupt "wrapper" function that is called, * in interrupt context, to initiate the interrupt handler(s) registered - * (via pcibr_intr_alloc/connect) for the occuring interrupt. Non-threaded + * (via pcibr_intr_alloc/connect) for the occurring interrupt. Non-threaded * handlers will be called directly, and threaded handlers will have their * thread woken up. */ diff -Nru a/arch/ia64/sn/io/sn2/pcibr/pcibr_slot.c b/arch/ia64/sn/io/sn2/pcibr/pcibr_slot.c --- a/arch/ia64/sn/io/sn2/pcibr/pcibr_slot.c Tue Mar 4 19:30:08 2003 +++ b/arch/ia64/sn/io/sn2/pcibr/pcibr_slot.c Tue Mar 4 19:30:08 2003 @@ -803,7 +803,7 @@ * 'min_gnt' and attempt to calculate a latency time. * * NOTE: For now if the device is on the 'real time' arbitration - * ring we dont set the latency timer. + * ring we don't set the latency timer. * * WAR: SGI's IOC3 and RAD devices target abort if you write a * single byte into their config space. So don't set the Latency @@ -852,7 +852,7 @@ } /* Get the PCI-X capability if running in PCI-X mode. If the func - * doesnt have a pcix capability, allocate a PCIIO_VENDOR_ID_NONE + * doesn't have a pcix capability, allocate a PCIIO_VENDOR_ID_NONE * pcibr_info struct so the device driver for that function is not * called. */ @@ -1449,7 +1449,7 @@ /* * The Adaptec 1160 FC Controller WAR #767995: * The part incorrectly ignores the upper 32 bits of a 64 bit - * address when decoding references to it's registers so to + * address when decoding references to its registers so to * keep it from responding to a bus cycle that it shouldn't * we only use I/O space to get at it's registers. Don't * enable memory space accesses on that PCI device. diff -Nru a/arch/ia64/sn/kernel/llsc4.c b/arch/ia64/sn/kernel/llsc4.c --- a/arch/ia64/sn/kernel/llsc4.c Tue Mar 4 19:30:12 2003 +++ b/arch/ia64/sn/kernel/llsc4.c Tue Mar 4 19:30:12 2003 @@ -301,7 +301,7 @@ */ linei = randn(linecount, &seed); sharei = randn(2, &seed); - slinei = (linei + (linecount/2))%linecount; /* I dont like this - fix later */ + slinei = (linei + (linecount/2))%linecount; /* I don't like this - fix later */ linep = (dataline_t *)blocks[linei]; slinep = (dataline_t *)blocks[slinei]; diff -Nru a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c --- a/arch/ia64/sn/kernel/setup.c Tue Mar 4 19:30:05 2003 +++ b/arch/ia64/sn/kernel/setup.c Tue Mar 4 19:30:05 2003 @@ -153,7 +153,7 @@ /** * early_sn_setup - early setup routine for SN platforms * - * Sets up an intial console to aid debugging. Intended primarily + * Sets up an initial console to aid debugging. Intended primarily * for bringup, it's only called if %BRINGUP and %CONFIG_IA64_EARLY_PRINTK * are turned on. See start_kernel() in init/main.c. */ @@ -172,7 +172,7 @@ /* * Parse enough of the SAL tables to locate the SAL entry point. Since, console - * IO on SN2 is done via SAL calls, early_printk wont work without this. + * IO on SN2 is done via SAL calls, early_printk won't work without this. * * This code duplicates some of the ACPI table parsing that is in efi.c & sal.c. * Any changes to those file may have to be made hereas well. diff -Nru a/arch/ia64/sn/kernel/sn1/sn1_smp.c b/arch/ia64/sn/kernel/sn1/sn1_smp.c --- a/arch/ia64/sn/kernel/sn1/sn1_smp.c Tue Mar 4 19:30:07 2003 +++ b/arch/ia64/sn/kernel/sn1/sn1_smp.c Tue Mar 4 19:30:07 2003 @@ -100,7 +100,7 @@ /* * The following table/struct is for remembering PTC coherency domains. It - * is also used to translate sapicid into cpuids. We dont want to start + * is also used to translate sapicid into cpuids. We don't want to start * cpus unless we know their cache domain. */ #ifdef PTC_NOTYET diff -Nru a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c --- a/arch/ia64/sn/kernel/sn2/sn2_smp.c Tue Mar 4 19:30:13 2003 +++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c Tue Mar 4 19:30:13 2003 @@ -395,7 +395,7 @@ mycnode = local_nodeid; /* - * For now, we dont want to spin uninterruptibly waiting + * For now, we don't want to spin uninterruptibly waiting * for the lock. Makes hangs hard to debug. */ local_irq_save(flags); @@ -506,7 +506,7 @@ pio_phys_write_mmr(p, val); #ifndef CONFIG_SHUB_1_0_SPECIFIC - /* doesnt work on shub 1.0 */ + /* doesn't work on shub 1.0 */ wait_piowc(); #endif } diff -Nru a/arch/m68k/ifpsp060/src/fpsp.S b/arch/m68k/ifpsp060/src/fpsp.S --- a/arch/m68k/ifpsp060/src/fpsp.S Tue Mar 4 19:30:14 2003 +++ b/arch/m68k/ifpsp060/src/fpsp.S Tue Mar 4 19:30:14 2003 @@ -2201,7 +2201,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) @@ -2241,7 +2241,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) @@ -2281,7 +2281,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) diff -Nru a/arch/m68k/ifpsp060/src/isp.S b/arch/m68k/ifpsp060/src/isp.S --- a/arch/m68k/ifpsp060/src/isp.S Tue Mar 4 19:30:05 2003 +++ b/arch/m68k/ifpsp060/src/isp.S Tue Mar 4 19:30:05 2003 @@ -843,7 +843,7 @@ bra.l _real_access # if the addressing mode was (an)+ or -(an), the address register must -# be restored to it's pre-exception value before entering _real_access. +# be restored to its pre-exception value before entering _real_access. isp_restore: cmpi.b SPCOND_FLG(%a6),&restore_flg # do we need a restore? bne.b isp_restore_done # no diff -Nru a/arch/m68k/ifpsp060/src/pfpsp.S b/arch/m68k/ifpsp060/src/pfpsp.S --- a/arch/m68k/ifpsp060/src/pfpsp.S Tue Mar 4 19:30:04 2003 +++ b/arch/m68k/ifpsp060/src/pfpsp.S Tue Mar 4 19:30:04 2003 @@ -2200,7 +2200,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) @@ -2240,7 +2240,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) @@ -2280,7 +2280,7 @@ mov.l LOCAL_SIZE+2+EXC_PC(%sp),LOCAL_SIZE+2+EXC_PC-0xc(%sp) mov.l LOCAL_SIZE+EXC_EA(%sp),LOCAL_SIZE+EXC_EA-0xc(%sp) -# now, we copy the default result to it's proper location +# now, we copy the default result to its proper location mov.l LOCAL_SIZE+FP_DST_EX(%sp),LOCAL_SIZE+0x4(%sp) mov.l LOCAL_SIZE+FP_DST_HI(%sp),LOCAL_SIZE+0x8(%sp) mov.l LOCAL_SIZE+FP_DST_LO(%sp),LOCAL_SIZE+0xc(%sp) diff -Nru a/arch/m68k/kernel/head.S b/arch/m68k/kernel/head.S --- a/arch/m68k/kernel/head.S Tue Mar 4 19:30:14 2003 +++ b/arch/m68k/kernel/head.S Tue Mar 4 19:30:14 2003 @@ -3127,7 +3127,7 @@ moveb %d0,M162_SCC_CTRL_A jra 3f 5: - /* 166/167/177; its a CD2401 */ + /* 166/167/177; it's a CD2401 */ moveb #0,M167_CYCAR moveb M167_CYIER,%d2 moveb #0x02,M167_CYIER diff -Nru a/arch/m68k/kernel/time.c b/arch/m68k/kernel/time.c --- a/arch/m68k/kernel/time.c Tue Mar 4 19:30:05 2003 +++ b/arch/m68k/kernel/time.c Tue Mar 4 19:30:05 2003 @@ -26,7 +26,7 @@ #include #include -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static inline int set_rtc_mmss(unsigned long nowtime) { diff -Nru a/arch/m68k/math-emu/fp_util.S b/arch/m68k/math-emu/fp_util.S --- a/arch/m68k/math-emu/fp_util.S Tue Mar 4 19:30:14 2003 +++ b/arch/m68k/math-emu/fp_util.S Tue Mar 4 19:30:14 2003 @@ -49,7 +49,7 @@ * is currently at that time unused, be careful if you want change * something here. %d0 and %d1 is always usable, sometimes %d2 (or * only the lower half) most function have to return the %a0 - * unmodified, so that the caller can immediatly reuse it. + * unmodified, so that the caller can immediately reuse it. */ .globl fp_ill, fp_end diff -Nru a/arch/m68k/q40/README b/arch/m68k/q40/README --- a/arch/m68k/q40/README Tue Mar 4 19:30:03 2003 +++ b/arch/m68k/q40/README Tue Mar 4 19:30:03 2003 @@ -16,7 +16,7 @@ particular device drivers. The floppy imposes a very high interrupt load on the CPU, approx 30K/s. -When something blocks interrupts (HD) it will loose some of them, so far +When something blocks interrupts (HD) it will lose some of them, so far this is not known to have caused any data loss. On highly loaded systems it can make the floppy very slow or practically stop. Other Q40 OS' simply poll the floppy for this reason - something that can't be done in Linux. diff -Nru a/arch/m68k/sun3/config.c b/arch/m68k/sun3/config.c --- a/arch/m68k/sun3/config.c Tue Mar 4 19:30:11 2003 +++ b/arch/m68k/sun3/config.c Tue Mar 4 19:30:11 2003 @@ -119,7 +119,7 @@ { unsigned long start_page; - /* align start/end to page boundries */ + /* align start/end to page boundaries */ memory_start = ((memory_start + (PAGE_SIZE-1)) & PAGE_MASK); memory_end = memory_end & PAGE_MASK; diff -Nru a/arch/m68knommu/kernel/ints.c b/arch/m68knommu/kernel/ints.c --- a/arch/m68knommu/kernel/ints.c Tue Mar 4 19:30:05 2003 +++ b/arch/m68knommu/kernel/ints.c Tue Mar 4 19:30:05 2003 @@ -214,7 +214,7 @@ /* * Do we need these probe functions on the m68k? * - * ... may be usefull with ISA devices + * ... may be useful with ISA devices */ unsigned long probe_irq_on (void) { diff -Nru a/arch/m68knommu/kernel/syscalltable.S b/arch/m68knommu/kernel/syscalltable.S --- a/arch/m68knommu/kernel/syscalltable.S Tue Mar 4 19:30:03 2003 +++ b/arch/m68knommu/kernel/syscalltable.S Tue Mar 4 19:30:03 2003 @@ -14,6 +14,7 @@ #include #include #include +#include .text ALIGN diff -Nru a/arch/m68knommu/kernel/time.c b/arch/m68knommu/kernel/time.c --- a/arch/m68knommu/kernel/time.c Tue Mar 4 19:30:11 2003 +++ b/arch/m68knommu/kernel/time.c Tue Mar 4 19:30:11 2003 @@ -26,7 +26,7 @@ #define TICK_SIZE (tick_nsec / 1000) -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static inline int set_rtc_mmss(unsigned long nowtime) { diff -Nru a/arch/m68knommu/platform/5307/entry.S b/arch/m68knommu/platform/5307/entry.S --- a/arch/m68knommu/platform/5307/entry.S Tue Mar 4 19:30:14 2003 +++ b/arch/m68knommu/platform/5307/entry.S Tue Mar 4 19:30:14 2003 @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include diff -Nru a/arch/m68knommu/platform/5307/vectors.c b/arch/m68knommu/platform/5307/vectors.c --- a/arch/m68knommu/platform/5307/vectors.c Tue Mar 4 19:30:13 2003 +++ b/arch/m68knommu/platform/5307/vectors.c Tue Mar 4 19:30:13 2003 @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include diff -Nru a/arch/m68knommu/platform/68360/ints.c b/arch/m68knommu/platform/68360/ints.c --- a/arch/m68knommu/platform/68360/ints.c Tue Mar 4 19:30:03 2003 +++ b/arch/m68knommu/platform/68360/ints.c Tue Mar 4 19:30:03 2003 @@ -291,7 +291,7 @@ /* unsigned long pend = *(volatile unsigned long *)pquicc->intr_cipr; */ - /* Bugger all that wierdness. For the moment, I seem to know where I came from; + /* Bugger all that weirdness. For the moment, I seem to know where I came from; * vec is passed from a specific ISR, so I'll use it. */ if (int_irq_list[irq] && int_irq_list[irq]->handler) { diff -Nru a/arch/mips/au1000/common/serial.c b/arch/mips/au1000/common/serial.c --- a/arch/mips/au1000/common/serial.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips/au1000/common/serial.c Tue Mar 4 19:30:05 2003 @@ -2703,7 +2703,7 @@ * port exists and is in use an error is returned. If the port * is not currently in the table it is added. * - * The port is then probed and if neccessary the IRQ is autodetected + * The port is then probed and if necessary the IRQ is autodetected * If this fails an error is returned. * * On success the port is ready to use and the line number is returned. diff -Nru a/arch/mips/baget/wbflush.c b/arch/mips/baget/wbflush.c --- a/arch/mips/baget/wbflush.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips/baget/wbflush.c Tue Mar 4 19:30:11 2003 @@ -17,7 +17,7 @@ } /* - * Baget/MIPS doesnt need to write back the WB. + * Baget/MIPS doesn't need to write back the WB. */ static void wbflush_baget(void) { diff -Nru a/arch/mips/ddb5xxx/common/pci.c b/arch/mips/ddb5xxx/common/pci.c --- a/arch/mips/ddb5xxx/common/pci.c Tue Mar 4 19:30:14 2003 +++ b/arch/mips/ddb5xxx/common/pci.c Tue Mar 4 19:30:14 2003 @@ -20,7 +20,7 @@ * Strategies: * * . We rely on pci_auto.c file to assign PCI resources (MEM and IO) - * TODO: this shold be optional for some machines where they do have + * TODO: this should be optional for some machines where they do have * a real "pcibios" that does resource assignment. * * . We then use pci_scan_bus() to "discover" all the resources for diff -Nru a/arch/mips/dec/boot/decstation.c b/arch/mips/dec/boot/decstation.c --- a/arch/mips/dec/boot/decstation.c Tue Mar 4 19:30:09 2003 +++ b/arch/mips/dec/boot/decstation.c Tue Mar 4 19:30:09 2003 @@ -70,7 +70,7 @@ #ifdef RELOC /* - * Now copy kernel image to it's destination. + * Now copy kernel image to its destination. */ len = ((unsigned long) (&_end) - k_start); memcpy((void *)k_start, &_ftext, len); diff -Nru a/arch/mips/kernel/irq.c b/arch/mips/kernel/irq.c --- a/arch/mips/kernel/irq.c Tue Mar 4 19:30:04 2003 +++ b/arch/mips/kernel/irq.c Tue Mar 4 19:30:04 2003 @@ -44,7 +44,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ printk("unexpected interrupt %d\n", irq); diff -Nru a/arch/mips/kernel/pci.c b/arch/mips/kernel/pci.c --- a/arch/mips/kernel/pci.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips/kernel/pci.c Tue Mar 4 19:30:11 2003 @@ -19,7 +19,7 @@ * Strategies: * * . We rely on pci_auto.c file to assign PCI resources (MEM and IO) - * TODO: this shold be optional for some machines where they do have + * TODO: this should be optional for some machines where they do have * a real "pcibios" that does resource assignment. * * . We then use pci_scan_bus() to "discover" all the resources for diff -Nru a/arch/mips/kernel/process.c b/arch/mips/kernel/process.c --- a/arch/mips/kernel/process.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips/kernel/process.c Tue Mar 4 19:30:08 2003 @@ -112,7 +112,7 @@ p->thread.reg31 = (unsigned long) ret_from_fork; /* - * New tasks loose permission to use the fpu. This accelerates context + * New tasks lose permission to use the fpu. This accelerates context * switching for most programs since they don't use the fpu. */ p->thread.cp0_status = read_32bit_cp0_register(CP0_STATUS) & diff -Nru a/arch/mips/kernel/r2300_misc.S b/arch/mips/kernel/r2300_misc.S --- a/arch/mips/kernel/r2300_misc.S Tue Mar 4 19:30:12 2003 +++ b/arch/mips/kernel/r2300_misc.S Tue Mar 4 19:30:12 2003 @@ -76,7 +76,7 @@ /* Check is PTE is present, if not then jump to LABEL. * PTR points to the page table where this PTE is located, * when the macro is done executing PTE will be restored - * with it's original value. + * with its original value. */ #define PTE_PRESENT(pte, ptr, label) \ andi pte, pte, (_PAGE_PRESENT | _PAGE_READ); \ diff -Nru a/arch/mips/kernel/r2300_switch.S b/arch/mips/kernel/r2300_switch.S --- a/arch/mips/kernel/r2300_switch.S Tue Mar 4 19:30:13 2003 +++ b/arch/mips/kernel/r2300_switch.S Tue Mar 4 19:30:13 2003 @@ -80,7 +80,7 @@ beqz a0, 2f # Save floating point state nor t3, zero, t3 .set reorder - lw t1, ST_OFF(a0) # last thread looses fpu + lw t1, ST_OFF(a0) # last thread loses fpu and t1, t3 sw t1, ST_OFF(a0) FPU_SAVE_SINGLE(a0, t1) # clobbers t1 @@ -108,7 +108,7 @@ /* * Load the FPU with signalling NANS. This bit pattern we're using has - * the property that no matter wether considered as single or as double + * the property that no matter whether considered as single or as double * precission represents signaling NANS. * * We initialize fcr31 to rounding to nearest, no exceptions. diff -Nru a/arch/mips/kernel/r4k_misc.S b/arch/mips/kernel/r4k_misc.S --- a/arch/mips/kernel/r4k_misc.S Tue Mar 4 19:30:05 2003 +++ b/arch/mips/kernel/r4k_misc.S Tue Mar 4 19:30:05 2003 @@ -93,7 +93,7 @@ /* Check is PTE is present, if not then jump to LABEL. * PTR points to the page table where this PTE is located, * when the macro is done executing PTE will be restored - * with it's original value. + * with its original value. */ #define PTE_PRESENT(pte, ptr, label) \ andi pte, pte, (_PAGE_PRESENT | _PAGE_READ); \ diff -Nru a/arch/mips/kernel/r4k_switch.S b/arch/mips/kernel/r4k_switch.S --- a/arch/mips/kernel/r4k_switch.S Tue Mar 4 19:30:13 2003 +++ b/arch/mips/kernel/r4k_switch.S Tue Mar 4 19:30:13 2003 @@ -85,7 +85,7 @@ beqz a0, 2f # Save floating point state nor t3, zero, t3 - lw t1, ST_OFF(a0) # last thread looses fpu + lw t1, ST_OFF(a0) # last thread loses fpu and t1, t3 sw t1, ST_OFF(a0) diff -Nru a/arch/mips/kernel/setup.c b/arch/mips/kernel/setup.c --- a/arch/mips/kernel/setup.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips/kernel/setup.c Tue Mar 4 19:30:05 2003 @@ -775,7 +775,7 @@ request_resource(&iomem_resource, res); /* - * We dont't know which RAM region contains kernel data, + * We don't know which RAM region contains kernel data, * so we try it repeatedly and let the resource manager * test it. */ diff -Nru a/arch/mips/kernel/time.c b/arch/mips/kernel/time.c --- a/arch/mips/kernel/time.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips/kernel/time.c Tue Mar 4 19:30:08 2003 @@ -32,7 +32,7 @@ #define USECS_PER_JIFFY (1000000/HZ) #define USECS_PER_JIFFY_FRAC ((1000000ULL << 32) / HZ & 0xffffffff) -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; /* * forward reference diff -Nru a/arch/mips/kernel/traps.c b/arch/mips/kernel/traps.c --- a/arch/mips/kernel/traps.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips/kernel/traps.c Tue Mar 4 19:30:08 2003 @@ -793,7 +793,7 @@ /* Some firmware leaves the BEV flag set, clear it. */ clear_cp0_status(ST0_BEV); - /* Copy the generic exception handler code to it's final destination. */ + /* Copy the generic exception handler code to its final destination. */ memcpy((void *)(KSEG0 + 0x80), &except_vec1_generic, 0x80); memcpy((void *)(KSEG0 + 0x100), &except_vec2_generic, 0x80); memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic, 0x80); @@ -805,7 +805,7 @@ set_except_vector(i, handle_reserved); /* - * Copy the EJTAG debug exception vector handler code to it's final + * Copy the EJTAG debug exception vector handler code to its final * destination. */ memcpy((void *)(KSEG0 + 0x300), &except_vec_ejtag_debug, 0x80); diff -Nru a/arch/mips/math-emu/dp_add.c b/arch/mips/math-emu/dp_add.c --- a/arch/mips/math-emu/dp_add.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips/math-emu/dp_add.c Tue Mar 4 19:30:05 2003 @@ -73,7 +73,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -92,7 +92,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/math-emu/dp_div.c b/arch/mips/math-emu/dp_div.c --- a/arch/mips/math-emu/dp_div.c Tue Mar 4 19:30:04 2003 +++ b/arch/mips/math-emu/dp_div.c Tue Mar 4 19:30:04 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -89,7 +89,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return ieee754dp_inf(xs ^ ys); - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/math-emu/dp_mul.c b/arch/mips/math-emu/dp_mul.c --- a/arch/mips/math-emu/dp_mul.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips/math-emu/dp_mul.c Tue Mar 4 19:30:08 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling */ + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO): case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF): diff -Nru a/arch/mips/math-emu/dp_sub.c b/arch/mips/math-emu/dp_sub.c --- a/arch/mips/math-emu/dp_sub.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips/math-emu/dp_sub.c Tue Mar 4 19:30:11 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/math-emu/ieee754.c b/arch/mips/math-emu/ieee754.c --- a/arch/mips/math-emu/ieee754.c Tue Mar 4 19:30:04 2003 +++ b/arch/mips/math-emu/ieee754.c Tue Mar 4 19:30:04 2003 @@ -3,7 +3,7 @@ * * BUGS * not much dp done - * doesnt generate IEEE754_INEXACT + * doesn't generate IEEE754_INEXACT * */ /* diff -Nru a/arch/mips/math-emu/ieee754dp.c b/arch/mips/math-emu/ieee754dp.c --- a/arch/mips/math-emu/ieee754dp.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips/math-emu/ieee754dp.c Tue Mar 4 19:30:11 2003 @@ -99,14 +99,14 @@ } -/* generate a normal/denormal number with over,under handeling +/* generate a normal/denormal number with over,under handling * sn is sign * xe is an unbiased exponent * xm is 3bit extended precision value. */ ieee754dp ieee754dp_format(int sn, int xe, unsigned long long xm) { - assert(xm); /* we dont gen exact zeros (probably should) */ + assert(xm); /* we don't gen exact zeros (probably should) */ assert((xm >> (DP_MBITS + 1 + 3)) == 0); /* no execess */ assert(xm & (DP_HIDDEN_BIT << 3)); diff -Nru a/arch/mips/math-emu/ieee754sp.c b/arch/mips/math-emu/ieee754sp.c --- a/arch/mips/math-emu/ieee754sp.c Tue Mar 4 19:30:06 2003 +++ b/arch/mips/math-emu/ieee754sp.c Tue Mar 4 19:30:06 2003 @@ -100,14 +100,14 @@ } -/* generate a normal/denormal number with over,under handeling +/* generate a normal/denormal number with over,under handling * sn is sign * xe is an unbiased exponent * xm is 3bit extended precision value. */ ieee754sp ieee754sp_format(int sn, int xe, unsigned xm) { - assert(xm); /* we dont gen exact zeros (probably should) */ + assert(xm); /* we don't gen exact zeros (probably should) */ assert((xm >> (SP_MBITS + 1 + 3)) == 0); /* no execess */ assert(xm & (SP_HIDDEN_BIT << 3)); diff -Nru a/arch/mips/math-emu/sp_add.c b/arch/mips/math-emu/sp_add.c --- a/arch/mips/math-emu/sp_add.c Tue Mar 4 19:30:12 2003 +++ b/arch/mips/math-emu/sp_add.c Tue Mar 4 19:30:12 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/math-emu/sp_div.c b/arch/mips/math-emu/sp_div.c --- a/arch/mips/math-emu/sp_div.c Tue Mar 4 19:30:12 2003 +++ b/arch/mips/math-emu/sp_div.c Tue Mar 4 19:30:12 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -89,7 +89,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return ieee754sp_inf(xs ^ ys); - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/math-emu/sp_fdp.c b/arch/mips/math-emu/sp_fdp.c --- a/arch/mips/math-emu/sp_fdp.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips/math-emu/sp_fdp.c Tue Mar 4 19:30:08 2003 @@ -49,7 +49,7 @@ case IEEE754_CLASS_ZERO: return ieee754sp_zero(xs); case IEEE754_CLASS_DNORM: - /* cant possibly be sp representable */ + /* can't possibly be sp representable */ SETCX(IEEE754_UNDERFLOW); return ieee754sp_xcpt(ieee754sp_zero(xs), "fdp", x); case IEEE754_CLASS_NORM: diff -Nru a/arch/mips/math-emu/sp_mul.c b/arch/mips/math-emu/sp_mul.c --- a/arch/mips/math-emu/sp_mul.c Tue Mar 4 19:30:10 2003 +++ b/arch/mips/math-emu/sp_mul.c Tue Mar 4 19:30:10 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling */ + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO): case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF): diff -Nru a/arch/mips/math-emu/sp_sub.c b/arch/mips/math-emu/sp_sub.c --- a/arch/mips/math-emu/sp_sub.c Tue Mar 4 19:30:07 2003 +++ b/arch/mips/math-emu/sp_sub.c Tue Mar 4 19:30:07 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips/mips-boards/generic/pci.c b/arch/mips/mips-boards/generic/pci.c --- a/arch/mips/mips-boards/generic/pci.c Tue Mar 4 19:30:07 2003 +++ b/arch/mips/mips-boards/generic/pci.c Tue Mar 4 19:30:07 2003 @@ -81,7 +81,7 @@ if (intr & (GT_INTRCAUSE_MASABORT0_BIT | GT_INTRCAUSE_TARABORT0_BIT)) { - /* Error occured */ + /* Error occurred */ /* Clear bits */ GT_WRITE( GT_INTRCAUSE_OFS, ~(GT_INTRCAUSE_MASABORT0_BIT | diff -Nru a/arch/mips64/kernel/process.c b/arch/mips64/kernel/process.c --- a/arch/mips64/kernel/process.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips64/kernel/process.c Tue Mar 4 19:30:05 2003 @@ -105,7 +105,7 @@ p->thread.reg31 = (unsigned long) ret_from_fork; /* - * New tasks loose permission to use the fpu. This accelerates context + * New tasks lose permission to use the fpu. This accelerates context * switching for most programs since they don't use the fpu. */ p->thread.cp0_status = read_32bit_cp0_register(CP0_STATUS) & diff -Nru a/arch/mips64/kernel/r4k_switch.S b/arch/mips64/kernel/r4k_switch.S --- a/arch/mips64/kernel/r4k_switch.S Tue Mar 4 19:30:04 2003 +++ b/arch/mips64/kernel/r4k_switch.S Tue Mar 4 19:30:04 2003 @@ -79,7 +79,7 @@ beqz a0, 2f # Save floating point state nor t3, zero, t3 - ld t1, ST_OFF(a0) # last thread looses fpu + ld t1, ST_OFF(a0) # last thread loses fpu and t1, t3 sd t1, ST_OFF(a0) sll t2, t1, 5 diff -Nru a/arch/mips64/kernel/smp.c b/arch/mips64/kernel/smp.c --- a/arch/mips64/kernel/smp.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips64/kernel/smp.c Tue Mar 4 19:30:11 2003 @@ -195,8 +195,7 @@ void flush_tlb_all(void) { - smp_call_function(flush_tlb_all_ipi, 0, 1, 1); - _flush_tlb_all(); + on_each_cpu(flush_tlb_all_ipi, 0, 1, 1); } static void flush_tlb_mm_ipi(void *mm) @@ -219,6 +218,8 @@ void flush_tlb_mm(struct mm_struct *mm) { + preempt_disable(); + if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) { smp_call_function(flush_tlb_mm_ipi, (void *)mm, 1, 1); } else { @@ -228,6 +229,8 @@ CPU_CONTEXT(i, mm) = 0; } _flush_tlb_mm(mm); + + preempt_enable(); } struct flush_tlb_data { @@ -246,6 +249,8 @@ void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end) { + preempt_disable(); + if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) { struct flush_tlb_data fd; @@ -260,6 +265,8 @@ CPU_CONTEXT(i, mm) = 0; } _flush_tlb_range(mm, start, end); + + preempt_enable(); } static void flush_tlb_page_ipi(void *info) @@ -271,6 +278,8 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long page) { + preempt_disable(); + if ((atomic_read(&vma->vm_mm->mm_users) != 1) || (current->mm != vma->vm_mm)) { struct flush_tlb_data fd; @@ -284,5 +293,7 @@ CPU_CONTEXT(i, vma->vm_mm) = 0; } _flush_tlb_page(vma, page); + + preempt_enable(); } diff -Nru a/arch/mips64/kernel/traps.c b/arch/mips64/kernel/traps.c --- a/arch/mips64/kernel/traps.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips64/kernel/traps.c Tue Mar 4 19:30:11 2003 @@ -497,7 +497,7 @@ /* Some firmware leaves the BEV flag set, clear it. */ set_cp0_status(ST0_BEV, 0); - /* Copy the generic exception handler code to it's final destination. */ + /* Copy the generic exception handler code to its final destination. */ memcpy((void *)(KSEG0 + 0x100), &except_vec2_generic, 0x80); memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic, 0x80); diff -Nru a/arch/mips64/math-emu/dp_add.c b/arch/mips64/math-emu/dp_add.c --- a/arch/mips64/math-emu/dp_add.c Tue Mar 4 19:30:14 2003 +++ b/arch/mips64/math-emu/dp_add.c Tue Mar 4 19:30:14 2003 @@ -73,7 +73,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -92,7 +92,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/math-emu/dp_div.c b/arch/mips64/math-emu/dp_div.c --- a/arch/mips64/math-emu/dp_div.c Tue Mar 4 19:30:03 2003 +++ b/arch/mips64/math-emu/dp_div.c Tue Mar 4 19:30:03 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -89,7 +89,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return ieee754dp_inf(xs ^ ys); - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/math-emu/dp_mul.c b/arch/mips64/math-emu/dp_mul.c --- a/arch/mips64/math-emu/dp_mul.c Tue Mar 4 19:30:14 2003 +++ b/arch/mips64/math-emu/dp_mul.c Tue Mar 4 19:30:14 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling */ + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO): case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF): diff -Nru a/arch/mips64/math-emu/dp_sub.c b/arch/mips64/math-emu/dp_sub.c --- a/arch/mips64/math-emu/dp_sub.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips64/math-emu/dp_sub.c Tue Mar 4 19:30:08 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/math-emu/ieee754dp.c b/arch/mips64/math-emu/ieee754dp.c --- a/arch/mips64/math-emu/ieee754dp.c Tue Mar 4 19:30:13 2003 +++ b/arch/mips64/math-emu/ieee754dp.c Tue Mar 4 19:30:13 2003 @@ -99,14 +99,14 @@ } -/* generate a normal/denormal number with over,under handeling +/* generate a normal/denormal number with over,under handling * sn is sign * xe is an unbiased exponent * xm is 3bit extended precision value. */ ieee754dp ieee754dp_format(int sn, int xe, unsigned long long xm) { - assert(xm); /* we dont gen exact zeros (probably should) */ + assert(xm); /* we don't gen exact zeros (probably should) */ assert((xm >> (DP_MBITS + 1 + 3)) == 0); /* no execess */ assert(xm & (DP_HIDDEN_BIT << 3)); diff -Nru a/arch/mips64/math-emu/ieee754sp.c b/arch/mips64/math-emu/ieee754sp.c --- a/arch/mips64/math-emu/ieee754sp.c Tue Mar 4 19:30:10 2003 +++ b/arch/mips64/math-emu/ieee754sp.c Tue Mar 4 19:30:10 2003 @@ -100,14 +100,14 @@ } -/* generate a normal/denormal number with over,under handeling +/* generate a normal/denormal number with over,under handling * sn is sign * xe is an unbiased exponent * xm is 3bit extended precision value. */ ieee754sp ieee754sp_format(int sn, int xe, unsigned xm) { - assert(xm); /* we dont gen exact zeros (probably should) */ + assert(xm); /* we don't gen exact zeros (probably should) */ assert((xm >> (SP_MBITS + 1 + 3)) == 0); /* no execess */ assert(xm & (SP_HIDDEN_BIT << 3)); diff -Nru a/arch/mips64/math-emu/sp_add.c b/arch/mips64/math-emu/sp_add.c --- a/arch/mips64/math-emu/sp_add.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips64/math-emu/sp_add.c Tue Mar 4 19:30:05 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/math-emu/sp_div.c b/arch/mips64/math-emu/sp_div.c --- a/arch/mips64/math-emu/sp_div.c Tue Mar 4 19:30:14 2003 +++ b/arch/mips64/math-emu/sp_div.c Tue Mar 4 19:30:14 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -89,7 +89,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return ieee754sp_inf(xs ^ ys); - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/math-emu/sp_fdp.c b/arch/mips64/math-emu/sp_fdp.c --- a/arch/mips64/math-emu/sp_fdp.c Tue Mar 4 19:30:13 2003 +++ b/arch/mips64/math-emu/sp_fdp.c Tue Mar 4 19:30:13 2003 @@ -49,7 +49,7 @@ case IEEE754_CLASS_ZERO: return ieee754sp_zero(xs); case IEEE754_CLASS_DNORM: - /* cant possibly be sp representable */ + /* can't possibly be sp representable */ SETCX(IEEE754_UNDERFLOW); return ieee754sp_xcpt(ieee754sp_zero(xs), "fdp", x); case IEEE754_CLASS_NORM: diff -Nru a/arch/mips64/math-emu/sp_mul.c b/arch/mips64/math-emu/sp_mul.c --- a/arch/mips64/math-emu/sp_mul.c Tue Mar 4 19:30:05 2003 +++ b/arch/mips64/math-emu/sp_mul.c Tue Mar 4 19:30:05 2003 @@ -72,7 +72,7 @@ return x; - /* Infinity handeling */ + /* Infinity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_ZERO): case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_INF): diff -Nru a/arch/mips64/math-emu/sp_sub.c b/arch/mips64/math-emu/sp_sub.c --- a/arch/mips64/math-emu/sp_sub.c Tue Mar 4 19:30:08 2003 +++ b/arch/mips64/math-emu/sp_sub.c Tue Mar 4 19:30:08 2003 @@ -72,7 +72,7 @@ return x; - /* Inifity handeling + /* Inifity handling */ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_INF): @@ -91,7 +91,7 @@ case CLPAIR(IEEE754_CLASS_INF, IEEE754_CLASS_DNORM): return x; - /* Zero handeling + /* Zero handling */ case CLPAIR(IEEE754_CLASS_ZERO, IEEE754_CLASS_ZERO): diff -Nru a/arch/mips64/mips-boards/generic/pci.c b/arch/mips64/mips-boards/generic/pci.c --- a/arch/mips64/mips-boards/generic/pci.c Tue Mar 4 19:30:04 2003 +++ b/arch/mips64/mips-boards/generic/pci.c Tue Mar 4 19:30:04 2003 @@ -87,7 +87,7 @@ if (intr & (GT_INTRCAUSE_MASABORT0_BIT | GT_INTRCAUSE_TARABORT0_BIT)) { - /* Error occured */ + /* Error occurred */ /* Clear bits */ GT_WRITE( GT_INTRCAUSE_OFS, ~(GT_INTRCAUSE_MASABORT0_BIT | diff -Nru a/arch/mips64/sgi-ip27/ip27-nmi.c b/arch/mips64/sgi-ip27/ip27-nmi.c --- a/arch/mips64/sgi-ip27/ip27-nmi.c Tue Mar 4 19:30:03 2003 +++ b/arch/mips64/sgi-ip27/ip27-nmi.c Tue Mar 4 19:30:03 2003 @@ -127,7 +127,7 @@ * This is for 2 reasons: * - sometimes a MMSC fail to NMI all cpus. * - on 512p SN0 system, the MMSC will only send NMIs to - * half the cpus. Unfortunately, we dont know which cpus may be + * half the cpus. Unfortunately, we don't know which cpus may be * NMIed - it depends on how the site chooses to configure. * * Note: it has been measure that it takes the MMSC up to 2.3 secs to diff -Nru a/arch/mips64/sgi-ip27/ip27-pci-dma.c b/arch/mips64/sgi-ip27/ip27-pci-dma.c --- a/arch/mips64/sgi-ip27/ip27-pci-dma.c Tue Mar 4 19:30:11 2003 +++ b/arch/mips64/sgi-ip27/ip27-pci-dma.c Tue Mar 4 19:30:11 2003 @@ -74,7 +74,7 @@ * must match what was provided for in a previous pci_map_single call. All * other usages are undefined. * - * After this call, reads by the cpu to the buffer are guarenteed to see + * After this call, reads by the cpu to the buffer are guaranteed to see * whatever the device wrote there. */ void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr, diff -Nru a/arch/parisc/kernel/cache.c b/arch/parisc/kernel/cache.c --- a/arch/parisc/kernel/cache.c Tue Mar 4 19:30:08 2003 +++ b/arch/parisc/kernel/cache.c Tue Mar 4 19:30:08 2003 @@ -39,8 +39,7 @@ void flush_data_cache(void) { - smp_call_function((void (*)(void *))flush_data_cache_local, NULL, 1, 1); - flush_data_cache_local(); + on_each_cpu((void (*)(void *))flush_data_cache_local, NULL, 1, 1); } #endif diff -Nru a/arch/parisc/kernel/irq.c b/arch/parisc/kernel/irq.c --- a/arch/parisc/kernel/irq.c Tue Mar 4 19:30:07 2003 +++ b/arch/parisc/kernel/irq.c Tue Mar 4 19:30:07 2003 @@ -61,20 +61,17 @@ static spinlock_t irq_lock = SPIN_LOCK_UNLOCKED; /* protect IRQ regions */ -#ifdef CONFIG_SMP static void cpu_set_eiem(void *info) { set_eiem((unsigned long) info); } -#endif static inline void disable_cpu_irq(void *unused, int irq) { unsigned long eirr_bit = EIEM_MASK(irq); cpu_eiem &= ~eirr_bit; - set_eiem(cpu_eiem); - smp_call_function(cpu_set_eiem, (void *) cpu_eiem, 1, 1); + on_each_cpu(cpu_set_eiem, (void *) cpu_eiem, 1, 1); } static void enable_cpu_irq(void *unused, int irq) @@ -83,8 +80,7 @@ mtctl(eirr_bit, 23); /* clear EIRR bit before unmasking */ cpu_eiem |= eirr_bit; - smp_call_function(cpu_set_eiem, (void *) cpu_eiem, 1, 1); - set_eiem(cpu_eiem); + on_each_cpu(cpu_set_eiem, (void *) cpu_eiem, 1, 1); } /* mask and disable are the same at the CPU level @@ -100,8 +96,7 @@ ** handle *any* unmasked pending interrupts. ** ie We don't need to check for pending interrupts here. */ - smp_call_function(cpu_set_eiem, (void *) cpu_eiem, 1, 1); - set_eiem(cpu_eiem); + on_each_cpu(cpu_set_eiem, (void *) cpu_eiem, 1, 1); } /* @@ -349,7 +344,7 @@ /* -** The alloc process needs to accept a parameter to accomodate limitations +** The alloc process needs to accept a parameter to accommodate limitations ** of the HW/SW which use these bits: ** Legacy PA I/O (GSC/NIO): 5 bits (architected EIM register) ** V-class (EPIC): 6 bits diff -Nru a/arch/parisc/kernel/perf.c b/arch/parisc/kernel/perf.c --- a/arch/parisc/kernel/perf.c Tue Mar 4 19:30:07 2003 +++ b/arch/parisc/kernel/perf.c Tue Mar 4 19:30:07 2003 @@ -255,7 +255,7 @@ } /* - * Open the device and initialize all of it's memory. The device is only + * Open the device and initialize all of its memory. The device is only * opened once, but can be "queried" by multiple processes that know its * file descriptor. */ diff -Nru a/arch/parisc/kernel/perf_images.h b/arch/parisc/kernel/perf_images.h --- a/arch/parisc/kernel/perf_images.h Tue Mar 4 19:30:04 2003 +++ b/arch/parisc/kernel/perf_images.h Tue Mar 4 19:30:04 2003 @@ -1556,7 +1556,7 @@ * IRTN_AV fires twice for every I-cache miss returning from RIB to the IFU. * It will not fire if a second I-cache miss is issued from the IFU to RIB * before the first returns. Therefore, if the IRTN_AV count is much less - * than 2x the ICORE_AV count, many speculative I-cache misses are occuring + * than 2x the ICORE_AV count, many speculative I-cache misses are occurring * which are "discovered" to be incorrect fairly quickly. * The ratio of I-cache miss transactions on Runway to the ICORE_AV count is * a measure of the effectiveness of instruction prefetching. This ratio diff -Nru a/arch/parisc/kernel/ptrace.c b/arch/parisc/kernel/ptrace.c --- a/arch/parisc/kernel/ptrace.c Tue Mar 4 19:30:04 2003 +++ b/arch/parisc/kernel/ptrace.c Tue Mar 4 19:30:04 2003 @@ -242,7 +242,7 @@ * * Allow writing to Nullify, Divide-step-correction, * and carry/borrow bits. - * BEWARE, if you set N, and then single step, it wont + * BEWARE, if you set N, and then single step, it won't * stop on the nullified instruction. */ DBG(("sys_ptrace(POKEUSR, %d, %lx, %lx)\n", diff -Nru a/arch/parisc/kernel/smp.c b/arch/parisc/kernel/smp.c --- a/arch/parisc/kernel/smp.c Tue Mar 4 19:30:14 2003 +++ b/arch/parisc/kernel/smp.c Tue Mar 4 19:30:14 2003 @@ -401,7 +401,7 @@ __setup("maxcpus=", maxcpus); /* - * Flush all other CPU's tlb and then mine. Do this with smp_call_function() + * Flush all other CPU's tlb and then mine. Do this with on_each_cpu() * as we want to ensure all TLB's flushed before proceeding. */ @@ -410,8 +410,7 @@ void smp_flush_tlb_all(void) { - smp_call_function((void (*)(void *))flush_tlb_all_local, NULL, 1, 1); - flush_tlb_all_local(); + on_each_cpu((void (*)(void *))flush_tlb_all_local, NULL, 1, 1); } diff -Nru a/arch/parisc/kernel/time.c b/arch/parisc/kernel/time.c --- a/arch/parisc/kernel/time.c Tue Mar 4 19:30:07 2003 +++ b/arch/parisc/kernel/time.c Tue Mar 4 19:30:07 2003 @@ -32,7 +32,7 @@ #include -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; /* xtime and wall_jiffies keep wall-clock time */ extern unsigned long wall_jiffies; diff -Nru a/arch/parisc/mm/init.c b/arch/parisc/mm/init.c --- a/arch/parisc/mm/init.c Tue Mar 4 19:30:08 2003 +++ b/arch/parisc/mm/init.c Tue Mar 4 19:30:08 2003 @@ -974,8 +974,7 @@ do_recycle++; } spin_unlock(&sid_lock); - smp_call_function((void (*)(void *))flush_tlb_all_local, NULL, 1, 1); - flush_tlb_all_local(); + on_each_cpu((void (*)(void *))flush_tlb_all_local, NULL, 1, 1); if (do_recycle) { spin_lock(&sid_lock); recycle_sids(recycle_ndirty,recycle_dirty_array); diff -Nru a/arch/ppc/4xx_io/serial_sicc.c b/arch/ppc/4xx_io/serial_sicc.c --- a/arch/ppc/4xx_io/serial_sicc.c Tue Mar 4 19:30:03 2003 +++ b/arch/ppc/4xx_io/serial_sicc.c Tue Mar 4 19:30:03 2003 @@ -139,7 +139,7 @@ #define _LSR_RX_ERR (_LSR_LB_BREAK | _LSR_FE_MASK | _LSR_OE_MASK | \ _LSR_PE_MASK ) -/* serial port reciever command register */ +/* serial port receiver command register */ #define _RCR_ER_MASK 0x80 /* enable receiver mask */ #define _RCR_DME_MASK 0x60 /* dma mode */ diff -Nru a/arch/ppc/8xx_io/cs4218_tdm.c b/arch/ppc/8xx_io/cs4218_tdm.c --- a/arch/ppc/8xx_io/cs4218_tdm.c Tue Mar 4 19:30:04 2003 +++ b/arch/ppc/8xx_io/cs4218_tdm.c Tue Mar 4 19:30:04 2003 @@ -2495,7 +2495,7 @@ cp->cp_simode &= ~0x00000fff; /* Enable common receive/transmit clock pins, use IDL format. - * Sync on falling edge, transmit rising clock, recieve falling + * Sync on falling edge, transmit rising clock, receive falling * clock, delay 1 bit on both Tx and Rx. Common Tx/Rx clocks and * sync. * Connect SMC2 to TSA. diff -Nru a/arch/ppc/kernel/l2cr.S b/arch/ppc/kernel/l2cr.S --- a/arch/ppc/kernel/l2cr.S Tue Mar 4 19:30:09 2003 +++ b/arch/ppc/kernel/l2cr.S Tue Mar 4 19:30:09 2003 @@ -136,7 +136,7 @@ /**** Might be a good idea to set L2DO here - to prevent instructions from getting into the cache. But since we invalidate the next time we enable the cache it doesn't really matter. - Don't do this unless you accomodate all processor variations. + Don't do this unless you accommodate all processor variations. The bit moved on the 7450..... ****/ diff -Nru a/arch/ppc/kernel/temp.c b/arch/ppc/kernel/temp.c --- a/arch/ppc/kernel/temp.c Tue Mar 4 19:30:09 2003 +++ b/arch/ppc/kernel/temp.c Tue Mar 4 19:30:09 2003 @@ -194,10 +194,7 @@ /* schedule ourselves to be run again */ mod_timer(&tau_timer, jiffies + shrink_timer) ; -#ifdef CONFIG_SMP - smp_call_function(tau_timeout, NULL, 1, 0); -#endif - tau_timeout(NULL); + on_each_cpu(tau_timeout, NULL, 1, 0); } /* @@ -239,10 +236,7 @@ tau_timer.expires = jiffies + shrink_timer; add_timer(&tau_timer); -#ifdef CONFIG_SMP - smp_call_function(TAU_init_smp, NULL, 1, 0); -#endif - TAU_init_smp(NULL); + on_each_cpu(TAU_init_smp, NULL, 1, 0); printk("Thermal assist unit "); #ifdef CONFIG_TAU_INT diff -Nru a/arch/ppc/kernel/time.c b/arch/ppc/kernel/time.c --- a/arch/ppc/kernel/time.c Tue Mar 4 19:30:12 2003 +++ b/arch/ppc/kernel/time.c Tue Mar 4 19:30:12 2003 @@ -68,7 +68,7 @@ #include /* XXX false sharing with below? */ -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; unsigned long disarm_decr[NR_CPUS]; diff -Nru a/arch/ppc/mm/mem_pieces.c b/arch/ppc/mm/mem_pieces.c --- a/arch/ppc/mm/mem_pieces.c Tue Mar 4 19:30:04 2003 +++ b/arch/ppc/mm/mem_pieces.c Tue Mar 4 19:30:04 2003 @@ -1,6 +1,6 @@ /* * Copyright (c) 1996 Paul Mackerras - * Changes to accomodate Power Macintoshes. + * Changes to accommodate Power Macintoshes. * Cort Dougan * Rewrites. * Grant Erickson diff -Nru a/arch/ppc/mm/mem_pieces.h b/arch/ppc/mm/mem_pieces.h --- a/arch/ppc/mm/mem_pieces.h Tue Mar 4 19:30:03 2003 +++ b/arch/ppc/mm/mem_pieces.h Tue Mar 4 19:30:03 2003 @@ -1,6 +1,6 @@ /* * Copyright (c) 1996 Paul Mackerras - * Changes to accomodate Power Macintoshes. + * Changes to accommodate Power Macintoshes. * Cort Dougan * Rewrites. * Grant Erickson diff -Nru a/arch/ppc/platforms/4xx/ibmstbx25.h b/arch/ppc/platforms/4xx/ibmstbx25.h --- a/arch/ppc/platforms/4xx/ibmstbx25.h Tue Mar 4 19:30:07 2003 +++ b/arch/ppc/platforms/4xx/ibmstbx25.h Tue Mar 4 19:30:07 2003 @@ -164,7 +164,7 @@ #define IBM_CPM_CPU 0x10000000 /* PPC405B3 clock control */ #define IBM_CPM_AUD 0x08000000 /* Audio Decoder */ #define IBM_CPM_EBIU 0x04000000 /* External Bus Interface Unit */ -#define IBM_CPM_IRR 0x02000000 /* Infrared reciever */ +#define IBM_CPM_IRR 0x02000000 /* Infrared receiver */ #define IBM_CPM_DMA 0x01000000 /* DMA controller */ #define IBM_CPM_UART2 0x00200000 /* Serial Control Port */ #define IBM_CPM_UART1 0x00100000 /* Serial 1 / Infrared */ diff -Nru a/arch/ppc/platforms/pmac_feature.c b/arch/ppc/platforms/pmac_feature.c --- a/arch/ppc/platforms/pmac_feature.c Tue Mar 4 19:30:13 2003 +++ b/arch/ppc/platforms/pmac_feature.c Tue Mar 4 19:30:13 2003 @@ -50,7 +50,7 @@ /* * We use a single global lock to protect accesses. Each driver has - * to take care of it's own locking + * to take care of its own locking */ static spinlock_t feature_lock __pmacdata = SPIN_LOCK_UNLOCKED; diff -Nru a/arch/ppc/syslib/mpc10x_common.c b/arch/ppc/syslib/mpc10x_common.c --- a/arch/ppc/syslib/mpc10x_common.c Tue Mar 4 19:30:05 2003 +++ b/arch/ppc/syslib/mpc10x_common.c Tue Mar 4 19:30:05 2003 @@ -109,7 +109,7 @@ return -1; } - /* Make sure its a supported bridge */ + /* Make sure it's a supported bridge */ early_read_config_dword(hose, 0, PCI_DEVFN(0,0), diff -Nru a/arch/ppc64/boot/addRamDisk.c b/arch/ppc64/boot/addRamDisk.c --- a/arch/ppc64/boot/addRamDisk.c Tue Mar 4 19:30:09 2003 +++ b/arch/ppc64/boot/addRamDisk.c Tue Mar 4 19:30:09 2003 @@ -154,7 +154,7 @@ /* Process the Sysmap file to determine where _end is */ sysmapPages = sysmapLen / 4096; - /* read the whole file line by line, expect that it doesnt fail */ + /* read the whole file line by line, expect that it doesn't fail */ while ( fgets(inbuf, 4096, sysmap) ) ; /* search for _end in the last page of the system map */ ptr_end = strstr(inbuf, " _end"); diff -Nru a/arch/ppc64/boot/addSystemMap.c b/arch/ppc64/boot/addSystemMap.c --- a/arch/ppc64/boot/addSystemMap.c Tue Mar 4 19:30:08 2003 +++ b/arch/ppc64/boot/addSystemMap.c Tue Mar 4 19:30:08 2003 @@ -146,7 +146,7 @@ /* Process the Sysmap file to determine the true end of the kernel */ sysmapPages = sysmapLen / 4096; printf("System map pages to copy = %ld\n", sysmapPages); - /* read the whole file line by line, expect that it doesnt fail */ + /* read the whole file line by line, expect that it doesn't fail */ while ( fgets(inbuf, 4096, sysmap) ) ; /* search for _end in the last page of the system map */ ptr_end = strstr(inbuf, " _end"); diff -Nru a/arch/ppc64/kernel/head.S b/arch/ppc64/kernel/head.S --- a/arch/ppc64/kernel/head.S Tue Mar 4 19:30:09 2003 +++ b/arch/ppc64/kernel/head.S Tue Mar 4 19:30:09 2003 @@ -109,7 +109,7 @@ .llong 0x0 /* Secondary processors write this value with their cpu # */ - /* after they enter the spin loop immediatly below. */ + /* after they enter the spin loop immediately below. */ .globl __secondary_hold_acknowledge __secondary_hold_acknowledge: .llong 0x0 diff -Nru a/arch/ppc64/kernel/ioctl32.c b/arch/ppc64/kernel/ioctl32.c --- a/arch/ppc64/kernel/ioctl32.c Tue Mar 4 19:30:14 2003 +++ b/arch/ppc64/kernel/ioctl32.c Tue Mar 4 19:30:14 2003 @@ -3315,7 +3315,7 @@ * * But how to keep track of these kernel buffers? We'd need to either * keep track of them in some table _or_ know about usbdevicefs internals - * (ie. the exact layout of it's file private, which is actually defined + * (ie. the exact layout of its file private, which is actually defined * in linux/usbdevice_fs.h, the layout of the async queues are private to * devio.c) * diff -Nru a/arch/ppc64/kernel/lmb.c b/arch/ppc64/kernel/lmb.c --- a/arch/ppc64/kernel/lmb.c Tue Mar 4 19:30:09 2003 +++ b/arch/ppc64/kernel/lmb.c Tue Mar 4 19:30:09 2003 @@ -73,7 +73,7 @@ _lmb->reserved.cnt = 1; } -/* This is only used here, it doesnt deserve to be in bitops.h */ +/* This is only used here, it doesn't deserve to be in bitops.h */ static __inline__ long cnt_trailing_zeros(unsigned long mask) { long cnt; diff -Nru a/arch/ppc64/kernel/pSeries_lpar.c b/arch/ppc64/kernel/pSeries_lpar.c --- a/arch/ppc64/kernel/pSeries_lpar.c Tue Mar 4 19:30:14 2003 +++ b/arch/ppc64/kernel/pSeries_lpar.c Tue Mar 4 19:30:14 2003 @@ -461,7 +461,7 @@ return -1; /* - * Since we try and ioremap PHBs we dont own, the pte insert + * Since we try and ioremap PHBs we don't own, the pte insert * will fail. However we must catch the failure in hash_page * or we will loop forever, so return -2 in this case. */ @@ -485,7 +485,7 @@ for (i = 0; i < HPTES_PER_GROUP; i++) { - /* dont remove a bolted entry */ + /* don't remove a bolted entry */ lpar_rc = plpar_pte_remove(H_ANDCOND, hpte_group + slot_offset, (0x1UL << 4), &dummy1, &dummy2); diff -Nru a/arch/ppc64/kernel/pci_dn.c b/arch/ppc64/kernel/pci_dn.c --- a/arch/ppc64/kernel/pci_dn.c Tue Mar 4 19:30:14 2003 +++ b/arch/ppc64/kernel/pci_dn.c Tue Mar 4 19:30:14 2003 @@ -150,7 +150,7 @@ } /* This is the "slow" path for looking up a device_node from a - * pci_dev. It will hunt for the device under it's parent's + * pci_dev. It will hunt for the device under its parent's * phb and then update sysdata for a future fastpath. * * It may also do fixups on the actual device since this happens diff -Nru a/arch/ppc64/kernel/ras.c b/arch/ppc64/kernel/ras.c --- a/arch/ppc64/kernel/ras.c Tue Mar 4 19:30:05 2003 +++ b/arch/ppc64/kernel/ras.c Tue Mar 4 19:30:05 2003 @@ -94,7 +94,7 @@ /* * Handle power subsystem events (EPOW). * - * Presently we just log the event has occured. This should be fixed + * Presently we just log the event has occurred. This should be fixed * to examine the type of power failure and take appropriate action where * the time horizon permits something useful to be done. */ diff -Nru a/arch/ppc64/kernel/smp.c b/arch/ppc64/kernel/smp.c --- a/arch/ppc64/kernel/smp.c Tue Mar 4 19:30:12 2003 +++ b/arch/ppc64/kernel/smp.c Tue Mar 4 19:30:12 2003 @@ -51,7 +51,7 @@ int smp_threads_ready = 0; unsigned long cache_decay_ticks; -/* initialised so it doesnt end up in bss */ +/* initialised so it doesn't end up in bss */ unsigned long cpu_online_map = 0; static struct smp_ops_t *smp_ops; diff -Nru a/arch/ppc64/kernel/time.c b/arch/ppc64/kernel/time.c --- a/arch/ppc64/kernel/time.c Tue Mar 4 19:30:13 2003 +++ b/arch/ppc64/kernel/time.c Tue Mar 4 19:30:13 2003 @@ -65,7 +65,7 @@ void smp_local_timer_interrupt(struct pt_regs *); -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; /* keep track of when we need to update the rtc */ time_t last_rtc_update; diff -Nru a/arch/ppc64/xmon/xmon.c b/arch/ppc64/xmon/xmon.c --- a/arch/ppc64/xmon/xmon.c Tue Mar 4 19:30:13 2003 +++ b/arch/ppc64/xmon/xmon.c Tue Mar 4 19:30:13 2003 @@ -2072,7 +2072,7 @@ int instr; int num_parms; - /* dont look for traceback table in userspace */ + /* don't look for traceback table in userspace */ if (codeaddr < PAGE_OFFSET) return 0; diff -Nru a/arch/s390/kernel/smp.c b/arch/s390/kernel/smp.c --- a/arch/s390/kernel/smp.c Tue Mar 4 19:30:03 2003 +++ b/arch/s390/kernel/smp.c Tue Mar 4 19:30:03 2003 @@ -228,8 +228,7 @@ void machine_restart_smp(char * __unused) { cpu_restart_map = cpu_online_map; - smp_call_function(do_machine_restart, NULL, 0, 0); - do_machine_restart(NULL); + on_each_cpu(do_machine_restart, NULL, 0, 0); } static void do_machine_halt(void * __unused) @@ -247,8 +246,7 @@ void machine_halt_smp(void) { - smp_call_function(do_machine_halt, NULL, 0, 0); - do_machine_halt(NULL); + on_each_cpu(do_machine_halt, NULL, 0, 0); } static void do_machine_power_off(void * __unused) @@ -266,8 +264,7 @@ void machine_power_off_smp(void) { - smp_call_function(do_machine_power_off, NULL, 0, 0); - do_machine_power_off(NULL); + on_each_cpu(do_machine_power_off, NULL, 0, 0); } /* @@ -339,8 +336,7 @@ void smp_ptlb_all(void) { - smp_call_function(smp_ptlb_callback, NULL, 0, 1); - local_flush_tlb(); + on_each_cpu(smp_ptlb_callback, NULL, 0, 1); } /* @@ -400,8 +396,10 @@ parms.end_ctl = cr; parms.orvals[cr] = 1 << bit; parms.andvals[cr] = 0xFFFFFFFF; + preempt_disable(); smp_call_function(smp_ctl_bit_callback, &parms, 0, 1); __ctl_set_bit(cr, bit); + preempt_enable(); } /* @@ -414,8 +412,10 @@ parms.end_ctl = cr; parms.orvals[cr] = 0x00000000; parms.andvals[cr] = ~(1 << bit); + preempt_disable(); smp_call_function(smp_ctl_bit_callback, &parms, 0, 1); __ctl_clear_bit(cr, bit); + preempt_enable(); } /* diff -Nru a/arch/s390/kernel/time.c b/arch/s390/kernel/time.c --- a/arch/s390/kernel/time.c Tue Mar 4 19:30:03 2003 +++ b/arch/s390/kernel/time.c Tue Mar 4 19:30:03 2003 @@ -46,7 +46,7 @@ #define TICK_SIZE tick -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static ext_int_info_t ext_int_info_timer; static uint64_t xtime_cc; diff -Nru a/arch/s390x/kernel/exec32.c b/arch/s390x/kernel/exec32.c --- a/arch/s390x/kernel/exec32.c Tue Mar 4 19:30:03 2003 +++ b/arch/s390x/kernel/exec32.c Tue Mar 4 19:30:03 2003 @@ -4,7 +4,7 @@ * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation * Author(s): Gerhard Tonn (ton@de.ibm.com) * - * Seperated from binfmt_elf32.c to reduce exports for module enablement. + * Separated from binfmt_elf32.c to reduce exports for module enablement. * */ diff -Nru a/arch/s390x/kernel/smp.c b/arch/s390x/kernel/smp.c --- a/arch/s390x/kernel/smp.c Tue Mar 4 19:30:09 2003 +++ b/arch/s390x/kernel/smp.c Tue Mar 4 19:30:09 2003 @@ -227,8 +227,7 @@ void machine_restart_smp(char * __unused) { cpu_restart_map = cpu_online_map; - smp_call_function(do_machine_restart, NULL, 0, 0); - do_machine_restart(NULL); + on_each_cpu(do_machine_restart, NULL, 0, 0); } static void do_machine_halt(void * __unused) @@ -246,8 +245,7 @@ void machine_halt_smp(void) { - smp_call_function(do_machine_halt, NULL, 0, 0); - do_machine_halt(NULL); + on_each_cpu(do_machine_halt, NULL, 0, 0); } static void do_machine_power_off(void * __unused) @@ -265,8 +263,7 @@ void machine_power_off_smp(void) { - smp_call_function(do_machine_power_off, NULL, 0, 0); - do_machine_power_off(NULL); + on_each_cpu(do_machine_power_off, NULL, 0, 0); } /* @@ -383,8 +380,10 @@ parms.end_ctl = cr; parms.orvals[cr] = 1 << bit; parms.andvals[cr] = -1L; + preempt_disable(); smp_call_function(smp_ctl_bit_callback, &parms, 0, 1); __ctl_set_bit(cr, bit); + preempt_enable(); } /* @@ -397,8 +396,10 @@ parms.end_ctl = cr; parms.orvals[cr] = 0; parms.andvals[cr] = ~(1L << bit); + preempt_disable(); smp_call_function(smp_ctl_bit_callback, &parms, 0, 1); __ctl_clear_bit(cr, bit); + preempt_enable(); } diff -Nru a/arch/s390x/kernel/time.c b/arch/s390x/kernel/time.c --- a/arch/s390x/kernel/time.c Tue Mar 4 19:30:13 2003 +++ b/arch/s390x/kernel/time.c Tue Mar 4 19:30:13 2003 @@ -45,7 +45,7 @@ #define TICK_SIZE tick -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static ext_int_info_t ext_int_info_timer; static uint64_t xtime_cc; diff -Nru a/arch/sh/kernel/fpu.c b/arch/sh/kernel/fpu.c --- a/arch/sh/kernel/fpu.c Tue Mar 4 19:30:09 2003 +++ b/arch/sh/kernel/fpu.c Tue Mar 4 19:30:09 2003 @@ -118,7 +118,7 @@ /* * Load the FPU with signalling NANS. This bit pattern we're using - * has the property that no matter wether considered as single or as + * has the property that no matter whether considered as single or as * double precission represents signaling NANS. */ diff -Nru a/arch/sh/kernel/irq.c b/arch/sh/kernel/irq.c --- a/arch/sh/kernel/irq.c Tue Mar 4 19:30:07 2003 +++ b/arch/sh/kernel/irq.c Tue Mar 4 19:30:07 2003 @@ -61,7 +61,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ printk("unexpected IRQ trap at vector %02x\n", irq); diff -Nru a/arch/sh/kernel/pci-dma.c b/arch/sh/kernel/pci-dma.c --- a/arch/sh/kernel/pci-dma.c Tue Mar 4 19:30:12 2003 +++ b/arch/sh/kernel/pci-dma.c Tue Mar 4 19:30:12 2003 @@ -24,7 +24,7 @@ ret = (void *) __get_free_pages(gfp, get_order(size)); if (ret != NULL) { - /* Is it neccessary to do the memset? */ + /* Is it necessary to do the memset? */ memset(ret, 0, size); *dma_handle = virt_to_bus(ret); } diff -Nru a/arch/sh/kernel/pci-sh7751.c b/arch/sh/kernel/pci-sh7751.c --- a/arch/sh/kernel/pci-sh7751.c Tue Mar 4 19:30:11 2003 +++ b/arch/sh/kernel/pci-sh7751.c Tue Mar 4 19:30:11 2003 @@ -285,7 +285,7 @@ struct pci_ops *bios = NULL; struct pci_ops *dir = NULL; - PCIDBG(1,"PCI: Starting intialization.\n"); + PCIDBG(1,"PCI: Starting initialization.\n"); #ifdef CONFIG_PCI_BIOS if ((pci_probe & PCI_PROBE_BIOS) && ((bios = pci_find_bios()))) { pci_probe |= PCI_BIOS_SORT; diff -Nru a/arch/sh/kernel/time.c b/arch/sh/kernel/time.c --- a/arch/sh/kernel/time.c Tue Mar 4 19:30:03 2003 +++ b/arch/sh/kernel/time.c Tue Mar 4 19:30:03 2003 @@ -70,7 +70,7 @@ #endif /* CONFIG_CPU_SUBTYPE_ST40STB1 */ #endif /* __sh3__ or __SH4__ */ -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; extern unsigned long wall_jiffies; #define TICK_SIZE tick diff -Nru a/arch/sh/stboards/pcidma.c b/arch/sh/stboards/pcidma.c --- a/arch/sh/stboards/pcidma.c Tue Mar 4 19:30:08 2003 +++ b/arch/sh/stboards/pcidma.c Tue Mar 4 19:30:08 2003 @@ -24,7 +24,7 @@ ret = (void *) __get_free_pages(gfp, get_order(size)); if (ret != NULL) { - /* Is it neccessary to do the memset? */ + /* Is it necessary to do the memset? */ memset(ret, 0, size); *dma_handle = virt_to_bus(ret); } diff -Nru a/arch/sparc/Kconfig b/arch/sparc/Kconfig --- a/arch/sparc/Kconfig Tue Mar 4 19:30:03 2003 +++ b/arch/sparc/Kconfig Tue Mar 4 19:30:03 2003 @@ -148,7 +148,7 @@ config MCA bool help - EISA is not supported. + MCA is not supported. Say N config PCMCIA diff -Nru a/arch/sparc/kernel/init_task.c b/arch/sparc/kernel/init_task.c --- a/arch/sparc/kernel/init_task.c Tue Mar 4 19:30:10 2003 +++ b/arch/sparc/kernel/init_task.c Tue Mar 4 19:30:10 2003 @@ -12,7 +12,7 @@ struct mm_struct init_mm = INIT_MM(init_mm); struct task_struct init_task = INIT_TASK(init_task); -/* .text section in head.S is aligned at 8k boundry and this gets linked +/* .text section in head.S is aligned at 8k boundary and this gets linked * right after that so that the init_thread_union is aligned properly as well. * If this is not aligned on a 8k boundry, then you should change code * in etrap.S which assumes it. diff -Nru a/arch/sparc/kernel/ioport.c b/arch/sparc/kernel/ioport.c --- a/arch/sparc/kernel/ioport.c Tue Mar 4 19:30:14 2003 +++ b/arch/sparc/kernel/ioport.c Tue Mar 4 19:30:14 2003 @@ -599,7 +599,7 @@ * must match what was provided for in a previous pci_map_single call. All * other usages are undefined. * - * After this call, reads by the cpu to the buffer are guarenteed to see + * After this call, reads by the cpu to the buffer are guaranteed to see * whatever the device wrote there. */ void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t ba, size_t size, diff -Nru a/arch/sparc/kernel/time.c b/arch/sparc/kernel/time.c --- a/arch/sparc/kernel/time.c Tue Mar 4 19:30:09 2003 +++ b/arch/sparc/kernel/time.c Tue Mar 4 19:30:09 2003 @@ -45,7 +45,7 @@ extern unsigned long wall_jiffies; -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED; enum sparc_clock_type sp_clock_typ; diff -Nru a/arch/sparc/lib/blockops.S b/arch/sparc/lib/blockops.S --- a/arch/sparc/lib/blockops.S Tue Mar 4 19:30:14 2003 +++ b/arch/sparc/lib/blockops.S Tue Mar 4 19:30:14 2003 @@ -38,7 +38,7 @@ * and (2 * PAGE_SIZE) (for kernel stacks) * and with a second arg of zero. We assume in * all of these cases that the buffer is aligned - * on at least an 8 byte boundry. + * on at least an 8 byte boundary. * * Therefore we special case them to make them * as fast as possible. diff -Nru a/arch/sparc/lib/checksum.S b/arch/sparc/lib/checksum.S --- a/arch/sparc/lib/checksum.S Tue Mar 4 19:30:10 2003 +++ b/arch/sparc/lib/checksum.S Tue Mar 4 19:30:10 2003 @@ -336,7 +336,7 @@ bne cc_dword_align ! yes, we check for short lengths there andcc %g1, 0xffffff80, %g0 ! can we use unrolled loop? 3: be 3f ! nope, less than one loop remains - andcc %o1, 4, %g0 ! dest aligned on 4 or 8 byte boundry? + andcc %o1, 4, %g0 ! dest aligned on 4 or 8 byte boundary? be ccdbl + 4 ! 8 byte aligned, kick ass 5: CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x00,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3) CSUMCOPY_BIGCHUNK(%o0,%o1,%g7,0x20,%o4,%o5,%g2,%g3,%g4,%g5,%o2,%o3) diff -Nru a/arch/sparc/mm/iommu.c b/arch/sparc/mm/iommu.c --- a/arch/sparc/mm/iommu.c Tue Mar 4 19:30:14 2003 +++ b/arch/sparc/mm/iommu.c Tue Mar 4 19:30:14 2003 @@ -112,7 +112,7 @@ for (i = 6; i < 9; i++) if ((1 << (i + PAGE_SHIFT)) == ptsize) break; - tmp = __get_free_pages(GFP_DMA, i); + tmp = __get_free_pages(GFP_KERNEL, i); if (!tmp) { prom_printf("Could not allocate iopte of size 0x%08x\n", ptsize); prom_halt(); diff -Nru a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c --- a/arch/sparc/mm/srmmu.c Tue Mar 4 19:30:10 2003 +++ b/arch/sparc/mm/srmmu.c Tue Mar 4 19:30:10 2003 @@ -2120,7 +2120,7 @@ srmmu_is_bad(); } -/* dont laugh, static pagetables */ +/* don't laugh, static pagetables */ static void srmmu_check_pgt_cache(int low, int high) { } diff -Nru a/arch/sparc/mm/sun4c.c b/arch/sparc/mm/sun4c.c --- a/arch/sparc/mm/sun4c.c Tue Mar 4 19:30:12 2003 +++ b/arch/sparc/mm/sun4c.c Tue Mar 4 19:30:12 2003 @@ -533,7 +533,7 @@ } } -/* Addr is always aligned on a page boundry for us already. */ +/* Addr is always aligned on a page boundary for us already. */ static void sun4c_map_dma_area(unsigned long va, u32 addr, int len) { unsigned long page, end; @@ -1042,7 +1042,7 @@ get_locked_segment(addr); /* We are changing the virtual color of the page(s) - * so we must flush the cache to guarentee consistency. + * so we must flush the cache to guarantee consistency. */ sun4c_flush_page(pages); #ifndef CONFIG_SUN4 diff -Nru a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig --- a/arch/sparc64/Kconfig Tue Mar 4 19:30:13 2003 +++ b/arch/sparc64/Kconfig Tue Mar 4 19:30:13 2003 @@ -150,18 +150,6 @@ If in doubt, say N. -config CPU_FREQ_PROC_INTF - tristate "/proc/cpufreq interface (DEPRECATED)" - depends on CPU_FREQ && PROC_FS - help - This enables the /proc/cpufreq interface for controlling - CPUFreq. Please note that it is recommended to use the sysfs - interface instead (which is built automatically). - - For details, take a look at linux/Documentation/cpufreq. - - If in doubt, say N. - config CPU_FREQ_TABLE tristate default y @@ -176,6 +164,8 @@ For details, take a look at linux/Documentation/cpufreq. If in doubt, say N. + +source "drivers/cpufreq/Kconfig" # Identify this as a Sparc64 build config SPARC64 diff -Nru a/arch/sparc64/defconfig b/arch/sparc64/defconfig --- a/arch/sparc64/defconfig Tue Mar 4 19:30:05 2003 +++ b/arch/sparc64/defconfig Tue Mar 4 19:30:05 2003 @@ -15,12 +15,6 @@ CONFIG_SYSVIPC=y # CONFIG_BSD_PROCESS_ACCT is not set CONFIG_SYSCTL=y -# CONFIG_LOG_BUF_SHIFT_17 is not set -# CONFIG_LOG_BUF_SHIFT_16 is not set -CONFIG_LOG_BUF_SHIFT_15=y -# CONFIG_LOG_BUF_SHIFT_14 is not set -# CONFIG_LOG_BUF_SHIFT_13 is not set -# CONFIG_LOG_BUF_SHIFT_12 is not set CONFIG_LOG_BUF_SHIFT=15 # @@ -30,6 +24,7 @@ CONFIG_MODULE_UNLOAD=y CONFIG_MODULE_FORCE_UNLOAD=y CONFIG_OBSOLETE_MODPARM=y +# CONFIG_MODVERSIONS is not set CONFIG_KMOD=y # @@ -45,6 +40,7 @@ CONFIG_NR_CPUS=4 CONFIG_CPU_FREQ=y CONFIG_CPU_FREQ_PROC_INTF=y +CONFIG_CPU_FREQ_TABLE=y CONFIG_US3_FREQ=m CONFIG_SPARC64=y CONFIG_HOTPLUG=y @@ -89,15 +85,52 @@ # # Graphics support # -# CONFIG_FB is not set +CONFIG_FB=y +# CONFIG_FB_CLGEN is not set +# CONFIG_FB_PM2 is not set +# CONFIG_FB_CYBER2000 is not set +# CONFIG_FB_IMSTT is not set +# CONFIG_FB_BW2 is not set +# CONFIG_FB_CG3 is not set +CONFIG_FB_CG6=y +# CONFIG_FB_RIVA is not set +# CONFIG_FB_MATROX is not set +# CONFIG_FB_RADEON is not set +# CONFIG_FB_ATY128 is not set +# CONFIG_FB_ATY is not set +# CONFIG_FB_SIS is not set +# CONFIG_FB_NEOMAGIC is not set +# CONFIG_FB_3DFX is not set +# CONFIG_FB_VOODOO1 is not set +# CONFIG_FB_TRIDENT is not set +# CONFIG_FB_PM3 is not set +CONFIG_FB_SBUS=y +CONFIG_FB_FFB=y +# CONFIG_FB_TCX is not set +# CONFIG_FB_CG14 is not set +# CONFIG_FB_P9100 is not set +# CONFIG_FB_LEO is not set +# CONFIG_FB_PCI is not set +# CONFIG_FB_VIRTUAL is not set # # Console display driver support # # CONFIG_VGA_CONSOLE is not set # CONFIG_MDA_CONSOLE is not set -CONFIG_PROM_CONSOLE=y +# CONFIG_PROM_CONSOLE is not set CONFIG_DUMMY_CONSOLE=y +CONFIG_FRAMEBUFFER_CONSOLE=y +CONFIG_PCI_CONSOLE=y +# CONFIG_FBCON_ADVANCED is not set +CONFIG_FONT_SUN8x16=y +# CONFIG_FONT_SUN12x22 is not set +CONFIG_FONTS=y +# CONFIG_FONT_8x8 is not set +# CONFIG_FONT_8x16 is not set +# CONFIG_FONT_6x11 is not set +# CONFIG_FONT_PEARL_8x8 is not set +# CONFIG_FONT_ACORN_8x8 is not set # # Serial drivers @@ -110,7 +143,7 @@ CONFIG_SERIAL_SUNCORE=y CONFIG_SERIAL_SUNZILOG=y CONFIG_SERIAL_SUNSU=y -# CONFIG_SERIAL_SUNSAB is not set +CONFIG_SERIAL_SUNSAB=m CONFIG_SERIAL_CORE=y CONFIG_SERIAL_CORE_CONSOLE=y @@ -190,7 +223,7 @@ CONFIG_BLK_DEV_ALI15X3=y # CONFIG_WDC_ALI15X3 is not set # CONFIG_BLK_DEV_AMD74XX is not set -CONFIG_BLK_DEV_CMD64X=y +# CONFIG_BLK_DEV_CMD64X is not set # CONFIG_BLK_DEV_TRIFLEX is not set # CONFIG_BLK_DEV_CY82C693 is not set # CONFIG_BLK_DEV_CS5520 is not set @@ -198,7 +231,7 @@ # CONFIG_BLK_DEV_HPT366 is not set # CONFIG_BLK_DEV_SC1200 is not set # CONFIG_BLK_DEV_PIIX is not set -CONFIG_BLK_DEV_NS87415=y +# CONFIG_BLK_DEV_NS87415 is not set # CONFIG_BLK_DEV_OPTI621 is not set # CONFIG_BLK_DEV_PDC202XX_OLD is not set # CONFIG_BLK_DEV_PDC202XX_NEW is not set @@ -221,9 +254,9 @@ # CONFIG_BLK_DEV_SD=y CONFIG_SD_EXTRA_DEVS=40 -CONFIG_CHR_DEV_ST=y +CONFIG_CHR_DEV_ST=m CONFIG_CHR_DEV_OSST=m -CONFIG_BLK_DEV_SR=y +CONFIG_BLK_DEV_SR=m CONFIG_BLK_DEV_SR_VENDOR=y CONFIG_SR_EXTRA_DEVS=2 CONFIG_CHR_DEV_SG=m @@ -320,11 +353,12 @@ CONFIG_INET_ESP=y CONFIG_XFRM_USER=m CONFIG_IPV6=m +CONFIG_IPV6_PRIVACY=y # # SCTP Configuration (EXPERIMENTAL) # -CONFIG_IPV6_SCTP__=y +CONFIG_IPV6_SCTP__=m CONFIG_IP_SCTP=m # CONFIG_SCTP_ADLER32 is not set # CONFIG_SCTP_DBG_MSG is not set @@ -395,6 +429,7 @@ # Ethernet (10 or 100Mbit) # CONFIG_NET_ETHERNET=y +# CONFIG_MII is not set CONFIG_SUNLANCE=y CONFIG_HAPPYMEAL=y CONFIG_SUNBMAC=m @@ -402,6 +437,7 @@ CONFIG_SUNGEM=y CONFIG_NET_VENDOR_3COM=y CONFIG_VORTEX=m +CONFIG_TYPHOON=m # # Tulip family network device support @@ -419,9 +455,11 @@ CONFIG_PCNET32=m # CONFIG_AMD8111_ETH is not set CONFIG_ADAPTEC_STARFIRE=m +CONFIG_ADAPTEC_STARFIRE_NAPI=y CONFIG_B44=m CONFIG_DGRS=m CONFIG_EEPRO100=m +# CONFIG_EEPRO100_PIO is not set CONFIG_E100=m CONFIG_FEALNX=m CONFIG_NATSEMI=m @@ -940,6 +978,7 @@ CONFIG_BT_HCIUART=m CONFIG_BT_HCIUART_H4=y CONFIG_BT_HCIUART_BCSP=y +CONFIG_BT_HCIUART_BCSP_TXCRC=y CONFIG_BT_HCIVHCI=m # diff -Nru a/arch/sparc64/kernel/Makefile b/arch/sparc64/kernel/Makefile --- a/arch/sparc64/kernel/Makefile Tue Mar 4 19:30:05 2003 +++ b/arch/sparc64/kernel/Makefile Tue Mar 4 19:30:05 2003 @@ -3,7 +3,7 @@ # EXTRA_AFLAGS := -ansi -CFLAGS += -Werror +EXTRA_CFLAGS := -Werror EXTRA_TARGETS := head.o init_task.o diff -Nru a/arch/sparc64/kernel/init_task.c b/arch/sparc64/kernel/init_task.c --- a/arch/sparc64/kernel/init_task.c Tue Mar 4 19:30:14 2003 +++ b/arch/sparc64/kernel/init_task.c Tue Mar 4 19:30:14 2003 @@ -12,7 +12,7 @@ static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand); struct mm_struct init_mm = INIT_MM(init_mm); -/* .text section in head.S is aligned at 2 page boundry and this gets linked +/* .text section in head.S is aligned at 2 page boundary and this gets linked * right after that so that the init_thread_union is aligned properly as well. * We really don't need this special alignment like the Intel does, but * I do it anyways for completeness. diff -Nru a/arch/sparc64/kernel/ioctl32.c b/arch/sparc64/kernel/ioctl32.c --- a/arch/sparc64/kernel/ioctl32.c Tue Mar 4 19:30:13 2003 +++ b/arch/sparc64/kernel/ioctl32.c Tue Mar 4 19:30:13 2003 @@ -3947,7 +3947,7 @@ * * But how to keep track of these kernel buffers? We'd need to either * keep track of them in some table _or_ know about usbdevicefs internals - * (ie. the exact layout of it's file private, which is actually defined + * (ie. the exact layout of its file private, which is actually defined * in linux/usbdevice_fs.h, the layout of the async queues are private to * devio.c) * diff -Nru a/arch/sparc64/kernel/iommu_common.h b/arch/sparc64/kernel/iommu_common.h --- a/arch/sparc64/kernel/iommu_common.h Tue Mar 4 19:30:14 2003 +++ b/arch/sparc64/kernel/iommu_common.h Tue Mar 4 19:30:14 2003 @@ -40,7 +40,7 @@ /* Two addresses are "virtually contiguous" if and only if: * 1) They are equal, or... - * 2) They are both on a page boundry + * 2) They are both on a page boundary */ #define VCONTIG(__X, __Y) (((__X) == (__Y)) || \ (((__X) | (__Y)) << (64UL - PAGE_SHIFT)) == 0UL) diff -Nru a/arch/sparc64/kernel/pci_common.c b/arch/sparc64/kernel/pci_common.c --- a/arch/sparc64/kernel/pci_common.c Tue Mar 4 19:30:05 2003 +++ b/arch/sparc64/kernel/pci_common.c Tue Mar 4 19:30:05 2003 @@ -583,7 +583,7 @@ * the PBM. * * However if that parent bridge has interrupt map/mask - * properties of it's own we use the PROM register property + * properties of its own we use the PROM register property * of the next child device on the path to PDEV. * * In detail the two cases are (note that the 'X' below is the diff -Nru a/arch/sparc64/kernel/sbus.c b/arch/sparc64/kernel/sbus.c --- a/arch/sparc64/kernel/sbus.c Tue Mar 4 19:30:14 2003 +++ b/arch/sparc64/kernel/sbus.c Tue Mar 4 19:30:14 2003 @@ -24,7 +24,7 @@ #include "iommu_common.h" /* These should be allocated on an SMP_CACHE_BYTES - * aligned boundry for optimal performance. + * aligned boundary for optimal performance. * * On SYSIO, using an 8K page size we have 1GB of SBUS * DMA space mapped. We divide this space into equally diff -Nru a/arch/sparc64/kernel/setup.c b/arch/sparc64/kernel/setup.c --- a/arch/sparc64/kernel/setup.c Tue Mar 4 19:30:07 2003 +++ b/arch/sparc64/kernel/setup.c Tue Mar 4 19:30:07 2003 @@ -688,6 +688,7 @@ sparc64_cpus = kmalloc(NR_CPUS * sizeof(struct cpu), GFP_KERNEL); if (!sparc64_cpus) return -ENOMEM; + memset(sparc64_cpus, 0, NR_CPUS * sizeof(struct cpu)); for (i = 0; i < NR_CPUS; i++) { if (cpu_possible(i)) register_cpu(&sparc64_cpus[i], i, NULL); diff -Nru a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c --- a/arch/sparc64/kernel/sparc64_ksyms.c Tue Mar 4 19:30:13 2003 +++ b/arch/sparc64/kernel/sparc64_ksyms.c Tue Mar 4 19:30:13 2003 @@ -114,6 +114,8 @@ extern unsigned long phys_base; extern unsigned long pfn_base; +extern unsigned int sys_call_table[]; + /* used by various drivers */ #ifdef CONFIG_SMP #ifndef CONFIG_DEBUG_SPINLOCK @@ -374,3 +376,6 @@ /* for ns8703 */ EXPORT_SYMBOL(ns87303_lock); + +/* for solaris compat module */ +EXPORT_SYMBOL_GPL(sys_call_table); diff -Nru a/arch/sparc64/kernel/time.c b/arch/sparc64/kernel/time.c --- a/arch/sparc64/kernel/time.c Tue Mar 4 19:30:08 2003 +++ b/arch/sparc64/kernel/time.c Tue Mar 4 19:30:08 2003 @@ -47,7 +47,7 @@ extern unsigned long wall_jiffies; -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; static unsigned long mstk48t08_regs = 0UL; static unsigned long mstk48t59_regs = 0UL; diff -Nru a/arch/sparc64/kernel/traps.c b/arch/sparc64/kernel/traps.c --- a/arch/sparc64/kernel/traps.c Tue Mar 4 19:30:14 2003 +++ b/arch/sparc64/kernel/traps.c Tue Mar 4 19:30:14 2003 @@ -571,7 +571,7 @@ unsigned long flush_linesize = ecache_flush_linesize; unsigned long flush_size = ecache_flush_size; - /* Run through the whole cache to guarentee the timed loop + /* Run through the whole cache to guarantee the timed loop * is really displacing cache lines. */ __asm__ __volatile__("1: subcc %0, %4, %0\n\t" diff -Nru a/arch/sparc64/kernel/us3_cpufreq.c b/arch/sparc64/kernel/us3_cpufreq.c --- a/arch/sparc64/kernel/us3_cpufreq.c Tue Mar 4 19:30:04 2003 +++ b/arch/sparc64/kernel/us3_cpufreq.c Tue Mar 4 19:30:04 2003 @@ -186,12 +186,16 @@ set_cpus_allowed(current, cpus_allowed); } -static int us3freq_setpolicy(struct cpufreq_policy *policy) +static int us3freq_target(struct cpufreq_policy *policy, + unsigned int target_freq, + unsigned int relation) { unsigned int new_index = 0; - if (cpufreq_frequency_table_setpolicy(policy, + if (cpufreq_frequency_table_target(policy, &us3_freq_table[policy->cpu].table[0], + target_freq, + relation, &new_index)) return -EINVAL; @@ -224,6 +228,7 @@ policy->policy = CPUFREQ_POLICY_PERFORMANCE; policy->cpuinfo.transition_latency = 0; + policy->cur = clock_tick; return cpufreq_frequency_table_cpuinfo(policy, table); } @@ -268,7 +273,7 @@ (NR_CPUS * sizeof(struct us3_freq_percpu_info))); driver->verify = us3freq_verify; - driver->setpolicy = us3freq_setpolicy; + driver->target = us3freq_target; driver->init = us3freq_cpu_init; driver->exit = us3freq_cpu_exit; strcpy(driver->name, "UltraSPARC-III"); diff -Nru a/arch/sparc64/lib/Makefile b/arch/sparc64/lib/Makefile --- a/arch/sparc64/lib/Makefile Tue Mar 4 19:30:04 2003 +++ b/arch/sparc64/lib/Makefile Tue Mar 4 19:30:04 2003 @@ -3,7 +3,7 @@ # EXTRA_AFLAGS := -ansi -CFLAGS += -Werror +EXTRA_CFLAGS := -Werror L_TARGET = lib.a obj-y := PeeCeeI.o blockops.o debuglocks.o strlen.o strncmp.o \ diff -Nru a/arch/sparc64/lib/U3copy_from_user.S b/arch/sparc64/lib/U3copy_from_user.S --- a/arch/sparc64/lib/U3copy_from_user.S Tue Mar 4 19:30:05 2003 +++ b/arch/sparc64/lib/U3copy_from_user.S Tue Mar 4 19:30:05 2003 @@ -416,7 +416,7 @@ 2: VISEntryHalf ! MS+MS - /* Compute (len - (len % 8)) into %g2. This is guarenteed + /* Compute (len - (len % 8)) into %g2. This is guaranteed * to be nonzero. */ andn %o2, 0x7, %g2 ! A0 Group @@ -425,7 +425,7 @@ * one 8-byte longword past the end of src. It actually * does not, as %g2 is subtracted as loads are done from * src, so we always stop before running off the end. - * Also, we are guarenteed to have at least 0x10 bytes + * Also, we are guaranteed to have at least 0x10 bytes * to move here. */ sub %g2, 0x8, %g2 ! A0 Group (reg-dep) diff -Nru a/arch/sparc64/lib/U3copy_in_user.S b/arch/sparc64/lib/U3copy_in_user.S --- a/arch/sparc64/lib/U3copy_in_user.S Tue Mar 4 19:30:07 2003 +++ b/arch/sparc64/lib/U3copy_in_user.S Tue Mar 4 19:30:07 2003 @@ -447,7 +447,7 @@ 2: VISEntryHalf ! MS+MS - /* Compute (len - (len % 8)) into %g2. This is guarenteed + /* Compute (len - (len % 8)) into %g2. This is guaranteed * to be nonzero. */ andn %o2, 0x7, %g2 ! A0 Group @@ -456,7 +456,7 @@ * one 8-byte longword past the end of src. It actually * does not, as %g2 is subtracted as loads are done from * src, so we always stop before running off the end. - * Also, we are guarenteed to have at least 0x10 bytes + * Also, we are guaranteed to have at least 0x10 bytes * to move here. */ sub %g2, 0x8, %g2 ! A0 Group (reg-dep) diff -Nru a/arch/sparc64/lib/U3copy_to_user.S b/arch/sparc64/lib/U3copy_to_user.S --- a/arch/sparc64/lib/U3copy_to_user.S Tue Mar 4 19:30:03 2003 +++ b/arch/sparc64/lib/U3copy_to_user.S Tue Mar 4 19:30:03 2003 @@ -463,7 +463,7 @@ 2: VISEntryHalf ! MS+MS - /* Compute (len - (len % 8)) into %g2. This is guarenteed + /* Compute (len - (len % 8)) into %g2. This is guaranteed * to be nonzero. */ andn %o2, 0x7, %g2 ! A0 Group @@ -472,7 +472,7 @@ * one 8-byte longword past the end of src. It actually * does not, as %g2 is subtracted as loads are done from * src, so we always stop before running off the end. - * Also, we are guarenteed to have at least 0x10 bytes + * Also, we are guaranteed to have at least 0x10 bytes * to move here. */ sub %g2, 0x8, %g2 ! A0 Group (reg-dep) diff -Nru a/arch/sparc64/lib/U3memcpy.S b/arch/sparc64/lib/U3memcpy.S --- a/arch/sparc64/lib/U3memcpy.S Tue Mar 4 19:30:14 2003 +++ b/arch/sparc64/lib/U3memcpy.S Tue Mar 4 19:30:14 2003 @@ -344,7 +344,7 @@ 2: VISEntryHalf ! MS+MS - /* Compute (len - (len % 8)) into %g2. This is guarenteed + /* Compute (len - (len % 8)) into %g2. This is guaranteed * to be nonzero. */ andn %o2, 0x7, %g2 ! A0 Group @@ -353,7 +353,7 @@ * one 8-byte longword past the end of src. It actually * does not, as %g2 is subtracted as loads are done from * src, so we always stop before running off the end. - * Also, we are guarenteed to have at least 0x10 bytes + * Also, we are guaranteed to have at least 0x10 bytes * to move here. */ sub %g2, 0x8, %g2 ! A0 Group (reg-dep) diff -Nru a/arch/sparc64/mm/Makefile b/arch/sparc64/mm/Makefile --- a/arch/sparc64/mm/Makefile Tue Mar 4 19:30:12 2003 +++ b/arch/sparc64/mm/Makefile Tue Mar 4 19:30:12 2003 @@ -3,7 +3,7 @@ # EXTRA_AFLAGS := -ansi -CFLAGS += -Werror +EXTRA_CFLAGS := -Werror obj-y := ultra.o fault.o init.o generic.o extable.o diff -Nru a/arch/sparc64/mm/hugetlbpage.c b/arch/sparc64/mm/hugetlbpage.c --- a/arch/sparc64/mm/hugetlbpage.c Tue Mar 4 19:30:11 2003 +++ b/arch/sparc64/mm/hugetlbpage.c Tue Mar 4 19:30:11 2003 @@ -25,6 +25,7 @@ extern long htlbpagemem; static void zap_hugetlb_resources(struct vm_area_struct *); +void free_huge_page(struct page *page); #define MAX_ID 32 struct htlbpagekey { @@ -64,6 +65,7 @@ spin_unlock(&htlbpage_lock); set_page_count(page, 1); + page->lru.prev = (void *)free_huge_page; memset(page_address(page), 0, HPAGE_SIZE); return page; diff -Nru a/arch/sparc64/prom/Makefile b/arch/sparc64/prom/Makefile --- a/arch/sparc64/prom/Makefile Tue Mar 4 19:30:13 2003 +++ b/arch/sparc64/prom/Makefile Tue Mar 4 19:30:13 2003 @@ -4,7 +4,7 @@ # EXTRA_AFLAGS := -ansi -CFLAGS += -Werror +EXTRA_CFLAGS := -Werror L_TARGET = lib.a obj-y := bootstr.o devops.o init.o memory.o misc.o \ diff -Nru a/arch/sparc64/prom/misc.c b/arch/sparc64/prom/misc.c --- a/arch/sparc64/prom/misc.c Tue Mar 4 19:30:12 2003 +++ b/arch/sparc64/prom/misc.c Tue Mar 4 19:30:12 2003 @@ -142,7 +142,7 @@ return prom_prev; } -/* Install Linux trap table so PROM uses that instead of it's own. */ +/* Install Linux trap table so PROM uses that instead of its own. */ void prom_set_trap_table(unsigned long tba) { p1275_cmd("SUNW,set-trap-table", P1275_INOUT(1, 0), tba); diff -Nru a/arch/sparc64/solaris/entry64.S b/arch/sparc64/solaris/entry64.S --- a/arch/sparc64/solaris/entry64.S Tue Mar 4 19:30:03 2003 +++ b/arch/sparc64/solaris/entry64.S Tue Mar 4 19:30:03 2003 @@ -16,6 +16,7 @@ #include #include #include +#include #include "conv.h" diff -Nru a/arch/um/kernel/irq.c b/arch/um/kernel/irq.c --- a/arch/um/kernel/irq.c Tue Mar 4 19:30:12 2003 +++ b/arch/um/kernel/irq.c Tue Mar 4 19:30:12 2003 @@ -45,7 +45,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ #if CONFIG_X86 diff -Nru a/arch/v850/kernel/irq.c b/arch/v850/kernel/irq.c --- a/arch/v850/kernel/irq.c Tue Mar 4 19:30:12 2003 +++ b/arch/v850/kernel/irq.c Tue Mar 4 19:30:12 2003 @@ -48,7 +48,7 @@ { /* * 'what should we do if we get a hw irq event on an illegal vector'. - * each architecture has to answer this themselves, it doesnt deserve + * each architecture has to answer this themselves, it doesn't deserve * a generic callback i think. */ printk("received IRQ %d with unknown interrupt type\n", irq); diff -Nru a/arch/v850/kernel/ma.c b/arch/v850/kernel/ma.c --- a/arch/v850/kernel/ma.c Tue Mar 4 19:30:04 2003 +++ b/arch/v850/kernel/ma.c Tue Mar 4 19:30:04 2003 @@ -61,7 +61,7 @@ specific chips may have more). */ if (chan < 2) { unsigned bits = 0x3 << (chan * 3); - /* Specify that the relevent pins on the chip should do + /* Specify that the relevant pins on the chip should do serial I/O, not direct I/O. */ MA_PORT4_PMC |= bits; /* Specify that we're using the UART, not the CSI device. */ diff -Nru a/arch/v850/kernel/rte_cb_multi.c b/arch/v850/kernel/rte_cb_multi.c --- a/arch/v850/kernel/rte_cb_multi.c Tue Mar 4 19:30:05 2003 +++ b/arch/v850/kernel/rte_cb_multi.c Tue Mar 4 19:30:05 2003 @@ -67,7 +67,7 @@ if ((word & 0xFC0) == 0x780) { /* A `jr' insn, fix up its offset (and yes, the - wierd half-word swapping is intentional). */ + weird half-word swapping is intentional). */ unsigned short hi = word & 0xFFFF; unsigned short lo = word >> 16; unsigned long udisp22 diff -Nru a/arch/v850/kernel/rte_ma1_cb.c b/arch/v850/kernel/rte_ma1_cb.c --- a/arch/v850/kernel/rte_ma1_cb.c Tue Mar 4 19:30:12 2003 +++ b/arch/v850/kernel/rte_ma1_cb.c Tue Mar 4 19:30:12 2003 @@ -93,7 +93,7 @@ /* Turn on the timer. */ NB85E_TIMER_C_TMCC0 (tc) |= NB85E_TIMER_C_TMCC0_CAE; - /* Make sure the relevent port0/port1 pins are assigned + /* Make sure the relevant port0/port1 pins are assigned interrupt duty. We used INTP001-INTP011 (don't screw with INTP000 because the monitor uses it). */ MA_PORT0_PMC |= 0x4; /* P02 (INTP001) in IRQ mode. */ diff -Nru a/arch/v850/kernel/time.c b/arch/v850/kernel/time.c --- a/arch/v850/kernel/time.c Tue Mar 4 19:30:11 2003 +++ b/arch/v850/kernel/time.c Tue Mar 4 19:30:11 2003 @@ -25,7 +25,7 @@ #include "mach.h" -u64 jiffies_64; +u64 jiffies_64 = INITIAL_JIFFIES; #define TICK_SIZE (tick_nsec / 1000) diff -Nru a/arch/x86_64/ia32/ia32_ioctl.c b/arch/x86_64/ia32/ia32_ioctl.c --- a/arch/x86_64/ia32/ia32_ioctl.c Tue Mar 4 19:30:09 2003 +++ b/arch/x86_64/ia32/ia32_ioctl.c Tue Mar 4 19:30:09 2003 @@ -3196,7 +3196,7 @@ * * But how to keep track of these kernel buffers? We'd need to either * keep track of them in some table _or_ know about usbdevicefs internals - * (ie. the exact layout of it's file private, which is actually defined + * (ie. the exact layout of its file private, which is actually defined * in linux/usbdevice_fs.h, the layout of the async queues are private to * devio.c) * diff -Nru a/arch/x86_64/kernel/apic.c b/arch/x86_64/kernel/apic.c --- a/arch/x86_64/kernel/apic.c Tue Mar 4 19:30:04 2003 +++ b/arch/x86_64/kernel/apic.c Tue Mar 4 19:30:04 2003 @@ -292,7 +292,7 @@ __error_in_apic_c(); /* - * Double-check wether this APIC is really registered. + * Double-check whether this APIC is really registered. * This is meaningless in clustered apic mode, so we skip it. */ if (!clustered_apic_mode && @@ -948,7 +948,7 @@ /* * Local APIC timer interrupt. This is the most natural way for doing * local interrupts, but local timer interrupts can be emulated by - * broadcast interrupts too. [in case the hw doesnt support APIC timers] + * broadcast interrupts too. [in case the hw doesn't support APIC timers] * * [ if a single-CPU system runs an SMP kernel then we call the local * interrupt as well. Thus we cannot inline the local irq ... ] diff -Nru a/arch/x86_64/kernel/bluesmoke.c b/arch/x86_64/kernel/bluesmoke.c --- a/arch/x86_64/kernel/bluesmoke.c Tue Mar 4 19:30:13 2003 +++ b/arch/x86_64/kernel/bluesmoke.c Tue Mar 4 19:30:13 2003 @@ -111,16 +111,12 @@ { u32 low, high; int i; - unsigned int *cpu = info; - BUG_ON (*cpu != smp_processor_id()); - - preempt_disable(); for (i=0; isize = mincount; wmb(); if (reload) { - load_LDT(pc); #ifdef CONFIG_SMP preempt_disable(); + load_LDT(pc); if (current->mm->cpu_vm_mask != (1<>10); return 0; diff -Nru a/arch/x86_64/kernel/smp.c b/arch/x86_64/kernel/smp.c --- a/arch/x86_64/kernel/smp.c Tue Mar 4 19:30:05 2003 +++ b/arch/x86_64/kernel/smp.c Tue Mar 4 19:30:05 2003 @@ -328,7 +328,7 @@ preempt_enable(); } -static inline void do_flush_tlb_all_local(void) +static void do_flush_tlb_all(void* info) { unsigned long cpu = smp_processor_id(); @@ -337,18 +337,9 @@ leave_mm(cpu); } -static void flush_tlb_all_ipi(void* info) -{ - do_flush_tlb_all_local(); -} - void flush_tlb_all(void) { - preempt_disable(); - smp_call_function (flush_tlb_all_ipi,0,1,1); - - do_flush_tlb_all_local(); - preempt_enable(); + on_each_cpu(do_flush_tlb_all, 0, 1, 1); } void smp_kdb_stop(void) diff -Nru a/arch/x86_64/kernel/smpboot.c b/arch/x86_64/kernel/smpboot.c --- a/arch/x86_64/kernel/smpboot.c Tue Mar 4 19:30:14 2003 +++ b/arch/x86_64/kernel/smpboot.c Tue Mar 4 19:30:14 2003 @@ -104,7 +104,7 @@ /* * TSC synchronization. * - * We first check wether all CPUs have their TSC's synchronized, + * We first check whether all CPUs have their TSC's synchronized, * then we print a warning if not, and always resync. */ @@ -774,7 +774,7 @@ } /* - * If we couldnt find an SMP configuration at boot time, + * If we couldn't find an SMP configuration at boot time, * get out of here now! */ if (!smp_found_config) { diff -Nru a/arch/x86_64/kernel/time.c b/arch/x86_64/kernel/time.c --- a/arch/x86_64/kernel/time.c Tue Mar 4 19:30:11 2003 +++ b/arch/x86_64/kernel/time.c Tue Mar 4 19:30:11 2003 @@ -30,7 +30,7 @@ #include #endif -u64 jiffies_64; +u64 jiffies_64; extern int using_apic_timer; diff -Nru a/arch/x86_64/mm/ioremap.c b/arch/x86_64/mm/ioremap.c --- a/arch/x86_64/mm/ioremap.c Tue Mar 4 19:30:13 2003 +++ b/arch/x86_64/mm/ioremap.c Tue Mar 4 19:30:13 2003 @@ -205,6 +205,7 @@ iounmap(p); p = NULL; } + global_flush_tlb(); } return p; @@ -226,6 +227,7 @@ change_page_attr(virt_to_page(__va(p->phys_addr)), p->size >> PAGE_SHIFT, PAGE_KERNEL); + global_flush_tlb(); } kfree(p); } diff -Nru a/arch/x86_64/mm/pageattr.c b/arch/x86_64/mm/pageattr.c --- a/arch/x86_64/mm/pageattr.c Tue Mar 4 19:30:08 2003 +++ b/arch/x86_64/mm/pageattr.c Tue Mar 4 19:30:08 2003 @@ -123,12 +123,7 @@ static inline void flush_map(unsigned long address) { - preempt_disable(); -#ifdef CONFIG_SMP - smp_call_function(flush_kernel_map, (void *)address, 1, 1); -#endif - flush_kernel_map((void *)address); - preempt_enable(); + on_each_cpu(flush_kernel_map, (void *)address, 1, 1); } struct deferred_page { diff -Nru a/drivers/acorn/block/fd1772.c b/drivers/acorn/block/fd1772.c --- a/drivers/acorn/block/fd1772.c Tue Mar 4 19:30:05 2003 +++ b/drivers/acorn/block/fd1772.c Tue Mar 4 19:30:05 2003 @@ -1081,7 +1081,7 @@ MotorOn = 1; START_TIMEOUT(); /* we must wait for the IRQ here, because the ST-DMA is - * released immediatly afterwards and the interrupt may be + * released immediately afterwards and the interrupt may be * delivered to the wrong driver. */ } diff -Nru a/drivers/acorn/block/mfmhd.c b/drivers/acorn/block/mfmhd.c --- a/drivers/acorn/block/mfmhd.c Tue Mar 4 19:30:05 2003 +++ b/drivers/acorn/block/mfmhd.c Tue Mar 4 19:30:05 2003 @@ -406,7 +406,7 @@ outw(command, MFM_COMMAND); status = inw(MFM_STATUS); - DBG("issue_command: status immediatly after command issue: %02X:\n ", status >> 8); + DBG("issue_command: status immediately after command issue: %02X:\n ", status >> 8); } static void wait_for_completion(void) @@ -451,7 +451,7 @@ return; }; - /* OK so what ever happend its not an error, now I reckon we are left between + /* OK so what ever happened it's not an error, now I reckon we are left between a choice of command end or some data which is ready to be collected */ /* I think we have to transfer data while the interrupt line is on and its not any other type of interrupt */ diff -Nru a/drivers/acorn/net/ether3.c b/drivers/acorn/net/ether3.c --- a/drivers/acorn/net/ether3.c Tue Mar 4 19:30:14 2003 +++ b/drivers/acorn/net/ether3.c Tue Mar 4 19:30:14 2003 @@ -101,7 +101,7 @@ /* * ether3 read/write. Slow things down a bit... - * The SEEQ8005 doesn't like us writing to it's registers + * The SEEQ8005 doesn't like us writing to its registers * too quickly. */ static inline void ether3_outb(int v, const int r) @@ -304,7 +304,7 @@ /* * There is a problem with the NQ8005 in that it occasionally loses the * last two bytes. To get round this problem, we receive the CRC as - * well. That way, if we do loose the last two, then it doesn't matter. + * well. That way, if we do lose the last two, then it doesn't matter. */ ether3_outw(priv->regs.config1 | CFG1_TRANSEND, REG_CONFIG1); ether3_outw((TX_END>>8) - 1, REG_BUFWIN); diff -Nru a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig --- a/drivers/acpi/Kconfig Tue Mar 4 19:30:14 2003 +++ b/drivers/acpi/Kconfig Tue Mar 4 19:30:14 2003 @@ -6,6 +6,7 @@ config ACPI bool "ACPI Support" if X86 + depends on !X86_VISWS default y if IA64 && (!IA64_HP_SIM || IA64_SGI_SN) ---help--- Advanced Configuration and Power Interface (ACPI) support for diff -Nru a/drivers/acpi/acpi_ksyms.c b/drivers/acpi/acpi_ksyms.c --- a/drivers/acpi/acpi_ksyms.c Tue Mar 4 19:30:06 2003 +++ b/drivers/acpi/acpi_ksyms.c Tue Mar 4 19:30:06 2003 @@ -76,6 +76,7 @@ EXPORT_SYMBOL(acpi_release_global_lock); EXPORT_SYMBOL(acpi_get_current_resources); EXPORT_SYMBOL(acpi_get_possible_resources); +EXPORT_SYMBOL(acpi_walk_resources); EXPORT_SYMBOL(acpi_set_current_resources); EXPORT_SYMBOL(acpi_enable_event); EXPORT_SYMBOL(acpi_disable_event); @@ -86,6 +87,7 @@ EXPORT_SYMBOL(acpi_get_register); EXPORT_SYMBOL(acpi_set_register); EXPORT_SYMBOL(acpi_enter_sleep_state); +EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios); EXPORT_SYMBOL(acpi_get_system_info); EXPORT_SYMBOL(acpi_get_devices); diff -Nru a/drivers/acpi/dispatcher/dsobject.c b/drivers/acpi/dispatcher/dsobject.c --- a/drivers/acpi/dispatcher/dsobject.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/dispatcher/dsobject.c Tue Mar 4 19:30:04 2003 @@ -396,7 +396,7 @@ return_ACPI_STATUS (status); } - /* Re-type the object according to it's argument */ + /* Re-type the object according to its argument */ node->type = ACPI_GET_OBJECT_TYPE (obj_desc); diff -Nru a/drivers/acpi/ec.c b/drivers/acpi/ec.c --- a/drivers/acpi/ec.c Tue Mar 4 19:30:09 2003 +++ b/drivers/acpi/ec.c Tue Mar 4 19:30:09 2003 @@ -644,15 +644,46 @@ } +static acpi_status +acpi_ec_io_ports ( + struct acpi_resource *resource, + void *context) +{ + struct acpi_ec *ec = (struct acpi_ec *) context; + struct acpi_generic_address *addr; + + if (resource->id != ACPI_RSTYPE_IO) { + return AE_OK; + } + + /* + * The first address region returned is the data port, and + * the second address region returned is the status/command + * port. + */ + if (ec->data_addr.register_bit_width == 0) { + addr = &ec->data_addr; + } else if (ec->command_addr.register_bit_width == 0) { + addr = &ec->command_addr; + } else { + return AE_CTRL_TERMINATE; + } + + addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO; + addr->register_bit_width = 8; + addr->register_bit_offset = 0; + addr->address = resource->data.io.min_base_address; + + return AE_OK; +} + + static int acpi_ec_start ( struct acpi_device *device) { - int result = 0; acpi_status status = AE_OK; struct acpi_ec *ec = NULL; - struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; - struct acpi_resource *resource = NULL; ACPI_FUNCTION_TRACE("acpi_ec_start"); @@ -667,33 +698,13 @@ /* * Get I/O port addresses. Convert to GAS format. */ - status = acpi_get_current_resources(ec->handle, &buffer); - if (ACPI_FAILURE(status)) { + status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS, + acpi_ec_io_ports, ec); + if (ACPI_FAILURE(status) || ec->command_addr.register_bit_width == 0) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error getting I/O port addresses")); return_VALUE(-ENODEV); } - resource = (struct acpi_resource *) buffer.pointer; - if (!resource || (resource->id != ACPI_RSTYPE_IO)) { - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid or missing resource\n")); - result = -ENODEV; - goto end; - } - ec->data_addr.address_space_id = ACPI_ADR_SPACE_SYSTEM_IO; - ec->data_addr.register_bit_width = 8; - ec->data_addr.register_bit_offset = 0; - ec->data_addr.address = resource->data.io.min_base_address; - - resource = ACPI_NEXT_RESOURCE(resource); - if (!resource || (resource->id != ACPI_RSTYPE_IO)) { - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid or missing resource\n")); - result = -ENODEV; - goto end; - } - ec->command_addr.address_space_id = ACPI_ADR_SPACE_SYSTEM_IO; - ec->command_addr.register_bit_width = 8; - ec->command_addr.register_bit_offset = 0; - ec->command_addr.address = resource->data.io.min_base_address; ec->status_addr = ec->command_addr; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n", @@ -706,8 +717,7 @@ status = acpi_install_gpe_handler(ec->gpe_bit, ACPI_EVENT_EDGE_TRIGGERED, &acpi_ec_gpe_handler, ec); if (ACPI_FAILURE(status)) { - result = -ENODEV; - goto end; + return_VALUE(-ENODEV); } status = acpi_install_address_space_handler (ec->handle, @@ -715,13 +725,10 @@ &acpi_ec_space_setup, ec); if (ACPI_FAILURE(status)) { acpi_remove_gpe_handler(ec->gpe_bit, &acpi_ec_gpe_handler); - result = -ENODEV; - goto end; + return_VALUE(-ENODEV); } -end: - acpi_os_free(buffer.pointer); - return_VALUE(result); + return_VALUE(AE_OK); } diff -Nru a/drivers/acpi/events/Makefile b/drivers/acpi/events/Makefile --- a/drivers/acpi/events/Makefile Tue Mar 4 19:30:03 2003 +++ b/drivers/acpi/events/Makefile Tue Mar 4 19:30:03 2003 @@ -4,6 +4,6 @@ obj-y := evevent.o evregion.o evsci.o evxfevnt.o \ evmisc.o evrgnini.o evxface.o evxfregn.o \ - evgpe.o + evgpe.o evgpeblk.o EXTRA_CFLAGS += $(ACPI_CFLAGS) diff -Nru a/drivers/acpi/events/evevent.c b/drivers/acpi/events/evevent.c --- a/drivers/acpi/events/evevent.c Tue Mar 4 19:30:13 2003 +++ b/drivers/acpi/events/evevent.c Tue Mar 4 19:30:13 2003 @@ -79,7 +79,7 @@ /* * Initialize the Fixed and General Purpose acpi_events prior. This is - * done prior to enabling SCIs to prevent interrupts from occuring + * done prior to enabling SCIs to prevent interrupts from occurring * before handers are installed. */ status = acpi_ev_fixed_event_initialize (); @@ -110,7 +110,7 @@ * * RETURN: Status * - * DESCRIPTION: Install handlers for the SCI, Global Lock, and GPEs. + * DESCRIPTION: Install interrupt handlers for the SCI and Global Lock * ******************************************************************************/ @@ -130,16 +130,6 @@ if (ACPI_FAILURE (status)) { ACPI_REPORT_ERROR (( "Unable to install System Control Interrupt Handler, %s\n", - acpi_format_exception (status))); - return_ACPI_STATUS (status); - } - - /* Install handlers for control method GPE handlers (_Lxx, _Exx) */ - - status = acpi_ev_init_gpe_control_methods (); - if (ACPI_FAILURE (status)) { - ACPI_REPORT_ERROR (( - "Unable to initialize GPE control methods, %s\n", acpi_format_exception (status))); return_ACPI_STATUS (status); } diff -Nru a/drivers/acpi/events/evgpe.c b/drivers/acpi/events/evgpe.c --- a/drivers/acpi/events/evgpe.c Tue Mar 4 19:30:10 2003 +++ b/drivers/acpi/events/evgpe.c Tue Mar 4 19:30:10 2003 @@ -51,401 +51,54 @@ /******************************************************************************* * - * FUNCTION: acpi_ev_gpe_initialize + * FUNCTION: acpi_ev_get_gpe_event_info * - * PARAMETERS: None - * - * RETURN: Status + * PARAMETERS: gpe_number - Raw GPE number * - * DESCRIPTION: Initialize the GPE data structures + * RETURN: None. * - ******************************************************************************/ - -acpi_status -acpi_ev_gpe_initialize (void) -{ - acpi_native_uint i; - acpi_native_uint j; - u32 gpe_block; - u32 gpe_register; - u32 gpe_number_index; - u32 gpe_number; - struct acpi_gpe_register_info *gpe_register_info; - acpi_status status; - - - ACPI_FUNCTION_TRACE ("ev_gpe_initialize"); - - - /* - * Initialize the GPE Block globals - * - * Why the GPE register block lengths are divided by 2: From the ACPI Spec, - * section "General-Purpose Event Registers", we have: - * - * "Each register block contains two registers of equal length - * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the - * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN - * The length of the GPE1_STS and GPE1_EN registers is equal to - * half the GPE1_LEN. If a generic register block is not supported - * then its respective block pointer and block length values in the - * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need - * to be the same size." - */ - acpi_gbl_gpe_block_info[0].register_count = 0; - acpi_gbl_gpe_block_info[1].register_count = 0; - - acpi_gbl_gpe_block_info[0].block_address = &acpi_gbl_FADT->xgpe0_blk; - acpi_gbl_gpe_block_info[1].block_address = &acpi_gbl_FADT->xgpe1_blk; - - acpi_gbl_gpe_block_info[0].block_base_number = 0; - acpi_gbl_gpe_block_info[1].block_base_number = acpi_gbl_FADT->gpe1_base; - - - /* - * Determine the maximum GPE number for this machine. - * - * Note: both GPE0 and GPE1 are optional, and either can exist without - * the other. - * If EITHER the register length OR the block address are zero, then that - * particular block is not supported. - */ - if (acpi_gbl_FADT->xgpe0_blk.register_bit_width && acpi_gbl_FADT->xgpe0_blk.address) { - /* GPE block 0 exists (has both length and address > 0) */ - - acpi_gbl_gpe_block_info[0].register_count = (u16) (acpi_gbl_FADT->xgpe0_blk.register_bit_width / (ACPI_GPE_REGISTER_WIDTH * 2)); - acpi_gbl_gpe_number_max = (acpi_gbl_gpe_block_info[0].register_count * ACPI_GPE_REGISTER_WIDTH) - 1; - } - - if (acpi_gbl_FADT->xgpe1_blk.register_bit_width && acpi_gbl_FADT->xgpe1_blk.address) { - /* GPE block 1 exists (has both length and address > 0) */ - - acpi_gbl_gpe_block_info[1].register_count = (u16) (acpi_gbl_FADT->xgpe1_blk.register_bit_width / (ACPI_GPE_REGISTER_WIDTH * 2)); - - /* Check for GPE0/GPE1 overlap (if both banks exist) */ - - if ((acpi_gbl_gpe_block_info[0].register_count) && - (acpi_gbl_gpe_number_max >= acpi_gbl_FADT->gpe1_base)) { - ACPI_REPORT_ERROR (( - "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1\n", - acpi_gbl_gpe_number_max, acpi_gbl_FADT->gpe1_base, - acpi_gbl_FADT->gpe1_base + ((acpi_gbl_gpe_block_info[1].register_count * ACPI_GPE_REGISTER_WIDTH) - 1))); - - /* Ignore GPE1 block by setting the register count to zero */ - - acpi_gbl_gpe_block_info[1].register_count = 0; - } - else { - /* - * GPE0 and GPE1 do not have to be contiguous in the GPE number space, - * But, GPE0 always starts at zero. - */ - acpi_gbl_gpe_number_max = acpi_gbl_FADT->gpe1_base + - ((acpi_gbl_gpe_block_info[1].register_count * ACPI_GPE_REGISTER_WIDTH) - 1); - } - } - - /* Exit if there are no GPE registers */ - - acpi_gbl_gpe_register_count = acpi_gbl_gpe_block_info[0].register_count + - acpi_gbl_gpe_block_info[1].register_count; - if (!acpi_gbl_gpe_register_count) { - /* GPEs are not required by ACPI, this is OK */ - - ACPI_REPORT_INFO (("There are no GPE blocks defined in the FADT\n")); - return_ACPI_STATUS (AE_OK); - } - - /* Check for Max GPE number out-of-range */ - - if (acpi_gbl_gpe_number_max > ACPI_GPE_MAX) { - ACPI_REPORT_ERROR (("Maximum GPE number from FADT is too large: 0x%X\n", - acpi_gbl_gpe_number_max)); - return_ACPI_STATUS (AE_BAD_VALUE); - } - - /* Allocate the GPE number-to-index translation table */ - - acpi_gbl_gpe_number_to_index = ACPI_MEM_CALLOCATE ( - sizeof (struct acpi_gpe_index_info) * - ((acpi_size) acpi_gbl_gpe_number_max + 1)); - if (!acpi_gbl_gpe_number_to_index) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "Could not allocate the gpe_number_to_index table\n")); - return_ACPI_STATUS (AE_NO_MEMORY); - } - - /* Set the Gpe index table to GPE_INVALID */ - - ACPI_MEMSET (acpi_gbl_gpe_number_to_index, (int) ACPI_GPE_INVALID, - sizeof (struct acpi_gpe_index_info) * ((acpi_size) acpi_gbl_gpe_number_max + 1)); - - /* Allocate the GPE register information block */ - - acpi_gbl_gpe_register_info = ACPI_MEM_CALLOCATE ( - (acpi_size) acpi_gbl_gpe_register_count * - sizeof (struct acpi_gpe_register_info)); - if (!acpi_gbl_gpe_register_info) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "Could not allocate the gpe_register_info table\n")); - goto error_exit1; - } - - /* - * Allocate the GPE dispatch handler block. There are eight distinct GPEs - * per register. Initialization to zeros is sufficient. - */ - acpi_gbl_gpe_number_info = ACPI_MEM_CALLOCATE ( - ((acpi_size) acpi_gbl_gpe_register_count * ACPI_GPE_REGISTER_WIDTH) * - sizeof (struct acpi_gpe_number_info)); - if (!acpi_gbl_gpe_number_info) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not allocate the gpe_number_info table\n")); - goto error_exit2; - } - - /* - * Initialize the GPE information and validation tables. A goal of these - * tables is to hide the fact that there are two separate GPE register sets - * in a given gpe hardware block, the status registers occupy the first half, - * and the enable registers occupy the second half. Another goal is to hide - * the fact that there may be multiple GPE hardware blocks. - */ - gpe_register = 0; - gpe_number_index = 0; - - for (gpe_block = 0; gpe_block < ACPI_MAX_GPE_BLOCKS; gpe_block++) { - for (i = 0; i < acpi_gbl_gpe_block_info[gpe_block].register_count; i++) { - gpe_register_info = &acpi_gbl_gpe_register_info[gpe_register]; - - /* Init the Register info for this entire GPE register (8 GPEs) */ - - gpe_register_info->base_gpe_number = (u8) (acpi_gbl_gpe_block_info[gpe_block].block_base_number - + (i * ACPI_GPE_REGISTER_WIDTH)); - - ACPI_STORE_ADDRESS (gpe_register_info->status_address.address, - (acpi_gbl_gpe_block_info[gpe_block].block_address->address - + i)); - - ACPI_STORE_ADDRESS (gpe_register_info->enable_address.address, - (acpi_gbl_gpe_block_info[gpe_block].block_address->address - + i - + acpi_gbl_gpe_block_info[gpe_block].register_count)); - - gpe_register_info->status_address.address_space_id = acpi_gbl_gpe_block_info[gpe_block].block_address->address_space_id; - gpe_register_info->enable_address.address_space_id = acpi_gbl_gpe_block_info[gpe_block].block_address->address_space_id; - gpe_register_info->status_address.register_bit_width = ACPI_GPE_REGISTER_WIDTH; - gpe_register_info->enable_address.register_bit_width = ACPI_GPE_REGISTER_WIDTH; - gpe_register_info->status_address.register_bit_offset = ACPI_GPE_REGISTER_WIDTH; - gpe_register_info->enable_address.register_bit_offset = ACPI_GPE_REGISTER_WIDTH; - - /* Init the Index mapping info for each GPE number within this register */ - - for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) { - gpe_number = gpe_register_info->base_gpe_number + (u32) j; - acpi_gbl_gpe_number_to_index[gpe_number].number_index = (u8) gpe_number_index; - - acpi_gbl_gpe_number_info[gpe_number_index].bit_mask = acpi_gbl_decode_to8bit[j]; - gpe_number_index++; - } - - /* - * Clear the status/enable registers. Note that status registers - * are cleared by writing a '1', while enable registers are cleared - * by writing a '0'. - */ - status = acpi_hw_low_level_write (ACPI_GPE_REGISTER_WIDTH, 0x00, &gpe_register_info->enable_address, 0); - if (ACPI_FAILURE (status)) { - return_ACPI_STATUS (status); - } - - status = acpi_hw_low_level_write (ACPI_GPE_REGISTER_WIDTH, 0xFF, &gpe_register_info->status_address, 0); - if (ACPI_FAILURE (status)) { - return_ACPI_STATUS (status); - } - - gpe_register++; - } - - if (i) { - /* Dump info about this valid GPE block */ - - ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "GPE Block%d: %X registers at %8.8X%8.8X\n", - (s32) gpe_block, acpi_gbl_gpe_block_info[0].register_count, - ACPI_HIDWORD (acpi_gbl_gpe_block_info[gpe_block].block_address->address), - ACPI_LODWORD (acpi_gbl_gpe_block_info[gpe_block].block_address->address))); - - ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "GPE Block%d defined as GPE%d to GPE%d\n", - (s32) gpe_block, - (u32) acpi_gbl_gpe_block_info[gpe_block].block_base_number, - (u32) (acpi_gbl_gpe_block_info[gpe_block].block_base_number + - ((acpi_gbl_gpe_block_info[gpe_block].register_count * ACPI_GPE_REGISTER_WIDTH) -1)))); - } - } - - return_ACPI_STATUS (AE_OK); - - - /* Error cleanup */ - -error_exit2: - ACPI_MEM_FREE (acpi_gbl_gpe_register_info); - -error_exit1: - ACPI_MEM_FREE (acpi_gbl_gpe_number_to_index); - return_ACPI_STATUS (AE_NO_MEMORY); -} - - -/******************************************************************************* + * DESCRIPTION: Returns the event_info struct + * associated with this GPE. * - * FUNCTION: acpi_ev_save_method_info - * - * PARAMETERS: None - * - * RETURN: None - * - * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a - * control method under the _GPE portion of the namespace. - * Extract the name and GPE type from the object, saving this - * information for quick lookup during GPE dispatch - * - * The name of each GPE control method is of the form: - * "_Lnn" or "_Enn" - * Where: - * L - means that the GPE is level triggered - * E - means that the GPE is edge triggered - * nn - is the GPE number [in HEX] + * TBD: this function will go away when full support of GPE block devices + * is implemented! * ******************************************************************************/ -static acpi_status -acpi_ev_save_method_info ( - acpi_handle obj_handle, - u32 level, - void *obj_desc, - void **return_value) +struct acpi_gpe_event_info * +acpi_ev_get_gpe_event_info ( + u32 gpe_number) { - u32 gpe_number; - struct acpi_gpe_number_info *gpe_number_info; - char name[ACPI_NAME_SIZE + 1]; - u8 type; - acpi_status status; - - - ACPI_FUNCTION_NAME ("ev_save_method_info"); - - - /* Extract the name from the object and convert to a string */ + struct acpi_gpe_block_info *gpe_block; - ACPI_MOVE_UNALIGNED32_TO_32 (name, - &((struct acpi_namespace_node *) obj_handle)->name.integer); - name[ACPI_NAME_SIZE] = 0; - /* - * Edge/Level determination is based on the 2nd character of the method name - */ - switch (name[1]) { - case 'L': - type = ACPI_EVENT_LEVEL_TRIGGERED; - break; - - case 'E': - type = ACPI_EVENT_EDGE_TRIGGERED; - break; + /* Examine GPE Block 0 */ - default: - /* Unknown method type, just ignore it! */ - - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "Unknown GPE method type: %s (name not of form _Lnn or _Enn)\n", - name)); - return (AE_OK); + gpe_block = acpi_gbl_gpe_block_list_head; + if (!gpe_block) { + return (NULL); } - /* Convert the last two characters of the name to the GPE Number */ - - gpe_number = ACPI_STRTOUL (&name[2], NULL, 16); - if (gpe_number == ACPI_UINT32_MAX) { - /* Conversion failed; invalid method, just ignore it */ - - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "Could not extract GPE number from name: %s (name not of form _Lnn or _Enn)\n", - name)); - return (AE_OK); + if ((gpe_number >= gpe_block->block_base_number) && + (gpe_number < gpe_block->block_base_number + (gpe_block->register_count * 8))) { + return (&gpe_block->event_info[gpe_number - gpe_block->block_base_number]); } - /* Get GPE index and ensure that we have a valid GPE number */ - - gpe_number_info = acpi_ev_get_gpe_number_info (gpe_number); - if (!gpe_number_info) { - /* Not valid, all we can do here is ignore it */ + /* Examine GPE Block 1 */ - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, - "GPE number associated with method is not valid %s\n", - name)); - return (AE_OK); + gpe_block = gpe_block->next; + if (!gpe_block) { + return (NULL); } - /* - * Now we can add this information to the gpe_number_info block - * for use during dispatch of this GPE. - */ - gpe_number_info->type = type; - gpe_number_info->method_node = (struct acpi_namespace_node *) obj_handle; - - /* - * Enable the GPE (SCIs should be disabled at this point) - */ - status = acpi_hw_enable_gpe (gpe_number); - if (ACPI_FAILURE (status)) { - return (status); + if ((gpe_number >= gpe_block->block_base_number) && + (gpe_number < gpe_block->block_base_number + (gpe_block->register_count * 8))) { + return (&gpe_block->event_info[gpe_number - gpe_block->block_base_number]); } - ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Registered GPE method %s as GPE number %2.2X\n", - name, gpe_number)); - return (AE_OK); + return (NULL); } - -/******************************************************************************* - * - * FUNCTION: acpi_ev_init_gpe_control_methods - * - * PARAMETERS: None - * - * RETURN: Status - * - * DESCRIPTION: Obtain the control methods associated with the GPEs. - * NOTE: Must be called AFTER namespace initialization! - * - ******************************************************************************/ - -acpi_status -acpi_ev_init_gpe_control_methods (void) -{ - acpi_status status; - - - ACPI_FUNCTION_TRACE ("ev_init_gpe_control_methods"); - - - /* Get a permanent handle to the _GPE object */ - - status = acpi_get_handle (NULL, "\\_GPE", &acpi_gbl_gpe_obj_handle); - if (ACPI_FAILURE (status)) { - return_ACPI_STATUS (status); - } - - /* Traverse the namespace under \_GPE to find all methods there */ - - status = acpi_walk_namespace (ACPI_TYPE_METHOD, acpi_gbl_gpe_obj_handle, - ACPI_UINT32_MAX, acpi_ev_save_method_info, - NULL, NULL); - - return_ACPI_STATUS (status); -} - - /******************************************************************************* * * FUNCTION: acpi_ev_gpe_detect @@ -470,62 +123,74 @@ struct acpi_gpe_register_info *gpe_register_info; u32 in_value; acpi_status status; + struct acpi_gpe_block_info *gpe_block; ACPI_FUNCTION_NAME ("ev_gpe_detect"); - /* - * Read all of the 8-bit GPE status and enable registers - * in both of the register blocks, saving all of it. - * Find all currently active GP events. - */ - for (i = 0; i < acpi_gbl_gpe_register_count; i++) { - gpe_register_info = &acpi_gbl_gpe_register_info[i]; + /* Examine all GPE blocks attached to this interrupt level */ - status = acpi_hw_low_level_read (ACPI_GPE_REGISTER_WIDTH, &in_value, &gpe_register_info->status_address, 0); - gpe_register_info->status = (u8) in_value; - if (ACPI_FAILURE (status)) { - return (ACPI_INTERRUPT_NOT_HANDLED); - } + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + /* + * Read all of the 8-bit GPE status and enable registers + * in this GPE block, saving all of them. + * Find all currently active GP events. + */ + for (i = 0; i < gpe_block->register_count; i++) { + /* Get the next status/enable pair */ - status = acpi_hw_low_level_read (ACPI_GPE_REGISTER_WIDTH, &in_value, &gpe_register_info->enable_address, 0); - gpe_register_info->enable = (u8) in_value; - if (ACPI_FAILURE (status)) { - return (ACPI_INTERRUPT_NOT_HANDLED); - } + gpe_register_info = &gpe_block->register_info[i]; + + status = acpi_hw_low_level_read (ACPI_GPE_REGISTER_WIDTH, &in_value, + &gpe_register_info->status_address, 0); + gpe_register_info->status = (u8) in_value; + if (ACPI_FAILURE (status)) { + return (ACPI_INTERRUPT_NOT_HANDLED); + } - ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS, - "GPE block at %8.8X%8.8X - Values: Enable %02X Status %02X\n", - ACPI_HIDWORD (gpe_register_info->enable_address.address), - ACPI_LODWORD (gpe_register_info->enable_address.address), - gpe_register_info->enable, - gpe_register_info->status)); - - /* First check if there is anything active at all in this register */ - - enabled_status_byte = (u8) (gpe_register_info->status & - gpe_register_info->enable); - if (!enabled_status_byte) { - /* No active GPEs in this register, move on */ + status = acpi_hw_low_level_read (ACPI_GPE_REGISTER_WIDTH, &in_value, + &gpe_register_info->enable_address, 0); + gpe_register_info->enable = (u8) in_value; + if (ACPI_FAILURE (status)) { + return (ACPI_INTERRUPT_NOT_HANDLED); + } - continue; - } + ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS, + "GPE block at %8.8X%8.8X - Values: Enable %02X Status %02X\n", + ACPI_HIDWORD (gpe_register_info->enable_address.address), + ACPI_LODWORD (gpe_register_info->enable_address.address), + gpe_register_info->enable, + gpe_register_info->status)); + + /* First check if there is anything active at all in this register */ + + enabled_status_byte = (u8) (gpe_register_info->status & + gpe_register_info->enable); + if (!enabled_status_byte) { + /* No active GPEs in this register, move on */ + + continue; + } - /* Now look at the individual GPEs in this byte register */ + /* Now look at the individual GPEs in this byte register */ - for (j = 0, bit_mask = 1; j < ACPI_GPE_REGISTER_WIDTH; j++, bit_mask <<= 1) { - /* Examine one GPE bit */ + for (j = 0, bit_mask = 1; j < ACPI_GPE_REGISTER_WIDTH; j++, bit_mask <<= 1) { + /* Examine one GPE bit */ - if (enabled_status_byte & bit_mask) { - /* - * Found an active GPE. Dispatch the event to a handler - * or method. - */ - int_status |= acpi_ev_gpe_dispatch ( - gpe_register_info->base_gpe_number + j); + if (enabled_status_byte & bit_mask) { + /* + * Found an active GPE. Dispatch the event to a handler + * or method. + */ + int_status |= acpi_ev_gpe_dispatch ( + &gpe_block->event_info[(i * ACPI_GPE_REGISTER_WIDTH) +j]); + } } } + + gpe_block = gpe_block->next; } return (int_status); @@ -536,7 +201,7 @@ * * FUNCTION: acpi_ev_asynch_execute_gpe_method * - * PARAMETERS: gpe_number - The 0-based GPE number + * PARAMETERS: gpe_event_info - Info for this GPE * * RETURN: None * @@ -552,20 +217,14 @@ acpi_ev_asynch_execute_gpe_method ( void *context) { - u32 gpe_number = (u32) ACPI_TO_INTEGER (context); - u32 gpe_number_index; - struct acpi_gpe_number_info gpe_number_info; + struct acpi_gpe_event_info *gpe_event_info = (void *) context; + u32 gpe_number = 0; acpi_status status; ACPI_FUNCTION_TRACE ("ev_asynch_execute_gpe_method"); - gpe_number_index = acpi_ev_get_gpe_number_index (gpe_number); - if (gpe_number_index == ACPI_GPE_INVALID) { - return_VOID; - } - /* * Take a snapshot of the GPE info for this level - we copy the * info to prevent a race condition with remove_handler. @@ -575,40 +234,38 @@ return_VOID; } - gpe_number_info = acpi_gbl_gpe_number_info [gpe_number_index]; status = acpi_ut_release_mutex (ACPI_MTX_EVENTS); if (ACPI_FAILURE (status)) { return_VOID; } - if (gpe_number_info.method_node) { + if (gpe_event_info->method_node) { /* * Invoke the GPE Method (_Lxx, _Exx): * (Evaluate the _Lxx/_Exx control method that corresponds to this GPE.) */ - status = acpi_ns_evaluate_by_handle (gpe_number_info.method_node, NULL, NULL); + status = acpi_ns_evaluate_by_handle (gpe_event_info->method_node, NULL, NULL); if (ACPI_FAILURE (status)) { ACPI_REPORT_ERROR (("%s while evaluating method [%4.4s] for GPE[%2.2X]\n", acpi_format_exception (status), - gpe_number_info.method_node->name.ascii, gpe_number)); + gpe_event_info->method_node->name.ascii, gpe_number)); } } - if (gpe_number_info.type & ACPI_EVENT_LEVEL_TRIGGERED) { + if (gpe_event_info->type & ACPI_EVENT_LEVEL_TRIGGERED) { /* * GPE is level-triggered, we clear the GPE status bit after handling * the event. */ - status = acpi_hw_clear_gpe (gpe_number); + status = acpi_hw_clear_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { return_VOID; } } - /* - * Enable the GPE. - */ - (void) acpi_hw_enable_gpe (gpe_number); + /* Enable this GPE */ + + (void) acpi_hw_enable_gpe (gpe_event_info); return_VOID; } @@ -617,7 +274,7 @@ * * FUNCTION: acpi_ev_gpe_dispatch * - * PARAMETERS: gpe_number - The 0-based GPE number + * PARAMETERS: gpe_event_info - info for this GPE * * RETURN: INTERRUPT_HANDLED or INTERRUPT_NOT_HANDLED * @@ -629,9 +286,9 @@ u32 acpi_ev_gpe_dispatch ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { - struct acpi_gpe_number_info *gpe_number_info; + u32 gpe_number = 0; /* TBD: remove */ acpi_status status; @@ -639,23 +296,14 @@ /* - * We don't have to worry about mutex on gpe_number_info because we are - * executing at interrupt level. - */ - gpe_number_info = acpi_ev_get_gpe_number_info (gpe_number); - if (!gpe_number_info) { - ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "GPE[%X] is not a valid event\n", gpe_number)); - return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); - } - - /* * If edge-triggered, clear the GPE status bit now. Note that * level-triggered events are cleared after the GPE is serviced. */ - if (gpe_number_info->type & ACPI_EVENT_EDGE_TRIGGERED) { - status = acpi_hw_clear_gpe (gpe_number); + if (gpe_event_info->type & ACPI_EVENT_EDGE_TRIGGERED) { + status = acpi_hw_clear_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to clear GPE[%2.2X]\n", gpe_number)); + ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to clear GPE[%2.2X]\n", + gpe_number)); return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); } } @@ -667,19 +315,20 @@ * If there is neither a handler nor a method, we disable the level to * prevent further events from coming in here. */ - if (gpe_number_info->handler) { + if (gpe_event_info->handler) { /* Invoke the installed handler (at interrupt level) */ - gpe_number_info->handler (gpe_number_info->context); + gpe_event_info->handler (gpe_event_info->context); } - else if (gpe_number_info->method_node) { + else if (gpe_event_info->method_node) { /* * Disable GPE, so it doesn't keep firing before the method has a * chance to run. */ - status = acpi_hw_disable_gpe (gpe_number); + status = acpi_hw_disable_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2.2X]\n", gpe_number)); + ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2.2X]\n", + gpe_number)); return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); } @@ -688,22 +337,27 @@ */ if (ACPI_FAILURE (acpi_os_queue_for_execution (OSD_PRIORITY_GPE, acpi_ev_asynch_execute_gpe_method, - ACPI_TO_POINTER (gpe_number)))) { - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to queue handler for GPE[%2.2X], event is disabled\n", gpe_number)); + gpe_event_info))) { + ACPI_REPORT_ERROR (( + "acpi_ev_gpe_dispatch: Unable to queue handler for GPE[%2.2X], event is disabled\n", + gpe_number)); } } else { /* No handler or method to run! */ - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: No handler or method for GPE[%2.2X], disabling event\n", gpe_number)); + ACPI_REPORT_ERROR (( + "acpi_ev_gpe_dispatch: No handler or method for GPE[%2.2X], disabling event\n", + gpe_number)); /* * Disable the GPE. The GPE will remain disabled until the ACPI * Core Subsystem is restarted, or the handler is reinstalled. */ - status = acpi_hw_disable_gpe (gpe_number); + status = acpi_hw_disable_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2.2X]\n", gpe_number)); + ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2.2X]\n", + gpe_number)); return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); } } @@ -711,10 +365,11 @@ /* * It is now safe to clear level-triggered evnets. */ - if (gpe_number_info->type & ACPI_EVENT_LEVEL_TRIGGERED) { - status = acpi_hw_clear_gpe (gpe_number); + if (gpe_event_info->type & ACPI_EVENT_LEVEL_TRIGGERED) { + status = acpi_hw_clear_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { - ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to clear GPE[%2.2X]\n", gpe_number)); + ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to clear GPE[%2.2X]\n", + gpe_number)); return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); } } diff -Nru a/drivers/acpi/events/evgpeblk.c b/drivers/acpi/events/evgpeblk.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/acpi/events/evgpeblk.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,545 @@ +/****************************************************************************** + * + * Module Name: evgpeblk - GPE block creation and initialization. + * + *****************************************************************************/ + +/* + * Copyright (C) 2000 - 2003, R. Byron Moore + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions, and the following disclaimer, + * without modification. + * 2. Redistributions in binary form must reproduce at minimum a disclaimer + * substantially similar to the "NO WARRANTY" disclaimer below + * ("Disclaimer") and any redistribution must be conditioned upon + * including a substantially similar Disclaimer requirement for further + * binary redistribution. + * 3. Neither the names of the above-listed copyright holders nor the names + * of any contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * Alternatively, this software may be distributed under the terms of the + * GNU General Public License ("GPL") version 2 as published by the Free + * Software Foundation. + * + * NO WARRANTY + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGES. + */ + +#include +#include +#include + +#define _COMPONENT ACPI_EVENTS + ACPI_MODULE_NAME ("evgpe") + + +/******************************************************************************* + * + * FUNCTION: acpi_ev_save_method_info + * + * PARAMETERS: Callback from walk_namespace + * + * RETURN: None + * + * DESCRIPTION: Called from acpi_walk_namespace. Expects each object to be a + * control method under the _GPE portion of the namespace. + * Extract the name and GPE type from the object, saving this + * information for quick lookup during GPE dispatch + * + * The name of each GPE control method is of the form: + * "_Lnn" or "_Enn" + * Where: + * L - means that the GPE is level triggered + * E - means that the GPE is edge triggered + * nn - is the GPE number [in HEX] + * + ******************************************************************************/ + +static acpi_status +acpi_ev_save_method_info ( + acpi_handle obj_handle, + u32 level, + void *obj_desc, + void **return_value) +{ + struct acpi_gpe_block_info *gpe_block = (void *) obj_desc; + struct acpi_gpe_event_info *gpe_event_info; + u32 gpe_number; + char name[ACPI_NAME_SIZE + 1]; + u8 type; + acpi_status status; + + + ACPI_FUNCTION_NAME ("ev_save_method_info"); + + + /* Extract the name from the object and convert to a string */ + + ACPI_MOVE_UNALIGNED32_TO_32 (name, + &((struct acpi_namespace_node *) obj_handle)->name.integer); + name[ACPI_NAME_SIZE] = 0; + + /* + * Edge/Level determination is based on the 2nd character of the method name + */ + switch (name[1]) { + case 'L': + type = ACPI_EVENT_LEVEL_TRIGGERED; + break; + + case 'E': + type = ACPI_EVENT_EDGE_TRIGGERED; + break; + + default: + /* Unknown method type, just ignore it! */ + + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Unknown GPE method type: %s (name not of form _Lnn or _Enn)\n", + name)); + return (AE_OK); + } + + /* Convert the last two characters of the name to the GPE Number */ + + gpe_number = ACPI_STRTOUL (&name[2], NULL, 16); + if (gpe_number == ACPI_UINT32_MAX) { + /* Conversion failed; invalid method, just ignore it */ + + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not extract GPE number from name: %s (name is not of form _Lnn or _Enn)\n", + name)); + return (AE_OK); + } + + /* Ensure that we have a valid GPE number for this GPE block */ + + if ((gpe_number < gpe_block->block_base_number) || + (gpe_number >= (gpe_block->register_count * 8))) { + /* Not valid, all we can do here is ignore it */ + + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "GPE number associated with method %s is not valid\n", name)); + return (AE_OK); + } + + /* + * Now we can add this information to the gpe_event_info block + * for use during dispatch of this GPE. + */ + gpe_event_info = &gpe_block->event_info[gpe_number - gpe_block->block_base_number]; + + gpe_event_info->type = type; + gpe_event_info->method_node = (struct acpi_namespace_node *) obj_handle; + + /* + * Enable the GPE (SCIs should be disabled at this point) + */ + status = acpi_hw_enable_gpe (gpe_event_info); + if (ACPI_FAILURE (status)) { + return (status); + } + + ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Registered GPE method %s as GPE number %2.2X\n", + name, gpe_number)); + return (AE_OK); +} + + +/******************************************************************************* + * + * FUNCTION: acpi_ev_install_gpe_block + * + * PARAMETERS: gpe_block - New GPE block + * + * RETURN: Status + * + * DESCRIPTION: Install new GPE block with mutex support + * + ******************************************************************************/ + +acpi_status +acpi_ev_install_gpe_block ( + struct acpi_gpe_block_info *gpe_block) +{ + struct acpi_gpe_block_info *next_gpe_block; + acpi_status status; + + + status = acpi_ut_acquire_mutex (ACPI_MTX_EVENTS); + if (ACPI_FAILURE (status)) { + return (status); + } + + /* Install the new block at the end of the global list */ + + if (acpi_gbl_gpe_block_list_head) { + next_gpe_block = acpi_gbl_gpe_block_list_head; + while (next_gpe_block->next) { + next_gpe_block = next_gpe_block->next; + } + + next_gpe_block->next = gpe_block; + gpe_block->previous = next_gpe_block; + } + else { + acpi_gbl_gpe_block_list_head = gpe_block; + } + + status = acpi_ut_release_mutex (ACPI_MTX_EVENTS); + return (status); +} + + +/******************************************************************************* + * + * FUNCTION: acpi_ev_create_gpe_info_blocks + * + * PARAMETERS: gpe_block - New GPE block + * + * RETURN: Status + * + * DESCRIPTION: Create the register_info and event_info blocks for this GPE block + * + ******************************************************************************/ + +acpi_status +acpi_ev_create_gpe_info_blocks ( + struct acpi_gpe_block_info *gpe_block) +{ + struct acpi_gpe_register_info *gpe_register_info = NULL; + struct acpi_gpe_event_info *gpe_event_info = NULL; + struct acpi_gpe_event_info *this_event; + struct acpi_gpe_register_info *this_register; + acpi_native_uint i; + acpi_native_uint j; + acpi_status status; + + + ACPI_FUNCTION_TRACE ("ev_create_gpe_info_blocks"); + + + /* Allocate the GPE register information block */ + + gpe_register_info = ACPI_MEM_CALLOCATE ( + (acpi_size) gpe_block->register_count * + sizeof (struct acpi_gpe_register_info)); + if (!gpe_register_info) { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, + "Could not allocate the gpe_register_info table\n")); + return_ACPI_STATUS (AE_NO_MEMORY); + } + + /* + * Allocate the GPE event_info block. There are eight distinct GPEs + * per register. Initialization to zeros is sufficient. + */ + gpe_event_info = ACPI_MEM_CALLOCATE ( + ((acpi_size) gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH) * + sizeof (struct acpi_gpe_event_info)); + if (!gpe_event_info) { + ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not allocate the gpe_event_info table\n")); + status = AE_NO_MEMORY; + goto error_exit; + } + + /* + * Initialize the GPE Register and Event structures. A goal of these + * tables is to hide the fact that there are two separate GPE register sets + * in a given gpe hardware block, the status registers occupy the first half, + * and the enable registers occupy the second half. Another goal is to hide + * the fact that there may be multiple GPE hardware blocks. + */ + this_register = gpe_register_info; + this_event = gpe_event_info; + + for (i = 0; i < gpe_block->register_count; i++) { + /* Init the register_info for this GPE register (8 GPEs) */ + + this_register->base_gpe_number = (u8) (gpe_block->block_base_number + + (i * ACPI_GPE_REGISTER_WIDTH)); + + ACPI_STORE_ADDRESS (this_register->status_address.address, + (gpe_block->block_address.address + + i)); + + ACPI_STORE_ADDRESS (this_register->enable_address.address, + (gpe_block->block_address.address + + i + + gpe_block->register_count)); + + this_register->status_address.address_space_id = gpe_block->block_address.address_space_id; + this_register->enable_address.address_space_id = gpe_block->block_address.address_space_id; + this_register->status_address.register_bit_width = ACPI_GPE_REGISTER_WIDTH; + this_register->enable_address.register_bit_width = ACPI_GPE_REGISTER_WIDTH; + this_register->status_address.register_bit_offset = ACPI_GPE_REGISTER_WIDTH; + this_register->enable_address.register_bit_offset = ACPI_GPE_REGISTER_WIDTH; + + /* Init the event_info for each GPE within this register */ + + for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) { + this_event->bit_mask = acpi_gbl_decode_to8bit[j]; + this_event->register_info = this_register; + this_event++; + } + + /* + * Clear the status/enable registers. Note that status registers + * are cleared by writing a '1', while enable registers are cleared + * by writing a '0'. + */ + status = acpi_hw_low_level_write (ACPI_GPE_REGISTER_WIDTH, 0x00, + &this_register->enable_address, 0); + if (ACPI_FAILURE (status)) { + goto error_exit; + } + + status = acpi_hw_low_level_write (ACPI_GPE_REGISTER_WIDTH, 0xFF, + &this_register->status_address, 0); + if (ACPI_FAILURE (status)) { + goto error_exit; + } + + this_register++; + } + + gpe_block->register_info = gpe_register_info; + gpe_block->event_info = gpe_event_info; + + return_ACPI_STATUS (AE_OK); + + +error_exit: + + if (gpe_register_info) { + ACPI_MEM_FREE (gpe_register_info); + } + if (gpe_event_info) { + ACPI_MEM_FREE (gpe_event_info); + } + + return_ACPI_STATUS (AE_OK); +} + + +/******************************************************************************* + * + * FUNCTION: acpi_ev_create_gpe_block + * + * PARAMETERS: TBD + * + * RETURN: Status + * + * DESCRIPTION: Create and Install a block of GPE registers + * + ******************************************************************************/ + +acpi_status +acpi_ev_create_gpe_block ( + char *pathname, + struct acpi_generic_address *gpe_block_address, + u32 register_count, + u8 gpe_block_base_number, + u32 interrupt_level) +{ + struct acpi_gpe_block_info *gpe_block; + acpi_status status; + acpi_handle obj_handle; + + + ACPI_FUNCTION_TRACE ("ev_create_gpe_block"); + + + if (!register_count) { + return_ACPI_STATUS (AE_OK); + } + + /* Get a handle to the parent object for this GPE block */ + + status = acpi_get_handle (NULL, pathname, &obj_handle); + if (ACPI_FAILURE (status)) { + return_ACPI_STATUS (status); + } + + /* Allocate a new GPE block */ + + gpe_block = ACPI_MEM_CALLOCATE (sizeof (struct acpi_gpe_block_info)); + if (!gpe_block) { + return_ACPI_STATUS (AE_NO_MEMORY); + } + + /* Initialize the new GPE block */ + + gpe_block->register_count = register_count; + gpe_block->block_base_number = gpe_block_base_number; + + ACPI_MEMCPY (&gpe_block->block_address, gpe_block_address, sizeof (struct acpi_generic_address)); + + /* Create the register_info and event_info sub-structures */ + + status = acpi_ev_create_gpe_info_blocks (gpe_block); + if (ACPI_FAILURE (status)) { + ACPI_MEM_FREE (gpe_block); + return_ACPI_STATUS (status); + } + + /* Install the new block in the global list(s) */ + /* TBD: Install block in the interrupt handler list */ + + status = acpi_ev_install_gpe_block (gpe_block); + if (ACPI_FAILURE (status)) { + ACPI_MEM_FREE (gpe_block); + return_ACPI_STATUS (status); + } + + /* Dump info about this GPE block */ + + ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "GPE Block: %X registers at %8.8X%8.8X\n", + gpe_block->register_count, + ACPI_HIDWORD (gpe_block->block_address.address), + ACPI_LODWORD (gpe_block->block_address.address))); + + ACPI_DEBUG_PRINT ((ACPI_DB_INIT, "GPE Block defined as GPE%d to GPE%d\n", + gpe_block->block_base_number, + (u32) (gpe_block->block_base_number + + ((gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH) -1)))); + + /* Find all GPE methods (_Lxx, _Exx) for this block */ + + status = acpi_walk_namespace (ACPI_TYPE_METHOD, obj_handle, + ACPI_UINT32_MAX, acpi_ev_save_method_info, + gpe_block, NULL); + + return_ACPI_STATUS (AE_OK); +} + + +/******************************************************************************* + * + * FUNCTION: acpi_ev_gpe_initialize + * + * PARAMETERS: None + * + * RETURN: Status + * + * DESCRIPTION: Initialize the GPE data structures + * + ******************************************************************************/ + +acpi_status +acpi_ev_gpe_initialize (void) +{ + u32 register_count0 = 0; + u32 register_count1 = 0; + u32 gpe_number_max = 0; + + + ACPI_FUNCTION_TRACE ("ev_gpe_initialize"); + + + /* + * Initialize the GPE Blocks defined in the FADT + * + * Why the GPE register block lengths are divided by 2: From the ACPI Spec, + * section "General-Purpose Event Registers", we have: + * + * "Each register block contains two registers of equal length + * GPEx_STS and GPEx_EN (where x is 0 or 1). The length of the + * GPE0_STS and GPE0_EN registers is equal to half the GPE0_LEN + * The length of the GPE1_STS and GPE1_EN registers is equal to + * half the GPE1_LEN. If a generic register block is not supported + * then its respective block pointer and block length values in the + * FADT table contain zeros. The GPE0_LEN and GPE1_LEN do not need + * to be the same size." + */ + + /* + * Determine the maximum GPE number for this machine. + * + * Note: both GPE0 and GPE1 are optional, and either can exist without + * the other. + * If EITHER the register length OR the block address are zero, then that + * particular block is not supported. + */ + if (acpi_gbl_FADT->gpe0_blk_len && + acpi_gbl_FADT->xgpe0_blk.address) { + /* GPE block 0 exists (has both length and address > 0) */ + + register_count0 = (u16) (acpi_gbl_FADT->gpe0_blk_len / 2); + + gpe_number_max = (register_count0 * ACPI_GPE_REGISTER_WIDTH) - 1; + + acpi_ev_create_gpe_block ("\\_GPE", &acpi_gbl_FADT->xgpe0_blk, + register_count0, 0, acpi_gbl_FADT->sci_int); + } + + if (acpi_gbl_FADT->gpe1_blk_len && + acpi_gbl_FADT->xgpe1_blk.address) { + /* GPE block 1 exists (has both length and address > 0) */ + + register_count1 = (u16) (acpi_gbl_FADT->gpe1_blk_len / 2); + + /* Check for GPE0/GPE1 overlap (if both banks exist) */ + + if ((register_count0) && + (gpe_number_max >= acpi_gbl_FADT->gpe1_base)) { + ACPI_REPORT_ERROR (( + "GPE0 block (GPE 0 to %d) overlaps the GPE1 block (GPE %d to %d) - Ignoring GPE1\n", + gpe_number_max, acpi_gbl_FADT->gpe1_base, + acpi_gbl_FADT->gpe1_base + + ((register_count1 * ACPI_GPE_REGISTER_WIDTH) - 1))); + + /* Ignore GPE1 block by setting the register count to zero */ + + register_count1 = 0; + } + else { + acpi_ev_create_gpe_block ("\\_GPE", &acpi_gbl_FADT->xgpe1_blk, + register_count1, acpi_gbl_FADT->gpe1_base, acpi_gbl_FADT->sci_int); + + /* + * GPE0 and GPE1 do not have to be contiguous in the GPE number space, + * But, GPE0 always starts at zero. + */ + gpe_number_max = acpi_gbl_FADT->gpe1_base + + ((register_count1 * ACPI_GPE_REGISTER_WIDTH) - 1); + } + } + + /* Exit if there are no GPE registers */ + + if ((register_count0 + register_count1) == 0) { + /* GPEs are not required by ACPI, this is OK */ + + ACPI_REPORT_INFO (("There are no GPE blocks defined in the FADT\n")); + return_ACPI_STATUS (AE_OK); + } + + /* Check for Max GPE number out-of-range */ + + if (gpe_number_max > ACPI_GPE_MAX) { + ACPI_REPORT_ERROR (("Maximum GPE number from FADT is too large: 0x%X\n", + gpe_number_max)); + return_ACPI_STATUS (AE_BAD_VALUE); + } + + return_ACPI_STATUS (AE_OK); +} + + diff -Nru a/drivers/acpi/events/evmisc.c b/drivers/acpi/events/evmisc.c --- a/drivers/acpi/events/evmisc.c Tue Mar 4 19:30:10 2003 +++ b/drivers/acpi/events/evmisc.c Tue Mar 4 19:30:10 2003 @@ -86,84 +86,6 @@ /******************************************************************************* * - * FUNCTION: acpi_ev_get_gpe_register_info - * - * PARAMETERS: gpe_number - Raw GPE number - * - * RETURN: Pointer to the info struct for this GPE register. - * - * DESCRIPTION: Returns the register index (index into the GPE register info - * table) associated with this GPE. - * - ******************************************************************************/ - -struct acpi_gpe_register_info * -acpi_ev_get_gpe_register_info ( - u32 gpe_number) -{ - - if (gpe_number > acpi_gbl_gpe_number_max) { - return (NULL); - } - - return (&acpi_gbl_gpe_register_info [ACPI_DIV_8 (acpi_gbl_gpe_number_to_index[gpe_number].number_index)]); -} - - -/******************************************************************************* - * - * FUNCTION: acpi_ev_get_gpe_number_info - * - * PARAMETERS: gpe_number - Raw GPE number - * - * RETURN: None. - * - * DESCRIPTION: Returns the number index (index into the GPE number info table) - * associated with this GPE. - * - ******************************************************************************/ - -struct acpi_gpe_number_info * -acpi_ev_get_gpe_number_info ( - u32 gpe_number) -{ - - if (gpe_number > acpi_gbl_gpe_number_max) { - return (NULL); - } - - return (&acpi_gbl_gpe_number_info [acpi_gbl_gpe_number_to_index[gpe_number].number_index]); -} - - -/******************************************************************************* - * - * FUNCTION: acpi_ev_get_gpe_number_index - * - * PARAMETERS: gpe_number - Raw GPE number - * - * RETURN: None. - * - * DESCRIPTION: Returns the number index (index into the GPE number info table) - * associated with this GPE. - * - ******************************************************************************/ - -u32 -acpi_ev_get_gpe_number_index ( - u32 gpe_number) -{ - - if (gpe_number > acpi_gbl_gpe_number_max) { - return (ACPI_GPE_INVALID); - } - - return (acpi_gbl_gpe_number_to_index[gpe_number].number_index); -} - - -/******************************************************************************* - * * FUNCTION: acpi_ev_queue_notify_request * * PARAMETERS: @@ -601,6 +523,9 @@ { acpi_native_uint i; acpi_status status; + struct acpi_gpe_block_info *gpe_block; + struct acpi_gpe_block_info *next_gpe_block; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("ev_terminate"); @@ -625,13 +550,19 @@ /* * Disable all GPEs */ - for (i = 0; i < acpi_gbl_gpe_number_max; i++) { - if (acpi_ev_get_gpe_number_index ((u32)i) != ACPI_GPE_INVALID) { - status = acpi_hw_disable_gpe((u32) i); + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + gpe_event_info = gpe_block->event_info; + for (i = 0; i < (gpe_block->register_count * 8); i++) { + status = acpi_hw_disable_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not disable GPE %d\n", (u32) i)); } + + gpe_event_info++; } + + gpe_block = gpe_block->next; } /* @@ -654,21 +585,16 @@ } /* - * Free global tables, etc. + * Free global GPE blocks and related info structures */ - if (acpi_gbl_gpe_register_info) { - ACPI_MEM_FREE (acpi_gbl_gpe_register_info); - acpi_gbl_gpe_register_info = NULL; - } - - if (acpi_gbl_gpe_number_info) { - ACPI_MEM_FREE (acpi_gbl_gpe_number_info); - acpi_gbl_gpe_number_info = NULL; - } + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + next_gpe_block = gpe_block->next; + ACPI_MEM_FREE (gpe_block->event_info); + ACPI_MEM_FREE (gpe_block->register_info); + ACPI_MEM_FREE (gpe_block); - if (acpi_gbl_gpe_number_to_index) { - ACPI_MEM_FREE (acpi_gbl_gpe_number_to_index); - acpi_gbl_gpe_number_to_index = NULL; + gpe_block = next_gpe_block; } return_VOID; diff -Nru a/drivers/acpi/events/evrgnini.c b/drivers/acpi/events/evrgnini.c --- a/drivers/acpi/events/evrgnini.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/events/evrgnini.c Tue Mar 4 19:30:04 2003 @@ -410,7 +410,7 @@ * Get the appropriate address space handler for a newly * created region. * - * This also performs address space specific intialization. For + * This also performs address space specific initialization. For * example, PCI regions must have an _ADR object that contains * a PCI address in the scope of the definition. This address is * required to perform an access to PCI config space. diff -Nru a/drivers/acpi/events/evsci.c b/drivers/acpi/events/evsci.c --- a/drivers/acpi/events/evsci.c Tue Mar 4 19:30:11 2003 +++ b/drivers/acpi/events/evsci.c Tue Mar 4 19:30:11 2003 @@ -69,38 +69,24 @@ void *context) { u32 interrupt_handled = ACPI_INTERRUPT_NOT_HANDLED; - u32 value; - acpi_status status; ACPI_FUNCTION_TRACE("ev_sci_handler"); /* - * Make sure that ACPI is enabled by checking SCI_EN. Note that we are - * required to treat the SCI interrupt as sharable, level, active low. + * We are guaranteed by the ACPI CA initialization/shutdown code that + * if this interrupt handler is installed, ACPI is enabled. */ - status = acpi_get_register (ACPI_BITREG_SCI_ENABLE, &value, ACPI_MTX_DO_NOT_LOCK); - if (ACPI_FAILURE (status)) { - return (ACPI_INTERRUPT_NOT_HANDLED); - } - - if (!value) { - /* ACPI is not enabled; this interrupt cannot be for us */ - - return_VALUE (ACPI_INTERRUPT_NOT_HANDLED); - } /* * Fixed acpi_events: - * ------------- * Check for and dispatch any Fixed acpi_events that have occurred */ interrupt_handled |= acpi_ev_fixed_event_detect (); /* * GPEs: - * ----- * Check for and dispatch any GPEs that have occurred */ interrupt_handled |= acpi_ev_gpe_detect (); diff -Nru a/drivers/acpi/events/evxface.c b/drivers/acpi/events/evxface.c --- a/drivers/acpi/events/evxface.c Tue Mar 4 19:30:10 2003 +++ b/drivers/acpi/events/evxface.c Tue Mar 4 19:30:10 2003 @@ -492,7 +492,7 @@ void *context) { acpi_status status; - struct acpi_gpe_number_info *gpe_number_info; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_install_gpe_handler"); @@ -506,8 +506,8 @@ /* Ensure that we have a valid GPE number */ - gpe_number_info = acpi_ev_get_gpe_number_info (gpe_number); - if (!gpe_number_info) { + gpe_event_info = acpi_ev_get_gpe_event_info (gpe_number); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } @@ -518,25 +518,25 @@ /* Make sure that there isn't a handler there already */ - if (gpe_number_info->handler) { + if (gpe_event_info->handler) { status = AE_ALREADY_EXISTS; goto cleanup; } /* Install the handler */ - gpe_number_info->handler = handler; - gpe_number_info->context = context; - gpe_number_info->type = (u8) type; + gpe_event_info->handler = handler; + gpe_event_info->context = context; + gpe_event_info->type = (u8) type; /* Clear the GPE (of stale events), the enable it */ - status = acpi_hw_clear_gpe (gpe_number); + status = acpi_hw_clear_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { goto cleanup; } - status = acpi_hw_enable_gpe (gpe_number); + status = acpi_hw_enable_gpe (gpe_event_info); cleanup: @@ -564,7 +564,7 @@ acpi_gpe_handler handler) { acpi_status status; - struct acpi_gpe_number_info *gpe_number_info; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_remove_gpe_handler"); @@ -578,14 +578,14 @@ /* Ensure that we have a valid GPE number */ - gpe_number_info = acpi_ev_get_gpe_number_info (gpe_number); - if (!gpe_number_info) { + gpe_event_info = acpi_ev_get_gpe_event_info (gpe_number); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Disable the GPE before removing the handler */ - status = acpi_hw_disable_gpe (gpe_number); + status = acpi_hw_disable_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } @@ -597,16 +597,16 @@ /* Make sure that the installed handler is the same */ - if (gpe_number_info->handler != handler) { - (void) acpi_hw_enable_gpe (gpe_number); + if (gpe_event_info->handler != handler) { + (void) acpi_hw_enable_gpe (gpe_event_info); status = AE_BAD_PARAMETER; goto cleanup; } /* Remove the handler */ - gpe_number_info->handler = NULL; - gpe_number_info->context = NULL; + gpe_event_info->handler = NULL; + gpe_event_info->context = NULL; cleanup: diff -Nru a/drivers/acpi/events/evxfevnt.c b/drivers/acpi/events/evxfevnt.c --- a/drivers/acpi/events/evxfevnt.c Tue Mar 4 19:30:05 2003 +++ b/drivers/acpi/events/evxfevnt.c Tue Mar 4 19:30:05 2003 @@ -163,6 +163,7 @@ { acpi_status status = AE_OK; u32 value; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_enable_event"); @@ -209,19 +210,20 @@ /* Ensure that we have a valid GPE number */ - if (acpi_ev_get_gpe_number_index (event) == ACPI_GPE_INVALID) { + gpe_event_info = acpi_ev_get_gpe_event_info (event); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } /* Enable the requested GPE number */ - status = acpi_hw_enable_gpe (event); + status = acpi_hw_enable_gpe (gpe_event_info); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } if (flags & ACPI_EVENT_WAKE_ENABLE) { - acpi_hw_enable_gpe_for_wakeup (event); + acpi_hw_enable_gpe_for_wakeup (gpe_event_info); } break; @@ -257,6 +259,7 @@ { acpi_status status = AE_OK; u32 value; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_disable_event"); @@ -301,7 +304,8 @@ /* Ensure that we have a valid GPE number */ - if (acpi_ev_get_gpe_number_index (event) == ACPI_GPE_INVALID) { + gpe_event_info = acpi_ev_get_gpe_event_info (event); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } @@ -311,10 +315,10 @@ */ if (flags & ACPI_EVENT_WAKE_DISABLE) { - acpi_hw_disable_gpe_for_wakeup (event); + acpi_hw_disable_gpe_for_wakeup (gpe_event_info); } else { - status = acpi_hw_disable_gpe (event); + status = acpi_hw_disable_gpe (gpe_event_info); } break; @@ -346,6 +350,7 @@ u32 type) { acpi_status status = AE_OK; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_clear_event"); @@ -375,11 +380,12 @@ /* Ensure that we have a valid GPE number */ - if (acpi_ev_get_gpe_number_index (event) == ACPI_GPE_INVALID) { + gpe_event_info = acpi_ev_get_gpe_event_info (event); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } - status = acpi_hw_clear_gpe (event); + status = acpi_hw_clear_gpe (gpe_event_info); break; @@ -415,6 +421,7 @@ acpi_event_status *event_status) { acpi_status status = AE_OK; + struct acpi_gpe_event_info *gpe_event_info; ACPI_FUNCTION_TRACE ("acpi_get_event_status"); @@ -447,7 +454,8 @@ /* Ensure that we have a valid GPE number */ - if (acpi_ev_get_gpe_number_index (event) == ACPI_GPE_INVALID) { + gpe_event_info = acpi_ev_get_gpe_event_info (event); + if (!gpe_event_info) { return_ACPI_STATUS (AE_BAD_PARAMETER); } @@ -463,4 +471,5 @@ return_ACPI_STATUS (status); } + diff -Nru a/drivers/acpi/hardware/hwgpe.c b/drivers/acpi/hardware/hwgpe.c --- a/drivers/acpi/hardware/hwgpe.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/hardware/hwgpe.c Tue Mar 4 19:30:04 2003 @@ -51,26 +51,6 @@ /****************************************************************************** * - * FUNCTION: acpi_hw_get_gpe_bit_mask - * - * PARAMETERS: gpe_number - The GPE - * - * RETURN: Gpe register bitmask for this gpe level - * - * DESCRIPTION: Get the bitmask for this GPE - * - ******************************************************************************/ - -u8 -acpi_hw_get_gpe_bit_mask ( - u32 gpe_number) -{ - return (acpi_gbl_gpe_number_info [acpi_ev_get_gpe_number_index (gpe_number)].bit_mask); -} - - -/****************************************************************************** - * * FUNCTION: acpi_hw_enable_gpe * * PARAMETERS: gpe_number - The GPE @@ -83,37 +63,29 @@ acpi_status acpi_hw_enable_gpe ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { u32 in_byte; acpi_status status; - struct acpi_gpe_register_info *gpe_register_info; ACPI_FUNCTION_ENTRY (); - /* Get the info block for the entire GPE register */ - - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); - if (!gpe_register_info) { - return (AE_BAD_PARAMETER); - } - /* * Read the current value of the register, set the appropriate bit * to enable the GPE, and write out the new register. */ status = acpi_hw_low_level_read (8, &in_byte, - &gpe_register_info->enable_address, 0); + &gpe_event_info->register_info->enable_address, 0); if (ACPI_FAILURE (status)) { return (status); } /* Write with the new GPE bit enabled */ - status = acpi_hw_low_level_write (8, (in_byte | acpi_hw_get_gpe_bit_mask (gpe_number)), - &gpe_register_info->enable_address, 0); + status = acpi_hw_low_level_write (8, (in_byte | gpe_event_info->bit_mask), + &gpe_event_info->register_info->enable_address, 0); return (status); } @@ -134,7 +106,7 @@ void acpi_hw_enable_gpe_for_wakeup ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { struct acpi_gpe_register_info *gpe_register_info; @@ -144,7 +116,7 @@ /* Get the info block for the entire GPE register */ - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); + gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return; } @@ -152,7 +124,7 @@ /* * Set the bit so we will not disable this when sleeping */ - gpe_register_info->wake_enable |= acpi_hw_get_gpe_bit_mask (gpe_number); + gpe_register_info->wake_enable |= gpe_event_info->bit_mask; } @@ -170,7 +142,7 @@ acpi_status acpi_hw_disable_gpe ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { u32 in_byte; acpi_status status; @@ -182,7 +154,7 @@ /* Get the info block for the entire GPE register */ - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); + gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return (AE_BAD_PARAMETER); } @@ -199,13 +171,13 @@ /* Write the byte with this GPE bit cleared */ - status = acpi_hw_low_level_write (8, (in_byte & ~(acpi_hw_get_gpe_bit_mask (gpe_number))), + status = acpi_hw_low_level_write (8, (in_byte & ~(gpe_event_info->bit_mask)), &gpe_register_info->enable_address, 0); if (ACPI_FAILURE (status)) { return (status); } - acpi_hw_disable_gpe_for_wakeup(gpe_number); + acpi_hw_disable_gpe_for_wakeup (gpe_event_info); return (AE_OK); } @@ -225,7 +197,7 @@ void acpi_hw_disable_gpe_for_wakeup ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { struct acpi_gpe_register_info *gpe_register_info; @@ -235,7 +207,7 @@ /* Get the info block for the entire GPE register */ - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); + gpe_register_info = gpe_event_info->register_info; if (!gpe_register_info) { return; } @@ -243,7 +215,7 @@ /* * Clear the bit so we will disable this when sleeping */ - gpe_register_info->wake_enable &= ~(acpi_hw_get_gpe_bit_mask (gpe_number)); + gpe_register_info->wake_enable &= ~(gpe_event_info->bit_mask); } @@ -261,28 +233,20 @@ acpi_status acpi_hw_clear_gpe ( - u32 gpe_number) + struct acpi_gpe_event_info *gpe_event_info) { acpi_status status; - struct acpi_gpe_register_info *gpe_register_info; ACPI_FUNCTION_ENTRY (); - /* Get the info block for the entire GPE register */ - - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); - if (!gpe_register_info) { - return (AE_BAD_PARAMETER); - } - /* * Write a one to the appropriate bit in the status register to * clear this GPE. */ - status = acpi_hw_low_level_write (8, acpi_hw_get_gpe_bit_mask (gpe_number), - &gpe_register_info->status_address, 0); + status = acpi_hw_low_level_write (8, gpe_event_info->bit_mask, + &gpe_event_info->register_info->status_address, 0); return (status); } @@ -308,6 +272,7 @@ u32 in_byte; u8 bit_mask; struct acpi_gpe_register_info *gpe_register_info; + struct acpi_gpe_event_info *gpe_event_info; acpi_status status; acpi_event_status local_event_status = 0; @@ -319,16 +284,18 @@ return (AE_BAD_PARAMETER); } - /* Get the info block for the entire GPE register */ - - gpe_register_info = acpi_ev_get_gpe_register_info (gpe_number); - if (!gpe_register_info) { + gpe_event_info = acpi_ev_get_gpe_event_info (gpe_number); + if (!gpe_event_info) { return (AE_BAD_PARAMETER); } + /* Get the info block for the entire GPE register */ + + gpe_register_info = gpe_event_info->register_info; + /* Get the register bitmask for this GPE */ - bit_mask = acpi_hw_get_gpe_bit_mask (gpe_number); + bit_mask = gpe_event_info->bit_mask; /* GPE Enabled? */ @@ -375,7 +342,7 @@ * * DESCRIPTION: Disable all non-wakeup GPEs * Call with interrupts disabled. The interrupt handler also - * modifies acpi_gbl_gpe_register_info[i].Enable, so it should not be + * modifies gpe_register_info->Enable, so it should not be * given the chance to run until after non-wake GPEs are * re-enabled. * @@ -389,40 +356,49 @@ struct acpi_gpe_register_info *gpe_register_info; u32 in_value; acpi_status status; + struct acpi_gpe_block_info *gpe_block; ACPI_FUNCTION_ENTRY (); - for (i = 0; i < acpi_gbl_gpe_register_count; i++) { - /* Get the info block for the entire GPE register */ + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + /* Get the register info for the entire GPE block */ - gpe_register_info = &acpi_gbl_gpe_register_info[i]; + gpe_register_info = gpe_block->register_info; if (!gpe_register_info) { return (AE_BAD_PARAMETER); } - /* - * Read the enabled status of all GPEs. We - * will be using it to restore all the GPEs later. - */ - status = acpi_hw_low_level_read (8, &in_value, - &gpe_register_info->enable_address, 0); - if (ACPI_FAILURE (status)) { - return (status); - } - - gpe_register_info->enable = (u8) in_value; + for (i = 0; i < gpe_block->register_count; i++) { + /* + * Read the enabled status of all GPEs. We + * will be using it to restore all the GPEs later. + */ + status = acpi_hw_low_level_read (8, &in_value, + &gpe_register_info->enable_address, 0); + if (ACPI_FAILURE (status)) { + return (status); + } + + gpe_register_info->enable = (u8) in_value; + + /* + * Disable all GPEs except wakeup GPEs. + */ + status = acpi_hw_low_level_write (8, gpe_register_info->wake_enable, + &gpe_register_info->enable_address, 0); + if (ACPI_FAILURE (status)) { + return (status); + } - /* - * Disable all GPEs except wakeup GPEs. - */ - status = acpi_hw_low_level_write (8, gpe_register_info->wake_enable, - &gpe_register_info->enable_address, 0); - if (ACPI_FAILURE (status)) { - return (status); + gpe_register_info++; } + + gpe_block = gpe_block->next; } + return (AE_OK); } @@ -446,28 +422,37 @@ u32 i; struct acpi_gpe_register_info *gpe_register_info; acpi_status status; + struct acpi_gpe_block_info *gpe_block; ACPI_FUNCTION_ENTRY (); - for (i = 0; i < acpi_gbl_gpe_register_count; i++) { - /* Get the info block for the entire GPE register */ + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + /* Get the register info for the entire GPE block */ - gpe_register_info = &acpi_gbl_gpe_register_info[i]; + gpe_register_info = gpe_block->register_info; if (!gpe_register_info) { return (AE_BAD_PARAMETER); } - /* - * We previously stored the enabled status of all GPEs. - * Blast them back in. - */ - status = acpi_hw_low_level_write (8, gpe_register_info->enable, - &gpe_register_info->enable_address, 0); - if (ACPI_FAILURE (status)) { - return (status); + for (i = 0; i < gpe_block->register_count; i++) { + /* + * We previously stored the enabled status of all GPEs. + * Blast them back in. + */ + status = acpi_hw_low_level_write (8, gpe_register_info->enable, + &gpe_register_info->enable_address, 0); + if (ACPI_FAILURE (status)) { + return (status); + } + + gpe_register_info++; } + + gpe_block = gpe_block->next; } + return (AE_OK); } diff -Nru a/drivers/acpi/hardware/hwregs.c b/drivers/acpi/hardware/hwregs.c --- a/drivers/acpi/hardware/hwregs.c Tue Mar 4 19:30:13 2003 +++ b/drivers/acpi/hardware/hwregs.c Tue Mar 4 19:30:13 2003 @@ -67,8 +67,8 @@ acpi_hw_clear_acpi_status (void) { acpi_native_uint i; - acpi_native_uint gpe_block; acpi_status status; + struct acpi_gpe_block_info *gpe_block; ACPI_FUNCTION_TRACE ("hw_clear_acpi_status"); @@ -100,16 +100,19 @@ } } - /* Clear the GPE Bits */ + /* Clear the GPE Bits in all GPE registers in all GPE blocks */ - for (gpe_block = 0; gpe_block < ACPI_MAX_GPE_BLOCKS; gpe_block++) { - for (i = 0; i < acpi_gbl_gpe_block_info[gpe_block].register_count; i++) { + gpe_block = acpi_gbl_gpe_block_list_head; + while (gpe_block) { + for (i = 0; i < gpe_block->register_count; i++) { status = acpi_hw_low_level_write (8, 0xFF, - acpi_gbl_gpe_block_info[gpe_block].block_address, (u32) i); + &gpe_block->register_info[i].status_address, (u32) i); if (ACPI_FAILURE (status)) { goto unlock_and_exit; } } + + gpe_block = gpe_block->next; } unlock_and_exit: @@ -370,7 +373,7 @@ /* * Status Registers are different from the rest. Clear by - * writing 1, writing 0 has no effect. So, the only relevent + * writing 1, writing 0 has no effect. So, the only relevant * information is the single bit we're interested in, all others should * be written as 0 so they will be left unchanged */ diff -Nru a/drivers/acpi/hardware/hwsleep.c b/drivers/acpi/hardware/hwsleep.c --- a/drivers/acpi/hardware/hwsleep.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/hardware/hwsleep.c Tue Mar 4 19:30:04 2003 @@ -250,7 +250,7 @@ /* Get current value of PM1A control */ - status = acpi_hw_register_read (ACPI_MTX_LOCK, ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol); + status = acpi_hw_register_read (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } @@ -268,12 +268,12 @@ /* Write #1: fill in SLP_TYP data */ - status = acpi_hw_register_write (ACPI_MTX_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol); + status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } - status = acpi_hw_register_write (ACPI_MTX_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol); + status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } @@ -287,12 +287,12 @@ ACPI_FLUSH_CPU_CACHE (); - status = acpi_hw_register_write (ACPI_MTX_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol); + status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1A_CONTROL, PM1Acontrol); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } - status = acpi_hw_register_write (ACPI_MTX_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol); + status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1B_CONTROL, PM1Bcontrol); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } @@ -308,7 +308,7 @@ */ acpi_os_stall (10000000); - status = acpi_hw_register_write (ACPI_MTX_LOCK, ACPI_REGISTER_PM1_CONTROL, + status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK, ACPI_REGISTER_PM1_CONTROL, sleep_enable_reg_info->access_bit_mask); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); @@ -318,7 +318,7 @@ /* Wait until we enter sleep state */ do { - status = acpi_get_register (ACPI_BITREG_WAKE_STATUS, &in_value, ACPI_MTX_LOCK); + status = acpi_get_register (ACPI_BITREG_WAKE_STATUS, &in_value, ACPI_MTX_DO_NOT_LOCK); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } @@ -327,13 +327,58 @@ } while (!in_value); - status = acpi_set_register (ACPI_BITREG_ARB_DISABLE, 0, ACPI_MTX_LOCK); + status = acpi_set_register (ACPI_BITREG_ARB_DISABLE, 0, ACPI_MTX_DO_NOT_LOCK); if (ACPI_FAILURE (status)) { return_ACPI_STATUS (status); } return_ACPI_STATUS (AE_OK); } + + +/****************************************************************************** + * + * FUNCTION: acpi_enter_sleep_state_s4bios + * + * PARAMETERS: None + * + * RETURN: Status + * + * DESCRIPTION: Perform a S4 bios request. + * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED + * + ******************************************************************************/ + +acpi_status +acpi_enter_sleep_state_s4bios ( + void) +{ + u32 in_value; + acpi_status status; + + + ACPI_FUNCTION_TRACE ("acpi_enter_sleep_state_s4bios"); + + acpi_set_register (ACPI_BITREG_WAKE_STATUS, 1, ACPI_MTX_DO_NOT_LOCK); + acpi_hw_clear_acpi_status(); + + acpi_hw_disable_non_wakeup_gpes(); + + ACPI_FLUSH_CPU_CACHE(); + + status = acpi_os_write_port (acpi_gbl_FADT->smi_cmd, (acpi_integer) acpi_gbl_FADT->S4bios_req, 8); + + do { + acpi_os_stall(1000); + status = acpi_get_register (ACPI_BITREG_WAKE_STATUS, &in_value, ACPI_MTX_DO_NOT_LOCK); + if (ACPI_FAILURE (status)) { + return_ACPI_STATUS (status); + } + } while (!in_value); + + return_ACPI_STATUS (AE_OK); +} + /****************************************************************************** * diff -Nru a/drivers/acpi/hardware/hwtimer.c b/drivers/acpi/hardware/hwtimer.c --- a/drivers/acpi/hardware/hwtimer.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/hardware/hwtimer.c Tue Mar 4 19:30:04 2003 @@ -133,7 +133,7 @@ * transitions (unlike many CPU timestamp counters) -- making it * a versatile and accurate timer. * - * Note that this function accomodates only a single timer + * Note that this function accommodates only a single timer * rollover. Thus for 24-bit timers, this function should only * be used for calculating durations less than ~4.6 seconds * (~20 minutes for 32-bit timers) -- calculations below diff -Nru a/drivers/acpi/osl.c b/drivers/acpi/osl.c --- a/drivers/acpi/osl.c Tue Mar 4 19:30:12 2003 +++ b/drivers/acpi/osl.c Tue Mar 4 19:30:12 2003 @@ -514,10 +514,12 @@ /* TODO: Change code to take advantage of driver model more */ void -acpi_os_derive_pci_id ( +acpi_os_derive_pci_id_2 ( acpi_handle rhandle, /* upper bound */ acpi_handle chandle, /* current node */ - struct acpi_pci_id **id) + struct acpi_pci_id **id, + int *is_bridge, + u8 *bus_number) { acpi_handle handle; struct acpi_pci_id *pci_id = *id; @@ -528,7 +530,7 @@ acpi_get_parent(chandle, &handle); if (handle != rhandle) { - acpi_os_derive_pci_id(rhandle, handle, &pci_id); + acpi_os_derive_pci_id_2(rhandle, handle, &pci_id, is_bridge, bus_number); status = acpi_get_type(handle, &type); if ( (ACPI_FAILURE(status)) || (type != ACPI_TYPE_DEVICE) ) @@ -539,15 +541,40 @@ pci_id->device = ACPI_HIWORD (ACPI_LODWORD (temp)); pci_id->function = ACPI_LOWORD (ACPI_LODWORD (temp)); + if (*is_bridge) + pci_id->bus = *bus_number; + /* any nicer way to get bus number of bridge ? */ status = acpi_os_read_pci_configuration(pci_id, 0x0e, &tu8, 8); - if (ACPI_SUCCESS(status) && (tu8 & 0x7f) == 1) { + if (ACPI_SUCCESS(status) && + ((tu8 & 0x7f) == 1 || (tu8 & 0x7f) == 2)) { + status = acpi_os_read_pci_configuration(pci_id, 0x18, &tu8, 8); + if (!ACPI_SUCCESS(status)) { + /* Certainly broken... FIX ME */ + return; + } + *is_bridge = 1; + pci_id->bus = tu8; status = acpi_os_read_pci_configuration(pci_id, 0x19, &tu8, 8); - if (ACPI_SUCCESS(status)) - pci_id->bus = tu8; - } + if (ACPI_SUCCESS(status)) { + *bus_number = tu8; + } + } else + *is_bridge = 0; } } +} + +void +acpi_os_derive_pci_id ( + acpi_handle rhandle, /* upper bound */ + acpi_handle chandle, /* current node */ + struct acpi_pci_id **id) +{ + int is_bridge = 1; + u8 bus_number = (*id)->bus; + + acpi_os_derive_pci_id_2(rhandle, chandle, id, &is_bridge, &bus_number); } #else /*!CONFIG_ACPI_PCI*/ diff -Nru a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c --- a/drivers/acpi/pci_link.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/pci_link.c Tue Mar 4 19:30:04 2003 @@ -90,42 +90,25 @@ PCI Link Device Management -------------------------------------------------------------------------- */ -static int -acpi_pci_link_get_possible ( - struct acpi_pci_link *link) +static acpi_status +acpi_pci_link_check_possible ( + struct acpi_resource *resource, + void *context) { - int result = 0; - acpi_status status = AE_OK; - struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; - struct acpi_resource *resource = NULL; + struct acpi_pci_link *link = (struct acpi_pci_link *) context; int i = 0; - ACPI_FUNCTION_TRACE("acpi_pci_link_get_possible"); - - if (!link) - return_VALUE(-EINVAL); - - status = acpi_get_possible_resources(link->handle, &buffer); - if (ACPI_FAILURE(status) || !buffer.pointer) { - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRS\n")); - result = -ENODEV; - goto end; - } - - resource = (struct acpi_resource *) buffer.pointer; - - /* skip past dependent function resource (if present) */ - if (resource->id == ACPI_RSTYPE_START_DPF) - resource = ACPI_NEXT_RESOURCE(resource); + ACPI_FUNCTION_TRACE("acpi_pci_link_check_possible"); switch (resource->id) { + case ACPI_RSTYPE_START_DPF: + return AE_OK; case ACPI_RSTYPE_IRQ: { struct acpi_resource_irq *p = &resource->data.irq; if (!p || !p->number_of_interrupts) { ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Blank IRQ resource\n")); - result = -ENODEV; - goto end; + return AE_OK; } for (i = 0; (inumber_of_interrupts && iinterrupts[i]) { @@ -143,8 +126,7 @@ if (!p || !p->number_of_interrupts) { ACPI_DEBUG_PRINT((ACPI_DB_WARN, "Blank IRQ resource\n")); - result = -ENODEV; - goto end; + return AE_OK; } for (i = 0; (inumber_of_interrupts && iinterrupts[i]) { @@ -159,18 +141,76 @@ default: ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Resource is not an IRQ entry\n")); - result = -ENODEV; - goto end; - break; + return AE_OK; + } + + return AE_CTRL_TERMINATE; +} + + +static int +acpi_pci_link_get_possible ( + struct acpi_pci_link *link) +{ + acpi_status status; + + ACPI_FUNCTION_TRACE("acpi_pci_link_get_possible"); + + if (!link) + return_VALUE(-EINVAL); + + status = acpi_walk_resources(link->handle, METHOD_NAME__PRS, + acpi_pci_link_check_possible, link); + if (ACPI_FAILURE(status)) { + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PRS\n")); + return_VALUE(-ENODEV); } - + ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d possible IRQs\n", link->irq.possible_count)); -end: - acpi_os_free(buffer.pointer); + return_VALUE(0); +} + - return_VALUE(result); +static acpi_status +acpi_pci_link_check_current ( + struct acpi_resource *resource, + void *context) +{ + int *irq = (int *) context; + + ACPI_FUNCTION_TRACE("acpi_pci_link_check_current"); + + switch (resource->id) { + case ACPI_RSTYPE_IRQ: + { + struct acpi_resource_irq *p = &resource->data.irq; + if (!p || !p->number_of_interrupts) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "Blank IRQ resource\n")); + return AE_OK; + } + *irq = p->interrupts[0]; + break; + } + case ACPI_RSTYPE_EXT_IRQ: + { + struct acpi_resource_ext_irq *p = &resource->data.extended_irq; + if (!p || !p->number_of_interrupts) { + ACPI_DEBUG_PRINT((ACPI_DB_WARN, + "Blank IRQ resource\n")); + return AE_OK; + } + *irq = p->interrupts[0]; + break; + } + default: + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, + "Resource isn't an IRQ\n")); + return AE_OK; + } + return AE_CTRL_TERMINATE; } @@ -180,8 +220,6 @@ { int result = 0; acpi_status status = AE_OK; - struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; - struct acpi_resource *resource = NULL; int irq = 0; ACPI_FUNCTION_TRACE("acpi_pci_link_get_current"); @@ -206,47 +244,16 @@ * Query and parse _CRS to get the current IRQ assignment. */ - status = acpi_get_current_resources(link->handle, &buffer); + status = acpi_walk_resources(link->handle, METHOD_NAME__CRS, + acpi_pci_link_check_current, &irq); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _CRS\n")); result = -ENODEV; goto end; } - resource = (struct acpi_resource *) buffer.pointer; - - switch (resource->id) { - case ACPI_RSTYPE_IRQ: - { - struct acpi_resource_irq *p = &resource->data.irq; - if (!p || !p->number_of_interrupts) { - ACPI_DEBUG_PRINT((ACPI_DB_WARN, - "Blank IRQ resource\n")); - result = -ENODEV; - goto end; - } - irq = p->interrupts[0]; - break; - } - case ACPI_RSTYPE_EXT_IRQ: - { - struct acpi_resource_ext_irq *p = &resource->data.extended_irq; - if (!p || !p->number_of_interrupts) { - ACPI_DEBUG_PRINT((ACPI_DB_WARN, - "Blank IRQ resource\n")); - result = -ENODEV; - goto end; - } - irq = p->interrupts[0]; - break; - } - default: - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Resource isn't an IRQ\n")); - result = -ENODEV; - goto end; - } if (!irq) { - ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid use of IRQ 0\n")); + ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "No IRQ resource found\n")); result = -ENODEV; goto end; } @@ -263,8 +270,6 @@ ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Link at IRQ %d \n", link->irq.active)); end: - acpi_os_free(buffer.pointer); - return_VALUE(result); } diff -Nru a/drivers/acpi/power.c b/drivers/acpi/power.c --- a/drivers/acpi/power.c Tue Mar 4 19:30:09 2003 +++ b/drivers/acpi/power.c Tue Mar 4 19:30:09 2003 @@ -351,7 +351,7 @@ /* * First we reference all power resources required in the target list - * (e.g. so the device doesn't loose power while transitioning). + * (e.g. so the device doesn't lose power while transitioning). */ for (i=0; icount; i++) { result = acpi_power_on(tl->handles[i]); diff -Nru a/drivers/acpi/processor.c b/drivers/acpi/processor.c --- a/drivers/acpi/processor.c Tue Mar 4 19:30:11 2003 +++ b/drivers/acpi/processor.c Tue Mar 4 19:30:11 2003 @@ -1560,7 +1560,7 @@ acpi_status status = 0; union acpi_object object = {0}; struct acpi_buffer buffer = {sizeof(union acpi_object), &object}; - static int cpu_count = 0; + static int cpu_index = 0; ACPI_FUNCTION_TRACE("acpi_processor_get_info"); @@ -1570,6 +1570,13 @@ if (num_online_cpus() > 1) errata.smp = TRUE; + /* + * Extra Processor objects may be enumerated on MP systems with + * less than the max # of CPUs. They should be ignored. + */ + if ((cpu_index + 1) > num_online_cpus()) + return_VALUE(-ENODEV); + acpi_processor_errata(pr); /* @@ -1601,7 +1608,7 @@ * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP. * >>> 'acpi_get_processor_id(acpi_id, &id)' in arch/xxx/acpi.c */ - pr->id = cpu_count++; + pr->id = cpu_index++; pr->acpi_id = object.processor.proc_id; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id, @@ -1609,21 +1616,17 @@ if (!object.processor.pblk_address) ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n")); - else if (object.processor.pblk_length < 4) + else if (object.processor.pblk_length != 6) ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid PBLK length [%d]\n", object.processor.pblk_length)); else { pr->throttling.address = object.processor.pblk_address; pr->throttling.duty_offset = acpi_fadt.duty_offset; pr->throttling.duty_width = acpi_fadt.duty_width; - - if (object.processor.pblk_length >= 5) - pr->power.states[ACPI_STATE_C2].address = - object.processor.pblk_address + 4; - - if (object.processor.pblk_length >= 6) - pr->power.states[ACPI_STATE_C3].address = - object.processor.pblk_address + 5; + pr->power.states[ACPI_STATE_C2].address = + object.processor.pblk_address + 4; + pr->power.states[ACPI_STATE_C3].address = + object.processor.pblk_address + 5; } acpi_processor_get_power_info(pr); diff -Nru a/drivers/acpi/resources/rsmemory.c b/drivers/acpi/resources/rsmemory.c --- a/drivers/acpi/resources/rsmemory.c Tue Mar 4 19:30:13 2003 +++ b/drivers/acpi/resources/rsmemory.c Tue Mar 4 19:30:13 2003 @@ -278,7 +278,7 @@ /* * Point to the place in the output buffer where the data portion will * begin. - * 1. Set the RESOURCE_DATA * Data to point to it's own address, then + * 1. Set the RESOURCE_DATA * Data to point to its own address, then * 2. Set the pointer to the next address. * * NOTE: output_struct->Data is cast to u8, otherwise, this addition adds diff -Nru a/drivers/acpi/resources/rsutils.c b/drivers/acpi/resources/rsutils.c --- a/drivers/acpi/resources/rsutils.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/resources/rsutils.c Tue Mar 4 19:30:04 2003 @@ -214,6 +214,60 @@ /******************************************************************************* * + * FUNCTION: acpi_rs_get_method_data + * + * PARAMETERS: Handle - a handle to the containing object + * ret_buffer - a pointer to a buffer structure for the + * results + * + * RETURN: Status + * + * DESCRIPTION: This function is called to get the _CRS or _PRS value of an + * object contained in an object specified by the handle passed in + * + * If the function fails an appropriate status will be returned + * and the contents of the callers buffer is undefined. + * + ******************************************************************************/ + +acpi_status +acpi_rs_get_method_data ( + acpi_handle handle, + char *path, + struct acpi_buffer *ret_buffer) +{ + union acpi_operand_object *obj_desc; + acpi_status status; + + + ACPI_FUNCTION_TRACE ("rs_get_method_data"); + + + /* Parameters guaranteed valid by caller */ + + /* + * Execute the method, no parameters + */ + status = acpi_ut_evaluate_object (handle, path, ACPI_BTYPE_BUFFER, &obj_desc); + if (ACPI_FAILURE (status)) { + return_ACPI_STATUS (status); + } + + /* + * Make the call to create a resource linked list from the + * byte stream buffer that comes back from the method + * execution. + */ + status = acpi_rs_create_resource_list (obj_desc, ret_buffer); + + /* On exit, we must delete the object returned by evaluate_object */ + + acpi_ut_remove_reference (obj_desc); + return_ACPI_STATUS (status); +} + +/******************************************************************************* + * * FUNCTION: acpi_rs_set_srs_method_data * * PARAMETERS: Handle - a handle to the containing object diff -Nru a/drivers/acpi/resources/rsxface.c b/drivers/acpi/resources/rsxface.c --- a/drivers/acpi/resources/rsxface.c Tue Mar 4 19:30:11 2003 +++ b/drivers/acpi/resources/rsxface.c Tue Mar 4 19:30:11 2003 @@ -212,6 +212,90 @@ /******************************************************************************* * + * FUNCTION: acpi_walk_resources + * + * PARAMETERS: device_handle - a handle to the device object for the + * device we are querying + * Path - method name of the resources we want + * (METHOD_NAME__CRS or METHOD_NAME__PRS) + * user_function - called for each resource + * Context - passed to user_function + * + * RETURN: Status + * + * DESCRIPTION: Retrieves the current or possible resource list for the + * specified device. The user_function is called once for + * each resource in the list. + * + ******************************************************************************/ + +acpi_status +acpi_walk_resources ( + acpi_handle device_handle, + char *path, + ACPI_WALK_RESOURCE_CALLBACK user_function, + void *context) +{ + acpi_status status; + struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; + struct acpi_resource *resource; + + ACPI_FUNCTION_TRACE ("acpi_walk_resources"); + + + if (!device_handle || + (ACPI_STRNCMP (path, METHOD_NAME__CRS, sizeof (METHOD_NAME__CRS)) && + ACPI_STRNCMP (path, METHOD_NAME__PRS, sizeof (METHOD_NAME__PRS)))) { + return_ACPI_STATUS (AE_BAD_PARAMETER); + } + + status = acpi_rs_get_method_data (device_handle, path, &buffer); + if (ACPI_FAILURE (status)) { + return_ACPI_STATUS (status); + } + + resource = (struct acpi_resource *) buffer.pointer; + for (;;) { + if (!resource || resource->id == ACPI_RSTYPE_END_TAG) { + break; + } + + status = user_function (resource, context); + + switch (status) { + case AE_OK: + case AE_CTRL_DEPTH: + + /* Just keep going */ + status = AE_OK; + break; + + case AE_CTRL_TERMINATE: + + /* Exit now, with OK stats */ + + status = AE_OK; + goto cleanup; + + default: + + /* All others are valid exceptions */ + + goto cleanup; + } + + resource = ACPI_NEXT_RESOURCE (resource); + } + +cleanup: + + acpi_os_free (buffer.pointer); + + return_ACPI_STATUS (status); +} + +/******************************************************************************* + * * FUNCTION: acpi_set_current_resources * * PARAMETERS: device_handle - a handle to the device object for the @@ -251,4 +335,65 @@ status = acpi_rs_set_srs_method_data (device_handle, in_buffer); return_ACPI_STATUS (status); +} + +#define COPY_FIELD(out, in, field) out->field = in->field +#define COPY_ADDRESS(out, in) \ + COPY_FIELD(out, in, resource_type); \ + COPY_FIELD(out, in, producer_consumer); \ + COPY_FIELD(out, in, decode); \ + COPY_FIELD(out, in, min_address_fixed); \ + COPY_FIELD(out, in, max_address_fixed); \ + COPY_FIELD(out, in, attribute); \ + COPY_FIELD(out, in, granularity); \ + COPY_FIELD(out, in, min_address_range); \ + COPY_FIELD(out, in, max_address_range); \ + COPY_FIELD(out, in, address_translation_offset); \ + COPY_FIELD(out, in, address_length); \ + COPY_FIELD(out, in, resource_source); + +/******************************************************************************* +* +* FUNCTION: acpi_resource_to_address64 +* +* PARAMETERS: resource - Pointer to a resource +* out - Pointer to the users's return +* buffer (a struct +* struct acpi_resource_address64) +* +* RETURN: Status +* +* DESCRIPTION: If the resource is an address16, address32, or address64, +* copy it to the address64 return buffer. This saves the +* caller from having to duplicate code for different-sized +* addresses. +* +******************************************************************************/ + +acpi_status +acpi_resource_to_address64 ( + struct acpi_resource *resource, + struct acpi_resource_address64 *out) +{ + struct acpi_resource_address16 *address16; + struct acpi_resource_address32 *address32; + struct acpi_resource_address64 *address64; + + switch (resource->id) { + case ACPI_RSTYPE_ADDRESS16: + address16 = (struct acpi_resource_address16 *) &resource->data; + COPY_ADDRESS(out, address16); + break; + case ACPI_RSTYPE_ADDRESS32: + address32 = (struct acpi_resource_address32 *) &resource->data; + COPY_ADDRESS(out, address32); + break; + case ACPI_RSTYPE_ADDRESS64: + address64 = (struct acpi_resource_address64 *) &resource->data; + COPY_ADDRESS(out, address64); + break; + default: + return (AE_BAD_PARAMETER); + } + return (AE_OK); } diff -Nru a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c --- a/drivers/acpi/sleep/main.c Tue Mar 4 19:30:03 2003 +++ b/drivers/acpi/sleep/main.c Tue Mar 4 19:30:03 2003 @@ -183,14 +183,21 @@ status = acpi_enter_sleep_state(state); break; - case ACPI_STATE_S2: #ifdef CONFIG_SOFTWARE_SUSPEND + case ACPI_STATE_S2: case ACPI_STATE_S3: do_suspend_lowlevel(0); + break; #endif + case ACPI_STATE_S4: + do_suspend_lowlevel_s4bios(0); + break; + default: + printk(KERN_WARNING PREFIX "don't know how to handle %d state.\n", state); break; } local_irq_restore(flags); + printk(KERN_CRIT "Back to C!\n"); return status; } @@ -211,21 +218,31 @@ if (state < ACPI_STATE_S1 || state > ACPI_STATE_S5) return AE_ERROR; + /* Since we handle S4OS via a different path (swsusp), give up if no s4bios. */ + if (state == ACPI_STATE_S4 && !acpi_gbl_FACS->S4bios_f) + return AE_ERROR; + + /* + * TBD: S1 can be done without device_suspend. Make a CONFIG_XX + * to handle however when S1 failed without device_suspend. + */ freeze_processes(); /* device_suspend needs processes to be stopped */ /* do we have a wakeup address for S2 and S3? */ - if (state == ACPI_STATE_S2 || state == ACPI_STATE_S3) { + /* Here, we support only S4BIOS, those we set the wakeup address */ + /* S4OS is only supported for now via swsusp.. */ + if (state == ACPI_STATE_S2 || state == ACPI_STATE_S3 || ACPI_STATE_S4) { if (!acpi_wakeup_address) return AE_ERROR; acpi_set_firmware_waking_vector((acpi_physical_address) acpi_wakeup_address); } - acpi_enter_sleep_state_prep(state); - status = acpi_system_save_state(state); if (!ACPI_SUCCESS(status)) return status; + acpi_enter_sleep_state_prep(state); + /* disable interrupts and flush caches */ ACPI_DISABLE_IRQS(); ACPI_FLUSH_CPU_CACHE(); @@ -237,8 +254,8 @@ * mode. So, we run these unconditionaly to make sure we have a usable system * no matter what. */ - acpi_system_restore_state(state); acpi_leave_sleep_state(state); + acpi_system_restore_state(state); /* make sure interrupts are enabled */ ACPI_ENABLE_IRQS(); @@ -267,6 +284,10 @@ if (ACPI_SUCCESS(status)) { sleep_states[i] = 1; printk(" S%d", i); + } + if (i == ACPI_STATE_S4 && acpi_gbl_FACS->S4bios_f) { + sleep_states[i] = 1; + printk(" S4bios"); } } printk(")\n"); diff -Nru a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c --- a/drivers/acpi/sleep/proc.c Tue Mar 4 19:30:11 2003 +++ b/drivers/acpi/sleep/proc.c Tue Mar 4 19:30:11 2003 @@ -27,8 +27,11 @@ ACPI_FUNCTION_TRACE("acpi_system_sleep_seq_show"); for (i = 0; i <= ACPI_STATE_S5; i++) { - if (sleep_states[i]) + if (sleep_states[i]) { seq_printf(seq,"S%d ", i); + if (i == ACPI_STATE_S4 && acpi_gbl_FACS->S4bios_f) + seq_printf(seq, "S4bios "); + } } seq_puts(seq, "\n"); diff -Nru a/drivers/acpi/tables/tbconvrt.c b/drivers/acpi/tables/tbconvrt.c --- a/drivers/acpi/tables/tbconvrt.c Tue Mar 4 19:30:07 2003 +++ b/drivers/acpi/tables/tbconvrt.c Tue Mar 4 19:30:07 2003 @@ -239,9 +239,8 @@ ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xpm1b_cnt_blk, local_fadt->pm1_cnt_len, local_fadt->V1_pm1b_cnt_blk); ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xpm2_cnt_blk, local_fadt->pm2_cnt_len, local_fadt->V1_pm2_cnt_blk); ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xpm_tmr_blk, local_fadt->pm_tm_len, local_fadt->V1_pm_tmr_blk); - ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe0_blk, local_fadt->gpe0_blk_len, local_fadt->V1_gpe0_blk); - ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe1_blk, local_fadt->gpe1_blk_len, local_fadt->V1_gpe1_blk); - + ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe0_blk, 0, local_fadt->V1_gpe0_blk); + ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe1_blk, 0, local_fadt->V1_gpe1_blk); } @@ -314,14 +313,15 @@ if (!(local_fadt->xgpe0_blk.address)) { ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe0_blk, - local_fadt->gpe0_blk_len, local_fadt->V1_gpe0_blk); + 0, local_fadt->V1_gpe0_blk); } if (!(local_fadt->xgpe1_blk.address)) { ASL_BUILD_GAS_FROM_V1_ENTRY (local_fadt->xgpe1_blk, - local_fadt->gpe1_blk_len, local_fadt->V1_gpe1_blk); + 0, local_fadt->V1_gpe1_blk); } } + /******************************************************************************* * diff -Nru a/drivers/acpi/tables.c b/drivers/acpi/tables.c --- a/drivers/acpi/tables.c Tue Mar 4 19:30:07 2003 +++ b/drivers/acpi/tables.c Tue Mar 4 19:30:07 2003 @@ -379,6 +379,7 @@ sdt.pa = ((struct acpi20_table_rsdp*)rsdp)->xsdt_address; + /* map in just the header */ header = (struct acpi_table_header *) __acpi_map_table(sdt.pa, sizeof(struct acpi_table_header)); @@ -387,6 +388,15 @@ return -ENODEV; } + /* remap in the entire table before processing */ + mapped_xsdt = (struct acpi_table_xsdt *) + __acpi_map_table(sdt.pa, header->length); + if (!mapped_xsdt) { + printk(KERN_WARNING PREFIX "Unable to map XSDT\n"); + return -ENODEV; + } + header = &mapped_xsdt->header; + if (strncmp(header->signature, "XSDT", 4)) { printk(KERN_WARNING PREFIX "XSDT signature incorrect\n"); return -ENODEV; @@ -404,15 +414,6 @@ sdt.count = ACPI_MAX_TABLES; } - mapped_xsdt = (struct acpi_table_xsdt *) - __acpi_map_table(sdt.pa, header->length); - if (!mapped_xsdt) { - printk(KERN_WARNING PREFIX "Unable to map XSDT\n"); - return -ENODEV; - } - - header = &mapped_xsdt->header; - for (i = 0; i < sdt.count; i++) sdt.entry[i].pa = (unsigned long) mapped_xsdt->entry[i]; } @@ -425,6 +426,7 @@ sdt.pa = rsdp->rsdt_address; + /* map in just the header */ header = (struct acpi_table_header *) __acpi_map_table(sdt.pa, sizeof(struct acpi_table_header)); if (!header) { @@ -432,6 +434,15 @@ return -ENODEV; } + /* remap in the entire table before processing */ + mapped_rsdt = (struct acpi_table_rsdt *) + __acpi_map_table(sdt.pa, header->length); + if (!mapped_rsdt) { + printk(KERN_WARNING PREFIX "Unable to map RSDT\n"); + return -ENODEV; + } + header = &mapped_rsdt->header; + if (strncmp(header->signature, "RSDT", 4)) { printk(KERN_WARNING PREFIX "RSDT signature incorrect\n"); return -ENODEV; @@ -449,15 +460,6 @@ sdt.count = ACPI_MAX_TABLES; } - mapped_rsdt = (struct acpi_table_rsdt *) - __acpi_map_table(sdt.pa, header->length); - if (!mapped_rsdt) { - printk(KERN_WARNING PREFIX "Unable to map RSDT\n"); - return -ENODEV; - } - - header = &mapped_rsdt->header; - for (i = 0; i < sdt.count; i++) sdt.entry[i].pa = (unsigned long) mapped_rsdt->entry[i]; } @@ -471,12 +473,20 @@ for (i = 0; i < sdt.count; i++) { + /* map in just the header */ header = (struct acpi_table_header *) __acpi_map_table(sdt.entry[i].pa, sizeof(struct acpi_table_header)); if (!header) continue; + /* remap in the entire table before processing */ + header = (struct acpi_table_header *) + __acpi_map_table(sdt.entry[i].pa, + header->length); + if (!header) + continue; + acpi_table_print(header, sdt.entry[i].pa); if (acpi_table_compute_checksum(header, header->length)) { diff -Nru a/drivers/acpi/utilities/utcopy.c b/drivers/acpi/utilities/utcopy.c --- a/drivers/acpi/utilities/utcopy.c Tue Mar 4 19:30:08 2003 +++ b/drivers/acpi/utilities/utcopy.c Tue Mar 4 19:30:08 2003 @@ -645,11 +645,11 @@ /* * Allocate and copy the actual buffer if and only if: - * 1) There is a valid buffer (length > 0) + * 1) There is a valid buffer pointer * 2) The buffer is not static (not in an ACPI table) (in this case, * the actual pointer was already copied above) */ - if ((source_desc->buffer.length) && + if ((source_desc->buffer.pointer) && (!(source_desc->common.flags & AOPOBJ_STATIC_POINTER))) { dest_desc->buffer.pointer = ACPI_MEM_ALLOCATE (source_desc->buffer.length); if (!dest_desc->buffer.pointer) { @@ -665,11 +665,11 @@ /* * Allocate and copy the actual string if and only if: - * 1) There is a valid string (length > 0) + * 1) There is a valid string pointer * 2) The string is not static (not in an ACPI table) (in this case, * the actual pointer was already copied above) */ - if ((source_desc->string.length) && + if ((source_desc->string.pointer) && (!(source_desc->common.flags & AOPOBJ_STATIC_POINTER))) { dest_desc->string.pointer = ACPI_MEM_ALLOCATE ((acpi_size) source_desc->string.length + 1); if (!dest_desc->string.pointer) { diff -Nru a/drivers/acpi/utilities/utglobal.c b/drivers/acpi/utilities/utglobal.c --- a/drivers/acpi/utilities/utglobal.c Tue Mar 4 19:30:04 2003 +++ b/drivers/acpi/utilities/utglobal.c Tue Mar 4 19:30:04 2003 @@ -729,6 +729,10 @@ acpi_gbl_acpi_mutex_info[i].use_count = 0; } + /* GPE support */ + + acpi_gbl_gpe_block_list_head = NULL; + /* Global notify handlers */ acpi_gbl_sys_notify.handler = NULL; @@ -766,8 +770,6 @@ /* Hardware oriented */ - acpi_gbl_gpe_register_info = NULL; - acpi_gbl_gpe_number_info = NULL; acpi_gbl_events_initialized = FALSE; /* Namespace */ diff -Nru a/drivers/atm/firestream.c b/drivers/atm/firestream.c --- a/drivers/atm/firestream.c Tue Mar 4 19:30:04 2003 +++ b/drivers/atm/firestream.c Tue Mar 4 19:30:04 2003 @@ -105,7 +105,7 @@ The FS50 CAM (VP/VC match registers) always take the lowest channel number that matches. This is not a problem. - However, they also ignore wether the channel is enabled or + However, they also ignore whether the channel is enabled or not. This means that if you allocate channel 0 to 1.2 and then channel 1 to 0.0, then disabeling channel 0 and writing 0 to the match channel for channel 0 will "steal" the traffic from channel diff -Nru a/drivers/atm/fore200e.c b/drivers/atm/fore200e.c --- a/drivers/atm/fore200e.c Tue Mar 4 19:30:14 2003 +++ b/drivers/atm/fore200e.c Tue Mar 4 19:30:14 2003 @@ -1132,8 +1132,7 @@ return; } - do_gettimeofday(&vcc->timestamp); - skb->stamp = vcc->timestamp; + do_gettimeofday(&skb->stamp); #ifdef FORE200E_52BYTE_AAL0_SDU if (cell_header) { diff -Nru a/drivers/atm/horizon.c b/drivers/atm/horizon.c --- a/drivers/atm/horizon.c Tue Mar 4 19:30:03 2003 +++ b/drivers/atm/horizon.c Tue Mar 4 19:30:03 2003 @@ -2874,11 +2874,7 @@ // writes to adapter memory (handles IRQ and SMP) spin_lock_init (&dev->mem_lock); -#if LINUX_VERSION_CODE >= 0x20303 init_waitqueue_head (&dev->tx_queue); -#else - dev->tx_queue = 0; -#endif // vpi in 0..4, vci in 6..10 dev->atm_dev->ci_range.vpi_bits = vpi_bits; diff -Nru a/drivers/atm/horizon.h b/drivers/atm/horizon.h --- a/drivers/atm/horizon.h Tue Mar 4 19:30:13 2003 +++ b/drivers/atm/horizon.h Tue Mar 4 19:30:13 2003 @@ -422,11 +422,7 @@ unsigned int tx_regions; // number of remaining regions spinlock_t mem_lock; -#if LINUX_VERSION_CODE >= 0x20303 wait_queue_head_t tx_queue; -#else - struct wait_queue * tx_queue; -#endif u8 irq; long flags; diff -Nru a/drivers/atm/iphase.c b/drivers/atm/iphase.c --- a/drivers/atm/iphase.c Tue Mar 4 19:30:13 2003 +++ b/drivers/atm/iphase.c Tue Mar 4 19:30:13 2003 @@ -436,7 +436,7 @@ if (crm == 0) crm = 1; f_abr_vc->f_crm = crm & 0xff; f_abr_vc->f_pcr = cellrate_to_float(srv_p->pcr); - icr = MIN( srv_p->icr, (srv_p->tbe > srv_p->frtt) ? + icr = min( srv_p->icr, (srv_p->tbe > srv_p->frtt) ? ((srv_p->tbe/srv_p->frtt)*1000000) : (1000000/(srv_p->frtt/srv_p->tbe))); f_abr_vc->f_icr = cellrate_to_float(icr); @@ -2071,7 +2071,7 @@ - UBR Table size is 4K - UBR wait queue is 4K since the table and wait queues are contiguous, all the bytes - can be intialized by one memeset. + can be initialized by one memeset. */ vcsize_sel = 0; diff -Nru a/drivers/atm/iphase.h b/drivers/atm/iphase.h --- a/drivers/atm/iphase.h Tue Mar 4 19:30:05 2003 +++ b/drivers/atm/iphase.h Tue Mar 4 19:30:05 2003 @@ -808,7 +808,6 @@ } r_vc_abr_entry; #define MRM 3 -#define MIN(x,y) ((x) < (y)) ? (x) : (y) typedef struct srv_cls_param { u32 class_type; /* CBR/VBR/ABR/UBR; use the enum above */ @@ -1017,13 +1016,8 @@ spinlock_t tx_lock; IARTN_Q tx_return_q; u32 close_pending; -#if LINUX_VERSION_CODE >= 0x20303 wait_queue_head_t close_wait; wait_queue_head_t timeout_wait; -#else - struct wait_queue *close_wait; - struct wait_queue *timeout_wait; -#endif struct cpcs_trailer_desc *tx_buf; u16 num_tx_desc, tx_buf_sz, rate_limit; u32 tx_cell_cnt, tx_pkt_cnt; diff -Nru a/drivers/atm/lanai.c b/drivers/atm/lanai.c --- a/drivers/atm/lanai.c Tue Mar 4 19:30:05 2003 +++ b/drivers/atm/lanai.c Tue Mar 4 19:30:05 2003 @@ -1300,7 +1300,7 @@ #define DESCRIPTOR_AAL5_STREAM (0x00004000) #define DESCRIPTOR_CLP (0x00002000) -/* Add 32-bit descriptor with it's padding */ +/* Add 32-bit descriptor with its padding */ static inline void vcc_tx_add_aal5_descriptor(struct lanai_vcc *lvcc, u32 flags, int len) { diff -Nru a/drivers/atm/suni.c b/drivers/atm/suni.c --- a/drivers/atm/suni.c Tue Mar 4 19:30:12 2003 +++ b/drivers/atm/suni.c Tue Mar 4 19:30:12 2003 @@ -233,8 +233,6 @@ if (!(PRIV(dev) = kmalloc(sizeof(struct suni_priv),GFP_KERNEL))) return -ENOMEM; - MOD_INC_USE_COUNT; - PRIV(dev)->dev = dev; spin_lock_irqsave(&sunis_lock,flags); first = !sunis; @@ -280,7 +278,6 @@ spin_unlock_irqrestore(&sunis_lock,flags); kfree(PRIV(dev)); - MOD_DEC_USE_COUNT; return 0; } @@ -293,7 +290,7 @@ }; -int __init suni_init(struct atm_dev *dev) +int suni_init(struct atm_dev *dev) { unsigned char mri; diff -Nru a/drivers/base/Makefile b/drivers/base/Makefile --- a/drivers/base/Makefile Tue Mar 4 19:30:13 2003 +++ b/drivers/base/Makefile Tue Mar 4 19:30:13 2003 @@ -2,7 +2,7 @@ obj-y := core.o sys.o interface.o power.o bus.o \ driver.o class.o intf.o platform.o \ - cpu.o firmware.o + cpu.o firmware.o init.o obj-$(CONFIG_NUMA) += node.o memblk.o obj-y += fs/ obj-$(CONFIG_HOTPLUG) += hotplug.o diff -Nru a/drivers/base/base.h b/drivers/base/base.h --- a/drivers/base/base.h Tue Mar 4 19:30:07 2003 +++ b/drivers/base/base.h Tue Mar 4 19:30:07 2003 @@ -1,6 +1,7 @@ #undef DEBUG extern struct semaphore device_sem; +extern struct semaphore devclass_sem; extern int bus_add_device(struct device * dev); extern void bus_remove_device(struct device * dev); diff -Nru a/drivers/base/bus.c b/drivers/base/bus.c --- a/drivers/base/bus.c Tue Mar 4 19:30:05 2003 +++ b/drivers/base/bus.c Tue Mar 4 19:30:05 2003 @@ -459,7 +459,7 @@ * @drv: driver. * * Detach the driver from the devices it controls, and remove - * it from it's bus's list of drivers. Finally, we drop the reference + * it from its bus's list of drivers. Finally, we drop the reference * to the bus we took in bus_add_driver(). */ @@ -544,12 +544,11 @@ subsystem_unregister(&bus->subsys); } -static int __init bus_subsys_init(void) +int __init buses_init(void) { return subsystem_register(&bus_subsys); } -core_initcall(bus_subsys_init); EXPORT_SYMBOL(bus_for_each_dev); EXPORT_SYMBOL(bus_for_each_drv); diff -Nru a/drivers/base/class.c b/drivers/base/class.c --- a/drivers/base/class.c Tue Mar 4 19:30:14 2003 +++ b/drivers/base/class.c Tue Mar 4 19:30:14 2003 @@ -13,6 +13,8 @@ #define to_class_attr(_attr) container_of(_attr,struct devclass_attribute,attr) #define to_class(obj) container_of(obj,struct device_class,subsys.kset.kobj) +DECLARE_MUTEX(devclass_sem); + static ssize_t devclass_attr_show(struct kobject * kobj, struct attribute * attr, char * buf) { @@ -163,29 +165,34 @@ struct device_class * cls; int error = 0; + down(&devclass_sem); if (dev->driver) { cls = get_devclass(dev->driver->devclass); - if (cls) { - down_write(&cls->subsys.rwsem); - pr_debug("device class %s: adding device %s\n", - cls->name,dev->name); - if (cls->add_device) - error = cls->add_device(dev); - if (!error) { - enum_device(cls,dev); - interface_add_dev(dev); - } - - list_add_tail(&dev->class_list,&cls->devices.list); - - /* notify userspace (call /sbin/hotplug) */ - class_hotplug (dev, "add"); - - up_write(&cls->subsys.rwsem); - if (error) - put_devclass(cls); + + if (!cls) + goto Done; + + pr_debug("device class %s: adding device %s\n", + cls->name,dev->name); + if (cls->add_device) + error = cls->add_device(dev); + if (error) { + put_devclass(cls); + goto Done; } + + down_write(&cls->subsys.rwsem); + enum_device(cls,dev); + list_add_tail(&dev->class_list,&cls->devices.list); + /* notify userspace (call /sbin/hotplug) */ + class_hotplug (dev, "add"); + + up_write(&cls->subsys.rwsem); + + interface_add_dev(dev); } + Done: + up(&devclass_sem); return error; } @@ -193,26 +200,33 @@ { struct device_class * cls; + down(&devclass_sem); if (dev->driver) { cls = dev->driver->devclass; - if (cls) { - down_write(&cls->subsys.rwsem); - pr_debug("device class %s: removing device %s\n", - cls->name,dev->name); - interface_remove_dev(dev); - unenum_device(cls,dev); - - list_del(&dev->class_list); - - /* notify userspace (call /sbin/hotplug) */ - class_hotplug (dev, "remove"); - - if (cls->remove_device) - cls->remove_device(dev); - up_write(&cls->subsys.rwsem); - put_devclass(cls); - } + if (!cls) + goto Done; + + interface_remove_dev(dev); + + down_write(&cls->subsys.rwsem); + pr_debug("device class %s: removing device %s\n", + cls->name,dev->name); + + unenum_device(cls,dev); + + list_del(&dev->class_list); + + /* notify userspace (call /sbin/hotplug) */ + class_hotplug (dev, "remove"); + + up_write(&cls->subsys.rwsem); + + if (cls->remove_device) + cls->remove_device(dev); + put_devclass(cls); } + Done: + up(&devclass_sem); } struct device_class * get_devclass(struct device_class * cls) @@ -252,12 +266,10 @@ subsystem_unregister(&cls->subsys); } -static int __init class_subsys_init(void) +int __init classes_init(void) { return subsystem_register(&class_subsys); } - -core_initcall(class_subsys_init); EXPORT_SYMBOL(devclass_create_file); EXPORT_SYMBOL(devclass_remove_file); diff -Nru a/drivers/base/core.c b/drivers/base/core.c --- a/drivers/base/core.c Tue Mar 4 19:30:04 2003 +++ b/drivers/base/core.c Tue Mar 4 19:30:04 2003 @@ -143,7 +143,6 @@ INIT_LIST_HEAD(&dev->driver_list); INIT_LIST_HEAD(&dev->bus_list); INIT_LIST_HEAD(&dev->class_list); - INIT_LIST_HEAD(&dev->intf_list); } /** @@ -310,12 +309,10 @@ put_device(dev); } -static int __init device_subsys_init(void) +int __init devices_init(void) { return subsystem_register(&devices_subsys); } - -core_initcall(device_subsys_init); EXPORT_SYMBOL(device_initialize); EXPORT_SYMBOL(device_add); diff -Nru a/drivers/base/cpu.c b/drivers/base/cpu.c --- a/drivers/base/cpu.c Tue Mar 4 19:30:05 2003 +++ b/drivers/base/cpu.c Tue Mar 4 19:30:05 2003 @@ -46,9 +46,8 @@ } -static int __init register_cpu_type(void) +int __init cpu_dev_init(void) { devclass_register(&cpu_devclass); return driver_register(&cpu_driver); } -postcore_initcall(register_cpu_type); diff -Nru a/drivers/base/firmware.c b/drivers/base/firmware.c --- a/drivers/base/firmware.c Tue Mar 4 19:30:09 2003 +++ b/drivers/base/firmware.c Tue Mar 4 19:30:09 2003 @@ -19,12 +19,10 @@ subsystem_unregister(s); } -static int __init firmware_init(void) +int __init firmware_init(void) { return subsystem_register(&firmware_subsys); } - -core_initcall(firmware_init); EXPORT_SYMBOL(firmware_register); EXPORT_SYMBOL(firmware_unregister); diff -Nru a/drivers/base/hotplug.c b/drivers/base/hotplug.c --- a/drivers/base/hotplug.c Tue Mar 4 19:30:03 2003 +++ b/drivers/base/hotplug.c Tue Mar 4 19:30:03 2003 @@ -17,6 +17,8 @@ #include #include #include +#include +#include #include "base.h" #include "fs/fs.h" diff -Nru a/drivers/base/init.c b/drivers/base/init.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/base/init.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,34 @@ + +#include +#include + +extern int devices_init(void); +extern int buses_init(void); +extern int classes_init(void); +extern int firmware_init(void); +extern int platform_bus_init(void); +extern int sys_bus_init(void); +extern int cpu_dev_init(void); + +/** + * driver_init - initialize driver model. + * + * Call the driver model init functions to initialize their + * subsystems. Called early from init/main.c. + */ + +void __init driver_init(void) +{ + /* These are the core pieces */ + devices_init(); + buses_init(); + classes_init(); + firmware_init(); + + /* These are also core pieces, but must come after the + * core core pieces. + */ + platform_bus_init(); + sys_bus_init(); + cpu_dev_init(); +} diff -Nru a/drivers/base/intf.c b/drivers/base/intf.c --- a/drivers/base/intf.c Tue Mar 4 19:30:13 2003 +++ b/drivers/base/intf.c Tue Mar 4 19:30:13 2003 @@ -12,80 +12,31 @@ #define to_intf(node) container_of(node,struct device_interface,kset.kobj.entry) -#define to_data(e) container_of(e,struct intf_data,kobj.entry) +#define to_dev(d) container_of(d,struct device,class_list) /** * intf_dev_link - create sysfs symlink for interface. - * @data: interface data descriptor. + * @intf: interface. + * @dev: device. * * Create a symlink 'phys' in the interface's directory to */ -static int intf_dev_link(struct intf_data * data) +static int intf_dev_link(struct device_interface * intf, struct device * dev) { - char name[16]; - snprintf(name,16,"%d",data->intf_num); - return sysfs_create_link(&data->intf->kset.kobj,&data->dev->kobj,name); + return sysfs_create_link(&intf->kset.kobj,&dev->kobj,dev->bus_id); } /** * intf_dev_unlink - remove symlink for interface. - * @intf: interface data descriptor. - * - */ - -static void intf_dev_unlink(struct intf_data * data) -{ - char name[16]; - snprintf(name,16,"%d",data->intf_num); - sysfs_remove_link(&data->intf->kset.kobj,name); -} - - -/** - * interface_add_data - attach data descriptor - * @data: interface data descriptor. - * - * This attaches the per-instance interface object to the - * interface (by registering its kobject) and the device - * itself (by inserting it into the device's list). - * - * Note that there is no explicit protection done in this - * function. This should be called from the interface's - * add_device() method, which is called under the protection - * of the class's rwsem. - */ - -int interface_add_data(struct intf_data * data) -{ - struct device_interface * intf = data->intf; - - if (intf) { - data->intf_num = intf->devnum++; - data->kobj.kset = &intf->kset; - kobject_register(&data->kobj); - - list_add_tail(&data->dev_entry,&data->dev->intf_list); - return intf_dev_link(data); - } - return -EINVAL; -} - - -/** - * interface_remove_data - detach data descriptor. - * @data: interface data descriptor. + * @intf: interface. + * @dev: device. * - * This detaches the per-instance data descriptor by removing - * it from the device's list and unregistering the kobject from - * the subsystem. */ -void interface_remove_data(struct intf_data * data) +static void intf_dev_unlink(struct device_interface * intf, struct device * dev) { - intf_dev_unlink(data); - list_del_init(&data->dev_entry); - kobject_unregister(&data->kobj); + sysfs_remove_link(&intf->kset.kobj,dev->bus_id); } @@ -103,33 +54,28 @@ { int error = 0; - if (intf->add_device) - error = intf->add_device(dev); + if (intf->add_device) { + if (!(error = intf->add_device(dev))) + intf_dev_link(intf,dev); + } pr_debug(" -> %s (%d)\n",dev->bus_id,error); return error; } /** * del - detach device from interface. - * @data: interface data descriptor. - * - * Another simple helper. Remove the data descriptor from - * the device and the interface, then call the interface's - * remove_device() method. + * @intf: interface. + * @dev: device. */ -static void del(struct intf_data * data) +static void del(struct device_interface * intf, struct device * dev) { - struct device_interface * intf = data->intf; - pr_debug(" -> %s ",intf->name); - interface_remove_data(data); if (intf->remove_device) - intf->remove_device(data); + intf->remove_device(dev); + intf_dev_unlink(intf,dev); } -#define to_dev(entry) container_of(entry,struct device,class_list) - /** * add_intf - add class's devices to interface. @@ -145,10 +91,8 @@ struct device_class * cls = intf->devclass; struct list_head * entry; - down_write(&cls->subsys.rwsem); list_for_each(entry,&cls->devices.list) add(intf,to_dev(entry)); - up_write(&cls->subsys.rwsem); } /** @@ -164,6 +108,7 @@ { struct device_class * cls = get_devclass(intf->devclass); + down(&devclass_sem); if (cls) { pr_debug("register interface '%s' with class '%s'\n", intf->name,cls->name); @@ -173,6 +118,7 @@ kset_register(&intf->kset); add_intf(intf); } + up(&devclass_sem); return 0; } @@ -188,14 +134,13 @@ static void del_intf(struct device_interface * intf) { + struct device_class * cls = intf->devclass; struct list_head * entry; - down_write(&intf->devclass->subsys.rwsem); - list_for_each(entry,&intf->kset.list) { - struct intf_data * data = to_data(entry); - del(data); + list_for_each(entry,&cls->devices.list) { + struct device * dev = to_dev(entry); + del(intf,dev); } - up_write(&intf->devclass->subsys.rwsem); } /** @@ -210,6 +155,8 @@ void interface_unregister(struct device_interface * intf) { struct device_class * cls = intf->devclass; + + down(&devclass_sem); if (cls) { pr_debug("unregistering interface '%s' from class '%s'\n", intf->name,cls->name); @@ -217,6 +164,7 @@ kset_unregister(&intf->kset); put_devclass(cls); } + up(&devclass_sem); } @@ -255,20 +203,21 @@ * This is another helper for the class driver core, and called * when the device is being removed from the class. * - * We iterate over the list of interface data descriptors attached - * to the device, and call del() [above] for each. Again, the - * class's rwsem is assumed to be held during this. + * We iterate over the list of the class's devices and call del() + * [above] for each. Again, the class's rwsem is _not_ held, but + * the devclass_sem is (see class.c). */ void interface_remove_dev(struct device * dev) { struct list_head * entry, * next; + struct device_class * cls = dev->driver->devclass; pr_debug("interfaces: removing device %s\n",dev->name); - list_for_each_safe(entry,next,&dev->intf_list) { - struct intf_data * intf_data = to_data(entry); - del(intf_data); + list_for_each_safe(entry,next,&cls->subsys.kset.list) { + struct device_interface * intf = to_intf(entry); + del(intf,dev); } } diff -Nru a/drivers/base/platform.c b/drivers/base/platform.c --- a/drivers/base/platform.c Tue Mar 4 19:30:04 2003 +++ b/drivers/base/platform.c Tue Mar 4 19:30:04 2003 @@ -41,9 +41,29 @@ if (pdev) device_unregister(&pdev->dev); } - + + +/** + * platform_match - bind platform device to platform driver. + * @dev: device. + * @drv: driver. + * + * Platform device IDs are assumed to be encoded like this: + * "", where is a short description of the + * type of device, like "pci" or "floppy", and is the + * enumerated instance of the device, like '0' or '42'. + * Driver IDs are simply "". + * So, extract the from the device, and compare it against + * the name of the driver. Return whether they match or not. + */ + static int platform_match(struct device * dev, struct device_driver * drv) { + char name[BUS_ID_SIZE]; + + if (sscanf(dev->bus_id,"%s",name)) + return (strcmp(name,drv->name) == 0); + return 0; } @@ -52,13 +72,11 @@ .match = platform_match, }; -static int __init platform_bus_init(void) +int __init platform_bus_init(void) { device_register(&legacy_bus); return bus_register(&platform_bus_type); } - -postcore_initcall(platform_bus_init); EXPORT_SYMBOL(platform_device_register); EXPORT_SYMBOL(platform_device_unregister); diff -Nru a/drivers/base/sys.c b/drivers/base/sys.c --- a/drivers/base/sys.c Tue Mar 4 19:30:03 2003 +++ b/drivers/base/sys.c Tue Mar 4 19:30:03 2003 @@ -138,13 +138,12 @@ .name = "system", }; -static int sys_bus_init(void) +int __init sys_bus_init(void) { bus_register(&system_bus_type); return device_register(&system_bus); } -postcore_initcall(sys_bus_init); EXPORT_SYMBOL(system_bus_type); EXPORT_SYMBOL(sys_device_register); EXPORT_SYMBOL(sys_device_unregister); diff -Nru a/drivers/block/cciss.c b/drivers/block/cciss.c --- a/drivers/block/cciss.c Tue Mar 4 19:30:14 2003 +++ b/drivers/block/cciss.c Tue Mar 4 19:30:14 2003 @@ -87,7 +87,11 @@ }; /* How long to wait (in millesconds) for board to go into simple mode */ -#define MAX_CONFIG_WAIT 1000 +#define MAX_CONFIG_WAIT 30000 +#define MAX_IOCTL_CONFIG_WAIT 1000 + +/*define how many times we will try a command because of bus resets */ +#define MAX_CMD_RETRIES 3 #define READ_AHEAD 128 #define NR_CMDS 384 /* #commands that can be outstanding */ @@ -116,7 +120,7 @@ static void start_io( ctlr_info_t *h); static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num, unsigned int log_unit, __u8 page_code, - unsigned char *scsi3addr); + unsigned char *scsi3addr, int cmd_type); #ifdef CONFIG_PROC_FS static int cciss_proc_get_info(char *buffer, char **start, off_t offset, @@ -351,7 +355,7 @@ if (ctlr >= MAX_CTLR || hba[ctlr] == NULL) return -ENXIO; /* - * Root is allowed to open raw volume zero even if its not configured + * Root is allowed to open raw volume zero even if it's not configured * so array config can still work. I don't think I really like this, * but I'm already using way to many device nodes to claim another one * for "raw controller". @@ -467,8 +471,7 @@ &(c->cfgtable->HostWrite.CoalIntCount)); writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL); - for(i=0;ivaddr + SA5_DOORBELL) & CFGTBL_ChangeReq)) break; @@ -476,8 +479,8 @@ udelay(1000); } spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); - if (i >= MAX_CONFIG_WAIT) - return( -EFAULT); + if (i >= MAX_IOCTL_CONFIG_WAIT) + return -EAGAIN; return(0); } case CCISS_GETNODENAME: @@ -514,8 +517,7 @@ writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL); - for(i=0;ivaddr + SA5_DOORBELL) & CFGTBL_ChangeReq)) break; @@ -523,8 +525,8 @@ udelay(1000); } spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); - if (i >= MAX_CONFIG_WAIT) - return( -EFAULT); + if (i >= MAX_IOCTL_CONFIG_WAIT) + return -EAGAIN; return(0); } @@ -575,6 +577,24 @@ case CCISS_REVALIDVOLS: return( revalidate_allvol(inode->i_rdev)); + case CCISS_GETLUNINFO: { + LogvolInfo_struct luninfo; + struct gendisk *disk = hba[ctlr]->gendisk[dsk]; + drive_info_struct *drv = &hba[ctlr]->drv[dsk]; + int i; + + luninfo.LunID = drv->LunID; + luninfo.num_opens = drv->usage_count; + luninfo.num_parts = 0; + /* count partitions 1 to 15 with sizes > 0 */ + for(i=1; i part[i].nr_sects != 0) + luninfo.num_parts++; + if (copy_to_user((void *) arg, &luninfo, + sizeof(LogvolInfo_struct))) + return -EFAULT; + return(0); + } case CCISS_DEREGDISK: return( deregister_disk(ctlr,dsk)); @@ -696,7 +716,153 @@ cmd_free(h, c, 0); return(0); } + case CCISS_BIG_PASSTHRU: { + BIG_IOCTL_Command_struct *ioc; + ctlr_info_t *h = hba[ctlr]; + CommandList_struct *c; + unsigned char **buff = NULL; + int *buff_size = NULL; + u64bit temp64; + unsigned long flags; + BYTE sg_used = 0; + int status = 0; + int i; + DECLARE_COMPLETION(wait); + __u32 left; + __u32 sz; + BYTE *data_ptr; + if (!arg) + return -EINVAL; + if (!capable(CAP_SYS_RAWIO)) + return -EPERM; + ioc = (BIG_IOCTL_Command_struct *) + kmalloc(sizeof(*ioc), GFP_KERNEL); + if (!ioc) { + status = -ENOMEM; + goto cleanup1; + } + if (copy_from_user(ioc, (void *) arg, sizeof(*ioc))) + return -EFAULT; + if ((ioc->buf_size < 1) && + (ioc->Request.Type.Direction != XFER_NONE)) + return -EINVAL; + /* Check kmalloc limits using all SGs */ + if (ioc->malloc_size > MAX_KMALLOC_SIZE) + return -EINVAL; + if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) + return -EINVAL; + buff = (unsigned char **) kmalloc(MAXSGENTRIES * + sizeof(char *), GFP_KERNEL); + if (!buff) { + status = -ENOMEM; + goto cleanup1; + } + memset(buff, 0, MAXSGENTRIES); + buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), + GFP_KERNEL); + if (!buff_size) { + status = -ENOMEM; + goto cleanup1; + } + left = ioc->buf_size; + data_ptr = (BYTE *) ioc->buf; + while (left) { + sz = (left > ioc->malloc_size) ? ioc->malloc_size : left; + buff_size[sg_used] = sz; + buff[sg_used] = kmalloc(sz, GFP_KERNEL); + if (buff[sg_used] == NULL) { + status = -ENOMEM; + goto cleanup1; + } + if (ioc->Request.Type.Direction == XFER_WRITE && + copy_from_user(buff[sg_used], data_ptr, sz)) { + status = -ENOMEM; + goto cleanup1; + } + left -= sz; + data_ptr += sz; + sg_used++; + } + if ((c = cmd_alloc(h , 0)) == NULL) { + status = -ENOMEM; + goto cleanup1; + } + c->cmd_type = CMD_IOCTL_PEND; + c->Header.ReplyQueue = 0; + + if( ioc->buf_size > 0) { + c->Header.SGList = sg_used; + c->Header.SGTotal= sg_used; + } else { + c->Header.SGList = 0; + c->Header.SGTotal= 0; + } + c->Header.LUN = ioc->LUN_info; + c->Header.Tag.lower = c->busaddr; + + c->Request = ioc->Request; + if (ioc->buf_size > 0 ) { + int i; + for(i=0; ipdev, buff[i], + buff_size[i], + PCI_DMA_BIDIRECTIONAL); + c->SG[i].Addr.lower = temp64.val32.lower; + c->SG[i].Addr.upper = temp64.val32.upper; + c->SG[i].Len = buff_size[i]; + c->SG[i].Ext = 0; /* we are not chaining */ + } + } + c->waiting = &wait; + /* Put the request on the tail of the request queue */ + spin_lock_irqsave(CCISS_LOCK(ctlr), flags); + addQ(&h->reqQ, c); + h->Qdepth++; + start_io(h); + spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags); + wait_for_completion(&wait); + /* unlock the buffers from DMA */ + for(i=0; iSG[i].Addr.lower; + temp64.val32.upper = c->SG[i].Addr.upper; + pci_unmap_single( h->pdev, (dma_addr_t) temp64.val, + buff_size[i], PCI_DMA_BIDIRECTIONAL); + } + /* Copy the error information out */ + ioc->error_info = *(c->err_info); + if (copy_to_user((void *) arg, ioc, sizeof(*ioc))) { + cmd_free(h, c, 0); + status = -EFAULT; + goto cleanup1; + } + if (ioc->Request.Type.Direction == XFER_READ) { + /* Copy the data out of the buffer we created */ + BYTE *ptr = (BYTE *) ioc->buf; + for(i=0; i< sg_used; i++) { + if (copy_to_user(ptr, buff[i], buff_size[i])) { + cmd_free(h, c, 0); + status = -EFAULT; + goto cleanup1; + } + ptr += buff_size[i]; + } + } + cmd_free(h, c, 0); + status = 0; +cleanup1: + if (buff) { + for(i=0; idrv[logvol].LunID = 0; return(0); } -static int sendcmd_withirq(__u8 cmd, - int ctlr, - void *buff, - size_t size, - unsigned int use_unit_num, - unsigned int log_unit, - __u8 page_code ) +static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, + size_t size, + unsigned int use_unit_num, /* 0: address the controller, + 1: address logical volume log_unit, + 2: periph device address is scsi3addr */ + unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr, + int cmd_type) { - ctlr_info_t *h = hba[ctlr]; - CommandList_struct *c; - u64bit buff_dma_handle; - unsigned long flags; - int return_status = IO_OK; - DECLARE_COMPLETION(wait); - - if ((c = cmd_alloc(h , 0)) == NULL) - { - return -ENOMEM; - } - // Fill in the command type + ctlr_info_t *h= hba[ctlr]; + u64bit buff_dma_handle; + int status = IO_OK; + c->cmd_type = CMD_IOCTL_PEND; - // Fill in Command Header - c->Header.ReplyQueue = 0; // unused in simple mode - if( buff != NULL) // buffer to fill - { + c->Header.ReplyQueue = 0; + if( buff != NULL) { c->Header.SGList = 1; c->Header.SGTotal= 1; - } else // no buffers to fill - { + } else { c->Header.SGList = 0; c->Header.SGTotal= 0; } - c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag - // Fill in Request block - switch(cmd) - { + c->Header.Tag.lower = c->busaddr; + + c->Request.Type.Type = cmd_type; + if (cmd_type == TYPE_CMD) { + switch(cmd) { case CISS_INQUIRY: /* If the logical unit number is 0 then, this is going - to controller so It's a physical command - mode = 0 target = 0. - So we have nothing to write. - Otherwise - mode = 1 target = LUNID - */ - if(use_unit_num != 0) - { + to controller so It's a physical command + mode = 0 target = 0. So we have nothing to write. + otherwise, if use_unit_num == 1, + mode = 1(volume set addressing) target = LUNID + otherwise, if use_unit_num == 2, + mode = 0(periph dev addr) target = scsi3addr */ + if (use_unit_num == 1) { c->Header.LUN.LogDev.VolId= - hba[ctlr]->drv[log_unit].LunID; + h->drv[log_unit].LunID; c->Header.LUN.LogDev.Mode = 1; + } else if (use_unit_num == 2) { + memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8); + c->Header.LUN.LogDev.Mode = 0; } - if(page_code != 0) - { + /* are we trying to read a vital product page */ + if(page_code != 0) { c->Request.CDB[1] = 0x01; c->Request.CDB[2] = page_code; } c->Request.CDBLen = 6; - c->Request.Type.Type = TYPE_CMD; // It is a command. c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out + c->Request.Type.Direction = XFER_READ; + c->Request.Timeout = 0; c->Request.CDB[0] = CISS_INQUIRY; c->Request.CDB[4] = size & 0xFF; break; - case CISS_REPORT_LOG: + case CISS_REPORT_LOG: + case CISS_REPORT_PHYS: /* Talking to controller so It's a physical command - mode = 00 target = 0. - So we have nothing to write. + mode = 00 target = 0. Nothing to write. */ - c->Request.CDBLen = 12; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = CISS_REPORT_LOG; - c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB - c->Request.CDB[7] = (size >> 16) & 0xFF; - c->Request.CDB[8] = (size >> 8) & 0xFF; - c->Request.CDB[9] = size & 0xFF; - break; - case CCISS_READ_CAPACITY: - c->Header.LUN.LogDev.VolId= - hba[ctlr]->drv[log_unit].LunID; + c->Request.CDBLen = 12; + c->Request.Type.Attribute = ATTR_SIMPLE; + c->Request.Type.Direction = XFER_READ; + c->Request.Timeout = 0; + c->Request.CDB[0] = cmd; + c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB + c->Request.CDB[7] = (size >> 16) & 0xFF; + c->Request.CDB[8] = (size >> 8) & 0xFF; + c->Request.CDB[9] = size & 0xFF; + break; + + case CCISS_READ_CAPACITY: + c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID; c->Header.LUN.LogDev.Mode = 1; c->Request.CDBLen = 10; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = CCISS_READ_CAPACITY; + c->Request.Type.Attribute = ATTR_SIMPLE; + c->Request.Type.Direction = XFER_READ; + c->Request.Timeout = 0; + c->Request.CDB[0] = cmd; + break; + case CCISS_CACHE_FLUSH: + c->Request.CDBLen = 12; + c->Request.Type.Attribute = ATTR_SIMPLE; + c->Request.Type.Direction = XFER_WRITE; + c->Request.Timeout = 0; + c->Request.CDB[0] = BMIC_WRITE; + c->Request.CDB[6] = BMIC_CACHE_FLUSH; break; default: printk(KERN_WARNING - "cciss: Unknown Command 0x%c sent attempted\n", cmd); - cmd_free(h, c, 1); + "cciss%d: Unknown Command 0x%c\n", ctlr, cmd); return(IO_ERROR); - }; - - // Fill in the scatter gather information - if (size > 0 ) - { - buff_dma_handle.val = (__u64) pci_map_single( h->pdev, + } + } else if (cmd_type == TYPE_MSG) { + switch (cmd) { + case 3: /* No-Op message */ + c->Request.CDBLen = 1; + c->Request.Type.Attribute = ATTR_SIMPLE; + c->Request.Type.Direction = XFER_WRITE; + c->Request.Timeout = 0; + c->Request.CDB[0] = cmd; + break; + default: + printk(KERN_WARNING + "cciss%d: unknown message type %d\n", + ctlr, cmd); + return IO_ERROR; + } + } else { + printk(KERN_WARNING + "cciss%d: unknown command type %d\n", ctlr, cmd_type); + return IO_ERROR; + } + /* Fill in the scatter gather information */ + if (size > 0) { + buff_dma_handle.val = (__u64) pci_map_single(h->pdev, buff, size, PCI_DMA_BIDIRECTIONAL); c->SG[0].Addr.lower = buff_dma_handle.val32.lower; c->SG[0].Addr.upper = buff_dma_handle.val32.upper; c->SG[0].Len = size; - c->SG[0].Ext = 0; // we are not chaining + c->SG[0].Ext = 0; /* we are not chaining */ + } + return status; +} +static int sendcmd_withirq(__u8 cmd, + int ctlr, + void *buff, + size_t size, + unsigned int use_unit_num, + unsigned int log_unit, + __u8 page_code, + int cmd_type) +{ + ctlr_info_t *h = hba[ctlr]; + CommandList_struct *c; + u64bit buff_dma_handle; + unsigned long flags; + int return_status; + DECLARE_COMPLETION(wait); + + if ((c = cmd_alloc(h , 0)) == NULL) + return -ENOMEM; + return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num, + log_unit, page_code, NULL, cmd_type); + if (return_status != IO_OK) { + cmd_free(h, c, 0); + return return_status; } +resend_cmd2: c->waiting = &wait; /* Put the request on the tail of the queue and send it */ @@ -934,10 +1141,6 @@ wait_for_completion(&wait); - /* unlock the buffers from DMA */ - pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val, - size, PCI_DMA_BIDIRECTIONAL); - if(c->err_info->CommandStatus != 0) { /* an error has occurred */ switch(c->err_info->CommandStatus) @@ -989,11 +1192,22 @@ return_status = IO_ERROR; break; case CMD_UNSOLICITED_ABORT: - printk(KERN_WARNING "cciss: cmd %p aborted " - "do to an unsolicited abort\n", c); + printk(KERN_WARNING + "cciss%d: unsolicited abort %p\n", + ctlr, c); + if (c->retry_count < MAX_CMD_RETRIES) { + printk(KERN_WARNING + "cciss%d: retrying %p\n", + ctlr, c); + c->retry_count++; + /* erase the old error information */ + memset(c->err_info, 0, + sizeof(ErrorInfo_struct)); + return_status = IO_OK; + INIT_COMPLETION(wait); + goto resend_cmd2; + } return_status = IO_ERROR; - - break; default: printk(KERN_WARNING "cciss: cmd %p returned " @@ -1002,6 +1216,9 @@ return_status = IO_ERROR; } } + /* unlock the buffers from DMA */ + pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val, + size, PCI_DMA_BIDIRECTIONAL); cmd_free(h, c, 0); return(return_status); @@ -1015,10 +1232,10 @@ memset(inq_buff, 0, sizeof(InquiryData_struct)); if (withirq) return_code = sendcmd_withirq(CISS_INQUIRY, ctlr, - inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1); + inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD); else return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff, - sizeof(*inq_buff), 1, logvol ,0xC1, NULL); + sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD); if (return_code == IO_OK) { if(inq_buff->data_byte[8] == 0xFF) { printk(KERN_WARNING @@ -1057,10 +1274,10 @@ memset(buf, 0, sizeof(*buf)); if (withirq) return_code = sendcmd_withirq(CCISS_READ_CAPACITY, - ctlr, buf, sizeof(*buf), 1, logvol, 0 ); + ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD); else return_code = sendcmd(CCISS_READ_CAPACITY, - ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL ); + ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD); if (return_code == IO_OK) { *total_size = be32_to_cpu(*((__u32 *) &buf->total_size[0]))+1; *block_size = be32_to_cpu(*((__u32 *) &buf->block_size[0])); @@ -1111,7 +1328,7 @@ goto mem_msg; return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff, - sizeof(ReportLunData_struct), 0, 0, 0 ); + sizeof(ReportLunData_struct), 0, 0, 0, TYPE_CMD); if( return_code == IO_OK) { @@ -1265,126 +1482,27 @@ 2: periph device address is scsi3addr */ unsigned int log_unit, __u8 page_code, - unsigned char *scsi3addr) + unsigned char *scsi3addr, + int cmd_type) { CommandList_struct *c; int i; unsigned long complete; ctlr_info_t *info_p= hba[ctlr]; u64bit buff_dma_handle; + int status; - c = cmd_alloc(info_p, 1); - if (c == NULL) - { + if ((c = cmd_alloc(info_p, 1)) == NULL) { printk(KERN_WARNING "cciss: unable to get memory"); return(IO_ERROR); } - // Fill in Command Header - c->Header.ReplyQueue = 0; // unused in simple mode - if( buff != NULL) // buffer to fill - { - c->Header.SGList = 1; - c->Header.SGTotal= 1; - } else // no buffers to fill - { - c->Header.SGList = 0; - c->Header.SGTotal= 0; - } - c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag - // Fill in Request block - switch(cmd) - { - case CISS_INQUIRY: - /* If the logical unit number is 0 then, this is going - to controller so It's a physical command - mode = 0 target = 0. - So we have nothing to write. - otherwise, if use_unit_num == 1, - mode = 1(volume set addressing) target = LUNID - otherwise, if use_unit_num == 2, - mode = 0(periph dev addr) target = scsi3addr - */ - if(use_unit_num == 1) - { - c->Header.LUN.LogDev.VolId= - hba[ctlr]->drv[log_unit].LunID; - c->Header.LUN.LogDev.Mode = 1; - } - else if (use_unit_num == 2) - { - memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8); - c->Header.LUN.LogDev.Mode = 0; // phys dev addr - } - - /* are we trying to read a vital product page */ - if(page_code != 0) - { - c->Request.CDB[1] = 0x01; - c->Request.CDB[2] = page_code; - } - c->Request.CDBLen = 6; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = CISS_INQUIRY; - c->Request.CDB[4] = size & 0xFF; - break; - case CISS_REPORT_LOG: - case CISS_REPORT_PHYS: - /* Talking to controller so It's a physical command - mode = 00 target = 0. - So we have nothing to write. - */ - c->Request.CDBLen = 12; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = cmd; - c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB - c->Request.CDB[7] = (size >> 16) & 0xFF; - c->Request.CDB[8] = (size >> 8) & 0xFF; - c->Request.CDB[9] = size & 0xFF; - break; - - case CCISS_READ_CAPACITY: - c->Header.LUN.LogDev.VolId= - hba[ctlr]->drv[log_unit].LunID; - c->Header.LUN.LogDev.Mode = 1; - c->Request.CDBLen = 10; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_READ; // Read - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = CCISS_READ_CAPACITY; - break; - case CCISS_CACHE_FLUSH: - c->Request.CDBLen = 12; - c->Request.Type.Type = TYPE_CMD; // It is a command. - c->Request.Type.Attribute = ATTR_SIMPLE; - c->Request.Type.Direction = XFER_WRITE; // No data - c->Request.Timeout = 0; // Don't time out - c->Request.CDB[0] = BMIC_WRITE; // BMIC Passthru - c->Request.CDB[6] = BMIC_CACHE_FLUSH; - break; - default: - printk(KERN_WARNING - "cciss: Unknown Command 0x%c sent attempted\n", - cmd); - cmd_free(info_p, c, 1); - return(IO_ERROR); - }; - // Fill in the scatter gather information - if (size > 0 ) - { - buff_dma_handle.val = (__u64) pci_map_single( info_p->pdev, - buff, size, PCI_DMA_BIDIRECTIONAL); - c->SG[0].Addr.lower = buff_dma_handle.val32.lower; - c->SG[0].Addr.upper = buff_dma_handle.val32.upper; - c->SG[0].Len = size; - c->SG[0].Ext = 0; // we are not chaining + status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num, + log_unit, page_code, scsi3addr, cmd_type); + if (status != IO_OK) { + cmd_free(info_p, c, 1); + return status; } +resend_cmd1: /* * Disable interrupt */ @@ -1417,9 +1535,6 @@ printk(KERN_DEBUG "cciss: command completed\n"); #endif /* CCISS_DEBUG */ - /* unlock the data buffer from DMA */ - pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val, - size, PCI_DMA_BIDIRECTIONAL); if (complete != 1) { if ( (complete & CISS_ERROR_BIT) && (complete & ~CISS_ERROR_BIT) == c->busaddr) @@ -1437,8 +1552,30 @@ )) { complete = c->busaddr; - } else - { + } else { + if (c->err_info->CommandStatus == + CMD_UNSOLICITED_ABORT) { + printk(KERN_WARNING "cciss%d: " + "unsolicited abort %p\n", + ctlr, c); + if (c->retry_count < MAX_CMD_RETRIES) { + printk(KERN_WARNING + "cciss%d: retrying %p\n", + ctlr, c); + c->retry_count++; + /* erase the old error */ + /* information */ + memset(c->err_info, 0, + sizeof(ErrorInfo_struct)); + goto resend_cmd1; + } else { + printk(KERN_WARNING + "cciss%d: retried %p too " + "many times\n", ctlr, c); + status = IO_ERROR; + goto cleanup1; + } + } printk(KERN_WARNING "ciss ciss%d: sendcmd" " Error %x \n", ctlr, c->err_info->CommandStatus); @@ -1448,27 +1585,31 @@ c->err_info->MoreErrInfo.Invalid_Cmd.offense_size, c->err_info->MoreErrInfo.Invalid_Cmd.offense_num, c->err_info->MoreErrInfo.Invalid_Cmd.offense_value); - cmd_free(info_p,c, 1); - return(IO_ERROR); + status = IO_ERROR; + goto cleanup1; } } if (complete != c->busaddr) { printk( KERN_WARNING "cciss cciss%d: SendCmd " "Invalid command list address returned! (%lx)\n", ctlr, complete); - cmd_free(info_p, c, 1); - return (IO_ERROR); + status = IO_ERROR; + goto cleanup1; } } else { printk( KERN_WARNING "cciss cciss%d: SendCmd Timeout out, " "No command list address returned!\n", ctlr); - cmd_free(info_p, c, 1); - return (IO_ERROR); + status = IO_ERROR; } + +cleanup1: + /* unlock the data buffer from DMA */ + pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val, + size, PCI_DMA_BIDIRECTIONAL); cmd_free(info_p, c, 1); - return (IO_OK); + return (status); } /* * Map (physical) PCI mem into (virtual) kernel space @@ -1552,27 +1693,35 @@ } } +/* Assumes that CCISS_LOCK(h->ctlr) is held. */ +/* Zeros out the error record and then resends the command back */ +/* to the controller */ +static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c) +{ + /* erase the old error information */ + memset(c->err_info, 0, sizeof(ErrorInfo_struct)); + + /* add it to software queue and then send it to the controller */ + addQ(&(h->reqQ),c); + h->Qdepth++; + if(h->Qdepth > h->maxQsinceinit) + h->maxQsinceinit = h->Qdepth; + + start_io(h); +} /* checks the status of the job and calls complete buffers to mark all * buffers for the completed job. */ -static inline void complete_command( CommandList_struct *cmd, int timeout) +static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd, + int timeout) { int status = 1; int i; + int retry_cmd = 0; u64bit temp64; if (timeout) status = 0; - /* unmap the DMA mapping for all the scatter gather elements */ - for(i=0; iHeader.SGList; i++) - { - temp64.val32.lower = cmd->SG[i].Addr.lower; - temp64.val32.upper = cmd->SG[i].Addr.upper; - pci_unmap_page(hba[cmd->ctlr]->pdev, - temp64.val, cmd->SG[i].Len, - (cmd->Request.Type.Direction == XFER_READ) ? - PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE); - } if(cmd->err_info->CommandStatus != 0) { /* an error has occurred */ @@ -1646,8 +1795,18 @@ status=0; break; case CMD_UNSOLICITED_ABORT: - printk(KERN_WARNING "cciss: cmd %p aborted " - "do to an unsolicited abort\n", cmd); + printk(KERN_WARNING "cciss%d: unsolicited " + "abort %p\n", h->ctlr, cmd); + if (cmd->retry_count < MAX_CMD_RETRIES) { + retry_cmd=1; + printk(KERN_WARNING + "cciss%d: retrying %p\n", + h->ctlr, cmd); + cmd->retry_count++; + } else + printk(KERN_WARNING + "cciss%d: %p retried too " + "many times\n", h->ctlr, cmd); status=0; break; case CMD_TIMEOUT: @@ -1662,7 +1821,21 @@ status=0; } } - + /* We need to return this command */ + if(retry_cmd) { + resend_cciss_cmd(h,cmd); + return; + } + /* command did not need to be retried */ + /* unmap the DMA mapping for all the scatter gather elements */ + for(i=0; iHeader.SGList; i++) { + temp64.val32.lower = cmd->SG[i].Addr.lower; + temp64.val32.upper = cmd->SG[i].Addr.upper; + pci_unmap_page(hba[cmd->ctlr]->pdev, + temp64.val, cmd->SG[i].Len, + (cmd->Request.Type.Direction == XFER_READ) ? + PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE); + } complete_buffers(cmd->rq->bio, status); #ifdef CCISS_DEBUG @@ -1670,6 +1843,7 @@ #endif /* CCISS_DEBUG */ end_that_request_last(cmd->rq); + cmd_free(h,cmd,1); } /* @@ -1816,8 +1990,7 @@ if (c->busaddr == a) { removeQ(&h->cmpQ, c); if (c->cmd_type == CMD_RWREQ) { - complete_command(c, 0); - cmd_free(h, c, 1); + complete_command(h, c, 0); } else if (c->cmd_type == CMD_IOCTL_PEND) { complete(c->waiting); } @@ -2038,12 +2211,15 @@ &(c->cfgtable->HostWrite.TransportRequest)); writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL); - for(i=0;ivaddr + SA5_DOORBELL) & CFGTBL_ChangeReq)) break; /* delay and try again */ - udelay(1000); + set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout(10); } #ifdef CCISS_DEBUG @@ -2102,7 +2278,7 @@ } /* Get the firmware version */ return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, - sizeof(InquiryData_struct), 0, 0 ,0, NULL ); + sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD); if (return_code == IO_OK) { hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32]; @@ -2116,7 +2292,7 @@ } /* Get the number of logical volumes */ return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, - sizeof(ReportLunData_struct), 0, 0, 0, NULL ); + sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD); if( return_code == IO_OK) { @@ -2390,7 +2566,8 @@ /* sendcmd will turn off interrupt, and send the flush... * To write all data in the battery backed cache to disks */ memset(flush_buf, 0, 4); - return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL); + return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL, + TYPE_CMD); if(return_code != IO_OK) { printk(KERN_WARNING "Error Flushing cache on controller %d\n", diff -Nru a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h --- a/drivers/block/cciss_cmd.h Tue Mar 4 19:30:05 2003 +++ b/drivers/block/cciss_cmd.h Tue Mar 4 19:30:05 2003 @@ -240,6 +240,7 @@ struct _CommandList_struct *next; struct request * rq; struct completion *waiting; + int retry_count; #ifdef CONFIG_CISS_SCSI_TAPE void * scsi_cmd; #endif diff -Nru a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c --- a/drivers/block/cciss_scsi.c Tue Mar 4 19:30:05 2003 +++ b/drivers/block/cciss_scsi.c Tue Mar 4 19:30:05 2003 @@ -47,7 +47,8 @@ 2: address is in scsi3addr */ unsigned int log_unit, __u8 page_code, - unsigned char *scsi3addr ); + unsigned char *scsi3addr, + int cmd_type); int __init cciss_scsi_detect(Scsi_Host_Template *tpnt); @@ -210,7 +211,7 @@ stk = &sa->cmd_stack; size = sizeof(struct cciss_scsi_cmd_stack_elem_t) * CMD_STACK_SIZE; - // pci_alloc_consistent guarentees 32-bit DMA address will + // pci_alloc_consistent guarantees 32-bit DMA address will // be used stk->pool = (struct cciss_scsi_cmd_stack_elem_t *) diff -Nru a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c --- a/drivers/block/cpqarray.c Tue Mar 4 19:30:04 2003 +++ b/drivers/block/cpqarray.c Tue Mar 4 19:30:04 2003 @@ -715,7 +715,7 @@ return -ENXIO; /* - * Root is allowed to open raw volume zero even if its not configured + * Root is allowed to open raw volume zero even if it's not configured * so array config can still work. I don't think I really like this, * but I'm already using way to many device nodes to claim another one * for "raw controller". diff -Nru a/drivers/block/deadline-iosched.c b/drivers/block/deadline-iosched.c --- a/drivers/block/deadline-iosched.c Tue Mar 4 19:30:12 2003 +++ b/drivers/block/deadline-iosched.c Tue Mar 4 19:30:12 2003 @@ -98,7 +98,7 @@ unsigned long expires; }; -static inline void deadline_move_to_dispatch(struct deadline_data *dd, struct deadline_rq *drq); +static void deadline_move_request(struct deadline_data *dd, struct deadline_rq *drq); static kmem_cache_t *drq_pool; @@ -205,7 +205,7 @@ return; } - deadline_move_to_dispatch(dd, __alias); + deadline_move_request(dd, __alias); goto retry; } diff -Nru a/drivers/block/genhd.c b/drivers/block/genhd.c --- a/drivers/block/genhd.c Tue Mar 4 19:30:08 2003 +++ b/drivers/block/genhd.c Tue Mar 4 19:30:08 2003 @@ -1,17 +1,5 @@ /* - * Code extracted from - * linux/kernel/hd.c - * - * Copyright (C) 1991-1998 Linus Torvalds - * - * devfs support - jj, rgooch, 980122 - * - * Moved partition checking code to fs/partitions* - Russell King - * (linux@arm.uk.linux.org) - */ - -/* - * TODO: rip out the remaining init crap from this file --hch + * gendisk handling */ #include @@ -29,8 +17,9 @@ static struct subsystem block_subsys; +#define MAX_PROBE_HASH 23 /* random */ -struct blk_probe { +static struct blk_probe { struct blk_probe *next; dev_t dev; unsigned long range; @@ -38,21 +27,27 @@ struct gendisk *(*get)(dev_t dev, int *part, void *data); int (*lock)(dev_t, void *); void *data; -} *probes[MAX_BLKDEV]; +} *probes[MAX_PROBE_HASH]; -/* index in the above */ +/* index in the above - for now: assume no multimajor ranges */ static inline int dev_to_index(dev_t dev) { - return MAJOR(dev); + return MAJOR(dev) % MAX_PROBE_HASH; } +/* + * Register device numbers dev..(dev+range-1) + * range must be nonzero + * The hash chain is sorted on range, so that subranges can override. + */ void blk_register_region(dev_t dev, unsigned long range, struct module *module, - struct gendisk *(*probe)(dev_t, int *, void *), - int (*lock)(dev_t, void *), void *data) + struct gendisk *(*probe)(dev_t, int *, void *), + int (*lock)(dev_t, void *), void *data) { int index = dev_to_index(dev); struct blk_probe *p = kmalloc(sizeof(struct blk_probe), GFP_KERNEL); struct blk_probe **s; + p->owner = module; p->get = probe; p->lock = lock; @@ -71,6 +66,7 @@ { int index = dev_to_index(dev); struct blk_probe **s; + down_write(&block_subsys.rwsem); for (s = &probes[index]; *s; s = &(*s)->next) { struct blk_probe *p = *s; @@ -94,6 +90,7 @@ static int exact_lock(dev_t dev, void *data) { struct gendisk *p = data; + if (!get_disk(p)) return -1; return 0; @@ -109,14 +106,14 @@ void add_disk(struct gendisk *disk) { disk->flags |= GENHD_FL_UP; - blk_register_region(MKDEV(disk->major, disk->first_minor), disk->minors, - NULL, exact_match, exact_lock, disk); + blk_register_region(MKDEV(disk->major, disk->first_minor), + disk->minors, NULL, exact_match, exact_lock, disk); register_disk(disk); elv_register_queue(disk); } EXPORT_SYMBOL(add_disk); -EXPORT_SYMBOL(del_gendisk); +EXPORT_SYMBOL(del_gendisk); /* in partitions/check.c */ void unlink_gendisk(struct gendisk *disk) { @@ -146,18 +143,17 @@ struct gendisk *(*probe)(dev_t, int *, void *); struct module *owner; void *data; - if (p->dev > dev || p->dev + p->range <= dev) + + if (p->dev > dev || p->dev + p->range - 1 < dev) continue; - if (p->range >= best) { - up_read(&block_subsys.rwsem); - return NULL; - } + if (p->range - 1 >= best) + break; if (!try_module_get(p->owner)) continue; owner = p->owner; data = p->data; probe = p->get; - best = p->range; + best = p->range - 1; *part = dev - p->dev; if (p->lock && p->lock(dev, data) < 0) { module_put(owner); @@ -169,7 +165,7 @@ module_put(owner); if (disk) return disk; - goto retry; + goto retry; /* this terminates: best decreases */ } up_read(&block_subsys.rwsem); return NULL; @@ -245,7 +241,7 @@ static struct gendisk *base_probe(dev_t dev, int *part, void *data) { - char name[20]; + char name[30]; sprintf(name, "block-major-%d", MAJOR(dev)); request_module(name); return NULL; @@ -256,11 +252,11 @@ struct blk_probe *base = kmalloc(sizeof(struct blk_probe), GFP_KERNEL); int i; memset(base, 0, sizeof(struct blk_probe)); - base->dev = MKDEV(1,0); - base->range = MKDEV(MAX_BLKDEV-1, 255) - base->dev + 1; + base->dev = 1; + base->range = ~0; /* range 1 .. ~0 */ base->get = base_probe; - for (i = 1; i < MAX_BLKDEV; i++) - probes[i] = base; + for (i = 0; i < MAX_PROBE_HASH; i++) + probes[i] = base; /* must remain last in chain */ blk_dev_init(); subsystem_register(&block_subsys); return 0; @@ -281,12 +277,14 @@ ssize_t (*show)(struct gendisk *, char *); }; -static ssize_t disk_attr_show(struct kobject * kobj, struct attribute * attr, - char * page) +static ssize_t disk_attr_show(struct kobject *kobj, struct attribute *attr, + char *page) { - struct gendisk * disk = to_disk(kobj); - struct disk_attribute * disk_attr = container_of(attr,struct disk_attribute,attr); + struct gendisk *disk = to_disk(kobj); + struct disk_attribute *disk_attr = + container_of(attr,struct disk_attribute,attr); ssize_t ret = 0; + if (disk_attr->show) ret = disk_attr->show(disk,page); return ret; @@ -303,11 +301,11 @@ } static ssize_t disk_range_read(struct gendisk * disk, char *page) { - return sprintf(page, "%d\n",disk->minors); + return sprintf(page, "%d\n", disk->minors); } static ssize_t disk_size_read(struct gendisk * disk, char *page) { - return sprintf(page, "%llu\n",(unsigned long long)get_capacity(disk)); + return sprintf(page, "%llu\n", (unsigned long long)get_capacity(disk)); } static inline unsigned jiffies_to_msec(unsigned jif) diff -Nru a/drivers/block/ll_rw_blk.c b/drivers/block/ll_rw_blk.c --- a/drivers/block/ll_rw_blk.c Tue Mar 4 19:30:04 2003 +++ b/drivers/block/ll_rw_blk.c Tue Mar 4 19:30:04 2003 @@ -1461,6 +1461,7 @@ if (blk_rq_tagged(rq)) blk_queue_end_tag(q, rq); + drive_stat_acct(rq, rq->nr_sectors, 1); __elv_add_request(q, rq, !at_head, 0); q->request_fn(q); spin_unlock_irqrestore(q->queue_lock, flags); @@ -1892,7 +1893,7 @@ } /** - * generic_make_request: hand a buffer to it's device driver for I/O + * generic_make_request: hand a buffer to its device driver for I/O * @bio: The bio describing the location in memory and on the device. * * generic_make_request() is used to make I/O requests of block diff -Nru a/drivers/block/loop.c b/drivers/block/loop.c --- a/drivers/block/loop.c Tue Mar 4 19:30:10 2003 +++ b/drivers/block/loop.c Tue Mar 4 19:30:10 2003 @@ -447,7 +447,22 @@ goto out_bh; } - bio = bio_copy(rbh, GFP_NOIO, rbh->bi_rw & WRITE); + /* + * When called on the page reclaim -> writepage path, this code can + * trivially consume all memory. So we drop PF_MEMALLOC to avoid + * stealing all the page reserves and throttle to the writeout rate. + * pdflush will have been woken by page reclaim. Let it do its work. + */ + do { + int flags = current->flags; + + current->flags &= ~PF_MEMALLOC; + bio = bio_copy(rbh, (GFP_ATOMIC & ~__GFP_HIGH) | __GFP_NOWARN, + rbh->bi_rw & WRITE); + current->flags = flags; + if (bio == NULL) + blk_congestion_wait(WRITE, HZ/10); + } while (bio == NULL); bio->bi_end_io = loop_end_io_transfer; bio->bi_private = rbh; diff -Nru a/drivers/block/scsi_ioctl.c b/drivers/block/scsi_ioctl.c --- a/drivers/block/scsi_ioctl.c Tue Mar 4 19:30:14 2003 +++ b/drivers/block/scsi_ioctl.c Tue Mar 4 19:30:14 2003 @@ -60,6 +60,7 @@ rq->flags |= REQ_NOMERGE; rq->waiting = &wait; + drive_stat_acct(rq, rq->nr_sectors, 1); elv_add_request(q, rq, 1, 1); generic_unplug_device(q); wait_for_completion(&wait); diff -Nru a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c --- a/drivers/cdrom/cdrom.c Tue Mar 4 19:30:04 2003 +++ b/drivers/cdrom/cdrom.c Tue Mar 4 19:30:04 2003 @@ -172,8 +172,8 @@ -- Defined CD_DVD and CD_CHANGER log levels. -- Fixed the CDROMREADxxx ioctls. -- CDROMPLAYTRKIND uses the GPCMD_PLAY_AUDIO_MSF command - too few - drives supported it. We loose the index part, however. - -- Small modifications to accomodate opens of /dev/hdc1, required + drives supported it. We lose the index part, however. + -- Small modifications to accommodate opens of /dev/hdc1, required for ide-cd to handle multisession discs. -- Export cdrom_mode_sense and cdrom_mode_select. -- init_cdrom_command() for setting up a cgc command. diff -Nru a/drivers/cdrom/sbpcd.c b/drivers/cdrom/sbpcd.c --- a/drivers/cdrom/sbpcd.c Tue Mar 4 19:30:05 2003 +++ b/drivers/cdrom/sbpcd.c Tue Mar 4 19:30:05 2003 @@ -341,7 +341,7 @@ * Trying to merge requests breaks this driver horribly (as in it goes * boom and apparently has done so since 2.3.41). As it is a legacy * driver for a horribly slow double speed CD on a hideous interface - * designed for polled operation, I won't loose any sleep in simply + * designed for polled operation, I won't lose any sleep in simply * disallowing merging. Paul G. 02/2001 * * Thu May 30 14:14:47 CEST 2002: diff -Nru a/drivers/char/Makefile b/drivers/char/Makefile --- a/drivers/char/Makefile Tue Mar 4 19:30:13 2003 +++ b/drivers/char/Makefile Tue Mar 4 19:30:13 2003 @@ -83,7 +83,7 @@ clean-files := consolemap_deftbl.c defkeymap.c qtronixmap.c $(obj)/consolemap_deftbl.c: $(src)/$(FONTMAPFILE) - $(call do_cmd,CONMK $@,$(objtree)/scripts/conmakehash $< > $@) + $(call do_cmd,CONMK $@,$(objtree)/scripts/conmakehash $< > $@) $(obj)/defkeymap.o: $(obj)/defkeymap.c diff -Nru a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig --- a/drivers/char/agp/Kconfig Tue Mar 4 19:30:10 2003 +++ b/drivers/char/agp/Kconfig Tue Mar 4 19:30:10 2003 @@ -34,14 +34,17 @@ depends on AGP config AGP_INTEL - tristate "Intel 440LX/BX/GX and I815/I820/I830M/I830MP/I840/I845/I850/I860 support" + tristate "Intel 440LX/BX/GX and I815/I820/830M/I830MP/I840/I845/845G/I850/852GM/855GM/I860/865G support" depends on AGP help This option gives you AGP support for the GLX component of the - XFree86 4.x on Intel 440LX/BX/GX, 815, 820, 830, 840, 845, 850 and 860 chipsets. + XFree86 4.x on Intel 440LX/BX/GX, 815, 820, 830, 840, 845, 850 + and 860 chipsets and full support for the 810, 815, 830M, 845G, + 852GM, 855GM and 865G integrated graphics chipsets. You should say Y here if you use XFree86 3.3.6 or 4.x and want to - use GLX or DRI. If unsure, say N. + use GLX or DRI, or if you have any Intel integrated graphics + chipsets. If unsure, say Y. #config AGP_I810 # tristate "Intel I810/I815/I830M (on-board) support" diff -Nru a/drivers/char/agp/agp.h b/drivers/char/agp/agp.h --- a/drivers/char/agp/agp.h Tue Mar 4 19:30:08 2003 +++ b/drivers/char/agp/agp.h Tue Mar 4 19:30:08 2003 @@ -42,9 +42,8 @@ static void __attribute__((unused)) global_cache_flush(void) { - if (smp_call_function(ipi_handler, NULL, 1, 1) != 0) + if (on_each_cpu(ipi_handler, NULL, 1, 1) != 0) panic(PFX "timed out waiting for the other CPUs!\n"); - flush_agp_cache(); } #else static inline void global_cache_flush(void) @@ -216,6 +215,21 @@ /* This one is for I830MP w. an external graphic card */ #define INTEL_I830_ERRSTS 0x92 + +/* Intel 855GM/852GM registers */ +#define I855_GMCH_GMS_STOLEN_0M 0x0 +#define I855_GMCH_GMS_STOLEN_1M (0x1 << 4) +#define I855_GMCH_GMS_STOLEN_4M (0x2 << 4) +#define I855_GMCH_GMS_STOLEN_8M (0x3 << 4) +#define I855_GMCH_GMS_STOLEN_16M (0x4 << 4) +#define I855_GMCH_GMS_STOLEN_32M (0x5 << 4) +#define I85X_CAPID 0x44 +#define I85X_VARIANT_MASK 0x7 +#define I85X_VARIANT_SHIFT 5 +#define I855_GME 0x0 +#define I855_GM 0x4 +#define I852_GME 0x2 +#define I852_GM 0x5 /* intel 815 register */ #define INTEL_815_APCONT 0x51 diff -Nru a/drivers/char/agp/alpha-agp.c b/drivers/char/agp/alpha-agp.c --- a/drivers/char/agp/alpha-agp.c Tue Mar 4 19:30:11 2003 +++ b/drivers/char/agp/alpha-agp.c Tue Mar 4 19:30:11 2003 @@ -185,7 +185,7 @@ agp_bridge->agp_destroy_page = agp_generic_destroy_page; agp_bridge->mode = agp->capability.lw; agp_bridge->cant_use_aperture = 1; - agp_bridgevm_ops = &alpha_core_agp_vm_ops; + agp_bridge->vm_ops = &alpha_core_agp_vm_ops; alpha_core_agp_driver.dev = agp_bridge->dev; agp_register_driver(&alpha_core_agp_driver); diff -Nru a/drivers/char/agp/intel-agp.c b/drivers/char/agp/intel-agp.c --- a/drivers/char/agp/intel-agp.c Tue Mar 4 19:30:08 2003 +++ b/drivers/char/agp/intel-agp.c Tue Mar 4 19:30:08 2003 @@ -2,6 +2,11 @@ * Intel AGPGART routines. */ +/* + * Intel(R) 855GM/852GM and 865G support added by David Dawes + * . + */ + #include #include #include @@ -294,34 +299,62 @@ u16 gmch_ctrl; int gtt_entries; u8 rdct; + int local = 0; static const int ddt[4] = { 0, 16, 32, 64 }; pci_read_config_word(agp_bridge->dev,I830_GMCH_CTRL,&gmch_ctrl); - switch (gmch_ctrl & I830_GMCH_GMS_MASK) { - case I830_GMCH_GMS_STOLEN_512: - gtt_entries = KB(512) - KB(132); - printk(KERN_INFO PFX "detected %dK stolen memory.\n",gtt_entries / KB(1)); - break; - case I830_GMCH_GMS_STOLEN_1024: - gtt_entries = MB(1) - KB(132); - printk(KERN_INFO PFX "detected %dK stolen memory.\n",gtt_entries / KB(1)); - break; - case I830_GMCH_GMS_STOLEN_8192: - gtt_entries = MB(8) - KB(132); - printk(KERN_INFO PFX "detected %dK stolen memory.\n",gtt_entries / KB(1)); - break; - case I830_GMCH_GMS_LOCAL: - rdct = INREG8(intel_i830_private.registers,I830_RDRAM_CHANNEL_TYPE); - gtt_entries = (I830_RDRAM_ND(rdct) + 1) * MB(ddt[I830_RDRAM_DDT(rdct)]); - printk(KERN_INFO PFX "detected %dK local memory.\n",gtt_entries / KB(1)); - break; - default: - printk(KERN_INFO PFX "no video memory detected.\n"); - gtt_entries = 0; - break; + if (agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82830_HB || + agp_bridge->dev->device == PCI_DEVICE_ID_INTEL_82845G_HB) { + switch (gmch_ctrl & I830_GMCH_GMS_MASK) { + case I830_GMCH_GMS_STOLEN_512: + gtt_entries = KB(512) - KB(132); + break; + case I830_GMCH_GMS_STOLEN_1024: + gtt_entries = MB(1) - KB(132); + break; + case I830_GMCH_GMS_STOLEN_8192: + gtt_entries = MB(8) - KB(132); + break; + case I830_GMCH_GMS_LOCAL: + rdct = INREG8(intel_i830_private.registers, + I830_RDRAM_CHANNEL_TYPE); + gtt_entries = (I830_RDRAM_ND(rdct) + 1) * + MB(ddt[I830_RDRAM_DDT(rdct)]); + local = 1; + break; + default: + gtt_entries = 0; + break; + } + } else { + switch (gmch_ctrl & I830_GMCH_GMS_MASK) { + case I855_GMCH_GMS_STOLEN_1M: + gtt_entries = MB(1) - KB(132); + break; + case I855_GMCH_GMS_STOLEN_4M: + gtt_entries = MB(4) - KB(132); + break; + case I855_GMCH_GMS_STOLEN_8M: + gtt_entries = MB(8) - KB(132); + break; + case I855_GMCH_GMS_STOLEN_16M: + gtt_entries = MB(16) - KB(132); + break; + case I855_GMCH_GMS_STOLEN_32M: + gtt_entries = MB(32) - KB(132); + break; + default: + gtt_entries = 0; + break; + } } - + if (gtt_entries > 0) + printk(KERN_INFO PFX "Detected %dK %s memory.\n", + gtt_entries / KB(1), local ? "local" : "stolen"); + else + printk(KERN_INFO PFX + "No pre-allocated video memory detected.\n"); gtt_entries /= KB(4); intel_i830_private.gtt_entries = gtt_entries; @@ -374,9 +407,18 @@ u16 gmch_ctrl; struct aper_size_info_fixed *values; - pci_read_config_word(agp_bridge->dev,I830_GMCH_CTRL,&gmch_ctrl); values = A_SIZE_FIX(agp_bridge->aperture_sizes); + if (agp_bridge->dev->device != PCI_DEVICE_ID_INTEL_82830_HB && + agp_bridge->dev->device != PCI_DEVICE_ID_INTEL_82845G_HB) { + /* 855GM/852GM/865G has 128MB aperture size */ + agp_bridge->previous_size = agp_bridge->current_size = (void *) values; + agp_bridge->aperture_size_idx = 0; + return(values[0].size); + } + + pci_read_config_word(agp_bridge->dev,I830_GMCH_CTRL,&gmch_ctrl); + if ((gmch_ctrl & I830_GMCH_MEM_MASK) == I830_GMCH_MEM_128M) { agp_bridge->previous_size = agp_bridge->current_size = (void *) values; agp_bridge->aperture_size_idx = 0; @@ -558,6 +600,7 @@ return(0); } + static int intel_fetch_size(void) { int i; @@ -1241,7 +1284,7 @@ { .device_id = PCI_DEVICE_ID_INTEL_82830_HB, .chipset = INTEL_I830_M, - .chipset_name = "i830M", + .chipset_name = "830M", .chipset_setup = intel_830mp_setup }, { @@ -1259,7 +1302,7 @@ { .device_id = PCI_DEVICE_ID_INTEL_82845G_HB, .chipset = INTEL_I845_G, - .chipset_name = "i845G", + .chipset_name = "845G", .chipset_setup = intel_845_setup }, { @@ -1269,11 +1312,23 @@ .chipset_setup = intel_850_setup }, { + .device_id = PCI_DEVICE_ID_INTEL_82855_HB, + .chipset = INTEL_I855_PM, + .chipset_name = "855PM", + .chipset_setup = intel_845_setup + }, + { .device_id = PCI_DEVICE_ID_INTEL_82860_HB, .chipset = INTEL_I860, .chipset_name = "i860", .chipset_setup = intel_860_setup }, + { + .device_id = PCI_DEVICE_ID_INTEL_82865_HB, + .chipset = INTEL_I865_G, + .chipset_name = "865G", + .chipset_setup = intel_845_setup + }, { }, /* dummy final entry, always present */ }; @@ -1387,13 +1442,13 @@ if (i810_dev == NULL) { /* - * We probably have a I845MP chipset with an external graphics + * We probably have a I845G chipset with an external graphics * card. It will be initialized later */ agp_bridge->type = INTEL_I845_G; break; } - printk(KERN_INFO PFX "Detected an Intel 845G Chipset.\n"); + printk(KERN_INFO PFX "Detected an Intel(R) 845G Chipset.\n"); agp_bridge->type = INTEL_I810; return intel_i830_setup(i810_dev); @@ -1408,7 +1463,63 @@ agp_bridge->type = INTEL_I830_M; break; } - printk(KERN_INFO PFX "Detected an Intel 830M Chipset.\n"); + printk(KERN_INFO PFX "Detected an Intel(R) 830M Chipset.\n"); + agp_bridge->type = INTEL_I810; + return intel_i830_setup(i810_dev); + + case PCI_DEVICE_ID_INTEL_82855_HB: + i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82855_IG, NULL); + if(i810_dev && PCI_FUNC(i810_dev->devfn) != 0) + i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82855_IG, i810_dev); + + if (i810_dev == NULL) { + /* Intel 855PM with external graphic card */ + /* It will be initialized later */ + agp_bridge->type = INTEL_I855_PM; + break; + } + { + u32 capval = 0; + const char *name = "855GM/852GM"; + pci_read_config_dword(dev, I85X_CAPID, &capval); + switch ((capval >> I85X_VARIANT_SHIFT) & + I85X_VARIANT_MASK) { + case I855_GME: + name = "855GME"; + break; + case I855_GM: + name = "855GM"; + break; + case I852_GME: + name = "852GME"; + break; + case I852_GM: + name = "852GM"; + break; + } + printk(KERN_INFO PFX + "Detected an Intel(R) %s Chipset.\n", name); + } + agp_bridge->type = INTEL_I810; + return intel_i830_setup(i810_dev); + + case PCI_DEVICE_ID_INTEL_82865_HB: + i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL, + PCI_DEVICE_ID_INTEL_82865_IG, NULL); + if (i810_dev && PCI_FUNC(i810_dev->devfn) != 0) { + i810_dev = pci_find_device(PCI_VENDOR_ID_INTEL, + PCI_DEVICE_ID_INTEL_82865_IG, i810_dev); + } + + if (i810_dev == NULL) { + /* + * We probably have a 865G chipset with an external graphics + * card. It will be initialized later + */ + agp_bridge->type = INTEL_I865_G; + break; + } + printk(KERN_INFO PFX "Detected an Intel(R) 865G Chipset.\n"); agp_bridge->type = INTEL_I810; return intel_i830_setup(i810_dev); diff -Nru a/drivers/char/cd1865.h b/drivers/char/cd1865.h --- a/drivers/char/cd1865.h Tue Mar 4 19:30:10 2003 +++ b/drivers/char/cd1865.h Tue Mar 4 19:30:10 2003 @@ -54,9 +54,9 @@ #define CD186x_RCSR 0x7a /* Receiver Character Status Register */ #define CD186x_TDR 0x7b /* Transmit Data Register */ #define CD186x_EOIR 0x7f /* End of Interrupt Register */ -#define CD186x_MRAR 0x75 /* Modem Request Acknowlege register */ -#define CD186x_TRAR 0x76 /* Transmit Request Acknowlege register */ -#define CD186x_RRAR 0x77 /* Receive Request Acknowlege register */ +#define CD186x_MRAR 0x75 /* Modem Request Acknowledge register */ +#define CD186x_TRAR 0x76 /* Transmit Request Acknowledge register */ +#define CD186x_RRAR 0x77 /* Receive Request Acknowledge register */ #define CD186x_SRCR 0x66 /* Service Request Configuration register */ /* Channel Registers */ diff -Nru a/drivers/char/cyclades.c b/drivers/char/cyclades.c --- a/drivers/char/cyclades.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/cyclades.c Tue Mar 4 19:30:05 2003 @@ -151,7 +151,7 @@ * Revision 2.2.1.4 1998/08/04 11:02:50 ivan * /proc/cyclades implementation with great collaboration of * Marc Lewis ; - * cyy_interrupt was changed to avoid occurence of kernel oopses + * cyy_interrupt was changed to avoid occurrence of kernel oopses * during PPP operation. * * Revision 2.2.1.3 1998/06/01 12:09:10 ivan diff -Nru a/drivers/char/drm/drm_vm.h b/drivers/char/drm/drm_vm.h --- a/drivers/char/drm/drm_vm.h Tue Mar 4 19:30:14 2003 +++ b/drivers/char/drm/drm_vm.h Tue Mar 4 19:30:14 2003 @@ -147,7 +147,7 @@ } /* Special close routine which deletes map information if we are the last - * person to close a mapping and its not in the global maplist. + * person to close a mapping and it's not in the global maplist. */ void DRM(vm_shm_close)(struct vm_area_struct *vma) diff -Nru a/drivers/char/drm/i810_drm.h b/drivers/char/drm/i810_drm.h --- a/drivers/char/drm/i810_drm.h Tue Mar 4 19:30:03 2003 +++ b/drivers/char/drm/i810_drm.h Tue Mar 4 19:30:03 2003 @@ -38,7 +38,7 @@ * - zbuffer linear offset and pitch -- also invarient * - drawing origin in back and depth buffers. * - * Keep the depth/back buffer state here to acommodate private buffers + * Keep the depth/back buffer state here to accommodate private buffers * in the future. */ #define I810_DESTREG_DI0 0 /* CMD_OP_DESTBUFFER_INFO (2 dwords) */ diff -Nru a/drivers/char/drm/i830_drm.h b/drivers/char/drm/i830_drm.h --- a/drivers/char/drm/i830_drm.h Tue Mar 4 19:30:07 2003 +++ b/drivers/char/drm/i830_drm.h Tue Mar 4 19:30:07 2003 @@ -68,7 +68,7 @@ * - zbuffer linear offset and pitch -- also invarient * - drawing origin in back and depth buffers. * - * Keep the depth/back buffer state here to acommodate private buffers + * Keep the depth/back buffer state here to accommodate private buffers * in the future. */ diff -Nru a/drivers/char/epca.c b/drivers/char/epca.c --- a/drivers/char/epca.c Tue Mar 4 19:30:10 2003 +++ b/drivers/char/epca.c Tue Mar 4 19:30:10 2003 @@ -897,7 +897,7 @@ Remember copy_from_user WILL generate a page fault if the user memory being accessed has been swapped out. This can cause this routine to temporarily sleep while this page - fault is occuring. + fault is occurring. ----------------------------------------------------------------- */ @@ -1865,7 +1865,7 @@ case PCXI: board_id = inb((int)bd->port); if ((board_id & 0x1) == 0x1) - { /* Begin its an XI card */ + { /* Begin it's an XI card */ /* Is it a 64K board */ if ((board_id & 0x30) == 0) @@ -2743,11 +2743,11 @@ /* --------------------------------------------------------------- Command sets channels iflag structure on the board. Such things - as input soft flow control, handeling of parity errors, and - break handeling are all set here. + as input soft flow control, handling of parity errors, and + break handling are all set here. ------------------------------------------------------------------- */ - /* break handeling, parity handeling, input stripping, flow control chars */ + /* break handling, parity handling, input stripping, flow control chars */ fepcmd(ch, SETIFLAGS, (unsigned int) ch->fepiflag, 0, 0, 0); } @@ -3516,7 +3516,7 @@ /* ------------------------------------------------------------------ The below routines pc_throttle and pc_unthrottle are used to slow (And resume) the receipt of data into the kernels - receive buffers. The exact occurence of this depends on the + receive buffers. The exact occurrence of this depends on the size of the kernels receive buffer and what the 'watermarks' are set to for that buffer. See the n_ttys.c file for more details. diff -Nru a/drivers/char/ftape/lowlevel/ftape-calibr.c b/drivers/char/ftape/lowlevel/ftape-calibr.c --- a/drivers/char/ftape/lowlevel/ftape-calibr.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/ftape/lowlevel/ftape-calibr.c Tue Mar 4 19:30:05 2003 @@ -56,7 +56,7 @@ * used directly to implement fine-grained timeouts. However, on * Alpha PCs, the 8254 is *not* used to implement the clock tick * (which is 1024 Hz, normally) and the 8254 timer runs at some - * "random" frequency (it seems to run at 18Hz, but its not safe to + * "random" frequency (it seems to run at 18Hz, but it's not safe to * rely on this value). Instead, we use the Alpha's "rpcc" * instruction to read cycle counts. As this is a 32 bit counter, * it will overflow only once per 30 seconds (on a 200MHz machine), diff -Nru a/drivers/char/ftape/lowlevel/ftape_syms.c b/drivers/char/ftape/lowlevel/ftape_syms.c --- a/drivers/char/ftape/lowlevel/ftape_syms.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/ftape/lowlevel/ftape_syms.c Tue Mar 4 19:30:07 2003 @@ -22,7 +22,7 @@ * * This file contains the symbols that the ftape low level * part of the QIC-40/80/3010/3020 floppy-tape driver "ftape" - * exports to it's high level clients + * exports to its high level clients */ #include diff -Nru a/drivers/char/ftape/zftape/zftape-vtbl.h b/drivers/char/ftape/zftape/zftape-vtbl.h --- a/drivers/char/ftape/zftape/zftape-vtbl.h Tue Mar 4 19:30:07 2003 +++ b/drivers/char/ftape/zftape/zftape-vtbl.h Tue Mar 4 19:30:07 2003 @@ -176,7 +176,7 @@ const zft_position *pos); /* this function decrements the zft_seg_pos counter if we are right - * at the beginning of a segment. This is to handel fsfm/bsfm -- we + * at the beginning of a segment. This is to handle fsfm/bsfm -- we * need to position before the eof mark. NOTE: zft_tape_pos is not * changed */ diff -Nru a/drivers/char/ftape/zftape/zftape-write.c b/drivers/char/ftape/zftape/zftape-write.c --- a/drivers/char/ftape/zftape/zftape-write.c Tue Mar 4 19:30:09 2003 +++ b/drivers/char/ftape/zftape/zftape-write.c Tue Mar 4 19:30:09 2003 @@ -357,7 +357,7 @@ *volume = zft_find_volume(pos->seg_pos); DUMP_VOLINFO(ft_t_noise, "", *volume); zft_just_before_eof = 0; - /* now merge with old data if neccessary */ + /* now merge with old data if necessary */ if (!zft_qic_mode && pos->seg_byte_pos != 0){ result = zft_fetch_segment(pos->seg_pos, zft_deblock_buf, diff -Nru a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c --- a/drivers/char/generic_serial.c Tue Mar 4 19:30:09 2003 +++ b/drivers/char/generic_serial.c Tue Mar 4 19:30:09 2003 @@ -142,14 +142,14 @@ /* Can't copy more? break out! */ if (c <= 0) break; - if (from_user) + if (from_user) { if (copy_from_user (port->xmit_buf + port->xmit_head, buf, c)) { up (& port->port_write_sem); return -EFAULT; } - else + } else memcpy (port->xmit_buf + port->xmit_head, buf, c); port -> xmit_cnt += c; diff -Nru a/drivers/char/hangcheck-timer.c b/drivers/char/hangcheck-timer.c --- a/drivers/char/hangcheck-timer.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/hangcheck-timer.c Tue Mar 4 19:30:07 2003 @@ -16,7 +16,7 @@ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * - * You should have recieved a copy of the GNU General Public + * You should have received a copy of the GNU General Public * License along with this program; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 021110-1307, USA. diff -Nru a/drivers/char/mwave/tp3780i.h b/drivers/char/mwave/tp3780i.h --- a/drivers/char/mwave/tp3780i.h Tue Mar 4 19:30:04 2003 +++ b/drivers/char/mwave/tp3780i.h Tue Mar 4 19:30:04 2003 @@ -72,7 +72,7 @@ #define TP_CFG_DisableLBusTimeout 0 /* Enable LBus timeout */ #define TP_CFG_N_Divisor 32 /* Clock = 39.1608 Mhz */ #define TP_CFG_M_Multiplier 37 /* " */ -#define TP_CFG_PllBypass 0 /* dont bypass */ +#define TP_CFG_PllBypass 0 /* don't bypass */ #define TP_CFG_ChipletEnable 0xFFFF /* Enable all chiplets */ typedef struct { diff -Nru a/drivers/char/n_hdlc.c b/drivers/char/n_hdlc.c --- a/drivers/char/n_hdlc.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/n_hdlc.c Tue Mar 4 19:30:05 2003 @@ -833,7 +833,7 @@ poll_wait(filp, &tty->read_wait, wait); poll_wait(filp, &tty->write_wait, wait); - /* set bits for operations that wont block */ + /* set bits for operations that won't block */ if(n_hdlc->rx_buf_list.head) mask |= POLLIN | POLLRDNORM; /* readable */ if (test_bit(TTY_OTHER_CLOSED, &tty->flags)) diff -Nru a/drivers/char/nvram.c b/drivers/char/nvram.c --- a/drivers/char/nvram.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/nvram.c Tue Mar 4 19:30:07 2003 @@ -606,7 +606,7 @@ #if MACH == COBALT -/* the cobalt CMOS has a wider range of it's checksum */ +/* the cobalt CMOS has a wider range of its checksum */ static int cobalt_check_checksum(void) { int i; diff -Nru a/drivers/char/nwflash.c b/drivers/char/nwflash.c --- a/drivers/char/nwflash.c Tue Mar 4 19:30:14 2003 +++ b/drivers/char/nwflash.c Tue Mar 4 19:30:14 2003 @@ -215,7 +215,7 @@ temp = ((int) (p + count) >> 16) - nBlock + 1; /* - * write ends at exactly 64k boundry? + * write ends at exactly 64k boundary? */ if (((int) (p + count) & 0xFFFF) == 0) temp -= 1; diff -Nru a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c --- a/drivers/char/pcmcia/synclink_cs.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/pcmcia/synclink_cs.c Tue Mar 4 19:30:07 2003 @@ -4505,7 +4505,7 @@ if (debug_level >= DEBUG_LEVEL_INFO) printk("mgslpc_sppp_rx_done(%s)\n",info->netname); if (skb == NULL) { - printk(KERN_NOTICE "%s: cant alloc skb, dropping packet\n", + printk(KERN_NOTICE "%s: can't alloc skb, dropping packet\n", info->netname); info->netstats.rx_dropped++; return; diff -Nru a/drivers/char/rio/list.h b/drivers/char/rio/list.h --- a/drivers/char/rio/list.h Tue Mar 4 19:30:12 2003 +++ b/drivers/char/rio/list.h Tue Mar 4 19:30:12 2003 @@ -111,7 +111,7 @@ /* ** can_remove_receive( PacketP, PortP ) returns non-zero if PKT_IN_USE is set ** for the next packet on the queue. It will also set PacketP to point to the -** relevent packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear, +** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear, ** then can_remove_receive() returns 0. */ #if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc) diff -Nru a/drivers/char/rio/parmmap.h b/drivers/char/rio/parmmap.h --- a/drivers/char/rio/parmmap.h Tue Mar 4 19:30:13 2003 +++ b/drivers/char/rio/parmmap.h Tue Mar 4 19:30:13 2003 @@ -31,7 +31,7 @@ ---------------------------------------------------------------------------- Date By Description ---------------------------------------------------------------------------- -6/4/1991 jonb Made changes to accomodate Mips R3230 bus +6/4/1991 jonb Made changes to accommodate Mips R3230 bus ***************************************************************************/ #ifndef _parmap_h diff -Nru a/drivers/char/rio/rio_linux.c b/drivers/char/rio/rio_linux.c --- a/drivers/char/rio/rio_linux.c Tue Mar 4 19:30:10 2003 +++ b/drivers/char/rio/rio_linux.c Tue Mar 4 19:30:10 2003 @@ -464,7 +464,7 @@ recursive calls will hang the machine in the interrupt routine. - hardware twiddling goes before "recursive". Otherwise when we - poll the card, and a recursive interrupt happens, we wont + poll the card, and a recursive interrupt happens, we won't ack the card, so it might keep on interrupting us. (especially level sensitive interrupt systems like PCI). diff -Nru a/drivers/char/rio/rioinit.c b/drivers/char/rio/rioinit.c --- a/drivers/char/rio/rioinit.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/rio/rioinit.c Tue Mar 4 19:30:05 2003 @@ -145,7 +145,7 @@ p->RIOHosts[p->RIONumHosts].PaddrP = info->location; /* - ** Check that we are able to accomodate another host + ** Check that we are able to accommodate another host */ if ( p->RIONumHosts >= RIO_HOSTS ) { diff -Nru a/drivers/char/rio/rioparam.c b/drivers/char/rio/rioparam.c --- a/drivers/char/rio/rioparam.c Tue Mar 4 19:30:14 2003 +++ b/drivers/char/rio/rioparam.c Tue Mar 4 19:30:14 2003 @@ -714,7 +714,7 @@ /* ** can_remove_receive(PktP,P) returns non-zero if PKT_IN_USE is set ** for the next packet on the queue. It will also set PktP to point to the -** relevent packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear, +** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear, ** then can_remove_receive() returns 0. */ int diff -Nru a/drivers/char/rio/rioroute.c b/drivers/char/rio/rioroute.c --- a/drivers/char/rio/rioroute.c Tue Mar 4 19:30:09 2003 +++ b/drivers/char/rio/rioroute.c Tue Mar 4 19:30:09 2003 @@ -521,7 +521,7 @@ /* ** If either of the modules on this unit is read-only or write-only ** or none-xprint, then we need to transfer that info over to the - ** relevent ports. + ** relevant ports. */ if ( HostP->Mapping[ThisUnit].SysPort != NO_PORT ) { @@ -976,7 +976,7 @@ /* ** We loop for all entries even after finding an entry and ** zeroing it because we may have two entries to delete if - ** its a 16 port RTA. + ** it's a 16 port RTA. */ for (entry = 0; entry < TOTAL_MAP_ENTRIES; entry++) { diff -Nru a/drivers/char/rio/riotable.c b/drivers/char/rio/riotable.c --- a/drivers/char/rio/riotable.c Tue Mar 4 19:30:13 2003 +++ b/drivers/char/rio/riotable.c Tue Mar 4 19:30:13 2003 @@ -309,7 +309,7 @@ } /* - ** wow! if we get here then its a goody! + ** wow! if we get here then it's a goody! */ /* diff -Nru a/drivers/char/rio/riotty.c b/drivers/char/rio/riotty.c --- a/drivers/char/rio/riotty.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/rio/riotty.c Tue Mar 4 19:30:07 2003 @@ -737,10 +737,10 @@ RIOCookMode(struct ttystatics *tp) { /* - ** We cant handle tm.c_mstate != 0 on SCO - ** We cant handle mapping - ** We cant handle non-ttwrite line disc. - ** We cant handle lflag XCASE + ** We can't handle tm.c_mstate != 0 on SCO + ** We can't handle mapping + ** We can't handle non-ttwrite line disc. + ** We can't handle lflag XCASE ** We can handle oflag OPOST & (OCRNL, ONLCR, TAB3) */ diff -Nru a/drivers/char/rocket_int.h b/drivers/char/rocket_int.h --- a/drivers/char/rocket_int.h Tue Mar 4 19:30:05 2003 +++ b/drivers/char/rocket_int.h Tue Mar 4 19:30:05 2003 @@ -834,7 +834,7 @@ /*************************************************************************** Function: sInitChanDefaults -Purpose: Initialize a channel structure to it's default state. +Purpose: Initialize a channel structure to its default state. Call: sInitChanDefaults(ChP) CHANNEL_T *ChP; Ptr to the channel structure Comments: This function must be called once for every channel structure diff -Nru a/drivers/char/scc.h b/drivers/char/scc.h --- a/drivers/char/scc.h Tue Mar 4 19:30:13 2003 +++ b/drivers/char/scc.h Tue Mar 4 19:30:13 2003 @@ -428,7 +428,7 @@ * for that purpose. They assume that a local variable 'port' is * declared and pointing to the port's scc_struct entry. The * variants with "_NB" appended should be used if no other SCC - * accesses follow immediatly (within 0.5 usecs). They just skip the + * accesses follow immediately (within 0.5 usecs). They just skip the * final delay nops. * * Please note that accesses to SCC registers should only take place diff -Nru a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c --- a/drivers/char/ser_a2232.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/ser_a2232.c Tue Mar 4 19:30:05 2003 @@ -590,7 +590,7 @@ printk("A2232: 65EC02 software sent SYNC event, don't know what to do. Ignoring."); break; default: - printk("A2232: 65EC02 software broken, unknown event type %d occured.\n",ibuf[bufpos-1]); + printk("A2232: 65EC02 software broken, unknown event type %d occurred.\n",ibuf[bufpos-1]); } /* event type switch */ break; case A2232INCTL_CHAR: @@ -599,7 +599,7 @@ bufpos++; break; default: - printk("A2232: 65EC02 software broken, unknown data type %d occured.\n",cbuf[bufpos]); + printk("A2232: 65EC02 software broken, unknown data type %d occurred.\n",cbuf[bufpos]); bufpos++; } /* switch on input data type */ } /* while there's something in the buffer */ diff -Nru a/drivers/char/sx.c b/drivers/char/sx.c --- a/drivers/char/sx.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/sx.c Tue Mar 4 19:30:07 2003 @@ -1216,7 +1216,7 @@ recursive calls will hang the machine in the interrupt routine. - hardware twiddling goes before "recursive". Otherwise when we - poll the card, and a recursive interrupt happens, we wont + poll the card, and a recursive interrupt happens, we won't ack the card, so it might keep on interrupting us. (especially level sensitive interrupt systems like PCI). diff -Nru a/drivers/char/synclink.c b/drivers/char/synclink.c --- a/drivers/char/synclink.c Tue Mar 4 19:30:07 2003 +++ b/drivers/char/synclink.c Tue Mar 4 19:30:07 2003 @@ -4260,7 +4260,7 @@ if ( info->tx_holding_count ) { /* determine if we have enough tx dma buffers - * to accomodate the next tx frame + * to accommodate the next tx frame */ struct tx_holding_buffer *ptx = &info->tx_holding_buffers[info->get_tx_holding_index]; @@ -7621,7 +7621,7 @@ status = info->rx_buffer_list[0].status; if ( status & (BIT8 + BIT3 + BIT1) ) { - /* receive error has occured */ + /* receive error has occurred */ rc = FALSE; } else { if ( memcmp( info->tx_buffer_list[0].virt_addr , @@ -8103,7 +8103,7 @@ if (debug_level >= DEBUG_LEVEL_INFO) printk("mgsl_sppp_rx_done(%s)\n",info->netname); if (skb == NULL) { - printk(KERN_NOTICE "%s: cant alloc skb, dropping packet\n", + printk(KERN_NOTICE "%s: can't alloc skb, dropping packet\n", info->netname); info->netstats.rx_dropped++; return; diff -Nru a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c --- a/drivers/char/synclinkmp.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/synclinkmp.c Tue Mar 4 19:30:05 2003 @@ -1829,7 +1829,7 @@ if (debug_level >= DEBUG_LEVEL_INFO) printk("sppp_rx_done(%s)\n",info->netname); if (skb == NULL) { - printk(KERN_NOTICE "%s: cant alloc skb, dropping packet\n", + printk(KERN_NOTICE "%s: can't alloc skb, dropping packet\n", info->netname); info->netstats.rx_dropped++; return; diff -Nru a/drivers/char/tty_io.c b/drivers/char/tty_io.c --- a/drivers/char/tty_io.c Tue Mar 4 19:30:10 2003 +++ b/drivers/char/tty_io.c Tue Mar 4 19:30:10 2003 @@ -1944,27 +1944,25 @@ schedule_delayed_work(&tty->flip.work, 1); return; } + + spin_lock_irqsave(&tty->read_lock, flags); if (tty->flip.buf_num) { cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE; fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE; tty->flip.buf_num = 0; - - local_irq_save(flags); // FIXME: is this safe? tty->flip.char_buf_ptr = tty->flip.char_buf; tty->flip.flag_buf_ptr = tty->flip.flag_buf; } else { cp = tty->flip.char_buf; fp = tty->flip.flag_buf; tty->flip.buf_num = 1; - - local_irq_save(flags); // FIXME: is this safe? tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE; tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE; } count = tty->flip.count; tty->flip.count = 0; - local_irq_restore(flags); // FIXME: is this safe? - + spin_unlock_irqrestore(&tty->read_lock, flags); + tty->ldisc.receive_buf(tty, cp, fp, count); } diff -Nru a/drivers/char/vt.c b/drivers/char/vt.c --- a/drivers/char/vt.c Tue Mar 4 19:30:13 2003 +++ b/drivers/char/vt.c Tue Mar 4 19:30:13 2003 @@ -1882,7 +1882,7 @@ buf = con_buf; } - /* At this point 'buf' is guarenteed to be a kernel buffer + /* At this point 'buf' is guaranteed to be a kernel buffer * and therefore no access to userspace (and therefore sleeping) * will be needed. The con_buf_sem serializes all tty based * console rendering and vcs write/read operations. We hold @@ -2872,7 +2872,7 @@ * this is done in order to maintain compatibility with the EGA/VGA fonts. It * is upto the actual low-level console-driver convert data into its favorite * format (maybe we should add a `fontoffset' field to the `display' - * structure so we wont have to convert the fontdata all the time. + * structure so we won't have to convert the fontdata all the time. * /Jes */ diff -Nru a/drivers/char/watchdog/Kconfig b/drivers/char/watchdog/Kconfig --- a/drivers/char/watchdog/Kconfig Tue Mar 4 19:30:11 2003 +++ b/drivers/char/watchdog/Kconfig Tue Mar 4 19:30:11 2003 @@ -313,6 +313,19 @@ You can compile this driver directly into the kernel, or use it as a module. The module will be called sc520_wdt. +config AMD7XX_TCO + tristate "AMD 766/768 TCO Timer/Watchdog" + depends on WATCHDOG + help + This is the driver for the hardware watchdog built in to the + AMD 766/768 chipsets. + This watchdog simply watches your kernel to make sure it doesn't + freeze, and if it does, it reboots your computer after a certain + amount of time. + + You can compile this driver directly into the kernel, or use + it as a module. The module will be called amd7xx_tco. + config ALIM7101_WDT tristate "ALi M7101 PMU Computer Watchdog" depends on WATCHDOG diff -Nru a/drivers/char/watchdog/Makefile b/drivers/char/watchdog/Makefile --- a/drivers/char/watchdog/Makefile Tue Mar 4 19:30:11 2003 +++ b/drivers/char/watchdog/Makefile Tue Mar 4 19:30:11 2003 @@ -30,3 +30,4 @@ obj-$(CONFIG_SC1200_WDT) += sc1200wdt.o obj-$(CONFIG_WAFER_WDT) += wafer5823wdt.o obj-$(CONFIG_CPU5_WDT) += cpu5wdt.o +obj-$(CONFIG_AMD7XX_TCO) += amd7xx_tco.o diff -Nru a/drivers/char/watchdog/acquirewdt.c b/drivers/char/watchdog/acquirewdt.c --- a/drivers/char/watchdog/acquirewdt.c Tue Mar 4 19:30:10 2003 +++ b/drivers/char/watchdog/acquirewdt.c Tue Mar 4 19:30:10 2003 @@ -141,8 +141,6 @@ spin_unlock(&acq_lock); return -EBUSY; } - if (nowayout) - MOD_INC_USE_COUNT; /* Activate */ acq_is_open=1; diff -Nru a/drivers/char/watchdog/amd7xx_tco.c b/drivers/char/watchdog/amd7xx_tco.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/char/watchdog/amd7xx_tco.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,373 @@ +/* + * AMD 766/768 TCO Timer Driver + * (c) Copyright 2002 Zwane Mwaikambo + * All Rights Reserved. + * + * Parts from; + * Hardware driver for the AMD 768 Random Number Generator (RNG) + * (c) Copyright 2001 Red Hat Inc + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License version 2 + * as published by the Free Software Foundation. + * + * The author(s) of this software shall not be held liable for damages + * of any nature resulting due to the use of this software. This + * software is provided AS-IS with no warranties. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define AMDTCO_MODULE_VER "build 20020601" +#define AMDTCO_MODULE_NAME "amd7xx_tco" +#define PFX AMDTCO_MODULE_NAME ": " + +#define MAX_TIMEOUT 38 /* max of 38 seconds */ + +/* pmbase registers */ +#define GLOBAL_SMI_REG 0x2a +#define TCO_EN (1 << 1) /* bit 1 in global SMI register */ +#define TCO_RELOAD_REG 0x40 /* bits 0-5 are current count, 6-7 are reserved */ +#define TCO_INITVAL_REG 0x41 /* bits 0-5 are value to load, 6-7 are reserved */ +#define TCO_TIMEOUT_MASK 0x3f +#define TCO_STATUS2_REG 0x46 +#define NDTO_STS2 (1 << 1) /* we're interested in the second timeout */ +#define BOOT_STS (1 << 2) /* will be set if NDTO_STS2 was set before reboot */ +#define TCO_CTRL1_REG 0x48 +#define TCO_HALT (1 << 11) + +static char banner[] __initdata = KERN_INFO PFX AMDTCO_MODULE_VER; +static int timeout = 38; +static u32 pmbase; /* PMxx I/O base */ +static struct pci_dev *dev; +static struct semaphore open_sem; +spinlock_t amdtco_lock; /* only for device access */ +static int expect_close = 0; + +MODULE_PARM(timeout, "i"); +MODULE_PARM_DESC(timeout, "range is 0-38 seconds, default is 38"); + +static inline int amdtco_status(void) +{ + u16 reg; + int status = 0; + + reg = inb(pmbase+TCO_CTRL1_REG); + if ((reg & TCO_HALT) == 0) + status |= WDIOF_KEEPALIVEPING; + + reg = inb(pmbase+TCO_STATUS2_REG); + if (reg & BOOT_STS) + status |= WDIOF_CARDRESET; + + return status; +} + +static inline void amdtco_ping(void) +{ + u8 reg; + + spin_lock(&amdtco_lock); + reg = inb(pmbase+TCO_RELOAD_REG); + outb(1 | reg, pmbase+TCO_RELOAD_REG); + spin_unlock(&amdtco_lock); +} + +static inline int amdtco_gettimeout(void) +{ + return inb(TCO_RELOAD_REG) & TCO_TIMEOUT_MASK; +} + +static inline void amdtco_settimeout(unsigned int timeout) +{ + u8 reg; + + spin_lock(&amdtco_lock); + reg = inb(pmbase+TCO_INITVAL_REG); + reg |= timeout & TCO_TIMEOUT_MASK; + outb(reg, pmbase+TCO_INITVAL_REG); + spin_unlock(&amdtco_lock); +} + +static inline void amdtco_global_enable(void) +{ + u16 reg; + + spin_lock(&amdtco_lock); + reg = inw(pmbase+GLOBAL_SMI_REG); + reg |= TCO_EN; + outw(reg, pmbase+GLOBAL_SMI_REG); + spin_unlock(&amdtco_lock); +} + +static inline void amdtco_enable(void) +{ + u16 reg; + + spin_lock(&amdtco_lock); + reg = inw(pmbase+TCO_CTRL1_REG); + reg &= ~TCO_HALT; + outw(reg, pmbase+TCO_CTRL1_REG); + spin_unlock(&amdtco_lock); +} + +static inline void amdtco_disable(void) +{ + u16 reg; + + spin_lock(&amdtco_lock); + reg = inw(pmbase+TCO_CTRL1_REG); + reg |= TCO_HALT; + outw(reg, pmbase+TCO_CTRL1_REG); + spin_unlock(&amdtco_lock); +} + +static int amdtco_fop_open(struct inode *inode, struct file *file) +{ + if (down_trylock(&open_sem)) + return -EBUSY; + + if (timeout > MAX_TIMEOUT) + timeout = MAX_TIMEOUT; + + amdtco_settimeout(timeout); + amdtco_global_enable(); + amdtco_ping(); + printk(KERN_INFO PFX "Watchdog enabled, timeout = %d/%d seconds", + amdtco_gettimeout(), timeout); + + return 0; +} + + +static int amdtco_fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) +{ + int new_timeout; + int tmp; + + static struct watchdog_info ident = { + .options = WDIOF_SETTIMEOUT | WDIOF_CARDRESET, + .identity = "AMD 766/768" + }; + + switch (cmd) { + default: + return -ENOTTY; + + case WDIOC_GETSUPPORT: + if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof ident)) + return -EFAULT; + return 0; + + case WDIOC_GETSTATUS: + return put_user(amdtco_status(), (int *)arg); + + case WDIOC_KEEPALIVE: + amdtco_ping(); + return 0; + + case WDIOC_SETTIMEOUT: + if (get_user(new_timeout, (int *)arg)) + return -EFAULT; + + if (new_timeout < 0) + return -EINVAL; + + if (new_timeout > MAX_TIMEOUT) + new_timeout = MAX_TIMEOUT; + + timeout = new_timeout; + amdtco_settimeout(timeout); + /* fall through and return the new timeout */ + + case WDIOC_GETTIMEOUT: + return put_user(amdtco_gettimeout(), (int *)arg); + + case WDIOC_SETOPTIONS: + if (copy_from_user(&tmp, (int *)arg, sizeof tmp)) + return -EFAULT; + + if (tmp & WDIOS_DISABLECARD) + amdtco_disable(); + + if (tmp & WDIOS_ENABLECARD) + amdtco_enable(); + + return 0; + } +} + + +static int amdtco_fop_release(struct inode *inode, struct file *file) +{ + if (expect_close) { + amdtco_disable(); + printk(KERN_INFO PFX "Watchdog disabled\n"); + } else { + amdtco_ping(); + printk(KERN_CRIT PFX "Unexpected close!, timeout in %d seconds)\n", timeout); + } + + up(&open_sem); + return 0; +} + + +static ssize_t amdtco_fop_write(struct file *file, const char *data, size_t len, loff_t *ppos) +{ + if (ppos != &file->f_pos) + return -ESPIPE; + + if (len) { +#ifndef CONFIG_WATCHDOG_NOWAYOUT + size_t i; + char c; + expect_close = 0; + + for (i = 0; i != len; i++) { + if (get_user(c, data + i)) + return -EFAULT; + + if (c == 'V') + expect_close = 1; + } +#endif + amdtco_ping(); + return len; + } + + return 0; +} + + +static int amdtco_notify_sys(struct notifier_block *this, unsigned long code, void *unused) +{ + if (code == SYS_DOWN || code == SYS_HALT) + amdtco_disable(); + + return NOTIFY_DONE; +} + + +static struct notifier_block amdtco_notifier = +{ + .notifier_call = amdtco_notify_sys +}; + +static struct file_operations amdtco_fops = +{ + .owner = THIS_MODULE, + .write = amdtco_fop_write, + .ioctl = amdtco_fop_ioctl, + .open = amdtco_fop_open, + .release = amdtco_fop_release +}; + +static struct miscdevice amdtco_miscdev = +{ + .minor = WATCHDOG_MINOR, + .name = "watchdog", + .fops = &amdtco_fops +}; + +static struct pci_device_id amdtco_pci_tbl[] __initdata = { + /* AMD 766 PCI_IDs here */ + { PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_OPUS_7443, PCI_ANY_ID, PCI_ANY_ID, }, + { 0, } +}; + +MODULE_DEVICE_TABLE (pci, amdtco_pci_tbl); + +static int __init amdtco_init(void) +{ + int ret; + + sema_init(&open_sem, 1); + spin_lock_init(&amdtco_lock); + + pci_for_each_dev(dev) { + if (pci_match_device (amdtco_pci_tbl, dev) != NULL) + goto found_one; + } + + return -ENODEV; + +found_one: + + if ((ret = register_reboot_notifier(&amdtco_notifier))) { + printk(KERN_ERR PFX "Unable to register reboot notifier err = %d\n", ret); + goto out_clean; + } + + if ((ret = misc_register(&amdtco_miscdev))) { + printk(KERN_ERR PFX "Unable to register miscdev on minor %d\n", WATCHDOG_MINOR); + goto out_unreg_reboot; + } + + pci_read_config_dword(dev, 0x58, &pmbase); + pmbase &= 0x0000FF00; + + if (pmbase == 0) { + printk (KERN_ERR PFX "power management base not set\n"); + ret = -EIO; + goto out_unreg_misc; + } + + /* ret = 0; */ + printk(banner); + goto out_clean; + +out_unreg_misc: + misc_deregister(&amdtco_miscdev); +out_unreg_reboot: + unregister_reboot_notifier(&amdtco_notifier); +out_clean: + return ret; +} + +static void __exit amdtco_exit(void) +{ + misc_deregister(&amdtco_miscdev); + unregister_reboot_notifier(&amdtco_notifier); +} + + +#ifndef MODULE +static int __init amdtco_setup(char *str) +{ + int ints[4]; + + str = get_options (str, ARRAY_SIZE(ints), ints); + if (ints[0] > 0) + timeout = ints[1]; + + return 1; +} + +__setup("amd7xx_tco=", amdtco_setup); +#endif + +module_init(amdtco_init); +module_exit(amdtco_exit); + +MODULE_AUTHOR("Zwane Mwaikambo "); +MODULE_DESCRIPTION("AMD 766/768 TCO Timer Driver"); +MODULE_LICENSE("GPL"); +EXPORT_NO_SYMBOLS; + diff -Nru a/drivers/char/watchdog/i810-tco.c b/drivers/char/watchdog/i810-tco.c --- a/drivers/char/watchdog/i810-tco.c Tue Mar 4 19:30:04 2003 +++ b/drivers/char/watchdog/i810-tco.c Tue Mar 4 19:30:04 2003 @@ -161,7 +161,7 @@ } /* - * Reload (trigger) the timer. Lock is needed so we dont reload it during + * Reload (trigger) the timer. Lock is needed so we don't reload it during * a reprogramming event */ @@ -218,7 +218,7 @@ tco_expect_close = 0; - /* scan to see wether or not we got the magic character */ + /* scan to see whether or not we got the magic character */ for (i = 0; i != len; i++) { u8 c; if(get_user(c, data+i)) diff -Nru a/drivers/char/watchdog/ib700wdt.c b/drivers/char/watchdog/ib700wdt.c --- a/drivers/char/watchdog/ib700wdt.c Tue Mar 4 19:30:13 2003 +++ b/drivers/char/watchdog/ib700wdt.c Tue Mar 4 19:30:13 2003 @@ -50,6 +50,8 @@ static spinlock_t ibwdt_lock; static int expect_close = 0; +#define PFX "ib700wdt: " + /* * * Watchdog Timer Configuration @@ -226,8 +228,6 @@ spin_unlock(&ibwdt_lock); return -EBUSY; } - if (nowayout) - MOD_INC_USE_COUNT; /* Activate */ ibwdt_is_open = 1; @@ -247,7 +247,7 @@ if (expect_close) outb_p(wd_times[wd_margin], WDT_STOP); else - printk(KERN_CRIT "WDT device closed unexpectedly. WDT will not stop!\n"); + printk(KERN_CRIT PFX "WDT device closed unexpectedly. WDT will not stop!\n"); ibwdt_is_open = 0; spin_unlock(&ibwdt_lock); @@ -300,29 +300,49 @@ .priority = 0 }; -static int __init -ibwdt_init(void) +static int __init ibwdt_init(void) { - printk("WDT driver for IB700 single board computer initialising.\n"); + int res; + + printk(KERN_INFO PFX "WDT driver for IB700 single board computer initialising.\n"); spin_lock_init(&ibwdt_lock); - if (misc_register(&ibwdt_miscdev)) - return -ENODEV; + res = misc_register(&ibwdt_miscdev); + if (res) { + printk (KERN_ERR PFX "failed to register misc device\n"); + goto out_nomisc; + } + #if WDT_START != WDT_STOP if (!request_region(WDT_STOP, 1, "IB700 WDT")) { - misc_deregister(&ibwdt_miscdev); - return -EIO; + printk (KERN_ERR PFX "STOP method I/O %X is not available.\n", WDT_STOP); + res = -EIO; + goto out_nostopreg; } #endif + if (!request_region(WDT_START, 1, "IB700 WDT")) { -#if WDT_START != WDT_STOP - release_region(WDT_STOP, 1); -#endif - misc_deregister(&ibwdt_miscdev); - return -EIO; + printk (KERN_ERR PFX "START method I/O %X is not available.\n", WDT_START); + res = -EIO; + goto out_nostartreg; + } + res = register_reboot_notifier(&ibwdt_notifier); + if (res) { + printk (KERN_ERR PFX "Failed to register reboot notifier.\n"); + goto out_noreboot; } - register_reboot_notifier(&ibwdt_notifier); return 0; + +out_noreboot: + release_region(WDT_START, 1); +out_nostartreg: +#if WDT_START != WDT_STOP + release_region(WDT_STOP, 1); +#endif +out_nostopreg: + misc_deregister(&ibwdt_miscdev); +out_nomisc: + return res; } static void __exit diff -Nru a/drivers/char/watchdog/indydog.c b/drivers/char/watchdog/indydog.c --- a/drivers/char/watchdog/indydog.c Tue Mar 4 19:30:13 2003 +++ b/drivers/char/watchdog/indydog.c Tue Mar 4 19:30:13 2003 @@ -53,9 +53,6 @@ if( test_and_set_bit(0,&indydog_alive) ) return -EBUSY; - if (nowayout) - MOD_INC_USE_COUNT; - /* * Activate timer */ diff -Nru a/drivers/char/watchdog/machzwd.c b/drivers/char/watchdog/machzwd.c --- a/drivers/char/watchdog/machzwd.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/watchdog/machzwd.c Tue Mar 4 19:30:05 2003 @@ -390,9 +390,6 @@ return -EBUSY; } - if (nowayout) - MOD_INC_USE_COUNT; - zf_is_open = 1; spin_unlock(&zf_lock); diff -Nru a/drivers/char/watchdog/mixcomwd.c b/drivers/char/watchdog/mixcomwd.c --- a/drivers/char/watchdog/mixcomwd.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/watchdog/mixcomwd.c Tue Mar 4 19:30:05 2003 @@ -93,9 +93,7 @@ } mixcomwd_ping(); - if (nowayout) { - MOD_INC_USE_COUNT; - } else { + if (!nowayout) { if(mixcomwd_timer_alive) { del_timer(&mixcomwd_timer); mixcomwd_timer_alive=0; diff -Nru a/drivers/char/watchdog/pcwd.c b/drivers/char/watchdog/pcwd.c --- a/drivers/char/watchdog/pcwd.c Tue Mar 4 19:30:04 2003 +++ b/drivers/char/watchdog/pcwd.c Tue Mar 4 19:30:04 2003 @@ -430,7 +430,7 @@ atomic_inc( &open_allowed ); return -EBUSY; } - MOD_INC_USE_COUNT; + /* Enable the port */ if (revision == PCWD_REVISION_C) { spin_lock(&io_lock); diff -Nru a/drivers/char/watchdog/sbc60xxwdt.c b/drivers/char/watchdog/sbc60xxwdt.c --- a/drivers/char/watchdog/sbc60xxwdt.c Tue Mar 4 19:30:11 2003 +++ b/drivers/char/watchdog/sbc60xxwdt.c Tue Mar 4 19:30:11 2003 @@ -50,7 +50,7 @@ * * Why `V' ? Well, `V' is the character in ASCII for the value 86, * and we all know that 86 is _the_ most random number in the universe. - * Therefore it is the letter that has the slightest chance of occuring + * Therefore it is the letter that has the slightest chance of occurring * by chance, when the system becomes corrupted. * */ @@ -206,9 +206,7 @@ /* Just in case we're already talking to someone... */ if(wdt_is_open) return -EBUSY; - if (nowayout) { - MOD_INC_USE_COUNT; - } + /* Good, fire up the show */ wdt_is_open = 1; wdt_startup(); diff -Nru a/drivers/char/watchdog/sc520_wdt.c b/drivers/char/watchdog/sc520_wdt.c --- a/drivers/char/watchdog/sc520_wdt.c Tue Mar 4 19:30:08 2003 +++ b/drivers/char/watchdog/sc520_wdt.c Tue Mar 4 19:30:08 2003 @@ -229,8 +229,6 @@ return -EBUSY; /* Good, fire up the show */ wdt_startup(); - if (nowayout) - MOD_INC_USE_COUNT; return 0; default: @@ -253,11 +251,6 @@ return 0; } -static long long fop_llseek(struct file *file, long long offset, int origin) -{ - return -ESPIPE; -} - static int fop_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { @@ -282,7 +275,7 @@ static struct file_operations wdt_fops = { .owner = THIS_MODULE, - .llseek = fop_llseek, + .llseek = no_llseek, .write = fop_write, .open = fop_open, .release = fop_close, diff -Nru a/drivers/char/watchdog/shwdt.c b/drivers/char/watchdog/shwdt.c --- a/drivers/char/watchdog/shwdt.c Tue Mar 4 19:30:05 2003 +++ b/drivers/char/watchdog/shwdt.c Tue Mar 4 19:30:05 2003 @@ -1,9 +1,9 @@ /* * drivers/char/shwdt.c * - * Watchdog driver for integrated watchdog in the SuperH 3/4 processors. + * Watchdog driver for integrated watchdog in the SuperH processors. * - * Copyright (C) 2001 Paul Mundt + * Copyright (C) 2001, 2002 Paul Mundt * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -26,14 +26,17 @@ #include #include -#if defined(CONFIG_CPU_SH4) +#if defined(CONFIG_CPU_SH5) + #define WTCNT CPRC_BASE + 0x10 + #define WTCSR CPRC_BASE + 0x18 +#elif defined(CONFIG_CPU_SH4) #define WTCNT 0xffc00008 #define WTCSR 0xffc0000c #elif defined(CONFIG_CPU_SH3) #define WTCNT 0xffffff84 #define WTCSR 0xffffff86 #else - #error "Can't use SH 3/4 watchdog on non-SH 3/4 processor." + #error "Can't use SuperH watchdog on this platform" #endif #define WTCNT_HIGH 0x5a00 @@ -186,10 +189,6 @@ if (test_and_set_bit(0, &sh_is_open)) return -EBUSY; - if (nowayout) { - MOD_INC_USE_COUNT; - } - sh_wdt_start(); break; @@ -405,8 +404,8 @@ misc_deregister(&sh_wdt_miscdev); } -MODULE_AUTHOR("Paul Mundt "); -MODULE_DESCRIPTION("SH 3/4 watchdog driver"); +MODULE_AUTHOR("Paul Mundt "); +MODULE_DESCRIPTION("SuperH watchdog driver"); MODULE_LICENSE("GPL"); MODULE_PARM(clock_division_ratio, "i"); MODULE_PARM_DESC(clock_division_ratio, "Clock division ratio. Valid ranges are from 0x5 (1.31ms) to 0x7 (5.25ms). Defaults to 0x7."); diff -Nru a/drivers/char/watchdog/softdog.c b/drivers/char/watchdog/softdog.c --- a/drivers/char/watchdog/softdog.c Tue Mar 4 19:30:08 2003 +++ b/drivers/char/watchdog/softdog.c Tue Mar 4 19:30:08 2003 @@ -103,9 +103,7 @@ { if(test_and_set_bit(0, &timer_alive)) return -EBUSY; - if (nowayout) { - MOD_INC_USE_COUNT; - } + /* * Activate timer */ diff -Nru a/drivers/char/watchdog/wdt.c b/drivers/char/watchdog/wdt.c --- a/drivers/char/watchdog/wdt.c Tue Mar 4 19:30:09 2003 +++ b/drivers/char/watchdog/wdt.c Tue Mar 4 19:30:09 2003 @@ -175,7 +175,7 @@ * * Handle an interrupt from the board. These are raised when the status * map changes in what the board considers an interesting way. That means - * a failure condition occuring. + * a failure condition occurring. */ void wdt_interrupt(int irq, void *dev_id, struct pt_regs *regs) diff -Nru a/drivers/char/watchdog/wdt977.c b/drivers/char/watchdog/wdt977.c --- a/drivers/char/watchdog/wdt977.c Tue Mar 4 19:30:12 2003 +++ b/drivers/char/watchdog/wdt977.c Tue Mar 4 19:30:12 2003 @@ -99,8 +99,6 @@ if (nowayout) { - MOD_INC_USE_COUNT; - /* do not permit disabling the watchdog by writing 0 to reg. 0xF2 */ if (!timeoutM) timeoutM = DEFAULT_TIMEOUT; } diff -Nru a/drivers/char/watchdog/wdt_pci.c b/drivers/char/watchdog/wdt_pci.c --- a/drivers/char/watchdog/wdt_pci.c Tue Mar 4 19:30:10 2003 +++ b/drivers/char/watchdog/wdt_pci.c Tue Mar 4 19:30:10 2003 @@ -158,7 +158,7 @@ * * Handle an interrupt from the board. These are raised when the status * map changes in what the board considers an interesting way. That means - * a failure condition occuring. + * a failure condition occurring. */ static void wdtpci_interrupt(int irq, void *dev_id, struct pt_regs *regs) @@ -365,9 +365,6 @@ if (down_trylock(&open_sem)) return -EBUSY; - if (nowayout) { - MOD_INC_USE_COUNT; - } /* * Activate */ diff -Nru a/drivers/cpufreq/Kconfig b/drivers/cpufreq/Kconfig --- a/drivers/cpufreq/Kconfig Tue Mar 4 19:30:13 2003 +++ b/drivers/cpufreq/Kconfig Tue Mar 4 19:30:13 2003 @@ -9,3 +9,30 @@ For details, take a look at linux/Documentation/cpufreq. If in doubt, say N. + +config CPU_FREQ_GOV_USERSPACE + tristate "'userspace' governor for userspace frequency scaling" + depends on CPU_FREQ + help + Enable this cpufreq governor when you either want to set the + CPU frequency manually or when an userspace programm shall + be able to set the CPU dynamically, like on LART + ( http://www.lart.tudelft.nl/ ) + + For details, take a look at linux/Documentation/cpufreq. + + If in doubt, say Y. + +config CPU_FREQ_24_API + bool "/proc/sys/cpu/ interface (2.4. / OLD)" + depends on CPU_FREQ && SYSCTL && CPU_FREQ_GOV_USERSPACE + help + This enables the /proc/sys/cpu/ sysctl interface for controlling + the CPUFreq,"userspace" governor. This is the same interface + as known from the.4.-kernel patches for CPUFreq, and offers + the same functionality as long as "userspace" is the + selected governor for the specified CPU. + + For details, take a look at linux/Documentation/cpufreq. + + If in doubt, say N. diff -Nru a/drivers/cpufreq/Makefile b/drivers/cpufreq/Makefile --- a/drivers/cpufreq/Makefile Tue Mar 4 19:30:14 2003 +++ b/drivers/cpufreq/Makefile Tue Mar 4 19:30:14 2003 @@ -1,3 +1,4 @@ #CPUfreq governors and cross-arch helpers obj-$(CONFIG_CPU_FREQ_TABLE) += freq_table.o obj-$(CONFIG_CPU_FREQ_PROC_INTF) += proc_intf.o +obj-$(CONFIG_CPU_FREQ_GOV_USERSPACE) += userspace.o diff -Nru a/drivers/cpufreq/userspace.c b/drivers/cpufreq/userspace.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/cpufreq/userspace.c Tue Mar 4 19:30:14 2003 @@ -0,0 +1,596 @@ +/* + * drivers/cpufreq/userspace.c + * + * Copyright (C) 2001 Russell King + * (C) 2002 - 2003 Dominik Brodowski + * + * $Id:$ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define CTL_CPU_VARS_SPEED_MAX(cpunr) { \ + .ctl_name = CPU_NR_FREQ_MAX, \ + .data = &cpu_max_freq[cpunr], \ + .procname = "speed-max", \ + .maxlen = sizeof(cpu_max_freq[cpunr]),\ + .mode = 0444, \ + .proc_handler = proc_dointvec, } + +#define CTL_CPU_VARS_SPEED_MIN(cpunr) { \ + .ctl_name = CPU_NR_FREQ_MIN, \ + .data = &cpu_min_freq[cpunr], \ + .procname = "speed-min", \ + .maxlen = sizeof(cpu_min_freq[cpunr]),\ + .mode = 0444, \ + .proc_handler = proc_dointvec, } + +#define CTL_CPU_VARS_SPEED(cpunr) { \ + .ctl_name = CPU_NR_FREQ, \ + .procname = "speed", \ + .mode = 0644, \ + .proc_handler = cpufreq_procctl, \ + .strategy = cpufreq_sysctl, \ + .extra1 = (void*) (cpunr), } + +#define CTL_TABLE_CPU_VARS(cpunr) static ctl_table ctl_cpu_vars_##cpunr[] = {\ + CTL_CPU_VARS_SPEED_MAX(cpunr), \ + CTL_CPU_VARS_SPEED_MIN(cpunr), \ + CTL_CPU_VARS_SPEED(cpunr), \ + { .ctl_name = 0, }, } + +/* the ctl_table entry for each CPU */ +#define CPU_ENUM(s) { \ + .ctl_name = (CPU_NR + s), \ + .procname = #s, \ + .mode = 0555, \ + .child = ctl_cpu_vars_##s } + +/** + * A few values needed by the userspace governor + */ +static unsigned int cpu_max_freq[NR_CPUS]; +static unsigned int cpu_min_freq[NR_CPUS]; +static unsigned int cpu_cur_freq[NR_CPUS]; +static unsigned int cpu_is_managed[NR_CPUS]; +static struct cpufreq_policy current_policy[NR_CPUS]; + +static DECLARE_MUTEX (userspace_sem); + + +/* keep track of frequency transitions */ +static int +userspace_cpufreq_notifier(struct notifier_block *nb, unsigned long val, + void *data) +{ + struct cpufreq_freqs *freq = data; + + cpu_cur_freq[freq->cpu] = freq->new; + + return 0; +} + +static struct notifier_block userspace_cpufreq_notifier_block = { + .notifier_call = userspace_cpufreq_notifier +}; + + +/** + * cpufreq_set - set the CPU frequency + * @freq: target frequency in kHz + * @cpu: CPU for which the frequency is to be set + * + * Sets the CPU frequency to freq. + */ +int cpufreq_set(unsigned int freq, unsigned int cpu) +{ + int ret = -EINVAL; + + down(&userspace_sem); + if (!cpu_is_managed[cpu]) + goto err; + + if (freq < cpu_min_freq[cpu]) + freq = cpu_min_freq[cpu]; + if (freq > cpu_max_freq[cpu]) + freq = cpu_max_freq[cpu]; + + ret = cpufreq_driver_target_l(¤t_policy[cpu], freq, + CPUFREQ_RELATION_L); + + err: + up(&userspace_sem); + return ret; +} +EXPORT_SYMBOL_GPL(cpufreq_set); + + +/** + * cpufreq_setmax - set the CPU to the maximum frequency + * @cpu - affected cpu; + * + * Sets the CPU frequency to the maximum frequency supported by + * this CPU. + */ +int cpufreq_setmax(unsigned int cpu) +{ + if (!cpu_is_managed[cpu] || !cpu_online(cpu)) + return -EINVAL; + return cpufreq_set(cpu_max_freq[cpu], cpu); +} +EXPORT_SYMBOL_GPL(cpufreq_setmax); + + +/** + * cpufreq_get - get the current CPU frequency (in kHz) + * @cpu: CPU number + * + * Get the CPU current (static) CPU frequency + */ +unsigned int cpufreq_get(unsigned int cpu) +{ + return cpu_cur_freq[cpu]; +} +EXPORT_SYMBOL(cpufreq_get); + + +#ifdef CONFIG_CPU_FREQ_24_API + + +/*********************** cpufreq_sysctl interface ********************/ +static int +cpufreq_procctl(ctl_table *ctl, int write, struct file *filp, + void *buffer, size_t *lenp) +{ + char buf[16], *p; + int cpu = (int) ctl->extra1; + int len, left = *lenp; + + if (!left || (filp->f_pos && !write) || !cpu_online(cpu)) { + *lenp = 0; + return 0; + } + + if (write) { + unsigned int freq; + + len = left; + if (left > sizeof(buf)) + left = sizeof(buf); + if (copy_from_user(buf, buffer, left)) + return -EFAULT; + buf[sizeof(buf) - 1] = '\0'; + + freq = simple_strtoul(buf, &p, 0); + cpufreq_set(freq, cpu); + } else { + len = sprintf(buf, "%d\n", cpufreq_get(cpu)); + if (len > left) + len = left; + if (copy_to_user(buffer, buf, len)) + return -EFAULT; + } + + *lenp = len; + filp->f_pos += len; + return 0; +} + +static int +cpufreq_sysctl(ctl_table *table, int *name, int nlen, + void *oldval, size_t *oldlenp, + void *newval, size_t newlen, void **context) +{ + int cpu = (int) table->extra1; + + if (!cpu_online(cpu)) + return -EINVAL; + + if (oldval && oldlenp) { + size_t oldlen; + + if (get_user(oldlen, oldlenp)) + return -EFAULT; + + if (oldlen != sizeof(unsigned int)) + return -EINVAL; + + if (put_user(cpufreq_get(cpu), (unsigned int *)oldval) || + put_user(sizeof(unsigned int), oldlenp)) + return -EFAULT; + } + if (newval && newlen) { + unsigned int freq; + + if (newlen != sizeof(unsigned int)) + return -EINVAL; + + if (get_user(freq, (unsigned int *)newval)) + return -EFAULT; + + cpufreq_set(freq, cpu); + } + return 1; +} + +/* ctl_table ctl_cpu_vars_{0,1,...,(NR_CPUS-1)} */ +/* due to NR_CPUS tweaking, a lot of if/endifs are required, sorry */ + CTL_TABLE_CPU_VARS(0); +#if NR_CPUS > 1 + CTL_TABLE_CPU_VARS(1); +#endif +#if NR_CPUS > 2 + CTL_TABLE_CPU_VARS(2); +#endif +#if NR_CPUS > 3 + CTL_TABLE_CPU_VARS(3); +#endif +#if NR_CPUS > 4 + CTL_TABLE_CPU_VARS(4); +#endif +#if NR_CPUS > 5 + CTL_TABLE_CPU_VARS(5); +#endif +#if NR_CPUS > 6 + CTL_TABLE_CPU_VARS(6); +#endif +#if NR_CPUS > 7 + CTL_TABLE_CPU_VARS(7); +#endif +#if NR_CPUS > 8 + CTL_TABLE_CPU_VARS(8); +#endif +#if NR_CPUS > 9 + CTL_TABLE_CPU_VARS(9); +#endif +#if NR_CPUS > 10 + CTL_TABLE_CPU_VARS(10); +#endif +#if NR_CPUS > 11 + CTL_TABLE_CPU_VARS(11); +#endif +#if NR_CPUS > 12 + CTL_TABLE_CPU_VARS(12); +#endif +#if NR_CPUS > 13 + CTL_TABLE_CPU_VARS(13); +#endif +#if NR_CPUS > 14 + CTL_TABLE_CPU_VARS(14); +#endif +#if NR_CPUS > 15 + CTL_TABLE_CPU_VARS(15); +#endif +#if NR_CPUS > 16 + CTL_TABLE_CPU_VARS(16); +#endif +#if NR_CPUS > 17 + CTL_TABLE_CPU_VARS(17); +#endif +#if NR_CPUS > 18 + CTL_TABLE_CPU_VARS(18); +#endif +#if NR_CPUS > 19 + CTL_TABLE_CPU_VARS(19); +#endif +#if NR_CPUS > 20 + CTL_TABLE_CPU_VARS(20); +#endif +#if NR_CPUS > 21 + CTL_TABLE_CPU_VARS(21); +#endif +#if NR_CPUS > 22 + CTL_TABLE_CPU_VARS(22); +#endif +#if NR_CPUS > 23 + CTL_TABLE_CPU_VARS(23); +#endif +#if NR_CPUS > 24 + CTL_TABLE_CPU_VARS(24); +#endif +#if NR_CPUS > 25 + CTL_TABLE_CPU_VARS(25); +#endif +#if NR_CPUS > 26 + CTL_TABLE_CPU_VARS(26); +#endif +#if NR_CPUS > 27 + CTL_TABLE_CPU_VARS(27); +#endif +#if NR_CPUS > 28 + CTL_TABLE_CPU_VARS(28); +#endif +#if NR_CPUS > 29 + CTL_TABLE_CPU_VARS(29); +#endif +#if NR_CPUS > 30 + CTL_TABLE_CPU_VARS(30); +#endif +#if NR_CPUS > 31 + CTL_TABLE_CPU_VARS(31); +#endif +#if NR_CPUS > 32 +#error please extend CPU enumeration +#endif + +/* due to NR_CPUS tweaking, a lot of if/endifs are required, sorry */ +static ctl_table ctl_cpu_table[NR_CPUS + 1] = { + CPU_ENUM(0), +#if NR_CPUS > 1 + CPU_ENUM(1), +#endif +#if NR_CPUS > 2 + CPU_ENUM(2), +#endif +#if NR_CPUS > 3 + CPU_ENUM(3), +#endif +#if NR_CPUS > 4 + CPU_ENUM(4), +#endif +#if NR_CPUS > 5 + CPU_ENUM(5), +#endif +#if NR_CPUS > 6 + CPU_ENUM(6), +#endif +#if NR_CPUS > 7 + CPU_ENUM(7), +#endif +#if NR_CPUS > 8 + CPU_ENUM(8), +#endif +#if NR_CPUS > 9 + CPU_ENUM(9), +#endif +#if NR_CPUS > 10 + CPU_ENUM(10), +#endif +#if NR_CPUS > 11 + CPU_ENUM(11), +#endif +#if NR_CPUS > 12 + CPU_ENUM(12), +#endif +#if NR_CPUS > 13 + CPU_ENUM(13), +#endif +#if NR_CPUS > 14 + CPU_ENUM(14), +#endif +#if NR_CPUS > 15 + CPU_ENUM(15), +#endif +#if NR_CPUS > 16 + CPU_ENUM(16), +#endif +#if NR_CPUS > 17 + CPU_ENUM(17), +#endif +#if NR_CPUS > 18 + CPU_ENUM(18), +#endif +#if NR_CPUS > 19 + CPU_ENUM(19), +#endif +#if NR_CPUS > 20 + CPU_ENUM(20), +#endif +#if NR_CPUS > 21 + CPU_ENUM(21), +#endif +#if NR_CPUS > 22 + CPU_ENUM(22), +#endif +#if NR_CPUS > 23 + CPU_ENUM(23), +#endif +#if NR_CPUS > 24 + CPU_ENUM(24), +#endif +#if NR_CPUS > 25 + CPU_ENUM(25), +#endif +#if NR_CPUS > 26 + CPU_ENUM(26), +#endif +#if NR_CPUS > 27 + CPU_ENUM(27), +#endif +#if NR_CPUS > 28 + CPU_ENUM(28), +#endif +#if NR_CPUS > 29 + CPU_ENUM(29), +#endif +#if NR_CPUS > 30 + CPU_ENUM(30), +#endif +#if NR_CPUS > 31 + CPU_ENUM(31), +#endif +#if NR_CPUS > 32 +#error please extend CPU enumeration +#endif + { + .ctl_name = 0, + } +}; + +static ctl_table ctl_cpu[2] = { + { + .ctl_name = CTL_CPU, + .procname = "cpu", + .mode = 0555, + .child = ctl_cpu_table, + }, + { + .ctl_name = 0, + } +}; + +struct ctl_table_header *cpufreq_sysctl_table; + +static inline void cpufreq_sysctl_init(void) +{ + cpufreq_sysctl_table = register_sysctl_table(ctl_cpu, 0); +} + +static inline void cpufreq_sysctl_exit(void) +{ + unregister_sysctl_table(cpufreq_sysctl_table); +} + +#else +#define cpufreq_sysctl_init() do {} while(0) +#define cpufreq_sysctl_exit() do {} while(0) +#endif /* CONFIG_CPU_FREQ_24API */ + + +/************************** sysfs interface ************************/ +static inline int to_cpu_nr (struct device *dev) +{ + struct sys_device * cpu_sys_dev = container_of(dev, struct sys_device, dev); + return (cpu_sys_dev->id); +} + +static ssize_t show_speed (struct device *dev, char *buf) +{ + unsigned int cpu = to_cpu_nr(dev); + + return sprintf (buf, "%u\n", cpu_cur_freq[cpu]); +} + +static ssize_t +store_speed (struct device *dev, const char *buf, size_t count) +{ + unsigned int cpu = to_cpu_nr(dev); + unsigned int freq = 0; + unsigned int ret; + + ret = sscanf (buf, "%u", &freq); + if (ret != 1) + return -EINVAL; + + cpufreq_set(freq, cpu); + + return count; +} + +static DEVICE_ATTR(scaling_setspeed, (S_IRUGO | S_IWUSR), show_speed, store_speed); + + +static int cpufreq_governor_userspace(struct cpufreq_policy *policy, + unsigned int event) +{ + unsigned int cpu = policy->cpu; + switch (event) { + case CPUFREQ_GOV_START: + if ((!cpu_online(cpu)) || (!try_module_get(THIS_MODULE)) || + !policy->cur) + return -EINVAL; + down(&userspace_sem); + cpu_is_managed[cpu] = 1; + cpu_min_freq[cpu] = policy->min; + cpu_max_freq[cpu] = policy->max; + cpu_cur_freq[cpu] = policy->cur; + device_create_file (policy->intf.dev, &dev_attr_scaling_setspeed); + memcpy (¤t_policy[cpu], policy, sizeof(struct cpufreq_policy)); + up(&userspace_sem); + break; + case CPUFREQ_GOV_STOP: + down(&userspace_sem); + cpu_is_managed[cpu] = 0; + cpu_min_freq[cpu] = 0; + cpu_max_freq[cpu] = 0; + device_remove_file (policy->intf.dev, &dev_attr_scaling_setspeed); + up(&userspace_sem); + module_put(THIS_MODULE); + break; + case CPUFREQ_GOV_LIMITS: + down(&userspace_sem); + cpu_min_freq[cpu] = policy->min; + cpu_max_freq[cpu] = policy->max; + if (policy->max < cpu_cur_freq[cpu]) + cpufreq_driver_target(¤t_policy[cpu], policy->max, + CPUFREQ_RELATION_H); + else if (policy->min > cpu_cur_freq[cpu]) + cpufreq_driver_target(¤t_policy[cpu], policy->min, + CPUFREQ_RELATION_L); + memcpy (¤t_policy[cpu], policy, sizeof(struct cpufreq_policy)); + up(&userspace_sem); + break; + } + return 0; +} + +/* on ARM SA1100 we need to rely on the values of cpufreq_get() - because + * of this, cpu_cur_freq[] needs to be set early. + */ +#if defined(CONFIG_ARM) && defined(CONFIG_ARCH_SA1100) +extern unsigned int sa11x0_getspeed(void); + +static void cpufreq_sa11x0_compat(void) +{ + cpu_cur_freq[0] = sa11x0_getspeed(); +} +#else +#define cpufreq_sa11x0_compat() do {} while(0) +#endif + + +static struct cpufreq_governor cpufreq_gov_userspace = { + .name = "userspace", + .governor = cpufreq_governor_userspace, + .owner = THIS_MODULE, +}; +EXPORT_SYMBOL(cpufreq_gov_userspace); + +static int already_init = 0; + +int cpufreq_gov_userspace_init(void) +{ + if (!already_init) { + down(&userspace_sem); + cpufreq_sa11x0_compat(); + cpufreq_sysctl_init(); + cpufreq_register_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); + already_init = 1; + up(&userspace_sem); + } + return cpufreq_register_governor(&cpufreq_gov_userspace); +} +EXPORT_SYMBOL(cpufreq_gov_userspace_init); + + +static void __exit cpufreq_gov_userspace_exit(void) +{ + cpufreq_unregister_governor(&cpufreq_gov_userspace); + cpufreq_unregister_notifier(&userspace_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); + cpufreq_sysctl_exit(); +} + + +MODULE_AUTHOR ("Dominik Brodowski , Russell King "); +MODULE_DESCRIPTION ("CPUfreq policy governor 'userspace'"); +MODULE_LICENSE ("GPL"); + +module_init(cpufreq_gov_userspace_init); +module_exit(cpufreq_gov_userspace_exit); diff -Nru a/drivers/hotplug/Makefile b/drivers/hotplug/Makefile --- a/drivers/hotplug/Makefile Tue Mar 4 19:30:11 2003 +++ b/drivers/hotplug/Makefile Tue Mar 4 19:30:11 2003 @@ -18,7 +18,7 @@ cpqphp-objs := cpqphp_core.o \ cpqphp_ctrl.o \ - cpqphp_proc.o \ + cpqphp_sysfs.o \ cpqphp_pci.o ibmphp-objs := ibmphp_core.o \ diff -Nru a/drivers/hotplug/acpiphp_glue.c b/drivers/hotplug/acpiphp_glue.c --- a/drivers/hotplug/acpiphp_glue.c Tue Mar 4 19:30:05 2003 +++ b/drivers/hotplug/acpiphp_glue.c Tue Mar 4 19:30:05 2003 @@ -229,136 +229,55 @@ /* decode ACPI _CRS data and convert into our internal resource list * TBD: _TRA, etc. */ -static void -decode_acpi_resource (struct acpi_resource *resource, struct acpiphp_bridge *bridge) +static acpi_status +decode_acpi_resource (struct acpi_resource *resource, void *context) { - struct acpi_resource_address16 *address16_data; - struct acpi_resource_address32 *address32_data; - struct acpi_resource_address64 *address64_data; + struct acpiphp_bridge *bridge = (struct acpiphp_bridge *) context; + struct acpi_resource_address64 address; struct pci_resource *res; - u32 resource_type, producer_consumer, address_length; - u64 min_address_range, max_address_range; - u16 cache_attribute = 0; - - int done = 0, found; - - /* shut up gcc */ - resource_type = producer_consumer = address_length = 0; - min_address_range = max_address_range = 0; - - while (!done) { - found = 0; - - switch (resource->id) { - case ACPI_RSTYPE_ADDRESS16: - address16_data = (struct acpi_resource_address16 *)&resource->data; - resource_type = address16_data->resource_type; - producer_consumer = address16_data->producer_consumer; - min_address_range = address16_data->min_address_range; - max_address_range = address16_data->max_address_range; - address_length = address16_data->address_length; - if (resource_type == ACPI_MEMORY_RANGE) - cache_attribute = address16_data->attribute.memory.cache_attribute; - found = 1; - break; + if (resource->id != ACPI_RSTYPE_ADDRESS16 && + resource->id != ACPI_RSTYPE_ADDRESS32 && + resource->id != ACPI_RSTYPE_ADDRESS64) + return AE_OK; - case ACPI_RSTYPE_ADDRESS32: - address32_data = (struct acpi_resource_address32 *)&resource->data; - resource_type = address32_data->resource_type; - producer_consumer = address32_data->producer_consumer; - min_address_range = address32_data->min_address_range; - max_address_range = address32_data->max_address_range; - address_length = address32_data->address_length; - if (resource_type == ACPI_MEMORY_RANGE) - cache_attribute = address32_data->attribute.memory.cache_attribute; - found = 1; - break; + acpi_resource_to_address64(resource, &address); - case ACPI_RSTYPE_ADDRESS64: - address64_data = (struct acpi_resource_address64 *)&resource->data; - resource_type = address64_data->resource_type; - producer_consumer = address64_data->producer_consumer; - min_address_range = address64_data->min_address_range; - max_address_range = address64_data->max_address_range; - address_length = address64_data->address_length; - if (resource_type == ACPI_MEMORY_RANGE) - cache_attribute = address64_data->attribute.memory.cache_attribute; - found = 1; - break; + if (address.producer_consumer == ACPI_PRODUCER && address.address_length > 0) { + dbg("resource type: %d: 0x%llx - 0x%llx\n", address.resource_type, address.min_address_range, address.max_address_range); + res = acpiphp_make_resource(address.min_address_range, + address.address_length); + if (!res) { + err("out of memory\n"); + return AE_OK; + } - case ACPI_RSTYPE_END_TAG: - done = 1; + switch (address.resource_type) { + case ACPI_MEMORY_RANGE: + if (address.attribute.memory.cache_attribute == ACPI_PREFETCHABLE_MEMORY) { + res->next = bridge->p_mem_head; + bridge->p_mem_head = res; + } else { + res->next = bridge->mem_head; + bridge->mem_head = res; + } + break; + case ACPI_IO_RANGE: + res->next = bridge->io_head; + bridge->io_head = res; + break; + case ACPI_BUS_NUMBER_RANGE: + res->next = bridge->bus_head; + bridge->bus_head = res; break; - default: - /* ignore */ + /* invalid type */ + kfree(res); break; } - - resource = (struct acpi_resource *)((char*)resource + resource->length); - - if (found && producer_consumer == ACPI_PRODUCER && address_length > 0) { - switch (resource_type) { - case ACPI_MEMORY_RANGE: - if (cache_attribute == ACPI_PREFETCHABLE_MEMORY) { - dbg("resource type: prefetchable memory 0x%x - 0x%x\n", (u32)min_address_range, (u32)max_address_range); - res = acpiphp_make_resource(min_address_range, - address_length); - if (!res) { - err("out of memory\n"); - return; - } - res->next = bridge->p_mem_head; - bridge->p_mem_head = res; - } else { - dbg("resource type: memory 0x%x - 0x%x\n", (u32)min_address_range, (u32)max_address_range); - res = acpiphp_make_resource(min_address_range, - address_length); - if (!res) { - err("out of memory\n"); - return; - } - res->next = bridge->mem_head; - bridge->mem_head = res; - } - break; - case ACPI_IO_RANGE: - dbg("resource type: io 0x%x - 0x%x\n", (u32)min_address_range, (u32)max_address_range); - res = acpiphp_make_resource(min_address_range, - address_length); - if (!res) { - err("out of memory\n"); - return; - } - res->next = bridge->io_head; - bridge->io_head = res; - break; - case ACPI_BUS_NUMBER_RANGE: - dbg("resource type: bus number %d - %d\n", (u32)min_address_range, (u32)max_address_range); - res = acpiphp_make_resource(min_address_range, - address_length); - if (!res) { - err("out of memory\n"); - return; - } - res->next = bridge->bus_head; - bridge->bus_head = res; - break; - default: - /* invalid type */ - break; - } - } } - acpiphp_resource_sort_and_combine(&bridge->io_head); - acpiphp_resource_sort_and_combine(&bridge->mem_head); - acpiphp_resource_sort_and_combine(&bridge->p_mem_head); - acpiphp_resource_sort_and_combine(&bridge->bus_head); - - dbg("ACPI _CRS resource:\n"); - acpiphp_dump_resource(bridge); + return AE_OK; } @@ -476,9 +395,6 @@ static void add_host_bridge (acpi_handle *handle, int seg, int bus) { acpi_status status; - struct acpi_buffer buffer = { .length = ACPI_ALLOCATE_BUFFER, - .pointer = NULL}; - struct acpiphp_bridge *bridge; bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); @@ -501,7 +417,8 @@ /* decode resources */ - status = acpi_get_current_resources(handle, &buffer); + status = acpi_walk_resources(handle, METHOD_NAME__CRS, + decode_acpi_resource, bridge); if (ACPI_FAILURE(status)) { err("failed to decode bridge resources\n"); @@ -509,8 +426,13 @@ return; } - decode_acpi_resource(buffer.pointer, bridge); - kfree(buffer.pointer); + acpiphp_resource_sort_and_combine(&bridge->io_head); + acpiphp_resource_sort_and_combine(&bridge->mem_head); + acpiphp_resource_sort_and_combine(&bridge->p_mem_head); + acpiphp_resource_sort_and_combine(&bridge->bus_head); + + dbg("ACPI _CRS resource:\n"); + acpiphp_dump_resource(bridge); if (bridge->bus_head) { bridge->bus = bridge->bus_head->base; @@ -1357,7 +1279,7 @@ if (sta != ACPI_STA_ALL) { retval = acpiphp_disable_slot(slot); if (retval) { - err("Error occured in enabling\n"); + err("Error occurred in enabling\n"); up(&slot->crit_sect); goto err_exit; } @@ -1368,7 +1290,7 @@ if (sta == ACPI_STA_ALL) { retval = acpiphp_enable_slot(slot); if (retval) { - err("Error occured in enabling\n"); + err("Error occurred in enabling\n"); up(&slot->crit_sect); goto err_exit; } diff -Nru a/drivers/hotplug/acpiphp_pci.c b/drivers/hotplug/acpiphp_pci.c --- a/drivers/hotplug/acpiphp_pci.c Tue Mar 4 19:30:03 2003 +++ b/drivers/hotplug/acpiphp_pci.c Tue Mar 4 19:30:03 2003 @@ -194,133 +194,6 @@ return 0; } - -/* enable pci_dev */ -static int configure_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct acpiphp_func *func; - struct acpiphp_bridge *bridge; - struct pci_dev *dev; - - func = (struct acpiphp_func *)wrapped_dev->data; - bridge = (struct acpiphp_bridge *)wrapped_bus->data; - dev = wrapped_dev->dev; - - /* TBD: support PCI-to-PCI bridge case */ - if (!func || !bridge) - return 0; - - //pci_proc_attach_device(dev); - //pci_announce_device_to_drivers(dev); - info("Device %s configured\n", dev->slot_name); - - return 0; -} - - -static int is_pci_dev_in_use (struct pci_dev* dev) -{ - /* - * dev->driver will be set if the device is in use by a new-style - * driver -- otherwise, check the device's regions to see if any - * driver has claimed them - */ - - int i, inuse=0; - - if (dev->driver) return 1; //assume driver feels responsible - - for (i = 0; !dev->driver && !inuse && (i < 6); i++) { - if (!pci_resource_start(dev, i)) - continue; - - if (pci_resource_flags(dev, i) & IORESOURCE_IO) - inuse = check_region(pci_resource_start(dev, i), - pci_resource_len(dev, i)); - else if (pci_resource_flags(dev, i) & IORESOURCE_MEM) - inuse = check_mem_region(pci_resource_start(dev, i), - pci_resource_len(dev, i)); - } - - return inuse; -} - - -static int pci_hp_remove_device (struct pci_dev *dev) -{ - if (is_pci_dev_in_use(dev)) { - err("***Cannot safely power down device -- " - "it appears to be in use***\n"); - return -EBUSY; - } - pci_remove_device(dev); - return 0; -} - - -/* remove device driver */ -static int unconfigure_pci_dev_driver (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev *dev = wrapped_dev->dev; - - dbg("attempting removal of driver for device %s\n", dev->slot_name); - - /* Now, remove the Linux Driver Representation */ - if (dev->driver) { - if (dev->driver->remove) { - dev->driver->remove(dev); - dbg("driver was properly removed\n"); - } - dev->driver = NULL; - } - - return is_pci_dev_in_use(dev); -} - - -/* remove pci_dev itself from system */ -static int unconfigure_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev *dev = wrapped_dev->dev; - - /* Now, remove the Linux Representation */ - if (dev) { - if (pci_hp_remove_device(dev) == 0) { - info("Device %s removed\n", dev->slot_name); - kfree(dev); /* Now, remove */ - } else { - return -1; /* problems while freeing, abort visitation */ - } - } - - return 0; -} - - -/* remove pci_bus itself from system */ -static int unconfigure_pci_bus (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev) -{ - struct pci_bus *bus = wrapped_bus->bus; - -#ifdef CONFIG_PROC_FS - /* Now, remove the Linux Representation */ - if (bus->procdir) { - pci_proc_detach_bus(bus); - } -#endif - /* the cleanup code should live in the kernel ... */ - bus->self->subordinate = NULL; - /* unlink from parent bus */ - list_del(&bus->node); - - /* Now, remove */ - if (bus) - kfree(bus); - - return 0; -} - - /* detect_used_resource - subtract resource under dev from bridge */ static int detect_used_resource (struct acpiphp_bridge *bridge, struct pci_dev *dev) { @@ -592,22 +465,6 @@ return retval; } - -/* for pci_visit_dev() */ -static struct pci_visit configure_functions = { - .post_visit_pci_dev = configure_pci_dev -}; - -static struct pci_visit unconfigure_functions_phase1 = { - .post_visit_pci_dev = unconfigure_pci_dev_driver -}; - -static struct pci_visit unconfigure_functions_phase2 = { - .post_visit_pci_bus = unconfigure_pci_bus, - .post_visit_pci_dev = unconfigure_pci_dev -}; - - /** * acpiphp_configure_function - configure PCI function * @func: function to be configured @@ -618,33 +475,10 @@ */ int acpiphp_configure_function (struct acpiphp_func *func) { - int retval = 0; - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; - struct acpiphp_bridge *bridge; - - /* if pci_dev is NULL, ignore it */ - if (!func->pci_dev) - goto err_exit; - - bridge = func->slot->bridge; - - memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped)); - memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped)); - wrapped_dev.dev = func->pci_dev; - wrapped_dev.data = func; - wrapped_bus.bus = bridge->pci_bus; - wrapped_bus.data = bridge; - - retval = pci_visit_dev(&configure_functions, &wrapped_dev, &wrapped_bus); - if (retval) - goto err_exit; - - err_exit: - return retval; + /* all handled by the pci core now */ + return 0; } - /** * acpiphp_unconfigure_function - unconfigure PCI function * @func: function to be unconfigured @@ -653,28 +487,13 @@ int acpiphp_unconfigure_function (struct acpiphp_func *func) { struct acpiphp_bridge *bridge; - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; int retval = 0; /* if pci_dev is NULL, ignore it */ if (!func->pci_dev) goto err_exit; - memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped)); - memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped)); - wrapped_dev.dev = func->pci_dev; - //wrapped_dev.data = func; - wrapped_bus.bus = func->slot->bridge->pci_bus; - //wrapped_bus.data = func->slot->bridge; - - retval = pci_visit_dev(&unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus); - if (retval) - goto err_exit; - - retval = pci_visit_dev(&unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus); - if (retval) - goto err_exit; + pci_remove_bus_device(func->pci_dev); /* free all resources */ bridge = func->slot->bridge; diff -Nru a/drivers/hotplug/cpci_hotplug_pci.c b/drivers/hotplug/cpci_hotplug_pci.c --- a/drivers/hotplug/cpci_hotplug_pci.c Tue Mar 4 19:30:11 2003 +++ b/drivers/hotplug/cpci_hotplug_pci.c Tue Mar 4 19:30:11 2003 @@ -483,29 +483,6 @@ return 0; } -static int unconfigure_visit_pci_dev_phase1(struct pci_dev_wrapped *wrapped_dev, - struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev *dev = wrapped_dev->dev; - - dbg("%s - enter", __FUNCTION__); - - dbg("attempting removal of driver for device %02x:%02x.%x", - dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); - - /* Now, remove the Linux Driver representation */ - if(dev->driver) { - dbg("device is attached to a driver"); - if(dev->driver->remove) { - dev->driver->remove(dev); - dbg("driver was removed"); - } - dev->driver = NULL; - } - dbg("%s - exit", __FUNCTION__); - return pci_is_dev_in_use(dev); -} - static int unconfigure_visit_pci_dev_phase2(struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) { @@ -577,10 +554,6 @@ .visit_pci_dev = configure_visit_pci_dev, }; -static struct pci_visit unconfigure_functions_phase1 = { - .post_visit_pci_dev = unconfigure_visit_pci_dev_phase1 -}; - static struct pci_visit unconfigure_functions_phase2 = { .post_visit_pci_bus = unconfigure_visit_pci_bus_phase2, .post_visit_pci_dev = unconfigure_visit_pci_dev_phase2 @@ -668,13 +641,6 @@ if(dev) { wrapped_dev.dev = dev; wrapped_bus.bus = dev->bus; - dbg("%s - unconfigure phase 1", __FUNCTION__); - rc = pci_visit_dev(&unconfigure_functions_phase1, - &wrapped_dev, &wrapped_bus); - if(rc) { - break; - } - dbg("%s - unconfigure phase 2", __FUNCTION__); rc = pci_visit_dev(&unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus); diff -Nru a/drivers/hotplug/cpqphp.h b/drivers/hotplug/cpqphp.h --- a/drivers/hotplug/cpqphp.h Tue Mar 4 19:30:13 2003 +++ b/drivers/hotplug/cpqphp.h Tue Mar 4 19:30:13 2003 @@ -403,31 +403,8 @@ #define msg_button_ignore "PCI slot #%d - button press ignored. (action in progress...)\n" -/* Proc functions for the hotplug controller info */ -#ifdef CONFIG_PROC_FS -extern int cpqhp_proc_init_ctrl (void); -extern int cpqhp_proc_destroy_ctrl (void); -extern int cpqhp_proc_create_ctrl (struct controller *ctrl); -extern int cpqhp_proc_remove_ctrl (struct controller *ctrl); -#else -static inline int cpqhp_proc_init_ctrl (void) -{ - return 0; -} -static inline int cpqhp_proc_destroy_ctrl (void) -{ - return 0; -} -static inline int cpqhp_proc_create_ctrl (struct controller *ctrl) -{ - return 0; -} -static inline int cpqhp_proc_remove_ctrl (struct controller *ctrl) -{ - return 0; -} -#endif - +/* sysfs functions for the hotplug controller info */ +extern void cpqhp_create_ctrl_files (struct controller *ctrl); /* controller functions */ extern void cpqhp_pushbutton_thread (unsigned long event_pointer); diff -Nru a/drivers/hotplug/cpqphp_core.c b/drivers/hotplug/cpqphp_core.c --- a/drivers/hotplug/cpqphp_core.c Tue Mar 4 19:30:03 2003 +++ b/drivers/hotplug/cpqphp_core.c Tue Mar 4 19:30:03 2003 @@ -1038,6 +1038,7 @@ dbg (" pcix_support %s\n", ctrl->pcix_support == 0 ? "not supported" : "supported"); ctrl->pci_dev = pdev; + pci_set_drvdata(pdev, ctrl); /* make our own copy of the pci bus structure, as we like tweaking it a lot */ ctrl->pci_bus = kmalloc (sizeof (*ctrl->pci_bus), GFP_KERNEL); @@ -1231,11 +1232,7 @@ // Done with exclusive hardware access up(&ctrl->crit_sect); - rc = cpqhp_proc_create_ctrl (ctrl); - if (rc) { - err("cpqhp_proc_create_ctrl failed\n"); - goto err_free_irq; - } + cpqhp_create_ctrl_files (ctrl); return 0; @@ -1309,10 +1306,6 @@ goto error; } - retval = cpqhp_proc_init_ctrl(); - if (retval) - goto error; - initialized = 1; return retval; @@ -1343,8 +1336,6 @@ ctrl = cpqhp_ctrl_list; while (ctrl) { - cpqhp_proc_remove_ctrl (ctrl); - if (ctrl->hpc_reg) { u16 misc; rc = read_slot_enable (ctrl); @@ -1431,8 +1422,6 @@ } } - remove_proc_entry("hpc", 0); - // Stop the notification mechanism cpqhp_event_stop_thread(); @@ -1490,9 +1479,6 @@ static void __exit cpqhpc_cleanup(void) { - dbg("cleaning up proc entries\n"); - cpqhp_proc_destroy_ctrl(); - dbg("unload_cpqphpd()\n"); unload_cpqphpd(); diff -Nru a/drivers/hotplug/cpqphp_pci.c b/drivers/hotplug/cpqphp_pci.c --- a/drivers/hotplug/cpqphp_pci.c Tue Mar 4 19:30:13 2003 +++ b/drivers/hotplug/cpqphp_pci.c Tue Mar 4 19:30:13 2003 @@ -44,48 +44,6 @@ static u16 unused_IRQ; - -static int is_pci_dev_in_use(struct pci_dev* dev) -{ - /* - * dev->driver will be set if the device is in use by a new-style - * driver -- otherwise, check the device's regions to see if any - * driver has claimed them - */ - - int i, inuse=0; - - if (dev->driver) return 1; //assume driver feels responsible - - for (i = 0; !dev->driver && !inuse && (i < 6); i++) { - if (!pci_resource_start(dev, i)) - continue; - - if (pci_resource_flags(dev, i) & IORESOURCE_IO) - inuse = check_region(pci_resource_start(dev, i), - pci_resource_len(dev, i)); - else if (pci_resource_flags(dev, i) & IORESOURCE_MEM) - inuse = check_mem_region(pci_resource_start(dev, i), - pci_resource_len(dev, i)); - } - - return inuse; - -} - - -static int pci_hp_remove_device(struct pci_dev *dev) -{ - if (is_pci_dev_in_use(dev)) { - err("***Cannot safely power down device -- " - "it appears to be in use***\n"); - return -EBUSY; - } - pci_remove_device(dev); - return 0; -} - - /* * detect_HRT_floating_pointer * @@ -122,144 +80,14 @@ return fp; } -static int configure_visit_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_bus* bus = wrapped_bus->bus; - struct pci_dev* dev = wrapped_dev->dev; - struct pci_func *temp_func; - int i=0; - - //We need to fix up the hotplug function representation with the linux representation - do { - temp_func = cpqhp_slot_find(dev->bus->number, dev->devfn >> 3, i++); - } while (temp_func && (temp_func->function != (dev->devfn & 0x07))); - - if (temp_func) { - temp_func->pci_dev = dev; - } else { - //We did not even find a hotplug rep of the function, create it - //This code might be taken out if we can guarantee the creation of functions - //in parallel (hotplug and Linux at the same time). - dbg("@@@@@@@@@@@ cpqhp_slot_create in %s\n", __FUNCTION__); - temp_func = cpqhp_slot_create(bus->number); - if (temp_func == NULL) - return -ENOMEM; - temp_func->pci_dev = dev; - } - - //Create /proc/bus/pci proc entry for this device and bus device is on - //Notify the drivers of the change - if (temp_func->pci_dev) { -// pci_insert_device (temp_func->pci_dev, bus); -// pci_proc_attach_device(temp_func->pci_dev); -// pci_announce_device_to_drivers(temp_func->pci_dev); - } - - return 0; -} - - -static int unconfigure_visit_pci_dev_phase2 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev* dev = wrapped_dev->dev; - - struct pci_func *temp_func; - int i=0; - - //We need to remove the hotplug function representation with the linux representation - do { - temp_func = cpqhp_slot_find(dev->bus->number, dev->devfn >> 3, i++); - if (temp_func) { - dbg("temp_func->function = %d\n", temp_func->function); - } - } while (temp_func && (temp_func->function != (dev->devfn & 0x07))); - - //Now, remove the Linux Representation - if (dev) { - if (pci_hp_remove_device(dev) == 0) { - kfree(dev); //Now, remove - } else { - return -1; // problems while freeing, abort visitation - } - } - - if (temp_func) { - temp_func->pci_dev = NULL; - } else { - dbg("No pci_func representation for bus, devfn = %d, %x\n", dev->bus->number, dev->devfn); - } - - return 0; -} - - -static int unconfigure_visit_pci_bus_phase2 (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev) -{ - struct pci_bus* bus = wrapped_bus->bus; - - //The cleanup code for proc entries regarding buses should be in the kernel... - if (bus->procdir) - dbg("detach_pci_bus %s\n", bus->procdir->name); - pci_proc_detach_bus(bus); - // The cleanup code should live in the kernel... - bus->self->subordinate = NULL; - // unlink from parent bus - list_del(&bus->node); - - // Now, remove - if (bus) - kfree(bus); - - return 0; -} - - -static int unconfigure_visit_pci_dev_phase1 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev* dev = wrapped_dev->dev; - - dbg("attempting removal of driver for device (%x, %x, %x)\n", dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); - //Now, remove the Linux Driver Representation - if (dev->driver) { - if (dev->driver->remove) { - dev->driver->remove(dev); - dbg("driver was properly removed\n"); - } - dev->driver = NULL; - } - - return is_pci_dev_in_use(dev); -} - - -static struct pci_visit configure_functions = { - .visit_pci_dev = configure_visit_pci_dev, -}; - - -static struct pci_visit unconfigure_functions_phase1 = { - .post_visit_pci_dev = unconfigure_visit_pci_dev_phase1 -}; - -static struct pci_visit unconfigure_functions_phase2 = { - .post_visit_pci_bus = unconfigure_visit_pci_bus_phase2, - .post_visit_pci_dev = unconfigure_visit_pci_dev_phase2 -}; - int cpqhp_configure_device (struct controller* ctrl, struct pci_func* func) { unsigned char bus; struct pci_dev dev0; struct pci_bus *child; - struct pci_dev* temp; int rc = 0; - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; - memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped)); - memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped)); - memset(&dev0, 0, sizeof(struct pci_dev)); if (func->pci_dev == NULL) @@ -287,44 +115,22 @@ } - temp = func->pci_dev; - - if (temp) { - wrapped_dev.dev = temp; - wrapped_bus.bus = temp->bus; - rc = pci_visit_dev(&configure_functions, &wrapped_dev, &wrapped_bus); - } return rc; } int cpqhp_unconfigure_device(struct pci_func* func) { - int rc = 0; int j; - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; - memset(&wrapped_dev, 0, sizeof(struct pci_dev_wrapped)); - memset(&wrapped_bus, 0, sizeof(struct pci_bus_wrapped)); - dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus, func->device, func->function); for (j=0; j<8 ; j++) { struct pci_dev* temp = pci_find_slot(func->bus, (func->device << 3) | j); - if (temp) { - wrapped_dev.dev = temp; - wrapped_bus.bus = temp->bus; - rc = pci_visit_dev(&unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus); - if (rc) - break; - - rc = pci_visit_dev(&unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus); - if (rc) - break; - } + if (temp) + pci_remove_bus_device(temp); } - return rc; + return 0; } static int PCI_RefinedAccessConfig(struct pci_bus *bus, unsigned int devfn, u8 offset, u32 *value) diff -Nru a/drivers/hotplug/cpqphp_proc.c b/drivers/hotplug/cpqphp_proc.c --- a/drivers/hotplug/cpqphp_proc.c Tue Mar 4 19:30:13 2003 +++ /dev/null Wed Dec 31 16:00:00 1969 @@ -1,197 +0,0 @@ -/* - * Compaq Hot Plug Controller Driver - * - * Copyright (c) 1995,2001 Compaq Computer Corporation - * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com) - * Copyright (c) 2001 IBM Corp. - * - * All rights reserved. - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or (at - * your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or - * NON INFRINGEMENT. See the GNU General Public License for more - * details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - * - * Send feedback to - * - */ - -#include -#include -#include -#include -#include -#include -#include -#include "cpqphp.h" - - - -static struct proc_dir_entry *ctrl_proc_root; - -/* A few routines that create proc entries for the hot plug controller */ - -static int read_ctrl (char *buf, char **start, off_t offset, int len, int *eof, void *data) -{ - struct controller *ctrl = (struct controller *)data; - char * out = buf; - int index; - struct pci_resource *res; - - if (offset > 0) return 0; /* no partial requests */ - len = 0; - *eof = 1; - - out += sprintf(out, "hot plug ctrl Info Page\n"); - out += sprintf(out, "bus = %d, device = %d, function = %d\n", - ctrl->bus, PCI_SLOT(ctrl->pci_dev->devfn), - PCI_FUNC(ctrl->pci_dev->devfn)); - out += sprintf(out, "Free resources: memory\n"); - index = 11; - res = ctrl->mem_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "Free resources: prefetchable memory\n"); - index = 11; - res = ctrl->p_mem_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "Free resources: IO\n"); - index = 11; - res = ctrl->io_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "Free resources: bus numbers\n"); - index = 11; - res = ctrl->bus_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - - *start = buf; - len = out-buf; - - return len; -} - -static int read_dev (char *buf, char **start, off_t offset, int len, int *eof, void *data) -{ - struct controller *ctrl = (struct controller *)data; - char * out = buf; - int index; - struct pci_resource *res; - struct pci_func *new_slot; - struct slot *slot; - - if (offset > 0) return 0; /* no partial requests */ - len = 0; - *eof = 1; - - out += sprintf(out, "hot plug ctrl Info Page\n"); - out += sprintf(out, "bus = %d, device = %d, function = %d\n", - ctrl->bus, PCI_SLOT(ctrl->pci_dev->devfn), - PCI_FUNC(ctrl->pci_dev->devfn)); - - slot=ctrl->slot; - - while (slot) { - new_slot = cpqhp_slot_find(slot->bus, slot->device, 0); - if (!new_slot) - break; - out += sprintf(out, "assigned resources: memory\n"); - index = 11; - res = new_slot->mem_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "assigned resources: prefetchable memory\n"); - index = 11; - res = new_slot->p_mem_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "assigned resources: IO\n"); - index = 11; - res = new_slot->io_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - out += sprintf(out, "assigned resources: bus numbers\n"); - index = 11; - res = new_slot->bus_head; - while (res && index--) { - out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); - res = res->next; - } - slot=slot->next; - } - - *start = buf; - len = out-buf; - - return len; -} - -int cpqhp_proc_create_ctrl (struct controller *ctrl) -{ - strcpy(ctrl->proc_name, "hpca"); - ctrl->proc_name[3] = 'a' + ctrl->bus; - - ctrl->proc_entry = create_proc_entry(ctrl->proc_name, S_IFREG | S_IRUGO, ctrl_proc_root); - ctrl->proc_entry->data = ctrl; - ctrl->proc_entry->read_proc = &read_ctrl; - - strcpy(ctrl->proc_name2, "slot_a"); - ctrl->proc_name2[5] = 'a' + ctrl->bus; - ctrl->proc_entry2 = create_proc_entry(ctrl->proc_name2, S_IFREG | S_IRUGO, ctrl_proc_root); - ctrl->proc_entry2->data = ctrl; - ctrl->proc_entry2->read_proc = &read_dev; - - return 0; -} - -int cpqhp_proc_remove_ctrl (struct controller *ctrl) -{ - if (ctrl->proc_entry) - remove_proc_entry(ctrl->proc_name, ctrl_proc_root); - if (ctrl->proc_entry2) - remove_proc_entry(ctrl->proc_name2, ctrl_proc_root); - - return 0; -} - -int cpqhp_proc_init_ctrl (void) -{ - ctrl_proc_root = proc_mkdir("hpc", proc_root_driver); - if (!ctrl_proc_root) - return -ENOMEM; - ctrl_proc_root->owner = THIS_MODULE; - return 0; -} - -int cpqhp_proc_destroy_ctrl (void) -{ - remove_proc_entry("hpc", proc_root_driver); - return 0; -} - diff -Nru a/drivers/hotplug/cpqphp_sysfs.c b/drivers/hotplug/cpqphp_sysfs.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/drivers/hotplug/cpqphp_sysfs.c Tue Mar 4 19:30:13 2003 @@ -0,0 +1,143 @@ +/* + * Compaq Hot Plug Controller Driver + * + * Copyright (c) 1995,2001 Compaq Computer Corporation + * Copyright (c) 2001,2003 Greg Kroah-Hartman (greg@kroah.com) + * Copyright (c) 2001 IBM Corp. + * + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or (at + * your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or + * NON INFRINGEMENT. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * Send feedback to + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include "cpqphp.h" + + +/* A few routines that create sysfs entries for the hot plug controller */ + +static int show_ctrl (struct device *dev, char *buf) +{ + struct pci_dev *pci_dev; + struct controller *ctrl; + char * out = buf; + int index; + struct pci_resource *res; + + pci_dev = container_of (dev, struct pci_dev, dev); + ctrl = pci_get_drvdata(pci_dev); + + out += sprintf(buf, "Free resources: memory\n"); + index = 11; + res = ctrl->mem_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "Free resources: prefetchable memory\n"); + index = 11; + res = ctrl->p_mem_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "Free resources: IO\n"); + index = 11; + res = ctrl->io_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "Free resources: bus numbers\n"); + index = 11; + res = ctrl->bus_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + + return out - buf; +} +static DEVICE_ATTR (ctrl, S_IRUGO, show_ctrl, NULL); + +static int show_dev (struct device *dev, char *buf) +{ + struct pci_dev *pci_dev; + struct controller *ctrl; + char * out = buf; + int index; + struct pci_resource *res; + struct pci_func *new_slot; + struct slot *slot; + + pci_dev = container_of (dev, struct pci_dev, dev); + ctrl = pci_get_drvdata(pci_dev); + + slot=ctrl->slot; + + while (slot) { + new_slot = cpqhp_slot_find(slot->bus, slot->device, 0); + if (!new_slot) + break; + out += sprintf(out, "assigned resources: memory\n"); + index = 11; + res = new_slot->mem_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "assigned resources: prefetchable memory\n"); + index = 11; + res = new_slot->p_mem_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "assigned resources: IO\n"); + index = 11; + res = new_slot->io_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + out += sprintf(out, "assigned resources: bus numbers\n"); + index = 11; + res = new_slot->bus_head; + while (res && index--) { + out += sprintf(out, "start = %8.8x, length = %8.8x\n", res->base, res->length); + res = res->next; + } + slot=slot->next; + } + + return out - buf; +} +static DEVICE_ATTR (dev, S_IRUGO, show_dev, NULL); + +void cpqhp_create_ctrl_files (struct controller *ctrl) +{ + device_create_file (&ctrl->pci_dev->dev, &dev_attr_ctrl); + device_create_file (&ctrl->pci_dev->dev, &dev_attr_dev); +} diff -Nru a/drivers/hotplug/ibmphp.h b/drivers/hotplug/ibmphp.h --- a/drivers/hotplug/ibmphp.h Tue Mar 4 19:30:04 2003 +++ b/drivers/hotplug/ibmphp.h Tue Mar 4 19:30:04 2003 @@ -683,11 +683,6 @@ #define ENABLE 1 #define DISABLE 0 -#define ADD 0 -#define REMOVE 1 -#define DETAIL 2 - -#define MAX_OPS 3 #define CARD_INFO 0x07 #define PCIX133 0x07 #define PCIX66 0x05 @@ -761,6 +756,7 @@ extern int ibmphp_init_devno (struct slot **); /* This function is called from EBDA, so we need it not be static */ extern int ibmphp_disable_slot (struct hotplug_slot *); /* This function is called from HPC, so we need it to not be static */ +extern int ibmphp_do_disable_slot (struct slot *slot_cur); extern int ibmphp_update_slot_info (struct slot *); /* This function is called from HPC, so we need it to not be be static */ extern int ibmphp_configure_card (struct pci_func *, u8); extern int ibmphp_unconfigure_card (struct slot **, int); diff -Nru a/drivers/hotplug/ibmphp_core.c b/drivers/hotplug/ibmphp_core.c --- a/drivers/hotplug/ibmphp_core.c Tue Mar 4 19:30:14 2003 +++ b/drivers/hotplug/ibmphp_core.c Tue Mar 4 19:30:14 2003 @@ -55,7 +55,6 @@ MODULE_LICENSE ("GPL"); MODULE_DESCRIPTION (DRIVER_DESC); -static int *ops[MAX_OPS + 1]; struct pci_bus *ibmphp_pci_bus; static int max_slots; @@ -550,20 +549,6 @@ struct list_head *tmp; int retval; int rc; - int j; - - for (j = 0; j < MAX_OPS; j++) { - ops[j] = (int *) kmalloc ((max_slots + 1) * sizeof (int), GFP_KERNEL); - memset (ops[j], 0, (max_slots + 1) * sizeof (int)); - if (!ops[j]) { - err ("out of system memory \n"); - return -ENOMEM; - } - } - - ops[ADD][0] = 0; - ops[REMOVE][0] = 0; - ops[DETAIL][0] = 0; list_for_each (tmp, &ibmphp_slot_head) { slot_cur = list_entry (tmp, struct slot, ibm_slot_list); @@ -588,24 +573,15 @@ if (retval) return retval; - debug ("status = %x, ext_status = %x\n", slot_cur->status, slot_cur->ext_status); - debug ("SLOT_POWER = %x, SLOT_PRESENT = %x, SLOT_LATCH = %x\n", SLOT_POWER (slot_cur->status), SLOT_PRESENT (slot_cur->status), SLOT_LATCH (slot_cur->status)); - - if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status))) - /* No power, adapter, and latch closed */ - ops[ADD][slot_cur->number] = 1; - else - ops[ADD][slot_cur->number] = 0; - - ops[DETAIL][slot_cur->number] = 1; - - if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status))) - /*Power,adapter,latch closed */ - ops[REMOVE][slot_cur->number] = 1; - else - ops[REMOVE][slot_cur->number] = 0; - - if ((SLOT_PWRGD (slot_cur->status)) && !(SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status))) { + debug ("status = %x\n", slot_cur->status); + debug ("ext_status = %x\n", slot_cur->ext_status); + debug ("SLOT_POWER = %x\n", SLOT_POWER (slot_cur->status)); + debug ("SLOT_PRESENT = %x\n", SLOT_PRESENT (slot_cur->status)); + debug ("SLOT_LATCH = %x\n", SLOT_LATCH (slot_cur->status)); + + if ((SLOT_PWRGD (slot_cur->status)) && + !(SLOT_PRESENT (slot_cur->status)) && + !(SLOT_LATCH (slot_cur->status))) { debug ("BEFORE POWER OFF COMMAND\n"); rc = power_off (slot_cur); if (rc) @@ -643,35 +619,20 @@ if (retval) return retval; - if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) - && !(SLOT_LATCH (slot_cur->status))) - ops[ADD][number] = 1; - else - ops[ADD][number] = 0; - - ops[DETAIL][number] = 1; - - if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) - && !(SLOT_LATCH (slot_cur->status))) - ops[REMOVE][number] = 1; - else - ops[REMOVE][number] = 0; - switch (opn) { case ENABLE: - if (ops[ADD][number]) + if (!(SLOT_PWRGD (slot_cur->status)) && + (SLOT_PRESENT (slot_cur->status)) && + !(SLOT_LATCH (slot_cur->status))) return 0; break; case DISABLE: - if (ops[REMOVE][number]) - return 0; - break; - case DETAIL: - if (ops[DETAIL][number]) + if ((SLOT_PWRGD (slot_cur->status)) && + (SLOT_PRESENT (slot_cur->status)) && + !(SLOT_LATCH (slot_cur->status))) return 0; break; default: - return -EINVAL; break; } err ("validate failed....\n"); @@ -820,174 +781,23 @@ debug ("%s -- exit\n", __FUNCTION__); } -static int ibm_is_pci_dev_in_use (struct pci_dev *dev) -{ - int i = 0; - int inuse = 0; - - if (dev->driver) - return 1; - - for (i = 0; !dev->driver && !inuse && (i < 6); i++) { - - if (!pci_resource_start (dev, i)) - continue; - - if (pci_resource_flags (dev, i) & IORESOURCE_IO) - inuse = check_region (pci_resource_start (dev, i), pci_resource_len (dev, i)); - - else if (pci_resource_flags (dev, i) & IORESOURCE_MEM) - inuse = check_mem_region (pci_resource_start (dev, i), pci_resource_len (dev, i)); - } - - return inuse; -} - -static int ibm_pci_hp_remove_device (struct pci_dev *dev) -{ - if (ibm_is_pci_dev_in_use (dev)) { - err ("***Cannot safely power down device -- it appears to be in use***\n"); - return -EBUSY; - } - pci_remove_device (dev); - return 0; -} - -static int ibm_unconfigure_visit_pci_dev_phase2 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev *dev = wrapped_dev->dev; - struct pci_func *temp_func; - int i = 0; - - do { - temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++); - } while (temp_func && (temp_func->function != (dev->devfn & 0x07))); - - if (dev) { - if (ibm_pci_hp_remove_device (dev) == 0) - kfree (dev); /* Now, remove */ - else - return -1; - } - - if (temp_func) - temp_func->dev = NULL; - else - debug ("No pci_func representation for bus, devfn = %d, %x\n", dev->bus->number, dev->devfn); - - return 0; -} - -static int ibm_unconfigure_visit_pci_bus_phase2 (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev) -{ - struct pci_bus *bus = wrapped_bus->bus; - - pci_proc_detach_bus (bus); - /* The cleanup code should live in the kernel... */ - bus->self->subordinate = NULL; - /* unlink from parent bus */ - list_del (&bus->node); - - /* Now, remove */ - if (bus) - kfree (bus); - - return 0; -} - -static int ibm_unconfigure_visit_pci_dev_phase1 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - struct pci_dev *dev = wrapped_dev->dev; - - debug ("attempting removal of driver for device (%x, %x, %x)\n", dev->bus->number, PCI_SLOT (dev->devfn), PCI_FUNC (dev->devfn)); - - /* Now, remove the Linux Driver Representation */ - if (dev->driver) { - debug ("is there a driver?\n"); - if (dev->driver->remove) { - dev->driver->remove (dev); - debug ("driver was properly removed\n"); - } - dev->driver = NULL; - } - - return ibm_is_pci_dev_in_use (dev); -} - -static struct pci_visit ibm_unconfigure_functions_phase1 = { - .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase1, -}; - -static struct pci_visit ibm_unconfigure_functions_phase2 = { - .post_visit_pci_bus = ibm_unconfigure_visit_pci_bus_phase2, - .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase2, -}; - static int ibm_unconfigure_device (struct pci_func *func) { - int rc = 0; - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; struct pci_dev *temp; u8 j; - memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped)); - memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped)); - - debug ("inside ibm_unconfigure_device\n"); + debug ("inside %s\n", __FUNCTION__); debug ("func->device = %x, func->function = %x\n", func->device, func->function); debug ("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0); for (j = 0; j < 0x08; j++) { temp = pci_find_slot (func->busno, (func->device << 3) | j); - if (temp) { - wrapped_dev.dev = temp; - wrapped_bus.bus = temp->bus; - rc = pci_visit_dev (&ibm_unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus); - if (rc) - break; - - rc = pci_visit_dev (&ibm_unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus); - if (rc) - break; - } + if (temp) + pci_remove_bus_device(temp); } - debug ("rc in ibm_unconfigure_device b4 returning is %d \n", rc); - return rc; -} - -static int configure_visit_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus) -{ - // struct pci_bus *bus = wrapped_bus->bus; /* We don't need this, since we don't create in the else statement */ - struct pci_dev *dev = wrapped_dev->dev; - struct pci_func *temp_func; - int i = 0; - - do { - temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++); - } while (temp_func && (temp_func->function != (dev->devfn & 0x07))); - - if (temp_func) - temp_func->dev = dev; - else { - /* This should not really happen, since we create functions - first and then call to configure */ - debug (" We shouldn't come here \n"); - } - - if (temp_func->dev) { -// pci_proc_attach_device (temp_func->dev); -// pci_announce_device_to_drivers (temp_func->dev); - } - return 0; } -static struct pci_visit configure_functions = { - .visit_pci_dev =configure_visit_pci_dev, -}; - - /* * The following function is to fix kernel bug regarding * getting bus entries, here we manually add those primary @@ -1037,15 +847,9 @@ unsigned char bus; struct pci_dev dev0; struct pci_bus *child; - struct pci_dev *temp; int rc = 0; int flag = 0; /* this is to make sure we don't double scan the bus, for bridged devices primarily */ - struct pci_dev_wrapped wrapped_dev; - struct pci_bus_wrapped wrapped_bus; - - memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped)); - memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped)); memset (&dev0, 0, sizeof (struct pci_dev)); if (!(bus_structure_fixup (func->busno))) @@ -1073,12 +877,6 @@ pci_do_scan_bus (child); } - temp = func->dev; - if (temp) { - wrapped_dev.dev = temp; - wrapped_bus.bus = temp->bus; - rc = pci_visit_dev (&configure_functions, &wrapped_dev, &wrapped_bus); - } return rc; } @@ -1274,7 +1072,6 @@ int rc, i, rcpr; struct slot *slot_cur; u8 function; - u8 faulted = 0; struct pci_func *tmp_func; ibmphp_lock_operations (); @@ -1284,16 +1081,7 @@ if ((rc = validate (slot_cur, ENABLE))) { err ("validate function failed \n"); - attn_off (slot_cur); /* need to turn off if was blinking b4 */ - attn_on (slot_cur); - rc = slot_update (&slot_cur); - if (rc) { - ibmphp_unlock_operations(); - return rc; - } - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return rc; + goto error_nopower; } attn_LED_blink (slot_cur); @@ -1301,10 +1089,7 @@ rc = set_bus (slot_cur); if (rc) { err ("was not able to set the bus \n"); - attn_off (slot_cur); - attn_on (slot_cur); - ibmphp_unlock_operations (); - return -ENODEV; + goto error_nopower; } /*-----------------debugging------------------------------*/ @@ -1314,18 +1099,12 @@ rc = check_limitations (slot_cur); if (rc) { - err ("Adding this card exceeds the limitations of this bus. \n"); - err ("(i.e., >1 133MHz cards running on same bus, or >2 66 PCI cards running on same bus \n. Try hot-adding into another bus \n"); - attn_off (slot_cur); - attn_on (slot_cur); - - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -ENODEV; - } - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return -EINVAL; + err ("Adding this card exceeds the limitations of this bus.\n"); + err ("(i.e., >1 133MHz cards running on same bus, or " + ">2 66 PCI cards running on same bus\n."); + err ("Try hot-adding into another bus \n"); + rc = -EINVAL; + goto error_nopower; } rc = power_on (slot_cur); @@ -1338,22 +1117,21 @@ if (slot_update (&slot_cur)) { attn_off (slot_cur); attn_on (slot_cur); - ibmphp_unlock_operations (); - return -ENODEV; + rc = -ENODEV; + goto exit; } /* Check to see the error of why it failed */ if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status))) - err ("power fault occured trying to power up \n"); + err ("power fault occurred trying to power up \n"); else if (SLOT_BUS_SPEED (slot_cur->status)) { - err ("bus speed mismatch occured. please check current bus speed and card capability \n"); + err ("bus speed mismatch occurred. please check current bus speed and card capability \n"); print_card_capability (slot_cur); } else if (SLOT_BUS_MODE (slot_cur->ext_status)) { - err ("bus mode mismatch occured. please check current bus mode and card capability \n"); + err ("bus mode mismatch occurred. please check current bus mode and card capability \n"); print_card_capability (slot_cur); } ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return rc; + goto exit; } debug ("after power_on\n"); /*-----------------------debugging---------------------------*/ @@ -1362,61 +1140,32 @@ /*----------------------------------------------------------*/ rc = slot_update (&slot_cur); - if (rc) { - attn_off (slot_cur); - attn_on (slot_cur); - rcpr = power_off (slot_cur); - if (rcpr) { - ibmphp_unlock_operations (); - return rcpr; - } - ibmphp_unlock_operations (); - return rc; - } + if (rc) + goto error_power; + rc = -EINVAL; if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) { - faulted = 1; - err ("power fault occured trying to power up... \n"); - } else if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) { - faulted = 1; - err ("bus speed mismatch occured. please check current bus speed and card capability \n"); + err ("power fault occurred trying to power up... \n"); + goto error_power; + } + if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) { + err ("bus speed mismatch occurred. please check current bus speed and card capability \n"); print_card_capability (slot_cur); + goto error_power; } /* Don't think this case will happen after above checks... but just in case, for paranoia sake */ - else if (!(SLOT_POWER (slot_cur->status))) { + if (!(SLOT_POWER (slot_cur->status))) { err ("power on failed... \n"); - faulted = 1; - } - if (faulted) { - attn_off (slot_cur); /* need to turn off b4 on */ - attn_on (slot_cur); - rcpr = power_off (slot_cur); - if (rcpr) { - ibmphp_unlock_operations (); - return rcpr; - } - - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -ENODEV; - } - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return -EINVAL; + goto error_power; } slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL); - if (!slot_cur->func) { /* We cannot do update_slot_info here, since no memory for kmalloc n.e.ways, and update_slot_info allocates some */ + if (!slot_cur->func) { + /* We cannot do update_slot_info here, since no memory for + * kmalloc n.e.ways, and update_slot_info allocates some */ err ("out of system memory \n"); - attn_off (slot_cur); - attn_on (slot_cur); - rcpr = power_off (slot_cur); - if (rcpr) { - ibmphp_unlock_operations (); - return rcpr; - } - ibmphp_unlock_operations (); - return -ENOMEM; + rc = -ENOMEM; + goto error_power; } memset (slot_cur->func, 0, sizeof (struct pci_func)); slot_cur->func->busno = slot_cur->bus; @@ -1431,21 +1180,10 @@ ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */ debug ("after unconfigure_card\n"); slot_cur->func = NULL; - attn_off (slot_cur); /* need to turn off in case was blinking */ - attn_on (slot_cur); - rcpr = power_off (slot_cur); - if (rcpr) { - ibmphp_unlock_operations (); - return rcpr; - } - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations(); - return -ENODEV; - } - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return -ENOMEM; + rc = -ENOMEM; + goto error_power; } + function = 0x00; do { tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++); @@ -1455,13 +1193,36 @@ attn_off (slot_cur); if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -EFAULT; + rc = -EFAULT; + goto exit; } ibmphp_print_test (); rc = ibmphp_update_slot_info (slot_cur); +exit: ibmphp_unlock_operations(); return rc; + +error_nopower: + attn_off (slot_cur); /* need to turn off if was blinking b4 */ + attn_on (slot_cur); +error_cont: + rcpr = slot_update (&slot_cur); + if (rcpr) { + rc = rcpr; + goto exit; + } + ibmphp_update_slot_info (slot_cur); + goto exit; + +error_power: + attn_off (slot_cur); /* need to turn off if was blinking b4 */ + attn_on (slot_cur); + rcpr = power_off (slot_cur); + if (rcpr) { + rc = rcpr; + goto exit; + } + goto error_cont; } /************************************************************** @@ -1472,45 +1233,34 @@ **************************************************************/ int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot) { + struct slot *slot = hotplug_slot->private; + int rc; + + ibmphp_lock_operations(); + rc = ibmphp_do_disable_slot(slot); + ibmphp_unlock_operations(); + return rc; +} + +int ibmphp_do_disable_slot (struct slot *slot_cur) +{ int rc; - struct slot *slot_cur = (struct slot *) hotplug_slot->private; u8 flag; int parm = 0; debug ("DISABLING SLOT... \n"); - if (slot_cur == NULL) { - ibmphp_unlock_operations (); - return -ENODEV; - } - - if (slot_cur->ctrl == NULL) { - ibmphp_unlock_operations (); + if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) { return -ENODEV; } - flag = slot_cur->flag; /* to see if got here from polling */ - - if (flag) - ibmphp_lock_operations (); - + flag = slot_cur->flag; slot_cur->flag = TRUE; if (flag == TRUE) { rc = validate (slot_cur, DISABLE); /* checking if powered off already & valid slot # */ - if (rc) { - /* Need to turn off if was blinking b4 */ - attn_off (slot_cur); - attn_on (slot_cur); - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -EFAULT; - } - - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return rc; - } + if (rc) + goto error; } attn_LED_blink (slot_cur); @@ -1519,10 +1269,8 @@ slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL); if (!slot_cur->func) { err ("out of system memory \n"); - attn_off (slot_cur); - attn_on (slot_cur); - ibmphp_unlock_operations (); - return -ENOMEM; + rc = -ENOMEM; + goto error; } memset (slot_cur->func, 0, sizeof (struct pci_func)); slot_cur->func->busno = slot_cur->bus; @@ -1531,11 +1279,9 @@ if ((rc = ibm_unconfigure_device (slot_cur->func))) { err ("removing from kernel failed... \n"); - err ("Please check to see if it was statically linked or is in use otherwise. (perhaps the driver is not 'hot-removable')\n"); - attn_off (slot_cur); - attn_on (slot_cur); - ibmphp_unlock_operations (); - return rc; + err ("Please check to see if it was statically linked or is " + "in use otherwise. (perhaps the driver is not 'hot-removable')\n"); + goto error; } /* If we got here from latch suddenly opening on operating card or @@ -1554,43 +1300,34 @@ debug ("in disable_slot. after unconfigure_card\n"); if (rc) { err ("could not unconfigure card.\n"); - attn_off (slot_cur); /* need to turn off if was blinking b4 */ - attn_on (slot_cur); - - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -EFAULT; - } - - if (flag) - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return -EFAULT; + goto error; } - rc = ibmphp_hpc_writeslot (hotplug_slot->private, HPC_SLOT_OFF); - if (rc) { - attn_off (slot_cur); - attn_on (slot_cur); - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -EFAULT; - } - - ibmphp_update_slot_info (slot_cur); - ibmphp_unlock_operations (); - return rc; - } + rc = ibmphp_hpc_writeslot (slot_cur, HPC_SLOT_OFF); + if (rc) + goto error; attn_off (slot_cur); - if (slot_update (&slot_cur)) { - ibmphp_unlock_operations (); - return -EFAULT; - } + rc = slot_update (&slot_cur); + if (rc) + goto exit; + rc = ibmphp_update_slot_info (slot_cur); ibmphp_print_test (); - ibmphp_unlock_operations(); +exit: return rc; + +error: + /* Need to turn off if was blinking b4 */ + attn_off (slot_cur); + attn_on (slot_cur); + if (slot_update (&slot_cur)) { + rc = -EFAULT; + goto exit; + } + if (flag) + ibmphp_update_slot_info (slot_cur); + goto exit; } struct hotplug_slot_ops ibmphp_hotplug_slot_ops = { @@ -1622,6 +1359,7 @@ debug ("after ebda hpc \n"); ibmphp_free_ebda_pci_rsrc_queue (); debug ("after ebda pci rsrc \n"); + kfree (ibmphp_pci_bus); } static int __init ibmphp_init (void) @@ -1637,13 +1375,15 @@ ibmphp_pci_bus = kmalloc (sizeof (*ibmphp_pci_bus), GFP_KERNEL); if (!ibmphp_pci_bus) { err ("out of memory\n"); - return -ENOMEM; + rc = -ENOMEM; + goto exit; } bus = ibmphp_find_bus (0); if (!bus) { err ("Can't find the root pci bus, can not continue\n"); - return -ENODEV; + rc = -ENODEV; + goto error; } memcpy (ibmphp_pci_bus, bus, sizeof (*ibmphp_pci_bus)); @@ -1654,39 +1394,39 @@ for (i = 0; i < 16; i++) irqs[i] = 0; - if ((rc = ibmphp_access_ebda ())) { - ibmphp_unload (); - return rc; - } + if ((rc = ibmphp_access_ebda ())) + goto error; debug ("after ibmphp_access_ebda ()\n"); - if ((rc = ibmphp_rsrc_init ())) { - ibmphp_unload (); - return rc; - } + if ((rc = ibmphp_rsrc_init ())) + goto error; debug ("AFTER Resource & EBDA INITIALIZATIONS\n"); max_slots = get_max_slots (); - if ((rc = ibmphp_register_pci ())) { - ibmphp_unload (); - return rc; - } + if ((rc = ibmphp_register_pci ())) + goto error; if (init_ops ()) { - ibmphp_unload (); - return -ENODEV; + rc = -ENODEV; + goto error; } + ibmphp_print_test (); if ((rc = ibmphp_hpc_start_poll_thread ())) { - ibmphp_unload (); - return -ENODEV; + goto error; } - /* if no NVRAM module selected, lock ourselves into memory with a - * module count of -1 so that no one can unload us. */ + /* lock ourselves into memory with a module + * count of -1 so that no one can unload us. */ MOD_DEC_USE_COUNT; - return 0; + +exit: + return rc; + +error: + ibmphp_unload (); + goto exit; } static void __exit ibmphp_exit (void) diff -Nru a/drivers/hotplug/ibmphp_hpc.c b/drivers/hotplug/ibmphp_hpc.c --- a/drivers/hotplug/ibmphp_hpc.c Tue Mar 4 19:30:05 2003 +++ b/drivers/hotplug/ibmphp_hpc.c Tue Mar 4 19:30:05 2003 @@ -1063,7 +1063,7 @@ if (disable) { debug ("process_changeinstatus - disable slot\n"); pslot->flag = FALSE; - rc = ibmphp_disable_slot (pslot->hotplug_slot); + rc = ibmphp_do_disable_slot (pslot); } if (update || disable) { diff -Nru a/drivers/hotplug/ibmphp_res.c b/drivers/hotplug/ibmphp_res.c --- a/drivers/hotplug/ibmphp_res.c Tue Mar 4 19:30:13 2003 +++ b/drivers/hotplug/ibmphp_res.c Tue Mar 4 19:30:13 2003 @@ -740,7 +740,7 @@ res->nextRange = NULL; } } else { - /* this is the case where it is 1st occurence of the range */ + /* this is the case where it is 1st occurrence of the range */ if (!res_prev) { /* at the beginning of the resource list */ res->next = NULL; diff -Nru a/drivers/hotplug/pci_hotplug_core.c b/drivers/hotplug/pci_hotplug_core.c --- a/drivers/hotplug/pci_hotplug_core.c Tue Mar 4 19:30:13 2003 +++ b/drivers/hotplug/pci_hotplug_core.c Tue Mar 4 19:30:13 2003 @@ -67,8 +67,6 @@ ////////////////////////////////////////////////////////////////// -static spinlock_t list_lock; - static LIST_HEAD(pci_hotplug_slot_list); static struct subsystem hotplug_slots_subsys; @@ -531,23 +529,16 @@ if ((slot->info == NULL) || (slot->ops == NULL)) return -EINVAL; - /* make sure we have not already registered this slot */ - spin_lock (&list_lock); - if (get_slot_from_name (slot->name) != NULL) { - spin_unlock (&list_lock); - return -EINVAL; - } - strncpy(slot->kobj.name, slot->name, KOBJ_NAME_LEN); kobj_set_kset_s(slot, hotplug_slots_subsys); + /* this can fail if we have already registered a slot with the same name */ if (kobject_register(&slot->kobj)) { err("Unable to register kobject"); return -EINVAL; } list_add (&slot->slot_list, &pci_hotplug_slot_list); - spin_unlock (&list_lock); result = fs_add_slot (slot); dbg ("Added slot %s to the list\n", slot->name); @@ -570,16 +561,11 @@ if (slot == NULL) return -ENODEV; - /* make sure we have this slot in our list before trying to delete it */ - spin_lock (&list_lock); temp = get_slot_from_name (slot->name); if (temp != slot) { - spin_unlock (&list_lock); return -ENODEV; } - list_del (&slot->slot_list); - spin_unlock (&list_lock); fs_remove_slot (slot); dbg ("Removed slot %s from the list\n", slot->name); @@ -638,8 +624,6 @@ static int __init pci_hotplug_init (void) { int result; - - spin_lock_init(&list_lock); kset_set_kset_s(&hotplug_slots_subsys, pci_bus_type.subsys); result = subsystem_register(&hotplug_slots_subsys); diff -Nru a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c --- a/drivers/i2c/busses/i2c-amd8111.c Tue Mar 4 19:30:13 2003 +++ b/drivers/i2c/busses/i2c-amd8111.c Tue Mar 4 19:30:13 2003 @@ -8,10 +8,8 @@ * the Free Software Foundation version 2. */ -#include #include #include -#include #include #include #include @@ -19,6 +17,7 @@ #include #include #include +#include MODULE_LICENSE("GPL"); MODULE_AUTHOR ("Vojtech Pavlik "); @@ -204,8 +203,6 @@ protocol |= AMD_SMB_PRTCL_BYTE_DATA; break; - case I2C_SMBUS_WORD_DATA_PEC: - protocol |= AMD_SMB_PRTCL_PEC; case I2C_SMBUS_WORD_DATA: amd_ec_write(smbus, AMD_SMB_CMD, command); if (read_write == I2C_SMBUS_WRITE) { @@ -215,8 +212,6 @@ protocol |= AMD_SMB_PRTCL_WORD_DATA | pec; break; - case I2C_SMBUS_BLOCK_DATA_PEC: - protocol |= AMD_SMB_PRTCL_PEC; case I2C_SMBUS_BLOCK_DATA: amd_ec_write(smbus, AMD_SMB_CMD, command); if (read_write == I2C_SMBUS_WRITE) { @@ -238,8 +233,6 @@ protocol |= AMD_SMB_PRTCL_I2C_BLOCK_DATA; break; - case I2C_SMBUS_PROC_CALL_PEC: - protocol |= AMD_SMB_PRTCL_PEC; case I2C_SMBUS_PROC_CALL: amd_ec_write(smbus, AMD_SMB_CMD, command); amd_ec_write(smbus, AMD_SMB_DATA, data->word); @@ -248,8 +241,6 @@ read_write = I2C_SMBUS_READ; break; - case I2C_SMBUS_BLOCK_PROC_CALL_PEC: - protocol |= AMD_SMB_PRTCL_PEC; case I2C_SMBUS_BLOCK_PROC_CALL: protocol |= pec; len = min_t(u8, data->block[0], 31); @@ -261,6 +252,13 @@ read_write = I2C_SMBUS_READ; break; + case I2C_SMBUS_WORD_DATA_PEC: + case I2C_SMBUS_BLOCK_DATA_PEC: + case I2C_SMBUS_PROC_CALL_PEC: + case I2C_SMBUS_BLOCK_PROC_CALL_PEC: + printk(KERN_WARNING "i2c-amd8111.c: Unexpected software PEC transaction %d\n.", size); + return -1; + default: printk(KERN_WARNING "i2c-amd8111.c: Unsupported transaction %d\n", size); return -1; @@ -296,18 +294,14 @@ break; case I2C_SMBUS_WORD_DATA: - case I2C_SMBUS_WORD_DATA_PEC: case I2C_SMBUS_PROC_CALL: - case I2C_SMBUS_PROC_CALL_PEC: amd_ec_read(smbus, AMD_SMB_DATA, temp + 0); amd_ec_read(smbus, AMD_SMB_DATA + 1, temp + 1); data->word = (temp[1] << 8) | temp[0]; break; case I2C_SMBUS_BLOCK_DATA: - case I2C_SMBUS_BLOCK_DATA_PEC: case I2C_SMBUS_BLOCK_PROC_CALL: - case I2C_SMBUS_BLOCK_PROC_CALL_PEC: amd_ec_read(smbus, AMD_SMB_BCNT, &len); len = min_t(u8, len, 32); case I2C_SMBUS_I2C_BLOCK_DATA: @@ -320,13 +314,12 @@ return 0; } + u32 amd8111_func(struct i2c_adapter *adapter) { return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | - I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_WORD_DATA_PEC | - I2C_FUNC_SMBUS_BLOCK_DATA | I2C_FUNC_SMBUS_BLOCK_DATA_PEC | - I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_PROC_CALL_PEC | - I2C_FUNC_SMBUS_BLOCK_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_PROC_CALL_PEC | + I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA | + I2C_FUNC_SMBUS_PROC_CALL | I2C_FUNC_SMBUS_BLOCK_PROC_CALL | I2C_FUNC_SMBUS_I2C_BLOCK | I2C_FUNC_SMBUS_HWPEC_CALC; } @@ -337,78 +330,81 @@ .functionality = amd8111_func, }; + +static struct pci_device_id amd8111_ids[] __devinitdata = { + { 0x1022, 0x746a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, + { 0, } +}; + static int __devinit amd8111_probe(struct pci_dev *dev, const struct pci_device_id *id) { struct amd_smbus *smbus; + int error = -ENODEV; if (~pci_resource_flags(dev, 0) & IORESOURCE_IO) - return -1; + return -ENODEV; - if (!(smbus = (void*)kmalloc(sizeof(struct amd_smbus), GFP_KERNEL))) - return -1; + smbus = kmalloc(sizeof(struct amd_smbus), GFP_KERNEL); + if (!smbus) + return -ENOMEM; memset(smbus, 0, sizeof(struct amd_smbus)); - pci_set_drvdata(dev, smbus); smbus->dev = dev; smbus->base = pci_resource_start(dev, 0); smbus->size = pci_resource_len(dev, 0); - if (!request_region(smbus->base, smbus->size, "amd8111 SMBus 2.0")) { - kfree(smbus); - return -1; - } + if (!request_region(smbus->base, smbus->size, "amd8111 SMBus 2.0")) + goto out_kfree; smbus->adapter.owner = THIS_MODULE; - sprintf(smbus->adapter.name, "SMBus2 AMD8111 adapter at %04x", smbus->base); + sprintf(smbus->adapter.name, + "SMBus2 AMD8111 adapter at %04x", smbus->base); smbus->adapter.id = I2C_ALGO_SMBUS | I2C_HW_SMBUS_AMD8111; smbus->adapter.algo = &smbus_algorithm; smbus->adapter.algo_data = smbus; - if (i2c_add_adapter(&smbus->adapter)) { - printk(KERN_WARNING "i2c-amd8111.c: Failed to register adapter.\n"); - release_region(smbus->base, smbus->size); - kfree(smbus); - return -1; - } + error = i2c_add_adapter(&smbus->adapter); + if (error) + goto out_release_region; pci_write_config_dword(smbus->dev, AMD_PCI_MISC, 0); - - printk(KERN_INFO "i2c-amd8111.c: AMD8111 SMBus 2.0 adapter at %#x\n", smbus->base); + pci_set_drvdata(dev, smbus); return 0; + + out_release_region: + release_region(smbus->base, smbus->size); + out_kfree: + kfree(smbus); + return -1; } + static void __devexit amd8111_remove(struct pci_dev *dev) { - struct amd_smbus *smbus = (void*) pci_get_drvdata(dev); - if (i2c_del_adapter(&smbus->adapter)) { - printk(KERN_WARNING "i2c-amd8111.c: Failed to unregister adapter.\n"); - return; - } + struct amd_smbus *smbus = pci_get_drvdata(dev); + + i2c_del_adapter(&smbus->adapter); release_region(smbus->base, smbus->size); kfree(smbus); } -static struct pci_device_id amd8111_id_table[] __devinitdata = -{{ 0x1022, 0x746a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, - { 0 }}; - - static struct pci_driver amd8111_driver = { - .name = "amd8111 smbus 2.0", - .id_table = amd8111_id_table, - .probe = amd8111_probe, - .remove = __devexit_p(amd8111_remove), + .name = "amd8111 smbus 2.0", + .id_table = amd8111_ids, + .probe = amd8111_probe, + .remove = __devexit_p(amd8111_remove), }; -int __init amd8111_init(void) +static int __init i2c_amd8111_init(void) { return pci_module_init(&amd8111_driver); } -void __exit amd8111_exit(void) + +static void __exit i2c_amd8111_exit(void) { pci_unregister_driver(&amd8111_driver); } -module_init(amd8111_init); -module_exit(amd8111_exit); +module_init(i2c_amd8111_init); +module_exit(i2c_amd8111_exit); diff -Nru a/drivers/i2c/chips/adm1021.c b/drivers/i2c/chips/adm1021.c --- a/drivers/i2c/chips/adm1021.c Tue Mar 4 19:30:04 2003 +++ b/drivers/i2c/chips/adm1021.c Tue Mar 4 19:30:04 2003 @@ -311,18 +311,14 @@ goto error3; /* Register a new directory entry with module sensors */ - if ((i = i2c_register_entry(new_client, - type_name, - data->type == - adm1021 ? - adm1021_dir_table_template : - adm1021_max_dir_table_template, - THIS_MODULE)) < 0) { - err = i; + err = i2c_register_entry(new_client, type_name, + (data->type == adm1021) ? + adm1021_dir_table_template : + adm1021_max_dir_table_template); + if (err < 0) goto error4; - } - data->sysctl_id = i; + data->sysctl_id = err; /* Initialize the ADM1021 chip */ adm1021_init_client(new_client); return 0; diff -Nru a/drivers/i2c/chips/lm75.c b/drivers/i2c/chips/lm75.c --- a/drivers/i2c/chips/lm75.c Tue Mar 4 19:30:03 2003 +++ b/drivers/i2c/chips/lm75.c Tue Mar 4 19:30:03 2003 @@ -191,9 +191,8 @@ goto error3; /* Register a new directory entry with module sensors */ - if ((i = i2c_register_entry(new_client, type_name, - lm75_dir_table_template, - THIS_MODULE)) < 0) { + i = i2c_register_entry(new_client, type_name, lm75_dir_table_template); + if (i < 0) { err = i; goto error4; } diff -Nru a/drivers/i2c/i2c-adap-ite.c b/drivers/i2c/i2c-adap-ite.c --- a/drivers/i2c/i2c-adap-ite.c Tue Mar 4 19:30:05 2003 +++ b/drivers/i2c/i2c-adap-ite.c Tue Mar 4 19:30:05 2003 @@ -265,7 +265,7 @@ MODULE_PARM(i2c_debug,"i"); -/* Called when module is loaded or when kernel is intialized. +/* Called when module is loaded or when kernel is initialized. * If MODULES is defined when this file is compiled, then this function will * resolve to init_module (the function called when insmod is invoked for a * module). Otherwise, this function is called early in the boot, when the diff -Nru a/drivers/i2c/i2c-algo-ibm_ocp.c b/drivers/i2c/i2c-algo-ibm_ocp.c --- a/drivers/i2c/i2c-algo-ibm_ocp.c Tue Mar 4 19:30:11 2003 +++ b/drivers/i2c/i2c-algo-ibm_ocp.c Tue Mar 4 19:30:11 2003 @@ -758,7 +758,7 @@ // Check to see if the bus is busy // ret = iic_inb(adap, iic->extsts); - // Mask off the irrelevent bits + // Mask off the irrelevant bits ret = ret & 0x70; // When the bus is free, the BCS bits in the EXTSTS register are 0b100 if(ret != 0x40) return IIC_ERR_LOST_ARB; diff -Nru a/drivers/i2c/i2c-algo-ite.c b/drivers/i2c/i2c-algo-ite.c --- a/drivers/i2c/i2c-algo-ite.c Tue Mar 4 19:30:13 2003 +++ b/drivers/i2c/i2c-algo-ite.c Tue Mar 4 19:30:13 2003 @@ -860,7 +860,7 @@ * is loaded via insmod) when this file is compiled with MODULES defined. * Otherwise (i.e. if you want this driver statically linked to the kernel), * a pointer to this function is stored in a table and called - * during the intialization of the kernel (in do_basic_setup in /init/main.c) + * during the initialization of the kernel (in do_basic_setup in /init/main.c) * * All this functionality is complements of the macros defined in linux/init.h */ diff -Nru a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c --- a/drivers/i2c/i2c-core.c Tue Mar 4 19:30:04 2003 +++ b/drivers/i2c/i2c-core.c Tue Mar 4 19:30:04 2003 @@ -61,11 +61,9 @@ /**** adapter list */ static struct i2c_adapter *adapters[I2C_ADAP_MAX]; -static int adap_count; /**** drivers list */ static struct i2c_driver *drivers[I2C_DRIVER_MAX]; -static int driver_count; /**** debug level */ static int i2c_debug; @@ -116,7 +114,6 @@ } adapters[i] = adap; - adap_count++; ADAP_UNLOCK(); /* init data types */ @@ -161,7 +158,6 @@ ERROR1: ADAP_LOCK(); adapters[i] = NULL; - adap_count--; ERROR0: ADAP_UNLOCK(); return res; @@ -227,7 +223,6 @@ #endif /* def CONFIG_PROC_FS */ adapters[i] = NULL; - adap_count--; ADAP_UNLOCK(); DEB(printk(KERN_DEBUG "i2c-core.o: adapter unregistered: %s\n",adap->name)); @@ -265,7 +260,6 @@ } drivers[i] = driver; - driver_count++; DRV_UNLOCK(); /* driver was successfully added */ @@ -361,7 +355,6 @@ } ADAP_UNLOCK(); drivers[i] = NULL; - driver_count--; DRV_UNLOCK(); DEB(printk(KERN_DEBUG "i2c-core.o: driver unregistered: %s\n",driver->name)); @@ -465,73 +458,6 @@ module_put(client->adapter->owner); } -struct i2c_client *i2c_get_client(int driver_id, int adapter_id, - struct i2c_client *prev) -{ - int i,j; - - /* Will iterate through the list of clients in each adapter of adapters-list - in search for a client that matches the search criteria. driver_id or - adapter_id are ignored if set to 0. If both are ignored this returns - first client found. */ - - i = j = 0; - - /* set starting point */ - if(prev) - { - if(!(prev->adapter)) - return (struct i2c_client *) -EINVAL; - - for(j=0; j < I2C_ADAP_MAX; j++) - if(prev->adapter == adapters[j]) - break; - - /* invalid starting point? */ - if (I2C_ADAP_MAX == j) { - printk(KERN_WARNING " i2c-core.o: get_client adapter for client:[%s] not found\n", - prev->name); - return (struct i2c_client *) -ENODEV; - } - - for(i=0; i < I2C_CLIENT_MAX; i++) - if(prev == adapters[j]->clients[i]) - break; - - /* invalid starting point? */ - if (I2C_CLIENT_MAX == i) { - printk(KERN_WARNING " i2c-core.o: get_client client:[%s] not found\n", - prev->name); - return (struct i2c_client *) -ENODEV; - } - - i++; /* start from one after prev */ - } - - for(; j < I2C_ADAP_MAX; j++) - { - if(!adapters[j]) - continue; - - if(adapter_id && (adapters[j]->id != adapter_id)) - continue; - - for(; i < I2C_CLIENT_MAX; i++) - { - if(!adapters[j]->clients[i]) - continue; - - if(driver_id && (adapters[j]->clients[i]->driver->id != driver_id)) - continue; - if(adapters[j]->clients[i]->flags & I2C_CLIENT_ALLOW_USE) - return adapters[j]->clients[i]; - } - i = 0; - } - - return 0; -} - int i2c_use_client(struct i2c_client *client) { if (!i2c_inc_use_client(client)) @@ -1421,11 +1347,9 @@ EXPORT_SYMBOL(i2c_del_driver); EXPORT_SYMBOL(i2c_attach_client); EXPORT_SYMBOL(i2c_detach_client); -EXPORT_SYMBOL(i2c_get_client); EXPORT_SYMBOL(i2c_use_client); EXPORT_SYMBOL(i2c_release_client); EXPORT_SYMBOL(i2c_check_addr); - EXPORT_SYMBOL(i2c_master_send); EXPORT_SYMBOL(i2c_master_recv); diff -Nru a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c --- a/drivers/i2c/i2c-dev.c Tue Mar 4 19:30:12 2003 +++ b/drivers/i2c/i2c-dev.c Tue Mar 4 19:30:12 2003 @@ -77,6 +77,7 @@ static struct i2c_adapter *i2cdev_adaps[I2CDEV_ADAPS_MAX]; static struct i2c_driver i2cdev_driver = { + .owner = THIS_MODULE, .name = "i2c-dev dummy driver", .id = I2C_DRIVERID_I2CDEV, .flags = I2C_DF_DUMMY, @@ -340,47 +341,42 @@ return 0; } -int i2cdev_open (struct inode *inode, struct file *file) +static int i2cdev_open(struct inode *inode, struct file *file) { unsigned int minor = minor(inode->i_rdev); struct i2c_client *client; - if ((minor >= I2CDEV_ADAPS_MAX) || ! (i2cdev_adaps[minor])) { -#ifdef DEBUG - printk(KERN_DEBUG "i2c-dev.o: Trying to open unattached adapter i2c-%d\n", - minor); -#endif + if ((minor >= I2CDEV_ADAPS_MAX) || !(i2cdev_adaps[minor])) return -ENODEV; - } - /* Note that we here allocate a client for later use, but we will *not* - register this client! Yes, this is safe. No, it is not very clean. */ - if(! (client = kmalloc(sizeof(struct i2c_client),GFP_KERNEL))) + client = kmalloc(sizeof(*client), GFP_KERNEL); + if (!client) return -ENOMEM; - memcpy(client,&i2cdev_client_template,sizeof(struct i2c_client)); + memcpy(client, &i2cdev_client_template, sizeof(*client)); + + /* registered with adapter, passed as client to user */ client->adapter = i2cdev_adaps[minor]; file->private_data = client; - if (!try_module_get(i2cdev_adaps[minor]->owner)) { - kfree(client); - return -ENODEV; - } + /* use adapter module, i2c-dev handled with fops */ + if (!try_module_get(client->adapter->owner)) + goto out_kfree; -#ifdef DEBUG - printk(KERN_DEBUG "i2c-dev.o: opened i2c-%d\n",minor); -#endif return 0; + + out_kfree: + kfree(client); + return -ENODEV; } -static int i2cdev_release (struct inode *inode, struct file *file) +static int i2cdev_release(struct inode *inode, struct file *file) { - unsigned int minor = minor(inode->i_rdev); - kfree(file->private_data); - file->private_data=NULL; -#ifdef DEBUG - printk(KERN_DEBUG "i2c-dev.o: Closed: i2c-%d\n", minor); -#endif - module_put(i2cdev_adaps[minor]->owner); + struct i2c_client *client = file->private_data; + + module_put(client->adapter->owner); + kfree(client); + file->private_data = NULL; + return 0; } diff -Nru a/drivers/i2c/i2c-proc.c b/drivers/i2c/i2c-proc.c --- a/drivers/i2c/i2c-proc.c Tue Mar 4 19:30:09 2003 +++ b/drivers/i2c/i2c-proc.c Tue Mar 4 19:30:09 2003 @@ -125,17 +125,12 @@ ctl_template should be a template of the newly created directory. It is copied in memory. The extra2 field of each file is set to point to client. If any driver wants subdirectories within the newly created directory, - this function must be updated! - controlling_mod is the controlling module. It should usually be - THIS_MODULE when calling. Note that this symbol is not defined in - kernels before 2.3.13; define it to NULL in that case. We will not use it - for anything older than 2.3.27 anyway. */ + this function must be updated! */ int i2c_register_entry(struct i2c_client *client, const char *prefix, - ctl_table * ctl_template, - struct module *controlling_mod) + ctl_table * ctl_template) { int i, res, len, id; - ctl_table *new_table; + ctl_table *new_table, *client_tbl, *tbl; char *name; struct ctl_table_header *new_header; @@ -150,26 +145,33 @@ kfree(name); return -ENOMEM; } - id += 256; + id += 256; + len = 0; while (ctl_template[len].procname) len++; - len += 7; - if (!(new_table = kmalloc(sizeof(ctl_table) * len, GFP_KERNEL))) { + if (!(new_table = kmalloc(sizeof(sysctl_table) + sizeof(ctl_table) * (len + 1), + GFP_KERNEL))) { kfree(name); return -ENOMEM; } - memcpy(new_table, sysctl_table, 6 * sizeof(ctl_table)); - new_table[0].child = &new_table[2]; - new_table[2].child = &new_table[4]; - new_table[4].child = &new_table[6]; - new_table[4].procname = name; - new_table[4].ctl_name = id; - memcpy(new_table + 6, ctl_template, (len - 6) * sizeof(ctl_table)); - for (i = 6; i < len; i++) - new_table[i].extra2 = client; + memcpy(new_table, sysctl_table, sizeof(sysctl_table)); + tbl = new_table; /* sys/ */ + tbl = tbl->child = tbl + 2; /* dev/ */ + tbl = tbl->child = tbl + 2; /* sensors/ */ + client_tbl = tbl->child = tbl + 2; /* XX-chip-YY-ZZ/ */ + + client_tbl->procname = name; + client_tbl->ctl_name = id; + client_tbl->child = client_tbl + 2; + + /* Next the client sysctls. --km */ + tbl = client_tbl->child; + memcpy(tbl, ctl_template, sizeof(ctl_table) * (len+1)); + for (i = 0; i < len; i++) + tbl[i].extra2 = client; if (!(new_header = register_sysctl_table(new_table, 0))) { printk(KERN_ERR "i2c-proc.o: error: sysctl interface not supported by kernel!\n"); @@ -178,21 +180,21 @@ return -EPERM; } - i2c_entries[id - 256] = new_header; + i2c_entries[id - 256] = new_header; i2c_clients[id - 256] = client; + #ifdef DEBUG if (!new_header || !new_header->ctl_table || !new_header->ctl_table->child || !new_header->ctl_table->child->child || - !new_header->ctl_table->child->child->de) { + !new_header->ctl_table->child->child->de ) { printk (KERN_ERR "i2c-proc.o: NULL pointer when trying to install fill_inode fix!\n"); return id; } #endif /* DEBUG */ - new_header->ctl_table->child->child->de->owner = controlling_mod; - + client_tbl->de->owner = client->driver->owner; return id; } @@ -515,7 +517,7 @@ return 0; } -int i2c_write_reals(int nrels, void *buffer, size_t *bufsize, +static int i2c_write_reals(int nrels, void *buffer, size_t *bufsize, long *results, int magnitude) { #define BUFLEN 20 diff -Nru a/drivers/ide/arm/icside.c b/drivers/ide/arm/icside.c --- a/drivers/ide/arm/icside.c Tue Mar 4 19:30:09 2003 +++ b/drivers/ide/arm/icside.c Tue Mar 4 19:30:09 2003 @@ -731,7 +731,7 @@ static int icside_dma_timeout(ide_drive_t *drive) { - printk(KERN_ERR "%s: DMA timeout occured: ", drive->name); + printk(KERN_ERR "%s: DMA timeout occurred: ", drive->name); if (icside_dma_test_irq(drive)) return 0; diff -Nru a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c --- a/drivers/ide/ide-cd.c Tue Mar 4 19:30:08 2003 +++ b/drivers/ide/ide-cd.c Tue Mar 4 19:30:08 2003 @@ -19,7 +19,7 @@ * ftp://fission.dt.wdc.com/pub/standards/SFF_atapi/spec/SFF8020-r2.6/PS/8020r26.ps * ftp://ftp.avc-pioneer.com/Mtfuji4/Spec/Fuji4r10.pdf * - * Drives that deviate from these standards will be accomodated as much + * Drives that deviate from these standards will be accommodated as much * as possible via compile time or command-line options. Since I only have * a few drives, you generally need to send me patches... * diff -Nru a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c --- a/drivers/ide/ide-dma.c Tue Mar 4 19:30:09 2003 +++ b/drivers/ide/ide-dma.c Tue Mar 4 19:30:09 2003 @@ -196,9 +196,9 @@ * @drive: the drive to build the DMA table for * @rq: the request holding the sg list * - * Perform the PCI mapping magic neccessary to access the source or + * Perform the PCI mapping magic necessary to access the source or * target buffers of a request via PCI DMA. The lower layers of the - * kernel provide the neccessary cache management so that we can + * kernel provide the necessary cache management so that we can * operate in a portable fashion */ @@ -226,9 +226,9 @@ * @drive: the drive to build the DMA table for * @rq: the request holding the sg list * - * Perform the PCI mapping magic neccessary to access the source or + * Perform the PCI mapping magic necessary to access the source or * target buffers of a taskfile request via PCI DMA. The lower layers - * of the kernel provide the neccessary cache management so that we can + * of the kernel provide the necessary cache management so that we can * operate in a portable fashion */ @@ -454,7 +454,7 @@ * An IDE DMA transfer timed out. In the event of an error we ask * the driver to resolve the problem, if a DMA transfer is still * in progress we continue to wait (arguably we need to add a - * secondary 'I dont care what the drive thinks' timeout here) + * secondary 'I don't care what the drive thinks' timeout here) * Finally if we have an interrupt but for some reason got the * timeout first we complete the I/O. This can occur if an * interrupt is lost or due to bugs. diff -Nru a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c --- a/drivers/ide/ide-io.c Tue Mar 4 19:30:13 2003 +++ b/drivers/ide/ide-io.c Tue Mar 4 19:30:13 2003 @@ -379,7 +379,7 @@ * @drive: drive the completion interrupt occurred on * * drive_cmd_intr() is invoked on completion of a special DRIVE_CMD. - * We do any neccessary daya reading and then wait for the drive to + * We do any necessary daya reading and then wait for the drive to * go non busy. At that point we may read the error data and complete * the request */ @@ -652,7 +652,7 @@ * @hwgroup: hardware group to select on * * choose_drive() selects the next drive which will be serviced. - * This is neccessary because the IDE layer can't issue commands + * This is necessary because the IDE layer can't issue commands * to both drives on the same cable, unlike SCSI. */ diff -Nru a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c --- a/drivers/ide/pci/pdc202xx_new.c Tue Mar 4 19:30:12 2003 +++ b/drivers/ide/pci/pdc202xx_new.c Tue Mar 4 19:30:12 2003 @@ -327,7 +327,7 @@ #endif /* PDC202_DEBUG_CABLE */ break; default: - /* If its not one we know we should never + /* If it's not one we know we should never arrive here.. */ BUG(); } diff -Nru a/drivers/ide/pci/triflex.h b/drivers/ide/pci/triflex.h --- a/drivers/ide/pci/triflex.h Tue Mar 4 19:30:11 2003 +++ b/drivers/ide/pci/triflex.h Tue Mar 4 19:30:11 2003 @@ -18,31 +18,26 @@ static ide_pci_device_t triflex_devices[] __devinitdata = { { - .vendor PCI_VENDOR_ID_COMPAQ, - .device PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE, - .name "TRIFLEX", - .init_chipset init_chipset_triflex, - .init_iops NULL, - .init_hwif init_hwif_triflex, - .channels 2, - .autodma AUTODMA, - .enablebits {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}}, - .bootable ON_BOARD, - .extra 0, + .vendor = PCI_VENDOR_ID_COMPAQ, + .device = PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE, + .name = "TRIFLEX", + .init_chipset = init_chipset_triflex, + .init_iops = NULL, + .init_hwif = init_hwif_triflex, + .channels = 2, + .autodma = AUTODMA, + .enablebits = {{0x80, 0x01, 0x01}, {0x80, 0x02, 0x02}}, + .bootable = ON_BOARD, },{ - .vendor 0, - .device 0, - .channels 0, - .bootable EOL, + .bootable = EOL, } }; #ifdef CONFIG_PROC_FS static ide_pci_host_proc_t triflex_proc __initdata = { - name: "triflex", - set: 1, - get_info: triflex_get_info, - parent: NULL, + .name = "triflex", + .set = 1, + .get_info = triflex_get_info, }; #endif diff -Nru a/drivers/ide/ppc/mpc8xx.c b/drivers/ide/ppc/mpc8xx.c --- a/drivers/ide/ppc/mpc8xx.c Tue Mar 4 19:30:14 2003 +++ b/drivers/ide/ppc/mpc8xx.c Tue Mar 4 19:30:14 2003 @@ -331,7 +331,7 @@ (0x80000000 >> ioport_dsc[data_port].irq); #ifdef CONFIG_IDE_8xx_PCCARD - /* Make sure we dont get garbage irq */ + /* Make sure we don't get garbage irq */ ((immap_t *) IMAP_ADDR)->im_pcmcia.pcmc_pscr = 0xFFFF; /* Enable falling edge irq */ diff -Nru a/drivers/ide/ppc/pmac.c b/drivers/ide/ppc/pmac.c --- a/drivers/ide/ppc/pmac.c Tue Mar 4 19:30:04 2003 +++ b/drivers/ide/ppc/pmac.c Tue Mar 4 19:30:04 2003 @@ -1400,7 +1400,7 @@ * to system memory when the disk interrupt occurs. * * The trick here is to increment drive->waiting_for_dma, - * and return as if no interrupt occured. If the counter + * and return as if no interrupt occurred. If the counter * reach a certain timeout value, we then return 1. If * we really got the interrupt, it will happen right away * again. diff -Nru a/drivers/ide/setup-pci.c b/drivers/ide/setup-pci.c --- a/drivers/ide/setup-pci.c Tue Mar 4 19:30:07 2003 +++ b/drivers/ide/setup-pci.c Tue Mar 4 19:30:07 2003 @@ -470,7 +470,7 @@ * @hwif: Hardware interface we are configuring * * Set up the DMA base for the interface. Enable the master bits as - * neccessary and attempt to bring the device DMA into a ready to use + * necessary and attempt to bring the device DMA into a ready to use * state */ @@ -573,7 +573,7 @@ * @index: ata index to update * * Scan the interfaces attached to this device and do any - * neccessary per port setup. Attach the devices and ask the + * necessary per port setup. Attach the devices and ask the * generic DMA layer to do its work for us. * * Normally called automaticall from do_ide_pci_setup_device, diff -Nru a/drivers/ieee1394/Makefile b/drivers/ieee1394/Makefile --- a/drivers/ieee1394/Makefile Tue Mar 4 19:30:14 2003 +++ b/drivers/ieee1394/Makefile Tue Mar 4 19:30:14 2003 @@ -18,13 +18,6 @@ clean-files := oui.c -ieee1394.o: $(ieee1394-objs) - $(LD) $(LDFLAGS) -r -o $@ $(ieee1394-objs) - -ifeq ($(obj),) -obj = . -endif - $(obj)/oui.o: $(obj)/oui.c $(obj)/oui.c: $(obj)/oui.db $(obj)/oui2c.sh $(CONFIG_SHELL) $(obj)/oui2c.sh < $(obj)/oui.db > $(obj)/oui.c diff -Nru a/drivers/ieee1394/amdtp.c b/drivers/ieee1394/amdtp.c --- a/drivers/ieee1394/amdtp.c Tue Mar 4 19:30:10 2003 +++ b/drivers/ieee1394/amdtp.c Tue Mar 4 19:30:10 2003 @@ -74,6 +74,8 @@ #include #include #include +#include +#include #include #include @@ -228,7 +230,7 @@ /* The cycle_count and cycle_offset fields are used for the * synchronization timestamps (syt) in the cip header. They * are incremented by at least a cycle every time we put a - * time stamp in a packet. As we dont time stamp all + * time stamp in a packet. As we don't time stamp all * packages, cycle_count isn't updated in every cycle, and * sometimes it's incremented by 2. Thus, we have * cycle_count2, which is simply incremented by one with each @@ -748,7 +750,7 @@ /* This next addition should be modulo 8000 (0x1f40), * but we only use the lower 4 bits of cycle_count, so - * we dont need the modulo. */ + * we don't need the modulo. */ atomic_add(s->cycle_offset.integer / 3072, &s->cycle_count); s->cycle_offset.integer %= 3072; } @@ -1262,8 +1264,11 @@ static int __init amdtp_init_module (void) { - if (ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_AMDTP, - THIS_MODULE, &amdtp_fops)) { + int ret; + + ret = ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_AMDTP, + THIS_MODULE, &amdtp_fops); + if (ret) { HPSB_ERR("amdtp: unable to get minor device block"); return -EIO; } @@ -1276,6 +1281,15 @@ return -EIO; } +#ifdef CONFIG_COMPAT + ret = register_ioctl32_conversion(AMDTP_IOC_CHANNEL, NULL); + ret |= register_ioctl32_conversion(AMDTP_IOC_PLUG, NULL); + ret |= register_ioctl32_conversion(AMDTP_IOC_PING, NULL); + ret |= register_ioctl32_conversion(AMDTP_IOC_ZAP, NULL); + if (ret) + HPSB_ERR("amdtp: Error registering ioctl32 translations"); +#endif + HPSB_INFO("Loaded AMDTP driver"); return 0; @@ -1283,6 +1297,17 @@ static void __exit amdtp_exit_module (void) { +#ifdef CONFIG_COMPAT + int ret; + + ret = unregister_ioctl32_conversion(AMDTP_IOC_CHANNEL); + ret |= unregister_ioctl32_conversion(AMDTP_IOC_PLUG); + ret |= unregister_ioctl32_conversion(AMDTP_IOC_PING); + ret |= unregister_ioctl32_conversion(AMDTP_IOC_ZAP); + if (ret) + HPSB_ERR("amdtp: Error unregistering ioctl32 translations"); +#endif + hpsb_unregister_highlevel(amdtp_highlevel); ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_AMDTP); diff -Nru a/drivers/ieee1394/dma.c b/drivers/ieee1394/dma.c --- a/drivers/ieee1394/dma.c Tue Mar 4 19:30:09 2003 +++ b/drivers/ieee1394/dma.c Tue Mar 4 19:30:09 2003 @@ -10,6 +10,7 @@ #include #include #include +#include #include "dma.h" /* dma_prog_region */ diff -Nru a/drivers/ieee1394/dv1394-private.h b/drivers/ieee1394/dv1394-private.h --- a/drivers/ieee1394/dv1394-private.h Tue Mar 4 19:30:10 2003 +++ b/drivers/ieee1394/dv1394-private.h Tue Mar 4 19:30:10 2003 @@ -488,7 +488,7 @@ struct frame *frames[DV1394_MAX_FRAMES]; /* n_frames also serves as an indicator that this struct video_card is - intialized and ready to run DMA buffers */ + initialized and ready to run DMA buffers */ int n_frames; diff -Nru a/drivers/ieee1394/dv1394.c b/drivers/ieee1394/dv1394.c --- a/drivers/ieee1394/dv1394.c Tue Mar 4 19:30:11 2003 +++ b/drivers/ieee1394/dv1394.c Tue Mar 4 19:30:11 2003 @@ -111,6 +111,8 @@ #include #include #include +#include +#include #include "ieee1394.h" #include "ieee1394_types.h" @@ -2701,7 +2703,7 @@ struct ti_ohci *ohci; struct video_card *video = NULL; unsigned long flags; - struct list_head *lh; + struct list_head *lh, *templh; char buf[32]; int n; @@ -2715,7 +2717,7 @@ /* find the corresponding video_cards */ spin_lock_irqsave(&dv1394_cards_lock, flags); if(!list_empty(&dv1394_cards)) { - list_for_each(lh, &dv1394_cards) { + list_for_each_safe(lh, templh, &dv1394_cards) { video = list_entry(lh, struct video_card, list); if((video->id >> 2) == ohci->id) dv1394_un_init(video); @@ -2907,6 +2909,98 @@ .host_reset = dv1394_host_reset, }; +#ifdef CONFIG_COMPAT + +#define DV1394_IOC32_INIT _IOW('#', 0x06, struct dv1394_init32) +#define DV1394_IOC32_GET_STATUS _IOR('#', 0x0c, struct dv1394_status32) + +struct dv1394_init32 { + u32 api_version; + u32 channel; + u32 n_frames; + u32 format; + u32 cip_n; + u32 cip_d; + u32 syt_offset; +}; + +struct dv1394_status32 { + struct dv1394_init32 init; + s32 active_frame; + u32 first_clear_frame; + u32 n_clear_frames; + u32 dropped_frames; +}; + +static int handle_dv1394_init(unsigned int fd, unsigned int cmd, unsigned long arg, + struct file *file) +{ + struct dv1394_init32 dv32; + struct dv1394_init dv; + mm_segment_t old_fs; + int ret; + + if (file->f_op->ioctl != dv1394_ioctl) + return -EFAULT; + + if (copy_from_user(&dv32, (void *)arg, sizeof(dv32))) + return -EFAULT; + + dv.api_version = dv32.api_version; + dv.channel = dv32.channel; + dv.n_frames = dv32.n_frames; + dv.format = dv32.format; + dv.cip_n = (unsigned long)dv32.cip_n; + dv.cip_d = (unsigned long)dv32.cip_d; + dv.syt_offset = dv32.syt_offset; + + old_fs = get_fs(); + set_fs(KERNEL_DS); + ret = dv1394_ioctl(file->f_dentry->d_inode, file, + DV1394_IOC_INIT, (unsigned long)&dv); + set_fs(old_fs); + + return ret; +} + +static int handle_dv1394_get_status(unsigned int fd, unsigned int cmd, unsigned long arg, + struct file *file) +{ + struct dv1394_status32 dv32; + struct dv1394_status dv; + mm_segment_t old_fs; + int ret; + + if (file->f_op->ioctl != dv1394_ioctl) + return -EFAULT; + + old_fs = get_fs(); + set_fs(KERNEL_DS); + ret = dv1394_ioctl(file->f_dentry->d_inode, file, + DV1394_IOC_GET_STATUS, (unsigned long)&dv); + set_fs(old_fs); + + if (!ret) { + dv32.init.api_version = dv.init.api_version; + dv32.init.channel = dv.init.channel; + dv32.init.n_frames = dv.init.n_frames; + dv32.init.format = dv.init.format; + dv32.init.cip_n = (u32)dv.init.cip_n; + dv32.init.cip_d = (u32)dv.init.cip_d; + dv32.init.syt_offset = dv.init.syt_offset; + dv32.active_frame = dv.active_frame; + dv32.first_clear_frame = dv.first_clear_frame; + dv32.n_clear_frames = dv.n_clear_frames; + dv32.dropped_frames = dv.dropped_frames; + + if (copy_to_user((struct dv1394_status32 *)arg, &dv32, sizeof(dv32))) + ret = -EFAULT; + } + + return ret; +} +#endif /* CONFIG_COMPAT */ + /*** KERNEL MODULE HANDLERS ************************************************/ @@ -2917,6 +3011,20 @@ static void __exit dv1394_exit_module(void) { +#ifdef CONFIG_COMPAT + int ret; + + ret = unregister_ioctl32_conversion(DV1394_IOC_SHUTDOWN); + ret |= unregister_ioctl32_conversion(DV1394_IOC_SUBMIT_FRAMES); + ret |= unregister_ioctl32_conversion(DV1394_IOC_WAIT_FRAMES); + ret |= unregister_ioctl32_conversion(DV1394_IOC_RECEIVE_FRAMES); + ret |= unregister_ioctl32_conversion(DV1394_IOC_START_RECEIVE); + ret |= unregister_ioctl32_conversion(DV1394_IOC32_INIT); + ret |= unregister_ioctl32_conversion(DV1394_IOC32_GET_STATUS); + if (ret) + printk(KERN_ERR "dv1394: Error unregistering ioctl32 translations\n"); +#endif + hpsb_unregister_highlevel (hl_handle); ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_DV1394); #ifdef CONFIG_DEVFS_FS @@ -2929,14 +3037,18 @@ static int __init dv1394_init_module(void) { - if (ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_DV1394, - THIS_MODULE, &dv1394_fops)) { + int ret; + + ret = ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_DV1394, + THIS_MODULE, &dv1394_fops); + if (ret) { printk(KERN_ERR "dv1394: unable to register character device\n"); return -EIO; } #ifdef CONFIG_DEVFS_FS - if (dv1394_devfs_add_dir("dv", NULL, NULL) < 0) { + ret = dv1394_devfs_add_dir("dv", NULL, NULL); + if (ret < 0) { printk(KERN_ERR "dv1394: unable to create /dev/ieee1394/dv\n"); ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_DV1394); return -ENOMEM; @@ -2944,7 +3056,8 @@ #endif #ifdef CONFIG_PROC_FS - if (dv1394_procfs_add_dir("dv",NULL,NULL) < 0) { + ret = dv1394_procfs_add_dir("dv",NULL,NULL); + if (ret < 0) { printk(KERN_ERR "dv1394: unable to create /proc/bus/ieee1394/dv\n"); ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_DV1394); #ifdef CONFIG_DEVFS_FS @@ -2967,9 +3080,23 @@ return -ENOMEM; } +#ifdef CONFIG_COMPAT + /* First compatible ones */ + ret = register_ioctl32_conversion(DV1394_IOC_SHUTDOWN, NULL); + ret |= register_ioctl32_conversion(DV1394_IOC_SUBMIT_FRAMES, NULL); + ret |= register_ioctl32_conversion(DV1394_IOC_WAIT_FRAMES, NULL); + ret |= register_ioctl32_conversion(DV1394_IOC_RECEIVE_FRAMES, NULL); + ret |= register_ioctl32_conversion(DV1394_IOC_START_RECEIVE, NULL); + + /* These need to be handled by translation */ + ret |= register_ioctl32_conversion(DV1394_IOC32_INIT, handle_dv1394_init); + ret |= register_ioctl32_conversion(DV1394_IOC32_GET_STATUS, handle_dv1394_get_status); + if (ret) + printk(KERN_ERR "dv1394: Error registering ioctl32 translations\n"); +#endif + return 0; } module_init(dv1394_init_module); module_exit(dv1394_exit_module); - diff -Nru a/drivers/ieee1394/eth1394.c b/drivers/ieee1394/eth1394.c --- a/drivers/ieee1394/eth1394.c Tue Mar 4 19:30:10 2003 +++ b/drivers/ieee1394/eth1394.c Tue Mar 4 19:30:10 2003 @@ -65,6 +65,7 @@ #include "ieee1394_transactions.h" #include "ieee1394.h" #include "highlevel.h" +#include "iso.h" #include "eth1394.h" #define ETH1394_PRINT_G(level, fmt, args...) \ @@ -77,7 +78,7 @@ printk(KERN_ERR fmt, ## args) static char version[] __devinitdata = - "$Rev: 770 $ Ben Collins "; + "$Rev: 806 $ Ben Collins "; /* Our ieee1394 highlevel driver */ #define ETHER1394_DRIVER_NAME "ether1394" @@ -101,6 +102,9 @@ MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)"); MODULE_LICENSE("GPL"); +static void ether1394_iso(struct hpsb_iso *iso); + + /* Find our host_info struct for a given host pointer. Must be called * under spinlock. */ static inline struct host_info *find_host_info (struct hpsb_host *host) @@ -178,15 +182,26 @@ * XXX: This is where we need to create a list of skb's for fragmented * packets. */ static inline void ether1394_encapsulate (struct sk_buff *skb, struct net_device *dev, - int proto) + int proto, struct packet_task *ptask) { union eth1394_hdr *hdr = (union eth1394_hdr *)skb_push (skb, hdr_type_len[ETH1394_HDR_LF_UF]); + hdr->words.word1 = 0; hdr->common.lf = ETH1394_HDR_LF_UF; hdr->words.word1 = htons(hdr->words.word1); hdr->uf.ether_type = proto; + /* Set the transmission type for the packet. Right now only ARP + * packets are sent via GASP. IP broadcast and IP multicast are not + * yet supported properly, they too should use GASP. */ + switch(proto) { + case __constant_htons(ETH_P_ARP): + ptask->tx_type = ETH1394_GASP; + break; + default: + ptask->tx_type = ETH1394_WRREQ; + } return; } @@ -199,14 +214,14 @@ { struct eth1394_priv *priv = (struct eth1394_priv *)(dev->priv); - u16 phy_id = priv->host->node_id & NODE_MASK; + u16 phy_id = NODEID_TO_NODE(priv->host->node_id); unsigned char *arp_ptr = (unsigned char *)skb->data; struct eth1394_arp *arp1394 = (struct eth1394_arp *)skb->data; unsigned char arp_data[2*(dev->addr_len+4)]; /* Copy the main data that we need */ - arp_ptr = memcpy (arp_data, arp_ptr + sizeof(struct arphdr), sizeof (arp_data)); + memcpy (arp_data, arp_ptr + sizeof(struct arphdr), sizeof (arp_data)); /* Extend the buffer enough for our new header */ skb_put (skb, sizeof (struct eth1394_arp) - @@ -214,7 +229,7 @@ #define PROCESS_MEMBER(ptr,val,len) \ memcpy (val, ptr, len); ptr += len - arp_ptr += arp1394->hw_addr_len; + arp_ptr = arp_data + arp1394->hw_addr_len; PROCESS_MEMBER (arp_ptr, &arp1394->sip, arp1394->ip_addr_len); arp_ptr += arp1394->hw_addr_len; PROCESS_MEMBER (arp_ptr, &arp1394->tip, arp1394->ip_addr_len); @@ -279,7 +294,8 @@ { unsigned long flags; struct eth1394_priv *priv = (struct eth1394_priv *)dev->priv; - int phy_id = priv->host->node_id & NODE_MASK; + int phy_id = NODEID_TO_NODE(priv->host->node_id); + struct hpsb_host *host = priv->host; spin_lock_irqsave (&priv->lock, flags); @@ -289,20 +305,23 @@ memset (priv->fifo_hi, 0, sizeof (priv->fifo_hi)); memset (priv->fifo_lo, 0, sizeof (priv->fifo_lo)); + priv->bc_state = ETHER1394_BC_CHECK; + /* Register our limits now */ - ether1394_register_limits (phy_id, (be32_to_cpu(priv->host->csr.rom[2]) >> 12) & 0xf, - priv->host->speed_map[(phy_id << 6) + phy_id], - (u64)(((u64)be32_to_cpu(priv->host->csr.rom[3]) << 32) | - be32_to_cpu(priv->host->csr.rom[4])), + ether1394_register_limits (phy_id, (be32_to_cpu(host->csr.rom[2]) >> 12) & 0xf, + host->speed_map[(phy_id << 6) + phy_id], + (u64)(((u64)be32_to_cpu(host->csr.rom[3]) << 32) | + be32_to_cpu(host->csr.rom[4])), ETHER1394_REGION_ADDR >> 32, ETHER1394_REGION_ADDR & 0xffffffff, priv); /* We'll use our max_rec as the default mtu */ if (set_mtu) - dev->mtu = (1 << (priv->max_rec[phy_id] + 1)) - sizeof (union eth1394_hdr); + dev->mtu = (1 << (priv->max_rec[phy_id] + 1)) - /* mtu = max_rec - */ + (sizeof (union eth1394_hdr) + 8); /* (hdr + GASP) */ /* Set our hardware address while we're at it */ - *(nodeid_t *)dev->dev_addr = htons (priv->host->node_id); + *(nodeid_t *)dev->dev_addr = htons (host->node_id); spin_unlock_irqrestore (&priv->lock, flags); } @@ -383,6 +402,15 @@ list_add_tail (&hi->list, &host_info_list); spin_unlock_irq (&host_info_lock); + /* Ignore validity in hopes that it will be set in the future. It'll + * check it on transmit. */ + priv->broadcast_channel = host->csr.broadcast_channel & 0x3f; + + priv->iso = hpsb_iso_recv_init(host, 8 * 4096, 8, priv->broadcast_channel, + 1, ether1394_iso); + if (priv->iso == NULL) { + priv->bc_state = ETHER1394_BC_CLOSED; + } return; out: @@ -396,11 +424,14 @@ /* Remove a card from our list */ static void ether1394_remove_host (struct hpsb_host *host) { + struct eth1394_priv *priv; struct host_info *hi; spin_lock_irq (&host_info_lock); hi = find_host_info (host); if (hi != NULL) { + priv = (struct eth1394_priv *)hi->dev->priv; + priv->bc_state = ETHER1394_BC_CLOSED; unregister_netdev (hi->dev); kfree (hi->dev); list_del (&hi->list); @@ -480,7 +511,7 @@ * about the sending machine. */ if (hdr->uf.ether_type == __constant_htons (ETH_P_ARP)) { unsigned long flags; - u16 phy_id = srcid & NODE_MASK; + u16 phy_id = NODEID_TO_NODE(srcid); struct eth1394_priv *priv = (struct eth1394_priv *)dev->priv; struct eth1394_arp arp1394; @@ -498,7 +529,7 @@ spin_unlock_irqrestore (&priv->lock, flags); #define PROCESS_MEMBER(ptr,val,len) \ - ptr = memcpy (ptr, val, len) + len + memcpy (ptr, val, len); ptr += len PROCESS_MEMBER (arp_ptr, src_hw, dev->addr_len); PROCESS_MEMBER (arp_ptr, &arp1394.sip, 4); PROCESS_MEMBER (arp_ptr, dest_hw, dev->addr_len); @@ -591,6 +622,104 @@ return RCODE_COMPLETE; } +static void ether1394_iso(struct hpsb_iso *iso) +{ + struct sk_buff *skb; + quadlet_t *data; + char *buf; + int flags; + struct net_device *dev = ether1394_find_dev(iso->host); + struct eth1394_priv *priv; + unsigned int len; + u32 specifier_id; + u16 source_id; + int i; + int nready; + + if (dev == NULL) { + ETH1394_PRINT_G (KERN_ERR, "Could not find net device for host %s\n", + iso->host->driver->name); + return; + } + + nready = hpsb_iso_n_ready(iso); + for(i = 0; i < nready; i++) { + struct hpsb_iso_packet_info *info = &iso->infos[iso->first_packet + i]; + data = (quadlet_t*) (iso->data_buf.kvirt + info->offset); + + /* skip over GASP header */ + buf = (char *)data + 8; + len = info->len - 8; + + specifier_id = (((be32_to_cpu(data[0]) & 0xffff) << 8) | + ((be32_to_cpu(data[1]) & 0xff000000) >> 24)); + source_id = be32_to_cpu(data[0]) >> 16; + + priv = (struct eth1394_priv *)dev->priv; + + if (info->channel != priv->broadcast_channel || + specifier_id != ETHER1394_GASP_SPECIFIER_ID) { + /* This packet is not for us */ + continue; + } + + /* A packet has been received by the ieee1394 bus. Build an skbuff + * around it so we can pass it to the high level network layer. */ + skb = dev_alloc_skb (len + dev->hard_header_len + 15); + if (!skb) { + HPSB_PRINT (KERN_ERR, "ether1394 rx: low on mem\n"); + priv->stats.rx_dropped++; + break; + } + + skb_reserve(skb, (dev->hard_header_len + 15) & ~15); + + memcpy (skb_put (skb, len), buf, len); + + /* Write metadata, and then pass to the receive level */ + skb->dev = dev; + skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */ + + /* Parse the encapsulation header. This actually does the job of + * converting to an ethernet frame header, aswell as arp + * conversion if needed. ARP conversion is easier in this + * direction, since we are using ethernet as our backend. */ + skb->protocol = ether1394_parse_encap (skb, dev, source_id, + LOCAL_BUS | ALL_NODES); + + spin_lock_irqsave (&priv->lock, flags); + if (!skb->protocol) { + priv->stats.rx_errors++; + priv->stats.rx_dropped++; + dev_kfree_skb_any(skb); + goto bad_proto; + } + + netif_stop_queue(dev); + if (netif_rx (skb) == NET_RX_DROP) { + priv->stats.rx_errors++; + priv->stats.rx_dropped++; + goto bad_proto; + } + + /* Statistics */ + priv->stats.rx_packets++; + priv->stats.rx_bytes += skb->len; + + bad_proto: + spin_unlock_irqrestore (&priv->lock, flags); + } + + hpsb_iso_recv_release_packets(iso, i); + + netif_start_queue(dev); + + dev->last_rx = jiffies; + + return; +} + + /* This function is our scheduled write */ static void hpsb_write_sched (void *__ptask) { @@ -598,13 +727,26 @@ struct sk_buff *skb = ptask->skb; struct net_device *dev = ptask->skb->dev; struct eth1394_priv *priv = (struct eth1394_priv *)dev->priv; - unsigned long flags; + unsigned long flags; + int status; + + if (ptask->tx_type == ETH1394_GASP) { + status = hpsb_send_gasp(priv->host, priv->broadcast_channel, + get_hpsb_generation(priv->host), + (quadlet_t *)skb->data, skb->len, + ETHER1394_GASP_SPECIFIER_ID, + ETHER1394_GASP_VERSION); + } else { + status = hpsb_write(priv->host, ptask->dest_node, + get_hpsb_generation(priv->host), + ptask->addr, (quadlet_t *)skb->data, + skb->len); + } + /* Statistics */ spin_lock_irqsave (&priv->lock, flags); - if (!hpsb_write(priv->host, ptask->dest_node, - get_hpsb_generation(priv->host), - ptask->addr, (quadlet_t *)skb->data, skb->len)) { + if (!status) { priv->stats.tx_bytes += skb->len; priv->stats.tx_packets++; } else { @@ -636,6 +778,67 @@ struct packet_task *ptask = NULL; int ret = 0; + spin_lock_irqsave (&priv->lock, flags); + if (priv->bc_state == ETHER1394_BC_CLOSED) { + ETH1394_PRINT(KERN_ERR, dev->name, + "Cannot send packet, no broadcast channel available."); + ret = -EAGAIN; + goto fail; + } + + /* First time sending? Need a broadcast channel for ARP and for + * listening on */ + if (priv->bc_state == ETHER1394_BC_CHECK) { + quadlet_t bc; + + /* Get the local copy of the broadcast channel and check its + * validity (the IRM should validate it for us) */ + + bc = priv->host->csr.broadcast_channel; + + if ((bc & 0xc0000000) != 0xc0000000) { + /* broadcast channel not validated yet */ + ETH1394_PRINT(KERN_WARNING, dev->name, + "Error BROADCAST_CHANNEL register valid " + "bit not set, can't send IP traffic\n"); + hpsb_iso_shutdown(priv->iso); + priv->bc_state = ETHER1394_BC_CLOSED; + ret = -EAGAIN; + spin_unlock_irqrestore (&priv->lock, flags); + goto fail; + } + if (priv->broadcast_channel != (bc & 0x3f)) { + /* This really shouldn't be possible, but just in case + * the IEEE 1394 spec changes regarding broadcast + * channels in the future. */ + hpsb_iso_shutdown(priv->iso); + + priv->broadcast_channel = bc & 0x3f; + ETH1394_PRINT(KERN_WARNING, dev->name, + "Changing to broadcast channel %d...\n", + priv->broadcast_channel); + + priv->iso = hpsb_iso_recv_init(priv->host, 8 * 4096, + 8, priv->broadcast_channel, + 1, ether1394_iso); + if (priv->iso == NULL) { + ret = -EAGAIN; + goto fail; + } + } + if (hpsb_iso_recv_start(priv->iso, -1, (1 << 3), -1) < 0) { + ETH1394_PRINT(KERN_ERR, dev->name, + "Could not start async reception\n"); + hpsb_iso_shutdown(priv->iso); + priv->bc_state = ETHER1394_BC_CLOSED; + ret = -EAGAIN; + spin_unlock_irqrestore (&priv->lock, flags); + goto fail; + } + priv->bc_state = ETHER1394_BC_OPENED; + } + spin_unlock_irqrestore (&priv->lock, flags); + if ((skb = skb_share_check (skb, kmflags)) == NULL) { ret = -ENOMEM; goto fail; @@ -654,8 +857,14 @@ if (proto == __constant_htons (ETH_P_ARP)) ether1394_arp_to_1394arp (skb, dev); + ptask = kmem_cache_alloc(packet_task_cache, kmflags); + if (ptask == NULL) { + ret = -ENOMEM; + goto fail; + } + /* Now add our encapsulation header */ - ether1394_encapsulate (skb, dev, proto); + ether1394_encapsulate (skb, dev, proto, ptask); /* TODO: The above encapsulate function needs to recognize when a * packet needs to be split for a specified node. It should create @@ -663,23 +872,17 @@ * call to schedule our writes. */ /* XXX: Right now we accept that we don't exactly follow RFC. When - * we do, we will send ARP requests via GASP format, and so we wont + * we do, we will send ARP requests via GASP format, and so we won't * need this hack. */ spin_lock_irqsave (&priv->lock, flags); - addr = (u64)priv->fifo_hi[dest_node & NODE_MASK] << 32 | - priv->fifo_lo[dest_node & NODE_MASK]; + addr = (u64)priv->fifo_hi[NODEID_TO_NODE(dest_node)] << 32 | + priv->fifo_lo[NODEID_TO_NODE(dest_node)]; spin_unlock_irqrestore (&priv->lock, flags); if (!addr) addr = ETHER1394_REGION_ADDR; - ptask = kmem_cache_alloc(packet_task_cache, kmflags); - if (ptask == NULL) { - ret = -ENOMEM; - goto fail; - } - ptask->skb = skb; ptask->addr = addr; ptask->dest_node = dest_node; @@ -702,7 +905,7 @@ netif_wake_queue (dev); spin_unlock_irqrestore (&priv->lock, flags); - return ret; + return 0; /* returning non-zero causes serious problems */ } /* Function for incoming 1394 packets */ @@ -738,6 +941,19 @@ static void __exit ether1394_exit_module (void) { + struct list_head *lh; + struct host_info *hi; + struct eth1394_priv *priv; + + lh = host_info_list.next; + while (lh != &host_info_list) { + hi = list_entry (lh, struct host_info, list); + priv = (struct eth1394_priv*)hi->dev->priv; + if (priv->bc_state != ETHER1394_BC_CLOSED) { + hpsb_iso_shutdown(priv->iso); + } + lh = lh->next; + } hpsb_unregister_highlevel (hl_handle); kmem_cache_destroy(packet_task_cache); } diff -Nru a/drivers/ieee1394/eth1394.h b/drivers/ieee1394/eth1394.h --- a/drivers/ieee1394/eth1394.h Tue Mar 4 19:30:13 2003 +++ b/drivers/ieee1394/eth1394.h Tue Mar 4 19:30:13 2003 @@ -30,9 +30,16 @@ #define ETHER1394_REGION_ADDR 0xfffff0200000ULL #define ETHER1394_REGION_ADDR_END (ETHER1394_REGION_ADDR + ETHER1394_REGION_ADDR_LEN) +/* GASP identifier numbers for IPv4 over IEEE 1394 */ +#define ETHER1394_GASP_SPECIFIER_ID 0x00005E +#define ETHER1394_GASP_VERSION 1 + /* Node set == 64 */ #define NODE_SET (ALL_NODES + 1) +enum eth1394_bc_states { ETHER1394_BC_CLOSED, ETHER1394_BC_OPENED, + ETHER1394_BC_CHECK }; + /* Private structure for our ethernet driver */ struct eth1394_priv { struct net_device_stats stats; /* Device stats */ @@ -43,6 +50,9 @@ u32 fifo_lo[ALL_NODES]; /* 32bit lo fifo offset per node */ u64 eui[ALL_NODES]; /* EUI-64 per node */ spinlock_t lock; /* Private lock */ + int broadcast_channel; /* Async stream Broadcast Channel */ + enum eth1394_bc_states bc_state; /* broadcast channel state */ + struct hpsb_iso *iso; /* Async stream recv handle */ }; struct host_info { @@ -51,12 +61,15 @@ struct net_device *dev; }; +typedef enum {ETH1394_GASP, ETH1394_WRREQ} eth1394_tx_type; + /* This is our task struct. It's used for the packet complete callback. */ struct packet_task { struct sk_buff *skb; /* Socket buffer we are sending */ nodeid_t dest_node; /* Destination of the packet */ u64 addr; /* Address */ struct hpsb_queue_struct tq; /* The task */ + eth1394_tx_type tx_type; /* Send data via GASP or Write Req. */ }; /* IP1394 headers */ diff -Nru a/drivers/ieee1394/hosts.c b/drivers/ieee1394/hosts.c --- a/drivers/ieee1394/hosts.c Tue Mar 4 19:30:07 2003 +++ b/drivers/ieee1394/hosts.c Tue Mar 4 19:30:07 2003 @@ -71,9 +71,6 @@ list_for_each(lh, &hosts) { if (host == list_entry(lh, struct hpsb_host, host_list)) { if (try_module_get(host->driver->owner)) { - /* we're doing this twice and don't seem - to undo it.. --hch */ - (void)try_module_get(host->driver->owner); host->refcount++; retval = 1; } diff -Nru a/drivers/ieee1394/ieee1394-ioctl.h b/drivers/ieee1394/ieee1394-ioctl.h --- a/drivers/ieee1394/ieee1394-ioctl.h Tue Mar 4 19:30:04 2003 +++ b/drivers/ieee1394/ieee1394-ioctl.h Tue Mar 4 19:30:04 2003 @@ -4,8 +4,8 @@ #ifndef __IEEE1394_IOCTL_H #define __IEEE1394_IOCTL_H -#include -#include +#include +#include /* AMDTP Gets 6 */ @@ -91,7 +91,7 @@ #define RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL \ _IOW ('#', 0x23, unsigned char) #define RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK \ - _IOW ('#', 0x24, u64) + _IOW ('#', 0x24, __u64) #define RAW1394_IOC_ISO_RECV_PACKETS \ _IOW ('#', 0x25, struct raw1394_iso_packets) #define RAW1394_IOC_ISO_RECV_RELEASE_PACKETS \ diff -Nru a/drivers/ieee1394/ieee1394_core.c b/drivers/ieee1394/ieee1394_core.c --- a/drivers/ieee1394/ieee1394_core.c Tue Mar 4 19:30:05 2003 +++ b/drivers/ieee1394/ieee1394_core.c Tue Mar 4 19:30:05 2003 @@ -361,7 +361,7 @@ host->topology_map[host->selfid_count++] = sid; } else { HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d", - sid, (host->node_id & BUS_MASK) >> 6); + sid, NODEID_TO_BUS(host->node_id)); } } @@ -396,9 +396,6 @@ /* irm_id is kept up to date by check_selfids() */ if (host->irm_id == host->node_id) { host->is_irm = 1; - host->is_busmgr = 1; - host->busmgr_id = host->node_id; - host->csr.bus_manager_id = host->node_id; } else { host->is_busmgr = 0; host->is_irm = 0; @@ -535,8 +532,8 @@ if (packet->type == hpsb_async && packet->node_id != ALL_NODES) { packet->speed_code = - host->speed_map[(host->node_id & NODE_MASK) * 64 - + (packet->node_id & NODE_MASK)]; + host->speed_map[NODEID_TO_NODE(host->node_id) * 64 + + NODEID_TO_NODE(packet->node_id)]; } #ifdef CONFIG_IEEE1394_VERBOSEDEBUG @@ -748,7 +745,7 @@ addr, 4, flags); if (!write_acked - && (((data[0] >> 16) & NODE_MASK) != NODE_MASK) + && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) && (rcode >= 0)) { /* not a broadcast write, reply */ PREP_REPLY_PACKET(0); @@ -763,7 +760,7 @@ addr, data[3]>>16, flags); if (!write_acked - && (((data[0] >> 16) & NODE_MASK) != NODE_MASK) + && (NODEID_TO_NODE(data[0] >> 16) != NODE_MASK) && (rcode >= 0)) { /* not a broadcast write, reply */ PREP_REPLY_PACKET(0); @@ -1248,6 +1245,7 @@ EXPORT_SYMBOL(hpsb_write); EXPORT_SYMBOL(hpsb_lock); EXPORT_SYMBOL(hpsb_lock64); +EXPORT_SYMBOL(hpsb_send_gasp); EXPORT_SYMBOL(hpsb_packet_success); /** highlevel.c **/ diff -Nru a/drivers/ieee1394/ieee1394_transactions.c b/drivers/ieee1394/ieee1394_transactions.c --- a/drivers/ieee1394/ieee1394_transactions.c Tue Mar 4 19:30:05 2003 +++ b/drivers/ieee1394/ieee1394_transactions.c Tue Mar 4 19:30:05 2003 @@ -98,6 +98,17 @@ packet->speed_code = SPEED_100; /* Force speed to be 100Mbps */ } +static void fill_async_stream_packet(struct hpsb_packet *packet, int length, + int channel, int tag, int sync) +{ + packet->header[0] = (length << 16) | (tag << 14) | (channel << 8) + | (TCODE_STREAM_DATA << 4) | sync; + + packet->header_size = 4; + packet->data_size = length; + packet->type = hpsb_async; + packet->tcode = TCODE_ISO_DATA; +} /** * hpsb_get_tlabel - allocate a transaction label @@ -495,7 +506,6 @@ } -/* We need a hpsb_lock64 function for the 64 bit equivalent. Probably. */ int hpsb_lock(struct hpsb_host *host, nodeid_t node, unsigned int generation, u64 addr, int extcode, quadlet_t *data, quadlet_t arg) { @@ -557,4 +567,59 @@ free_hpsb_packet(packet); return retval; +} + +int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation, + quadlet_t *buffer, size_t length, u32 specifier_id, + unsigned int version) +{ +#ifdef CONFIG_IEEE1394_VERBOSEDEBUG + int i; +#endif + + struct hpsb_packet *packet; + int retval = 0; + u16 specifier_id_hi = (specifier_id & 0x00ffff00) >> 8; + u8 specifier_id_lo = specifier_id & 0xff; + +#ifdef CONFIG_IEEE1394_VERBOSEDEBUG + HPSB_DEBUG("Send GASP: channel = %d, length = %d", channel, length); +#endif + + length += 8; + + packet = alloc_hpsb_packet(length + (length % 4 ? 4 - (length % 4) : 0)); + if (!packet) + return -ENOMEM; + + if (length % 4) { + packet->data[length / 4] = 0; + } + + packet->host = host; + fill_async_stream_packet(packet, length, channel, 3, 0); + + packet->data[0] = cpu_to_be32((host->node_id << 16) | specifier_id_hi); + packet->data[1] = cpu_to_be32((specifier_id_lo << 24) | (version & 0x00ffffff)); + + memcpy(&(packet->data[2]), buffer, length - 4); + +#ifdef CONFIG_IEEE1394_VERBOSEDEBUG + HPSB_DEBUG("GASP: packet->header_size = %d", packet->header_size); + HPSB_DEBUG("GASP: packet->data_size = %d", packet->data_size); + + for(i=0; i<(packet->data_size/4); i++) + HPSB_DEBUG("GASP: data[%d]: 0x%08x", i*4, be32_to_cpu(packet->data[i])); +#endif + + packet->generation = generation; + + packet->no_waiter = 1; + + if (!hpsb_send_packet(packet)) { + free_hpsb_packet(packet); + retval = -EINVAL; + } + + return retval; } diff -Nru a/drivers/ieee1394/ieee1394_transactions.h b/drivers/ieee1394/ieee1394_transactions.h --- a/drivers/ieee1394/ieee1394_transactions.h Tue Mar 4 19:30:05 2003 +++ b/drivers/ieee1394/ieee1394_transactions.h Tue Mar 4 19:30:05 2003 @@ -55,5 +55,8 @@ u64 addr, int extcode, quadlet_t *data, quadlet_t arg); int hpsb_lock64(struct hpsb_host *host, nodeid_t node, unsigned int generation, u64 addr, int extcode, octlet_t *data, octlet_t arg); +int hpsb_send_gasp(struct hpsb_host *host, int channel, unsigned int generation, + quadlet_t *buffer, size_t length, u32 specifier_id, + unsigned int version); #endif /* _IEEE1394_TRANSACTIONS_H */ diff -Nru a/drivers/ieee1394/ieee1394_types.h b/drivers/ieee1394/ieee1394_types.h --- a/drivers/ieee1394/ieee1394_types.h Tue Mar 4 19:30:12 2003 +++ b/drivers/ieee1394/ieee1394_types.h Tue Mar 4 19:30:12 2003 @@ -97,14 +97,17 @@ typedef u16 arm_length_t; #define BUS_MASK 0xffc0 +#define BUS_SHIFT 6 #define NODE_MASK 0x003f #define LOCAL_BUS 0xffc0 #define ALL_NODES 0x003f +#define NODEID_TO_BUS(nodeid) ((nodeid & BUS_MASK) >> BUS_SHIFT) +#define NODEID_TO_NODE(nodeid) (nodeid & NODE_MASK) + /* Can be used to consistently print a node/bus ID. */ -#define NODE_BUS_FMT "%02d:%04d" -#define NODE_BUS_ARGS(nodeid) \ - (nodeid & NODE_MASK), ((nodeid & BUS_MASK) >> 6) +#define NODE_BUS_FMT "%02d:%04d" +#define NODE_BUS_ARGS(nodeid) NODEID_TO_NODE(nodeid), NODEID_TO_BUS(nodeid) #define HPSB_PRINT(level, fmt, args...) printk(level "ieee1394: " fmt "\n" , ## args) diff -Nru a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c --- a/drivers/ieee1394/nodemgr.c Tue Mar 4 19:30:10 2003 +++ b/drivers/ieee1394/nodemgr.c Tue Mar 4 19:30:10 2003 @@ -1210,6 +1210,52 @@ return; } +/* Because we are a 1394a-2000 compliant IRM, we need to inform all the other + * nodes of the broadcast channel. (Really we're only setting the validity + * bit). */ +static void nodemgr_do_irm_duties(struct hpsb_host *host) +{ + quadlet_t bc; + + if (!host->is_irm) + return; + + host->csr.broadcast_channel |= 0x40000000; /* set validity bit */ + + bc = cpu_to_be32(host->csr.broadcast_channel); + + hpsb_write(host, LOCAL_BUS | ALL_NODES, get_hpsb_generation(host), + (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL), + &bc, + sizeof(quadlet_t)); +} + +/* We need to ensure that if we are not the IRM, that the IRM node is capable of + * everything we can do, otherwise issue a bus reset and try to become the IRM + * ourselves. */ +static int nodemgr_check_root_capability(struct hpsb_host *host) +{ + quadlet_t bc; + int status; + + if (host->is_irm) + return 1; + + status = hpsb_read(host, LOCAL_BUS | (host->irm_id), + get_hpsb_generation(host), + (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL), + &bc, sizeof(quadlet_t)); + + if (status < 0 || !(be32_to_cpu(bc) & 0x80000000)) { + /* The root node does not have a valid BROADCAST_CHANNEL + * register and we do, so reset the bus with force_root set */ + HPSB_INFO("Remote root is not IRM capable, resetting..."); + hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT); + return 0; + } + return 1; +} + static int nodemgr_host_thread(void *__hi) { struct host_info *hi = (struct host_info *)__hi; @@ -1217,12 +1263,21 @@ /* No userlevel access needed */ daemonize("knodemgrd"); allow_signal(SIGTERM); - + /* Sit and wait for a signal to probe the nodes on the bus. This * happens when we get a bus reset. */ while (!down_interruptible(&hi->reset_sem) && !down_interruptible(&nodemgr_serialize)) { + + if (!nodemgr_check_root_capability(hi->host)) { + /* Do nothing, we are resetting */ + up(&nodemgr_serialize); + continue; + } + nodemgr_node_probe(hi->host); + nodemgr_do_irm_duties(hi->host); + up(&nodemgr_serialize); } #ifdef CONFIG_IEEE1394_VERBOSEDEBUG diff -Nru a/drivers/ieee1394/ohci1394.c b/drivers/ieee1394/ohci1394.c --- a/drivers/ieee1394/ohci1394.c Tue Mar 4 19:30:13 2003 +++ b/drivers/ieee1394/ohci1394.c Tue Mar 4 19:30:13 2003 @@ -31,9 +31,9 @@ * * Things implemented, but still in test phase: * . Iso Transmit + * . Async Stream Packets Transmit (Receive done via Iso interface) * * Things not implemented: - * . Async Stream Packets * . DMA error recovery * * Known bugs: @@ -160,7 +160,7 @@ printk(level "%s_%d: " fmt "\n" , OHCI1394_DRIVER_NAME, card , ## args) static char version[] __devinitdata = - "$Rev: 762 $ Ben Collins "; + "$Rev: 801 $ Ben Collins "; /* Module Parameters */ MODULE_PARM(phys_dma,"i"); @@ -649,18 +649,31 @@ } else { d->prg_cpu[idx]->data[0] = packet->speed_code<<16 | (packet->header[0] & 0xFFFF); - d->prg_cpu[idx]->data[1] = - (packet->header[1] & 0xFFFF) | - (packet->header[0] & 0xFFFF0000); - d->prg_cpu[idx]->data[2] = packet->header[2]; - d->prg_cpu[idx]->data[3] = packet->header[3]; + + if (packet->tcode == TCODE_ISO_DATA) { + /* Sending an async stream packet */ + d->prg_cpu[idx]->data[1] = packet->header[0] & 0xFFFF0000; + } else { + /* Sending a normal async request or response */ + d->prg_cpu[idx]->data[1] = + (packet->header[1] & 0xFFFF) | + (packet->header[0] & 0xFFFF0000); + d->prg_cpu[idx]->data[2] = packet->header[2]; + d->prg_cpu[idx]->data[3] = packet->header[3]; + } packet_swab(d->prg_cpu[idx]->data, packet->tcode); } if (packet->data_size) { /* block transmit */ - d->prg_cpu[idx]->begin.control = - cpu_to_le32(DMA_CTL_OUTPUT_MORE | - DMA_CTL_IMMEDIATE | 0x10); + if (packet->tcode == TCODE_STREAM_DATA){ + d->prg_cpu[idx]->begin.control = + cpu_to_le32(DMA_CTL_OUTPUT_MORE | + DMA_CTL_IMMEDIATE | 0x8); + } else { + d->prg_cpu[idx]->begin.control = + cpu_to_le32(DMA_CTL_OUTPUT_MORE | + DMA_CTL_IMMEDIATE | 0x10); + } d->prg_cpu[idx]->end.control = cpu_to_le32(DMA_CTL_OUTPUT_LAST | DMA_CTL_IRQ | @@ -827,10 +840,10 @@ return 0; } - /* Decide wether we have an iso, a request, or a response packet */ + /* Decide whether we have an iso, a request, or a response packet */ if (packet->type == hpsb_raw) d = &ohci->at_req_context; - else if (packet->tcode == TCODE_ISO_DATA) { + else if ((packet->tcode == TCODE_ISO_DATA) && (packet->type == hpsb_iso)) { /* The legacy IT DMA context is initialized on first * use. However, the alloc cannot be run from * interrupt context, so we bail out if that is the @@ -856,7 +869,7 @@ } d = &ohci->it_legacy_context; - } else if (packet->tcode & 0x02) + } else if ((packet->tcode & 0x02) && (packet->tcode != TCODE_ISO_DATA)) d = &ohci->at_resp_context; else d = &ohci->at_req_context; @@ -1295,6 +1308,8 @@ u32 *prev_branch = NULL; for (blk = 0; blk < recv->nblocks; blk++) { + u32 control; + /* the DMA descriptor */ struct dma_cmd *cmd = &recv->block[blk]; @@ -1305,29 +1320,29 @@ unsigned long buf_offset = blk * recv->buf_stride; if (recv->dma_mode == BUFFER_FILL_MODE) { - cmd->control = 2 << 28; /* INPUT_MORE */ + control = 2 << 28; /* INPUT_MORE */ } else { - cmd->control = 3 << 28; /* INPUT_LAST */ + control = 3 << 28; /* INPUT_LAST */ } - cmd->control |= 8 << 24; /* s = 1, update xferStatus and resCount */ + control |= 8 << 24; /* s = 1, update xferStatus and resCount */ /* interrupt on last block, and at intervals */ if (blk == recv->nblocks-1 || (blk % recv->block_irq_interval) == 0) { - cmd->control |= 3 << 20; /* want interrupt */ + control |= 3 << 20; /* want interrupt */ } - cmd->control |= 3 << 18; /* enable branch to address */ - cmd->control |= recv->buf_stride; + control |= 3 << 18; /* enable branch to address */ + control |= recv->buf_stride; - cmd->address = dma_region_offset_to_bus(&iso->data_buf, buf_offset); + cmd->control = cpu_to_le32(control); + cmd->address = cpu_to_le32(dma_region_offset_to_bus(&iso->data_buf, buf_offset)); cmd->branchAddress = 0; /* filled in on next loop */ - cmd->status = recv->buf_stride; + cmd->status = cpu_to_le32(recv->buf_stride); /* link the previous descriptor to this one */ if (prev_branch) { - *prev_branch = dma_prog_region_offset_to_bus(&recv->prog, prog_offset); - *prev_branch |= 1; /* set Z=1 */ + *prev_branch = cpu_to_le32(dma_prog_region_offset_to_bus(&recv->prog, prog_offset) | 1); } prev_branch = &cmd->branchAddress; @@ -1485,18 +1500,18 @@ /* 'next' becomes the new end of the DMA chain, so disable branch and enable interrupt */ next->branchAddress = 0; - next->control |= 3 << 20; + next->control |= cpu_to_le32(3 << 20); /* link prev to next */ - prev->branchAddress = dma_prog_region_offset_to_bus(&recv->prog, - sizeof(struct dma_cmd) * next_i) - | 1; /* Z=1 */ + prev->branchAddress = cpu_to_le32(dma_prog_region_offset_to_bus(&recv->prog, + sizeof(struct dma_cmd) * next_i) + | 1); /* Z=1 */ /* disable interrupt on previous DMA descriptor, except at intervals */ if((prev_i % recv->block_irq_interval) == 0) { - prev->control |= 3 << 20; /* enable interrupt */ + prev->control |= cpu_to_le32(3 << 20); /* enable interrupt */ } else { - prev->control &= ~(3<<20); /* disable interrupt */ + prev->control &= cpu_to_le32(~(3<<20)); /* disable interrupt */ } wmb(); @@ -1720,8 +1735,8 @@ struct dma_cmd *il = ((struct dma_cmd*) recv->prog.kvirt) + iso->pkt_dma; /* check the DMA descriptor for new writes to xferStatus */ - u16 xferstatus = il->status >> 16; - u16 rescount = il->status & 0xFFFF; + u16 xferstatus = le32_to_cpu(il->status) >> 16; + u16 rescount = le32_to_cpu(il->status) & 0xFFFF; unsigned char event = xferstatus & 0x1F; @@ -1903,7 +1918,7 @@ struct iso_xmit_cmd *cmd = dma_region_i(&xmit->prog, struct iso_xmit_cmd, iso->pkt_dma); /* check for new writes to xferStatus */ - u16 xferstatus = cmd->output_last.status >> 16; + u16 xferstatus = le32_to_cpu(cmd->output_last.status) >> 16; u8 event = xferstatus & 0x1F; if(!event) { @@ -1919,7 +1934,7 @@ wake = 1; /* parse cycle */ - cycle = cmd->output_last.status & 0x1FFF; + cycle = le32_to_cpu(cmd->output_last.status) & 0x1FFF; /* tell the subsystem the packet has gone out */ hpsb_iso_packet_sent(iso, cycle, event != 0x11); @@ -1972,7 +1987,7 @@ /* set up the OUTPUT_MORE_IMMEDIATE descriptor */ memset(next, 0, sizeof(struct iso_xmit_cmd)); - next->output_more_immediate.control = 0x02000008; + next->output_more_immediate.control = cpu_to_le32(0x02000008); /* ISO packet header is embedded in the OUTPUT_MORE_IMMEDIATE */ @@ -1990,28 +2005,28 @@ next->iso_hdr[7] = len >> 8; /* set up the OUTPUT_LAST */ - next->output_last.control = 1 << 28; - next->output_last.control |= 1 << 27; /* update timeStamp */ - next->output_last.control |= 3 << 20; /* want interrupt */ - next->output_last.control |= 3 << 18; /* enable branch */ - next->output_last.control |= len; + next->output_last.control = cpu_to_le32(1 << 28); + next->output_last.control |= cpu_to_le32(1 << 27); /* update timeStamp */ + next->output_last.control |= cpu_to_le32(3 << 20); /* want interrupt */ + next->output_last.control |= cpu_to_le32(3 << 18); /* enable branch */ + next->output_last.control |= cpu_to_le32(len); /* payload bus address */ - next->output_last.address = dma_region_offset_to_bus(&iso->data_buf, offset); + next->output_last.address = cpu_to_le32(dma_region_offset_to_bus(&iso->data_buf, offset)); /* leave branchAddress at zero for now */ /* re-write the previous DMA descriptor to chain to this one */ /* set prev branch address to point to next (Z=3) */ - prev->output_last.branchAddress = - dma_prog_region_offset_to_bus(&xmit->prog, sizeof(struct iso_xmit_cmd) * next_i) | 3; + prev->output_last.branchAddress = cpu_to_le32( + dma_prog_region_offset_to_bus(&xmit->prog, sizeof(struct iso_xmit_cmd) * next_i) | 3); /* disable interrupt, unless required by the IRQ interval */ if(prev_i % iso->irq_interval) { - prev->output_last.control &= ~(3 << 20); /* no interrupt */ + prev->output_last.control &= cpu_to_le32(~(3 << 20)); /* no interrupt */ } else { - prev->output_last.control |= 3 << 20; /* enable interrupt */ + prev->output_last.control |= cpu_to_le32(3 << 20); /* enable interrupt */ } wmb(); @@ -2266,7 +2281,7 @@ if (event & OHCI1394_cycleInconsistent) { /* We subscribe to the cycleInconsistent event only to * clear the corresponding event bit... otherwise, - * isochronous cycleMatch DMA wont work. */ + * isochronous cycleMatch DMA won't work. */ DBGMSG(ohci->id, "OHCI1394_cycleInconsistent"); event &= ~OHCI1394_cycleInconsistent; } @@ -2366,7 +2381,7 @@ if (!(node_id & 0x80000000)) { PRINT(KERN_ERR, ohci->id, "SelfID received, but NodeID invalid " - "(probably new bus reset occured): %08X", + "(probably new bus reset occurred): %08X", node_id); goto selfid_not_valid; } @@ -3473,10 +3488,10 @@ static struct pci_device_id ohci1394_pci_tbl[] __devinitdata = { { - .class = PCI_CLASS_FIREWIRE_OHCI, - .class_mask = 0x00ffffff, - .vendor = PCI_ANY_ID, - .device = PCI_ANY_ID, + .class = PCI_CLASS_FIREWIRE_OHCI, + .class_mask = ~0, + .vendor = PCI_ANY_ID, + .device = PCI_ANY_ID, .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, }, @@ -3530,7 +3545,7 @@ tasklet_init(&tasklet->tasklet, func, data); tasklet->type = type; /* We init the tasklet->link field, so we can list_del() it - * without worrying wether it was added to the list or not. */ + * without worrying whether it was added to the list or not. */ INIT_LIST_HEAD(&tasklet->link); } diff -Nru a/drivers/ieee1394/ohci1394.h b/drivers/ieee1394/ohci1394.h --- a/drivers/ieee1394/ohci1394.h Tue Mar 4 19:30:04 2003 +++ b/drivers/ieee1394/ohci1394.h Tue Mar 4 19:30:04 2003 @@ -405,12 +405,12 @@ truncated */ #define EVT_OVERRUN 0x5 /* A recv FIFO overflowed on reception of ISO packet */ -#define EVT_DESCRIPTOR_READ 0x6 /* An unrecoverable error occured while host was +#define EVT_DESCRIPTOR_READ 0x6 /* An unrecoverable error occurred while host was reading a descriptor block */ -#define EVT_DATA_READ 0x7 /* An error occured while host controller was +#define EVT_DATA_READ 0x7 /* An error occurred while host controller was attempting to read from host memory in the data stage of descriptor processing */ -#define EVT_DATA_WRITE 0x8 /* An error occured while host controller was +#define EVT_DATA_WRITE 0x8 /* An error occurred while host controller was attempting to write either during the data stage of descriptor processing, or when processing a single 16-bit host memory write */ diff -Nru a/drivers/ieee1394/raw1394.c b/drivers/ieee1394/raw1394.c --- a/drivers/ieee1394/raw1394.c Tue Mar 4 19:30:03 2003 +++ b/drivers/ieee1394/raw1394.c Tue Mar 4 19:30:03 2003 @@ -238,7 +238,7 @@ list_del(&hi->list); host_count--; /* - FIXME: addressranges should be removed + FIXME: address ranges should be removed and fileinfo states should be initialized (including setting generation to internal-generation ...) @@ -281,8 +281,8 @@ req->req.misc = (host->node_id << 16) | host->node_count; if (fi->protocol_version > 3) { - req->req.misc |= ((host->irm_id - & NODE_MASK) << 8); + req->req.misc |= (NODEID_TO_NODE(host->irm_id) + << 8); } queue_complete_req(req); @@ -571,8 +571,7 @@ req->req.misc = (fi->host->node_id << 16) | fi->host->node_count; if (fi->protocol_version > 3) { - req->req.misc |= - (fi->host->irm_id & NODE_MASK) << 8; + req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8; } } else { req->req.error = RAW1394_ERROR_INVALID_ARG; @@ -2440,7 +2439,7 @@ spin_unlock_irq(&host_info_lock); if (fail > 0) { printk(KERN_ERR "raw1394: during addr_list-release " - "error(s) occured \n"); + "error(s) occurred \n"); } while (!done) { diff -Nru a/drivers/ieee1394/sbp2.c b/drivers/ieee1394/sbp2.c --- a/drivers/ieee1394/sbp2.c Tue Mar 4 19:30:04 2003 +++ b/drivers/ieee1394/sbp2.c Tue Mar 4 19:30:04 2003 @@ -27,30 +27,6 @@ * driver. It also registers as a SCSI lower-level driver in order to accept * SCSI commands for transport using SBP-2. * - * - * Driver Loading: - * - * Currently, the SBP-2 driver is supported only as a module. Because the - * Linux SCSI stack is not Plug-N-Play aware, module load order is - * important. Assuming the SCSI core drivers are either built into the - * kernel or already loaded as modules, you should load the IEEE-1394 modules - * in the following order: - * - * ieee1394 (e.g. insmod ieee1394) - * ohci1394 (e.g. insmod ohci1394) - * sbp2 (e.g. insmod sbp2) - * - * The SBP-2 driver will attempt to discover any attached SBP-2 devices when first - * loaded, or after any IEEE-1394 bus reset (e.g. a hot-plug). It will then print - * out a debug message indicating if it was able to discover a SBP-2 device. - * - * Currently, the SBP-2 driver will catch any attached SBP-2 devices during the - * initial scsi bus scan (when the driver is first loaded). To add or remove - * SBP-2 devices "after" this initial scan (i.e. if you plug-in or un-plug a - * device after the SBP-2 driver is loaded), you must either use the scsi procfs - * add-single-device, remove-single-device, or a shell script such as - * rescan-scsi-bus.sh. - * * The easiest way to add/detect new SBP-2 devices is to run the shell script * rescan-scsi-bus.sh (or re-load the SBP-2 driver). This script may be * found at: @@ -136,14 +112,6 @@ * - Error Handling: SCSI aborts and bus reset requests are handled somewhat * but the code needs additional debugging. * - * - Module: The SBP-2 driver is currently only supported as a module. It would not take - * much work to allow it to be compiled into the kernel, but you'd have to - * add some init code to the kernel to support this... and modules are much - * more flexible anyway. ;-) - * - * - Hot-plugging: Interaction with the SCSI stack and support for hot-plugging could - * stand some improvement. - * * * History: * @@ -295,10 +263,11 @@ * 04/23/02 - Fix for Sony CD-ROM drives. Only send fetch agent reset to sbp2 device if it * returns the dead bit in status. Thanks to Chandan (chandan@toad.net) for this one. * 04/27/02 - Fix sbp2 login problem on SMP systems, enable real spinlocks by default. (JSG) - * 06/09/02 - Don't force 36-bute SCSI inquiry, but leave in a define for badly behaved devices. (JSG) + * 06/09/02 - Don't force 36-byte SCSI inquiry, but leave in a define for badly behaved devices. (JSG) * 02/04/03 - Fixed a SMP deadlock (don't hold sbp2_command_lock while calling sbp2scsi_complete_command). * Also save/restore irq flags in sbp2scsi_complete_command - Sancho Dauskardt * 02/06/03 - Removed spinlock debugging; use kernel stuff instead (sda) + * 02/10/03 - Adopt to new hot-plug aware SCSI inferface (hch@lst.de) * */ @@ -350,7 +319,7 @@ #include "sbp2.h" static char version[] __devinitdata = - "$Rev: 779 $ James Goodwin "; + "$Rev: 797 $ James Goodwin "; /* * Module load parameter definitions @@ -497,6 +466,15 @@ * Globals */ +static void sbp2scsi_complete_all_commands(struct sbp2scsi_host_info *hi, + struct scsi_id_instance_data *scsi_id, + u32 status); + +static void sbp2scsi_complete_command(struct sbp2scsi_host_info *hi, + struct scsi_id_instance_data *scsi_id, + u32 scsi_status, Scsi_Cmnd *SCpnt, + void (*done)(Scsi_Cmnd *)); + static Scsi_Host_Template scsi_driver_template; static u8 sbp2_speedto_maxrec[] = { 0x7, 0x8, 0x9 }; @@ -822,7 +800,7 @@ { struct sbp2scsi_host_info *hi; - hi = (struct sbp2scsi_host_info *) command->Current_SCpnt->device->host->hostdata[0]; + hi = (struct sbp2scsi_host_info *)&command->Current_SCpnt->device->host->hostdata; if (hi == NULL) { printk(KERN_ERR "%s: hi == NULL\n", __FUNCTION__); @@ -871,59 +849,6 @@ * IEEE-1394 core driver stack related section *********************************************/ -/* - * This function is called at SCSI init in order to register our driver - * with the IEEE-1394 stack. - */ -int sbp2_init(void) -{ - SBP2_DEBUG("sbp2_init"); - - /* - * Register our high level driver with 1394 stack - */ - sbp2_hl_handle = hpsb_register_highlevel(SBP2_DEVICE_NAME, &sbp2_hl_ops); - - if (sbp2_hl_handle == NULL) { - SBP2_ERR("sbp2 failed to register with ieee1394 highlevel"); - return(-ENOMEM); - } - - /* - * Register our sbp2 status address space... - */ - hpsb_register_addrspace(sbp2_hl_handle, &sbp2_ops, SBP2_STATUS_FIFO_ADDRESS, - SBP2_STATUS_FIFO_ADDRESS + - SBP2_STATUS_FIFO_ENTRY_TO_OFFSET(SBP2SCSI_MAX_SCSI_IDS+1)); - - /* - * Handle data movement if physical dma is not enabled/supported on host controller - */ -#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA - hpsb_register_addrspace(sbp2_hl_handle, &sbp2_physdma_ops, 0x0ULL, 0xfffffffcULL); -#endif - - hpsb_register_protocol(&sbp2_driver); - - return 0; -} - -/* - * This function is called from cleanup module, or during shut-down, in - * order to unregister our driver. - */ -void sbp2_cleanup(void) -{ - SBP2_DEBUG("sbp2_cleanup"); - - hpsb_unregister_protocol(&sbp2_driver); - - if (sbp2_hl_handle) { - hpsb_unregister_highlevel(sbp2_hl_handle); - sbp2_hl_handle = NULL; - } -} - static int sbp2_probe(struct unit_directory *ud) { struct sbp2scsi_host_info *hi; @@ -999,35 +924,44 @@ { struct sbp2scsi_host_info *hi; unsigned long flags; + struct Scsi_Host *scsi_host; SBP2_DEBUG("sbp2_add_host"); - /* Allocate some memory for our host info structure */ - hi = (struct sbp2scsi_host_info *)kmalloc(sizeof(struct sbp2scsi_host_info), - in_interrupt() ? SLAB_ATOMIC : SLAB_KERNEL); - - if (hi == NULL) { - SBP2_ERR("out of memory in sbp2_add_host"); + /* Register our host with the SCSI stack. */ + scsi_host = scsi_register (&scsi_driver_template, sizeof(struct sbp2scsi_host_info)); + if (!scsi_host) { + SBP2_ERR("failed to register scsi host"); return; } - /* Initialize some host stuff */ + hi = (struct sbp2scsi_host_info *)&scsi_host->hostdata; memset(hi, 0, sizeof(struct sbp2scsi_host_info)); + + hi->scsi_host = scsi_host; INIT_LIST_HEAD(&hi->list); hi->host = host; hi->sbp2_command_lock = SPIN_LOCK_UNLOCKED; + hi->scsi_host->max_id = SBP2SCSI_MAX_SCSI_IDS; spin_lock_irqsave(&sbp2_host_info_lock, flags); list_add_tail(&hi->list, &sbp2_host_info_list); spin_unlock_irqrestore(&sbp2_host_info_lock, flags); - /* Register our host with the SCSI stack. */ - hi->scsi_host = scsi_register (&scsi_driver_template, sizeof(void *)); - if (hi->scsi_host) { - hi->scsi_host->hostdata[0] = (unsigned long)hi; - hi->scsi_host->max_id = SBP2SCSI_MAX_SCSI_IDS; + /* + * XXX(hch): Hopefully the ieee1394 code will be converted + * to the driver model at some point. Until that happens + * we'll have to pass in NULL here. + */ + if (scsi_add_host(hi->scsi_host, NULL)) { + SBP2_ERR("failed to add scsi host"); + + spin_lock_irqsave(&sbp2_host_info_lock, flags); + list_del(&hi->list); + spin_unlock_irqrestore(&sbp2_host_info_lock, flags); + + scsi_unregister(hi->scsi_host); } - scsi_driver_template.present++; return; } @@ -1079,16 +1013,15 @@ SBP2_DEBUG("sbp2_remove_host"); spin_lock_irqsave(&sbp2_host_info_lock, flags); - hi = sbp2_find_host_info(host); - if (hi != NULL) { + if (hi) list_del(&hi->list); - kfree(hi); - } - else - SBP2_ERR("attempt to remove unknown host %p", host); - spin_unlock_irqrestore(&sbp2_host_info_lock, flags); + + if (hi) { + scsi_remove_host(hi->scsi_host); + scsi_unregister(hi->scsi_host); + } } /* @@ -1098,6 +1031,7 @@ static int sbp2_start_device(struct sbp2scsi_host_info *hi, struct unit_directory *ud) { struct scsi_id_instance_data *scsi_id = NULL; + struct scsi_device *sdev; struct node_entry *ne; int i; @@ -1203,7 +1137,7 @@ /* * Find an empty spot to stick our scsi id instance data. */ - for (i = 0; i < SBP2SCSI_MAX_SCSI_IDS; i++) { + for (i = 0; i < hi->scsi_host->max_id; i++) { if (!hi->scsi_id[i]) { hi->scsi_id[i] = scsi_id; scsi_id->id = i; @@ -1224,7 +1158,7 @@ /* * Make sure we are not out of space */ - if (i == SBP2SCSI_MAX_SCSI_IDS) { + if (i == hi->scsi_host->max_id) { SBP2_ERR("No slots left for SBP-2 device"); sbp2_remove_device(hi, scsi_id); return -EBUSY; @@ -1256,6 +1190,13 @@ */ sbp2_max_speed_and_size(hi, scsi_id); + /* Add this device to the scsi layer now */ + sdev = scsi_add_device(hi->scsi_host, 0, scsi_id->id, 0); + if (IS_ERR(sdev)) { + SBP2_ERR("scsi_add_device failed"); + return PTR_ERR(sdev); + } + return 0; } @@ -1265,13 +1206,21 @@ static void sbp2_remove_device(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id) { + struct scsi_device *sdev = scsi_find_device(hi->scsi_host, 0, scsi_id->id, 0); + SBP2_DEBUG("sbp2_remove_device"); /* Complete any pending commands with selection timeout */ sbp2scsi_complete_all_commands(hi, scsi_id, DID_NO_CONNECT); - + + /* Remove it from the scsi layer now */ + if (scsi_remove_device(sdev)) + SBP2_ERR("scsi_remove_device failed"); + sbp2util_remove_command_orb_pool(scsi_id, hi); + hi->scsi_id[scsi_id->id] = NULL; + if (scsi_id->login_response) { pci_free_consistent(hi->host->pdev, sizeof(struct sbp2_login_response), @@ -1305,7 +1254,7 @@ } SBP2_DEBUG("SBP-2 device removed, SCSI ID = %d", scsi_id->id); - hi->scsi_id[scsi_id->id] = NULL; + kfree(scsi_id); } @@ -1793,8 +1742,8 @@ SBP2_DEBUG("sbp2_max_speed_and_size"); /* Initial setting comes from the hosts speed map */ - scsi_id->speed_code = hi->host->speed_map[(hi->host->node_id & NODE_MASK) * 64 - + (scsi_id->ne->nodeid & NODE_MASK)]; + scsi_id->speed_code = hi->host->speed_map[NODEID_TO_NODE(hi->host->node_id) * 64 + + NODEID_TO_NODE(scsi_id->ne->nodeid)]; /* Bump down our speed if the user requested it */ if (scsi_id->speed_code > sbp2_max_speed) { @@ -2661,7 +2610,7 @@ /* * Pull our host info and scsi id instance data from the scsi command */ - hi = (struct sbp2scsi_host_info *) SCpnt->device->host->hostdata[0]; + hi = (struct sbp2scsi_host_info *) &SCpnt->device->host->hostdata; if (!hi) { SBP2_ERR("sbp2scsi_host_info is NULL - this is bad!"); @@ -2766,8 +2715,10 @@ * * This can be called in interrupt context. */ -static void sbp2scsi_complete_command(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id, u32 scsi_status, - Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)) +static void sbp2scsi_complete_command(struct sbp2scsi_host_info *hi, + struct scsi_id_instance_data *scsi_id, + u32 scsi_status, Scsi_Cmnd *SCpnt, + void (*done)(Scsi_Cmnd *)) { unsigned long flags; @@ -2888,7 +2839,7 @@ */ static int sbp2scsi_abort (Scsi_Cmnd *SCpnt) { - struct sbp2scsi_host_info *hi = (struct sbp2scsi_host_info *) SCpnt->device->host->hostdata[0]; + struct sbp2scsi_host_info *hi = (struct sbp2scsi_host_info *)&SCpnt->device->host->hostdata; struct scsi_id_instance_data *scsi_id = hi->scsi_id[SCpnt->device->id]; struct sbp2_command_info *command; unsigned long flags; @@ -2938,7 +2889,7 @@ */ static int sbp2scsi_reset (Scsi_Cmnd *SCpnt) { - struct sbp2scsi_host_info *hi = (struct sbp2scsi_host_info *) SCpnt->device->host->hostdata[0]; + struct sbp2scsi_host_info *hi = (struct sbp2scsi_host_info *)&SCpnt->device->host->hostdata; struct scsi_id_instance_data *scsi_id = hi->scsi_id[SCpnt->device->id]; SBP2_ERR("reset requested"); @@ -2951,93 +2902,81 @@ return(SUCCESS); } -/* - * Called by scsi stack to get bios parameters (used by fdisk, and at boot). - */ -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,43) -static int sbp2scsi_biosparam (struct scsi_device *sdev, - struct block_device *dev, sector_t capacity, int geom[]) +static const char *sbp2scsi_info (struct Scsi_Host *host) { -#else -static int sbp2scsi_biosparam (Scsi_Disk *disk, kdev_t dev, int geom[]) + return "SCSI emulation for for IEEE-1394 Storage Devices"; +} + +/* Called for contents of procfs */ +#define SPRINTF(args...) \ + do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0) + +static int sbp2scsi_proc_info(char *buffer, char **start, off_t offset, + int length, int hostno, int inout) { - unsigned capacity = disk->capacity; -#endif - int heads, sectors, cylinders; + Scsi_Device *scd; + struct Scsi_Host *host; + struct sbp2scsi_host_info *hi; + char *pos = buffer; - SBP2_DEBUG("Request for bios parameters"); + /* if someone is sending us data, just throw it away */ + if (inout) + return length; - heads = 64; - sectors = 32; - cylinders = (int)capacity / (heads * sectors); + host = scsi_host_hn_get(hostno); + if (!host) /* if we couldn't find it, we return an error */ + return -ESRCH; - if (cylinders > 1024) { - heads = 255; - sectors = 63; - cylinders = (int)capacity / (heads * sectors); - } + hi = sbp2_find_host_info_scsi(host); + if (!hi) /* shouldn't happen, but... */ + return -ESRCH; - geom[0] = heads; - geom[1] = sectors; - geom[2] = cylinders; + SPRINTF("Host scsi%d : SBP-2 IEEE-1394 (%s)\n", hostno, + hi->host->driver->name); + SPRINTF("Driver version : %s\n", version); - return(0); -} + SPRINTF("\nModule options :\n"); + SPRINTF(" sbp2_max_speed : %s\n", hpsb_speedto_str[sbp2_max_speed]); + SPRINTF(" sbp2_max_sectors : %d\n", sbp2_max_sectors); + SPRINTF(" sbp2_serialize_io : %s\n", sbp2_serialize_io ? "yes" : "no"); + SPRINTF(" sbp2_exclusive_login : %s\n", sbp2_exclusive_login ? "yes" : "no"); -/* - * Called by scsi stack after scsi driver is registered - */ -static int sbp2scsi_detect (Scsi_Host_Template *tpnt) -{ - SBP2_DEBUG("sbp2scsi_detect"); + SPRINTF("\nAttached devices : %s\n", !list_empty(&host->my_devices) ? + "" : "none"); - /* - * Call sbp2_init to register with the ieee1394 stack. This - * results in a callback to sbp2_add_host for each ieee1394 - * host controller currently registered, and for each of those - * we register a scsi host with the scsi stack. - */ - -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) - spin_unlock_irq(&io_request_lock); - sbp2_init(); - spin_lock_irq(&io_request_lock); -#else - sbp2_init(); -#endif + list_for_each_entry (scd, &host->my_devices, siblings) { + int i; - /* We return the number of hosts registered. */ - return scsi_driver_template.present; -} + SPRINTF(" [Channel: %02d, Id: %02d, Lun: %02d] ", scd->channel, + scd->id, scd->lun); + SPRINTF("%s ", (scd->type < MAX_SCSI_DEVICE_CODE) ? + scsi_device_types[(short) scd->type] : "Unknown device"); + for (i = 0; (i < 8) && (scd->vendor[i] >= 0x20); i++) + SPRINTF("%c", scd->vendor[i]); -/* - * Called for contents of procfs - */ -static const char *sbp2scsi_info (struct Scsi_Host *host) -{ - struct sbp2scsi_host_info *hi = sbp2_find_host_info_scsi(host); - static char info[1024]; + SPRINTF(" "); - if (!hi) /* shouldn't happen, but... */ - return "IEEE-1394 SBP-2 protocol driver"; + for (i = 0; (i < 16) && (scd->model[i] >= 0x20); i++) + SPRINTF("%c", scd->model[i]); + + SPRINTF("\n"); + } - sprintf(info, "IEEE-1394 SBP-2 protocol driver (host: %s)\n%s\n" - "SBP-2 module load options:\n" - "- Max speed supported: %s\n" - "- Max sectors per I/O supported: %d\n" - "- Serialized I/O (debug): %s\n" - "- Exclusive login: %s", - hi->host->driver->name, - version, - hpsb_speedto_str[sbp2_max_speed], - sbp2_max_sectors, - sbp2_serialize_io ? "yes" : "no", - sbp2_exclusive_login ? "yes" : "no"); + SPRINTF("\n"); - return info; -} + /* release the reference count on this host */ + scsi_host_put(host); + /* Calculate start of next buffer, and return value. */ + *start = buffer + offset; + if ((pos - buffer) < offset) + return (0); + else if ((pos - buffer - offset) < length) + return (pos - buffer - offset); + else + return (length); +} MODULE_AUTHOR("James Goodwin "); MODULE_DESCRIPTION("IEEE-1394 SBP-2 protocol driver"); @@ -3046,25 +2985,23 @@ /* SCSI host template */ static Scsi_Host_Template scsi_driver_template = { - .name = "IEEE-1394 SBP-2 protocol driver", - .info = sbp2scsi_info, - .detect = sbp2scsi_detect, - .queuecommand = sbp2scsi_queuecommand, - .eh_abort_handler = sbp2scsi_abort, - .eh_device_reset_handler =sbp2scsi_reset, - .eh_bus_reset_handler = sbp2scsi_reset, - .eh_host_reset_handler =sbp2scsi_reset, - .bios_param = sbp2scsi_biosparam, - .this_id = -1, - .sg_tablesize = SG_ALL, - .use_clustering = ENABLE_CLUSTERING, - .cmd_per_lun = SBP2_MAX_CMDS_PER_LUN, - .can_queue = SBP2_MAX_SCSI_QUEUE, -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) - .use_new_eh_code = TRUE, -#endif - .emulated = 1, - .proc_name = SBP2_DEVICE_NAME, + .module = THIS_MODULE, + .name = "SBP-2 IEEE-1394", + .proc_name = SBP2_DEVICE_NAME, + .info = sbp2scsi_info, + .proc_info = sbp2scsi_proc_info, + .queuecommand = sbp2scsi_queuecommand, + .eh_abort_handler = sbp2scsi_abort, + .eh_device_reset_handler = sbp2scsi_reset, + .eh_bus_reset_handler = sbp2scsi_reset, + .eh_host_reset_handler = sbp2scsi_reset, + .this_id = -1, + .sg_tablesize = SG_ALL, + .use_clustering = ENABLE_CLUSTERING, + .cmd_per_lun = SBP2_MAX_CMDS_PER_LUN, + .can_queue = SBP2_MAX_SCSI_QUEUE, + .emulated = 1, + .highmem_io = 1, }; static int sbp2_module_init(void) @@ -3084,23 +3021,36 @@ */ scsi_driver_template.max_sectors = sbp2_max_sectors; + /* - * Ideally we would register our scsi_driver_template with the - * scsi stack and after that register with the ieee1394 stack - * and process the add_host callbacks. However, the detect - * function in the scsi host template requires that we find at - * least one host, so we "nest" the registrations by calling - * sbp2_init from the detect function. - */ - scsi_driver_template.module = THIS_MODULE; - if (SCSI_REGISTER_HOST(&scsi_driver_template) || - !scsi_driver_template.present) { - SBP2_ERR("Please load the lower level IEEE-1394 driver " - "(e.g. ohci1394) before sbp2..."); - sbp2_cleanup(); - return -ENODEV; + * Register our high level driver with 1394 stack + */ + sbp2_hl_handle = hpsb_register_highlevel(SBP2_DEVICE_NAME, + &sbp2_hl_ops); + if (!sbp2_hl_handle) { + SBP2_ERR("sbp2 failed to register with ieee1394 highlevel"); + return(-ENOMEM); } + /* + * Register our sbp2 status address space... + */ + hpsb_register_addrspace(sbp2_hl_handle, &sbp2_ops, + SBP2_STATUS_FIFO_ADDRESS, + SBP2_STATUS_FIFO_ADDRESS + + SBP2_STATUS_FIFO_ENTRY_TO_OFFSET( + SBP2SCSI_MAX_SCSI_IDS+1)); + + /* + * Handle data movement if physical dma is not enabled/supported + * on host controller + */ +#ifdef CONFIG_IEEE1394_SBP2_PHYS_DMA + hpsb_register_addrspace(sbp2_hl_handle, &sbp2_physdma_ops, + 0x0ULL, 0xfffffffcULL); +#endif + + hpsb_register_protocol(&sbp2_driver); return 0; } @@ -3108,17 +3058,9 @@ { SBP2_DEBUG("sbp2_module_exit"); - /* - * On module unload we unregister with the ieee1394 stack - * which results in remove_host callbacks for all ieee1394 - * host controllers. In the callbacks we unregister the - * corresponding scsi hosts. - */ - sbp2_cleanup(); - - if (SCSI_UNREGISTER_HOST(&scsi_driver_template)) - SBP2_ERR("sbp2_module_exit: couldn't unregister scsi driver"); - + hpsb_unregister_protocol(&sbp2_driver); + if (sbp2_hl_handle) + hpsb_unregister_highlevel(sbp2_hl_handle); } module_init(sbp2_module_init); diff -Nru a/drivers/ieee1394/sbp2.h b/drivers/ieee1394/sbp2.h --- a/drivers/ieee1394/sbp2.h Tue Mar 4 19:30:05 2003 +++ b/drivers/ieee1394/sbp2.h Tue Mar 4 19:30:05 2003 @@ -22,15 +22,6 @@ #ifndef SBP2_H #define SBP2_H -/* Some compatibility code */ -#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) -#define SCSI_REGISTER_HOST(tmpl) scsi_register_module(MODULE_SCSI_HA, tmpl) -#define SCSI_UNREGISTER_HOST(tmpl) scsi_unregister_module(MODULE_SCSI_HA, tmpl) -#else -#define SCSI_REGISTER_HOST(tmpl) scsi_register_host(tmpl) -#define SCSI_UNREGISTER_HOST(tmpl) scsi_unregister_host(tmpl) -#endif - #define SBP2_DEVICE_NAME "sbp2" /* @@ -442,8 +433,6 @@ static void sbp2_add_host(struct hpsb_host *host); static struct sbp2scsi_host_info *sbp2_find_host_info(struct hpsb_host *host); static void sbp2_remove_host(struct hpsb_host *host); -int sbp2_init(void); -void sbp2_cleanup(void); static int sbp2_probe(struct unit_directory *ud); static void sbp2_disconnect(struct unit_directory *ud); static void sbp2_update(struct unit_directory *ud); @@ -486,24 +475,5 @@ static void sbp2_parse_unit_directory(struct scsi_id_instance_data *scsi_id); static int sbp2_set_busy_timeout(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id); static int sbp2_max_speed_and_size(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id); - -/* - * Scsi interface related prototypes - */ -static int sbp2scsi_detect (Scsi_Host_Template *tpnt); -static const char *sbp2scsi_info (struct Scsi_Host *host); -void sbp2scsi_setup(char *str, int *ints); -#if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,44) -static int sbp2scsi_biosparam (struct scsi_device *sdev, struct block_device *dev, sector_t capacity, int geom[]); -#else -static int sbp2scsi_biosparam (Scsi_Disk *disk, kdev_t dev, int geom[]); -#endif -static int sbp2scsi_abort (Scsi_Cmnd *SCpnt); -static int sbp2scsi_reset (Scsi_Cmnd *SCpnt); -static int sbp2scsi_queuecommand (Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)); -static void sbp2scsi_complete_all_commands(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id, - u32 status); -static void sbp2scsi_complete_command(struct sbp2scsi_host_info *hi, struct scsi_id_instance_data *scsi_id, - u32 scsi_status, Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *)); #endif /* SBP2_H */ diff -Nru a/drivers/ieee1394/video1394.c b/drivers/ieee1394/video1394.c --- a/drivers/ieee1394/video1394.c Tue Mar 4 19:30:04 2003 +++ b/drivers/ieee1394/video1394.c Tue Mar 4 19:30:04 2003 @@ -43,6 +43,8 @@ #include #include #include +#include +#include #include "ieee1394.h" #include "ieee1394_types.h" @@ -1338,24 +1340,152 @@ MODULE_SUPPORTED_DEVICE(VIDEO1394_DRIVER_NAME); MODULE_LICENSE("GPL"); +#ifdef CONFIG_COMPAT + +#define VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER \ + _IOW ('#', 0x12, struct video1394_wait32) +#define VIDEO1394_IOC32_LISTEN_WAIT_BUFFER \ + _IOWR('#', 0x13, struct video1394_wait32) +#define VIDEO1394_IOC32_TALK_WAIT_BUFFER \ + _IOW ('#', 0x17, struct video1394_wait32) +#define VIDEO1394_IOC32_LISTEN_POLL_BUFFER \ + _IOWR('#', 0x18, struct video1394_wait32) + +struct video1394_wait32 { + u32 channel; + u32 buffer; + struct compat_timeval filltime; +}; + +static int video1394_wr_wait32(unsigned int fd, unsigned int cmd, unsigned long arg, + struct file *file) +{ + struct video1394_wait32 wait32; + struct video1394_wait wait; + mm_segment_t old_fs; + int ret; + + if (file->f_op->ioctl != video1394_ioctl) + return -EFAULT; + + if (copy_from_user(&wait32, (void *)arg, sizeof(wait32))) + return -EFAULT; + + wait.channel = wait32.channel; + wait.buffer = wait32.buffer; + wait.filltime.tv_sec = (time_t)wait32.filltime.tv_sec; + wait.filltime.tv_usec = (suseconds_t)wait32.filltime.tv_usec; + + old_fs = get_fs(); + set_fs(KERNEL_DS); + if (cmd == VIDEO1394_IOC32_LISTEN_WAIT_BUFFER) + ret = video1394_ioctl(file->f_dentry->d_inode, file, + VIDEO1394_IOC_LISTEN_WAIT_BUFFER, + (unsigned long) &wait); + else + ret = video1394_ioctl(file->f_dentry->d_inode, file, + VIDEO1394_IOC_LISTEN_POLL_BUFFER, + (unsigned long) &wait); + set_fs(old_fs); + + if (!ret) { + wait32.channel = wait.channel; + wait32.buffer = wait.buffer; + wait32.filltime.tv_sec = (int)wait.filltime.tv_sec; + wait32.filltime.tv_usec = (int)wait.filltime.tv_usec; + + if (copy_to_user((struct video1394_wait32 *)arg, &wait32, sizeof(wait32))) + ret = -EFAULT; + } + + return ret; +} + +static int video1394_w_wait32(unsigned int fd, unsigned int cmd, unsigned long arg, + struct file *file) +{ + struct video1394_wait32 wait32; + struct video1394_wait wait; + mm_segment_t old_fs; + int ret; + + if (file->f_op->ioctl != video1394_ioctl) + return -EFAULT; + + if (copy_from_user(&wait32, (void *)arg, sizeof(wait32))) + return -EFAULT; + + wait.channel = wait32.channel; + wait.buffer = wait32.buffer; + wait.filltime.tv_sec = (time_t)wait32.filltime.tv_sec; + wait.filltime.tv_usec = (suseconds_t)wait32.filltime.tv_usec; + + old_fs = get_fs(); + set_fs(KERNEL_DS); + if (cmd == VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER) + ret = video1394_ioctl(file->f_dentry->d_inode, file, + VIDEO1394_IOC_LISTEN_QUEUE_BUFFER, + (unsigned long) &wait); + else + ret = video1394_ioctl(file->f_dentry->d_inode, file, + VIDEO1394_IOC_TALK_WAIT_BUFFER, + (unsigned long) &wait); + set_fs(old_fs); + + return ret; +} + +static int video1394_queue_buf32(unsigned int fd, unsigned int cmd, unsigned long arg, + struct file *file) +{ + if (file->f_op->ioctl != video1394_ioctl) + return -EFAULT; + + return -EFAULT; + + return video1394_ioctl(file->f_dentry->d_inode, file, + VIDEO1394_IOC_TALK_QUEUE_BUFFER, arg); +} + +#endif /* CONFIG_COMPAT */ + static void __exit video1394_exit_module (void) { +#ifdef CONFIG_COMPAT + int ret; + + ret = unregister_ioctl32_conversion(VIDEO1394_IOC_LISTEN_CHANNEL); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC_UNLISTEN_CHANNEL); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC_TALK_CHANNEL); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC_UNTALK_CHANNEL); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_WAIT_BUFFER); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC_TALK_QUEUE_BUFFER); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC32_TALK_WAIT_BUFFER); + ret |= unregister_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_POLL_BUFFER); + if (ret) + PRINT_G(KERN_INFO, "Error unregistering ioctl32 translations"); +#endif + hpsb_unregister_highlevel (hl_handle); devfs_unregister(devfs_handle); ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_VIDEO1394); - + PRINT_G(KERN_INFO, "Removed " VIDEO1394_DRIVER_NAME " module"); } static int __init video1394_init_module (void) { - if (ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_VIDEO1394, - THIS_MODULE, &video1394_fops)) { + int ret; + + ret = ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_VIDEO1394, + THIS_MODULE, &video1394_fops); + if (ret) { PRINT_G(KERN_ERR, "video1394: unable to get minor device block"); - return -EIO; - } - + return -EIO; + } + devfs_handle = devfs_mk_dir(NULL, VIDEO1394_DRIVER_NAME, NULL); hl_handle = hpsb_register_highlevel (VIDEO1394_DRIVER_NAME, &hl_ops); @@ -1366,9 +1496,32 @@ return -ENOMEM; } +#ifdef CONFIG_COMPAT + /* First the compatible ones */ + ret = register_ioctl32_conversion(VIDEO1394_IOC_LISTEN_CHANNEL, NULL); + ret |= register_ioctl32_conversion(VIDEO1394_IOC_UNLISTEN_CHANNEL, NULL); + ret |= register_ioctl32_conversion(VIDEO1394_IOC_TALK_CHANNEL, NULL); + ret |= register_ioctl32_conversion(VIDEO1394_IOC_UNTALK_CHANNEL, NULL); + + /* These need translation */ + ret |= register_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_QUEUE_BUFFER, + video1394_w_wait32); + ret |= register_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_WAIT_BUFFER, + video1394_wr_wait32); + ret |= register_ioctl32_conversion(VIDEO1394_IOC_TALK_QUEUE_BUFFER, + video1394_queue_buf32); + ret |= register_ioctl32_conversion(VIDEO1394_IOC32_TALK_WAIT_BUFFER, + video1394_w_wait32); + ret |= register_ioctl32_conversion(VIDEO1394_IOC32_LISTEN_POLL_BUFFER, + video1394_wr_wait32); + if (ret) + PRINT_G(KERN_INFO, "Error registering ioctl32 translations"); +#endif + PRINT_G(KERN_INFO, "Installed " VIDEO1394_DRIVER_NAME " module"); return 0; } + module_init(video1394_init_module); module_exit(video1394_exit_module); diff -Nru a/drivers/isdn/eicon/adapter.h b/drivers/isdn/eicon/adapter.h --- a/drivers/isdn/eicon/adapter.h Tue Mar 4 19:30:13 2003 +++ b/drivers/isdn/eicon/adapter.h Tue Mar 4 19:30:13 2003 @@ -185,7 +185,7 @@ IDI_CALL DivasIdiRequest[]; /* - * intialisation entry point + * initialisation entry point */ int DivasInit(void); diff -Nru a/drivers/isdn/eicon/eicon_idi.c b/drivers/isdn/eicon/eicon_idi.c --- a/drivers/isdn/eicon/eicon_idi.c Tue Mar 4 19:30:03 2003 +++ b/drivers/isdn/eicon/eicon_idi.c Tue Mar 4 19:30:03 2003 @@ -2717,7 +2717,7 @@ int twaitpq = 0; if (ack->RcId != ((chan->e.ReqCh) ? chan->e.B2Id : chan->e.D3Id)) { - /* I dont know why this happens, should not ! */ + /* I don't know why this happens, should not ! */ /* just ignoring this RC */ eicon_log(ccard, 16, "idi_ack: Ch%d: RcId %d not equal to last %d\n", chan->No, ack->RcId, (chan->e.ReqCh) ? chan->e.B2Id : chan->e.D3Id); diff -Nru a/drivers/isdn/eicon/idi.c b/drivers/isdn/eicon/idi.c --- a/drivers/isdn/eicon/idi.c Tue Mar 4 19:30:05 2003 +++ b/drivers/isdn/eicon/idi.c Tue Mar 4 19:30:05 2003 @@ -435,7 +435,7 @@ a->ram_out(a, &ReqOut->ReqId, this->Id); a->ram_out(a, &ReqOut->ReqCh, this->ReqCh); - /* if its a specific request (no ASSIGN) ... */ + /* if it's a specific request (no ASSIGN) ... */ if(this->Id &0x1f) { diff -Nru a/drivers/isdn/hardware/eicon/dadapter.c b/drivers/isdn/hardware/eicon/dadapter.c --- a/drivers/isdn/hardware/eicon/dadapter.c Tue Mar 4 19:30:08 2003 +++ b/drivers/isdn/hardware/eicon/dadapter.c Tue Mar 4 19:30:08 2003 @@ -327,7 +327,7 @@ Adapter array will be written to memory described by 'buffer' If the last adapter seen in the returned adapter array is IDI_DADAPTER or if last adapter in array does have type '0', then - it was enougth space in buffer to accomodate all available + it was enougth space in buffer to accommodate all available adapter descriptors *NOTE 1 (debug interface): The IDI adapter of type 'IDI_DIMAINT' does register as 'request' diff -Nru a/drivers/isdn/hardware/eicon/di.c b/drivers/isdn/hardware/eicon/di.c --- a/drivers/isdn/hardware/eicon/di.c Tue Mar 4 19:30:07 2003 +++ b/drivers/isdn/hardware/eicon/di.c Tue Mar 4 19:30:07 2003 @@ -169,7 +169,7 @@ a->ram_outw(a, &ReqOut->XBuffer.length, length); a->ram_out(a, &ReqOut->ReqId, this->Id); a->ram_out(a, &ReqOut->ReqCh, this->ReqCh); - /* if its a specific request (no ASSIGN) ... */ + /* if it's a specific request (no ASSIGN) ... */ if(this->Id &0x1f) { /* if buffers are left in the list of data buffers do */ /* do chaining (LL_MDATA, N_MDATA) */ @@ -405,7 +405,7 @@ a->ram_outw(a, &RAM->XBuffer.length, length); a->ram_out(a, &RAM->ReqId, this->Id); a->ram_out(a, &RAM->ReqCh, this->ReqCh); - /* if its a specific request (no ASSIGN) ... */ + /* if it's a specific request (no ASSIGN) ... */ if(this->Id &0x1f) { /* if buffers are left in the list of data buffers do */ /* chaining (LL_MDATA, N_MDATA) */ diff -Nru a/drivers/isdn/hardware/eicon/i4l_idi.c b/drivers/isdn/hardware/eicon/i4l_idi.c --- a/drivers/isdn/hardware/eicon/i4l_idi.c Tue Mar 4 19:30:08 2003 +++ b/drivers/isdn/hardware/eicon/i4l_idi.c Tue Mar 4 19:30:08 2003 @@ -2717,7 +2717,7 @@ int twaitpq = 0; if (ack->RcId != ((chan->e.ReqCh) ? chan->e.B2Id : chan->e.D3Id)) { - /* I dont know why this happens, should not ! */ + /* I don't know why this happens, should not ! */ /* just ignoring this RC */ eicon_log(ccard, 16, "idi_ack: Ch%d: RcId %d not equal to last %d\n", chan->No, ack->RcId, (chan->e.ReqCh) ? chan->e.B2Id : chan->e.D3Id); diff -Nru a/drivers/isdn/hardware/eicon/istream.c b/drivers/isdn/hardware/eicon/istream.c --- a/drivers/isdn/hardware/eicon/istream.c Tue Mar 4 19:30:05 2003 +++ b/drivers/isdn/hardware/eicon/istream.c Tue Mar 4 19:30:05 2003 @@ -142,7 +142,7 @@ return 0 if zero packet was received return -1 if stream is empty return -2 if read buffer does not profide sufficient space - to accomodate entire segment + to accommodate entire segment max_length should be at least 68 bytes ------------------------------------------------------------------- */ int diva_istream_read (void* context, diff -Nru a/drivers/isdn/hisax/amd7930_fn.c b/drivers/isdn/hisax/amd7930_fn.c --- a/drivers/isdn/hisax/amd7930_fn.c Tue Mar 4 19:30:10 2003 +++ b/drivers/isdn/hisax/amd7930_fn.c Tue Mar 4 19:30:10 2003 @@ -42,7 +42,7 @@ * * Credits: * Programming the driver for Formula-n enter:now ISDN PCI and - * neccessary this driver for the used Amd 7930 D-channel-controller + * necessary this driver for the used Amd 7930 D-channel-controller * was spnsored by Formula-n Europe AG. * Thanks to Karsten Keil and Petr Novak, who gave me support in * Hisax-specific questions. @@ -317,7 +317,7 @@ QuickHex(t, cs->rcvbuf, cs->rcvidx); debugl1(cs, cs->dlog); } - /* moves recieved data in sk-buffer */ + /* moves received data in sk-buffer */ memcpy(skb_put(skb, cs->rcvidx), cs->rcvbuf, cs->rcvidx); skb_queue_tail(&cs->rq, skb); } diff -Nru a/drivers/isdn/hisax/asuscom.c b/drivers/isdn/hisax/asuscom.c --- a/drivers/isdn/hisax/asuscom.c Tue Mar 4 19:30:14 2003 +++ b/drivers/isdn/hisax/asuscom.c Tue Mar 4 19:30:14 2003 @@ -283,7 +283,7 @@ printk(KERN_ERR "AsusPnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "AsusPnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/avm_pci.c b/drivers/isdn/hisax/avm_pci.c --- a/drivers/isdn/hisax/avm_pci.c Tue Mar 4 19:30:07 2003 +++ b/drivers/isdn/hisax/avm_pci.c Tue Mar 4 19:30:07 2003 @@ -632,7 +632,7 @@ printk(KERN_ERR "FritzPnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pnp_avm, NULL) < 0) { + if (pnp_activate_dev(pnp_avm) < 0) { printk(KERN_ERR "FritzPnP: activate failed\n"); pnp_device_detach(pnp_avm); return 0; diff -Nru a/drivers/isdn/hisax/diva.c b/drivers/isdn/hisax/diva.c --- a/drivers/isdn/hisax/diva.c Tue Mar 4 19:30:13 2003 +++ b/drivers/isdn/hisax/diva.c Tue Mar 4 19:30:13 2003 @@ -600,7 +600,7 @@ printk(KERN_ERR "Diva PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "Diva PnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/elsa.c b/drivers/isdn/hisax/elsa.c --- a/drivers/isdn/hisax/elsa.c Tue Mar 4 19:30:04 2003 +++ b/drivers/isdn/hisax/elsa.c Tue Mar 4 19:30:04 2003 @@ -864,7 +864,7 @@ printk(KERN_ERR "Elsa PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { pnp_device_detach(pd); printk(KERN_ERR "Elsa PnP: activate failed\n"); return 0; diff -Nru a/drivers/isdn/hisax/enternow_pci.c b/drivers/isdn/hisax/enternow_pci.c --- a/drivers/isdn/hisax/enternow_pci.c Tue Mar 4 19:30:12 2003 +++ b/drivers/isdn/hisax/enternow_pci.c Tue Mar 4 19:30:12 2003 @@ -49,7 +49,7 @@ * * Credits: * Programming the driver for Formula-n enter:now ISDN PCI and - * neccessary the driver for the used Amd 7930 D-channel-controller + * necessary the driver for the used Amd 7930 D-channel-controller * was spnsored by Formula-n Europe AG. * Thanks to Karsten Keil and Petr Novak, who gave me support in * Hisax-specific questions. diff -Nru a/drivers/isdn/hisax/hfc_sx.c b/drivers/isdn/hisax/hfc_sx.c --- a/drivers/isdn/hisax/hfc_sx.c Tue Mar 4 19:30:04 2003 +++ b/drivers/isdn/hisax/hfc_sx.c Tue Mar 4 19:30:04 2003 @@ -97,7 +97,7 @@ /******************************************/ /* reset the specified fifo to defaults. */ -/* If its a send fifo init needed markers */ +/* If it's a send fifo init needed markers */ /******************************************/ static void reset_fifo(struct IsdnCardState *cs, u8 fifo) @@ -1200,7 +1200,7 @@ printk(KERN_ERR "HFC PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "HFC PnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/hfcscard.c b/drivers/isdn/hisax/hfcscard.c --- a/drivers/isdn/hisax/hfcscard.c Tue Mar 4 19:30:13 2003 +++ b/drivers/isdn/hisax/hfcscard.c Tue Mar 4 19:30:13 2003 @@ -193,7 +193,7 @@ printk(KERN_ERR "HFC PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "HFC PnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/isurf.c b/drivers/isdn/hisax/isurf.c --- a/drivers/isdn/hisax/isurf.c Tue Mar 4 19:30:09 2003 +++ b/drivers/isdn/hisax/isurf.c Tue Mar 4 19:30:09 2003 @@ -223,7 +223,7 @@ printk(KERN_ERR "ISurfPnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "ISurfPnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/ix1_micro.c b/drivers/isdn/hisax/ix1_micro.c --- a/drivers/isdn/hisax/ix1_micro.c Tue Mar 4 19:30:13 2003 +++ b/drivers/isdn/hisax/ix1_micro.c Tue Mar 4 19:30:13 2003 @@ -208,7 +208,7 @@ printk(KERN_ERR "ITK PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "ITK PnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/l3dss1.c b/drivers/isdn/hisax/l3dss1.c --- a/drivers/isdn/hisax/l3dss1.c Tue Mar 4 19:30:08 2003 +++ b/drivers/isdn/hisax/l3dss1.c Tue Mar 4 19:30:08 2003 @@ -1603,7 +1603,7 @@ * Bearer Capabilities */ p = skb->data; - /* only the first occurence 'll be detected ! */ + /* only the first occurrence 'll be detected ! */ if ((p = findie(p, skb->len, 0x04, 0))) { if ((p[1] < 2) || (p[1] > 11)) err = 1; diff -Nru a/drivers/isdn/hisax/l3ni1.c b/drivers/isdn/hisax/l3ni1.c --- a/drivers/isdn/hisax/l3ni1.c Tue Mar 4 19:30:05 2003 +++ b/drivers/isdn/hisax/l3ni1.c Tue Mar 4 19:30:05 2003 @@ -1456,7 +1456,7 @@ * Bearer Capabilities */ p = skb->data; - /* only the first occurence 'll be detected ! */ + /* only the first occurrence 'll be detected ! */ if ((p = findie(p, skb->len, 0x04, 0))) { if ((p[1] < 2) || (p[1] > 11)) err = 1; diff -Nru a/drivers/isdn/hisax/niccy.c b/drivers/isdn/hisax/niccy.c --- a/drivers/isdn/hisax/niccy.c Tue Mar 4 19:30:07 2003 +++ b/drivers/isdn/hisax/niccy.c Tue Mar 4 19:30:07 2003 @@ -232,7 +232,7 @@ printk(KERN_ERR "NiccyPnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "NiccyPnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/rawhdlc.c b/drivers/isdn/hisax/rawhdlc.c --- a/drivers/isdn/hisax/rawhdlc.c Tue Mar 4 19:30:05 2003 +++ b/drivers/isdn/hisax/rawhdlc.c Tue Mar 4 19:30:05 2003 @@ -34,7 +34,7 @@ * end-of-frame would occur), so the transmitter performs * "bit-stuffing" - inserting a zero bit after every five one bits, * irregardless of the original bit after the five ones. Byte - * ordering is irrelevent at this point - the data is treated as a + * ordering is irrelevant at this point - the data is treated as a * string of bits, not bytes. Since no more than 5 ones may now occur * in a row, the flag sequence, with its 6 ones, is unique. * diff -Nru a/drivers/isdn/hisax/sedlbauer.c b/drivers/isdn/hisax/sedlbauer.c --- a/drivers/isdn/hisax/sedlbauer.c Tue Mar 4 19:30:14 2003 +++ b/drivers/isdn/hisax/sedlbauer.c Tue Mar 4 19:30:14 2003 @@ -524,7 +524,7 @@ printk(KERN_ERR "Sedlbauer PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pd, NULL) < 0) { + if (pnp_activate_dev(pd) < 0) { printk(KERN_ERR "Sedlbauer PnP: activate failed\n"); pnp_device_detach(pd); return 0; diff -Nru a/drivers/isdn/hisax/teles3.c b/drivers/isdn/hisax/teles3.c --- a/drivers/isdn/hisax/teles3.c Tue Mar 4 19:30:14 2003 +++ b/drivers/isdn/hisax/teles3.c Tue Mar 4 19:30:14 2003 @@ -227,7 +227,7 @@ printk(KERN_ERR "Teles PnP: attach failed\n"); return 0; } - if (pnp_activate_dev(pnp_dev, NULL) < 0) { + if (pnp_activate_dev(pnp_dev) < 0) { printk(KERN_ERR "Teles PnP: activate failed\n"); pnp_device_detach(pnp_dev); return 0; diff -Nru a/drivers/isdn/hysdn/hycapi.c b/drivers/isdn/hysdn/hycapi.c --- a/drivers/isdn/hysdn/hycapi.c Tue Mar 4 19:30:04 2003 +++ b/drivers/isdn/hysdn/hycapi.c Tue Mar 4 19:30:04 2003 @@ -521,7 +521,7 @@ Receive a capi-message. All B3_DATA_IND are converted to 64K-extension compatible format. -New nccis are created if neccessary. +New nccis are created if necessary. *******************************************************************/ void @@ -702,7 +702,7 @@ /******************************************************************** hycapi_capi_create(hysdn_card *card) -Attach the card with it's capi-ctrl. +Attach the card with its capi-ctrl. *********************************************************************/ static void hycapi_fill_profile(hysdn_card *card) diff -Nru a/drivers/isdn/hysdn/hysdn_boot.c b/drivers/isdn/hysdn/hysdn_boot.c --- a/drivers/isdn/hysdn/hysdn_boot.c Tue Mar 4 19:30:08 2003 +++ b/drivers/isdn/hysdn/hysdn_boot.c Tue Mar 4 19:30:08 2003 @@ -357,7 +357,7 @@ hysdn_addlog(card, "SysReady Token Data invalid CRC"); return (1); } - len--; /* dont check CRC byte */ + len--; /* don't check CRC byte */ while (len > 0) { if (*cp == SYSR_TOK_END) diff -Nru a/drivers/isdn/i4l/isdn_ppp_ccp.c b/drivers/isdn/i4l/isdn_ppp_ccp.c --- a/drivers/isdn/i4l/isdn_ppp_ccp.c Tue Mar 4 19:30:07 2003 +++ b/drivers/isdn/i4l/isdn_ppp_ccp.c Tue Mar 4 19:30:07 2003 @@ -197,7 +197,7 @@ and increase ids only when an Ack is received for a given id */ id = ccp->reset->lastid++; - /* We always expect an Ack if the decompressor doesnt + /* We always expect an Ack if the decompressor doesn't know better */ rp->expra = 1; rp->dtval = 0; diff -Nru a/drivers/isdn/tpam/tpam_commands.c b/drivers/isdn/tpam/tpam_commands.c --- a/drivers/isdn/tpam/tpam_commands.c Tue Mar 4 19:30:04 2003 +++ b/drivers/isdn/tpam/tpam_commands.c Tue Mar 4 19:30:04 2003 @@ -880,7 +880,7 @@ memcpy(skb_put(result, len), data, len); } - /* In loop mode, resend the data immediatly */ + /* In loop mode, resend the data immediately */ if (card->loopmode) { struct sk_buff *loopskb; diff -Nru a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c --- a/drivers/macintosh/via-pmu.c Tue Mar 4 19:30:13 2003 +++ b/drivers/macintosh/via-pmu.c Tue Mar 4 19:30:13 2003 @@ -1179,7 +1179,7 @@ static inline void wait_for_ack(void) { - /* Sightly increased the delay, I had one occurence of the message + /* Sightly increased the delay, I had one occurrence of the message * reported */ int timeout = 4000; @@ -2066,7 +2066,7 @@ /* Make sure the decrementer won't interrupt us */ asm volatile("mtdec %0" : : "r" (0x7fffffff)); - /* Make sure any pending DEC interrupt occuring while we did + /* Make sure any pending DEC interrupt occurring while we did * the above didn't re-enable the DEC */ mb(); asm volatile("mtdec %0" : : "r" (0x7fffffff)); @@ -2211,7 +2211,7 @@ /* Make sure the decrementer won't interrupt us */ asm volatile("mtdec %0" : : "r" (0x7fffffff)); - /* Make sure any pending DEC interrupt occuring while we did + /* Make sure any pending DEC interrupt occurring while we did * the above didn't re-enable the DEC */ mb(); asm volatile("mtdec %0" : : "r" (0x7fffffff)); @@ -2376,7 +2376,7 @@ /* Make sure the decrementer won't interrupt us */ asm volatile("mtdec %0" : : "r" (0x7fffffff)); - /* Make sure any pending DEC interrupt occuring while we did + /* Make sure any pending DEC interrupt occurring while we did * the above didn't re-enable the DEC */ mb(); asm volatile("mtdec %0" : : "r" (0x7fffffff)); diff -Nru a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c --- a/drivers/md/dm-ioctl.c Tue Mar 4 19:30:05 2003 +++ b/drivers/md/dm-ioctl.c Tue Mar 4 19:30:05 2003 @@ -173,14 +173,18 @@ */ static int register_with_devfs(struct hash_cell *hc) { - char name[32]; struct gendisk *disk = dm_disk(hc->md); + char *name = kmalloc(DM_NAME_LEN + strlen(DM_DIR) + 1, GFP_KERNEL); + if (!name) { + return -ENOMEM; + } sprintf(name, DM_DIR "/%s", hc->name); devfs_register(NULL, name, DEVFS_FL_CURRENT_OWNER, disk->major, disk->first_minor, S_IFBLK | S_IRUSR | S_IWUSR | S_IRGRP, &dm_blk_dops, NULL); + kfree(name); return 0; } @@ -545,7 +549,7 @@ static int check_name(const char *name) { - if (strchr(name, '/')) { + if (name[0] == '/') { DMWARN("invalid device name"); return -EINVAL; } @@ -887,6 +891,7 @@ dm_table_put(t); return r; } + dm_table_put(t); /* md will have taken its own reference */ set_disk_ro(dm_disk(md), (param->flags & DM_READONLY_FLAG)); dm_put(md); @@ -1122,17 +1127,17 @@ return 0; failed: + devfs_remove(DM_DIR "/control"); + if (misc_deregister(&_dm_misc) < 0) + DMERR("misc_deregister failed for control device"); dm_hash_exit(); - misc_deregister(&_dm_misc); return r; } void dm_interface_exit(void) { - dm_hash_exit(); - devfs_remove(DM_DIR "/control"); - if (misc_deregister(&_dm_misc) < 0) DMERR("misc_deregister failed for control device"); + dm_hash_exit(); } diff -Nru a/drivers/md/dm-table.c b/drivers/md/dm-table.c --- a/drivers/md/dm-table.c Tue Mar 4 19:30:14 2003 +++ b/drivers/md/dm-table.c Tue Mar 4 19:30:14 2003 @@ -79,7 +79,7 @@ } #define __HIGH(l, r) if (*(l) < (r)) *(l) = (r) -#define __LOW(l, r) if (*(l) < (r)) *(l) = (r) +#define __LOW(l, r) if (*(l) == 0 || *(l) > (r)) *(l) = (r) /* * Combine two io_restrictions, always taking the lower value. @@ -499,7 +499,7 @@ } /* - * Decrement a devices use count and remove it if neccessary. + * Decrement a devices use count and remove it if necessary. */ void dm_put_device(struct dm_target *ti, struct dm_dev *dd) { @@ -591,7 +591,7 @@ tgt->type = dm_get_target_type(type); if (!tgt->type) { tgt->error = "unknown target type"; - goto bad; + return -EINVAL; } tgt->table = t; @@ -604,6 +604,7 @@ */ if (!adjoin(t, tgt)) { tgt->error = "Gap in table"; + r = -EINVAL; goto bad; } diff -Nru a/drivers/md/md.c b/drivers/md/md.c --- a/drivers/md/md.c Tue Mar 4 19:30:05 2003 +++ b/drivers/md/md.c Tue Mar 4 19:30:05 2003 @@ -119,7 +119,7 @@ .procname = "dev", .maxlen = 0, .mode = 0555, - .proc_handler = raid_dir_table, + .child = raid_dir_table, }, { .ctl_name = 0 } }; @@ -1427,7 +1427,7 @@ /* * 'default chunksize' in the old md code used to * be PAGE_SIZE, baaad. - * we abort here to be on the safe side. We dont + * we abort here to be on the safe side. We don't * want to continue the bad practice. */ printk(BAD_CHUNKSIZE); @@ -1731,7 +1731,7 @@ mddev_unlock(mddev); } /* on success, candidates will be empty, on error - * it wont... + * it won't... */ ITERATE_RDEV_GENERIC(candidates,rdev,tmp) export_rdev(rdev); @@ -2290,7 +2290,7 @@ } err = set_array_info(mddev, &info); if (err) { - printk(KERN_WARNING "md: couldnt set array info. %d\n", err); + printk(KERN_WARNING "md: couldn't set array info. %d\n", err); goto abort_unlock; } } diff -Nru a/drivers/media/dvb/av7110/saa7146.c b/drivers/media/dvb/av7110/saa7146.c --- a/drivers/media/dvb/av7110/saa7146.c Tue Mar 4 19:30:04 2003 +++ b/drivers/media/dvb/av7110/saa7146.c Tue Mar 4 19:30:04 2003 @@ -1396,7 +1396,7 @@ saa7146_write(saa->mem, MC2, (MASK_00 | MASK_16)); } - /* if any error is still present, a fatal error has occured ... */ + /* if any error is still present, a fatal error has occurred ... */ if ( SAA7146_I2C_BBR != (status = i2c_status_check(saa)) ) { hprintk("saa7146: i2c_reset: fatal error, status:0x%08x\n",status); return -EIO; @@ -1444,7 +1444,7 @@ /* check for some other mysterious error; we don't handle this here */ if ( 0 != ( status & 0xff)) { - hprintk("saa7146: i2c_write_out: some error has occured\n"); + hprintk("saa7146: i2c_write_out: some error has occurred\n"); return -EIO; } @@ -1570,7 +1570,7 @@ /* check, if DEBI still active */ u32 psr = saa7146_read(saa->mem, PSR); if (0 != (psr & SPCI_DEBI_S)) { - /* check, if error occured */ + /* check, if error occurred */ /* if ( 0 != (saa7146_read(saa->mem, SSR) & (MASK_23|MASK_22))) { */ if ( 0 != (saa7146_read(saa->mem, SSR) & (MASK_22))) { /* clear error status and indicate error */ diff -Nru a/drivers/media/dvb/av7110/saa7146_core.c b/drivers/media/dvb/av7110/saa7146_core.c --- a/drivers/media/dvb/av7110/saa7146_core.c Tue Mar 4 19:30:12 2003 +++ b/drivers/media/dvb/av7110/saa7146_core.c Tue Mar 4 19:30:12 2003 @@ -222,7 +222,7 @@ * we do not start the whole rps1-engine... */ - /* if address-error occured, don't retry */ + /* if address-error occurred, don't retry */ if (i2c_write_out(a, &a->i2c[i], SAA7146_I2C_TIMEOUT) < 0) { hprintk (KERN_ERR "saa7146_core.o: " "i2c error in address phase\n"); diff -Nru a/drivers/media/radio/miropcm20-radio.c b/drivers/media/radio/miropcm20-radio.c --- a/drivers/media/radio/miropcm20-radio.c Tue Mar 4 19:30:05 2003 +++ b/drivers/media/radio/miropcm20-radio.c Tue Mar 4 19:30:05 2003 @@ -15,7 +15,7 @@ */ /* What ever you think about the ACI, version 0x07 is not very well! - * I cant get frequency, 'tuner status', 'tuner flags' or mute/mono + * I can't get frequency, 'tuner status', 'tuner flags' or mute/mono * conditions... Robert */ @@ -93,7 +93,7 @@ } else { /* stereo */ *flags=VIDEO_TUNER_STEREO_ON; - /* I cant see stereo, when forced to mono */ + /* I can't see stereo, when forced to mono */ dev->stereo=1; } diff -Nru a/drivers/media/radio/miropcm20-rds-core.c b/drivers/media/radio/miropcm20-rds-core.c --- a/drivers/media/radio/miropcm20-rds-core.c Tue Mar 4 19:30:13 2003 +++ b/drivers/media/radio/miropcm20-rds-core.c Tue Mar 4 19:30:13 2003 @@ -91,7 +91,7 @@ } } -/* dont use any ..._nowait() function if you are not sure what you do... */ +/* don't use any ..._nowait() function if you are not sure what you do... */ static inline void rds_rawwrite_nowait(unsigned char byte) { diff -Nru a/drivers/media/radio/radio-aimslab.c b/drivers/media/radio/radio-aimslab.c --- a/drivers/media/radio/radio-aimslab.c Tue Mar 4 19:30:05 2003 +++ b/drivers/media/radio/radio-aimslab.c Tue Mar 4 19:30:05 2003 @@ -1,6 +1,6 @@ /* radiotrack (radioreveal) driver for Linux radio support * (c) 1997 M. Kirkwood - * Coverted to new API by Alan Cox + * Converted to new API by Alan Cox * Various bugfixes and enhancements by Russell Kroll * * History: diff -Nru a/drivers/media/radio/radio-gemtek.c b/drivers/media/radio/radio-gemtek.c --- a/drivers/media/radio/radio-gemtek.c Tue Mar 4 19:30:03 2003 +++ b/drivers/media/radio/radio-gemtek.c Tue Mar 4 19:30:03 2003 @@ -8,7 +8,7 @@ * RadioTrack II driver for Linux radio support (C) 1998 Ben Pfaff * * Based on RadioTrack I/RadioReveal (C) 1997 M. Kirkwood - * Coverted to new API by Alan Cox + * Converted to new API by Alan Cox * Various bugfixes and enhancements by Russell Kroll * * TODO: Allow for more than one of these foolish entities :-) diff -Nru a/drivers/media/radio/radio-rtrack2.c b/drivers/media/radio/radio-rtrack2.c --- a/drivers/media/radio/radio-rtrack2.c Tue Mar 4 19:30:11 2003 +++ b/drivers/media/radio/radio-rtrack2.c Tue Mar 4 19:30:11 2003 @@ -1,7 +1,7 @@ /* RadioTrack II driver for Linux radio support (C) 1998 Ben Pfaff * * Based on RadioTrack I/RadioReveal (C) 1997 M. Kirkwood - * Coverted to new API by Alan Cox + * Converted to new API by Alan Cox * Various bugfixes and enhancements by Russell Kroll * * TODO: Allow for more than one of these foolish entities :-) diff -Nru a/drivers/media/radio/radio-sf16fmi.c b/drivers/media/radio/radio-sf16fmi.c --- a/drivers/media/radio/radio-sf16fmi.c Tue Mar 4 19:30:13 2003 +++ b/drivers/media/radio/radio-sf16fmi.c Tue Mar 4 19:30:13 2003 @@ -262,7 +262,7 @@ return -ENODEV; if (pnp_device_attach(dev) < 0) return -EAGAIN; - if (pnp_activate_dev(dev, NULL) < 0) { + if (pnp_activate_dev(dev) < 0) { printk ("radio-sf16fmi: PnP configure failed (out of resources?)\n"); pnp_device_detach(dev); return -ENOMEM; diff -Nru a/drivers/media/radio/radio-terratec.c b/drivers/media/radio/radio-terratec.c --- a/drivers/media/radio/radio-terratec.c Tue Mar 4 19:30:08 2003 +++ b/drivers/media/radio/radio-terratec.c Tue Mar 4 19:30:08 2003 @@ -129,7 +129,7 @@ long rest; unsigned char buffer[25]; /* we have to bit shift 25 registers */ - freq = freq1/160; /* convert the freq. to a nice to handel value */ + freq = freq1/160; /* convert the freq. to a nice to handle value */ for(i=24;i>-1;i--) buffer[i]=0; diff -Nru a/drivers/media/video/saa7110.c b/drivers/media/video/saa7110.c --- a/drivers/media/video/saa7110.c Tue Mar 4 19:30:03 2003 +++ b/drivers/media/video/saa7110.c Tue Mar 4 19:30:03 2003 @@ -33,7 +33,7 @@ #define DEBUG(x...) /* remove when no long debugging */ #define SAA7110_MAX_INPUT 9 /* 6 CVBS, 3 SVHS */ -#define SAA7110_MAX_OUTPUT 0 /* its a decoder only */ +#define SAA7110_MAX_OUTPUT 0 /* it's a decoder only */ #define I2C_SAA7110 0x9C /* or 0x9E */ diff -Nru a/drivers/media/video/zr36067.c b/drivers/media/video/zr36067.c --- a/drivers/media/video/zr36067.c Tue Mar 4 19:30:14 2003 +++ b/drivers/media/video/zr36067.c Tue Mar 4 19:30:14 2003 @@ -3629,7 +3629,7 @@ ("%s: ioctl VIDIOCCAPTURE: %d\n", zr->name, v)); - /* If there is nothing to do, return immediatly */ + /* If there is nothing to do, return immediately */ if ((v && zr->v4l_overlay_active) || (!v && !zr->v4l_overlay_active)) @@ -4048,7 +4048,7 @@ zr->params = bp; - /* Make changes of input and norm go into effect immediatly */ + /* Make changes of input and norm go into effect immediately */ /* We switch overlay off and on since a change in the norm needs different VFE settings */ diff -Nru a/drivers/media/video/zr36120_i2c.c b/drivers/media/video/zr36120_i2c.c --- a/drivers/media/video/zr36120_i2c.c Tue Mar 4 19:30:14 2003 +++ b/drivers/media/video/zr36120_i2c.c Tue Mar 4 19:30:14 2003 @@ -86,7 +86,7 @@ if (ztv->tuner_type >= 0) { if (i2c_control_device(&ztv->i2c,I2C_DRIVERID_TUNER,TUNER_SET_TYPE,&ztv->tuner_type)<0) - DEBUG(printk(CARD_INFO "attach_inform; tuner wont be set to type %d\n",CARD,ztv->tuner_type)); + DEBUG(printk(CARD_INFO "attach_inform; tuner won't be set to type %d\n",CARD,ztv->tuner_type)); } break; default: diff -Nru a/drivers/message/fusion/mptlan.c b/drivers/message/fusion/mptlan.c --- a/drivers/message/fusion/mptlan.c Tue Mar 4 19:30:08 2003 +++ b/drivers/message/fusion/mptlan.c Tue Mar 4 19:30:08 2003 @@ -242,7 +242,7 @@ // would Oops because mf has already been set // to NULL. So after return from this func, // mpt_interrupt() will attempt to put (NULL) mf ptr - // item back onto it's adapter FreeQ - Oops!:-( + // item back onto its adapter FreeQ - Oops!:-( // It's Ok, since mpt_lan_send_turbo() *currently* // always returns 0, but..., just in case: diff -Nru a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c --- a/drivers/message/fusion/mptscsih.c Tue Mar 4 19:30:07 2003 +++ b/drivers/message/fusion/mptscsih.c Tue Mar 4 19:30:07 2003 @@ -116,7 +116,7 @@ #define MPT_ICFLAG_ECHO 0x02 /* ReadBuffer Echo buffer format */ #define MPT_ICFLAG_PHYS_DISK 0x04 /* Any SCSI IO but do Phys Disk Format */ #define MPT_ICFLAG_TAGGED_CMD 0x08 /* Do tagged IO */ -#define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occured with this command */ +#define MPT_ICFLAG_DID_RESET 0x20 /* Bus Reset occurred with this command */ #define MPT_ICFLAG_RESERVED 0x40 /* Reserved has been issued */ typedef struct _internal_cmd { @@ -4207,7 +4207,7 @@ /* * Need to check ASC here; if it is "special," then * the ASCQ is variable, and indicates failed component number. - * We must treat the ASCQ as a "dont care" while searching the + * We must treat the ASCQ as a "don't care" while searching the * mptscsih_ASCQ_Table[] by masking it off, and then restoring it later * on when we actually need to identify the failed component. */ diff -Nru a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c --- a/drivers/message/i2o/i2o_block.c Tue Mar 4 19:30:11 2003 +++ b/drivers/message/i2o/i2o_block.c Tue Mar 4 19:30:11 2003 @@ -798,7 +798,7 @@ /* * Queue depths probably belong with some kind of - * generic IOP commit control. Certainly its not right + * generic IOP commit control. Certainly it's not right * its global! */ if(atomic_read(&i2ob_queues[dev->unit]->queue_depth) >= dev->depth) @@ -1729,7 +1729,7 @@ * We may get further callbacks for ourself. The i2o_core * code handles this case reasonably sanely. The problem here * is we shouldn't get them .. but a couple of cards feel - * obliged to tell us stuff we dont care about. + * obliged to tell us stuff we don't care about. * * This isnt ideal at all but will do for now. */ diff -Nru a/drivers/message/i2o/i2o_core.c b/drivers/message/i2o/i2o_core.c --- a/drivers/message/i2o/i2o_core.c Tue Mar 4 19:30:10 2003 +++ b/drivers/message/i2o/i2o_core.c Tue Mar 4 19:30:10 2003 @@ -340,7 +340,7 @@ /* * Each I2O controller has a chain of devices on it. - * Each device has a pointer to it's LCT entry to be used + * Each device has a pointer to its LCT entry to be used * for fun purposes. */ @@ -2120,7 +2120,7 @@ * @iop: controller * * This function brings an I2O controller into HOLD state. The adapter - * is reset if neccessary and then the queues and resource table + * is reset if necessary and then the queues and resource table * are read. -1 is returned on a failure, 0 on success. * */ diff -Nru a/drivers/mtd/chips/amd_flash.c b/drivers/mtd/chips/amd_flash.c --- a/drivers/mtd/chips/amd_flash.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/chips/amd_flash.c Tue Mar 4 19:30:05 2003 @@ -120,10 +120,10 @@ static struct mtd_chip_driver amd_flash_chipdrv = { - probe: amd_flash_probe, - destroy: amd_flash_destroy, - name: "amd_flash", - module: THIS_MODULE + .probe = amd_flash_probe, + .destroy = amd_flash_destroy, + .name = "amd_flash", + .module = THIS_MODULE }; @@ -424,194 +424,194 @@ */ const struct amd_flash_info table[] = { { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV160DT, - name: "AMD AM29LV160DT", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 31 }, - { offset: 0x1F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x1F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x1FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV160DB, - name: "AMD AM29LV160DB", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 31 } - } - }, { - mfr_id: MANUFACTURER_TOSHIBA, - dev_id: TC58FVT160, - name: "Toshiba TC58FVT160", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 31 }, - { offset: 0x1F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x1F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x1FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_FUJITSU, - dev_id: MBM29LV160TE, - name: "Fujitsu MBM29LV160TE", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 31 }, - { offset: 0x1F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x1F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x1FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_TOSHIBA, - dev_id: TC58FVB160, - name: "Toshiba TC58FVB160", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 31 } - } - }, { - mfr_id: MANUFACTURER_FUJITSU, - dev_id: MBM29LV160BE, - name: "Fujitsu MBM29LV160BE", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 31 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BB, - name: "AMD AM29LV800BB", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 15 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29F800BB, - name: "AMD AM29F800BB", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 15 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BT, - name: "AMD AM29LV800BT", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 15 }, - { offset: 0x0F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x0F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x0FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29F800BT, - name: "AMD AM29F800BT", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 15 }, - { offset: 0x0F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x0F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x0FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BB, - name: "AMD AM29LV800BB", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 15 }, - { offset: 0x0F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x0F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x0FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W800T, - name: "ST M29W800T", - size: 0x00100000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 15 }, - { offset: 0x0F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x0F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x0FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W160DT, - name: "ST M29W160DT", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 31 }, - { offset: 0x1F0000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x1F8000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x1FC000, erasesize: 0x04000, numblocks: 1 } - } - }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W160DB, - name: "ST M29W160DB", - size: 0x00200000, - numeraseregions: 4, - regions: { - { offset: 0x000000, erasesize: 0x04000, numblocks: 1 }, - { offset: 0x004000, erasesize: 0x02000, numblocks: 2 }, - { offset: 0x008000, erasesize: 0x08000, numblocks: 1 }, - { offset: 0x010000, erasesize: 0x10000, numblocks: 31 } - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29BDS323D, - name: "AMD AM29BDS323D", - size: 0x00400000, - numeraseregions: 3, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 48 }, - { offset: 0x300000, erasesize: 0x10000, numblocks: 15 }, - { offset: 0x3f0000, erasesize: 0x02000, numblocks: 8 }, - } - }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29BDS643D, - name: "AMD AM29BDS643D", - size: 0x00800000, - numeraseregions: 3, - regions: { - { offset: 0x000000, erasesize: 0x10000, numblocks: 96 }, - { offset: 0x600000, erasesize: 0x10000, numblocks: 31 }, - { offset: 0x7f0000, erasesize: 0x02000, numblocks: 8 }, + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV160DT, + .name = "AMD AM29LV160DT", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 31 }, + { .offset = 0x1F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x1F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x1FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV160DB, + .name = "AMD AM29LV160DB", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 31 } + } + }, { + .mfr_id = MANUFACTURER_TOSHIBA, + .dev_id = TC58FVT160, + .name = "Toshiba TC58FVT160", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 31 }, + { .offset = 0x1F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x1F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x1FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_FUJITSU, + .dev_id = MBM29LV160TE, + .name = "Fujitsu MBM29LV160TE", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 31 }, + { .offset = 0x1F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x1F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x1FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_TOSHIBA, + .dev_id = TC58FVB160, + .name = "Toshiba TC58FVB160", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 31 } + } + }, { + .mfr_id = MANUFACTURER_FUJITSU, + .dev_id = MBM29LV160BE, + .name = "Fujitsu MBM29LV160BE", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 31 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BB, + .name = "AMD AM29LV800BB", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 15 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29F800BB, + .name = "AMD AM29F800BB", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 15 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BT, + .name = "AMD AM29LV800BT", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 15 }, + { .offset = 0x0F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x0F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x0FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29F800BT, + .name = "AMD AM29F800BT", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 15 }, + { .offset = 0x0F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x0F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x0FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BB, + .name = "AMD AM29LV800BB", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 15 }, + { .offset = 0x0F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x0F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x0FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W800T, + .name = "ST M29W800T", + .size = 0x00100000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 15 }, + { .offset = 0x0F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x0F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x0FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W160DT, + .name = "ST M29W160DT", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 31 }, + { .offset = 0x1F0000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x1F8000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x1FC000, .erasesize = 0x04000, .numblocks = 1 } + } + }, { + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W160DB, + .name = "ST M29W160DB", + .size = 0x00200000, + .numeraseregions = 4, + .regions = { + { .offset = 0x000000, .erasesize = 0x04000, .numblocks = 1 }, + { .offset = 0x004000, .erasesize = 0x02000, .numblocks = 2 }, + { .offset = 0x008000, .erasesize = 0x08000, .numblocks = 1 }, + { .offset = 0x010000, .erasesize = 0x10000, .numblocks = 31 } + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29BDS323D, + .name = "AMD AM29BDS323D", + .size = 0x00400000, + .numeraseregions = 3, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 48 }, + { .offset = 0x300000, .erasesize = 0x10000, .numblocks = 15 }, + { .offset = 0x3f0000, .erasesize = 0x02000, .numblocks = 8 }, + } + }, { + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29BDS643D, + .name = "AMD AM29BDS643D", + .size = 0x00800000, + .numeraseregions = 3, + .regions = { + { .offset = 0x000000, .erasesize = 0x10000, .numblocks = 96 }, + { .offset = 0x600000, .erasesize = 0x10000, .numblocks = 31 }, + { .offset = 0x7f0000, .erasesize = 0x02000, .numblocks = 8 }, } } }; diff -Nru a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c --- a/drivers/mtd/chips/cfi_cmdset_0001.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/chips/cfi_cmdset_0001.c Tue Mar 4 19:30:05 2003 @@ -47,10 +47,10 @@ static struct mtd_info *cfi_intelext_setup (struct map_info *); static struct mtd_chip_driver cfi_intelext_chipdrv = { - probe: NULL, /* Not usable directly */ - destroy: cfi_intelext_destroy, - name: "cfi_cmdset_0001", - module: THIS_MODULE + .probe = NULL, /* Not usable directly */ + .destroy = cfi_intelext_destroy, + .name = "cfi_cmdset_0001", + .module = THIS_MODULE }; /* #define DEBUG_LOCK_BITS */ diff -Nru a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c --- a/drivers/mtd/chips/cfi_cmdset_0002.c Tue Mar 4 19:30:08 2003 +++ b/drivers/mtd/chips/cfi_cmdset_0002.c Tue Mar 4 19:30:08 2003 @@ -43,10 +43,10 @@ static struct mtd_chip_driver cfi_amdstd_chipdrv = { - probe: NULL, /* Not usable directly */ - destroy: cfi_amdstd_destroy, - name: "cfi_cmdset_0002", - module: THIS_MODULE + .probe = NULL, /* Not usable directly */ + .destroy = cfi_amdstd_destroy, + .name = "cfi_cmdset_0002", + .module = THIS_MODULE }; struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary) diff -Nru a/drivers/mtd/chips/cfi_probe.c b/drivers/mtd/chips/cfi_probe.c --- a/drivers/mtd/chips/cfi_probe.c Tue Mar 4 19:30:12 2003 +++ b/drivers/mtd/chips/cfi_probe.c Tue Mar 4 19:30:12 2003 @@ -294,8 +294,8 @@ #endif /* DEBUG_CFI */ static struct chip_probe cfi_chip_probe = { - name: "CFI", - probe_chip: cfi_probe_chip + .name = "CFI", + .probe_chip = cfi_probe_chip }; struct mtd_info *cfi_probe(struct map_info *map) @@ -308,9 +308,9 @@ } static struct mtd_chip_driver cfi_chipdrv = { - probe: cfi_probe, - name: "cfi_probe", - module: THIS_MODULE + .probe = cfi_probe, + .name = "cfi_probe", + .module = THIS_MODULE }; int __init cfi_probe_init(void) diff -Nru a/drivers/mtd/chips/jedec.c b/drivers/mtd/chips/jedec.c --- a/drivers/mtd/chips/jedec.c Tue Mar 4 19:30:10 2003 +++ b/drivers/mtd/chips/jedec.c Tue Mar 4 19:30:10 2003 @@ -33,14 +33,51 @@ /* Listing of parts and sizes. We need this table to learn the sector size of the chip and the total length */ -static const struct JEDECTable JEDEC_table[] = - {{0x013D,"AMD Am29F017D",2*1024*1024,64*1024,MTD_CAP_NORFLASH}, - {0x01AD,"AMD Am29F016",2*1024*1024,64*1024,MTD_CAP_NORFLASH}, - {0x01D5,"AMD Am29F080",1*1024*1024,64*1024,MTD_CAP_NORFLASH}, - {0x01A4,"AMD Am29F040",512*1024,64*1024,MTD_CAP_NORFLASH}, - {0x20E3,"AMD Am29W040B",512*1024,64*1024,MTD_CAP_NORFLASH}, - {0xC2AD,"Macronix MX29F016",2*1024*1024,64*1024,MTD_CAP_NORFLASH}, - {}}; +static const struct JEDECTable JEDEC_table[] = { + { + .jedec = 0x013D, + .name = "AMD Am29F017D", + .size = 2*1024*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { + .jedec = 0x01AD, + .name = "AMD Am29F016", + .size = 2*1024*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { + .jedec = 0x01D5, + .name = "AMD Am29F080", + .size = 1*1024*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { + .jedec = 0x01A4, + .name = "AMD Am29F040", + .size = 512*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { + .jedec = 0x20E3, + .name = "AMD Am29W040B", + .size = 512*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { + .jedec = 0xC2AD, + .name = "Macronix MX29F016", + .size = 2*1024*1024, + .sectorsize = 64*1024, + .capabilities = MTD_CAP_NORFLASH + }, + { .jedec = 0x0 } +}; static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id); static void jedec_sync(struct mtd_info *mtd) {}; @@ -54,9 +91,9 @@ static struct mtd_chip_driver jedec_chipdrv = { - probe: jedec_probe, - name: "jedec", - module: THIS_MODULE + .probe = jedec_probe, + .name = "jedec", + .module = THIS_MODULE }; /* Probe entry point */ diff -Nru a/drivers/mtd/chips/jedec_probe.c b/drivers/mtd/chips/jedec_probe.c --- a/drivers/mtd/chips/jedec_probe.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/chips/jedec_probe.c Tue Mar 4 19:30:14 2003 @@ -75,176 +75,176 @@ static const struct amd_flash_info jedec_table[] = { { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV160DT, - name: "AMD AM29LV160DT", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,31), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV160DT, + .name = "AMD AM29LV160DT", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,31), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV160DB, - name: "AMD AM29LV160DB", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV160DB, + .name = "AMD AM29LV160DB", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,31) } }, { - mfr_id: MANUFACTURER_TOSHIBA, - dev_id: TC58FVT160, - name: "Toshiba TC58FVT160", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,31), + .mfr_id = MANUFACTURER_TOSHIBA, + .dev_id = TC58FVT160, + .name = "Toshiba TC58FVT160", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,31), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_FUJITSU, - dev_id: MBM29LV160TE, - name: "Fujitsu MBM29LV160TE", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,31), + .mfr_id = MANUFACTURER_FUJITSU, + .dev_id = MBM29LV160TE, + .name = "Fujitsu MBM29LV160TE", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,31), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_TOSHIBA, - dev_id: TC58FVB160, - name: "Toshiba TC58FVB160", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_TOSHIBA, + .dev_id = TC58FVB160, + .name = "Toshiba TC58FVB160", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,31) } }, { - mfr_id: MANUFACTURER_FUJITSU, - dev_id: MBM29LV160BE, - name: "Fujitsu MBM29LV160BE", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_FUJITSU, + .dev_id = MBM29LV160BE, + .name = "Fujitsu MBM29LV160BE", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,31) } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BB, - name: "AMD AM29LV800BB", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BB, + .name = "AMD AM29LV800BB", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,15), } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29F800BB, - name: "AMD AM29F800BB", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29F800BB, + .name = "AMD AM29F800BB", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,15), } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BT, - name: "AMD AM29LV800BT", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,15), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BT, + .name = "AMD AM29LV800BT", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,15), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29F800BT, - name: "AMD AM29F800BT", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,15), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29F800BT, + .name = "AMD AM29F800BT", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,15), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_AMD, - dev_id: AM29LV800BB, - name: "AMD AM29LV800BB", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,15), + .mfr_id = MANUFACTURER_AMD, + .dev_id = AM29LV800BB, + .name = "AMD AM29LV800BB", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,15), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W800T, - name: "ST M29W800T", - DevSize: SIZE_1MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,15), + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W800T, + .name = "ST M29W800T", + .DevSize = SIZE_1MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,15), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W160DT, - name: "ST M29W160DT", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x10000,31), + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W160DT, + .name = "ST M29W160DT", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x10000,31), ERASEINFO(0x08000,1), ERASEINFO(0x02000,2), ERASEINFO(0x04000,1) } }, { - mfr_id: MANUFACTURER_ST, - dev_id: M29W160DB, - name: "ST M29W160DB", - DevSize: SIZE_2MiB, - NumEraseRegions: 4, - regions: {ERASEINFO(0x04000,1), + .mfr_id = MANUFACTURER_ST, + .dev_id = M29W160DB, + .name = "ST M29W160DB", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 4, + .regions = {ERASEINFO(0x04000,1), ERASEINFO(0x02000,2), ERASEINFO(0x08000,1), ERASEINFO(0x10000,31) } }, { - mfr_id: MANUFACTURER_ATMEL, - dev_id: AT49BV16X4, - name: "Atmel AT49BV16X4", - DevSize: SIZE_2MiB, - NumEraseRegions: 3, - regions: {ERASEINFO(0x02000,8), + .mfr_id = MANUFACTURER_ATMEL, + .dev_id = AT49BV16X4, + .name = "Atmel AT49BV16X4", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 3, + .regions = {ERASEINFO(0x02000,8), ERASEINFO(0x08000,2), ERASEINFO(0x10000,30) } }, { - mfr_id: MANUFACTURER_ATMEL, - dev_id: AT49BV16X4T, - name: "Atmel AT49BV16X4T", - DevSize: SIZE_2MiB, - NumEraseRegions: 3, - regions: {ERASEINFO(0x10000,30), + .mfr_id = MANUFACTURER_ATMEL, + .dev_id = AT49BV16X4T, + .name = "Atmel AT49BV16X4T", + .DevSize = SIZE_2MiB, + .NumEraseRegions = 3, + .regions = {ERASEINFO(0x10000,30), ERASEINFO(0x08000,2), ERASEINFO(0x02000,8) } @@ -403,8 +403,8 @@ } static struct chip_probe jedec_chip_probe = { - name: "JEDEC", - probe_chip: jedec_probe_chip + .name = "JEDEC", + .probe_chip = jedec_probe_chip }; struct mtd_info *jedec_probe(struct map_info *map) @@ -417,9 +417,9 @@ } static struct mtd_chip_driver jedec_chipdrv = { - probe: jedec_probe, - name: "jedec_probe", - module: THIS_MODULE + .probe = jedec_probe, + .name = "jedec_probe", + .module = THIS_MODULE }; int __init jedec_probe_init(void) diff -Nru a/drivers/mtd/chips/map_absent.c b/drivers/mtd/chips/map_absent.c --- a/drivers/mtd/chips/map_absent.c Tue Mar 4 19:30:11 2003 +++ b/drivers/mtd/chips/map_absent.c Tue Mar 4 19:30:11 2003 @@ -36,10 +36,10 @@ static struct mtd_chip_driver map_absent_chipdrv = { - probe: map_absent_probe, - destroy: map_absent_destroy, - name: "map_absent", - module: THIS_MODULE + .probe = map_absent_probe, + .destroy = map_absent_destroy, + .name = "map_absent", + .module = THIS_MODULE }; static struct mtd_info *map_absent_probe(struct map_info *map) diff -Nru a/drivers/mtd/chips/map_ram.c b/drivers/mtd/chips/map_ram.c --- a/drivers/mtd/chips/map_ram.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/chips/map_ram.c Tue Mar 4 19:30:05 2003 @@ -23,9 +23,9 @@ static struct mtd_chip_driver mapram_chipdrv = { - probe: map_ram_probe, - name: "map_ram", - module: THIS_MODULE + .probe = map_ram_probe, + .name = "map_ram", + .module = THIS_MODULE }; static struct mtd_info *map_ram_probe(struct map_info *map) diff -Nru a/drivers/mtd/chips/map_rom.c b/drivers/mtd/chips/map_rom.c --- a/drivers/mtd/chips/map_rom.c Tue Mar 4 19:30:10 2003 +++ b/drivers/mtd/chips/map_rom.c Tue Mar 4 19:30:10 2003 @@ -21,9 +21,9 @@ struct mtd_info *map_rom_probe(struct map_info *map); static struct mtd_chip_driver maprom_chipdrv = { - probe: map_rom_probe, - name: "map_rom", - module: THIS_MODULE + .probe = map_rom_probe, + .name = "map_rom", + .module = THIS_MODULE }; struct mtd_info *map_rom_probe(struct map_info *map) diff -Nru a/drivers/mtd/chips/sharp.c b/drivers/mtd/chips/sharp.c --- a/drivers/mtd/chips/sharp.c Tue Mar 4 19:30:09 2003 +++ b/drivers/mtd/chips/sharp.c Tue Mar 4 19:30:09 2003 @@ -98,10 +98,10 @@ static void sharp_destroy(struct mtd_info *mtd); static struct mtd_chip_driver sharp_chipdrv = { - probe: sharp_probe, - destroy: sharp_destroy, - name: "sharp", - module: THIS_MODULE + .probe = sharp_probe, + .destroy = sharp_destroy, + .name = "sharp", + .module = THIS_MODULE }; diff -Nru a/drivers/mtd/devices/blkmtd.c b/drivers/mtd/devices/blkmtd.c --- a/drivers/mtd/devices/blkmtd.c Tue Mar 4 19:30:04 2003 +++ b/drivers/mtd/devices/blkmtd.c Tue Mar 4 19:30:04 2003 @@ -16,7 +16,7 @@ * thread writes pages out to the device in the background. This * ensures that writes are order even if a page is updated twice. * Also, since pages in the page cache are never marked as dirty, - * we dont have to worry about writepage() being called on some + * we don't have to worry about writepage() being called on some * random page which may not be in the write order. * * Erases are handled like writes, so the callback is called after @@ -33,7 +33,7 @@ * Page cache usage may still be a bit wrong. Check we are doing * everything properly. * - * Somehow allow writes to dirty the page cache so we dont use too + * Somehow allow writes to dirty the page cache so we don't use too * much memory making copies of outgoing pages. Need to handle case * where page x is written to, then page y, then page x again before * any of them have been committed to disk. @@ -217,7 +217,7 @@ DEBUG(3, "blkmtd: readpage: getting kiovec\n"); err = alloc_kiovec(1, &iobuf); if (err) { - printk("blkmtd: cant allocate kiobuf\n"); + printk("blkmtd: can't allocate kiobuf\n"); SetPageError(page); return err; } @@ -226,7 +226,7 @@ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,4) blocks = kmalloc(KIO_MAX_SECTORS * sizeof(*blocks)); if(blocks == NULL) { - printk("blkmtd: cant allocate iobuf blocks\n"); + printk("blkmtd: can't allocate iobuf blocks\n"); free_kiovec(1, &iobuf); SetPageError(page); return -ENOMEM; @@ -306,7 +306,7 @@ daemonize("blkmtdd"); if(alloc_kiovec(1, &iobuf)) { - printk("blkmtd: write_queue_task cant allocate kiobuf\n"); + printk("blkmtd: write_queue_task can't allocate kiobuf\n"); return 0; } @@ -314,7 +314,7 @@ #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,4) blocks = kmalloc(KIO_MAX_SECTORS * sizeof(unsigned long)); if(blocks == NULL) { - printk("blkmtd: write_queue_task cant allocate iobuf blocks\n"); + printk("blkmtd: write_queue_task can't allocate iobuf blocks\n"); free_kiovec(1, &iobuf); return 0; } @@ -350,7 +350,7 @@ int max_sectors = KIO_MAX_SECTORS >> (item->rawdevice->sector_bits - 9); /* If we are writing to the last page on the device and it doesn't end - * on a page boundary, subtract the number of sectors that dont exist. + * on a page boundary, subtract the number of sectors that don't exist. */ if(item->rawdevice->partial_last_page && (item->pagenr + item->pagecnt -1) == item->rawdevice->partial_last_page) { @@ -394,7 +394,7 @@ err = brw_kiovec(WRITE, 1, &iobuf, item->rawdevice->binding, blocks, item->rawdevice->sector_size); DEBUG(3, "bklmtd: write_task: done, err = %d\n", err); if(err != (cursectors << item->rawdevice->sector_bits)) { - /* if an error occured - set this to exit the loop */ + /* if an error occurred - set this to exit the loop */ sectorcnt = 0; } else { sectorcnt -= cursectors; @@ -794,7 +794,7 @@ page = grab_cache_page(&rawdevice->as, pagenr); DEBUG(3, "blkmtd: write: got page %d from page cache\n", pagenr); if(!page) { - printk("blkmtd: write: cant grab cache page %d\n", pagenr); + printk("blkmtd: write: can't grab cache page %d\n", pagenr); err = -EIO; goto write_err; } @@ -1090,7 +1090,7 @@ file = filp_open(device, mode, 0); if(IS_ERR(file)) { - printk("blkmtd: error, cant open device %s\n", device); + printk("blkmtd: error, can't open device %s\n", device); DEBUG(2, "blkmtd: filp_open returned %ld\n", PTR_ERR(file)); return 1; } @@ -1144,7 +1144,7 @@ DEBUG(1, "blkmtd: size = %ld\n", (long int)size); if(size == 0) { - printk("blkmtd: cant determine size\n"); + printk("blkmtd: can't determine size\n"); blkdev_put(bdev, BDEV_RAW); return 1; } diff -Nru a/drivers/mtd/devices/pmc551.c b/drivers/mtd/devices/pmc551.c --- a/drivers/mtd/devices/pmc551.c Tue Mar 4 19:30:12 2003 +++ b/drivers/mtd/devices/pmc551.c Tue Mar 4 19:30:12 2003 @@ -30,7 +30,7 @@ * * Notes: * Due to what I assume is more buggy SROM, the 64M PMC551 I - * have available claims that all 4 of it's DRAM banks have 64M + * have available claims that all 4 of its DRAM banks have 64M * of ram configured (making a grand total of 256M onboard). * This is slightly annoying since the BAR0 size reflects the * aperture size, not the dram size, and the V370PDC supplies no diff -Nru a/drivers/mtd/ftl.c b/drivers/mtd/ftl.c --- a/drivers/mtd/ftl.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/ftl.c Tue Mar 4 19:30:13 2003 @@ -155,8 +155,8 @@ void ftl_freepart(partition_t *part); static struct mtd_notifier ftl_notifier = { - add: ftl_notify_add, - remove: ftl_notify_remove, + .add = ftl_notify_add, + .remove = ftl_notify_remove, }; /* Partition state flags */ diff -Nru a/drivers/mtd/maps/autcpu12-nvram.c b/drivers/mtd/maps/autcpu12-nvram.c --- a/drivers/mtd/maps/autcpu12-nvram.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/autcpu12-nvram.c Tue Mar 4 19:30:13 2003 @@ -83,17 +83,17 @@ static struct mtd_info *sram_mtd; struct map_info autcpu12_sram_map = { - name: "SRAM", - size: 32768, - buswidth: 8, - read8: autcpu12_read8, - read16: autcpu12_read16, - read32: autcpu12_read32, - copy_from: autcpu12_copy_from, - write8: autcpu12_write8, - write16: autcpu12_write16, - write32: autcpu12_write32, - copy_to: autcpu12_copy_to + .name = "SRAM", + .size = 32768, + .buswidth = 8, + .read8 = autcpu12_read8, + .read16 = autcpu12_read16, + .read32 = autcpu12_read32, + .copy_from = autcpu12_copy_from, + .write8 = autcpu12_write8, + .write16 = autcpu12_write16, + .write32 = autcpu12_write32, + .copy_to = autcpu12_copy_to }; static int __init init_autcpu12_sram (void) diff -Nru a/drivers/mtd/maps/cdb89712.c b/drivers/mtd/maps/cdb89712.c --- a/drivers/mtd/maps/cdb89712.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/maps/cdb89712.c Tue Mar 4 19:30:14 2003 @@ -14,8 +14,6 @@ #include #include - - __u8 cdb89712_read8(struct map_info *map, unsigned long ofs) { return __raw_readb(map->map_priv_1 + ofs); @@ -65,28 +63,27 @@ } } - static struct mtd_info *flash_mtd; struct map_info cdb89712_flash_map = { - name: "flash", - size: FLASH_SIZE, - buswidth: FLASH_WIDTH, - read8: cdb89712_read8, - read16: cdb89712_read16, - read32: cdb89712_read32, - copy_from: cdb89712_copy_from, - write8: cdb89712_write8, - write16: cdb89712_write16, - write32: cdb89712_write32, - copy_to: cdb89712_copy_to + .name = "flash", + .size = FLASH_SIZE, + .buswidth = FLASH_WIDTH, + .read8 = cdb89712_read8, + .read16 = cdb89712_read16, + .read32 = cdb89712_read32, + .copy_from = cdb89712_copy_from, + .write8 = cdb89712_write8, + .write16 = cdb89712_write16, + .write32 = cdb89712_write32, + .copy_to = cdb89712_copy_to }; struct resource cdb89712_flash_resource = { - name: "Flash", - start: FLASH_START, - end: FLASH_START + FLASH_SIZE - 1, - flags: IORESOURCE_IO | IORESOURCE_BUSY, + .name = "Flash", + .start = FLASH_START, + .end = FLASH_START + FLASH_SIZE - 1, + .flags = IORESOURCE_IO | IORESOURCE_BUSY, }; static int __init init_cdb89712_flash (void) @@ -139,31 +136,27 @@ return err; } - - - - static struct mtd_info *sram_mtd; struct map_info cdb89712_sram_map = { - name: "SRAM", - size: SRAM_SIZE, - buswidth: SRAM_WIDTH, - read8: cdb89712_read8, - read16: cdb89712_read16, - read32: cdb89712_read32, - copy_from: cdb89712_copy_from, - write8: cdb89712_write8, - write16: cdb89712_write16, - write32: cdb89712_write32, - copy_to: cdb89712_copy_to + .name = "SRAM", + .size = SRAM_SIZE, + .buswidth = SRAM_WIDTH, + .read8 = cdb89712_read8, + .read16 = cdb89712_read16, + .read32 = cdb89712_read32, + .copy_from = cdb89712_copy_from, + .write8 = cdb89712_write8, + .write16 = cdb89712_write16, + .write32 = cdb89712_write32, + .copy_to = cdb89712_copy_to }; struct resource cdb89712_sram_resource = { - name: "SRAM", - start: SRAM_START, - end: SRAM_START + SRAM_SIZE - 1, - flags: IORESOURCE_IO | IORESOURCE_BUSY, + .name = "SRAM", + .start = SRAM_START, + .end = SRAM_START + SRAM_SIZE - 1, + .flags = IORESOURCE_IO | IORESOURCE_BUSY, }; static int __init init_cdb89712_sram (void) @@ -212,29 +205,23 @@ return err; } - - - - - - static struct mtd_info *bootrom_mtd; struct map_info cdb89712_bootrom_map = { - name: "BootROM", - size: BOOTROM_SIZE, - buswidth: BOOTROM_WIDTH, - read8: cdb89712_read8, - read16: cdb89712_read16, - read32: cdb89712_read32, - copy_from: cdb89712_copy_from, + .name = "BootROM", + .size = BOOTROM_SIZE, + .buswidth = BOOTROM_WIDTH, + .read8 = cdb89712_read8, + .read16 = cdb89712_read16, + .read32 = cdb89712_read32, + .copy_from = cdb89712_copy_from, }; struct resource cdb89712_bootrom_resource = { - name: "BootROM", - start: BOOTROM_START, - end: BOOTROM_START + BOOTROM_SIZE - 1, - flags: IORESOURCE_IO | IORESOURCE_BUSY, + .name = "BootROM", + .start = BOOTROM_START, + .end = BOOTROM_START + BOOTROM_SIZE - 1, + .flags = IORESOURCE_IO | IORESOURCE_BUSY, }; static int __init init_cdb89712_bootrom (void) @@ -282,10 +269,6 @@ out: return err; } - - - - static int __init init_cdb89712_maps(void) { diff -Nru a/drivers/mtd/maps/ceiva.c b/drivers/mtd/maps/ceiva.c --- a/drivers/mtd/maps/ceiva.c Tue Mar 4 19:30:07 2003 +++ b/drivers/mtd/maps/ceiva.c Tue Mar 4 19:30:07 2003 @@ -76,15 +76,15 @@ } static struct map_info clps_map __initdata = { - name: "clps flash", - read8: clps_read8, - read16: clps_read16, - read32: clps_read32, - copy_from: clps_copy_from, - write8: clps_write8, - write16: clps_write16, - write32: clps_write32, - copy_to: clps_copy_to, + .name = "clps flash", + .read8 = clps_read8, + .read16 = clps_read16, + .read32 = clps_read32, + .copy_from = clps_copy_from, + .write8 = clps_write8, + .write16 = clps_write16, + .write32 = clps_write32, + .copy_to = clps_copy_to, }; #ifdef CONFIG_MTD_CEIVA_STATICMAP @@ -94,7 +94,7 @@ * * Please note: * 1. The flash size given should be the largest flash size that can - * be accomodated. + * be accommodated. * * 2. The bus width must defined in clps_setup_flash. * @@ -115,23 +115,25 @@ static struct mtd_partition ceiva_partitions[] = { { - name: "Ceiva BOOT partition", - size: BOOT_PARTITION_SIZE_KiB*1024, - offset: 0, + .name = "Ceiva BOOT partition", + .size = BOOT_PARTITION_SIZE_KiB*1024, - },{ - name: "Ceiva parameters partition", - size: PARAMS_PARTITION_SIZE_KiB*1024, - offset: (16 + 8) * 1024, - },{ - name: "Ceiva kernel partition", - size: (KERNEL_PARTITION_SIZE_KiB)*1024, - offset: 0x20000, + }, + { + .name = "Ceiva parameters partition", + .size = PARAMS_PARTITION_SIZE_KiB*1024, + .offset = (16 + 8) * 1024, + }, + { + .name = "Ceiva kernel partition", + .size = (KERNEL_PARTITION_SIZE_KiB)*1024, + .offset = 0x20000, - },{ - name: "Ceiva root filesystem partition", - offset: MTDPART_OFS_APPEND, - size: (ROOT_PARTITION_SIZE_KiB)*1024, + }, + { + .name = "Ceiva root filesystem partition", + .offset = MTDPART_OFS_APPEND, + .size = (ROOT_PARTITION_SIZE_KiB)*1024, } }; #endif diff -Nru a/drivers/mtd/maps/cfi_flagadm.c b/drivers/mtd/maps/cfi_flagadm.c --- a/drivers/mtd/maps/cfi_flagadm.c Tue Mar 4 19:30:03 2003 +++ b/drivers/mtd/maps/cfi_flagadm.c Tue Mar 4 19:30:03 2003 @@ -99,39 +99,39 @@ } struct map_info flagadm_map = { - name: "FlagaDM flash device", - size: FLASH_SIZE, - buswidth: 2, - read8: flagadm_read8, - read16: flagadm_read16, - read32: flagadm_read32, - copy_from: flagadm_copy_from, - write8: flagadm_write8, - write16: flagadm_write16, - write32: flagadm_write32, - copy_to: flagadm_copy_to + .name = "FlagaDM flash device", + .size = FLASH_SIZE, + .buswidth = 2, + .read8 = flagadm_read8, + .read16 = flagadm_read16, + .read32 = flagadm_read32, + .copy_from = flagadm_copy_from, + .write8 = flagadm_write8, + .write16 = flagadm_write16, + .write32 = flagadm_write32, + .copy_to = flagadm_copy_to }; struct mtd_partition flagadm_parts[] = { { - name : "Bootloader", - offset : FLASH_PARTITION0_ADDR, - size : FLASH_PARTITION0_SIZE + .name = "Bootloader", + .offset = FLASH_PARTITION0_ADDR, + .size = FLASH_PARTITION0_SIZE }, { - name : "Kernel image", - offset : FLASH_PARTITION1_ADDR, - size : FLASH_PARTITION1_SIZE + .name = "Kernel image", + .offset = FLASH_PARTITION1_ADDR, + .size = FLASH_PARTITION1_SIZE }, { - name : "Initial ramdisk image", - offset : FLASH_PARTITION2_ADDR, - size : FLASH_PARTITION2_SIZE + .name = "Initial ramdisk image", + .offset = FLASH_PARTITION2_ADDR, + .size = FLASH_PARTITION2_SIZE }, { - name : "Persistant storage", - offset : FLASH_PARTITION3_ADDR, - size : FLASH_PARTITION3_SIZE + .name = "Persistant storage", + .offset = FLASH_PARTITION3_ADDR, + .size = FLASH_PARTITION3_SIZE } }; diff -Nru a/drivers/mtd/maps/cstm_mips_ixx.c b/drivers/mtd/maps/cstm_mips_ixx.c --- a/drivers/mtd/maps/cstm_mips_ixx.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/cstm_mips_ixx.c Tue Mar 4 19:30:05 2003 @@ -5,7 +5,7 @@ * Config with both CFI and JEDEC device support. * * Basically physmap.c with the addition of partitions and - * an array of mapping info to accomodate more than one flash type per board. + * an array of mapping info to accommodate more than one flash type per board. * * Copyright 2000 MontaVista Software Inc. * @@ -132,20 +132,15 @@ } const struct map_info basic_cstm_mips_ixx_map = { - NULL, - 0, - 0, - cstm_mips_ixx_read8, - cstm_mips_ixx_read16, - cstm_mips_ixx_read32, - cstm_mips_ixx_copy_from, - cstm_mips_ixx_write8, - cstm_mips_ixx_write16, - cstm_mips_ixx_write32, - cstm_mips_ixx_copy_to, - cstm_mips_ixx_set_vpp, - 0, - 0 + .read8 = cstm_mips_ixx_read8, + .read16 = cstm_mips_ixx_read16, + .read32 = cstm_mips_ixx_read32, + .copy_from = cstm_mips_ixx_copy_from, + .write8 = cstm_mips_ixx_write8, + .write16 = cstm_mips_ixx_write16, + .write32 = cstm_mips_ixx_write32, + .copy_to = cstm_mips_ixx_copy_to, + .set_vpp = cstm_mips_ixx_set_vpp, }; /* board and partition description */ @@ -175,9 +170,8 @@ static struct mtd_partition cstm_mips_ixx_partitions[PHYSMAP_NUMBER][MAX_PHYSMAP_PARTITIONS] = { { // 28F128J3A in 2x16 configuration { - name: "main partition ", - size: 0x02000000, // 128 x 2 x 128k byte sectors - offset: 0, + .name = "main partition ", + .size = 0x02000000, // 128 x 2 x 128k byte sectors }, }, }; @@ -197,9 +191,8 @@ static struct mtd_partition cstm_mips_ixx_partitions[PHYSMAP_NUMBER][MAX_PHYSMAP_PARTITIONS] = { { { - name: "main partition", - size: CONFIG_MTD_CSTM_MIPS_IXX_LEN, - offset: 0, + .name = "main partition", + .size = CONFIG_MTD_CSTM_MIPS_IXX_LEN, }, }, }; diff -Nru a/drivers/mtd/maps/dbox2-flash.c b/drivers/mtd/maps/dbox2-flash.c --- a/drivers/mtd/maps/dbox2-flash.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/maps/dbox2-flash.c Tue Mar 4 19:30:14 2003 @@ -16,22 +16,28 @@ /* partition_info gives details on the logical partitions that the split the * single flash device into. If the size if zero we use up to the end of the * device. */ -static struct mtd_partition partition_info[]= {{name: "BR bootloader", // raw - size: 128 * 1024, - offset: 0, - mask_flags: MTD_WRITEABLE}, - {name: "PPC bootloader", // flfs - size: 128 * 1024, - offset: MTDPART_OFS_APPEND, - mask_flags: 0}, - {name: "Kernel", // idxfs - size: 768 * 1024, - offset: MTDPART_OFS_APPEND, - mask_flags: 0}, - {name: "System", // jffs - size: MTDPART_SIZ_FULL, - offset: MTDPART_OFS_APPEND, - mask_flags: 0}}; +static struct mtd_partition partition_info[]= { + { + .name = "BR bootloader", /* raw */ + .size = 128 * 1024, + .mask_flags = MTD_WRITEABLE + }, + { + .name = "PPC bootloader", /* flfs */ + .size = 128 * 1024, + .offset = MTDPART_OFS_APPEND, + }, + { + .name = "Kernel", /* idxfs */ + .size = 768 * 1024, + .offset = MTDPART_OFS_APPEND, + }, + { + .name = "System", /* jffs */ + .size = MTDPART_SIZ_FULL, + .offset = MTDPART_OFS_APPEND, + } +}; #define NUM_PARTITIONS (sizeof(partition_info) / sizeof(partition_info[0])) @@ -84,17 +90,17 @@ } struct map_info dbox2_flash_map = { - name: "D-Box 2 flash memory", - size: WINDOW_SIZE, - buswidth: 4, - read8: dbox2_flash_read8, - read16: dbox2_flash_read16, - read32: dbox2_flash_read32, - copy_from: dbox2_flash_copy_from, - write8: dbox2_flash_write8, - write16: dbox2_flash_write16, - write32: dbox2_flash_write32, - copy_to: dbox2_flash_copy_to + .name = "D-Box 2 flash memory", + .size = WINDOW_SIZE, + .buswidth = 4, + .read8 = dbox2_flash_read8, + .read16 = dbox2_flash_read16, + .read32 = dbox2_flash_read32, + .copy_from = dbox2_flash_copy_from, + .write8 = dbox2_flash_write8, + .write16 = dbox2_flash_write16, + .write32 = dbox2_flash_write32, + .copy_to = dbox2_flash_copy_to }; int __init init_dbox2_flash(void) diff -Nru a/drivers/mtd/maps/dc21285.c b/drivers/mtd/maps/dc21285.c --- a/drivers/mtd/maps/dc21285.c Tue Mar 4 19:30:07 2003 +++ b/drivers/mtd/maps/dc21285.c Tue Mar 4 19:30:07 2003 @@ -92,23 +92,25 @@ } struct map_info dc21285_map = { - name: "DC21285 flash", - size: 16*1024*1024, - read8: dc21285_read8, - read16: dc21285_read16, - read32: dc21285_read32, - copy_from: dc21285_copy_from, - write8: dc21285_write8, - write16: dc21285_write16, - write32: dc21285_write32, - copy_to: dc21285_copy_to + .name = "DC21285 flash", + .size = 16*1024*1024, + .read8 = dc21285_read8, + .read16 = dc21285_read16, + .read32 = dc21285_read32, + .copy_from = dc21285_copy_from, + .write8 = dc21285_write8, + .write16 = dc21285_write16, + .write32 = dc21285_write32, + .copy_to = dc21285_copy_to }; - /* Partition stuff */ static struct mtd_partition *dc21285_parts; extern int parse_redboot_partitions(struct mtd_info *, struct mtd_partition **); +extern int parse_cmdline_partitions(struct mtd_info *master, + struct mtd_partition **pparts, + const char *mtd_id); int __init init_dc21285(void) { @@ -140,18 +142,34 @@ mymtd = do_map_probe("cfi_probe", &dc21285_map); if (mymtd) { int nrparts = 0; + const char *part_type = NULL; mymtd->module = THIS_MODULE; /* partition fixup */ - + do { +#ifdef CONFIG_MTD_CMDLINE_PARTS + nrparts = parse_cmdline_partitions(mymtd, &dc21285_parts, "dc21285"); + if (nrparts > 0) { + part_type = "command line"; + break; + } +#endif #ifdef CONFIG_MTD_REDBOOT_PARTS - nrparts = parse_redboot_partitions(mymtd, &dc21285_parts); + nrparts = parse_redboot_partitions(mymtd, &dc21285_parts); + if (nrparts > 0) { + part_type = "RedBoot"; + break; + } #endif + } while (0); + if (nrparts > 0) { add_mtd_partitions(mymtd, dc21285_parts, nrparts); + printk(KERN_NOTICE "DC21285 using %s partition " + "definition\n", part_type); } else if (nrparts == 0) { - printk(KERN_NOTICE "RedBoot partition table failed\n"); + printk(KERN_NOTICE "DC21285 partition table failed\n"); add_mtd_device(mymtd); } diff -Nru a/drivers/mtd/maps/edb7312.c b/drivers/mtd/maps/edb7312.c --- a/drivers/mtd/maps/edb7312.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/maps/edb7312.c Tue Mar 4 19:30:14 2003 @@ -79,17 +79,17 @@ } struct map_info edb7312nor_map = { - name: "NOR flash on EDB7312", - size: WINDOW_SIZE, - buswidth: BUSWIDTH, - read8: edb7312nor_read8, - read16: edb7312nor_read16, - read32: edb7312nor_read32, - copy_from: edb7312nor_copy_from, - write8: edb7312nor_write8, - write16: edb7312nor_write16, - write32: edb7312nor_write32, - copy_to: edb7312nor_copy_to + .name = "NOR flash on EDB7312", + .size = WINDOW_SIZE, + .buswidth = BUSWIDTH, + .read8 = edb7312nor_read8, + .read16 = edb7312nor_read16, + .read32 = edb7312nor_read32, + .copy_from = edb7312nor_copy_from, + .write8 = edb7312nor_write8, + .write16 = edb7312nor_write16, + .write32 = edb7312nor_write32, + .copy_to = edb7312nor_copy_to }; #ifdef CONFIG_MTD_PARTITIONS @@ -97,23 +97,22 @@ /* * MTD partitioning stuff */ -static struct mtd_partition static_partitions[3] = -{ - { - name: "ARMboot", - size: 0x40000, - offset: 0 - }, - { - name: "Kernel", - size: 0x200000, - offset: 0x40000 - }, - { - name: "RootFS", - size: 0xDC0000, - offset: 0x240000 - }, +static struct mtd_partition static_partitions[3] = { + { + .name = "ARMboot", + .size = 0x40000, + .offset = 0 + }, + { + .name = "Kernel", + .size = 0x200000, + .offset = 0x40000 + }, + { + .name = "RootFS", + .size = 0xDC0000, + .offset = 0x240000 + }, }; #define NB_OF(x) (sizeof (x) / sizeof (x[0])) diff -Nru a/drivers/mtd/maps/elan-104nc.c b/drivers/mtd/maps/elan-104nc.c --- a/drivers/mtd/maps/elan-104nc.c Tue Mar 4 19:30:08 2003 +++ b/drivers/mtd/maps/elan-104nc.c Tue Mar 4 19:30:08 2003 @@ -58,15 +58,20 @@ /* partition_info gives details on the logical partitions that the split the * single flash device into. If the size if zero we use up to the end of the * device. */ -static struct mtd_partition partition_info[]={ - { name: "ELAN-104NC flash boot partition", - offset: 0, - size: 640*1024 }, - { name: "ELAN-104NC flash partition 1", - offset: 640*1024, - size: 896*1024 }, - { name: "ELAN-104NC flash partition 2", - offset: (640+896)*1024 } +static struct mtd_partition partition_info[] = { + { + .name = "ELAN-104NC flash boot partition", + .size = 640*1024 + }, + { + .name = "ELAN-104NC flash partition 1", + .offset = 640*1024, + .size = 896*1024 + }, + { + .name = "ELAN-104NC flash partition 2", + .offset = (640+896)*1024, + } }; #define NUM_PARTITIONS (sizeof(partition_info)/sizeof(partition_info[0])) @@ -195,19 +200,20 @@ } static struct map_info elan_104nc_map = { - name: "ELAN-104NC flash", - size: 8*1024*1024, /* this must be set to a maximum possible amount - of flash so the cfi probe routines find all - the chips */ - buswidth: 2, - read8: elan_104nc_read8, - read16: elan_104nc_read16, - read32: elan_104nc_read32, - copy_from: elan_104nc_copy_from, - write8: elan_104nc_write8, - write16: elan_104nc_write16, - write32: elan_104nc_write32, - copy_to: elan_104nc_copy_to + .name = "ELAN-104NC flash", + .size = 8*1024*1024, /* this must be set to a maximum + possible amount of flash so the + cfi probe routines find all + the chips */ + .buswidth = 2, + .read8 = elan_104nc_read8, + .read16 = elan_104nc_read16, + .read32 = elan_104nc_read32, + .copy_from = elan_104nc_copy_from, + .write8 = elan_104nc_write8, + .write16 = elan_104nc_write16, + .write32 = elan_104nc_write32, + .copy_to = elan_104nc_copy_to }; /* MTD device for all of the flash. */ diff -Nru a/drivers/mtd/maps/epxa10db-flash.c b/drivers/mtd/maps/epxa10db-flash.c --- a/drivers/mtd/maps/epxa10db-flash.c Tue Mar 4 19:30:12 2003 +++ b/drivers/mtd/maps/epxa10db-flash.c Tue Mar 4 19:30:12 2003 @@ -92,17 +92,17 @@ static struct map_info epxa_map = { - name: "EPXA flash", - size: FLASH_SIZE, - buswidth: 2, - read8: epxa_read8, - read16: epxa_read16, - read32: epxa_read32, - copy_from: epxa_copy_from, - write8: epxa_write8, - write16: epxa_write16, - write32: epxa_write32, - copy_to: epxa_copy_to + .name = "EPXA flash", + .size = FLASH_SIZE, + .buswidth = 2, + .read8 = epxa_read8, + .read16 = epxa_read16, + .read32 = epxa_read32, + .copy_from = epxa_copy_from, + .write8 = epxa_write8, + .write16 = epxa_write16, + .write32 = epxa_write32, + .copy_to = epxa_copy_to }; diff -Nru a/drivers/mtd/maps/fortunet.c b/drivers/mtd/maps/fortunet.c --- a/drivers/mtd/maps/fortunet.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/fortunet.c Tue Mar 4 19:30:05 2003 @@ -78,16 +78,16 @@ } struct map_info default_map = { - size: DEF_WINDOW_SIZE, - buswidth: 4, - read8: fortunet_read8, - read16: fortunet_read16, - read32: fortunet_read32, - copy_from: fortunet_copy_from, - write8: fortunet_write8, - write16: fortunet_write16, - write32: fortunet_write32, - copy_to: fortunet_copy_to + .size = DEF_WINDOW_SIZE, + .buswidth = 4, + .read8 = fortunet_read8, + .read16 = fortunet_read16, + .read32 = fortunet_read32, + .copy_from = fortunet_copy_from, + .write8 = fortunet_write8, + .write16 = fortunet_write16, + .write32 = fortunet_write32, + .copy_to = fortunet_copy_to }; static char * __init get_string_option(char *dest,int dest_size,char *sor) diff -Nru a/drivers/mtd/maps/impa7.c b/drivers/mtd/maps/impa7.c --- a/drivers/mtd/maps/impa7.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/impa7.c Tue Mar 4 19:30:05 2003 @@ -82,30 +82,30 @@ static struct map_info impa7_map[NUM_FLASHBANKS] = { { - name: "impA7 NOR Flash Bank #0", - size: WINDOW_SIZE0, - buswidth: BUSWIDTH, - read8: impa7_read8, - read16: impa7_read16, - read32: impa7_read32, - copy_from: impa7_copy_from, - write8: impa7_write8, - write16: impa7_write16, - write32: impa7_write32, - copy_to: impa7_copy_to + .name = "impA7 NOR Flash Bank #0", + .size = WINDOW_SIZE0, + .buswidth = BUSWIDTH, + .read8 = impa7_read8, + .read16 = impa7_read16, + .read32 = impa7_read32, + .copy_from = impa7_copy_from, + .write8 = impa7_write8, + .write16 = impa7_write16, + .write32 = impa7_write32, + .copy_to = impa7_copy_to }, { - name: "impA7 NOR Flash Bank #1", - size: WINDOW_SIZE1, - buswidth: BUSWIDTH, - read8: impa7_read8, - read16: impa7_read16, - read32: impa7_read32, - copy_from: impa7_copy_from, - write8: impa7_write8, - write16: impa7_write16, - write32: impa7_write32, - copy_to: impa7_copy_to + .name = "impA7 NOR Flash Bank #1", + .size = WINDOW_SIZE1, + .buswidth = BUSWIDTH, + .read8 = impa7_read8, + .read16 = impa7_read16, + .read32 = impa7_read32, + .copy_from = impa7_copy_from, + .write8 = impa7_write8, + .write16 = impa7_write16, + .write32 = impa7_write32, + .copy_to = impa7_copy_to }, }; @@ -114,13 +114,12 @@ /* * MTD partitioning stuff */ -static struct mtd_partition static_partitions[] = -{ - { - name: "FileSystem", - size: 0x800000, - offset: 0x00000000 - }, +static struct mtd_partition static_partitions[] = { + { + .name = "FileSystem", + .size = 0x800000, + .offset = 0x00000000 + }, }; #define NB_OF(x) (sizeof (x) / sizeof (x[0])) @@ -143,8 +142,8 @@ const char *part_type = 0; int i; static struct { u_long addr; u_long size; } pt[NUM_FLASHBANKS] = { - { WINDOW_ADDR0, WINDOW_SIZE0 }, - { WINDOW_ADDR1, WINDOW_SIZE1 }, + { .addr = WINDOW_ADDR0, .size = WINDOW_SIZE0 }, + { .addr = WINDOW_ADDR1, .size = WINDOW_SIZE1 }, }; char mtdid[10]; int devicesfound = 0; diff -Nru a/drivers/mtd/maps/integrator-flash.c b/drivers/mtd/maps/integrator-flash.c --- a/drivers/mtd/maps/integrator-flash.c Tue Mar 4 19:30:12 2003 +++ b/drivers/mtd/maps/integrator-flash.c Tue Mar 4 19:30:12 2003 @@ -195,16 +195,16 @@ static struct map_info armflash_map = { - name: "AFS", - read8: armflash_read8, - read16: armflash_read16, - read32: armflash_read32, - copy_from: armflash_copy_from, - write8: armflash_write8, - write16: armflash_write16, - write32: armflash_write32, - copy_to: armflash_copy_to, - set_vpp: armflash_set_vpp, + .name = "AFS", + .read8 = armflash_read8, + .read16 = armflash_read16, + .read32 = armflash_read32, + .copy_from = armflash_copy_from, + .write8 = armflash_write8, + .write16 = armflash_write16, + .write32 = armflash_write32, + .copy_to = armflash_copy_to, + .set_vpp = armflash_set_vpp, }; static struct mtd_info *mtd; diff -Nru a/drivers/mtd/maps/iq80310.c b/drivers/mtd/maps/iq80310.c --- a/drivers/mtd/maps/iq80310.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/iq80310.c Tue Mar 4 19:30:13 2003 @@ -67,38 +67,40 @@ } static struct map_info iq80310_map = { - name: "IQ80310 flash", - size: WINDOW_SIZE, - buswidth: BUSWIDTH, - read8: iq80310_read8, - read16: iq80310_read16, - read32: iq80310_read32, - copy_from: iq80310_copy_from, - write8: iq80310_write8, - write16: iq80310_write16, - write32: iq80310_write32, - copy_to: iq80310_copy_to + .name = "IQ80310 flash", + .size = WINDOW_SIZE, + .buswidth = BUSWIDTH, + .read8 = iq80310_read8, + .read16 = iq80310_read16, + .read32 = iq80310_read32, + .copy_from = iq80310_copy_from, + .write8 = iq80310_write8, + .write16 = iq80310_write16, + .write32 = iq80310_write32, + .copy_to = iq80310_copy_to }; static struct mtd_partition iq80310_partitions[4] = { { - name: "Firmware", - size: 0x00080000, - offset: 0, - mask_flags: MTD_WRITEABLE /* force read-only */ - },{ - name: "Kernel", - size: 0x000a0000, - offset: 0x00080000, - },{ - name: "Filesystem", - size: 0x00600000, - offset: 0x00120000 - },{ - name: "RedBoot", - size: 0x000e0000, - offset: 0x00720000, - mask_flags: MTD_WRITEABLE + .name = "Firmware", + .size = 0x00080000, + .mask_flags = MTD_WRITEABLE /* force read-only */ + }, + { + .name = "Kernel", + .size = 0x000a0000, + .offset = 0x00080000, + }, + { + .name = "Filesystem", + .size = 0x00600000, + .offset = 0x00120000 + }, + { + .name = "RedBoot", + .size = 0x000e0000, + .offset = 0x00720000, + .mask_flags = MTD_WRITEABLE } }; diff -Nru a/drivers/mtd/maps/l440gx.c b/drivers/mtd/maps/l440gx.c --- a/drivers/mtd/maps/l440gx.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/l440gx.c Tue Mar 4 19:30:13 2003 @@ -76,18 +76,18 @@ } struct map_info l440gx_map = { - name: "L440GX BIOS", - size: WINDOW_SIZE, - buswidth: BUSWIDTH, - read8: l440gx_read8, - read16: l440gx_read16, - read32: l440gx_read32, - copy_from: l440gx_copy_from, - write8: l440gx_write8, - write16: l440gx_write16, - write32: l440gx_write32, - copy_to: l440gx_copy_to, - set_vpp: l440gx_set_vpp + .name = "L440GX BIOS", + .size = WINDOW_SIZE, + .buswidth = BUSWIDTH, + .read8 = l440gx_read8, + .read16 = l440gx_read16, + .read32 = l440gx_read32, + .copy_from = l440gx_copy_from, + .write8 = l440gx_write8, + .write16 = l440gx_write16, + .write32 = l440gx_write32, + .copy_to = l440gx_copy_to, + .set_vpp = l440gx_set_vpp }; static int __init init_l440gx(void) diff -Nru a/drivers/mtd/maps/netsc520.c b/drivers/mtd/maps/netsc520.c --- a/drivers/mtd/maps/netsc520.c Tue Mar 4 19:30:12 2003 +++ b/drivers/mtd/maps/netsc520.c Tue Mar 4 19:30:12 2003 @@ -93,27 +93,26 @@ /* partition_info gives details on the logical partitions that the split the * single flash device into. If the size if zero we use up to the end of the * device. */ -static struct mtd_partition partition_info[]={ - { - name: "NetSc520 boot kernel", - offset: 0, - size: 0xc0000 - }, - { - name: "NetSc520 Low BIOS", - offset: 0xc0000, - size: 0x40000 - }, - { - name: "NetSc520 file system", - offset: 0x100000, - size: 0xe80000 - }, - { - name: "NetSc520 High BIOS", - offset: 0xf80000, - size: 0x80000 - }, +static struct mtd_partition partition_info[] = { + { + .name = "NetSc520 boot kernel", + .size = 0xc0000 + }, + { + .name = "NetSc520 Low BIOS", + .offset = 0xc0000, + .size = 0x40000 + }, + { + .name = "NetSc520 file system", + .offset = 0x100000, + .size = 0xe80000 + }, + { + .name = "NetSc520 High BIOS", + .offset = 0xf80000, + .size = 0x80000 + }, }; #define NUM_PARTITIONS (sizeof(partition_info)/sizeof(partition_info[0])) @@ -127,18 +126,18 @@ #define WINDOW_ADDR 0x00200000 static struct map_info netsc520_map = { - name: "netsc520 Flash Bank", - size: WINDOW_SIZE, - buswidth: 4, - read8: netsc520_read8, - read16: netsc520_read16, - read32: netsc520_read32, - copy_from: netsc520_copy_from, - write8: netsc520_write8, - write16: netsc520_write16, - write32: netsc520_write32, - copy_to: netsc520_copy_to, - map_priv_2: WINDOW_ADDR + .name = "netsc520 Flash Bank", + .size = WINDOW_SIZE, + .buswidth = 4, + .read8 = netsc520_read8, + .read16 = netsc520_read16, + .read32 = netsc520_read32, + .copy_from = netsc520_copy_from, + .write8 = netsc520_write8, + .write16 = netsc520_write16, + .write32 = netsc520_write32, + .copy_to = netsc520_copy_to, + .map_priv_2 = WINDOW_ADDR }; #define NUM_FLASH_BANKS (sizeof(netsc520_map)/sizeof(struct map_info)) diff -Nru a/drivers/mtd/maps/nora.c b/drivers/mtd/maps/nora.c --- a/drivers/mtd/maps/nora.c Tue Mar 4 19:30:11 2003 +++ b/drivers/mtd/maps/nora.c Tue Mar 4 19:30:11 2003 @@ -58,17 +58,17 @@ } struct map_info nora_map = { - name: "NORA", - size: WINDOW_SIZE, - buswidth: 2, - read8: nora_read8, - read16: nora_read16, - read32: nora_read32, - copy_from: nora_copy_from, - write8: nora_write8, - write16: nora_write16, - write32: nora_write32, - copy_to: nora_copy_to + .name = "NORA", + .size = WINDOW_SIZE, + .buswidth = 2, + .read8 = nora_read8, + .read16 = nora_read16, + .read32 = nora_read32, + .copy_from = nora_copy_from, + .write8 = nora_write8, + .write16 = nora_write16, + .write32 = nora_write32, + .copy_to = nora_copy_to }; @@ -106,64 +106,63 @@ static struct mtd_info nora_mtds[4] = { /* boot, kernel, ramdisk, fs */ { - type: MTD_NORFLASH, - flags: MTD_CAP_NORFLASH, - size: 0x60000, - erasesize: 0x20000, - name: "NORA boot firmware", - module: THIS_MODULE, - erase: nora_mtd_erase, - read: nora_mtd_read, - write: nora_mtd_write, - suspend: nora_mtd_suspend, - resume: nora_mtd_resume, - sync: nora_mtd_sync, - priv: (void *)0 + .type = MTD_NORFLASH, + .flags = MTD_CAP_NORFLASH, + .size = 0x60000, + .erasesize = 0x20000, + .name = "NORA boot firmware", + .module = THIS_MODULE, + .erase = nora_mtd_erase, + .read = nora_mtd_read, + .write = nora_mtd_write, + .suspend = nora_mtd_suspend, + .resume = nora_mtd_resume, + .sync = nora_mtd_sync, }, { - type: MTD_NORFLASH, - flags: MTD_CAP_NORFLASH, - size: 0x0a0000, - erasesize: 0x20000, - name: "NORA kernel", - module: THIS_MODULE, - erase: nora_mtd_erase, - read: nora_mtd_read, - write: nora_mtd_write, - suspend: nora_mtd_suspend, - resume: nora_mtd_resume, - sync: nora_mtd_sync, - priv: (void *)0x60000 + .type = MTD_NORFLASH, + .flags = MTD_CAP_NORFLASH, + .size = 0x0a0000, + .erasesize = 0x20000, + .name = "NORA kernel", + .module = THIS_MODULE, + .erase = nora_mtd_erase, + .read = nora_mtd_read, + .write = nora_mtd_write, + .suspend = nora_mtd_suspend, + .resume = nora_mtd_resume, + .sync = nora_mtd_sync, + .priv = (void *)0x60000 }, { - type: MTD_NORFLASH, - flags: MTD_CAP_NORFLASH, - size: 0x900000, - erasesize: 0x20000, - name: "NORA root filesystem", - module: THIS_MODULE, - erase: nora_mtd_erase, - read: nora_mtd_read, - write: nora_mtd_write, - suspend: nora_mtd_suspend, - resume: nora_mtd_resume, - sync: nora_mtd_sync, - priv: (void *)0x100000 + .type = MTD_NORFLASH, + .flags = MTD_CAP_NORFLASH, + .size = 0x900000, + .erasesize = 0x20000, + .name = "NORA root filesystem", + .module = THIS_MODULE, + .erase = nora_mtd_erase, + .read = nora_mtd_read, + .write = nora_mtd_write, + .suspend = nora_mtd_suspend, + .resume = nora_mtd_resume, + .sync = nora_mtd_sync, + .priv = (void *)0x100000 }, { - type: MTD_NORFLASH, - flags: MTD_CAP_NORFLASH, - size: 0x1600000, - erasesize: 0x20000, - name: "NORA second filesystem", - module: THIS_MODULE, - erase: nora_mtd_erase, - read: nora_mtd_read, - write: nora_mtd_write, - suspend: nora_mtd_suspend, - resume: nora_mtd_resume, - sync: nora_mtd_sync, - priv: (void *)0xa00000 + .type = MTD_NORFLASH, + .flags = MTD_CAP_NORFLASH, + .size = 0x1600000, + .erasesize = 0x20000, + .name = "NORA second filesystem", + .module = THIS_MODULE, + .erase = nora_mtd_erase, + .read = nora_mtd_read, + .write = nora_mtd_write, + .suspend = nora_mtd_suspend, + .resume = nora_mtd_resume, + .sync = nora_mtd_sync, + .priv = (void *)0xa00000 } }; diff -Nru a/drivers/mtd/maps/ocelot.c b/drivers/mtd/maps/ocelot.c --- a/drivers/mtd/maps/ocelot.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/maps/ocelot.c Tue Mar 4 19:30:14 2003 @@ -70,22 +70,22 @@ static struct mtd_partition *parsed_parts; struct map_info ocelot_flash_map = { - name: "Ocelot boot flash", - size: FLASH_WINDOW_SIZE, - buswidth: FLASH_BUSWIDTH, - read8: ocelot_read8, - copy_from: ocelot_copy_from_cache, - write8: ocelot_write8, + .name = "Ocelot boot flash", + .size = FLASH_WINDOW_SIZE, + .buswidth = FLASH_BUSWIDTH, + .read8 = ocelot_read8, + .copy_from = ocelot_copy_from_cache, + .write8 = ocelot_write8, }; struct map_info ocelot_nvram_map = { - name: "Ocelot NVRAM", - size: NVRAM_WINDOW_SIZE, - buswidth: NVRAM_BUSWIDTH, - read8: ocelot_read8, - copy_from: ocelot_copy_from, - write8: ocelot_write8, - copy_to: ocelot_copy_to + .name = "Ocelot NVRAM", + .size = NVRAM_WINDOW_SIZE, + .buswidth = NVRAM_BUSWIDTH, + .read8 = ocelot_read8, + .copy_from = ocelot_copy_from, + .write8 = ocelot_write8, + .copy_to = ocelot_copy_to }; static int __init init_ocelot_maps(void) diff -Nru a/drivers/mtd/maps/octagon-5066.c b/drivers/mtd/maps/octagon-5066.c --- a/drivers/mtd/maps/octagon-5066.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/octagon-5066.c Tue Mar 4 19:30:05 2003 @@ -151,32 +151,32 @@ static struct map_info oct5066_map[2] = { { - name: "Octagon 5066 Socket", - size: 512 * 1024, - buswidth: 1, - read8: oct5066_read8, - read16: oct5066_read16, - read32: oct5066_read32, - copy_from: oct5066_copy_from, - write8: oct5066_write8, - write16: oct5066_write16, - write32: oct5066_write32, - copy_to: oct5066_copy_to, - map_priv_1: 1<<6 + .name = "Octagon 5066 Socket", + .size = 512 * 1024, + .buswidth = 1, + .read8 = oct5066_read8, + .read16 = oct5066_read16, + .read32 = oct5066_read32, + .copy_from = oct5066_copy_from, + .write8 = oct5066_write8, + .write16 = oct5066_write16, + .write32 = oct5066_write32, + .copy_to = oct5066_copy_to, + .map_priv_1 = 1<<6 }, { - name: "Octagon 5066 Internal Flash", - size: 2 * 1024 * 1024, - buswidth: 1, - read8: oct5066_read8, - read16: oct5066_read16, - read32: oct5066_read32, - copy_from: oct5066_copy_from, - write8: oct5066_write8, - write16: oct5066_write16, - write32: oct5066_write32, - copy_to: oct5066_copy_to, - map_priv_1: 2<<6 + .name = "Octagon 5066 Internal Flash", + .size = 2 * 1024 * 1024, + .buswidth = 1, + .read8 = oct5066_read8, + .read16 = oct5066_read16, + .read32 = oct5066_read32, + .copy_from = oct5066_copy_from, + .write8 = oct5066_write8, + .write16 = oct5066_write16, + .write32 = oct5066_write32, + .copy_to = oct5066_copy_to, + .map_priv_1 = 2<<6 } }; diff -Nru a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c --- a/drivers/mtd/maps/pci.c Tue Mar 4 19:30:07 2003 +++ b/drivers/mtd/maps/pci.c Tue Mar 4 19:30:07 2003 @@ -98,10 +98,10 @@ } static struct mtd_pci_info intel_iq80310_info = { - init: intel_iq80310_init, - exit: intel_iq80310_exit, - translate: intel_iq80310_translate, - map_name: "cfi_probe", + .init = intel_iq80310_init, + .exit = intel_iq80310_exit, + .translate = intel_iq80310_translate, + .map_name = "cfi_probe", }; /* @@ -181,10 +181,10 @@ } static struct mtd_pci_info intel_dc21285_info = { - init: intel_dc21285_init, - exit: intel_dc21285_exit, - translate: intel_dc21285_translate, - map_name: "jedec_probe", + .init = intel_dc21285_init, + .exit = intel_dc21285_exit, + .translate = intel_dc21285_translate, + .map_name = "jedec_probe", }; /* @@ -193,24 +193,22 @@ static struct pci_device_id mtd_pci_ids[] __devinitdata = { { - vendor: PCI_VENDOR_ID_INTEL, - device: 0x530d, - subvendor: PCI_ANY_ID, - subdevice: PCI_ANY_ID, - class: PCI_CLASS_MEMORY_OTHER << 8, - class_mask: 0xffff00, - driver_data: (unsigned long)&intel_iq80310_info, + .vendor = PCI_VENDOR_ID_INTEL, + .device = 0x530d, + .subvendor = PCI_ANY_ID, + .subdevice = PCI_ANY_ID, + .class = PCI_CLASS_MEMORY_OTHER << 8, + .class_mask = 0xffff00, + .driver_data = (unsigned long)&intel_iq80310_info, }, { - vendor: PCI_VENDOR_ID_DEC, - device: PCI_DEVICE_ID_DEC_21285, - subvendor: 0, /* DC21285 defaults to 0 on reset */ - subdevice: 0, /* DC21285 defaults to 0 on reset */ - class: 0, - class_mask: 0, - driver_data: (unsigned long)&intel_dc21285_info, + .vendor = PCI_VENDOR_ID_DEC, + .device = PCI_DEVICE_ID_DEC_21285, + .subvendor = 0, /* DC21285 defaults to 0 on reset */ + .subdevice = 0, /* DC21285 defaults to 0 on reset */ + .driver_data = (unsigned long)&intel_dc21285_info, }, - { 0, } + { .vendor = 0, } }; /* @@ -275,14 +273,14 @@ } static struct map_info mtd_pci_map = { - read8: mtd_pci_read8, - read16: mtd_pci_read16, - read32: mtd_pci_read32, - copy_from: mtd_pci_copyfrom, - write8: mtd_pci_write8, - write16: mtd_pci_write16, - write32: mtd_pci_write32, - copy_to: mtd_pci_copyto, + .read8 = mtd_pci_read8, + .read16 = mtd_pci_read16, + .read32 = mtd_pci_read32, + .copy_from = mtd_pci_copyfrom, + .write8 = mtd_pci_write8, + .write16 = mtd_pci_write16, + .write32 = mtd_pci_write32, + .copy_to = mtd_pci_copyto, }; static int __devinit @@ -359,10 +357,10 @@ } static struct pci_driver mtd_pci_driver = { - name: "MTD PCI", - probe: mtd_pci_probe, - remove: mtd_pci_remove, - id_table: mtd_pci_ids, + .name = "MTD PCI", + .probe = mtd_pci_probe, + .remove = mtd_pci_remove, + .id_table = mtd_pci_ids, }; static int __init mtd_pci_maps_init(void) diff -Nru a/drivers/mtd/maps/physmap.c b/drivers/mtd/maps/physmap.c --- a/drivers/mtd/maps/physmap.c Tue Mar 4 19:30:10 2003 +++ b/drivers/mtd/maps/physmap.c Tue Mar 4 19:30:10 2003 @@ -63,17 +63,17 @@ } struct map_info physmap_map = { - name: "Physically mapped flash", - size: WINDOW_SIZE, - buswidth: BUSWIDTH, - read8: physmap_read8, - read16: physmap_read16, - read32: physmap_read32, - copy_from: physmap_copy_from, - write8: physmap_write8, - write16: physmap_write16, - write32: physmap_write32, - copy_to: physmap_copy_to + .name = "Physically mapped flash", + .size = WINDOW_SIZE, + .buswidth = BUSWIDTH, + .read8 = physmap_read8, + .read16 = physmap_read16, + .read32 = physmap_read32, + .copy_from = physmap_copy_from, + .write8 = physmap_write8, + .write16 = physmap_write16, + .write32 = physmap_write32, + .copy_to = physmap_copy_to }; int __init init_physmap(void) diff -Nru a/drivers/mtd/maps/pnc2000.c b/drivers/mtd/maps/pnc2000.c --- a/drivers/mtd/maps/pnc2000.c Tue Mar 4 19:30:08 2003 +++ b/drivers/mtd/maps/pnc2000.c Tue Mar 4 19:30:08 2003 @@ -65,17 +65,17 @@ } struct map_info pnc_map = { - name: "PNC-2000", - size: WINDOW_SIZE, - buswidth: 4, - read8: pnc_read8, - read16: pnc_read16, - read32: pnc_read32, - copy_from: pnc_copy_from, - write8: pnc_write8, - write16: pnc_write16, - write32: pnc_write32, - copy_to: pnc_copy_to + .name = "PNC-2000", + .size = WINDOW_SIZE, + .buswidth = 4, + .read8 = pnc_read8, + .read16 = pnc_read16, + .read32 = pnc_read32, + .copy_from = pnc_copy_from, + .write8 = pnc_write8, + .write16 = pnc_write16, + .write32 = pnc_write32, + .copy_to = pnc_copy_to }; @@ -84,19 +84,18 @@ */ static struct mtd_partition pnc_partitions[3] = { { - name: "PNC-2000 boot firmware", - size: 0x20000, - offset: 0 + .name = "PNC-2000 boot firmware", + .size = 0x20000, }, { - name: "PNC-2000 kernel", - size: 0x1a0000, - offset: 0x20000 + .name = "PNC-2000 kernel", + .size = 0x1a0000, + .offset = 0x20000 }, { - name: "PNC-2000 filesystem", - size: 0x240000, - offset: 0x1c0000 + .name = "PNC-2000 filesystem", + .size = 0x240000, + .offset = 0x1c0000 } }; diff -Nru a/drivers/mtd/maps/rpxlite.c b/drivers/mtd/maps/rpxlite.c --- a/drivers/mtd/maps/rpxlite.c Tue Mar 4 19:30:14 2003 +++ b/drivers/mtd/maps/rpxlite.c Tue Mar 4 19:30:14 2003 @@ -61,17 +61,17 @@ } struct map_info rpxlite_map = { - name: "RPX", - size: WINDOW_SIZE, - buswidth: 4, - read8: rpxlite_read8, - read16: rpxlite_read16, - read32: rpxlite_read32, - copy_from: rpxlite_copy_from, - write8: rpxlite_write8, - write16: rpxlite_write16, - write32: rpxlite_write32, - copy_to: rpxlite_copy_to + .name = "RPX", + .size = WINDOW_SIZE, + .buswidth = 4, + .read8 = rpxlite_read8, + .read16 = rpxlite_read16, + .read32 = rpxlite_read32, + .copy_from = rpxlite_copy_from, + .write8 = rpxlite_write8, + .write16 = rpxlite_write16, + .write32 = rpxlite_write32, + .copy_to = rpxlite_copy_to }; int __init init_rpxlite(void) diff -Nru a/drivers/mtd/maps/sa1100-flash.c b/drivers/mtd/maps/sa1100-flash.c --- a/drivers/mtd/maps/sa1100-flash.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/sa1100-flash.c Tue Mar 4 19:30:05 2003 @@ -96,7 +96,7 @@ * 1. We no longer support static flash mappings via the machine io_desc * structure. * 2. The flash size given should be the largest flash size that can - * be accomodated. + * be accommodated. * * The MTD layer will detect flash chip aliasing and reduce the size of * the map accordingly. diff -Nru a/drivers/mtd/maps/sbc_gxx.c b/drivers/mtd/maps/sbc_gxx.c --- a/drivers/mtd/maps/sbc_gxx.c Tue Mar 4 19:30:10 2003 +++ b/drivers/mtd/maps/sbc_gxx.c Tue Mar 4 19:30:10 2003 @@ -90,15 +90,20 @@ /* partition_info gives details on the logical partitions that the split the * single flash device into. If the size if zero we use up to the end of the * device. */ -static struct mtd_partition partition_info[]={ - { name: "SBC-GXx flash boot partition", - offset: 0, - size: BOOT_PARTITION_SIZE_KiB*1024 }, - { name: "SBC-GXx flash data partition", - offset: BOOT_PARTITION_SIZE_KiB*1024, - size: (DATA_PARTITION_SIZE_KiB)*1024 }, - { name: "SBC-GXx flash application partition", - offset: (BOOT_PARTITION_SIZE_KiB+DATA_PARTITION_SIZE_KiB)*1024 } +static struct mtd_partition partition_info[] = { + { + .name = "SBC-GXx flash boot partition", + .size = BOOT_PARTITION_SIZE_KiB*1024 + }, + { + .name = "SBC-GXx flash data partition", + .offset = BOOT_PARTITION_SIZE_KiB*1024, + .size = (DATA_PARTITION_SIZE_KiB)*1024 + }, + { + .name = "SBC-GXx flash application partition", + .offset = (BOOT_PARTITION_SIZE_KiB+DATA_PARTITION_SIZE_KiB)*1024 + } }; #define NUM_PARTITIONS 3 @@ -203,19 +208,20 @@ } static struct map_info sbc_gxx_map = { - name: "SBC-GXx flash", - size: MAX_SIZE_KiB*1024, /* this must be set to a maximum possible amount - of flash so the cfi probe routines find all - the chips */ - buswidth: 1, - read8: sbc_gxx_read8, - read16: sbc_gxx_read16, - read32: sbc_gxx_read32, - copy_from: sbc_gxx_copy_from, - write8: sbc_gxx_write8, - write16: sbc_gxx_write16, - write32: sbc_gxx_write32, - copy_to: sbc_gxx_copy_to + .name = "SBC-GXx flash", + .size = MAX_SIZE_KiB*1024, /* this must be set to a maximum + possible amount of flash so + the cfi probe routines find + all the chips */ + .buswidth = 1, + .read8 = sbc_gxx_read8, + .read16 = sbc_gxx_read16, + .read32 = sbc_gxx_read32, + .copy_from = sbc_gxx_copy_from, + .write8 = sbc_gxx_write8, + .write16 = sbc_gxx_write16, + .write32 = sbc_gxx_write32, + .copy_to = sbc_gxx_copy_to }; /* MTD device for all of the flash. */ diff -Nru a/drivers/mtd/maps/sc520cdp.c b/drivers/mtd/maps/sc520cdp.c --- a/drivers/mtd/maps/sc520cdp.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/sc520cdp.c Tue Mar 4 19:30:13 2003 @@ -125,46 +125,46 @@ static struct map_info sc520cdp_map[] = { { - name: "SC520CDP Flash Bank #0", - size: WINDOW_SIZE_0, - buswidth: 4, - read8: sc520cdp_read8, - read16: sc520cdp_read16, - read32: sc520cdp_read32, - copy_from: sc520cdp_copy_from, - write8: sc520cdp_write8, - write16: sc520cdp_write16, - write32: sc520cdp_write32, - copy_to: sc520cdp_copy_to, - map_priv_2: WINDOW_ADDR_0 + .name = "SC520CDP Flash Bank #0", + .size = WINDOW_SIZE_0, + .buswidth = 4, + .read8 = sc520cdp_read8, + .read16 = sc520cdp_read16, + .read32 = sc520cdp_read32, + .copy_from = sc520cdp_copy_from, + .write8 = sc520cdp_write8, + .write16 = sc520cdp_write16, + .write32 = sc520cdp_write32, + .copy_to = sc520cdp_copy_to, + .map_priv_2 = WINDOW_ADDR_0 }, { - name: "SC520CDP Flash Bank #1", - size: WINDOW_SIZE_1, - buswidth: 4, - read8: sc520cdp_read8, - read16: sc520cdp_read16, - read32: sc520cdp_read32, - copy_from: sc520cdp_copy_from, - write8: sc520cdp_write8, - write16: sc520cdp_write16, - write32: sc520cdp_write32, - copy_to: sc520cdp_copy_to, - map_priv_2: WINDOW_ADDR_1 + .name = "SC520CDP Flash Bank #1", + .size = WINDOW_SIZE_1, + .buswidth = 4, + .read8 = sc520cdp_read8, + .read16 = sc520cdp_read16, + .read32 = sc520cdp_read32, + .copy_from = sc520cdp_copy_from, + .write8 = sc520cdp_write8, + .write16 = sc520cdp_write16, + .write32 = sc520cdp_write32, + .copy_to = sc520cdp_copy_to, + .map_priv_2 = WINDOW_ADDR_1 }, { - name: "SC520CDP DIL Flash", - size: WINDOW_SIZE_2, - buswidth: 1, - read8: sc520cdp_read8, - read16: sc520cdp_read16, - read32: sc520cdp_read32, - copy_from: sc520cdp_copy_from, - write8: sc520cdp_write8, - write16: sc520cdp_write16, - write32: sc520cdp_write32, - copy_to: sc520cdp_copy_to, - map_priv_2: WINDOW_ADDR_2 + .name = "SC520CDP DIL Flash", + .size = WINDOW_SIZE_2, + .buswidth = 1, + .read8 = sc520cdp_read8, + .read16 = sc520cdp_read16, + .read32 = sc520cdp_read32, + .copy_from = sc520cdp_copy_from, + .write8 = sc520cdp_write8, + .write16 = sc520cdp_write16, + .write32 = sc520cdp_write32, + .copy_to = sc520cdp_copy_to, + .map_priv_2 = WINDOW_ADDR_2 }, }; diff -Nru a/drivers/mtd/maps/solutionengine.c b/drivers/mtd/maps/solutionengine.c --- a/drivers/mtd/maps/solutionengine.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/solutionengine.c Tue Mar 4 19:30:13 2003 @@ -42,19 +42,19 @@ static struct mtd_partition *parsed_parts; struct map_info soleng_eprom_map = { - name: "Solution Engine EPROM", - size: 0x400000, - buswidth: 4, - copy_from: soleng_copy_from, + .name = "Solution Engine EPROM", + .size = 0x400000, + .buswidth = 4, + .copy_from = soleng_copy_from, }; struct map_info soleng_flash_map = { - name: "Solution Engine FLASH", - size: 0x400000, - buswidth: 4, - read32: soleng_read32, - copy_from: soleng_copy_from, - write32: soleng_write32, + .name = "Solution Engine FLASH", + .size = 0x400000, + .buswidth = 4, + .read32 = soleng_read32, + .copy_from = soleng_copy_from, + .write32 = soleng_write32, }; static int __init init_soleng_maps(void) diff -Nru a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c --- a/drivers/mtd/maps/sun_uflash.c Tue Mar 4 19:30:11 2003 +++ b/drivers/mtd/maps/sun_uflash.c Tue Mar 4 19:30:11 2003 @@ -91,17 +91,17 @@ } struct map_info uflash_map_templ = { - name: "SUNW,???-????", - size: UFLASH_WINDOW_SIZE, - buswidth: UFLASH_BUSWIDTH, - read8: uflash_read8, - read16: uflash_read16, - read32: uflash_read32, - copy_from: uflash_copy_from, - write8: uflash_write8, - write16: uflash_write16, - write32: uflash_write32, - copy_to: uflash_copy_to + .name = "SUNW,???-????", + .size = UFLASH_WINDOW_SIZE, + .buswidth = UFLASH_BUSWIDTH, + .read8 = uflash_read8, + .read16 = uflash_read16, + .read32 = uflash_read32, + .copy_from = uflash_copy_from, + .write8 = uflash_write8, + .write16 = uflash_write16, + .write32 = uflash_write32, + .copy_to = uflash_copy_to }; int uflash_devinit(struct linux_ebus_device* edev) diff -Nru a/drivers/mtd/maps/tqm8xxl.c b/drivers/mtd/maps/tqm8xxl.c --- a/drivers/mtd/maps/tqm8xxl.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/tqm8xxl.c Tue Mar 4 19:30:05 2003 @@ -92,17 +92,16 @@ } struct map_info tqm8xxl_map = { - name: "TQM8xxL", - //size: WINDOW_SIZE, - buswidth: 4, - read8: tqm8xxl_read8, - read16: tqm8xxl_read16, - read32: tqm8xxl_read32, - copy_from: tqm8xxl_copy_from, - write8: tqm8xxl_write8, - write16: tqm8xxl_write16, - write32: tqm8xxl_write32, - copy_to: tqm8xxl_copy_to + .name = "TQM8xxL", + .buswidth = 4, + .read8 = tqm8xxl_read8, + .read16 = tqm8xxl_read16, + .read32 = tqm8xxl_read32, + .copy_from = tqm8xxl_copy_from, + .write8 = tqm8xxl_write8, + .write16 = tqm8xxl_write16, + .write32 = tqm8xxl_write32, + .copy_to = tqm8xxl_copy_to }; /* @@ -125,40 +124,39 @@ */ static struct mtd_partition tqm8xxl_partitions[] = { { - name: "ppcboot", - offset: 0x00000000, - size: 0x00020000, /* 128KB */ - mask_flags: MTD_WRITEABLE, /* force read-only */ + .name = "ppcboot", + .offset = 0x00000000, + .size = 0x00020000, /* 128KB */ + .mask_flags = MTD_WRITEABLE, /* force read-only */ }, { - name: "kernel", /* default kernel image */ - offset: 0x00020000, - size: 0x000e0000, - mask_flags: MTD_WRITEABLE, /* force read-only */ + .name = "kernel", /* default kernel image */ + .offset = 0x00020000, + .size = 0x000e0000, + .mask_flags = MTD_WRITEABLE, /* force read-only */ }, { - name: "user", - offset: 0x00100000, - size: 0x00100000, + .name = "user", + .offset = 0x00100000, + .size = 0x00100000, }, { - name: "initrd", - offset: 0x00200000, - size: 0x00200000, + .name = "initrd", + .offset = 0x00200000, + .size = 0x00200000, } }; /* partition definition for second flahs bank */ static struct mtd_partition tqm8xxl_fs_partitions[] = { { - name: "cramfs", - offset: 0x00000000, - size: 0x00200000, + .name = "cramfs", + .offset = 0x00000000, + .size = 0x00200000, }, { - name: "jffs", - offset: 0x00200000, - size: 0x00200000, - //size: MTDPART_SIZ_FULL, + .name = "jffs", + .offset = 0x00200000, + .size = 0x00200000, } }; #endif diff -Nru a/drivers/mtd/maps/uclinux.c b/drivers/mtd/maps/uclinux.c --- a/drivers/mtd/maps/uclinux.c Tue Mar 4 19:30:13 2003 +++ b/drivers/mtd/maps/uclinux.c Tue Mar 4 19:30:13 2003 @@ -66,15 +66,15 @@ /****************************************************************************/ struct map_info uclinux_ram_map = { - name: "RAM", - read8: uclinux_read8, - read16: uclinux_read16, - read32: uclinux_read32, - copy_from: uclinux_copy_from, - write8: uclinux_write8, - write16: uclinux_write16, - write32: uclinux_write32, - copy_to: uclinux_copy_to, + .name = "RAM", + .read8 = uclinux_read8, + .read16 = uclinux_read16, + .read32 = uclinux_read32, + .copy_from = uclinux_copy_from, + .write8 = uclinux_write8, + .write16 = uclinux_write16, + .write32 = uclinux_write32, + .copy_to = uclinux_copy_to, }; struct mtd_info *uclinux_ram_mtdinfo; @@ -82,7 +82,7 @@ /****************************************************************************/ struct mtd_partition uclinux_romfs[] = { - { name: "ROMfs", offset: 0 } + { .name = "ROMfs", .offset = 0 } }; #define NUM_PARTITIONS (sizeof(uclinux_romfs) / sizeof(uclinux_romfs[0])) diff -Nru a/drivers/mtd/maps/vmax301.c b/drivers/mtd/maps/vmax301.c --- a/drivers/mtd/maps/vmax301.c Tue Mar 4 19:30:05 2003 +++ b/drivers/mtd/maps/vmax301.c Tue Mar 4 19:30:05 2003 @@ -142,34 +142,33 @@ static struct map_info vmax_map[2] = { { - name: "VMAX301 Internal Flash", - size: 3*2*1024*1024, - buswidth: 1, - read8: vmax301_read8, - read16: vmax301_read16, - read32: vmax301_read32, - copy_from: vmax301_copy_from, - write8: vmax301_write8, - write16: vmax301_write16, - write32: vmax301_write32, - copy_to: vmax301_copy_to, - map_priv_1: WINDOW_START + WINDOW_LENGTH, - map_priv_2: 0xFFFFFFFF + .name = "VMAX301 Internal Flash", + .size = 3*2*1024*1024, + .buswidth = 1, + .read8 = vmax301_read8, + .read16 = vmax301_read16, + .read32 = vmax301_read32, + .copy_from = vmax301_copy_from, + .write8 = vmax301_write8, + .write16 = vmax301_write16, + .write32 = vmax301_write32, + .copy_to = vmax301_copy_to, + .map_priv_1 = WINDOW_START + WINDOW_LENGTH, + .map_priv_2 = 0xFFFFFFFF }, { - name: "VMAX301 Socket", - size: 0, - buswidth: 1, - read8: vmax301_read8, - read16: vmax301_read16, - read32: vmax301_read32, - copy_from: vmax301_copy_from, - write8: vmax301_write8, - write16: vmax301_write16, - write32: vmax301_write32, - copy_to: vmax301_copy_to, - map_priv_1: WINDOW_START + (3*WINDOW_LENGTH), - map_priv_2: 0xFFFFFFFF + .name = "VMAX301 Socket", + .buswidth = 1, + .read8 = vmax301_read8, + .read16 = vmax301_read16, + .read32 = vmax301_read32, + .copy_from = vmax301_copy_from, + .write8 = vmax301_write8, + .write16 = vmax301_write16, + .write32 = vmax301_write32, + .copy_to = vmax301_copy_to, + .map_priv_1 = WINDOW_START + (3*WINDOW_LENGTH), + .map_priv_2 = 0xFFFFFFFF } }; diff -Nru a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c --- a/drivers/mtd/mtdchar.c Tue Mar 4 19:30:11 2003 +++ b/drivers/mtd/mtdchar.c Tue Mar 4 19:30:11 2003 @@ -19,8 +19,8 @@ static void mtd_notify_remove(struct mtd_info* mtd); static struct mtd_notifier notifier = { - add: mtd_notify_add, - remove: mtd_notify_remove, + .add = mtd_notify_add, + .remove = mtd_notify_remove, }; #endif @@ -445,13 +445,13 @@ } /* memory_ioctl */ static struct file_operations mtd_fops = { - owner: THIS_MODULE, - llseek: mtd_lseek, /* lseek */ - read: mtd_read, /* read */ - write: mtd_write, /* write */ - ioctl: mtd_ioctl, /* ioctl */ - open: mtd_open, /* open */ - release: mtd_close, /* release */ + .owner = THIS_MODULE, + .llseek = mtd_lseek, /* lseek */ + .read = mtd_read, /* read */ + .write = mtd_write, /* write */ + .ioctl = mtd_ioctl, /* ioctl */ + .open = mtd_open, /* open */ + .release = mtd_close, /* release */ }; diff -Nru a/drivers/mtd/nand/spia.c b/drivers/mtd/nand/spia.c --- a/drivers/mtd/nand/spia.c Tue Mar 4 19:30:10 2003 +++ b/drivers/mtd/nand/spia.c Tue Mar 4 19:30:10 2003 @@ -66,12 +66,15 @@ * Define partitions for flash device */ const static struct mtd_partition partition_info[] = { - { name: "SPIA flash partition 1", - offset: 0, - size: 2*1024*1024 }, - { name: "SPIA flash partition 2", - offset: 2*1024*1024, - size: 6*1024*1024 } + { + .name = "SPIA flash partition 1", + .size = 2*1024*1024 + }, + { + .name = "SPIA flash partition 2", + .offset = 2*1024*1024, + .size = 6*1024*1024 + } }; #define NUM_PARTITIONS 2 diff -Nru a/drivers/mtd/nftlcore.c b/drivers/mtd/nftlcore.c --- a/drivers/mtd/nftlcore.c Tue Mar 4 19:30:04 2003 +++ b/drivers/mtd/nftlcore.c Tue Mar 4 19:30:04 2003 @@ -914,8 +914,8 @@ ****************************************************************************/ static struct mtd_notifier nftl_notifier = { - add: NFTL_notify_add, - remove: NFTL_notify_remove + .add = NFTL_notify_add, + .remove = NFTL_notify_remove }; extern char nftlmountrev[]; diff -Nru a/drivers/net/3c501.c b/drivers/net/3c501.c --- a/drivers/net/3c501.c Tue Mar 4 19:30:03 2003 +++ b/drivers/net/3c501.c Tue Mar 4 19:30:03 2003 @@ -494,7 +494,7 @@ * @regs: Register data (surplus to our requirements) * * Handle the ether interface interrupts. The 3c501 needs a lot more - * hand holding than most cards. In paticular we get a transmit interrupt + * hand holding than most cards. In particular we get a transmit interrupt * with a collision error because the board firmware isnt capable of rewinding * its own transmit buffer pointers. It can however count to 16 for us. * @@ -684,7 +684,7 @@ * @dev: Device to pull the packets from * * We have a good packet. Well, not really "good", just mostly not broken. - * We must check everything to see if it is good. In paticular we occasionally + * We must check everything to see if it is good. In particular we occasionally * get wild packet sizes from the card. If the packet seems sane we PIO it * off the card and queue it for the protocol layers. */ diff -Nru a/drivers/net/3c503.c b/drivers/net/3c503.c --- a/drivers/net/3c503.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/3c503.c Tue Mar 4 19:30:11 2003 @@ -693,7 +693,7 @@ MODULE_PARM(xcvr, "1-" __MODULE_STRING(MAX_EL2_CARDS) "i"); MODULE_PARM_DESC(io, "I/O base address(es)"); MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)"); -MODULE_PARM_DESC(xcvr, "tranceiver(s) (0=internal, 1=external)"); +MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)"); MODULE_DESCRIPTION("3Com ISA EtherLink II, II/16 (3c503, 3c503/16) driver"); MODULE_LICENSE("GPL"); diff -Nru a/drivers/net/3c509.c b/drivers/net/3c509.c --- a/drivers/net/3c509.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/3c509.c Tue Mar 4 19:30:04 2003 @@ -385,7 +385,7 @@ idev))) { if (pnp_device_attach(idev) < 0) continue; - if (pnp_activate_dev(idev, NULL) < 0) { + if (pnp_activate_dev(idev) < 0) { __again: pnp_device_detach(idev); continue; @@ -1139,7 +1139,7 @@ int ioaddr = dev->base_addr; EL3WINDOW(0); - /* obtain current tranceiver via WN4_MEDIA? */ + /* obtain current transceiver via WN4_MEDIA? */ tmp = inw(ioaddr + WN0_ADDR_CONF); ecmd->transceiver = XCVR_INTERNAL; switch (tmp >> 14) { @@ -1548,7 +1548,7 @@ MODULE_PARM(max_interrupt_work, "i"); MODULE_PARM_DESC(debug, "debug level (0-6)"); MODULE_PARM_DESC(irq, "IRQ number(s) (assigned)"); -MODULE_PARM_DESC(xcvr,"tranceiver(s) (0=internal, 1=external)"); +MODULE_PARM_DESC(xcvr,"transceiver(s) (0=internal, 1=external)"); MODULE_PARM_DESC(max_interrupt_work, "maximum events handled per interrupt"); #ifdef __ISAPNP__ MODULE_PARM(nopnp, "i"); diff -Nru a/drivers/net/3c515.c b/drivers/net/3c515.c --- a/drivers/net/3c515.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/3c515.c Tue Mar 4 19:30:04 2003 @@ -469,7 +469,7 @@ if (pnp_device_attach(idev) < 0) continue; - if (pnp_activate_dev(idev, NULL) < 0) { + if (pnp_activate_dev(idev) < 0) { printk("pnp activate failed (out of resources?)\n"); pnp_device_detach(idev); return -ENOMEM; diff -Nru a/drivers/net/3c527.c b/drivers/net/3c527.c --- a/drivers/net/3c527.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/3c527.c Tue Mar 4 19:30:09 2003 @@ -227,7 +227,7 @@ * Because MCA bus is a real bus and we can scan for cards we could do a * single scan for all boards here. Right now we use the passed in device * structure and scan for only one board. This needs fixing for modules - * in paticular. + * in particular. */ int __init mc32_probe(struct net_device *dev) @@ -1168,7 +1168,7 @@ * the stack or, if the packet is near MTU sized, we allocate * another buffer and flip the old one up the stack. * - * We must succeed in keeping a buffer on the ring. If neccessary we + * We must succeed in keeping a buffer on the ring. If necessary we * will toss a received packet rather than lose a ring entry. Once * the first uncompleted descriptor is found, we move the * End-Of-List bit to include the buffers just processed. diff -Nru a/drivers/net/8390.c b/drivers/net/8390.c --- a/drivers/net/8390.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/8390.c Tue Mar 4 19:30:04 2003 @@ -277,7 +277,7 @@ /* Mask interrupts from the ethercard. SMP: We have to grab the lock here otherwise the IRQ handler on another CPU can flip window and race the IRQ mask set. We end - up trashing the mcast filter not disabling irqs if we dont lock */ + up trashing the mcast filter not disabling irqs if we don't lock */ spin_lock_irqsave(&ei_local->page_lock, flags); outb_p(0x00, e8390_base + EN0_IMR); @@ -417,7 +417,7 @@ * Handle the ether interface interrupts. We pull packets from * the 8390 via the card specific functions and fire them at the networking * stack. We also handle transmit completions and wake the transmit path if - * neccessary. We also update the counters and do other housekeeping as + * necessary. We also update the counters and do other housekeeping as * needed. */ diff -Nru a/drivers/net/acenic.c b/drivers/net/acenic.c --- a/drivers/net/acenic.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/acenic.c Tue Mar 4 19:30:08 2003 @@ -1378,7 +1378,7 @@ * On this platform, we know what the best dma settings * are. We use 64-byte maximum bursts, because if we * burst larger than the cache line size (or even cross - * a 64byte boundry in a single burst) the UltraSparc + * a 64byte boundary in a single burst) the UltraSparc * PCI controller will disconnect at 64-byte multiples. * * Read-multiple will be properly enabled above, and when diff -Nru a/drivers/net/atp.c b/drivers/net/atp.c --- a/drivers/net/atp.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/atp.c Tue Mar 4 19:30:14 2003 @@ -162,7 +162,7 @@ MODULE_PARM_DESC(debug, "ATP debug level (0-7)"); MODULE_PARM_DESC(io, "ATP I/O base address(es)"); MODULE_PARM_DESC(irq, "ATP IRQ number(s)"); -MODULE_PARM_DESC(xcvr, "ATP tranceiver(s) (0=internal, 1=external)"); +MODULE_PARM_DESC(xcvr, "ATP transceiver(s) (0=internal, 1=external)"); /* The number of low I/O ports used by the ethercard. */ #define ETHERCARD_TOTAL_SIZE 3 diff -Nru a/drivers/net/b44.h b/drivers/net/b44.h --- a/drivers/net/b44.h Tue Mar 4 19:30:11 2003 +++ b/drivers/net/b44.h Tue Mar 4 19:30:11 2003 @@ -424,7 +424,7 @@ }; /* There are only 12 bits in the DMA engine for descriptor offsetting - * so the table must be aligned on a boundry of this. + * so the table must be aligned on a boundary of this. */ #define DMA_TABLE_BYTES 4096 diff -Nru a/drivers/net/cs89x0.c b/drivers/net/cs89x0.c --- a/drivers/net/cs89x0.c Tue Mar 4 19:30:12 2003 +++ b/drivers/net/cs89x0.c Tue Mar 4 19:30:12 2003 @@ -1112,7 +1112,7 @@ int i; int ret; -#ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this wont work */ +#ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this won't work */ if (dev->irq < 2) { /* Allow interrupts to be generated by the chip */ /* Cirrus' release had this: */ diff -Nru a/drivers/net/declance.c b/drivers/net/declance.c --- a/drivers/net/declance.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/declance.c Tue Mar 4 19:30:10 2003 @@ -887,7 +887,7 @@ cp_to_buf((char *) lp->tx_buf_ptr_cpu[entry], skb->data, skblen); /* Clear the slack of the packet, do I need this? */ - /* For a firewall its a good idea - AC */ + /* For a firewall it's a good idea - AC */ /* if (len != skblen) memset ((char *) &ib->tx_buf [entry][skblen], 0, (len - skblen) << 1); diff -Nru a/drivers/net/dgrs.c b/drivers/net/dgrs.c --- a/drivers/net/dgrs.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/dgrs.c Tue Mar 4 19:30:04 2003 @@ -274,7 +274,7 @@ ulong x; /* - * If Space.c says not to use DMA, or if its not a PLX based + * If Space.c says not to use DMA, or if it's not a PLX based * PCI board, or if the expansion ROM space is not PCI * configured, then return false. */ @@ -331,10 +331,10 @@ * Initiate DMA using PLX part on PCI board. Spin the * processor until completed. All addresses are physical! * - * If pciaddr is NULL, then its a chaining DMA, and lcladdr is + * If pciaddr is NULL, then it's a chaining DMA, and lcladdr is * the address of the first DMA descriptor in the chain. * - * If pciaddr is not NULL, then its a single DMA. + * If pciaddr is not NULL, then it's a single DMA. * * In either case, "lcladdr" must have been fixed up to make * sure the MSB isn't set using the S2DMA macro before passing @@ -511,7 +511,7 @@ if (priv0->use_dma && priv0->dmadesc_h && len > 64) { /* - * If we can use DMA and its a long frame, copy it using + * If we can use DMA and it's a long frame, copy it using * DMA chaining. */ DMACHAIN *ddp_h; /* Host virtual DMA desc. pointer */ @@ -583,7 +583,7 @@ else if (priv0->use_dma) { /* - * If we can use DMA and its a shorter frame, copy it + * If we can use DMA and it's a shorter frame, copy it * using single DMA transfers. */ uchar *phys_p; diff -Nru a/drivers/net/e100/e100.h b/drivers/net/e100/e100.h --- a/drivers/net/e100/e100.h Tue Mar 4 19:30:05 2003 +++ b/drivers/net/e100/e100.h Tue Mar 4 19:30:05 2003 @@ -706,8 +706,6 @@ #define IPCB_INSERTVLAN_ENABLE BIT_1 #define IPCB_IP_ACTIVATION_DEFAULT IPCB_HARDWAREPARSING_ENABLE -#define FOLD_CSUM(_XSUM) ((((_XSUM << 16) | (_XSUM >> 16)) + _XSUM) >> 16) - /* Transmit Buffer Descriptor (TBD)*/ typedef struct _tbd_t { u32 tbd_buf_addr; /* Physical Transmit Buffer Address */ diff -Nru a/drivers/net/e100/e100_config.c b/drivers/net/e100/e100_config.c --- a/drivers/net/e100/e100_config.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/e100/e100_config.c Tue Mar 4 19:30:05 2003 @@ -149,7 +149,7 @@ * 32 from the RFD base address, instead of at offset 16. */ bdp->config[7] |= CB_CFIG_EXTENDED_RFD; - /* put the chip into D102 receive mode. This is neccessary + /* put the chip into D102 receive mode. This is necessary * for any parsing and offloading features. */ bdp->config[22] = CB_CFIG_RECEIVE_GAMLA_MODE; diff -Nru a/drivers/net/e100/e100_eeprom.c b/drivers/net/e100/e100_eeprom.c --- a/drivers/net/e100/e100_eeprom.c Tue Mar 4 19:30:07 2003 +++ b/drivers/net/e100/e100_eeprom.c Tue Mar 4 19:30:07 2003 @@ -138,7 +138,7 @@ // is then passed to the read/write functions. // // Returns: -// Size of the eeprom, or zero if an error occured +// Size of the eeprom, or zero if an error occurred //---------------------------------------------------------------------------------------- u16 e100_eeprom_size(struct e100_private *adapter) diff -Nru a/drivers/net/e100/e100_main.c b/drivers/net/e100/e100_main.c --- a/drivers/net/e100/e100_main.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/e100/e100_main.c Tue Mar 4 19:30:08 2003 @@ -1949,7 +1949,7 @@ /* to allow manipulation with current skb we need to unlink it */ list_del(&(rx_struct->list_elem)); - /* do not free & unmap badly recieved packet. + /* do not free & unmap badly received packet. * move it to the end of skb list for reuse */ if (!(rfd_status & RFD_STATUS_OK)) { e100_add_skb_to_end(bdp, rx_struct); @@ -2071,32 +2071,6 @@ } /** - * e100_pseudo_hdr_csum - compute IP pseudo-header checksum - * @ip: points to the header of the IP packet - * - * Return the 16 bit checksum of the IP pseudo-header.,which is computed - * on the fields: IP src, IP dst, next protocol, payload length. - * The checksum vaule is returned in network byte order. - */ -static inline u16 -e100_pseudo_hdr_csum(const struct iphdr *ip) -{ - u32 pseudo = 0; - u32 payload_len = 0; - - payload_len = ntohs(ip->tot_len) - (ip->ihl * 4); - - pseudo += htons(payload_len); - pseudo += (ip->protocol << 8); - pseudo += ip->saddr & 0x0000ffff; - pseudo += (ip->saddr & 0xffff0000) >> 16; - pseudo += ip->daddr & 0x0000ffff; - pseudo += (ip->daddr & 0xffff0000) >> 16; - - return FOLD_CSUM(pseudo); -} - -/** * e100_prepare_xmit_buff - prepare a buffer for transmission * @bdp: atapter's private data struct * @skb: skb to send @@ -2140,27 +2114,13 @@ if ((ip->protocol == IPPROTO_TCP) || (ip->protocol == IPPROTO_UDP)) { - u16 *chksum; - tcb->tcbu.ipcb.ip_activation_high = IPCB_HARDWAREPARSING_ENABLE; tcb->tcbu.ipcb.ip_schedule |= IPCB_TCPUDP_CHECKSUM_ENABLE; - if (ip->protocol == IPPROTO_TCP) { - struct tcphdr *tcp; - - tcp = (struct tcphdr *) ((u32 *) ip + ip->ihl); - chksum = &(tcp->check); + if (ip->protocol == IPPROTO_TCP) tcb->tcbu.ipcb.ip_schedule |= IPCB_TCP_PACKET; - } else { - struct udphdr *udp; - - udp = (struct udphdr *) ((u32 *) ip + ip->ihl); - chksum = &(udp->check); - } - - *chksum = e100_pseudo_hdr_csum(ip); } } @@ -2236,7 +2196,7 @@ spin_lock_irqsave(&(bdp->bd_lock), lock_flag); switch (bdp->next_cu_cmd) { case RESUME_NO_WAIT: - /*last cu command was a CU_RESMUE if this is a 558 or newer we dont need to + /*last cu command was a CU_RESMUE if this is a 558 or newer we don't need to * wait for command word to clear, we reach here only if we are bachlor */ e100_exec_cmd(bdp, SCB_CUC_RESUME); diff -Nru a/drivers/net/e2100.c b/drivers/net/e2100.c --- a/drivers/net/e2100.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/e2100.c Tue Mar 4 19:30:13 2003 @@ -389,7 +389,7 @@ MODULE_PARM_DESC(io, "I/O base address(es)"); MODULE_PARM_DESC(irq, "IRQ number(s)"); MODULE_PARM_DESC(mem, " memory base address(es)"); -MODULE_PARM_DESC(xcvr, "tranceiver(s) (0=internal, 1=external)"); +MODULE_PARM_DESC(xcvr, "transceiver(s) (0=internal, 1=external)"); MODULE_DESCRIPTION("Cabletron E2100 ISA ethernet driver"); MODULE_LICENSE("GPL"); diff -Nru a/drivers/net/eepro100.c b/drivers/net/eepro100.c --- a/drivers/net/eepro100.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/eepro100.c Tue Mar 4 19:30:11 2003 @@ -148,7 +148,7 @@ MODULE_PARM(max_interrupt_work, "i"); MODULE_PARM(multicast_filter_limit, "i"); MODULE_PARM_DESC(debug, "debug level (0-6)"); -MODULE_PARM_DESC(options, "Bits 0-3: tranceiver type, bit 4: full duplex, bit 5: 100Mbps"); +MODULE_PARM_DESC(options, "Bits 0-3: transceiver type, bit 4: full duplex, bit 5: 100Mbps"); MODULE_PARM_DESC(full_duplex, "full duplex setting(s) (1)"); MODULE_PARM_DESC(congenb, "Enable congestion control (1)"); MODULE_PARM_DESC(txfifo, "Tx FIFO threshold in 4 byte units, (0-15)"); diff -Nru a/drivers/net/eth16i.c b/drivers/net/eth16i.c --- a/drivers/net/eth16i.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/eth16i.c Tue Mar 4 19:30:13 2003 @@ -1231,7 +1231,7 @@ /* Turn off all interrupts from adapter */ outw(ETH16I_INTR_OFF, ioaddr + TX_INTR_REG); - /* eth16i_tx wont be called */ + /* eth16i_tx won't be called */ spin_lock(&lp->lock); status = inw(ioaddr + TX_STATUS_REG); /* Get the status */ diff -Nru a/drivers/net/fc/iph5526.c b/drivers/net/fc/iph5526.c --- a/drivers/net/fc/iph5526.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/fc/iph5526.c Tue Mar 4 19:30:05 2003 @@ -499,7 +499,7 @@ fi->q.ptr_tachyon_header[i] = fi->q.ptr_tachyon_header_base + 16*i; /* Allocate memory for indices. - * Indices should be aligned on 32 byte boundries. + * Indices should be aligned on 32 byte boundaries. */ fi->q.host_ocq_cons_indx = kmalloc(2*32, GFP_KERNEL); if (fi->q.host_ocq_cons_indx == NULL){ @@ -748,7 +748,7 @@ else if (current_IMQ_index < fi->q.imq_cons_indx) no_of_entries = IMQ_LENGTH - (fi->q.imq_cons_indx - current_IMQ_index); - /* We dont want to look at the same IMQ entry again. + /* We don't want to look at the same IMQ entry again. */ temp_imq_cons_indx = fi->q.imq_cons_indx + 1; if (no_of_entries != 0) @@ -2263,7 +2263,7 @@ u_int type = TYPE_ELS | SEQUENCE_INITIATIVE | FIRST_SEQUENCE; u_int my_mtu = fi->g.my_mtu; ENTER("tx_logi"); - /* We dont want interrupted for our own logi. + /* We don't want interrupted for our own logi. * It screws up the port discovery process. */ if (d_id == fi->g.my_id) @@ -2567,7 +2567,7 @@ } /* Perform Port Discovery after timer expires. * We are giving time for the ADISCed nodes to respond - * so that we dont have to perform PLOGI to those whose + * so that we don't have to perform PLOGI to those whose * login are _still_ valid. */ fi->explore_timer.function = port_discovery_timer; @@ -3175,38 +3175,6 @@ LEAVE("rx_net_mfs_packet"); } -unsigned short fc_type_trans(struct sk_buff *skb, struct net_device *dev) -{ -struct fch_hdr *fch=(struct fch_hdr *)skb->data; -struct fcllc *fcllc; - skb->mac.raw = skb->data; - fcllc = (struct fcllc *)(skb->data + sizeof(struct fch_hdr) + 2); - skb_pull(skb,sizeof(struct fch_hdr) + 2); - - if(*fch->daddr & 1) { - if(!memcmp(fch->daddr,dev->broadcast,FC_ALEN)) - skb->pkt_type = PACKET_BROADCAST; - else - skb->pkt_type = PACKET_MULTICAST; - } - else if(dev->flags & IFF_PROMISC) { - if(memcmp(fch->daddr, dev->dev_addr, FC_ALEN)) - skb->pkt_type=PACKET_OTHERHOST; - } - - /* Strip the SNAP header from ARP packets since we don't - * pass them through to the 802.2/SNAP layers. - */ - - if (fcllc->dsap == EXTENDED_SAP && - (fcllc->ethertype == ntohs(ETH_P_IP) || - fcllc->ethertype == ntohs(ETH_P_ARP))) { - skb_pull(skb, sizeof(struct fcllc)); - return fcllc->ethertype; - } - return ntohs(ETH_P_802_2); -} - static int tx_exchange(struct fc_info *fi, char *data, u_int len, u_int r_ctl, u_int type, u_int d_id, u_int mtu, int int_required, u_short tx_ox_id, u_int frame_class) { u_char df_ctl; @@ -3527,7 +3495,7 @@ /* There might be some new nodes to be * discovered. But, some of the earlier * requests as a result of the RSCN might be - * in progress. We dont want to duplicate that + * in progress. We don't want to duplicate that * effort. So letz call SCR after a lag. */ fi->explore_timer.function = scr_timer; diff -Nru a/drivers/net/fc/tach_structs.h b/drivers/net/fc/tach_structs.h --- a/drivers/net/fc/tach_structs.h Tue Mar 4 19:30:11 2003 +++ b/drivers/net/fc/tach_structs.h Tue Mar 4 19:30:11 2003 @@ -248,7 +248,7 @@ volatile u_char n_port_try; volatile u_char nport_timer_set; volatile u_char lport_timer_set; - /* Hmmm... We dont want to Initialize while closing */ + /* Hmmm... We don't want to Initialize while closing */ u_char dont_init; u_int my_node_name_high; u_int my_node_name_low; diff -Nru a/drivers/net/fec.c b/drivers/net/fec.c --- a/drivers/net/fec.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/fec.c Tue Mar 4 19:30:04 2003 @@ -828,7 +828,7 @@ /* * I had some nice ideas of running the MDIO faster... * The 971 should support 8MHz and I tried it, but things acted really - * wierd, so 2.5 MHz ought to be enough for anyone... + * weird, so 2.5 MHz ought to be enough for anyone... */ static void mii_parse_lxt971_sr2(uint mii_reg, struct net_device *dev) diff -Nru a/drivers/net/hamachi.c b/drivers/net/hamachi.c --- a/drivers/net/hamachi.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/hamachi.c Tue Mar 4 19:30:14 2003 @@ -316,7 +316,7 @@ the new buffer or the function returns non-zero which should case the scheduler to reschedule the buffer later. -01/15/1999 EPK Some adjustments were made to the chip intialization. +01/15/1999 EPK Some adjustments were made to the chip initialization. End-to-end flow control should now be fully active and the interrupt algorithm vars have been changed. These could probably use further tuning. diff -Nru a/drivers/net/hp100.c b/drivers/net/hp100.c --- a/drivers/net/hp100.c Tue Mar 4 19:30:07 2003 +++ b/drivers/net/hp100.c Tue Mar 4 19:30:07 2003 @@ -2811,7 +2811,7 @@ printk("hp100: %s: Problem logging into the HUB.\n", dev->name); if (lp->chip == HP100_CHIPID_LASSEN) { /* Check allowed Register to find out why there is a problem. */ - val = hp100_inw(TRAIN_ALLOW); /* wont work on non-ETR card */ + val = hp100_inw(TRAIN_ALLOW); /* won't work on non-ETR card */ #ifdef HP100_DEBUG_TRAINING printk("hp100: %s: MAC Configuration requested: 0x%04x, HUB allowed: 0x%04x\n", dev->name, hp100_inw(TRAIN_REQUEST), val); #endif @@ -2868,7 +2868,7 @@ hp100_andb(~HP100_PCI_RESET, PCICTRL2); hp100_orb(HP100_PCI_RESET, PCICTRL2); /* Wait for min. 300 ns */ - /* we cant use jiffies here, because it may be */ + /* we can't use jiffies here, because it may be */ /* that we have disabled the timer... */ udelay(400); hp100_andb(~HP100_PCI_RESET, PCICTRL2); diff -Nru a/drivers/net/irda/actisys-sir.c b/drivers/net/irda/actisys-sir.c --- a/drivers/net/irda/actisys-sir.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/irda/actisys-sir.c Tue Mar 4 19:30:10 2003 @@ -207,7 +207,7 @@ * o second put the dongle in a know state * * The dongle is powered of the RTS and DTR lines. In the dongle, there - * is a big capacitor to accomodate the current spikes. This capacitor + * is a big capacitor to accommodate the current spikes. This capacitor * takes a least 50 ms to be charged. In theory, the Bios set those lines * up, so by the time we arrive here we should be set. It doesn't hurt * to be on the conservative side, so we will wait... diff -Nru a/drivers/net/irda/actisys.c b/drivers/net/irda/actisys.c --- a/drivers/net/irda/actisys.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/irda/actisys.c Tue Mar 4 19:30:14 2003 @@ -217,7 +217,7 @@ * o second put the dongle in a know state * * The dongle is powered of the RTS and DTR lines. In the dongle, there - * is a big capacitor to accomodate the current spikes. This capacitor + * is a big capacitor to accommodate the current spikes. This capacitor * takes a least 50 ms to be charged. In theory, the Bios set those lines * up, so by the time we arrive here we should be set. It doesn't hurt * to be on the conservative side, so we will wait... diff -Nru a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c --- a/drivers/net/irda/irda-usb.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/irda/irda-usb.c Tue Mar 4 19:30:09 2003 @@ -120,7 +120,7 @@ /************************ TRANSMIT ROUTINES ************************/ /* * Receive packets from the IrDA stack and send them on the USB pipe. - * Handle speed change, timeout and lot's of uglyness... + * Handle speed change, timeout and lot's of ugliness... */ /*------------------------------------------------------------------*/ diff -Nru a/drivers/net/irda/irtty-sir.c b/drivers/net/irda/irtty-sir.c --- a/drivers/net/irda/irtty-sir.c Tue Mar 4 19:30:03 2003 +++ b/drivers/net/irda/irtty-sir.c Tue Mar 4 19:30:03 2003 @@ -532,7 +532,7 @@ tty->driver.flush_buffer(tty); /* from old irtty - but what is it good for? - * we _are_ the ldisc and we _dont_ implement flush_buffer! + * we _are_ the ldisc and we _don't_ implement flush_buffer! * * if (tty->ldisc.flush_buffer) * tty->ldisc.flush_buffer(tty); diff -Nru a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c --- a/drivers/net/irda/sir_dev.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/irda/sir_dev.c Tue Mar 4 19:30:10 2003 @@ -569,7 +569,7 @@ /* instead of adding tests to protect against drv->do_write==NULL * at several places we refuse to create a sir_dev instance for - * drivers which dont implement do_write. + * drivers which don't implement do_write. */ if (!drv || !drv->do_write) return NULL; diff -Nru a/drivers/net/irda/sir_kthread.c b/drivers/net/irda/sir_kthread.c --- a/drivers/net/irda/sir_kthread.c Tue Mar 4 19:30:12 2003 +++ b/drivers/net/irda/sir_kthread.c Tue Mar 4 19:30:12 2003 @@ -151,7 +151,7 @@ while (irda_rq_queue.thread != NULL) { - set_task_state(current, TASK_UNINTERRUPTIBLE); + set_task_state(current, TASK_INTERRUPTIBLE); add_wait_queue(&irda_rq_queue.kick, &wait); if (list_empty(&irda_rq_queue.request_list)) schedule(); diff -Nru a/drivers/net/ne.c b/drivers/net/ne.c --- a/drivers/net/ne.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/ne.c Tue Mar 4 19:30:08 2003 @@ -205,7 +205,7 @@ /* Avoid already found cards from previous calls */ if (pnp_device_attach(idev) < 0) continue; - if (pnp_activate_dev(idev, NULL) < 0) { + if (pnp_activate_dev(idev) < 0) { pnp_device_detach(idev); continue; } diff -Nru a/drivers/net/pcmcia/Kconfig b/drivers/net/pcmcia/Kconfig --- a/drivers/net/pcmcia/Kconfig Tue Mar 4 19:30:12 2003 +++ b/drivers/net/pcmcia/Kconfig Tue Mar 4 19:30:12 2003 @@ -153,19 +153,5 @@ The module will be called ibmtr_cs. If you want to compile it as a module, say M here and read . -config AIRONET4500_CS - tristate "Aironet 4500/4800 PCMCIA support" - depends on NET_PCMCIA_RADIO && AIRONET4500 && PCMCIA - help - Say Y here if you have a PCMCIA Aironet 4500/4800 card which you - want to use with the standard PCMCIA cardservices provided by the - pcmcia-cs package. - - This driver is also available as a module ( = code which can be - inserted in and removed from the running kernel whenever you want). - The module will be called aironet4500_cs. If you want to - compile it as a module, say M here and read - . - endmenu diff -Nru a/drivers/net/pcmcia/Makefile b/drivers/net/pcmcia/Makefile --- a/drivers/net/pcmcia/Makefile Tue Mar 4 19:30:03 2003 +++ b/drivers/net/pcmcia/Makefile Tue Mar 4 19:30:03 2003 @@ -13,7 +13,4 @@ obj-$(CONFIG_ARCNET_COM20020_CS)+= com20020_cs.o obj-$(CONFIG_PCMCIA_AXNET) += axnet_cs.o -# 16-bit wireless client drivers -obj-$(CONFIG_AIRONET4500_CS) += aironet4500_cs.o - obj-$(CONFIG_PCMCIA_IBMTR) += ibmtr_cs.o diff -Nru a/drivers/net/pcmcia/aironet4500_cs.c b/drivers/net/pcmcia/aironet4500_cs.c --- a/drivers/net/pcmcia/aironet4500_cs.c Tue Mar 4 19:30:04 2003 +++ /dev/null Wed Dec 31 16:00:00 1969 @@ -1,706 +0,0 @@ -/* - * Aironet 4500 Pcmcia driver - * - * Elmer Joandi, Januar 1999 - * Copyright Elmer Joandi, all rights restricted - * - * - * Revision 0.1 ,started 30.12.1998 - * - * - */ - -#define DRV_NAME "aironet4500_cs" -#define DRV_VERSION "0.1" - -static const char *awc_version = -DRV_NAME ".c v" DRV_VERSION " 1/1/99 Elmer Joandi, elmer@ylenurme.ee.\n"; - - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -#include "../aironet4500.h" - -static u_int irq_mask = 0x5eF8; -static int awc_ports[] = {0x140,0x100,0xc0, 0x80 }; -#if LINUX_VERSION_CODE > 0x20100 -MODULE_PARM(irq_mask, "i"); - -#endif - - -#define RUN_AT(x) (jiffies+(x)) - -#ifdef PCMCIA_DEBUG -static int pc_debug = PCMCIA_DEBUG; -MODULE_PARM(pc_debug, "i"); -#define PC_DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args) -static char *version = -"aironet4500_cs.c v0.1 1/1/99 Elmer Joandi, elmer@ylenurme.ee.\n"; -#else -#define PC_DEBUG(n, args...) -#endif - -/* Index of functions. */ - -static dev_info_t dev_info = "aironet4500_cs"; - -static dev_link_t *awc_attach(void); -static void awc_detach(dev_link_t *); -static void awc_release(u_long arg); -static int awc_event(event_t event, int priority, - event_callback_args_t *args); - -static dev_link_t *dev_list; - -static void cs_error(client_handle_t handle, int func, int ret) -{ -#if CS_RELEASE_CODE < 0x2911 - CardServices(ReportError, dev_info, (void *)func, (void *)ret); -#else - error_info_t err = { func, ret }; - CardServices(ReportError, handle, &err); -#endif -} - -#define CFG_CHECK(fn, args...) if (CardServices(fn, args) != 0) goto next_entry - -static void flush_stale_links(void) -{ - dev_link_t *link, *next; - for (link = dev_list; link; link = next) { - next = link->next; - if (link->state & DEV_STALE_LINK) - awc_detach(link); - } -} - - -/* - We never need to do anything when a awc device is "initialized" - by the net software, because we only register already-found cards. -*/ - -static int awc_pcmcia_init(struct net_device *dev) -{ - return awc_init(dev); - -} - -static int awc_pcmcia_open(struct net_device *dev) -{ - dev_link_t *link; - int status; - - for (link = dev_list; link; link = link->next) - if (link->priv == dev) break; - if (!DEV_OK(link)) - return -ENODEV; - - status = awc_open(dev); - - if (!status ) - link->open++; - - return status; -} - -static int awc_pcmcia_close(struct net_device *dev) -{ -// int ioaddr = dev->base_addr; - dev_link_t *link; - int ret; - - for (link = dev_list; link; link = link->next) - if (link->priv == dev) break; - if (link == NULL) - return -ENODEV; - - PC_DEBUG(2, "%s: closing device.\n", dev->name); - - link->open--; - ret = awc_close(dev); - - if (link->state & DEV_STALE_CONFIG) { - link->release.expires = RUN_AT( HZ/20 ); - link->state |= DEV_RELEASE_PENDING; - add_timer(&link->release); - } - return ret; -} - -static int netdev_ethtool_ioctl (struct net_device *dev, void *useraddr) -{ - u32 ethcmd; - - /* dev_ioctl() in ../../net/core/dev.c has already checked - capable(CAP_NET_ADMIN), so don't bother with that here. */ - - if (get_user(ethcmd, (u32 *)useraddr)) - return -EFAULT; - - switch (ethcmd) { - - case ETHTOOL_GDRVINFO: { - struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO }; - strcpy (info.driver, DRV_NAME); - strcpy (info.version, DRV_VERSION); - sprintf(info.bus_info, "PCMCIA 0x%lx", dev->base_addr); - if (copy_to_user (useraddr, &info, sizeof (info))) - return -EFAULT; - return 0; - } - -#ifdef PCMCIA_DEBUG - /* get message-level */ - case ETHTOOL_GMSGLVL: { - struct ethtool_value edata = {ETHTOOL_GMSGLVL}; - edata.data = pc_debug; - if (copy_to_user(useraddr, &edata, sizeof(edata))) - return -EFAULT; - return 0; - } - /* set message-level */ - case ETHTOOL_SMSGLVL: { - struct ethtool_value edata; - if (copy_from_user(&edata, useraddr, sizeof(edata))) - return -EFAULT; - pc_debug = edata.data; - return 0; - } -#endif - - default: - break; - } - - return -EOPNOTSUPP; -} - -static int awc_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) -{ - switch (cmd) { - case SIOCETHTOOL: - return netdev_ethtool_ioctl(dev, (void *) rq->ifr_data); - - default: - return -EOPNOTSUPP; - } - return 0; -} - -/* - awc_attach() creates an "instance" of the driver, allocating - local data structures for one device. The device is registered - with Card Services. -*/ - -static dev_link_t *awc_attach(void) -{ - client_reg_t client_reg; - dev_link_t *link = NULL; - struct net_device *dev = NULL; - int ret; - - PC_DEBUG(0, "awc_attach()\n"); - flush_stale_links(); - - /* Create the PC card device object. */ - link = kmalloc(sizeof(struct dev_link_t), GFP_KERNEL); - if (!link) - return NULL; - memset(link, 0, sizeof(struct dev_link_t)); - - link->dev = kmalloc(sizeof(struct dev_node_t), GFP_KERNEL); - if (!link->dev) { - kfree(link); - return NULL; - } - - memset(link->dev, 0, sizeof(struct dev_node_t)); - - init_timer(&link->release); - link->release.function = &awc_release; - link->release.data = (u_long)link; -// link->io.NumPorts1 = 32; - link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; -// link->io.IOAddrLines = 5; - link->irq.Attributes = IRQ_HANDLE_PRESENT ; // |IRQ_TYPE_EXCLUSIVE ; - link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID; - link->irq.IRQInfo2 = irq_mask; - link->irq.Handler = &awc_interrupt; - link->conf.Attributes = CONF_ENABLE_IRQ; - link->conf.Vcc = 50; - link->conf.IntType = INT_MEMORY_AND_IO; - link->conf.ConfigIndex = 1; - link->conf.Present = PRESENT_OPTION; - - /* Create the network device object. */ - - dev = kmalloc(sizeof(struct net_device ), GFP_KERNEL); -// dev = init_etherdev(0, sizeof(struct awc_private) ); - if (!dev ) { - printk(KERN_CRIT "out of mem on dev alloc \n"); - kfree(link->dev); - kfree(link); - return NULL; - }; - memset(dev,0,sizeof(struct net_device)); - dev->priv = kmalloc(sizeof(struct awc_private), GFP_KERNEL); - if (!dev->priv ) {printk(KERN_CRIT "out of mem on dev priv alloc \n"); return NULL;}; - memset(dev->priv,0,sizeof(struct awc_private)); - -// link->dev->minor = dev->minor; -// link->dev->major = dev->major; - - /* The 4500-specific entries in the device structure. */ - -// dev->tx_queue_len = tx_queue_len; - - dev->hard_start_xmit = &awc_start_xmit; -// dev->set_config = &awc_config_misiganes,aga mitte awc_config; - dev->get_stats = &awc_get_stats; -// dev->set_multicast_list = &awc_set_multicast_list; - dev->do_ioctl = &awc_ioctl; - - strcpy(dev->name, ((struct awc_private *)dev->priv)->node.dev_name); - - ether_setup(dev); - - dev->init = &awc_pcmcia_init; - dev->open = &awc_pcmcia_open; - dev->stop = &awc_pcmcia_close; - - link->priv = dev; -#if CS_RELEASE_CODE > 0x2911 - link->irq.Instance = dev; -#endif - - /* Register with Card Services */ - link->next = dev_list; - dev_list = link; - - - client_reg.dev_info = &dev_info; - client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE; - client_reg.EventMask = - CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL | - CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET | - CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME; - client_reg.event_handler = &awc_event; - client_reg.Version = 0x0210; - client_reg.event_callback_args.client_data = link; - ret = CardServices(RegisterClient, &link->handle, &client_reg); - if (ret != 0) { - cs_error(link->handle, RegisterClient, ret); - awc_detach(link); - return NULL; - } - - return link; -} /* awc_attach */ - -/* - - This deletes a driver "instance". The device is de-registered - with Card Services. If it has been released, all local data - structures are freed. Otherwise, the structures will be freed - when the device is released. - -*/ - -static void awc_detach(dev_link_t *link) -{ - dev_link_t **linkp; - unsigned long flags; - int i=0; - - DEBUG(0, "awc_detach(0x%p)\n", link); - - /* Locate device structure */ - for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next) - if (*linkp == link) break; - if (*linkp == NULL) - return; - - save_flags(flags); - cli(); - if (link->state & DEV_RELEASE_PENDING) { - del_timer(&link->release); - link->state &= ~DEV_RELEASE_PENDING; - } - restore_flags(flags); - - if (link->state & DEV_CONFIG) { - awc_release((u_long)link); - if (link->state & DEV_STALE_CONFIG) { - link->state |= DEV_STALE_LINK; - return; - } - } - - if (link->handle) - CardServices(DeregisterClient, link->handle); - - /* Unlink device structure, free bits */ - *linkp = link->next; - - i=0; - while ( i < MAX_AWCS) { - if (!aironet4500_devices[i]) - {i++; continue;} - if (aironet4500_devices[i] == link->priv){ - if (awc_proc_unset_fun) - awc_proc_unset_fun(i); - - aironet4500_devices[i]=0; - } - i++; - } - - if (link->priv) { - //struct net_device *dev = link->priv; - // dam dam damn mif (dev->priv) - // kfree(dev->priv); - kfree(link->priv); - } - kfree(link->dev); - kfree(link); - -} /* awc_detach */ - -/* - - awc_pcmcia_config() is scheduled to run after a CARD_INSERTION event - is received, to configure the PCMCIA socket, and to make the - ethernet device available to the system. - -*/ - -#define CS_CHECK(fn, args...) \ -while ((last_ret=CardServices(last_fn=(fn), args))!=0) goto cs_failed - -static void awc_pcmcia_config(dev_link_t *link) -{ - client_handle_t handle; - struct net_device *dev; - struct awc_private *lp; - tuple_t tuple; - int ii; - cisparse_t parse; - u_short buf[64]; - int last_fn, last_ret, i = 0; -// int ioaddr; - u16 *phys_addr; - int retval; - - handle = link->handle; - dev = link->priv; - phys_addr = (u16 *)dev->dev_addr; - - PC_DEBUG(0, "awc_pcmcia_config(0x%p)\n", link); - - tuple.Attributes = 0; - tuple.DesiredTuple = CISTPL_CONFIG; - CS_CHECK(GetFirstTuple, handle, &tuple); - tuple.TupleData = (cisdata_t *)buf; - tuple.TupleDataMax = 64; - tuple.TupleOffset = 0; - CS_CHECK(GetTupleData, handle, &tuple); - CS_CHECK(ParseTuple, handle, &tuple, &parse); - link->conf.ConfigBase = parse.config.base; - link->conf.Present = parse.config.rmask[0]; - - - /* Configure card */ - link->state |= DEV_CONFIG; - - tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; - CS_CHECK(GetFirstTuple, handle, &tuple); - - while (1) { - cistpl_cftable_entry_t dflt = { 0 }; - cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); - CFG_CHECK(GetTupleData, handle, &tuple); - CFG_CHECK(ParseTuple, handle, &tuple, &parse); - - if (cfg->flags & CISTPL_CFTABLE_DEFAULT) dflt = *cfg; - if (cfg->index == 0) goto next_entry; - link->conf.ConfigIndex = cfg->index; - - /* Use power settings for Vcc and Vpp if present */ - /* Note that the CIS values need to be rescaled */ - if (cfg->vcc.present & (1<conf.Vcc = cfg->vcc.param[CISTPL_POWER_VNOM]/10000; - else if (dflt.vcc.present & (1<conf.Vcc = dflt.vcc.param[CISTPL_POWER_VNOM]/10000; - - if (cfg->vpp1.present & (1<conf.Vpp1 = link->conf.Vpp2 = - cfg->vpp1.param[CISTPL_POWER_VNOM]/10000; - else if (dflt.vpp1.present & (1<conf.Vpp1 = link->conf.Vpp2 = - dflt.vpp1.param[CISTPL_POWER_VNOM]/10000; - - /* Do we need to allocate an interrupt? */ - if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) - link->conf.Attributes |= CONF_ENABLE_IRQ; - - /* IO window settings */ - link->io.NumPorts1 = link->io.NumPorts2 = 0; - if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { - cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; - link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO; - if (!(io->flags & CISTPL_IO_8BIT)) - link->io.Attributes1 = IO_DATA_PATH_WIDTH_16; - if (!(io->flags & CISTPL_IO_16BIT)) { - - link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; - printk(KERN_CRIT "8-bit IO not supported on this aironet 4500 driver \n"); - } - link->io.BasePort1 = io->win[0].base; - - link->io.NumPorts1 = io->win[0].len; - if (io->nwin > 1) { - link->io.Attributes2 = link->io.Attributes1; - link->io.BasePort2 = io->win[1].base; - link->io.NumPorts2 = io->win[1].len; - } - } - ii = 0; - last_fn = RequestIO; - while ((last_ret = CardServices(RequestIO, link->handle, &link->io)) ){ - - if (ii > 4) - goto cs_failed; - link->io.BasePort1 = awc_ports[ii]; - ii++; - }; - - - break; - - next_entry: - if (CardServices(GetNextTuple, handle, &tuple)) - break; - } - - if (link->conf.Attributes & CONF_ENABLE_IRQ){ - - ii = 0; last_fn = RequestIRQ; - while ((last_ret = CardServices(RequestIRQ, link->handle, &link->irq)) ){ - - ii++; - while (!(irq_mask & (1 << ii) ) && ii < 15) - ii++; - link->irq.IRQInfo2 = 1 << ii; - - if(ii > 15) - goto cs_failed; - printk("trying irq %d , mask %x \n",ii, link->irq.IRQInfo2); - - }; - } - - CS_CHECK(RequestConfiguration, link->handle, &link->conf); - - - dev->irq = link->irq.AssignedIRQ; - dev->base_addr = link->io.BasePort1; - - - awc_private_init( dev); - - - - retval = register_netdev(dev); - if (retval != 0) { - printk(KERN_NOTICE "awc_cs: register_netdev() failed for dev %x retval %x\n",(unsigned int)dev,retval); - goto failed; - } - - if(awc_pcmcia_init(dev)) goto failed; - - i=0; - while (aironet4500_devices[i] && i < MAX_AWCS-1) i++; - if (!aironet4500_devices[i]){ - aironet4500_devices[i]=dev; - if (awc_proc_set_fun) - awc_proc_set_fun(i); - } - - - link->state &= ~DEV_CONFIG_PENDING; - - lp = (struct awc_private *)dev->priv; - - DEBUG(1,"pcmcia config complete on port %x \n",(unsigned int)dev->base_addr); - - return; - -cs_failed: - cs_error(link->handle, last_fn, last_ret); - link->dev=NULL; -failed: - - awc_release((u_long)link); - return; - -} /* awc_pcmcia_config */ - -/* - After a card is removed, awc_release() will unregister the net - device, and release the PCMCIA configuration. If the device is - still open, this will be postponed until it is closed. - -*/ - -static void awc_release(u_long arg) -{ - dev_link_t *link = (dev_link_t *)arg; - struct net_device *dev = link->priv; - - DEBUG(0, "awc_release(0x%p)\n", link); - - if (link->open) { - DEBUG(1, "awc_cs: release postponed, '%s' still open\n", - link->dev->dev_name); - link->state |= DEV_STALE_CONFIG; - return; - } - - CardServices(ReleaseConfiguration, link->handle); - CardServices(ReleaseIO, link->handle, &link->io); - CardServices(ReleaseIRQ, link->handle, &link->irq); - - CardServices(ReleaseWindow, link->win); - if (link->dev) - unregister_netdev(dev); - // link->dev = NULL; - - link->state &= ~DEV_CONFIG; - if (link->state & DEV_STALE_LINK) - awc_detach(link); - -} /* awc_release */ - -/* - - The card status event handler. Mostly, this schedules other - stuff to run after an event is received. A CARD_REMOVAL event - also sets some flags to discourage the net drivers from trying - to talk to the card any more. -*/ - -static int awc_event(event_t event, int priority, - event_callback_args_t *args) -{ - dev_link_t *link = args->client_data; - struct net_device *dev = link->priv; - - PC_DEBUG(1, "awc_event(0x%06x)\n", event); - - switch (event) { - case CS_EVENT_CARD_REMOVAL: - link->state &= ~DEV_PRESENT; - if (link->state & DEV_CONFIG) { - netif_device_detach(dev); - link->release.expires = RUN_AT( HZ/20 ); - add_timer(&link->release); - } - break; - case CS_EVENT_CARD_INSERTION: - link->state |= DEV_PRESENT | DEV_CONFIG_PENDING; - awc_pcmcia_config(link); - break; - case CS_EVENT_PM_SUSPEND: - link->state |= DEV_SUSPEND; - /* Fall through... */ - case CS_EVENT_RESET_PHYSICAL: - if (link->state & DEV_CONFIG) { - if (link->open) - netif_device_detach(dev); - - CardServices(ReleaseConfiguration, link->handle); - } - break; - case CS_EVENT_PM_RESUME: - link->state &= ~DEV_SUSPEND; - /* Fall through... */ - case CS_EVENT_CARD_RESET: - if (link->state & DEV_CONFIG) { - CardServices(RequestConfiguration, link->handle, &link->conf); - if (link->open) { - // awc_reset(dev); - netif_device_attach(dev); - } - } - break; - } - return 0; -} /* awc_event */ - - - -static int __init aironet_cs_init(void) -{ - servinfo_t serv; - - /* Always emit the version, before any failure. */ - printk(KERN_INFO"%s", awc_version); - PC_DEBUG(0, "%s\n", version); - CardServices(GetCardServicesInfo, &serv); - if (serv.Revision != CS_RELEASE_CODE) { - printk(KERN_NOTICE "awc_cs: Card Services release " - "does not match!\n"); - return -1; - } - register_pcmcia_driver(&dev_info, &awc_attach, &awc_detach); - return 0; -} - -static void __exit aironet_cs_exit(void) -{ - DEBUG(0, "awc_cs: unloading %c ",'\n'); - unregister_pcmcia_driver(&dev_info); - - while (dev_list != NULL) { - if (dev_list->state & DEV_CONFIG) - awc_release((u_long)dev_list); - awc_detach(dev_list); - } - -// while (dev_list != NULL) -// awc_detach(dev_list); -} - -module_init(aironet_cs_init); -module_exit(aironet_cs_exit); -MODULE_LICENSE("GPL"); diff -Nru a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c --- a/drivers/net/pcmcia/axnet_cs.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/pcmcia/axnet_cs.c Tue Mar 4 19:30:09 2003 @@ -1226,7 +1226,7 @@ /* Mask interrupts from the ethercard. SMP: We have to grab the lock here otherwise the IRQ handler on another CPU can flip window and race the IRQ mask set. We end - up trashing the mcast filter not disabling irqs if we dont lock */ + up trashing the mcast filter not disabling irqs if we don't lock */ spin_lock_irqsave(&ei_local->page_lock, flags); outb_p(0x00, e8390_base + EN0_IMR); @@ -1341,7 +1341,7 @@ * Handle the ether interface interrupts. We pull packets from * the 8390 via the card specific functions and fire them at the networking * stack. We also handle transmit completions and wake the transmit path if - * neccessary. We also update the counters and do other housekeeping as + * necessary. We also update the counters and do other housekeeping as * needed. */ diff -Nru a/drivers/net/pppoe.c b/drivers/net/pppoe.c --- a/drivers/net/pppoe.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/pppoe.c Tue Mar 4 19:30:11 2003 @@ -292,7 +292,7 @@ /* Now restart from the beginning of this * hash chain. We always NULL out pppoe_dev - * so we are guarenteed to make forward + * so we are guaranteed to make forward * progress. */ po = item_hash_table[hash]; diff -Nru a/drivers/net/sb1000.c b/drivers/net/sb1000.c --- a/drivers/net/sb1000.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/sb1000.c Tue Mar 4 19:30:04 2003 @@ -170,7 +170,7 @@ if (pnp_device_attach(idev) < 0) continue; - if (pnp_activate_dev(idev, NULL) < 0) { + if (pnp_activate_dev(idev) < 0) { __again: pnp_device_detach(idev); continue; diff -Nru a/drivers/net/sb1250-mac.c b/drivers/net/sb1250-mac.c --- a/drivers/net/sb1250-mac.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/sb1250-mac.c Tue Mar 4 19:30:13 2003 @@ -512,7 +512,7 @@ * regidx = index of register to read * * Return value: - * value read, or 0 if an error occured. + * value read, or 0 if an error occurred. ********************************************************************* */ static unsigned int sbmac_mii_read(struct sbmac_softc *s,int phyaddr,int regidx) @@ -554,7 +554,7 @@ SBMAC_WRITECSR(s->sbm_mdio,M_MAC_MDIO_DIR_INPUT); /* - * If an error occured, the PHY will signal '1' back + * If an error occurred, the PHY will signal '1' back */ error = SBMAC_READCSR(s->sbm_mdio) & M_MAC_MDIO_IN; diff -Nru a/drivers/net/sis900.c b/drivers/net/sis900.c --- a/drivers/net/sis900.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/sis900.c Tue Mar 4 19:30:08 2003 @@ -1971,7 +1971,7 @@ status = mdio_read(dev, mii_phy->phy_addr, MII_CONTROL); /* enable auto negotiation and reset the negotioation - (I dont really know what the auto negatiotiation reset + (I don't really know what the auto negatiotiation reset really means, but it sounds for me right to do one here)*/ mdio_write(dev, mii_phy->phy_addr, MII_CONTROL, status | MII_CNTL_AUTO | MII_CNTL_RST_AUTO); diff -Nru a/drivers/net/sk98lin/h/lm80.h b/drivers/net/sk98lin/h/lm80.h --- a/drivers/net/sk98lin/h/lm80.h Tue Mar 4 19:30:13 2003 +++ b/drivers/net/sk98lin/h/lm80.h Tue Mar 4 19:30:13 2003 @@ -126,7 +126,7 @@ #define LM80_IS_BTI (1<<1) /* state of BTI# pin */ #define LM80_IS_FAN1 (1<<2) /* count limit exceeded for Fan 1 */ #define LM80_IS_FAN2 (1<<3) /* count limit exceeded for Fan 2 */ -#define LM80_IS_CI (1<<4) /* Chassis Intrusion occured */ +#define LM80_IS_CI (1<<4) /* Chassis Intrusion occurred */ #define LM80_IS_OS (1<<5) /* OS temperature limit exceeded */ /* bit 6 and 7 are reserved in LM80_ISRC_2 */ #define LM80_IS_HT_IRQ_MD (1<<6) /* Hot temperature interrupt mode */ diff -Nru a/drivers/net/sk98lin/h/skdrv1st.h b/drivers/net/sk98lin/h/skdrv1st.h --- a/drivers/net/sk98lin/h/skdrv1st.h Tue Mar 4 19:30:03 2003 +++ b/drivers/net/sk98lin/h/skdrv1st.h Tue Mar 4 19:30:03 2003 @@ -72,7 +72,7 @@ * Description: * * This is the first include file of the driver, which includes all - * neccessary system header files and some of the GEnesis header files. + * necessary system header files and some of the GEnesis header files. * It also defines some basic items. * * Include File Hierarchy: diff -Nru a/drivers/net/sk98lin/h/skdrv2nd.h b/drivers/net/sk98lin/h/skdrv2nd.h --- a/drivers/net/sk98lin/h/skdrv2nd.h Tue Mar 4 19:30:14 2003 +++ b/drivers/net/sk98lin/h/skdrv2nd.h Tue Mar 4 19:30:14 2003 @@ -85,7 +85,7 @@ * Description: * * This is the second include file of the driver, which includes all other - * neccessary files and defines all structures and constants used by the + * necessary files and defines all structures and constants used by the * driver and the common modules. * * Include File Hierarchy: diff -Nru a/drivers/net/sk98lin/h/xmac_ii.h b/drivers/net/sk98lin/h/xmac_ii.h --- a/drivers/net/sk98lin/h/xmac_ii.h Tue Mar 4 19:30:13 2003 +++ b/drivers/net/sk98lin/h/xmac_ii.h Tue Mar 4 19:30:13 2003 @@ -279,7 +279,7 @@ * XMAC Bit Definitions * * If the bit access behaviour differs from the register access behaviour - * (r/w, ro) this is docomented after the bit number. The following bit + * (r/w, ro) this is documented after the bit number. The following bit * access behaviours are used: * (sc) self clearing * (ro) read only @@ -413,7 +413,7 @@ #define XM_ST_BC (1L<<7) /* Bit 7: Broadcast packet */ #define XM_ST_MC (1L<<6) /* Bit 6: Multicast packet */ #define XM_ST_UC (1L<<5) /* Bit 5: Unicast packet */ -#define XM_ST_TX_UR (1L<<4) /* Bit 4: FIFO Underrun occured */ +#define XM_ST_TX_UR (1L<<4) /* Bit 4: FIFO Underrun occurred */ #define XM_ST_CS_ERR (1L<<3) /* Bit 3: Carrier Sense Error */ #define XM_ST_LAT_COL (1L<<2) /* Bit 2: Late Collision Error */ #define XM_ST_MUL_COL (1L<<1) /* Bit 1: Multiple Collisions */ diff -Nru a/drivers/net/sk98lin/skcsum.c b/drivers/net/sk98lin/skcsum.c --- a/drivers/net/sk98lin/skcsum.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/sk98lin/skcsum.c Tue Mar 4 19:30:04 2003 @@ -195,7 +195,7 @@ * zero.) * * Note: - * There is a bug in the ASIC whic may lead to wrong checksums. + * There is a bug in the ASIC which may lead to wrong checksums. * * Arguments: * pAc - A pointer to the adapter context struct. diff -Nru a/drivers/net/sk98lin/skge.c b/drivers/net/sk98lin/skge.c --- a/drivers/net/sk98lin/skge.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/sk98lin/skge.c Tue Mar 4 19:30:04 2003 @@ -3627,7 +3627,7 @@ * Description: * This routine writes a 16 bit value to the pci configuration * space. The flag PciConfigUp indicates whether the config space - * is accesible or must be set up first. + * is accessible or must be set up first. * * Returns: * 0 - indicate everything worked ok. @@ -3650,7 +3650,7 @@ * Description: * This routine writes a 8 bit value to the pci configuration * space. The flag PciConfigUp indicates whether the config space - * is accesible or must be set up first. + * is accessible or must be set up first. * * Returns: * 0 - indicate everything worked ok. diff -Nru a/drivers/net/sk98lin/skgehwt.c b/drivers/net/sk98lin/skgehwt.c --- a/drivers/net/sk98lin/skgehwt.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/sk98lin/skgehwt.c Tue Mar 4 19:30:13 2003 @@ -61,14 +61,14 @@ * fix: chg pAc -> pAC * * Revision 1.4 1998/08/10 14:14:52 gklug - * rmv: unneccessary SK_ADDR macro + * rmv: unnecessary SK_ADDR macro * * Revision 1.3 1998/08/07 12:53:44 gklug * fix: first compiled version * * Revision 1.2 1998/08/07 09:19:29 gklug * adapt functions to the C coding conventions - * rmv unneccessary functions. + * rmv unnecessary functions. * * Revision 1.1 1998/08/05 11:28:36 gklug * first version: adapted from SMT/FDDI diff -Nru a/drivers/net/sk98lin/skgepnmi.c b/drivers/net/sk98lin/skgepnmi.c --- a/drivers/net/sk98lin/skgepnmi.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/sk98lin/skgepnmi.c Tue Mar 4 19:30:11 2003 @@ -236,7 +236,7 @@ * -Fixed bug for RX counters. On an RX overflow interrupt the high * words of all RX counters were incremented. * -SET operations on FLOWCTRL_MODE and LINK_MODE accept now the - * value 0, which has no effect. It is usefull for multiple instance + * value 0, which has no effect. It is useful for multiple instance * SETs. * * Revision 1.37 1998/11/20 08:02:04 mhaveman @@ -1639,7 +1639,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed - * SK_PNMI_ERR_GENERAL A general severe internal error occured + * SK_PNMI_ERR_GENERAL A general severe internal error occurred * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to take * the data. * SK_PNMI_ERR_UNKNOWN_OID The requested OID is unknown @@ -1672,13 +1672,13 @@ * Description: * Calls a general sub-function for all this stuff. The preset does * the same as a set, but returns just before finally setting the - * new value. This is usefull to check if a set might be successfull. + * new value. This is useful to check if a set might be successful. * If as instance a -1 is passed, an array of values is supposed and * all instance of the OID will be set. * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -1716,13 +1716,13 @@ * Description: * Calls a general sub-function for all this stuff. The preset does * the same as a set, but returns just before finally setting the - * new value. This is usefull to check if a set might be successfull. + * new value. This is useful to check if a set might be successful. * If as instance a -1 is passed, an array of values is supposed and * all instance of the OID will be set. * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -1766,7 +1766,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed - * SK_PNMI_ERR_GENERAL A general severe internal error occured + * SK_PNMI_ERR_GENERAL A general severe internal error occurred * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to take * the data. * SK_PNMI_ERR_UNKNOWN_NET The requested NetIndex doesn't exist @@ -1935,7 +1935,7 @@ * Description: * Calls a general sub-function for all this set stuff. The preset does * the same as a set, but returns just before finally setting the - * new value. This is usefull to check if a set might be successfull. + * new value. This is useful to check if a set might be successful. * The sub-function runs through the IdTable, checks which OIDs are able * to set, and calls the handler function of the OID to perform the * preset. The return value of the function will also be stored in @@ -1944,7 +1944,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -1983,7 +1983,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -2934,7 +2934,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3002,7 +3002,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3137,7 +3137,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3280,7 +3280,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3427,7 +3427,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3639,7 +3639,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -3758,7 +3758,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -4003,7 +4003,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -4482,7 +4482,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -5189,7 +5189,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -5498,7 +5498,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -5698,7 +5698,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -6362,7 +6362,7 @@ * * Returns: * SK_PNMI_ERR_OK The request was successfully performed. - * SK_PNMI_ERR_GENERAL A general severe internal error occured. + * SK_PNMI_ERR_GENERAL A general severe internal error occurred. * SK_PNMI_ERR_TOO_SHORT The passed buffer is too short to contain * the correct data (e.g. a 32bit value is * needed, but a 16 bit value was passed). @@ -6813,7 +6813,7 @@ * * Description: * The COMMON module only tells us if the mode is half or full duplex. - * But in the decade of auto sensing it is usefull for the user to + * But in the decade of auto sensing it is useful for the user to * know if the mode was negotiated or forced. Therefore we have a * look to the mode, which was last used by the negotiation process. * @@ -7364,7 +7364,7 @@ * * Description: * The trap buffer stores various events. A user application somehow - * gets notified that an event occured and retrieves the trap buffer + * gets notified that an event occurred and retrieves the trap buffer * contens (or simply polls the buffer). The buffer is organized as * a ring which stores the newest traps at the beginning. The oldest * traps are overwritten by the newest ones. Each trap entry has a diff -Nru a/drivers/net/sk98lin/skgesirq.c b/drivers/net/sk98lin/skgesirq.c --- a/drivers/net/sk98lin/skgesirq.c Tue Mar 4 19:30:03 2003 +++ b/drivers/net/sk98lin/skgesirq.c Tue Mar 4 19:30:03 2003 @@ -736,14 +736,14 @@ /* Check whether XMACs are correctly initialized */ if ((Istatus & (IS_PA_TO_RX1 | IS_PA_TO_TX1)) && !pAC->GIni.GP[MAC_1].PState) { - /* XMAC was not initialized but Packet timeout occured */ + /* XMAC was not initialized but Packet timeout occurred */ SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E004, SKERR_SIRQ_E004MSG); } if ((Istatus & (IS_PA_TO_RX2 | IS_PA_TO_TX2)) && !pAC->GIni.GP[MAC_2].PState) { - /* XMAC was not initialized but Packet timeout occured */ + /* XMAC was not initialized but Packet timeout occurred */ SK_ERR_LOG(pAC, SK_ERRCL_SW | SK_ERRCL_INIT, SKERR_SIRQ_E005, SKERR_SIRQ_E005MSG); } @@ -1111,7 +1111,7 @@ * otherwise the Linux driver will have a problem. */ /* - * We received a bunch of frames or no CRC error occured on the + * We received a bunch of frames or no CRC error occurred on the * network -> ok. */ pPrt->PPrevRx = RxCts; @@ -1379,7 +1379,7 @@ pPrt->PAutoNegTOCt ++; /* - * Timeout occured. + * Timeout occurred. * What do we need now? */ SK_DBG_MSG(pAC,SK_DBGMOD_HWM, @@ -1389,7 +1389,7 @@ if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE && pPrt->PLipaAutoNeg != SK_LIPA_AUTO) { /* - * Timeout occured + * Timeout occurred * Set Link manually up. */ SkHWSenseSetNext(pAC, IoC, Port, SK_LMODE_FULL); @@ -1872,7 +1872,7 @@ pPrt->PAutoNegTimeOut ++; if (pPrt->PAutoNegTimeOut >= SK_AND_MAX_TO) { /* - * Timeout occured. + * Timeout occurred. * What do we need now? */ SK_DBG_MSG(pAC,SK_DBGMOD_HWM, @@ -1882,7 +1882,7 @@ if (pPrt->PLinkModeConf == SK_LMODE_AUTOSENSE && pPrt->PLipaAutoNeg != SK_LIPA_AUTO) { /* - * Timeout occured + * Timeout occurred * Set Link manually up. */ SkHWSenseSetNext(pAC, IoC, Port, diff -Nru a/drivers/net/sk98lin/ski2c.c b/drivers/net/sk98lin/ski2c.c --- a/drivers/net/sk98lin/ski2c.c Tue Mar 4 19:30:03 2003 +++ b/drivers/net/sk98lin/ski2c.c Tue Mar 4 19:30:03 2003 @@ -178,7 +178,7 @@ * Revision 1.2 1998/08/11 07:27:15 gklug * add: functions of the interface * adapt rest of source to C coding Conventions - * rmv: unneccessary code taken from Mona Lisa + * rmv: unnecessary code taken from Mona Lisa * * Revision 1.1 1998/06/19 14:28:43 malthoff * Created. Sources taken from ML Projekt. @@ -444,7 +444,7 @@ /* * Receive an ACK. * - * returns 0 If acknoledged + * returns 0 If acknowledged * 1 in case of an error */ int SkI2cRcvAck( diff -Nru a/drivers/net/sk98lin/skqueue.c b/drivers/net/sk98lin/skqueue.c --- a/drivers/net/sk98lin/skqueue.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/sk98lin/skqueue.c Tue Mar 4 19:30:05 2003 @@ -153,7 +153,7 @@ * send command to state machine * end * return error reported by individual Event function - * 0 if no error occured. + * 0 if no error occurred. */ int SkEventDispatcher( SK_AC *pAC, /* Adapters Context */ diff -Nru a/drivers/net/sk98lin/skvpd.c b/drivers/net/sk98lin/skvpd.c --- a/drivers/net/sk98lin/skvpd.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/sk98lin/skvpd.c Tue Mar 4 19:30:10 2003 @@ -563,7 +563,7 @@ /* * find the Keyword 'key' in the VPD buffer and fills the - * parameter sturct 'p' with it's values + * parameter sturct 'p' with its values * * returns *p success * 0: parameter was not found or VPD encoding error diff -Nru a/drivers/net/sk98lin/skxmac2.c b/drivers/net/sk98lin/skxmac2.c --- a/drivers/net/sk98lin/skxmac2.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/sk98lin/skxmac2.c Tue Mar 4 19:30:14 2003 @@ -596,7 +596,7 @@ * none, National: 80ns). * * ATTENTION: - * It is absolutely neccessary to reset the SW_RST Bit first + * It is absolutely necessary to reset the SW_RST Bit first * before calling this function. * * Returns: diff -Nru a/drivers/net/sk_mca.c b/drivers/net/sk_mca.c --- a/drivers/net/sk_mca.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/sk_mca.c Tue Mar 4 19:30:11 2003 @@ -45,7 +45,7 @@ May 23nd, 1999 can receive frames, send frames May 24th, 1999 - modularized intialization of LANCE + modularized initialization of LANCE loadable as module still Tx problem :-( May 26th, 1999 @@ -581,7 +581,7 @@ return GetLANCE(dev, LANCE_CSR0); } -/* did we loose blocks due to a FIFO overrun ? */ +/* did we lose blocks due to a FIFO overrun ? */ static u16 irqmiss_handler(struct SKMCA_NETDEV *dev, u16 oldcsr0) { diff -Nru a/drivers/net/skfp/h/smc.h b/drivers/net/skfp/h/smc.h --- a/drivers/net/skfp/h/smc.h Tue Mar 4 19:30:04 2003 +++ b/drivers/net/skfp/h/smc.h Tue Mar 4 19:30:04 2003 @@ -320,7 +320,7 @@ u_char evc_rep_required ; /* report required */ u_short evc_para ; /* SMT Para Number */ u_char *evc_cond_state ; /* condition state */ - u_char *evc_multiple ; /* multiple occurence */ + u_char *evc_multiple ; /* multiple occurrence */ } ; /* diff -Nru a/drivers/net/skfp/hwt.c b/drivers/net/skfp/hwt.c --- a/drivers/net/skfp/hwt.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/skfp/hwt.c Tue Mar 4 19:30:04 2003 @@ -264,7 +264,7 @@ * para start start time * duration time to wait * - * NOTE: The fuction will return immediatly, if the timer is not + * NOTE: The fuction will return immediately, if the timer is not * started ************************/ void hwt_wait_time(smc,start,duration) diff -Nru a/drivers/net/slhc.c b/drivers/net/slhc.c --- a/drivers/net/slhc.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/slhc.c Tue Mar 4 19:30:05 2003 @@ -265,7 +265,7 @@ /* Bail if the TCP packet isn't `compressible' (i.e., ACK isn't set or * some other control bit is set). Also uncompressible if - * its a runt. + * it's a runt. */ if(hlen > isize || th->syn || th->fin || th->rst || ! (th->ack)){ diff -Nru a/drivers/net/smc-ultra.c b/drivers/net/smc-ultra.c --- a/drivers/net/smc-ultra.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/smc-ultra.c Tue Mar 4 19:30:04 2003 @@ -293,7 +293,7 @@ /* Avoid already found cards from previous calls */ if (pnp_device_attach(idev) < 0) continue; - if (pnp_activate_dev(idev, NULL) < 0) { + if (pnp_activate_dev(idev) < 0) { __again: pnp_device_detach(idev); continue; diff -Nru a/drivers/net/sungem.c b/drivers/net/sungem.c --- a/drivers/net/sungem.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/sungem.c Tue Mar 4 19:30:14 2003 @@ -2991,7 +2991,7 @@ gem_begin_auto_negotiation(gp, NULL); spin_unlock_irq(&gp->lock); - /* It is guarenteed that the returned buffer will be at least + /* It is guaranteed that the returned buffer will be at least * PAGE_SIZE aligned. */ gp->init_block = (struct gem_init_block *) diff -Nru a/drivers/net/sungem.h b/drivers/net/sungem.h --- a/drivers/net/sungem.h Tue Mar 4 19:30:09 2003 +++ b/drivers/net/sungem.h Tue Mar 4 19:30:09 2003 @@ -562,7 +562,7 @@ */ /* Statistics Registers. All of these registers are 16-bits and - * track occurances of a specific event. GEM can be configured + * track occurrences of a specific event. GEM can be configured * to interrupt the host cpu when any of these counters overflow. * They should all be explicitly initialized to zero when the interface * is brought up. @@ -830,7 +830,7 @@ * RX Kick register) by the driver it must make sure the buffers are * truly ready and that the ownership bits are set properly. * - * Even though GEM modifies the RX descriptors, it guarentees that the + * Even though GEM modifies the RX descriptors, it guarantees that the * buffer DMA address field will stay the same when it performs these * updates. Therefore it can be used to keep track of DMA mappings * by the host driver just as in the TX descriptor case above. diff -Nru a/drivers/net/sunhme.c b/drivers/net/sunhme.c --- a/drivers/net/sunhme.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/sunhme.c Tue Mar 4 19:30:05 2003 @@ -520,7 +520,7 @@ ASD(("happy_meal_tcvr_write: reg=0x%02x value=%04x\n", reg, value)); /* Welcome to Sun Microsystems, can I take your order please? */ - if (!hp->happy_flags & HFLAG_FENABLE) + if (!(hp->happy_flags & HFLAG_FENABLE)) return happy_meal_bb_write(hp, tregs, reg, value); /* Would you like fries with that? */ @@ -1198,7 +1198,7 @@ * (ETH_FRAME_LEN + 64 + 2) = (1514 + 64 + 2) = 1580 bytes. * * First our alloc_skb() routine aligns the data base to a 64 byte - * boundry. We now have 0xf001b040 as our skb data address. We + * boundary. We now have 0xf001b040 as our skb data address. We * plug this into the receive descriptor address. * * Next, we skb_reserve() 2 bytes to account for the Happy Meal offset. @@ -1651,7 +1651,7 @@ hme_read32(hp, etxregs + ETX_CFG) | ETX_CFG_DMAENABLE); /* This chip really rots, for the receiver sometimes when you - * write to it's control registers not all the bits get there + * write to its control registers not all the bits get there * properly. I cannot think of a sane way to provide complete * coverage for this hardware bug yet. */ diff -Nru a/drivers/net/sunhme.h b/drivers/net/sunhme.h --- a/drivers/net/sunhme.h Tue Mar 4 19:30:08 2003 +++ b/drivers/net/sunhme.h Tue Mar 4 19:30:08 2003 @@ -298,7 +298,7 @@ #define CSCONFIG_NDISABLE 0x8000 /* Disable NRZI */ /* Happy Meal descriptor rings and such. - * All descriptor rings must be aligned on a 2K boundry. + * All descriptor rings must be aligned on a 2K boundary. * All receive buffers must be 64 byte aligned. * Always write the address first before setting the ownership * bits to avoid races with the hardware scanning the ring. diff -Nru a/drivers/net/sunlance.c b/drivers/net/sunlance.c --- a/drivers/net/sunlance.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/sunlance.c Tue Mar 4 19:30:05 2003 @@ -647,7 +647,7 @@ u8 *p8; unsigned long pbuf = (unsigned long) piobuf; - /* We know here that both src and dest are on a 16bit boundry. */ + /* We know here that both src and dest are on a 16bit boundary. */ *p16++ = sbus_readw(pbuf); p32 = (u32 *) p16; pbuf += 2; diff -Nru a/drivers/net/tg3.c b/drivers/net/tg3.c --- a/drivers/net/tg3.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/tg3.c Tue Mar 4 19:30:09 2003 @@ -25,6 +25,7 @@ #include #include #include +#include #include #include @@ -54,8 +55,8 @@ #define DRV_MODULE_NAME "tg3" #define PFX DRV_MODULE_NAME ": " -#define DRV_MODULE_VERSION "1.4" -#define DRV_MODULE_RELDATE "Feb 1, 2003" +#define DRV_MODULE_VERSION "1.4c" +#define DRV_MODULE_RELDATE "Feb 18, 2003" #define TG3_DEF_MAC_MODE 0 #define TG3_DEF_RX_MODE 0 @@ -216,6 +217,12 @@ tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW); } +static inline void tg3_cond_int(struct tg3 *tp) +{ + if (tp->hw_status->status & SD_STATUS_UPDATED) + tw32(GRC_LOCAL_CTRL, tp->grc_local_ctrl | GRC_LCLCTRL_SETINT); +} + static void tg3_enable_ints(struct tg3 *tp) { tw32(TG3PCI_MISC_HOST_CTRL, @@ -223,9 +230,55 @@ tw32_mailbox(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW, 0x00000000); tr32(MAILBOX_INTERRUPT_0 + TG3_64BIT_REG_LOW); - if (tp->hw_status->status & SD_STATUS_UPDATED) - tw32(GRC_LOCAL_CTRL, - tp->grc_local_ctrl | GRC_LCLCTRL_SETINT); + tg3_cond_int(tp); +} + +/* these netif_xxx funcs should be moved into generic net layer */ +static void netif_poll_disable(struct net_device *dev) +{ + while (test_and_set_bit(__LINK_STATE_RX_SCHED, &dev->state)) { + current->state = TASK_INTERRUPTIBLE; + schedule_timeout(1); + } +} + +static inline void netif_poll_enable(struct net_device *dev) +{ + clear_bit(__LINK_STATE_RX_SCHED, &dev->state); +} + +/* same as netif_rx_complete, except that local_irq_save(flags) + * has already been issued + */ +static inline void __netif_rx_complete(struct net_device *dev) +{ + if (!test_bit(__LINK_STATE_RX_SCHED, &dev->state)) BUG(); + list_del(&dev->poll_list); + clear_bit(__LINK_STATE_RX_SCHED, &dev->state); +} + +static inline void netif_tx_disable(struct net_device *dev) +{ + spin_lock_bh(&dev->xmit_lock); + netif_stop_queue(dev); + spin_unlock_bh(&dev->xmit_lock); +} + +static inline void tg3_netif_stop(struct tg3 *tp) +{ + netif_poll_disable(tp->dev); + netif_tx_disable(tp->dev); +} + +static inline void tg3_netif_start(struct tg3 *tp) +{ + netif_wake_queue(tp->dev); + /* NOTE: unconditional netif_wake_queue is only appropriate + * so long as all callers are assured to have free tx slots + * (such as after tg3_init_hw) + */ + netif_poll_enable(tp->dev); + tg3_cond_int(tp); } static void tg3_switch_clocks(struct tg3 *tp) @@ -387,7 +440,6 @@ } static int tg3_setup_phy(struct tg3 *); -static int tg3_halt(struct tg3 *); static int tg3_set_power_state(struct tg3 *tp, int state) { @@ -458,8 +510,6 @@ tg3_setup_phy(tp); } - tg3_halt(tp); - pci_read_config_word(tp->pdev, pm + PCI_PM_PMC, &power_caps); if (tp->tg3_flags & TG3_FLAG_WOL_ENABLE) { @@ -2044,7 +2094,12 @@ spin_unlock(&tp->tx_lock); } - /* run RX thread, within the bounds set by NAPI */ + spin_unlock_irqrestore(&tp->lock, flags); + + /* run RX thread, within the bounds set by NAPI. + * All RX "locking" is done by ensuring outside + * code synchronizes with dev->poll() + */ done = 1; if (sblk->idx[0].rx_producer != tp->rx_rcb_ptr) { int orig_budget = *budget; @@ -2064,12 +2119,12 @@ /* if no more work, tell net stack and NIC we're done */ if (done) { - netif_rx_complete(netdev); + spin_lock_irqsave(&tp->lock, flags); + __netif_rx_complete(netdev); tg3_enable_ints(tp); + spin_unlock_irqrestore(&tp->lock, flags); } - spin_unlock_irqrestore(&tp->lock, flags); - return (done ? 0 : 1); } @@ -2136,17 +2191,21 @@ static void tg3_init_rings(struct tg3 *); static int tg3_init_hw(struct tg3 *); +static int tg3_halt(struct tg3 *); -static void tg3_tx_timeout(struct net_device *dev) +static void tg3_reset_task(void *_data) { - struct tg3 *tp = dev->priv; + struct tg3 *tp = _data; + unsigned int restart_timer; - printk(KERN_ERR PFX "%s: transmit timed out, resetting\n", - dev->name); + tg3_netif_stop(tp); spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); + restart_timer = tp->tg3_flags2 & TG3_FLG2_RESTART_TIMER; + tp->tg3_flags2 &= ~TG3_FLG2_RESTART_TIMER; + tg3_halt(tp); tg3_init_rings(tp); tg3_init_hw(tp); @@ -2154,7 +2213,20 @@ spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); - netif_wake_queue(dev); + tg3_netif_start(tp); + + if (restart_timer) + mod_timer(&tp->timer, jiffies + 1); +} + +static void tg3_tx_timeout(struct net_device *dev) +{ + struct tg3 *tp = dev->priv; + + printk(KERN_ERR PFX "%s: transmit timed out, resetting\n", + dev->name); + + schedule_work(&tp->reset_task); } #if !PCI_DMA_BUS_IS_PHYS @@ -2194,7 +2266,7 @@ int i; #if !PCI_DMA_BUS_IS_PHYS - /* IOMMU, just map the guilty area again which is guarenteed to + /* IOMMU, just map the guilty area again which is guaranteed to * use different addresses. */ @@ -2229,7 +2301,7 @@ return -1; } - /* New SKB is guarenteed to be linear. */ + /* New SKB is guaranteed to be linear. */ entry = *start; new_addr = pci_map_single(tp->pdev, new_skb->data, new_skb->len, PCI_DMA_TODEVICE); @@ -2686,6 +2758,7 @@ return 0; } + tg3_netif_stop(tp); spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); @@ -2698,6 +2771,7 @@ spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); + tg3_netif_start(tp); return 0; } @@ -3073,6 +3147,7 @@ static void tg3_chip_reset(struct tg3 *tp) { u32 val; + u32 flags_save; /* Force NVRAM to settle. * This deals with a chip bug which can result in EEPROM @@ -3089,8 +3164,21 @@ } } + /* + * We must avoid the readl() that normally takes place. + * It locks machines, causes machine checks, and other + * fun things. So, temporarily disable the 5701 + * hardware workaround, while we do the reset. + */ + flags_save = tp->tg3_flags; + tp->tg3_flags &= ~TG3_FLAG_5701_REG_WRITE_BUG; + + /* do the reset */ tw32(GRC_MISC_CFG, GRC_MISC_CFG_CORECLK_RESET); + /* restore 5701 hardware bug workaround flag */ + tp->tg3_flags = flags_save; + /* Flush PCI posted writes. The normal MMIO registers * are inaccessible at this time so this is the only * way to make this reliably. I tried to use indirect @@ -3303,7 +3391,7 @@ 0x00000000 }; -#if 0 /* All zeros, dont eat up space with it. */ +#if 0 /* All zeros, don't eat up space with it. */ u32 tg3FwData[(TG3_FW_DATA_LEN / sizeof(u32)) + 1] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 @@ -3736,7 +3824,7 @@ 0x00000000 }; -#if 0 /* All zeros, dont eat up space with it. */ +#if 0 /* All zeros, don't eat up space with it. */ u32 tg3TsoFwData[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000 @@ -4394,9 +4482,11 @@ } if (!(tr32(WDMAC_MODE) & WDMAC_MODE_ENABLE)) { - tg3_halt(tp); - tg3_init_rings(tp); - tg3_init_hw(tp); + tp->tg3_flags2 |= TG3_FLG2_RESTART_TIMER; + spin_unlock(&tp->tx_lock); + spin_unlock_irqrestore(&tp->lock, flags); + schedule_work(&tp->reset_task); + return; } /* This part only runs once per second. */ @@ -4527,8 +4617,6 @@ return err; } - netif_start_queue(dev); - spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); @@ -4537,6 +4625,8 @@ spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); + netif_start_queue(dev); + return 0; } @@ -5302,6 +5392,7 @@ (ering.tx_pending > TG3_TX_RING_SIZE - 1)) return -EINVAL; + tg3_netif_stop(tp); spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); @@ -5315,6 +5406,7 @@ netif_wake_queue(tp->dev); spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); + tg3_netif_start(tp); return 0; } @@ -5337,6 +5429,7 @@ if (copy_from_user(&epause, useraddr, sizeof(epause))) return -EFAULT; + tg3_netif_stop(tp); spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); if (epause.autoneg) @@ -5356,6 +5449,7 @@ tg3_init_hw(tp); spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); + tg3_netif_start(tp); return 0; } @@ -5941,7 +6035,7 @@ /* Force memory write invalidate off. If we leave it on, * then on 5700_BX chips we have to enable a workaround. - * The workaround is to set the TG3PCI_DMA_RW_CTRL boundry + * The workaround is to set the TG3PCI_DMA_RW_CTRL boundary * to match the cacheline size. The Broadcom driver have this * workaround but turns MWI off all the times so never uses * it. This seems to suggest that the workaround is insufficient. @@ -6710,6 +6804,7 @@ spin_lock_init(&tp->lock); spin_lock_init(&tp->tx_lock); spin_lock_init(&tp->indirect_lock); + PREPARE_WORK(&tp->reset_task, tg3_reset_task, tp); tp->regs = (unsigned long) ioremap(tg3reg_base, tg3reg_len); if (tp->regs == 0UL) { @@ -6851,6 +6946,8 @@ if (!netif_running(dev)) return 0; + tg3_netif_stop(tp); + spin_lock_irq(&tp->lock); spin_lock(&tp->tx_lock); tg3_disable_ints(tp); @@ -6877,6 +6974,7 @@ spin_unlock_irq(&tp->lock); netif_device_attach(dev); + tg3_netif_start(tp); } return err; @@ -6906,6 +7004,8 @@ spin_unlock(&tp->tx_lock); spin_unlock_irq(&tp->lock); + + tg3_netif_start(tp); return 0; } diff -Nru a/drivers/net/tg3.h b/drivers/net/tg3.h --- a/drivers/net/tg3.h Tue Mar 4 19:30:05 2003 +++ b/drivers/net/tg3.h Tue Mar 4 19:30:05 2003 @@ -1821,6 +1821,8 @@ #define TG3_FLAG_GOT_SERDES_FLOWCTL 0x20000000 #define TG3_FLAG_SPLIT_MODE 0x40000000 #define TG3_FLAG_INIT_COMPLETE 0x80000000 + u32 tg3_flags2; +#define TG3_FLG2_RESTART_TIMER 0x00000001 u32 split_mode_max_reqs; #define SPLIT_MODE_5704_MAX_REQ 3 @@ -1889,6 +1891,7 @@ struct tg3_hw_stats *hw_stats; dma_addr_t stats_mapping; + struct work_struct reset_task; }; #endif /* !(_T3_H) */ diff -Nru a/drivers/net/tlan.c b/drivers/net/tlan.c --- a/drivers/net/tlan.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/tlan.c Tue Mar 4 19:30:04 2003 @@ -1630,7 +1630,7 @@ * host_int The contents of the HOST_INT * port. * - * This driver is structured to determine EOC occurances by + * This driver is structured to determine EOC occurrences by * reading the CSTAT member of the list structure. Tx EOC * interrupts are disabled via the DIO INTDIS register. * However, TLAN chips before revision 3.0 didn't have this @@ -1753,7 +1753,7 @@ * host_int The contents of the HOST_INT * port. * - * This driver is structured to determine EOC occurances by + * This driver is structured to determine EOC occurrences by * reading the CSTAT member of the list structure. Rx EOC * interrupts are disabled via the DIO INTDIS register. * However, TLAN chips before revision 3.0 didn't have this @@ -2399,7 +2399,7 @@ * dev A pointer to the device structure of the * TLAN device having the PHYs to be detailed. * - * This function prints the registers a PHY (aka tranceiver). + * This function prints the registers a PHY (aka transceiver). * ********************************************************************/ @@ -2515,7 +2515,7 @@ /* Wait for 50 ms and powerup * This is abitrary. It is intended to make sure the - * tranceiver settles. + * transceiver settles. */ TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_PUP ); @@ -2535,7 +2535,7 @@ TLan_MiiWriteReg( dev, priv->phy[priv->phyNum], MII_GEN_CTL, value ); TLan_MiiSync(dev->base_addr); /* Wait for 500 ms and reset the - * tranceiver. The TLAN docs say both 50 ms and + * transceiver. The TLAN docs say both 50 ms and * 500 ms, so do the longer, just in case. */ TLan_SetTimer( dev, (HZ/20), TLAN_TIMER_PHY_RESET ); @@ -2650,7 +2650,7 @@ TLan_MiiWriteReg( dev, phy, TLAN_TLPHY_CTL, tctl ); } - /* Wait for 2 sec to give the tranceiver time + /* Wait for 2 sec to give the transceiver time * to establish link. */ TLan_SetTimer( dev, (4*HZ), TLAN_TIMER_FINISH_RESET ); diff -Nru a/drivers/net/tokenring/lanstreamer.c b/drivers/net/tokenring/lanstreamer.c --- a/drivers/net/tokenring/lanstreamer.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/tokenring/lanstreamer.c Tue Mar 4 19:30:14 2003 @@ -542,7 +542,7 @@ writew(readw(streamer_mmio + LAPWWO) + 6, streamer_mmio + LAPA); if (readw(streamer_mmio + LAPD)) { - printk(KERN_INFO "tokenring card intialization failed. errorcode : %x\n", + printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n", ntohs(readw(streamer_mmio + LAPD))); release_region(dev->base_addr, STREAMER_IO_SPACE); return -1; diff -Nru a/drivers/net/tokenring/madgemc.c b/drivers/net/tokenring/madgemc.c --- a/drivers/net/tokenring/madgemc.c Tue Mar 4 19:30:13 2003 +++ b/drivers/net/tokenring/madgemc.c Tue Mar 4 19:30:13 2003 @@ -80,7 +80,7 @@ static void madgemc_interrupt(int irq, void *dev_id, struct pt_regs *regs); /* - * These work around paging, however they dont guarentee you're on the + * These work around paging, however they don't guarentee you're on the * right page. */ #define SIFREADB(reg) (inb(dev->base_addr + ((reg<0x8)?reg:reg-0x8))) diff -Nru a/drivers/net/tokenring/olympic.c b/drivers/net/tokenring/olympic.c --- a/drivers/net/tokenring/olympic.c Tue Mar 4 19:30:12 2003 +++ b/drivers/net/tokenring/olympic.c Tue Mar 4 19:30:12 2003 @@ -384,7 +384,7 @@ } #endif if(readw(init_srb+6)) { - printk(KERN_INFO "tokenring card intialization failed. errorcode : %x\n",readw(init_srb+6)); + printk(KERN_INFO "tokenring card initialization failed. errorcode : %x\n",readw(init_srb+6)); return -ENODEV; } diff -Nru a/drivers/net/tokenring/smctr.c b/drivers/net/tokenring/smctr.c --- a/drivers/net/tokenring/smctr.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/tokenring/smctr.c Tue Mar 4 19:30:08 2003 @@ -417,7 +417,7 @@ tp->tx_buff_end[BUG_QUEUE] = (__u16 *)smctr_malloc(dev, 0); /* Allocate MAC receive data buffers. - * MAC Rx buffer doesn't have to be on a 256 byte boundry. + * MAC Rx buffer doesn't have to be on a 256 byte boundary. */ tp->rx_buff_head[MAC_QUEUE] = (__u16 *)smctr_malloc(dev, RX_DATA_BUFFER_SIZE * tp->num_rx_bdbs[MAC_QUEUE]); @@ -438,7 +438,7 @@ * To guarantee a minimum of 256 contigous memory to * UM_Receive_Packet's lookahead pointer, before a page * change or ring end is encountered, place each rx buffer on - * a 256 byte boundry. + * a 256 byte boundary. */ smctr_malloc(dev, TO_256_BYTE_BOUNDRY(tp->sh_mem_used)); tp->rx_buff_head[NON_MAC_QUEUE] = (__u16 *)smctr_malloc(dev, @@ -1331,7 +1331,7 @@ mem_used += tp->tx_buff_size[BUG_QUEUE]; /* Allocate MAC receive data buffers. - * MAC receive buffers don't have to be on a 256 byte boundry. + * MAC receive buffers don't have to be on a 256 byte boundary. */ mem_used += RX_DATA_BUFFER_SIZE * tp->num_rx_bdbs[MAC_QUEUE]; @@ -1348,7 +1348,7 @@ * * Make sure the mem_used offset at this point is the * same as in allocate_shared memory or the following - * boundry adjustment will be incorrect (i.e. not allocating + * boundary adjustment will be incorrect (i.e. not allocating * the non-mac receive buffers above cannot change the 256 * byte offset). * @@ -3930,7 +3930,7 @@ return (err); } -/* Adapter RAM test. Incremental word ODD boundry data test. */ +/* Adapter RAM test. Incremental word ODD boundary data test. */ static int smctr_ram_memory_test(struct net_device *dev) { struct net_local *tp = (struct net_local *)dev->priv; @@ -3947,7 +3947,7 @@ pages_of_ram = tp->ram_size / tp->ram_usable; pword = tp->ram_access; - /* Incremental word ODD boundry test. */ + /* Incremental word ODD boundary test. */ for(page = 0; (page < pages_of_ram) && (~err); page++, start_pattern += 0x8000) { @@ -5598,7 +5598,7 @@ /* if all transmit buffer are cleared * need to set the tx_buff_curr[] to tx_buff_head[] * otherwise, tx buffer will be segregate and cannot - * accomodate and buffer greater than (curr - head) and + * accommodate and buffer greater than (curr - head) and * (end - curr) since we do not allow wrap around allocation. */ if(tp->tx_buff_used[queue] == 0) diff -Nru a/drivers/net/tulip/interrupt.c b/drivers/net/tulip/interrupt.c --- a/drivers/net/tulip/interrupt.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/tulip/interrupt.c Tue Mar 4 19:30:05 2003 @@ -487,7 +487,7 @@ * to the 21142/3 docs that is). * -- rmk */ - printk(KERN_ERR "%s: (%lu) System Error occured (%d)\n", + printk(KERN_ERR "%s: (%lu) System Error occurred (%d)\n", dev->name, tp->nir, error); } /* Clear all error sources, included undocumented ones! */ diff -Nru a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c --- a/drivers/net/tulip/tulip_core.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/tulip/tulip_core.c Tue Mar 4 19:30:10 2003 @@ -1306,7 +1306,7 @@ /* Intel Saturn. Switch to 8 long words burst, 8 long word cache aligned Aries might need this too. The Saturn errata are not pretty reading but - thankfully its an old 486 chipset. + thankfully it's an old 486 chipset. */ if (pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82424, NULL)) { diff -Nru a/drivers/net/tulip/winbond-840.c b/drivers/net/tulip/winbond-840.c --- a/drivers/net/tulip/winbond-840.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/tulip/winbond-840.c Tue Mar 4 19:30:05 2003 @@ -597,7 +597,7 @@ #define mdio_delay(mdio_addr) readl(mdio_addr) /* Set iff a MII transceiver on any interface requires mdio preamble. - This only set with older tranceivers, so the extra + This only set with older transceivers, so the extra code size of a per-interface flag is not worthwhile. */ static char mii_preamble_required = 1; diff -Nru a/drivers/net/tulip/xircom_cb.c b/drivers/net/tulip/xircom_cb.c --- a/drivers/net/tulip/xircom_cb.c Tue Mar 4 19:30:12 2003 +++ b/drivers/net/tulip/xircom_cb.c Tue Mar 4 19:30:12 2003 @@ -121,7 +121,7 @@ static void investigate_read_descriptor(struct net_device *dev,struct xircom_private *card, int descnr, unsigned int bufferoffset); static void investigate_write_descriptor(struct net_device *dev, struct xircom_private *card, int descnr, unsigned int bufferoffset); static void read_mac_address(struct xircom_private *card); -static void tranceiver_voodoo(struct xircom_private *card); +static void transceiver_voodoo(struct xircom_private *card); static void initialize_card(struct xircom_private *card); static void trigger_transmit(struct xircom_private *card); static void trigger_receive(struct xircom_private *card); @@ -301,7 +301,7 @@ /* start the transmitter to get a heartbeat */ /* TODO: send 2 dummy packets here */ - tranceiver_voodoo(private); + transceiver_voodoo(private); spin_lock_irqsave(&private->lock,flags); activate_transmitter(private); @@ -1116,15 +1116,15 @@ /* - tranceiver_voodoo() enables the external UTP plug thingy. + transceiver_voodoo() enables the external UTP plug thingy. it's called voodoo as I stole this code and cannot cross-reference it with the specification. */ -static void tranceiver_voodoo(struct xircom_private *card) +static void transceiver_voodoo(struct xircom_private *card) { unsigned long flags; - enter("tranceiver_voodoo"); + enter("transceiver_voodoo"); /* disable all powermanagement */ pci_write_config_dword(card->pdev, PCI_POWERMGMT, 0x0000); @@ -1143,7 +1143,7 @@ spin_unlock_irqrestore(&card->lock, flags); netif_start_queue(card->dev); - leave("tranceiver_voodoo"); + leave("transceiver_voodoo"); } diff -Nru a/drivers/net/tulip/xircom_tulip_cb.c b/drivers/net/tulip/xircom_tulip_cb.c --- a/drivers/net/tulip/xircom_tulip_cb.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/tulip/xircom_tulip_cb.c Tue Mar 4 19:30:04 2003 @@ -486,7 +486,7 @@ /* * To quote Arjan van de Ven: - * tranceiver_voodoo() enables the external UTP plug thingy. + * transceiver_voodoo() enables the external UTP plug thingy. * it's called voodoo as I stole this code and cannot cross-reference * it with the specification. * Actually it seems to go like this: diff -Nru a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c --- a/drivers/net/via-rhine.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/via-rhine.c Tue Mar 4 19:30:14 2003 @@ -108,11 +108,18 @@ - New reset code uses "force reset" cmd on Rhine-II - Various clean ups + LK1.1.17 (Roger Luethi) + - Fix race in via_rhine_start_tx() + - On errors, wait for Tx engine to turn off before scavenging + - Handle Tx descriptor write-back race on Rhine-II + - Force flushing for PCI posted writes + - More reset code changes + */ #define DRV_NAME "via-rhine" -#define DRV_VERSION "1.1.16" -#define DRV_RELDATE "February-15-2003" +#define DRV_VERSION "1.1.17" +#define DRV_RELDATE "March-1-2003" /* A few user-configurable values. @@ -132,7 +139,7 @@ Both 'options[]' and 'full_duplex[]' should exist for driver interoperability. The media type is usually passed in 'options[]'. - The default is autonegotation for speed and duplex. + The default is autonegotiation for speed and duplex. This should rarely be overridden. Use option values 0x10/0x20 for 10Mbps, 0x100,0x200 for 100Mbps. Use option values 0x10 and 0x100 for forcing half duplex fixed speed. @@ -368,6 +375,8 @@ #else #define RHINE_IOTYPE (PCI_USES_IO | PCI_USES_MASTER | PCI_ADDR0) #endif +/* Beware of PCI posted writes */ +#define IOSYNC do { readb(dev->base_addr + StationAddr); } while (0) /* directly indexed by enum via_rhine_chips, above */ static struct via_rhine_chip_info via_rhine_chip_info[] __devinitdata = @@ -403,7 +412,8 @@ MIICmd=0x70, MIIRegAddr=0x71, MIIData=0x72, MACRegEEcsr=0x74, ConfigA=0x78, ConfigB=0x79, ConfigC=0x7A, ConfigD=0x7B, RxMissed=0x7C, RxCRCErrs=0x7E, MiscCmd=0x81, - StickyHW=0x83, WOLcrClr=0xA4, WOLcgClr=0xA7, PwrcsrClr=0xAC, + StickyHW=0x83, IntrStatus2=0x84, WOLcrClr=0xA4, WOLcgClr=0xA7, + PwrcsrClr=0xAC, }; /* Bits in ConfigD */ @@ -430,6 +440,8 @@ IntrTxAborted=0x2000, IntrLinkChange=0x4000, IntrRxWakeUp=0x8000, IntrNormalSummary=0x0003, IntrAbnormalSummary=0xC260, + IntrTxDescRace=0x080000, /* mapped from IntrStatus2 */ + IntrTxErrSummary=0x082210, }; /* The Rx and Tx buffer descriptors. */ @@ -527,14 +539,28 @@ static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd); static int via_rhine_close(struct net_device *dev); +static inline u32 get_intr_status(struct net_device *dev) +{ + long ioaddr = dev->base_addr; + struct netdev_private *np = dev->priv; + u32 intr_status; + + intr_status = readw(ioaddr + IntrStatus); + /* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */ + if (np->chip_id == VT6102) + intr_status |= readb(ioaddr + IntrStatus2) << 16; + return intr_status; +} + static void wait_for_reset(struct net_device *dev, int chip_id, char *name) { long ioaddr = dev->base_addr; + int boguscnt = 20; - udelay(5); + IOSYNC; if (readw(ioaddr + ChipCmd) & CmdReset) { - printk(KERN_INFO "%s: Reset did not complete in 5 us. " + printk(KERN_INFO "%s: Reset not complete yet. " "Trying harder.\n", name); /* Rhine-II needs to be forced sometimes */ @@ -543,12 +569,14 @@ /* VT86C100A may need long delay after reset (dlink) */ /* Seen on Rhine-II as well (rl) */ - udelay(100); + while ((readw(ioaddr + ChipCmd) & CmdReset) && --boguscnt) + udelay(5); + } if (debug > 1) printk(KERN_INFO "%s: Reset %s.\n", name, - (readw(ioaddr + ChipCmd) & CmdReset) ? "failed" : "succeeded"); + boguscnt ? "succeeded" : "failed"); } #ifdef USE_MEM @@ -1226,6 +1254,7 @@ { struct netdev_private *np = dev->priv; unsigned entry; + u32 intr_status; /* Caution: the write order is important here, set the field with the "ownership" bits last. */ @@ -1275,8 +1304,15 @@ /* Non-x86 Todo: explicitly flush cache lines here. */ - /* Wake the potentially-idle transmit channel. */ - writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd); + /* + * Wake the potentially-idle transmit channel unless errors are + * pending (the ISR must sort them out first). + */ + intr_status = get_intr_status(dev); + if ((intr_status & IntrTxErrSummary) == 0) { + writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd); + } + IOSYNC; if (np->cur_tx == np->dirty_tx + TX_QUEUE_LEN) netif_stop_queue(dev); @@ -1303,38 +1339,51 @@ ioaddr = dev->base_addr; - while ((intr_status = readw(ioaddr + IntrStatus))) { + while ((intr_status = get_intr_status(dev))) { /* Acknowledge all of the current interrupt sources ASAP. */ + if (intr_status & IntrTxDescRace) + writeb(0x08, ioaddr + IntrStatus2); writew(intr_status & 0xffff, ioaddr + IntrStatus); + IOSYNC; if (debug > 4) - printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n", + printk(KERN_DEBUG "%s: Interrupt, status %8.8x.\n", dev->name, intr_status); if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped | IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf)) via_rhine_rx(dev); - if (intr_status & (IntrTxDone | IntrTxError | IntrTxUnderrun | - IntrTxAborted)) + if (intr_status & (IntrTxErrSummary | IntrTxDone)) { + if (intr_status & IntrTxErrSummary) { + int cnt = 20; + /* Avoid scavenging before Tx engine turned off */ + while ((readw(ioaddr+ChipCmd) & CmdTxOn) && --cnt) + udelay(5); + if (debug > 2 && !cnt) + printk(KERN_WARNING "%s: via_rhine_interrupt() " + "Tx engine still on.\n", + dev->name); + } via_rhine_tx(dev); + } /* Abnormal error summary/uncommon events handlers. */ if (intr_status & (IntrPCIErr | IntrLinkChange | IntrStatsMax | IntrTxError | IntrTxAborted | - IntrTxUnderrun)) + IntrTxUnderrun | IntrTxDescRace)) via_rhine_error(dev, intr_status); if (--boguscnt < 0) { printk(KERN_WARNING "%s: Too much work at interrupt, " - "status=0x%4.4x.\n", + "status=%#8.8x.\n", dev->name, intr_status); break; } } if (debug > 3) - printk(KERN_DEBUG "%s: exiting interrupt, status=%4.4x.\n", + printk(KERN_DEBUG "%s: exiting interrupt, status=%8.8x.\n", dev->name, readw(ioaddr + IntrStatus)); } @@ -1512,7 +1561,8 @@ } /* Pre-emptively restart Rx engine. */ - writew(CmdRxDemand | np->chip_cmd, dev->base_addr + ChipCmd); + writew(readw(dev->base_addr + ChipCmd) | CmdRxOn | CmdRxDemand, + dev->base_addr + ChipCmd); } /* Clears the "tally counters" for CRC errors and missed frames(?). @@ -1526,15 +1576,35 @@ readw(ioaddr + RxMissed); } -static inline void via_rhine_restart_tx(struct net_device *dev) { +static void via_rhine_restart_tx(struct net_device *dev) { struct netdev_private *np = dev->priv; + long ioaddr = dev->base_addr; int entry = np->dirty_tx % TX_RING_SIZE; + u32 intr_status; - /* We know better than the chip where it should continue */ - writel(np->tx_ring_dma + entry * sizeof(struct tx_desc), - dev->base_addr + TxRingPtr); + /* + * If new errors occured, we need to sort them out before doing Tx. + * In that case the ISR will be back here RSN anyway. + */ + intr_status = get_intr_status(dev); + + if ((intr_status & IntrTxErrSummary) == 0) { + + /* We know better than the chip where it should continue. */ + writel(np->tx_ring_dma + entry * sizeof(struct tx_desc), + ioaddr + TxRingPtr); + + writew(CmdTxDemand | np->chip_cmd, ioaddr + ChipCmd); + IOSYNC; + } + else { + /* This should never happen */ + if (debug > 1) + printk(KERN_WARNING "%s: via_rhine_restart_tx() " + "Another error occured %8.8x.\n", + dev->name, intr_status); + } - writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd); } static void via_rhine_error(struct net_device *dev, int intr_status) @@ -1564,9 +1634,8 @@ } if (intr_status & IntrTxAborted) { if (debug > 1) - printk(KERN_INFO "%s: Abort %4.4x, frame dropped.\n", + printk(KERN_INFO "%s: Abort %8.8x, frame dropped.\n", dev->name, intr_status); - via_rhine_restart_tx(dev); } if (intr_status & IntrTxUnderrun) { if (np->tx_thresh < 0xE0) @@ -1575,15 +1644,21 @@ printk(KERN_INFO "%s: Transmitter underrun, Tx " "threshold now %2.2x.\n", dev->name, np->tx_thresh); - via_rhine_restart_tx(dev); } + if (intr_status & IntrTxDescRace) { + if (debug > 2) + printk(KERN_INFO "%s: Tx descriptor write-back race.\n", + dev->name); + } + if (intr_status & ( IntrTxAborted | IntrTxUnderrun | IntrTxDescRace )) + via_rhine_restart_tx(dev); + if (intr_status & ~( IntrLinkChange | IntrStatsMax | IntrTxUnderrun | - IntrTxError | IntrTxAborted | IntrNormalSummary)) { + IntrTxError | IntrTxAborted | IntrNormalSummary | + IntrTxDescRace )) { if (debug > 1) - printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n", - dev->name, intr_status); - /* Recovery for other fault sources not known. */ - writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd); + printk(KERN_ERR "%s: Something Wicked happened! %8.8x.\n", + dev->name, intr_status); } spin_unlock (&np->lock); diff -Nru a/drivers/net/wan/comx-hw-munich.c b/drivers/net/wan/comx-hw-munich.c --- a/drivers/net/wan/comx-hw-munich.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/wan/comx-hw-munich.c Tue Mar 4 19:30:05 2003 @@ -1304,7 +1304,7 @@ ch = (struct comx_channel *)dev->priv; hw = (struct slicecom_privdata *)ch->HW_privdata; - /* We dont trust the "Tx available" info from the TIQ, but check */ + /* We don't trust the "Tx available" info from the TIQ, but check */ /* every ring if there is some free room */ if (ch->init_status && netif_running(dev)) diff -Nru a/drivers/net/wan/dlci.c b/drivers/net/wan/dlci.c --- a/drivers/net/wan/dlci.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/wan/dlci.c Tue Mar 4 19:30:09 2003 @@ -14,7 +14,7 @@ * 0.15 Mike Mclagan Packet freeing, bug in kmalloc call * DLCI_RET handling * 0.20 Mike McLagan More conservative on which packets - * are returned for retry and whic are + * are returned for retry and which are * are dropped. If DLCI_RET_DROP is * returned from the FRAD, the packet is * sent back to Linux for re-transmission diff -Nru a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c --- a/drivers/net/wan/dscc4.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/wan/dscc4.c Tue Mar 4 19:30:05 2003 @@ -47,7 +47,7 @@ * Tx direction * When the tx ring is full, the xmit routine issues a call to netdev_stop. * The device is supposed to be enabled again during an ALLS irq (we could - * use HI but as it's easy to loose events, it's fscked). + * use HI but as it's easy to lose events, it's fscked). * * Rx direction * The received frames aren't supposed to span over multiple receiving areas. diff -Nru a/drivers/net/wan/hostess_sv11.c b/drivers/net/wan/hostess_sv11.c --- a/drivers/net/wan/hostess_sv11.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/wan/hostess_sv11.c Tue Mar 4 19:30:11 2003 @@ -55,13 +55,13 @@ static void hostess_input(struct z8530_channel *c, struct sk_buff *skb) { - /* Drop the CRC - its not a good idea to try and negotiate it ;) */ + /* Drop the CRC - it's not a good idea to try and negotiate it ;) */ skb_trim(skb, skb->len-2); skb->protocol=__constant_htons(ETH_P_WAN_PPP); skb->mac.raw=skb->data; skb->dev=c->netdevice; /* - * Send it to the PPP layer. We dont have time to process + * Send it to the PPP layer. We don't have time to process * it right now. */ netif_rx(skb); diff -Nru a/drivers/net/wan/lmc/lmc_main.c b/drivers/net/wan/lmc/lmc_main.c --- a/drivers/net/wan/lmc/lmc_main.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/wan/lmc/lmc_main.c Tue Mar 4 19:30:05 2003 @@ -1024,7 +1024,7 @@ } -/* This is the entry point. This is what is called immediatly. */ +/* This is the entry point. This is what is called immediately. */ /* This goes out and finds the card */ int lmc_probe_fake(struct net_device *dev) /*fold00*/ @@ -2149,7 +2149,7 @@ /* owned by 21140 */ sc->lmc_rxring[i].status = 0x80000000; - /* used to be PKT_BUF_SZ now uses skb since we loose some to head room */ + /* used to be PKT_BUF_SZ now uses skb since we lose some to head room */ sc->lmc_rxring[i].length = skb->end - skb->data; /* use to be tail which is dumb since you're thinking why write diff -Nru a/drivers/net/wan/sbni.c b/drivers/net/wan/sbni.c --- a/drivers/net/wan/sbni.c Tue Mar 4 19:30:07 2003 +++ b/drivers/net/wan/sbni.c Tue Mar 4 19:30:07 2003 @@ -684,7 +684,7 @@ /* * if CRC is right but framelen incorrect then transmitter - * error was occured... drop entire packet + * error was occurred... drop entire packet */ else if( (frame_ok = skip_tail( dev->base_addr, framelen, crc )) != 0 ) diff -Nru a/drivers/net/wan/sdla_chdlc.c b/drivers/net/wan/sdla_chdlc.c --- a/drivers/net/wan/sdla_chdlc.c Tue Mar 4 19:30:08 2003 +++ b/drivers/net/wan/sdla_chdlc.c Tue Mar 4 19:30:08 2003 @@ -3529,7 +3529,7 @@ card->devname); }else{ /* IP addresses are the same and the link is up, - * we dont have to do anything here. Therefore, exit */ + * we don't have to do anything here. Therefore, exit */ return 0; } } diff -Nru a/drivers/net/wan/sdla_fr.c b/drivers/net/wan/sdla_fr.c --- a/drivers/net/wan/sdla_fr.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/wan/sdla_fr.c Tue Mar 4 19:30:14 2003 @@ -107,7 +107,7 @@ * the if clause for it(0,dev->tbusy) * forever. * The code got into this stage due to an -* interrupt occuring within the if clause for +* interrupt occurring within the if clause for * set_bit(0,dev->tbusy). Since an interrupt * disables furhter transmit interrupt and * makes dev->tbusy = 0, this effect was undone @@ -1726,7 +1726,7 @@ /*============================================================================ - * Setup so that a frame can be transmitted on the occurence of a transmit + * Setup so that a frame can be transmitted on the occurrence of a transmit * interrupt. */ static int setup_for_delayed_transmit (netdevice_t* dev, struct sk_buff *skb) @@ -2071,7 +2071,7 @@ ++card->statistics.isr_intr_test; break; - case FR_INTR_DLC: /* Event interrupt occured */ + case FR_INTR_DLC: /* Event interrupt occurred */ mbox->cmd.command = FR_READ_STATUS; mbox->cmd.length = 0; err = sdla_exec(mbox) ? mbox->cmd.result : CMD_TIMEOUT; @@ -2747,7 +2747,7 @@ return 1; } - /* If we get here, its an IPX-data packet so it'll get passed up the + /* If we get here, it's an IPX-data packet so it'll get passed up the * stack. * switch the network numbers */ diff -Nru a/drivers/net/wan/sdla_ppp.c b/drivers/net/wan/sdla_ppp.c --- a/drivers/net/wan/sdla_ppp.c Tue Mar 4 19:30:05 2003 +++ b/drivers/net/wan/sdla_ppp.c Tue Mar 4 19:30:05 2003 @@ -2004,7 +2004,7 @@ (unsigned long)card->u.p.txbuf, *card->u.p.txbuf_next, (unsigned long)card->rxmb, *card->u.p.rxbuf_next); - /* Tell timer interrupt that PPP event occured */ + /* Tell timer interrupt that PPP event occurred */ ppp_priv_area->timer_int_enabled |= TMR_INT_ENABLED_PPP_EVENT; flags->imask |= PPP_INTR_TIMER; @@ -2221,7 +2221,7 @@ return 1; } else { - //If we get here's its an IPX-data packet, so it'll get passed up the stack. + //If we get here it's an IPX-data packet, so it'll get passed up the stack. //switch the network numbers switch_net_numbers(sendpacket, network_number, 1); @@ -3418,7 +3418,7 @@ card->devname); }else{ /* IP addresses are the same and the link is up, - * we dont have to do anything here. Therefore, exit */ + * we don't have to do anything here. Therefore, exit */ return 0; } } diff -Nru a/drivers/net/wan/sdla_x25.c b/drivers/net/wan/sdla_x25.c --- a/drivers/net/wan/sdla_x25.c Tue Mar 4 19:30:11 2003 +++ b/drivers/net/wan/sdla_x25.c Tue Mar 4 19:30:11 2003 @@ -1598,7 +1598,7 @@ } /*============================================================================ - * Setup so that a frame can be transmitted on the occurence of a transmit + * Setup so that a frame can be transmitted on the occurrence of a transmit * interrupt. *===========================================================================*/ @@ -3064,7 +3064,7 @@ /* Bug Fix: Mar 14 2000 * The Protocol violation error conditions were - * not handeled previously */ + * not handled previously */ switch (mb->cmd.pktType & 0x7F){ @@ -3178,7 +3178,7 @@ * when clearing a call because protocol encapsulation is not * supported. * 4. If an incoming call is received while a call request is - * pending (i.e. call collision has occured), the incoming call + * pending (i.e. call collision has occurred), the incoming call * shall be rejected and call request shall be retried. *====================================================================*/ @@ -4088,7 +4088,7 @@ return 1; } else { - /*If we get here its an IPX-data packet, so it'll get passed up the stack. + /*If we get here it's an IPX-data packet, so it'll get passed up the stack. */ /* switch the network numbers */ switch_net_numbers(sendpacket, network_number, 1); diff -Nru a/drivers/net/wan/sdlamain.c b/drivers/net/wan/sdlamain.c --- a/drivers/net/wan/sdlamain.c Tue Mar 4 19:30:12 2003 +++ b/drivers/net/wan/sdlamain.c Tue Mar 4 19:30:12 2003 @@ -38,7 +38,7 @@ * replaced it with 'wandev->enable_tx_int'. * May 29, 1997 Jaspreet Singh Flow Control Problem * added "wandev->tx_int_enabled=1" line in the -* init module. This line intializes the flag for +* init module. This line initializes the flag for * preventing Interrupt disabled with device set to * busy * Jan 15, 1997 Gene Kozin Version 3.1.0 @@ -434,7 +434,7 @@ } /* If the current card has already been configured - * or its a piggyback card, do not try to allocate + * or it's a piggyback card, do not try to allocate * resources. */ if (!card->wandev.piggyback && !card->configured){ diff -Nru a/drivers/net/wan/sealevel.c b/drivers/net/wan/sealevel.c --- a/drivers/net/wan/sealevel.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/wan/sealevel.c Tue Mar 4 19:30:10 2003 @@ -56,13 +56,13 @@ static void sealevel_input(struct z8530_channel *c, struct sk_buff *skb) { - /* Drop the CRC - its not a good idea to try and negotiate it ;) */ + /* Drop the CRC - it's not a good idea to try and negotiate it ;) */ skb_trim(skb, skb->len-2); skb->protocol=htons(ETH_P_WAN_PPP); skb->mac.raw=skb->data; skb->dev=c->netdevice; /* - * Send it to the PPP layer. We dont have time to process + * Send it to the PPP layer. We don't have time to process * it right now. */ netif_rx(skb); diff -Nru a/drivers/net/wan/wanpipe_multppp.c b/drivers/net/wan/wanpipe_multppp.c --- a/drivers/net/wan/wanpipe_multppp.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/wan/wanpipe_multppp.c Tue Mar 4 19:30:14 2003 @@ -2283,7 +2283,7 @@ Intr_test_counter = 0; - /* The critical flag is unset because during intialization (if_open) + /* The critical flag is unset because during initialization (if_open) * we want the interrupts to be enabled so that when the wpc_isr is * called it does not exit due to critical flag set. */ diff -Nru a/drivers/net/wan/z85230.c b/drivers/net/wan/z85230.c --- a/drivers/net/wan/z85230.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/wan/z85230.c Tue Mar 4 19:30:04 2003 @@ -1634,7 +1634,7 @@ write_zsreg(c, R0, RES_Rx_CRC); } else - /* Can't occur as we dont reenable the DMA irq until + /* Can't occur as we don't reenable the DMA irq until after the flip is done */ printk(KERN_WARNING "%s: DMA flip overrun!\n", c->netdevice->name); diff -Nru a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig --- a/drivers/net/wireless/Kconfig Tue Mar 4 19:30:05 2003 +++ b/drivers/net/wireless/Kconfig Tue Mar 4 19:30:05 2003 @@ -6,13 +6,13 @@ depends on NETDEVICES config NET_RADIO - bool "Wireless LAN (non-hamradio)" + bool "Wireless LAN drivers (non-hamradio) & Wireless Extensions" ---help--- Support for wireless LANs and everything having to do with radio, but not with amateur radio or FM broadcasting. Saying Y here also enables the Wireless Extensions (creates - /proc/net/wireless and enables ifconfig access). The Wireless + /proc/net/wireless and enables iwconfig access). The Wireless Extension is a generic API allowing a driver to expose to the user space configuration and statistics specific to common Wireless LANs. The beauty of it is that a single set of tool can support all the @@ -28,6 +28,11 @@ special kernel support are available from . +# Note : the cards are obsolete (can't buy them anymore), but the drivers +# are not, as people are still using them... +comment "Obsolete Wireless cards support (pre-802.11)" + depends on NET_RADIO && (INET || ISA || PCMCIA) + config STRIP tristate "STRIP (Metricom starmode radio IP)" depends on NET_RADIO && INET @@ -68,10 +73,6 @@ On some computers the card ends up in non-valid state after some time. Use a ping-reset script to clear it. -comment "Wireless ISA/PCI cards support" - depends on NET_RADIO && (ISA || PCI || ALL_PPC || PCMCIA) - -# Good old obsolete Wavelan. config WAVELAN tristate "AT&T/Lucent old WaveLAN & DEC RoamAbout DS ISA support" depends on NET_RADIO && ISA @@ -102,7 +103,54 @@ module, say M here and read as well as . -# 802.11b cards +config PCMCIA_WAVELAN + tristate "AT&T/Lucent old WaveLAN Pcmcia wireless support" + depends on NET_RADIO && PCMCIA + help + Say Y here if you intend to attach an AT&T/Lucent Wavelan PCMCIA + (PC-card) wireless Ethernet networking card to your computer. This + driver is for the non-IEEE-802.11 Wavelan cards. + + This driver is also available as a module ( = code which can be + inserted in and removed from the running kernel whenever you want). + The module will be called wavelan_cs. If you want to compile it + as a module, say M here and read . + If unsure, say N. + +config PCMCIA_NETWAVE + tristate "Xircom Netwave AirSurfer Pcmcia wireless support" + depends on NET_RADIO && PCMCIA + help + Say Y here if you intend to attach this type of PCMCIA (PC-card) + wireless Ethernet networking card to your computer. + + This driver is also available as a module ( = code which can be + inserted in and removed from the running kernel whenever you want). + The module will be called netwave_cs. If you want to compile it + as a module, say M here and read . + If unsure, say N. + +comment "Wireless 802.11 Frequency Hopping cards support" + depends on NET_RADIO && PCMCIA + +config PCMCIA_RAYCS + tristate "Aviator/Raytheon 2.4MHz wireless support" + depends on NET_RADIO && PCMCIA + ---help--- + Say Y here if you intend to attach an Aviator/Raytheon PCMCIA + (PC-card) wireless Ethernet networking card to your computer. + Please read the file for + details. + + This driver is also available as a module ( = code which can be + inserted in and removed from the running kernel whenever you want). + The module will be called ray_cs. If you want to compile it as a + module, say M here and read . If + unsure, say N. + +comment "Wireless 802.11b ISA/PCI cards support" + depends on NET_RADIO && (ISA || PCI || ALL_PPC || PCMCIA) + config AIRO tristate "Cisco/Aironet 34X/35X/4500/4800 ISA and PCI cards" depends on NET_RADIO && (ISA || PCI) @@ -175,41 +223,12 @@ this variety. # If Pcmcia is compiled in, offer Pcmcia cards... -comment "Wireless Pcmcia/Cardbus cards support" - depends on NET_RADIO && PCMCIA - -# Obsolete cards -config PCMCIA_NETWAVE - tristate "Xircom Netwave AirSurfer Pcmcia wireless support" - depends on NET_RADIO && PCMCIA - help - Say Y here if you intend to attach this type of PCMCIA (PC-card) - wireless Ethernet networking card to your computer. - - This driver is also available as a module ( = code which can be - inserted in and removed from the running kernel whenever you want). - The module will be called netwave_cs. If you want to compile it - as a module, say M here and read . - If unsure, say N. - -config PCMCIA_WAVELAN - tristate "AT&T/Lucent old Wavelan Pcmcia wireless support" +comment "Wireless 802.11b Pcmcia/Cardbus cards support" depends on NET_RADIO && PCMCIA - help - Say Y here if you intend to attach an AT&T/Lucent Wavelan PCMCIA - (PC-card) wireless Ethernet networking card to your computer. This - driver is for the non-IEEE-802.11 Wavelan cards. - This driver is also available as a module ( = code which can be - inserted in and removed from the running kernel whenever you want). - The module will be called wavelan_cs. If you want to compile it - as a module, say M here and read . - If unsure, say N. - -# 802.11b cards config PCMCIA_HERMES tristate "Hermes PCMCIA card support" - depends on PCMCIA!=n && HERMES + depends on NET_RADIO && PCMCIA && HERMES ---help--- A driver for "Hermes" chipset based PCMCIA wireless adaptors, such as the Lucent WavelanIEEE/Orinoco cards and their OEM (Cabletron/ @@ -248,34 +267,6 @@ Hinds' pcmcia-cs package (see the file for location). You also want to check out the PCMCIA-HOWTO, available from . - -config NET_PCMCIA_RADIO - bool "PCMCIA Wireless LAN" - depends on NET_PCMCIA - help - Say Y here if you would like to use a PCMCIA (PC-card) device to - connect to a wireless local area network. Then say Y to the driver - for your particular card below. - - To use your PC-cards, you will need supporting software from David - Hinds' pcmcia-cs package (see the file - for location). You also want to check out the PCMCIA-HOWTO, - available from . - -config PCMCIA_RAYCS - tristate "Aviator/Raytheon 2.4MHz wireless support" - depends on NET_PCMCIA_RADIO && PCMCIA - ---help--- - Say Y here if you intend to attach an Aviator/Raytheon PCMCIA - (PC-card) wireless Ethernet networking card to your computer. - Please read the file for - details. - - This driver is also available as a module ( = code which can be - inserted in and removed from the running kernel whenever you want). - The module will be called ray_cs. If you want to compile it as a - module, say M here and read . If - unsure, say N. # yes, this works even when no drivers are selected config NET_WIRELESS diff -Nru a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c --- a/drivers/net/wireless/airo.c Tue Mar 4 19:30:04 2003 +++ b/drivers/net/wireless/airo.c Tue Mar 4 19:30:04 2003 @@ -970,7 +970,7 @@ int open; struct net_device *dev; /* Note, we can have MAX_FIDS outstanding. FIDs are 16-bits, so we - use the high bit to mark wether it is in use. */ + use the high bit to mark whether it is in use. */ #define MAX_FIDS 6 int fids[MAX_FIDS]; int registered; @@ -2213,7 +2213,7 @@ /* Enable the interrupts */ OUT4500( ai, EVINTEN, STATUS_INTS ); /* Note there is a race condition between the last two lines that - I dont know how to get rid of right now... */ + I don't know how to get rid of right now... */ } static void disable_interrupts( struct airo_info *ai ) { @@ -5126,7 +5126,7 @@ Resp rsp; /* Note : you may have realised that, as this is a SET operation, - * this is priviledged and therefore a normal user can't + * this is privileged and therefore a normal user can't * perform scanning. * This is not an error, while the device perform scanning, * traffic doesn't flow, so it's a perfect DoS... @@ -5816,7 +5816,7 @@ break; } - /* Seperate R/W functions bracket legality here + /* Separate R/W functions bracket legality here */ if ( com.command <= AIROGMICSTATS ) rc = readrids(dev,&com); diff -Nru a/drivers/net/wireless/arlan-proc.c b/drivers/net/wireless/arlan-proc.c --- a/drivers/net/wireless/arlan-proc.c Tue Mar 4 19:30:09 2003 +++ b/drivers/net/wireless/arlan-proc.c Tue Mar 4 19:30:09 2003 @@ -79,7 +79,7 @@ case 0xFB: return "ERROR BackBone failure "; case 0xFA: - return "ERROR tranceiver not found "; + return "ERROR transceiver not found "; case 0xF9: return "ERROR no more address space "; case 0xF8: diff -Nru a/drivers/net/wireless/arlan.c b/drivers/net/wireless/arlan.c --- a/drivers/net/wireless/arlan.c Tue Mar 4 19:30:10 2003 +++ b/drivers/net/wireless/arlan.c Tue Mar 4 19:30:10 2003 @@ -567,7 +567,7 @@ break; times++; } - /* if long command, we wont repeat trying */ ; + /* if long command, we won't repeat trying */ ; if (priv->card_polling_interval > 1) break; times++; diff -Nru a/drivers/net/wireless/orinoco.c b/drivers/net/wireless/orinoco.c --- a/drivers/net/wireless/orinoco.c Tue Mar 4 19:30:14 2003 +++ b/drivers/net/wireless/orinoco.c Tue Mar 4 19:30:14 2003 @@ -117,7 +117,7 @@ * o Init of priv->tx_rate_ctrl in firmware specific section. * o Prism2/Symbol rate, upto should be 0xF and not 0x15. Doh ! * o Spectrum card always need cor_reset (for every reset) - * o Fix cor_reset to not loose bit 7 in the register + * o Fix cor_reset to not lose bit 7 in the register * o flush_stale_links to remove zombie Pcmcia instances * o Ack previous hermes event before reset * Me (with my little hands) @@ -4166,7 +4166,7 @@ e = create_proc_read_entry("buf", S_IFREG | S_IRUGO, priv->dir_dev, orinoco_proc_get_hermes_buf, priv); if (! e) { - printk(KERN_ERR "Unable to intialize /proc/hermes/%s/buf\n", dev->name); + printk(KERN_ERR "Unable to initialize /proc/hermes/%s/buf\n", dev->name); goto fail; } diff -Nru a/drivers/net/wireless/todo.txt b/drivers/net/wireless/todo.txt --- a/drivers/net/wireless/todo.txt Tue Mar 4 19:30:11 2003 +++ b/drivers/net/wireless/todo.txt Tue Mar 4 19:30:11 2003 @@ -2,28 +2,14 @@ ------------- 1) Bring other kernel Wireless LAN drivers here - Already done : - o hermes.c/orinoco.c -> Wavelan IEEE driver + Airport driver - o airo.c/airo_cs.c -> Ben's Aironet driver - o wavelan.c -> old Wavelan ISA driver - o wavelan_cs.c -> old Wavelan Pcmcia driver - o netwave_cs.c -> Netwave Pcmcia driver - Drivers likely to go : - o ray_cs.c -> Raytheon/Aviator driver (maintainer MIA) - Drivers I have absolutely no control over : - o arlan.c -> old Aironet Arlan 655 (need to ask Elmer) - o aironet4500_xxx.c -> Elmer's Aironet driver (need to ask Elmer) - o strip.c -> Metricom's stuff. Not a wlan. Hum... - - ETA : Kernel 2.5.X + Completed 2) Bring new Wireless LAN driver not yet in the kernel there See my web page for details + In particular : HostAP 3) Misc o Mark wavelan, wavelan_cs, netwave_cs drivers as obsolete o Maybe arlan.c, ray_cs.c and strip.c also deserve to be obsolete - o Use new Probe/module stuff in wavelan.c - o New Wireless Extension API (pending) Jean II diff -Nru a/drivers/net/wireless/wavelan_cs.h b/drivers/net/wireless/wavelan_cs.h --- a/drivers/net/wireless/wavelan_cs.h Tue Mar 4 19:30:10 2003 +++ b/drivers/net/wireless/wavelan_cs.h Tue Mar 4 19:30:10 2003 @@ -60,7 +60,7 @@ /* The detection of the wavelan card is made by reading the MAC address * from the card and checking it. If you have a non AT&T product (OEM, * like DEC RoamAbout, or Digital Ocean, Epson, ...), you must modify this - * part to accomodate your hardware... + * part to accommodate your hardware... */ const unsigned char MAC_ADDRESSES[][3] = { diff -Nru a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c --- a/drivers/parisc/ccio-dma.c Tue Mar 4 19:30:05 2003 +++ b/drivers/parisc/ccio-dma.c Tue Mar 4 19:30:05 2003 @@ -924,7 +924,7 @@ ** can't change. And we need the offset from the first ** chunk - not the last one. Ergo Successive chunks ** must start on page boundaries and dove tail - ** with it's predecessor. + ** with its predecessor. */ sg_dma_len(vcontig_sg) = vcontig_len; diff -Nru a/drivers/parisc/dino.c b/drivers/parisc/dino.c --- a/drivers/parisc/dino.c Tue Mar 4 19:30:04 2003 +++ b/drivers/parisc/dino.c Tue Mar 4 19:30:04 2003 @@ -755,7 +755,7 @@ /* ** This enables DINO to generate interrupts when it sees - ** any of it's inputs *change*. Just asserting an IRQ + ** any of its inputs *change*. Just asserting an IRQ ** before it's enabled (ie unmasked) isn't good enough. */ gsc_writel(eim, dino_dev->hba.base_addr+DINO_IAR0); diff -Nru a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c --- a/drivers/parisc/sba_iommu.c Tue Mar 4 19:30:12 2003 +++ b/drivers/parisc/sba_iommu.c Tue Mar 4 19:30:12 2003 @@ -1114,7 +1114,7 @@ /* ** Two address ranges are DMA contiguous *iff* "end of prev" and -** "start of next" are both on a page boundry. +** "start of next" are both on a page boundary. ** ** (shift left is a quick trick to mask off upper bits) */ @@ -1219,7 +1219,7 @@ ** can't change. And we need the offset from the first ** chunk - not the last one. Ergo Successive chunks ** must start on page boundaries and dove tail - ** with it's predecessor. + ** with its predecessor. */ sg_dma_len(vcontig_sg) = vcontig_len; diff -Nru a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c --- a/drivers/parport/parport_pc.c Tue Mar 4 19:30:14 2003 +++ b/drivers/parport/parport_pc.c Tue Mar 4 19:30:14 2003 @@ -35,7 +35,7 @@ * All registers are 8 bits wide and read/write. If your hardware differs * only in register addresses (eg because your registers are on 32-bit * word boundaries) then you can alter the constants in parport_pc.h to - * accomodate this. + * accommodate this. * * Note that the ECP registers may not start at offset 0x400 for PCI cards, * but rather will start at port->base_hi. @@ -422,7 +422,7 @@ status = inb (STATUS (port)); if (status & 0x01) { /* EPP timeout should never occur... */ - printk (KERN_DEBUG "%s: EPP timeout occured while talking to " + printk (KERN_DEBUG "%s: EPP timeout occurred while talking to " "w91284pic (should not have done)\n", port->name); clear_epp_timeout (port); } diff -Nru a/drivers/pci/hotplug.c b/drivers/pci/hotplug.c --- a/drivers/pci/hotplug.c Tue Mar 4 19:30:13 2003 +++ b/drivers/pci/hotplug.c Tue Mar 4 19:30:13 2003 @@ -10,6 +10,7 @@ #define DBG(x...) #endif +static void pci_free_resources(struct pci_dev *dev); #ifdef CONFIG_HOTPLUG int pci_hotplug (struct device *dev, char **envp, int num_envp, @@ -185,7 +186,13 @@ { if (pci_dev_driver(dev)) return -EBUSY; - pci_remove_device(dev); + device_unregister(&dev->dev); + list_del(&dev->bus_list); + list_del(&dev->global_list); + pci_free_resources(dev); +#ifdef CONFIG_PROC_FS + pci_proc_detach_device(dev); +#endif return 0; } EXPORT_SYMBOL(pci_remove_device_safe); @@ -233,15 +240,33 @@ } /** - * pci_remove_device - remove a pci device + * pci_remove_bus_device - remove a PCI device and any children * @dev: the device to remove * - * Delete the device structure from the device lists, - * remove the /proc entry, and notify userspace (/sbin/hotplug). + * Remove a PCI device from the device lists, informing the drivers + * that the device has been removed. We also remove any subordinate + * buses and children in a depth-first manner. + * + * For each device we remove, delete the device structure from the + * device lists, remove the /proc entry, and notify userspace + * (/sbin/hotplug). */ -void -pci_remove_device(struct pci_dev *dev) +void pci_remove_bus_device(struct pci_dev *dev) { + if (dev->subordinate) { + struct pci_bus *b = dev->subordinate; + + pci_remove_behind_bridge(dev); + +#ifdef CONFIG_PROC_FS + pci_proc_detach_bus(b); +#endif + + list_del(&b->node); + kfree(b); + dev->subordinate = NULL; + } + device_unregister(&dev->dev); list_del(&dev->bus_list); list_del(&dev->global_list); @@ -249,9 +274,33 @@ #ifdef CONFIG_PROC_FS pci_proc_detach_device(dev); #endif + + kfree(dev); +} + +/** + * pci_remove_behind_bridge - remove all devices behind a PCI bridge + * @dev: PCI bridge device + * + * Remove all devices on the bus, except for the parent bridge. + * This also removes any child buses, and any devices they may + * contain in a depth-first manner. + */ +void pci_remove_behind_bridge(struct pci_dev *dev) +{ + struct list_head *l, *n; + + if (dev->subordinate) { + list_for_each_safe(l, n, &dev->subordinate->devices) { + struct pci_dev *dev = pci_dev_b(l); + + pci_remove_bus_device(dev); + } + } } #ifdef CONFIG_HOTPLUG EXPORT_SYMBOL(pci_insert_device); -EXPORT_SYMBOL(pci_remove_device); +EXPORT_SYMBOL(pci_remove_bus_device); +EXPORT_SYMBOL(pci_remove_behind_bridge); #endif diff -Nru a/drivers/pci/probe.c b/drivers/pci/probe.c --- a/drivers/pci/probe.c Tue Mar 4 19:30:11 2003 +++ b/drivers/pci/probe.c Tue Mar 4 19:30:11 2003 @@ -609,6 +609,7 @@ } return b; } +EXPORT_SYMBOL(pci_scan_bus_parented); EXPORT_SYMBOL(pci_devices); EXPORT_SYMBOL(pci_root_buses); diff -Nru a/drivers/pcmcia/cardbus.c b/drivers/pcmcia/cardbus.c --- a/drivers/pcmcia/cardbus.c Tue Mar 4 19:30:05 2003 +++ b/drivers/pcmcia/cardbus.c Tue Mar 4 19:30:05 2003 @@ -90,7 +90,7 @@ #define PCDATA_INDICATOR 0x0015 typedef struct cb_config_t { - struct pci_dev dev; + struct pci_dev *dev[8]; } cb_config_t; /*===================================================================== @@ -178,7 +178,7 @@ if (!s->cb_config) goto fail; - dev = &s->cb_config[0].dev; + dev = s->cb_config->dev[0]; /* Config space? */ if (space == 0) { @@ -248,14 +248,25 @@ } s->functions = fn; - c = kmalloc(fn * sizeof(struct cb_config_t), GFP_ATOMIC); + c = kmalloc(sizeof(struct cb_config_t), GFP_ATOMIC); if (!c) return CS_OUT_OF_RESOURCE; - memset(c, 0, fn * sizeof(struct cb_config_t)); + memset(c, 0, sizeof(struct cb_config_t)); + + for (i = 0; i < fn; i++) { + c->dev[i] = kmalloc(sizeof(struct pci_dev), GFP_ATOMIC); + if (!c->dev[i]) { + for (; i--; ) + kfree(c->dev[i]); + kfree(c); + return CS_OUT_OF_RESOURCE; + } + memset(c->dev[i], 0, sizeof(struct pci_dev)); + } irq = s->cap.pci_irq; for (i = 0; i < fn; i++) { - struct pci_dev *dev = &c[i].dev; + struct pci_dev *dev = c->dev[i]; u8 irq_pin; int r; @@ -309,11 +320,8 @@ cb_config_t *c = s->cb_config; if (c) { - int i; - s->cb_config = NULL; - for (i = 0 ; i < s->functions ; i++) - pci_remove_device(&c[i].dev); + pci_remove_behind_bridge(s->cap.cb_dev); kfree(c); printk(KERN_INFO "cs: cb_free(bus %d)\n", s->cap.cb_dev->subordinate->number); @@ -347,7 +355,7 @@ /* Set up PCI interrupt and command registers */ for (i = 0; i < s->functions; i++) { - dev = &s->cb_config[i].dev; + dev = s->cb_config->dev[i]; pci_write_config_byte(dev, PCI_COMMAND, PCI_COMMAND_MASTER | PCI_COMMAND_IO | PCI_COMMAND_MEMORY); pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, @@ -356,7 +364,7 @@ if (s->irq.AssignedIRQ) { for (i = 0; i < s->functions; i++) { - dev = &s->cb_config[i].dev; + dev = s->cb_config->dev[i]; pci_write_config_byte(dev, PCI_INTERRUPT_LINE, s->irq.AssignedIRQ); } diff -Nru a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c --- a/drivers/pcmcia/i82365.c Tue Mar 4 19:30:13 2003 +++ b/drivers/pcmcia/i82365.c Tue Mar 4 19:30:13 2003 @@ -846,7 +846,7 @@ printk("PNP "); - if (pnp_activate_dev(dev, NULL) < 0) { + if (pnp_activate_dev(dev) < 0) { printk("activate failed\n"); pnp_device_detach(dev); break; diff -Nru a/drivers/pcmcia/sa1100.h b/drivers/pcmcia/sa1100.h --- a/drivers/pcmcia/sa1100.h Tue Mar 4 19:30:10 2003 +++ b/drivers/pcmcia/sa1100.h Tue Mar 4 19:30:10 2003 @@ -150,6 +150,7 @@ */ #define SA1100_PCMCIA_POLL_PERIOD (2*HZ) +struct pcmcia_low_level; /* This structure encapsulates per-socket state which we might need to * use when responding to a Card Services query of some kind. @@ -158,6 +159,8 @@ /* * Core PCMCIA state */ + int nr; + struct resource res; socket_state_t cs_state; pccard_io_map io_map[MAX_IO_WIN]; pccard_mem_map pc_mem_map[MAX_WIN]; @@ -173,6 +176,9 @@ * Info from low level handler */ unsigned int irq; + unsigned int irq_state; + + struct pcmcia_low_level *ops; }; @@ -189,61 +195,55 @@ /* * Declaration for all machine specific init/exit functions. */ -extern int pcmcia_adsbitsy_init(void); -extern void pcmcia_adsbitsy_exit(void); - -extern int pcmcia_assabet_init(void); -extern void pcmcia_assabet_exit(void); - -extern int pcmcia_badge4_init(void); -extern void pcmcia_badge4_exit(void); +extern int pcmcia_adsbitsy_init(struct device *); +extern void pcmcia_adsbitsy_exit(struct device *); -extern int pcmcia_cerf_init(void); -extern void pcmcia_cerf_exit(void); +extern int pcmcia_assabet_init(struct device *); +extern void pcmcia_assabet_exit(struct device *); -extern int pcmcia_flexanet_init(void); -extern void pcmcia_flexanet_exit(void); +extern int pcmcia_badge4_init(struct device *); +extern void pcmcia_badge4_exit(struct device *); -extern int pcmcia_freebird_init(void); -extern void pcmcia_freebird_exit(void); +extern int pcmcia_cerf_init(struct device *); +extern void pcmcia_cerf_exit(struct device *); -extern int pcmcia_gcplus_init(void); -extern void pcmcia_gcplus_exit(void); +extern int pcmcia_flexanet_init(struct device *); +extern void pcmcia_flexanet_exit(struct device *); -extern int pcmcia_graphicsmaster_init(void); -extern void pcmcia_graphicsmaster_exit(void); +extern int pcmcia_freebird_init(struct device *); +extern void pcmcia_freebird_exit(struct device *); -extern int pcmcia_jornada720_init(void); -extern void pcmcia_jornada720_exit(void); +extern int pcmcia_gcplus_init(struct device *); +extern void pcmcia_gcplus_exit(struct device *); -extern int pcmcia_neponset_init(void); -extern void pcmcia_neponset_exit(void); +extern int pcmcia_graphicsmaster_init(struct device *); +extern void pcmcia_graphicsmaster_exit(struct device *); -extern int pcmcia_pangolin_init(void); -extern void pcmcia_pangolin_exit(void); +extern int pcmcia_pangolin_init(struct device *); +extern void pcmcia_pangolin_exit(struct device *); -extern int pcmcia_pfs168_init(void); -extern void pcmcia_pfs168_exit(void); +extern int pcmcia_pfs168_init(struct device *); +extern void pcmcia_pfs168_exit(struct device *); -extern int pcmcia_shannon_init(void); -extern void pcmcia_shannon_exit(void); +extern int pcmcia_shannon_init(struct device *); +extern void pcmcia_shannon_exit(struct device *); -extern int pcmcia_simpad_init(void); -extern void pcmcia_simpad_exit(void); +extern int pcmcia_simpad_init(struct device *); +extern void pcmcia_simpad_exit(struct device *); -extern int pcmcia_stork_init(void); -extern void pcmcia_stork_exit(void); +extern int pcmcia_stork_init(struct device *); +extern void pcmcia_stork_exit(struct device *); -extern int pcmcia_system3_init(void); -extern void pcmcia_system3_exit(void); +extern int pcmcia_system3_init(struct device *); +extern void pcmcia_system3_exit(struct device *); -extern int pcmcia_trizeps_init(void); -extern void pcmcia_trizeps_exit(void); +extern int pcmcia_trizeps_init(struct device *); +extern void pcmcia_trizeps_exit(struct device *); -extern int pcmcia_xp860_init(void); -extern void pcmcia_xp860_exit(void); +extern int pcmcia_xp860_init(struct device *); +extern void pcmcia_xp860_exit(struct device *); -extern int pcmcia_yopy_init(void); -extern void pcmcia_yopy_exit(void); +extern int pcmcia_yopy_init(struct device *); +extern void pcmcia_yopy_exit(struct device *); #endif /* !defined(_PCMCIA_SA1100_H) */ diff -Nru a/drivers/pcmcia/sa1100_adsbitsy.c b/drivers/pcmcia/sa1100_adsbitsy.c --- a/drivers/pcmcia/sa1100_adsbitsy.c Tue Mar 4 19:30:14 2003 +++ b/drivers/pcmcia/sa1100_adsbitsy.c Tue Mar 4 19:30:14 2003 @@ -9,8 +9,10 @@ * 7/5/01 Woojung Huh * */ +#include #include #include +#include #include #include @@ -34,12 +36,12 @@ } static int -adsbitsy_pcmcia_configure_socket(const struct pcmcia_configure *conf) +adsbitsy_pcmcia_configure_socket(int sock, const struct pcmcia_configure *conf) { unsigned int pa_dwr_mask, pa_dwr_set; int ret; - switch (conf->sock) { + switch (sock) { case 0: pa_dwr_mask = GPIO_GPIO0 | GPIO_GPIO1; @@ -71,7 +73,7 @@ return -1; } - ret = sa1111_pcmcia_configure_socket(conf); + ret = sa1111_pcmcia_configure_socket(sock, conf); if (ret == 0) { unsigned long flags; @@ -84,25 +86,25 @@ } static struct pcmcia_low_level adsbitsy_pcmcia_ops = { + .owner = THIS_MODULE, .init = adsbitsy_pcmcia_init, .shutdown = sa1111_pcmcia_shutdown, .socket_state = sa1111_pcmcia_socket_state, - .get_irq_info = sa1111_pcmcia_get_irq_info, .configure_socket = adsbitsy_pcmcia_configure_socket, .socket_init = sa1111_pcmcia_socket_init, .socket_suspend = sa1111_pcmcia_socket_suspend, }; -int __init pcmcia_adsbitsy_init(void) +int __init pcmcia_adsbitsy_init(struct device *dev) { int ret = -ENODEV; if (machine_is_adsbitsy()) - ret = sa1100_register_pcmcia(&adsbitsy_pcmcia_ops); + ret = sa1100_register_pcmcia(&adsbitsy_pcmcia_ops, dev); return ret; } -void __exit pcmcia_adsbitsy_exit(void) +void __exit pcmcia_adsbitsy_exit(struct device *dev) { - sa1100_unregister_pcmcia(&adsbitsy_pcmcia_ops); + sa1100_unregister_pcmcia(&adsbitsy_pcmcia_ops, dev); } diff -Nru a/drivers/pcmcia/sa1100_assabet.c b/drivers/pcmcia/sa1100_assabet.c --- a/drivers/pcmcia/sa1100_assabet.c Tue Mar 4 19:30:12 2003 +++ b/drivers/pcmcia/sa1100_assabet.c Tue Mar 4 19:30:12 2003 @@ -5,9 +5,11 @@ * */ #include +#include #include #include #include +#include #include #include @@ -31,18 +33,18 @@ { int i, res; - /* Set transition detect */ - set_irq_type(ASSABET_IRQ_GPIO_CF_IRQ, IRQT_FALLING); - /* Register interrupts */ for (i = 0; i < ARRAY_SIZE(irqs); i++) { - set_irq_type(irqs[i].irq, IRQT_NOEDGE); - res = request_irq(irqs[i].irq, init->handler, SA_INTERRUPT, - irqs[i].str, NULL); + res = request_irq(irqs[i].irq, sa1100_pcmcia_interrupt, + SA_INTERRUPT, irqs[i].str, NULL); if (res) goto irq_err; + set_irq_type(irqs[i].irq, IRQT_NOEDGE); } + init->socket_irq[0] = NO_IRQ; + init->socket_irq[1] = ASSABET_IRQ_GPIO_CF_IRQ; + /* There's only one slot, but it's "Slot 1": */ return 2; @@ -69,47 +71,31 @@ return 0; } -static int -assabet_pcmcia_socket_state(struct pcmcia_state_array *state_array) +static void +assabet_pcmcia_socket_state(int sock, struct pcmcia_state *state) { - unsigned long levels; + unsigned long levels = GPLR; - if (state_array->size < 2) - return -1; - - levels = GPLR; - - state_array->state[1].detect = (levels & ASSABET_GPIO_CF_CD) ? 0 : 1; - state_array->state[1].ready = (levels & ASSABET_GPIO_CF_IRQ) ? 1 : 0; - state_array->state[1].bvd1 = (levels & ASSABET_GPIO_CF_BVD1) ? 1 : 0; - state_array->state[1].bvd2 = (levels & ASSABET_GPIO_CF_BVD2) ? 1 : 0; - state_array->state[1].wrprot = 0; /* Not available on Assabet. */ - state_array->state[1].vs_3v = 1; /* Can only apply 3.3V on Assabet. */ - state_array->state[1].vs_Xv = 0; - - return 1; -} - -static int assabet_pcmcia_get_irq_info(struct pcmcia_irq_info *info) -{ - if (info->sock > 1) - return -1; - - if (info->sock == 1) - info->irq = ASSABET_IRQ_GPIO_CF_IRQ; - - return 0; + if (sock == 1) { + state->detect = (levels & ASSABET_GPIO_CF_CD) ? 0 : 1; + state->ready = (levels & ASSABET_GPIO_CF_IRQ) ? 1 : 0; + state->bvd1 = (levels & ASSABET_GPIO_CF_BVD1) ? 1 : 0; + state->bvd2 = (levels & ASSABET_GPIO_CF_BVD2) ? 1 : 0; + state->wrprot = 0; /* Not available on Assabet. */ + state->vs_3v = 1; /* Can only apply 3.3V on Assabet. */ + state->vs_Xv = 0; + } } static int -assabet_pcmcia_configure_socket(const struct pcmcia_configure *configure) +assabet_pcmcia_configure_socket(int sock, const struct pcmcia_configure *configure) { unsigned int mask; - if (configure->sock > 1) + if (sock > 1) return -1; - if (configure->sock == 0) + if (sock == 0) return 0; switch (configure->vcc) { @@ -138,15 +124,6 @@ ASSABET_BCR_frob(ASSABET_BCR_CF_RST | ASSABET_BCR_CF_PWR, mask); - /* - * Handle suspend mode properly. This prevents a - * flood of IRQs from the CF device. - */ - if (configure->irq) - enable_irq(ASSABET_IRQ_GPIO_CF_IRQ); - else - disable_irq(ASSABET_IRQ_GPIO_CF_IRQ); - return 0; } @@ -194,23 +171,23 @@ } static struct pcmcia_low_level assabet_pcmcia_ops = { + .owner = THIS_MODULE, .init = assabet_pcmcia_init, .shutdown = assabet_pcmcia_shutdown, .socket_state = assabet_pcmcia_socket_state, - .get_irq_info = assabet_pcmcia_get_irq_info, .configure_socket = assabet_pcmcia_configure_socket, .socket_init = assabet_pcmcia_socket_init, .socket_suspend = assabet_pcmcia_socket_suspend, }; -int __init pcmcia_assabet_init(void) +int __init pcmcia_assabet_init(struct device *dev) { int ret = -ENODEV; if (machine_is_assabet()) { if (!machine_has_neponset()) - ret = sa1100_register_pcmcia(&assabet_pcmcia_ops); + ret = sa1100_register_pcmcia(&assabet_pcmcia_ops, dev); #ifndef CONFIG_ASSABET_NEPONSET else printk(KERN_ERR "Card Services disabled: missing " @@ -220,8 +197,8 @@ return ret; } -void __exit pcmcia_assabet_exit(void) +void __exit pcmcia_assabet_exit(struct device *dev) { - sa1100_unregister_pcmcia(&assabet_pcmcia_ops); + sa1100_unregister_pcmcia(&assabet_pcmcia_ops, dev); } diff -Nru a/drivers/pcmcia/sa1100_badge4.c b/drivers/pcmcia/sa1100_badge4.c --- a/drivers/pcmcia/sa1100_badge4.c Tue Mar 4 19:30:05 2003 +++ b/drivers/pcmcia/sa1100_badge4.c Tue Mar 4 19:30:05 2003 @@ -12,6 +12,7 @@ * published by the Free Software Foundation. * */ +#include #include #include #include @@ -96,11 +97,11 @@ } static int -badge4_pcmcia_configure_socket(const struct pcmcia_configure *conf) +badge4_pcmcia_configure_socket(int sock, const struct pcmcia_configure *conf) { int ret; - switch (conf->sock) { + switch (sock) { case 0: if ((conf->vcc != 0) && (conf->vcc != badge4_pcmvcc)) { @@ -130,7 +131,7 @@ return -1; } - ret = sa1111_pcmcia_configure_socket(conf); + ret = sa1111_pcmcia_configure_socket(sock, conf); if (ret == 0) { unsigned long flags; int need5V; @@ -148,29 +149,29 @@ } static struct pcmcia_low_level badge4_pcmcia_ops = { + .owner = THIS_MODULE, .init = badge4_pcmcia_init, .shutdown = badge4_pcmcia_shutdown, .socket_state = sa1111_pcmcia_socket_state, - .get_irq_info = sa1111_pcmcia_get_irq_info, .configure_socket = badge4_pcmcia_configure_socket, .socket_init = sa1111_pcmcia_socket_init, .socket_suspend = sa1111_pcmcia_socket_suspend, }; -int pcmcia_badge4_init(void) +int pcmcia_badge4_init(struct device *dev) { int ret = -ENODEV; if (machine_is_badge4()) - ret = sa1100_register_pcmcia(&badge4_pcmcia_ops); + ret = sa1100_register_pcmcia(&badge4_pcmcia_ops, dev); return ret; } -void __devexit pcmcia_badge4_exit(void) +void __devexit pcmcia_badge4_exit(struct device *dev) { - sa1100_unregister_pcmcia(&badge4_pcmcia_ops); + sa1100_unregister_pcmcia(&badge4_pcmcia_ops, dev); } static int __init pcmv_setup(char *s) diff -Nru a/drivers/pcmcia/sa1100_cerf.c b/drivers/pcmcia/sa1100_cerf.c --- a/drivers/pcmcia/sa1100_cerf.c Tue Mar 4 19:30:13 2003 +++ b/drivers/pcmcia/sa1100_cerf.c Tue Mar 4 19:30:13 2003 @@ -6,8 +6,10 @@ * */ #include +#include #include #include +#include #include #include @@ -34,16 +36,16 @@ { int i, res; - set_irq_type(IRQ_GPIO_CF_IRQ, IRQT_FALLING); - for (i = 0; i < ARRAY_SIZE(irqs); i++) { - set_irq_type(irqs[i].irq, IRQT_NOEDGE); - res = request_irq(irqs[i].irq, init->handler, SA_INTERRUPT, + res = request_irq(irqs[i].irq, sa1100_pcmcia_interrupt, SA_INTERRUPT, irqs[i].str, NULL); if (res) goto irq_err; + set_irq_type(irqs[i].irq, IRQT_NOEDGE); } + init->socket_irq[CERF_SOCKET] = IRQ_GPIO_CF_IRQ; + return 2; irq_err: @@ -66,43 +68,28 @@ return 0; } -static int cerf_pcmcia_socket_state(struct pcmcia_state_array - *state_array){ - unsigned long levels; - int i = CERF_SOCKET; - - if(state_array->size<2) return -1; - - levels=GPLR; - - state_array->state[i].detect=((levels & GPIO_CF_CD)==0)?1:0; - state_array->state[i].ready=(levels & GPIO_CF_IRQ)?1:0; - state_array->state[i].bvd1=(levels & GPIO_CF_BVD1)?1:0; - state_array->state[i].bvd2=(levels & GPIO_CF_BVD2)?1:0; - state_array->state[i].wrprot=0; - state_array->state[i].vs_3v=1; - state_array->state[i].vs_Xv=0; - - return 1; -} - -static int cerf_pcmcia_get_irq_info(struct pcmcia_irq_info *info){ - - if(info->sock>1) return -1; - - if (info->sock == CERF_SOCKET) - info->irq=IRQ_GPIO_CF_IRQ; +static void cerf_pcmcia_socket_state(int sock, struct pcmcia_state *state) +{ + unsigned long levels=GPLR; - return 0; + if (sock == CERF_SOCKET) { + state->detect=((levels & GPIO_CF_CD)==0)?1:0; + state->ready=(levels & GPIO_CF_IRQ)?1:0; + state->bvd1=(levels & GPIO_CF_BVD1)?1:0; + state->bvd2=(levels & GPIO_CF_BVD2)?1:0; + state->wrprot=0; + state->vs_3v=1; + state->vs_Xv=0; + } } -static int cerf_pcmcia_configure_socket(const struct pcmcia_configure +static int cerf_pcmcia_configure_socket(int sock, const struct pcmcia_configure *configure) { - if(configure->sock>1) + if (sock>1) return -1; - if (configure->sock != CERF_SOCKET) + if (sock != CERF_SOCKET) return 0; switch(configure->vcc){ @@ -161,27 +148,27 @@ } static struct pcmcia_low_level cerf_pcmcia_ops = { + .owner = THIS_MODULE, .init = cerf_pcmcia_init, .shutdown = cerf_pcmcia_shutdown, .socket_state = cerf_pcmcia_socket_state, - .get_irq_info = cerf_pcmcia_get_irq_info, .configure_socket = cerf_pcmcia_configure_socket, .socket_init = cerf_pcmcia_socket_init, .socket_suspend = cerf_pcmcia_socket_suspend, }; -int __init pcmcia_cerf_init(void) +int __init pcmcia_cerf_init(struct device *dev) { int ret = -ENODEV; if (machine_is_cerf()) - ret = sa1100_register_pcmcia(&cerf_pcmcia_ops); + ret = sa1100_register_pcmcia(&cerf_pcmcia_ops, dev); return ret; } -void __exit pcmcia_cerf_exit(void) +void __exit pcmcia_cerf_exit(struct device *dev) { - sa1100_unregister_pcmcia(&cerf_pcmcia_ops); + sa1100_unregister_pcmcia(&cerf_pcmcia_ops, dev); } diff -Nru a/drivers/pcmcia/sa1100_flexanet.c b/drivers/pcmcia/sa1100_flexanet.c --- a/drivers/pcmcia/sa1100_flexanet.c Tue Mar 4 19:30:08 2003 +++ b/drivers/pcmcia/sa1100_flexanet.c Tue Mar 4 19:30:08 2003 @@ -5,9 +5,10 @@ * by Jordi Colomer, 09/05/2001 * */ - +#include #include