descriptors = f->ssp_descriptors;
                if (descriptors)
                        break;
-               /* FALLTHROUGH */
+               fallthrough;
        case USB_SPEED_SUPER:
                descriptors = f->ss_descriptors;
                if (descriptors)
                        break;
-               /* FALLTHROUGH */
+               fallthrough;
        case USB_SPEED_HIGH:
                descriptors = f->hs_descriptors;
                if (descriptors)
                        break;
-               /* FALLTHROUGH */
+               fallthrough;
        default:
                descriptors = f->fs_descriptors;
        }
                        want_comp_desc = 1;
                        break;
                }
-               /* fall through */
+               fallthrough;
        case USB_SPEED_SUPER:
                if (gadget_is_superspeed(g)) {
                        speed_desc = f->ss_descriptors;
                        want_comp_desc = 1;
                        break;
                }
-               /* fall through */
+               fallthrough;
        case USB_SPEED_HIGH:
                if (gadget_is_dualspeed(g)) {
                        speed_desc = f->hs_descriptors;
                        break;
                }
-               /* fall through */
+               fallthrough;
        default:
                speed_desc = f->fs_descriptors;
        }
                case USB_ENDPOINT_XFER_ISOC:
                        /* mult: bits 1:0 of bmAttributes */
                        _ep->mult = (comp_desc->bmAttributes & 0x3) + 1;
-                       /* fall through */
+                       fallthrough;
                case USB_ENDPOINT_XFER_BULK:
                case USB_ENDPOINT_XFER_INT:
                        _ep->maxburst = comp_desc->bMaxBurst + 1;
                        if (!gadget_is_dualspeed(gadget) ||
                            gadget->speed >= USB_SPEED_SUPER)
                                break;
-                       /* FALLTHROUGH */
+                       fallthrough;
                case USB_DT_CONFIG:
                        value = config_desc(cdev, w_value);
                        if (value >= 0)
 
        switch (type) {
        case FUNCTIONFS_RESUME:
                rem_type2 = FUNCTIONFS_SUSPEND;
-               /* FALL THROUGH */
+               fallthrough;
        case FUNCTIONFS_SUSPEND:
        case FUNCTIONFS_SETUP:
                rem_type1 = type;
 
                break;
        default:
                ERROR(cdev, "Set report failed %d\n", req->status);
-               /* FALLTHROUGH */
+               fallthrough;
        case -ECONNABORTED:             /* hardware forced ep reset */
        case -ECONNRESET:               /* request dequeued */
        case -ESHUTDOWN:                /* disconnect from host */
 
        case RELEASE:
        case RESERVE:
        case SEND_DIAGNOSTIC:
-               /* Fall through */
+               fallthrough;
 
        default:
 unknown_cmnd:
 
        case -ESHUTDOWN: /* disconnected */
        case -ECONNRESET: /* disabled */
                dev->stats.tx_aborted_errors++;
-               /* fall through */
+               fallthrough;
        default:
                dev->stats.tx_errors++;
        }
        /* Do resubmit in these cases: */
        case -EOVERFLOW: /* request buffer overflow */
                dev->stats.rx_over_errors++;
-               /* fall through */
+               fallthrough;
        default:
                dev->stats.rx_errors++;
                break;
 
 
        /* data overrun */
        case -EOVERFLOW:
-               /* FALLTHROUGH */
+               fallthrough;
 
        default:
                DBG(dev, "rx status %d\n", status);
        switch (req->status) {
        default:
                VDBG(dev, "tx err %d\n", req->status);
-               /* FALLTHROUGH */
+               fallthrough;
        case -ECONNRESET:               /* unlink */
        case -ESHUTDOWN:                /* disconnect etc */
                break;
                if (!w_value && !w_length &&
                   !(USB_DIR_IN & ctrl->bRequestType))
                        break;
-               /* fall through */
+               fallthrough;
        default:
                return false;
        }
 
                DBG(cdev, "RNDIS %s response error %d, %d/%d\n",
                        ep->name, status,
                        req->actual, req->length);
-               /* FALLTHROUGH */
+               fallthrough;
        case 0:
                if (ep != rndis->notify)
                        break;
 
        default:
                pr_debug_once("Unsupported prio_attr: %02x.\n",
                                cmd_iu->prio_attr);
-               /* fall through */
+               fallthrough;
        case UAS_SIMPLE_TAG:
                cmd->prio_attr = TCM_SIMPLE_TAG;
                break;
 
        /* data overrun */
        case -EOVERFLOW:
                dev->net->stats.rx_over_errors++;
-               /* FALLTHROUGH */
+               fallthrough;
 
        default:
                dev->net->stats.rx_errors++;
        default:
                dev->net->stats.tx_errors++;
                VDBG(dev, "tx err %d\n", req->status);
