1 /* SPDX-License-Identifier: BSD-3-Clause 2 * 3 * Copyright 2017,2020 NXP 4 * 5 */ 6 7 #include <sys/types.h> 8 #include <sys/ioctl.h> 9 #include <ifaddrs.h> 10 #include <fman.h> 11 /* This header declares things about Fman hardware itself (the format of status 12 * words and an inline implementation of CRC64). We include it only in order to 13 * instantiate the one global variable it depends on. 14 */ 15 #include <fsl_fman.h> 16 #include <fsl_fman_crc64.h> 17 #include <fsl_bman.h> 18 19 #define FMAN_SP_SG_DISABLE 0x80000000 20 #define FMAN_SP_EXT_BUF_MARG_START_SHIFT 16 21 22 /* Instantiate the global variable that the inline CRC64 implementation (in 23 * <fsl_fman.h>) depends on. 24 */ 25 DECLARE_FMAN_CRC64_TABLE(); 26 27 #define ETH_ADDR_TO_UINT64(eth_addr) \ 28 (uint64_t)(((uint64_t)(eth_addr)[0] << 40) | \ 29 ((uint64_t)(eth_addr)[1] << 32) | \ 30 ((uint64_t)(eth_addr)[2] << 24) | \ 31 ((uint64_t)(eth_addr)[3] << 16) | \ 32 ((uint64_t)(eth_addr)[4] << 8) | \ 33 ((uint64_t)(eth_addr)[5])) 34 35 void 36 fman_if_set_mcast_filter_table(struct fman_if *p) 37 { 38 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 39 void *hashtable_ctrl; 40 uint32_t i; 41 42 hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; 43 for (i = 0; i < 64; i++) 44 out_be32(hashtable_ctrl, i|HASH_CTRL_MCAST_EN); 45 } 46 47 void 48 fman_if_reset_mcast_filter_table(struct fman_if *p) 49 { 50 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 51 void *hashtable_ctrl; 52 uint32_t i; 53 54 hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; 55 for (i = 0; i < 64; i++) 56 out_be32(hashtable_ctrl, i & ~HASH_CTRL_MCAST_EN); 57 } 58 59 static 60 uint32_t get_mac_hash_code(uint64_t eth_addr) 61 { 62 uint64_t mask1, mask2; 63 uint32_t xorVal = 0; 64 uint8_t i, j; 65 66 for (i = 0; i < 6; i++) { 67 mask1 = eth_addr & (uint64_t)0x01; 68 eth_addr >>= 1; 69 70 for (j = 0; j < 7; j++) { 71 mask2 = eth_addr & (uint64_t)0x01; 72 mask1 ^= mask2; 73 eth_addr >>= 1; 74 } 75 76 xorVal |= (mask1 << (5 - i)); 77 } 78 79 return xorVal; 80 } 81 82 int 83 fman_if_add_hash_mac_addr(struct fman_if *p, uint8_t *eth) 84 { 85 uint64_t eth_addr; 86 void *hashtable_ctrl; 87 uint32_t hash; 88 89 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 90 91 eth_addr = ETH_ADDR_TO_UINT64(eth); 92 93 if (!(eth_addr & GROUP_ADDRESS)) 94 return -1; 95 96 hash = get_mac_hash_code(eth_addr) & HASH_CTRL_ADDR_MASK; 97 hash = hash | HASH_CTRL_MCAST_EN; 98 99 hashtable_ctrl = &((struct memac_regs *)__if->ccsr_map)->hashtable_ctrl; 100 out_be32(hashtable_ctrl, hash); 101 102 return 0; 103 } 104 105 int 106 fman_if_get_primary_mac_addr(struct fman_if *p, uint8_t *eth) 107 { 108 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 109 void *mac_reg = 110 &((struct memac_regs *)__if->ccsr_map)->mac_addr0.mac_addr_l; 111 u32 val = in_be32(mac_reg); 112 113 eth[0] = (val & 0x000000ff) >> 0; 114 eth[1] = (val & 0x0000ff00) >> 8; 115 eth[2] = (val & 0x00ff0000) >> 16; 116 eth[3] = (val & 0xff000000) >> 24; 117 118 mac_reg = &((struct memac_regs *)__if->ccsr_map)->mac_addr0.mac_addr_u; 119 val = in_be32(mac_reg); 120 121 eth[4] = (val & 0x000000ff) >> 0; 122 eth[5] = (val & 0x0000ff00) >> 8; 123 124 return 0; 125 } 126 127 void 128 fman_if_clear_mac_addr(struct fman_if *p, uint8_t addr_num) 129 { 130 struct __fman_if *m = container_of(p, struct __fman_if, __if); 131 void *reg; 132 133 if (addr_num) { 134 reg = &((struct memac_regs *)m->ccsr_map)-> 135 mac_addr[addr_num-1].mac_addr_l; 136 out_be32(reg, 0x0); 137 reg = &((struct memac_regs *)m->ccsr_map)-> 138 mac_addr[addr_num-1].mac_addr_u; 139 out_be32(reg, 0x0); 140 } else { 141 reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_l; 142 out_be32(reg, 0x0); 143 reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_u; 144 out_be32(reg, 0x0); 145 } 146 } 147 148 int 149 fman_if_add_mac_addr(struct fman_if *p, uint8_t *eth, uint8_t addr_num) 150 { 151 struct __fman_if *m = container_of(p, struct __fman_if, __if); 152 153 void *reg; 154 u32 val; 155 156 memcpy(&m->__if.mac_addr, eth, ETHER_ADDR_LEN); 157 158 if (addr_num) 159 reg = &((struct memac_regs *)m->ccsr_map)-> 160 mac_addr[addr_num-1].mac_addr_l; 161 else 162 reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_l; 163 164 val = (m->__if.mac_addr.addr_bytes[0] | 165 (m->__if.mac_addr.addr_bytes[1] << 8) | 166 (m->__if.mac_addr.addr_bytes[2] << 16) | 167 (m->__if.mac_addr.addr_bytes[3] << 24)); 168 out_be32(reg, val); 169 170 if (addr_num) 171 reg = &((struct memac_regs *)m->ccsr_map)-> 172 mac_addr[addr_num-1].mac_addr_u; 173 else 174 reg = &((struct memac_regs *)m->ccsr_map)->mac_addr0.mac_addr_u; 175 176 val = ((m->__if.mac_addr.addr_bytes[4] << 0) | 177 (m->__if.mac_addr.addr_bytes[5] << 8)); 178 out_be32(reg, val); 179 180 return 0; 181 } 182 183 void 184 fman_if_set_rx_ignore_pause_frames(struct fman_if *p, bool enable) 185 { 186 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 187 u32 value = 0; 188 void *cmdcfg; 189 190 assert(fman_ccsr_map_fd != -1); 191 192 /* Set Rx Ignore Pause Frames */ 193 cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; 194 if (enable) 195 value = in_be32(cmdcfg) | CMD_CFG_PAUSE_IGNORE; 196 else 197 value = in_be32(cmdcfg) & ~CMD_CFG_PAUSE_IGNORE; 198 199 out_be32(cmdcfg, value); 200 } 201 202 void 203 fman_if_conf_max_frame_len(struct fman_if *p, unsigned int max_frame_len) 204 { 205 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 206 unsigned int *maxfrm; 207 208 assert(fman_ccsr_map_fd != -1); 209 210 /* Set Max frame length */ 211 maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; 212 out_be32(maxfrm, (MAXFRM_RX_MASK & max_frame_len)); 213 } 214 215 void 216 fman_if_stats_get(struct fman_if *p, struct rte_eth_stats *stats) 217 { 218 struct __fman_if *m = container_of(p, struct __fman_if, __if); 219 struct memac_regs *regs = m->ccsr_map; 220 221 /* read recved packet count */ 222 stats->ipackets = (u64)in_be32(®s->rfrm_l) | 223 ((u64)in_be32(®s->rfrm_u)) << 32; 224 stats->ibytes = (u64)in_be32(®s->roct_l) | 225 ((u64)in_be32(®s->roct_u)) << 32; 226 stats->ierrors = (u64)in_be32(®s->rerr_l) | 227 ((u64)in_be32(®s->rerr_u)) << 32; 228 229 /* read xmited packet count */ 230 stats->opackets = (u64)in_be32(®s->tfrm_l) | 231 ((u64)in_be32(®s->tfrm_u)) << 32; 232 stats->obytes = (u64)in_be32(®s->toct_l) | 233 ((u64)in_be32(®s->toct_u)) << 32; 234 stats->oerrors = (u64)in_be32(®s->terr_l) | 235 ((u64)in_be32(®s->terr_u)) << 32; 236 } 237 238 void 239 fman_if_stats_get_all(struct fman_if *p, uint64_t *value, int n) 240 { 241 struct __fman_if *m = container_of(p, struct __fman_if, __if); 242 struct memac_regs *regs = m->ccsr_map; 243 int i; 244 uint64_t base_offset = offsetof(struct memac_regs, reoct_l); 245 246 for (i = 0; i < n; i++) 247 value[i] = (((u64)in_be32((char *)regs + base_offset + 8 * i) | 248 (u64)in_be32((char *)regs + base_offset + 249 8 * i + 4)) << 32); 250 } 251 252 void 253 fman_if_stats_reset(struct fman_if *p) 254 { 255 struct __fman_if *m = container_of(p, struct __fman_if, __if); 256 struct memac_regs *regs = m->ccsr_map; 257 uint32_t tmp; 258 259 tmp = in_be32(®s->statn_config); 260 261 tmp |= STATS_CFG_CLR; 262 263 out_be32(®s->statn_config, tmp); 264 265 while (in_be32(®s->statn_config) & STATS_CFG_CLR) 266 ; 267 } 268 269 void 270 fman_if_promiscuous_enable(struct fman_if *p) 271 { 272 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 273 void *cmdcfg; 274 275 assert(fman_ccsr_map_fd != -1); 276 277 /* Enable Rx promiscuous mode */ 278 cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; 279 out_be32(cmdcfg, in_be32(cmdcfg) | CMD_CFG_PROMIS_EN); 280 } 281 282 void 283 fman_if_promiscuous_disable(struct fman_if *p) 284 { 285 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 286 void *cmdcfg; 287 288 assert(fman_ccsr_map_fd != -1); 289 290 /* Disable Rx promiscuous mode */ 291 cmdcfg = &((struct memac_regs *)__if->ccsr_map)->command_config; 292 out_be32(cmdcfg, in_be32(cmdcfg) & (~CMD_CFG_PROMIS_EN)); 293 } 294 295 void 296 fman_if_enable_rx(struct fman_if *p) 297 { 298 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 299 300 assert(fman_ccsr_map_fd != -1); 301 302 /* enable Rx and Tx */ 303 out_be32(__if->ccsr_map + 8, in_be32(__if->ccsr_map + 8) | 3); 304 } 305 306 void 307 fman_if_disable_rx(struct fman_if *p) 308 { 309 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 310 311 assert(fman_ccsr_map_fd != -1); 312 313 /* only disable Rx, not Tx */ 314 out_be32(__if->ccsr_map + 8, in_be32(__if->ccsr_map + 8) & ~(u32)2); 315 } 316 317 void 318 fman_if_loopback_enable(struct fman_if *p) 319 { 320 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 321 322 assert(fman_ccsr_map_fd != -1); 323 324 /* Enable loopback mode */ 325 if ((__if->__if.is_memac) && (__if->__if.is_rgmii)) { 326 unsigned int *ifmode = 327 &((struct memac_regs *)__if->ccsr_map)->if_mode; 328 out_be32(ifmode, in_be32(ifmode) | IF_MODE_RLP); 329 } else{ 330 unsigned int *cmdcfg = 331 &((struct memac_regs *)__if->ccsr_map)->command_config; 332 out_be32(cmdcfg, in_be32(cmdcfg) | CMD_CFG_LOOPBACK_EN); 333 } 334 } 335 336 void 337 fman_if_loopback_disable(struct fman_if *p) 338 { 339 struct __fman_if *__if = container_of(p, struct __fman_if, __if); 340 341 assert(fman_ccsr_map_fd != -1); 342 /* Disable loopback mode */ 343 if ((__if->__if.is_memac) && (__if->__if.is_rgmii)) { 344 unsigned int *ifmode = 345 &((struct memac_regs *)__if->ccsr_map)->if_mode; 346 out_be32(ifmode, in_be32(ifmode) & ~IF_MODE_RLP); 347 } else { 348 unsigned int *cmdcfg = 349 &((struct memac_regs *)__if->ccsr_map)->command_config; 350 out_be32(cmdcfg, in_be32(cmdcfg) & ~CMD_CFG_LOOPBACK_EN); 351 } 352 } 353 354 void 355 fman_if_set_bp(struct fman_if *fm_if, unsigned num __always_unused, 356 int bpid, size_t bufsize) 357 { 358 u32 fmbm_ebmpi; 359 u32 ebmpi_val_ace = 0xc0000000; 360 u32 ebmpi_mask = 0xffc00000; 361 362 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 363 364 assert(fman_ccsr_map_fd != -1); 365 366 fmbm_ebmpi = 367 in_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ebmpi[0]); 368 fmbm_ebmpi = ebmpi_val_ace | (fmbm_ebmpi & ebmpi_mask) | (bpid << 16) | 369 (bufsize); 370 371 out_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ebmpi[0], 372 fmbm_ebmpi); 373 } 374 375 int 376 fman_if_get_fc_threshold(struct fman_if *fm_if) 377 { 378 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 379 unsigned int *fmbm_mpd; 380 381 assert(fman_ccsr_map_fd != -1); 382 383 fmbm_mpd = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_mpd; 384 return in_be32(fmbm_mpd); 385 } 386 387 int 388 fman_if_set_fc_threshold(struct fman_if *fm_if, u32 high_water, 389 u32 low_water, u32 bpid) 390 { 391 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 392 unsigned int *fmbm_mpd; 393 394 assert(fman_ccsr_map_fd != -1); 395 396 fmbm_mpd = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_mpd; 397 out_be32(fmbm_mpd, FMAN_ENABLE_BPOOL_DEPLETION); 398 return bm_pool_set_hw_threshold(bpid, low_water, high_water); 399 400 } 401 402 int 403 fman_if_get_fc_quanta(struct fman_if *fm_if) 404 { 405 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 406 407 assert(fman_ccsr_map_fd != -1); 408 409 return in_be32(&((struct memac_regs *)__if->ccsr_map)->pause_quanta[0]); 410 } 411 412 int 413 fman_if_set_fc_quanta(struct fman_if *fm_if, u16 pause_quanta) 414 { 415 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 416 417 assert(fman_ccsr_map_fd != -1); 418 419 out_be32(&((struct memac_regs *)__if->ccsr_map)->pause_quanta[0], 420 pause_quanta); 421 return 0; 422 } 423 424 int 425 fman_if_get_fdoff(struct fman_if *fm_if) 426 { 427 u32 fmbm_rebm; 428 int fdoff; 429 430 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 431 432 assert(fman_ccsr_map_fd != -1); 433 434 fmbm_rebm = in_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rebm); 435 436 fdoff = (fmbm_rebm >> FMAN_SP_EXT_BUF_MARG_START_SHIFT) & 0x1ff; 437 438 return fdoff; 439 } 440 441 void 442 fman_if_set_err_fqid(struct fman_if *fm_if, uint32_t err_fqid) 443 { 444 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 445 446 assert(fman_ccsr_map_fd != -1); 447 448 unsigned int *fmbm_refqid = 449 &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_refqid; 450 out_be32(fmbm_refqid, err_fqid); 451 } 452 453 int 454 fman_if_get_ic_params(struct fman_if *fm_if, struct fman_if_ic_params *icp) 455 { 456 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 457 int val = 0; 458 int iceof_mask = 0x001f0000; 459 int icsz_mask = 0x0000001f; 460 int iciof_mask = 0x00000f00; 461 462 assert(fman_ccsr_map_fd != -1); 463 464 unsigned int *fmbm_ricp = 465 &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ricp; 466 val = in_be32(fmbm_ricp); 467 468 icp->iceof = (val & iceof_mask) >> 12; 469 icp->iciof = (val & iciof_mask) >> 4; 470 icp->icsz = (val & icsz_mask) << 4; 471 472 return 0; 473 } 474 475 int 476 fman_if_set_ic_params(struct fman_if *fm_if, 477 const struct fman_if_ic_params *icp) 478 { 479 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 480 int val = 0; 481 int iceof_mask = 0x001f0000; 482 int icsz_mask = 0x0000001f; 483 int iciof_mask = 0x00000f00; 484 485 assert(fman_ccsr_map_fd != -1); 486 487 val |= (icp->iceof << 12) & iceof_mask; 488 val |= (icp->iciof << 4) & iciof_mask; 489 val |= (icp->icsz >> 4) & icsz_mask; 490 491 unsigned int *fmbm_ricp = 492 &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_ricp; 493 out_be32(fmbm_ricp, val); 494 495 return 0; 496 } 497 498 void 499 fman_if_set_fdoff(struct fman_if *fm_if, uint32_t fd_offset) 500 { 501 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 502 unsigned int *fmbm_rebm; 503 int val = 0; 504 int fmbm_mask = 0x01ff0000; 505 506 val = fd_offset << FMAN_SP_EXT_BUF_MARG_START_SHIFT; 507 508 assert(fman_ccsr_map_fd != -1); 509 510 fmbm_rebm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rebm; 511 512 out_be32(fmbm_rebm, (in_be32(fmbm_rebm) & ~fmbm_mask) | val); 513 } 514 515 void 516 fman_if_set_maxfrm(struct fman_if *fm_if, uint16_t max_frm) 517 { 518 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 519 unsigned int *reg_maxfrm; 520 521 assert(fman_ccsr_map_fd != -1); 522 523 reg_maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; 524 525 out_be32(reg_maxfrm, (in_be32(reg_maxfrm) & 0xFFFF0000) | max_frm); 526 } 527 528 uint16_t 529 fman_if_get_maxfrm(struct fman_if *fm_if) 530 { 531 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 532 unsigned int *reg_maxfrm; 533 534 assert(fman_ccsr_map_fd != -1); 535 536 reg_maxfrm = &((struct memac_regs *)__if->ccsr_map)->maxfrm; 537 538 return (in_be32(reg_maxfrm) | 0x0000FFFF); 539 } 540 541 /* MSB in fmbm_rebm register 542 * 0 - If BMI cannot store the frame in a single buffer it may select a buffer 543 * of smaller size and store the frame in scatter gather (S/G) buffers 544 * 1 - Scatter gather format is not enabled for frame storage. If BMI cannot 545 * store the frame in a single buffer, the frame is discarded. 546 */ 547 548 int 549 fman_if_get_sg_enable(struct fman_if *fm_if) 550 { 551 u32 fmbm_rebm; 552 553 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 554 555 assert(fman_ccsr_map_fd != -1); 556 557 fmbm_rebm = in_be32(&((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rebm); 558 559 return (fmbm_rebm & FMAN_SP_SG_DISABLE) ? 0 : 1; 560 } 561 562 void 563 fman_if_set_sg(struct fman_if *fm_if, int enable) 564 { 565 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 566 unsigned int *fmbm_rebm; 567 int val; 568 int fmbm_mask = FMAN_SP_SG_DISABLE; 569 570 if (enable) 571 val = 0; 572 else 573 val = FMAN_SP_SG_DISABLE; 574 575 assert(fman_ccsr_map_fd != -1); 576 577 fmbm_rebm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rebm; 578 579 out_be32(fmbm_rebm, (in_be32(fmbm_rebm) & ~fmbm_mask) | val); 580 } 581 582 void 583 fman_if_set_dnia(struct fman_if *fm_if, uint32_t nia) 584 { 585 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 586 unsigned int *fmqm_pndn; 587 588 assert(fman_ccsr_map_fd != -1); 589 590 fmqm_pndn = &((struct fman_port_qmi_regs *)__if->qmi_map)->fmqm_pndn; 591 592 out_be32(fmqm_pndn, nia); 593 } 594 595 void 596 fman_if_discard_rx_errors(struct fman_if *fm_if) 597 { 598 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 599 unsigned int *fmbm_rfsdm, *fmbm_rfsem; 600 601 fmbm_rfsem = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsem; 602 out_be32(fmbm_rfsem, 0); 603 604 /* Configure the discard mask to discard the error packets which have 605 * DMA errors, Frame size error, Header error etc. The mask 0x010EE3F0 606 * is to configured discard all the errors which come in the FD[STATUS] 607 */ 608 fmbm_rfsdm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsdm; 609 out_be32(fmbm_rfsdm, 0x010EE3F0); 610 } 611 612 void 613 fman_if_receive_rx_errors(struct fman_if *fm_if, 614 unsigned int err_eq) 615 { 616 struct __fman_if *__if = container_of(fm_if, struct __fman_if, __if); 617 unsigned int *fmbm_rcfg, *fmbm_rfsdm, *fmbm_rfsem; 618 unsigned int val; 619 620 fmbm_rcfg = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rcfg; 621 fmbm_rfsdm = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsdm; 622 fmbm_rfsem = &((struct rx_bmi_regs *)__if->bmi_map)->fmbm_rfsem; 623 624 val = in_be32(fmbm_rcfg); 625 out_be32(fmbm_rcfg, val | BMI_PORT_CFG_FDOVR); 626 627 out_be32(fmbm_rfsdm, 0); 628 out_be32(fmbm_rfsem, err_eq); 629 } 630