Merge branch 'ionic-updates' · tjh.dev/kernel@2d38c58

+1 -1

drivers/net/ethernet/pensando/ionic/ionic_dev.c

··· 25 25 hb = ionic_heartbeat_check(ionic); 26 26 27 27 if (hb >= 0) 28 - ionic_link_status_check_request(ionic->lif, false); 28 + ionic_link_status_check_request(ionic->lif, CAN_NOT_SLEEP); 29 29 } 30 30 31 31 void ionic_init_devinfo(struct ionic *ionic)

+3 -1

drivers/net/ethernet/pensando/ionic/ionic_dev.h

··· 12 12 13 13 #define IONIC_MAX_TX_DESC 8192 14 14 #define IONIC_MAX_RX_DESC 16384 15 - #define IONIC_MIN_TXRX_DESC 16 15 + #define IONIC_MIN_TXRX_DESC 64 16 16 #define IONIC_DEF_TXRX_DESC 4096 17 + #define IONIC_RX_FILL_THRESHOLD 16 18 + #define IONIC_RX_FILL_DIV 8 17 19 #define IONIC_LIFS_MAX 1024 18 20 #define IONIC_WATCHDOG_SECS 5 19 21 #define IONIC_ITR_COAL_USEC_DEFAULT 64

+61 -48

drivers/net/ethernet/pensando/ionic/ionic_lif.c

