the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
- Copyright (C) 19yy <name of author>
+ Copyright (C) <year> <name of author>
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
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
- Gnomovision version 69, Copyright (C) 19yy name of author
+ Gnomovision version 69, Copyright (C) year name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
When I got my two cards, one of them had this switch set to "enhanced". That
card didn't work at all, it wasn't even recognized by the driver. The other
card had this switch set to "compatible" and it behaved absolutely normally. I
-guess that the switch on one of the cards, must have been changed accidently
+guess that the switch on one of the cards, must have been changed accidentally
when the card was taken out of its former host. The question remains
unanswered, what is the purpose of the "enhanced" position?
Resources and links
===================
-Current developement on this driver is posted to:
+Current development on this driver is posted to:
- http://www.sourceforge.net/projects/bonding/
Donald Becker's Ethernet Drivers and diag programs may be found at :
callbacks. This currently takes place only during APM state transitions.
Upon going to sleep, the PCI subsystem walks its device tree twice. Both times, it does
-a depth first walk of the device tree. The first walk saves each of the device's state
+a depth first walk of the device tree. The first walk saves each of the device's state
and checks for devices that will prevent the system from entering a global power state.
The next walk then places the devices in a low power state.
-----------------
Usage:
- pci_restore_state(dev,buffer);
+ pci_restore_state(dev, buffer);
Description:
Restore previously saved config space. (First 64 bytes only);
-------------------
Usage:
- pci_set_power_state(dev,state);
+ pci_set_power_state(dev, state);
Description:
Transition device to low power state using PCI PM Capabilities registers.
---------------
Usage:
- pci_enable_wake(dev,state,enable);
+ pci_enable_wake(dev, state, enable);
Description:
Enable device to generate PME# during low power state using PCI PM
struct pci_driver:
int (*save_state) (struct pci_dev *dev, u32 state);
- int (*suspend)(struct pci_dev *dev, u32 state);
+ int (*suspend) (struct pci_dev *dev, u32 state);
int (*resume) (struct pci_dev *dev);
int (*enable_wake) (struct pci_dev *dev, u32 state, int enable);
The driver can also interpret this function as a notification that it may be entering
a sleep state in the near future. If it knows that the device cannot enter the
-requested state, either because of lack of support for it, or because the devices is
+requested state, either because of lack of support for it, or because the device is
middle of some critical operation, then it should fail.
This function should not be used to set any state in the device or the driver because
------------
In previous kernels (2.2.x), some configuration was required to
-get the driver to talk to the card. Being the new millenium and
+get the driver to talk to the card. Being the new millennium and
all, the 2.4.x kernels now support auto-configuration if ISA PnP
support is configured in. Theoretically, the driver even supports
having more than one card in this case.
SoftOSS keeps the samples loaded on the system's RAM so much RAM is
required. SoftOSS should never be used on machines with less than 16 MB
- of RAM since this is potentially dangerous (you may accidently run out
+ of RAM since this is potentially dangerous (you may accidentally run out
of memory which probably crashes the machine).
SoftOSS implements the wave table API originally designed for GUS. For
pci_bus = pci_bus_to_vertex(busnum);
if (!pci_bus) {
/*
- * During probing, the Linux pci code invents non existant
+ * During probing, the Linux pci code invents non-existent
* bus numbers and pci_dev structures and tries to access
- * them to determine existance. Don't crib during probing.
+ * them to determine existence. Don't crib during probing.
*/
if (done_probing)
printk("devfn_to_vertex: Invalid bus number %d given.\n", busnum);
* PCI access and QSpan control register addresses. The selection is
* further selected by a bit setting in a board control register.
* Although it should happen, we disable interrupts during this operation
- * to make sure some driver doesn't accidently access the PCI while
+ * to make sure some driver doesn't accidentally access the PCI while
* we have switched the chip select.
*/
* FUNCTION: Acpi_ex_resolve_node_to_value
*
* PARAMETERS: Object_ptr - Pointer to a location that contains
- * a pointer to a NS node, and will recieve a
+ * a pointer to a NS node, and will receive a
* pointer to the resolved object.
* Walk_state - Current state. Valid only if executing AML
* code. NULL if simply resolving an object
/* Allocate and claim adapter resources */
retval = mgsl_claim_resources(info);
- /* perform existance check and diagnostics */
+ /* perform existence check and diagnostics */
if ( !retval )
retval = mgsl_adapter_test(info);
* drive is ready to accept one, in which case we know the drive is not
* trying to interrupt us. And ide_set_handler() is always invoked before
* completing the issuance of any new drive command, so we will not be
- * accidently invoked as a result of any valid command completion interrupt.
+ * accidentally invoked as a result of any valid command completion interrupt.
*
*/
static void unexpected_intr (int irq, ide_hwgroup_t *hwgroup)
}
/*
- * This is needed untill the driver is capable of reading the
+ * This is needed until the driver is capable of reading the
* onboard I2C SROM to discover the "real" memory size.
*/
if(msize) {
this->ALE = 0x02;
this->NCE = 0x04;
- /* Scan to find existance of the device */
+ /* Scan to find existence of the device */
if (nand_scan (spia_mtd)) {
kfree (spia_mtd);
return -ENXIO;
Ser2HSCR0 = si->hscr0 | HSCR0_HSSP;
/*
- * Enable the DMA, receiver and recieve interrupt.
+ * Enable the DMA, receiver and receive interrupt.
*/
sa1100_dma_flush_all(si->rxdma);
sa1100_dma_queue_buffer(si->rxdma, NULL, si->rxbuf_dma, HPSIR_MAX_RXLEN);
add_timer(&card->u.x.x25_timer);
}
}
- /* Device is not up untill the we are in connected state */
+ /* Device is not up until the we are in connected state */
do_gettimeofday( &tv );
chan->router_start_time = tv.tv_sec;
* send_delayed_cmd_result
*
* Wait commands like PLEACE CALL or CLEAR CALL must wait
- * untill the result arrivers. This function passes
+ * until the result arrives. This function passes
* the result to a waiting sock.
*
*===============================================================*/
}
}
-void __devinit pci_read_bridge_bases(struct pci_bus *child)
+void __devinit pci_read_bridge_bases(struct pci_bus *child)
{
struct pci_dev *dev = child->self;
u8 io_base_lo, io_limit_lo;
}
}
-static struct pci_bus * __devinit pci_alloc_bus(void)
+static struct pci_bus * __devinit pci_alloc_bus(void)
{
struct pci_bus *b;
return max;
}
-int __devinit pci_bus_exists(const struct list_head *list, int nr)
+int __devinit pci_bus_exists(const struct list_head *list, int nr)
{
const struct list_head *l;
return 0;
}
-struct pci_bus * __devinit pci_alloc_primary_bus(int bus)
+struct pci_bus * __devinit pci_alloc_primary_bus(int bus)
{
struct pci_bus *b;
return b;
}
-struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata)
+struct pci_bus * __devinit pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata)
{
struct pci_bus *b = pci_alloc_primary_bus(bus);
if (b) {
return 0;
}
-static int __devinit pci_setup(char *str)
+static int __devinit pci_setup(char *str)
{
while (str) {
char *k = strchr(str, ',');
tape34xx_error_recovery_HWBUG(ti,21);
return;
case 0x3490:
- // Resetting event recieved. Since the driver does not support resetting event recovery
+ // Resetting event received. Since the driver does not support resetting event recovery
// (which has to be handled by the I/O Layer), we'll report and retry our command.
tape34xx_error_recovery_do_retry(ti);
return;
return;
case 0x3490:
// Global status intercept. We have to reissue the command.
- PRINT_WARN("An global status intercept was recieved, which will be recovered.\n");
+ PRINT_WARN("An global status intercept was received, which will be recovered.\n");
tape34xx_error_recovery_do_retry(ti);
return;
}
/* This is required because the device can go & come back */
/* even before we realize it is gone owing to the waits in our kernel threads */
/* & the device will be marked as not owned but its status will be good */
- /* & an attempt to accidently reprobe it may be done. */
+ /* & an attempt to accidentally reprobe it may be done. */
remove:
chandev_remove(chandev_get_by_irq(curr_irqinfo->sch.irq));
/*
* Read the latched byte, but turn off SPIOEN first
- * so that we don't inadvertantly cause a REQ for the
+ * so that we don't inadvertently cause a REQ for the
* next byte.
*/
ahc_outb(ahc, SXFRCTL0, ahc_inb(ahc, SXFRCTL0) & ~SPIOEN);
j->cidcw_wait = 0;
if(!j->flags.cidcw_ack) {
if(ixjdebug & 0x0200) {
- printk("IXJ cidcw phone%d did not recieve ACK from display %ld\n", j->board, jiffies);
+ printk("IXJ cidcw phone%d did not receive ACK from display %ld\n", j->board, jiffies);
}
ixj_post_cid(j);
if(j->cid_play_flag) {
* Invoke the transport and basic error-handling/recovery methods
*
* This is used by the protocol layers to actually send the message to
- * the device and recieve the response.
+ * the device and receive the response.
*/
void isd200_invoke_transport( struct us_data *us,
Scsi_Cmnd *srb,
/* Invoke the transport and basic error-handling/recovery methods
*
* This is used by the protocol layers to actually send the message to
- * the device and recieve the response.
+ * the device and receive the response.
*/
void usb_stor_invoke_transport(Scsi_Cmnd *srb, struct us_data *us)
{
{
struct us_data *us = (struct us_data *)urb->context;
- US_DEBUGP("USB IRQ recieved for device on host %d\n", us->host_no);
+ US_DEBUGP("USB IRQ received for device on host %d\n", us->host_no);
US_DEBUGP("-- IRQ data length is %d\n", urb->actual_length);
US_DEBUGP("-- IRQ state is %d\n", urb->status);
US_DEBUGP("-- Interrupt Status (0x%x, 0x%x)\n",
#include <linux/string.h>
#include "hpfs_fn.h"
-/* Remove external extended attributes. ano specifies wheter a is a
- direct sector where eas start or an anode */
+/* Remove external extended attributes. ano specifies whether a is a
+ direct sector where eas starts or an anode */
void hpfs_ea_ext_remove(struct super_block *s, secno a, int ano, unsigned len)
{
* These functions are normal device driver entry points
* and are called along with the similar entry points from
* other device drivers. They are included here as documentation
- * of their existance and purpose.
+ * of their existence and purpose.
*
* pcibr_init() is called to inform us that there is a pcibr driver
* configured into the kernel; it is responsible for registering
*/
struct journal_head * t_async_datalist;
- /* Doubly-linked circular list of all forget buffers (superceded
+ /* Doubly-linked circular list of all forget buffers (superseded
buffers which we can un-checkpoint once this transaction
commits) */
struct journal_head * t_forget;
#define BJ_SyncData 1 /* Normal data: flush before commit */
#define BJ_AsyncData 2 /* writepage data: wait on it before commit */
#define BJ_Metadata 3 /* Normal journaled metadata */
-#define BJ_Forget 4 /* Buffer superceded by this transaction */
+#define BJ_Forget 4 /* Buffer superseded by this transaction */
#define BJ_IO 5 /* Buffer is for temporary IO use */
#define BJ_Shadow 6 /* Buffer contents being shadowed to the log */
#define BJ_LogCtl 7 /* Buffer contains log descriptors */
int (*probe) (struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
void (*remove) (struct pci_dev *dev); /* Device removed (NULL if not a hot-plug capable driver) */
int (*save_state) (struct pci_dev *dev, u32 state); /* Save Device Context */
- int (*suspend)(struct pci_dev *dev, u32 state); /* Device suspended */
+ int (*suspend) (struct pci_dev *dev, u32 state); /* Device suspended */
int (*resume) (struct pci_dev *dev); /* Device woken up */
int (*enable_wake) (struct pci_dev *dev, u32 state, int enable); /* Enable wake event */
};
* indicate the current state of the hookswitch. The pstn_ring bit
* indicates that the DAA on a LineJACK card has detected ring voltage on
* the PSTN port. The caller_id bit indicates that caller_id data has been
-* recieved and is available. The pstn_wink bit indicates that the DAA on
-* the LineJACK has recieved a wink from the telco switch. The f0, f1, f2
+* received and is available. The pstn_wink bit indicates that the DAA on
+* the LineJACK has received a wink from the telco switch. The f0, f1, f2
* and f3 bits indicate that the filter has been triggered by detecting the
* frequency programmed into that filter.
*
if (bad_signal(sig, info, t))
goto out_nolock;
- /* The null signal is a permissions and process existance probe.
+ /* The null signal is a permissions and process existence probe.
No signal is actually delivered. Same goes for zombies. */
ret = 0;
if (!sig || !t->sig)
/*
Return value is changed to int to prevent illegal usage in future.
- It is still legal to use to check for device existance.
+ It is still legal to use to check for device existence.
User should understand, that the result returned by this function
is meaningless, if it was not issued under rtnl semaphore.
* passes the packet to the driver. Before each send(), a poll
* routine checks the sock resources The maximum value of
* packet sent counter is 1, thus if one packet is queued, the
- * application will block untill that packet is passed to the
+ * application will block until that packet is passed to the
* driver.
*
* RECEIVE:
* return code, the driver knows whether the packet was
* sucessfully queued. If the socket queue is full,
* protocol flow control is used by the driver, if any,
- * to slow down the traffic untill the sock queue is free.
+ * to slow down the traffic until the sock queue is free.
*
* Every time a packet arrives into a socket queue the
* socket wakes up processes which are waiting to receive
/* Check if data buffers are pending for transmission,
- * if so, check wheter user wants to wait untill data
+ * if so, check whether user wants to wait until data
* is transmitted, or clear a call and drop packets */
if (atomic_read(&sk->wmem_alloc) || check_driver_busy(sk)){
/* Check if data buffers are pending for transmission,
- * if so, check wheter user wants to wait untill data
+ * if so, check whether user wants to wait until data
* is transmitted, or reset a call and drop packets */
if (atomic_read(&sk->wmem_alloc) || check_driver_busy(sk)){
projects / linux / commitdiff