for (n = 0; n < 0x400; n += 0x40) {
                link->io.BasePort1 = n ^ 0x300;
                i = pcmcia_request_io(link, &link->io);
-               if (i == CS_SUCCESS)
+               if (i == 0)
                        break;
        }
 
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIO, i);
                goto failed;
        }
 
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                goto failed;
        }
 
 
 found_port:
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                goto failed;
        }
 
 
 found_port:
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                goto failed;
        }
 
                goto failed;
 
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                goto failed;
        }
 
 
        link->conf.IntType = 00000002;
 
-       if ((fail_rc = pcmcia_request_configuration(link,&link->conf))
-                                                               !=CS_SUCCESS) {
+       fail_rc = pcmcia_request_configuration(link, &link->conf);
+       if (fail_rc != 0) {
                dev_printk(KERN_INFO, &handle_to_dev(link),
                           "pcmcia_request_configuration failed 0x%x\n",
                           fail_rc);
 
        struct pcmcia_device *link = ipw->link;
        int ret = pccard_reset_card(link->socket);
 
-       if (ret != CS_SUCCESS)
+       if (ret != 0)
                cs_error(link, ResetCard, ret);
 }
 
        while (ret == 0) {
                ret = pcmcia_get_tuple_data(link, &tuple);
 
-               if (ret != CS_SUCCESS) {
+               if (ret != 0) {
                        cs_error(link, GetTupleData, ret);
                        goto exit0;
                }
 
        ret = pcmcia_get_first_tuple(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetFirstTuple, ret);
                goto exit0;
        }
 
        ret = pcmcia_get_tuple_data(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetTupleData, ret);
                goto exit0;
        }
 
        ret = pcmcia_parse_tuple(link, &tuple, &parse);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, ParseTuple, ret);
                goto exit0;
        }
 
        ret = pcmcia_get_first_tuple(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetFirstTuple, ret);
                goto exit0;
        }
 
        ret = pcmcia_get_tuple_data(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetTupleData, ret);
                goto exit0;
        }
 
        ret = pcmcia_parse_tuple(link, &tuple, &parse);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetTupleData, ret);
                goto exit0;
        }
 
        ret = pcmcia_request_io(link, &link->io);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, RequestIO, ret);
                goto exit0;
        }
 
        ret = pcmcia_get_first_tuple(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetFirstTuple, ret);
                goto exit1;
        }
 
        ret = pcmcia_get_tuple_data(link, &tuple);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, GetTupleData, ret);
                goto exit1;
        }
 
        ret = pcmcia_parse_tuple(link, &tuple, &parse);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, ParseTuple, ret);
                goto exit1;
        }
                ret = pcmcia_request_window(&link, &ipw->request_common_memory,
                                &ipw->handle_common_memory);
 
-               if (ret != CS_SUCCESS) {
+               if (ret != 0) {
                        cs_error(link, RequestWindow, ret);
                        goto exit1;
                }
                ret = pcmcia_map_mem_page(ipw->handle_common_memory,
                                &memreq_common_memory);
 
-               if (ret != CS_SUCCESS) {
+               if (ret != 0) {
                        cs_error(link, MapMemPage, ret);
                        goto exit1;
                }
                ret = pcmcia_request_window(&link, &ipw->request_attr_memory,
                                &ipw->handle_attr_memory);
 
-               if (ret != CS_SUCCESS) {
+               if (ret != 0) {
                        cs_error(link, RequestWindow, ret);
                        goto exit2;
                }
                ret = pcmcia_map_mem_page(ipw->handle_attr_memory,
                                &memreq_attr_memory);
 
-               if (ret != CS_SUCCESS) {
+               if (ret != 0) {
                        cs_error(link, MapMemPage, ret);
                        goto exit2;
                }
 
        ret = pcmcia_request_irq(link, &link->irq);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, RequestIRQ, ret);
                goto exit3;
        }
         */
        ret = pcmcia_request_configuration(link, &link->conf);
 
-       if (ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, RequestConfiguration, ret);
                goto exit4;
        }
 
         * allocate an interrupt line
         */
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
            cs_error(link, RequestIRQ, i);
            /* undo */
            pcmcia_disable_device(link);
          * configure the PCMCIA socket
          */
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
            cs_error(link, RequestConfiguration, i);
            pcmcia_disable_device(link);
            break;
 
         * allocate an interrupt line
         */
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
            cs_error(link, RequestIRQ, i);
            /* undo */
            pcmcia_disable_device(link);
         * configure the PCMCIA socket
         */
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
            cs_error(link, RequestConfiguration, i);
            pcmcia_disable_device(link);
            break;
 
     dev = link->priv;
 
     i = pcmcia_loop_config(link, elsa_cs_configcheck, NULL);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        last_fn = RequestIO;
        goto cs_failed;
     }
 
     i = pcmcia_request_irq(link, &link->irq);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
         link->irq.AssignedIRQ = 0;
        last_fn = RequestIRQ;
         goto cs_failed;
     }
 
     i = pcmcia_request_configuration(link, &link->conf);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
       last_fn = RequestConfiguration;
       goto cs_failed;
     }
 
     dev = link->priv;
 
     i = pcmcia_loop_config(link, teles_cs_configcheck, NULL);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        last_fn = RequestIO;
        goto cs_failed;
     }
 
     i = pcmcia_request_irq(link, &link->irq);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
         link->irq.AssignedIRQ = 0;
        last_fn = RequestIRQ;
         goto cs_failed;
     }
 
     i = pcmcia_request_configuration(link, &link->conf);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
       last_fn = RequestConfiguration;
       goto cs_failed;
     }
 
                DEBUG(2, "Remapping window from 0x%8.8x to 0x%8.8x",
                      dev->offset, mrq.CardOffset);
                mrq.Page = 0;
