Lines Matching refs:ndp
33 bool ncsi_channel_is_last(struct ncsi_dev_priv *ndp,
39 NCSI_FOR_EACH_PACKAGE(ndp, np)
51 static void ncsi_report_link(struct ncsi_dev_priv *ndp, bool force_down)
53 struct ncsi_dev *nd = &ndp->ndev;
65 NCSI_FOR_EACH_PACKAGE(ndp, np) {
93 struct ncsi_dev_priv *ndp = np->ndp;
116 netdev_warn(ndp->ndev.dev,
128 nca.ndp = ndp;
135 netdev_err(ndp->ndev.dev, "Error %d sending GLS\n",
141 netdev_err(ndp->ndev.dev, "NCSI Channel %d timed out!\n",
143 ncsi_report_link(ndp, true);
144 ndp->flags |= NCSI_DEV_RESHUFFLE;
153 spin_lock_irqsave(&ndp->lock, flags);
155 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
156 spin_unlock_irqrestore(&ndp->lock, flags);
157 ncsi_process_next_channel(ndp);
269 struct ncsi_package *ncsi_find_package(struct ncsi_dev_priv *ndp,
274 NCSI_FOR_EACH_PACKAGE(ndp, np) {
282 struct ncsi_package *ncsi_add_package(struct ncsi_dev_priv *ndp,
293 np->ndp = ndp;
298 spin_lock_irqsave(&ndp->lock, flags);
299 tmp = ncsi_find_package(ndp, id);
301 spin_unlock_irqrestore(&ndp->lock, flags);
306 list_add_tail_rcu(&np->node, &ndp->packages);
307 ndp->package_num++;
308 spin_unlock_irqrestore(&ndp->lock, flags);
315 struct ncsi_dev_priv *ndp = np->ndp;
324 spin_lock_irqsave(&ndp->lock, flags);
326 ndp->package_num--;
327 spin_unlock_irqrestore(&ndp->lock, flags);
332 void ncsi_find_package_and_channel(struct ncsi_dev_priv *ndp,
340 p = ncsi_find_package(ndp, NCSI_PACKAGE_INDEX(id));
353 struct ncsi_request *ncsi_alloc_request(struct ncsi_dev_priv *ndp,
357 int i, limit = ARRAY_SIZE(ndp->requests);
361 spin_lock_irqsave(&ndp->lock, flags);
362 for (i = ndp->request_id; i < limit; i++) {
363 if (ndp->requests[i].used)
366 nr = &ndp->requests[i];
369 ndp->request_id = i + 1;
374 for (i = NCSI_REQ_START_IDX; i < ndp->request_id; i++) {
375 if (ndp->requests[i].used)
378 nr = &ndp->requests[i];
381 ndp->request_id = i + 1;
386 spin_unlock_irqrestore(&ndp->lock, flags);
392 struct ncsi_dev_priv *ndp = nr->ndp;
402 spin_lock_irqsave(&ndp->lock, flags);
409 spin_unlock_irqrestore(&ndp->lock, flags);
411 if (driven && cmd && --ndp->pending_req_num == 0)
412 schedule_work(&ndp->work);
421 struct ncsi_dev_priv *ndp;
423 NCSI_FOR_EACH_DEV(ndp) {
424 if (ndp->ndev.dev == dev)
425 return &ndp->ndev;
434 struct ncsi_dev_priv *ndp = nr->ndp;
443 spin_lock_irqsave(&ndp->lock, flags);
446 spin_unlock_irqrestore(&ndp->lock, flags);
449 spin_unlock_irqrestore(&ndp->lock, flags);
456 ncsi_find_package_and_channel(ndp,
467 static void ncsi_suspend_channel(struct ncsi_dev_priv *ndp)
469 struct ncsi_dev *nd = &ndp->ndev;
476 np = ndp->active_package;
477 nc = ndp->active_channel;
478 nca.ndp = ndp;
485 ndp->pending_req_num = 1;
490 if (ndp->flags & NCSI_DEV_HWA)
503 if (ndp->flags & NCSI_DEV_RESHUFFLE)
513 ndp->pending_req_num = np->channel_num;
528 ndp->pending_req_num = 1;
541 ndp->pending_req_num = 1;
564 ndp->pending_req_num = 1;
580 if (ndp->flags & NCSI_DEV_RESET)
583 ncsi_process_next_channel(ndp);
598 static int clear_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
633 static int set_one_vid(struct ncsi_dev_priv *ndp, struct ncsi_channel *nc,
643 if (list_empty(&ndp->vlan_vids))
652 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
672 netdev_err(ndp->ndev.dev,
710 netdev_err(nca->ndp->ndev.dev,
735 netdev_err(nca->ndp->ndev.dev,
754 nca->ndp->ndev.dev->dev_addr, ETH_ALEN);
763 netdev_err(nca->ndp->ndev.dev,
784 if (nca->ndp->gma_flag == 1)
797 netdev_err(nca->ndp->ndev.dev,
810 static bool ncsi_channel_is_tx(struct ncsi_dev_priv *ndp,
820 NCSI_FOR_EACH_PACKAGE(ndp, np) {
821 if (!ndp->multi_package && np != nc->package)
831 list_for_each_entry_rcu(channel, &ndp->channel_queue, link) {
843 list_for_each_entry_rcu(channel, &ndp->channel_queue, link)
852 int ncsi_update_tx_channel(struct ncsi_dev_priv *ndp,
862 if (!package->multi_channel && !ndp->multi_package)
863 netdev_warn(ndp->ndev.dev,
865 nca.ndp = ndp;
869 NCSI_FOR_EACH_PACKAGE(ndp, np) {
872 if (!ndp->multi_package && np != package)
883 NCSI_FOR_EACH_PACKAGE(ndp, np) {
886 if (!ndp->multi_package && np != package)
888 if (!(ndp->package_whitelist & (0x1 << np->id)))
921 netdev_err(ndp->ndev.dev,
926 netdev_info(ndp->ndev.dev, "NCSI: channel %u enables Tx\n", enable->id);
933 netdev_err(ndp->ndev.dev,
940 static void ncsi_configure_channel(struct ncsi_dev_priv *ndp)
942 struct ncsi_package *np = ndp->active_package;
943 struct ncsi_channel *nc = ndp->active_channel;
945 struct ncsi_dev *nd = &ndp->ndev;
952 nca.ndp = ndp;
957 ndp->pending_req_num = 1;
961 if (ndp->flags & NCSI_DEV_HWA)
969 netdev_err(ndp->ndev.dev,
977 ndp->pending_req_num = 1;
985 netdev_err(ndp->ndev.dev,
1000 ndp->pending_req_num = 1;
1005 schedule_work(&ndp->work);
1018 ndp->pending_req_num = 1;
1025 ret = clear_one_vid(ndp, nc, &nca);
1028 schedule_work(&ndp->work);
1035 ret = set_one_vid(ndp, nc, &nca);
1038 schedule_work(&ndp->work);
1045 if (list_empty(&ndp->vlan_vids)) {
1073 else if (ncsi_channel_is_tx(ndp, nc))
1079 if (ncsi_channel_is_tx(ndp, nc))
1086 netdev_info(ndp->ndev.dev,
1109 netdev_err(ndp->ndev.dev,
1116 netdev_dbg(ndp->ndev.dev, "NCSI: channel %u config done\n",
1121 if (ndp->flags & NCSI_DEV_RESET) {
1138 spin_lock_irqsave(&ndp->lock, flags);
1139 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1140 spin_unlock_irqrestore(&ndp->lock, flags);
1143 ncsi_process_next_channel(ndp);
1151 netdev_dbg(ndp->ndev.dev,
1158 spin_lock_irqsave(&ndp->lock, flags);
1159 ndp->hot_channel = hot_nc;
1160 spin_unlock_irqrestore(&ndp->lock, flags);
1163 ncsi_process_next_channel(ndp);
1173 ncsi_report_link(ndp, true);
1176 static int ncsi_choose_active_channel(struct ncsi_dev_priv *ndp)
1184 spin_lock_irqsave(&ndp->lock, flags);
1185 hot_nc = ndp->hot_channel;
1186 spin_unlock_irqrestore(&ndp->lock, flags);
1195 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1196 if (!(ndp->package_whitelist & (0x1 << np->id)))
1227 spin_lock_irqsave(&ndp->lock, flags);
1229 &ndp->channel_queue);
1230 spin_unlock_irqrestore(&ndp->lock, flags);
1232 netdev_dbg(ndp->ndev.dev,
1243 if (with_link && !ndp->multi_package)
1247 if (list_empty(&ndp->channel_queue) && found) {
1248 netdev_info(ndp->ndev.dev,
1251 spin_lock_irqsave(&ndp->lock, flags);
1252 list_add_tail_rcu(&found->link, &ndp->channel_queue);
1253 spin_unlock_irqrestore(&ndp->lock, flags);
1255 netdev_warn(ndp->ndev.dev,
1257 ncsi_report_link(ndp, true);
1261 return ncsi_process_next_channel(ndp);
1264 static bool ncsi_check_hwa(struct ncsi_dev_priv *ndp)
1274 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1282 ndp->flags &= ~NCSI_DEV_HWA;
1289 ndp->flags |= NCSI_DEV_HWA;
1293 ndp->flags &= ~NCSI_DEV_HWA;
1297 static void ncsi_probe_channel(struct ncsi_dev_priv *ndp)
1299 struct ncsi_dev *nd = &ndp->ndev;
1306 nca.ndp = ndp;
1313 ndp->pending_req_num = 8;
1328 ndp->pending_req_num = 1;
1332 nca.package = ndp->package_probe_id;
1340 ndp->active_package = ncsi_find_package(ndp,
1341 ndp->package_probe_id);
1342 if (!ndp->active_package) {
1345 schedule_work(&ndp->work);
1350 ndp->mlx_multi_host)
1353 schedule_work(&ndp->work);
1357 ndp->pending_req_num = 1;
1360 nca.package = ndp->active_package->id;
1369 ndp->pending_req_num = 1;
1372 nca.package = ndp->active_package->id;
1382 ndp->pending_req_num = NCSI_RESERVED_CHANNEL;
1386 nca.package = ndp->active_package->id;
1399 np = ndp->active_package;
1400 ndp->pending_req_num = np->channel_num;
1426 ndp->pending_req_num = 1;
1430 nca.package = ndp->package_probe_id;
1437 ndp->package_probe_id++;
1438 if (ndp->package_probe_id >= 8) {
1440 ndp->flags |= NCSI_DEV_PROBED;
1444 ndp->active_package = NULL;
1451 if (ndp->flags & NCSI_DEV_PROBED) {
1453 ncsi_check_hwa(ndp);
1454 ncsi_choose_active_channel(ndp);
1459 netdev_err(ndp->ndev.dev,
1462 ncsi_report_link(ndp, true);
1467 struct ncsi_dev_priv *ndp = container_of(work,
1469 struct ncsi_dev *nd = &ndp->ndev;
1473 ncsi_probe_channel(ndp);
1476 ncsi_suspend_channel(ndp);
1479 ncsi_configure_channel(ndp);
1487 int ncsi_process_next_channel(struct ncsi_dev_priv *ndp)
1493 spin_lock_irqsave(&ndp->lock, flags);
1494 nc = list_first_or_null_rcu(&ndp->channel_queue,
1497 spin_unlock_irqrestore(&ndp->lock, flags);
1502 spin_unlock_irqrestore(&ndp->lock, flags);
1509 ndp->active_channel = nc;
1510 ndp->active_package = nc->package;
1514 ndp->ndev.state = ncsi_dev_state_config;
1515 netdev_dbg(ndp->ndev.dev, "NCSI: configuring channel %u\n",
1517 ncsi_configure_channel(ndp);
1520 ndp->ndev.state = ncsi_dev_state_suspend;
1521 netdev_dbg(ndp->ndev.dev, "NCSI: suspending channel %u\n",
1523 ncsi_suspend_channel(ndp);
1526 netdev_err(ndp->ndev.dev, "Invalid state 0x%x on %d:%d\n",
1528 ncsi_report_link(ndp, false);
1535 ndp->active_channel = NULL;
1536 ndp->active_package = NULL;
1537 if (ndp->flags & NCSI_DEV_RESHUFFLE) {
1538 ndp->flags &= ~NCSI_DEV_RESHUFFLE;
1539 return ncsi_choose_active_channel(ndp);
1542 ncsi_report_link(ndp, false);
1546 static int ncsi_kick_channels(struct ncsi_dev_priv *ndp)
1548 struct ncsi_dev *nd = &ndp->ndev;
1554 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1565 if ((ndp->ndev.state & 0xff00) ==
1584 spin_lock_irqsave(&ndp->lock, flags);
1585 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1586 spin_unlock_irqrestore(&ndp->lock, flags);
1598 struct ncsi_dev_priv *ndp;
1613 ndp = TO_NCSI_DEV_PRIV(nd);
1616 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
1637 list_add_rcu(&vlan->list, &ndp->vlan_vids);
1641 found = ncsi_kick_channels(ndp) != 0;
1643 return found ? ncsi_process_next_channel(ndp) : 0;
1650 struct ncsi_dev_priv *ndp;
1663 ndp = TO_NCSI_DEV_PRIV(nd);
1666 list_for_each_entry_safe(vlan, tmp, &ndp->vlan_vids, list)
1679 found = ncsi_kick_channels(ndp) != 0;
1681 return found ? ncsi_process_next_channel(ndp) : 0;
1688 struct ncsi_dev_priv *ndp;
1701 ndp = kzalloc(sizeof(*ndp), GFP_ATOMIC);
1702 if (!ndp)
1705 nd = &ndp->ndev;
1709 ndp->pending_req_num = 0;
1710 INIT_LIST_HEAD(&ndp->channel_queue);
1711 INIT_LIST_HEAD(&ndp->vlan_vids);
1712 INIT_WORK(&ndp->work, ncsi_dev_work);
1713 ndp->package_whitelist = UINT_MAX;
1716 spin_lock_init(&ndp->lock);
1717 INIT_LIST_HEAD(&ndp->packages);
1718 ndp->request_id = NCSI_REQ_START_IDX;
1719 for (i = 0; i < ARRAY_SIZE(ndp->requests); i++) {
1720 ndp->requests[i].id = i;
1721 ndp->requests[i].ndp = ndp;
1722 timer_setup(&ndp->requests[i].timer, ncsi_request_timeout, 0);
1726 list_add_tail_rcu(&ndp->node, &ncsi_dev_list);
1730 ndp->ptype.type = cpu_to_be16(ETH_P_NCSI);
1731 ndp->ptype.func = ncsi_rcv_rsp;
1732 ndp->ptype.dev = dev;
1733 dev_add_pack(&ndp->ptype);
1739 ndp->mlx_multi_host = true;
1748 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1754 if (!(ndp->flags & NCSI_DEV_PROBED)) {
1755 ndp->package_probe_id = 0;
1757 schedule_work(&ndp->work);
1767 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1778 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1792 netdev_dbg(ndp->ndev.dev, "NCSI: Stopping device\n");
1793 ncsi_report_link(ndp, true);
1799 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1804 spin_lock_irqsave(&ndp->lock, flags);
1806 if (!(ndp->flags & NCSI_DEV_RESET)) {
1812 spin_unlock_irqrestore(&ndp->lock, flags);
1820 ndp->flags |= NCSI_DEV_RESET;
1821 spin_unlock_irqrestore(&ndp->lock, flags);
1833 spin_unlock_irqrestore(&ndp->lock, flags);
1838 if (!list_empty(&ndp->channel_queue)) {
1840 list_for_each_entry_safe(nc, tmp, &ndp->channel_queue, link)
1843 spin_unlock_irqrestore(&ndp->lock, flags);
1846 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1866 spin_lock_irqsave(&ndp->lock, flags);
1867 ndp->flags &= ~NCSI_DEV_RESET;
1868 spin_unlock_irqrestore(&ndp->lock, flags);
1869 return ncsi_choose_active_channel(ndp);
1872 spin_lock_irqsave(&ndp->lock, flags);
1873 ndp->flags |= NCSI_DEV_RESET;
1874 ndp->active_channel = active;
1875 ndp->active_package = active->package;
1876 spin_unlock_irqrestore(&ndp->lock, flags);
1879 schedule_work(&ndp->work);
1885 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1889 dev_remove_pack(&ndp->ptype);
1891 list_for_each_entry_safe(np, tmp, &ndp->packages, node)
1895 list_del_rcu(&ndp->node);
1898 kfree(ndp);