qeth_l2_main.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248
  1. /*
  2. * drivers/s390/net/qeth_l2_main.c
  3. *
  4. * Copyright IBM Corp. 2007
  5. * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
  6. * Frank Pavlic <fpavlic@de.ibm.com>,
  7. * Thomas Spatzier <tspat@de.ibm.com>,
  8. * Frank Blaschka <frank.blaschka@de.ibm.com>
  9. */
  10. #include <linux/module.h>
  11. #include <linux/moduleparam.h>
  12. #include <linux/string.h>
  13. #include <linux/errno.h>
  14. #include <linux/kernel.h>
  15. #include <linux/etherdevice.h>
  16. #include <linux/mii.h>
  17. #include <linux/ip.h>
  18. #include <asm/s390_rdev.h>
  19. #include "qeth_core.h"
  20. #include "qeth_core_offl.h"
  21. static int qeth_l2_set_offline(struct ccwgroup_device *);
  22. static int qeth_l2_stop(struct net_device *);
  23. static int qeth_l2_send_delmac(struct qeth_card *, __u8 *);
  24. static int qeth_l2_send_setdelmac(struct qeth_card *, __u8 *,
  25. enum qeth_ipa_cmds,
  26. int (*reply_cb) (struct qeth_card *,
  27. struct qeth_reply*,
  28. unsigned long));
  29. static void qeth_l2_set_multicast_list(struct net_device *);
  30. static int qeth_l2_recover(void *);
  31. static int qeth_l2_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  32. {
  33. struct qeth_card *card = netdev_priv(dev);
  34. struct mii_ioctl_data *mii_data;
  35. int rc = 0;
  36. if (!card)
  37. return -ENODEV;
  38. if ((card->state != CARD_STATE_UP) &&
  39. (card->state != CARD_STATE_SOFTSETUP))
  40. return -ENODEV;
  41. if (card->info.type == QETH_CARD_TYPE_OSN)
  42. return -EPERM;
  43. switch (cmd) {
  44. case SIOC_QETH_ADP_SET_SNMP_CONTROL:
  45. rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
  46. break;
  47. case SIOC_QETH_GET_CARD_TYPE:
  48. if ((card->info.type == QETH_CARD_TYPE_OSAE) &&
  49. !card->info.guestlan)
  50. return 1;
  51. return 0;
  52. break;
  53. case SIOCGMIIPHY:
  54. mii_data = if_mii(rq);
  55. mii_data->phy_id = 0;
  56. break;
  57. case SIOCGMIIREG:
  58. mii_data = if_mii(rq);
  59. if (mii_data->phy_id != 0)
  60. rc = -EINVAL;
  61. else
  62. mii_data->val_out = qeth_mdio_read(dev,
  63. mii_data->phy_id, mii_data->reg_num);
  64. break;
  65. default:
  66. rc = -EOPNOTSUPP;
  67. }
  68. if (rc)
  69. QETH_DBF_TEXT_(TRACE, 2, "ioce%d", rc);
  70. return rc;
  71. }
  72. static int qeth_l2_verify_dev(struct net_device *dev)
  73. {
  74. struct qeth_card *card;
  75. unsigned long flags;
  76. int rc = 0;
  77. read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
  78. list_for_each_entry(card, &qeth_core_card_list.list, list) {
  79. if (card->dev == dev) {
  80. rc = QETH_REAL_CARD;
  81. break;
  82. }
  83. }
  84. read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
  85. return rc;
  86. }
  87. static struct net_device *qeth_l2_netdev_by_devno(unsigned char *read_dev_no)
  88. {
  89. struct qeth_card *card;
  90. struct net_device *ndev;
  91. unsigned char *readno;
  92. __u16 temp_dev_no, card_dev_no;
  93. char *endp;
  94. unsigned long flags;
  95. ndev = NULL;
  96. memcpy(&temp_dev_no, read_dev_no, 2);
  97. read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
  98. list_for_each_entry(card, &qeth_core_card_list.list, list) {
  99. readno = CARD_RDEV_ID(card);
  100. readno += (strlen(readno) - 4);
  101. card_dev_no = simple_strtoul(readno, &endp, 16);
  102. if (card_dev_no == temp_dev_no) {
  103. ndev = card->dev;
  104. break;
  105. }
  106. }
  107. read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
  108. return ndev;
  109. }
  110. static int qeth_l2_send_setgroupmac_cb(struct qeth_card *card,
  111. struct qeth_reply *reply,
  112. unsigned long data)
  113. {
  114. struct qeth_ipa_cmd *cmd;
  115. __u8 *mac;
  116. QETH_DBF_TEXT(TRACE, 2, "L2Sgmacb");
  117. cmd = (struct qeth_ipa_cmd *) data;
  118. mac = &cmd->data.setdelmac.mac[0];
  119. /* MAC already registered, needed in couple/uncouple case */
  120. if (cmd->hdr.return_code == 0x2005) {
  121. PRINT_WARN("Group MAC %02x:%02x:%02x:%02x:%02x:%02x " \
  122. "already existing on %s \n",
  123. mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
  124. QETH_CARD_IFNAME(card));
  125. cmd->hdr.return_code = 0;
  126. }
  127. if (cmd->hdr.return_code)
  128. PRINT_ERR("Could not set group MAC " \
  129. "%02x:%02x:%02x:%02x:%02x:%02x on %s: %x\n",
  130. mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
  131. QETH_CARD_IFNAME(card), cmd->hdr.return_code);
  132. return 0;
  133. }
  134. static int qeth_l2_send_setgroupmac(struct qeth_card *card, __u8 *mac)
  135. {
  136. QETH_DBF_TEXT(TRACE, 2, "L2Sgmac");
  137. return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETGMAC,
  138. qeth_l2_send_setgroupmac_cb);
  139. }
  140. static int qeth_l2_send_delgroupmac_cb(struct qeth_card *card,
  141. struct qeth_reply *reply,
  142. unsigned long data)
  143. {
  144. struct qeth_ipa_cmd *cmd;
  145. __u8 *mac;
  146. QETH_DBF_TEXT(TRACE, 2, "L2Dgmacb");
  147. cmd = (struct qeth_ipa_cmd *) data;
  148. mac = &cmd->data.setdelmac.mac[0];
  149. if (cmd->hdr.return_code)
  150. PRINT_ERR("Could not delete group MAC " \
  151. "%02x:%02x:%02x:%02x:%02x:%02x on %s: %x\n",
  152. mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
  153. QETH_CARD_IFNAME(card), cmd->hdr.return_code);
  154. return 0;
  155. }
  156. static int qeth_l2_send_delgroupmac(struct qeth_card *card, __u8 *mac)
  157. {
  158. QETH_DBF_TEXT(TRACE, 2, "L2Dgmac");
  159. return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELGMAC,
  160. qeth_l2_send_delgroupmac_cb);
  161. }
  162. static void qeth_l2_add_mc(struct qeth_card *card, __u8 *mac)
  163. {
  164. struct qeth_mc_mac *mc;
  165. mc = kmalloc(sizeof(struct qeth_mc_mac), GFP_ATOMIC);
  166. if (!mc) {
  167. PRINT_ERR("no mem vor mc mac address\n");
  168. return;
  169. }
  170. memcpy(mc->mc_addr, mac, OSA_ADDR_LEN);
  171. mc->mc_addrlen = OSA_ADDR_LEN;
  172. if (!qeth_l2_send_setgroupmac(card, mac))
  173. list_add_tail(&mc->list, &card->mc_list);
  174. else
  175. kfree(mc);
  176. }
  177. static void qeth_l2_del_all_mc(struct qeth_card *card)
  178. {
  179. struct qeth_mc_mac *mc, *tmp;
  180. spin_lock_bh(&card->mclock);
  181. list_for_each_entry_safe(mc, tmp, &card->mc_list, list) {
  182. qeth_l2_send_delgroupmac(card, mc->mc_addr);
  183. list_del(&mc->list);
  184. kfree(mc);
  185. }
  186. spin_unlock_bh(&card->mclock);
  187. }
  188. static void qeth_l2_get_packet_type(struct qeth_card *card,
  189. struct qeth_hdr *hdr, struct sk_buff *skb)
  190. {
  191. __u16 hdr_mac;
  192. if (!memcmp(skb->data + QETH_HEADER_SIZE,
  193. skb->dev->broadcast, 6)) {
  194. /* broadcast? */
  195. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
  196. return;
  197. }
  198. hdr_mac = *((__u16 *)skb->data);
  199. /* tr multicast? */
  200. switch (card->info.link_type) {
  201. case QETH_LINK_TYPE_HSTR:
  202. case QETH_LINK_TYPE_LANE_TR:
  203. if ((hdr_mac == QETH_TR_MAC_NC) ||
  204. (hdr_mac == QETH_TR_MAC_C))
  205. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
  206. else
  207. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
  208. break;
  209. /* eth or so multicast? */
  210. default:
  211. if ((hdr_mac == QETH_ETH_MAC_V4) ||
  212. (hdr_mac == QETH_ETH_MAC_V6))
  213. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
  214. else
  215. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
  216. }
  217. }
  218. static void qeth_l2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
  219. struct sk_buff *skb, int ipv, int cast_type)
  220. {
  221. struct vlan_ethhdr *veth = (struct vlan_ethhdr *)((skb->data) +
  222. QETH_HEADER_SIZE);
  223. memset(hdr, 0, sizeof(struct qeth_hdr));
  224. hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
  225. /* set byte byte 3 to casting flags */
  226. if (cast_type == RTN_MULTICAST)
  227. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
  228. else if (cast_type == RTN_BROADCAST)
  229. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
  230. else
  231. qeth_l2_get_packet_type(card, hdr, skb);
  232. hdr->hdr.l2.pkt_length = skb->len-QETH_HEADER_SIZE;
  233. /* VSWITCH relies on the VLAN
  234. * information to be present in
  235. * the QDIO header */
  236. if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
  237. hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
  238. hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
  239. }
  240. }
  241. static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
  242. struct qeth_reply *reply, unsigned long data)
  243. {
  244. struct qeth_ipa_cmd *cmd;
  245. QETH_DBF_TEXT(TRACE, 2, "L2sdvcb");
  246. cmd = (struct qeth_ipa_cmd *) data;
  247. if (cmd->hdr.return_code) {
  248. PRINT_ERR("Error in processing VLAN %i on %s: 0x%x. "
  249. "Continuing\n", cmd->data.setdelvlan.vlan_id,
  250. QETH_CARD_IFNAME(card), cmd->hdr.return_code);
  251. QETH_DBF_TEXT_(TRACE, 2, "L2VL%4x", cmd->hdr.command);
  252. QETH_DBF_TEXT_(TRACE, 2, "L2%s", CARD_BUS_ID(card));
  253. QETH_DBF_TEXT_(TRACE, 2, "err%d", cmd->hdr.return_code);
  254. }
  255. return 0;
  256. }
  257. static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
  258. enum qeth_ipa_cmds ipacmd)
  259. {
  260. struct qeth_ipa_cmd *cmd;
  261. struct qeth_cmd_buffer *iob;
  262. QETH_DBF_TEXT_(TRACE, 4, "L2sdv%x", ipacmd);
  263. iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
  264. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  265. cmd->data.setdelvlan.vlan_id = i;
  266. return qeth_send_ipa_cmd(card, iob,
  267. qeth_l2_send_setdelvlan_cb, NULL);
  268. }
  269. static void qeth_l2_process_vlans(struct qeth_card *card, int clear)
  270. {
  271. struct qeth_vlan_vid *id;
  272. QETH_DBF_TEXT(TRACE, 3, "L2prcvln");
  273. spin_lock_bh(&card->vlanlock);
  274. list_for_each_entry(id, &card->vid_list, list) {
  275. if (clear)
  276. qeth_l2_send_setdelvlan(card, id->vid,
  277. IPA_CMD_DELVLAN);
  278. else
  279. qeth_l2_send_setdelvlan(card, id->vid,
  280. IPA_CMD_SETVLAN);
  281. }
  282. spin_unlock_bh(&card->vlanlock);
  283. }
  284. static void qeth_l2_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
  285. {
  286. struct qeth_card *card = netdev_priv(dev);
  287. struct qeth_vlan_vid *id;
  288. QETH_DBF_TEXT_(TRACE, 4, "aid:%d", vid);
  289. id = kmalloc(sizeof(struct qeth_vlan_vid), GFP_ATOMIC);
  290. if (id) {
  291. id->vid = vid;
  292. qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
  293. spin_lock_bh(&card->vlanlock);
  294. list_add_tail(&id->list, &card->vid_list);
  295. spin_unlock_bh(&card->vlanlock);
  296. } else {
  297. PRINT_ERR("no memory for vid\n");
  298. }
  299. }
  300. static void qeth_l2_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
  301. {
  302. struct qeth_vlan_vid *id, *tmpid = NULL;
  303. struct qeth_card *card = netdev_priv(dev);
  304. QETH_DBF_TEXT_(TRACE, 4, "kid:%d", vid);
  305. spin_lock_bh(&card->vlanlock);
  306. list_for_each_entry(id, &card->vid_list, list) {
  307. if (id->vid == vid) {
  308. list_del(&id->list);
  309. tmpid = id;
  310. break;
  311. }
  312. }
  313. spin_unlock_bh(&card->vlanlock);
  314. if (tmpid) {
  315. qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
  316. kfree(tmpid);
  317. }
  318. qeth_l2_set_multicast_list(card->dev);
  319. }
  320. static int qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
  321. {
  322. int rc = 0;
  323. QETH_DBF_TEXT(SETUP , 2, "stopcard");
  324. QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
  325. qeth_set_allowed_threads(card, 0, 1);
  326. if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD))
  327. return -ERESTARTSYS;
  328. if (card->read.state == CH_STATE_UP &&
  329. card->write.state == CH_STATE_UP &&
  330. (card->state == CARD_STATE_UP)) {
  331. if (recovery_mode &&
  332. card->info.type != QETH_CARD_TYPE_OSN) {
  333. qeth_l2_stop(card->dev);
  334. } else {
  335. rtnl_lock();
  336. dev_close(card->dev);
  337. rtnl_unlock();
  338. }
  339. if (!card->use_hard_stop) {
  340. __u8 *mac = &card->dev->dev_addr[0];
  341. rc = qeth_l2_send_delmac(card, mac);
  342. QETH_DBF_TEXT_(SETUP, 2, "Lerr%d", rc);
  343. }
  344. card->state = CARD_STATE_SOFTSETUP;
  345. }
  346. if (card->state == CARD_STATE_SOFTSETUP) {
  347. qeth_l2_process_vlans(card, 1);
  348. qeth_l2_del_all_mc(card);
  349. qeth_clear_ipacmd_list(card);
  350. card->state = CARD_STATE_HARDSETUP;
  351. }
  352. if (card->state == CARD_STATE_HARDSETUP) {
  353. qeth_qdio_clear_card(card, 0);
  354. qeth_clear_qdio_buffers(card);
  355. qeth_clear_working_pool_list(card);
  356. card->state = CARD_STATE_DOWN;
  357. }
  358. if (card->state == CARD_STATE_DOWN) {
  359. qeth_clear_cmd_buffers(&card->read);
  360. qeth_clear_cmd_buffers(&card->write);
  361. }
  362. card->use_hard_stop = 0;
  363. return rc;
  364. }
  365. static void qeth_l2_process_inbound_buffer(struct qeth_card *card,
  366. struct qeth_qdio_buffer *buf, int index)
  367. {
  368. struct qdio_buffer_element *element;
  369. struct sk_buff *skb;
  370. struct qeth_hdr *hdr;
  371. int offset;
  372. unsigned int len;
  373. /* get first element of current buffer */
  374. element = (struct qdio_buffer_element *)&buf->buffer->element[0];
  375. offset = 0;
  376. if (card->options.performance_stats)
  377. card->perf_stats.bufs_rec++;
  378. while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
  379. &offset, &hdr))) {
  380. skb->dev = card->dev;
  381. /* is device UP ? */
  382. if (!(card->dev->flags & IFF_UP)) {
  383. dev_kfree_skb_any(skb);
  384. continue;
  385. }
  386. switch (hdr->hdr.l2.id) {
  387. case QETH_HEADER_TYPE_LAYER2:
  388. skb->pkt_type = PACKET_HOST;
  389. skb->protocol = eth_type_trans(skb, skb->dev);
  390. if (card->options.checksum_type == NO_CHECKSUMMING)
  391. skb->ip_summed = CHECKSUM_UNNECESSARY;
  392. else
  393. skb->ip_summed = CHECKSUM_NONE;
  394. if (skb->protocol == htons(ETH_P_802_2))
  395. *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
  396. len = skb->len;
  397. netif_rx(skb);
  398. break;
  399. case QETH_HEADER_TYPE_OSN:
  400. skb_push(skb, sizeof(struct qeth_hdr));
  401. skb_copy_to_linear_data(skb, hdr,
  402. sizeof(struct qeth_hdr));
  403. len = skb->len;
  404. card->osn_info.data_cb(skb);
  405. break;
  406. default:
  407. dev_kfree_skb_any(skb);
  408. QETH_DBF_TEXT(TRACE, 3, "inbunkno");
  409. QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
  410. continue;
  411. }
  412. card->dev->last_rx = jiffies;
  413. card->stats.rx_packets++;
  414. card->stats.rx_bytes += len;
  415. }
  416. }
  417. static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
  418. enum qeth_ipa_cmds ipacmd,
  419. int (*reply_cb) (struct qeth_card *,
  420. struct qeth_reply*,
  421. unsigned long))
  422. {
  423. struct qeth_ipa_cmd *cmd;
  424. struct qeth_cmd_buffer *iob;
  425. QETH_DBF_TEXT(TRACE, 2, "L2sdmac");
  426. iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
  427. cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
  428. cmd->data.setdelmac.mac_length = OSA_ADDR_LEN;
  429. memcpy(&cmd->data.setdelmac.mac, mac, OSA_ADDR_LEN);
  430. return qeth_send_ipa_cmd(card, iob, reply_cb, NULL);
  431. }
  432. static int qeth_l2_send_setmac_cb(struct qeth_card *card,
  433. struct qeth_reply *reply,
  434. unsigned long data)
  435. {
  436. struct qeth_ipa_cmd *cmd;
  437. QETH_DBF_TEXT(TRACE, 2, "L2Smaccb");
  438. cmd = (struct qeth_ipa_cmd *) data;
  439. if (cmd->hdr.return_code) {
  440. QETH_DBF_TEXT_(TRACE, 2, "L2er%x", cmd->hdr.return_code);
  441. card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
  442. cmd->hdr.return_code = -EIO;
  443. } else {
  444. card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
  445. memcpy(card->dev->dev_addr, cmd->data.setdelmac.mac,
  446. OSA_ADDR_LEN);
  447. PRINT_INFO("MAC address %2.2x:%2.2x:%2.2x:%2.2x:%2.2x:%2.2x "
  448. "successfully registered on device %s\n",
  449. card->dev->dev_addr[0], card->dev->dev_addr[1],
  450. card->dev->dev_addr[2], card->dev->dev_addr[3],
  451. card->dev->dev_addr[4], card->dev->dev_addr[5],
  452. card->dev->name);
  453. }
  454. return 0;
  455. }
  456. static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
  457. {
  458. QETH_DBF_TEXT(TRACE, 2, "L2Setmac");
  459. return qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC,
  460. qeth_l2_send_setmac_cb);
  461. }
  462. static int qeth_l2_send_delmac_cb(struct qeth_card *card,
  463. struct qeth_reply *reply,
  464. unsigned long data)
  465. {
  466. struct qeth_ipa_cmd *cmd;
  467. QETH_DBF_TEXT(TRACE, 2, "L2Dmaccb");
  468. cmd = (struct qeth_ipa_cmd *) data;
  469. if (cmd->hdr.return_code) {
  470. QETH_DBF_TEXT_(TRACE, 2, "err%d", cmd->hdr.return_code);
  471. cmd->hdr.return_code = -EIO;
  472. return 0;
  473. }
  474. card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
  475. return 0;
  476. }
  477. static int qeth_l2_send_delmac(struct qeth_card *card, __u8 *mac)
  478. {
  479. QETH_DBF_TEXT(TRACE, 2, "L2Delmac");
  480. if (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
  481. return 0;
  482. return qeth_l2_send_setdelmac(card, mac, IPA_CMD_DELVMAC,
  483. qeth_l2_send_delmac_cb);
  484. }
  485. static int qeth_l2_request_initial_mac(struct qeth_card *card)
  486. {
  487. int rc = 0;
  488. char vendor_pre[] = {0x02, 0x00, 0x00};
  489. QETH_DBF_TEXT(SETUP, 2, "doL2init");
  490. QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
  491. rc = qeth_query_setadapterparms(card);
  492. if (rc) {
  493. PRINT_WARN("could not query adapter parameters on device %s: "
  494. "x%x\n", CARD_BUS_ID(card), rc);
  495. }
  496. if (card->info.guestlan) {
  497. rc = qeth_setadpparms_change_macaddr(card);
  498. if (rc) {
  499. PRINT_WARN("couldn't get MAC address on "
  500. "device %s: x%x\n",
  501. CARD_BUS_ID(card), rc);
  502. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  503. return rc;
  504. }
  505. QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, OSA_ADDR_LEN);
  506. } else {
  507. random_ether_addr(card->dev->dev_addr);
  508. memcpy(card->dev->dev_addr, vendor_pre, 3);
  509. }
  510. return 0;
  511. }
  512. static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
  513. {
  514. struct sockaddr *addr = p;
  515. struct qeth_card *card = netdev_priv(dev);
  516. int rc = 0;
  517. QETH_DBF_TEXT(TRACE, 3, "setmac");
  518. if (qeth_l2_verify_dev(dev) != QETH_REAL_CARD) {
  519. QETH_DBF_TEXT(TRACE, 3, "setmcINV");
  520. return -EOPNOTSUPP;
  521. }
  522. if (card->info.type == QETH_CARD_TYPE_OSN) {
  523. PRINT_WARN("Setting MAC address on %s is not supported.\n",
  524. dev->name);
  525. QETH_DBF_TEXT(TRACE, 3, "setmcOSN");
  526. return -EOPNOTSUPP;
  527. }
  528. QETH_DBF_TEXT_(TRACE, 3, "%s", CARD_BUS_ID(card));
  529. QETH_DBF_HEX(TRACE, 3, addr->sa_data, OSA_ADDR_LEN);
  530. rc = qeth_l2_send_delmac(card, &card->dev->dev_addr[0]);
  531. if (!rc)
  532. rc = qeth_l2_send_setmac(card, addr->sa_data);
  533. return rc;
  534. }
  535. static void qeth_l2_set_multicast_list(struct net_device *dev)
  536. {
  537. struct qeth_card *card = netdev_priv(dev);
  538. struct dev_mc_list *dm;
  539. if (card->info.type == QETH_CARD_TYPE_OSN)
  540. return ;
  541. QETH_DBF_TEXT(TRACE, 3, "setmulti");
  542. qeth_l2_del_all_mc(card);
  543. spin_lock_bh(&card->mclock);
  544. for (dm = dev->mc_list; dm; dm = dm->next)
  545. qeth_l2_add_mc(card, dm->dmi_addr);
  546. spin_unlock_bh(&card->mclock);
  547. if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
  548. return;
  549. qeth_setadp_promisc_mode(card);
  550. }
  551. static int qeth_l2_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
  552. {
  553. int rc;
  554. struct qeth_hdr *hdr = NULL;
  555. int elements = 0;
  556. struct qeth_card *card = netdev_priv(dev);
  557. struct sk_buff *new_skb = skb;
  558. int ipv = qeth_get_ip_version(skb);
  559. int cast_type = qeth_get_cast_type(card, skb);
  560. struct qeth_qdio_out_q *queue = card->qdio.out_qs
  561. [qeth_get_priority_queue(card, skb, ipv, cast_type)];
  562. int tx_bytes = skb->len;
  563. enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
  564. struct qeth_eddp_context *ctx = NULL;
  565. if ((card->state != CARD_STATE_UP) || !card->lan_online) {
  566. card->stats.tx_carrier_errors++;
  567. goto tx_drop;
  568. }
  569. if ((card->info.type == QETH_CARD_TYPE_OSN) &&
  570. (skb->protocol == htons(ETH_P_IPV6)))
  571. goto tx_drop;
  572. if (card->options.performance_stats) {
  573. card->perf_stats.outbound_cnt++;
  574. card->perf_stats.outbound_start_time = qeth_get_micros();
  575. }
  576. netif_stop_queue(dev);
  577. if (skb_is_gso(skb))
  578. large_send = QETH_LARGE_SEND_EDDP;
  579. if (card->info.type == QETH_CARD_TYPE_OSN)
  580. hdr = (struct qeth_hdr *)skb->data;
  581. else {
  582. /* create a clone with writeable headroom */
  583. new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr));
  584. if (!new_skb)
  585. goto tx_drop;
  586. hdr = (struct qeth_hdr *)skb_push(new_skb,
  587. sizeof(struct qeth_hdr));
  588. qeth_l2_fill_header(card, hdr, new_skb, ipv, cast_type);
  589. }
  590. if (large_send == QETH_LARGE_SEND_EDDP) {
  591. ctx = qeth_eddp_create_context(card, new_skb, hdr,
  592. skb->sk->sk_protocol);
  593. if (ctx == NULL) {
  594. PRINT_WARN("could not create eddp context\n");
  595. goto tx_drop;
  596. }
  597. } else {
  598. elements = qeth_get_elements_no(card, (void *)hdr, new_skb, 0);
  599. if (!elements)
  600. goto tx_drop;
  601. }
  602. if ((large_send == QETH_LARGE_SEND_NO) &&
  603. (skb->ip_summed == CHECKSUM_PARTIAL))
  604. qeth_tx_csum(new_skb);
  605. if (card->info.type != QETH_CARD_TYPE_IQD)
  606. rc = qeth_do_send_packet(card, queue, new_skb, hdr,
  607. elements, ctx);
  608. else
  609. rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
  610. elements, ctx);
  611. if (!rc) {
  612. card->stats.tx_packets++;
  613. card->stats.tx_bytes += tx_bytes;
  614. if (new_skb != skb)
  615. dev_kfree_skb_any(skb);
  616. if (card->options.performance_stats) {
  617. if (large_send != QETH_LARGE_SEND_NO) {
  618. card->perf_stats.large_send_bytes += tx_bytes;
  619. card->perf_stats.large_send_cnt++;
  620. }
  621. if (skb_shinfo(new_skb)->nr_frags > 0) {
  622. card->perf_stats.sg_skbs_sent++;
  623. /* nr_frags + skb->data */
  624. card->perf_stats.sg_frags_sent +=
  625. skb_shinfo(new_skb)->nr_frags + 1;
  626. }
  627. }
  628. if (ctx != NULL) {
  629. qeth_eddp_put_context(ctx);
  630. dev_kfree_skb_any(new_skb);
  631. }
  632. } else {
  633. if (ctx != NULL)
  634. qeth_eddp_put_context(ctx);
  635. if (rc == -EBUSY) {
  636. if (new_skb != skb)
  637. dev_kfree_skb_any(new_skb);
  638. return NETDEV_TX_BUSY;
  639. } else
  640. goto tx_drop;
  641. }
  642. netif_wake_queue(dev);
  643. if (card->options.performance_stats)
  644. card->perf_stats.outbound_time += qeth_get_micros() -
  645. card->perf_stats.outbound_start_time;
  646. return rc;
  647. tx_drop:
  648. card->stats.tx_dropped++;
  649. card->stats.tx_errors++;
  650. if ((new_skb != skb) && new_skb)
  651. dev_kfree_skb_any(new_skb);
  652. dev_kfree_skb_any(skb);
  653. return NETDEV_TX_OK;
  654. }
  655. static void qeth_l2_qdio_input_handler(struct ccw_device *ccwdev,
  656. unsigned int status, unsigned int qdio_err,
  657. unsigned int siga_err, unsigned int queue,
  658. int first_element, int count, unsigned long card_ptr)
  659. {
  660. struct net_device *net_dev;
  661. struct qeth_card *card;
  662. struct qeth_qdio_buffer *buffer;
  663. int index;
  664. int i;
  665. card = (struct qeth_card *) card_ptr;
  666. net_dev = card->dev;
  667. if (card->options.performance_stats) {
  668. card->perf_stats.inbound_cnt++;
  669. card->perf_stats.inbound_start_time = qeth_get_micros();
  670. }
  671. if (status & QDIO_STATUS_LOOK_FOR_ERROR) {
  672. if (status & QDIO_STATUS_ACTIVATE_CHECK_CONDITION) {
  673. QETH_DBF_TEXT(TRACE, 1, "qdinchk");
  674. QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card));
  675. QETH_DBF_TEXT_(TRACE, 1, "%04X%04X", first_element,
  676. count);
  677. QETH_DBF_TEXT_(TRACE, 1, "%04X%04X", queue, status);
  678. qeth_schedule_recovery(card);
  679. return;
  680. }
  681. }
  682. for (i = first_element; i < (first_element + count); ++i) {
  683. index = i % QDIO_MAX_BUFFERS_PER_Q;
  684. buffer = &card->qdio.in_q->bufs[index];
  685. if (!((status & QDIO_STATUS_LOOK_FOR_ERROR) &&
  686. qeth_check_qdio_errors(buffer->buffer,
  687. qdio_err, siga_err, "qinerr")))
  688. qeth_l2_process_inbound_buffer(card, buffer, index);
  689. /* clear buffer and give back to hardware */
  690. qeth_put_buffer_pool_entry(card, buffer->pool_entry);
  691. qeth_queue_input_buffer(card, index);
  692. }
  693. if (card->options.performance_stats)
  694. card->perf_stats.inbound_time += qeth_get_micros() -
  695. card->perf_stats.inbound_start_time;
  696. }
  697. static int qeth_l2_open(struct net_device *dev)
  698. {
  699. struct qeth_card *card = netdev_priv(dev);
  700. QETH_DBF_TEXT(TRACE, 4, "qethopen");
  701. if (card->state != CARD_STATE_SOFTSETUP)
  702. return -ENODEV;
  703. if ((card->info.type != QETH_CARD_TYPE_OSN) &&
  704. (!(card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))) {
  705. QETH_DBF_TEXT(TRACE, 4, "nomacadr");
  706. return -EPERM;
  707. }
  708. card->data.state = CH_STATE_UP;
  709. card->state = CARD_STATE_UP;
  710. card->dev->flags |= IFF_UP;
  711. netif_start_queue(dev);
  712. if (!card->lan_online && netif_carrier_ok(dev))
  713. netif_carrier_off(dev);
  714. return 0;
  715. }
  716. static int qeth_l2_stop(struct net_device *dev)
  717. {
  718. struct qeth_card *card = netdev_priv(dev);
  719. QETH_DBF_TEXT(TRACE, 4, "qethstop");
  720. netif_tx_disable(dev);
  721. card->dev->flags &= ~IFF_UP;
  722. if (card->state == CARD_STATE_UP)
  723. card->state = CARD_STATE_SOFTSETUP;
  724. return 0;
  725. }
  726. static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
  727. {
  728. struct qeth_card *card = dev_get_drvdata(&gdev->dev);
  729. INIT_LIST_HEAD(&card->vid_list);
  730. INIT_LIST_HEAD(&card->mc_list);
  731. card->options.layer2 = 1;
  732. card->discipline.input_handler = (qdio_handler_t *)
  733. qeth_l2_qdio_input_handler;
  734. card->discipline.output_handler = (qdio_handler_t *)
  735. qeth_qdio_output_handler;
  736. card->discipline.recover = qeth_l2_recover;
  737. return 0;
  738. }
  739. static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
  740. {
  741. struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
  742. wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
  743. if (cgdev->state == CCWGROUP_ONLINE) {
  744. card->use_hard_stop = 1;
  745. qeth_l2_set_offline(cgdev);
  746. }
  747. if (card->dev) {
  748. unregister_netdev(card->dev);
  749. card->dev = NULL;
  750. }
  751. qeth_l2_del_all_mc(card);
  752. return;
  753. }
  754. static int qeth_l2_ethtool_set_tso(struct net_device *dev, u32 data)
  755. {
  756. struct qeth_card *card = netdev_priv(dev);
  757. if (data) {
  758. if (card->options.large_send == QETH_LARGE_SEND_NO) {
  759. card->options.large_send = QETH_LARGE_SEND_EDDP;
  760. dev->features |= NETIF_F_TSO;
  761. }
  762. } else {
  763. dev->features &= ~NETIF_F_TSO;
  764. card->options.large_send = QETH_LARGE_SEND_NO;
  765. }
  766. return 0;
  767. }
  768. static struct ethtool_ops qeth_l2_ethtool_ops = {
  769. .get_link = ethtool_op_get_link,
  770. .get_tx_csum = ethtool_op_get_tx_csum,
  771. .set_tx_csum = ethtool_op_set_tx_hw_csum,
  772. .get_sg = ethtool_op_get_sg,
  773. .set_sg = ethtool_op_set_sg,
  774. .get_tso = ethtool_op_get_tso,
  775. .set_tso = qeth_l2_ethtool_set_tso,
  776. .get_strings = qeth_core_get_strings,
  777. .get_ethtool_stats = qeth_core_get_ethtool_stats,
  778. .get_stats_count = qeth_core_get_stats_count,
  779. .get_drvinfo = qeth_core_get_drvinfo,
  780. .get_settings = qeth_core_ethtool_get_settings,
  781. };
  782. static struct ethtool_ops qeth_l2_osn_ops = {
  783. .get_strings = qeth_core_get_strings,
  784. .get_ethtool_stats = qeth_core_get_ethtool_stats,
  785. .get_stats_count = qeth_core_get_stats_count,
  786. .get_drvinfo = qeth_core_get_drvinfo,
  787. };
  788. static int qeth_l2_setup_netdev(struct qeth_card *card)
  789. {
  790. switch (card->info.type) {
  791. case QETH_CARD_TYPE_OSAE:
  792. card->dev = alloc_etherdev(0);
  793. break;
  794. case QETH_CARD_TYPE_IQD:
  795. card->dev = alloc_netdev(0, "hsi%d", ether_setup);
  796. break;
  797. case QETH_CARD_TYPE_OSN:
  798. card->dev = alloc_netdev(0, "osn%d", ether_setup);
  799. card->dev->flags |= IFF_NOARP;
  800. break;
  801. default:
  802. card->dev = alloc_etherdev(0);
  803. }
  804. if (!card->dev)
  805. return -ENODEV;
  806. card->dev->priv = card;
  807. card->dev->tx_timeout = &qeth_tx_timeout;
  808. card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
  809. card->dev->open = qeth_l2_open;
  810. card->dev->stop = qeth_l2_stop;
  811. card->dev->hard_start_xmit = qeth_l2_hard_start_xmit;
  812. card->dev->do_ioctl = qeth_l2_do_ioctl;
  813. card->dev->get_stats = qeth_get_stats;
  814. card->dev->change_mtu = qeth_change_mtu;
  815. card->dev->set_multicast_list = qeth_l2_set_multicast_list;
  816. card->dev->vlan_rx_kill_vid = qeth_l2_vlan_rx_kill_vid;
  817. card->dev->vlan_rx_add_vid = qeth_l2_vlan_rx_add_vid;
  818. card->dev->set_mac_address = qeth_l2_set_mac_address;
  819. card->dev->mtu = card->info.initial_mtu;
  820. if (card->info.type != QETH_CARD_TYPE_OSN)
  821. SET_ETHTOOL_OPS(card->dev, &qeth_l2_ethtool_ops);
  822. else
  823. SET_ETHTOOL_OPS(card->dev, &qeth_l2_osn_ops);
  824. card->dev->features |= NETIF_F_HW_VLAN_FILTER;
  825. card->info.broadcast_capable = 1;
  826. qeth_l2_request_initial_mac(card);
  827. SET_NETDEV_DEV(card->dev, &card->gdev->dev);
  828. return register_netdev(card->dev);
  829. }
  830. static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
  831. {
  832. struct qeth_card *card = dev_get_drvdata(&gdev->dev);
  833. int rc = 0;
  834. enum qeth_card_states recover_flag;
  835. BUG_ON(!card);
  836. QETH_DBF_TEXT(SETUP, 2, "setonlin");
  837. QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
  838. qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
  839. if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD)) {
  840. PRINT_WARN("set_online of card %s interrupted by user!\n",
  841. CARD_BUS_ID(card));
  842. return -ERESTARTSYS;
  843. }
  844. recover_flag = card->state;
  845. rc = ccw_device_set_online(CARD_RDEV(card));
  846. if (rc) {
  847. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  848. return -EIO;
  849. }
  850. rc = ccw_device_set_online(CARD_WDEV(card));
  851. if (rc) {
  852. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  853. return -EIO;
  854. }
  855. rc = ccw_device_set_online(CARD_DDEV(card));
  856. if (rc) {
  857. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  858. return -EIO;
  859. }
  860. rc = qeth_core_hardsetup_card(card);
  861. if (rc) {
  862. QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
  863. goto out_remove;
  864. }
  865. if (!card->dev && qeth_l2_setup_netdev(card))
  866. goto out_remove;
  867. if (card->info.type != QETH_CARD_TYPE_OSN)
  868. qeth_l2_send_setmac(card, &card->dev->dev_addr[0]);
  869. card->state = CARD_STATE_HARDSETUP;
  870. qeth_print_status_message(card);
  871. /* softsetup */
  872. QETH_DBF_TEXT(SETUP, 2, "softsetp");
  873. rc = qeth_send_startlan(card);
  874. if (rc) {
  875. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  876. if (rc == 0xe080) {
  877. PRINT_WARN("LAN on card %s if offline! "
  878. "Waiting for STARTLAN from card.\n",
  879. CARD_BUS_ID(card));
  880. card->lan_online = 0;
  881. }
  882. return rc;
  883. } else
  884. card->lan_online = 1;
  885. if (card->info.type != QETH_CARD_TYPE_OSN) {
  886. qeth_set_large_send(card, card->options.large_send);
  887. qeth_l2_process_vlans(card, 0);
  888. }
  889. netif_tx_disable(card->dev);
  890. rc = qeth_init_qdio_queues(card);
  891. if (rc) {
  892. QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
  893. goto out_remove;
  894. }
  895. card->state = CARD_STATE_SOFTSETUP;
  896. netif_carrier_on(card->dev);
  897. qeth_set_allowed_threads(card, 0xffffffff, 0);
  898. if (recover_flag == CARD_STATE_RECOVER) {
  899. if (recovery_mode &&
  900. card->info.type != QETH_CARD_TYPE_OSN) {
  901. qeth_l2_open(card->dev);
  902. } else {
  903. rtnl_lock();
  904. dev_open(card->dev);
  905. rtnl_unlock();
  906. }
  907. /* this also sets saved unicast addresses */
  908. qeth_l2_set_multicast_list(card->dev);
  909. }
  910. /* let user_space know that device is online */
  911. kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
  912. return 0;
  913. out_remove:
  914. card->use_hard_stop = 1;
  915. qeth_l2_stop_card(card, 0);
  916. ccw_device_set_offline(CARD_DDEV(card));
  917. ccw_device_set_offline(CARD_WDEV(card));
  918. ccw_device_set_offline(CARD_RDEV(card));
  919. if (recover_flag == CARD_STATE_RECOVER)
  920. card->state = CARD_STATE_RECOVER;
  921. else
  922. card->state = CARD_STATE_DOWN;
  923. return -ENODEV;
  924. }
  925. static int qeth_l2_set_online(struct ccwgroup_device *gdev)
  926. {
  927. return __qeth_l2_set_online(gdev, 0);
  928. }
  929. static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
  930. int recovery_mode)
  931. {
  932. struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
  933. int rc = 0, rc2 = 0, rc3 = 0;
  934. enum qeth_card_states recover_flag;
  935. QETH_DBF_TEXT(SETUP, 3, "setoffl");
  936. QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
  937. if (card->dev && netif_carrier_ok(card->dev))
  938. netif_carrier_off(card->dev);
  939. recover_flag = card->state;
  940. if (qeth_l2_stop_card(card, recovery_mode) == -ERESTARTSYS) {
  941. PRINT_WARN("Stopping card %s interrupted by user!\n",
  942. CARD_BUS_ID(card));
  943. return -ERESTARTSYS;
  944. }
  945. rc = ccw_device_set_offline(CARD_DDEV(card));
  946. rc2 = ccw_device_set_offline(CARD_WDEV(card));
  947. rc3 = ccw_device_set_offline(CARD_RDEV(card));
  948. if (!rc)
  949. rc = (rc2) ? rc2 : rc3;
  950. if (rc)
  951. QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
  952. if (recover_flag == CARD_STATE_UP)
  953. card->state = CARD_STATE_RECOVER;
  954. /* let user_space know that device is offline */
  955. kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
  956. return 0;
  957. }
  958. static int qeth_l2_set_offline(struct ccwgroup_device *cgdev)
  959. {
  960. return __qeth_l2_set_offline(cgdev, 0);
  961. }
  962. static int qeth_l2_recover(void *ptr)
  963. {
  964. struct qeth_card *card;
  965. int rc = 0;
  966. card = (struct qeth_card *) ptr;
  967. QETH_DBF_TEXT(TRACE, 2, "recover1");
  968. QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
  969. if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
  970. return 0;
  971. QETH_DBF_TEXT(TRACE, 2, "recover2");
  972. PRINT_WARN("Recovery of device %s started ...\n",
  973. CARD_BUS_ID(card));
  974. card->use_hard_stop = 1;
  975. __qeth_l2_set_offline(card->gdev, 1);
  976. rc = __qeth_l2_set_online(card->gdev, 1);
  977. /* don't run another scheduled recovery */
  978. qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
  979. qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
  980. if (!rc)
  981. PRINT_INFO("Device %s successfully recovered!\n",
  982. CARD_BUS_ID(card));
  983. else
  984. PRINT_INFO("Device %s could not be recovered!\n",
  985. CARD_BUS_ID(card));
  986. return 0;
  987. }
  988. static int __init qeth_l2_init(void)
  989. {
  990. PRINT_INFO("register layer 2 discipline\n");
  991. return 0;
  992. }
  993. static void __exit qeth_l2_exit(void)
  994. {
  995. PRINT_INFO("unregister layer 2 discipline\n");
  996. }
  997. static void qeth_l2_shutdown(struct ccwgroup_device *gdev)
  998. {
  999. struct qeth_card *card = dev_get_drvdata(&gdev->dev);
  1000. qeth_qdio_clear_card(card, 0);
  1001. qeth_clear_qdio_buffers(card);
  1002. }
  1003. struct ccwgroup_driver qeth_l2_ccwgroup_driver = {
  1004. .probe = qeth_l2_probe_device,
  1005. .remove = qeth_l2_remove_device,
  1006. .set_online = qeth_l2_set_online,
  1007. .set_offline = qeth_l2_set_offline,
  1008. .shutdown = qeth_l2_shutdown,
  1009. };
  1010. EXPORT_SYMBOL_GPL(qeth_l2_ccwgroup_driver);
  1011. static int qeth_osn_send_control_data(struct qeth_card *card, int len,
  1012. struct qeth_cmd_buffer *iob)
  1013. {
  1014. unsigned long flags;
  1015. int rc = 0;
  1016. QETH_DBF_TEXT(TRACE, 5, "osndctrd");
  1017. wait_event(card->wait_q,
  1018. atomic_cmpxchg(&card->write.irq_pending, 0, 1) == 0);
  1019. qeth_prepare_control_data(card, len, iob);
  1020. QETH_DBF_TEXT(TRACE, 6, "osnoirqp");
  1021. spin_lock_irqsave(get_ccwdev_lock(card->write.ccwdev), flags);
  1022. rc = ccw_device_start(card->write.ccwdev, &card->write.ccw,
  1023. (addr_t) iob, 0, 0);
  1024. spin_unlock_irqrestore(get_ccwdev_lock(card->write.ccwdev), flags);
  1025. if (rc) {
  1026. PRINT_WARN("qeth_osn_send_control_data: "
  1027. "ccw_device_start rc = %i\n", rc);
  1028. QETH_DBF_TEXT_(TRACE, 2, " err%d", rc);
  1029. qeth_release_buffer(iob->channel, iob);
  1030. atomic_set(&card->write.irq_pending, 0);
  1031. wake_up(&card->wait_q);
  1032. }
  1033. return rc;
  1034. }
  1035. static int qeth_osn_send_ipa_cmd(struct qeth_card *card,
  1036. struct qeth_cmd_buffer *iob, int data_len)
  1037. {
  1038. u16 s1, s2;
  1039. QETH_DBF_TEXT(TRACE, 4, "osndipa");
  1040. qeth_prepare_ipa_cmd(card, iob, QETH_PROT_OSN2);
  1041. s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len);
  1042. s2 = (u16)data_len;
  1043. memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2);
  1044. memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2);
  1045. memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2);
  1046. memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2);
  1047. return qeth_osn_send_control_data(card, s1, iob);
  1048. }
  1049. int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
  1050. {
  1051. struct qeth_cmd_buffer *iob;
  1052. struct qeth_card *card;
  1053. int rc;
  1054. QETH_DBF_TEXT(TRACE, 2, "osnsdmc");
  1055. if (!dev)
  1056. return -ENODEV;
  1057. card = netdev_priv(dev);
  1058. if (!card)
  1059. return -ENODEV;
  1060. if ((card->state != CARD_STATE_UP) &&
  1061. (card->state != CARD_STATE_SOFTSETUP))
  1062. return -ENODEV;
  1063. iob = qeth_wait_for_buffer(&card->write);
  1064. memcpy(iob->data+IPA_PDU_HEADER_SIZE, data, data_len);
  1065. rc = qeth_osn_send_ipa_cmd(card, iob, data_len);
  1066. return rc;
  1067. }
  1068. EXPORT_SYMBOL(qeth_osn_assist);
  1069. int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
  1070. int (*assist_cb)(struct net_device *, void *),
  1071. int (*data_cb)(struct sk_buff *))
  1072. {
  1073. struct qeth_card *card;
  1074. QETH_DBF_TEXT(TRACE, 2, "osnreg");
  1075. *dev = qeth_l2_netdev_by_devno(read_dev_no);
  1076. if (*dev == NULL)
  1077. return -ENODEV;
  1078. card = netdev_priv(*dev);
  1079. if (!card)
  1080. return -ENODEV;
  1081. if ((assist_cb == NULL) || (data_cb == NULL))
  1082. return -EINVAL;
  1083. card->osn_info.assist_cb = assist_cb;
  1084. card->osn_info.data_cb = data_cb;
  1085. return 0;
  1086. }
  1087. EXPORT_SYMBOL(qeth_osn_register);
  1088. void qeth_osn_deregister(struct net_device *dev)
  1089. {
  1090. struct qeth_card *card;
  1091. QETH_DBF_TEXT(TRACE, 2, "osndereg");
  1092. if (!dev)
  1093. return;
  1094. card = netdev_priv(dev);
  1095. if (!card)
  1096. return;
  1097. card->osn_info.assist_cb = NULL;
  1098. card->osn_info.data_cb = NULL;
  1099. return;
  1100. }
  1101. EXPORT_SYMBOL(qeth_osn_deregister);
  1102. module_init(qeth_l2_init);
  1103. module_exit(qeth_l2_exit);
  1104. MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
  1105. MODULE_DESCRIPTION("qeth layer 2 discipline");
  1106. MODULE_LICENSE("GPL");