-               if( (ret = pcmcia_map_mem_page(win, &mrq)) != CS_SUCCESS) {
+               ret = pcmcia_map_mem_page(win, &mrq);
+               if (ret != 0) {
                        cs_error(dev->p_dev, MapMemPage, ret);
                        return NULL;
                }
 
        DEBUG(2, "dev = %p on = %d vpp = %d\n", dev, on, dev->vpp);
        ret = pcmcia_modify_configuration(link, &mod);
-       if(ret != CS_SUCCESS) {
+       if (ret != 0)
                cs_error(link, ModifyConfiguration, ret);
-       }
 }
 
 
        tuple.DesiredTuple = RETURN_FIRST_TUPLE;
 
        rc = pcmcia_get_first_tuple(link, &tuple);
-       while(rc == CS_SUCCESS) {
+       while (rc == 0) {
                rc = pcmcia_get_tuple_data(link, &tuple);
-               if(rc != CS_SUCCESS) {
+               if (rc != 0) {
                        cs_error(link, GetTupleData, rc);
                        break;
                }
                rc = pcmcia_parse_tuple(link, &tuple, &parse);
-               if(rc != CS_SUCCESS) {
+               if (rc != 0) {
                        cs_error(link, ParseTuple, rc);
                        break;
                }
 
        DEBUG(2, "Validating CIS");
        ret = pcmcia_validate_cis(link, NULL);
-       if(ret != CS_SUCCESS) {
+       if (ret != 0)
                cs_error(link, GetTupleData, ret);
-       }
 
        card_settings(dev, link, &new_name);
 
        link->conf.ConfigIndex = 0;
        DEBUG(2, "Setting Configuration");
        ret = pcmcia_request_configuration(link, &link->conf);
-       if(ret != CS_SUCCESS) {
+       if (ret != 0) {
                cs_error(link, RequestConfiguration, ret);
                if (dev->win_base) {
                        iounmap(dev->win_base);
 
        for (i = j = 0; j < 0x400; j += 0x20) {
                link->io.BasePort1 = j ^ 0x300;
                i = pcmcia_request_io(link, &link->io);
-               if (i == CS_SUCCESS) break;
+               if (i == 0)
+                       break;
        }
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIO, i);
                goto failed;
        }
        tuple.TupleDataMax = 64;
        tuple.TupleOffset = 0;
        tuple.DesiredTuple = 0x88;
-       if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) {
+       if (pcmcia_get_first_tuple(link, &tuple) == 0) {
                pcmcia_get_tuple_data(link, &tuple);
                for (i = 0; i < 3; i++)
                        phys_addr[i] = htons(le16_to_cpu(buf[i]));
 
        if (multi && (j & 0x80)) continue;
        link->io.BasePort1 = j ^ 0x300;
        i = pcmcia_request_io(link, &link->io);
-       if (i == CS_SUCCESS) break;
+       if (i == 0)
+               break;
     }
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        cs_error(link, RequestIO, i);
        goto failed;
     }
     /* The 3c589 has an extra EEPROM for configuration info, including
        the hardware address.  The 3c562 puts the address in the CIS. */
     tuple.DesiredTuple = 0x88;
-    if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) {
+    if (pcmcia_get_first_tuple(link, &tuple) == 0) {
        pcmcia_get_tuple_data(link, &tuple);
        for (i = 0; i < 3; i++)
            phys_addr[i] = htons(le16_to_cpu(buf[i]));
 
        if (link->io.NumPorts2 > 0) {
            /* for master/slave multifunction cards */
            link->io.Attributes2 = IO_DATA_PATH_WIDTH_8;
-           link->irq.Attributes = 
+           link->irq.Attributes =
                IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED;
        }
     } else {
            link->io.BasePort1 = j ^ 0x300;
            link->io.BasePort2 = (j ^ 0x300) + 0x10;
            ret = pcmcia_request_io(link, &link->io);
-           if (ret == CS_SUCCESS) return ret;
+           if (ret == 0)
+                   return ret;
        }
        return ret;
     } else {
     /* don't trust the CIS on this; Linksys got it wrong */
     link->conf.Present = 0x63;
     last_ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
-    if (last_ret != CS_SUCCESS) {
+    if (last_ret != 0) {
        cs_error(link, RequestIO, last_ret);
        goto failed;
     }
 
     DEBUG(0, "com20020_config(0x%p)\n", link);
 
     DEBUG(1,"arcnet: baseport1 is %Xh\n", link->io.BasePort1);
-    i = !CS_SUCCESS;
+    i = -ENODEV;
     if (!link->io.BasePort1)
     {
        for (ioaddr = 0x100; ioaddr < 0x400; ioaddr += 0x10)
        {
            link->io.BasePort1 = ioaddr;
            i = pcmcia_request_io(link, &link->io);
-           if (i == CS_SUCCESS)
+           if (i == 0)
                break;
        }
     }
     else
        i = pcmcia_request_io(link, &link->io);
     
-    if (i != CS_SUCCESS)
+    if (i != 0)
     {
        DEBUG(1,"arcnet: requestIO failed totally!\n");
        goto failed;
           link->irq.AssignedIRQ,
           link->irq.IRQInfo1, link->irq.IRQInfo2);
     i = pcmcia_request_irq(link, &link->irq);
-    if (i != CS_SUCCESS)
+    if (i != 0)
     {
        DEBUG(1,"arcnet: requestIRQ failed totally!\n");
        goto failed;
 
            printk(KERN_NOTICE "fmvj18x_cs: out of resource for serial\n");
        }
        ret = pcmcia_request_io(link, &link->io);
-       if (ret == CS_SUCCESS) return ret;
+       if (ret == 0)
+               return ret;
     }
     return ret;
 }
     for (ioaddr = 0x300; ioaddr < 0x3e0; ioaddr += 0x20) {
        link->io.BasePort1 = ioaddr;
        ret = pcmcia_request_io(link, &link->io);
-       if (ret == CS_SUCCESS) {
+       if (ret == 0) {
            /* calculate ConfigIndex value */
            link->conf.ConfigIndex = 
                ((link->io.BasePort1 & 0x0f0) >> 3) | 0x22;
     tuple.TupleOffset = 0;
     tuple.DesiredTuple = CISTPL_FUNCE;
     tuple.TupleOffset = 0;
-    if (pcmcia_get_first_tuple(link, &tuple) == CS_SUCCESS) {
+    if (pcmcia_get_first_tuple(link, &tuple) == 0) {
        /* Yes, I have CISTPL_FUNCE. Let's check CISTPL_MANFID */
        tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
        CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(link, &tuple));
        link->irq.Attributes =
                IRQ_TYPE_DYNAMIC_SHARING|IRQ_FIRST_SHARED|IRQ_HANDLE_PRESENT;
        ret = mfc_try_io_port(link);
-       if (ret != CS_SUCCESS) goto cs_failed;
+       if (ret != 0) goto cs_failed;
     } else if (cardtype == UNGERMANN) {
        ret = ungermann_try_io_port(link);
-       if (ret != CS_SUCCESS) goto cs_failed;
+       if (ret != 0) goto cs_failed;
     } else { 
        CS_CHECK(RequestIO, pcmcia_request_io(link, &link->io));
     }
     req.Base = 0; req.Size = 0;
     req.AccessSpeed = 0;
     i = pcmcia_request_window(&link, &req, &link->win);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        cs_error(link, RequestWindow, i);
        return -1;
     }
 
     iounmap(base);
     j = pcmcia_release_window(link->win);
-    if (j != CS_SUCCESS)
+    if (j != 0)
        cs_error(link, ReleaseWindow, j);
     return (i != 0x200) ? 0 : -1;
 
     req.Base = 0; req.Size = 0;
     req.AccessSpeed = 0;
     i = pcmcia_request_window(&link, &req, &link->win);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        cs_error(link, RequestWindow, i);
        return -1;
     }
 
     iounmap(base);
     j = pcmcia_release_window(link->win);
-    if (j != CS_SUCCESS)
+    if (j != 0)
        cs_error(link, ReleaseWindow, j);
     return 0;
 
 
     /* Try PRIMARY card at 0xA20-0xA23 */
     link->io.BasePort1 = 0xA20;
     i = pcmcia_request_io(link, &link->io);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        /* Couldn't get 0xA20-0xA23.  Try ALTERNATE at 0xA24-0xA27. */
        link->io.BasePort1 = 0xA24;
        CS_CHECK(RequestIO, pcmcia_request_io(link, &link->io));
 
     req.Base = 0; req.Size = 0;
     req.AccessSpeed = 0;
     i = pcmcia_request_window(&link, &req, &link->win);
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        cs_error(link, RequestWindow, i);
        return NULL;
     }
 
     iounmap(virt);
     j = pcmcia_release_window(link->win);
-    if (j != CS_SUCCESS)
+    if (j != 0)
        cs_error(link, ReleaseWindow, j);
     return (i < NR_INFO) ? hw_info+i : NULL;
 } /* get_hwinfo */
            link->io.BasePort1 = j ^ 0x300;
            link->io.BasePort2 = (j ^ 0x300) + 0x10;
            ret = pcmcia_request_io(link, &link->io);
-           if (ret == CS_SUCCESS) return ret;
+           if (ret == 0)
+                   return ret;
        }
        return ret;
     } else {
 
 {
        int i;
 
-       if ((i = pcmcia_get_first_tuple(handle, tuple)) != CS_SUCCESS ||
-                       (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
+       i = pcmcia_get_first_tuple(handle, tuple);
+       if (i != 0)
+               return i;
+       i = pcmcia_get_tuple_data(handle, tuple);
+       if (i != 0)
                return i;
        return pcmcia_parse_tuple(handle, tuple, parse);
 }
 {
        int i;
 
-       if ((i = pcmcia_get_next_tuple(handle, tuple)) != CS_SUCCESS ||
-                       (i = pcmcia_get_tuple_data(handle, tuple)) != CS_SUCCESS)
+       if ((i = pcmcia_get_next_tuple(handle, tuple)) != 0 ||
+                       (i = pcmcia_get_tuple_data(handle, tuple)) != 0)
                return i;
        return pcmcia_parse_tuple(handle, tuple, parse);
 }
     req.Base = req.Size = 0;
     req.AccessSpeed = 0;
     i = pcmcia_request_window(&link, &req, &link->win);
-    if (i != CS_SUCCESS)
+    if (i != 0)
        goto free_cfg_mem;
     smc->base = ioremap(req.Base, req.Size);
     mem.CardOffset = mem.Page = 0;
        mem.CardOffset = link->conf.ConfigBase;
     i = pcmcia_map_mem_page(link->win, &mem);
 
-    if ((i == CS_SUCCESS)
+    if ((i == 0)
        && (smc->manfid == MANFID_MEGAHERTZ)
        && (smc->cardid == PRODID_MEGAHERTZ_EM3288))
        mhz_3288_power(link);
     /* Read the station address from the CIS.  It is stored as the last
        (fourth) string in the Version 1 Version/ID tuple. */
     tuple->DesiredTuple = CISTPL_VERS_1;
-    if (first_tuple(link, tuple, parse) != CS_SUCCESS) {
+    if (first_tuple(link, tuple, parse) != 0) {
        rc = -1;
        goto free_cfg_mem;
     }
     /* Ugh -- the EM1144 card has two VERS_1 tuples!?! */
-    if (next_tuple(link, tuple, parse) != CS_SUCCESS)
+    if (next_tuple(link, tuple, parse) != 0)
        first_tuple(link, tuple, parse);
     if (parse->version_1.ns > 3) {
        station_addr = parse->version_1.str + parse->version_1.ofs[3];
 
     /* Another possibility: for the EM3288, in a special tuple */
     tuple->DesiredTuple = 0x81;
-    if (pcmcia_get_first_tuple(link, tuple) != CS_SUCCESS) {
+    if (pcmcia_get_first_tuple(link, tuple) != 0) {
        rc = -1;
        goto free_cfg_mem;
     }
-    if (pcmcia_get_tuple_data(link, tuple) != CS_SUCCESS) {
+    if (pcmcia_get_tuple_data(link, tuple) != 0) {
        rc = -1;
        goto free_cfg_mem;
     }
     /* Check for a LAN function extension tuple */
     tuple->DesiredTuple = CISTPL_FUNCE;
     i = first_tuple(link, tuple, parse);
-    while (i == CS_SUCCESS) {
+    while (i == 0) {
        if (parse->funce.type == CISTPL_FUNCE_LAN_NODE_ID)
            break;
        i = next_tuple(link, tuple, parse);
     }
-    if (i == CS_SUCCESS) {
+    if (i == 0) {
        node_id = (cistpl_lan_node_id_t *)parse->funce.data;
        if (node_id->nb == 6) {
            for (i = 0; i < 6; i++)
     for (i = j = 0; j < 4; j++) {
        link->io.BasePort2 = com[j];
        i = pcmcia_request_io(link, &link->io);
-       if (i == CS_SUCCESS) break;
+       if (i == 0)
+               break;
     }
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        /* Fallback: turn off hard decode */
        link->conf.ConfigIndex = 0x03;
        link->io.NumPorts2 = 0;
     /* Read the station address from tuple 0x90, subtuple 0x04 */
     tuple->DesiredTuple = 0x90;
     i = pcmcia_get_first_tuple(link, tuple);
-    while (i == CS_SUCCESS) {
+    while (i == 0) {
        i = pcmcia_get_tuple_data(link, tuple);
-       if ((i != CS_SUCCESS) || (buf[0] == 0x04))
+       if ((i != 0) || (buf[0] == 0x04))
            break;
        i = pcmcia_get_next_tuple(link, tuple);
     }
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        rc = -1;
        goto free_cfg_mem;
     }
 
 ======================================================================*/
 
-#define CS_EXIT_TEST(ret, svc, label) \
-if (ret != CS_SUCCESS) { cs_error(link, svc, ret); goto label; }
+#define CS_EXIT_TEST(ret, svc, label)  \
+if (ret != 0) {                                \
+       cs_error(link, svc, ret);       \
+       goto label;                     \
+}
 
 static int smc91c92_config(struct pcmcia_device *link)
 {
 
        tuple.TupleOffset = 0;
 
        res = pcmcia_get_first_tuple(dev, &tuple);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_kfree_ssb;
        res = pcmcia_get_tuple_data(dev, &tuple);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_kfree_ssb;
        res = pcmcia_parse_tuple(dev, &tuple, &parse);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_kfree_ssb;
 
        dev->conf.ConfigBase = parse.config.base;
        win.Size = SSB_CORE_SIZE;
        win.AccessSpeed = 250;
        res = pcmcia_request_window(&dev, &win, &dev->win);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_kfree_ssb;
 
        mem.CardOffset = 0;
        mem.Page = 0;
        res = pcmcia_map_mem_page(dev->win, &mem);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_disable;
 
        dev->irq.Attributes = IRQ_TYPE_DYNAMIC_SHARING;
        dev->irq.Handler = NULL; /* The handler is registered later. */
        dev->irq.Instance = NULL;
        res = pcmcia_request_irq(dev, &dev->irq);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_disable;
 
        res = pcmcia_request_configuration(dev, &dev->conf);
-       if (res != CS_SUCCESS)
+       if (res != 0)
                goto err_disable;
 
        err = ssb_bus_pcmciabus_register(ssb, dev, win.Base);
 
        reg.Value = hw_priv->link->io.BasePort1 & 0x00ff;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "Prism3 SanDisk - failed to set I/O base 0 -"
                       " res=%d\n", res);
        }
        reg.Value = (hw_priv->link->io.BasePort1 & 0xff00) >> 8;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "Prism3 SanDisk - failed to set I/O base 1 -"
                       " res=%d\n", res);
        }
        reg.Value = COR_SOFT_RESET;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "%s: SanDisk - COR sreset failed (%d)\n",
                       dev->name, res);
                goto done;
        reg.Value = COR_LEVEL_REQ | 0x8 | COR_ADDR_DECODE | COR_FUNC_ENA;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "%s: SanDisk - COR sreset failed (%d)\n",
                       dev->name, res);
                goto done;
        reg.Value = 0;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 1 (%d)\n",
                       res);
                return;
        reg.Value |= COR_SOFT_RESET;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 2 (%d)\n",
                       res);
                return;
                reg.Value |= COR_IREQ_ENA;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_cor_sreset failed 3 (%d)\n",
                       res);
                return;
        reg.Value = 0;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 1 "
                       "(%d)\n", res);
                return;
        reg.Value |= COR_SOFT_RESET;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 2 "
                       "(%d)\n", res);
                return;
        reg.Offset = CISREG_CCSR;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 3 "
                       "(%d)\n", res);
                return;
        reg.Value = old_cor & ~COR_SOFT_RESET;
        res = pcmcia_access_configuration_register(hw_priv->link,
                                                   ®);
-       if (res != CS_SUCCESS) {
+       if (res != 0) {
                printk(KERN_DEBUG "prism2_pccard_genesis_sreset failed 4 "
                       "(%d)\n", res);
                return;
 
     for (i = j = 0x0; j < 0x400; j += 0x20) {
        link->io.BasePort1 = j ^ 0x300;
        i = pcmcia_request_io(link, &link->io);
-       if (i == CS_SUCCESS) break;
+       if (i == 0)
+               break;
     }
-    if (i != CS_SUCCESS) {
+    if (i != 0) {
        cs_error(link, RequestIO, i);
        goto failed;
     }
 
     iounmap(local->amem);
     /* Do bother checking to see if these succeed or not */
     i = pcmcia_release_window(local->amem_handle);
-    if ( i != CS_SUCCESS ) DEBUG(0,"ReleaseWindow(local->amem) ret = %x\n",i);
+    if ( i != 0 ) DEBUG(0,"ReleaseWindow(local->amem) ret = %x\n",i);
     i = pcmcia_release_window(local->rmem_handle);
-    if ( i != CS_SUCCESS ) DEBUG(0,"ReleaseWindow(local->rmem) ret = %x\n",i);
+    if ( i != 0 ) DEBUG(0,"ReleaseWindow(local->rmem) ret = %x\n",i);
     pcmcia_disable_device(link);
 
     DEBUG(2,"ray_release ending\n");
 
 #endif
 
   i = pcmcia_access_configuration_register(link, ®);
-  if(i != CS_SUCCESS)
+  if (i != 0)
     {
       cs_error(link, AccessConfigurationRegister, i);
       return FALSE;
   reg.Action = CS_WRITE;
   reg.Value = reg.Value | COR_SW_RESET;
   i = pcmcia_access_configuration_register(link, ®);
-  if(i != CS_SUCCESS)
+  if (i != 0)
     {
       cs_error(link, AccessConfigurationRegister, i);
       return FALSE;
   reg.Action = CS_WRITE;
   reg.Value = COR_LEVEL_IRQ | COR_CONFIG;
   i = pcmcia_access_configuration_register(link, ®);
-  if(i != CS_SUCCESS)
+  if (i != 0)
     {
       cs_error(link, AccessConfigurationRegister, i);
       return FALSE;
   do
     {
       i = pcmcia_request_io(link, &link->io);
-      if(i != CS_SUCCESS)
+      if (i != 0)
        {
          cs_error(link, RequestIO, i);
          break;
        * actually assign a handler to the interrupt.
        */
       i = pcmcia_request_irq(link, &link->irq);
-      if(i != CS_SUCCESS)
+      if (i != 0)
        {
          cs_error(link, RequestIRQ, i);
          break;
        */
       link->conf.ConfigIndex = 1;
       i = pcmcia_request_configuration(link, &link->conf);
-      if(i != CS_SUCCESS)
+      if (i != 0)
        {
          cs_error(link, RequestConfiguration, i);
          break;
       req.Base = req.Size = 0;
       req.AccessSpeed = mem_speed;
       i = pcmcia_request_window(&link, &req, &link->win);
-      if(i != CS_SUCCESS)
+      if (i != 0)
        {
          cs_error(link, RequestWindow, i);
          break;
 
       mem.CardOffset = 0; mem.Page = 0;
       i = pcmcia_map_mem_page(link->win, &mem);
-      if(i != CS_SUCCESS)
+      if (i != 0)
        {
          cs_error(link, MapMemPage, i);
          break;
 
                link->io.BasePort1 = j;
                link->io.BasePort2 = link->io.BasePort1 + 0x10;
                i = pcmcia_request_io(link, &link->io);
-               if (i == CS_SUCCESS)
+               if (i == 0)
                        break;
        }
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIO, i);
                goto failed;
        }
 
        pci_bus_add_devices(bus);
 
        s->irq.AssignedIRQ = s->pci_irq;
-       return CS_SUCCESS;
+       return 0;
 }
 
 void cb_free(struct pcmcia_socket * s)
 
        return CS_OUT_OF_RESOURCE;
     s->fake_cis_len = len;
     memcpy(s->fake_cis, data, len);
-    return CS_SUCCESS;
+    return 0;
 }
 EXPORT_SYMBOL(pcmcia_replace_cis);
 
        !(tuple->Attributes & TUPLE_RETURN_COMMON)) {
        cisdata_t req = tuple->DesiredTuple;
        tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
-       if (pccard_get_next_tuple(s, function, tuple) == CS_SUCCESS) {
+       if (pccard_get_next_tuple(s, function, tuple) == 0) {
            tuple->DesiredTuple = CISTPL_LINKTARGET;
-           if (pccard_get_next_tuple(s, function, tuple) != CS_SUCCESS)
+           if (pccard_get_next_tuple(s, function, tuple) != 0)
                return CS_NO_MORE_ITEMS;
        } else
            tuple->CISOffset = tuple->TupleLink = 0;
     tuple->TupleCode = link[0];
     tuple->TupleLink = link[1];
     tuple->CISOffset = ofs + 2;
-    return CS_SUCCESS;
+    return 0;
 }
 EXPORT_SYMBOL(pccard_get_next_tuple);
 
     len = tuple->TupleLink - tuple->TupleOffset;
     tuple->TupleDataLen = tuple->TupleLink;
     if (len == 0)
-       return CS_SUCCESS;
+       return 0;
     read_cis_cache(s, SPACE(tuple->Flags),
                   tuple->CISOffset + tuple->TupleOffset,
                   _MIN(len, tuple->TupleDataMax), tuple->TupleData);
-    return CS_SUCCESS;
+    return 0;
 }
 EXPORT_SYMBOL(pccard_get_tuple_data);
 
        if (++p == q) break;
     }
     
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2;
     csum->len = get_unaligned_le16(p + 2);
     csum->sum = *(p + 4);
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     if (tuple->TupleDataLen < 4)
        return CS_BAD_TUPLE;
     link->addr = get_unaligned_le32(tuple->TupleData);
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
        link->fn[i].addr = get_unaligned_le32(p);
        p += 4;
     }
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     }
     if (found) {
        *found = ns;
-       return CS_SUCCESS;
+       return 0;
     } else {
-       return (ns == max) ? CS_SUCCESS : CS_BAD_TUPLE;
+       return (ns == max) ? 0 : CS_BAD_TUPLE;
     }
 }
 
        p += 2;
     }
     jedec->nid = nid;
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
        return CS_BAD_TUPLE;
     m->manf = get_unaligned_le16(tuple->TupleData);
     m->card = get_unaligned_le16(tuple->TupleData + 2);
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     p = (u_char *)tuple->TupleData;
     f->func = p[0];
     f->sysinit = p[1];
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     f->type = p[0];
     for (i = 1; i < tuple->TupleDataLen; i++)
        f->data[i-1] = p[i];
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     for (i = 0; i <= rmsz; i++)
        config->rmask[i>>2] += p[i] << (8*(i%4));
     config->subtuples = tuple->TupleDataLen - (rasz+rmsz+4);
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*======================================================================
 
     entry->subtuples = q-p;
     
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     bar->attr = *p;
     p += 2;
     bar->size = get_unaligned_le32(p);
-    return CS_SUCCESS;
+    return 0;
 }
 
 static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config)
     p++;
     config->base = get_unaligned_le32(p);
     config->subtuples = tuple->TupleDataLen - 6;
