Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/netdev-2.6
* 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik/netdev-2.6:
- cxgb3 engine microcode load
cxgb3 - Fix dev->priv usage
qeth: Drop ARP packages on HiperSockets interface with NOARP attribute.
qeth: provide specific message for OSA-adapters exclusively used
qeth: crash during reboot after failing online setting
qeth: Announce tx checksumming for qeth devices in TSO/EDDP mode
qeth: dont return the return values of void functions.
qeth: enforce a rate limit for inbound scatter gather messages
qeth: ungrouping a device must not be interruptible
netxen: fix crashes during module unload
netxen: Avoid firmware load in PCI probe
PS3: fix the bug that 'ifconfig down' would hang
IOC3: Program UART predividers.
+427
-205
+1
-1
drivers/infiniband/hw/cxgb3/cxio_hal.c
+1
-1
drivers/infiniband/hw/cxgb3/cxio_hal.c
···
916
916
PDBG("%s opening rnic dev %s\n", __FUNCTION__, rdev_p->dev_name);
917
917
memset(&rdev_p->ctrl_qp, 0, sizeof(rdev_p->ctrl_qp));
918
918
if (!rdev_p->t3cdev_p)
919
-
rdev_p->t3cdev_p = T3CDEV(netdev_p);
919
+
rdev_p->t3cdev_p = dev2t3cdev(netdev_p);
920
920
rdev_p->t3cdev_p->ulp = (void *) rdev_p;
921
921
err = rdev_p->t3cdev_p->ctl(rdev_p->t3cdev_p, RDMA_GET_PARAMS,
922
922
&(rdev_p->rnic_info));
+2
drivers/net/cxgb3/adapter.h
+2
drivers/net/cxgb3/adapter.h
+2
-1
drivers/net/cxgb3/common.h
+2
-1
drivers/net/cxgb3/common.h
···
679
679
int t3_seeprom_read(struct adapter *adapter, u32 addr, u32 *data);
680
680
int t3_seeprom_write(struct adapter *adapter, u32 addr, u32 data);
681
681
int t3_seeprom_wp(struct adapter *adapter, int enable);
682
-
int t3_check_tpsram_version(struct adapter *adapter);
682
+
int t3_get_tp_version(struct adapter *adapter, u32 *vers);
683
+
int t3_check_tpsram_version(struct adapter *adapter, int *must_load);
683
684
int t3_check_tpsram(struct adapter *adapter, u8 *tp_ram, unsigned int size);
684
685
int t3_set_proto_sram(struct adapter *adap, u8 *data);
685
686
int t3_read_flash(struct adapter *adapter, unsigned int addr,
+153
-99
drivers/net/cxgb3/cxgb3_main.c
+153
-99
drivers/net/cxgb3/cxgb3_main.c
···
358
358
359
359
for (j = 0; j < pi->nqsets - 1; j++) {
360
360
if (!adap->dummy_netdev[dummy_idx]) {
361
-
nd = alloc_netdev(0, "", ether_setup);
361
+
struct port_info *p;
362
+
363
+
nd = alloc_netdev(sizeof(*p), "", ether_setup);
362
364
if (!nd)
363
365
goto free_all;
364
366
365
-
nd->priv = adap;
367
+
p = netdev_priv(nd);
368
+
p->adapter = adap;
366
369
nd->weight = 64;
367
370
set_bit(__LINK_STATE_START, &nd->state);
368
371
adap->dummy_netdev[dummy_idx] = nd;
···
485
482
#define CXGB3_SHOW(name, val_expr) \
486
483
static ssize_t format_##name(struct net_device *dev, char *buf) \
487
484
{ \
488
-
struct adapter *adap = dev->priv; \
485
+
struct port_info *pi = netdev_priv(dev); \
486
+
struct adapter *adap = pi->adapter; \
489
487
return sprintf(buf, "%u\n", val_expr); \
490
488
} \
491
489
static ssize_t show_##name(struct device *d, struct device_attribute *attr, \
···
497
493
498
494
static ssize_t set_nfilters(struct net_device *dev, unsigned int val)
499
495
{
500
-
struct adapter *adap = dev->priv;
496
+
struct port_info *pi = netdev_priv(dev);
497
+
struct adapter *adap = pi->adapter;
501
498
int min_tids = is_offload(adap) ? MC5_MIN_TIDS : 0;
502
499
503
500
if (adap->flags & FULL_INIT_DONE)
···
520
515
521
516
static ssize_t set_nservers(struct net_device *dev, unsigned int val)
522
517
{
523
-
struct adapter *adap = dev->priv;
518
+
struct port_info *pi = netdev_priv(dev);
519
+
struct adapter *adap = pi->adapter;
524
520
525
521
if (adap->flags & FULL_INIT_DONE)
526
522
return -EBUSY;
···
562
556
static ssize_t tm_attr_show(struct device *d, struct device_attribute *attr,
563
557
char *buf, int sched)
564
558
{
565
-
ssize_t len;
559
+
struct port_info *pi = netdev_priv(to_net_dev(d));
560
+
struct adapter *adap = pi->adapter;
566
561
unsigned int v, addr, bpt, cpt;
567
-
struct adapter *adap = to_net_dev(d)->priv;
562
+
ssize_t len;
568
563
569
564
addr = A_TP_TX_MOD_Q1_Q0_RATE_LIMIT - sched / 2;
570
565
rtnl_lock();
···
588
581
static ssize_t tm_attr_store(struct device *d, struct device_attribute *attr,
589
582
const char *buf, size_t len, int sched)
590
583
{
584
+
struct port_info *pi = netdev_priv(to_net_dev(d));
585
+
struct adapter *adap = pi->adapter;
586
+
unsigned int val;
591
587
char *endp;
592
588
ssize_t ret;
593
-
unsigned int val;
594
-
struct adapter *adap = to_net_dev(d)->priv;
595
589
596
590
if (!capable(CAP_NET_ADMIN))
597
591
return -EPERM;
···
729
721
}
730
722
731
723
#define FW_FNAME "t3fw-%d.%d.%d.bin"
724
+
#define TPSRAM_NAME "t3%c_protocol_sram-%d.%d.%d.bin"
732
725
733
726
static int upgrade_fw(struct adapter *adap)
734
727
{
···
748
739
}
749
740
ret = t3_load_fw(adap, fw->data, fw->size);
750
741
release_firmware(fw);
742
+
743
+
if (ret == 0)
744
+
dev_info(dev, "successful upgrade to firmware %d.%d.%d\n",
745
+
FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO);
746
+
else
747
+
dev_err(dev, "failed to upgrade to firmware %d.%d.%d\n",
748
+
FW_VERSION_MAJOR, FW_VERSION_MINOR, FW_VERSION_MICRO);
749
+
750
+
return ret;
751
+
}
752
+
753
+
static inline char t3rev2char(struct adapter *adapter)
754
+
{
755
+
char rev = 0;
756
+
757
+
switch(adapter->params.rev) {
758
+
case T3_REV_B:
759
+
case T3_REV_B2:
760
+
rev = 'b';
761
+
break;
762
+
}
763
+
return rev;
764
+
}
765
+
766
+
int update_tpsram(struct adapter *adap)
767
+
{
768
+
const struct firmware *tpsram;
769
+
char buf[64];
770
+
struct device *dev = &adap->pdev->dev;
771
+
int ret;
772
+
char rev;
773
+
774
+
rev = t3rev2char(adap);
775
+
if (!rev)
776
+
return 0;
777
+
778
+
snprintf(buf, sizeof(buf), TPSRAM_NAME, rev,
779
+
TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
780
+
781
+
ret = request_firmware(&tpsram, buf, dev);
782
+
if (ret < 0) {
783
+
dev_err(dev, "could not load TP SRAM: unable to load %s\n",
784
+
buf);
785
+
return ret;
786
+
}
787
+
788
+
ret = t3_check_tpsram(adap, tpsram->data, tpsram->size);
789
+
if (ret)
790
+
goto release_tpsram;
791
+
792
+
ret = t3_set_proto_sram(adap, tpsram->data);
793
+
if (ret == 0)
794
+
dev_info(dev,
795
+
"successful update of protocol engine "
796
+
"to %d.%d.%d\n",
797
+
TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
798
+
else
799
+
dev_err(dev, "failed to update of protocol engine %d.%d.%d\n",
800
+
TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
801
+
if (ret)
802
+
dev_err(dev, "loading protocol SRAM failed\n");
803
+
804
+
release_tpsram:
805
+
release_firmware(tpsram);
806
+
751
807
return ret;
752
808
}
753
809
···
829
755
static int cxgb_up(struct adapter *adap)
830
756
{
831
757
int err = 0;
758
+
int must_load;
832
759
833
760
if (!(adap->flags & FULL_INIT_DONE)) {
834
761
err = t3_check_fw_version(adap);
···
837
762
err = upgrade_fw(adap);
838
763
if (err)
839
764
goto out;
765
+
766
+
err = t3_check_tpsram_version(adap, &must_load);
767
+
if (err == -EINVAL) {
768
+
err = update_tpsram(adap);
769
+
if (err && must_load)
770
+
goto out;
771
+
}
840
772
841
773
err = init_dummy_netdevs(adap);
842
774
if (err)
···
940
858
941
859
static int offload_open(struct net_device *dev)
942
860
{
943
-
struct adapter *adapter = dev->priv;
944
-
struct t3cdev *tdev = T3CDEV(dev);
861
+
struct port_info *pi = netdev_priv(dev);
862
+
struct adapter *adapter = pi->adapter;
863
+
struct t3cdev *tdev = dev2t3cdev(dev);
945
864
int adap_up = adapter->open_device_map & PORT_MASK;
946
865
int err = 0;
947
866
···
1007
924
1008
925
static int cxgb_open(struct net_device *dev)
1009
926
{
1010
-
int err;
1011
-
struct adapter *adapter = dev->priv;
1012
927
struct port_info *pi = netdev_priv(dev);
928
+
struct adapter *adapter = pi->adapter;
1013
929
int other_ports = adapter->open_device_map & PORT_MASK;
930
+
int err;
1014
931
1015
932
if (!adapter->open_device_map && (err = cxgb_up(adapter)) < 0)
1016
933
return err;
···
1034
951
1035
952
static int cxgb_close(struct net_device *dev)
1036
953
{
1037
-
struct adapter *adapter = dev->priv;
1038
-
struct port_info *p = netdev_priv(dev);
954
+
struct port_info *pi = netdev_priv(dev);
955
+
struct adapter *adapter = pi->adapter;
1039
956
1040
-
t3_port_intr_disable(adapter, p->port_id);
957
+
t3_port_intr_disable(adapter, pi->port_id);
1041
958
netif_stop_queue(dev);
1042
-
p->phy.ops->power_down(&p->phy, 1);
959
+
pi->phy.ops->power_down(&pi->phy, 1);
1043
960
netif_carrier_off(dev);
1044
-
t3_mac_disable(&p->mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
961
+
t3_mac_disable(&pi->mac, MAC_DIRECTION_TX | MAC_DIRECTION_RX);
1045
962
1046
963
spin_lock(&adapter->work_lock); /* sync with update task */
1047
-
clear_bit(p->port_id, &adapter->open_device_map);
964
+
clear_bit(pi->port_id, &adapter->open_device_map);
1048
965
spin_unlock(&adapter->work_lock);
1049
966
1050
967
if (!(adapter->open_device_map & PORT_MASK))
···
1059
976
1060
977
static struct net_device_stats *cxgb_get_stats(struct net_device *dev)
1061
978
{
1062
-
struct adapter *adapter = dev->priv;
1063
-
struct port_info *p = netdev_priv(dev);
1064
-
struct net_device_stats *ns = &p->netstats;
979
+
struct port_info *pi = netdev_priv(dev);
980
+
struct adapter *adapter = pi->adapter;
981
+
struct net_device_stats *ns = &pi->netstats;
1065
982
const struct mac_stats *pstats;
1066
983
1067
984
spin_lock(&adapter->stats_lock);
1068
-
pstats = t3_mac_update_stats(&p->mac);
985
+
pstats = t3_mac_update_stats(&pi->mac);
1069
986
spin_unlock(&adapter->stats_lock);
1070
987
1071
988
ns->tx_bytes = pstats->tx_octets;
···
1098
1015
1099
1016
static u32 get_msglevel(struct net_device *dev)
1100
1017
{
1101
-
struct adapter *adapter = dev->priv;
1018
+
struct port_info *pi = netdev_priv(dev);
1019
+
struct adapter *adapter = pi->adapter;
1102
1020
1103
1021
return adapter->msg_enable;
1104
1022
}
1105
1023
1106
1024
static void set_msglevel(struct net_device *dev, u32 val)
1107
1025
{
1108
-
struct adapter *adapter = dev->priv;
1026
+
struct port_info *pi = netdev_priv(dev);
1027
+
struct adapter *adapter = pi->adapter;
1109
1028
1110
1029
adapter->msg_enable = val;
1111
1030
}
···
1181
1096
1182
1097
static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1183
1098
{
1099
+
struct port_info *pi = netdev_priv(dev);
1100
+
struct adapter *adapter = pi->adapter;
1184
1101
u32 fw_vers = 0;
1185
-
struct adapter *adapter = dev->priv;
1102
+
u32 tp_vers = 0;
1186
1103
1187
1104
t3_get_fw_version(adapter, &fw_vers);
1105
+
t3_get_tp_version(adapter, &tp_vers);
1188
1106
1189
1107
strcpy(info->driver, DRV_NAME);
1190
1108
strcpy(info->version, DRV_VERSION);
···
1196
1108
strcpy(info->fw_version, "N/A");
1197
1109
else {
1198
1110
snprintf(info->fw_version, sizeof(info->fw_version),
1199
-
"%s %u.%u.%u",
1111
+
"%s %u.%u.%u TP %u.%u.%u",
1200
1112
G_FW_VERSION_TYPE(fw_vers) ? "T" : "N",
1201
1113
G_FW_VERSION_MAJOR(fw_vers),
1202
1114
G_FW_VERSION_MINOR(fw_vers),
1203
-
G_FW_VERSION_MICRO(fw_vers));
1115
+
G_FW_VERSION_MICRO(fw_vers),
1116
+
G_TP_VERSION_MAJOR(tp_vers),
1117
+
G_TP_VERSION_MINOR(tp_vers),
1118
+
G_TP_VERSION_MICRO(tp_vers));
1204
1119
}
1205
1120
}
1206
1121
···
1227
1136
static void get_stats(struct net_device *dev, struct ethtool_stats *stats,
1228
1137
u64 *data)
1229
1138
{
1230
-
struct adapter *adapter = dev->priv;
1231
1139
struct port_info *pi = netdev_priv(dev);
1140
+
struct adapter *adapter = pi->adapter;
1232
1141
const struct mac_stats *s;
1233
1142
1234
1143
spin_lock(&adapter->stats_lock);
···
1296
1205
static void get_regs(struct net_device *dev, struct ethtool_regs *regs,
1297
1206
void *buf)
1298
1207
{
1299
-
struct adapter *ap = dev->priv;
1208
+
struct port_info *pi = netdev_priv(dev);
1209
+
struct adapter *ap = pi->adapter;
1300
1210
1301
1211
/*
1302
1212
* Version scheme:
···
1338
1246
1339
1247
static int cxgb3_phys_id(struct net_device *dev, u32 data)
1340
1248
{
1249
+
struct port_info *pi = netdev_priv(dev);
1250
+
struct adapter *adapter = pi->adapter;
1341
1251
int i;
1342
-
struct adapter *adapter = dev->priv;
1343
1252
1344
1253
if (data == 0)
1345
1254
data = 2;
···
1501
1408
1502
1409
static void get_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
1503
1410
{
1504
-
const struct adapter *adapter = dev->priv;
1505
-
const struct port_info *pi = netdev_priv(dev);
1411
+
struct port_info *pi = netdev_priv(dev);
1412
+
struct adapter *adapter = pi->adapter;
1506
1413
const struct qset_params *q = &adapter->params.sge.qset[pi->first_qset];
1507
1414
1508
1415
e->rx_max_pending = MAX_RX_BUFFERS;
···
1518
1425
1519
1426
static int set_sge_param(struct net_device *dev, struct ethtool_ringparam *e)
1520
1427
{
1521
-
int i;
1428
+
struct port_info *pi = netdev_priv(dev);
1429
+
struct adapter *adapter = pi->adapter;
1522
1430
struct qset_params *q;
1523
-
struct adapter *adapter = dev->priv;
1524
-
const struct port_info *pi = netdev_priv(dev);
1431
+
int i;
1525
1432
1526
1433
if (e->rx_pending > MAX_RX_BUFFERS ||
1527
1434
e->rx_jumbo_pending > MAX_RX_JUMBO_BUFFERS ||
···
1550
1457
1551
1458
static int set_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
1552
1459
{
1553
-
struct adapter *adapter = dev->priv;
1460
+
struct port_info *pi = netdev_priv(dev);
1461
+
struct adapter *adapter = pi->adapter;
1554
1462
struct qset_params *qsp = &adapter->params.sge.qset[0];
1555
1463
struct sge_qset *qs = &adapter->sge.qs[0];
1556
1464
···
1565
1471
1566
1472
static int get_coalesce(struct net_device *dev, struct ethtool_coalesce *c)
1567
1473
{
1568
-
struct adapter *adapter = dev->priv;
1474
+
struct port_info *pi = netdev_priv(dev);
1475
+
struct adapter *adapter = pi->adapter;
1569
1476
struct qset_params *q = adapter->params.sge.qset;
1570
1477
1571
1478
c->rx_coalesce_usecs = q->coalesce_usecs;
···
1576
1481
static int get_eeprom(struct net_device *dev, struct ethtool_eeprom *e,
1577
1482
u8 * data)
1578
1483
{
1484
+
struct port_info *pi = netdev_priv(dev);
1485
+
struct adapter *adapter = pi->adapter;
1579
1486
int i, err = 0;
1580
-
struct adapter *adapter = dev->priv;
1581
1487
1582
1488
u8 *buf = kmalloc(EEPROMSIZE, GFP_KERNEL);
1583
1489
if (!buf)
···
1597
1501
static int set_eeprom(struct net_device *dev, struct ethtool_eeprom *eeprom,
1598
1502
u8 * data)
1599
1503
{
1504
+
struct port_info *pi = netdev_priv(dev);
1505
+
struct adapter *adapter = pi->adapter;
1506
+
u32 aligned_offset, aligned_len, *p;
1600
1507
u8 *buf;
1601
1508
int err = 0;
1602
-
u32 aligned_offset, aligned_len, *p;
1603
-
struct adapter *adapter = dev->priv;
1604
1509
1605
1510
if (eeprom->magic != EEPROM_MAGIC)
1606
1511
return -EINVAL;
···
1689
1592
1690
1593
static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr)
1691
1594
{
1692
-
int ret;
1595
+
struct port_info *pi = netdev_priv(dev);
1596
+
struct adapter *adapter = pi->adapter;
1693
1597
u32 cmd;
1694
-
struct adapter *adapter = dev->priv;
1598
+
int ret;
1695
1599
1696
1600
if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
1697
1601
return -EFAULT;
···
2021
1923
2022
1924
static int cxgb_ioctl(struct net_device *dev, struct ifreq *req, int cmd)
2023
1925
{
2024
-
int ret, mmd;
2025
-
struct adapter *adapter = dev->priv;
2026
-
struct port_info *pi = netdev_priv(dev);
2027
1926
struct mii_ioctl_data *data = if_mii(req);
1927
+
struct port_info *pi = netdev_priv(dev);
1928
+
struct adapter *adapter = pi->adapter;
1929
+
int ret, mmd;
2028
1930
2029
1931
switch (cmd) {
2030
1932
case SIOCGMIIPHY:
···
2092
1994
2093
1995
static int cxgb_change_mtu(struct net_device *dev, int new_mtu)
2094
1996
{
2095
-
int ret;
2096
-
struct adapter *adapter = dev->priv;
2097
1997
struct port_info *pi = netdev_priv(dev);
1998
+
struct adapter *adapter = pi->adapter;
1999
+
int ret;
2098
2000
2099
2001
if (new_mtu < 81) /* accommodate SACK */
2100
2002
return -EINVAL;
···
2111
2013
2112
2014
static int cxgb_set_mac_addr(struct net_device *dev, void *p)
2113
2015
{
2114
-
struct adapter *adapter = dev->priv;
2115
2016
struct port_info *pi = netdev_priv(dev);
2017
+
struct adapter *adapter = pi->adapter;
2116
2018
struct sockaddr *addr = p;
2117
2019
2118
2020
if (!is_valid_ether_addr(addr->sa_data))
···
2148
2050
2149
2051
static void vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
2150
2052
{
2151
-
struct adapter *adapter = dev->priv;
2152
2053
struct port_info *pi = netdev_priv(dev);
2054
+
struct adapter *adapter = pi->adapter;
2153
2055
2154
2056
pi->vlan_grp = grp;
2155
2057
if (adapter->params.rev > 0)
···
2168
2070
#ifdef CONFIG_NET_POLL_CONTROLLER
2169
2071
static void cxgb_netpoll(struct net_device *dev)
2170
2072
{
2171
-
struct adapter *adapter = dev->priv;
2172
2073
struct port_info *pi = netdev_priv(dev);
2074
+
struct adapter *adapter = pi->adapter;
2173
2075
int qidx;
2174
2076
2175
2077
for (qidx = pi->first_qset; qidx < pi->first_qset + pi->nqsets; qidx++) {
···
2185
2087
}
2186
2088
}
2187
2089
#endif
2188
-
2189
-
#define TPSRAM_NAME "t3%c_protocol_sram-%d.%d.%d.bin"
2190
-
int update_tpsram(struct adapter *adap)
2191
-
{
2192
-
const struct firmware *tpsram;
2193
-
char buf[64];
2194
-
struct device *dev = &adap->pdev->dev;
2195
-
int ret;
2196
-
char rev;
2197
-
2198
-
rev = adap->params.rev == T3_REV_B2 ? 'b' : 'a';
2199
-
2200
-
snprintf(buf, sizeof(buf), TPSRAM_NAME, rev,
2201
-
TP_VERSION_MAJOR, TP_VERSION_MINOR, TP_VERSION_MICRO);
2202
-
2203
-
ret = request_firmware(&tpsram, buf, dev);
2204
-
if (ret < 0) {
2205
-
dev_err(dev, "could not load TP SRAM: unable to load %s\n",
2206
-
buf);
2207
-
return ret;
2208
-
}
2209
-
2210
-
ret = t3_check_tpsram(adap, tpsram->data, tpsram->size);
2211
-
if (ret)
2212
-
goto release_tpsram;
2213
-
2214
-
ret = t3_set_proto_sram(adap, tpsram->data);
2215
-
if (ret)
2216
-
dev_err(dev, "loading protocol SRAM failed\n");
2217
-
2218
-
release_tpsram:
2219
-
release_firmware(tpsram);
2220
-
2221
-
return ret;
2222
-
}
2223
-
2224
2090
2225
2091
/*
2226
2092
* Periodic accumulation of MAC statistics.
···
2495
2433
2496
2434
adapter->port[i] = netdev;
2497
2435
pi = netdev_priv(netdev);
2436
+
pi->adapter = adapter;
2498
2437
pi->rx_csum_offload = 1;
2499
2438
pi->nqsets = 1;
2500
2439
pi->first_qset = i;
···
2505
2442
netdev->irq = pdev->irq;
2506
2443
netdev->mem_start = mmio_start;
2507
2444
netdev->mem_end = mmio_start + mmio_len - 1;
2508
-
netdev->priv = adapter;
2509
2445
netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO;
2510
2446
netdev->features |= NETIF_F_LLTX;
2511
2447
if (pci_using_dac)
···
2529
2467
SET_ETHTOOL_OPS(netdev, &cxgb_ethtool_ops);
2530
2468
}
2531
2469
2532
-
pci_set_drvdata(pdev, adapter->port[0]);
2470
+
pci_set_drvdata(pdev, adapter);
2533
2471
if (t3_prep_adapter(adapter, ai, 1) < 0) {
2534
2472
err = -ENODEV;
2535
2473
goto out_free_dev;
2536
2474
}
2537
-
2538
-
err = t3_check_tpsram_version(adapter);
2539
-
if (err == -EINVAL)
2540
-
err = update_tpsram(adapter);
2541
-
2542
-
if (err)
2543
-
goto out_free_dev;
2544
2475
2545
2476
/*
2546
2477
* The card is now ready to go. If any errors occur during device
···
2602
2547
2603
2548
static void __devexit remove_one(struct pci_dev *pdev)
2604
2549
{
2605
-
struct net_device *dev = pci_get_drvdata(pdev);
2550
+
struct adapter *adapter = pci_get_drvdata(pdev);
2606
2551
2607
-
if (dev) {
2552
+
if (adapter) {
2608
2553
int i;
2609
-
struct adapter *adapter = dev->priv;
2610
2554
2611
2555
t3_sge_stop(adapter);
2612
2556
sysfs_remove_group(&adapter->port[0]->dev.kobj,
+13
-3
drivers/net/cxgb3/cxgb3_offload.c
+13
-3
drivers/net/cxgb3/cxgb3_offload.c
···
593
593
594
594
EXPORT_SYMBOL(cxgb3_alloc_stid);
595
595
596
+
/* Get the t3cdev associated with a net_device */
597
+
struct t3cdev *dev2t3cdev(struct net_device *dev)
598
+
{
599
+
const struct port_info *pi = netdev_priv(dev);
600
+
601
+
return (struct t3cdev *)pi->adapter;
602
+
}
603
+
604
+
EXPORT_SYMBOL(dev2t3cdev);
605
+
596
606
static int do_smt_write_rpl(struct t3cdev *dev, struct sk_buff *skb)
597
607
{
598
608
struct cpl_smt_write_rpl *rpl = cplhdr(skb);
···
935
925
struct net_device *dev = neigh->dev;
936
926
937
927
if (dev && (is_offloading(dev))) {
938
-
struct t3cdev *tdev = T3CDEV(dev);
928
+
struct t3cdev *tdev = dev2t3cdev(dev);
939
929
940
930
BUG_ON(!tdev);
941
931
t3_l2t_update(tdev, neigh);
···
983
973
"device ignored.\n", __FUNCTION__);
984
974
return;
985
975
}
986
-
tdev = T3CDEV(olddev);
976
+
tdev = dev2t3cdev(olddev);
987
977
BUG_ON(!tdev);
988
-
if (tdev != T3CDEV(newdev)) {
978
+
if (tdev != dev2t3cdev(newdev)) {
989
979
printk(KERN_WARNING "%s: Redirect to different "
990
980
"offload device ignored.\n", __FUNCTION__);
991
981
return;
+2
drivers/net/cxgb3/cxgb3_offload.h
+2
drivers/net/cxgb3/cxgb3_offload.h
+15
-8
drivers/net/cxgb3/sge.c
+15
-8
drivers/net/cxgb3/sge.c
···
1073
1073
{
1074
1074
unsigned int ndesc, pidx, credits, gen, compl;
1075
1075
const struct port_info *pi = netdev_priv(dev);
1076
-
struct adapter *adap = dev->priv;
1076
+
struct adapter *adap = pi->adapter;
1077
1077
struct sge_qset *qs = dev2qset(dev);
1078
1078
struct sge_txq *q = &qs->txq[TXQ_ETH];
1079
1079
···
1326
1326
struct sk_buff *skb;
1327
1327
struct sge_qset *qs = (struct sge_qset *)data;
1328
1328
struct sge_txq *q = &qs->txq[TXQ_CTRL];
1329
-
struct adapter *adap = qs->netdev->priv;
1329
+
const struct port_info *pi = netdev_priv(qs->netdev);
1330
+
struct adapter *adap = pi->adapter;
1330
1331
1331
1332
spin_lock(&q->lock);
1332
1333
again:reclaim_completed_tx_imm(q);
···
1532
1531
struct sk_buff *skb;
1533
1532
struct sge_qset *qs = (struct sge_qset *)data;
1534
1533
struct sge_txq *q = &qs->txq[TXQ_OFLD];
1535
-
struct adapter *adap = qs->netdev->priv;
1534
+
const struct port_info *pi = netdev_priv(qs->netdev);
1535
+
struct adapter *adap = pi->adapter;
1536
1536
1537
1537
spin_lock(&q->lock);
1538
1538
again:reclaim_completed_tx(adap, q);
···
1677
1675
*/
1678
1676
static int ofld_poll(struct net_device *dev, int *budget)
1679
1677
{
1680
-
struct adapter *adapter = dev->priv;
1678
+
const struct port_info *pi = netdev_priv(dev);
1679
+
struct adapter *adapter = pi->adapter;
1681
1680
struct sge_qset *qs = dev2qset(dev);
1682
1681
struct sge_rspq *q = &qs->rspq;
1683
1682
int work_done, limit = min(*budget, dev->quota), avail = limit;
···
2078
2075
*/
2079
2076
static int napi_rx_handler(struct net_device *dev, int *budget)
2080
2077
{
2081
-
struct adapter *adap = dev->priv;
2078
+
const struct port_info *pi = netdev_priv(dev);
2079
+
struct adapter *adap = pi->adapter;
2082
2080
struct sge_qset *qs = dev2qset(dev);
2083
2081
int effective_budget = min(*budget, dev->quota);
2084
2082
···
2209
2205
irqreturn_t t3_sge_intr_msix(int irq, void *cookie)
2210
2206
{
2211
2207
struct sge_qset *qs = cookie;
2212
-
struct adapter *adap = qs->netdev->priv;
2208
+
const struct port_info *pi = netdev_priv(qs->netdev);
2209
+
struct adapter *adap = pi->adapter;
2213
2210
struct sge_rspq *q = &qs->rspq;
2214
2211
2215
2212
spin_lock(&q->lock);
···
2229
2224
irqreturn_t t3_sge_intr_msix_napi(int irq, void *cookie)
2230
2225
{
2231
2226
struct sge_qset *qs = cookie;
2232
-
struct adapter *adap = qs->netdev->priv;
2227
+
const struct port_info *pi = netdev_priv(qs->netdev);
2228
+
struct adapter *adap = pi->adapter;
2233
2229
struct sge_rspq *q = &qs->rspq;
2234
2230
2235
2231
spin_lock(&q->lock);
···
2514
2508
{
2515
2509
spinlock_t *lock;
2516
2510
struct sge_qset *qs = (struct sge_qset *)data;
2517
-
struct adapter *adap = qs->netdev->priv;
2511
+
const struct port_info *pi = netdev_priv(qs->netdev);
2512
+
struct adapter *adap = pi->adapter;
2518
2513
2519
2514
if (spin_trylock(&qs->txq[TXQ_ETH].lock)) {
2520
2515
reclaim_completed_tx(adap, &qs->txq[TXQ_ETH]);
+40
-6
drivers/net/cxgb3/t3_hw.c
+40
-6
drivers/net/cxgb3/t3_hw.c
···
848
848
}
849
849
850
850
/**
851
-
* t3_check_tpsram_version - read the tp sram version
851
+
* t3_get_tp_version - read the tp sram version
852
852
* @adapter: the adapter
853
+
* @vers: where to place the version
853
854
*
854
-
* Reads the protocol sram version from serial eeprom.
855
+
* Reads the protocol sram version from sram.
855
856
*/
856
-
int t3_check_tpsram_version(struct adapter *adapter)
857
+
int t3_get_tp_version(struct adapter *adapter, u32 *vers)
857
858
{
858
859
int ret;
859
-
u32 vers;
860
-
unsigned int major, minor;
861
860
862
861
/* Get version loaded in SRAM */
863
862
t3_write_reg(adapter, A_TP_EMBED_OP_FIELD0, 0);
···
865
866
if (ret)
866
867
return ret;
867
868
868
-
vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);
869
+
*vers = t3_read_reg(adapter, A_TP_EMBED_OP_FIELD1);
870
+
871
+
return 0;
872
+
}
873
+
874
+
/**
875
+
* t3_check_tpsram_version - read the tp sram version
876
+
* @adapter: the adapter
877
+
* @must_load: set to 1 if loading a new microcode image is required
878
+
*
879
+
* Reads the protocol sram version from flash.
880
+
*/
881
+
int t3_check_tpsram_version(struct adapter *adapter, int *must_load)
882
+
{
883
+
int ret;
884
+
u32 vers;
885
+
unsigned int major, minor;
886
+
887
+
if (adapter->params.rev == T3_REV_A)
888
+
return 0;
889
+
890
+
*must_load = 1;
891
+
892
+
ret = t3_get_tp_version(adapter, &vers);
893
+
if (ret)
894
+
return ret;
869
895
870
896
major = G_TP_VERSION_MAJOR(vers);
871
897
minor = G_TP_VERSION_MINOR(vers);
···
898
874
if (major == TP_VERSION_MAJOR && minor == TP_VERSION_MINOR)
899
875
return 0;
900
876
877
+
if (major != TP_VERSION_MAJOR)
878
+
CH_ERR(adapter, "found wrong TP version (%u.%u), "
879
+
"driver needs version %d.%d\n", major, minor,
880
+
TP_VERSION_MAJOR, TP_VERSION_MINOR);
881
+
else {
882
+
*must_load = 0;
883
+
CH_ERR(adapter, "found wrong TP version (%u.%u), "
884
+
"driver compiled for version %d.%d\n", major, minor,
885
+
TP_VERSION_MAJOR, TP_VERSION_MINOR);
886
+
}
901
887
return -EINVAL;
902
888
}
903
889
-3
drivers/net/cxgb3/t3cdev.h
-3
drivers/net/cxgb3/t3cdev.h
+59
-19
drivers/net/ioc3-eth.c
+59
-19
drivers/net/ioc3-eth.c
···
48
48
#ifdef CONFIG_SERIAL_8250
49
49
#include <linux/serial_core.h>
50
50
#include <linux/serial_8250.h>
51
+
#include <linux/serial_reg.h>
51
52
#endif
52
53
53
54
#include <linux/netdevice.h>
···
1152
1151
* Also look in ip27-pci.c:pci_fixup_ioc3() for some comments on working
1153
1152
* around ioc3 oddities in this respect.
1154
1153
*
1155
-
* The IOC3 serials use a 22MHz clock rate with an additional divider by 3.
1154
+
* The IOC3 serials use a 22MHz clock rate with an additional divider which
1155
+
* can be programmed in the SCR register if the DLAB bit is set.
1156
+
*
1157
+
* Register to interrupt zero because we share the interrupt with
1158
+
* the serial driver which we don't properly support yet.
1159
+
*
1160
+
* Can't use UPF_IOREMAP as the whole of IOC3 resources have already been
1161
+
* registered.
1156
1162
*/
1163
+
static void __devinit ioc3_8250_register(struct ioc3_uartregs __iomem *uart)
1164
+
{
1165
+
#define COSMISC_CONSTANT 6
1166
+
1167
+
struct uart_port port = {
1168
+
.irq = 0,
1169
+
.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF,
1170
+
.iotype = UPIO_MEM,
1171
+
.regshift = 0,
1172
+
.uartclk = (22000000 << 1) / COSMISC_CONSTANT,
1173
+
1174
+
.membase = (unsigned char __iomem *) uart,
1175
+
.mapbase = (unsigned long) uart,
1176
+
};
1177
+
unsigned char lcr;
1178
+
1179
+
lcr = uart->iu_lcr;
1180
+
uart->iu_lcr = lcr | UART_LCR_DLAB;
1181
+
uart->iu_scr = COSMISC_CONSTANT,
1182
+
uart->iu_lcr = lcr;
1183
+
uart->iu_lcr;
1184
+
serial8250_register_port(&port);
1185
+
}
1157
1186
1158
1187
static void __devinit ioc3_serial_probe(struct pci_dev *pdev, struct ioc3 *ioc3)
1159
1188
{
1160
-
struct uart_port port;
1161
-
1162
1189
/*
1163
1190
* We need to recognice and treat the fourth MENET serial as it
1164
1191
* does not have an SuperIO chip attached to it, therefore attempting
···
1200
1171
return;
1201
1172
1202
1173
/*
1203
-
* Register to interrupt zero because we share the interrupt with
1204
-
* the serial driver which we don't properly support yet.
1205
-
*
1206
-
* Can't use UPF_IOREMAP as the whole of IOC3 resources have already
1207
-
* been registered.
1174
+
* Switch IOC3 to PIO mode. It probably already was but let's be
1175
+
* paranoid
1208
1176
*/
1209
-
memset(&port, 0, sizeof(port));
1210
-
port.irq = 0;
1211
-
port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
1212
-
port.iotype = UPIO_MEM;
1213
-
port.regshift = 0;
1214
-
port.uartclk = 22000000 / 3;
1177
+
ioc3->gpcr_s = GPCR_UARTA_MODESEL | GPCR_UARTB_MODESEL;
1178
+
ioc3->gpcr_s;
1179
+
ioc3->gppr_6 = 0;
1180
+
ioc3->gppr_6;
1181
+
ioc3->gppr_7 = 0;
1182
+
ioc3->gppr_7;
1183
+
ioc3->sscr_a = ioc3->sscr_a & ~SSCR_DMA_EN;
1184
+
ioc3->sscr_a;
1185
+
ioc3->sscr_b = ioc3->sscr_b & ~SSCR_DMA_EN;
1186
+
ioc3->sscr_b;
1187
+
/* Disable all SA/B interrupts except for SA/B_INT in SIO_IEC. */
1188
+
ioc3->sio_iec &= ~ (SIO_IR_SA_TX_MT | SIO_IR_SA_RX_FULL |
1189
+
SIO_IR_SA_RX_HIGH | SIO_IR_SA_RX_TIMER |
1190
+
SIO_IR_SA_DELTA_DCD | SIO_IR_SA_DELTA_CTS |
1191
+
SIO_IR_SA_TX_EXPLICIT | SIO_IR_SA_MEMERR);
1192
+
ioc3->sio_iec |= SIO_IR_SA_INT;
1193
+
ioc3->sscr_a = 0;
1194
+
ioc3->sio_iec &= ~ (SIO_IR_SB_TX_MT | SIO_IR_SB_RX_FULL |
1195
+
SIO_IR_SB_RX_HIGH | SIO_IR_SB_RX_TIMER |
1196
+
SIO_IR_SB_DELTA_DCD | SIO_IR_SB_DELTA_CTS |
1197
+
SIO_IR_SB_TX_EXPLICIT | SIO_IR_SB_MEMERR);
1198
+
ioc3->sio_iec |= SIO_IR_SB_INT;
1199
+
ioc3->sscr_b = 0;
1215
1200
1216
-
port.membase = (unsigned char *) &ioc3->sregs.uarta;
1217
-
serial8250_register_port(&port);
1218
-
1219
-
port.membase = (unsigned char *) &ioc3->sregs.uartb;
1220
-
serial8250_register_port(&port);
1201
+
ioc3_8250_register(&ioc3->sregs.uarta);
1202
+
ioc3_8250_register(&ioc3->sregs.uartb);
1221
1203
}
1222
1204
#endif
1223
1205
+4
-2
drivers/net/netxen/netxen_nic_hdr.h
+4
-2
drivers/net/netxen/netxen_nic_hdr.h
···
649
649
#define PCIX_INT_VECTOR (0x10100)
650
650
#define PCIX_INT_MASK (0x10104)
651
651
652
-
#define PCIX_MN_WINDOW (0x10200)
652
+
#define PCIX_MN_WINDOW_F0 (0x10200)
653
+
#define PCIX_MN_WINDOW(_f) (PCIX_MN_WINDOW_F0 + (0x20 * (_f)))
653
654
#define PCIX_MS_WINDOW (0x10204)
654
-
#define PCIX_SN_WINDOW (0x10208)
655
+
#define PCIX_SN_WINDOW_F0 (0x10208)
656
+
#define PCIX_SN_WINDOW(_f) (PCIX_SN_WINDOW_F0 + (0x20 * (_f)))
655
657
#define PCIX_CRB_WINDOW (0x10210)
656
658
#define PCIX_CRB_WINDOW_F0 (0x10210)
657
659
#define PCIX_CRB_WINDOW_F1 (0x10230)
+4
-4
drivers/net/netxen/netxen_nic_hw.c
+4
-4
drivers/net/netxen/netxen_nic_hw.c
···
904
904
ddr_mn_window = window;
905
905
writel(window, PCI_OFFSET_SECOND_RANGE(adapter,
906
906
NETXEN_PCIX_PH_REG
907
-
(PCIX_MN_WINDOW)));
907
+
(PCIX_MN_WINDOW(adapter->ahw.pci_func))));
908
908
/* MUST make sure window is set before we forge on... */
909
909
readl(PCI_OFFSET_SECOND_RANGE(adapter,
910
910
NETXEN_PCIX_PH_REG
911
-
(PCIX_MN_WINDOW)));
911
+
(PCIX_MN_WINDOW(adapter->ahw.pci_func))));
912
912
}
913
913
addr -= (window * NETXEN_WINDOW_ONE);
914
914
addr += NETXEN_PCI_DDR_NET;
···
929
929
writel((window << 22),
930
930
PCI_OFFSET_SECOND_RANGE(adapter,
931
931
NETXEN_PCIX_PH_REG
932
-
(PCIX_SN_WINDOW)));
932
+
(PCIX_SN_WINDOW(adapter->ahw.pci_func))));
933
933
/* MUST make sure window is set before we forge on... */
934
934
readl(PCI_OFFSET_SECOND_RANGE(adapter,
935
935
NETXEN_PCIX_PH_REG
936
-
(PCIX_SN_WINDOW)));
936
+
(PCIX_SN_WINDOW(adapter->ahw.pci_func))));
937
937
}
938
938
addr -= (window * 0x400000);
939
939
addr += NETXEN_PCI_QDR_NET;
+7
-12
drivers/net/netxen/netxen_nic_main.c
+7
-12
drivers/net/netxen/netxen_nic_main.c
···
639
639
NETXEN_CRB_NORMALIZE(adapter,
640
640
NETXEN_ROMUSB_GLB_PEGTUNE_DONE));
641
641
/* Handshake with the card before we register the devices. */
642
-
writel(0, NETXEN_CRB_NORMALIZE(adapter, CRB_CMDPEG_STATE));
643
-
netxen_pinit_from_rom(adapter, 0);
644
-
msleep(1);
645
-
netxen_load_firmware(adapter);
646
642
netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
647
643
}
648
644
···
746
750
747
751
netxen_nic_disable_int(adapter);
748
752
749
-
if (adapter->irq)
750
-
free_irq(adapter->irq, adapter);
751
-
752
753
if (adapter->is_up == NETXEN_ADAPTER_UP_MAGIC) {
753
754
init_firmware_done++;
754
755
netxen_free_hw_resources(adapter);
···
769
776
}
770
777
}
771
778
772
-
if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
773
-
pci_disable_msi(pdev);
774
-
775
779
vfree(adapter->cmd_buf_arr);
776
-
777
-
pci_disable_device(pdev);
778
780
779
781
if (adapter->portnum == 0) {
780
782
if (init_firmware_done) {
···
821
833
}
822
834
}
823
835
836
+
if (adapter->irq)
837
+
free_irq(adapter->irq, adapter);
838
+
839
+
if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
840
+
pci_disable_msi(pdev);
841
+
824
842
iounmap(adapter->ahw.db_base);
825
843
iounmap(adapter->ahw.pci_base0);
826
844
iounmap(adapter->ahw.pci_base1);
827
845
iounmap(adapter->ahw.pci_base2);
828
846
829
847
pci_release_regions(pdev);
848
+
pci_disable_device(pdev);
830
849
pci_set_drvdata(pdev, NULL);
831
850
832
851
free_netdev(netdev);
-1
drivers/net/ps3_gelic_net.c
-1
drivers/net/ps3_gelic_net.c
+2
-2
drivers/s390/net/qeth.h
+2
-2
drivers/s390/net/qeth.h
···
1178
1178
char *buf)
1179
1179
{
1180
1180
if (proto == QETH_PROT_IPV4)
1181
-
return qeth_ipaddr4_to_string(addr, buf);
1181
+
qeth_ipaddr4_to_string(addr, buf);
1182
1182
else if (proto == QETH_PROT_IPV6)
1183
-
return qeth_ipaddr6_to_string(addr, buf);
1183
+
qeth_ipaddr6_to_string(addr, buf);
1184
1184
}
1185
1185
1186
1186
static inline int
+118
-40
drivers/s390/net/qeth_main.c
+118
-40
drivers/s390/net/qeth_main.c
···
561
561
}
562
562
563
563
static int
564
-
qeth_wait_for_threads(struct qeth_card *card, unsigned long threads);
564
+
qeth_threads_running(struct qeth_card *card, unsigned long threads);
565
565
566
566
567
567
static void
···
576
576
if (!card)
577
577
return;
578
578
579
-
if (qeth_wait_for_threads(card, 0xffffffff))
580
-
return;
579
+
wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
581
580
582
581
if (cgdev->state == CCWGROUP_ONLINE){
583
582
card->use_hard_stop = 1;
···
1541
1542
card = CARD_FROM_CDEV(channel->ccwdev);
1542
1543
1543
1544
if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) {
1544
-
PRINT_ERR("IDX_ACTIVATE on write channel device %s: negative "
1545
-
"reply\n", CARD_WDEV_ID(card));
1545
+
if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19)
1546
+
PRINT_ERR("IDX_ACTIVATE on write channel device %s: "
1547
+
"adapter exclusively used by another host\n",
1548
+
CARD_WDEV_ID(card));
1549
+
else
1550
+
PRINT_ERR("IDX_ACTIVATE on write channel device %s: "
1551
+
"negative reply\n", CARD_WDEV_ID(card));
1546
1552
goto out;
1547
1553
}
1548
1554
memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2);
1549
1555
if ((temp & ~0x0100) != qeth_peer_func_level(card->info.func_level)) {
1550
1556
PRINT_WARN("IDX_ACTIVATE on write channel device %s: "
1551
-
"function level mismatch "
1552
-
"(sent: 0x%x, received: 0x%x)\n",
1553
-
CARD_WDEV_ID(card), card->info.func_level, temp);
1557
+
"function level mismatch "
1558
+
"(sent: 0x%x, received: 0x%x)\n",
1559
+
CARD_WDEV_ID(card), card->info.func_level, temp);
1554
1560
goto out;
1555
1561
}
1556
1562
channel->state = CH_STATE_UP;
···
1601
1597
goto out;
1602
1598
}
1603
1599
if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) {
1604
-
PRINT_ERR("IDX_ACTIVATE on read channel device %s: negative "
1605
-
"reply\n", CARD_RDEV_ID(card));
1600
+
if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19)
1601
+
PRINT_ERR("IDX_ACTIVATE on read channel device %s: "
1602
+
"adapter exclusively used by another host\n",
1603
+
CARD_RDEV_ID(card));
1604
+
else
1605
+
PRINT_ERR("IDX_ACTIVATE on read channel device %s: "
1606
+
"negative reply\n", CARD_RDEV_ID(card));
1606
1607
goto out;
1607
1608
}
1608
1609
···
1622
1613
memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2);
1623
1614
if (temp != qeth_peer_func_level(card->info.func_level)) {
1624
1615
PRINT_WARN("IDX_ACTIVATE on read channel device %s: function "
1625
-
"level mismatch (sent: 0x%x, received: 0x%x)\n",
1626
-
CARD_RDEV_ID(card), card->info.func_level, temp);
1616
+
"level mismatch (sent: 0x%x, received: 0x%x)\n",
1617
+
CARD_RDEV_ID(card), card->info.func_level, temp);
1627
1618
goto out;
1628
1619
}
1629
1620
memcpy(&card->token.issuer_rm_r,
···
2505
2496
struct iphdr *ip_hdr;
2506
2497
2507
2498
QETH_DBF_TEXT(trace,5,"skbfktr");
2508
-
skb_set_mac_header(skb, -QETH_FAKE_LL_LEN_TR);
2499
+
skb_set_mac_header(skb, (int)-QETH_FAKE_LL_LEN_TR);
2509
2500
/* this is a fake ethernet header */
2510
2501
fake_hdr = tr_hdr(skb);
2511
2502
···
2813
2804
if (newcount < count) {
2814
2805
/* we are in memory shortage so we switch back to
2815
2806
traditional skb allocation and drop packages */
2816
-
if (atomic_cmpxchg(&card->force_alloc_skb, 0, 1))
2817
-
printk(KERN_WARNING
2818
-
"qeth: switch to alloc skb\n");
2807
+
if (!atomic_read(&card->force_alloc_skb) &&
2808
+
net_ratelimit())
2809
+
PRINT_WARN("Switch to alloc skb\n");
2810
+
atomic_set(&card->force_alloc_skb, 3);
2819
2811
count = newcount;
2820
2812
} else {
2821
-
if (atomic_cmpxchg(&card->force_alloc_skb, 1, 0))
2822
-
printk(KERN_WARNING "qeth: switch to sg\n");
2813
+
if ((atomic_read(&card->force_alloc_skb) == 1) &&
2814
+
net_ratelimit())
2815
+
PRINT_WARN("Switch to sg\n");
2816
+
atomic_add_unless(&card->force_alloc_skb, -1, 0);
2823
2817
}
2824
2818
2825
2819
/*
···
3366
3354
while (i > 0)
3367
3355
kfree(card->qdio.out_qs[--i]);
3368
3356
kfree(card->qdio.out_qs);
3357
+
card->qdio.out_qs = NULL;
3369
3358
out_freepool:
3370
3359
qeth_free_buffer_pool(card);
3371
3360
out_freeinq:
3372
3361
kfree(card->qdio.in_q);
3362
+
card->qdio.in_q = NULL;
3373
3363
out_nomem:
3374
3364
atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED);
3375
3365
return -ENOMEM;
···
3387
3373
QETH_QDIO_UNINITIALIZED)
3388
3374
return;
3389
3375
kfree(card->qdio.in_q);
3376
+
card->qdio.in_q = NULL;
3390
3377
/* inbound buffer pool */
3391
3378
qeth_free_buffer_pool(card);
3392
3379
/* free outbound qdio_qs */
3393
-
for (i = 0; i < card->qdio.no_out_queues; ++i){
3394
-
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j)
3395
-
qeth_clear_output_buffer(card->qdio.out_qs[i],
3396
-
&card->qdio.out_qs[i]->bufs[j]);
3397
-
kfree(card->qdio.out_qs[i]);
3380
+
if (card->qdio.out_qs) {
3381
+
for (i = 0; i < card->qdio.no_out_queues; ++i) {
3382
+
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j)
3383
+
qeth_clear_output_buffer(card->qdio.out_qs[i],
3384
+
&card->qdio.out_qs[i]->bufs[j]);
3385
+
kfree(card->qdio.out_qs[i]);
3386
+
}
3387
+
kfree(card->qdio.out_qs);
3388
+
card->qdio.out_qs = NULL;
3398
3389
}
3399
-
kfree(card->qdio.out_qs);
3400
3390
}
3401
3391
3402
3392
static void
···
3411
3393
QETH_DBF_TEXT(trace, 2, "clearqdbf");
3412
3394
/* clear outbound buffers to free skbs */
3413
3395
for (i = 0; i < card->qdio.no_out_queues; ++i)
3414
-
if (card->qdio.out_qs[i]){
3396
+
if (card->qdio.out_qs && card->qdio.out_qs[i]) {
3415
3397
for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j)
3416
3398
qeth_clear_output_buffer(card->qdio.out_qs[i],
3417
3399
&card->qdio.out_qs[i]->bufs[j]);
···
4571
4553
return elements_needed;
4572
4554
}
4573
4555
4556
+
static void qeth_tx_csum(struct sk_buff *skb)
4557
+
{
4558
+
int tlen;
4559
+
4560
+
if (skb->protocol == htons(ETH_P_IP)) {
4561
+
tlen = ntohs(ip_hdr(skb)->tot_len) - (ip_hdr(skb)->ihl << 2);
4562
+
switch (ip_hdr(skb)->protocol) {
4563
+
case IPPROTO_TCP:
4564
+
tcp_hdr(skb)->check = 0;
4565
+
tcp_hdr(skb)->check = csum_tcpudp_magic(
4566
+
ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
4567
+
tlen, ip_hdr(skb)->protocol,
4568
+
skb_checksum(skb, skb_transport_offset(skb),
4569
+
tlen, 0));
4570
+
break;
4571
+
case IPPROTO_UDP:
4572
+
udp_hdr(skb)->check = 0;
4573
+
udp_hdr(skb)->check = csum_tcpudp_magic(
4574
+
ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
4575
+
tlen, ip_hdr(skb)->protocol,
4576
+
skb_checksum(skb, skb_transport_offset(skb),
4577
+
tlen, 0));
4578
+
break;
4579
+
}
4580
+
} else if (skb->protocol == htons(ETH_P_IPV6)) {
4581
+
switch (ipv6_hdr(skb)->nexthdr) {
4582
+
case IPPROTO_TCP:
4583
+
tcp_hdr(skb)->check = 0;
4584
+
tcp_hdr(skb)->check = csum_ipv6_magic(
4585
+
&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
4586
+
ipv6_hdr(skb)->payload_len,
4587
+
ipv6_hdr(skb)->nexthdr,
4588
+
skb_checksum(skb, skb_transport_offset(skb),
4589
+
ipv6_hdr(skb)->payload_len, 0));
4590
+
break;
4591
+
case IPPROTO_UDP:
4592
+
udp_hdr(skb)->check = 0;
4593
+
udp_hdr(skb)->check = csum_ipv6_magic(
4594
+
&ipv6_hdr(skb)->saddr, &ipv6_hdr(skb)->daddr,
4595
+
ipv6_hdr(skb)->payload_len,
4596
+
ipv6_hdr(skb)->nexthdr,
4597
+
skb_checksum(skb, skb_transport_offset(skb),
4598
+
ipv6_hdr(skb)->payload_len, 0));
4599
+
break;
4600
+
}
4601
+
}
4602
+
}
4574
4603
4575
4604
static int
4576
4605
qeth_send_packet(struct qeth_card *card, struct sk_buff *skb)
···
4703
4638
elements_needed += elems;
4704
4639
}
4705
4640
4641
+
if ((large_send == QETH_LARGE_SEND_NO) &&
4642
+
(skb->ip_summed == CHECKSUM_PARTIAL))
4643
+
qeth_tx_csum(new_skb);
4644
+
4706
4645
if (card->info.type != QETH_CARD_TYPE_IQD)
4707
4646
rc = qeth_do_send_packet(card, queue, new_skb, hdr,
4708
4647
elements_needed, ctx);
4709
-
else
4648
+
else {
4649
+
if ((skb->protocol == htons(ETH_P_ARP)) &&
4650
+
(card->dev->flags & IFF_NOARP)) {
4651
+
__qeth_free_new_skb(skb, new_skb);
4652
+
return -EPERM;
4653
+
}
4710
4654
rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
4711
4655
elements_needed, ctx);
4656
+
}
4712
4657
if (!rc) {
4713
4658
card->stats.tx_packets++;
4714
4659
card->stats.tx_bytes += tx_bytes;
···
6460
6385
static u32
6461
6386
qeth_ethtool_get_tx_csum(struct net_device *dev)
6462
6387
{
6463
-
/* We may need to say that we support tx csum offload if
6464
-
* we do EDDP or TSO. There are discussions going on to
6465
-
* enforce rules in the stack and in ethtool that make
6466
-
* SG and TSO depend on HW_CSUM. At the moment there are
6467
-
* no such rules....
6468
-
* If we say yes here, we have to checksum outbound packets
6469
-
* any time. */
6470
-
return 0;
6388
+
return (dev->features & NETIF_F_HW_CSUM) != 0;
6471
6389
}
6472
6390
6473
6391
static int
6474
6392
qeth_ethtool_set_tx_csum(struct net_device *dev, u32 data)
6475
6393
{
6476
-
return -EINVAL;
6394
+
if (data)
6395
+
dev->features |= NETIF_F_HW_CSUM;
6396
+
else
6397
+
dev->features &= ~NETIF_F_HW_CSUM;
6398
+
6399
+
return 0;
6477
6400
}
6478
6401
6479
6402
static u32
···
7485
7412
}
7486
7413
if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)){
7487
7414
card->options.large_send = QETH_LARGE_SEND_NO;
7488
-
card->dev->features &= ~ (NETIF_F_TSO | NETIF_F_SG);
7415
+
card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
7416
+
NETIF_F_HW_CSUM);
7489
7417
}
7490
7418
return rc;
7491
7419
}
···
7626
7552
card->options.large_send = type;
7627
7553
switch (card->options.large_send) {
7628
7554
case QETH_LARGE_SEND_EDDP:
7629
-
card->dev->features |= NETIF_F_TSO | NETIF_F_SG;
7555
+
card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
7556
+
NETIF_F_HW_CSUM;
7630
7557
break;
7631
7558
case QETH_LARGE_SEND_TSO:
7632
7559
if (qeth_is_supported(card, IPA_OUTBOUND_TSO)){
7633
-
card->dev->features |= NETIF_F_TSO | NETIF_F_SG;
7560
+
card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
7561
+
NETIF_F_HW_CSUM;
7634
7562
} else {
7635
7563
PRINT_WARN("TSO not supported on %s. "
7636
7564
"large_send set to 'no'.\n",
7637
7565
card->dev->name);
7638
-
card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
7566
+
card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
7567
+
NETIF_F_HW_CSUM);
7639
7568
card->options.large_send = QETH_LARGE_SEND_NO;
7640
7569
rc = -EOPNOTSUPP;
7641
7570
}
7642
7571
break;
7643
7572
default: /* includes QETH_LARGE_SEND_NO */
7644
-
card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
7573
+
card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
7574
+
NETIF_F_HW_CSUM);
7645
7575
break;
7646
7576
}
7647
7577
if (card->state == CARD_STATE_UP)
+1
drivers/s390/net/qeth_mpc.h
+1
drivers/s390/net/qeth_mpc.h
···
565
565
#define QETH_IDX_ACT_QDIO_DEV_REALADDR(buffer) (buffer+0x20)
566
566
#define QETH_IS_IDX_ACT_POS_REPLY(buffer) (((buffer)[0x08]&3)==2)
567
567
#define QETH_IDX_REPLY_LEVEL(buffer) (buffer+0x12)
568
+
#define QETH_IDX_ACT_CAUSE_CODE(buffer) (buffer)[0x09]
568
569
569
570
#define PDU_ENCAPSULATION(buffer) \
570
571
(buffer + *(buffer + (*(buffer+0x0b)) + \
+4
-4
drivers/s390/net/qeth_sys.c
+4
-4
drivers/s390/net/qeth_sys.c
···
1760
1760
{
1761
1761
struct qeth_card *card = dev->driver_data;
1762
1762
1763
-
if (card->info.type == QETH_CARD_TYPE_OSN)
1764
-
return sysfs_remove_group(&dev->kobj,
1765
-
&qeth_osn_device_attr_group);
1766
-
1763
+
if (card->info.type == QETH_CARD_TYPE_OSN) {
1764
+
sysfs_remove_group(&dev->kobj, &qeth_osn_device_attr_group);
1765
+
return;
1766
+
}
1767
1767
sysfs_remove_group(&dev->kobj, &qeth_device_attr_group);
1768
1768
sysfs_remove_group(&dev->kobj, &qeth_device_ipato_group);
1769
1769
sysfs_remove_group(&dev->kobj, &qeth_device_vipa_group);