Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *    Copyright IBM Corp. 2007
0004  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
0005  *       Frank Pavlic <fpavlic@de.ibm.com>,
0006  *       Thomas Spatzier <tspat@de.ibm.com>,
0007  *       Frank Blaschka <frank.blaschka@de.ibm.com>
0008  */
0009 
0010 #define KMSG_COMPONENT "qeth"
0011 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0012 
0013 #include <linux/list.h>
0014 #include <linux/rwsem.h>
0015 #include <asm/ebcdic.h>
0016 
0017 #include "qeth_core.h"
0018 
0019 static ssize_t qeth_dev_state_show(struct device *dev,
0020                 struct device_attribute *attr, char *buf)
0021 {
0022     struct qeth_card *card = dev_get_drvdata(dev);
0023 
0024     switch (card->state) {
0025     case CARD_STATE_DOWN:
0026         return sprintf(buf, "DOWN\n");
0027     case CARD_STATE_SOFTSETUP:
0028         if (card->dev->flags & IFF_UP)
0029             return sprintf(buf, "UP (LAN %s)\n",
0030                        netif_carrier_ok(card->dev) ? "ONLINE" :
0031                                      "OFFLINE");
0032         return sprintf(buf, "SOFTSETUP\n");
0033     default:
0034         return sprintf(buf, "UNKNOWN\n");
0035     }
0036 }
0037 
0038 static DEVICE_ATTR(state, 0444, qeth_dev_state_show, NULL);
0039 
0040 static ssize_t qeth_dev_chpid_show(struct device *dev,
0041                 struct device_attribute *attr, char *buf)
0042 {
0043     struct qeth_card *card = dev_get_drvdata(dev);
0044 
0045     return sprintf(buf, "%02X\n", card->info.chpid);
0046 }
0047 
0048 static DEVICE_ATTR(chpid, 0444, qeth_dev_chpid_show, NULL);
0049 
0050 static ssize_t qeth_dev_if_name_show(struct device *dev,
0051                 struct device_attribute *attr, char *buf)
0052 {
0053     struct qeth_card *card = dev_get_drvdata(dev);
0054 
0055     return sprintf(buf, "%s\n", netdev_name(card->dev));
0056 }
0057 
0058 static DEVICE_ATTR(if_name, 0444, qeth_dev_if_name_show, NULL);
0059 
0060 static ssize_t qeth_dev_card_type_show(struct device *dev,
0061                 struct device_attribute *attr, char *buf)
0062 {
0063     struct qeth_card *card = dev_get_drvdata(dev);
0064 
0065     return sprintf(buf, "%s\n", qeth_get_cardname_short(card));
0066 }
0067 
0068 static DEVICE_ATTR(card_type, 0444, qeth_dev_card_type_show, NULL);
0069 
0070 static const char *qeth_get_bufsize_str(struct qeth_card *card)
0071 {
0072     if (card->qdio.in_buf_size == 16384)
0073         return "16k";
0074     else if (card->qdio.in_buf_size == 24576)
0075         return "24k";
0076     else if (card->qdio.in_buf_size == 32768)
0077         return "32k";
0078     else if (card->qdio.in_buf_size == 40960)
0079         return "40k";
0080     else
0081         return "64k";
0082 }
0083 
0084 static ssize_t qeth_dev_inbuf_size_show(struct device *dev,
0085                 struct device_attribute *attr, char *buf)
0086 {
0087     struct qeth_card *card = dev_get_drvdata(dev);
0088 
0089     return sprintf(buf, "%s\n", qeth_get_bufsize_str(card));
0090 }
0091 
0092 static DEVICE_ATTR(inbuf_size, 0444, qeth_dev_inbuf_size_show, NULL);
0093 
0094 static ssize_t qeth_dev_portno_show(struct device *dev,
0095             struct device_attribute *attr, char *buf)
0096 {
0097     struct qeth_card *card = dev_get_drvdata(dev);
0098 
0099     return sprintf(buf, "%i\n", card->dev->dev_port);
0100 }
0101 
0102 static ssize_t qeth_dev_portno_store(struct device *dev,
0103         struct device_attribute *attr, const char *buf, size_t count)
0104 {
0105     struct qeth_card *card = dev_get_drvdata(dev);
0106     unsigned int portno, limit;
0107     int rc = 0;
0108 
0109     rc = kstrtouint(buf, 16, &portno);
0110     if (rc)
0111         return rc;
0112     if (portno > QETH_MAX_PORTNO)
0113         return -EINVAL;
0114 
0115     mutex_lock(&card->conf_mutex);
0116     if (card->state != CARD_STATE_DOWN) {
0117         rc = -EPERM;
0118         goto out;
0119     }
0120 
0121     limit = (card->ssqd.pcnt ? card->ssqd.pcnt - 1 : card->ssqd.pcnt);
0122     if (portno > limit) {
0123         rc = -EINVAL;
0124         goto out;
0125     }
0126     card->dev->dev_port = portno;
0127 out:
0128     mutex_unlock(&card->conf_mutex);
0129     return rc ? rc : count;
0130 }
0131 
0132 static DEVICE_ATTR(portno, 0644, qeth_dev_portno_show, qeth_dev_portno_store);
0133 
0134 static ssize_t qeth_dev_portname_show(struct device *dev,
0135                 struct device_attribute *attr, char *buf)
0136 {
0137     return sprintf(buf, "no portname required\n");
0138 }
0139 
0140 static ssize_t qeth_dev_portname_store(struct device *dev,
0141         struct device_attribute *attr, const char *buf, size_t count)
0142 {
0143     struct qeth_card *card = dev_get_drvdata(dev);
0144 
0145     dev_warn_once(&card->gdev->dev,
0146               "portname is deprecated and is ignored\n");
0147     return count;
0148 }
0149 
0150 static DEVICE_ATTR(portname, 0644, qeth_dev_portname_show,
0151         qeth_dev_portname_store);
0152 
0153 static ssize_t qeth_dev_prioqing_show(struct device *dev,
0154                 struct device_attribute *attr, char *buf)
0155 {
0156     struct qeth_card *card = dev_get_drvdata(dev);
0157 
0158     switch (card->qdio.do_prio_queueing) {
0159     case QETH_PRIO_Q_ING_PREC:
0160         return sprintf(buf, "%s\n", "by precedence");
0161     case QETH_PRIO_Q_ING_TOS:
0162         return sprintf(buf, "%s\n", "by type of service");
0163     case QETH_PRIO_Q_ING_SKB:
0164         return sprintf(buf, "%s\n", "by skb-priority");
0165     case QETH_PRIO_Q_ING_VLAN:
0166         return sprintf(buf, "%s\n", "by VLAN headers");
0167     case QETH_PRIO_Q_ING_FIXED:
0168         return sprintf(buf, "always queue %i\n",
0169                    card->qdio.default_out_queue);
0170     default:
0171         return sprintf(buf, "disabled\n");
0172     }
0173 }
0174 
0175 static ssize_t qeth_dev_prioqing_store(struct device *dev,
0176         struct device_attribute *attr, const char *buf, size_t count)
0177 {
0178     struct qeth_card *card = dev_get_drvdata(dev);
0179     int rc = 0;
0180 
0181     if (IS_IQD(card) || IS_VM_NIC(card))
0182         return -EOPNOTSUPP;
0183 
0184     mutex_lock(&card->conf_mutex);
0185     if (card->state != CARD_STATE_DOWN) {
0186         rc = -EPERM;
0187         goto out;
0188     }
0189 
0190     /* check if 1920 devices are supported ,
0191      * if though we have to permit priority queueing
0192      */
0193     if (card->qdio.no_out_queues == 1) {
0194         card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT;
0195         rc = -EPERM;
0196         goto out;
0197     }
0198 
0199     if (sysfs_streq(buf, "prio_queueing_prec")) {
0200         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_PREC;
0201         card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
0202     } else if (sysfs_streq(buf, "prio_queueing_skb")) {
0203         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_SKB;
0204         card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
0205     } else if (sysfs_streq(buf, "prio_queueing_tos")) {
0206         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
0207         card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
0208     } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
0209         if (IS_LAYER3(card)) {
0210             rc = -EOPNOTSUPP;
0211             goto out;
0212         }
0213         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_VLAN;
0214         card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
0215     } else if (sysfs_streq(buf, "no_prio_queueing:0")) {
0216         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
0217         card->qdio.default_out_queue = 0;
0218     } else if (sysfs_streq(buf, "no_prio_queueing:1")) {
0219         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
0220         card->qdio.default_out_queue = 1;
0221     } else if (sysfs_streq(buf, "no_prio_queueing:2")) {
0222         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
0223         card->qdio.default_out_queue = 2;
0224     } else if (sysfs_streq(buf, "no_prio_queueing:3")) {
0225         card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_FIXED;
0226         card->qdio.default_out_queue = 3;
0227     } else if (sysfs_streq(buf, "no_prio_queueing")) {
0228         card->qdio.do_prio_queueing = QETH_NO_PRIO_QUEUEING;
0229         card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
0230     } else
0231         rc = -EINVAL;
0232 out:
0233     mutex_unlock(&card->conf_mutex);
0234     return rc ? rc : count;
0235 }
0236 
0237 static DEVICE_ATTR(priority_queueing, 0644, qeth_dev_prioqing_show,
0238         qeth_dev_prioqing_store);
0239 
0240 static ssize_t qeth_dev_bufcnt_show(struct device *dev,
0241                 struct device_attribute *attr, char *buf)
0242 {
0243     struct qeth_card *card = dev_get_drvdata(dev);
0244 
0245     return sprintf(buf, "%i\n", card->qdio.in_buf_pool.buf_count);
0246 }
0247 
0248 static ssize_t qeth_dev_bufcnt_store(struct device *dev,
0249         struct device_attribute *attr, const char *buf, size_t count)
0250 {
0251     struct qeth_card *card = dev_get_drvdata(dev);
0252     unsigned int cnt;
0253     int rc = 0;
0254 
0255     rc = kstrtouint(buf, 10, &cnt);
0256     if (rc)
0257         return rc;
0258 
0259     mutex_lock(&card->conf_mutex);
0260     if (card->state != CARD_STATE_DOWN) {
0261         rc = -EPERM;
0262         goto out;
0263     }
0264 
0265     cnt = clamp(cnt, QETH_IN_BUF_COUNT_MIN, QETH_IN_BUF_COUNT_MAX);
0266     rc = qeth_resize_buffer_pool(card, cnt);
0267 
0268 out:
0269     mutex_unlock(&card->conf_mutex);
0270     return rc ? rc : count;
0271 }
0272 
0273 static DEVICE_ATTR(buffer_count, 0644, qeth_dev_bufcnt_show,
0274         qeth_dev_bufcnt_store);
0275 
0276 static ssize_t qeth_dev_recover_store(struct device *dev,
0277         struct device_attribute *attr, const char *buf, size_t count)
0278 {
0279     struct qeth_card *card = dev_get_drvdata(dev);
0280     bool reset;
0281     int rc;
0282 
0283     rc = kstrtobool(buf, &reset);
0284     if (rc)
0285         return rc;
0286 
0287     if (!qeth_card_hw_is_reachable(card))
0288         return -EPERM;
0289 
0290     if (reset)
0291         rc = qeth_schedule_recovery(card);
0292 
0293     return rc ? rc : count;
0294 }
0295 
0296 static DEVICE_ATTR(recover, 0200, NULL, qeth_dev_recover_store);
0297 
0298 static ssize_t qeth_dev_performance_stats_show(struct device *dev,
0299                 struct device_attribute *attr, char *buf)
0300 {
0301     return sprintf(buf, "1\n");
0302 }
0303 
0304 static ssize_t qeth_dev_performance_stats_store(struct device *dev,
0305         struct device_attribute *attr, const char *buf, size_t count)
0306 {
0307     struct qeth_card *card = dev_get_drvdata(dev);
0308     struct qeth_qdio_out_q *queue;
0309     unsigned int i;
0310     bool reset;
0311     int rc;
0312 
0313     rc = kstrtobool(buf, &reset);
0314     if (rc)
0315         return rc;
0316 
0317     if (reset) {
0318         memset(&card->stats, 0, sizeof(card->stats));
0319         for (i = 0; i < card->qdio.no_out_queues; i++) {
0320             queue = card->qdio.out_qs[i];
0321             if (!queue)
0322                 break;
0323             memset(&queue->stats, 0, sizeof(queue->stats));
0324         }
0325     }
0326 
0327     return count;
0328 }
0329 
0330 static DEVICE_ATTR(performance_stats, 0644, qeth_dev_performance_stats_show,
0331            qeth_dev_performance_stats_store);
0332 
0333 static ssize_t qeth_dev_layer2_show(struct device *dev,
0334         struct device_attribute *attr, char *buf)
0335 {
0336     struct qeth_card *card = dev_get_drvdata(dev);
0337 
0338     return sprintf(buf, "%i\n", card->options.layer);
0339 }
0340 
0341 static ssize_t qeth_dev_layer2_store(struct device *dev,
0342         struct device_attribute *attr, const char *buf, size_t count)
0343 {
0344     struct qeth_card *card = dev_get_drvdata(dev);
0345     struct net_device *ndev;
0346     enum qeth_discipline_id newdis;
0347     unsigned int input;
0348     int rc;
0349 
0350     rc = kstrtouint(buf, 16, &input);
0351     if (rc)
0352         return rc;
0353 
0354     switch (input) {
0355     case 0:
0356         newdis = QETH_DISCIPLINE_LAYER3;
0357         break;
0358     case 1:
0359         newdis = QETH_DISCIPLINE_LAYER2;
0360         break;
0361     default:
0362         return -EINVAL;
0363     }
0364 
0365     mutex_lock(&card->discipline_mutex);
0366     if (card->state != CARD_STATE_DOWN) {
0367         rc = -EPERM;
0368         goto out;
0369     }
0370 
0371     if (card->options.layer == newdis)
0372         goto out;
0373     if (card->info.layer_enforced) {
0374         /* fixed layer, can't switch */
0375         rc = -EOPNOTSUPP;
0376         goto out;
0377     }
0378 
0379     if (card->discipline) {
0380         /* start with a new, pristine netdevice: */
0381         ndev = qeth_clone_netdev(card->dev);
0382         if (!ndev) {
0383             rc = -ENOMEM;
0384             goto out;
0385         }
0386 
0387         qeth_remove_discipline(card);
0388         free_netdev(card->dev);
0389         card->dev = ndev;
0390     }
0391 
0392     rc = qeth_setup_discipline(card, newdis);
0393 
0394 out:
0395     mutex_unlock(&card->discipline_mutex);
0396     return rc ? rc : count;
0397 }
0398 
0399 static DEVICE_ATTR(layer2, 0644, qeth_dev_layer2_show,
0400            qeth_dev_layer2_store);
0401 
0402 #define ATTR_QETH_ISOLATION_NONE    ("none")
0403 #define ATTR_QETH_ISOLATION_FWD     ("forward")
0404 #define ATTR_QETH_ISOLATION_DROP    ("drop")
0405 
0406 static ssize_t qeth_dev_isolation_show(struct device *dev,
0407                 struct device_attribute *attr, char *buf)
0408 {
0409     struct qeth_card *card = dev_get_drvdata(dev);
0410 
0411     switch (card->options.isolation) {
0412     case ISOLATION_MODE_NONE:
0413         return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_NONE);
0414     case ISOLATION_MODE_FWD:
0415         return snprintf(buf, 9, "%s\n", ATTR_QETH_ISOLATION_FWD);
0416     case ISOLATION_MODE_DROP:
0417         return snprintf(buf, 6, "%s\n", ATTR_QETH_ISOLATION_DROP);
0418     default:
0419         return snprintf(buf, 5, "%s\n", "N/A");
0420     }
0421 }
0422 
0423 static ssize_t qeth_dev_isolation_store(struct device *dev,
0424         struct device_attribute *attr, const char *buf, size_t count)
0425 {
0426     struct qeth_card *card = dev_get_drvdata(dev);
0427     enum qeth_ipa_isolation_modes isolation;
0428     int rc = 0;
0429 
0430     mutex_lock(&card->conf_mutex);
0431     if (!IS_OSD(card) && !IS_OSX(card)) {
0432         rc = -EOPNOTSUPP;
0433         dev_err(&card->gdev->dev, "Adapter does not "
0434             "support QDIO data connection isolation\n");
0435         goto out;
0436     }
0437 
0438     /* parse input into isolation mode */
0439     if (sysfs_streq(buf, ATTR_QETH_ISOLATION_NONE)) {
0440         isolation = ISOLATION_MODE_NONE;
0441     } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_FWD)) {
0442         isolation = ISOLATION_MODE_FWD;
0443     } else if (sysfs_streq(buf, ATTR_QETH_ISOLATION_DROP)) {
0444         isolation = ISOLATION_MODE_DROP;
0445     } else {
0446         rc = -EINVAL;
0447         goto out;
0448     }
0449 
0450     if (qeth_card_hw_is_reachable(card))
0451         rc = qeth_setadpparms_set_access_ctrl(card, isolation);
0452 
0453     if (!rc)
0454         WRITE_ONCE(card->options.isolation, isolation);
0455 
0456 out:
0457     mutex_unlock(&card->conf_mutex);
0458 
0459     return rc ? rc : count;
0460 }
0461 
0462 static DEVICE_ATTR(isolation, 0644, qeth_dev_isolation_show,
0463             qeth_dev_isolation_store);
0464 
0465 static ssize_t qeth_dev_switch_attrs_show(struct device *dev,
0466                 struct device_attribute *attr, char *buf)
0467 {
0468     struct qeth_card *card = dev_get_drvdata(dev);
0469     struct qeth_switch_info sw_info;
0470     int rc = 0;
0471 
0472     if (!qeth_card_hw_is_reachable(card))
0473         return sprintf(buf, "n/a\n");
0474 
0475     rc = qeth_query_switch_attributes(card, &sw_info);
0476     if (rc)
0477         return rc;
0478 
0479     if (!sw_info.capabilities)
0480         rc = sprintf(buf, "unknown");
0481 
0482     if (sw_info.capabilities & QETH_SWITCH_FORW_802_1)
0483         rc = sprintf(buf, (sw_info.settings & QETH_SWITCH_FORW_802_1 ?
0484                             "[802.1]" : "802.1"));
0485     if (sw_info.capabilities & QETH_SWITCH_FORW_REFL_RELAY)
0486         rc += sprintf(buf + rc,
0487             (sw_info.settings & QETH_SWITCH_FORW_REFL_RELAY ?
0488                             " [rr]" : " rr"));
0489     rc += sprintf(buf + rc, "\n");
0490 
0491     return rc;
0492 }
0493 
0494 static DEVICE_ATTR(switch_attrs, 0444,
0495            qeth_dev_switch_attrs_show, NULL);
0496 
0497 static ssize_t qeth_hw_trap_show(struct device *dev,
0498                 struct device_attribute *attr, char *buf)
0499 {
0500     struct qeth_card *card = dev_get_drvdata(dev);
0501 
0502     if (card->info.hwtrap)
0503         return snprintf(buf, 5, "arm\n");
0504     else
0505         return snprintf(buf, 8, "disarm\n");
0506 }
0507 
0508 static ssize_t qeth_hw_trap_store(struct device *dev,
0509         struct device_attribute *attr, const char *buf, size_t count)
0510 {
0511     struct qeth_card *card = dev_get_drvdata(dev);
0512     int rc = 0;
0513     int state = 0;
0514 
0515     mutex_lock(&card->conf_mutex);
0516     if (qeth_card_hw_is_reachable(card))
0517         state = 1;
0518 
0519     if (sysfs_streq(buf, "arm") && !card->info.hwtrap) {
0520         if (state) {
0521             if (qeth_is_diagass_supported(card,
0522                 QETH_DIAGS_CMD_TRAP)) {
0523                 rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM);
0524                 if (!rc)
0525                     card->info.hwtrap = 1;
0526             } else
0527                 rc = -EINVAL;
0528         } else
0529             card->info.hwtrap = 1;
0530     } else if (sysfs_streq(buf, "disarm") && card->info.hwtrap) {
0531         if (state) {
0532             rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
0533             if (!rc)
0534                 card->info.hwtrap = 0;
0535         } else
0536             card->info.hwtrap = 0;
0537     } else if (sysfs_streq(buf, "trap") && state && card->info.hwtrap)
0538         rc = qeth_hw_trap(card, QETH_DIAGS_TRAP_CAPTURE);
0539     else
0540         rc = -EINVAL;
0541 
0542     mutex_unlock(&card->conf_mutex);
0543     return rc ? rc : count;
0544 }
0545 
0546 static DEVICE_ATTR(hw_trap, 0644, qeth_hw_trap_show,
0547            qeth_hw_trap_store);
0548 
0549 static ssize_t qeth_dev_blkt_store(struct qeth_card *card,
0550         const char *buf, size_t count, int *value, int max_value)
0551 {
0552     unsigned int input;
0553     int rc;
0554 
0555     rc = kstrtouint(buf, 10, &input);
0556     if (rc)
0557         return rc;
0558 
0559     if (input > max_value)
0560         return -EINVAL;
0561 
0562     mutex_lock(&card->conf_mutex);
0563     if (card->state != CARD_STATE_DOWN)
0564         rc = -EPERM;
0565     else
0566         *value = input;
0567     mutex_unlock(&card->conf_mutex);
0568     return rc ? rc : count;
0569 }
0570 
0571 static ssize_t qeth_dev_blkt_total_show(struct device *dev,
0572                 struct device_attribute *attr, char *buf)
0573 {
0574     struct qeth_card *card = dev_get_drvdata(dev);
0575 
0576     return sprintf(buf, "%i\n", card->info.blkt.time_total);
0577 }
0578 
0579 static ssize_t qeth_dev_blkt_total_store(struct device *dev,
0580         struct device_attribute *attr, const char *buf, size_t count)
0581 {
0582     struct qeth_card *card = dev_get_drvdata(dev);
0583 
0584     return qeth_dev_blkt_store(card, buf, count,
0585                    &card->info.blkt.time_total, 5000);
0586 }
0587 
0588 static DEVICE_ATTR(total, 0644, qeth_dev_blkt_total_show,
0589            qeth_dev_blkt_total_store);
0590 
0591 static ssize_t qeth_dev_blkt_inter_show(struct device *dev,
0592                 struct device_attribute *attr, char *buf)
0593 {
0594     struct qeth_card *card = dev_get_drvdata(dev);
0595 
0596     return sprintf(buf, "%i\n", card->info.blkt.inter_packet);
0597 }
0598 
0599 static ssize_t qeth_dev_blkt_inter_store(struct device *dev,
0600         struct device_attribute *attr, const char *buf, size_t count)
0601 {
0602     struct qeth_card *card = dev_get_drvdata(dev);
0603 
0604     return qeth_dev_blkt_store(card, buf, count,
0605                    &card->info.blkt.inter_packet, 1000);
0606 }
0607 
0608 static DEVICE_ATTR(inter, 0644, qeth_dev_blkt_inter_show,
0609            qeth_dev_blkt_inter_store);
0610 
0611 static ssize_t qeth_dev_blkt_inter_jumbo_show(struct device *dev,
0612                 struct device_attribute *attr, char *buf)
0613 {
0614     struct qeth_card *card = dev_get_drvdata(dev);
0615 
0616     return sprintf(buf, "%i\n", card->info.blkt.inter_packet_jumbo);
0617 }
0618 
0619 static ssize_t qeth_dev_blkt_inter_jumbo_store(struct device *dev,
0620         struct device_attribute *attr, const char *buf, size_t count)
0621 {
0622     struct qeth_card *card = dev_get_drvdata(dev);
0623 
0624     return qeth_dev_blkt_store(card, buf, count,
0625                    &card->info.blkt.inter_packet_jumbo, 1000);
0626 }
0627 
0628 static DEVICE_ATTR(inter_jumbo, 0644, qeth_dev_blkt_inter_jumbo_show,
0629            qeth_dev_blkt_inter_jumbo_store);
0630 
0631 static struct attribute *qeth_blkt_device_attrs[] = {
0632     &dev_attr_total.attr,
0633     &dev_attr_inter.attr,
0634     &dev_attr_inter_jumbo.attr,
0635     NULL,
0636 };
0637 
0638 static const struct attribute_group qeth_dev_blkt_group = {
0639     .name = "blkt",
0640     .attrs = qeth_blkt_device_attrs,
0641 };
0642 
0643 static struct attribute *qeth_dev_extended_attrs[] = {
0644     &dev_attr_inbuf_size.attr,
0645     &dev_attr_portno.attr,
0646     &dev_attr_portname.attr,
0647     &dev_attr_priority_queueing.attr,
0648     &dev_attr_performance_stats.attr,
0649     &dev_attr_layer2.attr,
0650     &dev_attr_isolation.attr,
0651     &dev_attr_hw_trap.attr,
0652     &dev_attr_switch_attrs.attr,
0653     NULL,
0654 };
0655 
0656 static const struct attribute_group qeth_dev_extended_group = {
0657     .attrs = qeth_dev_extended_attrs,
0658 };
0659 
0660 static struct attribute *qeth_dev_attrs[] = {
0661     &dev_attr_state.attr,
0662     &dev_attr_chpid.attr,
0663     &dev_attr_if_name.attr,
0664     &dev_attr_card_type.attr,
0665     &dev_attr_buffer_count.attr,
0666     &dev_attr_recover.attr,
0667     NULL,
0668 };
0669 
0670 static const struct attribute_group qeth_dev_group = {
0671     .attrs = qeth_dev_attrs,
0672 };
0673 
0674 const struct attribute_group *qeth_dev_groups[] = {
0675     &qeth_dev_group,
0676     &qeth_dev_extended_group,
0677     &qeth_dev_blkt_group,
0678     NULL,
0679 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!