14a71df50SFrank Blaschka /* 24a71df50SFrank Blaschka * drivers/s390/net/qeth_core_main.c 34a71df50SFrank Blaschka * 44a71df50SFrank Blaschka * Copyright IBM Corp. 2007 54a71df50SFrank Blaschka * Author(s): Utz Bacher <utz.bacher@de.ibm.com>, 64a71df50SFrank Blaschka * Frank Pavlic <fpavlic@de.ibm.com>, 74a71df50SFrank Blaschka * Thomas Spatzier <tspat@de.ibm.com>, 84a71df50SFrank Blaschka * Frank Blaschka <frank.blaschka@de.ibm.com> 94a71df50SFrank Blaschka */ 104a71df50SFrank Blaschka 114a71df50SFrank Blaschka #include <linux/module.h> 124a71df50SFrank Blaschka #include <linux/moduleparam.h> 134a71df50SFrank Blaschka #include <linux/string.h> 144a71df50SFrank Blaschka #include <linux/errno.h> 154a71df50SFrank Blaschka #include <linux/kernel.h> 164a71df50SFrank Blaschka #include <linux/ip.h> 174a71df50SFrank Blaschka #include <linux/ipv6.h> 184a71df50SFrank Blaschka #include <linux/tcp.h> 194a71df50SFrank Blaschka #include <linux/mii.h> 204a71df50SFrank Blaschka #include <linux/kthread.h> 214a71df50SFrank Blaschka 224a71df50SFrank Blaschka #include <asm-s390/ebcdic.h> 234a71df50SFrank Blaschka #include <asm-s390/io.h> 244a71df50SFrank Blaschka #include <asm/s390_rdev.h> 254a71df50SFrank Blaschka 264a71df50SFrank Blaschka #include "qeth_core.h" 274a71df50SFrank Blaschka #include "qeth_core_offl.h" 284a71df50SFrank Blaschka 29d11ba0c4SPeter Tiedemann struct qeth_dbf_info qeth_dbf[QETH_DBF_INFOS] = { 30d11ba0c4SPeter Tiedemann /* define dbf - Name, Pages, Areas, Maxlen, Level, View, Handle */ 31d11ba0c4SPeter Tiedemann /* N P A M L V H */ 32d11ba0c4SPeter Tiedemann [QETH_DBF_SETUP] = {"qeth_setup", 33d11ba0c4SPeter Tiedemann 8, 1, 8, 5, &debug_hex_ascii_view, NULL}, 34d11ba0c4SPeter Tiedemann [QETH_DBF_QERR] = {"qeth_qerr", 35d11ba0c4SPeter Tiedemann 2, 1, 8, 2, &debug_hex_ascii_view, NULL}, 36d11ba0c4SPeter Tiedemann [QETH_DBF_TRACE] = {"qeth_trace", 37d11ba0c4SPeter Tiedemann 4, 1, 8, 3, &debug_hex_ascii_view, NULL}, 38d11ba0c4SPeter Tiedemann [QETH_DBF_MSG] = {"qeth_msg", 39d11ba0c4SPeter Tiedemann 8, 1, 128, 3, &debug_sprintf_view, NULL}, 40d11ba0c4SPeter Tiedemann [QETH_DBF_SENSE] = {"qeth_sense", 41d11ba0c4SPeter Tiedemann 2, 1, 64, 2, &debug_hex_ascii_view, NULL}, 42d11ba0c4SPeter Tiedemann [QETH_DBF_MISC] = {"qeth_misc", 43d11ba0c4SPeter Tiedemann 2, 1, 256, 2, &debug_hex_ascii_view, NULL}, 44d11ba0c4SPeter Tiedemann [QETH_DBF_CTRL] = {"qeth_control", 45d11ba0c4SPeter Tiedemann 8, 1, QETH_DBF_CTRL_LEN, 5, &debug_hex_ascii_view, NULL}, 46d11ba0c4SPeter Tiedemann }; 47d11ba0c4SPeter Tiedemann EXPORT_SYMBOL_GPL(qeth_dbf); 484a71df50SFrank Blaschka 494a71df50SFrank Blaschka struct qeth_card_list_struct qeth_core_card_list; 504a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_card_list); 514a71df50SFrank Blaschka 524a71df50SFrank Blaschka static struct device *qeth_core_root_dev; 534a71df50SFrank Blaschka static unsigned int known_devices[][10] = QETH_MODELLIST_ARRAY; 544a71df50SFrank Blaschka static struct lock_class_key qdio_out_skb_queue_key; 554a71df50SFrank Blaschka 564a71df50SFrank Blaschka static void qeth_send_control_data_cb(struct qeth_channel *, 574a71df50SFrank Blaschka struct qeth_cmd_buffer *); 584a71df50SFrank Blaschka static int qeth_issue_next_read(struct qeth_card *); 594a71df50SFrank Blaschka static struct qeth_cmd_buffer *qeth_get_buffer(struct qeth_channel *); 604a71df50SFrank Blaschka static void qeth_setup_ccw(struct qeth_channel *, unsigned char *, __u32); 614a71df50SFrank Blaschka static void qeth_free_buffer_pool(struct qeth_card *); 624a71df50SFrank Blaschka static int qeth_qdio_establish(struct qeth_card *); 634a71df50SFrank Blaschka 644a71df50SFrank Blaschka 654a71df50SFrank Blaschka static inline void __qeth_fill_buffer_frag(struct sk_buff *skb, 664a71df50SFrank Blaschka struct qdio_buffer *buffer, int is_tso, 674a71df50SFrank Blaschka int *next_element_to_fill) 684a71df50SFrank Blaschka { 694a71df50SFrank Blaschka struct skb_frag_struct *frag; 704a71df50SFrank Blaschka int fragno; 714a71df50SFrank Blaschka unsigned long addr; 724a71df50SFrank Blaschka int element, cnt, dlen; 734a71df50SFrank Blaschka 744a71df50SFrank Blaschka fragno = skb_shinfo(skb)->nr_frags; 754a71df50SFrank Blaschka element = *next_element_to_fill; 764a71df50SFrank Blaschka dlen = 0; 774a71df50SFrank Blaschka 784a71df50SFrank Blaschka if (is_tso) 794a71df50SFrank Blaschka buffer->element[element].flags = 804a71df50SFrank Blaschka SBAL_FLAGS_MIDDLE_FRAG; 814a71df50SFrank Blaschka else 824a71df50SFrank Blaschka buffer->element[element].flags = 834a71df50SFrank Blaschka SBAL_FLAGS_FIRST_FRAG; 844a71df50SFrank Blaschka dlen = skb->len - skb->data_len; 854a71df50SFrank Blaschka if (dlen) { 864a71df50SFrank Blaschka buffer->element[element].addr = skb->data; 874a71df50SFrank Blaschka buffer->element[element].length = dlen; 884a71df50SFrank Blaschka element++; 894a71df50SFrank Blaschka } 904a71df50SFrank Blaschka for (cnt = 0; cnt < fragno; cnt++) { 914a71df50SFrank Blaschka frag = &skb_shinfo(skb)->frags[cnt]; 924a71df50SFrank Blaschka addr = (page_to_pfn(frag->page) << PAGE_SHIFT) + 934a71df50SFrank Blaschka frag->page_offset; 944a71df50SFrank Blaschka buffer->element[element].addr = (char *)addr; 954a71df50SFrank Blaschka buffer->element[element].length = frag->size; 964a71df50SFrank Blaschka if (cnt < (fragno - 1)) 974a71df50SFrank Blaschka buffer->element[element].flags = 984a71df50SFrank Blaschka SBAL_FLAGS_MIDDLE_FRAG; 994a71df50SFrank Blaschka else 1004a71df50SFrank Blaschka buffer->element[element].flags = 1014a71df50SFrank Blaschka SBAL_FLAGS_LAST_FRAG; 1024a71df50SFrank Blaschka element++; 1034a71df50SFrank Blaschka } 1044a71df50SFrank Blaschka *next_element_to_fill = element; 1054a71df50SFrank Blaschka } 1064a71df50SFrank Blaschka 1074a71df50SFrank Blaschka static inline const char *qeth_get_cardname(struct qeth_card *card) 1084a71df50SFrank Blaschka { 1094a71df50SFrank Blaschka if (card->info.guestlan) { 1104a71df50SFrank Blaschka switch (card->info.type) { 1114a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 1124a71df50SFrank Blaschka return " Guest LAN QDIO"; 1134a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 1144a71df50SFrank Blaschka return " Guest LAN Hiper"; 1154a71df50SFrank Blaschka default: 1164a71df50SFrank Blaschka return " unknown"; 1174a71df50SFrank Blaschka } 1184a71df50SFrank Blaschka } else { 1194a71df50SFrank Blaschka switch (card->info.type) { 1204a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 1214a71df50SFrank Blaschka return " OSD Express"; 1224a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 1234a71df50SFrank Blaschka return " HiperSockets"; 1244a71df50SFrank Blaschka case QETH_CARD_TYPE_OSN: 1254a71df50SFrank Blaschka return " OSN QDIO"; 1264a71df50SFrank Blaschka default: 1274a71df50SFrank Blaschka return " unknown"; 1284a71df50SFrank Blaschka } 1294a71df50SFrank Blaschka } 1304a71df50SFrank Blaschka return " n/a"; 1314a71df50SFrank Blaschka } 1324a71df50SFrank Blaschka 1334a71df50SFrank Blaschka /* max length to be returned: 14 */ 1344a71df50SFrank Blaschka const char *qeth_get_cardname_short(struct qeth_card *card) 1354a71df50SFrank Blaschka { 1364a71df50SFrank Blaschka if (card->info.guestlan) { 1374a71df50SFrank Blaschka switch (card->info.type) { 1384a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 1394a71df50SFrank Blaschka return "GuestLAN QDIO"; 1404a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 1414a71df50SFrank Blaschka return "GuestLAN Hiper"; 1424a71df50SFrank Blaschka default: 1434a71df50SFrank Blaschka return "unknown"; 1444a71df50SFrank Blaschka } 1454a71df50SFrank Blaschka } else { 1464a71df50SFrank Blaschka switch (card->info.type) { 1474a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 1484a71df50SFrank Blaschka switch (card->info.link_type) { 1494a71df50SFrank Blaschka case QETH_LINK_TYPE_FAST_ETH: 1504a71df50SFrank Blaschka return "OSD_100"; 1514a71df50SFrank Blaschka case QETH_LINK_TYPE_HSTR: 1524a71df50SFrank Blaschka return "HSTR"; 1534a71df50SFrank Blaschka case QETH_LINK_TYPE_GBIT_ETH: 1544a71df50SFrank Blaschka return "OSD_1000"; 1554a71df50SFrank Blaschka case QETH_LINK_TYPE_10GBIT_ETH: 1564a71df50SFrank Blaschka return "OSD_10GIG"; 1574a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE_ETH100: 1584a71df50SFrank Blaschka return "OSD_FE_LANE"; 1594a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE_TR: 1604a71df50SFrank Blaschka return "OSD_TR_LANE"; 1614a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE_ETH1000: 1624a71df50SFrank Blaschka return "OSD_GbE_LANE"; 1634a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE: 1644a71df50SFrank Blaschka return "OSD_ATM_LANE"; 1654a71df50SFrank Blaschka default: 1664a71df50SFrank Blaschka return "OSD_Express"; 1674a71df50SFrank Blaschka } 1684a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 1694a71df50SFrank Blaschka return "HiperSockets"; 1704a71df50SFrank Blaschka case QETH_CARD_TYPE_OSN: 1714a71df50SFrank Blaschka return "OSN"; 1724a71df50SFrank Blaschka default: 1734a71df50SFrank Blaschka return "unknown"; 1744a71df50SFrank Blaschka } 1754a71df50SFrank Blaschka } 1764a71df50SFrank Blaschka return "n/a"; 1774a71df50SFrank Blaschka } 1784a71df50SFrank Blaschka 1794a71df50SFrank Blaschka void qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads, 1804a71df50SFrank Blaschka int clear_start_mask) 1814a71df50SFrank Blaschka { 1824a71df50SFrank Blaschka unsigned long flags; 1834a71df50SFrank Blaschka 1844a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 1854a71df50SFrank Blaschka card->thread_allowed_mask = threads; 1864a71df50SFrank Blaschka if (clear_start_mask) 1874a71df50SFrank Blaschka card->thread_start_mask &= threads; 1884a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 1894a71df50SFrank Blaschka wake_up(&card->wait_q); 1904a71df50SFrank Blaschka } 1914a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_set_allowed_threads); 1924a71df50SFrank Blaschka 1934a71df50SFrank Blaschka int qeth_threads_running(struct qeth_card *card, unsigned long threads) 1944a71df50SFrank Blaschka { 1954a71df50SFrank Blaschka unsigned long flags; 1964a71df50SFrank Blaschka int rc = 0; 1974a71df50SFrank Blaschka 1984a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 1994a71df50SFrank Blaschka rc = (card->thread_running_mask & threads); 2004a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 2014a71df50SFrank Blaschka return rc; 2024a71df50SFrank Blaschka } 2034a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_threads_running); 2044a71df50SFrank Blaschka 2054a71df50SFrank Blaschka int qeth_wait_for_threads(struct qeth_card *card, unsigned long threads) 2064a71df50SFrank Blaschka { 2074a71df50SFrank Blaschka return wait_event_interruptible(card->wait_q, 2084a71df50SFrank Blaschka qeth_threads_running(card, threads) == 0); 2094a71df50SFrank Blaschka } 2104a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_wait_for_threads); 2114a71df50SFrank Blaschka 2124a71df50SFrank Blaschka void qeth_clear_working_pool_list(struct qeth_card *card) 2134a71df50SFrank Blaschka { 2144a71df50SFrank Blaschka struct qeth_buffer_pool_entry *pool_entry, *tmp; 2154a71df50SFrank Blaschka 216d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "clwrklst"); 2174a71df50SFrank Blaschka list_for_each_entry_safe(pool_entry, tmp, 2184a71df50SFrank Blaschka &card->qdio.in_buf_pool.entry_list, list){ 2194a71df50SFrank Blaschka list_del(&pool_entry->list); 2204a71df50SFrank Blaschka } 2214a71df50SFrank Blaschka } 2224a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_working_pool_list); 2234a71df50SFrank Blaschka 2244a71df50SFrank Blaschka static int qeth_alloc_buffer_pool(struct qeth_card *card) 2254a71df50SFrank Blaschka { 2264a71df50SFrank Blaschka struct qeth_buffer_pool_entry *pool_entry; 2274a71df50SFrank Blaschka void *ptr; 2284a71df50SFrank Blaschka int i, j; 2294a71df50SFrank Blaschka 230d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "alocpool"); 2314a71df50SFrank Blaschka for (i = 0; i < card->qdio.init_pool.buf_count; ++i) { 2324a71df50SFrank Blaschka pool_entry = kmalloc(sizeof(*pool_entry), GFP_KERNEL); 2334a71df50SFrank Blaschka if (!pool_entry) { 2344a71df50SFrank Blaschka qeth_free_buffer_pool(card); 2354a71df50SFrank Blaschka return -ENOMEM; 2364a71df50SFrank Blaschka } 2374a71df50SFrank Blaschka for (j = 0; j < QETH_MAX_BUFFER_ELEMENTS(card); ++j) { 238508b3c4fSUrsula Braun ptr = (void *) __get_free_page(GFP_KERNEL); 2394a71df50SFrank Blaschka if (!ptr) { 2404a71df50SFrank Blaschka while (j > 0) 2414a71df50SFrank Blaschka free_page((unsigned long) 2424a71df50SFrank Blaschka pool_entry->elements[--j]); 2434a71df50SFrank Blaschka kfree(pool_entry); 2444a71df50SFrank Blaschka qeth_free_buffer_pool(card); 2454a71df50SFrank Blaschka return -ENOMEM; 2464a71df50SFrank Blaschka } 2474a71df50SFrank Blaschka pool_entry->elements[j] = ptr; 2484a71df50SFrank Blaschka } 2494a71df50SFrank Blaschka list_add(&pool_entry->init_list, 2504a71df50SFrank Blaschka &card->qdio.init_pool.entry_list); 2514a71df50SFrank Blaschka } 2524a71df50SFrank Blaschka return 0; 2534a71df50SFrank Blaschka } 2544a71df50SFrank Blaschka 2554a71df50SFrank Blaschka int qeth_realloc_buffer_pool(struct qeth_card *card, int bufcnt) 2564a71df50SFrank Blaschka { 257d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "realcbp"); 2584a71df50SFrank Blaschka 2594a71df50SFrank Blaschka if ((card->state != CARD_STATE_DOWN) && 2604a71df50SFrank Blaschka (card->state != CARD_STATE_RECOVER)) 2614a71df50SFrank Blaschka return -EPERM; 2624a71df50SFrank Blaschka 2634a71df50SFrank Blaschka /* TODO: steel/add buffers from/to a running card's buffer pool (?) */ 2644a71df50SFrank Blaschka qeth_clear_working_pool_list(card); 2654a71df50SFrank Blaschka qeth_free_buffer_pool(card); 2664a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count = bufcnt; 2674a71df50SFrank Blaschka card->qdio.init_pool.buf_count = bufcnt; 2684a71df50SFrank Blaschka return qeth_alloc_buffer_pool(card); 2694a71df50SFrank Blaschka } 2704a71df50SFrank Blaschka 2714a71df50SFrank Blaschka int qeth_set_large_send(struct qeth_card *card, 2724a71df50SFrank Blaschka enum qeth_large_send_types type) 2734a71df50SFrank Blaschka { 2744a71df50SFrank Blaschka int rc = 0; 2754a71df50SFrank Blaschka 2764a71df50SFrank Blaschka if (card->dev == NULL) { 2774a71df50SFrank Blaschka card->options.large_send = type; 2784a71df50SFrank Blaschka return 0; 2794a71df50SFrank Blaschka } 2804a71df50SFrank Blaschka if (card->state == CARD_STATE_UP) 2814a71df50SFrank Blaschka netif_tx_disable(card->dev); 2824a71df50SFrank Blaschka card->options.large_send = type; 2834a71df50SFrank Blaschka switch (card->options.large_send) { 2844a71df50SFrank Blaschka case QETH_LARGE_SEND_EDDP: 2854a71df50SFrank Blaschka card->dev->features |= NETIF_F_TSO | NETIF_F_SG | 2864a71df50SFrank Blaschka NETIF_F_HW_CSUM; 2874a71df50SFrank Blaschka break; 2884a71df50SFrank Blaschka case QETH_LARGE_SEND_TSO: 2894a71df50SFrank Blaschka if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) { 2904a71df50SFrank Blaschka card->dev->features |= NETIF_F_TSO | NETIF_F_SG | 2914a71df50SFrank Blaschka NETIF_F_HW_CSUM; 2924a71df50SFrank Blaschka } else { 2934a71df50SFrank Blaschka card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG | 2944a71df50SFrank Blaschka NETIF_F_HW_CSUM); 2954a71df50SFrank Blaschka card->options.large_send = QETH_LARGE_SEND_NO; 2964a71df50SFrank Blaschka rc = -EOPNOTSUPP; 2974a71df50SFrank Blaschka } 2984a71df50SFrank Blaschka break; 2994a71df50SFrank Blaschka default: /* includes QETH_LARGE_SEND_NO */ 3004a71df50SFrank Blaschka card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG | 3014a71df50SFrank Blaschka NETIF_F_HW_CSUM); 3024a71df50SFrank Blaschka break; 3034a71df50SFrank Blaschka } 3044a71df50SFrank Blaschka if (card->state == CARD_STATE_UP) 3054a71df50SFrank Blaschka netif_wake_queue(card->dev); 3064a71df50SFrank Blaschka return rc; 3074a71df50SFrank Blaschka } 3084a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_set_large_send); 3094a71df50SFrank Blaschka 3104a71df50SFrank Blaschka static int qeth_issue_next_read(struct qeth_card *card) 3114a71df50SFrank Blaschka { 3124a71df50SFrank Blaschka int rc; 3134a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 3144a71df50SFrank Blaschka 315d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "issnxrd"); 3164a71df50SFrank Blaschka if (card->read.state != CH_STATE_UP) 3174a71df50SFrank Blaschka return -EIO; 3184a71df50SFrank Blaschka iob = qeth_get_buffer(&card->read); 3194a71df50SFrank Blaschka if (!iob) { 3204a71df50SFrank Blaschka PRINT_WARN("issue_next_read failed: no iob available!\n"); 3214a71df50SFrank Blaschka return -ENOMEM; 3224a71df50SFrank Blaschka } 3234a71df50SFrank Blaschka qeth_setup_ccw(&card->read, iob->data, QETH_BUFSIZE); 324d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "noirqpnd"); 3254a71df50SFrank Blaschka rc = ccw_device_start(card->read.ccwdev, &card->read.ccw, 3264a71df50SFrank Blaschka (addr_t) iob, 0, 0); 3274a71df50SFrank Blaschka if (rc) { 3284a71df50SFrank Blaschka PRINT_ERR("Error in starting next read ccw! rc=%i\n", rc); 3294a71df50SFrank Blaschka atomic_set(&card->read.irq_pending, 0); 3304a71df50SFrank Blaschka qeth_schedule_recovery(card); 3314a71df50SFrank Blaschka wake_up(&card->wait_q); 3324a71df50SFrank Blaschka } 3334a71df50SFrank Blaschka return rc; 3344a71df50SFrank Blaschka } 3354a71df50SFrank Blaschka 3364a71df50SFrank Blaschka static struct qeth_reply *qeth_alloc_reply(struct qeth_card *card) 3374a71df50SFrank Blaschka { 3384a71df50SFrank Blaschka struct qeth_reply *reply; 3394a71df50SFrank Blaschka 3404a71df50SFrank Blaschka reply = kzalloc(sizeof(struct qeth_reply), GFP_ATOMIC); 3414a71df50SFrank Blaschka if (reply) { 3424a71df50SFrank Blaschka atomic_set(&reply->refcnt, 1); 3434a71df50SFrank Blaschka atomic_set(&reply->received, 0); 3444a71df50SFrank Blaschka reply->card = card; 3454a71df50SFrank Blaschka }; 3464a71df50SFrank Blaschka return reply; 3474a71df50SFrank Blaschka } 3484a71df50SFrank Blaschka 3494a71df50SFrank Blaschka static void qeth_get_reply(struct qeth_reply *reply) 3504a71df50SFrank Blaschka { 3514a71df50SFrank Blaschka WARN_ON(atomic_read(&reply->refcnt) <= 0); 3524a71df50SFrank Blaschka atomic_inc(&reply->refcnt); 3534a71df50SFrank Blaschka } 3544a71df50SFrank Blaschka 3554a71df50SFrank Blaschka static void qeth_put_reply(struct qeth_reply *reply) 3564a71df50SFrank Blaschka { 3574a71df50SFrank Blaschka WARN_ON(atomic_read(&reply->refcnt) <= 0); 3584a71df50SFrank Blaschka if (atomic_dec_and_test(&reply->refcnt)) 3594a71df50SFrank Blaschka kfree(reply); 3604a71df50SFrank Blaschka } 3614a71df50SFrank Blaschka 362d11ba0c4SPeter Tiedemann static void qeth_issue_ipa_msg(struct qeth_ipa_cmd *cmd, int rc, 3634a71df50SFrank Blaschka struct qeth_card *card) 3644a71df50SFrank Blaschka { 3654a71df50SFrank Blaschka char *ipa_name; 366d11ba0c4SPeter Tiedemann int com = cmd->hdr.command; 3674a71df50SFrank Blaschka ipa_name = qeth_get_ipa_cmd_name(com); 368d11ba0c4SPeter Tiedemann if (rc) 369d11ba0c4SPeter Tiedemann QETH_DBF_MESSAGE(2, "IPA: %s(x%X) for %s returned x%X \"%s\"\n", 370d11ba0c4SPeter Tiedemann ipa_name, com, QETH_CARD_IFNAME(card), 371d11ba0c4SPeter Tiedemann rc, qeth_get_ipa_msg(rc)); 372d11ba0c4SPeter Tiedemann else 373d11ba0c4SPeter Tiedemann QETH_DBF_MESSAGE(5, "IPA: %s(x%X) for %s succeeded\n", 374d11ba0c4SPeter Tiedemann ipa_name, com, QETH_CARD_IFNAME(card)); 3754a71df50SFrank Blaschka } 3764a71df50SFrank Blaschka 3774a71df50SFrank Blaschka static struct qeth_ipa_cmd *qeth_check_ipa_data(struct qeth_card *card, 3784a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 3794a71df50SFrank Blaschka { 3804a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd = NULL; 3814a71df50SFrank Blaschka 382d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "chkipad"); 3834a71df50SFrank Blaschka if (IS_IPA(iob->data)) { 3844a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) PDU_ENCAPSULATION(iob->data); 3854a71df50SFrank Blaschka if (IS_IPA_REPLY(cmd)) { 386d11ba0c4SPeter Tiedemann if (cmd->hdr.command < IPA_CMD_SETCCID || 387d11ba0c4SPeter Tiedemann cmd->hdr.command > IPA_CMD_MODCCID) 388d11ba0c4SPeter Tiedemann qeth_issue_ipa_msg(cmd, 389d11ba0c4SPeter Tiedemann cmd->hdr.return_code, card); 3904a71df50SFrank Blaschka return cmd; 3914a71df50SFrank Blaschka } else { 3924a71df50SFrank Blaschka switch (cmd->hdr.command) { 3934a71df50SFrank Blaschka case IPA_CMD_STOPLAN: 3944a71df50SFrank Blaschka PRINT_WARN("Link failure on %s (CHPID 0x%X) - " 3954a71df50SFrank Blaschka "there is a network problem or " 3964a71df50SFrank Blaschka "someone pulled the cable or " 3974a71df50SFrank Blaschka "disabled the port.\n", 3984a71df50SFrank Blaschka QETH_CARD_IFNAME(card), 3994a71df50SFrank Blaschka card->info.chpid); 4004a71df50SFrank Blaschka card->lan_online = 0; 4014a71df50SFrank Blaschka if (card->dev && netif_carrier_ok(card->dev)) 4024a71df50SFrank Blaschka netif_carrier_off(card->dev); 4034a71df50SFrank Blaschka return NULL; 4044a71df50SFrank Blaschka case IPA_CMD_STARTLAN: 4054a71df50SFrank Blaschka PRINT_INFO("Link reestablished on %s " 4064a71df50SFrank Blaschka "(CHPID 0x%X). Scheduling " 4074a71df50SFrank Blaschka "IP address reset.\n", 4084a71df50SFrank Blaschka QETH_CARD_IFNAME(card), 4094a71df50SFrank Blaschka card->info.chpid); 4104a71df50SFrank Blaschka netif_carrier_on(card->dev); 411922dc062SUrsula Braun card->lan_online = 1; 4124a71df50SFrank Blaschka qeth_schedule_recovery(card); 4134a71df50SFrank Blaschka return NULL; 4144a71df50SFrank Blaschka case IPA_CMD_MODCCID: 4154a71df50SFrank Blaschka return cmd; 4164a71df50SFrank Blaschka case IPA_CMD_REGISTER_LOCAL_ADDR: 417d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "irla"); 4184a71df50SFrank Blaschka break; 4194a71df50SFrank Blaschka case IPA_CMD_UNREGISTER_LOCAL_ADDR: 420d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "urla"); 4214a71df50SFrank Blaschka break; 4224a71df50SFrank Blaschka default: 423c4cef07cSFrank Blaschka QETH_DBF_MESSAGE(2, "Received data is IPA " 4244a71df50SFrank Blaschka "but not a reply!\n"); 4254a71df50SFrank Blaschka break; 4264a71df50SFrank Blaschka } 4274a71df50SFrank Blaschka } 4284a71df50SFrank Blaschka } 4294a71df50SFrank Blaschka return cmd; 4304a71df50SFrank Blaschka } 4314a71df50SFrank Blaschka 4324a71df50SFrank Blaschka void qeth_clear_ipacmd_list(struct qeth_card *card) 4334a71df50SFrank Blaschka { 4344a71df50SFrank Blaschka struct qeth_reply *reply, *r; 4354a71df50SFrank Blaschka unsigned long flags; 4364a71df50SFrank Blaschka 437d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "clipalst"); 4384a71df50SFrank Blaschka 4394a71df50SFrank Blaschka spin_lock_irqsave(&card->lock, flags); 4404a71df50SFrank Blaschka list_for_each_entry_safe(reply, r, &card->cmd_waiter_list, list) { 4414a71df50SFrank Blaschka qeth_get_reply(reply); 4424a71df50SFrank Blaschka reply->rc = -EIO; 4434a71df50SFrank Blaschka atomic_inc(&reply->received); 4444a71df50SFrank Blaschka list_del_init(&reply->list); 4454a71df50SFrank Blaschka wake_up(&reply->wait_q); 4464a71df50SFrank Blaschka qeth_put_reply(reply); 4474a71df50SFrank Blaschka } 4484a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 4494a71df50SFrank Blaschka } 4504a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_ipacmd_list); 4514a71df50SFrank Blaschka 4524a71df50SFrank Blaschka static int qeth_check_idx_response(unsigned char *buffer) 4534a71df50SFrank Blaschka { 4544a71df50SFrank Blaschka if (!buffer) 4554a71df50SFrank Blaschka return 0; 4564a71df50SFrank Blaschka 457d11ba0c4SPeter Tiedemann QETH_DBF_HEX(CTRL, 2, buffer, QETH_DBF_CTRL_LEN); 4584a71df50SFrank Blaschka if ((buffer[2] & 0xc0) == 0xc0) { 4594a71df50SFrank Blaschka PRINT_WARN("received an IDX TERMINATE " 4604a71df50SFrank Blaschka "with cause code 0x%02x%s\n", 4614a71df50SFrank Blaschka buffer[4], 4624a71df50SFrank Blaschka ((buffer[4] == 0x22) ? 4634a71df50SFrank Blaschka " -- try another portname" : "")); 464d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "ckidxres"); 465d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, " idxterm"); 466d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, " rc%d", -EIO); 4674a71df50SFrank Blaschka return -EIO; 4684a71df50SFrank Blaschka } 4694a71df50SFrank Blaschka return 0; 4704a71df50SFrank Blaschka } 4714a71df50SFrank Blaschka 4724a71df50SFrank Blaschka static void qeth_setup_ccw(struct qeth_channel *channel, unsigned char *iob, 4734a71df50SFrank Blaschka __u32 len) 4744a71df50SFrank Blaschka { 4754a71df50SFrank Blaschka struct qeth_card *card; 4764a71df50SFrank Blaschka 477d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "setupccw"); 4784a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 4794a71df50SFrank Blaschka if (channel == &card->read) 4804a71df50SFrank Blaschka memcpy(&channel->ccw, READ_CCW, sizeof(struct ccw1)); 4814a71df50SFrank Blaschka else 4824a71df50SFrank Blaschka memcpy(&channel->ccw, WRITE_CCW, sizeof(struct ccw1)); 4834a71df50SFrank Blaschka channel->ccw.count = len; 4844a71df50SFrank Blaschka channel->ccw.cda = (__u32) __pa(iob); 4854a71df50SFrank Blaschka } 4864a71df50SFrank Blaschka 4874a71df50SFrank Blaschka static struct qeth_cmd_buffer *__qeth_get_buffer(struct qeth_channel *channel) 4884a71df50SFrank Blaschka { 4894a71df50SFrank Blaschka __u8 index; 4904a71df50SFrank Blaschka 491d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "getbuff"); 4924a71df50SFrank Blaschka index = channel->io_buf_no; 4934a71df50SFrank Blaschka do { 4944a71df50SFrank Blaschka if (channel->iob[index].state == BUF_STATE_FREE) { 4954a71df50SFrank Blaschka channel->iob[index].state = BUF_STATE_LOCKED; 4964a71df50SFrank Blaschka channel->io_buf_no = (channel->io_buf_no + 1) % 4974a71df50SFrank Blaschka QETH_CMD_BUFFER_NO; 4984a71df50SFrank Blaschka memset(channel->iob[index].data, 0, QETH_BUFSIZE); 4994a71df50SFrank Blaschka return channel->iob + index; 5004a71df50SFrank Blaschka } 5014a71df50SFrank Blaschka index = (index + 1) % QETH_CMD_BUFFER_NO; 5024a71df50SFrank Blaschka } while (index != channel->io_buf_no); 5034a71df50SFrank Blaschka 5044a71df50SFrank Blaschka return NULL; 5054a71df50SFrank Blaschka } 5064a71df50SFrank Blaschka 5074a71df50SFrank Blaschka void qeth_release_buffer(struct qeth_channel *channel, 5084a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 5094a71df50SFrank Blaschka { 5104a71df50SFrank Blaschka unsigned long flags; 5114a71df50SFrank Blaschka 512d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "relbuff"); 5134a71df50SFrank Blaschka spin_lock_irqsave(&channel->iob_lock, flags); 5144a71df50SFrank Blaschka memset(iob->data, 0, QETH_BUFSIZE); 5154a71df50SFrank Blaschka iob->state = BUF_STATE_FREE; 5164a71df50SFrank Blaschka iob->callback = qeth_send_control_data_cb; 5174a71df50SFrank Blaschka iob->rc = 0; 5184a71df50SFrank Blaschka spin_unlock_irqrestore(&channel->iob_lock, flags); 5194a71df50SFrank Blaschka } 5204a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_release_buffer); 5214a71df50SFrank Blaschka 5224a71df50SFrank Blaschka static struct qeth_cmd_buffer *qeth_get_buffer(struct qeth_channel *channel) 5234a71df50SFrank Blaschka { 5244a71df50SFrank Blaschka struct qeth_cmd_buffer *buffer = NULL; 5254a71df50SFrank Blaschka unsigned long flags; 5264a71df50SFrank Blaschka 5274a71df50SFrank Blaschka spin_lock_irqsave(&channel->iob_lock, flags); 5284a71df50SFrank Blaschka buffer = __qeth_get_buffer(channel); 5294a71df50SFrank Blaschka spin_unlock_irqrestore(&channel->iob_lock, flags); 5304a71df50SFrank Blaschka return buffer; 5314a71df50SFrank Blaschka } 5324a71df50SFrank Blaschka 5334a71df50SFrank Blaschka struct qeth_cmd_buffer *qeth_wait_for_buffer(struct qeth_channel *channel) 5344a71df50SFrank Blaschka { 5354a71df50SFrank Blaschka struct qeth_cmd_buffer *buffer; 5364a71df50SFrank Blaschka wait_event(channel->wait_q, 5374a71df50SFrank Blaschka ((buffer = qeth_get_buffer(channel)) != NULL)); 5384a71df50SFrank Blaschka return buffer; 5394a71df50SFrank Blaschka } 5404a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_wait_for_buffer); 5414a71df50SFrank Blaschka 5424a71df50SFrank Blaschka void qeth_clear_cmd_buffers(struct qeth_channel *channel) 5434a71df50SFrank Blaschka { 5444a71df50SFrank Blaschka int cnt; 5454a71df50SFrank Blaschka 5464a71df50SFrank Blaschka for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) 5474a71df50SFrank Blaschka qeth_release_buffer(channel, &channel->iob[cnt]); 5484a71df50SFrank Blaschka channel->buf_no = 0; 5494a71df50SFrank Blaschka channel->io_buf_no = 0; 5504a71df50SFrank Blaschka } 5514a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_cmd_buffers); 5524a71df50SFrank Blaschka 5534a71df50SFrank Blaschka static void qeth_send_control_data_cb(struct qeth_channel *channel, 5544a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 5554a71df50SFrank Blaschka { 5564a71df50SFrank Blaschka struct qeth_card *card; 5574a71df50SFrank Blaschka struct qeth_reply *reply, *r; 5584a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 5594a71df50SFrank Blaschka unsigned long flags; 5604a71df50SFrank Blaschka int keep_reply; 5614a71df50SFrank Blaschka 562d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "sndctlcb"); 5634a71df50SFrank Blaschka 5644a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 5654a71df50SFrank Blaschka if (qeth_check_idx_response(iob->data)) { 5664a71df50SFrank Blaschka qeth_clear_ipacmd_list(card); 5674a71df50SFrank Blaschka qeth_schedule_recovery(card); 5684a71df50SFrank Blaschka goto out; 5694a71df50SFrank Blaschka } 5704a71df50SFrank Blaschka 5714a71df50SFrank Blaschka cmd = qeth_check_ipa_data(card, iob); 5724a71df50SFrank Blaschka if ((cmd == NULL) && (card->state != CARD_STATE_DOWN)) 5734a71df50SFrank Blaschka goto out; 5744a71df50SFrank Blaschka /*in case of OSN : check if cmd is set */ 5754a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN && 5764a71df50SFrank Blaschka cmd && 5774a71df50SFrank Blaschka cmd->hdr.command != IPA_CMD_STARTLAN && 5784a71df50SFrank Blaschka card->osn_info.assist_cb != NULL) { 5794a71df50SFrank Blaschka card->osn_info.assist_cb(card->dev, cmd); 5804a71df50SFrank Blaschka goto out; 5814a71df50SFrank Blaschka } 5824a71df50SFrank Blaschka 5834a71df50SFrank Blaschka spin_lock_irqsave(&card->lock, flags); 5844a71df50SFrank Blaschka list_for_each_entry_safe(reply, r, &card->cmd_waiter_list, list) { 5854a71df50SFrank Blaschka if ((reply->seqno == QETH_IDX_COMMAND_SEQNO) || 5864a71df50SFrank Blaschka ((cmd) && (reply->seqno == cmd->hdr.seqno))) { 5874a71df50SFrank Blaschka qeth_get_reply(reply); 5884a71df50SFrank Blaschka list_del_init(&reply->list); 5894a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 5904a71df50SFrank Blaschka keep_reply = 0; 5914a71df50SFrank Blaschka if (reply->callback != NULL) { 5924a71df50SFrank Blaschka if (cmd) { 5934a71df50SFrank Blaschka reply->offset = (__u16)((char *)cmd - 5944a71df50SFrank Blaschka (char *)iob->data); 5954a71df50SFrank Blaschka keep_reply = reply->callback(card, 5964a71df50SFrank Blaschka reply, 5974a71df50SFrank Blaschka (unsigned long)cmd); 5984a71df50SFrank Blaschka } else 5994a71df50SFrank Blaschka keep_reply = reply->callback(card, 6004a71df50SFrank Blaschka reply, 6014a71df50SFrank Blaschka (unsigned long)iob); 6024a71df50SFrank Blaschka } 6034a71df50SFrank Blaschka if (cmd) 6044a71df50SFrank Blaschka reply->rc = (u16) cmd->hdr.return_code; 6054a71df50SFrank Blaschka else if (iob->rc) 6064a71df50SFrank Blaschka reply->rc = iob->rc; 6074a71df50SFrank Blaschka if (keep_reply) { 6084a71df50SFrank Blaschka spin_lock_irqsave(&card->lock, flags); 6094a71df50SFrank Blaschka list_add_tail(&reply->list, 6104a71df50SFrank Blaschka &card->cmd_waiter_list); 6114a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 6124a71df50SFrank Blaschka } else { 6134a71df50SFrank Blaschka atomic_inc(&reply->received); 6144a71df50SFrank Blaschka wake_up(&reply->wait_q); 6154a71df50SFrank Blaschka } 6164a71df50SFrank Blaschka qeth_put_reply(reply); 6174a71df50SFrank Blaschka goto out; 6184a71df50SFrank Blaschka } 6194a71df50SFrank Blaschka } 6204a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 6214a71df50SFrank Blaschka out: 6224a71df50SFrank Blaschka memcpy(&card->seqno.pdu_hdr_ack, 6234a71df50SFrank Blaschka QETH_PDU_HEADER_SEQ_NO(iob->data), 6244a71df50SFrank Blaschka QETH_SEQ_NO_LENGTH); 6254a71df50SFrank Blaschka qeth_release_buffer(channel, iob); 6264a71df50SFrank Blaschka } 6274a71df50SFrank Blaschka 6284a71df50SFrank Blaschka static int qeth_setup_channel(struct qeth_channel *channel) 6294a71df50SFrank Blaschka { 6304a71df50SFrank Blaschka int cnt; 6314a71df50SFrank Blaschka 632d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "setupch"); 6334a71df50SFrank Blaschka for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) { 6344a71df50SFrank Blaschka channel->iob[cnt].data = (char *) 6354a71df50SFrank Blaschka kmalloc(QETH_BUFSIZE, GFP_DMA|GFP_KERNEL); 6364a71df50SFrank Blaschka if (channel->iob[cnt].data == NULL) 6374a71df50SFrank Blaschka break; 6384a71df50SFrank Blaschka channel->iob[cnt].state = BUF_STATE_FREE; 6394a71df50SFrank Blaschka channel->iob[cnt].channel = channel; 6404a71df50SFrank Blaschka channel->iob[cnt].callback = qeth_send_control_data_cb; 6414a71df50SFrank Blaschka channel->iob[cnt].rc = 0; 6424a71df50SFrank Blaschka } 6434a71df50SFrank Blaschka if (cnt < QETH_CMD_BUFFER_NO) { 6444a71df50SFrank Blaschka while (cnt-- > 0) 6454a71df50SFrank Blaschka kfree(channel->iob[cnt].data); 6464a71df50SFrank Blaschka return -ENOMEM; 6474a71df50SFrank Blaschka } 6484a71df50SFrank Blaschka channel->buf_no = 0; 6494a71df50SFrank Blaschka channel->io_buf_no = 0; 6504a71df50SFrank Blaschka atomic_set(&channel->irq_pending, 0); 6514a71df50SFrank Blaschka spin_lock_init(&channel->iob_lock); 6524a71df50SFrank Blaschka 6534a71df50SFrank Blaschka init_waitqueue_head(&channel->wait_q); 6544a71df50SFrank Blaschka return 0; 6554a71df50SFrank Blaschka } 6564a71df50SFrank Blaschka 6574a71df50SFrank Blaschka static int qeth_set_thread_start_bit(struct qeth_card *card, 6584a71df50SFrank Blaschka unsigned long thread) 6594a71df50SFrank Blaschka { 6604a71df50SFrank Blaschka unsigned long flags; 6614a71df50SFrank Blaschka 6624a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 6634a71df50SFrank Blaschka if (!(card->thread_allowed_mask & thread) || 6644a71df50SFrank Blaschka (card->thread_start_mask & thread)) { 6654a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 6664a71df50SFrank Blaschka return -EPERM; 6674a71df50SFrank Blaschka } 6684a71df50SFrank Blaschka card->thread_start_mask |= thread; 6694a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 6704a71df50SFrank Blaschka return 0; 6714a71df50SFrank Blaschka } 6724a71df50SFrank Blaschka 6734a71df50SFrank Blaschka void qeth_clear_thread_start_bit(struct qeth_card *card, unsigned long thread) 6744a71df50SFrank Blaschka { 6754a71df50SFrank Blaschka unsigned long flags; 6764a71df50SFrank Blaschka 6774a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 6784a71df50SFrank Blaschka card->thread_start_mask &= ~thread; 6794a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 6804a71df50SFrank Blaschka wake_up(&card->wait_q); 6814a71df50SFrank Blaschka } 6824a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_thread_start_bit); 6834a71df50SFrank Blaschka 6844a71df50SFrank Blaschka void qeth_clear_thread_running_bit(struct qeth_card *card, unsigned long thread) 6854a71df50SFrank Blaschka { 6864a71df50SFrank Blaschka unsigned long flags; 6874a71df50SFrank Blaschka 6884a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 6894a71df50SFrank Blaschka card->thread_running_mask &= ~thread; 6904a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 6914a71df50SFrank Blaschka wake_up(&card->wait_q); 6924a71df50SFrank Blaschka } 6934a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_thread_running_bit); 6944a71df50SFrank Blaschka 6954a71df50SFrank Blaschka static int __qeth_do_run_thread(struct qeth_card *card, unsigned long thread) 6964a71df50SFrank Blaschka { 6974a71df50SFrank Blaschka unsigned long flags; 6984a71df50SFrank Blaschka int rc = 0; 6994a71df50SFrank Blaschka 7004a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 7014a71df50SFrank Blaschka if (card->thread_start_mask & thread) { 7024a71df50SFrank Blaschka if ((card->thread_allowed_mask & thread) && 7034a71df50SFrank Blaschka !(card->thread_running_mask & thread)) { 7044a71df50SFrank Blaschka rc = 1; 7054a71df50SFrank Blaschka card->thread_start_mask &= ~thread; 7064a71df50SFrank Blaschka card->thread_running_mask |= thread; 7074a71df50SFrank Blaschka } else 7084a71df50SFrank Blaschka rc = -EPERM; 7094a71df50SFrank Blaschka } 7104a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 7114a71df50SFrank Blaschka return rc; 7124a71df50SFrank Blaschka } 7134a71df50SFrank Blaschka 7144a71df50SFrank Blaschka int qeth_do_run_thread(struct qeth_card *card, unsigned long thread) 7154a71df50SFrank Blaschka { 7164a71df50SFrank Blaschka int rc = 0; 7174a71df50SFrank Blaschka 7184a71df50SFrank Blaschka wait_event(card->wait_q, 7194a71df50SFrank Blaschka (rc = __qeth_do_run_thread(card, thread)) >= 0); 7204a71df50SFrank Blaschka return rc; 7214a71df50SFrank Blaschka } 7224a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_do_run_thread); 7234a71df50SFrank Blaschka 7244a71df50SFrank Blaschka void qeth_schedule_recovery(struct qeth_card *card) 7254a71df50SFrank Blaschka { 726d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "startrec"); 7274a71df50SFrank Blaschka if (qeth_set_thread_start_bit(card, QETH_RECOVER_THREAD) == 0) 7284a71df50SFrank Blaschka schedule_work(&card->kernel_thread_starter); 7294a71df50SFrank Blaschka } 7304a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_schedule_recovery); 7314a71df50SFrank Blaschka 7324a71df50SFrank Blaschka static int qeth_get_problem(struct ccw_device *cdev, struct irb *irb) 7334a71df50SFrank Blaschka { 7344a71df50SFrank Blaschka int dstat, cstat; 7354a71df50SFrank Blaschka char *sense; 7364a71df50SFrank Blaschka 7374a71df50SFrank Blaschka sense = (char *) irb->ecw; 73823d805b6SPeter Oberparleiter cstat = irb->scsw.cmd.cstat; 73923d805b6SPeter Oberparleiter dstat = irb->scsw.cmd.dstat; 7404a71df50SFrank Blaschka 7414a71df50SFrank Blaschka if (cstat & (SCHN_STAT_CHN_CTRL_CHK | SCHN_STAT_INTF_CTRL_CHK | 7424a71df50SFrank Blaschka SCHN_STAT_CHN_DATA_CHK | SCHN_STAT_CHAIN_CHECK | 7434a71df50SFrank Blaschka SCHN_STAT_PROT_CHECK | SCHN_STAT_PROG_CHECK)) { 744d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "CGENCHK"); 7454a71df50SFrank Blaschka PRINT_WARN("check on device %s, dstat=x%x, cstat=x%x ", 7464a71df50SFrank Blaschka cdev->dev.bus_id, dstat, cstat); 7474a71df50SFrank Blaschka print_hex_dump(KERN_WARNING, "qeth: irb ", DUMP_PREFIX_OFFSET, 7484a71df50SFrank Blaschka 16, 1, irb, 64, 1); 7494a71df50SFrank Blaschka return 1; 7504a71df50SFrank Blaschka } 7514a71df50SFrank Blaschka 7524a71df50SFrank Blaschka if (dstat & DEV_STAT_UNIT_CHECK) { 7534a71df50SFrank Blaschka if (sense[SENSE_RESETTING_EVENT_BYTE] & 7544a71df50SFrank Blaschka SENSE_RESETTING_EVENT_FLAG) { 755d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "REVIND"); 7564a71df50SFrank Blaschka return 1; 7574a71df50SFrank Blaschka } 7584a71df50SFrank Blaschka if (sense[SENSE_COMMAND_REJECT_BYTE] & 7594a71df50SFrank Blaschka SENSE_COMMAND_REJECT_FLAG) { 760d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "CMDREJi"); 7614a71df50SFrank Blaschka return 0; 7624a71df50SFrank Blaschka } 7634a71df50SFrank Blaschka if ((sense[2] == 0xaf) && (sense[3] == 0xfe)) { 764d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "AFFE"); 7654a71df50SFrank Blaschka return 1; 7664a71df50SFrank Blaschka } 7674a71df50SFrank Blaschka if ((!sense[0]) && (!sense[1]) && (!sense[2]) && (!sense[3])) { 768d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "ZEROSEN"); 7694a71df50SFrank Blaschka return 0; 7704a71df50SFrank Blaschka } 771d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "DGENCHK"); 7724a71df50SFrank Blaschka return 1; 7734a71df50SFrank Blaschka } 7744a71df50SFrank Blaschka return 0; 7754a71df50SFrank Blaschka } 7764a71df50SFrank Blaschka 7774a71df50SFrank Blaschka static long __qeth_check_irb_error(struct ccw_device *cdev, 7784a71df50SFrank Blaschka unsigned long intparm, struct irb *irb) 7794a71df50SFrank Blaschka { 7804a71df50SFrank Blaschka if (!IS_ERR(irb)) 7814a71df50SFrank Blaschka return 0; 7824a71df50SFrank Blaschka 7834a71df50SFrank Blaschka switch (PTR_ERR(irb)) { 7844a71df50SFrank Blaschka case -EIO: 7854a71df50SFrank Blaschka PRINT_WARN("i/o-error on device %s\n", cdev->dev.bus_id); 786d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "ckirberr"); 787d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, " rc%d", -EIO); 7884a71df50SFrank Blaschka break; 7894a71df50SFrank Blaschka case -ETIMEDOUT: 7904a71df50SFrank Blaschka PRINT_WARN("timeout on device %s\n", cdev->dev.bus_id); 791d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "ckirberr"); 792d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, " rc%d", -ETIMEDOUT); 7934a71df50SFrank Blaschka if (intparm == QETH_RCD_PARM) { 7944a71df50SFrank Blaschka struct qeth_card *card = CARD_FROM_CDEV(cdev); 7954a71df50SFrank Blaschka 7964a71df50SFrank Blaschka if (card && (card->data.ccwdev == cdev)) { 7974a71df50SFrank Blaschka card->data.state = CH_STATE_DOWN; 7984a71df50SFrank Blaschka wake_up(&card->wait_q); 7994a71df50SFrank Blaschka } 8004a71df50SFrank Blaschka } 8014a71df50SFrank Blaschka break; 8024a71df50SFrank Blaschka default: 8034a71df50SFrank Blaschka PRINT_WARN("unknown error %ld on device %s\n", PTR_ERR(irb), 8044a71df50SFrank Blaschka cdev->dev.bus_id); 805d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "ckirberr"); 806d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, " rc???"); 8074a71df50SFrank Blaschka } 8084a71df50SFrank Blaschka return PTR_ERR(irb); 8094a71df50SFrank Blaschka } 8104a71df50SFrank Blaschka 8114a71df50SFrank Blaschka static void qeth_irq(struct ccw_device *cdev, unsigned long intparm, 8124a71df50SFrank Blaschka struct irb *irb) 8134a71df50SFrank Blaschka { 8144a71df50SFrank Blaschka int rc; 8154a71df50SFrank Blaschka int cstat, dstat; 8164a71df50SFrank Blaschka struct qeth_cmd_buffer *buffer; 8174a71df50SFrank Blaschka struct qeth_channel *channel; 8184a71df50SFrank Blaschka struct qeth_card *card; 8194a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 8204a71df50SFrank Blaschka __u8 index; 8214a71df50SFrank Blaschka 822d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "irq"); 8234a71df50SFrank Blaschka 8244a71df50SFrank Blaschka if (__qeth_check_irb_error(cdev, intparm, irb)) 8254a71df50SFrank Blaschka return; 82623d805b6SPeter Oberparleiter cstat = irb->scsw.cmd.cstat; 82723d805b6SPeter Oberparleiter dstat = irb->scsw.cmd.dstat; 8284a71df50SFrank Blaschka 8294a71df50SFrank Blaschka card = CARD_FROM_CDEV(cdev); 8304a71df50SFrank Blaschka if (!card) 8314a71df50SFrank Blaschka return; 8324a71df50SFrank Blaschka 8334a71df50SFrank Blaschka if (card->read.ccwdev == cdev) { 8344a71df50SFrank Blaschka channel = &card->read; 835d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "read"); 8364a71df50SFrank Blaschka } else if (card->write.ccwdev == cdev) { 8374a71df50SFrank Blaschka channel = &card->write; 838d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "write"); 8394a71df50SFrank Blaschka } else { 8404a71df50SFrank Blaschka channel = &card->data; 841d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "data"); 8424a71df50SFrank Blaschka } 8434a71df50SFrank Blaschka atomic_set(&channel->irq_pending, 0); 8444a71df50SFrank Blaschka 84523d805b6SPeter Oberparleiter if (irb->scsw.cmd.fctl & (SCSW_FCTL_CLEAR_FUNC)) 8464a71df50SFrank Blaschka channel->state = CH_STATE_STOPPED; 8474a71df50SFrank Blaschka 84823d805b6SPeter Oberparleiter if (irb->scsw.cmd.fctl & (SCSW_FCTL_HALT_FUNC)) 8494a71df50SFrank Blaschka channel->state = CH_STATE_HALTED; 8504a71df50SFrank Blaschka 8514a71df50SFrank Blaschka /*let's wake up immediately on data channel*/ 8524a71df50SFrank Blaschka if ((channel == &card->data) && (intparm != 0) && 8534a71df50SFrank Blaschka (intparm != QETH_RCD_PARM)) 8544a71df50SFrank Blaschka goto out; 8554a71df50SFrank Blaschka 8564a71df50SFrank Blaschka if (intparm == QETH_CLEAR_CHANNEL_PARM) { 857d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "clrchpar"); 8584a71df50SFrank Blaschka /* we don't have to handle this further */ 8594a71df50SFrank Blaschka intparm = 0; 8604a71df50SFrank Blaschka } 8614a71df50SFrank Blaschka if (intparm == QETH_HALT_CHANNEL_PARM) { 862d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "hltchpar"); 8634a71df50SFrank Blaschka /* we don't have to handle this further */ 8644a71df50SFrank Blaschka intparm = 0; 8654a71df50SFrank Blaschka } 8664a71df50SFrank Blaschka if ((dstat & DEV_STAT_UNIT_EXCEP) || 8674a71df50SFrank Blaschka (dstat & DEV_STAT_UNIT_CHECK) || 8684a71df50SFrank Blaschka (cstat)) { 8694a71df50SFrank Blaschka if (irb->esw.esw0.erw.cons) { 8704a71df50SFrank Blaschka /* TODO: we should make this s390dbf */ 8714a71df50SFrank Blaschka PRINT_WARN("sense data available on channel %s.\n", 8724a71df50SFrank Blaschka CHANNEL_ID(channel)); 8734a71df50SFrank Blaschka PRINT_WARN(" cstat 0x%X\n dstat 0x%X\n", cstat, dstat); 8744a71df50SFrank Blaschka print_hex_dump(KERN_WARNING, "qeth: irb ", 8754a71df50SFrank Blaschka DUMP_PREFIX_OFFSET, 16, 1, irb, 32, 1); 8764a71df50SFrank Blaschka print_hex_dump(KERN_WARNING, "qeth: sense data ", 8774a71df50SFrank Blaschka DUMP_PREFIX_OFFSET, 16, 1, irb->ecw, 32, 1); 8784a71df50SFrank Blaschka } 8794a71df50SFrank Blaschka if (intparm == QETH_RCD_PARM) { 8804a71df50SFrank Blaschka channel->state = CH_STATE_DOWN; 8814a71df50SFrank Blaschka goto out; 8824a71df50SFrank Blaschka } 8834a71df50SFrank Blaschka rc = qeth_get_problem(cdev, irb); 8844a71df50SFrank Blaschka if (rc) { 8854a71df50SFrank Blaschka qeth_schedule_recovery(card); 8864a71df50SFrank Blaschka goto out; 8874a71df50SFrank Blaschka } 8884a71df50SFrank Blaschka } 8894a71df50SFrank Blaschka 8904a71df50SFrank Blaschka if (intparm == QETH_RCD_PARM) { 8914a71df50SFrank Blaschka channel->state = CH_STATE_RCD_DONE; 8924a71df50SFrank Blaschka goto out; 8934a71df50SFrank Blaschka } 8944a71df50SFrank Blaschka if (intparm) { 8954a71df50SFrank Blaschka buffer = (struct qeth_cmd_buffer *) __va((addr_t)intparm); 8964a71df50SFrank Blaschka buffer->state = BUF_STATE_PROCESSED; 8974a71df50SFrank Blaschka } 8984a71df50SFrank Blaschka if (channel == &card->data) 8994a71df50SFrank Blaschka return; 9004a71df50SFrank Blaschka if (channel == &card->read && 9014a71df50SFrank Blaschka channel->state == CH_STATE_UP) 9024a71df50SFrank Blaschka qeth_issue_next_read(card); 9034a71df50SFrank Blaschka 9044a71df50SFrank Blaschka iob = channel->iob; 9054a71df50SFrank Blaschka index = channel->buf_no; 9064a71df50SFrank Blaschka while (iob[index].state == BUF_STATE_PROCESSED) { 9074a71df50SFrank Blaschka if (iob[index].callback != NULL) 9084a71df50SFrank Blaschka iob[index].callback(channel, iob + index); 9094a71df50SFrank Blaschka 9104a71df50SFrank Blaschka index = (index + 1) % QETH_CMD_BUFFER_NO; 9114a71df50SFrank Blaschka } 9124a71df50SFrank Blaschka channel->buf_no = index; 9134a71df50SFrank Blaschka out: 9144a71df50SFrank Blaschka wake_up(&card->wait_q); 9154a71df50SFrank Blaschka return; 9164a71df50SFrank Blaschka } 9174a71df50SFrank Blaschka 9184a71df50SFrank Blaschka static void qeth_clear_output_buffer(struct qeth_qdio_out_q *queue, 9194a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buf) 9204a71df50SFrank Blaschka { 9214a71df50SFrank Blaschka int i; 9224a71df50SFrank Blaschka struct sk_buff *skb; 9234a71df50SFrank Blaschka 9244a71df50SFrank Blaschka /* is PCI flag set on buffer? */ 9254a71df50SFrank Blaschka if (buf->buffer->element[0].flags & 0x40) 9264a71df50SFrank Blaschka atomic_dec(&queue->set_pci_flags_count); 9274a71df50SFrank Blaschka 9284a71df50SFrank Blaschka skb = skb_dequeue(&buf->skb_list); 9294a71df50SFrank Blaschka while (skb) { 9304a71df50SFrank Blaschka atomic_dec(&skb->users); 9314a71df50SFrank Blaschka dev_kfree_skb_any(skb); 9324a71df50SFrank Blaschka skb = skb_dequeue(&buf->skb_list); 9334a71df50SFrank Blaschka } 9344a71df50SFrank Blaschka qeth_eddp_buf_release_contexts(buf); 9354a71df50SFrank Blaschka for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(queue->card); ++i) { 9364a71df50SFrank Blaschka buf->buffer->element[i].length = 0; 9374a71df50SFrank Blaschka buf->buffer->element[i].addr = NULL; 9384a71df50SFrank Blaschka buf->buffer->element[i].flags = 0; 9394a71df50SFrank Blaschka } 9404a71df50SFrank Blaschka buf->next_element_to_fill = 0; 9414a71df50SFrank Blaschka atomic_set(&buf->state, QETH_QDIO_BUF_EMPTY); 9424a71df50SFrank Blaschka } 9434a71df50SFrank Blaschka 9444a71df50SFrank Blaschka void qeth_clear_qdio_buffers(struct qeth_card *card) 9454a71df50SFrank Blaschka { 9464a71df50SFrank Blaschka int i, j; 9474a71df50SFrank Blaschka 948d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "clearqdbf"); 9494a71df50SFrank Blaschka /* clear outbound buffers to free skbs */ 9504a71df50SFrank Blaschka for (i = 0; i < card->qdio.no_out_queues; ++i) 9514a71df50SFrank Blaschka if (card->qdio.out_qs[i]) { 9524a71df50SFrank Blaschka for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) 9534a71df50SFrank Blaschka qeth_clear_output_buffer(card->qdio.out_qs[i], 9544a71df50SFrank Blaschka &card->qdio.out_qs[i]->bufs[j]); 9554a71df50SFrank Blaschka } 9564a71df50SFrank Blaschka } 9574a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_clear_qdio_buffers); 9584a71df50SFrank Blaschka 9594a71df50SFrank Blaschka static void qeth_free_buffer_pool(struct qeth_card *card) 9604a71df50SFrank Blaschka { 9614a71df50SFrank Blaschka struct qeth_buffer_pool_entry *pool_entry, *tmp; 9624a71df50SFrank Blaschka int i = 0; 963d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "freepool"); 9644a71df50SFrank Blaschka list_for_each_entry_safe(pool_entry, tmp, 9654a71df50SFrank Blaschka &card->qdio.init_pool.entry_list, init_list){ 9664a71df50SFrank Blaschka for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) 9674a71df50SFrank Blaschka free_page((unsigned long)pool_entry->elements[i]); 9684a71df50SFrank Blaschka list_del(&pool_entry->init_list); 9694a71df50SFrank Blaschka kfree(pool_entry); 9704a71df50SFrank Blaschka } 9714a71df50SFrank Blaschka } 9724a71df50SFrank Blaschka 9734a71df50SFrank Blaschka static void qeth_free_qdio_buffers(struct qeth_card *card) 9744a71df50SFrank Blaschka { 9754a71df50SFrank Blaschka int i, j; 9764a71df50SFrank Blaschka 977d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "freeqdbf"); 9784a71df50SFrank Blaschka if (atomic_xchg(&card->qdio.state, QETH_QDIO_UNINITIALIZED) == 9794a71df50SFrank Blaschka QETH_QDIO_UNINITIALIZED) 9804a71df50SFrank Blaschka return; 9814a71df50SFrank Blaschka kfree(card->qdio.in_q); 9824a71df50SFrank Blaschka card->qdio.in_q = NULL; 9834a71df50SFrank Blaschka /* inbound buffer pool */ 9844a71df50SFrank Blaschka qeth_free_buffer_pool(card); 9854a71df50SFrank Blaschka /* free outbound qdio_qs */ 9864a71df50SFrank Blaschka if (card->qdio.out_qs) { 9874a71df50SFrank Blaschka for (i = 0; i < card->qdio.no_out_queues; ++i) { 9884a71df50SFrank Blaschka for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) 9894a71df50SFrank Blaschka qeth_clear_output_buffer(card->qdio.out_qs[i], 9904a71df50SFrank Blaschka &card->qdio.out_qs[i]->bufs[j]); 9914a71df50SFrank Blaschka kfree(card->qdio.out_qs[i]); 9924a71df50SFrank Blaschka } 9934a71df50SFrank Blaschka kfree(card->qdio.out_qs); 9944a71df50SFrank Blaschka card->qdio.out_qs = NULL; 9954a71df50SFrank Blaschka } 9964a71df50SFrank Blaschka } 9974a71df50SFrank Blaschka 9984a71df50SFrank Blaschka static void qeth_clean_channel(struct qeth_channel *channel) 9994a71df50SFrank Blaschka { 10004a71df50SFrank Blaschka int cnt; 10014a71df50SFrank Blaschka 1002d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "freech"); 10034a71df50SFrank Blaschka for (cnt = 0; cnt < QETH_CMD_BUFFER_NO; cnt++) 10044a71df50SFrank Blaschka kfree(channel->iob[cnt].data); 10054a71df50SFrank Blaschka } 10064a71df50SFrank Blaschka 10074a71df50SFrank Blaschka static int qeth_is_1920_device(struct qeth_card *card) 10084a71df50SFrank Blaschka { 10094a71df50SFrank Blaschka int single_queue = 0; 10104a71df50SFrank Blaschka struct ccw_device *ccwdev; 10114a71df50SFrank Blaschka struct channelPath_dsc { 10124a71df50SFrank Blaschka u8 flags; 10134a71df50SFrank Blaschka u8 lsn; 10144a71df50SFrank Blaschka u8 desc; 10154a71df50SFrank Blaschka u8 chpid; 10164a71df50SFrank Blaschka u8 swla; 10174a71df50SFrank Blaschka u8 zeroes; 10184a71df50SFrank Blaschka u8 chla; 10194a71df50SFrank Blaschka u8 chpp; 10204a71df50SFrank Blaschka } *chp_dsc; 10214a71df50SFrank Blaschka 1022d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "chk_1920"); 10234a71df50SFrank Blaschka 10244a71df50SFrank Blaschka ccwdev = card->data.ccwdev; 10254a71df50SFrank Blaschka chp_dsc = (struct channelPath_dsc *)ccw_device_get_chp_desc(ccwdev, 0); 10264a71df50SFrank Blaschka if (chp_dsc != NULL) { 10274a71df50SFrank Blaschka /* CHPP field bit 6 == 1 -> single queue */ 10284a71df50SFrank Blaschka single_queue = ((chp_dsc->chpp & 0x02) == 0x02); 10294a71df50SFrank Blaschka kfree(chp_dsc); 10304a71df50SFrank Blaschka } 1031d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "rc:%x", single_queue); 10324a71df50SFrank Blaschka return single_queue; 10334a71df50SFrank Blaschka } 10344a71df50SFrank Blaschka 10354a71df50SFrank Blaschka static void qeth_init_qdio_info(struct qeth_card *card) 10364a71df50SFrank Blaschka { 1037d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 4, "intqdinf"); 10384a71df50SFrank Blaschka atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED); 10394a71df50SFrank Blaschka /* inbound */ 10404a71df50SFrank Blaschka card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT; 10414a71df50SFrank Blaschka card->qdio.init_pool.buf_count = QETH_IN_BUF_COUNT_DEFAULT; 10424a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count = card->qdio.init_pool.buf_count; 10434a71df50SFrank Blaschka INIT_LIST_HEAD(&card->qdio.in_buf_pool.entry_list); 10444a71df50SFrank Blaschka INIT_LIST_HEAD(&card->qdio.init_pool.entry_list); 10454a71df50SFrank Blaschka } 10464a71df50SFrank Blaschka 10474a71df50SFrank Blaschka static void qeth_set_intial_options(struct qeth_card *card) 10484a71df50SFrank Blaschka { 10494a71df50SFrank Blaschka card->options.route4.type = NO_ROUTER; 10504a71df50SFrank Blaschka card->options.route6.type = NO_ROUTER; 10514a71df50SFrank Blaschka card->options.checksum_type = QETH_CHECKSUM_DEFAULT; 10524a71df50SFrank Blaschka card->options.broadcast_mode = QETH_TR_BROADCAST_ALLRINGS; 10534a71df50SFrank Blaschka card->options.macaddr_mode = QETH_TR_MACADDR_NONCANONICAL; 10544a71df50SFrank Blaschka card->options.fake_broadcast = 0; 10554a71df50SFrank Blaschka card->options.add_hhlen = DEFAULT_ADD_HHLEN; 10564a71df50SFrank Blaschka card->options.fake_ll = 0; 10574a71df50SFrank Blaschka card->options.performance_stats = 0; 10584a71df50SFrank Blaschka card->options.rx_sg_cb = QETH_RX_SG_CB; 10594a71df50SFrank Blaschka } 10604a71df50SFrank Blaschka 10614a71df50SFrank Blaschka static int qeth_do_start_thread(struct qeth_card *card, unsigned long thread) 10624a71df50SFrank Blaschka { 10634a71df50SFrank Blaschka unsigned long flags; 10644a71df50SFrank Blaschka int rc = 0; 10654a71df50SFrank Blaschka 10664a71df50SFrank Blaschka spin_lock_irqsave(&card->thread_mask_lock, flags); 1067d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, " %02x%02x%02x", 10684a71df50SFrank Blaschka (u8) card->thread_start_mask, 10694a71df50SFrank Blaschka (u8) card->thread_allowed_mask, 10704a71df50SFrank Blaschka (u8) card->thread_running_mask); 10714a71df50SFrank Blaschka rc = (card->thread_start_mask & thread); 10724a71df50SFrank Blaschka spin_unlock_irqrestore(&card->thread_mask_lock, flags); 10734a71df50SFrank Blaschka return rc; 10744a71df50SFrank Blaschka } 10754a71df50SFrank Blaschka 10764a71df50SFrank Blaschka static void qeth_start_kernel_thread(struct work_struct *work) 10774a71df50SFrank Blaschka { 10784a71df50SFrank Blaschka struct qeth_card *card = container_of(work, struct qeth_card, 10794a71df50SFrank Blaschka kernel_thread_starter); 1080d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE , 2, "strthrd"); 10814a71df50SFrank Blaschka 10824a71df50SFrank Blaschka if (card->read.state != CH_STATE_UP && 10834a71df50SFrank Blaschka card->write.state != CH_STATE_UP) 10844a71df50SFrank Blaschka return; 10854a71df50SFrank Blaschka if (qeth_do_start_thread(card, QETH_RECOVER_THREAD)) 10864a71df50SFrank Blaschka kthread_run(card->discipline.recover, (void *) card, 10874a71df50SFrank Blaschka "qeth_recover"); 10884a71df50SFrank Blaschka } 10894a71df50SFrank Blaschka 10904a71df50SFrank Blaschka static int qeth_setup_card(struct qeth_card *card) 10914a71df50SFrank Blaschka { 10924a71df50SFrank Blaschka 1093d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "setupcrd"); 1094d11ba0c4SPeter Tiedemann QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 10954a71df50SFrank Blaschka 10964a71df50SFrank Blaschka card->read.state = CH_STATE_DOWN; 10974a71df50SFrank Blaschka card->write.state = CH_STATE_DOWN; 10984a71df50SFrank Blaschka card->data.state = CH_STATE_DOWN; 10994a71df50SFrank Blaschka card->state = CARD_STATE_DOWN; 11004a71df50SFrank Blaschka card->lan_online = 0; 11014a71df50SFrank Blaschka card->use_hard_stop = 0; 11024a71df50SFrank Blaschka card->dev = NULL; 11034a71df50SFrank Blaschka spin_lock_init(&card->vlanlock); 11044a71df50SFrank Blaschka spin_lock_init(&card->mclock); 11054a71df50SFrank Blaschka card->vlangrp = NULL; 11064a71df50SFrank Blaschka spin_lock_init(&card->lock); 11074a71df50SFrank Blaschka spin_lock_init(&card->ip_lock); 11084a71df50SFrank Blaschka spin_lock_init(&card->thread_mask_lock); 11094a71df50SFrank Blaschka card->thread_start_mask = 0; 11104a71df50SFrank Blaschka card->thread_allowed_mask = 0; 11114a71df50SFrank Blaschka card->thread_running_mask = 0; 11124a71df50SFrank Blaschka INIT_WORK(&card->kernel_thread_starter, qeth_start_kernel_thread); 11134a71df50SFrank Blaschka INIT_LIST_HEAD(&card->ip_list); 11144a71df50SFrank Blaschka card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_KERNEL); 11154a71df50SFrank Blaschka if (!card->ip_tbd_list) { 1116d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 0, "iptbdnom"); 11174a71df50SFrank Blaschka return -ENOMEM; 11184a71df50SFrank Blaschka } 11194a71df50SFrank Blaschka INIT_LIST_HEAD(card->ip_tbd_list); 11204a71df50SFrank Blaschka INIT_LIST_HEAD(&card->cmd_waiter_list); 11214a71df50SFrank Blaschka init_waitqueue_head(&card->wait_q); 11224a71df50SFrank Blaschka /* intial options */ 11234a71df50SFrank Blaschka qeth_set_intial_options(card); 11244a71df50SFrank Blaschka /* IP address takeover */ 11254a71df50SFrank Blaschka INIT_LIST_HEAD(&card->ipato.entries); 11264a71df50SFrank Blaschka card->ipato.enabled = 0; 11274a71df50SFrank Blaschka card->ipato.invert4 = 0; 11284a71df50SFrank Blaschka card->ipato.invert6 = 0; 11294a71df50SFrank Blaschka /* init QDIO stuff */ 11304a71df50SFrank Blaschka qeth_init_qdio_info(card); 11314a71df50SFrank Blaschka return 0; 11324a71df50SFrank Blaschka } 11334a71df50SFrank Blaschka 11344a71df50SFrank Blaschka static struct qeth_card *qeth_alloc_card(void) 11354a71df50SFrank Blaschka { 11364a71df50SFrank Blaschka struct qeth_card *card; 11374a71df50SFrank Blaschka 1138d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "alloccrd"); 11394a71df50SFrank Blaschka card = kzalloc(sizeof(struct qeth_card), GFP_DMA|GFP_KERNEL); 11404a71df50SFrank Blaschka if (!card) 11414a71df50SFrank Blaschka return NULL; 1142d11ba0c4SPeter Tiedemann QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 11434a71df50SFrank Blaschka if (qeth_setup_channel(&card->read)) { 11444a71df50SFrank Blaschka kfree(card); 11454a71df50SFrank Blaschka return NULL; 11464a71df50SFrank Blaschka } 11474a71df50SFrank Blaschka if (qeth_setup_channel(&card->write)) { 11484a71df50SFrank Blaschka qeth_clean_channel(&card->read); 11494a71df50SFrank Blaschka kfree(card); 11504a71df50SFrank Blaschka return NULL; 11514a71df50SFrank Blaschka } 11524a71df50SFrank Blaschka card->options.layer2 = -1; 11534a71df50SFrank Blaschka return card; 11544a71df50SFrank Blaschka } 11554a71df50SFrank Blaschka 11564a71df50SFrank Blaschka static int qeth_determine_card_type(struct qeth_card *card) 11574a71df50SFrank Blaschka { 11584a71df50SFrank Blaschka int i = 0; 11594a71df50SFrank Blaschka 1160d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "detcdtyp"); 11614a71df50SFrank Blaschka 11624a71df50SFrank Blaschka card->qdio.do_prio_queueing = QETH_PRIOQ_DEFAULT; 11634a71df50SFrank Blaschka card->qdio.default_out_queue = QETH_DEFAULT_QUEUE; 11644a71df50SFrank Blaschka while (known_devices[i][4]) { 11654a71df50SFrank Blaschka if ((CARD_RDEV(card)->id.dev_type == known_devices[i][2]) && 11664a71df50SFrank Blaschka (CARD_RDEV(card)->id.dev_model == known_devices[i][3])) { 11674a71df50SFrank Blaschka card->info.type = known_devices[i][4]; 11684a71df50SFrank Blaschka card->qdio.no_out_queues = known_devices[i][8]; 11694a71df50SFrank Blaschka card->info.is_multicast_different = known_devices[i][9]; 11704a71df50SFrank Blaschka if (qeth_is_1920_device(card)) { 11714a71df50SFrank Blaschka PRINT_INFO("Priority Queueing not able " 11724a71df50SFrank Blaschka "due to hardware limitations!\n"); 11734a71df50SFrank Blaschka card->qdio.no_out_queues = 1; 11744a71df50SFrank Blaschka card->qdio.default_out_queue = 0; 11754a71df50SFrank Blaschka } 11764a71df50SFrank Blaschka return 0; 11774a71df50SFrank Blaschka } 11784a71df50SFrank Blaschka i++; 11794a71df50SFrank Blaschka } 11804a71df50SFrank Blaschka card->info.type = QETH_CARD_TYPE_UNKNOWN; 11814a71df50SFrank Blaschka PRINT_ERR("unknown card type on device %s\n", CARD_BUS_ID(card)); 11824a71df50SFrank Blaschka return -ENOENT; 11834a71df50SFrank Blaschka } 11844a71df50SFrank Blaschka 11854a71df50SFrank Blaschka static int qeth_clear_channel(struct qeth_channel *channel) 11864a71df50SFrank Blaschka { 11874a71df50SFrank Blaschka unsigned long flags; 11884a71df50SFrank Blaschka struct qeth_card *card; 11894a71df50SFrank Blaschka int rc; 11904a71df50SFrank Blaschka 1191d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "clearch"); 11924a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 11934a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 11944a71df50SFrank Blaschka rc = ccw_device_clear(channel->ccwdev, QETH_CLEAR_CHANNEL_PARM); 11954a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 11964a71df50SFrank Blaschka 11974a71df50SFrank Blaschka if (rc) 11984a71df50SFrank Blaschka return rc; 11994a71df50SFrank Blaschka rc = wait_event_interruptible_timeout(card->wait_q, 12004a71df50SFrank Blaschka channel->state == CH_STATE_STOPPED, QETH_TIMEOUT); 12014a71df50SFrank Blaschka if (rc == -ERESTARTSYS) 12024a71df50SFrank Blaschka return rc; 12034a71df50SFrank Blaschka if (channel->state != CH_STATE_STOPPED) 12044a71df50SFrank Blaschka return -ETIME; 12054a71df50SFrank Blaschka channel->state = CH_STATE_DOWN; 12064a71df50SFrank Blaschka return 0; 12074a71df50SFrank Blaschka } 12084a71df50SFrank Blaschka 12094a71df50SFrank Blaschka static int qeth_halt_channel(struct qeth_channel *channel) 12104a71df50SFrank Blaschka { 12114a71df50SFrank Blaschka unsigned long flags; 12124a71df50SFrank Blaschka struct qeth_card *card; 12134a71df50SFrank Blaschka int rc; 12144a71df50SFrank Blaschka 1215d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "haltch"); 12164a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 12174a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 12184a71df50SFrank Blaschka rc = ccw_device_halt(channel->ccwdev, QETH_HALT_CHANNEL_PARM); 12194a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 12204a71df50SFrank Blaschka 12214a71df50SFrank Blaschka if (rc) 12224a71df50SFrank Blaschka return rc; 12234a71df50SFrank Blaschka rc = wait_event_interruptible_timeout(card->wait_q, 12244a71df50SFrank Blaschka channel->state == CH_STATE_HALTED, QETH_TIMEOUT); 12254a71df50SFrank Blaschka if (rc == -ERESTARTSYS) 12264a71df50SFrank Blaschka return rc; 12274a71df50SFrank Blaschka if (channel->state != CH_STATE_HALTED) 12284a71df50SFrank Blaschka return -ETIME; 12294a71df50SFrank Blaschka return 0; 12304a71df50SFrank Blaschka } 12314a71df50SFrank Blaschka 12324a71df50SFrank Blaschka static int qeth_halt_channels(struct qeth_card *card) 12334a71df50SFrank Blaschka { 12344a71df50SFrank Blaschka int rc1 = 0, rc2 = 0, rc3 = 0; 12354a71df50SFrank Blaschka 1236d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "haltchs"); 12374a71df50SFrank Blaschka rc1 = qeth_halt_channel(&card->read); 12384a71df50SFrank Blaschka rc2 = qeth_halt_channel(&card->write); 12394a71df50SFrank Blaschka rc3 = qeth_halt_channel(&card->data); 12404a71df50SFrank Blaschka if (rc1) 12414a71df50SFrank Blaschka return rc1; 12424a71df50SFrank Blaschka if (rc2) 12434a71df50SFrank Blaschka return rc2; 12444a71df50SFrank Blaschka return rc3; 12454a71df50SFrank Blaschka } 12464a71df50SFrank Blaschka 12474a71df50SFrank Blaschka static int qeth_clear_channels(struct qeth_card *card) 12484a71df50SFrank Blaschka { 12494a71df50SFrank Blaschka int rc1 = 0, rc2 = 0, rc3 = 0; 12504a71df50SFrank Blaschka 1251d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "clearchs"); 12524a71df50SFrank Blaschka rc1 = qeth_clear_channel(&card->read); 12534a71df50SFrank Blaschka rc2 = qeth_clear_channel(&card->write); 12544a71df50SFrank Blaschka rc3 = qeth_clear_channel(&card->data); 12554a71df50SFrank Blaschka if (rc1) 12564a71df50SFrank Blaschka return rc1; 12574a71df50SFrank Blaschka if (rc2) 12584a71df50SFrank Blaschka return rc2; 12594a71df50SFrank Blaschka return rc3; 12604a71df50SFrank Blaschka } 12614a71df50SFrank Blaschka 12624a71df50SFrank Blaschka static int qeth_clear_halt_card(struct qeth_card *card, int halt) 12634a71df50SFrank Blaschka { 12644a71df50SFrank Blaschka int rc = 0; 12654a71df50SFrank Blaschka 1266d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "clhacrd"); 1267d11ba0c4SPeter Tiedemann QETH_DBF_HEX(TRACE, 3, &card, sizeof(void *)); 12684a71df50SFrank Blaschka 12694a71df50SFrank Blaschka if (halt) 12704a71df50SFrank Blaschka rc = qeth_halt_channels(card); 12714a71df50SFrank Blaschka if (rc) 12724a71df50SFrank Blaschka return rc; 12734a71df50SFrank Blaschka return qeth_clear_channels(card); 12744a71df50SFrank Blaschka } 12754a71df50SFrank Blaschka 12764a71df50SFrank Blaschka int qeth_qdio_clear_card(struct qeth_card *card, int use_halt) 12774a71df50SFrank Blaschka { 12784a71df50SFrank Blaschka int rc = 0; 12794a71df50SFrank Blaschka 1280d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "qdioclr"); 12814a71df50SFrank Blaschka switch (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ESTABLISHED, 12824a71df50SFrank Blaschka QETH_QDIO_CLEANING)) { 12834a71df50SFrank Blaschka case QETH_QDIO_ESTABLISHED: 12844a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_IQD) 12854a71df50SFrank Blaschka rc = qdio_cleanup(CARD_DDEV(card), 12864a71df50SFrank Blaschka QDIO_FLAG_CLEANUP_USING_HALT); 12874a71df50SFrank Blaschka else 12884a71df50SFrank Blaschka rc = qdio_cleanup(CARD_DDEV(card), 12894a71df50SFrank Blaschka QDIO_FLAG_CLEANUP_USING_CLEAR); 12904a71df50SFrank Blaschka if (rc) 1291d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 3, "1err%d", rc); 12924a71df50SFrank Blaschka atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED); 12934a71df50SFrank Blaschka break; 12944a71df50SFrank Blaschka case QETH_QDIO_CLEANING: 12954a71df50SFrank Blaschka return rc; 12964a71df50SFrank Blaschka default: 12974a71df50SFrank Blaschka break; 12984a71df50SFrank Blaschka } 12994a71df50SFrank Blaschka rc = qeth_clear_halt_card(card, use_halt); 13004a71df50SFrank Blaschka if (rc) 1301d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 3, "2err%d", rc); 13024a71df50SFrank Blaschka card->state = CARD_STATE_DOWN; 13034a71df50SFrank Blaschka return rc; 13044a71df50SFrank Blaschka } 13054a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_qdio_clear_card); 13064a71df50SFrank Blaschka 13074a71df50SFrank Blaschka static int qeth_read_conf_data(struct qeth_card *card, void **buffer, 13084a71df50SFrank Blaschka int *length) 13094a71df50SFrank Blaschka { 13104a71df50SFrank Blaschka struct ciw *ciw; 13114a71df50SFrank Blaschka char *rcd_buf; 13124a71df50SFrank Blaschka int ret; 13134a71df50SFrank Blaschka struct qeth_channel *channel = &card->data; 13144a71df50SFrank Blaschka unsigned long flags; 13154a71df50SFrank Blaschka 13164a71df50SFrank Blaschka /* 13174a71df50SFrank Blaschka * scan for RCD command in extended SenseID data 13184a71df50SFrank Blaschka */ 13194a71df50SFrank Blaschka ciw = ccw_device_get_ciw(channel->ccwdev, CIW_TYPE_RCD); 13204a71df50SFrank Blaschka if (!ciw || ciw->cmd == 0) 13214a71df50SFrank Blaschka return -EOPNOTSUPP; 13224a71df50SFrank Blaschka rcd_buf = kzalloc(ciw->count, GFP_KERNEL | GFP_DMA); 13234a71df50SFrank Blaschka if (!rcd_buf) 13244a71df50SFrank Blaschka return -ENOMEM; 13254a71df50SFrank Blaschka 13264a71df50SFrank Blaschka channel->ccw.cmd_code = ciw->cmd; 13274a71df50SFrank Blaschka channel->ccw.cda = (__u32) __pa(rcd_buf); 13284a71df50SFrank Blaschka channel->ccw.count = ciw->count; 13294a71df50SFrank Blaschka channel->ccw.flags = CCW_FLAG_SLI; 13304a71df50SFrank Blaschka channel->state = CH_STATE_RCD; 13314a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 13324a71df50SFrank Blaschka ret = ccw_device_start_timeout(channel->ccwdev, &channel->ccw, 13334a71df50SFrank Blaschka QETH_RCD_PARM, LPM_ANYPATH, 0, 13344a71df50SFrank Blaschka QETH_RCD_TIMEOUT); 13354a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 13364a71df50SFrank Blaschka if (!ret) 13374a71df50SFrank Blaschka wait_event(card->wait_q, 13384a71df50SFrank Blaschka (channel->state == CH_STATE_RCD_DONE || 13394a71df50SFrank Blaschka channel->state == CH_STATE_DOWN)); 13404a71df50SFrank Blaschka if (channel->state == CH_STATE_DOWN) 13414a71df50SFrank Blaschka ret = -EIO; 13424a71df50SFrank Blaschka else 13434a71df50SFrank Blaschka channel->state = CH_STATE_DOWN; 13444a71df50SFrank Blaschka if (ret) { 13454a71df50SFrank Blaschka kfree(rcd_buf); 13464a71df50SFrank Blaschka *buffer = NULL; 13474a71df50SFrank Blaschka *length = 0; 13484a71df50SFrank Blaschka } else { 13494a71df50SFrank Blaschka *length = ciw->count; 13504a71df50SFrank Blaschka *buffer = rcd_buf; 13514a71df50SFrank Blaschka } 13524a71df50SFrank Blaschka return ret; 13534a71df50SFrank Blaschka } 13544a71df50SFrank Blaschka 13554a71df50SFrank Blaschka static int qeth_get_unitaddr(struct qeth_card *card) 13564a71df50SFrank Blaschka { 13574a71df50SFrank Blaschka int length; 13584a71df50SFrank Blaschka char *prcd; 13594a71df50SFrank Blaschka int rc; 13604a71df50SFrank Blaschka 1361d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "getunit"); 13624a71df50SFrank Blaschka rc = qeth_read_conf_data(card, (void **) &prcd, &length); 13634a71df50SFrank Blaschka if (rc) { 13644a71df50SFrank Blaschka PRINT_ERR("qeth_read_conf_data for device %s returned %i\n", 13654a71df50SFrank Blaschka CARD_DDEV_ID(card), rc); 13664a71df50SFrank Blaschka return rc; 13674a71df50SFrank Blaschka } 13684a71df50SFrank Blaschka card->info.chpid = prcd[30]; 13694a71df50SFrank Blaschka card->info.unit_addr2 = prcd[31]; 13704a71df50SFrank Blaschka card->info.cula = prcd[63]; 13714a71df50SFrank Blaschka card->info.guestlan = ((prcd[0x10] == _ascebc['V']) && 13724a71df50SFrank Blaschka (prcd[0x11] == _ascebc['M'])); 13734a71df50SFrank Blaschka kfree(prcd); 13744a71df50SFrank Blaschka return 0; 13754a71df50SFrank Blaschka } 13764a71df50SFrank Blaschka 13774a71df50SFrank Blaschka static void qeth_init_tokens(struct qeth_card *card) 13784a71df50SFrank Blaschka { 13794a71df50SFrank Blaschka card->token.issuer_rm_w = 0x00010103UL; 13804a71df50SFrank Blaschka card->token.cm_filter_w = 0x00010108UL; 13814a71df50SFrank Blaschka card->token.cm_connection_w = 0x0001010aUL; 13824a71df50SFrank Blaschka card->token.ulp_filter_w = 0x0001010bUL; 13834a71df50SFrank Blaschka card->token.ulp_connection_w = 0x0001010dUL; 13844a71df50SFrank Blaschka } 13854a71df50SFrank Blaschka 13864a71df50SFrank Blaschka static void qeth_init_func_level(struct qeth_card *card) 13874a71df50SFrank Blaschka { 13884a71df50SFrank Blaschka if (card->ipato.enabled) { 13894a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_IQD) 13904a71df50SFrank Blaschka card->info.func_level = 13914a71df50SFrank Blaschka QETH_IDX_FUNC_LEVEL_IQD_ENA_IPAT; 13924a71df50SFrank Blaschka else 13934a71df50SFrank Blaschka card->info.func_level = 13944a71df50SFrank Blaschka QETH_IDX_FUNC_LEVEL_OSAE_ENA_IPAT; 13954a71df50SFrank Blaschka } else { 13964a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_IQD) 13974a71df50SFrank Blaschka /*FIXME:why do we have same values for dis and ena for 13984a71df50SFrank Blaschka osae??? */ 13994a71df50SFrank Blaschka card->info.func_level = 14004a71df50SFrank Blaschka QETH_IDX_FUNC_LEVEL_IQD_DIS_IPAT; 14014a71df50SFrank Blaschka else 14024a71df50SFrank Blaschka card->info.func_level = 14034a71df50SFrank Blaschka QETH_IDX_FUNC_LEVEL_OSAE_DIS_IPAT; 14044a71df50SFrank Blaschka } 14054a71df50SFrank Blaschka } 14064a71df50SFrank Blaschka 14074a71df50SFrank Blaschka static int qeth_idx_activate_get_answer(struct qeth_channel *channel, 14084a71df50SFrank Blaschka void (*idx_reply_cb)(struct qeth_channel *, 14094a71df50SFrank Blaschka struct qeth_cmd_buffer *)) 14104a71df50SFrank Blaschka { 14114a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 14124a71df50SFrank Blaschka unsigned long flags; 14134a71df50SFrank Blaschka int rc; 14144a71df50SFrank Blaschka struct qeth_card *card; 14154a71df50SFrank Blaschka 1416d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "idxanswr"); 14174a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 14184a71df50SFrank Blaschka iob = qeth_get_buffer(channel); 14194a71df50SFrank Blaschka iob->callback = idx_reply_cb; 14204a71df50SFrank Blaschka memcpy(&channel->ccw, READ_CCW, sizeof(struct ccw1)); 14214a71df50SFrank Blaschka channel->ccw.count = QETH_BUFSIZE; 14224a71df50SFrank Blaschka channel->ccw.cda = (__u32) __pa(iob->data); 14234a71df50SFrank Blaschka 14244a71df50SFrank Blaschka wait_event(card->wait_q, 14254a71df50SFrank Blaschka atomic_cmpxchg(&channel->irq_pending, 0, 1) == 0); 1426d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 6, "noirqpnd"); 14274a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 14284a71df50SFrank Blaschka rc = ccw_device_start(channel->ccwdev, 14294a71df50SFrank Blaschka &channel->ccw, (addr_t) iob, 0, 0); 14304a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 14314a71df50SFrank Blaschka 14324a71df50SFrank Blaschka if (rc) { 143314cc21b6SFrank Blaschka QETH_DBF_MESSAGE(2, "Error2 in activating channel rc=%d\n", rc); 1434d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 14354a71df50SFrank Blaschka atomic_set(&channel->irq_pending, 0); 14364a71df50SFrank Blaschka wake_up(&card->wait_q); 14374a71df50SFrank Blaschka return rc; 14384a71df50SFrank Blaschka } 14394a71df50SFrank Blaschka rc = wait_event_interruptible_timeout(card->wait_q, 14404a71df50SFrank Blaschka channel->state == CH_STATE_UP, QETH_TIMEOUT); 14414a71df50SFrank Blaschka if (rc == -ERESTARTSYS) 14424a71df50SFrank Blaschka return rc; 14434a71df50SFrank Blaschka if (channel->state != CH_STATE_UP) { 14444a71df50SFrank Blaschka rc = -ETIME; 1445d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 14464a71df50SFrank Blaschka qeth_clear_cmd_buffers(channel); 14474a71df50SFrank Blaschka } else 14484a71df50SFrank Blaschka rc = 0; 14494a71df50SFrank Blaschka return rc; 14504a71df50SFrank Blaschka } 14514a71df50SFrank Blaschka 14524a71df50SFrank Blaschka static int qeth_idx_activate_channel(struct qeth_channel *channel, 14534a71df50SFrank Blaschka void (*idx_reply_cb)(struct qeth_channel *, 14544a71df50SFrank Blaschka struct qeth_cmd_buffer *)) 14554a71df50SFrank Blaschka { 14564a71df50SFrank Blaschka struct qeth_card *card; 14574a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 14584a71df50SFrank Blaschka unsigned long flags; 14594a71df50SFrank Blaschka __u16 temp; 14604a71df50SFrank Blaschka __u8 tmp; 14614a71df50SFrank Blaschka int rc; 1462f06f6f32SCornelia Huck struct ccw_dev_id temp_devid; 14634a71df50SFrank Blaschka 14644a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 14654a71df50SFrank Blaschka 1466d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "idxactch"); 14674a71df50SFrank Blaschka 14684a71df50SFrank Blaschka iob = qeth_get_buffer(channel); 14694a71df50SFrank Blaschka iob->callback = idx_reply_cb; 14704a71df50SFrank Blaschka memcpy(&channel->ccw, WRITE_CCW, sizeof(struct ccw1)); 14714a71df50SFrank Blaschka channel->ccw.count = IDX_ACTIVATE_SIZE; 14724a71df50SFrank Blaschka channel->ccw.cda = (__u32) __pa(iob->data); 14734a71df50SFrank Blaschka if (channel == &card->write) { 14744a71df50SFrank Blaschka memcpy(iob->data, IDX_ACTIVATE_WRITE, IDX_ACTIVATE_SIZE); 14754a71df50SFrank Blaschka memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 14764a71df50SFrank Blaschka &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 14774a71df50SFrank Blaschka card->seqno.trans_hdr++; 14784a71df50SFrank Blaschka } else { 14794a71df50SFrank Blaschka memcpy(iob->data, IDX_ACTIVATE_READ, IDX_ACTIVATE_SIZE); 14804a71df50SFrank Blaschka memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 14814a71df50SFrank Blaschka &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 14824a71df50SFrank Blaschka } 14834a71df50SFrank Blaschka tmp = ((__u8)card->info.portno) | 0x80; 14844a71df50SFrank Blaschka memcpy(QETH_IDX_ACT_PNO(iob->data), &tmp, 1); 14854a71df50SFrank Blaschka memcpy(QETH_IDX_ACT_ISSUER_RM_TOKEN(iob->data), 14864a71df50SFrank Blaschka &card->token.issuer_rm_w, QETH_MPC_TOKEN_LENGTH); 14874a71df50SFrank Blaschka memcpy(QETH_IDX_ACT_FUNC_LEVEL(iob->data), 14884a71df50SFrank Blaschka &card->info.func_level, sizeof(__u16)); 1489f06f6f32SCornelia Huck ccw_device_get_id(CARD_DDEV(card), &temp_devid); 1490f06f6f32SCornelia Huck memcpy(QETH_IDX_ACT_QDIO_DEV_CUA(iob->data), &temp_devid.devno, 2); 14914a71df50SFrank Blaschka temp = (card->info.cula << 8) + card->info.unit_addr2; 14924a71df50SFrank Blaschka memcpy(QETH_IDX_ACT_QDIO_DEV_REALADDR(iob->data), &temp, 2); 14934a71df50SFrank Blaschka 14944a71df50SFrank Blaschka wait_event(card->wait_q, 14954a71df50SFrank Blaschka atomic_cmpxchg(&channel->irq_pending, 0, 1) == 0); 1496d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 6, "noirqpnd"); 14974a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(channel->ccwdev), flags); 14984a71df50SFrank Blaschka rc = ccw_device_start(channel->ccwdev, 14994a71df50SFrank Blaschka &channel->ccw, (addr_t) iob, 0, 0); 15004a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(channel->ccwdev), flags); 15014a71df50SFrank Blaschka 15024a71df50SFrank Blaschka if (rc) { 150314cc21b6SFrank Blaschka QETH_DBF_MESSAGE(2, "Error1 in activating channel. rc=%d\n", 150414cc21b6SFrank Blaschka rc); 1505d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 15064a71df50SFrank Blaschka atomic_set(&channel->irq_pending, 0); 15074a71df50SFrank Blaschka wake_up(&card->wait_q); 15084a71df50SFrank Blaschka return rc; 15094a71df50SFrank Blaschka } 15104a71df50SFrank Blaschka rc = wait_event_interruptible_timeout(card->wait_q, 15114a71df50SFrank Blaschka channel->state == CH_STATE_ACTIVATING, QETH_TIMEOUT); 15124a71df50SFrank Blaschka if (rc == -ERESTARTSYS) 15134a71df50SFrank Blaschka return rc; 15144a71df50SFrank Blaschka if (channel->state != CH_STATE_ACTIVATING) { 15154a71df50SFrank Blaschka PRINT_WARN("IDX activate timed out!\n"); 1516d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", -ETIME); 15174a71df50SFrank Blaschka qeth_clear_cmd_buffers(channel); 15184a71df50SFrank Blaschka return -ETIME; 15194a71df50SFrank Blaschka } 15204a71df50SFrank Blaschka return qeth_idx_activate_get_answer(channel, idx_reply_cb); 15214a71df50SFrank Blaschka } 15224a71df50SFrank Blaschka 15234a71df50SFrank Blaschka static int qeth_peer_func_level(int level) 15244a71df50SFrank Blaschka { 15254a71df50SFrank Blaschka if ((level & 0xff) == 8) 15264a71df50SFrank Blaschka return (level & 0xff) + 0x400; 15274a71df50SFrank Blaschka if (((level >> 8) & 3) == 1) 15284a71df50SFrank Blaschka return (level & 0xff) + 0x200; 15294a71df50SFrank Blaschka return level; 15304a71df50SFrank Blaschka } 15314a71df50SFrank Blaschka 15324a71df50SFrank Blaschka static void qeth_idx_write_cb(struct qeth_channel *channel, 15334a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 15344a71df50SFrank Blaschka { 15354a71df50SFrank Blaschka struct qeth_card *card; 15364a71df50SFrank Blaschka __u16 temp; 15374a71df50SFrank Blaschka 1538d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP , 2, "idxwrcb"); 15394a71df50SFrank Blaschka 15404a71df50SFrank Blaschka if (channel->state == CH_STATE_DOWN) { 15414a71df50SFrank Blaschka channel->state = CH_STATE_ACTIVATING; 15424a71df50SFrank Blaschka goto out; 15434a71df50SFrank Blaschka } 15444a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 15454a71df50SFrank Blaschka 15464a71df50SFrank Blaschka if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) { 15474a71df50SFrank Blaschka if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19) 15484a71df50SFrank Blaschka PRINT_ERR("IDX_ACTIVATE on write channel device %s: " 15494a71df50SFrank Blaschka "adapter exclusively used by another host\n", 15504a71df50SFrank Blaschka CARD_WDEV_ID(card)); 15514a71df50SFrank Blaschka else 15524a71df50SFrank Blaschka PRINT_ERR("IDX_ACTIVATE on write channel device %s: " 15534a71df50SFrank Blaschka "negative reply\n", CARD_WDEV_ID(card)); 15544a71df50SFrank Blaschka goto out; 15554a71df50SFrank Blaschka } 15564a71df50SFrank Blaschka memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2); 15574a71df50SFrank Blaschka if ((temp & ~0x0100) != qeth_peer_func_level(card->info.func_level)) { 15584a71df50SFrank Blaschka PRINT_WARN("IDX_ACTIVATE on write channel device %s: " 15594a71df50SFrank Blaschka "function level mismatch " 15604a71df50SFrank Blaschka "(sent: 0x%x, received: 0x%x)\n", 15614a71df50SFrank Blaschka CARD_WDEV_ID(card), card->info.func_level, temp); 15624a71df50SFrank Blaschka goto out; 15634a71df50SFrank Blaschka } 15644a71df50SFrank Blaschka channel->state = CH_STATE_UP; 15654a71df50SFrank Blaschka out: 15664a71df50SFrank Blaschka qeth_release_buffer(channel, iob); 15674a71df50SFrank Blaschka } 15684a71df50SFrank Blaschka 15694a71df50SFrank Blaschka static void qeth_idx_read_cb(struct qeth_channel *channel, 15704a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 15714a71df50SFrank Blaschka { 15724a71df50SFrank Blaschka struct qeth_card *card; 15734a71df50SFrank Blaschka __u16 temp; 15744a71df50SFrank Blaschka 1575d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP , 2, "idxrdcb"); 15764a71df50SFrank Blaschka if (channel->state == CH_STATE_DOWN) { 15774a71df50SFrank Blaschka channel->state = CH_STATE_ACTIVATING; 15784a71df50SFrank Blaschka goto out; 15794a71df50SFrank Blaschka } 15804a71df50SFrank Blaschka 15814a71df50SFrank Blaschka card = CARD_FROM_CDEV(channel->ccwdev); 15824a71df50SFrank Blaschka if (qeth_check_idx_response(iob->data)) 15834a71df50SFrank Blaschka goto out; 15844a71df50SFrank Blaschka 15854a71df50SFrank Blaschka if (!(QETH_IS_IDX_ACT_POS_REPLY(iob->data))) { 15864a71df50SFrank Blaschka if (QETH_IDX_ACT_CAUSE_CODE(iob->data) == 0x19) 15874a71df50SFrank Blaschka PRINT_ERR("IDX_ACTIVATE on read channel device %s: " 15884a71df50SFrank Blaschka "adapter exclusively used by another host\n", 15894a71df50SFrank Blaschka CARD_RDEV_ID(card)); 15904a71df50SFrank Blaschka else 15914a71df50SFrank Blaschka PRINT_ERR("IDX_ACTIVATE on read channel device %s: " 15924a71df50SFrank Blaschka "negative reply\n", CARD_RDEV_ID(card)); 15934a71df50SFrank Blaschka goto out; 15944a71df50SFrank Blaschka } 15954a71df50SFrank Blaschka 15964a71df50SFrank Blaschka /** 15974a71df50SFrank Blaschka * temporary fix for microcode bug 15984a71df50SFrank Blaschka * to revert it,replace OR by AND 15994a71df50SFrank Blaschka */ 16004a71df50SFrank Blaschka if ((!QETH_IDX_NO_PORTNAME_REQUIRED(iob->data)) || 16014a71df50SFrank Blaschka (card->info.type == QETH_CARD_TYPE_OSAE)) 16024a71df50SFrank Blaschka card->info.portname_required = 1; 16034a71df50SFrank Blaschka 16044a71df50SFrank Blaschka memcpy(&temp, QETH_IDX_ACT_FUNC_LEVEL(iob->data), 2); 16054a71df50SFrank Blaschka if (temp != qeth_peer_func_level(card->info.func_level)) { 16064a71df50SFrank Blaschka PRINT_WARN("IDX_ACTIVATE on read channel device %s: function " 16074a71df50SFrank Blaschka "level mismatch (sent: 0x%x, received: 0x%x)\n", 16084a71df50SFrank Blaschka CARD_RDEV_ID(card), card->info.func_level, temp); 16094a71df50SFrank Blaschka goto out; 16104a71df50SFrank Blaschka } 16114a71df50SFrank Blaschka memcpy(&card->token.issuer_rm_r, 16124a71df50SFrank Blaschka QETH_IDX_ACT_ISSUER_RM_TOKEN(iob->data), 16134a71df50SFrank Blaschka QETH_MPC_TOKEN_LENGTH); 16144a71df50SFrank Blaschka memcpy(&card->info.mcl_level[0], 16154a71df50SFrank Blaschka QETH_IDX_REPLY_LEVEL(iob->data), QETH_MCL_LENGTH); 16164a71df50SFrank Blaschka channel->state = CH_STATE_UP; 16174a71df50SFrank Blaschka out: 16184a71df50SFrank Blaschka qeth_release_buffer(channel, iob); 16194a71df50SFrank Blaschka } 16204a71df50SFrank Blaschka 16214a71df50SFrank Blaschka void qeth_prepare_control_data(struct qeth_card *card, int len, 16224a71df50SFrank Blaschka struct qeth_cmd_buffer *iob) 16234a71df50SFrank Blaschka { 16244a71df50SFrank Blaschka qeth_setup_ccw(&card->write, iob->data, len); 16254a71df50SFrank Blaschka iob->callback = qeth_release_buffer; 16264a71df50SFrank Blaschka 16274a71df50SFrank Blaschka memcpy(QETH_TRANSPORT_HEADER_SEQ_NO(iob->data), 16284a71df50SFrank Blaschka &card->seqno.trans_hdr, QETH_SEQ_NO_LENGTH); 16294a71df50SFrank Blaschka card->seqno.trans_hdr++; 16304a71df50SFrank Blaschka memcpy(QETH_PDU_HEADER_SEQ_NO(iob->data), 16314a71df50SFrank Blaschka &card->seqno.pdu_hdr, QETH_SEQ_NO_LENGTH); 16324a71df50SFrank Blaschka card->seqno.pdu_hdr++; 16334a71df50SFrank Blaschka memcpy(QETH_PDU_HEADER_ACK_SEQ_NO(iob->data), 16344a71df50SFrank Blaschka &card->seqno.pdu_hdr_ack, QETH_SEQ_NO_LENGTH); 1635d11ba0c4SPeter Tiedemann QETH_DBF_HEX(CTRL, 2, iob->data, QETH_DBF_CTRL_LEN); 16364a71df50SFrank Blaschka } 16374a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_prepare_control_data); 16384a71df50SFrank Blaschka 16394a71df50SFrank Blaschka int qeth_send_control_data(struct qeth_card *card, int len, 16404a71df50SFrank Blaschka struct qeth_cmd_buffer *iob, 16414a71df50SFrank Blaschka int (*reply_cb)(struct qeth_card *, struct qeth_reply *, 16424a71df50SFrank Blaschka unsigned long), 16434a71df50SFrank Blaschka void *reply_param) 16444a71df50SFrank Blaschka { 16454a71df50SFrank Blaschka int rc; 16464a71df50SFrank Blaschka unsigned long flags; 16474a71df50SFrank Blaschka struct qeth_reply *reply = NULL; 16484a71df50SFrank Blaschka unsigned long timeout; 16494a71df50SFrank Blaschka 1650d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "sendctl"); 16514a71df50SFrank Blaschka 16524a71df50SFrank Blaschka reply = qeth_alloc_reply(card); 16534a71df50SFrank Blaschka if (!reply) { 16544a71df50SFrank Blaschka return -ENOMEM; 16554a71df50SFrank Blaschka } 16564a71df50SFrank Blaschka reply->callback = reply_cb; 16574a71df50SFrank Blaschka reply->param = reply_param; 16584a71df50SFrank Blaschka if (card->state == CARD_STATE_DOWN) 16594a71df50SFrank Blaschka reply->seqno = QETH_IDX_COMMAND_SEQNO; 16604a71df50SFrank Blaschka else 16614a71df50SFrank Blaschka reply->seqno = card->seqno.ipa++; 16624a71df50SFrank Blaschka init_waitqueue_head(&reply->wait_q); 16634a71df50SFrank Blaschka spin_lock_irqsave(&card->lock, flags); 16644a71df50SFrank Blaschka list_add_tail(&reply->list, &card->cmd_waiter_list); 16654a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 1666d11ba0c4SPeter Tiedemann QETH_DBF_HEX(CTRL, 2, iob->data, QETH_DBF_CTRL_LEN); 16674a71df50SFrank Blaschka 16684a71df50SFrank Blaschka while (atomic_cmpxchg(&card->write.irq_pending, 0, 1)) ; 16694a71df50SFrank Blaschka qeth_prepare_control_data(card, len, iob); 16704a71df50SFrank Blaschka 16714a71df50SFrank Blaschka if (IS_IPA(iob->data)) 16724a71df50SFrank Blaschka timeout = jiffies + QETH_IPA_TIMEOUT; 16734a71df50SFrank Blaschka else 16744a71df50SFrank Blaschka timeout = jiffies + QETH_TIMEOUT; 16754a71df50SFrank Blaschka 1676d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "noirqpnd"); 16774a71df50SFrank Blaschka spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags); 16784a71df50SFrank Blaschka rc = ccw_device_start(card->write.ccwdev, &card->write.ccw, 16794a71df50SFrank Blaschka (addr_t) iob, 0, 0); 16804a71df50SFrank Blaschka spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags); 16814a71df50SFrank Blaschka if (rc) { 16824a71df50SFrank Blaschka PRINT_WARN("qeth_send_control_data: " 16834a71df50SFrank Blaschka "ccw_device_start rc = %i\n", rc); 1684d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, " err%d", rc); 16854a71df50SFrank Blaschka spin_lock_irqsave(&card->lock, flags); 16864a71df50SFrank Blaschka list_del_init(&reply->list); 16874a71df50SFrank Blaschka qeth_put_reply(reply); 16884a71df50SFrank Blaschka spin_unlock_irqrestore(&card->lock, flags); 16894a71df50SFrank Blaschka qeth_release_buffer(iob->channel, iob); 16904a71df50SFrank Blaschka atomic_set(&card->write.irq_pending, 0); 16914a71df50SFrank Blaschka wake_up(&card->wait_q); 16924a71df50SFrank Blaschka return rc; 16934a71df50SFrank Blaschka } 16944a71df50SFrank Blaschka while (!atomic_read(&reply->received)) { 16954a71df50SFrank Blaschka if (time_after(jiffies, timeout)) { 16964a71df50SFrank Blaschka spin_lock_irqsave(&reply->card->lock, flags); 16974a71df50SFrank Blaschka list_del_init(&reply->list); 16984a71df50SFrank Blaschka spin_unlock_irqrestore(&reply->card->lock, flags); 16994a71df50SFrank Blaschka reply->rc = -ETIME; 17004a71df50SFrank Blaschka atomic_inc(&reply->received); 17014a71df50SFrank Blaschka wake_up(&reply->wait_q); 17024a71df50SFrank Blaschka } 17034a71df50SFrank Blaschka cpu_relax(); 17044a71df50SFrank Blaschka }; 17054a71df50SFrank Blaschka rc = reply->rc; 17064a71df50SFrank Blaschka qeth_put_reply(reply); 17074a71df50SFrank Blaschka return rc; 17084a71df50SFrank Blaschka } 17094a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_send_control_data); 17104a71df50SFrank Blaschka 17114a71df50SFrank Blaschka static int qeth_cm_enable_cb(struct qeth_card *card, struct qeth_reply *reply, 17124a71df50SFrank Blaschka unsigned long data) 17134a71df50SFrank Blaschka { 17144a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 17154a71df50SFrank Blaschka 1716d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "cmenblcb"); 17174a71df50SFrank Blaschka 17184a71df50SFrank Blaschka iob = (struct qeth_cmd_buffer *) data; 17194a71df50SFrank Blaschka memcpy(&card->token.cm_filter_r, 17204a71df50SFrank Blaschka QETH_CM_ENABLE_RESP_FILTER_TOKEN(iob->data), 17214a71df50SFrank Blaschka QETH_MPC_TOKEN_LENGTH); 1722d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 17234a71df50SFrank Blaschka return 0; 17244a71df50SFrank Blaschka } 17254a71df50SFrank Blaschka 17264a71df50SFrank Blaschka static int qeth_cm_enable(struct qeth_card *card) 17274a71df50SFrank Blaschka { 17284a71df50SFrank Blaschka int rc; 17294a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 17304a71df50SFrank Blaschka 1731d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "cmenable"); 17324a71df50SFrank Blaschka 17334a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 17344a71df50SFrank Blaschka memcpy(iob->data, CM_ENABLE, CM_ENABLE_SIZE); 17354a71df50SFrank Blaschka memcpy(QETH_CM_ENABLE_ISSUER_RM_TOKEN(iob->data), 17364a71df50SFrank Blaschka &card->token.issuer_rm_r, QETH_MPC_TOKEN_LENGTH); 17374a71df50SFrank Blaschka memcpy(QETH_CM_ENABLE_FILTER_TOKEN(iob->data), 17384a71df50SFrank Blaschka &card->token.cm_filter_w, QETH_MPC_TOKEN_LENGTH); 17394a71df50SFrank Blaschka 17404a71df50SFrank Blaschka rc = qeth_send_control_data(card, CM_ENABLE_SIZE, iob, 17414a71df50SFrank Blaschka qeth_cm_enable_cb, NULL); 17424a71df50SFrank Blaschka return rc; 17434a71df50SFrank Blaschka } 17444a71df50SFrank Blaschka 17454a71df50SFrank Blaschka static int qeth_cm_setup_cb(struct qeth_card *card, struct qeth_reply *reply, 17464a71df50SFrank Blaschka unsigned long data) 17474a71df50SFrank Blaschka { 17484a71df50SFrank Blaschka 17494a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 17504a71df50SFrank Blaschka 1751d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "cmsetpcb"); 17524a71df50SFrank Blaschka 17534a71df50SFrank Blaschka iob = (struct qeth_cmd_buffer *) data; 17544a71df50SFrank Blaschka memcpy(&card->token.cm_connection_r, 17554a71df50SFrank Blaschka QETH_CM_SETUP_RESP_DEST_ADDR(iob->data), 17564a71df50SFrank Blaschka QETH_MPC_TOKEN_LENGTH); 1757d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 17584a71df50SFrank Blaschka return 0; 17594a71df50SFrank Blaschka } 17604a71df50SFrank Blaschka 17614a71df50SFrank Blaschka static int qeth_cm_setup(struct qeth_card *card) 17624a71df50SFrank Blaschka { 17634a71df50SFrank Blaschka int rc; 17644a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 17654a71df50SFrank Blaschka 1766d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "cmsetup"); 17674a71df50SFrank Blaschka 17684a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 17694a71df50SFrank Blaschka memcpy(iob->data, CM_SETUP, CM_SETUP_SIZE); 17704a71df50SFrank Blaschka memcpy(QETH_CM_SETUP_DEST_ADDR(iob->data), 17714a71df50SFrank Blaschka &card->token.issuer_rm_r, QETH_MPC_TOKEN_LENGTH); 17724a71df50SFrank Blaschka memcpy(QETH_CM_SETUP_CONNECTION_TOKEN(iob->data), 17734a71df50SFrank Blaschka &card->token.cm_connection_w, QETH_MPC_TOKEN_LENGTH); 17744a71df50SFrank Blaschka memcpy(QETH_CM_SETUP_FILTER_TOKEN(iob->data), 17754a71df50SFrank Blaschka &card->token.cm_filter_r, QETH_MPC_TOKEN_LENGTH); 17764a71df50SFrank Blaschka rc = qeth_send_control_data(card, CM_SETUP_SIZE, iob, 17774a71df50SFrank Blaschka qeth_cm_setup_cb, NULL); 17784a71df50SFrank Blaschka return rc; 17794a71df50SFrank Blaschka 17804a71df50SFrank Blaschka } 17814a71df50SFrank Blaschka 17824a71df50SFrank Blaschka static inline int qeth_get_initial_mtu_for_card(struct qeth_card *card) 17834a71df50SFrank Blaschka { 17844a71df50SFrank Blaschka switch (card->info.type) { 17854a71df50SFrank Blaschka case QETH_CARD_TYPE_UNKNOWN: 17864a71df50SFrank Blaschka return 1500; 17874a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 17884a71df50SFrank Blaschka return card->info.max_mtu; 17894a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 17904a71df50SFrank Blaschka switch (card->info.link_type) { 17914a71df50SFrank Blaschka case QETH_LINK_TYPE_HSTR: 17924a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE_TR: 17934a71df50SFrank Blaschka return 2000; 17944a71df50SFrank Blaschka default: 17954a71df50SFrank Blaschka return 1492; 17964a71df50SFrank Blaschka } 17974a71df50SFrank Blaschka default: 17984a71df50SFrank Blaschka return 1500; 17994a71df50SFrank Blaschka } 18004a71df50SFrank Blaschka } 18014a71df50SFrank Blaschka 18024a71df50SFrank Blaschka static inline int qeth_get_max_mtu_for_card(int cardtype) 18034a71df50SFrank Blaschka { 18044a71df50SFrank Blaschka switch (cardtype) { 18054a71df50SFrank Blaschka 18064a71df50SFrank Blaschka case QETH_CARD_TYPE_UNKNOWN: 18074a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 18084a71df50SFrank Blaschka case QETH_CARD_TYPE_OSN: 18094a71df50SFrank Blaschka return 61440; 18104a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 18114a71df50SFrank Blaschka return 57344; 18124a71df50SFrank Blaschka default: 18134a71df50SFrank Blaschka return 1500; 18144a71df50SFrank Blaschka } 18154a71df50SFrank Blaschka } 18164a71df50SFrank Blaschka 18174a71df50SFrank Blaschka static inline int qeth_get_mtu_out_of_mpc(int cardtype) 18184a71df50SFrank Blaschka { 18194a71df50SFrank Blaschka switch (cardtype) { 18204a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 18214a71df50SFrank Blaschka return 1; 18224a71df50SFrank Blaschka default: 18234a71df50SFrank Blaschka return 0; 18244a71df50SFrank Blaschka } 18254a71df50SFrank Blaschka } 18264a71df50SFrank Blaschka 18274a71df50SFrank Blaschka static inline int qeth_get_mtu_outof_framesize(int framesize) 18284a71df50SFrank Blaschka { 18294a71df50SFrank Blaschka switch (framesize) { 18304a71df50SFrank Blaschka case 0x4000: 18314a71df50SFrank Blaschka return 8192; 18324a71df50SFrank Blaschka case 0x6000: 18334a71df50SFrank Blaschka return 16384; 18344a71df50SFrank Blaschka case 0xa000: 18354a71df50SFrank Blaschka return 32768; 18364a71df50SFrank Blaschka case 0xffff: 18374a71df50SFrank Blaschka return 57344; 18384a71df50SFrank Blaschka default: 18394a71df50SFrank Blaschka return 0; 18404a71df50SFrank Blaschka } 18414a71df50SFrank Blaschka } 18424a71df50SFrank Blaschka 18434a71df50SFrank Blaschka static inline int qeth_mtu_is_valid(struct qeth_card *card, int mtu) 18444a71df50SFrank Blaschka { 18454a71df50SFrank Blaschka switch (card->info.type) { 18464a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 18474a71df50SFrank Blaschka return ((mtu >= 576) && (mtu <= 61440)); 18484a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 18494a71df50SFrank Blaschka return ((mtu >= 576) && 18504a71df50SFrank Blaschka (mtu <= card->info.max_mtu + 4096 - 32)); 18514a71df50SFrank Blaschka case QETH_CARD_TYPE_OSN: 18524a71df50SFrank Blaschka case QETH_CARD_TYPE_UNKNOWN: 18534a71df50SFrank Blaschka default: 18544a71df50SFrank Blaschka return 1; 18554a71df50SFrank Blaschka } 18564a71df50SFrank Blaschka } 18574a71df50SFrank Blaschka 18584a71df50SFrank Blaschka static int qeth_ulp_enable_cb(struct qeth_card *card, struct qeth_reply *reply, 18594a71df50SFrank Blaschka unsigned long data) 18604a71df50SFrank Blaschka { 18614a71df50SFrank Blaschka 18624a71df50SFrank Blaschka __u16 mtu, framesize; 18634a71df50SFrank Blaschka __u16 len; 18644a71df50SFrank Blaschka __u8 link_type; 18654a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 18664a71df50SFrank Blaschka 1867d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "ulpenacb"); 18684a71df50SFrank Blaschka 18694a71df50SFrank Blaschka iob = (struct qeth_cmd_buffer *) data; 18704a71df50SFrank Blaschka memcpy(&card->token.ulp_filter_r, 18714a71df50SFrank Blaschka QETH_ULP_ENABLE_RESP_FILTER_TOKEN(iob->data), 18724a71df50SFrank Blaschka QETH_MPC_TOKEN_LENGTH); 18734a71df50SFrank Blaschka if (qeth_get_mtu_out_of_mpc(card->info.type)) { 18744a71df50SFrank Blaschka memcpy(&framesize, QETH_ULP_ENABLE_RESP_MAX_MTU(iob->data), 2); 18754a71df50SFrank Blaschka mtu = qeth_get_mtu_outof_framesize(framesize); 18764a71df50SFrank Blaschka if (!mtu) { 18774a71df50SFrank Blaschka iob->rc = -EINVAL; 1878d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 18794a71df50SFrank Blaschka return 0; 18804a71df50SFrank Blaschka } 18814a71df50SFrank Blaschka card->info.max_mtu = mtu; 18824a71df50SFrank Blaschka card->info.initial_mtu = mtu; 18834a71df50SFrank Blaschka card->qdio.in_buf_size = mtu + 2 * PAGE_SIZE; 18844a71df50SFrank Blaschka } else { 18854a71df50SFrank Blaschka card->info.initial_mtu = qeth_get_initial_mtu_for_card(card); 18864a71df50SFrank Blaschka card->info.max_mtu = qeth_get_max_mtu_for_card(card->info.type); 18874a71df50SFrank Blaschka card->qdio.in_buf_size = QETH_IN_BUF_SIZE_DEFAULT; 18884a71df50SFrank Blaschka } 18894a71df50SFrank Blaschka 18904a71df50SFrank Blaschka memcpy(&len, QETH_ULP_ENABLE_RESP_DIFINFO_LEN(iob->data), 2); 18914a71df50SFrank Blaschka if (len >= QETH_MPC_DIFINFO_LEN_INDICATES_LINK_TYPE) { 18924a71df50SFrank Blaschka memcpy(&link_type, 18934a71df50SFrank Blaschka QETH_ULP_ENABLE_RESP_LINK_TYPE(iob->data), 1); 18944a71df50SFrank Blaschka card->info.link_type = link_type; 18954a71df50SFrank Blaschka } else 18964a71df50SFrank Blaschka card->info.link_type = 0; 1897d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 18984a71df50SFrank Blaschka return 0; 18994a71df50SFrank Blaschka } 19004a71df50SFrank Blaschka 19014a71df50SFrank Blaschka static int qeth_ulp_enable(struct qeth_card *card) 19024a71df50SFrank Blaschka { 19034a71df50SFrank Blaschka int rc; 19044a71df50SFrank Blaschka char prot_type; 19054a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 19064a71df50SFrank Blaschka 19074a71df50SFrank Blaschka /*FIXME: trace view callbacks*/ 1908d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "ulpenabl"); 19094a71df50SFrank Blaschka 19104a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 19114a71df50SFrank Blaschka memcpy(iob->data, ULP_ENABLE, ULP_ENABLE_SIZE); 19124a71df50SFrank Blaschka 19134a71df50SFrank Blaschka *(QETH_ULP_ENABLE_LINKNUM(iob->data)) = 19144a71df50SFrank Blaschka (__u8) card->info.portno; 19154a71df50SFrank Blaschka if (card->options.layer2) 19164a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) 19174a71df50SFrank Blaschka prot_type = QETH_PROT_OSN2; 19184a71df50SFrank Blaschka else 19194a71df50SFrank Blaschka prot_type = QETH_PROT_LAYER2; 19204a71df50SFrank Blaschka else 19214a71df50SFrank Blaschka prot_type = QETH_PROT_TCPIP; 19224a71df50SFrank Blaschka 19234a71df50SFrank Blaschka memcpy(QETH_ULP_ENABLE_PROT_TYPE(iob->data), &prot_type, 1); 19244a71df50SFrank Blaschka memcpy(QETH_ULP_ENABLE_DEST_ADDR(iob->data), 19254a71df50SFrank Blaschka &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 19264a71df50SFrank Blaschka memcpy(QETH_ULP_ENABLE_FILTER_TOKEN(iob->data), 19274a71df50SFrank Blaschka &card->token.ulp_filter_w, QETH_MPC_TOKEN_LENGTH); 19284a71df50SFrank Blaschka memcpy(QETH_ULP_ENABLE_PORTNAME_AND_LL(iob->data), 19294a71df50SFrank Blaschka card->info.portname, 9); 19304a71df50SFrank Blaschka rc = qeth_send_control_data(card, ULP_ENABLE_SIZE, iob, 19314a71df50SFrank Blaschka qeth_ulp_enable_cb, NULL); 19324a71df50SFrank Blaschka return rc; 19334a71df50SFrank Blaschka 19344a71df50SFrank Blaschka } 19354a71df50SFrank Blaschka 19364a71df50SFrank Blaschka static int qeth_ulp_setup_cb(struct qeth_card *card, struct qeth_reply *reply, 19374a71df50SFrank Blaschka unsigned long data) 19384a71df50SFrank Blaschka { 19394a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 19404a71df50SFrank Blaschka 1941d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "ulpstpcb"); 19424a71df50SFrank Blaschka 19434a71df50SFrank Blaschka iob = (struct qeth_cmd_buffer *) data; 19444a71df50SFrank Blaschka memcpy(&card->token.ulp_connection_r, 19454a71df50SFrank Blaschka QETH_ULP_SETUP_RESP_CONNECTION_TOKEN(iob->data), 19464a71df50SFrank Blaschka QETH_MPC_TOKEN_LENGTH); 1947d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, " rc%d", iob->rc); 19484a71df50SFrank Blaschka return 0; 19494a71df50SFrank Blaschka } 19504a71df50SFrank Blaschka 19514a71df50SFrank Blaschka static int qeth_ulp_setup(struct qeth_card *card) 19524a71df50SFrank Blaschka { 19534a71df50SFrank Blaschka int rc; 19544a71df50SFrank Blaschka __u16 temp; 19554a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 19564a71df50SFrank Blaschka struct ccw_dev_id dev_id; 19574a71df50SFrank Blaschka 1958d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "ulpsetup"); 19594a71df50SFrank Blaschka 19604a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 19614a71df50SFrank Blaschka memcpy(iob->data, ULP_SETUP, ULP_SETUP_SIZE); 19624a71df50SFrank Blaschka 19634a71df50SFrank Blaschka memcpy(QETH_ULP_SETUP_DEST_ADDR(iob->data), 19644a71df50SFrank Blaschka &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 19654a71df50SFrank Blaschka memcpy(QETH_ULP_SETUP_CONNECTION_TOKEN(iob->data), 19664a71df50SFrank Blaschka &card->token.ulp_connection_w, QETH_MPC_TOKEN_LENGTH); 19674a71df50SFrank Blaschka memcpy(QETH_ULP_SETUP_FILTER_TOKEN(iob->data), 19684a71df50SFrank Blaschka &card->token.ulp_filter_r, QETH_MPC_TOKEN_LENGTH); 19694a71df50SFrank Blaschka 19704a71df50SFrank Blaschka ccw_device_get_id(CARD_DDEV(card), &dev_id); 19714a71df50SFrank Blaschka memcpy(QETH_ULP_SETUP_CUA(iob->data), &dev_id.devno, 2); 19724a71df50SFrank Blaschka temp = (card->info.cula << 8) + card->info.unit_addr2; 19734a71df50SFrank Blaschka memcpy(QETH_ULP_SETUP_REAL_DEVADDR(iob->data), &temp, 2); 19744a71df50SFrank Blaschka rc = qeth_send_control_data(card, ULP_SETUP_SIZE, iob, 19754a71df50SFrank Blaschka qeth_ulp_setup_cb, NULL); 19764a71df50SFrank Blaschka return rc; 19774a71df50SFrank Blaschka } 19784a71df50SFrank Blaschka 19794a71df50SFrank Blaschka static int qeth_alloc_qdio_buffers(struct qeth_card *card) 19804a71df50SFrank Blaschka { 19814a71df50SFrank Blaschka int i, j; 19824a71df50SFrank Blaschka 1983d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "allcqdbf"); 19844a71df50SFrank Blaschka 19854a71df50SFrank Blaschka if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_UNINITIALIZED, 19864a71df50SFrank Blaschka QETH_QDIO_ALLOCATED) != QETH_QDIO_UNINITIALIZED) 19874a71df50SFrank Blaschka return 0; 19884a71df50SFrank Blaschka 19894a71df50SFrank Blaschka card->qdio.in_q = kmalloc(sizeof(struct qeth_qdio_q), 1990508b3c4fSUrsula Braun GFP_KERNEL); 19914a71df50SFrank Blaschka if (!card->qdio.in_q) 19924a71df50SFrank Blaschka goto out_nomem; 1993d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "inq"); 1994d11ba0c4SPeter Tiedemann QETH_DBF_HEX(SETUP, 2, &card->qdio.in_q, sizeof(void *)); 19954a71df50SFrank Blaschka memset(card->qdio.in_q, 0, sizeof(struct qeth_qdio_q)); 19964a71df50SFrank Blaschka /* give inbound qeth_qdio_buffers their qdio_buffers */ 19974a71df50SFrank Blaschka for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; ++i) 19984a71df50SFrank Blaschka card->qdio.in_q->bufs[i].buffer = 19994a71df50SFrank Blaschka &card->qdio.in_q->qdio_bufs[i]; 20004a71df50SFrank Blaschka /* inbound buffer pool */ 20014a71df50SFrank Blaschka if (qeth_alloc_buffer_pool(card)) 20024a71df50SFrank Blaschka goto out_freeinq; 20034a71df50SFrank Blaschka /* outbound */ 20044a71df50SFrank Blaschka card->qdio.out_qs = 20054a71df50SFrank Blaschka kmalloc(card->qdio.no_out_queues * 20064a71df50SFrank Blaschka sizeof(struct qeth_qdio_out_q *), GFP_KERNEL); 20074a71df50SFrank Blaschka if (!card->qdio.out_qs) 20084a71df50SFrank Blaschka goto out_freepool; 20094a71df50SFrank Blaschka for (i = 0; i < card->qdio.no_out_queues; ++i) { 20104a71df50SFrank Blaschka card->qdio.out_qs[i] = kmalloc(sizeof(struct qeth_qdio_out_q), 2011508b3c4fSUrsula Braun GFP_KERNEL); 20124a71df50SFrank Blaschka if (!card->qdio.out_qs[i]) 20134a71df50SFrank Blaschka goto out_freeoutq; 2014d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "outq %i", i); 2015d11ba0c4SPeter Tiedemann QETH_DBF_HEX(SETUP, 2, &card->qdio.out_qs[i], sizeof(void *)); 20164a71df50SFrank Blaschka memset(card->qdio.out_qs[i], 0, sizeof(struct qeth_qdio_out_q)); 20174a71df50SFrank Blaschka card->qdio.out_qs[i]->queue_no = i; 20184a71df50SFrank Blaschka /* give outbound qeth_qdio_buffers their qdio_buffers */ 20194a71df50SFrank Blaschka for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 20204a71df50SFrank Blaschka card->qdio.out_qs[i]->bufs[j].buffer = 20214a71df50SFrank Blaschka &card->qdio.out_qs[i]->qdio_bufs[j]; 20224a71df50SFrank Blaschka skb_queue_head_init(&card->qdio.out_qs[i]->bufs[j]. 20234a71df50SFrank Blaschka skb_list); 20244a71df50SFrank Blaschka lockdep_set_class( 20254a71df50SFrank Blaschka &card->qdio.out_qs[i]->bufs[j].skb_list.lock, 20264a71df50SFrank Blaschka &qdio_out_skb_queue_key); 20274a71df50SFrank Blaschka INIT_LIST_HEAD(&card->qdio.out_qs[i]->bufs[j].ctx_list); 20284a71df50SFrank Blaschka } 20294a71df50SFrank Blaschka } 20304a71df50SFrank Blaschka return 0; 20314a71df50SFrank Blaschka 20324a71df50SFrank Blaschka out_freeoutq: 20334a71df50SFrank Blaschka while (i > 0) 20344a71df50SFrank Blaschka kfree(card->qdio.out_qs[--i]); 20354a71df50SFrank Blaschka kfree(card->qdio.out_qs); 20364a71df50SFrank Blaschka card->qdio.out_qs = NULL; 20374a71df50SFrank Blaschka out_freepool: 20384a71df50SFrank Blaschka qeth_free_buffer_pool(card); 20394a71df50SFrank Blaschka out_freeinq: 20404a71df50SFrank Blaschka kfree(card->qdio.in_q); 20414a71df50SFrank Blaschka card->qdio.in_q = NULL; 20424a71df50SFrank Blaschka out_nomem: 20434a71df50SFrank Blaschka atomic_set(&card->qdio.state, QETH_QDIO_UNINITIALIZED); 20444a71df50SFrank Blaschka return -ENOMEM; 20454a71df50SFrank Blaschka } 20464a71df50SFrank Blaschka 20474a71df50SFrank Blaschka static void qeth_create_qib_param_field(struct qeth_card *card, 20484a71df50SFrank Blaschka char *param_field) 20494a71df50SFrank Blaschka { 20504a71df50SFrank Blaschka 20514a71df50SFrank Blaschka param_field[0] = _ascebc['P']; 20524a71df50SFrank Blaschka param_field[1] = _ascebc['C']; 20534a71df50SFrank Blaschka param_field[2] = _ascebc['I']; 20544a71df50SFrank Blaschka param_field[3] = _ascebc['T']; 20554a71df50SFrank Blaschka *((unsigned int *) (¶m_field[4])) = QETH_PCI_THRESHOLD_A(card); 20564a71df50SFrank Blaschka *((unsigned int *) (¶m_field[8])) = QETH_PCI_THRESHOLD_B(card); 20574a71df50SFrank Blaschka *((unsigned int *) (¶m_field[12])) = QETH_PCI_TIMER_VALUE(card); 20584a71df50SFrank Blaschka } 20594a71df50SFrank Blaschka 20604a71df50SFrank Blaschka static void qeth_create_qib_param_field_blkt(struct qeth_card *card, 20614a71df50SFrank Blaschka char *param_field) 20624a71df50SFrank Blaschka { 20634a71df50SFrank Blaschka param_field[16] = _ascebc['B']; 20644a71df50SFrank Blaschka param_field[17] = _ascebc['L']; 20654a71df50SFrank Blaschka param_field[18] = _ascebc['K']; 20664a71df50SFrank Blaschka param_field[19] = _ascebc['T']; 20674a71df50SFrank Blaschka *((unsigned int *) (¶m_field[20])) = card->info.blkt.time_total; 20684a71df50SFrank Blaschka *((unsigned int *) (¶m_field[24])) = card->info.blkt.inter_packet; 20694a71df50SFrank Blaschka *((unsigned int *) (¶m_field[28])) = 20704a71df50SFrank Blaschka card->info.blkt.inter_packet_jumbo; 20714a71df50SFrank Blaschka } 20724a71df50SFrank Blaschka 20734a71df50SFrank Blaschka static int qeth_qdio_activate(struct qeth_card *card) 20744a71df50SFrank Blaschka { 2075d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 3, "qdioact"); 20764a71df50SFrank Blaschka return qdio_activate(CARD_DDEV(card), 0); 20774a71df50SFrank Blaschka } 20784a71df50SFrank Blaschka 20794a71df50SFrank Blaschka static int qeth_dm_act(struct qeth_card *card) 20804a71df50SFrank Blaschka { 20814a71df50SFrank Blaschka int rc; 20824a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 20834a71df50SFrank Blaschka 2084d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "dmact"); 20854a71df50SFrank Blaschka 20864a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 20874a71df50SFrank Blaschka memcpy(iob->data, DM_ACT, DM_ACT_SIZE); 20884a71df50SFrank Blaschka 20894a71df50SFrank Blaschka memcpy(QETH_DM_ACT_DEST_ADDR(iob->data), 20904a71df50SFrank Blaschka &card->token.cm_connection_r, QETH_MPC_TOKEN_LENGTH); 20914a71df50SFrank Blaschka memcpy(QETH_DM_ACT_CONNECTION_TOKEN(iob->data), 20924a71df50SFrank Blaschka &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 20934a71df50SFrank Blaschka rc = qeth_send_control_data(card, DM_ACT_SIZE, iob, NULL, NULL); 20944a71df50SFrank Blaschka return rc; 20954a71df50SFrank Blaschka } 20964a71df50SFrank Blaschka 20974a71df50SFrank Blaschka static int qeth_mpc_initialize(struct qeth_card *card) 20984a71df50SFrank Blaschka { 20994a71df50SFrank Blaschka int rc; 21004a71df50SFrank Blaschka 2101d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "mpcinit"); 21024a71df50SFrank Blaschka 21034a71df50SFrank Blaschka rc = qeth_issue_next_read(card); 21044a71df50SFrank Blaschka if (rc) { 2105d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 21064a71df50SFrank Blaschka return rc; 21074a71df50SFrank Blaschka } 21084a71df50SFrank Blaschka rc = qeth_cm_enable(card); 21094a71df50SFrank Blaschka if (rc) { 2110d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 21114a71df50SFrank Blaschka goto out_qdio; 21124a71df50SFrank Blaschka } 21134a71df50SFrank Blaschka rc = qeth_cm_setup(card); 21144a71df50SFrank Blaschka if (rc) { 2115d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 21164a71df50SFrank Blaschka goto out_qdio; 21174a71df50SFrank Blaschka } 21184a71df50SFrank Blaschka rc = qeth_ulp_enable(card); 21194a71df50SFrank Blaschka if (rc) { 2120d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc); 21214a71df50SFrank Blaschka goto out_qdio; 21224a71df50SFrank Blaschka } 21234a71df50SFrank Blaschka rc = qeth_ulp_setup(card); 21244a71df50SFrank Blaschka if (rc) { 2125d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 21264a71df50SFrank Blaschka goto out_qdio; 21274a71df50SFrank Blaschka } 21284a71df50SFrank Blaschka rc = qeth_alloc_qdio_buffers(card); 21294a71df50SFrank Blaschka if (rc) { 2130d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 21314a71df50SFrank Blaschka goto out_qdio; 21324a71df50SFrank Blaschka } 21334a71df50SFrank Blaschka rc = qeth_qdio_establish(card); 21344a71df50SFrank Blaschka if (rc) { 2135d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 21364a71df50SFrank Blaschka qeth_free_qdio_buffers(card); 21374a71df50SFrank Blaschka goto out_qdio; 21384a71df50SFrank Blaschka } 21394a71df50SFrank Blaschka rc = qeth_qdio_activate(card); 21404a71df50SFrank Blaschka if (rc) { 2141d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "7err%d", rc); 21424a71df50SFrank Blaschka goto out_qdio; 21434a71df50SFrank Blaschka } 21444a71df50SFrank Blaschka rc = qeth_dm_act(card); 21454a71df50SFrank Blaschka if (rc) { 2146d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "8err%d", rc); 21474a71df50SFrank Blaschka goto out_qdio; 21484a71df50SFrank Blaschka } 21494a71df50SFrank Blaschka 21504a71df50SFrank Blaschka return 0; 21514a71df50SFrank Blaschka out_qdio: 21524a71df50SFrank Blaschka qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD); 21534a71df50SFrank Blaschka return rc; 21544a71df50SFrank Blaschka } 21554a71df50SFrank Blaschka 21564a71df50SFrank Blaschka static void qeth_print_status_with_portname(struct qeth_card *card) 21574a71df50SFrank Blaschka { 21584a71df50SFrank Blaschka char dbf_text[15]; 21594a71df50SFrank Blaschka int i; 21604a71df50SFrank Blaschka 21614a71df50SFrank Blaschka sprintf(dbf_text, "%s", card->info.portname + 1); 21624a71df50SFrank Blaschka for (i = 0; i < 8; i++) 21634a71df50SFrank Blaschka dbf_text[i] = 21644a71df50SFrank Blaschka (char) _ebcasc[(__u8) dbf_text[i]]; 21654a71df50SFrank Blaschka dbf_text[8] = 0; 21664a71df50SFrank Blaschka PRINT_INFO("Device %s/%s/%s is a%s card%s%s%s\n" 21674a71df50SFrank Blaschka "with link type %s (portname: %s)\n", 21684a71df50SFrank Blaschka CARD_RDEV_ID(card), 21694a71df50SFrank Blaschka CARD_WDEV_ID(card), 21704a71df50SFrank Blaschka CARD_DDEV_ID(card), 21714a71df50SFrank Blaschka qeth_get_cardname(card), 21724a71df50SFrank Blaschka (card->info.mcl_level[0]) ? " (level: " : "", 21734a71df50SFrank Blaschka (card->info.mcl_level[0]) ? card->info.mcl_level : "", 21744a71df50SFrank Blaschka (card->info.mcl_level[0]) ? ")" : "", 21754a71df50SFrank Blaschka qeth_get_cardname_short(card), 21764a71df50SFrank Blaschka dbf_text); 21774a71df50SFrank Blaschka 21784a71df50SFrank Blaschka } 21794a71df50SFrank Blaschka 21804a71df50SFrank Blaschka static void qeth_print_status_no_portname(struct qeth_card *card) 21814a71df50SFrank Blaschka { 21824a71df50SFrank Blaschka if (card->info.portname[0]) 21834a71df50SFrank Blaschka PRINT_INFO("Device %s/%s/%s is a%s " 21844a71df50SFrank Blaschka "card%s%s%s\nwith link type %s " 21854a71df50SFrank Blaschka "(no portname needed by interface).\n", 21864a71df50SFrank Blaschka CARD_RDEV_ID(card), 21874a71df50SFrank Blaschka CARD_WDEV_ID(card), 21884a71df50SFrank Blaschka CARD_DDEV_ID(card), 21894a71df50SFrank Blaschka qeth_get_cardname(card), 21904a71df50SFrank Blaschka (card->info.mcl_level[0]) ? " (level: " : "", 21914a71df50SFrank Blaschka (card->info.mcl_level[0]) ? card->info.mcl_level : "", 21924a71df50SFrank Blaschka (card->info.mcl_level[0]) ? ")" : "", 21934a71df50SFrank Blaschka qeth_get_cardname_short(card)); 21944a71df50SFrank Blaschka else 21954a71df50SFrank Blaschka PRINT_INFO("Device %s/%s/%s is a%s " 21964a71df50SFrank Blaschka "card%s%s%s\nwith link type %s.\n", 21974a71df50SFrank Blaschka CARD_RDEV_ID(card), 21984a71df50SFrank Blaschka CARD_WDEV_ID(card), 21994a71df50SFrank Blaschka CARD_DDEV_ID(card), 22004a71df50SFrank Blaschka qeth_get_cardname(card), 22014a71df50SFrank Blaschka (card->info.mcl_level[0]) ? " (level: " : "", 22024a71df50SFrank Blaschka (card->info.mcl_level[0]) ? card->info.mcl_level : "", 22034a71df50SFrank Blaschka (card->info.mcl_level[0]) ? ")" : "", 22044a71df50SFrank Blaschka qeth_get_cardname_short(card)); 22054a71df50SFrank Blaschka } 22064a71df50SFrank Blaschka 22074a71df50SFrank Blaschka void qeth_print_status_message(struct qeth_card *card) 22084a71df50SFrank Blaschka { 22094a71df50SFrank Blaschka switch (card->info.type) { 22104a71df50SFrank Blaschka case QETH_CARD_TYPE_OSAE: 22114a71df50SFrank Blaschka /* VM will use a non-zero first character 22124a71df50SFrank Blaschka * to indicate a HiperSockets like reporting 22134a71df50SFrank Blaschka * of the level OSA sets the first character to zero 22144a71df50SFrank Blaschka * */ 22154a71df50SFrank Blaschka if (!card->info.mcl_level[0]) { 22164a71df50SFrank Blaschka sprintf(card->info.mcl_level, "%02x%02x", 22174a71df50SFrank Blaschka card->info.mcl_level[2], 22184a71df50SFrank Blaschka card->info.mcl_level[3]); 22194a71df50SFrank Blaschka 22204a71df50SFrank Blaschka card->info.mcl_level[QETH_MCL_LENGTH] = 0; 22214a71df50SFrank Blaschka break; 22224a71df50SFrank Blaschka } 22234a71df50SFrank Blaschka /* fallthrough */ 22244a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 22254a71df50SFrank Blaschka if (card->info.guestlan) { 22264a71df50SFrank Blaschka card->info.mcl_level[0] = (char) _ebcasc[(__u8) 22274a71df50SFrank Blaschka card->info.mcl_level[0]]; 22284a71df50SFrank Blaschka card->info.mcl_level[1] = (char) _ebcasc[(__u8) 22294a71df50SFrank Blaschka card->info.mcl_level[1]]; 22304a71df50SFrank Blaschka card->info.mcl_level[2] = (char) _ebcasc[(__u8) 22314a71df50SFrank Blaschka card->info.mcl_level[2]]; 22324a71df50SFrank Blaschka card->info.mcl_level[3] = (char) _ebcasc[(__u8) 22334a71df50SFrank Blaschka card->info.mcl_level[3]]; 22344a71df50SFrank Blaschka card->info.mcl_level[QETH_MCL_LENGTH] = 0; 22354a71df50SFrank Blaschka } 22364a71df50SFrank Blaschka break; 22374a71df50SFrank Blaschka default: 22384a71df50SFrank Blaschka memset(&card->info.mcl_level[0], 0, QETH_MCL_LENGTH + 1); 22394a71df50SFrank Blaschka } 22404a71df50SFrank Blaschka if (card->info.portname_required) 22414a71df50SFrank Blaschka qeth_print_status_with_portname(card); 22424a71df50SFrank Blaschka else 22434a71df50SFrank Blaschka qeth_print_status_no_portname(card); 22444a71df50SFrank Blaschka } 22454a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_print_status_message); 22464a71df50SFrank Blaschka 22474a71df50SFrank Blaschka static void qeth_initialize_working_pool_list(struct qeth_card *card) 22484a71df50SFrank Blaschka { 22494a71df50SFrank Blaschka struct qeth_buffer_pool_entry *entry; 22504a71df50SFrank Blaschka 2251d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "inwrklst"); 22524a71df50SFrank Blaschka 22534a71df50SFrank Blaschka list_for_each_entry(entry, 22544a71df50SFrank Blaschka &card->qdio.init_pool.entry_list, init_list) { 22554a71df50SFrank Blaschka qeth_put_buffer_pool_entry(card, entry); 22564a71df50SFrank Blaschka } 22574a71df50SFrank Blaschka } 22584a71df50SFrank Blaschka 22594a71df50SFrank Blaschka static inline struct qeth_buffer_pool_entry *qeth_find_free_buffer_pool_entry( 22604a71df50SFrank Blaschka struct qeth_card *card) 22614a71df50SFrank Blaschka { 22624a71df50SFrank Blaschka struct list_head *plh; 22634a71df50SFrank Blaschka struct qeth_buffer_pool_entry *entry; 22644a71df50SFrank Blaschka int i, free; 22654a71df50SFrank Blaschka struct page *page; 22664a71df50SFrank Blaschka 22674a71df50SFrank Blaschka if (list_empty(&card->qdio.in_buf_pool.entry_list)) 22684a71df50SFrank Blaschka return NULL; 22694a71df50SFrank Blaschka 22704a71df50SFrank Blaschka list_for_each(plh, &card->qdio.in_buf_pool.entry_list) { 22714a71df50SFrank Blaschka entry = list_entry(plh, struct qeth_buffer_pool_entry, list); 22724a71df50SFrank Blaschka free = 1; 22734a71df50SFrank Blaschka for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 22744a71df50SFrank Blaschka if (page_count(virt_to_page(entry->elements[i])) > 1) { 22754a71df50SFrank Blaschka free = 0; 22764a71df50SFrank Blaschka break; 22774a71df50SFrank Blaschka } 22784a71df50SFrank Blaschka } 22794a71df50SFrank Blaschka if (free) { 22804a71df50SFrank Blaschka list_del_init(&entry->list); 22814a71df50SFrank Blaschka return entry; 22824a71df50SFrank Blaschka } 22834a71df50SFrank Blaschka } 22844a71df50SFrank Blaschka 22854a71df50SFrank Blaschka /* no free buffer in pool so take first one and swap pages */ 22864a71df50SFrank Blaschka entry = list_entry(card->qdio.in_buf_pool.entry_list.next, 22874a71df50SFrank Blaschka struct qeth_buffer_pool_entry, list); 22884a71df50SFrank Blaschka for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 22894a71df50SFrank Blaschka if (page_count(virt_to_page(entry->elements[i])) > 1) { 2290508b3c4fSUrsula Braun page = alloc_page(GFP_ATOMIC); 22914a71df50SFrank Blaschka if (!page) { 22924a71df50SFrank Blaschka return NULL; 22934a71df50SFrank Blaschka } else { 22944a71df50SFrank Blaschka free_page((unsigned long)entry->elements[i]); 22954a71df50SFrank Blaschka entry->elements[i] = page_address(page); 22964a71df50SFrank Blaschka if (card->options.performance_stats) 22974a71df50SFrank Blaschka card->perf_stats.sg_alloc_page_rx++; 22984a71df50SFrank Blaschka } 22994a71df50SFrank Blaschka } 23004a71df50SFrank Blaschka } 23014a71df50SFrank Blaschka list_del_init(&entry->list); 23024a71df50SFrank Blaschka return entry; 23034a71df50SFrank Blaschka } 23044a71df50SFrank Blaschka 23054a71df50SFrank Blaschka static int qeth_init_input_buffer(struct qeth_card *card, 23064a71df50SFrank Blaschka struct qeth_qdio_buffer *buf) 23074a71df50SFrank Blaschka { 23084a71df50SFrank Blaschka struct qeth_buffer_pool_entry *pool_entry; 23094a71df50SFrank Blaschka int i; 23104a71df50SFrank Blaschka 23114a71df50SFrank Blaschka pool_entry = qeth_find_free_buffer_pool_entry(card); 23124a71df50SFrank Blaschka if (!pool_entry) 23134a71df50SFrank Blaschka return 1; 23144a71df50SFrank Blaschka 23154a71df50SFrank Blaschka /* 23164a71df50SFrank Blaschka * since the buffer is accessed only from the input_tasklet 23174a71df50SFrank Blaschka * there shouldn't be a need to synchronize; also, since we use 23184a71df50SFrank Blaschka * the QETH_IN_BUF_REQUEUE_THRESHOLD we should never run out off 23194a71df50SFrank Blaschka * buffers 23204a71df50SFrank Blaschka */ 23214a71df50SFrank Blaschka BUG_ON(!pool_entry); 23224a71df50SFrank Blaschka 23234a71df50SFrank Blaschka buf->pool_entry = pool_entry; 23244a71df50SFrank Blaschka for (i = 0; i < QETH_MAX_BUFFER_ELEMENTS(card); ++i) { 23254a71df50SFrank Blaschka buf->buffer->element[i].length = PAGE_SIZE; 23264a71df50SFrank Blaschka buf->buffer->element[i].addr = pool_entry->elements[i]; 23274a71df50SFrank Blaschka if (i == QETH_MAX_BUFFER_ELEMENTS(card) - 1) 23284a71df50SFrank Blaschka buf->buffer->element[i].flags = SBAL_FLAGS_LAST_ENTRY; 23294a71df50SFrank Blaschka else 23304a71df50SFrank Blaschka buf->buffer->element[i].flags = 0; 23314a71df50SFrank Blaschka } 23324a71df50SFrank Blaschka return 0; 23334a71df50SFrank Blaschka } 23344a71df50SFrank Blaschka 23354a71df50SFrank Blaschka int qeth_init_qdio_queues(struct qeth_card *card) 23364a71df50SFrank Blaschka { 23374a71df50SFrank Blaschka int i, j; 23384a71df50SFrank Blaschka int rc; 23394a71df50SFrank Blaschka 2340d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "initqdqs"); 23414a71df50SFrank Blaschka 23424a71df50SFrank Blaschka /* inbound queue */ 23434a71df50SFrank Blaschka memset(card->qdio.in_q->qdio_bufs, 0, 23444a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q * sizeof(struct qdio_buffer)); 23454a71df50SFrank Blaschka qeth_initialize_working_pool_list(card); 23464a71df50SFrank Blaschka /*give only as many buffers to hardware as we have buffer pool entries*/ 23474a71df50SFrank Blaschka for (i = 0; i < card->qdio.in_buf_pool.buf_count - 1; ++i) 23484a71df50SFrank Blaschka qeth_init_input_buffer(card, &card->qdio.in_q->bufs[i]); 23494a71df50SFrank Blaschka card->qdio.in_q->next_buf_to_init = 23504a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count - 1; 23514a71df50SFrank Blaschka rc = do_QDIO(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0, 0, 23524a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count - 1, NULL); 23534a71df50SFrank Blaschka if (rc) { 2354d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 23554a71df50SFrank Blaschka return rc; 23564a71df50SFrank Blaschka } 23574a71df50SFrank Blaschka rc = qdio_synchronize(CARD_DDEV(card), QDIO_FLAG_SYNC_INPUT, 0); 23584a71df50SFrank Blaschka if (rc) { 2359d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 23604a71df50SFrank Blaschka return rc; 23614a71df50SFrank Blaschka } 23624a71df50SFrank Blaschka /* outbound queue */ 23634a71df50SFrank Blaschka for (i = 0; i < card->qdio.no_out_queues; ++i) { 23644a71df50SFrank Blaschka memset(card->qdio.out_qs[i]->qdio_bufs, 0, 23654a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q * sizeof(struct qdio_buffer)); 23664a71df50SFrank Blaschka for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j) { 23674a71df50SFrank Blaschka qeth_clear_output_buffer(card->qdio.out_qs[i], 23684a71df50SFrank Blaschka &card->qdio.out_qs[i]->bufs[j]); 23694a71df50SFrank Blaschka } 23704a71df50SFrank Blaschka card->qdio.out_qs[i]->card = card; 23714a71df50SFrank Blaschka card->qdio.out_qs[i]->next_buf_to_fill = 0; 23724a71df50SFrank Blaschka card->qdio.out_qs[i]->do_pack = 0; 23734a71df50SFrank Blaschka atomic_set(&card->qdio.out_qs[i]->used_buffers, 0); 23744a71df50SFrank Blaschka atomic_set(&card->qdio.out_qs[i]->set_pci_flags_count, 0); 23754a71df50SFrank Blaschka atomic_set(&card->qdio.out_qs[i]->state, 23764a71df50SFrank Blaschka QETH_OUT_Q_UNLOCKED); 23774a71df50SFrank Blaschka } 23784a71df50SFrank Blaschka return 0; 23794a71df50SFrank Blaschka } 23804a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_init_qdio_queues); 23814a71df50SFrank Blaschka 23824a71df50SFrank Blaschka static inline __u8 qeth_get_ipa_adp_type(enum qeth_link_types link_type) 23834a71df50SFrank Blaschka { 23844a71df50SFrank Blaschka switch (link_type) { 23854a71df50SFrank Blaschka case QETH_LINK_TYPE_HSTR: 23864a71df50SFrank Blaschka return 2; 23874a71df50SFrank Blaschka default: 23884a71df50SFrank Blaschka return 1; 23894a71df50SFrank Blaschka } 23904a71df50SFrank Blaschka } 23914a71df50SFrank Blaschka 23924a71df50SFrank Blaschka static void qeth_fill_ipacmd_header(struct qeth_card *card, 23934a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd, __u8 command, 23944a71df50SFrank Blaschka enum qeth_prot_versions prot) 23954a71df50SFrank Blaschka { 23964a71df50SFrank Blaschka memset(cmd, 0, sizeof(struct qeth_ipa_cmd)); 23974a71df50SFrank Blaschka cmd->hdr.command = command; 23984a71df50SFrank Blaschka cmd->hdr.initiator = IPA_CMD_INITIATOR_HOST; 23994a71df50SFrank Blaschka cmd->hdr.seqno = card->seqno.ipa; 24004a71df50SFrank Blaschka cmd->hdr.adapter_type = qeth_get_ipa_adp_type(card->info.link_type); 24014a71df50SFrank Blaschka cmd->hdr.rel_adapter_no = (__u8) card->info.portno; 24024a71df50SFrank Blaschka if (card->options.layer2) 24034a71df50SFrank Blaschka cmd->hdr.prim_version_no = 2; 24044a71df50SFrank Blaschka else 24054a71df50SFrank Blaschka cmd->hdr.prim_version_no = 1; 24064a71df50SFrank Blaschka cmd->hdr.param_count = 1; 24074a71df50SFrank Blaschka cmd->hdr.prot_version = prot; 24084a71df50SFrank Blaschka cmd->hdr.ipa_supported = 0; 24094a71df50SFrank Blaschka cmd->hdr.ipa_enabled = 0; 24104a71df50SFrank Blaschka } 24114a71df50SFrank Blaschka 24124a71df50SFrank Blaschka struct qeth_cmd_buffer *qeth_get_ipacmd_buffer(struct qeth_card *card, 24134a71df50SFrank Blaschka enum qeth_ipa_cmds ipacmd, enum qeth_prot_versions prot) 24144a71df50SFrank Blaschka { 24154a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 24164a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 24174a71df50SFrank Blaschka 24184a71df50SFrank Blaschka iob = qeth_wait_for_buffer(&card->write); 24194a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 24204a71df50SFrank Blaschka qeth_fill_ipacmd_header(card, cmd, ipacmd, prot); 24214a71df50SFrank Blaschka 24224a71df50SFrank Blaschka return iob; 24234a71df50SFrank Blaschka } 24244a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_ipacmd_buffer); 24254a71df50SFrank Blaschka 24264a71df50SFrank Blaschka void qeth_prepare_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob, 24274a71df50SFrank Blaschka char prot_type) 24284a71df50SFrank Blaschka { 24294a71df50SFrank Blaschka memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE); 24304a71df50SFrank Blaschka memcpy(QETH_IPA_CMD_PROT_TYPE(iob->data), &prot_type, 1); 24314a71df50SFrank Blaschka memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data), 24324a71df50SFrank Blaschka &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 24334a71df50SFrank Blaschka } 24344a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_prepare_ipa_cmd); 24354a71df50SFrank Blaschka 24364a71df50SFrank Blaschka int qeth_send_ipa_cmd(struct qeth_card *card, struct qeth_cmd_buffer *iob, 24374a71df50SFrank Blaschka int (*reply_cb)(struct qeth_card *, struct qeth_reply*, 24384a71df50SFrank Blaschka unsigned long), 24394a71df50SFrank Blaschka void *reply_param) 24404a71df50SFrank Blaschka { 24414a71df50SFrank Blaschka int rc; 24424a71df50SFrank Blaschka char prot_type; 24434a71df50SFrank Blaschka 2444d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "sendipa"); 24454a71df50SFrank Blaschka 24464a71df50SFrank Blaschka if (card->options.layer2) 24474a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) 24484a71df50SFrank Blaschka prot_type = QETH_PROT_OSN2; 24494a71df50SFrank Blaschka else 24504a71df50SFrank Blaschka prot_type = QETH_PROT_LAYER2; 24514a71df50SFrank Blaschka else 24524a71df50SFrank Blaschka prot_type = QETH_PROT_TCPIP; 24534a71df50SFrank Blaschka qeth_prepare_ipa_cmd(card, iob, prot_type); 2454d11ba0c4SPeter Tiedemann rc = qeth_send_control_data(card, IPA_CMD_LENGTH, 2455d11ba0c4SPeter Tiedemann iob, reply_cb, reply_param); 24564a71df50SFrank Blaschka return rc; 24574a71df50SFrank Blaschka } 24584a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_send_ipa_cmd); 24594a71df50SFrank Blaschka 24604a71df50SFrank Blaschka static int qeth_send_startstoplan(struct qeth_card *card, 24614a71df50SFrank Blaschka enum qeth_ipa_cmds ipacmd, enum qeth_prot_versions prot) 24624a71df50SFrank Blaschka { 24634a71df50SFrank Blaschka int rc; 24644a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 24654a71df50SFrank Blaschka 24664a71df50SFrank Blaschka iob = qeth_get_ipacmd_buffer(card, ipacmd, prot); 24674a71df50SFrank Blaschka rc = qeth_send_ipa_cmd(card, iob, NULL, NULL); 24684a71df50SFrank Blaschka 24694a71df50SFrank Blaschka return rc; 24704a71df50SFrank Blaschka } 24714a71df50SFrank Blaschka 24724a71df50SFrank Blaschka int qeth_send_startlan(struct qeth_card *card) 24734a71df50SFrank Blaschka { 24744a71df50SFrank Blaschka int rc; 24754a71df50SFrank Blaschka 2476d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "strtlan"); 24774a71df50SFrank Blaschka 24784a71df50SFrank Blaschka rc = qeth_send_startstoplan(card, IPA_CMD_STARTLAN, 0); 24794a71df50SFrank Blaschka return rc; 24804a71df50SFrank Blaschka } 24814a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_send_startlan); 24824a71df50SFrank Blaschka 24834a71df50SFrank Blaschka int qeth_send_stoplan(struct qeth_card *card) 24844a71df50SFrank Blaschka { 24854a71df50SFrank Blaschka int rc = 0; 24864a71df50SFrank Blaschka 24874a71df50SFrank Blaschka /* 24884a71df50SFrank Blaschka * TODO: according to the IPA format document page 14, 24894a71df50SFrank Blaschka * TCP/IP (we!) never issue a STOPLAN 24904a71df50SFrank Blaschka * is this right ?!? 24914a71df50SFrank Blaschka */ 2492d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "stoplan"); 24934a71df50SFrank Blaschka 24944a71df50SFrank Blaschka rc = qeth_send_startstoplan(card, IPA_CMD_STOPLAN, 0); 24954a71df50SFrank Blaschka return rc; 24964a71df50SFrank Blaschka } 24974a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_send_stoplan); 24984a71df50SFrank Blaschka 24994a71df50SFrank Blaschka int qeth_default_setadapterparms_cb(struct qeth_card *card, 25004a71df50SFrank Blaschka struct qeth_reply *reply, unsigned long data) 25014a71df50SFrank Blaschka { 25024a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 25034a71df50SFrank Blaschka 2504d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "defadpcb"); 25054a71df50SFrank Blaschka 25064a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) data; 25074a71df50SFrank Blaschka if (cmd->hdr.return_code == 0) 25084a71df50SFrank Blaschka cmd->hdr.return_code = 25094a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.return_code; 25104a71df50SFrank Blaschka return 0; 25114a71df50SFrank Blaschka } 25124a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_default_setadapterparms_cb); 25134a71df50SFrank Blaschka 25144a71df50SFrank Blaschka static int qeth_query_setadapterparms_cb(struct qeth_card *card, 25154a71df50SFrank Blaschka struct qeth_reply *reply, unsigned long data) 25164a71df50SFrank Blaschka { 25174a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 25184a71df50SFrank Blaschka 2519d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "quyadpcb"); 25204a71df50SFrank Blaschka 25214a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) data; 25224a71df50SFrank Blaschka if (cmd->data.setadapterparms.data.query_cmds_supp.lan_type & 0x7f) 25234a71df50SFrank Blaschka card->info.link_type = 25244a71df50SFrank Blaschka cmd->data.setadapterparms.data.query_cmds_supp.lan_type; 25254a71df50SFrank Blaschka card->options.adp.supported_funcs = 25264a71df50SFrank Blaschka cmd->data.setadapterparms.data.query_cmds_supp.supported_cmds; 25274a71df50SFrank Blaschka return qeth_default_setadapterparms_cb(card, reply, (unsigned long)cmd); 25284a71df50SFrank Blaschka } 25294a71df50SFrank Blaschka 25304a71df50SFrank Blaschka struct qeth_cmd_buffer *qeth_get_adapter_cmd(struct qeth_card *card, 25314a71df50SFrank Blaschka __u32 command, __u32 cmdlen) 25324a71df50SFrank Blaschka { 25334a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 25344a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 25354a71df50SFrank Blaschka 25364a71df50SFrank Blaschka iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETADAPTERPARMS, 25374a71df50SFrank Blaschka QETH_PROT_IPV4); 25384a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 25394a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.cmdlength = cmdlen; 25404a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.command_code = command; 25414a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.used_total = 1; 25424a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.seq_no = 1; 25434a71df50SFrank Blaschka 25444a71df50SFrank Blaschka return iob; 25454a71df50SFrank Blaschka } 25464a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_adapter_cmd); 25474a71df50SFrank Blaschka 25484a71df50SFrank Blaschka int qeth_query_setadapterparms(struct qeth_card *card) 25494a71df50SFrank Blaschka { 25504a71df50SFrank Blaschka int rc; 25514a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 25524a71df50SFrank Blaschka 2553d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "queryadp"); 25544a71df50SFrank Blaschka iob = qeth_get_adapter_cmd(card, IPA_SETADP_QUERY_COMMANDS_SUPPORTED, 25554a71df50SFrank Blaschka sizeof(struct qeth_ipacmd_setadpparms)); 25564a71df50SFrank Blaschka rc = qeth_send_ipa_cmd(card, iob, qeth_query_setadapterparms_cb, NULL); 25574a71df50SFrank Blaschka return rc; 25584a71df50SFrank Blaschka } 25594a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_query_setadapterparms); 25604a71df50SFrank Blaschka 25614a71df50SFrank Blaschka int qeth_check_qdio_errors(struct qdio_buffer *buf, unsigned int qdio_error, 25624a71df50SFrank Blaschka unsigned int siga_error, const char *dbftext) 25634a71df50SFrank Blaschka { 25644a71df50SFrank Blaschka if (qdio_error || siga_error) { 2565d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, dbftext); 2566d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(QERR, 2, dbftext); 2567d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(QERR, 2, " F15=%02X", 25684a71df50SFrank Blaschka buf->element[15].flags & 0xff); 2569d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(QERR, 2, " F14=%02X", 25704a71df50SFrank Blaschka buf->element[14].flags & 0xff); 2571d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(QERR, 2, " qerr=%X", qdio_error); 2572d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(QERR, 2, " serr=%X", siga_error); 25734a71df50SFrank Blaschka return 1; 25744a71df50SFrank Blaschka } 25754a71df50SFrank Blaschka return 0; 25764a71df50SFrank Blaschka } 25774a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_check_qdio_errors); 25784a71df50SFrank Blaschka 25794a71df50SFrank Blaschka void qeth_queue_input_buffer(struct qeth_card *card, int index) 25804a71df50SFrank Blaschka { 25814a71df50SFrank Blaschka struct qeth_qdio_q *queue = card->qdio.in_q; 25824a71df50SFrank Blaschka int count; 25834a71df50SFrank Blaschka int i; 25844a71df50SFrank Blaschka int rc; 25854a71df50SFrank Blaschka int newcount = 0; 25864a71df50SFrank Blaschka 25874a71df50SFrank Blaschka count = (index < queue->next_buf_to_init)? 25884a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count - 25894a71df50SFrank Blaschka (queue->next_buf_to_init - index) : 25904a71df50SFrank Blaschka card->qdio.in_buf_pool.buf_count - 25914a71df50SFrank Blaschka (queue->next_buf_to_init + QDIO_MAX_BUFFERS_PER_Q - index); 25924a71df50SFrank Blaschka /* only requeue at a certain threshold to avoid SIGAs */ 25934a71df50SFrank Blaschka if (count >= QETH_IN_BUF_REQUEUE_THRESHOLD(card)) { 25944a71df50SFrank Blaschka for (i = queue->next_buf_to_init; 25954a71df50SFrank Blaschka i < queue->next_buf_to_init + count; ++i) { 25964a71df50SFrank Blaschka if (qeth_init_input_buffer(card, 25974a71df50SFrank Blaschka &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q])) { 25984a71df50SFrank Blaschka break; 25994a71df50SFrank Blaschka } else { 26004a71df50SFrank Blaschka newcount++; 26014a71df50SFrank Blaschka } 26024a71df50SFrank Blaschka } 26034a71df50SFrank Blaschka 26044a71df50SFrank Blaschka if (newcount < count) { 26054a71df50SFrank Blaschka /* we are in memory shortage so we switch back to 26064a71df50SFrank Blaschka traditional skb allocation and drop packages */ 26074a71df50SFrank Blaschka atomic_set(&card->force_alloc_skb, 3); 26084a71df50SFrank Blaschka count = newcount; 26094a71df50SFrank Blaschka } else { 26104a71df50SFrank Blaschka atomic_add_unless(&card->force_alloc_skb, -1, 0); 26114a71df50SFrank Blaschka } 26124a71df50SFrank Blaschka 26134a71df50SFrank Blaschka /* 26144a71df50SFrank Blaschka * according to old code it should be avoided to requeue all 26154a71df50SFrank Blaschka * 128 buffers in order to benefit from PCI avoidance. 26164a71df50SFrank Blaschka * this function keeps at least one buffer (the buffer at 26174a71df50SFrank Blaschka * 'index') un-requeued -> this buffer is the first buffer that 26184a71df50SFrank Blaschka * will be requeued the next time 26194a71df50SFrank Blaschka */ 26204a71df50SFrank Blaschka if (card->options.performance_stats) { 26214a71df50SFrank Blaschka card->perf_stats.inbound_do_qdio_cnt++; 26224a71df50SFrank Blaschka card->perf_stats.inbound_do_qdio_start_time = 26234a71df50SFrank Blaschka qeth_get_micros(); 26244a71df50SFrank Blaschka } 26254a71df50SFrank Blaschka rc = do_QDIO(CARD_DDEV(card), 26264a71df50SFrank Blaschka QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT, 26274a71df50SFrank Blaschka 0, queue->next_buf_to_init, count, NULL); 26284a71df50SFrank Blaschka if (card->options.performance_stats) 26294a71df50SFrank Blaschka card->perf_stats.inbound_do_qdio_time += 26304a71df50SFrank Blaschka qeth_get_micros() - 26314a71df50SFrank Blaschka card->perf_stats.inbound_do_qdio_start_time; 26324a71df50SFrank Blaschka if (rc) { 26334a71df50SFrank Blaschka PRINT_WARN("qeth_queue_input_buffer's do_QDIO " 26344a71df50SFrank Blaschka "return %i (device %s).\n", 26354a71df50SFrank Blaschka rc, CARD_DDEV_ID(card)); 2636d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "qinberr"); 2637d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card)); 26384a71df50SFrank Blaschka } 26394a71df50SFrank Blaschka queue->next_buf_to_init = (queue->next_buf_to_init + count) % 26404a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 26414a71df50SFrank Blaschka } 26424a71df50SFrank Blaschka } 26434a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_queue_input_buffer); 26444a71df50SFrank Blaschka 26454a71df50SFrank Blaschka static int qeth_handle_send_error(struct qeth_card *card, 26464a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer, unsigned int qdio_err, 26474a71df50SFrank Blaschka unsigned int siga_err) 26484a71df50SFrank Blaschka { 26494a71df50SFrank Blaschka int sbalf15 = buffer->buffer->element[15].flags & 0xff; 26504a71df50SFrank Blaschka int cc = siga_err & 3; 26514a71df50SFrank Blaschka 2652d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "hdsnderr"); 26534a71df50SFrank Blaschka qeth_check_qdio_errors(buffer->buffer, qdio_err, siga_err, "qouterr"); 26544a71df50SFrank Blaschka switch (cc) { 26554a71df50SFrank Blaschka case 0: 26564a71df50SFrank Blaschka if (qdio_err) { 2657d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 1, "lnkfail"); 2658d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card)); 2659d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 1, "%04x %02x", 26604a71df50SFrank Blaschka (u16)qdio_err, (u8)sbalf15); 26614a71df50SFrank Blaschka return QETH_SEND_ERROR_LINK_FAILURE; 26624a71df50SFrank Blaschka } 26634a71df50SFrank Blaschka return QETH_SEND_ERROR_NONE; 26644a71df50SFrank Blaschka case 2: 26654a71df50SFrank Blaschka if (siga_err & QDIO_SIGA_ERROR_B_BIT_SET) { 2666d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 1, "SIGAcc2B"); 2667d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card)); 26684a71df50SFrank Blaschka return QETH_SEND_ERROR_KICK_IT; 26694a71df50SFrank Blaschka } 26704a71df50SFrank Blaschka if ((sbalf15 >= 15) && (sbalf15 <= 31)) 26714a71df50SFrank Blaschka return QETH_SEND_ERROR_RETRY; 26724a71df50SFrank Blaschka return QETH_SEND_ERROR_LINK_FAILURE; 26734a71df50SFrank Blaschka /* look at qdio_error and sbalf 15 */ 26744a71df50SFrank Blaschka case 1: 2675d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 1, "SIGAcc1"); 2676d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card)); 26774a71df50SFrank Blaschka return QETH_SEND_ERROR_LINK_FAILURE; 26784a71df50SFrank Blaschka case 3: 26794a71df50SFrank Blaschka default: 2680d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 1, "SIGAcc3"); 2681d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card)); 26824a71df50SFrank Blaschka return QETH_SEND_ERROR_KICK_IT; 26834a71df50SFrank Blaschka } 26844a71df50SFrank Blaschka } 26854a71df50SFrank Blaschka 26864a71df50SFrank Blaschka /* 26874a71df50SFrank Blaschka * Switched to packing state if the number of used buffers on a queue 26884a71df50SFrank Blaschka * reaches a certain limit. 26894a71df50SFrank Blaschka */ 26904a71df50SFrank Blaschka static void qeth_switch_to_packing_if_needed(struct qeth_qdio_out_q *queue) 26914a71df50SFrank Blaschka { 26924a71df50SFrank Blaschka if (!queue->do_pack) { 26934a71df50SFrank Blaschka if (atomic_read(&queue->used_buffers) 26944a71df50SFrank Blaschka >= QETH_HIGH_WATERMARK_PACK){ 26954a71df50SFrank Blaschka /* switch non-PACKING -> PACKING */ 2696d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "np->pack"); 26974a71df50SFrank Blaschka if (queue->card->options.performance_stats) 26984a71df50SFrank Blaschka queue->card->perf_stats.sc_dp_p++; 26994a71df50SFrank Blaschka queue->do_pack = 1; 27004a71df50SFrank Blaschka } 27014a71df50SFrank Blaschka } 27024a71df50SFrank Blaschka } 27034a71df50SFrank Blaschka 27044a71df50SFrank Blaschka /* 27054a71df50SFrank Blaschka * Switches from packing to non-packing mode. If there is a packing 27064a71df50SFrank Blaschka * buffer on the queue this buffer will be prepared to be flushed. 27074a71df50SFrank Blaschka * In that case 1 is returned to inform the caller. If no buffer 27084a71df50SFrank Blaschka * has to be flushed, zero is returned. 27094a71df50SFrank Blaschka */ 27104a71df50SFrank Blaschka static int qeth_switch_to_nonpacking_if_needed(struct qeth_qdio_out_q *queue) 27114a71df50SFrank Blaschka { 27124a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer; 27134a71df50SFrank Blaschka int flush_count = 0; 27144a71df50SFrank Blaschka 27154a71df50SFrank Blaschka if (queue->do_pack) { 27164a71df50SFrank Blaschka if (atomic_read(&queue->used_buffers) 27174a71df50SFrank Blaschka <= QETH_LOW_WATERMARK_PACK) { 27184a71df50SFrank Blaschka /* switch PACKING -> non-PACKING */ 2719d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "pack->np"); 27204a71df50SFrank Blaschka if (queue->card->options.performance_stats) 27214a71df50SFrank Blaschka queue->card->perf_stats.sc_p_dp++; 27224a71df50SFrank Blaschka queue->do_pack = 0; 27234a71df50SFrank Blaschka /* flush packing buffers */ 27244a71df50SFrank Blaschka buffer = &queue->bufs[queue->next_buf_to_fill]; 27254a71df50SFrank Blaschka if ((atomic_read(&buffer->state) == 27264a71df50SFrank Blaschka QETH_QDIO_BUF_EMPTY) && 27274a71df50SFrank Blaschka (buffer->next_element_to_fill > 0)) { 27284a71df50SFrank Blaschka atomic_set(&buffer->state, 27294a71df50SFrank Blaschka QETH_QDIO_BUF_PRIMED); 27304a71df50SFrank Blaschka flush_count++; 27314a71df50SFrank Blaschka queue->next_buf_to_fill = 27324a71df50SFrank Blaschka (queue->next_buf_to_fill + 1) % 27334a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 27344a71df50SFrank Blaschka } 27354a71df50SFrank Blaschka } 27364a71df50SFrank Blaschka } 27374a71df50SFrank Blaschka return flush_count; 27384a71df50SFrank Blaschka } 27394a71df50SFrank Blaschka 27404a71df50SFrank Blaschka /* 27414a71df50SFrank Blaschka * Called to flush a packing buffer if no more pci flags are on the queue. 27424a71df50SFrank Blaschka * Checks if there is a packing buffer and prepares it to be flushed. 27434a71df50SFrank Blaschka * In that case returns 1, otherwise zero. 27444a71df50SFrank Blaschka */ 27454a71df50SFrank Blaschka static int qeth_flush_buffers_on_no_pci(struct qeth_qdio_out_q *queue) 27464a71df50SFrank Blaschka { 27474a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer; 27484a71df50SFrank Blaschka 27494a71df50SFrank Blaschka buffer = &queue->bufs[queue->next_buf_to_fill]; 27504a71df50SFrank Blaschka if ((atomic_read(&buffer->state) == QETH_QDIO_BUF_EMPTY) && 27514a71df50SFrank Blaschka (buffer->next_element_to_fill > 0)) { 27524a71df50SFrank Blaschka /* it's a packing buffer */ 27534a71df50SFrank Blaschka atomic_set(&buffer->state, QETH_QDIO_BUF_PRIMED); 27544a71df50SFrank Blaschka queue->next_buf_to_fill = 27554a71df50SFrank Blaschka (queue->next_buf_to_fill + 1) % QDIO_MAX_BUFFERS_PER_Q; 27564a71df50SFrank Blaschka return 1; 27574a71df50SFrank Blaschka } 27584a71df50SFrank Blaschka return 0; 27594a71df50SFrank Blaschka } 27604a71df50SFrank Blaschka 27614a71df50SFrank Blaschka static void qeth_flush_buffers(struct qeth_qdio_out_q *queue, int under_int, 27624a71df50SFrank Blaschka int index, int count) 27634a71df50SFrank Blaschka { 27644a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buf; 27654a71df50SFrank Blaschka int rc; 27664a71df50SFrank Blaschka int i; 27674a71df50SFrank Blaschka unsigned int qdio_flags; 27684a71df50SFrank Blaschka 27694a71df50SFrank Blaschka for (i = index; i < index + count; ++i) { 27704a71df50SFrank Blaschka buf = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q]; 27714a71df50SFrank Blaschka buf->buffer->element[buf->next_element_to_fill - 1].flags |= 27724a71df50SFrank Blaschka SBAL_FLAGS_LAST_ENTRY; 27734a71df50SFrank Blaschka 27744a71df50SFrank Blaschka if (queue->card->info.type == QETH_CARD_TYPE_IQD) 27754a71df50SFrank Blaschka continue; 27764a71df50SFrank Blaschka 27774a71df50SFrank Blaschka if (!queue->do_pack) { 27784a71df50SFrank Blaschka if ((atomic_read(&queue->used_buffers) >= 27794a71df50SFrank Blaschka (QETH_HIGH_WATERMARK_PACK - 27804a71df50SFrank Blaschka QETH_WATERMARK_PACK_FUZZ)) && 27814a71df50SFrank Blaschka !atomic_read(&queue->set_pci_flags_count)) { 27824a71df50SFrank Blaschka /* it's likely that we'll go to packing 27834a71df50SFrank Blaschka * mode soon */ 27844a71df50SFrank Blaschka atomic_inc(&queue->set_pci_flags_count); 27854a71df50SFrank Blaschka buf->buffer->element[0].flags |= 0x40; 27864a71df50SFrank Blaschka } 27874a71df50SFrank Blaschka } else { 27884a71df50SFrank Blaschka if (!atomic_read(&queue->set_pci_flags_count)) { 27894a71df50SFrank Blaschka /* 27904a71df50SFrank Blaschka * there's no outstanding PCI any more, so we 27914a71df50SFrank Blaschka * have to request a PCI to be sure the the PCI 27924a71df50SFrank Blaschka * will wake at some time in the future then we 27934a71df50SFrank Blaschka * can flush packed buffers that might still be 27944a71df50SFrank Blaschka * hanging around, which can happen if no 27954a71df50SFrank Blaschka * further send was requested by the stack 27964a71df50SFrank Blaschka */ 27974a71df50SFrank Blaschka atomic_inc(&queue->set_pci_flags_count); 27984a71df50SFrank Blaschka buf->buffer->element[0].flags |= 0x40; 27994a71df50SFrank Blaschka } 28004a71df50SFrank Blaschka } 28014a71df50SFrank Blaschka } 28024a71df50SFrank Blaschka 28034a71df50SFrank Blaschka queue->card->dev->trans_start = jiffies; 28044a71df50SFrank Blaschka if (queue->card->options.performance_stats) { 28054a71df50SFrank Blaschka queue->card->perf_stats.outbound_do_qdio_cnt++; 28064a71df50SFrank Blaschka queue->card->perf_stats.outbound_do_qdio_start_time = 28074a71df50SFrank Blaschka qeth_get_micros(); 28084a71df50SFrank Blaschka } 28094a71df50SFrank Blaschka qdio_flags = QDIO_FLAG_SYNC_OUTPUT; 28104a71df50SFrank Blaschka if (under_int) 28114a71df50SFrank Blaschka qdio_flags |= QDIO_FLAG_UNDER_INTERRUPT; 28124a71df50SFrank Blaschka if (atomic_read(&queue->set_pci_flags_count)) 28134a71df50SFrank Blaschka qdio_flags |= QDIO_FLAG_PCI_OUT; 28144a71df50SFrank Blaschka rc = do_QDIO(CARD_DDEV(queue->card), qdio_flags, 28154a71df50SFrank Blaschka queue->queue_no, index, count, NULL); 28164a71df50SFrank Blaschka if (queue->card->options.performance_stats) 28174a71df50SFrank Blaschka queue->card->perf_stats.outbound_do_qdio_time += 28184a71df50SFrank Blaschka qeth_get_micros() - 28194a71df50SFrank Blaschka queue->card->perf_stats.outbound_do_qdio_start_time; 28204a71df50SFrank Blaschka if (rc) { 2821d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "flushbuf"); 2822d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, " err%d", rc); 2823d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_DDEV_ID(queue->card)); 28244a71df50SFrank Blaschka queue->card->stats.tx_errors += count; 28254a71df50SFrank Blaschka /* this must not happen under normal circumstances. if it 28264a71df50SFrank Blaschka * happens something is really wrong -> recover */ 28274a71df50SFrank Blaschka qeth_schedule_recovery(queue->card); 28284a71df50SFrank Blaschka return; 28294a71df50SFrank Blaschka } 28304a71df50SFrank Blaschka atomic_add(count, &queue->used_buffers); 28314a71df50SFrank Blaschka if (queue->card->options.performance_stats) 28324a71df50SFrank Blaschka queue->card->perf_stats.bufs_sent += count; 28334a71df50SFrank Blaschka } 28344a71df50SFrank Blaschka 28354a71df50SFrank Blaschka static void qeth_check_outbound_queue(struct qeth_qdio_out_q *queue) 28364a71df50SFrank Blaschka { 28374a71df50SFrank Blaschka int index; 28384a71df50SFrank Blaschka int flush_cnt = 0; 28394a71df50SFrank Blaschka int q_was_packing = 0; 28404a71df50SFrank Blaschka 28414a71df50SFrank Blaschka /* 28424a71df50SFrank Blaschka * check if weed have to switch to non-packing mode or if 28434a71df50SFrank Blaschka * we have to get a pci flag out on the queue 28444a71df50SFrank Blaschka */ 28454a71df50SFrank Blaschka if ((atomic_read(&queue->used_buffers) <= QETH_LOW_WATERMARK_PACK) || 28464a71df50SFrank Blaschka !atomic_read(&queue->set_pci_flags_count)) { 28474a71df50SFrank Blaschka if (atomic_xchg(&queue->state, QETH_OUT_Q_LOCKED_FLUSH) == 28484a71df50SFrank Blaschka QETH_OUT_Q_UNLOCKED) { 28494a71df50SFrank Blaschka /* 28504a71df50SFrank Blaschka * If we get in here, there was no action in 28514a71df50SFrank Blaschka * do_send_packet. So, we check if there is a 28524a71df50SFrank Blaschka * packing buffer to be flushed here. 28534a71df50SFrank Blaschka */ 28544a71df50SFrank Blaschka netif_stop_queue(queue->card->dev); 28554a71df50SFrank Blaschka index = queue->next_buf_to_fill; 28564a71df50SFrank Blaschka q_was_packing = queue->do_pack; 28574a71df50SFrank Blaschka /* queue->do_pack may change */ 28584a71df50SFrank Blaschka barrier(); 28594a71df50SFrank Blaschka flush_cnt += qeth_switch_to_nonpacking_if_needed(queue); 28604a71df50SFrank Blaschka if (!flush_cnt && 28614a71df50SFrank Blaschka !atomic_read(&queue->set_pci_flags_count)) 28624a71df50SFrank Blaschka flush_cnt += 28634a71df50SFrank Blaschka qeth_flush_buffers_on_no_pci(queue); 28644a71df50SFrank Blaschka if (queue->card->options.performance_stats && 28654a71df50SFrank Blaschka q_was_packing) 28664a71df50SFrank Blaschka queue->card->perf_stats.bufs_sent_pack += 28674a71df50SFrank Blaschka flush_cnt; 28684a71df50SFrank Blaschka if (flush_cnt) 28694a71df50SFrank Blaschka qeth_flush_buffers(queue, 1, index, flush_cnt); 28704a71df50SFrank Blaschka atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 28714a71df50SFrank Blaschka } 28724a71df50SFrank Blaschka } 28734a71df50SFrank Blaschka } 28744a71df50SFrank Blaschka 28754a71df50SFrank Blaschka void qeth_qdio_output_handler(struct ccw_device *ccwdev, unsigned int status, 28764a71df50SFrank Blaschka unsigned int qdio_error, unsigned int siga_error, 28774a71df50SFrank Blaschka unsigned int __queue, int first_element, int count, 28784a71df50SFrank Blaschka unsigned long card_ptr) 28794a71df50SFrank Blaschka { 28804a71df50SFrank Blaschka struct qeth_card *card = (struct qeth_card *) card_ptr; 28814a71df50SFrank Blaschka struct qeth_qdio_out_q *queue = card->qdio.out_qs[__queue]; 28824a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer; 28834a71df50SFrank Blaschka int i; 28844a71df50SFrank Blaschka 2885d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "qdouhdl"); 28864a71df50SFrank Blaschka if (status & QDIO_STATUS_LOOK_FOR_ERROR) { 28874a71df50SFrank Blaschka if (status & QDIO_STATUS_ACTIVATE_CHECK_CONDITION) { 2888d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "achkcond"); 2889d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card)); 2890d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, "%08x", status); 28914a71df50SFrank Blaschka netif_stop_queue(card->dev); 28924a71df50SFrank Blaschka qeth_schedule_recovery(card); 28934a71df50SFrank Blaschka return; 28944a71df50SFrank Blaschka } 28954a71df50SFrank Blaschka } 28964a71df50SFrank Blaschka if (card->options.performance_stats) { 28974a71df50SFrank Blaschka card->perf_stats.outbound_handler_cnt++; 28984a71df50SFrank Blaschka card->perf_stats.outbound_handler_start_time = 28994a71df50SFrank Blaschka qeth_get_micros(); 29004a71df50SFrank Blaschka } 29014a71df50SFrank Blaschka for (i = first_element; i < (first_element + count); ++i) { 29024a71df50SFrank Blaschka buffer = &queue->bufs[i % QDIO_MAX_BUFFERS_PER_Q]; 29034a71df50SFrank Blaschka /*we only handle the KICK_IT error by doing a recovery */ 29044a71df50SFrank Blaschka if (qeth_handle_send_error(card, buffer, 29054a71df50SFrank Blaschka qdio_error, siga_error) 29064a71df50SFrank Blaschka == QETH_SEND_ERROR_KICK_IT){ 29074a71df50SFrank Blaschka netif_stop_queue(card->dev); 29084a71df50SFrank Blaschka qeth_schedule_recovery(card); 29094a71df50SFrank Blaschka return; 29104a71df50SFrank Blaschka } 29114a71df50SFrank Blaschka qeth_clear_output_buffer(queue, buffer); 29124a71df50SFrank Blaschka } 29134a71df50SFrank Blaschka atomic_sub(count, &queue->used_buffers); 29144a71df50SFrank Blaschka /* check if we need to do something on this outbound queue */ 29154a71df50SFrank Blaschka if (card->info.type != QETH_CARD_TYPE_IQD) 29164a71df50SFrank Blaschka qeth_check_outbound_queue(queue); 29174a71df50SFrank Blaschka 29184a71df50SFrank Blaschka netif_wake_queue(queue->card->dev); 29194a71df50SFrank Blaschka if (card->options.performance_stats) 29204a71df50SFrank Blaschka card->perf_stats.outbound_handler_time += qeth_get_micros() - 29214a71df50SFrank Blaschka card->perf_stats.outbound_handler_start_time; 29224a71df50SFrank Blaschka } 29234a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_qdio_output_handler); 29244a71df50SFrank Blaschka 29254a71df50SFrank Blaschka int qeth_get_cast_type(struct qeth_card *card, struct sk_buff *skb) 29264a71df50SFrank Blaschka { 29274a71df50SFrank Blaschka int cast_type = RTN_UNSPEC; 29284a71df50SFrank Blaschka 29294a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) 29304a71df50SFrank Blaschka return cast_type; 29314a71df50SFrank Blaschka 29324a71df50SFrank Blaschka if (skb->dst && skb->dst->neighbour) { 29334a71df50SFrank Blaschka cast_type = skb->dst->neighbour->type; 29344a71df50SFrank Blaschka if ((cast_type == RTN_BROADCAST) || 29354a71df50SFrank Blaschka (cast_type == RTN_MULTICAST) || 29364a71df50SFrank Blaschka (cast_type == RTN_ANYCAST)) 29374a71df50SFrank Blaschka return cast_type; 29384a71df50SFrank Blaschka else 29394a71df50SFrank Blaschka return RTN_UNSPEC; 29404a71df50SFrank Blaschka } 29414a71df50SFrank Blaschka /* try something else */ 29424a71df50SFrank Blaschka if (skb->protocol == ETH_P_IPV6) 29434a71df50SFrank Blaschka return (skb_network_header(skb)[24] == 0xff) ? 29444a71df50SFrank Blaschka RTN_MULTICAST : 0; 29454a71df50SFrank Blaschka else if (skb->protocol == ETH_P_IP) 29464a71df50SFrank Blaschka return ((skb_network_header(skb)[16] & 0xf0) == 0xe0) ? 29474a71df50SFrank Blaschka RTN_MULTICAST : 0; 29484a71df50SFrank Blaschka /* ... */ 29494a71df50SFrank Blaschka if (!memcmp(skb->data, skb->dev->broadcast, 6)) 29504a71df50SFrank Blaschka return RTN_BROADCAST; 29514a71df50SFrank Blaschka else { 29524a71df50SFrank Blaschka u16 hdr_mac; 29534a71df50SFrank Blaschka 29544a71df50SFrank Blaschka hdr_mac = *((u16 *)skb->data); 29554a71df50SFrank Blaschka /* tr multicast? */ 29564a71df50SFrank Blaschka switch (card->info.link_type) { 29574a71df50SFrank Blaschka case QETH_LINK_TYPE_HSTR: 29584a71df50SFrank Blaschka case QETH_LINK_TYPE_LANE_TR: 29594a71df50SFrank Blaschka if ((hdr_mac == QETH_TR_MAC_NC) || 29604a71df50SFrank Blaschka (hdr_mac == QETH_TR_MAC_C)) 29614a71df50SFrank Blaschka return RTN_MULTICAST; 29624a71df50SFrank Blaschka break; 29634a71df50SFrank Blaschka /* eth or so multicast? */ 29644a71df50SFrank Blaschka default: 29654a71df50SFrank Blaschka if ((hdr_mac == QETH_ETH_MAC_V4) || 29664a71df50SFrank Blaschka (hdr_mac == QETH_ETH_MAC_V6)) 29674a71df50SFrank Blaschka return RTN_MULTICAST; 29684a71df50SFrank Blaschka } 29694a71df50SFrank Blaschka } 29704a71df50SFrank Blaschka return cast_type; 29714a71df50SFrank Blaschka } 29724a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_cast_type); 29734a71df50SFrank Blaschka 29744a71df50SFrank Blaschka int qeth_get_priority_queue(struct qeth_card *card, struct sk_buff *skb, 29754a71df50SFrank Blaschka int ipv, int cast_type) 29764a71df50SFrank Blaschka { 29774a71df50SFrank Blaschka if (!ipv && (card->info.type == QETH_CARD_TYPE_OSAE)) 29784a71df50SFrank Blaschka return card->qdio.default_out_queue; 29794a71df50SFrank Blaschka switch (card->qdio.no_out_queues) { 29804a71df50SFrank Blaschka case 4: 29814a71df50SFrank Blaschka if (cast_type && card->info.is_multicast_different) 29824a71df50SFrank Blaschka return card->info.is_multicast_different & 29834a71df50SFrank Blaschka (card->qdio.no_out_queues - 1); 29844a71df50SFrank Blaschka if (card->qdio.do_prio_queueing && (ipv == 4)) { 29854a71df50SFrank Blaschka const u8 tos = ip_hdr(skb)->tos; 29864a71df50SFrank Blaschka 29874a71df50SFrank Blaschka if (card->qdio.do_prio_queueing == 29884a71df50SFrank Blaschka QETH_PRIO_Q_ING_TOS) { 29894a71df50SFrank Blaschka if (tos & IP_TOS_NOTIMPORTANT) 29904a71df50SFrank Blaschka return 3; 29914a71df50SFrank Blaschka if (tos & IP_TOS_HIGHRELIABILITY) 29924a71df50SFrank Blaschka return 2; 29934a71df50SFrank Blaschka if (tos & IP_TOS_HIGHTHROUGHPUT) 29944a71df50SFrank Blaschka return 1; 29954a71df50SFrank Blaschka if (tos & IP_TOS_LOWDELAY) 29964a71df50SFrank Blaschka return 0; 29974a71df50SFrank Blaschka } 29984a71df50SFrank Blaschka if (card->qdio.do_prio_queueing == 29994a71df50SFrank Blaschka QETH_PRIO_Q_ING_PREC) 30004a71df50SFrank Blaschka return 3 - (tos >> 6); 30014a71df50SFrank Blaschka } else if (card->qdio.do_prio_queueing && (ipv == 6)) { 30024a71df50SFrank Blaschka /* TODO: IPv6!!! */ 30034a71df50SFrank Blaschka } 30044a71df50SFrank Blaschka return card->qdio.default_out_queue; 30054a71df50SFrank Blaschka case 1: /* fallthrough for single-out-queue 1920-device */ 30064a71df50SFrank Blaschka default: 30074a71df50SFrank Blaschka return card->qdio.default_out_queue; 30084a71df50SFrank Blaschka } 30094a71df50SFrank Blaschka } 30104a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_priority_queue); 30114a71df50SFrank Blaschka 30124a71df50SFrank Blaschka int qeth_get_elements_no(struct qeth_card *card, void *hdr, 30134a71df50SFrank Blaschka struct sk_buff *skb, int elems) 30144a71df50SFrank Blaschka { 30154a71df50SFrank Blaschka int elements_needed = 0; 30164a71df50SFrank Blaschka 30174a71df50SFrank Blaschka if (skb_shinfo(skb)->nr_frags > 0) 30184a71df50SFrank Blaschka elements_needed = (skb_shinfo(skb)->nr_frags + 1); 30194a71df50SFrank Blaschka if (elements_needed == 0) 30204a71df50SFrank Blaschka elements_needed = 1 + (((((unsigned long) hdr) % PAGE_SIZE) 30214a71df50SFrank Blaschka + skb->len) >> PAGE_SHIFT); 30224a71df50SFrank Blaschka if ((elements_needed + elems) > QETH_MAX_BUFFER_ELEMENTS(card)) { 302314cc21b6SFrank Blaschka QETH_DBF_MESSAGE(2, "Invalid size of IP packet " 30244a71df50SFrank Blaschka "(Number=%d / Length=%d). Discarded.\n", 30254a71df50SFrank Blaschka (elements_needed+elems), skb->len); 30264a71df50SFrank Blaschka return 0; 30274a71df50SFrank Blaschka } 30284a71df50SFrank Blaschka return elements_needed; 30294a71df50SFrank Blaschka } 30304a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_elements_no); 30314a71df50SFrank Blaschka 3032f90b744eSFrank Blaschka static inline void __qeth_fill_buffer(struct sk_buff *skb, 3033f90b744eSFrank Blaschka struct qdio_buffer *buffer, int is_tso, int *next_element_to_fill) 30344a71df50SFrank Blaschka { 30354a71df50SFrank Blaschka int length = skb->len; 30364a71df50SFrank Blaschka int length_here; 30374a71df50SFrank Blaschka int element; 30384a71df50SFrank Blaschka char *data; 30394a71df50SFrank Blaschka int first_lap ; 30404a71df50SFrank Blaschka 30414a71df50SFrank Blaschka element = *next_element_to_fill; 30424a71df50SFrank Blaschka data = skb->data; 30434a71df50SFrank Blaschka first_lap = (is_tso == 0 ? 1 : 0); 30444a71df50SFrank Blaschka 30454a71df50SFrank Blaschka while (length > 0) { 30464a71df50SFrank Blaschka /* length_here is the remaining amount of data in this page */ 30474a71df50SFrank Blaschka length_here = PAGE_SIZE - ((unsigned long) data % PAGE_SIZE); 30484a71df50SFrank Blaschka if (length < length_here) 30494a71df50SFrank Blaschka length_here = length; 30504a71df50SFrank Blaschka 30514a71df50SFrank Blaschka buffer->element[element].addr = data; 30524a71df50SFrank Blaschka buffer->element[element].length = length_here; 30534a71df50SFrank Blaschka length -= length_here; 30544a71df50SFrank Blaschka if (!length) { 30554a71df50SFrank Blaschka if (first_lap) 30564a71df50SFrank Blaschka buffer->element[element].flags = 0; 30574a71df50SFrank Blaschka else 30584a71df50SFrank Blaschka buffer->element[element].flags = 30594a71df50SFrank Blaschka SBAL_FLAGS_LAST_FRAG; 30604a71df50SFrank Blaschka } else { 30614a71df50SFrank Blaschka if (first_lap) 30624a71df50SFrank Blaschka buffer->element[element].flags = 30634a71df50SFrank Blaschka SBAL_FLAGS_FIRST_FRAG; 30644a71df50SFrank Blaschka else 30654a71df50SFrank Blaschka buffer->element[element].flags = 30664a71df50SFrank Blaschka SBAL_FLAGS_MIDDLE_FRAG; 30674a71df50SFrank Blaschka } 30684a71df50SFrank Blaschka data += length_here; 30694a71df50SFrank Blaschka element++; 30704a71df50SFrank Blaschka first_lap = 0; 30714a71df50SFrank Blaschka } 30724a71df50SFrank Blaschka *next_element_to_fill = element; 30734a71df50SFrank Blaschka } 30744a71df50SFrank Blaschka 3075f90b744eSFrank Blaschka static inline int qeth_fill_buffer(struct qeth_qdio_out_q *queue, 30764a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buf, struct sk_buff *skb) 30774a71df50SFrank Blaschka { 30784a71df50SFrank Blaschka struct qdio_buffer *buffer; 30794a71df50SFrank Blaschka struct qeth_hdr_tso *hdr; 30804a71df50SFrank Blaschka int flush_cnt = 0, hdr_len, large_send = 0; 30814a71df50SFrank Blaschka 30824a71df50SFrank Blaschka buffer = buf->buffer; 30834a71df50SFrank Blaschka atomic_inc(&skb->users); 30844a71df50SFrank Blaschka skb_queue_tail(&buf->skb_list, skb); 30854a71df50SFrank Blaschka 30864a71df50SFrank Blaschka hdr = (struct qeth_hdr_tso *) skb->data; 30874a71df50SFrank Blaschka /*check first on TSO ....*/ 30884a71df50SFrank Blaschka if (hdr->hdr.hdr.l3.id == QETH_HEADER_TYPE_TSO) { 30894a71df50SFrank Blaschka int element = buf->next_element_to_fill; 30904a71df50SFrank Blaschka 30914a71df50SFrank Blaschka hdr_len = sizeof(struct qeth_hdr_tso) + hdr->ext.dg_hdr_len; 30924a71df50SFrank Blaschka /*fill first buffer entry only with header information */ 30934a71df50SFrank Blaschka buffer->element[element].addr = skb->data; 30944a71df50SFrank Blaschka buffer->element[element].length = hdr_len; 30954a71df50SFrank Blaschka buffer->element[element].flags = SBAL_FLAGS_FIRST_FRAG; 30964a71df50SFrank Blaschka buf->next_element_to_fill++; 30974a71df50SFrank Blaschka skb->data += hdr_len; 30984a71df50SFrank Blaschka skb->len -= hdr_len; 30994a71df50SFrank Blaschka large_send = 1; 31004a71df50SFrank Blaschka } 31014a71df50SFrank Blaschka if (skb_shinfo(skb)->nr_frags == 0) 31024a71df50SFrank Blaschka __qeth_fill_buffer(skb, buffer, large_send, 31034a71df50SFrank Blaschka (int *)&buf->next_element_to_fill); 31044a71df50SFrank Blaschka else 31054a71df50SFrank Blaschka __qeth_fill_buffer_frag(skb, buffer, large_send, 31064a71df50SFrank Blaschka (int *)&buf->next_element_to_fill); 31074a71df50SFrank Blaschka 31084a71df50SFrank Blaschka if (!queue->do_pack) { 3109d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "fillbfnp"); 31104a71df50SFrank Blaschka /* set state to PRIMED -> will be flushed */ 31114a71df50SFrank Blaschka atomic_set(&buf->state, QETH_QDIO_BUF_PRIMED); 31124a71df50SFrank Blaschka flush_cnt = 1; 31134a71df50SFrank Blaschka } else { 3114d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 6, "fillbfpa"); 31154a71df50SFrank Blaschka if (queue->card->options.performance_stats) 31164a71df50SFrank Blaschka queue->card->perf_stats.skbs_sent_pack++; 31174a71df50SFrank Blaschka if (buf->next_element_to_fill >= 31184a71df50SFrank Blaschka QETH_MAX_BUFFER_ELEMENTS(queue->card)) { 31194a71df50SFrank Blaschka /* 31204a71df50SFrank Blaschka * packed buffer if full -> set state PRIMED 31214a71df50SFrank Blaschka * -> will be flushed 31224a71df50SFrank Blaschka */ 31234a71df50SFrank Blaschka atomic_set(&buf->state, QETH_QDIO_BUF_PRIMED); 31244a71df50SFrank Blaschka flush_cnt = 1; 31254a71df50SFrank Blaschka } 31264a71df50SFrank Blaschka } 31274a71df50SFrank Blaschka return flush_cnt; 31284a71df50SFrank Blaschka } 31294a71df50SFrank Blaschka 31304a71df50SFrank Blaschka int qeth_do_send_packet_fast(struct qeth_card *card, 31314a71df50SFrank Blaschka struct qeth_qdio_out_q *queue, struct sk_buff *skb, 31324a71df50SFrank Blaschka struct qeth_hdr *hdr, int elements_needed, 31334a71df50SFrank Blaschka struct qeth_eddp_context *ctx) 31344a71df50SFrank Blaschka { 31354a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer; 31364a71df50SFrank Blaschka int buffers_needed = 0; 31374a71df50SFrank Blaschka int flush_cnt = 0; 31384a71df50SFrank Blaschka int index; 31394a71df50SFrank Blaschka 31404a71df50SFrank Blaschka /* spin until we get the queue ... */ 31414a71df50SFrank Blaschka while (atomic_cmpxchg(&queue->state, QETH_OUT_Q_UNLOCKED, 31424a71df50SFrank Blaschka QETH_OUT_Q_LOCKED) != QETH_OUT_Q_UNLOCKED); 31434a71df50SFrank Blaschka /* ... now we've got the queue */ 31444a71df50SFrank Blaschka index = queue->next_buf_to_fill; 31454a71df50SFrank Blaschka buffer = &queue->bufs[queue->next_buf_to_fill]; 31464a71df50SFrank Blaschka /* 31474a71df50SFrank Blaschka * check if buffer is empty to make sure that we do not 'overtake' 31484a71df50SFrank Blaschka * ourselves and try to fill a buffer that is already primed 31494a71df50SFrank Blaschka */ 31504a71df50SFrank Blaschka if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY) 31514a71df50SFrank Blaschka goto out; 31524a71df50SFrank Blaschka if (ctx == NULL) 31534a71df50SFrank Blaschka queue->next_buf_to_fill = (queue->next_buf_to_fill + 1) % 31544a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 31554a71df50SFrank Blaschka else { 31564a71df50SFrank Blaschka buffers_needed = qeth_eddp_check_buffers_for_context(queue, 31574a71df50SFrank Blaschka ctx); 31584a71df50SFrank Blaschka if (buffers_needed < 0) 31594a71df50SFrank Blaschka goto out; 31604a71df50SFrank Blaschka queue->next_buf_to_fill = 31614a71df50SFrank Blaschka (queue->next_buf_to_fill + buffers_needed) % 31624a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 31634a71df50SFrank Blaschka } 31644a71df50SFrank Blaschka atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 31654a71df50SFrank Blaschka if (ctx == NULL) { 31664a71df50SFrank Blaschka qeth_fill_buffer(queue, buffer, skb); 31674a71df50SFrank Blaschka qeth_flush_buffers(queue, 0, index, 1); 31684a71df50SFrank Blaschka } else { 31694a71df50SFrank Blaschka flush_cnt = qeth_eddp_fill_buffer(queue, ctx, index); 31704a71df50SFrank Blaschka WARN_ON(buffers_needed != flush_cnt); 31714a71df50SFrank Blaschka qeth_flush_buffers(queue, 0, index, flush_cnt); 31724a71df50SFrank Blaschka } 31734a71df50SFrank Blaschka return 0; 31744a71df50SFrank Blaschka out: 31754a71df50SFrank Blaschka atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 31764a71df50SFrank Blaschka return -EBUSY; 31774a71df50SFrank Blaschka } 31784a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_do_send_packet_fast); 31794a71df50SFrank Blaschka 31804a71df50SFrank Blaschka int qeth_do_send_packet(struct qeth_card *card, struct qeth_qdio_out_q *queue, 31814a71df50SFrank Blaschka struct sk_buff *skb, struct qeth_hdr *hdr, 31824a71df50SFrank Blaschka int elements_needed, struct qeth_eddp_context *ctx) 31834a71df50SFrank Blaschka { 31844a71df50SFrank Blaschka struct qeth_qdio_out_buffer *buffer; 31854a71df50SFrank Blaschka int start_index; 31864a71df50SFrank Blaschka int flush_count = 0; 31874a71df50SFrank Blaschka int do_pack = 0; 31884a71df50SFrank Blaschka int tmp; 31894a71df50SFrank Blaschka int rc = 0; 31904a71df50SFrank Blaschka 31914a71df50SFrank Blaschka /* spin until we get the queue ... */ 31924a71df50SFrank Blaschka while (atomic_cmpxchg(&queue->state, QETH_OUT_Q_UNLOCKED, 31934a71df50SFrank Blaschka QETH_OUT_Q_LOCKED) != QETH_OUT_Q_UNLOCKED); 31944a71df50SFrank Blaschka start_index = queue->next_buf_to_fill; 31954a71df50SFrank Blaschka buffer = &queue->bufs[queue->next_buf_to_fill]; 31964a71df50SFrank Blaschka /* 31974a71df50SFrank Blaschka * check if buffer is empty to make sure that we do not 'overtake' 31984a71df50SFrank Blaschka * ourselves and try to fill a buffer that is already primed 31994a71df50SFrank Blaschka */ 32004a71df50SFrank Blaschka if (atomic_read(&buffer->state) != QETH_QDIO_BUF_EMPTY) { 32014a71df50SFrank Blaschka atomic_set(&queue->state, QETH_OUT_Q_UNLOCKED); 32024a71df50SFrank Blaschka return -EBUSY; 32034a71df50SFrank Blaschka } 32044a71df50SFrank Blaschka /* check if we need to switch packing state of this queue */ 32054a71df50SFrank Blaschka qeth_switch_to_packing_if_needed(queue); 32064a71df50SFrank Blaschka if (queue->do_pack) { 32074a71df50SFrank Blaschka do_pack = 1; 32084a71df50SFrank Blaschka if (ctx == NULL) { 32094a71df50SFrank Blaschka /* does packet fit in current buffer? */ 32104a71df50SFrank Blaschka if ((QETH_MAX_BUFFER_ELEMENTS(card) - 32114a71df50SFrank Blaschka buffer->next_element_to_fill) < elements_needed) { 32124a71df50SFrank Blaschka /* ... no -> set state PRIMED */ 32134a71df50SFrank Blaschka atomic_set(&buffer->state, 32144a71df50SFrank Blaschka QETH_QDIO_BUF_PRIMED); 32154a71df50SFrank Blaschka flush_count++; 32164a71df50SFrank Blaschka queue->next_buf_to_fill = 32174a71df50SFrank Blaschka (queue->next_buf_to_fill + 1) % 32184a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 32194a71df50SFrank Blaschka buffer = &queue->bufs[queue->next_buf_to_fill]; 32204a71df50SFrank Blaschka /* we did a step forward, so check buffer state 32214a71df50SFrank Blaschka * again */ 32224a71df50SFrank Blaschka if (atomic_read(&buffer->state) != 32234a71df50SFrank Blaschka QETH_QDIO_BUF_EMPTY){ 32244a71df50SFrank Blaschka qeth_flush_buffers(queue, 0, 32254a71df50SFrank Blaschka start_index, flush_count); 32264a71df50SFrank Blaschka atomic_set(&queue->state, 32274a71df50SFrank Blaschka QETH_OUT_Q_UNLOCKED); 32284a71df50SFrank Blaschka return -EBUSY; 32294a71df50SFrank Blaschka } 32304a71df50SFrank Blaschka } 32314a71df50SFrank Blaschka } else { 32324a71df50SFrank Blaschka /* check if we have enough elements (including following 32334a71df50SFrank Blaschka * free buffers) to handle eddp context */ 32344a71df50SFrank Blaschka if (qeth_eddp_check_buffers_for_context(queue, ctx) 32354a71df50SFrank Blaschka < 0) { 32364a71df50SFrank Blaschka rc = -EBUSY; 32374a71df50SFrank Blaschka goto out; 32384a71df50SFrank Blaschka } 32394a71df50SFrank Blaschka } 32404a71df50SFrank Blaschka } 32414a71df50SFrank Blaschka if (ctx == NULL) 32424a71df50SFrank Blaschka tmp = qeth_fill_buffer(queue, buffer, skb); 32434a71df50SFrank Blaschka else { 32444a71df50SFrank Blaschka tmp = qeth_eddp_fill_buffer(queue, ctx, 32454a71df50SFrank Blaschka queue->next_buf_to_fill); 32464a71df50SFrank Blaschka if (tmp < 0) { 32474a71df50SFrank Blaschka rc = -EBUSY; 32484a71df50SFrank Blaschka goto out; 32494a71df50SFrank Blaschka } 32504a71df50SFrank Blaschka } 32514a71df50SFrank Blaschka queue->next_buf_to_fill = (queue->next_buf_to_fill + tmp) % 32524a71df50SFrank Blaschka QDIO_MAX_BUFFERS_PER_Q; 32534a71df50SFrank Blaschka flush_count += tmp; 32544a71df50SFrank Blaschka out: 32554a71df50SFrank Blaschka if (flush_count) 32564a71df50SFrank Blaschka qeth_flush_buffers(queue, 0, start_index, flush_count); 32574a71df50SFrank Blaschka else if (!atomic_read(&queue->set_pci_flags_count)) 32584a71df50SFrank Blaschka atomic_xchg(&queue->state, QETH_OUT_Q_LOCKED_FLUSH); 32594a71df50SFrank Blaschka /* 32604a71df50SFrank Blaschka * queue->state will go from LOCKED -> UNLOCKED or from 32614a71df50SFrank Blaschka * LOCKED_FLUSH -> LOCKED if output_handler wanted to 'notify' us 32624a71df50SFrank Blaschka * (switch packing state or flush buffer to get another pci flag out). 32634a71df50SFrank Blaschka * In that case we will enter this loop 32644a71df50SFrank Blaschka */ 32654a71df50SFrank Blaschka while (atomic_dec_return(&queue->state)) { 32664a71df50SFrank Blaschka flush_count = 0; 32674a71df50SFrank Blaschka start_index = queue->next_buf_to_fill; 32684a71df50SFrank Blaschka /* check if we can go back to non-packing state */ 32694a71df50SFrank Blaschka flush_count += qeth_switch_to_nonpacking_if_needed(queue); 32704a71df50SFrank Blaschka /* 32714a71df50SFrank Blaschka * check if we need to flush a packing buffer to get a pci 32724a71df50SFrank Blaschka * flag out on the queue 32734a71df50SFrank Blaschka */ 32744a71df50SFrank Blaschka if (!flush_count && !atomic_read(&queue->set_pci_flags_count)) 32754a71df50SFrank Blaschka flush_count += qeth_flush_buffers_on_no_pci(queue); 32764a71df50SFrank Blaschka if (flush_count) 32774a71df50SFrank Blaschka qeth_flush_buffers(queue, 0, start_index, flush_count); 32784a71df50SFrank Blaschka } 32794a71df50SFrank Blaschka /* at this point the queue is UNLOCKED again */ 32804a71df50SFrank Blaschka if (queue->card->options.performance_stats && do_pack) 32814a71df50SFrank Blaschka queue->card->perf_stats.bufs_sent_pack += flush_count; 32824a71df50SFrank Blaschka 32834a71df50SFrank Blaschka return rc; 32844a71df50SFrank Blaschka } 32854a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_do_send_packet); 32864a71df50SFrank Blaschka 32874a71df50SFrank Blaschka static int qeth_setadp_promisc_mode_cb(struct qeth_card *card, 32884a71df50SFrank Blaschka struct qeth_reply *reply, unsigned long data) 32894a71df50SFrank Blaschka { 32904a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 32914a71df50SFrank Blaschka struct qeth_ipacmd_setadpparms *setparms; 32924a71df50SFrank Blaschka 3293d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "prmadpcb"); 32944a71df50SFrank Blaschka 32954a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) data; 32964a71df50SFrank Blaschka setparms = &(cmd->data.setadapterparms); 32974a71df50SFrank Blaschka 32984a71df50SFrank Blaschka qeth_default_setadapterparms_cb(card, reply, (unsigned long)cmd); 32994a71df50SFrank Blaschka if (cmd->hdr.return_code) { 3300d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "prmrc%2.2x", cmd->hdr.return_code); 33014a71df50SFrank Blaschka setparms->data.mode = SET_PROMISC_MODE_OFF; 33024a71df50SFrank Blaschka } 33034a71df50SFrank Blaschka card->info.promisc_mode = setparms->data.mode; 33044a71df50SFrank Blaschka return 0; 33054a71df50SFrank Blaschka } 33064a71df50SFrank Blaschka 33074a71df50SFrank Blaschka void qeth_setadp_promisc_mode(struct qeth_card *card) 33084a71df50SFrank Blaschka { 33094a71df50SFrank Blaschka enum qeth_ipa_promisc_modes mode; 33104a71df50SFrank Blaschka struct net_device *dev = card->dev; 33114a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 33124a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 33134a71df50SFrank Blaschka 3314d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "setprom"); 33154a71df50SFrank Blaschka 33164a71df50SFrank Blaschka if (((dev->flags & IFF_PROMISC) && 33174a71df50SFrank Blaschka (card->info.promisc_mode == SET_PROMISC_MODE_ON)) || 33184a71df50SFrank Blaschka (!(dev->flags & IFF_PROMISC) && 33194a71df50SFrank Blaschka (card->info.promisc_mode == SET_PROMISC_MODE_OFF))) 33204a71df50SFrank Blaschka return; 33214a71df50SFrank Blaschka mode = SET_PROMISC_MODE_OFF; 33224a71df50SFrank Blaschka if (dev->flags & IFF_PROMISC) 33234a71df50SFrank Blaschka mode = SET_PROMISC_MODE_ON; 3324d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "mode:%x", mode); 33254a71df50SFrank Blaschka 33264a71df50SFrank Blaschka iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_PROMISC_MODE, 33274a71df50SFrank Blaschka sizeof(struct qeth_ipacmd_setadpparms)); 33284a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *)(iob->data + IPA_PDU_HEADER_SIZE); 33294a71df50SFrank Blaschka cmd->data.setadapterparms.data.mode = mode; 33304a71df50SFrank Blaschka qeth_send_ipa_cmd(card, iob, qeth_setadp_promisc_mode_cb, NULL); 33314a71df50SFrank Blaschka } 33324a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_setadp_promisc_mode); 33334a71df50SFrank Blaschka 33344a71df50SFrank Blaschka int qeth_change_mtu(struct net_device *dev, int new_mtu) 33354a71df50SFrank Blaschka { 33364a71df50SFrank Blaschka struct qeth_card *card; 33374a71df50SFrank Blaschka char dbf_text[15]; 33384a71df50SFrank Blaschka 33394a71df50SFrank Blaschka card = netdev_priv(dev); 33404a71df50SFrank Blaschka 3341d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "chgmtu"); 33424a71df50SFrank Blaschka sprintf(dbf_text, "%8x", new_mtu); 3343d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, dbf_text); 33444a71df50SFrank Blaschka 33454a71df50SFrank Blaschka if (new_mtu < 64) 33464a71df50SFrank Blaschka return -EINVAL; 33474a71df50SFrank Blaschka if (new_mtu > 65535) 33484a71df50SFrank Blaschka return -EINVAL; 33494a71df50SFrank Blaschka if ((!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) && 33504a71df50SFrank Blaschka (!qeth_mtu_is_valid(card, new_mtu))) 33514a71df50SFrank Blaschka return -EINVAL; 33524a71df50SFrank Blaschka dev->mtu = new_mtu; 33534a71df50SFrank Blaschka return 0; 33544a71df50SFrank Blaschka } 33554a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_change_mtu); 33564a71df50SFrank Blaschka 33574a71df50SFrank Blaschka struct net_device_stats *qeth_get_stats(struct net_device *dev) 33584a71df50SFrank Blaschka { 33594a71df50SFrank Blaschka struct qeth_card *card; 33604a71df50SFrank Blaschka 33614a71df50SFrank Blaschka card = netdev_priv(dev); 33624a71df50SFrank Blaschka 3363d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 5, "getstat"); 33644a71df50SFrank Blaschka 33654a71df50SFrank Blaschka return &card->stats; 33664a71df50SFrank Blaschka } 33674a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_get_stats); 33684a71df50SFrank Blaschka 33694a71df50SFrank Blaschka static int qeth_setadpparms_change_macaddr_cb(struct qeth_card *card, 33704a71df50SFrank Blaschka struct qeth_reply *reply, unsigned long data) 33714a71df50SFrank Blaschka { 33724a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 33734a71df50SFrank Blaschka 3374d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "chgmaccb"); 33754a71df50SFrank Blaschka 33764a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) data; 33774a71df50SFrank Blaschka if (!card->options.layer2 || 33784a71df50SFrank Blaschka !(card->info.mac_bits & QETH_LAYER2_MAC_READ)) { 33794a71df50SFrank Blaschka memcpy(card->dev->dev_addr, 33804a71df50SFrank Blaschka &cmd->data.setadapterparms.data.change_addr.addr, 33814a71df50SFrank Blaschka OSA_ADDR_LEN); 33824a71df50SFrank Blaschka card->info.mac_bits |= QETH_LAYER2_MAC_READ; 33834a71df50SFrank Blaschka } 33844a71df50SFrank Blaschka qeth_default_setadapterparms_cb(card, reply, (unsigned long) cmd); 33854a71df50SFrank Blaschka return 0; 33864a71df50SFrank Blaschka } 33874a71df50SFrank Blaschka 33884a71df50SFrank Blaschka int qeth_setadpparms_change_macaddr(struct qeth_card *card) 33894a71df50SFrank Blaschka { 33904a71df50SFrank Blaschka int rc; 33914a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 33924a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 33934a71df50SFrank Blaschka 3394d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "chgmac"); 33954a71df50SFrank Blaschka 33964a71df50SFrank Blaschka iob = qeth_get_adapter_cmd(card, IPA_SETADP_ALTER_MAC_ADDRESS, 33974a71df50SFrank Blaschka sizeof(struct qeth_ipacmd_setadpparms)); 33984a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 33994a71df50SFrank Blaschka cmd->data.setadapterparms.data.change_addr.cmd = CHANGE_ADDR_READ_MAC; 34004a71df50SFrank Blaschka cmd->data.setadapterparms.data.change_addr.addr_size = OSA_ADDR_LEN; 34014a71df50SFrank Blaschka memcpy(&cmd->data.setadapterparms.data.change_addr.addr, 34024a71df50SFrank Blaschka card->dev->dev_addr, OSA_ADDR_LEN); 34034a71df50SFrank Blaschka rc = qeth_send_ipa_cmd(card, iob, qeth_setadpparms_change_macaddr_cb, 34044a71df50SFrank Blaschka NULL); 34054a71df50SFrank Blaschka return rc; 34064a71df50SFrank Blaschka } 34074a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_setadpparms_change_macaddr); 34084a71df50SFrank Blaschka 34094a71df50SFrank Blaschka void qeth_tx_timeout(struct net_device *dev) 34104a71df50SFrank Blaschka { 34114a71df50SFrank Blaschka struct qeth_card *card; 34124a71df50SFrank Blaschka 34134a71df50SFrank Blaschka card = netdev_priv(dev); 34144a71df50SFrank Blaschka card->stats.tx_errors++; 34154a71df50SFrank Blaschka qeth_schedule_recovery(card); 34164a71df50SFrank Blaschka } 34174a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_tx_timeout); 34184a71df50SFrank Blaschka 34194a71df50SFrank Blaschka int qeth_mdio_read(struct net_device *dev, int phy_id, int regnum) 34204a71df50SFrank Blaschka { 34214a71df50SFrank Blaschka struct qeth_card *card = netdev_priv(dev); 34224a71df50SFrank Blaschka int rc = 0; 34234a71df50SFrank Blaschka 34244a71df50SFrank Blaschka switch (regnum) { 34254a71df50SFrank Blaschka case MII_BMCR: /* Basic mode control register */ 34264a71df50SFrank Blaschka rc = BMCR_FULLDPLX; 34274a71df50SFrank Blaschka if ((card->info.link_type != QETH_LINK_TYPE_GBIT_ETH) && 34284a71df50SFrank Blaschka (card->info.link_type != QETH_LINK_TYPE_OSN) && 34294a71df50SFrank Blaschka (card->info.link_type != QETH_LINK_TYPE_10GBIT_ETH)) 34304a71df50SFrank Blaschka rc |= BMCR_SPEED100; 34314a71df50SFrank Blaschka break; 34324a71df50SFrank Blaschka case MII_BMSR: /* Basic mode status register */ 34334a71df50SFrank Blaschka rc = BMSR_ERCAP | BMSR_ANEGCOMPLETE | BMSR_LSTATUS | 34344a71df50SFrank Blaschka BMSR_10HALF | BMSR_10FULL | BMSR_100HALF | BMSR_100FULL | 34354a71df50SFrank Blaschka BMSR_100BASE4; 34364a71df50SFrank Blaschka break; 34374a71df50SFrank Blaschka case MII_PHYSID1: /* PHYS ID 1 */ 34384a71df50SFrank Blaschka rc = (dev->dev_addr[0] << 16) | (dev->dev_addr[1] << 8) | 34394a71df50SFrank Blaschka dev->dev_addr[2]; 34404a71df50SFrank Blaschka rc = (rc >> 5) & 0xFFFF; 34414a71df50SFrank Blaschka break; 34424a71df50SFrank Blaschka case MII_PHYSID2: /* PHYS ID 2 */ 34434a71df50SFrank Blaschka rc = (dev->dev_addr[2] << 10) & 0xFFFF; 34444a71df50SFrank Blaschka break; 34454a71df50SFrank Blaschka case MII_ADVERTISE: /* Advertisement control reg */ 34464a71df50SFrank Blaschka rc = ADVERTISE_ALL; 34474a71df50SFrank Blaschka break; 34484a71df50SFrank Blaschka case MII_LPA: /* Link partner ability reg */ 34494a71df50SFrank Blaschka rc = LPA_10HALF | LPA_10FULL | LPA_100HALF | LPA_100FULL | 34504a71df50SFrank Blaschka LPA_100BASE4 | LPA_LPACK; 34514a71df50SFrank Blaschka break; 34524a71df50SFrank Blaschka case MII_EXPANSION: /* Expansion register */ 34534a71df50SFrank Blaschka break; 34544a71df50SFrank Blaschka case MII_DCOUNTER: /* disconnect counter */ 34554a71df50SFrank Blaschka break; 34564a71df50SFrank Blaschka case MII_FCSCOUNTER: /* false carrier counter */ 34574a71df50SFrank Blaschka break; 34584a71df50SFrank Blaschka case MII_NWAYTEST: /* N-way auto-neg test register */ 34594a71df50SFrank Blaschka break; 34604a71df50SFrank Blaschka case MII_RERRCOUNTER: /* rx error counter */ 34614a71df50SFrank Blaschka rc = card->stats.rx_errors; 34624a71df50SFrank Blaschka break; 34634a71df50SFrank Blaschka case MII_SREVISION: /* silicon revision */ 34644a71df50SFrank Blaschka break; 34654a71df50SFrank Blaschka case MII_RESV1: /* reserved 1 */ 34664a71df50SFrank Blaschka break; 34674a71df50SFrank Blaschka case MII_LBRERROR: /* loopback, rx, bypass error */ 34684a71df50SFrank Blaschka break; 34694a71df50SFrank Blaschka case MII_PHYADDR: /* physical address */ 34704a71df50SFrank Blaschka break; 34714a71df50SFrank Blaschka case MII_RESV2: /* reserved 2 */ 34724a71df50SFrank Blaschka break; 34734a71df50SFrank Blaschka case MII_TPISTATUS: /* TPI status for 10mbps */ 34744a71df50SFrank Blaschka break; 34754a71df50SFrank Blaschka case MII_NCONFIG: /* network interface config */ 34764a71df50SFrank Blaschka break; 34774a71df50SFrank Blaschka default: 34784a71df50SFrank Blaschka break; 34794a71df50SFrank Blaschka } 34804a71df50SFrank Blaschka return rc; 34814a71df50SFrank Blaschka } 34824a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_mdio_read); 34834a71df50SFrank Blaschka 34844a71df50SFrank Blaschka static int qeth_send_ipa_snmp_cmd(struct qeth_card *card, 34854a71df50SFrank Blaschka struct qeth_cmd_buffer *iob, int len, 34864a71df50SFrank Blaschka int (*reply_cb)(struct qeth_card *, struct qeth_reply *, 34874a71df50SFrank Blaschka unsigned long), 34884a71df50SFrank Blaschka void *reply_param) 34894a71df50SFrank Blaschka { 34904a71df50SFrank Blaschka u16 s1, s2; 34914a71df50SFrank Blaschka 3492d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "sendsnmp"); 34934a71df50SFrank Blaschka 34944a71df50SFrank Blaschka memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE); 34954a71df50SFrank Blaschka memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data), 34964a71df50SFrank Blaschka &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 34974a71df50SFrank Blaschka /* adjust PDU length fields in IPA_PDU_HEADER */ 34984a71df50SFrank Blaschka s1 = (u32) IPA_PDU_HEADER_SIZE + len; 34994a71df50SFrank Blaschka s2 = (u32) len; 35004a71df50SFrank Blaschka memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2); 35014a71df50SFrank Blaschka memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2); 35024a71df50SFrank Blaschka memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2); 35034a71df50SFrank Blaschka memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2); 35044a71df50SFrank Blaschka return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob, 35054a71df50SFrank Blaschka reply_cb, reply_param); 35064a71df50SFrank Blaschka } 35074a71df50SFrank Blaschka 35084a71df50SFrank Blaschka static int qeth_snmp_command_cb(struct qeth_card *card, 35094a71df50SFrank Blaschka struct qeth_reply *reply, unsigned long sdata) 35104a71df50SFrank Blaschka { 35114a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 35124a71df50SFrank Blaschka struct qeth_arp_query_info *qinfo; 35134a71df50SFrank Blaschka struct qeth_snmp_cmd *snmp; 35144a71df50SFrank Blaschka unsigned char *data; 35154a71df50SFrank Blaschka __u16 data_len; 35164a71df50SFrank Blaschka 3517d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "snpcmdcb"); 35184a71df50SFrank Blaschka 35194a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *) sdata; 35204a71df50SFrank Blaschka data = (unsigned char *)((char *)cmd - reply->offset); 35214a71df50SFrank Blaschka qinfo = (struct qeth_arp_query_info *) reply->param; 35224a71df50SFrank Blaschka snmp = &cmd->data.setadapterparms.data.snmp; 35234a71df50SFrank Blaschka 35244a71df50SFrank Blaschka if (cmd->hdr.return_code) { 3525d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "scer1%i", cmd->hdr.return_code); 35264a71df50SFrank Blaschka return 0; 35274a71df50SFrank Blaschka } 35284a71df50SFrank Blaschka if (cmd->data.setadapterparms.hdr.return_code) { 35294a71df50SFrank Blaschka cmd->hdr.return_code = 35304a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.return_code; 3531d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "scer2%i", cmd->hdr.return_code); 35324a71df50SFrank Blaschka return 0; 35334a71df50SFrank Blaschka } 35344a71df50SFrank Blaschka data_len = *((__u16 *)QETH_IPA_PDU_LEN_PDU1(data)); 35354a71df50SFrank Blaschka if (cmd->data.setadapterparms.hdr.seq_no == 1) 35364a71df50SFrank Blaschka data_len -= (__u16)((char *)&snmp->data - (char *)cmd); 35374a71df50SFrank Blaschka else 35384a71df50SFrank Blaschka data_len -= (__u16)((char *)&snmp->request - (char *)cmd); 35394a71df50SFrank Blaschka 35404a71df50SFrank Blaschka /* check if there is enough room in userspace */ 35414a71df50SFrank Blaschka if ((qinfo->udata_len - qinfo->udata_offset) < data_len) { 3542d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "scer3%i", -ENOMEM); 35434a71df50SFrank Blaschka cmd->hdr.return_code = -ENOMEM; 35444a71df50SFrank Blaschka return 0; 35454a71df50SFrank Blaschka } 3546d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "snore%i", 35474a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.used_total); 3548d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "sseqn%i", 35494a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.seq_no); 35504a71df50SFrank Blaschka /*copy entries to user buffer*/ 35514a71df50SFrank Blaschka if (cmd->data.setadapterparms.hdr.seq_no == 1) { 35524a71df50SFrank Blaschka memcpy(qinfo->udata + qinfo->udata_offset, 35534a71df50SFrank Blaschka (char *)snmp, 35544a71df50SFrank Blaschka data_len + offsetof(struct qeth_snmp_cmd, data)); 35554a71df50SFrank Blaschka qinfo->udata_offset += offsetof(struct qeth_snmp_cmd, data); 35564a71df50SFrank Blaschka } else { 35574a71df50SFrank Blaschka memcpy(qinfo->udata + qinfo->udata_offset, 35584a71df50SFrank Blaschka (char *)&snmp->request, data_len); 35594a71df50SFrank Blaschka } 35604a71df50SFrank Blaschka qinfo->udata_offset += data_len; 35614a71df50SFrank Blaschka /* check if all replies received ... */ 3562d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "srtot%i", 35634a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.used_total); 3564d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "srseq%i", 35654a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.seq_no); 35664a71df50SFrank Blaschka if (cmd->data.setadapterparms.hdr.seq_no < 35674a71df50SFrank Blaschka cmd->data.setadapterparms.hdr.used_total) 35684a71df50SFrank Blaschka return 1; 35694a71df50SFrank Blaschka return 0; 35704a71df50SFrank Blaschka } 35714a71df50SFrank Blaschka 35724a71df50SFrank Blaschka int qeth_snmp_command(struct qeth_card *card, char __user *udata) 35734a71df50SFrank Blaschka { 35744a71df50SFrank Blaschka struct qeth_cmd_buffer *iob; 35754a71df50SFrank Blaschka struct qeth_ipa_cmd *cmd; 35764a71df50SFrank Blaschka struct qeth_snmp_ureq *ureq; 35774a71df50SFrank Blaschka int req_len; 35784a71df50SFrank Blaschka struct qeth_arp_query_info qinfo = {0, }; 35794a71df50SFrank Blaschka int rc = 0; 35804a71df50SFrank Blaschka 3581d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 3, "snmpcmd"); 35824a71df50SFrank Blaschka 35834a71df50SFrank Blaschka if (card->info.guestlan) 35844a71df50SFrank Blaschka return -EOPNOTSUPP; 35854a71df50SFrank Blaschka 35864a71df50SFrank Blaschka if ((!qeth_adp_supported(card, IPA_SETADP_SET_SNMP_CONTROL)) && 35874a71df50SFrank Blaschka (!card->options.layer2)) { 35884a71df50SFrank Blaschka return -EOPNOTSUPP; 35894a71df50SFrank Blaschka } 35904a71df50SFrank Blaschka /* skip 4 bytes (data_len struct member) to get req_len */ 35914a71df50SFrank Blaschka if (copy_from_user(&req_len, udata + sizeof(int), sizeof(int))) 35924a71df50SFrank Blaschka return -EFAULT; 35934a71df50SFrank Blaschka ureq = kmalloc(req_len+sizeof(struct qeth_snmp_ureq_hdr), GFP_KERNEL); 35944a71df50SFrank Blaschka if (!ureq) { 3595d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "snmpnome"); 35964a71df50SFrank Blaschka return -ENOMEM; 35974a71df50SFrank Blaschka } 35984a71df50SFrank Blaschka if (copy_from_user(ureq, udata, 35994a71df50SFrank Blaschka req_len + sizeof(struct qeth_snmp_ureq_hdr))) { 36004a71df50SFrank Blaschka kfree(ureq); 36014a71df50SFrank Blaschka return -EFAULT; 36024a71df50SFrank Blaschka } 36034a71df50SFrank Blaschka qinfo.udata_len = ureq->hdr.data_len; 36044a71df50SFrank Blaschka qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL); 36054a71df50SFrank Blaschka if (!qinfo.udata) { 36064a71df50SFrank Blaschka kfree(ureq); 36074a71df50SFrank Blaschka return -ENOMEM; 36084a71df50SFrank Blaschka } 36094a71df50SFrank Blaschka qinfo.udata_offset = sizeof(struct qeth_snmp_ureq_hdr); 36104a71df50SFrank Blaschka 36114a71df50SFrank Blaschka iob = qeth_get_adapter_cmd(card, IPA_SETADP_SET_SNMP_CONTROL, 36124a71df50SFrank Blaschka QETH_SNMP_SETADP_CMDLENGTH + req_len); 36134a71df50SFrank Blaschka cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 36144a71df50SFrank Blaschka memcpy(&cmd->data.setadapterparms.data.snmp, &ureq->cmd, req_len); 36154a71df50SFrank Blaschka rc = qeth_send_ipa_snmp_cmd(card, iob, QETH_SETADP_BASE_LEN + req_len, 36164a71df50SFrank Blaschka qeth_snmp_command_cb, (void *)&qinfo); 36174a71df50SFrank Blaschka if (rc) 361814cc21b6SFrank Blaschka QETH_DBF_MESSAGE(2, "SNMP command failed on %s: (0x%x)\n", 36194a71df50SFrank Blaschka QETH_CARD_IFNAME(card), rc); 36204a71df50SFrank Blaschka else { 36214a71df50SFrank Blaschka if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) 36224a71df50SFrank Blaschka rc = -EFAULT; 36234a71df50SFrank Blaschka } 36244a71df50SFrank Blaschka 36254a71df50SFrank Blaschka kfree(ureq); 36264a71df50SFrank Blaschka kfree(qinfo.udata); 36274a71df50SFrank Blaschka return rc; 36284a71df50SFrank Blaschka } 36294a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_snmp_command); 36304a71df50SFrank Blaschka 36314a71df50SFrank Blaschka static inline int qeth_get_qdio_q_format(struct qeth_card *card) 36324a71df50SFrank Blaschka { 36334a71df50SFrank Blaschka switch (card->info.type) { 36344a71df50SFrank Blaschka case QETH_CARD_TYPE_IQD: 36354a71df50SFrank Blaschka return 2; 36364a71df50SFrank Blaschka default: 36374a71df50SFrank Blaschka return 0; 36384a71df50SFrank Blaschka } 36394a71df50SFrank Blaschka } 36404a71df50SFrank Blaschka 36414a71df50SFrank Blaschka static int qeth_qdio_establish(struct qeth_card *card) 36424a71df50SFrank Blaschka { 36434a71df50SFrank Blaschka struct qdio_initialize init_data; 36444a71df50SFrank Blaschka char *qib_param_field; 36454a71df50SFrank Blaschka struct qdio_buffer **in_sbal_ptrs; 36464a71df50SFrank Blaschka struct qdio_buffer **out_sbal_ptrs; 36474a71df50SFrank Blaschka int i, j, k; 36484a71df50SFrank Blaschka int rc = 0; 36494a71df50SFrank Blaschka 3650d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "qdioest"); 36514a71df50SFrank Blaschka 36524a71df50SFrank Blaschka qib_param_field = kzalloc(QDIO_MAX_BUFFERS_PER_Q * sizeof(char), 36534a71df50SFrank Blaschka GFP_KERNEL); 36544a71df50SFrank Blaschka if (!qib_param_field) 36554a71df50SFrank Blaschka return -ENOMEM; 36564a71df50SFrank Blaschka 36574a71df50SFrank Blaschka qeth_create_qib_param_field(card, qib_param_field); 36584a71df50SFrank Blaschka qeth_create_qib_param_field_blkt(card, qib_param_field); 36594a71df50SFrank Blaschka 36604a71df50SFrank Blaschka in_sbal_ptrs = kmalloc(QDIO_MAX_BUFFERS_PER_Q * sizeof(void *), 36614a71df50SFrank Blaschka GFP_KERNEL); 36624a71df50SFrank Blaschka if (!in_sbal_ptrs) { 36634a71df50SFrank Blaschka kfree(qib_param_field); 36644a71df50SFrank Blaschka return -ENOMEM; 36654a71df50SFrank Blaschka } 36664a71df50SFrank Blaschka for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; ++i) 36674a71df50SFrank Blaschka in_sbal_ptrs[i] = (struct qdio_buffer *) 36684a71df50SFrank Blaschka virt_to_phys(card->qdio.in_q->bufs[i].buffer); 36694a71df50SFrank Blaschka 36704a71df50SFrank Blaschka out_sbal_ptrs = 36714a71df50SFrank Blaschka kmalloc(card->qdio.no_out_queues * QDIO_MAX_BUFFERS_PER_Q * 36724a71df50SFrank Blaschka sizeof(void *), GFP_KERNEL); 36734a71df50SFrank Blaschka if (!out_sbal_ptrs) { 36744a71df50SFrank Blaschka kfree(in_sbal_ptrs); 36754a71df50SFrank Blaschka kfree(qib_param_field); 36764a71df50SFrank Blaschka return -ENOMEM; 36774a71df50SFrank Blaschka } 36784a71df50SFrank Blaschka for (i = 0, k = 0; i < card->qdio.no_out_queues; ++i) 36794a71df50SFrank Blaschka for (j = 0; j < QDIO_MAX_BUFFERS_PER_Q; ++j, ++k) { 36804a71df50SFrank Blaschka out_sbal_ptrs[k] = (struct qdio_buffer *)virt_to_phys( 36814a71df50SFrank Blaschka card->qdio.out_qs[i]->bufs[j].buffer); 36824a71df50SFrank Blaschka } 36834a71df50SFrank Blaschka 36844a71df50SFrank Blaschka memset(&init_data, 0, sizeof(struct qdio_initialize)); 36854a71df50SFrank Blaschka init_data.cdev = CARD_DDEV(card); 36864a71df50SFrank Blaschka init_data.q_format = qeth_get_qdio_q_format(card); 36874a71df50SFrank Blaschka init_data.qib_param_field_format = 0; 36884a71df50SFrank Blaschka init_data.qib_param_field = qib_param_field; 36894a71df50SFrank Blaschka init_data.min_input_threshold = QETH_MIN_INPUT_THRESHOLD; 36904a71df50SFrank Blaschka init_data.max_input_threshold = QETH_MAX_INPUT_THRESHOLD; 36914a71df50SFrank Blaschka init_data.min_output_threshold = QETH_MIN_OUTPUT_THRESHOLD; 36924a71df50SFrank Blaschka init_data.max_output_threshold = QETH_MAX_OUTPUT_THRESHOLD; 36934a71df50SFrank Blaschka init_data.no_input_qs = 1; 36944a71df50SFrank Blaschka init_data.no_output_qs = card->qdio.no_out_queues; 36954a71df50SFrank Blaschka init_data.input_handler = card->discipline.input_handler; 36964a71df50SFrank Blaschka init_data.output_handler = card->discipline.output_handler; 36974a71df50SFrank Blaschka init_data.int_parm = (unsigned long) card; 36984a71df50SFrank Blaschka init_data.flags = QDIO_INBOUND_0COPY_SBALS | 36994a71df50SFrank Blaschka QDIO_OUTBOUND_0COPY_SBALS | 37004a71df50SFrank Blaschka QDIO_USE_OUTBOUND_PCIS; 37014a71df50SFrank Blaschka init_data.input_sbal_addr_array = (void **) in_sbal_ptrs; 37024a71df50SFrank Blaschka init_data.output_sbal_addr_array = (void **) out_sbal_ptrs; 37034a71df50SFrank Blaschka 37044a71df50SFrank Blaschka if (atomic_cmpxchg(&card->qdio.state, QETH_QDIO_ALLOCATED, 37054a71df50SFrank Blaschka QETH_QDIO_ESTABLISHED) == QETH_QDIO_ALLOCATED) { 37064a71df50SFrank Blaschka rc = qdio_initialize(&init_data); 37074a71df50SFrank Blaschka if (rc) 37084a71df50SFrank Blaschka atomic_set(&card->qdio.state, QETH_QDIO_ALLOCATED); 37094a71df50SFrank Blaschka } 37104a71df50SFrank Blaschka kfree(out_sbal_ptrs); 37114a71df50SFrank Blaschka kfree(in_sbal_ptrs); 37124a71df50SFrank Blaschka kfree(qib_param_field); 37134a71df50SFrank Blaschka return rc; 37144a71df50SFrank Blaschka } 37154a71df50SFrank Blaschka 37164a71df50SFrank Blaschka static void qeth_core_free_card(struct qeth_card *card) 37174a71df50SFrank Blaschka { 37184a71df50SFrank Blaschka 3719d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "freecrd"); 3720d11ba0c4SPeter Tiedemann QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 37214a71df50SFrank Blaschka qeth_clean_channel(&card->read); 37224a71df50SFrank Blaschka qeth_clean_channel(&card->write); 37234a71df50SFrank Blaschka if (card->dev) 37244a71df50SFrank Blaschka free_netdev(card->dev); 37254a71df50SFrank Blaschka kfree(card->ip_tbd_list); 37264a71df50SFrank Blaschka qeth_free_qdio_buffers(card); 37274a71df50SFrank Blaschka kfree(card); 37284a71df50SFrank Blaschka } 37294a71df50SFrank Blaschka 37304a71df50SFrank Blaschka static struct ccw_device_id qeth_ids[] = { 37314a71df50SFrank Blaschka {CCW_DEVICE(0x1731, 0x01), .driver_info = QETH_CARD_TYPE_OSAE}, 37324a71df50SFrank Blaschka {CCW_DEVICE(0x1731, 0x05), .driver_info = QETH_CARD_TYPE_IQD}, 37334a71df50SFrank Blaschka {CCW_DEVICE(0x1731, 0x06), .driver_info = QETH_CARD_TYPE_OSN}, 37344a71df50SFrank Blaschka {}, 37354a71df50SFrank Blaschka }; 37364a71df50SFrank Blaschka MODULE_DEVICE_TABLE(ccw, qeth_ids); 37374a71df50SFrank Blaschka 37384a71df50SFrank Blaschka static struct ccw_driver qeth_ccw_driver = { 37394a71df50SFrank Blaschka .name = "qeth", 37404a71df50SFrank Blaschka .ids = qeth_ids, 37414a71df50SFrank Blaschka .probe = ccwgroup_probe_ccwdev, 37424a71df50SFrank Blaschka .remove = ccwgroup_remove_ccwdev, 37434a71df50SFrank Blaschka }; 37444a71df50SFrank Blaschka 37454a71df50SFrank Blaschka static int qeth_core_driver_group(const char *buf, struct device *root_dev, 37464a71df50SFrank Blaschka unsigned long driver_id) 37474a71df50SFrank Blaschka { 3748022b660aSUrsula Braun return ccwgroup_create_from_string(root_dev, driver_id, 3749022b660aSUrsula Braun &qeth_ccw_driver, 3, buf); 37504a71df50SFrank Blaschka } 37514a71df50SFrank Blaschka 37524a71df50SFrank Blaschka int qeth_core_hardsetup_card(struct qeth_card *card) 37534a71df50SFrank Blaschka { 37544a71df50SFrank Blaschka int retries = 3; 37554a71df50SFrank Blaschka int mpno; 37564a71df50SFrank Blaschka int rc; 37574a71df50SFrank Blaschka 3758d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "hrdsetup"); 37594a71df50SFrank Blaschka atomic_set(&card->force_alloc_skb, 0); 37604a71df50SFrank Blaschka retry: 37614a71df50SFrank Blaschka if (retries < 3) { 37624a71df50SFrank Blaschka PRINT_WARN("Retrying to do IDX activates.\n"); 37634a71df50SFrank Blaschka ccw_device_set_offline(CARD_DDEV(card)); 37644a71df50SFrank Blaschka ccw_device_set_offline(CARD_WDEV(card)); 37654a71df50SFrank Blaschka ccw_device_set_offline(CARD_RDEV(card)); 37664a71df50SFrank Blaschka ccw_device_set_online(CARD_RDEV(card)); 37674a71df50SFrank Blaschka ccw_device_set_online(CARD_WDEV(card)); 37684a71df50SFrank Blaschka ccw_device_set_online(CARD_DDEV(card)); 37694a71df50SFrank Blaschka } 37704a71df50SFrank Blaschka rc = qeth_qdio_clear_card(card, card->info.type != QETH_CARD_TYPE_IQD); 37714a71df50SFrank Blaschka if (rc == -ERESTARTSYS) { 3772d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "break1"); 37734a71df50SFrank Blaschka return rc; 37744a71df50SFrank Blaschka } else if (rc) { 3775d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 37764a71df50SFrank Blaschka if (--retries < 0) 37774a71df50SFrank Blaschka goto out; 37784a71df50SFrank Blaschka else 37794a71df50SFrank Blaschka goto retry; 37804a71df50SFrank Blaschka } 37814a71df50SFrank Blaschka 37824a71df50SFrank Blaschka rc = qeth_get_unitaddr(card); 37834a71df50SFrank Blaschka if (rc) { 3784d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 37854a71df50SFrank Blaschka return rc; 37864a71df50SFrank Blaschka } 3787a74b08c7SUrsula Braun mpno = qdio_get_ssqd_pct(CARD_DDEV(card)); 3788a74b08c7SUrsula Braun if (mpno) 3789a74b08c7SUrsula Braun mpno = min(mpno - 1, QETH_MAX_PORTNO); 37904a71df50SFrank Blaschka if (card->info.portno > mpno) { 379114cc21b6SFrank Blaschka QETH_DBF_MESSAGE(2, "Device %s does not offer port number %d" 379214cc21b6SFrank Blaschka "\n.", CARD_BUS_ID(card), card->info.portno); 37934a71df50SFrank Blaschka rc = -ENODEV; 37944a71df50SFrank Blaschka goto out; 37954a71df50SFrank Blaschka } 37964a71df50SFrank Blaschka qeth_init_tokens(card); 37974a71df50SFrank Blaschka qeth_init_func_level(card); 37984a71df50SFrank Blaschka rc = qeth_idx_activate_channel(&card->read, qeth_idx_read_cb); 37994a71df50SFrank Blaschka if (rc == -ERESTARTSYS) { 3800d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "break2"); 38014a71df50SFrank Blaschka return rc; 38024a71df50SFrank Blaschka } else if (rc) { 3803d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 38044a71df50SFrank Blaschka if (--retries < 0) 38054a71df50SFrank Blaschka goto out; 38064a71df50SFrank Blaschka else 38074a71df50SFrank Blaschka goto retry; 38084a71df50SFrank Blaschka } 38094a71df50SFrank Blaschka rc = qeth_idx_activate_channel(&card->write, qeth_idx_write_cb); 38104a71df50SFrank Blaschka if (rc == -ERESTARTSYS) { 3811d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "break3"); 38124a71df50SFrank Blaschka return rc; 38134a71df50SFrank Blaschka } else if (rc) { 3814d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc); 38154a71df50SFrank Blaschka if (--retries < 0) 38164a71df50SFrank Blaschka goto out; 38174a71df50SFrank Blaschka else 38184a71df50SFrank Blaschka goto retry; 38194a71df50SFrank Blaschka } 38204a71df50SFrank Blaschka rc = qeth_mpc_initialize(card); 38214a71df50SFrank Blaschka if (rc) { 3822d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc); 38234a71df50SFrank Blaschka goto out; 38244a71df50SFrank Blaschka } 38254a71df50SFrank Blaschka return 0; 38264a71df50SFrank Blaschka out: 38274a71df50SFrank Blaschka PRINT_ERR("Initialization in hardsetup failed! rc=%d\n", rc); 38284a71df50SFrank Blaschka return rc; 38294a71df50SFrank Blaschka } 38304a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_hardsetup_card); 38314a71df50SFrank Blaschka 38324a71df50SFrank Blaschka static inline int qeth_create_skb_frag(struct qdio_buffer_element *element, 38334a71df50SFrank Blaschka struct sk_buff **pskb, int offset, int *pfrag, int data_len) 38344a71df50SFrank Blaschka { 38354a71df50SFrank Blaschka struct page *page = virt_to_page(element->addr); 38364a71df50SFrank Blaschka if (*pskb == NULL) { 38374a71df50SFrank Blaschka /* the upper protocol layers assume that there is data in the 38384a71df50SFrank Blaschka * skb itself. Copy a small amount (64 bytes) to make them 38394a71df50SFrank Blaschka * happy. */ 38404a71df50SFrank Blaschka *pskb = dev_alloc_skb(64 + ETH_HLEN); 38414a71df50SFrank Blaschka if (!(*pskb)) 38424a71df50SFrank Blaschka return -ENOMEM; 38434a71df50SFrank Blaschka skb_reserve(*pskb, ETH_HLEN); 38444a71df50SFrank Blaschka if (data_len <= 64) { 38454a71df50SFrank Blaschka memcpy(skb_put(*pskb, data_len), element->addr + offset, 38464a71df50SFrank Blaschka data_len); 38474a71df50SFrank Blaschka } else { 38484a71df50SFrank Blaschka get_page(page); 38494a71df50SFrank Blaschka memcpy(skb_put(*pskb, 64), element->addr + offset, 64); 38504a71df50SFrank Blaschka skb_fill_page_desc(*pskb, *pfrag, page, offset + 64, 38514a71df50SFrank Blaschka data_len - 64); 38524a71df50SFrank Blaschka (*pskb)->data_len += data_len - 64; 38534a71df50SFrank Blaschka (*pskb)->len += data_len - 64; 38544a71df50SFrank Blaschka (*pskb)->truesize += data_len - 64; 38554a71df50SFrank Blaschka (*pfrag)++; 38564a71df50SFrank Blaschka } 38574a71df50SFrank Blaschka } else { 38584a71df50SFrank Blaschka get_page(page); 38594a71df50SFrank Blaschka skb_fill_page_desc(*pskb, *pfrag, page, offset, data_len); 38604a71df50SFrank Blaschka (*pskb)->data_len += data_len; 38614a71df50SFrank Blaschka (*pskb)->len += data_len; 38624a71df50SFrank Blaschka (*pskb)->truesize += data_len; 38634a71df50SFrank Blaschka (*pfrag)++; 38644a71df50SFrank Blaschka } 38654a71df50SFrank Blaschka return 0; 38664a71df50SFrank Blaschka } 38674a71df50SFrank Blaschka 38684a71df50SFrank Blaschka struct sk_buff *qeth_core_get_next_skb(struct qeth_card *card, 38694a71df50SFrank Blaschka struct qdio_buffer *buffer, 38704a71df50SFrank Blaschka struct qdio_buffer_element **__element, int *__offset, 38714a71df50SFrank Blaschka struct qeth_hdr **hdr) 38724a71df50SFrank Blaschka { 38734a71df50SFrank Blaschka struct qdio_buffer_element *element = *__element; 38744a71df50SFrank Blaschka int offset = *__offset; 38754a71df50SFrank Blaschka struct sk_buff *skb = NULL; 38764a71df50SFrank Blaschka int skb_len; 38774a71df50SFrank Blaschka void *data_ptr; 38784a71df50SFrank Blaschka int data_len; 38794a71df50SFrank Blaschka int headroom = 0; 38804a71df50SFrank Blaschka int use_rx_sg = 0; 38814a71df50SFrank Blaschka int frag = 0; 38824a71df50SFrank Blaschka 38834a71df50SFrank Blaschka /* qeth_hdr must not cross element boundaries */ 38844a71df50SFrank Blaschka if (element->length < offset + sizeof(struct qeth_hdr)) { 38854a71df50SFrank Blaschka if (qeth_is_last_sbale(element)) 38864a71df50SFrank Blaschka return NULL; 38874a71df50SFrank Blaschka element++; 38884a71df50SFrank Blaschka offset = 0; 38894a71df50SFrank Blaschka if (element->length < sizeof(struct qeth_hdr)) 38904a71df50SFrank Blaschka return NULL; 38914a71df50SFrank Blaschka } 38924a71df50SFrank Blaschka *hdr = element->addr + offset; 38934a71df50SFrank Blaschka 38944a71df50SFrank Blaschka offset += sizeof(struct qeth_hdr); 38954a71df50SFrank Blaschka if (card->options.layer2) { 38964a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) { 38974a71df50SFrank Blaschka skb_len = (*hdr)->hdr.osn.pdu_length; 38984a71df50SFrank Blaschka headroom = sizeof(struct qeth_hdr); 38994a71df50SFrank Blaschka } else { 39004a71df50SFrank Blaschka skb_len = (*hdr)->hdr.l2.pkt_length; 39014a71df50SFrank Blaschka } 39024a71df50SFrank Blaschka } else { 39034a71df50SFrank Blaschka skb_len = (*hdr)->hdr.l3.length; 3904b403e685SFrank Blaschka if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) || 3905b403e685SFrank Blaschka (card->info.link_type == QETH_LINK_TYPE_HSTR)) 3906b403e685SFrank Blaschka headroom = TR_HLEN; 3907b403e685SFrank Blaschka else 3908b403e685SFrank Blaschka headroom = ETH_HLEN; 39094a71df50SFrank Blaschka } 39104a71df50SFrank Blaschka 39114a71df50SFrank Blaschka if (!skb_len) 39124a71df50SFrank Blaschka return NULL; 39134a71df50SFrank Blaschka 39144a71df50SFrank Blaschka if ((skb_len >= card->options.rx_sg_cb) && 39154a71df50SFrank Blaschka (!(card->info.type == QETH_CARD_TYPE_OSN)) && 39164a71df50SFrank Blaschka (!atomic_read(&card->force_alloc_skb))) { 39174a71df50SFrank Blaschka use_rx_sg = 1; 39184a71df50SFrank Blaschka } else { 39194a71df50SFrank Blaschka skb = dev_alloc_skb(skb_len + headroom); 39204a71df50SFrank Blaschka if (!skb) 39214a71df50SFrank Blaschka goto no_mem; 39224a71df50SFrank Blaschka if (headroom) 39234a71df50SFrank Blaschka skb_reserve(skb, headroom); 39244a71df50SFrank Blaschka } 39254a71df50SFrank Blaschka 39264a71df50SFrank Blaschka data_ptr = element->addr + offset; 39274a71df50SFrank Blaschka while (skb_len) { 39284a71df50SFrank Blaschka data_len = min(skb_len, (int)(element->length - offset)); 39294a71df50SFrank Blaschka if (data_len) { 39304a71df50SFrank Blaschka if (use_rx_sg) { 39314a71df50SFrank Blaschka if (qeth_create_skb_frag(element, &skb, offset, 39324a71df50SFrank Blaschka &frag, data_len)) 39334a71df50SFrank Blaschka goto no_mem; 39344a71df50SFrank Blaschka } else { 39354a71df50SFrank Blaschka memcpy(skb_put(skb, data_len), data_ptr, 39364a71df50SFrank Blaschka data_len); 39374a71df50SFrank Blaschka } 39384a71df50SFrank Blaschka } 39394a71df50SFrank Blaschka skb_len -= data_len; 39404a71df50SFrank Blaschka if (skb_len) { 39414a71df50SFrank Blaschka if (qeth_is_last_sbale(element)) { 3942d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 4, "unexeob"); 3943d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 4, "%s", 39444a71df50SFrank Blaschka CARD_BUS_ID(card)); 3945d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(QERR, 2, "unexeob"); 3946d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(QERR, 2, "%s", 39474a71df50SFrank Blaschka CARD_BUS_ID(card)); 3948d11ba0c4SPeter Tiedemann QETH_DBF_HEX(MISC, 4, buffer, sizeof(*buffer)); 39494a71df50SFrank Blaschka dev_kfree_skb_any(skb); 39504a71df50SFrank Blaschka card->stats.rx_errors++; 39514a71df50SFrank Blaschka return NULL; 39524a71df50SFrank Blaschka } 39534a71df50SFrank Blaschka element++; 39544a71df50SFrank Blaschka offset = 0; 39554a71df50SFrank Blaschka data_ptr = element->addr; 39564a71df50SFrank Blaschka } else { 39574a71df50SFrank Blaschka offset += data_len; 39584a71df50SFrank Blaschka } 39594a71df50SFrank Blaschka } 39604a71df50SFrank Blaschka *__element = element; 39614a71df50SFrank Blaschka *__offset = offset; 39624a71df50SFrank Blaschka if (use_rx_sg && card->options.performance_stats) { 39634a71df50SFrank Blaschka card->perf_stats.sg_skbs_rx++; 39644a71df50SFrank Blaschka card->perf_stats.sg_frags_rx += skb_shinfo(skb)->nr_frags; 39654a71df50SFrank Blaschka } 39664a71df50SFrank Blaschka return skb; 39674a71df50SFrank Blaschka no_mem: 39684a71df50SFrank Blaschka if (net_ratelimit()) { 3969d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(TRACE, 2, "noskbmem"); 3970d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(TRACE, 2, "%s", CARD_BUS_ID(card)); 39714a71df50SFrank Blaschka } 39724a71df50SFrank Blaschka card->stats.rx_dropped++; 39734a71df50SFrank Blaschka return NULL; 39744a71df50SFrank Blaschka } 39754a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_get_next_skb); 39764a71df50SFrank Blaschka 39774a71df50SFrank Blaschka static void qeth_unregister_dbf_views(void) 39784a71df50SFrank Blaschka { 3979d11ba0c4SPeter Tiedemann int x; 3980d11ba0c4SPeter Tiedemann for (x = 0; x < QETH_DBF_INFOS; x++) { 3981d11ba0c4SPeter Tiedemann debug_unregister(qeth_dbf[x].id); 3982d11ba0c4SPeter Tiedemann qeth_dbf[x].id = NULL; 3983d11ba0c4SPeter Tiedemann } 39844a71df50SFrank Blaschka } 39854a71df50SFrank Blaschka 3986345aa66eSPeter Tiedemann void qeth_dbf_longtext(enum qeth_dbf_names dbf_nix, int level, char *fmt, ...) 3987cd023216SPeter Tiedemann { 3988cd023216SPeter Tiedemann char dbf_txt_buf[32]; 3989345aa66eSPeter Tiedemann va_list args; 3990cd023216SPeter Tiedemann 3991cd023216SPeter Tiedemann if (level > (qeth_dbf[dbf_nix].id)->level) 3992cd023216SPeter Tiedemann return; 3993345aa66eSPeter Tiedemann va_start(args, fmt); 3994345aa66eSPeter Tiedemann vsnprintf(dbf_txt_buf, sizeof(dbf_txt_buf), fmt, args); 3995345aa66eSPeter Tiedemann va_end(args); 3996cd023216SPeter Tiedemann debug_text_event(qeth_dbf[dbf_nix].id, level, dbf_txt_buf); 3997cd023216SPeter Tiedemann } 3998cd023216SPeter Tiedemann EXPORT_SYMBOL_GPL(qeth_dbf_longtext); 3999cd023216SPeter Tiedemann 40004a71df50SFrank Blaschka static int qeth_register_dbf_views(void) 40014a71df50SFrank Blaschka { 4002d11ba0c4SPeter Tiedemann int ret; 4003d11ba0c4SPeter Tiedemann int x; 40044a71df50SFrank Blaschka 4005d11ba0c4SPeter Tiedemann for (x = 0; x < QETH_DBF_INFOS; x++) { 4006d11ba0c4SPeter Tiedemann /* register the areas */ 4007d11ba0c4SPeter Tiedemann qeth_dbf[x].id = debug_register(qeth_dbf[x].name, 4008d11ba0c4SPeter Tiedemann qeth_dbf[x].pages, 4009d11ba0c4SPeter Tiedemann qeth_dbf[x].areas, 4010d11ba0c4SPeter Tiedemann qeth_dbf[x].len); 4011d11ba0c4SPeter Tiedemann if (qeth_dbf[x].id == NULL) { 40124a71df50SFrank Blaschka qeth_unregister_dbf_views(); 40134a71df50SFrank Blaschka return -ENOMEM; 40144a71df50SFrank Blaschka } 40154a71df50SFrank Blaschka 4016d11ba0c4SPeter Tiedemann /* register a view */ 4017d11ba0c4SPeter Tiedemann ret = debug_register_view(qeth_dbf[x].id, qeth_dbf[x].view); 4018d11ba0c4SPeter Tiedemann if (ret) { 4019d11ba0c4SPeter Tiedemann qeth_unregister_dbf_views(); 4020d11ba0c4SPeter Tiedemann return ret; 4021d11ba0c4SPeter Tiedemann } 40224a71df50SFrank Blaschka 4023d11ba0c4SPeter Tiedemann /* set a passing level */ 4024d11ba0c4SPeter Tiedemann debug_set_level(qeth_dbf[x].id, qeth_dbf[x].level); 4025d11ba0c4SPeter Tiedemann } 40264a71df50SFrank Blaschka 40274a71df50SFrank Blaschka return 0; 40284a71df50SFrank Blaschka } 40294a71df50SFrank Blaschka 40304a71df50SFrank Blaschka int qeth_core_load_discipline(struct qeth_card *card, 40314a71df50SFrank Blaschka enum qeth_discipline_id discipline) 40324a71df50SFrank Blaschka { 40334a71df50SFrank Blaschka int rc = 0; 40344a71df50SFrank Blaschka switch (discipline) { 40354a71df50SFrank Blaschka case QETH_DISCIPLINE_LAYER3: 40364a71df50SFrank Blaschka card->discipline.ccwgdriver = try_then_request_module( 40374a71df50SFrank Blaschka symbol_get(qeth_l3_ccwgroup_driver), 40384a71df50SFrank Blaschka "qeth_l3"); 40394a71df50SFrank Blaschka break; 40404a71df50SFrank Blaschka case QETH_DISCIPLINE_LAYER2: 40414a71df50SFrank Blaschka card->discipline.ccwgdriver = try_then_request_module( 40424a71df50SFrank Blaschka symbol_get(qeth_l2_ccwgroup_driver), 40434a71df50SFrank Blaschka "qeth_l2"); 40444a71df50SFrank Blaschka break; 40454a71df50SFrank Blaschka } 40464a71df50SFrank Blaschka if (!card->discipline.ccwgdriver) { 40474a71df50SFrank Blaschka PRINT_ERR("Support for discipline %d not present\n", 40484a71df50SFrank Blaschka discipline); 40494a71df50SFrank Blaschka rc = -EINVAL; 40504a71df50SFrank Blaschka } 40514a71df50SFrank Blaschka return rc; 40524a71df50SFrank Blaschka } 40534a71df50SFrank Blaschka 40544a71df50SFrank Blaschka void qeth_core_free_discipline(struct qeth_card *card) 40554a71df50SFrank Blaschka { 40564a71df50SFrank Blaschka if (card->options.layer2) 40574a71df50SFrank Blaschka symbol_put(qeth_l2_ccwgroup_driver); 40584a71df50SFrank Blaschka else 40594a71df50SFrank Blaschka symbol_put(qeth_l3_ccwgroup_driver); 40604a71df50SFrank Blaschka card->discipline.ccwgdriver = NULL; 40614a71df50SFrank Blaschka } 40624a71df50SFrank Blaschka 40634a71df50SFrank Blaschka static int qeth_core_probe_device(struct ccwgroup_device *gdev) 40644a71df50SFrank Blaschka { 40654a71df50SFrank Blaschka struct qeth_card *card; 40664a71df50SFrank Blaschka struct device *dev; 40674a71df50SFrank Blaschka int rc; 40684a71df50SFrank Blaschka unsigned long flags; 40694a71df50SFrank Blaschka 4070d11ba0c4SPeter Tiedemann QETH_DBF_TEXT(SETUP, 2, "probedev"); 40714a71df50SFrank Blaschka 40724a71df50SFrank Blaschka dev = &gdev->dev; 40734a71df50SFrank Blaschka if (!get_device(dev)) 40744a71df50SFrank Blaschka return -ENODEV; 40754a71df50SFrank Blaschka 4076d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "%s", gdev->dev.bus_id); 40774a71df50SFrank Blaschka 40784a71df50SFrank Blaschka card = qeth_alloc_card(); 40794a71df50SFrank Blaschka if (!card) { 4080d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "1err%d", -ENOMEM); 40814a71df50SFrank Blaschka rc = -ENOMEM; 40824a71df50SFrank Blaschka goto err_dev; 40834a71df50SFrank Blaschka } 40844a71df50SFrank Blaschka card->read.ccwdev = gdev->cdev[0]; 40854a71df50SFrank Blaschka card->write.ccwdev = gdev->cdev[1]; 40864a71df50SFrank Blaschka card->data.ccwdev = gdev->cdev[2]; 40874a71df50SFrank Blaschka dev_set_drvdata(&gdev->dev, card); 40884a71df50SFrank Blaschka card->gdev = gdev; 40894a71df50SFrank Blaschka gdev->cdev[0]->handler = qeth_irq; 40904a71df50SFrank Blaschka gdev->cdev[1]->handler = qeth_irq; 40914a71df50SFrank Blaschka gdev->cdev[2]->handler = qeth_irq; 40924a71df50SFrank Blaschka 40934a71df50SFrank Blaschka rc = qeth_determine_card_type(card); 40944a71df50SFrank Blaschka if (rc) { 4095d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 40964a71df50SFrank Blaschka goto err_card; 40974a71df50SFrank Blaschka } 40984a71df50SFrank Blaschka rc = qeth_setup_card(card); 40994a71df50SFrank Blaschka if (rc) { 4100d11ba0c4SPeter Tiedemann QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc); 41014a71df50SFrank Blaschka goto err_card; 41024a71df50SFrank Blaschka } 41034a71df50SFrank Blaschka 41044a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) { 41054a71df50SFrank Blaschka rc = qeth_core_create_osn_attributes(dev); 41064a71df50SFrank Blaschka if (rc) 41074a71df50SFrank Blaschka goto err_card; 41084a71df50SFrank Blaschka rc = qeth_core_load_discipline(card, QETH_DISCIPLINE_LAYER2); 41094a71df50SFrank Blaschka if (rc) { 41104a71df50SFrank Blaschka qeth_core_remove_osn_attributes(dev); 41114a71df50SFrank Blaschka goto err_card; 41124a71df50SFrank Blaschka } 41134a71df50SFrank Blaschka rc = card->discipline.ccwgdriver->probe(card->gdev); 41144a71df50SFrank Blaschka if (rc) { 41154a71df50SFrank Blaschka qeth_core_free_discipline(card); 41164a71df50SFrank Blaschka qeth_core_remove_osn_attributes(dev); 41174a71df50SFrank Blaschka goto err_card; 41184a71df50SFrank Blaschka } 41194a71df50SFrank Blaschka } else { 41204a71df50SFrank Blaschka rc = qeth_core_create_device_attributes(dev); 41214a71df50SFrank Blaschka if (rc) 41224a71df50SFrank Blaschka goto err_card; 41234a71df50SFrank Blaschka } 41244a71df50SFrank Blaschka 41254a71df50SFrank Blaschka write_lock_irqsave(&qeth_core_card_list.rwlock, flags); 41264a71df50SFrank Blaschka list_add_tail(&card->list, &qeth_core_card_list.list); 41274a71df50SFrank Blaschka write_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 41284a71df50SFrank Blaschka return 0; 41294a71df50SFrank Blaschka 41304a71df50SFrank Blaschka err_card: 41314a71df50SFrank Blaschka qeth_core_free_card(card); 41324a71df50SFrank Blaschka err_dev: 41334a71df50SFrank Blaschka put_device(dev); 41344a71df50SFrank Blaschka return rc; 41354a71df50SFrank Blaschka } 41364a71df50SFrank Blaschka 41374a71df50SFrank Blaschka static void qeth_core_remove_device(struct ccwgroup_device *gdev) 41384a71df50SFrank Blaschka { 41394a71df50SFrank Blaschka unsigned long flags; 41404a71df50SFrank Blaschka struct qeth_card *card = dev_get_drvdata(&gdev->dev); 41414a71df50SFrank Blaschka 41424a71df50SFrank Blaschka if (card->discipline.ccwgdriver) { 41434a71df50SFrank Blaschka card->discipline.ccwgdriver->remove(gdev); 41444a71df50SFrank Blaschka qeth_core_free_discipline(card); 41454a71df50SFrank Blaschka } 41464a71df50SFrank Blaschka 41474a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_OSN) { 41484a71df50SFrank Blaschka qeth_core_remove_osn_attributes(&gdev->dev); 41494a71df50SFrank Blaschka } else { 41504a71df50SFrank Blaschka qeth_core_remove_device_attributes(&gdev->dev); 41514a71df50SFrank Blaschka } 41524a71df50SFrank Blaschka write_lock_irqsave(&qeth_core_card_list.rwlock, flags); 41534a71df50SFrank Blaschka list_del(&card->list); 41544a71df50SFrank Blaschka write_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 41554a71df50SFrank Blaschka qeth_core_free_card(card); 41564a71df50SFrank Blaschka dev_set_drvdata(&gdev->dev, NULL); 41574a71df50SFrank Blaschka put_device(&gdev->dev); 41584a71df50SFrank Blaschka return; 41594a71df50SFrank Blaschka } 41604a71df50SFrank Blaschka 41614a71df50SFrank Blaschka static int qeth_core_set_online(struct ccwgroup_device *gdev) 41624a71df50SFrank Blaschka { 41634a71df50SFrank Blaschka struct qeth_card *card = dev_get_drvdata(&gdev->dev); 41644a71df50SFrank Blaschka int rc = 0; 41654a71df50SFrank Blaschka int def_discipline; 41664a71df50SFrank Blaschka 41674a71df50SFrank Blaschka if (!card->discipline.ccwgdriver) { 41684a71df50SFrank Blaschka if (card->info.type == QETH_CARD_TYPE_IQD) 41694a71df50SFrank Blaschka def_discipline = QETH_DISCIPLINE_LAYER3; 41704a71df50SFrank Blaschka else 41714a71df50SFrank Blaschka def_discipline = QETH_DISCIPLINE_LAYER2; 41724a71df50SFrank Blaschka rc = qeth_core_load_discipline(card, def_discipline); 41734a71df50SFrank Blaschka if (rc) 41744a71df50SFrank Blaschka goto err; 41754a71df50SFrank Blaschka rc = card->discipline.ccwgdriver->probe(card->gdev); 41764a71df50SFrank Blaschka if (rc) 41774a71df50SFrank Blaschka goto err; 41784a71df50SFrank Blaschka } 41794a71df50SFrank Blaschka rc = card->discipline.ccwgdriver->set_online(gdev); 41804a71df50SFrank Blaschka err: 41814a71df50SFrank Blaschka return rc; 41824a71df50SFrank Blaschka } 41834a71df50SFrank Blaschka 41844a71df50SFrank Blaschka static int qeth_core_set_offline(struct ccwgroup_device *gdev) 41854a71df50SFrank Blaschka { 41864a71df50SFrank Blaschka struct qeth_card *card = dev_get_drvdata(&gdev->dev); 41874a71df50SFrank Blaschka return card->discipline.ccwgdriver->set_offline(gdev); 41884a71df50SFrank Blaschka } 41894a71df50SFrank Blaschka 41904a71df50SFrank Blaschka static void qeth_core_shutdown(struct ccwgroup_device *gdev) 41914a71df50SFrank Blaschka { 41924a71df50SFrank Blaschka struct qeth_card *card = dev_get_drvdata(&gdev->dev); 41934a71df50SFrank Blaschka if (card->discipline.ccwgdriver && 41944a71df50SFrank Blaschka card->discipline.ccwgdriver->shutdown) 41954a71df50SFrank Blaschka card->discipline.ccwgdriver->shutdown(gdev); 41964a71df50SFrank Blaschka } 41974a71df50SFrank Blaschka 41984a71df50SFrank Blaschka static struct ccwgroup_driver qeth_core_ccwgroup_driver = { 41994a71df50SFrank Blaschka .owner = THIS_MODULE, 42004a71df50SFrank Blaschka .name = "qeth", 42014a71df50SFrank Blaschka .driver_id = 0xD8C5E3C8, 42024a71df50SFrank Blaschka .probe = qeth_core_probe_device, 42034a71df50SFrank Blaschka .remove = qeth_core_remove_device, 42044a71df50SFrank Blaschka .set_online = qeth_core_set_online, 42054a71df50SFrank Blaschka .set_offline = qeth_core_set_offline, 42064a71df50SFrank Blaschka .shutdown = qeth_core_shutdown, 42074a71df50SFrank Blaschka }; 42084a71df50SFrank Blaschka 42094a71df50SFrank Blaschka static ssize_t 42104a71df50SFrank Blaschka qeth_core_driver_group_store(struct device_driver *ddrv, const char *buf, 42114a71df50SFrank Blaschka size_t count) 42124a71df50SFrank Blaschka { 42134a71df50SFrank Blaschka int err; 42144a71df50SFrank Blaschka err = qeth_core_driver_group(buf, qeth_core_root_dev, 42154a71df50SFrank Blaschka qeth_core_ccwgroup_driver.driver_id); 42164a71df50SFrank Blaschka if (err) 42174a71df50SFrank Blaschka return err; 42184a71df50SFrank Blaschka else 42194a71df50SFrank Blaschka return count; 42204a71df50SFrank Blaschka } 42214a71df50SFrank Blaschka 42224a71df50SFrank Blaschka static DRIVER_ATTR(group, 0200, NULL, qeth_core_driver_group_store); 42234a71df50SFrank Blaschka 42244a71df50SFrank Blaschka static struct { 42254a71df50SFrank Blaschka const char str[ETH_GSTRING_LEN]; 42264a71df50SFrank Blaschka } qeth_ethtool_stats_keys[] = { 42274a71df50SFrank Blaschka /* 0 */{"rx skbs"}, 42284a71df50SFrank Blaschka {"rx buffers"}, 42294a71df50SFrank Blaschka {"tx skbs"}, 42304a71df50SFrank Blaschka {"tx buffers"}, 42314a71df50SFrank Blaschka {"tx skbs no packing"}, 42324a71df50SFrank Blaschka {"tx buffers no packing"}, 42334a71df50SFrank Blaschka {"tx skbs packing"}, 42344a71df50SFrank Blaschka {"tx buffers packing"}, 42354a71df50SFrank Blaschka {"tx sg skbs"}, 42364a71df50SFrank Blaschka {"tx sg frags"}, 42374a71df50SFrank Blaschka /* 10 */{"rx sg skbs"}, 42384a71df50SFrank Blaschka {"rx sg frags"}, 42394a71df50SFrank Blaschka {"rx sg page allocs"}, 42404a71df50SFrank Blaschka {"tx large kbytes"}, 42414a71df50SFrank Blaschka {"tx large count"}, 42424a71df50SFrank Blaschka {"tx pk state ch n->p"}, 42434a71df50SFrank Blaschka {"tx pk state ch p->n"}, 42444a71df50SFrank Blaschka {"tx pk watermark low"}, 42454a71df50SFrank Blaschka {"tx pk watermark high"}, 42464a71df50SFrank Blaschka {"queue 0 buffer usage"}, 42474a71df50SFrank Blaschka /* 20 */{"queue 1 buffer usage"}, 42484a71df50SFrank Blaschka {"queue 2 buffer usage"}, 42494a71df50SFrank Blaschka {"queue 3 buffer usage"}, 42504a71df50SFrank Blaschka {"rx handler time"}, 42514a71df50SFrank Blaschka {"rx handler count"}, 42524a71df50SFrank Blaschka {"rx do_QDIO time"}, 42534a71df50SFrank Blaschka {"rx do_QDIO count"}, 42544a71df50SFrank Blaschka {"tx handler time"}, 42554a71df50SFrank Blaschka {"tx handler count"}, 42564a71df50SFrank Blaschka {"tx time"}, 42574a71df50SFrank Blaschka /* 30 */{"tx count"}, 42584a71df50SFrank Blaschka {"tx do_QDIO time"}, 42594a71df50SFrank Blaschka {"tx do_QDIO count"}, 42604a71df50SFrank Blaschka }; 42614a71df50SFrank Blaschka 42624a71df50SFrank Blaschka int qeth_core_get_stats_count(struct net_device *dev) 42634a71df50SFrank Blaschka { 42644a71df50SFrank Blaschka return (sizeof(qeth_ethtool_stats_keys) / ETH_GSTRING_LEN); 42654a71df50SFrank Blaschka } 42664a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_get_stats_count); 42674a71df50SFrank Blaschka 42684a71df50SFrank Blaschka void qeth_core_get_ethtool_stats(struct net_device *dev, 42694a71df50SFrank Blaschka struct ethtool_stats *stats, u64 *data) 42704a71df50SFrank Blaschka { 42714a71df50SFrank Blaschka struct qeth_card *card = netdev_priv(dev); 42724a71df50SFrank Blaschka data[0] = card->stats.rx_packets - 42734a71df50SFrank Blaschka card->perf_stats.initial_rx_packets; 42744a71df50SFrank Blaschka data[1] = card->perf_stats.bufs_rec; 42754a71df50SFrank Blaschka data[2] = card->stats.tx_packets - 42764a71df50SFrank Blaschka card->perf_stats.initial_tx_packets; 42774a71df50SFrank Blaschka data[3] = card->perf_stats.bufs_sent; 42784a71df50SFrank Blaschka data[4] = card->stats.tx_packets - card->perf_stats.initial_tx_packets 42794a71df50SFrank Blaschka - card->perf_stats.skbs_sent_pack; 42804a71df50SFrank Blaschka data[5] = card->perf_stats.bufs_sent - card->perf_stats.bufs_sent_pack; 42814a71df50SFrank Blaschka data[6] = card->perf_stats.skbs_sent_pack; 42824a71df50SFrank Blaschka data[7] = card->perf_stats.bufs_sent_pack; 42834a71df50SFrank Blaschka data[8] = card->perf_stats.sg_skbs_sent; 42844a71df50SFrank Blaschka data[9] = card->perf_stats.sg_frags_sent; 42854a71df50SFrank Blaschka data[10] = card->perf_stats.sg_skbs_rx; 42864a71df50SFrank Blaschka data[11] = card->perf_stats.sg_frags_rx; 42874a71df50SFrank Blaschka data[12] = card->perf_stats.sg_alloc_page_rx; 42884a71df50SFrank Blaschka data[13] = (card->perf_stats.large_send_bytes >> 10); 42894a71df50SFrank Blaschka data[14] = card->perf_stats.large_send_cnt; 42904a71df50SFrank Blaschka data[15] = card->perf_stats.sc_dp_p; 42914a71df50SFrank Blaschka data[16] = card->perf_stats.sc_p_dp; 42924a71df50SFrank Blaschka data[17] = QETH_LOW_WATERMARK_PACK; 42934a71df50SFrank Blaschka data[18] = QETH_HIGH_WATERMARK_PACK; 42944a71df50SFrank Blaschka data[19] = atomic_read(&card->qdio.out_qs[0]->used_buffers); 42954a71df50SFrank Blaschka data[20] = (card->qdio.no_out_queues > 1) ? 42964a71df50SFrank Blaschka atomic_read(&card->qdio.out_qs[1]->used_buffers) : 0; 42974a71df50SFrank Blaschka data[21] = (card->qdio.no_out_queues > 2) ? 42984a71df50SFrank Blaschka atomic_read(&card->qdio.out_qs[2]->used_buffers) : 0; 42994a71df50SFrank Blaschka data[22] = (card->qdio.no_out_queues > 3) ? 43004a71df50SFrank Blaschka atomic_read(&card->qdio.out_qs[3]->used_buffers) : 0; 43014a71df50SFrank Blaschka data[23] = card->perf_stats.inbound_time; 43024a71df50SFrank Blaschka data[24] = card->perf_stats.inbound_cnt; 43034a71df50SFrank Blaschka data[25] = card->perf_stats.inbound_do_qdio_time; 43044a71df50SFrank Blaschka data[26] = card->perf_stats.inbound_do_qdio_cnt; 43054a71df50SFrank Blaschka data[27] = card->perf_stats.outbound_handler_time; 43064a71df50SFrank Blaschka data[28] = card->perf_stats.outbound_handler_cnt; 43074a71df50SFrank Blaschka data[29] = card->perf_stats.outbound_time; 43084a71df50SFrank Blaschka data[30] = card->perf_stats.outbound_cnt; 43094a71df50SFrank Blaschka data[31] = card->perf_stats.outbound_do_qdio_time; 43104a71df50SFrank Blaschka data[32] = card->perf_stats.outbound_do_qdio_cnt; 43114a71df50SFrank Blaschka } 43124a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_get_ethtool_stats); 43134a71df50SFrank Blaschka 43144a71df50SFrank Blaschka void qeth_core_get_strings(struct net_device *dev, u32 stringset, u8 *data) 43154a71df50SFrank Blaschka { 43164a71df50SFrank Blaschka switch (stringset) { 43174a71df50SFrank Blaschka case ETH_SS_STATS: 43184a71df50SFrank Blaschka memcpy(data, &qeth_ethtool_stats_keys, 43194a71df50SFrank Blaschka sizeof(qeth_ethtool_stats_keys)); 43204a71df50SFrank Blaschka break; 43214a71df50SFrank Blaschka default: 43224a71df50SFrank Blaschka WARN_ON(1); 43234a71df50SFrank Blaschka break; 43244a71df50SFrank Blaschka } 43254a71df50SFrank Blaschka } 43264a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_get_strings); 43274a71df50SFrank Blaschka 43284a71df50SFrank Blaschka void qeth_core_get_drvinfo(struct net_device *dev, 43294a71df50SFrank Blaschka struct ethtool_drvinfo *info) 43304a71df50SFrank Blaschka { 43314a71df50SFrank Blaschka struct qeth_card *card = netdev_priv(dev); 43324a71df50SFrank Blaschka if (card->options.layer2) 43334a71df50SFrank Blaschka strcpy(info->driver, "qeth_l2"); 43344a71df50SFrank Blaschka else 43354a71df50SFrank Blaschka strcpy(info->driver, "qeth_l3"); 43364a71df50SFrank Blaschka 43374a71df50SFrank Blaschka strcpy(info->version, "1.0"); 43384a71df50SFrank Blaschka strcpy(info->fw_version, card->info.mcl_level); 43394a71df50SFrank Blaschka sprintf(info->bus_info, "%s/%s/%s", 43404a71df50SFrank Blaschka CARD_RDEV_ID(card), 43414a71df50SFrank Blaschka CARD_WDEV_ID(card), 43424a71df50SFrank Blaschka CARD_DDEV_ID(card)); 43434a71df50SFrank Blaschka } 43444a71df50SFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_get_drvinfo); 43454a71df50SFrank Blaschka 43463f9975aaSFrank Blaschka int qeth_core_ethtool_get_settings(struct net_device *netdev, 43473f9975aaSFrank Blaschka struct ethtool_cmd *ecmd) 43483f9975aaSFrank Blaschka { 43493f9975aaSFrank Blaschka struct qeth_card *card = netdev_priv(netdev); 43503f9975aaSFrank Blaschka enum qeth_link_types link_type; 43513f9975aaSFrank Blaschka 43523f9975aaSFrank Blaschka if ((card->info.type == QETH_CARD_TYPE_IQD) || (card->info.guestlan)) 43533f9975aaSFrank Blaschka link_type = QETH_LINK_TYPE_10GBIT_ETH; 43543f9975aaSFrank Blaschka else 43553f9975aaSFrank Blaschka link_type = card->info.link_type; 43563f9975aaSFrank Blaschka 43573f9975aaSFrank Blaschka ecmd->transceiver = XCVR_INTERNAL; 43583f9975aaSFrank Blaschka ecmd->supported = SUPPORTED_Autoneg; 43593f9975aaSFrank Blaschka ecmd->advertising = ADVERTISED_Autoneg; 43603f9975aaSFrank Blaschka ecmd->duplex = DUPLEX_FULL; 43613f9975aaSFrank Blaschka ecmd->autoneg = AUTONEG_ENABLE; 43623f9975aaSFrank Blaschka 43633f9975aaSFrank Blaschka switch (link_type) { 43643f9975aaSFrank Blaschka case QETH_LINK_TYPE_FAST_ETH: 43653f9975aaSFrank Blaschka case QETH_LINK_TYPE_LANE_ETH100: 43663f9975aaSFrank Blaschka ecmd->supported |= SUPPORTED_10baseT_Half | 43673f9975aaSFrank Blaschka SUPPORTED_10baseT_Full | 43683f9975aaSFrank Blaschka SUPPORTED_100baseT_Half | 43693f9975aaSFrank Blaschka SUPPORTED_100baseT_Full | 43703f9975aaSFrank Blaschka SUPPORTED_TP; 43713f9975aaSFrank Blaschka ecmd->advertising |= ADVERTISED_10baseT_Half | 43723f9975aaSFrank Blaschka ADVERTISED_10baseT_Full | 43733f9975aaSFrank Blaschka ADVERTISED_100baseT_Half | 43743f9975aaSFrank Blaschka ADVERTISED_100baseT_Full | 43753f9975aaSFrank Blaschka ADVERTISED_TP; 43763f9975aaSFrank Blaschka ecmd->speed = SPEED_100; 43773f9975aaSFrank Blaschka ecmd->port = PORT_TP; 43783f9975aaSFrank Blaschka break; 43793f9975aaSFrank Blaschka 43803f9975aaSFrank Blaschka case QETH_LINK_TYPE_GBIT_ETH: 43813f9975aaSFrank Blaschka case QETH_LINK_TYPE_LANE_ETH1000: 43823f9975aaSFrank Blaschka ecmd->supported |= SUPPORTED_10baseT_Half | 43833f9975aaSFrank Blaschka SUPPORTED_10baseT_Full | 43843f9975aaSFrank Blaschka SUPPORTED_100baseT_Half | 43853f9975aaSFrank Blaschka SUPPORTED_100baseT_Full | 43863f9975aaSFrank Blaschka SUPPORTED_1000baseT_Half | 43873f9975aaSFrank Blaschka SUPPORTED_1000baseT_Full | 43883f9975aaSFrank Blaschka SUPPORTED_FIBRE; 43893f9975aaSFrank Blaschka ecmd->advertising |= ADVERTISED_10baseT_Half | 43903f9975aaSFrank Blaschka ADVERTISED_10baseT_Full | 43913f9975aaSFrank Blaschka ADVERTISED_100baseT_Half | 43923f9975aaSFrank Blaschka ADVERTISED_100baseT_Full | 43933f9975aaSFrank Blaschka ADVERTISED_1000baseT_Half | 43943f9975aaSFrank Blaschka ADVERTISED_1000baseT_Full | 43953f9975aaSFrank Blaschka ADVERTISED_FIBRE; 43963f9975aaSFrank Blaschka ecmd->speed = SPEED_1000; 43973f9975aaSFrank Blaschka ecmd->port = PORT_FIBRE; 43983f9975aaSFrank Blaschka break; 43993f9975aaSFrank Blaschka 44003f9975aaSFrank Blaschka case QETH_LINK_TYPE_10GBIT_ETH: 44013f9975aaSFrank Blaschka ecmd->supported |= SUPPORTED_10baseT_Half | 44023f9975aaSFrank Blaschka SUPPORTED_10baseT_Full | 44033f9975aaSFrank Blaschka SUPPORTED_100baseT_Half | 44043f9975aaSFrank Blaschka SUPPORTED_100baseT_Full | 44053f9975aaSFrank Blaschka SUPPORTED_1000baseT_Half | 44063f9975aaSFrank Blaschka SUPPORTED_1000baseT_Full | 44073f9975aaSFrank Blaschka SUPPORTED_10000baseT_Full | 44083f9975aaSFrank Blaschka SUPPORTED_FIBRE; 44093f9975aaSFrank Blaschka ecmd->advertising |= ADVERTISED_10baseT_Half | 44103f9975aaSFrank Blaschka ADVERTISED_10baseT_Full | 44113f9975aaSFrank Blaschka ADVERTISED_100baseT_Half | 44123f9975aaSFrank Blaschka ADVERTISED_100baseT_Full | 44133f9975aaSFrank Blaschka ADVERTISED_1000baseT_Half | 44143f9975aaSFrank Blaschka ADVERTISED_1000baseT_Full | 44153f9975aaSFrank Blaschka ADVERTISED_10000baseT_Full | 44163f9975aaSFrank Blaschka ADVERTISED_FIBRE; 44173f9975aaSFrank Blaschka ecmd->speed = SPEED_10000; 44183f9975aaSFrank Blaschka ecmd->port = PORT_FIBRE; 44193f9975aaSFrank Blaschka break; 44203f9975aaSFrank Blaschka 44213f9975aaSFrank Blaschka default: 44223f9975aaSFrank Blaschka ecmd->supported |= SUPPORTED_10baseT_Half | 44233f9975aaSFrank Blaschka SUPPORTED_10baseT_Full | 44243f9975aaSFrank Blaschka SUPPORTED_TP; 44253f9975aaSFrank Blaschka ecmd->advertising |= ADVERTISED_10baseT_Half | 44263f9975aaSFrank Blaschka ADVERTISED_10baseT_Full | 44273f9975aaSFrank Blaschka ADVERTISED_TP; 44283f9975aaSFrank Blaschka ecmd->speed = SPEED_10; 44293f9975aaSFrank Blaschka ecmd->port = PORT_TP; 44303f9975aaSFrank Blaschka } 44313f9975aaSFrank Blaschka 44323f9975aaSFrank Blaschka return 0; 44333f9975aaSFrank Blaschka } 44343f9975aaSFrank Blaschka EXPORT_SYMBOL_GPL(qeth_core_ethtool_get_settings); 44353f9975aaSFrank Blaschka 44364a71df50SFrank Blaschka static int __init qeth_core_init(void) 44374a71df50SFrank Blaschka { 44384a71df50SFrank Blaschka int rc; 44394a71df50SFrank Blaschka 44404a71df50SFrank Blaschka PRINT_INFO("loading core functions\n"); 44414a71df50SFrank Blaschka INIT_LIST_HEAD(&qeth_core_card_list.list); 44424a71df50SFrank Blaschka rwlock_init(&qeth_core_card_list.rwlock); 44434a71df50SFrank Blaschka 44444a71df50SFrank Blaschka rc = qeth_register_dbf_views(); 44454a71df50SFrank Blaschka if (rc) 44464a71df50SFrank Blaschka goto out_err; 44474a71df50SFrank Blaschka rc = ccw_driver_register(&qeth_ccw_driver); 44484a71df50SFrank Blaschka if (rc) 44494a71df50SFrank Blaschka goto ccw_err; 44504a71df50SFrank Blaschka rc = ccwgroup_driver_register(&qeth_core_ccwgroup_driver); 44514a71df50SFrank Blaschka if (rc) 44524a71df50SFrank Blaschka goto ccwgroup_err; 44534a71df50SFrank Blaschka rc = driver_create_file(&qeth_core_ccwgroup_driver.driver, 44544a71df50SFrank Blaschka &driver_attr_group); 44554a71df50SFrank Blaschka if (rc) 44564a71df50SFrank Blaschka goto driver_err; 44574a71df50SFrank Blaschka qeth_core_root_dev = s390_root_dev_register("qeth"); 44584a71df50SFrank Blaschka rc = IS_ERR(qeth_core_root_dev) ? PTR_ERR(qeth_core_root_dev) : 0; 44594a71df50SFrank Blaschka if (rc) 44604a71df50SFrank Blaschka goto register_err; 44614a71df50SFrank Blaschka return 0; 44624a71df50SFrank Blaschka 44634a71df50SFrank Blaschka register_err: 44644a71df50SFrank Blaschka driver_remove_file(&qeth_core_ccwgroup_driver.driver, 44654a71df50SFrank Blaschka &driver_attr_group); 44664a71df50SFrank Blaschka driver_err: 44674a71df50SFrank Blaschka ccwgroup_driver_unregister(&qeth_core_ccwgroup_driver); 44684a71df50SFrank Blaschka ccwgroup_err: 44694a71df50SFrank Blaschka ccw_driver_unregister(&qeth_ccw_driver); 44704a71df50SFrank Blaschka ccw_err: 44714a71df50SFrank Blaschka qeth_unregister_dbf_views(); 44724a71df50SFrank Blaschka out_err: 44734a71df50SFrank Blaschka PRINT_ERR("Initialization failed with code %d\n", rc); 44744a71df50SFrank Blaschka return rc; 44754a71df50SFrank Blaschka } 44764a71df50SFrank Blaschka 44774a71df50SFrank Blaschka static void __exit qeth_core_exit(void) 44784a71df50SFrank Blaschka { 44794a71df50SFrank Blaschka s390_root_dev_unregister(qeth_core_root_dev); 44804a71df50SFrank Blaschka driver_remove_file(&qeth_core_ccwgroup_driver.driver, 44814a71df50SFrank Blaschka &driver_attr_group); 44824a71df50SFrank Blaschka ccwgroup_driver_unregister(&qeth_core_ccwgroup_driver); 44834a71df50SFrank Blaschka ccw_driver_unregister(&qeth_ccw_driver); 44844a71df50SFrank Blaschka qeth_unregister_dbf_views(); 44854a71df50SFrank Blaschka PRINT_INFO("core functions removed\n"); 44864a71df50SFrank Blaschka } 44874a71df50SFrank Blaschka 44884a71df50SFrank Blaschka module_init(qeth_core_init); 44894a71df50SFrank Blaschka module_exit(qeth_core_exit); 44904a71df50SFrank Blaschka MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 44914a71df50SFrank Blaschka MODULE_DESCRIPTION("qeth core functions"); 44924a71df50SFrank Blaschka MODULE_LICENSE("GPL"); 4493