drivers/net/ethernet/microchip/lan966x/lan966x_mac.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 #include <net/switchdev.h>
   4 #include "lan966x_main.h"
   5
   6 #define LAN966X_MAC_COLUMNS             4
   7 #define MACACCESS_CMD_IDLE              0
   8 #define MACACCESS_CMD_LEARN             1
   9 #define MACACCESS_CMD_FORGET            2
  10 #define MACACCESS_CMD_AGE               3
  11 #define MACACCESS_CMD_GET_NEXT          4
  12 #define MACACCESS_CMD_INIT              5
  13 #define MACACCESS_CMD_READ              6
  14 #define MACACCESS_CMD_WRITE             7
  15 #define MACACCESS_CMD_SYNC_GET_NEXT     8
  16
  17 #define LAN966X_MAC_INVALID_ROW         -1
  18
  19 struct lan966x_mac_entry {
  20         struct list_head list;
  21         unsigned char mac[ETH_ALEN] __aligned(2);
  22         u16 vid;
  23         u16 port_index;
  24         int row;
  25         bool lag;
  26 };
  27
  28 struct lan966x_mac_raw_entry {
  29         u32 mach;
  30         u32 macl;
  31         u32 maca;
  32         bool processed;
  33 };
  34
  35 static int lan966x_mac_get_status(struct lan966x *lan966x)
  36 {
  37         return lan_rd(lan966x, ANA_MACACCESS);
  38 }
  39
  40 static int lan966x_mac_wait_for_completion(struct lan966x *lan966x)
  41 {
  42         u32 val;
  43
  44         return readx_poll_timeout_atomic(lan966x_mac_get_status,
  45                                          lan966x, val,
  46                                          (ANA_MACACCESS_MAC_TABLE_CMD_GET(val)) ==
  47                                          MACACCESS_CMD_IDLE,
  48                                          TABLE_UPDATE_SLEEP_US,
  49                                          TABLE_UPDATE_TIMEOUT_US);
  50 }
  51
  52 static void lan966x_mac_select(struct lan966x *lan966x,
  53                                const unsigned char mac[ETH_ALEN],
  54                                unsigned int vid)
  55 {
  56         u32 macl = 0, mach = 0;
  57
  58         /* Set the MAC address to handle and the vlan associated in a format
  59          * understood by the hardware.
  60          */
  61         mach |= vid    << 16;
  62         mach |= mac[0] << 8;
  63         mach |= mac[1] << 0;
  64         macl |= mac[2] << 24;
  65         macl |= mac[3] << 16;
  66         macl |= mac[4] << 8;
  67         macl |= mac[5] << 0;
  68
  69         lan_wr(macl, lan966x, ANA_MACLDATA);
  70         lan_wr(mach, lan966x, ANA_MACHDATA);
  71 }
  72
  73 static int __lan966x_mac_learn_locked(struct lan966x *lan966x, int pgid,
  74                                       bool cpu_copy,
  75                                       const unsigned char mac[ETH_ALEN],
  76                                       unsigned int vid,
  77                                       enum macaccess_entry_type type)
  78 {
  79         lockdep_assert_held(&lan966x->mac_lock);
  80
  81         lan966x_mac_select(lan966x, mac, vid);
  82
  83         /* Issue a write command */
  84         lan_wr(ANA_MACACCESS_VALID_SET(1) |
  85                ANA_MACACCESS_CHANGE2SW_SET(0) |
  86                ANA_MACACCESS_MAC_CPU_COPY_SET(cpu_copy) |
  87                ANA_MACACCESS_DEST_IDX_SET(pgid) |
  88                ANA_MACACCESS_ENTRYTYPE_SET(type) |
  89                ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_LEARN),
  90                lan966x, ANA_MACACCESS);
  91
  92         return lan966x_mac_wait_for_completion(lan966x);
  93 }
  94
  95 static int __lan966x_mac_learn(struct lan966x *lan966x, int pgid,
  96                                bool cpu_copy,
  97                                const unsigned char mac[ETH_ALEN],
  98                                unsigned int vid,
  99                                enum macaccess_entry_type type)
 100 {
 101         int ret;
 102
 103         spin_lock(&lan966x->mac_lock);
 104         ret = __lan966x_mac_learn_locked(lan966x, pgid, cpu_copy, mac, vid, type);
 105         spin_unlock(&lan966x->mac_lock);
 106
 107         return ret;
 108 }
 109
 110 /* The mask of the front ports is encoded inside the mac parameter via a call
 111  * to lan966x_mdb_encode_mac().
 112  */
 113 int lan966x_mac_ip_learn(struct lan966x *lan966x,
 114                          bool cpu_copy,
 115                          const unsigned char mac[ETH_ALEN],
 116                          unsigned int vid,
 117                          enum macaccess_entry_type type)
 118 {
 119         WARN_ON(type != ENTRYTYPE_MACV4 && type != ENTRYTYPE_MACV6);
 120
 121         return __lan966x_mac_learn(lan966x, 0, cpu_copy, mac, vid, type);
 122 }
 123
 124 int lan966x_mac_learn(struct lan966x *lan966x, int port,
 125                       const unsigned char mac[ETH_ALEN],
 126                       unsigned int vid,
 127                       enum macaccess_entry_type type)
 128 {
 129         WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);
 130
 131         return __lan966x_mac_learn(lan966x, port, false, mac, vid, type);
 132 }
 133
 134 static int lan966x_mac_learn_locked(struct lan966x *lan966x, int port,
 135                                     const unsigned char mac[ETH_ALEN],
 136                                     unsigned int vid,
 137                                     enum macaccess_entry_type type)
 138 {
 139         WARN_ON(type != ENTRYTYPE_NORMAL && type != ENTRYTYPE_LOCKED);
 140
 141         return __lan966x_mac_learn_locked(lan966x, port, false, mac, vid, type);
 142 }
 143
 144 static int lan966x_mac_forget_locked(struct lan966x *lan966x,
 145                                      const unsigned char mac[ETH_ALEN],
 146                                      unsigned int vid,
 147                                      enum macaccess_entry_type type)
 148 {
 149         lockdep_assert_held(&lan966x->mac_lock);
 150
 151         lan966x_mac_select(lan966x, mac, vid);
 152
 153         /* Issue a forget command */
 154         lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) |
 155                ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_FORGET),
 156                lan966x, ANA_MACACCESS);
 157
 158         return lan966x_mac_wait_for_completion(lan966x);
 159 }
 160
 161 int lan966x_mac_forget(struct lan966x *lan966x,
 162                        const unsigned char mac[ETH_ALEN],
 163                        unsigned int vid,
 164                        enum macaccess_entry_type type)
 165 {
 166         int ret;
 167
 168         spin_lock(&lan966x->mac_lock);
 169         ret = lan966x_mac_forget_locked(lan966x, mac, vid, type);
 170         spin_unlock(&lan966x->mac_lock);
 171
 172         return ret;
 173 }
 174
 175 int lan966x_mac_cpu_learn(struct lan966x *lan966x, const char *addr, u16 vid)
 176 {
 177         return lan966x_mac_learn(lan966x, PGID_CPU, addr, vid, ENTRYTYPE_LOCKED);
 178 }
 179
 180 int lan966x_mac_cpu_forget(struct lan966x *lan966x, const char *addr, u16 vid)
 181 {
 182         return lan966x_mac_forget(lan966x, addr, vid, ENTRYTYPE_LOCKED);
 183 }
 184
 185 void lan966x_mac_set_ageing(struct lan966x *lan966x,
 186                             u32 ageing)
 187 {
 188         lan_rmw(ANA_AUTOAGE_AGE_PERIOD_SET(ageing / 2),
 189                 ANA_AUTOAGE_AGE_PERIOD,
 190                 lan966x, ANA_AUTOAGE);
 191 }
 192
 193 void lan966x_mac_init(struct lan966x *lan966x)
 194 {
 195         /* Clear the MAC table */
 196         lan_wr(MACACCESS_CMD_INIT, lan966x, ANA_MACACCESS);
 197         lan966x_mac_wait_for_completion(lan966x);
 198
 199         spin_lock_init(&lan966x->mac_lock);
 200         INIT_LIST_HEAD(&lan966x->mac_entries);
 201 }
 202
 203 static struct lan966x_mac_entry *lan966x_mac_alloc_entry(struct lan966x_port *port,
 204                                                          const unsigned char *mac,
 205                                                          u16 vid)
 206 {
 207         struct lan966x_mac_entry *mac_entry;
 208
 209         mac_entry = kzalloc(sizeof(*mac_entry), GFP_ATOMIC);
 210         if (!mac_entry)
 211                 return NULL;
 212
 213         memcpy(mac_entry->mac, mac, ETH_ALEN);
 214         mac_entry->vid = vid;
 215         mac_entry->port_index = port->chip_port;
 216         mac_entry->row = LAN966X_MAC_INVALID_ROW;
 217         mac_entry->lag = port->bond ? true : false;
 218         return mac_entry;
 219 }
 220
 221 static struct lan966x_mac_entry *lan966x_mac_find_entry(struct lan966x *lan966x,
 222                                                         const unsigned char *mac,
 223                                                         u16 vid, u16 port_index)
 224 {
 225         struct lan966x_mac_entry *res = NULL;
 226         struct lan966x_mac_entry *mac_entry;
 227
 228         list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
 229                 if (mac_entry->vid == vid &&
 230                     ether_addr_equal(mac, mac_entry->mac) &&
 231                     mac_entry->port_index == port_index) {
 232                         res = mac_entry;
 233                         break;
 234                 }
 235         }
 236
 237         return res;
 238 }
 239
 240 static int lan966x_mac_lookup(struct lan966x *lan966x,
 241                               const unsigned char mac[ETH_ALEN],
 242                               unsigned int vid, enum macaccess_entry_type type)
 243 {
 244         int ret;
 245
 246         lan966x_mac_select(lan966x, mac, vid);
 247
 248         /* Issue a read command */
 249         lan_wr(ANA_MACACCESS_ENTRYTYPE_SET(type) |
 250                ANA_MACACCESS_VALID_SET(1) |
 251                ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_READ),
 252                lan966x, ANA_MACACCESS);
 253
 254         ret = lan966x_mac_wait_for_completion(lan966x);
 255         if (ret)
 256                 return ret;
 257
 258         return ANA_MACACCESS_VALID_GET(lan_rd(lan966x, ANA_MACACCESS));
 259 }
 260
 261 static void lan966x_fdb_call_notifiers(enum switchdev_notifier_type type,
 262                                        const char *mac, u16 vid,
 263                                        struct net_device *dev)
 264 {
 265         struct switchdev_notifier_fdb_info info = { 0 };
 266
 267         info.addr = mac;
 268         info.vid = vid;
 269         info.offloaded = true;
 270         call_switchdev_notifiers(type, dev, &info.info, NULL);
 271 }
 272
 273 int lan966x_mac_add_entry(struct lan966x *lan966x, struct lan966x_port *port,
 274                           const unsigned char *addr, u16 vid)
 275 {
 276         struct lan966x_mac_entry *mac_entry;
 277
 278         spin_lock(&lan966x->mac_lock);
 279         if (lan966x_mac_lookup(lan966x, addr, vid, ENTRYTYPE_NORMAL)) {
 280                 spin_unlock(&lan966x->mac_lock);
 281                 return 0;
 282         }
 283
 284         /* In case the entry already exists, don't add it again to SW,
 285          * just update HW, but we need to look in the actual HW because
 286          * it is possible for an entry to be learn by HW and before we
 287          * get the interrupt the frame will reach CPU and the CPU will
 288          * add the entry but without the extern_learn flag.
 289          */
 290         mac_entry = lan966x_mac_find_entry(lan966x, addr, vid, port->chip_port);
 291         if (mac_entry) {
 292                 spin_unlock(&lan966x->mac_lock);
 293                 goto mac_learn;
 294         }
 295
 296         mac_entry = lan966x_mac_alloc_entry(port, addr, vid);
 297         if (!mac_entry) {
 298                 spin_unlock(&lan966x->mac_lock);
 299                 return -ENOMEM;
 300         }
 301
 302         list_add_tail(&mac_entry->list, &lan966x->mac_entries);
 303         spin_unlock(&lan966x->mac_lock);
 304
 305         lan966x_fdb_call_notifiers(SWITCHDEV_FDB_OFFLOADED, addr, vid,
 306                                    port->bond ?: port->dev);
 307
 308 mac_learn:
 309         lan966x_mac_learn(lan966x, port->chip_port, addr, vid, ENTRYTYPE_LOCKED);
 310
 311         return 0;
 312 }
 313
 314 int lan966x_mac_del_entry(struct lan966x *lan966x, const unsigned char *addr,
 315                           u16 vid)
 316 {
 317         struct lan966x_mac_entry *mac_entry, *tmp;
 318
 319         spin_lock(&lan966x->mac_lock);
 320         list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 321                                  list) {
 322                 if (mac_entry->vid == vid &&
 323                     ether_addr_equal(addr, mac_entry->mac)) {
 324                         lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 325                                                   mac_entry->vid,
 326                                                   ENTRYTYPE_LOCKED);
 327
 328                         list_del(&mac_entry->list);
 329                         kfree(mac_entry);
 330                 }
 331         }
 332         spin_unlock(&lan966x->mac_lock);
 333
 334         return 0;
 335 }
 336
 337 void lan966x_mac_lag_replace_port_entry(struct lan966x *lan966x,
 338                                         struct lan966x_port *src,
 339                                         struct lan966x_port *dst)
 340 {
 341         struct lan966x_mac_entry *mac_entry;
 342
 343         spin_lock(&lan966x->mac_lock);
 344         list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
 345                 if (mac_entry->port_index == src->chip_port &&
 346                     mac_entry->lag) {
 347                         lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 348                                                   mac_entry->vid,
 349                                                   ENTRYTYPE_LOCKED);
 350
 351                         lan966x_mac_learn_locked(lan966x, dst->chip_port,
 352                                                  mac_entry->mac, mac_entry->vid,
 353                                                  ENTRYTYPE_LOCKED);
 354                         mac_entry->port_index = dst->chip_port;
 355                 }
 356         }
 357         spin_unlock(&lan966x->mac_lock);
 358 }
 359
 360 void lan966x_mac_lag_remove_port_entry(struct lan966x *lan966x,
 361                                        struct lan966x_port *src)
 362 {
 363         struct lan966x_mac_entry *mac_entry, *tmp;
 364
 365         spin_lock(&lan966x->mac_lock);
 366         list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 367                                  list) {
 368                 if (mac_entry->port_index == src->chip_port &&
 369                     mac_entry->lag) {
 370                         lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 371                                                   mac_entry->vid,
 372                                                   ENTRYTYPE_LOCKED);
 373
 374                         list_del(&mac_entry->list);
 375                         kfree(mac_entry);
 376                 }
 377         }
 378         spin_unlock(&lan966x->mac_lock);
 379 }
 380
 381 void lan966x_mac_purge_entries(struct lan966x *lan966x)
 382 {
 383         struct lan966x_mac_entry *mac_entry, *tmp;
 384
 385         spin_lock(&lan966x->mac_lock);
 386         list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries,
 387                                  list) {
 388                 lan966x_mac_forget_locked(lan966x, mac_entry->mac,
 389                                           mac_entry->vid, ENTRYTYPE_LOCKED);
 390
 391                 list_del(&mac_entry->list);
 392                 kfree(mac_entry);
 393         }
 394         spin_unlock(&lan966x->mac_lock);
 395 }
 396
 397 static void lan966x_mac_notifiers(enum switchdev_notifier_type type,
 398                                   unsigned char *mac, u32 vid,
 399                                   struct net_device *dev)
 400 {
 401         rtnl_lock();
 402         lan966x_fdb_call_notifiers(type, mac, vid, dev);
 403         rtnl_unlock();
 404 }
 405
 406 static void lan966x_mac_process_raw_entry(struct lan966x_mac_raw_entry *raw_entry,
 407                                           u8 *mac, u16 *vid, u32 *dest_idx)
 408 {
 409         mac[0] = (raw_entry->mach >> 8)  & 0xff;
 410         mac[1] = (raw_entry->mach >> 0)  & 0xff;
 411         mac[2] = (raw_entry->macl >> 24) & 0xff;
 412         mac[3] = (raw_entry->macl >> 16) & 0xff;
 413         mac[4] = (raw_entry->macl >> 8)  & 0xff;
 414         mac[5] = (raw_entry->macl >> 0)  & 0xff;
 415
 416         *vid = (raw_entry->mach >> 16) & 0xfff;
 417         *dest_idx = ANA_MACACCESS_DEST_IDX_GET(raw_entry->maca);
 418 }
 419
 420 static void lan966x_mac_irq_process(struct lan966x *lan966x, u32 row,
 421                                     struct lan966x_mac_raw_entry *raw_entries)
 422 {
 423         struct lan966x_mac_entry *mac_entry, *tmp;
 424         unsigned char mac[ETH_ALEN] __aligned(2);
 425         struct list_head mac_deleted_entries;
 426         struct lan966x_port *port;
 427         u32 dest_idx;
 428         u32 column;
 429         u16 vid;
 430
 431         INIT_LIST_HEAD(&mac_deleted_entries);
 432
 433         spin_lock(&lan966x->mac_lock);
 434         list_for_each_entry_safe(mac_entry, tmp, &lan966x->mac_entries, list) {
 435                 bool found = false;
 436
 437                 if (mac_entry->row != row)
 438                         continue;
 439
 440                 for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
 441                         /* All the valid entries are at the start of the row,
 442                          * so when get one invalid entry it can just skip the
 443                          * rest of the columns
 444                          */
 445                         if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
 446                                 break;
 447
 448                         lan966x_mac_process_raw_entry(&raw_entries[column],
 449                                                       mac, &vid, &dest_idx);
 450                         if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
 451                                 continue;
 452
 453                         /* If the entry in SW is found, then there is nothing
 454                          * to do
 455                          */
 456                         if (mac_entry->vid == vid &&
 457                             ether_addr_equal(mac_entry->mac, mac) &&
 458                             mac_entry->port_index == dest_idx) {
 459                                 raw_entries[column].processed = true;
 460                                 found = true;
 461                                 break;
 462                         }
 463                 }
 464
 465                 if (!found) {
 466                         list_del(&mac_entry->list);
 467                         /* Move the entry from SW list to a tmp list such that
 468                          * it would be deleted later
 469                          */
 470                         list_add_tail(&mac_entry->list, &mac_deleted_entries);
 471                 }
 472         }
 473         spin_unlock(&lan966x->mac_lock);
 474
 475         list_for_each_entry_safe(mac_entry, tmp, &mac_deleted_entries, list) {
 476                 /* Notify the bridge that the entry doesn't exist
 477                  * anymore in the HW
 478                  */
 479                 port = lan966x->ports[mac_entry->port_index];
 480                 lan966x_mac_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
 481                                       mac_entry->mac, mac_entry->vid,
 482                                       port->bond ?: port->dev);
 483                 list_del(&mac_entry->list);
 484                 kfree(mac_entry);
 485         }
 486
 487         /* Now go to the list of columns and see if any entry was not in the SW
 488          * list, then that means that the entry is new so it needs to notify the
 489          * bridge.
 490          */
 491         for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
 492                 /* All the valid entries are at the start of the row, so when
 493                  * get one invalid entry it can just skip the rest of the columns
 494                  */
 495                 if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
 496                         break;
 497
 498                 /* If the entry already exists then don't do anything */
 499                 if (raw_entries[column].processed)
 500                         continue;
 501
 502                 lan966x_mac_process_raw_entry(&raw_entries[column],
 503                                               mac, &vid, &dest_idx);
 504                 if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
 505                         continue;
 506
 507                 spin_lock(&lan966x->mac_lock);
 508                 mac_entry = lan966x_mac_find_entry(lan966x, mac, vid, dest_idx);
 509                 if (mac_entry) {
 510                         spin_unlock(&lan966x->mac_lock);
 511                         continue;
 512                 }
 513
 514                 port = lan966x->ports[dest_idx];
 515                 mac_entry = lan966x_mac_alloc_entry(port, mac, vid);
 516                 if (!mac_entry) {
 517                         spin_unlock(&lan966x->mac_lock);
 518                         return;
 519                 }
 520
 521                 mac_entry->row = row;
 522                 list_add_tail(&mac_entry->list, &lan966x->mac_entries);
 523                 spin_unlock(&lan966x->mac_lock);
 524
 525                 lan966x_mac_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
 526                                       mac, vid, port->bond ?: port->dev);
 527         }
 528 }
 529
 530 irqreturn_t lan966x_mac_irq_handler(struct lan966x *lan966x)
 531 {
 532         struct lan966x_mac_raw_entry entry[LAN966X_MAC_COLUMNS] = { 0 };
 533         u32 index, column;
 534         bool stop = true;
 535         u32 val;
 536
 537         /* Start the scan from 0, 0 */
 538         lan_wr(ANA_MACTINDX_M_INDEX_SET(0) |
 539                ANA_MACTINDX_BUCKET_SET(0),
 540                lan966x, ANA_MACTINDX);
 541
 542         while (1) {
 543                 spin_lock(&lan966x->mac_lock);
 544                 lan_rmw(ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_SYNC_GET_NEXT),
 545                         ANA_MACACCESS_MAC_TABLE_CMD,
 546                         lan966x, ANA_MACACCESS);
 547                 lan966x_mac_wait_for_completion(lan966x);
 548
 549                 val = lan_rd(lan966x, ANA_MACTINDX);
 550                 index = ANA_MACTINDX_M_INDEX_GET(val);
 551                 column = ANA_MACTINDX_BUCKET_GET(val);
 552
 553                 /* The SYNC-GET-NEXT returns all the entries(4) in a row in
 554                  * which is suffered a change. By change it means that new entry
 555                  * was added or an entry was removed because of ageing.
 556                  * It would return all the columns for that row. And after that
 557                  * it would return the next row The stop conditions of the
 558                  * SYNC-GET-NEXT is when it reaches 'directly' to row 0
 559                  * column 3. So if SYNC-GET-NEXT returns row 0 and column 0
 560                  * then it is required to continue to read more even if it
 561                  * reaches row 0 and column 3.
 562                  */
 563                 if (index == 0 && column == 0)
 564                         stop = false;
 565
 566                 if (column == LAN966X_MAC_COLUMNS - 1 &&
 567                     index == 0 && stop) {
 568                         spin_unlock(&lan966x->mac_lock);
 569                         break;
 570                 }
 571
 572                 entry[column].mach = lan_rd(lan966x, ANA_MACHDATA);
 573                 entry[column].macl = lan_rd(lan966x, ANA_MACLDATA);
 574                 entry[column].maca = lan_rd(lan966x, ANA_MACACCESS);
 575                 spin_unlock(&lan966x->mac_lock);
 576
 577                 /* Once all the columns are read process them */
 578                 if (column == LAN966X_MAC_COLUMNS - 1) {
 579                         lan966x_mac_irq_process(lan966x, index, entry);
 580                         /* A row was processed so it is safe to assume that the
 581                          * next row/column can be the stop condition
 582                          */
 583                         stop = true;
 584                 }
 585         }
 586
 587         lan_rmw(ANA_ANAINTR_INTR_SET(0),
 588                 ANA_ANAINTR_INTR,
 589                 lan966x, ANA_ANAINTR);
 590
 591         return IRQ_HANDLED;
 592 }