/**
  * enum cvmx_usb_status - possible callback function status codes
  *
- * @CVMX_USB_STATUS_SUCCESS:     The transaction / operation finished without
+ * @CVMX_USB_STATUS_OK:                  The transaction / operation finished without
  *                               any errors
  * @CVMX_USB_STATUS_SHORT:       FIXME: This is currently not implemented
  * @CVMX_USB_STATUS_CANCEL:      The transaction was canceled while in flight
  *                               even after a number of retries
  */
 enum cvmx_usb_status {
-       CVMX_USB_STATUS_SUCCESS,
+       CVMX_USB_STATUS_OK,
        CVMX_USB_STATUS_SHORT,
        CVMX_USB_STATUS_CANCEL,
        CVMX_USB_STATUS_ERROR,
        struct usb_hcd *hcd = octeon_to_hcd(priv);
        struct device *dev = hcd->self.controller;
 
-       if (likely(status == CVMX_USB_STATUS_SUCCESS))
+       if (likely(status == CVMX_USB_STATUS_OK))
                urb->actual_length = bytes_transferred;
        else
                urb->actual_length = 0;
                /* Recalculate the transfer size by adding up each packet */
                urb->actual_length = 0;
                for (i = 0; i < urb->number_of_packets; i++) {
-                       if (iso_packet[i].status == CVMX_USB_STATUS_SUCCESS) {
+                       if (iso_packet[i].status == CVMX_USB_STATUS_OK) {
                                urb->iso_frame_desc[i].status = 0;
                                urb->iso_frame_desc[i].actual_length =
                                        iso_packet[i].length;
        }
 
        switch (status) {
-       case CVMX_USB_STATUS_SUCCESS:
+       case CVMX_USB_STATUS_OK:
                urb->status = 0;
                break;
        case CVMX_USB_STATUS_CANCEL:
                 * next one
                 */
                if ((transaction->iso_number_packets > 1) &&
-                   (complete_code == CVMX_USB_STATUS_SUCCESS)) {
+                   (complete_code == CVMX_USB_STATUS_OK)) {
                        /* No bytes transferred for this packet as of yet */
                        transaction->actual_bytes = 0;
                        /* One less ISO waiting to transfer */
                            (bytes_in_last_packet < pipe->max_packet))
                                cvmx_usb_complete(usb, pipe,
                                                  transaction,
-                                                 CVMX_USB_STATUS_SUCCESS);
+                                                 CVMX_USB_STATUS_OK);
                } else {
                        /*
                         * Split transactions retry the split complete 4 times
                                else
                                        cvmx_usb_complete(usb, pipe,
                                                          transaction,
-                                                         CVMX_USB_STATUS_SUCCESS);
+                                                         CVMX_USB_STATUS_OK);
                                break;
                        case CVMX_USB_STAGE_STATUS_SPLIT_COMPLETE:
                                cvmx_usb_complete(usb, pipe, transaction,
-                                                 CVMX_USB_STATUS_SUCCESS);
+                                                 CVMX_USB_STATUS_OK);
                                break;
                        }
                        break;
                                                        pipe->interval;
                                        cvmx_usb_complete(usb, pipe,
                                                          transaction,
-                                                         CVMX_USB_STATUS_SUCCESS);
+                                                         CVMX_USB_STATUS_OK);
                                }
                        } else {
                                if ((pipe->device_speed ==
                                                        pipe->interval;
                                        cvmx_usb_complete(usb, pipe,
                                                          transaction,
-                                                         CVMX_USB_STATUS_SUCCESS);
+                                                         CVMX_USB_STATUS_OK);
                                }
                        }
                        break;
                                                        pipe->interval;
                                                cvmx_usb_complete(usb, pipe,
                                                                  transaction,
-                                                                 CVMX_USB_STATUS_SUCCESS);
+                                                                 CVMX_USB_STATUS_OK);
                                        }
                                } else {
                                        if (transaction->stage ==
                                                        cvmx_usb_complete(usb,
                                                                          pipe,
                                                                          transaction,
-                                                                         CVMX_USB_STATUS_SUCCESS);
+                                                                         CVMX_USB_STATUS_OK);
                                                }
                                        } else
                                                transaction->stage =
                        } else {
                                pipe->next_tx_frame += pipe->interval;
                                cvmx_usb_complete(usb, pipe, transaction,
-                                                 CVMX_USB_STATUS_SUCCESS);
+                                                 CVMX_USB_STATUS_OK);
                        }
                        break;
                }