··· 123 123 link_up = link_status == IONIC_PORT_OPER_STATUS_UP; 124 124 125 125 if (link_up) { 126 + if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) { 127 + mutex_lock(&lif->queue_lock); 128 + ionic_start_queues(lif); 129 + mutex_unlock(&lif->queue_lock); 130 + } 131 + 126 132 if (!netif_carrier_ok(netdev)) { 127 133 u32 link_speed; 128 134 ··· 137 131 netdev_info(netdev, "Link up - %d Gbps\n", 138 132 link_speed / 1000); 139 133 netif_carrier_on(netdev); 140 - } 141 - 142 - if (lif->netdev->flags & IFF_UP && netif_running(lif->netdev)) { 143 - mutex_lock(&lif->queue_lock); 144 - ionic_start_queues(lif); 145 - mutex_unlock(&lif->queue_lock); 146 134 } 147 135 } else { 148 136 if (netif_carrier_ok(netdev)) { ··· 1074 1074 1075 1075 static int ionic_addr_add(struct net_device *netdev, const u8 *addr) 1076 1076 { 1077 - return ionic_lif_addr(netdev_priv(netdev), addr, true, true); 1077 + return ionic_lif_addr(netdev_priv(netdev), addr, ADD_ADDR, CAN_SLEEP); 1078 1078 } 1079 1079 1080 1080 static int ionic_ndo_addr_add(struct net_device *netdev, const u8 *addr) 1081 1081 { 1082 - return ionic_lif_addr(netdev_priv(netdev), addr, true, false); 1082 + return ionic_lif_addr(netdev_priv(netdev), addr, ADD_ADDR, CAN_NOT_SLEEP); 1083 1083 } 1084 1084 1085 1085 static int ionic_addr_del(struct net_device *netdev, const u8 *addr) 1086 1086 { 1087 - return ionic_lif_addr(netdev_priv(netdev), addr, false, true); 1087 + return ionic_lif_addr(netdev_priv(netdev), addr, DEL_ADDR, CAN_SLEEP); 1088 1088 } 1089 1089 1090 1090 static int ionic_ndo_addr_del(struct net_device *netdev, const u8 *addr) 1091 1091 { 1092 - return ionic_lif_addr(netdev_priv(netdev), addr, false, false); 1092 + return ionic_lif_addr(netdev_priv(netdev), addr, DEL_ADDR, CAN_NOT_SLEEP); 1093 1093 } 1094 1094 1095 1095 static void ionic_lif_rx_mode(struct ionic_lif *lif, unsigned int rx_mode) ··· 1129 1129 lif->rx_mode = rx_mode; 1130 1130 } 1131 1131 1132 - static void _ionic_lif_rx_mode(struct ionic_lif *lif, unsigned int rx_mode, 1133 - bool from_ndo) 1134 - { 1135 - struct ionic_deferred_work *work; 1136 - 1137 - if (from_ndo) { 1138 - work = kzalloc(sizeof(*work), GFP_ATOMIC); 1139 - if (!work) { 1140 - netdev_err(lif->netdev, "%s OOM\n", __func__); 1141 - return; 1142 - } 1143 - work->type = IONIC_DW_TYPE_RX_MODE; 1144 - work->rx_mode = rx_mode; 1145 - netdev_dbg(lif->netdev, "deferred: rx_mode\n"); 1146 - ionic_lif_deferred_enqueue(&lif->deferred, work); 1147 - } else { 1148 - ionic_lif_rx_mode(lif, rx_mode); 1149 - } 1150 - } 1151 - 1152 - static void ionic_dev_uc_sync(struct net_device *netdev, bool from_ndo) 1153 - { 1154 - if (from_ndo) 1155 - __dev_uc_sync(netdev, ionic_ndo_addr_add, ionic_ndo_addr_del); 1156 - else 1157 - __dev_uc_sync(netdev, ionic_addr_add, ionic_addr_del); 1158 - 1159 - } 1160 - 1161 - static void ionic_set_rx_mode(struct net_device *netdev, bool from_ndo) 1132 + static void ionic_set_rx_mode(struct net_device *netdev, bool can_sleep) 1162 1133 { 1163 1134 struct ionic_lif *lif = netdev_priv(netdev); 1135 + struct ionic_deferred_work *work; 1164 1136 unsigned int nfilters; 1165 1137 unsigned int rx_mode; 1166 1138 ··· 1149 1177 * we remove our overflow flag and check the netdev flags 1150 1178 * to see if we can disable NIC PROMISC 1151 1179 */ 1152 - ionic_dev_uc_sync(netdev, from_ndo); 1180 + if (can_sleep) 1181 + __dev_uc_sync(netdev, ionic_addr_add, ionic_addr_del); 1182 + else 1183 + __dev_uc_sync(netdev, ionic_ndo_addr_add, ionic_ndo_addr_del); 1153 1184 nfilters = le32_to_cpu(lif->identity->eth.max_ucast_filters); 1154 1185 if (netdev_uc_count(netdev) + 1 > nfilters) { 1155 1186 rx_mode |= IONIC_RX_MODE_F_PROMISC; ··· 1164 1189 } 1165 1190 1166 1191 /* same for multicast */ 1167 - ionic_dev_uc_sync(netdev, from_ndo); 1192 + if (can_sleep) 1193 + __dev_mc_sync(netdev, ionic_addr_add, ionic_addr_del); 1194 + else 1195 + __dev_mc_sync(netdev, ionic_ndo_addr_add, ionic_ndo_addr_del); 1168 1196 nfilters = le32_to_cpu(lif->identity->eth.max_mcast_filters); 1169 1197 if (netdev_mc_count(netdev) > nfilters) { 1170 1198 rx_mode |= IONIC_RX_MODE_F_ALLMULTI; ··· 1178 1200 rx_mode &= ~IONIC_RX_MODE_F_ALLMULTI; 1179 1201 } 1180 1202 1181 - if (lif->rx_mode != rx_mode) 1182 - _ionic_lif_rx_mode(lif, rx_mode, from_ndo); 1203 + if (lif->rx_mode != rx_mode) { 1204 + if (!can_sleep) { 1205 + work = kzalloc(sizeof(*work), GFP_ATOMIC); 1206 + if (!work) { 1207 + netdev_err(lif->netdev, "%s OOM\n", __func__); 1208 + return; 1209 + } 1210 + work->type = IONIC_DW_TYPE_RX_MODE; 1211 + work->rx_mode = rx_mode; 1212 + netdev_dbg(lif->netdev, "deferred: rx_mode\n"); 1213 + ionic_lif_deferred_enqueue(&lif->deferred, work); 1214 + } else { 1215 + ionic_lif_rx_mode(lif, rx_mode); 1216 + } 1217 + } 1183 1218 } 1184 1219 1185 1220 static void ionic_ndo_set_rx_mode(struct net_device *netdev) 1186 1221 { 1187 - ionic_set_rx_mode(netdev, true); 1222 + ionic_set_rx_mode(netdev, CAN_NOT_SLEEP); 1188 1223 } 1189 1224 1190 1225 static __le64 ionic_netdev_features_to_nic(netdev_features_t features) ··· 1616 1625 ionic_lif_rss_config(lif, 0x0, NULL, NULL); 1617 1626 } 1618 1627 1628 + static void ionic_lif_quiesce(struct ionic_lif *lif) 1629 + { 1630 + struct ionic_admin_ctx ctx = { 1631 + .work = COMPLETION_INITIALIZER_ONSTACK(ctx.work), 1632 + .cmd.lif_setattr = { 1633 + .opcode = IONIC_CMD_LIF_SETATTR, 1634 + .index = cpu_to_le16(lif->index), 1635 + .attr = IONIC_LIF_ATTR_STATE, 1636 + .state = IONIC_LIF_QUIESCE, 1637 + }, 1638 + }; 1639 + int err; 1640 + 1641 + err = ionic_adminq_post_wait(lif, &ctx); 1642 + if (err) 1643 + netdev_err(lif->netdev, "lif quiesce failed %d\n", err); 1644 + } 1645 + 1619 1646 static void ionic_txrx_disable(struct ionic_lif *lif) 1620 1647 { 1621 1648 unsigned int i; ··· 1648 1639 for (i = 0; i < lif->nxqs; i++) 1649 1640 err = ionic_qcq_disable(lif->rxqcqs[i], (err != -ETIMEDOUT)); 1650 1641 } 1642 + 1643 + ionic_lif_quiesce(lif); 1651 1644 } 1652 1645 1653 1646 static void ionic_txrx_deinit(struct ionic_lif *lif) ··· 1784 1773 if (lif->netdev->features & NETIF_F_RXHASH) 1785 1774 ionic_lif_rss_init(lif); 1786 1775 1787 - ionic_set_rx_mode(lif->netdev, false); 1776 + ionic_set_rx_mode(lif->netdev, CAN_SLEEP); 1788 1777 1789 1778 return 0; 1790 1779 ··· 2792 2781 */ 2793 2782 if (!ether_addr_equal(ctx.comp.lif_getattr.mac, 2794 2783 netdev->dev_addr)) 2795 - ionic_lif_addr(lif, netdev->dev_addr, true, true); 2784 + ionic_lif_addr(lif, netdev->dev_addr, ADD_ADDR, CAN_SLEEP); 2796 2785 } else { 2797 2786 /* Update the netdev mac with the device's mac */ 2798 2787 memcpy(addr.sa_data, ctx.comp.lif_getattr.mac, netdev->addr_len); ··· 2809 2798 2810 2799 netdev_dbg(lif->netdev, "adding station MAC addr %pM\n", 2811 2800 netdev->dev_addr); 2812 - ionic_lif_addr(lif, netdev->dev_addr, true, true); 2801 + ionic_lif_addr(lif, netdev->dev_addr, ADD_ADDR, CAN_SLEEP); 2813 2802 2814 2803 return 0; 2815 2804 } ··· 2970 2959 dev_err(lif->ionic->dev, "Cannot register net device, aborting\n"); 2971 2960 return err; 2972 2961 } 2962 + 2963 + ionic_link_status_check_request(lif, true); 2973 2964 lif->registered = true; 2974 2965 ionic_lif_set_netdev_info(lif); 2975 2966