-    return CS_SUCCESS;
+    return 0;
 }
 
 static int parse_cftable_entry_cb(tuple_t *tuple,
 
     entry->subtuples = q-p;
     
-    return CS_SUCCESS;
+    return 0;
 }
 
 #endif
        p += 6;
     }
     geo->ngeo = n;
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
        if (*p == '\0') break;
        if (++p == q) return CS_BAD_TUPLE;
     }
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
     fmt->offset = get_unaligned_le32(p + 2);
     fmt->length = get_unaligned_le32(p + 6);
 
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
 
 int pccard_parse_tuple(tuple_t *tuple, cisparse_t *parse)
 {
-    int ret = CS_SUCCESS;
+    int ret = 0;
     
     if (tuple->TupleDataLen > tuple->TupleDataMax)
        return CS_BAD_TUPLE;
        break;
     case CISTPL_NO_LINK:
     case CISTPL_LINKTARGET:
-       ret = CS_SUCCESS;
+       ret = 0;
        break;
     default:
        ret = CS_UNSUPPORTED_FUNCTION;
     tuple.DesiredTuple = code;
     tuple.Attributes = TUPLE_RETURN_COMMON;
     ret = pccard_get_first_tuple(s, function, &tuple);
-    if (ret != CS_SUCCESS) goto done;
+    if (ret != 0)
+           goto done;
     tuple.TupleData = buf;
     tuple.TupleOffset = 0;
     tuple.TupleDataMax = 255;
     ret = pccard_get_tuple_data(s, &tuple);
-    if (ret != CS_SUCCESS) goto done;
+    if (ret != 0)
+           goto done;
     ret = pccard_parse_tuple(&tuple, parse);
 done:
     kfree(buf);
     tuple->DesiredTuple = RETURN_FIRST_TUPLE;
     tuple->Attributes = TUPLE_RETURN_COMMON;
     ret = pccard_get_first_tuple(s, function, tuple);
-    if (ret != CS_SUCCESS)
+    if (ret != 0)
        goto done;
 
     /* First tuple should be DEVICE; we should really have either that
        or a CFTABLE_ENTRY of some sort */
     if ((tuple->TupleCode == CISTPL_DEVICE) ||
-       (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY, p) == CS_SUCCESS) ||
-       (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY_CB, p) == CS_SUCCESS))
+       (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY, p) == 0) ||
+       (pccard_read_tuple(s, function, CISTPL_CFTABLE_ENTRY_CB, p) == 0))
        dev_ok++;
 
     /* All cards should have a MANFID tuple, and/or a VERS_1 or VERS_2
        tuple, for card identification.  Certain old D-Link and Linksys
        cards have only a broken VERS_2 tuple; hence the bogus test. */
-    if ((pccard_read_tuple(s, function, CISTPL_MANFID, p) == CS_SUCCESS) ||
-       (pccard_read_tuple(s, function, CISTPL_VERS_1, p) == CS_SUCCESS) ||
+    if ((pccard_read_tuple(s, function, CISTPL_MANFID, p) == 0) ||
+       (pccard_read_tuple(s, function, CISTPL_VERS_1, p) == 0) ||
        (pccard_read_tuple(s, function, CISTPL_VERS_2, p) != CS_NO_MORE_ITEMS))
        ident_ok++;
 
 
     for (count = 1; count < MAX_TUPLES; count++) {
        ret = pccard_get_next_tuple(s, function, tuple);
-       if (ret != CS_SUCCESS) break;
+       if (ret != 0)
+               break;
        if (((tuple->TupleCode > 0x23) && (tuple->TupleCode < 0x40)) ||
            ((tuple->TupleCode > 0x47) && (tuple->TupleCode < 0x80)) ||
            ((tuple->TupleCode > 0x90) && (tuple->TupleCode < 0xff)))
            *info = count;
     kfree(tuple);
     kfree(p);
-    return CS_SUCCESS;
+    return 0;
 }
 EXPORT_SYMBOL(pccard_validate_cis);
 
                        return CS_NO_CARD;
 
                if (status & SS_READY)
-                       return CS_SUCCESS;
+                       return 0;
 
                msleep(unreset_check * 10);
        }
                return CS_NO_CARD;
 
        ret = socket_setup(skt, setup_delay);
