git.sur5r.net Git - u-boot/blob - drivers/net/ks8851_mll.c

   1 /*
   2  * Micrel KS8851_MLL 16bit Network driver
   3  * Copyright (c) 2011 Roberto Cerati <roberto.cerati@bticino.it>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <asm/io.h>
   9 #include <common.h>
  10 #include <command.h>
  11 #include <malloc.h>
  12 #include <net.h>
  13 #include <miiphy.h>
  14
  15 #include "ks8851_mll.h"
  16
  17 #define DRIVERNAME                      "ks8851_mll"
  18
  19 #define MAX_RECV_FRAMES                 32
  20 #define MAX_BUF_SIZE                    2048
  21 #define TX_BUF_SIZE                     2000
  22 #define RX_BUF_SIZE                     2000
  23
  24 static const struct chip_id chip_ids[] =  {
  25         {CIDER_ID, "KSZ8851"},
  26         {0, NULL},
  27 };
  28
  29 /*
  30  * union ks_tx_hdr - tx header data
  31  * @txb: The header as bytes
  32  * @txw: The header as 16bit, little-endian words
  33  *
  34  * A dual representation of the tx header data to allow
  35  * access to individual bytes, and to allow 16bit accesses
  36  * with 16bit alignment.
  37  */
  38 union ks_tx_hdr {
  39         u8      txb[4];
  40         __le16  txw[2];
  41 };
  42
  43 /*
  44  * struct ks_net - KS8851 driver private data
  45  * @net_device  : The network device we're bound to
  46  * @txh         : temporaly buffer to save status/length.
  47  * @frame_head_info     : frame header information for multi-pkt rx.
  48  * @statelock   : Lock on this structure for tx list.
  49  * @msg_enable  : The message flags controlling driver output (see ethtool).
  50  * @frame_cnt   : number of frames received.
  51  * @bus_width   : i/o bus width.
  52  * @irq         : irq number assigned to this device.
  53  * @rc_rxqcr    : Cached copy of KS_RXQCR.
  54  * @rc_txcr     : Cached copy of KS_TXCR.
  55  * @rc_ier      : Cached copy of KS_IER.
  56  * @sharedbus   : Multipex(addr and data bus) mode indicator.
  57  * @cmd_reg_cache       : command register cached.
  58  * @cmd_reg_cache_int   : command register cached. Used in the irq handler.
  59  * @promiscuous : promiscuous mode indicator.
  60  * @all_mcast   : mutlicast indicator.
  61  * @mcast_lst_size      : size of multicast list.
  62  * @mcast_lst           : multicast list.
  63  * @mcast_bits          : multicast enabed.
  64  * @mac_addr            : MAC address assigned to this device.
  65  * @fid                 : frame id.
  66  * @extra_byte          : number of extra byte prepended rx pkt.
  67  * @enabled             : indicator this device works.
  68  */
  69
  70 /* Receive multiplex framer header info */
  71 struct type_frame_head {
  72         u16     sts;         /* Frame status */
  73         u16     len;         /* Byte count */
  74 } fr_h_i[MAX_RECV_FRAMES];
  75
  76 struct ks_net {
  77         struct net_device       *netdev;
  78         union ks_tx_hdr         txh;
  79         struct type_frame_head  *frame_head_info;
  80         u32                     msg_enable;
  81         u32                     frame_cnt;
  82         int                     bus_width;
  83         int                     irq;
  84         u16                     rc_rxqcr;
  85         u16                     rc_txcr;
  86         u16                     rc_ier;
  87         u16                     sharedbus;
  88         u16                     cmd_reg_cache;
  89         u16                     cmd_reg_cache_int;
  90         u16                     promiscuous;
  91         u16                     all_mcast;
  92         u16                     mcast_lst_size;
  93         u8                      mcast_lst[MAX_MCAST_LST][MAC_ADDR_LEN];
  94         u8                      mcast_bits[HW_MCAST_SIZE];
  95         u8                      mac_addr[6];
  96         u8                      fid;
  97         u8                      extra_byte;
  98         u8                      enabled;
  99 } ks_str, *ks;
 100
 101 #define BE3             0x8000      /* Byte Enable 3 */
 102 #define BE2             0x4000      /* Byte Enable 2 */
 103 #define BE1             0x2000      /* Byte Enable 1 */
 104 #define BE0             0x1000      /* Byte Enable 0 */
 105
 106 static u8 ks_rdreg8(struct eth_device *dev, u16 offset)
 107 {
 108         u8 shift_bit = offset & 0x03;
 109         u8 shift_data = (offset & 1) << 3;
 110
 111         writew(offset | (BE0 << shift_bit), dev->iobase + 2);
 112
 113         return (u8)(readw(dev->iobase) >> shift_data);
 114 }
 115
 116 static u16 ks_rdreg16(struct eth_device *dev, u16 offset)
 117 {
 118         writew(offset | ((BE1 | BE0) << (offset & 0x02)), dev->iobase + 2);
 119
 120         return readw(dev->iobase);
 121 }
 122
 123 static void ks_wrreg8(struct eth_device *dev, u16 offset, u8 val)
 124 {
 125         u8 shift_bit = (offset & 0x03);
 126         u16 value_write = (u16)(val << ((offset & 1) << 3));
 127
 128         writew(offset | (BE0 << shift_bit), dev->iobase + 2);
 129         writew(value_write, dev->iobase);
 130 }
 131
 132 static void ks_wrreg16(struct eth_device *dev, u16 offset, u16 val)
 133 {
 134         writew(offset | ((BE1 | BE0) << (offset & 0x02)), dev->iobase + 2);
 135         writew(val, dev->iobase);
 136 }
 137
 138 /*
 139  * ks_inblk - read a block of data from QMU. This is called after sudo DMA mode
 140  * enabled.
 141  * @ks: The chip state
 142  * @wptr: buffer address to save data
 143  * @len: length in byte to read
 144  */
 145 static inline void ks_inblk(struct eth_device *dev, u16 *wptr, u32 len)
 146 {
 147         len >>= 1;
 148
 149         while (len--)
 150                 *wptr++ = readw(dev->iobase);
 151 }
 152
 153 /*
 154  * ks_outblk - write data to QMU. This is called after sudo DMA mode enabled.
 155  * @ks: The chip information
 156  * @wptr: buffer address
 157  * @len: length in byte to write
 158  */
 159 static inline void ks_outblk(struct eth_device *dev, u16 *wptr, u32 len)
 160 {
 161         len >>= 1;
 162
 163         while (len--)
 164                 writew(*wptr++, dev->iobase);
 165 }
 166
 167 static void ks_enable_int(struct eth_device *dev)
 168 {
 169         ks_wrreg16(dev, KS_IER, ks->rc_ier);
 170 }
 171
 172 static void ks_set_powermode(struct eth_device *dev, unsigned pwrmode)
 173 {
 174         unsigned pmecr;
 175
 176         ks_rdreg16(dev, KS_GRR);
 177         pmecr = ks_rdreg16(dev, KS_PMECR);
 178         pmecr &= ~PMECR_PM_MASK;
 179         pmecr |= pwrmode;
 180
 181         ks_wrreg16(dev, KS_PMECR, pmecr);
 182 }
 183
 184 /*
 185  * ks_read_config - read chip configuration of bus width.
 186  * @ks: The chip information
 187  */
 188 static void ks_read_config(struct eth_device *dev)
 189 {
 190         u16 reg_data = 0;
 191
 192         /* Regardless of bus width, 8 bit read should always work. */
 193         reg_data = ks_rdreg8(dev, KS_CCR) & 0x00FF;
 194         reg_data |= ks_rdreg8(dev, KS_CCR + 1) << 8;
 195
 196         /* addr/data bus are multiplexed */
 197         ks->sharedbus = (reg_data & CCR_SHARED) == CCR_SHARED;
 198
 199         /*
 200          * There are garbage data when reading data from QMU,
 201          * depending on bus-width.
 202          */
 203         if (reg_data & CCR_8BIT) {
 204                 ks->bus_width = ENUM_BUS_8BIT;
 205                 ks->extra_byte = 1;
 206         } else if (reg_data & CCR_16BIT) {
 207                 ks->bus_width = ENUM_BUS_16BIT;
 208                 ks->extra_byte = 2;
 209         } else {
 210                 ks->bus_width = ENUM_BUS_32BIT;
 211                 ks->extra_byte = 4;
 212         }
 213 }
 214
 215 /*
 216  * ks_soft_reset - issue one of the soft reset to the device
 217  * @ks: The device state.
 218  * @op: The bit(s) to set in the GRR
 219  *
 220  * Issue the relevant soft-reset command to the device's GRR register
 221  * specified by @op.
 222  *
 223  * Note, the delays are in there as a caution to ensure that the reset
 224  * has time to take effect and then complete. Since the datasheet does
 225  * not currently specify the exact sequence, we have chosen something
 226  * that seems to work with our device.
 227  */
 228 static void ks_soft_reset(struct eth_device *dev, unsigned op)
 229 {
 230         /* Disable interrupt first */
 231         ks_wrreg16(dev, KS_IER, 0x0000);
 232         ks_wrreg16(dev, KS_GRR, op);
 233         mdelay(10);     /* wait a short time to effect reset */
 234         ks_wrreg16(dev, KS_GRR, 0);
 235         mdelay(1);      /* wait for condition to clear */
 236 }
 237
 238 void ks_enable_qmu(struct eth_device *dev)
 239 {
 240         u16 w;
 241
 242         w = ks_rdreg16(dev, KS_TXCR);
 243
 244         /* Enables QMU Transmit (TXCR). */
 245         ks_wrreg16(dev, KS_TXCR, w | TXCR_TXE);
 246
 247         /* Enable RX Frame Count Threshold and Auto-Dequeue RXQ Frame */
 248         w = ks_rdreg16(dev, KS_RXQCR);
 249         ks_wrreg16(dev, KS_RXQCR, w | RXQCR_RXFCTE);
 250
 251         /* Enables QMU Receive (RXCR1). */
 252         w = ks_rdreg16(dev, KS_RXCR1);
 253         ks_wrreg16(dev, KS_RXCR1, w | RXCR1_RXE);
 254 }
 255
 256 static void ks_disable_qmu(struct eth_device *dev)
 257 {
 258         u16 w;
 259
 260         w = ks_rdreg16(dev, KS_TXCR);
 261
 262         /* Disables QMU Transmit (TXCR). */
 263         w &= ~TXCR_TXE;
 264         ks_wrreg16(dev, KS_TXCR, w);
 265
 266         /* Disables QMU Receive (RXCR1). */
 267         w = ks_rdreg16(dev, KS_RXCR1);
 268         w &= ~RXCR1_RXE;
 269         ks_wrreg16(dev, KS_RXCR1, w);
 270 }
 271
 272 static inline void ks_read_qmu(struct eth_device *dev, u16 *buf, u32 len)
 273 {
 274         u32 r = ks->extra_byte & 0x1;
 275         u32 w = ks->extra_byte - r;
 276
 277         /* 1. set sudo DMA mode */
 278         ks_wrreg16(dev, KS_RXFDPR, RXFDPR_RXFPAI);
 279         ks_wrreg8(dev, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff);
 280
 281         /*
 282          * 2. read prepend data
 283          *
 284          * read 4 + extra bytes and discard them.
 285          * extra bytes for dummy, 2 for status, 2 for len
 286          */
 287
 288         if (r)
 289                 ks_rdreg8(dev, 0);
 290
 291         ks_inblk(dev, buf, w + 2 + 2);
 292
 293         /* 3. read pkt data */
 294         ks_inblk(dev, buf, ALIGN(len, 4));
 295
 296         /* 4. reset sudo DMA Mode */
 297         ks_wrreg8(dev, KS_RXQCR, (ks->rc_rxqcr & ~RXQCR_SDA) & 0xff);
 298 }
 299
 300 static void ks_rcv(struct eth_device *dev, uchar **pv_data)
 301 {
 302         struct type_frame_head *frame_hdr = ks->frame_head_info;
 303         int i;
 304
 305         ks->frame_cnt = ks_rdreg16(dev, KS_RXFCTR) >> 8;
 306
 307         /* read all header information */
 308         for (i = 0; i < ks->frame_cnt; i++) {
 309                 /* Checking Received packet status */
 310                 frame_hdr->sts = ks_rdreg16(dev, KS_RXFHSR);
 311                 /* Get packet len from hardware */
 312                 frame_hdr->len = ks_rdreg16(dev, KS_RXFHBCR);
 313                 frame_hdr++;
 314         }
 315
 316         frame_hdr = ks->frame_head_info;
 317         while (ks->frame_cnt--) {
 318                 if ((frame_hdr->sts & RXFSHR_RXFV) &&
 319                     (frame_hdr->len < RX_BUF_SIZE) &&
 320                     frame_hdr->len) {
 321                         /* read data block including CRC 4 bytes */
 322                         ks_read_qmu(dev, (u16 *)(*pv_data), frame_hdr->len);
 323
 324                         /* net_rx_packets buffer size is ok (*pv_data) */
 325                         net_process_received_packet(*pv_data, frame_hdr->len);
 326                         pv_data++;
 327                 } else {
 328                         ks_wrreg16(dev, KS_RXQCR, (ks->rc_rxqcr | RXQCR_RRXEF));
 329                         printf(DRIVERNAME ": bad packet\n");
 330                 }
 331                 frame_hdr++;
 332         }
 333 }
 334
 335 /*
 336  * ks_read_selftest - read the selftest memory info.
 337  * @ks: The device state
 338  *
 339  * Read and check the TX/RX memory selftest information.
 340  */
 341 static int ks_read_selftest(struct eth_device *dev)
 342 {
 343         u16 both_done = MBIR_TXMBF | MBIR_RXMBF;
 344         u16 mbir;
 345         int ret = 0;
 346
 347         mbir = ks_rdreg16(dev, KS_MBIR);
 348
 349         if ((mbir & both_done) != both_done) {
 350                 printf(DRIVERNAME ": Memory selftest not finished\n");
 351                 return 0;
 352         }
 353
 354         if (mbir & MBIR_TXMBFA) {
 355                 printf(DRIVERNAME ": TX memory selftest fails\n");
 356                 ret |= 1;
 357         }
 358
 359         if (mbir & MBIR_RXMBFA) {
 360                 printf(DRIVERNAME ": RX memory selftest fails\n");
 361                 ret |= 2;
 362         }
 363
 364         debug(DRIVERNAME ": the selftest passes\n");
 365
 366         return ret;
 367 }
 368
 369 static void ks_setup(struct eth_device *dev)
 370 {
 371         u16 w;
 372
 373         /* Setup Transmit Frame Data Pointer Auto-Increment (TXFDPR) */
 374         ks_wrreg16(dev, KS_TXFDPR, TXFDPR_TXFPAI);
 375
 376         /* Setup Receive Frame Data Pointer Auto-Increment */
 377         ks_wrreg16(dev, KS_RXFDPR, RXFDPR_RXFPAI);
 378
 379         /* Setup Receive Frame Threshold - 1 frame (RXFCTFC) */
 380         ks_wrreg16(dev, KS_RXFCTR, 1 & RXFCTR_THRESHOLD_MASK);
 381
 382         /* Setup RxQ Command Control (RXQCR) */
 383         ks->rc_rxqcr = RXQCR_CMD_CNTL;
 384         ks_wrreg16(dev, KS_RXQCR, ks->rc_rxqcr);
 385
 386         /*
 387          * set the force mode to half duplex, default is full duplex
 388          * because if the auto-negotiation fails, most switch uses
 389          * half-duplex.
 390          */
 391         w = ks_rdreg16(dev, KS_P1MBCR);
 392         w &= ~P1MBCR_FORCE_FDX;
 393         ks_wrreg16(dev, KS_P1MBCR, w);
 394
 395         w = TXCR_TXFCE | TXCR_TXPE | TXCR_TXCRC | TXCR_TCGIP;
 396         ks_wrreg16(dev, KS_TXCR, w);
 397
 398         w = RXCR1_RXFCE | RXCR1_RXBE | RXCR1_RXUE | RXCR1_RXME | RXCR1_RXIPFCC;
 399
 400         /* Normal mode */
 401         w |= RXCR1_RXPAFMA;
 402
 403         ks_wrreg16(dev, KS_RXCR1, w);
 404 }
 405
 406 static void ks_setup_int(struct eth_device *dev)
 407 {
 408         ks->rc_ier = 0x00;
 409
 410         /* Clear the interrupts status of the hardware. */
 411         ks_wrreg16(dev, KS_ISR, 0xffff);
 412
 413         /* Enables the interrupts of the hardware. */
 414         ks->rc_ier = (IRQ_LCI | IRQ_TXI | IRQ_RXI);
 415 }
 416
 417 static int ks8851_mll_detect_chip(struct eth_device *dev)
 418 {
 419         unsigned short val, i;
 420
 421         ks_read_config(dev);
 422
 423         val = ks_rdreg16(dev, KS_CIDER);
 424
 425         if (val == 0xffff) {
 426                 /* Special case -- no chip present */
 427                 printf(DRIVERNAME ":  is chip mounted ?\n");
 428                 return -1;
 429         } else if ((val & 0xfff0) != CIDER_ID) {
 430                 printf(DRIVERNAME ": Invalid chip id 0x%04x\n", val);
 431                 return -1;
 432         }
 433
 434         debug("Read back KS8851 id 0x%x\n", val);
 435
 436         /* only one entry in the table */
 437         val &= 0xfff0;
 438         for (i = 0; chip_ids[i].id != 0; i++) {
 439                 if (chip_ids[i].id == val)
 440                         break;
 441         }
 442         if (!chip_ids[i].id) {
 443                 printf(DRIVERNAME ": Unknown chip ID %04x\n", val);
 444                 return -1;
 445         }
 446
 447         dev->priv = (void *)&chip_ids[i];
 448
 449         return 0;
 450 }
 451
 452 static void ks8851_mll_reset(struct eth_device *dev)
 453 {
 454         /* wake up powermode to normal mode */
 455         ks_set_powermode(dev, PMECR_PM_NORMAL);
 456         mdelay(1);      /* wait for normal mode to take effect */
 457
 458         /* Disable interrupt and reset */
 459         ks_soft_reset(dev, GRR_GSR);
 460
 461         /* turn off the IRQs and ack any outstanding */
 462         ks_wrreg16(dev, KS_IER, 0x0000);
 463         ks_wrreg16(dev, KS_ISR, 0xffff);
 464
 465         /* shutdown RX/TX QMU */
 466         ks_disable_qmu(dev);
 467 }
 468
 469 static void ks8851_mll_phy_configure(struct eth_device *dev)
 470 {
 471         u16 data;
 472
 473         ks_setup(dev);
 474         ks_setup_int(dev);
 475
 476         /* Probing the phy */
 477         data = ks_rdreg16(dev, KS_OBCR);
 478         ks_wrreg16(dev, KS_OBCR, data | OBCR_ODS_16MA);
 479
 480         debug(DRIVERNAME ": phy initialized\n");
 481 }
 482
 483 static void ks8851_mll_enable(struct eth_device *dev)
 484 {
 485         ks_wrreg16(dev, KS_ISR, 0xffff);
 486         ks_enable_int(dev);
 487         ks_enable_qmu(dev);
 488 }
 489
 490 static int ks8851_mll_init(struct eth_device *dev, bd_t *bd)
 491 {
 492         struct chip_id *id = dev->priv;
 493
 494         debug(DRIVERNAME ": detected %s controller\n", id->name);
 495
 496         if (ks_read_selftest(dev)) {
 497                 printf(DRIVERNAME ": Selftest failed\n");
 498                 return -1;
 499         }
 500
 501         ks8851_mll_reset(dev);
 502
 503         /* Configure the PHY, initialize the link state */
 504         ks8851_mll_phy_configure(dev);
 505
 506         /* static allocation of private informations */
 507         ks->frame_head_info = fr_h_i;
 508
 509         /* Turn on Tx + Rx */
 510         ks8851_mll_enable(dev);
 511
 512         return 0;
 513 }
 514
 515 static void ks_write_qmu(struct eth_device *dev, u8 *pdata, u16 len)
 516 {
 517         /* start header at txb[0] to align txw entries */
 518         ks->txh.txw[0] = 0;
 519         ks->txh.txw[1] = cpu_to_le16(len);
 520
 521         /* 1. set sudo-DMA mode */
 522         ks_wrreg16(dev, KS_TXFDPR, TXFDPR_TXFPAI);
 523         ks_wrreg8(dev, KS_RXQCR, (ks->rc_rxqcr | RXQCR_SDA) & 0xff);
 524         /* 2. write status/lenth info */
 525         ks_outblk(dev, ks->txh.txw, 4);
 526         /* 3. write pkt data */
 527         ks_outblk(dev, (u16 *)pdata, ALIGN(len, 4));
 528         /* 4. reset sudo-DMA mode */
 529         ks_wrreg8(dev, KS_RXQCR, (ks->rc_rxqcr & ~RXQCR_SDA) & 0xff);
 530         /* 5. Enqueue Tx(move the pkt from TX buffer into TXQ) */
 531         ks_wrreg16(dev, KS_TXQCR, TXQCR_METFE);
 532         /* 6. wait until TXQCR_METFE is auto-cleared */
 533         do { } while (ks_rdreg16(dev, KS_TXQCR) & TXQCR_METFE);
 534 }
 535
 536 static int ks8851_mll_send(struct eth_device *dev, void *packet, int length)
 537 {
 538         u8 *data = (u8 *)packet;
 539         u16 tmplen = (u16)length;
 540         u16 retv;
 541
 542         /*
 543          * Extra space are required:
 544          * 4 byte for alignment, 4 for status/length, 4 for CRC
 545          */
 546         retv = ks_rdreg16(dev, KS_TXMIR) & 0x1fff;
 547         if (retv >= tmplen + 12) {
 548                 ks_write_qmu(dev, data, tmplen);
 549                 return 0;
 550         } else {
 551                 printf(DRIVERNAME ": failed to send packet: No buffer\n");
 552                 return -1;
 553         }
 554 }
 555
 556 static void ks8851_mll_halt(struct eth_device *dev)
 557 {
 558         ks8851_mll_reset(dev);
 559 }
 560
 561 /*
 562  * Maximum receive ring size; that is, the number of packets
 563  * we can buffer before overflow happens. Basically, this just
 564  * needs to be enough to prevent a packet being discarded while
 565  * we are processing the previous one.
 566  */
 567 static int ks8851_mll_recv(struct eth_device *dev)
 568 {
 569         u16 status;
 570
 571         status = ks_rdreg16(dev, KS_ISR);
 572
 573         ks_wrreg16(dev, KS_ISR, status);
 574
 575         if ((status & IRQ_RXI))
 576                 ks_rcv(dev, (uchar **)net_rx_packets);
 577
 578         if ((status & IRQ_LDI)) {
 579                 u16 pmecr = ks_rdreg16(dev, KS_PMECR);
 580                 pmecr &= ~PMECR_WKEVT_MASK;
 581                 ks_wrreg16(dev, KS_PMECR, pmecr | PMECR_WKEVT_LINK);
 582         }
 583
 584         return 0;
 585 }
 586
 587 static int ks8851_mll_write_hwaddr(struct eth_device *dev)
 588 {
 589         u16 addrl, addrm, addrh;
 590
 591         addrh = (dev->enetaddr[0] << 8) | dev->enetaddr[1];
 592         addrm = (dev->enetaddr[2] << 8) | dev->enetaddr[3];
 593         addrl = (dev->enetaddr[4] << 8) | dev->enetaddr[5];
 594
 595         ks_wrreg16(dev, KS_MARH, addrh);
 596         ks_wrreg16(dev, KS_MARM, addrm);
 597         ks_wrreg16(dev, KS_MARL, addrl);
 598
 599         return 0;
 600 }
 601
 602 int ks8851_mll_initialize(u8 dev_num, int base_addr)
 603 {
 604         struct eth_device *dev;
 605
 606         dev = malloc(sizeof(*dev));
 607         if (!dev) {
 608                 printf("Error: Failed to allocate memory\n");
 609                 return -1;
 610         }
 611         memset(dev, 0, sizeof(*dev));
 612
 613         dev->iobase = base_addr;
 614
 615         ks = &ks_str;
 616
 617         /* Try to detect chip. Will fail if not present. */
 618         if (ks8851_mll_detect_chip(dev)) {
 619                 free(dev);
 620                 return -1;
 621         }
 622
 623         dev->init = ks8851_mll_init;
 624         dev->halt = ks8851_mll_halt;
 625         dev->send = ks8851_mll_send;
 626         dev->recv = ks8851_mll_recv;
 627         dev->write_hwaddr = ks8851_mll_write_hwaddr;
 628         sprintf(dev->name, "%s-%hu", DRIVERNAME, dev_num);
 629
 630         eth_register(dev);
 631
 632         return 0;
 633 }