}
        s390_kobj = kobject_create_and_add("s390", hypervisor_kobj);
        if (!s390_kobj) {
-               rc = -ENOMEM;;
+               rc = -ENOMEM;
                goto fail_sysfs;
        }
        rc = register_filesystem(&hypfs_type);
 
        if (!inti)
                return -ENOMEM;
 
-       inti->type = KVM_S390_PROGRAM_INT;;
+       inti->type = KVM_S390_PROGRAM_INT;
        inti->pgm.code = code;
 
        VCPU_EVENT(vcpu, 3, "inject: program check %d (from kernel)", code);
 
                                tid = ((a << IMAP_AID_SHIFT) |
                                       (n << IMAP_NID_SHIFT));
                                tid &= (IMAP_AID_SAFARI |
-                                       IMAP_NID_SAFARI);;
+                                       IMAP_NID_SAFARI);
                        }
                } else {
                        tid = cpuid << IMAP_TID_SHIFT;
 
                     char **error_out)
 {
        char *end;
-       int n, err = -EINVAL;;
+       int n, err = -EINVAL;
 
        n = simple_strtoul(str, &end, 0);
        if (end == str) {
 
        else ErrorCode = get_user(ControllerNumber,
                             &UserSpaceControllerInfo->ControllerNumber);
        if (ErrorCode != 0)
-               break;;
+               break;
        ErrorCode = -ENXIO;
        if (ControllerNumber < 0 ||
            ControllerNumber > DAC960_ControllerCount - 1) {
        }
        Controller = DAC960_Controllers[ControllerNumber];
        if (Controller == NULL)
-               break;;
+               break;
        memset(&ControllerInfo, 0, sizeof(DAC960_ControllerInfo_T));
        ControllerInfo.ControllerNumber = ControllerNumber;
        ControllerInfo.FirmwareType = Controller->FirmwareType;
 
                goto out_release;
        }
        fs->swim3_intr = macio_irq(mdev, 0);
-       fs->dma_intr = macio_irq(mdev, 1);;
+       fs->dma_intr = macio_irq(mdev, 1);
        fs->cur_cyl = -1;
        fs->cur_sector = -1;
        fs->secpercyl = 36;
 
        struct channel *ch = container_of(work, struct channel, tqueue);
        /* Called in response to a modem change event */
        if (ch && ch->magic == EPCA_MAGIC) {
-               struct tty_struct *tty = tty_port_tty_get(&ch->port);;
+               struct tty_struct *tty = tty_port_tty_get(&ch->port);
 
                if (tty && tty->driver_data) {
                        if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
 
        for (try = 0; try < 5; try++) {
                /* Load the send data into the aux channel data registers */
                for (i = 0; i < send_bytes; i += 4) {
-                       uint32_t    d = pack_aux(send + i, send_bytes - i);;
+                       uint32_t    d = pack_aux(send + i, send_bytes - i);
        
                        I915_WRITE(ch_data + i, d);
                }
 
        case 0x443C:
                /* TX_FILTER0_[0-15] */
                i = (reg - 0x4400) >> 2;
-               tmp = ib_chunk->kdata[idx] & 0x7;;
+               tmp = ib_chunk->kdata[idx] & 0x7;
                if (tmp == 2 || tmp == 4 || tmp == 6) {
                        track->textures[i].roundup_w = false;
                }
-               tmp = (ib_chunk->kdata[idx] >> 3) & 0x7;;
+               tmp = (ib_chunk->kdata[idx] >> 3) & 0x7;
                if (tmp == 2 || tmp == 4 || tmp == 6) {
                        track->textures[i].roundup_h = false;
                }
 
 {
        int idx = -ENOENT;
        u8 bootable = (d && (d->host_flags & IDE_HFLAG_NON_BOOTABLE)) ? 0 : 1;
-       u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;;
+       u8 i = (d && (d->host_flags & IDE_HFLAG_QD_2ND_PORT)) ? 1 : 0;
 
        /*
         * Claim an unassigned slot.
 
                goto out;
 
        if (umc8672_probe() == 0)
-               return 0;;
+               return 0;
 out:
-       return -ENODEV;;
+       return -ENODEV;
 }
 
 module_init(umc8672_init);
 
        if (!g_debbuf->buf) {
                kfree(g_cmsg);
                kfree(g_debbuf);
-               return -ENOMEM;;
+               return -ENOMEM;
        }
        g_debbuf->size = CDEBUG_GSIZE;
        g_debbuf->buf[0] = 0;
 
 
                if (cpu > 1)
                        continue;
-               rcpu = &rm->cpu[cpu];;
+               rcpu = &rm->cpu[cpu];
                rcpu->prev_idle = get_cpu_idle_time(cpu);
                rcpu->prev_wall = jiffies64_to_cputime64(get_jiffies_64());
                schedule_delayed_work_on(cpu, &rm->cpu[cpu].sniffer,
 
        BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "rx");
 
        skb->protocol = cpu_to_be16(ETH_P_ARCNET);
-;
        netif_rx(skb);
 }
 
 
        BUGLVL(D_SKB) arcnet_dump_skb(dev, skb, "rx");
 
        skb->protocol = cpu_to_be16(ETH_P_ARCNET);
-;
        netif_rx(skb);
 }
 
 
        rxtime  = get_ictt_value(priv->rxic);
        rxcount = get_icft_value(priv->rxic);
        txtime  = get_ictt_value(priv->txic);
-       txcount = get_icft_value(priv->txic);;
+       txcount = get_icft_value(priv->txic);
        cvals->rx_coalesce_usecs = gfar_ticks2usecs(priv, rxtime);
        cvals->rx_max_coalesced_frames = rxcount;
 
 
        if (emac_read_uint_prop(np, "mdio-device", &dev->mdio_ph, 0))
                dev->mdio_ph = 0;
        if (emac_read_uint_prop(np, "zmii-device", &dev->zmii_ph, 0))
-               dev->zmii_ph = 0;;
+               dev->zmii_ph = 0;
        if (emac_read_uint_prop(np, "zmii-channel", &dev->zmii_port, 0))
-               dev->zmii_port = 0xffffffff;;
+               dev->zmii_port = 0xffffffff;
        if (emac_read_uint_prop(np, "rgmii-device", &dev->rgmii_ph, 0))
-               dev->rgmii_ph = 0;;
+               dev->rgmii_ph = 0;
        if (emac_read_uint_prop(np, "rgmii-channel", &dev->rgmii_port, 0))
-               dev->rgmii_port = 0xffffffff;;
+               dev->rgmii_port = 0xffffffff;
        if (emac_read_uint_prop(np, "fifo-entry-size", &dev->fifo_entry_size, 0))
                dev->fifo_entry_size = 16;
        if (emac_read_uint_prop(np, "mal-burst-size", &dev->mal_burst_size, 0))
 
        /* VFs are limited to using the MTA hash table for their multicast
         * addresses */
        for (i = 0; i < n; i++)
-               vf_data->vf_mc_hashes[i] = hash_list[i];;
+               vf_data->vf_mc_hashes[i] = hash_list[i];
 
        /* Flush and reset the mta with the new values */
        igb_set_rx_mode(adapter->netdev);
 
        dcrs = dcr_resource_start(np, 0);
        if (dcrs == 0) {
                dev_err(&op->dev, "could not get DMA register address\n");
-               goto nodev;;
+               goto nodev;
        }
        lp->sdma_dcrs = dcr_map(np, dcrs, dcr_resource_len(np, 0));
        dev_dbg(&op->dev, "DCR base: %x\n", dcrs);
 
        /* addr_len |!src_insert |pre-len |loopback */
        writeb(0x2e, &cfg_cmd->adr_len);
        writeb(0x00, &cfg_cmd->priority);
-       writeb(0x60, &cfg_cmd->ifs);;
+       writeb(0x60, &cfg_cmd->ifs);
        writeb(0x00, &cfg_cmd->time_low);
        writeb(0xf2, &cfg_cmd->time_high);
-       writeb(0x00, &cfg_cmd->promisc);;
+       writeb(0x00, &cfg_cmd->promisc);
        if (dev->flags & IFF_ALLMULTI) {
                int len = ((char __iomem *)p->iscp - (char __iomem *)ptr - 8) / 6;
                if (num_addrs > len) {
 
            FLAGS_LI;           /* Load irq delay values */
        if (rx_ring->lbq_len) {
                cqicb->flags |= FLAGS_LL;       /* Load lbq values */
-               tmp = (u64)rx_ring->lbq_base_dma;;
+               tmp = (u64)rx_ring->lbq_base_dma;
                base_indirect_ptr = (__le64 *) rx_ring->lbq_base_indirect;
                page_entries = 0;
                do {
        }
        if (rx_ring->sbq_len) {
                cqicb->flags |= FLAGS_LS;       /* Load sbq values */
-               tmp = (u64)rx_ring->sbq_base_dma;;
+               tmp = (u64)rx_ring->sbq_base_dma;
                base_indirect_ptr = (__le64 *) rx_ring->sbq_base_indirect;
                page_entries = 0;
                do {
 
                        /*PC88b*/
                        if (!phy->cf_join) {
                                phy->cf_join = TRUE ;
-                               queue_event(smc,EVENT_CFM,CF_JOIN+np) ; ;
+                               queue_event(smc,EVENT_CFM,CF_JOIN+np) ;
                        }
                        if (cmd == PC_JOIN)
                                GO_STATE(PC8_ACTIVE) ;
 
                                mib_p->fddiPORTLerFlag ;
                        sp->p4050_pad = 0 ;
                        sp->p4050_cutoff =
-                               mib_p->fddiPORTLer_Cutoff ; ;
+                               mib_p->fddiPORTLer_Cutoff ;
                        sp->p4050_alarm =
-                               mib_p->fddiPORTLer_Alarm ; ;
+                               mib_p->fddiPORTLer_Alarm ;
                        sp->p4050_estimate =
                                mib_p->fddiPORTLer_Estimate ;
                        sp->p4050_reject_ct =
                        sp->p4051_porttype =
                                mib_p->fddiPORTMy_Type ;
                        sp->p4051_connectstate =
-                               mib_p->fddiPORTConnectState ; ;
+                               mib_p->fddiPORTConnectState ;
                        sp->p4051_pc_neighbor =
                                mib_p->fddiPORTNeighborType ;
                        sp->p4051_pc_withhold =
                        struct smt_p_4053       *sp ;
                        sp = (struct smt_p_4053 *) to ;
                        sp->p4053_multiple =
-                               mib_p->fddiPORTMultiple_P ; ;
+                               mib_p->fddiPORTMultiple_P ;
                        sp->p4053_availablepaths =
                                mib_p->fddiPORTAvailablePaths ;
                        sp->p4053_currentpath =
 
        if (skge->wol & WAKE_MAGIC)
                ctrl |= WOL_CTL_ENA_PME_ON_MAGIC_PKT|WOL_CTL_ENA_MAGIC_PKT_UNIT;
        else
-               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;;
+               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;
 
        ctrl |= WOL_CTL_DIS_PME_ON_PATTERN|WOL_CTL_DIS_PATTERN_UNIT;
        skge_write16(hw, WOL_REGS(port, WOL_CTRL_STAT), ctrl);
 
        if (sky2->wol & WAKE_MAGIC)
                ctrl |= WOL_CTL_ENA_PME_ON_MAGIC_PKT|WOL_CTL_ENA_MAGIC_PKT_UNIT;
        else
-               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;;
+               ctrl |= WOL_CTL_DIS_PME_ON_MAGIC_PKT|WOL_CTL_DIS_MAGIC_PKT_UNIT;
 
        ctrl |= WOL_CTL_DIS_PME_ON_PATTERN|WOL_CTL_DIS_PATTERN_UNIT;
        sky2_write16(hw, WOL_REGS(port, WOL_CTRL_STAT), ctrl);
 
        rxd_info->l4_cksum_valid =
                (u32)VXGE_HW_RING_RXD_L4_CKSUM_CORRECT_GET(rxdp->control_0);
        rxd_info->l4_cksum =
-               (u32)VXGE_HW_RING_RXD_L4_CKSUM_GET(rxdp->control_0);;
+               (u32)VXGE_HW_RING_RXD_L4_CKSUM_GET(rxdp->control_0);
        rxd_info->frame =
                (u32)VXGE_HW_RING_RXD_ETHER_ENCAP_GET(rxdp->control_0);
        rxd_info->proto =
 
        enum vxge_hw_status status;
        /* 0 - Tx, 1 - Rx  */
        int tim_msix_id[4];
-       int alarm_msix_id = 0, msix_intr_vect = 0;;
+       int alarm_msix_id = 0, msix_intr_vect = 0;
        vdev->intr_cnt = 0;
 
        /* allocate msix vectors */
 
 
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
-       struct rtc_device       *rtc = platform_get_drvdata(pdev);;
+       struct rtc_device       *rtc = platform_get_drvdata(pdev);
 
        device_init_wakeup(&pdev->dev, 0);
 
 
               sizeof(uid->serial) - 1);
        EBCASC(uid->serial, sizeof(uid->serial) - 1);
        uid->ssid = private->gneq->subsystemID;
-       uid->real_unit_addr = private->ned->unit_addr;;
+       uid->real_unit_addr = private->ned->unit_addr;
        if (private->sneq) {
                uid->type = private->sneq->sua_flags;
                if (uid->type == UA_BASE_PAV_ALIAS)
 
        IUCV_DBF_TEXT(trace, 3, __func__);
 
         if (count >= IFNAMSIZ)
-                count = IFNAMSIZ - 1;;
+                count = IFNAMSIZ - 1;
 
        for (i = 0, p = buf; i < count && *p; i++, p++) {
                if (*p == '\n' || *p == ' ')
 
        if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) ||
                     !(status & ZFCP_STATUS_COMMON_RUNNING))) {
                zfcp_scsi_command_fail(scpnt, DID_ERROR);
-               return 0;;
+               return 0;
        }
 
        ret = zfcp_fsf_send_fcp_command_task(unit, scpnt);
 
        resp_hdr->opcode = login->op_code;
        resp_hdr->flags = login->response_flags;
        resp_hdr->max_version = login->version_max;
-       resp_hdr->active_version = login->version_active;;
+       resp_hdr->active_version = login->version_active;
        resp_hdr->hlength = 0;
 
        hton24(resp_hdr->dlength, login->data_length);
 
                vport->ct_flags &= ~FC_CT_RFF_ID;
                CtReq->CommandResponse.bits.CmdRsp =
                    be16_to_cpu(SLI_CTNS_RFF_ID);
-               CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);;
+               CtReq->un.rff.PortId = cpu_to_be32(vport->fc_myDID);
                CtReq->un.rff.fbits = FC4_FEATURE_INIT;
                CtReq->un.rff.type_code = FC_FCP_DATA;
                cmpl = lpfc_cmpl_ct_cmd_rff_id;
 
        unsigned        bits = ust->bits_per_word;
        unsigned        bytes;
        u16             val, w;
-       int             status = 0;;
+       int             status = 0;
 
        if (!t->tx_buf && !t->rx_buf)
                return 0;
 
 
  err_no_iores:
  err_no_pdata:
-       spi_master_put(hw->master);;
+       spi_master_put(hw->master);
 
  err_nomem:
        return err;
 
        desc = usb_get_intfdata(intf);
        if (test_bit(WDM_DISCONNECTING, &desc->flags))
                goto out;
-
-       ;
        file->private_data = desc;
 
        rv = usb_autopm_get_interface(desc->intf);
 
        }
 
        /* Set Baud Rate */
-       baud = tty_get_baud_rate(tty);;
+       baud = tty_get_baud_rate(tty);
        switch (baud) {
        case 300:       buf[0] = 0x00;  break;
        case 600:       buf[0] = 0x01;  break;
 
 
        netif_wake_queue(net_dev);
 #ifdef i1480u_FLOW_CONTROL
-       result = usb_submit_urb(i1480u->notif_urb, GFP_KERNEL);;
+       result = usb_submit_urb(i1480u->notif_urb, GFP_KERNEL);
        if (result < 0) {
                dev_err(dev, "Can't submit notification URB: %d\n", result);
                goto error_notif_urb_submit;
 
                                d0 >>= right;
                        } else if (src_idx+n <= bits) {
                                // Single source word
-                               d0 <<= left;;
+                               d0 <<= left;
                        } else {
                                // 2 source words
                                d1 = FB_READL(src + 1);
 
 
        fbi->clk = clk_get(&pdev->dev, NULL);
        if (IS_ERR(fbi->clk)) {
-               ret = PTR_ERR(fbi->clk);;
+               ret = PTR_ERR(fbi->clk);
                dev_err(&pdev->dev, "unable to get clock: %d\n", ret);
                goto failed_getclock;
        }
 
        int ret = platform_driver_register(&s3c2410fb_driver);
 
        if (ret == 0)
-               ret = platform_driver_register(&s3c2412fb_driver);;
+               ret = platform_driver_register(&s3c2412fb_driver);
 
        return ret;
 }
 
        page = balloon_first_page();
        for (i = 0; i < nr_pages; i++) {
                BUG_ON(page == NULL);
-               frame_list[i] = page_to_pfn(page);;
+               frame_list[i] = page_to_pfn(page);
                page = balloon_next_page(page);
        }
 
 
                        DPRINTK(("autofs: not expirable (not a mounted directory): %s\n", ent->name));
                        continue;
                }
-               while (d_mountpoint(path.dentry) && follow_down(&path));
+               while (d_mountpoint(path.dentry) && follow_down(&path))
                        ;
                umount_ok = may_umount(path.mnt);
                path_put(&path);
 
                                                                extent);
                                cs = btrfs_file_extent_offset(src, extent);
                                cl = btrfs_file_extent_num_bytes(src,
-                                                               extent);;
+                                                               extent);
                                if (btrfs_file_extent_compression(src,
                                                                  extent)) {
                                        cs = 0;
 
        rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
        if (rc != 0) {
                cERROR(1, ("%s: Failed to resolve server part of %s to IP: %d",
-                         __func__, *devname, rc));;
+                         __func__, *devname, rc));
                goto compose_mount_options_err;
        }
        /* md_len = strlen(...) + 12 for 'sep+prefixpath='
 
 
        p = read_buf(xdr, len);
        if (unlikely(p == NULL))
-               return htonl(NFS4ERR_RESOURCE);;
+               return htonl(NFS4ERR_RESOURCE);
 
        memcpy(sid->data, p, len);
        return 0;
 
                err = -EIO;
                mlog_errno(err);
        }
-       return err;;
+       return err;
 }
 
 /* Read data from global quotafile - avoid pagecache and such because we cannot
 
        __u8    _esb_resvd[4];
        __u8    esb_service_params[112]; /* TBD */
        __u8    esb_seq_status[8];      /* sequence statuses, 8 bytes each */
-} __attribute__((packed));;
-
+} __attribute__((packed));
 
 /*
  * Define expected size for ASSERTs.
 
                    seq_print_ip_sym(seq, it->from, symflags) &&
                    trace_seq_printf(seq, "\n"))
                        return TRACE_TYPE_HANDLED;
-               return TRACE_TYPE_PARTIAL_LINE;;
+               return TRACE_TYPE_PARTIAL_LINE;
        }
        return TRACE_TYPE_UNHANDLED;
 }
 
                return 0;
        }
 
-       return rdev->ops->set_tx_power(wdev->wiphy, type, dbm);;
+       return rdev->ops->set_tx_power(wdev->wiphy, type, dbm);
 }
 EXPORT_SYMBOL_GPL(cfg80211_wext_siwtxpower);
 
 
        curr_tempo = 60;
        curr_timebase = 100;
        opened = 1;
-
-       ;
-
        {
                def_tmr.expires = (1) + jiffies;
                add_timer(&def_tmr);
 
                       - wm9081->fs);
        for (i = 1; i < ARRAY_SIZE(clk_sys_rates); i++) {
                cur_val = abs((wm9081->sysclk_rate /
-                              clk_sys_rates[i].ratio) - wm9081->fs);;
+                              clk_sys_rates[i].ratio) - wm9081->fs);
                if (cur_val < best_val) {
                        best = i;
                        best_val = cur_val;
 
                        do_div(tmp, freq_out);
                        val = tmp;
 
-                       val = (val << 16) | 64;;
+                       val = (val << 16) | 64;
                        ssp_write_reg(ssp, SSACDD, val);
 
                        ssacd |= (0x6 << 4);
 
 {
        int ret = 0;
 #ifdef ENFORCE_RATES
-       struct snd_pcm_runtime *runtime = substream->runtime;;
+       struct snd_pcm_runtime *runtime = substream->runtime;
 #endif
 
        mutex_lock(&clk_lock);