-       if (ret == CS_SUCCESS) {
+       if (ret == 0) {
                skt->state |= SOCKET_PRESENT;
 
                dev_printk(KERN_NOTICE, &skt->dev,
                skt->ops->suspend(skt);
        skt->state |= SOCKET_SUSPEND;
 
-       return CS_SUCCESS;
+       return 0;
 }
 
 /*
        }
 
        ret = socket_setup(skt, resume_delay);
-       if (ret == CS_SUCCESS) {
+       if (ret == 0) {
                /*
                 * FIXME: need a better check here for cardbus cards.
                 */
 
        skt->state &= ~SOCKET_SUSPEND;
 
-       return CS_SUCCESS;
+       return 0;
 }
 
 static void socket_remove(struct pcmcia_socket *skt)
                        send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
                        if (skt->callback)
                                skt->callback->suspend(skt);
-                       if (socket_reset(skt) == CS_SUCCESS) {
+                       if (socket_reset(skt) == 0) {
                                send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
                                if (skt->callback)
                                        skt->callback->resume(skt);
                        }
                }
 
-               ret = CS_SUCCESS;
+               ret = 0;
        } while (0);
        mutex_unlock(&skt->skt_mutex);
 
 
        else
                printk("%s: Unknown error code %#x\n", serv, err->retcode);
 
-       return CS_SUCCESS;
+       return 0;
 } /* report_error */
 
 /* end of code which was in cs.c before */
 
 #else
 static inline void __init pcmcia_setup_ioctl(void) { return; }
 static inline void __exit pcmcia_cleanup_ioctl(void) { return; }
-static inline void handle_event(struct pcmcia_socket *s, event_t event) { return; }
-static inline int handle_request(struct pcmcia_socket *s, event_t event) { return CS_SUCCESS; }
+static inline void handle_event(struct pcmcia_socket *s, event_t event)
+{
+       return;
+}
+static inline int handle_request(struct pcmcia_socket *s, event_t event)
+{
+       return 0;
+}
 #endif
 
 #else
 
 static inline int adjust_irq(struct pcmcia_socket *s, adjust_t *adj) {
-       return CS_SUCCESS;
+       return 0;
 }
 
 #endif
                        status->CardState |=
                                (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
                }
-               return CS_SUCCESS;
+               return 0;
        }
        status->CardState |=
                (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
                (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
        status->CardState |=
                (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
-       return CS_SUCCESS;
+       return 0;
 } /* pccard_get_status */
 
 int pccard_get_configuration_info(struct pcmcia_socket *s,
                                        config->BasePort1 + 1;
                        }
                }
-               return CS_SUCCESS;
+               return 0;
        }
 #endif
 
                config->Attributes = 0;
                config->Vcc = s->socket.Vcc;
                config->Vpp1 = config->Vpp2 = s->socket.Vpp;
-               return CS_SUCCESS;
+               return 0;
        }
 
        config->Attributes = c->Attributes | CONF_VALID_CLIENT;
        config->Attributes2 = c->io.Attributes2;
        config->IOAddrLines = c->io.IOAddrLines;
 
-       return CS_SUCCESS;
+       return 0;
 } /* pccard_get_configuration_info */
 
 
        err = -EINVAL;
     }
 
-    if ((err == 0) && (ret != CS_SUCCESS)) {
+    if ((err == 0) && (ret != 0)) {
        ds_dbg(2, "ds_ioctl: ret = %d\n", ret);
        switch (ret) {
        case CS_BAD_SOCKET: case CS_NO_CARD:
 
                return CS_BAD_ARGS;
                break;
        }
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_access_configuration_register */
 EXPORT_SYMBOL(pcmcia_access_configuration_register);
 
        if (win->ctl.flags & MAP_USE_WAIT)
                req->Attributes |= WIN_USE_WAIT;
        *handle = win;
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_get_window */
 EXPORT_SYMBOL(pcmcia_get_window);
 
                return CS_BAD_HANDLE;
        req->Page = 0;
        req->CardOffset = win->ctl.card_start;
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_get_mem_page */
 EXPORT_SYMBOL(pcmcia_get_mem_page);
 
        win->ctl.card_start = req->CardOffset;
        if (s->ops->set_mem_map(s, &win->ctl) != 0)
                return CS_BAD_OFFSET;
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_map_mem_page */
 EXPORT_SYMBOL(pcmcia_map_mem_page);
 
                }
        }
 