-               /* FALLTHROUGH */
+               fallthrough;
        case -ECONNRESET:               /* unlink */
        case -ESHUTDOWN:                /* disconnect etc */
                dev_kfree_skb_any(skb);
 
                        /* presumably a transient fault */
                        pr_warn("ttyGS%d: unexpected RX status %d\n",
                                port->port_num, req->status);
-                       /* FALLTHROUGH */
+                       fallthrough;
                case 0:
                        /* normal completion */
                        break;
                /* presumably a transient fault */
                pr_warn("%s: unexpected %s status %d\n",
                        __func__, ep->name, req->status);
-               /* FALL THROUGH */
+               fallthrough;
        case 0:
                /* normal completion */
                gs_start_tx(port);
        default:
                pr_warn("%s: unexpected %s status %d\n",
                        __func__, ep->name, req->status);
-               /* fall through */
+               fallthrough;
        case 0:
                /* normal completion */
                spin_lock(&cons->lock);
 
        case STATE_EP_READY:                    /* not configured yet */
                if (is_write)
                        return 0;
-               // FALLTHRU
+               fallthrough;
        case STATE_EP_UNBOUND:                  /* clean disconnect */
                break;
        // case STATE_EP_DISABLED:              /* "can't happen" */
        case GADGETFS_DISCONNECT:
                if (dev->state == STATE_DEV_SETUP)
                        dev->setup_abort = 1;
-               // FALL THROUGH
+               fallthrough;
        case GADGETFS_CONNECT:
                dev->ev_next = 0;
                break;
                        make_qualifier (dev);
                        break;
                case USB_DT_OTHER_SPEED_CONFIG:
-                       // FALLTHROUGH
                case USB_DT_CONFIG:
                        value = config_buf (dev,
                                        w_value >> 8,
        case STATE_DEV_UNCONNECTED:
                next_event (dev, GADGETFS_SUSPEND);
                ep0_readable (dev);
-               /* FALLTHROUGH */
+               fallthrough;
        default:
                break;
        }
 
                        if (max <= 1024)
                                break;
                        /* save a return statement */
-                       /* fall through */
+                       fallthrough;
                case USB_SPEED_FULL:
                        if (max <= 64)
                                break;
                        /* save a return statement */
-                       /* fall through */
+                       fallthrough;
                default:
                        if (max <= 8)
                                break;
                        if (max <= 1024)
                                break;
                        /* save a return statement */
-                       /* fall through */
+                       fallthrough;
                case USB_SPEED_FULL:
                        if (max <= 1023)
                                break;
                         * this almost certainly polls too fast.
                         */
                        limit = max(limit, periodic_bytes(dum, ep));
-                       /* FALLTHROUGH */
+                       fallthrough;
 
                default:
 treat_control_like_bulk:
                                         "supported for USB 2.0 roothub\n");
                                goto error;
                        }
-                       /* FALLS THROUGH */
+                       fallthrough;
                case USB_PORT_FEAT_RESET:
                        /* if it's already enabled, disable */
                        if (hcd->speed == HCD_USB3) {
                         * interval? Is it still 50msec as for HS?
                         */
                        dum_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
-                       /* FALLS THROUGH */
+                       fallthrough;
                default:
                        if (hcd->speed == HCD_USB3) {
                                if ((dum_hcd->port_status &
 
        max = get_unaligned_le16(&desc->wMaxPacketSize);
        switch (max) {
        case 64:
-               mode++; /* fall through */
+               mode++;
+               fallthrough;
        case 32:
-               mode++; /* fall through */
+               mode++;
+               fallthrough;
        case 16:
-               mode++; /* fall through */
+               mode++;
+               fallthrough;
        case 8:
                mode <<= 3;
                break;
 
                                type = "integrated";
                                break;
                        }
-                       /* FALL THROUGH */
+                       fallthrough;
                case 3:
                case 11:
                case 16:
                case 14:                        /* transceiverless */
                        if (cpu_is_omap1710())
                                goto bad_on_1710;
-                       /* FALL THROUGH */
+                       fallthrough;
                case 13:
                case 15:
                        type = "no";
 
        switch (idx) {
        default:
                idx = 0;
-               /* fall through */
+               fallthrough;
        case 0:
                fifo_reg = S3C2410_UDC_EP0_FIFO_REG;
                break;
        switch (idx) {
        default:
                idx = 0;
-               /* fall through */
+               fallthrough;
        case 0:
                fifo_reg = S3C2410_UDC_EP0_FIFO_REG;
                break;
 
                ep_wait_for_stopped(xudc, ep_index);
                ep->enq_ptr = ep->deq_ptr;
                tegra_xudc_ep_nuke(ep, -EIO);
-               /* FALLTHROUGH */
+               fallthrough;
        case TRB_CMPL_CODE_STREAM_NUMP_ERROR:
        case TRB_CMPL_CODE_CTRL_DIR_ERR:
        case TRB_CMPL_CODE_INVALID_STREAM_TYPE_ERR: