#define memzero(s,n) memset ((s),0,(n))
#define puts srm_printk
extern long srm_printk(const char *, ...)
- __attribute__ ((format (printf, 1, 2)));;
+ __attribute__ ((format (printf, 1, 2)));
/*
* gzip delarations
struct mmap_arg_struct a;
if (copy_from_user(&a, arg, sizeof(a)))
- goto out;;
+ goto out;
error = -EINVAL;
if (a.offset & ~PAGE_MASK)
struct mmap_arg_struct a;
if (copy_from_user(&a, arg, sizeof(a)))
- goto out;;
+ goto out;
error = -EINVAL;
if (a.offset & ~PAGE_MASK)
fix_virt_function_pointer((void**)&runtime->set_variable);
fix_virt_function_pointer((void**)&runtime->get_next_high_mono_count);
fix_virt_function_pointer((void**)&runtime->reset_system);
- return EFI_SUCCESS;;
+ return EFI_SUCCESS;
}
void
win_alloc->wa_pages = size;
}
- return new_res->start;;
+ return new_res->start;
}
/*
/* Block off the range used by PROM. */
res->start = prom_base_addr;
- res->end = prom_base_addr + (prom_base_size - 1);;
+ res->end = prom_base_addr + (prom_base_size - 1);
status = request_resource(&pcibr_soft->bs_mem_win_root_resource, res);
if (status)
panic("PCIBR:Unable to request_resource()\n");
printk("%s: Removing probably wrong IRQ %d from %s\n",
__FUNCTION__, irq, irq_tab[irq-64].devname);
- irq_tab[irq-64].handler = mvme16x_defhand;;
+ irq_tab[irq-64].handler = mvme16x_defhand;
irq_tab[irq-64].flags = IRQ_FLG_STD;
irq_tab[irq-64].dev_id = NULL;
irq_tab[irq-64].devname = NULL;
ks.st_atime.tv_sec = (s32) stat->atime.tv_sec;
ks.st_atime.tv_nsec = stat->atime.tv_nsec;
ks.st_mtime.tv_sec = (s32) stat->mtime.tv_sec;
- ks.st_mtime.tv_nsec = stat->mtime.tv_nsec;;
+ ks.st_mtime.tv_nsec = stat->mtime.tv_nsec;
ks.st_ctime.tv_sec = (s32) stat->ctime.tv_sec;
- ks.st_ctime.tv_nsec = stat->ctime.tv_nsec;;
+ ks.st_ctime.tv_nsec = stat->ctime.tv_nsec;
ks.st_blksize = (s32) stat->blksize;
ks.st_blocks = (long long) stat->blocks;
void *
ioremap(phys_addr_t addr, unsigned long size)
{
- phys_addr_t addr64 = fixup_bigphys_addr(addr, size);;
+ phys_addr_t addr64 = fixup_bigphys_addr(addr, size);
return ioremap64(addr64, size);
}
SOLD("calling GETSOCKOPT");
set_fs(KERNEL_DS);
error = sys_socketcall(SYS_GETSOCKOPT, args);
- set_fs(old_fs);;
+ set_fs(old_fs);
if (error) {
failed = TBADOPT;
break;
if (acpi_gbl_FADT->mon_alrm)
mo = CMOS_READ(acpi_gbl_FADT->mon_alrm);
else
- mo = CMOS_READ(RTC_MONTH);;
+ mo = CMOS_READ(RTC_MONTH);
if (acpi_gbl_FADT->century)
yr = CMOS_READ(acpi_gbl_FADT->century) * 100 + CMOS_READ(RTC_YEAR);
else
return;
}
- info_p->log_drives = id_ctlr_buf->nr_drvs;;
+ info_p->log_drives = id_ctlr_buf->nr_drvs;
for(i=0;i<4;i++)
info_p->firm_rev[i] = id_ctlr_buf->firm_rev[i];
info_p->ctlr_sig = id_ctlr_buf->cfg_sig;
for ( ; try!=0;try--)
{
j=inb(CDi_status);
- if (!(j&s_not_data_ready)) break;;
+ if (!(j&s_not_data_ready)) break;
if (!(j&s_not_result_ready)) break;
if (fam0LV_drive) if (j&s_attention) break;
}
if (!handle) {
DRM_MEM_ERROR(DRM_MEM_TOTALAGP,
"Attempt to free NULL AGP handle\n");
- return retval;;
+ return retval;
}
if (DRM(agp_free_memory)(handle)) {
}
wake_up_interruptible(&dev->buf_writers);
- return DRM_MIN(avail, count);;
+ return DRM_MIN(avail, count);
}
static void do_serial_hangup (void *private_data)
{
struct dz_serial *info = (struct dz_serial *) private_data;
- struct tty_struct *tty = info->tty;;
+ struct tty_struct *tty = info->tty;
if (!tty)
return;
/* been postponed for lack of bytes. */
if (literals>0)
{
- register UBYTE *r=p_ziv-literals;;
+ register UBYTE *r=p_ziv-literals;
hash[HASH(r)]=r;
if (literals==2)
{r++; hash[HASH(r)]=r;}
if (bRC) goto exit_smapi_request_error;
if (mwave_3780i_io) {
- usDI = dspio_index;;
+ usDI = dspio_index;
}
if (mwave_3780i_irq) {
usSI = (usSI & 0xff00) | mwave_3780i_irq;
unsigned char int_status;
cir = (struct cir_port *)dev_id;
- int_status = get_int_status(cir);;
+ int_status = get_int_status(cir);
if (int_status & 0x4) {
clear_fifo(cir);
return;
break;
case TIOCL_SETVESABLANK:
set_vesa_blanking(arg);
- break;;
+ break;
case TIOCL_SETKMSGREDIRECT:
if (!capable(CAP_SYS_ADMIN)) {
ret = -EPERM;
static int trm290_ide_dma_end (ide_drive_t *drive)
{
ide_hwif_t *hwif = HWIF(drive);
- u16 status = 0;;
+ u16 status = 0;
drive->waiting_for_dma = 0;
/* purge DMA mappings */
local_irq_save(flags);
gameport_trigger(gameport);
- v = gameport_read(gameport);;
+ v = gameport_read(gameport);
while (t > 0 && i < length) {
t--; u = v;
for(i=0;i<MAX_CIP_TYPES;i++)
{
info_mask_group[i] = 0;
- cip_mask_group [i] = 0;;
+ cip_mask_group [i] = 0;
}
for(i=0;i<MAX_APPL;i++)
{
adapter->isac.priv = adapter;
switch (adapter->type) {
case AVM_FRITZ_PCIV2:
- adapter->isac.read_isac = &fcpci2_read_isac;;
+ adapter->isac.read_isac = &fcpci2_read_isac;
adapter->isac.write_isac = &fcpci2_write_isac;
adapter->isac.read_isac_fifo = &fcpci2_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci2_write_isac_fifo;
adapter->write_ctrl = &fcpci2_write_ctrl;
break;
case AVM_FRITZ_PCI:
- adapter->isac.read_isac = &fcpci_read_isac;;
+ adapter->isac.read_isac = &fcpci_read_isac;
adapter->isac.write_isac = &fcpci_write_isac;
adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
adapter->write_ctrl = &fcpci_write_ctrl;
break;
case AVM_FRITZ_PNP:
- adapter->isac.read_isac = &fcpci_read_isac;;
+ adapter->isac.read_isac = &fcpci_read_isac;
adapter->isac.write_isac = &fcpci_write_isac;
adapter->isac.read_isac_fifo = &fcpci_read_isac_fifo;
adapter->isac.write_isac_fifo = &fcpci_write_isac_fifo;
}
card->para[1] = pnp_port_start(pnp_d, 0);
card->para[2] = pnp_port_start(pnp_d, 1);
- card->para[0] = pnp_irq(pnp_d, 0);;
+ card->para[0] = pnp_irq(pnp_d, 0);
if (!card->para[0] || !card->para[1] || !card->para[2]) {
printk(KERN_ERR "NiccyPnP:some resources are missing %ld/%lx/%lx\n",
card->para[0], card->para[1], card->para[2]);
printk(KERN_WARNING "nj LOCK_ATOMIC s0val %x->%x\n",
cs->hw.njet.last_is0, s0val);
spin_unlock_irqrestore(&cs->lock, flags);
- return IRQ_HANDLED;;
+ return IRQ_HANDLED;
}
cs->hw.njet.irqstat0 = s0val;
if ((cs->hw.njet.irqstat0 & NETJET_IRQM0_READ) !=
fh->jpg_settings.TmpDcm);
fmt->fmt.pix.sizeimage =
zoran_v4l2_calc_bufsize(&fh->
- jpg_settings);;
+ jpg_settings);
fmt->fmt.pix.pixelformat =
V4L2_PIX_FMT_MJPEG;
if (fh->jpg_settings.TmpDcm == 1)
goto out;
/* Update written bytes count */
- written += mtd->oobblock;;
+ written += mtd->oobblock;
/* Increment page address */
page++;
nand_deselect ();
spin_unlock_bh (&this->chip_lock);
- ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;;
+ ret = instr->state == MTD_ERASE_DONE ? 0 : -EIO;
/* Do call back function */
if (!ret && instr->callback)
instr->callback (instr);
char name[48];
#ifdef INDEX_DEBUG
spinlock_t debug_lock
- __attribute__ ((aligned (SMP_CACHE_BYTES)));;
+ __attribute__ ((aligned (SMP_CACHE_BYTES)));
u32 last_tx, last_std_rx, last_mini_rx;
#endif
struct net_device_stats stats;
static const struct hdlcdrv_channel_params dflt_ch_params = {
20, 2, 10, 40, 0
};
- struct hdlcdrv_state *s = dev->priv;;
+ struct hdlcdrv_state *s = dev->priv;
/*
* initialize the hdlcdrv_state struct
rc = -ENOMEM;
goto err_unmap_tx_dma;
}
- mp->rx_dma_intr = macio_irq(mdev, 2);;
+ mp->rx_dma_intr = macio_irq(mdev, 2);
mp->tx_cmds = (volatile struct dbdma_cmd *) DBDMA_ALIGN(mp + 1);
mp->rx_cmds = mp->tx_cmds + NCMDS_TX * N_TX_RING + 1;
to the low-power state.
A miniport driver must always return NDIS_STATUS_SUCCESS
to a query of OID_PNP_QUERY_POWER. */
- *pLen = sizeof(SK_DEVICE_POWER_STATE);;
+ *pLen = sizeof(SK_DEVICE_POWER_STATE);
RetCode = SK_PNMI_ERR_OK;
break;
tp->rxHiRing.ringBase = (u8 *) tp->shared->rxHi;
tp->rxBuffRing.ringBase = (u8 *) tp->shared->rxBuff;
tp->cmdRing.ringBase = (u8 *) tp->shared->cmd;
- tp->respRing.ringBase = (u8 *) tp->shared->resp;;
+ tp->respRing.ringBase = (u8 *) tp->shared->resp;
tp->txLoRing.writeRegister = TYPHOON_REG_TX_LO_READY;
tp->txHiRing.writeRegister = TYPHOON_REG_TX_HI_READY;
priv->retransmissions = 0;
if (priv->Conf->tx_delay_ms)
{
- priv->tx_done_delayed = jiffies + (priv->Conf->tx_delay_ms * HZ) / 1000 + 1;;
+ priv->tx_done_delayed = jiffies + (priv->Conf->tx_delay_ms * HZ) / 1000 + 1;
}
else
{
int channel;
int reg_domain;
int tx_rate;
- int auto_tx_rate;;
+ int auto_tx_rate;
int rts_threshold;
int frag_threshold;
int long_retry, short_retry;
/* Note that for the next two, the count is in 16-bit words, not bytes */
static inline void hermes_read_words(struct hermes *hw, int off, void *buf, unsigned count)
{
- off = off << hw->reg_spacing;;
+ off = off << hw->reg_spacing;
if (hw->io_space) {
insw(hw->iobase + off, buf, count);
cpqhp_rom_start = ioremap(ROM_PHY_ADDR, ROM_PHY_LEN);
if (!cpqhp_rom_start) {
err ("Could not ioremap memory region for ROM\n");
- retval = -EIO;;
+ retval = -EIO;
goto error;
}
smbios_table = detect_SMBIOS_pointer(cpqhp_rom_start, cpqhp_rom_start + ROM_PHY_LEN);
if (!smbios_table) {
err ("Could not find the SMBIOS pointer in memory\n");
- retval = -EIO;;
+ retval = -EIO;
goto error;
}
smbios_start = ioremap(readl(smbios_table + ST_ADDRESS), readw(smbios_table + ST_LENGTH));
if (!smbios_start) {
err ("Could not ioremap memory region taken from SMBIOS values\n");
- retval = -EIO;;
+ retval = -EIO;
goto error;
}
rc = hp_register_read_word(php_ctlr->pci_dev, SLOT_CTRL, temp_word);
if (rc) {
err("%s : hp_register_read_word SLOT_CTRL failed\n", __FUNCTION__);
- return IRQ_NONE;;
+ return IRQ_NONE;
}
temp_word = (temp_word & ~HP_INTR_ENABLE) | 0x00;
rc = hp_register_write_word(php_ctlr->pci_dev, SLOT_CTRL, temp_word);
if (rc) {
err("%s : hp_register_write_word SLOT_CTRL failed\n", __FUNCTION__);
- return IRQ_NONE;;
+ return IRQ_NONE;
}
}
pangolin_pcmcia_socket_state(struct sa1100_pcmcia_socket *skt,
struct pcmcia_state *state)
{
- unsigned long levels = GPLR;;
+ unsigned long levels = GPLR;
state->detect=((levels & GPIO_PCMCIA_CD)==0)?1:0;
state->ready=(levels & GPIO_PCMCIA_IRQ)?1:0;
LOW_WATERMARK_PACK);
/* first_element is the last buffer that we got back from hydra */
if (!switch_state && !last_pci_hit)
- return;;
+ return;
QETH_DBF_CARD3(0, trace, "stchcw", card);
if (atomic_swap(&card->outbound_ringbuffer_lock[queue], QETH_LOCK_FLUSH)
== QETH_LOCK_UNLOCKED) {
card->portname_required =
((!QETH_IDX_NO_PORTNAME_REQUIRED(card->dma_stuff->recbuf)) &&
- (card->type == QETH_CARD_TYPE_OSAE));;
+ (card->type == QETH_CARD_TYPE_OSAE));
/*
* however, as the portname indication of OSA is wrong, we have to
ZFCP_LOG_INFO("error: Exchange of configuration data between "
"the adapter %s and the device driver failed.\n",
zfcp_get_busid_by_adapter(adapter));
- retval = ZFCP_ERP_FAILED;;
+ retval = ZFCP_ERP_FAILED;
}
return retval;
static int aic7770_resume(struct ahc_softc *ahc);
static int aha2840_load_seeprom(struct ahc_softc *ahc);
static ahc_device_setup_t ahc_aic7770_VL_setup;
-static ahc_device_setup_t ahc_aic7770_EISA_setup;;
+static ahc_device_setup_t ahc_aic7770_EISA_setup;
static ahc_device_setup_t ahc_aic7770_setup;
struct aic7770_identity aic7770_ident_table[] =
cpqfcHBAdata->fcChip.InitializeTachyon = CpqTsInitializeTachLite;
cpqfcHBAdata->fcChip.LaserControl = CpqTsLaserControl;
cpqfcHBAdata->fcChip.ProcessIMQEntry = CpqTsProcessIMQEntry;
- cpqfcHBAdata->fcChip.InitializeFrameManager = CpqTsInitializeFrameManager;;
+ cpqfcHBAdata->fcChip.InitializeFrameManager = CpqTsInitializeFrameManager;
cpqfcHBAdata->fcChip.ReadWriteWWN = CpqTsReadWriteWWN;
cpqfcHBAdata->fcChip.ReadWriteNVRAM = CpqTsReadWriteNVRAM;
static int dma_can_transfer(struct NCR_ESP *esp, Scsi_Cmnd * sp)
{
- return sp->SCp.this_residual;;
+ return sp->SCp.this_residual;
}
static void dma_dump_state(struct NCR_ESP *esp)
(adpt_hba*)(host->hostdata[0]) = pHba;
pHba->host = host;
- host->irq = pHba->pDev->irq;;
+ host->irq = pHba->pDev->irq;
/* no IO ports, so don't have to set host->io_port and
* host->n_io_port
*/
/* disable board interrupts, deinit services */
gdth_writeb(0xff, &dp6_ptr->io.irqdel);
- gdth_writeb(0x00, &dp6_ptr->io.irqen);;
+ gdth_writeb(0x00, &dp6_ptr->io.irqen);
gdth_writeb(0x00, &dp6_ptr->u.ic.S_Status);
gdth_writeb(0x00, &dp6_ptr->u.ic.Cmd_Index);
tul_append_done_scb(pCurHcb, pCurScb);
}
for (i = 0; i < pCurHcb->HCS_MaxTar; i++) {
- pCurHcb->HCS_Tcs[i].TCS_Flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);;
+ pCurHcb->HCS_Tcs[i].TCS_Flags &= ~(TCF_SYNC_DONE | TCF_WDTR_DONE);
}
return (-1);
}
return 0; /* return 0 to signal end-of-file */
}
if (off > 0x40000) /* ALWAYS stop after 256k bytes have been read */
- stop = 1;;
+ stop = 1;
if (hd->proc & PR_STOP) /* stop every other time */
stop = 1;
return strlen(bp);
outb_p (0xFF, padapter->tag); // clear the op interrupt
outb_p (CMD_DONE, padapter->cmd); // complete the op
- goto irq_return;; // done, but, with what?
+ goto irq_return; // done, but, with what?
unmapProceed:;
if ( !bus )
(pdev->DiskMirror[0].pairIdentifier == (pdev->DiskMirror[1].pairIdentifier ^ 1)) )
{
if ( (pdev->DiskMirror[0].status & UCBF_MATCHED) && (pdev->DiskMirror[1].status & UCBF_MATCHED) )
- break;;
+ break;
if ( pdev->DiskMirror[0].status & UCBF_SURVIVOR ) // is first drive survivor?
testsize = SetReconstruct (pdev, 0);
if ( ++Installed < MAXADAPTER )
continue;
- break;;
+ break;
unregister:;
scsi_unregister (pshost);
}
if ( ++Installed < MAXADAPTER )
continue;
- break;;
+ break;
unregister1:;
scsi_unregister (pshost);
}
release_region(qbase, 0x10);
}
if (qbase == 0x430)
- return NULL;;
+ return NULL;
} else
printk(KERN_INFO "Ql: Using preset base address of %03x\n", qbase);
LEAVE("isp2x00_reset");
- return return_status;;
+ return return_status;
}
LEAVE("isp1020_reset");
- return return_status;;
+ return return_status;
}
#endif
psrb = psrb2;
}
- pdcb->GoingSRBCnt = 0;;
+ pdcb->GoingSRBCnt = 0;
pdcb->pGoingSRB = NULL;
pdcb->TagMask = 0;
pdcb = pdcb->pNextDCB;
return 0;
}
if (off > 0x40000) /* ALWAYS stop after 256k bytes have been read */
- stop = 1;;
+ stop = 1;
if (hd->proc & PR_STOP) /* stop every other time */
stop = 1;
return strlen(bp);
se401->scratch_overflow=0;
se401->scratch_next++;
if (se401->scratch_next>=SE401_NUMSCRATCH)
- se401->scratch_next=0;;
+ se401->scratch_next=0;
break;
}
}
stv680->scratch_overflow = 0;
stv680->scratch_next++;
if (stv680->scratch_next >= STV680_NUMSCRATCH)
- stv680->scratch_next = 0;;
+ stv680->scratch_next = 0;
break;
} /* switch */
} else {
static int empeg_open (struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
- int result = 0;;
+ int result = 0;
if (port_paranoia_check (port, __FUNCTION__))
return -ENODEV;
/* only do something if we have a bulk out endpoint */
if (!serial->num_bulk_out)
- return(0);;
+ return(0);
/* another write is still pending? */
if (port->write_urb->status == -EINPROGRESS) {
#ifdef CONFIG_PPC_OF
/* iBook2's */
if (machine_is_compatible("PowerBook4,3")) {
- rinfo->panel_info.ref_divider = rinfo->pll.ref_div;;
+ rinfo->panel_info.ref_divider = rinfo->pll.ref_div;
rinfo->panel_info.post_divider = 0x6;
rinfo->panel_info.fbk_divider = 0xad;
rinfo->panel_info.use_bios_dividers = 1;
}
/* Aluminium PowerBook 17" */
if (machine_is_compatible("PowerBook5,3")) {
- rinfo->panel_info.ref_divider = rinfo->pll.ref_div;;
+ rinfo->panel_info.ref_divider = rinfo->pll.ref_div;
rinfo->panel_info.post_divider = 0x4;
rinfo->panel_info.fbk_divider = 0x80;
rinfo->panel_info.use_bios_dividers = 1;
}
/* iBook G4 */
if (machine_is_compatible("PowerBook6,3")) {
- rinfo->panel_info.ref_divider = rinfo->pll.ref_div;;
+ rinfo->panel_info.ref_divider = rinfo->pll.ref_div;
rinfo->panel_info.post_divider = 0x6;
rinfo->panel_info.fbk_divider = 0xad;
rinfo->panel_info.use_bios_dividers = 1;
*/
static u32 fb_get_hblank_by_dclk(u32 dclk, u32 xres)
{
- u32 duty_cycle, h_period, hblank;;
+ u32 duty_cycle, h_period, hblank;
dclk /= 1000;
h_period = 100 - C_VAL;
static void i810_load_2d(struct i810fb_par *par)
{
u32 tmp;
- u8 tmp8, *mmio = par->mmio_start_virtual;;
+ u8 tmp8, *mmio = par->mmio_start_virtual;
i810_writel(FW_BLC, mmio, par->watermark);
tmp = i810_readl(PIXCONF, mmio);
#ifdef SIS315H
- unsigned char bridgerev = SiS_GetReg(SiS_Pr->SiS_Part4Port,0x01);;
+ unsigned char bridgerev = SiS_GetReg(SiS_Pr->SiS_Part4Port,0x01);
/* The following is nearly unpreditable and varies from machine
* to machine. Especially the 301DH seems to be a real trouble
if(server->ssocket) {
cFYI(1,("State: 0x%x Flags: 0x%lx", server->ssocket->state,
server->ssocket->flags));
- server->ssocket->ops->shutdown(server->ssocket,SEND_SHUTDOWN);;
+ server->ssocket->ops->shutdown(server->ssocket,SEND_SHUTDOWN);
cFYI(1,("Post shutdown state: 0x%x Flags: 0x%lx", server->ssocket->state,
server->ssocket->flags));
sock_release(server->ssocket);
VFS_STATVFS(vfsp, &stat, NULL, rc);
avail = statp.f_bfree;
- return sbp->sb_fdblocks;;
+ return sbp->sb_fdblocks;
#endif
return 0x0fffffff;
}
fs = get_fs();
set_fs(get_ds());
- flags = MSG_DONTWAIT | MSG_NOSIGNAL;;
+ flags = MSG_DONTWAIT | MSG_NOSIGNAL;
msg.msg_flags = flags;
msg.msg_name = NULL;
msg.msg_namelen = 0;
fsp = copy_fs_struct(current->fs);
if (fsp == NULL) {
module_put(ep->module);
- return -ENOMEM;;
+ return -ENOMEM;
}
task_lock(current);
asmlinkage long
sys_personality(u_long personality)
{
- u_long old = current->personality;;
+ u_long old = current->personality;
if (personality != 0xffffffff) {
set_personality(personality);
int bitmap_equal(const unsigned long *bitmap1,
unsigned long *bitmap2, int bits)
{
- int k, lim = bits/BITS_PER_LONG;;
+ int k, lim = bits/BITS_PER_LONG;
for (k = 0; k < lim; ++k)
if (bitmap1[k] != bitmap2[k])
return 0;
goto err_addr_free;
if (cls != ASN1_UNI || con != ASN1_PRI || tag != ASN1_INT)
- goto err_addr_free;;
+ goto err_addr_free;
if (!asn1_uint_decode(ctx, end, &trap->general))
- goto err_addr_free;;
+ goto err_addr_free;
if (!asn1_header_decode(ctx, &end, &cls, &con, &tag))
goto err_addr_free;
newinet->id = newtp->write_seq ^ jiffies;
tcp_sync_mss(newsk, dst_pmtu(dst));
- newtp->advmss = dst_metric(dst, RTAX_ADVMSS);;
+ newtp->advmss = dst_metric(dst, RTAX_ADVMSS);
tcp_initialize_rcv_mss(newsk);
__tcp_v4_hash(newsk, 0);
self->provider.mac_address[4] =
self->provider.send_arb_val & 0xff;
self->provider.mac_address[5] =
- (self->provider.send_arb_val >> 8) & 0xff;;
+ (self->provider.send_arb_val >> 8) & 0xff;
} else {
/* Just generate something for now */
get_random_bytes(self->provider.mac_address+4, 1);
lsap = (struct lsap_cb *) sap;
- self->max_seg_size = max_seg_size - TTP_HEADER;;
+ self->max_seg_size = max_seg_size - TTP_HEADER;
self->max_header_size = max_header_size+TTP_HEADER;
IRDA_DEBUG(4, "%s(), TSAP sel=%02x\n", __FUNCTION__, self->stsap_sel);
sin6->sin6_port = xp->selector.sport;
sin6->sin6_flowinfo = 0;
memcpy(&sin6->sin6_addr, xp->selector.saddr.a6,
- sizeof(struct in6_addr));;
+ sizeof(struct in6_addr));
sin6->sin6_scope_id = 0;
}
#endif
struct tc_hfsc_qopt *qopt;
if (opt == NULL || RTA_PAYLOAD(opt) < sizeof(*qopt))
- return -EINVAL;;
+ return -EINVAL;
qopt = RTA_DATA(opt);
sch_tree_lock(sch);
if (retval) {
/* Can't finish building the list, clean up. */
sctp_bind_addr_clean(bp);
- break;;
+ break;
}
len = ntohs(param->length);
struct __sctp_missing {
__u32 num_missing;
__u16 type;
-} __attribute__((packed));;
+} __attribute__((packed));
/*
* Report a missing mandatory parameter.
* 3) Peeling off non-partial delivery; move pd_lobby to recieve_queue.
*/
skb_queue_head_init(&newsp->pd_lobby);
- sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode;;
+ sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode;
if (sctp_sk(oldsk)->pd_mode) {
struct sk_buff_head *queue;
len = qword_get(&mesg, buf, mlen);
status = -EINVAL;
if (len < 0)
- goto out;;
+ goto out;
status = -ENOMEM;
if (dup_to_netobj(&rsii.in_token, buf, len))
goto out;
static int selinux_quota_on(struct file *f)
{
- return file_has_perm(current, f, FILE__QUOTAON);;
+ return file_has_perm(current, f, FILE__QUOTAON);
}
static int selinux_syslog(int type)
if (dmabuf->channel == NULL) {
kfree (card->states[0]);
- card->states[0] = NULL;;
+ card->states[0] = NULL;
return -ENODEV;
}
if (dmabuf->channel == NULL) {
kfree (card->states[1]);
- card->states[1] = NULL;;
+ card->states[1] = NULL;
return -ENODEV;
}
if(file->f_mode & FMODE_READ) {
if((dmabuf->read_channel = card->alloc_rec_pcm_channel(card)) == NULL) {
kfree (card->states[i]);
- card->states[i] = NULL;;
+ card->states[i] = NULL;
return -EBUSY;
}
dmabuf->trigger |= PCM_ENABLE_INPUT;
if(file->f_mode & FMODE_READ)
card->free_pcm_channel(card,dmabuf->read_channel->num);
kfree (card->states[i]);
- card->states[i] = NULL;;
+ card->states[i] = NULL;
return -EBUSY;
}
/* Initialize to 8kHz? What if we don't support 8kHz? */
spin_unlock_irqrestore(&s->lock, flags);
- return result & 0xffff;;
+ return result & 0xffff;
}
count = rme96xx_getispace(dma,val);
abinfo.fragsize = (s->fragsize*dma->inchannels)>>dma->formatshift;
- abinfo.bytes = (count*dma->inchannels)>>dma->formatshift;;
+ abinfo.bytes = (count*dma->inchannels)>>dma->formatshift;
abinfo.fragstotal = 2;
abinfo.fragments = count > s->fragsize;
return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
return -EINVAL;
val = rme96xx_gethwptr(dma->s,0);
spin_lock_irqsave(&s->lock,flags);
- cinfo.bytes = s->fragsize<<1;;
+ cinfo.bytes = s->fragsize<<1;
count = val - dma->readptr;
if (count < 0)
count += s->fragsize<<1;
return -EINVAL;
val = rme96xx_gethwptr(dma->s,0);
spin_lock_irqsave(&s->lock,flags);
- cinfo.bytes = s->fragsize<<1;;
+ cinfo.bytes = s->fragsize<<1;
count = val - dma->writeptr;
if (count < 0)
count += s->fragsize<<1;
void sound_stop_timer(void)
{
- del_timer(&seq_timer);;
+ del_timer(&seq_timer);
}
void conf_printf(char *name, struct address_info *hw_config)
def_tmr_close(int dev)
{
opened = tmr_running = 0;
- del_timer(&def_tmr);;
+ del_timer(&def_tmr);
}
static int
case SNDRV_PCM_TRIGGER_STOP:
if (harmony->cap_stopped)
return -EBUSY;
- harmony->cap_stopped = 1;;
+ harmony->cap_stopped = 1;
snd_harmony_disable_interrupts(harmony);
break;
case SNDRV_PCM_TRIGGER_START:
return hwread(vortex->mmio, WT_PARM(wt, 3));
}
if (reg == 7) {
- return hwread(vortex->mmio, WT_GMODE(wt));;
+ return hwread(vortex->mmio, WT_GMODE(wt));
}
return 0;
entry->private_data = chip;
entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry->c.text.read_size = 512;
- entry->c.text.read = cs46xx_dsp_proc_task_tree_read;;
+ entry->c.text.read = cs46xx_dsp_proc_task_tree_read;
if (snd_info_register(entry) < 0) {
snd_info_free_entry(entry);
entry = NULL;
entry->private_data = chip;
entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry->c.text.read_size = 1024;
- entry->c.text.read = cs46xx_dsp_proc_scb_read;;
+ entry->c.text.read = cs46xx_dsp_proc_scb_read;
if (snd_info_register(entry) < 0) {
snd_info_free_entry(entry);
entry = NULL;
projects / history.git / commitdiff