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,
713 netdev_err(nca->ndp->ndev.dev,
739 netdev_err(nca->ndp->ndev.dev,
764 netdev_err(nca->ndp->ndev.dev,
783 nca->ndp->ndev.dev->dev_addr, ETH_ALEN);
792 netdev_err(nca->ndp->ndev.dev,
813 netdev_err(nca->ndp->ndev.dev,
836 if (nca->ndp->gma_flag == 1)
849 netdev_err(nca->ndp->ndev.dev,
862 static bool ncsi_channel_is_tx(struct ncsi_dev_priv *ndp,
872 NCSI_FOR_EACH_PACKAGE(ndp, np) {
873 if (!ndp->multi_package && np != nc->package)
883 list_for_each_entry_rcu(channel, &ndp->channel_queue, link) {
895 list_for_each_entry_rcu(channel, &ndp->channel_queue, link)
904 int ncsi_update_tx_channel(struct ncsi_dev_priv *ndp,
914 if (!package->multi_channel && !ndp->multi_package)
915 netdev_warn(ndp->ndev.dev,
917 nca.ndp = ndp;
921 NCSI_FOR_EACH_PACKAGE(ndp, np) {
924 if (!ndp->multi_package && np != package)
935 NCSI_FOR_EACH_PACKAGE(ndp, np) {
938 if (!ndp->multi_package && np != package)
940 if (!(ndp->package_whitelist & (0x1 << np->id)))
973 netdev_err(ndp->ndev.dev,
978 netdev_info(ndp->ndev.dev, "NCSI: channel %u enables Tx\n", enable->id);
985 netdev_err(ndp->ndev.dev,
992 static void ncsi_configure_channel(struct ncsi_dev_priv *ndp)
994 struct ncsi_package *np = ndp->active_package;
995 struct ncsi_channel *nc = ndp->active_channel;
997 struct ncsi_dev *nd = &ndp->ndev;
1004 nca.ndp = ndp;
1009 ndp->pending_req_num = 1;
1013 if (ndp->flags & NCSI_DEV_HWA)
1021 netdev_err(ndp->ndev.dev,
1029 ndp->pending_req_num = 1;
1037 netdev_err(ndp->ndev.dev,
1052 ndp->pending_req_num = 1;
1057 schedule_work(&ndp->work);
1070 ndp->pending_req_num = 1;
1077 ret = clear_one_vid(ndp, nc, &nca);
1080 schedule_work(&ndp->work);
1087 ret = set_one_vid(ndp, nc, &nca);
1090 schedule_work(&ndp->work);
1097 if (list_empty(&ndp->vlan_vids)) {
1125 else if (ncsi_channel_is_tx(ndp, nc))
1131 if (ncsi_channel_is_tx(ndp, nc))
1138 netdev_info(ndp->ndev.dev,
1161 netdev_err(ndp->ndev.dev,
1168 netdev_dbg(ndp->ndev.dev, "NCSI: channel %u config done\n",
1173 if (ndp->flags & NCSI_DEV_RESET) {
1190 spin_lock_irqsave(&ndp->lock, flags);
1191 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1192 spin_unlock_irqrestore(&ndp->lock, flags);
1195 ncsi_process_next_channel(ndp);
1203 netdev_dbg(ndp->ndev.dev,
1210 spin_lock_irqsave(&ndp->lock, flags);
1211 ndp->hot_channel = hot_nc;
1212 spin_unlock_irqrestore(&ndp->lock, flags);
1215 ncsi_process_next_channel(ndp);
1225 ncsi_report_link(ndp, true);
1228 static int ncsi_choose_active_channel(struct ncsi_dev_priv *ndp)
1236 spin_lock_irqsave(&ndp->lock, flags);
1237 hot_nc = ndp->hot_channel;
1238 spin_unlock_irqrestore(&ndp->lock, flags);
1247 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1248 if (!(ndp->package_whitelist & (0x1 << np->id)))
1279 spin_lock_irqsave(&ndp->lock, flags);
1281 &ndp->channel_queue);
1282 spin_unlock_irqrestore(&ndp->lock, flags);
1284 netdev_dbg(ndp->ndev.dev,
1295 if (with_link && !ndp->multi_package)
1299 if (list_empty(&ndp->channel_queue) && found) {
1300 netdev_info(ndp->ndev.dev,
1303 spin_lock_irqsave(&ndp->lock, flags);
1304 list_add_tail_rcu(&found->link, &ndp->channel_queue);
1305 spin_unlock_irqrestore(&ndp->lock, flags);
1307 netdev_warn(ndp->ndev.dev,
1309 ncsi_report_link(ndp, true);
1313 return ncsi_process_next_channel(ndp);
1316 static bool ncsi_check_hwa(struct ncsi_dev_priv *ndp)
1326 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1334 ndp->flags &= ~NCSI_DEV_HWA;
1341 ndp->flags |= NCSI_DEV_HWA;
1345 ndp->flags &= ~NCSI_DEV_HWA;
1349 static void ncsi_probe_channel(struct ncsi_dev_priv *ndp)
1351 struct ncsi_dev *nd = &ndp->ndev;
1358 nca.ndp = ndp;
1365 ndp->pending_req_num = 8;
1380 ndp->pending_req_num = 1;
1384 nca.package = ndp->package_probe_id;
1392 ndp->active_package = ncsi_find_package(ndp,
1393 ndp->package_probe_id);
1394 if (!ndp->active_package) {
1397 schedule_work(&ndp->work);
1402 ndp->mlx_multi_host)
1405 schedule_work(&ndp->work);
1409 ndp->pending_req_num = 1;
1412 nca.package = ndp->active_package->id;
1421 ndp->pending_req_num = 1;
1424 nca.package = ndp->active_package->id;
1434 ndp->pending_req_num = NCSI_RESERVED_CHANNEL;
1438 nca.package = ndp->active_package->id;
1452 ndp->pending_req_num = 1;
1455 nca.package = ndp->active_package->id;
1467 np = ndp->active_package;
1468 ndp->pending_req_num = np->channel_num;
1494 ndp->pending_req_num = 1;
1498 nca.package = ndp->package_probe_id;
1505 ndp->package_probe_id++;
1506 if (ndp->package_probe_id >= 8) {
1508 ndp->flags |= NCSI_DEV_PROBED;
1512 ndp->active_package = NULL;
1519 if (ndp->flags & NCSI_DEV_PROBED) {
1521 ncsi_check_hwa(ndp);
1522 ncsi_choose_active_channel(ndp);
1527 netdev_err(ndp->ndev.dev,
1530 ncsi_report_link(ndp, true);
1535 struct ncsi_dev_priv *ndp = container_of(work,
1537 struct ncsi_dev *nd = &ndp->ndev;
1541 ncsi_probe_channel(ndp);
1544 ncsi_suspend_channel(ndp);
1547 ncsi_configure_channel(ndp);
1555 int ncsi_process_next_channel(struct ncsi_dev_priv *ndp)
1561 spin_lock_irqsave(&ndp->lock, flags);
1562 nc = list_first_or_null_rcu(&ndp->channel_queue,
1565 spin_unlock_irqrestore(&ndp->lock, flags);
1570 spin_unlock_irqrestore(&ndp->lock, flags);
1577 ndp->active_channel = nc;
1578 ndp->active_package = nc->package;
1582 ndp->ndev.state = ncsi_dev_state_config;
1583 netdev_dbg(ndp->ndev.dev, "NCSI: configuring channel %u\n",
1585 ncsi_configure_channel(ndp);
1588 ndp->ndev.state = ncsi_dev_state_suspend;
1589 netdev_dbg(ndp->ndev.dev, "NCSI: suspending channel %u\n",
1591 ncsi_suspend_channel(ndp);
1594 netdev_err(ndp->ndev.dev, "Invalid state 0x%x on %d:%d\n",
1596 ncsi_report_link(ndp, false);
1603 ndp->active_channel = NULL;
1604 ndp->active_package = NULL;
1605 if (ndp->flags & NCSI_DEV_RESHUFFLE) {
1606 ndp->flags &= ~NCSI_DEV_RESHUFFLE;
1607 return ncsi_choose_active_channel(ndp);
1610 ncsi_report_link(ndp, false);
1614 static int ncsi_kick_channels(struct ncsi_dev_priv *ndp)
1616 struct ncsi_dev *nd = &ndp->ndev;
1622 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1633 if ((ndp->ndev.state & 0xff00) ==
1652 spin_lock_irqsave(&ndp->lock, flags);
1653 list_add_tail_rcu(&nc->link, &ndp->channel_queue);
1654 spin_unlock_irqrestore(&ndp->lock, flags);
1666 struct ncsi_dev_priv *ndp;
1681 ndp = TO_NCSI_DEV_PRIV(nd);
1684 list_for_each_entry_rcu(vlan, &ndp->vlan_vids, list) {
1705 list_add_rcu(&vlan->list, &ndp->vlan_vids);
1709 found = ncsi_kick_channels(ndp) != 0;
1711 return found ? ncsi_process_next_channel(ndp) : 0;
1718 struct ncsi_dev_priv *ndp;
1731 ndp = TO_NCSI_DEV_PRIV(nd);
1734 list_for_each_entry_safe(vlan, tmp, &ndp->vlan_vids, list)
1747 found = ncsi_kick_channels(ndp) != 0;
1749 return found ? ncsi_process_next_channel(ndp) : 0;
1756 struct ncsi_dev_priv *ndp;
1769 ndp = kzalloc(sizeof(*ndp), GFP_ATOMIC);
1770 if (!ndp)
1773 nd = &ndp->ndev;
1777 ndp->pending_req_num = 0;
1778 INIT_LIST_HEAD(&ndp->channel_queue);
1779 INIT_LIST_HEAD(&ndp->vlan_vids);
1780 INIT_WORK(&ndp->work, ncsi_dev_work);
1781 ndp->package_whitelist = UINT_MAX;
1784 spin_lock_init(&ndp->lock);
1785 INIT_LIST_HEAD(&ndp->packages);
1786 ndp->request_id = NCSI_REQ_START_IDX;
1787 for (i = 0; i < ARRAY_SIZE(ndp->requests); i++) {
1788 ndp->requests[i].id = i;
1789 ndp->requests[i].ndp = ndp;
1790 timer_setup(&ndp->requests[i].timer, ncsi_request_timeout, 0);
1794 list_add_tail_rcu(&ndp->node, &ncsi_dev_list);
1798 ndp->ptype.type = cpu_to_be16(ETH_P_NCSI);
1799 ndp->ptype.func = ncsi_rcv_rsp;
1800 ndp->ptype.dev = dev;
1801 dev_add_pack(&ndp->ptype);
1808 ndp->mlx_multi_host = true;
1817 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1823 if (!(ndp->flags & NCSI_DEV_PROBED)) {
1824 ndp->package_probe_id = 0;
1826 schedule_work(&ndp->work);
1836 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1847 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1861 netdev_dbg(ndp->ndev.dev, "NCSI: Stopping device\n");
1862 ncsi_report_link(ndp, true);
1868 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1873 spin_lock_irqsave(&ndp->lock, flags);
1875 if (!(ndp->flags & NCSI_DEV_RESET)) {
1881 spin_unlock_irqrestore(&ndp->lock, flags);
1889 ndp->flags |= NCSI_DEV_RESET;
1890 spin_unlock_irqrestore(&ndp->lock, flags);
1902 spin_unlock_irqrestore(&ndp->lock, flags);
1907 if (!list_empty(&ndp->channel_queue)) {
1909 list_for_each_entry_safe(nc, tmp, &ndp->channel_queue, link)
1912 spin_unlock_irqrestore(&ndp->lock, flags);
1915 NCSI_FOR_EACH_PACKAGE(ndp, np) {
1935 spin_lock_irqsave(&ndp->lock, flags);
1936 ndp->flags &= ~NCSI_DEV_RESET;
1937 spin_unlock_irqrestore(&ndp->lock, flags);
1938 return ncsi_choose_active_channel(ndp);
1941 spin_lock_irqsave(&ndp->lock, flags);
1942 ndp->flags |= NCSI_DEV_RESET;
1943 ndp->active_channel = active;
1944 ndp->active_package = active->package;
1945 spin_unlock_irqrestore(&ndp->lock, flags);
1948 schedule_work(&ndp->work);
1954 struct ncsi_dev_priv *ndp = TO_NCSI_DEV_PRIV(nd);
1958 dev_remove_pack(&ndp->ptype);
1960 list_for_each_entry_safe(np, tmp, &ndp->packages, node)
1964 list_del_rcu(&ndp->node);
1967 kfree(ndp);