-       return CS_SUCCESS;
+       return 0;
 } /* modify_configuration */
 EXPORT_SYMBOL(pcmcia_modify_configuration);
 
                        }
        }
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_release_configuration */
 
 
        if (req->NumPorts2)
                release_io_space(s, req->BasePort2, req->NumPorts2);
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_release_io */
 
 
        pcmcia_used_irq[req->AssignedIRQ]--;
 #endif
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_release_irq */
 
 
 
        win->magic = 0;
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_release_window */
 EXPORT_SYMBOL(pcmcia_release_window);
 
 
        c->state |= CONFIG_LOCKED;
        p_dev->_locked = 1;
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_request_configuration */
 EXPORT_SYMBOL(pcmcia_request_configuration);
 
        c->io = *req;
        c->state |= CONFIG_IO_REQ;
        p_dev->_io = 1;
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_request_io */
 EXPORT_SYMBOL(pcmcia_request_io);
 
        pcmcia_used_irq[irq]++;
 #endif
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_request_irq */
 EXPORT_SYMBOL(pcmcia_request_irq);
 
        }
        *wh = win;
 
-       return CS_SUCCESS;
+       return 0;
 } /* pcmcia_request_window */
 EXPORT_SYMBOL(pcmcia_request_window);
 
 
     if (!q) return CS_OUT_OF_RESOURCE;
     q->base = base; q->num = num;
     q->next = p->next; p->next = q;
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*====================================================================*/
            }
        }
     }
-    return CS_SUCCESS;
+    return 0;
 }
 
 /*======================================================================
 
 {
        int i;
        i = pcmcia_get_first_tuple(handle, tuple);
-       if (i != CS_SUCCESS)
+       if (i != 0)
                return CS_NO_MORE_ITEMS;
        i = pcmcia_get_tuple_data(handle, tuple);
-       if (i != CS_SUCCESS)
+       if (i != 0)
                return i;
        return pcmcia_parse_tuple(handle, tuple, parse);
 }
 
 found_port:
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestIRQ, i);
                link->irq.AssignedIRQ = 0;
        }
                info->quirk->config(link);
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                return -1;
        }
        }
 
        i = pcmcia_request_irq(link, &link->irq);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                /* FIXME: comment does not fit, error handling does not fit */
                printk(KERN_NOTICE
                       "serial_cs: no usable port range found, giving up\n");
                info->quirk->config(link);
 
        i = pcmcia_request_configuration(link, &link->conf);
-       if (i != CS_SUCCESS) {
+       if (i != 0) {
                cs_error(link, RequestConfiguration, i);
                return -ENODEV;
        }
        /* Is this a compliant multifunction card? */
        tuple->DesiredTuple = CISTPL_LONGLINK_MFC;
        tuple->Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
-       info->multi = (first_tuple(link, tuple, parse) == CS_SUCCESS);
+       info->multi = (first_tuple(link, tuple, parse) == 0);
 
        /* Is this a multiport card? */
        tuple->DesiredTuple = CISTPL_MANFID;
            ((link->func_id == CISTPL_FUNCID_MULTI) ||
             (link->func_id == CISTPL_FUNCID_SERIAL))) {
                tuple->DesiredTuple = CISTPL_CFTABLE_ENTRY;
-               if (first_tuple(link, tuple, parse) == CS_SUCCESS) {
+               if (first_tuple(link, tuple, parse) == 0) {
                        if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
                                info->multi = cf->io.win[0].len >> 3;
                        if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
 
        reg.Action = CS_WRITE;
        reg.Value = value;
        res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
-       if (unlikely(res != CS_SUCCESS))
+       if (unlikely(res != 0))
                return -EBUSY;
 
        return 0;
        reg.Offset = offset;
        reg.Action = CS_READ;
        res = pcmcia_access_configuration_register(bus->host_pcmcia, ®);
-       if (unlikely(res != CS_SUCCESS))
+       if (unlikely(res != 0))
                return -EBUSY;
        *value = reg.Value;
 
        tuple.TupleData = buf;
        tuple.TupleDataMax = sizeof(buf);
        res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
-       GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl");
+       GOTO_ERROR_ON(res != 0, "MAC first tpl");
        res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-       GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl data");
+       GOTO_ERROR_ON(res != 0, "MAC first tpl data");
        while (1) {
                GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1");
                if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID)
                        break;
                res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
-               GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl");
+               GOTO_ERROR_ON(res != 0, "MAC next tpl");
                res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-               GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl data");
+               GOTO_ERROR_ON(res != 0, "MAC next tpl data");
        }
        GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size");
        memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN);
        tuple.TupleData = buf;
        tuple.TupleDataMax = sizeof(buf);
        res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
-       GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl");
+       GOTO_ERROR_ON(res != 0, "VEN first tpl");
        res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-       GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl data");
+       GOTO_ERROR_ON(res != 0, "VEN first tpl data");
        while (1) {
                GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1");
                switch (tuple.TupleData[0]) {
                res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
                if (res == CS_NO_MORE_ITEMS)
                        break;
-               GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl");
+               GOTO_ERROR_ON(res != 0, "VEN next tpl");
                res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-               GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl data");
+               GOTO_ERROR_ON(res != 0, "VEN next tpl data");
        }
 
        return 0;