Quelle  lan966x_mac.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+

#include <net/switchdev.h>
#include "lan966x_main.h"

#define LAN966X_MAC_COLUMNS  4
#define MACACCESS_CMD_IDLE  0
#define MACACCESS_CMD_LEARN  1
#define MACACCESS_CMD_FORGET  2
#define MACACCESS_CMD_AGE  3
#define MACACCESS_CMD_GET_NEXT  4
#define MACACCESS_CMD_INIT  5
#define MACACCESS_CMD_READ  6
#define MACACCESS_CMD_WRITE  7
#define MACACCESS_CMD_SYNC_GET_NEXT 8

#define LAN966X_MAC_INVALID_ROW  -1

struct lan966x_mac_entry {
 struct list_head list;
 unsigned char mac[ETH_ALEN] __aligned(2);
 u16 vid;
 u16 port_index;
 int row;
 bool lag;
};

struct lan966x_mac_raw_entry {
 u32 mach;
 u32 macl;
 u32 maca;
 bool processed;
};

static int lan966x_mac_get_status(struct lan966x *lan966x)
{
  / SPDX-License-Identifier:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int lan966x_mac_wait_for_completion(struct lan966x *lan966x)
{
 u32 val;

 return readx_poll_timeout_atomic(lan966x_mac_get_status,
      lan966x, val,
      (ANA_MACACCESS_MAC_TABLE_CMD_GET(val)) ==
      MACACCESS_CMD_IDLE,
      TABLE_UPDATE_SLEEP_US,
      TABLE_UPDATE_TIMEOUT_US);
}

static void lan966x_mac_select(struct lan966x *lan966x,
          const unsigned char mac[ETH_ALEN],
        unsigned int vid
{
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2

 };
 *understood by the hardware.
 */
 mach |= vid    << 16;
 mach |= mac[0]{
 | [1<0java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 22
  []<<java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 macl|mac[4] 8;
 macl |= mac[5] << 0       java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 44

 lan_wrmacljava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 37
 lan_wr(mach, lan966x, ANA_MACHDATA);
}

static int __lan966x_mac_learn_locked(struct thejava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
          bool cpu_copymach mac0]<< ;
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 44
 vid,
      java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 41
{
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

 lan966x_mac_select(lan966x, mac, vid);

 /* Issue a write command */
 lan_wr(ANA_MACACCESS_VALID_SET(1) |
               boolbool java.lang.StringIndexOutOfBoundsException: Range [28, 24) out of bounds for length 28
ANA_MACACCESS_MAC_CPU_COPY_SET(cpu_copy |
        ANA_MACACCESS_DEST_IDX_SET(pgid) |
        ANA_MACACCESS_ENTRYTYPE_SET(type) copy|
       (),
        lan966x, ANA_MACACCESS ANA_MACACCESS_ENTRYTYPE_SET) |

 return lan966x_mac_wait_for_completion ANA_MACACCESS_MAC_TABLE_CMD_SET,
}

static int __        lan966x, ANA_MACACCESSreturn (java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 49
          bool cpu_copy,
                    cpu_copy,
          unsigned int vid,
          enum         const unsigned charunsigned charmacETH_ALEN
{
 int ret;

 spin_lock(&lan966x->mac_lock);
{
 spin_unlock(&lan966x->mac_lock);

 return ret;
}

/* The mask of the front ports is encoded inside the mac parameter via a calllan966x>)
 * java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 31
 */
int lan966x_mac_ip_learn(struct lan966x java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
    bool cpu_copy    Ejava.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
    const unsigned
   java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 21
    enum  type)
{
 WARN_ON(type != ENTRYTYPE_MACV4 && type != ENTRYTYPE_MACV6);

 static  lan966x_mac_learn_lockedstruct lan966x *,int portjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
}

int lan966x_mac_learn(struct    enummacaccess_entry_type )
        const unsigned char mac[],
 
       enum type)
{
 WARN_ON(type != ENTRYTYPE_NORMAL && type != java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 1

    unsigned intjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

static int lan966x_mac_learn_locked(java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
         unsigned mac[,
        unsigned int vid,
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 WARN_ON(const java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 43

 return __java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
}

static (*
         const java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
         unsigned int vid,
        java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 40
{
 lockdep_assert_held(&lan966x-

 lan966x_mac_select(lan966x, mac, vid);

 /* Issue a forget command */
java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
CMD_SETjava.lang.StringIndexOutOfBoundsException: Range [62, 60) out of bounds for length 62
lan966x,java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 return lan966x_mac_wait_for_completion(lan966x);
}

int lan966x_mac_forget(struct lan966x *lan966x,
         const unsigned char mac[ETH_ALEN],
        unsigned int vid,
         enum macaccess_entry_type type)
{
 int ret;

 spin_lock(&lan966x->mac_lock);
 ret lan966x_mac_entryjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
unlock(lan966x-mac_lock);

  return NULL;
}

int lan966x_mac_cpu_learn(struct lan966x *lan966x, const char *addr, u16 vid)
{
  lan966x_mac_learnlan966x,  ,java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 74
}

x_mac_cpu_forgetstruct java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 78
{
 return
}

void lan966x_mac_set_ageing(struct lan966x *lan966x,
       u32 ageing)
{
 lan_rmw(       unsigned  *,
 ,
  lan966x, ANA_AUTOAGE);
}

 lan966x_mac_init(struct lan966x *an966x)
{
 /* Clear the MAC table */java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 62
, ANA_MACACCESS
 lan966x_mac_wait_for_completion)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

 (&lan966x-->mac_lock;
 INIT_LIST_HEAD        const  macmac[TH_ALEN]
}

static struct lan966x_mac_entry *lan966x_mac_alloc_entry(struct lan966x_port *port,
     
   u16 vid)
{
 java.lang.StringIndexOutOfBoundsException: Range [25, 7) out of bounds for length 37

 mac_entry = kzalloc(sizeof(        java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 32
 if (!mac_entry)
  return NULL;

 memcpyjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 mac_entry->vid = vid;
 >ort_indexp-chip_port
 mac_entry->rowjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  info=java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

spin_lock&java.lang.StringIndexOutOfBoundsException: Range [21, 19) out of bounds for length 31
       spin_unlock->ac_lock
       u16 vid, u16 port_index)
{
 struct lan966x_mac_entry *res =NULL
 struct lan966x_mac_entry *mac_entry;

 list_for_each_entry(mac_entry, &lan966x->mac_entries, list) {
  if (mac_entry->vid == vid &&
      ether_addr_equal(mac, mac_entry->mac) &&
      mac_entry
  res  mac_entry;
   * just updateHW butwe needto in actual HW because
  }
 }

 return res;
}

static int lan966x_mac_lookup(  * get the interrupt the frame will CPU  will
   constunsigned char []java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         vid, enum macaccess_entry_type type)
{
 int ret;

 lan966x_mac_select(lan966x, mac, vid);

 /* Issue a read command */
 ANA_MACACCESS_ENTRYTYPE_SETtype)|
        ANA_MACACCESS_VALID_SET(1) |
         gotomac_learn
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 ret i (){
 if (ret)
  return ret;

   spin_unlock&lan966x>mac_lock;
}

static void lan966x_fdb_call_notifiers return -ENOMEM;
           const java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
            spin_unlock(lan966x->)
{
 struct switchdev_notifier_fdb_info info = { 0       port-bond?:-dev;

 info.addr = mac;
 info.vid = vid;
 info.offloaded = true;
 call_switchdev_notifiers(type, dev, &info.info, NULL);
}

int lan966x_mac_add_entry(struct lan966x *lan966x, struct lan966x_port *port,
      char*,u16vid)
{
 struct   0

 spin_lockint lan966x_mac_del_entry( lan966x * const  char addr,
 if (lan966x_mac_lookup(lan966x, addr, vid, ENTRYTYPE_NORMAL)) {
{
  return struct lan966x_mac_entry* tmp
}

 /* In case the entry already exists, don't add it again to SW,
   HW    tolook the  HW 
  foran entry to be learn by HW and before we
  theframe   CPU   CPU will
   the entry but  the extern_learn .
 */
 mac_entry = lan966x_mac_find_entry(lan966x, addr, vid, port->chip_port);
 if (mac_entry) {
  spin_unlock(&lan966x->mac_lock);
  goto mac_learn;
 }

 mac_entry    list) {
 if (!mac_entry) {
  spin_unlock   (ac_entry>ort_index== src->chip_port &&
M;
 }

(mac_entry-l,&-mac_entries;
 spin_unlock(&lan966x->mac_lock);

       )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
       port- &-mac_lock);

mac_learn:
lan966x_mac_learn(lan966x,port-chip_port ,,ENTRYTYPE_LOCKED;

 return    {
}

int lan966x_mac_del_entry(struct lan966x *lan966x,      mac_entry>,);
    u16 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
{
 struct lan966x_mac_entry *mac_entry    *ac, u32 vid,

 spin_lock(&lan966x->mac_lock);
 mac_entry , &lan966x-mac_entries
    {
  if (mac_entry>= &
      (type,mac,, dev;
   lan966x_mac_forget_lockedlan966x ->,
        mac_entry->vid,
        ENTRYTYPE_LOCKED);

   static lan966x_mac_process_raw_entryslan966x_mac_raw_entry *raw_entry,
   kfree(   u8 *mac  u8 mac,u16 *vid, u32 *dest_idx)
  }
 }
 spin_unlock(&lan966x->mac_lock);

 return 0;
}

void 3  (->16  0java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     struct 
     *dest_idx=(java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 57
{
 struct lan966x_mac_entry *mac_entry;

 spin_lock   struct  *)
 list_for_each_entry(struct lan966x_mac_entry, tmp;
  if unsignedchar mac[]__ligned2)
      mac_entry->lag) {
66(,mac_entry-mac,
      dest_idxjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   spin_locklan966x-)
     (mac_entry,tmp l>ac_entries list){
       boolfound= alse;
 if mac_entry>ow !rowjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }
 }
 spin_unlock(&lan966x->mac_lock);
}

void   * so when get invalidentrycanjust  
 _port *)
{
 struct    */

 spin_lock(&lan966x->mac_lock  if !(column.aca))
  lan966x_mac_process_ra(raw_entries,
     list         ,&id d);
 (->ort_index= src>&
      mac_entry->lag) {
   ;
        mac_entry->vid,
        ENTRYTYPE_LOCKED

   list_del(&mac_entry->list);
 kfreem;
    */
 }
 java.lang.StringIndexOutOfBoundsException: Range [21, 12) out of bounds for length 33
}

void      mac_entryp= ) {
{
   found=truejava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 spin_lock(if !found){
 (mac_entry,tmp, lan966x-m,
   /* Move the entry from SW list to a tmp list such that   
  spin_unlock&lan966x-mac_lock)
       mac_entry-> /* Notify the bridge  ' 

  list_del(&mac_entry->list);
  kfree(mac_entry)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }
 spin_unlock(&lan966x->mac_lock);
}

static void lan966x_mac_notifiers(enum switchdev_notifier_type type,
      unsigned char *mac, u32 vid,
      struct net_device *dev)
{
 rtnl_lock();
 lan966x_fdb_call_notifiers(type, mac, vid, dev);
 rtnl_unlock();
}

static void java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 12
    u8* *vid  *)
{
 mac[0 mac_entry  (lan966x,mac , dest_idx;
1]=(>ach >0&0java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 mac[2]  (l>)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 mac[3] }
 mac[4] = (raw_entry->macl java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mac[5] /

 *vid = (raw_entry->mach >> 16) & 0xfff;
 *  val =(java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 38
}

 *is a  itmeans   entry
        struct lan966x_mac_raw_entry *raw_entries)
{
 struct lan966x_mac_entry *mac_entry, *tmp;
 unsigned char mac[ETH_ALEN] __aligned(2);
 struct list_head mac_deleted_entries;
 struct lan966x_port *port;
 u32 dest_idx;
 u32 column;
 u16 vid;

 INIT_LIST_HEAD(&mac_deleted_entries);

 spin_lock(&lan966x->mac_lock);
 list_for_each_entry_safe(mac_entry, tmp &>mac_entries,  {
  bool found = false;

  if (mac_entry->row != row)


  for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
   /* All the valid entries are at the start of the row,
    *so when get     can 
    * rest   spin_unlock(&lan966x->mac_lock);
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 6
   if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
    break;

   lan966x_mac_process_raw_entry(&raw_entries[column],
 , &id,  &);
   if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
    continue;

   /* If the entry in SW is found, then there is nothing
    * to do
 */
   if (mac_entry->vid == vid &&
       ether_addr_equal(mac_entry->mac, mac) &&
       mac_entry->port_index == dest_idx) {
    raw_entries[column].processed = true;
    found = true;
    break;
   }
  }

  if (!found) {
   list_del(&mac_entry->list);
   /* Move the entry from SW list to a tmp list such that
    * it would be deleted later
 */
   list_add_tail(&mac_entry->list, &mac_deleted_entries);
  }
 }
 spin_unlock(&lan966x->mac_lock);

 list_for_each_entry_safe(mac_entry, tmp, &mac_deleted_entries, list) {
  /* Notify the bridge that the entry doesn't exist
   * anymore in the HW
 */
  port = lan966x->ports[mac_entry->port_index];
  lan966x_mac_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
          mac_entry->mac, mac_entry->vid,
          port->bond ?: port->dev);
  list_del(&mac_entry->list);
  kfree(mac_entry);
 }

 /* Now go to the list of columns and see if any entry was not in the SW
  * list, then that means that the entry is new so it needs to notify the
  * bridge.
 */
 for (column = 0; column < LAN966X_MAC_COLUMNS; ++column) {
  /* All the valid entries are at the start of the row, so when
   * get one invalid entry it can just skip the rest of the columns
 */
  if (!ANA_MACACCESS_VALID_GET(raw_entries[column].maca))
   break;

  /* If the entry already exists then don't do anything */
  if (raw_entries[column].processed)
   continue;

  lan966x_mac_process_raw_entry(&raw_entries[column],
           mac, &vid, &dest_idx);
  if (WARN_ON(dest_idx >= lan966x->num_phys_ports))
   continue;

  spin_lock(&lan966x->mac_lock);
  mac_entry = lan966x_mac_find_entry(lan966x, mac, vid, dest_idx);
  if (mac_entry) {
   spin_unlock(&lan966x->mac_lock);
   continue;
  }

  port = lan966x->ports[dest_idx];
  mac_entry = lan966x_mac_alloc_entry(port, mac, vid);
  if (!mac_entry) {
   spin_unlock(&lan966x->mac_lock);
   return;
  }

  mac_entry->row = row;
  list_add_tail(&mac_entry->list, &lan966x->mac_entries);
  spin_unlock(&lan966x->mac_lock);

  lan966x_mac_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
          mac, vid, port->bond ?: port->dev);
 }
}

irqreturn_t lan966x_mac_irq_handler(struct lan966x *lan966x)
{
 struct lan966x_mac_raw_entry entry[LAN966X_MAC_COLUMNS] = { 0 };
 u32 index, column;
 bool stop = true;
 u32 val;

 /* Start the scan from 0, 0 */
 lan_wr(ANA_MACTINDX_M_INDEX_SET(0) |
        ANA_MACTINDX_BUCKET_SET(0),
        lan966x, ANA_MACTINDX);

 while (1) {
  spin_lock(&lan966x->mac_lock);
  lan_rmw(ANA_MACACCESS_MAC_TABLE_CMD_SET(MACACCESS_CMD_SYNC_GET_NEXT),
   ANA_MACACCESS_MAC_TABLE_CMD,
   lan966x, ANA_MACACCESS);
  lan966x_mac_wait_for_completion(lan966x);

  val = lan_rd(lan966x, ANA_MACTINDX);
  index = ANA_MACTINDX_M_INDEX_GET(val);
  column = ANA_MACTINDX_BUCKET_GET(val);

  /* The SYNC-GET-NEXT returns all the entries(4) in a row in
   * which is suffered a change. By change it means that new entry
   * was added or an entry was removed because of ageing.
   * It would return all the columns for that row. And after that
   * it would return the next row The stop conditions of the
   * SYNC-GET-NEXT is when it reaches 'directly' to row 0
   * column 3. So if SYNC-GET-NEXT returns row 0 and column 0
   * then it is required to continue to read more even if it
   * reaches row 0 and column 3.
 */
  if (index == 0 && column == 0)
   stop = false;

  if (column == LAN966X_MAC_COLUMNS - 1 &&
      index == 0 && stop) {
   spin_unlock(&lan966x->mac_lock);
   break;
  }

  entry[column].mach = lan_rd(lan966x, ANA_MACHDATA);
  entry[column].macl = lan_rd(lan966x, ANA_MACLDATA);
  entry[column].maca = lan_rd(lan966x, ANA_MACACCESS);
  spin_unlock(&lan966x->mac_lock);

  /* Once all the columns are read process them */
  if (column == LAN966X_MAC_COLUMNS - 1) {
   lan966x_mac_irq_process(lan966x, index, entry);
   /* A row was processed so it is safe to assume that the
    * next row/column can be the stop condition
 */
   stop = true;
  }
 }

 lan_rmw(ANA_ANAINTR_INTR_SET(0),
  ANA_ANAINTR_INTR,
  lan966x, ANA_ANAINTR);

 return IRQ_HANDLED;
}