+6

drivers/net/ethernet/pensando/ionic/ionic_lif.h

··· 13 13 14 14 #define IONIC_MAX_NUM_NAPI_CNTR (NAPI_POLL_WEIGHT + 1) 15 15 #define IONIC_MAX_NUM_SG_CNTR (IONIC_TX_MAX_SG_ELEMS + 1) 16 + 17 + #define ADD_ADDR true 18 + #define DEL_ADDR false 19 + #define CAN_SLEEP true 20 + #define CAN_NOT_SLEEP false 21 + 16 22 #define IONIC_RX_COPYBREAK_DEFAULT 256 17 23 #define IONIC_TX_BUDGET_DEFAULT 256 18 24

+10 -8

drivers/net/ethernet/pensando/ionic/ionic_txrx.c

··· 392 392 q->dbval | q->head_idx); 393 393 } 394 394 395 - static void ionic_rx_fill_cb(void *arg) 396 - { 397 - ionic_rx_fill(arg); 398 - } 399 - 400 395 void ionic_rx_empty(struct ionic_queue *q) 401 396 { 402 397 struct ionic_desc_info *desc_info; ··· 475 480 struct ionic_cq *cq = napi_to_cq(napi); 476 481 struct ionic_dev *idev; 477 482 struct ionic_lif *lif; 483 + u16 rx_fill_threshold; 478 484 u32 work_done = 0; 479 485 u32 flags = 0; 480 486 ··· 485 489 work_done = ionic_cq_service(cq, budget, 486 490 ionic_rx_service, NULL, NULL); 487 491 488 - if (work_done) 492 + rx_fill_threshold = min_t(u16, IONIC_RX_FILL_THRESHOLD, 493 + cq->num_descs / IONIC_RX_FILL_DIV); 494 + if (work_done && ionic_q_space_avail(cq->bound_q) >= rx_fill_threshold) 489 495 ionic_rx_fill(cq->bound_q); 490 496 491 497 if (work_done < budget && napi_complete_done(napi, work_done)) { ··· 516 518 struct ionic_dev *idev; 517 519 struct ionic_lif *lif; 518 520 struct ionic_cq *txcq; 521 + u16 rx_fill_threshold; 519 522 u32 rx_work_done = 0; 520 523 u32 tx_work_done = 0; 521 524 u32 flags = 0; ··· 530 531 531 532 rx_work_done = ionic_cq_service(rxcq, budget, 532 533 ionic_rx_service, NULL, NULL); 533 - if (rx_work_done) 534 - ionic_rx_fill_cb(rxcq->bound_q); 534 + 535 + rx_fill_threshold = min_t(u16, IONIC_RX_FILL_THRESHOLD, 536 + rxcq->num_descs / IONIC_RX_FILL_DIV); 537 + if (rx_work_done && ionic_q_space_avail(rxcq->bound_q) >= rx_fill_threshold) 538 + ionic_rx_fill(rxcq->bound_q); 535 539 536 540 if (rx_work_done < budget && napi_complete_done(napi, rx_work_done)) { 537 541 ionic_dim_update(qcq);

Configure Feed

Configure Feed