chipidea's ffs_nr() is pretty much what __ffs() does.
Use that one instead.
Signed-off-by: Felipe Balbi <balbi@ti.com>
[rebased on top of debug infrastructure rework]
Signed-off-by: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
        OP_LAST = OP_ENDPTCTRL + ENDPT_MAX / 2,
 };
 
-/**
- * ffs_nr: find first (least significant) bit set
- * @x: the word to search
- *
- * This function returns bit number (instead of position)
- */
-static inline int ffs_nr(u32 x)
-{
-       int n = ffs(x);
-
-       return n ? n-1 : 32;
-}
-
 /**
  * hw_read: reads from a hw register
  * @reg:  register index
        u32 val = hw_read(ci, reg, ~0);
 
        hw_write(ci, reg, mask, data);
-       return (val & mask) >> ffs_nr(mask);
+       return (val & mask) >> __ffs(mask);
 }
 
 int hw_device_reset(struct ci13xxx *ci, u32 mode);
 
        if (mode > TEST_MODE_MAX)
                return -EINVAL;
 
-       hw_write(ci, OP_PORTSC, PORTSC_PTC, mode << ffs_nr(PORTSC_PTC));
+       hw_write(ci, OP_PORTSC, PORTSC_PTC, mode << __ffs(PORTSC_PTC));
        return 0;
 }
 
  */
 u8 hw_port_test_get(struct ci13xxx *ci)
 {
-       return hw_read(ci, OP_PORTSC, PORTSC_PTC) >> ffs_nr(PORTSC_PTC);
+       return hw_read(ci, OP_PORTSC, PORTSC_PTC) >> __ffs(PORTSC_PTC);
 }
 
 static int hw_device_init(struct ci13xxx *ci, void __iomem *base)
 
        hw_alloc_regmap(ci, false);
        reg = hw_read(ci, CAP_HCCPARAMS, HCCPARAMS_LEN) >>
-               ffs_nr(HCCPARAMS_LEN);
+               __ffs(HCCPARAMS_LEN);
        ci->hw_bank.lpm  = reg;
        hw_alloc_regmap(ci, !!reg);
        ci->hw_bank.size = ci->hw_bank.op - ci->hw_bank.abs;
        ci->hw_bank.size /= sizeof(u32);
 
        reg = hw_read(ci, CAP_DCCPARAMS, DCCPARAMS_DEN) >>
-               ffs_nr(DCCPARAMS_DEN);
+               __ffs(DCCPARAMS_DEN);
        ci->hw_ep_max = reg * 2;   /* cache hw ENDPT_MAX */
 
        if (ci->hw_ep_max > ENDPT_MAX)
 
 
        if (dir) {
                mask  = ENDPTCTRL_TXT;  /* type    */
-               data  = type << ffs_nr(mask);
+               data  = type << __ffs(mask);
 
                mask |= ENDPTCTRL_TXS;  /* unstall */
                mask |= ENDPTCTRL_TXR;  /* reset data toggle */
                data |= ENDPTCTRL_TXE;
        } else {
                mask  = ENDPTCTRL_RXT;  /* type    */
-               data  = type << ffs_nr(mask);
+               data  = type << __ffs(mask);
 
                mask |= ENDPTCTRL_RXS;  /* unstall */
                mask |= ENDPTCTRL_RXR;  /* reset data toggle */
 static void hw_usb_set_address(struct ci13xxx *ci, u8 value)
 {
        hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
-                value << ffs_nr(DEVICEADDR_USBADR));
+                value << __ffs(DEVICEADDR_USBADR));
 }
 
 /**
         * TODO - handle requests which spawns into several TDs
         */
        memset(mReq->ptr, 0, sizeof(*mReq->ptr));
-       mReq->ptr->token    = length << ffs_nr(TD_TOTAL_BYTES);
+       mReq->ptr->token    = length << __ffs(TD_TOTAL_BYTES);
        mReq->ptr->token   &= TD_TOTAL_BYTES;
        mReq->ptr->token   |= TD_STATUS_ACTIVE;
        if (mReq->zptr) {
                mReq->req.status = -1;
 
        mReq->req.actual   = mReq->ptr->token & TD_TOTAL_BYTES;
-       mReq->req.actual >>= ffs_nr(TD_TOTAL_BYTES);
+       mReq->req.actual >>= __ffs(TD_TOTAL_BYTES);
        mReq->req.actual   = mReq->req.length - mReq->req.actual;
        mReq->req.actual   = mReq->req.status ? 0 : mReq->req.actual;
 
                mEp->qh.ptr->cap &= ~QH_ZLT;
 
        mEp->qh.ptr->cap |=
-               (mEp->ep.maxpacket << ffs_nr(QH_MAX_PKT)) & QH_MAX_PKT;
+               (mEp->ep.maxpacket << __ffs(QH_MAX_PKT)) & QH_MAX_PKT;
        mEp->qh.ptr->td.next |= TD_TERMINATE;   /* needed? */
 
        /*